From 97b6b150a79c718be1d3cf163c9b6576a0822bad Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Fri, 23 Apr 2021 13:13:38 +0100 Subject: [PATCH 001/279] Fixed a couple of typos (#3715) --- test/datasets_utils.py | 2 +- torchvision/datasets/places365.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/datasets_utils.py b/test/datasets_utils.py index 60e3990f3a2..de772d1c7d0 100644 --- a/test/datasets_utils.py +++ b/test/datasets_utils.py @@ -44,7 +44,7 @@ class UsageError(Exception): class LazyImporter: - r"""Lazy importer for additional dependicies. + r"""Lazy importer for additional dependencies. Some datasets require additional packages that are no direct dependencies of torchvision. Instances of this class provide modules listed in MODULES as attributes. They are only imported when accessed. diff --git a/torchvision/datasets/places365.py b/torchvision/datasets/places365.py index 2ee9cdbe8c4..648e0d604ba 100644 --- a/torchvision/datasets/places365.py +++ b/torchvision/datasets/places365.py @@ -13,7 +13,7 @@ class Places365(VisionDataset): Args: root (string): Root directory of the Places365 dataset. - split (string, optional): The dataset split. Can be one of ``train-standard`` (default), ``train-challendge``, + split (string, optional): The dataset split. Can be one of ``train-standard`` (default), ``train-challenge``, ``val``. small (bool, optional): If ``True``, uses the small images, i. e. resized to 256 x 256 pixels, instead of the high resolution ones. From 4150ceae77a4a9fc35bfb5ba5ae5ab7157fb2310 Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Fri, 23 Apr 2021 17:43:30 +0200 Subject: [PATCH 002/279] fix check for exceeded quota on Google Drive (#3710) * fix check for exceeded quota on Google Drive * safeguard quota exceed check --- torchvision/datasets/utils.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/torchvision/datasets/utils.py b/torchvision/datasets/utils.py index 8da26d6e98e..0d1d879f045 100644 --- a/torchvision/datasets/utils.py +++ b/torchvision/datasets/utils.py @@ -175,9 +175,11 @@ def list_files(root: str, suffix: str, prefix: bool = False) -> List[str]: def _quota_exceeded(response: "requests.models.Response") -> bool: # type: ignore[name-defined] - return False - # See https://github.com/pytorch/vision/issues/2992 for details - # return "Google Drive - Quota exceeded" in response.text + try: + start = next(response.iter_content(chunk_size=128, decode_unicode=True)) + return isinstance(start, str) and "Google Drive - Quota exceeded" in start + except StopIteration: + return False def download_file_from_google_drive(file_id: str, root: str, filename: Optional[str] = None, md5: Optional[str] = None): From 4b0b332a14c2b516e2fb20574035df91970897c4 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Fri, 23 Apr 2021 18:11:17 +0100 Subject: [PATCH 003/279] Ported places365 dataset's tests to the new test framework (#3705) * Ported places365 dataset's tests to the new test framework * Made some attributes private * Removed unnecessary compute_md5() * Added test_images_download_preexisting() Co-authored-by: Philip Meier --- test/fakedata_generation.py | 100 ------------------- test/test_datasets.py | 192 +++++++++++++++++------------------- 2 files changed, 91 insertions(+), 201 deletions(-) diff --git a/test/fakedata_generation.py b/test/fakedata_generation.py index f7fc54d9346..28f4eaa46e8 100644 --- a/test/fakedata_generation.py +++ b/test/fakedata_generation.py @@ -208,103 +208,3 @@ def _make_annotations_archive(root): _make_annotations_archive(root_base) yield root - - -@contextlib.contextmanager -def places365_root(split="train-standard", small=False): - VARIANTS = { - "train-standard": "standard", - "train-challenge": "challenge", - "val": "standard", - } - # {split: file} - DEVKITS = { - "train-standard": "filelist_places365-standard.tar", - "train-challenge": "filelist_places365-challenge.tar", - "val": "filelist_places365-standard.tar", - } - CATEGORIES = "categories_places365.txt" - # {split: file} - FILE_LISTS = { - "train-standard": "places365_train_standard.txt", - "train-challenge": "places365_train_challenge.txt", - "val": "places365_train_standard.txt", - } - # {(split, small): (archive, folder_default, folder_renamed)} - IMAGES = { - ("train-standard", False): ("train_large_places365standard.tar", "data_large", "data_large_standard"), - ("train-challenge", False): ("train_large_places365challenge.tar", "data_large", "data_large_challenge"), - ("val", False): ("val_large.tar", "val_large", "val_large"), - ("train-standard", True): ("train_256_places365standard.tar", "data_256", "data_256_standard"), - ("train-challenge", True): ("train_256_places365challenge.tar", "data_256", "data_256_challenge"), - ("val", True): ("val_256.tar", "val_256", "val_256"), - } - - # (class, idx) - CATEGORIES_CONTENT = (("/a/airfield", 0), ("/a/apartment_building/outdoor", 8), ("/b/badlands", 30)) - # (file, idx) - FILE_LIST_CONTENT = ( - ("Places365_val_00000001.png", 0), - *((f"{category}/Places365_train_00000001.png", idx) for category, idx in CATEGORIES_CONTENT), - ) - - def mock_target(attr, partial="torchvision.datasets.places365.Places365"): - return f"{partial}.{attr}" - - def make_txt(root, name, seq): - file = os.path.join(root, name) - with open(file, "w") as fh: - for string, idx in seq: - fh.write(f"{string} {idx}\n") - return name, compute_md5(file) - - def make_categories_txt(root, name): - return make_txt(root, name, CATEGORIES_CONTENT) - - def make_file_list_txt(root, name): - return make_txt(root, name, FILE_LIST_CONTENT) - - def make_image(file, size): - os.makedirs(os.path.dirname(file), exist_ok=True) - PIL.Image.fromarray(np.zeros((*size, 3), dtype=np.uint8)).save(file) - - def make_devkit_archive(stack, root, split): - archive = DEVKITS[split] - files = [] - - meta = make_categories_txt(root, CATEGORIES) - mock_class_attribute(stack, mock_target("_CATEGORIES_META"), meta) - files.append(meta[0]) - - meta = {split: make_file_list_txt(root, FILE_LISTS[split])} - mock_class_attribute(stack, mock_target("_FILE_LIST_META"), meta) - files.extend([item[0] for item in meta.values()]) - - meta = {VARIANTS[split]: make_tar(root, archive, *files)} - mock_class_attribute(stack, mock_target("_DEVKIT_META"), meta) - - def make_images_archive(stack, root, split, small): - archive, folder_default, folder_renamed = IMAGES[(split, small)] - - image_size = (256, 256) if small else (512, random.randint(512, 1024)) - files, idcs = zip(*FILE_LIST_CONTENT) - images = [file.lstrip("/").replace("/", os.sep) for file in files] - for image in images: - make_image(os.path.join(root, folder_default, image), image_size) - - meta = {(split, small): make_tar(root, archive, folder_default)} - mock_class_attribute(stack, mock_target("_IMAGES_META"), meta) - - return [(os.path.join(root, folder_renamed, image), idx) for image, idx in zip(images, idcs)] - - with contextlib.ExitStack() as stack, get_tmp_dir() as root: - make_devkit_archive(stack, root, split) - class_to_idx = dict(CATEGORIES_CONTENT) - classes = list(class_to_idx.keys()) - - data = {"class_to_idx": class_to_idx, "classes": classes} - data["imgs"] = make_images_archive(stack, root, split, small) - - clean_dir(root, ".tar$") - - yield root, data diff --git a/test/test_datasets.py b/test/test_datasets.py index f28885d064d..fc81d82dcf0 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -9,7 +9,6 @@ import torchvision from torchvision.datasets import utils from common_utils import get_tmp_dir -from fakedata_generation import places365_root import xml.etree.ElementTree as ET from urllib.request import Request, urlopen import itertools @@ -41,106 +40,6 @@ HAS_PYAV = False -class DatasetTestcase(unittest.TestCase): - def generic_classification_dataset_test(self, dataset, num_images=1): - self.assertEqual(len(dataset), num_images) - img, target = dataset[0] - self.assertTrue(isinstance(img, PIL.Image.Image)) - self.assertTrue(isinstance(target, int)) - - def generic_segmentation_dataset_test(self, dataset, num_images=1): - self.assertEqual(len(dataset), num_images) - img, target = dataset[0] - self.assertTrue(isinstance(img, PIL.Image.Image)) - self.assertTrue(isinstance(target, PIL.Image.Image)) - - -class Tester(DatasetTestcase): - def test_places365(self): - for split, small in itertools.product(("train-standard", "train-challenge", "val"), (False, True)): - with places365_root(split=split, small=small) as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365(root, split=split, small=small, download=True) - self.generic_classification_dataset_test(dataset, num_images=len(data["imgs"])) - - def test_places365_transforms(self): - expected_image = "image" - expected_target = "target" - - def transform(image): - return expected_image - - def target_transform(target): - return expected_target - - with places365_root() as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365( - root, transform=transform, target_transform=target_transform, download=True - ) - actual_image, actual_target = dataset[0] - - self.assertEqual(actual_image, expected_image) - self.assertEqual(actual_target, expected_target) - - def test_places365_devkit_download(self): - for split in ("train-standard", "train-challenge", "val"): - with self.subTest(split=split): - with places365_root(split=split) as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365(root, split=split, download=True) - - with self.subTest("classes"): - self.assertSequenceEqual(dataset.classes, data["classes"]) - - with self.subTest("class_to_idx"): - self.assertDictEqual(dataset.class_to_idx, data["class_to_idx"]) - - with self.subTest("imgs"): - self.assertSequenceEqual(dataset.imgs, data["imgs"]) - - def test_places365_devkit_no_download(self): - for split in ("train-standard", "train-challenge", "val"): - with self.subTest(split=split): - with places365_root(split=split) as places365: - root, data = places365 - - with self.assertRaises(RuntimeError): - torchvision.datasets.Places365(root, split=split, download=False) - - def test_places365_images_download(self): - for split, small in itertools.product(("train-standard", "train-challenge", "val"), (False, True)): - with self.subTest(split=split, small=small): - with places365_root(split=split, small=small) as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365(root, split=split, small=small, download=True) - - assert all(os.path.exists(item[0]) for item in dataset.imgs) - - def test_places365_images_download_preexisting(self): - split = "train-standard" - small = False - images_dir = "data_large_standard" - - with places365_root(split=split, small=small) as places365: - root, data = places365 - os.mkdir(os.path.join(root, images_dir)) - - with self.assertRaises(RuntimeError): - torchvision.datasets.Places365(root, split=split, small=small, download=True) - - def test_places365_repr_smoke(self): - with places365_root() as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365(root, download=True) - self.assertIsInstance(repr(dataset), str) - - class STL10TestCase(datasets_utils.ImageDatasetTestCase): DATASET_CLASS = datasets.STL10 ADDITIONAL_CONFIGS = datasets_utils.combinations_grid( @@ -1763,5 +1662,96 @@ def inject_fake_data(self, tmpdir, config): return num_examples +class Places365TestCase(datasets_utils.ImageDatasetTestCase): + DATASET_CLASS = datasets.Places365 + ADDITIONAL_CONFIGS = datasets_utils.combinations_grid( + split=("train-standard", "train-challenge", "val"), + small=(False, True), + ) + _CATEGORIES = "categories_places365.txt" + # {split: file} + _FILE_LISTS = { + "train-standard": "places365_train_standard.txt", + "train-challenge": "places365_train_challenge.txt", + "val": "places365_val.txt", + } + # {(split, small): folder_name} + _IMAGES = { + ("train-standard", False): "data_large_standard", + ("train-challenge", False): "data_large_challenge", + ("val", False): "val_large", + ("train-standard", True): "data_256_standard", + ("train-challenge", True): "data_256_challenge", + ("val", True): "val_256", + } + # (class, idx) + _CATEGORIES_CONTENT = ( + ("/a/airfield", 0), + ("/a/apartment_building/outdoor", 8), + ("/b/badlands", 30), + ) + # (file, idx) + _FILE_LIST_CONTENT = ( + ("Places365_val_00000001.png", 0), + *((f"{category}/Places365_train_00000001.png", idx) + for category, idx in _CATEGORIES_CONTENT), + ) + + @staticmethod + def _make_txt(root, name, seq): + file = os.path.join(root, name) + with open(file, "w") as fh: + for text, idx in seq: + fh.write(f"{text} {idx}\n") + + @staticmethod + def _make_categories_txt(root, name): + Places365TestCase._make_txt(root, name, Places365TestCase._CATEGORIES_CONTENT) + + @staticmethod + def _make_file_list_txt(root, name): + Places365TestCase._make_txt(root, name, Places365TestCase._FILE_LIST_CONTENT) + + @staticmethod + def _make_image(file_name, size): + os.makedirs(os.path.dirname(file_name), exist_ok=True) + PIL.Image.fromarray(np.zeros((*size, 3), dtype=np.uint8)).save(file_name) + + @staticmethod + def _make_devkit_archive(root, split): + Places365TestCase._make_categories_txt(root, Places365TestCase._CATEGORIES) + Places365TestCase._make_file_list_txt(root, Places365TestCase._FILE_LISTS[split]) + + @staticmethod + def _make_images_archive(root, split, small): + folder_name = Places365TestCase._IMAGES[(split, small)] + image_size = (256, 256) if small else (512, random.randint(512, 1024)) + files, idcs = zip(*Places365TestCase._FILE_LIST_CONTENT) + images = [f.lstrip("/").replace("/", os.sep) for f in files] + for image in images: + Places365TestCase._make_image(os.path.join(root, folder_name, image), image_size) + + return [(os.path.join(root, folder_name, image), idx) for image, idx in zip(images, idcs)] + + def inject_fake_data(self, tmpdir, config): + self._make_devkit_archive(tmpdir, config['split']) + return len(self._make_images_archive(tmpdir, config['split'], config['small'])) + + def test_classes(self): + classes = list(map(lambda x: x[0], self._CATEGORIES_CONTENT)) + with self.create_dataset() as (dataset, _): + self.assertEqual(dataset.classes, classes) + + def test_class_to_idx(self): + class_to_idx = dict(self._CATEGORIES_CONTENT) + with self.create_dataset() as (dataset, _): + self.assertEqual(dataset.class_to_idx, class_to_idx) + + def test_images_download_preexisting(self): + with self.assertRaises(RuntimeError): + with self.create_dataset({'download': True}): + pass + + if __name__ == "__main__": unittest.main() From 10f8ddb4f429af2b65e278b87e06bd1074959234 Mon Sep 17 00:00:00 2001 From: Jon Janzen Date: Fri, 23 Apr 2021 10:56:00 -0700 Subject: [PATCH 004/279] Delete show_link_to_built_docs.yml This is triggering crazy amounts of API calls for internal tools. I'm reverting this to stop the problem. --- .github/workflows/show_link_to_built_docs.yml | 16 ---------------- 1 file changed, 16 deletions(-) delete mode 100644 .github/workflows/show_link_to_built_docs.yml diff --git a/.github/workflows/show_link_to_built_docs.yml b/.github/workflows/show_link_to_built_docs.yml deleted file mode 100644 index a89c5d2b631..00000000000 --- a/.github/workflows/show_link_to_built_docs.yml +++ /dev/null @@ -1,16 +0,0 @@ -name: See built docs here! - -on: - status - -jobs: - circleci_artifacts_redirector_job: - runs-on: ubuntu-latest - name: Run CircleCI artifacts redirector - steps: - - name: GitHub Action step - uses: larsoner/circleci-artifacts-redirector-action@master - with: - repo-token: ${{ secrets.GITHUB_TOKEN }} - artifact-path: 0/docs/index.html - circleci-jobs: build_docs From 7be02cbc0bca55b510641c2aef184eb24c98bdb1 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 23 Apr 2021 18:44:59 +0000 Subject: [PATCH 005/279] Remove leftover exception (#3717) --- test/test_models.py | 1 - 1 file changed, 1 deletion(-) diff --git a/test/test_models.py b/test/test_models.py index afbd7feee38..395fd92178c 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -195,7 +195,6 @@ def compute_mean_std(tensor): # only the best way to assert results but also handles the cases # where we need to create a new expected result. self.assertExpected(output, name, prec=prec) - raise AssertionError except AssertionError: # Unfortunately detection models are flaky due to the unstable sort # in NMS. If matching across all outputs fails, use the same approach From d4195587166134c3806ae81458d08b06f5e00295 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 23 Apr 2021 19:07:55 +0000 Subject: [PATCH 006/279] Revert "Ported places365 dataset's tests to the new test framework (#3705)" (#3718) This reverts commit 4b0b332a14c2b516e2fb20574035df91970897c4. --- test/fakedata_generation.py | 100 +++++++++++++++++++ test/test_datasets.py | 192 +++++++++++++++++++----------------- 2 files changed, 201 insertions(+), 91 deletions(-) diff --git a/test/fakedata_generation.py b/test/fakedata_generation.py index 28f4eaa46e8..f7fc54d9346 100644 --- a/test/fakedata_generation.py +++ b/test/fakedata_generation.py @@ -208,3 +208,103 @@ def _make_annotations_archive(root): _make_annotations_archive(root_base) yield root + + +@contextlib.contextmanager +def places365_root(split="train-standard", small=False): + VARIANTS = { + "train-standard": "standard", + "train-challenge": "challenge", + "val": "standard", + } + # {split: file} + DEVKITS = { + "train-standard": "filelist_places365-standard.tar", + "train-challenge": "filelist_places365-challenge.tar", + "val": "filelist_places365-standard.tar", + } + CATEGORIES = "categories_places365.txt" + # {split: file} + FILE_LISTS = { + "train-standard": "places365_train_standard.txt", + "train-challenge": "places365_train_challenge.txt", + "val": "places365_train_standard.txt", + } + # {(split, small): (archive, folder_default, folder_renamed)} + IMAGES = { + ("train-standard", False): ("train_large_places365standard.tar", "data_large", "data_large_standard"), + ("train-challenge", False): ("train_large_places365challenge.tar", "data_large", "data_large_challenge"), + ("val", False): ("val_large.tar", "val_large", "val_large"), + ("train-standard", True): ("train_256_places365standard.tar", "data_256", "data_256_standard"), + ("train-challenge", True): ("train_256_places365challenge.tar", "data_256", "data_256_challenge"), + ("val", True): ("val_256.tar", "val_256", "val_256"), + } + + # (class, idx) + CATEGORIES_CONTENT = (("/a/airfield", 0), ("/a/apartment_building/outdoor", 8), ("/b/badlands", 30)) + # (file, idx) + FILE_LIST_CONTENT = ( + ("Places365_val_00000001.png", 0), + *((f"{category}/Places365_train_00000001.png", idx) for category, idx in CATEGORIES_CONTENT), + ) + + def mock_target(attr, partial="torchvision.datasets.places365.Places365"): + return f"{partial}.{attr}" + + def make_txt(root, name, seq): + file = os.path.join(root, name) + with open(file, "w") as fh: + for string, idx in seq: + fh.write(f"{string} {idx}\n") + return name, compute_md5(file) + + def make_categories_txt(root, name): + return make_txt(root, name, CATEGORIES_CONTENT) + + def make_file_list_txt(root, name): + return make_txt(root, name, FILE_LIST_CONTENT) + + def make_image(file, size): + os.makedirs(os.path.dirname(file), exist_ok=True) + PIL.Image.fromarray(np.zeros((*size, 3), dtype=np.uint8)).save(file) + + def make_devkit_archive(stack, root, split): + archive = DEVKITS[split] + files = [] + + meta = make_categories_txt(root, CATEGORIES) + mock_class_attribute(stack, mock_target("_CATEGORIES_META"), meta) + files.append(meta[0]) + + meta = {split: make_file_list_txt(root, FILE_LISTS[split])} + mock_class_attribute(stack, mock_target("_FILE_LIST_META"), meta) + files.extend([item[0] for item in meta.values()]) + + meta = {VARIANTS[split]: make_tar(root, archive, *files)} + mock_class_attribute(stack, mock_target("_DEVKIT_META"), meta) + + def make_images_archive(stack, root, split, small): + archive, folder_default, folder_renamed = IMAGES[(split, small)] + + image_size = (256, 256) if small else (512, random.randint(512, 1024)) + files, idcs = zip(*FILE_LIST_CONTENT) + images = [file.lstrip("/").replace("/", os.sep) for file in files] + for image in images: + make_image(os.path.join(root, folder_default, image), image_size) + + meta = {(split, small): make_tar(root, archive, folder_default)} + mock_class_attribute(stack, mock_target("_IMAGES_META"), meta) + + return [(os.path.join(root, folder_renamed, image), idx) for image, idx in zip(images, idcs)] + + with contextlib.ExitStack() as stack, get_tmp_dir() as root: + make_devkit_archive(stack, root, split) + class_to_idx = dict(CATEGORIES_CONTENT) + classes = list(class_to_idx.keys()) + + data = {"class_to_idx": class_to_idx, "classes": classes} + data["imgs"] = make_images_archive(stack, root, split, small) + + clean_dir(root, ".tar$") + + yield root, data diff --git a/test/test_datasets.py b/test/test_datasets.py index fc81d82dcf0..f28885d064d 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -9,6 +9,7 @@ import torchvision from torchvision.datasets import utils from common_utils import get_tmp_dir +from fakedata_generation import places365_root import xml.etree.ElementTree as ET from urllib.request import Request, urlopen import itertools @@ -40,6 +41,106 @@ HAS_PYAV = False +class DatasetTestcase(unittest.TestCase): + def generic_classification_dataset_test(self, dataset, num_images=1): + self.assertEqual(len(dataset), num_images) + img, target = dataset[0] + self.assertTrue(isinstance(img, PIL.Image.Image)) + self.assertTrue(isinstance(target, int)) + + def generic_segmentation_dataset_test(self, dataset, num_images=1): + self.assertEqual(len(dataset), num_images) + img, target = dataset[0] + self.assertTrue(isinstance(img, PIL.Image.Image)) + self.assertTrue(isinstance(target, PIL.Image.Image)) + + +class Tester(DatasetTestcase): + def test_places365(self): + for split, small in itertools.product(("train-standard", "train-challenge", "val"), (False, True)): + with places365_root(split=split, small=small) as places365: + root, data = places365 + + dataset = torchvision.datasets.Places365(root, split=split, small=small, download=True) + self.generic_classification_dataset_test(dataset, num_images=len(data["imgs"])) + + def test_places365_transforms(self): + expected_image = "image" + expected_target = "target" + + def transform(image): + return expected_image + + def target_transform(target): + return expected_target + + with places365_root() as places365: + root, data = places365 + + dataset = torchvision.datasets.Places365( + root, transform=transform, target_transform=target_transform, download=True + ) + actual_image, actual_target = dataset[0] + + self.assertEqual(actual_image, expected_image) + self.assertEqual(actual_target, expected_target) + + def test_places365_devkit_download(self): + for split in ("train-standard", "train-challenge", "val"): + with self.subTest(split=split): + with places365_root(split=split) as places365: + root, data = places365 + + dataset = torchvision.datasets.Places365(root, split=split, download=True) + + with self.subTest("classes"): + self.assertSequenceEqual(dataset.classes, data["classes"]) + + with self.subTest("class_to_idx"): + self.assertDictEqual(dataset.class_to_idx, data["class_to_idx"]) + + with self.subTest("imgs"): + self.assertSequenceEqual(dataset.imgs, data["imgs"]) + + def test_places365_devkit_no_download(self): + for split in ("train-standard", "train-challenge", "val"): + with self.subTest(split=split): + with places365_root(split=split) as places365: + root, data = places365 + + with self.assertRaises(RuntimeError): + torchvision.datasets.Places365(root, split=split, download=False) + + def test_places365_images_download(self): + for split, small in itertools.product(("train-standard", "train-challenge", "val"), (False, True)): + with self.subTest(split=split, small=small): + with places365_root(split=split, small=small) as places365: + root, data = places365 + + dataset = torchvision.datasets.Places365(root, split=split, small=small, download=True) + + assert all(os.path.exists(item[0]) for item in dataset.imgs) + + def test_places365_images_download_preexisting(self): + split = "train-standard" + small = False + images_dir = "data_large_standard" + + with places365_root(split=split, small=small) as places365: + root, data = places365 + os.mkdir(os.path.join(root, images_dir)) + + with self.assertRaises(RuntimeError): + torchvision.datasets.Places365(root, split=split, small=small, download=True) + + def test_places365_repr_smoke(self): + with places365_root() as places365: + root, data = places365 + + dataset = torchvision.datasets.Places365(root, download=True) + self.assertIsInstance(repr(dataset), str) + + class STL10TestCase(datasets_utils.ImageDatasetTestCase): DATASET_CLASS = datasets.STL10 ADDITIONAL_CONFIGS = datasets_utils.combinations_grid( @@ -1662,96 +1763,5 @@ def inject_fake_data(self, tmpdir, config): return num_examples -class Places365TestCase(datasets_utils.ImageDatasetTestCase): - DATASET_CLASS = datasets.Places365 - ADDITIONAL_CONFIGS = datasets_utils.combinations_grid( - split=("train-standard", "train-challenge", "val"), - small=(False, True), - ) - _CATEGORIES = "categories_places365.txt" - # {split: file} - _FILE_LISTS = { - "train-standard": "places365_train_standard.txt", - "train-challenge": "places365_train_challenge.txt", - "val": "places365_val.txt", - } - # {(split, small): folder_name} - _IMAGES = { - ("train-standard", False): "data_large_standard", - ("train-challenge", False): "data_large_challenge", - ("val", False): "val_large", - ("train-standard", True): "data_256_standard", - ("train-challenge", True): "data_256_challenge", - ("val", True): "val_256", - } - # (class, idx) - _CATEGORIES_CONTENT = ( - ("/a/airfield", 0), - ("/a/apartment_building/outdoor", 8), - ("/b/badlands", 30), - ) - # (file, idx) - _FILE_LIST_CONTENT = ( - ("Places365_val_00000001.png", 0), - *((f"{category}/Places365_train_00000001.png", idx) - for category, idx in _CATEGORIES_CONTENT), - ) - - @staticmethod - def _make_txt(root, name, seq): - file = os.path.join(root, name) - with open(file, "w") as fh: - for text, idx in seq: - fh.write(f"{text} {idx}\n") - - @staticmethod - def _make_categories_txt(root, name): - Places365TestCase._make_txt(root, name, Places365TestCase._CATEGORIES_CONTENT) - - @staticmethod - def _make_file_list_txt(root, name): - Places365TestCase._make_txt(root, name, Places365TestCase._FILE_LIST_CONTENT) - - @staticmethod - def _make_image(file_name, size): - os.makedirs(os.path.dirname(file_name), exist_ok=True) - PIL.Image.fromarray(np.zeros((*size, 3), dtype=np.uint8)).save(file_name) - - @staticmethod - def _make_devkit_archive(root, split): - Places365TestCase._make_categories_txt(root, Places365TestCase._CATEGORIES) - Places365TestCase._make_file_list_txt(root, Places365TestCase._FILE_LISTS[split]) - - @staticmethod - def _make_images_archive(root, split, small): - folder_name = Places365TestCase._IMAGES[(split, small)] - image_size = (256, 256) if small else (512, random.randint(512, 1024)) - files, idcs = zip(*Places365TestCase._FILE_LIST_CONTENT) - images = [f.lstrip("/").replace("/", os.sep) for f in files] - for image in images: - Places365TestCase._make_image(os.path.join(root, folder_name, image), image_size) - - return [(os.path.join(root, folder_name, image), idx) for image, idx in zip(images, idcs)] - - def inject_fake_data(self, tmpdir, config): - self._make_devkit_archive(tmpdir, config['split']) - return len(self._make_images_archive(tmpdir, config['split'], config['small'])) - - def test_classes(self): - classes = list(map(lambda x: x[0], self._CATEGORIES_CONTENT)) - with self.create_dataset() as (dataset, _): - self.assertEqual(dataset.classes, classes) - - def test_class_to_idx(self): - class_to_idx = dict(self._CATEGORIES_CONTENT) - with self.create_dataset() as (dataset, _): - self.assertEqual(dataset.class_to_idx, class_to_idx) - - def test_images_download_preexisting(self): - with self.assertRaises(RuntimeError): - with self.create_dataset({'download': True}): - pass - - if __name__ == "__main__": unittest.main() From 08fa7d6be3595838361aeb2adc1cd51f66fbb0e0 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 26 Apr 2021 09:47:07 +0100 Subject: [PATCH 007/279] Use sphinx-galery 0.9 and simplify conf.py (#3724) --- docs/requirements.txt | 2 +- docs/source/conf.py | 9 --------- 2 files changed, 1 insertion(+), 10 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 6fda04707ea..778c2880bb8 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,5 +1,5 @@ sphinx==2.4.4 -sphinx-gallery +sphinx-gallery>=0.9.0 matplotlib numpy -e git+git://github.com/pytorch/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme diff --git a/docs/source/conf.py b/docs/source/conf.py index b0079a00668..639c877fc9f 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -281,15 +281,6 @@ def inject_minigalleries(app, what, name, obj, options, lines): https://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html """ - conf_file_path = Path(__file__).parent.absolute() - backrefs_path = conf_file_path / sphinx_gallery_conf['backreferences_dir'] / (name + '.examples') - if not (os.path.isfile(backrefs_path) and os.path.getsize(backrefs_path) > 0): - # We avoid showing the (empty) minigallery if there's nothing to show, i.e. if the object - # isn't used in any example. - # FIXME: this check can be removed once https://github.com/sphinx-gallery/sphinx-gallery/pull/813 - # is merged and the new sphinx-gallery version (> 0.8.x) is released. - return - if what in ("class", "function"): lines.append(f".. minigallery:: {name}") lines.append(f" :add-heading: Examples using ``{name.split('.')[-1]}``:") From 283c790776d4e950662dade8e21433e86047e452 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 26 Apr 2021 10:06:07 +0100 Subject: [PATCH 008/279] Fix accept mechanism in tests (#3721) --- test/common_utils.py | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index beb6ba2d81a..6c987cf9348 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -47,17 +47,6 @@ def set_rng_seed(seed): TEST_WITH_SLOW = os.getenv('PYTORCH_TEST_WITH_SLOW', '0') == '1' -parser = argparse.ArgumentParser(add_help=False) -parser.add_argument('--accept', action='store_true') -args, remaining = parser.parse_known_args() -if not ACCEPT: - ACCEPT = args.accept -for i, arg in enumerate(sys.argv): - if arg == '--accept': - del sys.argv[i] - break - - class MapNestedTensorObjectImpl(object): def __init__(self, tensor_map_fn): self.tensor_map_fn = tensor_map_fn @@ -119,8 +108,9 @@ def _get_expected_file(self, name=None): if not ACCEPT and not os.path.exists(expected_file): raise RuntimeError( f"No expect file exists for {os.path.basename(expected_file)} in {expected_file}; " - "to accept the current output, run:\n" - f"python {__main__.__file__} {munged_id} --accept") + "to accept the current output, re-run the failing test after setting the EXPECTTEST_ACCEPT " + "env variable. For example: EXPECTTEST_ACCEPT=1 pytest test/test_models.py -k alexnet" + ) return expected_file From 03f94a698578031278f9c3c588a1dcd82b80d7b8 Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Mon, 26 Apr 2021 12:09:02 +0200 Subject: [PATCH 009/279] Remove fakeroot dependency of Places365 in download tests (#3730) --- test/test_datasets_download.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/test/test_datasets_download.py b/test/test_datasets_download.py index 6ff3a33bcc9..6064163ae38 100644 --- a/test/test_datasets_download.py +++ b/test/test_datasets_download.py @@ -23,7 +23,6 @@ ) from common_utils import get_tmp_dir -from fakedata_generation import places365_root def limit_requests_per_time(min_secs_between_requests=2.0): @@ -221,14 +220,16 @@ def root(): def places365(): - with log_download_attempts(patch=False) as urls_and_md5s: - for split, small in itertools.product(("train-standard", "train-challenge", "val"), (False, True)): - with places365_root(split=split, small=small) as places365: - root, data = places365 - - datasets.Places365(root, split=split, small=small, download=True) - - return make_download_configs(urls_and_md5s, name="Places365") + return itertools.chain( + *[ + collect_download_configs( + lambda: datasets.Places365(ROOT, split=split, small=small, download=True), + name=f"Places365, {split}, {'small' if small else 'large'}", + file="places365", + ) + for split, small in itertools.product(("train-standard", "train-challenge", "val"), (False, True)) + ] + ) def caltech101(): From ae63bd08a3c6d8e5a468c13ece2ec04e6745dcdf Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Mon, 26 Apr 2021 12:06:56 +0100 Subject: [PATCH 010/279] Revert "Revert "Ported places365 dataset's tests to the new test framework (#3705)" (#3718)" (#3731) This reverts commit d4195587166134c3806ae81458d08b06f5e00295. --- test/fakedata_generation.py | 100 ------------------- test/test_datasets.py | 192 +++++++++++++++++------------------- 2 files changed, 91 insertions(+), 201 deletions(-) diff --git a/test/fakedata_generation.py b/test/fakedata_generation.py index f7fc54d9346..28f4eaa46e8 100644 --- a/test/fakedata_generation.py +++ b/test/fakedata_generation.py @@ -208,103 +208,3 @@ def _make_annotations_archive(root): _make_annotations_archive(root_base) yield root - - -@contextlib.contextmanager -def places365_root(split="train-standard", small=False): - VARIANTS = { - "train-standard": "standard", - "train-challenge": "challenge", - "val": "standard", - } - # {split: file} - DEVKITS = { - "train-standard": "filelist_places365-standard.tar", - "train-challenge": "filelist_places365-challenge.tar", - "val": "filelist_places365-standard.tar", - } - CATEGORIES = "categories_places365.txt" - # {split: file} - FILE_LISTS = { - "train-standard": "places365_train_standard.txt", - "train-challenge": "places365_train_challenge.txt", - "val": "places365_train_standard.txt", - } - # {(split, small): (archive, folder_default, folder_renamed)} - IMAGES = { - ("train-standard", False): ("train_large_places365standard.tar", "data_large", "data_large_standard"), - ("train-challenge", False): ("train_large_places365challenge.tar", "data_large", "data_large_challenge"), - ("val", False): ("val_large.tar", "val_large", "val_large"), - ("train-standard", True): ("train_256_places365standard.tar", "data_256", "data_256_standard"), - ("train-challenge", True): ("train_256_places365challenge.tar", "data_256", "data_256_challenge"), - ("val", True): ("val_256.tar", "val_256", "val_256"), - } - - # (class, idx) - CATEGORIES_CONTENT = (("/a/airfield", 0), ("/a/apartment_building/outdoor", 8), ("/b/badlands", 30)) - # (file, idx) - FILE_LIST_CONTENT = ( - ("Places365_val_00000001.png", 0), - *((f"{category}/Places365_train_00000001.png", idx) for category, idx in CATEGORIES_CONTENT), - ) - - def mock_target(attr, partial="torchvision.datasets.places365.Places365"): - return f"{partial}.{attr}" - - def make_txt(root, name, seq): - file = os.path.join(root, name) - with open(file, "w") as fh: - for string, idx in seq: - fh.write(f"{string} {idx}\n") - return name, compute_md5(file) - - def make_categories_txt(root, name): - return make_txt(root, name, CATEGORIES_CONTENT) - - def make_file_list_txt(root, name): - return make_txt(root, name, FILE_LIST_CONTENT) - - def make_image(file, size): - os.makedirs(os.path.dirname(file), exist_ok=True) - PIL.Image.fromarray(np.zeros((*size, 3), dtype=np.uint8)).save(file) - - def make_devkit_archive(stack, root, split): - archive = DEVKITS[split] - files = [] - - meta = make_categories_txt(root, CATEGORIES) - mock_class_attribute(stack, mock_target("_CATEGORIES_META"), meta) - files.append(meta[0]) - - meta = {split: make_file_list_txt(root, FILE_LISTS[split])} - mock_class_attribute(stack, mock_target("_FILE_LIST_META"), meta) - files.extend([item[0] for item in meta.values()]) - - meta = {VARIANTS[split]: make_tar(root, archive, *files)} - mock_class_attribute(stack, mock_target("_DEVKIT_META"), meta) - - def make_images_archive(stack, root, split, small): - archive, folder_default, folder_renamed = IMAGES[(split, small)] - - image_size = (256, 256) if small else (512, random.randint(512, 1024)) - files, idcs = zip(*FILE_LIST_CONTENT) - images = [file.lstrip("/").replace("/", os.sep) for file in files] - for image in images: - make_image(os.path.join(root, folder_default, image), image_size) - - meta = {(split, small): make_tar(root, archive, folder_default)} - mock_class_attribute(stack, mock_target("_IMAGES_META"), meta) - - return [(os.path.join(root, folder_renamed, image), idx) for image, idx in zip(images, idcs)] - - with contextlib.ExitStack() as stack, get_tmp_dir() as root: - make_devkit_archive(stack, root, split) - class_to_idx = dict(CATEGORIES_CONTENT) - classes = list(class_to_idx.keys()) - - data = {"class_to_idx": class_to_idx, "classes": classes} - data["imgs"] = make_images_archive(stack, root, split, small) - - clean_dir(root, ".tar$") - - yield root, data diff --git a/test/test_datasets.py b/test/test_datasets.py index f28885d064d..fc81d82dcf0 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -9,7 +9,6 @@ import torchvision from torchvision.datasets import utils from common_utils import get_tmp_dir -from fakedata_generation import places365_root import xml.etree.ElementTree as ET from urllib.request import Request, urlopen import itertools @@ -41,106 +40,6 @@ HAS_PYAV = False -class DatasetTestcase(unittest.TestCase): - def generic_classification_dataset_test(self, dataset, num_images=1): - self.assertEqual(len(dataset), num_images) - img, target = dataset[0] - self.assertTrue(isinstance(img, PIL.Image.Image)) - self.assertTrue(isinstance(target, int)) - - def generic_segmentation_dataset_test(self, dataset, num_images=1): - self.assertEqual(len(dataset), num_images) - img, target = dataset[0] - self.assertTrue(isinstance(img, PIL.Image.Image)) - self.assertTrue(isinstance(target, PIL.Image.Image)) - - -class Tester(DatasetTestcase): - def test_places365(self): - for split, small in itertools.product(("train-standard", "train-challenge", "val"), (False, True)): - with places365_root(split=split, small=small) as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365(root, split=split, small=small, download=True) - self.generic_classification_dataset_test(dataset, num_images=len(data["imgs"])) - - def test_places365_transforms(self): - expected_image = "image" - expected_target = "target" - - def transform(image): - return expected_image - - def target_transform(target): - return expected_target - - with places365_root() as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365( - root, transform=transform, target_transform=target_transform, download=True - ) - actual_image, actual_target = dataset[0] - - self.assertEqual(actual_image, expected_image) - self.assertEqual(actual_target, expected_target) - - def test_places365_devkit_download(self): - for split in ("train-standard", "train-challenge", "val"): - with self.subTest(split=split): - with places365_root(split=split) as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365(root, split=split, download=True) - - with self.subTest("classes"): - self.assertSequenceEqual(dataset.classes, data["classes"]) - - with self.subTest("class_to_idx"): - self.assertDictEqual(dataset.class_to_idx, data["class_to_idx"]) - - with self.subTest("imgs"): - self.assertSequenceEqual(dataset.imgs, data["imgs"]) - - def test_places365_devkit_no_download(self): - for split in ("train-standard", "train-challenge", "val"): - with self.subTest(split=split): - with places365_root(split=split) as places365: - root, data = places365 - - with self.assertRaises(RuntimeError): - torchvision.datasets.Places365(root, split=split, download=False) - - def test_places365_images_download(self): - for split, small in itertools.product(("train-standard", "train-challenge", "val"), (False, True)): - with self.subTest(split=split, small=small): - with places365_root(split=split, small=small) as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365(root, split=split, small=small, download=True) - - assert all(os.path.exists(item[0]) for item in dataset.imgs) - - def test_places365_images_download_preexisting(self): - split = "train-standard" - small = False - images_dir = "data_large_standard" - - with places365_root(split=split, small=small) as places365: - root, data = places365 - os.mkdir(os.path.join(root, images_dir)) - - with self.assertRaises(RuntimeError): - torchvision.datasets.Places365(root, split=split, small=small, download=True) - - def test_places365_repr_smoke(self): - with places365_root() as places365: - root, data = places365 - - dataset = torchvision.datasets.Places365(root, download=True) - self.assertIsInstance(repr(dataset), str) - - class STL10TestCase(datasets_utils.ImageDatasetTestCase): DATASET_CLASS = datasets.STL10 ADDITIONAL_CONFIGS = datasets_utils.combinations_grid( @@ -1763,5 +1662,96 @@ def inject_fake_data(self, tmpdir, config): return num_examples +class Places365TestCase(datasets_utils.ImageDatasetTestCase): + DATASET_CLASS = datasets.Places365 + ADDITIONAL_CONFIGS = datasets_utils.combinations_grid( + split=("train-standard", "train-challenge", "val"), + small=(False, True), + ) + _CATEGORIES = "categories_places365.txt" + # {split: file} + _FILE_LISTS = { + "train-standard": "places365_train_standard.txt", + "train-challenge": "places365_train_challenge.txt", + "val": "places365_val.txt", + } + # {(split, small): folder_name} + _IMAGES = { + ("train-standard", False): "data_large_standard", + ("train-challenge", False): "data_large_challenge", + ("val", False): "val_large", + ("train-standard", True): "data_256_standard", + ("train-challenge", True): "data_256_challenge", + ("val", True): "val_256", + } + # (class, idx) + _CATEGORIES_CONTENT = ( + ("/a/airfield", 0), + ("/a/apartment_building/outdoor", 8), + ("/b/badlands", 30), + ) + # (file, idx) + _FILE_LIST_CONTENT = ( + ("Places365_val_00000001.png", 0), + *((f"{category}/Places365_train_00000001.png", idx) + for category, idx in _CATEGORIES_CONTENT), + ) + + @staticmethod + def _make_txt(root, name, seq): + file = os.path.join(root, name) + with open(file, "w") as fh: + for text, idx in seq: + fh.write(f"{text} {idx}\n") + + @staticmethod + def _make_categories_txt(root, name): + Places365TestCase._make_txt(root, name, Places365TestCase._CATEGORIES_CONTENT) + + @staticmethod + def _make_file_list_txt(root, name): + Places365TestCase._make_txt(root, name, Places365TestCase._FILE_LIST_CONTENT) + + @staticmethod + def _make_image(file_name, size): + os.makedirs(os.path.dirname(file_name), exist_ok=True) + PIL.Image.fromarray(np.zeros((*size, 3), dtype=np.uint8)).save(file_name) + + @staticmethod + def _make_devkit_archive(root, split): + Places365TestCase._make_categories_txt(root, Places365TestCase._CATEGORIES) + Places365TestCase._make_file_list_txt(root, Places365TestCase._FILE_LISTS[split]) + + @staticmethod + def _make_images_archive(root, split, small): + folder_name = Places365TestCase._IMAGES[(split, small)] + image_size = (256, 256) if small else (512, random.randint(512, 1024)) + files, idcs = zip(*Places365TestCase._FILE_LIST_CONTENT) + images = [f.lstrip("/").replace("/", os.sep) for f in files] + for image in images: + Places365TestCase._make_image(os.path.join(root, folder_name, image), image_size) + + return [(os.path.join(root, folder_name, image), idx) for image, idx in zip(images, idcs)] + + def inject_fake_data(self, tmpdir, config): + self._make_devkit_archive(tmpdir, config['split']) + return len(self._make_images_archive(tmpdir, config['split'], config['small'])) + + def test_classes(self): + classes = list(map(lambda x: x[0], self._CATEGORIES_CONTENT)) + with self.create_dataset() as (dataset, _): + self.assertEqual(dataset.classes, classes) + + def test_class_to_idx(self): + class_to_idx = dict(self._CATEGORIES_CONTENT) + with self.create_dataset() as (dataset, _): + self.assertEqual(dataset.class_to_idx, class_to_idx) + + def test_images_download_preexisting(self): + with self.assertRaises(RuntimeError): + with self.create_dataset({'download': True}): + pass + + if __name__ == "__main__": unittest.main() From eda9435624b1e1bdd6801d95eca2d9f43f83fa3e Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 26 Apr 2021 13:23:34 +0100 Subject: [PATCH 011/279] Prevent potential bug in DatasetFolder.make_dataset (#3733) --- torchvision/datasets/folder.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/torchvision/datasets/folder.py b/torchvision/datasets/folder.py index 9eb849bbe34..7392a33f6b2 100644 --- a/torchvision/datasets/folder.py +++ b/torchvision/datasets/folder.py @@ -200,6 +200,13 @@ def make_dataset( extensions: Optional[Tuple[str, ...]] = None, is_valid_file: Optional[Callable[[str], bool]] = None, ) -> List[Tuple[str, int]]: + if class_to_idx is None: + # prevent potential bug since make_dataset() would use the class_to_idx logic of the + # find_classes() function, instead of using that of the find_classes() method, which + # is potentially overridden and thus could have a different logic. + raise ValueError( + "The class_to_idx parameter cannot be None." + ) return make_dataset(directory, class_to_idx, extensions=extensions, is_valid_file=is_valid_file) def find_classes(self, dir: str) -> Tuple[List[str], Dict[str, int]]: From 5bc68cc9d54c8488173290df55ccb3aa36ce61c0 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Mon, 26 Apr 2021 14:15:40 +0100 Subject: [PATCH 012/279] Cleaned-up imports in test files related to datasets (#3720) --- test/datasets_utils.py | 2 -- test/fakedata_generation.py | 16 +++++++-------- test/test_datasets.py | 39 +++++++++++++------------------------ 3 files changed, 20 insertions(+), 37 deletions(-) diff --git a/test/datasets_utils.py b/test/datasets_utils.py index de772d1c7d0..8077a03b910 100644 --- a/test/datasets_utils.py +++ b/test/datasets_utils.py @@ -1,4 +1,3 @@ -import collections.abc import contextlib import functools import importlib @@ -15,7 +14,6 @@ import PIL import PIL.Image - import torch import torchvision.datasets import torchvision.io diff --git a/test/fakedata_generation.py b/test/fakedata_generation.py index 28f4eaa46e8..8540410351e 100644 --- a/test/fakedata_generation.py +++ b/test/fakedata_generation.py @@ -1,19 +1,17 @@ import os import contextlib +import hashlib +import pickle +import re import tarfile -import json +import unittest.mock +from distutils import dir_util + import numpy as np import PIL import torch + from common_utils import get_tmp_dir -import pickle -import random -from itertools import cycle -from torchvision.io.video import write_video -import unittest.mock -import hashlib -from distutils import dir_util -import re def mock_class_attribute(stack, target, new): diff --git a/test/test_datasets.py b/test/test_datasets.py index fc81d82dcf0..1166040d5e1 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -1,31 +1,24 @@ +import bz2 import contextlib -import sys -import os -import unittest -import numpy as np -import PIL -from PIL import Image -from torch._utils_internal import get_file_path_2 -import torchvision -from torchvision.datasets import utils -from common_utils import get_tmp_dir -import xml.etree.ElementTree as ET -from urllib.request import Request, urlopen +import io import itertools -import datasets_utils +import os import pathlib import pickle -from torchvision import datasets -import torch -import shutil import json import random -import bz2 -import torch.nn.functional as F +import shutil import string -import io +import unittest +import xml.etree.ElementTree as ET import zipfile +import PIL +import datasets_utils +import numpy as np +import torch +import torch.nn.functional as F +from torchvision import datasets try: import scipy @@ -33,12 +26,6 @@ except ImportError: HAS_SCIPY = False -try: - import av - HAS_PYAV = True -except ImportError: - HAS_PYAV = False - class STL10TestCase(datasets_utils.ImageDatasetTestCase): DATASET_CLASS = datasets.STL10 @@ -946,7 +933,7 @@ def _create_lmdb(self, root, cls): key = "".join(random.choice(hexdigits_lowercase) for _ in range(40)).encode() buffer = io.BytesIO() - Image.open(file).save(buffer, format) + PIL.Image.open(file).save(buffer, format) buffer.seek(0) value = buffer.read() From 7bc5bd855536c34a1759d125436f791dde4fb8b7 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Mon, 26 Apr 2021 16:57:57 +0100 Subject: [PATCH 013/279] Added download test for KITTI dataset (#3736) --- test/test_datasets_download.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/test/test_datasets_download.py b/test/test_datasets_download.py index 6064163ae38..0066b76ccbe 100644 --- a/test/test_datasets_download.py +++ b/test/test_datasets_download.py @@ -392,6 +392,19 @@ def widerface(): ) +def kitti(): + return itertools.chain( + *[ + collect_download_configs( + lambda train=train: datasets.Kitti(ROOT, train=train, download=True), + name=f"Kitti, {'train' if train else 'test'}", + file="kitti", + ) + for train in (True, False) + ] + ) + + def make_parametrize_kwargs(download_configs): argvalues = [] ids = [] @@ -427,6 +440,7 @@ def make_parametrize_kwargs(download_configs): usps(), celeba(), widerface(), + kitti(), ) ) ) From fbf547cfb2d35a8d47c43d695667f740739ce4ad Mon Sep 17 00:00:00 2001 From: Guillem Orellana Trullols Date: Tue, 27 Apr 2021 16:15:28 +0200 Subject: [PATCH 014/279] Proper error message (#3725) * Proper error message Now when there are missing ffmpeg libraries the error displayed is: ``` {0} header files were not found, disabling ffmpeg. ``` This is because the missing `.format`. This PR fixes the warning message by appending the proper format operation. * Use f-string Co-authored-by: Prabhat Roy --- setup.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/setup.py b/setup.py index ff4c48d4cbb..86007622715 100644 --- a/setup.py +++ b/setup.py @@ -374,8 +374,7 @@ def get_extensions(): library_found |= len(glob.glob(full_path)) > 0 if not library_found: - print('{0} header files were not found, disabling ffmpeg ' - 'support') + print(f'{library} header files were not found, disabling ffmpeg support') has_ffmpeg = False if has_ffmpeg: From c2b8575cbad1f88d6d42f54a84ceb26b9d94d3d5 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Tue, 27 Apr 2021 16:07:30 +0100 Subject: [PATCH 015/279] Removed unused import (#3738) --- test/test_datasets.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/test/test_datasets.py b/test/test_datasets.py index 1166040d5e1..a076b843fa8 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -20,12 +20,6 @@ import torch.nn.functional as F from torchvision import datasets -try: - import scipy - HAS_SCIPY = True -except ImportError: - HAS_SCIPY = False - class STL10TestCase(datasets_utils.ImageDatasetTestCase): DATASET_CLASS = datasets.STL10 From d4aa0111249b720d5233c8dda68a925008d973fd Mon Sep 17 00:00:00 2001 From: Aditya Oke <47158509+oke-aditya@users.noreply.github.com> Date: Wed, 28 Apr 2021 00:12:53 +0530 Subject: [PATCH 016/279] Add illustrations for AutoAugment in gallery example (#3727) Co-authored-by: Nicolas Hug --- gallery/plot_transforms.py | 23 +++++++++++++++++++++++ torchvision/transforms/autoaugment.py | 10 ---------- 2 files changed, 23 insertions(+), 10 deletions(-) diff --git a/gallery/plot_transforms.py b/gallery/plot_transforms.py index ed919914146..e5d6ca5a9aa 100644 --- a/gallery/plot_transforms.py +++ b/gallery/plot_transforms.py @@ -178,3 +178,26 @@ def _plot(img, title, **kwargs): # performs gaussianblur transform on an image. gaus_blur_img = T.GaussianBlur(kernel_size=(5, 9), sigma=(0.4, 3.0))(orig_img) plot(gaus_blur_img, "Gaussian Blurred Image") + + +#################################### +# AutoAugment +# ----------- +# The :class:`~torchvision.transforms.AutoAugment` transform +# automatically augments data based on a given auto-augmentation policy. +# See :class:`~torchvision.transforms.AutoAugmentPolicy` for the available policies. +policies = [T.AutoAugmentPolicy.CIFAR10, T.AutoAugmentPolicy.IMAGENET, T.AutoAugmentPolicy.SVHN] +num_cols = 5 +fig, axs = plt.subplots(nrows=len(policies), ncols=num_cols) +fig.suptitle("Auto-augmented images with different policies") + +for pol_idx, policy in enumerate(policies): + auto_augmenter = T.AutoAugment(policy) + for col in range(num_cols): + augmented_img = auto_augmenter(orig_img) + + ax = axs[pol_idx, col] + ax.imshow(np.asarray(augmented_img)) + ax.set(xticklabels=[], yticklabels=[], xticks=[], yticks=[]) + if col == 0: + ax.set(ylabel=str(policy).split('.')[-1]) diff --git a/torchvision/transforms/autoaugment.py b/torchvision/transforms/autoaugment.py index 1889a62e948..97522945d2e 100644 --- a/torchvision/transforms/autoaugment.py +++ b/torchvision/transforms/autoaugment.py @@ -142,16 +142,6 @@ class AutoAugment(torch.nn.Module): If input is Tensor, only ``InterpolationMode.NEAREST``, ``InterpolationMode.BILINEAR`` are supported. fill (sequence or number, optional): Pixel fill value for the area outside the transformed image. If given a number, the value is used for all bands respectively. - If input is PIL Image, the options is only available for ``Pillow>=5.0.0``. - - Example: - >>> t = transforms.AutoAugment() - >>> transformed = t(image) - - >>> transform=transforms.Compose([ - >>> transforms.Resize(256), - >>> transforms.AutoAugment(), - >>> transforms.ToTensor()]) """ def __init__(self, policy: AutoAugmentPolicy = AutoAugmentPolicy.IMAGENET, From 8e82f22708fec1e7f0eadb20087621a2d3cd299f Mon Sep 17 00:00:00 2001 From: Aditya Oke <47158509+oke-aditya@users.noreply.github.com> Date: Wed, 28 Apr 2021 01:53:34 +0530 Subject: [PATCH 017/279] Add docs for Interpolation modes (#3739) * Add docs for Interpolation modes * Update torchvision/transforms/functional.py Co-authored-by: Nicolas Hug Co-authored-by: Nicolas Hug Co-authored-by: Vasilis Vryniotis --- torchvision/transforms/functional.py | 1 + 1 file changed, 1 insertion(+) diff --git a/torchvision/transforms/functional.py b/torchvision/transforms/functional.py index 00836004375..855ce19bde4 100644 --- a/torchvision/transforms/functional.py +++ b/torchvision/transforms/functional.py @@ -21,6 +21,7 @@ class InterpolationMode(Enum): """Interpolation modes + Available interpolation methods are ``nearest``, ``bilinear``, ``bicubic``, ``box``, ``hamming``, and ``lanczos``. """ NEAREST = "nearest" BILINEAR = "bilinear" From 7af30ee9ab64039d04150d118e8b72473184fd6e Mon Sep 17 00:00:00 2001 From: Aditya Oke <47158509+oke-aditya@users.noreply.github.com> Date: Wed, 28 Apr 2021 01:55:20 +0530 Subject: [PATCH 018/279] remove unused imports (#3740) Co-authored-by: Vasilis Vryniotis --- torchvision/datasets/hmdb51.py | 1 - torchvision/datasets/ucf101.py | 1 - torchvision/datasets/voc.py | 1 - torchvision/io/_video_opt.py | 1 - torchvision/io/image.py | 1 - torchvision/io/video.py | 1 - torchvision/models/detection/faster_rcnn.py | 1 - torchvision/models/quantization/inception.py | 1 - torchvision/models/quantization/resnet.py | 3 +-- 9 files changed, 1 insertion(+), 10 deletions(-) diff --git a/torchvision/datasets/hmdb51.py b/torchvision/datasets/hmdb51.py index 113186b71b9..4912eb01600 100644 --- a/torchvision/datasets/hmdb51.py +++ b/torchvision/datasets/hmdb51.py @@ -1,7 +1,6 @@ import glob import os -from .utils import list_dir from .folder import find_classes, make_dataset from .video_utils import VideoClips from .vision import VisionDataset diff --git a/torchvision/datasets/ucf101.py b/torchvision/datasets/ucf101.py index 709151c2fcb..71f62257bcb 100644 --- a/torchvision/datasets/ucf101.py +++ b/torchvision/datasets/ucf101.py @@ -1,6 +1,5 @@ import os -from .utils import list_dir from .folder import find_classes, make_dataset from .video_utils import VideoClips from .vision import VisionDataset diff --git a/torchvision/datasets/voc.py b/torchvision/datasets/voc.py index c459dcb5c9e..56bd92c7972 100644 --- a/torchvision/datasets/voc.py +++ b/torchvision/datasets/voc.py @@ -1,5 +1,4 @@ import os -import tarfile import collections from .vision import VisionDataset from xml.etree.ElementTree import Element as ET_Element diff --git a/torchvision/io/_video_opt.py b/torchvision/io/_video_opt.py index e7d0494a250..4cc2b60c706 100644 --- a/torchvision/io/_video_opt.py +++ b/torchvision/io/_video_opt.py @@ -26,7 +26,6 @@ if os.name == 'nt': # Load the video_reader extension using LoadLibraryExW import ctypes - import sys kernel32 = ctypes.WinDLL('kernel32.dll', use_last_error=True) with_load_library_flags = hasattr(kernel32, 'AddDllDirectory') diff --git a/torchvision/io/image.py b/torchvision/io/image.py index e193555e447..8310c1eb273 100644 --- a/torchvision/io/image.py +++ b/torchvision/io/image.py @@ -22,7 +22,6 @@ if os.name == 'nt': # Load the image extension using LoadLibraryExW import ctypes - import sys kernel32 = ctypes.WinDLL('kernel32.dll', use_last_error=True) with_load_library_flags = hasattr(kernel32, 'AddDllDirectory') diff --git a/torchvision/io/video.py b/torchvision/io/video.py index 34a11826049..22cad38d10b 100644 --- a/torchvision/io/video.py +++ b/torchvision/io/video.py @@ -8,7 +8,6 @@ import torch from . import _video_opt -from ._video_opt import VideoMetaData try: diff --git a/torchvision/models/detection/faster_rcnn.py b/torchvision/models/detection/faster_rcnn.py index 6781c965d18..53100e54adb 100644 --- a/torchvision/models/detection/faster_rcnn.py +++ b/torchvision/models/detection/faster_rcnn.py @@ -1,4 +1,3 @@ -import torch from torch import nn import torch.nn.functional as F diff --git a/torchvision/models/quantization/inception.py b/torchvision/models/quantization/inception.py index efce265271f..1475cad5eb4 100644 --- a/torchvision/models/quantization/inception.py +++ b/torchvision/models/quantization/inception.py @@ -1,5 +1,4 @@ import warnings -from collections import namedtuple import torch import torch.nn as nn diff --git a/torchvision/models/quantization/resnet.py b/torchvision/models/quantization/resnet.py index c6a87c8c7d9..f5ac3d0a486 100644 --- a/torchvision/models/quantization/resnet.py +++ b/torchvision/models/quantization/resnet.py @@ -2,8 +2,7 @@ from torchvision.models.resnet import Bottleneck, BasicBlock, ResNet, model_urls import torch.nn as nn from torchvision.models.utils import load_state_dict_from_url -from torch.quantization import QuantStub, DeQuantStub, fuse_modules -from torch._jit_internal import Optional +from torch.quantization import fuse_modules from .utils import _replace_relu, quantize_model __all__ = ['QuantizableResNet', 'resnet18', 'resnet50', From c8f7d772e844d707e152e2a1fa1aad26cf1b7530 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 27 Apr 2021 20:56:46 +0000 Subject: [PATCH 019/279] Remove inconsistent FB copyright headers (#3741) --- test/cpp/test_custom_operators.cpp | 2 -- torchvision/csrc/io/decoder/stream.cpp | 2 +- torchvision/models/detection/anchor_utils.py | 1 - torchvision/models/detection/generalized_rcnn.py | 1 - torchvision/models/detection/image_list.py | 1 - torchvision/models/detection/rpn.py | 1 - torchvision/ops/poolers.py | 1 - 7 files changed, 1 insertion(+), 8 deletions(-) diff --git a/test/cpp/test_custom_operators.cpp b/test/cpp/test_custom_operators.cpp index d660852bbfb..499683a78af 100644 --- a/test/cpp/test_custom_operators.cpp +++ b/test/cpp/test_custom_operators.cpp @@ -1,5 +1,3 @@ -// Copyright 2004-present Facebook. All Rights Reserved. - #include #include #include diff --git a/torchvision/csrc/io/decoder/stream.cpp b/torchvision/csrc/io/decoder/stream.cpp index 4da48647382..e924ea6a3d1 100644 --- a/torchvision/csrc/io/decoder/stream.cpp +++ b/torchvision/csrc/io/decoder/stream.cpp @@ -17,7 +17,7 @@ Stream::Stream( Stream::~Stream() { if (frame_) { - av_free(frame_); // Copyright 2004-present Facebook. All Rights Reserved. + av_free(frame_); } if (codecCtx_) { avcodec_free_context(&codecCtx_); diff --git a/torchvision/models/detection/anchor_utils.py b/torchvision/models/detection/anchor_utils.py index a40a9aad699..bb38d55decc 100644 --- a/torchvision/models/detection/anchor_utils.py +++ b/torchvision/models/detection/anchor_utils.py @@ -1,4 +1,3 @@ -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. import torch from torch import nn, Tensor diff --git a/torchvision/models/detection/generalized_rcnn.py b/torchvision/models/detection/generalized_rcnn.py index c321e79f298..1d3979caa3f 100644 --- a/torchvision/models/detection/generalized_rcnn.py +++ b/torchvision/models/detection/generalized_rcnn.py @@ -1,4 +1,3 @@ -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. """ Implements the Generalized R-CNN framework """ diff --git a/torchvision/models/detection/image_list.py b/torchvision/models/detection/image_list.py index cff7ef8fd5a..a389b3c3ce1 100644 --- a/torchvision/models/detection/image_list.py +++ b/torchvision/models/detection/image_list.py @@ -1,4 +1,3 @@ -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. import torch from torch import Tensor from typing import List, Tuple diff --git a/torchvision/models/detection/rpn.py b/torchvision/models/detection/rpn.py index 9f9bf9da5f5..a98eac24dd3 100644 --- a/torchvision/models/detection/rpn.py +++ b/torchvision/models/detection/rpn.py @@ -1,4 +1,3 @@ -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. import torch from torch.nn import functional as F from torch import nn, Tensor diff --git a/torchvision/ops/poolers.py b/torchvision/ops/poolers.py index a0ba5b42774..f4ff289299b 100644 --- a/torchvision/ops/poolers.py +++ b/torchvision/ops/poolers.py @@ -1,4 +1,3 @@ -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. import torch from torch import nn, Tensor From 5ac27fe301b0d5323ac301dafadf1d8866b6657d Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 28 Apr 2021 10:47:21 +0100 Subject: [PATCH 020/279] Rework transforms example in gallery (#3744) --- gallery/plot_transforms.py | 216 ++++++++++++++++++++----------------- 1 file changed, 116 insertions(+), 100 deletions(-) diff --git a/gallery/plot_transforms.py b/gallery/plot_transforms.py index e5d6ca5a9aa..f265054dbc4 100644 --- a/gallery/plot_transforms.py +++ b/gallery/plot_transforms.py @@ -11,21 +11,40 @@ import matplotlib.pyplot as plt import numpy as np +import torch import torchvision.transforms as T +plt.rcParams["savefig.bbox"] = 'tight' orig_img = Image.open(Path('assets') / 'astronaut.jpg') - - -def plot(img, title: str = "", with_orig: bool = True, **kwargs): - def _plot(img, title, **kwargs): - plt.figure().suptitle(title, fontsize=25) - plt.imshow(np.asarray(img), **kwargs) - plt.axis('off') +# if you change the seed, make sure that the randomly-applied transforms +# properly show that the image can be both transformed and *not* transformed! +torch.manual_seed(0) + + +def plot(imgs, with_orig=True, row_title=None, **imshow_kwargs): + if not isinstance(imgs[0], list): + # Make a 2d grid even if there's just 1 row + imgs = [imgs] + + num_rows = len(imgs) + num_cols = len(imgs[0]) + with_orig + fig, axs = plt.subplots(nrows=num_rows, ncols=num_cols, squeeze=False) + for row_idx, row in enumerate(imgs): + row = [orig_img] + row if with_orig else row + for col_idx, img in enumerate(row): + ax = axs[row_idx, col_idx] + ax.imshow(np.asarray(img), **imshow_kwargs) + ax.set(xticklabels=[], yticklabels=[], xticks=[], yticks=[]) if with_orig: - _plot(orig_img, "Original Image") - _plot(img, title, **kwargs) + axs[0, 0].set(title='Original image') + axs[0, 0].title.set_size(8) + if row_title is not None: + for row_idx in range(num_rows): + axs[row_idx, 0].set(ylabel=row_title[row_idx]) + + plt.tight_layout() #################################### @@ -34,8 +53,8 @@ def _plot(img, title, **kwargs): # The :class:`~torchvision.transforms.Pad` transform # (see also :func:`~torchvision.transforms.functional.pad`) # fills image borders with some pixel values. -padded_img = T.Pad(padding=30)(orig_img) -plot(padded_img, "Padded Image") +padded_imgs = [T.Pad(padding=padding)(orig_img) for padding in (3, 10, 30, 50)] +plot(padded_imgs) #################################### # Resize @@ -43,8 +62,8 @@ def _plot(img, title, **kwargs): # The :class:`~torchvision.transforms.Resize` transform # (see also :func:`~torchvision.transforms.functional.resize`) # resizes an image. -resized_img = T.Resize(size=30)(orig_img) -plot(resized_img, "Resized Image") +resized_imgs = [T.Resize(size=size)(orig_img) for size in (30, 50, 100, orig_img.size)] +plot(resized_imgs) #################################### # CenterCrop @@ -52,9 +71,8 @@ def _plot(img, title, **kwargs): # The :class:`~torchvision.transforms.CenterCrop` transform # (see also :func:`~torchvision.transforms.functional.center_crop`) # crops the given image at the center. -center_cropped_img = T.CenterCrop(size=(100, 100))(orig_img) -plot(center_cropped_img, "Center Cropped Image") - +center_crops = [T.CenterCrop(size=size)(orig_img) for size in (30, 50, 100, orig_img.size)] +plot(center_crops) #################################### # FiveCrop @@ -62,20 +80,8 @@ def _plot(img, title, **kwargs): # The :class:`~torchvision.transforms.FiveCrop` transform # (see also :func:`~torchvision.transforms.functional.five_crop`) # crops the given image into four corners and the central crop. -(img1, img2, img3, img4, img5) = T.FiveCrop(size=(100, 100))(orig_img) -plot(img1, "Top Left Corner Image") -plot(img2, "Top Right Corner Image", with_orig=False) -plot(img3, "Bottom Left Corner Image", with_orig=False) -plot(img4, "Bottom Right Corner Image", with_orig=False) -plot(img5, "Center Image", with_orig=False) - -#################################### -# ColorJitter -# ----------- -# The :class:`~torchvision.transforms.ColorJitter` transform -# randomly changes the brightness, saturation, and other properties of an image. -jitted_img = T.ColorJitter(brightness=.5, hue=.3)(orig_img) -plot(jitted_img, "Jitted Image") +(top_left, top_right, bottom_left, bottom_right, center) = T.FiveCrop(size=(100, 100))(orig_img) +plot([top_left, top_right, bottom_left, bottom_right, center]) #################################### # Grayscale @@ -84,120 +90,130 @@ def _plot(img, title, **kwargs): # (see also :func:`~torchvision.transforms.functional.to_grayscale`) # converts an image to grayscale gray_img = T.Grayscale()(orig_img) -plot(gray_img, "Grayscale Image", cmap='gray') +plot([gray_img], cmap='gray') #################################### -# RandomPerspective +# Random transforms # ----------------- +# The following transforms are random, which means that the same transfomer +# instance will produce different result each time it transforms a given image. +# +# ColorJitter +# ~~~~~~~~~~~ +# The :class:`~torchvision.transforms.ColorJitter` transform +# randomly changes the brightness, saturation, and other properties of an image. +jitter = T.ColorJitter(brightness=.5, hue=.3) +jitted_imgs = [jitter(orig_img) for _ in range(4)] +plot(jitted_imgs) + +#################################### +# GaussianBlur +# ~~~~~~~~~~~~ +# The :class:`~torchvision.transforms.GaussianBlur` transform +# (see also :func:`~torchvision.transforms.functional.gaussian_blur`) +# performs gaussian blur transform on an image. +blurrer = T.GaussianBlur(kernel_size=(5, 9), sigma=(0.1, 5)) +blurred_imgs = [blurrer(orig_img) for _ in range(4)] +plot(blurred_imgs) + +#################################### +# RandomPerspective +# ~~~~~~~~~~~~~~~~~ # The :class:`~torchvision.transforms.RandomPerspective` transform # (see also :func:`~torchvision.transforms.functional.perspective`) # performs random perspective transform on an image. -perspectived_img = T.RandomPerspective(distortion_scale=0.6, p=1.0)(orig_img) -plot(perspectived_img, "Perspective transformed Image") +perspective_transformer = T.RandomPerspective(distortion_scale=0.6, p=1.0) +perspective_imgs = [perspective_transformer(orig_img) for _ in range(4)] +plot(perspective_imgs) #################################### # RandomRotation -# -------------- +# ~~~~~~~~~~~~~~ # The :class:`~torchvision.transforms.RandomRotation` transform # (see also :func:`~torchvision.transforms.functional.rotate`) # rotates an image with random angle. -rotated_img = T.RandomRotation(degrees=(30, 70))(orig_img) -plot(rotated_img, "Rotated Image") +rotater = T.RandomRotation(degrees=(0, 180)) +rotated_imgs = [rotater(orig_img) for _ in range(4)] +plot(rotated_imgs) #################################### # RandomAffine -# ------------ +# ~~~~~~~~~~~~ # The :class:`~torchvision.transforms.RandomAffine` transform # (see also :func:`~torchvision.transforms.functional.affine`) # performs random affine transform on an image. -affined_img = T.RandomAffine(degrees=(30, 70), translate=(0.1, 0.3), scale=(0.5, 0.75))(orig_img) -plot(affined_img, "Affine transformed Image") +affine_transfomer = T.RandomAffine(degrees=(30, 70), translate=(0.1, 0.3), scale=(0.5, 0.75)) +affine_imgs = [affine_transfomer(orig_img) for _ in range(4)] +plot(affine_imgs) #################################### # RandomCrop -# ---------- +# ~~~~~~~~~~ # The :class:`~torchvision.transforms.RandomCrop` transform # (see also :func:`~torchvision.transforms.functional.crop`) # crops an image at a random location. -crop_img = T.RandomCrop(size=(128, 128))(orig_img) -plot(crop_img, "Random cropped Image") +cropper = T.RandomCrop(size=(128, 128)) +crops = [cropper(orig_img) for _ in range(4)] +plot(crops) #################################### # RandomResizedCrop -# ----------------- +# ~~~~~~~~~~~~~~~~~ # The :class:`~torchvision.transforms.RandomResizedCrop` transform # (see also :func:`~torchvision.transforms.functional.resized_crop`) # crops an image at a random location, and then resizes the crop to a given # size. -resized_crop_img = T.RandomResizedCrop(size=(32, 32))(orig_img) -plot(resized_crop_img, "Random resized cropped Image") +resize_cropper = T.RandomResizedCrop(size=(32, 32)) +resized_crops = [resize_cropper(orig_img) for _ in range(4)] +plot(resized_crops) #################################### +# AutoAugment +# ~~~~~~~~~~~ +# The :class:`~torchvision.transforms.AutoAugment` transform +# automatically augments data based on a given auto-augmentation policy. +# See :class:`~torchvision.transforms.AutoAugmentPolicy` for the available policies. +policies = [T.AutoAugmentPolicy.CIFAR10, T.AutoAugmentPolicy.IMAGENET, T.AutoAugmentPolicy.SVHN] +augmenters = [T.AutoAugment(policy) for policy in policies] +imgs = [ + [augmenter(orig_img) for _ in range(4)] + for augmenter in augmenters +] +row_title = [str(policy).split('.')[-1] for policy in policies] +plot(imgs, row_title=row_title) + +#################################### +# Randomly-applied transforms +# --------------------------- +# +# Some transforms are randomly-applied given a probability ``p``. That is, the +# transformed image may actually be the same as the original one, even when +# called with the same transformer instance! +# # RandomHorizontalFlip -# -------------------- +# ~~~~~~~~~~~~~~~~~~~~ # The :class:`~torchvision.transforms.RandomHorizontalFlip` transform # (see also :func:`~torchvision.transforms.functional.hflip`) # performs horizontal flip of an image, with a given probability. -# -# .. note:: -# Since the transform is applied randomly, the two images below may actually be -# the same. -random_hflip_img = T.RandomHorizontalFlip(p=0.5)(orig_img) -plot(random_hflip_img, "Random horizontal flipped Image") +hflipper = T.RandomHorizontalFlip(p=0.5) +transformed_imgs = [hflipper(orig_img) for _ in range(4)] +plot(transformed_imgs) #################################### # RandomVerticalFlip -# ------------------ +# ~~~~~~~~~~~~~~~~~~ # The :class:`~torchvision.transforms.RandomVerticalFlip` transform # (see also :func:`~torchvision.transforms.functional.vflip`) # performs vertical flip of an image, with a given probability. -# -# .. note:: -# Since the transform is applied randomly, the two images below may actually be -# the same. -random_vflip_img = T.RandomVerticalFlip(p=0.5)(orig_img) -plot(random_vflip_img, "Random vertical flipped Image") +vflipper = T.RandomVerticalFlip(p=0.5) +transformed_imgs = [vflipper(orig_img) for _ in range(4)] +plot(transformed_imgs) #################################### # RandomApply -# ----------- +# ~~~~~~~~~~~ # The :class:`~torchvision.transforms.RandomApply` transform -# randomly applies a list of transforms, with a given probability -# -# .. note:: -# Since the transform is applied randomly, the two images below may actually be -# the same. -random_apply_img = T.RandomApply(transforms=[T.RandomCrop(size=(64, 64))], p=0.5)(orig_img) -plot(random_apply_img, "Random Apply transformed Image") - -#################################### -# GaussianBlur -# ------------ -# The :class:`~torchvision.transforms.GaussianBlur` transform -# (see also :func:`~torchvision.transforms.functional.gaussian_blur`) -# performs gaussianblur transform on an image. -gaus_blur_img = T.GaussianBlur(kernel_size=(5, 9), sigma=(0.4, 3.0))(orig_img) -plot(gaus_blur_img, "Gaussian Blurred Image") - - -#################################### -# AutoAugment -# ----------- -# The :class:`~torchvision.transforms.AutoAugment` transform -# automatically augments data based on a given auto-augmentation policy. -# See :class:`~torchvision.transforms.AutoAugmentPolicy` for the available policies. -policies = [T.AutoAugmentPolicy.CIFAR10, T.AutoAugmentPolicy.IMAGENET, T.AutoAugmentPolicy.SVHN] -num_cols = 5 -fig, axs = plt.subplots(nrows=len(policies), ncols=num_cols) -fig.suptitle("Auto-augmented images with different policies") - -for pol_idx, policy in enumerate(policies): - auto_augmenter = T.AutoAugment(policy) - for col in range(num_cols): - augmented_img = auto_augmenter(orig_img) - - ax = axs[pol_idx, col] - ax.imshow(np.asarray(augmented_img)) - ax.set(xticklabels=[], yticklabels=[], xticks=[], yticks=[]) - if col == 0: - ax.set(ylabel=str(policy).split('.')[-1]) +# randomly applies a list of transforms, with a given probability. +applier = T.RandomApply(transforms=[T.RandomCrop(size=(64, 64))], p=0.5) +transformed_imgs = [applier(orig_img) for _ in range(4)] +plot(transformed_imgs) From 54d88f79b44747e462dee7523fa17d24116bd783 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 28 Apr 2021 11:02:37 +0100 Subject: [PATCH 021/279] Expose public methods in docs for datasets (#3732) --- docs/source/datasets.rst | 39 +++++------- torchvision/datasets/folder.py | 110 +++++++++++++++++---------------- 2 files changed, 75 insertions(+), 74 deletions(-) diff --git a/docs/source/datasets.rst b/docs/source/datasets.rst index cb02f2bcaa3..af1b95db4bb 100644 --- a/docs/source/datasets.rst +++ b/docs/source/datasets.rst @@ -13,17 +13,11 @@ For example: :: shuffle=True, num_workers=args.nThreads) -The following datasets are available: - -.. contents:: Datasets - :local: +.. currentmodule:: torchvision.datasets All the datasets have almost similar API. They all have two common arguments: ``transform`` and ``target_transform`` to transform the input and target respectively. - - -.. currentmodule:: torchvision.datasets - +You can also create your own datasets using the provided :ref:`base classes `. Caltech ~~~~~~~ @@ -86,13 +80,6 @@ Detection :members: __getitem__ :special-members: -DatasetFolder -~~~~~~~~~~~~~ - -.. autoclass:: DatasetFolder - :members: __getitem__ - :special-members: - EMNIST ~~~~~~ @@ -127,13 +114,6 @@ HMDB51 :members: __getitem__ :special-members: -ImageFolder -~~~~~~~~~~~ - -.. autoclass:: ImageFolder - :members: __getitem__ - :special-members: - ImageNet ~~~~~~~~~~~ @@ -263,3 +243,18 @@ WIDERFace .. autoclass:: WIDERFace :members: __getitem__ :special-members: + + +.. _base_classes_datasets: + +Base classes for custom datasets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: DatasetFolder + :members: __getitem__, find_classes, make_dataset + :special-members: + + +.. autoclass:: ImageFolder + :members: __getitem__ + :special-members: diff --git a/torchvision/datasets/folder.py b/torchvision/datasets/folder.py index 7392a33f6b2..29255c7ab40 100644 --- a/torchvision/datasets/folder.py +++ b/torchvision/datasets/folder.py @@ -33,30 +33,9 @@ def is_image_file(filename: str) -> bool: def find_classes(directory: str) -> Tuple[List[str], Dict[str, int]]: - """Finds the class folders in a dataset structured as follows: - - .. code:: - - directory/ - ├── class_x - │ ├── xxx.ext - │ ├── xxy.ext - │ └── ... - │ └── xxz.ext - └── class_y - ├── 123.ext - ├── nsdf3.ext - └── ... - └── asd932_.ext - - Args: - directory (str): Root directory path. + """Finds the class folders in a dataset. - Raises: - FileNotFoundError: If ``directory`` has no class folders. - - Returns: - (Tuple[List[str], Dict[str, int]]): List of all classes and dictionary mapping each class to an index. + See :class:`DatasetFolder` for details. """ classes = sorted(entry.name for entry in os.scandir(directory) if entry.is_dir()) if not classes: @@ -74,24 +53,10 @@ def make_dataset( ) -> List[Tuple[str, int]]: """Generates a list of samples of a form (path_to_sample, class). - Args: - directory (str): root dataset directory - class_to_idx (Optional[Dict[str, int]]): Dictionary mapping class name to class index. If omitted, is generated - by :func:`find_classes`. - extensions (optional): A list of allowed extensions. - Either extensions or is_valid_file should be passed. Defaults to None. - is_valid_file (optional): A function that takes path of a file - and checks if the file is a valid file - (used to check of corrupt files) both extensions and - is_valid_file should not be passed. Defaults to None. - - Raises: - ValueError: In case ``class_to_idx`` is empty. - ValueError: In case ``extensions`` and ``is_valid_file`` are None or both are not None. - FileNotFoundError: In case no valid file was found for any class. + See :class:`DatasetFolder` for details. - Returns: - List[Tuple[str, int]]: samples of a form (path_to_sample, class) + Note: The class_to_idx parameter is here optional and will use the logic of the ``find_classes`` function + by default. """ directory = os.path.expanduser(directory) @@ -140,15 +105,10 @@ def is_valid_file(x: str) -> bool: class DatasetFolder(VisionDataset): - """A generic data loader where the samples are arranged in this way: :: - - root/class_x/xxx.ext - root/class_x/xxy.ext - root/class_x/[...]/xxz.ext + """A generic data loader. - root/class_y/123.ext - root/class_y/nsdf3.ext - root/class_y/[...]/asd932_.ext + This default directory structure can be customized by overriding the + :meth:`find_classes` method. Args: root (string): Root directory path. @@ -200,6 +160,28 @@ def make_dataset( extensions: Optional[Tuple[str, ...]] = None, is_valid_file: Optional[Callable[[str], bool]] = None, ) -> List[Tuple[str, int]]: + """Generates a list of samples of a form (path_to_sample, class). + + This can be overridden to e.g. read files from a compressed zip file instead of from the disk. + + Args: + directory (str): root dataset directory, corresponding to ``self.root``. + class_to_idx (Dict[str, int]): Dictionary mapping class name to class index. + extensions (optional): A list of allowed extensions. + Either extensions or is_valid_file should be passed. Defaults to None. + is_valid_file (optional): A function that takes path of a file + and checks if the file is a valid file + (used to check of corrupt files) both extensions and + is_valid_file should not be passed. Defaults to None. + + Raises: + ValueError: In case ``class_to_idx`` is empty. + ValueError: In case ``extensions`` and ``is_valid_file`` are None or both are not None. + FileNotFoundError: In case no valid file was found for any class. + + Returns: + List[Tuple[str, int]]: samples of a form (path_to_sample, class) + """ if class_to_idx is None: # prevent potential bug since make_dataset() would use the class_to_idx logic of the # find_classes() function, instead of using that of the find_classes() method, which @@ -209,13 +191,34 @@ def make_dataset( ) return make_dataset(directory, class_to_idx, extensions=extensions, is_valid_file=is_valid_file) - def find_classes(self, dir: str) -> Tuple[List[str], Dict[str, int]]: - """Same as :func:`find_classes`. + def find_classes(self, directory: str) -> Tuple[List[str], Dict[str, int]]: + """Find the class folders in a dataset structured as follows:: + + directory/ + ├── class_x + │ ├── xxx.ext + │ ├── xxy.ext + │ └── ... + │ └── xxz.ext + └── class_y + ├── 123.ext + ├── nsdf3.ext + └── ... + └── asd932_.ext This method can be overridden to only consider a subset of classes, or to adapt to a different dataset directory structure. + + Args: + directory(str): Root directory path, corresponding to ``self.root`` + + Raises: + FileNotFoundError: If ``dir`` has no class folders. + + Returns: + (Tuple[List[str], Dict[str, int]]): List of all classes and dictionary mapping each class to an index. """ - return find_classes(dir) + return find_classes(directory) def __getitem__(self, index: int) -> Tuple[Any, Any]: """ @@ -267,7 +270,7 @@ def default_loader(path: str) -> Any: class ImageFolder(DatasetFolder): - """A generic data loader where the images are arranged in this way: :: + """A generic data loader where the images are arranged in this way by default: :: root/dog/xxx.png root/dog/xxy.png @@ -277,6 +280,9 @@ class ImageFolder(DatasetFolder): root/cat/nsdf3.png root/cat/[...]/asd932_.png + This class inherits from :class:`~torchvision.datasets.DatasetFolder` so + the same methods can be overridden to customize the dataset. + Args: root (string): Root directory path. transform (callable, optional): A function/transform that takes in an PIL image From 1b0bd0e32cef4d4c52abf599dd25583ca7859997 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 28 Apr 2021 19:15:20 +0100 Subject: [PATCH 022/279] [FBcode->GH] Parametrize test_perspective (#3748) (#3749) Summary: Pull Request resolved: https://github.com/pytorch/vision/pull/3748 This PR parametrizes the `perspective`-related tests, and avoids having deeply nested for-loops which will help debugging. "What" gets tested is left unchanged. The newly-introduced `cpu_and_gpu()` generator along with the `dont_collect` mark is a logic that allows to not run CPU tests on GPU machines (and vice versa). Reviewed By: fmassa Differential Revision: D27908299 fbshipit-source-id: 24a10a89fe90ae0a9e62de4bc7e768a669ebf212 --- test/common_utils.py | 24 +++++ test/conftest.py | 14 +++ test/test_functional_tensor.py | 188 ++++++++++++++++++--------------- 3 files changed, 143 insertions(+), 83 deletions(-) create mode 100644 test/conftest.py diff --git a/test/common_utils.py b/test/common_utils.py index 6c987cf9348..c5b39c451a3 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -402,3 +402,27 @@ def call_args_to_kwargs_only(call_args, *callable_or_arg_names): kwargs_only = kwargs.copy() kwargs_only.update(dict(zip(arg_names, args))) return kwargs_only + + +def cpu_and_gpu(): + import pytest # noqa + # ignore CPU tests in RE as they're already covered by another contbuild + IN_RE_WORKER = os.environ.get("INSIDE_RE_WORKER") is not None + IN_FBCODE = os.environ.get("IN_FBCODE_TORCHVISION") == "1" + CUDA_NOT_AVAILABLE_MSG = 'CUDA device not available' + + devices = [] if IN_RE_WORKER else ['cpu'] + + if torch.cuda.is_available(): + cuda_marks = () + elif IN_FBCODE: + # Dont collect cuda tests on fbcode if the machine doesnt have a GPU + # This avoids skipping the tests. More robust would be to detect if + # we're in sancastle instead of fbcode? + cuda_marks = pytest.mark.dont_collect() + else: + cuda_marks = pytest.mark.skip(reason=CUDA_NOT_AVAILABLE_MSG) + + devices.append(pytest.param('cuda', marks=cuda_marks)) + + return devices diff --git a/test/conftest.py b/test/conftest.py new file mode 100644 index 00000000000..6e10e4ef071 --- /dev/null +++ b/test/conftest.py @@ -0,0 +1,14 @@ +def pytest_configure(config): + # register an additional marker (see pytest_collection_modifyitems) + config.addinivalue_line( + "markers", "dont_collect: marks a test that should not be collected (avoids skipping it)" + ) + + +def pytest_collection_modifyitems(items): + # This hook is called by pytest after it has collected the tests (google its name!) + # We can ignore some tests as we see fit here. In particular we ignore the tests that + # we have marked with the custom 'dont_collect' mark. This avoids skipping the tests, + # since the internal fb infra doesn't like skipping tests. + to_keep = [item for item in items if item.get_closest_marker('dont_collect') is None] + items[:] = to_keep diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index d2bc4c8a7bc..1964e3134ec 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -1,17 +1,20 @@ +import itertools import os import unittest import colorsys import math import numpy as np +import pytest import torch import torchvision.transforms.functional_tensor as F_t import torchvision.transforms.functional_pil as F_pil import torchvision.transforms.functional as F +import torchvision.transforms as T from torchvision.transforms import InterpolationMode -from common_utils import TransformsTester +from common_utils import TransformsTester, cpu_and_gpu from typing import Dict, List, Sequence, Tuple @@ -19,6 +22,13 @@ NEAREST, BILINEAR, BICUBIC = InterpolationMode.NEAREST, InterpolationMode.BILINEAR, InterpolationMode.BICUBIC +@pytest.fixture(scope='module') +def tester(): + # instanciation of the Tester class used for equality assertions and other utilities + # TODO: remove this eventually when we don't need the class anymore + return Tester() + + class Tester(TransformsTester): def setUp(self): @@ -759,88 +769,6 @@ def test_rotate(self): res2 = F.rotate(tensor, 45, interpolation=BILINEAR) self.assertTrue(res1.equal(res2)) - def _test_perspective(self, tensor, pil_img, scripted_transform, test_configs): - dt = tensor.dtype - for f in [None, [0, 0, 0], [1, 2, 3], [255, 255, 255], [1, ], (2.0, )]: - for r in [NEAREST, ]: - for spoints, epoints in test_configs: - f_pil = int(f[0]) if f is not None and len(f) == 1 else f - out_pil_img = F.perspective(pil_img, startpoints=spoints, endpoints=epoints, interpolation=r, - fill=f_pil) - out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) - - for fn in [F.perspective, scripted_transform]: - out_tensor = fn(tensor, startpoints=spoints, endpoints=epoints, interpolation=r, fill=f).cpu() - - if out_tensor.dtype != torch.uint8: - out_tensor = out_tensor.to(torch.uint8) - - num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 - ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] - # Tolerance : less than 5% of different pixels - self.assertLess( - ratio_diff_pixels, - 0.05, - msg="{}: {}\n{} vs \n{}".format( - (f, r, dt, spoints, epoints), - ratio_diff_pixels, - out_tensor[0, :7, :7], - out_pil_tensor[0, :7, :7] - ) - ) - - def test_perspective(self): - - from torchvision.transforms import RandomPerspective - - data = [self._create_data(26, 34, device=self.device), self._create_data(26, 26, device=self.device)] - scripted_transform = torch.jit.script(F.perspective) - - for tensor, pil_img in data: - - test_configs = [ - [[[0, 0], [33, 0], [33, 25], [0, 25]], [[3, 2], [32, 3], [30, 24], [2, 25]]], - [[[3, 2], [32, 3], [30, 24], [2, 25]], [[0, 0], [33, 0], [33, 25], [0, 25]]], - [[[3, 2], [32, 3], [30, 24], [2, 25]], [[5, 5], [30, 3], [33, 19], [4, 25]]], - ] - n = 10 - test_configs += [ - RandomPerspective.get_params(pil_img.size[0], pil_img.size[1], i / n) for i in range(n) - ] - - for dt in [None, torch.float32, torch.float64, torch.float16]: - - if dt == torch.float16 and torch.device(self.device).type == "cpu": - # skip float16 on CPU case - continue - - if dt is not None: - tensor = tensor.to(dtype=dt) - - self._test_perspective(tensor, pil_img, scripted_transform, test_configs) - - batch_tensors = self._create_data_batch(26, 36, num_samples=4, device=self.device) - if dt is not None: - batch_tensors = batch_tensors.to(dtype=dt) - - # Ignore the equivalence between scripted and regular function on float16 cuda. The pixels at - # the border may be entirely different due to small rounding errors. - scripted_fn_atol = -1 if (dt == torch.float16 and self.device == "cuda") else 1e-8 - - for spoints, epoints in test_configs: - self._test_fn_on_batch( - batch_tensors, F.perspective, scripted_fn_atol=scripted_fn_atol, - startpoints=spoints, endpoints=epoints, interpolation=NEAREST - ) - - # assert changed type warning - spoints = [[0, 0], [33, 0], [33, 25], [0, 25]] - epoints = [[3, 2], [32, 3], [30, 24], [2, 25]] - with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): - res1 = F.perspective(tensor, startpoints=spoints, endpoints=epoints, interpolation=2) - res2 = F.perspective(tensor, startpoints=spoints, endpoints=epoints, interpolation=BILINEAR) - self.assertTrue(res1.equal(res2)) - def test_gaussian_blur(self): small_image_tensor = torch.from_numpy( np.arange(3 * 10 * 12, dtype="uint8").reshape((10, 12, 3)) @@ -996,5 +924,99 @@ def test_scale_channel(self): self.assertTrue(scaled_cpu.equal(scaled_cuda.to('cpu'))) +def _get_data_dims_and_points_for_perspective(): + # Ideally we would parametrize independently over data dims and points, but + # we want to tests on some points that also depend on the data dims. + # Pytest doesn't support covariant parametrization, so we do it somewhat manually here. + + data_dims = [(26, 34), (26, 26)] + points = [ + [[[0, 0], [33, 0], [33, 25], [0, 25]], [[3, 2], [32, 3], [30, 24], [2, 25]]], + [[[3, 2], [32, 3], [30, 24], [2, 25]], [[0, 0], [33, 0], [33, 25], [0, 25]]], + [[[3, 2], [32, 3], [30, 24], [2, 25]], [[5, 5], [30, 3], [33, 19], [4, 25]]], + ] + + dims_and_points = list(itertools.product(data_dims, points)) + + # up to here, we could just have used 2 @parametrized. + # Down below is the covarariant part as the points depend on the data dims. + + n = 10 + for dim in data_dims: + points += [ + (dim, T.RandomPerspective.get_params(dim[1], dim[0], i / n)) + for i in range(n) + ] + return dims_and_points + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dims_and_points', _get_data_dims_and_points_for_perspective()) +@pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) +@pytest.mark.parametrize('fill', (None, [0, 0, 0], [1, 2, 3], [255, 255, 255], [1, ], (2.0, ))) +@pytest.mark.parametrize('fn', [F.perspective, torch.jit.script(F.perspective)]) +def test_perspective_pil_vs_tensor(device, dims_and_points, dt, fill, fn, tester): + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + data_dims, (spoints, epoints) = dims_and_points + + tensor, pil_img = tester._create_data(*data_dims, device=device) + if dt is not None: + tensor = tensor.to(dtype=dt) + + interpolation = NEAREST + fill_pil = int(fill[0]) if fill is not None and len(fill) == 1 else fill + out_pil_img = F.perspective(pil_img, startpoints=spoints, endpoints=epoints, interpolation=interpolation, + fill=fill_pil) + out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) + out_tensor = fn(tensor, startpoints=spoints, endpoints=epoints, interpolation=interpolation, fill=fill).cpu() + + if out_tensor.dtype != torch.uint8: + out_tensor = out_tensor.to(torch.uint8) + + num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 + ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] + # Tolerance : less than 5% of different pixels + assert ratio_diff_pixels < 0.05 + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dims_and_points', _get_data_dims_and_points_for_perspective()) +@pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) +def test_perspective_batch(device, dims_and_points, dt, tester): + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + data_dims, (spoints, epoints) = dims_and_points + + batch_tensors = tester._create_data_batch(*data_dims, num_samples=4, device=device) + if dt is not None: + batch_tensors = batch_tensors.to(dtype=dt) + + # Ignore the equivalence between scripted and regular function on float16 cuda. The pixels at + # the border may be entirely different due to small rounding errors. + scripted_fn_atol = -1 if (dt == torch.float16 and device == "cuda") else 1e-8 + tester._test_fn_on_batch( + batch_tensors, F.perspective, scripted_fn_atol=scripted_fn_atol, + startpoints=spoints, endpoints=epoints, interpolation=NEAREST + ) + + +def test_perspective_interpolation_warning(tester): + # assert changed type warning + spoints = [[0, 0], [33, 0], [33, 25], [0, 25]] + epoints = [[3, 2], [32, 3], [30, 24], [2, 25]] + tensor = torch.randint(0, 256, (3, 26, 26)) + with tester.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): + res1 = F.perspective(tensor, startpoints=spoints, endpoints=epoints, interpolation=2) + res2 = F.perspective(tensor, startpoints=spoints, endpoints=epoints, interpolation=BILINEAR) + tester.assertTrue(res1.equal(res2)) + + if __name__ == '__main__': unittest.main() From cac8a97b0bd14eddeff56f87a890d5cc85776e18 Mon Sep 17 00:00:00 2001 From: Zhiqiang Wang Date: Thu, 29 Apr 2021 06:18:58 +0800 Subject: [PATCH 023/279] Keep consistency in Classes ConvBNActivation (#3750) * Keep consistency of ConvBNActivation * Simplify using the Python3 idiom Co-authored-by: Vasilis Vryniotis Co-authored-by: Vasilis Vryniotis --- torchvision/models/mobilenetv2.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/models/mobilenetv2.py b/torchvision/models/mobilenetv2.py index 386513b4071..3938156949f 100644 --- a/torchvision/models/mobilenetv2.py +++ b/torchvision/models/mobilenetv2.py @@ -46,7 +46,7 @@ def __init__( norm_layer = nn.BatchNorm2d if activation_layer is None: activation_layer = nn.ReLU6 - super(ConvBNReLU, self).__init__( + super().__init__( nn.Conv2d(in_planes, out_planes, kernel_size, stride, padding, dilation=dilation, groups=groups, bias=False), norm_layer(out_planes), From 58afa5110ce65c718dea676eccc5783d7e56d07a Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Thu, 29 Apr 2021 18:17:40 +0100 Subject: [PATCH 024/279] Removed caching from AnchorGenerator (#3745) --- torchvision/models/detection/anchor_utils.py | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) diff --git a/torchvision/models/detection/anchor_utils.py b/torchvision/models/detection/anchor_utils.py index bb38d55decc..ee9f2a1ab5a 100644 --- a/torchvision/models/detection/anchor_utils.py +++ b/torchvision/models/detection/anchor_utils.py @@ -1,7 +1,7 @@ import torch from torch import nn, Tensor -from typing import List, Optional, Dict +from typing import List, Optional from .image_list import ImageList @@ -28,7 +28,6 @@ class AnchorGenerator(nn.Module): __annotations__ = { "cell_anchors": Optional[List[torch.Tensor]], - "_cache": Dict[str, List[torch.Tensor]] } def __init__( @@ -49,7 +48,6 @@ def __init__( self.sizes = sizes self.aspect_ratios = aspect_ratios self.cell_anchors = None - self._cache = {} # TODO: https://github.com/pytorch/pytorch/issues/26792 # For every (aspect_ratios, scales) combination, output a zero-centered anchor with those values. @@ -131,14 +129,6 @@ def grid_anchors(self, grid_sizes: List[List[int]], strides: List[List[Tensor]]) return anchors - def cached_grid_anchors(self, grid_sizes: List[List[int]], strides: List[List[Tensor]]) -> List[Tensor]: - key = str(grid_sizes) + str(strides) - if key in self._cache: - return self._cache[key] - anchors = self.grid_anchors(grid_sizes, strides) - self._cache[key] = anchors - return anchors - def forward(self, image_list: ImageList, feature_maps: List[Tensor]) -> List[Tensor]: grid_sizes = list([feature_map.shape[-2:] for feature_map in feature_maps]) image_size = image_list.tensors.shape[-2:] @@ -146,12 +136,10 @@ def forward(self, image_list: ImageList, feature_maps: List[Tensor]) -> List[Ten strides = [[torch.tensor(image_size[0] // g[0], dtype=torch.int64, device=device), torch.tensor(image_size[1] // g[1], dtype=torch.int64, device=device)] for g in grid_sizes] self.set_cell_anchors(dtype, device) - anchors_over_all_feature_maps = self.cached_grid_anchors(grid_sizes, strides) + anchors_over_all_feature_maps = self.grid_anchors(grid_sizes, strides) anchors: List[List[torch.Tensor]] = [] for i in range(len(image_list.image_sizes)): anchors_in_image = [anchors_per_feature_map for anchors_per_feature_map in anchors_over_all_feature_maps] anchors.append(anchors_in_image) anchors = [torch.cat(anchors_per_image) for anchors_per_image in anchors] - # Clear the cache in case that memory leaks. - self._cache.clear() return anchors From 7c35e13337a611258e0403298a268224816881f8 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Fri, 30 Apr 2021 12:39:50 +0100 Subject: [PATCH 025/279] Refactored set_cell_anchors() in AnchorGenerator (#3755) * Refactored set_cell_anchors() in AnchorGenerator * Addressed review comment * Fixed test failure --- torchvision/models/detection/anchor_utils.py | 31 +++++--------------- 1 file changed, 8 insertions(+), 23 deletions(-) diff --git a/torchvision/models/detection/anchor_utils.py b/torchvision/models/detection/anchor_utils.py index ee9f2a1ab5a..9a63df1c943 100644 --- a/torchvision/models/detection/anchor_utils.py +++ b/torchvision/models/detection/anchor_utils.py @@ -1,7 +1,7 @@ import torch from torch import nn, Tensor -from typing import List, Optional +from typing import List from .image_list import ImageList @@ -27,7 +27,7 @@ class AnchorGenerator(nn.Module): """ __annotations__ = { - "cell_anchors": Optional[List[torch.Tensor]], + "cell_anchors": List[torch.Tensor], } def __init__( @@ -47,7 +47,8 @@ def __init__( self.sizes = sizes self.aspect_ratios = aspect_ratios - self.cell_anchors = None + self.cell_anchors = [self.generate_anchors(size, aspect_ratio) + for size, aspect_ratio in zip(sizes, aspect_ratios)] # TODO: https://github.com/pytorch/pytorch/issues/26792 # For every (aspect_ratios, scales) combination, output a zero-centered anchor with those values. @@ -67,24 +68,8 @@ def generate_anchors(self, scales: List[int], aspect_ratios: List[float], dtype: return base_anchors.round() def set_cell_anchors(self, dtype: torch.dtype, device: torch.device): - if self.cell_anchors is not None: - cell_anchors = self.cell_anchors - assert cell_anchors is not None - # suppose that all anchors have the same device - # which is a valid assumption in the current state of the codebase - if cell_anchors[0].device == device: - return - - cell_anchors = [ - self.generate_anchors( - sizes, - aspect_ratios, - dtype, - device - ) - for sizes, aspect_ratios in zip(self.sizes, self.aspect_ratios) - ] - self.cell_anchors = cell_anchors + self.cell_anchors = [cell_anchor.to(dtype=dtype, device=device) + for cell_anchor in self.cell_anchors] def num_anchors_per_location(self): return [len(s) * len(a) for s, a in zip(self.sizes, self.aspect_ratios)] @@ -130,7 +115,7 @@ def grid_anchors(self, grid_sizes: List[List[int]], strides: List[List[Tensor]]) return anchors def forward(self, image_list: ImageList, feature_maps: List[Tensor]) -> List[Tensor]: - grid_sizes = list([feature_map.shape[-2:] for feature_map in feature_maps]) + grid_sizes = [feature_map.shape[-2:] for feature_map in feature_maps] image_size = image_list.tensors.shape[-2:] dtype, device = feature_maps[0].dtype, feature_maps[0].device strides = [[torch.tensor(image_size[0] // g[0], dtype=torch.int64, device=device), @@ -138,7 +123,7 @@ def forward(self, image_list: ImageList, feature_maps: List[Tensor]) -> List[Ten self.set_cell_anchors(dtype, device) anchors_over_all_feature_maps = self.grid_anchors(grid_sizes, strides) anchors: List[List[torch.Tensor]] = [] - for i in range(len(image_list.image_sizes)): + for _ in range(len(image_list.image_sizes)): anchors_in_image = [anchors_per_feature_map for anchors_per_feature_map in anchors_over_all_feature_maps] anchors.append(anchors_in_image) anchors = [torch.cat(anchors_per_image) for anchors_per_image in anchors] From 730c5e1eab130e2900c8e839ea08fa11f024516f Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 30 Apr 2021 16:30:26 +0000 Subject: [PATCH 026/279] Add SSD architecture with VGG16 backbone (#3403) * Early skeleton of API. * Adding MultiFeatureMap and vgg16 backbone. * Making vgg16 backbone same as paper. * Making code generic to support all vggs. * Moving vgg's extra layers a separate class + L2 scaling. * Adding header vgg layers. * Fix maxpool patching. * Refactoring code to allow for support of different backbones & sizes: - Skeleton for Default Boxes generator class - Dynamic estimation of configuration when possible - Addition of types * Complete the implementation of DefaultBox generator. * Replace randn with empty. * Minor refactoring * Making clamping between 0 and 1 optional. * Change xywh to xyxy encoding. * Adding parameters and reusing objects in constructor. * Temporarily inherit from Retina to avoid dup code. * Implement forward methods + temp workarounds to inherit from retina. * Inherit more methods from retinanet. * Fix type error. * Add Regression loss. * Fixing JIT issues. * Change JIT workaround to minimize new code. * Fixing initialization bug. * Add classification loss. * Update todos. * Add weight loading support. * Support SSD512. * Change kernel_size to get output size 1x1 * Add xavier init and refactoring. * Adding unit-tests and fixing JIT issues. * Add a test for dbox generator. * Remove unnecessary import. * Workaround on GeneralizedRCNNTransform to support fixed size input. * Remove unnecessary random calls from the test. * Remove more rand calls from the test. * change mapping and handling of empty labels * Fix JIT warnings. * Speed up loss. * Convert 0-1 dboxes to original size. * Fix warning. * Fix tests. * Update comments. * Fixing minor bugs. * Introduce a custom DBoxMatcher. * Minor refactoring * Move extra layer definition inside feature extractor. * handle no bias on init. * Remove fixed image size limitation * Change initialization values for bias of classification head. * Refactoring and update test file. * Adding ResNet backbone. * Minor refactoring. * Remove inheritance of retina and general refactoring. * SSD should fix the input size. * Fixing messages and comments. * Silently ignoring exception if test-only. * Update comments. * Update regression loss. * Restore Xavier init everywhere, update the negative sampling method, change the clipping approach. * Fixing tests. * Refactor to move the losses from the Head to the SSD. * Removing resnet50 ssd version. * Adding support for best performing backbone and its config. * Refactor and clean up the API. * Fix lint * Update todos and comments. * Adding RandomHorizontalFlip and RandomIoUCrop transforms. * Adding necessary checks to our tranforms. * Adding RandomZoomOut. * Adding RandomPhotometricDistort. * Moving Detection transforms to references. * Update presets * fix lint * leave compose and object * Adding scaling for completeness. * Adding params in the repr * Remove unnecessary import. * minor refactoring * Remove unnecessary call. * Give better names to DBox* classes * Port num_anchors estimation in generator * Remove rescaling and fix presets * Add the ability to pass a custom head and refactoring. * fix lint * Fix unit-test * Update todos. * Change mean values. * Change the default parameter of SSD to train the full VGG16 and remove the catch of exception for eval only. * Adding documentation * Adding weights and updating readmes. * Update the model weights with a more performing model. * Adding doc for head. * Restore import. --- docs/source/models.rst | 19 +- references/detection/README.md | 8 + references/detection/presets.py | 22 +- references/detection/train.py | 10 +- references/detection/transforms.py | 230 ++++++- .../ModelTester.test_ssd300_vgg16_expect.pkl | Bin 0 -> 6925 bytes test/test_models.py | 1 + test/test_models_detection_anchor_utils.py | 32 +- .../test_models_detection_negative_samples.py | 9 + torchvision/models/detection/__init__.py | 1 + torchvision/models/detection/_utils.py | 50 +- torchvision/models/detection/anchor_utils.py | 97 ++- torchvision/models/detection/ssd.py | 564 ++++++++++++++++++ torchvision/models/detection/transform.py | 46 +- 14 files changed, 1032 insertions(+), 57 deletions(-) create mode 100644 test/expect/ModelTester.test_ssd300_vgg16_expect.pkl create mode 100644 torchvision/models/detection/ssd.py diff --git a/docs/source/models.rst b/docs/source/models.rst index 09ec450574b..c70cd07979f 100644 --- a/docs/source/models.rst +++ b/docs/source/models.rst @@ -381,17 +381,18 @@ Object Detection, Instance Segmentation and Person Keypoint Detection The models subpackage contains definitions for the following model architectures for detection: -- `Faster R-CNN ResNet-50 FPN `_ -- `Mask R-CNN ResNet-50 FPN `_ +- `Faster R-CNN `_ +- `Mask R-CNN `_ +- `RetinaNet `_ +- `SSD `_ The pre-trained models for detection, instance segmentation and keypoint detection are initialized with the classification models in torchvision. The models expect a list of ``Tensor[C, H, W]``, in the range ``0-1``. -The models internally resize the images so that they have a minimum size -of ``800``. This option can be changed by passing the option ``min_size`` -to the constructor of the models. +The models internally resize the images but the behaviour varies depending +on the model. Check the constructor of the models for more information. For object detection and instance segmentation, the pre-trained @@ -425,6 +426,7 @@ Faster R-CNN ResNet-50 FPN 37.0 - - Faster R-CNN MobileNetV3-Large FPN 32.8 - - Faster R-CNN MobileNetV3-Large 320 FPN 22.8 - - RetinaNet ResNet-50 FPN 36.4 - - +SSD VGG16 25.1 - - Mask R-CNN ResNet-50 FPN 37.9 34.6 - ====================================== ======= ======== =========== @@ -483,6 +485,7 @@ Faster R-CNN ResNet-50 FPN 0.2288 0.0590 Faster R-CNN MobileNetV3-Large FPN 0.1020 0.0415 1.0 Faster R-CNN MobileNetV3-Large 320 FPN 0.0978 0.0376 0.6 RetinaNet ResNet-50 FPN 0.2514 0.0939 4.1 +SSD VGG16 0.2093 0.0744 1.5 Mask R-CNN ResNet-50 FPN 0.2728 0.0903 5.4 Keypoint R-CNN ResNet-50 FPN 0.3789 0.1242 6.8 ====================================== =================== ================== =========== @@ -502,6 +505,12 @@ RetinaNet .. autofunction:: torchvision.models.detection.retinanet_resnet50_fpn +SSD +------------ + +.. autofunction:: torchvision.models.detection.ssd300_vgg16 + + Mask R-CNN ---------- diff --git a/references/detection/README.md b/references/detection/README.md index c8eaf46da5f..e4d52869d35 100644 --- a/references/detection/README.md +++ b/references/detection/README.md @@ -48,6 +48,14 @@ python -m torch.distributed.launch --nproc_per_node=8 --use_env train.py\ --lr-steps 16 22 --aspect-ratio-group-factor 3 --lr 0.01 ``` +### SSD VGG16 +``` +python -m torch.distributed.launch --nproc_per_node=8 --use_env train.py\ + --dataset coco --model ssd300_vgg16 --epochs 120\ + --lr-steps 80 110 --aspect-ratio-group-factor 3 --lr 0.002 --batch-size 4\ + --weight-decay 0.0005 --data-augmentation ssd +``` + ### Mask R-CNN ``` diff --git a/references/detection/presets.py b/references/detection/presets.py index b0c86ed1265..22937cf9576 100644 --- a/references/detection/presets.py +++ b/references/detection/presets.py @@ -2,12 +2,22 @@ class DetectionPresetTrain: - def __init__(self, hflip_prob=0.5): - trans = [T.ToTensor()] - if hflip_prob > 0: - trans.append(T.RandomHorizontalFlip(hflip_prob)) - - self.transforms = T.Compose(trans) + def __init__(self, data_augmentation, hflip_prob=0.5, mean=(123., 117., 104.)): + if data_augmentation == 'hflip': + self.transforms = T.Compose([ + T.RandomHorizontalFlip(p=hflip_prob), + T.ToTensor(), + ]) + elif data_augmentation == 'ssd': + self.transforms = T.Compose([ + T.RandomPhotometricDistort(), + T.RandomZoomOut(fill=list(mean)), + T.RandomIoUCrop(), + T.RandomHorizontalFlip(p=hflip_prob), + T.ToTensor(), + ]) + else: + raise ValueError(f'Unknown data augmentation policy "{data_augmentation}"') def __call__(self, img, target): return self.transforms(img, target) diff --git a/references/detection/train.py b/references/detection/train.py index 83fad36d2cc..81f170e73d0 100644 --- a/references/detection/train.py +++ b/references/detection/train.py @@ -47,8 +47,8 @@ def get_dataset(name, image_set, transform, data_path): return ds, num_classes -def get_transform(train): - return presets.DetectionPresetTrain() if train else presets.DetectionPresetEval() +def get_transform(train, data_augmentation): + return presets.DetectionPresetTrain(data_augmentation) if train else presets.DetectionPresetEval() def main(args): @@ -60,8 +60,9 @@ def main(args): # Data loading code print("Loading data") - dataset, num_classes = get_dataset(args.dataset, "train", get_transform(train=True), args.data_path) - dataset_test, _ = get_dataset(args.dataset, "val", get_transform(train=False), args.data_path) + dataset, num_classes = get_dataset(args.dataset, "train", get_transform(True, args.data_augmentation), + args.data_path) + dataset_test, _ = get_dataset(args.dataset, "val", get_transform(False, args.data_augmentation), args.data_path) print("Creating data loaders") if args.distributed: @@ -179,6 +180,7 @@ def main(args): parser.add_argument('--rpn-score-thresh', default=None, type=float, help='rpn score threshold for faster-rcnn') parser.add_argument('--trainable-backbone-layers', default=None, type=int, help='number of trainable layers of backbone') + parser.add_argument('--data-augmentation', default="hflip", help='data augmentation policy (default: hflip)') parser.add_argument( "--test-only", dest="test_only", diff --git a/references/detection/transforms.py b/references/detection/transforms.py index 937ae3c07fc..8e4b8870eaf 100644 --- a/references/detection/transforms.py +++ b/references/detection/transforms.py @@ -1,6 +1,10 @@ -import random +import torch +import torchvision +from torch import nn, Tensor from torchvision.transforms import functional as F +from torchvision.transforms import transforms as T +from typing import List, Tuple, Dict, Optional def _flip_coco_person_keypoints(kps, width): @@ -23,27 +27,213 @@ def __call__(self, image, target): return image, target -class RandomHorizontalFlip(object): - def __init__(self, prob): - self.prob = prob - - def __call__(self, image, target): - if random.random() < self.prob: - height, width = image.shape[-2:] - image = image.flip(-1) - bbox = target["boxes"] - bbox[:, [0, 2]] = width - bbox[:, [2, 0]] - target["boxes"] = bbox - if "masks" in target: - target["masks"] = target["masks"].flip(-1) - if "keypoints" in target: - keypoints = target["keypoints"] - keypoints = _flip_coco_person_keypoints(keypoints, width) - target["keypoints"] = keypoints +class RandomHorizontalFlip(T.RandomHorizontalFlip): + def forward(self, image: Tensor, + target: Optional[Dict[str, Tensor]] = None) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]: + if torch.rand(1) < self.p: + image = F.hflip(image) + if target is not None: + width, _ = F._get_image_size(image) + target["boxes"][:, [0, 2]] = width - target["boxes"][:, [2, 0]] + if "masks" in target: + target["masks"] = target["masks"].flip(-1) + if "keypoints" in target: + keypoints = target["keypoints"] + keypoints = _flip_coco_person_keypoints(keypoints, width) + target["keypoints"] = keypoints return image, target -class ToTensor(object): - def __call__(self, image, target): +class ToTensor(nn.Module): + def forward(self, image: Tensor, + target: Optional[Dict[str, Tensor]] = None) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]: image = F.to_tensor(image) return image, target + + +class RandomIoUCrop(nn.Module): + def __init__(self, min_scale: float = 0.3, max_scale: float = 1.0, min_aspect_ratio: float = 0.5, + max_aspect_ratio: float = 2.0, sampler_options: Optional[List[float]] = None, trials: int = 40): + super().__init__() + # Configuration similar to https://github.com/weiliu89/caffe/blob/ssd/examples/ssd/ssd_coco.py#L89-L174 + self.min_scale = min_scale + self.max_scale = max_scale + self.min_aspect_ratio = min_aspect_ratio + self.max_aspect_ratio = max_aspect_ratio + if sampler_options is None: + sampler_options = [0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0] + self.options = sampler_options + self.trials = trials + + def forward(self, image: Tensor, + target: Optional[Dict[str, Tensor]] = None) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]: + if target is None: + raise ValueError("The targets can't be None for this transform.") + + if isinstance(image, torch.Tensor): + if image.ndimension() not in {2, 3}: + raise ValueError('image should be 2/3 dimensional. Got {} dimensions.'.format(image.ndimension())) + elif image.ndimension() == 2: + image = image.unsqueeze(0) + + orig_w, orig_h = F._get_image_size(image) + + while True: + # sample an option + idx = int(torch.randint(low=0, high=len(self.options), size=(1,))) + min_jaccard_overlap = self.options[idx] + if min_jaccard_overlap >= 1.0: # a value larger than 1 encodes the leave as-is option + return image, target + + for _ in range(self.trials): + # check the aspect ratio limitations + r = self.min_scale + (self.max_scale - self.min_scale) * torch.rand(2) + new_w = int(orig_w * r[0]) + new_h = int(orig_h * r[1]) + aspect_ratio = new_w / new_h + if not (self.min_aspect_ratio <= aspect_ratio <= self.max_aspect_ratio): + continue + + # check for 0 area crops + r = torch.rand(2) + left = int((orig_w - new_w) * r[0]) + top = int((orig_h - new_h) * r[1]) + right = left + new_w + bottom = top + new_h + if left == right or top == bottom: + continue + + # check for any valid boxes with centers within the crop area + cx = 0.5 * (target["boxes"][:, 0] + target["boxes"][:, 2]) + cy = 0.5 * (target["boxes"][:, 1] + target["boxes"][:, 3]) + is_within_crop_area = (left < cx) & (cx < right) & (top < cy) & (cy < bottom) + if not is_within_crop_area.any(): + continue + + # check at least 1 box with jaccard limitations + boxes = target["boxes"][is_within_crop_area] + ious = torchvision.ops.boxes.box_iou(boxes, torch.tensor([[left, top, right, bottom]], + dtype=boxes.dtype, device=boxes.device)) + if ious.max() < min_jaccard_overlap: + continue + + # keep only valid boxes and perform cropping + target["boxes"] = boxes + target["labels"] = target["labels"][is_within_crop_area] + target["boxes"][:, 0::2] -= left + target["boxes"][:, 1::2] -= top + target["boxes"][:, 0::2].clamp_(min=0, max=new_w) + target["boxes"][:, 1::2].clamp_(min=0, max=new_h) + image = F.crop(image, top, left, new_h, new_w) + + return image, target + + +class RandomZoomOut(nn.Module): + def __init__(self, fill: Optional[List[float]] = None, side_range: Tuple[float, float] = (1., 4.), p: float = 0.5): + super().__init__() + if fill is None: + fill = [0., 0., 0.] + self.fill = fill + self.side_range = side_range + if side_range[0] < 1. or side_range[0] > side_range[1]: + raise ValueError("Invalid canvas side range provided {}.".format(side_range)) + self.p = p + + @torch.jit.unused + def _get_fill_value(self, is_pil): + # type: (bool) -> int + # We fake the type to make it work on JIT + return tuple(int(x) for x in self.fill) if is_pil else 0 + + def forward(self, image: Tensor, + target: Optional[Dict[str, Tensor]] = None) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]: + if isinstance(image, torch.Tensor): + if image.ndimension() not in {2, 3}: + raise ValueError('image should be 2/3 dimensional. Got {} dimensions.'.format(image.ndimension())) + elif image.ndimension() == 2: + image = image.unsqueeze(0) + + if torch.rand(1) < self.p: + return image, target + + orig_w, orig_h = F._get_image_size(image) + + r = self.side_range[0] + torch.rand(1) * (self.side_range[1] - self.side_range[0]) + canvas_width = int(orig_w * r) + canvas_height = int(orig_h * r) + + r = torch.rand(2) + left = int((canvas_width - orig_w) * r[0]) + top = int((canvas_height - orig_h) * r[1]) + right = canvas_width - (left + orig_w) + bottom = canvas_height - (top + orig_h) + + if torch.jit.is_scripting(): + fill = 0 + else: + fill = self._get_fill_value(F._is_pil_image(image)) + + image = F.pad(image, [left, top, right, bottom], fill=fill) + if isinstance(image, torch.Tensor): + v = torch.tensor(self.fill, device=image.device, dtype=image.dtype).view(-1, 1, 1) + image[..., :top, :] = image[..., :, :left] = image[..., (top + orig_h):, :] = \ + image[..., :, (left + orig_w):] = v + + if target is not None: + target["boxes"][:, 0::2] += left + target["boxes"][:, 1::2] += top + + return image, target + + +class RandomPhotometricDistort(nn.Module): + def __init__(self, contrast: Tuple[float] = (0.5, 1.5), saturation: Tuple[float] = (0.5, 1.5), + hue: Tuple[float] = (-0.05, 0.05), brightness: Tuple[float] = (0.875, 1.125), p: float = 0.5): + super().__init__() + self._brightness = T.ColorJitter(brightness=brightness) + self._contrast = T.ColorJitter(contrast=contrast) + self._hue = T.ColorJitter(hue=hue) + self._saturation = T.ColorJitter(saturation=saturation) + self.p = p + + def forward(self, image: Tensor, + target: Optional[Dict[str, Tensor]] = None) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]: + if isinstance(image, torch.Tensor): + if image.ndimension() not in {2, 3}: + raise ValueError('image should be 2/3 dimensional. Got {} dimensions.'.format(image.ndimension())) + elif image.ndimension() == 2: + image = image.unsqueeze(0) + + r = torch.rand(7) + + if r[0] < self.p: + image = self._brightness(image) + + contrast_before = r[1] < 0.5 + if contrast_before: + if r[2] < self.p: + image = self._contrast(image) + + if r[3] < self.p: + image = self._saturation(image) + + if r[4] < self.p: + image = self._hue(image) + + if not contrast_before: + if r[5] < self.p: + image = self._contrast(image) + + if r[6] < self.p: + channels = F._get_image_num_channels(image) + permutation = torch.randperm(channels) + + is_pil = F._is_pil_image(image) + if is_pil: + image = F.to_tensor(image) + image = image[..., permutation, :, :] + if is_pil: + image = F.to_pil_image(image) + + return image, target diff --git a/test/expect/ModelTester.test_ssd300_vgg16_expect.pkl b/test/expect/ModelTester.test_ssd300_vgg16_expect.pkl new file mode 100644 index 0000000000000000000000000000000000000000..0bfa91467d36228a5679c02e9441d3dcdeb4def6 GIT binary patch literal 6925 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 List[Ten anchors.append(anchors_in_image) anchors = [torch.cat(anchors_per_image) for anchors_per_image in anchors] return anchors + + +class DefaultBoxGenerator(nn.Module): + """ + This module generates the default boxes of SSD for a set of feature maps and image sizes. + + Args: + aspect_ratios (List[List[int]]): A list with all the aspect ratios used in each feature map. + min_ratio (float): The minimum scale :math:`\text{s}_{\text{min}}` of the default boxes used in the estimation + of the scales of each feature map. + max_ratio (float): The maximum scale :math:`\text{s}_{\text{max}}` of the default boxes used in the estimation + of the scales of each feature map. + steps (List[int]], optional): It's a hyper-parameter that affects the tiling of defalt boxes. If not provided + it will be estimated from the data. + clip (bool): Whether the standardized values of default boxes should be clipped between 0 and 1. The clipping + is applied while the boxes are encoded in format ``(cx, cy, w, h)``. + """ + + def __init__(self, aspect_ratios: List[List[int]], min_ratio: float = 0.15, max_ratio: float = 0.9, + steps: Optional[List[int]] = None, clip: bool = True): + super().__init__() + if steps is not None: + assert len(aspect_ratios) == len(steps) + self.aspect_ratios = aspect_ratios + self.steps = steps + self.clip = clip + num_outputs = len(aspect_ratios) + + # Estimation of default boxes scales + # Inspired from https://github.com/weiliu89/caffe/blob/ssd/examples/ssd/ssd_pascal.py#L311-L317 + min_centile = int(100 * min_ratio) + max_centile = int(100 * max_ratio) + conv4_centile = min_centile // 2 # assume half of min_ratio as in paper + step = (max_centile - min_centile) // (num_outputs - 2) + centiles = [conv4_centile, min_centile] + for c in range(min_centile, max_centile + 1, step): + centiles.append(c + step) + self.scales = [c / 100 for c in centiles] + + self._wh_pairs = [] + for k in range(num_outputs): + # Adding the 2 default width-height pairs for aspect ratio 1 and scale s'k + s_k = self.scales[k] + s_prime_k = math.sqrt(self.scales[k] * self.scales[k + 1]) + wh_pairs = [(s_k, s_k), (s_prime_k, s_prime_k)] + + # Adding 2 pairs for each aspect ratio of the feature map k + for ar in self.aspect_ratios[k]: + sq_ar = math.sqrt(ar) + w = self.scales[k] * sq_ar + h = self.scales[k] / sq_ar + wh_pairs.extend([(w, h), (h, w)]) + + self._wh_pairs.append(wh_pairs) + + def num_anchors_per_location(self): + # Estimate num of anchors based on aspect ratios: 2 default boxes + 2 * ratios of feaure map. + return [2 + 2 * len(r) for r in self.aspect_ratios] + + def __repr__(self) -> str: + s = self.__class__.__name__ + '(' + s += 'aspect_ratios={aspect_ratios}' + s += ', clip={clip}' + s += ', scales={scales}' + s += ', steps={steps}' + s += ')' + return s.format(**self.__dict__) + + def forward(self, image_list: ImageList, feature_maps: List[Tensor]) -> List[Tensor]: + grid_sizes = [feature_map.shape[-2:] for feature_map in feature_maps] + image_size = image_list.tensors.shape[-2:] + dtype, device = feature_maps[0].dtype, feature_maps[0].device + + # Default Boxes calculation based on page 6 of SSD paper + default_boxes: List[List[float]] = [] + for k, f_k in enumerate(grid_sizes): + # Now add the default boxes for each width-height pair + for j in range(f_k[0]): + cy = (j + 0.5) / (float(f_k[0]) if self.steps is None else image_size[1] / self.steps[k]) + for i in range(f_k[1]): + cx = (i + 0.5) / (float(f_k[1]) if self.steps is None else image_size[0] / self.steps[k]) + default_boxes.extend([[cx, cy, w, h] for w, h in self._wh_pairs[k]]) + + dboxes = [] + for _ in image_list.image_sizes: + dboxes_in_image = torch.tensor(default_boxes, dtype=dtype, device=device) + if self.clip: + dboxes_in_image.clamp_(min=0, max=1) + dboxes_in_image = torch.cat([dboxes_in_image[:, :2] - 0.5 * dboxes_in_image[:, 2:], + dboxes_in_image[:, :2] + 0.5 * dboxes_in_image[:, 2:]], -1) + dboxes_in_image[:, 0::2] *= image_size[1] + dboxes_in_image[:, 1::2] *= image_size[0] + dboxes.append(dboxes_in_image) + return dboxes diff --git a/torchvision/models/detection/ssd.py b/torchvision/models/detection/ssd.py new file mode 100644 index 00000000000..fcb79d6e651 --- /dev/null +++ b/torchvision/models/detection/ssd.py @@ -0,0 +1,564 @@ +import torch +import torch.nn.functional as F +import warnings + +from collections import OrderedDict +from torch import nn, Tensor +from typing import Any, Dict, List, Optional, Tuple + +from . import _utils as det_utils +from .anchor_utils import DefaultBoxGenerator +from .backbone_utils import _validate_trainable_layers +from .transform import GeneralizedRCNNTransform +from .. import vgg +from ..utils import load_state_dict_from_url +from ...ops import boxes as box_ops + +__all__ = ['SSD', 'ssd300_vgg16'] + +model_urls = { + 'ssd300_vgg16_coco': 'https://download.pytorch.org/models/ssd300_vgg16_coco-b556d3b4.pth', +} + +backbone_urls = { + # We port the features of a VGG16 backbone trained by amdegroot because unlike the one on TorchVision, it uses the + # same input standardization method as the paper. Ref: https://s3.amazonaws.com/amdegroot-models/vgg16_reducedfc.pth + 'vgg16_features': 'https://download.pytorch.org/models/vgg16_features-amdegroot.pth' +} + + +def _xavier_init(conv: nn.Module): + for layer in conv.modules(): + if isinstance(layer, nn.Conv2d): + torch.nn.init.xavier_uniform_(layer.weight) + if layer.bias is not None: + torch.nn.init.constant_(layer.bias, 0.0) + + +class SSDHead(nn.Module): + def __init__(self, in_channels: List[int], num_anchors: List[int], num_classes: int): + super().__init__() + self.classification_head = SSDClassificationHead(in_channels, num_anchors, num_classes) + self.regression_head = SSDRegressionHead(in_channels, num_anchors) + + def forward(self, x: List[Tensor]) -> Dict[str, Tensor]: + return { + 'bbox_regression': self.regression_head(x), + 'cls_logits': self.classification_head(x), + } + + +class SSDScoringHead(nn.Module): + def __init__(self, module_list: nn.ModuleList, num_columns: int): + super().__init__() + self.module_list = module_list + self.num_columns = num_columns + + def _get_result_from_module_list(self, x: Tensor, idx: int) -> Tensor: + """ + This is equivalent to self.module_list[idx](x), + but torchscript doesn't support this yet + """ + num_blocks = len(self.module_list) + if idx < 0: + idx += num_blocks + i = 0 + out = x + for module in self.module_list: + if i == idx: + out = module(x) + i += 1 + return out + + def forward(self, x: List[Tensor]) -> Tensor: + all_results = [] + + for i, features in enumerate(x): + results = self._get_result_from_module_list(features, i) + + # Permute output from (N, A * K, H, W) to (N, HWA, K). + N, _, H, W = results.shape + results = results.view(N, -1, self.num_columns, H, W) + results = results.permute(0, 3, 4, 1, 2) + results = results.reshape(N, -1, self.num_columns) # Size=(N, HWA, K) + + all_results.append(results) + + return torch.cat(all_results, dim=1) + + +class SSDClassificationHead(SSDScoringHead): + def __init__(self, in_channels: List[int], num_anchors: List[int], num_classes: int): + cls_logits = nn.ModuleList() + for channels, anchors in zip(in_channels, num_anchors): + cls_logits.append(nn.Conv2d(channels, num_classes * anchors, kernel_size=3, padding=1)) + _xavier_init(cls_logits) + super().__init__(cls_logits, num_classes) + + +class SSDRegressionHead(SSDScoringHead): + def __init__(self, in_channels: List[int], num_anchors: List[int]): + bbox_reg = nn.ModuleList() + for channels, anchors in zip(in_channels, num_anchors): + bbox_reg.append(nn.Conv2d(channels, 4 * anchors, kernel_size=3, padding=1)) + _xavier_init(bbox_reg) + super().__init__(bbox_reg, 4) + + +class SSD(nn.Module): + """ + Implements SSD architecture from `"SSD: Single Shot MultiBox Detector" `_. + + The input to the model is expected to be a list of tensors, each of shape [C, H, W], one for each + image, and should be in 0-1 range. Different images can have different sizes but they will be resized + to a fixed size before passing it to the backbone. + + The behavior of the model changes depending if it is in training or evaluation mode. + + During training, the model expects both the input tensors, as well as a targets (list of dictionary), + containing: + - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with + ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. + - labels (Int64Tensor[N]): the class label for each ground-truth box + + The model returns a Dict[Tensor] during training, containing the classification and regression + losses. + + During inference, the model requires only the input tensors, and returns the post-processed + predictions as a List[Dict[Tensor]], one for each input image. The fields of the Dict are as + follows: + - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with + ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. + - labels (Int64Tensor[N]): the predicted labels for each image + - scores (Tensor[N]): the scores for each prediction + + Args: + backbone (nn.Module): the network used to compute the features for the model. + It should contain an out_channels attribute with the list of the output channels of + each feature map. The backbone should return a single Tensor or an OrderedDict[Tensor]. + anchor_generator (DefaultBoxGenerator): module that generates the default boxes for a + set of feature maps. + size (Tuple[int, int]): the width and height to which images will be rescaled before feeding them + to the backbone. + num_classes (int): number of output classes of the model (excluding the background). + image_mean (Tuple[float, float, float]): mean values used for input normalization. + They are generally the mean values of the dataset on which the backbone has been trained + on + image_std (Tuple[float, float, float]): std values used for input normalization. + They are generally the std values of the dataset on which the backbone has been trained on + head (nn.Module, optional): Module run on top of the backbone features. Defaults to a module containing + a classification and regression module. + score_thresh (float): Score threshold used for postprocessing the detections. + nms_thresh (float): NMS threshold used for postprocessing the detections. + detections_per_img (int): Number of best detections to keep after NMS. + iou_thresh (float): minimum IoU between the anchor and the GT box so that they can be + considered as positive during training. + topk_candidates (int): Number of best detections to keep before NMS. + positive_fraction (float): a number between 0 and 1 which indicates the proportion of positive + proposals used during the training of the classification head. It is used to estimate the negative to + positive ratio. + """ + __annotations__ = { + 'box_coder': det_utils.BoxCoder, + 'proposal_matcher': det_utils.Matcher, + } + + def __init__(self, backbone: nn.Module, anchor_generator: DefaultBoxGenerator, + size: Tuple[int, int], num_classes: int, + image_mean: Optional[List[float]] = None, image_std: Optional[List[float]] = None, + head: Optional[nn.Module] = None, + score_thresh: float = 0.01, + nms_thresh: float = 0.45, + detections_per_img: int = 200, + iou_thresh: float = 0.5, + topk_candidates: int = 400, + positive_fraction: float = 0.25): + super().__init__() + + self.backbone = backbone + + self.anchor_generator = anchor_generator + + self.box_coder = det_utils.BoxCoder(weights=(10., 10., 5., 5.)) + + if head is None: + if hasattr(backbone, 'out_channels'): + out_channels = backbone.out_channels + else: + out_channels = det_utils.retrieve_out_channels(backbone, size) + + assert len(out_channels) == len(anchor_generator.aspect_ratios) + + num_anchors = self.anchor_generator.num_anchors_per_location() + head = SSDHead(out_channels, num_anchors, num_classes) + self.head = head + + self.proposal_matcher = det_utils.SSDMatcher(iou_thresh) + + if image_mean is None: + image_mean = [0.485, 0.456, 0.406] + if image_std is None: + image_std = [0.229, 0.224, 0.225] + self.transform = GeneralizedRCNNTransform(min(size), max(size), image_mean, image_std, + size_divisible=1, fixed_size=size) + + self.score_thresh = score_thresh + self.nms_thresh = nms_thresh + self.detections_per_img = detections_per_img + self.topk_candidates = topk_candidates + self.neg_to_pos_ratio = (1.0 - positive_fraction) / positive_fraction + + # used only on torchscript mode + self._has_warned = False + + @torch.jit.unused + def eager_outputs(self, losses: Dict[str, Tensor], + detections: List[Dict[str, Tensor]]) -> Tuple[Dict[str, Tensor], List[Dict[str, Tensor]]]: + if self.training: + return losses + + return detections + + def compute_loss(self, targets: List[Dict[str, Tensor]], head_outputs: Dict[str, Tensor], anchors: List[Tensor], + matched_idxs: List[Tensor]) -> Dict[str, Tensor]: + bbox_regression = head_outputs['bbox_regression'] + cls_logits = head_outputs['cls_logits'] + + # Match original targets with default boxes + num_foreground = 0 + bbox_loss = [] + cls_targets = [] + for (targets_per_image, bbox_regression_per_image, cls_logits_per_image, anchors_per_image, + matched_idxs_per_image) in zip(targets, bbox_regression, cls_logits, anchors, matched_idxs): + # produce the matching between boxes and targets + foreground_idxs_per_image = torch.where(matched_idxs_per_image >= 0)[0] + foreground_matched_idxs_per_image = matched_idxs_per_image[foreground_idxs_per_image] + num_foreground += foreground_matched_idxs_per_image.numel() + + # Calculate regression loss + matched_gt_boxes_per_image = targets_per_image['boxes'][foreground_matched_idxs_per_image] + bbox_regression_per_image = bbox_regression_per_image[foreground_idxs_per_image, :] + anchors_per_image = anchors_per_image[foreground_idxs_per_image, :] + target_regression = self.box_coder.encode_single(matched_gt_boxes_per_image, anchors_per_image) + bbox_loss.append(torch.nn.functional.smooth_l1_loss( + bbox_regression_per_image, + target_regression, + reduction='sum' + )) + + # Estimate ground truth for class targets + gt_classes_target = torch.zeros((cls_logits_per_image.size(0), ), dtype=targets_per_image['labels'].dtype, + device=targets_per_image['labels'].device) + gt_classes_target[foreground_idxs_per_image] = \ + targets_per_image['labels'][foreground_matched_idxs_per_image] + cls_targets.append(gt_classes_target) + + bbox_loss = torch.stack(bbox_loss) + cls_targets = torch.stack(cls_targets) + + # Calculate classification loss + num_classes = cls_logits.size(-1) + cls_loss = F.cross_entropy( + cls_logits.view(-1, num_classes), + cls_targets.view(-1), + reduction='none' + ).view(cls_targets.size()) + + # Hard Negative Sampling + foreground_idxs = cls_targets > 0 + num_negative = self.neg_to_pos_ratio * foreground_idxs.sum(1, keepdim=True) + # num_negative[num_negative < self.neg_to_pos_ratio] = self.neg_to_pos_ratio + negative_loss = cls_loss.clone() + negative_loss[foreground_idxs] = -float('inf') # use -inf to detect positive values that creeped in the sample + values, idx = negative_loss.sort(1, descending=True) + # background_idxs = torch.logical_and(idx.sort(1)[1] < num_negative, torch.isfinite(values)) + background_idxs = idx.sort(1)[1] < num_negative + + N = max(1, num_foreground) + return { + 'bbox_regression': bbox_loss.sum() / N, + 'classification': (cls_loss[foreground_idxs].sum() + cls_loss[background_idxs].sum()) / N, + } + + def forward(self, images: List[Tensor], + targets: Optional[List[Dict[str, Tensor]]] = None) -> Tuple[Dict[str, Tensor], List[Dict[str, Tensor]]]: + if self.training and targets is None: + raise ValueError("In training mode, targets should be passed") + + if self.training: + assert targets is not None + for target in targets: + boxes = target["boxes"] + if isinstance(boxes, torch.Tensor): + if len(boxes.shape) != 2 or boxes.shape[-1] != 4: + raise ValueError("Expected target boxes to be a tensor" + "of shape [N, 4], got {:}.".format( + boxes.shape)) + else: + raise ValueError("Expected target boxes to be of type " + "Tensor, got {:}.".format(type(boxes))) + + # get the original image sizes + original_image_sizes: List[Tuple[int, int]] = [] + for img in images: + val = img.shape[-2:] + assert len(val) == 2 + original_image_sizes.append((val[0], val[1])) + + # transform the input + images, targets = self.transform(images, targets) + + # Check for degenerate boxes + if targets is not None: + for target_idx, target in enumerate(targets): + boxes = target["boxes"] + degenerate_boxes = boxes[:, 2:] <= boxes[:, :2] + if degenerate_boxes.any(): + bb_idx = torch.where(degenerate_boxes.any(dim=1))[0][0] + degen_bb: List[float] = boxes[bb_idx].tolist() + raise ValueError("All bounding boxes should have positive height and width." + " Found invalid box {} for target at index {}." + .format(degen_bb, target_idx)) + + # get the features from the backbone + features = self.backbone(images.tensors) + if isinstance(features, torch.Tensor): + features = OrderedDict([('0', features)]) + + features = list(features.values()) + + # compute the ssd heads outputs using the features + head_outputs = self.head(features) + + # create the set of anchors + anchors = self.anchor_generator(images, features) + + losses = {} + detections: List[Dict[str, Tensor]] = [] + if self.training: + assert targets is not None + + matched_idxs = [] + for anchors_per_image, targets_per_image in zip(anchors, targets): + if targets_per_image['boxes'].numel() == 0: + matched_idxs.append(torch.full((anchors_per_image.size(0),), -1, dtype=torch.int64, + device=anchors_per_image.device)) + continue + + match_quality_matrix = box_ops.box_iou(targets_per_image['boxes'], anchors_per_image) + matched_idxs.append(self.proposal_matcher(match_quality_matrix)) + + losses = self.compute_loss(targets, head_outputs, anchors, matched_idxs) + else: + detections = self.postprocess_detections(head_outputs, anchors, images.image_sizes) + detections = self.transform.postprocess(detections, images.image_sizes, original_image_sizes) + + if torch.jit.is_scripting(): + if not self._has_warned: + warnings.warn("SSD always returns a (Losses, Detections) tuple in scripting") + self._has_warned = True + return losses, detections + return self.eager_outputs(losses, detections) + + def postprocess_detections(self, head_outputs: Dict[str, Tensor], image_anchors: List[Tensor], + image_shapes: List[Tuple[int, int]]) -> List[Dict[str, Tensor]]: + bbox_regression = head_outputs['bbox_regression'] + pred_scores = F.softmax(head_outputs['cls_logits'], dim=-1) + + num_classes = pred_scores.size(-1) + device = pred_scores.device + + detections: List[Dict[str, Tensor]] = [] + + for boxes, scores, anchors, image_shape in zip(bbox_regression, pred_scores, image_anchors, image_shapes): + boxes = self.box_coder.decode_single(boxes, anchors) + boxes = box_ops.clip_boxes_to_image(boxes, image_shape) + + image_boxes = [] + image_scores = [] + image_labels = [] + for label in range(1, num_classes): + score = scores[:, label] + + keep_idxs = score > self.score_thresh + score = score[keep_idxs] + box = boxes[keep_idxs] + + # keep only topk scoring predictions + num_topk = min(self.topk_candidates, score.size(0)) + score, idxs = score.topk(num_topk) + box = box[idxs] + + image_boxes.append(box) + image_scores.append(score) + image_labels.append(torch.full_like(score, fill_value=label, dtype=torch.int64, device=device)) + + image_boxes = torch.cat(image_boxes, dim=0) + image_scores = torch.cat(image_scores, dim=0) + image_labels = torch.cat(image_labels, dim=0) + + # non-maximum suppression + keep = box_ops.batched_nms(image_boxes, image_scores, image_labels, self.nms_thresh) + keep = keep[:self.detections_per_img] + + detections.append({ + 'boxes': image_boxes[keep], + 'scores': image_scores[keep], + 'labels': image_labels[keep], + }) + return detections + + +class SSDFeatureExtractorVGG(nn.Module): + def __init__(self, backbone: nn.Module, highres: bool, rescaling: bool): + super().__init__() + + _, _, maxpool3_pos, maxpool4_pos, _ = (i for i, layer in enumerate(backbone) if isinstance(layer, nn.MaxPool2d)) + + # Patch ceil_mode for maxpool3 to get the same WxH output sizes as the paper + backbone[maxpool3_pos].ceil_mode = True + + # parameters used for L2 regularization + rescaling + self.scale_weight = nn.Parameter(torch.ones(512) * 20) + + # Multiple Feature maps - page 4, Fig 2 of SSD paper + self.features = nn.Sequential( + *backbone[:maxpool4_pos] # until conv4_3 + ) + + # SSD300 case - page 4, Fig 2 of SSD paper + extra = nn.ModuleList([ + nn.Sequential( + nn.Conv2d(1024, 256, kernel_size=1), + nn.ReLU(inplace=True), + nn.Conv2d(256, 512, kernel_size=3, padding=1, stride=2), # conv8_2 + nn.ReLU(inplace=True), + ), + nn.Sequential( + nn.Conv2d(512, 128, kernel_size=1), + nn.ReLU(inplace=True), + nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2), # conv9_2 + nn.ReLU(inplace=True), + ), + nn.Sequential( + nn.Conv2d(256, 128, kernel_size=1), + nn.ReLU(inplace=True), + nn.Conv2d(128, 256, kernel_size=3), # conv10_2 + nn.ReLU(inplace=True), + ), + nn.Sequential( + nn.Conv2d(256, 128, kernel_size=1), + nn.ReLU(inplace=True), + nn.Conv2d(128, 256, kernel_size=3), # conv11_2 + nn.ReLU(inplace=True), + ) + ]) + if highres: + # Additional layers for the SSD512 case. See page 11, footernote 5. + extra.append(nn.Sequential( + nn.Conv2d(256, 128, kernel_size=1), + nn.ReLU(inplace=True), + nn.Conv2d(128, 256, kernel_size=4), # conv12_2 + nn.ReLU(inplace=True), + )) + _xavier_init(extra) + + fc = nn.Sequential( + nn.MaxPool2d(kernel_size=3, stride=1, padding=1, ceil_mode=False), # add modified maxpool5 + nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, padding=6, dilation=6), # FC6 with atrous + nn.ReLU(inplace=True), + nn.Conv2d(in_channels=1024, out_channels=1024, kernel_size=1), # FC7 + nn.ReLU(inplace=True) + ) + _xavier_init(fc) + extra.insert(0, nn.Sequential( + *backbone[maxpool4_pos:-1], # until conv5_3, skip maxpool5 + fc, + )) + self.extra = extra + self.rescaling = rescaling + + def forward(self, x: Tensor) -> Dict[str, Tensor]: + # Undo the 0-1 scaling of toTensor. Necessary for some backbones. + if self.rescaling: + x *= 255 + + # L2 regularization + Rescaling of 1st block's feature map + x = self.features(x) + rescaled = self.scale_weight.view(1, -1, 1, 1) * F.normalize(x) + output = [rescaled] + + # Calculating Feature maps for the rest blocks + for block in self.extra: + x = block(x) + output.append(x) + + return OrderedDict([(str(i), v) for i, v in enumerate(output)]) + + +def _vgg_extractor(backbone_name: str, highres: bool, progress: bool, pretrained: bool, trainable_layers: int, + rescaling: bool): + if backbone_name in backbone_urls: + # Use custom backbones more appropriate for SSD + arch = backbone_name.split('_')[0] + backbone = vgg.__dict__[arch](pretrained=False, progress=progress).features + if pretrained: + state_dict = load_state_dict_from_url(backbone_urls[backbone_name], progress=progress) + backbone.load_state_dict(state_dict) + else: + # Use standard backbones from TorchVision + backbone = vgg.__dict__[backbone_name](pretrained=pretrained, progress=progress).features + + # Gather the indices of maxpools. These are the locations of output blocks. + stage_indices = [i for i, b in enumerate(backbone) if isinstance(b, nn.MaxPool2d)] + num_stages = len(stage_indices) + + # find the index of the layer from which we wont freeze + assert 0 <= trainable_layers <= num_stages + freeze_before = num_stages if trainable_layers == 0 else stage_indices[num_stages - trainable_layers] + + for b in backbone[:freeze_before]: + for parameter in b.parameters(): + parameter.requires_grad_(False) + + return SSDFeatureExtractorVGG(backbone, highres, rescaling) + + +def ssd300_vgg16(pretrained: bool = False, progress: bool = True, num_classes: int = 91, + pretrained_backbone: bool = True, trainable_backbone_layers: Optional[int] = None, **kwargs: Any): + """ + Constructs an SSD model with a VGG16 backbone. See `SSD` for more details. + + Example: + + >>> model = torchvision.models.detection.ssd300_vgg16(pretrained=True) + >>> model.eval() + >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)] + >>> predictions = model(x) + + Args: + pretrained (bool): If True, returns a model pre-trained on COCO train2017 + progress (bool): If True, displays a progress bar of the download to stderr + num_classes (int): number of output classes of the model (including the background) + pretrained_backbone (bool): If True, returns a model with backbone pre-trained on Imagenet + trainable_backbone_layers (int): number of trainable (not frozen) resnet layers starting from final block. + Valid values are between 0 and 5, with 5 meaning all backbone layers are trainable. + """ + trainable_backbone_layers = _validate_trainable_layers( + pretrained or pretrained_backbone, trainable_backbone_layers, 5, 5) + + if pretrained: + # no need to download the backbone if pretrained is set + pretrained_backbone = False + + backbone = _vgg_extractor("vgg16_features", False, progress, pretrained_backbone, trainable_backbone_layers, True) + anchor_generator = DefaultBoxGenerator([[2], [2, 3], [2, 3], [2, 3], [2], [2]], steps=[8, 16, 32, 64, 100, 300]) + model = SSD(backbone, anchor_generator, (300, 300), num_classes, + image_mean=[0.48235, 0.45882, 0.40784], image_std=[1., 1., 1.], **kwargs) + if pretrained: + weights_name = 'ssd300_vgg16_coco' + if model_urls.get(weights_name, None) is None: + raise ValueError("No checkpoint is available for model {}".format(weights_name)) + state_dict = load_state_dict_from_url(model_urls[weights_name], progress=progress) + model.load_state_dict(state_dict) + return model diff --git a/torchvision/models/detection/transform.py b/torchvision/models/detection/transform.py index 56e502f726d..55cfb483847 100644 --- a/torchvision/models/detection/transform.py +++ b/torchvision/models/detection/transform.py @@ -1,8 +1,8 @@ import math import torch -from torch import nn, Tensor -from torch.nn import functional as F import torchvision + +from torch import nn, Tensor from typing import List, Tuple, Dict, Optional from .image_list import ImageList @@ -23,32 +23,40 @@ def _fake_cast_onnx(v): return v -def _resize_image_and_masks(image, self_min_size, self_max_size, target): - # type: (Tensor, float, float, Optional[Dict[str, Tensor]]) -> Tuple[Tensor, Optional[Dict[str, Tensor]]] +def _resize_image_and_masks(image: Tensor, self_min_size: float, self_max_size: float, + target: Optional[Dict[str, Tensor]], + fixed_size: Optional[Tuple[int, int]]) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]: if torchvision._is_tracing(): im_shape = _get_shape_onnx(image) else: im_shape = torch.tensor(image.shape[-2:]) - min_size = torch.min(im_shape).to(dtype=torch.float32) - max_size = torch.max(im_shape).to(dtype=torch.float32) - scale = torch.min(self_min_size / min_size, self_max_size / max_size) - - if torchvision._is_tracing(): - scale_factor = _fake_cast_onnx(scale) + size: Optional[List[int]] = None + scale_factor: Optional[float] = None + recompute_scale_factor: Optional[bool] = None + if fixed_size is not None: + size = [fixed_size[1], fixed_size[0]] else: - scale_factor = scale.item() + min_size = torch.min(im_shape).to(dtype=torch.float32) + max_size = torch.max(im_shape).to(dtype=torch.float32) + scale = torch.min(self_min_size / min_size, self_max_size / max_size) + + if torchvision._is_tracing(): + scale_factor = _fake_cast_onnx(scale) + else: + scale_factor = scale.item() + recompute_scale_factor = True - image = torch.nn.functional.interpolate( - image[None], scale_factor=scale_factor, mode='bilinear', recompute_scale_factor=True, - align_corners=False)[0] + image = torch.nn.functional.interpolate(image[None], size=size, scale_factor=scale_factor, mode='bilinear', + recompute_scale_factor=recompute_scale_factor, align_corners=False)[0] if target is None: return image, target if "masks" in target: mask = target["masks"] - mask = F.interpolate(mask[:, None].float(), scale_factor=scale_factor, recompute_scale_factor=True)[:, 0].byte() + mask = torch.nn.functional.interpolate(mask[:, None].float(), size=size, scale_factor=scale_factor, + recompute_scale_factor=recompute_scale_factor)[:, 0].byte() target["masks"] = mask return image, target @@ -65,7 +73,7 @@ class GeneralizedRCNNTransform(nn.Module): It returns a ImageList for the inputs, and a List[Dict[Tensor]] for the targets """ - def __init__(self, min_size, max_size, image_mean, image_std): + def __init__(self, min_size, max_size, image_mean, image_std, size_divisible=32, fixed_size=None): super(GeneralizedRCNNTransform, self).__init__() if not isinstance(min_size, (list, tuple)): min_size = (min_size,) @@ -73,6 +81,8 @@ def __init__(self, min_size, max_size, image_mean, image_std): self.max_size = max_size self.image_mean = image_mean self.image_std = image_std + self.size_divisible = size_divisible + self.fixed_size = fixed_size def forward(self, images, # type: List[Tensor] @@ -106,7 +116,7 @@ def forward(self, targets[i] = target_index image_sizes = [img.shape[-2:] for img in images] - images = self.batch_images(images) + images = self.batch_images(images, size_divisible=self.size_divisible) image_sizes_list: List[Tuple[int, int]] = [] for image_size in image_sizes: assert len(image_size) == 2 @@ -144,7 +154,7 @@ def resize(self, image, target): else: # FIXME assume for now that testing uses the largest scale size = float(self.min_size[-1]) - image, target = _resize_image_and_masks(image, size, float(self.max_size), target) + image, target = _resize_image_and_masks(image, size, float(self.max_size), target, self.fixed_size) if target is None: return image, target From 3975ec563c1d6609cbe8a6fef5d2bc402191a132 Mon Sep 17 00:00:00 2001 From: vfdev Date: Mon, 3 May 2021 16:54:37 +0200 Subject: [PATCH 027/279] Update codeql.yml (#3764) --- .github/workflows/codeql.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index 387d82ec343..3c8bc96a5bd 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -31,7 +31,7 @@ jobs: - name: Install Torch run: | python -m pip install cmake - python -m pip install torch==1.8.1+cpu -f https://download.pytorch.org/whl/torch_stable.html + python -m pip install --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html sudo ln -s /usr/bin/ninja /usr/bin/ninja-build - name: Build TorchVision From cde7ff014dceda46f2b60183f3f3856bdb94f7c0 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Mon, 3 May 2021 18:52:07 +0000 Subject: [PATCH 028/279] Pass custom scales on DefaultBoxGenerator and change default estimation. (#3766) --- test/test_models_detection_anchor_utils.py | 8 ++--- torchvision/models/detection/anchor_utils.py | 38 ++++++++++++-------- torchvision/models/detection/ssd.py | 4 ++- 3 files changed, 31 insertions(+), 19 deletions(-) diff --git a/test/test_models_detection_anchor_utils.py b/test/test_models_detection_anchor_utils.py index a1937fb01cc..ed1b06b5f96 100644 --- a/test/test_models_detection_anchor_utils.py +++ b/test/test_models_detection_anchor_utils.py @@ -76,10 +76,10 @@ def test_defaultbox_generator(self): dboxes = model(images, features) dboxes_output = torch.tensor([ - [6.9750, 6.9750, 8.0250, 8.0250], - [6.7315, 6.7315, 8.2685, 8.2685], - [6.7575, 7.1288, 8.2425, 7.8712], - [7.1288, 6.7575, 7.8712, 8.2425] + [6.3750, 6.3750, 8.6250, 8.6250], + [4.7443, 4.7443, 10.2557, 10.2557], + [5.9090, 6.7045, 9.0910, 8.2955], + [6.7045, 5.9090, 8.2955, 9.0910] ]) self.assertEqual(len(dboxes), 2) diff --git a/torchvision/models/detection/anchor_utils.py b/torchvision/models/detection/anchor_utils.py index 8a8b08399ab..cf0bdbd69d7 100644 --- a/torchvision/models/detection/anchor_utils.py +++ b/torchvision/models/detection/anchor_utils.py @@ -138,9 +138,11 @@ class DefaultBoxGenerator(nn.Module): Args: aspect_ratios (List[List[int]]): A list with all the aspect ratios used in each feature map. min_ratio (float): The minimum scale :math:`\text{s}_{\text{min}}` of the default boxes used in the estimation - of the scales of each feature map. + of the scales of each feature map. It is used only if the ``scales`` parameter is not provided. max_ratio (float): The maximum scale :math:`\text{s}_{\text{max}}` of the default boxes used in the estimation - of the scales of each feature map. + of the scales of each feature map. It is used only if the ``scales`` parameter is not provided. + scales (List[float]], optional): The scales of the default boxes. If not provided it will be estimated using + the ``min_ratio`` and ``max_ratio`` parameters. steps (List[int]], optional): It's a hyper-parameter that affects the tiling of defalt boxes. If not provided it will be estimated from the data. clip (bool): Whether the standardized values of default boxes should be clipped between 0 and 1. The clipping @@ -148,7 +150,7 @@ class DefaultBoxGenerator(nn.Module): """ def __init__(self, aspect_ratios: List[List[int]], min_ratio: float = 0.15, max_ratio: float = 0.9, - steps: Optional[List[int]] = None, clip: bool = True): + scales: Optional[List[float]] = None, steps: Optional[List[int]] = None, clip: bool = True): super().__init__() if steps is not None: assert len(aspect_ratios) == len(steps) @@ -158,15 +160,15 @@ def __init__(self, aspect_ratios: List[List[int]], min_ratio: float = 0.15, max_ num_outputs = len(aspect_ratios) # Estimation of default boxes scales - # Inspired from https://github.com/weiliu89/caffe/blob/ssd/examples/ssd/ssd_pascal.py#L311-L317 - min_centile = int(100 * min_ratio) - max_centile = int(100 * max_ratio) - conv4_centile = min_centile // 2 # assume half of min_ratio as in paper - step = (max_centile - min_centile) // (num_outputs - 2) - centiles = [conv4_centile, min_centile] - for c in range(min_centile, max_centile + 1, step): - centiles.append(c + step) - self.scales = [c / 100 for c in centiles] + if scales is None: + if num_outputs > 1: + range_ratio = max_ratio - min_ratio + self.scales = [min_ratio + range_ratio * k / (num_outputs - 1.0) for k in range(num_outputs)] + self.scales.append(1.0) + else: + self.scales = [min_ratio, max_ratio] + else: + self.scales = scales self._wh_pairs = [] for k in range(num_outputs): @@ -207,9 +209,17 @@ def forward(self, image_list: ImageList, feature_maps: List[Tensor]) -> List[Ten for k, f_k in enumerate(grid_sizes): # Now add the default boxes for each width-height pair for j in range(f_k[0]): - cy = (j + 0.5) / (float(f_k[0]) if self.steps is None else image_size[1] / self.steps[k]) + if self.steps is not None: + y_f_k = image_size[1] / self.steps[k] + else: + y_f_k = float(f_k[0]) + cy = (j + 0.5) / y_f_k for i in range(f_k[1]): - cx = (i + 0.5) / (float(f_k[1]) if self.steps is None else image_size[0] / self.steps[k]) + if self.steps is not None: + x_f_k = image_size[0] / self.steps[k] + else: + x_f_k = float(f_k[1]) + cx = (i + 0.5) / x_f_k default_boxes.extend([[cx, cy, w, h] for w, h in self._wh_pairs[k]]) dboxes = [] diff --git a/torchvision/models/detection/ssd.py b/torchvision/models/detection/ssd.py index fcb79d6e651..aeb93012d78 100644 --- a/torchvision/models/detection/ssd.py +++ b/torchvision/models/detection/ssd.py @@ -552,7 +552,9 @@ def ssd300_vgg16(pretrained: bool = False, progress: bool = True, num_classes: i pretrained_backbone = False backbone = _vgg_extractor("vgg16_features", False, progress, pretrained_backbone, trainable_backbone_layers, True) - anchor_generator = DefaultBoxGenerator([[2], [2, 3], [2, 3], [2, 3], [2], [2]], steps=[8, 16, 32, 64, 100, 300]) + anchor_generator = DefaultBoxGenerator([[2], [2, 3], [2, 3], [2, 3], [2], [2]], + scales=[0.07, 0.15, 0.33, 0.51, 0.69, 0.87, 1.05], + steps=[8, 16, 32, 64, 100, 300]) model = SSD(backbone, anchor_generator, (300, 300), num_classes, image_mean=[0.48235, 0.45882, 0.40784], image_std=[1., 1., 1.], **kwargs) if pretrained: From 3e847dc031e9a977fc617b9757f322657178060d Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 4 May 2021 08:10:57 +0000 Subject: [PATCH 029/279] Clean up test accept behaviour (#3759) --- test/common_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index c5b39c451a3..974390ce242 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -43,7 +43,7 @@ def set_rng_seed(seed): np.random.seed(seed) -ACCEPT = os.getenv('EXPECTTEST_ACCEPT') +ACCEPT = os.getenv('EXPECTTEST_ACCEPT', '0') == '1' TEST_WITH_SLOW = os.getenv('PYTORCH_TEST_WITH_SLOW', '0') == '1' @@ -121,7 +121,7 @@ def assertExpected(self, output, name, prec=None): pickable with `torch.save`. This file is placed in the 'expect' directory in the same directory as the test script. You can automatically update the recorded test - output using --accept. + output using an EXPECTTEST_ACCEPT=1 env variable. """ expected_file = self._get_expected_file(name) From 9e6bdbabcf2a39563d69dad81d8fddef5800ae3f Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 4 May 2021 16:23:32 +0100 Subject: [PATCH 030/279] Skip r2plus1d_18 test on linux GPU Circle CI machines (#3768) --- .circleci/config.yml | 2 +- .circleci/config.yml.in | 2 +- test/common_utils.py | 1 + test/test_models.py | 6 +++++- 4 files changed, 8 insertions(+), 3 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index c12f0b731c4..6b3f82c553a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -648,7 +648,7 @@ jobs: command: docker run -t --gpus all -v $PWD:$PWD -w $PWD -e UPLOAD_CHANNEL -e CU_VERSION "${image_name}" .circleci/unittest/linux/scripts/install.sh - run: name: Run tests - command: docker run -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/run_test.sh + command: docker run -e CIRCLECI -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/run_test.sh - run: name: Post Process command: docker run -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/post_process.sh diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index fe811d75dbe..741deac8837 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -648,7 +648,7 @@ jobs: command: docker run -t --gpus all -v $PWD:$PWD -w $PWD -e UPLOAD_CHANNEL -e CU_VERSION "${image_name}" .circleci/unittest/linux/scripts/install.sh - run: name: Run tests - command: docker run -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/run_test.sh + command: docker run -e CIRCLECI -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/run_test.sh - run: name: Post Process command: docker run -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/post_process.sh diff --git a/test/common_utils.py b/test/common_utils.py index 974390ce242..2c2fa73cf04 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -23,6 +23,7 @@ IS_PY39 = sys.version_info.major == 3 and sys.version_info.minor == 9 PY39_SEGFAULT_SKIP_MSG = "Segmentation fault with Python 3.9, see https://github.com/pytorch/vision/issues/3367" PY39_SKIP = unittest.skipIf(IS_PY39, PY39_SEGFAULT_SKIP_MSG) +IN_CIRCLE_CI = os.getenv("CIRCLECI", False) == 'true' @contextlib.contextmanager diff --git a/test/test_models.py b/test/test_models.py index c23087a05e9..157288a2c32 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -1,4 +1,5 @@ -from common_utils import TestCase, map_nested_tensor_object, freeze_rng_state, set_rng_seed +import sys +from common_utils import TestCase, map_nested_tensor_object, freeze_rng_state, set_rng_seed, IN_CIRCLE_CI from collections import OrderedDict from itertools import product import functools @@ -458,6 +459,9 @@ def test_detection_model_validation(model_name): @pytest.mark.parametrize('model_name', get_available_video_models()) @pytest.mark.parametrize('dev', _devs) def test_video_model(model_name, dev): + if IN_CIRCLE_CI and 'cuda' in dev.type and model_name == 'r2plus1d_18' and sys.platform == 'linux': + # FIXME: Failure should fixed and test re-actived. See https://github.com/pytorch/vision/issues/3702 + pytest.skip('r2plus1d_18 fails on CircleCI linux GPU machines.') ModelTester()._test_video_model(model_name, dev) From 3782888352b405441a631baa962a7bbb5a839fa8 Mon Sep 17 00:00:00 2001 From: moto <855818+mthrok@users.noreply.github.com> Date: Wed, 5 May 2021 13:33:47 -0400 Subject: [PATCH 031/279] Update CI jobs xcode/macOS version to match PyTorch core (#3778) xcode Version 9 is no longer supported by Apple. https://developer.apple.com/support/xcode/ Updating xcode to 12.0, which also updates the macOS to 10.15. See https://circleci.com/docs/2.0/testing-ios/#supported-xcode-versions --- .circleci/config.yml | 8 ++++---- .circleci/config.yml.in | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 6b3f82c553a..3f22d6b6c35 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -337,7 +337,7 @@ jobs: binary_macos_wheel: <<: *binary_common macos: - xcode: "9.4.1" + xcode: "12.0" steps: - checkout_merge - designate_upload_channel @@ -397,7 +397,7 @@ jobs: binary_macos_conda: <<: *binary_common macos: - xcode: "9.4.1" + xcode: "12.0" steps: - checkout_merge - designate_upload_channel @@ -739,7 +739,7 @@ jobs: unittest_macos_cpu: <<: *binary_common macos: - xcode: "9.4.1" + xcode: "12.0" resource_class: large steps: - checkout @@ -815,7 +815,7 @@ jobs: cmake_macos_cpu: <<: *binary_common macos: - xcode: "9.4.1" + xcode: "12.0" steps: - checkout_merge - designate_upload_channel diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 741deac8837..0984b8bb961 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -337,7 +337,7 @@ jobs: binary_macos_wheel: <<: *binary_common macos: - xcode: "9.4.1" + xcode: "12.0" steps: - checkout_merge - designate_upload_channel @@ -397,7 +397,7 @@ jobs: binary_macos_conda: <<: *binary_common macos: - xcode: "9.4.1" + xcode: "12.0" steps: - checkout_merge - designate_upload_channel @@ -739,7 +739,7 @@ jobs: unittest_macos_cpu: <<: *binary_common macos: - xcode: "9.4.1" + xcode: "12.0" resource_class: large steps: - checkout @@ -815,7 +815,7 @@ jobs: cmake_macos_cpu: <<: *binary_common macos: - xcode: "9.4.1" + xcode: "12.0" steps: - checkout_merge - designate_upload_channel From 90a6206c5ca2ab26190cb89c2e42d95e0ece8c90 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 5 May 2021 20:42:40 +0100 Subject: [PATCH 032/279] Show built doc links directly in PR GUI -- v2 (#3734) --- .github/workflows/show_link_to_built_docs.yml | 18 ++++++++++++++++++ CONTRIBUTING.md | 4 ++++ 2 files changed, 22 insertions(+) create mode 100644 .github/workflows/show_link_to_built_docs.yml diff --git a/.github/workflows/show_link_to_built_docs.yml b/.github/workflows/show_link_to_built_docs.yml new file mode 100644 index 00000000000..c939db98e86 --- /dev/null +++ b/.github/workflows/show_link_to_built_docs.yml @@ -0,0 +1,18 @@ +name: Show CI job with links to built docs + +on: + pull_request: + branches: [ master ] + +jobs: + circleci_artifacts_redirector_job: + runs-on: ubuntu-latest + name: Run CircleCI artifacts redirector + steps: + - name: GitHub Action step + uses: larsoner/circleci-artifacts-redirector-action@master + with: + repo-token: ${{ secrets.GITHUB_TOKEN }} + artifact-path: 0/docs/index.html + circleci-jobs: build_docs + job-title: See the built docs here! diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 063815938ba..e72696e26a0 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -125,6 +125,10 @@ make html Then open `docs/build/html/index.html` in your favorite browser. +The docs are also automatically built when you submit a PR. The job that +builds the docs is named `build_docs`. If that job passes, a link to the +rendered docs will be available in a job called `See the built docs here!`. + ### New model More details on how to add a new model will be provided later. Please, do not send any PR with a new model without discussing From c2ab0c59f42babf9ad01aa616cd8a901daac86dd Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Thu, 6 May 2021 13:22:10 +0000 Subject: [PATCH 033/279] Make reference scripts compatible with submitit (#3785) * Add submitit script, partition param and parser on its own method. * Fix method names, handle add_help correctly and refactoring. * Delete run_with_submitit.py file --- references/classification/train.py | 10 +- .../classification/train_quantization.py | 11 +- references/detection/train.py | 116 +++++++++--------- references/segmentation/train.py | 9 +- 4 files changed, 71 insertions(+), 75 deletions(-) diff --git a/references/classification/train.py b/references/classification/train.py index 232c3b5556b..b4e9d274662 100644 --- a/references/classification/train.py +++ b/references/classification/train.py @@ -224,9 +224,9 @@ def main(args): print('Training time {}'.format(total_time_str)) -def parse_args(): +def get_args_parser(add_help=True): import argparse - parser = argparse.ArgumentParser(description='PyTorch Classification Training') + parser = argparse.ArgumentParser(description='PyTorch Classification Training', add_help=add_help) parser.add_argument('--data-path', default='/datasets01/imagenet_full_size/061417/', help='dataset') parser.add_argument('--model', default='resnet18', help='model') @@ -291,11 +291,9 @@ def parse_args(): help='number of distributed processes') parser.add_argument('--dist-url', default='env://', help='url used to set up distributed training') - args = parser.parse_args() - - return args + return parser if __name__ == "__main__": - args = parse_args() + args = get_args_parser().parse_args() main(args) diff --git a/references/classification/train_quantization.py b/references/classification/train_quantization.py index dd41d0b3d1f..ec945f4f58f 100644 --- a/references/classification/train_quantization.py +++ b/references/classification/train_quantization.py @@ -13,7 +13,6 @@ def main(args): - if args.output_dir: utils.mkdir(args.output_dir) @@ -162,9 +161,9 @@ def main(args): print('Training time {}'.format(total_time_str)) -def parse_args(): +def get_args_parser(add_help=True): import argparse - parser = argparse.ArgumentParser(description='PyTorch Classification Training') + parser = argparse.ArgumentParser(description='PyTorch Quantized Classification Training', add_help=add_help) parser.add_argument('--data-path', default='/datasets01/imagenet_full_size/061417/', @@ -250,11 +249,9 @@ def parse_args(): default='env://', help='url used to set up distributed training') - args = parser.parse_args() - - return args + return parser if __name__ == "__main__": - args = parse_args() + args = get_args_parser().parse_args() main(args) diff --git a/references/detection/train.py b/references/detection/train.py index 81f170e73d0..712c41f658f 100644 --- a/references/detection/train.py +++ b/references/detection/train.py @@ -51,7 +51,65 @@ def get_transform(train, data_augmentation): return presets.DetectionPresetTrain(data_augmentation) if train else presets.DetectionPresetEval() +def get_args_parser(add_help=True): + import argparse + parser = argparse.ArgumentParser(description='PyTorch Detection Training', add_help=add_help) + + parser.add_argument('--data-path', default='/datasets01/COCO/022719/', help='dataset') + parser.add_argument('--dataset', default='coco', help='dataset') + parser.add_argument('--model', default='maskrcnn_resnet50_fpn', help='model') + parser.add_argument('--device', default='cuda', help='device') + parser.add_argument('-b', '--batch-size', default=2, type=int, + help='images per gpu, the total batch size is $NGPU x batch_size') + parser.add_argument('--epochs', default=26, type=int, metavar='N', + help='number of total epochs to run') + parser.add_argument('-j', '--workers', default=4, type=int, metavar='N', + help='number of data loading workers (default: 4)') + parser.add_argument('--lr', default=0.02, type=float, + help='initial learning rate, 0.02 is the default value for training ' + 'on 8 gpus and 2 images_per_gpu') + parser.add_argument('--momentum', default=0.9, type=float, metavar='M', + help='momentum') + parser.add_argument('--wd', '--weight-decay', default=1e-4, type=float, + metavar='W', help='weight decay (default: 1e-4)', + dest='weight_decay') + parser.add_argument('--lr-step-size', default=8, type=int, help='decrease lr every step-size epochs') + parser.add_argument('--lr-steps', default=[16, 22], nargs='+', type=int, help='decrease lr every step-size epochs') + parser.add_argument('--lr-gamma', default=0.1, type=float, help='decrease lr by a factor of lr-gamma') + parser.add_argument('--print-freq', default=20, type=int, help='print frequency') + parser.add_argument('--output-dir', default='.', help='path where to save') + parser.add_argument('--resume', default='', help='resume from checkpoint') + parser.add_argument('--start_epoch', default=0, type=int, help='start epoch') + parser.add_argument('--aspect-ratio-group-factor', default=3, type=int) + parser.add_argument('--rpn-score-thresh', default=None, type=float, help='rpn score threshold for faster-rcnn') + parser.add_argument('--trainable-backbone-layers', default=None, type=int, + help='number of trainable layers of backbone') + parser.add_argument('--data-augmentation', default="hflip", help='data augmentation policy (default: hflip)') + parser.add_argument( + "--test-only", + dest="test_only", + help="Only test the model", + action="store_true", + ) + parser.add_argument( + "--pretrained", + dest="pretrained", + help="Use pre-trained models from the modelzoo", + action="store_true", + ) + + # distributed training parameters + parser.add_argument('--world-size', default=1, type=int, + help='number of distributed processes') + parser.add_argument('--dist-url', default='env://', help='url used to set up distributed training') + + return parser + + def main(args): + if args.output_dir: + utils.mkdir(args.output_dir) + utils.init_distributed_mode(args) print(args) @@ -147,61 +205,5 @@ def main(args): if __name__ == "__main__": - import argparse - parser = argparse.ArgumentParser( - description=__doc__) - - parser.add_argument('--data-path', default='/datasets01/COCO/022719/', help='dataset') - parser.add_argument('--dataset', default='coco', help='dataset') - parser.add_argument('--model', default='maskrcnn_resnet50_fpn', help='model') - parser.add_argument('--device', default='cuda', help='device') - parser.add_argument('-b', '--batch-size', default=2, type=int, - help='images per gpu, the total batch size is $NGPU x batch_size') - parser.add_argument('--epochs', default=26, type=int, metavar='N', - help='number of total epochs to run') - parser.add_argument('-j', '--workers', default=4, type=int, metavar='N', - help='number of data loading workers (default: 4)') - parser.add_argument('--lr', default=0.02, type=float, - help='initial learning rate, 0.02 is the default value for training ' - 'on 8 gpus and 2 images_per_gpu') - parser.add_argument('--momentum', default=0.9, type=float, metavar='M', - help='momentum') - parser.add_argument('--wd', '--weight-decay', default=1e-4, type=float, - metavar='W', help='weight decay (default: 1e-4)', - dest='weight_decay') - parser.add_argument('--lr-step-size', default=8, type=int, help='decrease lr every step-size epochs') - parser.add_argument('--lr-steps', default=[16, 22], nargs='+', type=int, help='decrease lr every step-size epochs') - parser.add_argument('--lr-gamma', default=0.1, type=float, help='decrease lr by a factor of lr-gamma') - parser.add_argument('--print-freq', default=20, type=int, help='print frequency') - parser.add_argument('--output-dir', default='.', help='path where to save') - parser.add_argument('--resume', default='', help='resume from checkpoint') - parser.add_argument('--start_epoch', default=0, type=int, help='start epoch') - parser.add_argument('--aspect-ratio-group-factor', default=3, type=int) - parser.add_argument('--rpn-score-thresh', default=None, type=float, help='rpn score threshold for faster-rcnn') - parser.add_argument('--trainable-backbone-layers', default=None, type=int, - help='number of trainable layers of backbone') - parser.add_argument('--data-augmentation', default="hflip", help='data augmentation policy (default: hflip)') - parser.add_argument( - "--test-only", - dest="test_only", - help="Only test the model", - action="store_true", - ) - parser.add_argument( - "--pretrained", - dest="pretrained", - help="Use pre-trained models from the modelzoo", - action="store_true", - ) - - # distributed training parameters - parser.add_argument('--world-size', default=1, type=int, - help='number of distributed processes') - parser.add_argument('--dist-url', default='env://', help='url used to set up distributed training') - - args = parser.parse_args() - - if args.output_dir: - utils.mkdir(args.output_dir) - + args = get_args_parser().parse_args() main(args) diff --git a/references/segmentation/train.py b/references/segmentation/train.py index 690e248323e..47907546dbc 100644 --- a/references/segmentation/train.py +++ b/references/segmentation/train.py @@ -172,9 +172,9 @@ def main(args): print('Training time {}'.format(total_time_str)) -def parse_args(): +def get_args_parser(add_help=True): import argparse - parser = argparse.ArgumentParser(description='PyTorch Segmentation Training') + parser = argparse.ArgumentParser(description='PyTorch Segmentation Training', add_help=add_help) parser.add_argument('--data-path', default='/datasets01/COCO/022719/', help='dataset path') parser.add_argument('--dataset', default='coco', help='dataset name') @@ -215,10 +215,9 @@ def parse_args(): help='number of distributed processes') parser.add_argument('--dist-url', default='env://', help='url used to set up distributed training') - args = parser.parse_args() - return args + return parser if __name__ == "__main__": - args = parse_args() + args = get_args_parser().parse_args() main(args) From a78d0d83d0a499fe8480d7a9f493676e746c4699 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 7 May 2021 08:41:30 +0000 Subject: [PATCH 034/279] Add checkpoints used for preemption. (#3789) --- references/detection/train.py | 10 ++++++++-- references/segmentation/train.py | 18 +++++++++++------- 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/references/detection/train.py b/references/detection/train.py index 712c41f658f..4eb39bf17f5 100644 --- a/references/detection/train.py +++ b/references/detection/train.py @@ -188,13 +188,19 @@ def main(args): train_one_epoch(model, optimizer, data_loader, device, epoch, args.print_freq) lr_scheduler.step() if args.output_dir: - utils.save_on_master({ + checkpoint = { 'model': model_without_ddp.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'args': args, - 'epoch': epoch}, + 'epoch': epoch + } + utils.save_on_master( + checkpoint, os.path.join(args.output_dir, 'model_{}.pth'.format(epoch))) + utils.save_on_master( + checkpoint, + os.path.join(args.output_dir, 'checkpoint.pth')) # evaluate after every epoch evaluate(model, data_loader_test, device=device) diff --git a/references/segmentation/train.py b/references/segmentation/train.py index 47907546dbc..fb6c7eeee15 100644 --- a/references/segmentation/train.py +++ b/references/segmentation/train.py @@ -157,15 +157,19 @@ def main(args): train_one_epoch(model, criterion, optimizer, data_loader, lr_scheduler, device, epoch, args.print_freq) confmat = evaluate(model, data_loader_test, device=device, num_classes=num_classes) print(confmat) + checkpoint = { + 'model': model_without_ddp.state_dict(), + 'optimizer': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'epoch': epoch, + 'args': args + } utils.save_on_master( - { - 'model': model_without_ddp.state_dict(), - 'optimizer': optimizer.state_dict(), - 'lr_scheduler': lr_scheduler.state_dict(), - 'epoch': epoch, - 'args': args - }, + checkpoint, os.path.join(args.output_dir, 'model_{}.pth'.format(epoch))) + utils.save_on_master( + checkpoint, + os.path.join(args.output_dir, 'checkpoint.pth')) total_time = time.time() - start_time total_time_str = str(datetime.timedelta(seconds=int(total_time))) From 851b623c8c7236dc6c5d7e0ec904a2576a965ff7 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 7 May 2021 15:34:28 +0000 Subject: [PATCH 035/279] Pin JPEG version to resolve the size_t issue on windows (#3787) --- .circleci/unittest/linux/scripts/environment.yml | 3 ++- .circleci/unittest/windows/scripts/environment.yml | 3 ++- packaging/torchvision/meta.yaml | 9 ++++++--- 3 files changed, 10 insertions(+), 5 deletions(-) diff --git a/.circleci/unittest/linux/scripts/environment.yml b/.circleci/unittest/linux/scripts/environment.yml index dcad1abfa31..5ddc862c869 100644 --- a/.circleci/unittest/linux/scripts/environment.yml +++ b/.circleci/unittest/linux/scripts/environment.yml @@ -9,7 +9,8 @@ dependencies: - codecov - pip - libpng - - jpeg + # NOTE: Pinned to fix issues with size_t on Windows + - jpeg <=9b - ca-certificates - pip: - future diff --git a/.circleci/unittest/windows/scripts/environment.yml b/.circleci/unittest/windows/scripts/environment.yml index b4f32cb3cad..1f9c38d82c0 100644 --- a/.circleci/unittest/windows/scripts/environment.yml +++ b/.circleci/unittest/windows/scripts/environment.yml @@ -9,7 +9,8 @@ dependencies: - codecov - pip - libpng - - jpeg + # NOTE: Pinned to fix issues with size_t on Windows + - jpeg <=9b - ca-certificates - pip: - future diff --git a/packaging/torchvision/meta.yaml b/packaging/torchvision/meta.yaml index 8516b2f0ed4..d25b00c042f 100644 --- a/packaging/torchvision/meta.yaml +++ b/packaging/torchvision/meta.yaml @@ -9,7 +9,8 @@ requirements: build: - {{ compiler('c') }} # [win] - libpng - - jpeg + # NOTE: Pinned to fix issues with size_t on Windows + - jpeg <=9b # NOTE: The only ffmpeg version that we build is actually 4.2 - ffmpeg >=4.2 # [not win] @@ -24,7 +25,8 @@ requirements: - python - libpng - ffmpeg >=4.2 # [not win] - - jpeg + # NOTE: Pinned to fix issues with size_t on Windows + - jpeg <=9b - pillow >=5.3.0 {{ environ.get('CONDA_PYTORCH_CONSTRAINT') }} {{ environ.get('CONDA_CUDATOOLKIT_CONSTRAINT') }} @@ -51,7 +53,8 @@ test: - pytest - scipy - av >=8.0.1 - - jpeg + # NOTE: Pinned to fix issues with size_t on Windows + - jpeg <=9b - ca-certificates From 2f225833884ab133a9a17d9ab5f40894cdfea7ff Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 7 May 2021 15:36:45 +0000 Subject: [PATCH 036/279] Add auto-augment introduced transforms in docs (#3793) * Add auto-augment introduced transforms in docs. * Adding examples in Gallery. * Make posterize more extreme. --- docs/source/transforms.rst | 18 +++++++++++ gallery/plot_transforms.py | 62 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+) diff --git a/docs/source/transforms.rst b/docs/source/transforms.rst index 21e2c152626..e94c51fe560 100644 --- a/docs/source/transforms.rst +++ b/docs/source/transforms.rst @@ -136,6 +136,24 @@ Transforms on PIL Image and torch.\*Tensor .. autoclass:: GaussianBlur :members: +.. autoclass:: RandomInvert + :members: + +.. autoclass:: RandomPosterize + :members: + +.. autoclass:: RandomSolarize + :members: + +.. autoclass:: RandomAdjustSharpness + :members: + +.. autoclass:: RandomAutocontrast + :members: + +.. autoclass:: RandomEqualize + :members: + .. _transforms_pil_only: Transforms on PIL Image only diff --git a/gallery/plot_transforms.py b/gallery/plot_transforms.py index f265054dbc4..863058fc862 100644 --- a/gallery/plot_transforms.py +++ b/gallery/plot_transforms.py @@ -167,6 +167,68 @@ def plot(imgs, with_orig=True, row_title=None, **imshow_kwargs): resized_crops = [resize_cropper(orig_img) for _ in range(4)] plot(resized_crops) +#################################### +# RandomInvert +# ~~~~~~~~~~~~ +# The :class:`~torchvision.transforms.RandomInvert` transform +# (see also :func:`~torchvision.transforms.functional.invert`) +# randomly inverts the colors of the given image. +inverter = T.RandomInvert() +invertered_imgs = [inverter(orig_img) for _ in range(4)] +plot(invertered_imgs) + +#################################### +# RandomPosterize +# ~~~~~~~~~~~~~~~ +# The :class:`~torchvision.transforms.RandomPosterize` transform +# (see also :func:`~torchvision.transforms.functional.posterize`) +# randomly posterizes the image by reducing the number of bits +# of each color channel. +posterizer = T.RandomPosterize(bits=2) +posterized_imgs = [posterizer(orig_img) for _ in range(4)] +plot(posterized_imgs) + +#################################### +# RandomSolarize +# ~~~~~~~~~~~~~~ +# The :class:`~torchvision.transforms.RandomSolarize` transform +# (see also :func:`~torchvision.transforms.functional.solarize`) +# randomly solarizes the image by inverting all pixel values above +# the threshold. +solarizer = T.RandomSolarize(threshold=192.0) +solarized_imgs = [solarizer(orig_img) for _ in range(4)] +plot(solarized_imgs) + +#################################### +# RandomAdjustSharpness +# ~~~~~~~~~~~~~~~~~~~~~ +# The :class:`~torchvision.transforms.RandomAdjustSharpness` transform +# (see also :func:`~torchvision.transforms.functional.adjust_sharpness`) +# randomly adjusts the sharpness of the given image. +sharpness_adjuster = T.RandomAdjustSharpness(sharpness_factor=2) +sharpened_imgs = [sharpness_adjuster(orig_img) for _ in range(4)] +plot(sharpened_imgs) + +#################################### +# RandomAutocontrast +# ~~~~~~~~~~~~~~~~~~ +# The :class:`~torchvision.transforms.RandomAutocontrast` transform +# (see also :func:`~torchvision.transforms.functional.autocontrast`) +# randomly applies autocontrast to the given image. +autocontraster = T.RandomAutocontrast() +autocontrasted_imgs = [autocontraster(orig_img) for _ in range(4)] +plot(autocontrasted_imgs) + +#################################### +# RandomEqualize +# ~~~~~~~~~~~~~~ +# The :class:`~torchvision.transforms.RandomEqualize` transform +# (see also :func:`~torchvision.transforms.functional.equalize`) +# randomly equalizes the histogram of the given image. +equalizer = T.RandomEqualize() +equalized_imgs = [equalizer(orig_img) for _ in range(4)] +plot(equalized_imgs) + #################################### # AutoAugment # ~~~~~~~~~~~ From 5339e63148304ce32fd1cbd1e8bb74ea79458691 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 7 May 2021 16:49:16 +0100 Subject: [PATCH 037/279] Remove "Show link to docs" GH Action (#3796) --- .github/workflows/show_link_to_built_docs.yml | 18 ------------------ CONTRIBUTING.md | 4 ++-- 2 files changed, 2 insertions(+), 20 deletions(-) delete mode 100644 .github/workflows/show_link_to_built_docs.yml diff --git a/.github/workflows/show_link_to_built_docs.yml b/.github/workflows/show_link_to_built_docs.yml deleted file mode 100644 index c939db98e86..00000000000 --- a/.github/workflows/show_link_to_built_docs.yml +++ /dev/null @@ -1,18 +0,0 @@ -name: Show CI job with links to built docs - -on: - pull_request: - branches: [ master ] - -jobs: - circleci_artifacts_redirector_job: - runs-on: ubuntu-latest - name: Run CircleCI artifacts redirector - steps: - - name: GitHub Action step - uses: larsoner/circleci-artifacts-redirector-action@master - with: - repo-token: ${{ secrets.GITHUB_TOKEN }} - artifact-path: 0/docs/index.html - circleci-jobs: build_docs - job-title: See the built docs here! diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index e72696e26a0..14161dfbd81 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -126,8 +126,8 @@ make html Then open `docs/build/html/index.html` in your favorite browser. The docs are also automatically built when you submit a PR. The job that -builds the docs is named `build_docs`. If that job passes, a link to the -rendered docs will be available in a job called `See the built docs here!`. +builds the docs is named `build_docs`. You can access the rendered docs by +clicking on that job and then going to the "Artifacts" tab. ### New model From d6fee5a4c4518ddb11f3dc1b52c102a7bdad5b49 Mon Sep 17 00:00:00 2001 From: Ivan Kobzarev Date: Mon, 10 May 2021 03:00:38 -0700 Subject: [PATCH 038/279] [android][circle_ci] android build job (#3679) Co-authored-by: Francisco Massa --- .circleci/config.yml | 55 +++++++++++++++++++ .circleci/config.yml.in | 46 ++++++++++++++++ .circleci/regenerate.py | 27 +++++++++ .../android/scripts/binary_android_build.sh | 27 +++++++++ .../android/scripts/binary_android_upload.sh | 34 ++++++++++++ .../android/scripts/install_gradle.sh | 19 +++++++ android/build.gradle | 1 + android/gradle.properties | 2 +- android/ops/build.gradle | 3 +- android/test_app/app/build.gradle | 5 +- 10 files changed, 214 insertions(+), 5 deletions(-) create mode 100644 .circleci/unittest/android/scripts/binary_android_build.sh create mode 100644 .circleci/unittest/android/scripts/binary_android_upload.sh create mode 100755 .circleci/unittest/android/scripts/install_gradle.sh diff --git a/.circleci/config.yml b/.circleci/config.yml index 3f22d6b6c35..ca06419e29a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -160,6 +160,14 @@ torchvision_ios_params: &torchvision_ios_params IOS_ARCH: << parameters.ios_arch >> IOS_PLATFORM: << parameters.ios_platform >> +torchvision_android_params: &torchvision_android_params + parameters: + build_environment: + type: string + default: "" + environment: + BUILD_ENVIRONMENT: << parameters.build_environment >> + smoke_test_common: &smoke_test_common <<: *binary_common docker: @@ -394,6 +402,42 @@ jobs: cat "$script" source "$script" + binary_android_build: + <<: *torchvision_android_params + docker: + - image: circleci/android:api-29-ndk + resource_class: xlarge + steps: + - attach_workspace: + at: ~/workspace + - checkout + - run: + name: Build + no_output_timeout: "1h" + command: | + script="/home/circleci/project/.circleci/unittest/android/scripts/binary_android_build.sh" + cat "$script" + source "$script" + - store_artifacts: + path: ~/workspace/artifacts + + binary_android_upload: + <<: *torchvision_android_params + docker: + - image: circleci/android:api-29-ndk + resource_class: xlarge + steps: + - attach_workspace: + at: ~/workspace + - checkout + - run: + name: Upload + no_output_timeout: "1h" + command: | + script="/home/circleci/project/.circleci/unittest/android/scripts/binary_android_upload.sh" + cat "$script" + source "$script" + binary_macos_conda: <<: *binary_common macos: @@ -1506,6 +1550,9 @@ workflows: ios_arch: arm64 ios_platform: OS name: binary_libtorchvision_ops_ios_12.0.0_arm64 + - binary_android_build: + build_environment: binary-libtorchvision_ops-android + name: binary_libtorchvision_ops_android unittest: jobs: @@ -1681,6 +1728,14 @@ workflows: requires: - nightly_binary_libtorchvision_ops_ios_12.0.0_x86_64 - nightly_binary_libtorchvision_ops_ios_12.0.0_arm64 + - binary_android_upload: + build_environment: nightly-binary-libtorchvision_ops-android-upload + context: org-member + filters: + branches: + only: + - nightly + name: nightly_binary_libtorchvision_ops_android_upload - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 0984b8bb961..8f15657ea94 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -160,6 +160,14 @@ torchvision_ios_params: &torchvision_ios_params IOS_ARCH: << parameters.ios_arch >> IOS_PLATFORM: << parameters.ios_platform >> +torchvision_android_params: &torchvision_android_params + parameters: + build_environment: + type: string + default: "" + environment: + BUILD_ENVIRONMENT: << parameters.build_environment >> + smoke_test_common: &smoke_test_common <<: *binary_common docker: @@ -394,6 +402,42 @@ jobs: cat "$script" source "$script" + binary_android_build: + <<: *torchvision_android_params + docker: + - image: circleci/android:api-29-ndk + resource_class: xlarge + steps: + - attach_workspace: + at: ~/workspace + - checkout + - run: + name: Build + no_output_timeout: "1h" + command: | + script="/home/circleci/project/.circleci/unittest/android/scripts/binary_android_build.sh" + cat "$script" + source "$script" + - store_artifacts: + path: ~/workspace/artifacts + + binary_android_upload: + <<: *torchvision_android_params + docker: + - image: circleci/android:api-29-ndk + resource_class: xlarge + steps: + - attach_workspace: + at: ~/workspace + - checkout + - run: + name: Upload + no_output_timeout: "1h" + command: | + script="/home/circleci/project/.circleci/unittest/android/scripts/binary_android_upload.sh" + cat "$script" + source "$script" + binary_macos_conda: <<: *binary_common macos: @@ -934,6 +978,7 @@ workflows: - torchhub_test - torch_onnx_test {{ ios_workflows() }} + {{ android_workflows() }} unittest: jobs: @@ -954,6 +999,7 @@ workflows: - torchhub_test - torch_onnx_test {{ ios_workflows(nightly=True) }} + {{ android_workflows(nightly=True) }} {{ build_workflows(prefix="nightly_", filter_branch="nightly", upload=True) }} docker_build: triggers: diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py index c853ec273e4..e550a9d626b 100755 --- a/.circleci/regenerate.py +++ b/.circleci/regenerate.py @@ -291,6 +291,32 @@ def ios_workflows(indentation=6, nightly=False): return indent(indentation, jobs) +def android_workflows(indentation=6, nightly=False): + jobs = [] + build_job_names = [] + name_prefix = "nightly_" if nightly else "" + env_prefix = "nightly-" if nightly else "" + + name = f'{name_prefix}binary_libtorchvision_ops_android' + build_job_names.append(name) + build_job = { + 'build_environment': f'{env_prefix}binary-libtorchvision_ops-android', + 'name': name, + } + + if nightly: + upload_job = { + 'build_environment': f'{env_prefix}binary-libtorchvision_ops-android-upload', + 'context': 'org-member', + 'filters': gen_filter_branch_tree('nightly'), + 'name': f'{name_prefix}binary_libtorchvision_ops_android_upload' + } + jobs.append({'binary_android_upload': upload_job}) + else: + jobs.append({'binary_android_build': build_job}) + return indent(indentation, jobs) + + if __name__ == "__main__": d = os.path.dirname(__file__) env = jinja2.Environment( @@ -306,4 +332,5 @@ def ios_workflows(indentation=6, nightly=False): unittest_workflows=unittest_workflows, cmake_workflows=cmake_workflows, ios_workflows=ios_workflows, + android_workflows=android_workflows, )) diff --git a/.circleci/unittest/android/scripts/binary_android_build.sh b/.circleci/unittest/android/scripts/binary_android_build.sh new file mode 100644 index 00000000000..0d8c0d47d8a --- /dev/null +++ b/.circleci/unittest/android/scripts/binary_android_build.sh @@ -0,0 +1,27 @@ +#!/bin/bash +set -ex -o pipefail + +echo "DIR: $(pwd)" +echo "ANDROID_HOME=${ANDROID_HOME}" +echo "ANDROID_NDK_HOME=${ANDROID_NDK_HOME}" +echo "JAVA_HOME=${JAVA_HOME}" + +WORKSPACE=/home/circleci/workspace +VISION_ANDROID=/home/circleci/project/android + +. /home/circleci/project/.circleci/unittest/android/scripts/install_gradle.sh + +GRADLE_LOCAL_PROPERTIES=${VISION_ANDROID}/local.properties +rm -f $GRADLE_LOCAL_PROPERTIES + +echo "sdk.dir=${ANDROID_HOME}" >> $GRADLE_LOCAL_PROPERTIES +echo "ndk.dir=${ANDROID_NDK_HOME}" >> $GRADLE_LOCAL_PROPERTIES + +echo "GRADLE_PATH $GRADLE_PATH" +echo "GRADLE_HOME $GRADLE_HOME" + +${GRADLE_PATH} --scan --stacktrace --debug --no-daemon -p ${VISION_ANDROID} assemble || true + +mkdir -p ~/workspace/artifacts +find . -type f -name *aar -print | xargs tar cfvz ~/workspace/artifacts/artifacts-aars.tgz +find . -type f -name *apk -print | xargs tar cfvz ~/workspace/artifacts/artifacts-apks.tgz diff --git a/.circleci/unittest/android/scripts/binary_android_upload.sh b/.circleci/unittest/android/scripts/binary_android_upload.sh new file mode 100644 index 00000000000..1472a877d90 --- /dev/null +++ b/.circleci/unittest/android/scripts/binary_android_upload.sh @@ -0,0 +1,34 @@ +#!/bin/bash +set -ex -o pipefail + +echo "DIR: $(pwd)" +echo "ANDROID_HOME=${ANDROID_HOME}" +echo "ANDROID_NDK_HOME=${ANDROID_NDK_HOME}" +echo "JAVA_HOME=${JAVA_HOME}" + +WORKSPACE=/home/circleci/workspace +VISION_ANDROID=/home/circleci/project/android + +. /home/circleci/project/.circleci/unittest/android/scripts/install_gradle.sh + +GRADLE_LOCAL_PROPERTIES=${VISION_ANDROID}/local.properties +rm -f $GRADLE_LOCAL_PROPERTIES +GRADLE_PROPERTIES=/home/circleci/project/android/gradle.properties + +echo "sdk.dir=${ANDROID_HOME}" >> $GRADLE_LOCAL_PROPERTIES +echo "ndk.dir=${ANDROID_NDK_HOME}" >> $GRADLE_LOCAL_PROPERTIES + +echo "SONATYPE_NEXUS_USERNAME=${SONATYPE_NEXUS_USERNAME}" >> $GRADLE_PROPERTIES +echo "mavenCentralRepositoryUsername=${SONATYPE_NEXUS_USERNAME}" >> $GRADLE_PROPERTIES +echo "SONATYPE_NEXUS_PASSWORD=${SONATYPE_NEXUS_PASSWORD}" >> $GRADLE_PROPERTIES +echo "mavenCentralRepositoryPassword=${SONATYPE_NEXUS_PASSWORD}" >> $GRADLE_PROPERTIES + +echo "signing.keyId=${ANDROID_SIGN_KEY}" >> $GRADLE_PROPERTIES +echo "signing.password=${ANDROID_SIGN_PASS}" >> $GRADLE_PROPERTIES + +cat /home/circleci/project/android/gradle.properties | grep VERSION + +${GRADLE_PATH} --scan --stacktrace --debug --no-daemon -p ${VISION_ANDROID} ops:uploadArchives + +mkdir -p ~/workspace/artifacts +find . -type f -name *aar -print | xargs tar cfvz ~/workspace/artifacts/artifacts-aars.tgz diff --git a/.circleci/unittest/android/scripts/install_gradle.sh b/.circleci/unittest/android/scripts/install_gradle.sh new file mode 100755 index 00000000000..5f803abfa94 --- /dev/null +++ b/.circleci/unittest/android/scripts/install_gradle.sh @@ -0,0 +1,19 @@ +#!/bin/bash +set -ex + +_https_amazon_aws=https://ossci-android.s3.amazonaws.com +GRADLE_VERSION=6.8.3 + +_gradle_home=/opt/gradle +sudo rm -rf $gradle_home +sudo mkdir -p $_gradle_home + +curl --silent --output /tmp/gradle.zip --retry 3 $_https_amazon_aws/gradle-${GRADLE_VERSION}-bin.zip + +sudo unzip -q /tmp/gradle.zip -d $_gradle_home +rm /tmp/gradle.zip + +sudo chmod -R 777 $_gradle_home + +export GRADLE_HOME=$_gradle_home/gradle-$GRADLE_VERSION +export GRADLE_PATH=${GRADLE_HOME}/bin/gradle diff --git a/android/build.gradle b/android/build.gradle index 8e5fb09f827..b905bdf3a17 100644 --- a/android/build.gradle +++ b/android/build.gradle @@ -15,6 +15,7 @@ allprojects { androidSupportAppCompatV7Version = "28.0.0" fbjniJavaOnlyVersion = "0.0.3" soLoaderNativeLoaderVersion = "0.8.0" + pytorchAndroidVersion = "1.9.0-SNAPSHOT" } repositories { diff --git a/android/gradle.properties b/android/gradle.properties index 87804c30107..a8105544f30 100644 --- a/android/gradle.properties +++ b/android/gradle.properties @@ -21,4 +21,4 @@ android.enableJetifier=true testAppAllVariantsEnabled=false -org.gradle.jvmargs=-Xmx4096m +org.gradle.jvmargs=-Xmx12g diff --git a/android/ops/build.gradle b/android/ops/build.gradle index 773e09fb280..df20f6f030d 100644 --- a/android/ops/build.gradle +++ b/android/ops/build.gradle @@ -55,8 +55,7 @@ android { dependencies { implementation 'com.android.support:appcompat-v7:' + rootProject.androidSupportAppCompatV7Version - implementation 'org.pytorch:pytorch_android:1.8.0-SNAPSHOT' - extractForNativeBuild 'org.pytorch:pytorch_android:1.8.0-SNAPSHOT' + extractForNativeBuild "org.pytorch:pytorch_android:$pytorchAndroidVersion" // For testing: deps on local aar files //implementation(name: 'pytorch_android-release', ext: 'aar') diff --git a/android/test_app/app/build.gradle b/android/test_app/app/build.gradle index cc6b4590261..76b2d741793 100644 --- a/android/test_app/app/build.gradle +++ b/android/test_app/app/build.gradle @@ -75,6 +75,7 @@ android { } packagingOptions { doNotStrip '**.so' + pickFirst '**.so' } // Filtering for CI @@ -101,8 +102,8 @@ dependencies { implementation 'com.facebook.soloader:nativeloader:0.8.0' localImplementation project(':ops') - implementation 'org.pytorch:pytorch_android:1.8.0-SNAPSHOT' - implementation 'org.pytorch:pytorch_android_torchvision:1.8.0-SNAPSHOT' + implementation "org.pytorch:pytorch_android:$pytorchAndroidVersion" + implementation "org.pytorch:pytorch_android_torchvision:$pytorchAndroidVersion" aarImplementation(name: 'pytorch_android-release', ext: 'aar') aarImplementation(name: 'pytorch_android_torchvision-release', ext: 'aar') From b56f17ae1ae8a5d08067c7f7444af21fb3b59ca6 Mon Sep 17 00:00:00 2001 From: vfdev Date: Mon, 10 May 2021 15:08:44 +0200 Subject: [PATCH 039/279] Added antialias option to transforms.functional.resize (#3761) * WIP Added antialias option to transforms.functional.resize * Updates according to the review * Excluded these C++ files for iOS build * Added support for mixed downsampling/upsampling * Fixed heap overflow caused by explicit loop unrolling * Applied PR review suggestions - used pytest parametrize instead unittest - cast to scalar_t ptr - removed interpolate aa files for ios/android keeping original cmake version --- android/ops/CMakeLists.txt | 7 + ios/CMakeLists.txt | 7 + test/test_functional_tensor.py | 47 ++ test/test_transforms.py | 4 + .../csrc/ops/cpu/interpolate_aa_kernels.cpp | 485 ++++++++++++++++++ torchvision/csrc/ops/interpolate_aa.cpp | 45 ++ torchvision/csrc/ops/interpolate_aa.h | 25 + torchvision/transforms/functional.py | 14 +- torchvision/transforms/functional_tensor.py | 20 +- torchvision/transforms/transforms.py | 15 +- 10 files changed, 661 insertions(+), 8 deletions(-) create mode 100644 torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp create mode 100644 torchvision/csrc/ops/interpolate_aa.cpp create mode 100644 torchvision/csrc/ops/interpolate_aa.h diff --git a/android/ops/CMakeLists.txt b/android/ops/CMakeLists.txt index ad42adbfa71..3210925a85c 100644 --- a/android/ops/CMakeLists.txt +++ b/android/ops/CMakeLists.txt @@ -14,6 +14,13 @@ file(GLOB VISION_SRCS ../../torchvision/csrc/ops/*.h ../../torchvision/csrc/ops/*.cpp) +# Remove interpolate_aa sources as they are temporary code +# see https://github.com/pytorch/vision/pull/3761 +# and IndexingUtils.h is unavailable on Android build +list(REMOVE_ITEM VISION_SRCS "${CMAKE_CURRENT_LIST_DIR}/../../torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp") +list(REMOVE_ITEM VISION_SRCS "${CMAKE_CURRENT_LIST_DIR}/../../torchvision/csrc/ops/interpolate_aa.cpp") +list(REMOVE_ITEM VISION_SRCS "${CMAKE_CURRENT_LIST_DIR}/../../torchvision/csrc/ops/interpolate_aa.h") + add_library(${TARGET} SHARED ${VISION_SRCS} ) diff --git a/ios/CMakeLists.txt b/ios/CMakeLists.txt index 6b9fd3925b2..2ac46c15018 100644 --- a/ios/CMakeLists.txt +++ b/ios/CMakeLists.txt @@ -11,6 +11,13 @@ file(GLOB VISION_SRCS ../torchvision/csrc/ops/*.h ../torchvision/csrc/ops/*.cpp) +# Remove interpolate_aa sources as they are temporary code +# see https://github.com/pytorch/vision/pull/3761 +# and using TensorIterator unavailable with iOS +list(REMOVE_ITEM VISION_SRCS "${CMAKE_CURRENT_LIST_DIR}/../torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp") +list(REMOVE_ITEM VISION_SRCS "${CMAKE_CURRENT_LIST_DIR}/../torchvision/csrc/ops/interpolate_aa.cpp") +list(REMOVE_ITEM VISION_SRCS "${CMAKE_CURRENT_LIST_DIR}/../torchvision/csrc/ops/interpolate_aa.h") + add_library(${TARGET} STATIC ${VISION_SRCS} ) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 1964e3134ec..f28b6e633d9 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -1018,5 +1018,52 @@ def test_perspective_interpolation_warning(tester): tester.assertTrue(res1.equal(res2)) +@pytest.mark.parametrize('device', ["cpu", ]) +@pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) +@pytest.mark.parametrize('size', [[96, 72], [96, 420], [420, 72]]) +@pytest.mark.parametrize('interpolation', [BILINEAR, ]) +def test_resize_antialias(device, dt, size, interpolation, tester): + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + script_fn = torch.jit.script(F.resize) + tensor, pil_img = tester._create_data(320, 290, device=device) + + if dt is not None: + # This is a trivial cast to float of uint8 data to test all cases + tensor = tensor.to(dt) + + resized_tensor = F.resize(tensor, size=size, interpolation=interpolation, antialias=True) + resized_pil_img = F.resize(pil_img, size=size, interpolation=interpolation) + + tester.assertEqual( + resized_tensor.size()[1:], resized_pil_img.size[::-1], + msg=f"{size}, {interpolation}, {dt}" + ) + + resized_tensor_f = resized_tensor + # we need to cast to uint8 to compare with PIL image + if resized_tensor_f.dtype == torch.uint8: + resized_tensor_f = resized_tensor_f.to(torch.float) + + tester.approxEqualTensorToPIL( + resized_tensor_f, resized_pil_img, tol=0.5, msg=f"{size}, {interpolation}, {dt}" + ) + tester.approxEqualTensorToPIL( + resized_tensor_f, resized_pil_img, tol=1.0 + 1e-5, agg_method="max", + msg=f"{size}, {interpolation}, {dt}" + ) + + if isinstance(size, int): + script_size = [size, ] + else: + script_size = size + + resize_result = script_fn(tensor, size=script_size, interpolation=interpolation, antialias=True) + tester.assertTrue(resized_tensor.equal(resize_result), msg=f"{size}, {interpolation}, {dt}") + + if __name__ == '__main__': unittest.main() diff --git a/test/test_transforms.py b/test/test_transforms.py index 0a01247aa87..9402a37bc35 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -348,6 +348,10 @@ def test_resize(self): self.assertEqual((owidth, oheight), result.size) + with self.assertWarnsRegex(UserWarning, r"Anti-alias option is always applied for PIL Image input"): + t = transforms.Resize(osize, antialias=False) + t(img) + def test_random_crop(self): height = random.randint(10, 32) * 2 width = random.randint(10, 32) * 2 diff --git a/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp b/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp new file mode 100644 index 00000000000..62fec046850 --- /dev/null +++ b/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp @@ -0,0 +1,485 @@ +#include +#include +#include +#include +#include +#include + +#include + +// Code temporary is in torchvision before merging it to PyTorch +namespace at { +namespace native { +namespace internal_upsample { + +using scale_t = std::vector>; + +template +static inline scalar_t interpolate_aa_single_dim_zero_strides( + char* src, + char** data, + int64_t i, + const index_t ids_stride) { + const index_t ids_min = *(index_t*)&data[0][0]; + const index_t ids_size = *(index_t*)&data[1][0]; + + char* src_min = src + ids_min; + + scalar_t t = *(scalar_t*)&src_min[0]; + index_t wts_idx = *(index_t*)&data[4][0]; + scalar_t* wts_ptr = (scalar_t*)&data[3][wts_idx]; + scalar_t wts = wts_ptr[0]; + + scalar_t output = t * wts; + int j = 1; + for (; j < ids_size; j++) { + wts = wts_ptr[j]; + t = *(scalar_t*)&src_min[j * ids_stride]; + output += t * wts; + } + return output; +} + +template +static inline scalar_t interpolate_aa_single_dim( + char* src, + char** data, + const int64_t* strides, + int64_t i, + const index_t ids_stride) { + index_t ids_min = *(index_t*)&data[0][i * strides[0]]; + index_t ids_size = *(index_t*)&data[1][i * strides[1]]; + + char* src_min = src + ids_min; + + scalar_t t = *(scalar_t*)&src_min[0]; + index_t wts_idx = *(index_t*)&data[4][i * strides[4]]; + scalar_t* wts_ptr = (scalar_t*)&data[3][wts_idx]; + scalar_t wts = wts_ptr[0]; + + scalar_t output = t * wts; + int j = 1; + for (; j < ids_size; j++) { + wts = wts_ptr[j]; + t = *(scalar_t*)&src_min[j * ids_stride]; + output += t * wts; + } + return output; +} + +template +static inline void basic_loop_aa_single_dim_zero_strides( + char** data, + const int64_t* strides, + int64_t n) { + char* dst = data[0]; + char* src = data[1]; + // index stride is constant for the given dimension + const index_t ids_stride = *(index_t*)&data[2 + 2][0]; + + for (int64_t i = 0; i < n; i++) { + *(scalar_t*)&dst[i * strides[0]] = + interpolate_aa_single_dim_zero_strides( + src + i * strides[1], &data[2], i, ids_stride); + } +} + +template +static inline void basic_loop_aa_single_dim_nonzero_strides( + char** data, + const int64_t* strides, + int64_t n) { + char* dst = data[0]; + char* src = data[1]; + // index stride is constant for the given dimension + const index_t ids_stride = *(index_t*)&data[2 + 2][0]; + + if (strides[1] == 0) { + for (int64_t i = 0; i < n; i++) { + *(scalar_t*)&dst[i * strides[0]] = + interpolate_aa_single_dim( + src, &data[2], &strides[2], i, ids_stride); + } + } else { + for (int64_t i = 0; i < n; i++) { + *(scalar_t*)&dst[i * strides[0]] = + interpolate_aa_single_dim( + src + i * strides[1], &data[2], &strides[2], i, ids_stride); + } + } +} + +template +static inline bool is_zero_stride(const int64_t* strides) { + bool output = strides[0] == 0; + for (int i = 1; i < m; i++) { + output &= (strides[i] == 0); + } + return output; +} + +template +void ti_cpu_upsample_generic_aa( + at::TensorIterator& iter, + int interp_size = -1) { + TORCH_INTERNAL_ASSERT(interp_size > 0); + + auto loop = [&](char** data, const int64_t* strides, int64_t n) { + if ((strides[0] == sizeof(scalar_t)) && (strides[1] == sizeof(scalar_t)) && + is_zero_stride<3 + 2>(&strides[2])) { + basic_loop_aa_single_dim_zero_strides( + data, strides, n); + } else { + basic_loop_aa_single_dim_nonzero_strides( + data, strides, n); + } + }; + + iter.for_each(loop); +} + +// Helper structs to use with ti_upsample_generic_Nd_kernel_impl +template +struct HelperInterpBase { + static inline void init_indices_weights( + std::vector& output, + int64_t output_size, + int64_t ndims, + int64_t reshape_dim, + int interp_size) { + auto new_shape = std::vector(ndims, 1); + new_shape[reshape_dim] = output_size; + + for (int j = 0; j < interp_size; j++) { + output.emplace_back( + empty(new_shape, CPU(c10::CppTypeToScalarType()))); + output.emplace_back( + empty(new_shape, CPU(c10::CppTypeToScalarType()))); + } + } +}; + +template +struct HelperInterpLinear : public HelperInterpBase { + static const int interp_size = 2; + + static inline std::vector compute_indices_weights( + int64_t input_size, + int64_t output_size, + int64_t stride, + int64_t ndims, + int64_t reshape_dim, + bool align_corners, + const c10::optional opt_scale, + bool antialias, + int& out_interp_size) { + scalar_t scale = area_pixel_compute_scale( + input_size, output_size, align_corners, opt_scale); + TORCH_INTERNAL_ASSERT(antialias); + + return _compute_indices_weights_aa( + input_size, + output_size, + stride, + ndims, + reshape_dim, + align_corners, + scale, + out_interp_size); + } + + // taken from + // https://github.com/python-pillow/Pillow/blob/6812205f18ca4ef54372e87e1a13ce4a859434df/ + // src/libImaging/Resample.c#L20-L29 + static inline scalar_t _filter(scalar_t x) { + if (x < 0.0) { + x = -x; + } + if (x < 1.0) { + return 1.0 - x; + } + return 0.0; + } + + static inline std::vector _compute_indices_weights_aa( + int64_t input_size, + int64_t output_size, + int64_t stride, + int64_t ndims, + int64_t reshape_dim, + bool align_corners, + scalar_t scale, + int& out_interp_size) { + int interp_size = HelperInterpLinear::interp_size; + scalar_t support = + (scale >= 1.0) ? (interp_size / 2) * scale : interp_size / 2 * 1.0; + interp_size = (int)ceilf(support) * 2 + 1; + + // return interp_size + out_interp_size = interp_size; + + std::vector output; + auto new_shape = std::vector(ndims, 1); + new_shape[reshape_dim] = output_size; + + // ---- Bounds approach as in PIL ----- + // bounds: xmin/xmax + output.emplace_back( + empty(new_shape, CPU(c10::CppTypeToScalarType()))); + output.emplace_back( + empty(new_shape, CPU(c10::CppTypeToScalarType()))); + output.emplace_back( + empty(new_shape, CPU(c10::CppTypeToScalarType()))); + + { + // Weights + new_shape[reshape_dim] = output_size * interp_size; + auto wts = empty(new_shape, CPU(c10::CppTypeToScalarType())); + auto strides = wts.strides().vec(); + strides[reshape_dim] = 0; + new_shape[reshape_dim] = output_size; + wts = wts.as_strided(new_shape, strides); + output.emplace_back(wts); + // Weights indices + output.emplace_back( + empty(new_shape, CPU(c10::CppTypeToScalarType()))); + } + + scalar_t center, total_w, invscale = (scale >= 1.0) ? 1.0 / scale : 1.0; + index_t zero = static_cast(0); + int64_t* idx_ptr_xmin = output[0].data_ptr(); + int64_t* idx_ptr_size = output[1].data_ptr(); + int64_t* idx_ptr_stride = output[2].data_ptr(); + scalar_t* wt_ptr = output[3].data_ptr(); + int64_t* wt_idx_ptr = output[4].data_ptr(); + + int64_t xmin, xmax, j; + + for (int64_t i = 0; i < output_size; i++) { + center = scale * (i + 0.5); + xmin = std::max(static_cast(center - support + 0.5), zero); + xmax = + std::min(static_cast(center + support + 0.5), input_size) - + xmin; + idx_ptr_xmin[i] = xmin * stride; + idx_ptr_size[i] = xmax; + idx_ptr_stride[i] = stride; + + wt_idx_ptr[i] = i * interp_size * sizeof(scalar_t); + + total_w = 0.0; + for (j = 0; j < xmax; j++) { + scalar_t w = _filter((j + xmin - center + 0.5) * invscale); + wt_ptr[i * interp_size + j] = w; + total_w += w; + } + for (j = 0; j < xmax; j++) { + if (total_w != 0.0) { + wt_ptr[i * interp_size + j] /= total_w; + } + } + + for (; j < interp_size; j++) { + wt_ptr[i * interp_size + j] = static_cast(0.0); + } + } + return output; + } +}; + +template < + typename index_t, + int out_ndims, + typename scale_type, + template + class F> +void _ti_separable_upsample_generic_Nd_kernel_impl_single_dim( + Tensor& output, + const Tensor& input, + int interp_dim, + bool align_corners, + const scale_type& scales, + bool antialias) { + // input can be NCHW, NCL or NCKHW + auto shape = input.sizes().vec(); + auto strides = input.strides().vec(); + auto oshape = output.sizes(); + + TORCH_INTERNAL_ASSERT( + shape.size() == oshape.size() && shape.size() == 2 + out_ndims); + TORCH_INTERNAL_ASSERT(strides.size() == 2 + out_ndims); + TORCH_INTERNAL_ASSERT(antialias); + + for (int i = 0; i < out_ndims; i++) { + shape[i + 2] = oshape[i + 2]; + } + strides[interp_dim] = 0; + auto restrided_input = input.as_strided(shape, strides); + + std::vector> indices_weights; + + int interp_size = F::interp_size; + auto input_scalar_type = input.scalar_type(); + + if (interp_size == 1 && input_scalar_type == at::ScalarType::Byte) { + // nearest also supports uint8 tensor, but we have to use float + // with compute_indices_weights + input_scalar_type = at::ScalarType::Float; + } + + AT_DISPATCH_FLOATING_TYPES_AND( + at::ScalarType::Byte, + input_scalar_type, + "compute_indices_weights_generic", + [&] { + indices_weights.emplace_back( + F::compute_indices_weights( + input.size(interp_dim), + oshape[interp_dim], + input.stride(interp_dim) * input.element_size(), + input.dim(), + interp_dim, + align_corners, + scales[interp_dim - 2], + antialias, + interp_size)); + }); + + TensorIteratorConfig config; + config.check_all_same_dtype(false) + .declare_static_dtype_and_device(input.scalar_type(), input.device()) + .add_output(output) + .add_input(restrided_input); + + for (auto& idx_weight : indices_weights) { + for (auto& tensor : idx_weight) { + config.add_input(tensor); + } + } + + auto iter = config.build(); + + if (interp_size > 1) { + // Nearest also supports uint8 tensor, so need to handle it separately + AT_DISPATCH_FLOATING_TYPES(iter.dtype(), "upsample_generic_Nd", [&] { + ti_cpu_upsample_generic_aa( + iter, interp_size); + }); + } else { + AT_DISPATCH_FLOATING_TYPES_AND( + at::ScalarType::Byte, iter.dtype(), "upsample_generic_Nd", [&] { + ti_cpu_upsample_generic_aa( + iter, interp_size); + }); + } +} + +template < + typename index_t, + int out_ndims, + typename scale_type, + template + class F> +void ti_separable_upsample_generic_Nd_kernel_impl( + Tensor& output, + const Tensor& input, + bool align_corners, + const scale_type& scales, + bool antialias) { + auto temp_oshape = input.sizes().vec(); + at::Tensor temp_output, temp_input = input; + for (int i = 0; i < out_ndims - 1; i++) { + int interp_dim = 2 + out_ndims - 1 - i; + temp_oshape[interp_dim] = output.sizes()[interp_dim]; + temp_output = at::empty(temp_oshape, input.options()); + _ti_separable_upsample_generic_Nd_kernel_impl_single_dim< + index_t, + out_ndims, + scale_t, + HelperInterpLinear>( + temp_output, temp_input, interp_dim, align_corners, scales, antialias); + temp_input = temp_output; + } + _ti_separable_upsample_generic_Nd_kernel_impl_single_dim< + index_t, + out_ndims, + scale_t, + HelperInterpLinear>( + output, temp_input, 2, align_corners, scales, antialias); +} + +void _ti_upsample_bilinear2d_kernel_impl( + Tensor& output, + const Tensor& input, + bool align_corners, + c10::optional scales_h, + c10::optional scales_w, + bool antialias) { + ti_separable_upsample_generic_Nd_kernel_impl< + int64_t, + 2, + scale_t, + HelperInterpLinear>( + output, input, align_corners, {scales_h, scales_w}, antialias); +} + +} // namespace internal_upsample +} // namespace native +} // namespace at + +namespace vision { +namespace ops { + +namespace { + +at::Tensor interpolate_linear_aa_forward_kernel( + const at::Tensor& input, + at::IntArrayRef output_size, + bool align_corners) { + TORCH_CHECK(input.device().is_cpu(), "input must be a CPU tensor"); + + c10::optional> scale_factors = {}; + + // Copied from UpSampleBilinear2d.cpp + auto output = at::empty({0}, input.options()); + auto osize = at::native::upsample::compute_output_size( + input.sizes(), output_size, scale_factors); + auto scale_h = at::native::upsample::get_scale_value(scale_factors, 0); + auto scale_w = at::native::upsample::get_scale_value(scale_factors, 1); + auto full_output_size = + at::native::upsample_2d_common_check(input.sizes(), osize); + + // Allow for empty batch size but not other dimensions + TORCH_CHECK( + input.numel() != 0 || + c10::multiply_integers( + input.sizes().begin() + 1, input.sizes().end()), + "Non-empty 4D data tensor expected but got a tensor with sizes ", + input.sizes()); + + output.resize_(full_output_size, input.suggest_memory_format()); + at::native::internal_upsample::_ti_upsample_bilinear2d_kernel_impl( + output, input, align_corners, scale_h, scale_w, /*antialias=*/true); + return output; +} + +// TODO: Implement backward function +// at::Tensor interpolate_linear_aa_backward_kernel( +// const at::Tensor& grad) { +// return grad_input; +// } + +} // namespace + +TORCH_LIBRARY_IMPL(torchvision, CPU, m) { + m.impl( + TORCH_SELECTIVE_NAME("torchvision::_interpolate_linear_aa"), + TORCH_FN(interpolate_linear_aa_forward_kernel)); + // TODO: Implement backward function + // m.impl( + // TORCH_SELECTIVE_NAME("torchvision::_interpolate_linear_aa_backward"), + // TORCH_FN(interpolate_linear_aa_backward_kernel)); +} + +} // namespace ops +} // namespace vision diff --git a/torchvision/csrc/ops/interpolate_aa.cpp b/torchvision/csrc/ops/interpolate_aa.cpp new file mode 100644 index 00000000000..209cc73cf76 --- /dev/null +++ b/torchvision/csrc/ops/interpolate_aa.cpp @@ -0,0 +1,45 @@ +#include "interpolate_aa.h" + +#include + +namespace vision { +namespace ops { + +at::Tensor interpolate_linear_aa( + const at::Tensor& input, // Input image + at::IntArrayRef output_size, // Output image size + bool align_corners) // The flag to align corners +{ + static auto op = + c10::Dispatcher::singleton() + .findSchemaOrThrow("torchvision::interpolate_linear_aa", "") + .typed(); + return op.call(input, output_size, align_corners); +} + +namespace detail { + +// TODO: Implement backward function +// at::Tensor _interpolate_linear_aa_backward( +// const at::Tensor& grad, +// at::IntArrayRef output_size, +// bool align_corners) +// { +// return at::Tensor(); +// } + +} // namespace detail + +TORCH_LIBRARY_FRAGMENT(torchvision, m) { + m.def(TORCH_SELECTIVE_SCHEMA( + "torchvision::_interpolate_linear_aa(Tensor input, int[] output_size, bool align_corners) -> Tensor")); + // TODO: Implement backward function + // m.def(TORCH_SELECTIVE_SCHEMA( + // "torchvision::_interpolate_linear_aa_backward(Tensor grad, Tensor rois, + // float spatial_scale, int pooled_height, int pooled_width, int + // batch_size, int channels, int height, int width, int sampling_ratio, + // bool aligned) -> Tensor")); +} + +} // namespace ops +} // namespace vision diff --git a/torchvision/csrc/ops/interpolate_aa.h b/torchvision/csrc/ops/interpolate_aa.h new file mode 100644 index 00000000000..acadce49392 --- /dev/null +++ b/torchvision/csrc/ops/interpolate_aa.h @@ -0,0 +1,25 @@ +#pragma once + +#include +#include "../macros.h" + +namespace vision { +namespace ops { + +VISION_API at::Tensor _interpolate_linear_aa( + const at::Tensor& input, + at::IntArrayRef output_size, + bool align_corners = false); + +namespace detail { + +// TODO: Implement backward function +// at::Tensor _interpolate_linear_aa_backward( +// const at::Tensor& grad, +// at::IntArrayRef output_size, +// bool align_corners=false); + +} // namespace detail + +} // namespace ops +} // namespace vision diff --git a/torchvision/transforms/functional.py b/torchvision/transforms/functional.py index 855ce19bde4..17dd649159e 100644 --- a/torchvision/transforms/functional.py +++ b/torchvision/transforms/functional.py @@ -341,7 +341,7 @@ def normalize(tensor: Tensor, mean: List[float], std: List[float], inplace: bool def resize(img: Tensor, size: List[int], interpolation: InterpolationMode = InterpolationMode.BILINEAR, - max_size: Optional[int] = None) -> Tensor: + max_size: Optional[int] = None, antialias: Optional[bool] = None) -> Tensor: r"""Resize the input image to the given size. If the image is torch Tensor, it is expected to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions @@ -375,6 +375,12 @@ def resize(img: Tensor, size: List[int], interpolation: InterpolationMode = Inte smaller edge may be shorter than ``size``. This is only supported if ``size`` is an int (or a sequence of length 1 in torchscript mode). + antialias (bool, optional): antialias flag. If ``img`` is PIL Image, the flag is ignored and anti-alias + is always used. If ``img`` is Tensor, the flag is False by default and can be set True for + ``InterpolationMode.BILINEAR`` only mode. + + .. warning:: + There is no autodiff support for ``antialias=True`` option with input ``img`` as Tensor. Returns: PIL Image or Tensor: Resized image. @@ -391,10 +397,14 @@ def resize(img: Tensor, size: List[int], interpolation: InterpolationMode = Inte raise TypeError("Argument interpolation should be a InterpolationMode") if not isinstance(img, torch.Tensor): + if antialias is not None and not antialias: + warnings.warn( + "Anti-alias option is always applied for PIL Image input. Argument antialias is ignored." + ) pil_interpolation = pil_modes_mapping[interpolation] return F_pil.resize(img, size=size, interpolation=pil_interpolation, max_size=max_size) - return F_t.resize(img, size=size, interpolation=interpolation.value, max_size=max_size) + return F_t.resize(img, size=size, interpolation=interpolation.value, max_size=max_size, antialias=antialias) def scale(*args, **kwargs): diff --git a/torchvision/transforms/functional_tensor.py b/torchvision/transforms/functional_tensor.py index 156d49150bc..e29065e6ec0 100644 --- a/torchvision/transforms/functional_tensor.py +++ b/torchvision/transforms/functional_tensor.py @@ -470,7 +470,13 @@ def pad(img: Tensor, padding: List[int], fill: int = 0, padding_mode: str = "con return img -def resize(img: Tensor, size: List[int], interpolation: str = "bilinear", max_size: Optional[int] = None) -> Tensor: +def resize( + img: Tensor, + size: List[int], + interpolation: str = "bilinear", + max_size: Optional[int] = None, + antialias: Optional[bool] = None +) -> Tensor: _assert_image_tensor(img) if not isinstance(size, (int, tuple, list)): @@ -494,6 +500,12 @@ def resize(img: Tensor, size: List[int], interpolation: str = "bilinear", max_si "i.e. size should be an int or a sequence of length 1 in torchscript mode." ) + if antialias is None: + antialias = False + + if antialias and interpolation not in ["bilinear", ]: + raise ValueError("Antialias option is supported for bilinear interpolation mode only") + w, h = _get_image_size(img) if isinstance(size, int) or len(size) == 1: # specified size only for the smallest edge @@ -524,7 +536,11 @@ def resize(img: Tensor, size: List[int], interpolation: str = "bilinear", max_si # Define align_corners to avoid warnings align_corners = False if interpolation in ["bilinear", "bicubic"] else None - img = interpolate(img, size=[new_h, new_w], mode=interpolation, align_corners=align_corners) + if antialias: + # Apply antialias for donwsampling on both dims + img = torch.ops.torchvision._interpolate_linear_aa(img, [new_h, new_w], align_corners=False) + else: + img = interpolate(img, size=[new_h, new_w], mode=interpolation, align_corners=align_corners) if interpolation == "bicubic" and out_dtype == torch.uint8: img = img.clamp(min=0, max=255) diff --git a/torchvision/transforms/transforms.py b/torchvision/transforms/transforms.py index dd87cc2b82c..4e013227be1 100644 --- a/torchvision/transforms/transforms.py +++ b/torchvision/transforms/transforms.py @@ -257,10 +257,16 @@ class Resize(torch.nn.Module): smaller edge may be shorter than ``size``. This is only supported if ``size`` is an int (or a sequence of length 1 in torchscript mode). + antialias (bool, optional): antialias flag. If ``img`` is PIL Image, the flag is ignored and anti-alias + is always used. If ``img`` is Tensor, the flag is False by default and can be set True for + ``InterpolationMode.BILINEAR`` only mode. + + .. warning:: + There is no autodiff support for ``antialias=True`` option with input ``img`` as Tensor. """ - def __init__(self, size, interpolation=InterpolationMode.BILINEAR, max_size=None): + def __init__(self, size, interpolation=InterpolationMode.BILINEAR, max_size=None, antialias=None): super().__init__() if not isinstance(size, (int, Sequence)): raise TypeError("Size should be int or sequence. Got {}".format(type(size))) @@ -278,6 +284,7 @@ def __init__(self, size, interpolation=InterpolationMode.BILINEAR, max_size=None interpolation = _interpolation_modes_from_int(interpolation) self.interpolation = interpolation + self.antialias = antialias def forward(self, img): """ @@ -287,12 +294,12 @@ def forward(self, img): Returns: PIL Image or Tensor: Rescaled image. """ - return F.resize(img, self.size, self.interpolation, self.max_size) + return F.resize(img, self.size, self.interpolation, self.max_size, self.antialias) def __repr__(self): interpolate_str = self.interpolation.value - return self.__class__.__name__ + '(size={0}, interpolation={1}, max_size={2})'.format( - self.size, interpolate_str, self.max_size) + return self.__class__.__name__ + '(size={0}, interpolation={1}, max_size={2}, antialias={3})'.format( + self.size, interpolate_str, self.max_size, self.antialias) class Scale(Resize): From 00ea88c0a7ba94bf019730540a51c2577e740f07 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 10 May 2021 14:42:21 +0100 Subject: [PATCH 040/279] Convert "tensor transforms" notebook into a sphinx-gallery example (#3780) --- docs/source/transforms.rst | 16 +++ gallery/assets/dog1.jpg | Bin 0 -> 97422 bytes gallery/assets/dog2.jpg | Bin 0 -> 90796 bytes gallery/assets/imagenet_class_index.json | 1 + gallery/plot_scripted_tensor_transforms.py | 145 +++++++++++++++++++++ gallery/plot_transforms.py | 3 +- 6 files changed, 164 insertions(+), 1 deletion(-) create mode 100644 gallery/assets/dog1.jpg create mode 100644 gallery/assets/dog2.jpg create mode 100644 gallery/assets/imagenet_class_index.json create mode 100644 gallery/plot_scripted_tensor_transforms.py diff --git a/docs/source/transforms.rst b/docs/source/transforms.rst index e94c51fe560..59479f23899 100644 --- a/docs/source/transforms.rst +++ b/docs/source/transforms.rst @@ -1,3 +1,5 @@ +.. _transforms: + torchvision.transforms ====================== @@ -33,6 +35,20 @@ images of a given batch, but they will produce different transformations across calls. For reproducible transformations across calls, you may use :ref:`functional transforms `. +The following examples illustate the use of the available transforms: + + * :ref:`sphx_glr_auto_examples_plot_transforms.py` + + .. figure:: ../source/auto_examples/images/sphx_glr_plot_transforms_001.png + :align: center + :scale: 65% + + * :ref:`sphx_glr_auto_examples_plot_scripted_tensor_transforms.py` + + .. figure:: ../source/auto_examples/images/sphx_glr_plot_scripted_tensor_transforms_001.png + :align: center + :scale: 30% + .. warning:: Since v0.8.0 all random transformations are using torch default random generator to sample random parameters. diff --git a/gallery/assets/dog1.jpg b/gallery/assets/dog1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..df29f9d97043337d85ec53729364db818e7f923c GIT binary patch literal 97422 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

6zWLG3~MtJ2?@qQDMI9uF{j>m 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 DPA-*# literal 0 HcmV?d00001 diff --git a/gallery/assets/dog2.jpg b/gallery/assets/dog2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..528dfec7209cd3bbb415cf610a57b8955149d028 GIT binary patch literal 90796 zcmeFZbzEEB@;4gXY0;v^-9nHOq%H35))EpVK#)LjTBJpSYjJmXDbOOt-JRl6q%G2x z8aMRxInTN8@0|DE_x^j&3j4EXul1c-GqYyz?7hj%_2Tsg;I^8QsuBPL0|TIf{s68w zgR00mw1102pZMW~0Nv`MtMB)AWC62QGg)uMzB3;bTN8EPxt%yuf4LWrVcYmP#7o(0--s9AYnJ>)nE#MN zj>cpDp|gSL0d&Lv{ki^Ef8D5#MqaM~xqM2-J1pe(=afxuyJtl@CgWs(151f z0JNvDFtM?4aImq_=m7LM0GkYloJCj`mqHhU$LdB23X0FeXOpYzrqY}G$Sz`y3??9? zzC%Mx$HB?P&BH4yCVo!>EGe&`sHCi-s-|yXXk=_+Y6gYb*xK2{9o#*hczSvJ_=Y@x z5gHaAfl5eBN=|v1nwFklP*_x4Qd(AC-_Y39+|t_is;BpDU;n`1(D3xk?A-jq;?nZw z*7nZs-u}Vi`%h=*7nh&Ee7*X1W7mzHf3<%Y_P^LghPDe68ygE7@5U|+OfU3?MTU*T zB8*EetBVJ5qhJLE;Zw@R=hbx+u!-n>q_Rd%5mK{@ZgPCOG3~cy|L+V7{{LjzKMnia zu4Mo*76y9pu*d)p06l{0FYs!paI08(E8)S)`bIS@XG$0&&`e{nyNFLKLwZuByM{@K zbOBX95f$0Mm!IY0A;+}^&G%{#4|N1a<1E?Z&(>3qw3g#1Vf}`w%8ehY2&mYCbQoTP ztBAJZmLi6^vu0twe#ZCNJ?VouA`Z>^O!}MOeo`3$@~XHvECFklLY!B3U^9BdQUTyc zif9kUulgCn;zRE+%!7<27)PsR zmR6|q)r&WHBx)`{Z+pkK%7^$bX2zR~j&r7()G61%Iz}wz1{F41i8TF!67&Ote*^#D!`u*aoAHC@*z1qoB ziO+`p41dZh=u%wii)Pf8s}s{@+aWOeECLVAVZ@~1sw1g~;dfd~Ions2?$DH3weMh= zg73BYM@SXualh6hVcP_{bscF3Kk=X~>Ikot>K=!iOi3NU*18#2POz%1R+pQe|1xOh zUgIlzu8jXqc)z8|_ULo4H_ltTSheXj)fs43#|#k*FnZ}Ce|+BY2@x0GbYbvS)hy40 zEK@;StIeP?ms$?%$^+|GIc49&s@Va$%x$(NcQ5;Ga*9l&zN(?@IoGFF!YEcAdk^ZD z^k)P+MoD@+*g&cfYqd9{;3{upPc2tR=TPEJGtYsE#O$`x4~Ubhsvm1@$!&M%iex$n zXybBHFYYGCdhT2UD#46p#|lvg`|-OYb@j4Yvziz=0=AeZo@YK8q=lD6x#@AH`6 z$!U*C))lF!4Sf%{TOD=FPA=JT3e?!f2?NYA30S*{ujYck&5rqh(ZJYLmeu8`8iUqZ zv%Lv^n%qz#p(Q*9DVMlwy^q;c8KdHmXmaZ4Y$fk&5T#J0BzajfKx^Mi)+b51x+ZBr z&sw!yDu-jWw!)P(4Z~VAR(Eqat<+ZAzf|{BX~A^mjZ2H93tswQF7D9Jy3%@487aXL zpKe4W+r`!C1m6%hmNt~Z&RQ}%3d8F(Z=`?f`P1Pz1vN~dmBssfR8O-IQ7Wp4P<@{J zsn4K3%xwZf5YvY5iM; zenq&Fp2};_E=E4lM{g5s6}OvIU=)}Sd$NK+*sxpPs6r(f-c@_Fiz z;o|bC%~P2pb^`gt5Jay(y@i%lflE*-2{cM`nAQCK`CnAl&pp}Lc5tiA%_7`cnbu-{ zU1mb87p0Bj-;kLpBgk>E%F3Lk`4lWwgJ=N0bPEm5MzP)!R3R?3kPeSiK0ob5;o~uR z@rWX#hSJ#D3f|&-<06JuoArD;LaF7#I!;mFhYAH6U3sILk0hUd^v`cT6__(1=gr*S zS;nKB!Hp3zY4t87>pkn2;T=!h1K|NSo)nliy~`?)sCWf?a}Y^h4Fp#>AA}FA3#ud6 zl_99Xbfwm$HU`qm$<9K3vt7wAl^I23vAklKdG~kUutsjgG}+Ee$KYY+I(phjj4PVf znqu%Oo88S#lTrw)=9&Lo*PboG2sc|>`q=iRc+7n_Ifyc3byiX8J)E;DPhT$#k6^lF zDsos&eVF@59cjARrRNG39q~aaHYv$yn)}{PDG)Oz5gZ%`$du2gh7G#4Fr#V^gcfU5 z&#E0Q*-R)4?V@zDUvdnXGu+L)yHfU$X0L7OOJpOM8MnH|M4s`;Z{eP=_;{r-qdak_2?Of68&uGFc7@`X*tjMjcp-GYLc?S+u zIGc~$QI&zb+!f5(A~d(xc~-!XsL^H&B$ zUqJgo$2nNX(hY@j1VV8frh(FQaT`387M>E{2c^r1K+boQ`HhCygi_j(;H_7s0xZe( z!vtlv4KFZQ9u5>eI><_!=!65ZDr9n<5}_y__{qv(SIervTekawdf`0_o#GFQ8DoVODZF zFzPqm%?2FWpRXRQ8zaTXDCgFNM1>5AJ~}XJ09PTDvszKRmjt)30k_nSpA0t8xcKf? zpUf42^GH?NN;D~(c_r3)T88O}N$0ec9>%gJCN4Mb>F(CDHEAkW^$^L;XRsZ1-S(*lR~WgPK(-7EOIhO$af#|W#~;ayk9r%#5Xd}Q{_?UvtuE$(cEk$P z-4`xL4o}}Jli}quPT7!(VwewXd3zT^!&U^pQ#SJ8#mnPqDLTvLKA;M&0TJ+3?GzPak>!k+ zyd3)bp7=}Kh$ULl+_slqRqjS!6(t%NNu33804`3Eql@aiUM^jfS6fo<#t7;ZC}QT? zMTA|V2tV{@y7G-xrOH;Ct0{q2G<`d$BiXr!eNo1fp0mS}(Z!S4 z71R0mn#Tsx-(_nQRTchgkw&t55xxtFztX~nZGZ%8oA@ipLw2QhEwRu;CzhXAcrzLes0)W4p| z+$*DPErzcQ*pIx@6EPA~-J}V7`p0mVO|*d$z%+9gin< zVA1+IbX>NrLDTZ->=TE9H}p$EN2W(kckfGnDf5_8E08Q&I8mi>$ocL&6*{>sHX`p3 zp0<$=iGb#~eb8RYb8kQf*iOONyu^aG9KY^QXE+k8J=M8Y!ZbOpjj0Oc2Kmj4=WZW= zp25VA-ce>$xr$&gm_2pXRkd}7R=-PRhdO70G<7*J%GG!!_?gA6u6fI( zp5=3I*}zuXZO#-wsvJXAPE}T2YLIb-*H3thXANyc5Tk^^H;SUBumW z*CJ9izNc19M>-`@h4Q~j(+kR1uzaZqSfGm7UwVQ}_m*a)QmSN4`t`i*Ac$=)??q_^ z9;#7?J4){l*OV~8rJE5wcfG~zmtRE5XlxafGgywUgqh?EDyfvf7i_(0lDa5IO3ma( zeu$>%E7I6g`p*g26S+C>Anyf5hq1mQdC-4P6*CtrD5fbw99w~Gz8wA)ZgRIjoP9VY zd?wV3%~@*3dH1Y~3tWirRi=*;VrJ%nTH<1<;^s)QtP^`|Ncp_=O8BDIk@{2&L zVA;*0j_N5@v%DdRW1OZO5|qb5fl^OO(%77DnYmFm@^`ZxOZm=HSPan#vt`a~yS5QJ zbi5z$SqbhzjT&NfAS{UnI+LLeioqZP$KY3S=>K=@xaaSw7AxV=MiR624K79>zt*& zMV%Sh@cY+r8LdX|Y`)gd7D_SEF%KEs4NnC+8qZl@>;ZNGE{`rV9EM;d7m@BAp-Yz8o%+E8J zQu}2^y31gs*-Uca*6*m%&vm7`RVK|x-0p`Old7Pe%Nl6_S{YMiF@zG0dXSj0$MQ4j zni`v$8h)CbiHUMCa8h)~PfVPEXlE-WxSF4COOy&bFEHnRFrqaW8mjVX1nth+Cplj! ztEGh!9{Y!k^HS82;_}=MUc&oWZO54*Nv?V4p_DtyU${)FF5L+k-O5_>TyWap^P#!E ztq7g$xl-R&@@xaCq)t8P0UJuyjyWVoWX!?NDp~6z&`lQ!!;_KH-)V)1u zp6Wb%?wjsVu6iykDKLc0M;JOevAp9E?8VW6=A4hYeH+z$_SvT(+InKmFp=GtT)69p zqZ$#lrS90L1enr(&U|%KZF?K;#20fdZ>|S1s^ww4zIEDZ1B#Gew^~u(1F~lJJYt>c zXUS!MIxK`AJ6{Y{o>snt-4e9OJTV%O57Z*joxb>bBDB7>o3>-^)>7m#zq|@m_-Mg8 z~WUnPfF&KVyT{_WtxhG9L+nP-4fNXyMNo{!h zP{)C{yEo{v>ZslQjVGX-yj+wYf3My#IsI`ORo6TFN-0C4zEK$AWMh)L3%kSp6P;AM zVEcz~j#{J|s!T*5K)+7wAlCww z(HwhxPrkF~ru%er!I{&f3%lyVrypUI*{E$)dmU$EJqa^wU^$*s6l%)_5xq*ra62+6 z!SVGhXN=_o$7fzK&$8V0Ser9pL@%`V-?*c8pC6Ae5ao%En6R{r2wX(~!e%X!DG}Zn^=;9%Ox z6?L}sLzUZD)YAS=nirxQ^e1nX9UT>Z6|N3yh~40JCdWc z9M{@(6MV}sOIYvB>x()u?q!vjHv)tAier0)Rk;(4Fx;0j&CReZwWMI-fnY4rIbGWE zW32g3^2elyc($Jz4BQXtM1Me39;;1%7FpfQf9c2|F3ZT?h@(gy}VNLn&+{3^5pr5caEP6qT@o09hFgA!r6(*r^#xHZ$FzjpTqs} zGSq)pVL&=YQ*^bNqF#D8I9S43yGa|{c_)Z$`9b(c9EYR3ybXFo#f$yn66fq#TnAD{ z_?;5bUF8|&v${ubgkia5`R2pwz{0alq@4I-sAqZk?rQ;_tYB!)5>lKGOvs- zcXyjA)$7iAwwZran0QU)Wt}ORV1;Bqo4Bktnp(h_+~(k99f!hb2U+XHXl=81#E%m{ zq+duKse1)k<5!LhNg+in6hEg)zeKX@ZpJy&`vR*D=CqWalnyD&i!W&VEjkCE^Q+-o zT<+tYRe$f*h5PPBQm6SxP%Sg?r(V62!DAY4mAU_Q@p0h`@!=BUN(n1p)Q1amK1O+? z`u2u4*@(I2wH4AZ<~SMI>avRW?$egU56Hf1>rA;kCkv5w8J4^pc;qOh^>MGjKiGn| zucM6LXArAp`_ack7dMY-EnF)6ZbtXm^REj+RZYb&eW2K`yuI$62fIQ|h7F2J_w2QkT>Ld&V}-xGRkz+i04g*%?@bnas}Tazsj8Gl-WcBO(e`>>0x&)k(5# zQz{)EBl|!tAXh|#4f2AkO1CN0uM8A!5wiTMor!df-x{98BEwriM4^}O%b4U>wR2#; zUVM)OhArrBL@mlsddl<0Zsfybv%Pi^cJ)Am2)toQegDbtVY1mc#3goXV`5}E*u_&? z$GD=x?N*uJ1&@miW=ci7LDBcr0qOAp84HI%s2NuOd~&k3K+`mY+x zR9c=Ip+M`V5*U8zt?hMU0a0t}X5KB)U?PA|BGYi2dX~eEhQ{RZ5_a99)~!xomrzk} z^efXY4oke@?LbFA-6{TEYf#Sydy{^%`(wYFG7l;%&mdX-a6>qFunZku6(FAD)=`Dq!xetIqC}P3&F+=BtqlhAIm2>k55gfFSd4oQ0A6&GlBn zIqYfu2J^@evkax83y}`h&C*k6tUh{H?tbm3B01;trQVW5Cmm48K92p=BJR*pUF`$O z6X)uLLmMM2nn4|_FI~SZP=hTkCi^H?wLu06t~#nB$uqUlVGq`|@p08p!mBEbl7jG5Q^uty0;MXwn%*KC?e zD#cU2Of1OcJ;NdMU#J^=C%8v5^H%-^X@GrOZD~kJMS(j*?vWX&gm^@ zW?TJtC?lwz#s=F|bwP44W7oIY8Mtwx{0?t9Tfm;!%F-dL>gPNCcE%@~ynXRNniE`nSYdbpTX&30GSdTSZY48|N1__m8K$?%J>eaSKVeF2x;E16{+Zf^psEi@jO)KG>LytNz z9Vln4GKRAD29*Z&+Sb0#`Zj_z5L>iYIXSs_qH$N*PM(w8%t-Cpg4Ai@FPa{nR^p{m zq)SyiFuN8!m$4`#snx(#JZ91WMOAodSX3T!oWz(iXs=F-bU``YU*5u8S$JUZr}+8h zH)CSEU(Ac&=q|MHF0DOQWRVjm)vof%uk{XH7w-O2qmO?=boVLGBY2|p3S=d|vprVr zLyc2kO~{2$5|VT~{!7EV!$(e*3Ml-EvB5Flx!F$+*|&|HtQ4rlbYtB5@iwmr%RfML z%tEuFv&RXhu!mSSLEAyG=cuKGp%?A7ni*lkB3FdxS*&{y_P7Gj*j@2pw+WY#^y9|P zN9q+pjJ?nC_*%~%QVj@bHPI6=h7`EOK~%YBe>w_!r1tSDNL1f} zG2?$$j)l@5(BX1$a6 z>`TKJq(pVKqq0e%T`ZTIevGf@k7p^oiI8JGB^q{2@u*B8X&j z1d*?^L#3+)e3qK5Jco^bp4EZJDIFRM0MNNy4gB) z6Aj)GEmsEZelLmoB~f)m<iIfo`{k?R`UQfMZzJGLWo>;mie1s%&8=x6 ze}lo-2xey%ygdTU3tN!klcV4xNeFBzX$T14Q!le|!JXF+wE`*fv@3=;vQtEDr8Xb! zQ5&sfgK)s2HJL!}-kPGjJ(gI@5366rB^ZJLMY7DZDKB~WLBmB~YWr3CaX_cb!}An- zeF?Hy*c-+V+^X>*-z7^IeOsMkr|Xlq^On>I-Cijbe&K8U(OaY2&nNTY(fS5RMfrhm z-EMn|`U|To*@0pQqLFxK;{=0jd>KB*rMaQuXcvmdE>pX%vbH*H*8svZM;_%gc12%? z=uW=h1grg!rc7n>}zcKmT#xQ-US3icHjo>^deDTdp*8EMKE zKQB|>iAh@A`n?nPTaU?3Gk;VUt|6Ypk?t7o#pG*M^S0$~evoX%;85x|uE|d@<1@9f z84q{&!ootUMs|STy^HsJm;!3w6k8kPX%z}6?uO6|oG}%dMfOd1+k9pxrl7~--e)BE zQ6?(pA-cHMCmJWM*}_f?jsN)|S(fu9@QF?}2!#Hb#8SxH+iIVD8Zcs$5=5@90Xf<| z^ChCX%EXhk9A~($a*4X0X~kI@0fOQ!9igg=0F!EwcRxZbN%kt7hr6!65N?>5^BVz&);0~ z1zy(3nO+*8MfU=nH7Ri#lj8VN){?$qOip1$5IFgHAx5ZH}b zZ?t@8MJHZtoS5!{uPzlR!)p`$xYSBndX@x{?LS_!H%3xhJ1Ah4Hi){n7K474*>Qcv zFho>wIdtIgUS5)M1vAs&Id7?{jSbhKWlCM77w~drwy^=)$hRHR=ks&C$oFBgI@J#B zqR(TU#m&tZ8m#cr>M%z8qLRYy2`kO^L)r|7e3GT=RMGgTZBM)9uOWIUIV_5hsfzrM zpWpcT1?;rDXl=9Y{%~k~bbHP^qA-14HU?!v{Hv)V|M2W^c;TfgrLYjuUF2xMn5IK* zl(~&w5sxZ&%4I2M9L1ZFsO*wXH?ziqZL5PGT|2d@>sw;N>6OPAi2 zC2Ptuxl4c@yZcD!o@jLdHtQz6NJ^V2iZ58`b<%0Id*h4@QSX98 zow`Oc$gYH4=-IDMC;NJ3m$Eg*yJ~Ut%WW0v$VdkkPcNI^T4|hX0O^}#4{=o75JSQ9 zca3d~jxmKs&5~s!j#*@>8eTx1ika+^`Fa*Y-~jgTWH^*!Tzi84qrdcnrm5fe83%DSxyn7BK6ARwKk ztQ&BJ$uWM*J!jXlKfa`oKJo5JNmfbjk0UJQaC1TYSVxk)=8cPkXS|1q57d2ZLafna zK~X#D`xOFC2>f=<iXvT8kJwhz2(sl5|T-OtxrUbkx+?zF(EC>aqW;tV&!dQh49G zB*UD({%mEUIV&VBl6qj$ph(~|W?_uPRy><>7lt`rtgk0E%dpkGM;8le*h)-5T;hSn zndsN6JJ6Up9uI)i&}I3Uh{`b=^sHtqUUiYG&xXuB5yfFyfZRL}R)SZw%^n9 zDrTx7y#rVL;h6neF{YGCqKd3`x4@2&g^)h8GWJUOVBePovmEiZld#1BVY!k$=9reqQwk~Yk?mPJ@^F8UE;0L9Z#hL3h^7&EQs)(|; zOWwg7ImtRd;XGATEa(n0hkA6Z20) z?Pdl}e;p+bu$5g(Uw$*-1$K^Qb7|@(=Q&0P_^4?*n4EVJ3oUOb(}BD^XwWujgnFzk;wA*p716@DT)n1E}5qo5Xcmte-GUq$<4|p}H;YZg2{n zu3l8pAI$mwDdvstdW&#L^**DJ|=1hw*uFR2Ok(s;sl`G!1 zmVzgc*R&Ba)GEJ@j7G&LmBdpcbR@Gw&dQUVISknzYrbw|(W(7r*kZMKu)#p=9%M1P zpnJGmNM<9WQZetPH$+U1d1p-XD_gv&Wv{GSLQY3oty~$lD;|UAH~kf`W@ezAQ*ymh(lcV#8FU!ZKep> zg1R31>2*90X(FA}0!gCsvCX}^5yzt#S3YH|!T4-&j^v!ICFei`BGxO7yn9q~1QWFT zKX}SG7s#ajsc7&5m8EpcLN^KvBrC1 zlJ0TgWfxTQ3>wKGEMQ7>CRSEwZAW=|y`^QJlA;J^9@11zpfbx9d)X1mb3ou{oasUqZP)uq~|r@ej_uRKquv^fjFwPKrFo2 zBP~bufIiz;wm^oTKImKEEP-6z;fmW5Y}v}XS_U5R)@MU{1SH*k{d&Z5!KPm7nIIf8@s-fr-Nl#B>|LekPg0`m-?R@h|c~$SNc&d9k>c44Z7> z$4^I&YU!bE0s8WGV(=r33$b+{CVLh}aVJ`0&sui0qmSm`9+%nEmQ#GiA6my+*scK! z`n>RTx%LRsxL`Xa054+0C@_wGKcW}MyqypY+z{-Ke^fbzRwXqbM>H`~n}A&=H_aqMe`AP<8en(TAr!N12djVv1am^Wko5 zBr4}*L~sPlr>;%#ibR*3Q|VTAXtIyE$tK&?s1Z-!C`BYFfu@$1aUM6P5)#L-Y$FL{Yt^#Q}+E#%QY$f|gdU@0z*tDHzok9;@ zdVX=ObW<^nbJPvV`dpB+cpl)Md`w`Hl&KD7<~Z)#WV z(u>M^Xa6f}u%Ublug?U-(`4tVy)fOBEvu0|#psaJD01cPkZ)6<#za;An6AXLpcO{N zdwJO}Co7}s*xl|h3o{e{+@6e`d60EqDi&lg`dISkyA0`zUs;FK4^2KS55PB@H$t*= ze~Dh!hY$DJt!~`L6$v@|6>#{T?Rx2YleEa*!^2flNXXe;5CU_twh@H7AcVXju0q0s zKp}wi18-Ld)X~O++1kbq?kvOlq5TajGaM$vYAmJ+)O3}%v4^YpB5m}2wG5!Xj!-a+ z^}&5+X>Unyge$_v1H$Z$aB_B+^p;`$EnE^!-*gMHGXI8nILfe^pc6RcU63}+qJpA= zKml|ji6@8^EdvR&mDE#E`Xd2-B*XegRWC0uK`#+O7o?q#Fc=IL0)m7nd+U1Fd3@dv6--@9}po-q;jz6Mrj(-bw_kanh zq7OvThM)mLARtge00IyBqkp+6d{{ zxVt<-LTwa1ZJa&W{+i6y>52Ql&h^CI=BDenu1+vpA+(ymSL`qROLZpfZ=Odqh&f1^VQMT~$Gb z^=4K{mtBRHeisjsE7ni00x4I35Z%l#RVipLBawy))1gA7zDZpgNppcuZ@JG zLl)xnuln4`fuZHVM8w6!g~hD}#KmAh0Z|Avy&iD>Do#sf3mUL5Bq#0kN|Ya&Wb=`>nmCJkkc@;es@9adDDi{b!ET zO;G=dSV;{RDC8!pehT}A|0n7%em(TH#N7kwqxzrJ{=WhK5mhQ^4i}`)pSkpH-2PBbaOU5qmLvpv z;|>{CcZjDAjP*|^)E?q&XM?_6p~LteF!;ZTDxfe7C<1|q2}sz2U;^j}fC@<51EHf5 z43+?jf<>)?Fx$WQ-Cb-wydX#$Svz!yqt^x<;J@?Fn7RKE4?KSXz3gpn78{+BCIA!@ z5C$6j$w&k90ns^XK-S;ubaP4ihb=c}F#6>A+svEOTT=BVF7%(cx;nvakbm3$oA=)W z{_gw}LjRHJ@A2O}@-D7E=o7}?L)**w-%s^F5Wo2};7}W9cb9*w+`o(o-B|iB7h|+q zzq`;^_#5({Ul{k9|J(lSf&Y5ozaIFn2mb4U|9as6e;)Yzk<-Q*edFeZexSVG!mL%5 zmw&9Ir>&%_p@>e|N2lB8IzbWc*yv9_s|eSAaP{ibhZAAU=#2rO3{VAV0(1b(0BgV# z036^1@Bj#)_s-}ZcYq#xT<$;c)BWbxL33H7x!?dOnnMBL0zd#Dzxe?-Yk{6a)lrvzvsEB%z$ZY3jmyz001PW006}#06=K| z55J+uZpHxx3jlxt+E*H506;^E=q6B7~>6A=;-k&u$#CLtvwB_g^_eVdGel8TCo_|_d7YDyY%N-E0V zB_6QQJlHq{I5-59Bt#^X|HtjR=cdHN1;zyy2D-YzUnL$G&>s3-3*p8UzZ*6V7A__R z9snO*D1q)zp@hH2&|q}Y3v>a9>p#T?Ze!g>FK0D!1PAk&DnRV3Erm0RfyIU_@^v*} zI^<<`JXd#uFq7*KECIU{eC1x#$(>xH%%M;T#%`EHs zq~60_FobJbebqcE;hb(T!Jj>@*gA6tJhhn0ZF1W*8|DsGP0<%S5!hwepN^WRD^INu zCg%dH7|1ke3w1T&|5&T!@DsMN?{PS=>wy<92MtqmYe@>|*=z9Zi_K3bhff2qh+_(V8ibmt`O}>J$FXo~nBr$fC=uhHYehQco0gi%(3zp*V+rq-X9^xHQjK?zDDiWPm~Y7EZzh zSJ|9T1ydIg9G?zcn;dZvyD$nYWcY?ys@6etMnTf1##FsF;)-YdHr@rHuS2~xi+$;= zY|XgEqv)yrEW&V4U=~6&UDZrEhTnT`a9T%VCaw(BK!cw;c0}>6vc{`x~Ud)LFdcBU)Dcryfudf&xjOlEb~m%?1)JyviT* zA%y8uRL2FDnz$a~(k<+G4B>9Fg$$9-J`3>dN+~@FG}36@;)EqvP8XE1Y<%Wz5eX zWuS+=V_kKq1nW{oSIlM--V`E}F!mgJi#pLwtFA+@3W|+A7A1{>v3l`sWfwxO#!&|l zl?yvmKUY$sTT0@^O1Ve3vufybm=yjLqojWntS)WI{;fk_I&8RSTHe zVu0wfGO+#bR4U)D@Mg$mp-U{&!;0p&_$dx3ArNBGZX8iedAo>%p9N)1jQ2`1H&W5m zT22*wBCqwLZDP#ErYx6-KC34E2bLbh`oh1LkBIUcKa1*+PiXHb3Y<4(#9yynA=y=% z!bVm8qu2R~>q#8kR;*DzD4omRFcC2x?LOi^<}ejE`Y>tkZrpdOb)yvO5mgP2TsfS~ zUFr>O-PeHEm8KUDDJOR`jj1bolW)r`HLp9}F{!6Wsxb4ZVt?P!m*YZYj$BU8z}R=7 zX2XczPt{VxB0~xvX|}~VL#}=j$Tfe*RB5ZLHK;A8LFtIM-(L5OQt`@T*0{XC z`qO!vFHK~G>Ma0vI|){x)!m#oDS9wbl0^R2sjMuK)yTZzQH+t?FRb&){Ln;(uWC!< z&*V0xg_NbT*Ka8(S?Qw2j8=uw3h%DOA`U{Q0@EmLe~$Ir?z1=m3qqoYuUN|>7c zeVo1`MqCo&78mpa4xQdY!`-CK)~k9v3h~;m`!Y(D8uRR0n#plhn%UeY;at+?d`3@S zYpSIs^T-+Y;1mYtn#((8lmi`va68ej?VDNTs4YoT-xg&V7c#PE$LsA8@Zl6nl-`PL zjL^HVB63w$HBrr^;-Pq0p`p0NV@(lV>KO*RD(Q$~-jUQ`7~K~%4D>B*{6w2wM=!^o zsp*Dg4Yj^)5vekZEt8glYUZ*id|8|xyTPVpme!T zrMU8GA&Y3LZmV_+yVxG7%nVMXy4c#m;Tj!Uq}&^X zq85NQMzjxdFYN2ZF;3S-pwvc8tb-~;lJ0w+D%jTH4+Ilv;eavsTBmsOv*3oQPWq6f zo`tcgY+wG;C8;)nN(-g4APORtTcwG+iii7&6-f+Tj8TH4evfSMhW-8UiLg1xC{I8R zun~&-t*$ig*H~BZ<;MI1-0&DG0 zy|cd=-jdXWVd2H`?`5BL~VonA;#!ZM39XvywI zOpVIb@=VG^5{KcEBSOm%#!;9<@E4V|(pgx00{cgz@iR5p(SxEp%A|8EiU{`75|%(g zIik#c86R`?MpKV%0%jxvG|z5?yXS{#rWntIGlin|SeyHH4)#xE zJ!MOINwF*6zeEvBWs$+cN#Pn9*z1u^SH@*onWu^IBFXK?0s*B*Rt^`ZwHV)& zZC0)pw2a$xnA;EvodN29ak{ApYoSRK9^?aP6aEuYq>po3r#YWWHxj*L>{c3fTZ{jChZ}7Sa;b%sKo=- zF;o*p;I5xefLuc11}Vf{{$-C`8uowXWKFH7wb^wIK8bU>B9pU@@OJYs`qqY64ag2F zV$p_^*Bt`P2M>4-S>oUF4BqXDTy8cAu=dV-azqU8;`r=S3F+arKAtE^<8IaAc*Dac z-xD%ER$}KtT5PteATsIXAXrQ;z{UO2$uW3umJ;|j+q z#F(&?qWx2%zIE>l8RlmmX#g9)(>DNSb#q1I>AA3d3&_OUNPX8-6DH~X-;uAI3U}Ra z>i8(X7CMMY(QrDAL5<>MmJwkn$jYZ#3+EWGj8J*mvo%^zKrsZTDP!S_ovbX+ubel} zdJaGEc#g-vKM+Zw*!|w<+tev7}Ag<N+mt3*w3cE=0TT@Mphsg!& zr@f-AT%>Mni<{BxN?-mj0G2>$zYDw%#LzS#lG4SHj;PeaU-kz``<4WPI{lXCXIzbGXlbB_!ek z$CK``A#fD^Zg0>xM|(IM6E8+B48#LFG~5~ zn@ecLg|HbKkUWuzw+BZKVl07J5wW~+tk!{MGe+4UBGLKoy}TjkoaNgYu)!W^VbN>m zH@)1121qP7pLdUNjpgMgKZ5Z$bu4Z;FGRC?>qATg1gtn zRP;Q1ISKdYG$?03NFh)gpx>L){C{%6lJK^@e+tW9VG@z8<#F| zMiCHiC@I^m0-B3B!1c}1zHWnhxnL3{J`hdU&Qk%i-rUQ3MlYP*P+n6p$DQ8bQ~v-@ z&-jH~b=>oug7~q7B{dNXZa(Ud7pvvozlzXbphlGc07HVu%hPT1{VKgex#;<{@{=A; z{{V9Hy(kPkW7zP$7;_+a*qyWn5=4y<&gldi%8RWfvq)pwT+Fqvo-PN5MqhJgy~hI`~mW-jC;cx3-paa-hE}z#U?pXttXuhJb}q zA&wU2$*DJj*0uv+klGgM&T<~gn3bZ9a*9-pyk;;W(bW)bPqbObwr2DOK@1$-1aWmT z>E>(S#ix|KlxfYr$mNVMnXJyn@cIzAjU-)}EgtD+Frmg>?b ze%zw9`JS4&)|1!H9j4odve62IiN`&tp0AcI1&A8%h%4ylWS$OG@?N1{OSW7VnimvH zneJ7P7_(FZ*o_%xA{rJ@{0#k5h2o_@Or2Wt4 zJ||e&>Bg}uk_YH$UtyOPqgdr)iAKZ`Avyan%Ow=ng7OHJ-h^h%@G#yGeUb*-nlAEzhl9Q23@PSsYK zh1At?7}MwzpQv12q<3y@Rt$rjoTQNz$I z%LuU74G?l^)yXyBVG7hk&h208}eoT;6fj z&Z(ma49b0lo%1{2czSGHy)#Oc(jz5ANbxGARx(Dh9Yd>`M{fmNyUrqm>M`^$a=pc7 z2RiOAJDk0nik@xR$XYxFRFmdTw5l7R0X_)~LZrlkotCk>ls7Ji9(9{A+j2BbC)`ns zfibfk=+iGQHS@aM&^%(f~7(W(&EC?}$oh$j>2%}(d9wQ$=_LM8UaH4=P#xn~x3 zm8|0HTqL5po!iehHN8j8>|T10VDbL|OV4TQc>KkIcoJS6Hy(QW4<)-g!yCgYtwm3? z>#qh`zddY|u+82%u3nk~D!t^!kJ7u>P_2!tfY`%{1<*QvU$vp9Pjp@mV z76ui;qI}wU9gz!^gn~oJ`1Hg*PD4>_Fu#dxvMKl3ZOagpqRD|W=;lBj9$(PBQ|Nwl zlb%5I-P4b&(RsSO-d#ST`B_G#2_p-3W{pr16_}7w07^C)Ijx{ewhmtTZpts7vPbR;eCmvh!jkxJ7+Mv_}Pr1JW{XqJg3_HZU~hY4qHmf~Uq7>cR8 ztZoyMZ#*|GnssuGd3eFs$Nk?3%0>Y=+x1UBvi|_jUlI=MAx6>y_EdT-a3sS-p<49@ zAfVnSI!T&f*~;kt~{MS z(Z|u_@1wA@@)r&l9&0vASE<<1k`g^A>pcY{PECTSMz_=#(<|)2;smBA)^|vOBcm6R z-))g7*4d603^A3MlQ~|HvhI3p(85!_*1lV3fr+v$B3Vu*p~WRFjQ$!foj{G3gWo4 z3V<_H=W&y|XxHisYBs}#^OtqFmW4i&`zV0Bx7kGZ)f|R`MoY^fS!k949Z;R^WIiAg zmC|`XfrKO;rtNlu_$^eb5R&ytdUay(6UPdfV#uycdHeJ;e3!qKgSqGn>-H!ea(7=l-TCjVs7C625lL9s`Rv>byq?JMobxlqR%l7+08&dy zLuvYtFGsL$B*LK`s8TsH=p7}N<60)mG1e$%h0g-ebZM2RG<~_@ykVrYLP><}79?)l z16k+#bj}}MtE@6E%!+JcC+n7>X^Ft9#(>zewrkUYWM=6Z_!k9MQY+0stHwWcl1paO(m9+N%;=F*tMpUo@llhY5D;eb_MVcE*3W$!L%yyhwU zCz0xr?GwML`ooiG&;tqwxRW21je`R{VA#p?t~eFPgxCHau_@>e=}Q1o*| zSd_iXho-T4(YrZkA=XxjQT(d+n#@tT^F2he>5Ucz)$6R92i5~Its1YHS35YQ!)@g5 zxpH(d2Iw2N7v27E1qUOMu9EpFNonYXh9wZckr6=4L=rR5<%VUDA#qXaDtcf`8zR;j z8rXDq&h%=YSGfsd7^^Wd+{5iLPO;a`=iY|}7qgOey@QV1Z_T>l+D}*MDqZ3Ecye2c4*;1$|tJAQf9&9)8%y+4nn?72xj;Pj#3^;*pq8*2`z&X7oY zr_nzl^}MxIox6w7wexjgN*s4yW4%wE-=pRP=ashC$?Z7B;PJ#iWH!(f+025+Cr{++ z*@1>JgN@)s=Q+lnNln4(dF$*Gr;rm2L$Q5fo{lFyJXY>&g7u4=q(&c^{f{8AD;S;j zRixTZSbQXWsK9q<7LHz~{$HwE#9<(XT>2}s>5Dm*3e%={`PJLWl&<8TAzJV`F+3ST`izUKic(8-wW=A@z$ z8fO_zWfgLS35r6O69Cor79x_E9~KDpU8S|1$`!i!-q9@{z@{Ukr}KBH){{5RFW)*I z&R;s~ozMk{W-LO7RB^eJBEh!l;wP(zXE*?%1YJfM(f}hbA>&A@2G1d>Mg(=HAUQE< zXtR)!D}A&qeiIlTnlh7A2ZZGz6iD3Vtdh+1WAZ5zA2sAL7_Kb5#Z?jWwf_Lh^vh!4 zq*Fr)&^bLYogFFJ3!1`w*_pw4Q+*C@ffz0nbqIIdCX5tz6EKrrcsn?ONrT!Y02dmN zSaeO!Rc?Ds2Ewz59uGtgXRyeUoSA|yXSO>aMA!#RvIr(qP&n3;1P*4j29h^n!)wM1;a9J~fmhgL59-gnd`OvasS(C#>4-60@$6!#UDL)N&HLaiOL`}W+#KmFMxzB+GHYSF_kIkBp9WI z2qy%Nd&+mCnVVVtm&yH-(4#_>jAL$RzS=anCDIYmV04s0%!xh59mF7+tYsjTVkB)*5r1X++qXupWqhR$NvpAIMc&+Hv1ju1AHCyzzU8Y%%S`JOs~lmy#XO zTodzVkIa0dHvOpa8?nGhv7+!X(N~StA2%jDk&U!3ffPzXk_N1+i^V5@-+$e5zL(@~_PT-9HRM$hBn+*&w96ps~GJ+i2-{ zV(cr#&r2b0iupt}4(P$)p{Q7p&?+TLC#<$ZWBh~ho}DW%iv-Oumh#$@!9@39KO8JH z7mZzN{{Y^8xN_tv3tn;KIb@R&K@|T0n-CEmF${3!lQxyd2O*Sd7|rZ~>aR8e)ej@D z3-jfd;YjIua~k0%_7}S!_FB=aBKbrYml|ceH3jmFbf`$bhZifuRBT16c_~@gkp2%D z>h?!O}H4Ts2xQh-}63gv&{$3Q+* ziu+i&=G_xiiBRKYB$+N&Qe$!8rQzleg0fZNztb;)5qzoyfYps(Ug<=J$SUQ>@jP;r z8ftW<)ug|M^@DWdM5SuNNis(;N$XBAhADb=0pB6UPx@d zE)SQhBJkJ9;$-^hINWm8jqNb14K5jUukFEPQxcDCx9+cBEgGl%7daFIo?%#n7#uy&dDB}5pysu5oF8Akom@s zmB|nBWe%i}d`veB;(z{CooV9apa>eA;fsx5ibKi8ik+B+M>HI%!^Nmusqw6NSqE1N z9&$`#0Cm`dX7YwOecr<3W3WFCg^AMhP+23ovO73j$nRUAFLu-sbGbO)6e>G8)VEA1 zI}tKOH;ZgF7@Yix65~7DfuW}^>su&s5mAfPW^IOY(YL#ht}pgq)mhaK7Y1)xd|w`8ksDQyo;T3={d)vdqoa-EC|a(2JhF>kT3PK{Fy4k;z*)~RqZZ1tIglX z^L0|wgCTHVIwPtJYBk}0N6+yk824m`&K0f>F%n+CAr7d^q+p~RoNW{kak7#d0!EY+ zVM@weY`-coe4-8)B&2+v zw`Ig5u;9uTJaQK&gsPW~oT*CH-rNt38J3D)26WDi=S^;RYl%lA2Ao zD@q@gk?O@RsL5MS^VMHFtyLcDEnmy>HJ>ZL;$hh2t|rRLTe#(;1+g#ALcM4Af<1`% zyQg<~T$SL$%es{(tAnL-auckp^7{OK0he{;U5NPJd$Eq}aa7o(>UV#_cXxHv>n{_! zpNV|Ae=mCn!kcA5`4?039D7_fL^n&qFD)v^!7Ww%67ioOl2%Zu@H}Z51vPPH;gN`Y zkCo+JBB1QvRIAAb?7tTjJe1PZI@ddD6lS)5ne=XbW1-H-E*w_+5l{x@0biCx}z zm0!U-JM;W@J%C{2r}5{+ed+L@<%Qz!*_?`%hZA;4w?+;u17pJEhsX82 zt^yN_UcsXv@#e23cBu-aDb^|03vx#pMo31a3?a9^IlW#ngeUUn|o{KoCWU?qs zv~n2OV+4hB#1^YGDg)(#}6wGKZ3@t8|$)osy&j5 z`gLLr-&dS}12^F7ACX725c%Q75N!(L-;p8t3)f?oy*cNp#w-+4%h!lO)8>qE5hIi! zql@e=$B$o+*qELs9u#E+ku#4TCnk4t3!91F4PG<>?FIDsC8TM#QEI_58_SjaT$ke+ z?&`*pGSUNTYhRkQ+_7$iH`l7wT)72e;i+=v#=`Zu<&Todgloi$Ead4ira$`1m{%jWNiiTKv6M7JUMFC+`W?~+slH5xF9~e< zX(@hd%9(io0R6G!PB_-9e;K|+{8t4Dj67tRGIR2^6n?iP z=DsE`h+{J+*E)Fe@`hpsiy6-F;`c+3*NoG5I16675mJZ3i^#;aE|oK;_N5oJHUipf z$tyR98GKsW0MR(UEHuWSn+#j2X_KSk^Se#2%ceFkq%Bmui?crsay(fy5WZB^m3*4r zH>Vl--CvPP$~Oc#mVaUE&&bZ)U5vw*mo{H8!;e%V=Vl%k*p*#?4IIeIXMr5Bb?@s~ z^42KNoWJ=)oGLB4?wt_7 zhxxKlrs}RuKkfk%u&V&*WO}&;e#K?UuNT=wud`I7-Rr-nV+uTs+=Ucyi5!tZ&YZRY zNL)fe^+}#iH`atQeR){9qmkDZ8}=?($JXV;m|`w5FtMsZ&Zs!nHIIz1fku3){A7Ge zC-N`o?5oEuS18pwvo>lkg(*CurU{6xHD8J9XKhv8Smq#TzJuS7X>mhygZVVH?LHldQ;4 z9yYQuJ1)EJ;$lN0lc~&;D;`(mcIZAXSzd(|)y<1`HN~fLhiVt2*C^WaEg|zRIap$8 zpY{I$oGM;9H9)A-9|Pm~@qB2NjjhY7%lK}^<&TRQcqdKxlkz&Vm4|MC-P4ZZe~S0< z7cY}9*Vh-@<@`g##>nDXUGuR=HgT6;am9|{8FIu=E2f_yF|hKPKG*fol4wDMq&u;y z)zwK;RO3ZvgNsX4qvnb(2M>^!!#7&ItkuZdYKYNERe$FeR!nmUrysLs$KYLjyd#ukA;RiTb3TbnCVyS& zpRbeZS!VkTdi~Ms#3hF@2sz(4JBI~xVrDs@VM6ctPMy`3I!jbt$}L=3dD+*Jx}*w+D#`4wQ@gL$Rx649LV?3I_*qhbmV=cYviC(`O z*!xKoaX|HRcI3kY)KR0NL?QyC9>Wc9fa}uaIKB}R5xd|b-I8(kUJd=!LpO@_}JEM_{0Oa=`#ximt zly&X#JlrSfBoznyA&D>8BGyl+WaW9@TfgwB{ylBKUxS5#mz5`nL3stSV3I18OH`ln zABx@G-Q85Gr2hbd)mL@_`EN^_Ya%{v#N)f7_hSv!`3Mj^W}WN@#4&M`CO;61B0UJi zLl!q<-06MOk^2e~`vO!Oc0ZL%QXKa$`{VW;F>`x54?Wy>ISGBz;VheZqyc9y{kOUa=O9kZ`VF0U~2J<-aY|cXWkqRY1I-%8+rb z>hrv)lBVdkFP7+@nHG_~xr<07b#Ao(0F646+8WlW7U)4Nlse*dLJ+K9YdH+TNym;J zDLa!8wBz+n*dGj1i`Kcx5oKlqrbw`B(!{a>rc?W65KUXuz&Zk)QRZLxKMGy}W( zuT`@c2B^eOvi_LA`7%GR4OdNWkm{;lD7)w)q8q-aeN-d44^%^);i6FTzK$c}lJUu2 zOMXtn(aRuq9eLx}fh(~TMyh(JCEIEk<&msmbOtD@o02&>6t8Oxbc`DuY(n;XL=%-2 z&IcXKBslVnhRBLFD)tYnZb9L5F#g6TO_Y6nm>IaatM)(Eqmnn(&3ew1v**I-BaY|v zp`DM5`k@54nuVa;eyv=%x!+f<$aYD!MEN~{d6uzSBZwQ zvayD|&R5!~n{pYTXC=plNn*y1H5Mqf*Z>QLJqHtt=Q5ZKd_jbydAK5Hla492<2`#H zNjepqfLL>Wt}=&nn3T3IoC^;hsQP&jW0X=!8;p-9MUBgx6Qv$rYFF*;ljNs#{J8!! z@^xg%thqSViaty}B5+5zU{tZjycAX(5#m^=4m>e-Aqc5Y8eeWPuP{i9Bxz+0IR-$J z6gLdYAs)lZ%<(U9Fx>Ck7>-V4nIsZyh4>9M%Z-w18zSp5Jp4qy%eg1>iy&hR?AIYC ziV|bTl7cB$v36LRtFLpzARaNpKF_P}Vv%&XxTBdlw7$T_A9oYY>OWu24#Tr}&|^g4 z7R0y<%DD#JfpT&VqnPws-94nmnvht$cuHG|)SSf+Pw5wks@t%?1n3f@E#b-X;?K<> zchboYGgOACst*qstdKQZ9CeZ1_&m@z{yA&H7i7e7vl2utyCHmJmv^p**)|A-B1X=N zNOQTF(m7Pu69<%ChfV$&Fv&12KhUFYd5>$8A;Xu8oAu78 zvdYf-&@bbfL6Fp@ZogqDu35yz3rd3u-%Hx$YXFJQ?@*yxNX@)||7 z9JaT&HmWa{?=LCW_$Bh)-mG$R4E*uM8ID}XCOoRm_DH0kCc)ULf;@!j{EbkZlRzP+2Al67zy=7&)nHzTBmOWbtP@$B(d1lZ5v zB(^+;7E)%!w<$Lq@oeKM)MDkl+bov~j(8aip)7P!M_|fMi~}rq)1aO&jv0_M%K~6< z5tm#40I8knQn_JK7EFj>!GjV4kCJUEUyXQ-?6^f8VtkY}LP&D6eN3`s zCNeftVY%b_Qwc14?7X#qv*CDI0q7ug4Ip%(E^)0Vd2y$c#biiaaUnUU#EgbeBx-%T znFxS>!veU>X#l_B~tlNvO3{pSqP2#c@g!%%PI?(j!}^3P9r40 zXCJK0{{RfRU;B=AB=HT5*5S-iS^II4k%kq}F8;b1Vt`Nje{T!YffoU!s1DG}dF z*hamaBXMVS9{E>Jg2mM$e@vsfOH?uWp}e+S(BExSd2%Wz{1d;1i97!Q8r_|F%7ol~ zRv^a-k_U}1&QCWymHnH63{41fd-m+Mgn9_eC$s&QA6vl55r-x}Xhn`OLF?llLgiyz zu3IseJ;8)CNA_uBGLm0q_7pZQ-dNmS*BbkRWd>B|aif_O5dos#IPv7Tgur72>A=+H z_6U|Z;${rw;s!EB@*Hi+9BSo5#CS7!kb2*&NoI9^$~b%$mlUrJ)ez{SRYzQOQyclb zX$KZBbjM0Of#nR|xaI!t zDMA7JPEZ)f>2g0;87KbB6;7mFMku+NiHJvyORx7iFkEC9#E0!k9E+usEPPkFSPjm=+#ZIk`u0g05sQGVnEb~07E}gSDBNS0zh_6A{>vA$ z^VoHuj6SL3O%78r&C5<)PwT(nw9|UK-CiE{wMImnEv{F4d%ncqhMHH0gg+4YvuscD zlcgt!kCowbzBstp$}DMPbDyMf;`bx68wUnfiels$*n)4ljB)aT?H|Un<$4UCRFmZT z@w*&JBfV71gwXnrug(CO_8jaX4lt0S4$#{Sj3L9%%ETy(2v8L4-NiR%2~BCbN; zmt~t{6z_4#N2ID(YexGW)md$t++je!M=yEL89f`lk6x zB_9XtF{qi|pL|=3EeuuYc?LMGh~q1X0B<4t!CbM65?Exmja_%3P>1-XN@xD(E51$k-M zh5lyvC5lO!S#(}Qd=`O}S~^l%?vD?8d^M75Sve&T%Pb~Q=DOquLSPk?N%<=TCc#K&WcmlA@0x=}c#(X7}%#=753d0lv%+1+b~c}XB zN6D?)Hkru!AcXQFQ130Il{#B>A34Bfne- zq)D9E{{Z3$V_48)a#O@eqc2Hya}i8ZAUv{7U}1`};Bl4+IEE@KB4q-N0ddmDg1AxF zkGfFllqBebSJ&s&=Uiy{y5m%#udgh29A(Go#;>D_%P|1#XL1x!jMjW_Q4TZb=;AoA znakGW`lHE+B2#9MDae^hTC?NwaAT7`Y6^L)l(|~C)AG)EPHc?4e?-Dx16}}hU3mPl zCUWFvWTFn4IME*>`vapQG>g`o9my0N=7pP&`eef9BZb8Ay8_3aOr#SOa!PpPD#wKr zxbW)7;JmobE^LH_Ba}iiJMG;rMMi)vv0TesytNN5MB1xkhc`?J`7x?DL*iy;$P|YxNWb%$o!-C>xmVO~8EKy?+$C=9> zX`FJ|3>!2vo0Su>!?60LZ z*Gkk+_3UXzU)69Y4A1`npG7G4pQdMZg2z@B#QI#Ht=DD0wFYK8icrY-1e(2GN05ke zvN!CLEug>oAtOXcJeUV8jAU0Et1BdvV$qxI*&nLpmZWcQuMNCi5)6+_-*jPElTDE> zHY?J46l_sSxQv>Qm=G4Y3M!%mg-_3299Cl9>n#P#(EPYAP#+PHsoEvSX5CpRSXbbxwq{qs!+Q zK^9cl@%7FL^E*y>Kd*#%c|Fvj1?=;oo)XeU}9P(}qi3A5D zosaT`wuF%YGou<6>*Bd_Z`n>>2w#OitcFV|%+3#+_dOJ*DkmhTsRUSmj!a@8D7N_R zCmNPDm=*FY{O>$!1d zeFG(pj4`>S;eG=gq$qN7v{C12{=JZ<%a~Z6KlP(#NhzcbMpPn0aN}~(!6CiJ>npJl z!J8gT92n${MHnT+jJ#oI*$4!37obSW#gt;bsOu)iJfzJLPEobDF5@!f*$1*oKgts9 z{i9i-2n43C4@Fqw=AW3B*$g~NpUSvBiSdmuPC!k@KpaUpeR5RsA0MHT)L5AU9=RBp z%NRs&W3>X53Zmg+GeaSZq6t32!3pHS>GgqN1gDjN;-9C7>-Hs{6G$81F``~FgOqtu zG+bWs;cnswg(noG;_{-4G%_Q7T|IWcurtIBbQ%&(ECxTu_S%cOggY8k3R9h91$4 z2yd1?GZGE^4oOK7%t+%7bPg|kpdc}va)faDlo5=UXh)BVIDq8fBP_f`9y63)Bx5(y zDQA}vSTQ7w~bB$i~T&9S={~MJ5cnFqnoUk1kjeiy&f?CmMP1<3F<;n3*z! zkeXPXHh-hAj6JbKltG?ABq$UTdee(BNTY0ATWO;Nq5jHF5(H#YW0M*A3OLW5k!-#E zkB7+Q5Ge!N+-gPjqY?Fo1H<{O7a5BA%)FGb#Vp&@aucdSDI=4G$TFD9Swdb%Dg}_>P&9K zKNNb$FiD4#K5iuI&_oXXJb9|=@YFedR1;kOp-9IUE7=D?vF;{(kxV1*%$FlW90^J3 z9!38EmK7jrFPdD7USlef z`xyn{eBwZpa0jYPNQ#tVpqdeMal&C7DCJH88e{9S6X2slrjeC6RgAdD1Y;oO#038U z{U84TIL4iZA@zZ`6lP3_6Tkn&04Nav0s;XA009L70RRI40000100I#ZAp;U1F+l_{ z6CzPEVL(E0|Jncu0RsU6KLIC1;NW25nTKygAa?;6F-&nF*Fb@TgBOdz;*Bv7hVeEn zHIj@|Pl*^IrjvqjI-ePq3|ONB6@ZM8(;(JH25GDfUMYi2acD?sI4EhZr?E~34g)4^ z5D}7$gk<1^j0m*W07P(7#|5M(0|e7-aY#K53VH@uraq-O41>7s`-tMvfq;yZV7yQo zYXc_%2R7bsM4Lofrag*MdmiB|#g-wDh)YPo`X&8}Wa6)CRF*rFHm`;zc z#!gFp467TgSl|?7b-b3-B7|V#+rURsQdr_etx=*5D+4ljJwiH^qZiY3YKA!&9qT15 zQQTl)yqmyD=rUOQlJ9zejMgO6NeyP5#CpZ73=9s$G}1#5jGn_1Yat=y&?f^W-G!IL zb*p$JHPDu9SY#vY1mco}MLIT=3|;|2Z6?s11O&E*x`Um>hB>4Lnn-IEg6=V6gVcSJ z$JQww4?t3TlY!9SBNAom5sE}wNJvPQSa0z{R6f41k1-Olbia zDa=roXh%}dq}V%;%K@SX{uxg}(kRHuX}lERu|_10@)#*8L%4<*zJs-5uzD1+`f<3fOzb^0V3dZK$>N*a9T1}%^;{M3N z=z5fgia^AlmIbsRVBlnZqQm`%>O6TR+>L64U}j^40RE)AWA$ye@)>j)lXxdw+DmyT z4B9}zMs2p+c~i~g@@=%7+DouGZU=nni%8@vuOP$sET_n&gy=IgUQN87NRoBUqb21} zHr{V1lYKa}&@TYc`xe{Dv=-ZKw%czXNB-@RBL}6Wmr;Yz_CIjo z^w@yn#2*mF-a?a?hF+&`(*hBH2{HkM$!|tNy96>B87*}k11_Vm)gz_1 z*gG44pk)9HIez9SIy0JUE zWq`>&Z>$5kAD*MO)Oi#WjlQ^rKd8?(Y#u)Uw1vB8ZkzF$`r!*lr2! zplfJ91^R+NC+d@$Ktc~fj-&+E|7x{?%Kx z9xv2`?mn0L{Ylb>Hra3d1V($Bgim%5<0!M`B1^a92_8DXk=(JUYxV6G&`?v@jD#Zv zDGB>AV(xvYM$w}`*i$Iev;JMcPmbTy^7TJY5#zbFM@MJ$4(_kv`9|F~%%XZ~n1Yzs zQJ9>LlE_9*3VzH`?`FI0MushxrP~IO#~YE=2^Q5QB{=8B{E?SXoJRyBq`Cs$NpI~% z4(7jPddJ4BV}+DsYg25E2Xk`EZ#af~!1#%3lbL$+c^{T0@)86d#7~F-U1FMWPP`gvST%9MfHcEFPy+M~e>_ zv1uqqH=}y8Ku=PHKwYu`ia=`-=?Jk6Gm1ibMhP8`1I0gYlt-mIl&=+E0ezIi(HB3bGe-UQ`5o~^#4NJSWB@~KBN@5-< z2trCu52y__ingl~4ZMa!@qlT!lgK=tOt&w@oP-83v<8rj0Mo^m*e>K5CD(o3^3V>}fuHq>zJ(37ZwJQNN&TA0PuaH8nA^7wCf~^NwpzRU zVm>F-U@=dqV}Xiw4xtjfLUd@SQ*XtmP=N7#VXHszZQue@kJP`AJf3uk+em*TL(Dg9 zo=DAgJ;1k$A+8RLQLDZ*Wmk~H)Qxczbfkt+r<|E;9hqEczw;zKZMenUnU;xZEbu%^ z1I;oi7Q$2>M6xB(k6LN2wU|fe5J6a(X-G#B-#-wZ2i#IjH6`(jt`HFBpuyBW;$&< zKk1mT)f@zQh^Jfto2x_e+vE#Lej7`@wGE!~BL=z{%Bb->2a_-j`5VW_5X;*C)nbuIh^%9xuV z;u$zBU>eP*?H;$-3{nO-v5u`LK)`8$)4R4Yy{TvFF%MsH6UJ7~JcBENM(&QN6wMk2 z-Mvy<54fX%bVxXsz3-)@qa=g|yAK%PA%s~0>lpmJ8bi7*kas;~FCp9Ul#!@oD-QHI z1VDrmJ$a&}%fxu?{{Wj0Bx{OJ0oIb(q-xf=rm;;tQql$~r0b#+qjt#{IwC>k7E{+p z^2yuWle1^ng_K7|lZmJPyS}9;#?kmlVdJ)zDcj^zwN9~pPn5zOMLbY2B%BcX5gA^u z3=yMr+VIY-ULZ@A^l?!jT;P-Q!Nti`j$gGa^hPD zP>ln0`i&SL>If{N31RDhXT^f1Q z%T|dt#{{zRm#8?=(XN2$liJeKG3mz6*^{&M_KmIqvXdmqp63={P&{Y4OJ^}Iv1oag+F@{yJwGYXBl3F%fp5 z$k1W7A`)cw)=xHjnu%{+e;rW;zGfLb4Dq0J~DK)`&&43m^l;6vmRs z)~VIm2t&mb8A+e|YT9d8TSr30I^$B16Sh7OG)Z{dDBHmQ03Htw9xu~zz7LT^v6tF%AR_@rUW|tvS%vMfVXT`24!ya zNH&C_IwRDEfEu-un?WN+-*xBzH7KdbrM$7qQR-N!ux&k*vTP@&2Ip~>878}%w ziqYGb>gh)CFc~~_L~=v)$5+(pn3{AgJVPywz2Ed1{U_u900=aMB-0%o6Bx@x{WN|V z?MgV&y74k?_0a{{UG<0kRVCL>?qOQypGCB|6bLrzR3oWTZ`AlCiR8Y}tMB=ry{{P}5%th=2O%Fa^Fh{C{Vc z_XqWDwzY3s#nvnaGpF*Sa^J|yRBrHj1N#JS5XySmPs_{owi4Al#Axo5I(5BRZjfpG zy3urzB)^i4G7&Mn9YPMRpd3+8jaY03R6|c3arwwNvuzgMPsOqF&ua7tPNZKJcvjp-`YAc1c#0Kka<=Gx`&Ys-mj^T$!r0mR~va~fXL|E zP4N#TNH(7zSiU@q>uCtc!9+(UU`AR$2-73{zb&_)StHld_)t<`6NBRyEWDm+wk?RoQ|j3V*+;H2#2_KF zY#e~g7&r)JucL`&mQ!bw%LgSG0f<6bhG!!I8J}SqBuY@0CAOKWPEJA+f`fu`aX1*W z7@q|Q62oLNlw@Ed#j+UDjCRHXaeM*v0x}s%@NzK;8HO?tn=>i)81iu#pA&$V#VGPq z;C*v}KX77|dYesW^-Silry&PDU)8Pq}3X zu1W`k;@J+@N%R?I1)mj4SwdO*V4*1q!1QrnQ4WV35#~J{RCoa;23Wy37@S)bcJJ`mq_gIssDzw>2sl2ap9jRCvytKw zoClspP9X_SPC@W88>J0X>|_U|wZZ=YpgnUY z+(Ha?&zZ!sfhkKUIR_!KMk=488OX)5eu4T&r)csrj|a#=;@`CRlzBL+euymOV%Ry4 zC+XY#m-V}Nu+)4f5XK>X z-aK~8`t^)M(+oUbCE!~QHEUiY7Oa-FknwoDAGVq!Ou|M(!e6!+csw2~W;{=*VTKSG zVIktf3^4HwWA=Z;LBt@-32E1YVdc*FDGt|ON?FOsYmxMTV=%)QA6xdn%S~wX{m4${ zuGG#U=_8!9+amJG1^G`-(2Dsf!15aUK1K)qGo9^pEi}>XzJ(pOJT)lazbSTa_bV>~ zUC9IaX6V8EBd;Yms#B1UMIHuE&_7pp+P04Ie%-1L-O8I5zpbpbsIN%8AcB{OE$YKl zK1*b^K7&3AQIgdkO2|J| zH9U%IA{*_R?qb8`*$3_F$AWN1BLO4K2`biLH&>++S%mRoOE|j z5bWEN@Z7^L-r2d;rpP@o?$IMu2X3Q`&zNH;6;Gg)w!kc*2=!(V+_!f96lP)Gwf$pCF+rN^lTRP>&}!Y+a&^ zA9l1P%U|WGmwQ_~WDecW*cBQz{gQPq-t3KC-|5@Y`=g}ZSZWhQ5)fy}&4ve>jeB#N~BNgqLU^JkV z0iDaZe zQZZi9f?e8jcJwT=g4^~<(c9cLv(8d{mRU{!VrJ5OPoX4&x3^9?AB_RP284nYymbh-joMVz+uP&XH2M&M zfWx3k@Cq*vY{!DjIFz*8waf;etSkPV2VTo#4fQEX3&vZ2FKi}^AVMr<+unkUgcos~ z0}PY!?pKMFYMf81ryP<`iO(ikXVklUeBMKBBYvNh?}_dEvWriGl!jf8ubo8AIr1qlfEJ}Fs6gXv=CykoAh_UQI6rgoK!RSp48<{{W!y#7oBz@Gl$(idbcsXVfr^$_s0V zY=|j(b_-sUoAlJ^m`Z$dL26~;R=O8@n#f09DZXl**+LRfS{xh_fQD14z`^k_@_D?2 z$(C`;B;)@8+ie=#RHwJ~&aHa!z5ZTyXw9@DW>pVxlJ<@+^$+E9X? z+O_E{!(CE5903Vq0JGo(gh=oXL4@j;<%vyQpY+$p`g%c1a8rPI=n~8$@S7uY5pZ5e z5}iag8sOrgs|lzsm1UQjFAv<8l5G9L{nwkWC&c-fLDwB(#j$qnBNYDtO%ILod1K{} z*kUqYgctsETQe;R3x3ny0ci7w?!41yoIKu4vWuqACRt_CA>zh}dd#&fAZm;q0!wFZ z&|2eQ{{T2R-x4JlxPvV%$*_Qvn$}wl3LByl8sJE6xKeb@YcEOFA&f#%f`R59u?G;I zunJB-;x{KHDaPH4+q0lTaewliG(%y?Lrd^2V{kUv*GAAZWd6S(>+fw$> z8kcdD;CLutwWDzv0Lx=6{#kot5voIauu|5#rv#?iqeAVq@w=s(hobIQEbMMZk1$)% zSZMvG;MLpiAN@PpmL5=>Jeg%RF)e=u6o)_?+Ho%+$YeaVO`-dZOU_eb@|Tz4H%5s- z<)g!kTBj8c7lo0xA`A9tox0bjahwbQhOXJs2L~JDGTmdNCYebLbK?*77L>QICRw3KWXn?O894^7>xGn*KH z(8a{nwkH5R6cm(diE0XT4Yht-Jf3Y%iT?nE&Ie6k2ejhS&bp#y<~l*iy+>)@qxU7- zw4zx}U-egS_O|ykeQb>y8N|0u zpl5Qha8ip9^Pcf7b!t8yozj-U?XnvG0G44VMs#Ems(MBUEkXHhGok@+QcjM61hw9` z%Y92)CeZEN2blc4!ff(?V}FQ>v-dyK_Ql(5nx?3sYqp)fIS7Ueo00+fw z#G=!SHYh{;9m^?UW#LbOZ*zaPRn|dWVWo?gUDd8p4yj^ zZ7INiXRLRUF$_C<+nZnHwEe+-E|EHCbuA%$(`Dt-y{!u8eA*;j<7=~dyyG@`W z79j;TCI0}HzlKrXNS>Ha;JS9$hm*)4rr>t+37>|yFFhKXwXja_;rp`vz+Pb&(Kcrw zJLCCmAfq<$1iT%qn&@8MA%N(R*gSM#wBEIQM&)g)W*VJSHYkLd3GM!6CQ3gkA)O<~ z%5^|WYb<_J0(I%)dq9NNUIxzsFl6+LYR-=-L5G@7jZfv26c>^&qrJKO!gWB+#-4dV zMWLqY2qM~q;H4)_4P8Pvek_QM7$x|WfSQC?PeA_9c(Y{IDiMTK@oDu*YSc5!M8hSq5}WVkboH!Zd#0BcgW5(7Xfo z{u+;m<+3*PmVg97>Au(^Q?nvNU`0R=+muK+u7$VxB`uDabx&zJF(H8%i4XZ`b#2qodjYWcY8aGb z<+JdO3?roI6RTh}C~7-nM~puyN@_bnM^cfCkKr2N6coSz!~i-F009F61Oo*J0|WyA z0|5X40RRFKArdhIK~WGQVIVRSFmXbGQb3^ukt4A)!D7)+6mpV7qO$P++5iXv0RRR+ z0^xD&#~I@adlRphL_2g?a1`<>#}78E9>gi&9N|SAK|Ek7IQa*N3$GYmeEO+SRX#>I zSo$dlbVJo+l}f#g%O9h2rllA%ut(MJ(>3Id)2a8c(K zRZhh`ihQXj$ek4_#z$kPn0V8(K3xz8%N}HQBd|QmsZ>&U(O0uiA_r`F(5dpY94b2# zy%7WhvljSyBd2$bLaw0P68P8j@- zJTX|TRw!`AVzF4PRx1^X#WJ`9inP;>+ZkDJ>DhVOidE%vcUDWjEVlfFd2{l#S#8~h zg+D-4Y^zGAH{UD4aqg%GgbY(y-ut`Bxmt`?=S`3RQDo$u(*VJ(k0w-hr_7Eq@-7TN8%E=M3qKJl!Ria}+ z72lAJV`?iv`XX(Y{>#KQf}a%T!8D8rS-EekT~M9&!kctn5t2t@zHL5ywY}X@ij-Z7 z0uW_^#EliHqr5djd0Vhj)~lFunU;O5(z7z$2a40CtHXXXK$-MX!5OVtwtdL^eCE3Y ziA;WRmz;YP;(W34L$^g<#BPhRZvuANczI*qt|qEnAS*KFFe>Q3qJx&^v{o@f_7hXh zsy-f?uS0?!B^Ug>fhYd}k)u?{Q<$DzzHXj$aIa#D?LAY5FplchQ0`F~ZM?fvij&K^ z3dVy2QdBS-M(VAiID}kd)l2FE4P#*rV=4_w7eIf-f}sv> zZbG;MPsHTbfsPZ3j7%Wn46akkIw~3}40S3oMiiCaRziumbyICTs{a6^{!5+o3mPKb zIws9E^a#+vRUwRSIwxjX%Gxy-7esVixNe2-hM_IJTFNS(5{!&fGcFaPsQ`Mf4el9? zD4dsE!}RiL{)QFS-lP8j%8#Nnmo4QD8Z-&F0SlA7RisL#70-Re5>*%ZR5DiQV5M1v zYKvHN4@DJ`SPFBf_Zg1OcwzH(<6gumE_0@<`Yd1~8~*^Jt!L#8;d|BHQl(BW9d5~2b*P2!j|%*CylP7*f8BY!#C>+*JH9BI;>H3P`ZPv?t z&@#r1)i*7o7&P-j5*7;%6C5ZO94m)n;t&c#!-fk5InE7HloU-BL0+l`93|$vAk!v& zfV-_=RFZd8)m-@K6#m+;`l>8>LZu4AI6LjL4qTI7+ z-Bs05FsN(lu$9q7(}W=|wM6=;9GPfEN1}*x z{Y-G6=%iq*eReDF4du|#B2nC-Tu_wXyBVx$#q9a+pHCAh1<5#dYB;lmr2%MRLiW@j~MVu83$prCj1+Of{dnHmL4_ z!Nx8nJnNz|kK_bvNUCE+GS$ZbpbLHL?{c**XO(s=tLQ zD6(RmT(8VOmB|u!#YO%mX2SrWo4TSyr*|h1EgPZ%gdJ2Hf+t-OYqh|l0p@?vH!DGh z;Se#|UAk^&=F{k=<-DxMp6O`{xnZR0xiIL6AkRRp(O0n?CKa%#gsLjauNm#ruu(Ec zQm$zr3=nZ`c)7rHErC&W!*I3Y!H-SWQPiL=q9*_qnR?=_j}kN(d(%N^fQR)@bGgbE z!a5SDn*1I%L9aDgENQ4W6yZ8iICUyY_@Q#juW&0X=!LH#P0EovtWk=r6cDggQ3`b7 zMS{Ufp44{XijBOcmk1|*72z17(g1XKmLw`*s*B>Oje#ek$&3Xjbz^ZjllviFQIAzI z1=?<+XP{E&V1xq+tZY_?V6`qf>Qi$qr0J?9yPyHYqC=_^oO}DJw?r)(r`s5&c$49n z2+m;-RjLLqXh1wuegOAQ>J+SaQCEb8UNWP|uVOe8bm$PIs8!(#iOu%@B8YWW0;++6 zv7P5qP`3t(AS(zt^kZ}j#3Ps4YO-bJM|<`}w*Z{uKo|Us;}F>absf||?)*yN(m*g5 zG4EEYjH>ik3Za%LT}fUbhX{bw=>0MZx)30Gg&hRA{l8Yf2Tq}ntEcdQsyQx{>mUL)#s2)0D@ z#Yy)B(Cx5C+AcBgOt;zZF9=o%LIk#P*>n97baL*wPq}jlJFKU-F}&E%vgGlJ)NZSf zR5LP!gNsznQ%7~%#yzY&)5E80F!W6=X*5BiWTBx@Rx%VU6XzH}1K170rmiJO6PuaJ z-ir8M3y(XDdy{F(6yJBbSl89mg>fL1?CjbwXtJ_$+xq#&fM~LEs%`p`p4?VpKFgsS zeXSK@c0|oKRPN%rfXr#tIOS$NlkmDF2NObSn>3swMRQ#}6gXpn3VoHglU~gc(FMAL z!ZuwvM;K5Kyep#(c+&;4=4yN0vbf+@G3&=HdlMxb!~A2EA_M^4mEBPt7&UWf(Uo$*5#~DyiIZI0no(6>x3L{ge`H(LV_qBWZ-@xU!@6pk^U0jr7+kFaP75vMW5zg2fx4iKua zs_3E3Q4+C;K)1cRtAZ|N$A-mPcv{*FN+(SfLY^V6ag9~fjRMZiI1E-}VufJ=Pt(RdZ-cvrsWz2{v~)#ID*u2@v{W**G>3!3ez&~>Hdlc{{Ra73N6LjE6at)*(&Qs zV^8H4wddcW7Xp3Bxqw`PfH+hr;ddBQJRwg3!Y7Bx=YVT@iAL;7 z58Gj>%`)hf%S0}51-J!lm^k|GrL`W{`A+`;(ve)UPQ3Dmts)Hs`Fl&UV zmdepa|@%-cnnB#OR%H z0-CJ4TMeo?k9B5&64w5i)k#&uWI&*mGm36!(E`KBeu^s>N^izVOlx1MBST67#7kx*0b2POUv68)@ zI-mtls{KP^49NR;Kl_MPu4b~L6q9Nq=~0MMP;3^R(26!u>%%TLS(&;;iuR3FydF0uud0{jpHQyJFn@J9 zxmDaLzQfcbd^m)22XPftCbfbQ%W;O9wHFs6M|7Y}lmfWmrB0<)Y>XNx)l#bGnrx^b zZh$7LS~*ippZ@H()-1+$G)Mi2u+ z%*+^1Duq7I=vrb_yAqu6E268hsw|m})DcBV3J428g(|IdM#!9(1|F(>GU)cQ>YUdT zD57;jaY3vST2q7Z(&cPIqQa#}yw2TP!w3V-)UB1GWlwj| zYPqraSMbRFkhP+i%Kb)y{k2#RL|g}ZP1Xc9lPcDf8Y(wV1*XvEu(lW6I@?>8%fj%( zW$`ht3B~f#0C%|p)*BsGxw@w2w7tQgcd?b2THDJc6#Ta^G~IPk&2bRXA*kg$1DDK7 zF}lN8Ov}ssqCJ*`14YhpiXqE_puOD{&oXps!WtDdqIjgK)f4+K>%$m52N;sSUnCRp zHxzSz(Z@IY4lBbgwZnATGzxO+ek||!56p^aBESy(|6SnqlqZ|U3d-DAK6iOxnMW$V;_llS7tR_JMOM;(D__FqmVrtj;O$0z`xCXom@Ix@{HCln?d(%DkuMw#VM(Lq@&nWfI% zG`57M-B!CBP-tj+hGGt(2DsY?O3HQJ+SH>^NZeqW{L6E+4I>2^V%Ey$!5WYn6MPrN zCg1Y1VEa+-)i_Bl(Coez&H*}GBw%4w_uYaa!_gnpL&}M^Adh<0<9wNwfsX!gN`V0O!~^U>DCU3xw&MG3loe))~NKN&8~|pF8a5X=c;pF;4TqV8<_Cdu$FqS`1!bI zg%b>DsvOmduL+L1>+ai@0L?VH)Bqsgxy!dSo4r8QG36@MEnE?3Vk!8kw}M@4Wyr>dEZ zwL={Oa1eG(bB{;}&Nv|W>Z?uZifO2YXgt3WMnH3aa;~Jj$yT^xi(3Q=)kB{h70huS ziNF3Q~vi>op7l-!%-W@iwk~CR)PbJJ~9N^jlV0cXM**d4a*5^dPKoWyC9mHyvkU$?$t`nf0I#&od%P_An@*$u z0N|euCW8cSGF(%@U}DxNmM2Wrr+8m|zym?t!}EF$Ka_b>Y3ojWx+#Y4ZM zc7*B?<}ftj|HJ?%5CH%J0s;a80s;d80RR910096IAu&NwVGwbFk)g5h(ZTWIAphC` z2mt{A0Y4$4Da=BK<4UER#cgpnV6c|mzLfzRIg3xB6__y_mAyczinJS-UOGignN2-) z@dr`dOVhb_wJZ3DMsZafq&r8{ze4!3=vD+=3sTA4Cel=HQ8=nvR3Ogaw#7twjZ>{m zRy*N5OrmBD#dADEjY z%mkz?S(ULN8)dqsN=Ts%p)v^!ET=`@AJ*veT*Zk9QjMMlz~oJ8GI z2oRMs+-kj9LUQIKNm}9r1QC&aCRk1&w21XC1E>)w#3J`rBU+;J%&5)!vQk#&8H=L_ z+&s%sRL-j{Z8pQAP?(iPFo9praI-hLhU4)l!Ra)c5`j{!!fqx2E*w<#Npo{1pd02{ zf+=P^NrvH74i$Kaj{g8aiAcG`tbGlEW-F~kYK$_$(Gu9Q-i=Poq1=85{6R=kiXq9F z*no1)mInKljxH&#m&*hcq3VwiP-$}r`UOm=Y-P=`LY+m)^var{0TM1_f)|J*)FT5m zF5IG%?TdhbYGlNtIY5x4JxI=2u(*uO)gH{^850tE$_B9#^(|p3;!*DKF0!=B^@ak; zh6=G(7=t-XAJrN@Ic3c$il&f>8)s6c=n3)=BEU2%rmz#pCF6ugr>P(+HrZgT&5i z7H(c*4U+7mmx*M>g!Hu|40oEDgtEHC$Uw+>mnwrwWW>0#))6671w+8gmmHzsrGjRu+L>g@Qw>0?nPG(#1MUXH%L^0I;>&>>JB|cadPFY7 z!|5xJT&ponMiE@Vs7ix5}6X3C9Wkj9Z<9zK(-=Ov?!>>48vWC%w=AV^5L{+ zJk!-%GD~1cCSijBx)x`exCC9b6lt`G$h>@f&JJDL2$silana7S$kFUb&sTrta( zVRBr{61gxOy~6310+4~+Lx*yZvl*PrYcB>k978K;msyrY!>AZ>QjslFe6|SN2M}dQ zaV}BFn)N%FG|adl1H`h@Dom(_G;!3ptkNgipP7I}7QoE&a%IpfiIIBZ2t=47`bCP9 z-d{3m1majrEtfHOguya^bGgHXU1zy|1W2sL;}vj7`tUPrxq^-Bm@yFUC5Tll5K?1A zWOrpLx>x5ZNUB;~#Lj;c!m0(q7$*k>@J3fC**+pvj6sy(;$OnV%ULHqW(H@4dUGX0 zA+*yI&BmlI5y31F^moS3rw>NGRwV{vn+i2D!|^h%W30xa+`ZUO1a2cKVdyxCdE870 zwsY$nj9hhNm^dQNXZ~fQqbzqQac~=%GPV)ou`s+#QBw$NH>j&CGZIUy4UtX6TH<$o z!bjGvF`eXdH<^e+>xj&y$x|y4R45w6SedO%(;Y#=#Mjjh1ZF^pmrO>yLKmADmdFEw zWgWxDDpn(gA?=n5RN8J5q8o7>8JU#I3_|5*1fMbdbU&=RG@V905h)x@2r-SQ2*m3{ z1*vfzs#oylQ6X;LfMYY)1C87ya&b{Cu?&o|uWr)9H)>S`dBChfi(C=5_c*btA5g=&lw3ekqY{P* z)`BtVj0-E$!I0F+iB4_Y%=8(}X1-C$EyS&bk3qF@&)gg(!e>imDw2poDhgozDNjrb zg&>PbSjV82_sN-&ZYECSk>!LJear>}X-QndgU0OlG5}(EOwduW{NXl+<}X_1@tS7w ziWO(1OqUH?Dp8lINVv@4=JfK#ZV%2-EU zqzz>w>J%YzI-#l=nUh4zpGB_zqp-dvqce~R$d!uat8*JMFs4XTscSKNRp`Q$&g8L_ zV;qGkbSRk%h(lDuA%rf(wE+?T0K;jM5{YY!UMxVkg7XHEGcP4u%(!@#iy_3RmXjhS zrc=zxgujk4zZm876$dX6vP*7-I`kMz*U|}aj4=tZ=_g5)Q7&MJ(qto0QKNH+y|HbMlVY^a`GoMj zOV3=sd`=^Ya3;J%69lD}<4JSWS@kh^IF-9(R%M5{k5Z)6F=d&FXnIAIQM-W!JrqW; zg-cWGcEqqfzZm+cX;il_ApkIm7YmPom`eaBt889?DrY7W4Mt%V&1QdEEA0aNV+|af z#?lTRNbnW?hcPgf@hYelaRM&D7RnS_`5i)(y^g0>V2~dDMcwGY@>Q+%2&PwiyU1<^i@%6K@XV$9K-Fgw z6o(+bD>H4=4@9_K@J$S!8D78lq)l!e%<{z@&7(CP(#$kX*vbvc>`kThVU3I|LV1*~X42*?S-QCApI$_)QqaoX$eO*9ZZT~m;D|0N;uWVdg5g&r2&gbh0I79J ztBZMxtYTD9xnrndRSFc!;W8Bo;#ploPBRLLqcc*i!ZRj-n7Dz3_o=K6#c@gtBoS=` z3|Ex&kDHc)M6vb;%0I5GcIdI?e9NMAb|j7WvFKT>k(vkK z56$?7X*dqZ`CU1H$o1x2;~-tiA!I!crR%}fHwA;ZS2Il%R6U`(J!M&Rz@}S6P;rDT zIf5-QY?Pu6VkC?*n2A=P%nYVv?hRZj#IWaTCJPT{zEo7p#!ev%Mn#n}JVdg6CXarz zhoTiO4+xUvVsE@R6A?pl4j>l!$d1DRe+*lFw0@uqK~cJiR|~V9%=%wZuW&TD)x(rV zJDO4sbsF@=;#r5IXo;pn0tAKB%MeFVs#GT$Qig7NJLU<0zFt`GuSs^WT@)S6P9sD_ zXyk&oETMB922y6d0%=l^%<&K|?jo}7M)53Wj27|ouU>C+$1K65N82aDm&&h zRg^8~7I1ottVTT}d)9KyIfeAO@DKM9^$9Hj3Q8l|2bs)95aY6z{Rqwi33)>hR}h8F z6)9Nt8LA^jBBpZeKpaF{$y|Ia__?7;pv*L;$2W5WT5YTD5Z>^Nrl>~G;t;D%6qk4x zdu3+Qv|TTVzJ{vE{7jDC2-B?n#{Msi=30{A9PTruD68sb#ijvq1JDEyQpHV1xRjYn zxu8Hrh7()$HL)p+EEnj3DlkIzIfT8H7A1^ojmW^5Oy;r=RIQK{`+|WsvjrJr748v= z2+A_oH-`+rF3rd7HF-zFr+0dk@5tKB5YS^HreM5OSGY92vZU3uqnd?+7fnNKRu`Ly z9BS*I`wyhb&nJLlE3SI-mlu^uL*h}mx=p1FgS5)1P_=>=k5a!`vY<06inwMgUhZ(C zk4G?*;y%b0WF^tkW~u?{TGSQiK8b6Yc&7qrPo*u3@rbn>5ygzF&KqJ2l>WIYRfD>t zv|8@Ei*RkuH#OP=L*`+aelr5wc7L2o_4Xg#L=;?txrLFGQT=W@;!Dd(A zGVp+3E8&lpEc08=*w^CZyS^ng`3PeVCpdo_=qf?2xU9?kO@P*%!WLGg)H0{WCmZE- z`51?s9E@AUxojcSE{R*zp{NxFZUv;J?UVyErU{woh19I2L}W%r(Gt4s8ZJRh}V_gT=?!K10|?kA1e-m4hc{841eZ>$|G?` z1;@%%s%3Q+#dA8+nPwP6mUR?;5I?FvnaPgg0mK&uV3n~4%(`Y0>H~1XQUo}rWE{*a zz!=i6L1`tHLmtr8Eh?iK{{Vlei}+!ZIFZ+Z>gB&4A^f`fX4KHnBb!|h@I9-6eV9yYAcH}U{q)&*q4wa zw97k8!RU-FhL5E*kc{5+q==rBLpYWi!b0@{iWq6nrs+{YdR(GYFzya1fpYCoSc5hD zgG_|s!4au;xK06qA!j4`AV9L+@5D(*?5`l z{iFQEu^vboxn4PxvM8&fYsIrHw_T)L}^IWY8(jG0lF zfeW4srTB=+kdn~{Qq~6vlMu>B15+ko!x>bFG3lBh$_aBbH!x7geic_Q>(nV_Dut9~ zZ_KTd^Qm|-*lHV5zSk)k58_)#CHaO5_^0)N#SHv;j5KwpGRVt6-l0cy^TYt?1b2e+ zL@y)6u`*^Zs$NbbhahOYLgxXz1aAmHW_{h83FJF$i9_d*j)L6H<|vzRVgO8{opBFn za4I2EDO4PxNV8k^J*`KQT(gOXq+u-LRBmV=Kv}pVApySO=>jVqHw5GH>v0GNgy@R{ zZ$v@Dz_K7TI(zb3JEa;#vb&k{_vM`~m*}uywQQZWjUSK#thF{FpZPwD*vXX1e1?;Z&mw+G|BC@sMy|LR$gwX_PMMnarX@~)~ z95l_&z|=%5^iYUM&1Nw`1fV6Wm!@n7GPWbK$Hc>OvdBoDz%F(~iOkF|H5m#n#NV3Y z*w#VaM=1{yinGgeCNXJ(%u`4I0A)M{^F|tM%&%NO=`m!*bXzSY4-kwsTagNty~dbT zMKic;r<~_2Icz|AR6Mzwu$HCQ_MsIMk~201np7<}uA*`iHy#rBe(T4BSS|5O_*}mgO@CY|gIYXfZ1$ z%W=*#3xuOlkOp2A8(mMPM7wso+XXm_GlZ-SB2|dhe~4ANfA@nV(&2x>8o$VYH3-V@ zALPrr0{mqd1%dMnbZ7%V5DhZzCDE}Kr72s*5%e_VigA<9j+N1zL${Tow8P5VpzP@x z4?6iwy6mW=sETW;YTi0r&(S#isghBWPufut01<8>v6-_q^;xTwvavvOFHQ*s7c)mP z&|>KVa|}>2(8J8*?me*IQy&1YtUfB^;^Mid40>Pi zf#pwdK$HozRLlyoVS+75-UkWdXZ%VQ0#s8Ss3xl1T-WHSVCiwo$}$D54-l0E)_n76b6UyQ`-4JPjE@7&ADzb2l45LC>X+bjFb7JvZZzO3^ZlEpju zg7S6JDu&Mz#?$6j<hpye?A=&+-KKpyr8bnnM?2# z5{26vw=ou<2RA%@vbf&d#hajB8y zu3Sen!rmZ_8jd((>&hrx&`MJ?S(ud*yNK+J;RfB1cC`Y_S;wSf^C(oHq;rhQ3=6o^ zY+M#EcLfMZ1y-Lz6^UPIPwv8IKa*?(x82O9*QJ0Ev59x7-njS$c#VCMz-*nxz1me{o5{p{S>|uCFo(#HCqeIhk|JPZJWQ(K>|f zV4TwB`bzU1gw#taz?7XJR`4ZLLdH z`R61GZFm>;j9@LzCp{zKm$wGB>5nF$czYl;S?;A*2xIXYOe5L zwPGW&OI&=;x_#UFM?x^=J&Q7kr0($oY{Hik4E)wk0HxV08+bQyg|uv`rGVYB7^4+) zgp&0kmz0FxiDlj|4Fr0^m<9#huL?7y(@M7LQd2D_5SCw4VtQb>N~ZXt;_DU2ZZ63h za?X^+tWPiI1pt{yOr6Ts*5lXI2#0wwN#&SmW9~TDGXhfKUe*P@M_nsa!@C z?BT%^tj*Q^I+vf^>NrCeMLCMYV{aAF3aT5#q!o8(P!Ou6T+l@S07-56G`$47Aj|W_ zF4(jEeNIzUM+DQ9mz0A{@hqs5xV+x5u4SV@=f}({6V4#CAJnm>Z5YvLVq)5QLYWcs z5hSJ7C4NK_-g94-_%gMcf$5D4Ah41RK$iiE==9iNMKeaE=cu$`-FFDK zQf(a=&oaI&RHL!3;|f>GTyw*h!zmvVxq#65M_|-GEG`fc`L%Y-@KVFI38Hy|{{W=Q z*}CH0eqgY43!f*%y};`Dm$qAIoAocW)1B0*V!x2MEPmFLaahsdfdCvAQo$_;6;i#K zX5ukxlzOYB1n^WruK9hz>ot0JnLz?2a5$7;boRkba>dkd$pL8+Ft}<1dcNAfxMd!r zXZPwU-d-4$4D&4%Oqs86l-)+EoiNqe9CZa)Ikp`(240+P}W3qKL-QcrO#V{W8I5q{3VJGj(o>z zp*kjA1LKJ3N8tqAH!02Fbh$?B6ym?;B|`jjGU+)JQ%7Av5>7;LZuw#xbeosy!sS$< zqd8JOr00TEokbZ`&KMrj+XS;zw#1~_OwVY$VmrSOb|o1*L0oPb5Qa4jk}a9DQAFA> zP9=O!b9E}NPUQo5U`w^}4kK3qf9!4z?t6uO5x{0;+6n<5;XclOrTvo*U+(3AwWZD7 z$k5EbXsjIp(450ATXdKrB9_)r$Uy}`QkM0s4Burp`X9_a%lbdepuqvve@R+#Gs~t_ za%qO^=ktkle$uRxaABOON1>B=&*_Q0rn<0{vp~lp7a%?_zNHO^hY2z)*d6)w!_h!o zWgv|a<4kkv1BwtRD&~?^%9Q$)$YWg=>1a00D$#&C%pqcQDmGXW8hOjmxffD^Ev}-p zaB3ipVECGZOI=I_q2>VesCRHh?B}^# zjvHs8&3;Xzv938!|jLk3i2eyZmqEkzQm#_SYVmT)X zGb;L>MqDe{`JQB;`zvuBoQF&t6d7!$5~SZh`8DwQ24t7#X5}}l)TF1$7HEQ zqj0W|T-cxrk?i#{jxxK7Vp=s9P|6qwp>0q{$Lgw8y$WbTT>`6@%VxsY05`+v*4V;%d3IYK5d>~ z5F2N8Oi(WPIK(@*UQh|(1_@jP^op7>J`XYFnA31uCRY09+M+l$2RL;S&LLcyM+jI; zDlsr4X=ma6!Y~qFSk}^}y4O=$YqDIgeL|%^7|pZ?6JNE&w;r6-c9W=pQOPEZpOgR# zXAHO;6q7b;6IG@e%e}nB3vu%ZhbhS&sfGeUxGy<~V^c$Kn6|pqsYemC>K5u8aQ^_p zCHb$i%Esx1(J21JM2ehAM@*(zQ`p6dyu*VRD9n#gLep?OaG4p_$5NB9jT!cYofv~T4>199 z1cjA4VwFX!CJT7#Q7w6lU_THPwLCxuk0_2)kg%mNH{3^N*_Yv`~MBP&5&W?mT0(Hpo-EB8a+1#8^z6F$(Tzh-*y83V~MV zaCUB1*>bD_Egg93Si22E&5_&(XdX}wQ01-AHzZX6L;CqfX&UH1b* z(WWgbDa)BmbLI-gG_MlYI7748jK^8r89zz1HCgdC*Xp>}!K?d-ysQq6*wg~lnKL($ z_#ryb!1D$MYpRXDefo+qc+i7WAl^Yx98x(B?n(8 zABoWxMdoBm5}y8v^EIl6roYUr)?7^(LgRiC-cOj{5x7eXB4KJ|GdhUSA!}7e_&=DV zOaz(7QO|#fT&ZAtM|5*+taIe7S`yVs+DjDeW#&7XL~HR=1Z&P`!@G@2TZa&V{DU(o zRpwxgz6pMzA_dyia3V9-!GJ(&DhxU<<*$Hej!t6i5xHvex8fB?!V}5TrPQ7>3d*_* zQx_$>H~#>Vf=b_hVgqcbe=MMQ8)n!z-dKRbh+Ma(-};X_L}gxQQ_X+0Lr`gZnP#m7 zrWbHH1zc&B#3MXV^6 z%axWWYl!F-h*|~2v0a0RUhs-W5!jK2GBSX8lyHD5{h&3k%qspue+9>bw}{Ki+lhpC z#s1;2ZB1cqZkGhJ__<;7d`U}14}x6hdbxa8oFXp|G4LMN6`wE|iLQvX7o<3q&BHdt z0b}=EIKnpTIxC4U4n8Mn3w~z8HwFw*#Rm+molRGVOM@&>2&=-kg8n&01-bFE@+^! zbr&T1HqDCj=4@IVMN&UgIWyF_)8?WQ^HJ1l<_XEvI{Sd5UvnKx4!N7KqfE$)jY?kF z)*y&}b30ZRK%sgiFh8GfLe|*Xj!~(4D3uTz53a^+QRymF`*`0AO1(lK1 zFky~iBJH7yiy2DUTatns{h>C^EY7nBFv{1{i<(LYIO!PHCEwKf<~61&;2=Rt7N9H@ zR%E3aZrmDC^#JPWpZrXcvKT?`Dv>Qz~hGrpj&IEAO5^@$i*ZG&C z%M)(%;#DHM>7dUPLB6mVGP+l+rplBNj~?XJ4xP z%)+l@sm$Nd1m;-{m|QMZzmi_H*3_yT8TojNa)J*NKgidJy}ymFpd&PH1{E!&$;%yv zuR;hQW%(uJjk7o+bpl3T^oLr0V81E|IjZIXmWXQphB~nGSLFZ*5ByIvJ+P2znJ{XW zcBZ54X&MOm(XU305|F#xM4>x#0NXo#rokMw7=z3T+QWSijKHdhgDQ^3<#~;EG1}gE zZdz>8LKfE*GN8)SGZ3XSY_~p{sdogle~EZ|T(#6jD%G-&1X2hxg+>MvyJFRpPb2dI z7dzzN5m-zS&tEYjwH{{X0;eg(Ij^!b|GxPB< z?PM1ad?N!yR;N~B#0?NjhLyqqS{}FJ2!&hhzNQAn^zkhSvbvYzZZ6mt#Y{_?>z|kW zLJsJeFX3}lNXC&7sP9&9Tt4ADp*IhyykicncfMh6lS0}503u#cJ}SHa08k~bPY`$h zqnJu^#yzz6MfsO-TGB4;`jwDD#DKSJL>1YDb3!k!aZnz?Xf#ZL?3i31s5Xnari=VU zSBxm5oPU{xKv3S5p0xR#AB(=gN2Rs_ChmvliW3+89e97d)Z+Dr;b+B}ldd{+r$ ziD-5A8de9kZX1>0m!Awmu5d8~Qm*)w<`u(rEd^+@7ioG)mEPc`ms7T^gE**?jO8AG z7?vu9i!SfP7iI%&8L?2V<<-DVGH5xAM8w+3>+^~x)+sY{w7rAw#hFUuD9{}xpXYm zIfrtXYq>*V5#?N50QBOzp;LsK3ke=-=+-CY90k!+9AF285hrDk?0iRBpdDG6Xu-QO zsg0_xDW3lTQkupct6$7gpvRUB5A!UtyKfXr>pBKuE4Qnkmx$mh;4ds=3TS^(KyYE1 zPcgK*Y-g2KwijyEX9%Z9ApRp1bxhmgGXfY0#k^>gF0$dL`2?#vvj7oMiG}-x`k-G{ zM7SS;oW7*vhzF5Wbp>=C!TWr%cCb7uEBwy_9h@%M7q$!jt;%KCa(OU%g?p?JU*|M8_#c4v&{{T?2Erj4d%)RW7w(bCxuy~9|QhmRu z2vq>KTi@uE4C*y!F#$Fa(?%jB$gx#t`GGgl8y;m7t5E7*P|atE5#Ser1Do2AoYK3%DQl7!zFLfEGZx!`GRN zKZP-iwJO28tCoco?QZDD#8w;^Z6@qR$nB&2%FDTQH+lZ^6A86fAJh1jlibPuFowPz z<9YL#^NnY8hXR#I4^Amp%oJw)Cdgn7{I+$=;LI4jXSjHpKRxOO(EW*e1z%Fi$!d#j z=;B#m<=$1>tiW>A*$4d06wnpCKnx|%0-5|UbIor(#z89HbpHT+%ESStH=$e89ACsm zjoi_KkZ4V%r_{9=>9Sk}RVjYq^3csiOyP=!-F(jw5Tmx5gAc?HGZVtJNkMcnS1_!5 zaz)zxb(pJYM<Y)2CXylL6ikH`#kB)9-R!q9_ zGNWqJkKOPzFzDG#*uEfgzcjNh8BsxmHWsZ)#gMVj_M`O0gv?;lfWRNtVmehY7#Jo9 zxmf66YGR$|R^xXX;i4Qo$Apd4=f?RVY9BMDXte=cQ=w^j~bVkjdh8m?mqU0U7v z+^gBWGJa=n_qWny+b)qT8Fgp5;Omp+a%wP+Fz{t(`umrx5a{X7-eRHcX+MV8dk+YB zzGWqbTCCW2RF=vP!~dO=KuTp^uA;7es_ zmyLg!XhjWTJLKVJ)T(n30+dxiJWyaJSc4Ns5EW&U_;D;sFDg95&d+ zMV~M#f^&6KZnI!|&!7SYnYF2^+v4IHhBY`r7T~#V9j;@y6>?@cT|7jg#zMz2t%cn9 zg4v;v`inlDakX49O{9C=qiP994=|SV#5rI( zXPcJYJk^pXZi&XCtpc?vlKZo=I+$c@CNC2TK(XBL{$@1VvUjpu?BM-Pv!r;izqO9~ z8QlV#<9ucz)+hhk01N{G00IC50000G{zrG;=avyyWe4wXqI0m|AB!^M4x!ILp+L0=f--%9)Tj>an&u`n6`ZKos!T&m z&;vI-;Hj;pQt#1lop)xeRmLW#iGCw^YqK1Hv2eZb+-N@UlCGAdYx};xYMHw!#EX2B z&Y)V6=@k)&3?=LT06TIY`x+!}q~frrC5Y4a(b)D8T^lP?cD&ZZ#RhZy(#+H4W{f>R z@0^glUj_&FKO{R8(9O*_Coh3xB%Y{e*fCBYNP!h4g3|+P%&|8dbs0~~2(Gx^2;yL= z%*S4<5H+;k)e}l<{O4%mf}XKC7$TOLu3D#P)2PFZP(6Sr5|iL)7Tr!ZZoVe?xtHvt zTEMUr!sfCTea=(wmx*ZBG>8}txl;!caD{Dw8kGsLiP%0*wqQEC0AIDXcH+P$nT+sW z?FY{wqEPI+n0JDdMs@UQ<(A2}8QHdJ4Qzur?3a`q& z_>>dGDOQYURZ9ZvkiqBOP-ho|7+;+-e3>G~lm@2m;a$O9QA2CTcW0<}61N4B^}h$5 z6QEoC@k=Bt<%KOSb8mVJ4P>;1h8Pf`X3Ckma zaW0!0bLb^ma65w4mq1xMtMrZPSa8BBC^y__%^SqdP1QvbzT52irMtZqI#mZBzE{^H z>QnXI)JEEaVsO0q0^;^&8Z0gkmiOxH39*4Cc8K(j6As|%0MR@&?T$g&X|eLtCbPu( zUUf|5NYK)qJyw79_QSd2+wL>D60I)Z<{~3n*G$u)dXRs~pJ7$>`I$3TV48D1-4+@X zypWR|Hf**wS2eyiNW_Il*cU!s>Z_z#2OYgJrba%_%SzxJrYN5jI1ruBIZ#(4oiE|< zG1bTFC=vjJpIc=w(4LOG1n?RM54^nzBQegOoN0Fy5UuF1?x%#_#jn_j$z_M!CyF>c z(h4~py_r&@T)%Sb1^u*w!CFq{r)0Mf!^OXyJyX^@}nk@aTBMJ98nT;gwCWVku{zfvP z=cL~WbG$cfKP)t5kBeF=;lMh@!wdjIU|&V#&D$gNxwl<3ZZ*;G611H39Am?~Ain6X zHsUZ@D%g)HwuP%lM2LJ`0fz6VI+&u#`qRB-BTmX|z0T$58Ahof70!O+o)2{ZcPAi? zbFdu$02!={`|uy{s~j;%>>Mm9A?tgDdP**~9I=GGaCOq)Mof-OE9nM6^$s2=b?deh zRE3O+u0-524L&tTi6cSiVeu+Yk}jK$oQ?WzGj|FdM=Q#=MH}xn2QY@EBQz<jT#}{s0--%_qisvPk4s6KW#d#IvYzELEqBnZz2DjxLJV=}lVnV{$YZ=WJSc(&waRx4T&6=>UVB?8P?gT6w+TM^{6 ztk%Sx7c3wnk|wsxrR_TYCFr3y4F~bS$?7tJOy0yIn+*Q|y_cL?k6?L#mC&q?wKz(@ zp0)V@00J58NoF%iEkvv{F8~!8Tk=WlgC)*h4g9%bQ>G(p zf1?J8LFS!#xJ0yZ?IDFY636EpNti!Rl+&RLGagG?P@{Zapy9&)^_|HkQi-Pm#sOe_U3Gxv4WIhDMrR*6l!pp*2+2Z*=%a@B^ zJwh)bj?W*aPx^q_uweN1&cm9S9bLc|tBY{GOKlF^O9<8%s4apdojx0HV#$wTWH;lE z%L~Qs>9RKL_^|IIk!OCHKL@s!Qah1*_79F0WaWE~kiA1MA0NW?ExP5KaQqe|k1fe_ z;Q5l+S+}XLa_!U-+m-G+4xIRBtE>0nA@DQw$ZRd&h9(3j=bI&x+sX3c?juHV8A!^W zHTuWTFiRPBJ`pHm+XKn=$;$=b%)^Jk{Cb98w}>_fhWwM}{TTQNa$kw0l4B@bnd}h) ze25S)EX$C@7x8l~`Qi&KoO?XCXP3MtIVc^mu%*>RkJXYxEq4ax}B@$Z2%=c(<7Y;zQtwb|z%_8S*;| zIWX24@qP__>lwJ2H{ii%8xiz-@K0?Ev@qb0q@RQFJ)3QrE|To~K23zS*oNB<$Hs2W z;&5vroa4`d&!YF~l3Gjf(U)!0;OkR_$=|0IM~pHq-4~Y6!;@`nxK5vrtasoz!;=!W z>4PEIBjRjEd&ubwn>+GPiw(W_8>ubJIccAM9P)L%__2=6r3N9f@n!y&1UYovS{Vyu zvhfc5J12`X<0E?r`<8tV#rjSOE+yE4A^A&*(`FESXwC^Bv$u=P+_1;TLd{*9^FDbl zAFCOFNqJyTm#A`1PK3S)h_cJcd}PBN=gChn)8psB^XcR^-Liy3ut#SOU3?x-Nh0kY zNwDSGSY&tWNRCgN6FwhdaeKUz2rT)QL?K|y4~90QB=%bJ8+iQ& z&MzC^f=H{7d{(9*m*E*#EbERUx6u^lwwh*v z(1T()_?sWNL_|!MNhPufKFe76_vdD)5M=Vw836Ct3_0+3>6b4MzYy#!h++5;a`JmG z%bU&Y!{P}n*fPzs4~P0^#(p1njobI&W%#=}d1lGL3l5d>LR`7rEse~~e7 zXOf90ZIfW^uVFFq69i3$*}Eb^4otx9hCcxb416v_4*c6>wpp9 zc__BPJ(=<~5AA|`om(t5hFcFlD`nXrN6;Plg6k2yh`#~J)9?)WM7_ND1kgV&;+cCU zMT|Q#4~9?q*xdX-A1oQj5w|^r{=oYaiNa)m3#LqoFuM2W7E7$6WAyLHdv$slY?Hh7 zb!Tl~Ep6n5*aZ75e;^~4hw&ceiN@2-v9Jx^!I=7M4{tVf_BI7=6HU9uM%i?fB zi0dv|YIw&k+wpIAQJW_nJ_LI{+u38|_VePzw#y_aZI!XvZJv-sL2feLhI=t&+p)ML zx?wRXJrJ{4MoI$ObFGNW9gbpLY%kW^dY%_Vzdigv=syU8O!<~W;|+p*w%D1n&RN?z z5of{hl3*9*VdB@DoOf8_HvUbIL~mPtJQo6TVm4c1Fm_Uok;q}}KS9rlKF7d)XMPWl z*RaCQ$3Eq`e*OIV4}xA>u^;`$)%gtch<5%V6J!wb<3R54{{SM6uA#V#Yw zmzYPe{cp)mqZjYU-1yIv7IWc}W_gAN#I5$;1n|l2hhj<27hx&?05i0(!ZUwKdi_u1 z9g;O;aqv3ZCYLgTCSKaL1S2|*n4QBp@#@GX_D_(U!&tIh$+FLk&#!Fw{{Rzy6#& z#yYq86K};VGV5qVY>vk*<(3TJzaAwF;jh4BKQmynBHl-_<>DDVY=gFZekJ7Hk?{c( zTM2;(+#5RHV*+t}M~B2p{vzrIWaG$CLpkKX9@%B;S$p`vsoK?UP&nE8@-F2YHM{BIbTi1u3K?m%k6!qpf^EQallS<1*TC)PeNgp$bVaJ@~o z{4MN#n=i?a`tQ>BEG|%d*^iB|-Xos2RzW5i9?LnFfoYeJy1~oKk6SpmBCFFHWWCvw z+#|v_*@JC}@58vm@zD%+W6z6c;Vie3%XJg;FUXP!i355607(A;OfH;&U@|=U9`8|b zaxDjB3?=FttMY#BU7Z%lU-^Puj1XS_1QRQAU7seh?#m$9A+~1Ef(?}si6F5g<+ct& zBFW|33-&h=@?3!jC9f>UAWC4qLKiZ86pw?XOe84Vk0ETCdy}6Le4B0-AhLn8BpdL~ z@+6t~$ZG*3m$qaUS=GS+%d zFYnH*$fA>Md$wZ>M&*l6B(zCve&6Dg{E~IQ@lKRJh!_qa7e#iX_ z{(>~q*!W#!doDbZSOq^33!@o&e7o<%MnnNB#h(KHmnPo39qpD*tjUO%&9uvVZ_Uyk z6Lj*!Ah`i)cK6-69FLC+eOkP@?6x}@vyfL?uoEV5=UnoJ18?{9F{&w6!0(A&zXkVzg<~nmQTP*nuH$PxeGld$1I2!AApE&5ZYQH zC`cH57WVFK-b5P7t(3YNyFcdKM$G-$QloRHJ}g>O)doR_%wVR?e`Hpq0pCuMKr z?szSvpFV36!;_EFOV#9j4`q@}7VAsQ{4SPR1NVlgTsEZ(jl8GjZ*Q@<-%Nx3XlggLa{)_B@Wng#8}JM$Y#C04wr%#izeB68tQ{$zhA%J{@)+Gfp-*`U3_zA&^u&()*E}5te0&Q;zv-+XQJJV@v~#lMbceJ&3M>zJZ`MX zhB^c;CU5o+78Vfnli_fl-wDvVOIGRRJM2GT%PEPmj+=AkyCj2*#@Mv^u+M%H3D3 zT#w83H-rO>m_|%OLs)r!h|ZHBU*gENd2hhmC|GadZ};vF*>>;C6v#3^mypL(BgVqi zd)OYN1|!rbq&vhT+_UNSfspg#vbGlMK1~mS-MijilFr*+{{WK6bmK5%09anYJhQNg z!tMB#yHPtq6=T z1CU4H=PkkR9gZ@Fbd0#%^FF8cV0Oa|6X$HoaAn#*zax<>X2Hw5VqKlYXK;^8moU~@ zo>|Kkm-68_jLnBxCRkX-?V<7>nIbTGzXTpm79Xb1>NZ}^P8;G!LJamls7?|OTlm{` zdW;>vNInLv)csM)Touae{WF2fvLWXbHn zI1-*0`N}UY9g(2`TseENE}V-Yat|Q~VFG)HJ^|Yj{{Y2~<<)+xV1wZN4!Fyb$0LT2 z&cICmpq>y@wsL&AO&o2%@pHSF^6)_hBsWquU}eTlWtyD3k%a#MiC@Vexf%OoG6`4q zM4hxfvG`sl441u!fo9A33OffTKMus3_CHYgyvXe;{L`=|E+mL63|%D)!R%|haKODI z&XxuaHc-PQN6E*xb)FGWWx=o?WzI@{jCo+|5xtjQNm+Rg`~$`SIdBKEw`b6m9F1X| z2>osbuni?kdH(>o7obOMlZCm)bp@Qc zeg}@oJ0N5uP5u!_Zv$~}&fYMBSU-ts)rE(Vr~$F~N2~INIdzE!i%Th=34bJKZ$yVU z`v#V-FuXftS#mJ!<0l=0(i~Ier)e&GXfJOL6BDs{7Q}-;lOxQ3CtUV4$^QWF?Z~)c zV)0LxON1>Ki}`OMp4jMNG1B983k(W!PM505v3k08T{#qEe*%^pa7%eEB6xuI_8pXV zNO8$9M_>TTAy%i78HMK-%iH)QVr(3-&^|hSs88>&{w(bEVQu8eA0~Kh32DrX$RmgO z63*S1AV6jiW$lz&E%7V`%)fga0I?e|F>C1`ZED$eQ z&q>x=ns5B2^oeYIU;tSQmH@HMAZQT7f3b{X8w};G;jbn84%m*^@foIe>C2a&$TMCq z{F}f)K|X>5lis>E8wl!y7DC}DS`go48%L61X9nU5^t)w$oW8R%)?dV3VNH+Jek6G^ zv?Pw)xj5q+oVESD1mlCr{Jgk7v#_!bTWyXYBCrDu7|S@BmJWaBR^Qmb{gYig1{hum zJV1EHXDm+q0BI(!9!>6YN7%13ynqmg`{HXjG2 zl$H*&m_8oB{{Xv4ZzB#Mz4A<+yr(c!ndPz(b^zM&rECsT76Gmtw^ zuq|!YUHI&{_7-4`NpqGpxV4Q{@mmFKcd;$EA0Ie172O}?2wO1-oDx3 zWI`IrOdYtd$wEC}^sS4wunWnvy#HD8hdqQ zW0F7@Hu#0ep4&YqquU+5TcSVy-B+@BjtJ$Mev4`edL%p__875;#|nQoqU`=nz&q&_)_6wwk(;GBj!Y2B(r`QFZg|fFXVHqxyX0s4PHNCCt+k6ZcFi-VB0<%W3kM64#C)x%Om0X z_6UOr^2l6c1iH_*j-$ z`L@Figs!<@ci?WU!e5M$#v7<`lYS&1PMCf!LmtKEJ^9>c!1L6g%{Mg!0dm9~Kk&D^qSI$ZeE1;SS5P?Blb~gR;+o^b9c4 z@@p`^ZRf!KmSy<=0F{ToJ~B{;;z{`ae}nh>U%E7vpe5`$o74Pp9~fc zZ7m^`J7>WMW#5MNKY21{ZTQ=5vRGWq%Y;r}i4TAg$cj3q3@5V27 z_FXLFK2{ShpC+y?p|o;vm*H&Bw)|hMlH2}vB`ROP796}wgsV1N@k?1=C6f2!Ww-0> zN3kuQrR=WtKlPSyR|sQmCOY95zkA8;kZqVkey?qg!}E`f*%UHEC*s{%eyq7H{0L$n z0cCG)uOfOzc*-OEtlv)>3e8Szb4}$&p8GHEmDRySbAj#xE1?vo2{60+yf48&7U7PkMdnU=2 z+iWuUSq=LvB)or-bLD^=S;bXu&e&-@x`#mfK^nOgRksaq*ma@t+m8?Uw%l zhre^+!)!4uO`{Y0E_ObaJ(gbD5dOu%JRboBET@+d+a!asOG_l5$HH7#4272| znA(RVg2{6u+ugjIkdg*Tzd|+D#Kv<9J_Fz}0whE6$7R;t_vf!C_)GX&%j+1Bay^)~ zEf$;puDqO%vKhK;tg|8e1HHfP2r?5Wgj^PO!{Aa_(iN*@mO=E#*_#kpWWlp$C?$ma ze^MRKn9&}k(6EC(9o}!`b(T36bKjCd{gYtJyM`g~{Zfx0hDrPJ^8K>UnPsF4B<_44 z1c&*c#PZIDYC`e7R(GD`I*+Y*=4P}WtJav{4DDb zzvOGbYyfTD__#F;VmluREA|YAa~H77*gR~X<;|lB+wwp$2J*Gr z`jj@^x)&|QpZksJ`#aFFL|cr8iT?l}+n=9VnvzU~o%tNUVm@w@$KhQ`jHS~KMtt~x zg}13;@mj_-??wWR$pbY(?mS&pKgU**&F zJ@xse8t>b4w{0Xl41dRnuxy#+wqxeckv>A-&&cY=NOR%wm*XZ8gR|$(pqaMY#kLLJ zEb;-Vn=u2_J(Uu7_vBUr+FV<+`ARl;cl;@Q8biMc7Ej1?;~UgM0|5FTsre^25&jJ z@sdljWA(~nxGrCXFPyN;Gi0&|x8b)UX&+YOJzUu@oqRiFYkqsS+2oytcQ z%u5MNcMYK-GW?qaNa2&PkXiCt#PV88u*y*u*xk8k$e4o2wtSX0(aB|%z4&}@!Qmu( z%b-m12ze<@B)dEL8gJyJjIe(v$-fLRj5yvdBUZ{jPxTfrS#s{VJuV-Gv%-Cdd~`!> z^pR|v1-tN@VYXa{ZH4~;a@#M!+cHOld9Lw}{8KcT{ev?%u9^YOrE}t{D~gF829U28lK5(89p9C`SPUJ;dL3c;RMNvc6Rk{PaJ{YVlDlQ ze$29Zy+JJavXDhlS5{kTXCjhSILYhD38b`=aRHI^%=R;fyq1UP#p)cqLp^dc@ida# z*z4os?hGZ9E&CYO0ptrP{{XfB07zf3&=`-OS$eRyCH%YW-CwC;2a+89wIFd0{B5EGtk1?Q z@xM+Xe`BP35J(H$IdLM!d21tb;XrhFJ+UyyYhR) zftE$L0eq zjNsebZH>dQoAET*($~4`k;H#~cyx!QqG22i50gIpApTpolP+33lJ&Fi#gKZDRh@c= z`!4wrgzeZr8*ka0zlFME@awFIiQT8|xV(nl+(ovBK6cu&yt+0lylD?j!(z7I*iDm` zocTaE^*x+v?V?O1wr5Ljpwr=Di!);uY<^51?D{0Ofd{K^*U18eFfZvBpOCx}Jh}@!$0Nz|5-AU&?6k8zhVfzSXCEj#V9g5%>c40LbmU~GO@T$9oZ*cRHjy4aZx2Oh*a*h~KaDY#orllo8hoER}g2Z)6>A>^SUF}qh_TYR5ZN!OOyjg9yX zEbet_m%oj+XUjdFHd~Sri(iex;KFe$o;Z-1y|Q5kmx%WEES9a3%O|id*&JpZ_%+%=dp{3W2a>04CP6py8PRm206mv~Y(8uR}Ehz|b%_}(o4 z0QF{@kNxeOb;RHq_-8H&(;^+{OlvbK;)MywT(jp9lQmN4`2q-9w z6cGtgQ1tuoi|hFhc6P3F&gXu|>mHzZF+?^b;g~;cwz1Fyw9vC^9dzfiTifTd7m*r? zDafC+%>wDnx79qcZ%J<}3gu`1T+p&W#Cj98NQSMyB3V38L#AEI7OYkgD?I((>t?Z! zK4;6z+0C!#SSa~bo4q%c#Xae`xSr_Y-q%|wYL?)T`ilQ0vOTPrzTTt!+4~EziDjPA zue7;!p2aiX^UPWC4d_q9w~N~{PmCcnxt~j3VqLN;@=^_IRwUWBOUC4^n^|Po+Ei}d zx@yWbTKThT6q7-&`W}T*CJOb$*D) z<6tG)fJb^B{;1oj(BBmU9$A)m{{sj&JnHM#3C-F2!{GTJ;0FB#;PX@h_geQlm(^$4My_x4!$Qj~%BCzmOP8f8vPG_ByALAhj8g5$a2c(w$MmieG(lUm zV?4Q!x&FQ^(&aDw`rraA{K@oI54J(;1aXy2TX`m)usBqfCNvhSUctvU@z$veuov;U z&)BSZoAmilK=zgI_pS5c!GC~PKRx^t9#}t$x;>lcympBXQs*-g&M?_*TV7 zTO_$&&E}%Pj~FAx#hvsnr$DUA&n`{%I^r~v-1xe#%74ME-_l%ehjzB-@}-?T&^{BXJEdZ6^!cP^Xs`{R{iuslKc^6uCn*K{cG<KN;%T!{tHwku{2h+C`t z@gb$-)h~6;={CN?cep;i5&&WU3t+wy|Nb9Dz`%=*9lWmes523Swg z&s_e#IerDIAyc7h;jSCcX9(Il8BAp;p6nWt>-jC(a-Ef@^0LGP?Nb9?_}J5htd<^s zjegZtM{Hl12XL2eiB=lGp`8Xyd>9>U2igmBt~4&N`tgpb z5vvBGsukJ^d#+4e=rMtnd9SFZfg9_cL#bgGnO*?_uyFo)sZ0yr=cA*Wj=ZApZ(*Ec zU9=)vlf+gXZK)RBp+mNRr5^O31>YJbt=UpYQ@i-mo9km;&Rb71tsS^siLLfRj$z4@ z%O0C+*a`W!oHPl2MF)q)rm;?|t0i(y8_%v?7g8|P&qLW_#;L+olhL=~r*mtP=`;*P zAEaA#s`L3X7^?Ktg*8#9X-aW`#;2~cZMLNn(^SV#Ceon5MgHD5B_||-0fU&ydy1+C zR#cXuM=M?V0HGVfqE5+=nWWiP6zTXvjuaco;)cw^T@cVR0oangK6bjw2c~ zy{kMSMEiv`RYATH*J*LzuxIwgh4v7ZDQ?!HhGtT*mB2!F)RZQk9&*!v`0M04L zuxr+6+6*u!Ci5P%y?|2<>)Q-&{;uu-xRpm!(LEVlzhbdFR`r=@jMZe$$x53}XImSF zsCx6v013aL?koWJG6Gn^1SJ^8+bzMMBS+ChR);b#m0CMf@<_aXE51oGT`{5fgFlcv z@ANhg&8Zv3Gfd@_7FYm^8`R14bEi=b;a5rQQPihXdnT(J@UMoDkltPA#`IZH+Bl?{ z&nxDRI>N%0MZv2J$7ux_v>UPv9lPTbSx-saYZq}}Ol$WLf%(G=$3z(EEDO@WiD3aj zVowDc2HXiJ6yb^tnB!nE6>KzNyU5XQ=y&a`TYT#aH>4Y849;FVJ;*cuV-PH5 zq{-*9wBL0h$2g+_NbPSinJWoH1h2xRO;*bq@k*htAP$fOugSnN{Va@pW)l~TKzQ3IZ$Zh>V9{@8btTFR=3(n1Qjrdt*9sGZEF z+RQ<#EI;Yl>2z{xK;bO59Z9Y=<*n6x_=-^8=5DJ`4SzbK0}%=2q^*WG)~}7xUsXo|XwBd6&tq&Gfa^ zCnNr4O1?F#4{4YlrcW}K_90;*4ejsp$UZ67`cK@xKe$SjE5SOuhnr8#hTeS=cknqy zxW(AZ;3tHXffzqL)6W$e3v|B;T}sS?jGVdil7_RObaft)Vuu7w zst2o*$4y+L)MtydO(u*{!B+VR)T3F70ED7}T8Fmz5$iOZ=;upunA6_TELf;S&AWP7 zKuKRO7;77M{}!BLz0q29%;Jb6-CBvt03eERwjrh2-iQ_7&oMN=xb^ zx~1y>ZVy21rtv0)wluK&?Vng&r%k*sVXIE-6@@d~SyrHT2>6&HJw9=P&r0#S7 z86^-$f&dnwgS^o4JoY5DvYH zKhz6sIRyR2ga(E__$Js@iRRn9;S!@uw-1SEUyUXn(QJ50P%WZnooc5Gc;2rx$Q@LR ziI&>7%m?_#QSOQ>jyZ{3k4~b|#S|di;oX|8l>YmMoXHJQ4BQWN9wkg_lS1fIq(+-& zxbAwURmslSv+J5}XP-Z{xJI7Ju%*VXvARR90yI=ki%#>bBX-R@A%sp^E{1^^jRg`# z7U#Tr@0^XwQm8bw<~1p?`A-6;Q?mRBw-hSqVt-ANgh;S++~C?Z2y{Y!^C7w=on4tp z(A=FmSR0{VEih>J1S%#aMxhJ|KK9JXQov5|HC!?(j)vX!f+uLU)NrmVJKG3*Z%#*b zu6SY6$JVSx3;@gblx(8JkFAIIkLsUW-tA(Q5KiA-2hi7e;1?h#yTH%#UMH4Un{-1sEOng5gh9Y+`}XJ+SBVZU+P zFB6XP15EWvSDd0NtyAQK;tb)slz|Ql_n;;G zwvyG zCF?JR8Plp;DeXEyZEkhu4*2J1aT#~T&Vq`)9ISiJTBKfBct5G`?d+8J?xJzMJ{gyC zTY_!X-t>v&T5;k|97<#ha~Al?;TE@8@7;GccEPd^Q%(N)PWZ)g3jzE1rO-S?5ZCXf z5vDnQo%ZYQy0-U?JJmyiXN|z=>k(}mjNSKWK<@$V%F=A+jeKs6Af{I7U2v?FZVroL ztP-5&VaQaO^RmEJH3t=2BxGcY9!5RcTd%Nfb>ubFxA1U|nT;ZRw9GE`44Hp$*c|Wf z&9Nv!B`{}fg0C87iz82dn@Wc6HU(tKmegGx+qh&%s;UGNq}V-UZ-fEx7+39ho5;*d z>D$T;yVsIuVB@DLna$H0ag%7Ag1}kJk^N14n}x?Xkh~h^?!bpQJ|lZ%v44lO;k{W8 z-#9e3L9Y1N8t|uu!1PoSZpj5roQ_LhN~U&J+j5B**k*ITpR0 z_14&j3xHhJ*O3j8O|*u4n7{V2W{ph*pCIBmxzCi9L6SF3q>M2?PAY=o3mr!@Ba>eFA+gg|-$Uo$>#M$( zzE8rqUyFC=mwcm;2VWdzrEh`AEimi3#NSZjb}Ms=a2LMinrejuS!X z9FY>y5my0Lcw&V=1_O3+8#WO*D2Zv&JBk$M$^h9QoKj~b+kMiop$-`{JV)p-2c79- zp^=TX1&hM0Q>Gj*rQs_7B*k4ZRaJl(N0y2775=)mU@Lo(h(_xiY-#g6|MT>q>e7tP zl9MrNZCUQ=gT2x)ohqqQ`?RqJU3YfA>S#?kI;sjIx4*epqB${Sz0nT#M$U~5OI|!a zD!SUP!`4I1Tf)I7QO#lPC+OS2d6UR3N&=1wllTi@DS0PwL5tS+rHf&c3)_ILrwJR) zYCN7D1oo{Umn28J*!NQ(*A5tQIlpizSKO2ji_Wmo{=K%x2VUdky2$qPinPkyo&L&`IcTnK&hGv(a{Q2NqyZicgWYU>Z7 z(sOEs*%rsK$4(tAjvRr>c8XeIdhz6PRvKPNqFG8rul+3AdPQGufju*WPTL?ZC4g1l zkYoBD1F!_QCgLJZH$?-BOSzpcKWN7thq48gD5G_D;Fp_?O#^%a>b3=<<*j1u)Kv*I z9X4)-teVn)sLPHW#6}zigMtISdMLb14vW3fQ2=NTGnX8Y>k~v)>5>dgV~% z#)k2UG`fw2cSS|y*D3I^bAn3fB3-;l+i+(ZAay74(jZTldRt1^+zM)nt`12pU6$GQ z8ZYc2aX02kse9#r=bxK5u6r}w!m4uE>@A}#HwfFKC{Vn{DJC-27krG|Cf8D9PqC*S zU<7B}vxM|2nUXyA<(D*6fpXD&HynyN;S^K05gxo`X2f|*=1xD$h=Q1Pi_=Qm(v);m zE10u-yk-jRuEas`zD8#>CDsEZ*xCoa-jk zvcgu!-|;IMdNE>>Kl}L`H|)8GLk#`o=v$wNlKicizU^NaURRl%@Df)<3mC74aVXBB zrGrn&qwSJp{6vuf8*RKo_LPkzwj@iaS!*Q_Y3ZQNQ#VUUV!0MjYD3EO%;NN$?VwA3 zf-WBR^ZX!h1T(_7fp&3yl2$t1rO49!0s&hI7&!>NHTH-xz38HuwSFo@)c8JO^_p^U zAFfYU!+v?h@!IJf4+ab~9We9Mgcq@R-rAunCqQ492>W8F`lmA0z*Aq)j8@GK+t0~h z;MNJ6-J}O;pZD~LLKWbF?g^uuJK67<~{6GhcmII5n*PlJ-A9I!pNW zij@6zGya|P3N8cw5W~oHIW*zWt2xE_uMI-#jl1;PS#UYJGrUI-9%2#xkOYA>=TLaN zi8m14mdE1$1KfP_Hi-K<%T&HGwo`T})Ik_U!f7MD@4eNqBH!s*4mH za%NW@-Kn|7VKu~?f~8p$PJ+~Pzt(Zoc?7I2hs9$NqwH-5Q^KN;%ZhkIs`V6tc3 zz7?QZ0LWRDX+>9zl;4iiyQjeGUlQPCJTxpz5 z(e1dZJRZK1g3+c+cIZkPZ@Rv@^xt=q)8A4=&s2I#Bt@7WE7-evL(q|*rx<}duukyx zZV?^aSoKDu%lyhLbr8kMHY;MiqF{Z|^Pg&u1PVTgscXni!Lgfvh|NRf3`;aprP?K$ z49%im&vNs8C$~xaMsZP3gt2rv}>Gi5!p1dH|d|iZPd@yYPRVD(|*6 zQ!+H68swUmSW=t!D<*rVF&>RzTw`~eAsDhA`ZrN)nW)c|rSg}^%&xiRUGkYhpR()7 z^F67DF|kz>tH>hm?yG;#iFOG_#J+@w3i81H0e*hYzJe&fk7i(Kt!1u|qG*W-OzW}T z7JUxSTy%M-I(3Uu*&yLdo27o+Siu3hNu`P{ z>5+d!_Rt(X^gE$eUD--DcW0P78rQGWkTw-lx}md`!YEAR9qM-v`u$Qvf`5O z5#MI|rCsmo${yq{ur?))=6%{X_RDSIYiXX$G(kWt*4c-idV;?t z%F$gScmMAcrENK~3KjPWn|jiTVNX20Xo*)jvl+t>i=2s^a{kZlBe3s1viU(P0__taoa9*hmtuw=(Knm;VRBH;*UC? zWYtByah3wDF#pX?xTRuJfJz5lrA2k=x>t{ql=%2)fyy*FI~c#~O=ibwvoVoVf2n8Gfp#?a`n zHOb(H$lS`X zPCq{tUE9R!FVw*F(V^c$N4XXx00TB%4u0vk=qI`sV!nmFSKBwP;g{ zkokMUOg2OsuK`!lG#JS18)dy(=ShJ-_wE`yhFs~cVV+}9P!P|UUP{a+BWBVdpIyYQ zVzdaofx0w^OgJPMGd7a`CwFQ9h4x2Zib%Z||8O^B7@@^Y^i`x(Pt^#tVYeyvD8IWS zQO721=>3O~GY)u_^_`rb)}P#{a;y}9k;O#T(NKvnHb~vfnk(4Jqu@d$5qc+4P*1nc zJB^f}uMbhK?mVVaoo(-}?zeI1J4Kgts`s1fM&ZB-u%WB9K#K?+MI%@dBEs378jp#R z>JlqS8|CoAr#8(}t@p~_uM%KWOgLski+HE?sYF&A@$V1PwLO6O05%rs%dB`+Zi)20 z@vWKWbi7d)*~4Kzi*d)aI)d!Syr=psR2l}E(izCYm9DH!L5C7`EtN(kSDqK{8Dt|v zUxmIm=k^YZ>gnm>_=qVj)bOFcL4>Y7tDy-(J=O_(KFKBeQk_eNBU>}~f*j9f*bj>S zWo|1scqUG`MzaM0)m(n5M2^y@M0|$d8?$EiNTur7f6I}1)G@7fQat*z?}xf0UN*_& zD$l?b4l$tQ{g;oVQEg%^cjUx2-LjT|sS^7J%YC4H(16BTs*?PqSOc7{SlJELMeRZ^ zJAYppo+dLP(n!k1J!G-m{N0-_R3cXc=tunmbz5$6=Qc)_Md$nK=Ei2Cc653qIt$nl zvjxM#(M8u>c?+;s>!GllSAjRVYHQ~nWKvmPmPFTKB6aM-u%qa4{XtzmQ zSz~pt)cPo)rXZ*^cA1wxp52Q6IP-x2LTW_ta-}gGgyeInDwZxhTXoS!^o`?~ zHj+u-sFI5qK=9p+{B~@})A#da{k;^rAm1Lr&hb?3YtIWLWj@b1=vZ8}2D&jOqR(6{ z3a)%<_epc+nc^TFRBSZv?(Rk9i7Vtf@K@7LQQzBsb+GEBuXR3Z`Q+bq{_gJb4=D^* z%ZI(21Sqi5=Pf7Y=*OMr6a_n0d33oT+>lWsRkf?eJUzjy$BkmY`c!8V0q?bQU9q0H*FtLuwaQ(wARqvhs8$X8L)r+L=?vPSF}c+sa{$c%8|=PqBGh z>^FbewcGSbcm5%2djOd;S+WS(6glS8a@*cN!yV-0c@onbHy?a!@=1R$;la=L>2eA6 zBk$X!XGlLVvR((3wl~xLn}P#o6?}20bc8UUePxw>e#OP1!Y83sY*`mSmpzISo&HzX zZXzNPD~3|}K>57ZAW87CJu+1YEW!0UZb_jb$xb(HZP=OET5msjo&SBj_-BVGalUFL z*iR=o}4GVzQFogQLp+rDjYr5Visf-{WRTD3?r)P zPkiO4f;q3aUNA>NFv z!TI{cNI0L~#^sA8F`j})ihAr2%dgD^)ow*GD&#nE;d2c@^m+yl zf%+YMVV%8z#XR3Gy3NC}tHDJs%s5!Sd-S|D8yf`4%!>|g!B{WFk%6@#ai&O!H=*Mj<~2eh@ka}l9^^jegT5j~GZscAZBM!; znKDPc-^58q4Tp7Zep_Qo%yA4HgB z=!+M=^W(|liB6{+z{dP|bc-cC^_Nyp3Ifi0b`v)(la7!6zV=BJPN~rCq&j__s_@;x z=9zIb|H=yyqSF)`=R;_(ocY6BpegUcsmu)gw)9v0e)n=4TeB!?3-j>#CrS9;V#=_9 zLMP*?nH?UbJ`>8z0$)xF*=Za}iyx@Oy7*V6w)z$69CLy!!j+I@MPXrBSv>vtx;@ed$ z`?>1b8FLrxhP7VH$7U&@zuRehZDNMK8fjvdf;jfOg~g{Blj188(*ZcEc1TuQE;mYH z@?c!fN#$CP1orNYt_Cl0OlzH+pN>d`PeX+gO0?uT`yBHItk2}_6a-=+l{fOKS%7{@ zQqX_&y+qBM{RGh1WurvOT&yVc66~R8&e9+d;sxB~Hj~r{)9nz`n%kVRmXM5Z9geDK znHGE^L0L2{h79&5f4K#MAlr;LapDfslfT}C{|esUQjNljsGqAfdTdCTVE^?uJ(j6r zZwGn~Gk3PCe*EVfJ34=k_D>I&iTKl&YOH#xcvuqATR3O0@j?oD7*e#E)58EM;)x&D zqQ5P`+C|HuZXani6!%>N1qhewinV=X-05b!2z&RfksvwXn=ekDp^wSG&60oXEhn?w zK5}<@fRC1?ZOix2JN!22+=V$adu1;554EoQ zeD&Uo6uIWW()Y2B4OPAuZ`3Ntuxpr-(Rz<%r%gH?5x;O|9L;6oD3iZk=?_qy$(zZF=&)5^0(o$h zGq=)MCMAxKaNTLBoP7QEsHFOHf-Eil=H{-0uqwNL)Q_E<_=~<7MAn1_0NQYQv3WS` z77aT4N}W!hyXBFWPC{=0@<7t-e}l|vpxobsF5jOP31R}!Mc!Vott(Gz1#6m%xQqG} zvs4;id&O+f;z=*H_{2-%VaGLMva2JUJl)oa&yTR}AUe781;raG(E6&iOE6<1LS+}>wh4%X27KQcavKx-Z;`AHY zANg({Tw96bJ{&Q0_11()zUF9lfyFM3lYJ5kzy8=CHo?bN{rX`II!oWVu+m5<+ZddRs>W?=+hx;it^5-wIut5 zW`+6`B7(24C;9iWJB0NKi|~@NC);P@>Gq=*9cZd>1k1CYnqWbv;T9qH*$R9h(wc5G zu-e!{d}5~*PnQVd(kEIl;CyigH?J3YPdCCneCzC4^Ik@UG*|X7#^`x<2{N=sDx$hB zt&CLL4ev4ZsS?KJ%Lrr5m~*aD#ePs3 zZ*){czT&!Y=QDPx&oQi@I`?CDve^&>h|Q5bcgq;GXMZ}T*@cS|#fRTCGa98KdTFm1p<4=gulS4afBrbXj0|}Dm=Gk=Azi$5O)?vD z@jB~P)$lHsE2x-zAV@(39?Oo<=PvLSU)0Yn;YZIo05Kfdn}^q{xKGC{HihPK6*hDw zw82a-*ezH|x6;w(38{9!)MufSaIYDEeY>1+^7h~b(a3&*7}+2@sLk$9LLr9{)+T~D z2&^*=2z5FX{8$o*&>rEk4dyr;yEQnKlk#UV_sPL*5_>-~BTv>uMWs@oxvsgZQX~$0 z({bzPu^oNUkgW=HMw-fNRCA$&&tEadf`)G0)Cn&`H8J8Jh7+FkS9{fKbJM zb4gpNx5dlk1#i}v;au3iT^u*I78ZSoVit9|J)Tn(*MEfv_W1$+!*39X*P*d0{&(q= zM4{0ZN~MZ;LzI=Zw9N)@YE>xve``ncq>tiRZnxY19{D9B*R)P$wT%ncOCOXYf|MGkJ$CZ& z#Pf$WpcVLLY$E(2+n~noT+cPg3xxbSV!MK%%I(gR(YCMVRqYOWI{9c>@iyFA4lDOH zaaV~Fl}h1u*QjC#b?(&9eN*wNT75kYQ~VwtqlKCq=9bG*fYoQ~Y~*DEz~pX2%(;q7=8N(ZJ~r?|G5p7#QL)l;#@rQ+-CdKxEr zt0}7D;eM_9UV)!Sk{9WxtXen%)y{iDu$Lw4?%Ipn1A4JzT4BCO~ zz>nzvO_d6!Q4YOtz`8JqD)$xrYWy2`s{KjOR>15ng}zQQ-le`UAr{Qjp;B1?;MoZQ zN@*}6llXQ16Tgi}1j`*#g2B~GMEmObCWx3h7r5K~2e?ZRP++iPXZs+}FBF;r?WbV8 z&fn7&F5k>YgE-u)q@^lQWZTUda^kYRvOuM%jL951*eyy+Hb#|$!!r35FP-3ZI?da1 z#=OsV1(xI2e}HTn%sMXs10#z3==Ysmk**ope7OoVu`)(?J|I*h$KX z9P5UN8cLp8?Adru*$ahPF^AuNL1osZ(ooNdg9H{Lcroc`26$}dBL>V(*T1B@2-AcY zhGI=L8Y^qT2Xemfr^Rm;xbjF}=R{iy#Hd6K&=`pg|&3IBaQqD5fP;~uDY zUZ7Q7T5YuHsNzoGvD6pzdl&OSGwX&_Kj&1_@{+jA!>E6A~SY5Im1;C^uwK}wviq_%Gr1S{BY>ovum%8 z--1!K4uU}T_L*aMc50TyzXx5FDmkZDU87a!f09J7xMMNighDwa4L{9vxl9ARKeHi! z(Q#K7V{(Ps?b1Et=?@mJU}1RDDqy+0I9mXxDW zH`5sx;W7;=k!K|sWJ^vdEZ7~-;3Q2Nz6 zb=1N{5sk zX9?b_MgeJFkg!TS34Z8{5cK&RTi&<3%`$XPjGdBanllAe0BYAd*iiMLS@Z!k;y1C7((U4=2(m=WzJIa`|Khfpy z_uA>L;capG<%r6p3AQ`q-G8{aB@q<-E2Vmte!Nzbf13SiqH7_P1!KZf12}#4rLWhE z6eu4H`bLL87li%?@cXPm>4`tz_~Ih5uoWt|E2Q+u#!!~~H&P*JlM3b&Tai2EHS4}p z0qF34C_Bfx^cnJI zI06U?Ph9#QFsrRmnfx#4n{uU_>Ye7hWp-7gf{wg*dfB!~mO~UAp9CI6tW~)4T*&*tjz@0 z$7vc7+&+SC3^12nIy}DtwxG-3Ggy-l>tr$v;zSEVjw==u^wU`38s7Up4^eGUL-Tvh zH)sI-()h>rM|5>O?+r%OSHGu|h5nGsqJoUX1WVFD4(^s>L51Waa*d$h=&VIkDagbV zxX;IL_uAPFKP;+j#qcR0>&v|ejdwM7ly7ppP|4Y(+Hay*W4G2q0a={}`m6+?S(FqjKzBoe$vne@gC{coH63A+r zWTA?KF!z_%T(XlROXR8|D*X4tIzFXj8p&$VB=7p~1@m;u0)_}#pWUTf)t(81%#Yu# zSQ%Sbh^=q3s7|E@*3DQFZ>!5s5`}C2DA5aC6D=PT>M8uGS7h->h{O>AAS-{InYTJ^ zYnOn=Trbj2LE=0f1>0t3Z~4*glv)m{Hsom1oj0UIgSbD}laz-=`g!d}cj?zuRluZ2 zpNYw$Kry2nj;-Q0V4!oBKMdp~-i!Iy|4Uz=R}xnr_t0S|DLg3Q$QepomZ!_@k1g?O z$?BF~7oB3^EAaQns~{}<61h8N#mrF~djSspDK95$&6Vhx@_OCeeARP}L@N}r#S#)c zm0Z?6Nk#Wc?YjAdX+FBTNG@Tii$fQD(&J8!^`tUWxqzl~E2Kq=_AxgTI+<7_$Kos2 z8?RBfM~nK*tD}X##<|wsMsdY;=m9PUhtPHRT-k^#BNFydX!{@w^SSux0YLSZAWucF ziM95Cv02<1?M+hLmr_?%#gm0MBpw&5M9HkgnlC8+hV6#3{{HVhbvX)mYLZ2#UvM5t zQiya(qld!ewSmUoqC#3}>?mDNy2QT8j^QtOkSuu8a%m@b8yaUY@+fx6d{{^Js$w@M zwjIJI^ogO#O|m%t^?!i(wV@N^+(Jn${fIk=k%r@L~h$nn=(Dg0F<{V>*bQ} z)C~?co+Z^kZ`6lV>$4GA1g&U*_#blrg|3*;k9yX=QFS*h1#2mMDkq`b{(zCLXVE;5 z$Kt>teY=KD(m9TYK=TI2X&Rgn-$D}OB+m?rlECw2dFr#CZukPH^iRSnI6z3L`5l2k zvNVcKd%(oPqmau1FOu}$YV%uJ=0Be#C&0{ve%#P{*3W5gdgjdL0*Y}FU$GCXxU6vgvMAXeQ!H9_L!$M{$qI}jxzau zh~LV|L6mnkq}^XIsuzUw@$qjQuxx5d@reodOe0P?@s)or8k1=nNX8AYu@Qyq6`_Tq z-C&iYmA^3s#zwkRE2VjcI%`>?43i1jiY0Pq;Zh~+rK*&^+Ad<1g2={dO-irirCUwKt--Nmb3$p3{9G^V&nyY9%vOh^C<4Y z+RAi1%2Q%Up%0{bDr76LfT6jEs1%J;2(zXWu7n#0-4uG$aC=l#?5ea8(OC?&5vM&l zp0r?=P2iqrREw%NZfXPm&6>gWk7g_I{s*W5zX7Lwb&gHAE;eYX@b`ASXF0+n6S^|f zT{|GJ8c~?}=2^ThlqHOntD{pMaZDOvvhLS7PZ_7dzEgCiGghNpwfzS#HkPS#IxsBp z-B`#F7c0r3m(LrUIFa<6peyGee&ml#$mI1ik>tgKk`&%ku6y>ofyAPyWN`NxeYH$OJ-)UBBQKg7cpG^_XR=1E$rU|+!nK9yO0HDr>i9Ho@maS+C zqf=7QRVJsvX1K+9o6+p(!+sqOY*oZdlw}i37-#BFq=k)9N^rGUw%c7Ambk-Q47=sM z(o6G&O=s=TpB}Z?47P!OZmlctJc*Xg%hMe?M>Jvx#uNb2rw)j{!U@7>#+8H^KIc|4 z6ZG}ZPSFhKF@8>3{JQWTDFj=W1mhPkpJ!fxL;A$V3Q`0^-KN_K^aZyVXI_qFx={s} zLtk!gF^$+&eF1{NAHh`r14wz9+%Wm@II<3F$U4XCdtwWt!#LydgKDStfGSSZ_-X#- z@~0%at?Y|TlMH*z#vx0@_Gh6qEP_+GFt)f7qOTGyp=sIOHpdEcUzF2-8Egs%Qx9D> zslH)Q$n@2zZ+f7bb7pYt&_v>?nf8|>@F>TxF8@_6{~}CR5h|x+&A}!9k_1|<3FGuU ztbEpi)628$o)@tr;8dMb89Cf<-FQBGUzDEZNwTTae9$4^b%kv?YA%EvD7xp)482yC zLzJJQh*8rE3MTci!Nad4cpnK&iHUnHwtBh`XY;SR6!g)jE6zP>vd?+W8CW$Dk8BlH zCEpfs@9hADsOFto(5FM3uTH*d#Bw0WzgtT&QcU$&^TOxXilIKYmdgz1GgT_SstYmd zeFS6y@s;!q>iv^sJHTePv`(|E;`3435%A))a###yEr-T9k)yEFTDo5`W~&Q8+Lw*i@H5 zA$+Q=95TSo5)@1;x_0X%CozcXOYvR3N3pZoFkKExBj3cmr+Y_?ErKHIRy5UW!;JjL zb7D(<*Ind%)6-uGMbwC{98P$hsHsWRb@p&9ngZ_`**_fto}&+DP#V zwnJ^~696zPE6H|QZg+IWd*dqfQP5*lb5Q4h3{Hs&c3mF<2k*u&U|b@887D{)RRCeI zgWtsk$opTVzkp9z2Zvmle~NlZ$U}bwrN2V1wkC>aAN7XYWuGC6@S|B;j%b9SKdtp03L^GoT_oQ1sGZ1TEqt&OfRO^FvZt)~0+1J#v;S?^0J*0dOCi;tBo z@aWTkyb>ahJp8#Cr7L%K>2!Pk)cOZAiBa|)i1t@q0_FcMj_`PP<%|_s2x@JI7U?Qn zNK070pmqf5X2bt<^33gf{>GxLUfu3rqogJ{Rp~@Awsw5wu%C3N%5Y!+I zc$hG2gw&|Fsy#LL^8;0#iw=c{ip3B9d+kM{V&KU5_8T>8E6cc7U!t18uVbS7LXhs> zwx0@(-27y0>f9nuil_|+{dlZ^q?Hw@TG!Z}K$_;#Tb>1h@M6wihaa%auQ6=KR|ih2 z{j?j4$KdxPVjeYNJtnQzqfNaXC>#s-p&1S$7$m^MLT4o?iTLTqZph~*$0yt;mVD~? zUm@l3+00y8T41Ckz2#4}C+nhf&{I$J&6cr}_j^2APzkKdyGR9hFyO98I)L7tkO#WV zdx=O+CF1x}!`WWE+2br3D41d&b9=Jt)$&FKGZ4|C5_ul|)=EiF$G8IP1{bXCy;URWMD?dqOm9 zCqOpqN`1@={k2INEp%E^LKlzv%BxwCh?MqNDF$t8Q{y~}W;m>RI5^HpB_`(alN zL!b)dn64bbU6@KprD?~)2H>R0Z_S>WJ{nk#bn6r`7Sm(@nXZZJ^rldhXBK^{Xr&Fn zvU`7@;R-5X5@Ne}25Dp-547S&&2PEVrnM~`C_2yCLGrW{9D%LTAEWY0$2h;+UeSiI4F&!OaI06h z;3LcciX{r2*Lwtc8Rc|PF$y=^G7owMCJ2)>9ED@Xc4I?~dp^X8pl-YTQk2_4nu6T8$ z_6FWIWlCOUzTL^>s{^;RdV6MUbkk08U;WoI|A>wJ#t_( zGW!$peZq;SH%?YCJ&Av7iZ?u1-UNUXQyX*#Ykpa=*+@?bhMc$FMwN=|MwS*pbf~K3 zwouG@UG+fh zl!p;ep9F|qK#vnLhPIy5wiQ0+_JO%wFR7;co13`$7;N8&NpG{_C7S}WlXpu9*N2(w z&4t#BA0q!AAK$hRt@}{{(mU2KUJSAow|KLs*O_!4Q^=uY&GL6GU9X7vy2uZpLqY%b zRvRIPE}I;>$PX#zD9N2<<7AIp88gZe5f>}mP`ao2RdVpglQs`<_S7dKo}E;3n-prx zxD{YWDduMn9k9M%CWSsT*}ak!o&F%~Ir+<)Y-HaBoD#-_l+Xem_8a<1UNKrLb@!S^ zT|+43g$0k;i`60UnAtiYUPG8SLqg*E!RKSciLtAt9M7|5-%a1lh_wmk8!Ml!0UBC- z_OM@qP%~H0mK)8cEDF!?|Bc$x4F8cofcJ(mr6_K}0r1f9m z$VV03vl0t1=@^w-xIQewgoMP8ZG0 zm+lT{)1hRtcx75;oVrsarpgLSBR~B3vCK{?cyn}Ebk?%1VwwjjUih=vCSCiLQ z%uc+ymP(GZ)51}xQwSK7CHRG_8F*3kKLNK8NbeJ6gii<|@XzIF&k^MMTz)EQR7}9~ zN7mx=$pTgwQNxXD&x$yy#3S3x*I7X`G$0t&c|d_74^5p)LU0`Mtrad72+_yx;T9M+ zXJ5r4%Yy+Vzmo3aCrU7i<+vYMbxzllVLGD zt6Y+iIf!ggIYbM!+}Xf5PEHnnXq|yDiPP%7mn4`@9^xi!%rOA~fr*&I)hTj;B4P)6 zeAr_I`?I7f&^i;~+*gJ5*eNcdm28SX$!*pdx zn^;Wu{{U)Ij1+*<5y=%lV(k!iY-?F<_A!%IK{_)#{{Xa37wnwHk!I8|4-2Yk5d!V^ zNh&izi0ZhZ+d(_{pfXG+P-?jV&S6xcNtlqH4sL8oBNF#;3Ze+JSTdwC4@$WjfIws2 zaw>wB7yC7PSR`c{vq&9^i*8y>@Wctf9%~f?XoSx8@c?aXeoGG$VU%V&)ky-uAR<>T zVC!|r0|BC8GqT4fiII_v3~24ViRMmZ2=;J~9=!3L}xo?3{5WLfFC->2tCfr#7ZT(su}6 zQm9JoV<9%jR>+!lmT0F1ra<(gH9`q$Q3Q!x2Djpfp;cg@OU+B=1p#q~wTj{6zYKD_ z-Zwl`keEEqab8+RVJn&uz8)^ugS@jd@V|>bHb)wA!I6Q!?tjyFBM<~pm z_^A#SAj#E&IuSAOs2Jo?K~%U*a%+NJP{~Ng4b-M{E47~ZpcIBV8x~&x4tpE|n1`;>!xeV0~LNS`DB3U!I$L#r_l5z-wI(%_+r9x99)2NzKN1#YZ-2VWU zS}BaPU?!s?osEGAeY>M^)p9Ij)P}5>afHqTlAU0ZVLA&b5=_7v&6~Y~Pk8>9Yz!))tGOpamUTK?gDJcdKr#YGk!kL|n zqr79i(2zu$G?r&9k=SmTIVn6*=;_qZA((Jxki$$2Q z2T80L`{K+YAV}gLhVxEFe0W3$Kd8+iW1NBoRlp)*oeV>Qo*hr`nZWU6Ku6|)MnnSv z?yf00CFa8;bfJN^Rh6Ki4gmNeWr7M)WS;2B0gX5Cc z(I?g{*AfB|f4i?LB-uW6M+kBe=gx6J`0}0?RoH=nF$!}b9$&3gnB_o{pNc)a0iP)5 zxqU%6d4$dyTq%($oD;2-1`EN!`}&%A8W<3WBhEhSb7FABhF8z=TFG%39t6}53(Ay) zc=KS<0d7dtAI)T3bW$bPJ1WT*4VFzF=QTnYutSOQS&$%4C1n|zR+_<%25{jRCF-nY z@}5RzBNDGJT1-k4j>M)I&x3`UGjL{$Z*+#|I3`+}GJ!!cl?{K4lo-j#SrkAWW$)<- z%;O^x9{y+m17$Ke^|em_Qkb-rC2S1sjSf1irns zRFMfwA`Xc#r(+1k8-GxASUNdW+yX8qj>9x$*nn^yLP9g~jDd5&Fht5|V-JosVpz#2 zl_4t5;lO;Q69fQ^rWzdZ&L{$8XyC$3$4aXsTaW;jyh07cCUw)AM8$zZIDwr%CMbiK zAZYUrW*xDHm*sx%j-=VHZl$vM36Sj%l^dz2Um5-No65{ycFRi z0x6U*GZ`)>1C^q&RgDP?f|x^%;))p3iX}K)p@VO5kYJIzV>iZn$<@Wzj ztOSp4Q|qc~3gRw3(F7u{iiH(`1ODcr>CWyy?JRj9#Y8vrLWvLtcT{FI)ewAzO`Ym5 z2;McjSY|pv@4KBp2fDES5*69W$K$9ss$8q;gJ5XS; zI^3^{)T&FAG0Wf8bvuTj83&1u^X}mcfMu&8oPBb2V1(g>^DYrOj670N36uo9zSyO+ z*epk;em7L>$&+)K#xc;=TND@oA%A$YQgAWI<*~+e1L;+q0B+`ap06?$1w*u+~TT- z5y8wT-d0X?W(!u6fShxa#x5EPl>)8|%;1}YJ&yA|1mhiiM2Ue3Ie-X)4r5r|#Bc%* z7(nUr+Ho2%Nk(iUC>JDH)GGdc!i zs&ZvB5YERBiYX90UB9~;s0jxUcUT}HkSuG(SCo$eIhyWq7z4m2CMa9oFrD;syOlIS zY|EW(&s4|&LRg7ef4-f5=qIhvIcp%@8h@Kbm^N z#)kxt7;CtL4s-mE#b0~X5(~8oTn3@3hNNd+4Nq|2Z}v8ARy`%wV3A|ZZH=f zu$erechwUzh;EKUX>9%yARQ7}#=fiw=YkLr5Qz*f^Iq5pqLPiUBq!CJKnxPWIfPGC zHqhfdgs$OVL#n3jh^mz#GEBi3GrBDV0iDM(LS+P4iqFIZ06VTt0EK%o+Fd!P2VsF9G94eYFP7GzQa05P9)iPK`hcxV9ilLYujQLtf< zhC*_ohfxW!nVSh#d?Z zgYy`xrf^WwWb;t?#4)D>+uy2+!#D}S&nOmok+KI2eCjB%QW8KQkAZB?ImnzKeXbw6 z!V#t*0WtPJ7GH33RI&`gcf`<4U?adIZQH@s*xZYdf_9IBTsD*sooWKG!jUayJyj~4 zN@7#|#Wl*4A~<@O&xL0}uM?cbaY#g1OJ>+)_2TD}X}~ENmKYb#Y2R{ES`@Pign6c7 zWJsl?A5SQq56Tp*JMd_gfaoZ>@4`On^IGGh}&cq{*e2BLn&Sy8Xj4 z94NO7j3JQxQ7Ix$HkkDk0Z2rG4p-;#OC2G=AScZNCT8a z72$%+=ixqU4yGY8IVK_#j%YzhiZNjs&h^E~11<^XPZisjFOVBLTpq0QUW+PRt;>Vz zs>MvM*g(dtuZr+g&zBnW=Be2MiP;V@2`y%9hB@#Y7@-9RwSlC@f7>kJWEky&J--zw zg0SR}B>0{hc4}oKN=Pb+-sy&kpi0B8Wg|UUKo;DEm6(mj@e^K137=PlNgq7f#?8sX z;U*Ea`>WM`urLDz%7*cZ-h+iAB>74q;Xw&0P{AXC2}fG7HZ>Ok;T9NBoiQ>UUX7Fi z43trXaK^7Qo5+j?T!TJ})-<(9%roKB-HwP62?OZ{>}--LXJ&aZ!H0^v129;dhF2qa zY@E*$7Dgf#1Y>I{;mwkSHyFYr2Q5Rz0|~OQf?yUL4DQL!0Vr%nWq?db&=|y-6wc&m z?4>9*)KHVx@mWiR_R9xQ`o&dc2@C~5=OOiR0u2zJMUmPy`mjaRwF+d8(>sh_2H-<5 zhI5GLqA8iv&P)5>wWyI55H_2YRm~s-ADf0!&k-gG^bvphi7rv+y0vOG!k)pqv<^M+8s|%VDt&p(t@$YvT~mh{Cc2 zOd6c8M=F_({%S%-i3y5lfr{q|Kfzs`!C=U_?uo?Q6H|9n2g#I2;=ee$9L4)JXTdy# z3Hi-Cq9k{jibRtv!7G!^VMqjRW;5AjS%OAXX3twrGlrFfRM1%tQS^ONB$60bKe#Eb zM3t0G$9Sy;lVPz8bz|r*DBtm8-pbx355Z=JFoqb&eMQicm4izI8p~Q@7(fY!CGyXq zW&Z$dz9@wz1Z%4-!D!1kJ}z=iUP&_vb=nm<0wDAANO^_KBmUW_GYLQ>CZa0LUg_Me1Wc literal 0 HcmV?d00001 diff --git a/gallery/assets/imagenet_class_index.json b/gallery/assets/imagenet_class_index.json new file mode 100644 index 00000000000..5fe0dfefcd3 --- /dev/null +++ b/gallery/assets/imagenet_class_index.json @@ -0,0 +1 @@ +{"0": ["n01440764", "tench"], "1": ["n01443537", "goldfish"], "2": ["n01484850", "great_white_shark"], "3": ["n01491361", "tiger_shark"], "4": ["n01494475", "hammerhead"], "5": ["n01496331", "electric_ray"], "6": ["n01498041", "stingray"], "7": ["n01514668", "cock"], "8": ["n01514859", "hen"], "9": ["n01518878", "ostrich"], "10": ["n01530575", "brambling"], "11": ["n01531178", "goldfinch"], "12": ["n01532829", "house_finch"], "13": ["n01534433", "junco"], "14": ["n01537544", "indigo_bunting"], "15": ["n01558993", "robin"], "16": ["n01560419", "bulbul"], "17": ["n01580077", "jay"], "18": ["n01582220", "magpie"], "19": ["n01592084", "chickadee"], "20": ["n01601694", "water_ouzel"], "21": ["n01608432", "kite"], "22": ["n01614925", "bald_eagle"], "23": ["n01616318", "vulture"], "24": ["n01622779", "great_grey_owl"], "25": ["n01629819", "European_fire_salamander"], "26": ["n01630670", "common_newt"], "27": ["n01631663", "eft"], "28": ["n01632458", "spotted_salamander"], "29": ["n01632777", "axolotl"], "30": ["n01641577", "bullfrog"], "31": ["n01644373", "tree_frog"], "32": ["n01644900", "tailed_frog"], "33": ["n01664065", "loggerhead"], "34": ["n01665541", "leatherback_turtle"], "35": ["n01667114", "mud_turtle"], "36": ["n01667778", "terrapin"], "37": ["n01669191", "box_turtle"], "38": ["n01675722", "banded_gecko"], "39": ["n01677366", "common_iguana"], "40": ["n01682714", "American_chameleon"], "41": ["n01685808", "whiptail"], "42": ["n01687978", "agama"], "43": ["n01688243", "frilled_lizard"], "44": ["n01689811", "alligator_lizard"], "45": ["n01692333", "Gila_monster"], "46": ["n01693334", "green_lizard"], "47": ["n01694178", "African_chameleon"], "48": ["n01695060", "Komodo_dragon"], "49": ["n01697457", "African_crocodile"], "50": ["n01698640", "American_alligator"], "51": ["n01704323", "triceratops"], "52": ["n01728572", "thunder_snake"], "53": ["n01728920", "ringneck_snake"], "54": ["n01729322", "hognose_snake"], "55": ["n01729977", "green_snake"], "56": ["n01734418", "king_snake"], "57": ["n01735189", "garter_snake"], "58": ["n01737021", "water_snake"], "59": ["n01739381", "vine_snake"], "60": ["n01740131", "night_snake"], "61": ["n01742172", "boa_constrictor"], "62": ["n01744401", "rock_python"], "63": ["n01748264", "Indian_cobra"], "64": ["n01749939", "green_mamba"], "65": ["n01751748", "sea_snake"], "66": ["n01753488", "horned_viper"], "67": ["n01755581", "diamondback"], "68": ["n01756291", "sidewinder"], "69": ["n01768244", "trilobite"], "70": ["n01770081", "harvestman"], "71": ["n01770393", "scorpion"], "72": ["n01773157", "black_and_gold_garden_spider"], "73": ["n01773549", "barn_spider"], "74": ["n01773797", "garden_spider"], "75": ["n01774384", "black_widow"], "76": ["n01774750", "tarantula"], "77": ["n01775062", "wolf_spider"], "78": ["n01776313", "tick"], "79": ["n01784675", "centipede"], "80": ["n01795545", "black_grouse"], "81": ["n01796340", "ptarmigan"], "82": ["n01797886", "ruffed_grouse"], "83": ["n01798484", "prairie_chicken"], "84": ["n01806143", "peacock"], "85": ["n01806567", "quail"], "86": ["n01807496", "partridge"], "87": ["n01817953", "African_grey"], "88": ["n01818515", "macaw"], "89": ["n01819313", "sulphur-crested_cockatoo"], "90": ["n01820546", "lorikeet"], "91": ["n01824575", "coucal"], "92": ["n01828970", "bee_eater"], "93": ["n01829413", "hornbill"], "94": ["n01833805", "hummingbird"], "95": ["n01843065", "jacamar"], "96": ["n01843383", "toucan"], "97": ["n01847000", "drake"], "98": ["n01855032", "red-breasted_merganser"], "99": ["n01855672", "goose"], "100": ["n01860187", "black_swan"], "101": ["n01871265", "tusker"], "102": ["n01872401", "echidna"], "103": ["n01873310", "platypus"], "104": ["n01877812", "wallaby"], "105": ["n01882714", "koala"], "106": ["n01883070", "wombat"], "107": ["n01910747", "jellyfish"], "108": ["n01914609", "sea_anemone"], "109": ["n01917289", "brain_coral"], "110": ["n01924916", "flatworm"], "111": ["n01930112", "nematode"], "112": ["n01943899", "conch"], "113": ["n01944390", "snail"], "114": ["n01945685", "slug"], "115": ["n01950731", "sea_slug"], "116": ["n01955084", "chiton"], "117": ["n01968897", "chambered_nautilus"], "118": ["n01978287", "Dungeness_crab"], "119": ["n01978455", "rock_crab"], "120": ["n01980166", "fiddler_crab"], "121": ["n01981276", "king_crab"], "122": ["n01983481", "American_lobster"], "123": ["n01984695", "spiny_lobster"], "124": ["n01985128", "crayfish"], "125": ["n01986214", "hermit_crab"], "126": ["n01990800", "isopod"], "127": ["n02002556", "white_stork"], "128": ["n02002724", "black_stork"], "129": ["n02006656", "spoonbill"], "130": ["n02007558", "flamingo"], "131": ["n02009229", "little_blue_heron"], "132": ["n02009912", "American_egret"], "133": ["n02011460", "bittern"], "134": ["n02012849", "crane"], "135": ["n02013706", "limpkin"], "136": ["n02017213", "European_gallinule"], "137": ["n02018207", "American_coot"], "138": ["n02018795", "bustard"], "139": ["n02025239", "ruddy_turnstone"], "140": ["n02027492", "red-backed_sandpiper"], "141": ["n02028035", "redshank"], "142": ["n02033041", "dowitcher"], "143": ["n02037110", "oystercatcher"], "144": ["n02051845", "pelican"], "145": ["n02056570", "king_penguin"], "146": ["n02058221", "albatross"], "147": ["n02066245", "grey_whale"], "148": ["n02071294", "killer_whale"], "149": ["n02074367", "dugong"], "150": ["n02077923", "sea_lion"], "151": ["n02085620", "Chihuahua"], "152": ["n02085782", "Japanese_spaniel"], "153": ["n02085936", "Maltese_dog"], "154": ["n02086079", "Pekinese"], "155": ["n02086240", "Shih-Tzu"], "156": ["n02086646", "Blenheim_spaniel"], "157": ["n02086910", "papillon"], "158": ["n02087046", "toy_terrier"], "159": ["n02087394", "Rhodesian_ridgeback"], "160": ["n02088094", "Afghan_hound"], "161": ["n02088238", "basset"], "162": ["n02088364", "beagle"], "163": ["n02088466", "bloodhound"], "164": ["n02088632", "bluetick"], "165": ["n02089078", "black-and-tan_coonhound"], "166": ["n02089867", "Walker_hound"], "167": ["n02089973", "English_foxhound"], "168": ["n02090379", "redbone"], "169": ["n02090622", "borzoi"], "170": ["n02090721", "Irish_wolfhound"], "171": ["n02091032", "Italian_greyhound"], "172": ["n02091134", "whippet"], "173": ["n02091244", "Ibizan_hound"], "174": ["n02091467", "Norwegian_elkhound"], "175": ["n02091635", "otterhound"], "176": ["n02091831", "Saluki"], "177": ["n02092002", "Scottish_deerhound"], "178": ["n02092339", "Weimaraner"], "179": ["n02093256", "Staffordshire_bullterrier"], "180": ["n02093428", "American_Staffordshire_terrier"], "181": ["n02093647", "Bedlington_terrier"], "182": ["n02093754", "Border_terrier"], "183": ["n02093859", "Kerry_blue_terrier"], "184": ["n02093991", "Irish_terrier"], "185": ["n02094114", "Norfolk_terrier"], "186": ["n02094258", "Norwich_terrier"], "187": ["n02094433", "Yorkshire_terrier"], "188": ["n02095314", "wire-haired_fox_terrier"], "189": ["n02095570", "Lakeland_terrier"], "190": ["n02095889", "Sealyham_terrier"], "191": ["n02096051", "Airedale"], "192": ["n02096177", "cairn"], "193": ["n02096294", "Australian_terrier"], "194": ["n02096437", "Dandie_Dinmont"], "195": ["n02096585", "Boston_bull"], "196": ["n02097047", "miniature_schnauzer"], "197": ["n02097130", "giant_schnauzer"], "198": ["n02097209", "standard_schnauzer"], "199": ["n02097298", "Scotch_terrier"], "200": ["n02097474", "Tibetan_terrier"], "201": ["n02097658", "silky_terrier"], "202": ["n02098105", "soft-coated_wheaten_terrier"], "203": ["n02098286", "West_Highland_white_terrier"], "204": ["n02098413", "Lhasa"], "205": ["n02099267", "flat-coated_retriever"], "206": ["n02099429", "curly-coated_retriever"], "207": ["n02099601", "golden_retriever"], "208": ["n02099712", "Labrador_retriever"], "209": ["n02099849", "Chesapeake_Bay_retriever"], "210": ["n02100236", "German_short-haired_pointer"], "211": ["n02100583", "vizsla"], "212": ["n02100735", "English_setter"], "213": ["n02100877", "Irish_setter"], "214": ["n02101006", "Gordon_setter"], "215": ["n02101388", "Brittany_spaniel"], "216": ["n02101556", "clumber"], "217": ["n02102040", "English_springer"], "218": ["n02102177", "Welsh_springer_spaniel"], "219": ["n02102318", "cocker_spaniel"], "220": ["n02102480", "Sussex_spaniel"], "221": ["n02102973", "Irish_water_spaniel"], "222": ["n02104029", "kuvasz"], "223": ["n02104365", "schipperke"], "224": ["n02105056", "groenendael"], "225": ["n02105162", "malinois"], "226": ["n02105251", "briard"], "227": ["n02105412", "kelpie"], "228": ["n02105505", "komondor"], "229": ["n02105641", "Old_English_sheepdog"], "230": ["n02105855", "Shetland_sheepdog"], "231": ["n02106030", "collie"], "232": ["n02106166", "Border_collie"], "233": ["n02106382", "Bouvier_des_Flandres"], "234": ["n02106550", "Rottweiler"], "235": ["n02106662", "German_shepherd"], "236": ["n02107142", "Doberman"], "237": ["n02107312", "miniature_pinscher"], "238": ["n02107574", "Greater_Swiss_Mountain_dog"], "239": ["n02107683", "Bernese_mountain_dog"], "240": ["n02107908", "Appenzeller"], "241": ["n02108000", "EntleBucher"], "242": ["n02108089", "boxer"], "243": ["n02108422", "bull_mastiff"], "244": ["n02108551", "Tibetan_mastiff"], "245": ["n02108915", "French_bulldog"], "246": ["n02109047", "Great_Dane"], "247": ["n02109525", "Saint_Bernard"], "248": ["n02109961", "Eskimo_dog"], "249": ["n02110063", "malamute"], "250": ["n02110185", "Siberian_husky"], "251": ["n02110341", "dalmatian"], "252": ["n02110627", "affenpinscher"], "253": ["n02110806", "basenji"], "254": ["n02110958", "pug"], "255": ["n02111129", "Leonberg"], "256": ["n02111277", "Newfoundland"], "257": ["n02111500", "Great_Pyrenees"], "258": ["n02111889", "Samoyed"], "259": ["n02112018", "Pomeranian"], "260": ["n02112137", "chow"], "261": ["n02112350", "keeshond"], "262": ["n02112706", "Brabancon_griffon"], "263": ["n02113023", "Pembroke"], "264": ["n02113186", "Cardigan"], "265": ["n02113624", "toy_poodle"], "266": ["n02113712", "miniature_poodle"], "267": ["n02113799", "standard_poodle"], "268": ["n02113978", "Mexican_hairless"], "269": ["n02114367", "timber_wolf"], "270": ["n02114548", "white_wolf"], "271": ["n02114712", "red_wolf"], "272": ["n02114855", "coyote"], "273": ["n02115641", "dingo"], "274": ["n02115913", "dhole"], "275": ["n02116738", "African_hunting_dog"], "276": ["n02117135", "hyena"], "277": ["n02119022", "red_fox"], "278": ["n02119789", "kit_fox"], "279": ["n02120079", "Arctic_fox"], "280": ["n02120505", "grey_fox"], "281": ["n02123045", "tabby"], "282": ["n02123159", "tiger_cat"], "283": ["n02123394", "Persian_cat"], "284": ["n02123597", "Siamese_cat"], "285": ["n02124075", "Egyptian_cat"], "286": ["n02125311", "cougar"], "287": ["n02127052", "lynx"], "288": ["n02128385", "leopard"], "289": ["n02128757", "snow_leopard"], "290": ["n02128925", "jaguar"], "291": ["n02129165", "lion"], "292": ["n02129604", "tiger"], "293": ["n02130308", "cheetah"], "294": ["n02132136", "brown_bear"], "295": ["n02133161", "American_black_bear"], "296": ["n02134084", "ice_bear"], "297": ["n02134418", "sloth_bear"], "298": ["n02137549", "mongoose"], "299": ["n02138441", "meerkat"], "300": ["n02165105", "tiger_beetle"], "301": ["n02165456", "ladybug"], "302": ["n02167151", "ground_beetle"], "303": ["n02168699", "long-horned_beetle"], "304": ["n02169497", "leaf_beetle"], "305": ["n02172182", "dung_beetle"], "306": ["n02174001", "rhinoceros_beetle"], "307": ["n02177972", "weevil"], "308": ["n02190166", "fly"], "309": ["n02206856", "bee"], "310": ["n02219486", "ant"], "311": ["n02226429", "grasshopper"], "312": ["n02229544", "cricket"], "313": ["n02231487", "walking_stick"], "314": ["n02233338", "cockroach"], "315": ["n02236044", "mantis"], "316": ["n02256656", "cicada"], "317": ["n02259212", "leafhopper"], "318": ["n02264363", "lacewing"], "319": ["n02268443", "dragonfly"], "320": ["n02268853", "damselfly"], "321": ["n02276258", "admiral"], "322": ["n02277742", "ringlet"], "323": ["n02279972", "monarch"], "324": ["n02280649", "cabbage_butterfly"], "325": ["n02281406", "sulphur_butterfly"], "326": ["n02281787", "lycaenid"], "327": ["n02317335", "starfish"], "328": ["n02319095", "sea_urchin"], "329": ["n02321529", "sea_cucumber"], "330": ["n02325366", "wood_rabbit"], "331": ["n02326432", "hare"], "332": ["n02328150", "Angora"], "333": ["n02342885", "hamster"], "334": ["n02346627", "porcupine"], "335": ["n02356798", "fox_squirrel"], "336": ["n02361337", "marmot"], "337": ["n02363005", "beaver"], "338": ["n02364673", "guinea_pig"], "339": ["n02389026", "sorrel"], "340": ["n02391049", "zebra"], "341": ["n02395406", "hog"], "342": ["n02396427", "wild_boar"], "343": ["n02397096", "warthog"], "344": ["n02398521", "hippopotamus"], "345": ["n02403003", "ox"], "346": ["n02408429", "water_buffalo"], "347": ["n02410509", "bison"], "348": ["n02412080", "ram"], "349": ["n02415577", "bighorn"], "350": ["n02417914", "ibex"], "351": ["n02422106", "hartebeest"], "352": ["n02422699", "impala"], "353": ["n02423022", "gazelle"], "354": ["n02437312", "Arabian_camel"], "355": ["n02437616", "llama"], "356": ["n02441942", "weasel"], "357": ["n02442845", "mink"], "358": ["n02443114", "polecat"], "359": ["n02443484", "black-footed_ferret"], "360": ["n02444819", "otter"], "361": ["n02445715", "skunk"], "362": ["n02447366", "badger"], "363": ["n02454379", "armadillo"], "364": ["n02457408", "three-toed_sloth"], "365": ["n02480495", "orangutan"], "366": ["n02480855", "gorilla"], "367": ["n02481823", "chimpanzee"], "368": ["n02483362", "gibbon"], "369": ["n02483708", "siamang"], "370": ["n02484975", "guenon"], "371": ["n02486261", "patas"], "372": ["n02486410", "baboon"], "373": ["n02487347", "macaque"], "374": ["n02488291", "langur"], "375": ["n02488702", "colobus"], "376": ["n02489166", "proboscis_monkey"], "377": ["n02490219", "marmoset"], "378": ["n02492035", "capuchin"], "379": ["n02492660", "howler_monkey"], "380": ["n02493509", "titi"], "381": ["n02493793", "spider_monkey"], "382": ["n02494079", "squirrel_monkey"], "383": ["n02497673", "Madagascar_cat"], "384": ["n02500267", "indri"], "385": ["n02504013", "Indian_elephant"], "386": ["n02504458", "African_elephant"], "387": ["n02509815", "lesser_panda"], "388": ["n02510455", "giant_panda"], "389": ["n02514041", "barracouta"], "390": ["n02526121", "eel"], "391": ["n02536864", "coho"], "392": ["n02606052", "rock_beauty"], "393": ["n02607072", "anemone_fish"], "394": ["n02640242", "sturgeon"], "395": ["n02641379", "gar"], "396": ["n02643566", "lionfish"], "397": ["n02655020", "puffer"], "398": ["n02666196", "abacus"], "399": ["n02667093", "abaya"], "400": ["n02669723", "academic_gown"], "401": ["n02672831", "accordion"], "402": ["n02676566", "acoustic_guitar"], "403": ["n02687172", "aircraft_carrier"], "404": ["n02690373", "airliner"], "405": ["n02692877", "airship"], "406": ["n02699494", "altar"], "407": ["n02701002", "ambulance"], "408": ["n02704792", "amphibian"], "409": ["n02708093", "analog_clock"], "410": ["n02727426", "apiary"], "411": ["n02730930", "apron"], "412": ["n02747177", "ashcan"], "413": ["n02749479", "assault_rifle"], "414": ["n02769748", "backpack"], "415": ["n02776631", "bakery"], "416": ["n02777292", "balance_beam"], "417": ["n02782093", "balloon"], "418": ["n02783161", "ballpoint"], "419": ["n02786058", "Band_Aid"], "420": ["n02787622", "banjo"], "421": ["n02788148", "bannister"], "422": ["n02790996", "barbell"], "423": ["n02791124", "barber_chair"], "424": ["n02791270", "barbershop"], "425": ["n02793495", "barn"], "426": ["n02794156", "barometer"], "427": ["n02795169", "barrel"], "428": ["n02797295", "barrow"], "429": ["n02799071", "baseball"], "430": ["n02802426", "basketball"], "431": ["n02804414", "bassinet"], "432": ["n02804610", "bassoon"], "433": ["n02807133", "bathing_cap"], "434": ["n02808304", "bath_towel"], "435": ["n02808440", "bathtub"], "436": ["n02814533", "beach_wagon"], "437": ["n02814860", "beacon"], "438": ["n02815834", "beaker"], "439": ["n02817516", "bearskin"], "440": ["n02823428", "beer_bottle"], "441": ["n02823750", "beer_glass"], "442": ["n02825657", "bell_cote"], "443": ["n02834397", "bib"], "444": ["n02835271", "bicycle-built-for-two"], "445": ["n02837789", "bikini"], "446": ["n02840245", "binder"], "447": ["n02841315", "binoculars"], "448": ["n02843684", "birdhouse"], "449": ["n02859443", "boathouse"], "450": ["n02860847", "bobsled"], "451": ["n02865351", "bolo_tie"], "452": ["n02869837", "bonnet"], "453": ["n02870880", "bookcase"], "454": ["n02871525", "bookshop"], "455": ["n02877765", "bottlecap"], "456": ["n02879718", "bow"], "457": ["n02883205", "bow_tie"], "458": ["n02892201", "brass"], "459": ["n02892767", "brassiere"], "460": ["n02894605", "breakwater"], "461": ["n02895154", "breastplate"], "462": ["n02906734", "broom"], "463": ["n02909870", "bucket"], "464": ["n02910353", "buckle"], "465": ["n02916936", "bulletproof_vest"], "466": ["n02917067", "bullet_train"], "467": ["n02927161", "butcher_shop"], "468": ["n02930766", "cab"], "469": ["n02939185", "caldron"], "470": ["n02948072", "candle"], "471": ["n02950826", "cannon"], "472": ["n02951358", "canoe"], "473": ["n02951585", "can_opener"], "474": ["n02963159", "cardigan"], "475": ["n02965783", "car_mirror"], "476": ["n02966193", "carousel"], "477": ["n02966687", "carpenter's_kit"], "478": ["n02971356", "carton"], "479": ["n02974003", "car_wheel"], "480": ["n02977058", "cash_machine"], "481": ["n02978881", "cassette"], "482": ["n02979186", "cassette_player"], "483": ["n02980441", "castle"], "484": ["n02981792", "catamaran"], "485": ["n02988304", "CD_player"], "486": ["n02992211", "cello"], "487": ["n02992529", "cellular_telephone"], "488": ["n02999410", "chain"], "489": ["n03000134", "chainlink_fence"], "490": ["n03000247", "chain_mail"], "491": ["n03000684", "chain_saw"], "492": ["n03014705", "chest"], "493": ["n03016953", "chiffonier"], "494": ["n03017168", "chime"], "495": ["n03018349", "china_cabinet"], "496": ["n03026506", "Christmas_stocking"], "497": ["n03028079", "church"], "498": ["n03032252", "cinema"], "499": ["n03041632", "cleaver"], "500": ["n03042490", "cliff_dwelling"], "501": ["n03045698", "cloak"], "502": ["n03047690", "clog"], "503": ["n03062245", "cocktail_shaker"], "504": ["n03063599", "coffee_mug"], "505": ["n03063689", "coffeepot"], "506": ["n03065424", "coil"], "507": ["n03075370", "combination_lock"], "508": ["n03085013", "computer_keyboard"], "509": ["n03089624", "confectionery"], "510": ["n03095699", "container_ship"], "511": ["n03100240", "convertible"], "512": ["n03109150", "corkscrew"], "513": ["n03110669", "cornet"], "514": ["n03124043", "cowboy_boot"], "515": ["n03124170", "cowboy_hat"], "516": ["n03125729", "cradle"], "517": ["n03126707", "crane"], "518": ["n03127747", "crash_helmet"], "519": ["n03127925", "crate"], "520": ["n03131574", "crib"], "521": ["n03133878", "Crock_Pot"], "522": ["n03134739", "croquet_ball"], "523": ["n03141823", "crutch"], "524": ["n03146219", "cuirass"], "525": ["n03160309", "dam"], "526": ["n03179701", "desk"], "527": ["n03180011", "desktop_computer"], "528": ["n03187595", "dial_telephone"], "529": ["n03188531", "diaper"], "530": ["n03196217", "digital_clock"], "531": ["n03197337", "digital_watch"], "532": ["n03201208", "dining_table"], "533": ["n03207743", "dishrag"], "534": ["n03207941", "dishwasher"], "535": ["n03208938", "disk_brake"], "536": ["n03216828", "dock"], "537": ["n03218198", "dogsled"], "538": ["n03220513", "dome"], "539": ["n03223299", "doormat"], "540": ["n03240683", "drilling_platform"], "541": ["n03249569", "drum"], "542": ["n03250847", "drumstick"], "543": ["n03255030", "dumbbell"], "544": ["n03259280", "Dutch_oven"], "545": ["n03271574", "electric_fan"], "546": ["n03272010", "electric_guitar"], "547": ["n03272562", "electric_locomotive"], "548": ["n03290653", "entertainment_center"], "549": ["n03291819", "envelope"], "550": ["n03297495", "espresso_maker"], "551": ["n03314780", "face_powder"], "552": ["n03325584", "feather_boa"], "553": ["n03337140", "file"], "554": ["n03344393", "fireboat"], "555": ["n03345487", "fire_engine"], "556": ["n03347037", "fire_screen"], "557": ["n03355925", "flagpole"], "558": ["n03372029", "flute"], "559": ["n03376595", "folding_chair"], "560": ["n03379051", "football_helmet"], "561": ["n03384352", "forklift"], "562": ["n03388043", "fountain"], "563": ["n03388183", "fountain_pen"], "564": ["n03388549", "four-poster"], "565": ["n03393912", "freight_car"], "566": ["n03394916", "French_horn"], "567": ["n03400231", "frying_pan"], "568": ["n03404251", "fur_coat"], "569": ["n03417042", "garbage_truck"], "570": ["n03424325", "gasmask"], "571": ["n03425413", "gas_pump"], "572": ["n03443371", "goblet"], "573": ["n03444034", "go-kart"], "574": ["n03445777", "golf_ball"], "575": ["n03445924", "golfcart"], "576": ["n03447447", "gondola"], "577": ["n03447721", "gong"], "578": ["n03450230", "gown"], "579": ["n03452741", "grand_piano"], "580": ["n03457902", "greenhouse"], "581": ["n03459775", "grille"], "582": ["n03461385", "grocery_store"], "583": ["n03467068", "guillotine"], "584": ["n03476684", "hair_slide"], "585": ["n03476991", "hair_spray"], "586": ["n03478589", "half_track"], "587": ["n03481172", "hammer"], "588": ["n03482405", "hamper"], "589": ["n03483316", "hand_blower"], "590": ["n03485407", "hand-held_computer"], "591": ["n03485794", "handkerchief"], "592": ["n03492542", "hard_disc"], "593": ["n03494278", "harmonica"], "594": ["n03495258", "harp"], "595": ["n03496892", "harvester"], "596": ["n03498962", "hatchet"], "597": ["n03527444", "holster"], "598": ["n03529860", "home_theater"], "599": ["n03530642", "honeycomb"], "600": ["n03532672", "hook"], "601": ["n03534580", "hoopskirt"], "602": ["n03535780", "horizontal_bar"], "603": ["n03538406", "horse_cart"], "604": ["n03544143", "hourglass"], "605": ["n03584254", "iPod"], "606": ["n03584829", "iron"], "607": ["n03590841", "jack-o'-lantern"], "608": ["n03594734", "jean"], "609": ["n03594945", "jeep"], "610": ["n03595614", "jersey"], "611": ["n03598930", "jigsaw_puzzle"], "612": ["n03599486", "jinrikisha"], "613": ["n03602883", "joystick"], "614": ["n03617480", "kimono"], "615": ["n03623198", "knee_pad"], "616": ["n03627232", "knot"], "617": ["n03630383", "lab_coat"], "618": ["n03633091", "ladle"], "619": ["n03637318", "lampshade"], "620": ["n03642806", "laptop"], "621": ["n03649909", "lawn_mower"], "622": ["n03657121", "lens_cap"], "623": ["n03658185", "letter_opener"], "624": ["n03661043", "library"], "625": ["n03662601", "lifeboat"], "626": ["n03666591", "lighter"], "627": ["n03670208", "limousine"], "628": ["n03673027", "liner"], "629": ["n03676483", "lipstick"], "630": ["n03680355", "Loafer"], "631": ["n03690938", "lotion"], "632": ["n03691459", "loudspeaker"], "633": ["n03692522", "loupe"], "634": ["n03697007", "lumbermill"], "635": ["n03706229", "magnetic_compass"], "636": ["n03709823", "mailbag"], "637": ["n03710193", "mailbox"], "638": ["n03710637", "maillot"], "639": ["n03710721", "maillot"], "640": ["n03717622", "manhole_cover"], "641": ["n03720891", "maraca"], "642": ["n03721384", "marimba"], "643": ["n03724870", "mask"], "644": ["n03729826", "matchstick"], "645": ["n03733131", "maypole"], "646": ["n03733281", "maze"], "647": ["n03733805", "measuring_cup"], "648": ["n03742115", "medicine_chest"], "649": ["n03743016", "megalith"], "650": ["n03759954", "microphone"], "651": ["n03761084", "microwave"], "652": ["n03763968", "military_uniform"], "653": ["n03764736", "milk_can"], "654": ["n03769881", "minibus"], "655": ["n03770439", "miniskirt"], "656": ["n03770679", "minivan"], "657": ["n03773504", "missile"], "658": ["n03775071", "mitten"], "659": ["n03775546", "mixing_bowl"], "660": ["n03776460", "mobile_home"], "661": ["n03777568", "Model_T"], "662": ["n03777754", "modem"], "663": ["n03781244", "monastery"], "664": ["n03782006", "monitor"], "665": ["n03785016", "moped"], "666": ["n03786901", "mortar"], "667": ["n03787032", "mortarboard"], "668": ["n03788195", "mosque"], "669": ["n03788365", "mosquito_net"], "670": ["n03791053", "motor_scooter"], "671": ["n03792782", "mountain_bike"], "672": ["n03792972", "mountain_tent"], "673": ["n03793489", "mouse"], "674": ["n03794056", "mousetrap"], "675": ["n03796401", "moving_van"], "676": ["n03803284", "muzzle"], "677": ["n03804744", "nail"], "678": ["n03814639", "neck_brace"], "679": ["n03814906", "necklace"], "680": ["n03825788", "nipple"], "681": ["n03832673", "notebook"], "682": ["n03837869", "obelisk"], "683": ["n03838899", "oboe"], "684": ["n03840681", "ocarina"], "685": ["n03841143", "odometer"], "686": ["n03843555", "oil_filter"], "687": ["n03854065", "organ"], "688": ["n03857828", "oscilloscope"], "689": ["n03866082", "overskirt"], "690": ["n03868242", "oxcart"], "691": ["n03868863", "oxygen_mask"], "692": ["n03871628", "packet"], "693": ["n03873416", "paddle"], "694": ["n03874293", "paddlewheel"], "695": ["n03874599", "padlock"], "696": ["n03876231", "paintbrush"], "697": ["n03877472", "pajama"], "698": ["n03877845", "palace"], "699": ["n03884397", "panpipe"], "700": ["n03887697", "paper_towel"], "701": ["n03888257", "parachute"], "702": ["n03888605", "parallel_bars"], "703": ["n03891251", "park_bench"], "704": ["n03891332", "parking_meter"], "705": ["n03895866", "passenger_car"], "706": ["n03899768", "patio"], "707": ["n03902125", "pay-phone"], "708": ["n03903868", "pedestal"], "709": ["n03908618", "pencil_box"], "710": ["n03908714", "pencil_sharpener"], "711": ["n03916031", "perfume"], "712": ["n03920288", "Petri_dish"], "713": ["n03924679", "photocopier"], "714": ["n03929660", "pick"], "715": ["n03929855", "pickelhaube"], "716": ["n03930313", "picket_fence"], "717": ["n03930630", "pickup"], "718": ["n03933933", "pier"], "719": ["n03935335", "piggy_bank"], "720": ["n03937543", "pill_bottle"], "721": ["n03938244", "pillow"], "722": ["n03942813", "ping-pong_ball"], "723": ["n03944341", "pinwheel"], "724": ["n03947888", "pirate"], "725": ["n03950228", "pitcher"], "726": ["n03954731", "plane"], "727": ["n03956157", "planetarium"], "728": ["n03958227", "plastic_bag"], "729": ["n03961711", "plate_rack"], "730": ["n03967562", "plow"], "731": ["n03970156", "plunger"], "732": ["n03976467", "Polaroid_camera"], "733": ["n03976657", "pole"], "734": ["n03977966", "police_van"], "735": ["n03980874", "poncho"], "736": ["n03982430", "pool_table"], "737": ["n03983396", "pop_bottle"], "738": ["n03991062", "pot"], "739": ["n03992509", "potter's_wheel"], "740": ["n03995372", "power_drill"], "741": ["n03998194", "prayer_rug"], "742": ["n04004767", "printer"], "743": ["n04005630", "prison"], "744": ["n04008634", "projectile"], "745": ["n04009552", "projector"], "746": ["n04019541", "puck"], "747": ["n04023962", "punching_bag"], "748": ["n04026417", "purse"], "749": ["n04033901", "quill"], "750": ["n04033995", "quilt"], "751": ["n04037443", "racer"], "752": ["n04039381", "racket"], "753": ["n04040759", "radiator"], "754": ["n04041544", "radio"], "755": ["n04044716", "radio_telescope"], "756": ["n04049303", "rain_barrel"], "757": ["n04065272", "recreational_vehicle"], "758": ["n04067472", "reel"], "759": ["n04069434", "reflex_camera"], "760": ["n04070727", "refrigerator"], "761": ["n04074963", "remote_control"], "762": ["n04081281", "restaurant"], "763": ["n04086273", "revolver"], "764": ["n04090263", "rifle"], "765": ["n04099969", "rocking_chair"], "766": ["n04111531", "rotisserie"], "767": ["n04116512", "rubber_eraser"], "768": ["n04118538", "rugby_ball"], "769": ["n04118776", "rule"], "770": ["n04120489", "running_shoe"], "771": ["n04125021", "safe"], "772": ["n04127249", "safety_pin"], "773": ["n04131690", "saltshaker"], "774": ["n04133789", "sandal"], "775": ["n04136333", "sarong"], "776": ["n04141076", "sax"], "777": ["n04141327", "scabbard"], "778": ["n04141975", "scale"], "779": ["n04146614", "school_bus"], "780": ["n04147183", "schooner"], "781": ["n04149813", "scoreboard"], "782": ["n04152593", "screen"], "783": ["n04153751", "screw"], "784": ["n04154565", "screwdriver"], "785": ["n04162706", "seat_belt"], "786": ["n04179913", "sewing_machine"], "787": ["n04192698", "shield"], "788": ["n04200800", "shoe_shop"], "789": ["n04201297", "shoji"], "790": ["n04204238", "shopping_basket"], "791": ["n04204347", "shopping_cart"], "792": ["n04208210", "shovel"], "793": ["n04209133", "shower_cap"], "794": ["n04209239", "shower_curtain"], "795": ["n04228054", "ski"], "796": ["n04229816", "ski_mask"], "797": ["n04235860", "sleeping_bag"], "798": ["n04238763", "slide_rule"], "799": ["n04239074", "sliding_door"], "800": ["n04243546", "slot"], "801": ["n04251144", "snorkel"], "802": ["n04252077", "snowmobile"], "803": ["n04252225", "snowplow"], "804": ["n04254120", "soap_dispenser"], "805": ["n04254680", "soccer_ball"], "806": ["n04254777", "sock"], "807": ["n04258138", "solar_dish"], "808": ["n04259630", "sombrero"], "809": ["n04263257", "soup_bowl"], "810": ["n04264628", "space_bar"], "811": ["n04265275", "space_heater"], "812": ["n04266014", "space_shuttle"], "813": ["n04270147", "spatula"], "814": ["n04273569", "speedboat"], "815": ["n04275548", "spider_web"], "816": ["n04277352", "spindle"], "817": ["n04285008", "sports_car"], "818": ["n04286575", "spotlight"], "819": ["n04296562", "stage"], "820": ["n04310018", "steam_locomotive"], "821": ["n04311004", "steel_arch_bridge"], "822": ["n04311174", "steel_drum"], "823": ["n04317175", "stethoscope"], "824": ["n04325704", "stole"], "825": ["n04326547", "stone_wall"], "826": ["n04328186", "stopwatch"], "827": ["n04330267", "stove"], "828": ["n04332243", "strainer"], "829": ["n04335435", "streetcar"], "830": ["n04336792", "stretcher"], "831": ["n04344873", "studio_couch"], "832": ["n04346328", "stupa"], "833": ["n04347754", "submarine"], "834": ["n04350905", "suit"], "835": ["n04355338", "sundial"], "836": ["n04355933", "sunglass"], "837": ["n04356056", "sunglasses"], "838": ["n04357314", "sunscreen"], "839": ["n04366367", "suspension_bridge"], "840": ["n04367480", "swab"], "841": ["n04370456", "sweatshirt"], "842": ["n04371430", "swimming_trunks"], "843": ["n04371774", "swing"], "844": ["n04372370", "switch"], "845": ["n04376876", "syringe"], "846": ["n04380533", "table_lamp"], "847": ["n04389033", "tank"], "848": ["n04392985", "tape_player"], "849": ["n04398044", "teapot"], "850": ["n04399382", "teddy"], "851": ["n04404412", "television"], "852": ["n04409515", "tennis_ball"], "853": ["n04417672", "thatch"], "854": ["n04418357", "theater_curtain"], "855": ["n04423845", "thimble"], "856": ["n04428191", "thresher"], "857": ["n04429376", "throne"], "858": ["n04435653", "tile_roof"], "859": ["n04442312", "toaster"], "860": ["n04443257", "tobacco_shop"], "861": ["n04447861", "toilet_seat"], "862": ["n04456115", "torch"], "863": ["n04458633", "totem_pole"], "864": ["n04461696", "tow_truck"], "865": ["n04462240", "toyshop"], "866": ["n04465501", "tractor"], "867": ["n04467665", "trailer_truck"], "868": ["n04476259", "tray"], "869": ["n04479046", "trench_coat"], "870": ["n04482393", "tricycle"], "871": ["n04483307", "trimaran"], "872": ["n04485082", "tripod"], "873": ["n04486054", "triumphal_arch"], "874": ["n04487081", "trolleybus"], "875": ["n04487394", "trombone"], "876": ["n04493381", "tub"], "877": ["n04501370", "turnstile"], "878": ["n04505470", "typewriter_keyboard"], "879": ["n04507155", "umbrella"], "880": ["n04509417", "unicycle"], "881": ["n04515003", "upright"], "882": ["n04517823", "vacuum"], "883": ["n04522168", "vase"], "884": ["n04523525", "vault"], "885": ["n04525038", "velvet"], "886": ["n04525305", "vending_machine"], "887": ["n04532106", "vestment"], "888": ["n04532670", "viaduct"], "889": ["n04536866", "violin"], "890": ["n04540053", "volleyball"], "891": ["n04542943", "waffle_iron"], "892": ["n04548280", "wall_clock"], "893": ["n04548362", "wallet"], "894": ["n04550184", "wardrobe"], "895": ["n04552348", "warplane"], "896": ["n04553703", "washbasin"], "897": ["n04554684", "washer"], "898": ["n04557648", "water_bottle"], "899": ["n04560804", "water_jug"], "900": ["n04562935", "water_tower"], "901": ["n04579145", "whiskey_jug"], "902": ["n04579432", "whistle"], "903": ["n04584207", "wig"], "904": ["n04589890", "window_screen"], "905": ["n04590129", "window_shade"], "906": ["n04591157", "Windsor_tie"], "907": ["n04591713", "wine_bottle"], "908": ["n04592741", "wing"], "909": ["n04596742", "wok"], "910": ["n04597913", "wooden_spoon"], "911": ["n04599235", "wool"], "912": ["n04604644", "worm_fence"], "913": ["n04606251", "wreck"], "914": ["n04612504", "yawl"], "915": ["n04613696", "yurt"], "916": ["n06359193", "web_site"], "917": ["n06596364", "comic_book"], "918": ["n06785654", "crossword_puzzle"], "919": ["n06794110", "street_sign"], "920": ["n06874185", "traffic_light"], "921": ["n07248320", "book_jacket"], "922": ["n07565083", "menu"], "923": ["n07579787", "plate"], "924": ["n07583066", "guacamole"], "925": ["n07584110", "consomme"], "926": ["n07590611", "hot_pot"], "927": ["n07613480", "trifle"], "928": ["n07614500", "ice_cream"], "929": ["n07615774", "ice_lolly"], "930": ["n07684084", "French_loaf"], "931": ["n07693725", "bagel"], "932": ["n07695742", "pretzel"], "933": ["n07697313", "cheeseburger"], "934": ["n07697537", "hotdog"], "935": ["n07711569", "mashed_potato"], "936": ["n07714571", "head_cabbage"], "937": ["n07714990", "broccoli"], "938": ["n07715103", "cauliflower"], "939": ["n07716358", "zucchini"], "940": ["n07716906", "spaghetti_squash"], "941": ["n07717410", "acorn_squash"], "942": ["n07717556", "butternut_squash"], "943": ["n07718472", "cucumber"], "944": ["n07718747", "artichoke"], "945": ["n07720875", "bell_pepper"], "946": ["n07730033", "cardoon"], "947": ["n07734744", "mushroom"], "948": ["n07742313", "Granny_Smith"], "949": ["n07745940", "strawberry"], "950": ["n07747607", "orange"], "951": ["n07749582", "lemon"], "952": ["n07753113", "fig"], "953": ["n07753275", "pineapple"], "954": ["n07753592", "banana"], "955": ["n07754684", "jackfruit"], "956": ["n07760859", "custard_apple"], "957": ["n07768694", "pomegranate"], "958": ["n07802026", "hay"], "959": ["n07831146", "carbonara"], "960": ["n07836838", "chocolate_sauce"], "961": ["n07860988", "dough"], "962": ["n07871810", "meat_loaf"], "963": ["n07873807", "pizza"], "964": ["n07875152", "potpie"], "965": ["n07880968", "burrito"], "966": ["n07892512", "red_wine"], "967": ["n07920052", "espresso"], "968": ["n07930864", "cup"], "969": ["n07932039", "eggnog"], "970": ["n09193705", "alp"], "971": ["n09229709", "bubble"], "972": ["n09246464", "cliff"], "973": ["n09256479", "coral_reef"], "974": ["n09288635", "geyser"], "975": ["n09332890", "lakeside"], "976": ["n09399592", "promontory"], "977": ["n09421951", "sandbar"], "978": ["n09428293", "seashore"], "979": ["n09468604", "valley"], "980": ["n09472597", "volcano"], "981": ["n09835506", "ballplayer"], "982": ["n10148035", "groom"], "983": ["n10565667", "scuba_diver"], "984": ["n11879895", "rapeseed"], "985": ["n11939491", "daisy"], "986": ["n12057211", "yellow_lady's_slipper"], "987": ["n12144580", "corn"], "988": ["n12267677", "acorn"], "989": ["n12620546", "hip"], "990": ["n12768682", "buckeye"], "991": ["n12985857", "coral_fungus"], "992": ["n12998815", "agaric"], "993": ["n13037406", "gyromitra"], "994": ["n13040303", "stinkhorn"], "995": ["n13044778", "earthstar"], "996": ["n13052670", "hen-of-the-woods"], "997": ["n13054560", "bolete"], "998": ["n13133613", "ear"], "999": ["n15075141", "toilet_tissue"]} \ No newline at end of file diff --git a/gallery/plot_scripted_tensor_transforms.py b/gallery/plot_scripted_tensor_transforms.py new file mode 100644 index 00000000000..1decb0b7d21 --- /dev/null +++ b/gallery/plot_scripted_tensor_transforms.py @@ -0,0 +1,145 @@ +""" +========================= +Tensor transforms and JIT +========================= + +This example illustrates various features that are now supported by the +:ref:`image transformations ` on Tensor images. In particular, we +show how image transforms can be performed on GPU, and how one can also script +them using JIT compilation. + +Prior to v0.8.0, transforms in torchvision have traditionally been PIL-centric +and presented multiple limitations due to that. Now, since v0.8.0, transforms +implementations are Tensor and PIL compatible and we can achieve the following +new features: + +- transform multi-band torch tensor images (with more than 3-4 channels) +- torchscript transforms together with your model for deployment +- support for GPU acceleration +- batched transformation such as for videos +- read and decode data directly as torch tensor with torchscript support (for PNG and JPEG image formats) + +.. note:: + These features are only possible with **Tensor** images. +""" + +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np + +import torch +import torchvision.transforms as T +from torchvision.io import read_image + + +plt.rcParams["savefig.bbox"] = 'tight' +torch.manual_seed(0) + + +def show(imgs): + fix, axs = plt.subplots(ncols=len(imgs), squeeze=False) + for i, img in enumerate(imgs): + img = T.ToPILImage()(img.to('cpu')) + axs[0, i].imshow(np.asarray(img)) + axs[0, i].set(xticklabels=[], yticklabels=[], xticks=[], yticks=[]) + + +#################################### +# The :func:`~torchvision.io.read_image` function allows to read an image and +# directly load it as a tensor + +dog1 = read_image(str(Path('assets') / 'dog1.jpg')) +dog2 = read_image(str(Path('assets') / 'dog2.jpg')) +show([dog1, dog2]) + +#################################### +# Transforming images on GPU +# -------------------------- +# Most transforms natively support tensors on top of PIL images (to visualize +# the effect of the transforms, you may refer to see +# :ref:`sphx_glr_auto_examples_plot_transforms.py`). +# Using tensor images, we can run the transforms on GPUs if cuda is available! + +import torch.nn as nn + +transforms = torch.nn.Sequential( + T.RandomCrop(224), + T.RandomHorizontalFlip(p=0.3), +) + +device = 'cuda' if torch.cuda.is_available() else 'cpu' +dog1 = dog1.to(device) +dog2 = dog2.to(device) + +transformed_dog1 = transforms(dog1) +transformed_dog2 = transforms(dog2) +show([transformed_dog1, transformed_dog2]) + +#################################### +# Scriptable transforms for easier deployment via torchscript +# ----------------------------------------------------------- +# We now show how to combine image transformations and a model forward pass, +# while using ``torch.jit.script`` to obtain a single scripted module. +# +# Let's define a ``Predictor`` module that transforms the input tensor and then +# applies an ImageNet model on it. + +from torchvision.models import resnet18 + + +class Predictor(nn.Module): + + def __init__(self): + super().__init__() + self.resnet18 = resnet18(pretrained=True, progress=False).eval() + self.transforms = nn.Sequential( + T.Resize([256, ]), # We use single int value inside a list due to torchscript type restrictions + T.CenterCrop(224), + T.ConvertImageDtype(torch.float), + T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + with torch.no_grad(): + x = self.transforms(x) + y_pred = self.resnet18(x) + return y_pred.argmax(dim=1) + + +#################################### +# Now, let's define scripted and non-scripted instances of ``Predictor`` and +# apply it on multiple tensor images of the same size + +predictor = Predictor().to(device) +scripted_predictor = torch.jit.script(predictor).to(device) + +batch = torch.stack([dog1, dog2]).to(device) + +res = predictor(batch) +res_scripted = scripted_predictor(batch) + +#################################### +# We can verify that the prediction of the scripted and non-scripted models are +# the same: + +import json + +with open(Path('assets') / 'imagenet_class_index.json', 'r') as labels_file: + labels = json.load(labels_file) + +for i, (pred, pred_scripted) in enumerate(zip(res, res_scripted)): + assert pred == pred_scripted + print(f"Prediction for Dog {i + 1}: {labels[str(pred.item())]}") + +#################################### +# Since the model is scripted, it can be easily dumped on disk an re-used + +import tempfile + +with tempfile.NamedTemporaryFile() as f: + scripted_predictor.save(f.name) + + dumped_scripted_predictor = torch.jit.load(f.name) + res_scripted_dumped = dumped_scripted_predictor(batch) +assert (res_scripted_dumped == res_scripted).all() diff --git a/gallery/plot_transforms.py b/gallery/plot_transforms.py index 863058fc862..032dd584c26 100644 --- a/gallery/plot_transforms.py +++ b/gallery/plot_transforms.py @@ -3,7 +3,8 @@ Illustration of transforms ========================== -This example illustrates the various transforms available in :mod:`torchvision.transforms`. +This example illustrates the various transforms available in :ref:`the +torchvision.transforms module `. """ from PIL import Image From d8ff3193758b2c3aec122deb427b58aef7c54b0a Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 10 May 2021 20:47:04 +0100 Subject: [PATCH 041/279] Fix wheel relocation issues on OSX (#3794) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * hello * Try with DYLD_FALLBACK_LIBRARY_PATH Co-authored-by: Edgar Andrés Margffoy Tuay --- packaging/build_wheel.sh | 2 +- test/test_ops.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/packaging/build_wheel.sh b/packaging/build_wheel.sh index 72acdf01fbe..05dc23a43ab 100755 --- a/packaging/build_wheel.sh +++ b/packaging/build_wheel.sh @@ -48,7 +48,7 @@ if [[ "$(uname)" == Darwin ]]; then bin_path=$(dirname $python_exec) env_path=$(dirname $bin_path) for whl in *.whl; do - DYLD_LIBRARY_PATH="$env_path/lib/:$DYLD_LIBRARY_PATH" delocate-wheel -v $whl + DYLD_FALLBACK_LIBRARY_PATH="$env_path/lib/:$DYLD_FALLBACK_LIBRARY_PATH" delocate-wheel -v $whl done else if [[ "$OSTYPE" == "msys" ]]; then diff --git a/test/test_ops.py b/test/test_ops.py index 8c63c9c29c6..dab69a739b9 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -117,6 +117,7 @@ def fn(*args, **kwargs): pass def get_script_fn(*args, **kwargs): + # Hello pass def expected_fn(*args, **kwargs): From 389109a8126a7c4affea86c37de53bb485c1c633 Mon Sep 17 00:00:00 2001 From: Nikita Shulga Date: Mon, 10 May 2021 17:32:54 -0700 Subject: [PATCH 042/279] Remove cu101 build (#3809) --- .circleci/config.yml | 592 ---------------------------------------- .circleci/regenerate.py | 8 +- 2 files changed, 4 insertions(+), 596 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index ca06419e29a..d874755824c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -975,12 +975,6 @@ workflows: name: binary_linux_wheel_py3.6_cpu python_version: '3.6' wheel_docker_image: pytorch/manylinux-cuda102 - - binary_linux_wheel: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - name: binary_linux_wheel_py3.6_cu101 - python_version: '3.6' - wheel_docker_image: pytorch/manylinux-cuda101 - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -1009,12 +1003,6 @@ workflows: name: binary_linux_wheel_py3.7_cpu python_version: '3.7' wheel_docker_image: pytorch/manylinux-cuda102 - - binary_linux_wheel: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - name: binary_linux_wheel_py3.7_cu101 - python_version: '3.7' - wheel_docker_image: pytorch/manylinux-cuda101 - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -1043,12 +1031,6 @@ workflows: name: binary_linux_wheel_py3.8_cpu python_version: '3.8' wheel_docker_image: pytorch/manylinux-cuda102 - - binary_linux_wheel: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - name: binary_linux_wheel_py3.8_cu101 - python_version: '3.8' - wheel_docker_image: pytorch/manylinux-cuda101 - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -1077,12 +1059,6 @@ workflows: name: binary_linux_wheel_py3.9_cpu python_version: '3.9' wheel_docker_image: pytorch/manylinux-cuda102 - - binary_linux_wheel: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - name: binary_linux_wheel_py3.9_cu101 - python_version: '3.9' - wheel_docker_image: pytorch/manylinux-cuda101 - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -1138,15 +1114,6 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.6_cpu python_version: '3.6' - - binary_win_wheel: - cu_version: cu101 - filters: - branches: - only: master - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: binary_win_wheel_py3.6_cu101 - python_version: '3.6' - binary_win_wheel: cu_version: cu102 filters: @@ -1174,15 +1141,6 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.7_cpu python_version: '3.7' - - binary_win_wheel: - cu_version: cu101 - filters: - branches: - only: master - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: binary_win_wheel_py3.7_cu101 - python_version: '3.7' - binary_win_wheel: cu_version: cu102 filters: @@ -1210,15 +1168,6 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.8_cpu python_version: '3.8' - - binary_win_wheel: - cu_version: cu101 - filters: - branches: - only: master - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: binary_win_wheel_py3.8_cu101 - python_version: '3.8' - binary_win_wheel: cu_version: cu102 filters: @@ -1241,15 +1190,6 @@ workflows: cu_version: cpu name: binary_win_wheel_py3.9_cpu python_version: '3.9' - - binary_win_wheel: - cu_version: cu101 - filters: - branches: - only: master - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: binary_win_wheel_py3.9_cu101 - python_version: '3.9' - binary_win_wheel: cu_version: cu102 filters: @@ -1269,12 +1209,6 @@ workflows: name: binary_linux_conda_py3.6_cpu python_version: '3.6' wheel_docker_image: pytorch/manylinux-cuda102 - - binary_linux_conda: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - name: binary_linux_conda_py3.6_cu101 - python_version: '3.6' - wheel_docker_image: pytorch/manylinux-cuda101 - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -1293,12 +1227,6 @@ workflows: name: binary_linux_conda_py3.7_cpu python_version: '3.7' wheel_docker_image: pytorch/manylinux-cuda102 - - binary_linux_conda: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - name: binary_linux_conda_py3.7_cu101 - python_version: '3.7' - wheel_docker_image: pytorch/manylinux-cuda101 - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -1317,12 +1245,6 @@ workflows: name: binary_linux_conda_py3.8_cpu python_version: '3.8' wheel_docker_image: pytorch/manylinux-cuda102 - - binary_linux_conda: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - name: binary_linux_conda_py3.8_cu101 - python_version: '3.8' - wheel_docker_image: pytorch/manylinux-cuda101 - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -1341,12 +1263,6 @@ workflows: name: binary_linux_conda_py3.9_cpu python_version: '3.9' wheel_docker_image: pytorch/manylinux-cuda102 - - binary_linux_conda: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - name: binary_linux_conda_py3.9_cu101 - python_version: '3.9' - wheel_docker_image: pytorch/manylinux-cuda101 - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -1392,15 +1308,6 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.6_cpu python_version: '3.6' - - binary_win_conda: - cu_version: cu101 - filters: - branches: - only: master - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: binary_win_conda_py3.6_cu101 - python_version: '3.6' - binary_win_conda: cu_version: cu102 filters: @@ -1428,15 +1335,6 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.7_cpu python_version: '3.7' - - binary_win_conda: - cu_version: cu101 - filters: - branches: - only: master - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: binary_win_conda_py3.7_cu101 - python_version: '3.7' - binary_win_conda: cu_version: cu102 filters: @@ -1464,15 +1362,6 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.8_cpu python_version: '3.8' - - binary_win_conda: - cu_version: cu101 - filters: - branches: - only: master - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: binary_win_conda_py3.8_cu101 - python_version: '3.8' - binary_win_conda: cu_version: cu102 filters: @@ -1495,15 +1384,6 @@ workflows: cu_version: cpu name: binary_win_conda_py3.9_cpu python_version: '3.9' - - binary_win_conda: - cu_version: cu101 - filters: - branches: - only: master - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: binary_win_conda_py3.9_cu101 - python_version: '3.9' - binary_win_conda: cu_version: cu102 filters: @@ -1767,37 +1647,6 @@ workflows: python_version: '3.6' requires: - nightly_binary_linux_wheel_py3.6_cpu_upload - - binary_linux_wheel: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.6_cu101 - python_version: '3.6' - wheel_docker_image: pytorch/manylinux-cuda101 - - binary_wheel_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.6_cu101_upload - requires: - - nightly_binary_linux_wheel_py3.6_cu101 - subfolder: cu101/ - - smoke_test_linux_pip: - filters: - branches: - only: - - nightly - name: nightly_binary_linux_wheel_py3.6_cu101_smoke_test_pip - python_version: '3.6' - requires: - - nightly_binary_linux_wheel_py3.6_cu101_upload - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -1951,37 +1800,6 @@ workflows: python_version: '3.7' requires: - nightly_binary_linux_wheel_py3.7_cpu_upload - - binary_linux_wheel: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.7_cu101 - python_version: '3.7' - wheel_docker_image: pytorch/manylinux-cuda101 - - binary_wheel_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.7_cu101_upload - requires: - - nightly_binary_linux_wheel_py3.7_cu101 - subfolder: cu101/ - - smoke_test_linux_pip: - filters: - branches: - only: - - nightly - name: nightly_binary_linux_wheel_py3.7_cu101_smoke_test_pip - python_version: '3.7' - requires: - - nightly_binary_linux_wheel_py3.7_cu101_upload - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -2135,37 +1953,6 @@ workflows: python_version: '3.8' requires: - nightly_binary_linux_wheel_py3.8_cpu_upload - - binary_linux_wheel: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.8_cu101 - python_version: '3.8' - wheel_docker_image: pytorch/manylinux-cuda101 - - binary_wheel_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.8_cu101_upload - requires: - - nightly_binary_linux_wheel_py3.8_cu101 - subfolder: cu101/ - - smoke_test_linux_pip: - filters: - branches: - only: - - nightly - name: nightly_binary_linux_wheel_py3.8_cu101_smoke_test_pip - python_version: '3.8' - requires: - - nightly_binary_linux_wheel_py3.8_cu101_upload - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -2319,37 +2106,6 @@ workflows: python_version: '3.9' requires: - nightly_binary_linux_wheel_py3.9_cpu_upload - - binary_linux_wheel: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.9_cu101 - python_version: '3.9' - wheel_docker_image: pytorch/manylinux-cuda101 - - binary_wheel_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.9_cu101_upload - requires: - - nightly_binary_linux_wheel_py3.9_cu101 - subfolder: cu101/ - - smoke_test_linux_pip: - filters: - branches: - only: - - nightly - name: nightly_binary_linux_wheel_py3.9_cu101_smoke_test_pip - python_version: '3.9' - requires: - - nightly_binary_linux_wheel_py3.9_cu101_upload - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -2589,35 +2345,6 @@ workflows: python_version: '3.6' requires: - nightly_binary_win_wheel_py3.6_cpu_upload - - binary_win_wheel: - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_wheel_py3.6_cu101 - python_version: '3.6' - - binary_wheel_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_wheel_py3.6_cu101_upload - requires: - - nightly_binary_win_wheel_py3.6_cu101 - subfolder: cu101/ - - smoke_test_win_pip: - filters: - branches: - only: - - nightly - name: nightly_binary_win_wheel_py3.6_cu101_smoke_test_pip - python_version: '3.6' - requires: - - nightly_binary_win_wheel_py3.6_cu101_upload - binary_win_wheel: cu_version: cu102 filters: @@ -2705,35 +2432,6 @@ workflows: python_version: '3.7' requires: - nightly_binary_win_wheel_py3.7_cpu_upload - - binary_win_wheel: - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_wheel_py3.7_cu101 - python_version: '3.7' - - binary_wheel_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_wheel_py3.7_cu101_upload - requires: - - nightly_binary_win_wheel_py3.7_cu101 - subfolder: cu101/ - - smoke_test_win_pip: - filters: - branches: - only: - - nightly - name: nightly_binary_win_wheel_py3.7_cu101_smoke_test_pip - python_version: '3.7' - requires: - - nightly_binary_win_wheel_py3.7_cu101_upload - binary_win_wheel: cu_version: cu102 filters: @@ -2821,35 +2519,6 @@ workflows: python_version: '3.8' requires: - nightly_binary_win_wheel_py3.8_cpu_upload - - binary_win_wheel: - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_wheel_py3.8_cu101 - python_version: '3.8' - - binary_wheel_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_wheel_py3.8_cu101_upload - requires: - - nightly_binary_win_wheel_py3.8_cu101 - subfolder: cu101/ - - smoke_test_win_pip: - filters: - branches: - only: - - nightly - name: nightly_binary_win_wheel_py3.8_cu101_smoke_test_pip - python_version: '3.8' - requires: - - nightly_binary_win_wheel_py3.8_cu101_upload - binary_win_wheel: cu_version: cu102 filters: @@ -2937,35 +2606,6 @@ workflows: python_version: '3.9' requires: - nightly_binary_win_wheel_py3.9_cpu_upload - - binary_win_wheel: - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_wheel_py3.9_cu101 - python_version: '3.9' - - binary_wheel_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_wheel_py3.9_cu101_upload - requires: - - nightly_binary_win_wheel_py3.9_cu101 - subfolder: cu101/ - - smoke_test_win_pip: - filters: - branches: - only: - - nightly - name: nightly_binary_win_wheel_py3.9_cu101_smoke_test_pip - python_version: '3.9' - requires: - - nightly_binary_win_wheel_py3.9_cu101_upload - binary_win_wheel: cu_version: cu102 filters: @@ -3054,36 +2694,6 @@ workflows: python_version: '3.6' requires: - nightly_binary_linux_conda_py3.6_cpu_upload - - binary_linux_conda: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_conda_py3.6_cu101 - python_version: '3.6' - wheel_docker_image: pytorch/manylinux-cuda101 - - binary_conda_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_conda_py3.6_cu101_upload - requires: - - nightly_binary_linux_conda_py3.6_cu101 - - smoke_test_linux_conda: - filters: - branches: - only: - - nightly - name: nightly_binary_linux_conda_py3.6_cu101_smoke_test_conda - python_version: '3.6' - requires: - - nightly_binary_linux_conda_py3.6_cu101_upload - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -3174,36 +2784,6 @@ workflows: python_version: '3.7' requires: - nightly_binary_linux_conda_py3.7_cpu_upload - - binary_linux_conda: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_conda_py3.7_cu101 - python_version: '3.7' - wheel_docker_image: pytorch/manylinux-cuda101 - - binary_conda_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_conda_py3.7_cu101_upload - requires: - - nightly_binary_linux_conda_py3.7_cu101 - - smoke_test_linux_conda: - filters: - branches: - only: - - nightly - name: nightly_binary_linux_conda_py3.7_cu101_smoke_test_conda - python_version: '3.7' - requires: - - nightly_binary_linux_conda_py3.7_cu101_upload - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -3294,36 +2874,6 @@ workflows: python_version: '3.8' requires: - nightly_binary_linux_conda_py3.8_cpu_upload - - binary_linux_conda: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_conda_py3.8_cu101 - python_version: '3.8' - wheel_docker_image: pytorch/manylinux-cuda101 - - binary_conda_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_conda_py3.8_cu101_upload - requires: - - nightly_binary_linux_conda_py3.8_cu101 - - smoke_test_linux_conda: - filters: - branches: - only: - - nightly - name: nightly_binary_linux_conda_py3.8_cu101_smoke_test_conda - python_version: '3.8' - requires: - - nightly_binary_linux_conda_py3.8_cu101_upload - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -3414,36 +2964,6 @@ workflows: python_version: '3.9' requires: - nightly_binary_linux_conda_py3.9_cpu_upload - - binary_linux_conda: - conda_docker_image: pytorch/conda-builder:cuda101 - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_conda_py3.9_cu101 - python_version: '3.9' - wheel_docker_image: pytorch/manylinux-cuda101 - - binary_conda_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_conda_py3.9_cu101_upload - requires: - - nightly_binary_linux_conda_py3.9_cu101 - - smoke_test_linux_conda: - filters: - branches: - only: - - nightly - name: nightly_binary_linux_conda_py3.9_cu101_smoke_test_conda - python_version: '3.9' - requires: - - nightly_binary_linux_conda_py3.9_cu101_upload - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cuda102 cu_version: cu102 @@ -3616,34 +3136,6 @@ workflows: python_version: '3.6' requires: - nightly_binary_win_conda_py3.6_cpu_upload - - binary_win_conda: - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_conda_py3.6_cu101 - python_version: '3.6' - - binary_conda_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_conda_py3.6_cu101_upload - requires: - - nightly_binary_win_conda_py3.6_cu101 - - smoke_test_win_conda: - filters: - branches: - only: - - nightly - name: nightly_binary_win_conda_py3.6_cu101_smoke_test_conda - python_version: '3.6' - requires: - - nightly_binary_win_conda_py3.6_cu101_upload - binary_win_conda: cu_version: cu102 filters: @@ -3728,34 +3220,6 @@ workflows: python_version: '3.7' requires: - nightly_binary_win_conda_py3.7_cpu_upload - - binary_win_conda: - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_conda_py3.7_cu101 - python_version: '3.7' - - binary_conda_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_conda_py3.7_cu101_upload - requires: - - nightly_binary_win_conda_py3.7_cu101 - - smoke_test_win_conda: - filters: - branches: - only: - - nightly - name: nightly_binary_win_conda_py3.7_cu101_smoke_test_conda - python_version: '3.7' - requires: - - nightly_binary_win_conda_py3.7_cu101_upload - binary_win_conda: cu_version: cu102 filters: @@ -3840,34 +3304,6 @@ workflows: python_version: '3.8' requires: - nightly_binary_win_conda_py3.8_cpu_upload - - binary_win_conda: - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_conda_py3.8_cu101 - python_version: '3.8' - - binary_conda_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_conda_py3.8_cu101_upload - requires: - - nightly_binary_win_conda_py3.8_cu101 - - smoke_test_win_conda: - filters: - branches: - only: - - nightly - name: nightly_binary_win_conda_py3.8_cu101_smoke_test_conda - python_version: '3.8' - requires: - - nightly_binary_win_conda_py3.8_cu101_upload - binary_win_conda: cu_version: cu102 filters: @@ -3952,34 +3388,6 @@ workflows: python_version: '3.9' requires: - nightly_binary_win_conda_py3.9_cpu_upload - - binary_win_conda: - cu_version: cu101 - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_conda_py3.9_cu101 - python_version: '3.9' - - binary_conda_upload: - context: org-member - filters: - branches: - only: nightly - tags: - only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_win_conda_py3.9_cu101_upload - requires: - - nightly_binary_win_conda_py3.9_cu101 - - smoke_test_win_conda: - filters: - branches: - only: - - nightly - name: nightly_binary_win_conda_py3.9_cu101_smoke_test_conda - python_version: '3.9' - requires: - - nightly_binary_win_conda_py3.9_cu101_upload - binary_win_conda: cu_version: cu102 filters: diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py index e550a9d626b..b512fd55fae 100755 --- a/.circleci/regenerate.py +++ b/.circleci/regenerate.py @@ -30,8 +30,8 @@ def build_workflows(prefix='', filter_branch=None, upload=False, indentation=6, for btype in ["wheel", "conda"]: for os_type in ["linux", "macos", "win"]: python_versions = PYTHON_VERSIONS - cu_versions_dict = {"linux": ["cpu", "cu101", "cu102", "cu111", "rocm4.0.1", "rocm4.1"], - "win": ["cpu", "cu101", "cu102", "cu111"], + cu_versions_dict = {"linux": ["cpu", "cu102", "cu111", "rocm4.0.1", "rocm4.1"], + "win": ["cpu", "cu102", "cu111"], "macos": ["cpu"]} cu_versions = cu_versions_dict[os_type] for python_version in python_versions: @@ -39,7 +39,7 @@ def build_workflows(prefix='', filter_branch=None, upload=False, indentation=6, # ROCm conda packages not yet supported if cu_version.startswith('rocm') and btype == "conda": continue - for unicode in ([False, True] if btype == "wheel" and python_version == "2.7" else [False]): + for unicode in [False]: fb = filter_branch if windows_latest_only and os_type == "win" and filter_branch is None and \ (python_version != python_versions[-1] or @@ -211,7 +211,7 @@ def generate_smoketest_workflow(pydistro, base_workflow_name, filter_branch, pyt if filter_branch: d["filters"] = gen_filter_branch_tree(filter_branch) - return {"smoke_test_{os_type}_{pydistro}".format(os_type=os_type, pydistro=pydistro): d} + return {f"smoke_test_{os_type}_{pydistro}": d} def indent(indentation, data_list): From 9dbff560f463641d27f8f9d65a0ec58fc3dbcd49 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 11 May 2021 08:24:35 +0100 Subject: [PATCH 043/279] remove comment (#3807) --- test/test_ops.py | 1 - 1 file changed, 1 deletion(-) diff --git a/test/test_ops.py b/test/test_ops.py index dab69a739b9..8c63c9c29c6 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -117,7 +117,6 @@ def fn(*args, **kwargs): pass def get_script_fn(*args, **kwargs): - # Hello pass def expected_fn(*args, **kwargs): From 5dd7dfe389d292296695fb3c341fdfcedf34afa7 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 11 May 2021 08:25:53 +0100 Subject: [PATCH 044/279] Added VisionTestApp for testing vision ops in iOS (#3629) (#3806) Co-authored-by: Yuchen Huang --- .gitignore | 3 + .../VisionTestApp.xcodeproj/project.pbxproj | 5933 +++++++++++++++++ .../contents.xcworkspacedata | 7 + .../xcshareddata/IDEWorkspaceChecks.plist | 8 + ios/VisionTestApp/VisionTestApp/AppDelegate.h | 7 + ios/VisionTestApp/VisionTestApp/AppDelegate.m | 44 + .../AccentColor.colorset/Contents.json | 11 + .../AppIcon.appiconset/Contents.json | 98 + .../Assets.xcassets/Contents.json | 6 + .../Base.lproj/LaunchScreen.storyboard | 33 + .../VisionTestApp/Base.lproj/Main.storyboard | 79 + ios/VisionTestApp/VisionTestApp/Info.plist | 45 + ios/VisionTestApp/VisionTestApp/ModelRunner.h | 13 + .../VisionTestApp/ModelRunner.mm | 73 + .../VisionTestApp/ViewController.h | 8 + .../VisionTestApp/ViewController.mm | 44 + ios/VisionTestApp/VisionTestApp/main.m | 18 + ios/VisionTestApp/clean.sh | 8 + ios/VisionTestApp/make_assets.py | 17 + ios/VisionTestApp/setup.sh | 33 + 20 files changed, 6488 insertions(+) create mode 100644 ios/VisionTestApp/VisionTestApp.xcodeproj/project.pbxproj create mode 100644 ios/VisionTestApp/VisionTestApp.xcodeproj/project.xcworkspace/contents.xcworkspacedata create mode 100644 ios/VisionTestApp/VisionTestApp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist create mode 100644 ios/VisionTestApp/VisionTestApp/AppDelegate.h create mode 100644 ios/VisionTestApp/VisionTestApp/AppDelegate.m create mode 100644 ios/VisionTestApp/VisionTestApp/Assets.xcassets/AccentColor.colorset/Contents.json create mode 100644 ios/VisionTestApp/VisionTestApp/Assets.xcassets/AppIcon.appiconset/Contents.json create mode 100644 ios/VisionTestApp/VisionTestApp/Assets.xcassets/Contents.json create mode 100644 ios/VisionTestApp/VisionTestApp/Base.lproj/LaunchScreen.storyboard create mode 100644 ios/VisionTestApp/VisionTestApp/Base.lproj/Main.storyboard create mode 100644 ios/VisionTestApp/VisionTestApp/Info.plist create mode 100644 ios/VisionTestApp/VisionTestApp/ModelRunner.h create mode 100644 ios/VisionTestApp/VisionTestApp/ModelRunner.mm create mode 100644 ios/VisionTestApp/VisionTestApp/ViewController.h create mode 100644 ios/VisionTestApp/VisionTestApp/ViewController.mm create mode 100644 ios/VisionTestApp/VisionTestApp/main.m create mode 100755 ios/VisionTestApp/clean.sh create mode 100644 ios/VisionTestApp/make_assets.py create mode 100755 ios/VisionTestApp/setup.sh diff --git a/.gitignore b/.gitignore index 915fe5b0f78..ed35abaa478 100644 --- a/.gitignore +++ b/.gitignore @@ -28,3 +28,6 @@ gen.yml *.orig *-checkpoint.ipynb *.venv + +## Xcode User settings +xcuserdata/ diff --git a/ios/VisionTestApp/VisionTestApp.xcodeproj/project.pbxproj b/ios/VisionTestApp/VisionTestApp.xcodeproj/project.pbxproj new file mode 100644 index 00000000000..5e71c77e6f8 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp.xcodeproj/project.pbxproj @@ -0,0 +1,5933 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 50; + objects = { + +/* Begin PBXBuildFile section */ + 0C12EF3D2616383D00B66C86 /* avx.py in Resources */ = {isa = PBXBuildFile; fileRef = 0C12EEF32616383C00B66C86 /* avx.py */; }; + 0C12EF3E2616383D00B66C86 /* __init__.py in Resources */ = {isa = PBXBuildFile; fileRef = 0C12EEF42616383C00B66C86 /* __init__.py */; }; + 0C12EF3F2616383D00B66C86 /* avx2.py in Resources */ = {isa = PBXBuildFile; fileRef = 0C12EEF62616383C00B66C86 /* avx2.py */; }; + 0C12EF402616383D00B66C86 /* THTensor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C12EF192616383C00B66C86 /* THTensor.cpp */; }; + 0C12EF412616383D00B66C86 /* THTensorMath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C12EF1A2616383C00B66C86 /* THTensorMath.cpp */; }; + 0C12EF422616383D00B66C86 /* THStorageCopy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C12EF1C2616383C00B66C86 /* THStorageCopy.cpp */; }; + 0C12EF432616383D00B66C86 /* THLapack.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C12EF212616383C00B66C86 /* THLapack.cpp */; }; + 0C12EF442616383D00B66C86 /* THStorage.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C12EF242616383C00B66C86 /* THStorage.cpp */; }; + 0C12EF452616383D00B66C86 /* THBlas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C12EF262616383C00B66C86 /* THBlas.cpp */; }; + 0C12EF462616383D00B66C86 /* THTensorLapack.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0C12EF272616383C00B66C86 /* THTensorLapack.cpp */; }; + 0C12EF472616383D00B66C86 /* libtorch_cpu.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF332616383C00B66C86 /* libtorch_cpu.a */; }; + 0C12EF482616383D00B66C86 /* libtorch.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF342616383C00B66C86 /* libtorch.a */; }; + 0C12EF492616383D00B66C86 /* libcpuinfo.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF352616383C00B66C86 /* libcpuinfo.a */; }; + 0C12EF4A2616383D00B66C86 /* libXNNPACK.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF362616383C00B66C86 /* libXNNPACK.a */; }; + 0C12EF4C2616383D00B66C86 /* libpthreadpool.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF382616383C00B66C86 /* libpthreadpool.a */; }; + 0C12EF4D2616383D00B66C86 /* libc10.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF392616383C00B66C86 /* libc10.a */; }; + 0C12EF4E2616383D00B66C86 /* libeigen_blas.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF3A2616383C00B66C86 /* libeigen_blas.a */; }; + 0C12EF4F2616383D00B66C86 /* libclog.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF3B2616383C00B66C86 /* libclog.a */; }; + 0C12EF502616383D00B66C86 /* libpytorch_qnnpack.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF3C2616383C00B66C86 /* libpytorch_qnnpack.a */; }; + 0C12EF7626163B7600B66C86 /* frcnn_mnetv3.pt in Resources */ = {isa = PBXBuildFile; fileRef = 0C12EF7526163B7600B66C86 /* frcnn_mnetv3.pt */; }; + 0C12EF7A26163C7C00B66C86 /* libtorchvision_ops.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C12EF372616383C00B66C86 /* libtorchvision_ops.a */; }; + 0CEB0AC026151A8800F1F7D5 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CEB0ABF26151A8800F1F7D5 /* AppDelegate.m */; }; + 0CEB0AC626151A8800F1F7D5 /* ViewController.mm in Sources */ = {isa = PBXBuildFile; fileRef = 0CEB0AC526151A8800F1F7D5 /* ViewController.mm */; }; + 0CEB0AC926151A8800F1F7D5 /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 0CEB0AC726151A8800F1F7D5 /* Main.storyboard */; }; + 0CEB0ACB26151A8900F1F7D5 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 0CEB0ACA26151A8900F1F7D5 /* Assets.xcassets */; }; + 0CEB0ACE26151A8900F1F7D5 /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 0CEB0ACC26151A8900F1F7D5 /* LaunchScreen.storyboard */; }; + 0CEB0AD126151A8900F1F7D5 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 0CEB0AD026151A8900F1F7D5 /* main.m */; }; + 0CEB0B3A26152ED900F1F7D5 /* ModelRunner.mm in Sources */ = {isa = PBXBuildFile; fileRef = 0CEB0B3926152ED900F1F7D5 /* ModelRunner.mm */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 0C12E78A2616383A00B66C86 /* attr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = attr.h; sourceTree = ""; }; + 0C12E78B2616383A00B66C86 /* embed.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = embed.h; sourceTree = ""; }; + 0C12E78C2616383A00B66C86 /* numpy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = numpy.h; sourceTree = ""; }; + 0C12E78D2616383A00B66C86 /* pybind11.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pybind11.h; sourceTree = ""; }; + 0C12E78E2616383A00B66C86 /* operators.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operators.h; sourceTree = ""; }; + 0C12E78F2616383A00B66C86 /* iostream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = iostream.h; sourceTree = ""; }; + 0C12E7902616383A00B66C86 /* chrono.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = chrono.h; sourceTree = ""; }; + 0C12E7912616383A00B66C86 /* stl_bind.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stl_bind.h; sourceTree = ""; }; + 0C12E7922616383A00B66C86 /* buffer_info.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = buffer_info.h; sourceTree = ""; }; + 0C12E7932616383A00B66C86 /* options.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = options.h; sourceTree = ""; }; + 0C12E7942616383A00B66C86 /* functional.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = functional.h; sourceTree = ""; }; + 0C12E7952616383A00B66C86 /* stl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stl.h; sourceTree = ""; }; + 0C12E7972616383A00B66C86 /* typeid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = typeid.h; sourceTree = ""; }; + 0C12E7982616383A00B66C86 /* descr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = descr.h; sourceTree = ""; }; + 0C12E7992616383A00B66C86 /* internals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = internals.h; sourceTree = ""; }; + 0C12E79A2616383A00B66C86 /* common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common.h; sourceTree = ""; }; + 0C12E79B2616383A00B66C86 /* class.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = class.h; sourceTree = ""; }; + 0C12E79C2616383A00B66C86 /* init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = ""; }; + 0C12E79D2616383A00B66C86 /* common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common.h; sourceTree = ""; }; + 0C12E79E2616383A00B66C86 /* eval.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = eval.h; sourceTree = ""; }; + 0C12E79F2616383A00B66C86 /* cast.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cast.h; sourceTree = ""; }; + 0C12E7A02616383A00B66C86 /* eigen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = eigen.h; sourceTree = ""; }; + 0C12E7A12616383A00B66C86 /* pytypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pytypes.h; sourceTree = ""; }; + 0C12E7A22616383A00B66C86 /* complex.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = complex.h; sourceTree = ""; }; + 0C12E7A52616383A00B66C86 /* optical_flow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = optical_flow.h; sourceTree = ""; }; + 0C12E7A62616383A00B66C86 /* video_decoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = video_decoder.h; sourceTree = ""; }; + 0C12E7A72616383A00B66C86 /* video_input_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = video_input_op.h; sourceTree = ""; }; + 0C12E7A82616383A00B66C86 /* video_io.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = video_io.h; sourceTree = ""; }; + 0C12E7AB2616383A00B66C86 /* conv_transpose_unpool_base_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_transpose_unpool_base_op.h; sourceTree = ""; }; + 0C12E7AD2616383A00B66C86 /* operator_fallback_ideep.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator_fallback_ideep.h; sourceTree = ""; }; + 0C12E7AE2616383A00B66C86 /* conv_pool_base_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_pool_base_op.h; sourceTree = ""; }; + 0C12E7B02616383A00B66C86 /* ideep_context.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ideep_context.h; sourceTree = ""; }; + 0C12E7B12616383A00B66C86 /* ideep_operator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ideep_operator.h; sourceTree = ""; }; + 0C12E7B22616383A00B66C86 /* ideep_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ideep_utils.h; sourceTree = ""; }; + 0C12E7B42616383A00B66C86 /* net_async_task_graph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_async_task_graph.h; sourceTree = ""; }; + 0C12E7B52616383A00B66C86 /* net_simple_refcount.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_simple_refcount.h; sourceTree = ""; }; + 0C12E7B62616383A00B66C86 /* tensor_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_impl.h; sourceTree = ""; }; + 0C12E7B72616383A00B66C86 /* plan_executor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = plan_executor.h; sourceTree = ""; }; + 0C12E7B82616383A00B66C86 /* qtensor_serialization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = qtensor_serialization.h; sourceTree = ""; }; + 0C12E7B92616383A00B66C86 /* context_gpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = context_gpu.h; sourceTree = ""; }; + 0C12E7BA2616383A00B66C86 /* observer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = observer.h; sourceTree = ""; }; + 0C12E7BB2616383A00B66C86 /* blob_serializer_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = blob_serializer_base.h; sourceTree = ""; }; + 0C12E7BC2616383A00B66C86 /* memonger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = memonger.h; sourceTree = ""; }; + 0C12E7BD2616383A00B66C86 /* tensor_int8.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_int8.h; sourceTree = ""; }; + 0C12E7BE2616383A00B66C86 /* static_tracepoint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = static_tracepoint.h; sourceTree = ""; }; + 0C12E7BF2616383A00B66C86 /* net.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net.h; sourceTree = ""; }; + 0C12E7C02616383A00B66C86 /* numa.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = numa.h; sourceTree = ""; }; + 0C12E7C12616383A00B66C86 /* scope_guard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = scope_guard.h; sourceTree = ""; }; + 0C12E7C22616383A00B66C86 /* test_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = test_utils.h; sourceTree = ""; }; + 0C12E7C32616383A00B66C86 /* event.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = event.h; sourceTree = ""; }; + 0C12E7C42616383A00B66C86 /* types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = types.h; sourceTree = ""; }; + 0C12E7C52616383A00B66C86 /* context_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = context_base.h; sourceTree = ""; }; + 0C12E7C62616383A00B66C86 /* operator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator.h; sourceTree = ""; }; + 0C12E7C72616383A00B66C86 /* db.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = db.h; sourceTree = ""; }; + 0C12E7C82616383A00B66C86 /* blob.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = blob.h; sourceTree = ""; }; + 0C12E7C92616383A00B66C86 /* static_tracepoint_elfx86.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = static_tracepoint_elfx86.h; sourceTree = ""; }; + 0C12E7CA2616383A00B66C86 /* net_async_tracing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_async_tracing.h; sourceTree = ""; }; + 0C12E7CB2616383A00B66C86 /* flags.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = flags.h; sourceTree = ""; }; + 0C12E7CC2616383A00B66C86 /* net_async_task_future.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_async_task_future.h; sourceTree = ""; }; + 0C12E7CD2616383A00B66C86 /* operator_schema.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator_schema.h; sourceTree = ""; }; + 0C12E7CE2616383A00B66C86 /* context.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = context.h; sourceTree = ""; }; + 0C12E7CF2616383A00B66C86 /* net_async_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_async_base.h; sourceTree = ""; }; + 0C12E7D02616383A00B66C86 /* prof_dag_counters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prof_dag_counters.h; sourceTree = ""; }; + 0C12E7D12616383A00B66C86 /* logging.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = logging.h; sourceTree = ""; }; + 0C12E7D22616383A00B66C86 /* net_async_scheduling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_async_scheduling.h; sourceTree = ""; }; + 0C12E7D32616383A00B66C86 /* graph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graph.h; sourceTree = ""; }; + 0C12E7D42616383A00B66C86 /* common_cudnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common_cudnn.h; sourceTree = ""; }; + 0C12E7D52616383A00B66C86 /* net_async_task.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_async_task.h; sourceTree = ""; }; + 0C12E7D62616383A00B66C86 /* export_caffe2_op_to_c10.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = export_caffe2_op_to_c10.h; sourceTree = ""; }; + 0C12E7D72616383A00B66C86 /* net_simple.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_simple.h; sourceTree = ""; }; + 0C12E7D82616383A00B66C86 /* workspace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = workspace.h; sourceTree = ""; }; + 0C12E7D92616383A00B66C86 /* timer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = timer.h; sourceTree = ""; }; + 0C12E7DA2616383A00B66C86 /* event_cpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = event_cpu.h; sourceTree = ""; }; + 0C12E7DB2616383A00B66C86 /* common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common.h; sourceTree = ""; }; + 0C12E7DC2616383A00B66C86 /* blob_stats.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = blob_stats.h; sourceTree = ""; }; + 0C12E7DD2616383A00B66C86 /* allocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = allocator.h; sourceTree = ""; }; + 0C12E7DE2616383A00B66C86 /* macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = macros.h; sourceTree = ""; }; + 0C12E7E02616383A00B66C86 /* miopen_wrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = miopen_wrapper.h; sourceTree = ""; }; + 0C12E7E12616383A00B66C86 /* common_miopen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common_miopen.h; sourceTree = ""; }; + 0C12E7E22616383A00B66C86 /* storage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = storage.h; sourceTree = ""; }; + 0C12E7E32616383A00B66C86 /* transform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transform.h; sourceTree = ""; }; + 0C12E7E42616383A00B66C86 /* common_omp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common_omp.h; sourceTree = ""; }; + 0C12E7E52616383A00B66C86 /* export_c10_op_to_caffe2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = export_c10_op_to_caffe2.h; sourceTree = ""; }; + 0C12E7EB2616383A00B66C86 /* OpClasses.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OpClasses.h; sourceTree = ""; }; + 0C12E7EC2616383A00B66C86 /* OpEnum.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OpEnum.h; sourceTree = ""; }; + 0C12E7ED2616383A00B66C86 /* OpNames.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OpNames.h; sourceTree = ""; }; + 0C12E7EF2616383A00B66C86 /* Compiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Compiler.h; sourceTree = ""; }; + 0C12E7F02616383A00B66C86 /* NeuralNet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NeuralNet.h; sourceTree = ""; }; + 0C12E7F12616383A00B66C86 /* ControlFlow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ControlFlow.h; sourceTree = ""; }; + 0C12E7F32616383A00B66C86 /* SubgraphMatcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SubgraphMatcher.h; sourceTree = ""; }; + 0C12E7F42616383A00B66C86 /* Match.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Match.h; sourceTree = ""; }; + 0C12E7F62616383A00B66C86 /* Algorithms.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Algorithms.h; sourceTree = ""; }; + 0C12E7F72616383A00B66C86 /* TopoSort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TopoSort.h; sourceTree = ""; }; + 0C12E7F82616383A00B66C86 /* Graph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Graph.h; sourceTree = ""; }; + 0C12E7F92616383A00B66C86 /* TarjansImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TarjansImpl.h; sourceTree = ""; }; + 0C12E7FA2616383A00B66C86 /* BinaryMatchImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BinaryMatchImpl.h; sourceTree = ""; }; + 0C12E7FC2616383A00B66C86 /* Dot.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Dot.h; sourceTree = ""; }; + 0C12E7FE2616383A00B66C86 /* Casting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Casting.h; sourceTree = ""; }; + 0C12E7FF2616383A00B66C86 /* Common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Common.h; sourceTree = ""; }; + 0C12E8012616383A00B66C86 /* test_util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = test_util.h; sourceTree = ""; }; + 0C12E8022616383A00B66C86 /* module.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = module.h; sourceTree = ""; }; + 0C12E8032616383A00B66C86 /* init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = ""; }; + 0C12E8042616383A00B66C86 /* net_dag_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_dag_utils.h; sourceTree = ""; }; + 0C12E8052616383A00B66C86 /* stats.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stats.h; sourceTree = ""; }; + 0C12E8062616383A00B66C86 /* tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor.h; sourceTree = ""; }; + 0C12E8072616383A00B66C86 /* common_gpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common_gpu.h; sourceTree = ""; }; + 0C12E8082616383A00B66C86 /* qtensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = qtensor.h; sourceTree = ""; }; + 0C12E8092616383A00B66C86 /* net_parallel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_parallel.h; sourceTree = ""; }; + 0C12E80A2616383A00B66C86 /* operator_gradient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator_gradient.h; sourceTree = ""; }; + 0C12E80B2616383A00B66C86 /* cudnn_wrappers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cudnn_wrappers.h; sourceTree = ""; }; + 0C12E80C2616383A00B66C86 /* distributions_stubs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = distributions_stubs.h; sourceTree = ""; }; + 0C12E80D2616383A00B66C86 /* blob_serialization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = blob_serialization.h; sourceTree = ""; }; + 0C12E80F2616383A00B66C86 /* mpi_common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mpi_common.h; sourceTree = ""; }; + 0C12E8102616383A00B66C86 /* mpi_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mpi_ops.h; sourceTree = ""; }; + 0C12E8122616383A00B66C86 /* caffe2_pb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = caffe2_pb.h; sourceTree = ""; }; + 0C12E8132616383A00B66C86 /* torch_pb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = torch_pb.h; sourceTree = ""; }; + 0C12E8172616383A00B66C86 /* top_k.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = top_k.h; sourceTree = ""; }; + 0C12E8182616383A00B66C86 /* channel_stats_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = channel_stats_op.h; sourceTree = ""; }; + 0C12E8192616383A00B66C86 /* gru_unit_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gru_unit_op.h; sourceTree = ""; }; + 0C12E81A2616383A00B66C86 /* half_float_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = half_float_ops.h; sourceTree = ""; }; + 0C12E81B2616383A00B66C86 /* sqr_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sqr_op.h; sourceTree = ""; }; + 0C12E81C2616383A00B66C86 /* mean_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mean_op.h; sourceTree = ""; }; + 0C12E81D2616383A00B66C86 /* thresholded_relu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = thresholded_relu_op.h; sourceTree = ""; }; + 0C12E81E2616383A00B66C86 /* ctc_greedy_decoder_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ctc_greedy_decoder_op.h; sourceTree = ""; }; + 0C12E81F2616383A00B66C86 /* conv_op_cache_cudnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_op_cache_cudnn.h; sourceTree = ""; }; + 0C12E8202616383A00B66C86 /* utility_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utility_ops.h; sourceTree = ""; }; + 0C12E8212616383A00B66C86 /* selu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = selu_op.h; sourceTree = ""; }; + 0C12E8222616383A00B66C86 /* map_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = map_ops.h; sourceTree = ""; }; + 0C12E8232616383A00B66C86 /* roi_align_rotated_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = roi_align_rotated_op.h; sourceTree = ""; }; + 0C12E8242616383A00B66C86 /* fused_rowwise_random_quantization_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_rowwise_random_quantization_ops.h; sourceTree = ""; }; + 0C12E8252616383A00B66C86 /* stop_gradient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stop_gradient.h; sourceTree = ""; }; + 0C12E8262616383A00B66C86 /* batch_gather_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_gather_ops.h; sourceTree = ""; }; + 0C12E8272616383A00B66C86 /* asin_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = asin_op.h; sourceTree = ""; }; + 0C12E8282616383A00B66C86 /* cosh_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cosh_op.h; sourceTree = ""; }; + 0C12E8292616383A00B66C86 /* atan_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = atan_op.h; sourceTree = ""; }; + 0C12E82A2616383A00B66C86 /* reverse_packed_segs_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reverse_packed_segs_op.h; sourceTree = ""; }; + 0C12E82B2616383A00B66C86 /* given_tensor_byte_string_to_uint8_fill_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = given_tensor_byte_string_to_uint8_fill_op.h; sourceTree = ""; }; + 0C12E82C2616383A00B66C86 /* ensure_clipped_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ensure_clipped_op.h; sourceTree = ""; }; + 0C12E82D2616383A00B66C86 /* conv_transpose_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_transpose_op.h; sourceTree = ""; }; + 0C12E82E2616383A00B66C86 /* generate_proposals_op_util_nms.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = generate_proposals_op_util_nms.h; sourceTree = ""; }; + 0C12E82F2616383A00B66C86 /* enforce_finite_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = enforce_finite_op.h; sourceTree = ""; }; + 0C12E8302616383A00B66C86 /* conv_transpose_unpool_op_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_transpose_unpool_op_base.h; sourceTree = ""; }; + 0C12E8312616383A00B66C86 /* gather_fused_8bit_rowwise_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gather_fused_8bit_rowwise_op.h; sourceTree = ""; }; + 0C12E8322616383A00B66C86 /* batch_matmul_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_matmul_op.h; sourceTree = ""; }; + 0C12E8332616383A00B66C86 /* batch_bucketize_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_bucketize_op.h; sourceTree = ""; }; + 0C12E8342616383A00B66C86 /* softsign_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = softsign_op.h; sourceTree = ""; }; + 0C12E8352616383A00B66C86 /* elementwise_logical_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_logical_ops.h; sourceTree = ""; }; + 0C12E8362616383A00B66C86 /* percentile_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = percentile_op.h; sourceTree = ""; }; + 0C12E8372616383A00B66C86 /* length_split_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = length_split_op.h; sourceTree = ""; }; + 0C12E8382616383A00B66C86 /* locally_connected_op_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = locally_connected_op_impl.h; sourceTree = ""; }; + 0C12E8392616383A00B66C86 /* rmac_regions_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rmac_regions_op.h; sourceTree = ""; }; + 0C12E83A2616383A00B66C86 /* hard_sigmoid_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hard_sigmoid_op.h; sourceTree = ""; }; + 0C12E83B2616383A00B66C86 /* ensure_cpu_output_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ensure_cpu_output_op.h; sourceTree = ""; }; + 0C12E83C2616383A00B66C86 /* batch_box_cox_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_box_cox_op.h; sourceTree = ""; }; + 0C12E83D2616383A00B66C86 /* ctc_beam_search_decoder_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ctc_beam_search_decoder_op.h; sourceTree = ""; }; + 0C12E83E2616383A00B66C86 /* flexible_top_k.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = flexible_top_k.h; sourceTree = ""; }; + 0C12E83F2616383A00B66C86 /* fully_connected_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fully_connected_op.h; sourceTree = ""; }; + 0C12E8402616383A00B66C86 /* key_split_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = key_split_ops.h; sourceTree = ""; }; + 0C12E8412616383A00B66C86 /* reciprocal_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reciprocal_op.h; sourceTree = ""; }; + 0C12E8422616383A00B66C86 /* roi_align_gradient_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = roi_align_gradient_op.h; sourceTree = ""; }; + 0C12E8432616383A00B66C86 /* group_norm_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = group_norm_op.h; sourceTree = ""; }; + 0C12E8442616383A00B66C86 /* load_save_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = load_save_op.h; sourceTree = ""; }; + 0C12E8452616383A00B66C86 /* cos_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cos_op.h; sourceTree = ""; }; + 0C12E8462616383A00B66C86 /* expand_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = expand_op.h; sourceTree = ""; }; + 0C12E8472616383A00B66C86 /* elementwise_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_ops.h; sourceTree = ""; }; + 0C12E8482616383A00B66C86 /* im2col_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = im2col_op.h; sourceTree = ""; }; + 0C12E8492616383A00B66C86 /* space_batch_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = space_batch_op.h; sourceTree = ""; }; + 0C12E84A2616383A00B66C86 /* relu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = relu_op.h; sourceTree = ""; }; + 0C12E84B2616383A00B66C86 /* while_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = while_op.h; sourceTree = ""; }; + 0C12E84C2616383A00B66C86 /* remove_data_blocks_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remove_data_blocks_op.h; sourceTree = ""; }; + 0C12E84D2616383A00B66C86 /* elementwise_mul_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_mul_op.h; sourceTree = ""; }; + 0C12E84E2616383A00B66C86 /* numpy_tile_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = numpy_tile_op.h; sourceTree = ""; }; + 0C12E84F2616383A00B66C86 /* rowmul_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rowmul_op.h; sourceTree = ""; }; + 0C12E8502616383A00B66C86 /* accumulate_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = accumulate_op.h; sourceTree = ""; }; + 0C12E8512616383A00B66C86 /* sparse_lp_regularizer_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sparse_lp_regularizer_op.h; sourceTree = ""; }; + 0C12E8522616383A00B66C86 /* bisect_percentile_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bisect_percentile_op.h; sourceTree = ""; }; + 0C12E8532616383A00B66C86 /* tile_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tile_op.h; sourceTree = ""; }; + 0C12E8542616383A00B66C86 /* gelu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gelu_op.h; sourceTree = ""; }; + 0C12E8552616383A00B66C86 /* stats_put_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stats_put_ops.h; sourceTree = ""; }; + 0C12E8562616383A00B66C86 /* given_tensor_fill_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = given_tensor_fill_op.h; sourceTree = ""; }; + 0C12E8572616383A00B66C86 /* accuracy_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = accuracy_op.h; sourceTree = ""; }; + 0C12E8582616383A00B66C86 /* bbox_transform_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bbox_transform_op.h; sourceTree = ""; }; + 0C12E8592616383A00B66C86 /* boolean_unmask_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = boolean_unmask_ops.h; sourceTree = ""; }; + 0C12E85A2616383A00B66C86 /* glu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = glu_op.h; sourceTree = ""; }; + 0C12E85B2616383A00B66C86 /* resize_3d_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = resize_3d_op.h; sourceTree = ""; }; + 0C12E85C2616383A00B66C86 /* unsafe_coalesce.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unsafe_coalesce.h; sourceTree = ""; }; + 0C12E85D2616383A00B66C86 /* conv_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_op.h; sourceTree = ""; }; + 0C12E85E2616383A00B66C86 /* conv_op_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_op_impl.h; sourceTree = ""; }; + 0C12E85F2616383A00B66C86 /* erf_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = erf_op.h; sourceTree = ""; }; + 0C12E8602616383A00B66C86 /* fused_rowwise_8bit_conversion_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_rowwise_8bit_conversion_ops.h; sourceTree = ""; }; + 0C12E8612616383A00B66C86 /* locally_connected_op_util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = locally_connected_op_util.h; sourceTree = ""; }; + 0C12E8622616383A00B66C86 /* channel_backprop_stats_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = channel_backprop_stats_op.h; sourceTree = ""; }; + 0C12E8632616383A00B66C86 /* order_switch_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = order_switch_ops.h; sourceTree = ""; }; + 0C12E8642616383A00B66C86 /* lengths_reducer_fused_nbit_rowwise_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_reducer_fused_nbit_rowwise_ops.h; sourceTree = ""; }; + 0C12E8652616383A00B66C86 /* lengths_reducer_fused_8bit_rowwise_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_reducer_fused_8bit_rowwise_ops.h; sourceTree = ""; }; + 0C12E8662616383A00B66C86 /* load_save_op_util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = load_save_op_util.h; sourceTree = ""; }; + 0C12E8672616383A00B66C86 /* conv_transpose_op_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_transpose_op_impl.h; sourceTree = ""; }; + 0C12E8682616383A00B66C86 /* op_utils_cudnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = op_utils_cudnn.h; sourceTree = ""; }; + 0C12E8692616383A00B66C86 /* prelu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prelu_op.h; sourceTree = ""; }; + 0C12E86A2616383A00B66C86 /* box_with_nms_limit_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = box_with_nms_limit_op.h; sourceTree = ""; }; + 0C12E86B2616383A00B66C86 /* fc_inference.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fc_inference.h; sourceTree = ""; }; + 0C12E86C2616383A00B66C86 /* distance_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = distance_op.h; sourceTree = ""; }; + 0C12E86D2616383A00B66C86 /* data_couple.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = data_couple.h; sourceTree = ""; }; + 0C12E86E2616383A00B66C86 /* dataset_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dataset_ops.h; sourceTree = ""; }; + 0C12E86F2616383A00B66C86 /* merge_id_lists_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = merge_id_lists_op.h; sourceTree = ""; }; + 0C12E8702616383A00B66C86 /* generate_proposals_op_util_nms_gpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = generate_proposals_op_util_nms_gpu.h; sourceTree = ""; }; + 0C12E8712616383A00B66C86 /* async_net_barrier_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = async_net_barrier_op.h; sourceTree = ""; }; + 0C12E8722616383A00B66C86 /* deform_conv_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = deform_conv_op.h; sourceTree = ""; }; + 0C12E8742616383A00B66C86 /* int8_relu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_relu_op.h; sourceTree = ""; }; + 0C12E8752616383A00B66C86 /* int8_channel_shuffle_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_channel_shuffle_op.h; sourceTree = ""; }; + 0C12E8762616383A00B66C86 /* int8_concat_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_concat_op.h; sourceTree = ""; }; + 0C12E8772616383A00B66C86 /* int8_dequantize_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_dequantize_op.h; sourceTree = ""; }; + 0C12E8782616383A00B66C86 /* int8_slice_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_slice_op.h; sourceTree = ""; }; + 0C12E8792616383A00B66C86 /* int8_quantize_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_quantize_op.h; sourceTree = ""; }; + 0C12E87A2616383A00B66C86 /* int8_flatten_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_flatten_op.h; sourceTree = ""; }; + 0C12E87B2616383A00B66C86 /* int8_max_pool_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_max_pool_op.h; sourceTree = ""; }; + 0C12E87C2616383A00B66C86 /* int8_softmax_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_softmax_op.h; sourceTree = ""; }; + 0C12E87D2616383A00B66C86 /* int8_average_pool_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_average_pool_op.h; sourceTree = ""; }; + 0C12E87E2616383A00B66C86 /* int8_fc_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_fc_op.h; sourceTree = ""; }; + 0C12E87F2616383A00B66C86 /* int8_conv_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_conv_op.h; sourceTree = ""; }; + 0C12E8802616383A00B66C86 /* int8_test_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_test_utils.h; sourceTree = ""; }; + 0C12E8812616383A00B66C86 /* int8_roi_align_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_roi_align_op.h; sourceTree = ""; }; + 0C12E8822616383A00B66C86 /* int8_given_tensor_fill_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_given_tensor_fill_op.h; sourceTree = ""; }; + 0C12E8832616383A00B66C86 /* int8_reshape_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_reshape_op.h; sourceTree = ""; }; + 0C12E8842616383A00B66C86 /* int8_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_utils.h; sourceTree = ""; }; + 0C12E8852616383A00B66C86 /* int8_resize_nearest_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_resize_nearest_op.h; sourceTree = ""; }; + 0C12E8862616383A00B66C86 /* int8_sigmoid_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_sigmoid_op.h; sourceTree = ""; }; + 0C12E8872616383A00B66C86 /* int8_simd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_simd.h; sourceTree = ""; }; + 0C12E8882616383A00B66C86 /* int8_conv_transpose_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_conv_transpose_op.h; sourceTree = ""; }; + 0C12E8892616383A00B66C86 /* int8_leaky_relu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_leaky_relu_op.h; sourceTree = ""; }; + 0C12E88A2616383A00B66C86 /* int8_add_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_add_op.h; sourceTree = ""; }; + 0C12E88B2616383A00B66C86 /* int8_transpose_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_transpose_op.h; sourceTree = ""; }; + 0C12E88C2616383A00B66C86 /* sqrt_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sqrt_op.h; sourceTree = ""; }; + 0C12E88D2616383A00B66C86 /* elementwise_div_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_div_op.h; sourceTree = ""; }; + 0C12E88E2616383A00B66C86 /* deform_conv_op_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = deform_conv_op_impl.h; sourceTree = ""; }; + 0C12E88F2616383A00B66C86 /* feature_maps_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = feature_maps_ops.h; sourceTree = ""; }; + 0C12E8902616383A00B66C86 /* text_file_reader_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = text_file_reader_utils.h; sourceTree = ""; }; + 0C12E8912616383A00B66C86 /* scale_blobs_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = scale_blobs_op.h; sourceTree = ""; }; + 0C12E8922616383A00B66C86 /* pool_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pool_op.h; sourceTree = ""; }; + 0C12E8932616383A00B66C86 /* conv_transpose_op_mobile_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_transpose_op_mobile_impl.h; sourceTree = ""; }; + 0C12E8942616383A00B66C86 /* dense_vector_to_id_list_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dense_vector_to_id_list_op.h; sourceTree = ""; }; + 0C12E8952616383A00B66C86 /* minmax_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = minmax_ops.h; sourceTree = ""; }; + 0C12E8962616383A00B66C86 /* lengths_tile_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_tile_op.h; sourceTree = ""; }; + 0C12E8972616383A00B66C86 /* pool_op_util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pool_op_util.h; sourceTree = ""; }; + 0C12E8982616383A00B66C86 /* no_default_engine_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = no_default_engine_op.h; sourceTree = ""; }; + 0C12E8992616383A00B66C86 /* onnx_while_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnx_while_op.h; sourceTree = ""; }; + 0C12E89A2616383A00B66C86 /* reduce_front_back_sum_mean_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reduce_front_back_sum_mean_ops.h; sourceTree = ""; }; + 0C12E89B2616383A00B66C86 /* roi_pool_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = roi_pool_op.h; sourceTree = ""; }; + 0C12E89C2616383A00B66C86 /* flatten_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = flatten_op.h; sourceTree = ""; }; + 0C12E89D2616383A00B66C86 /* self_binning_histogram_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = self_binning_histogram_op.h; sourceTree = ""; }; + 0C12E89E2616383A00B66C86 /* normalize_l1_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = normalize_l1_op.h; sourceTree = ""; }; + 0C12E89F2616383A00B66C86 /* pow_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pow_op.h; sourceTree = ""; }; + 0C12E8A02616383A00B66C86 /* exp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = exp_op.h; sourceTree = ""; }; + 0C12E8A12616383A00B66C86 /* heatmap_max_keypoint_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = heatmap_max_keypoint_op.h; sourceTree = ""; }; + 0C12E8A22616383A00B66C86 /* assert_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = assert_op.h; sourceTree = ""; }; + 0C12E8A32616383A00B66C86 /* piecewise_linear_transform_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = piecewise_linear_transform_op.h; sourceTree = ""; }; + 0C12E8A42616383A00B66C86 /* cbrt_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cbrt_op.h; sourceTree = ""; }; + 0C12E8A52616383A00B66C86 /* weighted_sample_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = weighted_sample_op.h; sourceTree = ""; }; + 0C12E8A62616383A00B66C86 /* tanh_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tanh_op.h; sourceTree = ""; }; + 0C12E8A72616383A00B66C86 /* softmax_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = softmax_op.h; sourceTree = ""; }; + 0C12E8A82616383A00B66C86 /* listwise_l2r_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = listwise_l2r_op.h; sourceTree = ""; }; + 0C12E8A92616383A00B66C86 /* variable_length_sequence_padding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = variable_length_sequence_padding.h; sourceTree = ""; }; + 0C12E8AA2616383A00B66C86 /* elementwise_add_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_add_op.h; sourceTree = ""; }; + 0C12E8AB2616383A00B66C86 /* leaky_relu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = leaky_relu_op.h; sourceTree = ""; }; + 0C12E8AC2616383A00B66C86 /* elementwise_linear_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_linear_op.h; sourceTree = ""; }; + 0C12E8AD2616383A00B66C86 /* elu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elu_op.h; sourceTree = ""; }; + 0C12E8AE2616383A00B66C86 /* jsd_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jsd_op.h; sourceTree = ""; }; + 0C12E8AF2616383A00B66C86 /* collect_and_distribute_fpn_rpn_proposals_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = collect_and_distribute_fpn_rpn_proposals_op.h; sourceTree = ""; }; + 0C12E8B02616383A00B66C86 /* reduce_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reduce_ops.h; sourceTree = ""; }; + 0C12E8B12616383A00B66C86 /* string_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = string_ops.h; sourceTree = ""; }; + 0C12E8B22616383A00B66C86 /* boolean_mask_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = boolean_mask_ops.h; sourceTree = ""; }; + 0C12E8B32616383A00B66C86 /* local_response_normalization_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = local_response_normalization_op.h; sourceTree = ""; }; + 0C12E8B42616383A00B66C86 /* partition_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = partition_ops.h; sourceTree = ""; }; + 0C12E8B52616383A00B66C86 /* sparse_dropout_with_replacement_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sparse_dropout_with_replacement_op.h; sourceTree = ""; }; + 0C12E8B62616383A00B66C86 /* loss_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = loss_op.h; sourceTree = ""; }; + 0C12E8B72616383A00B66C86 /* counter_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = counter_ops.h; sourceTree = ""; }; + 0C12E8B82616383A00B66C86 /* h_softmax_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = h_softmax_op.h; sourceTree = ""; }; + 0C12E8B92616383A00B66C86 /* lengths_reducer_rowwise_8bit_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_reducer_rowwise_8bit_ops.h; sourceTree = ""; }; + 0C12E8BA2616383A00B66C86 /* copy_rows_to_tensor_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = copy_rows_to_tensor_op.h; sourceTree = ""; }; + 0C12E8BB2616383A00B66C86 /* moments_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = moments_op.h; sourceTree = ""; }; + 0C12E8BC2616383A00B66C86 /* logit_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = logit_op.h; sourceTree = ""; }; + 0C12E8BD2616383A00B66C86 /* perplexity_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = perplexity_op.h; sourceTree = ""; }; + 0C12E8BE2616383A00B66C86 /* roi_align_rotated_gradient_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = roi_align_rotated_gradient_op.h; sourceTree = ""; }; + 0C12E8BF2616383A00B66C86 /* ceil_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ceil_op.h; sourceTree = ""; }; + 0C12E8C02616383A00B66C86 /* find_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = find_op.h; sourceTree = ""; }; + 0C12E8C12616383A00B66C86 /* layer_norm_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = layer_norm_op.h; sourceTree = ""; }; + 0C12E8C22616383A00B66C86 /* negate_gradient_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = negate_gradient_op.h; sourceTree = ""; }; + 0C12E8C32616383A00B66C86 /* resize_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = resize_op.h; sourceTree = ""; }; + 0C12E8C42616383A00B66C86 /* lengths_reducer_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_reducer_ops.h; sourceTree = ""; }; + 0C12E8C52616383A00B66C86 /* batch_sparse_to_dense_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_sparse_to_dense_op.h; sourceTree = ""; }; + 0C12E8C62616383A00B66C86 /* replace_nan_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = replace_nan_op.h; sourceTree = ""; }; + 0C12E8C72616383A00B66C86 /* max_pool_with_index_gpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = max_pool_with_index_gpu.h; sourceTree = ""; }; + 0C12E8C82616383A00B66C86 /* find_duplicate_elements_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = find_duplicate_elements_op.h; sourceTree = ""; }; + 0C12E8C92616383A00B66C86 /* expand_squeeze_dims_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = expand_squeeze_dims_op.h; sourceTree = ""; }; + 0C12E8CA2616383A00B66C86 /* sinusoid_position_encoding_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sinusoid_position_encoding_op.h; sourceTree = ""; }; + 0C12E8CB2616383A00B66C86 /* pack_segments.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pack_segments.h; sourceTree = ""; }; + 0C12E8CC2616383A00B66C86 /* softplus_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = softplus_op.h; sourceTree = ""; }; + 0C12E8CD2616383A00B66C86 /* quantile_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quantile_op.h; sourceTree = ""; }; + 0C12E8CE2616383A00B66C86 /* sinh_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sinh_op.h; sourceTree = ""; }; + 0C12E8CF2616383A00B66C86 /* fused_rowwise_nbitfake_conversion_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_rowwise_nbitfake_conversion_ops.h; sourceTree = ""; }; + 0C12E8D02616383A00B66C86 /* cross_entropy_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cross_entropy_op.h; sourceTree = ""; }; + 0C12E8D12616383A00B66C86 /* feed_blob_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = feed_blob_op.h; sourceTree = ""; }; + 0C12E8D22616383A00B66C86 /* slice_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = slice_op.h; sourceTree = ""; }; + 0C12E8D32616383A00B66C86 /* rsqrt_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rsqrt_op.h; sourceTree = ""; }; + 0C12E8D42616383A00B66C86 /* free_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = free_op.h; sourceTree = ""; }; + 0C12E8D52616383A00B66C86 /* square_root_divide_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = square_root_divide_op.h; sourceTree = ""; }; + 0C12E8D62616383A00B66C86 /* conv_op_shared.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_op_shared.h; sourceTree = ""; }; + 0C12E8D72616383A00B66C86 /* apmeter_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = apmeter_op.h; sourceTree = ""; }; + 0C12E8D82616383A00B66C86 /* lstm_unit_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lstm_unit_op.h; sourceTree = ""; }; + 0C12E8D92616383A00B66C86 /* index_hash_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = index_hash_ops.h; sourceTree = ""; }; + 0C12E8DA2616383A00B66C86 /* lengths_pad_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_pad_op.h; sourceTree = ""; }; + 0C12E8DB2616383A00B66C86 /* elementwise_ops_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_ops_utils.h; sourceTree = ""; }; + 0C12E8DC2616383A00B66C86 /* sparse_normalize_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sparse_normalize_op.h; sourceTree = ""; }; + 0C12E8DD2616383A00B66C86 /* multi_class_accuracy_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = multi_class_accuracy_op.h; sourceTree = ""; }; + 0C12E8DE2616383A00B66C86 /* cast_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cast_op.h; sourceTree = ""; }; + 0C12E8DF2616383A00B66C86 /* transpose_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transpose_op.h; sourceTree = ""; }; + 0C12E8E02616383A00B66C86 /* create_scope_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = create_scope_op.h; sourceTree = ""; }; + 0C12E8E12616383A00B66C86 /* zero_gradient_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = zero_gradient_op.h; sourceTree = ""; }; + 0C12E8E22616383A00B66C86 /* lstm_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lstm_utils.h; sourceTree = ""; }; + 0C12E8E32616383A00B66C86 /* tt_linear_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tt_linear_op.h; sourceTree = ""; }; + 0C12E8E42616383A00B66C86 /* relu_n_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = relu_n_op.h; sourceTree = ""; }; + 0C12E8E52616383A00B66C86 /* generate_proposals_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = generate_proposals_op.h; sourceTree = ""; }; + 0C12E8E72616383A00B66C86 /* activation_ops_miopen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = activation_ops_miopen.h; sourceTree = ""; }; + 0C12E8E82616383A00B66C86 /* lpnorm_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lpnorm_op.h; sourceTree = ""; }; + 0C12E8E92616383A00B66C86 /* sequence_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sequence_ops.h; sourceTree = ""; }; + 0C12E8EA2616383A00B66C86 /* abs_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = abs_op.h; sourceTree = ""; }; + 0C12E8EB2616383A00B66C86 /* activation_ops_cudnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = activation_ops_cudnn.h; sourceTree = ""; }; + 0C12E8EC2616383A00B66C86 /* elementwise_op_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_op_test.h; sourceTree = ""; }; + 0C12E8ED2616383A00B66C86 /* inference_lstm_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = inference_lstm_op.h; sourceTree = ""; }; + 0C12E8EE2616383A00B66C86 /* concat_split_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = concat_split_op.h; sourceTree = ""; }; + 0C12E8EF2616383A00B66C86 /* reduction_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reduction_ops.h; sourceTree = ""; }; + 0C12E8F02616383A00B66C86 /* gather_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gather_op.h; sourceTree = ""; }; + 0C12E8F12616383A00B66C86 /* log_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = log_op.h; sourceTree = ""; }; + 0C12E8F22616383A00B66C86 /* conv_pool_op_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_pool_op_base.h; sourceTree = ""; }; + 0C12E8F32616383A00B66C86 /* unique_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unique_ops.h; sourceTree = ""; }; + 0C12E8F42616383A00B66C86 /* elementwise_sub_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_sub_op.h; sourceTree = ""; }; + 0C12E8F52616383A00B66C86 /* segment_reduction_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = segment_reduction_op.h; sourceTree = ""; }; + 0C12E8F62616383A00B66C86 /* fused_rowwise_nbit_conversion_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_rowwise_nbit_conversion_ops.h; sourceTree = ""; }; + 0C12E8F72616383A00B66C86 /* stump_func_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stump_func_op.h; sourceTree = ""; }; + 0C12E8F82616383A00B66C86 /* swish_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = swish_op.h; sourceTree = ""; }; + 0C12E8F92616383A00B66C86 /* pack_rnn_sequence_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pack_rnn_sequence_op.h; sourceTree = ""; }; + 0C12E8FA2616383A00B66C86 /* softmax_with_loss_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = softmax_with_loss_op.h; sourceTree = ""; }; + 0C12E8FB2616383A00B66C86 /* integral_image_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = integral_image_op.h; sourceTree = ""; }; + 0C12E8FC2616383A00B66C86 /* mish_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mish_op.h; sourceTree = ""; }; + 0C12E8FD2616383A00B66C86 /* weighted_multi_sampling_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = weighted_multi_sampling_op.h; sourceTree = ""; }; + 0C12E8FE2616383A00B66C86 /* bucketize_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bucketize_op.h; sourceTree = ""; }; + 0C12E8FF2616383A00B66C86 /* is_empty_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = is_empty_op.h; sourceTree = ""; }; + 0C12E9002616383A00B66C86 /* mod_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mod_op.h; sourceTree = ""; }; + 0C12E9012616383A00B66C86 /* clip_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = clip_op.h; sourceTree = ""; }; + 0C12E9022616383A00B66C86 /* prepend_dim_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prepend_dim_op.h; sourceTree = ""; }; + 0C12E9032616383A00B66C86 /* copy_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = copy_op.h; sourceTree = ""; }; + 0C12E9042616383A00B66C86 /* rank_loss_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rank_loss_op.h; sourceTree = ""; }; + 0C12E9052616383A00B66C86 /* lengths_top_k_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_top_k_op.h; sourceTree = ""; }; + 0C12E9062616383A00B66C86 /* summarize_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = summarize_op.h; sourceTree = ""; }; + 0C12E9072616383A00B66C86 /* one_hot_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = one_hot_ops.h; sourceTree = ""; }; + 0C12E9082616383A00B66C86 /* cc_bmm_bg_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cc_bmm_bg_op.h; sourceTree = ""; }; + 0C12E9092616383A00B66C86 /* acos_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = acos_op.h; sourceTree = ""; }; + 0C12E90A2616383A00B66C86 /* softmax_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = softmax_utils.h; sourceTree = ""; }; + 0C12E90B2616383A00B66C86 /* tensor_protos_db_input.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_protos_db_input.h; sourceTree = ""; }; + 0C12E90C2616383A00B66C86 /* generate_proposals_op_util_boxes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = generate_proposals_op_util_boxes.h; sourceTree = ""; }; + 0C12E90D2616383A00B66C86 /* conv_transpose_op_mobile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_transpose_op_mobile.h; sourceTree = ""; }; + 0C12E90E2616383A00B66C86 /* arg_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = arg_ops.h; sourceTree = ""; }; + 0C12E90F2616383A00B66C86 /* negative_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = negative_op.h; sourceTree = ""; }; + 0C12E9102616383A00B66C86 /* operator_fallback_gpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator_fallback_gpu.h; sourceTree = ""; }; + 0C12E9112616383A00B66C86 /* margin_ranking_criterion_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = margin_ranking_criterion_op.h; sourceTree = ""; }; + 0C12E9122616383A00B66C86 /* matmul_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = matmul_op.h; sourceTree = ""; }; + 0C12E9132616383A00B66C86 /* roi_align_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = roi_align_op.h; sourceTree = ""; }; + 0C12E9142616383A00B66C86 /* pad_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pad_op.h; sourceTree = ""; }; + 0C12E9152616383A00B66C86 /* histogram_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = histogram_op.h; sourceTree = ""; }; + 0C12E9162616383A00B66C86 /* floor_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = floor_op.h; sourceTree = ""; }; + 0C12E9172616383A00B66C86 /* normalize_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = normalize_op.h; sourceTree = ""; }; + 0C12E9182616383A00B66C86 /* cube_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cube_op.h; sourceTree = ""; }; + 0C12E9192616383A00B66C86 /* reshape_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reshape_op.h; sourceTree = ""; }; + 0C12E91A2616383A00B66C86 /* instance_norm_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = instance_norm_op.h; sourceTree = ""; }; + 0C12E91B2616383A00B66C86 /* ngram_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ngram_ops.h; sourceTree = ""; }; + 0C12E91C2616383A00B66C86 /* if_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = if_op.h; sourceTree = ""; }; + 0C12E91D2616383A00B66C86 /* reduce_front_back_max_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reduce_front_back_max_ops.h; sourceTree = ""; }; + 0C12E91E2616383A00B66C86 /* reducer_functors.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reducer_functors.h; sourceTree = ""; }; + 0C12E91F2616383A00B66C86 /* affine_channel_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = affine_channel_op.h; sourceTree = ""; }; + 0C12E9202616383A00B66C86 /* sigmoid_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sigmoid_op.h; sourceTree = ""; }; + 0C12E9212616383A00B66C86 /* channel_shuffle_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = channel_shuffle_op.h; sourceTree = ""; }; + 0C12E9222616383A00B66C86 /* locally_connected_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = locally_connected_op.h; sourceTree = ""; }; + 0C12E9232616383A00B66C86 /* conditional_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conditional_op.h; sourceTree = ""; }; + 0C12E9242616383A00B66C86 /* rms_norm_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rms_norm_op.h; sourceTree = ""; }; + 0C12E9252616383A00B66C86 /* dropout_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dropout_op.h; sourceTree = ""; }; + 0C12E9262616383A00B66C86 /* gather_ranges_to_dense_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gather_ranges_to_dense_op.h; sourceTree = ""; }; + 0C12E9272616383A00B66C86 /* shape_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = shape_op.h; sourceTree = ""; }; + 0C12E9282616383A00B66C86 /* index_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = index_ops.h; sourceTree = ""; }; + 0C12E9292616383A00B66C86 /* tan_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tan_op.h; sourceTree = ""; }; + 0C12E92A2616383A00B66C86 /* scale_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = scale_op.h; sourceTree = ""; }; + 0C12E92B2616383A00B66C86 /* cosine_embedding_criterion_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cosine_embedding_criterion_op.h; sourceTree = ""; }; + 0C12E92C2616383A00B66C86 /* sparse_to_dense_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sparse_to_dense_op.h; sourceTree = ""; }; + 0C12E92D2616383A00B66C86 /* quant_decode_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quant_decode_op.h; sourceTree = ""; }; + 0C12E92F2616383A00B66C86 /* recurrent_network_blob_fetcher_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = recurrent_network_blob_fetcher_op.h; sourceTree = ""; }; + 0C12E9302616383A00B66C86 /* recurrent_op_cudnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = recurrent_op_cudnn.h; sourceTree = ""; }; + 0C12E9312616383A00B66C86 /* recurrent_network_executor_gpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = recurrent_network_executor_gpu.h; sourceTree = ""; }; + 0C12E9322616383A00B66C86 /* recurrent_network_executor_incl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = recurrent_network_executor_incl.h; sourceTree = ""; }; + 0C12E9342616383A00B66C86 /* recurrent_op_miopen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = recurrent_op_miopen.h; sourceTree = ""; }; + 0C12E9352616383A00B66C86 /* recurrent_network_executor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = recurrent_network_executor.h; sourceTree = ""; }; + 0C12E9362616383A00B66C86 /* recurrent_network_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = recurrent_network_op.h; sourceTree = ""; }; + 0C12E9372616383A00B66C86 /* sparse_to_dense_mask_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sparse_to_dense_mask_op.h; sourceTree = ""; }; + 0C12E9382616383A00B66C86 /* sin_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sin_op.h; sourceTree = ""; }; + 0C12E9392616383A00B66C86 /* upsample_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = upsample_op.h; sourceTree = ""; }; + 0C12E93A2616383A00B66C86 /* filler_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = filler_op.h; sourceTree = ""; }; + 0C12E93B2616383A00B66C86 /* batch_permutation_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_permutation_op.h; sourceTree = ""; }; + 0C12E93C2616383A00B66C86 /* spatial_softmax_with_loss_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = spatial_softmax_with_loss_op.h; sourceTree = ""; }; + 0C12E93D2616383A00B66C86 /* batch_moments_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_moments_op.h; sourceTree = ""; }; + 0C12E93E2616383A00B66C86 /* alias_with_name.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = alias_with_name.h; sourceTree = ""; }; + 0C12E93F2616383A00B66C86 /* do_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = do_op.h; sourceTree = ""; }; + 0C12E9402616383A00B66C86 /* prefetch_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prefetch_op.h; sourceTree = ""; }; + 0C12E9412616383A00B66C86 /* byte_weight_dequant_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = byte_weight_dequant_op.h; sourceTree = ""; }; + 0C12E9422616383A00B66C86 /* spatial_batch_norm_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = spatial_batch_norm_op.h; sourceTree = ""; }; + 0C12E9442616383A00B66C86 /* helper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = helper.h; sourceTree = ""; }; + 0C12E9452616383A00B66C86 /* device.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = device.h; sourceTree = ""; }; + 0C12E9462616383A00B66C86 /* onnxifi_init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnxifi_init.h; sourceTree = ""; }; + 0C12E9472616383A00B66C86 /* backend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = backend.h; sourceTree = ""; }; + 0C12E9492616383A00B66C86 /* schema.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = schema.h; sourceTree = ""; }; + 0C12E94A2616383A00B66C86 /* constants.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = constants.h; sourceTree = ""; }; + 0C12E94B2616383A00B66C86 /* operator_sets.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator_sets.h; sourceTree = ""; }; + 0C12E94C2616383A00B66C86 /* backend_rep.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = backend_rep.h; sourceTree = ""; }; + 0C12E94D2616383A00B66C86 /* onnx_exporter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnx_exporter.h; sourceTree = ""; }; + 0C12E94E2616383A00B66C86 /* offline_tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = offline_tensor.h; sourceTree = ""; }; + 0C12E94F2616383A00B66C86 /* onnxifi_graph_info.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnxifi_graph_info.h; sourceTree = ""; }; + 0C12E9542616383A00B66C86 /* pybind_state.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pybind_state.h; sourceTree = ""; }; + 0C12E9552616383A00B66C86 /* pybind_state_registry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pybind_state_registry.h; sourceTree = ""; }; + 0C12E95D2616383A00B66C86 /* dlpack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dlpack.h; sourceTree = ""; }; + 0C12E9692616383A00B66C86 /* pybind_state_dlpack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pybind_state_dlpack.h; sourceTree = ""; }; + 0C12E9712616383A00B66C86 /* redis_store_handler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = redis_store_handler.h; sourceTree = ""; }; + 0C12E9722616383A00B66C86 /* file_store_handler_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = file_store_handler_op.h; sourceTree = ""; }; + 0C12E9732616383A00B66C86 /* store_handler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = store_handler.h; sourceTree = ""; }; + 0C12E9742616383A00B66C86 /* store_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = store_ops.h; sourceTree = ""; }; + 0C12E9752616383A00B66C86 /* file_store_handler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = file_store_handler.h; sourceTree = ""; }; + 0C12E9762616383A00B66C86 /* redis_store_handler_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = redis_store_handler_op.h; sourceTree = ""; }; + 0C12E9782616383A00B66C86 /* embedding_lookup.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = embedding_lookup.h; sourceTree = ""; }; + 0C12E9792616383A00B66C86 /* fused_8bit_rowwise_embedding_lookup_idx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_8bit_rowwise_embedding_lookup_idx.h; sourceTree = ""; }; + 0C12E97A2616383A00B66C86 /* lstm_unit_cpu-impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "lstm_unit_cpu-impl.h"; sourceTree = ""; }; + 0C12E97B2616383A00B66C86 /* embedding_lookup_idx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = embedding_lookup_idx.h; sourceTree = ""; }; + 0C12E97C2616383A00B66C86 /* adagrad.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adagrad.h; sourceTree = ""; }; + 0C12E97D2616383A00B66C86 /* lstm_unit_cpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lstm_unit_cpu.h; sourceTree = ""; }; + 0C12E97E2616383A00B66C86 /* cvtsh_ss_bugfix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cvtsh_ss_bugfix.h; sourceTree = ""; }; + 0C12E97F2616383A00B66C86 /* common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common.h; sourceTree = ""; }; + 0C12E9802616383A00B66C86 /* math.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = math.h; sourceTree = ""; }; + 0C12E9812616383A00B66C86 /* typed_axpy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = typed_axpy.h; sourceTree = ""; }; + 0C12E9822616383A00B66C86 /* fused_nbit_rowwise_conversion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_nbit_rowwise_conversion.h; sourceTree = ""; }; + 0C12E9832616383A00B66C86 /* fused_8bit_rowwise_embedding_lookup.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_8bit_rowwise_embedding_lookup.h; sourceTree = ""; }; + 0C12E9842616383A00B66C86 /* lstm_unit_cpu_common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lstm_unit_cpu_common.h; sourceTree = ""; }; + 0C12E9872616383A00B66C86 /* fully_connected_op_decomposition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fully_connected_op_decomposition.h; sourceTree = ""; }; + 0C12E9882616383A00B66C86 /* fully_connected_op_sparse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fully_connected_op_sparse.h; sourceTree = ""; }; + 0C12E9892616383A00B66C86 /* tt_contraction_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tt_contraction_op.h; sourceTree = ""; }; + 0C12E98A2616383A00B66C86 /* fully_connected_op_prune.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fully_connected_op_prune.h; sourceTree = ""; }; + 0C12E98B2616383A00B66C86 /* funhash_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = funhash_op.h; sourceTree = ""; }; + 0C12E98C2616383A00B66C86 /* sparse_funhash_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sparse_funhash_op.h; sourceTree = ""; }; + 0C12E98D2616383A00B66C86 /* sparse_matrix_reshape_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sparse_matrix_reshape_op.h; sourceTree = ""; }; + 0C12E98E2616383A00B66C86 /* tt_pad_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tt_pad_op.h; sourceTree = ""; }; + 0C12E9912616383A00B66C86 /* common_rtc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common_rtc.h; sourceTree = ""; }; + 0C12E9932616383A00B66C86 /* read_adapter_interface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = read_adapter_interface.h; sourceTree = ""; }; + 0C12E9942616383A00B66C86 /* crc_alt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = crc_alt.h; sourceTree = ""; }; + 0C12E9952616383A00B66C86 /* versions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = versions.h; sourceTree = ""; }; + 0C12E9962616383A00B66C86 /* inline_container.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = inline_container.h; sourceTree = ""; }; + 0C12E9972616383A00B66C86 /* file_adapter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = file_adapter.h; sourceTree = ""; }; + 0C12E9982616383A00B66C86 /* istream_adapter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = istream_adapter.h; sourceTree = ""; }; + 0C12E99A2616383A00B66C86 /* filler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = filler.h; sourceTree = ""; }; + 0C12E99B2616383A00B66C86 /* math-detail.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "math-detail.h"; sourceTree = ""; }; + 0C12E99C2616383A00B66C86 /* signal_handler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = signal_handler.h; sourceTree = ""; }; + 0C12E99D2616383A00B66C86 /* cpu_neon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cpu_neon.h; sourceTree = ""; }; + 0C12E99E2616383A00B66C86 /* conversions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conversions.h; sourceTree = ""; }; + 0C12E99F2616383A00B66C86 /* string_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = string_utils.h; sourceTree = ""; }; + 0C12E9A02616383A00B66C86 /* simple_queue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = simple_queue.h; sourceTree = ""; }; + 0C12E9A12616383A00B66C86 /* cpuid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cpuid.h; sourceTree = ""; }; + 0C12E9A32616383A00B66C86 /* ThreadPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadPool.h; sourceTree = ""; }; + 0C12E9A42616383A00B66C86 /* ThreadPoolCommon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadPoolCommon.h; sourceTree = ""; }; + 0C12E9A52616383A00B66C86 /* pthreadpool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pthreadpool.h; sourceTree = ""; }; + 0C12E9A62616383A00B66C86 /* pthreadpool-cpp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "pthreadpool-cpp.h"; sourceTree = ""; }; + 0C12E9A72616383A00B66C86 /* WorkersPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkersPool.h; sourceTree = ""; }; + 0C12E9A82616383A00B66C86 /* thread_pool_guard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = thread_pool_guard.h; sourceTree = ""; }; + 0C12E9AA2616383A00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12E9AB2616383A00B66C86 /* broadcast.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = broadcast.h; sourceTree = ""; }; + 0C12E9AC2616383A00B66C86 /* elementwise.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise.h; sourceTree = ""; }; + 0C12E9AD2616383A00B66C86 /* half_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = half_utils.h; sourceTree = ""; }; + 0C12E9AE2616383A00B66C86 /* reduce.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reduce.h; sourceTree = ""; }; + 0C12E9AF2616383A00B66C86 /* transpose.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transpose.h; sourceTree = ""; }; + 0C12E9B02616383A00B66C86 /* fixed_divisor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fixed_divisor.h; sourceTree = ""; }; + 0C12E9B12616383A00B66C86 /* proto_wrap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = proto_wrap.h; sourceTree = ""; }; + 0C12E9B22616383A00B66C86 /* bench_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bench_utils.h; sourceTree = ""; }; + 0C12E9B32616383A00B66C86 /* cast.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cast.h; sourceTree = ""; }; + 0C12E9B52616383A00B66C86 /* murmur_hash3.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = murmur_hash3.h; sourceTree = ""; }; + 0C12E9B62616383A00B66C86 /* math.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = math.h; sourceTree = ""; }; + 0C12E9B72616383B00B66C86 /* eigen_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = eigen_utils.h; sourceTree = ""; }; + 0C12E9B82616383B00B66C86 /* smart_tensor_printer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = smart_tensor_printer.h; sourceTree = ""; }; + 0C12E9B92616383B00B66C86 /* proto_convert.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = proto_convert.h; sourceTree = ""; }; + 0C12E9BA2616383B00B66C86 /* proto_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = proto_utils.h; sourceTree = ""; }; + 0C12E9BB2616383B00B66C86 /* cblas.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cblas.h; sourceTree = ""; }; + 0C12E9BC2616383B00B66C86 /* map_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = map_utils.h; sourceTree = ""; }; + 0C12E9BD2616383B00B66C86 /* zmq_helper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = zmq_helper.h; sourceTree = ""; }; + 0C12E9C12616383B00B66C86 /* ctc_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ctc_op.h; sourceTree = ""; }; + 0C12E9C32616383B00B66C86 /* cuda_nccl_gpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cuda_nccl_gpu.h; sourceTree = ""; }; + 0C12E9C92616383B00B66C86 /* allreduce_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = allreduce_ops.h; sourceTree = ""; }; + 0C12E9CA2616383B00B66C86 /* allgather_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = allgather_ops.h; sourceTree = ""; }; + 0C12E9CB2616383B00B66C86 /* context.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = context.h; sourceTree = ""; }; + 0C12E9CC2616383B00B66C86 /* store_handler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = store_handler.h; sourceTree = ""; }; + 0C12E9CD2616383B00B66C86 /* broadcast_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = broadcast_ops.h; sourceTree = ""; }; + 0C12E9CE2616383B00B66C86 /* reduce_scatter_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reduce_scatter_ops.h; sourceTree = ""; }; + 0C12E9CF2616383B00B66C86 /* common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common.h; sourceTree = ""; }; + 0C12E9D02616383B00B66C86 /* common_world_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common_world_ops.h; sourceTree = ""; }; + 0C12E9D12616383B00B66C86 /* barrier_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = barrier_ops.h; sourceTree = ""; }; + 0C12E9D32616383B00B66C86 /* sum_fp16_fake_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sum_fp16_fake_op.h; sourceTree = ""; }; + 0C12E9D42616383B00B66C86 /* lengths_reducer_fused_4bit_rowwise_fp16_fake_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_reducer_fused_4bit_rowwise_fp16_fake_op.h; sourceTree = ""; }; + 0C12E9D52616383B00B66C86 /* int8_dequantize_op_nnpi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_dequantize_op_nnpi.h; sourceTree = ""; }; + 0C12E9D72616383B00B66C86 /* fp16_gemm_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fp16_gemm_utils.h; sourceTree = ""; }; + 0C12E9D82616383B00B66C86 /* fp16_fma.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fp16_fma.h; sourceTree = ""; }; + 0C12E9D92616383B00B66C86 /* fp16_fc_acc_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fp16_fc_acc_op.h; sourceTree = ""; }; + 0C12E9DA2616383B00B66C86 /* layernorm_fp16_fake_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = layernorm_fp16_fake_op.h; sourceTree = ""; }; + 0C12E9DB2616383B00B66C86 /* unary_fp16_fake_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unary_fp16_fake_op.h; sourceTree = ""; }; + 0C12E9DC2616383B00B66C86 /* int8_quantize_op_nnpi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_quantize_op_nnpi.h; sourceTree = ""; }; + 0C12E9DD2616383B00B66C86 /* lengths_reducer_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_reducer_ops.h; sourceTree = ""; }; + 0C12E9DE2616383B00B66C86 /* common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common.h; sourceTree = ""; }; + 0C12E9DF2616383B00B66C86 /* batch_matmul_fp16_fake_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_matmul_fp16_fake_op.h; sourceTree = ""; }; + 0C12E9E02616383B00B66C86 /* lengths_reducer_fused_8bit_rowwise_fp16_fake_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lengths_reducer_fused_8bit_rowwise_fp16_fake_op.h; sourceTree = ""; }; + 0C12E9E12616383B00B66C86 /* spatial_batch_norm_fp16_fake_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = spatial_batch_norm_fp16_fake_op.h; sourceTree = ""; }; + 0C12E9E22616383B00B66C86 /* quant_lut_fp16_fake_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quant_lut_fp16_fake_op.h; sourceTree = ""; }; + 0C12E9E32616383B00B66C86 /* int8_swish_op_nnpi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_swish_op_nnpi.h; sourceTree = ""; }; + 0C12E9E72616383B00B66C86 /* context.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = context.h; sourceTree = ""; }; + 0C12E9EA2616383B00B66C86 /* prof_dag_stats_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prof_dag_stats_op.h; sourceTree = ""; }; + 0C12E9EC2616383B00B66C86 /* tensorrt_tranformer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensorrt_tranformer.h; sourceTree = ""; }; + 0C12E9ED2616383B00B66C86 /* trt_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = trt_utils.h; sourceTree = ""; }; + 0C12E9EE2616383B00B66C86 /* tensorrt_op_trt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensorrt_op_trt.h; sourceTree = ""; }; + 0C12E9F02616383B00B66C86 /* shm_mutex.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = shm_mutex.h; sourceTree = ""; }; + 0C12E9F32616383B00B66C86 /* aten_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aten_op.h; sourceTree = ""; }; + 0C12E9F52616383B00B66C86 /* aten_op_template.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aten_op_template.h; sourceTree = ""; }; + 0C12E9F82616383B00B66C86 /* image_input_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = image_input_op.h; sourceTree = ""; }; + 0C12E9F92616383B00B66C86 /* transform_gpu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transform_gpu.h; sourceTree = ""; }; + 0C12E9FC2616383B00B66C86 /* fbgemm_fp16_pack_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fbgemm_fp16_pack_op.h; sourceTree = ""; }; + 0C12E9FD2616383B00B66C86 /* concat_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = concat_dnnlowp_op.h; sourceTree = ""; }; + 0C12E9FE2616383B00B66C86 /* fully_connected_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fully_connected_dnnlowp_op.h; sourceTree = ""; }; + 0C12E9FF2616383B00B66C86 /* int8_quant_scheme_blob_fill.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_quant_scheme_blob_fill.h; sourceTree = ""; }; + 0C12EA002616383B00B66C86 /* quantize_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quantize_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA012616383B00B66C86 /* batch_matmul_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_matmul_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA022616383B00B66C86 /* utility_dnnlowp_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utility_dnnlowp_ops.h; sourceTree = ""; }; + 0C12EA032616383B00B66C86 /* activation_distribution_observer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = activation_distribution_observer.h; sourceTree = ""; }; + 0C12EA042616383B00B66C86 /* compute_equalization_scale.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = compute_equalization_scale.h; sourceTree = ""; }; + 0C12EA052616383B00B66C86 /* caffe2_dnnlowp_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = caffe2_dnnlowp_utils.h; sourceTree = ""; }; + 0C12EA062616383B00B66C86 /* dnnlowp_partition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dnnlowp_partition.h; sourceTree = ""; }; + 0C12EA072616383B00B66C86 /* fully_connected_fake_lowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fully_connected_fake_lowp_op.h; sourceTree = ""; }; + 0C12EA082616383B00B66C86 /* op_wrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = op_wrapper.h; sourceTree = ""; }; + 0C12EA092616383B00B66C86 /* batch_permutation_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_permutation_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA0A2616383B00B66C86 /* conv_relu_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_relu_op.h; sourceTree = ""; }; + 0C12EA0B2616383B00B66C86 /* conv_pool_dnnlowp_op_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_pool_dnnlowp_op_base.h; sourceTree = ""; }; + 0C12EA0C2616383B00B66C86 /* mmio.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mmio.h; sourceTree = ""; }; + 0C12EA0D2616383B00B66C86 /* lstm_unit_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lstm_unit_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA0E2616383B00B66C86 /* fbgemm_pack_matrix_cache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fbgemm_pack_matrix_cache.h; sourceTree = ""; }; + 0C12EA0F2616383B00B66C86 /* im2col_dnnlowp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = im2col_dnnlowp.h; sourceTree = ""; }; + 0C12EA102616383B00B66C86 /* fbgemm_pack_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fbgemm_pack_op.h; sourceTree = ""; }; + 0C12EA112616383B00B66C86 /* resize_nearest_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = resize_nearest_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA122616383B00B66C86 /* group_norm_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = group_norm_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA132616383B00B66C86 /* elementwise_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA142616383B00B66C86 /* fb_fc_packed_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fb_fc_packed_op.h; sourceTree = ""; }; + 0C12EA152616383B00B66C86 /* relu_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = relu_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA162616383B00B66C86 /* spatial_batch_norm_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = spatial_batch_norm_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA172616383B00B66C86 /* dequantize_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dequantize_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA182616383B00B66C86 /* kl_minimization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kl_minimization.h; sourceTree = ""; }; + 0C12EA192616383B00B66C86 /* dynamic_histogram.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dynamic_histogram.h; sourceTree = ""; }; + 0C12EA1A2616383B00B66C86 /* tanh.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tanh.h; sourceTree = ""; }; + 0C12EA1B2616383B00B66C86 /* fbgemm_pack_blob.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fbgemm_pack_blob.h; sourceTree = ""; }; + 0C12EA1C2616383B00B66C86 /* resize_nearest_3d_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = resize_nearest_3d_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA1D2616383B00B66C86 /* int8_gen_quant_params.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_gen_quant_params.h; sourceTree = ""; }; + 0C12EA1E2616383B00B66C86 /* conv_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA1F2616383B00B66C86 /* sigmoid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sigmoid.h; sourceTree = ""; }; + 0C12EA202616383B00B66C86 /* channel_shuffle_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = channel_shuffle_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA212616383B00B66C86 /* int8_gen_quant_params_min_max.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = int8_gen_quant_params_min_max.h; sourceTree = ""; }; + 0C12EA222616383B00B66C86 /* quantization_error_minimization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quantization_error_minimization.h; sourceTree = ""; }; + 0C12EA232616383B00B66C86 /* elementwise_linear_dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = elementwise_linear_dnnlowp_op.h; sourceTree = ""; }; + 0C12EA242616383B00B66C86 /* dnnlowp_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dnnlowp_op.h; sourceTree = ""; }; + 0C12EA252616383B00B66C86 /* l2_minimization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = l2_minimization.h; sourceTree = ""; }; + 0C12EA262616383B00B66C86 /* dnnlowp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dnnlowp.h; sourceTree = ""; }; + 0C12EA272616383B00B66C86 /* conv_dnnlowp_acc16_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_dnnlowp_acc16_op.h; sourceTree = ""; }; + 0C12EA282616383B00B66C86 /* transpose.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transpose.h; sourceTree = ""; }; + 0C12EA292616383B00B66C86 /* pool_dnnlowp_op_avx2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pool_dnnlowp_op_avx2.h; sourceTree = ""; }; + 0C12EA2A2616383B00B66C86 /* fully_connected_dnnlowp_acc16_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fully_connected_dnnlowp_acc16_op.h; sourceTree = ""; }; + 0C12EA2C2616383B00B66C86 /* single_op_transform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = single_op_transform.h; sourceTree = ""; }; + 0C12EA2D2616383B00B66C86 /* common_subexpression_elimination.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common_subexpression_elimination.h; sourceTree = ""; }; + 0C12EA2E2616383B00B66C86 /* conv_to_nnpack_transform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv_to_nnpack_transform.h; sourceTree = ""; }; + 0C12EA2F2616383B00B66C86 /* pattern_net_transform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pattern_net_transform.h; sourceTree = ""; }; + 0C12EA342616383B00B66C86 /* libopencl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = libopencl.h; sourceTree = ""; }; + 0C12EA362616383B00B66C86 /* cl_platform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cl_platform.h; sourceTree = ""; }; + 0C12EA372616383B00B66C86 /* opencl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = opencl.h; sourceTree = ""; }; + 0C12EA382616383B00B66C86 /* cl_ext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cl_ext.h; sourceTree = ""; }; + 0C12EA392616383B00B66C86 /* cl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cl.h; sourceTree = ""; }; + 0C12EA3A2616383B00B66C86 /* cl_gl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cl_gl.h; sourceTree = ""; }; + 0C12EA3B2616383B00B66C86 /* cl_gl_ext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cl_gl_ext.h; sourceTree = ""; }; + 0C12EA3E2616383B00B66C86 /* ios_caffe_defines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ios_caffe_defines.h; sourceTree = ""; }; + 0C12EA402616383B00B66C86 /* mpscnn_graph_mask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mpscnn_graph_mask.h; sourceTree = ""; }; + 0C12EA412616383B00B66C86 /* mpscnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mpscnn.h; sourceTree = ""; }; + 0C12EA422616383B00B66C86 /* mpscnn_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mpscnn_test.h; sourceTree = ""; }; + 0C12EA432616383B00B66C86 /* mpscnn_kernels.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mpscnn_kernels.h; sourceTree = ""; }; + 0C12EA442616383B00B66C86 /* mpscnn_context.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mpscnn_context.h; sourceTree = ""; }; + 0C12EA452616383B00B66C86 /* ios_caffe.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ios_caffe.h; sourceTree = ""; }; + 0C12EA462616383B00B66C86 /* ios_caffe_predictor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ios_caffe_predictor.h; sourceTree = ""; }; + 0C12EA482616383B00B66C86 /* snpe_ffi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = snpe_ffi.h; sourceTree = ""; }; + 0C12EA4A2616383B00B66C86 /* nnapi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nnapi.h; sourceTree = ""; }; + 0C12EA4B2616383B00B66C86 /* NeuralNetworks.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NeuralNetworks.h; sourceTree = ""; }; + 0C12EA4C2616383B00B66C86 /* dlnnapi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dlnnapi.h; sourceTree = ""; }; + 0C12EA4E2616383B00B66C86 /* ulp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ulp.h; sourceTree = ""; }; + 0C12EA4F2616383B00B66C86 /* ulp_neon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ulp_neon.h; sourceTree = ""; }; + 0C12EA522616383B00B66C86 /* libvulkan-stub.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "libvulkan-stub.h"; sourceTree = ""; }; + 0C12EA542616383B00B66C86 /* vulkan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan.h; sourceTree = ""; }; + 0C12EA552616383B00B66C86 /* vk_platform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vk_platform.h; sourceTree = ""; }; + 0C12EA582616383B00B66C86 /* fp16_momentum_sgd_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fp16_momentum_sgd_op.h; sourceTree = ""; }; + 0C12EA592616383B00B66C86 /* rmsprop_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rmsprop_op.h; sourceTree = ""; }; + 0C12EA5A2616383B00B66C86 /* lars_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lars_op.h; sourceTree = ""; }; + 0C12EA5B2616383B00B66C86 /* yellowfin_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = yellowfin_op.h; sourceTree = ""; }; + 0C12EA5C2616383B00B66C86 /* math_lp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = math_lp.h; sourceTree = ""; }; + 0C12EA5D2616383B00B66C86 /* storm_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = storm_op.h; sourceTree = ""; }; + 0C12EA5E2616383B00B66C86 /* adagrad_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adagrad_op.h; sourceTree = ""; }; + 0C12EA5F2616383B00B66C86 /* clip_tensor_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = clip_tensor_op.h; sourceTree = ""; }; + 0C12EA602616383B00B66C86 /* gftrl_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gftrl_op.h; sourceTree = ""; }; + 0C12EA612616383B00B66C86 /* adadelta_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adadelta_op.h; sourceTree = ""; }; + 0C12EA622616383B00B66C86 /* learning_rate_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = learning_rate_op.h; sourceTree = ""; }; + 0C12EA632616383B00B66C86 /* adagrad_fused.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adagrad_fused.h; sourceTree = ""; }; + 0C12EA642616383B00B66C86 /* adam_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adam_op.h; sourceTree = ""; }; + 0C12EA652616383B00B66C86 /* ftrl_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ftrl_op.h; sourceTree = ""; }; + 0C12EA662616383B00B66C86 /* weight_scale_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = weight_scale_op.h; sourceTree = ""; }; + 0C12EA672616383B00B66C86 /* learning_rate_adaption_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = learning_rate_adaption_op.h; sourceTree = ""; }; + 0C12EA682616383B00B66C86 /* rowwise_counter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rowwise_counter.h; sourceTree = ""; }; + 0C12EA692616383B00B66C86 /* iter_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = iter_op.h; sourceTree = ""; }; + 0C12EA6A2616383B00B66C86 /* rowwise_adagrad_fused.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rowwise_adagrad_fused.h; sourceTree = ""; }; + 0C12EA6B2616383B00B66C86 /* momentum_sgd_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = momentum_sgd_op.h; sourceTree = ""; }; + 0C12EA6C2616383B00B66C86 /* wngrad_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wngrad_op.h; sourceTree = ""; }; + 0C12EA6D2616383B00B66C86 /* decay_adagrad_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = decay_adagrad_op.h; sourceTree = ""; }; + 0C12EA6E2616383B00B66C86 /* learning_rate_functors.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = learning_rate_functors.h; sourceTree = ""; }; + 0C12EA6F2616383B00B66C86 /* fp32_momentum_sgd_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fp32_momentum_sgd_op.h; sourceTree = ""; }; + 0C12EA712616383B00B66C86 /* blobs_queue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = blobs_queue.h; sourceTree = ""; }; + 0C12EA722616383B00B66C86 /* rebatching_queue_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rebatching_queue_ops.h; sourceTree = ""; }; + 0C12EA732616383B00B66C86 /* queue_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = queue_ops.h; sourceTree = ""; }; + 0C12EA742616383B00B66C86 /* rebatching_queue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rebatching_queue.h; sourceTree = ""; }; + 0C12EA752616383B00B66C86 /* blobs_queue_db.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = blobs_queue_db.h; sourceTree = ""; }; + 0C12EA772616383B00B66C86 /* create_db_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = create_db_op.h; sourceTree = ""; }; + 0C12EA7B2616383B00B66C86 /* ast.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ast.h; sourceTree = ""; }; + 0C12EA7C2616383B00B66C86 /* graphmatcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graphmatcher.h; sourceTree = ""; }; + 0C12EA7D2616383B00B66C86 /* device.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = device.h; sourceTree = ""; }; + 0C12EA7E2616383B00B66C86 /* annotations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = annotations.h; sourceTree = ""; }; + 0C12EA7F2616383B00B66C86 /* mobile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mobile.h; sourceTree = ""; }; + 0C12EA802616383B00B66C86 /* onnxifi_transformer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnxifi_transformer.h; sourceTree = ""; }; + 0C12EA812616383B00B66C86 /* converter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = converter.h; sourceTree = ""; }; + 0C12EA822616383B00B66C86 /* backend_transformer_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = backend_transformer_base.h; sourceTree = ""; }; + 0C12EA832616383B00B66C86 /* fakefp16_transform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fakefp16_transform.h; sourceTree = ""; }; + 0C12EA842616383B00B66C86 /* fusion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fusion.h; sourceTree = ""; }; + 0C12EA852616383B00B66C86 /* shape_info.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = shape_info.h; sourceTree = ""; }; + 0C12EA862616383B00B66C86 /* optimizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = optimizer.h; sourceTree = ""; }; + 0C12EA872616383B00B66C86 /* glow_net_transform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = glow_net_transform.h; sourceTree = ""; }; + 0C12EA882616383B00B66C86 /* backend_cutting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = backend_cutting.h; sourceTree = ""; }; + 0C12EA892616383B00B66C86 /* distributed.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = distributed.h; sourceTree = ""; }; + 0C12EA8A2616383B00B66C86 /* onnxifi_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnxifi_op.h; sourceTree = ""; }; + 0C12EA8B2616383B00B66C86 /* tvm_transformer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tvm_transformer.h; sourceTree = ""; }; + 0C12EA8C2616383B00B66C86 /* passes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = passes.h; sourceTree = ""; }; + 0C12EA8D2616383B00B66C86 /* bound_shape_inferencer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bound_shape_inferencer.h; sourceTree = ""; }; + 0C12EA8F2616383B00B66C86 /* concat_elim.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = concat_elim.h; sourceTree = ""; }; + 0C12EA902616383B00B66C86 /* pointwise_elim.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pointwise_elim.h; sourceTree = ""; }; + 0C12EA912616383B00B66C86 /* freeze_quantization_params.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = freeze_quantization_params.h; sourceTree = ""; }; + 0C12EA922616383B00B66C86 /* in_batch_broadcast.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = in_batch_broadcast.h; sourceTree = ""; }; + 0C12EA932616383B00B66C86 /* cc_amrc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cc_amrc.h; sourceTree = ""; }; + 0C12EA942616383B00B66C86 /* onnx_convert.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnx_convert.h; sourceTree = ""; }; + 0C12EA952616383B00B66C86 /* optimize_ideep.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = optimize_ideep.h; sourceTree = ""; }; + 0C12EA972616383B00B66C86 /* ThreadLocalPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadLocalPtr.h; sourceTree = ""; }; + 0C12EA982616383B00B66C86 /* InferenceGraph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InferenceGraph.h; sourceTree = ""; }; + 0C12EA992616383B00B66C86 /* predictor_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = predictor_utils.h; sourceTree = ""; }; + 0C12EA9A2616383B00B66C86 /* predictor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = predictor.h; sourceTree = ""; }; + 0C12EA9B2616383B00B66C86 /* predictor_config.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = predictor_config.h; sourceTree = ""; }; + 0C12EA9D2616383B00B66C86 /* data_filler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = data_filler.h; sourceTree = ""; }; + 0C12EA9E2616383B00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12EA9F2616383B00B66C86 /* net_supplier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net_supplier.h; sourceTree = ""; }; + 0C12EAA02616383B00B66C86 /* time_profiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = time_profiler.h; sourceTree = ""; }; + 0C12EAA12616383B00B66C86 /* emulator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = emulator.h; sourceTree = ""; }; + 0C12EAA22616383B00B66C86 /* output_formatter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = output_formatter.h; sourceTree = ""; }; + 0C12EAA32616383B00B66C86 /* std_output_formatter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = std_output_formatter.h; sourceTree = ""; }; + 0C12EAA42616383B00B66C86 /* benchmark.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = benchmark.h; sourceTree = ""; }; + 0C12EAA52616383B00B66C86 /* profiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = profiler.h; sourceTree = ""; }; + 0C12EAA62616383B00B66C86 /* transforms.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transforms.h; sourceTree = ""; }; + 0C12EAA82616383B00B66C86 /* operator_attaching_net_observer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator_attaching_net_observer.h; sourceTree = ""; }; + 0C12EAA92616383B00B66C86 /* time_observer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = time_observer.h; sourceTree = ""; }; + 0C12EAAA2616383B00B66C86 /* runcnt_observer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = runcnt_observer.h; sourceTree = ""; }; + 0C12EAAB2616383B00B66C86 /* profile_observer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = profile_observer.h; sourceTree = ""; }; + 0C12EAB12616383B00B66C86 /* quant_decomp_zstd_op.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quant_decomp_zstd_op.h; sourceTree = ""; }; + 0C12EAB22616383B00B66C86 /* cpuinfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cpuinfo.h; sourceTree = ""; }; + 0C12EAB52616383B00B66C86 /* Size.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Size.h; sourceTree = ""; }; + 0C12EAB62616383B00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12EAB72616383B00B66C86 /* Device.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Device.h; sourceTree = ""; }; + 0C12EAB92616383B00B66C86 /* init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = ""; }; + 0C12EABA2616383B00B66C86 /* onnx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnx.h; sourceTree = ""; }; + 0C12EABB2616383B00B66C86 /* Types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Types.h; sourceTree = ""; }; + 0C12EABE2616383B00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12EAC02616383B00B66C86 /* container.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = container.h; sourceTree = ""; }; + 0C12EAC12616383B00B66C86 /* context.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = context.h; sourceTree = ""; }; + 0C12EAC32616383B00B66C86 /* cleanup_autograd_context_req.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cleanup_autograd_context_req.h; sourceTree = ""; }; + 0C12EAC42616383B00B66C86 /* cleanup_autograd_context_resp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cleanup_autograd_context_resp.h; sourceTree = ""; }; + 0C12EAC52616383B00B66C86 /* rref_backward_req.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rref_backward_req.h; sourceTree = ""; }; + 0C12EAC62616383B00B66C86 /* rpc_with_profiling_req.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rpc_with_profiling_req.h; sourceTree = ""; }; + 0C12EAC72616383B00B66C86 /* propagate_gradients_resp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = propagate_gradients_resp.h; sourceTree = ""; }; + 0C12EAC82616383B00B66C86 /* propagate_gradients_req.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = propagate_gradients_req.h; sourceTree = ""; }; + 0C12EAC92616383B00B66C86 /* autograd_metadata.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = autograd_metadata.h; sourceTree = ""; }; + 0C12EACA2616383B00B66C86 /* rpc_with_autograd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rpc_with_autograd.h; sourceTree = ""; }; + 0C12EACB2616383B00B66C86 /* rref_backward_resp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rref_backward_resp.h; sourceTree = ""; }; + 0C12EACC2616383B00B66C86 /* rpc_with_profiling_resp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rpc_with_profiling_resp.h; sourceTree = ""; }; + 0C12EACD2616383B00B66C86 /* python_autograd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_autograd.h; sourceTree = ""; }; + 0C12EACE2616383B00B66C86 /* autograd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = autograd.h; sourceTree = ""; }; + 0C12EAD02616383B00B66C86 /* sendrpc_backward.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sendrpc_backward.h; sourceTree = ""; }; + 0C12EAD12616383B00B66C86 /* recvrpc_backward.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = recvrpc_backward.h; sourceTree = ""; }; + 0C12EAD32616383B00B66C86 /* dist_engine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dist_engine.h; sourceTree = ""; }; + 0C12EAD62616383B00B66C86 /* RpcMetricsHandler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RpcMetricsHandler.h; sourceTree = ""; }; + 0C12EAD72616383B00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12EAD82616383B00B66C86 /* rref_context.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rref_context.h; sourceTree = ""; }; + 0C12EAD92616383B00B66C86 /* request_callback_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = request_callback_impl.h; sourceTree = ""; }; + 0C12EADA2616383B00B66C86 /* python_resp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_resp.h; sourceTree = ""; }; + 0C12EADB2616383B00B66C86 /* rref_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rref_impl.h; sourceTree = ""; }; + 0C12EADC2616383B00B66C86 /* request_callback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = request_callback.h; sourceTree = ""; }; + 0C12EADD2616383B00B66C86 /* types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = types.h; sourceTree = ""; }; + 0C12EADE2616383B00B66C86 /* rref_proto.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rref_proto.h; sourceTree = ""; }; + 0C12EADF2616383B00B66C86 /* py_rref.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = py_rref.h; sourceTree = ""; }; + 0C12EAE02616383B00B66C86 /* rpc_agent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rpc_agent.h; sourceTree = ""; }; + 0C12EAE12616383B00B66C86 /* python_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_functions.h; sourceTree = ""; }; + 0C12EAE22616383B00B66C86 /* message.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = message.h; sourceTree = ""; }; + 0C12EAE32616383B00B66C86 /* request_callback_no_python.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = request_callback_no_python.h; sourceTree = ""; }; + 0C12EAE42616383B00B66C86 /* python_remote_call.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_remote_call.h; sourceTree = ""; }; + 0C12EAE52616383B00B66C86 /* python_call.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_call.h; sourceTree = ""; }; + 0C12EAE62616383B00B66C86 /* tensorpipe_agent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensorpipe_agent.h; sourceTree = ""; }; + 0C12EAE72616383B00B66C86 /* script_remote_call.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = script_remote_call.h; sourceTree = ""; }; + 0C12EAE92616383B00B66C86 /* testing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = testing.h; sourceTree = ""; }; + 0C12EAEA2616383B00B66C86 /* faulty_process_group_agent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = faulty_process_group_agent.h; sourceTree = ""; }; + 0C12EAEB2616383B00B66C86 /* macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = macros.h; sourceTree = ""; }; + 0C12EAEC2616383B00B66C86 /* script_resp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = script_resp.h; sourceTree = ""; }; + 0C12EAED2616383B00B66C86 /* rpc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rpc.h; sourceTree = ""; }; + 0C12EAEE2616383B00B66C86 /* rpc_command_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rpc_command_base.h; sourceTree = ""; }; + 0C12EAF02616383B00B66C86 /* remote_profiler_manager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remote_profiler_manager.h; sourceTree = ""; }; + 0C12EAF12616383B00B66C86 /* server_process_global_profiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = server_process_global_profiler.h; sourceTree = ""; }; + 0C12EAF22616383B00B66C86 /* script_call.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = script_call.h; sourceTree = ""; }; + 0C12EAF32616383B00B66C86 /* unpickled_python_remote_call.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unpickled_python_remote_call.h; sourceTree = ""; }; + 0C12EAF42616383B00B66C86 /* torchscript_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = torchscript_functions.h; sourceTree = ""; }; + 0C12EAF52616383B00B66C86 /* unpickled_python_call.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unpickled_python_call.h; sourceTree = ""; }; + 0C12EAF62616383B00B66C86 /* tensorpipe_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensorpipe_utils.h; sourceTree = ""; }; + 0C12EAF72616383B00B66C86 /* agent_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = agent_utils.h; sourceTree = ""; }; + 0C12EAF82616383B00B66C86 /* process_group_agent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = process_group_agent.h; sourceTree = ""; }; + 0C12EAF92616383B00B66C86 /* python_rpc_handler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_rpc_handler.h; sourceTree = ""; }; + 0C12EAFB2616383B00B66C86 /* python_comm_hook.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_comm_hook.h; sourceTree = ""; }; + 0C12EAFC2616383B00B66C86 /* c10d.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = c10d.h; sourceTree = ""; }; + 0C12EAFF2616383B00B66C86 /* python_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_functions.h; sourceTree = ""; }; + 0C12EB002616383B00B66C86 /* Functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Functions.h; sourceTree = ""; }; + 0C12EB012616383B00B66C86 /* variable_factories.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = variable_factories.h; sourceTree = ""; }; + 0C12EB022616383B00B66C86 /* python_function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_function.h; sourceTree = ""; }; + 0C12EB032616383B00B66C86 /* custom_function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = custom_function.h; sourceTree = ""; }; + 0C12EB042616383B00B66C86 /* python_linalg_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_linalg_functions.h; sourceTree = ""; }; + 0C12EB052616383B00B66C86 /* record_function_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = record_function_ops.h; sourceTree = ""; }; + 0C12EB062616383B00B66C86 /* engine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = engine.h; sourceTree = ""; }; + 0C12EB072616383B00B66C86 /* edge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = edge.h; sourceTree = ""; }; + 0C12EB082616383B00B66C86 /* saved_variable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = saved_variable.h; sourceTree = ""; }; + 0C12EB092616383B00B66C86 /* python_engine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_engine.h; sourceTree = ""; }; + 0C12EB0A2616383B00B66C86 /* python_legacy_variable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_legacy_variable.h; sourceTree = ""; }; + 0C12EB0B2616383B00B66C86 /* python_cpp_function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_cpp_function.h; sourceTree = ""; }; + 0C12EB0C2616383B00B66C86 /* python_hook.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_hook.h; sourceTree = ""; }; + 0C12EB0D2616383B00B66C86 /* VariableTypeUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VariableTypeUtils.h; sourceTree = ""; }; + 0C12EB0E2616383B00B66C86 /* python_autograd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_autograd.h; sourceTree = ""; }; + 0C12EB0F2616383B00B66C86 /* profiler_kineto.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = profiler_kineto.h; sourceTree = ""; }; + 0C12EB102616383B00B66C86 /* variable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = variable.h; sourceTree = ""; }; + 0C12EB122616383B00B66C86 /* wrap_outputs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wrap_outputs.h; sourceTree = ""; }; + 0C12EB132616383B00B66C86 /* python_arg_parsing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_arg_parsing.h; sourceTree = ""; }; + 0C12EB142616383B00B66C86 /* grad_layout_contract.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = grad_layout_contract.h; sourceTree = ""; }; + 0C12EB152616383B00B66C86 /* lambda_post_hook.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lambda_post_hook.h; sourceTree = ""; }; + 0C12EB162616383B00B66C86 /* error_messages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = error_messages.h; sourceTree = ""; }; + 0C12EB172616383B00B66C86 /* python_fft_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_fft_functions.h; sourceTree = ""; }; + 0C12EB182616383B00B66C86 /* python_variable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_variable.h; sourceTree = ""; }; + 0C12EB192616383B00B66C86 /* function_hook.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = function_hook.h; sourceTree = ""; }; + 0C12EB1A2616383B00B66C86 /* input_metadata.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = input_metadata.h; sourceTree = ""; }; + 0C12EB1B2616383B00B66C86 /* grad_mode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = grad_mode.h; sourceTree = ""; }; + 0C12EB1C2616383B00B66C86 /* symbolic.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = symbolic.h; sourceTree = ""; }; + 0C12EB1D2616383B00B66C86 /* input_buffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = input_buffer.h; sourceTree = ""; }; + 0C12EB1E2616383B00B66C86 /* profiler_legacy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = profiler_legacy.h; sourceTree = ""; }; + 0C12EB1F2616383B00B66C86 /* autograd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = autograd.h; sourceTree = ""; }; + 0C12EB202616383B00B66C86 /* cpp_hook.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cpp_hook.h; sourceTree = ""; }; + 0C12EB222616383B00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12EB232616383B00B66C86 /* pybind.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pybind.h; sourceTree = ""; }; + 0C12EB242616383B00B66C86 /* comm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = comm.h; sourceTree = ""; }; + 0C12EB252616383B00B66C86 /* basic_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = basic_ops.h; sourceTree = ""; }; + 0C12EB262616383B00B66C86 /* accumulate_grad.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = accumulate_grad.h; sourceTree = ""; }; + 0C12EB272616383B00B66C86 /* tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor.h; sourceTree = ""; }; + 0C12EB282616383B00B66C86 /* python_special_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_special_functions.h; sourceTree = ""; }; + 0C12EB292616383B00B66C86 /* FunctionsManual.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FunctionsManual.h; sourceTree = ""; }; + 0C12EB2A2616383B00B66C86 /* forward_grad.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = forward_grad.h; sourceTree = ""; }; + 0C12EB2B2616383B00B66C86 /* python_anomaly_mode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_anomaly_mode.h; sourceTree = ""; }; + 0C12EB2C2616383B00B66C86 /* python_nn_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_nn_functions.h; sourceTree = ""; }; + 0C12EB2D2616383B00B66C86 /* InferenceMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InferenceMode.h; sourceTree = ""; }; + 0C12EB2E2616383B00B66C86 /* python_variable_indexing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_variable_indexing.h; sourceTree = ""; }; + 0C12EB2F2616383B00B66C86 /* profiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = profiler.h; sourceTree = ""; }; + 0C12EB302616383B00B66C86 /* function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = function.h; sourceTree = ""; }; + 0C12EB312616383B00B66C86 /* anomaly_mode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = anomaly_mode.h; sourceTree = ""; }; + 0C12EB322616383B00B66C86 /* profiler_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = profiler_utils.h; sourceTree = ""; }; + 0C12EB352616383B00B66C86 /* interpreter_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = interpreter_impl.h; sourceTree = ""; }; + 0C12EB382616383B00B66C86 /* deploy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = deploy.h; sourceTree = ""; }; + 0C12EB3A2616383B00B66C86 /* init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = ""; }; + 0C12EB3C2616383B00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12EB3D2616383B00B66C86 /* THCP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THCP.h; sourceTree = ""; }; + 0C12EB3E2616383B00B66C86 /* nccl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nccl.h; sourceTree = ""; }; + 0C12EB3F2616383B00B66C86 /* python_nccl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_nccl.h; sourceTree = ""; }; + 0C12EB402616383B00B66C86 /* device_set.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = device_set.h; sourceTree = ""; }; + 0C12EB412616383B00B66C86 /* Event.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Event.h; sourceTree = ""; }; + 0C12EB422616383B00B66C86 /* serialization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = serialization.h; sourceTree = ""; }; + 0C12EB432616383B00B66C86 /* python_comm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_comm.h; sourceTree = ""; }; + 0C12EB442616383B00B66C86 /* comm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = comm.h; sourceTree = ""; }; + 0C12EB452616383B00B66C86 /* Stream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Stream.h; sourceTree = ""; }; + 0C12EB472616383B00B66C86 /* undef_macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = undef_macros.h; sourceTree = ""; }; + 0C12EB482616383B00B66C86 /* restore_macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = restore_macros.h; sourceTree = ""; }; + 0C12EB492616383B00B66C86 /* Storage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Storage.h; sourceTree = ""; }; + 0C12EB4A2616383B00B66C86 /* Module.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Module.h; sourceTree = ""; }; + 0C12EB4B2616383B00B66C86 /* override_macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = override_macros.h; sourceTree = ""; }; + 0C12EB4C2616383B00B66C86 /* serialization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = serialization.h; sourceTree = ""; }; + 0C12EB4D2616383B00B66C86 /* Exceptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Exceptions.h; sourceTree = ""; }; + 0C12EB4E2616383B00B66C86 /* QScheme.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = QScheme.h; sourceTree = ""; }; + 0C12EB502616383B00B66C86 /* object_ptr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = object_ptr.h; sourceTree = ""; }; + 0C12EB512616383B00B66C86 /* tensor_numpy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_numpy.h; sourceTree = ""; }; + 0C12EB522616383B00B66C86 /* tensor_dtypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_dtypes.h; sourceTree = ""; }; + 0C12EB532616383B00B66C86 /* python_tuples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_tuples.h; sourceTree = ""; }; + 0C12EB542616383B00B66C86 /* python_numbers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_numbers.h; sourceTree = ""; }; + 0C12EB552616383B00B66C86 /* python_scalars.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_scalars.h; sourceTree = ""; }; + 0C12EB562616383B00B66C86 /* pybind.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pybind.h; sourceTree = ""; }; + 0C12EB572616383B00B66C86 /* tensor_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_types.h; sourceTree = ""; }; + 0C12EB582616383B00B66C86 /* tensor_memoryformats.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_memoryformats.h; sourceTree = ""; }; + 0C12EB592616383B00B66C86 /* python_arg_parser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_arg_parser.h; sourceTree = ""; }; + 0C12EB5A2616383B00B66C86 /* cuda_lazy_init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cuda_lazy_init.h; sourceTree = ""; }; + 0C12EB5B2616383B00B66C86 /* tensor_new.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_new.h; sourceTree = ""; }; + 0C12EB5C2616383B00B66C86 /* tensor_qschemes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_qschemes.h; sourceTree = ""; }; + 0C12EB5D2616383B00B66C86 /* python_dispatch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_dispatch.h; sourceTree = ""; }; + 0C12EB5E2616383B00B66C86 /* tensor_list.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_list.h; sourceTree = ""; }; + 0C12EB5F2616383B00B66C86 /* invalid_arguments.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = invalid_arguments.h; sourceTree = ""; }; + 0C12EB602616383B00B66C86 /* auto_gil.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = auto_gil.h; sourceTree = ""; }; + 0C12EB612616383B00B66C86 /* python_strings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_strings.h; sourceTree = ""; }; + 0C12EB622616383B00B66C86 /* byte_order.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = byte_order.h; sourceTree = ""; }; + 0C12EB632616383B00B66C86 /* pycfunction_helpers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pycfunction_helpers.h; sourceTree = ""; }; + 0C12EB642616383B00B66C86 /* cuda_enabled.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cuda_enabled.h; sourceTree = ""; }; + 0C12EB652616383B00B66C86 /* numpy_stub.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = numpy_stub.h; sourceTree = ""; }; + 0C12EB662616383B00B66C86 /* out_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = out_types.h; sourceTree = ""; }; + 0C12EB672616383B00B66C86 /* memory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = memory.h; sourceTree = ""; }; + 0C12EB682616383B00B66C86 /* tensor_layouts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_layouts.h; sourceTree = ""; }; + 0C12EB692616383B00B66C86 /* structseq.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = structseq.h; sourceTree = ""; }; + 0C12EB6A2616383B00B66C86 /* throughput_benchmark.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = throughput_benchmark.h; sourceTree = ""; }; + 0C12EB6B2616383B00B66C86 /* disable_torch_function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = disable_torch_function.h; sourceTree = ""; }; + 0C12EB6C2616383B00B66C86 /* throughput_benchmark-inl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "throughput_benchmark-inl.h"; sourceTree = ""; }; + 0C12EB6D2616383B00B66C86 /* tensor_flatten.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_flatten.h; sourceTree = ""; }; + 0C12EB6E2616383B00B66C86 /* tensor_apply.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_apply.h; sourceTree = ""; }; + 0C12EB6F2616383B00B66C86 /* init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = ""; }; + 0C12EB702616383B00B66C86 /* python_compat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_compat.h; sourceTree = ""; }; + 0C12EB712616383B00B66C86 /* disallow_copy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = disallow_copy.h; sourceTree = ""; }; + 0C12EB722616383B00B66C86 /* six.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = six.h; sourceTree = ""; }; + 0C12EB732616383B00B66C86 /* python_stub.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_stub.h; sourceTree = ""; }; + 0C12EB742616383B00B66C86 /* variadic.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = variadic.h; sourceTree = ""; }; + 0C12EB752616383B00B66C86 /* Stream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Stream.h; sourceTree = ""; }; + 0C12EB762616383B00B66C86 /* StorageDefs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageDefs.h; sourceTree = ""; }; + 0C12EB772616383B00B66C86 /* DataLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DataLoader.h; sourceTree = ""; }; + 0C12EB782616383B00B66C86 /* THP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THP.h; sourceTree = ""; }; + 0C12EB792616383B00B66C86 /* python_headers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_headers.h; sourceTree = ""; }; + 0C12EB7A2616383B00B66C86 /* Layout.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Layout.h; sourceTree = ""; }; + 0C12EB7B2616383B00B66C86 /* DynamicTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DynamicTypes.h; sourceTree = ""; }; + 0C12EB7C2616383B00B66C86 /* copy_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = copy_utils.h; sourceTree = ""; }; + 0C12EB7F2616383B00B66C86 /* jit_opt_limit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jit_opt_limit.h; sourceTree = ""; }; + 0C12EB812616383B00B66C86 /* error_report.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = error_report.h; sourceTree = ""; }; + 0C12EB822616383B00B66C86 /* source_range.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = source_range.h; sourceTree = ""; }; + 0C12EB832616383B00B66C86 /* edit_distance.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = edit_distance.h; sourceTree = ""; }; + 0C12EB842616383B00B66C86 /* canonicalize_modified_loop.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = canonicalize_modified_loop.h; sourceTree = ""; }; + 0C12EB852616383B00B66C86 /* schema_matching.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = schema_matching.h; sourceTree = ""; }; + 0C12EB862616383B00B66C86 /* function_schema_parser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = function_schema_parser.h; sourceTree = ""; }; + 0C12EB872616383B00B66C86 /* tree_views.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tree_views.h; sourceTree = ""; }; + 0C12EB882616383B00B66C86 /* ir_emitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_emitter.h; sourceTree = ""; }; + 0C12EB892616383B00B66C86 /* parser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parser.h; sourceTree = ""; }; + 0C12EB8A2616383B00B66C86 /* strtod.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = strtod.h; sourceTree = ""; }; + 0C12EB8B2616383B00B66C86 /* tree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tree.h; sourceTree = ""; }; + 0C12EB8C2616383B00B66C86 /* concrete_module_type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = concrete_module_type.h; sourceTree = ""; }; + 0C12EB8D2616383B00B66C86 /* builtin_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = builtin_functions.h; sourceTree = ""; }; + 0C12EB8E2616383B00B66C86 /* exit_transforms.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = exit_transforms.h; sourceTree = ""; }; + 0C12EB8F2616383B00B66C86 /* parse_string_literal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parse_string_literal.h; sourceTree = ""; }; + 0C12EB902616383B00B66C86 /* sugared_value.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sugared_value.h; sourceTree = ""; }; + 0C12EB912616383B00B66C86 /* inline_loop_condition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = inline_loop_condition.h; sourceTree = ""; }; + 0C12EB922616383B00B66C86 /* name_mangler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = name_mangler.h; sourceTree = ""; }; + 0C12EB932616383B00B66C86 /* code_template.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = code_template.h; sourceTree = ""; }; + 0C12EB942616383B00B66C86 /* tracer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tracer.h; sourceTree = ""; }; + 0C12EB952616383B00B66C86 /* resolver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = resolver.h; sourceTree = ""; }; + 0C12EB962616383B00B66C86 /* script_type_parser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = script_type_parser.h; sourceTree = ""; }; + 0C12EB972616383B00B66C86 /* schema_type_parser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = schema_type_parser.h; sourceTree = ""; }; + 0C12EB982616383B00B66C86 /* lexer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lexer.h; sourceTree = ""; }; + 0C12EB992616383B00B66C86 /* versioned_symbols.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = versioned_symbols.h; sourceTree = ""; }; + 0C12EB9A2616383B00B66C86 /* convert_to_ssa.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = convert_to_ssa.h; sourceTree = ""; }; + 0C12EB9B2616383B00B66C86 /* mini_environment.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mini_environment.h; sourceTree = ""; }; + 0C12EB9C2616383B00B66C86 /* parser_constants.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parser_constants.h; sourceTree = ""; }; + 0C12EB9E2616383B00B66C86 /* pybind.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pybind.h; sourceTree = ""; }; + 0C12EB9F2616383B00B66C86 /* python_ir.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_ir.h; sourceTree = ""; }; + 0C12EBA02616383B00B66C86 /* script_init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = script_init.h; sourceTree = ""; }; + 0C12EBA12616383B00B66C86 /* python_tree_views.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_tree_views.h; sourceTree = ""; }; + 0C12EBA22616383B00B66C86 /* python_ivalue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_ivalue.h; sourceTree = ""; }; + 0C12EBA32616383B00B66C86 /* python_custom_class.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_custom_class.h; sourceTree = ""; }; + 0C12EBA42616383B00B66C86 /* update_graph_executor_opt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = update_graph_executor_opt.h; sourceTree = ""; }; + 0C12EBA52616383B00B66C86 /* python_tracer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_tracer.h; sourceTree = ""; }; + 0C12EBA62616383B00B66C86 /* pybind_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pybind_utils.h; sourceTree = ""; }; + 0C12EBA72616383B00B66C86 /* init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = ""; }; + 0C12EBA82616383B00B66C86 /* python_sugared_value.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_sugared_value.h; sourceTree = ""; }; + 0C12EBA92616383B00B66C86 /* python_arg_flatten.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_arg_flatten.h; sourceTree = ""; }; + 0C12EBAA2616383B00B66C86 /* module_python.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = module_python.h; sourceTree = ""; }; + 0C12EBAC2616383B00B66C86 /* ir_mutator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_mutator.h; sourceTree = ""; }; + 0C12EBAD2616383B00B66C86 /* ir_simplifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_simplifier.h; sourceTree = ""; }; + 0C12EBAE2616383B00B66C86 /* ir_visitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_visitor.h; sourceTree = ""; }; + 0C12EBAF2616383B00B66C86 /* llvm_jit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = llvm_jit.h; sourceTree = ""; }; + 0C12EBB02616383B00B66C86 /* tensorexpr_init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensorexpr_init.h; sourceTree = ""; }; + 0C12EBB12616383B00B66C86 /* types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = types.h; sourceTree = ""; }; + 0C12EBB22616383B00B66C86 /* mem_dependency_checker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mem_dependency_checker.h; sourceTree = ""; }; + 0C12EBB32616383B00B66C86 /* ir.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir.h; sourceTree = ""; }; + 0C12EBB42616383B00B66C86 /* exceptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = exceptions.h; sourceTree = ""; }; + 0C12EBB52616383B00B66C86 /* cuda_codegen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cuda_codegen.h; sourceTree = ""; }; + 0C12EBB62616383B00B66C86 /* hash_provider.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hash_provider.h; sourceTree = ""; }; + 0C12EBB72616383B00B66C86 /* ir_printer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_printer.h; sourceTree = ""; }; + 0C12EBB82616383B00B66C86 /* llvm_codegen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = llvm_codegen.h; sourceTree = ""; }; + 0C12EBB92616383B00B66C86 /* expr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = expr.h; sourceTree = ""; }; + 0C12EBBA2616383B00B66C86 /* cuda_random.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cuda_random.h; sourceTree = ""; }; + 0C12EBBB2616383B00B66C86 /* execution_counter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = execution_counter.h; sourceTree = ""; }; + 0C12EBBC2616383B00B66C86 /* codegen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = codegen.h; sourceTree = ""; }; + 0C12EBBD2616383B00B66C86 /* unique_name_manager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unique_name_manager.h; sourceTree = ""; }; + 0C12EBBE2616383B00B66C86 /* cpp_codegen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cpp_codegen.h; sourceTree = ""; }; + 0C12EBBF2616383B00B66C86 /* var_substitutor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = var_substitutor.h; sourceTree = ""; }; + 0C12EBC02616383B00B66C86 /* eval.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = eval.h; sourceTree = ""; }; + 0C12EBC12616383B00B66C86 /* bounds_inference.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bounds_inference.h; sourceTree = ""; }; + 0C12EBC22616383B00B66C86 /* intrinsic_symbols.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = intrinsic_symbols.h; sourceTree = ""; }; + 0C12EBC32616383B00B66C86 /* block_codegen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = block_codegen.h; sourceTree = ""; }; + 0C12EBC42616383B00B66C86 /* external_functions_registry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = external_functions_registry.h; sourceTree = ""; }; + 0C12EBC52616383B00B66C86 /* kernel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kernel.h; sourceTree = ""; }; + 0C12EBC62616383B00B66C86 /* loopnest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = loopnest.h; sourceTree = ""; }; + 0C12EBC72616383B00B66C86 /* bounds_overlap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bounds_overlap.h; sourceTree = ""; }; + 0C12EBC82616383B00B66C86 /* ir_verifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_verifier.h; sourceTree = ""; }; + 0C12EBC92616383B00B66C86 /* dim_arg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dim_arg.h; sourceTree = ""; }; + 0C12EBCA2616383B00B66C86 /* external_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = external_functions.h; sourceTree = ""; }; + 0C12EBCB2616383B00B66C86 /* stmt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stmt.h; sourceTree = ""; }; + 0C12EBCC2616383B00B66C86 /* half_support.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = half_support.h; sourceTree = ""; }; + 0C12EBCD2616383B00B66C86 /* registerizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = registerizer.h; sourceTree = ""; }; + 0C12EBCE2616383B00B66C86 /* reduction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reduction.h; sourceTree = ""; }; + 0C12EBCF2616383B00B66C86 /* tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor.h; sourceTree = ""; }; + 0C12EBD02616383B00B66C86 /* mem_arena.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mem_arena.h; sourceTree = ""; }; + 0C12EBD12616383B00B66C86 /* analysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = analysis.h; sourceTree = ""; }; + 0C12EBD32616383B00B66C86 /* named_value.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = named_value.h; sourceTree = ""; }; + 0C12EBD42616383B00B66C86 /* irparser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = irparser.h; sourceTree = ""; }; + 0C12EBD52616383B00B66C86 /* ir.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir.h; sourceTree = ""; }; + 0C12EBD62616383B00B66C86 /* graph_node_list.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graph_node_list.h; sourceTree = ""; }; + 0C12EBD72616383B00B66C86 /* ir_views.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_views.h; sourceTree = ""; }; + 0C12EBD82616383B00B66C86 /* alias_analysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = alias_analysis.h; sourceTree = ""; }; + 0C12EBD92616383B00B66C86 /* attributes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = attributes.h; sourceTree = ""; }; + 0C12EBDA2616383B00B66C86 /* type_hashing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = type_hashing.h; sourceTree = ""; }; + 0C12EBDB2616383B00B66C86 /* constants.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = constants.h; sourceTree = ""; }; + 0C12EBDC2616383B00B66C86 /* subgraph_matcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = subgraph_matcher.h; sourceTree = ""; }; + 0C12EBDD2616383B00B66C86 /* scope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = scope.h; sourceTree = ""; }; + 0C12EBDE2616383B00B66C86 /* node_hashing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = node_hashing.h; sourceTree = ""; }; + 0C12EBE02616383B00B66C86 /* cuda.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cuda.h; sourceTree = ""; }; + 0C12EBE22616383B00B66C86 /* import_source.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = import_source.h; sourceTree = ""; }; + 0C12EBE32616383B00B66C86 /* export.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = export.h; sourceTree = ""; }; + 0C12EBE42616383B00B66C86 /* import_export_helpers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = import_export_helpers.h; sourceTree = ""; }; + 0C12EBE52616383B00B66C86 /* type_name_uniquer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = type_name_uniquer.h; sourceTree = ""; }; + 0C12EBE62616383B00B66C86 /* pickler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pickler.h; sourceTree = ""; }; + 0C12EBE72616383B00B66C86 /* python_print.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_print.h; sourceTree = ""; }; + 0C12EBE82616383B00B66C86 /* import_legacy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = import_legacy.h; sourceTree = ""; }; + 0C12EBE92616383B00B66C86 /* import_export_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = import_export_functions.h; sourceTree = ""; }; + 0C12EBEA2616383B00B66C86 /* pickle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pickle.h; sourceTree = ""; }; + 0C12EBEB2616383B00B66C86 /* import_export_constants.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = import_export_constants.h; sourceTree = ""; }; + 0C12EBEC2616383B00B66C86 /* source_range_serialization_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = source_range_serialization_impl.h; sourceTree = ""; }; + 0C12EBED2616383B00B66C86 /* import.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = import.h; sourceTree = ""; }; + 0C12EBEE2616383B00B66C86 /* unpickler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unpickler.h; sourceTree = ""; }; + 0C12EBEF2616383B00B66C86 /* source_range_serialization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = source_range_serialization.h; sourceTree = ""; }; + 0C12EBF02616383B00B66C86 /* onnx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnx.h; sourceTree = ""; }; + 0C12EBF22616383B00B66C86 /* backend_interface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = backend_interface.h; sourceTree = ""; }; + 0C12EBF32616383B00B66C86 /* backend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = backend.h; sourceTree = ""; }; + 0C12EBF42616383B00B66C86 /* backend_resolver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = backend_resolver.h; sourceTree = ""; }; + 0C12EBF52616383B00B66C86 /* backend_detail.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = backend_detail.h; sourceTree = ""; }; + 0C12EBF62616383B00B66C86 /* backend_init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = backend_init.h; sourceTree = ""; }; + 0C12EBF82616383B00B66C86 /* slice_indices_adjust.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = slice_indices_adjust.h; sourceTree = ""; }; + 0C12EBF92616383B00B66C86 /* operator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator.h; sourceTree = ""; }; + 0C12EBFA2616383B00B66C86 /* interpreter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = interpreter.h; sourceTree = ""; }; + 0C12EBFB2616383B00B66C86 /* register_ops_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = register_ops_utils.h; sourceTree = ""; }; + 0C12EBFC2616383B00B66C86 /* jit_exception.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jit_exception.h; sourceTree = ""; }; + 0C12EBFD2616383B00B66C86 /* exception_message.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = exception_message.h; sourceTree = ""; }; + 0C12EBFE2616383B00B66C86 /* argument_spec.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = argument_spec.h; sourceTree = ""; }; + 0C12EBFF2616383B00B66C86 /* logging.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = logging.h; sourceTree = ""; }; + 0C12EC002616383B00B66C86 /* profiling_graph_executor_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = profiling_graph_executor_impl.h; sourceTree = ""; }; + 0C12EC012616383B00B66C86 /* custom_operator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = custom_operator.h; sourceTree = ""; }; + 0C12EC032616383B00B66C86 /* fusion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fusion.h; sourceTree = ""; }; + 0C12EC042616383B00B66C86 /* passes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = passes.h; sourceTree = ""; }; + 0C12EC052616383B00B66C86 /* ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ops.h; sourceTree = ""; }; + 0C12EC062616383B00B66C86 /* impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = impl.h; sourceTree = ""; }; + 0C12EC072616383B00B66C86 /* init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = ""; }; + 0C12EC082616383B00B66C86 /* vararg_functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vararg_functions.h; sourceTree = ""; }; + 0C12EC092616383B00B66C86 /* symbolic_script.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = symbolic_script.h; sourceTree = ""; }; + 0C12EC0A2616383B00B66C86 /* variable_tensor_list.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = variable_tensor_list.h; sourceTree = ""; }; + 0C12EC0B2616383B00B66C86 /* autodiff.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = autodiff.h; sourceTree = ""; }; + 0C12EC0C2616383B00B66C86 /* print_handler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = print_handler.h; sourceTree = ""; }; + 0C12EC0D2616383B00B66C86 /* profiling_record.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = profiling_record.h; sourceTree = ""; }; + 0C12EC0E2616383B00B66C86 /* graph_executor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graph_executor.h; sourceTree = ""; }; + 0C12EC0F2616383B00B66C86 /* operator_options.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator_options.h; sourceTree = ""; }; + 0C12EC102616383B00B66C86 /* instruction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = instruction.h; sourceTree = ""; }; + 0C12EC112616383B00B66C86 /* graph_executor_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graph_executor_impl.h; sourceTree = ""; }; + 0C12EC132616383B00B66C86 /* remove_expands.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remove_expands.h; sourceTree = ""; }; + 0C12EC142616383B00B66C86 /* peephole_list_idioms.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = peephole_list_idioms.h; sourceTree = ""; }; + 0C12EC152616383B00B66C86 /* subgraph_rewrite.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = subgraph_rewrite.h; sourceTree = ""; }; + 0C12EC162616383B00B66C86 /* fuse_relu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fuse_relu.h; sourceTree = ""; }; + 0C12EC172616383B00B66C86 /* guard_elimination.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = guard_elimination.h; sourceTree = ""; }; + 0C12EC182616383B00B66C86 /* peephole_alias_sensitive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = peephole_alias_sensitive.h; sourceTree = ""; }; + 0C12EC192616383B00B66C86 /* freeze_module.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = freeze_module.h; sourceTree = ""; }; + 0C12EC1A2616383B00B66C86 /* clear_undefinedness.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = clear_undefinedness.h; sourceTree = ""; }; + 0C12EC1B2616383B00B66C86 /* peephole.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = peephole.h; sourceTree = ""; }; + 0C12EC1C2616383B00B66C86 /* remove_dropout.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remove_dropout.h; sourceTree = ""; }; + 0C12EC1D2616383B00B66C86 /* update_differentiable_graph_requires_grad.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = update_differentiable_graph_requires_grad.h; sourceTree = ""; }; + 0C12EC1E2616383B00B66C86 /* metal_rewrite.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = metal_rewrite.h; sourceTree = ""; }; + 0C12EC1F2616383B00B66C86 /* liveness.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = liveness.h; sourceTree = ""; }; + 0C12EC212616383B00B66C86 /* eval_peephole.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = eval_peephole.h; sourceTree = ""; }; + 0C12EC222616383B00B66C86 /* function_substitution.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = function_substitution.h; sourceTree = ""; }; + 0C12EC232616383B00B66C86 /* helper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = helper.h; sourceTree = ""; }; + 0C12EC242616383B00B66C86 /* unpack_quantized_weights.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unpack_quantized_weights.h; sourceTree = ""; }; + 0C12EC252616383B00B66C86 /* preprocess_for_onnx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = preprocess_for_onnx.h; sourceTree = ""; }; + 0C12EC262616383B00B66C86 /* scalar_type_analysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = scalar_type_analysis.h; sourceTree = ""; }; + 0C12EC272616383B00B66C86 /* shape_type_inference.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = shape_type_inference.h; sourceTree = ""; }; + 0C12EC282616383B00B66C86 /* peephole.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = peephole.h; sourceTree = ""; }; + 0C12EC292616383B00B66C86 /* eliminate_unused_items.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = eliminate_unused_items.h; sourceTree = ""; }; + 0C12EC2A2616383B00B66C86 /* constant_fold.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = constant_fold.h; sourceTree = ""; }; + 0C12EC2B2616383B00B66C86 /* constant_map.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = constant_map.h; sourceTree = ""; }; + 0C12EC2C2616383B00B66C86 /* fixup_onnx_controlflow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fixup_onnx_controlflow.h; sourceTree = ""; }; + 0C12EC2D2616383B00B66C86 /* cast_all_constant_to_floating.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cast_all_constant_to_floating.h; sourceTree = ""; }; + 0C12EC2E2616383B00B66C86 /* fold_if_node.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fold_if_node.h; sourceTree = ""; }; + 0C12EC2F2616383B00B66C86 /* list_model_parameters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = list_model_parameters.h; sourceTree = ""; }; + 0C12EC312616383B00B66C86 /* common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common.h; sourceTree = ""; }; + 0C12EC322616383B00B66C86 /* pattern_conversion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pattern_conversion.h; sourceTree = ""; }; + 0C12EC332616383B00B66C86 /* pattern_encapsulation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pattern_encapsulation.h; sourceTree = ""; }; + 0C12EC342616383B00B66C86 /* remove_inplace_ops_for_onnx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remove_inplace_ops_for_onnx.h; sourceTree = ""; }; + 0C12EC352616383B00B66C86 /* prepare_division_for_onnx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prepare_division_for_onnx.h; sourceTree = ""; }; + 0C12EC362616383B00B66C86 /* remove_mutation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remove_mutation.h; sourceTree = ""; }; + 0C12EC372616383B00B66C86 /* common_subexpression_elimination.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common_subexpression_elimination.h; sourceTree = ""; }; + 0C12EC382616383B00B66C86 /* batch_mm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batch_mm.h; sourceTree = ""; }; + 0C12EC392616383B00B66C86 /* constant_pooling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = constant_pooling.h; sourceTree = ""; }; + 0C12EC3A2616383B00B66C86 /* canonicalize_graph_fuser_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = canonicalize_graph_fuser_ops.h; sourceTree = ""; }; + 0C12EC3B2616383B00B66C86 /* fuse_linear.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fuse_linear.h; sourceTree = ""; }; + 0C12EC3C2616383B00B66C86 /* annotate_warns.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = annotate_warns.h; sourceTree = ""; }; + 0C12EC3D2616383B00B66C86 /* specialize_autogradzero.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = specialize_autogradzero.h; sourceTree = ""; }; + 0C12EC3E2616383B00B66C86 /* prepack_folding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prepack_folding.h; sourceTree = ""; }; + 0C12EC3F2616383B00B66C86 /* frozen_conv_folding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = frozen_conv_folding.h; sourceTree = ""; }; + 0C12EC402616383B00B66C86 /* constant_propagation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = constant_propagation.h; sourceTree = ""; }; + 0C12EC412616383B00B66C86 /* insert_guards.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = insert_guards.h; sourceTree = ""; }; + 0C12EC432616383B00B66C86 /* memory_dag.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = memory_dag.h; sourceTree = ""; }; + 0C12EC442616383B00B66C86 /* subgraph_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = subgraph_utils.h; sourceTree = ""; }; + 0C12EC452616383B00B66C86 /* check_alias_annotation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = check_alias_annotation.h; sourceTree = ""; }; + 0C12EC462616383B00B66C86 /* inliner.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = inliner.h; sourceTree = ""; }; + 0C12EC472616383B00B66C86 /* lower_grad_of.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_grad_of.h; sourceTree = ""; }; + 0C12EC492616383B00B66C86 /* helper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = helper.h; sourceTree = ""; }; + 0C12EC4A2616383B00B66C86 /* quantization_type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quantization_type.h; sourceTree = ""; }; + 0C12EC4B2616383B00B66C86 /* insert_observers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = insert_observers.h; sourceTree = ""; }; + 0C12EC4C2616383B00B66C86 /* dedup_module_uses.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dedup_module_uses.h; sourceTree = ""; }; + 0C12EC4D2616383B00B66C86 /* quantization_patterns.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quantization_patterns.h; sourceTree = ""; }; + 0C12EC4E2616383B00B66C86 /* finalize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = finalize.h; sourceTree = ""; }; + 0C12EC4F2616383B00B66C86 /* insert_quant_dequant.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = insert_quant_dequant.h; sourceTree = ""; }; + 0C12EC502616383B00B66C86 /* fusion_passes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fusion_passes.h; sourceTree = ""; }; + 0C12EC512616383B00B66C86 /* normalize_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = normalize_ops.h; sourceTree = ""; }; + 0C12EC522616383B00B66C86 /* vulkan_rewrite.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_rewrite.h; sourceTree = ""; }; + 0C12EC532616383B00B66C86 /* erase_number_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = erase_number_types.h; sourceTree = ""; }; + 0C12EC542616383B00B66C86 /* graph_rewrite_helper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graph_rewrite_helper.h; sourceTree = ""; }; + 0C12EC552616383B00B66C86 /* graph_fuser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graph_fuser.h; sourceTree = ""; }; + 0C12EC562616383B00B66C86 /* fold_conv_bn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fold_conv_bn.h; sourceTree = ""; }; + 0C12EC572616383B00B66C86 /* remove_redundant_profiles.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remove_redundant_profiles.h; sourceTree = ""; }; + 0C12EC582616383B00B66C86 /* inline_forked_closures.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = inline_forked_closures.h; sourceTree = ""; }; + 0C12EC592616383B00B66C86 /* tensorexpr_fuser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensorexpr_fuser.h; sourceTree = ""; }; + 0C12EC5A2616383B00B66C86 /* decompose_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = decompose_ops.h; sourceTree = ""; }; + 0C12EC5B2616383B00B66C86 /* remove_inplace_ops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remove_inplace_ops.h; sourceTree = ""; }; + 0C12EC5C2616383B00B66C86 /* inline_fork_wait.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = inline_fork_wait.h; sourceTree = ""; }; + 0C12EC5D2616383B00B66C86 /* create_autodiff_subgraphs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = create_autodiff_subgraphs.h; sourceTree = ""; }; + 0C12EC5E2616383B00B66C86 /* requires_grad_analysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = requires_grad_analysis.h; sourceTree = ""; }; + 0C12EC5F2616383B00B66C86 /* dead_code_elimination.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dead_code_elimination.h; sourceTree = ""; }; + 0C12EC602616383B00B66C86 /* clear_profiling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = clear_profiling.h; sourceTree = ""; }; + 0C12EC612616383B00B66C86 /* create_functional_graphs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = create_functional_graphs.h; sourceTree = ""; }; + 0C12EC622616383B00B66C86 /* bailout_graph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bailout_graph.h; sourceTree = ""; }; + 0C12EC632616383B00B66C86 /* lower_tuples.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_tuples.h; sourceTree = ""; }; + 0C12EC642616383B00B66C86 /* frozen_graph_optimizations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = frozen_graph_optimizations.h; sourceTree = ""; }; + 0C12EC652616383B00B66C86 /* frozen_ops_to_mkldnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = frozen_ops_to_mkldnn.h; sourceTree = ""; }; + 0C12EC662616383B00B66C86 /* canonicalize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = canonicalize.h; sourceTree = ""; }; + 0C12EC672616383B00B66C86 /* hoist_conv_packed_params.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hoist_conv_packed_params.h; sourceTree = ""; }; + 0C12EC682616383B00B66C86 /* loop_unrolling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = loop_unrolling.h; sourceTree = ""; }; + 0C12EC692616383B00B66C86 /* shape_analysis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = shape_analysis.h; sourceTree = ""; }; + 0C12EC6A2616383B00B66C86 /* fixup_trace_scope_blocks.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fixup_trace_scope_blocks.h; sourceTree = ""; }; + 0C12EC6B2616383B00B66C86 /* remove_exceptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remove_exceptions.h; sourceTree = ""; }; + 0C12EC6C2616383B00B66C86 /* inline_autodiff_subgraphs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = inline_autodiff_subgraphs.h; sourceTree = ""; }; + 0C12EC6D2616383B00B66C86 /* inplace_check.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = inplace_check.h; sourceTree = ""; }; + 0C12EC6E2616383B00B66C86 /* cuda_graph_fuser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cuda_graph_fuser.h; sourceTree = ""; }; + 0C12EC6F2616383B00B66C86 /* pass_manager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pass_manager.h; sourceTree = ""; }; + 0C12EC702616383B00B66C86 /* onnx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = onnx.h; sourceTree = ""; }; + 0C12EC712616383B00B66C86 /* xnnpack_rewrite.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xnnpack_rewrite.h; sourceTree = ""; }; + 0C12EC722616383B00B66C86 /* lift_closures.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lift_closures.h; sourceTree = ""; }; + 0C12EC732616383B00B66C86 /* frozen_conv_add_relu_fusion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = frozen_conv_add_relu_fusion.h; sourceTree = ""; }; + 0C12EC742616383B00B66C86 /* lower_graph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_graph.h; sourceTree = ""; }; + 0C12EC782616383B00B66C86 /* type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = type.h; sourceTree = ""; }; + 0C12EC792616383B00B66C86 /* executor_kernel_arg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = executor_kernel_arg.h; sourceTree = ""; }; + 0C12EC7A2616383B00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12EC7B2616383B00B66C86 /* kernel_ir_printer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kernel_ir_printer.h; sourceTree = ""; }; + 0C12EC7D2616383B00B66C86 /* index_compute.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = index_compute.h; sourceTree = ""; }; + 0C12EC7E2616383B00B66C86 /* transform_replay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transform_replay.h; sourceTree = ""; }; + 0C12EC7F2616383B00B66C86 /* parser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parser.h; sourceTree = ""; }; + 0C12EC802616383B00B66C86 /* executor_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = executor_utils.h; sourceTree = ""; }; + 0C12EC812616383B00B66C86 /* manager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = manager.h; sourceTree = ""; }; + 0C12EC822616383B00B66C86 /* scheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = scheduler.h; sourceTree = ""; }; + 0C12EC832616383B00B66C86 /* lower_unroll.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_unroll.h; sourceTree = ""; }; + 0C12EC852616383B00B66C86 /* ir_printer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_printer.h; sourceTree = ""; }; + 0C12EC862616383B00B66C86 /* lower_insert_syncs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_insert_syncs.h; sourceTree = ""; }; + 0C12EC872616383B00B66C86 /* lower2device.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower2device.h; sourceTree = ""; }; + 0C12EC882616383B00B66C86 /* predicate_compute.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = predicate_compute.h; sourceTree = ""; }; + 0C12EC892616383B00B66C86 /* compute_at.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = compute_at.h; sourceTree = ""; }; + 0C12EC8A2616383B00B66C86 /* ir_all_nodes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_all_nodes.h; sourceTree = ""; }; + 0C12EC8B2616383B00B66C86 /* mutator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mutator.h; sourceTree = ""; }; + 0C12EC8D2616383B00B66C86 /* documentation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = documentation.h; sourceTree = ""; }; + 0C12EC8F2616383B00B66C86 /* fusion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fusion.h; sourceTree = ""; }; + 0C12EC902616383B00B66C86 /* lower_loops.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_loops.h; sourceTree = ""; }; + 0C12EC912616383B00B66C86 /* interface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = interface.h; sourceTree = ""; }; + 0C12EC922616383B00B66C86 /* arith.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = arith.h; sourceTree = ""; }; + 0C12EC932616383B00B66C86 /* kernel_cache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kernel_cache.h; sourceTree = ""; }; + 0C12EC942616383B00B66C86 /* codegen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = codegen.h; sourceTree = ""; }; + 0C12EC952616383B00B66C86 /* ir_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_utils.h; sourceTree = ""; }; + 0C12EC962616383B00B66C86 /* lower_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_utils.h; sourceTree = ""; }; + 0C12EC972616383B00B66C86 /* lower_index.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_index.h; sourceTree = ""; }; + 0C12EC982616383B00B66C86 /* transform_rfactor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transform_rfactor.h; sourceTree = ""; }; + 0C12EC992616383B00B66C86 /* transform_iter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transform_iter.h; sourceTree = ""; }; + 0C12EC9A2616383B00B66C86 /* lower_alias_memory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_alias_memory.h; sourceTree = ""; }; + 0C12EC9B2616383B00B66C86 /* executor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = executor.h; sourceTree = ""; }; + 0C12EC9C2616383B00B66C86 /* ir_graphviz.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_graphviz.h; sourceTree = ""; }; + 0C12EC9D2616383B00B66C86 /* ir_iostream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_iostream.h; sourceTree = ""; }; + 0C12EC9E2616383B00B66C86 /* partition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = partition.h; sourceTree = ""; }; + 0C12EC9F2616383B00B66C86 /* shape_inference.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = shape_inference.h; sourceTree = ""; }; + 0C12ECA02616383B00B66C86 /* kernel_ir_builder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kernel_ir_builder.h; sourceTree = ""; }; + 0C12ECA12616383B00B66C86 /* instrumentation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = instrumentation.h; sourceTree = ""; }; + 0C12ECA22616383B00B66C86 /* kernel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kernel.h; sourceTree = ""; }; + 0C12ECA32616383B00B66C86 /* dispatch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dispatch.h; sourceTree = ""; }; + 0C12ECA42616383B00B66C86 /* lower_validation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_validation.h; sourceTree = ""; }; + 0C12ECA52616383B00B66C86 /* ir_internal_nodes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_internal_nodes.h; sourceTree = ""; }; + 0C12ECA62616383B00B66C86 /* lower_thread_predicate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lower_thread_predicate.h; sourceTree = ""; }; + 0C12ECA72616383B00B66C86 /* ir_interface_nodes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_interface_nodes.h; sourceTree = ""; }; + 0C12ECA82616383B00B66C86 /* ir_cloner.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_cloner.h; sourceTree = ""; }; + 0C12ECA92616383B00B66C86 /* ir_base_nodes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ir_base_nodes.h; sourceTree = ""; }; + 0C12ECAA2616383B00B66C86 /* executor_launch_params.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = executor_launch_params.h; sourceTree = ""; }; + 0C12ECAB2616383B00B66C86 /* kernel_ir.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kernel_ir.h; sourceTree = ""; }; + 0C12ECAC2616383B00B66C86 /* iter_visitor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = iter_visitor.h; sourceTree = ""; }; + 0C12ECAD2616383B00B66C86 /* expr_evaluator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = expr_evaluator.h; sourceTree = ""; }; + 0C12ECAF2616383B00B66C86 /* tensor_info.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_info.h; sourceTree = ""; }; + 0C12ECB02616383B00B66C86 /* arg_spec.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = arg_spec.h; sourceTree = ""; }; + 0C12ECB12616383B00B66C86 /* compiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = compiler.h; sourceTree = ""; }; + 0C12ECB22616383B00B66C86 /* fallback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fallback.h; sourceTree = ""; }; + 0C12ECB42616383B00B66C86 /* temp_file.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = temp_file.h; sourceTree = ""; }; + 0C12ECB52616383B00B66C86 /* fused_kernel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_kernel.h; sourceTree = ""; }; + 0C12ECB62616383B00B66C86 /* resource_strings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = resource_strings.h; sourceTree = ""; }; + 0C12ECB82616383B00B66C86 /* fused_kernel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_kernel.h; sourceTree = ""; }; + 0C12ECB92616383B00B66C86 /* resource_strings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = resource_strings.h; sourceTree = ""; }; + 0C12ECBA2616383B00B66C86 /* partition_desc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = partition_desc.h; sourceTree = ""; }; + 0C12ECBB2616383B00B66C86 /* fused_kernel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fused_kernel.h; sourceTree = ""; }; + 0C12ECBC2616383B00B66C86 /* kernel_spec.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kernel_spec.h; sourceTree = ""; }; + 0C12ECBD2616383B00B66C86 /* interface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = interface.h; sourceTree = ""; }; + 0C12ECBE2616383B00B66C86 /* kernel_cache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kernel_cache.h; sourceTree = ""; }; + 0C12ECBF2616383B00B66C86 /* codegen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = codegen.h; sourceTree = ""; }; + 0C12ECC02616383B00B66C86 /* executor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = executor.h; sourceTree = ""; }; + 0C12ECC12616383B00B66C86 /* tensor_desc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor_desc.h; sourceTree = ""; }; + 0C12ECC32616383B00B66C86 /* file_check.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = file_check.h; sourceTree = ""; }; + 0C12ECC42616383B00B66C86 /* hooks_for_testing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hooks_for_testing.h; sourceTree = ""; }; + 0C12ECC52616383B00B66C86 /* jit_log.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jit_log.h; sourceTree = ""; }; + 0C12ECC72616383B00B66C86 /* observer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = observer.h; sourceTree = ""; }; + 0C12ECC82616383B00B66C86 /* sequential.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sequential.h; sourceTree = ""; }; + 0C12ECC92616383B00B66C86 /* interpreter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = interpreter.h; sourceTree = ""; }; + 0C12ECCA2616383B00B66C86 /* export_data.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = export_data.h; sourceTree = ""; }; + 0C12ECCB2616383B00B66C86 /* method.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = method.h; sourceTree = ""; }; + 0C12ECCD2616383B00B66C86 /* sgd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sgd.h; sourceTree = ""; }; + 0C12ECCE2616383B00B66C86 /* import_data.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = import_data.h; sourceTree = ""; }; + 0C12ECCF2616383B00B66C86 /* type_parser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = type_parser.h; sourceTree = ""; }; + 0C12ECD02616383B00B66C86 /* import.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = import.h; sourceTree = ""; }; + 0C12ECD12616383B00B66C86 /* module.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = module.h; sourceTree = ""; }; + 0C12ECD22616383B00B66C86 /* function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = function.h; sourceTree = ""; }; + 0C12ECD32616383B00B66C86 /* resource_guard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = resource_guard.h; sourceTree = ""; }; + 0C12ECD52616383B00B66C86 /* function_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = function_impl.h; sourceTree = ""; }; + 0C12ECD62616383B00B66C86 /* method.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = method.h; sourceTree = ""; }; + 0C12ECD72616383B00B66C86 /* compilation_unit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = compilation_unit.h; sourceTree = ""; }; + 0C12ECD82616383B00B66C86 /* object.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = object.h; sourceTree = ""; }; + 0C12ECD92616383B00B66C86 /* module.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = module.h; sourceTree = ""; }; + 0C12ECDA2616383B00B66C86 /* Storage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Storage.h; sourceTree = ""; }; + 0C12ECDE2616383B00B66C86 /* fft.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fft.h; sourceTree = ""; }; + 0C12ECDF2616383B00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12ECE02616383B00B66C86 /* version.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = version.h; sourceTree = ""; }; + 0C12ECE32616383B00B66C86 /* normalization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = normalization.h; sourceTree = ""; }; + 0C12ECE42616383B00B66C86 /* rnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rnn.h; sourceTree = ""; }; + 0C12ECE52616383B00B66C86 /* distance.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = distance.h; sourceTree = ""; }; + 0C12ECE62616383B00B66C86 /* batchnorm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batchnorm.h; sourceTree = ""; }; + 0C12ECE72616383B00B66C86 /* linear.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = linear.h; sourceTree = ""; }; + 0C12ECE82616383B00B66C86 /* instancenorm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = instancenorm.h; sourceTree = ""; }; + 0C12ECE92616383B00B66C86 /* vision.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vision.h; sourceTree = ""; }; + 0C12ECEA2616383B00B66C86 /* transformercoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transformercoder.h; sourceTree = ""; }; + 0C12ECEB2616383B00B66C86 /* dropout.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dropout.h; sourceTree = ""; }; + 0C12ECEC2616383B00B66C86 /* upsampling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = upsampling.h; sourceTree = ""; }; + 0C12ECED2616383B00B66C86 /* embedding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = embedding.h; sourceTree = ""; }; + 0C12ECEE2616383C00B66C86 /* fold.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fold.h; sourceTree = ""; }; + 0C12ECEF2616383C00B66C86 /* activation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = activation.h; sourceTree = ""; }; + 0C12ECF02616383C00B66C86 /* transformer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transformer.h; sourceTree = ""; }; + 0C12ECF12616383C00B66C86 /* pooling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pooling.h; sourceTree = ""; }; + 0C12ECF22616383C00B66C86 /* transformerlayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transformerlayer.h; sourceTree = ""; }; + 0C12ECF32616383C00B66C86 /* adaptive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adaptive.h; sourceTree = ""; }; + 0C12ECF42616383C00B66C86 /* conv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv.h; sourceTree = ""; }; + 0C12ECF52616383C00B66C86 /* padding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = padding.h; sourceTree = ""; }; + 0C12ECF62616383C00B66C86 /* pixelshuffle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pixelshuffle.h; sourceTree = ""; }; + 0C12ECF72616383C00B66C86 /* loss.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = loss.h; sourceTree = ""; }; + 0C12ECF82616383C00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12ECFA2616383C00B66C86 /* data_parallel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = data_parallel.h; sourceTree = ""; }; + 0C12ECFB2616383C00B66C86 /* pimpl-inl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "pimpl-inl.h"; sourceTree = ""; }; + 0C12ECFD2616383C00B66C86 /* rnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rnn.h; sourceTree = ""; }; + 0C12ECFE2616383C00B66C86 /* clip_grad.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = clip_grad.h; sourceTree = ""; }; + 0C12ECFF2616383C00B66C86 /* convert_parameters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = convert_parameters.h; sourceTree = ""; }; + 0C12ED002616383C00B66C86 /* options.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = options.h; sourceTree = ""; }; + 0C12ED012616383C00B66C86 /* functional.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = functional.h; sourceTree = ""; }; + 0C12ED022616383C00B66C86 /* modules.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = modules.h; sourceTree = ""; }; + 0C12ED032616383C00B66C86 /* pimpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pimpl.h; sourceTree = ""; }; + 0C12ED042616383C00B66C86 /* module.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = module.h; sourceTree = ""; }; + 0C12ED062616383C00B66C86 /* normalization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = normalization.h; sourceTree = ""; }; + 0C12ED072616383C00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12ED082616383C00B66C86 /* rnn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rnn.h; sourceTree = ""; }; + 0C12ED092616383C00B66C86 /* distance.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = distance.h; sourceTree = ""; }; + 0C12ED0A2616383C00B66C86 /* batchnorm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batchnorm.h; sourceTree = ""; }; + 0C12ED0B2616383C00B66C86 /* linear.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = linear.h; sourceTree = ""; }; + 0C12ED0C2616383C00B66C86 /* instancenorm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = instancenorm.h; sourceTree = ""; }; + 0C12ED0D2616383C00B66C86 /* transformercoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transformercoder.h; sourceTree = ""; }; + 0C12ED0E2616383C00B66C86 /* _functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _functions.h; sourceTree = ""; }; + 0C12ED102616383C00B66C86 /* named_any.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = named_any.h; sourceTree = ""; }; + 0C12ED112616383C00B66C86 /* any_value.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = any_value.h; sourceTree = ""; }; + 0C12ED122616383C00B66C86 /* modulelist.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = modulelist.h; sourceTree = ""; }; + 0C12ED132616383C00B66C86 /* moduledict.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = moduledict.h; sourceTree = ""; }; + 0C12ED142616383C00B66C86 /* sequential.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sequential.h; sourceTree = ""; }; + 0C12ED152616383C00B66C86 /* functional.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = functional.h; sourceTree = ""; }; + 0C12ED162616383C00B66C86 /* parameterlist.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parameterlist.h; sourceTree = ""; }; + 0C12ED172616383C00B66C86 /* parameterdict.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parameterdict.h; sourceTree = ""; }; + 0C12ED182616383C00B66C86 /* any.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = any.h; sourceTree = ""; }; + 0C12ED192616383C00B66C86 /* any_module_holder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = any_module_holder.h; sourceTree = ""; }; + 0C12ED1A2616383C00B66C86 /* dropout.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dropout.h; sourceTree = ""; }; + 0C12ED1B2616383C00B66C86 /* common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = common.h; sourceTree = ""; }; + 0C12ED1C2616383C00B66C86 /* upsampling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = upsampling.h; sourceTree = ""; }; + 0C12ED1D2616383C00B66C86 /* embedding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = embedding.h; sourceTree = ""; }; + 0C12ED1E2616383C00B66C86 /* fold.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fold.h; sourceTree = ""; }; + 0C12ED1F2616383C00B66C86 /* activation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = activation.h; sourceTree = ""; }; + 0C12ED202616383C00B66C86 /* transformer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transformer.h; sourceTree = ""; }; + 0C12ED212616383C00B66C86 /* pooling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pooling.h; sourceTree = ""; }; + 0C12ED222616383C00B66C86 /* transformerlayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transformerlayer.h; sourceTree = ""; }; + 0C12ED232616383C00B66C86 /* adaptive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adaptive.h; sourceTree = ""; }; + 0C12ED242616383C00B66C86 /* conv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv.h; sourceTree = ""; }; + 0C12ED252616383C00B66C86 /* padding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = padding.h; sourceTree = ""; }; + 0C12ED262616383C00B66C86 /* pixelshuffle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pixelshuffle.h; sourceTree = ""; }; + 0C12ED272616383C00B66C86 /* loss.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = loss.h; sourceTree = ""; }; + 0C12ED282616383C00B66C86 /* init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = ""; }; + 0C12ED292616383C00B66C86 /* cloneable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cloneable.h; sourceTree = ""; }; + 0C12ED2B2616383C00B66C86 /* normalization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = normalization.h; sourceTree = ""; }; + 0C12ED2C2616383C00B66C86 /* distance.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = distance.h; sourceTree = ""; }; + 0C12ED2D2616383C00B66C86 /* batchnorm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = batchnorm.h; sourceTree = ""; }; + 0C12ED2E2616383C00B66C86 /* linear.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = linear.h; sourceTree = ""; }; + 0C12ED2F2616383C00B66C86 /* instancenorm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = instancenorm.h; sourceTree = ""; }; + 0C12ED302616383C00B66C86 /* vision.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vision.h; sourceTree = ""; }; + 0C12ED312616383C00B66C86 /* dropout.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dropout.h; sourceTree = ""; }; + 0C12ED322616383C00B66C86 /* upsampling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = upsampling.h; sourceTree = ""; }; + 0C12ED332616383C00B66C86 /* embedding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = embedding.h; sourceTree = ""; }; + 0C12ED342616383C00B66C86 /* fold.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fold.h; sourceTree = ""; }; + 0C12ED352616383C00B66C86 /* activation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = activation.h; sourceTree = ""; }; + 0C12ED362616383C00B66C86 /* pooling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pooling.h; sourceTree = ""; }; + 0C12ED372616383C00B66C86 /* conv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conv.h; sourceTree = ""; }; + 0C12ED382616383C00B66C86 /* padding.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = padding.h; sourceTree = ""; }; + 0C12ED392616383C00B66C86 /* pixelshuffle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pixelshuffle.h; sourceTree = ""; }; + 0C12ED3A2616383C00B66C86 /* loss.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = loss.h; sourceTree = ""; }; + 0C12ED3C2616383C00B66C86 /* init.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = ""; }; + 0C12ED3D2616383C00B66C86 /* enum.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = enum.h; sourceTree = ""; }; + 0C12ED3E2616383C00B66C86 /* types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = types.h; sourceTree = ""; }; + 0C12ED3F2616383C00B66C86 /* all.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = all.h; sourceTree = ""; }; + 0C12ED402616383C00B66C86 /* data.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = data.h; sourceTree = ""; }; + 0C12ED412616383C00B66C86 /* arg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = arg.h; sourceTree = ""; }; + 0C12ED432616383C00B66C86 /* rmsprop.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rmsprop.h; sourceTree = ""; }; + 0C12ED442616383C00B66C86 /* lbfgs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lbfgs.h; sourceTree = ""; }; + 0C12ED452616383C00B66C86 /* optimizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = optimizer.h; sourceTree = ""; }; + 0C12ED462616383C00B66C86 /* adagrad.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adagrad.h; sourceTree = ""; }; + 0C12ED472616383C00B66C86 /* sgd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sgd.h; sourceTree = ""; }; + 0C12ED482616383C00B66C86 /* serialize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = serialize.h; sourceTree = ""; }; + 0C12ED492616383C00B66C86 /* adamw.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adamw.h; sourceTree = ""; }; + 0C12ED4B2616383C00B66C86 /* lr_scheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lr_scheduler.h; sourceTree = ""; }; + 0C12ED4C2616383C00B66C86 /* step_lr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = step_lr.h; sourceTree = ""; }; + 0C12ED4D2616383C00B66C86 /* adam.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adam.h; sourceTree = ""; }; + 0C12ED4F2616383C00B66C86 /* archive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = archive.h; sourceTree = ""; }; + 0C12ED502616383C00B66C86 /* input-archive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "input-archive.h"; sourceTree = ""; }; + 0C12ED512616383C00B66C86 /* output-archive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "output-archive.h"; sourceTree = ""; }; + 0C12ED522616383C00B66C86 /* tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor.h; sourceTree = ""; }; + 0C12ED532616383C00B66C86 /* torch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = torch.h; sourceTree = ""; }; + 0C12ED542616383C00B66C86 /* optim.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = optim.h; sourceTree = ""; }; + 0C12ED552616383C00B66C86 /* jit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jit.h; sourceTree = ""; }; + 0C12ED572616383C00B66C86 /* static.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = static.h; sourceTree = ""; }; + 0C12ED582616383C00B66C86 /* TensorDataContainer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorDataContainer.h; sourceTree = ""; }; + 0C12ED592616383C00B66C86 /* nn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nn.h; sourceTree = ""; }; + 0C12ED5A2616383C00B66C86 /* ordered_dict.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ordered_dict.h; sourceTree = ""; }; + 0C12ED5B2616383C00B66C86 /* cuda.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cuda.h; sourceTree = ""; }; + 0C12ED5C2616383C00B66C86 /* autograd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = autograd.h; sourceTree = ""; }; + 0C12ED5D2616383C00B66C86 /* linalg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = linalg.h; sourceTree = ""; }; + 0C12ED5E2616383C00B66C86 /* special.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = special.h; sourceTree = ""; }; + 0C12ED5F2616383C00B66C86 /* python.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python.h; sourceTree = ""; }; + 0C12ED602616383C00B66C86 /* serialize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = serialize.h; sourceTree = ""; }; + 0C12ED622616383C00B66C86 /* example.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = example.h; sourceTree = ""; }; + 0C12ED632616383C00B66C86 /* dataloader_options.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dataloader_options.h; sourceTree = ""; }; + 0C12ED652616383C00B66C86 /* mnist.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mnist.h; sourceTree = ""; }; + 0C12ED662616383C00B66C86 /* shared.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = shared.h; sourceTree = ""; }; + 0C12ED672616383C00B66C86 /* map.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = map.h; sourceTree = ""; }; + 0C12ED682616383C00B66C86 /* chunk.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = chunk.h; sourceTree = ""; }; + 0C12ED692616383C00B66C86 /* stateful.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stateful.h; sourceTree = ""; }; + 0C12ED6A2616383C00B66C86 /* tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor.h; sourceTree = ""; }; + 0C12ED6B2616383C00B66C86 /* base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = base.h; sourceTree = ""; }; + 0C12ED6C2616383C00B66C86 /* worker_exception.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = worker_exception.h; sourceTree = ""; }; + 0C12ED6D2616383C00B66C86 /* dataloader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dataloader.h; sourceTree = ""; }; + 0C12ED6F2616383C00B66C86 /* data_shuttle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = data_shuttle.h; sourceTree = ""; }; + 0C12ED702616383C00B66C86 /* sequencers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sequencers.h; sourceTree = ""; }; + 0C12ED712616383C00B66C86 /* queue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = queue.h; sourceTree = ""; }; + 0C12ED722616383C00B66C86 /* samplers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = samplers.h; sourceTree = ""; }; + 0C12ED742616383C00B66C86 /* lambda.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lambda.h; sourceTree = ""; }; + 0C12ED752616383C00B66C86 /* stack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stack.h; sourceTree = ""; }; + 0C12ED762616383C00B66C86 /* collate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = collate.h; sourceTree = ""; }; + 0C12ED772616383C00B66C86 /* tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tensor.h; sourceTree = ""; }; + 0C12ED782616383C00B66C86 /* base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = base.h; sourceTree = ""; }; + 0C12ED7A2616383C00B66C86 /* sequential.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sequential.h; sourceTree = ""; }; + 0C12ED7B2616383C00B66C86 /* custom_batch_request.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = custom_batch_request.h; sourceTree = ""; }; + 0C12ED7C2616383C00B66C86 /* stream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stream.h; sourceTree = ""; }; + 0C12ED7D2616383C00B66C86 /* distributed.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = distributed.h; sourceTree = ""; }; + 0C12ED7E2616383C00B66C86 /* serialize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = serialize.h; sourceTree = ""; }; + 0C12ED7F2616383C00B66C86 /* random.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = random.h; sourceTree = ""; }; + 0C12ED802616383C00B66C86 /* base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = base.h; sourceTree = ""; }; + 0C12ED812616383C00B66C86 /* datasets.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = datasets.h; sourceTree = ""; }; + 0C12ED822616383C00B66C86 /* transforms.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = transforms.h; sourceTree = ""; }; + 0C12ED832616383C00B66C86 /* iterator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = iterator.h; sourceTree = ""; }; + 0C12ED852616383C00B66C86 /* stateless.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stateless.h; sourceTree = ""; }; + 0C12ED862616383C00B66C86 /* stateful.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stateful.h; sourceTree = ""; }; + 0C12ED872616383C00B66C86 /* base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = base.h; sourceTree = ""; }; + 0C12ED882616383C00B66C86 /* expanding_array.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = expanding_array.h; sourceTree = ""; }; + 0C12ED952616383C00B66C86 /* MemoryFormat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MemoryFormat.h; sourceTree = ""; }; + 0C12ED972616383C00B66C86 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = ""; }; + 0C12ED982616383C00B66C86 /* serialization.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = serialization.h; sourceTree = ""; }; + 0C12ED992616383C00B66C86 /* Storage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Storage.h; sourceTree = ""; }; + 0C12ED9B2616383C00B66C86 /* python_tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_tensor.h; sourceTree = ""; }; + 0C12ED9C2616383C00B66C86 /* WindowsTorchApiMacro.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WindowsTorchApiMacro.h; sourceTree = ""; }; + 0C12ED9D2616383C00B66C86 /* Dtype.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Dtype.h; sourceTree = ""; }; + 0C12ED9E2616383C00B66C86 /* Module.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Module.h; sourceTree = ""; }; + 0C12ED9F2616383C00B66C86 /* THP_export.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THP_export.h; sourceTree = ""; }; + 0C12EDA02616383C00B66C86 /* python_dimname.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_dimname.h; sourceTree = ""; }; + 0C12EDA12616383C00B66C86 /* CudaIPCTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CudaIPCTypes.h; sourceTree = ""; }; + 0C12EDA22616383C00B66C86 /* Generator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Generator.h; sourceTree = ""; }; + 0C12EDA32616383C00B66C86 /* TypeInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TypeInfo.h; sourceTree = ""; }; + 0C12EDA42616383C00B66C86 /* PythonTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PythonTypes.h; sourceTree = ""; }; + 0C12EDA52616383C00B66C86 /* script.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = script.h; sourceTree = ""; }; + 0C12EDA62616383C00B66C86 /* library.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = library.h; sourceTree = ""; }; + 0C12EDA72616383C00B66C86 /* custom_class_detail.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = custom_class_detail.h; sourceTree = ""; }; + 0C12EDA82616383C00B66C86 /* custom_class.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = custom_class.h; sourceTree = ""; }; + 0C12EDA92616383C00B66C86 /* extension.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = extension.h; sourceTree = ""; }; + 0C12EDAA2616383C00B66C86 /* xnnpack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xnnpack.h; sourceTree = ""; }; + 0C12EDAB2616383C00B66C86 /* fp16.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fp16.h; sourceTree = ""; }; + 0C12EDAC2616383C00B66C86 /* qnnpack_func.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = qnnpack_func.h; sourceTree = ""; }; + 0C12EDAD2616383C00B66C86 /* pthreadpool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pthreadpool.h; sourceTree = ""; }; + 0C12EDAE2616383C00B66C86 /* clog.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = clog.h; sourceTree = ""; }; + 0C12EDB02616383C00B66C86 /* Formatting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Formatting.h; sourceTree = ""; }; + 0C12EDB12616383C00B66C86 /* CPUFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CPUFunctions.h; sourceTree = ""; }; + 0C12EDB22616383C00B66C86 /* MetaFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MetaFunctions.h; sourceTree = ""; }; + 0C12EDB32616383C00B66C86 /* Utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Utils.h; sourceTree = ""; }; + 0C12EDB42616383C00B66C86 /* CUDAGeneratorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAGeneratorImpl.h; sourceTree = ""; }; + 0C12EDB52616383C00B66C86 /* TensorOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorOptions.h; sourceTree = ""; }; + 0C12EDB62616383C00B66C86 /* TensorUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorUtils.h; sourceTree = ""; }; + 0C12EDB72616383C00B66C86 /* MemoryOverlap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MemoryOverlap.h; sourceTree = ""; }; + 0C12EDB82616383C00B66C86 /* InitialTensorOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InitialTensorOptions.h; sourceTree = ""; }; + 0C12EDB92616383C00B66C86 /* Version.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Version.h; sourceTree = ""; }; + 0C12EDBA2616383C00B66C86 /* DLConvertor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DLConvertor.h; sourceTree = ""; }; + 0C12EDBB2616383C00B66C86 /* Device.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Device.h; sourceTree = ""; }; + 0C12EDBD2616383C00B66C86 /* Dict_inl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Dict_inl.h; sourceTree = ""; }; + 0C12EDBE2616383C00B66C86 /* Formatting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Formatting.h; sourceTree = ""; }; + 0C12EDBF2616383C00B66C86 /* TensorBody.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorBody.h; sourceTree = ""; }; + 0C12EDC12616383C00B66C86 /* adaption.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adaption.h; sourceTree = ""; }; + 0C12EDC22616383C00B66C86 /* op_allowlist.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = op_allowlist.h; sourceTree = ""; }; + 0C12EDC32616383C00B66C86 /* op_registration.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = op_registration.h; sourceTree = ""; }; + 0C12EDC42616383C00B66C86 /* infer_schema.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = infer_schema.h; sourceTree = ""; }; + 0C12EDC52616383C00B66C86 /* jit_type_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jit_type_base.h; sourceTree = ""; }; + 0C12EDC62616383C00B66C86 /* typeid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = typeid.h; sourceTree = ""; }; + 0C12EDC72616383C00B66C86 /* rref_interface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rref_interface.h; sourceTree = ""; }; + 0C12EDC82616383C00B66C86 /* Range.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Range.h; sourceTree = ""; }; + 0C12EDC92616383C00B66C86 /* interned_strings_class.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = interned_strings_class.h; sourceTree = ""; }; + 0C12EDCA2616383C00B66C86 /* operator_name.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = operator_name.h; sourceTree = ""; }; + 0C12EDCB2616383C00B66C86 /* DeprecatedTypePropertiesRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DeprecatedTypePropertiesRegistry.h; sourceTree = ""; }; + 0C12EDCC2616383C00B66C86 /* Backtrace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Backtrace.h; sourceTree = ""; }; + 0C12EDCD2616383C00B66C86 /* TransformationHelper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TransformationHelper.h; sourceTree = ""; }; + 0C12EDCE2616383C00B66C86 /* blob.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = blob.h; sourceTree = ""; }; + 0C12EDCF2616383C00B66C86 /* function_schema.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = function_schema.h; sourceTree = ""; }; + 0C12EDD12616383C00B66C86 /* OperatorOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OperatorOptions.h; sourceTree = ""; }; + 0C12EDD22616383C00B66C86 /* RegistrationHandleRAII.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegistrationHandleRAII.h; sourceTree = ""; }; + 0C12EDD32616383C00B66C86 /* ObservedOperators.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ObservedOperators.h; sourceTree = ""; }; + 0C12EDD42616383C00B66C86 /* DispatchKeyExtractor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DispatchKeyExtractor.h; sourceTree = ""; }; + 0C12EDD52616383C00B66C86 /* Dispatcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Dispatcher.h; sourceTree = ""; }; + 0C12EDD62616383C00B66C86 /* CppSignature.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CppSignature.h; sourceTree = ""; }; + 0C12EDD72616383C00B66C86 /* OperatorEntry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OperatorEntry.h; sourceTree = ""; }; + 0C12EDD82616383C00B66C86 /* MT19937RNGEngine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MT19937RNGEngine.h; sourceTree = ""; }; + 0C12EDD92616383C00B66C86 /* ivalue_to.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ivalue_to.h; sourceTree = ""; }; + 0C12EDDA2616383C00B66C86 /* aten_interned_strings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aten_interned_strings.h; sourceTree = ""; }; + 0C12EDDB2616383C00B66C86 /* LegacyTypeDispatch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LegacyTypeDispatch.h; sourceTree = ""; }; + 0C12EDDC2616383C00B66C86 /* function_schema_inl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = function_schema_inl.h; sourceTree = ""; }; + 0C12EDDD2616383C00B66C86 /* qualified_name.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = qualified_name.h; sourceTree = ""; }; + 0C12EDDE2616383C00B66C86 /* UndefinedTensorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UndefinedTensorImpl.h; sourceTree = ""; }; + 0C12EDDF2616383C00B66C86 /* NamedTensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NamedTensor.h; sourceTree = ""; }; + 0C12EDE02616383C00B66C86 /* Scalar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Scalar.h; sourceTree = ""; }; + 0C12EDE12616383C00B66C86 /* functional.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = functional.h; sourceTree = ""; }; + 0C12EDE22616383C00B66C86 /* DeprecatedTypeProperties.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DeprecatedTypeProperties.h; sourceTree = ""; }; + 0C12EDE32616383C00B66C86 /* interned_strings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = interned_strings.h; sourceTree = ""; }; + 0C12EDE42616383C00B66C86 /* List.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = List.h; sourceTree = ""; }; + 0C12EDE52616383C00B66C86 /* ATenOpList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATenOpList.h; sourceTree = ""; }; + 0C12EDE62616383C00B66C86 /* Dict.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Dict.h; sourceTree = ""; }; + 0C12EDE72616383C00B66C86 /* grad_mode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = grad_mode.h; sourceTree = ""; }; + 0C12EDE82616383C00B66C86 /* DistributionsHelper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DistributionsHelper.h; sourceTree = ""; }; + 0C12EDE92616383C00B66C86 /* Macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Macros.h; sourceTree = ""; }; + 0C12EDEA2616383C00B66C86 /* VariableHooksInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VariableHooksInterface.h; sourceTree = ""; }; + 0C12EDEB2616383C00B66C86 /* ScalarType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScalarType.h; sourceTree = ""; }; + 0C12EDEC2616383C00B66C86 /* Array.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Array.h; sourceTree = ""; }; + 0C12EDED2616383C00B66C86 /* stack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stack.h; sourceTree = ""; }; + 0C12EDEE2616383C00B66C86 /* ATenGeneral.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATenGeneral.h; sourceTree = ""; }; + 0C12EDEF2616383C00B66C86 /* UnsafeFromTH.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UnsafeFromTH.h; sourceTree = ""; }; + 0C12EDF02616383C00B66C86 /* QuantizerBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = QuantizerBase.h; sourceTree = ""; }; + 0C12EDF12616383C00B66C86 /* alias_info.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = alias_info.h; sourceTree = ""; }; + 0C12EDF22616383C00B66C86 /* List_inl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = List_inl.h; sourceTree = ""; }; + 0C12EDF32616383C00B66C86 /* jit_type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = jit_type.h; sourceTree = ""; }; + 0C12EDF42616383C00B66C86 /* ivalue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ivalue.h; sourceTree = ""; }; + 0C12EDF52616383C00B66C86 /* Dimname.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Dimname.h; sourceTree = ""; }; + 0C12EDF62616383C00B66C86 /* Vitals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Vitals.h; sourceTree = ""; }; + 0C12EDF92616383C00B66C86 /* make_boxed_from_unboxed_functor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = make_boxed_from_unboxed_functor.h; sourceTree = ""; }; + 0C12EDFA2616383C00B66C86 /* boxing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = boxing.h; sourceTree = ""; }; + 0C12EDFB2616383C00B66C86 /* test_helpers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = test_helpers.h; sourceTree = ""; }; + 0C12EDFC2616383C00B66C86 /* WrapFunctionIntoFunctor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WrapFunctionIntoFunctor.h; sourceTree = ""; }; + 0C12EDFD2616383C00B66C86 /* WrapFunctionIntoRuntimeFunctor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WrapFunctionIntoRuntimeFunctor.h; sourceTree = ""; }; + 0C12EDFE2616383C00B66C86 /* KernelFunction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = KernelFunction.h; sourceTree = ""; }; + 0C12EDFF2616383C00B66C86 /* KernelFunction_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = KernelFunction_impl.h; sourceTree = ""; }; + 0C12EE002616383C00B66C86 /* builtin_function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = builtin_function.h; sourceTree = ""; }; + 0C12EE012616383C00B66C86 /* DimVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DimVector.h; sourceTree = ""; }; + 0C12EE022616383C00B66C86 /* Reduction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Reduction.h; sourceTree = ""; }; + 0C12EE032616383C00B66C86 /* Tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Tensor.h; sourceTree = ""; }; + 0C12EE042616383C00B66C86 /* function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = function.h; sourceTree = ""; }; + 0C12EE052616383C00B66C86 /* Generator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Generator.h; sourceTree = ""; }; + 0C12EE062616383C00B66C86 /* PhiloxRNGEngine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PhiloxRNGEngine.h; sourceTree = ""; }; + 0C12EE072616383C00B66C86 /* TensorAccessor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorAccessor.h; sourceTree = ""; }; + 0C12EE082616383C00B66C86 /* ivalue_inl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ivalue_inl.h; sourceTree = ""; }; + 0C12EE092616383C00B66C86 /* Variadic.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Variadic.h; sourceTree = ""; }; + 0C12EE0A2616383C00B66C86 /* VmapMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VmapMode.h; sourceTree = ""; }; + 0C12EE0B2616383C00B66C86 /* BatchedFallback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BatchedFallback.h; sourceTree = ""; }; + 0C12EE0C2616383C00B66C86 /* dlpack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dlpack.h; sourceTree = ""; }; + 0C12EE0D2616383C00B66C86 /* Config.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Config.h; sourceTree = ""; }; + 0C12EE0E2616383C00B66C86 /* SparseTensorUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SparseTensorUtils.h; sourceTree = ""; }; + 0C12EE0F2616383C00B66C86 /* Backtrace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Backtrace.h; sourceTree = ""; }; + 0C12EE122616383C00B66C86 /* vec256_bfloat16.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256_bfloat16.h; sourceTree = ""; }; + 0C12EE132616383C00B66C86 /* vec256_float_neon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256_float_neon.h; sourceTree = ""; }; + 0C12EE142616383C00B66C86 /* missing_vst1_neon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = missing_vst1_neon.h; sourceTree = ""; }; + 0C12EE152616383C00B66C86 /* vec256_qint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256_qint.h; sourceTree = ""; }; + 0C12EE162616383C00B66C86 /* intrinsics.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = intrinsics.h; sourceTree = ""; }; + 0C12EE172616383C00B66C86 /* functional.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = functional.h; sourceTree = ""; }; + 0C12EE182616383C00B66C86 /* vec256_complex_float.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256_complex_float.h; sourceTree = ""; }; + 0C12EE192616383C00B66C86 /* vec256_double.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256_double.h; sourceTree = ""; }; + 0C12EE1A2616383C00B66C86 /* vec256_base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256_base.h; sourceTree = ""; }; + 0C12EE1B2616383C00B66C86 /* vec256_float.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256_float.h; sourceTree = ""; }; + 0C12EE1C2616383C00B66C86 /* missing_vld1_neon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = missing_vld1_neon.h; sourceTree = ""; }; + 0C12EE1D2616383C00B66C86 /* vec256.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256.h; sourceTree = ""; }; + 0C12EE1E2616383C00B66C86 /* vec256_int.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256_int.h; sourceTree = ""; }; + 0C12EE1F2616383C00B66C86 /* vec256_complex_double.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vec256_complex_double.h; sourceTree = ""; }; + 0C12EE202616383C00B66C86 /* FlushDenormal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FlushDenormal.h; sourceTree = ""; }; + 0C12EE212616383C00B66C86 /* vml.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vml.h; sourceTree = ""; }; + 0C12EE222616383C00B66C86 /* TracerMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TracerMode.h; sourceTree = ""; }; + 0C12EE232616383C00B66C86 /* Backend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Backend.h; sourceTree = ""; }; + 0C12EE242616383C00B66C86 /* RegistrationDeclarations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegistrationDeclarations.h; sourceTree = ""; }; + 0C12EE252616383C00B66C86 /* CompositeImplicitAutogradFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CompositeImplicitAutogradFunctions.h; sourceTree = ""; }; + 0C12EE262616383C00B66C86 /* PTThreadPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PTThreadPool.h; sourceTree = ""; }; + 0C12EE272616383C00B66C86 /* OpaqueTensorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OpaqueTensorImpl.h; sourceTree = ""; }; + 0C12EE282616383C00B66C86 /* LegacyTHFunctionsCPU.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LegacyTHFunctionsCPU.h; sourceTree = ""; }; + 0C12EE2A2616383C00B66C86 /* QTensorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = QTensorImpl.h; sourceTree = ""; }; + 0C12EE2B2616383C00B66C86 /* Quantizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Quantizer.h; sourceTree = ""; }; + 0C12EE2C2616383C00B66C86 /* record_function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = record_function.h; sourceTree = ""; }; + 0C12EE2D2616383C00B66C86 /* WrapDimUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WrapDimUtils.h; sourceTree = ""; }; + 0C12EE2E2616383C00B66C86 /* RedispatchFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RedispatchFunctions.h; sourceTree = ""; }; + 0C12EE2F2616383C00B66C86 /* Context.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Context.h; sourceTree = ""; }; + 0C12EE302616383C00B66C86 /* div_rtn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = div_rtn.h; sourceTree = ""; }; + 0C12EE312616383C00B66C86 /* ExpandUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ExpandUtils.h; sourceTree = ""; }; + 0C12EE322616383C00B66C86 /* TypeDefault.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TypeDefault.h; sourceTree = ""; }; + 0C12EE332616383C00B66C86 /* CPUFixedAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CPUFixedAllocator.h; sourceTree = ""; }; + 0C12EE342616383C00B66C86 /* NamedTensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NamedTensor.h; sourceTree = ""; }; + 0C12EE352616383C00B66C86 /* Scalar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Scalar.h; sourceTree = ""; }; + 0C12EE362616383C00B66C86 /* ParallelNativeTBB.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParallelNativeTBB.h; sourceTree = ""; }; + 0C12EE372616383C00B66C86 /* ArrayRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ArrayRef.h; sourceTree = ""; }; + 0C12EE382616383C00B66C86 /* SequenceNumber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SequenceNumber.h; sourceTree = ""; }; + 0C12EE392616383C00B66C86 /* MatrixRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MatrixRef.h; sourceTree = ""; }; + 0C12EE3A2616383C00B66C86 /* CompositeExplicitAutogradFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CompositeExplicitAutogradFunctions.h; sourceTree = ""; }; + 0C12EE3B2616383C00B66C86 /* NumericUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NumericUtils.h; sourceTree = ""; }; + 0C12EE3C2616383C00B66C86 /* ATen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ATen.h; sourceTree = ""; }; + 0C12EE3D2616383C00B66C86 /* TensorNames.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorNames.h; sourceTree = ""; }; + 0C12EE3E2616383C00B66C86 /* TensorMeta.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorMeta.h; sourceTree = ""; }; + 0C12EE3F2616383C00B66C86 /* TensorIndexing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorIndexing.h; sourceTree = ""; }; + 0C12EE402616383C00B66C86 /* Layout.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Layout.h; sourceTree = ""; }; + 0C12EE412616383C00B66C86 /* SparseTensorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SparseTensorImpl.h; sourceTree = ""; }; + 0C12EE432616383C00B66C86 /* CUDAHooksInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAHooksInterface.h; sourceTree = ""; }; + 0C12EE442616383C00B66C86 /* FunctionTraits.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FunctionTraits.h; sourceTree = ""; }; + 0C12EE452616383C00B66C86 /* HIPHooksInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HIPHooksInterface.h; sourceTree = ""; }; + 0C12EE462616383C00B66C86 /* WrapDimUtilsMulti.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WrapDimUtilsMulti.h; sourceTree = ""; }; + 0C12EE472616383C00B66C86 /* TensorOperators.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorOperators.h; sourceTree = ""; }; + 0C12EE482616383C00B66C86 /* ScalarType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScalarType.h; sourceTree = ""; }; + 0C12EE492616383C00B66C86 /* cpp_custom_type_hack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cpp_custom_type_hack.h; sourceTree = ""; }; + 0C12EE4A2616383C00B66C86 /* VmapTransforms.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VmapTransforms.h; sourceTree = ""; }; + 0C12EE4B2616383C00B66C86 /* Storage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Storage.h; sourceTree = ""; }; + 0C12EE4C2616383C00B66C86 /* DeviceGuard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DeviceGuard.h; sourceTree = ""; }; + 0C12EE4D2616383C00B66C86 /* ParallelNative.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParallelNative.h; sourceTree = ""; }; + 0C12EE4E2616383C00B66C86 /* Dispatch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Dispatch.h; sourceTree = ""; }; + 0C12EE4F2616383C00B66C86 /* CPUGeneratorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CPUGeneratorImpl.h; sourceTree = ""; }; + 0C12EE502616383C00B66C86 /* Functions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Functions.h; sourceTree = ""; }; + 0C12EE512616383C00B66C86 /* ParallelOpenMP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParallelOpenMP.h; sourceTree = ""; }; + 0C12EE522616383C00B66C86 /* BatchedTensorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BatchedTensorImpl.h; sourceTree = ""; }; + 0C12EE532616383C00B66C86 /* CPUApplyUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CPUApplyUtils.h; sourceTree = ""; }; + 0C12EE542616383C00B66C86 /* ThreadLocalState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadLocalState.h; sourceTree = ""; }; + 0C12EE552616383C00B66C86 /* ScalarOps.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScalarOps.h; sourceTree = ""; }; + 0C12EE562616383C00B66C86 /* NativeFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeFunctions.h; sourceTree = ""; }; + 0C12EE572616383C00B66C86 /* DynamicLibrary.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DynamicLibrary.h; sourceTree = ""; }; + 0C12EE582616383C00B66C86 /* TensorGeometry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorGeometry.h; sourceTree = ""; }; + 0C12EE592616383C00B66C86 /* TensorIterator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorIterator.h; sourceTree = ""; }; + 0C12EE5A2616383C00B66C86 /* NamedTensorUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NamedTensorUtils.h; sourceTree = ""; }; + 0C12EE5B2616383C00B66C86 /* Dimname.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Dimname.h; sourceTree = ""; }; + 0C12EE5C2616383C00B66C86 /* autocast_mode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = autocast_mode.h; sourceTree = ""; }; + 0C12EE5D2616383C00B66C86 /* Parallel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Parallel.h; sourceTree = ""; }; + 0C12EE5E2616383C00B66C86 /* DimVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DimVector.h; sourceTree = ""; }; + 0C12EE5F2616383C00B66C86 /* InferSize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InferSize.h; sourceTree = ""; }; + 0C12EE602616383C00B66C86 /* SmallVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SmallVector.h; sourceTree = ""; }; + 0C12EE612616383C00B66C86 /* Tensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Tensor.h; sourceTree = ""; }; + 0C12EE622616383C00B66C86 /* Generator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Generator.h; sourceTree = ""; }; + 0C12EE632616383C00B66C86 /* AccumulateType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AccumulateType.h; sourceTree = ""; }; + 0C12EE642616383C00B66C86 /* TensorAccessor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorAccessor.h; sourceTree = ""; }; + 0C12EE652616383C00B66C86 /* LegacyTHFunctionsCUDA.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LegacyTHFunctionsCUDA.h; sourceTree = ""; }; + 0C12EE6A2616383C00B66C86 /* InlineStreamGuard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineStreamGuard.h; sourceTree = ""; }; + 0C12EE6B2616383C00B66C86 /* SizesAndStrides.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SizesAndStrides.h; sourceTree = ""; }; + 0C12EE6C2616383C00B66C86 /* InlineDeviceGuard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineDeviceGuard.h; sourceTree = ""; }; + 0C12EE6D2616383C00B66C86 /* LocalDispatchKeySet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalDispatchKeySet.h; sourceTree = ""; }; + 0C12EE6E2616383C00B66C86 /* VirtualGuardImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VirtualGuardImpl.h; sourceTree = ""; }; + 0C12EE6F2616383C00B66C86 /* InlineEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineEvent.h; sourceTree = ""; }; + 0C12EE702616383C00B66C86 /* DeviceGuardImplInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DeviceGuardImplInterface.h; sourceTree = ""; }; + 0C12EE712616383C00B66C86 /* FakeGuardImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FakeGuardImpl.h; sourceTree = ""; }; + 0C12EE722616383C00B66C86 /* QEngine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = QEngine.h; sourceTree = ""; }; + 0C12EE732616383C00B66C86 /* TensorOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorOptions.h; sourceTree = ""; }; + 0C12EE742616383C00B66C86 /* Device.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Device.h; sourceTree = ""; }; + 0C12EE752616383C00B66C86 /* CPUAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CPUAllocator.h; sourceTree = ""; }; + 0C12EE762616383C00B66C86 /* DefaultDtype.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DefaultDtype.h; sourceTree = ""; }; + 0C12EE772616383C00B66C86 /* DefaultTensorOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DefaultTensorOptions.h; sourceTree = ""; }; + 0C12EE782616383C00B66C86 /* Event.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Event.h; sourceTree = ""; }; + 0C12EE792616383C00B66C86 /* Backend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Backend.h; sourceTree = ""; }; + 0C12EE7A2616383C00B66C86 /* CompileTimeFunctionPointer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CompileTimeFunctionPointer.h; sourceTree = ""; }; + 0C12EE7B2616383C00B66C86 /* WrapDimMinimal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WrapDimMinimal.h; sourceTree = ""; }; + 0C12EE7C2616383C00B66C86 /* QScheme.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = QScheme.h; sourceTree = ""; }; + 0C12EE7D2616383C00B66C86 /* Stream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Stream.h; sourceTree = ""; }; + 0C12EE7E2616383C00B66C86 /* UndefinedTensorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UndefinedTensorImpl.h; sourceTree = ""; }; + 0C12EE7F2616383C00B66C86 /* Scalar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Scalar.h; sourceTree = ""; }; + 0C12EE802616383C00B66C86 /* thread_pool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = thread_pool.h; sourceTree = ""; }; + 0C12EE812616383C00B66C86 /* CopyBytes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CopyBytes.h; sourceTree = ""; }; + 0C12EE822616383C00B66C86 /* StreamGuard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StreamGuard.h; sourceTree = ""; }; + 0C12EE832616383C00B66C86 /* Layout.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Layout.h; sourceTree = ""; }; + 0C12EE842616383C00B66C86 /* GeneratorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GeneratorImpl.h; sourceTree = ""; }; + 0C12EE852616383C00B66C86 /* DispatchKeySet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DispatchKeySet.h; sourceTree = ""; }; + 0C12EE862616383C00B66C86 /* Allocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Allocator.h; sourceTree = ""; }; + 0C12EE872616383C00B66C86 /* TensorImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TensorImpl.h; sourceTree = ""; }; + 0C12EE882616383C00B66C86 /* ScalarType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScalarType.h; sourceTree = ""; }; + 0C12EE892616383C00B66C86 /* Storage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Storage.h; sourceTree = ""; }; + 0C12EE8A2616383C00B66C86 /* DeviceType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DeviceType.h; sourceTree = ""; }; + 0C12EE8B2616383C00B66C86 /* DeviceGuard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DeviceGuard.h; sourceTree = ""; }; + 0C12EE8C2616383C00B66C86 /* StorageImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageImpl.h; sourceTree = ""; }; + 0C12EE8D2616383C00B66C86 /* MemoryFormat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MemoryFormat.h; sourceTree = ""; }; + 0C12EE8E2616383C00B66C86 /* DispatchKey.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DispatchKey.h; sourceTree = ""; }; + 0C12EE8F2616383C00B66C86 /* ScalarTypeToTypeMeta.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScalarTypeToTypeMeta.h; sourceTree = ""; }; + 0C12EE902616383C00B66C86 /* InferenceMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InferenceMode.h; sourceTree = ""; }; + 0C12EE952616383C00B66C86 /* complex_test_common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = complex_test_common.h; sourceTree = ""; }; + 0C12EE962616383C00B66C86 /* complex_math_test_common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = complex_math_test_common.h; sourceTree = ""; }; + 0C12EE972616383C00B66C86 /* Macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Macros.h; sourceTree = ""; }; + 0C12EE992616383C00B66C86 /* Type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Type.h; sourceTree = ""; }; + 0C12EE9A2616383C00B66C86 /* order_preserving_flat_hash_map.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = order_preserving_flat_hash_map.h; sourceTree = ""; }; + 0C12EE9B2616383C00B66C86 /* reverse_iterator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = reverse_iterator.h; sourceTree = ""; }; + 0C12EE9C2616383C00B66C86 /* quint4x2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quint4x2.h; sourceTree = ""; }; + 0C12EE9D2616383C00B66C86 /* Half.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Half.h; sourceTree = ""; }; + 0C12EE9E2616383C00B66C86 /* flat_hash_map.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = flat_hash_map.h; sourceTree = ""; }; + 0C12EE9F2616383C00B66C86 /* llvmMathExtras.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = llvmMathExtras.h; sourceTree = ""; }; + 0C12EEA02616383C00B66C86 /* math_compat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = math_compat.h; sourceTree = ""; }; + 0C12EEA12616383C00B66C86 /* Bitset.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Bitset.h; sourceTree = ""; }; + 0C12EEA22616383C00B66C86 /* typeid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = typeid.h; sourceTree = ""; }; + 0C12EEA32616383C00B66C86 /* intrusive_ptr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = intrusive_ptr.h; sourceTree = ""; }; + 0C12EEA42616383C00B66C86 /* string_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = string_utils.h; sourceTree = ""; }; + 0C12EEA52616383C00B66C86 /* win32-headers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "win32-headers.h"; sourceTree = ""; }; + 0C12EEA62616383C00B66C86 /* AlignOf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AlignOf.h; sourceTree = ""; }; + 0C12EEA72616383C00B66C86 /* numa.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = numa.h; sourceTree = ""; }; + 0C12EEA82616383C00B66C86 /* qint32.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = qint32.h; sourceTree = ""; }; + 0C12EEA92616383C00B66C86 /* MaybeOwned.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MaybeOwned.h; sourceTree = ""; }; + 0C12EEAA2616383C00B66C86 /* Half-inl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "Half-inl.h"; sourceTree = ""; }; + 0C12EEAB2616383C00B66C86 /* TypeTraits.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TypeTraits.h; sourceTree = ""; }; + 0C12EEAC2616383C00B66C86 /* FunctionRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FunctionRef.h; sourceTree = ""; }; + 0C12EEAD2616383C00B66C86 /* Backtrace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Backtrace.h; sourceTree = ""; }; + 0C12EEAE2616383C00B66C86 /* BFloat16-inl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "BFloat16-inl.h"; sourceTree = ""; }; + 0C12EEAF2616383C00B66C86 /* in_place.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = in_place.h; sourceTree = ""; }; + 0C12EEB02616383C00B66C86 /* ConstexprCrc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ConstexprCrc.h; sourceTree = ""; }; + 0C12EEB12616383C00B66C86 /* IdWrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IdWrapper.h; sourceTree = ""; }; + 0C12EEB22616383C00B66C86 /* Flags.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Flags.h; sourceTree = ""; }; + 0C12EEB32616383C00B66C86 /* overloaded.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = overloaded.h; sourceTree = ""; }; + 0C12EEB42616383C00B66C86 /* quint8.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = quint8.h; sourceTree = ""; }; + 0C12EEB52616383C00B66C86 /* StringUtil.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringUtil.h; sourceTree = ""; }; + 0C12EEB62616383C00B66C86 /* Logging.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Logging.h; sourceTree = ""; }; + 0C12EEB72616383C00B66C86 /* MathConstants.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MathConstants.h; sourceTree = ""; }; + 0C12EEB82616383C00B66C86 /* Registry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Registry.h; sourceTree = ""; }; + 0C12EEB92616383C00B66C86 /* Optional.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Optional.h; sourceTree = ""; }; + 0C12EEBA2616383C00B66C86 /* tempfile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tempfile.h; sourceTree = ""; }; + 0C12EEBB2616383C00B66C86 /* ArrayRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ArrayRef.h; sourceTree = ""; }; + 0C12EEBC2616383C00B66C86 /* thread_name.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = thread_name.h; sourceTree = ""; }; + 0C12EEBD2616383C00B66C86 /* Unicode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Unicode.h; sourceTree = ""; }; + 0C12EEBE2616383C00B66C86 /* TypeCast.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TypeCast.h; sourceTree = ""; }; + 0C12EEBF2616383C00B66C86 /* sparse_bitset.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sparse_bitset.h; sourceTree = ""; }; + 0C12EEC02616383C00B66C86 /* BFloat16.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BFloat16.h; sourceTree = ""; }; + 0C12EEC12616383C00B66C86 /* TypeList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TypeList.h; sourceTree = ""; }; + 0C12EEC22616383C00B66C86 /* TypeIndex.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TypeIndex.h; sourceTree = ""; }; + 0C12EEC32616383C00B66C86 /* Array.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Array.h; sourceTree = ""; }; + 0C12EEC42616383C00B66C86 /* logging_is_google_glog.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = logging_is_google_glog.h; sourceTree = ""; }; + 0C12EEC52616383C00B66C86 /* Metaprogramming.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Metaprogramming.h; sourceTree = ""; }; + 0C12EEC62616383C00B66C86 /* either.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = either.h; sourceTree = ""; }; + 0C12EEC72616383C00B66C86 /* BFloat16-math.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "BFloat16-math.h"; sourceTree = ""; }; + 0C12EEC82616383C00B66C86 /* Deprecated.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Deprecated.h; sourceTree = ""; }; + 0C12EEC92616383C00B66C86 /* irange.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = irange.h; sourceTree = ""; }; + 0C12EECA2616383C00B66C86 /* LeftRight.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LeftRight.h; sourceTree = ""; }; + 0C12EECB2616383C00B66C86 /* qint8.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = qint8.h; sourceTree = ""; }; + 0C12EECC2616383C00B66C86 /* complex_math.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = complex_math.h; sourceTree = ""; }; + 0C12EECD2616383C00B66C86 /* logging_is_not_google_glog.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = logging_is_not_google_glog.h; sourceTree = ""; }; + 0C12EECE2616383C00B66C86 /* Exception.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Exception.h; sourceTree = ""; }; + 0C12EECF2616383C00B66C86 /* UniqueVoidPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UniqueVoidPtr.h; sourceTree = ""; }; + 0C12EED02616383C00B66C86 /* ThreadLocalDebugInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadLocalDebugInfo.h; sourceTree = ""; }; + 0C12EED12616383C00B66C86 /* accumulate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = accumulate.h; sourceTree = ""; }; + 0C12EED22616383C00B66C86 /* C++17.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "C++17.h"; sourceTree = ""; }; + 0C12EED32616383C00B66C86 /* SmallVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SmallVector.h; sourceTree = ""; }; + 0C12EED42616383C00B66C86 /* hash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hash.h; sourceTree = ""; }; + 0C12EED52616383C00B66C86 /* python_stub.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = python_stub.h; sourceTree = ""; }; + 0C12EED62616383C00B66C86 /* complex.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = complex.h; sourceTree = ""; }; + 0C12EED72616383C00B66C86 /* string_view.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = string_view.h; sourceTree = ""; }; + 0C12EED82616383C00B66C86 /* variant.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = variant.h; sourceTree = ""; }; + 0C12EED92616383C00B66C86 /* complex_utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = complex_utils.h; sourceTree = ""; }; + 0C12EEDC2616383C00B66C86 /* CUDATest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDATest.h; sourceTree = ""; }; + 0C12EEDD2616383C00B66C86 /* CUDAGuardImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAGuardImpl.h; sourceTree = ""; }; + 0C12EEDE2616383C00B66C86 /* CUDAMathCompat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAMathCompat.h; sourceTree = ""; }; + 0C12EEE12616383C00B66C86 /* CUDAStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAStream.h; sourceTree = ""; }; + 0C12EEE22616383C00B66C86 /* CUDAGuard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAGuard.h; sourceTree = ""; }; + 0C12EEE32616383C00B66C86 /* CUDAGraphsC10Utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAGraphsC10Utils.h; sourceTree = ""; }; + 0C12EEE42616383C00B66C86 /* CUDAMacros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAMacros.h; sourceTree = ""; }; + 0C12EEE52616383C00B66C86 /* CUDAFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAFunctions.h; sourceTree = ""; }; + 0C12EEE62616383C00B66C86 /* CUDAException.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDAException.h; sourceTree = ""; }; + 0C12EEE72616383C00B66C86 /* CUDACachingAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CUDACachingAllocator.h; sourceTree = ""; }; + 0C12EEE92616383C00B66C86 /* cmake_macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cmake_macros.h; sourceTree = ""; }; + 0C12EEEA2616383C00B66C86 /* Export.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Export.h; sourceTree = ""; }; + 0C12EEEB2616383C00B66C86 /* Macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Macros.h; sourceTree = ""; }; + 0C12EEED2616383C00B66C86 /* CPUCachingAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CPUCachingAllocator.h; sourceTree = ""; }; + 0C12EEEE2616383C00B66C86 /* CPUProfilingAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CPUProfilingAllocator.h; sourceTree = ""; }; + 0C12EEF02616383C00B66C86 /* psimd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = psimd.h; sourceTree = ""; }; + 0C12EEF12616383C00B66C86 /* fxdiv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fxdiv.h; sourceTree = ""; }; + 0C12EEF32616383C00B66C86 /* avx.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = avx.py; sourceTree = ""; }; + 0C12EEF42616383C00B66C86 /* __init__.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = __init__.py; sourceTree = ""; }; + 0C12EEF52616383C00B66C86 /* fp16.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fp16.h; sourceTree = ""; }; + 0C12EEF62616383C00B66C86 /* avx2.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = avx2.py; sourceTree = ""; }; + 0C12EEF72616383C00B66C86 /* psimd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = psimd.h; sourceTree = ""; }; + 0C12EEF82616383C00B66C86 /* bitcasts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bitcasts.h; sourceTree = ""; }; + 0C12EEFB2616383C00B66C86 /* THCUNN.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THCUNN.h; sourceTree = ""; }; + 0C12EEFD2616383C00B66C86 /* THTensorDimApply.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THTensorDimApply.h; sourceTree = ""; }; + 0C12EEFE2616383C00B66C86 /* THBlas.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THBlas.h; sourceTree = ""; }; + 0C12EEFF2616383C00B66C86 /* THGenerateQUInt8Type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateQUInt8Type.h; sourceTree = ""; }; + 0C12EF002616383C00B66C86 /* THGenerateQInt8Type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateQInt8Type.h; sourceTree = ""; }; + 0C12EF012616383C00B66C86 /* THGenerateComplexTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateComplexTypes.h; sourceTree = ""; }; + 0C12EF022616383C00B66C86 /* THGenerateFloatType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateFloatType.h; sourceTree = ""; }; + 0C12EF032616383C00B66C86 /* THGenerateQInt32Type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateQInt32Type.h; sourceTree = ""; }; + 0C12EF042616383C00B66C86 /* THGenerateDoubleType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateDoubleType.h; sourceTree = ""; }; + 0C12EF052616383C00B66C86 /* THGenerateShortType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateShortType.h; sourceTree = ""; }; + 0C12EF062616383C00B66C86 /* THGenerateIntTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateIntTypes.h; sourceTree = ""; }; + 0C12EF072616383C00B66C86 /* THGenerateLongType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateLongType.h; sourceTree = ""; }; + 0C12EF082616383C00B66C86 /* THGenerateComplexFloatType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateComplexFloatType.h; sourceTree = ""; }; + 0C12EF092616383C00B66C86 /* THAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THAllocator.h; sourceTree = ""; }; + 0C12EF0A2616383C00B66C86 /* THGenerateCharType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateCharType.h; sourceTree = ""; }; + 0C12EF0B2616383C00B66C86 /* THStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THStorage.h; sourceTree = ""; }; + 0C12EF0C2616383C00B66C86 /* THHalf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THHalf.h; sourceTree = ""; }; + 0C12EF0D2616383C00B66C86 /* THGenerateHalfType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateHalfType.h; sourceTree = ""; }; + 0C12EF0E2616383C00B66C86 /* THGenerateIntType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateIntType.h; sourceTree = ""; }; + 0C12EF0F2616383C00B66C86 /* THVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THVector.h; sourceTree = ""; }; + 0C12EF102616383C00B66C86 /* THGeneral.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGeneral.h; sourceTree = ""; }; + 0C12EF112616383C00B66C86 /* THGenerateBoolType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateBoolType.h; sourceTree = ""; }; + 0C12EF122616383C00B66C86 /* THLapack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THLapack.h; sourceTree = ""; }; + 0C12EF132616383C00B66C86 /* THGenerateComplexDoubleType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateComplexDoubleType.h; sourceTree = ""; }; + 0C12EF142616383C00B66C86 /* THGenerateBFloat16Type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateBFloat16Type.h; sourceTree = ""; }; + 0C12EF152616383C00B66C86 /* THGenerateQTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateQTypes.h; sourceTree = ""; }; + 0C12EF162616383C00B66C86 /* THGenerateFloatTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateFloatTypes.h; sourceTree = ""; }; + 0C12EF182616383C00B66C86 /* THBlas.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THBlas.h; sourceTree = ""; }; + 0C12EF192616383C00B66C86 /* THTensor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = THTensor.cpp; sourceTree = ""; }; + 0C12EF1A2616383C00B66C86 /* THTensorMath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = THTensorMath.cpp; sourceTree = ""; }; + 0C12EF1B2616383C00B66C86 /* THTensorMath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THTensorMath.h; sourceTree = ""; }; + 0C12EF1C2616383C00B66C86 /* THStorageCopy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = THStorageCopy.cpp; sourceTree = ""; }; + 0C12EF1D2616383C00B66C86 /* THTensorFastGetSet.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = THTensorFastGetSet.hpp; sourceTree = ""; }; + 0C12EF1E2616383C00B66C86 /* THStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THStorage.h; sourceTree = ""; }; + 0C12EF1F2616383C00B66C86 /* THTensorLapack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THTensorLapack.h; sourceTree = ""; }; + 0C12EF202616383C00B66C86 /* THVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THVector.h; sourceTree = ""; }; + 0C12EF212616383C00B66C86 /* THLapack.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = THLapack.cpp; sourceTree = ""; }; + 0C12EF222616383C00B66C86 /* THStorageCopy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THStorageCopy.h; sourceTree = ""; }; + 0C12EF232616383C00B66C86 /* THLapack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THLapack.h; sourceTree = ""; }; + 0C12EF242616383C00B66C86 /* THStorage.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = THStorage.cpp; sourceTree = ""; }; + 0C12EF252616383C00B66C86 /* THTensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THTensor.h; sourceTree = ""; }; + 0C12EF262616383C00B66C86 /* THBlas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = THBlas.cpp; sourceTree = ""; }; + 0C12EF272616383C00B66C86 /* THTensorLapack.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = THTensorLapack.cpp; sourceTree = ""; }; + 0C12EF282616383C00B66C86 /* THTensor.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = THTensor.hpp; sourceTree = ""; }; + 0C12EF292616383C00B66C86 /* THTensor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THTensor.h; sourceTree = ""; }; + 0C12EF2A2616383C00B66C86 /* TH.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TH.h; sourceTree = ""; }; + 0C12EF2B2616383C00B66C86 /* THTensorApply.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THTensorApply.h; sourceTree = ""; }; + 0C12EF2C2616383C00B66C86 /* THStorageFunctions.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = THStorageFunctions.hpp; sourceTree = ""; }; + 0C12EF2D2616383C00B66C86 /* THGenerateAllTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateAllTypes.h; sourceTree = ""; }; + 0C12EF2E2616383C00B66C86 /* THTensor.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = THTensor.hpp; sourceTree = ""; }; + 0C12EF2F2616383C00B66C86 /* THGenerateByteType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateByteType.h; sourceTree = ""; }; + 0C12EF302616383C00B66C86 /* THStorageFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THStorageFunctions.h; sourceTree = ""; }; + 0C12EF312616383C00B66C86 /* THGenerateQUInt4x2Type.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = THGenerateQUInt4x2Type.h; sourceTree = ""; }; + 0C12EF332616383C00B66C86 /* libtorch_cpu.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libtorch_cpu.a; sourceTree = ""; }; + 0C12EF342616383C00B66C86 /* libtorch.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libtorch.a; sourceTree = ""; }; + 0C12EF352616383C00B66C86 /* libcpuinfo.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libcpuinfo.a; sourceTree = ""; }; + 0C12EF362616383C00B66C86 /* libXNNPACK.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libXNNPACK.a; sourceTree = ""; }; + 0C12EF372616383C00B66C86 /* libtorchvision_ops.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libtorchvision_ops.a; sourceTree = ""; }; + 0C12EF382616383C00B66C86 /* libpthreadpool.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libpthreadpool.a; sourceTree = ""; }; + 0C12EF392616383C00B66C86 /* libc10.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libc10.a; sourceTree = ""; }; + 0C12EF3A2616383C00B66C86 /* libeigen_blas.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libeigen_blas.a; sourceTree = ""; }; + 0C12EF3B2616383C00B66C86 /* libclog.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libclog.a; sourceTree = ""; }; + 0C12EF3C2616383C00B66C86 /* libpytorch_qnnpack.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libpytorch_qnnpack.a; sourceTree = ""; }; + 0C12EF7526163B7600B66C86 /* frcnn_mnetv3.pt */ = {isa = PBXFileReference; lastKnownFileType = file; path = frcnn_mnetv3.pt; sourceTree = ""; }; + 0CEB0ABB26151A8800F1F7D5 /* VisionTestApp.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = VisionTestApp.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 0CEB0ABE26151A8800F1F7D5 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = ""; }; + 0CEB0ABF26151A8800F1F7D5 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = ""; }; + 0CEB0AC426151A8800F1F7D5 /* ViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ViewController.h; sourceTree = ""; }; + 0CEB0AC526151A8800F1F7D5 /* ViewController.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = ViewController.mm; sourceTree = ""; }; + 0CEB0AC826151A8800F1F7D5 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = ""; }; + 0CEB0ACA26151A8900F1F7D5 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; + 0CEB0ACD26151A8900F1F7D5 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; + 0CEB0ACF26151A8900F1F7D5 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + 0CEB0AD026151A8900F1F7D5 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; + 0CEB0B3826152ED900F1F7D5 /* ModelRunner.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ModelRunner.h; sourceTree = ""; }; + 0CEB0B3926152ED900F1F7D5 /* ModelRunner.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = ModelRunner.mm; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 0CEB0AB826151A8800F1F7D5 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 0C12EF502616383D00B66C86 /* libpytorch_qnnpack.a in Frameworks */, + 0C12EF4C2616383D00B66C86 /* libpthreadpool.a in Frameworks */, + 0C12EF4F2616383D00B66C86 /* libclog.a in Frameworks */, + 0C12EF482616383D00B66C86 /* libtorch.a in Frameworks */, + 0C12EF4A2616383D00B66C86 /* libXNNPACK.a in Frameworks */, + 0C12EF472616383D00B66C86 /* libtorch_cpu.a in Frameworks */, + 0C12EF7A26163C7C00B66C86 /* libtorchvision_ops.a in Frameworks */, + 0C12EF492616383D00B66C86 /* libcpuinfo.a in Frameworks */, + 0C12EF4E2616383D00B66C86 /* libeigen_blas.a in Frameworks */, + 0C12EF4D2616383D00B66C86 /* libc10.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 0C12E7872616383A00B66C86 /* install */ = { + isa = PBXGroup; + children = ( + 0C12E7882616383A00B66C86 /* include */, + 0C12EF322616383C00B66C86 /* lib */, + ); + path = install; + sourceTree = ""; + }; + 0C12E7882616383A00B66C86 /* include */ = { + isa = PBXGroup; + children = ( + 0C12E7892616383A00B66C86 /* pybind11 */, + 0C12E7A32616383A00B66C86 /* caffe2 */, + 0C12EAB22616383B00B66C86 /* cpuinfo.h */, + 0C12EAB32616383B00B66C86 /* torch */, + 0C12EDAA2616383C00B66C86 /* xnnpack.h */, + 0C12EDAB2616383C00B66C86 /* fp16.h */, + 0C12EDAC2616383C00B66C86 /* qnnpack_func.h */, + 0C12EDAD2616383C00B66C86 /* pthreadpool.h */, + 0C12EDAE2616383C00B66C86 /* clog.h */, + 0C12EDAF2616383C00B66C86 /* ATen */, + 0C12EE662616383C00B66C86 /* c10 */, + 0C12EEF02616383C00B66C86 /* psimd.h */, + 0C12EEF12616383C00B66C86 /* fxdiv.h */, + 0C12EEF22616383C00B66C86 /* fp16 */, + 0C12EEF92616383C00B66C86 /* THCUNN */, + 0C12EEFC2616383C00B66C86 /* TH */, + ); + path = include; + sourceTree = ""; + }; + 0C12E7892616383A00B66C86 /* pybind11 */ = { + isa = PBXGroup; + children = ( + 0C12E78A2616383A00B66C86 /* attr.h */, + 0C12E78B2616383A00B66C86 /* embed.h */, + 0C12E78C2616383A00B66C86 /* numpy.h */, + 0C12E78D2616383A00B66C86 /* pybind11.h */, + 0C12E78E2616383A00B66C86 /* operators.h */, + 0C12E78F2616383A00B66C86 /* iostream.h */, + 0C12E7902616383A00B66C86 /* chrono.h */, + 0C12E7912616383A00B66C86 /* stl_bind.h */, + 0C12E7922616383A00B66C86 /* buffer_info.h */, + 0C12E7932616383A00B66C86 /* options.h */, + 0C12E7942616383A00B66C86 /* functional.h */, + 0C12E7952616383A00B66C86 /* stl.h */, + 0C12E7962616383A00B66C86 /* detail */, + 0C12E79D2616383A00B66C86 /* common.h */, + 0C12E79E2616383A00B66C86 /* eval.h */, + 0C12E79F2616383A00B66C86 /* cast.h */, + 0C12E7A02616383A00B66C86 /* eigen.h */, + 0C12E7A12616383A00B66C86 /* pytypes.h */, + 0C12E7A22616383A00B66C86 /* complex.h */, + ); + path = pybind11; + sourceTree = ""; + }; + 0C12E7962616383A00B66C86 /* detail */ = { + isa = PBXGroup; + children = ( + 0C12E7972616383A00B66C86 /* typeid.h */, + 0C12E7982616383A00B66C86 /* descr.h */, + 0C12E7992616383A00B66C86 /* internals.h */, + 0C12E79A2616383A00B66C86 /* common.h */, + 0C12E79B2616383A00B66C86 /* class.h */, + 0C12E79C2616383A00B66C86 /* init.h */, + ); + path = detail; + sourceTree = ""; + }; + 0C12E7A32616383A00B66C86 /* caffe2 */ = { + isa = PBXGroup; + children = ( + 0C12E7A42616383A00B66C86 /* video */, + 0C12E7A92616383A00B66C86 /* ideep */, + 0C12E7B32616383A00B66C86 /* core */, + 0C12E80E2616383A00B66C86 /* mpi */, + 0C12E8112616383A00B66C86 /* proto */, + 0C12E8142616383A00B66C86 /* test */, + 0C12E8162616383A00B66C86 /* operators */, + 0C12E9432616383A00B66C86 /* onnx */, + 0C12E9502616383A00B66C86 /* python */, + 0C12E9702616383A00B66C86 /* distributed */, + 0C12E9772616383A00B66C86 /* perfkernels */, + 0C12E9852616383A00B66C86 /* experiments */, + 0C12E9902616383A00B66C86 /* cuda_rtc */, + 0C12E9922616383A00B66C86 /* serialize */, + 0C12E9992616383A00B66C86 /* utils */, + 0C12E9BE2616383B00B66C86 /* contrib */, + 0C12E9F72616383B00B66C86 /* image */, + 0C12E9FA2616383B00B66C86 /* quantization */, + 0C12EA2B2616383B00B66C86 /* transforms */, + 0C12EA302616383B00B66C86 /* mobile */, + 0C12EA572616383B00B66C86 /* sgd */, + 0C12EA702616383B00B66C86 /* queue */, + 0C12EA762616383B00B66C86 /* db */, + 0C12EA782616383B00B66C86 /* opt */, + 0C12EA962616383B00B66C86 /* predictor */, + 0C12EAA72616383B00B66C86 /* observers */, + 0C12EAAC2616383B00B66C86 /* share */, + ); + path = caffe2; + sourceTree = ""; + }; + 0C12E7A42616383A00B66C86 /* video */ = { + isa = PBXGroup; + children = ( + 0C12E7A52616383A00B66C86 /* optical_flow.h */, + 0C12E7A62616383A00B66C86 /* video_decoder.h */, + 0C12E7A72616383A00B66C86 /* video_input_op.h */, + 0C12E7A82616383A00B66C86 /* video_io.h */, + ); + path = video; + sourceTree = ""; + }; + 0C12E7A92616383A00B66C86 /* ideep */ = { + isa = PBXGroup; + children = ( + 0C12E7AA2616383A00B66C86 /* operators */, + 0C12E7AF2616383A00B66C86 /* utils */, + 0C12E7B22616383A00B66C86 /* ideep_utils.h */, + ); + path = ideep; + sourceTree = ""; + }; + 0C12E7AA2616383A00B66C86 /* operators */ = { + isa = PBXGroup; + children = ( + 0C12E7AB2616383A00B66C86 /* conv_transpose_unpool_base_op.h */, + 0C12E7AC2616383A00B66C86 /* quantization */, + 0C12E7AD2616383A00B66C86 /* operator_fallback_ideep.h */, + 0C12E7AE2616383A00B66C86 /* conv_pool_base_op.h */, + ); + path = operators; + sourceTree = ""; + }; + 0C12E7AC2616383A00B66C86 /* quantization */ = { + isa = PBXGroup; + children = ( + ); + path = quantization; + sourceTree = ""; + }; + 0C12E7AF2616383A00B66C86 /* utils */ = { + isa = PBXGroup; + children = ( + 0C12E7B02616383A00B66C86 /* ideep_context.h */, + 0C12E7B12616383A00B66C86 /* ideep_operator.h */, + ); + path = utils; + sourceTree = ""; + }; + 0C12E7B32616383A00B66C86 /* core */ = { + isa = PBXGroup; + children = ( + 0C12E7B42616383A00B66C86 /* net_async_task_graph.h */, + 0C12E7B52616383A00B66C86 /* net_simple_refcount.h */, + 0C12E7B62616383A00B66C86 /* tensor_impl.h */, + 0C12E7B72616383A00B66C86 /* plan_executor.h */, + 0C12E7B82616383A00B66C86 /* qtensor_serialization.h */, + 0C12E7B92616383A00B66C86 /* context_gpu.h */, + 0C12E7BA2616383A00B66C86 /* observer.h */, + 0C12E7BB2616383A00B66C86 /* blob_serializer_base.h */, + 0C12E7BC2616383A00B66C86 /* memonger.h */, + 0C12E7BD2616383A00B66C86 /* tensor_int8.h */, + 0C12E7BE2616383A00B66C86 /* static_tracepoint.h */, + 0C12E7BF2616383A00B66C86 /* net.h */, + 0C12E7C02616383A00B66C86 /* numa.h */, + 0C12E7C12616383A00B66C86 /* scope_guard.h */, + 0C12E7C22616383A00B66C86 /* test_utils.h */, + 0C12E7C32616383A00B66C86 /* event.h */, + 0C12E7C42616383A00B66C86 /* types.h */, + 0C12E7C52616383A00B66C86 /* context_base.h */, + 0C12E7C62616383A00B66C86 /* operator.h */, + 0C12E7C72616383A00B66C86 /* db.h */, + 0C12E7C82616383A00B66C86 /* blob.h */, + 0C12E7C92616383A00B66C86 /* static_tracepoint_elfx86.h */, + 0C12E7CA2616383A00B66C86 /* net_async_tracing.h */, + 0C12E7CB2616383A00B66C86 /* flags.h */, + 0C12E7CC2616383A00B66C86 /* net_async_task_future.h */, + 0C12E7CD2616383A00B66C86 /* operator_schema.h */, + 0C12E7CE2616383A00B66C86 /* context.h */, + 0C12E7CF2616383A00B66C86 /* net_async_base.h */, + 0C12E7D02616383A00B66C86 /* prof_dag_counters.h */, + 0C12E7D12616383A00B66C86 /* logging.h */, + 0C12E7D22616383A00B66C86 /* net_async_scheduling.h */, + 0C12E7D32616383A00B66C86 /* graph.h */, + 0C12E7D42616383A00B66C86 /* common_cudnn.h */, + 0C12E7D52616383A00B66C86 /* net_async_task.h */, + 0C12E7D62616383A00B66C86 /* export_caffe2_op_to_c10.h */, + 0C12E7D72616383A00B66C86 /* net_simple.h */, + 0C12E7D82616383A00B66C86 /* workspace.h */, + 0C12E7D92616383A00B66C86 /* timer.h */, + 0C12E7DA2616383A00B66C86 /* event_cpu.h */, + 0C12E7DB2616383A00B66C86 /* common.h */, + 0C12E7DC2616383A00B66C86 /* blob_stats.h */, + 0C12E7DD2616383A00B66C86 /* allocator.h */, + 0C12E7DE2616383A00B66C86 /* macros.h */, + 0C12E7DF2616383A00B66C86 /* hip */, + 0C12E7E22616383A00B66C86 /* storage.h */, + 0C12E7E32616383A00B66C86 /* transform.h */, + 0C12E7E42616383A00B66C86 /* common_omp.h */, + 0C12E7E52616383A00B66C86 /* export_c10_op_to_caffe2.h */, + 0C12E7E62616383A00B66C86 /* nomnigraph */, + 0C12E8022616383A00B66C86 /* module.h */, + 0C12E8032616383A00B66C86 /* init.h */, + 0C12E8042616383A00B66C86 /* net_dag_utils.h */, + 0C12E8052616383A00B66C86 /* stats.h */, + 0C12E8062616383A00B66C86 /* tensor.h */, + 0C12E8072616383A00B66C86 /* common_gpu.h */, + 0C12E8082616383A00B66C86 /* qtensor.h */, + 0C12E8092616383A00B66C86 /* net_parallel.h */, + 0C12E80A2616383A00B66C86 /* operator_gradient.h */, + 0C12E80B2616383A00B66C86 /* cudnn_wrappers.h */, + 0C12E80C2616383A00B66C86 /* distributions_stubs.h */, + 0C12E80D2616383A00B66C86 /* blob_serialization.h */, + ); + path = core; + sourceTree = ""; + }; + 0C12E7DF2616383A00B66C86 /* hip */ = { + isa = PBXGroup; + children = ( + 0C12E7E02616383A00B66C86 /* miopen_wrapper.h */, + 0C12E7E12616383A00B66C86 /* common_miopen.h */, + ); + path = hip; + sourceTree = ""; + }; + 0C12E7E62616383A00B66C86 /* nomnigraph */ = { + isa = PBXGroup; + children = ( + 0C12E7E72616383A00B66C86 /* Representations */, + 0C12E7E82616383A00B66C86 /* include */, + 0C12E8002616383A00B66C86 /* tests */, + ); + path = nomnigraph; + sourceTree = ""; + }; + 0C12E7E72616383A00B66C86 /* Representations */ = { + isa = PBXGroup; + children = ( + ); + path = Representations; + sourceTree = ""; + }; + 0C12E7E82616383A00B66C86 /* include */ = { + isa = PBXGroup; + children = ( + 0C12E7E92616383A00B66C86 /* nomnigraph */, + ); + path = include; + sourceTree = ""; + }; + 0C12E7E92616383A00B66C86 /* nomnigraph */ = { + isa = PBXGroup; + children = ( + 0C12E7EA2616383A00B66C86 /* Generated */, + 0C12E7EE2616383A00B66C86 /* Representations */, + 0C12E7F22616383A00B66C86 /* Transformations */, + 0C12E7F52616383A00B66C86 /* Graph */, + 0C12E7FB2616383A00B66C86 /* Converters */, + 0C12E7FD2616383A00B66C86 /* Support */, + ); + path = nomnigraph; + sourceTree = ""; + }; + 0C12E7EA2616383A00B66C86 /* Generated */ = { + isa = PBXGroup; + children = ( + 0C12E7EB2616383A00B66C86 /* OpClasses.h */, + 0C12E7EC2616383A00B66C86 /* OpEnum.h */, + 0C12E7ED2616383A00B66C86 /* OpNames.h */, + ); + path = Generated; + sourceTree = ""; + }; + 0C12E7EE2616383A00B66C86 /* Representations */ = { + isa = PBXGroup; + children = ( + 0C12E7EF2616383A00B66C86 /* Compiler.h */, + 0C12E7F02616383A00B66C86 /* NeuralNet.h */, + 0C12E7F12616383A00B66C86 /* ControlFlow.h */, + ); + path = Representations; + sourceTree = ""; + }; + 0C12E7F22616383A00B66C86 /* Transformations */ = { + isa = PBXGroup; + children = ( + 0C12E7F32616383A00B66C86 /* SubgraphMatcher.h */, + 0C12E7F42616383A00B66C86 /* Match.h */, + ); + path = Transformations; + sourceTree = ""; + }; + 0C12E7F52616383A00B66C86 /* Graph */ = { + isa = PBXGroup; + children = ( + 0C12E7F62616383A00B66C86 /* Algorithms.h */, + 0C12E7F72616383A00B66C86 /* TopoSort.h */, + 0C12E7F82616383A00B66C86 /* Graph.h */, + 0C12E7F92616383A00B66C86 /* TarjansImpl.h */, + 0C12E7FA2616383A00B66C86 /* BinaryMatchImpl.h */, + ); + path = Graph; + sourceTree = ""; + }; + 0C12E7FB2616383A00B66C86 /* Converters */ = { + isa = PBXGroup; + children = ( + 0C12E7FC2616383A00B66C86 /* Dot.h */, + ); + path = Converters; + sourceTree = ""; + }; + 0C12E7FD2616383A00B66C86 /* Support */ = { + isa = PBXGroup; + children = ( + 0C12E7FE2616383A00B66C86 /* Casting.h */, + 0C12E7FF2616383A00B66C86 /* Common.h */, + ); + path = Support; + sourceTree = ""; + }; + 0C12E8002616383A00B66C86 /* tests */ = { + isa = PBXGroup; + children = ( + 0C12E8012616383A00B66C86 /* test_util.h */, + ); + path = tests; + sourceTree = ""; + }; + 0C12E80E2616383A00B66C86 /* mpi */ = { + isa = PBXGroup; + children = ( + 0C12E80F2616383A00B66C86 /* mpi_common.h */, + 0C12E8102616383A00B66C86 /* mpi_ops.h */, + ); + path = mpi; + sourceTree = ""; + }; + 0C12E8112616383A00B66C86 /* proto */ = { + isa = PBXGroup; + children = ( + 0C12E8122616383A00B66C86 /* caffe2_pb.h */, + 0C12E8132616383A00B66C86 /* torch_pb.h */, + ); + path = proto; + sourceTree = ""; + }; + 0C12E8142616383A00B66C86 /* test */ = { + isa = PBXGroup; + children = ( + 0C12E8152616383A00B66C86 /* assets */, + ); + path = test; + sourceTree = ""; + }; + 0C12E8152616383A00B66C86 /* assets */ = { + isa = PBXGroup; + children = ( + ); + path = assets; + sourceTree = ""; + }; + 0C12E8162616383A00B66C86 /* operators */ = { + isa = PBXGroup; + children = ( + 0C12E8172616383A00B66C86 /* top_k.h */, + 0C12E8182616383A00B66C86 /* channel_stats_op.h */, + 0C12E8192616383A00B66C86 /* gru_unit_op.h */, + 0C12E81A2616383A00B66C86 /* half_float_ops.h */, + 0C12E81B2616383A00B66C86 /* sqr_op.h */, + 0C12E81C2616383A00B66C86 /* mean_op.h */, + 0C12E81D2616383A00B66C86 /* thresholded_relu_op.h */, + 0C12E81E2616383A00B66C86 /* ctc_greedy_decoder_op.h */, + 0C12E81F2616383A00B66C86 /* conv_op_cache_cudnn.h */, + 0C12E8202616383A00B66C86 /* utility_ops.h */, + 0C12E8212616383A00B66C86 /* selu_op.h */, + 0C12E8222616383A00B66C86 /* map_ops.h */, + 0C12E8232616383A00B66C86 /* roi_align_rotated_op.h */, + 0C12E8242616383A00B66C86 /* fused_rowwise_random_quantization_ops.h */, + 0C12E8252616383A00B66C86 /* stop_gradient.h */, + 0C12E8262616383A00B66C86 /* batch_gather_ops.h */, + 0C12E8272616383A00B66C86 /* asin_op.h */, + 0C12E8282616383A00B66C86 /* cosh_op.h */, + 0C12E8292616383A00B66C86 /* atan_op.h */, + 0C12E82A2616383A00B66C86 /* reverse_packed_segs_op.h */, + 0C12E82B2616383A00B66C86 /* given_tensor_byte_string_to_uint8_fill_op.h */, + 0C12E82C2616383A00B66C86 /* ensure_clipped_op.h */, + 0C12E82D2616383A00B66C86 /* conv_transpose_op.h */, + 0C12E82E2616383A00B66C86 /* generate_proposals_op_util_nms.h */, + 0C12E82F2616383A00B66C86 /* enforce_finite_op.h */, + 0C12E8302616383A00B66C86 /* conv_transpose_unpool_op_base.h */, + 0C12E8312616383A00B66C86 /* gather_fused_8bit_rowwise_op.h */, + 0C12E8322616383A00B66C86 /* batch_matmul_op.h */, + 0C12E8332616383A00B66C86 /* batch_bucketize_op.h */, + 0C12E8342616383A00B66C86 /* softsign_op.h */, + 0C12E8352616383A00B66C86 /* elementwise_logical_ops.h */, + 0C12E8362616383A00B66C86 /* percentile_op.h */, + 0C12E8372616383A00B66C86 /* length_split_op.h */, + 0C12E8382616383A00B66C86 /* locally_connected_op_impl.h */, + 0C12E8392616383A00B66C86 /* rmac_regions_op.h */, + 0C12E83A2616383A00B66C86 /* hard_sigmoid_op.h */, + 0C12E83B2616383A00B66C86 /* ensure_cpu_output_op.h */, + 0C12E83C2616383A00B66C86 /* batch_box_cox_op.h */, + 0C12E83D2616383A00B66C86 /* ctc_beam_search_decoder_op.h */, + 0C12E83E2616383A00B66C86 /* flexible_top_k.h */, + 0C12E83F2616383A00B66C86 /* fully_connected_op.h */, + 0C12E8402616383A00B66C86 /* key_split_ops.h */, + 0C12E8412616383A00B66C86 /* reciprocal_op.h */, + 0C12E8422616383A00B66C86 /* roi_align_gradient_op.h */, + 0C12E8432616383A00B66C86 /* group_norm_op.h */, + 0C12E8442616383A00B66C86 /* load_save_op.h */, + 0C12E8452616383A00B66C86 /* cos_op.h */, + 0C12E8462616383A00B66C86 /* expand_op.h */, + 0C12E8472616383A00B66C86 /* elementwise_ops.h */, + 0C12E8482616383A00B66C86 /* im2col_op.h */, + 0C12E8492616383A00B66C86 /* space_batch_op.h */, + 0C12E84A2616383A00B66C86 /* relu_op.h */, + 0C12E84B2616383A00B66C86 /* while_op.h */, + 0C12E84C2616383A00B66C86 /* remove_data_blocks_op.h */, + 0C12E84D2616383A00B66C86 /* elementwise_mul_op.h */, + 0C12E84E2616383A00B66C86 /* numpy_tile_op.h */, + 0C12E84F2616383A00B66C86 /* rowmul_op.h */, + 0C12E8502616383A00B66C86 /* accumulate_op.h */, + 0C12E8512616383A00B66C86 /* sparse_lp_regularizer_op.h */, + 0C12E8522616383A00B66C86 /* bisect_percentile_op.h */, + 0C12E8532616383A00B66C86 /* tile_op.h */, + 0C12E8542616383A00B66C86 /* gelu_op.h */, + 0C12E8552616383A00B66C86 /* stats_put_ops.h */, + 0C12E8562616383A00B66C86 /* given_tensor_fill_op.h */, + 0C12E8572616383A00B66C86 /* accuracy_op.h */, + 0C12E8582616383A00B66C86 /* bbox_transform_op.h */, + 0C12E8592616383A00B66C86 /* boolean_unmask_ops.h */, + 0C12E85A2616383A00B66C86 /* glu_op.h */, + 0C12E85B2616383A00B66C86 /* resize_3d_op.h */, + 0C12E85C2616383A00B66C86 /* unsafe_coalesce.h */, + 0C12E85D2616383A00B66C86 /* conv_op.h */, + 0C12E85E2616383A00B66C86 /* conv_op_impl.h */, + 0C12E85F2616383A00B66C86 /* erf_op.h */, + 0C12E8602616383A00B66C86 /* fused_rowwise_8bit_conversion_ops.h */, + 0C12E8612616383A00B66C86 /* locally_connected_op_util.h */, + 0C12E8622616383A00B66C86 /* channel_backprop_stats_op.h */, + 0C12E8632616383A00B66C86 /* order_switch_ops.h */, + 0C12E8642616383A00B66C86 /* lengths_reducer_fused_nbit_rowwise_ops.h */, + 0C12E8652616383A00B66C86 /* lengths_reducer_fused_8bit_rowwise_ops.h */, + 0C12E8662616383A00B66C86 /* load_save_op_util.h */, + 0C12E8672616383A00B66C86 /* conv_transpose_op_impl.h */, + 0C12E8682616383A00B66C86 /* op_utils_cudnn.h */, + 0C12E8692616383A00B66C86 /* prelu_op.h */, + 0C12E86A2616383A00B66C86 /* box_with_nms_limit_op.h */, + 0C12E86B2616383A00B66C86 /* fc_inference.h */, + 0C12E86C2616383A00B66C86 /* distance_op.h */, + 0C12E86D2616383A00B66C86 /* data_couple.h */, + 0C12E86E2616383A00B66C86 /* dataset_ops.h */, + 0C12E86F2616383A00B66C86 /* merge_id_lists_op.h */, + 0C12E8702616383A00B66C86 /* generate_proposals_op_util_nms_gpu.h */, + 0C12E8712616383A00B66C86 /* async_net_barrier_op.h */, + 0C12E8722616383A00B66C86 /* deform_conv_op.h */, + 0C12E8732616383A00B66C86 /* quantized */, + 0C12E88C2616383A00B66C86 /* sqrt_op.h */, + 0C12E88D2616383A00B66C86 /* elementwise_div_op.h */, + 0C12E88E2616383A00B66C86 /* deform_conv_op_impl.h */, + 0C12E88F2616383A00B66C86 /* feature_maps_ops.h */, + 0C12E8902616383A00B66C86 /* text_file_reader_utils.h */, + 0C12E8912616383A00B66C86 /* scale_blobs_op.h */, + 0C12E8922616383A00B66C86 /* pool_op.h */, + 0C12E8932616383A00B66C86 /* conv_transpose_op_mobile_impl.h */, + 0C12E8942616383A00B66C86 /* dense_vector_to_id_list_op.h */, + 0C12E8952616383A00B66C86 /* minmax_ops.h */, + 0C12E8962616383A00B66C86 /* lengths_tile_op.h */, + 0C12E8972616383A00B66C86 /* pool_op_util.h */, + 0C12E8982616383A00B66C86 /* no_default_engine_op.h */, + 0C12E8992616383A00B66C86 /* onnx_while_op.h */, + 0C12E89A2616383A00B66C86 /* reduce_front_back_sum_mean_ops.h */, + 0C12E89B2616383A00B66C86 /* roi_pool_op.h */, + 0C12E89C2616383A00B66C86 /* flatten_op.h */, + 0C12E89D2616383A00B66C86 /* self_binning_histogram_op.h */, + 0C12E89E2616383A00B66C86 /* normalize_l1_op.h */, + 0C12E89F2616383A00B66C86 /* pow_op.h */, + 0C12E8A02616383A00B66C86 /* exp_op.h */, + 0C12E8A12616383A00B66C86 /* heatmap_max_keypoint_op.h */, + 0C12E8A22616383A00B66C86 /* assert_op.h */, + 0C12E8A32616383A00B66C86 /* piecewise_linear_transform_op.h */, + 0C12E8A42616383A00B66C86 /* cbrt_op.h */, + 0C12E8A52616383A00B66C86 /* weighted_sample_op.h */, + 0C12E8A62616383A00B66C86 /* tanh_op.h */, + 0C12E8A72616383A00B66C86 /* softmax_op.h */, + 0C12E8A82616383A00B66C86 /* listwise_l2r_op.h */, + 0C12E8A92616383A00B66C86 /* variable_length_sequence_padding.h */, + 0C12E8AA2616383A00B66C86 /* elementwise_add_op.h */, + 0C12E8AB2616383A00B66C86 /* leaky_relu_op.h */, + 0C12E8AC2616383A00B66C86 /* elementwise_linear_op.h */, + 0C12E8AD2616383A00B66C86 /* elu_op.h */, + 0C12E8AE2616383A00B66C86 /* jsd_op.h */, + 0C12E8AF2616383A00B66C86 /* collect_and_distribute_fpn_rpn_proposals_op.h */, + 0C12E8B02616383A00B66C86 /* reduce_ops.h */, + 0C12E8B12616383A00B66C86 /* string_ops.h */, + 0C12E8B22616383A00B66C86 /* boolean_mask_ops.h */, + 0C12E8B32616383A00B66C86 /* local_response_normalization_op.h */, + 0C12E8B42616383A00B66C86 /* partition_ops.h */, + 0C12E8B52616383A00B66C86 /* sparse_dropout_with_replacement_op.h */, + 0C12E8B62616383A00B66C86 /* loss_op.h */, + 0C12E8B72616383A00B66C86 /* counter_ops.h */, + 0C12E8B82616383A00B66C86 /* h_softmax_op.h */, + 0C12E8B92616383A00B66C86 /* lengths_reducer_rowwise_8bit_ops.h */, + 0C12E8BA2616383A00B66C86 /* copy_rows_to_tensor_op.h */, + 0C12E8BB2616383A00B66C86 /* moments_op.h */, + 0C12E8BC2616383A00B66C86 /* logit_op.h */, + 0C12E8BD2616383A00B66C86 /* perplexity_op.h */, + 0C12E8BE2616383A00B66C86 /* roi_align_rotated_gradient_op.h */, + 0C12E8BF2616383A00B66C86 /* ceil_op.h */, + 0C12E8C02616383A00B66C86 /* find_op.h */, + 0C12E8C12616383A00B66C86 /* layer_norm_op.h */, + 0C12E8C22616383A00B66C86 /* negate_gradient_op.h */, + 0C12E8C32616383A00B66C86 /* resize_op.h */, + 0C12E8C42616383A00B66C86 /* lengths_reducer_ops.h */, + 0C12E8C52616383A00B66C86 /* batch_sparse_to_dense_op.h */, + 0C12E8C62616383A00B66C86 /* replace_nan_op.h */, + 0C12E8C72616383A00B66C86 /* max_pool_with_index_gpu.h */, + 0C12E8C82616383A00B66C86 /* find_duplicate_elements_op.h */, + 0C12E8C92616383A00B66C86 /* expand_squeeze_dims_op.h */, + 0C12E8CA2616383A00B66C86 /* sinusoid_position_encoding_op.h */, + 0C12E8CB2616383A00B66C86 /* pack_segments.h */, + 0C12E8CC2616383A00B66C86 /* softplus_op.h */, + 0C12E8CD2616383A00B66C86 /* quantile_op.h */, + 0C12E8CE2616383A00B66C86 /* sinh_op.h */, + 0C12E8CF2616383A00B66C86 /* fused_rowwise_nbitfake_conversion_ops.h */, + 0C12E8D02616383A00B66C86 /* cross_entropy_op.h */, + 0C12E8D12616383A00B66C86 /* feed_blob_op.h */, + 0C12E8D22616383A00B66C86 /* slice_op.h */, + 0C12E8D32616383A00B66C86 /* rsqrt_op.h */, + 0C12E8D42616383A00B66C86 /* free_op.h */, + 0C12E8D52616383A00B66C86 /* square_root_divide_op.h */, + 0C12E8D62616383A00B66C86 /* conv_op_shared.h */, + 0C12E8D72616383A00B66C86 /* apmeter_op.h */, + 0C12E8D82616383A00B66C86 /* lstm_unit_op.h */, + 0C12E8D92616383A00B66C86 /* index_hash_ops.h */, + 0C12E8DA2616383A00B66C86 /* lengths_pad_op.h */, + 0C12E8DB2616383A00B66C86 /* elementwise_ops_utils.h */, + 0C12E8DC2616383A00B66C86 /* sparse_normalize_op.h */, + 0C12E8DD2616383A00B66C86 /* multi_class_accuracy_op.h */, + 0C12E8DE2616383A00B66C86 /* cast_op.h */, + 0C12E8DF2616383A00B66C86 /* transpose_op.h */, + 0C12E8E02616383A00B66C86 /* create_scope_op.h */, + 0C12E8E12616383A00B66C86 /* zero_gradient_op.h */, + 0C12E8E22616383A00B66C86 /* lstm_utils.h */, + 0C12E8E32616383A00B66C86 /* tt_linear_op.h */, + 0C12E8E42616383A00B66C86 /* relu_n_op.h */, + 0C12E8E52616383A00B66C86 /* generate_proposals_op.h */, + 0C12E8E62616383A00B66C86 /* hip */, + 0C12E8E82616383A00B66C86 /* lpnorm_op.h */, + 0C12E8E92616383A00B66C86 /* sequence_ops.h */, + 0C12E8EA2616383A00B66C86 /* abs_op.h */, + 0C12E8EB2616383A00B66C86 /* activation_ops_cudnn.h */, + 0C12E8EC2616383A00B66C86 /* elementwise_op_test.h */, + 0C12E8ED2616383A00B66C86 /* inference_lstm_op.h */, + 0C12E8EE2616383A00B66C86 /* concat_split_op.h */, + 0C12E8EF2616383A00B66C86 /* reduction_ops.h */, + 0C12E8F02616383A00B66C86 /* gather_op.h */, + 0C12E8F12616383A00B66C86 /* log_op.h */, + 0C12E8F22616383A00B66C86 /* conv_pool_op_base.h */, + 0C12E8F32616383A00B66C86 /* unique_ops.h */, + 0C12E8F42616383A00B66C86 /* elementwise_sub_op.h */, + 0C12E8F52616383A00B66C86 /* segment_reduction_op.h */, + 0C12E8F62616383A00B66C86 /* fused_rowwise_nbit_conversion_ops.h */, + 0C12E8F72616383A00B66C86 /* stump_func_op.h */, + 0C12E8F82616383A00B66C86 /* swish_op.h */, + 0C12E8F92616383A00B66C86 /* pack_rnn_sequence_op.h */, + 0C12E8FA2616383A00B66C86 /* softmax_with_loss_op.h */, + 0C12E8FB2616383A00B66C86 /* integral_image_op.h */, + 0C12E8FC2616383A00B66C86 /* mish_op.h */, + 0C12E8FD2616383A00B66C86 /* weighted_multi_sampling_op.h */, + 0C12E8FE2616383A00B66C86 /* bucketize_op.h */, + 0C12E8FF2616383A00B66C86 /* is_empty_op.h */, + 0C12E9002616383A00B66C86 /* mod_op.h */, + 0C12E9012616383A00B66C86 /* clip_op.h */, + 0C12E9022616383A00B66C86 /* prepend_dim_op.h */, + 0C12E9032616383A00B66C86 /* copy_op.h */, + 0C12E9042616383A00B66C86 /* rank_loss_op.h */, + 0C12E9052616383A00B66C86 /* lengths_top_k_op.h */, + 0C12E9062616383A00B66C86 /* summarize_op.h */, + 0C12E9072616383A00B66C86 /* one_hot_ops.h */, + 0C12E9082616383A00B66C86 /* cc_bmm_bg_op.h */, + 0C12E9092616383A00B66C86 /* acos_op.h */, + 0C12E90A2616383A00B66C86 /* softmax_utils.h */, + 0C12E90B2616383A00B66C86 /* tensor_protos_db_input.h */, + 0C12E90C2616383A00B66C86 /* generate_proposals_op_util_boxes.h */, + 0C12E90D2616383A00B66C86 /* conv_transpose_op_mobile.h */, + 0C12E90E2616383A00B66C86 /* arg_ops.h */, + 0C12E90F2616383A00B66C86 /* negative_op.h */, + 0C12E9102616383A00B66C86 /* operator_fallback_gpu.h */, + 0C12E9112616383A00B66C86 /* margin_ranking_criterion_op.h */, + 0C12E9122616383A00B66C86 /* matmul_op.h */, + 0C12E9132616383A00B66C86 /* roi_align_op.h */, + 0C12E9142616383A00B66C86 /* pad_op.h */, + 0C12E9152616383A00B66C86 /* histogram_op.h */, + 0C12E9162616383A00B66C86 /* floor_op.h */, + 0C12E9172616383A00B66C86 /* normalize_op.h */, + 0C12E9182616383A00B66C86 /* cube_op.h */, + 0C12E9192616383A00B66C86 /* reshape_op.h */, + 0C12E91A2616383A00B66C86 /* instance_norm_op.h */, + 0C12E91B2616383A00B66C86 /* ngram_ops.h */, + 0C12E91C2616383A00B66C86 /* if_op.h */, + 0C12E91D2616383A00B66C86 /* reduce_front_back_max_ops.h */, + 0C12E91E2616383A00B66C86 /* reducer_functors.h */, + 0C12E91F2616383A00B66C86 /* affine_channel_op.h */, + 0C12E9202616383A00B66C86 /* sigmoid_op.h */, + 0C12E9212616383A00B66C86 /* channel_shuffle_op.h */, + 0C12E9222616383A00B66C86 /* locally_connected_op.h */, + 0C12E9232616383A00B66C86 /* conditional_op.h */, + 0C12E9242616383A00B66C86 /* rms_norm_op.h */, + 0C12E9252616383A00B66C86 /* dropout_op.h */, + 0C12E9262616383A00B66C86 /* gather_ranges_to_dense_op.h */, + 0C12E9272616383A00B66C86 /* shape_op.h */, + 0C12E9282616383A00B66C86 /* index_ops.h */, + 0C12E9292616383A00B66C86 /* tan_op.h */, + 0C12E92A2616383A00B66C86 /* scale_op.h */, + 0C12E92B2616383A00B66C86 /* cosine_embedding_criterion_op.h */, + 0C12E92C2616383A00B66C86 /* sparse_to_dense_op.h */, + 0C12E92D2616383A00B66C86 /* quant_decode_op.h */, + 0C12E92E2616383A00B66C86 /* rnn */, + 0C12E9372616383A00B66C86 /* sparse_to_dense_mask_op.h */, + 0C12E9382616383A00B66C86 /* sin_op.h */, + 0C12E9392616383A00B66C86 /* upsample_op.h */, + 0C12E93A2616383A00B66C86 /* filler_op.h */, + 0C12E93B2616383A00B66C86 /* batch_permutation_op.h */, + 0C12E93C2616383A00B66C86 /* spatial_softmax_with_loss_op.h */, + 0C12E93D2616383A00B66C86 /* batch_moments_op.h */, + 0C12E93E2616383A00B66C86 /* alias_with_name.h */, + 0C12E93F2616383A00B66C86 /* do_op.h */, + 0C12E9402616383A00B66C86 /* prefetch_op.h */, + 0C12E9412616383A00B66C86 /* byte_weight_dequant_op.h */, + 0C12E9422616383A00B66C86 /* spatial_batch_norm_op.h */, + ); + path = operators; + sourceTree = ""; + }; + 0C12E8732616383A00B66C86 /* quantized */ = { + isa = PBXGroup; + children = ( + 0C12E8742616383A00B66C86 /* int8_relu_op.h */, + 0C12E8752616383A00B66C86 /* int8_channel_shuffle_op.h */, + 0C12E8762616383A00B66C86 /* int8_concat_op.h */, + 0C12E8772616383A00B66C86 /* int8_dequantize_op.h */, + 0C12E8782616383A00B66C86 /* int8_slice_op.h */, + 0C12E8792616383A00B66C86 /* int8_quantize_op.h */, + 0C12E87A2616383A00B66C86 /* int8_flatten_op.h */, + 0C12E87B2616383A00B66C86 /* int8_max_pool_op.h */, + 0C12E87C2616383A00B66C86 /* int8_softmax_op.h */, + 0C12E87D2616383A00B66C86 /* int8_average_pool_op.h */, + 0C12E87E2616383A00B66C86 /* int8_fc_op.h */, + 0C12E87F2616383A00B66C86 /* int8_conv_op.h */, + 0C12E8802616383A00B66C86 /* int8_test_utils.h */, + 0C12E8812616383A00B66C86 /* int8_roi_align_op.h */, + 0C12E8822616383A00B66C86 /* int8_given_tensor_fill_op.h */, + 0C12E8832616383A00B66C86 /* int8_reshape_op.h */, + 0C12E8842616383A00B66C86 /* int8_utils.h */, + 0C12E8852616383A00B66C86 /* int8_resize_nearest_op.h */, + 0C12E8862616383A00B66C86 /* int8_sigmoid_op.h */, + 0C12E8872616383A00B66C86 /* int8_simd.h */, + 0C12E8882616383A00B66C86 /* int8_conv_transpose_op.h */, + 0C12E8892616383A00B66C86 /* int8_leaky_relu_op.h */, + 0C12E88A2616383A00B66C86 /* int8_add_op.h */, + 0C12E88B2616383A00B66C86 /* int8_transpose_op.h */, + ); + path = quantized; + sourceTree = ""; + }; + 0C12E8E62616383A00B66C86 /* hip */ = { + isa = PBXGroup; + children = ( + 0C12E8E72616383A00B66C86 /* activation_ops_miopen.h */, + ); + path = hip; + sourceTree = ""; + }; + 0C12E92E2616383A00B66C86 /* rnn */ = { + isa = PBXGroup; + children = ( + 0C12E92F2616383A00B66C86 /* recurrent_network_blob_fetcher_op.h */, + 0C12E9302616383A00B66C86 /* recurrent_op_cudnn.h */, + 0C12E9312616383A00B66C86 /* recurrent_network_executor_gpu.h */, + 0C12E9322616383A00B66C86 /* recurrent_network_executor_incl.h */, + 0C12E9332616383A00B66C86 /* hip */, + 0C12E9352616383A00B66C86 /* recurrent_network_executor.h */, + 0C12E9362616383A00B66C86 /* recurrent_network_op.h */, + ); + path = rnn; + sourceTree = ""; + }; + 0C12E9332616383A00B66C86 /* hip */ = { + isa = PBXGroup; + children = ( + 0C12E9342616383A00B66C86 /* recurrent_op_miopen.h */, + ); + path = hip; + sourceTree = ""; + }; + 0C12E9432616383A00B66C86 /* onnx */ = { + isa = PBXGroup; + children = ( + 0C12E9442616383A00B66C86 /* helper.h */, + 0C12E9452616383A00B66C86 /* device.h */, + 0C12E9462616383A00B66C86 /* onnxifi_init.h */, + 0C12E9472616383A00B66C86 /* backend.h */, + 0C12E9482616383A00B66C86 /* torch_ops */, + 0C12E94C2616383A00B66C86 /* backend_rep.h */, + 0C12E94D2616383A00B66C86 /* onnx_exporter.h */, + 0C12E94E2616383A00B66C86 /* offline_tensor.h */, + 0C12E94F2616383A00B66C86 /* onnxifi_graph_info.h */, + ); + path = onnx; + sourceTree = ""; + }; + 0C12E9482616383A00B66C86 /* torch_ops */ = { + isa = PBXGroup; + children = ( + 0C12E9492616383A00B66C86 /* schema.h */, + 0C12E94A2616383A00B66C86 /* constants.h */, + 0C12E94B2616383A00B66C86 /* operator_sets.h */, + ); + path = torch_ops; + sourceTree = ""; + }; + 0C12E9502616383A00B66C86 /* python */ = { + isa = PBXGroup; + children = ( + 0C12E9512616383A00B66C86 /* serialized_test */, + 0C12E9542616383A00B66C86 /* pybind_state.h */, + 0C12E9552616383A00B66C86 /* pybind_state_registry.h */, + 0C12E9562616383A00B66C86 /* ideep */, + 0C12E9572616383A00B66C86 /* mint */, + 0C12E95B2616383A00B66C86 /* layers */, + 0C12E95C2616383A00B66C86 /* test */, + 0C12E95D2616383A00B66C86 /* dlpack.h */, + 0C12E95E2616383A00B66C86 /* onnx */, + 0C12E9612616383A00B66C86 /* trt */, + 0C12E9632616383A00B66C86 /* operator_test */, + 0C12E9642616383A00B66C86 /* models */, + 0C12E9662616383A00B66C86 /* docs */, + 0C12E9672616383A00B66C86 /* fakelowp */, + 0C12E9682616383A00B66C86 /* modeling */, + 0C12E9692616383A00B66C86 /* pybind_state_dlpack.h */, + 0C12E96A2616383A00B66C86 /* mkl */, + 0C12E96B2616383A00B66C86 /* examples */, + 0C12E96C2616383A00B66C86 /* benchmarks */, + 0C12E96D2616383A00B66C86 /* predictor */, + 0C12E96E2616383A00B66C86 /* helpers */, + 0C12E96F2616383A00B66C86 /* rnn */, + ); + path = python; + sourceTree = ""; + }; + 0C12E9512616383A00B66C86 /* serialized_test */ = { + isa = PBXGroup; + children = ( + 0C12E9522616383A00B66C86 /* data */, + ); + path = serialized_test; + sourceTree = ""; + }; + 0C12E9522616383A00B66C86 /* data */ = { + isa = PBXGroup; + children = ( + 0C12E9532616383A00B66C86 /* operator_test */, + ); + path = data; + sourceTree = ""; + }; + 0C12E9532616383A00B66C86 /* operator_test */ = { + isa = PBXGroup; + children = ( + ); + path = operator_test; + sourceTree = ""; + }; + 0C12E9562616383A00B66C86 /* ideep */ = { + isa = PBXGroup; + children = ( + ); + path = ideep; + sourceTree = ""; + }; + 0C12E9572616383A00B66C86 /* mint */ = { + isa = PBXGroup; + children = ( + 0C12E9582616383A00B66C86 /* static */, + 0C12E95A2616383A00B66C86 /* templates */, + ); + path = mint; + sourceTree = ""; + }; + 0C12E9582616383A00B66C86 /* static */ = { + isa = PBXGroup; + children = ( + 0C12E9592616383A00B66C86 /* css */, + ); + path = static; + sourceTree = ""; + }; + 0C12E9592616383A00B66C86 /* css */ = { + isa = PBXGroup; + children = ( + ); + path = css; + sourceTree = ""; + }; + 0C12E95A2616383A00B66C86 /* templates */ = { + isa = PBXGroup; + children = ( + ); + path = templates; + sourceTree = ""; + }; + 0C12E95B2616383A00B66C86 /* layers */ = { + isa = PBXGroup; + children = ( + ); + path = layers; + sourceTree = ""; + }; + 0C12E95C2616383A00B66C86 /* test */ = { + isa = PBXGroup; + children = ( + ); + path = test; + sourceTree = ""; + }; + 0C12E95E2616383A00B66C86 /* onnx */ = { + isa = PBXGroup; + children = ( + 0C12E95F2616383A00B66C86 /* bin */, + 0C12E9602616383A00B66C86 /* tests */, + ); + path = onnx; + sourceTree = ""; + }; + 0C12E95F2616383A00B66C86 /* bin */ = { + isa = PBXGroup; + children = ( + ); + path = bin; + sourceTree = ""; + }; + 0C12E9602616383A00B66C86 /* tests */ = { + isa = PBXGroup; + children = ( + ); + path = tests; + sourceTree = ""; + }; + 0C12E9612616383A00B66C86 /* trt */ = { + isa = PBXGroup; + children = ( + 0C12E9622616383A00B66C86 /* data */, + ); + path = trt; + sourceTree = ""; + }; + 0C12E9622616383A00B66C86 /* data */ = { + isa = PBXGroup; + children = ( + ); + path = data; + sourceTree = ""; + }; + 0C12E9632616383A00B66C86 /* operator_test */ = { + isa = PBXGroup; + children = ( + ); + path = operator_test; + sourceTree = ""; + }; + 0C12E9642616383A00B66C86 /* models */ = { + isa = PBXGroup; + children = ( + 0C12E9652616383A00B66C86 /* seq2seq */, + ); + path = models; + sourceTree = ""; + }; + 0C12E9652616383A00B66C86 /* seq2seq */ = { + isa = PBXGroup; + children = ( + ); + path = seq2seq; + sourceTree = ""; + }; + 0C12E9662616383A00B66C86 /* docs */ = { + isa = PBXGroup; + children = ( + ); + path = docs; + sourceTree = ""; + }; + 0C12E9672616383A00B66C86 /* fakelowp */ = { + isa = PBXGroup; + children = ( + ); + path = fakelowp; + sourceTree = ""; + }; + 0C12E9682616383A00B66C86 /* modeling */ = { + isa = PBXGroup; + children = ( + ); + path = modeling; + sourceTree = ""; + }; + 0C12E96A2616383A00B66C86 /* mkl */ = { + isa = PBXGroup; + children = ( + ); + path = mkl; + sourceTree = ""; + }; + 0C12E96B2616383A00B66C86 /* examples */ = { + isa = PBXGroup; + children = ( + ); + path = examples; + sourceTree = ""; + }; + 0C12E96C2616383A00B66C86 /* benchmarks */ = { + isa = PBXGroup; + children = ( + ); + path = benchmarks; + sourceTree = ""; + }; + 0C12E96D2616383A00B66C86 /* predictor */ = { + isa = PBXGroup; + children = ( + ); + path = predictor; + sourceTree = ""; + }; + 0C12E96E2616383A00B66C86 /* helpers */ = { + isa = PBXGroup; + children = ( + ); + path = helpers; + sourceTree = ""; + }; + 0C12E96F2616383A00B66C86 /* rnn */ = { + isa = PBXGroup; + children = ( + ); + path = rnn; + sourceTree = ""; + }; + 0C12E9702616383A00B66C86 /* distributed */ = { + isa = PBXGroup; + children = ( + 0C12E9712616383A00B66C86 /* redis_store_handler.h */, + 0C12E9722616383A00B66C86 /* file_store_handler_op.h */, + 0C12E9732616383A00B66C86 /* store_handler.h */, + 0C12E9742616383A00B66C86 /* store_ops.h */, + 0C12E9752616383A00B66C86 /* file_store_handler.h */, + 0C12E9762616383A00B66C86 /* redis_store_handler_op.h */, + ); + path = distributed; + sourceTree = ""; + }; + 0C12E9772616383A00B66C86 /* perfkernels */ = { + isa = PBXGroup; + children = ( + 0C12E9782616383A00B66C86 /* embedding_lookup.h */, + 0C12E9792616383A00B66C86 /* fused_8bit_rowwise_embedding_lookup_idx.h */, + 0C12E97A2616383A00B66C86 /* lstm_unit_cpu-impl.h */, + 0C12E97B2616383A00B66C86 /* embedding_lookup_idx.h */, + 0C12E97C2616383A00B66C86 /* adagrad.h */, + 0C12E97D2616383A00B66C86 /* lstm_unit_cpu.h */, + 0C12E97E2616383A00B66C86 /* cvtsh_ss_bugfix.h */, + 0C12E97F2616383A00B66C86 /* common.h */, + 0C12E9802616383A00B66C86 /* math.h */, + 0C12E9812616383A00B66C86 /* typed_axpy.h */, + 0C12E9822616383A00B66C86 /* fused_nbit_rowwise_conversion.h */, + 0C12E9832616383A00B66C86 /* fused_8bit_rowwise_embedding_lookup.h */, + 0C12E9842616383A00B66C86 /* lstm_unit_cpu_common.h */, + ); + path = perfkernels; + sourceTree = ""; + }; + 0C12E9852616383A00B66C86 /* experiments */ = { + isa = PBXGroup; + children = ( + 0C12E9862616383A00B66C86 /* operators */, + 0C12E98F2616383A00B66C86 /* python */, + ); + path = experiments; + sourceTree = ""; + }; + 0C12E9862616383A00B66C86 /* operators */ = { + isa = PBXGroup; + children = ( + 0C12E9872616383A00B66C86 /* fully_connected_op_decomposition.h */, + 0C12E9882616383A00B66C86 /* fully_connected_op_sparse.h */, + 0C12E9892616383A00B66C86 /* tt_contraction_op.h */, + 0C12E98A2616383A00B66C86 /* fully_connected_op_prune.h */, + 0C12E98B2616383A00B66C86 /* funhash_op.h */, + 0C12E98C2616383A00B66C86 /* sparse_funhash_op.h */, + 0C12E98D2616383A00B66C86 /* sparse_matrix_reshape_op.h */, + 0C12E98E2616383A00B66C86 /* tt_pad_op.h */, + ); + path = operators; + sourceTree = ""; + }; + 0C12E98F2616383A00B66C86 /* python */ = { + isa = PBXGroup; + children = ( + ); + path = python; + sourceTree = ""; + }; + 0C12E9902616383A00B66C86 /* cuda_rtc */ = { + isa = PBXGroup; + children = ( + 0C12E9912616383A00B66C86 /* common_rtc.h */, + ); + path = cuda_rtc; + sourceTree = ""; + }; + 0C12E9922616383A00B66C86 /* serialize */ = { + isa = PBXGroup; + children = ( + 0C12E9932616383A00B66C86 /* read_adapter_interface.h */, + 0C12E9942616383A00B66C86 /* crc_alt.h */, + 0C12E9952616383A00B66C86 /* versions.h */, + 0C12E9962616383A00B66C86 /* inline_container.h */, + 0C12E9972616383A00B66C86 /* file_adapter.h */, + 0C12E9982616383A00B66C86 /* istream_adapter.h */, + ); + path = serialize; + sourceTree = ""; + }; + 0C12E9992616383A00B66C86 /* utils */ = { + isa = PBXGroup; + children = ( + 0C12E99A2616383A00B66C86 /* filler.h */, + 0C12E99B2616383A00B66C86 /* math-detail.h */, + 0C12E99C2616383A00B66C86 /* signal_handler.h */, + 0C12E99D2616383A00B66C86 /* cpu_neon.h */, + 0C12E99E2616383A00B66C86 /* conversions.h */, + 0C12E99F2616383A00B66C86 /* string_utils.h */, + 0C12E9A02616383A00B66C86 /* simple_queue.h */, + 0C12E9A12616383A00B66C86 /* cpuid.h */, + 0C12E9A22616383A00B66C86 /* threadpool */, + 0C12E9A92616383A00B66C86 /* math */, + 0C12E9B02616383A00B66C86 /* fixed_divisor.h */, + 0C12E9B12616383A00B66C86 /* proto_wrap.h */, + 0C12E9B22616383A00B66C86 /* bench_utils.h */, + 0C12E9B32616383A00B66C86 /* cast.h */, + 0C12E9B42616383A00B66C86 /* hip */, + 0C12E9B52616383A00B66C86 /* murmur_hash3.h */, + 0C12E9B62616383A00B66C86 /* math.h */, + 0C12E9B72616383B00B66C86 /* eigen_utils.h */, + 0C12E9B82616383B00B66C86 /* smart_tensor_printer.h */, + 0C12E9B92616383B00B66C86 /* proto_convert.h */, + 0C12E9BA2616383B00B66C86 /* proto_utils.h */, + 0C12E9BB2616383B00B66C86 /* cblas.h */, + 0C12E9BC2616383B00B66C86 /* map_utils.h */, + 0C12E9BD2616383B00B66C86 /* zmq_helper.h */, + ); + path = utils; + sourceTree = ""; + }; + 0C12E9A22616383A00B66C86 /* threadpool */ = { + isa = PBXGroup; + children = ( + 0C12E9A32616383A00B66C86 /* ThreadPool.h */, + 0C12E9A42616383A00B66C86 /* ThreadPoolCommon.h */, + 0C12E9A52616383A00B66C86 /* pthreadpool.h */, + 0C12E9A62616383A00B66C86 /* pthreadpool-cpp.h */, + 0C12E9A72616383A00B66C86 /* WorkersPool.h */, + 0C12E9A82616383A00B66C86 /* thread_pool_guard.h */, + ); + path = threadpool; + sourceTree = ""; + }; + 0C12E9A92616383A00B66C86 /* math */ = { + isa = PBXGroup; + children = ( + 0C12E9AA2616383A00B66C86 /* utils.h */, + 0C12E9AB2616383A00B66C86 /* broadcast.h */, + 0C12E9AC2616383A00B66C86 /* elementwise.h */, + 0C12E9AD2616383A00B66C86 /* half_utils.h */, + 0C12E9AE2616383A00B66C86 /* reduce.h */, + 0C12E9AF2616383A00B66C86 /* transpose.h */, + ); + path = math; + sourceTree = ""; + }; + 0C12E9B42616383A00B66C86 /* hip */ = { + isa = PBXGroup; + children = ( + ); + path = hip; + sourceTree = ""; + }; + 0C12E9BE2616383B00B66C86 /* contrib */ = { + isa = PBXGroup; + children = ( + 0C12E9BF2616383B00B66C86 /* nnpack */, + 0C12E9C02616383B00B66C86 /* warpctc */, + 0C12E9C22616383B00B66C86 /* nccl */, + 0C12E9C42616383B00B66C86 /* ideep */, + 0C12E9C52616383B00B66C86 /* docker-ubuntu-14.04 */, + 0C12E9C62616383B00B66C86 /* playground */, + 0C12E9C82616383B00B66C86 /* gloo */, + 0C12E9D22616383B00B66C86 /* fakelowp */, + 0C12E9E42616383B00B66C86 /* script */, + 0C12E9E62616383B00B66C86 /* opencl */, + 0C12E9E92616383B00B66C86 /* prof */, + 0C12E9EB2616383B00B66C86 /* tensorrt */, + 0C12E9EF2616383B00B66C86 /* shm_mutex */, + 0C12E9F12616383B00B66C86 /* tensorboard */, + 0C12E9F22616383B00B66C86 /* aten */, + 0C12E9F62616383B00B66C86 /* pytorch */, + ); + path = contrib; + sourceTree = ""; + }; + 0C12E9BF2616383B00B66C86 /* nnpack */ = { + isa = PBXGroup; + children = ( + ); + path = nnpack; + sourceTree = ""; + }; + 0C12E9C02616383B00B66C86 /* warpctc */ = { + isa = PBXGroup; + children = ( + 0C12E9C12616383B00B66C86 /* ctc_op.h */, + ); + path = warpctc; + sourceTree = ""; + }; + 0C12E9C22616383B00B66C86 /* nccl */ = { + isa = PBXGroup; + children = ( + 0C12E9C32616383B00B66C86 /* cuda_nccl_gpu.h */, + ); + path = nccl; + sourceTree = ""; + }; + 0C12E9C42616383B00B66C86 /* ideep */ = { + isa = PBXGroup; + children = ( + ); + path = ideep; + sourceTree = ""; + }; + 0C12E9C52616383B00B66C86 /* docker-ubuntu-14.04 */ = { + isa = PBXGroup; + children = ( + ); + path = "docker-ubuntu-14.04"; + sourceTree = ""; + }; + 0C12E9C62616383B00B66C86 /* playground */ = { + isa = PBXGroup; + children = ( + 0C12E9C72616383B00B66C86 /* resnetdemo */, + ); + path = playground; + sourceTree = ""; + }; + 0C12E9C72616383B00B66C86 /* resnetdemo */ = { + isa = PBXGroup; + children = ( + ); + path = resnetdemo; + sourceTree = ""; + }; + 0C12E9C82616383B00B66C86 /* gloo */ = { + isa = PBXGroup; + children = ( + 0C12E9C92616383B00B66C86 /* allreduce_ops.h */, + 0C12E9CA2616383B00B66C86 /* allgather_ops.h */, + 0C12E9CB2616383B00B66C86 /* context.h */, + 0C12E9CC2616383B00B66C86 /* store_handler.h */, + 0C12E9CD2616383B00B66C86 /* broadcast_ops.h */, + 0C12E9CE2616383B00B66C86 /* reduce_scatter_ops.h */, + 0C12E9CF2616383B00B66C86 /* common.h */, + 0C12E9D02616383B00B66C86 /* common_world_ops.h */, + 0C12E9D12616383B00B66C86 /* barrier_ops.h */, + ); + path = gloo; + sourceTree = ""; + }; + 0C12E9D22616383B00B66C86 /* fakelowp */ = { + isa = PBXGroup; + children = ( + 0C12E9D32616383B00B66C86 /* sum_fp16_fake_op.h */, + 0C12E9D42616383B00B66C86 /* lengths_reducer_fused_4bit_rowwise_fp16_fake_op.h */, + 0C12E9D52616383B00B66C86 /* int8_dequantize_op_nnpi.h */, + 0C12E9D62616383B00B66C86 /* test */, + 0C12E9D72616383B00B66C86 /* fp16_gemm_utils.h */, + 0C12E9D82616383B00B66C86 /* fp16_fma.h */, + 0C12E9D92616383B00B66C86 /* fp16_fc_acc_op.h */, + 0C12E9DA2616383B00B66C86 /* layernorm_fp16_fake_op.h */, + 0C12E9DB2616383B00B66C86 /* unary_fp16_fake_op.h */, + 0C12E9DC2616383B00B66C86 /* int8_quantize_op_nnpi.h */, + 0C12E9DD2616383B00B66C86 /* lengths_reducer_ops.h */, + 0C12E9DE2616383B00B66C86 /* common.h */, + 0C12E9DF2616383B00B66C86 /* batch_matmul_fp16_fake_op.h */, + 0C12E9E02616383B00B66C86 /* lengths_reducer_fused_8bit_rowwise_fp16_fake_op.h */, + 0C12E9E12616383B00B66C86 /* spatial_batch_norm_fp16_fake_op.h */, + 0C12E9E22616383B00B66C86 /* quant_lut_fp16_fake_op.h */, + 0C12E9E32616383B00B66C86 /* int8_swish_op_nnpi.h */, + ); + path = fakelowp; + sourceTree = ""; + }; + 0C12E9D62616383B00B66C86 /* test */ = { + isa = PBXGroup; + children = ( + ); + path = test; + sourceTree = ""; + }; + 0C12E9E42616383B00B66C86 /* script */ = { + isa = PBXGroup; + children = ( + 0C12E9E52616383B00B66C86 /* examples */, + ); + path = script; + sourceTree = ""; + }; + 0C12E9E52616383B00B66C86 /* examples */ = { + isa = PBXGroup; + children = ( + ); + path = examples; + sourceTree = ""; + }; + 0C12E9E62616383B00B66C86 /* opencl */ = { + isa = PBXGroup; + children = ( + 0C12E9E72616383B00B66C86 /* context.h */, + 0C12E9E82616383B00B66C86 /* OpenCL */, + ); + path = opencl; + sourceTree = ""; + }; + 0C12E9E82616383B00B66C86 /* OpenCL */ = { + isa = PBXGroup; + children = ( + ); + path = OpenCL; + sourceTree = ""; + }; + 0C12E9E92616383B00B66C86 /* prof */ = { + isa = PBXGroup; + children = ( + 0C12E9EA2616383B00B66C86 /* prof_dag_stats_op.h */, + ); + path = prof; + sourceTree = ""; + }; + 0C12E9EB2616383B00B66C86 /* tensorrt */ = { + isa = PBXGroup; + children = ( + 0C12E9EC2616383B00B66C86 /* tensorrt_tranformer.h */, + 0C12E9ED2616383B00B66C86 /* trt_utils.h */, + 0C12E9EE2616383B00B66C86 /* tensorrt_op_trt.h */, + ); + path = tensorrt; + sourceTree = ""; + }; + 0C12E9EF2616383B00B66C86 /* shm_mutex */ = { + isa = PBXGroup; + children = ( + 0C12E9F02616383B00B66C86 /* shm_mutex.h */, + ); + path = shm_mutex; + sourceTree = ""; + }; + 0C12E9F12616383B00B66C86 /* tensorboard */ = { + isa = PBXGroup; + children = ( + ); + path = tensorboard; + sourceTree = ""; + }; + 0C12E9F22616383B00B66C86 /* aten */ = { + isa = PBXGroup; + children = ( + 0C12E9F32616383B00B66C86 /* aten_op.h */, + 0C12E9F42616383B00B66C86 /* docs */, + 0C12E9F52616383B00B66C86 /* aten_op_template.h */, + ); + path = aten; + sourceTree = ""; + }; + 0C12E9F42616383B00B66C86 /* docs */ = { + isa = PBXGroup; + children = ( + ); + path = docs; + sourceTree = ""; + }; + 0C12E9F62616383B00B66C86 /* pytorch */ = { + isa = PBXGroup; + children = ( + ); + path = pytorch; + sourceTree = ""; + }; + 0C12E9F72616383B00B66C86 /* image */ = { + isa = PBXGroup; + children = ( + 0C12E9F82616383B00B66C86 /* image_input_op.h */, + 0C12E9F92616383B00B66C86 /* transform_gpu.h */, + ); + path = image; + sourceTree = ""; + }; + 0C12E9FA2616383B00B66C86 /* quantization */ = { + isa = PBXGroup; + children = ( + 0C12E9FB2616383B00B66C86 /* server */, + ); + path = quantization; + sourceTree = ""; + }; + 0C12E9FB2616383B00B66C86 /* server */ = { + isa = PBXGroup; + children = ( + 0C12E9FC2616383B00B66C86 /* fbgemm_fp16_pack_op.h */, + 0C12E9FD2616383B00B66C86 /* concat_dnnlowp_op.h */, + 0C12E9FE2616383B00B66C86 /* fully_connected_dnnlowp_op.h */, + 0C12E9FF2616383B00B66C86 /* int8_quant_scheme_blob_fill.h */, + 0C12EA002616383B00B66C86 /* quantize_dnnlowp_op.h */, + 0C12EA012616383B00B66C86 /* batch_matmul_dnnlowp_op.h */, + 0C12EA022616383B00B66C86 /* utility_dnnlowp_ops.h */, + 0C12EA032616383B00B66C86 /* activation_distribution_observer.h */, + 0C12EA042616383B00B66C86 /* compute_equalization_scale.h */, + 0C12EA052616383B00B66C86 /* caffe2_dnnlowp_utils.h */, + 0C12EA062616383B00B66C86 /* dnnlowp_partition.h */, + 0C12EA072616383B00B66C86 /* fully_connected_fake_lowp_op.h */, + 0C12EA082616383B00B66C86 /* op_wrapper.h */, + 0C12EA092616383B00B66C86 /* batch_permutation_dnnlowp_op.h */, + 0C12EA0A2616383B00B66C86 /* conv_relu_op.h */, + 0C12EA0B2616383B00B66C86 /* conv_pool_dnnlowp_op_base.h */, + 0C12EA0C2616383B00B66C86 /* mmio.h */, + 0C12EA0D2616383B00B66C86 /* lstm_unit_dnnlowp_op.h */, + 0C12EA0E2616383B00B66C86 /* fbgemm_pack_matrix_cache.h */, + 0C12EA0F2616383B00B66C86 /* im2col_dnnlowp.h */, + 0C12EA102616383B00B66C86 /* fbgemm_pack_op.h */, + 0C12EA112616383B00B66C86 /* resize_nearest_dnnlowp_op.h */, + 0C12EA122616383B00B66C86 /* group_norm_dnnlowp_op.h */, + 0C12EA132616383B00B66C86 /* elementwise_dnnlowp_op.h */, + 0C12EA142616383B00B66C86 /* fb_fc_packed_op.h */, + 0C12EA152616383B00B66C86 /* relu_dnnlowp_op.h */, + 0C12EA162616383B00B66C86 /* spatial_batch_norm_dnnlowp_op.h */, + 0C12EA172616383B00B66C86 /* dequantize_dnnlowp_op.h */, + 0C12EA182616383B00B66C86 /* kl_minimization.h */, + 0C12EA192616383B00B66C86 /* dynamic_histogram.h */, + 0C12EA1A2616383B00B66C86 /* tanh.h */, + 0C12EA1B2616383B00B66C86 /* fbgemm_pack_blob.h */, + 0C12EA1C2616383B00B66C86 /* resize_nearest_3d_dnnlowp_op.h */, + 0C12EA1D2616383B00B66C86 /* int8_gen_quant_params.h */, + 0C12EA1E2616383B00B66C86 /* conv_dnnlowp_op.h */, + 0C12EA1F2616383B00B66C86 /* sigmoid.h */, + 0C12EA202616383B00B66C86 /* channel_shuffle_dnnlowp_op.h */, + 0C12EA212616383B00B66C86 /* int8_gen_quant_params_min_max.h */, + 0C12EA222616383B00B66C86 /* quantization_error_minimization.h */, + 0C12EA232616383B00B66C86 /* elementwise_linear_dnnlowp_op.h */, + 0C12EA242616383B00B66C86 /* dnnlowp_op.h */, + 0C12EA252616383B00B66C86 /* l2_minimization.h */, + 0C12EA262616383B00B66C86 /* dnnlowp.h */, + 0C12EA272616383B00B66C86 /* conv_dnnlowp_acc16_op.h */, + 0C12EA282616383B00B66C86 /* transpose.h */, + 0C12EA292616383B00B66C86 /* pool_dnnlowp_op_avx2.h */, + 0C12EA2A2616383B00B66C86 /* fully_connected_dnnlowp_acc16_op.h */, + ); + path = server; + sourceTree = ""; + }; + 0C12EA2B2616383B00B66C86 /* transforms */ = { + isa = PBXGroup; + children = ( + 0C12EA2C2616383B00B66C86 /* single_op_transform.h */, + 0C12EA2D2616383B00B66C86 /* common_subexpression_elimination.h */, + 0C12EA2E2616383B00B66C86 /* conv_to_nnpack_transform.h */, + 0C12EA2F2616383B00B66C86 /* pattern_net_transform.h */, + ); + path = transforms; + sourceTree = ""; + }; + 0C12EA302616383B00B66C86 /* mobile */ = { + isa = PBXGroup; + children = ( + 0C12EA312616383B00B66C86 /* contrib */, + ); + path = mobile; + sourceTree = ""; + }; + 0C12EA312616383B00B66C86 /* contrib */ = { + isa = PBXGroup; + children = ( + 0C12EA322616383B00B66C86 /* libopencl-stub */, + 0C12EA3D2616383B00B66C86 /* ios */, + 0C12EA472616383B00B66C86 /* snpe */, + 0C12EA492616383B00B66C86 /* nnapi */, + 0C12EA4D2616383B00B66C86 /* ulp2 */, + 0C12EA502616383B00B66C86 /* libvulkan-stub */, + ); + path = contrib; + sourceTree = ""; + }; + 0C12EA322616383B00B66C86 /* libopencl-stub */ = { + isa = PBXGroup; + children = ( + 0C12EA332616383B00B66C86 /* include */, + 0C12EA3C2616383B00B66C86 /* src */, + ); + path = "libopencl-stub"; + sourceTree = ""; + }; + 0C12EA332616383B00B66C86 /* include */ = { + isa = PBXGroup; + children = ( + 0C12EA342616383B00B66C86 /* libopencl.h */, + 0C12EA352616383B00B66C86 /* CL */, + ); + path = include; + sourceTree = ""; + }; + 0C12EA352616383B00B66C86 /* CL */ = { + isa = PBXGroup; + children = ( + 0C12EA362616383B00B66C86 /* cl_platform.h */, + 0C12EA372616383B00B66C86 /* opencl.h */, + 0C12EA382616383B00B66C86 /* cl_ext.h */, + 0C12EA392616383B00B66C86 /* cl.h */, + 0C12EA3A2616383B00B66C86 /* cl_gl.h */, + 0C12EA3B2616383B00B66C86 /* cl_gl_ext.h */, + ); + path = CL; + sourceTree = ""; + }; + 0C12EA3C2616383B00B66C86 /* src */ = { + isa = PBXGroup; + children = ( + ); + path = src; + sourceTree = ""; + }; + 0C12EA3D2616383B00B66C86 /* ios */ = { + isa = PBXGroup; + children = ( + 0C12EA3E2616383B00B66C86 /* ios_caffe_defines.h */, + 0C12EA3F2616383B00B66C86 /* mpscnn */, + 0C12EA452616383B00B66C86 /* ios_caffe.h */, + 0C12EA462616383B00B66C86 /* ios_caffe_predictor.h */, + ); + path = ios; + sourceTree = ""; + }; + 0C12EA3F2616383B00B66C86 /* mpscnn */ = { + isa = PBXGroup; + children = ( + 0C12EA402616383B00B66C86 /* mpscnn_graph_mask.h */, + 0C12EA412616383B00B66C86 /* mpscnn.h */, + 0C12EA422616383B00B66C86 /* mpscnn_test.h */, + 0C12EA432616383B00B66C86 /* mpscnn_kernels.h */, + 0C12EA442616383B00B66C86 /* mpscnn_context.h */, + ); + path = mpscnn; + sourceTree = ""; + }; + 0C12EA472616383B00B66C86 /* snpe */ = { + isa = PBXGroup; + children = ( + 0C12EA482616383B00B66C86 /* snpe_ffi.h */, + ); + path = snpe; + sourceTree = ""; + }; + 0C12EA492616383B00B66C86 /* nnapi */ = { + isa = PBXGroup; + children = ( + 0C12EA4A2616383B00B66C86 /* nnapi.h */, + 0C12EA4B2616383B00B66C86 /* NeuralNetworks.h */, + 0C12EA4C2616383B00B66C86 /* dlnnapi.h */, + ); + path = nnapi; + sourceTree = ""; + }; + 0C12EA4D2616383B00B66C86 /* ulp2 */ = { + isa = PBXGroup; + children = ( + 0C12EA4E2616383B00B66C86 /* ulp.h */, + 0C12EA4F2616383B00B66C86 /* ulp_neon.h */, + ); + path = ulp2; + sourceTree = ""; + }; + 0C12EA502616383B00B66C86 /* libvulkan-stub */ = { + isa = PBXGroup; + children = ( + 0C12EA512616383B00B66C86 /* include */, + 0C12EA562616383B00B66C86 /* src */, + ); + path = "libvulkan-stub"; + sourceTree = ""; + }; + 0C12EA512616383B00B66C86 /* include */ = { + isa = PBXGroup; + children = ( + 0C12EA522616383B00B66C86 /* libvulkan-stub.h */, + 0C12EA532616383B00B66C86 /* vulkan */, + ); + path = include; + sourceTree = ""; + }; + 0C12EA532616383B00B66C86 /* vulkan */ = { + isa = PBXGroup; + children = ( + 0C12EA542616383B00B66C86 /* vulkan.h */, + 0C12EA552616383B00B66C86 /* vk_platform.h */, + ); + path = vulkan; + sourceTree = ""; + }; + 0C12EA562616383B00B66C86 /* src */ = { + isa = PBXGroup; + children = ( + ); + path = src; + sourceTree = ""; + }; + 0C12EA572616383B00B66C86 /* sgd */ = { + isa = PBXGroup; + children = ( + 0C12EA582616383B00B66C86 /* fp16_momentum_sgd_op.h */, + 0C12EA592616383B00B66C86 /* rmsprop_op.h */, + 0C12EA5A2616383B00B66C86 /* lars_op.h */, + 0C12EA5B2616383B00B66C86 /* yellowfin_op.h */, + 0C12EA5C2616383B00B66C86 /* math_lp.h */, + 0C12EA5D2616383B00B66C86 /* storm_op.h */, + 0C12EA5E2616383B00B66C86 /* adagrad_op.h */, + 0C12EA5F2616383B00B66C86 /* clip_tensor_op.h */, + 0C12EA602616383B00B66C86 /* gftrl_op.h */, + 0C12EA612616383B00B66C86 /* adadelta_op.h */, + 0C12EA622616383B00B66C86 /* learning_rate_op.h */, + 0C12EA632616383B00B66C86 /* adagrad_fused.h */, + 0C12EA642616383B00B66C86 /* adam_op.h */, + 0C12EA652616383B00B66C86 /* ftrl_op.h */, + 0C12EA662616383B00B66C86 /* weight_scale_op.h */, + 0C12EA672616383B00B66C86 /* learning_rate_adaption_op.h */, + 0C12EA682616383B00B66C86 /* rowwise_counter.h */, + 0C12EA692616383B00B66C86 /* iter_op.h */, + 0C12EA6A2616383B00B66C86 /* rowwise_adagrad_fused.h */, + 0C12EA6B2616383B00B66C86 /* momentum_sgd_op.h */, + 0C12EA6C2616383B00B66C86 /* wngrad_op.h */, + 0C12EA6D2616383B00B66C86 /* decay_adagrad_op.h */, + 0C12EA6E2616383B00B66C86 /* learning_rate_functors.h */, + 0C12EA6F2616383B00B66C86 /* fp32_momentum_sgd_op.h */, + ); + path = sgd; + sourceTree = ""; + }; + 0C12EA702616383B00B66C86 /* queue */ = { + isa = PBXGroup; + children = ( + 0C12EA712616383B00B66C86 /* blobs_queue.h */, + 0C12EA722616383B00B66C86 /* rebatching_queue_ops.h */, + 0C12EA732616383B00B66C86 /* queue_ops.h */, + 0C12EA742616383B00B66C86 /* rebatching_queue.h */, + 0C12EA752616383B00B66C86 /* blobs_queue_db.h */, + ); + path = queue; + sourceTree = ""; + }; + 0C12EA762616383B00B66C86 /* db */ = { + isa = PBXGroup; + children = ( + 0C12EA772616383B00B66C86 /* create_db_op.h */, + ); + path = db; + sourceTree = ""; + }; + 0C12EA782616383B00B66C86 /* opt */ = { + isa = PBXGroup; + children = ( + 0C12EA792616383B00B66C86 /* nql */, + 0C12EA7D2616383B00B66C86 /* device.h */, + 0C12EA7E2616383B00B66C86 /* annotations.h */, + 0C12EA7F2616383B00B66C86 /* mobile.h */, + 0C12EA802616383B00B66C86 /* onnxifi_transformer.h */, + 0C12EA812616383B00B66C86 /* converter.h */, + 0C12EA822616383B00B66C86 /* backend_transformer_base.h */, + 0C12EA832616383B00B66C86 /* fakefp16_transform.h */, + 0C12EA842616383B00B66C86 /* fusion.h */, + 0C12EA852616383B00B66C86 /* shape_info.h */, + 0C12EA862616383B00B66C86 /* optimizer.h */, + 0C12EA872616383B00B66C86 /* glow_net_transform.h */, + 0C12EA882616383B00B66C86 /* backend_cutting.h */, + 0C12EA892616383B00B66C86 /* distributed.h */, + 0C12EA8A2616383B00B66C86 /* onnxifi_op.h */, + 0C12EA8B2616383B00B66C86 /* tvm_transformer.h */, + 0C12EA8C2616383B00B66C86 /* passes.h */, + 0C12EA8D2616383B00B66C86 /* bound_shape_inferencer.h */, + 0C12EA8E2616383B00B66C86 /* custom */, + 0C12EA942616383B00B66C86 /* onnx_convert.h */, + 0C12EA952616383B00B66C86 /* optimize_ideep.h */, + ); + path = opt; + sourceTree = ""; + }; + 0C12EA792616383B00B66C86 /* nql */ = { + isa = PBXGroup; + children = ( + 0C12EA7A2616383B00B66C86 /* tests */, + 0C12EA7B2616383B00B66C86 /* ast.h */, + 0C12EA7C2616383B00B66C86 /* graphmatcher.h */, + ); + path = nql; + sourceTree = ""; + }; + 0C12EA7A2616383B00B66C86 /* tests */ = { + isa = PBXGroup; + children = ( + ); + path = tests; + sourceTree = ""; + }; + 0C12EA8E2616383B00B66C86 /* custom */ = { + isa = PBXGroup; + children = ( + 0C12EA8F2616383B00B66C86 /* concat_elim.h */, + 0C12EA902616383B00B66C86 /* pointwise_elim.h */, + 0C12EA912616383B00B66C86 /* freeze_quantization_params.h */, + 0C12EA922616383B00B66C86 /* in_batch_broadcast.h */, + 0C12EA932616383B00B66C86 /* cc_amrc.h */, + ); + path = custom; + sourceTree = ""; + }; + 0C12EA962616383B00B66C86 /* predictor */ = { + isa = PBXGroup; + children = ( + 0C12EA972616383B00B66C86 /* ThreadLocalPtr.h */, + 0C12EA982616383B00B66C86 /* InferenceGraph.h */, + 0C12EA992616383B00B66C86 /* predictor_utils.h */, + 0C12EA9A2616383B00B66C86 /* predictor.h */, + 0C12EA9B2616383B00B66C86 /* predictor_config.h */, + 0C12EA9C2616383B00B66C86 /* emulator */, + 0C12EAA62616383B00B66C86 /* transforms.h */, + ); + path = predictor; + sourceTree = ""; + }; + 0C12EA9C2616383B00B66C86 /* emulator */ = { + isa = PBXGroup; + children = ( + 0C12EA9D2616383B00B66C86 /* data_filler.h */, + 0C12EA9E2616383B00B66C86 /* utils.h */, + 0C12EA9F2616383B00B66C86 /* net_supplier.h */, + 0C12EAA02616383B00B66C86 /* time_profiler.h */, + 0C12EAA12616383B00B66C86 /* emulator.h */, + 0C12EAA22616383B00B66C86 /* output_formatter.h */, + 0C12EAA32616383B00B66C86 /* std_output_formatter.h */, + 0C12EAA42616383B00B66C86 /* benchmark.h */, + 0C12EAA52616383B00B66C86 /* profiler.h */, + ); + path = emulator; + sourceTree = ""; + }; + 0C12EAA72616383B00B66C86 /* observers */ = { + isa = PBXGroup; + children = ( + 0C12EAA82616383B00B66C86 /* operator_attaching_net_observer.h */, + 0C12EAA92616383B00B66C86 /* time_observer.h */, + 0C12EAAA2616383B00B66C86 /* runcnt_observer.h */, + 0C12EAAB2616383B00B66C86 /* profile_observer.h */, + ); + path = observers; + sourceTree = ""; + }; + 0C12EAAC2616383B00B66C86 /* share */ = { + isa = PBXGroup; + children = ( + 0C12EAAD2616383B00B66C86 /* contrib */, + ); + path = share; + sourceTree = ""; + }; + 0C12EAAD2616383B00B66C86 /* contrib */ = { + isa = PBXGroup; + children = ( + 0C12EAAE2616383B00B66C86 /* nnpack */, + 0C12EAAF2616383B00B66C86 /* depthwise */, + 0C12EAB02616383B00B66C86 /* zstd */, + ); + path = contrib; + sourceTree = ""; + }; + 0C12EAAE2616383B00B66C86 /* nnpack */ = { + isa = PBXGroup; + children = ( + ); + path = nnpack; + sourceTree = ""; + }; + 0C12EAAF2616383B00B66C86 /* depthwise */ = { + isa = PBXGroup; + children = ( + ); + path = depthwise; + sourceTree = ""; + }; + 0C12EAB02616383B00B66C86 /* zstd */ = { + isa = PBXGroup; + children = ( + 0C12EAB12616383B00B66C86 /* quant_decomp_zstd_op.h */, + ); + path = zstd; + sourceTree = ""; + }; + 0C12EAB32616383B00B66C86 /* torch */ = { + isa = PBXGroup; + children = ( + 0C12EAB42616383B00B66C86 /* csrc */, + 0C12EDA52616383C00B66C86 /* script.h */, + 0C12EDA62616383C00B66C86 /* library.h */, + 0C12EDA72616383C00B66C86 /* custom_class_detail.h */, + 0C12EDA82616383C00B66C86 /* custom_class.h */, + 0C12EDA92616383C00B66C86 /* extension.h */, + ); + path = torch; + sourceTree = ""; + }; + 0C12EAB42616383B00B66C86 /* csrc */ = { + isa = PBXGroup; + children = ( + 0C12EAB52616383B00B66C86 /* Size.h */, + 0C12EAB62616383B00B66C86 /* utils.h */, + 0C12EAB72616383B00B66C86 /* Device.h */, + 0C12EAB82616383B00B66C86 /* onnx */, + 0C12EABB2616383B00B66C86 /* Types.h */, + 0C12EABC2616383B00B66C86 /* distributed */, + 0C12EAFD2616383B00B66C86 /* autograd */, + 0C12EB332616383B00B66C86 /* deploy */, + 0C12EB392616383B00B66C86 /* multiprocessing */, + 0C12EB3B2616383B00B66C86 /* cuda */, + 0C12EB4C2616383B00B66C86 /* serialization.h */, + 0C12EB4D2616383B00B66C86 /* Exceptions.h */, + 0C12EB4E2616383B00B66C86 /* QScheme.h */, + 0C12EB4F2616383B00B66C86 /* utils */, + 0C12EB752616383B00B66C86 /* Stream.h */, + 0C12EB762616383B00B66C86 /* StorageDefs.h */, + 0C12EB772616383B00B66C86 /* DataLoader.h */, + 0C12EB782616383B00B66C86 /* THP.h */, + 0C12EB792616383B00B66C86 /* python_headers.h */, + 0C12EB7A2616383B00B66C86 /* Layout.h */, + 0C12EB7B2616383B00B66C86 /* DynamicTypes.h */, + 0C12EB7C2616383B00B66C86 /* copy_utils.h */, + 0C12EB7D2616383B00B66C86 /* jit */, + 0C12ECDA2616383B00B66C86 /* Storage.h */, + 0C12ECDB2616383B00B66C86 /* api */, + 0C12ED952616383C00B66C86 /* MemoryFormat.h */, + 0C12ED962616383C00B66C86 /* generic */, + 0C12ED9A2616383C00B66C86 /* tensor */, + 0C12ED9C2616383C00B66C86 /* WindowsTorchApiMacro.h */, + 0C12ED9D2616383C00B66C86 /* Dtype.h */, + 0C12ED9E2616383C00B66C86 /* Module.h */, + 0C12ED9F2616383C00B66C86 /* THP_export.h */, + 0C12EDA02616383C00B66C86 /* python_dimname.h */, + 0C12EDA12616383C00B66C86 /* CudaIPCTypes.h */, + 0C12EDA22616383C00B66C86 /* Generator.h */, + 0C12EDA32616383C00B66C86 /* TypeInfo.h */, + 0C12EDA42616383C00B66C86 /* PythonTypes.h */, + ); + path = csrc; + sourceTree = ""; + }; + 0C12EAB82616383B00B66C86 /* onnx */ = { + isa = PBXGroup; + children = ( + 0C12EAB92616383B00B66C86 /* init.h */, + 0C12EABA2616383B00B66C86 /* onnx.h */, + ); + path = onnx; + sourceTree = ""; + }; + 0C12EABC2616383B00B66C86 /* distributed */ = { + isa = PBXGroup; + children = ( + 0C12EABD2616383B00B66C86 /* autograd */, + 0C12EAD42616383B00B66C86 /* rpc */, + 0C12EAFA2616383B00B66C86 /* c10d */, + ); + path = distributed; + sourceTree = ""; + }; + 0C12EABD2616383B00B66C86 /* autograd */ = { + isa = PBXGroup; + children = ( + 0C12EABE2616383B00B66C86 /* utils.h */, + 0C12EABF2616383B00B66C86 /* context */, + 0C12EAC22616383B00B66C86 /* rpc_messages */, + 0C12EACD2616383B00B66C86 /* python_autograd.h */, + 0C12EACE2616383B00B66C86 /* autograd.h */, + 0C12EACF2616383B00B66C86 /* functions */, + 0C12EAD22616383B00B66C86 /* engine */, + ); + path = autograd; + sourceTree = ""; + }; + 0C12EABF2616383B00B66C86 /* context */ = { + isa = PBXGroup; + children = ( + 0C12EAC02616383B00B66C86 /* container.h */, + 0C12EAC12616383B00B66C86 /* context.h */, + ); + path = context; + sourceTree = ""; + }; + 0C12EAC22616383B00B66C86 /* rpc_messages */ = { + isa = PBXGroup; + children = ( + 0C12EAC32616383B00B66C86 /* cleanup_autograd_context_req.h */, + 0C12EAC42616383B00B66C86 /* cleanup_autograd_context_resp.h */, + 0C12EAC52616383B00B66C86 /* rref_backward_req.h */, + 0C12EAC62616383B00B66C86 /* rpc_with_profiling_req.h */, + 0C12EAC72616383B00B66C86 /* propagate_gradients_resp.h */, + 0C12EAC82616383B00B66C86 /* propagate_gradients_req.h */, + 0C12EAC92616383B00B66C86 /* autograd_metadata.h */, + 0C12EACA2616383B00B66C86 /* rpc_with_autograd.h */, + 0C12EACB2616383B00B66C86 /* rref_backward_resp.h */, + 0C12EACC2616383B00B66C86 /* rpc_with_profiling_resp.h */, + ); + path = rpc_messages; + sourceTree = ""; + }; + 0C12EACF2616383B00B66C86 /* functions */ = { + isa = PBXGroup; + children = ( + 0C12EAD02616383B00B66C86 /* sendrpc_backward.h */, + 0C12EAD12616383B00B66C86 /* recvrpc_backward.h */, + ); + path = functions; + sourceTree = ""; + }; + 0C12EAD22616383B00B66C86 /* engine */ = { + isa = PBXGroup; + children = ( + 0C12EAD32616383B00B66C86 /* dist_engine.h */, + ); + path = engine; + sourceTree = ""; + }; + 0C12EAD42616383B00B66C86 /* rpc */ = { + isa = PBXGroup; + children = ( + 0C12EAD52616383B00B66C86 /* metrics */, + 0C12EAD72616383B00B66C86 /* utils.h */, + 0C12EAD82616383B00B66C86 /* rref_context.h */, + 0C12EAD92616383B00B66C86 /* request_callback_impl.h */, + 0C12EADA2616383B00B66C86 /* python_resp.h */, + 0C12EADB2616383B00B66C86 /* rref_impl.h */, + 0C12EADC2616383B00B66C86 /* request_callback.h */, + 0C12EADD2616383B00B66C86 /* types.h */, + 0C12EADE2616383B00B66C86 /* rref_proto.h */, + 0C12EADF2616383B00B66C86 /* py_rref.h */, + 0C12EAE02616383B00B66C86 /* rpc_agent.h */, + 0C12EAE12616383B00B66C86 /* python_functions.h */, + 0C12EAE22616383B00B66C86 /* message.h */, + 0C12EAE32616383B00B66C86 /* request_callback_no_python.h */, + 0C12EAE42616383B00B66C86 /* python_remote_call.h */, + 0C12EAE52616383B00B66C86 /* python_call.h */, + 0C12EAE62616383B00B66C86 /* tensorpipe_agent.h */, + 0C12EAE72616383B00B66C86 /* script_remote_call.h */, + 0C12EAE82616383B00B66C86 /* testing */, + 0C12EAEB2616383B00B66C86 /* macros.h */, + 0C12EAEC2616383B00B66C86 /* script_resp.h */, + 0C12EAED2616383B00B66C86 /* rpc.h */, + 0C12EAEE2616383B00B66C86 /* rpc_command_base.h */, + 0C12EAEF2616383B00B66C86 /* profiler */, + 0C12EAF22616383B00B66C86 /* script_call.h */, + 0C12EAF32616383B00B66C86 /* unpickled_python_remote_call.h */, + 0C12EAF42616383B00B66C86 /* torchscript_functions.h */, + 0C12EAF52616383B00B66C86 /* unpickled_python_call.h */, + 0C12EAF62616383B00B66C86 /* tensorpipe_utils.h */, + 0C12EAF72616383B00B66C86 /* agent_utils.h */, + 0C12EAF82616383B00B66C86 /* process_group_agent.h */, + 0C12EAF92616383B00B66C86 /* python_rpc_handler.h */, + ); + path = rpc; + sourceTree = ""; + }; + 0C12EAD52616383B00B66C86 /* metrics */ = { + isa = PBXGroup; + children = ( + 0C12EAD62616383B00B66C86 /* RpcMetricsHandler.h */, + ); + path = metrics; + sourceTree = ""; + }; + 0C12EAE82616383B00B66C86 /* testing */ = { + isa = PBXGroup; + children = ( + 0C12EAE92616383B00B66C86 /* testing.h */, + 0C12EAEA2616383B00B66C86 /* faulty_process_group_agent.h */, + ); + path = testing; + sourceTree = ""; + }; + 0C12EAEF2616383B00B66C86 /* profiler */ = { + isa = PBXGroup; + children = ( + 0C12EAF02616383B00B66C86 /* remote_profiler_manager.h */, + 0C12EAF12616383B00B66C86 /* server_process_global_profiler.h */, + ); + path = profiler; + sourceTree = ""; + }; + 0C12EAFA2616383B00B66C86 /* c10d */ = { + isa = PBXGroup; + children = ( + 0C12EAFB2616383B00B66C86 /* python_comm_hook.h */, + 0C12EAFC2616383B00B66C86 /* c10d.h */, + ); + path = c10d; + sourceTree = ""; + }; + 0C12EAFD2616383B00B66C86 /* autograd */ = { + isa = PBXGroup; + children = ( + 0C12EAFE2616383B00B66C86 /* generated */, + 0C12EB022616383B00B66C86 /* python_function.h */, + 0C12EB032616383B00B66C86 /* custom_function.h */, + 0C12EB042616383B00B66C86 /* python_linalg_functions.h */, + 0C12EB052616383B00B66C86 /* record_function_ops.h */, + 0C12EB062616383B00B66C86 /* engine.h */, + 0C12EB072616383B00B66C86 /* edge.h */, + 0C12EB082616383B00B66C86 /* saved_variable.h */, + 0C12EB092616383B00B66C86 /* python_engine.h */, + 0C12EB0A2616383B00B66C86 /* python_legacy_variable.h */, + 0C12EB0B2616383B00B66C86 /* python_cpp_function.h */, + 0C12EB0C2616383B00B66C86 /* python_hook.h */, + 0C12EB0D2616383B00B66C86 /* VariableTypeUtils.h */, + 0C12EB0E2616383B00B66C86 /* python_autograd.h */, + 0C12EB0F2616383B00B66C86 /* profiler_kineto.h */, + 0C12EB102616383B00B66C86 /* variable.h */, + 0C12EB112616383B00B66C86 /* utils */, + 0C12EB172616383B00B66C86 /* python_fft_functions.h */, + 0C12EB182616383B00B66C86 /* python_variable.h */, + 0C12EB192616383B00B66C86 /* function_hook.h */, + 0C12EB1A2616383B00B66C86 /* input_metadata.h */, + 0C12EB1B2616383B00B66C86 /* grad_mode.h */, + 0C12EB1C2616383B00B66C86 /* symbolic.h */, + 0C12EB1D2616383B00B66C86 /* input_buffer.h */, + 0C12EB1E2616383B00B66C86 /* profiler_legacy.h */, + 0C12EB1F2616383B00B66C86 /* autograd.h */, + 0C12EB202616383B00B66C86 /* cpp_hook.h */, + 0C12EB212616383B00B66C86 /* functions */, + 0C12EB282616383B00B66C86 /* python_special_functions.h */, + 0C12EB292616383B00B66C86 /* FunctionsManual.h */, + 0C12EB2A2616383B00B66C86 /* forward_grad.h */, + 0C12EB2B2616383B00B66C86 /* python_anomaly_mode.h */, + 0C12EB2C2616383B00B66C86 /* python_nn_functions.h */, + 0C12EB2D2616383B00B66C86 /* InferenceMode.h */, + 0C12EB2E2616383B00B66C86 /* python_variable_indexing.h */, + 0C12EB2F2616383B00B66C86 /* profiler.h */, + 0C12EB302616383B00B66C86 /* function.h */, + 0C12EB312616383B00B66C86 /* anomaly_mode.h */, + 0C12EB322616383B00B66C86 /* profiler_utils.h */, + ); + path = autograd; + sourceTree = ""; + }; + 0C12EAFE2616383B00B66C86 /* generated */ = { + isa = PBXGroup; + children = ( + 0C12EAFF2616383B00B66C86 /* python_functions.h */, + 0C12EB002616383B00B66C86 /* Functions.h */, + 0C12EB012616383B00B66C86 /* variable_factories.h */, + ); + path = generated; + sourceTree = ""; + }; + 0C12EB112616383B00B66C86 /* utils */ = { + isa = PBXGroup; + children = ( + 0C12EB122616383B00B66C86 /* wrap_outputs.h */, + 0C12EB132616383B00B66C86 /* python_arg_parsing.h */, + 0C12EB142616383B00B66C86 /* grad_layout_contract.h */, + 0C12EB152616383B00B66C86 /* lambda_post_hook.h */, + 0C12EB162616383B00B66C86 /* error_messages.h */, + ); + path = utils; + sourceTree = ""; + }; + 0C12EB212616383B00B66C86 /* functions */ = { + isa = PBXGroup; + children = ( + 0C12EB222616383B00B66C86 /* utils.h */, + 0C12EB232616383B00B66C86 /* pybind.h */, + 0C12EB242616383B00B66C86 /* comm.h */, + 0C12EB252616383B00B66C86 /* basic_ops.h */, + 0C12EB262616383B00B66C86 /* accumulate_grad.h */, + 0C12EB272616383B00B66C86 /* tensor.h */, + ); + path = functions; + sourceTree = ""; + }; + 0C12EB332616383B00B66C86 /* deploy */ = { + isa = PBXGroup; + children = ( + 0C12EB342616383B00B66C86 /* interpreter */, + 0C12EB372616383B00B66C86 /* example */, + 0C12EB382616383B00B66C86 /* deploy.h */, + ); + path = deploy; + sourceTree = ""; + }; + 0C12EB342616383B00B66C86 /* interpreter */ = { + isa = PBXGroup; + children = ( + 0C12EB352616383B00B66C86 /* interpreter_impl.h */, + 0C12EB362616383B00B66C86 /* third_party */, + ); + path = interpreter; + sourceTree = ""; + }; + 0C12EB362616383B00B66C86 /* third_party */ = { + isa = PBXGroup; + children = ( + ); + path = third_party; + sourceTree = ""; + }; + 0C12EB372616383B00B66C86 /* example */ = { + isa = PBXGroup; + children = ( + ); + path = example; + sourceTree = ""; + }; + 0C12EB392616383B00B66C86 /* multiprocessing */ = { + isa = PBXGroup; + children = ( + 0C12EB3A2616383B00B66C86 /* init.h */, + ); + path = multiprocessing; + sourceTree = ""; + }; + 0C12EB3B2616383B00B66C86 /* cuda */ = { + isa = PBXGroup; + children = ( + 0C12EB3C2616383B00B66C86 /* utils.h */, + 0C12EB3D2616383B00B66C86 /* THCP.h */, + 0C12EB3E2616383B00B66C86 /* nccl.h */, + 0C12EB3F2616383B00B66C86 /* python_nccl.h */, + 0C12EB402616383B00B66C86 /* device_set.h */, + 0C12EB412616383B00B66C86 /* Event.h */, + 0C12EB422616383B00B66C86 /* serialization.h */, + 0C12EB432616383B00B66C86 /* python_comm.h */, + 0C12EB442616383B00B66C86 /* comm.h */, + 0C12EB452616383B00B66C86 /* Stream.h */, + 0C12EB462616383B00B66C86 /* shared */, + 0C12EB472616383B00B66C86 /* undef_macros.h */, + 0C12EB482616383B00B66C86 /* restore_macros.h */, + 0C12EB492616383B00B66C86 /* Storage.h */, + 0C12EB4A2616383B00B66C86 /* Module.h */, + 0C12EB4B2616383B00B66C86 /* override_macros.h */, + ); + path = cuda; + sourceTree = ""; + }; + 0C12EB462616383B00B66C86 /* shared */ = { + isa = PBXGroup; + children = ( + ); + path = shared; + sourceTree = ""; + }; + 0C12EB4F2616383B00B66C86 /* utils */ = { + isa = PBXGroup; + children = ( + 0C12EB502616383B00B66C86 /* object_ptr.h */, + 0C12EB512616383B00B66C86 /* tensor_numpy.h */, + 0C12EB522616383B00B66C86 /* tensor_dtypes.h */, + 0C12EB532616383B00B66C86 /* python_tuples.h */, + 0C12EB542616383B00B66C86 /* python_numbers.h */, + 0C12EB552616383B00B66C86 /* python_scalars.h */, + 0C12EB562616383B00B66C86 /* pybind.h */, + 0C12EB572616383B00B66C86 /* tensor_types.h */, + 0C12EB582616383B00B66C86 /* tensor_memoryformats.h */, + 0C12EB592616383B00B66C86 /* python_arg_parser.h */, + 0C12EB5A2616383B00B66C86 /* cuda_lazy_init.h */, + 0C12EB5B2616383B00B66C86 /* tensor_new.h */, + 0C12EB5C2616383B00B66C86 /* tensor_qschemes.h */, + 0C12EB5D2616383B00B66C86 /* python_dispatch.h */, + 0C12EB5E2616383B00B66C86 /* tensor_list.h */, + 0C12EB5F2616383B00B66C86 /* invalid_arguments.h */, + 0C12EB602616383B00B66C86 /* auto_gil.h */, + 0C12EB612616383B00B66C86 /* python_strings.h */, + 0C12EB622616383B00B66C86 /* byte_order.h */, + 0C12EB632616383B00B66C86 /* pycfunction_helpers.h */, + 0C12EB642616383B00B66C86 /* cuda_enabled.h */, + 0C12EB652616383B00B66C86 /* numpy_stub.h */, + 0C12EB662616383B00B66C86 /* out_types.h */, + 0C12EB672616383B00B66C86 /* memory.h */, + 0C12EB682616383B00B66C86 /* tensor_layouts.h */, + 0C12EB692616383B00B66C86 /* structseq.h */, + 0C12EB6A2616383B00B66C86 /* throughput_benchmark.h */, + 0C12EB6B2616383B00B66C86 /* disable_torch_function.h */, + 0C12EB6C2616383B00B66C86 /* throughput_benchmark-inl.h */, + 0C12EB6D2616383B00B66C86 /* tensor_flatten.h */, + 0C12EB6E2616383B00B66C86 /* tensor_apply.h */, + 0C12EB6F2616383B00B66C86 /* init.h */, + 0C12EB702616383B00B66C86 /* python_compat.h */, + 0C12EB712616383B00B66C86 /* disallow_copy.h */, + 0C12EB722616383B00B66C86 /* six.h */, + 0C12EB732616383B00B66C86 /* python_stub.h */, + 0C12EB742616383B00B66C86 /* variadic.h */, + ); + path = utils; + sourceTree = ""; + }; + 0C12EB7D2616383B00B66C86 /* jit */ = { + isa = PBXGroup; + children = ( + 0C12EB7E2616383B00B66C86 /* generated */, + 0C12EB7F2616383B00B66C86 /* jit_opt_limit.h */, + 0C12EB802616383B00B66C86 /* frontend */, + 0C12EB9D2616383B00B66C86 /* python */, + 0C12EBAB2616383B00B66C86 /* tensorexpr */, + 0C12EBD22616383B00B66C86 /* ir */, + 0C12EBDF2616383B00B66C86 /* cuda */, + 0C12EBE12616383B00B66C86 /* serialization */, + 0C12EBF12616383B00B66C86 /* backends */, + 0C12EBF72616383B00B66C86 /* runtime */, + 0C12EC122616383B00B66C86 /* passes */, + 0C12EC752616383B00B66C86 /* docs */, + 0C12EC762616383B00B66C86 /* codegen */, + 0C12ECC22616383B00B66C86 /* testing */, + 0C12ECC52616383B00B66C86 /* jit_log.h */, + 0C12ECC62616383B00B66C86 /* mobile */, + 0C12ECD32616383B00B66C86 /* resource_guard.h */, + 0C12ECD42616383B00B66C86 /* api */, + ); + path = jit; + sourceTree = ""; + }; + 0C12EB7E2616383B00B66C86 /* generated */ = { + isa = PBXGroup; + children = ( + ); + path = generated; + sourceTree = ""; + }; + 0C12EB802616383B00B66C86 /* frontend */ = { + isa = PBXGroup; + children = ( + 0C12EB812616383B00B66C86 /* error_report.h */, + 0C12EB822616383B00B66C86 /* source_range.h */, + 0C12EB832616383B00B66C86 /* edit_distance.h */, + 0C12EB842616383B00B66C86 /* canonicalize_modified_loop.h */, + 0C12EB852616383B00B66C86 /* schema_matching.h */, + 0C12EB862616383B00B66C86 /* function_schema_parser.h */, + 0C12EB872616383B00B66C86 /* tree_views.h */, + 0C12EB882616383B00B66C86 /* ir_emitter.h */, + 0C12EB892616383B00B66C86 /* parser.h */, + 0C12EB8A2616383B00B66C86 /* strtod.h */, + 0C12EB8B2616383B00B66C86 /* tree.h */, + 0C12EB8C2616383B00B66C86 /* concrete_module_type.h */, + 0C12EB8D2616383B00B66C86 /* builtin_functions.h */, + 0C12EB8E2616383B00B66C86 /* exit_transforms.h */, + 0C12EB8F2616383B00B66C86 /* parse_string_literal.h */, + 0C12EB902616383B00B66C86 /* sugared_value.h */, + 0C12EB912616383B00B66C86 /* inline_loop_condition.h */, + 0C12EB922616383B00B66C86 /* name_mangler.h */, + 0C12EB932616383B00B66C86 /* code_template.h */, + 0C12EB942616383B00B66C86 /* tracer.h */, + 0C12EB952616383B00B66C86 /* resolver.h */, + 0C12EB962616383B00B66C86 /* script_type_parser.h */, + 0C12EB972616383B00B66C86 /* schema_type_parser.h */, + 0C12EB982616383B00B66C86 /* lexer.h */, + 0C12EB992616383B00B66C86 /* versioned_symbols.h */, + 0C12EB9A2616383B00B66C86 /* convert_to_ssa.h */, + 0C12EB9B2616383B00B66C86 /* mini_environment.h */, + 0C12EB9C2616383B00B66C86 /* parser_constants.h */, + ); + path = frontend; + sourceTree = ""; + }; + 0C12EB9D2616383B00B66C86 /* python */ = { + isa = PBXGroup; + children = ( + 0C12EB9E2616383B00B66C86 /* pybind.h */, + 0C12EB9F2616383B00B66C86 /* python_ir.h */, + 0C12EBA02616383B00B66C86 /* script_init.h */, + 0C12EBA12616383B00B66C86 /* python_tree_views.h */, + 0C12EBA22616383B00B66C86 /* python_ivalue.h */, + 0C12EBA32616383B00B66C86 /* python_custom_class.h */, + 0C12EBA42616383B00B66C86 /* update_graph_executor_opt.h */, + 0C12EBA52616383B00B66C86 /* python_tracer.h */, + 0C12EBA62616383B00B66C86 /* pybind_utils.h */, + 0C12EBA72616383B00B66C86 /* init.h */, + 0C12EBA82616383B00B66C86 /* python_sugared_value.h */, + 0C12EBA92616383B00B66C86 /* python_arg_flatten.h */, + 0C12EBAA2616383B00B66C86 /* module_python.h */, + ); + path = python; + sourceTree = ""; + }; + 0C12EBAB2616383B00B66C86 /* tensorexpr */ = { + isa = PBXGroup; + children = ( + 0C12EBAC2616383B00B66C86 /* ir_mutator.h */, + 0C12EBAD2616383B00B66C86 /* ir_simplifier.h */, + 0C12EBAE2616383B00B66C86 /* ir_visitor.h */, + 0C12EBAF2616383B00B66C86 /* llvm_jit.h */, + 0C12EBB02616383B00B66C86 /* tensorexpr_init.h */, + 0C12EBB12616383B00B66C86 /* types.h */, + 0C12EBB22616383B00B66C86 /* mem_dependency_checker.h */, + 0C12EBB32616383B00B66C86 /* ir.h */, + 0C12EBB42616383B00B66C86 /* exceptions.h */, + 0C12EBB52616383B00B66C86 /* cuda_codegen.h */, + 0C12EBB62616383B00B66C86 /* hash_provider.h */, + 0C12EBB72616383B00B66C86 /* ir_printer.h */, + 0C12EBB82616383B00B66C86 /* llvm_codegen.h */, + 0C12EBB92616383B00B66C86 /* expr.h */, + 0C12EBBA2616383B00B66C86 /* cuda_random.h */, + 0C12EBBB2616383B00B66C86 /* execution_counter.h */, + 0C12EBBC2616383B00B66C86 /* codegen.h */, + 0C12EBBD2616383B00B66C86 /* unique_name_manager.h */, + 0C12EBBE2616383B00B66C86 /* cpp_codegen.h */, + 0C12EBBF2616383B00B66C86 /* var_substitutor.h */, + 0C12EBC02616383B00B66C86 /* eval.h */, + 0C12EBC12616383B00B66C86 /* bounds_inference.h */, + 0C12EBC22616383B00B66C86 /* intrinsic_symbols.h */, + 0C12EBC32616383B00B66C86 /* block_codegen.h */, + 0C12EBC42616383B00B66C86 /* external_functions_registry.h */, + 0C12EBC52616383B00B66C86 /* kernel.h */, + 0C12EBC62616383B00B66C86 /* loopnest.h */, + 0C12EBC72616383B00B66C86 /* bounds_overlap.h */, + 0C12EBC82616383B00B66C86 /* ir_verifier.h */, + 0C12EBC92616383B00B66C86 /* dim_arg.h */, + 0C12EBCA2616383B00B66C86 /* external_functions.h */, + 0C12EBCB2616383B00B66C86 /* stmt.h */, + 0C12EBCC2616383B00B66C86 /* half_support.h */, + 0C12EBCD2616383B00B66C86 /* registerizer.h */, + 0C12EBCE2616383B00B66C86 /* reduction.h */, + 0C12EBCF2616383B00B66C86 /* tensor.h */, + 0C12EBD02616383B00B66C86 /* mem_arena.h */, + 0C12EBD12616383B00B66C86 /* analysis.h */, + ); + path = tensorexpr; + sourceTree = ""; + }; + 0C12EBD22616383B00B66C86 /* ir */ = { + isa = PBXGroup; + children = ( + 0C12EBD32616383B00B66C86 /* named_value.h */, + 0C12EBD42616383B00B66C86 /* irparser.h */, + 0C12EBD52616383B00B66C86 /* ir.h */, + 0C12EBD62616383B00B66C86 /* graph_node_list.h */, + 0C12EBD72616383B00B66C86 /* ir_views.h */, + 0C12EBD82616383B00B66C86 /* alias_analysis.h */, + 0C12EBD92616383B00B66C86 /* attributes.h */, + 0C12EBDA2616383B00B66C86 /* type_hashing.h */, + 0C12EBDB2616383B00B66C86 /* constants.h */, + 0C12EBDC2616383B00B66C86 /* subgraph_matcher.h */, + 0C12EBDD2616383B00B66C86 /* scope.h */, + 0C12EBDE2616383B00B66C86 /* node_hashing.h */, + ); + path = ir; + sourceTree = ""; + }; + 0C12EBDF2616383B00B66C86 /* cuda */ = { + isa = PBXGroup; + children = ( + 0C12EBE02616383B00B66C86 /* cuda.h */, + ); + path = cuda; + sourceTree = ""; + }; + 0C12EBE12616383B00B66C86 /* serialization */ = { + isa = PBXGroup; + children = ( + 0C12EBE22616383B00B66C86 /* import_source.h */, + 0C12EBE32616383B00B66C86 /* export.h */, + 0C12EBE42616383B00B66C86 /* import_export_helpers.h */, + 0C12EBE52616383B00B66C86 /* type_name_uniquer.h */, + 0C12EBE62616383B00B66C86 /* pickler.h */, + 0C12EBE72616383B00B66C86 /* python_print.h */, + 0C12EBE82616383B00B66C86 /* import_legacy.h */, + 0C12EBE92616383B00B66C86 /* import_export_functions.h */, + 0C12EBEA2616383B00B66C86 /* pickle.h */, + 0C12EBEB2616383B00B66C86 /* import_export_constants.h */, + 0C12EBEC2616383B00B66C86 /* source_range_serialization_impl.h */, + 0C12EBED2616383B00B66C86 /* import.h */, + 0C12EBEE2616383B00B66C86 /* unpickler.h */, + 0C12EBEF2616383B00B66C86 /* source_range_serialization.h */, + 0C12EBF02616383B00B66C86 /* onnx.h */, + ); + path = serialization; + sourceTree = ""; + }; + 0C12EBF12616383B00B66C86 /* backends */ = { + isa = PBXGroup; + children = ( + 0C12EBF22616383B00B66C86 /* backend_interface.h */, + 0C12EBF32616383B00B66C86 /* backend.h */, + 0C12EBF42616383B00B66C86 /* backend_resolver.h */, + 0C12EBF52616383B00B66C86 /* backend_detail.h */, + 0C12EBF62616383B00B66C86 /* backend_init.h */, + ); + path = backends; + sourceTree = ""; + }; + 0C12EBF72616383B00B66C86 /* runtime */ = { + isa = PBXGroup; + children = ( + 0C12EBF82616383B00B66C86 /* slice_indices_adjust.h */, + 0C12EBF92616383B00B66C86 /* operator.h */, + 0C12EBFA2616383B00B66C86 /* interpreter.h */, + 0C12EBFB2616383B00B66C86 /* register_ops_utils.h */, + 0C12EBFC2616383B00B66C86 /* jit_exception.h */, + 0C12EBFD2616383B00B66C86 /* exception_message.h */, + 0C12EBFE2616383B00B66C86 /* argument_spec.h */, + 0C12EBFF2616383B00B66C86 /* logging.h */, + 0C12EC002616383B00B66C86 /* profiling_graph_executor_impl.h */, + 0C12EC012616383B00B66C86 /* custom_operator.h */, + 0C12EC022616383B00B66C86 /* static */, + 0C12EC082616383B00B66C86 /* vararg_functions.h */, + 0C12EC092616383B00B66C86 /* symbolic_script.h */, + 0C12EC0A2616383B00B66C86 /* variable_tensor_list.h */, + 0C12EC0B2616383B00B66C86 /* autodiff.h */, + 0C12EC0C2616383B00B66C86 /* print_handler.h */, + 0C12EC0D2616383B00B66C86 /* profiling_record.h */, + 0C12EC0E2616383B00B66C86 /* graph_executor.h */, + 0C12EC0F2616383B00B66C86 /* operator_options.h */, + 0C12EC102616383B00B66C86 /* instruction.h */, + 0C12EC112616383B00B66C86 /* graph_executor_impl.h */, + ); + path = runtime; + sourceTree = ""; + }; + 0C12EC022616383B00B66C86 /* static */ = { + isa = PBXGroup; + children = ( + 0C12EC032616383B00B66C86 /* fusion.h */, + 0C12EC042616383B00B66C86 /* passes.h */, + 0C12EC052616383B00B66C86 /* ops.h */, + 0C12EC062616383B00B66C86 /* impl.h */, + 0C12EC072616383B00B66C86 /* init.h */, + ); + path = static; + sourceTree = ""; + }; + 0C12EC122616383B00B66C86 /* passes */ = { + isa = PBXGroup; + children = ( + 0C12EC132616383B00B66C86 /* remove_expands.h */, + 0C12EC142616383B00B66C86 /* peephole_list_idioms.h */, + 0C12EC152616383B00B66C86 /* subgraph_rewrite.h */, + 0C12EC162616383B00B66C86 /* fuse_relu.h */, + 0C12EC172616383B00B66C86 /* guard_elimination.h */, + 0C12EC182616383B00B66C86 /* peephole_alias_sensitive.h */, + 0C12EC192616383B00B66C86 /* freeze_module.h */, + 0C12EC1A2616383B00B66C86 /* clear_undefinedness.h */, + 0C12EC1B2616383B00B66C86 /* peephole.h */, + 0C12EC1C2616383B00B66C86 /* remove_dropout.h */, + 0C12EC1D2616383B00B66C86 /* update_differentiable_graph_requires_grad.h */, + 0C12EC1E2616383B00B66C86 /* metal_rewrite.h */, + 0C12EC1F2616383B00B66C86 /* liveness.h */, + 0C12EC202616383B00B66C86 /* onnx */, + 0C12EC362616383B00B66C86 /* remove_mutation.h */, + 0C12EC372616383B00B66C86 /* common_subexpression_elimination.h */, + 0C12EC382616383B00B66C86 /* batch_mm.h */, + 0C12EC392616383B00B66C86 /* constant_pooling.h */, + 0C12EC3A2616383B00B66C86 /* canonicalize_graph_fuser_ops.h */, + 0C12EC3B2616383B00B66C86 /* fuse_linear.h */, + 0C12EC3C2616383B00B66C86 /* annotate_warns.h */, + 0C12EC3D2616383B00B66C86 /* specialize_autogradzero.h */, + 0C12EC3E2616383B00B66C86 /* prepack_folding.h */, + 0C12EC3F2616383B00B66C86 /* frozen_conv_folding.h */, + 0C12EC402616383B00B66C86 /* constant_propagation.h */, + 0C12EC412616383B00B66C86 /* insert_guards.h */, + 0C12EC422616383B00B66C86 /* utils */, + 0C12EC462616383B00B66C86 /* inliner.h */, + 0C12EC472616383B00B66C86 /* lower_grad_of.h */, + 0C12EC482616383B00B66C86 /* quantization */, + 0C12EC512616383B00B66C86 /* normalize_ops.h */, + 0C12EC522616383B00B66C86 /* vulkan_rewrite.h */, + 0C12EC532616383B00B66C86 /* erase_number_types.h */, + 0C12EC542616383B00B66C86 /* graph_rewrite_helper.h */, + 0C12EC552616383B00B66C86 /* graph_fuser.h */, + 0C12EC562616383B00B66C86 /* fold_conv_bn.h */, + 0C12EC572616383B00B66C86 /* remove_redundant_profiles.h */, + 0C12EC582616383B00B66C86 /* inline_forked_closures.h */, + 0C12EC592616383B00B66C86 /* tensorexpr_fuser.h */, + 0C12EC5A2616383B00B66C86 /* decompose_ops.h */, + 0C12EC5B2616383B00B66C86 /* remove_inplace_ops.h */, + 0C12EC5C2616383B00B66C86 /* inline_fork_wait.h */, + 0C12EC5D2616383B00B66C86 /* create_autodiff_subgraphs.h */, + 0C12EC5E2616383B00B66C86 /* requires_grad_analysis.h */, + 0C12EC5F2616383B00B66C86 /* dead_code_elimination.h */, + 0C12EC602616383B00B66C86 /* clear_profiling.h */, + 0C12EC612616383B00B66C86 /* create_functional_graphs.h */, + 0C12EC622616383B00B66C86 /* bailout_graph.h */, + 0C12EC632616383B00B66C86 /* lower_tuples.h */, + 0C12EC642616383B00B66C86 /* frozen_graph_optimizations.h */, + 0C12EC652616383B00B66C86 /* frozen_ops_to_mkldnn.h */, + 0C12EC662616383B00B66C86 /* canonicalize.h */, + 0C12EC672616383B00B66C86 /* hoist_conv_packed_params.h */, + 0C12EC682616383B00B66C86 /* loop_unrolling.h */, + 0C12EC692616383B00B66C86 /* shape_analysis.h */, + 0C12EC6A2616383B00B66C86 /* fixup_trace_scope_blocks.h */, + 0C12EC6B2616383B00B66C86 /* remove_exceptions.h */, + 0C12EC6C2616383B00B66C86 /* inline_autodiff_subgraphs.h */, + 0C12EC6D2616383B00B66C86 /* inplace_check.h */, + 0C12EC6E2616383B00B66C86 /* cuda_graph_fuser.h */, + 0C12EC6F2616383B00B66C86 /* pass_manager.h */, + 0C12EC702616383B00B66C86 /* onnx.h */, + 0C12EC712616383B00B66C86 /* xnnpack_rewrite.h */, + 0C12EC722616383B00B66C86 /* lift_closures.h */, + 0C12EC732616383B00B66C86 /* frozen_conv_add_relu_fusion.h */, + 0C12EC742616383B00B66C86 /* lower_graph.h */, + ); + path = passes; + sourceTree = ""; + }; + 0C12EC202616383B00B66C86 /* onnx */ = { + isa = PBXGroup; + children = ( + 0C12EC212616383B00B66C86 /* eval_peephole.h */, + 0C12EC222616383B00B66C86 /* function_substitution.h */, + 0C12EC232616383B00B66C86 /* helper.h */, + 0C12EC242616383B00B66C86 /* unpack_quantized_weights.h */, + 0C12EC252616383B00B66C86 /* preprocess_for_onnx.h */, + 0C12EC262616383B00B66C86 /* scalar_type_analysis.h */, + 0C12EC272616383B00B66C86 /* shape_type_inference.h */, + 0C12EC282616383B00B66C86 /* peephole.h */, + 0C12EC292616383B00B66C86 /* eliminate_unused_items.h */, + 0C12EC2A2616383B00B66C86 /* constant_fold.h */, + 0C12EC2B2616383B00B66C86 /* constant_map.h */, + 0C12EC2C2616383B00B66C86 /* fixup_onnx_controlflow.h */, + 0C12EC2D2616383B00B66C86 /* cast_all_constant_to_floating.h */, + 0C12EC2E2616383B00B66C86 /* fold_if_node.h */, + 0C12EC2F2616383B00B66C86 /* list_model_parameters.h */, + 0C12EC302616383B00B66C86 /* pattern_conversion */, + 0C12EC342616383B00B66C86 /* remove_inplace_ops_for_onnx.h */, + 0C12EC352616383B00B66C86 /* prepare_division_for_onnx.h */, + ); + path = onnx; + sourceTree = ""; + }; + 0C12EC302616383B00B66C86 /* pattern_conversion */ = { + isa = PBXGroup; + children = ( + 0C12EC312616383B00B66C86 /* common.h */, + 0C12EC322616383B00B66C86 /* pattern_conversion.h */, + 0C12EC332616383B00B66C86 /* pattern_encapsulation.h */, + ); + path = pattern_conversion; + sourceTree = ""; + }; + 0C12EC422616383B00B66C86 /* utils */ = { + isa = PBXGroup; + children = ( + 0C12EC432616383B00B66C86 /* memory_dag.h */, + 0C12EC442616383B00B66C86 /* subgraph_utils.h */, + 0C12EC452616383B00B66C86 /* check_alias_annotation.h */, + ); + path = utils; + sourceTree = ""; + }; + 0C12EC482616383B00B66C86 /* quantization */ = { + isa = PBXGroup; + children = ( + 0C12EC492616383B00B66C86 /* helper.h */, + 0C12EC4A2616383B00B66C86 /* quantization_type.h */, + 0C12EC4B2616383B00B66C86 /* insert_observers.h */, + 0C12EC4C2616383B00B66C86 /* dedup_module_uses.h */, + 0C12EC4D2616383B00B66C86 /* quantization_patterns.h */, + 0C12EC4E2616383B00B66C86 /* finalize.h */, + 0C12EC4F2616383B00B66C86 /* insert_quant_dequant.h */, + 0C12EC502616383B00B66C86 /* fusion_passes.h */, + ); + path = quantization; + sourceTree = ""; + }; + 0C12EC752616383B00B66C86 /* docs */ = { + isa = PBXGroup; + children = ( + ); + path = docs; + sourceTree = ""; + }; + 0C12EC762616383B00B66C86 /* codegen */ = { + isa = PBXGroup; + children = ( + 0C12EC772616383B00B66C86 /* cuda */, + 0C12ECAE2616383B00B66C86 /* fuser */, + ); + path = codegen; + sourceTree = ""; + }; + 0C12EC772616383B00B66C86 /* cuda */ = { + isa = PBXGroup; + children = ( + 0C12EC782616383B00B66C86 /* type.h */, + 0C12EC792616383B00B66C86 /* executor_kernel_arg.h */, + 0C12EC7A2616383B00B66C86 /* utils.h */, + 0C12EC7B2616383B00B66C86 /* kernel_ir_printer.h */, + 0C12EC7C2616383B00B66C86 /* tools */, + 0C12EC7D2616383B00B66C86 /* index_compute.h */, + 0C12EC7E2616383B00B66C86 /* transform_replay.h */, + 0C12EC7F2616383B00B66C86 /* parser.h */, + 0C12EC802616383B00B66C86 /* executor_utils.h */, + 0C12EC812616383B00B66C86 /* manager.h */, + 0C12EC822616383B00B66C86 /* scheduler.h */, + 0C12EC832616383B00B66C86 /* lower_unroll.h */, + 0C12EC842616383B00B66C86 /* runtime */, + 0C12EC852616383B00B66C86 /* ir_printer.h */, + 0C12EC862616383B00B66C86 /* lower_insert_syncs.h */, + 0C12EC872616383B00B66C86 /* lower2device.h */, + 0C12EC882616383B00B66C86 /* predicate_compute.h */, + 0C12EC892616383B00B66C86 /* compute_at.h */, + 0C12EC8A2616383B00B66C86 /* ir_all_nodes.h */, + 0C12EC8B2616383B00B66C86 /* mutator.h */, + 0C12EC8C2616383B00B66C86 /* docs */, + 0C12EC8F2616383B00B66C86 /* fusion.h */, + 0C12EC902616383B00B66C86 /* lower_loops.h */, + 0C12EC912616383B00B66C86 /* interface.h */, + 0C12EC922616383B00B66C86 /* arith.h */, + 0C12EC932616383B00B66C86 /* kernel_cache.h */, + 0C12EC942616383B00B66C86 /* codegen.h */, + 0C12EC952616383B00B66C86 /* ir_utils.h */, + 0C12EC962616383B00B66C86 /* lower_utils.h */, + 0C12EC972616383B00B66C86 /* lower_index.h */, + 0C12EC982616383B00B66C86 /* transform_rfactor.h */, + 0C12EC992616383B00B66C86 /* transform_iter.h */, + 0C12EC9A2616383B00B66C86 /* lower_alias_memory.h */, + 0C12EC9B2616383B00B66C86 /* executor.h */, + 0C12EC9C2616383B00B66C86 /* ir_graphviz.h */, + 0C12EC9D2616383B00B66C86 /* ir_iostream.h */, + 0C12EC9E2616383B00B66C86 /* partition.h */, + 0C12EC9F2616383B00B66C86 /* shape_inference.h */, + 0C12ECA02616383B00B66C86 /* kernel_ir_builder.h */, + 0C12ECA12616383B00B66C86 /* instrumentation.h */, + 0C12ECA22616383B00B66C86 /* kernel.h */, + 0C12ECA32616383B00B66C86 /* dispatch.h */, + 0C12ECA42616383B00B66C86 /* lower_validation.h */, + 0C12ECA52616383B00B66C86 /* ir_internal_nodes.h */, + 0C12ECA62616383B00B66C86 /* lower_thread_predicate.h */, + 0C12ECA72616383B00B66C86 /* ir_interface_nodes.h */, + 0C12ECA82616383B00B66C86 /* ir_cloner.h */, + 0C12ECA92616383B00B66C86 /* ir_base_nodes.h */, + 0C12ECAA2616383B00B66C86 /* executor_launch_params.h */, + 0C12ECAB2616383B00B66C86 /* kernel_ir.h */, + 0C12ECAC2616383B00B66C86 /* iter_visitor.h */, + 0C12ECAD2616383B00B66C86 /* expr_evaluator.h */, + ); + path = cuda; + sourceTree = ""; + }; + 0C12EC7C2616383B00B66C86 /* tools */ = { + isa = PBXGroup; + children = ( + ); + path = tools; + sourceTree = ""; + }; + 0C12EC842616383B00B66C86 /* runtime */ = { + isa = PBXGroup; + children = ( + ); + path = runtime; + sourceTree = ""; + }; + 0C12EC8C2616383B00B66C86 /* docs */ = { + isa = PBXGroup; + children = ( + 0C12EC8D2616383B00B66C86 /* documentation.h */, + 0C12EC8E2616383B00B66C86 /* images */, + ); + path = docs; + sourceTree = ""; + }; + 0C12EC8E2616383B00B66C86 /* images */ = { + isa = PBXGroup; + children = ( + ); + path = images; + sourceTree = ""; + }; + 0C12ECAE2616383B00B66C86 /* fuser */ = { + isa = PBXGroup; + children = ( + 0C12ECAF2616383B00B66C86 /* tensor_info.h */, + 0C12ECB02616383B00B66C86 /* arg_spec.h */, + 0C12ECB12616383B00B66C86 /* compiler.h */, + 0C12ECB22616383B00B66C86 /* fallback.h */, + 0C12ECB32616383B00B66C86 /* cpu */, + 0C12ECB72616383B00B66C86 /* cuda */, + 0C12ECBA2616383B00B66C86 /* partition_desc.h */, + 0C12ECBB2616383B00B66C86 /* fused_kernel.h */, + 0C12ECBC2616383B00B66C86 /* kernel_spec.h */, + 0C12ECBD2616383B00B66C86 /* interface.h */, + 0C12ECBE2616383B00B66C86 /* kernel_cache.h */, + 0C12ECBF2616383B00B66C86 /* codegen.h */, + 0C12ECC02616383B00B66C86 /* executor.h */, + 0C12ECC12616383B00B66C86 /* tensor_desc.h */, + ); + path = fuser; + sourceTree = ""; + }; + 0C12ECB32616383B00B66C86 /* cpu */ = { + isa = PBXGroup; + children = ( + 0C12ECB42616383B00B66C86 /* temp_file.h */, + 0C12ECB52616383B00B66C86 /* fused_kernel.h */, + 0C12ECB62616383B00B66C86 /* resource_strings.h */, + ); + path = cpu; + sourceTree = ""; + }; + 0C12ECB72616383B00B66C86 /* cuda */ = { + isa = PBXGroup; + children = ( + 0C12ECB82616383B00B66C86 /* fused_kernel.h */, + 0C12ECB92616383B00B66C86 /* resource_strings.h */, + ); + path = cuda; + sourceTree = ""; + }; + 0C12ECC22616383B00B66C86 /* testing */ = { + isa = PBXGroup; + children = ( + 0C12ECC32616383B00B66C86 /* file_check.h */, + 0C12ECC42616383B00B66C86 /* hooks_for_testing.h */, + ); + path = testing; + sourceTree = ""; + }; + 0C12ECC62616383B00B66C86 /* mobile */ = { + isa = PBXGroup; + children = ( + 0C12ECC72616383B00B66C86 /* observer.h */, + 0C12ECC82616383B00B66C86 /* sequential.h */, + 0C12ECC92616383B00B66C86 /* interpreter.h */, + 0C12ECCA2616383B00B66C86 /* export_data.h */, + 0C12ECCB2616383B00B66C86 /* method.h */, + 0C12ECCC2616383B00B66C86 /* optim */, + 0C12ECCE2616383B00B66C86 /* import_data.h */, + 0C12ECCF2616383B00B66C86 /* type_parser.h */, + 0C12ECD02616383B00B66C86 /* import.h */, + 0C12ECD12616383B00B66C86 /* module.h */, + 0C12ECD22616383B00B66C86 /* function.h */, + ); + path = mobile; + sourceTree = ""; + }; + 0C12ECCC2616383B00B66C86 /* optim */ = { + isa = PBXGroup; + children = ( + 0C12ECCD2616383B00B66C86 /* sgd.h */, + ); + path = optim; + sourceTree = ""; + }; + 0C12ECD42616383B00B66C86 /* api */ = { + isa = PBXGroup; + children = ( + 0C12ECD52616383B00B66C86 /* function_impl.h */, + 0C12ECD62616383B00B66C86 /* method.h */, + 0C12ECD72616383B00B66C86 /* compilation_unit.h */, + 0C12ECD82616383B00B66C86 /* object.h */, + 0C12ECD92616383B00B66C86 /* module.h */, + ); + path = api; + sourceTree = ""; + }; + 0C12ECDB2616383B00B66C86 /* api */ = { + isa = PBXGroup; + children = ( + 0C12ECDC2616383B00B66C86 /* include */, + 0C12ED892616383C00B66C86 /* src */, + ); + path = api; + sourceTree = ""; + }; + 0C12ECDC2616383B00B66C86 /* include */ = { + isa = PBXGroup; + children = ( + 0C12ECDD2616383B00B66C86 /* torch */, + ); + path = include; + sourceTree = ""; + }; + 0C12ECDD2616383B00B66C86 /* torch */ = { + isa = PBXGroup; + children = ( + 0C12ECDE2616383B00B66C86 /* fft.h */, + 0C12ECDF2616383B00B66C86 /* utils.h */, + 0C12ECE02616383B00B66C86 /* version.h */, + 0C12ECE12616383B00B66C86 /* nn */, + 0C12ED3B2616383C00B66C86 /* python */, + 0C12ED3D2616383C00B66C86 /* enum.h */, + 0C12ED3E2616383C00B66C86 /* types.h */, + 0C12ED3F2616383C00B66C86 /* all.h */, + 0C12ED402616383C00B66C86 /* data.h */, + 0C12ED412616383C00B66C86 /* arg.h */, + 0C12ED422616383C00B66C86 /* optim */, + 0C12ED4E2616383C00B66C86 /* serialize */, + 0C12ED532616383C00B66C86 /* torch.h */, + 0C12ED542616383C00B66C86 /* optim.h */, + 0C12ED552616383C00B66C86 /* jit.h */, + 0C12ED562616383C00B66C86 /* detail */, + 0C12ED592616383C00B66C86 /* nn.h */, + 0C12ED5A2616383C00B66C86 /* ordered_dict.h */, + 0C12ED5B2616383C00B66C86 /* cuda.h */, + 0C12ED5C2616383C00B66C86 /* autograd.h */, + 0C12ED5D2616383C00B66C86 /* linalg.h */, + 0C12ED5E2616383C00B66C86 /* special.h */, + 0C12ED5F2616383C00B66C86 /* python.h */, + 0C12ED602616383C00B66C86 /* serialize.h */, + 0C12ED612616383C00B66C86 /* data */, + 0C12ED882616383C00B66C86 /* expanding_array.h */, + ); + path = torch; + sourceTree = ""; + }; + 0C12ECE12616383B00B66C86 /* nn */ = { + isa = PBXGroup; + children = ( + 0C12ECE22616383B00B66C86 /* options */, + 0C12ECF82616383C00B66C86 /* utils.h */, + 0C12ECF92616383C00B66C86 /* parallel */, + 0C12ECFB2616383C00B66C86 /* pimpl-inl.h */, + 0C12ECFC2616383C00B66C86 /* utils */, + 0C12ED002616383C00B66C86 /* options.h */, + 0C12ED012616383C00B66C86 /* functional.h */, + 0C12ED022616383C00B66C86 /* modules.h */, + 0C12ED032616383C00B66C86 /* pimpl.h */, + 0C12ED042616383C00B66C86 /* module.h */, + 0C12ED052616383C00B66C86 /* modules */, + 0C12ED282616383C00B66C86 /* init.h */, + 0C12ED292616383C00B66C86 /* cloneable.h */, + 0C12ED2A2616383C00B66C86 /* functional */, + ); + path = nn; + sourceTree = ""; + }; + 0C12ECE22616383B00B66C86 /* options */ = { + isa = PBXGroup; + children = ( + 0C12ECE32616383B00B66C86 /* normalization.h */, + 0C12ECE42616383B00B66C86 /* rnn.h */, + 0C12ECE52616383B00B66C86 /* distance.h */, + 0C12ECE62616383B00B66C86 /* batchnorm.h */, + 0C12ECE72616383B00B66C86 /* linear.h */, + 0C12ECE82616383B00B66C86 /* instancenorm.h */, + 0C12ECE92616383B00B66C86 /* vision.h */, + 0C12ECEA2616383B00B66C86 /* transformercoder.h */, + 0C12ECEB2616383B00B66C86 /* dropout.h */, + 0C12ECEC2616383B00B66C86 /* upsampling.h */, + 0C12ECED2616383B00B66C86 /* embedding.h */, + 0C12ECEE2616383C00B66C86 /* fold.h */, + 0C12ECEF2616383C00B66C86 /* activation.h */, + 0C12ECF02616383C00B66C86 /* transformer.h */, + 0C12ECF12616383C00B66C86 /* pooling.h */, + 0C12ECF22616383C00B66C86 /* transformerlayer.h */, + 0C12ECF32616383C00B66C86 /* adaptive.h */, + 0C12ECF42616383C00B66C86 /* conv.h */, + 0C12ECF52616383C00B66C86 /* padding.h */, + 0C12ECF62616383C00B66C86 /* pixelshuffle.h */, + 0C12ECF72616383C00B66C86 /* loss.h */, + ); + path = options; + sourceTree = ""; + }; + 0C12ECF92616383C00B66C86 /* parallel */ = { + isa = PBXGroup; + children = ( + 0C12ECFA2616383C00B66C86 /* data_parallel.h */, + ); + path = parallel; + sourceTree = ""; + }; + 0C12ECFC2616383C00B66C86 /* utils */ = { + isa = PBXGroup; + children = ( + 0C12ECFD2616383C00B66C86 /* rnn.h */, + 0C12ECFE2616383C00B66C86 /* clip_grad.h */, + 0C12ECFF2616383C00B66C86 /* convert_parameters.h */, + ); + path = utils; + sourceTree = ""; + }; + 0C12ED052616383C00B66C86 /* modules */ = { + isa = PBXGroup; + children = ( + 0C12ED062616383C00B66C86 /* normalization.h */, + 0C12ED072616383C00B66C86 /* utils.h */, + 0C12ED082616383C00B66C86 /* rnn.h */, + 0C12ED092616383C00B66C86 /* distance.h */, + 0C12ED0A2616383C00B66C86 /* batchnorm.h */, + 0C12ED0B2616383C00B66C86 /* linear.h */, + 0C12ED0C2616383C00B66C86 /* instancenorm.h */, + 0C12ED0D2616383C00B66C86 /* transformercoder.h */, + 0C12ED0E2616383C00B66C86 /* _functions.h */, + 0C12ED0F2616383C00B66C86 /* container */, + 0C12ED1A2616383C00B66C86 /* dropout.h */, + 0C12ED1B2616383C00B66C86 /* common.h */, + 0C12ED1C2616383C00B66C86 /* upsampling.h */, + 0C12ED1D2616383C00B66C86 /* embedding.h */, + 0C12ED1E2616383C00B66C86 /* fold.h */, + 0C12ED1F2616383C00B66C86 /* activation.h */, + 0C12ED202616383C00B66C86 /* transformer.h */, + 0C12ED212616383C00B66C86 /* pooling.h */, + 0C12ED222616383C00B66C86 /* transformerlayer.h */, + 0C12ED232616383C00B66C86 /* adaptive.h */, + 0C12ED242616383C00B66C86 /* conv.h */, + 0C12ED252616383C00B66C86 /* padding.h */, + 0C12ED262616383C00B66C86 /* pixelshuffle.h */, + 0C12ED272616383C00B66C86 /* loss.h */, + ); + path = modules; + sourceTree = ""; + }; + 0C12ED0F2616383C00B66C86 /* container */ = { + isa = PBXGroup; + children = ( + 0C12ED102616383C00B66C86 /* named_any.h */, + 0C12ED112616383C00B66C86 /* any_value.h */, + 0C12ED122616383C00B66C86 /* modulelist.h */, + 0C12ED132616383C00B66C86 /* moduledict.h */, + 0C12ED142616383C00B66C86 /* sequential.h */, + 0C12ED152616383C00B66C86 /* functional.h */, + 0C12ED162616383C00B66C86 /* parameterlist.h */, + 0C12ED172616383C00B66C86 /* parameterdict.h */, + 0C12ED182616383C00B66C86 /* any.h */, + 0C12ED192616383C00B66C86 /* any_module_holder.h */, + ); + path = container; + sourceTree = ""; + }; + 0C12ED2A2616383C00B66C86 /* functional */ = { + isa = PBXGroup; + children = ( + 0C12ED2B2616383C00B66C86 /* normalization.h */, + 0C12ED2C2616383C00B66C86 /* distance.h */, + 0C12ED2D2616383C00B66C86 /* batchnorm.h */, + 0C12ED2E2616383C00B66C86 /* linear.h */, + 0C12ED2F2616383C00B66C86 /* instancenorm.h */, + 0C12ED302616383C00B66C86 /* vision.h */, + 0C12ED312616383C00B66C86 /* dropout.h */, + 0C12ED322616383C00B66C86 /* upsampling.h */, + 0C12ED332616383C00B66C86 /* embedding.h */, + 0C12ED342616383C00B66C86 /* fold.h */, + 0C12ED352616383C00B66C86 /* activation.h */, + 0C12ED362616383C00B66C86 /* pooling.h */, + 0C12ED372616383C00B66C86 /* conv.h */, + 0C12ED382616383C00B66C86 /* padding.h */, + 0C12ED392616383C00B66C86 /* pixelshuffle.h */, + 0C12ED3A2616383C00B66C86 /* loss.h */, + ); + path = functional; + sourceTree = ""; + }; + 0C12ED3B2616383C00B66C86 /* python */ = { + isa = PBXGroup; + children = ( + 0C12ED3C2616383C00B66C86 /* init.h */, + ); + path = python; + sourceTree = ""; + }; + 0C12ED422616383C00B66C86 /* optim */ = { + isa = PBXGroup; + children = ( + 0C12ED432616383C00B66C86 /* rmsprop.h */, + 0C12ED442616383C00B66C86 /* lbfgs.h */, + 0C12ED452616383C00B66C86 /* optimizer.h */, + 0C12ED462616383C00B66C86 /* adagrad.h */, + 0C12ED472616383C00B66C86 /* sgd.h */, + 0C12ED482616383C00B66C86 /* serialize.h */, + 0C12ED492616383C00B66C86 /* adamw.h */, + 0C12ED4A2616383C00B66C86 /* schedulers */, + 0C12ED4D2616383C00B66C86 /* adam.h */, + ); + path = optim; + sourceTree = ""; + }; + 0C12ED4A2616383C00B66C86 /* schedulers */ = { + isa = PBXGroup; + children = ( + 0C12ED4B2616383C00B66C86 /* lr_scheduler.h */, + 0C12ED4C2616383C00B66C86 /* step_lr.h */, + ); + path = schedulers; + sourceTree = ""; + }; + 0C12ED4E2616383C00B66C86 /* serialize */ = { + isa = PBXGroup; + children = ( + 0C12ED4F2616383C00B66C86 /* archive.h */, + 0C12ED502616383C00B66C86 /* input-archive.h */, + 0C12ED512616383C00B66C86 /* output-archive.h */, + 0C12ED522616383C00B66C86 /* tensor.h */, + ); + path = serialize; + sourceTree = ""; + }; + 0C12ED562616383C00B66C86 /* detail */ = { + isa = PBXGroup; + children = ( + 0C12ED572616383C00B66C86 /* static.h */, + 0C12ED582616383C00B66C86 /* TensorDataContainer.h */, + ); + path = detail; + sourceTree = ""; + }; + 0C12ED612616383C00B66C86 /* data */ = { + isa = PBXGroup; + children = ( + 0C12ED622616383C00B66C86 /* example.h */, + 0C12ED632616383C00B66C86 /* dataloader_options.h */, + 0C12ED642616383C00B66C86 /* datasets */, + 0C12ED6C2616383C00B66C86 /* worker_exception.h */, + 0C12ED6D2616383C00B66C86 /* dataloader.h */, + 0C12ED6E2616383C00B66C86 /* detail */, + 0C12ED722616383C00B66C86 /* samplers.h */, + 0C12ED732616383C00B66C86 /* transforms */, + 0C12ED792616383C00B66C86 /* samplers */, + 0C12ED812616383C00B66C86 /* datasets.h */, + 0C12ED822616383C00B66C86 /* transforms.h */, + 0C12ED832616383C00B66C86 /* iterator.h */, + 0C12ED842616383C00B66C86 /* dataloader */, + ); + path = data; + sourceTree = ""; + }; + 0C12ED642616383C00B66C86 /* datasets */ = { + isa = PBXGroup; + children = ( + 0C12ED652616383C00B66C86 /* mnist.h */, + 0C12ED662616383C00B66C86 /* shared.h */, + 0C12ED672616383C00B66C86 /* map.h */, + 0C12ED682616383C00B66C86 /* chunk.h */, + 0C12ED692616383C00B66C86 /* stateful.h */, + 0C12ED6A2616383C00B66C86 /* tensor.h */, + 0C12ED6B2616383C00B66C86 /* base.h */, + ); + path = datasets; + sourceTree = ""; + }; + 0C12ED6E2616383C00B66C86 /* detail */ = { + isa = PBXGroup; + children = ( + 0C12ED6F2616383C00B66C86 /* data_shuttle.h */, + 0C12ED702616383C00B66C86 /* sequencers.h */, + 0C12ED712616383C00B66C86 /* queue.h */, + ); + path = detail; + sourceTree = ""; + }; + 0C12ED732616383C00B66C86 /* transforms */ = { + isa = PBXGroup; + children = ( + 0C12ED742616383C00B66C86 /* lambda.h */, + 0C12ED752616383C00B66C86 /* stack.h */, + 0C12ED762616383C00B66C86 /* collate.h */, + 0C12ED772616383C00B66C86 /* tensor.h */, + 0C12ED782616383C00B66C86 /* base.h */, + ); + path = transforms; + sourceTree = ""; + }; + 0C12ED792616383C00B66C86 /* samplers */ = { + isa = PBXGroup; + children = ( + 0C12ED7A2616383C00B66C86 /* sequential.h */, + 0C12ED7B2616383C00B66C86 /* custom_batch_request.h */, + 0C12ED7C2616383C00B66C86 /* stream.h */, + 0C12ED7D2616383C00B66C86 /* distributed.h */, + 0C12ED7E2616383C00B66C86 /* serialize.h */, + 0C12ED7F2616383C00B66C86 /* random.h */, + 0C12ED802616383C00B66C86 /* base.h */, + ); + path = samplers; + sourceTree = ""; + }; + 0C12ED842616383C00B66C86 /* dataloader */ = { + isa = PBXGroup; + children = ( + 0C12ED852616383C00B66C86 /* stateless.h */, + 0C12ED862616383C00B66C86 /* stateful.h */, + 0C12ED872616383C00B66C86 /* base.h */, + ); + path = dataloader; + sourceTree = ""; + }; + 0C12ED892616383C00B66C86 /* src */ = { + isa = PBXGroup; + children = ( + 0C12ED8A2616383C00B66C86 /* nn */, + 0C12ED8E2616383C00B66C86 /* python */, + 0C12ED8F2616383C00B66C86 /* optim */, + 0C12ED912616383C00B66C86 /* serialize */, + 0C12ED922616383C00B66C86 /* data */, + ); + path = src; + sourceTree = ""; + }; + 0C12ED8A2616383C00B66C86 /* nn */ = { + isa = PBXGroup; + children = ( + 0C12ED8B2616383C00B66C86 /* options */, + 0C12ED8C2616383C00B66C86 /* modules */, + ); + path = nn; + sourceTree = ""; + }; + 0C12ED8B2616383C00B66C86 /* options */ = { + isa = PBXGroup; + children = ( + ); + path = options; + sourceTree = ""; + }; + 0C12ED8C2616383C00B66C86 /* modules */ = { + isa = PBXGroup; + children = ( + 0C12ED8D2616383C00B66C86 /* container */, + ); + path = modules; + sourceTree = ""; + }; + 0C12ED8D2616383C00B66C86 /* container */ = { + isa = PBXGroup; + children = ( + ); + path = container; + sourceTree = ""; + }; + 0C12ED8E2616383C00B66C86 /* python */ = { + isa = PBXGroup; + children = ( + ); + path = python; + sourceTree = ""; + }; + 0C12ED8F2616383C00B66C86 /* optim */ = { + isa = PBXGroup; + children = ( + 0C12ED902616383C00B66C86 /* schedulers */, + ); + path = optim; + sourceTree = ""; + }; + 0C12ED902616383C00B66C86 /* schedulers */ = { + isa = PBXGroup; + children = ( + ); + path = schedulers; + sourceTree = ""; + }; + 0C12ED912616383C00B66C86 /* serialize */ = { + isa = PBXGroup; + children = ( + ); + path = serialize; + sourceTree = ""; + }; + 0C12ED922616383C00B66C86 /* data */ = { + isa = PBXGroup; + children = ( + 0C12ED932616383C00B66C86 /* datasets */, + 0C12ED942616383C00B66C86 /* samplers */, + ); + path = data; + sourceTree = ""; + }; + 0C12ED932616383C00B66C86 /* datasets */ = { + isa = PBXGroup; + children = ( + ); + path = datasets; + sourceTree = ""; + }; + 0C12ED942616383C00B66C86 /* samplers */ = { + isa = PBXGroup; + children = ( + ); + path = samplers; + sourceTree = ""; + }; + 0C12ED962616383C00B66C86 /* generic */ = { + isa = PBXGroup; + children = ( + 0C12ED972616383C00B66C86 /* utils.h */, + 0C12ED982616383C00B66C86 /* serialization.h */, + 0C12ED992616383C00B66C86 /* Storage.h */, + ); + path = generic; + sourceTree = ""; + }; + 0C12ED9A2616383C00B66C86 /* tensor */ = { + isa = PBXGroup; + children = ( + 0C12ED9B2616383C00B66C86 /* python_tensor.h */, + ); + path = tensor; + sourceTree = ""; + }; + 0C12EDAF2616383C00B66C86 /* ATen */ = { + isa = PBXGroup; + children = ( + 0C12EDB02616383C00B66C86 /* Formatting.h */, + 0C12EDB12616383C00B66C86 /* CPUFunctions.h */, + 0C12EDB22616383C00B66C86 /* MetaFunctions.h */, + 0C12EDB32616383C00B66C86 /* Utils.h */, + 0C12EDB42616383C00B66C86 /* CUDAGeneratorImpl.h */, + 0C12EDB52616383C00B66C86 /* TensorOptions.h */, + 0C12EDB62616383C00B66C86 /* TensorUtils.h */, + 0C12EDB72616383C00B66C86 /* MemoryOverlap.h */, + 0C12EDB82616383C00B66C86 /* InitialTensorOptions.h */, + 0C12EDB92616383C00B66C86 /* Version.h */, + 0C12EDBA2616383C00B66C86 /* DLConvertor.h */, + 0C12EDBB2616383C00B66C86 /* Device.h */, + 0C12EDBC2616383C00B66C86 /* core */, + 0C12EE0A2616383C00B66C86 /* VmapMode.h */, + 0C12EE0B2616383C00B66C86 /* BatchedFallback.h */, + 0C12EE0C2616383C00B66C86 /* dlpack.h */, + 0C12EE0D2616383C00B66C86 /* Config.h */, + 0C12EE0E2616383C00B66C86 /* SparseTensorUtils.h */, + 0C12EE0F2616383C00B66C86 /* Backtrace.h */, + 0C12EE102616383C00B66C86 /* cpu */, + 0C12EE222616383C00B66C86 /* TracerMode.h */, + 0C12EE232616383C00B66C86 /* Backend.h */, + 0C12EE242616383C00B66C86 /* RegistrationDeclarations.h */, + 0C12EE252616383C00B66C86 /* CompositeImplicitAutogradFunctions.h */, + 0C12EE262616383C00B66C86 /* PTThreadPool.h */, + 0C12EE272616383C00B66C86 /* OpaqueTensorImpl.h */, + 0C12EE282616383C00B66C86 /* LegacyTHFunctionsCPU.h */, + 0C12EE292616383C00B66C86 /* quantized */, + 0C12EE2C2616383C00B66C86 /* record_function.h */, + 0C12EE2D2616383C00B66C86 /* WrapDimUtils.h */, + 0C12EE2E2616383C00B66C86 /* RedispatchFunctions.h */, + 0C12EE2F2616383C00B66C86 /* Context.h */, + 0C12EE302616383C00B66C86 /* div_rtn.h */, + 0C12EE312616383C00B66C86 /* ExpandUtils.h */, + 0C12EE322616383C00B66C86 /* TypeDefault.h */, + 0C12EE332616383C00B66C86 /* CPUFixedAllocator.h */, + 0C12EE342616383C00B66C86 /* NamedTensor.h */, + 0C12EE352616383C00B66C86 /* Scalar.h */, + 0C12EE362616383C00B66C86 /* ParallelNativeTBB.h */, + 0C12EE372616383C00B66C86 /* ArrayRef.h */, + 0C12EE382616383C00B66C86 /* SequenceNumber.h */, + 0C12EE392616383C00B66C86 /* MatrixRef.h */, + 0C12EE3A2616383C00B66C86 /* CompositeExplicitAutogradFunctions.h */, + 0C12EE3B2616383C00B66C86 /* NumericUtils.h */, + 0C12EE3C2616383C00B66C86 /* ATen.h */, + 0C12EE3D2616383C00B66C86 /* TensorNames.h */, + 0C12EE3E2616383C00B66C86 /* TensorMeta.h */, + 0C12EE3F2616383C00B66C86 /* TensorIndexing.h */, + 0C12EE402616383C00B66C86 /* Layout.h */, + 0C12EE412616383C00B66C86 /* SparseTensorImpl.h */, + 0C12EE422616383C00B66C86 /* detail */, + 0C12EE462616383C00B66C86 /* WrapDimUtilsMulti.h */, + 0C12EE472616383C00B66C86 /* TensorOperators.h */, + 0C12EE482616383C00B66C86 /* ScalarType.h */, + 0C12EE492616383C00B66C86 /* cpp_custom_type_hack.h */, + 0C12EE4A2616383C00B66C86 /* VmapTransforms.h */, + 0C12EE4B2616383C00B66C86 /* Storage.h */, + 0C12EE4C2616383C00B66C86 /* DeviceGuard.h */, + 0C12EE4D2616383C00B66C86 /* ParallelNative.h */, + 0C12EE4E2616383C00B66C86 /* Dispatch.h */, + 0C12EE4F2616383C00B66C86 /* CPUGeneratorImpl.h */, + 0C12EE502616383C00B66C86 /* Functions.h */, + 0C12EE512616383C00B66C86 /* ParallelOpenMP.h */, + 0C12EE522616383C00B66C86 /* BatchedTensorImpl.h */, + 0C12EE532616383C00B66C86 /* CPUApplyUtils.h */, + 0C12EE542616383C00B66C86 /* ThreadLocalState.h */, + 0C12EE552616383C00B66C86 /* ScalarOps.h */, + 0C12EE562616383C00B66C86 /* NativeFunctions.h */, + 0C12EE572616383C00B66C86 /* DynamicLibrary.h */, + 0C12EE582616383C00B66C86 /* TensorGeometry.h */, + 0C12EE592616383C00B66C86 /* TensorIterator.h */, + 0C12EE5A2616383C00B66C86 /* NamedTensorUtils.h */, + 0C12EE5B2616383C00B66C86 /* Dimname.h */, + 0C12EE5C2616383C00B66C86 /* autocast_mode.h */, + 0C12EE5D2616383C00B66C86 /* Parallel.h */, + 0C12EE5E2616383C00B66C86 /* DimVector.h */, + 0C12EE5F2616383C00B66C86 /* InferSize.h */, + 0C12EE602616383C00B66C86 /* SmallVector.h */, + 0C12EE612616383C00B66C86 /* Tensor.h */, + 0C12EE622616383C00B66C86 /* Generator.h */, + 0C12EE632616383C00B66C86 /* AccumulateType.h */, + 0C12EE642616383C00B66C86 /* TensorAccessor.h */, + 0C12EE652616383C00B66C86 /* LegacyTHFunctionsCUDA.h */, + ); + path = ATen; + sourceTree = ""; + }; + 0C12EDBC2616383C00B66C86 /* core */ = { + isa = PBXGroup; + children = ( + 0C12EDBD2616383C00B66C86 /* Dict_inl.h */, + 0C12EDBE2616383C00B66C86 /* Formatting.h */, + 0C12EDBF2616383C00B66C86 /* TensorBody.h */, + 0C12EDC02616383C00B66C86 /* op_registration */, + 0C12EDC52616383C00B66C86 /* jit_type_base.h */, + 0C12EDC62616383C00B66C86 /* typeid.h */, + 0C12EDC72616383C00B66C86 /* rref_interface.h */, + 0C12EDC82616383C00B66C86 /* Range.h */, + 0C12EDC92616383C00B66C86 /* interned_strings_class.h */, + 0C12EDCA2616383C00B66C86 /* operator_name.h */, + 0C12EDCB2616383C00B66C86 /* DeprecatedTypePropertiesRegistry.h */, + 0C12EDCC2616383C00B66C86 /* Backtrace.h */, + 0C12EDCD2616383C00B66C86 /* TransformationHelper.h */, + 0C12EDCE2616383C00B66C86 /* blob.h */, + 0C12EDCF2616383C00B66C86 /* function_schema.h */, + 0C12EDD02616383C00B66C86 /* dispatch */, + 0C12EDD82616383C00B66C86 /* MT19937RNGEngine.h */, + 0C12EDD92616383C00B66C86 /* ivalue_to.h */, + 0C12EDDA2616383C00B66C86 /* aten_interned_strings.h */, + 0C12EDDB2616383C00B66C86 /* LegacyTypeDispatch.h */, + 0C12EDDC2616383C00B66C86 /* function_schema_inl.h */, + 0C12EDDD2616383C00B66C86 /* qualified_name.h */, + 0C12EDDE2616383C00B66C86 /* UndefinedTensorImpl.h */, + 0C12EDDF2616383C00B66C86 /* NamedTensor.h */, + 0C12EDE02616383C00B66C86 /* Scalar.h */, + 0C12EDE12616383C00B66C86 /* functional.h */, + 0C12EDE22616383C00B66C86 /* DeprecatedTypeProperties.h */, + 0C12EDE32616383C00B66C86 /* interned_strings.h */, + 0C12EDE42616383C00B66C86 /* List.h */, + 0C12EDE52616383C00B66C86 /* ATenOpList.h */, + 0C12EDE62616383C00B66C86 /* Dict.h */, + 0C12EDE72616383C00B66C86 /* grad_mode.h */, + 0C12EDE82616383C00B66C86 /* DistributionsHelper.h */, + 0C12EDE92616383C00B66C86 /* Macros.h */, + 0C12EDEA2616383C00B66C86 /* VariableHooksInterface.h */, + 0C12EDEB2616383C00B66C86 /* ScalarType.h */, + 0C12EDEC2616383C00B66C86 /* Array.h */, + 0C12EDED2616383C00B66C86 /* stack.h */, + 0C12EDEE2616383C00B66C86 /* ATenGeneral.h */, + 0C12EDEF2616383C00B66C86 /* UnsafeFromTH.h */, + 0C12EDF02616383C00B66C86 /* QuantizerBase.h */, + 0C12EDF12616383C00B66C86 /* alias_info.h */, + 0C12EDF22616383C00B66C86 /* List_inl.h */, + 0C12EDF32616383C00B66C86 /* jit_type.h */, + 0C12EDF42616383C00B66C86 /* ivalue.h */, + 0C12EDF52616383C00B66C86 /* Dimname.h */, + 0C12EDF62616383C00B66C86 /* Vitals.h */, + 0C12EDF72616383C00B66C86 /* boxing */, + 0C12EE002616383C00B66C86 /* builtin_function.h */, + 0C12EE012616383C00B66C86 /* DimVector.h */, + 0C12EE022616383C00B66C86 /* Reduction.h */, + 0C12EE032616383C00B66C86 /* Tensor.h */, + 0C12EE042616383C00B66C86 /* function.h */, + 0C12EE052616383C00B66C86 /* Generator.h */, + 0C12EE062616383C00B66C86 /* PhiloxRNGEngine.h */, + 0C12EE072616383C00B66C86 /* TensorAccessor.h */, + 0C12EE082616383C00B66C86 /* ivalue_inl.h */, + 0C12EE092616383C00B66C86 /* Variadic.h */, + ); + path = core; + sourceTree = ""; + }; + 0C12EDC02616383C00B66C86 /* op_registration */ = { + isa = PBXGroup; + children = ( + 0C12EDC12616383C00B66C86 /* adaption.h */, + 0C12EDC22616383C00B66C86 /* op_allowlist.h */, + 0C12EDC32616383C00B66C86 /* op_registration.h */, + 0C12EDC42616383C00B66C86 /* infer_schema.h */, + ); + path = op_registration; + sourceTree = ""; + }; + 0C12EDD02616383C00B66C86 /* dispatch */ = { + isa = PBXGroup; + children = ( + 0C12EDD12616383C00B66C86 /* OperatorOptions.h */, + 0C12EDD22616383C00B66C86 /* RegistrationHandleRAII.h */, + 0C12EDD32616383C00B66C86 /* ObservedOperators.h */, + 0C12EDD42616383C00B66C86 /* DispatchKeyExtractor.h */, + 0C12EDD52616383C00B66C86 /* Dispatcher.h */, + 0C12EDD62616383C00B66C86 /* CppSignature.h */, + 0C12EDD72616383C00B66C86 /* OperatorEntry.h */, + ); + path = dispatch; + sourceTree = ""; + }; + 0C12EDF72616383C00B66C86 /* boxing */ = { + isa = PBXGroup; + children = ( + 0C12EDF82616383C00B66C86 /* impl */, + 0C12EDFE2616383C00B66C86 /* KernelFunction.h */, + 0C12EDFF2616383C00B66C86 /* KernelFunction_impl.h */, + ); + path = boxing; + sourceTree = ""; + }; + 0C12EDF82616383C00B66C86 /* impl */ = { + isa = PBXGroup; + children = ( + 0C12EDF92616383C00B66C86 /* make_boxed_from_unboxed_functor.h */, + 0C12EDFA2616383C00B66C86 /* boxing.h */, + 0C12EDFB2616383C00B66C86 /* test_helpers.h */, + 0C12EDFC2616383C00B66C86 /* WrapFunctionIntoFunctor.h */, + 0C12EDFD2616383C00B66C86 /* WrapFunctionIntoRuntimeFunctor.h */, + ); + path = impl; + sourceTree = ""; + }; + 0C12EE102616383C00B66C86 /* cpu */ = { + isa = PBXGroup; + children = ( + 0C12EE112616383C00B66C86 /* vec256 */, + 0C12EE202616383C00B66C86 /* FlushDenormal.h */, + 0C12EE212616383C00B66C86 /* vml.h */, + ); + path = cpu; + sourceTree = ""; + }; + 0C12EE112616383C00B66C86 /* vec256 */ = { + isa = PBXGroup; + children = ( + 0C12EE122616383C00B66C86 /* vec256_bfloat16.h */, + 0C12EE132616383C00B66C86 /* vec256_float_neon.h */, + 0C12EE142616383C00B66C86 /* missing_vst1_neon.h */, + 0C12EE152616383C00B66C86 /* vec256_qint.h */, + 0C12EE162616383C00B66C86 /* intrinsics.h */, + 0C12EE172616383C00B66C86 /* functional.h */, + 0C12EE182616383C00B66C86 /* vec256_complex_float.h */, + 0C12EE192616383C00B66C86 /* vec256_double.h */, + 0C12EE1A2616383C00B66C86 /* vec256_base.h */, + 0C12EE1B2616383C00B66C86 /* vec256_float.h */, + 0C12EE1C2616383C00B66C86 /* missing_vld1_neon.h */, + 0C12EE1D2616383C00B66C86 /* vec256.h */, + 0C12EE1E2616383C00B66C86 /* vec256_int.h */, + 0C12EE1F2616383C00B66C86 /* vec256_complex_double.h */, + ); + path = vec256; + sourceTree = ""; + }; + 0C12EE292616383C00B66C86 /* quantized */ = { + isa = PBXGroup; + children = ( + 0C12EE2A2616383C00B66C86 /* QTensorImpl.h */, + 0C12EE2B2616383C00B66C86 /* Quantizer.h */, + ); + path = quantized; + sourceTree = ""; + }; + 0C12EE422616383C00B66C86 /* detail */ = { + isa = PBXGroup; + children = ( + 0C12EE432616383C00B66C86 /* CUDAHooksInterface.h */, + 0C12EE442616383C00B66C86 /* FunctionTraits.h */, + 0C12EE452616383C00B66C86 /* HIPHooksInterface.h */, + ); + path = detail; + sourceTree = ""; + }; + 0C12EE662616383C00B66C86 /* c10 */ = { + isa = PBXGroup; + children = ( + 0C12EE672616383C00B66C86 /* benchmark */, + 0C12EE682616383C00B66C86 /* core */, + 0C12EE912616383C00B66C86 /* test */, + 0C12EE982616383C00B66C86 /* util */, + 0C12EEDA2616383C00B66C86 /* cuda */, + 0C12EEE82616383C00B66C86 /* macros */, + 0C12EEEC2616383C00B66C86 /* mobile */, + 0C12EEEF2616383C00B66C86 /* hip */, + ); + path = c10; + sourceTree = ""; + }; + 0C12EE672616383C00B66C86 /* benchmark */ = { + isa = PBXGroup; + children = ( + ); + path = benchmark; + sourceTree = ""; + }; + 0C12EE682616383C00B66C86 /* core */ = { + isa = PBXGroup; + children = ( + 0C12EE692616383C00B66C86 /* impl */, + 0C12EE722616383C00B66C86 /* QEngine.h */, + 0C12EE732616383C00B66C86 /* TensorOptions.h */, + 0C12EE742616383C00B66C86 /* Device.h */, + 0C12EE752616383C00B66C86 /* CPUAllocator.h */, + 0C12EE762616383C00B66C86 /* DefaultDtype.h */, + 0C12EE772616383C00B66C86 /* DefaultTensorOptions.h */, + 0C12EE782616383C00B66C86 /* Event.h */, + 0C12EE792616383C00B66C86 /* Backend.h */, + 0C12EE7A2616383C00B66C86 /* CompileTimeFunctionPointer.h */, + 0C12EE7B2616383C00B66C86 /* WrapDimMinimal.h */, + 0C12EE7C2616383C00B66C86 /* QScheme.h */, + 0C12EE7D2616383C00B66C86 /* Stream.h */, + 0C12EE7E2616383C00B66C86 /* UndefinedTensorImpl.h */, + 0C12EE7F2616383C00B66C86 /* Scalar.h */, + 0C12EE802616383C00B66C86 /* thread_pool.h */, + 0C12EE812616383C00B66C86 /* CopyBytes.h */, + 0C12EE822616383C00B66C86 /* StreamGuard.h */, + 0C12EE832616383C00B66C86 /* Layout.h */, + 0C12EE842616383C00B66C86 /* GeneratorImpl.h */, + 0C12EE852616383C00B66C86 /* DispatchKeySet.h */, + 0C12EE862616383C00B66C86 /* Allocator.h */, + 0C12EE872616383C00B66C86 /* TensorImpl.h */, + 0C12EE882616383C00B66C86 /* ScalarType.h */, + 0C12EE892616383C00B66C86 /* Storage.h */, + 0C12EE8A2616383C00B66C86 /* DeviceType.h */, + 0C12EE8B2616383C00B66C86 /* DeviceGuard.h */, + 0C12EE8C2616383C00B66C86 /* StorageImpl.h */, + 0C12EE8D2616383C00B66C86 /* MemoryFormat.h */, + 0C12EE8E2616383C00B66C86 /* DispatchKey.h */, + 0C12EE8F2616383C00B66C86 /* ScalarTypeToTypeMeta.h */, + 0C12EE902616383C00B66C86 /* InferenceMode.h */, + ); + path = core; + sourceTree = ""; + }; + 0C12EE692616383C00B66C86 /* impl */ = { + isa = PBXGroup; + children = ( + 0C12EE6A2616383C00B66C86 /* InlineStreamGuard.h */, + 0C12EE6B2616383C00B66C86 /* SizesAndStrides.h */, + 0C12EE6C2616383C00B66C86 /* InlineDeviceGuard.h */, + 0C12EE6D2616383C00B66C86 /* LocalDispatchKeySet.h */, + 0C12EE6E2616383C00B66C86 /* VirtualGuardImpl.h */, + 0C12EE6F2616383C00B66C86 /* InlineEvent.h */, + 0C12EE702616383C00B66C86 /* DeviceGuardImplInterface.h */, + 0C12EE712616383C00B66C86 /* FakeGuardImpl.h */, + ); + path = impl; + sourceTree = ""; + }; + 0C12EE912616383C00B66C86 /* test */ = { + isa = PBXGroup; + children = ( + 0C12EE922616383C00B66C86 /* core */, + 0C12EE942616383C00B66C86 /* util */, + ); + path = test; + sourceTree = ""; + }; + 0C12EE922616383C00B66C86 /* core */ = { + isa = PBXGroup; + children = ( + 0C12EE932616383C00B66C86 /* impl */, + ); + path = core; + sourceTree = ""; + }; + 0C12EE932616383C00B66C86 /* impl */ = { + isa = PBXGroup; + children = ( + ); + path = impl; + sourceTree = ""; + }; + 0C12EE942616383C00B66C86 /* util */ = { + isa = PBXGroup; + children = ( + 0C12EE952616383C00B66C86 /* complex_test_common.h */, + 0C12EE962616383C00B66C86 /* complex_math_test_common.h */, + 0C12EE972616383C00B66C86 /* Macros.h */, + ); + path = util; + sourceTree = ""; + }; + 0C12EE982616383C00B66C86 /* util */ = { + isa = PBXGroup; + children = ( + 0C12EE992616383C00B66C86 /* Type.h */, + 0C12EE9A2616383C00B66C86 /* order_preserving_flat_hash_map.h */, + 0C12EE9B2616383C00B66C86 /* reverse_iterator.h */, + 0C12EE9C2616383C00B66C86 /* quint4x2.h */, + 0C12EE9D2616383C00B66C86 /* Half.h */, + 0C12EE9E2616383C00B66C86 /* flat_hash_map.h */, + 0C12EE9F2616383C00B66C86 /* llvmMathExtras.h */, + 0C12EEA02616383C00B66C86 /* math_compat.h */, + 0C12EEA12616383C00B66C86 /* Bitset.h */, + 0C12EEA22616383C00B66C86 /* typeid.h */, + 0C12EEA32616383C00B66C86 /* intrusive_ptr.h */, + 0C12EEA42616383C00B66C86 /* string_utils.h */, + 0C12EEA52616383C00B66C86 /* win32-headers.h */, + 0C12EEA62616383C00B66C86 /* AlignOf.h */, + 0C12EEA72616383C00B66C86 /* numa.h */, + 0C12EEA82616383C00B66C86 /* qint32.h */, + 0C12EEA92616383C00B66C86 /* MaybeOwned.h */, + 0C12EEAA2616383C00B66C86 /* Half-inl.h */, + 0C12EEAB2616383C00B66C86 /* TypeTraits.h */, + 0C12EEAC2616383C00B66C86 /* FunctionRef.h */, + 0C12EEAD2616383C00B66C86 /* Backtrace.h */, + 0C12EEAE2616383C00B66C86 /* BFloat16-inl.h */, + 0C12EEAF2616383C00B66C86 /* in_place.h */, + 0C12EEB02616383C00B66C86 /* ConstexprCrc.h */, + 0C12EEB12616383C00B66C86 /* IdWrapper.h */, + 0C12EEB22616383C00B66C86 /* Flags.h */, + 0C12EEB32616383C00B66C86 /* overloaded.h */, + 0C12EEB42616383C00B66C86 /* quint8.h */, + 0C12EEB52616383C00B66C86 /* StringUtil.h */, + 0C12EEB62616383C00B66C86 /* Logging.h */, + 0C12EEB72616383C00B66C86 /* MathConstants.h */, + 0C12EEB82616383C00B66C86 /* Registry.h */, + 0C12EEB92616383C00B66C86 /* Optional.h */, + 0C12EEBA2616383C00B66C86 /* tempfile.h */, + 0C12EEBB2616383C00B66C86 /* ArrayRef.h */, + 0C12EEBC2616383C00B66C86 /* thread_name.h */, + 0C12EEBD2616383C00B66C86 /* Unicode.h */, + 0C12EEBE2616383C00B66C86 /* TypeCast.h */, + 0C12EEBF2616383C00B66C86 /* sparse_bitset.h */, + 0C12EEC02616383C00B66C86 /* BFloat16.h */, + 0C12EEC12616383C00B66C86 /* TypeList.h */, + 0C12EEC22616383C00B66C86 /* TypeIndex.h */, + 0C12EEC32616383C00B66C86 /* Array.h */, + 0C12EEC42616383C00B66C86 /* logging_is_google_glog.h */, + 0C12EEC52616383C00B66C86 /* Metaprogramming.h */, + 0C12EEC62616383C00B66C86 /* either.h */, + 0C12EEC72616383C00B66C86 /* BFloat16-math.h */, + 0C12EEC82616383C00B66C86 /* Deprecated.h */, + 0C12EEC92616383C00B66C86 /* irange.h */, + 0C12EECA2616383C00B66C86 /* LeftRight.h */, + 0C12EECB2616383C00B66C86 /* qint8.h */, + 0C12EECC2616383C00B66C86 /* complex_math.h */, + 0C12EECD2616383C00B66C86 /* logging_is_not_google_glog.h */, + 0C12EECE2616383C00B66C86 /* Exception.h */, + 0C12EECF2616383C00B66C86 /* UniqueVoidPtr.h */, + 0C12EED02616383C00B66C86 /* ThreadLocalDebugInfo.h */, + 0C12EED12616383C00B66C86 /* accumulate.h */, + 0C12EED22616383C00B66C86 /* C++17.h */, + 0C12EED32616383C00B66C86 /* SmallVector.h */, + 0C12EED42616383C00B66C86 /* hash.h */, + 0C12EED52616383C00B66C86 /* python_stub.h */, + 0C12EED62616383C00B66C86 /* complex.h */, + 0C12EED72616383C00B66C86 /* string_view.h */, + 0C12EED82616383C00B66C86 /* variant.h */, + 0C12EED92616383C00B66C86 /* complex_utils.h */, + ); + path = util; + sourceTree = ""; + }; + 0C12EEDA2616383C00B66C86 /* cuda */ = { + isa = PBXGroup; + children = ( + 0C12EEDB2616383C00B66C86 /* impl */, + 0C12EEDE2616383C00B66C86 /* CUDAMathCompat.h */, + 0C12EEDF2616383C00B66C86 /* test */, + 0C12EEE12616383C00B66C86 /* CUDAStream.h */, + 0C12EEE22616383C00B66C86 /* CUDAGuard.h */, + 0C12EEE32616383C00B66C86 /* CUDAGraphsC10Utils.h */, + 0C12EEE42616383C00B66C86 /* CUDAMacros.h */, + 0C12EEE52616383C00B66C86 /* CUDAFunctions.h */, + 0C12EEE62616383C00B66C86 /* CUDAException.h */, + 0C12EEE72616383C00B66C86 /* CUDACachingAllocator.h */, + ); + path = cuda; + sourceTree = ""; + }; + 0C12EEDB2616383C00B66C86 /* impl */ = { + isa = PBXGroup; + children = ( + 0C12EEDC2616383C00B66C86 /* CUDATest.h */, + 0C12EEDD2616383C00B66C86 /* CUDAGuardImpl.h */, + ); + path = impl; + sourceTree = ""; + }; + 0C12EEDF2616383C00B66C86 /* test */ = { + isa = PBXGroup; + children = ( + 0C12EEE02616383C00B66C86 /* impl */, + ); + path = test; + sourceTree = ""; + }; + 0C12EEE02616383C00B66C86 /* impl */ = { + isa = PBXGroup; + children = ( + ); + path = impl; + sourceTree = ""; + }; + 0C12EEE82616383C00B66C86 /* macros */ = { + isa = PBXGroup; + children = ( + 0C12EEE92616383C00B66C86 /* cmake_macros.h */, + 0C12EEEA2616383C00B66C86 /* Export.h */, + 0C12EEEB2616383C00B66C86 /* Macros.h */, + ); + path = macros; + sourceTree = ""; + }; + 0C12EEEC2616383C00B66C86 /* mobile */ = { + isa = PBXGroup; + children = ( + 0C12EEED2616383C00B66C86 /* CPUCachingAllocator.h */, + 0C12EEEE2616383C00B66C86 /* CPUProfilingAllocator.h */, + ); + path = mobile; + sourceTree = ""; + }; + 0C12EEEF2616383C00B66C86 /* hip */ = { + isa = PBXGroup; + children = ( + ); + path = hip; + sourceTree = ""; + }; + 0C12EEF22616383C00B66C86 /* fp16 */ = { + isa = PBXGroup; + children = ( + 0C12EEF32616383C00B66C86 /* avx.py */, + 0C12EEF42616383C00B66C86 /* __init__.py */, + 0C12EEF52616383C00B66C86 /* fp16.h */, + 0C12EEF62616383C00B66C86 /* avx2.py */, + 0C12EEF72616383C00B66C86 /* psimd.h */, + 0C12EEF82616383C00B66C86 /* bitcasts.h */, + ); + path = fp16; + sourceTree = ""; + }; + 0C12EEF92616383C00B66C86 /* THCUNN */ = { + isa = PBXGroup; + children = ( + 0C12EEFA2616383C00B66C86 /* generic */, + ); + path = THCUNN; + sourceTree = ""; + }; + 0C12EEFA2616383C00B66C86 /* generic */ = { + isa = PBXGroup; + children = ( + 0C12EEFB2616383C00B66C86 /* THCUNN.h */, + ); + path = generic; + sourceTree = ""; + }; + 0C12EEFC2616383C00B66C86 /* TH */ = { + isa = PBXGroup; + children = ( + 0C12EEFD2616383C00B66C86 /* THTensorDimApply.h */, + 0C12EEFE2616383C00B66C86 /* THBlas.h */, + 0C12EEFF2616383C00B66C86 /* THGenerateQUInt8Type.h */, + 0C12EF002616383C00B66C86 /* THGenerateQInt8Type.h */, + 0C12EF012616383C00B66C86 /* THGenerateComplexTypes.h */, + 0C12EF022616383C00B66C86 /* THGenerateFloatType.h */, + 0C12EF032616383C00B66C86 /* THGenerateQInt32Type.h */, + 0C12EF042616383C00B66C86 /* THGenerateDoubleType.h */, + 0C12EF052616383C00B66C86 /* THGenerateShortType.h */, + 0C12EF062616383C00B66C86 /* THGenerateIntTypes.h */, + 0C12EF072616383C00B66C86 /* THGenerateLongType.h */, + 0C12EF082616383C00B66C86 /* THGenerateComplexFloatType.h */, + 0C12EF092616383C00B66C86 /* THAllocator.h */, + 0C12EF0A2616383C00B66C86 /* THGenerateCharType.h */, + 0C12EF0B2616383C00B66C86 /* THStorage.h */, + 0C12EF0C2616383C00B66C86 /* THHalf.h */, + 0C12EF0D2616383C00B66C86 /* THGenerateHalfType.h */, + 0C12EF0E2616383C00B66C86 /* THGenerateIntType.h */, + 0C12EF0F2616383C00B66C86 /* THVector.h */, + 0C12EF102616383C00B66C86 /* THGeneral.h */, + 0C12EF112616383C00B66C86 /* THGenerateBoolType.h */, + 0C12EF122616383C00B66C86 /* THLapack.h */, + 0C12EF132616383C00B66C86 /* THGenerateComplexDoubleType.h */, + 0C12EF142616383C00B66C86 /* THGenerateBFloat16Type.h */, + 0C12EF152616383C00B66C86 /* THGenerateQTypes.h */, + 0C12EF162616383C00B66C86 /* THGenerateFloatTypes.h */, + 0C12EF172616383C00B66C86 /* generic */, + 0C12EF292616383C00B66C86 /* THTensor.h */, + 0C12EF2A2616383C00B66C86 /* TH.h */, + 0C12EF2B2616383C00B66C86 /* THTensorApply.h */, + 0C12EF2C2616383C00B66C86 /* THStorageFunctions.hpp */, + 0C12EF2D2616383C00B66C86 /* THGenerateAllTypes.h */, + 0C12EF2E2616383C00B66C86 /* THTensor.hpp */, + 0C12EF2F2616383C00B66C86 /* THGenerateByteType.h */, + 0C12EF302616383C00B66C86 /* THStorageFunctions.h */, + 0C12EF312616383C00B66C86 /* THGenerateQUInt4x2Type.h */, + ); + path = TH; + sourceTree = ""; + }; + 0C12EF172616383C00B66C86 /* generic */ = { + isa = PBXGroup; + children = ( + 0C12EF182616383C00B66C86 /* THBlas.h */, + 0C12EF192616383C00B66C86 /* THTensor.cpp */, + 0C12EF1A2616383C00B66C86 /* THTensorMath.cpp */, + 0C12EF1B2616383C00B66C86 /* THTensorMath.h */, + 0C12EF1C2616383C00B66C86 /* THStorageCopy.cpp */, + 0C12EF1D2616383C00B66C86 /* THTensorFastGetSet.hpp */, + 0C12EF1E2616383C00B66C86 /* THStorage.h */, + 0C12EF1F2616383C00B66C86 /* THTensorLapack.h */, + 0C12EF202616383C00B66C86 /* THVector.h */, + 0C12EF212616383C00B66C86 /* THLapack.cpp */, + 0C12EF222616383C00B66C86 /* THStorageCopy.h */, + 0C12EF232616383C00B66C86 /* THLapack.h */, + 0C12EF242616383C00B66C86 /* THStorage.cpp */, + 0C12EF252616383C00B66C86 /* THTensor.h */, + 0C12EF262616383C00B66C86 /* THBlas.cpp */, + 0C12EF272616383C00B66C86 /* THTensorLapack.cpp */, + 0C12EF282616383C00B66C86 /* THTensor.hpp */, + ); + path = generic; + sourceTree = ""; + }; + 0C12EF322616383C00B66C86 /* lib */ = { + isa = PBXGroup; + children = ( + 0C12EF332616383C00B66C86 /* libtorch_cpu.a */, + 0C12EF342616383C00B66C86 /* libtorch.a */, + 0C12EF352616383C00B66C86 /* libcpuinfo.a */, + 0C12EF362616383C00B66C86 /* libXNNPACK.a */, + 0C12EF372616383C00B66C86 /* libtorchvision_ops.a */, + 0C12EF382616383C00B66C86 /* libpthreadpool.a */, + 0C12EF392616383C00B66C86 /* libc10.a */, + 0C12EF3A2616383C00B66C86 /* libeigen_blas.a */, + 0C12EF3B2616383C00B66C86 /* libclog.a */, + 0C12EF3C2616383C00B66C86 /* libpytorch_qnnpack.a */, + ); + path = lib; + sourceTree = ""; + }; + 0C12EF6F26163A4C00B66C86 /* Frameworks */ = { + isa = PBXGroup; + children = ( + ); + name = Frameworks; + sourceTree = ""; + }; + 0CEB0AB226151A8800F1F7D5 = { + isa = PBXGroup; + children = ( + 0C12E7872616383A00B66C86 /* install */, + 0CEB0ABD26151A8800F1F7D5 /* VisionTestApp */, + 0CEB0ABC26151A8800F1F7D5 /* Products */, + 0C12EF6F26163A4C00B66C86 /* Frameworks */, + ); + sourceTree = ""; + }; + 0CEB0ABC26151A8800F1F7D5 /* Products */ = { + isa = PBXGroup; + children = ( + 0CEB0ABB26151A8800F1F7D5 /* VisionTestApp.app */, + ); + name = Products; + sourceTree = ""; + }; + 0CEB0ABD26151A8800F1F7D5 /* VisionTestApp */ = { + isa = PBXGroup; + children = ( + 0CEB0B3826152ED900F1F7D5 /* ModelRunner.h */, + 0CEB0B3926152ED900F1F7D5 /* ModelRunner.mm */, + 0CEB0ABE26151A8800F1F7D5 /* AppDelegate.h */, + 0CEB0ABF26151A8800F1F7D5 /* AppDelegate.m */, + 0CEB0AC426151A8800F1F7D5 /* ViewController.h */, + 0CEB0AC526151A8800F1F7D5 /* ViewController.mm */, + 0CEB0AC726151A8800F1F7D5 /* Main.storyboard */, + 0CEB0ACA26151A8900F1F7D5 /* Assets.xcassets */, + 0CEB0ACC26151A8900F1F7D5 /* LaunchScreen.storyboard */, + 0CEB0ACF26151A8900F1F7D5 /* Info.plist */, + 0CEB0AD026151A8900F1F7D5 /* main.m */, + 0C12EF7526163B7600B66C86 /* frcnn_mnetv3.pt */, + ); + path = VisionTestApp; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 0CEB0ABA26151A8800F1F7D5 /* VisionTestApp */ = { + isa = PBXNativeTarget; + buildConfigurationList = 0CEB0AEA26151A8900F1F7D5 /* Build configuration list for PBXNativeTarget "VisionTestApp" */; + buildPhases = ( + 0CEB0AB726151A8800F1F7D5 /* Sources */, + 0CEB0AB826151A8800F1F7D5 /* Frameworks */, + 0CEB0AB926151A8800F1F7D5 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = VisionTestApp; + productName = VisionTestApp; + productReference = 0CEB0ABB26151A8800F1F7D5 /* VisionTestApp.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 0CEB0AB326151A8800F1F7D5 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 1240; + TargetAttributes = { + 0CEB0ABA26151A8800F1F7D5 = { + CreatedOnToolsVersion = 12.4; + }; + }; + }; + buildConfigurationList = 0CEB0AB626151A8800F1F7D5 /* Build configuration list for PBXProject "VisionTestApp" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 0CEB0AB226151A8800F1F7D5; + productRefGroup = 0CEB0ABC26151A8800F1F7D5 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 0CEB0ABA26151A8800F1F7D5 /* VisionTestApp */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 0CEB0AB926151A8800F1F7D5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 0C12EF3D2616383D00B66C86 /* avx.py in Resources */, + 0CEB0ACE26151A8900F1F7D5 /* LaunchScreen.storyboard in Resources */, + 0C12EF3F2616383D00B66C86 /* avx2.py in Resources */, + 0C12EF7626163B7600B66C86 /* frcnn_mnetv3.pt in Resources */, + 0CEB0ACB26151A8900F1F7D5 /* Assets.xcassets in Resources */, + 0C12EF3E2616383D00B66C86 /* __init__.py in Resources */, + 0CEB0AC926151A8800F1F7D5 /* Main.storyboard in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 0CEB0AB726151A8800F1F7D5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 0CEB0AC626151A8800F1F7D5 /* ViewController.mm in Sources */, + 0CEB0AC026151A8800F1F7D5 /* AppDelegate.m in Sources */, + 0C12EF412616383D00B66C86 /* THTensorMath.cpp in Sources */, + 0C12EF422616383D00B66C86 /* THStorageCopy.cpp in Sources */, + 0C12EF462616383D00B66C86 /* THTensorLapack.cpp in Sources */, + 0CEB0AD126151A8900F1F7D5 /* main.m in Sources */, + 0C12EF432616383D00B66C86 /* THLapack.cpp in Sources */, + 0C12EF402616383D00B66C86 /* THTensor.cpp in Sources */, + 0C12EF442616383D00B66C86 /* THStorage.cpp in Sources */, + 0CEB0B3A26152ED900F1F7D5 /* ModelRunner.mm in Sources */, + 0C12EF452616383D00B66C86 /* THBlas.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXVariantGroup section */ + 0CEB0AC726151A8800F1F7D5 /* Main.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 0CEB0AC826151A8800F1F7D5 /* Base */, + ); + name = Main.storyboard; + sourceTree = ""; + }; + 0CEB0ACC26151A8900F1F7D5 /* LaunchScreen.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 0CEB0ACD26151A8900F1F7D5 /* Base */, + ); + name = LaunchScreen.storyboard; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 0CEB0AE826151A8900F1F7D5 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_BITCODE = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = ""; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + LIBRARY_SEARCH_PATHS = ""; + MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; + MTL_FAST_MATH = YES; + ONLY_ACTIVE_ARCH = YES; + OTHER_LDFLAGS = ""; + SDKROOT = iphoneos; + }; + name = Debug; + }; + 0CEB0AE926151A8900F1F7D5 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_WEAK = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_BITCODE = NO; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = ""; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + LIBRARY_SEARCH_PATHS = ""; + MTL_ENABLE_DEBUG_INFO = NO; + MTL_FAST_MATH = YES; + OTHER_LDFLAGS = ""; + SDKROOT = iphoneos; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + 0CEB0AEB26151A8900F1F7D5 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor; + CODE_SIGN_STYLE = Automatic; + ENABLE_BITCODE = NO; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(PROJECT_DIR)/install/include", + ); + INFOPLIST_FILE = VisionTestApp/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "$(PROJECT_DIR)/VisionTestApp", + "$(PROJECT_DIR)", + "$(PROJECT_DIR)/install/lib", + ); + OTHER_LDFLAGS = ( + "$(inherited)", + "-ObjC", + "-l\"XNNPACK\"", + "-l\"c++\"", + "-l\"c10\"", + "-l\"clog\"", + "-l\"cpuinfo\"", + "-l\"eigen_blas\"", + "-l\"pthreadpool\"", + "-l\"pytorch_qnnpack\"", + "-l\"stdc++\"", + "-l\"torch\"", + "-l\"torch_cpu\"", + "-l\"torchvision_ops\"", + "-force_load", + "$(PROJECT_DIR)/install/lib/libtorch.a", + "-force_load", + "$(PROJECT_DIR)/install/lib/libtorch_cpu.a", + "-force_load", + "$(PROJECT_DIR)/install/lib/libtorchvision_ops.a", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.pytorch.ios.VisionTestApp.VisionTestApp; + PRODUCT_NAME = "$(TARGET_NAME)"; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + 0CEB0AEC26151A8900F1F7D5 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor; + CODE_SIGN_STYLE = Automatic; + ENABLE_BITCODE = NO; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(PROJECT_DIR)/install/include", + ); + INFOPLIST_FILE = VisionTestApp/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "$(PROJECT_DIR)/VisionTestApp", + "$(PROJECT_DIR)", + "$(PROJECT_DIR)/install/lib", + ); + OTHER_LDFLAGS = ( + "$(inherited)", + "-ObjC", + "-l\"XNNPACK\"", + "-l\"c++\"", + "-l\"c10\"", + "-l\"clog\"", + "-l\"cpuinfo\"", + "-l\"eigen_blas\"", + "-l\"pthreadpool\"", + "-l\"pytorch_qnnpack\"", + "-l\"stdc++\"", + "-l\"torch\"", + "-l\"torch_cpu\"", + "-l\"torchvision_ops\"", + "-force_load", + "$(PROJECT_DIR)/install/lib/libtorch.a", + "-force_load", + "$(PROJECT_DIR)/install/lib/libtorch_cpu.a", + "-force_load", + "$(PROJECT_DIR)/install/lib/libtorchvision_ops.a", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.pytorch.ios.VisionTestApp.VisionTestApp; + PRODUCT_NAME = "$(TARGET_NAME)"; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 0CEB0AB626151A8800F1F7D5 /* Build configuration list for PBXProject "VisionTestApp" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 0CEB0AE826151A8900F1F7D5 /* Debug */, + 0CEB0AE926151A8900F1F7D5 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 0CEB0AEA26151A8900F1F7D5 /* Build configuration list for PBXNativeTarget "VisionTestApp" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 0CEB0AEB26151A8900F1F7D5 /* Debug */, + 0CEB0AEC26151A8900F1F7D5 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 0CEB0AB326151A8800F1F7D5 /* Project object */; +} diff --git a/ios/VisionTestApp/VisionTestApp.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/ios/VisionTestApp/VisionTestApp.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 00000000000..919434a6254 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/ios/VisionTestApp/VisionTestApp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/ios/VisionTestApp/VisionTestApp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000000..18d981003d6 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/ios/VisionTestApp/VisionTestApp/AppDelegate.h b/ios/VisionTestApp/VisionTestApp/AppDelegate.h new file mode 100644 index 00000000000..0dde86886e6 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/AppDelegate.h @@ -0,0 +1,7 @@ +#import + +@interface AppDelegate : UIResponder + +@property(strong, nonatomic) UIWindow *window; + +@end diff --git a/ios/VisionTestApp/VisionTestApp/AppDelegate.m b/ios/VisionTestApp/VisionTestApp/AppDelegate.m new file mode 100644 index 00000000000..a20d3987c80 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/AppDelegate.m @@ -0,0 +1,44 @@ + +#import "AppDelegate.h" + +@interface AppDelegate () + +@end + +@implementation AppDelegate + + +- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { + // Override point for customization after application launch. + return YES; +} + + +- (void)applicationWillResignActive:(UIApplication *)application { + // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state. + // Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game. +} + + +- (void)applicationDidEnterBackground:(UIApplication *)application { + // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. + // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits. +} + + +- (void)applicationWillEnterForeground:(UIApplication *)application { + // Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background. +} + + +- (void)applicationDidBecomeActive:(UIApplication *)application { + // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface. +} + + +- (void)applicationWillTerminate:(UIApplication *)application { + // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:. +} + + +@end diff --git a/ios/VisionTestApp/VisionTestApp/Assets.xcassets/AccentColor.colorset/Contents.json b/ios/VisionTestApp/VisionTestApp/Assets.xcassets/AccentColor.colorset/Contents.json new file mode 100644 index 00000000000..eb878970081 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/Assets.xcassets/AccentColor.colorset/Contents.json @@ -0,0 +1,11 @@ +{ + "colors" : [ + { + "idiom" : "universal" + } + ], + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/ios/VisionTestApp/VisionTestApp/Assets.xcassets/AppIcon.appiconset/Contents.json b/ios/VisionTestApp/VisionTestApp/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 00000000000..9221b9bb1a3 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,98 @@ +{ + "images" : [ + { + "idiom" : "iphone", + "scale" : "2x", + "size" : "20x20" + }, + { + "idiom" : "iphone", + "scale" : "3x", + "size" : "20x20" + }, + { + "idiom" : "iphone", + "scale" : "2x", + "size" : "29x29" + }, + { + "idiom" : "iphone", + "scale" : "3x", + "size" : "29x29" + }, + { + "idiom" : "iphone", + "scale" : "2x", + "size" : "40x40" + }, + { + "idiom" : "iphone", + "scale" : "3x", + "size" : "40x40" + }, + { + "idiom" : "iphone", + "scale" : "2x", + "size" : "60x60" + }, + { + "idiom" : "iphone", + "scale" : "3x", + "size" : "60x60" + }, + { + "idiom" : "ipad", + "scale" : "1x", + "size" : "20x20" + }, + { + "idiom" : "ipad", + "scale" : "2x", + "size" : "20x20" + }, + { + "idiom" : "ipad", + "scale" : "1x", + "size" : "29x29" + }, + { + "idiom" : "ipad", + "scale" : "2x", + "size" : "29x29" + }, + { + "idiom" : "ipad", + "scale" : "1x", + "size" : "40x40" + }, + { + "idiom" : "ipad", + "scale" : "2x", + "size" : "40x40" + }, + { + "idiom" : "ipad", + "scale" : "1x", + "size" : "76x76" + }, + { + "idiom" : "ipad", + "scale" : "2x", + "size" : "76x76" + }, + { + "idiom" : "ipad", + "scale" : "2x", + "size" : "83.5x83.5" + }, + { + "idiom" : "ios-marketing", + "scale" : "1x", + "size" : "1024x1024" + } + ], + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/ios/VisionTestApp/VisionTestApp/Assets.xcassets/Contents.json b/ios/VisionTestApp/VisionTestApp/Assets.xcassets/Contents.json new file mode 100644 index 00000000000..73c00596a7f --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/Assets.xcassets/Contents.json @@ -0,0 +1,6 @@ +{ + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/ios/VisionTestApp/VisionTestApp/Base.lproj/LaunchScreen.storyboard b/ios/VisionTestApp/VisionTestApp/Base.lproj/LaunchScreen.storyboard new file mode 100644 index 00000000000..0b64f641701 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/Base.lproj/LaunchScreen.storyboard @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/ios/VisionTestApp/VisionTestApp/Base.lproj/Main.storyboard b/ios/VisionTestApp/VisionTestApp/Base.lproj/Main.storyboard new file mode 100644 index 00000000000..b20f277b049 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/Base.lproj/Main.storyboard @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/ios/VisionTestApp/VisionTestApp/Info.plist b/ios/VisionTestApp/VisionTestApp/Info.plist new file mode 100644 index 00000000000..5bae3d0ded5 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/Info.plist @@ -0,0 +1,45 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + $(PRODUCT_BUNDLE_PACKAGE_TYPE) + CFBundleShortVersionString + 1.0 + CFBundleVersion + 1 + LSRequiresIPhoneOS + + UIApplicationSupportsIndirectInputEvents + + UILaunchStoryboardName + LaunchScreen + UIMainStoryboardFile + Main + UIRequiredDeviceCapabilities + + armv7 + + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + + diff --git a/ios/VisionTestApp/VisionTestApp/ModelRunner.h b/ios/VisionTestApp/VisionTestApp/ModelRunner.h new file mode 100644 index 00000000000..f71c80c981c --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/ModelRunner.h @@ -0,0 +1,13 @@ + +#import + +NS_ASSUME_NONNULL_BEGIN + +@interface ModelRunner : NSObject + ++ (NSString* )run; ++ (BOOL)setUp; + +@end + +NS_ASSUME_NONNULL_END diff --git a/ios/VisionTestApp/VisionTestApp/ModelRunner.mm b/ios/VisionTestApp/VisionTestApp/ModelRunner.mm new file mode 100644 index 00000000000..1583e977497 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/ModelRunner.mm @@ -0,0 +1,73 @@ + +#import "ModelRunner.h" +#include +#include +#include "ATen/ATen.h" +#include "caffe2/core/timer.h" +#include "caffe2/utils/string_utils.h" +#include "torch/csrc/autograd/grad_mode.h" +#include "torch/csrc/jit/serialization/import.h" +#include "torch/script.h" + +static NSString *model_name = @"frcnn_mnetv3"; +static NSString *model_suffix = @"pt"; +static NSString *model_path = nil; +static int warmup = 5; +static int iter = 20; + +@implementation ModelRunner + ++ (NSString *)run { + std::vector logs; +#define UI_LOG(fmt, ...) \ + { \ + NSString* log = [NSString stringWithFormat:fmt, __VA_ARGS__]; \ + NSLog(@"%@", log); \ + logs.push_back(log.UTF8String); \ + } + + auto module = torch::jit::load(std::string(model_path.UTF8String)); + module.eval(); + + std::vector inputs; + auto img_tensor = torch::ones({3, 224, 224}, at::ScalarType::Float); + inputs.push_back(c10::List(img_tensor)); + torch::autograd::AutoGradMode guard(false); + at::AutoNonVariableTypeMode nonVarTypeModeGuard(true); + + UI_LOG(@"Running warmup runs...", nil); + for (int i = 0; i < warmup; ++i) { + module.forward(inputs); + } + UI_LOG(@"Warmup runs finished.\nMain runs...", nil); + caffe2::Timer timer; + auto millis = timer.MilliSeconds(); + for (int i = 0; i < iter; ++i) { + module.forward(inputs); + } + millis = timer.MilliSeconds(); + UI_LOG(@"Main run finished. \nMilliseconds per iter: %.3f", millis / iter, nil); + UI_LOG(@"Iters per second: : %.3f", 1000.0 * iter / millis, nil); + UI_LOG(@"Done.", nil); + + std::cout << module.forward(inputs) << std::endl; + + NSString* log_text = @""; + for (auto& msg : logs) { + log_text = [log_text stringByAppendingString:[NSString stringWithUTF8String:msg.c_str()]]; + log_text = [log_text stringByAppendingString:@"\n"]; + } + return log_text; +} + ++ (BOOL)setUp { + model_path = [[NSBundle mainBundle] pathForResource:model_name ofType:model_suffix]; + if (![[NSFileManager defaultManager] fileExistsAtPath:model_path]) { + NSLog(@"Invalid model path!"); + model_path = nil; + return NO; + } + return YES; +} + +@end diff --git a/ios/VisionTestApp/VisionTestApp/ViewController.h b/ios/VisionTestApp/VisionTestApp/ViewController.h new file mode 100644 index 00000000000..7df67432f92 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/ViewController.h @@ -0,0 +1,8 @@ + +#import + +@interface ViewController : UIViewController + + +@end + diff --git a/ios/VisionTestApp/VisionTestApp/ViewController.mm b/ios/VisionTestApp/VisionTestApp/ViewController.mm new file mode 100644 index 00000000000..900005d3990 --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/ViewController.mm @@ -0,0 +1,44 @@ + +#import "ViewController.h" +#include +#import "ModelRunner.h" + +@interface ViewController () +@property (weak, nonatomic) IBOutlet UITextView *textView; +@end + +static NSString const *config_error_msg = @"Wrong model configurations... Please fix and click \"Redo\""; + +@implementation ViewController + +- (void)viewDidLoad { + [super viewDidLoad]; + if ([ModelRunner setUp]) { + [self testModel]; + } else { + self.textView.text = [config_error_msg copy]; + } +} + + +- (IBAction)rerun:(id)sender { + self.textView.text = @""; + if (![ModelRunner setUp]) { + self.textView.text = [config_error_msg copy]; + return; + } + dispatch_async(dispatch_get_main_queue(), ^{ + [self testModel]; + }); +} + +- (void)testModel { + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ + NSString *text = [ModelRunner run]; + dispatch_async(dispatch_get_main_queue(), ^{ + self.textView.text = [self.textView.text stringByAppendingString:text]; + }); + }); +} + +@end diff --git a/ios/VisionTestApp/VisionTestApp/main.m b/ios/VisionTestApp/VisionTestApp/main.m new file mode 100644 index 00000000000..1a8b57c33bc --- /dev/null +++ b/ios/VisionTestApp/VisionTestApp/main.m @@ -0,0 +1,18 @@ +// +// main.m +// VisionTestApp +// +// Created by Yuchen Huang on 3/31/21. +// + +#import +#import "AppDelegate.h" + +int main(int argc, char * argv[]) { + NSString * appDelegateClassName; + @autoreleasepool { + // Setup code that might create autoreleased objects goes here. + appDelegateClassName = NSStringFromClass([AppDelegate class]); + } + return UIApplicationMain(argc, argv, nil, appDelegateClassName); +} diff --git a/ios/VisionTestApp/clean.sh b/ios/VisionTestApp/clean.sh new file mode 100755 index 00000000000..20bedc784d9 --- /dev/null +++ b/ios/VisionTestApp/clean.sh @@ -0,0 +1,8 @@ +#!/bin/bash +set -ex -o pipefail + +TEST_APP_PATH=$(dirname $(realpath $0)) +cd ${TEST_APP_PATH} + +rm -rf ./install +rm ./VisionTestApp/*.pt diff --git a/ios/VisionTestApp/make_assets.py b/ios/VisionTestApp/make_assets.py new file mode 100644 index 00000000000..122094b3547 --- /dev/null +++ b/ios/VisionTestApp/make_assets.py @@ -0,0 +1,17 @@ +import torch +import torchvision +from torch.utils.mobile_optimizer import optimize_for_mobile + +print(torch.__version__) + +model = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_320_fpn( + pretrained=True, + box_score_thresh=0.7, + rpn_post_nms_top_n_test=100, + rpn_score_thresh=0.4, + rpn_pre_nms_top_n_test=150) + +model.eval() +script_model = torch.jit.script(model) +opt_script_model = optimize_for_mobile(script_model) +opt_script_model.save("VisionTestApp/frcnn_mnetv3.pt") diff --git a/ios/VisionTestApp/setup.sh b/ios/VisionTestApp/setup.sh new file mode 100755 index 00000000000..3b3520d7052 --- /dev/null +++ b/ios/VisionTestApp/setup.sh @@ -0,0 +1,33 @@ +#!/bin/bash +set -ex -o pipefail + +echo "" +echo "DIR: $(pwd)" + +TEST_APP_PATH=$(dirname $(realpath $0)) +cd ${TEST_APP_PATH} + +PYTORCH_IOS_NIGHTLY_NAME=libtorch_ios_nightly_build.zip +VISION_IOS_NIGHTLY_NAME=libtorchvision_ops_ios_nightly_build.zip + +echo "Downloading torch libs and vision libs..." +wget https://ossci-ios-build.s3.amazonaws.com/${PYTORCH_IOS_NIGHTLY_NAME} +wget https://ossci-ios-build.s3.amazonaws.com/${VISION_IOS_NIGHTLY_NAME} + +mkdir -p ./library/torch +mkdir -p ./library/vision + +echo "Unziping torch libs and vision libs..." +unzip -d ./library/torch ./${PYTORCH_IOS_NIGHTLY_NAME} +unzip -d ./library/vision ./${VISION_IOS_NIGHTLY_NAME} + +cp ./library/vision/install/lib/*.a ./library/torch/install/lib +cp -r ./library/torch/install . + +rm -rf ./library +rm -rf ./*.zip + +echo "Generating the vision model..." +python ./make_assets.py + +echo "Finished project setups." From 48441cc5b434ccbc1c088d7cd72e3b86e8afcfdd Mon Sep 17 00:00:00 2001 From: Zhiqiang Wang Date: Tue, 11 May 2021 17:13:54 +0800 Subject: [PATCH 045/279] Refactor grid default boxes with torch meshgrid (#3799) * Refactor grid default boxes with torch.meshgrid * Fix torch jit tracing * Only doing the list multiplication once Co-authored-by: Francisco Massa * Make grid_default_box private as suggested Co-authored-by: Vasilis Vryniotis * Replace list multiplication with torch.repeat * Move the clipping into _grid_default_boxes to accelerate Co-authored-by: Francisco Massa Co-authored-by: Vasilis Vryniotis --- torchvision/models/detection/anchor_utils.py | 65 ++++++++++++-------- 1 file changed, 40 insertions(+), 25 deletions(-) diff --git a/torchvision/models/detection/anchor_utils.py b/torchvision/models/detection/anchor_utils.py index cf0bdbd69d7..3e0740036c8 100644 --- a/torchvision/models/detection/anchor_utils.py +++ b/torchvision/models/detection/anchor_utils.py @@ -170,26 +170,59 @@ def __init__(self, aspect_ratios: List[List[int]], min_ratio: float = 0.15, max_ else: self.scales = scales - self._wh_pairs = [] + self._wh_pairs = self._generate_wh_pairs(num_outputs) + + def _generate_wh_pairs(self, num_outputs: int, dtype: torch.dtype = torch.float32, + device: torch.device = torch.device("cpu")) -> List[Tensor]: + _wh_pairs: List[Tensor] = [] for k in range(num_outputs): # Adding the 2 default width-height pairs for aspect ratio 1 and scale s'k s_k = self.scales[k] s_prime_k = math.sqrt(self.scales[k] * self.scales[k + 1]) - wh_pairs = [(s_k, s_k), (s_prime_k, s_prime_k)] + wh_pairs = [[s_k, s_k], [s_prime_k, s_prime_k]] # Adding 2 pairs for each aspect ratio of the feature map k for ar in self.aspect_ratios[k]: sq_ar = math.sqrt(ar) w = self.scales[k] * sq_ar h = self.scales[k] / sq_ar - wh_pairs.extend([(w, h), (h, w)]) + wh_pairs.extend([[w, h], [h, w]]) - self._wh_pairs.append(wh_pairs) + _wh_pairs.append(torch.as_tensor(wh_pairs, dtype=dtype, device=device)) + return _wh_pairs def num_anchors_per_location(self): # Estimate num of anchors based on aspect ratios: 2 default boxes + 2 * ratios of feaure map. return [2 + 2 * len(r) for r in self.aspect_ratios] + # Default Boxes calculation based on page 6 of SSD paper + def _grid_default_boxes(self, grid_sizes: List[List[int]], image_size: List[int], + dtype: torch.dtype = torch.float32) -> Tensor: + default_boxes = [] + for k, f_k in enumerate(grid_sizes): + # Now add the default boxes for each width-height pair + if self.steps is not None: + x_f_k, y_f_k = [img_shape / self.steps[k] for img_shape in image_size] + else: + y_f_k, x_f_k = f_k + + shifts_x = (torch.arange(0, f_k[1], dtype=dtype) + 0.5) / x_f_k + shifts_y = (torch.arange(0, f_k[0], dtype=dtype) + 0.5) / y_f_k + shift_y, shift_x = torch.meshgrid(shifts_y, shifts_x) + shift_x = shift_x.reshape(-1) + shift_y = shift_y.reshape(-1) + + shifts = torch.stack((shift_x, shift_y) * len(self._wh_pairs[k]), dim=-1).reshape(-1, 2) + # Clipping the default boxes while the boxes are encoded in format (cx, cy, w, h) + _wh_pair = self._wh_pairs[k].clamp(min=0, max=1) if self.clip else self._wh_pairs[k] + wh_pairs = _wh_pair.repeat((f_k[0] * f_k[1]), 1) + + default_box = torch.cat((shifts, wh_pairs), dim=1) + + default_boxes.append(default_box) + + return torch.cat(default_boxes, dim=0) + def __repr__(self) -> str: s = self.__class__.__name__ + '(' s += 'aspect_ratios={aspect_ratios}' @@ -203,30 +236,12 @@ def forward(self, image_list: ImageList, feature_maps: List[Tensor]) -> List[Ten grid_sizes = [feature_map.shape[-2:] for feature_map in feature_maps] image_size = image_list.tensors.shape[-2:] dtype, device = feature_maps[0].dtype, feature_maps[0].device - - # Default Boxes calculation based on page 6 of SSD paper - default_boxes: List[List[float]] = [] - for k, f_k in enumerate(grid_sizes): - # Now add the default boxes for each width-height pair - for j in range(f_k[0]): - if self.steps is not None: - y_f_k = image_size[1] / self.steps[k] - else: - y_f_k = float(f_k[0]) - cy = (j + 0.5) / y_f_k - for i in range(f_k[1]): - if self.steps is not None: - x_f_k = image_size[0] / self.steps[k] - else: - x_f_k = float(f_k[1]) - cx = (i + 0.5) / x_f_k - default_boxes.extend([[cx, cy, w, h] for w, h in self._wh_pairs[k]]) + default_boxes = self._grid_default_boxes(grid_sizes, image_size, dtype=dtype) + default_boxes = default_boxes.to(device) dboxes = [] for _ in image_list.image_sizes: - dboxes_in_image = torch.tensor(default_boxes, dtype=dtype, device=device) - if self.clip: - dboxes_in_image.clamp_(min=0, max=1) + dboxes_in_image = default_boxes dboxes_in_image = torch.cat([dboxes_in_image[:, :2] - 0.5 * dboxes_in_image[:, 2:], dboxes_in_image[:, :2] + 0.5 * dboxes_in_image[:, 2:]], -1) dboxes_in_image[:, 0::2] *= image_size[1] From 45002089de1c040637864904a22758e280ff6cab Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 11 May 2021 09:20:24 +0000 Subject: [PATCH 046/279] Fix inconsistent version pinning across yaml files (#3790) * Fix inconsistent version pinning across yaml files. * Pin pillow to >=5.3.0 * Pin pillow>=5.3.0 everywhere --- .circleci/config.yml | 2 +- .circleci/config.yml.in | 2 +- .circleci/smoke_test/docker/Dockerfile | 6 +++--- .circleci/unittest/linux/scripts/environment.yml | 2 +- .circleci/unittest/linux/scripts/install.sh | 2 +- .circleci/unittest/windows/scripts/environment.yml | 2 +- .circleci/unittest/windows/scripts/install.sh | 2 +- packaging/build_cmake.sh | 2 +- packaging/torchvision/meta.yaml | 2 +- torchvision/transforms/transforms.py | 3 --- 10 files changed, 11 insertions(+), 14 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index d874755824c..5d9794a53b0 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -580,7 +580,7 @@ jobs: fi conda create ${CONDA_CHANNEL_FLAGS} -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} conda activate python${PYTHON_VERSION} - conda install Pillow + conda install Pillow>=5.3.0 conda install -v -y -c pytorch-nightly pytorch conda install -v -y $(ls ~/workspace/torchvision*.tar.bz2) - run: diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 8f15657ea94..6ef1372e184 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -580,7 +580,7 @@ jobs: fi conda create ${CONDA_CHANNEL_FLAGS} -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} conda activate python${PYTHON_VERSION} - conda install Pillow + conda install Pillow>=5.3.0 conda install -v -y -c pytorch-nightly pytorch conda install -v -y $(ls ~/workspace/torchvision*.tar.bz2) - run: diff --git a/.circleci/smoke_test/docker/Dockerfile b/.circleci/smoke_test/docker/Dockerfile index b6f25645620..e2227cf5e8b 100644 --- a/.circleci/smoke_test/docker/Dockerfile +++ b/.circleci/smoke_test/docker/Dockerfile @@ -30,7 +30,7 @@ RUN conda create -y --name python3.7 python=3.7 RUN conda create -y --name python3.8 python=3.8 SHELL [ "/bin/bash", "-c" ] RUN echo "source /usr/local/etc/profile.d/conda.sh" >> ~/.bashrc -RUN source /usr/local/etc/profile.d/conda.sh && conda activate python3.6 && conda install -y Pillow -RUN source /usr/local/etc/profile.d/conda.sh && conda activate python3.7 && conda install -y Pillow -RUN source /usr/local/etc/profile.d/conda.sh && conda activate python3.8 && conda install -y Pillow +RUN source /usr/local/etc/profile.d/conda.sh && conda activate python3.6 && conda install -y Pillow>=5.3.0 +RUN source /usr/local/etc/profile.d/conda.sh && conda activate python3.7 && conda install -y Pillow>=5.3.0 +RUN source /usr/local/etc/profile.d/conda.sh && conda activate python3.8 && conda install -y Pillow>=5.3.0 CMD [ "/bin/bash"] diff --git a/.circleci/unittest/linux/scripts/environment.yml b/.circleci/unittest/linux/scripts/environment.yml index 5ddc862c869..710c4829a20 100644 --- a/.circleci/unittest/linux/scripts/environment.yml +++ b/.circleci/unittest/linux/scripts/environment.yml @@ -14,6 +14,6 @@ dependencies: - ca-certificates - pip: - future - - pillow>=4.1.1 + - pillow >=5.3.0 - scipy - av diff --git a/.circleci/unittest/linux/scripts/install.sh b/.circleci/unittest/linux/scripts/install.sh index f05c4b59962..7058e4d7095 100755 --- a/.circleci/unittest/linux/scripts/install.sh +++ b/.circleci/unittest/linux/scripts/install.sh @@ -29,7 +29,7 @@ conda install -y -c "pytorch-${UPLOAD_CHANNEL}" -c conda-forge "pytorch-${UPLOAD if [ $PYTHON_VERSION == "3.6" ]; then printf "Installing minimal PILLOW version\n" # Install the minimal PILLOW version. Otherwise, let setup.py install the latest - pip install pillow==5.3.0 + pip install pillow>=5.3.0 fi printf "* Installing torchvision\n" diff --git a/.circleci/unittest/windows/scripts/environment.yml b/.circleci/unittest/windows/scripts/environment.yml index 1f9c38d82c0..fdc2fe68f64 100644 --- a/.circleci/unittest/windows/scripts/environment.yml +++ b/.circleci/unittest/windows/scripts/environment.yml @@ -14,7 +14,7 @@ dependencies: - ca-certificates - pip: - future - - pillow>=4.1.1 + - pillow >=5.3.0 - scipy - av - dataclasses diff --git a/.circleci/unittest/windows/scripts/install.sh b/.circleci/unittest/windows/scripts/install.sh index 9c59dd33007..a90e88a71d4 100644 --- a/.circleci/unittest/windows/scripts/install.sh +++ b/.circleci/unittest/windows/scripts/install.sh @@ -31,7 +31,7 @@ conda install -y -c "pytorch-${UPLOAD_CHANNEL}" -c conda-forge "pytorch-${UPLOAD if [ $PYTHON_VERSION == "3.6" ]; then printf "Installing minimal PILLOW version\n" # Install the minimal PILLOW version. Otherwise, let setup.py install the latest - pip install pillow==5.3.0 + pip install pillow>=5.3.0 fi printf "* Installing torchvision\n" diff --git a/packaging/build_cmake.sh b/packaging/build_cmake.sh index da758f4b7dc..0945f576ee2 100755 --- a/packaging/build_cmake.sh +++ b/packaging/build_cmake.sh @@ -21,7 +21,7 @@ setup_conda_pytorch_constraint setup_conda_cudatoolkit_plain_constraint if [[ "$OSTYPE" == "msys" ]]; then - conda install -yq conda-build cmake pillow future + conda install -yq conda-build cmake pillow>=5.3.0 future pip install dataclasses fi diff --git a/packaging/torchvision/meta.yaml b/packaging/torchvision/meta.yaml index d25b00c042f..c9b6d04fdc7 100644 --- a/packaging/torchvision/meta.yaml +++ b/packaging/torchvision/meta.yaml @@ -52,7 +52,7 @@ test: requires: - pytest - scipy - - av >=8.0.1 + - av # NOTE: Pinned to fix issues with size_t on Windows - jpeg <=9b - ca-certificates diff --git a/torchvision/transforms/transforms.py b/torchvision/transforms/transforms.py index 4e013227be1..1ec5bee0002 100644 --- a/torchvision/transforms/transforms.py +++ b/torchvision/transforms/transforms.py @@ -704,7 +704,6 @@ class RandomPerspective(torch.nn.Module): For backward compatibility integer values (e.g. ``PIL.Image.NEAREST``) are still acceptable. fill (sequence or number): Pixel fill value for the area outside the transformed image. Default is ``0``. If given a number, the value is used for all bands respectively. - If input is PIL Image, the options is only available for ``Pillow>=5.0.0``. """ def __init__(self, distortion_scale=0.5, p=0.5, interpolation=InterpolationMode.BILINEAR, fill=0): @@ -1216,7 +1215,6 @@ class RandomRotation(torch.nn.Module): Default is the center of the image. fill (sequence or number): Pixel fill value for the area outside the rotated image. Default is ``0``. If given a number, the value is used for all bands respectively. - If input is PIL Image, the options is only available for ``Pillow>=5.2.0``. resample (int, optional): deprecated argument and will be removed since v0.10.0. Please use the ``interpolation`` parameter instead. @@ -1327,7 +1325,6 @@ class RandomAffine(torch.nn.Module): For backward compatibility integer values (e.g. ``PIL.Image.NEAREST``) are still acceptable. fill (sequence or number): Pixel fill value for the area outside the transformed image. Default is ``0``. If given a number, the value is used for all bands respectively. - If input is PIL Image, the options is only available for ``Pillow>=5.0.0``. fillcolor (sequence or number, optional): deprecated argument and will be removed since v0.10.0. Please use the ``fill`` parameter instead. resample (int, optional): deprecated argument and will be removed since v0.10.0. From f87ce881e84388daf30905732f8286b8f49e9001 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 11 May 2021 13:36:12 +0100 Subject: [PATCH 047/279] Support for decoding jpegs on GPU with nvjpeg (#3792) Co-authored-by: James Thewlis --- CMakeLists.txt | 2 +- setup.py | 17 +- test/common_utils.py | 22 ++- test/test_image.py | 41 +++- .../csrc/io/image/cuda/decode_jpeg_cuda.cpp | 185 ++++++++++++++++++ .../csrc/io/image/cuda/decode_jpeg_cuda.h | 15 ++ torchvision/csrc/io/image/image.cpp | 3 +- torchvision/csrc/io/image/image.h | 1 + torchvision/io/image.py | 16 +- 9 files changed, 291 insertions(+), 11 deletions(-) create mode 100644 torchvision/csrc/io/image/cuda/decode_jpeg_cuda.cpp create mode 100644 torchvision/csrc/io/image/cuda/decode_jpeg_cuda.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 547ab7ddd2b..2dec2de88e7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -61,7 +61,7 @@ include(CMakePackageConfigHelpers) set(TVCPP torchvision/csrc) list(APPEND ALLOW_LISTED ${TVCPP} ${TVCPP}/io/image ${TVCPP}/io/image/cpu ${TVCPP}/models ${TVCPP}/ops - ${TVCPP}/ops/autograd ${TVCPP}/ops/cpu) + ${TVCPP}/ops/autograd ${TVCPP}/ops/cpu ${TVCPP}/io/image/cuda) if(WITH_CUDA) list(APPEND ALLOW_LISTED ${TVCPP}/ops/cuda ${TVCPP}/ops/autocast) endif() diff --git a/setup.py b/setup.py index 86007622715..4cc3d0698a4 100644 --- a/setup.py +++ b/setup.py @@ -315,8 +315,23 @@ def get_extensions(): image_library += [jpeg_lib] image_include += [jpeg_include] + # Locating nvjpeg + # Should be included in CUDA_HOME for CUDA >= 10.1, which is the minimum version we have in the CI + nvjpeg_found = ( + extension is CUDAExtension and + CUDA_HOME is not None and + os.path.exists(os.path.join(CUDA_HOME, 'include', 'nvjpeg.h')) + ) + + print('NVJPEG found: {0}'.format(nvjpeg_found)) + image_macros += [('NVJPEG_FOUND', str(int(nvjpeg_found)))] + if nvjpeg_found: + print('Building torchvision with NVJPEG image support') + image_link_flags.append('nvjpeg') + image_path = os.path.join(extensions_dir, 'io', 'image') - image_src = glob.glob(os.path.join(image_path, '*.cpp')) + glob.glob(os.path.join(image_path, 'cpu', '*.cpp')) + image_src = (glob.glob(os.path.join(image_path, '*.cpp')) + glob.glob(os.path.join(image_path, 'cpu', '*.cpp')) + + glob.glob(os.path.join(image_path, 'cuda', '*.cpp'))) if png_found or jpeg_found: ext_modules.append(extension( diff --git a/test/common_utils.py b/test/common_utils.py index 2c2fa73cf04..2a4aab5f65b 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -24,6 +24,9 @@ PY39_SEGFAULT_SKIP_MSG = "Segmentation fault with Python 3.9, see https://github.com/pytorch/vision/issues/3367" PY39_SKIP = unittest.skipIf(IS_PY39, PY39_SEGFAULT_SKIP_MSG) IN_CIRCLE_CI = os.getenv("CIRCLECI", False) == 'true' +IN_RE_WORKER = os.environ.get("INSIDE_RE_WORKER") is not None +IN_FBCODE = os.environ.get("IN_FBCODE_TORCHVISION") == "1" +CUDA_NOT_AVAILABLE_MSG = 'CUDA device not available' @contextlib.contextmanager @@ -407,11 +410,8 @@ def call_args_to_kwargs_only(call_args, *callable_or_arg_names): def cpu_and_gpu(): import pytest # noqa - # ignore CPU tests in RE as they're already covered by another contbuild - IN_RE_WORKER = os.environ.get("INSIDE_RE_WORKER") is not None - IN_FBCODE = os.environ.get("IN_FBCODE_TORCHVISION") == "1" - CUDA_NOT_AVAILABLE_MSG = 'CUDA device not available' + # ignore CPU tests in RE as they're already covered by another contbuild devices = [] if IN_RE_WORKER else ['cpu'] if torch.cuda.is_available(): @@ -427,3 +427,17 @@ def cpu_and_gpu(): devices.append(pytest.param('cuda', marks=cuda_marks)) return devices + + +def needs_cuda(test_func): + import pytest # noqa + + if IN_FBCODE and not IN_RE_WORKER: + # We don't want to skip in fbcode, so we just don't collect + # TODO: slightly more robust way would be to detect if we're in a sandcastle instance + # so that the test will still be collected (and skipped) in the devvms. + return pytest.mark.dont_collect(test_func) + elif torch.cuda.is_available(): + return test_func + else: + return pytest.mark.skip(reason=CUDA_NOT_AVAILABLE_MSG)(test_func) diff --git a/test/test_image.py b/test/test_image.py index ebc9a221f6d..11c8f3d7a03 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -3,10 +3,11 @@ import os import unittest +import pytest import numpy as np import torch from PIL import Image -from common_utils import get_tmp_dir +from common_utils import get_tmp_dir, needs_cuda from torchvision.io.image import ( decode_png, decode_jpeg, encode_jpeg, write_jpeg, decode_image, read_file, @@ -278,5 +279,43 @@ def test_write_file_non_ascii(self): os.unlink(fpath) +@needs_cuda +@pytest.mark.parametrize('mode', [ImageReadMode.UNCHANGED, ImageReadMode.GRAY, ImageReadMode.RGB]) +@pytest.mark.parametrize('img_path', get_images(IMAGE_ROOT, ".jpg")) +@pytest.mark.parametrize('scripted', (False, True)) +def test_decode_jpeg_cuda(mode, img_path, scripted): + if 'cmyk' in img_path: + pytest.xfail("Decoding a CMYK jpeg isn't supported") + tester = ImageTester() + data = read_file(img_path) + img = decode_image(data, mode=mode) + f = torch.jit.script(decode_jpeg) if scripted else decode_jpeg + img_nvjpeg = f(data, mode=mode, device='cuda') + + # Some difference expected between jpeg implementations + tester.assertTrue((img.float() - img_nvjpeg.cpu().float()).abs().mean() < 2) + + +@needs_cuda +@pytest.mark.parametrize('cuda_device', ('cuda', 'cuda:0', torch.device('cuda'))) +def test_decode_jpeg_cuda_device_param(cuda_device): + """Make sure we can pass a string or a torch.device as device param""" + data = read_file(next(get_images(IMAGE_ROOT, ".jpg"))) + decode_jpeg(data, device=cuda_device) + + +@needs_cuda +def test_decode_jpeg_cuda_errors(): + data = read_file(next(get_images(IMAGE_ROOT, ".jpg"))) + with pytest.raises(RuntimeError, match="Expected a non empty 1-dimensional tensor"): + decode_jpeg(data.reshape(-1, 1), device='cuda') + with pytest.raises(RuntimeError, match="input tensor must be on CPU"): + decode_jpeg(data.to('cuda'), device='cuda') + with pytest.raises(RuntimeError, match="Expected a torch.uint8 tensor"): + decode_jpeg(data.to(torch.float), device='cuda') + with pytest.raises(RuntimeError, match="Expected a cuda device"): + torch.ops.image.decode_jpeg_cuda(data, ImageReadMode.UNCHANGED.value, 'cpu') + + if __name__ == '__main__': unittest.main() diff --git a/torchvision/csrc/io/image/cuda/decode_jpeg_cuda.cpp b/torchvision/csrc/io/image/cuda/decode_jpeg_cuda.cpp new file mode 100644 index 00000000000..68f63ced427 --- /dev/null +++ b/torchvision/csrc/io/image/cuda/decode_jpeg_cuda.cpp @@ -0,0 +1,185 @@ +#include "decode_jpeg_cuda.h" + +#include + +#if NVJPEG_FOUND +#include +#include +#include +#endif + +#include + +namespace vision { +namespace image { + +#if !NVJPEG_FOUND + +torch::Tensor decode_jpeg_cuda( + const torch::Tensor& data, + ImageReadMode mode, + torch::Device device) { + TORCH_CHECK( + false, "decode_jpeg_cuda: torchvision not compiled with nvJPEG support"); +} + +#else + +namespace { +static nvjpegHandle_t nvjpeg_handle = nullptr; +} + +torch::Tensor decode_jpeg_cuda( + const torch::Tensor& data, + ImageReadMode mode, + torch::Device device) { + TORCH_CHECK(data.dtype() == torch::kU8, "Expected a torch.uint8 tensor"); + + TORCH_CHECK( + !data.is_cuda(), + "The input tensor must be on CPU when decoding with nvjpeg") + + TORCH_CHECK( + data.dim() == 1 && data.numel() > 0, + "Expected a non empty 1-dimensional tensor"); + + TORCH_CHECK(device.is_cuda(), "Expected a cuda device") + + at::cuda::CUDAGuard device_guard(device); + + // Create global nvJPEG handle + std::once_flag nvjpeg_handle_creation_flag; + std::call_once(nvjpeg_handle_creation_flag, []() { + if (nvjpeg_handle == nullptr) { + nvjpegStatus_t create_status = nvjpegCreateSimple(&nvjpeg_handle); + + if (create_status != NVJPEG_STATUS_SUCCESS) { + // Reset handle so that one can still call the function again in the + // same process if there was a failure + free(nvjpeg_handle); + nvjpeg_handle = nullptr; + } + TORCH_CHECK( + create_status == NVJPEG_STATUS_SUCCESS, + "nvjpegCreateSimple failed: ", + create_status); + } + }); + + // Create the jpeg state + nvjpegJpegState_t jpeg_state; + nvjpegStatus_t state_status = + nvjpegJpegStateCreate(nvjpeg_handle, &jpeg_state); + + TORCH_CHECK( + state_status == NVJPEG_STATUS_SUCCESS, + "nvjpegJpegStateCreate failed: ", + state_status); + + auto datap = data.data_ptr(); + + // Get the image information + int num_channels; + nvjpegChromaSubsampling_t subsampling; + int widths[NVJPEG_MAX_COMPONENT]; + int heights[NVJPEG_MAX_COMPONENT]; + nvjpegStatus_t info_status = nvjpegGetImageInfo( + nvjpeg_handle, + datap, + data.numel(), + &num_channels, + &subsampling, + widths, + heights); + + if (info_status != NVJPEG_STATUS_SUCCESS) { + nvjpegJpegStateDestroy(jpeg_state); + TORCH_CHECK(false, "nvjpegGetImageInfo failed: ", info_status); + } + + if (subsampling == NVJPEG_CSS_UNKNOWN) { + nvjpegJpegStateDestroy(jpeg_state); + TORCH_CHECK(false, "Unknown NVJPEG chroma subsampling"); + } + + int width = widths[0]; + int height = heights[0]; + + nvjpegOutputFormat_t ouput_format; + int num_channels_output; + + switch (mode) { + case IMAGE_READ_MODE_UNCHANGED: + num_channels_output = num_channels; + // For some reason, setting output_format to NVJPEG_OUTPUT_UNCHANGED will + // not properly decode RGB images (it's fine for grayscale), so we set + // output_format manually here + if (num_channels == 1) { + ouput_format = NVJPEG_OUTPUT_Y; + } else if (num_channels == 3) { + ouput_format = NVJPEG_OUTPUT_RGB; + } else { + nvjpegJpegStateDestroy(jpeg_state); + TORCH_CHECK( + false, + "When mode is UNCHANGED, only 1 or 3 input channels are allowed."); + } + break; + case IMAGE_READ_MODE_GRAY: + ouput_format = NVJPEG_OUTPUT_Y; + num_channels_output = 1; + break; + case IMAGE_READ_MODE_RGB: + ouput_format = NVJPEG_OUTPUT_RGB; + num_channels_output = 3; + break; + default: + nvjpegJpegStateDestroy(jpeg_state); + TORCH_CHECK( + false, "The provided mode is not supported for JPEG decoding on GPU"); + } + + auto out_tensor = torch::empty( + {int64_t(num_channels_output), int64_t(height), int64_t(width)}, + torch::dtype(torch::kU8).device(device)); + + // nvjpegImage_t is a struct with + // - an array of pointers to each channel + // - the pitch for each channel + // which must be filled in manually + nvjpegImage_t out_image; + + for (int c = 0; c < num_channels_output; c++) { + out_image.channel[c] = out_tensor[c].data_ptr(); + out_image.pitch[c] = width; + } + for (int c = num_channels_output; c < NVJPEG_MAX_COMPONENT; c++) { + out_image.channel[c] = nullptr; + out_image.pitch[c] = 0; + } + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(device.index()); + + nvjpegStatus_t decode_status = nvjpegDecode( + nvjpeg_handle, + jpeg_state, + datap, + data.numel(), + ouput_format, + &out_image, + stream); + + nvjpegJpegStateDestroy(jpeg_state); + + TORCH_CHECK( + decode_status == NVJPEG_STATUS_SUCCESS, + "nvjpegDecode failed: ", + decode_status); + + return out_tensor; +} + +#endif // NVJPEG_FOUND + +} // namespace image +} // namespace vision diff --git a/torchvision/csrc/io/image/cuda/decode_jpeg_cuda.h b/torchvision/csrc/io/image/cuda/decode_jpeg_cuda.h new file mode 100644 index 00000000000..496b355e9b7 --- /dev/null +++ b/torchvision/csrc/io/image/cuda/decode_jpeg_cuda.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include "../image_read_mode.h" + +namespace vision { +namespace image { + +C10_EXPORT torch::Tensor decode_jpeg_cuda( + const torch::Tensor& data, + ImageReadMode mode, + torch::Device device); + +} // namespace image +} // namespace vision diff --git a/torchvision/csrc/io/image/image.cpp b/torchvision/csrc/io/image/image.cpp index 51cf9c7ce3e..37d64013cb2 100644 --- a/torchvision/csrc/io/image/image.cpp +++ b/torchvision/csrc/io/image/image.cpp @@ -21,7 +21,8 @@ static auto registry = torch::RegisterOperators() .op("image::encode_jpeg", &encode_jpeg) .op("image::read_file", &read_file) .op("image::write_file", &write_file) - .op("image::decode_image", &decode_image); + .op("image::decode_image", &decode_image) + .op("image::decode_jpeg_cuda", &decode_jpeg_cuda); } // namespace image } // namespace vision diff --git a/torchvision/csrc/io/image/image.h b/torchvision/csrc/io/image/image.h index fb09d6d71b8..05bac44c77d 100644 --- a/torchvision/csrc/io/image/image.h +++ b/torchvision/csrc/io/image/image.h @@ -6,3 +6,4 @@ #include "cpu/encode_jpeg.h" #include "cpu/encode_png.h" #include "cpu/read_write_file.h" +#include "cuda/decode_jpeg_cuda.h" diff --git a/torchvision/io/image.py b/torchvision/io/image.py index 8310c1eb273..399a6f0d1ac 100644 --- a/torchvision/io/image.py +++ b/torchvision/io/image.py @@ -148,7 +148,8 @@ def write_png(input: torch.Tensor, filename: str, compression_level: int = 6): write_file(filename, output) -def decode_jpeg(input: torch.Tensor, mode: ImageReadMode = ImageReadMode.UNCHANGED) -> torch.Tensor: +def decode_jpeg(input: torch.Tensor, mode: ImageReadMode = ImageReadMode.UNCHANGED, + device: str = 'cpu') -> torch.Tensor: """ Decodes a JPEG image into a 3 dimensional RGB Tensor. Optionally converts the image to the desired format. @@ -156,16 +157,25 @@ def decode_jpeg(input: torch.Tensor, mode: ImageReadMode = ImageReadMode.UNCHANG Args: input (Tensor[1]): a one dimensional uint8 tensor containing - the raw bytes of the JPEG image. + the raw bytes of the JPEG image. This tensor must be on CPU, + regardless of the ``device`` parameter. mode (ImageReadMode): the read mode used for optionally converting the image. Default: `ImageReadMode.UNCHANGED`. See `ImageReadMode` class for more information on various available modes. + device (str or torch.device): The device on which the decoded image will + be stored. If a cuda device is specified, the image will be decoded + with `nvjpeg `_. This is only + supported for CUDA version >= 10.1 Returns: output (Tensor[image_channels, image_height, image_width]) """ - output = torch.ops.image.decode_jpeg(input, mode.value) + device = torch.device(device) + if device.type == 'cuda': + output = torch.ops.image.decode_jpeg_cuda(input, mode.value, device) + else: + output = torch.ops.image.decode_jpeg(input, mode.value) return output From a00fa4067d445eb965f0dd71e0b47082c5a77b15 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 11 May 2021 15:18:35 +0100 Subject: [PATCH 048/279] Convert "Visualization utilities" notebook into a sphinx-gallery example (#3774) --- docs/Makefile | 2 +- gallery/plot_scripted_tensor_transforms.py | 2 +- gallery/plot_visualization_utils.py | 131 +++++++++++++++++++++ torchvision/utils.py | 14 +-- 4 files changed, 134 insertions(+), 15 deletions(-) create mode 100644 gallery/plot_visualization_utils.py diff --git a/docs/Makefile b/docs/Makefile index 58daa471f5c..de809ed81cb 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -26,7 +26,7 @@ html-noplot: # Avoids running the gallery examples, which may take time clean: rm -rf $(BUILDDIR)/* - rm -rf auto_examples/ + rm -rf $(SOURCEDIR)/auto_examples/ .PHONY: help Makefile docset diff --git a/gallery/plot_scripted_tensor_transforms.py b/gallery/plot_scripted_tensor_transforms.py index 1decb0b7d21..4eeeeb311b9 100644 --- a/gallery/plot_scripted_tensor_transforms.py +++ b/gallery/plot_scripted_tensor_transforms.py @@ -34,7 +34,7 @@ plt.rcParams["savefig.bbox"] = 'tight' -torch.manual_seed(0) +torch.manual_seed(1) def show(imgs): diff --git a/gallery/plot_visualization_utils.py b/gallery/plot_visualization_utils.py new file mode 100644 index 00000000000..58788437a28 --- /dev/null +++ b/gallery/plot_visualization_utils.py @@ -0,0 +1,131 @@ +""" +======================= +Visualization utilities +======================= + +This example illustrates some of the utilities that torchvision offers for +visualizing images, bounding boxes, and segmentation masks. +""" + + +import torch +import numpy as np +import scipy.misc +import matplotlib.pyplot as plt + +import torchvision.transforms.functional as F + + +plt.rcParams["savefig.bbox"] = 'tight' + + +def show(imgs): + if not isinstance(imgs, list): + imgs = [imgs] + fix, axs = plt.subplots(ncols=len(imgs), squeeze=False) + for i, img in enumerate(imgs): + img = F.to_pil_image(img.to('cpu')) + axs[0, i].imshow(np.asarray(img)) + axs[0, i].set(xticklabels=[], yticklabels=[], xticks=[], yticks=[]) + + +#################################### +# Visualizing a grid of images +# ---------------------------- +# The :func:`~torchvision.utils.make_grid` function can be used to create a +# tensor that represents multiple images in a grid. This util requires a single +# image of dtype ``uint8`` as input. + +from torchvision.utils import make_grid +from torchvision.io import read_image +from pathlib import Path + +dog1_int = read_image(str(Path('assets') / 'dog1.jpg')) +dog2_int = read_image(str(Path('assets') / 'dog2.jpg')) + +grid = make_grid([dog1_int, dog2_int, dog1_int, dog2_int]) +show(grid) + +#################################### +# Visualizing bounding boxes +# -------------------------- +# We can use :func:`~torchvision.utils.draw_bounding_boxes` to draw boxes on an +# image. We can set the colors, labels, width as well as font and font size ! +# The boxes are in ``(xmin, ymin, xmax, ymax)`` format +# from torchvision.utils import draw_bounding_boxes + +from torchvision.utils import draw_bounding_boxes + + +boxes = torch.tensor([[50, 50, 100, 200], [210, 150, 350, 430]], dtype=torch.float) +colors = ["blue", "yellow"] +result = draw_bounding_boxes(dog1_int, boxes, colors=colors, width=5) +show(result) + + +##################################### +# Naturally, we can also plot bounding boxes produced by torchvision detection +# models. Here is demo with a Faster R-CNN model loaded from +# :func:`~torchvision.models.detection.fasterrcnn_resnet50_fpn` +# model. You can also try using a RetinaNet with +# :func:`~torchvision.models.detection.retinanet_resnet50_fpn`. + +from torchvision.models.detection import fasterrcnn_resnet50_fpn +from torchvision.transforms.functional import convert_image_dtype + + +dog1_float = convert_image_dtype(dog1_int, dtype=torch.float) +dog2_float = convert_image_dtype(dog2_int, dtype=torch.float) +batch = torch.stack([dog1_float, dog2_float]) + +model = fasterrcnn_resnet50_fpn(pretrained=True, progress=False) +model = model.eval() + +outputs = model(batch) +print(outputs) + +##################################### +# Let's plot the boxes detected by our model. We will only plot the boxes with a +# score greater than a given threshold. + +threshold = .8 +dogs_with_boxes = [ + draw_bounding_boxes(dog_int, boxes=output['boxes'][output['scores'] > threshold], width=4) + for dog_int, output in zip((dog1_int, dog2_int), outputs) +] +show(dogs_with_boxes) + +##################################### +# Visualizing segmentation masks +# ------------------------------ +# The :func:`~torchvision.utils.draw_segmentation_masks` function can be used to +# draw segmentation amasks on images. We can set the colors as well as +# transparency of masks. +# +# Here is demo with torchvision's FCN Resnet-50, loaded with +# :func:`~torchvision.models.segmentation.fcn_resnet50`. +# You can also try using +# DeepLabv3 (:func:`~torchvision.models.segmentation.deeplabv3_resnet50`) +# or lraspp mobilenet models +# (:func:`~torchvision.models.segmentation.lraspp_mobilenet_v3_large`). +# +# Like :func:`~torchvision.utils.draw_bounding_boxes`, +# :func:`~torchvision.utils.draw_segmentation_masks` requires a single RGB image +# of dtype `uint8`. + +from torchvision.models.segmentation import fcn_resnet50 +from torchvision.utils import draw_segmentation_masks + + +model = fcn_resnet50(pretrained=True, progress=False) +model = model.eval() + +# The model expects the batch to be normalized +batch = F.normalize(batch, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) +outputs = model(batch) + +dogs_with_masks = [ + draw_segmentation_masks(dog_int, masks=masks, alpha=0.6) + for dog_int, masks in zip((dog1_int, dog2_int), outputs['out']) +] +show(dogs_with_masks) diff --git a/torchvision/utils.py b/torchvision/utils.py index 39423e3b227..9d9bbdb3c80 100644 --- a/torchvision/utils.py +++ b/torchvision/utils.py @@ -40,10 +40,6 @@ def make_grid( Returns: grid (Tensor): the tensor containing grid of images. - - Example: - See this notebook - `here `_ """ if not (torch.is_tensor(tensor) or (isinstance(tensor, list) and all(torch.is_tensor(t) for t in tensor))): @@ -174,10 +170,6 @@ def draw_bounding_boxes( Returns: img (Tensor[C, H, W]): Image Tensor of dtype uint8 with bounding boxes plotted. - - Example: - See this notebook - `linked `_ """ if not isinstance(image, torch.Tensor): @@ -239,16 +231,12 @@ def draw_segmentation_masks( Args: image (Tensor): Tensor of shape (3 x H x W) and dtype uint8. masks (Tensor): Tensor of shape (num_masks, H, W). Each containing probability of predicted class. - alpha (float): Float number between 0 and 1 denoting factor of transpaerency of masks. + alpha (float): Float number between 0 and 1 denoting factor of transparency of masks. colors (List[Union[str, Tuple[int, int, int]]]): List containing the colors of masks. The colors can be represented as `str` or `Tuple[int, int, int]`. Returns: img (Tensor[C, H, W]): Image Tensor of dtype uint8 with segmentation masks plotted. - - Example: - See this notebook - `attached `_ """ if not isinstance(image, torch.Tensor): From 43d772067fe77965ec8fc49c799de5cea44b8aa2 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 11 May 2021 14:50:30 +0000 Subject: [PATCH 049/279] Add SSDlite architecture with MobileNetV3 backbones (#3757) * Partial implementation of SSDlite. * Add normal init and BN hyperparams. * Refactor to keep JIT happy * Completed SSDlite. * Fix lint * Update todos * Add expected file in repo. * Use C4 expansion instead of C4 output. * Change scales formula for Default Boxes. * Add cosine annealing on trainer. * Make T_max count epochs. * Fix test and handle corner-case. * Add support of support width_mult * Add ssdlite presets. * Change ReLU6, [-1,1] rescaling, backbone init & no pretraining. * Use _reduced_tail=True. * Add sync BN support. * Adding the best config along with its weights and documentation. * Make mean/std configurable. * Fix not implemented for half exception --- docs/source/models.rst | 8 + references/detection/README.md | 8 + references/detection/presets.py | 6 + references/detection/train.py | 28 ++- ...t_ssdlite320_mobilenet_v3_large_expect.pkl | Bin 0 -> 9677 bytes test/test_models.py | 1 + torchvision/models/detection/__init__.py | 1 + torchvision/models/detection/anchor_utils.py | 4 +- torchvision/models/detection/ssdlite.py | 228 ++++++++++++++++++ 9 files changed, 277 insertions(+), 7 deletions(-) create mode 100644 test/expect/ModelTester.test_ssdlite320_mobilenet_v3_large_expect.pkl create mode 100644 torchvision/models/detection/ssdlite.py diff --git a/docs/source/models.rst b/docs/source/models.rst index c70cd07979f..f9fb793ed36 100644 --- a/docs/source/models.rst +++ b/docs/source/models.rst @@ -427,6 +427,7 @@ Faster R-CNN MobileNetV3-Large FPN 32.8 - - Faster R-CNN MobileNetV3-Large 320 FPN 22.8 - - RetinaNet ResNet-50 FPN 36.4 - - SSD VGG16 25.1 - - +SSDlite MobileNetV3-Large 21.3 - - Mask R-CNN ResNet-50 FPN 37.9 34.6 - ====================================== ======= ======== =========== @@ -486,6 +487,7 @@ Faster R-CNN MobileNetV3-Large FPN 0.1020 0.0415 Faster R-CNN MobileNetV3-Large 320 FPN 0.0978 0.0376 0.6 RetinaNet ResNet-50 FPN 0.2514 0.0939 4.1 SSD VGG16 0.2093 0.0744 1.5 +SSDlite MobileNetV3-Large 0.1773 0.0906 1.5 Mask R-CNN ResNet-50 FPN 0.2728 0.0903 5.4 Keypoint R-CNN ResNet-50 FPN 0.3789 0.1242 6.8 ====================================== =================== ================== =========== @@ -511,6 +513,12 @@ SSD .. autofunction:: torchvision.models.detection.ssd300_vgg16 +SSDlite +------------ + +.. autofunction:: torchvision.models.detection.ssdlite320_mobilenet_v3_large + + Mask R-CNN ---------- diff --git a/references/detection/README.md b/references/detection/README.md index e4d52869d35..2fb0b658aa7 100644 --- a/references/detection/README.md +++ b/references/detection/README.md @@ -56,6 +56,14 @@ python -m torch.distributed.launch --nproc_per_node=8 --use_env train.py\ --weight-decay 0.0005 --data-augmentation ssd ``` +### SSDlite MobileNetV3-Large +``` +python -m torch.distributed.launch --nproc_per_node=8 --use_env train.py\ + --dataset coco --model ssdlite320_mobilenet_v3_large --epochs 660\ + --aspect-ratio-group-factor 3 --lr-scheduler cosineannealinglr --lr 0.15 --batch-size 24\ + --weight-decay 0.00004 --data-augmentation ssdlite +``` + ### Mask R-CNN ``` diff --git a/references/detection/presets.py b/references/detection/presets.py index 22937cf9576..1fac69ae356 100644 --- a/references/detection/presets.py +++ b/references/detection/presets.py @@ -16,6 +16,12 @@ def __init__(self, data_augmentation, hflip_prob=0.5, mean=(123., 117., 104.)): T.RandomHorizontalFlip(p=hflip_prob), T.ToTensor(), ]) + elif data_augmentation == 'ssdlite': + self.transforms = T.Compose([ + T.RandomIoUCrop(), + T.RandomHorizontalFlip(p=hflip_prob), + T.ToTensor(), + ]) else: raise ValueError(f'Unknown data augmentation policy "{data_augmentation}"') diff --git a/references/detection/train.py b/references/detection/train.py index 4eb39bf17f5..cd4148e9bf7 100644 --- a/references/detection/train.py +++ b/references/detection/train.py @@ -73,9 +73,13 @@ def get_args_parser(add_help=True): parser.add_argument('--wd', '--weight-decay', default=1e-4, type=float, metavar='W', help='weight decay (default: 1e-4)', dest='weight_decay') - parser.add_argument('--lr-step-size', default=8, type=int, help='decrease lr every step-size epochs') - parser.add_argument('--lr-steps', default=[16, 22], nargs='+', type=int, help='decrease lr every step-size epochs') - parser.add_argument('--lr-gamma', default=0.1, type=float, help='decrease lr by a factor of lr-gamma') + parser.add_argument('--lr-scheduler', default="multisteplr", help='the lr scheduler (default: multisteplr)') + parser.add_argument('--lr-step-size', default=8, type=int, + help='decrease lr every step-size epochs (multisteplr scheduler only)') + parser.add_argument('--lr-steps', default=[16, 22], nargs='+', type=int, + help='decrease lr every step-size epochs (multisteplr scheduler only)') + parser.add_argument('--lr-gamma', default=0.1, type=float, + help='decrease lr by a factor of lr-gamma (multisteplr scheduler only)') parser.add_argument('--print-freq', default=20, type=int, help='print frequency') parser.add_argument('--output-dir', default='.', help='path where to save') parser.add_argument('--resume', default='', help='resume from checkpoint') @@ -85,6 +89,12 @@ def get_args_parser(add_help=True): parser.add_argument('--trainable-backbone-layers', default=None, type=int, help='number of trainable layers of backbone') parser.add_argument('--data-augmentation', default="hflip", help='data augmentation policy (default: hflip)') + parser.add_argument( + "--sync-bn", + dest="sync_bn", + help="Use sync batch norm", + action="store_true", + ) parser.add_argument( "--test-only", dest="test_only", @@ -156,6 +166,8 @@ def main(args): model = torchvision.models.detection.__dict__[args.model](num_classes=num_classes, pretrained=args.pretrained, **kwargs) model.to(device) + if args.distributed and args.sync_bn: + model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model) model_without_ddp = model if args.distributed: @@ -166,8 +178,14 @@ def main(args): optimizer = torch.optim.SGD( params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) - # lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_step_size, gamma=args.lr_gamma) - lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_steps, gamma=args.lr_gamma) + args.lr_scheduler = args.lr_scheduler.lower() + if args.lr_scheduler == 'multisteplr': + lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_steps, gamma=args.lr_gamma) + elif args.lr_scheduler == 'cosineannealinglr': + lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs) + else: + raise RuntimeError("Invalid lr scheduler '{}'. Only MultiStepLR and CosineAnnealingLR " + "are supported.".format(args.lr_scheduler)) if args.resume: checkpoint = torch.load(args.resume, map_location='cpu') diff --git a/test/expect/ModelTester.test_ssdlite320_mobilenet_v3_large_expect.pkl b/test/expect/ModelTester.test_ssdlite320_mobilenet_v3_large_expect.pkl new file mode 100644 index 0000000000000000000000000000000000000000..f314346af014d1b8406bbfdbdc59695476c23c66 GIT binary patch literal 9677 zcmeHNUrbw77(XqALSY39vLS3F3IY=-l!ZSDMtVCda3w2MBd)rxltPh0IqjuE6HS8| zgY3bL3}#3)%#8<49MurEWC<==qP}dwYBn~Fi4T)34zr*y`l9Fi?xD1u%qL?E_avw1 z{_gp{-~G;a{(Zgo*u)eKA?fMlfs{iG#1(LR`$HaMk4th@4-fdPf}R{sNMZGBl)Ob% zS`O~~8#npt6|SrXl4r~0lmFu?5(Fq5;r z%p$MG``{Bzjg2(NtL>;%N%WCUQ7`5lqXsei7|osV0$H9!AGOnbB=fntJ-#5_EtByk zJ?|gti?wJ^Qj2OEn(FFl0q1{=^A`et(IoQkmFPY@Ego@I+eB^p;kN0#0Tm&TZQFKT z5y?#GI^&iL@qt!ByV;G52a{6nOh2f3|0|{Jh@IvKSV|!&<<9g2+x#&p<<9g2L~W3i z^55|T1Z}#h!e5VO5CZvOL0kTILEC{E7KK^`!)DMH7lG?;o@-XJ;sa$2C}ZINFa}^f ztiE1&HNpZ8$PZf&)3#p^*?R!1pl0i#ylTU5z947$&g|--(0lR=^JYCWqDNi ze7RZZU7l}&dv&eF0@Tm?&!SFUs{=71i=1N~`LAEhLXLv-C$N5e><6qr;=F-;7fPG3 zzGCoGVSe#BVfOt|tnaw@3%AG4ZTJ!S)*NG;?@Q#fnEMbf7&9zj-;JsF5bqycM?ONp z4wk}t3$(YlEP%KyRAPZPt~r(w?~1A{(4Mn%3y34eGS2rc;_0P43)n{p*a3W%$amNA z2jZ+~G1vbYam4s6>igQ#nH(XfmrSU?nEMUZmxVg<`LbQW*N%J}RfQ<8k3Nljoh!MB z7mRMs_ax`D$@ZWfpzlTfTa)=%Ulw{B`8TSX5bL83j(xqdg|cE>pC-U%+Xr?5-xMo>Zv?US?g`{u zDhVTQcTA)Hs^Lvpp3E?O$Nc-uWDG<9WTtlD_&DmkB*2(FXnqR)dBph};t%IeAzm=< zu|WOY+%?1(jP;0ZD;ngB7+>W0agGBVw;;Z`dxGP^*z;jAtYt~EAziu z@U nn.Sequential: + return nn.Sequential( + # 3x3 depthwise with stride 1 and padding 1 + ConvBNActivation(in_channels, in_channels, kernel_size=kernel_size, groups=in_channels, + norm_layer=norm_layer, activation_layer=nn.ReLU6), + + # 1x1 projetion to output channels + nn.Conv2d(in_channels, out_channels, 1) + ) + + +def _extra_block(in_channels: int, out_channels: int, norm_layer: Callable[..., nn.Module]) -> nn.Sequential: + activation = nn.ReLU6 + intermediate_channels = out_channels // 2 + return nn.Sequential( + # 1x1 projection to half output channels + ConvBNActivation(in_channels, intermediate_channels, kernel_size=1, + norm_layer=norm_layer, activation_layer=activation), + + # 3x3 depthwise with stride 2 and padding 1 + ConvBNActivation(intermediate_channels, intermediate_channels, kernel_size=3, stride=2, + groups=intermediate_channels, norm_layer=norm_layer, activation_layer=activation), + + # 1x1 projetion to output channels + ConvBNActivation(intermediate_channels, out_channels, kernel_size=1, + norm_layer=norm_layer, activation_layer=activation), + ) + + +def _normal_init(conv: nn.Module): + for layer in conv.modules(): + if isinstance(layer, nn.Conv2d): + torch.nn.init.normal_(layer.weight, mean=0.0, std=0.03) + if layer.bias is not None: + torch.nn.init.constant_(layer.bias, 0.0) + + +class SSDLiteHead(nn.Module): + def __init__(self, in_channels: List[int], num_anchors: List[int], num_classes: int, + norm_layer: Callable[..., nn.Module]): + super().__init__() + self.classification_head = SSDLiteClassificationHead(in_channels, num_anchors, num_classes, norm_layer) + self.regression_head = SSDLiteRegressionHead(in_channels, num_anchors, norm_layer) + + def forward(self, x: List[Tensor]) -> Dict[str, Tensor]: + return { + 'bbox_regression': self.regression_head(x), + 'cls_logits': self.classification_head(x), + } + + +class SSDLiteClassificationHead(SSDScoringHead): + def __init__(self, in_channels: List[int], num_anchors: List[int], num_classes: int, + norm_layer: Callable[..., nn.Module]): + cls_logits = nn.ModuleList() + for channels, anchors in zip(in_channels, num_anchors): + cls_logits.append(_prediction_block(channels, num_classes * anchors, 3, norm_layer)) + _normal_init(cls_logits) + super().__init__(cls_logits, num_classes) + + +class SSDLiteRegressionHead(SSDScoringHead): + def __init__(self, in_channels: List[int], num_anchors: List[int], norm_layer: Callable[..., nn.Module]): + bbox_reg = nn.ModuleList() + for channels, anchors in zip(in_channels, num_anchors): + bbox_reg.append(_prediction_block(channels, 4 * anchors, 3, norm_layer)) + _normal_init(bbox_reg) + super().__init__(bbox_reg, 4) + + +class SSDLiteFeatureExtractorMobileNet(nn.Module): + def __init__(self, backbone: nn.Module, c4_pos: int, norm_layer: Callable[..., nn.Module], rescaling: bool, + **kwargs: Any): + super().__init__() + # non-public config parameters + min_depth = kwargs.pop('_min_depth', 16) + width_mult = kwargs.pop('_width_mult', 1.0) + + assert not backbone[c4_pos].use_res_connect + self.features = nn.Sequential( + nn.Sequential(*backbone[:c4_pos], backbone[c4_pos].block[0]), # from start until C4 expansion layer + nn.Sequential(backbone[c4_pos].block[1:], *backbone[c4_pos + 1:]), # from C4 depthwise until end + ) + + get_depth = lambda d: max(min_depth, int(d * width_mult)) # noqa: E731 + extra = nn.ModuleList([ + _extra_block(backbone[-1].out_channels, get_depth(512), norm_layer), + _extra_block(get_depth(512), get_depth(256), norm_layer), + _extra_block(get_depth(256), get_depth(256), norm_layer), + _extra_block(get_depth(256), get_depth(128), norm_layer), + ]) + _normal_init(extra) + + self.extra = extra + self.rescaling = rescaling + + def forward(self, x: Tensor) -> Dict[str, Tensor]: + # Rescale from [0, 1] to [-1, -1] + if self.rescaling: + x = 2.0 * x - 1.0 + + # Get feature maps from backbone and extra. Can't be refactored due to JIT limitations. + output = [] + for block in self.features: + x = block(x) + output.append(x) + + for block in self.extra: + x = block(x) + output.append(x) + + return OrderedDict([(str(i), v) for i, v in enumerate(output)]) + + +def _mobilenet_extractor(backbone_name: str, progress: bool, pretrained: bool, trainable_layers: int, + norm_layer: Callable[..., nn.Module], rescaling: bool, **kwargs: Any): + backbone = mobilenet.__dict__[backbone_name](pretrained=pretrained, progress=progress, + norm_layer=norm_layer, **kwargs).features + if not pretrained: + # Change the default initialization scheme if not pretrained + _normal_init(backbone) + + # Gather the indices of blocks which are strided. These are the locations of C1, ..., Cn-1 blocks. + # The first and last blocks are always included because they are the C0 (conv1) and Cn. + stage_indices = [0] + [i for i, b in enumerate(backbone) if getattr(b, "_is_cn", False)] + [len(backbone) - 1] + num_stages = len(stage_indices) + + # find the index of the layer from which we wont freeze + assert 0 <= trainable_layers <= num_stages + freeze_before = num_stages if trainable_layers == 0 else stage_indices[num_stages - trainable_layers] + + for b in backbone[:freeze_before]: + for parameter in b.parameters(): + parameter.requires_grad_(False) + + return SSDLiteFeatureExtractorMobileNet(backbone, stage_indices[-2], norm_layer, rescaling, **kwargs) + + +def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = True, num_classes: int = 91, + pretrained_backbone: bool = False, trainable_backbone_layers: Optional[int] = None, + norm_layer: Optional[Callable[..., nn.Module]] = None, + **kwargs: Any): + """ + Constructs an SSDlite model with a MobileNetV3 Large backbone. See `SSD` for more details. + + Example: + + >>> model = torchvision.models.detection.ssdlite320_mobilenet_v3_large(pretrained=True) + >>> model.eval() + >>> x = [torch.rand(3, 320, 320), torch.rand(3, 500, 400)] + >>> predictions = model(x) + + Args: + norm_layer: + **kwargs: + pretrained (bool): If True, returns a model pre-trained on COCO train2017 + progress (bool): If True, displays a progress bar of the download to stderr + num_classes (int): number of output classes of the model (including the background) + pretrained_backbone (bool): If True, returns a model with backbone pre-trained on Imagenet + trainable_backbone_layers (int): number of trainable (not frozen) resnet layers starting from final block. + Valid values are between 0 and 6, with 6 meaning all backbone layers are trainable. + norm_layer (callable, optional): Module specifying the normalization layer to use. + """ + trainable_backbone_layers = _validate_trainable_layers( + pretrained or pretrained_backbone, trainable_backbone_layers, 6, 6) + + if pretrained: + pretrained_backbone = False + + # Enable [-1, 1] rescaling and reduced tail if no pretrained backbone is selected + rescaling = reduce_tail = not pretrained_backbone + + if norm_layer is None: + norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.03) + + backbone = _mobilenet_extractor("mobilenet_v3_large", progress, pretrained_backbone, trainable_backbone_layers, + norm_layer, rescaling, _reduced_tail=reduce_tail, _width_mult=1.0) + + size = (320, 320) + anchor_generator = DefaultBoxGenerator([[2, 3] for _ in range(6)], min_ratio=0.2, max_ratio=0.95) + out_channels = det_utils.retrieve_out_channels(backbone, size) + num_anchors = anchor_generator.num_anchors_per_location() + assert len(out_channels) == len(anchor_generator.aspect_ratios) + + defaults = { + "score_thresh": 0.001, + "nms_thresh": 0.55, + "detections_per_img": 300, + "topk_candidates": 300, + "image_mean": [0., 0., 0.], + "image_std": [1., 1., 1.], + } + kwargs = {**defaults, **kwargs} + model = SSD(backbone, anchor_generator, size, num_classes, + head=SSDLiteHead(out_channels, num_anchors, num_classes, norm_layer), **kwargs) + + if pretrained: + weights_name = 'ssdlite320_mobilenet_v3_large_coco' + if model_urls.get(weights_name, None) is None: + raise ValueError("No checkpoint is available for model {}".format(weights_name)) + state_dict = load_state_dict_from_url(model_urls[weights_name], progress=progress) + model.load_state_dict(state_dict) + return model From 6374cff272806238d241227348b33c483c2b1a0c Mon Sep 17 00:00:00 2001 From: Aditya Oke <47158509+oke-aditya@users.noreply.github.com> Date: Tue, 11 May 2021 20:50:38 +0530 Subject: [PATCH 050/279] Fix io docs and expose `ImageReadMode` in `torchvision.io` (#3812) * Fix io imports and expose methods * fix fmt Co-authored-by: Vasilis Vryniotis --- docs/source/io.rst | 10 ++++++++++ torchvision/io/__init__.py | 2 ++ torchvision/io/image.py | 32 ++++++++++++++++---------------- 3 files changed, 28 insertions(+), 16 deletions(-) diff --git a/docs/source/io.rst b/docs/source/io.rst index e85951e719a..2e416469d17 100644 --- a/docs/source/io.rst +++ b/docs/source/io.rst @@ -59,14 +59,24 @@ Example of inspecting a video: Image ----- +.. autoclass:: ImageReadMode + .. autofunction:: read_image .. autofunction:: decode_image .. autofunction:: encode_jpeg +.. autofunction:: decode_jpeg + .. autofunction:: write_jpeg .. autofunction:: encode_png +.. autofunction:: decode_png + .. autofunction:: write_png + +.. autofunction:: read_file + +.. autofunction:: write_file diff --git a/torchvision/io/__init__.py b/torchvision/io/__init__.py index fe4cc81ccd7..742344e6b0f 100644 --- a/torchvision/io/__init__.py +++ b/torchvision/io/__init__.py @@ -17,6 +17,7 @@ write_video, ) from .image import ( + ImageReadMode, decode_image, decode_jpeg, decode_png, @@ -186,6 +187,7 @@ def set_current_stream(self, stream: str): "_read_video_meta_data", "VideoMetaData", "Timebase", + "ImageReadMode", "decode_image", "decode_jpeg", "decode_png", diff --git a/torchvision/io/image.py b/torchvision/io/image.py index 399a6f0d1ac..4f824abad60 100644 --- a/torchvision/io/image.py +++ b/torchvision/io/image.py @@ -52,10 +52,10 @@ class ImageReadMode(Enum): """ Support for various modes while reading images. - Use `ImageReadMode.UNCHANGED` for loading the image as-is, - `ImageReadMode.GRAY` for converting to grayscale, - `ImageReadMode.GRAY_ALPHA` for grayscale with transparency, - `ImageReadMode.RGB` for RGB and `ImageReadMode.RGB_ALPHA` for + Use ``ImageReadMode.UNCHANGED`` for loading the image as-is, + ``ImageReadMode.GRAY`` for converting to grayscale, + ``ImageReadMode.GRAY_ALPHA`` for grayscale with transparency, + ``ImageReadMode.RGB`` for RGB and ``ImageReadMode.RGB_ALPHA`` for RGB with transparency. """ UNCHANGED = 0 @@ -102,7 +102,7 @@ def decode_png(input: torch.Tensor, mode: ImageReadMode = ImageReadMode.UNCHANGE input (Tensor[1]): a one dimensional uint8 tensor containing the raw bytes of the PNG image. mode (ImageReadMode): the read mode used for optionally - converting the image. Default: `ImageReadMode.UNCHANGED`. + converting the image. Default: ``ImageReadMode.UNCHANGED``. See `ImageReadMode` class for more information on various available modes. @@ -120,7 +120,7 @@ def encode_png(input: torch.Tensor, compression_level: int = 6) -> torch.Tensor: Args: input (Tensor[channels, image_height, image_width]): int8 image tensor of - `c` channels, where `c` must 3 or 1. + ``c`` channels, where ``c`` must 3 or 1. compression_level (int): Compression factor for the resulting file, it must be a number between 0 and 9. Default: 6 @@ -139,7 +139,7 @@ def write_png(input: torch.Tensor, filename: str, compression_level: int = 6): Args: input (Tensor[channels, image_height, image_width]): int8 image tensor of - `c` channels, where `c` must be 1 or 3. + ``c`` channels, where ``c`` must be 1 or 3. filename (str): Path to save the image. compression_level (int): Compression factor for the resulting file, it must be a number between 0 and 9. Default: 6 @@ -160,8 +160,8 @@ def decode_jpeg(input: torch.Tensor, mode: ImageReadMode = ImageReadMode.UNCHANG the raw bytes of the JPEG image. This tensor must be on CPU, regardless of the ``device`` parameter. mode (ImageReadMode): the read mode used for optionally - converting the image. Default: `ImageReadMode.UNCHANGED`. - See `ImageReadMode` class for more information on various + converting the image. Default: ``ImageReadMode.UNCHANGED``. + See ``ImageReadMode`` class for more information on various available modes. device (str or torch.device): The device on which the decoded image will be stored. If a cuda device is specified, the image will be decoded @@ -186,7 +186,7 @@ def encode_jpeg(input: torch.Tensor, quality: int = 75) -> torch.Tensor: Args: input (Tensor[channels, image_height, image_width])): int8 image tensor of - `c` channels, where `c` must be 1 or 3. + ``c`` channels, where ``c`` must be 1 or 3. quality (int): Quality of the resulting JPEG file, it must be a number between 1 and 100. Default: 75 @@ -207,8 +207,8 @@ def write_jpeg(input: torch.Tensor, filename: str, quality: int = 75): Takes an input tensor in CHW layout and saves it in a JPEG file. Args: - input (Tensor[channels, image_height, image_width]): int8 image tensor of `c` - channels, where `c` must be 1 or 3. + input (Tensor[channels, image_height, image_width]): int8 image tensor of ``c`` + channels, where ``c`` must be 1 or 3. filename (str): Path to save the image. quality (int): Quality of the resulting JPEG file, it must be a number between 1 and 100. Default: 75 @@ -229,8 +229,8 @@ def decode_image(input: torch.Tensor, mode: ImageReadMode = ImageReadMode.UNCHAN input (Tensor): a one dimensional uint8 tensor containing the raw bytes of the PNG or JPEG image. mode (ImageReadMode): the read mode used for optionally converting the image. - Default: `ImageReadMode.UNCHANGED`. - See `ImageReadMode` class for more information on various + Default: ``ImageReadMode.UNCHANGED``. + See ``ImageReadMode`` class for more information on various available modes. Returns: @@ -249,8 +249,8 @@ def read_image(path: str, mode: ImageReadMode = ImageReadMode.UNCHANGED) -> torc Args: path (str): path of the JPEG or PNG image. mode (ImageReadMode): the read mode used for optionally converting the image. - Default: `ImageReadMode.UNCHANGED`. - See `ImageReadMode` class for more information on various + Default: ``ImageReadMode.UNCHANGED``. + See ``ImageReadMode`` class for more information on various available modes. Returns: From e35793a1a4000db1f9f99673437c514e24e65451 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Wed, 12 May 2021 15:58:09 +0000 Subject: [PATCH 051/279] Cerrypicking cleanups for SSD and SSDlite. (#3818) --- docs/source/models.rst | 14 +++++------ references/detection/README.md | 4 ++-- torchvision/models/detection/ssd.py | 31 ++++++++++++++----------- torchvision/models/detection/ssdlite.py | 30 ++++++++++++------------ 4 files changed, 41 insertions(+), 38 deletions(-) diff --git a/docs/source/models.rst b/docs/source/models.rst index f9fb793ed36..c2b81e49735 100644 --- a/docs/source/models.rst +++ b/docs/source/models.rst @@ -426,8 +426,8 @@ Faster R-CNN ResNet-50 FPN 37.0 - - Faster R-CNN MobileNetV3-Large FPN 32.8 - - Faster R-CNN MobileNetV3-Large 320 FPN 22.8 - - RetinaNet ResNet-50 FPN 36.4 - - -SSD VGG16 25.1 - - -SSDlite MobileNetV3-Large 21.3 - - +SSD300 VGG16 25.1 - - +SSDlite320 MobileNetV3-Large 21.3 - - Mask R-CNN ResNet-50 FPN 37.9 34.6 - ====================================== ======= ======== =========== @@ -486,8 +486,8 @@ Faster R-CNN ResNet-50 FPN 0.2288 0.0590 Faster R-CNN MobileNetV3-Large FPN 0.1020 0.0415 1.0 Faster R-CNN MobileNetV3-Large 320 FPN 0.0978 0.0376 0.6 RetinaNet ResNet-50 FPN 0.2514 0.0939 4.1 -SSD VGG16 0.2093 0.0744 1.5 -SSDlite MobileNetV3-Large 0.1773 0.0906 1.5 +SSD300 VGG16 0.2093 0.0744 1.5 +SSDlite320 MobileNetV3-Large 0.1773 0.0906 1.5 Mask R-CNN ResNet-50 FPN 0.2728 0.0903 5.4 Keypoint R-CNN ResNet-50 FPN 0.3789 0.1242 6.8 ====================================== =================== ================== =========== @@ -502,19 +502,19 @@ Faster R-CNN RetinaNet ------------- +--------- .. autofunction:: torchvision.models.detection.retinanet_resnet50_fpn SSD ------------- +--- .. autofunction:: torchvision.models.detection.ssd300_vgg16 SSDlite ------------- +------- .. autofunction:: torchvision.models.detection.ssdlite320_mobilenet_v3_large diff --git a/references/detection/README.md b/references/detection/README.md index 2fb0b658aa7..ea5be6ea791 100644 --- a/references/detection/README.md +++ b/references/detection/README.md @@ -48,7 +48,7 @@ python -m torch.distributed.launch --nproc_per_node=8 --use_env train.py\ --lr-steps 16 22 --aspect-ratio-group-factor 3 --lr 0.01 ``` -### SSD VGG16 +### SSD300 VGG16 ``` python -m torch.distributed.launch --nproc_per_node=8 --use_env train.py\ --dataset coco --model ssd300_vgg16 --epochs 120\ @@ -56,7 +56,7 @@ python -m torch.distributed.launch --nproc_per_node=8 --use_env train.py\ --weight-decay 0.0005 --data-augmentation ssd ``` -### SSDlite MobileNetV3-Large +### SSDlite320 MobileNetV3-Large ``` python -m torch.distributed.launch --nproc_per_node=8 --use_env train.py\ --dataset coco --model ssdlite320_mobilenet_v3_large --epochs 660\ diff --git a/torchvision/models/detection/ssd.py b/torchvision/models/detection/ssd.py index aeb93012d78..f6150cf5cd5 100644 --- a/torchvision/models/detection/ssd.py +++ b/torchvision/models/detection/ssd.py @@ -410,7 +410,7 @@ def postprocess_detections(self, head_outputs: Dict[str, Tensor], image_anchors: class SSDFeatureExtractorVGG(nn.Module): - def __init__(self, backbone: nn.Module, highres: bool, rescaling: bool): + def __init__(self, backbone: nn.Module, highres: bool): super().__init__() _, _, maxpool3_pos, maxpool4_pos, _ = (i for i, layer in enumerate(backbone) if isinstance(layer, nn.MaxPool2d)) @@ -476,13 +476,8 @@ def __init__(self, backbone: nn.Module, highres: bool, rescaling: bool): fc, )) self.extra = extra - self.rescaling = rescaling def forward(self, x: Tensor) -> Dict[str, Tensor]: - # Undo the 0-1 scaling of toTensor. Necessary for some backbones. - if self.rescaling: - x *= 255 - # L2 regularization + Rescaling of 1st block's feature map x = self.features(x) rescaled = self.scale_weight.view(1, -1, 1, 1) * F.normalize(x) @@ -496,8 +491,7 @@ def forward(self, x: Tensor) -> Dict[str, Tensor]: return OrderedDict([(str(i), v) for i, v in enumerate(output)]) -def _vgg_extractor(backbone_name: str, highres: bool, progress: bool, pretrained: bool, trainable_layers: int, - rescaling: bool): +def _vgg_extractor(backbone_name: str, highres: bool, progress: bool, pretrained: bool, trainable_layers: int): if backbone_name in backbone_urls: # Use custom backbones more appropriate for SSD arch = backbone_name.split('_')[0] @@ -521,19 +515,19 @@ def _vgg_extractor(backbone_name: str, highres: bool, progress: bool, pretrained for parameter in b.parameters(): parameter.requires_grad_(False) - return SSDFeatureExtractorVGG(backbone, highres, rescaling) + return SSDFeatureExtractorVGG(backbone, highres) def ssd300_vgg16(pretrained: bool = False, progress: bool = True, num_classes: int = 91, pretrained_backbone: bool = True, trainable_backbone_layers: Optional[int] = None, **kwargs: Any): """ - Constructs an SSD model with a VGG16 backbone. See `SSD` for more details. + Constructs an SSD model with input size 300x300 and a VGG16 backbone. See `SSD` for more details. Example: >>> model = torchvision.models.detection.ssd300_vgg16(pretrained=True) >>> model.eval() - >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)] + >>> x = [torch.rand(3, 300, 300), torch.rand(3, 500, 400)] >>> predictions = model(x) Args: @@ -544,6 +538,9 @@ def ssd300_vgg16(pretrained: bool = False, progress: bool = True, num_classes: i trainable_backbone_layers (int): number of trainable (not frozen) resnet layers starting from final block. Valid values are between 0 and 5, with 5 meaning all backbone layers are trainable. """ + if "size" in kwargs: + warnings.warn("The size of the model is already fixed; ignoring the argument.") + trainable_backbone_layers = _validate_trainable_layers( pretrained or pretrained_backbone, trainable_backbone_layers, 5, 5) @@ -551,12 +548,18 @@ def ssd300_vgg16(pretrained: bool = False, progress: bool = True, num_classes: i # no need to download the backbone if pretrained is set pretrained_backbone = False - backbone = _vgg_extractor("vgg16_features", False, progress, pretrained_backbone, trainable_backbone_layers, True) + backbone = _vgg_extractor("vgg16_features", False, progress, pretrained_backbone, trainable_backbone_layers) anchor_generator = DefaultBoxGenerator([[2], [2, 3], [2, 3], [2, 3], [2], [2]], scales=[0.07, 0.15, 0.33, 0.51, 0.69, 0.87, 1.05], steps=[8, 16, 32, 64, 100, 300]) - model = SSD(backbone, anchor_generator, (300, 300), num_classes, - image_mean=[0.48235, 0.45882, 0.40784], image_std=[1., 1., 1.], **kwargs) + + defaults = { + # Rescale the input in a way compatible to the backbone + "image_mean": [0.48235, 0.45882, 0.40784], + "image_std": [1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0], # undo the 0-1 scaling of toTensor + } + kwargs = {**defaults, **kwargs} + model = SSD(backbone, anchor_generator, (300, 300), num_classes, **kwargs) if pretrained: weights_name = 'ssd300_vgg16_coco' if model_urls.get(weights_name, None) is None: diff --git a/torchvision/models/detection/ssdlite.py b/torchvision/models/detection/ssdlite.py index 412434dabd7..8498a78d6dd 100644 --- a/torchvision/models/detection/ssdlite.py +++ b/torchvision/models/detection/ssdlite.py @@ -1,4 +1,5 @@ import torch +import warnings from collections import OrderedDict from functools import partial @@ -94,8 +95,7 @@ def __init__(self, in_channels: List[int], num_anchors: List[int], norm_layer: C class SSDLiteFeatureExtractorMobileNet(nn.Module): - def __init__(self, backbone: nn.Module, c4_pos: int, norm_layer: Callable[..., nn.Module], rescaling: bool, - **kwargs: Any): + def __init__(self, backbone: nn.Module, c4_pos: int, norm_layer: Callable[..., nn.Module], **kwargs: Any): super().__init__() # non-public config parameters min_depth = kwargs.pop('_min_depth', 16) @@ -117,13 +117,8 @@ def __init__(self, backbone: nn.Module, c4_pos: int, norm_layer: Callable[..., n _normal_init(extra) self.extra = extra - self.rescaling = rescaling def forward(self, x: Tensor) -> Dict[str, Tensor]: - # Rescale from [0, 1] to [-1, -1] - if self.rescaling: - x = 2.0 * x - 1.0 - # Get feature maps from backbone and extra. Can't be refactored due to JIT limitations. output = [] for block in self.features: @@ -138,7 +133,7 @@ def forward(self, x: Tensor) -> Dict[str, Tensor]: def _mobilenet_extractor(backbone_name: str, progress: bool, pretrained: bool, trainable_layers: int, - norm_layer: Callable[..., nn.Module], rescaling: bool, **kwargs: Any): + norm_layer: Callable[..., nn.Module], **kwargs: Any): backbone = mobilenet.__dict__[backbone_name](pretrained=pretrained, progress=progress, norm_layer=norm_layer, **kwargs).features if not pretrained: @@ -158,7 +153,7 @@ def _mobilenet_extractor(backbone_name: str, progress: bool, pretrained: bool, t for parameter in b.parameters(): parameter.requires_grad_(False) - return SSDLiteFeatureExtractorMobileNet(backbone, stage_indices[-2], norm_layer, rescaling, **kwargs) + return SSDLiteFeatureExtractorMobileNet(backbone, stage_indices[-2], norm_layer, **kwargs) def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = True, num_classes: int = 91, @@ -166,7 +161,7 @@ def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = Tru norm_layer: Optional[Callable[..., nn.Module]] = None, **kwargs: Any): """ - Constructs an SSDlite model with a MobileNetV3 Large backbone. See `SSD` for more details. + Constructs an SSDlite model with input size 320x320 and a MobileNetV3 Large backbone. See `SSD` for more details. Example: @@ -186,20 +181,23 @@ def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = Tru Valid values are between 0 and 6, with 6 meaning all backbone layers are trainable. norm_layer (callable, optional): Module specifying the normalization layer to use. """ + if "size" in kwargs: + warnings.warn("The size of the model is already fixed; ignoring the argument.") + trainable_backbone_layers = _validate_trainable_layers( pretrained or pretrained_backbone, trainable_backbone_layers, 6, 6) if pretrained: pretrained_backbone = False - # Enable [-1, 1] rescaling and reduced tail if no pretrained backbone is selected - rescaling = reduce_tail = not pretrained_backbone + # Enable reduced tail if no pretrained backbone is selected + reduce_tail = not pretrained_backbone if norm_layer is None: norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.03) backbone = _mobilenet_extractor("mobilenet_v3_large", progress, pretrained_backbone, trainable_backbone_layers, - norm_layer, rescaling, _reduced_tail=reduce_tail, _width_mult=1.0) + norm_layer, _reduced_tail=reduce_tail, _width_mult=1.0) size = (320, 320) anchor_generator = DefaultBoxGenerator([[2, 3] for _ in range(6)], min_ratio=0.2, max_ratio=0.95) @@ -212,8 +210,10 @@ def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = Tru "nms_thresh": 0.55, "detections_per_img": 300, "topk_candidates": 300, - "image_mean": [0., 0., 0.], - "image_std": [1., 1., 1.], + # Rescale the input in a way compatible to the backbone: + # The following mean/std rescale the data from [0, 1] to [-1, -1] + "image_mean": [0.5, 0.5, 0.5], + "image_std": [0.5, 0.5, 0.5], } kwargs = {**defaults, **kwargs} model = SSD(backbone, anchor_generator, size, num_classes, From 0fd0f503a14ccf3f51d291c2f89721a7bc36c7b8 Mon Sep 17 00:00:00 2001 From: vfdev Date: Thu, 13 May 2021 11:41:41 +0200 Subject: [PATCH 052/279] Added bicubic support for interpolation with AA (#3810) * Added support for bicubic mode with AA * Updated comment in the test --- test/test_functional_tensor.py | 13 +- .../csrc/ops/cpu/interpolate_aa_kernels.cpp | 223 ++++++++++++------ torchvision/csrc/ops/interpolate_aa.cpp | 16 +- torchvision/csrc/ops/interpolate_aa.h | 5 + torchvision/transforms/functional_tensor.py | 10 +- 5 files changed, 192 insertions(+), 75 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index f28b6e633d9..6d9b20870e5 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -1021,7 +1021,7 @@ def test_perspective_interpolation_warning(tester): @pytest.mark.parametrize('device', ["cpu", ]) @pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) @pytest.mark.parametrize('size', [[96, 72], [96, 420], [420, 72]]) -@pytest.mark.parametrize('interpolation', [BILINEAR, ]) +@pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC]) def test_resize_antialias(device, dt, size, interpolation, tester): if dt == torch.float16 and device == "cpu": @@ -1051,8 +1051,17 @@ def test_resize_antialias(device, dt, size, interpolation, tester): tester.approxEqualTensorToPIL( resized_tensor_f, resized_pil_img, tol=0.5, msg=f"{size}, {interpolation}, {dt}" ) + + accepted_tol = 1.0 + 1e-5 + if interpolation == BICUBIC: + # this overall mean value to make the tests pass + # High value is mostly required for test cases with + # downsampling and upsampling where we can not exactly + # match PIL implementation. + accepted_tol = 15.0 + tester.approxEqualTensorToPIL( - resized_tensor_f, resized_pil_img, tol=1.0 + 1e-5, agg_method="max", + resized_tensor_f, resized_pil_img, tol=accepted_tol, agg_method="max", msg=f"{size}, {interpolation}, {dt}" ) diff --git a/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp b/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp index 62fec046850..97b025aafb4 100644 --- a/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp +++ b/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp @@ -141,66 +141,7 @@ void ti_cpu_upsample_generic_aa( // Helper structs to use with ti_upsample_generic_Nd_kernel_impl template struct HelperInterpBase { - static inline void init_indices_weights( - std::vector& output, - int64_t output_size, - int64_t ndims, - int64_t reshape_dim, - int interp_size) { - auto new_shape = std::vector(ndims, 1); - new_shape[reshape_dim] = output_size; - - for (int j = 0; j < interp_size; j++) { - output.emplace_back( - empty(new_shape, CPU(c10::CppTypeToScalarType()))); - output.emplace_back( - empty(new_shape, CPU(c10::CppTypeToScalarType()))); - } - } -}; - -template -struct HelperInterpLinear : public HelperInterpBase { - static const int interp_size = 2; - - static inline std::vector compute_indices_weights( - int64_t input_size, - int64_t output_size, - int64_t stride, - int64_t ndims, - int64_t reshape_dim, - bool align_corners, - const c10::optional opt_scale, - bool antialias, - int& out_interp_size) { - scalar_t scale = area_pixel_compute_scale( - input_size, output_size, align_corners, opt_scale); - TORCH_INTERNAL_ASSERT(antialias); - - return _compute_indices_weights_aa( - input_size, - output_size, - stride, - ndims, - reshape_dim, - align_corners, - scale, - out_interp_size); - } - - // taken from - // https://github.com/python-pillow/Pillow/blob/6812205f18ca4ef54372e87e1a13ce4a859434df/ - // src/libImaging/Resample.c#L20-L29 - static inline scalar_t _filter(scalar_t x) { - if (x < 0.0) { - x = -x; - } - if (x < 1.0) { - return 1.0 - x; - } - return 0.0; - } - + template static inline std::vector _compute_indices_weights_aa( int64_t input_size, int64_t output_size, @@ -209,14 +150,15 @@ struct HelperInterpLinear : public HelperInterpBase { int64_t reshape_dim, bool align_corners, scalar_t scale, - int& out_interp_size) { - int interp_size = HelperInterpLinear::interp_size; + int& in_out_interp_size, + filter_fn_t filter_fn) { + int interp_size = in_out_interp_size; scalar_t support = - (scale >= 1.0) ? (interp_size / 2) * scale : interp_size / 2 * 1.0; + (scale >= 1.0) ? (interp_size * 0.5) * scale : interp_size * 0.5; interp_size = (int)ceilf(support) * 2 + 1; // return interp_size - out_interp_size = interp_size; + in_out_interp_size = interp_size; std::vector output; auto new_shape = std::vector(ndims, 1); @@ -269,7 +211,7 @@ struct HelperInterpLinear : public HelperInterpBase { total_w = 0.0; for (j = 0; j < xmax; j++) { - scalar_t w = _filter((j + xmin - center + 0.5) * invscale); + scalar_t w = filter_fn((j + xmin - center + 0.5) * invscale); wt_ptr[i * interp_size + j] = w; total_w += w; } @@ -287,6 +229,102 @@ struct HelperInterpLinear : public HelperInterpBase { } }; +template +struct HelperInterpLinear : public HelperInterpBase { + static const int interp_size = 2; + + // taken from + // https://github.com/python-pillow/Pillow/blob/6812205f18ca4ef54372e87e1a13ce4a859434df/ + // src/libImaging/Resample.c#L20-L29 + static inline scalar_t _filter(scalar_t x) { + if (x < 0.0) { + x = -x; + } + if (x < 1.0) { + return 1.0 - x; + } + return 0.0; + } + + static inline std::vector compute_indices_weights( + int64_t input_size, + int64_t output_size, + int64_t stride, + int64_t ndims, + int64_t reshape_dim, + bool align_corners, + const c10::optional opt_scale, + bool antialias, + int& out_interp_size) { + TORCH_INTERNAL_ASSERT(antialias); + scalar_t scale = area_pixel_compute_scale( + input_size, output_size, align_corners, opt_scale); + + out_interp_size = HelperInterpLinear::interp_size; + return HelperInterpLinear::_compute_indices_weights_aa( + input_size, + output_size, + stride, + ndims, + reshape_dim, + align_corners, + scale, + out_interp_size, + _filter); + } +}; + +template +struct HelperInterpCubic : public HelperInterpBase { + static const int interp_size = 4; + + static inline std::vector compute_indices_weights( + int64_t input_size, + int64_t output_size, + int64_t stride, + int64_t ndims, + int64_t reshape_dim, + bool align_corners, + const c10::optional opt_scale, + bool antialias, + int& out_interp_size) { + TORCH_INTERNAL_ASSERT(antialias); + scalar_t scale = area_pixel_compute_scale( + input_size, output_size, align_corners, opt_scale); + + out_interp_size = HelperInterpCubic::interp_size; + return HelperInterpCubic::_compute_indices_weights_aa( + input_size, + output_size, + stride, + ndims, + reshape_dim, + align_corners, + scale, + out_interp_size, + _filter); + } + + // taken from + // https://github.com/python-pillow/Pillow/blob/6812205f18ca4ef54372e87e1a13ce4a859434df/ + // src/libImaging/Resample.c#L46-L62 + static inline scalar_t _filter(scalar_t x) { + // https://en.wikipedia.org/wiki/Bicubic_interpolation#Bicubic_convolution_algorithm +#define a -0.5 + if (x < 0.0) { + x = -x; + } + if (x < 1.0) { + return ((a + 2.0) * x - (a + 3.0)) * x * x + 1; + } + if (x < 2.0) { + return (((x - 5) * x + 8) * x - 4) * a; + } + return 0.0; +#undef a + } +}; + template < typename index_t, int out_ndims, @@ -396,7 +434,7 @@ void ti_separable_upsample_generic_Nd_kernel_impl( index_t, out_ndims, scale_t, - HelperInterpLinear>( + F>( temp_output, temp_input, interp_dim, align_corners, scales, antialias); temp_input = temp_output; } @@ -404,8 +442,7 @@ void ti_separable_upsample_generic_Nd_kernel_impl( index_t, out_ndims, scale_t, - HelperInterpLinear>( - output, temp_input, 2, align_corners, scales, antialias); + F>(output, temp_input, 2, align_corners, scales, antialias); } void _ti_upsample_bilinear2d_kernel_impl( @@ -423,6 +460,21 @@ void _ti_upsample_bilinear2d_kernel_impl( output, input, align_corners, {scales_h, scales_w}, antialias); } +void _ti_upsample_bicubic2d_kernel_impl( + Tensor& output, + const Tensor& input, + bool align_corners, + c10::optional scales_h, + c10::optional scales_w, + bool antialias) { + ti_separable_upsample_generic_Nd_kernel_impl< + int64_t, + 2, + scale_t, + HelperInterpCubic>( + output, input, align_corners, {scales_h, scales_w}, antialias); +} + } // namespace internal_upsample } // namespace native } // namespace at @@ -463,6 +515,37 @@ at::Tensor interpolate_linear_aa_forward_kernel( return output; } +at::Tensor interpolate_bicubic_aa_forward_kernel( + const at::Tensor& input, + at::IntArrayRef output_size, + bool align_corners) { + TORCH_CHECK(input.device().is_cpu(), "input must be a CPU tensor"); + + c10::optional> scale_factors = {}; + + // Copied from UpSampleBilinear2d.cpp + auto output = at::empty({0}, input.options()); + auto osize = at::native::upsample::compute_output_size( + input.sizes(), output_size, scale_factors); + auto scale_h = at::native::upsample::get_scale_value(scale_factors, 0); + auto scale_w = at::native::upsample::get_scale_value(scale_factors, 1); + auto full_output_size = + at::native::upsample_2d_common_check(input.sizes(), osize); + + // Allow for empty batch size but not other dimensions + TORCH_CHECK( + input.numel() != 0 || + c10::multiply_integers( + input.sizes().begin() + 1, input.sizes().end()), + "Non-empty 4D data tensor expected but got a tensor with sizes ", + input.sizes()); + + output.resize_(full_output_size, input.suggest_memory_format()); + at::native::internal_upsample::_ti_upsample_bicubic2d_kernel_impl( + output, input, align_corners, scale_h, scale_w, /*antialias=*/true); + return output; +} + // TODO: Implement backward function // at::Tensor interpolate_linear_aa_backward_kernel( // const at::Tensor& grad) { @@ -475,6 +558,10 @@ TORCH_LIBRARY_IMPL(torchvision, CPU, m) { m.impl( TORCH_SELECTIVE_NAME("torchvision::_interpolate_linear_aa"), TORCH_FN(interpolate_linear_aa_forward_kernel)); + m.impl( + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bicubic_aa"), + TORCH_FN(interpolate_bicubic_aa_forward_kernel)); + // TODO: Implement backward function // m.impl( // TORCH_SELECTIVE_NAME("torchvision::_interpolate_linear_aa_backward"), diff --git a/torchvision/csrc/ops/interpolate_aa.cpp b/torchvision/csrc/ops/interpolate_aa.cpp index 209cc73cf76..90bc26a1fb5 100644 --- a/torchvision/csrc/ops/interpolate_aa.cpp +++ b/torchvision/csrc/ops/interpolate_aa.cpp @@ -12,11 +12,23 @@ at::Tensor interpolate_linear_aa( { static auto op = c10::Dispatcher::singleton() - .findSchemaOrThrow("torchvision::interpolate_linear_aa", "") + .findSchemaOrThrow("torchvision::_interpolate_linear_aa", "") .typed(); return op.call(input, output_size, align_corners); } +at::Tensor interpolate_bicubic_aa( + const at::Tensor& input, // Input image + at::IntArrayRef output_size, // Output image size + bool align_corners) // The flag to align corners +{ + static auto op = + c10::Dispatcher::singleton() + .findSchemaOrThrow("torchvision::_interpolate_bicubic_aa", "") + .typed(); + return op.call(input, output_size, align_corners); +} + namespace detail { // TODO: Implement backward function @@ -33,6 +45,8 @@ namespace detail { TORCH_LIBRARY_FRAGMENT(torchvision, m) { m.def(TORCH_SELECTIVE_SCHEMA( "torchvision::_interpolate_linear_aa(Tensor input, int[] output_size, bool align_corners) -> Tensor")); + m.def(TORCH_SELECTIVE_SCHEMA( + "torchvision::_interpolate_bicubic_aa(Tensor input, int[] output_size, bool align_corners) -> Tensor")); // TODO: Implement backward function // m.def(TORCH_SELECTIVE_SCHEMA( // "torchvision::_interpolate_linear_aa_backward(Tensor grad, Tensor rois, diff --git a/torchvision/csrc/ops/interpolate_aa.h b/torchvision/csrc/ops/interpolate_aa.h index acadce49392..0a9ffb4b168 100644 --- a/torchvision/csrc/ops/interpolate_aa.h +++ b/torchvision/csrc/ops/interpolate_aa.h @@ -11,6 +11,11 @@ VISION_API at::Tensor _interpolate_linear_aa( at::IntArrayRef output_size, bool align_corners = false); +VISION_API at::Tensor _interpolate_bicubic_aa( + const at::Tensor& input, + at::IntArrayRef output_size, + bool align_corners = false); + namespace detail { // TODO: Implement backward function diff --git a/torchvision/transforms/functional_tensor.py b/torchvision/transforms/functional_tensor.py index e29065e6ec0..7aa63f539cb 100644 --- a/torchvision/transforms/functional_tensor.py +++ b/torchvision/transforms/functional_tensor.py @@ -503,8 +503,8 @@ def resize( if antialias is None: antialias = False - if antialias and interpolation not in ["bilinear", ]: - raise ValueError("Antialias option is supported for bilinear interpolation mode only") + if antialias and interpolation not in ["bilinear", "bicubic"]: + raise ValueError("Antialias option is supported for bilinear and bicubic interpolation modes only") w, h = _get_image_size(img) @@ -537,8 +537,10 @@ def resize( align_corners = False if interpolation in ["bilinear", "bicubic"] else None if antialias: - # Apply antialias for donwsampling on both dims - img = torch.ops.torchvision._interpolate_linear_aa(img, [new_h, new_w], align_corners=False) + if interpolation == "bilinear": + img = torch.ops.torchvision._interpolate_linear_aa(img, [new_h, new_w], align_corners=False) + elif interpolation == "bicubic": + img = torch.ops.torchvision._interpolate_bicubic_aa(img, [new_h, new_w], align_corners=False) else: img = interpolate(img, size=[new_h, new_w], mode=interpolation, align_corners=align_corners) From f5aa5f587c7b583d08d202d33ae1e29df787b2d7 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Thu, 13 May 2021 16:49:48 +0100 Subject: [PATCH 053/279] Added dataset download support in fbcode (#3823) (#3826) Summary: Pull Request resolved: https://github.com/pytorch/vision/pull/3823 Uploaded FashionMNIST dataset to [manifold](https://www.internalfb.com/intern/network/manifold/?bucket=torchvision&path=tree%2Fdatasets) bucket `torchvision`. Any new dataset that needs to be added could be uploaded under `tree/datasets/`. Reviewed By: datumbox Differential Revision: D28358470 fbshipit-source-id: 6f2282d3f1ce4b1416e962de8fb132896d4b2d76 --- torchvision/datasets/_utils.py | 6 +++++ torchvision/datasets/utils.py | 43 ++++++++++++++++++++-------------- 2 files changed, 32 insertions(+), 17 deletions(-) create mode 100644 torchvision/datasets/_utils.py diff --git a/torchvision/datasets/_utils.py b/torchvision/datasets/_utils.py new file mode 100644 index 00000000000..d0664d50d54 --- /dev/null +++ b/torchvision/datasets/_utils.py @@ -0,0 +1,6 @@ +def _download_file_from_remote_location(fpath: str) -> None: + pass + + +def _is_remote_location_available() -> bool: + return False diff --git a/torchvision/datasets/utils.py b/torchvision/datasets/utils.py index 0d1d879f045..36d6f8e657e 100644 --- a/torchvision/datasets/utils.py +++ b/torchvision/datasets/utils.py @@ -17,6 +17,11 @@ import torch from torch.utils.model_zoo import tqdm +from ._utils import ( + _download_file_from_remote_location, + _is_remote_location_available, +) + USER_AGENT = "pytorch/vision" @@ -117,26 +122,30 @@ def download_url( print('Using downloaded and verified file: ' + fpath) return - # expand redirect chain if needed - url = _get_redirect_url(url, max_hops=max_redirect_hops) + if _is_remote_location_available(): + _download_file_from_remote_location(fpath) + else: + # expand redirect chain if needed + url = _get_redirect_url(url, max_hops=max_redirect_hops) - # check if file is located on Google Drive - file_id = _get_google_drive_file_id(url) - if file_id is not None: - return download_file_from_google_drive(file_id, root, filename, md5) + # check if file is located on Google Drive + file_id = _get_google_drive_file_id(url) + if file_id is not None: + return download_file_from_google_drive(file_id, root, filename, md5) - # download the file - try: - print('Downloading ' + url + ' to ' + fpath) - _urlretrieve(url, fpath) - except (urllib.error.URLError, IOError) as e: # type: ignore[attr-defined] - if url[:5] == 'https': - url = url.replace('https:', 'http:') - print('Failed download. Trying https -> http instead.' - ' Downloading ' + url + ' to ' + fpath) + # download the file + try: + print('Downloading ' + url + ' to ' + fpath) _urlretrieve(url, fpath) - else: - raise e + except (urllib.error.URLError, IOError) as e: # type: ignore[attr-defined] + if url[:5] == 'https': + url = url.replace('https:', 'http:') + print('Failed download. Trying https -> http instead.' + ' Downloading ' + url + ' to ' + fpath) + _urlretrieve(url, fpath) + else: + raise e + # check integrity of downloaded file if not check_integrity(fpath, md5): raise RuntimeError("File not found or corrupted.") From b94a4014a68d08f37697f4672729571a46f0042d Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Thu, 13 May 2021 18:59:57 +0000 Subject: [PATCH 054/279] Making protected params of MobileNetV3 public (#3828) * Converting private parameters to public. * Add kwargs to handle extra params. * Add another kwargs. * Add arguments in _mobilenet_extractor. --- torchvision/models/detection/ssdlite.py | 8 +++----- torchvision/models/mobilenetv3.py | 16 ++++++++-------- torchvision/models/quantization/mobilenetv3.py | 2 +- torchvision/models/segmentation/segmentation.py | 4 ++-- 4 files changed, 14 insertions(+), 16 deletions(-) diff --git a/torchvision/models/detection/ssdlite.py b/torchvision/models/detection/ssdlite.py index 8498a78d6dd..dcab863feb1 100644 --- a/torchvision/models/detection/ssdlite.py +++ b/torchvision/models/detection/ssdlite.py @@ -95,11 +95,9 @@ def __init__(self, in_channels: List[int], num_anchors: List[int], norm_layer: C class SSDLiteFeatureExtractorMobileNet(nn.Module): - def __init__(self, backbone: nn.Module, c4_pos: int, norm_layer: Callable[..., nn.Module], **kwargs: Any): + def __init__(self, backbone: nn.Module, c4_pos: int, norm_layer: Callable[..., nn.Module], width_mult: float = 1.0, + min_depth: int = 16, **kwargs: Any): super().__init__() - # non-public config parameters - min_depth = kwargs.pop('_min_depth', 16) - width_mult = kwargs.pop('_width_mult', 1.0) assert not backbone[c4_pos].use_res_connect self.features = nn.Sequential( @@ -197,7 +195,7 @@ def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = Tru norm_layer = partial(nn.BatchNorm2d, eps=0.001, momentum=0.03) backbone = _mobilenet_extractor("mobilenet_v3_large", progress, pretrained_backbone, trainable_backbone_layers, - norm_layer, _reduced_tail=reduce_tail, _width_mult=1.0) + norm_layer, reduced_tail=reduce_tail, **kwargs) size = (320, 320) anchor_generator = DefaultBoxGenerator([[2, 3] for _ in range(6)], min_ratio=0.2, max_ratio=0.95) diff --git a/torchvision/models/mobilenetv3.py b/torchvision/models/mobilenetv3.py index 1e2606daa42..890fd30d07d 100644 --- a/torchvision/models/mobilenetv3.py +++ b/torchvision/models/mobilenetv3.py @@ -106,7 +106,8 @@ def __init__( last_channel: int, num_classes: int = 1000, block: Optional[Callable[..., nn.Module]] = None, - norm_layer: Optional[Callable[..., nn.Module]] = None + norm_layer: Optional[Callable[..., nn.Module]] = None, + **kwargs: Any ) -> None: """ MobileNet V3 main class @@ -184,11 +185,10 @@ def forward(self, x: Tensor) -> Tensor: return self._forward_impl(x) -def _mobilenet_v3_conf(arch: str, params: Dict[str, Any]): - # non-public config parameters - reduce_divider = 2 if params.pop('_reduced_tail', False) else 1 - dilation = 2 if params.pop('_dilated', False) else 1 - width_mult = params.pop('_width_mult', 1.0) +def _mobilenet_v3_conf(arch: str, width_mult: float = 1.0, reduced_tail: bool = False, dilated: bool = False, + **kwargs: Any): + reduce_divider = 2 if reduced_tail else 1 + dilation = 2 if dilated else 1 bneck_conf = partial(InvertedResidualConfig, width_mult=width_mult) adjust_channels = partial(InvertedResidualConfig.adjust_channels, width_mult=width_mult) @@ -260,7 +260,7 @@ def mobilenet_v3_large(pretrained: bool = False, progress: bool = True, **kwargs progress (bool): If True, displays a progress bar of the download to stderr """ arch = "mobilenet_v3_large" - inverted_residual_setting, last_channel = _mobilenet_v3_conf(arch, kwargs) + inverted_residual_setting, last_channel = _mobilenet_v3_conf(arch, **kwargs) return _mobilenet_v3_model(arch, inverted_residual_setting, last_channel, pretrained, progress, **kwargs) @@ -274,5 +274,5 @@ def mobilenet_v3_small(pretrained: bool = False, progress: bool = True, **kwargs progress (bool): If True, displays a progress bar of the download to stderr """ arch = "mobilenet_v3_small" - inverted_residual_setting, last_channel = _mobilenet_v3_conf(arch, kwargs) + inverted_residual_setting, last_channel = _mobilenet_v3_conf(arch, **kwargs) return _mobilenet_v3_model(arch, inverted_residual_setting, last_channel, pretrained, progress, **kwargs) diff --git a/torchvision/models/quantization/mobilenetv3.py b/torchvision/models/quantization/mobilenetv3.py index a980e605e65..fe434f8b297 100644 --- a/torchvision/models/quantization/mobilenetv3.py +++ b/torchvision/models/quantization/mobilenetv3.py @@ -127,5 +127,5 @@ def mobilenet_v3_large(pretrained=False, progress=True, quantize=False, **kwargs quantize (bool): If True, returns a quantized model, else returns a float model """ arch = "mobilenet_v3_large" - inverted_residual_setting, last_channel = _mobilenet_v3_conf(arch, kwargs) + inverted_residual_setting, last_channel = _mobilenet_v3_conf(arch, **kwargs) return _mobilenet_v3_model(arch, inverted_residual_setting, last_channel, pretrained, progress, quantize, **kwargs) diff --git a/torchvision/models/segmentation/segmentation.py b/torchvision/models/segmentation/segmentation.py index f7a4a807185..4f328974543 100644 --- a/torchvision/models/segmentation/segmentation.py +++ b/torchvision/models/segmentation/segmentation.py @@ -32,7 +32,7 @@ def _segm_model(name, backbone_name, num_classes, aux, pretrained_backbone=True) aux_layer = 'layer3' aux_inplanes = 1024 elif 'mobilenet_v3' in backbone_name: - backbone = mobilenetv3.__dict__[backbone_name](pretrained=pretrained_backbone, _dilated=True).features + backbone = mobilenetv3.__dict__[backbone_name](pretrained=pretrained_backbone, dilated=True).features # Gather the indices of blocks which are strided. These are the locations of C1, ..., Cn-1 blocks. # The first and last blocks are always included because they are the C0 (conv1) and Cn. @@ -87,7 +87,7 @@ def _load_weights(model, arch_type, backbone, progress): def _segm_lraspp_mobilenetv3(backbone_name, num_classes, pretrained_backbone=True): - backbone = mobilenetv3.__dict__[backbone_name](pretrained=pretrained_backbone, _dilated=True).features + backbone = mobilenetv3.__dict__[backbone_name](pretrained=pretrained_backbone, dilated=True).features # Gather the indices of blocks which are strided. These are the locations of C1, ..., Cn-1 blocks. # The first and last blocks are always included because they are the C0 (conv1) and Cn. From 3193b73417713a4690e41e76490099f701030aa8 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 14 May 2021 10:59:22 +0100 Subject: [PATCH 055/279] Added Makefile rule to not build the examples (#3834) --- .gitignore | 5 +++++ CONTRIBUTING.md | 18 ++++++++++++++++++ docs/Makefile | 11 ++++++++--- 3 files changed, 31 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index ed35abaa478..3a1e8b6232a 100644 --- a/.gitignore +++ b/.gitignore @@ -9,9 +9,14 @@ torchvision/version.py */**/**/*.pyc */**/*~ *~ + docs/build +# sphinx-gallery docs/source/auto_examples/ docs/source/gen_modules/ +# pytorch-sphinx-theme gets installed here +docs/src + .coverage htmlcov .*.swp diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 14161dfbd81..71dde22c6a6 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -129,6 +129,24 @@ The docs are also automatically built when you submit a PR. The job that builds the docs is named `build_docs`. You can access the rendered docs by clicking on that job and then going to the "Artifacts" tab. +You can clean the built docs and re-start the build from scratch by doing ``make +clean``. + +#### Building the example gallery - or not + +When you run ``make html`` for the first time, all the examples in the gallery +will be built. Subsequent builds should be faster, and will only build the +examples that have been modified. + +You can run ``make html-noplot`` to not build the examples at all. This is +useful after a ``make clean`` to do some quick checks that are not related to +the examples. + +You can also choose to only build a subset of the examples by using the +``EXAMPLES_PATTERN`` env variable, which accepts a regular expression. For +example ``EXAMPLES_PATTERN="transforms" make html`` will only build the examples +with "transforms" in their name. + ### New model More details on how to add a new model will be provided later. Please, do not send any PR with a new model without discussing diff --git a/docs/Makefile b/docs/Makefile index de809ed81cb..0488c3db88f 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -1,8 +1,12 @@ # Minimal makefile for Sphinx documentation # +ifneq ($(EXAMPLES_PATTERN),) + EXAMPLES_PATTERN_OPTS := -D sphinx_gallery_conf.filename_pattern="$(EXAMPLES_PATTERN)" +endif + # You can set these variables from the command line. -SPHINXOPTS = -W # turn warnings into errors +SPHINXOPTS = -W -j auto $(EXAMPLES_PATTERN_OPTS) SPHINXBUILD = sphinx-build SPHINXPROJ = torchvision SOURCEDIR = source @@ -20,13 +24,14 @@ docset: html convert $(SPHINXPROJ).docset/icon@2x.png -resize 16x16 $(SPHINXPROJ).docset/icon.png html-noplot: # Avoids running the gallery examples, which may take time - $(SPHINXBUILD) -D plot_gallery=0 -b html $(ASPHINXOPTS) "$(BUILDDIR)"/html + $(SPHINXBUILD) -D plot_gallery=0 -b html $(ASPHINXOPTS) "${SOURCEDIR}" "$(BUILDDIR)"/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." clean: rm -rf $(BUILDDIR)/* - rm -rf $(SOURCEDIR)/auto_examples/ + rm -rf $(SOURCEDIR)/auto_examples/ # sphinx-gallery + rm -rf $(SOURCEDIR)/gen_modules/ # sphinx-gallery .PHONY: help Makefile docset From f1d734213af65dc06e777877d315973ba8386080 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Sat, 15 May 2021 09:58:32 +0100 Subject: [PATCH 056/279] remove old css file (#3839) --- docs/source/_static/css/pytorch_theme.css | 118 ---------------------- docs/source/conf.py | 9 -- 2 files changed, 127 deletions(-) delete mode 100644 docs/source/_static/css/pytorch_theme.css diff --git a/docs/source/_static/css/pytorch_theme.css b/docs/source/_static/css/pytorch_theme.css deleted file mode 100644 index 0e54497643c..00000000000 --- a/docs/source/_static/css/pytorch_theme.css +++ /dev/null @@ -1,118 +0,0 @@ -body { - font-family: "Lato","proxima-nova","Helvetica Neue",Arial,sans-serif; -} - -/* Default header fonts are ugly */ -h1, h2, .rst-content .toctree-wrapper p.caption, h3, h4, h5, h6, legend, p.caption { - font-family: "Lato","proxima-nova","Helvetica Neue",Arial,sans-serif; -} - -/* Use white for docs background */ -.wy-side-nav-search { - background-color: #fff; -} - -.wy-nav-content-wrap, .wy-menu li.current > a { - background-color: #fff; -} - -@media screen and (min-width: 1400px) { - .wy-nav-content-wrap { - background-color: rgba(0, 0, 0, 0.0470588); - } - - .wy-nav-content { - background-color: #fff; - } -} - -/* Fixes for mobile */ -.wy-nav-top { - background-color: #fff; - background-image: url('../img/pytorch-logo-dark.svg'); - background-repeat: no-repeat; - background-position: center; - padding: 0; - margin: 0.4045em 0.809em; - color: #333; -} - -.wy-nav-top > a { - display: none; -} - -@media screen and (max-width: 768px) { - .wy-side-nav-search>a img.logo { - height: 60px; - } -} - -/* This is needed to ensure that logo above search scales properly */ -.wy-side-nav-search a { - display: block; -} - -/* This ensures that multiple constructors will remain in separate lines. */ -.rst-content dl:not(.docutils) dt { - display: table; -} - -/* Use our red for literals (it's very similar to the original color) */ -.rst-content tt.literal, .rst-content tt.literal, .rst-content code.literal { - color: #F05732; -} - -.rst-content tt.xref, a .rst-content tt, .rst-content tt.xref, -.rst-content code.xref, a .rst-content tt, a .rst-content code { - color: #404040; -} - -/* Change link colors (except for the menu) */ - -a { - color: #F05732; -} - -a:hover { - color: #F05732; -} - - -a:visited { - color: #D44D2C; -} - -.wy-menu a { - color: #b3b3b3; -} - -.wy-menu a:hover { - color: #b3b3b3; -} - -/* Default footer text is quite big */ -footer { - font-size: 80%; -} - -footer .rst-footer-buttons { - font-size: 125%; /* revert footer settings - 1/80% = 125% */ -} - -footer p { - font-size: 100%; -} - -/* For hidden headers that appear in TOC tree */ -/* see http://stackoverflow.com/a/32363545/3343043 */ -.rst-content .hidden-section { - display: none; -} - -nav .hidden-section { - display: inherit; -} - -.wy-side-nav-search>div.version { - color: #000; -} diff --git a/docs/source/conf.py b/docs/source/conf.py index 639c877fc9f..e1b7ff2b3a5 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -137,15 +137,6 @@ # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] -# html_style_path = 'css/pytorch_theme.css' -# html_context = { -# 'css_files': [ -# 'https://fonts.googleapis.com/css?family=Lato', -# '_static/css/pytorch_theme.css' -# ], -# } - - # -- Options for HTMLHelp output ------------------------------------------ # Output file base name for HTML help builder. From 3a96fb57dd868c413befc4f60bad3d2effebdef7 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 17 May 2021 07:58:00 +0100 Subject: [PATCH 057/279] Show links to notebooks in sphinx-gallery examples (#3838) --- docs/source/_static/css/custom_torchvision.css | 12 ++++++++++++ docs/source/conf.py | 5 +++++ 2 files changed, 17 insertions(+) create mode 100644 docs/source/_static/css/custom_torchvision.css diff --git a/docs/source/_static/css/custom_torchvision.css b/docs/source/_static/css/custom_torchvision.css new file mode 100644 index 00000000000..fb039a47c0a --- /dev/null +++ b/docs/source/_static/css/custom_torchvision.css @@ -0,0 +1,12 @@ +/* This rule (and possibly this entire file) should be removed once +https://github.com/pytorch/pytorch_sphinx_theme/issues/125 is fixed. + +We override the rule so that the links to the notebooks aren't hidden in the +gallery examples. pytorch_sphinx_theme is supposed to customize those links so +that they render nicely (look at the nice links on top of the tutorials +examples) but it doesn't work for repos that are not the tutorial repo, and in +torchvision it just hides the links. So we have to put them back here */ +article.pytorch-article .sphx-glr-download-link-note.admonition.note, +article.pytorch-article .reference.download.internal, article.pytorch-article .sphx-glr-signature { + display: block; +} \ No newline at end of file diff --git a/docs/source/conf.py b/docs/source/conf.py index e1b7ff2b3a5..7345f5eef86 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -137,6 +137,11 @@ # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] +# TODO: remove this once https://github.com/pytorch/pytorch_sphinx_theme/issues/125 is fixed +html_css_files = [ + 'css/custom_torchvision.css', +] + # -- Options for HTMLHelp output ------------------------------------------ # Output file base name for HTML help builder. From 0fece1f70b1d1d43a3a6553fc05b32c70c397304 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 17 May 2021 08:45:55 +0100 Subject: [PATCH 058/279] Add cross-PR caching within CircleCI for gallery examples (#3837) --- .circleci/config.yml | 15 +++++++++++++++ .circleci/config.yml.in | 15 +++++++++++++++ 2 files changed, 30 insertions(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index 5d9794a53b0..0f3e06634a1 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -916,6 +916,15 @@ jobs: - run: name: Install torchvision command: .circleci/unittest/linux/scripts/install.sh + - run: + name: Generate cache key + # This will refresh cache on Sundays, nightly build should generate new cache. + command: echo "$(date +"%Y-%U")" > .circleci-weekly + - restore_cache: + + keys: + - sphinx-gallery-{{ checksum "./docs/source/conf.py" }}-{{ checksum ".circleci-weekly" }} + - run: name: Build docs command: | @@ -928,6 +937,12 @@ jobs: pip install -r requirements.txt make html popd + - save_cache: + + key: sphinx-gallery-{{ checksum "./docs/source/conf.py" }}-{{ checksum ".circleci-weekly" }} + + paths: + - ./docs/source/auto_examples - persist_to_workspace: root: ./ paths: diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 6ef1372e184..3471b776a2f 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -916,6 +916,15 @@ jobs: - run: name: Install torchvision command: .circleci/unittest/linux/scripts/install.sh + - run: + name: Generate cache key + # This will refresh cache on Sundays, nightly build should generate new cache. + command: echo "$(date +"%Y-%U")" > .circleci-weekly + - restore_cache: + {% raw %} + keys: + - sphinx-gallery-{{ checksum "./docs/source/conf.py" }}-{{ checksum ".circleci-weekly" }} + {% endraw %} - run: name: Build docs command: | @@ -928,6 +937,12 @@ jobs: pip install -r requirements.txt make html popd + - save_cache: + {% raw %} + key: sphinx-gallery-{{ checksum "./docs/source/conf.py" }}-{{ checksum ".circleci-weekly" }} + {% endraw %} + paths: + - ./docs/source/auto_examples - persist_to_workspace: root: ./ paths: From 32bccc53cd442e59904a001d269acda2c4357f34 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 17 May 2021 10:13:05 +0100 Subject: [PATCH 059/279] Port _test_adjust_fn to pytest (#3845) --- test/test_functional_tensor.py | 364 +++++++++++++++++++-------------- 1 file changed, 214 insertions(+), 150 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 6d9b20870e5..6fa455f6a6b 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -324,85 +324,6 @@ def test_pad(self): self._test_fn_on_batch(batch_tensors, F.pad, padding=script_pad, **kwargs) - def _test_adjust_fn(self, fn, fn_pil, fn_t, configs, tol=2.0 + 1e-10, agg_method="max", - dts=(None, torch.float32, torch.float64)): - script_fn = torch.jit.script(fn) - torch.manual_seed(15) - tensor, pil_img = self._create_data(26, 34, device=self.device) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) - - for dt in dts: - - if dt is not None: - tensor = F.convert_image_dtype(tensor, dt) - batch_tensors = F.convert_image_dtype(batch_tensors, dt) - - for config in configs: - adjusted_tensor = fn_t(tensor, **config) - adjusted_pil = fn_pil(pil_img, **config) - scripted_result = script_fn(tensor, **config) - msg = "{}, {}".format(dt, config) - self.assertEqual(adjusted_tensor.dtype, scripted_result.dtype, msg=msg) - self.assertEqual(adjusted_tensor.size()[1:], adjusted_pil.size[::-1], msg=msg) - - rbg_tensor = adjusted_tensor - - if adjusted_tensor.dtype != torch.uint8: - rbg_tensor = F.convert_image_dtype(adjusted_tensor, torch.uint8) - - # Check that max difference does not exceed 2 in [0, 255] range - # Exact matching is not possible due to incompatibility convert_image_dtype and PIL results - self.approxEqualTensorToPIL(rbg_tensor.float(), adjusted_pil, tol=tol, msg=msg, agg_method=agg_method) - - atol = 1e-6 - if adjusted_tensor.dtype == torch.uint8 and "cuda" in torch.device(self.device).type: - atol = 1.0 - self.assertTrue(adjusted_tensor.allclose(scripted_result, atol=atol), msg=msg) - - self._test_fn_on_batch(batch_tensors, fn, scripted_fn_atol=atol, **config) - - def test_adjust_brightness(self): - self._test_adjust_fn( - F.adjust_brightness, - F_pil.adjust_brightness, - F_t.adjust_brightness, - [{"brightness_factor": f} for f in [0.1, 0.5, 1.0, 1.34, 2.5]] - ) - - def test_adjust_contrast(self): - self._test_adjust_fn( - F.adjust_contrast, - F_pil.adjust_contrast, - F_t.adjust_contrast, - [{"contrast_factor": f} for f in [0.2, 0.5, 1.0, 1.5, 2.0]] - ) - - def test_adjust_saturation(self): - self._test_adjust_fn( - F.adjust_saturation, - F_pil.adjust_saturation, - F_t.adjust_saturation, - [{"saturation_factor": f} for f in [0.5, 0.75, 1.0, 1.5, 2.0]] - ) - - def test_adjust_hue(self): - self._test_adjust_fn( - F.adjust_hue, - F_pil.adjust_hue, - F_t.adjust_hue, - [{"hue_factor": f} for f in [-0.45, -0.25, 0.0, 0.25, 0.45]], - tol=16.1, - agg_method="max" - ) - - def test_adjust_gamma(self): - self._test_adjust_fn( - F.adjust_gamma, - F_pil.adjust_gamma, - F_t.adjust_gamma, - [{"gamma": g1, "gain": g2} for g1, g2 in zip([0.8, 1.0, 1.2], [0.7, 1.0, 1.3])] - ) - def test_resize(self): script_fn = torch.jit.script(F.resize) tensor, pil_img = self._create_data(26, 36, device=self.device) @@ -833,77 +754,6 @@ def test_gaussian_blur(self): msg="{}, {}".format(ksize, sigma) ) - def test_invert(self): - self._test_adjust_fn( - F.invert, - F_pil.invert, - F_t.invert, - [{}], - tol=1.0, - agg_method="max" - ) - - def test_posterize(self): - self._test_adjust_fn( - F.posterize, - F_pil.posterize, - F_t.posterize, - [{"bits": bits} for bits in range(0, 8)], - tol=1.0, - agg_method="max", - dts=(None,) - ) - - def test_solarize(self): - self._test_adjust_fn( - F.solarize, - F_pil.solarize, - F_t.solarize, - [{"threshold": threshold} for threshold in [0, 64, 128, 192, 255]], - tol=1.0, - agg_method="max", - dts=(None,) - ) - self._test_adjust_fn( - F.solarize, - lambda img, threshold: F_pil.solarize(img, 255 * threshold), - F_t.solarize, - [{"threshold": threshold} for threshold in [0.0, 0.25, 0.5, 0.75, 1.0]], - tol=1.0, - agg_method="max", - dts=(torch.float32, torch.float64) - ) - - def test_adjust_sharpness(self): - self._test_adjust_fn( - F.adjust_sharpness, - F_pil.adjust_sharpness, - F_t.adjust_sharpness, - [{"sharpness_factor": f} for f in [0.2, 0.5, 1.0, 1.5, 2.0]] - ) - - def test_autocontrast(self): - self._test_adjust_fn( - F.autocontrast, - F_pil.autocontrast, - F_t.autocontrast, - [{}], - tol=1.0, - agg_method="max" - ) - - def test_equalize(self): - torch.set_deterministic(False) - self._test_adjust_fn( - F.equalize, - F_pil.equalize, - F_t.equalize, - [{}], - tol=1.0, - agg_method="max", - dts=(None,) - ) - @unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device") class CUDATester(Tester): @@ -1074,5 +924,219 @@ def test_resize_antialias(device, dt, size, interpolation, tester): tester.assertTrue(resized_tensor.equal(resize_result), msg=f"{size}, {interpolation}, {dt}") +def check_functional_vs_PIL_vs_scripted(fn, fn_pil, fn_t, config, device, dtype, tol=2.0 + 1e-10, agg_method="max"): + + tester = Tester() + + script_fn = torch.jit.script(fn) + torch.manual_seed(15) + tensor, pil_img = tester._create_data(26, 34, device=device) + batch_tensors = tester._create_data_batch(16, 18, num_samples=4, device=device) + + if dtype is not None: + tensor = F.convert_image_dtype(tensor, dtype) + batch_tensors = F.convert_image_dtype(batch_tensors, dtype) + + out_fn_t = fn_t(tensor, **config) + out_pil = fn_pil(pil_img, **config) + out_scripted = script_fn(tensor, **config) + assert out_fn_t.dtype == out_scripted.dtype + assert out_fn_t.size()[1:] == out_pil.size[::-1] + + rbg_tensor = out_fn_t + + if out_fn_t.dtype != torch.uint8: + rbg_tensor = F.convert_image_dtype(out_fn_t, torch.uint8) + + # Check that max difference does not exceed 2 in [0, 255] range + # Exact matching is not possible due to incompatibility convert_image_dtype and PIL results + tester.approxEqualTensorToPIL(rbg_tensor.float(), out_pil, tol=tol, agg_method=agg_method) + + atol = 1e-6 + if out_fn_t.dtype == torch.uint8 and "cuda" in torch.device(device).type: + atol = 1.0 + assert out_fn_t.allclose(out_scripted, atol=atol) + + # FIXME: fn will be scripted again in _test_fn_on_batch. We could avoid that. + tester._test_fn_on_batch(batch_tensors, fn, scripted_fn_atol=atol, **config) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dtype', (None, torch.float32, torch.float64)) +@pytest.mark.parametrize('config', [{"brightness_factor": f} for f in (0.1, 0.5, 1.0, 1.34, 2.5)]) +def test_adjust_brightness(device, dtype, config): + check_functional_vs_PIL_vs_scripted( + F.adjust_brightness, + F_pil.adjust_brightness, + F_t.adjust_brightness, + config, + device, + dtype, + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dtype', (None, torch.float32, torch.float64)) +def test_invert(device, dtype): + check_functional_vs_PIL_vs_scripted( + F.invert, + F_pil.invert, + F_t.invert, + {}, + device, + dtype, + tol=1.0, + agg_method="max" + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('config', [{"bits": bits} for bits in range(0, 8)]) +def test_posterize(device, config): + check_functional_vs_PIL_vs_scripted( + F.posterize, + F_pil.posterize, + F_t.posterize, + config, + device, + dtype=None, + tol=1.0, + agg_method="max", + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('config', [{"threshold": threshold} for threshold in [0, 64, 128, 192, 255]]) +def test_solarize1(device, config): + check_functional_vs_PIL_vs_scripted( + F.solarize, + F_pil.solarize, + F_t.solarize, + config, + device, + dtype=None, + tol=1.0, + agg_method="max", + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dtype', (torch.float32, torch.float64)) +@pytest.mark.parametrize('config', [{"threshold": threshold} for threshold in [0.0, 0.25, 0.5, 0.75, 1.0]]) +def test_solarize2(device, dtype, config): + check_functional_vs_PIL_vs_scripted( + F.solarize, + lambda img, threshold: F_pil.solarize(img, 255 * threshold), + F_t.solarize, + config, + device, + dtype, + tol=1.0, + agg_method="max", + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dtype', (None, torch.float32, torch.float64)) +@pytest.mark.parametrize('config', [{"sharpness_factor": f} for f in [0.2, 0.5, 1.0, 1.5, 2.0]]) +def test_adjust_sharpness(device, dtype, config): + check_functional_vs_PIL_vs_scripted( + F.adjust_sharpness, + F_pil.adjust_sharpness, + F_t.adjust_sharpness, + config, + device, + dtype, + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dtype', (None, torch.float32, torch.float64)) +def test_autocontrast(device, dtype): + check_functional_vs_PIL_vs_scripted( + F.autocontrast, + F_pil.autocontrast, + F_t.autocontrast, + {}, + device, + dtype, + tol=1.0, + agg_method="max" + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_equalize(device): + torch.set_deterministic(False) + check_functional_vs_PIL_vs_scripted( + F.equalize, + F_pil.equalize, + F_t.equalize, + {}, + device, + dtype=None, + tol=1.0, + agg_method="max", + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dtype', (None, torch.float32, torch.float64)) +@pytest.mark.parametrize('config', [{"contrast_factor": f} for f in [0.2, 0.5, 1.0, 1.5, 2.0]]) +def test_adjust_contrast(device, dtype, config): + check_functional_vs_PIL_vs_scripted( + F.adjust_contrast, + F_pil.adjust_contrast, + F_t.adjust_contrast, + config, + device, + dtype + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dtype', (None, torch.float32, torch.float64)) +@pytest.mark.parametrize('config', [{"saturation_factor": f} for f in [0.5, 0.75, 1.0, 1.5, 2.0]]) +def test_adjust_saturation(device, dtype, config): + check_functional_vs_PIL_vs_scripted( + F.adjust_saturation, + F_pil.adjust_saturation, + F_t.adjust_saturation, + config, + device, + dtype + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dtype', (None, torch.float32, torch.float64)) +@pytest.mark.parametrize('config', [{"hue_factor": f} for f in [-0.45, -0.25, 0.0, 0.25, 0.45]]) +def test_adjust_hue(device, dtype, config): + check_functional_vs_PIL_vs_scripted( + F.adjust_hue, + F_pil.adjust_hue, + F_t.adjust_hue, + config, + device, + dtype, + tol=16.1, + agg_method="max" + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dtype', (None, torch.float32, torch.float64)) +@pytest.mark.parametrize('config', [{"gamma": g1, "gain": g2} for g1, g2 in zip([0.8, 1.0, 1.2], [0.7, 1.0, 1.3])]) +def test_adjust_gamma(device, dtype, config): + check_functional_vs_PIL_vs_scripted( + F.adjust_gamma, + F_pil.adjust_gamma, + F_t.adjust_gamma, + config, + device, + dtype, + ) + + if __name__ == '__main__': unittest.main() From 5bb997c6173e016438c765c8190c0747d472e1f6 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 17 May 2021 12:33:25 +0100 Subject: [PATCH 060/279] Rewrite draw_segmentation_masks and update gallery example to illustrate both instance and semantic segmentation models (#3824) --- gallery/plot_visualization_utils.py | 269 ++++++++++++++++-- .../fakedata/draw_segm_masks_colors_util.png | Bin 88 -> 0 bytes .../draw_segm_masks_no_colors_util.png | Bin 106 -> 0 bytes test/test_utils.py | 132 +++++---- torchvision/utils.py | 77 +++-- 5 files changed, 376 insertions(+), 102 deletions(-) delete mode 100644 test/assets/fakedata/draw_segm_masks_colors_util.png delete mode 100644 test/assets/fakedata/draw_segm_masks_no_colors_util.png diff --git a/gallery/plot_visualization_utils.py b/gallery/plot_visualization_utils.py index 58788437a28..04c5e3dcb53 100644 --- a/gallery/plot_visualization_utils.py +++ b/gallery/plot_visualization_utils.py @@ -24,7 +24,8 @@ def show(imgs): imgs = [imgs] fix, axs = plt.subplots(ncols=len(imgs), squeeze=False) for i, img in enumerate(imgs): - img = F.to_pil_image(img.to('cpu')) + img = img.detach() + img = F.to_pil_image(img) axs[0, i].imshow(np.asarray(img)) axs[0, i].set(xticklabels=[], yticklabels=[], xticks=[], yticks=[]) @@ -50,9 +51,8 @@ def show(imgs): # Visualizing bounding boxes # -------------------------- # We can use :func:`~torchvision.utils.draw_bounding_boxes` to draw boxes on an -# image. We can set the colors, labels, width as well as font and font size ! -# The boxes are in ``(xmin, ymin, xmax, ymax)`` format -# from torchvision.utils import draw_bounding_boxes +# image. We can set the colors, labels, width as well as font and font size. +# The boxes are in ``(xmin, ymin, xmax, ymax)`` format. from torchvision.utils import draw_bounding_boxes @@ -74,9 +74,8 @@ def show(imgs): from torchvision.transforms.functional import convert_image_dtype -dog1_float = convert_image_dtype(dog1_int, dtype=torch.float) -dog2_float = convert_image_dtype(dog2_int, dtype=torch.float) -batch = torch.stack([dog1_float, dog2_float]) +batch_int = torch.stack([dog1_int, dog2_int]) +batch = convert_image_dtype(batch_int, dtype=torch.float) model = fasterrcnn_resnet50_fpn(pretrained=True, progress=False) model = model.eval() @@ -91,7 +90,7 @@ def show(imgs): threshold = .8 dogs_with_boxes = [ draw_bounding_boxes(dog_int, boxes=output['boxes'][output['scores'] > threshold], width=4) - for dog_int, output in zip((dog1_int, dog2_int), outputs) + for dog_int, output in zip(batch_int, outputs) ] show(dogs_with_boxes) @@ -99,33 +98,255 @@ def show(imgs): # Visualizing segmentation masks # ------------------------------ # The :func:`~torchvision.utils.draw_segmentation_masks` function can be used to -# draw segmentation amasks on images. We can set the colors as well as -# transparency of masks. +# draw segmentation masks on images. Semantic segmentation and instance +# segmentation models have different outputs, so we will treat each +# independently. # -# Here is demo with torchvision's FCN Resnet-50, loaded with -# :func:`~torchvision.models.segmentation.fcn_resnet50`. -# You can also try using -# DeepLabv3 (:func:`~torchvision.models.segmentation.deeplabv3_resnet50`) -# or lraspp mobilenet models +# Semantic segmentation models +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +# +# We will see how to use it with torchvision's FCN Resnet-50, loaded with +# :func:`~torchvision.models.segmentation.fcn_resnet50`. You can also try using +# DeepLabv3 (:func:`~torchvision.models.segmentation.deeplabv3_resnet50`) or +# lraspp mobilenet models # (:func:`~torchvision.models.segmentation.lraspp_mobilenet_v3_large`). # -# Like :func:`~torchvision.utils.draw_bounding_boxes`, -# :func:`~torchvision.utils.draw_segmentation_masks` requires a single RGB image -# of dtype `uint8`. +# Let's start by looking at the ouput of the model. Remember that in general, +# images must be normalized before they're passed to a semantic segmentation +# model. from torchvision.models.segmentation import fcn_resnet50 -from torchvision.utils import draw_segmentation_masks model = fcn_resnet50(pretrained=True, progress=False) model = model.eval() -# The model expects the batch to be normalized -batch = F.normalize(batch, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) -outputs = model(batch) +normalized_batch = F.normalize(batch, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) +output = model(normalized_batch)['out'] +print(output.shape, output.min().item(), output.max().item()) + +##################################### +# As we can see above, the output of the segmentation model is a tensor of shape +# ``(batch_size, num_classes, H, W)``. Each value is a non-normalized score, and +# we can normalize them into ``[0, 1]`` by using a softmax. After the softmax, +# we can interpret each value as a probability indicating how likely a given +# pixel is to belong to a given class. +# +# Let's plot the masks that have been detected for the dog class and for the +# boat class: + +sem_classes = [ + '__background__', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', + 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', + 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor' +] +sem_class_to_idx = {cls: idx for (idx, cls) in enumerate(sem_classes)} + +normalized_masks = torch.nn.functional.softmax(output, dim=1) + +dog_and_boat_masks = [ + normalized_masks[img_idx, sem_class_to_idx[cls]] + for img_idx in range(batch.shape[0]) + for cls in ('dog', 'boat') +] + +show(dog_and_boat_masks) + +##################################### +# As expected, the model is confident about the dog class, but not so much for +# the boat class. +# +# The :func:`~torchvision.utils.draw_segmentation_masks` function can be used to +# plots those masks on top of the original image. This function expects the +# masks to be boolean masks, but our masks above contain probabilities in ``[0, +# 1]``. To get boolean masks, we can do the following: + +class_dim = 1 +boolean_dog_masks = (normalized_masks.argmax(class_dim) == sem_class_to_idx['dog']) +print(f"shape = {boolean_dog_masks.shape}, dtype = {boolean_dog_masks.dtype}") +show([m.float() for m in boolean_dog_masks]) + + +##################################### +# The line above where we define ``boolean_dog_masks`` is a bit cryptic, but you +# can read it as the following query: "For which pixels is 'dog' the most likely +# class?" +# +# .. note:: +# While we're using the ``normalized_masks`` here, we would have +# gotten the same result by using the non-normalized scores of the model +# directly (as the softmax operation preserves the order). +# +# Now that we have boolean masks, we can use them with +# :func:`~torchvision.utils.draw_segmentation_masks` to plot them on top of the +# original images: + +from torchvision.utils import draw_segmentation_masks + +dogs_with_masks = [ + draw_segmentation_masks(img, masks=mask, alpha=0.7) + for img, mask in zip(batch_int, boolean_dog_masks) +] +show(dogs_with_masks) + +##################################### +# We can plot more than one mask per image! Remember that the model returned as +# many masks as there are classes. Let's ask the same query as above, but this +# time for *all* classes, not just the dog class: "For each pixel and each class +# C, is class C the most most likely class?" +# +# This one is a bit more involved, so we'll first show how to do it with a +# single image, and then we'll generalize to the batch + +num_classes = normalized_masks.shape[1] +dog1_masks = normalized_masks[0] +class_dim = 0 +dog1_all_classes_masks = dog1_masks.argmax(class_dim) == torch.arange(num_classes)[:, None, None] + +print(f"dog1_masks shape = {dog1_masks.shape}, dtype = {dog1_masks.dtype}") +print(f"dog1_all_classes_masks = {dog1_all_classes_masks.shape}, dtype = {dog1_all_classes_masks.dtype}") + +dog_with_all_masks = draw_segmentation_masks(dog1_int, masks=dog1_all_classes_masks, alpha=.6) +show(dog_with_all_masks) + +##################################### +# We can see in the image above that only 2 masks were drawn: the mask for the +# background and the mask for the dog. This is because the model thinks that +# only these 2 classes are the most likely ones across all the pixels. If the +# model had detected another class as the most likely among other pixels, we +# would have seen its mask above. +# +# Removing the background mask is as simple as passing +# ``masks=dog1_all_classes_masks[1:]``, because the background class is the +# class with index 0. +# +# Let's now do the same but for an entire batch of images. The code is similar +# but involves a bit more juggling with the dimensions. + +class_dim = 1 +all_classes_masks = normalized_masks.argmax(class_dim) == torch.arange(num_classes)[:, None, None, None] +print(f"shape = {all_classes_masks.shape}, dtype = {all_classes_masks.dtype}") +# The first dimension is the classes now, so we need to swap it +all_classes_masks = all_classes_masks.swapaxes(0, 1) dogs_with_masks = [ - draw_segmentation_masks(dog_int, masks=masks, alpha=0.6) - for dog_int, masks in zip((dog1_int, dog2_int), outputs['out']) + draw_segmentation_masks(img, masks=mask, alpha=.6) + for img, mask in zip(batch_int, all_classes_masks) ] show(dogs_with_masks) + + +##################################### +# Instance segmentation models +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +# +# Instance segmentation models have a significantly different output from the +# semantic segmentation models. We will see here how to plot the masks for such +# models. Let's start by analyzing the output of a Mask-RCNN model. Note that +# these models don't require the images to be normalized, so we don't need to +# use the normalized batch. + +from torchvision.models.detection import maskrcnn_resnet50_fpn +model = maskrcnn_resnet50_fpn(pretrained=True, progress=False) +model = model.eval() + +output = model(batch) +print(output) + +##################################### +# Let's break this down. For each image in the batch, the model outputs some +# detections (or instances). The number of detection varies for each input +# image. Each instance is described by its bounding box, its label, its score +# and its mask. +# +# The way the output is organized is as follows: the output is a list of length +# ``batch_size``. Each entry in the list corresponds to an input image, and it +# is a dict with keys 'boxes', 'labels', 'scores', and 'masks'. Each value +# associated to those keys has ``num_instances`` elements in it. In our case +# above there are 3 instances detected in the first image, and 2 instances in +# the second one. +# +# The boxes can be plotted with :func:`~torchvision.utils.draw_bounding_boxes` +# as above, but here we're more interested in the masks. These masks are quite +# different from the masks that we saw above for the semantic segmentation +# models. + +dog1_output = output[0] +dog1_masks = dog1_output['masks'] +print(f"shape = {dog1_masks.shape}, dtype = {dog1_masks.dtype}, " + f"min = {dog1_masks.min()}, max = {dog1_masks.max()}") + +##################################### +# Here the masks corresponds to probabilities indicating, for each pixel, how +# likely it is to belong to the predicted label of that instance. Those +# predicted labels correspond to the 'labels' element in the same output dict. +# Let's see which labels were predicted for the instances of the first image. + +inst_classes = [ + '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', + 'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'N/A', 'stop sign', + 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', + 'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella', 'N/A', 'N/A', + 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', + 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', + 'bottle', 'N/A', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', + 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', + 'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'N/A', 'dining table', + 'N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', + 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book', + 'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush' +] + +inst_class_to_idx = {cls: idx for (idx, cls) in enumerate(inst_classes)} + +print("For the first dog, the following instances were detected:") +print([inst_classes[label] for label in dog1_output['labels']]) + +##################################### +# Interestingly, the model detects two persons in the image. Let's go ahead and +# plot those masks. Since :func:`~torchvision.utils.draw_segmentation_masks` +# expects boolean masks, we need to convert those probabilities into boolean +# values. Remember that the semantic of those masks is "How likely is this pixel +# to belong to the predicted class?". As a result, a natural way of converting +# those masks into boolean values is to threshold them with the 0.5 probability +# (one could also choose a different threshold). + +proba_threshold = 0.5 +dog1_bool_masks = dog1_output['masks'] > proba_threshold +print(f"shape = {dog1_bool_masks.shape}, dtype = {dog1_bool_masks.dtype}") + +# There's an extra dimension (1) to the masks. We need to remove it +dog1_bool_masks = dog1_bool_masks.squeeze(1) + +show(draw_segmentation_masks(dog1_int, dog1_bool_masks, alpha=0.9)) + +##################################### +# The model seems to have properly detected the dog, but it also confused trees +# with people. Looking more closely at the scores will help us plotting more +# relevant masks: + +print(dog1_output['scores']) + +##################################### +# Clearly the model is less confident about the dog detection than it is about +# the people detections. That's good news. When plotting the masks, we can ask +# for only those that have a good score. Let's use a score threshold of .75 +# here, and also plot the masks of the second dog. + +score_threshold = .75 + +boolean_masks = [ + out['masks'][out['scores'] > score_threshold] > proba_threshold + for out in output +] + +dogs_with_masks = [ + draw_segmentation_masks(img, mask.squeeze(1)) + for img, mask in zip(batch_int, boolean_masks) +] +show(dogs_with_masks) + +##################################### +# The two 'people' masks in the first image where not selected because they have +# a lower score than the score threshold. Similarly in the second image, the +# instance with class 15 (which corresponds to 'bench') was not selected. diff --git a/test/assets/fakedata/draw_segm_masks_colors_util.png b/test/assets/fakedata/draw_segm_masks_colors_util.png deleted file mode 100644 index 454b35556317dc1da1707fb234cf8563c1e8c707..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 88 zcmeAS@N?(olHy`uVBq!ia0vp^tRT$61SFYwH*Nw_@}4e^Ar*6yP5$MdX<(7~Fa6*B l;o_6Vh6|XE{XeGhiNULzE&Y{;O%+fngQu&X%Q~loCIFN+8JPe8 diff --git a/test/assets/fakedata/draw_segm_masks_no_colors_util.png b/test/assets/fakedata/draw_segm_masks_no_colors_util.png deleted file mode 100644 index f048d2469d2414d6e1e864111a6117a30a7d210b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 106 zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc1SFYWcSQjyLr)jSkcv6UCi5Pib torch.Tensor: @@ -229,49 +229,68 @@ def draw_segmentation_masks( The values of the input image should be uint8 between 0 and 255. Args: - image (Tensor): Tensor of shape (3 x H x W) and dtype uint8. - masks (Tensor): Tensor of shape (num_masks, H, W). Each containing probability of predicted class. - alpha (float): Float number between 0 and 1 denoting factor of transparency of masks. - colors (List[Union[str, Tuple[int, int, int]]]): List containing the colors of masks. The colors can - be represented as `str` or `Tuple[int, int, int]`. + image (Tensor): Tensor of shape (3, H, W) and dtype uint8. + masks (Tensor): Tensor of shape (num_masks, H, W) or (H, W) and dtype bool. + alpha (float): Float number between 0 and 1 denoting the transparency of the masks. + 0 means full transparency, 1 means no transparency. + colors (list or None): List containing the colors of the masks. The colors can + be represented as PIL strings e.g. "red" or "#FF00FF", or as RGB tuples e.g. ``(240, 10, 157)``. + When ``masks`` has a single entry of shape (H, W), you can pass a single color instead of a list + with one element. By default, random colors are generated for each mask. Returns: - img (Tensor[C, H, W]): Image Tensor of dtype uint8 with segmentation masks plotted. + img (Tensor[C, H, W]): Image Tensor, with segmentation masks drawn on top. """ if not isinstance(image, torch.Tensor): - raise TypeError(f"Tensor expected, got {type(image)}") + raise TypeError(f"The image must be a tensor, got {type(image)}") elif image.dtype != torch.uint8: - raise ValueError(f"Tensor uint8 expected, got {image.dtype}") + raise ValueError(f"The image dtype must be uint8, got {image.dtype}") elif image.dim() != 3: raise ValueError("Pass individual images, not batches") elif image.size()[0] != 3: raise ValueError("Pass an RGB image. Other Image formats are not supported") + if masks.ndim == 2: + masks = masks[None, :, :] + if masks.ndim != 3: + raise ValueError("masks must be of shape (H, W) or (batch_size, H, W)") + if masks.dtype != torch.bool: + raise ValueError(f"The masks must be of dtype bool. Got {masks.dtype}") + if masks.shape[-2:] != image.shape[-2:]: + raise ValueError("The image and the masks must have the same height and width") num_masks = masks.size()[0] - masks = masks.argmax(0) + if colors is not None and num_masks > len(colors): + raise ValueError(f"There are more masks ({num_masks}) than colors ({len(colors)})") if colors is None: - palette = torch.tensor([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1]) - colors_t = torch.as_tensor([i for i in range(num_masks)])[:, None] * palette - color_arr = (colors_t % 255).numpy().astype("uint8") - else: - color_list = [] - for color in colors: - if isinstance(color, str): - # This will automatically raise Error if rgb cannot be parsed. - fill_color = ImageColor.getrgb(color) - color_list.append(fill_color) - elif isinstance(color, tuple): - color_list.append(color) + colors = _generate_color_palette(num_masks) + + if not isinstance(colors, list): + colors = [colors] + if not isinstance(colors[0], (tuple, str)): + raise ValueError("colors must be a tuple or a string, or a list thereof") + if isinstance(colors[0], tuple) and len(colors[0]) != 3: + raise ValueError("It seems that you passed a tuple of colors instead of a list of colors") + + out_dtype = torch.uint8 + + colors_ = [] + for color in colors: + if isinstance(color, str): + color = ImageColor.getrgb(color) + color = torch.tensor(color, dtype=out_dtype) + colors_.append(color) - color_arr = np.array(color_list).astype("uint8") + img_to_draw = image.detach().clone() + # TODO: There might be a way to vectorize this + for mask, color in zip(masks, colors_): + img_to_draw[:, mask] = color[:, None] - _, h, w = image.size() - img_to_draw = Image.fromarray(masks.byte().cpu().numpy()).resize((w, h)) - img_to_draw.putpalette(color_arr) + out = image * (1 - alpha) + img_to_draw * alpha + return out.to(out_dtype) - img_to_draw = torch.from_numpy(np.array(img_to_draw.convert('RGB'))) - img_to_draw = img_to_draw.permute((2, 0, 1)) - return (image.float() * alpha + img_to_draw.float() * (1.0 - alpha)).to(dtype=torch.uint8) +def _generate_color_palette(num_masks): + palette = torch.tensor([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1]) + return [tuple((i * palette) % 255) for i in range(num_masks)] From 11bf27e37190b320216c349e39b085fb33aefed1 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Mon, 17 May 2021 13:03:13 +0000 Subject: [PATCH 061/279] Adding some references on MobileNetV3 implementation. (#3850) --- torchvision/models/mobilenetv3.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torchvision/models/mobilenetv3.py b/torchvision/models/mobilenetv3.py index 890fd30d07d..3ac517d0ced 100644 --- a/torchvision/models/mobilenetv3.py +++ b/torchvision/models/mobilenetv3.py @@ -19,7 +19,7 @@ class SqueezeExcitation(nn.Module): - + # Implemented as described at Figure 4 of the MobileNetV3 paper def __init__(self, input_channels: int, squeeze_factor: int = 4): super().__init__() squeeze_channels = _make_divisible(input_channels // squeeze_factor, 8) @@ -40,7 +40,7 @@ def forward(self, input: Tensor) -> Tensor: class InvertedResidualConfig: - + # Stores information listed at Tables 1 and 2 of the MobileNetV3 paper def __init__(self, input_channels: int, kernel: int, expanded_channels: int, out_channels: int, use_se: bool, activation: str, stride: int, dilation: int, width_mult: float): self.input_channels = self.adjust_channels(input_channels, width_mult) @@ -58,7 +58,7 @@ def adjust_channels(channels: int, width_mult: float): class InvertedResidual(nn.Module): - + # Implemented as described at section 5 of MobileNetV3 paper def __init__(self, cnf: InvertedResidualConfig, norm_layer: Callable[..., nn.Module], se_layer: Callable[..., nn.Module] = SqueezeExcitation): super().__init__() From 6397190105cf7392db42bb8c04816c22f8b5ccc7 Mon Sep 17 00:00:00 2001 From: Jaesun Park Date: Mon, 17 May 2021 23:46:47 +0900 Subject: [PATCH 062/279] Make crop work the same for pil and tensor (#3770) * Make crop work the same for pil and tensor * Only call pad if needed in functional_tensor.crop * Fix top-left functional_tensor.crop * Update document for functional.crop * Add other test cases of functional.crop * Fix bug * Fixing formattter * Fix stylings Co-authored-by: Vasilis Vryniotis --- test/test_transforms_tensor.py | 16 ++++++++++++++++ torchvision/transforms/functional.py | 3 ++- torchvision/transforms/functional_tensor.py | 9 ++++++++- 3 files changed, 26 insertions(+), 2 deletions(-) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 4a2f59c6a9b..2c598e90833 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -188,6 +188,22 @@ def test_crop(self): 'crop', 'RandomCrop', fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs ) + # Test transforms.functional.crop including outside the image area + fn_kwargs = {"top": -2, "left": 3, "height": 4, "width": 5} # top + self._test_functional_op('crop', fn_kwargs=fn_kwargs) + + fn_kwargs = {"top": 1, "left": -3, "height": 4, "width": 5} # left + self._test_functional_op('crop', fn_kwargs=fn_kwargs) + + fn_kwargs = {"top": 7, "left": 3, "height": 4, "width": 5} # bottom + self._test_functional_op('crop', fn_kwargs=fn_kwargs) + + fn_kwargs = {"top": 3, "left": 8, "height": 4, "width": 5} # right + self._test_functional_op('crop', fn_kwargs=fn_kwargs) + + fn_kwargs = {"top": -3, "left": -3, "height": 15, "width": 15} # all + self._test_functional_op('crop', fn_kwargs=fn_kwargs) + sizes = [5, [5, ], [6, 6]] padding_configs = [ {"padding_mode": "constant", "fill": 0}, diff --git a/torchvision/transforms/functional.py b/torchvision/transforms/functional.py index 17dd649159e..5bbd91b3fd8 100644 --- a/torchvision/transforms/functional.py +++ b/torchvision/transforms/functional.py @@ -463,7 +463,8 @@ def pad(img: Tensor, padding: List[int], fill: int = 0, padding_mode: str = "con def crop(img: Tensor, top: int, left: int, height: int, width: int) -> Tensor: """Crop the given image at specified location and output size. If the image is torch Tensor, it is expected - to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions + to have [..., H, W] shape, where ... means an arbitrary number of leading dimensions. + If image size is smaller than output size along any edge, image is padded with 0 and then cropped. Args: img (PIL Image or Tensor): Image to be cropped. (0,0) denotes the top left corner of the image. diff --git a/torchvision/transforms/functional_tensor.py b/torchvision/transforms/functional_tensor.py index 7aa63f539cb..57a0b75fdd2 100644 --- a/torchvision/transforms/functional_tensor.py +++ b/torchvision/transforms/functional_tensor.py @@ -122,7 +122,14 @@ def hflip(img: Tensor) -> Tensor: def crop(img: Tensor, top: int, left: int, height: int, width: int) -> Tensor: _assert_image_tensor(img) - return img[..., top:top + height, left:left + width] + w, h = _get_image_size(img) + right = left + width + bottom = top + height + + if left < 0 or top < 0 or right > w or bottom > h: + padding_ltrb = [max(-left, 0), max(-top, 0), max(right - w, 0), max(bottom - h, 0)] + return pad(img[..., max(top, 0):bottom, max(left, 0):right], padding_ltrb, fill=0) + return img[..., top:bottom, left:right] def rgb_to_grayscale(img: Tensor, num_output_channels: int = 1) -> Tensor: From 541e0f135b91e10b0b884ffc9952591a51c8aed6 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 17 May 2021 16:31:05 +0100 Subject: [PATCH 063/279] Update models weights for inception_v3, vgg11, and vgg13 (#3851) --- torchvision/models/inception.py | 2 +- torchvision/models/vgg.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/torchvision/models/inception.py b/torchvision/models/inception.py index 4abad7c02e7..05b1cf07620 100644 --- a/torchvision/models/inception.py +++ b/torchvision/models/inception.py @@ -12,7 +12,7 @@ model_urls = { # Inception v3 ported from TensorFlow - 'inception_v3_google': 'https://download.pytorch.org/models/inception_v3_google-1a9a5a14.pth', + 'inception_v3_google': 'https://download.pytorch.org/models/inception_v3_google-0cc3c7bd.pth', } InceptionOutputs = namedtuple('InceptionOutputs', ['logits', 'aux_logits']) diff --git a/torchvision/models/vgg.py b/torchvision/models/vgg.py index 667aabbed48..20da5c18a57 100644 --- a/torchvision/models/vgg.py +++ b/torchvision/models/vgg.py @@ -11,8 +11,8 @@ model_urls = { - 'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth', - 'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth', + 'vgg11': 'https://download.pytorch.org/models/vgg11-8a719046.pth', + 'vgg13': 'https://download.pytorch.org/models/vgg13-19584684.pth', 'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth', 'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth', 'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth', From e68d6b03ff1203974ae01acc9815312d5a8a195f Mon Sep 17 00:00:00 2001 From: chengjuzhou Date: Tue, 18 May 2021 00:47:54 +0800 Subject: [PATCH 064/279] correct the size of returned tensor in comments of ps_roi_pool.py and ps_roi_align.py (#3849) * correct the size of returne tensor * Styling changes Co-authored-by: Vasilis Vryniotis --- torchvision/ops/ps_roi_align.py | 2 +- torchvision/ops/ps_roi_pool.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/torchvision/ops/ps_roi_align.py b/torchvision/ops/ps_roi_align.py index 8097211dfe9..d42353e2b0d 100644 --- a/torchvision/ops/ps_roi_align.py +++ b/torchvision/ops/ps_roi_align.py @@ -39,7 +39,7 @@ def ps_roi_align( ``ceil(roi_width / output_width)``, and likewise for height). Default: -1 Returns: - Tensor[K, C, output_size[0], output_size[1]]: The pooled RoIs + Tensor[K, C / (output_size[0] * output_size[1]), output_size[0], output_size[1]]: The pooled RoIs """ _assert_has_ops() check_roi_boxes_shape(boxes) diff --git a/torchvision/ops/ps_roi_pool.py b/torchvision/ops/ps_roi_pool.py index 01cee261f77..d0331e557fd 100644 --- a/torchvision/ops/ps_roi_pool.py +++ b/torchvision/ops/ps_roi_pool.py @@ -33,7 +33,7 @@ def ps_roi_pool( the box coordinates. Default: 1.0 Returns: - Tensor[K, C, output_size[0], output_size[1]]: The pooled RoIs. + Tensor[K, C / (output_size[0] * output_size[1]), output_size[0], output_size[1]]: The pooled RoIs. """ _assert_has_ops() check_roi_boxes_shape(boxes) From 8fb76e8fae30048f499bc0ec0445aa6101a1d442 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 17 May 2021 18:56:36 +0100 Subject: [PATCH 065/279] Port NMS tests to use pytest and introduce the cpu_only decorator (#3852) --- test/common_utils.py | 13 +++++ test/test_ops.py | 114 +++++++++++++++++++++++-------------------- 2 files changed, 75 insertions(+), 52 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index 2a4aab5f65b..1f48e8c649b 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -409,6 +409,7 @@ def call_args_to_kwargs_only(call_args, *callable_or_arg_names): def cpu_and_gpu(): + # TODO: make this properly handle CircleCI import pytest # noqa # ignore CPU tests in RE as they're already covered by another contbuild @@ -430,6 +431,7 @@ def cpu_and_gpu(): def needs_cuda(test_func): + # TODO: make this properly handle CircleCI import pytest # noqa if IN_FBCODE and not IN_RE_WORKER: @@ -441,3 +443,14 @@ def needs_cuda(test_func): return test_func else: return pytest.mark.skip(reason=CUDA_NOT_AVAILABLE_MSG)(test_func) + + +def cpu_only(test_func): + # TODO: make this properly handle CircleCI + import pytest # noqa + + if IN_RE_WORKER: + # The assumption is that all RE workers have GPUs. + return pytest.mark.dont_collect(test_func) + else: + return test_func diff --git a/test/test_ops.py b/test/test_ops.py index 8c63c9c29c6..2e9fac8bc42 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -1,6 +1,7 @@ -from common_utils import set_rng_seed +from common_utils import needs_cuda, cpu_only import math import unittest +import pytest import numpy as np @@ -437,8 +438,8 @@ def test_msroialign_repr(self): self.assertEqual(t.__repr__(), expected_string) -class NMSTester(unittest.TestCase): - def reference_nms(self, boxes, scores, iou_threshold): +class TestNMS: + def _reference_nms(self, boxes, scores, iou_threshold): """ Args: box_scores (N, 5): boxes in corner-form and probabilities. @@ -478,65 +479,73 @@ def _create_tensors_with_iou(self, N, iou_thresh): scores = torch.rand(N) return boxes, scores - def test_nms(self): + @cpu_only + @pytest.mark.parametrize("iou", (.2, .5, .8)) + def test_nms_ref(self, iou): err_msg = 'NMS incompatible between CPU and reference implementation for IoU={}' - for iou in [0.2, 0.5, 0.8]: - boxes, scores = self._create_tensors_with_iou(1000, iou) - keep_ref = self.reference_nms(boxes, scores, iou) - keep = ops.nms(boxes, scores, iou) - self.assertTrue(torch.allclose(keep, keep_ref), err_msg.format(iou)) - self.assertRaises(RuntimeError, ops.nms, torch.rand(4), torch.rand(3), 0.5) - self.assertRaises(RuntimeError, ops.nms, torch.rand(3, 5), torch.rand(3), 0.5) - self.assertRaises(RuntimeError, ops.nms, torch.rand(3, 4), torch.rand(3, 2), 0.5) - self.assertRaises(RuntimeError, ops.nms, torch.rand(3, 4), torch.rand(4), 0.5) - - def test_qnms(self): + boxes, scores = self._create_tensors_with_iou(1000, iou) + keep_ref = self._reference_nms(boxes, scores, iou) + keep = ops.nms(boxes, scores, iou) + assert torch.allclose(keep, keep_ref), err_msg.format(iou) + + @cpu_only + def test_nms_input_errors(self): + with pytest.raises(RuntimeError): + ops.nms(torch.rand(4), torch.rand(3), 0.5) + with pytest.raises(RuntimeError): + ops.nms(torch.rand(3, 5), torch.rand(3), 0.5) + with pytest.raises(RuntimeError): + ops.nms(torch.rand(3, 4), torch.rand(3, 2), 0.5) + with pytest.raises(RuntimeError): + ops.nms(torch.rand(3, 4), torch.rand(4), 0.5) + + @cpu_only + @pytest.mark.parametrize("iou", (.2, .5, .8)) + @pytest.mark.parametrize("scale, zero_point", ((1, 0), (2, 50), (3, 10))) + def test_qnms(self, iou, scale, zero_point): # Note: we compare qnms vs nms instead of qnms vs reference implementation. # This is because with the int convertion, the trick used in _create_tensors_with_iou # doesn't really work (in fact, nms vs reference implem will also fail with ints) err_msg = 'NMS and QNMS give different results for IoU={}' - for iou in [0.2, 0.5, 0.8]: - for scale, zero_point in ((1, 0), (2, 50), (3, 10)): - boxes, scores = self._create_tensors_with_iou(1000, iou) - scores *= 100 # otherwise most scores would be 0 or 1 after int convertion + boxes, scores = self._create_tensors_with_iou(1000, iou) + scores *= 100 # otherwise most scores would be 0 or 1 after int convertion - qboxes = torch.quantize_per_tensor(boxes, scale=scale, zero_point=zero_point, - dtype=torch.quint8) - qscores = torch.quantize_per_tensor(scores, scale=scale, zero_point=zero_point, - dtype=torch.quint8) + qboxes = torch.quantize_per_tensor(boxes, scale=scale, zero_point=zero_point, dtype=torch.quint8) + qscores = torch.quantize_per_tensor(scores, scale=scale, zero_point=zero_point, dtype=torch.quint8) - boxes = qboxes.dequantize() - scores = qscores.dequantize() + boxes = qboxes.dequantize() + scores = qscores.dequantize() - keep = ops.nms(boxes, scores, iou) - qkeep = ops.nms(qboxes, qscores, iou) + keep = ops.nms(boxes, scores, iou) + qkeep = ops.nms(qboxes, qscores, iou) - self.assertTrue(torch.allclose(qkeep, keep), err_msg.format(iou)) + assert torch.allclose(qkeep, keep), err_msg.format(iou) - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") - def test_nms_cuda(self, dtype=torch.float64): + @needs_cuda + @pytest.mark.parametrize("iou", (.2, .5, .8)) + def test_nms_cuda(self, iou, dtype=torch.float64): tol = 1e-3 if dtype is torch.half else 1e-5 err_msg = 'NMS incompatible between CPU and CUDA for IoU={}' - for iou in [0.2, 0.5, 0.8]: - boxes, scores = self._create_tensors_with_iou(1000, iou) - r_cpu = ops.nms(boxes, scores, iou) - r_cuda = ops.nms(boxes.cuda(), scores.cuda(), iou) - - is_eq = torch.allclose(r_cpu, r_cuda.cpu()) - if not is_eq: - # if the indices are not the same, ensure that it's because the scores - # are duplicate - is_eq = torch.allclose(scores[r_cpu], scores[r_cuda.cpu()], rtol=tol, atol=tol) - self.assertTrue(is_eq, err_msg.format(iou)) - - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") - def test_autocast(self): - for dtype in (torch.float, torch.half): - with torch.cuda.amp.autocast(): - self.test_nms_cuda(dtype=dtype) - - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") + boxes, scores = self._create_tensors_with_iou(1000, iou) + r_cpu = ops.nms(boxes, scores, iou) + r_cuda = ops.nms(boxes.cuda(), scores.cuda(), iou) + + is_eq = torch.allclose(r_cpu, r_cuda.cpu()) + if not is_eq: + # if the indices are not the same, ensure that it's because the scores + # are duplicate + is_eq = torch.allclose(scores[r_cpu], scores[r_cuda.cpu()], rtol=tol, atol=tol) + assert is_eq, err_msg.format(iou) + + @needs_cuda + @pytest.mark.parametrize("iou", (.2, .5, .8)) + @pytest.mark.parametrize("dtype", (torch.float, torch.half)) + def test_autocast(self, iou, dtype): + with torch.cuda.amp.autocast(): + self.test_nms_cuda(iou=iou, dtype=dtype) + + @needs_cuda def test_nms_cuda_float16(self): boxes = torch.tensor([[285.3538, 185.5758, 1193.5110, 851.4551], [285.1472, 188.7374, 1192.4984, 851.0669], @@ -546,8 +555,9 @@ def test_nms_cuda_float16(self): iou_thres = 0.2 keep32 = ops.nms(boxes, scores, iou_thres) keep16 = ops.nms(boxes.to(torch.float16), scores.to(torch.float16), iou_thres) - self.assertTrue(torch.all(torch.eq(keep32, keep16))) + assert torch.all(torch.eq(keep32, keep16)) + @cpu_only def test_batched_nms_implementations(self): """Make sure that both implementations of batched_nms yield identical results""" @@ -564,11 +574,11 @@ def test_batched_nms_implementations(self): keep_trick = ops.boxes._batched_nms_coordinate_trick(boxes, scores, idxs, iou_threshold) err_msg = "The vanilla and the trick implementation yield different nms outputs." - self.assertTrue(torch.allclose(keep_vanilla, keep_trick), err_msg) + assert torch.allclose(keep_vanilla, keep_trick), err_msg # Also make sure an empty tensor is returned if boxes is empty empty = torch.empty((0,), dtype=torch.int64) - self.assertTrue(torch.allclose(empty, ops.batched_nms(empty, None, None, None))) + assert torch.allclose(empty, ops.batched_nms(empty, None, None, None)) class DeformConvTester(OpTester, unittest.TestCase): From 33db2b3ebfdd2f73a9228f430fa7dd91c3b18078 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 18 May 2021 10:30:42 +0100 Subject: [PATCH 066/279] Improvements to models docs (#3853) --- docs/source/models.rst | 6 ++- gallery/plot_visualization_utils.py | 22 +++++++++-- torchvision/models/detection/faster_rcnn.py | 16 +++++--- torchvision/models/detection/keypoint_rcnn.py | 8 ++-- torchvision/models/detection/mask_rcnn.py | 8 ++-- torchvision/models/detection/retinanet.py | 8 ++-- torchvision/models/detection/ssd.py | 37 ++++++++++++++++--- torchvision/models/detection/ssdlite.py | 5 ++- 8 files changed, 84 insertions(+), 26 deletions(-) diff --git a/docs/source/models.rst b/docs/source/models.rst index c2b81e49735..56dce6a76dc 100644 --- a/docs/source/models.rst +++ b/docs/source/models.rst @@ -329,6 +329,8 @@ The images have to be loaded in to a range of ``[0, 1]`` and then normalized usi ``mean = [0.485, 0.456, 0.406]`` and ``std = [0.229, 0.224, 0.225]``. They have been trained on images resized such that their minimum size is 520. +For details on how to plot the masks of such models, you may refer to :ref:`semantic_seg_output`. + The pre-trained models have been trained on a subset of COCO train2017, on the 20 categories that are present in the Pascal VOC dataset. You can see more information on how the subset has been selected in ``references/segmentation/coco_utils.py``. The classes that the pre-trained model outputs are the following, @@ -374,6 +376,7 @@ LR-ASPP .. autofunction:: torchvision.models.segmentation.lraspp_mobilenet_v3_large +.. _object_det_inst_seg_pers_keypoint_det: Object Detection, Instance Segmentation and Person Keypoint Detection ===================================================================== @@ -392,7 +395,8 @@ in torchvision. The models expect a list of ``Tensor[C, H, W]``, in the range ``0-1``. The models internally resize the images but the behaviour varies depending -on the model. Check the constructor of the models for more information. +on the model. Check the constructor of the models for more information. The +output format of such models is illustrated in :ref:`instance_seg_output`. For object detection and instance segmentation, the pre-trained diff --git a/gallery/plot_visualization_utils.py b/gallery/plot_visualization_utils.py index 04c5e3dcb53..b5b3d7e103e 100644 --- a/gallery/plot_visualization_utils.py +++ b/gallery/plot_visualization_utils.py @@ -68,7 +68,8 @@ def show(imgs): # models. Here is demo with a Faster R-CNN model loaded from # :func:`~torchvision.models.detection.fasterrcnn_resnet50_fpn` # model. You can also try using a RetinaNet with -# :func:`~torchvision.models.detection.retinanet_resnet50_fpn`. +# :func:`~torchvision.models.detection.retinanet_resnet50_fpn`. For more details +# on the output of such models, you may refer to :ref:`instance_seg_output`. from torchvision.models.detection import fasterrcnn_resnet50_fpn from torchvision.transforms.functional import convert_image_dtype @@ -87,9 +88,9 @@ def show(imgs): # Let's plot the boxes detected by our model. We will only plot the boxes with a # score greater than a given threshold. -threshold = .8 +score_threshold = .8 dogs_with_boxes = [ - draw_bounding_boxes(dog_int, boxes=output['boxes'][output['scores'] > threshold], width=4) + draw_bounding_boxes(dog_int, boxes=output['boxes'][output['scores'] > score_threshold], width=4) for dog_int, output in zip(batch_int, outputs) ] show(dogs_with_boxes) @@ -102,6 +103,8 @@ def show(imgs): # segmentation models have different outputs, so we will treat each # independently. # +# .. _semantic_seg_output: +# # Semantic segmentation models # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # @@ -237,6 +240,8 @@ def show(imgs): ##################################### +# .. _instance_seg_output: +# # Instance segmentation models # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # @@ -245,6 +250,15 @@ def show(imgs): # models. Let's start by analyzing the output of a Mask-RCNN model. Note that # these models don't require the images to be normalized, so we don't need to # use the normalized batch. +# +# .. note:: +# +# We will here describe the output of a Mask-RCNN model. The models in +# :ref:`object_det_inst_seg_pers_keypoint_det` all have a similar output +# format, but some of them may have extra info like keypoints for +# :func:`~torchvision.models.detection.keypointrcnn_resnet50_fpn`, and some +# of them may not have masks, like +# :func:`~torchvision.models.detection.fasterrcnn_resnet50_fpn`. from torchvision.models.detection import maskrcnn_resnet50_fpn model = maskrcnn_resnet50_fpn(pretrained=True, progress=False) @@ -255,7 +269,7 @@ def show(imgs): ##################################### # Let's break this down. For each image in the batch, the model outputs some -# detections (or instances). The number of detection varies for each input +# detections (or instances). The number of detections varies for each input # image. Each instance is described by its bounding box, its label, its score # and its mask. # diff --git a/torchvision/models/detection/faster_rcnn.py b/torchvision/models/detection/faster_rcnn.py index 53100e54adb..bf8df3b9377 100644 --- a/torchvision/models/detection/faster_rcnn.py +++ b/torchvision/models/detection/faster_rcnn.py @@ -317,12 +317,14 @@ def fasterrcnn_resnet50_fpn(pretrained=False, progress=True, During inference, the model requires only the input tensors, and returns the post-processed predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as - follows: + follows, where ``N`` is the number of detections: - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. - - labels (``Int64Tensor[N]``): the predicted labels for each image - - scores (``Tensor[N]``): the scores or each prediction + - labels (``Int64Tensor[N]``): the predicted labels for each detection + - scores (``Tensor[N]``): the scores of each detection + + For more details on the output, you may refer to :ref:`instance_seg_output`. Faster R-CNN is exportable to ONNX for a fixed batch size with inputs images of fixed size. @@ -399,7 +401,9 @@ def fasterrcnn_mobilenet_v3_large_320_fpn(pretrained=False, progress=True, num_c trainable_backbone_layers=None, **kwargs): """ Constructs a low resolution Faster R-CNN model with a MobileNetV3-Large FPN backbone tunned for mobile use-cases. - It works similarly to Faster R-CNN with ResNet-50 FPN backbone. See `fasterrcnn_resnet50_fpn` for more details. + It works similarly to Faster R-CNN with ResNet-50 FPN backbone. See + :func:`~torchvision.models.detection.fasterrcnn_resnet50_fpn` for more + details. Example:: @@ -435,7 +439,9 @@ def fasterrcnn_mobilenet_v3_large_fpn(pretrained=False, progress=True, num_class trainable_backbone_layers=None, **kwargs): """ Constructs a high resolution Faster R-CNN model with a MobileNetV3-Large FPN backbone. - It works similarly to Faster R-CNN with ResNet-50 FPN backbone. See `fasterrcnn_resnet50_fpn` for more details. + It works similarly to Faster R-CNN with ResNet-50 FPN backbone. See + :func:`~torchvision.models.detection.fasterrcnn_resnet50_fpn` for more + details. Example:: diff --git a/torchvision/models/detection/keypoint_rcnn.py b/torchvision/models/detection/keypoint_rcnn.py index 0d460ade27c..0d9a4de6dca 100644 --- a/torchvision/models/detection/keypoint_rcnn.py +++ b/torchvision/models/detection/keypoint_rcnn.py @@ -297,14 +297,16 @@ def keypointrcnn_resnet50_fpn(pretrained=False, progress=True, During inference, the model requires only the input tensors, and returns the post-processed predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as - follows: + follows, where ``N`` is the number of detected instances: - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. - - labels (``Int64Tensor[N]``): the predicted labels for each image - - scores (``Tensor[N]``): the scores or each prediction + - labels (``Int64Tensor[N]``): the predicted labels for each instance + - scores (``Tensor[N]``): the scores or each instance - keypoints (``FloatTensor[N, K, 3]``): the locations of the predicted keypoints, in ``[x, y, v]`` format. + For more details on the output, you may refer to :ref:`instance_seg_output`. + Keypoint R-CNN is exportable to ONNX for a fixed batch size with inputs images of fixed size. Example:: diff --git a/torchvision/models/detection/mask_rcnn.py b/torchvision/models/detection/mask_rcnn.py index 1e6fb77f07a..589a42068bf 100644 --- a/torchvision/models/detection/mask_rcnn.py +++ b/torchvision/models/detection/mask_rcnn.py @@ -289,16 +289,18 @@ def maskrcnn_resnet50_fpn(pretrained=False, progress=True, During inference, the model requires only the input tensors, and returns the post-processed predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as - follows: + follows, where ``N`` is the number of detected instances: - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. - - labels (``Int64Tensor[N]``): the predicted labels for each image - - scores (``Tensor[N]``): the scores or each prediction + - labels (``Int64Tensor[N]``): the predicted labels for each instance + - scores (``Tensor[N]``): the scores or each instance - masks (``UInt8Tensor[N, 1, H, W]``): the predicted masks for each instance, in ``0-1`` range. In order to obtain the final segmentation masks, the soft masks can be thresholded, generally with a value of 0.5 (``mask >= 0.5``) + For more details on the output and on how to plot the masks, you may refer to :ref:`instance_seg_output`. + Mask R-CNN is exportable to ONNX for a fixed batch size with inputs images of fixed size. Example:: diff --git a/torchvision/models/detection/retinanet.py b/torchvision/models/detection/retinanet.py index 43b0d14dd5e..af6943628a4 100644 --- a/torchvision/models/detection/retinanet.py +++ b/torchvision/models/detection/retinanet.py @@ -586,12 +586,14 @@ def retinanet_resnet50_fpn(pretrained=False, progress=True, During inference, the model requires only the input tensors, and returns the post-processed predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as - follows: + follows, where ``N`` is the number of detections: - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. - - labels (``Int64Tensor[N]``): the predicted labels for each image - - scores (``Tensor[N]``): the scores or each prediction + - labels (``Int64Tensor[N]``): the predicted labels for each detection + - scores (``Tensor[N]``): the scores of each detection + + For more details on the output, you may refer to :ref:`instance_seg_output`. Example:: diff --git a/torchvision/models/detection/ssd.py b/torchvision/models/detection/ssd.py index f6150cf5cd5..6695167d462 100644 --- a/torchvision/models/detection/ssd.py +++ b/torchvision/models/detection/ssd.py @@ -126,11 +126,12 @@ class SSD(nn.Module): During inference, the model requires only the input tensors, and returns the post-processed predictions as a List[Dict[Tensor]], one for each input image. The fields of the Dict are as - follows: + follows, where ``N`` is the number of detections: + - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. - - labels (Int64Tensor[N]): the predicted labels for each image - - scores (Tensor[N]): the scores for each prediction + - labels (Int64Tensor[N]): the predicted labels for each detection + - scores (Tensor[N]): the scores for each detection Args: backbone (nn.Module): the network used to compute the features for the model. @@ -520,8 +521,34 @@ def _vgg_extractor(backbone_name: str, highres: bool, progress: bool, pretrained def ssd300_vgg16(pretrained: bool = False, progress: bool = True, num_classes: int = 91, pretrained_backbone: bool = True, trainable_backbone_layers: Optional[int] = None, **kwargs: Any): - """ - Constructs an SSD model with input size 300x300 and a VGG16 backbone. See `SSD` for more details. + """Constructs an SSD model with input size 300x300 and a VGG16 backbone. + + Reference: `"SSD: Single Shot MultiBox Detector" `_. + + The input to the model is expected to be a list of tensors, each of shape [C, H, W], one for each + image, and should be in 0-1 range. Different images can have different sizes but they will be resized + to a fixed size before passing it to the backbone. + + The behavior of the model changes depending if it is in training or evaluation mode. + + During training, the model expects both the input tensors, as well as a targets (list of dictionary), + containing: + + - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with + ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. + - labels (Int64Tensor[N]): the class label for each ground-truth box + + The model returns a Dict[Tensor] during training, containing the classification and regression + losses. + + During inference, the model requires only the input tensors, and returns the post-processed + predictions as a List[Dict[Tensor]], one for each input image. The fields of the Dict are as + follows, where ``N`` is the number of detections: + + - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with + ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``. + - labels (Int64Tensor[N]): the predicted labels for each detection + - scores (Tensor[N]): the scores for each detection Example: diff --git a/torchvision/models/detection/ssdlite.py b/torchvision/models/detection/ssdlite.py index dcab863feb1..56e0d0e4958 100644 --- a/torchvision/models/detection/ssdlite.py +++ b/torchvision/models/detection/ssdlite.py @@ -158,8 +158,9 @@ def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = Tru pretrained_backbone: bool = False, trainable_backbone_layers: Optional[int] = None, norm_layer: Optional[Callable[..., nn.Module]] = None, **kwargs: Any): - """ - Constructs an SSDlite model with input size 320x320 and a MobileNetV3 Large backbone. See `SSD` for more details. + """Constructs an SSDlite model with input size 320x320 and a MobileNetV3 Large backbone. + + See :func:`~torchvision.models.detection.ssd300_vgg16` for more details. Example: From b6f733046c9259f354d060cd808241a558d7d596 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 18 May 2021 13:31:39 +0000 Subject: [PATCH 067/279] SSDlite documentation fixes (#3855) * Remove incorrect params from doc and add references to the paper. * Add paper links in doc. --- torchvision/models/detection/ssdlite.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/torchvision/models/detection/ssdlite.py b/torchvision/models/detection/ssdlite.py index 56e0d0e4958..30e4383ed5d 100644 --- a/torchvision/models/detection/ssdlite.py +++ b/torchvision/models/detection/ssdlite.py @@ -23,6 +23,7 @@ } +# Building blocks of SSDlite as described in section 6.2 of MobileNetV2 paper def _prediction_block(in_channels: int, out_channels: int, kernel_size: int, norm_layer: Callable[..., nn.Module]) -> nn.Sequential: return nn.Sequential( @@ -101,6 +102,7 @@ def __init__(self, backbone: nn.Module, c4_pos: int, norm_layer: Callable[..., n assert not backbone[c4_pos].use_res_connect self.features = nn.Sequential( + # As described in section 6.3 of MobileNetV3 paper nn.Sequential(*backbone[:c4_pos], backbone[c4_pos].block[0]), # from start until C4 expansion layer nn.Sequential(backbone[c4_pos].block[1:], *backbone[c4_pos + 1:]), # from C4 depthwise until end ) @@ -158,7 +160,11 @@ def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = Tru pretrained_backbone: bool = False, trainable_backbone_layers: Optional[int] = None, norm_layer: Optional[Callable[..., nn.Module]] = None, **kwargs: Any): - """Constructs an SSDlite model with input size 320x320 and a MobileNetV3 Large backbone. + """Constructs an SSDlite model with input size 320x320 and a MobileNetV3 Large backbone, as described at + `"Searching for MobileNetV3" + `_ and + `"MobileNetV2: Inverted Residuals and Linear Bottlenecks" + `_. See :func:`~torchvision.models.detection.ssd300_vgg16` for more details. @@ -170,8 +176,6 @@ def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = Tru >>> predictions = model(x) Args: - norm_layer: - **kwargs: pretrained (bool): If True, returns a model pre-trained on COCO train2017 progress (bool): If True, displays a progress bar of the download to stderr num_classes (int): number of output classes of the model (including the background) @@ -189,7 +193,7 @@ def ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = Tru if pretrained: pretrained_backbone = False - # Enable reduced tail if no pretrained backbone is selected + # Enable reduced tail if no pretrained backbone is selected. See Table 6 of MobileNetV3 paper. reduce_tail = not pretrained_backbone if norm_layer is None: From 2c52d9f9e3a5ebb4513f1399ae5a84df140f5c96 Mon Sep 17 00:00:00 2001 From: Jeff Daily Date: Tue, 18 May 2021 18:41:48 -0700 Subject: [PATCH 068/279] add rocm4.2 to nightly wheel builds (#3840) * add rocm4.2 to nightly wheel builds * remove rocm4.0.1 build Co-authored-by: Francisco Massa Co-authored-by: Eli Uriegas <1700823+seemethere@users.noreply.github.com> --- .circleci/config.yml | 168 ++++++++++++++++++++-------------------- .circleci/regenerate.py | 2 +- 2 files changed, 85 insertions(+), 85 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 0f3e06634a1..fe0c913674d 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1002,16 +1002,16 @@ workflows: name: binary_linux_wheel_py3.6_cu111 python_version: '3.6' wheel_docker_image: pytorch/manylinux-cuda111 - - binary_linux_wheel: - cu_version: rocm4.0.1 - name: binary_linux_wheel_py3.6_rocm4.0.1 - python_version: '3.6' - wheel_docker_image: pytorch/manylinux-rocm:4.0.1 - binary_linux_wheel: cu_version: rocm4.1 name: binary_linux_wheel_py3.6_rocm4.1 python_version: '3.6' wheel_docker_image: pytorch/manylinux-rocm:4.1 + - binary_linux_wheel: + cu_version: rocm4.2 + name: binary_linux_wheel_py3.6_rocm4.2 + python_version: '3.6' + wheel_docker_image: pytorch/manylinux-rocm:4.2 - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1030,16 +1030,16 @@ workflows: name: binary_linux_wheel_py3.7_cu111 python_version: '3.7' wheel_docker_image: pytorch/manylinux-cuda111 - - binary_linux_wheel: - cu_version: rocm4.0.1 - name: binary_linux_wheel_py3.7_rocm4.0.1 - python_version: '3.7' - wheel_docker_image: pytorch/manylinux-rocm:4.0.1 - binary_linux_wheel: cu_version: rocm4.1 name: binary_linux_wheel_py3.7_rocm4.1 python_version: '3.7' wheel_docker_image: pytorch/manylinux-rocm:4.1 + - binary_linux_wheel: + cu_version: rocm4.2 + name: binary_linux_wheel_py3.7_rocm4.2 + python_version: '3.7' + wheel_docker_image: pytorch/manylinux-rocm:4.2 - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1058,16 +1058,16 @@ workflows: name: binary_linux_wheel_py3.8_cu111 python_version: '3.8' wheel_docker_image: pytorch/manylinux-cuda111 - - binary_linux_wheel: - cu_version: rocm4.0.1 - name: binary_linux_wheel_py3.8_rocm4.0.1 - python_version: '3.8' - wheel_docker_image: pytorch/manylinux-rocm:4.0.1 - binary_linux_wheel: cu_version: rocm4.1 name: binary_linux_wheel_py3.8_rocm4.1 python_version: '3.8' wheel_docker_image: pytorch/manylinux-rocm:4.1 + - binary_linux_wheel: + cu_version: rocm4.2 + name: binary_linux_wheel_py3.8_rocm4.2 + python_version: '3.8' + wheel_docker_image: pytorch/manylinux-rocm:4.2 - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1086,16 +1086,16 @@ workflows: name: binary_linux_wheel_py3.9_cu111 python_version: '3.9' wheel_docker_image: pytorch/manylinux-cuda111 - - binary_linux_wheel: - cu_version: rocm4.0.1 - name: binary_linux_wheel_py3.9_rocm4.0.1 - python_version: '3.9' - wheel_docker_image: pytorch/manylinux-rocm:4.0.1 - binary_linux_wheel: cu_version: rocm4.1 name: binary_linux_wheel_py3.9_rocm4.1 python_version: '3.9' wheel_docker_image: pytorch/manylinux-rocm:4.1 + - binary_linux_wheel: + cu_version: rocm4.2 + name: binary_linux_wheel_py3.9_rocm4.2 + python_version: '3.9' + wheel_docker_image: pytorch/manylinux-rocm:4.2 - binary_macos_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1725,15 +1725,15 @@ workflows: requires: - nightly_binary_linux_wheel_py3.6_cu111_upload - binary_linux_wheel: - cu_version: rocm4.0.1 + cu_version: rocm4.1 filters: branches: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.6_rocm4.0.1 + name: nightly_binary_linux_wheel_py3.6_rocm4.1 python_version: '3.6' - wheel_docker_image: pytorch/manylinux-rocm:4.0.1 + wheel_docker_image: pytorch/manylinux-rocm:4.1 - binary_wheel_upload: context: org-member filters: @@ -1741,29 +1741,29 @@ workflows: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.6_rocm4.0.1_upload + name: nightly_binary_linux_wheel_py3.6_rocm4.1_upload requires: - - nightly_binary_linux_wheel_py3.6_rocm4.0.1 - subfolder: rocm4.0.1/ + - nightly_binary_linux_wheel_py3.6_rocm4.1 + subfolder: rocm4.1/ - smoke_test_linux_pip: filters: branches: only: - nightly - name: nightly_binary_linux_wheel_py3.6_rocm4.0.1_smoke_test_pip + name: nightly_binary_linux_wheel_py3.6_rocm4.1_smoke_test_pip python_version: '3.6' requires: - - nightly_binary_linux_wheel_py3.6_rocm4.0.1_upload + - nightly_binary_linux_wheel_py3.6_rocm4.1_upload - binary_linux_wheel: - cu_version: rocm4.1 + cu_version: rocm4.2 filters: branches: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.6_rocm4.1 + name: nightly_binary_linux_wheel_py3.6_rocm4.2 python_version: '3.6' - wheel_docker_image: pytorch/manylinux-rocm:4.1 + wheel_docker_image: pytorch/manylinux-rocm:4.2 - binary_wheel_upload: context: org-member filters: @@ -1771,19 +1771,19 @@ workflows: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.6_rocm4.1_upload + name: nightly_binary_linux_wheel_py3.6_rocm4.2_upload requires: - - nightly_binary_linux_wheel_py3.6_rocm4.1 - subfolder: rocm4.1/ + - nightly_binary_linux_wheel_py3.6_rocm4.2 + subfolder: rocm4.2/ - smoke_test_linux_pip: filters: branches: only: - nightly - name: nightly_binary_linux_wheel_py3.6_rocm4.1_smoke_test_pip + name: nightly_binary_linux_wheel_py3.6_rocm4.2_smoke_test_pip python_version: '3.6' requires: - - nightly_binary_linux_wheel_py3.6_rocm4.1_upload + - nightly_binary_linux_wheel_py3.6_rocm4.2_upload - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1878,15 +1878,15 @@ workflows: requires: - nightly_binary_linux_wheel_py3.7_cu111_upload - binary_linux_wheel: - cu_version: rocm4.0.1 + cu_version: rocm4.1 filters: branches: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.7_rocm4.0.1 + name: nightly_binary_linux_wheel_py3.7_rocm4.1 python_version: '3.7' - wheel_docker_image: pytorch/manylinux-rocm:4.0.1 + wheel_docker_image: pytorch/manylinux-rocm:4.1 - binary_wheel_upload: context: org-member filters: @@ -1894,29 +1894,29 @@ workflows: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.7_rocm4.0.1_upload + name: nightly_binary_linux_wheel_py3.7_rocm4.1_upload requires: - - nightly_binary_linux_wheel_py3.7_rocm4.0.1 - subfolder: rocm4.0.1/ + - nightly_binary_linux_wheel_py3.7_rocm4.1 + subfolder: rocm4.1/ - smoke_test_linux_pip: filters: branches: only: - nightly - name: nightly_binary_linux_wheel_py3.7_rocm4.0.1_smoke_test_pip + name: nightly_binary_linux_wheel_py3.7_rocm4.1_smoke_test_pip python_version: '3.7' requires: - - nightly_binary_linux_wheel_py3.7_rocm4.0.1_upload + - nightly_binary_linux_wheel_py3.7_rocm4.1_upload - binary_linux_wheel: - cu_version: rocm4.1 + cu_version: rocm4.2 filters: branches: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.7_rocm4.1 + name: nightly_binary_linux_wheel_py3.7_rocm4.2 python_version: '3.7' - wheel_docker_image: pytorch/manylinux-rocm:4.1 + wheel_docker_image: pytorch/manylinux-rocm:4.2 - binary_wheel_upload: context: org-member filters: @@ -1924,19 +1924,19 @@ workflows: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.7_rocm4.1_upload + name: nightly_binary_linux_wheel_py3.7_rocm4.2_upload requires: - - nightly_binary_linux_wheel_py3.7_rocm4.1 - subfolder: rocm4.1/ + - nightly_binary_linux_wheel_py3.7_rocm4.2 + subfolder: rocm4.2/ - smoke_test_linux_pip: filters: branches: only: - nightly - name: nightly_binary_linux_wheel_py3.7_rocm4.1_smoke_test_pip + name: nightly_binary_linux_wheel_py3.7_rocm4.2_smoke_test_pip python_version: '3.7' requires: - - nightly_binary_linux_wheel_py3.7_rocm4.1_upload + - nightly_binary_linux_wheel_py3.7_rocm4.2_upload - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -2031,15 +2031,15 @@ workflows: requires: - nightly_binary_linux_wheel_py3.8_cu111_upload - binary_linux_wheel: - cu_version: rocm4.0.1 + cu_version: rocm4.1 filters: branches: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.8_rocm4.0.1 + name: nightly_binary_linux_wheel_py3.8_rocm4.1 python_version: '3.8' - wheel_docker_image: pytorch/manylinux-rocm:4.0.1 + wheel_docker_image: pytorch/manylinux-rocm:4.1 - binary_wheel_upload: context: org-member filters: @@ -2047,29 +2047,29 @@ workflows: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.8_rocm4.0.1_upload + name: nightly_binary_linux_wheel_py3.8_rocm4.1_upload requires: - - nightly_binary_linux_wheel_py3.8_rocm4.0.1 - subfolder: rocm4.0.1/ + - nightly_binary_linux_wheel_py3.8_rocm4.1 + subfolder: rocm4.1/ - smoke_test_linux_pip: filters: branches: only: - nightly - name: nightly_binary_linux_wheel_py3.8_rocm4.0.1_smoke_test_pip + name: nightly_binary_linux_wheel_py3.8_rocm4.1_smoke_test_pip python_version: '3.8' requires: - - nightly_binary_linux_wheel_py3.8_rocm4.0.1_upload + - nightly_binary_linux_wheel_py3.8_rocm4.1_upload - binary_linux_wheel: - cu_version: rocm4.1 + cu_version: rocm4.2 filters: branches: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.8_rocm4.1 + name: nightly_binary_linux_wheel_py3.8_rocm4.2 python_version: '3.8' - wheel_docker_image: pytorch/manylinux-rocm:4.1 + wheel_docker_image: pytorch/manylinux-rocm:4.2 - binary_wheel_upload: context: org-member filters: @@ -2077,19 +2077,19 @@ workflows: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.8_rocm4.1_upload + name: nightly_binary_linux_wheel_py3.8_rocm4.2_upload requires: - - nightly_binary_linux_wheel_py3.8_rocm4.1 - subfolder: rocm4.1/ + - nightly_binary_linux_wheel_py3.8_rocm4.2 + subfolder: rocm4.2/ - smoke_test_linux_pip: filters: branches: only: - nightly - name: nightly_binary_linux_wheel_py3.8_rocm4.1_smoke_test_pip + name: nightly_binary_linux_wheel_py3.8_rocm4.2_smoke_test_pip python_version: '3.8' requires: - - nightly_binary_linux_wheel_py3.8_rocm4.1_upload + - nightly_binary_linux_wheel_py3.8_rocm4.2_upload - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -2184,15 +2184,15 @@ workflows: requires: - nightly_binary_linux_wheel_py3.9_cu111_upload - binary_linux_wheel: - cu_version: rocm4.0.1 + cu_version: rocm4.1 filters: branches: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.9_rocm4.0.1 + name: nightly_binary_linux_wheel_py3.9_rocm4.1 python_version: '3.9' - wheel_docker_image: pytorch/manylinux-rocm:4.0.1 + wheel_docker_image: pytorch/manylinux-rocm:4.1 - binary_wheel_upload: context: org-member filters: @@ -2200,29 +2200,29 @@ workflows: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.9_rocm4.0.1_upload + name: nightly_binary_linux_wheel_py3.9_rocm4.1_upload requires: - - nightly_binary_linux_wheel_py3.9_rocm4.0.1 - subfolder: rocm4.0.1/ + - nightly_binary_linux_wheel_py3.9_rocm4.1 + subfolder: rocm4.1/ - smoke_test_linux_pip: filters: branches: only: - nightly - name: nightly_binary_linux_wheel_py3.9_rocm4.0.1_smoke_test_pip + name: nightly_binary_linux_wheel_py3.9_rocm4.1_smoke_test_pip python_version: '3.9' requires: - - nightly_binary_linux_wheel_py3.9_rocm4.0.1_upload + - nightly_binary_linux_wheel_py3.9_rocm4.1_upload - binary_linux_wheel: - cu_version: rocm4.1 + cu_version: rocm4.2 filters: branches: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.9_rocm4.1 + name: nightly_binary_linux_wheel_py3.9_rocm4.2 python_version: '3.9' - wheel_docker_image: pytorch/manylinux-rocm:4.1 + wheel_docker_image: pytorch/manylinux-rocm:4.2 - binary_wheel_upload: context: org-member filters: @@ -2230,19 +2230,19 @@ workflows: only: nightly tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ - name: nightly_binary_linux_wheel_py3.9_rocm4.1_upload + name: nightly_binary_linux_wheel_py3.9_rocm4.2_upload requires: - - nightly_binary_linux_wheel_py3.9_rocm4.1 - subfolder: rocm4.1/ + - nightly_binary_linux_wheel_py3.9_rocm4.2 + subfolder: rocm4.2/ - smoke_test_linux_pip: filters: branches: only: - nightly - name: nightly_binary_linux_wheel_py3.9_rocm4.1_smoke_test_pip + name: nightly_binary_linux_wheel_py3.9_rocm4.2_smoke_test_pip python_version: '3.9' requires: - - nightly_binary_linux_wheel_py3.9_rocm4.1_upload + - nightly_binary_linux_wheel_py3.9_rocm4.2_upload - binary_macos_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py index b512fd55fae..5fea42c5b47 100755 --- a/.circleci/regenerate.py +++ b/.circleci/regenerate.py @@ -30,7 +30,7 @@ def build_workflows(prefix='', filter_branch=None, upload=False, indentation=6, for btype in ["wheel", "conda"]: for os_type in ["linux", "macos", "win"]: python_versions = PYTHON_VERSIONS - cu_versions_dict = {"linux": ["cpu", "cu102", "cu111", "rocm4.0.1", "rocm4.1"], + cu_versions_dict = {"linux": ["cpu", "cu102", "cu111", "rocm4.1", "rocm4.2"], "win": ["cpu", "cu102", "cu111"], "macos": ["cpu"]} cu_versions = cu_versions_dict[os_type] From 3c47bfdfb42d805ae18355cd59c609358fa1660c Mon Sep 17 00:00:00 2001 From: vfdev Date: Wed, 19 May 2021 15:58:06 +0200 Subject: [PATCH 069/279] Added CUDA support for interpolation AA bilinear/bicubic (#3842) * Added CUDA support for interpolation AA bilinear/bicubic * Fixed code formatting error * Fixed cuda tests on cpu-only builds * Fixed cuda internal torch check for bicubic mode --- test/test_functional_tensor.py | 19 +- .../csrc/ops/cuda/interpolate_aa_kernels.cu | 403 ++++++++++++++++++ 2 files changed, 420 insertions(+), 2 deletions(-) create mode 100644 torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 6fa455f6a6b..31a1c1a43e8 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -14,7 +14,7 @@ import torchvision.transforms as T from torchvision.transforms import InterpolationMode -from common_utils import TransformsTester, cpu_and_gpu +from common_utils import TransformsTester, cpu_and_gpu, needs_cuda from typing import Dict, List, Sequence, Tuple @@ -868,12 +868,14 @@ def test_perspective_interpolation_warning(tester): tester.assertTrue(res1.equal(res2)) -@pytest.mark.parametrize('device', ["cpu", ]) +@pytest.mark.parametrize('device', cpu_and_gpu()) @pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) @pytest.mark.parametrize('size', [[96, 72], [96, 420], [420, 72]]) @pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC]) def test_resize_antialias(device, dt, size, interpolation, tester): + torch.manual_seed(12) + if dt == torch.float16 and device == "cpu": # skip float16 on CPU case return @@ -924,6 +926,19 @@ def test_resize_antialias(device, dt, size, interpolation, tester): tester.assertTrue(resized_tensor.equal(resize_result), msg=f"{size}, {interpolation}, {dt}") +@needs_cuda +@pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC]) +def test_assert_resize_antialias(interpolation, tester): + + # Checks implementation on very large scales + # and catch TORCH_CHECK inside interpolate_aa_kernels.cu + torch.manual_seed(12) + tensor, pil_img = tester._create_data(1000, 1000, device="cuda") + + with pytest.raises(RuntimeError, match=r"Max supported scale factor is"): + F.resize(tensor, size=(5, 5), interpolation=interpolation, antialias=True) + + def check_functional_vs_PIL_vs_scripted(fn, fn_pil, fn_t, config, device, dtype, tol=2.0 + 1e-10, agg_method="max"): tester = Tester() diff --git a/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu b/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu new file mode 100644 index 00000000000..4259fa2b0e8 --- /dev/null +++ b/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu @@ -0,0 +1,403 @@ +#include +// Copied and adapted from +// Adapted from interp.cpp from Caffe util by Pauline Luc +// Originally developed by George Papandreou +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Below is experimental temporary code before merging it to PyTorch +namespace at { +namespace native { +namespace internal_upsample { + +__device__ __forceinline__ size_t +idx(const size_t nc, + const size_t height, + const size_t width, + const size_t y, + const size_t x) { + return (nc * height + y) * width + x; +} + +// taken from +// https://github.com/python-pillow/Pillow/blob/6812205f18ca4ef54372e87e1a13ce4a859434df/ +// src/libImaging/Resample.c#L20-L29 +template +__device__ __forceinline__ static accscalar_t bilinear_filter(accscalar_t x) { + if (x < 0.0) { + x = -x; + } + if (x < 1.0) { + return static_cast(1.0) - x; + } + return static_cast(0.0); +} + +// taken from +// https://github.com/python-pillow/Pillow/blob/6812205f18ca4ef54372e87e1a13ce4a859434df/ +// src/libImaging/Resample.c#L46-L62 +template +__device__ __forceinline__ static accscalar_t bicubic_filter(accscalar_t x) { + // https://en.wikipedia.org/wiki/Bicubic_interpolation#Bicubic_convolution_algorithm +#define a -0.5 + if (x < 0.0) { + x = -x; + } + if (x < 1.0) { + return ((a + 2.0) * x - (a + 3.0)) * x * x + static_cast(1.0); + } + if (x < 2.0) { + return (((x - 5) * x + 8) * x - 4) * a; + } + return static_cast(0.0); +#undef a +} + +template +__device__ __forceinline__ static void _compute_weights( + const int64_t i, + const int64_t input_size, + const accscalar_t scale, + const accscalar_t support, + scalar_t* wt_ptr, + int64_t interp_size, + filter_fn_t filter_fn, + int64_t& xmin, + int64_t& xmax) { + accscalar_t invscale = (scale >= 1.0) ? 1.0 / scale : 1.0; + accscalar_t center = scale * (i + 0.5); + xmin = max( + static_cast(center - support + 0.5), static_cast(0)); + xmax = min(static_cast(center + support + 0.5), input_size) - xmin; + + accscalar_t total_w = 0.0; + int64_t j = 0; + for (j = 0; j < xmax; j++) { + accscalar_t w = filter_fn((j + xmin - center + 0.5) * invscale); + wt_ptr[j] = static_cast(w); + total_w += w; + } + for (j = 0; j < xmax; j++) { + if (total_w != 0.0) { + wt_ptr[j] /= total_w; + } + } + for (; j < interp_size; j++) { + wt_ptr[j] = static_cast(0.0); + } +} + +template +__device__ __forceinline__ static accscalar_t interpolate_aa_single_dim( + scalar_t* src, + scalar_t* weights, + int64_t size) { + scalar_t t = static_cast(*src); + scalar_t wts = static_cast(weights[0]); + accscalar_t output = t * wts; + + int64_t j = 1; + for (; j < size; j++) { + wts = static_cast(weights[j]); + t = static_cast(*(src + j)); + output += t * wts; + } + return output; +} + +template +C10_LAUNCH_BOUNDS_1(1024) +__global__ void upsample_gen2d_out_frame( + const int n, + const accscalar_t rheight, + const accscalar_t rwidth, + const bool align_corners, + const PackedTensorAccessor64 idata, + PackedTensorAccessor64 odata) { + int index = threadIdx.x + blockIdx.x * blockDim.x; + + const int batchsize = idata.size(0); + const int channels = idata.size(1); + const int height1 = idata.size(2); + const int width1 = idata.size(3); + const int height2 = odata.size(2); + const int width2 = odata.size(3); + + if (index < n) { + const int w2 = index % width2; // 0:width2-1 + const int h2 = index / width2; // 0:height2-1 + // special case: just copy + if (height1 == height2 && width1 == width2) { + const int h1 = h2; + const int w1 = w2; + for (int n = 0; n < batchsize; n++) { + for (int c = 0; c < channels; ++c) { + const scalar_t val = idata[n][c][h1][w1]; + odata[n][c][h2][w2] = val; + } + } + return; + } + + const accscalar_t support_h = static_cast( + (rheight >= 1.0) ? (interp_size * 0.5) * rheight : interp_size * 0.5); + const accscalar_t support_w = static_cast( + (rwidth >= 1.0) ? (interp_size * 0.5) * rwidth : interp_size * 0.5); + + const int interp_height = (int)ceilf(support_h) * 2 + 1; + const int interp_width = (int)ceilf(support_w) * 2 + 1; + + // Setup local buffers + // TODO: maybe we can specify dynamic shared memory size before calling the + // cuda code, however we should then ensure that device has enough shared + // memory + scalar_t wx[256]; + scalar_t wy[256]; + scalar_t buffer1[256]; + scalar_t buffer2[256]; + + // Compute weights + int64_t xmin, xsize, ymin, ysize; + typedef scalar_t (*filter_fn_t)(scalar_t); + if (interp_size == 2) { + _compute_weights( + w2, + width1, + rwidth, + support_w, + wx, + interp_width, + bilinear_filter, + xmin, + xsize); + _compute_weights( + h2, + height1, + rheight, + support_h, + wy, + interp_height, + bilinear_filter, + ymin, + ysize); + } else if (interp_size == 4) { + _compute_weights( + w2, + width1, + rwidth, + support_w, + wx, + interp_width, + bicubic_filter, + xmin, + xsize); + _compute_weights( + h2, + height1, + rheight, + support_h, + wy, + interp_height, + bicubic_filter, + ymin, + ysize); + } + + for (int n = 0; n < batchsize; n++) { + for (int c = 0; c < channels; ++c) { + // interpolate on x-axis for ymin to ymin + ysize + for (int64_t y = 0; y < ysize; y++) { + // copy data into the local buffer and use + // interpolate_aa_single_dim method + for (int x = 0; x < xsize; x++) { + buffer1[x] = idata[n][c][ymin + y][xmin + x]; + } + + buffer2[y] = static_cast( + interpolate_aa_single_dim( + buffer1, wx, xsize)); + } + odata[n][c][h2][w2] = static_cast( + interpolate_aa_single_dim( + buffer2, wy, ysize)); + } + } + } +} + +template +static void upsample_gen2d_out_cuda_template( + const Tensor& output, + const Tensor& input, + IntArrayRef output_size, + bool align_corners, + c10::optional scales_h, + c10::optional scales_w) { + TensorArg input_arg{input, "input", 1}, output_arg{output, "output", 2}; + checkAllSameGPU("upsample_gen2d_out_cuda", {input_arg, output_arg}); + + int output_height = output_size[0]; + int output_width = output_size[1]; + + int nbatch = input.size(0); + int channels = input.size(1); + int input_height = input.size(2); + int input_width = input.size(3); + + const int num_kernels = output_height * output_width; + const int num_threads = std::min( + at::cuda::getCurrentDeviceProperties()->maxThreadsPerBlock, 1024); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + input.scalar_type(), "upsample_bilinear2d_out_frame", [&] { + using accscalar_t = at::acc_type; + + auto idata = input.packed_accessor64(); + auto odata = output.packed_accessor64(); + + const accscalar_t rheight = area_pixel_compute_scale( + input_height, output_height, align_corners, scales_h); + const accscalar_t rwidth = area_pixel_compute_scale( + input_width, output_width, align_corners, scales_w); + + // We are using static buffer memory of 256 * sizeof(float) per thread + // to store weights. Size of weights array is + // interp_size = scale * 2 + 1 for bilinear mode + TORCH_CHECK( + rheight < (255 / interp_size), + "Max supported scale factor is 127 (bilinear), 63 (bicubic)"); + TORCH_CHECK( + rwidth < (255 / interp_size), + "Max supported scale factor is 127 (bilinear), 63 (bicubic)"); + + upsample_gen2d_out_frame + <<>>( + num_kernels, rheight, rwidth, align_corners, idata, odata); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + }); +} + +} // namespace internal_upsample +} // namespace native +} // namespace at + +namespace vision { +namespace ops { + +namespace { + +// Copied from "UpSample.h" as we can not use UpSample.h with UpSample.cuh +static std::array upsample_2d_common_check( + at::IntArrayRef input_size, + at::IntArrayRef output_size) { + TORCH_CHECK( + output_size.size() == 2, + "It is expected output_size equals to 2, but got size ", + output_size.size()); + + TORCH_CHECK( + input_size.size() == 4, + "It is expected input_size equals to 4, but got size ", + input_size.size()); + + int64_t output_height = output_size[0]; + int64_t output_width = output_size[1]; + + int64_t nbatch = input_size[0]; + int64_t channels = input_size[1]; + int64_t input_height = input_size[2]; + int64_t input_width = input_size[3]; + + TORCH_CHECK( + input_height > 0 && input_width > 0 && output_height > 0 && + output_width > 0, + "Input and output sizes should be greater than 0," + " but got input (H: ", + input_height, + ", W: ", + input_width, + ") output (H: ", + output_height, + ", W: ", + output_width, + ")"); + + return {nbatch, channels, output_height, output_width}; +} + +template +at::Tensor interpolate_gen2d_aa_forward_kernel( + const at::Tensor& input, + at::IntArrayRef output_size, + bool align_corners) { + c10::optional> scale_factors = {}; + + // Copied from UpSampleBilinear2d.cpp + auto output = at::empty({0}, input.options()); + auto osize = at::native::upsample::compute_output_size( + input.sizes(), output_size, scale_factors); + auto scale_h = at::native::upsample_cuda::get_scale_value(scale_factors, 0); + auto scale_w = at::native::upsample_cuda::get_scale_value(scale_factors, 1); + + auto full_output_size = upsample_2d_common_check(input.sizes(), osize); + + // Allow for empty batch size but not other dimensions + TORCH_CHECK( + input.numel() != 0 || + c10::multiply_integers( + input.sizes().begin() + 1, input.sizes().end()), + "Non-empty 4D data tensor expected but got a tensor with sizes ", + input.sizes()); + + output.resize_(full_output_size, input.suggest_memory_format()); + + at::native::internal_upsample::upsample_gen2d_out_cuda_template( + output, + input, + {full_output_size[2], full_output_size[3]}, + align_corners, + scale_h, + scale_w); + return output; +} + +at::Tensor interpolate_linear_aa_forward_kernel( + const at::Tensor& input, + at::IntArrayRef output_size, + bool align_corners) { + return interpolate_gen2d_aa_forward_kernel<2>( + input, output_size, align_corners); +} + +at::Tensor interpolate_bicubic_aa_forward_kernel( + const at::Tensor& input, + at::IntArrayRef output_size, + bool align_corners) { + return interpolate_gen2d_aa_forward_kernel<4>( + input, output_size, align_corners); +} + +} // namespace + +TORCH_LIBRARY_IMPL(torchvision, CUDA, m) { + m.impl( + TORCH_SELECTIVE_NAME("torchvision::_interpolate_linear_aa"), + TORCH_FN(interpolate_linear_aa_forward_kernel)); + m.impl( + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bicubic_aa"), + TORCH_FN(interpolate_bicubic_aa_forward_kernel)); +} + +} // namespace ops +} // namespace vision From 59c6731897c2b8c48431136515ee80d235c9c2d1 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Wed, 19 May 2021 17:00:28 +0100 Subject: [PATCH 070/279] Updated all_gather() to make use of all_gather_object() (#3857) --- references/detection/utils.py | 37 ++++------------------------------- 1 file changed, 4 insertions(+), 33 deletions(-) diff --git a/references/detection/utils.py b/references/detection/utils.py index 82ae79bc3fb..3c52abb2167 100644 --- a/references/detection/utils.py +++ b/references/detection/utils.py @@ -1,14 +1,12 @@ from collections import defaultdict, deque import datetime -import pickle +import errno +import os import time import torch import torch.distributed as dist -import errno -import os - class SmoothedValue(object): """Track a series of values and provide access to smoothed values over a @@ -83,35 +81,8 @@ def all_gather(data): world_size = get_world_size() if world_size == 1: return [data] - - # serialized to a Tensor - buffer = pickle.dumps(data) - storage = torch.ByteStorage.from_buffer(buffer) - tensor = torch.ByteTensor(storage).to("cuda") - - # obtain Tensor size of each rank - local_size = torch.tensor([tensor.numel()], device="cuda") - size_list = [torch.tensor([0], device="cuda") for _ in range(world_size)] - dist.all_gather(size_list, local_size) - size_list = [int(size.item()) for size in size_list] - max_size = max(size_list) - - # receiving Tensor from all ranks - # we pad the tensor because torch all_gather does not support - # gathering tensors of different shapes - tensor_list = [] - for _ in size_list: - tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device="cuda")) - if local_size != max_size: - padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device="cuda") - tensor = torch.cat((tensor, padding), dim=0) - dist.all_gather(tensor_list, tensor) - - data_list = [] - for size, tensor in zip(size_list, tensor_list): - buffer = tensor.cpu().numpy().tobytes()[:size] - data_list.append(pickle.loads(buffer)) - + data_list = [None] * world_size + dist.all_gather_object(data_list, data) return data_list From 6a543019976a623c7f448d2d2613ae449be1839e Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Thu, 20 May 2021 10:23:06 +0100 Subject: [PATCH 071/279] fbcode-friendly tests for nvjpeg decoding (#3860) --- test/test_image.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/test/test_image.py b/test/test_image.py index 11c8f3d7a03..4ed001c61f7 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -280,8 +280,15 @@ def test_write_file_non_ascii(self): @needs_cuda +@pytest.mark.parametrize('img_path', [ + # We need to change the "id" for that parameter. + # If we don't, the test id (i.e. its name) will contain the whole path to the image which is machine-specific, + # and this creates issues when the test is running in a different machine than where it was collected + # (typically, in fb internal infra) + pytest.param(jpeg_path, id=jpeg_path.split('/')[-1]) + for jpeg_path in get_images(IMAGE_ROOT, ".jpg") +]) @pytest.mark.parametrize('mode', [ImageReadMode.UNCHANGED, ImageReadMode.GRAY, ImageReadMode.RGB]) -@pytest.mark.parametrize('img_path', get_images(IMAGE_ROOT, ".jpg")) @pytest.mark.parametrize('scripted', (False, True)) def test_decode_jpeg_cuda(mode, img_path, scripted): if 'cmyk' in img_path: From 26e34735bc935b0d54588dc32358171390ab593b Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Thu, 20 May 2021 12:38:12 +0100 Subject: [PATCH 072/279] [FBcode->GH] Added url to class mapping logic to manifold download (#3864) Reviewed By: fmassa Differential Revision: D28537606 fbshipit-source-id: beaf15f4e38a7d986ef26587383aa2aee3e48952 --- torchvision/datasets/_utils.py | 2 +- torchvision/datasets/utils.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/torchvision/datasets/_utils.py b/torchvision/datasets/_utils.py index d0664d50d54..5661b31a4b9 100644 --- a/torchvision/datasets/_utils.py +++ b/torchvision/datasets/_utils.py @@ -1,4 +1,4 @@ -def _download_file_from_remote_location(fpath: str) -> None: +def _download_file_from_remote_location(fpath: str, url: str) -> None: pass diff --git a/torchvision/datasets/utils.py b/torchvision/datasets/utils.py index 36d6f8e657e..e6798bd4500 100644 --- a/torchvision/datasets/utils.py +++ b/torchvision/datasets/utils.py @@ -123,7 +123,7 @@ def download_url( return if _is_remote_location_available(): - _download_file_from_remote_location(fpath) + _download_file_from_remote_location(fpath, url) else: # expand redirect chain if needed url = _get_redirect_url(url, max_hops=max_redirect_hops) From b0601631ecd1afb841a312329d976c4c4a966acd Mon Sep 17 00:00:00 2001 From: Zhiqiang Wang Date: Fri, 21 May 2021 01:07:10 +0800 Subject: [PATCH 073/279] Make target argument in transform.py truly optional (#3866) --- torchvision/models/detection/transform.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/torchvision/models/detection/transform.py b/torchvision/models/detection/transform.py index 55cfb483847..0ca5273e047 100644 --- a/torchvision/models/detection/transform.py +++ b/torchvision/models/detection/transform.py @@ -24,8 +24,9 @@ def _fake_cast_onnx(v): def _resize_image_and_masks(image: Tensor, self_min_size: float, self_max_size: float, - target: Optional[Dict[str, Tensor]], - fixed_size: Optional[Tuple[int, int]]) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]: + target: Optional[Dict[str, Tensor]] = None, + fixed_size: Optional[Tuple[int, int]] = None, + ) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]: if torchvision._is_tracing(): im_shape = _get_shape_onnx(image) else: @@ -146,8 +147,10 @@ def torch_choice(self, k): index = int(torch.empty(1).uniform_(0., float(len(k))).item()) return k[index] - def resize(self, image, target): - # type: (Tensor, Optional[Dict[str, Tensor]]) -> Tuple[Tensor, Optional[Dict[str, Tensor]]] + def resize(self, + image: Tensor, + target: Optional[Dict[str, Tensor]] = None, + ) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]: h, w = image.shape[-2:] if self.training: size = float(self.torch_choice(self.min_size)) From 7b87af25ba03c2cd2579a66b6c2945624b25a277 Mon Sep 17 00:00:00 2001 From: Sofiane Abbar Date: Thu, 20 May 2021 19:40:56 +0100 Subject: [PATCH 074/279] replaced deprecated call to ByteTensor with from_numpy (#3813) replaced byteTensor with from_numpy fixed lint issues and copy related worning Co-authored-by: Sofiane Abbar Co-authored-by: Vasilis Vryniotis --- torchvision/transforms/functional.py | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/torchvision/transforms/functional.py b/torchvision/transforms/functional.py index 5bbd91b3fd8..6a86a000d65 100644 --- a/torchvision/transforms/functional.py +++ b/torchvision/transforms/functional.py @@ -124,17 +124,13 @@ def to_tensor(pic): return torch.from_numpy(nppic).to(dtype=default_float_dtype) # handle PIL Image - if pic.mode == 'I': - img = torch.from_numpy(np.array(pic, np.int32, copy=False)) - elif pic.mode == 'I;16': - img = torch.from_numpy(np.array(pic, np.int16, copy=False)) - elif pic.mode == 'F': - img = torch.from_numpy(np.array(pic, np.float32, copy=False)) - elif pic.mode == '1': - img = 255 * torch.from_numpy(np.array(pic, np.uint8, copy=False)) - else: - img = torch.ByteTensor(torch.ByteStorage.from_buffer(pic.tobytes())) + mode_to_nptype = {'I': np.int32, 'I;16': np.int16, 'F': np.float32} + img = torch.from_numpy( + np.array(pic, mode_to_nptype.get(pic.mode, np.uint8), copy=True) + ) + if pic.mode == '1': + img = 255 * img img = img.view(pic.size[1], pic.size[0], len(pic.getbands())) # put it from HWC to CHW format img = img.permute((2, 0, 1)).contiguous() From 952267800f7060834ce8732c434d876dd05e526b Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Fri, 21 May 2021 10:08:41 +0200 Subject: [PATCH 075/279] Remove obsolete test_datasets_transforms.py (#3867) --- test/test_datasets_transforms.py | 72 -------------------------------- 1 file changed, 72 deletions(-) delete mode 100644 test/test_datasets_transforms.py diff --git a/test/test_datasets_transforms.py b/test/test_datasets_transforms.py deleted file mode 100644 index 6cffd4f76a9..00000000000 --- a/test/test_datasets_transforms.py +++ /dev/null @@ -1,72 +0,0 @@ -import os -import shutil -import contextlib -import tempfile -import unittest -from torchvision.datasets import ImageFolder - -FAKEDATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), - 'assets', 'fakedata') - - -@contextlib.contextmanager -def tmp_dir(src=None, **kwargs): - tmp_dir = tempfile.mkdtemp(**kwargs) - if src is not None: - os.rmdir(tmp_dir) - shutil.copytree(src, tmp_dir) - try: - yield tmp_dir - finally: - shutil.rmtree(tmp_dir) - - -def mock_transform(return_value, arg_list): - def mock(arg): - arg_list.append(arg) - return return_value - return mock - - -class Tester(unittest.TestCase): - def test_transform(self): - with tmp_dir(src=os.path.join(FAKEDATA_DIR, 'imagefolder')) as root: - class_a_image_files = [os.path.join(root, 'a', file) - for file in ('a1.png', 'a2.png', 'a3.png')] - class_b_image_files = [os.path.join(root, 'b', file) - for file in ('b1.png', 'b2.png', 'b3.png', 'b4.png')] - return_value = os.path.join(root, 'a', 'a1.png') - args = [] - transform = mock_transform(return_value, args) - dataset = ImageFolder(root, loader=lambda x: x, transform=transform) - - outputs = [dataset[i][0] for i in range(len(dataset))] - self.assertEqual([return_value] * len(outputs), outputs) - - imgs = sorted(class_a_image_files + class_b_image_files) - self.assertEqual(imgs, sorted(args)) - - def test_target_transform(self): - with tmp_dir(src=os.path.join(FAKEDATA_DIR, 'imagefolder')) as root: - class_a_image_files = [os.path.join(root, 'a', file) - for file in ('a1.png', 'a2.png', 'a3.png')] - class_b_image_files = [os.path.join(root, 'b', file) - for file in ('b1.png', 'b2.png', 'b3.png', 'b4.png')] - return_value = os.path.join(root, 'a', 'a1.png') - args = [] - target_transform = mock_transform(return_value, args) - dataset = ImageFolder(root, loader=lambda x: x, - target_transform=target_transform) - - outputs = [dataset[i][1] for i in range(len(dataset))] - self.assertEqual([return_value] * len(outputs), outputs) - - class_a_idx = dataset.class_to_idx['a'] - class_b_idx = dataset.class_to_idx['b'] - targets = sorted([class_a_idx] * len(class_a_image_files) + - [class_b_idx] * len(class_b_image_files)) - self.assertEqual(targets, sorted(args)) - - -if __name__ == '__main__': - unittest.main() From 91d9797e564229fc5e94892c98f38ad080db1a7b Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 21 May 2021 10:47:16 +0100 Subject: [PATCH 076/279] Change CI cuda versions to 10.2 (#3869) * Change cuda versions. * changing cu_version * patching regenerate.py * more changes. --- .circleci/config.yml | 32 ++++++++++++++++---------------- .circleci/config.yml.in | 10 +++++----- .circleci/regenerate.py | 6 +++--- 3 files changed, 24 insertions(+), 24 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index fe0c913674d..85a2e273de5 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -133,7 +133,7 @@ binary_common: &binary_common wheel_docker_image: description: "Wheel only: what docker image to use" type: string - default: "pytorch/manylinux-cuda101" + default: "pytorch/manylinux-cuda102" conda_docker_image: description: "Conda only: what docker image to use" type: string @@ -660,10 +660,10 @@ jobs: unittest_linux_gpu: <<: *binary_common machine: - image: ubuntu-1604-cuda-10.1:201909-23 + image: ubuntu-1604-cuda-10.2:202012-01 resource_class: gpu.small environment: - image_name: "pytorch/manylinux-cuda101" + image_name: "pytorch/manylinux-cuda102" PYTHON_VERSION: << parameters.python_version >> steps: - checkout @@ -743,7 +743,7 @@ jobs: executor: name: windows-gpu environment: - CUDA_VERSION: "10.1" + CUDA_VERSION: "10.2" PYTHON_VERSION: << parameters.python_version >> steps: - checkout @@ -839,7 +839,7 @@ jobs: cmake_linux_gpu: <<: *binary_common machine: - image: ubuntu-1604-cuda-10.1:201909-23 + image: ubuntu-1604-cuda-10.2:202012-01 resource_class: gpu.small environment: PYTHON_VERSION: << parameters.python_version >> @@ -1468,7 +1468,7 @@ workflows: name: unittest_linux_cpu_py3.9 python_version: '3.9' - unittest_linux_gpu: - cu_version: cu101 + cu_version: cu102 filters: branches: only: @@ -1477,7 +1477,7 @@ workflows: name: unittest_linux_gpu_py3.6 python_version: '3.6' - unittest_linux_gpu: - cu_version: cu101 + cu_version: cu102 filters: branches: only: @@ -1486,11 +1486,11 @@ workflows: name: unittest_linux_gpu_py3.7 python_version: '3.7' - unittest_linux_gpu: - cu_version: cu101 + cu_version: cu102 name: unittest_linux_gpu_py3.8 python_version: '3.8' - unittest_linux_gpu: - cu_version: cu101 + cu_version: cu102 filters: branches: only: @@ -1515,7 +1515,7 @@ workflows: name: unittest_windows_cpu_py3.9 python_version: '3.9' - unittest_windows_gpu: - cu_version: cu101 + cu_version: cu102 filters: branches: only: @@ -1524,7 +1524,7 @@ workflows: name: unittest_windows_gpu_py3.6 python_version: '3.6' - unittest_windows_gpu: - cu_version: cu101 + cu_version: cu102 filters: branches: only: @@ -1533,11 +1533,11 @@ workflows: name: unittest_windows_gpu_py3.7 python_version: '3.7' - unittest_windows_gpu: - cu_version: cu101 + cu_version: cu102 name: unittest_windows_gpu_py3.8 python_version: '3.8' - unittest_windows_gpu: - cu_version: cu101 + cu_version: cu102 filters: branches: only: @@ -1569,16 +1569,16 @@ workflows: name: cmake_linux_cpu python_version: '3.8' - cmake_linux_gpu: - cu_version: cu101 + cu_version: cu102 name: cmake_linux_gpu python_version: '3.8' - wheel_docker_image: pytorch/manylinux-cuda101 + wheel_docker_image: pytorch/manylinux-cuda102 - cmake_windows_cpu: cu_version: cpu name: cmake_windows_cpu python_version: '3.8' - cmake_windows_gpu: - cu_version: cu101 + cu_version: cu102 name: cmake_windows_gpu python_version: '3.8' - cmake_macos_cpu: diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 3471b776a2f..992985d8550 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -133,7 +133,7 @@ binary_common: &binary_common wheel_docker_image: description: "Wheel only: what docker image to use" type: string - default: "pytorch/manylinux-cuda101" + default: "pytorch/manylinux-cuda102" conda_docker_image: description: "Conda only: what docker image to use" type: string @@ -660,10 +660,10 @@ jobs: unittest_linux_gpu: <<: *binary_common machine: - image: ubuntu-1604-cuda-10.1:201909-23 + image: ubuntu-1604-cuda-10.2:202012-01 resource_class: gpu.small environment: - image_name: "pytorch/manylinux-cuda101" + image_name: "pytorch/manylinux-cuda102" PYTHON_VERSION: << parameters.python_version >> steps: - checkout @@ -743,7 +743,7 @@ jobs: executor: name: windows-gpu environment: - CUDA_VERSION: "10.1" + CUDA_VERSION: "10.2" PYTHON_VERSION: << parameters.python_version >> steps: - checkout @@ -839,7 +839,7 @@ jobs: cmake_linux_gpu: <<: *binary_common machine: - image: ubuntu-1604-cuda-10.1:201909-23 + image: ubuntu-1604-cuda-10.2:202012-01 resource_class: gpu.small environment: PYTHON_VERSION: << parameters.python_version >> diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py index 5fea42c5b47..db6b44c089a 100755 --- a/.circleci/regenerate.py +++ b/.circleci/regenerate.py @@ -234,7 +234,7 @@ def unittest_workflows(indentation=6): if device_type == 'gpu': if python_version != "3.8": job['filters'] = gen_filter_branch_tree('master', 'nightly') - job['cu_version'] = 'cu101' + job['cu_version'] = 'cu102' else: job['cu_version'] = 'cpu' @@ -255,9 +255,9 @@ def cmake_workflows(indentation=6): 'python_version': python_version } - job['cu_version'] = 'cu101' if device == 'gpu' else 'cpu' + job['cu_version'] = 'cu102' if device == 'gpu' else 'cpu' if device == 'gpu' and os_type == 'linux': - job['wheel_docker_image'] = 'pytorch/manylinux-cuda101' + job['wheel_docker_image'] = 'pytorch/manylinux-cuda102' jobs.append({f'cmake_{os_type}_{device}': job}) return indent(indentation, jobs) From dba5cf31d7b2d851945f3fbf7425d5850a491dfd Mon Sep 17 00:00:00 2001 From: Aditya Oke <47158509+oke-aditya@users.noreply.github.com> Date: Fri, 21 May 2021 15:41:13 +0530 Subject: [PATCH 077/279] Add copy button and automatic cross-refs to external projects in docs (#3868) --- docs/requirements.txt | 1 + docs/source/conf.py | 9 +++++---- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 778c2880bb8..68efe2cb639 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,5 +1,6 @@ sphinx==2.4.4 sphinx-gallery>=0.9.0 +sphinx-copybutton>=0.3.1 matplotlib numpy -e git+git://github.com/pytorch/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme diff --git a/docs/source/conf.py b/docs/source/conf.py index 7345f5eef86..216557d269e 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -21,10 +21,6 @@ # import sys # sys.path.insert(0, os.path.abspath('.')) -from pathlib import Path -import os - -import torch import torchvision import pytorch_sphinx_theme @@ -48,7 +44,9 @@ 'sphinx.ext.mathjax', 'sphinx.ext.napoleon', 'sphinx.ext.viewcode', + 'sphinx.ext.duration', 'sphinx_gallery.gen_gallery', + "sphinx_copybutton" ] sphinx_gallery_conf = { @@ -202,7 +200,10 @@ # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = { 'python': ('https://docs.python.org/', None), + 'torch': ('https://pytorch.org/docs/stable/', None), 'numpy': ('http://docs.scipy.org/doc/numpy/', None), + 'PIL': ('https://pillow.readthedocs.io/en/stable/', None), + 'matplotlib': ('https://matplotlib.org/stable/', None), } # -- A patch that prevents Sphinx from cross-referencing ivar tags ------- From 1a10a9a8e3e67e2faf8111a58755431620954dbf Mon Sep 17 00:00:00 2001 From: Bruno Korbar Date: Fri, 21 May 2021 11:26:33 +0100 Subject: [PATCH 078/279] remove deprecated function call (#3858) Co-authored-by: Prabhat Roy --- torchvision/csrc/io/decoder/stream.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/csrc/io/decoder/stream.cpp b/torchvision/csrc/io/decoder/stream.cpp index e924ea6a3d1..37dd5805d5a 100644 --- a/torchvision/csrc/io/decoder/stream.cpp +++ b/torchvision/csrc/io/decoder/stream.cpp @@ -232,7 +232,7 @@ void Stream::setFramePts(DecoderHeader* header, bool flush) { if (flush) { header->pts = nextPts_; // already in us } else { - header->pts = av_frame_get_best_effort_timestamp(frame_); + header->pts = frame_->best_effort_timestamp; if (header->pts == AV_NOPTS_VALUE) { header->pts = nextPts_; } else { From 231f80d5a910d76958560350bcf502d53eabc312 Mon Sep 17 00:00:00 2001 From: Bruno Korbar Date: Fri, 21 May 2021 11:29:50 +0100 Subject: [PATCH 079/279] remove deprecated function calls (#3859) Co-authored-by: Prabhat Roy --- torchvision/csrc/io/decoder/util.cpp | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/torchvision/csrc/io/decoder/util.cpp b/torchvision/csrc/io/decoder/util.cpp index 774612d3927..658876ff600 100644 --- a/torchvision/csrc/io/decoder/util.cpp +++ b/torchvision/csrc/io/decoder/util.cpp @@ -49,8 +49,8 @@ inline size_t getSize(const AVSubtitleRect& x) { switch (y.type) { case SUBTITLE_BITMAP: for (int i = 0; i < y.nb_colors; ++i) { - s += sizeof(y.pict.linesize[i]); - s += y.pict.linesize[i]; + s += sizeof(y.linesize[i]); + s += y.linesize[i]; } break; case SUBTITLE_TEXT: @@ -93,14 +93,14 @@ inline bool serializeItem( switch (x.type) { case SUBTITLE_BITMAP: for (int i = 0; i < x.nb_colors; ++i) { - if (!serializeItem(d, l, p, x.pict.linesize[i])) { + if (!serializeItem(d, l, p, x.linesize[i])) { return false; } - if (p + x.pict.linesize[i] > l) { + if (p + x.linesize[i] > l) { return false; } - memcpy(d + p, x.pict.data[i], x.pict.linesize[i]); - p += x.pict.linesize[i]; + memcpy(d + p, x.data[i], x.linesize[i]); + p += x.linesize[i]; } return true; case SUBTITLE_TEXT: { @@ -172,15 +172,15 @@ inline bool deserializeItem( switch (x.type) { case SUBTITLE_BITMAP: for (int i = 0; i < x.nb_colors; ++i) { - if (!deserializeItem(y, l, p, x.pict.linesize[i])) { + if (!deserializeItem(y, l, p, x.linesize[i])) { return false; } - if (p + x.pict.linesize[i] > l) { + if (p + x.linesize[i] > l) { return false; } - x.pict.data[i] = (uint8_t*)av_malloc(x.pict.linesize[i]); - memcpy(x.pict.data[i], y + p, x.pict.linesize[i]); - p += x.pict.linesize[i]; + x.data[i] = (uint8_t*)av_malloc(x.linesize[i]); + memcpy(x.data[i], y + p, x.linesize[i]); + p += x.linesize[i]; } return true; case SUBTITLE_TEXT: { From 89cb9083fef990c08ccab6dc7f9b51bcbe13b5d9 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 11:35:12 +0100 Subject: [PATCH 080/279] Add new assert_equal test util based on torch.testing.assert_close (#3872) Co-authored-by: Philip Meier --- test/_assert_utils.py | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 test/_assert_utils.py diff --git a/test/_assert_utils.py b/test/_assert_utils.py new file mode 100644 index 00000000000..e766e2df4b8 --- /dev/null +++ b/test/_assert_utils.py @@ -0,0 +1,11 @@ +"""This is a temporary module and should be removed as soon as torch.testing.assert_equal is supported.""" +# TODO: remove this as soon torch.testing.assert_equal is supported + +import functools + +import torch.testing + +__all__ = ["assert_equal"] + + +assert_equal = functools.partial(torch.testing.assert_close, rtol=0, atol=0) From c4685e81635f120ed329020cb90c6a2a3637620b Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 21 May 2021 13:44:49 +0100 Subject: [PATCH 081/279] Moving tensors to the right device (#3870) * Moving tensors to the right device. * Switch to gpu.medium --- .circleci/config.yml | 2 +- .circleci/config.yml.in | 2 +- torchvision/models/detection/roi_heads.py | 2 +- torchvision/transforms/functional_tensor.py | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 85a2e273de5..fcbc37c33f5 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -661,7 +661,7 @@ jobs: <<: *binary_common machine: image: ubuntu-1604-cuda-10.2:202012-01 - resource_class: gpu.small + resource_class: gpu.nvidia.medium environment: image_name: "pytorch/manylinux-cuda102" PYTHON_VERSION: << parameters.python_version >> diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 992985d8550..0fccf9d6764 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -661,7 +661,7 @@ jobs: <<: *binary_common machine: image: ubuntu-1604-cuda-10.2:202012-01 - resource_class: gpu.small + resource_class: gpu.nvidia.medium environment: image_name: "pytorch/manylinux-cuda102" PYTHON_VERSION: << parameters.python_version >> diff --git a/torchvision/models/detection/roi_heads.py b/torchvision/models/detection/roi_heads.py index 5be5cd81853..9948d5f537f 100644 --- a/torchvision/models/detection/roi_heads.py +++ b/torchvision/models/detection/roi_heads.py @@ -274,7 +274,7 @@ def heatmaps_to_keypoints(maps, rois): xy_preds[i, 0, :] = x + offset_x[i] xy_preds[i, 1, :] = y + offset_y[i] xy_preds[i, 2, :] = 1 - end_scores[i, :] = roi_map[torch.arange(num_keypoints), y_int, x_int] + end_scores[i, :] = roi_map[torch.arange(num_keypoints, device=roi_map.device), y_int, x_int] return xy_preds.permute(0, 2, 1), end_scores diff --git a/torchvision/transforms/functional_tensor.py b/torchvision/transforms/functional_tensor.py index 57a0b75fdd2..a0e32d4237e 100644 --- a/torchvision/transforms/functional_tensor.py +++ b/torchvision/transforms/functional_tensor.py @@ -391,12 +391,12 @@ def _pad_symmetric(img: Tensor, padding: List[int]) -> Tensor: x_indices = [i for i in range(in_sizes[-1])] # [0, 1, 2, 3, ...] left_indices = [i for i in range(padding[0] - 1, -1, -1)] # e.g. [3, 2, 1, 0] right_indices = [-(i + 1) for i in range(padding[1])] # e.g. [-1, -2, -3] - x_indices = torch.tensor(left_indices + x_indices + right_indices) + x_indices = torch.tensor(left_indices + x_indices + right_indices, device=img.device) y_indices = [i for i in range(in_sizes[-2])] top_indices = [i for i in range(padding[2] - 1, -1, -1)] bottom_indices = [-(i + 1) for i in range(padding[3])] - y_indices = torch.tensor(top_indices + y_indices + bottom_indices) + y_indices = torch.tensor(top_indices + y_indices + bottom_indices, device=img.device) ndim = img.ndim if ndim == 3: From 05a3941f94e0f5c162a80beff13365a607e08edb Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 14:38:47 +0100 Subject: [PATCH 082/279] Use torch.testing.assert_close in test_datasets_samplers.py (#3874) Co-authored-by: Philip Meier --- test/test_datasets_samplers.py | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/test/test_datasets_samplers.py b/test/test_datasets_samplers.py index e76f4f9d007..10d8704dbb1 100644 --- a/test/test_datasets_samplers.py +++ b/test/test_datasets_samplers.py @@ -14,6 +14,7 @@ from torchvision import get_video_backend from common_utils import get_tmp_dir +from _assert_utils import assert_equal @contextlib.contextmanager @@ -47,8 +48,8 @@ def test_random_clip_sampler(self): indices = torch.tensor(list(iter(sampler))) videos = torch.div(indices, 5, rounding_mode='floor') v_idxs, count = torch.unique(videos, return_counts=True) - self.assertTrue(v_idxs.equal(torch.tensor([0, 1, 2]))) - self.assertTrue(count.equal(torch.tensor([3, 3, 3]))) + assert_equal(v_idxs, torch.tensor([0, 1, 2])) + assert_equal(count, torch.tensor([3, 3, 3])) def test_random_clip_sampler_unequal(self): with get_list_of_videos(num_videos=3, sizes=[10, 25, 25]) as video_list: @@ -64,8 +65,8 @@ def test_random_clip_sampler_unequal(self): indices = torch.tensor(indices) - 2 videos = torch.div(indices, 5, rounding_mode='floor') v_idxs, count = torch.unique(videos, return_counts=True) - self.assertTrue(v_idxs.equal(torch.tensor([0, 1]))) - self.assertTrue(count.equal(torch.tensor([3, 3]))) + assert_equal(v_idxs, torch.tensor([0, 1])) + assert_equal(count, torch.tensor([3, 3])) def test_uniform_clip_sampler(self): with get_list_of_videos(num_videos=3, sizes=[25, 25, 25]) as video_list: @@ -75,9 +76,9 @@ def test_uniform_clip_sampler(self): indices = torch.tensor(list(iter(sampler))) videos = torch.div(indices, 5, rounding_mode='floor') v_idxs, count = torch.unique(videos, return_counts=True) - self.assertTrue(v_idxs.equal(torch.tensor([0, 1, 2]))) - self.assertTrue(count.equal(torch.tensor([3, 3, 3]))) - self.assertTrue(indices.equal(torch.tensor([0, 2, 4, 5, 7, 9, 10, 12, 14]))) + assert_equal(v_idxs, torch.tensor([0, 1, 2])) + assert_equal(count, torch.tensor([3, 3, 3])) + assert_equal(indices, torch.tensor([0, 2, 4, 5, 7, 9, 10, 12, 14])) def test_uniform_clip_sampler_insufficient_clips(self): with get_list_of_videos(num_videos=3, sizes=[10, 25, 25]) as video_list: @@ -85,7 +86,7 @@ def test_uniform_clip_sampler_insufficient_clips(self): sampler = UniformClipSampler(video_clips, 3) self.assertEqual(len(sampler), 3 * 3) indices = torch.tensor(list(iter(sampler))) - self.assertTrue(indices.equal(torch.tensor([0, 0, 1, 2, 4, 6, 7, 9, 11]))) + assert_equal(indices, torch.tensor([0, 0, 1, 2, 4, 6, 7, 9, 11])) def test_distributed_sampler_and_uniform_clip_sampler(self): with get_list_of_videos(num_videos=3, sizes=[25, 25, 25]) as video_list: @@ -100,7 +101,7 @@ def test_distributed_sampler_and_uniform_clip_sampler(self): ) indices = torch.tensor(list(iter(distributed_sampler_rank0))) self.assertEqual(len(distributed_sampler_rank0), 6) - self.assertTrue(indices.equal(torch.tensor([0, 2, 4, 10, 12, 14]))) + assert_equal(indices, torch.tensor([0, 2, 4, 10, 12, 14])) distributed_sampler_rank1 = DistributedSampler( clip_sampler, @@ -110,7 +111,7 @@ def test_distributed_sampler_and_uniform_clip_sampler(self): ) indices = torch.tensor(list(iter(distributed_sampler_rank1))) self.assertEqual(len(distributed_sampler_rank1), 6) - self.assertTrue(indices.equal(torch.tensor([5, 7, 9, 0, 2, 4]))) + assert_equal(indices, torch.tensor([5, 7, 9, 0, 2, 4])) if __name__ == '__main__': From 05e061f566e965dea40154fc9012e1b984eb4e06 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 14:58:48 +0100 Subject: [PATCH 083/279] Use torch.testing.assert_close in datasets_video_utils.py (#3875) Co-authored-by: Philip Meier --- test/test_datasets_video_utils.py | 45 ++++++++++++++++--------------- 1 file changed, 23 insertions(+), 22 deletions(-) diff --git a/test/test_datasets_video_utils.py b/test/test_datasets_video_utils.py index 694214544f7..0a9d3bdfc36 100644 --- a/test/test_datasets_video_utils.py +++ b/test/test_datasets_video_utils.py @@ -7,6 +7,7 @@ from torchvision.datasets.video_utils import VideoClips, unfold from common_utils import get_tmp_dir +from _assert_utils import assert_equal @contextlib.contextmanager @@ -40,7 +41,7 @@ def test_unfold(self): [0, 1, 2], [3, 4, 5], ]) - self.assertTrue(r.equal(expected)) + assert_equal(r, expected, check_stride=False) r = unfold(a, 3, 2, 1) expected = torch.tensor([ @@ -48,38 +49,38 @@ def test_unfold(self): [2, 3, 4], [4, 5, 6] ]) - self.assertTrue(r.equal(expected)) + assert_equal(r, expected, check_stride=False) r = unfold(a, 3, 2, 2) expected = torch.tensor([ [0, 2, 4], [2, 4, 6], ]) - self.assertTrue(r.equal(expected)) + assert_equal(r, expected, check_stride=False) @unittest.skipIf(not io.video._av_available(), "this test requires av") def test_video_clips(self): with get_list_of_videos(num_videos=3) as video_list: video_clips = VideoClips(video_list, 5, 5, num_workers=2) - self.assertEqual(video_clips.num_clips(), 1 + 2 + 3) + assert video_clips.num_clips() == 1 + 2 + 3 for i, (v_idx, c_idx) in enumerate([(0, 0), (1, 0), (1, 1), (2, 0), (2, 1), (2, 2)]): video_idx, clip_idx = video_clips.get_clip_location(i) - self.assertEqual(video_idx, v_idx) - self.assertEqual(clip_idx, c_idx) + assert video_idx == v_idx + assert clip_idx == c_idx video_clips = VideoClips(video_list, 6, 6) - self.assertEqual(video_clips.num_clips(), 0 + 1 + 2) + assert video_clips.num_clips() == 0 + 1 + 2 for i, (v_idx, c_idx) in enumerate([(1, 0), (2, 0), (2, 1)]): video_idx, clip_idx = video_clips.get_clip_location(i) - self.assertEqual(video_idx, v_idx) - self.assertEqual(clip_idx, c_idx) + assert video_idx == v_idx + assert clip_idx == c_idx video_clips = VideoClips(video_list, 6, 1) - self.assertEqual(video_clips.num_clips(), 0 + (10 - 6 + 1) + (15 - 6 + 1)) + assert video_clips.num_clips() == 0 + (10 - 6 + 1) + (15 - 6 + 1) for i, v_idx, c_idx in [(0, 1, 0), (4, 1, 4), (5, 2, 0), (6, 2, 1)]: video_idx, clip_idx = video_clips.get_clip_location(i) - self.assertEqual(video_idx, v_idx) - self.assertEqual(clip_idx, c_idx) + assert video_idx == v_idx + assert clip_idx == c_idx @unittest.skipIf(not io.video._av_available(), "this test requires av") def test_video_clips_custom_fps(self): @@ -89,8 +90,8 @@ def test_video_clips_custom_fps(self): video_clips = VideoClips(video_list, num_frames, num_frames, fps, num_workers=2) for i in range(video_clips.num_clips()): video, audio, info, video_idx = video_clips.get_clip(i) - self.assertEqual(video.shape[0], num_frames) - self.assertEqual(info["video_fps"], fps) + assert video.shape[0] == num_frames + assert info["video_fps"] == fps # TODO add tests checking that the content is right def test_compute_clips_for_video(self): @@ -103,9 +104,9 @@ def test_compute_clips_for_video(self): clips, idxs = VideoClips.compute_clips_for_video(video_pts, num_frames, num_frames, orig_fps, new_fps) resampled_idxs = VideoClips._resample_video_idx(int(duration * new_fps), orig_fps, new_fps) - self.assertEqual(len(clips), 1) - self.assertTrue(clips.equal(idxs)) - self.assertTrue(idxs[0].equal(resampled_idxs)) + assert len(clips) == 1 + assert_equal(clips, idxs) + assert_equal(idxs[0], resampled_idxs) # case 2: all frames appear only once num_frames = 4 @@ -115,9 +116,9 @@ def test_compute_clips_for_video(self): clips, idxs = VideoClips.compute_clips_for_video(video_pts, num_frames, num_frames, orig_fps, new_fps) resampled_idxs = VideoClips._resample_video_idx(int(duration * new_fps), orig_fps, new_fps) - self.assertEqual(len(clips), 3) - self.assertTrue(clips.equal(idxs)) - self.assertTrue(idxs.flatten().equal(resampled_idxs)) + assert len(clips) == 3 + assert_equal(clips, idxs) + assert_equal(idxs.flatten(), resampled_idxs) # case 3: frames aren't enough for a clip num_frames = 32 @@ -126,8 +127,8 @@ def test_compute_clips_for_video(self): with self.assertWarns(UserWarning): clips, idxs = VideoClips.compute_clips_for_video(video_pts, num_frames, num_frames, orig_fps, new_fps) - self.assertEqual(len(clips), 0) - self.assertEqual(len(idxs), 0) + assert len(clips) == 0 + assert len(idxs) == 0 if __name__ == '__main__': From 195bb86e0b515bb7b1f8ca4ed4ebebd0b36bd6df Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 14:59:54 +0100 Subject: [PATCH 084/279] Use torch.testing.assert_close in test_image.py (#3877) Co-authored-by: Philip Meier --- test/test_image.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/test/test_image.py b/test/test_image.py index 4ed001c61f7..ebc47fde9e4 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -8,6 +8,7 @@ import torch from PIL import Image from common_utils import get_tmp_dir, needs_cuda +from _assert_utils import assert_equal from torchvision.io.image import ( decode_png, decode_jpeg, encode_jpeg, write_jpeg, decode_image, read_file, @@ -107,7 +108,7 @@ def test_encode_jpeg(self): for src_img in [img, img.contiguous()]: # PIL sets jpeg quality to 75 by default jpeg_bytes = encode_jpeg(src_img, quality=75) - self.assertTrue(jpeg_bytes.equal(pil_bytes)) + assert_equal(jpeg_bytes, pil_bytes) with self.assertRaisesRegex( RuntimeError, "Input tensor dtype should be uint8"): @@ -191,7 +192,7 @@ def test_encode_png(self): rec_img = torch.from_numpy(np.array(rec_img)) rec_img = rec_img.permute(2, 0, 1) - self.assertTrue(img_pil.equal(rec_img)) + assert_equal(img_pil, rec_img) with self.assertRaisesRegex( RuntimeError, "Input tensor dtype should be uint8"): @@ -224,7 +225,7 @@ def test_write_png(self): saved_image = torch.from_numpy(np.array(Image.open(torch_png))) saved_image = saved_image.permute(2, 0, 1) - self.assertTrue(img_pil.equal(saved_image)) + assert_equal(img_pil, saved_image) def test_read_file(self): with get_tmp_dir() as d: @@ -235,7 +236,7 @@ def test_read_file(self): data = read_file(fpath) expected = torch.tensor(list(content), dtype=torch.uint8) - self.assertTrue(data.equal(expected)) + assert_equal(data, expected) os.unlink(fpath) with self.assertRaisesRegex( @@ -251,7 +252,7 @@ def test_read_file_non_ascii(self): data = read_file(fpath) expected = torch.tensor(list(content), dtype=torch.uint8) - self.assertTrue(data.equal(expected)) + assert_equal(data, expected) os.unlink(fpath) def test_write_file(self): From ed239b8a90b740f8158baf09a60cc15b6bef965e Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 15:00:44 +0100 Subject: [PATCH 085/279] Use torch.testing.assert_close in test_io.py (#3878) Co-authored-by: Philip Meier --- test/test_io.py | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/test/test_io.py b/test/test_io.py index 7d752bdbcf7..e86ea9e84fc 100644 --- a/test/test_io.py +++ b/test/test_io.py @@ -10,6 +10,7 @@ from urllib.error import URLError from common_utils import get_tmp_dir +from _assert_utils import assert_equal try: @@ -74,7 +75,7 @@ class TestIO(unittest.TestCase): def test_write_read_video(self): with temp_video(10, 300, 300, 5, lossless=True) as (f_name, data): lv, _, info = io.read_video(f_name) - self.assertTrue(data.equal(lv)) + assert_equal(data, lv) self.assertEqual(info["video_fps"], 5) @unittest.skipIf(not io._HAS_VIDEO_OPT, "video_reader backend is not chosen") @@ -116,14 +117,14 @@ def test_read_partial_video(self): lv, _, _ = io.read_video(f_name, pts[start], pts[start + offset - 1]) s_data = data[start:(start + offset)] self.assertEqual(len(lv), offset) - self.assertTrue(s_data.equal(lv)) + assert_equal(s_data, lv) if get_video_backend() == "pyav": # for "video_reader" backend, we don't decode the closest early frame # when the given start pts is not matching any frame pts lv, _, _ = io.read_video(f_name, pts[4] + 1, pts[7]) self.assertEqual(len(lv), 4) - self.assertTrue(data[4:8].equal(lv)) + assert_equal(data[4:8], lv) def test_read_partial_video_bframes(self): # do not use lossless encoding, to test the presence of B-frames @@ -135,16 +136,16 @@ def test_read_partial_video_bframes(self): lv, _, _ = io.read_video(f_name, pts[start], pts[start + offset - 1]) s_data = data[start:(start + offset)] self.assertEqual(len(lv), offset) - self.assertTrue((s_data.float() - lv.float()).abs().max() < self.TOLERANCE) + assert_equal(s_data, lv, rtol=0.0, atol=self.TOLERANCE) lv, _, _ = io.read_video(f_name, pts[4] + 1, pts[7]) # TODO fix this if get_video_backend() == 'pyav': self.assertEqual(len(lv), 4) - self.assertTrue((data[4:8].float() - lv.float()).abs().max() < self.TOLERANCE) + assert_equal(data[4:8], lv, rtol=0.0, atol=self.TOLERANCE) else: self.assertEqual(len(lv), 3) - self.assertTrue((data[5:8].float() - lv.float()).abs().max() < self.TOLERANCE) + assert_equal(data[5:8], lv, rtol=0.0, atol=self.TOLERANCE) def test_read_packed_b_frames_divx_file(self): name = "hmdb51_Turnk_r_Pippi_Michel_cartwheel_f_cm_np2_le_med_6.avi" @@ -175,7 +176,7 @@ def test_read_video_pts_unit_sec(self): with temp_video(10, 300, 300, 5, lossless=True) as (f_name, data): lv, _, info = io.read_video(f_name, pts_unit='sec') - self.assertTrue(data.equal(lv)) + assert_equal(data, lv) self.assertEqual(info["video_fps"], 5) self.assertEqual(info, {"video_fps": 5}) @@ -201,7 +202,7 @@ def test_read_partial_video_pts_unit_sec(self): lv, _, _ = io.read_video(f_name, pts[start], pts[start + offset - 1], pts_unit='sec') s_data = data[start:(start + offset)] self.assertEqual(len(lv), offset) - self.assertTrue(s_data.equal(lv)) + assert_equal(s_data, lv) container = av.open(f_name) stream = container.streams[0] @@ -212,7 +213,7 @@ def test_read_partial_video_pts_unit_sec(self): # for "video_reader" backend, we don't decode the closest early frame # when the given start pts is not matching any frame pts self.assertEqual(len(lv), 4) - self.assertTrue(data[4:8].equal(lv)) + assert_equal(data[4:8], lv) container.close() def test_read_video_corrupted_file(self): @@ -251,9 +252,10 @@ def test_read_video_partially_corrupted_file(self): else: self.assertEqual(len(video), 4) # but the valid decoded content is still correct - self.assertTrue(video[:3].equal(data[:3])) + assert_equal(video[:3], data[:3]) # and the last few frames are wrong - self.assertFalse(video.equal(data)) + with self.assertRaises(AssertionError): + assert_equal(video, data) @unittest.skipIf(sys.platform == 'win32', 'temporarily disabled on Windows') def test_write_video_with_audio(self): @@ -278,7 +280,7 @@ def test_write_video_with_audio(self): ) self.assertEqual(info["video_fps"], out_info["video_fps"]) - self.assertTrue(video_tensor.equal(out_video_tensor)) + assert_equal(video_tensor, out_video_tensor) audio_stream = av.open(f_name).streams.audio[0] out_audio_stream = av.open(out_f_name).streams.audio[0] From 86d45414a58c92e4df27214c6a2ea8109ccc7f82 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 15:02:19 +0100 Subject: [PATCH 086/279] Use torch.testing.assert_close in test_anchor_utils.py (#3880) Co-authored-by: Philip Meier --- test/test_models_detection_anchor_utils.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/test/test_models_detection_anchor_utils.py b/test/test_models_detection_anchor_utils.py index ed1b06b5f96..13c399a0c32 100644 --- a/test/test_models_detection_anchor_utils.py +++ b/test/test_models_detection_anchor_utils.py @@ -1,5 +1,6 @@ import torch from common_utils import TestCase +from _assert_utils import assert_equal from torchvision.models.detection.anchor_utils import AnchorGenerator, DefaultBoxGenerator from torchvision.models.detection.image_list import ImageList @@ -62,8 +63,8 @@ def test_anchor_generator(self): self.assertEqual(len(anchors), 2) self.assertEqual(tuple(anchors[0].shape), (9, 4)) self.assertEqual(tuple(anchors[1].shape), (9, 4)) - self.assertEqual(anchors[0], anchors_output) - self.assertEqual(anchors[1], anchors_output) + assert_equal(anchors[0], anchors_output) + assert_equal(anchors[1], anchors_output) def test_defaultbox_generator(self): images = torch.zeros(2, 3, 15, 15) @@ -85,5 +86,5 @@ def test_defaultbox_generator(self): self.assertEqual(len(dboxes), 2) self.assertEqual(tuple(dboxes[0].shape), (4, 4)) self.assertEqual(tuple(dboxes[1].shape), (4, 4)) - self.assertTrue(dboxes[0].allclose(dboxes_output)) - self.assertTrue(dboxes[1].allclose(dboxes_output)) + torch.testing.assert_close(dboxes[0], dboxes_output, rtol=1e-5, atol=1e-8) + torch.testing.assert_close(dboxes[1], dboxes_output, rtol=1e-5, atol=1e-8) From c307db4bea58b09183bdbca67460c00999f9a844 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 15:03:04 +0100 Subject: [PATCH 087/279] Use torch.testing.assert_close in test_detection_utils.py (#3881) Co-authored-by: Philip Meier --- test/test_models_detection_utils.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/test_models_detection_utils.py b/test/test_models_detection_utils.py index f61d825e0d8..a20e0abc965 100644 --- a/test/test_models_detection_utils.py +++ b/test/test_models_detection_utils.py @@ -4,6 +4,7 @@ from torchvision.models.detection.transform import GeneralizedRCNNTransform import unittest from torchvision.models.detection import backbone_utils +from _assert_utils import assert_equal class Tester(unittest.TestCase): @@ -55,8 +56,8 @@ def test_transform_copy_targets(self): targets = [{'boxes': torch.rand(3, 4)}, {'boxes': torch.rand(2, 4)}] targets_copy = copy.deepcopy(targets) out = transform(image, targets) # noqa: F841 - self.assertTrue(torch.equal(targets[0]['boxes'], targets_copy[0]['boxes'])) - self.assertTrue(torch.equal(targets[1]['boxes'], targets_copy[1]['boxes'])) + assert_equal(targets[0]['boxes'], targets_copy[0]['boxes']) + assert_equal(targets[1]['boxes'], targets_copy[1]['boxes']) def test_not_float_normalize(self): transform = GeneralizedRCNNTransform(300, 500, torch.zeros(3), torch.ones(3)) From ea34cd1ea6f59fb50328525521be0f300e232dbd Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 15:03:29 +0100 Subject: [PATCH 088/279] Use torch.testing.assert_close in test_onnx.py (#3882) Co-authored-by: Philip Meier --- test/test_onnx.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/test/test_onnx.py b/test/test_onnx.py index 63f182004b8..d0140c79dfc 100644 --- a/test/test_onnx.py +++ b/test/test_onnx.py @@ -7,6 +7,7 @@ onnxruntime = None from common_utils import set_rng_seed +from _assert_utils import assert_equal import io import torch from torchvision import ops @@ -483,8 +484,8 @@ def test_heatmaps_to_keypoints(self): jit_trace = torch.jit.trace(heatmaps_to_keypoints, (maps, rois)) out_trace = jit_trace(maps, rois) - assert torch.all(out[0].eq(out_trace[0])) - assert torch.all(out[1].eq(out_trace[1])) + assert_equal(out[0], out_trace[0]) + assert_equal(out[1], out_trace[1]) maps2 = torch.rand(20, 2, 21, 21) rois2 = torch.rand(20, 4) @@ -492,8 +493,8 @@ def test_heatmaps_to_keypoints(self): out2 = heatmaps_to_keypoints(maps2, rois2) out_trace2 = jit_trace(maps2, rois2) - assert torch.all(out2[0].eq(out_trace2[0])) - assert torch.all(out2[1].eq(out_trace2[1])) + assert_equal(out2[0], out_trace2[0]) + assert_equal(out2[1], out_trace2[1]) def test_keypoint_rcnn(self): images, test_images = self.get_test_images() From 55150bfbc4d239c5168f7ceb4f87eb5b31e4dc63 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 15:05:07 +0100 Subject: [PATCH 089/279] Use torch.testing.assert_close in test_ops.py (#3883) Co-authored-by: Philip Meier --- test/test_ops.py | 88 +++++++++++++++++++----------------------------- 1 file changed, 35 insertions(+), 53 deletions(-) diff --git a/test/test_ops.py b/test/test_ops.py index 2e9fac8bc42..964199edc66 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -1,4 +1,5 @@ from common_utils import needs_cuda, cpu_only +from _assert_utils import assert_equal import math import unittest import pytest @@ -78,7 +79,7 @@ def _test_forward(self, device, contiguous, x_dtype=None, rois_dtype=None, **kwa sampling_ratio=-1, device=device, dtype=self.dtype, **kwargs) tol = 1e-3 if (x_dtype is torch.half or rois_dtype is torch.half) else 1e-5 - self.assertTrue(torch.allclose(gt_y.to(y.dtype), y, rtol=tol, atol=tol)) + torch.testing.assert_close(gt_y.to(y), y, rtol=tol, atol=tol) def _test_backward(self, device, contiguous): pool_size = 2 @@ -363,7 +364,7 @@ def make_rois(num_rois=1000): abs_diff = torch.abs(qy[diff_idx].dequantize() - quantized_float_y[diff_idx].dequantize()) t_scale = torch.full_like(abs_diff, fill_value=scale) - self.assertTrue(torch.allclose(abs_diff, t_scale, atol=1e-5)) + torch.testing.assert_close(abs_diff, t_scale, rtol=1e-5, atol=1e-5) x = torch.randint(50, 100, size=(2, 3, 10, 10)).to(dtype) qx = torch.quantize_per_tensor(x, scale=1, zero_point=0, dtype=torch.qint8) @@ -555,7 +556,7 @@ def test_nms_cuda_float16(self): iou_thres = 0.2 keep32 = ops.nms(boxes, scores, iou_thres) keep16 = ops.nms(boxes.to(torch.float16), scores.to(torch.float16), iou_thres) - assert torch.all(torch.eq(keep32, keep16)) + assert_equal(keep32, keep16) @cpu_only def test_batched_nms_implementations(self): @@ -573,12 +574,13 @@ def test_batched_nms_implementations(self): keep_vanilla = ops.boxes._batched_nms_vanilla(boxes, scores, idxs, iou_threshold) keep_trick = ops.boxes._batched_nms_coordinate_trick(boxes, scores, idxs, iou_threshold) - err_msg = "The vanilla and the trick implementation yield different nms outputs." - assert torch.allclose(keep_vanilla, keep_trick), err_msg + torch.testing.assert_close( + keep_vanilla, keep_trick, msg="The vanilla and the trick implementation yield different nms outputs." + ) # Also make sure an empty tensor is returned if boxes is empty empty = torch.empty((0,), dtype=torch.int64) - assert torch.allclose(empty, ops.batched_nms(empty, None, None, None)) + torch.testing.assert_close(empty, ops.batched_nms(empty, None, None, None)) class DeformConvTester(OpTester, unittest.TestCase): @@ -690,15 +692,17 @@ def _test_forward_with_batchsize(self, device, contiguous, batch_sz, dtype): bias = layer.bias.data expected = self.expected_fn(x, weight, offset, mask, bias, stride=stride, padding=padding, dilation=dilation) - self.assertTrue(torch.allclose(res.to(expected.dtype), expected, rtol=tol, atol=tol), - '\nres:\n{}\nexpected:\n{}'.format(res, expected)) + torch.testing.assert_close( + res.to(expected), expected, rtol=tol, atol=tol, msg='\nres:\n{}\nexpected:\n{}'.format(res, expected) + ) # no modulation test res = layer(x, offset) expected = self.expected_fn(x, weight, offset, None, bias, stride=stride, padding=padding, dilation=dilation) - self.assertTrue(torch.allclose(res.to(expected.dtype), expected, rtol=tol, atol=tol), - '\nres:\n{}\nexpected:\n{}'.format(res, expected)) + torch.testing.assert_close( + res.to(expected), expected, rtol=tol, atol=tol, msg='\nres:\n{}\nexpected:\n{}'.format(res, expected) + ) # test for wrong sizes with self.assertRaises(RuntimeError): @@ -778,7 +782,7 @@ def test_compare_cpu_cuda_grads(self): else: self.assertTrue(init_weight.grad is not None) res_grads = init_weight.grad.to("cpu") - self.assertTrue(true_cpu_grads.allclose(res_grads)) + torch.testing.assert_close(true_cpu_grads, res_grads) @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") def test_autocast(self): @@ -812,14 +816,14 @@ def test_frozenbatchnorm2d_eps(self): bn = torch.nn.BatchNorm2d(sample_size[1]).eval() bn.load_state_dict(state_dict) # Difference is expected to fall in an acceptable range - self.assertTrue(torch.allclose(fbn(x), bn(x), atol=1e-6)) + torch.testing.assert_close(fbn(x), bn(x), rtol=1e-5, atol=1e-6) # Check computation for eps > 0 fbn = ops.misc.FrozenBatchNorm2d(sample_size[1], eps=1e-5) fbn.load_state_dict(state_dict, strict=False) bn = torch.nn.BatchNorm2d(sample_size[1], eps=1e-5).eval() bn.load_state_dict(state_dict) - self.assertTrue(torch.allclose(fbn(x), bn(x), atol=1e-6)) + torch.testing.assert_close(fbn(x), bn(x), rtol=1e-5, atol=1e-6) def test_frozenbatchnorm2d_n_arg(self): """Ensure a warning is thrown when passing `n` kwarg @@ -860,20 +864,10 @@ def test_bbox_same(self): exp_xyxy = torch.tensor([[0, 0, 100, 100], [0, 0, 0, 0], [10, 15, 30, 35], [23, 35, 93, 95]], dtype=torch.float) - box_same = ops.box_convert(box_tensor, in_fmt="xyxy", out_fmt="xyxy") - self.assertEqual(exp_xyxy.size(), torch.Size([4, 4])) - self.assertEqual(exp_xyxy.dtype, box_tensor.dtype) - assert torch.all(torch.eq(box_same, exp_xyxy)).item() - - box_same = ops.box_convert(box_tensor, in_fmt="xywh", out_fmt="xywh") - self.assertEqual(exp_xyxy.size(), torch.Size([4, 4])) - self.assertEqual(exp_xyxy.dtype, box_tensor.dtype) - assert torch.all(torch.eq(box_same, exp_xyxy)).item() - - box_same = ops.box_convert(box_tensor, in_fmt="cxcywh", out_fmt="cxcywh") - self.assertEqual(exp_xyxy.size(), torch.Size([4, 4])) - self.assertEqual(exp_xyxy.dtype, box_tensor.dtype) - assert torch.all(torch.eq(box_same, exp_xyxy)).item() + assert exp_xyxy.size() == torch.Size([4, 4]) + assert_equal(ops.box_convert(box_tensor, in_fmt="xyxy", out_fmt="xyxy"), exp_xyxy) + assert_equal(ops.box_convert(box_tensor, in_fmt="xywh", out_fmt="xywh"), exp_xyxy) + assert_equal(ops.box_convert(box_tensor, in_fmt="cxcywh", out_fmt="cxcywh"), exp_xyxy) def test_bbox_xyxy_xywh(self): # Simple test convert boxes to xywh and back. Make sure they are same. @@ -883,16 +877,13 @@ def test_bbox_xyxy_xywh(self): exp_xywh = torch.tensor([[0, 0, 100, 100], [0, 0, 0, 0], [10, 15, 20, 20], [23, 35, 70, 60]], dtype=torch.float) + assert exp_xywh.size() == torch.Size([4, 4]) box_xywh = ops.box_convert(box_tensor, in_fmt="xyxy", out_fmt="xywh") - self.assertEqual(exp_xywh.size(), torch.Size([4, 4])) - self.assertEqual(exp_xywh.dtype, box_tensor.dtype) - assert torch.all(torch.eq(box_xywh, exp_xywh)).item() + assert_equal(box_xywh, exp_xywh) # Reverse conversion box_xyxy = ops.box_convert(box_xywh, in_fmt="xywh", out_fmt="xyxy") - self.assertEqual(box_xyxy.size(), torch.Size([4, 4])) - self.assertEqual(box_xyxy.dtype, box_tensor.dtype) - assert torch.all(torch.eq(box_xyxy, box_tensor)).item() + assert_equal(box_xyxy, box_tensor) def test_bbox_xyxy_cxcywh(self): # Simple test convert boxes to xywh and back. Make sure they are same. @@ -902,16 +893,13 @@ def test_bbox_xyxy_cxcywh(self): exp_cxcywh = torch.tensor([[50, 50, 100, 100], [0, 0, 0, 0], [20, 25, 20, 20], [58, 65, 70, 60]], dtype=torch.float) + assert exp_cxcywh.size() == torch.Size([4, 4]) box_cxcywh = ops.box_convert(box_tensor, in_fmt="xyxy", out_fmt="cxcywh") - self.assertEqual(exp_cxcywh.size(), torch.Size([4, 4])) - self.assertEqual(exp_cxcywh.dtype, box_tensor.dtype) - assert torch.all(torch.eq(box_cxcywh, exp_cxcywh)).item() + assert_equal(box_cxcywh, exp_cxcywh) # Reverse conversion box_xyxy = ops.box_convert(box_cxcywh, in_fmt="cxcywh", out_fmt="xyxy") - self.assertEqual(box_xyxy.size(), torch.Size([4, 4])) - self.assertEqual(box_xyxy.dtype, box_tensor.dtype) - assert torch.all(torch.eq(box_xyxy, box_tensor)).item() + assert_equal(box_xyxy, box_tensor) def test_bbox_xywh_cxcywh(self): box_tensor = torch.tensor([[0, 0, 100, 100], [0, 0, 0, 0], @@ -921,16 +909,13 @@ def test_bbox_xywh_cxcywh(self): exp_cxcywh = torch.tensor([[50, 50, 100, 100], [0, 0, 0, 0], [20, 25, 20, 20], [58, 65, 70, 60]], dtype=torch.float) + assert exp_cxcywh.size() == torch.Size([4, 4]) box_cxcywh = ops.box_convert(box_tensor, in_fmt="xywh", out_fmt="cxcywh") - self.assertEqual(exp_cxcywh.size(), torch.Size([4, 4])) - self.assertEqual(exp_cxcywh.dtype, box_tensor.dtype) - assert torch.all(torch.eq(box_cxcywh, exp_cxcywh)).item() + assert_equal(box_cxcywh, exp_cxcywh) # Reverse conversion box_xywh = ops.box_convert(box_cxcywh, in_fmt="cxcywh", out_fmt="xywh") - self.assertEqual(box_xywh.size(), torch.Size([4, 4])) - self.assertEqual(box_xywh.dtype, box_tensor.dtype) - assert torch.all(torch.eq(box_xywh, box_tensor)).item() + assert_equal(box_xywh, box_tensor) def test_bbox_invalid(self): box_tensor = torch.tensor([[0, 0, 100, 100], [0, 0, 0, 0], @@ -951,19 +936,18 @@ def test_bbox_convert_jit(self): box_xywh = ops.box_convert(box_tensor, in_fmt="xyxy", out_fmt="xywh") scripted_xywh = scripted_fn(box_tensor, 'xyxy', 'xywh') - self.assertTrue((scripted_xywh - box_xywh).abs().max() < TOLERANCE) + torch.testing.assert_close(scripted_xywh, box_xywh, rtol=0.0, atol=TOLERANCE) box_cxcywh = ops.box_convert(box_tensor, in_fmt="xyxy", out_fmt="cxcywh") scripted_cxcywh = scripted_fn(box_tensor, 'xyxy', 'cxcywh') - self.assertTrue((scripted_cxcywh - box_cxcywh).abs().max() < TOLERANCE) + torch.testing.assert_close(scripted_cxcywh, box_cxcywh, rtol=0.0, atol=TOLERANCE) class BoxAreaTester(unittest.TestCase): def test_box_area(self): def area_check(box, expected, tolerance=1e-4): out = ops.box_area(box) - assert out.size() == expected.size() - assert ((out - expected).abs().max() < tolerance).item() + torch.testing.assert_close(out, expected, rtol=0.0, check_dtype=False, atol=tolerance) # Check for int boxes for dtype in [torch.int8, torch.int16, torch.int32, torch.int64]: @@ -991,8 +975,7 @@ class BoxIouTester(unittest.TestCase): def test_iou(self): def iou_check(box, expected, tolerance=1e-4): out = ops.box_iou(box, box) - assert out.size() == expected.size() - assert ((out - expected).abs().max() < tolerance).item() + torch.testing.assert_close(out, expected, rtol=0.0, check_dtype=False, atol=tolerance) # Check for int boxes for dtype in [torch.int16, torch.int32, torch.int64]: @@ -1013,8 +996,7 @@ class GenBoxIouTester(unittest.TestCase): def test_gen_iou(self): def gen_iou_check(box, expected, tolerance=1e-4): out = ops.generalized_box_iou(box, box) - assert out.size() == expected.size() - assert ((out - expected).abs().max() < tolerance).item() + torch.testing.assert_close(out, expected, rtol=0.0, check_dtype=False, atol=tolerance) # Check for int boxes for dtype in [torch.int16, torch.int32, torch.int64]: From 97b05a893f73ee6d5c0c35858e2109a7a4a4679d Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 15:05:31 +0100 Subject: [PATCH 090/279] Use torch.testing.assert_close in test_transforms_tensor.py (#3885) Co-authored-by: Philip Meier --- test/test_transforms_tensor.py | 29 ++++++++++++++++++----------- 1 file changed, 18 insertions(+), 11 deletions(-) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 2c598e90833..0d5e365351d 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -10,6 +10,7 @@ from typing import Sequence from common_utils import TransformsTester, get_tmp_dir, int_dtypes, float_dtypes +from _assert_utils import assert_equal NEAREST, BILINEAR, BICUBIC = InterpolationMode.NEAREST, InterpolationMode.BILINEAR, InterpolationMode.BICUBIC @@ -38,7 +39,7 @@ def _test_transform_vs_scripted(self, transform, s_transform, tensor, msg=None): out1 = transform(tensor) torch.manual_seed(12) out2 = s_transform(tensor) - self.assertTrue(out1.equal(out2), msg=msg) + assert_equal(out1, out2, msg=msg) def _test_transform_vs_scripted_on_batch(self, transform, s_transform, batch_tensors, msg=None): torch.manual_seed(12) @@ -48,11 +49,11 @@ def _test_transform_vs_scripted_on_batch(self, transform, s_transform, batch_ten img_tensor = batch_tensors[i, ...] torch.manual_seed(12) transformed_img = transform(img_tensor) - self.assertTrue(transformed_img.equal(transformed_batch[i, ...]), msg=msg) + assert_equal(transformed_img, transformed_batch[i, ...], msg=msg) torch.manual_seed(12) s_transformed_batch = s_transform(batch_tensors) - self.assertTrue(transformed_batch.equal(s_transformed_batch), msg=msg) + assert_equal(transformed_batch, s_transformed_batch, msg=msg) def _test_class_op(self, method, meth_kwargs=None, test_exact_match=True, **match_kwargs): if meth_kwargs is None: @@ -75,7 +76,7 @@ def _test_class_op(self, method, meth_kwargs=None, test_exact_match=True, **matc torch.manual_seed(12) transformed_tensor_script = scripted_fn(tensor) - self.assertTrue(transformed_tensor.equal(transformed_tensor_script)) + assert_equal(transformed_tensor, transformed_tensor_script) batch_tensors = self._create_data_batch(height=23, width=34, channels=3, num_samples=4, device=self.device) self._test_transform_vs_scripted_on_batch(f, scripted_fn, batch_tensors) @@ -270,8 +271,11 @@ def _test_op_list_output(self, func, method, out_length, fn_kwargs=None, meth_kw self.assertEqual(len(transformed_t_list), len(transformed_t_list_script)) self.assertEqual(len(transformed_t_list_script), out_length) for transformed_tensor, transformed_tensor_script in zip(transformed_t_list, transformed_t_list_script): - self.assertTrue(transformed_tensor.equal(transformed_tensor_script), - msg="{} vs {}".format(transformed_tensor, transformed_tensor_script)) + assert_equal( + transformed_tensor, + transformed_tensor_script, + msg="{} vs {}".format(transformed_tensor, transformed_tensor_script), + ) # test for class interface fn = getattr(T, method)(**meth_kwargs) @@ -289,8 +293,11 @@ def _test_op_list_output(self, func, method, out_length, fn_kwargs=None, meth_kw torch.manual_seed(12) transformed_img_list = fn(img_tensor) for transformed_img, transformed_batch in zip(transformed_img_list, transformed_batch_list): - self.assertTrue(transformed_img.equal(transformed_batch[i, ...]), - msg="{} vs {}".format(transformed_img, transformed_batch[i, ...])) + assert_equal( + transformed_img, + transformed_batch[i, ...], + msg="{} vs {}".format(transformed_img, transformed_batch[i, ...]), + ) with get_tmp_dir() as tmp_dir: scripted_fn.save(os.path.join(tmp_dir, "t_op_list_{}.pt".format(method))) @@ -505,7 +512,7 @@ def test_linear_transformation(self): transformed_batch = fn(batch_tensors) torch.manual_seed(12) s_transformed_batch = scripted_fn(batch_tensors) - self.assertTrue(transformed_batch.equal(s_transformed_batch)) + assert_equal(transformed_batch, s_transformed_batch) with get_tmp_dir() as tmp_dir: scripted_fn.save(os.path.join(tmp_dir, "t_norm.pt")) @@ -525,7 +532,7 @@ def test_compose(self): transformed_tensor = transforms(tensor) torch.manual_seed(12) transformed_tensor_script = scripted_fn(tensor) - self.assertTrue(transformed_tensor.equal(transformed_tensor_script), msg="{}".format(transforms)) + assert_equal(transformed_tensor, transformed_tensor_script, msg="{}".format(transforms)) t = T.Compose([ lambda x: x, @@ -551,7 +558,7 @@ def test_random_apply(self): transformed_tensor = transforms(tensor) torch.manual_seed(12) transformed_tensor_script = scripted_fn(tensor) - self.assertTrue(transformed_tensor.equal(transformed_tensor_script), msg="{}".format(transforms)) + assert_equal(transformed_tensor, transformed_tensor_script, msg="{}".format(transforms)) if torch.device(self.device).type == "cpu": # Can't check this twice, otherwise From 6fa93086651945b7c9a2ce09516e7aab8bcbf106 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 15:05:54 +0100 Subject: [PATCH 091/279] Use torch.testing.assert_close in test_transforms_video.py (#3886) Co-authored-by: Philip Meier --- test/test_transforms_video.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/test_transforms_video.py b/test/test_transforms_video.py index e0c7ab5260b..942bb010f71 100644 --- a/test/test_transforms_video.py +++ b/test/test_transforms_video.py @@ -4,6 +4,7 @@ import random import numpy as np import warnings +from _assert_utils import assert_equal try: from scipy import stats @@ -120,7 +121,7 @@ def samples_from_standard_normal(tensor): # Checking the optional in-place behaviour tensor = torch.rand((3, 128, 16, 16)) tensor_inplace = transforms.NormalizeVideo((0.5, 0.5, 0.5), (0.5, 0.5, 0.5), inplace=True)(tensor) - self.assertTrue(torch.equal(tensor, tensor_inplace)) + assert_equal(tensor, tensor_inplace) transforms.NormalizeVideo((0.5, 0.5, 0.5), (0.5, 0.5, 0.5), inplace=True).__repr__() From b32773454029cc410984a0f2151edb3f6f89ac5d Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 21 May 2021 15:06:23 +0100 Subject: [PATCH 092/279] Remove codecov (#3871) --- .circleci/unittest/linux/scripts/environment.yml | 1 - .circleci/unittest/linux/scripts/post_process.sh | 2 -- .circleci/unittest/windows/scripts/environment.yml | 1 - .circleci/unittest/windows/scripts/post_process.sh | 2 -- README.rst | 3 --- 5 files changed, 9 deletions(-) diff --git a/.circleci/unittest/linux/scripts/environment.yml b/.circleci/unittest/linux/scripts/environment.yml index 710c4829a20..fcf61a6e2f8 100644 --- a/.circleci/unittest/linux/scripts/environment.yml +++ b/.circleci/unittest/linux/scripts/environment.yml @@ -6,7 +6,6 @@ channels: dependencies: - pytest - pytest-cov - - codecov - pip - libpng # NOTE: Pinned to fix issues with size_t on Windows diff --git a/.circleci/unittest/linux/scripts/post_process.sh b/.circleci/unittest/linux/scripts/post_process.sh index a84a0dea55e..e97bf2a7b1b 100755 --- a/.circleci/unittest/linux/scripts/post_process.sh +++ b/.circleci/unittest/linux/scripts/post_process.sh @@ -4,5 +4,3 @@ set -e eval "$(./conda/bin/conda shell.bash hook)" conda activate ./env - -codecov diff --git a/.circleci/unittest/windows/scripts/environment.yml b/.circleci/unittest/windows/scripts/environment.yml index fdc2fe68f64..9a916a27d07 100644 --- a/.circleci/unittest/windows/scripts/environment.yml +++ b/.circleci/unittest/windows/scripts/environment.yml @@ -6,7 +6,6 @@ channels: dependencies: - pytest - pytest-cov - - codecov - pip - libpng # NOTE: Pinned to fix issues with size_t on Windows diff --git a/.circleci/unittest/windows/scripts/post_process.sh b/.circleci/unittest/windows/scripts/post_process.sh index b132113194b..5c5cbb758a9 100644 --- a/.circleci/unittest/windows/scripts/post_process.sh +++ b/.circleci/unittest/windows/scripts/post_process.sh @@ -4,5 +4,3 @@ set -e eval "$(./conda/Scripts/conda.exe 'shell.bash' 'hook')" conda activate ./env - -codecov diff --git a/README.rst b/README.rst index beab4641176..db50cae8fd0 100644 --- a/README.rst +++ b/README.rst @@ -1,9 +1,6 @@ torchvision =========== -.. image:: https://codecov.io/gh/pytorch/vision/branch/master/graph/badge.svg - :target: https://codecov.io/gh/pytorch/vision - .. image:: https://pepy.tech/badge/torchvision :target: https://pepy.tech/project/torchvision From b2f188eb0f25d487c532e97aebeef77353e7889d Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 21 May 2021 15:06:52 +0100 Subject: [PATCH 093/279] Replace deprecated AutoNonVariableTypeMode with AutoDispatchBelowADInplaceOrView. (#3786) Co-authored-by: Francisco Massa --- torchvision/csrc/ops/autograd/deform_conv2d_kernel.cpp | 4 ++-- torchvision/csrc/ops/autograd/ps_roi_align_kernel.cpp | 4 ++-- torchvision/csrc/ops/autograd/ps_roi_pool_kernel.cpp | 4 ++-- torchvision/csrc/ops/autograd/roi_align_kernel.cpp | 4 ++-- torchvision/csrc/ops/autograd/roi_pool_kernel.cpp | 4 ++-- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/torchvision/csrc/ops/autograd/deform_conv2d_kernel.cpp b/torchvision/csrc/ops/autograd/deform_conv2d_kernel.cpp index 77b44b77f62..801afb6a9bc 100644 --- a/torchvision/csrc/ops/autograd/deform_conv2d_kernel.cpp +++ b/torchvision/csrc/ops/autograd/deform_conv2d_kernel.cpp @@ -27,7 +27,7 @@ class DeformConv2dFunction int64_t groups, int64_t offset_groups, bool use_mask) { - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto output = deform_conv2d( input, weight, @@ -142,7 +142,7 @@ class DeformConv2dBackwardFunction int64_t groups, int64_t offset_groups, bool use_mask) { - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto result = detail::_deform_conv2d_backward( grad, input, diff --git a/torchvision/csrc/ops/autograd/ps_roi_align_kernel.cpp b/torchvision/csrc/ops/autograd/ps_roi_align_kernel.cpp index 98b78b8ab82..47e51ce9ca2 100644 --- a/torchvision/csrc/ops/autograd/ps_roi_align_kernel.cpp +++ b/torchvision/csrc/ops/autograd/ps_roi_align_kernel.cpp @@ -24,7 +24,7 @@ class PSROIAlignFunction ctx->saved_data["pooled_width"] = pooled_width; ctx->saved_data["sampling_ratio"] = sampling_ratio; ctx->saved_data["input_shape"] = input.sizes(); - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto result = ps_roi_align( input, rois, @@ -89,7 +89,7 @@ class PSROIAlignBackwardFunction int64_t channels, int64_t height, int64_t width) { - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto grad_in = detail::_ps_roi_align_backward( grad, rois, diff --git a/torchvision/csrc/ops/autograd/ps_roi_pool_kernel.cpp b/torchvision/csrc/ops/autograd/ps_roi_pool_kernel.cpp index 9118f31b218..ddc37262382 100644 --- a/torchvision/csrc/ops/autograd/ps_roi_pool_kernel.cpp +++ b/torchvision/csrc/ops/autograd/ps_roi_pool_kernel.cpp @@ -21,7 +21,7 @@ class PSROIPoolFunction : public torch::autograd::Function { ctx->saved_data["pooled_height"] = pooled_height; ctx->saved_data["pooled_width"] = pooled_width; ctx->saved_data["input_shape"] = input.sizes(); - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto result = ps_roi_pool(input, rois, spatial_scale, pooled_height, pooled_width); @@ -78,7 +78,7 @@ class PSROIPoolBackwardFunction int64_t channels, int64_t height, int64_t width) { - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto grad_in = detail::_ps_roi_pool_backward( grad, rois, diff --git a/torchvision/csrc/ops/autograd/roi_align_kernel.cpp b/torchvision/csrc/ops/autograd/roi_align_kernel.cpp index 73f335fadf6..f26842b6428 100644 --- a/torchvision/csrc/ops/autograd/roi_align_kernel.cpp +++ b/torchvision/csrc/ops/autograd/roi_align_kernel.cpp @@ -26,7 +26,7 @@ class ROIAlignFunction : public torch::autograd::Function { ctx->saved_data["aligned"] = aligned; ctx->saved_data["input_shape"] = input.sizes(); ctx->save_for_backward({rois}); - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto result = roi_align( input, rois, @@ -85,7 +85,7 @@ class ROIAlignBackwardFunction int64_t width, int64_t sampling_ratio, bool aligned) { - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto result = detail::_roi_align_backward( grad, rois, diff --git a/torchvision/csrc/ops/autograd/roi_pool_kernel.cpp b/torchvision/csrc/ops/autograd/roi_pool_kernel.cpp index 4aec303efd7..d246f831bcb 100644 --- a/torchvision/csrc/ops/autograd/roi_pool_kernel.cpp +++ b/torchvision/csrc/ops/autograd/roi_pool_kernel.cpp @@ -21,7 +21,7 @@ class ROIPoolFunction : public torch::autograd::Function { ctx->saved_data["pooled_height"] = pooled_height; ctx->saved_data["pooled_width"] = pooled_width; ctx->saved_data["input_shape"] = input.sizes(); - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto result = roi_pool(input, rois, spatial_scale, pooled_height, pooled_width); @@ -78,7 +78,7 @@ class ROIPoolBackwardFunction int64_t channels, int64_t height, int64_t width) { - at::AutoNonVariableTypeMode g; + at::AutoDispatchBelowADInplaceOrView g; auto grad_in = detail::_roi_pool_backward( grad, rois, From 31ee79e682fb768d605effa94b2b2226639bc7c2 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 15:07:10 +0100 Subject: [PATCH 094/279] Use torch.testing.assert_close in test_utils (#3887) Co-authored-by: Philip Meier --- test/test_utils.py | 36 +++++++++++++++++------------------- 1 file changed, 17 insertions(+), 19 deletions(-) diff --git a/test/test_utils.py b/test/test_utils.py index ee683b27ca4..e9bafdeab42 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -9,6 +9,7 @@ from io import BytesIO import torchvision.transforms.functional as F from PIL import Image, __version__ as PILLOW_VERSION, ImageColor +from _assert_utils import assert_equal PILLOW_VERSION = tuple(int(x) for x in PILLOW_VERSION.split('.')) @@ -48,13 +49,13 @@ def test_make_grid_not_inplace(self): t_clone = t.clone() utils.make_grid(t, normalize=False) - self.assertTrue(torch.equal(t, t_clone), 'make_grid modified tensor in-place') + assert_equal(t, t_clone, msg='make_grid modified tensor in-place') utils.make_grid(t, normalize=True, scale_each=False) - self.assertTrue(torch.equal(t, t_clone), 'make_grid modified tensor in-place') + assert_equal(t, t_clone, msg='make_grid modified tensor in-place') utils.make_grid(t, normalize=True, scale_each=True) - self.assertTrue(torch.equal(t, t_clone), 'make_grid modified tensor in-place') + assert_equal(t, t_clone, msg='make_grid modified tensor in-place') def test_normalize_in_make_grid(self): t = torch.rand(5, 3, 10, 10) * 255 @@ -70,8 +71,8 @@ def test_normalize_in_make_grid(self): rounded_grid_max = torch.round(grid_max * 10 ** n_digits) / (10 ** n_digits) rounded_grid_min = torch.round(grid_min * 10 ** n_digits) / (10 ** n_digits) - self.assertTrue(torch.equal(norm_max, rounded_grid_max), 'Normalized max is not equal to 1') - self.assertTrue(torch.equal(norm_min, rounded_grid_min), 'Normalized min is not equal to 0') + assert_equal(norm_max, rounded_grid_max, msg='Normalized max is not equal to 1') + assert_equal(norm_min, rounded_grid_min, msg='Normalized min is not equal to 0') @unittest.skipIf(sys.platform in ('win32', 'cygwin'), 'temporarily disabled on Windows') def test_save_image(self): @@ -96,8 +97,7 @@ def test_save_image_file_object(self): fp = BytesIO() utils.save_image(t, fp, format='png') img_bytes = Image.open(fp) - self.assertTrue(torch.equal(F.to_tensor(img_orig), F.to_tensor(img_bytes)), - 'Image not stored in file object') + assert_equal(F.to_tensor(img_orig), F.to_tensor(img_bytes), msg='Image not stored in file object') @unittest.skipIf(sys.platform in ('win32', 'cygwin'), 'temporarily disabled on Windows') def test_save_image_single_pixel_file_object(self): @@ -108,8 +108,7 @@ def test_save_image_single_pixel_file_object(self): fp = BytesIO() utils.save_image(t, fp, format='png') img_bytes = Image.open(fp) - self.assertTrue(torch.equal(F.to_tensor(img_orig), F.to_tensor(img_bytes)), - 'Pixel Image not stored in file object') + assert_equal(F.to_tensor(img_orig), F.to_tensor(img_bytes), msg='Image not stored in file object') def test_draw_boxes(self): img = torch.full((3, 100, 100), 255, dtype=torch.uint8) @@ -127,11 +126,11 @@ def test_draw_boxes(self): if PILLOW_VERSION >= (8, 2): # The reference image is only valid for new PIL versions expected = torch.as_tensor(np.array(Image.open(path))).permute(2, 0, 1) - self.assertTrue(torch.equal(result, expected)) + assert_equal(result, expected) # Check if modification is not in place - self.assertTrue(torch.all(torch.eq(boxes, boxes_cp)).item()) - self.assertTrue(torch.all(torch.eq(img, img_cp)).item()) + assert_equal(boxes, boxes_cp) + assert_equal(img, img_cp) def test_draw_boxes_vanilla(self): img = torch.full((3, 100, 100), 0, dtype=torch.uint8) @@ -145,10 +144,10 @@ def test_draw_boxes_vanilla(self): res.save(path) expected = torch.as_tensor(np.array(Image.open(path))).permute(2, 0, 1) - self.assertTrue(torch.equal(result, expected)) + assert_equal(result, expected) # Check if modification is not in place - self.assertTrue(torch.all(torch.eq(boxes, boxes_cp)).item()) - self.assertTrue(torch.all(torch.eq(img, img_cp)).item()) + assert_equal(boxes, boxes_cp) + assert_equal(img, img_cp) def test_draw_invalid_boxes(self): img_tp = ((1, 1, 1), (1, 2, 3)) @@ -187,7 +186,7 @@ def test_draw_segmentation_masks(colors, alpha): # Make sure the image didn't change where there's no mask masked_pixels = masks[0] | masks[1] - assert (img[:, ~masked_pixels] == out[:, ~masked_pixels]).all() + assert_equal(img[:, ~masked_pixels], out[:, ~masked_pixels]) if colors is None: colors = utils._generate_color_palette(num_masks) @@ -203,9 +202,8 @@ def test_draw_segmentation_masks(colors, alpha): elif alpha == 0: assert (out[:, mask] == img[:, mask]).all() - interpolated_color = (img[:, mask] * (1 - alpha) + color[:, None] * alpha) - max_diff = (out[:, mask] - interpolated_color).abs().max() - assert max_diff <= 1 + interpolated_color = (img[:, mask] * (1 - alpha) + color[:, None] * alpha).to(dtype) + torch.testing.assert_close(out[:, mask], interpolated_color, rtol=0.0, atol=1.0) def test_draw_segmentation_masks_errors(): From 74559c476e6dcd8701c5765e7462d6b8aa7e0966 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 21 May 2021 15:07:31 +0100 Subject: [PATCH 095/279] Use torch.testing.assert_close in test_video_reader.py (#3888) Co-authored-by: Philip Meier --- test/test_video_reader.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/test/test_video_reader.py b/test/test_video_reader.py index 5b9b2184daf..d9326138397 100644 --- a/test/test_video_reader.py +++ b/test/test_video_reader.py @@ -11,6 +11,7 @@ from numpy.random import randint from torchvision.io import _HAS_VIDEO_OPT from common_utils import PY39_SKIP +from _assert_utils import assert_equal try: @@ -359,8 +360,7 @@ def compare_decoding_result(self, tv_result, ref_result, config=all_check_config ) self.assertAlmostEqual(mean_delta, 0, delta=1.0) - is_same = torch.all(torch.eq(vtimebase, ref_result.vtimebase)).item() - self.assertEqual(is_same, True) + assert_equal(vtimebase, ref_result.vtimebase) if ( config.check_aframes @@ -369,8 +369,7 @@ def compare_decoding_result(self, tv_result, ref_result, config=all_check_config ): """Audio stream is available and audio frame is required to return from decoder""" - is_same = torch.all(torch.eq(aframes, ref_result.aframes)).item() - self.assertEqual(is_same, True) + assert_equal(aframes, ref_result.aframes) if ( config.check_aframe_pts @@ -378,11 +377,9 @@ def compare_decoding_result(self, tv_result, ref_result, config=all_check_config and ref_result.aframe_pts.numel() > 0 ): """Audio stream is available""" - is_same = torch.all(torch.eq(aframe_pts, ref_result.aframe_pts)).item() - self.assertEqual(is_same, True) + assert_equal(aframe_pts, ref_result.aframe_pts) - is_same = torch.all(torch.eq(atimebase, ref_result.atimebase)).item() - self.assertEqual(is_same, True) + assert_equal(atimebase, ref_result.atimebase) @unittest.skip( "This stress test will iteratively decode the same set of videos." From 0bb9b9147a1cf6dec81b7130979d33f25c5720a9 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Sat, 22 May 2021 11:15:50 +0100 Subject: [PATCH 096/279] Fix the spacing of labels on draw_bounding_boxes (#3895) --- test/assets/fakedata/draw_boxes_util.png | Bin 547 -> 560 bytes torchvision/utils.py | 3 ++- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/test/assets/fakedata/draw_boxes_util.png b/test/assets/fakedata/draw_boxes_util.png index 2c361c5fafd52abb6a6b645e92fb4fe972a716ac..d38f8be78ac72d8d9e3cfeb110bc141c78b645c6 100644 GIT binary patch delta 465 zcmZ3?vVmoSO8s|F7srr_IdAVAENpU+aClfRt98lhQj_`$Am0ma!@GHVpMCzjB=yF$ zEaRu&<;?H?xcKnWtm9fQ*y8J5w>~>LOXPJCzAZ!_DP5B;1Nt_ocxecbn;V1 zL1b(Ov;4q`y%}ozefrE7FZ{k}=HFeBMUqU%fR3wSVzmy;e&^O?&j19Tu6{1-oD!M< DcU;^k delta 448 zcmdnMvY2IpO8qNO7srr_IdAVA%spfv;qdUjXt4pynTw(p4=qp06`bNabJ02ch0@E$ zDRQ@NRfb(@s=U8asL9QL+vA81lVdaZG^2X;lRsC#Kc}VCcmDV`^XJ8JUy}0f2D`l3 z{`>#Fp5Gt7+!rtKUl#HE?Y)norbn&z&O7uo!uV*_mZiJSimd+GR{tYl-?cRz9_>#A zv?G=}@8VmXY_ZSljupc(rXE%aZUeCmTKngiADw$dEoe$#`LP$T7?ulZE0w+9eLqg> zUfZEOGxz*xv*n5jIt%Q0+rJk4Tx=jOe?;q)JKyY%4hwgi;~V52{c)dOI{T8vw7iJv zvtw@?C->dCdAH!*tf|W1%gYznrybpu^2uk>z5};koLbAApmQLiVIxB_Bh2~)orG&E zov+^bXM0-u+ghKeHw(T=dUqwq_fPoQt~~8mbIED@7dm&AyIx=8CmpM6zNt=X``p45 z#ynY|8QsTr=|#_77k^s!!(RP}hbAr%AEDSW`6Z*| Date: Sat, 22 May 2021 12:07:47 +0100 Subject: [PATCH 097/279] Use torch.testing.assert_close in common_utils.py (#3873) Co-authored-by: Philip Meier --- test/common_utils.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index 1f48e8c649b..44c4a1fca77 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -20,6 +20,8 @@ import numpy as np from PIL import Image +from _assert_utils import assert_equal + IS_PY39 = sys.version_info.major == 3 and sys.version_info.minor == 9 PY39_SEGFAULT_SKIP_MSG = "Segmentation fault with Python 3.9, see https://github.com/pytorch/vision/issues/3367" PY39_SKIP = unittest.skipIf(IS_PY39, PY39_SEGFAULT_SKIP_MSG) @@ -139,7 +141,8 @@ def assertExpected(self, output, name, prec=None): raise RuntimeError("The output for {}, is larger than 50kb".format(filename)) else: expected = torch.load(expected_file) - self.assertEqual(output, expected, prec=prec) + rtol = atol = prec or self.precision + torch.testing.assert_close(output, expected, rtol=rtol, atol=atol, check_dtype=False) def assertEqual(self, x, y, prec=None, message='', allow_inf=False): """ @@ -345,7 +348,7 @@ def compareTensorToPIL(self, tensor, pil_image, msg=None): pil_tensor = torch.as_tensor(np_pil_image.transpose((2, 0, 1))) if msg is None: msg = "tensor:\n{} \ndid not equal PIL tensor:\n{}".format(tensor, pil_tensor) - self.assertTrue(tensor.cpu().equal(pil_tensor), msg) + assert_equal(tensor.cpu(), pil_tensor, check_stride=False, msg=msg) def approxEqualTensorToPIL(self, tensor, pil_image, tol=1e-5, msg=None, agg_method="mean", allowed_percentage_diff=None): From b2d4d8a24e221b3d084184fee89a8e1f51e1bcaf Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Sat, 22 May 2021 20:19:09 +0100 Subject: [PATCH 098/279] Fixing SSD and SSDlite docs (#3896) --- docs/source/models.rst | 7 ++++--- gallery/plot_visualization_utils.py | 5 +++-- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/docs/source/models.rst b/docs/source/models.rst index 56dce6a76dc..b9bff7a36e8 100644 --- a/docs/source/models.rst +++ b/docs/source/models.rst @@ -388,6 +388,7 @@ architectures for detection: - `Mask R-CNN `_ - `RetinaNet `_ - `SSD `_ +- `SSDlite `_ The pre-trained models for detection, instance segmentation and keypoint detection are initialized with the classification models @@ -475,9 +476,9 @@ Runtime characteristics The implementations of the models for object detection, instance segmentation and keypoint detection are efficient. -In the following table, we use 8 V100 GPUs, with CUDA 10.0 and CUDNN 7.4 to -report the results. During training, we use a batch size of 2 per GPU, and -during testing a batch size of 1 is used. +In the following table, we use 8 GPUs to report the results. During training, +we use a batch size of 2 per GPU for all models except SSD which uses 4 +and SSDlite which uses 24. During testing a batch size of 1 is used. For test time, we report the time for the model evaluation and postprocessing (including mask pasting in image), but not the time for computing the diff --git a/gallery/plot_visualization_utils.py b/gallery/plot_visualization_utils.py index b5b3d7e103e..feedee4e3cf 100644 --- a/gallery/plot_visualization_utils.py +++ b/gallery/plot_visualization_utils.py @@ -10,7 +10,6 @@ import torch import numpy as np -import scipy.misc import matplotlib.pyplot as plt import torchvision.transforms.functional as F @@ -68,7 +67,9 @@ def show(imgs): # models. Here is demo with a Faster R-CNN model loaded from # :func:`~torchvision.models.detection.fasterrcnn_resnet50_fpn` # model. You can also try using a RetinaNet with -# :func:`~torchvision.models.detection.retinanet_resnet50_fpn`. For more details +# :func:`~torchvision.models.detection.retinanet_resnet50_fpn`, an SSDlite with +# :func:`~torchvision.models.detection.ssdlite320_mobilenet_v3_large` or an SSD with +# :func:`~torchvision.models.detection.ssd300_vgg16`. For more details # on the output of such models, you may refer to :ref:`instance_seg_output`. from torchvision.models.detection import fasterrcnn_resnet50_fpn From c89cd065841d16d27ffaae81d10f2a93f569ab14 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Mon, 24 May 2021 10:27:05 +0100 Subject: [PATCH 099/279] Fix Android CI (#3900) --- android/ops/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/android/ops/CMakeLists.txt b/android/ops/CMakeLists.txt index 3210925a85c..6f5323c0d39 100644 --- a/android/ops/CMakeLists.txt +++ b/android/ops/CMakeLists.txt @@ -35,7 +35,7 @@ target_compile_options(${TARGET} PRIVATE set(BUILD_SUBDIR ${ANDROID_ABI}) -find_library(PYTORCH_LIBRARY pytorch_jni +find_library(PYTORCH_LIBRARY pytorch_jni_lite PATHS ${PYTORCH_LINK_DIRS} NO_CMAKE_FIND_ROOT_PATH) From 88358528422cf0dc1b6f752f8a58e7330bb87cae Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Mon, 24 May 2021 11:02:16 +0100 Subject: [PATCH 100/279] Change leftover AutoNonVariableTypeMode class. (#3897) * Change leftover AutoNonVariableTypeMode class. * Replace with InferenceMode --- ios/VisionTestApp/VisionTestApp/ModelRunner.mm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ios/VisionTestApp/VisionTestApp/ModelRunner.mm b/ios/VisionTestApp/VisionTestApp/ModelRunner.mm index 1583e977497..dea3822df26 100644 --- a/ios/VisionTestApp/VisionTestApp/ModelRunner.mm +++ b/ios/VisionTestApp/VisionTestApp/ModelRunner.mm @@ -33,7 +33,7 @@ + (NSString *)run { auto img_tensor = torch::ones({3, 224, 224}, at::ScalarType::Float); inputs.push_back(c10::List(img_tensor)); torch::autograd::AutoGradMode guard(false); - at::AutoNonVariableTypeMode nonVarTypeModeGuard(true); + at::InferenceMode nonVarTypeModeGuard(true); UI_LOG(@"Running warmup runs...", nil); for (int i = 0; i < warmup; ++i) { From 963d432c465324fa056c0bab96a8f5f8444f34e1 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 24 May 2021 12:18:26 +0100 Subject: [PATCH 101/279] Use torch.testing.assert_close in test_transforms.py (#3884) Co-authored-by: Philip Meier --- test/test_transforms.py | 187 +++++++++++++++++++++------------------- 1 file changed, 100 insertions(+), 87 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index 9402a37bc35..69498859778 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -22,6 +22,7 @@ stats = None from common_utils import cycle_over, int_dtypes, float_dtypes +from _assert_utils import assert_equal GRACE_HOPPER = get_file_path_2( @@ -102,8 +103,10 @@ def test_center_crop_2(self): "image_size: {} crop_size: {}".format(input_image_size, crop_size)) # Ensure output for PIL and Tensor are equal - self.assertEqual((output_tensor - output_pil).sum(), 0, - "image_size: {} crop_size: {}".format(input_image_size, crop_size)) + assert_equal( + output_tensor, output_pil, check_stride=False, + msg="image_size: {} crop_size: {}".format(input_image_size, crop_size) + ) # Check if content in center of both image and cropped output is same. center_size = (min(crop_size[0], input_image_size[0]), min(crop_size[1], input_image_size[1])) @@ -126,8 +129,10 @@ def test_center_crop_2(self): input_center_tl[1]:input_center_tl[1] + center_size[1] ] - self.assertEqual((output_center - img_center).sum(), 0, - "image_size: {} crop_size: {}".format(input_image_size, crop_size)) + assert_equal( + output_center, img_center, check_stride=False, + msg="image_size: {} crop_size: {}".format(input_image_size, crop_size) + ) def test_five_crop(self): to_pil_image = transforms.ToPILImage() @@ -382,7 +387,7 @@ def test_random_crop(self): ])(img) self.assertEqual(result.size(1), height) self.assertEqual(result.size(2), width) - self.assertTrue(np.allclose(img.numpy(), result.numpy())) + torch.testing.assert_close(result, img) result = transforms.Compose([ transforms.ToPILImage(), @@ -414,8 +419,14 @@ def test_pad(self): # to the pad value fill_v = fill / 255 eps = 1e-5 - self.assertTrue((result[:, :padding, :] - fill_v).abs().max() < eps) - self.assertTrue((result[:, :, :padding] - fill_v).abs().max() < eps) + h_padded = result[:, :padding, :] + w_padded = result[:, :, :padding] + torch.testing.assert_close( + h_padded, torch.full_like(h_padded, fill_value=fill_v), check_stride=False, rtol=0.0, atol=eps + ) + torch.testing.assert_close( + w_padded, torch.full_like(w_padded, fill_value=fill_v), check_stride=False, rtol=0.0, atol=eps + ) self.assertRaises(ValueError, transforms.Pad(padding, fill=(1, 2)), transforms.ToPILImage()(img)) @@ -448,7 +459,7 @@ def test_pad_with_non_constant_padding_modes(self): # First 6 elements of leftmost edge in the middle of the image, values are in order: # edge_pad, edge_pad, edge_pad, constant_pad, constant value added to leftmost edge, 0 edge_middle_slice = np.asarray(edge_padded_img).transpose(2, 0, 1)[0][17][:6] - self.assertTrue(np.all(edge_middle_slice == np.asarray([200, 200, 200, 200, 1, 0]))) + assert_equal(edge_middle_slice, np.asarray([200, 200, 200, 200, 1, 0], dtype=np.uint8), check_stride=False) self.assertEqual(transforms.ToTensor()(edge_padded_img).size(), (3, 35, 35)) # Pad 3 to left/right, 2 to top/bottom @@ -456,7 +467,7 @@ def test_pad_with_non_constant_padding_modes(self): # First 6 elements of leftmost edge in the middle of the image, values are in order: # reflect_pad, reflect_pad, reflect_pad, constant_pad, constant value added to leftmost edge, 0 reflect_middle_slice = np.asarray(reflect_padded_img).transpose(2, 0, 1)[0][17][:6] - self.assertTrue(np.all(reflect_middle_slice == np.asarray([0, 0, 1, 200, 1, 0]))) + assert_equal(reflect_middle_slice, np.asarray([0, 0, 1, 200, 1, 0], dtype=np.uint8), check_stride=False) self.assertEqual(transforms.ToTensor()(reflect_padded_img).size(), (3, 33, 35)) # Pad 3 to left, 2 to top, 2 to right, 1 to bottom @@ -464,7 +475,7 @@ def test_pad_with_non_constant_padding_modes(self): # First 6 elements of leftmost edge in the middle of the image, values are in order: # sym_pad, sym_pad, sym_pad, constant_pad, constant value added to leftmost edge, 0 symmetric_middle_slice = np.asarray(symmetric_padded_img).transpose(2, 0, 1)[0][17][:6] - self.assertTrue(np.all(symmetric_middle_slice == np.asarray([0, 1, 200, 200, 1, 0]))) + assert_equal(symmetric_middle_slice, np.asarray([0, 1, 200, 200, 1, 0], dtype=np.uint8), check_stride=False) self.assertEqual(transforms.ToTensor()(symmetric_padded_img).size(), (3, 32, 34)) # Check negative padding explicitly for symmetric case, since it is not @@ -473,8 +484,8 @@ def test_pad_with_non_constant_padding_modes(self): symmetric_padded_img_neg = F.pad(img, (-1, 2, 3, -3), padding_mode='symmetric') symmetric_neg_middle_left = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][:3] symmetric_neg_middle_right = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][-4:] - self.assertTrue(np.all(symmetric_neg_middle_left == np.asarray([1, 0, 0]))) - self.assertTrue(np.all(symmetric_neg_middle_right == np.asarray([200, 200, 0, 0]))) + assert_equal(symmetric_neg_middle_left, np.asarray([1, 0, 0], dtype=np.uint8), check_stride=False) + assert_equal(symmetric_neg_middle_right, np.asarray([200, 200, 0, 0], dtype=np.uint8), check_stride=False) self.assertEqual(transforms.ToTensor()(symmetric_padded_img_neg).size(), (3, 28, 31)) def test_pad_raises_with_invalid_pad_sequence_len(self): @@ -499,12 +510,12 @@ def test_lambda(self): trans = transforms.Lambda(lambda x: x.add(10)) x = torch.randn(10) y = trans(x) - self.assertTrue(y.equal(torch.add(x, 10))) + assert_equal(y, torch.add(x, 10)) trans = transforms.Lambda(lambda x: x.add_(10)) x = torch.randn(10) y = trans(x) - self.assertTrue(y.equal(x)) + assert_equal(y, x) # Checking if Lambda can be printed as string trans.__repr__() @@ -613,23 +624,23 @@ def test_to_tensor(self): input_data = torch.ByteTensor(channels, height, width).random_(0, 255).float().div_(255) img = transforms.ToPILImage()(input_data) output = trans(img) - self.assertTrue(np.allclose(input_data.numpy(), output.numpy())) + torch.testing.assert_close(output, input_data, check_stride=False) ndarray = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) output = trans(ndarray) expected_output = ndarray.transpose((2, 0, 1)) / 255.0 - self.assertTrue(np.allclose(output.numpy(), expected_output)) + torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) ndarray = np.random.rand(height, width, channels).astype(np.float32) output = trans(ndarray) expected_output = ndarray.transpose((2, 0, 1)) - self.assertTrue(np.allclose(output.numpy(), expected_output)) + torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) # separate test for mode '1' PIL images input_data = torch.ByteTensor(1, height, width).bernoulli_() img = transforms.ToPILImage()(input_data.mul(255)).convert('1') output = trans(img) - self.assertTrue(np.allclose(input_data.numpy(), output.numpy())) + torch.testing.assert_close(input_data, output, check_dtype=False, check_stride=False) def test_to_tensor_with_other_default_dtypes(self): current_def_dtype = torch.get_default_dtype() @@ -665,8 +676,7 @@ def test_convert_image_dtype_float_to_float(self): output_image = transform(input_image) output_image_script = transform_script(input_image, output_dtype) - script_diff = output_image_script - output_image - self.assertLess(script_diff.abs().max(), 1e-6) + torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) actual_min, actual_max = output_image.tolist() desired_min, desired_max = 0.0, 1.0 @@ -691,8 +701,7 @@ def test_convert_image_dtype_float_to_int(self): output_image = transform(input_image) output_image_script = transform_script(input_image, output_dtype) - script_diff = output_image_script - output_image - self.assertLess(script_diff.abs().max(), 1e-6) + torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) actual_min, actual_max = output_image.tolist() desired_min, desired_max = 0, torch.iinfo(output_dtype).max @@ -711,8 +720,7 @@ def test_convert_image_dtype_int_to_float(self): output_image = transform(input_image) output_image_script = transform_script(input_image, output_dtype) - script_diff = output_image_script - output_image - self.assertLess(script_diff.abs().max(), 1e-6) + torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) actual_min, actual_max = output_image.tolist() desired_min, desired_max = 0.0, 1.0 @@ -736,9 +744,12 @@ def test_convert_image_dtype_int_to_int(self): output_image = transform(input_image) output_image_script = transform_script(input_image, output_dtype) - script_diff = output_image_script.float() - output_image.float() - self.assertLess( - script_diff.abs().max(), 1e-6, msg="{} vs {}".format(output_image_script, output_image) + torch.testing.assert_close( + output_image_script, + output_image, + rtol=0.0, + atol=1e-6, + msg="{} vs {}".format(output_image_script, output_image), ) actual_min, actual_max = output_image.tolist() @@ -780,8 +791,7 @@ def test_accimage_to_tensor(self): expected_output = trans(Image.open(GRACE_HOPPER).convert('RGB')) output = trans(accimage.Image(GRACE_HOPPER)) - self.assertEqual(expected_output.size(), output.size()) - self.assertTrue(np.allclose(output.numpy(), expected_output.numpy())) + torch.testing.assert_close(output, expected_output) def test_pil_to_tensor(self): test_channels = [1, 3, 4] @@ -796,25 +806,25 @@ def test_pil_to_tensor(self): input_data = torch.ByteTensor(channels, height, width).random_(0, 255) img = transforms.ToPILImage()(input_data) output = trans(img) - self.assertTrue(np.allclose(input_data.numpy(), output.numpy())) + torch.testing.assert_close(input_data, output, check_stride=False) input_data = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) img = transforms.ToPILImage()(input_data) output = trans(img) expected_output = input_data.transpose((2, 0, 1)) - self.assertTrue(np.allclose(output.numpy(), expected_output)) + torch.testing.assert_close(output.numpy(), expected_output) input_data = torch.as_tensor(np.random.rand(channels, height, width).astype(np.float32)) img = transforms.ToPILImage()(input_data) # CHW -> HWC and (* 255).byte() output = trans(img) # HWC -> CHW expected_output = (input_data * 255).byte() - self.assertTrue(np.allclose(output.numpy(), expected_output.numpy())) + torch.testing.assert_close(output, expected_output, check_stride=False) # separate test for mode '1' PIL images input_data = torch.ByteTensor(1, height, width).bernoulli_() img = transforms.ToPILImage()(input_data.mul(255)).convert('1') - output = trans(img) - self.assertTrue(np.allclose(input_data.numpy(), output.numpy())) + output = trans(img).view(torch.uint8).bool().to(torch.uint8) + torch.testing.assert_close(input_data, output, check_stride=False) @unittest.skipIf(accimage is None, 'accimage not available') def test_accimage_pil_to_tensor(self): @@ -824,7 +834,7 @@ def test_accimage_pil_to_tensor(self): output = trans(accimage.Image(GRACE_HOPPER)) self.assertEqual(expected_output.size(), output.size()) - self.assertTrue(np.allclose(output.numpy(), expected_output.numpy())) + torch.testing.assert_close(output, expected_output) @unittest.skipIf(accimage is None, 'accimage not available') def test_accimage_resize(self): @@ -859,7 +869,7 @@ def test_accimage_crop(self): output = trans(accimage.Image(GRACE_HOPPER)) self.assertEqual(expected_output.size(), output.size()) - self.assertTrue(np.allclose(output.numpy(), expected_output.numpy())) + torch.testing.assert_close(output, expected_output) def test_1_channel_tensor_to_pil_image(self): to_tensor = transforms.ToTensor() @@ -880,12 +890,13 @@ def test_1_channel_tensor_to_pil_image(self): for transform in [transforms.ToPILImage(), transforms.ToPILImage(mode=mode)]: img = transform(img_data) self.assertEqual(img.mode, mode) - self.assertTrue(np.allclose(expected_output, to_tensor(img).numpy())) + torch.testing.assert_close(expected_output, to_tensor(img).numpy(), check_stride=False) # 'F' mode for torch.FloatTensor img_F_mode = transforms.ToPILImage(mode='F')(img_data_float) self.assertEqual(img_F_mode.mode, 'F') - self.assertTrue(np.allclose(np.array(Image.fromarray(img_data_float.squeeze(0).numpy(), mode='F')), - np.array(img_F_mode))) + torch.testing.assert_close( + np.array(Image.fromarray(img_data_float.squeeze(0).numpy(), mode='F')), np.array(img_F_mode) + ) def test_1_channel_ndarray_to_pil_image(self): img_data_float = torch.Tensor(4, 4, 1).uniform_().numpy() @@ -899,7 +910,9 @@ def test_1_channel_ndarray_to_pil_image(self): for transform in [transforms.ToPILImage(), transforms.ToPILImage(mode=mode)]: img = transform(img_data) self.assertEqual(img.mode, mode) - self.assertTrue(np.allclose(img_data[:, :, 0], img)) + # note: we explicitly convert img's dtype because pytorch doesn't support uint16 + # and otherwise assert_close wouldn't be able to construct a tensor from the uint16 array + torch.testing.assert_close(img_data[:, :, 0], np.asarray(img).astype(img_data.dtype)) def test_2_channel_ndarray_to_pil_image(self): def verify_img_data(img_data, mode): @@ -911,7 +924,7 @@ def verify_img_data(img_data, mode): self.assertEqual(img.mode, mode) split = img.split() for i in range(2): - self.assertTrue(np.allclose(img_data[:, :, i], split[i])) + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy() for mode in [None, 'LA']: @@ -984,7 +997,7 @@ def verify_img_data(img_data, mode): self.assertEqual(img.mode, mode) split = img.split() for i in range(3): - self.assertTrue(np.allclose(img_data[:, :, i], split[i])) + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy() for mode in [None, 'RGB', 'HSV', 'YCbCr']: @@ -1033,7 +1046,7 @@ def verify_img_data(img_data, mode): self.assertEqual(img.mode, mode) split = img.split() for i in range(4): - self.assertTrue(np.allclose(img_data[:, :, i], split[i])) + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy() for mode in [None, 'RGBA', 'CMYK', 'RGBX']: @@ -1064,7 +1077,7 @@ def test_2d_tensor_to_pil_image(self): for transform in [transforms.ToPILImage(), transforms.ToPILImage(mode=mode)]: img = transform(img_data) self.assertEqual(img.mode, mode) - self.assertTrue(np.allclose(expected_output, to_tensor(img).numpy())) + np.testing.assert_allclose(expected_output, to_tensor(img).numpy()[0]) def test_2d_ndarray_to_pil_image(self): img_data_float = torch.Tensor(4, 4).uniform_().numpy() @@ -1078,7 +1091,7 @@ def test_2d_ndarray_to_pil_image(self): for transform in [transforms.ToPILImage(), transforms.ToPILImage(mode=mode)]: img = transform(img_data) self.assertEqual(img.mode, mode) - self.assertTrue(np.allclose(img_data, img)) + np.testing.assert_allclose(img_data, img) def test_tensor_bad_types_to_pil_image(self): with self.assertRaisesRegex(ValueError, r'pic should be 2/3 dimensional. Got \d+ dimensions.'): @@ -1189,7 +1202,7 @@ def samples_from_standard_normal(tensor): # Checking the optional in-place behaviour tensor = torch.rand((1, 16, 16)) tensor_inplace = transforms.Normalize((0.5,), (0.5,), inplace=True)(tensor) - self.assertTrue(torch.equal(tensor, tensor_inplace)) + assert_equal(tensor, tensor_inplace) def test_normalize_different_dtype(self): for dtype1 in [torch.float32, torch.float64]: @@ -1207,7 +1220,7 @@ def test_normalize_3d_tensor(self): mean = torch.rand(n_channels) std = torch.rand(n_channels) img = torch.rand(n_channels, img_size, img_size) - target = F.normalize(img, mean, std).numpy() + target = F.normalize(img, mean, std) mean_unsqueezed = mean.view(-1, 1, 1) std_unsqueezed = std.view(-1, 1, 1) @@ -1215,8 +1228,8 @@ def test_normalize_3d_tensor(self): result2 = F.normalize(img, mean_unsqueezed.repeat(1, img_size, img_size), std_unsqueezed.repeat(1, img_size, img_size)) - assert_array_almost_equal(target, result1.numpy()) - assert_array_almost_equal(target, result2.numpy()) + torch.testing.assert_close(target, result1) + torch.testing.assert_close(target, result2) def test_adjust_brightness(self): x_shape = [2, 2, 3] @@ -1227,21 +1240,21 @@ def test_adjust_brightness(self): # test 0 y_pil = F.adjust_brightness(x_pil, 1) y_np = np.array(y_pil) - self.assertTrue(np.allclose(y_np, x_np)) + torch.testing.assert_close(y_np, x_np) # test 1 y_pil = F.adjust_brightness(x_pil, 0.5) y_np = np.array(y_pil) y_ans = [0, 2, 6, 27, 67, 113, 18, 4, 117, 45, 127, 0] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) # test 2 y_pil = F.adjust_brightness(x_pil, 2) y_np = np.array(y_pil) y_ans = [0, 10, 26, 108, 255, 255, 74, 16, 255, 180, 255, 2] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) def test_adjust_contrast(self): x_shape = [2, 2, 3] @@ -1252,21 +1265,21 @@ def test_adjust_contrast(self): # test 0 y_pil = F.adjust_contrast(x_pil, 1) y_np = np.array(y_pil) - self.assertTrue(np.allclose(y_np, x_np)) + torch.testing.assert_close(y_np, x_np) # test 1 y_pil = F.adjust_contrast(x_pil, 0.5) y_np = np.array(y_pil) y_ans = [43, 45, 49, 70, 110, 156, 61, 47, 160, 88, 170, 43] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) # test 2 y_pil = F.adjust_contrast(x_pil, 2) y_np = np.array(y_pil) y_ans = [0, 0, 0, 22, 184, 255, 0, 0, 255, 94, 255, 0] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) @unittest.skipIf(Image.__version__ >= '7', "Temporarily disabled") def test_adjust_saturation(self): @@ -1278,21 +1291,21 @@ def test_adjust_saturation(self): # test 0 y_pil = F.adjust_saturation(x_pil, 1) y_np = np.array(y_pil) - self.assertTrue(np.allclose(y_np, x_np)) + torch.testing.assert_close(y_np, x_np) # test 1 y_pil = F.adjust_saturation(x_pil, 0.5) y_np = np.array(y_pil) y_ans = [2, 4, 8, 87, 128, 173, 39, 25, 138, 133, 215, 88] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) # test 2 y_pil = F.adjust_saturation(x_pil, 2) y_np = np.array(y_pil) y_ans = [0, 6, 22, 0, 149, 255, 32, 0, 255, 4, 255, 0] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) def test_adjust_hue(self): x_shape = [2, 2, 3] @@ -1310,21 +1323,21 @@ def test_adjust_hue(self): y_np = np.array(y_pil) y_ans = [0, 5, 13, 54, 139, 226, 35, 8, 234, 91, 255, 1] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) # test 1 y_pil = F.adjust_hue(x_pil, 0.25) y_np = np.array(y_pil) y_ans = [13, 0, 12, 224, 54, 226, 234, 8, 99, 1, 222, 255] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) # test 2 y_pil = F.adjust_hue(x_pil, -0.25) y_np = np.array(y_pil) y_ans = [0, 13, 2, 54, 226, 58, 8, 234, 152, 255, 43, 1] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) def test_adjust_sharpness(self): x_shape = [4, 4, 3] @@ -1337,7 +1350,7 @@ def test_adjust_sharpness(self): # test 0 y_pil = F.adjust_sharpness(x_pil, 1) y_np = np.array(y_pil) - self.assertTrue(np.allclose(y_np, x_np)) + torch.testing.assert_close(y_np, x_np) # test 1 y_pil = F.adjust_sharpness(x_pil, 0.5) @@ -1346,7 +1359,7 @@ def test_adjust_sharpness(self): 30, 74, 103, 96, 114, 97, 110, 100, 101, 114, 32, 81, 103, 108, 102, 101, 107, 116, 105, 115, 0, 0, 73, 32, 108, 111, 118, 101, 32, 121, 111, 117] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) # test 2 y_pil = F.adjust_sharpness(x_pil, 2) @@ -1355,7 +1368,7 @@ def test_adjust_sharpness(self): 0, 46, 118, 111, 132, 97, 110, 100, 101, 114, 32, 95, 135, 146, 126, 112, 119, 116, 105, 115, 0, 0, 73, 32, 108, 111, 118, 101, 32, 121, 111, 117] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) # test 3 x_shape = [2, 2, 3] @@ -1366,7 +1379,7 @@ def test_adjust_sharpness(self): y_pil = F.adjust_sharpness(x_pil, 2) y_np = np.array(y_pil).transpose(2, 0, 1) y_th = F.adjust_sharpness(x_th, 2) - self.assertTrue(np.allclose(y_np, y_th.numpy())) + torch.testing.assert_close(y_np, y_th.numpy()) def test_adjust_gamma(self): x_shape = [2, 2, 3] @@ -1377,21 +1390,21 @@ def test_adjust_gamma(self): # test 0 y_pil = F.adjust_gamma(x_pil, 1) y_np = np.array(y_pil) - self.assertTrue(np.allclose(y_np, x_np)) + torch.testing.assert_close(y_np, x_np) # test 1 y_pil = F.adjust_gamma(x_pil, 0.5) y_np = np.array(y_pil) y_ans = [0, 35, 57, 117, 186, 241, 97, 45, 245, 152, 255, 16] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) # test 2 y_pil = F.adjust_gamma(x_pil, 2) y_np = np.array(y_pil) y_ans = [0, 0, 0, 11, 71, 201, 5, 0, 215, 31, 255, 0] y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - self.assertTrue(np.allclose(y_np, y_ans)) + torch.testing.assert_close(y_np, y_ans) def test_adjusts_L_mode(self): x_shape = [2, 2, 3] @@ -1450,10 +1463,10 @@ def test_linear_transformation(self): cov += np.dot(xwhite, xwhite.T) / num_features mean += np.sum(xwhite) / num_features # if rtol for std = 1e-3 then rtol for cov = 2e-3 as std**2 = cov - self.assertTrue(np.allclose(cov / num_samples, np.identity(1), rtol=2e-3), - "cov not close to 1") - self.assertTrue(np.allclose(mean / num_samples, 0, rtol=1e-3), - "mean not close to 0") + torch.testing.assert_close(cov / num_samples, np.identity(1), rtol=2e-3, atol=1e-8, check_dtype=False, + msg="cov not close to 1") + torch.testing.assert_close(mean / num_samples, 0, rtol=1e-3, atol=1e-8, check_dtype=False, + msg="mean not close to 0") # Checking if LinearTransformation can be printed as string whitening.__repr__() @@ -1491,7 +1504,7 @@ def test_rotate(self): result_a = F.rotate(img, 90) result_b = F.rotate(img, -270) - self.assertTrue(np.all(np.array(result_a) == np.array(result_b))) + assert_equal(np.array(result_a), np.array(result_b)) def test_rotate_fill(self): img = F.to_pil_image(np.ones((100, 100, 3), dtype=np.uint8) * 255, "RGB") @@ -1732,7 +1745,7 @@ def test_to_grayscale(self): gray_np_1 = np.array(gray_pil_1) self.assertEqual(gray_pil_1.mode, 'L', 'mode should be L') self.assertEqual(gray_np_1.shape, tuple(x_shape[0:2]), 'should be 1 channel') - np.testing.assert_equal(gray_np, gray_np_1) + assert_equal(gray_np, gray_np_1) # Case 2: RGB -> 3 channel grayscale trans2 = transforms.Grayscale(num_output_channels=3) @@ -1740,9 +1753,9 @@ def test_to_grayscale(self): gray_np_2 = np.array(gray_pil_2) self.assertEqual(gray_pil_2.mode, 'RGB', 'mode should be RGB') self.assertEqual(gray_np_2.shape, tuple(x_shape), 'should be 3 channel') - np.testing.assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) - np.testing.assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) - np.testing.assert_equal(gray_np, gray_np_2[:, :, 0]) + assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) + assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) + assert_equal(gray_np, gray_np_2[:, :, 0], check_stride=False) # Case 3: 1 channel grayscale -> 1 channel grayscale trans3 = transforms.Grayscale(num_output_channels=1) @@ -1750,7 +1763,7 @@ def test_to_grayscale(self): gray_np_3 = np.array(gray_pil_3) self.assertEqual(gray_pil_3.mode, 'L', 'mode should be L') self.assertEqual(gray_np_3.shape, tuple(x_shape[0:2]), 'should be 1 channel') - np.testing.assert_equal(gray_np, gray_np_3) + assert_equal(gray_np, gray_np_3) # Case 4: 1 channel grayscale -> 3 channel grayscale trans4 = transforms.Grayscale(num_output_channels=3) @@ -1758,9 +1771,9 @@ def test_to_grayscale(self): gray_np_4 = np.array(gray_pil_4) self.assertEqual(gray_pil_4.mode, 'RGB', 'mode should be RGB') self.assertEqual(gray_np_4.shape, tuple(x_shape), 'should be 3 channel') - np.testing.assert_equal(gray_np_4[:, :, 0], gray_np_4[:, :, 1]) - np.testing.assert_equal(gray_np_4[:, :, 1], gray_np_4[:, :, 2]) - np.testing.assert_equal(gray_np, gray_np_4[:, :, 0]) + assert_equal(gray_np_4[:, :, 0], gray_np_4[:, :, 1]) + assert_equal(gray_np_4[:, :, 1], gray_np_4[:, :, 2]) + assert_equal(gray_np, gray_np_4[:, :, 0], check_stride=False) # Checking if Grayscale can be printed as string trans4.__repr__() @@ -1827,9 +1840,9 @@ def test_random_grayscale(self): gray_np_2 = np.array(gray_pil_2) self.assertEqual(gray_pil_2.mode, 'RGB', 'mode should be RGB') self.assertEqual(gray_np_2.shape, tuple(x_shape), 'should be 3 channel') - np.testing.assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) - np.testing.assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) - np.testing.assert_equal(gray_np, gray_np_2[:, :, 0]) + assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) + assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) + assert_equal(gray_np, gray_np_2[:, :, 0], check_stride=False) # Case 3b: RGB -> 3 channel grayscale (unchanged) trans2 = transforms.RandomGrayscale(p=0.0) @@ -1837,7 +1850,7 @@ def test_random_grayscale(self): gray_np_2 = np.array(gray_pil_2) self.assertEqual(gray_pil_2.mode, 'RGB', 'mode should be RGB') self.assertEqual(gray_np_2.shape, tuple(x_shape), 'should be 3 channel') - np.testing.assert_equal(x_np, gray_np_2) + assert_equal(x_np, gray_np_2) # Case 3c: 1 channel grayscale -> 1 channel grayscale (grayscaled) trans3 = transforms.RandomGrayscale(p=1.0) @@ -1845,7 +1858,7 @@ def test_random_grayscale(self): gray_np_3 = np.array(gray_pil_3) self.assertEqual(gray_pil_3.mode, 'L', 'mode should be L') self.assertEqual(gray_np_3.shape, tuple(x_shape[0:2]), 'should be 1 channel') - np.testing.assert_equal(gray_np, gray_np_3) + assert_equal(gray_np, gray_np_3) # Case 3d: 1 channel grayscale -> 1 channel grayscale (unchanged) trans3 = transforms.RandomGrayscale(p=0.0) @@ -1853,7 +1866,7 @@ def test_random_grayscale(self): gray_np_3 = np.array(gray_pil_3) self.assertEqual(gray_pil_3.mode, 'L', 'mode should be L') self.assertEqual(gray_np_3.shape, tuple(x_shape[0:2]), 'should be 1 channel') - np.testing.assert_equal(gray_np, gray_np_3) + assert_equal(gray_np, gray_np_3) # Checking if RandomGrayscale can be printed as string trans3.__repr__() From b96d381ce45e398a5a9ab112f29da4100ef16852 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 24 May 2021 12:38:10 +0100 Subject: [PATCH 102/279] Use torch.testing.assert_close in test_functional_tensor (#3876) Co-authored-by: Philip Meier --- test/test_functional_tensor.py | 84 +++++++++++++++++----------------- 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 31a1c1a43e8..9b73308e3e1 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -15,6 +15,7 @@ from torchvision.transforms import InterpolationMode from common_utils import TransformsTester, cpu_and_gpu, needs_cuda +from _assert_utils import assert_equal from typing import Dict, List, Sequence, Tuple @@ -39,13 +40,13 @@ def _test_fn_on_batch(self, batch_tensors, fn, scripted_fn_atol=1e-8, **fn_kwarg for i in range(len(batch_tensors)): img_tensor = batch_tensors[i, ...] transformed_img = fn(img_tensor, **fn_kwargs) - self.assertTrue(transformed_img.equal(transformed_batch[i, ...])) + assert_equal(transformed_img, transformed_batch[i, ...]) if scripted_fn_atol >= 0: scripted_fn = torch.jit.script(fn) # scriptable function test s_transformed_batch = scripted_fn(batch_tensors, **fn_kwargs) - self.assertTrue(transformed_batch.allclose(s_transformed_batch, atol=scripted_fn_atol)) + torch.testing.assert_close(transformed_batch, s_transformed_batch, rtol=1e-5, atol=scripted_fn_atol) def test_assert_image_tensor(self): shape = (100,) @@ -79,7 +80,7 @@ def test_vflip(self): # scriptable function test vflipped_img_script = script_vflip(img_tensor) - self.assertTrue(vflipped_img.equal(vflipped_img_script)) + assert_equal(vflipped_img, vflipped_img_script) batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) self._test_fn_on_batch(batch_tensors, F.vflip) @@ -94,7 +95,7 @@ def test_hflip(self): # scriptable function test hflipped_img_script = script_hflip(img_tensor) - self.assertTrue(hflipped_img.equal(hflipped_img_script)) + assert_equal(hflipped_img, hflipped_img_script) batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) self._test_fn_on_batch(batch_tensors, F.hflip) @@ -140,11 +141,10 @@ def test_hsv2rgb(self): for h1, s1, v1 in zip(h, s, v): rgb.append(colorsys.hsv_to_rgb(h1, s1, v1)) colorsys_img = torch.tensor(rgb, dtype=torch.float32, device=self.device) - max_diff = (ft_img - colorsys_img).abs().max() - self.assertLess(max_diff, 1e-5) + torch.testing.assert_close(ft_img, colorsys_img, rtol=0.0, atol=1e-5) s_rgb_img = scripted_fn(hsv_img) - self.assertTrue(rgb_img.allclose(s_rgb_img)) + torch.testing.assert_close(rgb_img, s_rgb_img) batch_tensors = self._create_data_batch(120, 100, num_samples=4, device=self.device).float() self._test_fn_on_batch(batch_tensors, F_t._hsv2rgb) @@ -177,7 +177,7 @@ def test_rgb2hsv(self): self.assertLess(max_diff, 1e-5) s_hsv_img = scripted_fn(rgb_img) - self.assertTrue(hsv_img.allclose(s_hsv_img, atol=1e-7)) + torch.testing.assert_close(hsv_img, s_hsv_img, rtol=1e-5, atol=1e-7) batch_tensors = self._create_data_batch(120, 100, num_samples=4, device=self.device).float() self._test_fn_on_batch(batch_tensors, F_t._rgb2hsv) @@ -194,7 +194,7 @@ def test_rgb_to_grayscale(self): self.approxEqualTensorToPIL(gray_tensor.float(), gray_pil_image, tol=1.0 + 1e-10, agg_method="max") s_gray_tensor = script_rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) - self.assertTrue(s_gray_tensor.equal(gray_tensor)) + assert_equal(s_gray_tensor, gray_tensor) batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) self._test_fn_on_batch(batch_tensors, F.rgb_to_grayscale, num_output_channels=num_output_channels) @@ -240,12 +240,12 @@ def test_five_crop(self): for j in range(len(tuple_transformed_imgs)): true_transformed_img = tuple_transformed_imgs[j] transformed_img = tuple_transformed_batches[j][i, ...] - self.assertTrue(true_transformed_img.equal(transformed_img)) + assert_equal(true_transformed_img, transformed_img) # scriptable function test s_tuple_transformed_batches = script_five_crop(batch_tensors, [10, 11]) for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): - self.assertTrue(transformed_batch.equal(s_transformed_batch)) + assert_equal(transformed_batch, s_transformed_batch) def test_ten_crop(self): script_ten_crop = torch.jit.script(F.ten_crop) @@ -272,12 +272,12 @@ def test_ten_crop(self): for j in range(len(tuple_transformed_imgs)): true_transformed_img = tuple_transformed_imgs[j] transformed_img = tuple_transformed_batches[j][i, ...] - self.assertTrue(true_transformed_img.equal(transformed_img)) + assert_equal(true_transformed_img, transformed_img) # scriptable function test s_tuple_transformed_batches = script_ten_crop(batch_tensors, [10, 11]) for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): - self.assertTrue(transformed_batch.equal(s_transformed_batch)) + assert_equal(transformed_batch, s_transformed_batch) def test_pad(self): script_fn = torch.jit.script(F.pad) @@ -320,7 +320,7 @@ def test_pad(self): else: script_pad = pad pad_tensor_script = script_fn(tensor, script_pad, **kwargs) - self.assertTrue(pad_tensor.equal(pad_tensor_script), msg="{}, {}".format(pad, kwargs)) + assert_equal(pad_tensor, pad_tensor_script, msg="{}, {}".format(pad, kwargs)) self._test_fn_on_batch(batch_tensors, F.pad, padding=script_pad, **kwargs) @@ -348,9 +348,10 @@ def test_resize(self): resized_tensor = F.resize(tensor, size=size, interpolation=interpolation, max_size=max_size) resized_pil_img = F.resize(pil_img, size=size, interpolation=interpolation, max_size=max_size) - self.assertEqual( - resized_tensor.size()[1:], resized_pil_img.size[::-1], - msg="{}, {}".format(size, interpolation) + assert_equal( + resized_tensor.size()[1:], + resized_pil_img.size[::-1], + msg="{}, {}".format(size, interpolation), ) if interpolation not in [NEAREST, ]: @@ -374,7 +375,7 @@ def test_resize(self): resize_result = script_fn(tensor, size=script_size, interpolation=interpolation, max_size=max_size) - self.assertTrue(resized_tensor.equal(resize_result), msg="{}, {}".format(size, interpolation)) + assert_equal(resized_tensor, resize_result, msg="{}, {}".format(size, interpolation)) self._test_fn_on_batch( batch_tensors, F.resize, size=script_size, interpolation=interpolation, max_size=max_size @@ -384,7 +385,7 @@ def test_resize(self): with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): res1 = F.resize(tensor, size=32, interpolation=2) res2 = F.resize(tensor, size=32, interpolation=BILINEAR) - self.assertTrue(res1.equal(res2)) + assert_equal(res1, res2) for img in (tensor, pil_img): exp_msg = "max_size should only be passed if size specifies the length of the smaller edge" @@ -400,15 +401,17 @@ def test_resized_crop(self): for mode in [NEAREST, BILINEAR, BICUBIC]: out_tensor = F.resized_crop(tensor, top=0, left=0, height=26, width=36, size=[26, 36], interpolation=mode) - self.assertTrue(tensor.equal(out_tensor), msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) + assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) # 2) resize by half and crop a TL corner tensor, _ = self._create_data(26, 36, device=self.device) out_tensor = F.resized_crop(tensor, top=0, left=0, height=20, width=30, size=[10, 15], interpolation=NEAREST) expected_out_tensor = tensor[:, :20:2, :30:2] - self.assertTrue( - expected_out_tensor.equal(out_tensor), - msg="{} vs {}".format(expected_out_tensor[0, :10, :10], out_tensor[0, :10, :10]) + assert_equal( + expected_out_tensor, + out_tensor, + check_stride=False, + msg="{} vs {}".format(expected_out_tensor[0, :10, :10], out_tensor[0, :10, :10]), ) batch_tensors = self._create_data_batch(26, 36, num_samples=4, device=self.device) @@ -420,15 +423,11 @@ def _test_affine_identity_map(self, tensor, scripted_affine): # 1) identity map out_tensor = F.affine(tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST) - self.assertTrue( - tensor.equal(out_tensor), msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5]) - ) + assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) out_tensor = scripted_affine( tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST ) - self.assertTrue( - tensor.equal(out_tensor), msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5]) - ) + assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) def _test_affine_square_rotations(self, tensor, pil_img, scripted_affine): # 2) Test rotation @@ -452,9 +451,11 @@ def _test_affine_square_rotations(self, tensor, pil_img, scripted_affine): tensor, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST ) if true_tensor is not None: - self.assertTrue( - true_tensor.equal(out_tensor), - msg="{}\n{} vs \n{}".format(a, out_tensor[0, :5, :5], true_tensor[0, :5, :5]) + assert_equal( + true_tensor, + out_tensor, + msg="{}\n{} vs \n{}".format(a, out_tensor[0, :5, :5], true_tensor[0, :5, :5]), + check_stride=False, ) if out_tensor.dtype != torch.uint8: @@ -593,18 +594,19 @@ def test_affine(self): with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"): res1 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=2) res2 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=BILINEAR) - self.assertTrue(res1.equal(res2)) + assert_equal(res1, res2) # assert changed type warning with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): res1 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=2) res2 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=BILINEAR) - self.assertTrue(res1.equal(res2)) + assert_equal(res1, res2) with self.assertWarnsRegex(UserWarning, r"Argument fillcolor is deprecated and will be removed"): res1 = F.affine(pil_img, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], fillcolor=10) res2 = F.affine(pil_img, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], fill=10) - self.assertEqual(res1, res2) + # we convert the PIL images to numpy as assert_equal doesn't work on PIL images. + assert_equal(np.asarray(res1), np.asarray(res2)) def _test_rotate_all_options(self, tensor, pil_img, scripted_rotate, centers): img_size = pil_img.size @@ -682,13 +684,13 @@ def test_rotate(self): with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"): res1 = F.rotate(tensor, 45, resample=2) res2 = F.rotate(tensor, 45, interpolation=BILINEAR) - self.assertTrue(res1.equal(res2)) + assert_equal(res1, res2) # assert changed type warning with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): res1 = F.rotate(tensor, 45, interpolation=2) res2 = F.rotate(tensor, 45, interpolation=BILINEAR) - self.assertTrue(res1.equal(res2)) + assert_equal(res1, res2) def test_gaussian_blur(self): small_image_tensor = torch.from_numpy( @@ -747,10 +749,8 @@ def test_gaussian_blur(self): for fn in [F.gaussian_blur, scripted_transform]: out = fn(tensor, kernel_size=ksize, sigma=sigma) - self.assertEqual(true_out.shape, out.shape, msg="{}, {}".format(ksize, sigma)) - self.assertLessEqual( - torch.max(true_out.float() - out.float()), - 1.0, + torch.testing.assert_close( + out, true_out, rtol=0.0, atol=1.0, check_stride=False, msg="{}, {}".format(ksize, sigma) ) @@ -771,7 +771,7 @@ def test_scale_channel(self): img_chan = torch.randint(0, 256, size=size).to('cpu') scaled_cpu = F_t._scale_channel(img_chan) scaled_cuda = F_t._scale_channel(img_chan.to('cuda')) - self.assertTrue(scaled_cpu.equal(scaled_cuda.to('cpu'))) + assert_equal(scaled_cpu, scaled_cuda.to('cpu')) def _get_data_dims_and_points_for_perspective(): From 21049e905dacb3692a5030b60a94fee29d7bd8cc Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 24 May 2021 17:03:57 +0100 Subject: [PATCH 103/279] Use torch.testing.assert_close in test_models.py (#3879) Co-authored-by: Philip Meier --- test/test_models.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/test/test_models.py b/test/test_models.py index 401c4175ccf..2995e66b6fd 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -120,7 +120,7 @@ def check_out(out): # predictions match. expected_file = self._get_expected_file(name) expected = torch.load(expected_file) - self.assertEqual(out.argmax(dim=1), expected.argmax(dim=1), prec=prec) + torch.testing.assert_close(out.argmax(dim=1), expected.argmax(dim=1), rtol=prec, atol=prec) return False # Partial validation performed return True # Full validation performed @@ -205,7 +205,8 @@ def compute_mean_std(tensor): # scores. expected_file = self._get_expected_file(name) expected = torch.load(expected_file) - self.assertEqual(output[0]["scores"], expected[0]["scores"], prec=prec) + torch.testing.assert_close(output[0]["scores"], expected[0]["scores"], rtol=prec, atol=prec, + check_device=False, check_dtype=False) # Note: Fmassa proposed turning off NMS by adapting the threshold # and then using the Hungarian algorithm as in DETR to find the @@ -301,10 +302,8 @@ def test_memory_efficient_densenet(self): model2.eval() out2 = model2(x) - max_diff = (out1 - out2).abs().max() - self.assertTrue(num_params == num_grad) - self.assertTrue(max_diff < 1e-5) + torch.testing.assert_close(out1, out2, rtol=0.0, atol=1e-5) def test_resnet_dilation(self): # TODO improve tests to also check that each layer has the right dimensionality From 9c31d1d5af5877514ebdf12c15d65110715d6040 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 24 May 2021 18:29:56 +0100 Subject: [PATCH 104/279] Fix pointer to contiguous data in quantized roi_align (#3904) --- torchvision/csrc/ops/quantized/cpu/qroi_align_kernel.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/torchvision/csrc/ops/quantized/cpu/qroi_align_kernel.cpp b/torchvision/csrc/ops/quantized/cpu/qroi_align_kernel.cpp index e34b277747e..cfd5ec4ee97 100644 --- a/torchvision/csrc/ops/quantized/cpu/qroi_align_kernel.cpp +++ b/torchvision/csrc/ops/quantized/cpu/qroi_align_kernel.cpp @@ -23,11 +23,15 @@ void qroi_align_forward_kernel_impl( bool aligned, const at::Tensor& t_rois, T* output) { - const T* input = t_input.contiguous().data_ptr(); + // Don't delete these otherwise the .data_ptr() data might be undefined + auto t_input_cont = t_input.contiguous(); + auto t_rois_cont = t_rois.contiguous(); + + const T* input = t_input_cont.data_ptr(); int64_t input_zp = t_input.q_zero_point(); float input_scale = t_input.q_scale(); - const T* rois = t_rois.contiguous().data_ptr(); + const T* rois = t_rois_cont.data_ptr(); int64_t rois_zp = t_rois.q_zero_point(); float rois_scale = t_rois.q_scale(); From 21824ce62718116e998c6c65715aaa421d93b7ee Mon Sep 17 00:00:00 2001 From: vfdev Date: Tue, 25 May 2021 10:58:49 +0200 Subject: [PATCH 105/279] Port resize tests to pytest and fix their flakyness (#3907) Co-authored-by: Philip Meier --- test/test_functional_tensor.py | 149 +++++++++++++++++---------------- 1 file changed, 77 insertions(+), 72 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 9b73308e3e1..12a8d41914b 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -324,76 +324,6 @@ def test_pad(self): self._test_fn_on_batch(batch_tensors, F.pad, padding=script_pad, **kwargs) - def test_resize(self): - script_fn = torch.jit.script(F.resize) - tensor, pil_img = self._create_data(26, 36, device=self.device) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) - - for dt in [None, torch.float32, torch.float64, torch.float16]: - - if dt == torch.float16 and torch.device(self.device).type == "cpu": - # skip float16 on CPU case - continue - - if dt is not None: - # This is a trivial cast to float of uint8 data to test all cases - tensor = tensor.to(dt) - batch_tensors = batch_tensors.to(dt) - - for size in [32, 26, [32, ], [32, 32], (32, 32), [26, 35]]: - for max_size in (None, 33, 40, 1000): - if max_size is not None and isinstance(size, Sequence) and len(size) != 1: - continue # unsupported, see assertRaises below - for interpolation in [BILINEAR, BICUBIC, NEAREST]: - resized_tensor = F.resize(tensor, size=size, interpolation=interpolation, max_size=max_size) - resized_pil_img = F.resize(pil_img, size=size, interpolation=interpolation, max_size=max_size) - - assert_equal( - resized_tensor.size()[1:], - resized_pil_img.size[::-1], - msg="{}, {}".format(size, interpolation), - ) - - if interpolation not in [NEAREST, ]: - # We can not check values if mode = NEAREST, as results are different - # E.g. resized_tensor = [[a, a, b, c, d, d, e, ...]] - # E.g. resized_pil_img = [[a, b, c, c, d, e, f, ...]] - resized_tensor_f = resized_tensor - # we need to cast to uint8 to compare with PIL image - if resized_tensor_f.dtype == torch.uint8: - resized_tensor_f = resized_tensor_f.to(torch.float) - - # Pay attention to high tolerance for MAE - self.approxEqualTensorToPIL( - resized_tensor_f, resized_pil_img, tol=8.0, msg="{}, {}".format(size, interpolation) - ) - - if isinstance(size, int): - script_size = [size, ] - else: - script_size = size - - resize_result = script_fn(tensor, size=script_size, interpolation=interpolation, - max_size=max_size) - assert_equal(resized_tensor, resize_result, msg="{}, {}".format(size, interpolation)) - - self._test_fn_on_batch( - batch_tensors, F.resize, size=script_size, interpolation=interpolation, max_size=max_size - ) - - # assert changed type warning - with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): - res1 = F.resize(tensor, size=32, interpolation=2) - res2 = F.resize(tensor, size=32, interpolation=BILINEAR) - assert_equal(res1, res2) - - for img in (tensor, pil_img): - exp_msg = "max_size should only be passed if size specifies the length of the smaller edge" - with self.assertRaisesRegex(ValueError, exp_msg): - F.resize(img, size=(32, 34), max_size=35) - with self.assertRaisesRegex(ValueError, "max_size = 32 must be strictly greater"): - F.resize(img, size=32, max_size=32) - def test_resized_crop(self): # test values of F.resized_crop in several cases: # 1) resize to the same size, crop to the same size => should be identity @@ -868,18 +798,93 @@ def test_perspective_interpolation_warning(tester): tester.assertTrue(res1.equal(res2)) +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) +@pytest.mark.parametrize('size', [32, 26, [32, ], [32, 32], (32, 32), [26, 35]]) +@pytest.mark.parametrize('max_size', [None, 34, 40, 1000]) +@pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC, NEAREST]) +def test_resize(device, dt, size, max_size, interpolation, tester): + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + if max_size is not None and isinstance(size, Sequence) and len(size) != 1: + return # unsupported + + torch.manual_seed(12) + script_fn = torch.jit.script(F.resize) + tensor, pil_img = tester._create_data(26, 36, device=device) + batch_tensors = tester._create_data_batch(16, 18, num_samples=4, device=device) + + if dt is not None: + # This is a trivial cast to float of uint8 data to test all cases + tensor = tensor.to(dt) + batch_tensors = batch_tensors.to(dt) + + resized_tensor = F.resize(tensor, size=size, interpolation=interpolation, max_size=max_size) + resized_pil_img = F.resize(pil_img, size=size, interpolation=interpolation, max_size=max_size) + + assert resized_tensor.size()[1:] == resized_pil_img.size[::-1] + + if interpolation not in [NEAREST, ]: + # We can not check values if mode = NEAREST, as results are different + # E.g. resized_tensor = [[a, a, b, c, d, d, e, ...]] + # E.g. resized_pil_img = [[a, b, c, c, d, e, f, ...]] + resized_tensor_f = resized_tensor + # we need to cast to uint8 to compare with PIL image + if resized_tensor_f.dtype == torch.uint8: + resized_tensor_f = resized_tensor_f.to(torch.float) + + # Pay attention to high tolerance for MAE + tester.approxEqualTensorToPIL(resized_tensor_f, resized_pil_img, tol=8.0) + + if isinstance(size, int): + script_size = [size, ] + else: + script_size = size + + resize_result = script_fn( + tensor, size=script_size, interpolation=interpolation, max_size=max_size + ) + assert_equal(resized_tensor, resize_result) + + tester._test_fn_on_batch( + batch_tensors, F.resize, size=script_size, interpolation=interpolation, max_size=max_size + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_resize_asserts(device, tester): + + tensor, pil_img = tester._create_data(26, 36, device=device) + + # assert changed type warning + with pytest.warns(UserWarning, match=r"Argument interpolation should be of type InterpolationMode"): + res1 = F.resize(tensor, size=32, interpolation=2) + + res2 = F.resize(tensor, size=32, interpolation=BILINEAR) + assert_equal(res1, res2) + + for img in (tensor, pil_img): + exp_msg = "max_size should only be passed if size specifies the length of the smaller edge" + with pytest.raises(ValueError, match=exp_msg): + F.resize(img, size=(32, 34), max_size=35) + with pytest.raises(ValueError, match="max_size = 32 must be strictly greater"): + F.resize(img, size=32, max_size=32) + + @pytest.mark.parametrize('device', cpu_and_gpu()) @pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) @pytest.mark.parametrize('size', [[96, 72], [96, 420], [420, 72]]) @pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC]) def test_resize_antialias(device, dt, size, interpolation, tester): - torch.manual_seed(12) - if dt == torch.float16 and device == "cpu": # skip float16 on CPU case return + torch.manual_seed(12) script_fn = torch.jit.script(F.resize) tensor, pil_img = tester._create_data(320, 290, device=device) From c58d5d1747e629d71b4aec48b5c6e0e122c95a0f Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 25 May 2021 12:06:25 +0100 Subject: [PATCH 106/279] Fix bug on detection backbones when trainable_layers == 0 (#3906) * Fix a bug when trainable_layers == 0 * Fix same issue on ssd. --- torchvision/models/detection/backbone_utils.py | 2 +- torchvision/models/detection/ssd.py | 2 +- torchvision/models/detection/ssdlite.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/torchvision/models/detection/backbone_utils.py b/torchvision/models/detection/backbone_utils.py index d662de8078a..3178a81b52c 100644 --- a/torchvision/models/detection/backbone_utils.py +++ b/torchvision/models/detection/backbone_utils.py @@ -151,7 +151,7 @@ def mobilenet_backbone( # find the index of the layer from which we wont freeze assert 0 <= trainable_layers <= num_stages - freeze_before = num_stages if trainable_layers == 0 else stage_indices[num_stages - trainable_layers] + freeze_before = len(backbone) if trainable_layers == 0 else stage_indices[num_stages - trainable_layers] for b in backbone[:freeze_before]: for parameter in b.parameters(): diff --git a/torchvision/models/detection/ssd.py b/torchvision/models/detection/ssd.py index 6695167d462..b6e620dba4a 100644 --- a/torchvision/models/detection/ssd.py +++ b/torchvision/models/detection/ssd.py @@ -510,7 +510,7 @@ def _vgg_extractor(backbone_name: str, highres: bool, progress: bool, pretrained # find the index of the layer from which we wont freeze assert 0 <= trainable_layers <= num_stages - freeze_before = num_stages if trainable_layers == 0 else stage_indices[num_stages - trainable_layers] + freeze_before = len(backbone) if trainable_layers == 0 else stage_indices[num_stages - trainable_layers] for b in backbone[:freeze_before]: for parameter in b.parameters(): diff --git a/torchvision/models/detection/ssdlite.py b/torchvision/models/detection/ssdlite.py index 30e4383ed5d..26378d7038d 100644 --- a/torchvision/models/detection/ssdlite.py +++ b/torchvision/models/detection/ssdlite.py @@ -147,7 +147,7 @@ def _mobilenet_extractor(backbone_name: str, progress: bool, pretrained: bool, t # find the index of the layer from which we wont freeze assert 0 <= trainable_layers <= num_stages - freeze_before = num_stages if trainable_layers == 0 else stage_indices[num_stages - trainable_layers] + freeze_before = len(backbone) if trainable_layers == 0 else stage_indices[num_stages - trainable_layers] for b in backbone[:freeze_before]: for parameter in b.parameters(): From eaddb902c29547fb036a14b6a2e6be4bb436210d Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 25 May 2021 12:10:54 +0100 Subject: [PATCH 107/279] Fix write and encode jpeg tests (#3908) --- test/test_image.py | 229 ++++++++++++++++++++++++++++++--------------- 1 file changed, 156 insertions(+), 73 deletions(-) diff --git a/test/test_image.py b/test/test_image.py index ebc47fde9e4..eae4a1473c5 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -1,24 +1,36 @@ import glob import io import os +import sys import unittest +from pathlib import Path import pytest import numpy as np import torch from PIL import Image -from common_utils import get_tmp_dir, needs_cuda +import torchvision.transforms.functional as F +from common_utils import get_tmp_dir, needs_cuda, cpu_only from _assert_utils import assert_equal from torchvision.io.image import ( decode_png, decode_jpeg, encode_jpeg, write_jpeg, decode_image, read_file, - encode_png, write_png, write_file, ImageReadMode) + encode_png, write_png, write_file, ImageReadMode, read_image) IMAGE_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets") FAKEDATA_DIR = os.path.join(IMAGE_ROOT, "fakedata") IMAGE_DIR = os.path.join(FAKEDATA_DIR, "imagefolder") DAMAGED_JPEG = os.path.join(IMAGE_ROOT, 'damaged_jpeg') ENCODE_JPEG = os.path.join(IMAGE_ROOT, "encode_jpeg") +IS_WINDOWS = sys.platform in ('win32', 'cygwin') + + +def _get_safe_image_name(name): + # Used when we need to change the pytest "id" for an "image path" parameter. + # If we don't, the test id (i.e. its name) will contain the whole path to the image, which is machine-specific, + # and this creates issues when the test is running in a different machine than where it was collected + # (typically, in fb internal infra) + return name.split(os.path.sep)[-1] def get_images(directory, img_ext): @@ -93,72 +105,6 @@ def test_damaged_images(self): with self.assertRaises(RuntimeError): decode_jpeg(data) - def test_encode_jpeg(self): - for img_path in get_images(ENCODE_JPEG, ".jpg"): - dirname = os.path.dirname(img_path) - filename, _ = os.path.splitext(os.path.basename(img_path)) - write_folder = os.path.join(dirname, 'jpeg_write') - expected_file = os.path.join( - write_folder, '{0}_pil.jpg'.format(filename)) - img = decode_jpeg(read_file(img_path)) - - with open(expected_file, 'rb') as f: - pil_bytes = f.read() - pil_bytes = torch.as_tensor(list(pil_bytes), dtype=torch.uint8) - for src_img in [img, img.contiguous()]: - # PIL sets jpeg quality to 75 by default - jpeg_bytes = encode_jpeg(src_img, quality=75) - assert_equal(jpeg_bytes, pil_bytes) - - with self.assertRaisesRegex( - RuntimeError, "Input tensor dtype should be uint8"): - encode_jpeg(torch.empty((3, 100, 100), dtype=torch.float32)) - - with self.assertRaisesRegex( - ValueError, "Image quality should be a positive number " - "between 1 and 100"): - encode_jpeg(torch.empty((3, 100, 100), dtype=torch.uint8), quality=-1) - - with self.assertRaisesRegex( - ValueError, "Image quality should be a positive number " - "between 1 and 100"): - encode_jpeg(torch.empty((3, 100, 100), dtype=torch.uint8), quality=101) - - with self.assertRaisesRegex( - RuntimeError, "The number of channels should be 1 or 3, got: 5"): - encode_jpeg(torch.empty((5, 100, 100), dtype=torch.uint8)) - - with self.assertRaisesRegex( - RuntimeError, "Input data should be a 3-dimensional tensor"): - encode_jpeg(torch.empty((1, 3, 100, 100), dtype=torch.uint8)) - - with self.assertRaisesRegex( - RuntimeError, "Input data should be a 3-dimensional tensor"): - encode_jpeg(torch.empty((100, 100), dtype=torch.uint8)) - - def test_write_jpeg(self): - with get_tmp_dir() as d: - for img_path in get_images(ENCODE_JPEG, ".jpg"): - data = read_file(img_path) - img = decode_jpeg(data) - - basedir = os.path.dirname(img_path) - filename, _ = os.path.splitext(os.path.basename(img_path)) - torch_jpeg = os.path.join( - d, '{0}_torch.jpg'.format(filename)) - pil_jpeg = os.path.join( - basedir, 'jpeg_write', '{0}_pil.jpg'.format(filename)) - - write_jpeg(img, torch_jpeg, quality=75) - - with open(torch_jpeg, 'rb') as f: - torch_bytes = f.read() - - with open(pil_jpeg, 'rb') as f: - pil_bytes = f.read() - - self.assertEqual(torch_bytes, pil_bytes) - def test_decode_png(self): conversion = [(None, ImageReadMode.UNCHANGED), ("L", ImageReadMode.GRAY), ("LA", ImageReadMode.GRAY_ALPHA), ("RGB", ImageReadMode.RGB), ("RGBA", ImageReadMode.RGB_ALPHA)] @@ -282,11 +228,7 @@ def test_write_file_non_ascii(self): @needs_cuda @pytest.mark.parametrize('img_path', [ - # We need to change the "id" for that parameter. - # If we don't, the test id (i.e. its name) will contain the whole path to the image which is machine-specific, - # and this creates issues when the test is running in a different machine than where it was collected - # (typically, in fb internal infra) - pytest.param(jpeg_path, id=jpeg_path.split('/')[-1]) + pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) for jpeg_path in get_images(IMAGE_ROOT, ".jpg") ]) @pytest.mark.parametrize('mode', [ImageReadMode.UNCHANGED, ImageReadMode.GRAY, ImageReadMode.RGB]) @@ -325,5 +267,146 @@ def test_decode_jpeg_cuda_errors(): torch.ops.image.decode_jpeg_cuda(data, ImageReadMode.UNCHANGED.value, 'cpu') +@cpu_only +def test_encode_jpeg_errors(): + + with pytest.raises(RuntimeError, match="Input tensor dtype should be uint8"): + encode_jpeg(torch.empty((3, 100, 100), dtype=torch.float32)) + + with pytest.raises(ValueError, match="Image quality should be a positive number " + "between 1 and 100"): + encode_jpeg(torch.empty((3, 100, 100), dtype=torch.uint8), quality=-1) + + with pytest.raises(ValueError, match="Image quality should be a positive number " + "between 1 and 100"): + encode_jpeg(torch.empty((3, 100, 100), dtype=torch.uint8), quality=101) + + with pytest.raises(RuntimeError, match="The number of channels should be 1 or 3, got: 5"): + encode_jpeg(torch.empty((5, 100, 100), dtype=torch.uint8)) + + with pytest.raises(RuntimeError, match="Input data should be a 3-dimensional tensor"): + encode_jpeg(torch.empty((1, 3, 100, 100), dtype=torch.uint8)) + + with pytest.raises(RuntimeError, match="Input data should be a 3-dimensional tensor"): + encode_jpeg(torch.empty((100, 100), dtype=torch.uint8)) + + +def _collect_if(cond): + # TODO: remove this once test_encode_jpeg_windows and test_write_jpeg_windows + # are removed + def _inner(test_func): + if cond: + return test_func + else: + return pytest.mark.dont_collect(test_func) + return _inner + + +@cpu_only +@_collect_if(cond=IS_WINDOWS) +def test_encode_jpeg_windows(): + # This test is *wrong*. + # It compares a torchvision-encoded jpeg with a PIL-encoded jpeg, but it + # starts encoding the torchvision version from an image that comes from + # decode_jpeg, which can yield different results from pil.decode (see + # test_decode... which uses a high tolerance). + # Instead, we should start encoding from the exact same decoded image, for a + # valid comparison. This is done in test_encode_jpeg, but unfortunately + # these more correct tests fail on windows (probably because of a difference + # in libjpeg) between torchvision and PIL. + # FIXME: make the correct tests pass on windows and remove this. + for img_path in get_images(ENCODE_JPEG, ".jpg"): + dirname = os.path.dirname(img_path) + filename, _ = os.path.splitext(os.path.basename(img_path)) + write_folder = os.path.join(dirname, 'jpeg_write') + expected_file = os.path.join( + write_folder, '{0}_pil.jpg'.format(filename)) + img = decode_jpeg(read_file(img_path)) + + with open(expected_file, 'rb') as f: + pil_bytes = f.read() + pil_bytes = torch.as_tensor(list(pil_bytes), dtype=torch.uint8) + for src_img in [img, img.contiguous()]: + # PIL sets jpeg quality to 75 by default + jpeg_bytes = encode_jpeg(src_img, quality=75) + assert_equal(jpeg_bytes, pil_bytes) + + +@cpu_only +@_collect_if(cond=IS_WINDOWS) +def test_write_jpeg_windows(): + # FIXME: Remove this eventually, see test_encode_jpeg_windows + with get_tmp_dir() as d: + for img_path in get_images(ENCODE_JPEG, ".jpg"): + data = read_file(img_path) + img = decode_jpeg(data) + + basedir = os.path.dirname(img_path) + filename, _ = os.path.splitext(os.path.basename(img_path)) + torch_jpeg = os.path.join( + d, '{0}_torch.jpg'.format(filename)) + pil_jpeg = os.path.join( + basedir, 'jpeg_write', '{0}_pil.jpg'.format(filename)) + + write_jpeg(img, torch_jpeg, quality=75) + + with open(torch_jpeg, 'rb') as f: + torch_bytes = f.read() + + with open(pil_jpeg, 'rb') as f: + pil_bytes = f.read() + + assert_equal(torch_bytes, pil_bytes) + + +@cpu_only +@_collect_if(cond=not IS_WINDOWS) +@pytest.mark.parametrize('img_path', [ + pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) + for jpeg_path in get_images(ENCODE_JPEG, ".jpg") +]) +def test_encode_jpeg(img_path): + img = read_image(img_path) + + pil_img = F.to_pil_image(img) + buf = io.BytesIO() + pil_img.save(buf, format='JPEG', quality=75) + + # pytorch can't read from raw bytes so we go through numpy + pil_bytes = np.frombuffer(buf.getvalue(), dtype=np.uint8) + encoded_jpeg_pil = torch.as_tensor(pil_bytes) + + for src_img in [img, img.contiguous()]: + encoded_jpeg_torch = encode_jpeg(src_img, quality=75) + assert_equal(encoded_jpeg_torch, encoded_jpeg_pil) + + +@cpu_only +@_collect_if(cond=not IS_WINDOWS) +@pytest.mark.parametrize('img_path', [ + pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) + for jpeg_path in get_images(ENCODE_JPEG, ".jpg") +]) +def test_write_jpeg(img_path): + with get_tmp_dir() as d: + d = Path(d) + img = read_image(img_path) + pil_img = F.to_pil_image(img) + + torch_jpeg = str(d / 'torch.jpg') + pil_jpeg = str(d / 'pil.jpg') + + write_jpeg(img, torch_jpeg, quality=75) + pil_img.save(pil_jpeg, quality=75) + + with open(torch_jpeg, 'rb') as f: + torch_bytes = f.read() + + with open(pil_jpeg, 'rb') as f: + pil_bytes = f.read() + + assert_equal(torch_bytes, pil_bytes) + + if __name__ == '__main__': unittest.main() From 1b6fe6827ac20d1e058f8d0b6f80b0f3cc93971b Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 25 May 2021 12:40:50 +0100 Subject: [PATCH 108/279] remove masks (#3910) Co-authored-by: Vasilis Vryniotis --- test/test_utils.py | 24 ------------------------ 1 file changed, 24 deletions(-) diff --git a/test/test_utils.py b/test/test_utils.py index e9bafdeab42..9e59a10aa5c 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -17,30 +17,6 @@ boxes = torch.tensor([[0, 0, 20, 20], [0, 0, 0, 0], [10, 15, 30, 35], [23, 35, 93, 95]], dtype=torch.float) -masks = torch.tensor([ - [ - [-2.2799, -2.2799, -2.2799, -2.2799, -2.2799], - [5.0914, 5.0914, 5.0914, 5.0914, 5.0914], - [-2.2799, -2.2799, -2.2799, -2.2799, -2.2799], - [-2.2799, -2.2799, -2.2799, -2.2799, -2.2799], - [-2.2799, -2.2799, -2.2799, -2.2799, -2.2799] - ], - [ - [5.0914, 5.0914, 5.0914, 5.0914, 5.0914], - [-2.2799, -2.2799, -2.2799, -2.2799, -2.2799], - [5.0914, 5.0914, 5.0914, 5.0914, 5.0914], - [5.0914, 5.0914, 5.0914, 5.0914, 5.0914], - [-1.4541, -1.4541, -1.4541, -1.4541, -1.4541] - ], - [ - [-1.4541, -1.4541, -1.4541, -1.4541, -1.4541], - [-1.4541, -1.4541, -1.4541, -1.4541, -1.4541], - [-1.4541, -1.4541, -1.4541, -1.4541, -1.4541], - [-1.4541, -1.4541, -1.4541, -1.4541, -1.4541], - [5.0914, 5.0914, 5.0914, 5.0914, 5.0914], - ] -], dtype=torch.float) - class Tester(unittest.TestCase): From 154283b1ceaad85f582d9e721a02fd9c6b31952a Mon Sep 17 00:00:00 2001 From: Zhiqiang Wang Date: Wed, 26 May 2021 04:50:12 +0800 Subject: [PATCH 109/279] Port test/test_utils.py to pytest (#3917) --- test/test_utils.py | 239 +++++++++++++++++++++++---------------------- 1 file changed, 124 insertions(+), 115 deletions(-) diff --git a/test/test_utils.py b/test/test_utils.py index 9e59a10aa5c..3fed2535c77 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -5,7 +5,7 @@ import tempfile import torch import torchvision.utils as utils -import unittest + from io import BytesIO import torchvision.transforms.functional as F from PIL import Image, __version__ as PILLOW_VERSION, ImageColor @@ -18,122 +18,131 @@ [10, 15, 30, 35], [23, 35, 93, 95]], dtype=torch.float) -class Tester(unittest.TestCase): - - def test_make_grid_not_inplace(self): - t = torch.rand(5, 3, 10, 10) - t_clone = t.clone() - - utils.make_grid(t, normalize=False) - assert_equal(t, t_clone, msg='make_grid modified tensor in-place') - - utils.make_grid(t, normalize=True, scale_each=False) - assert_equal(t, t_clone, msg='make_grid modified tensor in-place') - - utils.make_grid(t, normalize=True, scale_each=True) - assert_equal(t, t_clone, msg='make_grid modified tensor in-place') - - def test_normalize_in_make_grid(self): - t = torch.rand(5, 3, 10, 10) * 255 - norm_max = torch.tensor(1.0) - norm_min = torch.tensor(0.0) - - grid = utils.make_grid(t, normalize=True) - grid_max = torch.max(grid) - grid_min = torch.min(grid) - - # Rounding the result to one decimal for comparison - n_digits = 1 - rounded_grid_max = torch.round(grid_max * 10 ** n_digits) / (10 ** n_digits) - rounded_grid_min = torch.round(grid_min * 10 ** n_digits) / (10 ** n_digits) - - assert_equal(norm_max, rounded_grid_max, msg='Normalized max is not equal to 1') - assert_equal(norm_min, rounded_grid_min, msg='Normalized min is not equal to 0') - - @unittest.skipIf(sys.platform in ('win32', 'cygwin'), 'temporarily disabled on Windows') - def test_save_image(self): - with tempfile.NamedTemporaryFile(suffix='.png') as f: - t = torch.rand(2, 3, 64, 64) - utils.save_image(t, f.name) - self.assertTrue(os.path.exists(f.name), 'The image is not present after save') - - @unittest.skipIf(sys.platform in ('win32', 'cygwin'), 'temporarily disabled on Windows') - def test_save_image_single_pixel(self): - with tempfile.NamedTemporaryFile(suffix='.png') as f: - t = torch.rand(1, 3, 1, 1) - utils.save_image(t, f.name) - self.assertTrue(os.path.exists(f.name), 'The pixel image is not present after save') - - @unittest.skipIf(sys.platform in ('win32', 'cygwin'), 'temporarily disabled on Windows') - def test_save_image_file_object(self): - with tempfile.NamedTemporaryFile(suffix='.png') as f: - t = torch.rand(2, 3, 64, 64) - utils.save_image(t, f.name) - img_orig = Image.open(f.name) - fp = BytesIO() - utils.save_image(t, fp, format='png') - img_bytes = Image.open(fp) - assert_equal(F.to_tensor(img_orig), F.to_tensor(img_bytes), msg='Image not stored in file object') - - @unittest.skipIf(sys.platform in ('win32', 'cygwin'), 'temporarily disabled on Windows') - def test_save_image_single_pixel_file_object(self): - with tempfile.NamedTemporaryFile(suffix='.png') as f: - t = torch.rand(1, 3, 1, 1) - utils.save_image(t, f.name) - img_orig = Image.open(f.name) - fp = BytesIO() - utils.save_image(t, fp, format='png') - img_bytes = Image.open(fp) - assert_equal(F.to_tensor(img_orig), F.to_tensor(img_bytes), msg='Image not stored in file object') - - def test_draw_boxes(self): - img = torch.full((3, 100, 100), 255, dtype=torch.uint8) - img_cp = img.clone() - boxes_cp = boxes.clone() - labels = ["a", "b", "c", "d"] - colors = ["green", "#FF00FF", (0, 255, 0), "red"] - result = utils.draw_bounding_boxes(img, boxes, labels=labels, colors=colors, fill=True) - - path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets", "fakedata", "draw_boxes_util.png") - if not os.path.exists(path): - res = Image.fromarray(result.permute(1, 2, 0).contiguous().numpy()) - res.save(path) - - if PILLOW_VERSION >= (8, 2): - # The reference image is only valid for new PIL versions - expected = torch.as_tensor(np.array(Image.open(path))).permute(2, 0, 1) - assert_equal(result, expected) - - # Check if modification is not in place - assert_equal(boxes, boxes_cp) - assert_equal(img, img_cp) - - def test_draw_boxes_vanilla(self): - img = torch.full((3, 100, 100), 0, dtype=torch.uint8) - img_cp = img.clone() - boxes_cp = boxes.clone() - result = utils.draw_bounding_boxes(img, boxes, fill=False, width=7) - - path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets", "fakedata", "draw_boxes_vanilla.png") - if not os.path.exists(path): - res = Image.fromarray(result.permute(1, 2, 0).contiguous().numpy()) - res.save(path) +def test_make_grid_not_inplace(): + t = torch.rand(5, 3, 10, 10) + t_clone = t.clone() + + utils.make_grid(t, normalize=False) + assert_equal(t, t_clone, msg='make_grid modified tensor in-place') + + utils.make_grid(t, normalize=True, scale_each=False) + assert_equal(t, t_clone, msg='make_grid modified tensor in-place') + + utils.make_grid(t, normalize=True, scale_each=True) + assert_equal(t, t_clone, msg='make_grid modified tensor in-place') + + +def test_normalize_in_make_grid(): + t = torch.rand(5, 3, 10, 10) * 255 + norm_max = torch.tensor(1.0) + norm_min = torch.tensor(0.0) + + grid = utils.make_grid(t, normalize=True) + grid_max = torch.max(grid) + grid_min = torch.min(grid) + + # Rounding the result to one decimal for comparison + n_digits = 1 + rounded_grid_max = torch.round(grid_max * 10 ** n_digits) / (10 ** n_digits) + rounded_grid_min = torch.round(grid_min * 10 ** n_digits) / (10 ** n_digits) + + assert_equal(norm_max, rounded_grid_max, msg='Normalized max is not equal to 1') + assert_equal(norm_min, rounded_grid_min, msg='Normalized min is not equal to 0') + + +@pytest.mark.skipif(sys.platform in ('win32', 'cygwin'), reason='temporarily disabled on Windows') +def test_save_image(): + with tempfile.NamedTemporaryFile(suffix='.png') as f: + t = torch.rand(2, 3, 64, 64) + utils.save_image(t, f.name) + assert os.path.exists(f.name), 'The image is not present after save' + +@pytest.mark.skipif(sys.platform in ('win32', 'cygwin'), reason='temporarily disabled on Windows') +def test_save_image_single_pixel(): + with tempfile.NamedTemporaryFile(suffix='.png') as f: + t = torch.rand(1, 3, 1, 1) + utils.save_image(t, f.name) + assert os.path.exists(f.name), 'The pixel image is not present after save' + + +@pytest.mark.skipif(sys.platform in ('win32', 'cygwin'), reason='temporarily disabled on Windows') +def test_save_image_file_object(): + with tempfile.NamedTemporaryFile(suffix='.png') as f: + t = torch.rand(2, 3, 64, 64) + utils.save_image(t, f.name) + img_orig = Image.open(f.name) + fp = BytesIO() + utils.save_image(t, fp, format='png') + img_bytes = Image.open(fp) + assert_equal(F.to_tensor(img_orig), F.to_tensor(img_bytes), msg='Image not stored in file object') + + +@pytest.mark.skipif(sys.platform in ('win32', 'cygwin'), reason='temporarily disabled on Windows') +def test_save_image_single_pixel_file_object(): + with tempfile.NamedTemporaryFile(suffix='.png') as f: + t = torch.rand(1, 3, 1, 1) + utils.save_image(t, f.name) + img_orig = Image.open(f.name) + fp = BytesIO() + utils.save_image(t, fp, format='png') + img_bytes = Image.open(fp) + assert_equal(F.to_tensor(img_orig), F.to_tensor(img_bytes), msg='Image not stored in file object') + + +def test_draw_boxes(): + img = torch.full((3, 100, 100), 255, dtype=torch.uint8) + img_cp = img.clone() + boxes_cp = boxes.clone() + labels = ["a", "b", "c", "d"] + colors = ["green", "#FF00FF", (0, 255, 0), "red"] + result = utils.draw_bounding_boxes(img, boxes, labels=labels, colors=colors, fill=True) + + path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets", "fakedata", "draw_boxes_util.png") + if not os.path.exists(path): + res = Image.fromarray(result.permute(1, 2, 0).contiguous().numpy()) + res.save(path) + + if PILLOW_VERSION >= (8, 2): + # The reference image is only valid for new PIL versions expected = torch.as_tensor(np.array(Image.open(path))).permute(2, 0, 1) assert_equal(result, expected) - # Check if modification is not in place - assert_equal(boxes, boxes_cp) - assert_equal(img, img_cp) - def test_draw_invalid_boxes(self): - img_tp = ((1, 1, 1), (1, 2, 3)) - img_wrong1 = torch.full((3, 5, 5), 255, dtype=torch.float) - img_wrong2 = torch.full((1, 3, 5, 5), 255, dtype=torch.uint8) - boxes = torch.tensor([[0, 0, 20, 20], [0, 0, 0, 0], - [10, 15, 30, 35], [23, 35, 93, 95]], dtype=torch.float) - self.assertRaises(TypeError, utils.draw_bounding_boxes, img_tp, boxes) - self.assertRaises(ValueError, utils.draw_bounding_boxes, img_wrong1, boxes) - self.assertRaises(ValueError, utils.draw_bounding_boxes, img_wrong2, boxes) + # Check if modification is not in place + assert_equal(boxes, boxes_cp) + assert_equal(img, img_cp) + + +def test_draw_boxes_vanilla(): + img = torch.full((3, 100, 100), 0, dtype=torch.uint8) + img_cp = img.clone() + boxes_cp = boxes.clone() + result = utils.draw_bounding_boxes(img, boxes, fill=False, width=7) + + path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets", "fakedata", "draw_boxes_vanilla.png") + if not os.path.exists(path): + res = Image.fromarray(result.permute(1, 2, 0).contiguous().numpy()) + res.save(path) + + expected = torch.as_tensor(np.array(Image.open(path))).permute(2, 0, 1) + assert_equal(result, expected) + # Check if modification is not in place + assert_equal(boxes, boxes_cp) + assert_equal(img, img_cp) + + +def test_draw_invalid_boxes(): + img_tp = ((1, 1, 1), (1, 2, 3)) + img_wrong1 = torch.full((3, 5, 5), 255, dtype=torch.float) + img_wrong2 = torch.full((1, 3, 5, 5), 255, dtype=torch.uint8) + boxes = torch.tensor([[0, 0, 20, 20], [0, 0, 0, 0], + [10, 15, 30, 35], [23, 35, 93, 95]], dtype=torch.float) + with pytest.raises(TypeError, match="Tensor expected"): + utils.draw_bounding_boxes(img_tp, boxes) + with pytest.raises(ValueError, match="Tensor uint8 expected"): + utils.draw_bounding_boxes(img_wrong1, boxes) + with pytest.raises(ValueError, match="Pass individual images, not batches"): + utils.draw_bounding_boxes(img_wrong2, boxes) @pytest.mark.parametrize('colors', [ @@ -218,5 +227,5 @@ def test_draw_segmentation_masks_errors(): utils.draw_segmentation_masks(image=img, masks=masks, colors=bad_colors) -if __name__ == '__main__': - unittest.main() +if __name__ == "__main__": + pytest.main([__file__]) From f5843099d895e72c27ffa9d29cc91dd8df7f3832 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Tue, 25 May 2021 22:15:51 +0100 Subject: [PATCH 110/279] Fixed audio-video synchronisation problem in read_video() when using `pts` as unit (#3791) * Fixed audio-video synchronisation problem in read_video() when using as unit * Addressed review comments * Added unit test --- test/test_video_reader.py | 39 ++++++++++++++++++++++++++++++ torchvision/io/_video_opt.py | 47 +++++++++++++++++++++++++----------- torchvision/io/video.py | 16 +++++++++--- 3 files changed, 84 insertions(+), 18 deletions(-) diff --git a/test/test_video_reader.py b/test/test_video_reader.py index d9326138397..9818b6fc900 100644 --- a/test/test_video_reader.py +++ b/test/test_video_reader.py @@ -1238,6 +1238,45 @@ def test_read_video_from_memory_scripted(self): ) # FUTURE: check value of video / audio frames + def test_audio_video_sync(self): + """Test if audio/video are synchronised with pyav output.""" + for test_video, config in test_videos.items(): + full_path = os.path.join(VIDEO_DIR, test_video) + container = av.open(full_path) + if not container.streams.audio: + # Skip if no audio stream + continue + start_pts_val, cutoff = 0, 1 + if container.streams.video: + video = container.streams.video[0] + arr = [] + for index, frame in enumerate(container.decode(video)): + if index == cutoff: + start_pts_val = frame.pts + if index >= cutoff: + arr.append(frame.to_rgb().to_ndarray()) + visual, _, info = io.read_video(full_path, start_pts=start_pts_val, pts_unit='pts') + self.assertAlmostEqual( + config.video_fps, info['video_fps'], delta=0.0001 + ) + arr = torch.Tensor(arr) + if arr.shape == visual.shape: + self.assertGreaterEqual( + torch.mean(torch.isclose(visual.float(), arr, atol=1e-5).float()), 0.99) + + container = av.open(full_path) + if container.streams.audio: + audio = container.streams.audio[0] + arr = [] + for index, frame in enumerate(container.decode(audio)): + if index >= cutoff: + arr.append(frame.to_ndarray()) + _, audio, _ = io.read_video(full_path, start_pts=start_pts_val, pts_unit='pts') + arr = torch.as_tensor(np.concatenate(arr, axis=1)) + if arr.shape == audio.shape: + self.assertGreaterEqual( + torch.mean(torch.isclose(audio.float(), arr).float()), 0.99) + if __name__ == "__main__": unittest.main() diff --git a/torchvision/io/_video_opt.py b/torchvision/io/_video_opt.py index 4cc2b60c706..a34b023bc6c 100644 --- a/torchvision/io/_video_opt.py +++ b/torchvision/io/_video_opt.py @@ -471,6 +471,14 @@ def _probe_video_from_memory(video_data): return info +def _convert_to_sec(start_pts, end_pts, pts_unit, time_base): + if pts_unit == 'pts': + start_pts = float(start_pts * time_base) + end_pts = float(end_pts * time_base) + pts_unit = 'sec' + return start_pts, end_pts, pts_unit + + def _read_video(filename, start_pts=0, end_pts=None, pts_unit="pts"): if end_pts is None: end_pts = float("inf") @@ -485,32 +493,43 @@ def _read_video(filename, start_pts=0, end_pts=None, pts_unit="pts"): has_video = info.has_video has_audio = info.has_audio + video_pts_range = (0, -1) + video_timebase = default_timebase + audio_pts_range = (0, -1) + audio_timebase = default_timebase + time_base = default_timebase + + if has_video: + video_timebase = Fraction( + info.video_timebase.numerator, info.video_timebase.denominator + ) + time_base = video_timebase + + if has_audio: + audio_timebase = Fraction( + info.audio_timebase.numerator, info.audio_timebase.denominator + ) + time_base = time_base if time_base else audio_timebase + + # video_timebase is the default time_base + start_pts_sec, end_pts_sec, pts_unit = _convert_to_sec( + start_pts, end_pts, pts_unit, time_base) def get_pts(time_base): - start_offset = start_pts - end_offset = end_pts + start_offset = start_pts_sec + end_offset = end_pts_sec if pts_unit == "sec": - start_offset = int(math.floor(start_pts * (1 / time_base))) + start_offset = int(math.floor(start_pts_sec * (1 / time_base))) if end_offset != float("inf"): - end_offset = int(math.ceil(end_pts * (1 / time_base))) + end_offset = int(math.ceil(end_pts_sec * (1 / time_base))) if end_offset == float("inf"): end_offset = -1 return start_offset, end_offset - video_pts_range = (0, -1) - video_timebase = default_timebase if has_video: - video_timebase = Fraction( - info.video_timebase.numerator, info.video_timebase.denominator - ) video_pts_range = get_pts(video_timebase) - audio_pts_range = (0, -1) - audio_timebase = default_timebase if has_audio: - audio_timebase = Fraction( - info.audio_timebase.numerator, info.audio_timebase.denominator - ) audio_pts_range = get_pts(audio_timebase) vframes, aframes, info = _read_video_from_file( diff --git a/torchvision/io/video.py b/torchvision/io/video.py index 22cad38d10b..e16e8906d97 100644 --- a/torchvision/io/video.py +++ b/torchvision/io/video.py @@ -278,11 +278,19 @@ def read_video( try: with av.open(filename, metadata_errors="ignore") as container: + time_base = _video_opt.default_timebase + if container.streams.video: + time_base = container.streams.video[0].time_base + elif container.streams.audio: + time_base = container.streams.audio[0].time_base + # video_timebase is the default time_base + start_pts_sec, end_pts_sec, pts_unit = _video_opt._convert_to_sec( + start_pts, end_pts, pts_unit, time_base) if container.streams.video: video_frames = _read_from_stream( container, - start_pts, - end_pts, + start_pts_sec, + end_pts_sec, pts_unit, container.streams.video[0], {"video": 0}, @@ -295,8 +303,8 @@ def read_video( if container.streams.audio: audio_frames = _read_from_stream( container, - start_pts, - end_pts, + start_pts_sec, + end_pts_sec, pts_unit, container.streams.audio[0], {"audio": 0}, From 48de528919dade9f59228020c3cb99b74dd33f48 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Wed, 26 May 2021 09:02:06 +0100 Subject: [PATCH 111/279] [FBcode->GH] Add check_stride=False (#3920) --- test/test_transforms.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index 69498859778..de309cb66c5 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -834,7 +834,7 @@ def test_accimage_pil_to_tensor(self): output = trans(accimage.Image(GRACE_HOPPER)) self.assertEqual(expected_output.size(), output.size()) - torch.testing.assert_close(output, expected_output) + torch.testing.assert_close(output, expected_output, check_stride=False) @unittest.skipIf(accimage is None, 'accimage not available') def test_accimage_resize(self): From 6d1a0840c8f460514e753adebc87dff0be173586 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Wed, 26 May 2021 09:59:00 +0100 Subject: [PATCH 112/279] Reenable tests for r2plus1d_18. (#3919) Co-authored-by: Nicolas Hug --- test/test_models.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/test/test_models.py b/test/test_models.py index 2995e66b6fd..180bbcd032d 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -459,9 +459,6 @@ def test_detection_model_validation(model_name): @pytest.mark.parametrize('model_name', get_available_video_models()) @pytest.mark.parametrize('dev', _devs) def test_video_model(model_name, dev): - if IN_CIRCLE_CI and 'cuda' in dev.type and model_name == 'r2plus1d_18' and sys.platform == 'linux': - # FIXME: Failure should fixed and test re-actived. See https://github.com/pytorch/vision/issues/3702 - pytest.skip('r2plus1d_18 fails on CircleCI linux GPU machines.') ModelTester()._test_video_model(model_name, dev) From fc852f3b39fe25dd8bf1dedee8f19ea04aa84c15 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 26 May 2021 10:23:30 +0100 Subject: [PATCH 113/279] Fix installation instructions in contributing guide (#3923) --- CONTRIBUTING.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 71dde22c6a6..748dc50df9e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -44,11 +44,11 @@ conda install pytorch -c pytorch-nightly -c conda-forge ```bash git clone https://github.com/pytorch/vision.git cd vision -python setup.py install +python setup.py develop # or, for OSX -# MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ python setup.py install +# MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ python setup.py develop # for C++ debugging, please use DEBUG=1 -# DEBUG=1 python setup.py install +# DEBUG=1 python setup.py develop pip install flake8 typing mypy pytest scipy ``` You may also have to install `libpng-dev` and `libjpeg-turbo8-dev` libraries: From c2cdad4f4ed210860ae9a90983f704d34a96fd22 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Wed, 26 May 2021 12:41:38 +0100 Subject: [PATCH 114/279] Bump master versions. (#3925) --- packaging/build_cmake.sh | 2 +- packaging/build_conda.sh | 2 +- packaging/build_wheel.sh | 2 +- version.txt | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packaging/build_cmake.sh b/packaging/build_cmake.sh index 0945f576ee2..db4cc88b63f 100755 --- a/packaging/build_cmake.sh +++ b/packaging/build_cmake.sh @@ -15,7 +15,7 @@ script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" . "$script_dir/pkg_helpers.bash" export BUILD_TYPE=conda -setup_env 0.10.0 +setup_env 0.11.0 export SOURCE_ROOT_DIR="$PWD" setup_conda_pytorch_constraint setup_conda_cudatoolkit_plain_constraint diff --git a/packaging/build_conda.sh b/packaging/build_conda.sh index 5f2239aae7e..85c7d88273f 100755 --- a/packaging/build_conda.sh +++ b/packaging/build_conda.sh @@ -5,7 +5,7 @@ script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" . "$script_dir/pkg_helpers.bash" export BUILD_TYPE=conda -setup_env 0.10.0 +setup_env 0.11.0 export SOURCE_ROOT_DIR="$PWD" setup_conda_pytorch_constraint setup_conda_cudatoolkit_constraint diff --git a/packaging/build_wheel.sh b/packaging/build_wheel.sh index 05dc23a43ab..b2c9fcf57de 100755 --- a/packaging/build_wheel.sh +++ b/packaging/build_wheel.sh @@ -5,7 +5,7 @@ script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" . "$script_dir/pkg_helpers.bash" export BUILD_TYPE=wheel -setup_env 0.10.0 +setup_env 0.11.0 setup_wheel_python pip_install numpy pyyaml future ninja setup_pip_pytorch_version diff --git a/version.txt b/version.txt index 37f1777fc35..d22e31d2073 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -0.10.0a0 +0.11.0a0 From 2ab93592529243862ce8ad5b6acf2628ef8d0dc8 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Wed, 26 May 2021 17:35:12 +0100 Subject: [PATCH 115/279] Improve model parameterization on tests (#3926) * Improve model parameterization on tests. * Code review changes. --- test/test_models.py | 69 +++++++++++++++++++++++++++++++-------------- 1 file changed, 48 insertions(+), 21 deletions(-) diff --git a/test/test_models.py b/test/test_models.py index 180bbcd032d..be4c2b6995d 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -74,12 +74,37 @@ def get_available_video_models(): ) +# The following contains configuration parameters for all models which are used by +# the _test_*_model methods. +_model_params = { + 'inception_v3': { + 'input_shape': (1, 3, 299, 299) + }, + 'retinanet_resnet50_fpn': { + 'score_thresh': 0.01, + }, + 'fasterrcnn_mobilenet_v3_large_fpn': { + 'box_score_thresh': 0.02076, + }, + 'fasterrcnn_mobilenet_v3_large_320_fpn': { + 'box_score_thresh': 0.02076, + 'rpn_pre_nms_top_n_test': 1000, + 'rpn_post_nms_top_n_test': 1000, + } +} + + class ModelTester(TestCase): - def _test_classification_model(self, name, input_shape, dev): + def _test_classification_model(self, name, dev): set_rng_seed(0) - # passing num_class equal to a number other than 1000 helps in making the test - # more enforcing in nature - model = models.__dict__[name](num_classes=50) + defaults = { + 'num_classes': 50, + 'input_shape': (1, 3, 224, 224), + } + kwargs = {**defaults, **_model_params.get(name, {})} + input_shape = kwargs.pop('input_shape') + + model = models.__dict__[name](**kwargs) model.eval().to(device=dev) # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests x = torch.rand(input_shape).to(device=dev) @@ -98,11 +123,16 @@ def _test_classification_model(self, name, input_shape, dev): def _test_segmentation_model(self, name, dev): set_rng_seed(0) - # passing num_classes equal to a number other than 21 helps in making the test's - # expected file size smaller - model = models.segmentation.__dict__[name](num_classes=10, pretrained_backbone=False) + defaults = { + 'num_classes': 10, + 'pretrained_backbone': False, + 'input_shape': (1, 3, 32, 32), + } + kwargs = {**defaults, **_model_params.get(name, {})} + input_shape = kwargs.pop('input_shape') + + model = models.segmentation.__dict__[name](**kwargs) model.eval().to(device=dev) - input_shape = (1, 3, 32, 32) # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests x = torch.rand(input_shape).to(device=dev) out = model(x)["out"] @@ -146,18 +176,16 @@ def check_out(out): def _test_detection_model(self, name, dev): set_rng_seed(0) - kwargs = {} - if "retinanet" in name: - # Reduce the default threshold to ensure the returned boxes are not empty. - kwargs["score_thresh"] = 0.01 - elif "fasterrcnn_mobilenet_v3_large" in name: - kwargs["box_score_thresh"] = 0.02076 - if "fasterrcnn_mobilenet_v3_large_320_fpn" in name: - kwargs["rpn_pre_nms_top_n_test"] = 1000 - kwargs["rpn_post_nms_top_n_test"] = 1000 - model = models.detection.__dict__[name](num_classes=50, pretrained_backbone=False, **kwargs) + defaults = { + 'num_classes': 50, + 'pretrained_backbone': False, + 'input_shape': (3, 300, 300), + } + kwargs = {**defaults, **_model_params.get(name, {})} + input_shape = kwargs.pop('input_shape') + + model = models.detection.__dict__[name](**kwargs) model.eval().to(device=dev) - input_shape = (3, 300, 300) # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests x = torch.rand(input_shape).to(device=dev) model_input = [x] @@ -435,8 +463,7 @@ def test_generalizedrcnn_transform_repr(self): @pytest.mark.parametrize('model_name', get_available_classification_models()) @pytest.mark.parametrize('dev', _devs) def test_classification_model(model_name, dev): - input_shape = (1, 3, 299, 299) if model_name == 'inception_v3' else (1, 3, 224, 224) - ModelTester()._test_classification_model(model_name, input_shape, dev) + ModelTester()._test_classification_model(model_name, dev) @pytest.mark.parametrize('model_name', get_available_segmentation_models()) From e3e7c256f39ec5ea21b3363019e8a6627c44eb44 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Thu, 27 May 2021 10:05:33 +0100 Subject: [PATCH 116/279] Remove deprecated CI vars. (#3928) --- packaging/wheel/linux_manywheel.sh | 3 --- packaging/wheel/osx_wheel.sh | 2 -- 2 files changed, 5 deletions(-) diff --git a/packaging/wheel/linux_manywheel.sh b/packaging/wheel/linux_manywheel.sh index 19e7d1a7500..965c8150748 100644 --- a/packaging/wheel/linux_manywheel.sh +++ b/packaging/wheel/linux_manywheel.sh @@ -14,9 +14,6 @@ else cu_suffix="+$CUVER" fi -export TORCHVISION_BUILD_VERSION="0.4.0.dev$(date "+%Y%m%d")${cu_suffix}" -export TORCHVISION_BUILD_NUMBER="1" -export TORCHVISION_LOCAL_VERSION_LABEL="$CUVER" export OUT_DIR="/remote/$CUVER" pushd /opt/python diff --git a/packaging/wheel/osx_wheel.sh b/packaging/wheel/osx_wheel.sh index 900485d3199..2bea559c174 100644 --- a/packaging/wheel/osx_wheel.sh +++ b/packaging/wheel/osx_wheel.sh @@ -12,8 +12,6 @@ wget -q https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh & . ~/minconda_wheel_env_tmp/bin/activate -export TORCHVISION_BUILD_VERSION="0.4.0.dev$(date "+%Y%m%d")" -export TORCHVISION_BUILD_NUMBER="1" export OUT_DIR=~/torchvision_wheels export MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ From 4c563846b4ecf87440a1b155a8daf5c27a7b9aeb Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Thu, 27 May 2021 12:31:03 +0100 Subject: [PATCH 117/279] Speedup the slow tests of detection models (#3929) * Speed up keypoint and retina. * Update keypoint expected file * Speed up fasterrcnn_resnet50_fpn. * Speed up maskrcnn_resnet50_fpn. * Updating params to resolve flakiness. * limit runs to those 4 tests * Relaxing precision to resolve flakiness * Undo test filtering --- test/common_utils.py | 2 +- ...er.test_fasterrcnn_resnet50_fpn_expect.pkl | Bin 4109 -> 3939 bytes ....test_keypointrcnn_resnet50_fpn_expect.pkl | Bin 11755 -> 2263 bytes ...ster.test_maskrcnn_resnet50_fpn_expect.pkl | Bin 4705 -> 4507 bytes ...ter.test_retinanet_resnet50_fpn_expect.pkl | Bin 9677 -> 9571 bytes test/test_models.py | 23 ++++++++++++++++++ 6 files changed, 24 insertions(+), 1 deletion(-) diff --git a/test/common_utils.py b/test/common_utils.py index 44c4a1fca77..6186ad43137 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -311,7 +311,7 @@ def assertExportImportModule(self, m, args): results = m(*args) with freeze_rng_state(): results_from_imported = m_import(*args) - self.assertEqual(results, results_from_imported, prec=3e-5) + self.assertEqual(results, results_from_imported, prec=3e-4) @contextlib.contextmanager diff --git a/test/expect/ModelTester.test_fasterrcnn_resnet50_fpn_expect.pkl b/test/expect/ModelTester.test_fasterrcnn_resnet50_fpn_expect.pkl index 3085bf36e60b8dd3d688b9beee2567821825e218..e95ba5f53985e3773c6a625bed929b406350aa90 100644 GIT binary patch literal 3939 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 ZgrhGFs8kD}kE5)i`qV^@9U3pk{tLM76p#P_ literal 11755 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 diff --git a/test/expect/ModelTester.test_maskrcnn_resnet50_fpn_expect.pkl b/test/expect/ModelTester.test_maskrcnn_resnet50_fpn_expect.pkl index d8ee673ab607bf6ce7ef60bc36d7ca3aad3cb86e..36b680816726017ffafc262ca38861df2737087a 100644 GIT binary patch literal 4507 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 literal 9677 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 diff --git a/test/test_models.py b/test/test_models.py index be4c2b6995d..caca48224ba 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -81,7 +81,30 @@ def get_available_video_models(): 'input_shape': (1, 3, 299, 299) }, 'retinanet_resnet50_fpn': { + 'num_classes': 20, 'score_thresh': 0.01, + 'min_size': 224, + 'max_size': 224, + 'input_shape': (3, 224, 224), + }, + 'keypointrcnn_resnet50_fpn': { + 'num_classes': 2, + 'min_size': 224, + 'max_size': 224, + 'box_score_thresh': 0.15, + 'input_shape': (3, 224, 224), + }, + 'fasterrcnn_resnet50_fpn': { + 'num_classes': 20, + 'min_size': 224, + 'max_size': 224, + 'input_shape': (3, 224, 224), + }, + 'maskrcnn_resnet50_fpn': { + 'num_classes': 10, + 'min_size': 224, + 'max_size': 224, + 'input_shape': (3, 224, 224), }, 'fasterrcnn_mobilenet_v3_large_fpn': { 'box_score_thresh': 0.02076, From 1cbcb2b1966c892dff715228b8c15e29cc372ccf Mon Sep 17 00:00:00 2001 From: Zhiqiang Wang Date: Thu, 27 May 2021 20:13:30 +0800 Subject: [PATCH 118/279] Port test/test_image.py to pytest (#3930) --- test/test_image.py | 452 ++++++++++++++++++++++++--------------------- 1 file changed, 245 insertions(+), 207 deletions(-) diff --git a/test/test_image.py b/test/test_image.py index eae4a1473c5..61bf3a4070c 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -2,7 +2,6 @@ import io import os import sys -import unittest from pathlib import Path import pytest @@ -54,176 +53,209 @@ def normalize_dimensions(img_pil): return img_pil -class ImageTester(unittest.TestCase): - def test_decode_jpeg(self): - conversion = [(None, ImageReadMode.UNCHANGED), ("L", ImageReadMode.GRAY), ("RGB", ImageReadMode.RGB)] - for img_path in get_images(IMAGE_ROOT, ".jpg"): - for pil_mode, mode in conversion: - with Image.open(img_path) as img: - is_cmyk = img.mode == "CMYK" - if pil_mode is not None: - if is_cmyk: - # libjpeg does not support the conversion - continue - img = img.convert(pil_mode) - img_pil = torch.from_numpy(np.array(img)) - if is_cmyk: - # flip the colors to match libjpeg - img_pil = 255 - img_pil - - img_pil = normalize_dimensions(img_pil) - data = read_file(img_path) - img_ljpeg = decode_image(data, mode=mode) - - # Permit a small variation on pixel values to account for implementation - # differences between Pillow and LibJPEG. - abs_mean_diff = (img_ljpeg.type(torch.float32) - img_pil).abs().mean().item() - self.assertTrue(abs_mean_diff < 2) - - with self.assertRaisesRegex(RuntimeError, "Expected a non empty 1-dimensional tensor"): - decode_jpeg(torch.empty((100, 1), dtype=torch.uint8)) - - with self.assertRaisesRegex(RuntimeError, "Expected a torch.uint8 tensor"): - decode_jpeg(torch.empty((100,), dtype=torch.float16)) - - with self.assertRaises(RuntimeError): - decode_jpeg(torch.empty((100), dtype=torch.uint8)) - - def test_damaged_images(self): - # Test image with bad Huffman encoding (should not raise) - bad_huff = read_file(os.path.join(DAMAGED_JPEG, 'bad_huffman.jpg')) - try: - _ = decode_jpeg(bad_huff) - except RuntimeError: - self.assertTrue(False) - - # Truncated images should raise an exception - truncated_images = glob.glob( - os.path.join(DAMAGED_JPEG, 'corrupt*.jpg')) - for image_path in truncated_images: - data = read_file(image_path) - with self.assertRaises(RuntimeError): - decode_jpeg(data) - - def test_decode_png(self): - conversion = [(None, ImageReadMode.UNCHANGED), ("L", ImageReadMode.GRAY), ("LA", ImageReadMode.GRAY_ALPHA), - ("RGB", ImageReadMode.RGB), ("RGBA", ImageReadMode.RGB_ALPHA)] - for img_path in get_images(FAKEDATA_DIR, ".png"): - for pil_mode, mode in conversion: - with Image.open(img_path) as img: - if pil_mode is not None: - img = img.convert(pil_mode) - img_pil = torch.from_numpy(np.array(img)) - - img_pil = normalize_dimensions(img_pil) - data = read_file(img_path) - img_lpng = decode_image(data, mode=mode) - - tol = 0 if conversion is None else 1 - self.assertTrue(img_lpng.allclose(img_pil, atol=tol)) - - with self.assertRaises(RuntimeError): - decode_png(torch.empty((), dtype=torch.uint8)) - with self.assertRaises(RuntimeError): - decode_png(torch.randint(3, 5, (300,), dtype=torch.uint8)) - - def test_encode_png(self): - for img_path in get_images(IMAGE_DIR, '.png'): - pil_image = Image.open(img_path) - img_pil = torch.from_numpy(np.array(pil_image)) - img_pil = img_pil.permute(2, 0, 1) - png_buf = encode_png(img_pil, compression_level=6) - - rec_img = Image.open(io.BytesIO(bytes(png_buf.tolist()))) - rec_img = torch.from_numpy(np.array(rec_img)) - rec_img = rec_img.permute(2, 0, 1) - - assert_equal(img_pil, rec_img) - - with self.assertRaisesRegex( - RuntimeError, "Input tensor dtype should be uint8"): - encode_png(torch.empty((3, 100, 100), dtype=torch.float32)) - - with self.assertRaisesRegex( - RuntimeError, "Compression level should be between 0 and 9"): - encode_png(torch.empty((3, 100, 100), dtype=torch.uint8), - compression_level=-1) - - with self.assertRaisesRegex( - RuntimeError, "Compression level should be between 0 and 9"): - encode_png(torch.empty((3, 100, 100), dtype=torch.uint8), - compression_level=10) - - with self.assertRaisesRegex( - RuntimeError, "The number of channels should be 1 or 3, got: 5"): - encode_png(torch.empty((5, 100, 100), dtype=torch.uint8)) - - def test_write_png(self): - with get_tmp_dir() as d: - for img_path in get_images(IMAGE_DIR, '.png'): - pil_image = Image.open(img_path) - img_pil = torch.from_numpy(np.array(pil_image)) - img_pil = img_pil.permute(2, 0, 1) - - filename, _ = os.path.splitext(os.path.basename(img_path)) - torch_png = os.path.join(d, '{0}_torch.png'.format(filename)) - write_png(img_pil, torch_png, compression_level=6) - saved_image = torch.from_numpy(np.array(Image.open(torch_png))) - saved_image = saved_image.permute(2, 0, 1) - - assert_equal(img_pil, saved_image) - - def test_read_file(self): - with get_tmp_dir() as d: - fname, content = 'test1.bin', b'TorchVision\211\n' - fpath = os.path.join(d, fname) - with open(fpath, 'wb') as f: - f.write(content) - - data = read_file(fpath) - expected = torch.tensor(list(content), dtype=torch.uint8) - assert_equal(data, expected) - os.unlink(fpath) - - with self.assertRaisesRegex( - RuntimeError, "No such file or directory: 'tst'"): - read_file('tst') - - def test_read_file_non_ascii(self): - with get_tmp_dir() as d: - fname, content = '日本語(Japanese).bin', b'TorchVision\211\n' - fpath = os.path.join(d, fname) - with open(fpath, 'wb') as f: - f.write(content) - - data = read_file(fpath) - expected = torch.tensor(list(content), dtype=torch.uint8) - assert_equal(data, expected) - os.unlink(fpath) - - def test_write_file(self): - with get_tmp_dir() as d: - fname, content = 'test1.bin', b'TorchVision\211\n' - fpath = os.path.join(d, fname) - content_tensor = torch.tensor(list(content), dtype=torch.uint8) - write_file(fpath, content_tensor) - - with open(fpath, 'rb') as f: - saved_content = f.read() - self.assertEqual(content, saved_content) - os.unlink(fpath) - - def test_write_file_non_ascii(self): - with get_tmp_dir() as d: - fname, content = '日本語(Japanese).bin', b'TorchVision\211\n' - fpath = os.path.join(d, fname) - content_tensor = torch.tensor(list(content), dtype=torch.uint8) - write_file(fpath, content_tensor) - - with open(fpath, 'rb') as f: - saved_content = f.read() - self.assertEqual(content, saved_content) - os.unlink(fpath) +@pytest.mark.parametrize('img_path', [ + pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) + for jpeg_path in get_images(IMAGE_ROOT, ".jpg") +]) +@pytest.mark.parametrize('pil_mode, mode', [ + (None, ImageReadMode.UNCHANGED), + ("L", ImageReadMode.GRAY), + ("RGB", ImageReadMode.RGB), +]) +def test_decode_jpeg(img_path, pil_mode, mode): + + with Image.open(img_path) as img: + is_cmyk = img.mode == "CMYK" + if pil_mode is not None: + if is_cmyk: + # libjpeg does not support the conversion + pytest.xfail("Decoding a CMYK jpeg isn't supported") + img = img.convert(pil_mode) + img_pil = torch.from_numpy(np.array(img)) + if is_cmyk: + # flip the colors to match libjpeg + img_pil = 255 - img_pil + + img_pil = normalize_dimensions(img_pil) + data = read_file(img_path) + img_ljpeg = decode_image(data, mode=mode) + + # Permit a small variation on pixel values to account for implementation + # differences between Pillow and LibJPEG. + abs_mean_diff = (img_ljpeg.type(torch.float32) - img_pil).abs().mean().item() + assert abs_mean_diff < 2 + + +def test_decode_jpeg_errors(): + with pytest.raises(RuntimeError, match="Expected a non empty 1-dimensional tensor"): + decode_jpeg(torch.empty((100, 1), dtype=torch.uint8)) + + with pytest.raises(RuntimeError, match="Expected a torch.uint8 tensor"): + decode_jpeg(torch.empty((100,), dtype=torch.float16)) + + with pytest.raises(RuntimeError, match="Not a JPEG file"): + decode_jpeg(torch.empty((100), dtype=torch.uint8)) + + +def test_decode_bad_huffman_images(): + # sanity check: make sure we can decode the bad Huffman encoding + bad_huff = read_file(os.path.join(DAMAGED_JPEG, 'bad_huffman.jpg')) + decode_jpeg(bad_huff) + + +@pytest.mark.parametrize('img_path', [ + pytest.param(truncated_image, id=_get_safe_image_name(truncated_image)) + for truncated_image in glob.glob(os.path.join(DAMAGED_JPEG, 'corrupt*.jpg')) +]) +def test_damaged_corrupt_images(img_path): + # Truncated images should raise an exception + data = read_file(img_path) + if 'corrupt34' in img_path: + match_message = "Image is incomplete or truncated" + else: + match_message = "Unsupported marker type" + with pytest.raises(RuntimeError, match=match_message): + decode_jpeg(data) + + +@pytest.mark.parametrize('img_path', [ + pytest.param(png_path, id=_get_safe_image_name(png_path)) + for png_path in get_images(FAKEDATA_DIR, ".png") +]) +@pytest.mark.parametrize('pil_mode, mode', [ + (None, ImageReadMode.UNCHANGED), + ("L", ImageReadMode.GRAY), + ("LA", ImageReadMode.GRAY_ALPHA), + ("RGB", ImageReadMode.RGB), + ("RGBA", ImageReadMode.RGB_ALPHA), +]) +def test_decode_png(img_path, pil_mode, mode): + + with Image.open(img_path) as img: + if pil_mode is not None: + img = img.convert(pil_mode) + img_pil = torch.from_numpy(np.array(img)) + + img_pil = normalize_dimensions(img_pil) + data = read_file(img_path) + img_lpng = decode_image(data, mode=mode) + + tol = 0 if pil_mode is None else 1 + assert img_lpng.allclose(img_pil, atol=tol) + + +def test_decode_png_errors(): + with pytest.raises(RuntimeError, match="Expected a non empty 1-dimensional tensor"): + decode_png(torch.empty((), dtype=torch.uint8)) + with pytest.raises(RuntimeError, match="Content is not png"): + decode_png(torch.randint(3, 5, (300,), dtype=torch.uint8)) + + +@pytest.mark.parametrize('img_path', [ + pytest.param(png_path, id=_get_safe_image_name(png_path)) + for png_path in get_images(IMAGE_DIR, ".png") +]) +def test_encode_png(img_path): + pil_image = Image.open(img_path) + img_pil = torch.from_numpy(np.array(pil_image)) + img_pil = img_pil.permute(2, 0, 1) + png_buf = encode_png(img_pil, compression_level=6) + + rec_img = Image.open(io.BytesIO(bytes(png_buf.tolist()))) + rec_img = torch.from_numpy(np.array(rec_img)) + rec_img = rec_img.permute(2, 0, 1) + + assert_equal(img_pil, rec_img) + + +def test_encode_png_errors(): + with pytest.raises(RuntimeError, match="Input tensor dtype should be uint8"): + encode_png(torch.empty((3, 100, 100), dtype=torch.float32)) + + with pytest.raises(RuntimeError, match="Compression level should be between 0 and 9"): + encode_png(torch.empty((3, 100, 100), dtype=torch.uint8), + compression_level=-1) + + with pytest.raises(RuntimeError, match="Compression level should be between 0 and 9"): + encode_png(torch.empty((3, 100, 100), dtype=torch.uint8), + compression_level=10) + + with pytest.raises(RuntimeError, match="The number of channels should be 1 or 3, got: 5"): + encode_png(torch.empty((5, 100, 100), dtype=torch.uint8)) + + +@pytest.mark.parametrize('img_path', [ + pytest.param(png_path, id=_get_safe_image_name(png_path)) + for png_path in get_images(IMAGE_DIR, ".png") +]) +def test_write_png(img_path): + with get_tmp_dir() as d: + pil_image = Image.open(img_path) + img_pil = torch.from_numpy(np.array(pil_image)) + img_pil = img_pil.permute(2, 0, 1) + + filename, _ = os.path.splitext(os.path.basename(img_path)) + torch_png = os.path.join(d, '{0}_torch.png'.format(filename)) + write_png(img_pil, torch_png, compression_level=6) + saved_image = torch.from_numpy(np.array(Image.open(torch_png))) + saved_image = saved_image.permute(2, 0, 1) + + assert_equal(img_pil, saved_image) + + +def test_read_file(): + with get_tmp_dir() as d: + fname, content = 'test1.bin', b'TorchVision\211\n' + fpath = os.path.join(d, fname) + with open(fpath, 'wb') as f: + f.write(content) + + data = read_file(fpath) + expected = torch.tensor(list(content), dtype=torch.uint8) + os.unlink(fpath) + assert_equal(data, expected) + + with pytest.raises(RuntimeError, match="No such file or directory: 'tst'"): + read_file('tst') + + +def test_read_file_non_ascii(): + with get_tmp_dir() as d: + fname, content = '日本語(Japanese).bin', b'TorchVision\211\n' + fpath = os.path.join(d, fname) + with open(fpath, 'wb') as f: + f.write(content) + + data = read_file(fpath) + expected = torch.tensor(list(content), dtype=torch.uint8) + os.unlink(fpath) + assert_equal(data, expected) + + +def test_write_file(): + with get_tmp_dir() as d: + fname, content = 'test1.bin', b'TorchVision\211\n' + fpath = os.path.join(d, fname) + content_tensor = torch.tensor(list(content), dtype=torch.uint8) + write_file(fpath, content_tensor) + + with open(fpath, 'rb') as f: + saved_content = f.read() + os.unlink(fpath) + assert content == saved_content + + +def test_write_file_non_ascii(): + with get_tmp_dir() as d: + fname, content = '日本語(Japanese).bin', b'TorchVision\211\n' + fpath = os.path.join(d, fname) + content_tensor = torch.tensor(list(content), dtype=torch.uint8) + write_file(fpath, content_tensor) + + with open(fpath, 'rb') as f: + saved_content = f.read() + os.unlink(fpath) + assert content == saved_content @needs_cuda @@ -236,14 +268,14 @@ def test_write_file_non_ascii(self): def test_decode_jpeg_cuda(mode, img_path, scripted): if 'cmyk' in img_path: pytest.xfail("Decoding a CMYK jpeg isn't supported") - tester = ImageTester() + data = read_file(img_path) img = decode_image(data, mode=mode) f = torch.jit.script(decode_jpeg) if scripted else decode_jpeg img_nvjpeg = f(data, mode=mode, device='cuda') # Some difference expected between jpeg implementations - tester.assertTrue((img.float() - img_nvjpeg.cpu().float()).abs().mean() < 2) + assert (img.float() - img_nvjpeg.cpu().float()).abs().mean() < 2 @needs_cuda @@ -304,7 +336,11 @@ def _inner(test_func): @cpu_only @_collect_if(cond=IS_WINDOWS) -def test_encode_jpeg_windows(): +@pytest.mark.parametrize('img_path', [ + pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) + for jpeg_path in get_images(ENCODE_JPEG, ".jpg") +]) +def test_encode_jpeg_windows(img_path): # This test is *wrong*. # It compares a torchvision-encoded jpeg with a PIL-encoded jpeg, but it # starts encoding the torchvision version from an image that comes from @@ -315,48 +351,50 @@ def test_encode_jpeg_windows(): # these more correct tests fail on windows (probably because of a difference # in libjpeg) between torchvision and PIL. # FIXME: make the correct tests pass on windows and remove this. - for img_path in get_images(ENCODE_JPEG, ".jpg"): - dirname = os.path.dirname(img_path) - filename, _ = os.path.splitext(os.path.basename(img_path)) - write_folder = os.path.join(dirname, 'jpeg_write') - expected_file = os.path.join( - write_folder, '{0}_pil.jpg'.format(filename)) - img = decode_jpeg(read_file(img_path)) - - with open(expected_file, 'rb') as f: - pil_bytes = f.read() - pil_bytes = torch.as_tensor(list(pil_bytes), dtype=torch.uint8) - for src_img in [img, img.contiguous()]: - # PIL sets jpeg quality to 75 by default - jpeg_bytes = encode_jpeg(src_img, quality=75) - assert_equal(jpeg_bytes, pil_bytes) + dirname = os.path.dirname(img_path) + filename, _ = os.path.splitext(os.path.basename(img_path)) + write_folder = os.path.join(dirname, 'jpeg_write') + expected_file = os.path.join( + write_folder, '{0}_pil.jpg'.format(filename)) + img = decode_jpeg(read_file(img_path)) + + with open(expected_file, 'rb') as f: + pil_bytes = f.read() + pil_bytes = torch.as_tensor(list(pil_bytes), dtype=torch.uint8) + for src_img in [img, img.contiguous()]: + # PIL sets jpeg quality to 75 by default + jpeg_bytes = encode_jpeg(src_img, quality=75) + assert_equal(jpeg_bytes, pil_bytes) @cpu_only @_collect_if(cond=IS_WINDOWS) -def test_write_jpeg_windows(): +@pytest.mark.parametrize('img_path', [ + pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) + for jpeg_path in get_images(ENCODE_JPEG, ".jpg") +]) +def test_write_jpeg_windows(img_path): # FIXME: Remove this eventually, see test_encode_jpeg_windows with get_tmp_dir() as d: - for img_path in get_images(ENCODE_JPEG, ".jpg"): - data = read_file(img_path) - img = decode_jpeg(data) + data = read_file(img_path) + img = decode_jpeg(data) - basedir = os.path.dirname(img_path) - filename, _ = os.path.splitext(os.path.basename(img_path)) - torch_jpeg = os.path.join( - d, '{0}_torch.jpg'.format(filename)) - pil_jpeg = os.path.join( - basedir, 'jpeg_write', '{0}_pil.jpg'.format(filename)) + basedir = os.path.dirname(img_path) + filename, _ = os.path.splitext(os.path.basename(img_path)) + torch_jpeg = os.path.join( + d, '{0}_torch.jpg'.format(filename)) + pil_jpeg = os.path.join( + basedir, 'jpeg_write', '{0}_pil.jpg'.format(filename)) - write_jpeg(img, torch_jpeg, quality=75) + write_jpeg(img, torch_jpeg, quality=75) - with open(torch_jpeg, 'rb') as f: - torch_bytes = f.read() + with open(torch_jpeg, 'rb') as f: + torch_bytes = f.read() - with open(pil_jpeg, 'rb') as f: - pil_bytes = f.read() + with open(pil_jpeg, 'rb') as f: + pil_bytes = f.read() - assert_equal(torch_bytes, pil_bytes) + assert_equal(torch_bytes, pil_bytes) @cpu_only @@ -408,5 +446,5 @@ def test_write_jpeg(img_path): assert_equal(torch_bytes, pil_bytes) -if __name__ == '__main__': - unittest.main() +if __name__ == "__main__": + pytest.main([__file__]) From fec39cd5d2e09bd5eda2b4b97b426708bd10b26d Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Thu, 27 May 2021 13:37:58 +0100 Subject: [PATCH 119/279] Added check for invalid input file (#3932) --- test/test_video_reader.py | 14 ++++++++++---- torchvision/io/video.py | 4 ++++ 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/test/test_video_reader.py b/test/test_video_reader.py index 9818b6fc900..e13aeb537f2 100644 --- a/test/test_video_reader.py +++ b/test/test_video_reader.py @@ -1,7 +1,6 @@ import collections import math import os -import time import unittest from fractions import Fraction @@ -9,6 +8,7 @@ import torch import torchvision.io as io from numpy.random import randint +from torchvision import set_video_backend from torchvision.io import _HAS_VIDEO_OPT from common_utils import PY39_SKIP from _assert_utils import assert_equal @@ -23,9 +23,6 @@ av = None -from urllib.error import URLError - - VIDEO_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets", "videos") CheckerConfig = [ @@ -1277,6 +1274,15 @@ def test_audio_video_sync(self): self.assertGreaterEqual( torch.mean(torch.isclose(audio.float(), arr).float()), 0.99) + def test_invalid_file(self): + set_video_backend('video_reader') + with self.assertRaises(RuntimeError): + io.read_video('foo.mp4') + + set_video_backend('pyav') + with self.assertRaises(RuntimeError): + io.read_video('foo.mp4') + if __name__ == "__main__": unittest.main() diff --git a/torchvision/io/video.py b/torchvision/io/video.py index e16e8906d97..faa2f236fa3 100644 --- a/torchvision/io/video.py +++ b/torchvision/io/video.py @@ -1,5 +1,6 @@ import gc import math +import os import re import warnings from typing import Any, Dict, List, Optional, Tuple, Union @@ -258,6 +259,9 @@ def read_video( from torchvision import get_video_backend + if not os.path.exists(filename): + raise RuntimeError(f'File not found: {filename}') + if get_video_backend() != "pyav": return _video_opt._read_video(filename, start_pts, end_pts, pts_unit) From 882e11db8138236ce375ea0dc8a53fd91f715a90 Mon Sep 17 00:00:00 2001 From: Shrill Shrestha <43284212+ShrillShrestha@users.noreply.github.com> Date: Thu, 27 May 2021 10:55:59 -0500 Subject: [PATCH 120/279] Port test/test_io.py to pytest (#3922) --- test/test_io.py | 176 ++++++++++++++++++++++++------------------------ 1 file changed, 87 insertions(+), 89 deletions(-) diff --git a/test/test_io.py b/test/test_io.py index e86ea9e84fc..93164a9997f 100644 --- a/test/test_io.py +++ b/test/test_io.py @@ -1,3 +1,4 @@ +import pytest import os import contextlib import sys @@ -5,7 +6,6 @@ import torch import torchvision.io as io from torchvision import get_video_backend -import unittest import warnings from urllib.error import URLError @@ -64,10 +64,10 @@ def temp_video(num_frames, height, width, fps, lossless=False, video_codec=None, os.unlink(f.name) -@unittest.skipIf(get_video_backend() != "pyav" and not io._HAS_VIDEO_OPT, - "video_reader backend not available") -@unittest.skipIf(av is None, "PyAV unavailable") -class TestIO(unittest.TestCase): +@pytest.mark.skipif(get_video_backend() != "pyav" and not io._HAS_VIDEO_OPT, + reason="video_reader backend not available") +@pytest.mark.skipif(av is None, reason="PyAV unavailable") +class TestVideo: # compression adds artifacts, thus we add a tolerance of # 6 in 0-255 range TOLERANCE = 6 @@ -76,23 +76,23 @@ def test_write_read_video(self): with temp_video(10, 300, 300, 5, lossless=True) as (f_name, data): lv, _, info = io.read_video(f_name) assert_equal(data, lv) - self.assertEqual(info["video_fps"], 5) + assert info["video_fps"] == 5 - @unittest.skipIf(not io._HAS_VIDEO_OPT, "video_reader backend is not chosen") + @pytest.mark.skipif(not io._HAS_VIDEO_OPT, reason="video_reader backend is not chosen") def test_probe_video_from_file(self): with temp_video(10, 300, 300, 5) as (f_name, data): video_info = io._probe_video_from_file(f_name) - self.assertAlmostEqual(video_info.video_duration, 2, delta=0.1) - self.assertAlmostEqual(video_info.video_fps, 5, delta=0.1) + assert pytest.approx(2, rel=0.0, abs=0.1) == video_info.video_duration + assert pytest.approx(5, rel=0.0, abs=0.1) == video_info.video_fps - @unittest.skipIf(not io._HAS_VIDEO_OPT, "video_reader backend is not chosen") + @pytest.mark.skipif(not io._HAS_VIDEO_OPT, reason="video_reader backend is not chosen") def test_probe_video_from_memory(self): with temp_video(10, 300, 300, 5) as (f_name, data): with open(f_name, "rb") as fp: filebuffer = fp.read() video_info = io._probe_video_from_memory(filebuffer) - self.assertAlmostEqual(video_info.video_duration, 2, delta=0.1) - self.assertAlmostEqual(video_info.video_fps, 5, delta=0.1) + assert pytest.approx(2, rel=0.0, abs=0.1) == video_info.video_duration + assert pytest.approx(5, rel=0.0, abs=0.1) == video_info.video_fps def test_read_timestamps(self): with temp_video(10, 300, 300, 5) as (f_name, data): @@ -100,51 +100,52 @@ def test_read_timestamps(self): # note: not all formats/codecs provide accurate information for computing the # timestamps. For the format that we use here, this information is available, # so we use it as a baseline - container = av.open(f_name) - stream = container.streams[0] - pts_step = int(round(float(1 / (stream.average_rate * stream.time_base)))) - num_frames = int(round(float(stream.average_rate * stream.time_base * stream.duration))) - expected_pts = [i * pts_step for i in range(num_frames)] + with av.open(f_name) as container: + stream = container.streams[0] + pts_step = int(round(float(1 / (stream.average_rate * stream.time_base)))) + num_frames = int(round(float(stream.average_rate * stream.time_base * stream.duration))) + expected_pts = [i * pts_step for i in range(num_frames)] - self.assertEqual(pts, expected_pts) - container.close() + assert pts == expected_pts - def test_read_partial_video(self): + @pytest.mark.parametrize('start', range(5)) + @pytest.mark.parametrize('offset', range(1, 4)) + def test_read_partial_video(self, start, offset): with temp_video(10, 300, 300, 5, lossless=True) as (f_name, data): pts, _ = io.read_video_timestamps(f_name) - for start in range(5): - for offset in range(1, 4): - lv, _, _ = io.read_video(f_name, pts[start], pts[start + offset - 1]) - s_data = data[start:(start + offset)] - self.assertEqual(len(lv), offset) - assert_equal(s_data, lv) + + lv, _, _ = io.read_video(f_name, pts[start], pts[start + offset - 1]) + s_data = data[start:(start + offset)] + assert len(lv) == offset + assert_equal(s_data, lv) if get_video_backend() == "pyav": # for "video_reader" backend, we don't decode the closest early frame # when the given start pts is not matching any frame pts lv, _, _ = io.read_video(f_name, pts[4] + 1, pts[7]) - self.assertEqual(len(lv), 4) + assert len(lv) == 4 assert_equal(data[4:8], lv) - def test_read_partial_video_bframes(self): + @pytest.mark.parametrize('start', range(0, 80, 20)) + @pytest.mark.parametrize('offset', range(1, 4)) + def test_read_partial_video_bframes(self, start, offset): # do not use lossless encoding, to test the presence of B-frames options = {'bframes': '16', 'keyint': '10', 'min-keyint': '4'} with temp_video(100, 300, 300, 5, options=options) as (f_name, data): pts, _ = io.read_video_timestamps(f_name) - for start in range(0, 80, 20): - for offset in range(1, 4): - lv, _, _ = io.read_video(f_name, pts[start], pts[start + offset - 1]) - s_data = data[start:(start + offset)] - self.assertEqual(len(lv), offset) - assert_equal(s_data, lv, rtol=0.0, atol=self.TOLERANCE) + + lv, _, _ = io.read_video(f_name, pts[start], pts[start + offset - 1]) + s_data = data[start:(start + offset)] + assert len(lv) == offset + assert_equal(s_data, lv, rtol=0.0, atol=self.TOLERANCE) lv, _, _ = io.read_video(f_name, pts[4] + 1, pts[7]) # TODO fix this if get_video_backend() == 'pyav': - self.assertEqual(len(lv), 4) + assert len(lv) == 4 assert_equal(data[4:8], lv, rtol=0.0, atol=self.TOLERANCE) else: - self.assertEqual(len(lv), 3) + assert len(lv) == 3 assert_equal(data[5:8], lv, rtol=0.0, atol=self.TOLERANCE) def test_read_packed_b_frames_divx_file(self): @@ -152,8 +153,8 @@ def test_read_packed_b_frames_divx_file(self): f_name = os.path.join(VIDEO_DIR, name) pts, fps = io.read_video_timestamps(f_name) - self.assertEqual(pts, sorted(pts)) - self.assertEqual(fps, 30) + assert pts == sorted(pts) + assert fps == 30 def test_read_timestamps_from_packet(self): with temp_video(10, 300, 300, 5, video_codec='mpeg4') as (f_name, data): @@ -161,79 +162,76 @@ def test_read_timestamps_from_packet(self): # note: not all formats/codecs provide accurate information for computing the # timestamps. For the format that we use here, this information is available, # so we use it as a baseline - container = av.open(f_name) - stream = container.streams[0] - # make sure we went through the optimized codepath - self.assertIn(b'Lavc', stream.codec_context.extradata) - pts_step = int(round(float(1 / (stream.average_rate * stream.time_base)))) - num_frames = int(round(float(stream.average_rate * stream.time_base * stream.duration))) - expected_pts = [i * pts_step for i in range(num_frames)] + with av.open(f_name) as container: + stream = container.streams[0] + # make sure we went through the optimized codepath + assert b'Lavc' in stream.codec_context.extradata + pts_step = int(round(float(1 / (stream.average_rate * stream.time_base)))) + num_frames = int(round(float(stream.average_rate * stream.time_base * stream.duration))) + expected_pts = [i * pts_step for i in range(num_frames)] - self.assertEqual(pts, expected_pts) - container.close() + assert pts == expected_pts def test_read_video_pts_unit_sec(self): with temp_video(10, 300, 300, 5, lossless=True) as (f_name, data): lv, _, info = io.read_video(f_name, pts_unit='sec') assert_equal(data, lv) - self.assertEqual(info["video_fps"], 5) - self.assertEqual(info, {"video_fps": 5}) + assert info["video_fps"] == 5 + assert info == {"video_fps": 5} def test_read_timestamps_pts_unit_sec(self): with temp_video(10, 300, 300, 5) as (f_name, data): pts, _ = io.read_video_timestamps(f_name, pts_unit='sec') - container = av.open(f_name) - stream = container.streams[0] - pts_step = int(round(float(1 / (stream.average_rate * stream.time_base)))) - num_frames = int(round(float(stream.average_rate * stream.time_base * stream.duration))) - expected_pts = [i * pts_step * stream.time_base for i in range(num_frames)] + with av.open(f_name) as container: + stream = container.streams[0] + pts_step = int(round(float(1 / (stream.average_rate * stream.time_base)))) + num_frames = int(round(float(stream.average_rate * stream.time_base * stream.duration))) + expected_pts = [i * pts_step * stream.time_base for i in range(num_frames)] - self.assertEqual(pts, expected_pts) - container.close() + assert pts == expected_pts - def test_read_partial_video_pts_unit_sec(self): + @pytest.mark.parametrize('start', range(5)) + @pytest.mark.parametrize('offset', range(1, 4)) + def test_read_partial_video_pts_unit_sec(self, start, offset): with temp_video(10, 300, 300, 5, lossless=True) as (f_name, data): pts, _ = io.read_video_timestamps(f_name, pts_unit='sec') - for start in range(5): - for offset in range(1, 4): - lv, _, _ = io.read_video(f_name, pts[start], pts[start + offset - 1], pts_unit='sec') - s_data = data[start:(start + offset)] - self.assertEqual(len(lv), offset) - assert_equal(s_data, lv) - - container = av.open(f_name) - stream = container.streams[0] - lv, _, _ = io.read_video(f_name, - int(pts[4] * (1.0 / stream.time_base) + 1) * stream.time_base, pts[7], - pts_unit='sec') + lv, _, _ = io.read_video(f_name, pts[start], pts[start + offset - 1], pts_unit='sec') + s_data = data[start:(start + offset)] + assert len(lv) == offset + assert_equal(s_data, lv) + + with av.open(f_name) as container: + stream = container.streams[0] + lv, _, _ = io.read_video(f_name, + int(pts[4] * (1.0 / stream.time_base) + 1) * stream.time_base, pts[7], + pts_unit='sec') if get_video_backend() == "pyav": # for "video_reader" backend, we don't decode the closest early frame # when the given start pts is not matching any frame pts - self.assertEqual(len(lv), 4) + assert len(lv) == 4 assert_equal(data[4:8], lv) - container.close() def test_read_video_corrupted_file(self): with tempfile.NamedTemporaryFile(suffix='.mp4') as f: f.write(b'This is not an mpg4 file') video, audio, info = io.read_video(f.name) - self.assertIsInstance(video, torch.Tensor) - self.assertIsInstance(audio, torch.Tensor) - self.assertEqual(video.numel(), 0) - self.assertEqual(audio.numel(), 0) - self.assertEqual(info, {}) + assert isinstance(video, torch.Tensor) + assert isinstance(audio, torch.Tensor) + assert video.numel() == 0 + assert audio.numel() == 0 + assert info == {} def test_read_video_timestamps_corrupted_file(self): with tempfile.NamedTemporaryFile(suffix='.mp4') as f: f.write(b'This is not an mpg4 file') video_pts, video_fps = io.read_video_timestamps(f.name) - self.assertEqual(video_pts, []) - self.assertIs(video_fps, None) + assert video_pts == [] + assert video_fps is None - @unittest.skip("Temporarily disabled due to new pyav") + @pytest.mark.skip(reason="Temporarily disabled due to new pyav") def test_read_video_partially_corrupted_file(self): with temp_video(5, 4, 4, 5, lossless=True) as (f_name, data): with open(f_name, 'r+b') as f: @@ -248,16 +246,16 @@ def test_read_video_partially_corrupted_file(self): # check that size is not equal to 5, but 3 # TODO fix this if get_video_backend() == 'pyav': - self.assertEqual(len(video), 3) + assert len(video) == 3 else: - self.assertEqual(len(video), 4) + assert len(video) == 4 # but the valid decoded content is still correct assert_equal(video[:3], data[:3]) # and the last few frames are wrong - with self.assertRaises(AssertionError): + with pytest.raises(AssertionError): assert_equal(video, data) - @unittest.skipIf(sys.platform == 'win32', 'temporarily disabled on Windows') + @pytest.mark.skipif(sys.platform == 'win32', reason='temporarily disabled on Windows') def test_write_video_with_audio(self): f_name = os.path.join(VIDEO_DIR, "R6llTwEh07w.mp4") video_tensor, audio_tensor, info = io.read_video(f_name, pts_unit="sec") @@ -279,19 +277,19 @@ def test_write_video_with_audio(self): out_f_name, pts_unit="sec" ) - self.assertEqual(info["video_fps"], out_info["video_fps"]) + assert info["video_fps"] == out_info["video_fps"] assert_equal(video_tensor, out_video_tensor) audio_stream = av.open(f_name).streams.audio[0] out_audio_stream = av.open(out_f_name).streams.audio[0] - self.assertEqual(info["audio_fps"], out_info["audio_fps"]) - self.assertEqual(audio_stream.rate, out_audio_stream.rate) - self.assertAlmostEqual(audio_stream.frames, out_audio_stream.frames, delta=1) - self.assertEqual(audio_stream.frame_size, out_audio_stream.frame_size) + assert info["audio_fps"] == out_info["audio_fps"] + assert audio_stream.rate == out_audio_stream.rate + assert pytest.approx(out_audio_stream.frames, rel=0.0, abs=1) == audio_stream.frames + assert audio_stream.frame_size == out_audio_stream.frame_size # TODO add tests for audio if __name__ == '__main__': - unittest.main() + pytest.main(__file__) From 234d262f39e561ee13018b33902e84b852277ec3 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 1 Jun 2021 07:22:03 +0100 Subject: [PATCH 121/279] Speed up Transformations tests (#3936) --- test/test_transforms.py | 6 +++--- test/test_transforms_tensor.py | 39 ++++++++++++++++++++++------------ 2 files changed, 28 insertions(+), 17 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index de309cb66c5..3676de53627 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -1604,7 +1604,7 @@ def _test_transformation(a, t, s, sh): # Accept 3 wrong pixels self.assertLess(n_diff_pixels, 3, "a={}, t={}, s={}, sh={}\n".format(a, t, s, sh) + - "n diff pixels={}\n".format(np.sum(np.array(result)[:, :, 0] != true_result[:, :, 0]))) + "n diff pixels={}\n".format(n_diff_pixels)) # Test rotation a = 45 @@ -1623,9 +1623,9 @@ def _test_transformation(a, t, s, sh): _test_transformation(a=0.0, t=(0.0, 0.0), s=1.0, sh=sh) # Test rotation, scale, translation, shear - for a in range(-90, 90, 25): + for a in range(-90, 90, 36): for t1 in range(-10, 10, 5): - for s in [0.75, 0.98, 1.0, 1.2, 1.4]: + for s in [0.77, 1.0, 1.27]: for sh in range(-15, 15, 5): _test_transformation(a=a, t=(t1, t1), s=s, sh=(sh, sh)) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 0d5e365351d..96711decdd0 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -398,21 +398,32 @@ def test_random_affine(self): tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=self.device) batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=self.device) - for shear in [15, 10.0, (5.0, 10.0), [-15, 15], [-10.0, 10.0, -11.0, 11.0]]: + def _test(**kwargs): + transform = T.RandomAffine(**kwargs) + s_transform = torch.jit.script(transform) + + self._test_transform_vs_scripted(transform, s_transform, tensor) + self._test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + + return s_transform + + for interpolation in [NEAREST, BILINEAR]: + for shear in [15, 10.0, (5.0, 10.0), [-15, 15], [-10.0, 10.0, -11.0, 11.0]]: + _test(degrees=0.0, interpolation=interpolation, shear=shear) + for scale in [(0.7, 1.2), [0.7, 1.2]]: - for translate in [(0.1, 0.2), [0.2, 0.1]]: - for degrees in [45, 35.0, (-45, 45), [-90.0, 90.0]]: - for interpolation in [NEAREST, BILINEAR]: - for fill in [85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]: - transform = T.RandomAffine( - degrees=degrees, translate=translate, - scale=scale, shear=shear, interpolation=interpolation, fill=fill - ) - s_transform = torch.jit.script(transform) - - self._test_transform_vs_scripted(transform, s_transform, tensor) - self._test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + _test(degrees=0.0, interpolation=interpolation, scale=scale) + + for translate in [(0.1, 0.2), [0.2, 0.1]]: + _test(degrees=0.0, interpolation=interpolation, translate=translate) + + for degrees in [45, 35.0, (-45, 45), [-90.0, 90.0]]: + _test(degrees=degrees, interpolation=interpolation) + + for fill in [85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]: + _test(degrees=0.0, interpolation=interpolation, fill=fill) + s_transform = _test(degrees=0.0) with get_tmp_dir() as tmp_dir: s_transform.save(os.path.join(tmp_dir, "t_random_affine.pt")) @@ -663,7 +674,7 @@ def test_autoaugment(self): for fill in [None, 85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]: transform = T.AutoAugment(policy=policy, fill=fill) s_transform = torch.jit.script(transform) - for _ in range(100): + for _ in range(25): self._test_transform_vs_scripted(transform, s_transform, tensor) self._test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) From 9b29f3f22783112406d9c1a6db47165a297c3942 Mon Sep 17 00:00:00 2001 From: IgorSusmelj Date: Tue, 1 Jun 2021 08:32:49 +0200 Subject: [PATCH 122/279] Faster dataset indexing (#3939) --- torchvision/datasets/folder.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torchvision/datasets/folder.py b/torchvision/datasets/folder.py index 29255c7ab40..1280495273c 100644 --- a/torchvision/datasets/folder.py +++ b/torchvision/datasets/folder.py @@ -86,8 +86,8 @@ def is_valid_file(x: str) -> bool: continue for root, _, fnames in sorted(os.walk(target_dir, followlinks=True)): for fname in sorted(fnames): - path = os.path.join(root, fname) - if is_valid_file(path): + if is_valid_file(fname): + path = os.path.join(root, fname) item = path, class_index instances.append(item) From 2cc83594def8ca99d73f7cbe1e9af5f887a82d77 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 1 Jun 2021 07:53:41 +0100 Subject: [PATCH 123/279] Turn on fast gradcheck for DeformConv to speed-up tests (#3933) --- test/test_ops.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/test_ops.py b/test/test_ops.py index 964199edc66..934daeedc58 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -725,13 +725,13 @@ def func(x_, offset_, mask_, weight_, bias_): return ops.deform_conv2d(x_, offset_, weight_, bias_, stride=stride, padding=padding, dilation=dilation, mask=mask_) - gradcheck(func, (x, offset, mask, weight, bias), nondet_tol=1e-5) + gradcheck(func, (x, offset, mask, weight, bias), nondet_tol=1e-5, fast_mode=True) def func_no_mask(x_, offset_, weight_, bias_): return ops.deform_conv2d(x_, offset_, weight_, bias_, stride=stride, padding=padding, dilation=dilation, mask=None) - gradcheck(func_no_mask, (x, offset, weight, bias), nondet_tol=1e-5) + gradcheck(func_no_mask, (x, offset, weight, bias), nondet_tol=1e-5, fast_mode=True) @torch.jit.script def script_func(x_, offset_, mask_, weight_, bias_, stride_, pad_, dilation_): @@ -740,7 +740,7 @@ def script_func(x_, offset_, mask_, weight_, bias_, stride_, pad_, dilation_): padding=pad_, dilation=dilation_, mask=mask_) gradcheck(lambda z, off, msk, wei, bi: script_func(z, off, msk, wei, bi, stride, padding, dilation), - (x, offset, mask, weight, bias), nondet_tol=1e-5) + (x, offset, mask, weight, bias), nondet_tol=1e-5, fast_mode=True) @torch.jit.script def script_func_no_mask(x_, offset_, weight_, bias_, stride_, pad_, dilation_): @@ -749,7 +749,7 @@ def script_func_no_mask(x_, offset_, weight_, bias_, stride_, pad_, dilation_): padding=pad_, dilation=dilation_, mask=None) gradcheck(lambda z, off, wei, bi: script_func_no_mask(z, off, wei, bi, stride, padding, dilation), - (x, offset, weight, bias), nondet_tol=1e-5) + (x, offset, weight, bias), nondet_tol=1e-5, fast_mode=True) @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") def test_compare_cpu_cuda_grads(self): From e395a79c1fdc0dfb8971aa2651d2fb41f81da624 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 1 Jun 2021 12:19:07 +0100 Subject: [PATCH 124/279] Fix DeformConvTester::test_backward_cuda by setting threads per block to 512 (#3942) --- torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu b/torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu index 6f257322b85..2ea5e43f146 100644 --- a/torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu +++ b/torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu @@ -85,10 +85,7 @@ inline unsigned int GET_THREADS() { #ifdef __HIP_PLATFORM_HCC__ return 256; #endif - if (at::cuda::getCurrentDeviceProperties()->major >= 6) { - return 1024; - } - return 512; + return 512; } inline unsigned int GET_BLOCKS( From 8e8c66583a1dda87e86bbfa939bf71a028ac0d03 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 1 Jun 2021 12:25:40 +0100 Subject: [PATCH 125/279] Fix clang formatting in deform_conv2d_kernel.cu (#3943) --- torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu b/torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu index 2ea5e43f146..c72e0b666a3 100644 --- a/torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu +++ b/torchvision/csrc/ops/cuda/deform_conv2d_kernel.cu @@ -85,7 +85,7 @@ inline unsigned int GET_THREADS() { #ifdef __HIP_PLATFORM_HCC__ return 256; #endif - return 512; + return 512; } inline unsigned int GET_BLOCKS( From f6b6b5109627cb0bcfbebf90ebce740bacae9c59 Mon Sep 17 00:00:00 2001 From: Bruno Korbar Date: Tue, 1 Jun 2021 12:54:55 +0100 Subject: [PATCH 126/279] addressing #3805: remove deprecated function call 3 (#3861) * remove unused functions * shut up annoying warnings via cast * prabhat's comments * Fixed clang format error Co-authored-by: Prabhat Roy --- torchvision/csrc/io/decoder/audio_stream.cpp | 8 ++++---- torchvision/csrc/io/decoder/decoder.cpp | 6 ++---- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/torchvision/csrc/io/decoder/audio_stream.cpp b/torchvision/csrc/io/decoder/audio_stream.cpp index 9d66e589bf3..f6507130bda 100644 --- a/torchvision/csrc/io/decoder/audio_stream.cpp +++ b/torchvision/csrc/io/decoder/audio_stream.cpp @@ -7,13 +7,13 @@ namespace ffmpeg { namespace { bool operator==(const AudioFormat& x, const AVFrame& y) { - return x.samples == y.sample_rate && x.channels == y.channels && - x.format == y.format; + return static_cast(x.samples) == y.sample_rate && + static_cast(x.channels) == y.channels && x.format == y.format; } bool operator==(const AudioFormat& x, const AVCodecContext& y) { - return x.samples == y.sample_rate && x.channels == y.channels && - x.format == y.sample_fmt; + return static_cast(x.samples) == y.sample_rate && + static_cast(x.channels) == y.channels && x.format == y.sample_fmt; } AudioFormat& toAudioFormat(AudioFormat& x, const AVFrame& y) { diff --git a/torchvision/csrc/io/decoder/decoder.cpp b/torchvision/csrc/io/decoder/decoder.cpp index 6c9a3cdf825..18e49a4d002 100644 --- a/torchvision/csrc/io/decoder/decoder.cpp +++ b/torchvision/csrc/io/decoder/decoder.cpp @@ -196,8 +196,6 @@ int64_t Decoder::seekCallback(int64_t offset, int whence) { void Decoder::initOnce() { static std::once_flag flagInit; std::call_once(flagInit, []() { - av_register_all(); - avcodec_register_all(); avformat_network_init(); // register ffmpeg lock manager av_lockmgr_register(&ffmpeg_lock); @@ -397,10 +395,10 @@ bool Decoder::init( } bool Decoder::openStreams(std::vector* metadata) { - for (int i = 0; i < inputCtx_->nb_streams; i++) { + for (int i = 0; i < static_cast(inputCtx_->nb_streams); i++) { // - find the corespondent format at params_.formats set MediaFormat format; - const auto media = inputCtx_->streams[i]->codec->codec_type; + const auto media = inputCtx_->streams[i]->codecpar->codec_type; if (!mapFfmpegType(media, &format.type)) { VLOG(1) << "Stream media: " << media << " at index " << i << " gets ignored, unknown type"; From d1f1a5445dcbbd0d733dc38a32d9ae153337daae Mon Sep 17 00:00:00 2001 From: Jiawei Liu Date: Tue, 1 Jun 2021 20:16:51 +0800 Subject: [PATCH 127/279] Document minimum required shapes for classification model builder. (#3944) * [doc] add minimum input size for alexnet builder * [doc] add minimum input size for vgg builder * [doc] add minimum input size for squeezenet builder * [doc] add minimum input size for densenet builder * [doc] add minimum input size for inception_v3 builder * [doc] add minimum input size for googlenet builder Co-authored-by: Vasilis Vryniotis --- torchvision/models/alexnet.py | 1 + torchvision/models/densenet.py | 4 ++++ torchvision/models/googlenet.py | 1 + torchvision/models/inception.py | 1 + torchvision/models/squeezenet.py | 2 ++ torchvision/models/vgg.py | 8 ++++++++ 6 files changed, 17 insertions(+) diff --git a/torchvision/models/alexnet.py b/torchvision/models/alexnet.py index b9e8206d552..0b78f4ee003 100644 --- a/torchvision/models/alexnet.py +++ b/torchvision/models/alexnet.py @@ -53,6 +53,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: def alexnet(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> AlexNet: r"""AlexNet model architecture from the `"One weird trick..." `_ paper. + The required minimum input size of the model is 63x63. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet diff --git a/torchvision/models/densenet.py b/torchvision/models/densenet.py index 02d18c1e22b..e4f7e5b0255 100644 --- a/torchvision/models/densenet.py +++ b/torchvision/models/densenet.py @@ -257,6 +257,7 @@ def _densenet( def densenet121(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> DenseNet: r"""Densenet-121 model from `"Densely Connected Convolutional Networks" `_. + The required minimum input size of the model is 29x29. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -271,6 +272,7 @@ def densenet121(pretrained: bool = False, progress: bool = True, **kwargs: Any) def densenet161(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> DenseNet: r"""Densenet-161 model from `"Densely Connected Convolutional Networks" `_. + The required minimum input size of the model is 29x29. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -285,6 +287,7 @@ def densenet161(pretrained: bool = False, progress: bool = True, **kwargs: Any) def densenet169(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> DenseNet: r"""Densenet-169 model from `"Densely Connected Convolutional Networks" `_. + The required minimum input size of the model is 29x29. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -299,6 +302,7 @@ def densenet169(pretrained: bool = False, progress: bool = True, **kwargs: Any) def densenet201(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> DenseNet: r"""Densenet-201 model from `"Densely Connected Convolutional Networks" `_. + The required minimum input size of the model is 29x29. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet diff --git a/torchvision/models/googlenet.py b/torchvision/models/googlenet.py index cef48dea76a..63066520983 100644 --- a/torchvision/models/googlenet.py +++ b/torchvision/models/googlenet.py @@ -26,6 +26,7 @@ def googlenet(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> "GoogLeNet": r"""GoogLeNet (Inception v1) model architecture from `"Going Deeper with Convolutions" `_. + The required minimum input size of the model is 15x15. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet diff --git a/torchvision/models/inception.py b/torchvision/models/inception.py index 05b1cf07620..836a12a7a64 100644 --- a/torchvision/models/inception.py +++ b/torchvision/models/inception.py @@ -26,6 +26,7 @@ def inception_v3(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> "Inception3": r"""Inception v3 model architecture from `"Rethinking the Inception Architecture for Computer Vision" `_. + The required minimum input size of the model is 75x75. .. note:: **Important**: In contrast to the other models the inception_v3 expects tensors with a size of diff --git a/torchvision/models/squeezenet.py b/torchvision/models/squeezenet.py index 7830e4b70ef..c4220173d19 100644 --- a/torchvision/models/squeezenet.py +++ b/torchvision/models/squeezenet.py @@ -126,6 +126,7 @@ def squeezenet1_0(pretrained: bool = False, progress: bool = True, **kwargs: Any r"""SqueezeNet model architecture from the `"SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size" `_ paper. + The required minimum input size of the model is 21x21. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -139,6 +140,7 @@ def squeezenet1_1(pretrained: bool = False, progress: bool = True, **kwargs: Any `_. SqueezeNet 1.1 has 2.4x less computation and slightly fewer parameters than SqueezeNet 1.0, without sacrificing accuracy. + The required minimum input size of the model is 17x17. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet diff --git a/torchvision/models/vgg.py b/torchvision/models/vgg.py index 20da5c18a57..9ed73a4868b 100644 --- a/torchvision/models/vgg.py +++ b/torchvision/models/vgg.py @@ -105,6 +105,7 @@ def _vgg(arch: str, cfg: str, batch_norm: bool, pretrained: bool, progress: bool def vgg11(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG: r"""VGG 11-layer model (configuration "A") from `"Very Deep Convolutional Networks For Large-Scale Image Recognition" `_. + The required minimum input size of the model is 32x32. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -116,6 +117,7 @@ def vgg11(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG def vgg11_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG: r"""VGG 11-layer model (configuration "A") with batch normalization `"Very Deep Convolutional Networks For Large-Scale Image Recognition" `_. + The required minimum input size of the model is 32x32. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -127,6 +129,7 @@ def vgg11_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> def vgg13(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG: r"""VGG 13-layer model (configuration "B") `"Very Deep Convolutional Networks For Large-Scale Image Recognition" `_. + The required minimum input size of the model is 32x32. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -138,6 +141,7 @@ def vgg13(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG def vgg13_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG: r"""VGG 13-layer model (configuration "B") with batch normalization `"Very Deep Convolutional Networks For Large-Scale Image Recognition" `_. + The required minimum input size of the model is 32x32. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -149,6 +153,7 @@ def vgg13_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> def vgg16(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG: r"""VGG 16-layer model (configuration "D") `"Very Deep Convolutional Networks For Large-Scale Image Recognition" `_. + The required minimum input size of the model is 32x32. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -160,6 +165,7 @@ def vgg16(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG def vgg16_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG: r"""VGG 16-layer model (configuration "D") with batch normalization `"Very Deep Convolutional Networks For Large-Scale Image Recognition" `_. + The required minimum input size of the model is 32x32. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -171,6 +177,7 @@ def vgg16_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> def vgg19(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG: r"""VGG 19-layer model (configuration "E") `"Very Deep Convolutional Networks For Large-Scale Image Recognition" `_. + The required minimum input size of the model is 32x32. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet @@ -182,6 +189,7 @@ def vgg19(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG def vgg19_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VGG: r"""VGG 19-layer model (configuration 'E') with batch normalization `"Very Deep Convolutional Networks For Large-Scale Image Recognition" `_. + The required minimum input size of the model is 32x32. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet From 31d53367671d2deed42318a488a8d66158d7fbbe Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 2 Jun 2021 16:21:35 +0100 Subject: [PATCH 128/279] Remove TransformsTester (#3946) --- test/common_utils.py | 110 ++++++++++--------- test/test_functional_tensor.py | 189 +++++++++++++++------------------ test/test_transforms_tensor.py | 46 ++++---- 3 files changed, 175 insertions(+), 170 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index 6186ad43137..8fe76e38e93 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -325,54 +325,6 @@ def freeze_rng_state(): torch.set_rng_state(rng_state) -class TransformsTester(unittest.TestCase): - - def _create_data(self, height=3, width=3, channels=3, device="cpu"): - tensor = torch.randint(0, 256, (channels, height, width), dtype=torch.uint8, device=device) - pil_img = Image.fromarray(tensor.permute(1, 2, 0).contiguous().cpu().numpy()) - return tensor, pil_img - - def _create_data_batch(self, height=3, width=3, channels=3, num_samples=4, device="cpu"): - batch_tensor = torch.randint( - 0, 256, - (num_samples, channels, height, width), - dtype=torch.uint8, - device=device - ) - return batch_tensor - - def compareTensorToPIL(self, tensor, pil_image, msg=None): - np_pil_image = np.array(pil_image) - if np_pil_image.ndim == 2: - np_pil_image = np_pil_image[:, :, None] - pil_tensor = torch.as_tensor(np_pil_image.transpose((2, 0, 1))) - if msg is None: - msg = "tensor:\n{} \ndid not equal PIL tensor:\n{}".format(tensor, pil_tensor) - assert_equal(tensor.cpu(), pil_tensor, check_stride=False, msg=msg) - - def approxEqualTensorToPIL(self, tensor, pil_image, tol=1e-5, msg=None, agg_method="mean", - allowed_percentage_diff=None): - np_pil_image = np.array(pil_image) - if np_pil_image.ndim == 2: - np_pil_image = np_pil_image[:, :, None] - pil_tensor = torch.as_tensor(np_pil_image.transpose((2, 0, 1))).to(tensor) - - if allowed_percentage_diff is not None: - # Assert that less than a given %age of pixels are different - self.assertTrue( - (tensor != pil_tensor).to(torch.float).mean() <= allowed_percentage_diff - ) - # error value can be mean absolute error, max abs error - # Convert to float to avoid underflow when computing absolute difference - tensor = tensor.to(torch.float) - pil_tensor = pil_tensor.to(torch.float) - err = getattr(torch, agg_method)(torch.abs(tensor - pil_tensor)).item() - self.assertTrue( - err < tol, - msg="{}: err={}, tol={}: \n{}\nvs\n{}".format(msg, err, tol, tensor[0, :10, :10], pil_tensor[0, :10, :10]) - ) - - def cycle_over(objs): for idx, obj in enumerate(objs): yield obj, objs[:idx] + objs[idx + 1:] @@ -457,3 +409,65 @@ def cpu_only(test_func): return pytest.mark.dont_collect(test_func) else: return test_func + + +def _create_data(height=3, width=3, channels=3, device="cpu"): + # TODO: When all relevant tests are ported to pytest, turn this into a module-level fixture + tensor = torch.randint(0, 256, (channels, height, width), dtype=torch.uint8, device=device) + pil_img = Image.fromarray(tensor.permute(1, 2, 0).contiguous().cpu().numpy()) + return tensor, pil_img + + +def _create_data_batch(height=3, width=3, channels=3, num_samples=4, device="cpu"): + # TODO: When all relevant tests are ported to pytest, turn this into a module-level fixture + batch_tensor = torch.randint( + 0, 256, + (num_samples, channels, height, width), + dtype=torch.uint8, + device=device + ) + return batch_tensor + + +def _assert_equal_tensor_to_pil(tensor, pil_image, msg=None): + np_pil_image = np.array(pil_image) + if np_pil_image.ndim == 2: + np_pil_image = np_pil_image[:, :, None] + pil_tensor = torch.as_tensor(np_pil_image.transpose((2, 0, 1))) + if msg is None: + msg = "tensor:\n{} \ndid not equal PIL tensor:\n{}".format(tensor, pil_tensor) + assert_equal(tensor.cpu(), pil_tensor, check_stride=False, msg=msg) + + +def _assert_approx_equal_tensor_to_pil(tensor, pil_image, tol=1e-5, msg=None, agg_method="mean", + allowed_percentage_diff=None): + # TODO: we could just merge this into _assert_equal_tensor_to_pil + np_pil_image = np.array(pil_image) + if np_pil_image.ndim == 2: + np_pil_image = np_pil_image[:, :, None] + pil_tensor = torch.as_tensor(np_pil_image.transpose((2, 0, 1))).to(tensor) + + if allowed_percentage_diff is not None: + # Assert that less than a given %age of pixels are different + assert (tensor != pil_tensor).to(torch.float).mean() <= allowed_percentage_diff + + # error value can be mean absolute error, max abs error + # Convert to float to avoid underflow when computing absolute difference + tensor = tensor.to(torch.float) + pil_tensor = pil_tensor.to(torch.float) + err = getattr(torch, agg_method)(torch.abs(tensor - pil_tensor)).item() + assert err < tol + + +def _test_fn_on_batch(batch_tensors, fn, scripted_fn_atol=1e-8, **fn_kwargs): + transformed_batch = fn(batch_tensors, **fn_kwargs) + for i in range(len(batch_tensors)): + img_tensor = batch_tensors[i, ...] + transformed_img = fn(img_tensor, **fn_kwargs) + assert_equal(transformed_img, transformed_batch[i, ...]) + + if scripted_fn_atol >= 0: + scripted_fn = torch.jit.script(fn) + # scriptable function test + s_transformed_batch = scripted_fn(batch_tensors, **fn_kwargs) + torch.testing.assert_close(transformed_batch, s_transformed_batch, rtol=1e-5, atol=scripted_fn_atol) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 12a8d41914b..66605811fdb 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -14,7 +14,15 @@ import torchvision.transforms as T from torchvision.transforms import InterpolationMode -from common_utils import TransformsTester, cpu_and_gpu, needs_cuda +from common_utils import ( + cpu_and_gpu, + needs_cuda, + _create_data, + _create_data_batch, + _assert_equal_tensor_to_pil, + _assert_approx_equal_tensor_to_pil, + _test_fn_on_batch, +) from _assert_utils import assert_equal from typing import Dict, List, Sequence, Tuple @@ -23,31 +31,11 @@ NEAREST, BILINEAR, BICUBIC = InterpolationMode.NEAREST, InterpolationMode.BILINEAR, InterpolationMode.BICUBIC -@pytest.fixture(scope='module') -def tester(): - # instanciation of the Tester class used for equality assertions and other utilities - # TODO: remove this eventually when we don't need the class anymore - return Tester() - - -class Tester(TransformsTester): +class Tester(unittest.TestCase): def setUp(self): self.device = "cpu" - def _test_fn_on_batch(self, batch_tensors, fn, scripted_fn_atol=1e-8, **fn_kwargs): - transformed_batch = fn(batch_tensors, **fn_kwargs) - for i in range(len(batch_tensors)): - img_tensor = batch_tensors[i, ...] - transformed_img = fn(img_tensor, **fn_kwargs) - assert_equal(transformed_img, transformed_batch[i, ...]) - - if scripted_fn_atol >= 0: - scripted_fn = torch.jit.script(fn) - # scriptable function test - s_transformed_batch = scripted_fn(batch_tensors, **fn_kwargs) - torch.testing.assert_close(transformed_batch, s_transformed_batch, rtol=1e-5, atol=scripted_fn_atol) - def test_assert_image_tensor(self): shape = (100,) tensor = torch.rand(*shape, dtype=torch.float, device=self.device) @@ -73,37 +61,37 @@ def test_assert_image_tensor(self): def test_vflip(self): script_vflip = torch.jit.script(F.vflip) - img_tensor, pil_img = self._create_data(16, 18, device=self.device) + img_tensor, pil_img = _create_data(16, 18, device=self.device) vflipped_img = F.vflip(img_tensor) vflipped_pil_img = F.vflip(pil_img) - self.compareTensorToPIL(vflipped_img, vflipped_pil_img) + _assert_equal_tensor_to_pil(vflipped_img, vflipped_pil_img) # scriptable function test vflipped_img_script = script_vflip(img_tensor) assert_equal(vflipped_img, vflipped_img_script) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) - self._test_fn_on_batch(batch_tensors, F.vflip) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) + _test_fn_on_batch(batch_tensors, F.vflip) def test_hflip(self): script_hflip = torch.jit.script(F.hflip) - img_tensor, pil_img = self._create_data(16, 18, device=self.device) + img_tensor, pil_img = _create_data(16, 18, device=self.device) hflipped_img = F.hflip(img_tensor) hflipped_pil_img = F.hflip(pil_img) - self.compareTensorToPIL(hflipped_img, hflipped_pil_img) + _assert_equal_tensor_to_pil(hflipped_img, hflipped_pil_img) # scriptable function test hflipped_img_script = script_hflip(img_tensor) assert_equal(hflipped_img, hflipped_img_script) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) - self._test_fn_on_batch(batch_tensors, F.hflip) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) + _test_fn_on_batch(batch_tensors, F.hflip) def test_crop(self): script_crop = torch.jit.script(F.crop) - img_tensor, pil_img = self._create_data(16, 18, device=self.device) + img_tensor, pil_img = _create_data(16, 18, device=self.device) test_configs = [ (1, 2, 4, 5), # crop inside top-left corner @@ -116,13 +104,13 @@ def test_crop(self): pil_img_cropped = F.crop(pil_img, top, left, height, width) img_tensor_cropped = F.crop(img_tensor, top, left, height, width) - self.compareTensorToPIL(img_tensor_cropped, pil_img_cropped) + _assert_equal_tensor_to_pil(img_tensor_cropped, pil_img_cropped) img_tensor_cropped = script_crop(img_tensor, top, left, height, width) - self.compareTensorToPIL(img_tensor_cropped, pil_img_cropped) + _assert_equal_tensor_to_pil(img_tensor_cropped, pil_img_cropped) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) - self._test_fn_on_batch(batch_tensors, F.crop, top=top, left=left, height=height, width=width) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) + _test_fn_on_batch(batch_tensors, F.crop, top=top, left=left, height=height, width=width) def test_hsv2rgb(self): scripted_fn = torch.jit.script(F_t._hsv2rgb) @@ -146,8 +134,8 @@ def test_hsv2rgb(self): s_rgb_img = scripted_fn(hsv_img) torch.testing.assert_close(rgb_img, s_rgb_img) - batch_tensors = self._create_data_batch(120, 100, num_samples=4, device=self.device).float() - self._test_fn_on_batch(batch_tensors, F_t._hsv2rgb) + batch_tensors = _create_data_batch(120, 100, num_samples=4, device=self.device).float() + _test_fn_on_batch(batch_tensors, F_t._hsv2rgb) def test_rgb2hsv(self): scripted_fn = torch.jit.script(F_t._rgb2hsv) @@ -179,58 +167,58 @@ def test_rgb2hsv(self): s_hsv_img = scripted_fn(rgb_img) torch.testing.assert_close(hsv_img, s_hsv_img, rtol=1e-5, atol=1e-7) - batch_tensors = self._create_data_batch(120, 100, num_samples=4, device=self.device).float() - self._test_fn_on_batch(batch_tensors, F_t._rgb2hsv) + batch_tensors = _create_data_batch(120, 100, num_samples=4, device=self.device).float() + _test_fn_on_batch(batch_tensors, F_t._rgb2hsv) def test_rgb_to_grayscale(self): script_rgb_to_grayscale = torch.jit.script(F.rgb_to_grayscale) - img_tensor, pil_img = self._create_data(32, 34, device=self.device) + img_tensor, pil_img = _create_data(32, 34, device=self.device) for num_output_channels in (3, 1): gray_pil_image = F.rgb_to_grayscale(pil_img, num_output_channels=num_output_channels) gray_tensor = F.rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) - self.approxEqualTensorToPIL(gray_tensor.float(), gray_pil_image, tol=1.0 + 1e-10, agg_method="max") + _assert_approx_equal_tensor_to_pil(gray_tensor.float(), gray_pil_image, tol=1.0 + 1e-10, agg_method="max") s_gray_tensor = script_rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) assert_equal(s_gray_tensor, gray_tensor) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) - self._test_fn_on_batch(batch_tensors, F.rgb_to_grayscale, num_output_channels=num_output_channels) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) + _test_fn_on_batch(batch_tensors, F.rgb_to_grayscale, num_output_channels=num_output_channels) def test_center_crop(self): script_center_crop = torch.jit.script(F.center_crop) - img_tensor, pil_img = self._create_data(32, 34, device=self.device) + img_tensor, pil_img = _create_data(32, 34, device=self.device) cropped_pil_image = F.center_crop(pil_img, [10, 11]) cropped_tensor = F.center_crop(img_tensor, [10, 11]) - self.compareTensorToPIL(cropped_tensor, cropped_pil_image) + _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) cropped_tensor = script_center_crop(img_tensor, [10, 11]) - self.compareTensorToPIL(cropped_tensor, cropped_pil_image) + _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) - self._test_fn_on_batch(batch_tensors, F.center_crop, output_size=[10, 11]) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) + _test_fn_on_batch(batch_tensors, F.center_crop, output_size=[10, 11]) def test_five_crop(self): script_five_crop = torch.jit.script(F.five_crop) - img_tensor, pil_img = self._create_data(32, 34, device=self.device) + img_tensor, pil_img = _create_data(32, 34, device=self.device) cropped_pil_images = F.five_crop(pil_img, [10, 11]) cropped_tensors = F.five_crop(img_tensor, [10, 11]) for i in range(5): - self.compareTensorToPIL(cropped_tensors[i], cropped_pil_images[i]) + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) cropped_tensors = script_five_crop(img_tensor, [10, 11]) for i in range(5): - self.compareTensorToPIL(cropped_tensors[i], cropped_pil_images[i]) + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) tuple_transformed_batches = F.five_crop(batch_tensors, [10, 11]) for i in range(len(batch_tensors)): img_tensor = batch_tensors[i, ...] @@ -250,19 +238,19 @@ def test_five_crop(self): def test_ten_crop(self): script_ten_crop = torch.jit.script(F.ten_crop) - img_tensor, pil_img = self._create_data(32, 34, device=self.device) + img_tensor, pil_img = _create_data(32, 34, device=self.device) cropped_pil_images = F.ten_crop(pil_img, [10, 11]) cropped_tensors = F.ten_crop(img_tensor, [10, 11]) for i in range(10): - self.compareTensorToPIL(cropped_tensors[i], cropped_pil_images[i]) + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) cropped_tensors = script_ten_crop(img_tensor, [10, 11]) for i in range(10): - self.compareTensorToPIL(cropped_tensors[i], cropped_pil_images[i]) + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) tuple_transformed_batches = F.ten_crop(batch_tensors, [10, 11]) for i in range(len(batch_tensors)): img_tensor = batch_tensors[i, ...] @@ -281,8 +269,8 @@ def test_ten_crop(self): def test_pad(self): script_fn = torch.jit.script(F.pad) - tensor, pil_img = self._create_data(7, 8, device=self.device) - batch_tensors = self._create_data_batch(16, 18, num_samples=4, device=self.device) + tensor, pil_img = _create_data(7, 8, device=self.device) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) for dt in [None, torch.float32, torch.float64, torch.float16]: @@ -313,7 +301,7 @@ def test_pad(self): if pad_tensor_8b.dtype != torch.uint8: pad_tensor_8b = pad_tensor_8b.to(torch.uint8) - self.compareTensorToPIL(pad_tensor_8b, pad_pil_img, msg="{}, {}".format(pad, kwargs)) + _assert_equal_tensor_to_pil(pad_tensor_8b, pad_pil_img, msg="{}, {}".format(pad, kwargs)) if isinstance(pad, int): script_pad = [pad, ] @@ -322,19 +310,19 @@ def test_pad(self): pad_tensor_script = script_fn(tensor, script_pad, **kwargs) assert_equal(pad_tensor, pad_tensor_script, msg="{}, {}".format(pad, kwargs)) - self._test_fn_on_batch(batch_tensors, F.pad, padding=script_pad, **kwargs) + _test_fn_on_batch(batch_tensors, F.pad, padding=script_pad, **kwargs) def test_resized_crop(self): # test values of F.resized_crop in several cases: # 1) resize to the same size, crop to the same size => should be identity - tensor, _ = self._create_data(26, 36, device=self.device) + tensor, _ = _create_data(26, 36, device=self.device) for mode in [NEAREST, BILINEAR, BICUBIC]: out_tensor = F.resized_crop(tensor, top=0, left=0, height=26, width=36, size=[26, 36], interpolation=mode) assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) # 2) resize by half and crop a TL corner - tensor, _ = self._create_data(26, 36, device=self.device) + tensor, _ = _create_data(26, 36, device=self.device) out_tensor = F.resized_crop(tensor, top=0, left=0, height=20, width=30, size=[10, 15], interpolation=NEAREST) expected_out_tensor = tensor[:, :20:2, :30:2] assert_equal( @@ -344,8 +332,8 @@ def test_resized_crop(self): msg="{} vs {}".format(expected_out_tensor[0, :10, :10], out_tensor[0, :10, :10]), ) - batch_tensors = self._create_data_batch(26, 36, num_samples=4, device=self.device) - self._test_fn_on_batch( + batch_tensors = _create_data_batch(26, 36, num_samples=4, device=self.device) + _test_fn_on_batch( batch_tensors, F.resized_crop, top=1, left=2, height=20, width=30, size=[10, 15], interpolation=NEAREST ) @@ -447,7 +435,7 @@ def _test_affine_translations(self, tensor, pil_img, scripted_affine): if out_tensor.dtype != torch.uint8: out_tensor = out_tensor.to(torch.uint8) - self.compareTensorToPIL(out_tensor, out_pil_img) + _assert_equal_tensor_to_pil(out_tensor, out_pil_img) def _test_affine_all_ops(self, tensor, pil_img, scripted_affine): # 4) Test rotation + translation + scale + share @@ -491,7 +479,7 @@ def test_affine(self): # Tests on square and rectangular images scripted_affine = torch.jit.script(F.affine) - data = [self._create_data(26, 26, device=self.device), self._create_data(32, 26, device=self.device)] + data = [_create_data(26, 26, device=self.device), _create_data(32, 26, device=self.device)] for tensor, pil_img in data: for dt in [None, torch.float32, torch.float64, torch.float16]: @@ -511,11 +499,11 @@ def test_affine(self): self._test_affine_translations(tensor, pil_img, scripted_affine) self._test_affine_all_ops(tensor, pil_img, scripted_affine) - batch_tensors = self._create_data_batch(26, 36, num_samples=4, device=self.device) + batch_tensors = _create_data_batch(26, 36, num_samples=4, device=self.device) if dt is not None: batch_tensors = batch_tensors.to(dtype=dt) - self._test_fn_on_batch( + _test_fn_on_batch( batch_tensors, F.affine, angle=-43, translate=[-3, 4], scale=1.2, shear=[4.0, 5.0] ) @@ -580,7 +568,7 @@ def test_rotate(self): # Tests on square image scripted_rotate = torch.jit.script(F.rotate) - data = [self._create_data(26, 26, device=self.device), self._create_data(32, 26, device=self.device)] + data = [_create_data(26, 26, device=self.device), _create_data(32, 26, device=self.device)] for tensor, pil_img in data: img_size = pil_img.size @@ -601,12 +589,12 @@ def test_rotate(self): self._test_rotate_all_options(tensor, pil_img, scripted_rotate, centers) - batch_tensors = self._create_data_batch(26, 36, num_samples=4, device=self.device) + batch_tensors = _create_data_batch(26, 36, num_samples=4, device=self.device) if dt is not None: batch_tensors = batch_tensors.to(dtype=dt) center = (20, 22) - self._test_fn_on_batch( + _test_fn_on_batch( batch_tensors, F.rotate, angle=32, interpolation=NEAREST, expand=True, center=center ) tensor, pil_img = data[0] @@ -735,7 +723,7 @@ def _get_data_dims_and_points_for_perspective(): @pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) @pytest.mark.parametrize('fill', (None, [0, 0, 0], [1, 2, 3], [255, 255, 255], [1, ], (2.0, ))) @pytest.mark.parametrize('fn', [F.perspective, torch.jit.script(F.perspective)]) -def test_perspective_pil_vs_tensor(device, dims_and_points, dt, fill, fn, tester): +def test_perspective_pil_vs_tensor(device, dims_and_points, dt, fill, fn): if dt == torch.float16 and device == "cpu": # skip float16 on CPU case @@ -743,7 +731,7 @@ def test_perspective_pil_vs_tensor(device, dims_and_points, dt, fill, fn, tester data_dims, (spoints, epoints) = dims_and_points - tensor, pil_img = tester._create_data(*data_dims, device=device) + tensor, pil_img = _create_data(*data_dims, device=device) if dt is not None: tensor = tensor.to(dtype=dt) @@ -766,7 +754,7 @@ def test_perspective_pil_vs_tensor(device, dims_and_points, dt, fill, fn, tester @pytest.mark.parametrize('device', cpu_and_gpu()) @pytest.mark.parametrize('dims_and_points', _get_data_dims_and_points_for_perspective()) @pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) -def test_perspective_batch(device, dims_and_points, dt, tester): +def test_perspective_batch(device, dims_and_points, dt): if dt == torch.float16 and device == "cpu": # skip float16 on CPU case @@ -774,28 +762,28 @@ def test_perspective_batch(device, dims_and_points, dt, tester): data_dims, (spoints, epoints) = dims_and_points - batch_tensors = tester._create_data_batch(*data_dims, num_samples=4, device=device) + batch_tensors = _create_data_batch(*data_dims, num_samples=4, device=device) if dt is not None: batch_tensors = batch_tensors.to(dtype=dt) # Ignore the equivalence between scripted and regular function on float16 cuda. The pixels at # the border may be entirely different due to small rounding errors. scripted_fn_atol = -1 if (dt == torch.float16 and device == "cuda") else 1e-8 - tester._test_fn_on_batch( + _test_fn_on_batch( batch_tensors, F.perspective, scripted_fn_atol=scripted_fn_atol, startpoints=spoints, endpoints=epoints, interpolation=NEAREST ) -def test_perspective_interpolation_warning(tester): +def test_perspective_interpolation_warning(): # assert changed type warning spoints = [[0, 0], [33, 0], [33, 25], [0, 25]] epoints = [[3, 2], [32, 3], [30, 24], [2, 25]] tensor = torch.randint(0, 256, (3, 26, 26)) - with tester.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): + with pytest.warns(UserWarning, match="Argument interpolation should be of type InterpolationMode"): res1 = F.perspective(tensor, startpoints=spoints, endpoints=epoints, interpolation=2) res2 = F.perspective(tensor, startpoints=spoints, endpoints=epoints, interpolation=BILINEAR) - tester.assertTrue(res1.equal(res2)) + assert_equal(res1, res2) @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -803,7 +791,7 @@ def test_perspective_interpolation_warning(tester): @pytest.mark.parametrize('size', [32, 26, [32, ], [32, 32], (32, 32), [26, 35]]) @pytest.mark.parametrize('max_size', [None, 34, 40, 1000]) @pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC, NEAREST]) -def test_resize(device, dt, size, max_size, interpolation, tester): +def test_resize(device, dt, size, max_size, interpolation): if dt == torch.float16 and device == "cpu": # skip float16 on CPU case @@ -814,8 +802,8 @@ def test_resize(device, dt, size, max_size, interpolation, tester): torch.manual_seed(12) script_fn = torch.jit.script(F.resize) - tensor, pil_img = tester._create_data(26, 36, device=device) - batch_tensors = tester._create_data_batch(16, 18, num_samples=4, device=device) + tensor, pil_img = _create_data(26, 36, device=device) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) if dt is not None: # This is a trivial cast to float of uint8 data to test all cases @@ -837,7 +825,7 @@ def test_resize(device, dt, size, max_size, interpolation, tester): resized_tensor_f = resized_tensor_f.to(torch.float) # Pay attention to high tolerance for MAE - tester.approxEqualTensorToPIL(resized_tensor_f, resized_pil_img, tol=8.0) + _assert_approx_equal_tensor_to_pil(resized_tensor_f, resized_pil_img, tol=8.0) if isinstance(size, int): script_size = [size, ] @@ -849,15 +837,15 @@ def test_resize(device, dt, size, max_size, interpolation, tester): ) assert_equal(resized_tensor, resize_result) - tester._test_fn_on_batch( + _test_fn_on_batch( batch_tensors, F.resize, size=script_size, interpolation=interpolation, max_size=max_size ) @pytest.mark.parametrize('device', cpu_and_gpu()) -def test_resize_asserts(device, tester): +def test_resize_asserts(device): - tensor, pil_img = tester._create_data(26, 36, device=device) + tensor, pil_img = _create_data(26, 36, device=device) # assert changed type warning with pytest.warns(UserWarning, match=r"Argument interpolation should be of type InterpolationMode"): @@ -878,7 +866,7 @@ def test_resize_asserts(device, tester): @pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) @pytest.mark.parametrize('size', [[96, 72], [96, 420], [420, 72]]) @pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC]) -def test_resize_antialias(device, dt, size, interpolation, tester): +def test_resize_antialias(device, dt, size, interpolation): if dt == torch.float16 and device == "cpu": # skip float16 on CPU case @@ -886,7 +874,7 @@ def test_resize_antialias(device, dt, size, interpolation, tester): torch.manual_seed(12) script_fn = torch.jit.script(F.resize) - tensor, pil_img = tester._create_data(320, 290, device=device) + tensor, pil_img = _create_data(320, 290, device=device) if dt is not None: # This is a trivial cast to float of uint8 data to test all cases @@ -895,17 +883,14 @@ def test_resize_antialias(device, dt, size, interpolation, tester): resized_tensor = F.resize(tensor, size=size, interpolation=interpolation, antialias=True) resized_pil_img = F.resize(pil_img, size=size, interpolation=interpolation) - tester.assertEqual( - resized_tensor.size()[1:], resized_pil_img.size[::-1], - msg=f"{size}, {interpolation}, {dt}" - ) + assert resized_tensor.size()[1:] == resized_pil_img.size[::-1] resized_tensor_f = resized_tensor # we need to cast to uint8 to compare with PIL image if resized_tensor_f.dtype == torch.uint8: resized_tensor_f = resized_tensor_f.to(torch.float) - tester.approxEqualTensorToPIL( + _assert_approx_equal_tensor_to_pil( resized_tensor_f, resized_pil_img, tol=0.5, msg=f"{size}, {interpolation}, {dt}" ) @@ -917,7 +902,7 @@ def test_resize_antialias(device, dt, size, interpolation, tester): # match PIL implementation. accepted_tol = 15.0 - tester.approxEqualTensorToPIL( + _assert_approx_equal_tensor_to_pil( resized_tensor_f, resized_pil_img, tol=accepted_tol, agg_method="max", msg=f"{size}, {interpolation}, {dt}" ) @@ -928,17 +913,17 @@ def test_resize_antialias(device, dt, size, interpolation, tester): script_size = size resize_result = script_fn(tensor, size=script_size, interpolation=interpolation, antialias=True) - tester.assertTrue(resized_tensor.equal(resize_result), msg=f"{size}, {interpolation}, {dt}") + assert_equal(resized_tensor, resize_result) @needs_cuda @pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC]) -def test_assert_resize_antialias(interpolation, tester): +def test_assert_resize_antialias(interpolation): # Checks implementation on very large scales # and catch TORCH_CHECK inside interpolate_aa_kernels.cu torch.manual_seed(12) - tensor, pil_img = tester._create_data(1000, 1000, device="cuda") + tensor, pil_img = _create_data(1000, 1000, device="cuda") with pytest.raises(RuntimeError, match=r"Max supported scale factor is"): F.resize(tensor, size=(5, 5), interpolation=interpolation, antialias=True) @@ -946,12 +931,10 @@ def test_assert_resize_antialias(interpolation, tester): def check_functional_vs_PIL_vs_scripted(fn, fn_pil, fn_t, config, device, dtype, tol=2.0 + 1e-10, agg_method="max"): - tester = Tester() - script_fn = torch.jit.script(fn) torch.manual_seed(15) - tensor, pil_img = tester._create_data(26, 34, device=device) - batch_tensors = tester._create_data_batch(16, 18, num_samples=4, device=device) + tensor, pil_img = _create_data(26, 34, device=device) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) if dtype is not None: tensor = F.convert_image_dtype(tensor, dtype) @@ -970,7 +953,7 @@ def check_functional_vs_PIL_vs_scripted(fn, fn_pil, fn_t, config, device, dtype, # Check that max difference does not exceed 2 in [0, 255] range # Exact matching is not possible due to incompatibility convert_image_dtype and PIL results - tester.approxEqualTensorToPIL(rbg_tensor.float(), out_pil, tol=tol, agg_method=agg_method) + _assert_approx_equal_tensor_to_pil(rbg_tensor.float(), out_pil, tol=tol, agg_method=agg_method) atol = 1e-6 if out_fn_t.dtype == torch.uint8 and "cuda" in torch.device(device).type: @@ -978,7 +961,7 @@ def check_functional_vs_PIL_vs_scripted(fn, fn_pil, fn_t, config, device, dtype, assert out_fn_t.allclose(out_scripted, atol=atol) # FIXME: fn will be scripted again in _test_fn_on_batch. We could avoid that. - tester._test_fn_on_batch(batch_tensors, fn, scripted_fn_atol=atol, **config) + _test_fn_on_batch(batch_tensors, fn, scripted_fn_atol=atol, **config) @pytest.mark.parametrize('device', cpu_and_gpu()) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 96711decdd0..a725d9a44da 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -9,14 +9,22 @@ import unittest from typing import Sequence -from common_utils import TransformsTester, get_tmp_dir, int_dtypes, float_dtypes +from common_utils import ( + get_tmp_dir, + int_dtypes, + float_dtypes, + _create_data, + _create_data_batch, + _assert_equal_tensor_to_pil, + _assert_approx_equal_tensor_to_pil, +) from _assert_utils import assert_equal NEAREST, BILINEAR, BICUBIC = InterpolationMode.NEAREST, InterpolationMode.BILINEAR, InterpolationMode.BICUBIC -class Tester(TransformsTester): +class Tester(unittest.TestCase): def setUp(self): self.device = "cpu" @@ -26,13 +34,13 @@ def _test_functional_op(self, func, fn_kwargs, test_exact_match=True, **match_kw fn_kwargs = {} f = getattr(F, func) - tensor, pil_img = self._create_data(height=10, width=10, device=self.device) + tensor, pil_img = _create_data(height=10, width=10, device=self.device) transformed_tensor = f(tensor, **fn_kwargs) transformed_pil_img = f(pil_img, **fn_kwargs) if test_exact_match: - self.compareTensorToPIL(transformed_tensor, transformed_pil_img, **match_kwargs) + _assert_equal_tensor_to_pil(transformed_tensor, transformed_pil_img, **match_kwargs) else: - self.approxEqualTensorToPIL(transformed_tensor, transformed_pil_img, **match_kwargs) + _assert_approx_equal_tensor_to_pil(transformed_tensor, transformed_pil_img, **match_kwargs) def _test_transform_vs_scripted(self, transform, s_transform, tensor, msg=None): torch.manual_seed(12) @@ -63,22 +71,22 @@ def _test_class_op(self, method, meth_kwargs=None, test_exact_match=True, **matc f = getattr(T, method)(**meth_kwargs) scripted_fn = torch.jit.script(f) - tensor, pil_img = self._create_data(26, 34, device=self.device) + tensor, pil_img = _create_data(26, 34, device=self.device) # set seed to reproduce the same transformation for tensor and PIL image torch.manual_seed(12) transformed_tensor = f(tensor) torch.manual_seed(12) transformed_pil_img = f(pil_img) if test_exact_match: - self.compareTensorToPIL(transformed_tensor, transformed_pil_img, **match_kwargs) + _assert_equal_tensor_to_pil(transformed_tensor, transformed_pil_img, **match_kwargs) else: - self.approxEqualTensorToPIL(transformed_tensor.float(), transformed_pil_img, **match_kwargs) + _assert_approx_equal_tensor_to_pil(transformed_tensor.float(), transformed_pil_img, **match_kwargs) torch.manual_seed(12) transformed_tensor_script = scripted_fn(tensor) assert_equal(transformed_tensor, transformed_tensor_script) - batch_tensors = self._create_data_batch(height=23, width=34, channels=3, num_samples=4, device=self.device) + batch_tensors = _create_data_batch(height=23, width=34, channels=3, num_samples=4, device=self.device) self._test_transform_vs_scripted_on_batch(f, scripted_fn, batch_tensors) with get_tmp_dir() as tmp_dir: @@ -259,13 +267,13 @@ def _test_op_list_output(self, func, method, out_length, fn_kwargs=None, meth_kw fn = getattr(F, func) scripted_fn = torch.jit.script(fn) - tensor, pil_img = self._create_data(height=20, width=20, device=self.device) + tensor, pil_img = _create_data(height=20, width=20, device=self.device) transformed_t_list = fn(tensor, **fn_kwargs) transformed_p_list = fn(pil_img, **fn_kwargs) self.assertEqual(len(transformed_t_list), len(transformed_p_list)) self.assertEqual(len(transformed_t_list), out_length) for transformed_tensor, transformed_pil_img in zip(transformed_t_list, transformed_p_list): - self.compareTensorToPIL(transformed_tensor, transformed_pil_img) + _assert_equal_tensor_to_pil(transformed_tensor, transformed_pil_img) transformed_t_list_script = scripted_fn(tensor.detach().clone(), **fn_kwargs) self.assertEqual(len(transformed_t_list), len(transformed_t_list_script)) @@ -284,7 +292,7 @@ def _test_op_list_output(self, func, method, out_length, fn_kwargs=None, meth_kw self.assertEqual(len(output), len(transformed_t_list_script)) # test on batch of tensors - batch_tensors = self._create_data_batch(height=23, width=34, channels=3, num_samples=4, device=self.device) + batch_tensors = _create_data_batch(height=23, width=34, channels=3, num_samples=4, device=self.device) torch.manual_seed(12) transformed_batch_list = fn(batch_tensors) @@ -350,7 +358,7 @@ def test_resize(self): self.assertEqual(y.shape[1], 38) self.assertEqual(y.shape[2], int(38 * 46 / 32)) - tensor, _ = self._create_data(height=34, width=36, device=self.device) + tensor, _ = _create_data(height=34, width=36, device=self.device) batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=self.device) for dt in [None, torch.float32, torch.float64]: @@ -487,7 +495,7 @@ def test_to_grayscale(self): def test_normalize(self): fn = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) - tensor, _ = self._create_data(26, 34, device=self.device) + tensor, _ = _create_data(26, 34, device=self.device) with self.assertRaisesRegex(TypeError, r"Input tensor should be a float tensor"): fn(tensor) @@ -506,7 +514,7 @@ def test_normalize(self): def test_linear_transformation(self): c, h, w = 3, 24, 32 - tensor, _ = self._create_data(h, w, channels=c, device=self.device) + tensor, _ = _create_data(h, w, channels=c, device=self.device) matrix = torch.rand(c * h * w, c * h * w, device=self.device) mean_vector = torch.rand(c * h * w, device=self.device) @@ -529,7 +537,7 @@ def test_linear_transformation(self): scripted_fn.save(os.path.join(tmp_dir, "t_norm.pt")) def test_compose(self): - tensor, _ = self._create_data(26, 34, device=self.device) + tensor, _ = _create_data(26, 34, device=self.device) tensor = tensor.to(dtype=torch.float32) / 255.0 transforms = T.Compose([ @@ -552,7 +560,7 @@ def test_compose(self): torch.jit.script(t) def test_random_apply(self): - tensor, _ = self._create_data(26, 34, device=self.device) + tensor, _ = _create_data(26, 34, device=self.device) tensor = tensor.to(dtype=torch.float32) / 255.0 transforms = T.RandomApply([ @@ -620,7 +628,7 @@ def test_random_erasing(self): with self.assertRaises(ValueError, msg="If value is a sequence, it should have either a single value or 3"): random_erasing(img) - tensor, _ = self._create_data(24, 32, channels=3, device=self.device) + tensor, _ = _create_data(24, 32, channels=3, device=self.device) batch_tensors = torch.rand(4, 3, 44, 56, device=self.device) test_configs = [ @@ -640,7 +648,7 @@ def test_random_erasing(self): scripted_fn.save(os.path.join(tmp_dir, "t_random_erasing.pt")) def test_convert_image_dtype(self): - tensor, _ = self._create_data(26, 34, device=self.device) + tensor, _ = _create_data(26, 34, device=self.device) batch_tensors = torch.rand(4, 3, 44, 56, device=self.device) for in_dtype in int_dtypes() + float_dtypes(): From 4c0fdc6135cfeef10e8f6c586207acd59730793b Mon Sep 17 00:00:00 2001 From: Saswat Das Date: Thu, 3 Jun 2021 14:28:55 +0530 Subject: [PATCH 129/279] Port test_adjust_xxx in test_transforms to pytest (#3950) --- test/test_transforms.py | 386 ++++++++++++++++++++-------------------- 1 file changed, 197 insertions(+), 189 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index 3676de53627..d83b03c1911 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -10,6 +10,7 @@ import math import random import numpy as np +import pytest from PIL import Image try: import accimage @@ -1231,195 +1232,6 @@ def test_normalize_3d_tensor(self): torch.testing.assert_close(target, result1) torch.testing.assert_close(target, result2) - def test_adjust_brightness(self): - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - - # test 0 - y_pil = F.adjust_brightness(x_pil, 1) - y_np = np.array(y_pil) - torch.testing.assert_close(y_np, x_np) - - # test 1 - y_pil = F.adjust_brightness(x_pil, 0.5) - y_np = np.array(y_pil) - y_ans = [0, 2, 6, 27, 67, 113, 18, 4, 117, 45, 127, 0] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - # test 2 - y_pil = F.adjust_brightness(x_pil, 2) - y_np = np.array(y_pil) - y_ans = [0, 10, 26, 108, 255, 255, 74, 16, 255, 180, 255, 2] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - def test_adjust_contrast(self): - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - - # test 0 - y_pil = F.adjust_contrast(x_pil, 1) - y_np = np.array(y_pil) - torch.testing.assert_close(y_np, x_np) - - # test 1 - y_pil = F.adjust_contrast(x_pil, 0.5) - y_np = np.array(y_pil) - y_ans = [43, 45, 49, 70, 110, 156, 61, 47, 160, 88, 170, 43] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - # test 2 - y_pil = F.adjust_contrast(x_pil, 2) - y_np = np.array(y_pil) - y_ans = [0, 0, 0, 22, 184, 255, 0, 0, 255, 94, 255, 0] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - @unittest.skipIf(Image.__version__ >= '7', "Temporarily disabled") - def test_adjust_saturation(self): - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - - # test 0 - y_pil = F.adjust_saturation(x_pil, 1) - y_np = np.array(y_pil) - torch.testing.assert_close(y_np, x_np) - - # test 1 - y_pil = F.adjust_saturation(x_pil, 0.5) - y_np = np.array(y_pil) - y_ans = [2, 4, 8, 87, 128, 173, 39, 25, 138, 133, 215, 88] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - # test 2 - y_pil = F.adjust_saturation(x_pil, 2) - y_np = np.array(y_pil) - y_ans = [0, 6, 22, 0, 149, 255, 32, 0, 255, 4, 255, 0] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - def test_adjust_hue(self): - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - - with self.assertRaises(ValueError): - F.adjust_hue(x_pil, -0.7) - F.adjust_hue(x_pil, 1) - - # test 0: almost same as x_data but not exact. - # probably because hsv <-> rgb floating point ops - y_pil = F.adjust_hue(x_pil, 0) - y_np = np.array(y_pil) - y_ans = [0, 5, 13, 54, 139, 226, 35, 8, 234, 91, 255, 1] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - # test 1 - y_pil = F.adjust_hue(x_pil, 0.25) - y_np = np.array(y_pil) - y_ans = [13, 0, 12, 224, 54, 226, 234, 8, 99, 1, 222, 255] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - # test 2 - y_pil = F.adjust_hue(x_pil, -0.25) - y_np = np.array(y_pil) - y_ans = [0, 13, 2, 54, 226, 58, 8, 234, 152, 255, 43, 1] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - def test_adjust_sharpness(self): - x_shape = [4, 4, 3] - x_data = [75, 121, 114, 105, 97, 107, 105, 32, 66, 111, 117, 114, 99, 104, 97, 0, - 0, 65, 108, 101, 120, 97, 110, 100, 101, 114, 32, 86, 114, 121, 110, 105, - 111, 116, 105, 115, 0, 0, 73, 32, 108, 111, 118, 101, 32, 121, 111, 117] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - - # test 0 - y_pil = F.adjust_sharpness(x_pil, 1) - y_np = np.array(y_pil) - torch.testing.assert_close(y_np, x_np) - - # test 1 - y_pil = F.adjust_sharpness(x_pil, 0.5) - y_np = np.array(y_pil) - y_ans = [75, 121, 114, 105, 97, 107, 105, 32, 66, 111, 117, 114, 99, 104, 97, 30, - 30, 74, 103, 96, 114, 97, 110, 100, 101, 114, 32, 81, 103, 108, 102, 101, - 107, 116, 105, 115, 0, 0, 73, 32, 108, 111, 118, 101, 32, 121, 111, 117] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - # test 2 - y_pil = F.adjust_sharpness(x_pil, 2) - y_np = np.array(y_pil) - y_ans = [75, 121, 114, 105, 97, 107, 105, 32, 66, 111, 117, 114, 99, 104, 97, 0, - 0, 46, 118, 111, 132, 97, 110, 100, 101, 114, 32, 95, 135, 146, 126, 112, - 119, 116, 105, 115, 0, 0, 73, 32, 108, 111, 118, 101, 32, 121, 111, 117] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - # test 3 - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - x_th = torch.tensor(x_np.transpose(2, 0, 1)) - y_pil = F.adjust_sharpness(x_pil, 2) - y_np = np.array(y_pil).transpose(2, 0, 1) - y_th = F.adjust_sharpness(x_th, 2) - torch.testing.assert_close(y_np, y_th.numpy()) - - def test_adjust_gamma(self): - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - - # test 0 - y_pil = F.adjust_gamma(x_pil, 1) - y_np = np.array(y_pil) - torch.testing.assert_close(y_np, x_np) - - # test 1 - y_pil = F.adjust_gamma(x_pil, 0.5) - y_np = np.array(y_pil) - y_ans = [0, 35, 57, 117, 186, 241, 97, 45, 245, 152, 255, 16] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - # test 2 - y_pil = F.adjust_gamma(x_pil, 2) - y_np = np.array(y_pil) - y_ans = [0, 0, 0, 11, 71, 201, 5, 0, 215, 31, 255, 0] - y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) - torch.testing.assert_close(y_np, y_ans) - - def test_adjusts_L_mode(self): - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_rgb = Image.fromarray(x_np, mode='RGB') - - x_l = x_rgb.convert('L') - self.assertEqual(F.adjust_brightness(x_l, 2).mode, 'L') - self.assertEqual(F.adjust_saturation(x_l, 2).mode, 'L') - self.assertEqual(F.adjust_contrast(x_l, 2).mode, 'L') - self.assertEqual(F.adjust_hue(x_l, 0.4).mode, 'L') - self.assertEqual(F.adjust_sharpness(x_l, 2).mode, 'L') - self.assertEqual(F.adjust_gamma(x_l, 0.5).mode, 'L') - def test_color_jitter(self): color_jitter = transforms.ColorJitter(2, 2, 2, 0.1) @@ -2019,5 +1831,201 @@ def test_random_erasing(self): t.__repr__() +def test_adjust_brightness(): + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + + # test 0 + y_pil = F.adjust_brightness(x_pil, 1) + y_np = np.array(y_pil) + torch.testing.assert_close(y_np, x_np) + + # test 1 + y_pil = F.adjust_brightness(x_pil, 0.5) + y_np = np.array(y_pil) + y_ans = [0, 2, 6, 27, 67, 113, 18, 4, 117, 45, 127, 0] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + # test 2 + y_pil = F.adjust_brightness(x_pil, 2) + y_np = np.array(y_pil) + y_ans = [0, 10, 26, 108, 255, 255, 74, 16, 255, 180, 255, 2] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + +def test_adjust_contrast(): + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + + # test 0 + y_pil = F.adjust_contrast(x_pil, 1) + y_np = np.array(y_pil) + torch.testing.assert_close(y_np, x_np) + + # test 1 + y_pil = F.adjust_contrast(x_pil, 0.5) + y_np = np.array(y_pil) + y_ans = [43, 45, 49, 70, 110, 156, 61, 47, 160, 88, 170, 43] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + # test 2 + y_pil = F.adjust_contrast(x_pil, 2) + y_np = np.array(y_pil) + y_ans = [0, 0, 0, 22, 184, 255, 0, 0, 255, 94, 255, 0] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + +@pytest.mark.skipif(Image.__version__ >= '7', reason="Temporarily disabled") +def test_adjust_saturation(): + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + + # test 0 + y_pil = F.adjust_saturation(x_pil, 1) + y_np = np.array(y_pil) + torch.testing.assert_close(y_np, x_np) + + # test 1 + y_pil = F.adjust_saturation(x_pil, 0.5) + y_np = np.array(y_pil) + y_ans = [2, 4, 8, 87, 128, 173, 39, 25, 138, 133, 215, 88] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + # test 2 + y_pil = F.adjust_saturation(x_pil, 2) + y_np = np.array(y_pil) + y_ans = [0, 6, 22, 0, 149, 255, 32, 0, 255, 4, 255, 0] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + +def test_adjust_hue(): + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + + with pytest.raises(ValueError): + F.adjust_hue(x_pil, -0.7) + F.adjust_hue(x_pil, 1) + + # test 0: almost same as x_data but not exact. + # probably because hsv <-> rgb floating point ops + y_pil = F.adjust_hue(x_pil, 0) + y_np = np.array(y_pil) + y_ans = [0, 5, 13, 54, 139, 226, 35, 8, 234, 91, 255, 1] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + # test 1 + y_pil = F.adjust_hue(x_pil, 0.25) + y_np = np.array(y_pil) + y_ans = [13, 0, 12, 224, 54, 226, 234, 8, 99, 1, 222, 255] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + # test 2 + y_pil = F.adjust_hue(x_pil, -0.25) + y_np = np.array(y_pil) + y_ans = [0, 13, 2, 54, 226, 58, 8, 234, 152, 255, 43, 1] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + +def test_adjust_sharpness(): + x_shape = [4, 4, 3] + x_data = [75, 121, 114, 105, 97, 107, 105, 32, 66, 111, 117, 114, 99, 104, 97, 0, + 0, 65, 108, 101, 120, 97, 110, 100, 101, 114, 32, 86, 114, 121, 110, 105, + 111, 116, 105, 115, 0, 0, 73, 32, 108, 111, 118, 101, 32, 121, 111, 117] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + + # test 0 + y_pil = F.adjust_sharpness(x_pil, 1) + y_np = np.array(y_pil) + torch.testing.assert_close(y_np, x_np) + + # test 1 + y_pil = F.adjust_sharpness(x_pil, 0.5) + y_np = np.array(y_pil) + y_ans = [75, 121, 114, 105, 97, 107, 105, 32, 66, 111, 117, 114, 99, 104, 97, 30, + 30, 74, 103, 96, 114, 97, 110, 100, 101, 114, 32, 81, 103, 108, 102, 101, + 107, 116, 105, 115, 0, 0, 73, 32, 108, 111, 118, 101, 32, 121, 111, 117] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + # test 2 + y_pil = F.adjust_sharpness(x_pil, 2) + y_np = np.array(y_pil) + y_ans = [75, 121, 114, 105, 97, 107, 105, 32, 66, 111, 117, 114, 99, 104, 97, 0, + 0, 46, 118, 111, 132, 97, 110, 100, 101, 114, 32, 95, 135, 146, 126, 112, + 119, 116, 105, 115, 0, 0, 73, 32, 108, 111, 118, 101, 32, 121, 111, 117] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + # test 3 + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + x_th = torch.tensor(x_np.transpose(2, 0, 1)) + y_pil = F.adjust_sharpness(x_pil, 2) + y_np = np.array(y_pil).transpose(2, 0, 1) + y_th = F.adjust_sharpness(x_th, 2) + torch.testing.assert_close(y_np, y_th.numpy()) + + +def test_adjust_gamma(): + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + + # test 0 + y_pil = F.adjust_gamma(x_pil, 1) + y_np = np.array(y_pil) + torch.testing.assert_close(y_np, x_np) + + # test 1 + y_pil = F.adjust_gamma(x_pil, 0.5) + y_np = np.array(y_pil) + y_ans = [0, 35, 57, 117, 186, 241, 97, 45, 245, 152, 255, 16] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + # test 2 + y_pil = F.adjust_gamma(x_pil, 2) + y_np = np.array(y_pil) + y_ans = [0, 0, 0, 11, 71, 201, 5, 0, 215, 31, 255, 0] + y_ans = np.array(y_ans, dtype=np.uint8).reshape(x_shape) + torch.testing.assert_close(y_np, y_ans) + + +def test_adjusts_L_mode(): + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_rgb = Image.fromarray(x_np, mode='RGB') + + x_l = x_rgb.convert('L') + assert F.adjust_brightness(x_l, 2).mode == 'L' + assert F.adjust_saturation(x_l, 2).mode == 'L' + assert F.adjust_contrast(x_l, 2).mode == 'L' + assert F.adjust_hue(x_l, 0.4).mode == 'L' + assert F.adjust_sharpness(x_l, 2).mode == 'L' + assert F.adjust_gamma(x_l, 0.5).mode == 'L' + + if __name__ == '__main__': unittest.main() From 7daa90ac84cc656e9ceb6cc30f9a5e46a2561c3f Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Thu, 3 Jun 2021 10:47:45 +0100 Subject: [PATCH 130/279] Take assertExpected and check_jit_scriptable out of the TestCase class (#3947) --- test/common_utils.py | 108 ------------------------------------ test/test_models.py | 129 ++++++++++++++++++++++++++++++++++++++----- 2 files changed, 116 insertions(+), 121 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index 8fe76e38e93..ebc21feda69 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -5,9 +5,7 @@ import unittest import argparse import sys -import io import torch -import warnings import __main__ import random import inspect @@ -15,7 +13,6 @@ from numbers import Number from torch._six import string_classes from collections import OrderedDict -from _utils_internal import get_relative_path import numpy as np from PIL import Image @@ -49,10 +46,6 @@ def set_rng_seed(seed): np.random.seed(seed) -ACCEPT = os.getenv('EXPECTTEST_ACCEPT', '0') == '1' -TEST_WITH_SLOW = os.getenv('PYTORCH_TEST_WITH_SLOW', '0') == '1' - - class MapNestedTensorObjectImpl(object): def __init__(self, tensor_map_fn): self.tensor_map_fn = tensor_map_fn @@ -95,55 +88,6 @@ def is_iterable(obj): class TestCase(unittest.TestCase): precision = 1e-5 - def _get_expected_file(self, name=None): - # NB: we take __file__ from the module that defined the test - # class, so we place the expect directory where the test script - # lives, NOT where test/common_utils.py lives. - module_id = self.__class__.__module__ - - # Determine expected file based on environment - expected_file_base = get_relative_path( - os.path.realpath(sys.modules[module_id].__file__), - "expect") - - # Note: for legacy reasons, the reference file names all had "ModelTest.test_" in their names - # We hardcode it here to avoid having to re-generate the reference files - expected_file = expected_file = os.path.join(expected_file_base, 'ModelTester.test_' + name) - expected_file += "_expect.pkl" - - if not ACCEPT and not os.path.exists(expected_file): - raise RuntimeError( - f"No expect file exists for {os.path.basename(expected_file)} in {expected_file}; " - "to accept the current output, re-run the failing test after setting the EXPECTTEST_ACCEPT " - "env variable. For example: EXPECTTEST_ACCEPT=1 pytest test/test_models.py -k alexnet" - ) - - return expected_file - - def assertExpected(self, output, name, prec=None): - r""" - Test that a python value matches the recorded contents of a file - based on a "check" name. The value must be - pickable with `torch.save`. This file - is placed in the 'expect' directory in the same directory - as the test script. You can automatically update the recorded test - output using an EXPECTTEST_ACCEPT=1 env variable. - """ - expected_file = self._get_expected_file(name) - - if ACCEPT: - filename = {os.path.basename(expected_file)} - print("Accepting updated output for {}:\n\n{}".format(filename, output)) - torch.save(output, expected_file) - MAX_PICKLE_SIZE = 50 * 1000 # 50 KB - binary_size = os.path.getsize(expected_file) - if binary_size > MAX_PICKLE_SIZE: - raise RuntimeError("The output for {}, is larger than 50kb".format(filename)) - else: - expected = torch.load(expected_file) - rtol = atol = prec or self.precision - torch.testing.assert_close(output, expected, rtol=rtol, atol=atol, check_dtype=False) - def assertEqual(self, x, y, prec=None, message='', allow_inf=False): """ This is copied from pytorch/test/common_utils.py's TestCase.assertEqual @@ -261,58 +205,6 @@ def assertTensorsEqual(a, b): else: super(TestCase, self).assertEqual(x, y, message) - def check_jit_scriptable(self, nn_module, args, unwrapper=None, skip=False): - """ - Check that a nn.Module's results in TorchScript match eager and that it - can be exported - """ - if not TEST_WITH_SLOW or skip: - # TorchScript is not enabled, skip these tests - msg = "The check_jit_scriptable test for {} was skipped. " \ - "This test checks if the module's results in TorchScript " \ - "match eager and that it can be exported. To run these " \ - "tests make sure you set the environment variable " \ - "PYTORCH_TEST_WITH_SLOW=1 and that the test is not " \ - "manually skipped.".format(nn_module.__class__.__name__) - warnings.warn(msg, RuntimeWarning) - return None - - sm = torch.jit.script(nn_module) - - with freeze_rng_state(): - eager_out = nn_module(*args) - - with freeze_rng_state(): - script_out = sm(*args) - if unwrapper: - script_out = unwrapper(script_out) - - self.assertEqual(eager_out, script_out, prec=1e-4) - self.assertExportImportModule(sm, args) - - return sm - - def getExportImportCopy(self, m): - """ - Save and load a TorchScript model - """ - buffer = io.BytesIO() - torch.jit.save(m, buffer) - buffer.seek(0) - imported = torch.jit.load(buffer) - return imported - - def assertExportImportModule(self, m, args): - """ - Check that the results of a model are the same after saving and loading - """ - m_import = self.getExportImportCopy(m) - with freeze_rng_state(): - results = m(*args) - with freeze_rng_state(): - results_from_imported = m_import(*args) - self.assertEqual(results, results_from_imported, prec=3e-4) - @contextlib.contextmanager def freeze_rng_state(): diff --git a/test/test_models.py b/test/test_models.py index caca48224ba..3a335f6c3a6 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -1,5 +1,8 @@ +import os +import io import sys -from common_utils import TestCase, map_nested_tensor_object, freeze_rng_state, set_rng_seed, IN_CIRCLE_CI +from common_utils import TestCase, map_nested_tensor_object, freeze_rng_state, set_rng_seed +from _utils_internal import get_relative_path from collections import OrderedDict from itertools import product import functools @@ -13,6 +16,9 @@ import pytest +ACCEPT = os.getenv('EXPECTTEST_ACCEPT', '0') == '1' + + def get_available_classification_models(): # TODO add a registration mechanism to torchvision.models return [k for k, v in models.__dict__.items() if callable(v) and k[0].lower() == k[0] and k[0] != "_"] @@ -33,6 +39,103 @@ def get_available_video_models(): return [k for k, v in models.video.__dict__.items() if callable(v) and k[0].lower() == k[0] and k[0] != "_"] +def _get_expected_file(name=None): + # Determine expected file based on environment + expected_file_base = get_relative_path(os.path.realpath(__file__), "expect") + + # Note: for legacy reasons, the reference file names all had "ModelTest.test_" in their names + # We hardcode it here to avoid having to re-generate the reference files + expected_file = expected_file = os.path.join(expected_file_base, 'ModelTester.test_' + name) + expected_file += "_expect.pkl" + + if not ACCEPT and not os.path.exists(expected_file): + raise RuntimeError( + f"No expect file exists for {os.path.basename(expected_file)} in {expected_file}; " + "to accept the current output, re-run the failing test after setting the EXPECTTEST_ACCEPT " + "env variable. For example: EXPECTTEST_ACCEPT=1 pytest test/test_models.py -k alexnet" + ) + + return expected_file + + +def _assert_expected(output, name, prec): + """Test that a python value matches the recorded contents of a file + based on a "check" name. The value must be + pickable with `torch.save`. This file + is placed in the 'expect' directory in the same directory + as the test script. You can automatically update the recorded test + output using an EXPECTTEST_ACCEPT=1 env variable. + """ + expected_file = _get_expected_file(name) + + if ACCEPT: + filename = {os.path.basename(expected_file)} + print("Accepting updated output for {}:\n\n{}".format(filename, output)) + torch.save(output, expected_file) + MAX_PICKLE_SIZE = 50 * 1000 # 50 KB + binary_size = os.path.getsize(expected_file) + if binary_size > MAX_PICKLE_SIZE: + raise RuntimeError("The output for {}, is larger than 50kb".format(filename)) + else: + expected = torch.load(expected_file) + rtol = atol = prec + torch.testing.assert_close(output, expected, rtol=rtol, atol=atol, check_dtype=False) + + +def _check_jit_scriptable(nn_module, args, unwrapper=None, skip=False): + """Check that a nn.Module's results in TorchScript match eager and that it can be exported""" + + def assert_export_import_module(m, args): + """Check that the results of a model are the same after saving and loading""" + def get_export_import_copy(m): + """Save and load a TorchScript model""" + buffer = io.BytesIO() + torch.jit.save(m, buffer) + buffer.seek(0) + imported = torch.jit.load(buffer) + return imported + + m_import = get_export_import_copy(m) + with freeze_rng_state(): + results = m(*args) + with freeze_rng_state(): + results_from_imported = m_import(*args) + tol = 3e-4 + try: + torch.testing.assert_close(results, results_from_imported, atol=tol, rtol=tol) + except pytest.UsageError: + # custom check for the models that return named tuples: + # we compare field by field while ignoring None as assert_close can't handle None + for a, b in zip(results, results_from_imported): + if a is not None: + torch.testing.assert_close(a, b, atol=tol, rtol=tol) + + TEST_WITH_SLOW = os.getenv('PYTORCH_TEST_WITH_SLOW', '0') == '1' + if not TEST_WITH_SLOW or skip: + # TorchScript is not enabled, skip these tests + msg = "The check_jit_scriptable test for {} was skipped. " \ + "This test checks if the module's results in TorchScript " \ + "match eager and that it can be exported. To run these " \ + "tests make sure you set the environment variable " \ + "PYTORCH_TEST_WITH_SLOW=1 and that the test is not " \ + "manually skipped.".format(nn_module.__class__.__name__) + warnings.warn(msg, RuntimeWarning) + return None + + sm = torch.jit.script(nn_module) + + with freeze_rng_state(): + eager_out = nn_module(*args) + + with freeze_rng_state(): + script_out = sm(*args) + if unwrapper: + script_out = unwrapper(script_out) + + torch.testing.assert_close(eager_out, script_out, atol=1e-4, rtol=1e-4) + assert_export_import_module(sm, args) + + # If 'unwrapper' is provided it will be called with the script model outputs # before they are compared to the eager model outputs. This is useful if the # model outputs are different between TorchScript / Eager mode @@ -132,16 +235,16 @@ def _test_classification_model(self, name, dev): # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests x = torch.rand(input_shape).to(device=dev) out = model(x) - self.assertExpected(out.cpu(), name, prec=0.1) + _assert_expected(out.cpu(), name, prec=0.1) self.assertEqual(out.shape[-1], 50) - self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) if dev == torch.device("cuda"): with torch.cuda.amp.autocast(): out = model(x) # See autocast_flaky_numerics comment at top of file. if name not in autocast_flaky_numerics: - self.assertExpected(out.cpu(), name, prec=0.1) + _assert_expected(out.cpu(), name, prec=0.1) self.assertEqual(out.shape[-1], 50) def _test_segmentation_model(self, name, dev): @@ -166,12 +269,12 @@ def check_out(out): # We first try to assert the entire output if possible. This is not # only the best way to assert results but also handles the cases # where we need to create a new expected result. - self.assertExpected(out.cpu(), name, prec=prec) + _assert_expected(out.cpu(), name, prec=prec) except AssertionError: # Unfortunately some segmentation models are flaky with autocast # so instead of validating the probability scores, check that the class # predictions match. - expected_file = self._get_expected_file(name) + expected_file = _get_expected_file(name) expected = torch.load(expected_file) torch.testing.assert_close(out.argmax(dim=1), expected.argmax(dim=1), rtol=prec, atol=prec) return False # Partial validation performed @@ -180,7 +283,7 @@ def check_out(out): full_validation = check_out(out) - self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) if dev == torch.device("cuda"): with torch.cuda.amp.autocast(): @@ -248,13 +351,13 @@ def compute_mean_std(tensor): # We first try to assert the entire output if possible. This is not # only the best way to assert results but also handles the cases # where we need to create a new expected result. - self.assertExpected(output, name, prec=prec) + _assert_expected(output, name, prec=prec) except AssertionError: # Unfortunately detection models are flaky due to the unstable sort # in NMS. If matching across all outputs fails, use the same approach # as in NMSTester.test_nms_cuda to see if this is caused by duplicate # scores. - expected_file = self._get_expected_file(name) + expected_file = _get_expected_file(name) expected = torch.load(expected_file) torch.testing.assert_close(output[0]["scores"], expected[0]["scores"], rtol=prec, atol=prec, check_device=False, check_dtype=False) @@ -268,7 +371,7 @@ def compute_mean_std(tensor): return True # Full validation performed full_validation = check_out(out) - self.check_jit_scriptable(model, ([x],), unwrapper=script_model_unwrapper.get(name, None)) + _check_jit_scriptable(model, ([x],), unwrapper=script_model_unwrapper.get(name, None)) if dev == torch.device("cuda"): with torch.cuda.amp.autocast(): @@ -318,7 +421,7 @@ def _test_video_model(self, name, dev): # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests x = torch.rand(input_shape).to(device=dev) out = model(x) - self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) self.assertEqual(out.shape[-1], 50) if dev == torch.device("cuda"): @@ -398,7 +501,7 @@ def test_inception_v3_eval(self): model.AuxLogits = None model = model.eval() x = torch.rand(1, 3, 299, 299) - self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) def test_fasterrcnn_double(self): model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50, pretrained_backbone=False) @@ -427,7 +530,7 @@ def test_googlenet_eval(self): model.aux2 = None model = model.eval() x = torch.rand(1, 3, 224, 224) - self.check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) @unittest.skipIf(not torch.cuda.is_available(), 'needs GPU') def test_fasterrcnn_switch_devices(self): From f7b4cb0438702f67cf71cdd7dd8057fc377fb816 Mon Sep 17 00:00:00 2001 From: Drishti Bhasin <56479884+Dbhasin1@users.noreply.github.com> Date: Thu, 3 Jun 2021 19:52:07 +0530 Subject: [PATCH 131/279] Port test pad in test_transforms to pytest (#3954) --- test/test_transforms.py | 211 ++++++++++++++++++++-------------------- 1 file changed, 107 insertions(+), 104 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index d83b03c1911..6dd4dfc3830 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -403,110 +403,6 @@ def test_random_crop(self): with self.assertRaisesRegex(ValueError, r"Required crop size .+ is larger then input image size .+"): t(img) - def test_pad(self): - height = random.randint(10, 32) * 2 - width = random.randint(10, 32) * 2 - img = torch.ones(3, height, width) - padding = random.randint(1, 20) - fill = random.randint(1, 50) - result = transforms.Compose([ - transforms.ToPILImage(), - transforms.Pad(padding, fill=fill), - transforms.ToTensor(), - ])(img) - self.assertEqual(result.size(1), height + 2 * padding) - self.assertEqual(result.size(2), width + 2 * padding) - # check that all elements in the padded region correspond - # to the pad value - fill_v = fill / 255 - eps = 1e-5 - h_padded = result[:, :padding, :] - w_padded = result[:, :, :padding] - torch.testing.assert_close( - h_padded, torch.full_like(h_padded, fill_value=fill_v), check_stride=False, rtol=0.0, atol=eps - ) - torch.testing.assert_close( - w_padded, torch.full_like(w_padded, fill_value=fill_v), check_stride=False, rtol=0.0, atol=eps - ) - self.assertRaises(ValueError, transforms.Pad(padding, fill=(1, 2)), - transforms.ToPILImage()(img)) - - def test_pad_with_tuple_of_pad_values(self): - height = random.randint(10, 32) * 2 - width = random.randint(10, 32) * 2 - img = transforms.ToPILImage()(torch.ones(3, height, width)) - - padding = tuple([random.randint(1, 20) for _ in range(2)]) - output = transforms.Pad(padding)(img) - self.assertEqual(output.size, (width + padding[0] * 2, height + padding[1] * 2)) - - padding = tuple([random.randint(1, 20) for _ in range(4)]) - output = transforms.Pad(padding)(img) - self.assertEqual(output.size[0], width + padding[0] + padding[2]) - self.assertEqual(output.size[1], height + padding[1] + padding[3]) - - # Checking if Padding can be printed as string - transforms.Pad(padding).__repr__() - - def test_pad_with_non_constant_padding_modes(self): - """Unit tests for edge, reflect, symmetric padding""" - img = torch.zeros(3, 27, 27).byte() - img[:, :, 0] = 1 # Constant value added to leftmost edge - img = transforms.ToPILImage()(img) - img = F.pad(img, 1, (200, 200, 200)) - - # pad 3 to all sidess - edge_padded_img = F.pad(img, 3, padding_mode='edge') - # First 6 elements of leftmost edge in the middle of the image, values are in order: - # edge_pad, edge_pad, edge_pad, constant_pad, constant value added to leftmost edge, 0 - edge_middle_slice = np.asarray(edge_padded_img).transpose(2, 0, 1)[0][17][:6] - assert_equal(edge_middle_slice, np.asarray([200, 200, 200, 200, 1, 0], dtype=np.uint8), check_stride=False) - self.assertEqual(transforms.ToTensor()(edge_padded_img).size(), (3, 35, 35)) - - # Pad 3 to left/right, 2 to top/bottom - reflect_padded_img = F.pad(img, (3, 2), padding_mode='reflect') - # First 6 elements of leftmost edge in the middle of the image, values are in order: - # reflect_pad, reflect_pad, reflect_pad, constant_pad, constant value added to leftmost edge, 0 - reflect_middle_slice = np.asarray(reflect_padded_img).transpose(2, 0, 1)[0][17][:6] - assert_equal(reflect_middle_slice, np.asarray([0, 0, 1, 200, 1, 0], dtype=np.uint8), check_stride=False) - self.assertEqual(transforms.ToTensor()(reflect_padded_img).size(), (3, 33, 35)) - - # Pad 3 to left, 2 to top, 2 to right, 1 to bottom - symmetric_padded_img = F.pad(img, (3, 2, 2, 1), padding_mode='symmetric') - # First 6 elements of leftmost edge in the middle of the image, values are in order: - # sym_pad, sym_pad, sym_pad, constant_pad, constant value added to leftmost edge, 0 - symmetric_middle_slice = np.asarray(symmetric_padded_img).transpose(2, 0, 1)[0][17][:6] - assert_equal(symmetric_middle_slice, np.asarray([0, 1, 200, 200, 1, 0], dtype=np.uint8), check_stride=False) - self.assertEqual(transforms.ToTensor()(symmetric_padded_img).size(), (3, 32, 34)) - - # Check negative padding explicitly for symmetric case, since it is not - # implemented for tensor case to compare to - # Crop 1 to left, pad 2 to top, pad 3 to right, crop 3 to bottom - symmetric_padded_img_neg = F.pad(img, (-1, 2, 3, -3), padding_mode='symmetric') - symmetric_neg_middle_left = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][:3] - symmetric_neg_middle_right = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][-4:] - assert_equal(symmetric_neg_middle_left, np.asarray([1, 0, 0], dtype=np.uint8), check_stride=False) - assert_equal(symmetric_neg_middle_right, np.asarray([200, 200, 0, 0], dtype=np.uint8), check_stride=False) - self.assertEqual(transforms.ToTensor()(symmetric_padded_img_neg).size(), (3, 28, 31)) - - def test_pad_raises_with_invalid_pad_sequence_len(self): - with self.assertRaises(ValueError): - transforms.Pad(()) - - with self.assertRaises(ValueError): - transforms.Pad((1, 2, 3)) - - with self.assertRaises(ValueError): - transforms.Pad((1, 2, 3, 4, 5)) - - def test_pad_with_mode_F_images(self): - pad = 2 - transform = transforms.Pad(pad) - - img = Image.new("F", (10, 10)) - padded_img = transform(img) - self.assertSequenceEqual(padded_img.size, [edge_size + 2 * pad for edge_size in img.size]) - def test_lambda(self): trans = transforms.Lambda(lambda x: x.add(10)) x = torch.randn(10) @@ -1831,6 +1727,113 @@ def test_random_erasing(self): t.__repr__() +class TestPad: + + def test_pad(self): + height = random.randint(10, 32) * 2 + width = random.randint(10, 32) * 2 + img = torch.ones(3, height, width) + padding = random.randint(1, 20) + fill = random.randint(1, 50) + result = transforms.Compose([ + transforms.ToPILImage(), + transforms.Pad(padding, fill=fill), + transforms.ToTensor(), + ])(img) + assert result.size(1) == height + 2 * padding + assert result.size(2) == width + 2 * padding + # check that all elements in the padded region correspond + # to the pad value + fill_v = fill / 255 + eps = 1e-5 + h_padded = result[:, :padding, :] + w_padded = result[:, :, :padding] + torch.testing.assert_close( + h_padded, torch.full_like(h_padded, fill_value=fill_v), check_stride=False, rtol=0.0, atol=eps + ) + torch.testing.assert_close( + w_padded, torch.full_like(w_padded, fill_value=fill_v), check_stride=False, rtol=0.0, atol=eps + ) + pytest.raises(ValueError, transforms.Pad(padding, fill=(1, 2)), + transforms.ToPILImage()(img)) + + def test_pad_with_tuple_of_pad_values(self): + height = random.randint(10, 32) * 2 + width = random.randint(10, 32) * 2 + img = transforms.ToPILImage()(torch.ones(3, height, width)) + + padding = tuple([random.randint(1, 20) for _ in range(2)]) + output = transforms.Pad(padding)(img) + assert output.size == (width + padding[0] * 2, height + padding[1] * 2) + + padding = tuple([random.randint(1, 20) for _ in range(4)]) + output = transforms.Pad(padding)(img) + assert output.size[0] == width + padding[0] + padding[2] + assert output.size[1] == height + padding[1] + padding[3] + + # Checking if Padding can be printed as string + transforms.Pad(padding).__repr__() + + def test_pad_with_non_constant_padding_modes(self): + """Unit tests for edge, reflect, symmetric padding""" + img = torch.zeros(3, 27, 27).byte() + img[:, :, 0] = 1 # Constant value added to leftmost edge + img = transforms.ToPILImage()(img) + img = F.pad(img, 1, (200, 200, 200)) + + # pad 3 to all sidess + edge_padded_img = F.pad(img, 3, padding_mode='edge') + # First 6 elements of leftmost edge in the middle of the image, values are in order: + # edge_pad, edge_pad, edge_pad, constant_pad, constant value added to leftmost edge, 0 + edge_middle_slice = np.asarray(edge_padded_img).transpose(2, 0, 1)[0][17][:6] + assert_equal(edge_middle_slice, np.asarray([200, 200, 200, 200, 1, 0], dtype=np.uint8), check_stride=False) + assert transforms.ToTensor()(edge_padded_img).size() == (3, 35, 35) + + # Pad 3 to left/right, 2 to top/bottom + reflect_padded_img = F.pad(img, (3, 2), padding_mode='reflect') + # First 6 elements of leftmost edge in the middle of the image, values are in order: + # reflect_pad, reflect_pad, reflect_pad, constant_pad, constant value added to leftmost edge, 0 + reflect_middle_slice = np.asarray(reflect_padded_img).transpose(2, 0, 1)[0][17][:6] + assert_equal(reflect_middle_slice, np.asarray([0, 0, 1, 200, 1, 0], dtype=np.uint8), check_stride=False) + assert transforms.ToTensor()(reflect_padded_img).size() == (3, 33, 35) + + # Pad 3 to left, 2 to top, 2 to right, 1 to bottom + symmetric_padded_img = F.pad(img, (3, 2, 2, 1), padding_mode='symmetric') + # First 6 elements of leftmost edge in the middle of the image, values are in order: + # sym_pad, sym_pad, sym_pad, constant_pad, constant value added to leftmost edge, 0 + symmetric_middle_slice = np.asarray(symmetric_padded_img).transpose(2, 0, 1)[0][17][:6] + assert_equal(symmetric_middle_slice, np.asarray([0, 1, 200, 200, 1, 0], dtype=np.uint8), check_stride=False) + assert transforms.ToTensor()(symmetric_padded_img).size() == (3, 32, 34) + + # Check negative padding explicitly for symmetric case, since it is not + # implemented for tensor case to compare to + # Crop 1 to left, pad 2 to top, pad 3 to right, crop 3 to bottom + symmetric_padded_img_neg = F.pad(img, (-1, 2, 3, -3), padding_mode='symmetric') + symmetric_neg_middle_left = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][:3] + symmetric_neg_middle_right = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][-4:] + assert_equal(symmetric_neg_middle_left, np.asarray([1, 0, 0], dtype=np.uint8), check_stride=False) + assert_equal(symmetric_neg_middle_right, np.asarray([200, 200, 0, 0], dtype=np.uint8), check_stride=False) + assert transforms.ToTensor()(symmetric_padded_img_neg).size() == (3, 28, 31) + + def test_pad_raises_with_invalid_pad_sequence_len(self): + with pytest.raises(ValueError): + transforms.Pad(()) + + with pytest.raises(ValueError): + transforms.Pad((1, 2, 3)) + + with pytest.raises(ValueError): + transforms.Pad((1, 2, 3, 4, 5)) + + def test_pad_with_mode_F_images(self): + pad = 2 + transform = transforms.Pad(pad) + + img = Image.new("F", (10, 10)) + padded_img = transform(img) + assert_equal(padded_img.size, [edge_size + 2 * pad for edge_size in img.size], check_stride=False) + + def test_adjust_brightness(): x_shape = [2, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] From 2a52c2dca73513d0d0c3e2a505aed05e5b9aa792 Mon Sep 17 00:00:00 2001 From: Shrill Shrestha <43284212+ShrillShrestha@users.noreply.github.com> Date: Thu, 3 Jun 2021 11:25:31 -0500 Subject: [PATCH 132/279] Port test_randomness in test_transforms.py to pytest (#3955) --- test/test_transforms.py | 100 ++++++++++++---------------------------- 1 file changed, 30 insertions(+), 70 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index 6dd4dfc3830..33d81c657da 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -1621,76 +1621,6 @@ def test_gaussian_blur_asserts(self): with self.assertRaisesRegex(ValueError, r"sigma should be a single number or a list/tuple with length 2"): transforms.GaussianBlur(3, "sigma_string") - def _test_randomness(self, fn, trans, configs): - random_state = random.getstate() - random.seed(42) - img = transforms.ToPILImage()(torch.rand(3, 16, 18)) - - for p in [0.5, 0.7]: - for config in configs: - inv_img = fn(img, **config) - - num_samples = 250 - counts = 0 - for _ in range(num_samples): - tranformation = trans(p=p, **config) - tranformation.__repr__() - out = tranformation(img) - if out == inv_img: - counts += 1 - - p_value = stats.binom_test(counts, num_samples, p=p) - random.setstate(random_state) - self.assertGreater(p_value, 0.0001) - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_invert(self): - self._test_randomness( - F.invert, - transforms.RandomInvert, - [{}] - ) - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_posterize(self): - self._test_randomness( - F.posterize, - transforms.RandomPosterize, - [{"bits": 4}] - ) - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_solarize(self): - self._test_randomness( - F.solarize, - transforms.RandomSolarize, - [{"threshold": 192}] - ) - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_adjust_sharpness(self): - self._test_randomness( - F.adjust_sharpness, - transforms.RandomAdjustSharpness, - [{"sharpness_factor": 2.0}] - ) - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_autocontrast(self): - self._test_randomness( - F.autocontrast, - transforms.RandomAutocontrast, - [{}] - ) - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_equalize(self): - self._test_randomness( - F.equalize, - transforms.RandomEqualize, - [{}] - ) - def test_autoaugment(self): for policy in transforms.AutoAugmentPolicy: for fill in [None, 85, (128, 128, 128)]: @@ -1834,6 +1764,36 @@ def test_pad_with_mode_F_images(self): assert_equal(padded_img.size, [edge_size + 2 * pad for edge_size in img.size], check_stride=False) +@pytest.mark.skipif(stats is None, reason="scipy.stats not available") +@pytest.mark.parametrize('fn, trans, config', [ + (F.invert, transforms.RandomInvert, {}), + (F.posterize, transforms.RandomPosterize, {"bits": 4}), + (F.solarize, transforms.RandomSolarize, {"threshold": 192}), + (F.adjust_sharpness, transforms.RandomAdjustSharpness, {"sharpness_factor": 2.0}), + (F.autocontrast, transforms.RandomAutocontrast, {}), + (F.equalize, transforms.RandomEqualize, {})]) +@pytest.mark.parametrize('p', (.5, .7)) +def test_randomness(fn, trans, config, p): + random_state = random.getstate() + random.seed(42) + img = transforms.ToPILImage()(torch.rand(3, 16, 18)) + + inv_img = fn(img, **config) + + num_samples = 250 + counts = 0 + for _ in range(num_samples): + tranformation = trans(p=p, **config) + tranformation.__repr__() + out = tranformation(img) + if out == inv_img: + counts += 1 + + p_value = stats.binom_test(counts, num_samples, p=p) + random.setstate(random_state) + assert p_value > 0.0001 + + def test_adjust_brightness(): x_shape = [2, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] From a0cd96ff95bf73d174f42a57c0739af33530cd76 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 4 Jun 2021 09:03:55 +0100 Subject: [PATCH 133/279] Port test_ops.py to pytest (#3953) --- test/test_ops.py | 416 +++++++++++++++++++++++------------------------ 1 file changed, 208 insertions(+), 208 deletions(-) diff --git a/test/test_ops.py b/test/test_ops.py index 934daeedc58..f08720206ad 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -1,7 +1,7 @@ -from common_utils import needs_cuda, cpu_only +from common_utils import needs_cuda, cpu_only, cpu_and_gpu from _assert_utils import assert_equal import math -import unittest +from abc import ABC, abstractmethod import pytest import numpy as np @@ -15,48 +15,12 @@ from typing import Tuple -class OpTester(object): - @classmethod - def setUpClass(cls): - cls.dtype = torch.float64 +class RoIOpTester(ABC): + dtype = torch.float64 - def test_forward_cpu_contiguous(self): - self._test_forward(device=torch.device('cpu'), contiguous=True) - - def test_forward_cpu_non_contiguous(self): - self._test_forward(device=torch.device('cpu'), contiguous=False) - - def test_backward_cpu_contiguous(self): - self._test_backward(device=torch.device('cpu'), contiguous=True) - - def test_backward_cpu_non_contiguous(self): - self._test_backward(device=torch.device('cpu'), contiguous=False) - - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") - def test_forward_cuda_contiguous(self): - self._test_forward(device=torch.device('cuda'), contiguous=True) - - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") - def test_forward_cuda_non_contiguous(self): - self._test_forward(device=torch.device('cuda'), contiguous=False) - - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") - def test_backward_cuda_contiguous(self): - self._test_backward(device=torch.device('cuda'), contiguous=True) - - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") - def test_backward_cuda_non_contiguous(self): - self._test_backward(device=torch.device('cuda'), contiguous=False) - - def _test_forward(self, device, contiguous): - pass - - def _test_backward(self, device, contiguous): - pass - - -class RoIOpTester(OpTester): - def _test_forward(self, device, contiguous, x_dtype=None, rois_dtype=None, **kwargs): + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('contiguous', (True, False)) + def test_forward(self, device, contiguous, x_dtype=None, rois_dtype=None, **kwargs): x_dtype = self.dtype if x_dtype is None else x_dtype rois_dtype = self.dtype if rois_dtype is None else rois_dtype pool_size = 5 @@ -74,14 +38,16 @@ def _test_forward(self, device, contiguous, x_dtype=None, rois_dtype=None, **kwa pool_h, pool_w = pool_size, pool_size y = self.fn(x, rois, pool_h, pool_w, spatial_scale=1, sampling_ratio=-1, **kwargs) # the following should be true whether we're running an autocast test or not. - self.assertTrue(y.dtype == x.dtype) + assert y.dtype == x.dtype gt_y = self.expected_fn(x, rois, pool_h, pool_w, spatial_scale=1, sampling_ratio=-1, device=device, dtype=self.dtype, **kwargs) tol = 1e-3 if (x_dtype is torch.half or rois_dtype is torch.half) else 1e-5 torch.testing.assert_close(gt_y.to(y), y, rtol=tol, atol=tol) - def _test_backward(self, device, contiguous): + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('contiguous', (True, False)) + def test_backward(self, device, contiguous): pool_size = 2 x = torch.rand(1, 2 * (pool_size ** 2), 5, 5, dtype=self.dtype, device=device, requires_grad=True) if not contiguous: @@ -96,43 +62,43 @@ def func(z): script_func = self.get_script_fn(rois, pool_size) - self.assertTrue(gradcheck(func, (x,))) - self.assertTrue(gradcheck(script_func, (x,))) + gradcheck(func, (x,)) + gradcheck(script_func, (x,)) - def test_boxes_shape(self): - self._test_boxes_shape() + @needs_cuda + @pytest.mark.parametrize('x_dtype', (torch.float, torch.half)) + @pytest.mark.parametrize('rois_dtype', (torch.float, torch.half)) + def test_autocast(self, x_dtype, rois_dtype): + with torch.cuda.amp.autocast(): + self.test_forward(torch.device("cuda"), contiguous=False, x_dtype=x_dtype, rois_dtype=rois_dtype) def _helper_boxes_shape(self, func): # test boxes as Tensor[N, 5] - with self.assertRaises(AssertionError): + with pytest.raises(AssertionError): a = torch.linspace(1, 8 * 8, 8 * 8).reshape(1, 1, 8, 8) boxes = torch.tensor([[0, 0, 3, 3]], dtype=a.dtype) func(a, boxes, output_size=(2, 2)) # test boxes as List[Tensor[N, 4]] - with self.assertRaises(AssertionError): + with pytest.raises(AssertionError): a = torch.linspace(1, 8 * 8, 8 * 8).reshape(1, 1, 8, 8) boxes = torch.tensor([[0, 0, 3]], dtype=a.dtype) ops.roi_pool(a, [boxes], output_size=(2, 2)) + @abstractmethod def fn(*args, **kwargs): pass + @abstractmethod def get_script_fn(*args, **kwargs): pass + @abstractmethod def expected_fn(*args, **kwargs): pass - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") - def test_autocast(self): - for x_dtype in (torch.float, torch.half): - for rois_dtype in (torch.float, torch.half): - with torch.cuda.amp.autocast(): - self._test_forward(torch.device("cuda"), contiguous=False, x_dtype=x_dtype, rois_dtype=rois_dtype) - -class RoIPoolTester(RoIOpTester, unittest.TestCase): +class TestRoiPool(RoIOpTester): def fn(self, x, rois, pool_h, pool_w, spatial_scale=1, sampling_ratio=-1, **kwargs): return ops.RoIPool((pool_h, pool_w), spatial_scale)(x, rois) @@ -167,11 +133,12 @@ def get_slice(k, block): y[roi_idx, :, i, j] = bin_x.reshape(n_channels, -1).max(dim=1)[0] return y - def _test_boxes_shape(self): + @cpu_only + def test_boxes_shape(self): self._helper_boxes_shape(ops.roi_pool) -class PSRoIPoolTester(RoIOpTester, unittest.TestCase): +class TestPSRoIPool(RoIOpTester): def fn(self, x, rois, pool_h, pool_w, spatial_scale=1, sampling_ratio=-1, **kwargs): return ops.PSRoIPool((pool_h, pool_w), 1)(x, rois) @@ -184,7 +151,7 @@ def expected_fn(self, x, rois, pool_h, pool_w, spatial_scale=1, sampling_ratio=- if device is None: device = torch.device("cpu") n_input_channels = x.size(1) - self.assertEqual(n_input_channels % (pool_h * pool_w), 0, "input channels must be divisible by ph * pw") + assert n_input_channels % (pool_h * pool_w) == 0, "input channels must be divisible by ph * pw" n_output_channels = int(n_input_channels / (pool_h * pool_w)) y = torch.zeros(rois.size(0), n_output_channels, pool_h, pool_w, dtype=dtype, device=device) @@ -211,7 +178,8 @@ def get_slice(k, block): y[roi_idx, c_out, i, j] = t / area return y - def _test_boxes_shape(self): + @cpu_only + def test_boxes_shape(self): self._helper_boxes_shape(ops.ps_roi_pool) @@ -247,7 +215,7 @@ def bilinear_interpolate(data, y, x, snap_border=False): return val -class RoIAlignTester(RoIOpTester, unittest.TestCase): +class TestRoIAlign(RoIOpTester): def fn(self, x, rois, pool_h, pool_w, spatial_scale=1, sampling_ratio=-1, aligned=False, **kwargs): return ops.RoIAlign((pool_h, pool_w), spatial_scale=spatial_scale, sampling_ratio=sampling_ratio, aligned=aligned)(x, rois) @@ -294,14 +262,36 @@ def expected_fn(self, in_data, rois, pool_h, pool_w, spatial_scale=1, sampling_r out_data[r, channel, i, j] = val return out_data - def _test_boxes_shape(self): + @cpu_only + def test_boxes_shape(self): self._helper_boxes_shape(ops.roi_align) - def _test_forward(self, device, contiguous, x_dtype=None, rois_dtype=None, **kwargs): - for aligned in (True, False): - super()._test_forward(device, contiguous, x_dtype, rois_dtype, aligned=aligned) + @pytest.mark.parametrize('aligned', (True, False)) + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('contiguous', (True, False)) + def test_forward(self, device, contiguous, aligned, x_dtype=None, rois_dtype=None): + super().test_forward(device=device, contiguous=contiguous, x_dtype=x_dtype, rois_dtype=rois_dtype, + aligned=aligned) - def test_qroialign(self): + @needs_cuda + @pytest.mark.parametrize('aligned', (True, False)) + @pytest.mark.parametrize('x_dtype', (torch.float, torch.half)) + @pytest.mark.parametrize('rois_dtype', (torch.float, torch.half)) + def test_autocast(self, aligned, x_dtype, rois_dtype): + with torch.cuda.amp.autocast(): + self.test_forward(torch.device("cuda"), contiguous=False, aligned=aligned, x_dtype=x_dtype, + rois_dtype=rois_dtype) + + def _make_rois(self, img_size, num_imgs, dtype, num_rois=1000): + rois = torch.randint(0, img_size // 2, size=(num_rois, 5)).to(dtype) + rois[:, 0] = torch.randint(0, num_imgs, size=(num_rois,)) # set batch index + rois[:, 3:] += rois[:, 1:3] # make sure boxes aren't degenerate + return rois + + @pytest.mark.parametrize('aligned', (True, False)) + @pytest.mark.parametrize('scale, zero_point', ((1, 0), (2, 10), (0.1, 50))) + @pytest.mark.parametrize('qdtype', (torch.qint8, torch.quint8, torch.qint32)) + def test_qroialign(self, aligned, scale, zero_point, qdtype): """Make sure quantized version of RoIAlign is close to float version""" pool_size = 5 img_size = 10 @@ -309,72 +299,64 @@ def test_qroialign(self): num_imgs = 1 dtype = torch.float - def make_rois(num_rois=1000): - rois = torch.randint(0, img_size // 2, size=(num_rois, 5)).to(dtype) - rois[:, 0] = torch.randint(0, num_imgs, size=(num_rois,)) # set batch index - rois[:, 3:] += rois[:, 1:3] # make sure boxes aren't degenerate - return rois - - for aligned in (True, False): - for scale, zero_point in ((1, 0), (2, 10), (0.1, 50)): - for qdtype in (torch.qint8, torch.quint8, torch.qint32): - - x = torch.randint(50, 100, size=(num_imgs, n_channels, img_size, img_size)).to(dtype) - qx = torch.quantize_per_tensor(x, scale=scale, zero_point=zero_point, dtype=qdtype) - - rois = make_rois() - qrois = torch.quantize_per_tensor(rois, scale=scale, zero_point=zero_point, dtype=qdtype) - - x, rois = qx.dequantize(), qrois.dequantize() # we want to pass the same inputs - - y = ops.roi_align( - x, - rois, - output_size=pool_size, - spatial_scale=1, - sampling_ratio=-1, - aligned=aligned, - ) - qy = ops.roi_align( - qx, - qrois, - output_size=pool_size, - spatial_scale=1, - sampling_ratio=-1, - aligned=aligned, - ) - - # The output qy is itself a quantized tensor and there might have been a loss of info when it was - # quantized. For a fair comparison we need to quantize y as well - quantized_float_y = torch.quantize_per_tensor(y, scale=scale, zero_point=zero_point, dtype=qdtype) - - try: - # Ideally, we would assert this, which passes with (scale, zero) == (1, 0) - self.assertTrue((qy == quantized_float_y).all()) - except AssertionError: - # But because the computation aren't exactly the same between the 2 RoIAlign procedures, some - # rounding error may lead to a difference of 2 in the output. - # For example with (scale, zero) = (2, 10), 45.00000... will be quantized to 44 - # but 45.00000001 will be rounded to 46. We make sure below that: - # - such discrepancies between qy and quantized_float_y are very rare (less then 5%) - # - any difference between qy and quantized_float_y is == scale - diff_idx = torch.where(qy != quantized_float_y) - num_diff = diff_idx[0].numel() - self.assertTrue(num_diff / qy.numel() < .05) - - abs_diff = torch.abs(qy[diff_idx].dequantize() - quantized_float_y[diff_idx].dequantize()) - t_scale = torch.full_like(abs_diff, fill_value=scale) - torch.testing.assert_close(abs_diff, t_scale, rtol=1e-5, atol=1e-5) + x = torch.randint(50, 100, size=(num_imgs, n_channels, img_size, img_size)).to(dtype) + qx = torch.quantize_per_tensor(x, scale=scale, zero_point=zero_point, dtype=qdtype) + + rois = self._make_rois(img_size, num_imgs, dtype) + qrois = torch.quantize_per_tensor(rois, scale=scale, zero_point=zero_point, dtype=qdtype) + + x, rois = qx.dequantize(), qrois.dequantize() # we want to pass the same inputs + y = ops.roi_align( + x, + rois, + output_size=pool_size, + spatial_scale=1, + sampling_ratio=-1, + aligned=aligned, + ) + qy = ops.roi_align( + qx, + qrois, + output_size=pool_size, + spatial_scale=1, + sampling_ratio=-1, + aligned=aligned, + ) + + # The output qy is itself a quantized tensor and there might have been a loss of info when it was + # quantized. For a fair comparison we need to quantize y as well + quantized_float_y = torch.quantize_per_tensor(y, scale=scale, zero_point=zero_point, dtype=qdtype) + + try: + # Ideally, we would assert this, which passes with (scale, zero) == (1, 0) + assert (qy == quantized_float_y).all() + except AssertionError: + # But because the computation aren't exactly the same between the 2 RoIAlign procedures, some + # rounding error may lead to a difference of 2 in the output. + # For example with (scale, zero) = (2, 10), 45.00000... will be quantized to 44 + # but 45.00000001 will be rounded to 46. We make sure below that: + # - such discrepancies between qy and quantized_float_y are very rare (less then 5%) + # - any difference between qy and quantized_float_y is == scale + diff_idx = torch.where(qy != quantized_float_y) + num_diff = diff_idx[0].numel() + assert num_diff / qy.numel() < .05 + + abs_diff = torch.abs(qy[diff_idx].dequantize() - quantized_float_y[diff_idx].dequantize()) + t_scale = torch.full_like(abs_diff, fill_value=scale) + torch.testing.assert_close(abs_diff, t_scale, rtol=1e-5, atol=1e-5) + + def test_qroi_align_multiple_images(self): + dtype = torch.float x = torch.randint(50, 100, size=(2, 3, 10, 10)).to(dtype) qx = torch.quantize_per_tensor(x, scale=1, zero_point=0, dtype=torch.qint8) - rois = make_rois(10) + rois = self._make_rois(img_size=10, num_imgs=2, dtype=dtype, num_rois=10) qrois = torch.quantize_per_tensor(rois, scale=1, zero_point=0, dtype=torch.qint8) - with self.assertRaisesRegex(RuntimeError, "Only one image per batch is allowed"): - ops.roi_align(qx, qrois, output_size=pool_size) + with pytest.raises(RuntimeError, match="Only one image per batch is allowed"): + ops.roi_align(qx, qrois, output_size=5) -class PSRoIAlignTester(RoIOpTester, unittest.TestCase): +class TestPSRoIAlign(RoIOpTester): def fn(self, x, rois, pool_h, pool_w, spatial_scale=1, sampling_ratio=-1, **kwargs): return ops.PSRoIAlign((pool_h, pool_w), spatial_scale=spatial_scale, sampling_ratio=sampling_ratio)(x, rois) @@ -388,7 +370,7 @@ def expected_fn(self, in_data, rois, pool_h, pool_w, device, spatial_scale=1, if device is None: device = torch.device("cpu") n_input_channels = in_data.size(1) - self.assertEqual(n_input_channels % (pool_h * pool_w), 0, "input channels must be divisible by ph * pw") + assert n_input_channels % (pool_h * pool_w) == 0, "input channels must be divisible by ph * pw" n_output_channels = int(n_input_channels / (pool_h * pool_w)) out_data = torch.zeros(rois.size(0), n_output_channels, pool_h, pool_w, dtype=dtype, device=device) @@ -421,11 +403,13 @@ def expected_fn(self, in_data, rois, pool_h, pool_w, device, spatial_scale=1, out_data[r, c_out, i, j] = val return out_data - def _test_boxes_shape(self): + @cpu_only + def test_boxes_shape(self): self._helper_boxes_shape(ops.ps_roi_align) -class MultiScaleRoIAlignTester(unittest.TestCase): +@cpu_only +class TestMultiScaleRoIAlign: def test_msroialign_repr(self): fmap_names = ['0'] output_size = (7, 7) @@ -436,7 +420,7 @@ def test_msroialign_repr(self): # Check integrity of object __repr__ attribute expected_string = (f"MultiScaleRoIAlign(featmap_names={fmap_names}, output_size={output_size}, " f"sampling_ratio={sampling_ratio})") - self.assertEqual(t.__repr__(), expected_string) + assert repr(t) == expected_string class TestNMS: @@ -583,7 +567,9 @@ def test_batched_nms_implementations(self): torch.testing.assert_close(empty, ops.batched_nms(empty, None, None, None)) -class DeformConvTester(OpTester, unittest.TestCase): +class TestDeformConv: + dtype = torch.float64 + def expected_fn(self, x, weight, offset, mask, bias, stride=1, padding=0, dilation=1): stride_h, stride_w = _pair(stride) pad_h, pad_w = _pair(padding) @@ -671,12 +657,11 @@ def get_fn_args(self, device, contiguous, batch_sz, dtype): return x, weight, offset, mask, bias, stride, pad, dilation - def _test_forward(self, device, contiguous, dtype=None): - dtype = self.dtype if dtype is None else dtype - for batch_sz in [0, 33]: - self._test_forward_with_batchsize(device, contiguous, batch_sz, dtype) - - def _test_forward_with_batchsize(self, device, contiguous, batch_sz, dtype): + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('contiguous', (True, False)) + @pytest.mark.parametrize('batch_sz', (0, 33)) + def test_forward(self, device, contiguous, batch_sz, dtype=None): + dtype = dtype or self.dtype x, _, offset, mask, _, stride, padding, dilation = self.get_fn_args(device, contiguous, batch_sz, dtype) in_channels = 6 out_channels = 2 @@ -704,20 +689,28 @@ def _test_forward_with_batchsize(self, device, contiguous, batch_sz, dtype): res.to(expected), expected, rtol=tol, atol=tol, msg='\nres:\n{}\nexpected:\n{}'.format(res, expected) ) - # test for wrong sizes - with self.assertRaises(RuntimeError): + @cpu_only + def test_wrong_sizes(self): + in_channels = 6 + out_channels = 2 + kernel_size = (3, 2) + groups = 2 + x, _, offset, mask, _, stride, padding, dilation = self.get_fn_args('cpu', contiguous=True, + batch_sz=10, dtype=self.dtype) + layer = ops.DeformConv2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, + dilation=dilation, groups=groups) + with pytest.raises(RuntimeError, match="the shape of the offset"): wrong_offset = torch.rand_like(offset[:, :2]) - res = layer(x, wrong_offset) + layer(x, wrong_offset) - with self.assertRaises(RuntimeError): + with pytest.raises(RuntimeError, match=r'mask.shape\[1\] is not valid'): wrong_mask = torch.rand_like(mask[:, :2]) - res = layer(x, offset, wrong_mask) + layer(x, offset, wrong_mask) - def _test_backward(self, device, contiguous): - for batch_sz in [0, 33]: - self._test_backward_with_batchsize(device, contiguous, batch_sz) - - def _test_backward_with_batchsize(self, device, contiguous, batch_sz): + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('contiguous', (True, False)) + @pytest.mark.parametrize('batch_sz', (0, 33)) + def test_backward(self, device, contiguous, batch_sz): x, weight, offset, mask, bias, stride, padding, dilation = self.get_fn_args(device, contiguous, batch_sz, self.dtype) @@ -751,47 +744,50 @@ def script_func_no_mask(x_, offset_, weight_, bias_, stride_, pad_, dilation_): gradcheck(lambda z, off, wei, bi: script_func_no_mask(z, off, wei, bi, stride, padding, dilation), (x, offset, weight, bias), nondet_tol=1e-5, fast_mode=True) - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") - def test_compare_cpu_cuda_grads(self): + @needs_cuda + @pytest.mark.parametrize('contiguous', (True, False)) + def test_compare_cpu_cuda_grads(self, contiguous): # Test from https://github.com/pytorch/vision/issues/2598 # Run on CUDA only - for contiguous in [False, True]: - # compare grads computed on CUDA with grads computed on CPU - true_cpu_grads = None - - init_weight = torch.randn(9, 9, 3, 3, requires_grad=True) - img = torch.randn(8, 9, 1000, 110) - offset = torch.rand(8, 2 * 3 * 3, 1000, 110) - mask = torch.rand(8, 3 * 3, 1000, 110) - - if not contiguous: - img = img.permute(0, 1, 3, 2).contiguous().permute(0, 1, 3, 2) - offset = offset.permute(1, 3, 0, 2).contiguous().permute(2, 0, 3, 1) - mask = mask.permute(1, 3, 0, 2).contiguous().permute(2, 0, 3, 1) - weight = init_weight.permute(3, 2, 0, 1).contiguous().permute(2, 3, 1, 0) - else: - weight = init_weight - for d in ["cpu", "cuda"]: + # compare grads computed on CUDA with grads computed on CPU + true_cpu_grads = None - out = ops.deform_conv2d(img.to(d), offset.to(d), weight.to(d), padding=1, mask=mask.to(d)) - out.mean().backward() - if true_cpu_grads is None: - true_cpu_grads = init_weight.grad - self.assertTrue(true_cpu_grads is not None) - else: - self.assertTrue(init_weight.grad is not None) - res_grads = init_weight.grad.to("cpu") - torch.testing.assert_close(true_cpu_grads, res_grads) + init_weight = torch.randn(9, 9, 3, 3, requires_grad=True) + img = torch.randn(8, 9, 1000, 110) + offset = torch.rand(8, 2 * 3 * 3, 1000, 110) + mask = torch.rand(8, 3 * 3, 1000, 110) - @unittest.skipIf(not torch.cuda.is_available(), "CUDA unavailable") - def test_autocast(self): - for dtype in (torch.float, torch.half): - with torch.cuda.amp.autocast(): - self._test_forward(torch.device("cuda"), False, dtype=dtype) + if not contiguous: + img = img.permute(0, 1, 3, 2).contiguous().permute(0, 1, 3, 2) + offset = offset.permute(1, 3, 0, 2).contiguous().permute(2, 0, 3, 1) + mask = mask.permute(1, 3, 0, 2).contiguous().permute(2, 0, 3, 1) + weight = init_weight.permute(3, 2, 0, 1).contiguous().permute(2, 3, 1, 0) + else: + weight = init_weight + for d in ["cpu", "cuda"]: -class FrozenBNTester(unittest.TestCase): + out = ops.deform_conv2d(img.to(d), offset.to(d), weight.to(d), padding=1, mask=mask.to(d)) + out.mean().backward() + if true_cpu_grads is None: + true_cpu_grads = init_weight.grad + assert true_cpu_grads is not None + else: + assert init_weight.grad is not None + res_grads = init_weight.grad.to("cpu") + torch.testing.assert_close(true_cpu_grads, res_grads) + + @needs_cuda + @pytest.mark.parametrize('batch_sz', (0, 33)) + @pytest.mark.parametrize('dtype', (torch.float, torch.half)) + def test_autocast(self, batch_sz, dtype): + with torch.cuda.amp.autocast(): + self.test_forward(torch.device("cuda"), contiguous=False, batch_sz=batch_sz, dtype=dtype) + + +@cpu_only +class TestFrozenBNT: def test_frozenbatchnorm2d_repr(self): num_features = 32 eps = 1e-5 @@ -799,7 +795,7 @@ def test_frozenbatchnorm2d_repr(self): # Check integrity of object __repr__ attribute expected_string = f"FrozenBatchNorm2d({num_features}, eps={eps})" - self.assertEqual(t.__repr__(), expected_string) + assert repr(t) == expected_string def test_frozenbatchnorm2d_eps(self): sample_size = (4, 32, 28, 28) @@ -828,11 +824,12 @@ def test_frozenbatchnorm2d_eps(self): def test_frozenbatchnorm2d_n_arg(self): """Ensure a warning is thrown when passing `n` kwarg (remove this when support of `n` is dropped)""" - self.assertWarns(DeprecationWarning, ops.misc.FrozenBatchNorm2d, 32, eps=1e-5, n=32) + with pytest.warns(DeprecationWarning): + ops.misc.FrozenBatchNorm2d(32, eps=1e-5, n=32) -class BoxConversionTester(unittest.TestCase): - @staticmethod +@cpu_only +class TestBoxConversion: def _get_box_sequences(): # Define here the argument type of `boxes` supported by region pooling operations box_tensor = torch.tensor([[0, 0, 0, 100, 100], [1, 0, 0, 100, 100]], dtype=torch.float) @@ -841,22 +838,23 @@ def _get_box_sequences(): box_tuple = tuple(box_list) return box_tensor, box_list, box_tuple - def test_check_roi_boxes_shape(self): + @pytest.mark.parametrize('box_sequence', _get_box_sequences()) + def test_check_roi_boxes_shape(self, box_sequence): # Ensure common sequences of tensors are supported - for box_sequence in self._get_box_sequences(): - self.assertIsNone(ops._utils.check_roi_boxes_shape(box_sequence)) + ops._utils.check_roi_boxes_shape(box_sequence) - def test_convert_boxes_to_roi_format(self): + @pytest.mark.parametrize('box_sequence', _get_box_sequences()) + def test_convert_boxes_to_roi_format(self, box_sequence): # Ensure common sequences of tensors yield the same result ref_tensor = None - for box_sequence in self._get_box_sequences(): - if ref_tensor is None: - ref_tensor = box_sequence - else: - self.assertTrue(torch.equal(ref_tensor, ops._utils.convert_boxes_to_roi_format(box_sequence))) + if ref_tensor is None: + ref_tensor = box_sequence + else: + assert_equal(ref_tensor, ops._utils.convert_boxes_to_roi_format(box_sequence)) -class BoxTester(unittest.TestCase): +@cpu_only +class TestBox: def test_bbox_same(self): box_tensor = torch.tensor([[0, 0, 100, 100], [0, 0, 0, 0], [10, 15, 30, 35], [23, 35, 93, 95]], dtype=torch.float) @@ -917,15 +915,14 @@ def test_bbox_xywh_cxcywh(self): box_xywh = ops.box_convert(box_cxcywh, in_fmt="cxcywh", out_fmt="xywh") assert_equal(box_xywh, box_tensor) - def test_bbox_invalid(self): + @pytest.mark.parametrize('inv_infmt', ["xwyh", "cxwyh"]) + @pytest.mark.parametrize('inv_outfmt', ["xwcx", "xhwcy"]) + def test_bbox_invalid(self, inv_infmt, inv_outfmt): box_tensor = torch.tensor([[0, 0, 100, 100], [0, 0, 0, 0], [10, 15, 20, 20], [23, 35, 70, 60]], dtype=torch.float) - invalid_infmts = ["xwyh", "cxwyh"] - invalid_outfmts = ["xwcx", "xhwcy"] - for inv_infmt in invalid_infmts: - for inv_outfmt in invalid_outfmts: - self.assertRaises(ValueError, ops.box_convert, box_tensor, inv_infmt, inv_outfmt) + with pytest.raises(ValueError): + ops.box_convert(box_tensor, inv_infmt, inv_outfmt) def test_bbox_convert_jit(self): box_tensor = torch.tensor([[0, 0, 100, 100], [0, 0, 0, 0], @@ -943,7 +940,8 @@ def test_bbox_convert_jit(self): torch.testing.assert_close(scripted_cxcywh, box_cxcywh, rtol=0.0, atol=TOLERANCE) -class BoxAreaTester(unittest.TestCase): +@cpu_only +class TestBoxArea: def test_box_area(self): def area_check(box, expected, tolerance=1e-4): out = ops.box_area(box) @@ -971,7 +969,8 @@ def area_check(box, expected, tolerance=1e-4): area_check(box_tensor, expected) -class BoxIouTester(unittest.TestCase): +@cpu_only +class TestBoxIou: def test_iou(self): def iou_check(box, expected, tolerance=1e-4): out = ops.box_iou(box, box) @@ -992,7 +991,8 @@ def iou_check(box, expected, tolerance=1e-4): iou_check(box_tensor, expected, tolerance=0.002 if dtype == torch.float16 else 1e-4) -class GenBoxIouTester(unittest.TestCase): +@cpu_only +class TestGenBoxIou: def test_gen_iou(self): def gen_iou_check(box, expected, tolerance=1e-4): out = ops.generalized_box_iou(box, box) @@ -1014,4 +1014,4 @@ def gen_iou_check(box, expected, tolerance=1e-4): if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From 136ca60578e2d68ef2ae6cdb6732c8fe2a8cf1ea Mon Sep 17 00:00:00 2001 From: Aditya Oke <47158509+oke-aditya@users.noreply.github.com> Date: Fri, 4 Jun 2021 14:07:05 +0530 Subject: [PATCH 134/279] Add sphinx Index at the bottom of the index.html page (#3894) --- docs/source/conf.py | 15 +++++++-------- docs/source/index.rst | 6 ++++++ 2 files changed, 13 insertions(+), 8 deletions(-) diff --git a/docs/source/conf.py b/docs/source/conf.py index 216557d269e..6bbb05c13c7 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -27,9 +27,7 @@ # -- General configuration ------------------------------------------------ -# If your documentation needs a minimal Sphinx version, state it here. -# -# needs_sphinx = '1.0' +# Required version of sphinx is set from docs/requirements.txt # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom @@ -40,13 +38,12 @@ 'sphinx.ext.doctest', 'sphinx.ext.intersphinx', 'sphinx.ext.todo', - 'sphinx.ext.coverage', 'sphinx.ext.mathjax', 'sphinx.ext.napoleon', 'sphinx.ext.viewcode', 'sphinx.ext.duration', 'sphinx_gallery.gen_gallery', - "sphinx_copybutton" + 'sphinx_copybutton', ] sphinx_gallery_conf = { @@ -60,14 +57,16 @@ napoleon_numpy_docstring = False napoleon_google_docstring = True + # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # -# source_suffix = ['.rst', '.md'] -source_suffix = '.rst' +source_suffix = { + '.rst': 'restructuredtext', +} # The master toctree document. master_doc = 'index' @@ -147,7 +146,6 @@ # -- Options for LaTeX output --------------------------------------------- - latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # @@ -166,6 +164,7 @@ # 'figure_align': 'htbp', } + # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). diff --git a/docs/source/index.rst b/docs/source/index.rst index 61cb573c96f..b25a85d8617 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -58,3 +58,9 @@ architectures, and common image transformations for computer vision. TorchElastic TorchServe PyTorch on XLA Devices + + +Indices +------- + +* :ref:`genindex` From dc5ede718f7876cb0aeba338ec5da2bd6db94ed2 Mon Sep 17 00:00:00 2001 From: Sahil Goyal <59660566+sahilg06@users.noreply.github.com> Date: Fri, 4 Jun 2021 14:40:41 +0530 Subject: [PATCH 135/279] Port some tests in test_transforms to pytest (#3957) --- test/test_transforms.py | 224 ++++++++++++++++++++-------------------- 1 file changed, 113 insertions(+), 111 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index 33d81c657da..7c594512880 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -403,20 +403,6 @@ def test_random_crop(self): with self.assertRaisesRegex(ValueError, r"Required crop size .+ is larger then input image size .+"): t(img) - def test_lambda(self): - trans = transforms.Lambda(lambda x: x.add(10)) - x = torch.randn(10) - y = trans(x) - assert_equal(y, torch.add(x, 10)) - - trans = transforms.Lambda(lambda x: x.add_(10)) - x = torch.randn(10) - y = trans(x) - assert_equal(y, x) - - # Checking if Lambda can be printed as string - trans.__repr__() - @unittest.skipIf(stats is None, 'scipy.stats not available') def test_random_apply(self): random_state = random.getstate() @@ -1179,61 +1165,6 @@ def test_linear_transformation(self): # Checking if LinearTransformation can be printed as string whitening.__repr__() - def test_rotate(self): - x = np.zeros((100, 100, 3), dtype=np.uint8) - x[40, 40] = [255, 255, 255] - - with self.assertRaisesRegex(TypeError, r"img should be PIL Image"): - F.rotate(x, 10) - - img = F.to_pil_image(x) - - result = F.rotate(img, 45) - self.assertEqual(result.size, (100, 100)) - r, c, ch = np.where(result) - self.assertTrue(all(x in r for x in [49, 50])) - self.assertTrue(all(x in c for x in [36])) - self.assertTrue(all(x in ch for x in [0, 1, 2])) - - result = F.rotate(img, 45, expand=True) - self.assertEqual(result.size, (142, 142)) - r, c, ch = np.where(result) - self.assertTrue(all(x in r for x in [70, 71])) - self.assertTrue(all(x in c for x in [57])) - self.assertTrue(all(x in ch for x in [0, 1, 2])) - - result = F.rotate(img, 45, center=(40, 40)) - self.assertEqual(result.size, (100, 100)) - r, c, ch = np.where(result) - self.assertTrue(all(x in r for x in [40])) - self.assertTrue(all(x in c for x in [40])) - self.assertTrue(all(x in ch for x in [0, 1, 2])) - - result_a = F.rotate(img, 90) - result_b = F.rotate(img, -270) - - assert_equal(np.array(result_a), np.array(result_b)) - - def test_rotate_fill(self): - img = F.to_pil_image(np.ones((100, 100, 3), dtype=np.uint8) * 255, "RGB") - - modes = ("L", "RGB", "F") - nums_bands = [len(mode) for mode in modes] - fill = 127 - - for mode, num_bands in zip(modes, nums_bands): - img_conv = img.convert(mode) - img_rot = F.rotate(img_conv, 45.0, fill=fill) - pixel = img_rot.getpixel((0, 0)) - - if not isinstance(pixel, tuple): - pixel = (pixel,) - self.assertTupleEqual(pixel, tuple([fill] * num_bands)) - - for wrong_num_bands in set(nums_bands) - {num_bands}: - with self.assertRaises(ValueError): - F.rotate(img_conv, 45.0, fill=tuple([fill] * wrong_num_bands)) - def test_affine(self): input_img = np.zeros((40, 40, 3), dtype=np.uint8) cnt = [20, 20] @@ -1579,48 +1510,6 @@ def test_random_grayscale(self): # Checking if RandomGrayscale can be printed as string trans3.__repr__() - def test_gaussian_blur_asserts(self): - np_img = np.ones((100, 100, 3), dtype=np.uint8) * 255 - img = F.to_pil_image(np_img, "RGB") - - with self.assertRaisesRegex(ValueError, r"If kernel_size is a sequence its length should be 2"): - F.gaussian_blur(img, [3]) - - with self.assertRaisesRegex(ValueError, r"If kernel_size is a sequence its length should be 2"): - F.gaussian_blur(img, [3, 3, 3]) - with self.assertRaisesRegex(ValueError, r"Kernel size should be a tuple/list of two integers"): - transforms.GaussianBlur([3, 3, 3]) - - with self.assertRaisesRegex(ValueError, r"kernel_size should have odd and positive integers"): - F.gaussian_blur(img, [4, 4]) - with self.assertRaisesRegex(ValueError, r"Kernel size value should be an odd and positive number"): - transforms.GaussianBlur([4, 4]) - - with self.assertRaisesRegex(ValueError, r"kernel_size should have odd and positive integers"): - F.gaussian_blur(img, [-3, -3]) - with self.assertRaisesRegex(ValueError, r"Kernel size value should be an odd and positive number"): - transforms.GaussianBlur([-3, -3]) - - with self.assertRaisesRegex(ValueError, r"If sigma is a sequence, its length should be 2"): - F.gaussian_blur(img, 3, [1, 1, 1]) - with self.assertRaisesRegex(ValueError, r"sigma should be a single number or a list/tuple with length 2"): - transforms.GaussianBlur(3, [1, 1, 1]) - - with self.assertRaisesRegex(ValueError, r"sigma should have positive values"): - F.gaussian_blur(img, 3, -1.0) - with self.assertRaisesRegex(ValueError, r"If sigma is a single number, it must be positive"): - transforms.GaussianBlur(3, -1.0) - - with self.assertRaisesRegex(TypeError, r"kernel_size should be int or a sequence of integers"): - F.gaussian_blur(img, "kernel_size_string") - with self.assertRaisesRegex(ValueError, r"Kernel size should be a tuple/list of two integers"): - transforms.GaussianBlur("kernel_size_string") - - with self.assertRaisesRegex(TypeError, r"sigma should be either float or sequence of floats"): - F.gaussian_blur(img, 3, "sigma_string") - with self.assertRaisesRegex(ValueError, r"sigma should be a single number or a list/tuple with length 2"): - transforms.GaussianBlur(3, "sigma_string") - def test_autoaugment(self): for policy in transforms.AutoAugmentPolicy: for fill in [None, 85, (128, 128, 128)]: @@ -1990,5 +1879,118 @@ def test_adjusts_L_mode(): assert F.adjust_gamma(x_l, 0.5).mode == 'L' +def test_rotate(): + x = np.zeros((100, 100, 3), dtype=np.uint8) + x[40, 40] = [255, 255, 255] + + with pytest.raises(TypeError, match=r"img should be PIL Image"): + F.rotate(x, 10) + + img = F.to_pil_image(x) + + result = F.rotate(img, 45) + assert result.size == (100, 100) + r, c, ch = np.where(result) + assert all(x in r for x in [49, 50]) + assert all(x in c for x in [36]) + assert all(x in ch for x in [0, 1, 2]) + + result = F.rotate(img, 45, expand=True) + assert result.size == (142, 142) + r, c, ch = np.where(result) + assert all(x in r for x in [70, 71]) + assert all(x in c for x in [57]) + assert all(x in ch for x in [0, 1, 2]) + + result = F.rotate(img, 45, center=(40, 40)) + assert result.size == (100, 100) + r, c, ch = np.where(result) + assert all(x in r for x in [40]) + assert all(x in c for x in [40]) + assert all(x in ch for x in [0, 1, 2]) + + result_a = F.rotate(img, 90) + result_b = F.rotate(img, -270) + + assert_equal(np.array(result_a), np.array(result_b)) + + +@pytest.mark.parametrize('mode', ["L", "RGB", "F"]) +def test_rotate_fill(mode): + img = F.to_pil_image(np.ones((100, 100, 3), dtype=np.uint8) * 255, "RGB") + + num_bands = len(mode) + wrong_num_bands = num_bands + 1 + fill = 127 + + img_conv = img.convert(mode) + img_rot = F.rotate(img_conv, 45.0, fill=fill) + pixel = img_rot.getpixel((0, 0)) + + if not isinstance(pixel, tuple): + pixel = (pixel,) + assert pixel == tuple([fill] * num_bands) + + with pytest.raises(ValueError): + F.rotate(img_conv, 45.0, fill=tuple([fill] * wrong_num_bands)) + + +def test_gaussian_blur_asserts(): + np_img = np.ones((100, 100, 3), dtype=np.uint8) * 255 + img = F.to_pil_image(np_img, "RGB") + + with pytest.raises(ValueError, match=r"If kernel_size is a sequence its length should be 2"): + F.gaussian_blur(img, [3]) + with pytest.raises(ValueError, match=r"If kernel_size is a sequence its length should be 2"): + F.gaussian_blur(img, [3, 3, 3]) + with pytest.raises(ValueError, match=r"Kernel size should be a tuple/list of two integers"): + transforms.GaussianBlur([3, 3, 3]) + + with pytest.raises(ValueError, match=r"kernel_size should have odd and positive integers"): + F.gaussian_blur(img, [4, 4]) + with pytest.raises(ValueError, match=r"Kernel size value should be an odd and positive number"): + transforms.GaussianBlur([4, 4]) + + with pytest.raises(ValueError, match=r"kernel_size should have odd and positive integers"): + F.gaussian_blur(img, [-3, -3]) + with pytest.raises(ValueError, match=r"Kernel size value should be an odd and positive number"): + transforms.GaussianBlur([-3, -3]) + + with pytest.raises(ValueError, match=r"If sigma is a sequence, its length should be 2"): + F.gaussian_blur(img, 3, [1, 1, 1]) + with pytest.raises(ValueError, match=r"sigma should be a single number or a list/tuple with length 2"): + transforms.GaussianBlur(3, [1, 1, 1]) + + with pytest.raises(ValueError, match=r"sigma should have positive values"): + F.gaussian_blur(img, 3, -1.0) + with pytest.raises(ValueError, match=r"If sigma is a single number, it must be positive"): + transforms.GaussianBlur(3, -1.0) + + with pytest.raises(TypeError, match=r"kernel_size should be int or a sequence of integers"): + F.gaussian_blur(img, "kernel_size_string") + with pytest.raises(ValueError, match=r"Kernel size should be a tuple/list of two integers"): + transforms.GaussianBlur("kernel_size_string") + + with pytest.raises(TypeError, match=r"sigma should be either float or sequence of floats"): + F.gaussian_blur(img, 3, "sigma_string") + with pytest.raises(ValueError, match=r"sigma should be a single number or a list/tuple with length 2"): + transforms.GaussianBlur(3, "sigma_string") + + +def test_lambda(): + trans = transforms.Lambda(lambda x: x.add(10)) + x = torch.randn(10) + y = trans(x) + assert_equal(y, torch.add(x, 10)) + + trans = transforms.Lambda(lambda x: x.add_(10)) + x = torch.randn(10) + y = trans(x) + assert_equal(y, x) + + # Checking if Lambda can be printed as string + trans.__repr__() + + if __name__ == '__main__': unittest.main() From 96ad7f0c80538e06323ab2a4d2d4fb513022f59a Mon Sep 17 00:00:00 2001 From: Ishan Kumar Date: Fri, 4 Jun 2021 16:07:47 +0530 Subject: [PATCH 136/279] Port grayscale tests in test_tranforms to pytest (#3962) --- test/test_transforms.py | 288 ++++++++++++++++++++-------------------- 1 file changed, 145 insertions(+), 143 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index 7c594512880..65f44fe3a05 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -1367,149 +1367,6 @@ def test_random_affine(self): t = transforms.RandomAffine(10, interpolation=2) self.assertEqual(t.interpolation, transforms.InterpolationMode.BILINEAR) - def test_to_grayscale(self): - """Unit tests for grayscale transform""" - - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - x_pil_2 = x_pil.convert('L') - gray_np = np.array(x_pil_2) - - # Test Set: Grayscale an image with desired number of output channels - # Case 1: RGB -> 1 channel grayscale - trans1 = transforms.Grayscale(num_output_channels=1) - gray_pil_1 = trans1(x_pil) - gray_np_1 = np.array(gray_pil_1) - self.assertEqual(gray_pil_1.mode, 'L', 'mode should be L') - self.assertEqual(gray_np_1.shape, tuple(x_shape[0:2]), 'should be 1 channel') - assert_equal(gray_np, gray_np_1) - - # Case 2: RGB -> 3 channel grayscale - trans2 = transforms.Grayscale(num_output_channels=3) - gray_pil_2 = trans2(x_pil) - gray_np_2 = np.array(gray_pil_2) - self.assertEqual(gray_pil_2.mode, 'RGB', 'mode should be RGB') - self.assertEqual(gray_np_2.shape, tuple(x_shape), 'should be 3 channel') - assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) - assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) - assert_equal(gray_np, gray_np_2[:, :, 0], check_stride=False) - - # Case 3: 1 channel grayscale -> 1 channel grayscale - trans3 = transforms.Grayscale(num_output_channels=1) - gray_pil_3 = trans3(x_pil_2) - gray_np_3 = np.array(gray_pil_3) - self.assertEqual(gray_pil_3.mode, 'L', 'mode should be L') - self.assertEqual(gray_np_3.shape, tuple(x_shape[0:2]), 'should be 1 channel') - assert_equal(gray_np, gray_np_3) - - # Case 4: 1 channel grayscale -> 3 channel grayscale - trans4 = transforms.Grayscale(num_output_channels=3) - gray_pil_4 = trans4(x_pil_2) - gray_np_4 = np.array(gray_pil_4) - self.assertEqual(gray_pil_4.mode, 'RGB', 'mode should be RGB') - self.assertEqual(gray_np_4.shape, tuple(x_shape), 'should be 3 channel') - assert_equal(gray_np_4[:, :, 0], gray_np_4[:, :, 1]) - assert_equal(gray_np_4[:, :, 1], gray_np_4[:, :, 2]) - assert_equal(gray_np, gray_np_4[:, :, 0], check_stride=False) - - # Checking if Grayscale can be printed as string - trans4.__repr__() - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_grayscale(self): - """Unit tests for random grayscale transform""" - - # Test Set 1: RGB -> 3 channel grayscale - random_state = random.getstate() - random.seed(42) - x_shape = [2, 2, 3] - x_np = np.random.randint(0, 256, x_shape, np.uint8) - x_pil = Image.fromarray(x_np, mode='RGB') - x_pil_2 = x_pil.convert('L') - gray_np = np.array(x_pil_2) - - num_samples = 250 - num_gray = 0 - for _ in range(num_samples): - gray_pil_2 = transforms.RandomGrayscale(p=0.5)(x_pil) - gray_np_2 = np.array(gray_pil_2) - if np.array_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) and \ - np.array_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) and \ - np.array_equal(gray_np, gray_np_2[:, :, 0]): - num_gray = num_gray + 1 - - p_value = stats.binom_test(num_gray, num_samples, p=0.5) - random.setstate(random_state) - self.assertGreater(p_value, 0.0001) - - # Test Set 2: grayscale -> 1 channel grayscale - random_state = random.getstate() - random.seed(42) - x_shape = [2, 2, 3] - x_np = np.random.randint(0, 256, x_shape, np.uint8) - x_pil = Image.fromarray(x_np, mode='RGB') - x_pil_2 = x_pil.convert('L') - gray_np = np.array(x_pil_2) - - num_samples = 250 - num_gray = 0 - for _ in range(num_samples): - gray_pil_3 = transforms.RandomGrayscale(p=0.5)(x_pil_2) - gray_np_3 = np.array(gray_pil_3) - if np.array_equal(gray_np, gray_np_3): - num_gray = num_gray + 1 - - p_value = stats.binom_test(num_gray, num_samples, p=1.0) # Note: grayscale is always unchanged - random.setstate(random_state) - self.assertGreater(p_value, 0.0001) - - # Test set 3: Explicit tests - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - x_pil_2 = x_pil.convert('L') - gray_np = np.array(x_pil_2) - - # Case 3a: RGB -> 3 channel grayscale (grayscaled) - trans2 = transforms.RandomGrayscale(p=1.0) - gray_pil_2 = trans2(x_pil) - gray_np_2 = np.array(gray_pil_2) - self.assertEqual(gray_pil_2.mode, 'RGB', 'mode should be RGB') - self.assertEqual(gray_np_2.shape, tuple(x_shape), 'should be 3 channel') - assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) - assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) - assert_equal(gray_np, gray_np_2[:, :, 0], check_stride=False) - - # Case 3b: RGB -> 3 channel grayscale (unchanged) - trans2 = transforms.RandomGrayscale(p=0.0) - gray_pil_2 = trans2(x_pil) - gray_np_2 = np.array(gray_pil_2) - self.assertEqual(gray_pil_2.mode, 'RGB', 'mode should be RGB') - self.assertEqual(gray_np_2.shape, tuple(x_shape), 'should be 3 channel') - assert_equal(x_np, gray_np_2) - - # Case 3c: 1 channel grayscale -> 1 channel grayscale (grayscaled) - trans3 = transforms.RandomGrayscale(p=1.0) - gray_pil_3 = trans3(x_pil_2) - gray_np_3 = np.array(gray_pil_3) - self.assertEqual(gray_pil_3.mode, 'L', 'mode should be L') - self.assertEqual(gray_np_3.shape, tuple(x_shape[0:2]), 'should be 1 channel') - assert_equal(gray_np, gray_np_3) - - # Case 3d: 1 channel grayscale -> 1 channel grayscale (unchanged) - trans3 = transforms.RandomGrayscale(p=0.0) - gray_pil_3 = trans3(x_pil_2) - gray_np_3 = np.array(gray_pil_3) - self.assertEqual(gray_pil_3.mode, 'L', 'mode should be L') - self.assertEqual(gray_np_3.shape, tuple(x_shape[0:2]), 'should be 1 channel') - assert_equal(gray_np, gray_np_3) - - # Checking if RandomGrayscale can be printed as string - trans3.__repr__() - def test_autoaugment(self): for policy in transforms.AutoAugmentPolicy: for fill in [None, 85, (128, 128, 128)]: @@ -1992,5 +1849,150 @@ def test_lambda(): trans.__repr__() +def test_to_grayscale(): + """Unit tests for grayscale transform""" + + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + x_pil_2 = x_pil.convert('L') + gray_np = np.array(x_pil_2) + + # Test Set: Grayscale an image with desired number of output channels + # Case 1: RGB -> 1 channel grayscale + trans1 = transforms.Grayscale(num_output_channels=1) + gray_pil_1 = trans1(x_pil) + gray_np_1 = np.array(gray_pil_1) + assert gray_pil_1.mode == 'L', 'mode should be L' + assert gray_np_1.shape == tuple(x_shape[0:2]), 'should be 1 channel' + assert_equal(gray_np, gray_np_1) + + # Case 2: RGB -> 3 channel grayscale + trans2 = transforms.Grayscale(num_output_channels=3) + gray_pil_2 = trans2(x_pil) + gray_np_2 = np.array(gray_pil_2) + assert gray_pil_2.mode == 'RGB', 'mode should be RGB' + assert gray_np_2.shape == tuple(x_shape), 'should be 3 channel' + assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) + assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) + assert_equal(gray_np, gray_np_2[:, :, 0], check_stride=False) + + # Case 3: 1 channel grayscale -> 1 channel grayscale + trans3 = transforms.Grayscale(num_output_channels=1) + gray_pil_3 = trans3(x_pil_2) + gray_np_3 = np.array(gray_pil_3) + assert gray_pil_3.mode == 'L', 'mode should be L' + assert gray_np_3.shape == tuple(x_shape[0:2]), 'should be 1 channel' + assert_equal(gray_np, gray_np_3) + + # Case 4: 1 channel grayscale -> 3 channel grayscale + trans4 = transforms.Grayscale(num_output_channels=3) + gray_pil_4 = trans4(x_pil_2) + gray_np_4 = np.array(gray_pil_4) + assert gray_pil_4.mode == 'RGB', 'mode should be RGB' + assert gray_np_4.shape == tuple(x_shape), 'should be 3 channel' + assert_equal(gray_np_4[:, :, 0], gray_np_4[:, :, 1]) + assert_equal(gray_np_4[:, :, 1], gray_np_4[:, :, 2]) + assert_equal(gray_np, gray_np_4[:, :, 0], check_stride=False) + + # Checking if Grayscale can be printed as string + trans4.__repr__() + + +@pytest.mark.skipif(stats is None, reason="scipy.stats not available") +def test_random_grayscale(): + """Unit tests for random grayscale transform""" + + # Test Set 1: RGB -> 3 channel grayscale + random_state = random.getstate() + random.seed(42) + x_shape = [2, 2, 3] + x_np = np.random.randint(0, 256, x_shape, np.uint8) + x_pil = Image.fromarray(x_np, mode='RGB') + x_pil_2 = x_pil.convert('L') + gray_np = np.array(x_pil_2) + + num_samples = 250 + num_gray = 0 + for _ in range(num_samples): + gray_pil_2 = transforms.RandomGrayscale(p=0.5)(x_pil) + gray_np_2 = np.array(gray_pil_2) + if np.array_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) and \ + np.array_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) and \ + np.array_equal(gray_np, gray_np_2[:, :, 0]): + num_gray = num_gray + 1 + + p_value = stats.binom_test(num_gray, num_samples, p=0.5) + random.setstate(random_state) + assert p_value > 0.0001 + + # Test Set 2: grayscale -> 1 channel grayscale + random_state = random.getstate() + random.seed(42) + x_shape = [2, 2, 3] + x_np = np.random.randint(0, 256, x_shape, np.uint8) + x_pil = Image.fromarray(x_np, mode='RGB') + x_pil_2 = x_pil.convert('L') + gray_np = np.array(x_pil_2) + + num_samples = 250 + num_gray = 0 + for _ in range(num_samples): + gray_pil_3 = transforms.RandomGrayscale(p=0.5)(x_pil_2) + gray_np_3 = np.array(gray_pil_3) + if np.array_equal(gray_np, gray_np_3): + num_gray = num_gray + 1 + + p_value = stats.binom_test(num_gray, num_samples, p=1.0) # Note: grayscale is always unchanged + random.setstate(random_state) + assert p_value > 0.0001 + + # Test set 3: Explicit tests + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + x_pil_2 = x_pil.convert('L') + gray_np = np.array(x_pil_2) + + # Case 3a: RGB -> 3 channel grayscale (grayscaled) + trans2 = transforms.RandomGrayscale(p=1.0) + gray_pil_2 = trans2(x_pil) + gray_np_2 = np.array(gray_pil_2) + assert gray_pil_2.mode == 'RGB', 'mode should be RGB' + assert gray_np_2.shape == tuple(x_shape), 'should be 3 channel' + assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) + assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) + assert_equal(gray_np, gray_np_2[:, :, 0], check_stride=False) + + # Case 3b: RGB -> 3 channel grayscale (unchanged) + trans2 = transforms.RandomGrayscale(p=0.0) + gray_pil_2 = trans2(x_pil) + gray_np_2 = np.array(gray_pil_2) + assert gray_pil_2.mode == 'RGB', 'mode should be RGB' + assert gray_np_2.shape == tuple(x_shape), 'should be 3 channel' + assert_equal(x_np, gray_np_2) + + # Case 3c: 1 channel grayscale -> 1 channel grayscale (grayscaled) + trans3 = transforms.RandomGrayscale(p=1.0) + gray_pil_3 = trans3(x_pil_2) + gray_np_3 = np.array(gray_pil_3) + assert gray_pil_3.mode == 'L', 'mode should be L' + assert gray_np_3.shape == tuple(x_shape[0:2]), 'should be 1 channel' + assert_equal(gray_np, gray_np_3) + + # Case 3d: 1 channel grayscale -> 1 channel grayscale (unchanged) + trans3 = transforms.RandomGrayscale(p=0.0) + gray_pil_3 = trans3(x_pil_2) + gray_np_3 = np.array(gray_pil_3) + assert gray_pil_3.mode == 'L', 'mode should be L' + assert gray_np_3.shape == tuple(x_shape[0:2]), 'should be 1 channel' + assert_equal(gray_np, gray_np_3) + + # Checking if RandomGrayscale can be printed as string + trans3.__repr__() + + if __name__ == '__main__': unittest.main() From 6e5a83fbd94b8d0b482ddd527662d8de2bfe817e Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Fri, 4 Jun 2021 14:48:42 +0100 Subject: [PATCH 137/279] Fixed read_image bug (#3948) * Fixed read_image bug * Removed unused import * Skip tests if cv2 unavailable * Removed cv2 dependency --- test/test_image.py | 36 ++++++++++++++++++++ torchvision/csrc/io/image/cpu/decode_png.cpp | 6 ++-- 2 files changed, 40 insertions(+), 2 deletions(-) diff --git a/test/test_image.py b/test/test_image.py index 61bf3a4070c..e5aeef0dc37 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -258,6 +258,42 @@ def test_write_file_non_ascii(): assert content == saved_content +@pytest.mark.parametrize('shape', [ + (27, 27), + (60, 60), + (105, 105), +]) +def test_read_1_bit_png(shape): + with get_tmp_dir() as root: + image_path = os.path.join(root, f'test_{shape}.png') + pixels = np.random.rand(*shape) > 0.5 + img = Image.fromarray(pixels) + img.save(image_path) + img1 = read_image(image_path) + img2 = normalize_dimensions(torch.as_tensor(pixels * 255, dtype=torch.uint8)) + assert_equal(img1, img2, check_stride=False) + + +@pytest.mark.parametrize('shape', [ + (27, 27), + (60, 60), + (105, 105), +]) +@pytest.mark.parametrize('mode', [ + ImageReadMode.UNCHANGED, + ImageReadMode.GRAY, +]) +def test_read_1_bit_png_consistency(shape, mode): + with get_tmp_dir() as root: + image_path = os.path.join(root, f'test_{shape}.png') + pixels = np.random.rand(*shape) > 0.5 + img = Image.fromarray(pixels) + img.save(image_path) + img1 = read_image(image_path, mode) + img2 = read_image(image_path, mode) + assert_equal(img1, img2) + + @needs_cuda @pytest.mark.parametrize('img_path', [ pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) diff --git a/torchvision/csrc/io/image/cpu/decode_png.cpp b/torchvision/csrc/io/image/cpu/decode_png.cpp index 5ee33635a1c..315ed611614 100644 --- a/torchvision/csrc/io/image/cpu/decode_png.cpp +++ b/torchvision/csrc/io/image/cpu/decode_png.cpp @@ -73,6 +73,9 @@ torch::Tensor decode_png(const torch::Tensor& data, ImageReadMode mode) { int channels = png_get_channels(png_ptr, info_ptr); + if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) + png_set_expand_gray_1_2_4_to_8(png_ptr); + if (mode != IMAGE_READ_MODE_UNCHANGED) { // TODO: consider supporting PNG_INFO_tRNS bool is_palette = (color_type & PNG_COLOR_MASK_PALETTE) != 0; @@ -155,10 +158,9 @@ torch::Tensor decode_png(const torch::Tensor& data, ImageReadMode mode) { auto tensor = torch::empty({int64_t(height), int64_t(width), channels}, torch::kU8); auto ptr = tensor.accessor().data(); - auto bytes = png_get_rowbytes(png_ptr, info_ptr); for (png_uint_32 i = 0; i < height; ++i) { png_read_row(png_ptr, ptr, nullptr); - ptr += bytes; + ptr += width * channels; } png_destroy_read_struct(&png_ptr, &info_ptr, nullptr); return tensor.permute({2, 0, 1}); From a0b44d704fde018afc23a2c520828e3e39f96d03 Mon Sep 17 00:00:00 2001 From: Shengwei An Date: Fri, 4 Jun 2021 10:32:03 -0400 Subject: [PATCH 138/279] Change 'range' in docstrings of make_grid to 'value_range' (#3967) --- torchvision/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/utils.py b/torchvision/utils.py index 12787433781..ea197d7386e 100644 --- a/torchvision/utils.py +++ b/torchvision/utils.py @@ -30,7 +30,7 @@ def make_grid( The final grid size is ``(B / nrow, nrow)``. Default: ``8``. padding (int, optional): amount of padding. Default: ``2``. normalize (bool, optional): If True, shift the image to the range (0, 1), - by the min and max values specified by :attr:`range`. Default: ``False``. + by the min and max values specified by ``value_range``. Default: ``False``. value_range (tuple, optional): tuple (min, max) where min and max are numbers, then these numbers are used to normalize the image. By default, min and max are computed from the tensor. From 21426ddc98cbc87b318b1712191951c771ad58f0 Mon Sep 17 00:00:00 2001 From: Vivek Kumar <60113444+vivekkumar7089@users.noreply.github.com> Date: Fri, 4 Jun 2021 20:05:45 +0530 Subject: [PATCH 139/279] Port some tests in test_transforms.py to pytest (#3964) --- test/test_transforms.py | 179 ++++++++++++++++++++-------------------- 1 file changed, 91 insertions(+), 88 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index 65f44fe3a05..fe73b3c32ae 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -403,94 +403,6 @@ def test_random_crop(self): with self.assertRaisesRegex(ValueError, r"Required crop size .+ is larger then input image size .+"): t(img) - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_apply(self): - random_state = random.getstate() - random.seed(42) - random_apply_transform = transforms.RandomApply( - [ - transforms.RandomRotation((-45, 45)), - transforms.RandomHorizontalFlip(), - transforms.RandomVerticalFlip(), - ], p=0.75 - ) - img = transforms.ToPILImage()(torch.rand(3, 10, 10)) - num_samples = 250 - num_applies = 0 - for _ in range(num_samples): - out = random_apply_transform(img) - if out != img: - num_applies += 1 - - p_value = stats.binom_test(num_applies, num_samples, p=0.75) - random.setstate(random_state) - self.assertGreater(p_value, 0.0001) - - # Checking if RandomApply can be printed as string - random_apply_transform.__repr__() - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_choice(self): - random_state = random.getstate() - random.seed(42) - random_choice_transform = transforms.RandomChoice( - [ - transforms.Resize(15), - transforms.Resize(20), - transforms.CenterCrop(10) - ] - ) - img = transforms.ToPILImage()(torch.rand(3, 25, 25)) - num_samples = 250 - num_resize_15 = 0 - num_resize_20 = 0 - num_crop_10 = 0 - for _ in range(num_samples): - out = random_choice_transform(img) - if out.size == (15, 15): - num_resize_15 += 1 - elif out.size == (20, 20): - num_resize_20 += 1 - elif out.size == (10, 10): - num_crop_10 += 1 - - p_value = stats.binom_test(num_resize_15, num_samples, p=0.33333) - self.assertGreater(p_value, 0.0001) - p_value = stats.binom_test(num_resize_20, num_samples, p=0.33333) - self.assertGreater(p_value, 0.0001) - p_value = stats.binom_test(num_crop_10, num_samples, p=0.33333) - self.assertGreater(p_value, 0.0001) - - random.setstate(random_state) - # Checking if RandomChoice can be printed as string - random_choice_transform.__repr__() - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_order(self): - random_state = random.getstate() - random.seed(42) - random_order_transform = transforms.RandomOrder( - [ - transforms.Resize(20), - transforms.CenterCrop(10) - ] - ) - img = transforms.ToPILImage()(torch.rand(3, 25, 25)) - num_samples = 250 - num_normal_order = 0 - resize_crop_out = transforms.CenterCrop(10)(transforms.Resize(20)(img)) - for _ in range(num_samples): - out = random_order_transform(img) - if out == resize_crop_out: - num_normal_order += 1 - - p_value = stats.binom_test(num_normal_order, num_samples, p=0.5) - random.setstate(random_state) - self.assertGreater(p_value, 0.0001) - - # Checking if RandomOrder can be printed as string - random_order_transform.__repr__() - def test_to_tensor(self): test_channels = [1, 3, 4] height, width = 4, 4 @@ -1994,5 +1906,96 @@ def test_random_grayscale(): trans3.__repr__() +@pytest.mark.skipif(stats is None, reason='scipy.stats not available') +def test_random_apply(): + random_state = random.getstate() + random.seed(42) + random_apply_transform = transforms.RandomApply( + [ + transforms.RandomRotation((-45, 45)), + transforms.RandomHorizontalFlip(), + transforms.RandomVerticalFlip(), + ], p=0.75 + ) + img = transforms.ToPILImage()(torch.rand(3, 10, 10)) + num_samples = 250 + num_applies = 0 + for _ in range(num_samples): + out = random_apply_transform(img) + if out != img: + num_applies += 1 + + p_value = stats.binom_test(num_applies, num_samples, p=0.75) + random.setstate(random_state) + assert p_value > 0.0001 + + # Checking if RandomApply can be printed as string + random_apply_transform.__repr__() + + +@pytest.mark.skipif(stats is None, reason='scipy.stats not available') +def test_random_choice(): + random_state = random.getstate() + random.seed(42) + random_choice_transform = transforms.RandomChoice( + [ + transforms.Resize(15), + transforms.Resize(20), + transforms.CenterCrop(10) + ] + ) + img = transforms.ToPILImage()(torch.rand(3, 25, 25)) + num_samples = 250 + num_resize_15 = 0 + num_resize_20 = 0 + num_crop_10 = 0 + for _ in range(num_samples): + out = random_choice_transform(img) + if out.size == (15, 15): + num_resize_15 += 1 + elif out.size == (20, 20): + num_resize_20 += 1 + elif out.size == (10, 10): + num_crop_10 += 1 + + p_value = stats.binom_test(num_resize_15, num_samples, p=0.33333) + assert p_value > 0.0001 + p_value = stats.binom_test(num_resize_20, num_samples, p=0.33333) + assert p_value > 0.0001 + p_value = stats.binom_test(num_crop_10, num_samples, p=0.33333) + assert p_value > 0.0001 + + random.setstate(random_state) + # Checking if RandomChoice can be printed as string + random_choice_transform.__repr__() + + +@pytest.mark.skipif(stats is None, reason='scipy.stats not available') +def test_random_order(): + random_state = random.getstate() + random.seed(42) + random_order_transform = transforms.RandomOrder( + [ + transforms.Resize(20), + transforms.CenterCrop(10) + ] + ) + img = transforms.ToPILImage()(torch.rand(3, 25, 25)) + num_samples = 250 + num_normal_order = 0 + resize_crop_out = transforms.CenterCrop(10)(transforms.Resize(20)(img)) + for _ in range(num_samples): + out = random_order_transform(img) + if out == resize_crop_out: + num_normal_order += 1 + + p_value = stats.binom_test(num_normal_order, num_samples, p=0.5) + random.setstate(random_state) + assert p_value > 0.0001 + + # Checking if RandomOrder can be printed as string + random_order_transform.__repr__() + + if __name__ == '__main__': unittest.main() From c6c5a5f5765fa1eb28ce7d827254ce10957c8366 Mon Sep 17 00:00:00 2001 From: Bruno Korbar Date: Fri, 4 Jun 2021 17:54:16 +0100 Subject: [PATCH 140/279] Add warning for files with corrupt containers (#3961) Co-authored-by: Vasilis Vryniotis --- torchvision/io/video.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torchvision/io/video.py b/torchvision/io/video.py index faa2f236fa3..b45e6da9f44 100644 --- a/torchvision/io/video.py +++ b/torchvision/io/video.py @@ -391,9 +391,9 @@ def read_video_timestamps(filename: str, pts_unit: str = "pts") -> Tuple[List[in except av.AVError: warnings.warn(f"Failed decoding frames for file {filename}") video_fps = float(video_stream.average_rate) - except av.AVError: - # TODO add a warning - pass + except av.AVError as e: + msg = f"Failed to open container for {filename}; Caught error: {e}" + warnings.warn(msg, RuntimeWarning) pts.sort() From 744e37d7b5dec429b03cda213224543816499cb2 Mon Sep 17 00:00:00 2001 From: Aditya Oke <47158509+oke-aditya@users.noreply.github.com> Date: Fri, 4 Jun 2021 22:25:47 +0530 Subject: [PATCH 141/279] Add Docs for `VisionDataset` (#3863) * fix * add docs for VisionDataset * add getitem * add deprecated note to transform * Update torchvision/datasets/vision.py Co-authored-by: Philip Meier * fix docs * Update torchvision/datasets/vision.py * flake8 Co-authored-by: Nicolas Hug Co-authored-by: Philip Meier Co-authored-by: Vasilis Vryniotis --- docs/source/datasets.rst | 4 ++++ torchvision/datasets/vision.py | 24 ++++++++++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/docs/source/datasets.rst b/docs/source/datasets.rst index af1b95db4bb..f0cb19ed690 100644 --- a/docs/source/datasets.rst +++ b/docs/source/datasets.rst @@ -258,3 +258,7 @@ Base classes for custom datasets .. autoclass:: ImageFolder :members: __getitem__ :special-members: + +.. autoclass:: VisionDataset + :members: __getitem__ + :special-members: diff --git a/torchvision/datasets/vision.py b/torchvision/datasets/vision.py index 7aa25f79eb8..2cc9ce14cb1 100644 --- a/torchvision/datasets/vision.py +++ b/torchvision/datasets/vision.py @@ -5,6 +5,23 @@ class VisionDataset(data.Dataset): + """ + Base Class For making datasets which are compatible with torchvision. + It is necessary to override the ``__getitem__`` and ``__len__`` method. + + Args: + root (string): Root directory of dataset. + transforms (callable, optional): A function/transforms that takes in + an image and a label and returns the transformed versions of both. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + target_transform (callable, optional): A function/transform that takes in the + target and transforms it. + + .. note:: + + :attr:`transforms` and the combination of :attr:`transform` and :attr:`target_transform` are mutually exclusive. + """ _repr_indent = 4 def __init__( @@ -33,6 +50,13 @@ def __init__( self.transforms = transforms def __getitem__(self, index: int) -> Any: + """ + Args: + index (int): Index + + Returns: + (Any): Sample and meta data, optionally transformed by the respective transforms. + """ raise NotImplementedError def __len__(self) -> int: From 366bf0aa64f795f6b0f4bcb3b3e3c3ed555f11bf Mon Sep 17 00:00:00 2001 From: Anirudh Date: Sat, 5 Jun 2021 16:41:40 +0530 Subject: [PATCH 142/279] Port test resize in test_transforms to pytest (#3952) --- test/test_transforms.py | 205 +++++++++++++++++++++------------------- 1 file changed, 109 insertions(+), 96 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index fe73b3c32ae..b674414e46a 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -202,31 +202,6 @@ def test_ten_crop(self): self.assertEqual(len(results), 10) self.assertEqual(results, expected_output) - def test_randomresized_params(self): - height = random.randint(24, 32) * 2 - width = random.randint(24, 32) * 2 - img = torch.ones(3, height, width) - to_pil_image = transforms.ToPILImage() - img = to_pil_image(img) - size = 100 - epsilon = 0.05 - min_scale = 0.25 - for _ in range(10): - scale_min = max(round(random.random(), 2), min_scale) - scale_range = (scale_min, scale_min + round(random.random(), 2)) - aspect_min = max(round(random.random(), 2), epsilon) - aspect_ratio_range = (aspect_min, aspect_min + round(random.random(), 2)) - randresizecrop = transforms.RandomResizedCrop(size, scale_range, aspect_ratio_range) - i, j, h, w = randresizecrop.get_params(img, scale_range, aspect_ratio_range) - aspect_ratio_obtained = w / h - self.assertTrue((min(aspect_ratio_range) - epsilon <= aspect_ratio_obtained and - aspect_ratio_obtained <= max(aspect_ratio_range) + epsilon) or - aspect_ratio_obtained == 1.0) - self.assertIsInstance(i, int) - self.assertIsInstance(j, int) - self.assertIsInstance(h, int) - self.assertIsInstance(w, int) - def test_randomperspective(self): for _ in range(10): height = random.randint(24, 32) * 2 @@ -287,77 +262,6 @@ def test_randomperspective_fill(self): with self.assertRaises(ValueError): F.perspective(img_conv, startpoints, endpoints, fill=tuple([fill] * wrong_num_bands)) - def test_resize(self): - - input_sizes = [ - # height, width - # square image - (28, 28), - (27, 27), - # rectangular image: h < w - (28, 34), - (29, 35), - # rectangular image: h > w - (34, 28), - (35, 29), - ] - test_output_sizes_1 = [ - # single integer - 22, 27, 28, 36, - # single integer in tuple/list - [22, ], (27, ), - ] - test_output_sizes_2 = [ - # two integers - [22, 22], [22, 28], [22, 36], - [27, 22], [36, 22], [28, 28], - [28, 37], [37, 27], [37, 37] - ] - - for height, width in input_sizes: - img = Image.new("RGB", size=(width, height), color=127) - - for osize in test_output_sizes_1: - for max_size in (None, 37, 1000): - - t = transforms.Resize(osize, max_size=max_size) - result = t(img) - - msg = "{}, {} - {} - {}".format(height, width, osize, max_size) - osize = osize[0] if isinstance(osize, (list, tuple)) else osize - # If size is an int, smaller edge of the image will be matched to this number. - # i.e, if height > width, then image will be rescaled to (size * height / width, size). - if height < width: - exp_w, exp_h = (int(osize * width / height), osize) # (w, h) - if max_size is not None and max_size < exp_w: - exp_w, exp_h = max_size, int(max_size * exp_h / exp_w) - self.assertEqual(result.size, (exp_w, exp_h), msg=msg) - elif width < height: - exp_w, exp_h = (osize, int(osize * height / width)) # (w, h) - if max_size is not None and max_size < exp_h: - exp_w, exp_h = int(max_size * exp_w / exp_h), max_size - self.assertEqual(result.size, (exp_w, exp_h), msg=msg) - else: - exp_w, exp_h = (osize, osize) # (w, h) - if max_size is not None and max_size < osize: - exp_w, exp_h = max_size, max_size - self.assertEqual(result.size, (exp_w, exp_h), msg=msg) - - for height, width in input_sizes: - img = Image.new("RGB", size=(width, height), color=127) - - for osize in test_output_sizes_2: - oheight, owidth = osize - - t = transforms.Resize(osize) - result = t(img) - - self.assertEqual((owidth, oheight), result.size) - - with self.assertWarnsRegex(UserWarning, r"Anti-alias option is always applied for PIL Image input"): - t = transforms.Resize(osize, antialias=False) - t(img) - def test_random_crop(self): height = random.randint(10, 32) * 2 width = random.randint(10, 32) * 2 @@ -1315,6 +1219,115 @@ def test_random_erasing(self): t.__repr__() +def test_randomresized_params(): + height = random.randint(24, 32) * 2 + width = random.randint(24, 32) * 2 + img = torch.ones(3, height, width) + to_pil_image = transforms.ToPILImage() + img = to_pil_image(img) + size = 100 + epsilon = 0.05 + min_scale = 0.25 + for _ in range(10): + scale_min = max(round(random.random(), 2), min_scale) + scale_range = (scale_min, scale_min + round(random.random(), 2)) + aspect_min = max(round(random.random(), 2), epsilon) + aspect_ratio_range = (aspect_min, aspect_min + round(random.random(), 2)) + randresizecrop = transforms.RandomResizedCrop(size, scale_range, aspect_ratio_range) + i, j, h, w = randresizecrop.get_params(img, scale_range, aspect_ratio_range) + aspect_ratio_obtained = w / h + assert((min(aspect_ratio_range) - epsilon <= aspect_ratio_obtained and + aspect_ratio_obtained <= max(aspect_ratio_range) + epsilon) or + aspect_ratio_obtained == 1.0) + assert isinstance(i, int) + assert isinstance(j, int) + assert isinstance(h, int) + assert isinstance(w, int) + + +@pytest.mark.parametrize('height, width', [ + # height, width + # square image + (28, 28), + (27, 27), + # rectangular image: h < w + (28, 34), + (29, 35), + # rectangular image: h > w + (34, 28), + (35, 29), +]) +@pytest.mark.parametrize('osize', [ + # single integer + 22, 27, 28, 36, + # single integer in tuple/list + [22, ], (27, ), +]) +@pytest.mark.parametrize('max_size', (None, 37, 1000)) +def test_resize(height, width, osize, max_size): + img = Image.new("RGB", size=(width, height), color=127) + + t = transforms.Resize(osize, max_size=max_size) + result = t(img) + + msg = "{}, {} - {} - {}".format(height, width, osize, max_size) + osize = osize[0] if isinstance(osize, (list, tuple)) else osize + # If size is an int, smaller edge of the image will be matched to this number. + # i.e, if height > width, then image will be rescaled to (size * height / width, size). + if height < width: + exp_w, exp_h = (int(osize * width / height), osize) # (w, h) + if max_size is not None and max_size < exp_w: + exp_w, exp_h = max_size, int(max_size * exp_h / exp_w) + assert result.size == (exp_w, exp_h), msg + elif width < height: + exp_w, exp_h = (osize, int(osize * height / width)) # (w, h) + if max_size is not None and max_size < exp_h: + exp_w, exp_h = int(max_size * exp_w / exp_h), max_size + assert result.size == (exp_w, exp_h), msg + else: + exp_w, exp_h = (osize, osize) # (w, h) + if max_size is not None and max_size < osize: + exp_w, exp_h = max_size, max_size + assert result.size == (exp_w, exp_h), msg + + +@pytest.mark.parametrize('height, width', [ + # height, width + # square image + (28, 28), + (27, 27), + # rectangular image: h < w + (28, 34), + (29, 35), + # rectangular image: h > w + (34, 28), + (35, 29), +]) +@pytest.mark.parametrize('osize', [ + # two integers sequence output + [22, 22], [22, 28], [22, 36], + [27, 22], [36, 22], [28, 28], + [28, 37], [37, 27], [37, 37] +]) +def test_resize_sequence_output(height, width, osize): + img = Image.new("RGB", size=(width, height), color=127) + oheight, owidth = osize + + t = transforms.Resize(osize) + result = t(img) + + assert (owidth, oheight) == result.size + + +def test_resize_antialias_error(): + osize = [37, 37] + img = Image.new("RGB", size=(35, 29), color=127) + + with pytest.warns(UserWarning, match=r"Anti-alias option is always applied for PIL Image input"): + t = transforms.Resize(osize, antialias=False) + t(img) + + class TestPad: def test_pad(self): From 15bebfbcfb32bc6fcc39087337fdd4d02082132f Mon Sep 17 00:00:00 2001 From: DevPranjal <72960463+DevPranjal@users.noreply.github.com> Date: Sat, 5 Jun 2021 16:50:06 +0530 Subject: [PATCH 143/279] Port to_tensor tests in test_transforms to pytest (#3966) --- test/test_transforms.py | 177 ++++++++++++++++++++++------------------ 1 file changed, 96 insertions(+), 81 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index b674414e46a..d4558c98a69 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -307,54 +307,6 @@ def test_random_crop(self): with self.assertRaisesRegex(ValueError, r"Required crop size .+ is larger then input image size .+"): t(img) - def test_to_tensor(self): - test_channels = [1, 3, 4] - height, width = 4, 4 - trans = transforms.ToTensor() - - with self.assertRaises(TypeError): - trans(np.random.rand(1, height, width).tolist()) - - with self.assertRaises(ValueError): - trans(np.random.rand(height)) - trans(np.random.rand(1, 1, height, width)) - - for channels in test_channels: - input_data = torch.ByteTensor(channels, height, width).random_(0, 255).float().div_(255) - img = transforms.ToPILImage()(input_data) - output = trans(img) - torch.testing.assert_close(output, input_data, check_stride=False) - - ndarray = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) - output = trans(ndarray) - expected_output = ndarray.transpose((2, 0, 1)) / 255.0 - torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) - - ndarray = np.random.rand(height, width, channels).astype(np.float32) - output = trans(ndarray) - expected_output = ndarray.transpose((2, 0, 1)) - torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) - - # separate test for mode '1' PIL images - input_data = torch.ByteTensor(1, height, width).bernoulli_() - img = transforms.ToPILImage()(input_data.mul(255)).convert('1') - output = trans(img) - torch.testing.assert_close(input_data, output, check_dtype=False, check_stride=False) - - def test_to_tensor_with_other_default_dtypes(self): - current_def_dtype = torch.get_default_dtype() - - t = transforms.ToTensor() - np_arr = np.random.randint(0, 255, (32, 32, 3), dtype=np.uint8) - img = Image.fromarray(np_arr) - - for dtype in [torch.float16, torch.float, torch.double]: - torch.set_default_dtype(dtype) - res = t(img) - self.assertTrue(res.dtype == dtype, msg=f"{res.dtype} vs {dtype}") - - torch.set_default_dtype(current_def_dtype) - def test_max_value(self): for dtype in int_dtypes(): self.assertEqual(F_t._max_value(dtype), torch.iinfo(dtype).max) @@ -492,39 +444,6 @@ def test_accimage_to_tensor(self): torch.testing.assert_close(output, expected_output) - def test_pil_to_tensor(self): - test_channels = [1, 3, 4] - height, width = 4, 4 - trans = transforms.PILToTensor() - - with self.assertRaises(TypeError): - trans(np.random.rand(1, height, width).tolist()) - trans(np.random.rand(1, height, width)) - - for channels in test_channels: - input_data = torch.ByteTensor(channels, height, width).random_(0, 255) - img = transforms.ToPILImage()(input_data) - output = trans(img) - torch.testing.assert_close(input_data, output, check_stride=False) - - input_data = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) - img = transforms.ToPILImage()(input_data) - output = trans(img) - expected_output = input_data.transpose((2, 0, 1)) - torch.testing.assert_close(output.numpy(), expected_output) - - input_data = torch.as_tensor(np.random.rand(channels, height, width).astype(np.float32)) - img = transforms.ToPILImage()(input_data) # CHW -> HWC and (* 255).byte() - output = trans(img) # HWC -> CHW - expected_output = (input_data * 255).byte() - torch.testing.assert_close(output, expected_output, check_stride=False) - - # separate test for mode '1' PIL images - input_data = torch.ByteTensor(1, height, width).bernoulli_() - img = transforms.ToPILImage()(input_data.mul(255)).convert('1') - output = trans(img).view(torch.uint8).bool().to(torch.uint8) - torch.testing.assert_close(input_data, output, check_stride=False) - @unittest.skipIf(accimage is None, 'accimage not available') def test_accimage_pil_to_tensor(self): trans = transforms.PILToTensor() @@ -1219,6 +1138,102 @@ def test_random_erasing(self): t.__repr__() +@pytest.mark.parametrize('channels', [1, 3, 4]) +def test_to_tensor(channels): + height, width = 4, 4 + trans = transforms.ToTensor() + + input_data = torch.ByteTensor(channels, height, width).random_(0, 255).float().div_(255) + img = transforms.ToPILImage()(input_data) + output = trans(img) + torch.testing.assert_close(output, input_data, check_stride=False) + + ndarray = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) + output = trans(ndarray) + expected_output = ndarray.transpose((2, 0, 1)) / 255.0 + torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) + + ndarray = np.random.rand(height, width, channels).astype(np.float32) + output = trans(ndarray) + expected_output = ndarray.transpose((2, 0, 1)) + torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) + + # separate test for mode '1' PIL images + input_data = torch.ByteTensor(1, height, width).bernoulli_() + img = transforms.ToPILImage()(input_data.mul(255)).convert('1') + output = trans(img) + torch.testing.assert_close(input_data, output, check_dtype=False, check_stride=False) + + +def test_to_tensor_errors(): + height, width = 4, 4 + trans = transforms.ToTensor() + + with pytest.raises(TypeError): + trans(np.random.rand(1, height, width).tolist()) + + with pytest.raises(ValueError): + trans(np.random.rand(height)) + + with pytest.raises(ValueError): + trans(np.random.rand(1, 1, height, width)) + + +@pytest.mark.parametrize('dtype', [torch.float16, torch.float, torch.double]) +def test_to_tensor_with_other_default_dtypes(dtype): + current_def_dtype = torch.get_default_dtype() + + t = transforms.ToTensor() + np_arr = np.random.randint(0, 255, (32, 32, 3), dtype=np.uint8) + img = Image.fromarray(np_arr) + + torch.set_default_dtype(dtype) + res = t(img) + assert res.dtype == dtype, f"{res.dtype} vs {dtype}" + + torch.set_default_dtype(current_def_dtype) + + +@pytest.mark.parametrize('channels', [1, 3, 4]) +def test_pil_to_tensor(channels): + height, width = 4, 4 + trans = transforms.PILToTensor() + + input_data = torch.ByteTensor(channels, height, width).random_(0, 255) + img = transforms.ToPILImage()(input_data) + output = trans(img) + torch.testing.assert_close(input_data, output, check_stride=False) + + input_data = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) + img = transforms.ToPILImage()(input_data) + output = trans(img) + expected_output = input_data.transpose((2, 0, 1)) + torch.testing.assert_close(output.numpy(), expected_output) + + input_data = torch.as_tensor(np.random.rand(channels, height, width).astype(np.float32)) + img = transforms.ToPILImage()(input_data) # CHW -> HWC and (* 255).byte() + output = trans(img) # HWC -> CHW + expected_output = (input_data * 255).byte() + torch.testing.assert_close(output, expected_output, check_stride=False) + + # separate test for mode '1' PIL images + input_data = torch.ByteTensor(1, height, width).bernoulli_() + img = transforms.ToPILImage()(input_data.mul(255)).convert('1') + output = trans(img).view(torch.uint8).bool().to(torch.uint8) + torch.testing.assert_close(input_data, output, check_stride=False) + + +def test_pil_to_tensor_errors(): + height, width = 4, 4 + trans = transforms.PILToTensor() + + with pytest.raises(TypeError): + trans(np.random.rand(1, height, width).tolist()) + + with pytest.raises(TypeError): + trans(np.random.rand(1, height, width)) + + def test_randomresized_params(): height = random.randint(24, 32) * 2 width = random.randint(24, 32) * 2 From 729fee5c702508192092152ff78b9bc37a7e3abd Mon Sep 17 00:00:00 2001 From: Vivek Kumar <60113444+vivekkumar7089@users.noreply.github.com> Date: Sat, 5 Jun 2021 16:58:49 +0530 Subject: [PATCH 144/279] Port random flip tests to pytest in test_transforms.py (#3971) --- test/test_transforms.py | 234 ++++++++++++++++++++-------------------- 1 file changed, 119 insertions(+), 115 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index d4558c98a69..440a5faedf2 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -734,121 +734,6 @@ def test_ndarray_bad_types_to_pil_image(self): with self.assertRaisesRegex(ValueError, r'pic should not have > 4 channels. Got \d+ channels.'): transforms.ToPILImage()(np.ones([4, 4, 6])) - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_vertical_flip(self): - random_state = random.getstate() - random.seed(42) - img = transforms.ToPILImage()(torch.rand(3, 10, 10)) - vimg = img.transpose(Image.FLIP_TOP_BOTTOM) - - num_samples = 250 - num_vertical = 0 - for _ in range(num_samples): - out = transforms.RandomVerticalFlip()(img) - if out == vimg: - num_vertical += 1 - - p_value = stats.binom_test(num_vertical, num_samples, p=0.5) - random.setstate(random_state) - self.assertGreater(p_value, 0.0001) - - num_samples = 250 - num_vertical = 0 - for _ in range(num_samples): - out = transforms.RandomVerticalFlip(p=0.7)(img) - if out == vimg: - num_vertical += 1 - - p_value = stats.binom_test(num_vertical, num_samples, p=0.7) - random.setstate(random_state) - self.assertGreater(p_value, 0.0001) - - # Checking if RandomVerticalFlip can be printed as string - transforms.RandomVerticalFlip().__repr__() - - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_horizontal_flip(self): - random_state = random.getstate() - random.seed(42) - img = transforms.ToPILImage()(torch.rand(3, 10, 10)) - himg = img.transpose(Image.FLIP_LEFT_RIGHT) - - num_samples = 250 - num_horizontal = 0 - for _ in range(num_samples): - out = transforms.RandomHorizontalFlip()(img) - if out == himg: - num_horizontal += 1 - - p_value = stats.binom_test(num_horizontal, num_samples, p=0.5) - random.setstate(random_state) - self.assertGreater(p_value, 0.0001) - - num_samples = 250 - num_horizontal = 0 - for _ in range(num_samples): - out = transforms.RandomHorizontalFlip(p=0.7)(img) - if out == himg: - num_horizontal += 1 - - p_value = stats.binom_test(num_horizontal, num_samples, p=0.7) - random.setstate(random_state) - self.assertGreater(p_value, 0.0001) - - # Checking if RandomHorizontalFlip can be printed as string - transforms.RandomHorizontalFlip().__repr__() - - @unittest.skipIf(stats is None, 'scipy.stats is not available') - def test_normalize(self): - def samples_from_standard_normal(tensor): - p_value = stats.kstest(list(tensor.view(-1)), 'norm', args=(0, 1)).pvalue - return p_value > 0.0001 - - random_state = random.getstate() - random.seed(42) - for channels in [1, 3]: - img = torch.rand(channels, 10, 10) - mean = [img[c].mean() for c in range(channels)] - std = [img[c].std() for c in range(channels)] - normalized = transforms.Normalize(mean, std)(img) - self.assertTrue(samples_from_standard_normal(normalized)) - random.setstate(random_state) - - # Checking if Normalize can be printed as string - transforms.Normalize(mean, std).__repr__() - - # Checking the optional in-place behaviour - tensor = torch.rand((1, 16, 16)) - tensor_inplace = transforms.Normalize((0.5,), (0.5,), inplace=True)(tensor) - assert_equal(tensor, tensor_inplace) - - def test_normalize_different_dtype(self): - for dtype1 in [torch.float32, torch.float64]: - img = torch.rand(3, 10, 10, dtype=dtype1) - for dtype2 in [torch.int64, torch.float32, torch.float64]: - mean = torch.tensor([1, 2, 3], dtype=dtype2) - std = torch.tensor([1, 2, 1], dtype=dtype2) - # checks that it doesn't crash - transforms.functional.normalize(img, mean, std) - - def test_normalize_3d_tensor(self): - torch.manual_seed(28) - n_channels = 3 - img_size = 10 - mean = torch.rand(n_channels) - std = torch.rand(n_channels) - img = torch.rand(n_channels, img_size, img_size) - target = F.normalize(img, mean, std) - - mean_unsqueezed = mean.view(-1, 1, 1) - std_unsqueezed = std.view(-1, 1, 1) - result1 = F.normalize(img, mean_unsqueezed, std_unsqueezed) - result2 = F.normalize(img, - mean_unsqueezed.repeat(1, img_size, img_size), - std_unsqueezed.repeat(1, img_size, img_size)) - torch.testing.assert_close(target, result1) - torch.testing.assert_close(target, result2) - def test_color_jitter(self): color_jitter = transforms.ColorJitter(2, 2, 2, 0.1) @@ -2025,5 +1910,124 @@ def test_random_order(): random_order_transform.__repr__() +@pytest.mark.skipif(stats is None, reason='scipy.stats not available') +def test_random_vertical_flip(): + random_state = random.getstate() + random.seed(42) + img = transforms.ToPILImage()(torch.rand(3, 10, 10)) + vimg = img.transpose(Image.FLIP_TOP_BOTTOM) + + num_samples = 250 + num_vertical = 0 + for _ in range(num_samples): + out = transforms.RandomVerticalFlip()(img) + if out == vimg: + num_vertical += 1 + + p_value = stats.binom_test(num_vertical, num_samples, p=0.5) + random.setstate(random_state) + assert p_value > 0.0001 + + num_samples = 250 + num_vertical = 0 + for _ in range(num_samples): + out = transforms.RandomVerticalFlip(p=0.7)(img) + if out == vimg: + num_vertical += 1 + + p_value = stats.binom_test(num_vertical, num_samples, p=0.7) + random.setstate(random_state) + assert p_value > 0.0001 + + # Checking if RandomVerticalFlip can be printed as string + transforms.RandomVerticalFlip().__repr__() + + +@pytest.mark.skipif(stats is None, reason='scipy.stats not available') +def test_random_horizontal_flip(): + random_state = random.getstate() + random.seed(42) + img = transforms.ToPILImage()(torch.rand(3, 10, 10)) + himg = img.transpose(Image.FLIP_LEFT_RIGHT) + + num_samples = 250 + num_horizontal = 0 + for _ in range(num_samples): + out = transforms.RandomHorizontalFlip()(img) + if out == himg: + num_horizontal += 1 + + p_value = stats.binom_test(num_horizontal, num_samples, p=0.5) + random.setstate(random_state) + assert p_value > 0.0001 + + num_samples = 250 + num_horizontal = 0 + for _ in range(num_samples): + out = transforms.RandomHorizontalFlip(p=0.7)(img) + if out == himg: + num_horizontal += 1 + + p_value = stats.binom_test(num_horizontal, num_samples, p=0.7) + random.setstate(random_state) + assert p_value > 0.0001 + + # Checking if RandomHorizontalFlip can be printed as string + transforms.RandomHorizontalFlip().__repr__() + + +@pytest.mark.skipif(stats is None, reason='scipy.stats not available') +def test_normalize(): + def samples_from_standard_normal(tensor): + p_value = stats.kstest(list(tensor.view(-1)), 'norm', args=(0, 1)).pvalue + return p_value > 0.0001 + + random_state = random.getstate() + random.seed(42) + for channels in [1, 3]: + img = torch.rand(channels, 10, 10) + mean = [img[c].mean() for c in range(channels)] + std = [img[c].std() for c in range(channels)] + normalized = transforms.Normalize(mean, std)(img) + assert samples_from_standard_normal(normalized) + random.setstate(random_state) + + # Checking if Normalize can be printed as string + transforms.Normalize(mean, std).__repr__() + + # Checking the optional in-place behaviour + tensor = torch.rand((1, 16, 16)) + tensor_inplace = transforms.Normalize((0.5,), (0.5,), inplace=True)(tensor) + assert_equal(tensor, tensor_inplace) + + +@pytest.mark.parametrize('dtype1', [torch.float32, torch.float64]) +@pytest.mark.parametrize('dtype2', [torch.int64, torch.float32, torch.float64]) +def test_normalize_different_dtype(dtype1, dtype2): + img = torch.rand(3, 10, 10, dtype=dtype1) + mean = torch.tensor([1, 2, 3], dtype=dtype2) + std = torch.tensor([1, 2, 1], dtype=dtype2) + # checks that it doesn't crash + transforms.functional.normalize(img, mean, std) + + +def test_normalize_3d_tensor(): + torch.manual_seed(28) + n_channels = 3 + img_size = 10 + mean = torch.rand(n_channels) + std = torch.rand(n_channels) + img = torch.rand(n_channels, img_size, img_size) + target = F.normalize(img, mean, std) + + mean_unsqueezed = mean.view(-1, 1, 1) + std_unsqueezed = std.view(-1, 1, 1) + result1 = F.normalize(img, mean_unsqueezed, std_unsqueezed) + result2 = F.normalize(img, mean_unsqueezed.repeat(1, img_size, img_size), + std_unsqueezed.repeat(1, img_size, img_size)) + torch.testing.assert_close(target, result1) + torch.testing.assert_close(target, result2) + + if __name__ == '__main__': unittest.main() From 453dd2e40d5fe1b2bde56a82e694b28b74f34c9a Mon Sep 17 00:00:00 2001 From: Anirudh Date: Sat, 5 Jun 2021 17:03:04 +0530 Subject: [PATCH 145/279] Port some test_random_xxx in test_transforms to pytest (#3972) --- test/test_transforms.py | 337 ++++++++++++++++++++-------------------- 1 file changed, 172 insertions(+), 165 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index 440a5faedf2..a0279ad3c80 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -202,111 +202,6 @@ def test_ten_crop(self): self.assertEqual(len(results), 10) self.assertEqual(results, expected_output) - def test_randomperspective(self): - for _ in range(10): - height = random.randint(24, 32) * 2 - width = random.randint(24, 32) * 2 - img = torch.ones(3, height, width) - to_pil_image = transforms.ToPILImage() - img = to_pil_image(img) - perp = transforms.RandomPerspective() - startpoints, endpoints = perp.get_params(width, height, 0.5) - tr_img = F.perspective(img, startpoints, endpoints) - tr_img2 = F.to_tensor(F.perspective(tr_img, endpoints, startpoints)) - tr_img = F.to_tensor(tr_img) - self.assertEqual(img.size[0], width) - self.assertEqual(img.size[1], height) - self.assertGreater(torch.nn.functional.mse_loss(tr_img, F.to_tensor(img)) + 0.3, - torch.nn.functional.mse_loss(tr_img2, F.to_tensor(img))) - - def test_randomperspective_fill(self): - - # assert fill being either a Sequence or a Number - with self.assertRaises(TypeError): - transforms.RandomPerspective(fill={}) - - t = transforms.RandomPerspective(fill=None) - self.assertTrue(t.fill == 0) - - height = 100 - width = 100 - img = torch.ones(3, height, width) - to_pil_image = transforms.ToPILImage() - img = to_pil_image(img) - - modes = ("L", "RGB", "F") - nums_bands = [len(mode) for mode in modes] - fill = 127 - - for mode, num_bands in zip(modes, nums_bands): - img_conv = img.convert(mode) - perspective = transforms.RandomPerspective(p=1, fill=fill) - tr_img = perspective(img_conv) - pixel = tr_img.getpixel((0, 0)) - - if not isinstance(pixel, tuple): - pixel = (pixel,) - self.assertTupleEqual(pixel, tuple([fill] * num_bands)) - - for mode, num_bands in zip(modes, nums_bands): - img_conv = img.convert(mode) - startpoints, endpoints = transforms.RandomPerspective.get_params(width, height, 0.5) - tr_img = F.perspective(img_conv, startpoints, endpoints, fill=fill) - pixel = tr_img.getpixel((0, 0)) - - if not isinstance(pixel, tuple): - pixel = (pixel,) - self.assertTupleEqual(pixel, tuple([fill] * num_bands)) - - for wrong_num_bands in set(nums_bands) - {num_bands}: - with self.assertRaises(ValueError): - F.perspective(img_conv, startpoints, endpoints, fill=tuple([fill] * wrong_num_bands)) - - def test_random_crop(self): - height = random.randint(10, 32) * 2 - width = random.randint(10, 32) * 2 - oheight = random.randint(5, (height - 2) / 2) * 2 - owidth = random.randint(5, (width - 2) / 2) * 2 - img = torch.ones(3, height, width) - result = transforms.Compose([ - transforms.ToPILImage(), - transforms.RandomCrop((oheight, owidth)), - transforms.ToTensor(), - ])(img) - self.assertEqual(result.size(1), oheight) - self.assertEqual(result.size(2), owidth) - - padding = random.randint(1, 20) - result = transforms.Compose([ - transforms.ToPILImage(), - transforms.RandomCrop((oheight, owidth), padding=padding), - transforms.ToTensor(), - ])(img) - self.assertEqual(result.size(1), oheight) - self.assertEqual(result.size(2), owidth) - - result = transforms.Compose([ - transforms.ToPILImage(), - transforms.RandomCrop((height, width)), - transforms.ToTensor() - ])(img) - self.assertEqual(result.size(1), height) - self.assertEqual(result.size(2), width) - torch.testing.assert_close(result, img) - - result = transforms.Compose([ - transforms.ToPILImage(), - transforms.RandomCrop((height + 1, width + 1), pad_if_needed=True), - transforms.ToTensor(), - ])(img) - self.assertEqual(result.size(1), height + 1) - self.assertEqual(result.size(2), width + 1) - - t = transforms.RandomCrop(48) - img = torch.ones(3, 32, 32) - with self.assertRaisesRegex(ValueError, r"Required crop size .+ is larger then input image size .+"): - t(img) - def test_max_value(self): for dtype in int_dtypes(): self.assertEqual(F_t._max_value(dtype), torch.iinfo(dtype).max) @@ -888,41 +783,6 @@ def _test_transformation(a, t, s, sh): for sh in range(-15, 15, 5): _test_transformation(a=a, t=(t1, t1), s=s, sh=(sh, sh)) - def test_random_rotation(self): - - with self.assertRaises(ValueError): - transforms.RandomRotation(-0.7) - transforms.RandomRotation([-0.7]) - transforms.RandomRotation([-0.7, 0, 0.7]) - - # assert fill being either a Sequence or a Number - with self.assertRaises(TypeError): - transforms.RandomRotation(0, fill={}) - - t = transforms.RandomRotation(0, fill=None) - self.assertTrue(t.fill == 0) - - t = transforms.RandomRotation(10) - angle = t.get_params(t.degrees) - self.assertTrue(angle > -10 and angle < 10) - - t = transforms.RandomRotation((-10, 10)) - angle = t.get_params(t.degrees) - self.assertTrue(-10 < angle < 10) - - # Checking if RandomRotation can be printed as string - t.__repr__() - - # assert deprecation warning and non-BC - with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"): - t = transforms.RandomRotation((-10, 10), resample=2) - self.assertEqual(t.interpolation, transforms.InterpolationMode.BILINEAR) - - # assert changed type warning - with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): - t = transforms.RandomRotation((-10, 10), interpolation=2) - self.assertEqual(t.interpolation, transforms.InterpolationMode.BILINEAR) - def test_random_affine(self): with self.assertRaises(ValueError): @@ -997,31 +857,6 @@ def test_autoaugment(self): img = transform(img) transform.__repr__() - @unittest.skipIf(stats is None, 'scipy.stats not available') - def test_random_erasing(self): - img = torch.ones(3, 128, 128) - - t = transforms.RandomErasing(scale=(0.1, 0.1), ratio=(1 / 3, 3.)) - y, x, h, w, v = t.get_params(img, t.scale, t.ratio, [t.value, ]) - aspect_ratio = h / w - # Add some tolerance due to the rounding and int conversion used in the transform - tol = 0.05 - self.assertTrue(1 / 3 - tol <= aspect_ratio <= 3 + tol) - - aspect_ratios = [] - random.seed(42) - trial = 1000 - for _ in range(trial): - y, x, h, w, v = t.get_params(img, t.scale, t.ratio, [t.value, ]) - aspect_ratios.append(h / w) - - count_bigger_then_ones = len([1 for aspect_ratio in aspect_ratios if aspect_ratio > 1]) - p_value = stats.binom_test(count_bigger_then_ones, trial, p=0.5) - self.assertGreater(p_value, 0.0001) - - # Checking if RandomErasing can be printed as string - t.__repr__() - @pytest.mark.parametrize('channels', [1, 3, 4]) def test_to_tensor(channels): @@ -1910,6 +1745,178 @@ def test_random_order(): random_order_transform.__repr__() +def test_random_crop(): + height = random.randint(10, 32) * 2 + width = random.randint(10, 32) * 2 + oheight = random.randint(5, (height - 2) / 2) * 2 + owidth = random.randint(5, (width - 2) / 2) * 2 + img = torch.ones(3, height, width) + result = transforms.Compose([ + transforms.ToPILImage(), + transforms.RandomCrop((oheight, owidth)), + transforms.ToTensor(), + ])(img) + assert result.size(1) == oheight + assert result.size(2) == owidth + + padding = random.randint(1, 20) + result = transforms.Compose([ + transforms.ToPILImage(), + transforms.RandomCrop((oheight, owidth), padding=padding), + transforms.ToTensor(), + ])(img) + assert result.size(1) == oheight + assert result.size(2) == owidth + + result = transforms.Compose([ + transforms.ToPILImage(), + transforms.RandomCrop((height, width)), + transforms.ToTensor() + ])(img) + assert result.size(1) == height + assert result.size(2) == width + torch.testing.assert_close(result, img) + + result = transforms.Compose([ + transforms.ToPILImage(), + transforms.RandomCrop((height + 1, width + 1), pad_if_needed=True), + transforms.ToTensor(), + ])(img) + assert result.size(1) == height + 1 + assert result.size(2) == width + 1 + + t = transforms.RandomCrop(48) + img = torch.ones(3, 32, 32) + with pytest.raises(ValueError, match=r"Required crop size .+ is larger then input image size .+"): + t(img) + + +@pytest.mark.skipif(stats is None, reason="scipy.stats not available") +def test_random_erasing(): + img = torch.ones(3, 128, 128) + + t = transforms.RandomErasing(scale=(0.1, 0.1), ratio=(1 / 3, 3.)) + y, x, h, w, v = t.get_params(img, t.scale, t.ratio, [t.value, ]) + aspect_ratio = h / w + # Add some tolerance due to the rounding and int conversion used in the transform + tol = 0.05 + assert (1 / 3 - tol <= aspect_ratio <= 3 + tol) + + aspect_ratios = [] + random.seed(42) + trial = 1000 + for _ in range(trial): + y, x, h, w, v = t.get_params(img, t.scale, t.ratio, [t.value, ]) + aspect_ratios.append(h / w) + + count_bigger_then_ones = len([1 for aspect_ratio in aspect_ratios if aspect_ratio > 1]) + p_value = stats.binom_test(count_bigger_then_ones, trial, p=0.5) + assert p_value > 0.0001 + + # Checking if RandomErasing can be printed as string + t.__repr__() + + +def test_random_rotation(): + + with pytest.raises(ValueError): + transforms.RandomRotation(-0.7) + + with pytest.raises(ValueError): + transforms.RandomRotation([-0.7]) + + with pytest.raises(ValueError): + transforms.RandomRotation([-0.7, 0, 0.7]) + + t = transforms.RandomRotation(0, fill=None) + assert t.fill == 0 + + t = transforms.RandomRotation(10) + angle = t.get_params(t.degrees) + assert (angle > -10 and angle < 10) + + t = transforms.RandomRotation((-10, 10)) + angle = t.get_params(t.degrees) + assert (-10 < angle < 10) + + # Checking if RandomRotation can be printed as string + t.__repr__() + + # assert deprecation warning and non-BC + with pytest.warns(UserWarning, match=r"Argument resample is deprecated and will be removed"): + t = transforms.RandomRotation((-10, 10), resample=2) + assert t.interpolation == transforms.InterpolationMode.BILINEAR + + # assert changed type warning + with pytest.warns(UserWarning, match=r"Argument interpolation should be of type InterpolationMode"): + t = transforms.RandomRotation((-10, 10), interpolation=2) + assert t.interpolation == transforms.InterpolationMode.BILINEAR + + +def test_random_rotation_error(): + # assert fill being either a Sequence or a Number + with pytest.raises(TypeError): + transforms.RandomRotation(0, fill={}) + + +def test_randomperspective(): + for _ in range(10): + height = random.randint(24, 32) * 2 + width = random.randint(24, 32) * 2 + img = torch.ones(3, height, width) + to_pil_image = transforms.ToPILImage() + img = to_pil_image(img) + perp = transforms.RandomPerspective() + startpoints, endpoints = perp.get_params(width, height, 0.5) + tr_img = F.perspective(img, startpoints, endpoints) + tr_img2 = F.to_tensor(F.perspective(tr_img, endpoints, startpoints)) + tr_img = F.to_tensor(tr_img) + assert img.size[0] == width + assert img.size[1] == height + assert (torch.nn.functional.mse_loss(tr_img, F.to_tensor(img)) + 0.3 > + torch.nn.functional.mse_loss(tr_img2, F.to_tensor(img))) + + +@pytest.mark.parametrize('mode', ["L", "RGB", "F"]) +def test_randomperspective_fill(mode): + + # assert fill being either a Sequence or a Number + with pytest.raises(TypeError): + transforms.RandomPerspective(fill={}) + + t = transforms.RandomPerspective(fill=None) + assert t.fill == 0 + + height = 100 + width = 100 + img = torch.ones(3, height, width) + to_pil_image = transforms.ToPILImage() + img = to_pil_image(img) + fill = 127 + num_bands = len(mode) + + img_conv = img.convert(mode) + perspective = transforms.RandomPerspective(p=1, fill=fill) + tr_img = perspective(img_conv) + pixel = tr_img.getpixel((0, 0)) + + if not isinstance(pixel, tuple): + pixel = (pixel,) + assert pixel == tuple([fill] * num_bands) + + startpoints, endpoints = transforms.RandomPerspective.get_params(width, height, 0.5) + tr_img = F.perspective(img_conv, startpoints, endpoints, fill=fill) + pixel = tr_img.getpixel((0, 0)) + + if not isinstance(pixel, tuple): + pixel = (pixel,) + assert pixel == tuple([fill] * num_bands) + + wrong_num_bands = num_bands + 1 + with pytest.raises(ValueError): + F.perspective(img_conv, startpoints, endpoints, fill=tuple([fill] * wrong_num_bands)) + + @pytest.mark.skipif(stats is None, reason='scipy.stats not available') def test_random_vertical_flip(): random_state = random.getstate() From 02e5bb406456457d74ae73ad5ade796c3d209c5f Mon Sep 17 00:00:00 2001 From: Zhiqiang Wang Date: Sat, 5 Jun 2021 23:04:52 +0800 Subject: [PATCH 146/279] Port the xxx_to_pil_image tests in test_transforms.py to pytest (#3959) --- test/test_transforms.py | 544 ++++++++++++++++++++++------------------ 1 file changed, 299 insertions(+), 245 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index a0279ad3c80..bf3a030f285 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -384,251 +384,6 @@ def test_accimage_crop(self): self.assertEqual(expected_output.size(), output.size()) torch.testing.assert_close(output, expected_output) - def test_1_channel_tensor_to_pil_image(self): - to_tensor = transforms.ToTensor() - - img_data_float = torch.Tensor(1, 4, 4).uniform_() - img_data_byte = torch.ByteTensor(1, 4, 4).random_(0, 255) - img_data_short = torch.ShortTensor(1, 4, 4).random_() - img_data_int = torch.IntTensor(1, 4, 4).random_() - - inputs = [img_data_float, img_data_byte, img_data_short, img_data_int] - expected_outputs = [img_data_float.mul(255).int().float().div(255).numpy(), - img_data_byte.float().div(255.0).numpy(), - img_data_short.numpy(), - img_data_int.numpy()] - expected_modes = ['L', 'L', 'I;16', 'I'] - - for img_data, expected_output, mode in zip(inputs, expected_outputs, expected_modes): - for transform in [transforms.ToPILImage(), transforms.ToPILImage(mode=mode)]: - img = transform(img_data) - self.assertEqual(img.mode, mode) - torch.testing.assert_close(expected_output, to_tensor(img).numpy(), check_stride=False) - # 'F' mode for torch.FloatTensor - img_F_mode = transforms.ToPILImage(mode='F')(img_data_float) - self.assertEqual(img_F_mode.mode, 'F') - torch.testing.assert_close( - np.array(Image.fromarray(img_data_float.squeeze(0).numpy(), mode='F')), np.array(img_F_mode) - ) - - def test_1_channel_ndarray_to_pil_image(self): - img_data_float = torch.Tensor(4, 4, 1).uniform_().numpy() - img_data_byte = torch.ByteTensor(4, 4, 1).random_(0, 255).numpy() - img_data_short = torch.ShortTensor(4, 4, 1).random_().numpy() - img_data_int = torch.IntTensor(4, 4, 1).random_().numpy() - - inputs = [img_data_float, img_data_byte, img_data_short, img_data_int] - expected_modes = ['F', 'L', 'I;16', 'I'] - for img_data, mode in zip(inputs, expected_modes): - for transform in [transforms.ToPILImage(), transforms.ToPILImage(mode=mode)]: - img = transform(img_data) - self.assertEqual(img.mode, mode) - # note: we explicitly convert img's dtype because pytorch doesn't support uint16 - # and otherwise assert_close wouldn't be able to construct a tensor from the uint16 array - torch.testing.assert_close(img_data[:, :, 0], np.asarray(img).astype(img_data.dtype)) - - def test_2_channel_ndarray_to_pil_image(self): - def verify_img_data(img_data, mode): - if mode is None: - img = transforms.ToPILImage()(img_data) - self.assertEqual(img.mode, 'LA') # default should assume LA - else: - img = transforms.ToPILImage(mode=mode)(img_data) - self.assertEqual(img.mode, mode) - split = img.split() - for i in range(2): - torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) - - img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy() - for mode in [None, 'LA']: - verify_img_data(img_data, mode) - - transforms.ToPILImage().__repr__() - - with self.assertRaises(ValueError): - # should raise if we try a mode for 4 or 1 or 3 channel images - transforms.ToPILImage(mode='RGBA')(img_data) - transforms.ToPILImage(mode='P')(img_data) - transforms.ToPILImage(mode='RGB')(img_data) - - def test_2_channel_tensor_to_pil_image(self): - def verify_img_data(img_data, expected_output, mode): - if mode is None: - img = transforms.ToPILImage()(img_data) - self.assertEqual(img.mode, 'LA') # default should assume LA - else: - img = transforms.ToPILImage(mode=mode)(img_data) - self.assertEqual(img.mode, mode) - split = img.split() - for i in range(2): - self.assertTrue(np.allclose(expected_output[i].numpy(), F.to_tensor(split[i]).numpy())) - - img_data = torch.Tensor(2, 4, 4).uniform_() - expected_output = img_data.mul(255).int().float().div(255) - for mode in [None, 'LA']: - verify_img_data(img_data, expected_output, mode=mode) - - with self.assertRaises(ValueError): - # should raise if we try a mode for 4 or 1 or 3 channel images - transforms.ToPILImage(mode='RGBA')(img_data) - transforms.ToPILImage(mode='P')(img_data) - transforms.ToPILImage(mode='RGB')(img_data) - - def test_3_channel_tensor_to_pil_image(self): - def verify_img_data(img_data, expected_output, mode): - if mode is None: - img = transforms.ToPILImage()(img_data) - self.assertEqual(img.mode, 'RGB') # default should assume RGB - else: - img = transforms.ToPILImage(mode=mode)(img_data) - self.assertEqual(img.mode, mode) - split = img.split() - for i in range(3): - self.assertTrue(np.allclose(expected_output[i].numpy(), F.to_tensor(split[i]).numpy())) - - img_data = torch.Tensor(3, 4, 4).uniform_() - expected_output = img_data.mul(255).int().float().div(255) - for mode in [None, 'RGB', 'HSV', 'YCbCr']: - verify_img_data(img_data, expected_output, mode=mode) - - with self.assertRaises(ValueError): - # should raise if we try a mode for 4 or 1 or 2 channel images - transforms.ToPILImage(mode='RGBA')(img_data) - transforms.ToPILImage(mode='P')(img_data) - transforms.ToPILImage(mode='LA')(img_data) - - with self.assertRaises(ValueError): - transforms.ToPILImage()(torch.Tensor(1, 3, 4, 4).uniform_()) - - def test_3_channel_ndarray_to_pil_image(self): - def verify_img_data(img_data, mode): - if mode is None: - img = transforms.ToPILImage()(img_data) - self.assertEqual(img.mode, 'RGB') # default should assume RGB - else: - img = transforms.ToPILImage(mode=mode)(img_data) - self.assertEqual(img.mode, mode) - split = img.split() - for i in range(3): - torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) - - img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy() - for mode in [None, 'RGB', 'HSV', 'YCbCr']: - verify_img_data(img_data, mode) - - # Checking if ToPILImage can be printed as string - transforms.ToPILImage().__repr__() - - with self.assertRaises(ValueError): - # should raise if we try a mode for 4 or 1 or 2 channel images - transforms.ToPILImage(mode='RGBA')(img_data) - transforms.ToPILImage(mode='P')(img_data) - transforms.ToPILImage(mode='LA')(img_data) - - def test_4_channel_tensor_to_pil_image(self): - def verify_img_data(img_data, expected_output, mode): - if mode is None: - img = transforms.ToPILImage()(img_data) - self.assertEqual(img.mode, 'RGBA') # default should assume RGBA - else: - img = transforms.ToPILImage(mode=mode)(img_data) - self.assertEqual(img.mode, mode) - - split = img.split() - for i in range(4): - self.assertTrue(np.allclose(expected_output[i].numpy(), F.to_tensor(split[i]).numpy())) - - img_data = torch.Tensor(4, 4, 4).uniform_() - expected_output = img_data.mul(255).int().float().div(255) - for mode in [None, 'RGBA', 'CMYK', 'RGBX']: - verify_img_data(img_data, expected_output, mode) - - with self.assertRaises(ValueError): - # should raise if we try a mode for 3 or 1 or 2 channel images - transforms.ToPILImage(mode='RGB')(img_data) - transforms.ToPILImage(mode='P')(img_data) - transforms.ToPILImage(mode='LA')(img_data) - - def test_4_channel_ndarray_to_pil_image(self): - def verify_img_data(img_data, mode): - if mode is None: - img = transforms.ToPILImage()(img_data) - self.assertEqual(img.mode, 'RGBA') # default should assume RGBA - else: - img = transforms.ToPILImage(mode=mode)(img_data) - self.assertEqual(img.mode, mode) - split = img.split() - for i in range(4): - torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) - - img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy() - for mode in [None, 'RGBA', 'CMYK', 'RGBX']: - verify_img_data(img_data, mode) - - with self.assertRaises(ValueError): - # should raise if we try a mode for 3 or 1 or 2 channel images - transforms.ToPILImage(mode='RGB')(img_data) - transforms.ToPILImage(mode='P')(img_data) - transforms.ToPILImage(mode='LA')(img_data) - - def test_2d_tensor_to_pil_image(self): - to_tensor = transforms.ToTensor() - - img_data_float = torch.Tensor(4, 4).uniform_() - img_data_byte = torch.ByteTensor(4, 4).random_(0, 255) - img_data_short = torch.ShortTensor(4, 4).random_() - img_data_int = torch.IntTensor(4, 4).random_() - - inputs = [img_data_float, img_data_byte, img_data_short, img_data_int] - expected_outputs = [img_data_float.mul(255).int().float().div(255).numpy(), - img_data_byte.float().div(255.0).numpy(), - img_data_short.numpy(), - img_data_int.numpy()] - expected_modes = ['L', 'L', 'I;16', 'I'] - - for img_data, expected_output, mode in zip(inputs, expected_outputs, expected_modes): - for transform in [transforms.ToPILImage(), transforms.ToPILImage(mode=mode)]: - img = transform(img_data) - self.assertEqual(img.mode, mode) - np.testing.assert_allclose(expected_output, to_tensor(img).numpy()[0]) - - def test_2d_ndarray_to_pil_image(self): - img_data_float = torch.Tensor(4, 4).uniform_().numpy() - img_data_byte = torch.ByteTensor(4, 4).random_(0, 255).numpy() - img_data_short = torch.ShortTensor(4, 4).random_().numpy() - img_data_int = torch.IntTensor(4, 4).random_().numpy() - - inputs = [img_data_float, img_data_byte, img_data_short, img_data_int] - expected_modes = ['F', 'L', 'I;16', 'I'] - for img_data, mode in zip(inputs, expected_modes): - for transform in [transforms.ToPILImage(), transforms.ToPILImage(mode=mode)]: - img = transform(img_data) - self.assertEqual(img.mode, mode) - np.testing.assert_allclose(img_data, img) - - def test_tensor_bad_types_to_pil_image(self): - with self.assertRaisesRegex(ValueError, r'pic should be 2/3 dimensional. Got \d+ dimensions.'): - transforms.ToPILImage()(torch.ones(1, 3, 4, 4)) - with self.assertRaisesRegex(ValueError, r'pic should not have > 4 channels. Got \d+ channels.'): - transforms.ToPILImage()(torch.ones(6, 4, 4)) - - def test_ndarray_bad_types_to_pil_image(self): - trans = transforms.ToPILImage() - reg_msg = r'Input type \w+ is not supported' - with self.assertRaisesRegex(TypeError, reg_msg): - trans(np.ones([4, 4, 1], np.int64)) - with self.assertRaisesRegex(TypeError, reg_msg): - trans(np.ones([4, 4, 1], np.uint16)) - with self.assertRaisesRegex(TypeError, reg_msg): - trans(np.ones([4, 4, 1], np.uint32)) - with self.assertRaisesRegex(TypeError, reg_msg): - trans(np.ones([4, 4, 1], np.float64)) - - with self.assertRaisesRegex(ValueError, r'pic should be 2/3 dimensional. Got \d+ dimensions.'): - transforms.ToPILImage()(np.ones([1, 4, 4, 3])) - with self.assertRaisesRegex(ValueError, r'pic should not have > 4 channels. Got \d+ channels.'): - transforms.ToPILImage()(np.ones([4, 4, 6])) - def test_color_jitter(self): color_jitter = transforms.ColorJitter(2, 2, 2, 0.1) @@ -1200,6 +955,305 @@ def test_randomness(fn, trans, config, p): assert p_value > 0.0001 +def _get_1_channel_tensor_various_types(): + img_data_float = torch.Tensor(1, 4, 4).uniform_() + expected_output = img_data_float.mul(255).int().float().div(255).numpy() + yield img_data_float, expected_output, 'L' + + img_data_byte = torch.ByteTensor(1, 4, 4).random_(0, 255) + expected_output = img_data_byte.float().div(255.0).numpy() + yield img_data_byte, expected_output, 'L' + + img_data_short = torch.ShortTensor(1, 4, 4).random_() + expected_output = img_data_short.numpy() + yield img_data_short, expected_output, 'I;16' + + img_data_int = torch.IntTensor(1, 4, 4).random_() + expected_output = img_data_int.numpy() + yield img_data_int, expected_output, 'I' + + +@pytest.mark.parametrize('with_mode', [False, True]) +@pytest.mark.parametrize('img_data, expected_output, expected_mode', _get_1_channel_tensor_various_types()) +def test_1_channel_tensor_to_pil_image(with_mode, img_data, expected_output, expected_mode): + transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() + to_tensor = transforms.ToTensor() + + img = transform(img_data) + assert img.mode == expected_mode + torch.testing.assert_close(expected_output, to_tensor(img).numpy(), check_stride=False) + + +def test_1_channel_float_tensor_to_pil_image(): + img_data = torch.Tensor(1, 4, 4).uniform_() + # 'F' mode for torch.FloatTensor + img_F_mode = transforms.ToPILImage(mode='F')(img_data) + assert img_F_mode.mode == 'F' + torch.testing.assert_close( + np.array(Image.fromarray(img_data.squeeze(0).numpy(), mode='F')), np.array(img_F_mode) + ) + + +@pytest.mark.parametrize('with_mode', [False, True]) +@pytest.mark.parametrize('img_data, expected_mode', [ + (torch.Tensor(4, 4, 1).uniform_().numpy(), 'F'), + (torch.ByteTensor(4, 4, 1).random_(0, 255).numpy(), 'L'), + (torch.ShortTensor(4, 4, 1).random_().numpy(), 'I;16'), + (torch.IntTensor(4, 4, 1).random_().numpy(), 'I'), +]) +def test_1_channel_ndarray_to_pil_image(with_mode, img_data, expected_mode): + transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() + img = transform(img_data) + assert img.mode == expected_mode + # note: we explicitly convert img's dtype because pytorch doesn't support uint16 + # and otherwise assert_close wouldn't be able to construct a tensor from the uint16 array + torch.testing.assert_close(img_data[:, :, 0], np.asarray(img).astype(img_data.dtype)) + + +@pytest.mark.parametrize('expected_mode', [None, 'LA']) +def test_2_channel_ndarray_to_pil_image(expected_mode): + img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy() + + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'LA' # default should assume LA + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + split = img.split() + for i in range(2): + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) + + +def test_2_channel_ndarray_to_pil_image_error(): + img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy() + transforms.ToPILImage().__repr__() + + # should raise if we try a mode for 4 or 1 or 3 channel images + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='RGBA')(img_data) + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='RGB')(img_data) + + +@pytest.mark.parametrize('expected_mode', [None, 'LA']) +def test_2_channel_tensor_to_pil_image(expected_mode): + img_data = torch.Tensor(2, 4, 4).uniform_() + expected_output = img_data.mul(255).int().float().div(255) + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'LA' # default should assume LA + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + + split = img.split() + for i in range(2): + torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy()) + + +def test_2_channel_tensor_to_pil_image_error(): + img_data = torch.Tensor(2, 4, 4).uniform_() + + # should raise if we try a mode for 4 or 1 or 3 channel images + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='RGBA')(img_data) + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='RGB')(img_data) + + +def _get_2d_tensor_various_types(): + img_data_float = torch.Tensor(4, 4).uniform_() + expected_output = img_data_float.mul(255).int().float().div(255).numpy() + yield img_data_float, expected_output, 'L' + + img_data_byte = torch.ByteTensor(4, 4).random_(0, 255) + expected_output = img_data_byte.float().div(255.0).numpy() + yield img_data_byte, expected_output, 'L' + + img_data_short = torch.ShortTensor(4, 4).random_() + expected_output = img_data_short.numpy() + yield img_data_short, expected_output, 'I;16' + + img_data_int = torch.IntTensor(4, 4).random_() + expected_output = img_data_int.numpy() + yield img_data_int, expected_output, 'I' + + +@pytest.mark.parametrize('with_mode', [False, True]) +@pytest.mark.parametrize('img_data, expected_output, expected_mode', _get_2d_tensor_various_types()) +def test_2d_tensor_to_pil_image(with_mode, img_data, expected_output, expected_mode): + transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() + to_tensor = transforms.ToTensor() + + img = transform(img_data) + assert img.mode == expected_mode + torch.testing.assert_close(expected_output, to_tensor(img).numpy()[0]) + + +@pytest.mark.parametrize('with_mode', [False, True]) +@pytest.mark.parametrize('img_data, expected_mode', [ + (torch.Tensor(4, 4).uniform_().numpy(), 'F'), + (torch.ByteTensor(4, 4).random_(0, 255).numpy(), 'L'), + (torch.ShortTensor(4, 4).random_().numpy(), 'I;16'), + (torch.IntTensor(4, 4).random_().numpy(), 'I'), +]) +def test_2d_ndarray_to_pil_image(with_mode, img_data, expected_mode): + transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() + img = transform(img_data) + assert img.mode == expected_mode + np.testing.assert_allclose(img_data, img) + + +@pytest.mark.parametrize('expected_mode', [None, 'RGB', 'HSV', 'YCbCr']) +def test_3_channel_tensor_to_pil_image(expected_mode): + img_data = torch.Tensor(3, 4, 4).uniform_() + expected_output = img_data.mul(255).int().float().div(255) + + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'RGB' # default should assume RGB + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + split = img.split() + for i in range(3): + torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy()) + + +def test_3_channel_tensor_to_pil_image_error(): + img_data = torch.Tensor(3, 4, 4).uniform_() + error_message_3d = r"Only modes \['RGB', 'YCbCr', 'HSV'\] are supported for 3D inputs" + # should raise if we try a mode for 4 or 1 or 2 channel images + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='RGBA')(img_data) + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='LA')(img_data) + + with pytest.raises(ValueError, match=r'pic should be 2/3 dimensional. Got \d+ dimensions.'): + transforms.ToPILImage()(torch.Tensor(1, 3, 4, 4).uniform_()) + + +@pytest.mark.parametrize('expected_mode', [None, 'RGB', 'HSV', 'YCbCr']) +def test_3_channel_ndarray_to_pil_image(expected_mode): + img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy() + + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'RGB' # default should assume RGB + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + split = img.split() + for i in range(3): + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) + + +def test_3_channel_ndarray_to_pil_image_error(): + img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy() + + # Checking if ToPILImage can be printed as string + transforms.ToPILImage().__repr__() + + error_message_3d = r"Only modes \['RGB', 'YCbCr', 'HSV'\] are supported for 3D inputs" + # should raise if we try a mode for 4 or 1 or 2 channel images + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='RGBA')(img_data) + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='LA')(img_data) + + +@pytest.mark.parametrize('expected_mode', [None, 'RGBA', 'CMYK', 'RGBX']) +def test_4_channel_tensor_to_pil_image(expected_mode): + img_data = torch.Tensor(4, 4, 4).uniform_() + expected_output = img_data.mul(255).int().float().div(255) + + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'RGBA' # default should assume RGBA + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + + split = img.split() + for i in range(4): + torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy()) + + +def test_4_channel_tensor_to_pil_image_error(): + img_data = torch.Tensor(4, 4, 4).uniform_() + + error_message_4d = r"Only modes \['RGBA', 'CMYK', 'RGBX'\] are supported for 4D inputs" + # should raise if we try a mode for 3 or 1 or 2 channel images + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='RGB')(img_data) + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='LA')(img_data) + + +@pytest.mark.parametrize('expected_mode', [None, 'RGBA', 'CMYK', 'RGBX']) +def test_4_channel_ndarray_to_pil_image(expected_mode): + img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy() + + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'RGBA' # default should assume RGBA + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + split = img.split() + for i in range(4): + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) + + +def test_4_channel_ndarray_to_pil_image_error(): + img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy() + + error_message_4d = r"Only modes \['RGBA', 'CMYK', 'RGBX'\] are supported for 4D inputs" + # should raise if we try a mode for 3 or 1 or 2 channel images + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='RGB')(img_data) + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='LA')(img_data) + + +def test_ndarray_bad_types_to_pil_image(): + trans = transforms.ToPILImage() + reg_msg = r'Input type \w+ is not supported' + with pytest.raises(TypeError, match=reg_msg): + trans(np.ones([4, 4, 1], np.int64)) + with pytest.raises(TypeError, match=reg_msg): + trans(np.ones([4, 4, 1], np.uint16)) + with pytest.raises(TypeError, match=reg_msg): + trans(np.ones([4, 4, 1], np.uint32)) + with pytest.raises(TypeError, match=reg_msg): + trans(np.ones([4, 4, 1], np.float64)) + + with pytest.raises(ValueError, match=r'pic should be 2/3 dimensional. Got \d+ dimensions.'): + transforms.ToPILImage()(np.ones([1, 4, 4, 3])) + with pytest.raises(ValueError, match=r'pic should not have > 4 channels. Got \d+ channels.'): + transforms.ToPILImage()(np.ones([4, 4, 6])) + + +def test_tensor_bad_types_to_pil_image(): + with pytest.raises(ValueError, match=r'pic should be 2/3 dimensional. Got \d+ dimensions.'): + transforms.ToPILImage()(torch.ones(1, 3, 4, 4)) + with pytest.raises(ValueError, match=r'pic should not have > 4 channels. Got \d+ channels.'): + transforms.ToPILImage()(torch.ones(6, 4, 4)) + + def test_adjust_brightness(): x_shape = [2, 2, 3] x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] From 6cb73eb3f7af884ce77f4040c1772d026833910f Mon Sep 17 00:00:00 2001 From: Sahil Goyal <59660566+sahilg06@users.noreply.github.com> Date: Sun, 6 Jun 2021 01:06:25 +0530 Subject: [PATCH 147/279] port some tests in test_functional_tensor to pytest (#3977) --- test/test_functional_tensor.py | 279 +++++++++++++++++---------------- 1 file changed, 141 insertions(+), 138 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 66605811fdb..3222148da24 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -36,82 +36,6 @@ class Tester(unittest.TestCase): def setUp(self): self.device = "cpu" - def test_assert_image_tensor(self): - shape = (100,) - tensor = torch.rand(*shape, dtype=torch.float, device=self.device) - - list_of_methods = [(F_t._get_image_size, (tensor, )), (F_t.vflip, (tensor, )), - (F_t.hflip, (tensor, )), (F_t.crop, (tensor, 1, 2, 4, 5)), - (F_t.adjust_brightness, (tensor, 0.)), (F_t.adjust_contrast, (tensor, 1.)), - (F_t.adjust_hue, (tensor, -0.5)), (F_t.adjust_saturation, (tensor, 2.)), - (F_t.center_crop, (tensor, [10, 11])), (F_t.five_crop, (tensor, [10, 11])), - (F_t.ten_crop, (tensor, [10, 11])), (F_t.pad, (tensor, [2, ], 2, "constant")), - (F_t.resize, (tensor, [10, 11])), (F_t.perspective, (tensor, [0.2, ])), - (F_t.gaussian_blur, (tensor, (2, 2), (0.7, 0.5))), - (F_t.invert, (tensor, )), (F_t.posterize, (tensor, 0)), - (F_t.solarize, (tensor, 0.3)), (F_t.adjust_sharpness, (tensor, 0.3)), - (F_t.autocontrast, (tensor, )), (F_t.equalize, (tensor, ))] - - for func, args in list_of_methods: - with self.assertRaises(Exception) as context: - func(*args) - - self.assertTrue('Tensor is not a torch image.' in str(context.exception)) - - def test_vflip(self): - script_vflip = torch.jit.script(F.vflip) - - img_tensor, pil_img = _create_data(16, 18, device=self.device) - vflipped_img = F.vflip(img_tensor) - vflipped_pil_img = F.vflip(pil_img) - _assert_equal_tensor_to_pil(vflipped_img, vflipped_pil_img) - - # scriptable function test - vflipped_img_script = script_vflip(img_tensor) - assert_equal(vflipped_img, vflipped_img_script) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - _test_fn_on_batch(batch_tensors, F.vflip) - - def test_hflip(self): - script_hflip = torch.jit.script(F.hflip) - - img_tensor, pil_img = _create_data(16, 18, device=self.device) - hflipped_img = F.hflip(img_tensor) - hflipped_pil_img = F.hflip(pil_img) - _assert_equal_tensor_to_pil(hflipped_img, hflipped_pil_img) - - # scriptable function test - hflipped_img_script = script_hflip(img_tensor) - assert_equal(hflipped_img, hflipped_img_script) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - _test_fn_on_batch(batch_tensors, F.hflip) - - def test_crop(self): - script_crop = torch.jit.script(F.crop) - - img_tensor, pil_img = _create_data(16, 18, device=self.device) - - test_configs = [ - (1, 2, 4, 5), # crop inside top-left corner - (2, 12, 3, 4), # crop inside top-right corner - (8, 3, 5, 6), # crop inside bottom-left corner - (8, 11, 4, 3), # crop inside bottom-right corner - ] - - for top, left, height, width in test_configs: - pil_img_cropped = F.crop(pil_img, top, left, height, width) - - img_tensor_cropped = F.crop(img_tensor, top, left, height, width) - _assert_equal_tensor_to_pil(img_tensor_cropped, pil_img_cropped) - - img_tensor_cropped = script_crop(img_tensor, top, left, height, width) - _assert_equal_tensor_to_pil(img_tensor_cropped, pil_img_cropped) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - _test_fn_on_batch(batch_tensors, F.crop, top=top, left=left, height=height, width=width) - def test_hsv2rgb(self): scripted_fn = torch.jit.script(F_t._hsv2rgb) shape = (3, 100, 150) @@ -610,68 +534,6 @@ def test_rotate(self): res2 = F.rotate(tensor, 45, interpolation=BILINEAR) assert_equal(res1, res2) - def test_gaussian_blur(self): - small_image_tensor = torch.from_numpy( - np.arange(3 * 10 * 12, dtype="uint8").reshape((10, 12, 3)) - ).permute(2, 0, 1).to(self.device) - - large_image_tensor = torch.from_numpy( - np.arange(26 * 28, dtype="uint8").reshape((1, 26, 28)) - ).to(self.device) - - scripted_transform = torch.jit.script(F.gaussian_blur) - - # true_cv2_results = { - # # np_img = np.arange(3 * 10 * 12, dtype="uint8").reshape((10, 12, 3)) - # # cv2.GaussianBlur(np_img, ksize=(3, 3), sigmaX=0.8) - # "3_3_0.8": ... - # # cv2.GaussianBlur(np_img, ksize=(3, 3), sigmaX=0.5) - # "3_3_0.5": ... - # # cv2.GaussianBlur(np_img, ksize=(3, 5), sigmaX=0.8) - # "3_5_0.8": ... - # # cv2.GaussianBlur(np_img, ksize=(3, 5), sigmaX=0.5) - # "3_5_0.5": ... - # # np_img2 = np.arange(26 * 28, dtype="uint8").reshape((26, 28)) - # # cv2.GaussianBlur(np_img2, ksize=(23, 23), sigmaX=1.7) - # "23_23_1.7": ... - # } - p = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'assets', 'gaussian_blur_opencv_results.pt') - true_cv2_results = torch.load(p) - - for tensor in [small_image_tensor, large_image_tensor]: - - for dt in [None, torch.float32, torch.float64, torch.float16]: - if dt == torch.float16 and torch.device(self.device).type == "cpu": - # skip float16 on CPU case - continue - - if dt is not None: - tensor = tensor.to(dtype=dt) - - for ksize in [(3, 3), [3, 5], (23, 23)]: - for sigma in [[0.5, 0.5], (0.5, 0.5), (0.8, 0.8), (1.7, 1.7)]: - - _ksize = (ksize, ksize) if isinstance(ksize, int) else ksize - _sigma = sigma[0] if sigma is not None else None - shape = tensor.shape - gt_key = "{}_{}_{}__{}_{}_{}".format( - shape[-2], shape[-1], shape[-3], - _ksize[0], _ksize[1], _sigma - ) - if gt_key not in true_cv2_results: - continue - - true_out = torch.tensor( - true_cv2_results[gt_key] - ).reshape(shape[-2], shape[-1], shape[-3]).permute(2, 0, 1).to(tensor) - - for fn in [F.gaussian_blur, scripted_transform]: - out = fn(tensor, kernel_size=ksize, sigma=sigma) - torch.testing.assert_close( - out, true_out, rtol=0.0, atol=1.0, check_stride=False, - msg="{}, {}".format(ksize, sigma) - ) - @unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device") class CUDATester(Tester): @@ -1141,5 +1003,146 @@ def test_adjust_gamma(device, dtype, config): ) +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('func, args', [ + (F_t._get_image_size, ()), (F_t.vflip, ()), + (F_t.hflip, ()), (F_t.crop, (1, 2, 4, 5)), + (F_t.adjust_brightness, (0., )), (F_t.adjust_contrast, (1., )), + (F_t.adjust_hue, (-0.5, )), (F_t.adjust_saturation, (2., )), + (F_t.center_crop, ([10, 11], )), (F_t.five_crop, ([10, 11], )), + (F_t.ten_crop, ([10, 11], )), (F_t.pad, ([2, ], 2, "constant")), + (F_t.resize, ([10, 11], )), (F_t.perspective, ([0.2, ])), + (F_t.gaussian_blur, ((2, 2), (0.7, 0.5))), + (F_t.invert, ()), (F_t.posterize, (0, )), + (F_t.solarize, (0.3, )), (F_t.adjust_sharpness, (0.3, )), + (F_t.autocontrast, ()), (F_t.equalize, ()) +]) +def test_assert_image_tensor(device, func, args): + shape = (100,) + tensor = torch.rand(*shape, dtype=torch.float, device=device) + with pytest.raises(Exception, match=r"Tensor is not a torch image."): + func(tensor, *args) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_vflip(device): + script_vflip = torch.jit.script(F.vflip) + + img_tensor, pil_img = _create_data(16, 18, device=device) + vflipped_img = F.vflip(img_tensor) + vflipped_pil_img = F.vflip(pil_img) + _assert_equal_tensor_to_pil(vflipped_img, vflipped_pil_img) + + # scriptable function test + vflipped_img_script = script_vflip(img_tensor) + assert_equal(vflipped_img, vflipped_img_script) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + _test_fn_on_batch(batch_tensors, F.vflip) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_hflip(device): + script_hflip = torch.jit.script(F.hflip) + + img_tensor, pil_img = _create_data(16, 18, device=device) + hflipped_img = F.hflip(img_tensor) + hflipped_pil_img = F.hflip(pil_img) + _assert_equal_tensor_to_pil(hflipped_img, hflipped_pil_img) + + # scriptable function test + hflipped_img_script = script_hflip(img_tensor) + assert_equal(hflipped_img, hflipped_img_script) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + _test_fn_on_batch(batch_tensors, F.hflip) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('top, left, height, width', [ + (1, 2, 4, 5), # crop inside top-left corner + (2, 12, 3, 4), # crop inside top-right corner + (8, 3, 5, 6), # crop inside bottom-left corner + (8, 11, 4, 3), # crop inside bottom-right corner +]) +def test_crop(device, top, left, height, width): + script_crop = torch.jit.script(F.crop) + + img_tensor, pil_img = _create_data(16, 18, device=device) + + pil_img_cropped = F.crop(pil_img, top, left, height, width) + + img_tensor_cropped = F.crop(img_tensor, top, left, height, width) + _assert_equal_tensor_to_pil(img_tensor_cropped, pil_img_cropped) + + img_tensor_cropped = script_crop(img_tensor, top, left, height, width) + _assert_equal_tensor_to_pil(img_tensor_cropped, pil_img_cropped) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + _test_fn_on_batch(batch_tensors, F.crop, top=top, left=left, height=height, width=width) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('image_size', ('small', 'large')) +@pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) +@pytest.mark.parametrize('ksize', [(3, 3), [3, 5], (23, 23)]) +@pytest.mark.parametrize('sigma', [[0.5, 0.5], (0.5, 0.5), (0.8, 0.8), (1.7, 1.7)]) +@pytest.mark.parametrize('fn', [F.gaussian_blur, torch.jit.script(F.gaussian_blur)]) +def test_gaussian_blur(device, image_size, dt, ksize, sigma, fn): + + # true_cv2_results = { + # # np_img = np.arange(3 * 10 * 12, dtype="uint8").reshape((10, 12, 3)) + # # cv2.GaussianBlur(np_img, ksize=(3, 3), sigmaX=0.8) + # "3_3_0.8": ... + # # cv2.GaussianBlur(np_img, ksize=(3, 3), sigmaX=0.5) + # "3_3_0.5": ... + # # cv2.GaussianBlur(np_img, ksize=(3, 5), sigmaX=0.8) + # "3_5_0.8": ... + # # cv2.GaussianBlur(np_img, ksize=(3, 5), sigmaX=0.5) + # "3_5_0.5": ... + # # np_img2 = np.arange(26 * 28, dtype="uint8").reshape((26, 28)) + # # cv2.GaussianBlur(np_img2, ksize=(23, 23), sigmaX=1.7) + # "23_23_1.7": ... + # } + p = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'assets', 'gaussian_blur_opencv_results.pt') + true_cv2_results = torch.load(p) + + if image_size == 'small': + tensor = torch.from_numpy( + np.arange(3 * 10 * 12, dtype="uint8").reshape((10, 12, 3)) + ).permute(2, 0, 1).to(device) + else: + tensor = torch.from_numpy( + np.arange(26 * 28, dtype="uint8").reshape((1, 26, 28)) + ).to(device) + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + if dt is not None: + tensor = tensor.to(dtype=dt) + + _ksize = (ksize, ksize) if isinstance(ksize, int) else ksize + _sigma = sigma[0] if sigma is not None else None + shape = tensor.shape + gt_key = "{}_{}_{}__{}_{}_{}".format( + shape[-2], shape[-1], shape[-3], + _ksize[0], _ksize[1], _sigma + ) + if gt_key not in true_cv2_results: + return + + true_out = torch.tensor( + true_cv2_results[gt_key] + ).reshape(shape[-2], shape[-1], shape[-3]).permute(2, 0, 1).to(tensor) + + out = fn(tensor, kernel_size=ksize, sigma=sigma) + torch.testing.assert_close( + out, true_out, rtol=0.0, atol=1.0, check_stride=False, + msg="{}, {}".format(ksize, sigma) + ) + + if __name__ == '__main__': unittest.main() From a2329ff653094150ee1c127411c678c01c198ee4 Mon Sep 17 00:00:00 2001 From: Saswat Das Date: Sun, 6 Jun 2021 14:22:47 +0530 Subject: [PATCH 148/279] port pad, resized_crop and test_affine in test_functional_tensor to pytest (#3974) --- test/test_functional_tensor.py | 550 +++++++++++++++++---------------- 1 file changed, 291 insertions(+), 259 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 3222148da24..0329542981e 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -191,265 +191,6 @@ def test_ten_crop(self): for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): assert_equal(transformed_batch, s_transformed_batch) - def test_pad(self): - script_fn = torch.jit.script(F.pad) - tensor, pil_img = _create_data(7, 8, device=self.device) - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - - for dt in [None, torch.float32, torch.float64, torch.float16]: - - if dt == torch.float16 and torch.device(self.device).type == "cpu": - # skip float16 on CPU case - continue - - if dt is not None: - # This is a trivial cast to float of uint8 data to test all cases - tensor = tensor.to(dt) - batch_tensors = batch_tensors.to(dt) - - for pad in [2, [3, ], [0, 3], (3, 3), [4, 2, 4, 3]]: - configs = [ - {"padding_mode": "constant", "fill": 0}, - {"padding_mode": "constant", "fill": 10}, - {"padding_mode": "constant", "fill": 20}, - {"padding_mode": "edge"}, - {"padding_mode": "reflect"}, - {"padding_mode": "symmetric"}, - ] - for kwargs in configs: - pad_tensor = F_t.pad(tensor, pad, **kwargs) - pad_pil_img = F_pil.pad(pil_img, pad, **kwargs) - - pad_tensor_8b = pad_tensor - # we need to cast to uint8 to compare with PIL image - if pad_tensor_8b.dtype != torch.uint8: - pad_tensor_8b = pad_tensor_8b.to(torch.uint8) - - _assert_equal_tensor_to_pil(pad_tensor_8b, pad_pil_img, msg="{}, {}".format(pad, kwargs)) - - if isinstance(pad, int): - script_pad = [pad, ] - else: - script_pad = pad - pad_tensor_script = script_fn(tensor, script_pad, **kwargs) - assert_equal(pad_tensor, pad_tensor_script, msg="{}, {}".format(pad, kwargs)) - - _test_fn_on_batch(batch_tensors, F.pad, padding=script_pad, **kwargs) - - def test_resized_crop(self): - # test values of F.resized_crop in several cases: - # 1) resize to the same size, crop to the same size => should be identity - tensor, _ = _create_data(26, 36, device=self.device) - - for mode in [NEAREST, BILINEAR, BICUBIC]: - out_tensor = F.resized_crop(tensor, top=0, left=0, height=26, width=36, size=[26, 36], interpolation=mode) - assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) - - # 2) resize by half and crop a TL corner - tensor, _ = _create_data(26, 36, device=self.device) - out_tensor = F.resized_crop(tensor, top=0, left=0, height=20, width=30, size=[10, 15], interpolation=NEAREST) - expected_out_tensor = tensor[:, :20:2, :30:2] - assert_equal( - expected_out_tensor, - out_tensor, - check_stride=False, - msg="{} vs {}".format(expected_out_tensor[0, :10, :10], out_tensor[0, :10, :10]), - ) - - batch_tensors = _create_data_batch(26, 36, num_samples=4, device=self.device) - _test_fn_on_batch( - batch_tensors, F.resized_crop, top=1, left=2, height=20, width=30, size=[10, 15], interpolation=NEAREST - ) - - def _test_affine_identity_map(self, tensor, scripted_affine): - # 1) identity map - out_tensor = F.affine(tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST) - - assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) - out_tensor = scripted_affine( - tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST - ) - assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) - - def _test_affine_square_rotations(self, tensor, pil_img, scripted_affine): - # 2) Test rotation - test_configs = [ - (90, torch.rot90(tensor, k=1, dims=(-1, -2))), - (45, None), - (30, None), - (-30, None), - (-45, None), - (-90, torch.rot90(tensor, k=-1, dims=(-1, -2))), - (180, torch.rot90(tensor, k=2, dims=(-1, -2))), - ] - for a, true_tensor in test_configs: - out_pil_img = F.affine( - pil_img, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST - ) - out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))).to(self.device) - - for fn in [F.affine, scripted_affine]: - out_tensor = fn( - tensor, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST - ) - if true_tensor is not None: - assert_equal( - true_tensor, - out_tensor, - msg="{}\n{} vs \n{}".format(a, out_tensor[0, :5, :5], true_tensor[0, :5, :5]), - check_stride=False, - ) - - if out_tensor.dtype != torch.uint8: - out_tensor = out_tensor.to(torch.uint8) - - num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 - ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] - # Tolerance : less than 6% of different pixels - self.assertLess( - ratio_diff_pixels, - 0.06, - msg="{}\n{} vs \n{}".format( - ratio_diff_pixels, out_tensor[0, :7, :7], out_pil_tensor[0, :7, :7] - ) - ) - - def _test_affine_rect_rotations(self, tensor, pil_img, scripted_affine): - test_configs = [ - 90, 45, 15, -30, -60, -120 - ] - for a in test_configs: - - out_pil_img = F.affine( - pil_img, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST - ) - out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) - - for fn in [F.affine, scripted_affine]: - out_tensor = fn( - tensor, angle=a, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST - ).cpu() - - if out_tensor.dtype != torch.uint8: - out_tensor = out_tensor.to(torch.uint8) - - num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 - ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] - # Tolerance : less than 3% of different pixels - self.assertLess( - ratio_diff_pixels, - 0.03, - msg="{}: {}\n{} vs \n{}".format( - a, ratio_diff_pixels, out_tensor[0, :7, :7], out_pil_tensor[0, :7, :7] - ) - ) - - def _test_affine_translations(self, tensor, pil_img, scripted_affine): - # 3) Test translation - test_configs = [ - [10, 12], (-12, -13) - ] - for t in test_configs: - - out_pil_img = F.affine(pil_img, angle=0, translate=t, scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST) - - for fn in [F.affine, scripted_affine]: - out_tensor = fn(tensor, angle=0, translate=t, scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST) - - if out_tensor.dtype != torch.uint8: - out_tensor = out_tensor.to(torch.uint8) - - _assert_equal_tensor_to_pil(out_tensor, out_pil_img) - - def _test_affine_all_ops(self, tensor, pil_img, scripted_affine): - # 4) Test rotation + translation + scale + share - test_configs = [ - (45.5, [5, 6], 1.0, [0.0, 0.0], None), - (33, (5, -4), 1.0, [0.0, 0.0], [0, 0, 0]), - (45, [-5, 4], 1.2, [0.0, 0.0], (1, 2, 3)), - (33, (-4, -8), 2.0, [0.0, 0.0], [255, 255, 255]), - (85, (10, -10), 0.7, [0.0, 0.0], [1, ]), - (0, [0, 0], 1.0, [35.0, ], (2.0, )), - (-25, [0, 0], 1.2, [0.0, 15.0], None), - (-45, [-10, 0], 0.7, [2.0, 5.0], None), - (-45, [-10, -10], 1.2, [4.0, 5.0], None), - (-90, [0, 0], 1.0, [0.0, 0.0], None), - ] - for r in [NEAREST, ]: - for a, t, s, sh, f in test_configs: - f_pil = int(f[0]) if f is not None and len(f) == 1 else f - out_pil_img = F.affine(pil_img, angle=a, translate=t, scale=s, shear=sh, interpolation=r, fill=f_pil) - out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) - - for fn in [F.affine, scripted_affine]: - out_tensor = fn(tensor, angle=a, translate=t, scale=s, shear=sh, interpolation=r, fill=f).cpu() - - if out_tensor.dtype != torch.uint8: - out_tensor = out_tensor.to(torch.uint8) - - num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 - ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] - # Tolerance : less than 5% (cpu), 6% (cuda) of different pixels - tol = 0.06 if self.device == "cuda" else 0.05 - self.assertLess( - ratio_diff_pixels, - tol, - msg="{}: {}\n{} vs \n{}".format( - (r, a, t, s, sh, f), ratio_diff_pixels, out_tensor[0, :7, :7], out_pil_tensor[0, :7, :7] - ) - ) - - def test_affine(self): - # Tests on square and rectangular images - scripted_affine = torch.jit.script(F.affine) - - data = [_create_data(26, 26, device=self.device), _create_data(32, 26, device=self.device)] - for tensor, pil_img in data: - - for dt in [None, torch.float32, torch.float64, torch.float16]: - - if dt == torch.float16 and torch.device(self.device).type == "cpu": - # skip float16 on CPU case - continue - - if dt is not None: - tensor = tensor.to(dtype=dt) - - self._test_affine_identity_map(tensor, scripted_affine) - if pil_img.size[0] == pil_img.size[1]: - self._test_affine_square_rotations(tensor, pil_img, scripted_affine) - else: - self._test_affine_rect_rotations(tensor, pil_img, scripted_affine) - self._test_affine_translations(tensor, pil_img, scripted_affine) - self._test_affine_all_ops(tensor, pil_img, scripted_affine) - - batch_tensors = _create_data_batch(26, 36, num_samples=4, device=self.device) - if dt is not None: - batch_tensors = batch_tensors.to(dtype=dt) - - _test_fn_on_batch( - batch_tensors, F.affine, angle=-43, translate=[-3, 4], scale=1.2, shear=[4.0, 5.0] - ) - - tensor, pil_img = data[0] - # assert deprecation warning and non-BC - with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"): - res1 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=2) - res2 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=BILINEAR) - assert_equal(res1, res2) - - # assert changed type warning - with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): - res1 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=2) - res2 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=BILINEAR) - assert_equal(res1, res2) - - with self.assertWarnsRegex(UserWarning, r"Argument fillcolor is deprecated and will be removed"): - res1 = F.affine(pil_img, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], fillcolor=10) - res2 = F.affine(pil_img, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], fill=10) - # we convert the PIL images to numpy as assert_equal doesn't work on PIL images. - assert_equal(np.asarray(res1), np.asarray(res2)) - def _test_rotate_all_options(self, tensor, pil_img, scripted_rotate, centers): img_size = pil_img.size dt = tensor.dtype @@ -554,6 +295,225 @@ def test_scale_channel(self): assert_equal(scaled_cpu, scaled_cuda.to('cpu')) +class TestAffine: + + ALL_DTYPES = [None, torch.float32, torch.float64, torch.float16] + scripted_affine = torch.jit.script(F.affine) + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('height, width', [(26, 26), (32, 26)]) + @pytest.mark.parametrize('dt', ALL_DTYPES) + def test_identity_map(self, device, height, width, dt): + # Tests on square and rectangular images + tensor, pil_img = _create_data(height, width, device=device) + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + if dt is not None: + tensor = tensor.to(dtype=dt) + + # 1) identity map + out_tensor = F.affine(tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST) + + assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) + out_tensor = self.scripted_affine( + tensor, angle=0, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST + ) + assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('height, width', [(26, 26)]) + @pytest.mark.parametrize('dt', ALL_DTYPES) + @pytest.mark.parametrize('angle, config', [ + (90, {'k': 1, 'dims': (-1, -2)}), + (45, None), + (30, None), + (-30, None), + (-45, None), + (-90, {'k': -1, 'dims': (-1, -2)}), + (180, {'k': 2, 'dims': (-1, -2)}), + ]) + @pytest.mark.parametrize('fn', [F.affine, scripted_affine]) + def test_square_rotations(self, device, height, width, dt, angle, config, fn): + # 2) Test rotation + tensor, pil_img = _create_data(height, width, device=device) + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + if dt is not None: + tensor = tensor.to(dtype=dt) + + out_pil_img = F.affine( + pil_img, angle=angle, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST + ) + out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))).to(device) + + out_tensor = fn( + tensor, angle=angle, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST + ) + if config is not None: + assert_equal( + torch.rot90(tensor, **config), + out_tensor, + check_stride=False, + ) + + if out_tensor.dtype != torch.uint8: + out_tensor = out_tensor.to(torch.uint8) + + num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 + ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] + # Tolerance : less than 6% of different pixels + assert ratio_diff_pixels < 0.06, "{}\n{} vs \n{}".format( + ratio_diff_pixels, out_tensor[0, :7, :7], out_pil_tensor[0, :7, :7] + ) + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('height, width', [(32, 26)]) + @pytest.mark.parametrize('dt', ALL_DTYPES) + @pytest.mark.parametrize('angle', [90, 45, 15, -30, -60, -120]) + @pytest.mark.parametrize('fn', [F.affine, scripted_affine]) + def test_rect_rotations(self, device, height, width, dt, angle, fn): + # Tests on rectangular images + tensor, pil_img = _create_data(height, width, device=device) + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + if dt is not None: + tensor = tensor.to(dtype=dt) + + out_pil_img = F.affine( + pil_img, angle=angle, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST + ) + out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) + + out_tensor = fn( + tensor, angle=angle, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST + ).cpu() + + if out_tensor.dtype != torch.uint8: + out_tensor = out_tensor.to(torch.uint8) + + num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 + ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] + # Tolerance : less than 3% of different pixels + assert ratio_diff_pixels < 0.03, "{}: {}\n{} vs \n{}".format( + angle, ratio_diff_pixels, out_tensor[0, :7, :7], out_pil_tensor[0, :7, :7] + ) + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('height, width', [(26, 26), (32, 26)]) + @pytest.mark.parametrize('dt', ALL_DTYPES) + @pytest.mark.parametrize('t', [[10, 12], (-12, -13)]) + @pytest.mark.parametrize('fn', [F.affine, scripted_affine]) + def test_translations(self, device, height, width, dt, t, fn): + # 3) Test translation + tensor, pil_img = _create_data(height, width, device=device) + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + if dt is not None: + tensor = tensor.to(dtype=dt) + + out_pil_img = F.affine(pil_img, angle=0, translate=t, scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST) + + out_tensor = fn(tensor, angle=0, translate=t, scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST) + + if out_tensor.dtype != torch.uint8: + out_tensor = out_tensor.to(torch.uint8) + + _assert_equal_tensor_to_pil(out_tensor, out_pil_img) + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('height, width', [(26, 26), (32, 26)]) + @pytest.mark.parametrize('dt', ALL_DTYPES) + @pytest.mark.parametrize('a, t, s, sh, f', [ + (45.5, [5, 6], 1.0, [0.0, 0.0], None), + (33, (5, -4), 1.0, [0.0, 0.0], [0, 0, 0]), + (45, [-5, 4], 1.2, [0.0, 0.0], (1, 2, 3)), + (33, (-4, -8), 2.0, [0.0, 0.0], [255, 255, 255]), + (85, (10, -10), 0.7, [0.0, 0.0], [1, ]), + (0, [0, 0], 1.0, [35.0, ], (2.0, )), + (-25, [0, 0], 1.2, [0.0, 15.0], None), + (-45, [-10, 0], 0.7, [2.0, 5.0], None), + (-45, [-10, -10], 1.2, [4.0, 5.0], None), + (-90, [0, 0], 1.0, [0.0, 0.0], None), + ]) + @pytest.mark.parametrize('fn', [F.affine, scripted_affine]) + def test_all_ops(self, device, height, width, dt, a, t, s, sh, f, fn): + # 4) Test rotation + translation + scale + shear + tensor, pil_img = _create_data(height, width, device=device) + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + if dt is not None: + tensor = tensor.to(dtype=dt) + + f_pil = int(f[0]) if f is not None and len(f) == 1 else f + out_pil_img = F.affine(pil_img, angle=a, translate=t, scale=s, shear=sh, interpolation=NEAREST, fill=f_pil) + out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) + + out_tensor = fn(tensor, angle=a, translate=t, scale=s, shear=sh, interpolation=NEAREST, fill=f).cpu() + + if out_tensor.dtype != torch.uint8: + out_tensor = out_tensor.to(torch.uint8) + + num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 + ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] + # Tolerance : less than 5% (cpu), 6% (cuda) of different pixels + tol = 0.06 if device == "cuda" else 0.05 + assert ratio_diff_pixels < tol, "{}: {}\n{} vs \n{}".format( + (i, a, t, s, sh, f), ratio_diff_pixels, out_tensor[0, :7, :7], out_pil_tensor[0, :7, :7] + ) + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('dt', ALL_DTYPES) + def test_batches(self, device, dt): + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + batch_tensors = _create_data_batch(26, 36, num_samples=4, device=device) + if dt is not None: + batch_tensors = batch_tensors.to(dtype=dt) + + _test_fn_on_batch( + batch_tensors, F.affine, angle=-43, translate=[-3, 4], scale=1.2, shear=[4.0, 5.0] + ) + + @pytest.mark.parametrize('device', cpu_and_gpu()) + def test_warnings(self, device): + tensor, pil_img = _create_data(26, 26, device=device) + + # assert deprecation warning and non-BC + with pytest.warns(UserWarning, match=r"Argument resample is deprecated and will be removed"): + res1 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], resample=2) + res2 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=BILINEAR) + assert_equal(res1, res2) + + # assert changed type warning + with pytest.warns(UserWarning, match=r"Argument interpolation should be of type InterpolationMode"): + res1 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=2) + res2 = F.affine(tensor, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=BILINEAR) + assert_equal(res1, res2) + + with pytest.warns(UserWarning, match=r"Argument fillcolor is deprecated and will be removed"): + res1 = F.affine(pil_img, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], fillcolor=10) + res2 = F.affine(pil_img, 45, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], fill=10) + # we convert the PIL images to numpy as assert_equal doesn't work on PIL images. + assert_equal(np.asarray(res1), np.asarray(res2)) + + def _get_data_dims_and_points_for_perspective(): # Ideally we would parametrize independently over data dims and points, but # we want to tests on some points that also depend on the data dims. @@ -1003,6 +963,78 @@ def test_adjust_gamma(device, dtype, config): ) +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('dt', [None, torch.float32, torch.float64, torch.float16]) +@pytest.mark.parametrize('pad', [2, [3, ], [0, 3], (3, 3), [4, 2, 4, 3]]) +@pytest.mark.parametrize('config', [ + {"padding_mode": "constant", "fill": 0}, + {"padding_mode": "constant", "fill": 10}, + {"padding_mode": "constant", "fill": 20}, + {"padding_mode": "edge"}, + {"padding_mode": "reflect"}, + {"padding_mode": "symmetric"}, +]) +def test_pad(device, dt, pad, config): + script_fn = torch.jit.script(F.pad) + tensor, pil_img = _create_data(7, 8, device=device) + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + if dt is not None: + # This is a trivial cast to float of uint8 data to test all cases + tensor = tensor.to(dt) + batch_tensors = batch_tensors.to(dt) + + pad_tensor = F_t.pad(tensor, pad, **config) + pad_pil_img = F_pil.pad(pil_img, pad, **config) + + pad_tensor_8b = pad_tensor + # we need to cast to uint8 to compare with PIL image + if pad_tensor_8b.dtype != torch.uint8: + pad_tensor_8b = pad_tensor_8b.to(torch.uint8) + + _assert_equal_tensor_to_pil(pad_tensor_8b, pad_pil_img, msg="{}, {}".format(pad, config)) + + if isinstance(pad, int): + script_pad = [pad, ] + else: + script_pad = pad + pad_tensor_script = script_fn(tensor, script_pad, **config) + assert_equal(pad_tensor, pad_tensor_script, msg="{}, {}".format(pad, config)) + + _test_fn_on_batch(batch_tensors, F.pad, padding=script_pad, **config) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('mode', [NEAREST, BILINEAR, BICUBIC]) +def test_resized_crop(device, mode): + # test values of F.resized_crop in several cases: + # 1) resize to the same size, crop to the same size => should be identity + tensor, _ = _create_data(26, 36, device=device) + + out_tensor = F.resized_crop(tensor, top=0, left=0, height=26, width=36, size=[26, 36], interpolation=mode) + assert_equal(tensor, out_tensor, msg="{} vs {}".format(out_tensor[0, :5, :5], tensor[0, :5, :5])) + + # 2) resize by half and crop a TL corner + tensor, _ = _create_data(26, 36, device=device) + out_tensor = F.resized_crop(tensor, top=0, left=0, height=20, width=30, size=[10, 15], interpolation=NEAREST) + expected_out_tensor = tensor[:, :20:2, :30:2] + assert_equal( + expected_out_tensor, + out_tensor, + check_stride=False, + msg="{} vs {}".format(expected_out_tensor[0, :10, :10], out_tensor[0, :10, :10]), + ) + + batch_tensors = _create_data_batch(26, 36, num_samples=4, device=device) + _test_fn_on_batch( + batch_tensors, F.resized_crop, top=1, left=2, height=20, width=30, size=[10, 15], interpolation=NEAREST + ) + + @pytest.mark.parametrize('device', cpu_and_gpu()) @pytest.mark.parametrize('func, args', [ (F_t._get_image_size, ()), (F_t.vflip, ()), From 44fefe60281219d8022308693053c1ae15b9c5ba Mon Sep 17 00:00:00 2001 From: Anirudh Date: Mon, 7 Jun 2021 14:57:05 +0530 Subject: [PATCH 149/279] Port test_models to pytest (#3978) --- test/test_models.py | 740 ++++++++++++++++++++++---------------------- 1 file changed, 371 insertions(+), 369 deletions(-) diff --git a/test/test_models.py b/test/test_models.py index 3a335f6c3a6..4f021d323b2 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -1,19 +1,16 @@ import os import io import sys -from common_utils import TestCase, map_nested_tensor_object, freeze_rng_state, set_rng_seed +from common_utils import map_nested_tensor_object, freeze_rng_state, set_rng_seed, cpu_and_gpu, needs_cuda, cpu_only from _utils_internal import get_relative_path from collections import OrderedDict -from itertools import product import functools import operator import torch import torch.nn as nn from torchvision import models -import unittest -import warnings - import pytest +import warnings ACCEPT = os.getenv('EXPECTTEST_ACCEPT', '0') == '1' @@ -220,399 +217,404 @@ def get_export_import_copy(m): } -class ModelTester(TestCase): - def _test_classification_model(self, name, dev): - set_rng_seed(0) - defaults = { - 'num_classes': 50, - 'input_shape': (1, 3, 224, 224), - } - kwargs = {**defaults, **_model_params.get(name, {})} - input_shape = kwargs.pop('input_shape') - - model = models.__dict__[name](**kwargs) - model.eval().to(device=dev) - # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests - x = torch.rand(input_shape).to(device=dev) - out = model(x) - _assert_expected(out.cpu(), name, prec=0.1) - self.assertEqual(out.shape[-1], 50) - _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) - - if dev == torch.device("cuda"): - with torch.cuda.amp.autocast(): - out = model(x) - # See autocast_flaky_numerics comment at top of file. - if name not in autocast_flaky_numerics: - _assert_expected(out.cpu(), name, prec=0.1) - self.assertEqual(out.shape[-1], 50) - - def _test_segmentation_model(self, name, dev): - set_rng_seed(0) - defaults = { - 'num_classes': 10, - 'pretrained_backbone': False, - 'input_shape': (1, 3, 32, 32), - } - kwargs = {**defaults, **_model_params.get(name, {})} - input_shape = kwargs.pop('input_shape') - - model = models.segmentation.__dict__[name](**kwargs) - model.eval().to(device=dev) - # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests - x = torch.rand(input_shape).to(device=dev) - out = model(x)["out"] - - def check_out(out): - prec = 0.01 - try: - # We first try to assert the entire output if possible. This is not - # only the best way to assert results but also handles the cases - # where we need to create a new expected result. - _assert_expected(out.cpu(), name, prec=prec) - except AssertionError: - # Unfortunately some segmentation models are flaky with autocast - # so instead of validating the probability scores, check that the class - # predictions match. - expected_file = _get_expected_file(name) - expected = torch.load(expected_file) - torch.testing.assert_close(out.argmax(dim=1), expected.argmax(dim=1), rtol=prec, atol=prec) - return False # Partial validation performed - - return True # Full validation performed - - full_validation = check_out(out) - - _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) - - if dev == torch.device("cuda"): - with torch.cuda.amp.autocast(): - out = model(x)["out"] - # See autocast_flaky_numerics comment at top of file. - if name not in autocast_flaky_numerics: - full_validation &= check_out(out) - - if not full_validation: - msg = "The output of {} could only be partially validated. " \ - "This is likely due to unit-test flakiness, but you may " \ - "want to do additional manual checks if you made " \ - "significant changes to the codebase.".format(self._testMethodName) - warnings.warn(msg, RuntimeWarning) - raise unittest.SkipTest(msg) - - def _test_detection_model(self, name, dev): - set_rng_seed(0) - defaults = { - 'num_classes': 50, - 'pretrained_backbone': False, - 'input_shape': (3, 300, 300), - } - kwargs = {**defaults, **_model_params.get(name, {})} - input_shape = kwargs.pop('input_shape') - - model = models.detection.__dict__[name](**kwargs) - model.eval().to(device=dev) - # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests - x = torch.rand(input_shape).to(device=dev) - model_input = [x] - out = model(model_input) - self.assertIs(model_input[0], x) - - def check_out(out): - self.assertEqual(len(out), 1) - - def compact(tensor): - size = tensor.size() - elements_per_sample = functools.reduce(operator.mul, size[1:], 1) - if elements_per_sample > 30: - return compute_mean_std(tensor) - else: - return subsample_tensor(tensor) - - def subsample_tensor(tensor): - num_elems = tensor.size(0) - num_samples = 20 - if num_elems <= num_samples: - return tensor - - ith_index = num_elems // num_samples - return tensor[ith_index - 1::ith_index] - - def compute_mean_std(tensor): - # can't compute mean of integral tensor - tensor = tensor.to(torch.double) - mean = torch.mean(tensor) - std = torch.std(tensor) - return {"mean": mean, "std": std} - - output = map_nested_tensor_object(out, tensor_map_fn=compact) - prec = 0.01 - try: - # We first try to assert the entire output if possible. This is not - # only the best way to assert results but also handles the cases - # where we need to create a new expected result. - _assert_expected(output, name, prec=prec) - except AssertionError: - # Unfortunately detection models are flaky due to the unstable sort - # in NMS. If matching across all outputs fails, use the same approach - # as in NMSTester.test_nms_cuda to see if this is caused by duplicate - # scores. - expected_file = _get_expected_file(name) - expected = torch.load(expected_file) - torch.testing.assert_close(output[0]["scores"], expected[0]["scores"], rtol=prec, atol=prec, - check_device=False, check_dtype=False) - - # Note: Fmassa proposed turning off NMS by adapting the threshold - # and then using the Hungarian algorithm as in DETR to find the - # best match between output and expected boxes and eliminate some - # of the flakiness. Worth exploring. - return False # Partial validation performed - - return True # Full validation performed - - full_validation = check_out(out) - _check_jit_scriptable(model, ([x],), unwrapper=script_model_unwrapper.get(name, None)) - - if dev == torch.device("cuda"): - with torch.cuda.amp.autocast(): - out = model(model_input) - # See autocast_flaky_numerics comment at top of file. - if name not in autocast_flaky_numerics: - full_validation &= check_out(out) - - if not full_validation: - msg = "The output of {} could only be partially validated. " \ - "This is likely due to unit-test flakiness, but you may " \ - "want to do additional manual checks if you made " \ - "significant changes to the codebase.".format(self._testMethodName) - warnings.warn(msg, RuntimeWarning) - raise unittest.SkipTest(msg) - - def _test_detection_model_validation(self, name): - set_rng_seed(0) - model = models.detection.__dict__[name](num_classes=50, pretrained_backbone=False) - input_shape = (3, 300, 300) - x = [torch.rand(input_shape)] - - # validate that targets are present in training - self.assertRaises(ValueError, model, x) - - # validate type - targets = [{'boxes': 0.}] - self.assertRaises(ValueError, model, x, targets=targets) - - # validate boxes shape - for boxes in (torch.rand((4,)), torch.rand((1, 5))): - targets = [{'boxes': boxes}] - self.assertRaises(ValueError, model, x, targets=targets) - - # validate that no degenerate boxes are present - boxes = torch.tensor([[1, 3, 1, 4], [2, 4, 3, 4]]) - targets = [{'boxes': boxes}] - self.assertRaises(ValueError, model, x, targets=targets) - - def _test_video_model(self, name, dev): - # the default input shape is - # bs * num_channels * clip_len * h *w - input_shape = (1, 3, 4, 112, 112) - # test both basicblock and Bottleneck - model = models.video.__dict__[name](num_classes=50) - model.eval().to(device=dev) - # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests - x = torch.rand(input_shape).to(device=dev) - out = model(x) - _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) - self.assertEqual(out.shape[-1], 50) - - if dev == torch.device("cuda"): - with torch.cuda.amp.autocast(): - out = model(x) - self.assertEqual(out.shape[-1], 50) - - def _make_sliced_model(self, model, stop_layer): - layers = OrderedDict() - for name, layer in model.named_children(): - layers[name] = layer - if name == stop_layer: - break - new_model = torch.nn.Sequential(layers) - return new_model - - def test_memory_efficient_densenet(self): - input_shape = (1, 3, 300, 300) - x = torch.rand(input_shape) - - for name in ['densenet121', 'densenet169', 'densenet201', 'densenet161']: - model1 = models.__dict__[name](num_classes=50, memory_efficient=True) - params = model1.state_dict() - num_params = sum([x.numel() for x in model1.parameters()]) - model1.eval() - out1 = model1(x) - out1.sum().backward() - num_grad = sum([x.grad.numel() for x in model1.parameters() if x.grad is not None]) - - model2 = models.__dict__[name](num_classes=50, memory_efficient=False) - model2.load_state_dict(params) - model2.eval() - out2 = model2(x) - - self.assertTrue(num_params == num_grad) - torch.testing.assert_close(out1, out2, rtol=0.0, atol=1e-5) - - def test_resnet_dilation(self): - # TODO improve tests to also check that each layer has the right dimensionality - for i in product([False, True], [False, True], [False, True]): - model = models.__dict__["resnet50"](replace_stride_with_dilation=i) - model = self._make_sliced_model(model, stop_layer="layer4") - model.eval() - x = torch.rand(1, 3, 224, 224) - out = model(x) - f = 2 ** sum(i) - self.assertEqual(out.shape, (1, 2048, 7 * f, 7 * f)) - - def test_mobilenet_v2_residual_setting(self): - model = models.__dict__["mobilenet_v2"](inverted_residual_setting=[[1, 16, 1, 1], [6, 24, 2, 2]]) - model.eval() - x = torch.rand(1, 3, 224, 224) - out = model(x) - self.assertEqual(out.shape[-1], 1000) - - def test_mobilenet_norm_layer(self): - for name in ["mobilenet_v2", "mobilenet_v3_large", "mobilenet_v3_small"]: - model = models.__dict__[name]() - self.assertTrue(any(isinstance(x, nn.BatchNorm2d) for x in model.modules())) - - def get_gn(num_channels): - return nn.GroupNorm(32, num_channels) - - model = models.__dict__[name](norm_layer=get_gn) - self.assertFalse(any(isinstance(x, nn.BatchNorm2d) for x in model.modules())) - self.assertTrue(any(isinstance(x, nn.GroupNorm) for x in model.modules())) - - def test_inception_v3_eval(self): - # replacement for models.inception_v3(pretrained=True) that does not download weights - kwargs = {} - kwargs['transform_input'] = True - kwargs['aux_logits'] = True - kwargs['init_weights'] = False - name = "inception_v3" - model = models.Inception3(**kwargs) - model.aux_logits = False - model.AuxLogits = None - model = model.eval() - x = torch.rand(1, 3, 299, 299) - _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) - - def test_fasterrcnn_double(self): - model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50, pretrained_backbone=False) - model.double() - model.eval() - input_shape = (3, 300, 300) - x = torch.rand(input_shape, dtype=torch.float64) - model_input = [x] +def _make_sliced_model(model, stop_layer): + layers = OrderedDict() + for name, layer in model.named_children(): + layers[name] = layer + if name == stop_layer: + break + new_model = torch.nn.Sequential(layers) + return new_model + + +@cpu_only +@pytest.mark.parametrize('model_name', ['densenet121', 'densenet169', 'densenet201', 'densenet161']) +def test_memory_efficient_densenet(model_name): + input_shape = (1, 3, 300, 300) + x = torch.rand(input_shape) + + model1 = models.__dict__[model_name](num_classes=50, memory_efficient=True) + params = model1.state_dict() + num_params = sum([x.numel() for x in model1.parameters()]) + model1.eval() + out1 = model1(x) + out1.sum().backward() + num_grad = sum([x.grad.numel() for x in model1.parameters() if x.grad is not None]) + + model2 = models.__dict__[model_name](num_classes=50, memory_efficient=False) + model2.load_state_dict(params) + model2.eval() + out2 = model2(x) + + assert num_params == num_grad + torch.testing.assert_close(out1, out2, rtol=0.0, atol=1e-5) + + +@cpu_only +@pytest.mark.parametrize('dilate_layer_2', (True, False)) +@pytest.mark.parametrize('dilate_layer_3', (True, False)) +@pytest.mark.parametrize('dilate_layer_4', (True, False)) +def test_resnet_dilation(dilate_layer_2, dilate_layer_3, dilate_layer_4): + # TODO improve tests to also check that each layer has the right dimensionality + model = models.__dict__["resnet50"](replace_stride_with_dilation=(dilate_layer_2, dilate_layer_3, dilate_layer_4)) + model = _make_sliced_model(model, stop_layer="layer4") + model.eval() + x = torch.rand(1, 3, 224, 224) + out = model(x) + f = 2 ** sum((dilate_layer_2, dilate_layer_3, dilate_layer_4)) + assert out.shape == (1, 2048, 7 * f, 7 * f) + + +@cpu_only +def test_mobilenet_v2_residual_setting(): + model = models.__dict__["mobilenet_v2"](inverted_residual_setting=[[1, 16, 1, 1], [6, 24, 2, 2]]) + model.eval() + x = torch.rand(1, 3, 224, 224) + out = model(x) + assert out.shape[-1] == 1000 + + +@cpu_only +@pytest.mark.parametrize('model_name', ["mobilenet_v2", "mobilenet_v3_large", "mobilenet_v3_small"]) +def test_mobilenet_norm_layer(model_name): + model = models.__dict__[model_name]() + assert any(isinstance(x, nn.BatchNorm2d) for x in model.modules()) + + def get_gn(num_channels): + return nn.GroupNorm(32, num_channels) + + model = models.__dict__[model_name](norm_layer=get_gn) + assert not(any(isinstance(x, nn.BatchNorm2d) for x in model.modules())) + assert any(isinstance(x, nn.GroupNorm) for x in model.modules()) + + +@cpu_only +def test_inception_v3_eval(): + # replacement for models.inception_v3(pretrained=True) that does not download weights + kwargs = {} + kwargs['transform_input'] = True + kwargs['aux_logits'] = True + kwargs['init_weights'] = False + name = "inception_v3" + model = models.Inception3(**kwargs) + model.aux_logits = False + model.AuxLogits = None + model = model.eval() + x = torch.rand(1, 3, 299, 299) + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) + + +@cpu_only +def test_fasterrcnn_double(): + model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50, pretrained_backbone=False) + model.double() + model.eval() + input_shape = (3, 300, 300) + x = torch.rand(input_shape, dtype=torch.float64) + model_input = [x] + out = model(model_input) + assert model_input[0] is x + assert len(out) == 1 + assert "boxes" in out[0] + assert "scores" in out[0] + assert "labels" in out[0] + + +@cpu_only +def test_googlenet_eval(): + # replacement for models.googlenet(pretrained=True) that does not download weights + kwargs = {} + kwargs['transform_input'] = True + kwargs['aux_logits'] = True + kwargs['init_weights'] = False + name = "googlenet" + model = models.GoogLeNet(**kwargs) + model.aux_logits = False + model.aux1 = None + model.aux2 = None + model = model.eval() + x = torch.rand(1, 3, 224, 224) + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) + + +@needs_cuda +def test_fasterrcnn_switch_devices(): + def checkOut(out): + assert len(out) == 1 + assert "boxes" in out[0] + assert "scores" in out[0] + assert "labels" in out[0] + + model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50, pretrained_backbone=False) + model.cuda() + model.eval() + input_shape = (3, 300, 300) + x = torch.rand(input_shape, device='cuda') + model_input = [x] + out = model(model_input) + assert model_input[0] is x + + checkOut(out) + + with torch.cuda.amp.autocast(): out = model(model_input) - self.assertIs(model_input[0], x) - self.assertEqual(len(out), 1) - self.assertTrue("boxes" in out[0]) - self.assertTrue("scores" in out[0]) - self.assertTrue("labels" in out[0]) - - def test_googlenet_eval(self): - # replacement for models.googlenet(pretrained=True) that does not download weights - kwargs = {} - kwargs['transform_input'] = True - kwargs['aux_logits'] = True - kwargs['init_weights'] = False - name = "googlenet" - model = models.GoogLeNet(**kwargs) - model.aux_logits = False - model.aux1 = None - model.aux2 = None - model = model.eval() - x = torch.rand(1, 3, 224, 224) - _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) - - @unittest.skipIf(not torch.cuda.is_available(), 'needs GPU') - def test_fasterrcnn_switch_devices(self): - def checkOut(out): - self.assertEqual(len(out), 1) - self.assertTrue("boxes" in out[0]) - self.assertTrue("scores" in out[0]) - self.assertTrue("labels" in out[0]) - - model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50, pretrained_backbone=False) - model.cuda() - model.eval() - input_shape = (3, 300, 300) - x = torch.rand(input_shape, device='cuda') - model_input = [x] - out = model(model_input) - self.assertIs(model_input[0], x) - - checkOut(out) - with torch.cuda.amp.autocast(): - out = model(model_input) - - checkOut(out) - - # now switch to cpu and make sure it works - model.cpu() - x = x.cpu() - out_cpu = model([x]) + checkOut(out) - checkOut(out_cpu) + # now switch to cpu and make sure it works + model.cpu() + x = x.cpu() + out_cpu = model([x]) - def test_generalizedrcnn_transform_repr(self): + checkOut(out_cpu) - min_size, max_size = 224, 299 - image_mean = [0.485, 0.456, 0.406] - image_std = [0.229, 0.224, 0.225] - t = models.detection.transform.GeneralizedRCNNTransform(min_size=min_size, - max_size=max_size, - image_mean=image_mean, - image_std=image_std) +@cpu_only +def test_generalizedrcnn_transform_repr(): - # Check integrity of object __repr__ attribute - expected_string = 'GeneralizedRCNNTransform(' - _indent = '\n ' - expected_string += '{0}Normalize(mean={1}, std={2})'.format(_indent, image_mean, image_std) - expected_string += '{0}Resize(min_size=({1},), max_size={2}, '.format(_indent, min_size, max_size) - expected_string += "mode='bilinear')\n)" - self.assertEqual(t.__repr__(), expected_string) + min_size, max_size = 224, 299 + image_mean = [0.485, 0.456, 0.406] + image_std = [0.229, 0.224, 0.225] + t = models.detection.transform.GeneralizedRCNNTransform(min_size=min_size, + max_size=max_size, + image_mean=image_mean, + image_std=image_std) -_devs = [torch.device("cpu"), torch.device("cuda")] if torch.cuda.is_available() else [torch.device("cpu")] + # Check integrity of object __repr__ attribute + expected_string = 'GeneralizedRCNNTransform(' + _indent = '\n ' + expected_string += '{0}Normalize(mean={1}, std={2})'.format(_indent, image_mean, image_std) + expected_string += '{0}Resize(min_size=({1},), max_size={2}, '.format(_indent, min_size, max_size) + expected_string += "mode='bilinear')\n)" + assert t.__repr__() == expected_string @pytest.mark.parametrize('model_name', get_available_classification_models()) -@pytest.mark.parametrize('dev', _devs) +@pytest.mark.parametrize('dev', cpu_and_gpu()) def test_classification_model(model_name, dev): - ModelTester()._test_classification_model(model_name, dev) + set_rng_seed(0) + defaults = { + 'num_classes': 50, + 'input_shape': (1, 3, 224, 224), + } + kwargs = {**defaults, **_model_params.get(model_name, {})} + input_shape = kwargs.pop('input_shape') + + model = models.__dict__[model_name](**kwargs) + model.eval().to(device=dev) + # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests + x = torch.rand(input_shape).to(device=dev) + out = model(x) + _assert_expected(out.cpu(), model_name, prec=0.1) + assert out.shape[-1] == 50 + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(model_name, None)) + + if dev == torch.device("cuda"): + with torch.cuda.amp.autocast(): + out = model(x) + # See autocast_flaky_numerics comment at top of file. + if model_name not in autocast_flaky_numerics: + _assert_expected(out.cpu(), model_name, prec=0.1) + assert out.shape[-1] == 50 @pytest.mark.parametrize('model_name', get_available_segmentation_models()) -@pytest.mark.parametrize('dev', _devs) +@pytest.mark.parametrize('dev', cpu_and_gpu()) def test_segmentation_model(model_name, dev): - ModelTester()._test_segmentation_model(model_name, dev) + set_rng_seed(0) + defaults = { + 'num_classes': 10, + 'pretrained_backbone': False, + 'input_shape': (1, 3, 32, 32), + } + kwargs = {**defaults, **_model_params.get(model_name, {})} + input_shape = kwargs.pop('input_shape') + + model = models.segmentation.__dict__[model_name](**kwargs) + model.eval().to(device=dev) + # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests + x = torch.rand(input_shape).to(device=dev) + out = model(x)["out"] + + def check_out(out): + prec = 0.01 + try: + # We first try to assert the entire output if possible. This is not + # only the best way to assert results but also handles the cases + # where we need to create a new expected result. + _assert_expected(out.cpu(), model_name, prec=prec) + except AssertionError: + # Unfortunately some segmentation models are flaky with autocast + # so instead of validating the probability scores, check that the class + # predictions match. + expected_file = _get_expected_file(model_name) + expected = torch.load(expected_file) + torch.testing.assert_close(out.argmax(dim=1), expected.argmax(dim=1), rtol=prec, atol=prec) + return False # Partial validation performed + + return True # Full validation performed + + full_validation = check_out(out) + + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(model_name, None)) + + if dev == torch.device("cuda"): + with torch.cuda.amp.autocast(): + out = model(x)["out"] + # See autocast_flaky_numerics comment at top of file. + if model_name not in autocast_flaky_numerics: + full_validation &= check_out(out) + + if not full_validation: + msg = "The output of {} could only be partially validated. " \ + "This is likely due to unit-test flakiness, but you may " \ + "want to do additional manual checks if you made " \ + "significant changes to the codebase.".format(test_segmentation_model.__name__) + warnings.warn(msg, RuntimeWarning) + pytest.skip(msg) @pytest.mark.parametrize('model_name', get_available_detection_models()) -@pytest.mark.parametrize('dev', _devs) +@pytest.mark.parametrize('dev', cpu_and_gpu()) def test_detection_model(model_name, dev): - ModelTester()._test_detection_model(model_name, dev) + set_rng_seed(0) + defaults = { + 'num_classes': 50, + 'pretrained_backbone': False, + 'input_shape': (3, 300, 300), + } + kwargs = {**defaults, **_model_params.get(model_name, {})} + input_shape = kwargs.pop('input_shape') + + model = models.detection.__dict__[model_name](**kwargs) + model.eval().to(device=dev) + # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests + x = torch.rand(input_shape).to(device=dev) + model_input = [x] + out = model(model_input) + assert model_input[0] is x + + def check_out(out): + assert len(out) == 1 + + def compact(tensor): + size = tensor.size() + elements_per_sample = functools.reduce(operator.mul, size[1:], 1) + if elements_per_sample > 30: + return compute_mean_std(tensor) + else: + return subsample_tensor(tensor) + + def subsample_tensor(tensor): + num_elems = tensor.size(0) + num_samples = 20 + if num_elems <= num_samples: + return tensor + + ith_index = num_elems // num_samples + return tensor[ith_index - 1::ith_index] + + def compute_mean_std(tensor): + # can't compute mean of integral tensor + tensor = tensor.to(torch.double) + mean = torch.mean(tensor) + std = torch.std(tensor) + return {"mean": mean, "std": std} + + output = map_nested_tensor_object(out, tensor_map_fn=compact) + prec = 0.01 + try: + # We first try to assert the entire output if possible. This is not + # only the best way to assert results but also handles the cases + # where we need to create a new expected result. + _assert_expected(output, model_name, prec=prec) + except AssertionError: + # Unfortunately detection models are flaky due to the unstable sort + # in NMS. If matching across all outputs fails, use the same approach + # as in NMSTester.test_nms_cuda to see if this is caused by duplicate + # scores. + expected_file = _get_expected_file(model_name) + expected = torch.load(expected_file) + torch.testing.assert_close(output[0]["scores"], expected[0]["scores"], rtol=prec, atol=prec, + check_device=False, check_dtype=False) + + # Note: Fmassa proposed turning off NMS by adapting the threshold + # and then using the Hungarian algorithm as in DETR to find the + # best match between output and expected boxes and eliminate some + # of the flakiness. Worth exploring. + return False # Partial validation performed + + return True # Full validation performed + + full_validation = check_out(out) + _check_jit_scriptable(model, ([x],), unwrapper=script_model_unwrapper.get(model_name, None)) + + if dev == torch.device("cuda"): + with torch.cuda.amp.autocast(): + out = model(model_input) + # See autocast_flaky_numerics comment at top of file. + if model_name not in autocast_flaky_numerics: + full_validation &= check_out(out) + + if not full_validation: + msg = "The output of {} could only be partially validated. " \ + "This is likely due to unit-test flakiness, but you may " \ + "want to do additional manual checks if you made " \ + "significant changes to the codebase.".format(test_detection_model.__name__) + warnings.warn(msg, RuntimeWarning) + pytest.skip(msg) +@cpu_only @pytest.mark.parametrize('model_name', get_available_detection_models()) def test_detection_model_validation(model_name): - ModelTester()._test_detection_model_validation(model_name) + set_rng_seed(0) + model = models.detection.__dict__[model_name](num_classes=50, pretrained_backbone=False) + input_shape = (3, 300, 300) + x = [torch.rand(input_shape)] + + # validate that targets are present in training + with pytest.raises(ValueError): + model(x) + + # validate type + targets = [{'boxes': 0.}] + with pytest.raises(ValueError): + model(x, targets=targets) + + # validate boxes shape + for boxes in (torch.rand((4,)), torch.rand((1, 5))): + targets = [{'boxes': boxes}] + with pytest.raises(ValueError): + model(x, targets=targets) + + # validate that no degenerate boxes are present + boxes = torch.tensor([[1, 3, 1, 4], [2, 4, 3, 4]]) + targets = [{'boxes': boxes}] + with pytest.raises(ValueError): + model(x, targets=targets) @pytest.mark.parametrize('model_name', get_available_video_models()) -@pytest.mark.parametrize('dev', _devs) +@pytest.mark.parametrize('dev', cpu_and_gpu()) def test_video_model(model_name, dev): - ModelTester()._test_video_model(model_name, dev) + # the default input shape is + # bs * num_channels * clip_len * h *w + input_shape = (1, 3, 4, 112, 112) + # test both basicblock and Bottleneck + model = models.video.__dict__[model_name](num_classes=50) + model.eval().to(device=dev) + # RNG always on CPU, to ensure x in cuda tests is bitwise identical to x in cpu tests + x = torch.rand(input_shape).to(device=dev) + out = model(x) + _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(model_name, None)) + assert out.shape[-1] == 50 + + if dev == torch.device("cuda"): + with torch.cuda.amp.autocast(): + out = model(x) + assert out.shape[-1] == 50 if __name__ == '__main__': From 964ce1e95cba640768c5a39dbc018531c49d476c Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 7 Jun 2021 10:56:42 +0100 Subject: [PATCH 150/279] Prepare test_transforms_tensor.py for porting to pytest (#3976) --- test/test_transforms_tensor.py | 307 +++++++++++++++++---------------- 1 file changed, 163 insertions(+), 144 deletions(-) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index a725d9a44da..63b25fb7f11 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -24,145 +24,158 @@ NEAREST, BILINEAR, BICUBIC = InterpolationMode.NEAREST, InterpolationMode.BILINEAR, InterpolationMode.BICUBIC -class Tester(unittest.TestCase): - - def setUp(self): - self.device = "cpu" +def _test_transform_vs_scripted(transform, s_transform, tensor, msg=None): + torch.manual_seed(12) + out1 = transform(tensor) + torch.manual_seed(12) + out2 = s_transform(tensor) + assert_equal(out1, out2, msg=msg) - def _test_functional_op(self, func, fn_kwargs, test_exact_match=True, **match_kwargs): - if fn_kwargs is None: - fn_kwargs = {} - f = getattr(F, func) - tensor, pil_img = _create_data(height=10, width=10, device=self.device) - transformed_tensor = f(tensor, **fn_kwargs) - transformed_pil_img = f(pil_img, **fn_kwargs) - if test_exact_match: - _assert_equal_tensor_to_pil(transformed_tensor, transformed_pil_img, **match_kwargs) - else: - _assert_approx_equal_tensor_to_pil(transformed_tensor, transformed_pil_img, **match_kwargs) +def _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors, msg=None): + torch.manual_seed(12) + transformed_batch = transform(batch_tensors) - def _test_transform_vs_scripted(self, transform, s_transform, tensor, msg=None): + for i in range(len(batch_tensors)): + img_tensor = batch_tensors[i, ...] torch.manual_seed(12) - out1 = transform(tensor) - torch.manual_seed(12) - out2 = s_transform(tensor) - assert_equal(out1, out2, msg=msg) + transformed_img = transform(img_tensor) + assert_equal(transformed_img, transformed_batch[i, ...], msg=msg) - def _test_transform_vs_scripted_on_batch(self, transform, s_transform, batch_tensors, msg=None): - torch.manual_seed(12) - transformed_batch = transform(batch_tensors) + torch.manual_seed(12) + s_transformed_batch = s_transform(batch_tensors) + assert_equal(transformed_batch, s_transformed_batch, msg=msg) - for i in range(len(batch_tensors)): - img_tensor = batch_tensors[i, ...] - torch.manual_seed(12) - transformed_img = transform(img_tensor) - assert_equal(transformed_img, transformed_batch[i, ...], msg=msg) - torch.manual_seed(12) - s_transformed_batch = s_transform(batch_tensors) - assert_equal(transformed_batch, s_transformed_batch, msg=msg) +def _test_functional_op(f, device, fn_kwargs=None, test_exact_match=True, **match_kwargs): + fn_kwargs = fn_kwargs or {} - def _test_class_op(self, method, meth_kwargs=None, test_exact_match=True, **match_kwargs): - if meth_kwargs is None: - meth_kwargs = {} + tensor, pil_img = _create_data(height=10, width=10, device=device) + transformed_tensor = f(tensor, **fn_kwargs) + transformed_pil_img = f(pil_img, **fn_kwargs) + if test_exact_match: + _assert_equal_tensor_to_pil(transformed_tensor, transformed_pil_img, **match_kwargs) + else: + _assert_approx_equal_tensor_to_pil(transformed_tensor, transformed_pil_img, **match_kwargs) - # test for class interface - f = getattr(T, method)(**meth_kwargs) - scripted_fn = torch.jit.script(f) - tensor, pil_img = _create_data(26, 34, device=self.device) - # set seed to reproduce the same transformation for tensor and PIL image - torch.manual_seed(12) - transformed_tensor = f(tensor) - torch.manual_seed(12) - transformed_pil_img = f(pil_img) - if test_exact_match: - _assert_equal_tensor_to_pil(transformed_tensor, transformed_pil_img, **match_kwargs) - else: - _assert_approx_equal_tensor_to_pil(transformed_tensor.float(), transformed_pil_img, **match_kwargs) +def _test_class_op(method, device, meth_kwargs=None, test_exact_match=True, **match_kwargs): + # TODO: change the name: it's not a method, it's a class. + meth_kwargs = meth_kwargs or {} - torch.manual_seed(12) - transformed_tensor_script = scripted_fn(tensor) - assert_equal(transformed_tensor, transformed_tensor_script) + # test for class interface + f = method(**meth_kwargs) + scripted_fn = torch.jit.script(f) - batch_tensors = _create_data_batch(height=23, width=34, channels=3, num_samples=4, device=self.device) - self._test_transform_vs_scripted_on_batch(f, scripted_fn, batch_tensors) + tensor, pil_img = _create_data(26, 34, device=device) + # set seed to reproduce the same transformation for tensor and PIL image + torch.manual_seed(12) + transformed_tensor = f(tensor) + torch.manual_seed(12) + transformed_pil_img = f(pil_img) + if test_exact_match: + _assert_equal_tensor_to_pil(transformed_tensor, transformed_pil_img, **match_kwargs) + else: + _assert_approx_equal_tensor_to_pil(transformed_tensor.float(), transformed_pil_img, **match_kwargs) - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_{}.pt".format(method))) + torch.manual_seed(12) + transformed_tensor_script = scripted_fn(tensor) + assert_equal(transformed_tensor, transformed_tensor_script) + + batch_tensors = _create_data_batch(height=23, width=34, channels=3, num_samples=4, device=device) + _test_transform_vs_scripted_on_batch(f, scripted_fn, batch_tensors) + + with get_tmp_dir() as tmp_dir: + scripted_fn.save(os.path.join(tmp_dir, f"t_{method.__name__}.pt")) - def _test_op(self, func, method, fn_kwargs=None, meth_kwargs=None, test_exact_match=True, **match_kwargs): - self._test_functional_op(func, fn_kwargs, test_exact_match=test_exact_match, **match_kwargs) - self._test_class_op(method, meth_kwargs, test_exact_match=test_exact_match, **match_kwargs) + +def _test_op(func, method, device, fn_kwargs=None, meth_kwargs=None, test_exact_match=True, **match_kwargs): + _test_functional_op(func, device, fn_kwargs, test_exact_match=test_exact_match, **match_kwargs) + _test_class_op(method, device, meth_kwargs, test_exact_match=test_exact_match, **match_kwargs) + + +class Tester(unittest.TestCase): + + def setUp(self): + self.device = "cpu" def test_random_horizontal_flip(self): - self._test_op('hflip', 'RandomHorizontalFlip') + _test_op(F.hflip, T.RandomHorizontalFlip, device=self.device) def test_random_vertical_flip(self): - self._test_op('vflip', 'RandomVerticalFlip') + _test_op(F.vflip, T.RandomVerticalFlip, device=self.device) def test_random_invert(self): - self._test_op('invert', 'RandomInvert') + _test_op(F.invert, T.RandomInvert, device=self.device) def test_random_posterize(self): fn_kwargs = meth_kwargs = {"bits": 4} - self._test_op( - 'posterize', 'RandomPosterize', fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + _test_op( + F.posterize, T.RandomPosterize, device=self.device, fn_kwargs=fn_kwargs, + meth_kwargs=meth_kwargs ) def test_random_solarize(self): fn_kwargs = meth_kwargs = {"threshold": 192.0} - self._test_op( - 'solarize', 'RandomSolarize', fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + _test_op( + F.solarize, T.RandomSolarize, device=self.device, fn_kwargs=fn_kwargs, + meth_kwargs=meth_kwargs ) def test_random_adjust_sharpness(self): fn_kwargs = meth_kwargs = {"sharpness_factor": 2.0} - self._test_op( - 'adjust_sharpness', 'RandomAdjustSharpness', fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + _test_op( + F.adjust_sharpness, T.RandomAdjustSharpness, device=self.device, fn_kwargs=fn_kwargs, + meth_kwargs=meth_kwargs ) def test_random_autocontrast(self): # We check the max abs difference because on some (very rare) pixels, the actual value may be different # between PIL and tensors due to floating approximations. - self._test_op('autocontrast', 'RandomAutocontrast', test_exact_match=False, agg_method='max', - tol=(1 + 1e-5), allowed_percentage_diff=.05) + _test_op( + F.autocontrast, T.RandomAutocontrast, device=self.device, test_exact_match=False, + agg_method='max', tol=(1 + 1e-5), allowed_percentage_diff=.05 + ) def test_random_equalize(self): - self._test_op('equalize', 'RandomEqualize') + _test_op(F.equalize, T.RandomEqualize, device=self.device) def test_color_jitter(self): tol = 1.0 + 1e-10 for f in [0.1, 0.5, 1.0, 1.34, (0.3, 0.7), [0.4, 0.5]]: meth_kwargs = {"brightness": f} - self._test_class_op( - "ColorJitter", meth_kwargs=meth_kwargs, test_exact_match=False, tol=tol, agg_method="max" + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, + tol=tol, agg_method="max" ) for f in [0.2, 0.5, 1.0, 1.5, (0.3, 0.7), [0.4, 0.5]]: meth_kwargs = {"contrast": f} - self._test_class_op( - "ColorJitter", meth_kwargs=meth_kwargs, test_exact_match=False, tol=tol, agg_method="max" + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, + tol=tol, agg_method="max" ) for f in [0.5, 0.75, 1.0, 1.25, (0.3, 0.7), [0.3, 0.4]]: meth_kwargs = {"saturation": f} - self._test_class_op( - "ColorJitter", meth_kwargs=meth_kwargs, test_exact_match=False, tol=tol, agg_method="max" + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, + tol=tol, agg_method="max" ) for f in [0.2, 0.5, (-0.2, 0.3), [-0.4, 0.5]]: meth_kwargs = {"hue": f} - self._test_class_op( - "ColorJitter", meth_kwargs=meth_kwargs, test_exact_match=False, tol=16.1, agg_method="max" + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, + tol=16.1, agg_method="max" ) # All 4 parameters together meth_kwargs = {"brightness": 0.2, "contrast": 0.2, "saturation": 0.2, "hue": 0.2} - self._test_class_op( - "ColorJitter", meth_kwargs=meth_kwargs, test_exact_match=False, tol=12.1, agg_method="max" + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, + tol=12.1, agg_method="max" ) def test_pad(self): @@ -170,48 +183,49 @@ def test_pad(self): fill = 127 if m == "constant" else 0 for mul in [1, -1]: # Test functional.pad (PIL and Tensor) with padding as single int - self._test_functional_op( - "pad", fn_kwargs={"padding": mul * 2, "fill": fill, "padding_mode": m} + _test_functional_op( + F.pad, fn_kwargs={"padding": mul * 2, "fill": fill, "padding_mode": m}, + device=self.device ) # Test functional.pad and transforms.Pad with padding as [int, ] fn_kwargs = meth_kwargs = {"padding": [mul * 2, ], "fill": fill, "padding_mode": m} - self._test_op( - "pad", "Pad", fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + _test_op( + F.pad, T.Pad, device=self.device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs ) # Test functional.pad and transforms.Pad with padding as list fn_kwargs = meth_kwargs = {"padding": [mul * 4, 4], "fill": fill, "padding_mode": m} - self._test_op( - "pad", "Pad", fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + _test_op( + F.pad, T.Pad, device=self.device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs ) # Test functional.pad and transforms.Pad with padding as tuple fn_kwargs = meth_kwargs = {"padding": (mul * 2, 2, 2, mul * 2), "fill": fill, "padding_mode": m} - self._test_op( - "pad", "Pad", fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + _test_op( + F.pad, T.Pad, device=self.device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs ) def test_crop(self): fn_kwargs = {"top": 2, "left": 3, "height": 4, "width": 5} # Test transforms.RandomCrop with size and padding as tuple meth_kwargs = {"size": (4, 5), "padding": (4, 4), "pad_if_needed": True, } - self._test_op( - 'crop', 'RandomCrop', fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + _test_op( + F.crop, T.RandomCrop, device=self.device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs ) # Test transforms.functional.crop including outside the image area fn_kwargs = {"top": -2, "left": 3, "height": 4, "width": 5} # top - self._test_functional_op('crop', fn_kwargs=fn_kwargs) + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) fn_kwargs = {"top": 1, "left": -3, "height": 4, "width": 5} # left - self._test_functional_op('crop', fn_kwargs=fn_kwargs) + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) fn_kwargs = {"top": 7, "left": 3, "height": 4, "width": 5} # bottom - self._test_functional_op('crop', fn_kwargs=fn_kwargs) + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) fn_kwargs = {"top": 3, "left": 8, "height": 4, "width": 5} # right - self._test_functional_op('crop', fn_kwargs=fn_kwargs) + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) fn_kwargs = {"top": -3, "left": -3, "height": 15, "width": 15} # all - self._test_functional_op('crop', fn_kwargs=fn_kwargs) + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) sizes = [5, [5, ], [6, 6]] padding_configs = [ @@ -226,18 +240,20 @@ def test_crop(self): for padding_config in padding_configs: config = dict(padding_config) config["size"] = size - self._test_class_op("RandomCrop", config) + _test_class_op(T.RandomCrop, self.device, config) def test_center_crop(self): fn_kwargs = {"output_size": (4, 5)} meth_kwargs = {"size": (4, 5), } - self._test_op( - "center_crop", "CenterCrop", fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + _test_op( + F.center_crop, T.CenterCrop, device=self.device, fn_kwargs=fn_kwargs, + meth_kwargs=meth_kwargs ) fn_kwargs = {"output_size": (5,)} meth_kwargs = {"size": (5, )} - self._test_op( - "center_crop", "CenterCrop", fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + _test_op( + F.center_crop, T.CenterCrop, device=self.device, fn_kwargs=fn_kwargs, + meth_kwargs=meth_kwargs ) tensor = torch.randint(0, 256, (3, 10, 10), dtype=torch.uint8, device=self.device) # Test torchscript of transforms.CenterCrop with size as int @@ -378,8 +394,8 @@ def test_resize(self): transform = T.Resize(size=script_size, interpolation=interpolation, max_size=max_size) s_transform = torch.jit.script(transform) - self._test_transform_vs_scripted(transform, s_transform, tensor) - self._test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) with get_tmp_dir() as tmp_dir: s_transform.save(os.path.join(tmp_dir, "t_resize.pt")) @@ -396,8 +412,8 @@ def test_resized_crop(self): size=size, scale=scale, ratio=ratio, interpolation=interpolation ) s_transform = torch.jit.script(transform) - self._test_transform_vs_scripted(transform, s_transform, tensor) - self._test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) with get_tmp_dir() as tmp_dir: s_transform.save(os.path.join(tmp_dir, "t_resized_crop.pt")) @@ -410,8 +426,8 @@ def _test(**kwargs): transform = T.RandomAffine(**kwargs) s_transform = torch.jit.script(transform) - self._test_transform_vs_scripted(transform, s_transform, tensor) - self._test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) return s_transform @@ -449,8 +465,8 @@ def test_random_rotate(self): ) s_transform = torch.jit.script(transform) - self._test_transform_vs_scripted(transform, s_transform, tensor) - self._test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) with get_tmp_dir() as tmp_dir: s_transform.save(os.path.join(tmp_dir, "t_random_rotate.pt")) @@ -469,8 +485,8 @@ def test_random_perspective(self): ) s_transform = torch.jit.script(transform) - self._test_transform_vs_scripted(transform, s_transform, tensor) - self._test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) with get_tmp_dir() as tmp_dir: s_transform.save(os.path.join(tmp_dir, "t_perspective.pt")) @@ -479,18 +495,21 @@ def test_to_grayscale(self): meth_kwargs = {"num_output_channels": 1} tol = 1.0 + 1e-10 - self._test_class_op( - "Grayscale", meth_kwargs=meth_kwargs, test_exact_match=False, tol=tol, agg_method="max" + _test_class_op( + T.Grayscale, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, + tol=tol, agg_method="max" ) meth_kwargs = {"num_output_channels": 3} - self._test_class_op( - "Grayscale", meth_kwargs=meth_kwargs, test_exact_match=False, tol=tol, agg_method="max" + _test_class_op( + T.Grayscale, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, + tol=tol, agg_method="max" ) meth_kwargs = {} - self._test_class_op( - "RandomGrayscale", meth_kwargs=meth_kwargs, test_exact_match=False, tol=tol, agg_method="max" + _test_class_op( + T.RandomGrayscale, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, + tol=tol, agg_method="max" ) def test_normalize(self): @@ -505,8 +524,8 @@ def test_normalize(self): # test for class interface scripted_fn = torch.jit.script(fn) - self._test_transform_vs_scripted(fn, scripted_fn, tensor) - self._test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) + _test_transform_vs_scripted(fn, scripted_fn, tensor) + _test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) with get_tmp_dir() as tmp_dir: scripted_fn.save(os.path.join(tmp_dir, "t_norm.pt")) @@ -522,7 +541,7 @@ def test_linear_transformation(self): fn = T.LinearTransformation(matrix, mean_vector) scripted_fn = torch.jit.script(fn) - self._test_transform_vs_scripted(fn, scripted_fn, tensor) + _test_transform_vs_scripted(fn, scripted_fn, tensor) batch_tensors = torch.rand(4, c, h, w, device=self.device) # We skip some tests from _test_transform_vs_scripted_on_batch as @@ -590,34 +609,34 @@ def test_random_apply(self): def test_gaussian_blur(self): tol = 1.0 + 1e-10 - self._test_class_op( - "GaussianBlur", meth_kwargs={"kernel_size": 3, "sigma": 0.75}, - test_exact_match=False, agg_method="max", tol=tol + _test_class_op( + T.GaussianBlur, meth_kwargs={"kernel_size": 3, "sigma": 0.75}, + test_exact_match=False, device=self.device, agg_method="max", tol=tol ) - self._test_class_op( - "GaussianBlur", meth_kwargs={"kernel_size": 23, "sigma": [0.1, 2.0]}, - test_exact_match=False, agg_method="max", tol=tol + _test_class_op( + T.GaussianBlur, meth_kwargs={"kernel_size": 23, "sigma": [0.1, 2.0]}, + test_exact_match=False, device=self.device, agg_method="max", tol=tol ) - self._test_class_op( - "GaussianBlur", meth_kwargs={"kernel_size": 23, "sigma": (0.1, 2.0)}, - test_exact_match=False, agg_method="max", tol=tol + _test_class_op( + T.GaussianBlur, meth_kwargs={"kernel_size": 23, "sigma": (0.1, 2.0)}, + test_exact_match=False, device=self.device, agg_method="max", tol=tol ) - self._test_class_op( - "GaussianBlur", meth_kwargs={"kernel_size": [3, 3], "sigma": (1.0, 1.0)}, - test_exact_match=False, agg_method="max", tol=tol + _test_class_op( + T.GaussianBlur, meth_kwargs={"kernel_size": [3, 3], "sigma": (1.0, 1.0)}, + test_exact_match=False, device=self.device, agg_method="max", tol=tol ) - self._test_class_op( - "GaussianBlur", meth_kwargs={"kernel_size": (3, 3), "sigma": (0.1, 2.0)}, - test_exact_match=False, agg_method="max", tol=tol + _test_class_op( + T.GaussianBlur, meth_kwargs={"kernel_size": (3, 3), "sigma": (0.1, 2.0)}, + test_exact_match=False, device=self.device, agg_method="max", tol=tol ) - self._test_class_op( - "GaussianBlur", meth_kwargs={"kernel_size": [23], "sigma": 0.75}, - test_exact_match=False, agg_method="max", tol=tol + _test_class_op( + T.GaussianBlur, meth_kwargs={"kernel_size": [23], "sigma": 0.75}, + test_exact_match=False, device=self.device, agg_method="max", tol=tol ) def test_random_erasing(self): @@ -641,8 +660,8 @@ def test_random_erasing(self): for config in test_configs: fn = T.RandomErasing(**config) scripted_fn = torch.jit.script(fn) - self._test_transform_vs_scripted(fn, scripted_fn, tensor) - self._test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) + _test_transform_vs_scripted(fn, scripted_fn, tensor) + _test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) with get_tmp_dir() as tmp_dir: scripted_fn.save(os.path.join(tmp_dir, "t_random_erasing.pt")) @@ -662,13 +681,13 @@ def test_convert_image_dtype(self): if (in_dtype == torch.float32 and out_dtype in (torch.int32, torch.int64)) or \ (in_dtype == torch.float64 and out_dtype == torch.int64): with self.assertRaisesRegex(RuntimeError, r"cannot be performed safely"): - self._test_transform_vs_scripted(fn, scripted_fn, in_tensor) + _test_transform_vs_scripted(fn, scripted_fn, in_tensor) with self.assertRaisesRegex(RuntimeError, r"cannot be performed safely"): - self._test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) + _test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) continue - self._test_transform_vs_scripted(fn, scripted_fn, in_tensor) - self._test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) + _test_transform_vs_scripted(fn, scripted_fn, in_tensor) + _test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) with get_tmp_dir() as tmp_dir: scripted_fn.save(os.path.join(tmp_dir, "t_convert_dtype.pt")) @@ -683,8 +702,8 @@ def test_autoaugment(self): transform = T.AutoAugment(policy=policy, fill=fill) s_transform = torch.jit.script(transform) for _ in range(25): - self._test_transform_vs_scripted(transform, s_transform, tensor) - self._test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) if s_transform is not None: with get_tmp_dir() as tmp_dir: From 4c95bb6e487a393cf440bf56697efa74c8b392c6 Mon Sep 17 00:00:00 2001 From: Zhiqiang Wang Date: Mon, 7 Jun 2021 18:29:27 +0800 Subject: [PATCH 151/279] Port test_rotate in test_functional_tensor.py to pytest (#3983) --- test/test_functional_tensor.py | 168 ++++++++++++++++----------------- 1 file changed, 83 insertions(+), 85 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 0329542981e..d21d91046d7 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -191,90 +191,6 @@ def test_ten_crop(self): for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): assert_equal(transformed_batch, s_transformed_batch) - def _test_rotate_all_options(self, tensor, pil_img, scripted_rotate, centers): - img_size = pil_img.size - dt = tensor.dtype - for r in [NEAREST, ]: - for a in range(-180, 180, 17): - for e in [True, False]: - for c in centers: - for f in [None, [0, 0, 0], (1, 2, 3), [255, 255, 255], [1, ], (2.0, )]: - f_pil = int(f[0]) if f is not None and len(f) == 1 else f - out_pil_img = F.rotate(pil_img, angle=a, interpolation=r, expand=e, center=c, fill=f_pil) - out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) - for fn in [F.rotate, scripted_rotate]: - out_tensor = fn(tensor, angle=a, interpolation=r, expand=e, center=c, fill=f).cpu() - - if out_tensor.dtype != torch.uint8: - out_tensor = out_tensor.to(torch.uint8) - - self.assertEqual( - out_tensor.shape, - out_pil_tensor.shape, - msg="{}: {} vs {}".format( - (img_size, r, dt, a, e, c), out_tensor.shape, out_pil_tensor.shape - )) - - num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 - ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] - # Tolerance : less than 3% of different pixels - self.assertLess( - ratio_diff_pixels, - 0.03, - msg="{}: {}\n{} vs \n{}".format( - (img_size, r, dt, a, e, c, f), - ratio_diff_pixels, - out_tensor[0, :7, :7], - out_pil_tensor[0, :7, :7] - ) - ) - - def test_rotate(self): - # Tests on square image - scripted_rotate = torch.jit.script(F.rotate) - - data = [_create_data(26, 26, device=self.device), _create_data(32, 26, device=self.device)] - for tensor, pil_img in data: - - img_size = pil_img.size - centers = [ - None, - (int(img_size[0] * 0.3), int(img_size[0] * 0.4)), - [int(img_size[0] * 0.5), int(img_size[0] * 0.6)] - ] - - for dt in [None, torch.float32, torch.float64, torch.float16]: - - if dt == torch.float16 and torch.device(self.device).type == "cpu": - # skip float16 on CPU case - continue - - if dt is not None: - tensor = tensor.to(dtype=dt) - - self._test_rotate_all_options(tensor, pil_img, scripted_rotate, centers) - - batch_tensors = _create_data_batch(26, 36, num_samples=4, device=self.device) - if dt is not None: - batch_tensors = batch_tensors.to(dtype=dt) - - center = (20, 22) - _test_fn_on_batch( - batch_tensors, F.rotate, angle=32, interpolation=NEAREST, expand=True, center=center - ) - tensor, pil_img = data[0] - # assert deprecation warning and non-BC - with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"): - res1 = F.rotate(tensor, 45, resample=2) - res2 = F.rotate(tensor, 45, interpolation=BILINEAR) - assert_equal(res1, res2) - - # assert changed type warning - with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): - res1 = F.rotate(tensor, 45, interpolation=2) - res2 = F.rotate(tensor, 45, interpolation=BILINEAR) - assert_equal(res1, res2) - @unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device") class CUDATester(Tester): @@ -295,6 +211,88 @@ def test_scale_channel(self): assert_equal(scaled_cpu, scaled_cuda.to('cpu')) +class TestRotate: + + ALL_DTYPES = [None, torch.float32, torch.float64, torch.float16] + scripted_rotate = torch.jit.script(F.rotate) + IMG_W = 26 + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('height, width', [(26, IMG_W), (32, IMG_W)]) + @pytest.mark.parametrize('center', [ + None, + (int(IMG_W * 0.3), int(IMG_W * 0.4)), + [int(IMG_W * 0.5), int(IMG_W * 0.6)], + ]) + @pytest.mark.parametrize('dt', ALL_DTYPES) + @pytest.mark.parametrize('angle', range(-180, 180, 17)) + @pytest.mark.parametrize('expand', [True, False]) + @pytest.mark.parametrize('fill', [None, [0, 0, 0], (1, 2, 3), [255, 255, 255], [1, ], (2.0, )]) + @pytest.mark.parametrize('fn', [F.rotate, scripted_rotate]) + def test_rotate(self, device, height, width, center, dt, angle, expand, fill, fn): + tensor, pil_img = _create_data(height, width, device=device) + + if dt == torch.float16 and torch.device(device).type == "cpu": + # skip float16 on CPU case + return + + if dt is not None: + tensor = tensor.to(dtype=dt) + + f_pil = int(fill[0]) if fill is not None and len(fill) == 1 else fill + out_pil_img = F.rotate(pil_img, angle=angle, interpolation=NEAREST, expand=expand, center=center, fill=f_pil) + out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) + + out_tensor = fn(tensor, angle=angle, interpolation=NEAREST, expand=expand, center=center, fill=fill).cpu() + + if out_tensor.dtype != torch.uint8: + out_tensor = out_tensor.to(torch.uint8) + + assert out_tensor.shape == out_pil_tensor.shape, ( + f"{(height, width, NEAREST, dt, angle, expand, center)}: " + f"{out_tensor.shape} vs {out_pil_tensor.shape}") + + num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 + ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] + # Tolerance : less than 3% of different pixels + assert ratio_diff_pixels < 0.03, ( + f"{(height, width, NEAREST, dt, angle, expand, center, fill)}: " + f"{ratio_diff_pixels}\n{out_tensor[0, :7, :7]} vs \n" + f"{out_pil_tensor[0, :7, :7]}") + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('dt', ALL_DTYPES) + def test_rotate_batch(self, device, dt): + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + batch_tensors = _create_data_batch(26, 36, num_samples=4, device=device) + if dt is not None: + batch_tensors = batch_tensors.to(dtype=dt) + + center = (20, 22) + _test_fn_on_batch( + batch_tensors, F.rotate, angle=32, interpolation=NEAREST, expand=True, center=center + ) + + def test_rotate_deprecation_resample(self): + tensor, _ = _create_data(26, 26) + # assert deprecation warning and non-BC + with pytest.warns(UserWarning, match=r"Argument resample is deprecated and will be removed"): + res1 = F.rotate(tensor, 45, resample=2) + res2 = F.rotate(tensor, 45, interpolation=BILINEAR) + assert_equal(res1, res2) + + def test_rotate_interpolation_type(self): + tensor, _ = _create_data(26, 26) + # assert changed type warning + with pytest.warns(UserWarning, match=r"Argument interpolation should be of type InterpolationMode"): + res1 = F.rotate(tensor, 45, interpolation=2) + res2 = F.rotate(tensor, 45, interpolation=BILINEAR) + assert_equal(res1, res2) + + class TestAffine: ALL_DTYPES = [None, torch.float32, torch.float64, torch.float16] @@ -473,7 +471,7 @@ def test_all_ops(self, device, height, width, dt, a, t, s, sh, f, fn): # Tolerance : less than 5% (cpu), 6% (cuda) of different pixels tol = 0.06 if device == "cuda" else 0.05 assert ratio_diff_pixels < tol, "{}: {}\n{} vs \n{}".format( - (i, a, t, s, sh, f), ratio_diff_pixels, out_tensor[0, :7, :7], out_pil_tensor[0, :7, :7] + (NEAREST, a, t, s, sh, f), ratio_diff_pixels, out_tensor[0, :7, :7], out_pil_tensor[0, :7, :7] ) @pytest.mark.parametrize('device', cpu_and_gpu()) From 7fb4ef57b3ca3c521eab7b80c02fc255a2c9aeee Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Mon, 7 Jun 2021 12:26:39 +0100 Subject: [PATCH 152/279] Revert "addressing #3805: remove deprecated function call 3 (#3861)" (#3989) This reverts commit f6b6b5109627cb0bcfbebf90ebce740bacae9c59. --- torchvision/csrc/io/decoder/audio_stream.cpp | 8 ++++---- torchvision/csrc/io/decoder/decoder.cpp | 6 ++++-- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/torchvision/csrc/io/decoder/audio_stream.cpp b/torchvision/csrc/io/decoder/audio_stream.cpp index f6507130bda..9d66e589bf3 100644 --- a/torchvision/csrc/io/decoder/audio_stream.cpp +++ b/torchvision/csrc/io/decoder/audio_stream.cpp @@ -7,13 +7,13 @@ namespace ffmpeg { namespace { bool operator==(const AudioFormat& x, const AVFrame& y) { - return static_cast(x.samples) == y.sample_rate && - static_cast(x.channels) == y.channels && x.format == y.format; + return x.samples == y.sample_rate && x.channels == y.channels && + x.format == y.format; } bool operator==(const AudioFormat& x, const AVCodecContext& y) { - return static_cast(x.samples) == y.sample_rate && - static_cast(x.channels) == y.channels && x.format == y.sample_fmt; + return x.samples == y.sample_rate && x.channels == y.channels && + x.format == y.sample_fmt; } AudioFormat& toAudioFormat(AudioFormat& x, const AVFrame& y) { diff --git a/torchvision/csrc/io/decoder/decoder.cpp b/torchvision/csrc/io/decoder/decoder.cpp index 18e49a4d002..6c9a3cdf825 100644 --- a/torchvision/csrc/io/decoder/decoder.cpp +++ b/torchvision/csrc/io/decoder/decoder.cpp @@ -196,6 +196,8 @@ int64_t Decoder::seekCallback(int64_t offset, int whence) { void Decoder::initOnce() { static std::once_flag flagInit; std::call_once(flagInit, []() { + av_register_all(); + avcodec_register_all(); avformat_network_init(); // register ffmpeg lock manager av_lockmgr_register(&ffmpeg_lock); @@ -395,10 +397,10 @@ bool Decoder::init( } bool Decoder::openStreams(std::vector* metadata) { - for (int i = 0; i < static_cast(inputCtx_->nb_streams); i++) { + for (int i = 0; i < inputCtx_->nb_streams; i++) { // - find the corespondent format at params_.formats set MediaFormat format; - const auto media = inputCtx_->streams[i]->codecpar->codec_type; + const auto media = inputCtx_->streams[i]->codec->codec_type; if (!mapFfmpegType(media, &format.type)) { VLOG(1) << "Stream media: " << media << " at index " << i << " gets ignored, unknown type"; From a629a9b24de99096770ced30dbca07792f0f3005 Mon Sep 17 00:00:00 2001 From: Vivek Kumar <60113444+vivekkumar7089@users.noreply.github.com> Date: Mon, 7 Jun 2021 17:47:08 +0530 Subject: [PATCH 153/279] Port some tests to pytest in test_functional_tensor.py (#3988) --- test/test_functional_tensor.py | 402 ++++++++++++++++++++------------- 1 file changed, 249 insertions(+), 153 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index d21d91046d7..d0cb062ec2a 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -36,160 +36,89 @@ class Tester(unittest.TestCase): def setUp(self): self.device = "cpu" - def test_hsv2rgb(self): - scripted_fn = torch.jit.script(F_t._hsv2rgb) - shape = (3, 100, 150) - for _ in range(10): - hsv_img = torch.rand(*shape, dtype=torch.float, device=self.device) - rgb_img = F_t._hsv2rgb(hsv_img) - ft_img = rgb_img.permute(1, 2, 0).flatten(0, 1) - - h, s, v, = hsv_img.unbind(0) - h = h.flatten().cpu().numpy() - s = s.flatten().cpu().numpy() - v = v.flatten().cpu().numpy() - - rgb = [] - for h1, s1, v1 in zip(h, s, v): - rgb.append(colorsys.hsv_to_rgb(h1, s1, v1)) - colorsys_img = torch.tensor(rgb, dtype=torch.float32, device=self.device) - torch.testing.assert_close(ft_img, colorsys_img, rtol=0.0, atol=1e-5) - - s_rgb_img = scripted_fn(hsv_img) - torch.testing.assert_close(rgb_img, s_rgb_img) - - batch_tensors = _create_data_batch(120, 100, num_samples=4, device=self.device).float() - _test_fn_on_batch(batch_tensors, F_t._hsv2rgb) - - def test_rgb2hsv(self): - scripted_fn = torch.jit.script(F_t._rgb2hsv) - shape = (3, 150, 100) - for _ in range(10): - rgb_img = torch.rand(*shape, dtype=torch.float, device=self.device) - hsv_img = F_t._rgb2hsv(rgb_img) - ft_hsv_img = hsv_img.permute(1, 2, 0).flatten(0, 1) - - r, g, b, = rgb_img.unbind(dim=-3) - r = r.flatten().cpu().numpy() - g = g.flatten().cpu().numpy() - b = b.flatten().cpu().numpy() - - hsv = [] - for r1, g1, b1 in zip(r, g, b): - hsv.append(colorsys.rgb_to_hsv(r1, g1, b1)) - - colorsys_img = torch.tensor(hsv, dtype=torch.float32, device=self.device) - - ft_hsv_img_h, ft_hsv_img_sv = torch.split(ft_hsv_img, [1, 2], dim=1) - colorsys_img_h, colorsys_img_sv = torch.split(colorsys_img, [1, 2], dim=1) - - max_diff_h = ((colorsys_img_h * 2 * math.pi).sin() - (ft_hsv_img_h * 2 * math.pi).sin()).abs().max() - max_diff_sv = (colorsys_img_sv - ft_hsv_img_sv).abs().max() - max_diff = max(max_diff_h, max_diff_sv) - self.assertLess(max_diff, 1e-5) - - s_hsv_img = scripted_fn(rgb_img) - torch.testing.assert_close(hsv_img, s_hsv_img, rtol=1e-5, atol=1e-7) - - batch_tensors = _create_data_batch(120, 100, num_samples=4, device=self.device).float() - _test_fn_on_batch(batch_tensors, F_t._rgb2hsv) - - def test_rgb_to_grayscale(self): - script_rgb_to_grayscale = torch.jit.script(F.rgb_to_grayscale) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - for num_output_channels in (3, 1): - gray_pil_image = F.rgb_to_grayscale(pil_img, num_output_channels=num_output_channels) - gray_tensor = F.rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) - - _assert_approx_equal_tensor_to_pil(gray_tensor.float(), gray_pil_image, tol=1.0 + 1e-10, agg_method="max") - - s_gray_tensor = script_rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) - assert_equal(s_gray_tensor, gray_tensor) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - _test_fn_on_batch(batch_tensors, F.rgb_to_grayscale, num_output_channels=num_output_channels) - - def test_center_crop(self): - script_center_crop = torch.jit.script(F.center_crop) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - cropped_pil_image = F.center_crop(pil_img, [10, 11]) - - cropped_tensor = F.center_crop(img_tensor, [10, 11]) - _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) - - cropped_tensor = script_center_crop(img_tensor, [10, 11]) - _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - _test_fn_on_batch(batch_tensors, F.center_crop, output_size=[10, 11]) - - def test_five_crop(self): - script_five_crop = torch.jit.script(F.five_crop) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - cropped_pil_images = F.five_crop(pil_img, [10, 11]) - - cropped_tensors = F.five_crop(img_tensor, [10, 11]) - for i in range(5): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - cropped_tensors = script_five_crop(img_tensor, [10, 11]) - for i in range(5): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - tuple_transformed_batches = F.five_crop(batch_tensors, [10, 11]) - for i in range(len(batch_tensors)): - img_tensor = batch_tensors[i, ...] - tuple_transformed_imgs = F.five_crop(img_tensor, [10, 11]) - self.assertEqual(len(tuple_transformed_imgs), len(tuple_transformed_batches)) - - for j in range(len(tuple_transformed_imgs)): - true_transformed_img = tuple_transformed_imgs[j] - transformed_img = tuple_transformed_batches[j][i, ...] - assert_equal(true_transformed_img, transformed_img) - - # scriptable function test - s_tuple_transformed_batches = script_five_crop(batch_tensors, [10, 11]) - for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): - assert_equal(transformed_batch, s_transformed_batch) - - def test_ten_crop(self): - script_ten_crop = torch.jit.script(F.ten_crop) - - img_tensor, pil_img = _create_data(32, 34, device=self.device) - - cropped_pil_images = F.ten_crop(pil_img, [10, 11]) - - cropped_tensors = F.ten_crop(img_tensor, [10, 11]) - for i in range(10): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - cropped_tensors = script_ten_crop(img_tensor, [10, 11]) - for i in range(10): - _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) - - batch_tensors = _create_data_batch(16, 18, num_samples=4, device=self.device) - tuple_transformed_batches = F.ten_crop(batch_tensors, [10, 11]) - for i in range(len(batch_tensors)): - img_tensor = batch_tensors[i, ...] - tuple_transformed_imgs = F.ten_crop(img_tensor, [10, 11]) - self.assertEqual(len(tuple_transformed_imgs), len(tuple_transformed_batches)) - - for j in range(len(tuple_transformed_imgs)): - true_transformed_img = tuple_transformed_imgs[j] - transformed_img = tuple_transformed_batches[j][i, ...] - assert_equal(true_transformed_img, transformed_img) + def _test_rotate_all_options(self, tensor, pil_img, scripted_rotate, centers): + img_size = pil_img.size + dt = tensor.dtype + for r in [NEAREST, ]: + for a in range(-180, 180, 17): + for e in [True, False]: + for c in centers: + for f in [None, [0, 0, 0], (1, 2, 3), [255, 255, 255], [1, ], (2.0, )]: + f_pil = int(f[0]) if f is not None and len(f) == 1 else f + out_pil_img = F.rotate(pil_img, angle=a, interpolation=r, expand=e, center=c, fill=f_pil) + out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) + for fn in [F.rotate, scripted_rotate]: + out_tensor = fn(tensor, angle=a, interpolation=r, expand=e, center=c, fill=f).cpu() + + if out_tensor.dtype != torch.uint8: + out_tensor = out_tensor.to(torch.uint8) + + self.assertEqual( + out_tensor.shape, + out_pil_tensor.shape, + msg="{}: {} vs {}".format( + (img_size, r, dt, a, e, c), out_tensor.shape, out_pil_tensor.shape + )) + + num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 + ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] + # Tolerance : less than 3% of different pixels + self.assertLess( + ratio_diff_pixels, + 0.03, + msg="{}: {}\n{} vs \n{}".format( + (img_size, r, dt, a, e, c, f), + ratio_diff_pixels, + out_tensor[0, :7, :7], + out_pil_tensor[0, :7, :7] + ) + ) + + def test_rotate(self): + # Tests on square image + scripted_rotate = torch.jit.script(F.rotate) + + data = [_create_data(26, 26, device=self.device), _create_data(32, 26, device=self.device)] + for tensor, pil_img in data: + + img_size = pil_img.size + centers = [ + None, + (int(img_size[0] * 0.3), int(img_size[0] * 0.4)), + [int(img_size[0] * 0.5), int(img_size[0] * 0.6)] + ] + + for dt in [None, torch.float32, torch.float64, torch.float16]: + + if dt == torch.float16 and torch.device(self.device).type == "cpu": + # skip float16 on CPU case + continue + + if dt is not None: + tensor = tensor.to(dtype=dt) + + self._test_rotate_all_options(tensor, pil_img, scripted_rotate, centers) + + batch_tensors = _create_data_batch(26, 36, num_samples=4, device=self.device) + if dt is not None: + batch_tensors = batch_tensors.to(dtype=dt) + + center = (20, 22) + _test_fn_on_batch( + batch_tensors, F.rotate, angle=32, interpolation=NEAREST, expand=True, center=center + ) + tensor, pil_img = data[0] + # assert deprecation warning and non-BC + with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"): + res1 = F.rotate(tensor, 45, resample=2) + res2 = F.rotate(tensor, 45, interpolation=BILINEAR) + assert_equal(res1, res2) - # scriptable function test - s_tuple_transformed_batches = script_ten_crop(batch_tensors, [10, 11]) - for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): - assert_equal(transformed_batch, s_transformed_batch) + # assert changed type warning + with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): + res1 = F.rotate(tensor, 45, interpolation=2) + res2 = F.rotate(tensor, 45, interpolation=BILINEAR) + assert_equal(res1, res2) @unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device") @@ -1174,5 +1103,172 @@ def test_gaussian_blur(device, image_size, dt, ksize, sigma, fn): ) +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_hsv2rgb(device): + scripted_fn = torch.jit.script(F_t._hsv2rgb) + shape = (3, 100, 150) + for _ in range(10): + hsv_img = torch.rand(*shape, dtype=torch.float, device=device) + rgb_img = F_t._hsv2rgb(hsv_img) + ft_img = rgb_img.permute(1, 2, 0).flatten(0, 1) + + h, s, v, = hsv_img.unbind(0) + h = h.flatten().cpu().numpy() + s = s.flatten().cpu().numpy() + v = v.flatten().cpu().numpy() + + rgb = [] + for h1, s1, v1 in zip(h, s, v): + rgb.append(colorsys.hsv_to_rgb(h1, s1, v1)) + colorsys_img = torch.tensor(rgb, dtype=torch.float32, device=device) + torch.testing.assert_close(ft_img, colorsys_img, rtol=0.0, atol=1e-5) + + s_rgb_img = scripted_fn(hsv_img) + torch.testing.assert_close(rgb_img, s_rgb_img) + + batch_tensors = _create_data_batch(120, 100, num_samples=4, device=device).float() + _test_fn_on_batch(batch_tensors, F_t._hsv2rgb) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_rgb2hsv(device): + scripted_fn = torch.jit.script(F_t._rgb2hsv) + shape = (3, 150, 100) + for _ in range(10): + rgb_img = torch.rand(*shape, dtype=torch.float, device=device) + hsv_img = F_t._rgb2hsv(rgb_img) + ft_hsv_img = hsv_img.permute(1, 2, 0).flatten(0, 1) + + r, g, b, = rgb_img.unbind(dim=-3) + r = r.flatten().cpu().numpy() + g = g.flatten().cpu().numpy() + b = b.flatten().cpu().numpy() + + hsv = [] + for r1, g1, b1 in zip(r, g, b): + hsv.append(colorsys.rgb_to_hsv(r1, g1, b1)) + + colorsys_img = torch.tensor(hsv, dtype=torch.float32, device=device) + + ft_hsv_img_h, ft_hsv_img_sv = torch.split(ft_hsv_img, [1, 2], dim=1) + colorsys_img_h, colorsys_img_sv = torch.split(colorsys_img, [1, 2], dim=1) + + max_diff_h = ((colorsys_img_h * 2 * math.pi).sin() - (ft_hsv_img_h * 2 * math.pi).sin()).abs().max() + max_diff_sv = (colorsys_img_sv - ft_hsv_img_sv).abs().max() + max_diff = max(max_diff_h, max_diff_sv) + assert max_diff < 1e-5 + + s_hsv_img = scripted_fn(rgb_img) + torch.testing.assert_close(hsv_img, s_hsv_img, rtol=1e-5, atol=1e-7) + + batch_tensors = _create_data_batch(120, 100, num_samples=4, device=device).float() + _test_fn_on_batch(batch_tensors, F_t._rgb2hsv) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('num_output_channels', (3, 1)) +def test_rgb_to_grayscale(device, num_output_channels): + script_rgb_to_grayscale = torch.jit.script(F.rgb_to_grayscale) + + img_tensor, pil_img = _create_data(32, 34, device=device) + + gray_pil_image = F.rgb_to_grayscale(pil_img, num_output_channels=num_output_channels) + gray_tensor = F.rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) + + _assert_approx_equal_tensor_to_pil(gray_tensor.float(), gray_pil_image, tol=1.0 + 1e-10, agg_method="max") + + s_gray_tensor = script_rgb_to_grayscale(img_tensor, num_output_channels=num_output_channels) + assert_equal(s_gray_tensor, gray_tensor) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + _test_fn_on_batch(batch_tensors, F.rgb_to_grayscale, num_output_channels=num_output_channels) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_center_crop(device): + script_center_crop = torch.jit.script(F.center_crop) + + img_tensor, pil_img = _create_data(32, 34, device=device) + + cropped_pil_image = F.center_crop(pil_img, [10, 11]) + + cropped_tensor = F.center_crop(img_tensor, [10, 11]) + _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) + + cropped_tensor = script_center_crop(img_tensor, [10, 11]) + _assert_equal_tensor_to_pil(cropped_tensor, cropped_pil_image) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + _test_fn_on_batch(batch_tensors, F.center_crop, output_size=[10, 11]) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_five_crop(device): + script_five_crop = torch.jit.script(F.five_crop) + + img_tensor, pil_img = _create_data(32, 34, device=device) + + cropped_pil_images = F.five_crop(pil_img, [10, 11]) + + cropped_tensors = F.five_crop(img_tensor, [10, 11]) + for i in range(5): + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) + + cropped_tensors = script_five_crop(img_tensor, [10, 11]) + for i in range(5): + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + tuple_transformed_batches = F.five_crop(batch_tensors, [10, 11]) + for i in range(len(batch_tensors)): + img_tensor = batch_tensors[i, ...] + tuple_transformed_imgs = F.five_crop(img_tensor, [10, 11]) + assert len(tuple_transformed_imgs) == len(tuple_transformed_batches) + + for j in range(len(tuple_transformed_imgs)): + true_transformed_img = tuple_transformed_imgs[j] + transformed_img = tuple_transformed_batches[j][i, ...] + assert_equal(true_transformed_img, transformed_img) + + # scriptable function test + s_tuple_transformed_batches = script_five_crop(batch_tensors, [10, 11]) + for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): + assert_equal(transformed_batch, s_transformed_batch) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_ten_crop(device): + script_ten_crop = torch.jit.script(F.ten_crop) + + img_tensor, pil_img = _create_data(32, 34, device=device) + + cropped_pil_images = F.ten_crop(pil_img, [10, 11]) + + cropped_tensors = F.ten_crop(img_tensor, [10, 11]) + for i in range(10): + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) + + cropped_tensors = script_ten_crop(img_tensor, [10, 11]) + for i in range(10): + _assert_equal_tensor_to_pil(cropped_tensors[i], cropped_pil_images[i]) + + batch_tensors = _create_data_batch(16, 18, num_samples=4, device=device) + tuple_transformed_batches = F.ten_crop(batch_tensors, [10, 11]) + for i in range(len(batch_tensors)): + img_tensor = batch_tensors[i, ...] + tuple_transformed_imgs = F.ten_crop(img_tensor, [10, 11]) + assert len(tuple_transformed_imgs) == len(tuple_transformed_batches) + + for j in range(len(tuple_transformed_imgs)): + true_transformed_img = tuple_transformed_imgs[j] + transformed_img = tuple_transformed_batches[j][i, ...] + assert_equal(true_transformed_img, transformed_img) + + # scriptable function test + s_tuple_transformed_batches = script_ten_crop(batch_tensors, [10, 11]) + for transformed_batch, s_transformed_batch in zip(tuple_transformed_batches, s_tuple_transformed_batches): + assert_equal(transformed_batch, s_transformed_batch) + + if __name__ == '__main__': unittest.main() From 182f80df564668bdfd70e0f8aafe48ae63c2d167 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 7 Jun 2021 13:56:05 +0100 Subject: [PATCH 154/279] Finish porting test_functional_tensor.py to pytest (#3990) --- test/test_functional_tensor.py | 122 ++++----------------------------- 1 file changed, 13 insertions(+), 109 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index d0cb062ec2a..a02636ccdf9 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -1,6 +1,5 @@ import itertools import os -import unittest import colorsys import math @@ -31,113 +30,18 @@ NEAREST, BILINEAR, BICUBIC = InterpolationMode.NEAREST, InterpolationMode.BILINEAR, InterpolationMode.BICUBIC -class Tester(unittest.TestCase): - - def setUp(self): - self.device = "cpu" - - def _test_rotate_all_options(self, tensor, pil_img, scripted_rotate, centers): - img_size = pil_img.size - dt = tensor.dtype - for r in [NEAREST, ]: - for a in range(-180, 180, 17): - for e in [True, False]: - for c in centers: - for f in [None, [0, 0, 0], (1, 2, 3), [255, 255, 255], [1, ], (2.0, )]: - f_pil = int(f[0]) if f is not None and len(f) == 1 else f - out_pil_img = F.rotate(pil_img, angle=a, interpolation=r, expand=e, center=c, fill=f_pil) - out_pil_tensor = torch.from_numpy(np.array(out_pil_img).transpose((2, 0, 1))) - for fn in [F.rotate, scripted_rotate]: - out_tensor = fn(tensor, angle=a, interpolation=r, expand=e, center=c, fill=f).cpu() - - if out_tensor.dtype != torch.uint8: - out_tensor = out_tensor.to(torch.uint8) - - self.assertEqual( - out_tensor.shape, - out_pil_tensor.shape, - msg="{}: {} vs {}".format( - (img_size, r, dt, a, e, c), out_tensor.shape, out_pil_tensor.shape - )) - - num_diff_pixels = (out_tensor != out_pil_tensor).sum().item() / 3.0 - ratio_diff_pixels = num_diff_pixels / out_tensor.shape[-1] / out_tensor.shape[-2] - # Tolerance : less than 3% of different pixels - self.assertLess( - ratio_diff_pixels, - 0.03, - msg="{}: {}\n{} vs \n{}".format( - (img_size, r, dt, a, e, c, f), - ratio_diff_pixels, - out_tensor[0, :7, :7], - out_pil_tensor[0, :7, :7] - ) - ) - - def test_rotate(self): - # Tests on square image - scripted_rotate = torch.jit.script(F.rotate) - - data = [_create_data(26, 26, device=self.device), _create_data(32, 26, device=self.device)] - for tensor, pil_img in data: - - img_size = pil_img.size - centers = [ - None, - (int(img_size[0] * 0.3), int(img_size[0] * 0.4)), - [int(img_size[0] * 0.5), int(img_size[0] * 0.6)] - ] - - for dt in [None, torch.float32, torch.float64, torch.float16]: - - if dt == torch.float16 and torch.device(self.device).type == "cpu": - # skip float16 on CPU case - continue - - if dt is not None: - tensor = tensor.to(dtype=dt) - - self._test_rotate_all_options(tensor, pil_img, scripted_rotate, centers) - - batch_tensors = _create_data_batch(26, 36, num_samples=4, device=self.device) - if dt is not None: - batch_tensors = batch_tensors.to(dtype=dt) - - center = (20, 22) - _test_fn_on_batch( - batch_tensors, F.rotate, angle=32, interpolation=NEAREST, expand=True, center=center - ) - tensor, pil_img = data[0] - # assert deprecation warning and non-BC - with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"): - res1 = F.rotate(tensor, 45, resample=2) - res2 = F.rotate(tensor, 45, interpolation=BILINEAR) - assert_equal(res1, res2) - - # assert changed type warning - with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): - res1 = F.rotate(tensor, 45, interpolation=2) - res2 = F.rotate(tensor, 45, interpolation=BILINEAR) - assert_equal(res1, res2) - - -@unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device") -class CUDATester(Tester): - - def setUp(self): - self.device = "cuda" - - def test_scale_channel(self): - """Make sure that _scale_channel gives the same results on CPU and GPU as - histc or bincount are used depending on the device. - """ - # TODO: when # https://github.com/pytorch/pytorch/issues/53194 is fixed, - # only use bincount and remove that test. - size = (1_000,) - img_chan = torch.randint(0, 256, size=size).to('cpu') - scaled_cpu = F_t._scale_channel(img_chan) - scaled_cuda = F_t._scale_channel(img_chan.to('cuda')) - assert_equal(scaled_cpu, scaled_cuda.to('cpu')) +@needs_cuda +def test_scale_channel(): + """Make sure that _scale_channel gives the same results on CPU and GPU as + histc or bincount are used depending on the device. + """ + # TODO: when # https://github.com/pytorch/pytorch/issues/53194 is fixed, + # only use bincount and remove that test. + size = (1_000,) + img_chan = torch.randint(0, 256, size=size).to('cpu') + scaled_cpu = F_t._scale_channel(img_chan) + scaled_cuda = F_t._scale_channel(img_chan.to('cuda')) + assert_equal(scaled_cpu, scaled_cuda.to('cpu')) class TestRotate: @@ -1271,4 +1175,4 @@ def test_ten_crop(device): if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From 0013d9314cf1bd83eaf38c3ac6e0e9342fa99683 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 7 Jun 2021 15:15:45 +0100 Subject: [PATCH 155/279] Port test_backbone_utils.py to pytest (#3991) --- test/test_backbone_utils.py | 26 ++++++-------------------- 1 file changed, 6 insertions(+), 20 deletions(-) diff --git a/test/test_backbone_utils.py b/test/test_backbone_utils.py index 7ee1aed1459..712dccf11a8 100644 --- a/test/test_backbone_utils.py +++ b/test/test_backbone_utils.py @@ -1,25 +1,11 @@ -import unittest - - import torch from torchvision.models.detection.backbone_utils import resnet_fpn_backbone +import pytest -class ResnetFPNBackboneTester(unittest.TestCase): - @classmethod - def setUpClass(cls): - cls.dtype = torch.float32 - - def test_resnet18_fpn_backbone(self): - device = torch.device('cpu') - x = torch.rand(1, 3, 300, 300, dtype=self.dtype, device=device) - resnet18_fpn = resnet_fpn_backbone(backbone_name='resnet18', pretrained=False) - y = resnet18_fpn(x) - self.assertEqual(list(y.keys()), ['0', '1', '2', '3', 'pool']) - def test_resnet50_fpn_backbone(self): - device = torch.device('cpu') - x = torch.rand(1, 3, 300, 300, dtype=self.dtype, device=device) - resnet50_fpn = resnet_fpn_backbone(backbone_name='resnet50', pretrained=False) - y = resnet50_fpn(x) - self.assertEqual(list(y.keys()), ['0', '1', '2', '3', 'pool']) +@pytest.mark.parametrize('backbone_name', ('resnet18', 'resnet50')) +def test_resnet_fpn_backbone(backbone_name): + x = torch.rand(1, 3, 300, 300, dtype=torch.float32, device='cpu') + y = resnet_fpn_backbone(backbone_name=backbone_name, pretrained=False)(x) + assert list(y.keys()) == ['0', '1', '2', '3', 'pool'] From 27bdb8cfa5d85bedac03cbf46254d7861a210462 Mon Sep 17 00:00:00 2001 From: Anirudh Date: Tue, 8 Jun 2021 14:42:11 +0530 Subject: [PATCH 156/279] port test_accimage_xxx in test_transforms to pytest (#3985) --- test/test_transforms.py | 108 ++++++++++++++++++++-------------------- 1 file changed, 54 insertions(+), 54 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index bf3a030f285..c77cf179dd7 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -330,60 +330,6 @@ def test_convert_image_dtype_int_to_int_consistency(self): self.assertEqual(actual_min, desired_min) self.assertEqual(actual_max, desired_max) - @unittest.skipIf(accimage is None, 'accimage not available') - def test_accimage_to_tensor(self): - trans = transforms.ToTensor() - - expected_output = trans(Image.open(GRACE_HOPPER).convert('RGB')) - output = trans(accimage.Image(GRACE_HOPPER)) - - torch.testing.assert_close(output, expected_output) - - @unittest.skipIf(accimage is None, 'accimage not available') - def test_accimage_pil_to_tensor(self): - trans = transforms.PILToTensor() - - expected_output = trans(Image.open(GRACE_HOPPER).convert('RGB')) - output = trans(accimage.Image(GRACE_HOPPER)) - - self.assertEqual(expected_output.size(), output.size()) - torch.testing.assert_close(output, expected_output, check_stride=False) - - @unittest.skipIf(accimage is None, 'accimage not available') - def test_accimage_resize(self): - trans = transforms.Compose([ - transforms.Resize(256, interpolation=Image.LINEAR), - transforms.ToTensor(), - ]) - - # Checking if Compose, Resize and ToTensor can be printed as string - trans.__repr__() - - expected_output = trans(Image.open(GRACE_HOPPER).convert('RGB')) - output = trans(accimage.Image(GRACE_HOPPER)) - - self.assertEqual(expected_output.size(), output.size()) - self.assertLess(np.abs((expected_output - output).mean()), 1e-3) - self.assertLess((expected_output - output).var(), 1e-5) - # note the high absolute tolerance - self.assertTrue(np.allclose(output.numpy(), expected_output.numpy(), atol=5e-2)) - - @unittest.skipIf(accimage is None, 'accimage not available') - def test_accimage_crop(self): - trans = transforms.Compose([ - transforms.CenterCrop(256), - transforms.ToTensor(), - ]) - - # Checking if Compose, CenterCrop and ToTensor can be printed as string - trans.__repr__() - - expected_output = trans(Image.open(GRACE_HOPPER).convert('RGB')) - output = trans(accimage.Image(GRACE_HOPPER)) - - self.assertEqual(expected_output.size(), output.size()) - torch.testing.assert_close(output, expected_output) - def test_color_jitter(self): color_jitter = transforms.ColorJitter(2, 2, 2, 0.1) @@ -613,6 +559,60 @@ def test_autoaugment(self): transform.__repr__() +@pytest.mark.skipif(accimage is None, reason="accimage not available") +class TestAccImage: + + def test_accimage_to_tensor(self): + trans = transforms.ToTensor() + + expected_output = trans(Image.open(GRACE_HOPPER).convert('RGB')) + output = trans(accimage.Image(GRACE_HOPPER)) + + torch.testing.assert_close(output, expected_output) + + def test_accimage_pil_to_tensor(self): + trans = transforms.PILToTensor() + + expected_output = trans(Image.open(GRACE_HOPPER).convert('RGB')) + output = trans(accimage.Image(GRACE_HOPPER)) + + assert expected_output.size() == output.size() + torch.testing.assert_close(output, expected_output, check_stride=False) + + def test_accimage_resize(self): + trans = transforms.Compose([ + transforms.Resize(256, interpolation=Image.LINEAR), + transforms.ToTensor(), + ]) + + # Checking if Compose, Resize and ToTensor can be printed as string + trans.__repr__() + + expected_output = trans(Image.open(GRACE_HOPPER).convert('RGB')) + output = trans(accimage.Image(GRACE_HOPPER)) + + assert expected_output.size() == output.size() + assert np.abs((expected_output - output).mean()) < 1e-3 + assert (expected_output - output).var() < 1e-5 + # note the high absolute tolerance + torch.testing.assert_close(output.numpy(), expected_output.numpy(), rtol=1e-5, atol=5e-2) + + def test_accimage_crop(self): + trans = transforms.Compose([ + transforms.CenterCrop(256), + transforms.ToTensor(), + ]) + + # Checking if Compose, CenterCrop and ToTensor can be printed as string + trans.__repr__() + + expected_output = trans(Image.open(GRACE_HOPPER).convert('RGB')) + output = trans(accimage.Image(GRACE_HOPPER)) + + assert expected_output.size() == output.size() + torch.testing.assert_close(output, expected_output) + + @pytest.mark.parametrize('channels', [1, 3, 4]) def test_to_tensor(channels): height, width = 4, 4 From 9dca76df50fae4041827da9a54ab4ba327aae1a4 Mon Sep 17 00:00:00 2001 From: Ishan Kumar Date: Tue, 8 Jun 2021 15:10:31 +0530 Subject: [PATCH 157/279] Port affine transform tests in test_tranforms to pytest (#3984) --- test/test_transforms.py | 362 ++++++++++++++++++++++------------------ 1 file changed, 195 insertions(+), 167 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index c77cf179dd7..a23bda42bd0 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -381,173 +381,6 @@ def test_linear_transformation(self): # Checking if LinearTransformation can be printed as string whitening.__repr__() - def test_affine(self): - input_img = np.zeros((40, 40, 3), dtype=np.uint8) - cnt = [20, 20] - for pt in [(16, 16), (20, 16), (20, 20)]: - for i in range(-5, 5): - for j in range(-5, 5): - input_img[pt[0] + i, pt[1] + j, :] = [255, 155, 55] - - with self.assertRaises(TypeError, msg="Argument translate should be a sequence"): - F.affine(input_img, 10, translate=0, scale=1, shear=1) - - pil_img = F.to_pil_image(input_img) - - def _to_3x3_inv(inv_result_matrix): - result_matrix = np.zeros((3, 3)) - result_matrix[:2, :] = np.array(inv_result_matrix).reshape((2, 3)) - result_matrix[2, 2] = 1 - return np.linalg.inv(result_matrix) - - def _test_transformation(a, t, s, sh): - a_rad = math.radians(a) - s_rad = [math.radians(sh_) for sh_ in sh] - cx, cy = cnt - tx, ty = t - sx, sy = s_rad - rot = a_rad - - # 1) Check transformation matrix: - C = np.array([[1, 0, cx], - [0, 1, cy], - [0, 0, 1]]) - T = np.array([[1, 0, tx], - [0, 1, ty], - [0, 0, 1]]) - Cinv = np.linalg.inv(C) - - RS = np.array( - [[s * math.cos(rot), -s * math.sin(rot), 0], - [s * math.sin(rot), s * math.cos(rot), 0], - [0, 0, 1]]) - - SHx = np.array([[1, -math.tan(sx), 0], - [0, 1, 0], - [0, 0, 1]]) - - SHy = np.array([[1, 0, 0], - [-math.tan(sy), 1, 0], - [0, 0, 1]]) - - RSS = np.matmul(RS, np.matmul(SHy, SHx)) - - true_matrix = np.matmul(T, np.matmul(C, np.matmul(RSS, Cinv))) - - result_matrix = _to_3x3_inv(F._get_inverse_affine_matrix(center=cnt, angle=a, - translate=t, scale=s, shear=sh)) - self.assertLess(np.sum(np.abs(true_matrix - result_matrix)), 1e-10) - # 2) Perform inverse mapping: - true_result = np.zeros((40, 40, 3), dtype=np.uint8) - inv_true_matrix = np.linalg.inv(true_matrix) - for y in range(true_result.shape[0]): - for x in range(true_result.shape[1]): - # Same as for PIL: - # https://github.com/python-pillow/Pillow/blob/71f8ec6a0cfc1008076a023c0756542539d057ab/ - # src/libImaging/Geometry.c#L1060 - input_pt = np.array([x + 0.5, y + 0.5, 1.0]) - res = np.floor(np.dot(inv_true_matrix, input_pt)).astype(np.int) - _x, _y = res[:2] - if 0 <= _x < input_img.shape[1] and 0 <= _y < input_img.shape[0]: - true_result[y, x, :] = input_img[_y, _x, :] - - result = F.affine(pil_img, angle=a, translate=t, scale=s, shear=sh) - self.assertEqual(result.size, pil_img.size) - # Compute number of different pixels: - np_result = np.array(result) - n_diff_pixels = np.sum(np_result != true_result) / 3 - # Accept 3 wrong pixels - self.assertLess(n_diff_pixels, 3, - "a={}, t={}, s={}, sh={}\n".format(a, t, s, sh) + - "n diff pixels={}\n".format(n_diff_pixels)) - - # Test rotation - a = 45 - _test_transformation(a=a, t=(0, 0), s=1.0, sh=(0.0, 0.0)) - - # Test translation - t = [10, 15] - _test_transformation(a=0.0, t=t, s=1.0, sh=(0.0, 0.0)) - - # Test scale - s = 1.2 - _test_transformation(a=0.0, t=(0.0, 0.0), s=s, sh=(0.0, 0.0)) - - # Test shear - sh = [45.0, 25.0] - _test_transformation(a=0.0, t=(0.0, 0.0), s=1.0, sh=sh) - - # Test rotation, scale, translation, shear - for a in range(-90, 90, 36): - for t1 in range(-10, 10, 5): - for s in [0.77, 1.0, 1.27]: - for sh in range(-15, 15, 5): - _test_transformation(a=a, t=(t1, t1), s=s, sh=(sh, sh)) - - def test_random_affine(self): - - with self.assertRaises(ValueError): - transforms.RandomAffine(-0.7) - transforms.RandomAffine([-0.7]) - transforms.RandomAffine([-0.7, 0, 0.7]) - - transforms.RandomAffine([-90, 90], translate=2.0) - transforms.RandomAffine([-90, 90], translate=[-1.0, 1.0]) - transforms.RandomAffine([-90, 90], translate=[-1.0, 0.0, 1.0]) - - transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.0]) - transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[-1.0, 1.0]) - transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, -0.5]) - transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 3.0, -0.5]) - - transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=-7) - transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10]) - transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10, 0, 10]) - transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10, 0, 10, 0, 10]) - - # assert fill being either a Sequence or a Number - with self.assertRaises(TypeError): - transforms.RandomAffine(0, fill={}) - - t = transforms.RandomAffine(0, fill=None) - self.assertTrue(t.fill == 0) - - x = np.zeros((100, 100, 3), dtype=np.uint8) - img = F.to_pil_image(x) - - t = transforms.RandomAffine(10, translate=[0.5, 0.3], scale=[0.7, 1.3], shear=[-10, 10, 20, 40]) - for _ in range(100): - angle, translations, scale, shear = t.get_params(t.degrees, t.translate, t.scale, t.shear, - img_size=img.size) - self.assertTrue(-10 < angle < 10) - self.assertTrue(-img.size[0] * 0.5 <= translations[0] <= img.size[0] * 0.5, - "{} vs {}".format(translations[0], img.size[0] * 0.5)) - self.assertTrue(-img.size[1] * 0.5 <= translations[1] <= img.size[1] * 0.5, - "{} vs {}".format(translations[1], img.size[1] * 0.5)) - self.assertTrue(0.7 < scale < 1.3) - self.assertTrue(-10 < shear[0] < 10) - self.assertTrue(-20 < shear[1] < 40) - - # Checking if RandomAffine can be printed as string - t.__repr__() - - t = transforms.RandomAffine(10, interpolation=transforms.InterpolationMode.BILINEAR) - self.assertIn("bilinear", t.__repr__()) - - # assert deprecation warning and non-BC - with self.assertWarnsRegex(UserWarning, r"Argument resample is deprecated and will be removed"): - t = transforms.RandomAffine(10, resample=2) - self.assertEqual(t.interpolation, transforms.InterpolationMode.BILINEAR) - - with self.assertWarnsRegex(UserWarning, r"Argument fillcolor is deprecated and will be removed"): - t = transforms.RandomAffine(10, fillcolor=10) - self.assertEqual(t.fill, 10) - - # assert changed type warning - with self.assertWarnsRegex(UserWarning, r"Argument interpolation should be of type InterpolationMode"): - t = transforms.RandomAffine(10, interpolation=2) - self.assertEqual(t.interpolation, transforms.InterpolationMode.BILINEAR) - def test_autoaugment(self): for policy in transforms.AutoAugmentPolicy: for fill in [None, 85, (128, 128, 128)]: @@ -2090,5 +1923,200 @@ def test_normalize_3d_tensor(): torch.testing.assert_close(target, result2) +class TestAffine: + + @pytest.fixture(scope='class') + def input_img(self): + input_img = np.zeros((40, 40, 3), dtype=np.uint8) + for pt in [(16, 16), (20, 16), (20, 20)]: + for i in range(-5, 5): + for j in range(-5, 5): + input_img[pt[0] + i, pt[1] + j, :] = [255, 155, 55] + return input_img + + def test_affine_translate_seq(self, input_img): + with pytest.raises(TypeError, match=r"Argument translate should be a sequence"): + F.affine(input_img, 10, translate=0, scale=1, shear=1) + + @pytest.fixture(scope='class') + def pil_image(self, input_img): + return F.to_pil_image(input_img) + + def _to_3x3_inv(self, inv_result_matrix): + result_matrix = np.zeros((3, 3)) + result_matrix[:2, :] = np.array(inv_result_matrix).reshape((2, 3)) + result_matrix[2, 2] = 1 + return np.linalg.inv(result_matrix) + + def _test_transformation(self, angle, translate, scale, shear, pil_image, input_img): + + a_rad = math.radians(angle) + s_rad = [math.radians(sh_) for sh_ in shear] + cnt = [20, 20] + cx, cy = cnt + tx, ty = translate + sx, sy = s_rad + rot = a_rad + + # 1) Check transformation matrix: + C = np.array([[1, 0, cx], + [0, 1, cy], + [0, 0, 1]]) + T = np.array([[1, 0, tx], + [0, 1, ty], + [0, 0, 1]]) + Cinv = np.linalg.inv(C) + + RS = np.array( + [[scale * math.cos(rot), -scale * math.sin(rot), 0], + [scale * math.sin(rot), scale * math.cos(rot), 0], + [0, 0, 1]]) + + SHx = np.array([[1, -math.tan(sx), 0], + [0, 1, 0], + [0, 0, 1]]) + + SHy = np.array([[1, 0, 0], + [-math.tan(sy), 1, 0], + [0, 0, 1]]) + + RSS = np.matmul(RS, np.matmul(SHy, SHx)) + + true_matrix = np.matmul(T, np.matmul(C, np.matmul(RSS, Cinv))) + + result_matrix = self._to_3x3_inv(F._get_inverse_affine_matrix(center=cnt, angle=angle, + translate=translate, scale=scale, shear=shear)) + assert np.sum(np.abs(true_matrix - result_matrix)) < 1e-10 + # 2) Perform inverse mapping: + true_result = np.zeros((40, 40, 3), dtype=np.uint8) + inv_true_matrix = np.linalg.inv(true_matrix) + for y in range(true_result.shape[0]): + for x in range(true_result.shape[1]): + # Same as for PIL: + # https://github.com/python-pillow/Pillow/blob/71f8ec6a0cfc1008076a023c0756542539d057ab/ + # src/libImaging/Geometry.c#L1060 + input_pt = np.array([x + 0.5, y + 0.5, 1.0]) + res = np.floor(np.dot(inv_true_matrix, input_pt)).astype(np.int) + _x, _y = res[:2] + if 0 <= _x < input_img.shape[1] and 0 <= _y < input_img.shape[0]: + true_result[y, x, :] = input_img[_y, _x, :] + + result = F.affine(pil_image, angle=angle, translate=translate, scale=scale, shear=shear) + assert result.size == pil_image.size + # Compute number of different pixels: + np_result = np.array(result) + n_diff_pixels = np.sum(np_result != true_result) / 3 + # Accept 3 wrong pixels + error_msg = ("angle={}, translate={}, scale={}, shear={}\n".format(angle, translate, scale, shear) + + "n diff pixels={}\n".format(n_diff_pixels)) + assert n_diff_pixels < 3, error_msg + + def test_transformation_discrete(self, pil_image, input_img): + # Test rotation + angle = 45 + self._test_transformation(angle=angle, translate=(0, 0), scale=1.0, + shear=(0.0, 0.0), pil_image=pil_image, input_img=input_img) + + # Test translation + translate = [10, 15] + self._test_transformation(angle=0.0, translate=translate, scale=1.0, + shear=(0.0, 0.0), pil_image=pil_image, input_img=input_img) + + # Test scale + scale = 1.2 + self._test_transformation(angle=0.0, translate=(0.0, 0.0), scale=scale, + shear=(0.0, 0.0), pil_image=pil_image, input_img=input_img) + + # Test shear + shear = [45.0, 25.0] + self._test_transformation(angle=0.0, translate=(0.0, 0.0), scale=1.0, + shear=shear, pil_image=pil_image, input_img=input_img) + + @pytest.mark.parametrize("angle", range(-90, 90, 36)) + @pytest.mark.parametrize("translate", range(-10, 10, 5)) + @pytest.mark.parametrize("scale", [0.77, 1.0, 1.27]) + @pytest.mark.parametrize("shear", range(-15, 15, 5)) + def test_transformation_range(self, angle, translate, scale, shear, pil_image, input_img): + self._test_transformation(angle=angle, translate=(translate, translate), scale=scale, + shear=(shear, shear), pil_image=pil_image, input_img=input_img) + + +def test_random_affine(): + + with pytest.raises(ValueError): + transforms.RandomAffine(-0.7) + with pytest.raises(ValueError): + transforms.RandomAffine([-0.7]) + with pytest.raises(ValueError): + transforms.RandomAffine([-0.7, 0, 0.7]) + with pytest.raises(TypeError): + transforms.RandomAffine([-90, 90], translate=2.0) + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[-1.0, 1.0]) + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[-1.0, 0.0, 1.0]) + + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.0]) + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[-1.0, 1.0]) + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, -0.5]) + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 3.0, -0.5]) + + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=-7) + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10]) + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10, 0, 10]) + with pytest.raises(ValueError): + transforms.RandomAffine([-90, 90], translate=[0.2, 0.2], scale=[0.5, 0.5], shear=[-10, 0, 10, 0, 10]) + + # assert fill being either a Sequence or a Number + with pytest.raises(TypeError): + transforms.RandomAffine(0, fill={}) + + t = transforms.RandomAffine(0, fill=None) + assert t.fill == 0 + + x = np.zeros((100, 100, 3), dtype=np.uint8) + img = F.to_pil_image(x) + + t = transforms.RandomAffine(10, translate=[0.5, 0.3], scale=[0.7, 1.3], shear=[-10, 10, 20, 40]) + for _ in range(100): + angle, translations, scale, shear = t.get_params(t.degrees, t.translate, t.scale, t.shear, + img_size=img.size) + assert -10 < angle < 10 + assert -img.size[0] * 0.5 <= translations[0] <= img.size[0] * 0.5, ("{} vs {}" + .format(translations[0], img.size[0] * 0.5)) + assert -img.size[1] * 0.5 <= translations[1] <= img.size[1] * 0.5, ("{} vs {}" + .format(translations[1], img.size[1] * 0.5)) + assert 0.7 < scale < 1.3 + assert -10 < shear[0] < 10 + assert -20 < shear[1] < 40 + + # Checking if RandomAffine can be printed as string + t.__repr__() + + t = transforms.RandomAffine(10, interpolation=transforms.InterpolationMode.BILINEAR) + assert "bilinear" in t.__repr__() + + # assert deprecation warning and non-BC + with pytest.warns(UserWarning, match=r"Argument resample is deprecated and will be removed"): + t = transforms.RandomAffine(10, resample=2) + assert t.interpolation == transforms.InterpolationMode.BILINEAR + + with pytest.warns(UserWarning, match=r"Argument fillcolor is deprecated and will be removed"): + t = transforms.RandomAffine(10, fillcolor=10) + assert t.fill == 10 + + # assert changed type warning + with pytest.warns(UserWarning, match=r"Argument interpolation should be of type InterpolationMode"): + t = transforms.RandomAffine(10, interpolation=2) + assert t.interpolation == transforms.InterpolationMode.BILINEAR + + if __name__ == '__main__': unittest.main() From befbe1b372e7c028a7b4cb2155110fbae708038e Mon Sep 17 00:00:00 2001 From: S Harish <46412734+harishsdev@users.noreply.github.com> Date: Tue, 8 Jun 2021 15:58:00 +0530 Subject: [PATCH 158/279] Port some tests to pytest in test_transforms.py (#3981) --- test/test_transforms.py | 481 ++++++++++++++++++++-------------------- 1 file changed, 241 insertions(+), 240 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index a23bda42bd0..49396e78435 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -32,185 +32,6 @@ class Tester(unittest.TestCase): - def test_center_crop(self): - height = random.randint(10, 32) * 2 - width = random.randint(10, 32) * 2 - oheight = random.randint(5, (height - 2) / 2) * 2 - owidth = random.randint(5, (width - 2) / 2) * 2 - - img = torch.ones(3, height, width) - oh1 = (height - oheight) // 2 - ow1 = (width - owidth) // 2 - imgnarrow = img[:, oh1:oh1 + oheight, ow1:ow1 + owidth] - imgnarrow.fill_(0) - result = transforms.Compose([ - transforms.ToPILImage(), - transforms.CenterCrop((oheight, owidth)), - transforms.ToTensor(), - ])(img) - self.assertEqual(result.sum(), 0, - "height: {} width: {} oheight: {} owdith: {}".format(height, width, oheight, owidth)) - oheight += 1 - owidth += 1 - result = transforms.Compose([ - transforms.ToPILImage(), - transforms.CenterCrop((oheight, owidth)), - transforms.ToTensor(), - ])(img) - sum1 = result.sum() - self.assertGreater(sum1, 1, - "height: {} width: {} oheight: {} owdith: {}".format(height, width, oheight, owidth)) - oheight += 1 - owidth += 1 - result = transforms.Compose([ - transforms.ToPILImage(), - transforms.CenterCrop((oheight, owidth)), - transforms.ToTensor(), - ])(img) - sum2 = result.sum() - self.assertGreater(sum2, 0, - "height: {} width: {} oheight: {} owdith: {}".format(height, width, oheight, owidth)) - self.assertGreater(sum2, sum1, - "height: {} width: {} oheight: {} owdith: {}".format(height, width, oheight, owidth)) - - def test_center_crop_2(self): - """ Tests when center crop size is larger than image size, along any dimension""" - even_image_size = (random.randint(10, 32) * 2, random.randint(10, 32) * 2) - odd_image_size = (even_image_size[0] + 1, even_image_size[1] + 1) - - # Since height is independent of width, we can ignore images with odd height and even width and vice-versa. - input_image_sizes = [even_image_size, odd_image_size] - - # Get different crop sizes - delta = random.choice((1, 3, 5)) - crop_size_delta = [-2 * delta, -delta, 0, delta, 2 * delta] - crop_size_params = itertools.product(input_image_sizes, crop_size_delta, crop_size_delta) - - for (input_image_size, delta_height, delta_width) in crop_size_params: - img = torch.ones(3, *input_image_size) - crop_size = (input_image_size[0] + delta_height, input_image_size[1] + delta_width) - - # Test both transforms, one with PIL input and one with tensor - output_pil = transforms.Compose([ - transforms.ToPILImage(), - transforms.CenterCrop(crop_size), - transforms.ToTensor()], - )(img) - self.assertEqual(output_pil.size()[1:3], crop_size, - "image_size: {} crop_size: {}".format(input_image_size, crop_size)) - - output_tensor = transforms.CenterCrop(crop_size)(img) - self.assertEqual(output_tensor.size()[1:3], crop_size, - "image_size: {} crop_size: {}".format(input_image_size, crop_size)) - - # Ensure output for PIL and Tensor are equal - assert_equal( - output_tensor, output_pil, check_stride=False, - msg="image_size: {} crop_size: {}".format(input_image_size, crop_size) - ) - - # Check if content in center of both image and cropped output is same. - center_size = (min(crop_size[0], input_image_size[0]), min(crop_size[1], input_image_size[1])) - crop_center_tl, input_center_tl = [0, 0], [0, 0] - for index in range(2): - if crop_size[index] > input_image_size[index]: - crop_center_tl[index] = (crop_size[index] - input_image_size[index]) // 2 - else: - input_center_tl[index] = (input_image_size[index] - crop_size[index]) // 2 - - output_center = output_pil[ - :, - crop_center_tl[0]:crop_center_tl[0] + center_size[0], - crop_center_tl[1]:crop_center_tl[1] + center_size[1] - ] - - img_center = img[ - :, - input_center_tl[0]:input_center_tl[0] + center_size[0], - input_center_tl[1]:input_center_tl[1] + center_size[1] - ] - - assert_equal( - output_center, img_center, check_stride=False, - msg="image_size: {} crop_size: {}".format(input_image_size, crop_size) - ) - - def test_five_crop(self): - to_pil_image = transforms.ToPILImage() - h = random.randint(5, 25) - w = random.randint(5, 25) - for single_dim in [True, False]: - crop_h = random.randint(1, h) - crop_w = random.randint(1, w) - if single_dim: - crop_h = min(crop_h, crop_w) - crop_w = crop_h - transform = transforms.FiveCrop(crop_h) - else: - transform = transforms.FiveCrop((crop_h, crop_w)) - - img = torch.FloatTensor(3, h, w).uniform_() - results = transform(to_pil_image(img)) - - self.assertEqual(len(results), 5) - for crop in results: - self.assertEqual(crop.size, (crop_w, crop_h)) - - to_pil_image = transforms.ToPILImage() - tl = to_pil_image(img[:, 0:crop_h, 0:crop_w]) - tr = to_pil_image(img[:, 0:crop_h, w - crop_w:]) - bl = to_pil_image(img[:, h - crop_h:, 0:crop_w]) - br = to_pil_image(img[:, h - crop_h:, w - crop_w:]) - center = transforms.CenterCrop((crop_h, crop_w))(to_pil_image(img)) - expected_output = (tl, tr, bl, br, center) - self.assertEqual(results, expected_output) - - def test_ten_crop(self): - to_pil_image = transforms.ToPILImage() - h = random.randint(5, 25) - w = random.randint(5, 25) - for should_vflip in [True, False]: - for single_dim in [True, False]: - crop_h = random.randint(1, h) - crop_w = random.randint(1, w) - if single_dim: - crop_h = min(crop_h, crop_w) - crop_w = crop_h - transform = transforms.TenCrop(crop_h, - vertical_flip=should_vflip) - five_crop = transforms.FiveCrop(crop_h) - else: - transform = transforms.TenCrop((crop_h, crop_w), - vertical_flip=should_vflip) - five_crop = transforms.FiveCrop((crop_h, crop_w)) - - img = to_pil_image(torch.FloatTensor(3, h, w).uniform_()) - results = transform(img) - expected_output = five_crop(img) - - # Checking if FiveCrop and TenCrop can be printed as string - transform.__repr__() - five_crop.__repr__() - - if should_vflip: - vflipped_img = img.transpose(Image.FLIP_TOP_BOTTOM) - expected_output += five_crop(vflipped_img) - else: - hflipped_img = img.transpose(Image.FLIP_LEFT_RIGHT) - expected_output += five_crop(hflipped_img) - - self.assertEqual(len(results), 10) - self.assertEqual(results, expected_output) - - def test_max_value(self): - for dtype in int_dtypes(): - self.assertEqual(F_t._max_value(dtype), torch.iinfo(dtype).max) - - # remove float testing as it can lead to errors such as - # runtime error: 5.7896e+76 is outside the range of representable values of type 'float' - # for dtype in float_dtypes(): - # self.assertGreater(F_t._max_value(dtype), torch.finfo(dtype).max) - def test_convert_image_dtype_float_to_float(self): for input_dtype, output_dtypes in cycle_over(float_dtypes()): input_image = torch.tensor((0.0, 1.0), dtype=input_dtype) @@ -330,67 +151,6 @@ def test_convert_image_dtype_int_to_int_consistency(self): self.assertEqual(actual_min, desired_min) self.assertEqual(actual_max, desired_max) - def test_color_jitter(self): - color_jitter = transforms.ColorJitter(2, 2, 2, 0.1) - - x_shape = [2, 2, 3] - x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] - x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) - x_pil = Image.fromarray(x_np, mode='RGB') - x_pil_2 = x_pil.convert('L') - - for i in range(10): - y_pil = color_jitter(x_pil) - self.assertEqual(y_pil.mode, x_pil.mode) - - y_pil_2 = color_jitter(x_pil_2) - self.assertEqual(y_pil_2.mode, x_pil_2.mode) - - # Checking if ColorJitter can be printed as string - color_jitter.__repr__() - - def test_linear_transformation(self): - num_samples = 1000 - x = torch.randn(num_samples, 3, 10, 10) - flat_x = x.view(x.size(0), x.size(1) * x.size(2) * x.size(3)) - # compute principal components - sigma = torch.mm(flat_x.t(), flat_x) / flat_x.size(0) - u, s, _ = np.linalg.svd(sigma.numpy()) - zca_epsilon = 1e-10 # avoid division by 0 - d = torch.Tensor(np.diag(1. / np.sqrt(s + zca_epsilon))) - u = torch.Tensor(u) - principal_components = torch.mm(torch.mm(u, d), u.t()) - mean_vector = (torch.sum(flat_x, dim=0) / flat_x.size(0)) - # initialize whitening matrix - whitening = transforms.LinearTransformation(principal_components, mean_vector) - # estimate covariance and mean using weak law of large number - num_features = flat_x.size(1) - cov = 0.0 - mean = 0.0 - for i in x: - xwhite = whitening(i) - xwhite = xwhite.view(1, -1).numpy() - cov += np.dot(xwhite, xwhite.T) / num_features - mean += np.sum(xwhite) / num_features - # if rtol for std = 1e-3 then rtol for cov = 2e-3 as std**2 = cov - torch.testing.assert_close(cov / num_samples, np.identity(1), rtol=2e-3, atol=1e-8, check_dtype=False, - msg="cov not close to 1") - torch.testing.assert_close(mean / num_samples, 0, rtol=1e-3, atol=1e-8, check_dtype=False, - msg="mean not close to 0") - - # Checking if LinearTransformation can be printed as string - whitening.__repr__() - - def test_autoaugment(self): - for policy in transforms.AutoAugmentPolicy: - for fill in [None, 85, (128, 128, 128)]: - random.seed(42) - img = Image.open(GRACE_HOPPER) - transform = transforms.AutoAugment(policy=policy, fill=fill) - for _ in range(100): - img = transform(img) - transform.__repr__() - @pytest.mark.skipif(accimage is None, reason="accimage not available") class TestAccImage: @@ -1632,6 +1392,130 @@ def test_random_order(): random_order_transform.__repr__() +def test_linear_transformation(): + num_samples = 1000 + x = torch.randn(num_samples, 3, 10, 10) + flat_x = x.view(x.size(0), x.size(1) * x.size(2) * x.size(3)) + # compute principal components + sigma = torch.mm(flat_x.t(), flat_x) / flat_x.size(0) + u, s, _ = np.linalg.svd(sigma.numpy()) + zca_epsilon = 1e-10 # avoid division by 0 + d = torch.Tensor(np.diag(1. / np.sqrt(s + zca_epsilon))) + u = torch.Tensor(u) + principal_components = torch.mm(torch.mm(u, d), u.t()) + mean_vector = (torch.sum(flat_x, dim=0) / flat_x.size(0)) + # initialize whitening matrix + whitening = transforms.LinearTransformation(principal_components, mean_vector) + # estimate covariance and mean using weak law of large number + num_features = flat_x.size(1) + cov = 0.0 + mean = 0.0 + for i in x: + xwhite = whitening(i) + xwhite = xwhite.view(1, -1).numpy() + cov += np.dot(xwhite, xwhite.T) / num_features + mean += np.sum(xwhite) / num_features + # if rtol for std = 1e-3 then rtol for cov = 2e-3 as std**2 = cov + torch.testing.assert_close(cov / num_samples, np.identity(1), rtol=2e-3, atol=1e-8, check_dtype=False, + msg="cov not close to 1") + torch.testing.assert_close(mean / num_samples, 0, rtol=1e-3, atol=1e-8, check_dtype=False, + msg="mean not close to 0") + + # Checking if LinearTransformation can be printed as string + whitening.__repr__() + + +@pytest.mark.parametrize('dtype', int_dtypes()) +def test_max_value(dtype): + + assert F_t._max_value(dtype) == torch.iinfo(dtype).max + # remove float testing as it can lead to errors such as + # runtime error: 5.7896e+76 is outside the range of representable values of type 'float' + # for dtype in float_dtypes(): + # self.assertGreater(F_t._max_value(dtype), torch.finfo(dtype).max) + + +@pytest.mark.parametrize('should_vflip', [True, False]) +@pytest.mark.parametrize('single_dim', [True, False]) +def test_ten_crop(should_vflip, single_dim): + to_pil_image = transforms.ToPILImage() + h = random.randint(5, 25) + w = random.randint(5, 25) + crop_h = random.randint(1, h) + crop_w = random.randint(1, w) + if single_dim: + crop_h = min(crop_h, crop_w) + crop_w = crop_h + transform = transforms.TenCrop(crop_h, + vertical_flip=should_vflip) + five_crop = transforms.FiveCrop(crop_h) + else: + transform = transforms.TenCrop((crop_h, crop_w), + vertical_flip=should_vflip) + five_crop = transforms.FiveCrop((crop_h, crop_w)) + + img = to_pil_image(torch.FloatTensor(3, h, w).uniform_()) + results = transform(img) + expected_output = five_crop(img) + + # Checking if FiveCrop and TenCrop can be printed as string + transform.__repr__() + five_crop.__repr__() + + if should_vflip: + vflipped_img = img.transpose(Image.FLIP_TOP_BOTTOM) + expected_output += five_crop(vflipped_img) + else: + hflipped_img = img.transpose(Image.FLIP_LEFT_RIGHT) + expected_output += five_crop(hflipped_img) + + assert len(results) == 10 + assert results == expected_output + + +@pytest.mark.parametrize('single_dim', [True, False]) +def test_five_crop(single_dim): + to_pil_image = transforms.ToPILImage() + h = random.randint(5, 25) + w = random.randint(5, 25) + crop_h = random.randint(1, h) + crop_w = random.randint(1, w) + if single_dim: + crop_h = min(crop_h, crop_w) + crop_w = crop_h + transform = transforms.FiveCrop(crop_h) + else: + transform = transforms.FiveCrop((crop_h, crop_w)) + + img = torch.FloatTensor(3, h, w).uniform_() + + results = transform(to_pil_image(img)) + + assert len(results) == 5 + for crop in results: + assert crop.size == (crop_w, crop_h) + + to_pil_image = transforms.ToPILImage() + tl = to_pil_image(img[:, 0:crop_h, 0:crop_w]) + tr = to_pil_image(img[:, 0:crop_h, w - crop_w:]) + bl = to_pil_image(img[:, h - crop_h:, 0:crop_w]) + br = to_pil_image(img[:, h - crop_h:, w - crop_w:]) + center = transforms.CenterCrop((crop_h, crop_w))(to_pil_image(img)) + expected_output = (tl, tr, bl, br, center) + assert results == expected_output + + +@pytest.mark.parametrize('policy', transforms.AutoAugmentPolicy) +@pytest.mark.parametrize('fill', [None, 85, (128, 128, 128)]) +def test_autoaugment(policy, fill): + random.seed(42) + img = Image.open(GRACE_HOPPER) + transform = transforms.AutoAugment(policy=policy, fill=fill) + for _ in range(100): + img = transform(img) + transform.__repr__() + + def test_random_crop(): height = random.randint(10, 32) * 2 width = random.randint(10, 32) * 2 @@ -1678,6 +1562,123 @@ def test_random_crop(): t(img) +def test_center_crop(): + height = random.randint(10, 32) * 2 + width = random.randint(10, 32) * 2 + oheight = random.randint(5, (height - 2) / 2) * 2 + owidth = random.randint(5, (width - 2) / 2) * 2 + + img = torch.ones(3, height, width) + oh1 = (height - oheight) // 2 + ow1 = (width - owidth) // 2 + imgnarrow = img[:, oh1:oh1 + oheight, ow1:ow1 + owidth] + imgnarrow.fill_(0) + result = transforms.Compose([ + transforms.ToPILImage(), + transforms.CenterCrop((oheight, owidth)), + transforms.ToTensor(), + ])(img) + assert result.sum() == 0 + oheight += 1 + owidth += 1 + result = transforms.Compose([ + transforms.ToPILImage(), + transforms.CenterCrop((oheight, owidth)), + transforms.ToTensor(), + ])(img) + sum1 = result.sum() + assert sum1 > 1 + oheight += 1 + owidth += 1 + result = transforms.Compose([ + transforms.ToPILImage(), + transforms.CenterCrop((oheight, owidth)), + transforms.ToTensor(), + ])(img) + sum2 = result.sum() + assert sum2 > 0 + assert sum2 > sum1 + + +@pytest.mark.parametrize('odd_image_size', (True, False)) +@pytest.mark.parametrize('delta', (1, 3, 5)) +@pytest.mark.parametrize('delta_width', (-2, -1, 0, 1, 2)) +@pytest.mark.parametrize('delta_height', (-2, -1, 0, 1, 2)) +def test_center_crop_2(odd_image_size, delta, delta_width, delta_height): + """ Tests when center crop size is larger than image size, along any dimension""" + + # Since height is independent of width, we can ignore images with odd height and even width and vice-versa. + input_image_size = (random.randint(10, 32) * 2, random.randint(10, 32) * 2) + if odd_image_size: + input_image_size = (input_image_size[0] + 1, input_image_size[1] + 1) + + delta_height *= delta + delta_width *= delta + + img = torch.ones(3, *input_image_size) + crop_size = (input_image_size[0] + delta_height, input_image_size[1] + delta_width) + + # Test both transforms, one with PIL input and one with tensor + output_pil = transforms.Compose([ + transforms.ToPILImage(), + transforms.CenterCrop(crop_size), + transforms.ToTensor()], + )(img) + assert output_pil.size()[1:3] == crop_size + + output_tensor = transforms.CenterCrop(crop_size)(img) + assert output_tensor.size()[1:3] == crop_size + + # Ensure output for PIL and Tensor are equal + assert_equal( + output_tensor, output_pil, check_stride=False, + msg="image_size: {} crop_size: {}".format(input_image_size, crop_size) + ) + + # Check if content in center of both image and cropped output is same. + center_size = (min(crop_size[0], input_image_size[0]), min(crop_size[1], input_image_size[1])) + crop_center_tl, input_center_tl = [0, 0], [0, 0] + for index in range(2): + if crop_size[index] > input_image_size[index]: + crop_center_tl[index] = (crop_size[index] - input_image_size[index]) // 2 + else: + input_center_tl[index] = (input_image_size[index] - crop_size[index]) // 2 + + output_center = output_pil[ + :, + crop_center_tl[0]:crop_center_tl[0] + center_size[0], + crop_center_tl[1]:crop_center_tl[1] + center_size[1] + ] + + img_center = img[ + :, + input_center_tl[0]:input_center_tl[0] + center_size[0], + input_center_tl[1]:input_center_tl[1] + center_size[1] + ] + + assert_equal(output_center, img_center, check_stride=False) + + +def test_color_jitter(): + color_jitter = transforms.ColorJitter(2, 2, 2, 0.1) + + x_shape = [2, 2, 3] + x_data = [0, 5, 13, 54, 135, 226, 37, 8, 234, 90, 255, 1] + x_np = np.array(x_data, dtype=np.uint8).reshape(x_shape) + x_pil = Image.fromarray(x_np, mode='RGB') + x_pil_2 = x_pil.convert('L') + + for _ in range(10): + y_pil = color_jitter(x_pil) + assert y_pil.mode == x_pil.mode + + y_pil_2 = color_jitter(x_pil_2) + assert y_pil_2.mode == x_pil_2.mode + + # Checking if ColorJitter can be printed as string + color_jitter.__repr__() + + @pytest.mark.skipif(stats is None, reason="scipy.stats not available") def test_random_erasing(): img = torch.ones(3, 128, 128) From e4c56081ded40403bc3b53ff73ed819d6a46f33e Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Tue, 8 Jun 2021 20:52:21 +0100 Subject: [PATCH 159/279] Fixed comparison warnings in audio_stream and video_stream (#4007) * Fixed comparison warnings in audio_stream and video_stream * Fixed clang error --- torchvision/csrc/io/decoder/audio_stream.cpp | 8 ++++---- torchvision/csrc/io/decoder/video_stream.cpp | 6 ++++-- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/torchvision/csrc/io/decoder/audio_stream.cpp b/torchvision/csrc/io/decoder/audio_stream.cpp index 9d66e589bf3..3baebab9430 100644 --- a/torchvision/csrc/io/decoder/audio_stream.cpp +++ b/torchvision/csrc/io/decoder/audio_stream.cpp @@ -7,13 +7,13 @@ namespace ffmpeg { namespace { bool operator==(const AudioFormat& x, const AVFrame& y) { - return x.samples == y.sample_rate && x.channels == y.channels && - x.format == y.format; + return x.samples == static_cast(y.sample_rate) && + x.channels == static_cast(y.channels) && x.format == y.format; } bool operator==(const AudioFormat& x, const AVCodecContext& y) { - return x.samples == y.sample_rate && x.channels == y.channels && - x.format == y.sample_fmt; + return x.samples == static_cast(y.sample_rate) && + x.channels == static_cast(y.channels) && x.format == y.sample_fmt; } AudioFormat& toAudioFormat(AudioFormat& x, const AVFrame& y) { diff --git a/torchvision/csrc/io/decoder/video_stream.cpp b/torchvision/csrc/io/decoder/video_stream.cpp index a9e20434fe0..79e4a2dc399 100644 --- a/torchvision/csrc/io/decoder/video_stream.cpp +++ b/torchvision/csrc/io/decoder/video_stream.cpp @@ -6,11 +6,13 @@ namespace ffmpeg { namespace { bool operator==(const VideoFormat& x, const AVFrame& y) { - return x.width == y.width && x.height == y.height && x.format == y.format; + return x.width == static_cast(y.width) && + x.height == static_cast(y.height) && x.format == y.format; } bool operator==(const VideoFormat& x, const AVCodecContext& y) { - return x.width == y.width && x.height == y.height && x.format == y.pix_fmt; + return x.width == static_cast(y.width) && + x.height == static_cast(y.height) && x.format == y.pix_fmt; } VideoFormat& toVideoFormat(VideoFormat& x, const AVFrame& y) { From aaf240f1e85e073e67ed76a71df94e0601fcecc8 Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Wed, 9 Jun 2021 07:10:03 +0200 Subject: [PATCH 160/279] ping maintainers in case a PR was not properly labeled (#3993) * test label extraction * debug * debug * ping maintainers in case a PR was not properly labeled * flake8 * add required labels --- .github/process_pr.py | 78 +++++++++++++++++++++++++++++++++ .github/workflows/pr-labels.yml | 39 +++++++++++++++++ 2 files changed, 117 insertions(+) create mode 100644 .github/process_pr.py create mode 100644 .github/workflows/pr-labels.yml diff --git a/.github/process_pr.py b/.github/process_pr.py new file mode 100644 index 00000000000..f0f4c14f31b --- /dev/null +++ b/.github/process_pr.py @@ -0,0 +1,78 @@ +import json +import sys +from typing import Any, Dict, Set, Tuple + +import requests + +# If the PR has any of these labels, we mark it as properly labeled. +REQUIRED_LABELS = { + "new feature", + "bug", + "code quality", + "enhancement", + "bc-breaking", + "dependency issue", + "deprecation", + "module: c++ frontend", + "module: ci", + "module: datasets", + "module: documentation", + "module: io", + "module: models.quantization", + "module: models", + "module: onnx", + "module: ops", + "module: reference scripts", + "module: rocm", + "module: tests", + "module: transforms", + "module: utils", + "module: video", + "Perf", + "Revert(ed)", +} + + +def main(commit_hash: str) -> Dict[str, Any]: + pr_number = get_pr_number(commit_hash) + merger, labels = get_pr_merger_and_labels(pr_number) + is_properly_labeled = bool(REQUIRED_LABELS.intersection(labels)) + if not is_properly_labeled: + users = {merger, *get_pr_reviewers(pr_number)} + else: + users = () + return dict( + is_properly_labeled=is_properly_labeled, + responsible_users=", ".join(sorted([f"@{user}" for user in users])), + ) + + +def _query_torchvision(cmd: str, *, accept) -> Any: + response = requests.get(f"https://api.github.com/repos/pytorch/vision/{cmd}", headers=dict(Accept=accept)) + return response.json() + + +def get_pr_number(commit_hash: str) -> int: + # See https://docs.github.com/en/rest/reference/repos#list-pull-requests-associated-with-a-commit + data = _query_torchvision(f"commits/{commit_hash}/pulls", accept="application/vnd.github.groot-preview+json") + return data[0]["number"] + + +def get_pr_merger_and_labels(pr_number: int) -> Tuple[str, Set[str]]: + # See https://docs.github.com/en/rest/reference/pulls#get-a-pull-request + data = _query_torchvision(f"pulls/{pr_number}", accept="application/vnd.github.v3+json") + merger = data["merged_by"]["login"] + labels = {label["name"] for label in data["labels"]} + return merger, labels + + +def get_pr_reviewers(pr_number: int) -> Set[str]: + # See https://docs.github.com/en/rest/reference/pulls#list-reviews-for-a-pull-request + data = _query_torchvision(f"pulls/{pr_number}/reviews", accept="application/vnd.github.v3+json") + return {review["user"]["login"] for review in data if review["state"] == "APPROVED"} + + +if __name__ == "__main__": + commit_hash = sys.argv[1] + data = main(commit_hash) + print(json.dumps(data)) diff --git a/.github/workflows/pr-labels.yml b/.github/workflows/pr-labels.yml new file mode 100644 index 00000000000..398c9f75ae6 --- /dev/null +++ b/.github/workflows/pr-labels.yml @@ -0,0 +1,39 @@ +name: pr-labels + +on: + push: + branches: + - master + +jobs: + is-properly-labeled: + runs-on: ubuntu-latest + + steps: + - name: Set up python + uses: actions/setup-python@v2 + + - name: Install requests + run: pip install requests + + - name: Checkout repository + uses: actions/checkout@v2 + + - name: Process PR associated with current commit + id: data + run: | + DATA=$(python .github/foo.py ${{ github.sha }}) + jq . <<< $DATA + echo "::set-output name=is_properly_labeled::$(jq .is_properly_labeled <<< $DATA)" + echo "::set-output name=responsible_users::$(jq .responsible_users <<< $DATA)" + + - name: Ping responsible users + if: steps.data.outputs.is_properly_labeled == "false" + uses: mshick/add-pr-comment@v1 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + message: | + Hey ${{ steps.data.outputs.responsible_users }}! + + You approved or merged this PR, but no labels were added. From a00c735d9f69555331c463c564a7a40d0bed73b5 Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Wed, 9 Jun 2021 09:56:48 +0200 Subject: [PATCH 161/279] fix syntax in PR labels workflow (#4012) --- .github/workflows/pr-labels.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pr-labels.yml b/.github/workflows/pr-labels.yml index 398c9f75ae6..c27a0171bc6 100644 --- a/.github/workflows/pr-labels.yml +++ b/.github/workflows/pr-labels.yml @@ -28,7 +28,7 @@ jobs: echo "::set-output name=responsible_users::$(jq .responsible_users <<< $DATA)" - name: Ping responsible users - if: steps.data.outputs.is_properly_labeled == "false" + if: ${{ !steps.data.outputs.is_properly_labeled }} uses: mshick/add-pr-comment@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} From ea6be1240e5d83888b8d7fb08062496fa0c0c711 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Wed, 9 Jun 2021 09:09:17 +0100 Subject: [PATCH 162/279] Ignore missing report warning for requests (#4011) --- torchvision/datasets/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/datasets/utils.py b/torchvision/datasets/utils.py index e6798bd4500..2b5c2f9f567 100644 --- a/torchvision/datasets/utils.py +++ b/torchvision/datasets/utils.py @@ -201,7 +201,7 @@ def download_file_from_google_drive(file_id: str, root: str, filename: Optional[ md5 (str, optional): MD5 checksum of the download. If None, do not check """ # Based on https://stackoverflow.com/questions/38511444/python-download-files-from-google-drive-using-url - import requests + import requests # type: ignore url = "https://docs.google.com/uc?export=download" root = os.path.expanduser(root) From c52a33a13165f7a63219b8575f2f0c74858a99b0 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 9 Jun 2021 09:42:20 +0100 Subject: [PATCH 163/279] Skip some CPU-only tests on CircleCI machines with GPU (#4002) --- .circleci/config.yml | 10 +++++++++- .circleci/config.yml.in | 10 +++++++++- test/common_utils.py | 17 +++++++++++++---- 3 files changed, 31 insertions(+), 6 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index fcbc37c33f5..e0da7563767 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -687,12 +687,20 @@ jobs: paths: - conda - env + - run: + # Here we create an envlist file that contains some env variables that we want the docker container to be aware of. + # Normally, the CIRCLECI variable is set and available on all CI workflows: https://circleci.com/docs/2.0/env-vars/#built-in-environment-variables. + # They're avaiable in all the other workflows (OSX and Windows). + # But here, we're running the unittest_linux_gpu workflows in a docker container, where those variables aren't accessible. + # So instead we dump the variables we need in env.list and we pass that file when invoking "docker run". + name: export CIRCLECI env var + command: echo "CIRCLECI=true" >> ./env.list - run: name: Install torchvision command: docker run -t --gpus all -v $PWD:$PWD -w $PWD -e UPLOAD_CHANNEL -e CU_VERSION "${image_name}" .circleci/unittest/linux/scripts/install.sh - run: name: Run tests - command: docker run -e CIRCLECI -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/run_test.sh + command: docker run --env-file ./env.list -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/run_test.sh - run: name: Post Process command: docker run -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/post_process.sh diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 0fccf9d6764..e3cefda8981 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -687,12 +687,20 @@ jobs: paths: - conda - env + - run: + # Here we create an envlist file that contains some env variables that we want the docker container to be aware of. + # Normally, the CIRCLECI variable is set and available on all CI workflows: https://circleci.com/docs/2.0/env-vars/#built-in-environment-variables. + # They're avaiable in all the other workflows (OSX and Windows). + # But here, we're running the unittest_linux_gpu workflows in a docker container, where those variables aren't accessible. + # So instead we dump the variables we need in env.list and we pass that file when invoking "docker run". + name: export CIRCLECI env var + command: echo "CIRCLECI=true" >> ./env.list - run: name: Install torchvision command: docker run -t --gpus all -v $PWD:$PWD -w $PWD -e UPLOAD_CHANNEL -e CU_VERSION "${image_name}" .circleci/unittest/linux/scripts/install.sh - run: name: Run tests - command: docker run -e CIRCLECI -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/run_test.sh + command: docker run --env-file ./env.list -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/run_test.sh - run: name: Post Process command: docker run -t --gpus all -v $PWD:$PWD -w $PWD "${image_name}" .circleci/unittest/linux/scripts/post_process.sh diff --git a/test/common_utils.py b/test/common_utils.py index ebc21feda69..a95591ae570 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -26,6 +26,7 @@ IN_RE_WORKER = os.environ.get("INSIDE_RE_WORKER") is not None IN_FBCODE = os.environ.get("IN_FBCODE_TORCHVISION") == "1" CUDA_NOT_AVAILABLE_MSG = 'CUDA device not available' +CIRCLECI_GPU_NO_CUDA_MSG = "We're in a CircleCI GPU machine, and this test doesn't need cuda." @contextlib.contextmanager @@ -256,11 +257,19 @@ def call_args_to_kwargs_only(call_args, *callable_or_arg_names): def cpu_and_gpu(): - # TODO: make this properly handle CircleCI import pytest # noqa # ignore CPU tests in RE as they're already covered by another contbuild - devices = [] if IN_RE_WORKER else ['cpu'] + # also ignore CPU tests in CircleCI machines that have a GPU: these tests + # are run on CPU-only machines already. + if IN_RE_WORKER: + devices = [] + else: + if IN_CIRCLE_CI and torch.cuda.is_available(): + mark = pytest.mark.skip(reason=CIRCLECI_GPU_NO_CUDA_MSG) + else: + mark = () + devices = [pytest.param('cpu', marks=mark)] if torch.cuda.is_available(): cuda_marks = () @@ -278,7 +287,6 @@ def cpu_and_gpu(): def needs_cuda(test_func): - # TODO: make this properly handle CircleCI import pytest # noqa if IN_FBCODE and not IN_RE_WORKER: @@ -293,12 +301,13 @@ def needs_cuda(test_func): def cpu_only(test_func): - # TODO: make this properly handle CircleCI import pytest # noqa if IN_RE_WORKER: # The assumption is that all RE workers have GPUs. return pytest.mark.dont_collect(test_func) + elif IN_CIRCLE_CI and torch.cuda.is_available(): + return pytest.mark.skip(reason=CIRCLECI_GPU_NO_CUDA_MSG)(test_func) else: return test_func From 69f2e1b3c834e6197c090b2bc1ab42214feac632 Mon Sep 17 00:00:00 2001 From: Anirudh Date: Wed, 9 Jun 2021 15:28:39 +0530 Subject: [PATCH 164/279] [pytest port] color_jitter, pad, crop, center_crop in test_transforms_tensor (#4008) --- test/test_transforms_tensor.py | 286 ++++++++++++++++++--------------- 1 file changed, 152 insertions(+), 134 deletions(-) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 63b25fb7f11..2cd2f04831d 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -7,6 +7,7 @@ import numpy as np import unittest +import pytest from typing import Sequence from common_utils import ( @@ -17,6 +18,7 @@ _create_data_batch, _assert_equal_tensor_to_pil, _assert_approx_equal_tensor_to_pil, + cpu_and_gpu ) from _assert_utils import assert_equal @@ -140,140 +142,6 @@ def test_random_autocontrast(self): def test_random_equalize(self): _test_op(F.equalize, T.RandomEqualize, device=self.device) - def test_color_jitter(self): - - tol = 1.0 + 1e-10 - for f in [0.1, 0.5, 1.0, 1.34, (0.3, 0.7), [0.4, 0.5]]: - meth_kwargs = {"brightness": f} - _test_class_op( - T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, - tol=tol, agg_method="max" - ) - - for f in [0.2, 0.5, 1.0, 1.5, (0.3, 0.7), [0.4, 0.5]]: - meth_kwargs = {"contrast": f} - _test_class_op( - T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, - tol=tol, agg_method="max" - ) - - for f in [0.5, 0.75, 1.0, 1.25, (0.3, 0.7), [0.3, 0.4]]: - meth_kwargs = {"saturation": f} - _test_class_op( - T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, - tol=tol, agg_method="max" - ) - - for f in [0.2, 0.5, (-0.2, 0.3), [-0.4, 0.5]]: - meth_kwargs = {"hue": f} - _test_class_op( - T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, - tol=16.1, agg_method="max" - ) - - # All 4 parameters together - meth_kwargs = {"brightness": 0.2, "contrast": 0.2, "saturation": 0.2, "hue": 0.2} - _test_class_op( - T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, - tol=12.1, agg_method="max" - ) - - def test_pad(self): - for m in ["constant", "edge", "reflect", "symmetric"]: - fill = 127 if m == "constant" else 0 - for mul in [1, -1]: - # Test functional.pad (PIL and Tensor) with padding as single int - _test_functional_op( - F.pad, fn_kwargs={"padding": mul * 2, "fill": fill, "padding_mode": m}, - device=self.device - ) - # Test functional.pad and transforms.Pad with padding as [int, ] - fn_kwargs = meth_kwargs = {"padding": [mul * 2, ], "fill": fill, "padding_mode": m} - _test_op( - F.pad, T.Pad, device=self.device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - # Test functional.pad and transforms.Pad with padding as list - fn_kwargs = meth_kwargs = {"padding": [mul * 4, 4], "fill": fill, "padding_mode": m} - _test_op( - F.pad, T.Pad, device=self.device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - # Test functional.pad and transforms.Pad with padding as tuple - fn_kwargs = meth_kwargs = {"padding": (mul * 2, 2, 2, mul * 2), "fill": fill, "padding_mode": m} - _test_op( - F.pad, T.Pad, device=self.device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - - def test_crop(self): - fn_kwargs = {"top": 2, "left": 3, "height": 4, "width": 5} - # Test transforms.RandomCrop with size and padding as tuple - meth_kwargs = {"size": (4, 5), "padding": (4, 4), "pad_if_needed": True, } - _test_op( - F.crop, T.RandomCrop, device=self.device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - - # Test transforms.functional.crop including outside the image area - fn_kwargs = {"top": -2, "left": 3, "height": 4, "width": 5} # top - _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) - - fn_kwargs = {"top": 1, "left": -3, "height": 4, "width": 5} # left - _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) - - fn_kwargs = {"top": 7, "left": 3, "height": 4, "width": 5} # bottom - _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) - - fn_kwargs = {"top": 3, "left": 8, "height": 4, "width": 5} # right - _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) - - fn_kwargs = {"top": -3, "left": -3, "height": 15, "width": 15} # all - _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=self.device) - - sizes = [5, [5, ], [6, 6]] - padding_configs = [ - {"padding_mode": "constant", "fill": 0}, - {"padding_mode": "constant", "fill": 10}, - {"padding_mode": "constant", "fill": 20}, - {"padding_mode": "edge"}, - {"padding_mode": "reflect"}, - ] - - for size in sizes: - for padding_config in padding_configs: - config = dict(padding_config) - config["size"] = size - _test_class_op(T.RandomCrop, self.device, config) - - def test_center_crop(self): - fn_kwargs = {"output_size": (4, 5)} - meth_kwargs = {"size": (4, 5), } - _test_op( - F.center_crop, T.CenterCrop, device=self.device, fn_kwargs=fn_kwargs, - meth_kwargs=meth_kwargs - ) - fn_kwargs = {"output_size": (5,)} - meth_kwargs = {"size": (5, )} - _test_op( - F.center_crop, T.CenterCrop, device=self.device, fn_kwargs=fn_kwargs, - meth_kwargs=meth_kwargs - ) - tensor = torch.randint(0, 256, (3, 10, 10), dtype=torch.uint8, device=self.device) - # Test torchscript of transforms.CenterCrop with size as int - f = T.CenterCrop(size=5) - scripted_fn = torch.jit.script(f) - scripted_fn(tensor) - - # Test torchscript of transforms.CenterCrop with size as [int, ] - f = T.CenterCrop(size=[5, ]) - scripted_fn = torch.jit.script(f) - scripted_fn(tensor) - - # Test torchscript of transforms.CenterCrop with size as tuple - f = T.CenterCrop(size=(6, 6)) - scripted_fn = torch.jit.script(f) - scripted_fn(tensor) - - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_center_crop.pt")) - def _test_op_list_output(self, func, method, out_length, fn_kwargs=None, meth_kwargs=None): if fn_kwargs is None: fn_kwargs = {} @@ -710,6 +578,156 @@ def test_autoaugment(self): s_transform.save(os.path.join(tmp_dir, "t_autoaugment.pt")) +@pytest.mark.parametrize('device', cpu_and_gpu()) +class TestColorJitter: + + @pytest.mark.parametrize('brightness', [0.1, 0.5, 1.0, 1.34, (0.3, 0.7), [0.4, 0.5]]) + def test_color_jitter_brightness(self, brightness, device): + tol = 1.0 + 1e-10 + meth_kwargs = {"brightness": brightness} + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=device, + tol=tol, agg_method="max" + ) + + @pytest.mark.parametrize('contrast', [0.2, 0.5, 1.0, 1.5, (0.3, 0.7), [0.4, 0.5]]) + def test_color_jitter_contrast(self, contrast, device): + tol = 1.0 + 1e-10 + meth_kwargs = {"contrast": contrast} + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=device, + tol=tol, agg_method="max" + ) + + @pytest.mark.parametrize('saturation', [0.5, 0.75, 1.0, 1.25, (0.3, 0.7), [0.3, 0.4]]) + def test_color_jitter_saturation(self, saturation, device): + tol = 1.0 + 1e-10 + meth_kwargs = {"saturation": saturation} + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=device, + tol=tol, agg_method="max" + ) + + @pytest.mark.parametrize('hue', [0.2, 0.5, (-0.2, 0.3), [-0.4, 0.5]]) + def test_color_jitter_hue(self, hue, device): + meth_kwargs = {"hue": hue} + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=device, + tol=16.1, agg_method="max" + ) + + def test_color_jitter_all(self, device): + # All 4 parameters together + meth_kwargs = {"brightness": 0.2, "contrast": 0.2, "saturation": 0.2, "hue": 0.2} + _test_class_op( + T.ColorJitter, meth_kwargs=meth_kwargs, test_exact_match=False, device=device, + tol=12.1, agg_method="max" + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('m', ["constant", "edge", "reflect", "symmetric"]) +@pytest.mark.parametrize('mul', [1, -1]) +def test_pad(m, mul, device): + fill = 127 if m == "constant" else 0 + + # Test functional.pad (PIL and Tensor) with padding as single int + _test_functional_op( + F.pad, fn_kwargs={"padding": mul * 2, "fill": fill, "padding_mode": m}, + device=device + ) + # Test functional.pad and transforms.Pad with padding as [int, ] + fn_kwargs = meth_kwargs = {"padding": [mul * 2, ], "fill": fill, "padding_mode": m} + _test_op( + F.pad, T.Pad, device=device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + ) + # Test functional.pad and transforms.Pad with padding as list + fn_kwargs = meth_kwargs = {"padding": [mul * 4, 4], "fill": fill, "padding_mode": m} + _test_op( + F.pad, T.Pad, device=device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + ) + # Test functional.pad and transforms.Pad with padding as tuple + fn_kwargs = meth_kwargs = {"padding": (mul * 2, 2, 2, mul * 2), "fill": fill, "padding_mode": m} + _test_op( + F.pad, T.Pad, device=device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + ) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_crop(device): + fn_kwargs = {"top": 2, "left": 3, "height": 4, "width": 5} + # Test transforms.RandomCrop with size and padding as tuple + meth_kwargs = {"size": (4, 5), "padding": (4, 4), "pad_if_needed": True, } + _test_op( + F.crop, T.RandomCrop, device=device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs + ) + + # Test transforms.functional.crop including outside the image area + fn_kwargs = {"top": -2, "left": 3, "height": 4, "width": 5} # top + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=device) + + fn_kwargs = {"top": 1, "left": -3, "height": 4, "width": 5} # left + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=device) + + fn_kwargs = {"top": 7, "left": 3, "height": 4, "width": 5} # bottom + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=device) + + fn_kwargs = {"top": 3, "left": 8, "height": 4, "width": 5} # right + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=device) + + fn_kwargs = {"top": -3, "left": -3, "height": 15, "width": 15} # all + _test_functional_op(F.crop, fn_kwargs=fn_kwargs, device=device) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('padding_config', [ + {"padding_mode": "constant", "fill": 0}, + {"padding_mode": "constant", "fill": 10}, + {"padding_mode": "constant", "fill": 20}, + {"padding_mode": "edge"}, + {"padding_mode": "reflect"} +]) +@pytest.mark.parametrize('size', [5, [5, ], [6, 6]]) +def test_crop_pad(size, padding_config, device): + config = dict(padding_config) + config["size"] = size + _test_class_op(T.RandomCrop, device, config) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_center_crop(device): + fn_kwargs = {"output_size": (4, 5)} + meth_kwargs = {"size": (4, 5), } + _test_op( + F.center_crop, T.CenterCrop, device=device, fn_kwargs=fn_kwargs, + meth_kwargs=meth_kwargs + ) + fn_kwargs = {"output_size": (5,)} + meth_kwargs = {"size": (5, )} + _test_op( + F.center_crop, T.CenterCrop, device=device, fn_kwargs=fn_kwargs, + meth_kwargs=meth_kwargs + ) + tensor = torch.randint(0, 256, (3, 10, 10), dtype=torch.uint8, device=device) + # Test torchscript of transforms.CenterCrop with size as int + f = T.CenterCrop(size=5) + scripted_fn = torch.jit.script(f) + scripted_fn(tensor) + + # Test torchscript of transforms.CenterCrop with size as [int, ] + f = T.CenterCrop(size=[5, ]) + scripted_fn = torch.jit.script(f) + scripted_fn(tensor) + + # Test torchscript of transforms.CenterCrop with size as tuple + f = T.CenterCrop(size=(6, 6)) + scripted_fn = torch.jit.script(f) + scripted_fn(tensor) + + with get_tmp_dir() as tmp_dir: + scripted_fn.save(os.path.join(tmp_dir, "t_center_crop.pt")) + + @unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device") class CUDATester(Tester): From 9ff01a0819beda9a89ecb2137f2c68d999a5d665 Mon Sep 17 00:00:00 2001 From: Anirudh Date: Wed, 9 Jun 2021 15:31:05 +0530 Subject: [PATCH 165/279] Install missing stubs for mypy (#4014) --- .circleci/config.yml | 1 + .circleci/config.yml.in | 1 + torchvision/datasets/utils.py | 2 +- 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index e0da7563767..c6e45edbfcc 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -205,6 +205,7 @@ jobs: sudo apt-get update -y sudo apt install -y libturbojpeg-dev pip install --user --progress-bar off mypy + pip install --user --progress-bar off types-requests pip install --user --progress-bar off --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html pip install --user --progress-bar off --editable . mypy --config-file mypy.ini diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index e3cefda8981..fdc5c68c13a 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -205,6 +205,7 @@ jobs: sudo apt-get update -y sudo apt install -y libturbojpeg-dev pip install --user --progress-bar off mypy + pip install --user --progress-bar off types-requests pip install --user --progress-bar off --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html pip install --user --progress-bar off --editable . mypy --config-file mypy.ini diff --git a/torchvision/datasets/utils.py b/torchvision/datasets/utils.py index 2b5c2f9f567..e6798bd4500 100644 --- a/torchvision/datasets/utils.py +++ b/torchvision/datasets/utils.py @@ -201,7 +201,7 @@ def download_file_from_google_drive(file_id: str, root: str, filename: Optional[ md5 (str, optional): MD5 checksum of the download. If None, do not check """ # Based on https://stackoverflow.com/questions/38511444/python-download-files-from-google-drive-using-url - import requests # type: ignore + import requests url = "https://docs.google.com/uc?export=download" root = os.path.expanduser(root) From 4db4d157d919d869888460f8473f33dfd6a30bfc Mon Sep 17 00:00:00 2001 From: Vivek Kumar <60113444+vivekkumar7089@users.noreply.github.com> Date: Wed, 9 Jun 2021 16:11:09 +0530 Subject: [PATCH 166/279] Port random affine, rotate, perspective and to_grayscale to pytest (#4000) --- test/test_transforms_tensor.py | 216 ++++++++++++++++++--------------- 1 file changed, 121 insertions(+), 95 deletions(-) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 2cd2f04831d..4e167d64b6a 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -18,7 +18,7 @@ _create_data_batch, _assert_equal_tensor_to_pil, _assert_approx_equal_tensor_to_pil, - cpu_and_gpu + cpu_and_gpu, ) from _assert_utils import assert_equal @@ -286,100 +286,6 @@ def test_resized_crop(self): with get_tmp_dir() as tmp_dir: s_transform.save(os.path.join(tmp_dir, "t_resized_crop.pt")) - def test_random_affine(self): - tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=self.device) - batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=self.device) - - def _test(**kwargs): - transform = T.RandomAffine(**kwargs) - s_transform = torch.jit.script(transform) - - _test_transform_vs_scripted(transform, s_transform, tensor) - _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - - return s_transform - - for interpolation in [NEAREST, BILINEAR]: - for shear in [15, 10.0, (5.0, 10.0), [-15, 15], [-10.0, 10.0, -11.0, 11.0]]: - _test(degrees=0.0, interpolation=interpolation, shear=shear) - - for scale in [(0.7, 1.2), [0.7, 1.2]]: - _test(degrees=0.0, interpolation=interpolation, scale=scale) - - for translate in [(0.1, 0.2), [0.2, 0.1]]: - _test(degrees=0.0, interpolation=interpolation, translate=translate) - - for degrees in [45, 35.0, (-45, 45), [-90.0, 90.0]]: - _test(degrees=degrees, interpolation=interpolation) - - for fill in [85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]: - _test(degrees=0.0, interpolation=interpolation, fill=fill) - - s_transform = _test(degrees=0.0) - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_random_affine.pt")) - - def test_random_rotate(self): - tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=self.device) - batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=self.device) - - for center in [(0, 0), [10, 10], None, (56, 44)]: - for expand in [True, False]: - for degrees in [45, 35.0, (-45, 45), [-90.0, 90.0]]: - for interpolation in [NEAREST, BILINEAR]: - for fill in [85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]: - transform = T.RandomRotation( - degrees=degrees, interpolation=interpolation, expand=expand, center=center, fill=fill - ) - s_transform = torch.jit.script(transform) - - _test_transform_vs_scripted(transform, s_transform, tensor) - _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_random_rotate.pt")) - - def test_random_perspective(self): - tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=self.device) - batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=self.device) - - for distortion_scale in np.linspace(0.1, 1.0, num=20): - for interpolation in [NEAREST, BILINEAR]: - for fill in [85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]: - transform = T.RandomPerspective( - distortion_scale=distortion_scale, - interpolation=interpolation, - fill=fill - ) - s_transform = torch.jit.script(transform) - - _test_transform_vs_scripted(transform, s_transform, tensor) - _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_perspective.pt")) - - def test_to_grayscale(self): - - meth_kwargs = {"num_output_channels": 1} - tol = 1.0 + 1e-10 - _test_class_op( - T.Grayscale, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, - tol=tol, agg_method="max" - ) - - meth_kwargs = {"num_output_channels": 3} - _test_class_op( - T.Grayscale, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, - tol=tol, agg_method="max" - ) - - meth_kwargs = {} - _test_class_op( - T.RandomGrayscale, meth_kwargs=meth_kwargs, test_exact_match=False, device=self.device, - tol=tol, agg_method="max" - ) - def test_normalize(self): fn = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) tensor, _ = _create_data(26, 34, device=self.device) @@ -736,5 +642,125 @@ def setUp(self): self.device = "cuda" +def _test_random_affine_helper(device, **kwargs): + tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=device) + batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=device) + transform = T.RandomAffine(**kwargs) + s_transform = torch.jit.script(transform) + + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_random_affine(device): + transform = T.RandomAffine(degrees=45.0) + s_transform = torch.jit.script(transform) + with get_tmp_dir() as tmp_dir: + s_transform.save(os.path.join(tmp_dir, "t_random_affine.pt")) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('interpolation', [NEAREST, BILINEAR]) +@pytest.mark.parametrize('shear', [15, 10.0, (5.0, 10.0), [-15, 15], [-10.0, 10.0, -11.0, 11.0]]) +def test_random_affine_shear(device, interpolation, shear): + _test_random_affine_helper(device, degrees=0.0, interpolation=interpolation, shear=shear) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('interpolation', [NEAREST, BILINEAR]) +@pytest.mark.parametrize('scale', [(0.7, 1.2), [0.7, 1.2]]) +def test_random_affine_scale(device, interpolation, scale): + _test_random_affine_helper(device, degrees=0.0, interpolation=interpolation, scale=scale) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('interpolation', [NEAREST, BILINEAR]) +@pytest.mark.parametrize('translate', [(0.1, 0.2), [0.2, 0.1]]) +def test_random_affine_translate(device, interpolation, translate): + _test_random_affine_helper(device, degrees=0.0, interpolation=interpolation, translate=translate) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('interpolation', [NEAREST, BILINEAR]) +@pytest.mark.parametrize('degrees', [45, 35.0, (-45, 45), [-90.0, 90.0]]) +def test_random_affine_degrees(device, interpolation, degrees): + _test_random_affine_helper(device, degrees=degrees, interpolation=interpolation) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('interpolation', [NEAREST, BILINEAR]) +@pytest.mark.parametrize('fill', [85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]) +def test_random_affine_fill(device, interpolation, fill): + _test_random_affine_helper(device, degrees=0.0, interpolation=interpolation, fill=fill) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('center', [(0, 0), [10, 10], None, (56, 44)]) +@pytest.mark.parametrize('expand', [True, False]) +@pytest.mark.parametrize('degrees', [45, 35.0, (-45, 45), [-90.0, 90.0]]) +@pytest.mark.parametrize('interpolation', [NEAREST, BILINEAR]) +@pytest.mark.parametrize('fill', [85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]) +def test_random_rotate(device, center, expand, degrees, interpolation, fill): + tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=device) + batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=device) + + transform = T.RandomRotation( + degrees=degrees, interpolation=interpolation, expand=expand, center=center, fill=fill + ) + s_transform = torch.jit.script(transform) + + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + + +def test_random_rotate_save(): + transform = T.RandomRotation(degrees=45.0) + s_transform = torch.jit.script(transform) + with get_tmp_dir() as tmp_dir: + s_transform.save(os.path.join(tmp_dir, "t_random_rotate.pt")) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('distortion_scale', np.linspace(0.1, 1.0, num=20)) +@pytest.mark.parametrize('interpolation', [NEAREST, BILINEAR]) +@pytest.mark.parametrize('fill', [85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]) +def test_random_perspective(device, distortion_scale, interpolation, fill): + tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=device) + batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=device) + + transform = T.RandomPerspective( + distortion_scale=distortion_scale, + interpolation=interpolation, + fill=fill + ) + s_transform = torch.jit.script(transform) + + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + + +def test_random_perspective_save(): + transform = T.RandomPerspective() + s_transform = torch.jit.script(transform) + with get_tmp_dir() as tmp_dir: + s_transform.save(os.path.join(tmp_dir, "t_perspective.pt")) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('Klass, meth_kwargs', [ + (T.Grayscale, {"num_output_channels": 1}), + (T.Grayscale, {"num_output_channels": 3}), + (T.RandomGrayscale, {}) +]) +def test_to_grayscale(device, Klass, meth_kwargs): + + tol = 1.0 + 1e-10 + _test_class_op( + Klass, meth_kwargs=meth_kwargs, test_exact_match=False, device=device, + tol=tol, agg_method="max" + ) + + if __name__ == '__main__': unittest.main() From 78fc1434776a5fdbf3d7ff54b32394be3e0cfa3a Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Wed, 9 Jun 2021 13:54:54 +0200 Subject: [PATCH 167/279] Fix workflow for pinging maintainers in case of unlabeled PRs (#4021) * add additional workflow trigger * [skip ci] fix name of script for PR label processing (#4013) * trigger CI * fix workflow in case commit has no associated PR * [skip CI] test PR for label-checking workflow (#4015) * [skip CI] fix PR labels processing logic (#4016) * [skip CI] try fix trigger for unlabeled PR pings (#4017) * [skip CI] remove quotes around users ping (#4018) * [skip CI] cleanup PR labeling workflow (#4019) * [skip CI] fix ping message for unlabeled PRs (#4020) * cleanup --- .github/{process_pr.py => process_commit.py} | 44 +++++++++++--------- .github/workflows/pr-labels.yml | 18 ++++---- 2 files changed, 32 insertions(+), 30 deletions(-) rename .github/{process_pr.py => process_commit.py} (58%) diff --git a/.github/process_pr.py b/.github/process_commit.py similarity index 58% rename from .github/process_pr.py rename to .github/process_commit.py index f0f4c14f31b..33edd74194e 100644 --- a/.github/process_pr.py +++ b/.github/process_commit.py @@ -1,10 +1,15 @@ -import json +""" +This script finds all responsible users for labeling a PR by a commit SHA. It is used by the workflow in +'.github/workflows/pr-labels.yml'. If there exists no PR associated with the commit or the PR is properly labeled, +this script is a no-op. +""" + import sys -from typing import Any, Dict, Set, Tuple +from typing import Any, Optional, Set, Tuple import requests -# If the PR has any of these labels, we mark it as properly labeled. +# If the PR has any of these labels, we accept it as properly labeled. REQUIRED_LABELS = { "new feature", "bug", @@ -33,34 +38,35 @@ } -def main(commit_hash: str) -> Dict[str, Any]: +def find_responsible_users(commit_hash: str) -> Set[str]: pr_number = get_pr_number(commit_hash) + if not pr_number: + return set() + merger, labels = get_pr_merger_and_labels(pr_number) is_properly_labeled = bool(REQUIRED_LABELS.intersection(labels)) - if not is_properly_labeled: - users = {merger, *get_pr_reviewers(pr_number)} - else: - users = () - return dict( - is_properly_labeled=is_properly_labeled, - responsible_users=", ".join(sorted([f"@{user}" for user in users])), - ) + if is_properly_labeled: + return set() + + return {merger, *get_pr_reviewers(pr_number)} -def _query_torchvision(cmd: str, *, accept) -> Any: +def query_torchvision(cmd: str, *, accept) -> Any: response = requests.get(f"https://api.github.com/repos/pytorch/vision/{cmd}", headers=dict(Accept=accept)) return response.json() -def get_pr_number(commit_hash: str) -> int: +def get_pr_number(commit_hash: str) -> Optional[int]: # See https://docs.github.com/en/rest/reference/repos#list-pull-requests-associated-with-a-commit - data = _query_torchvision(f"commits/{commit_hash}/pulls", accept="application/vnd.github.groot-preview+json") + data = query_torchvision(f"commits/{commit_hash}/pulls", accept="application/vnd.github.groot-preview+json") + if not data: + return None return data[0]["number"] def get_pr_merger_and_labels(pr_number: int) -> Tuple[str, Set[str]]: # See https://docs.github.com/en/rest/reference/pulls#get-a-pull-request - data = _query_torchvision(f"pulls/{pr_number}", accept="application/vnd.github.v3+json") + data = query_torchvision(f"pulls/{pr_number}", accept="application/vnd.github.v3+json") merger = data["merged_by"]["login"] labels = {label["name"] for label in data["labels"]} return merger, labels @@ -68,11 +74,11 @@ def get_pr_merger_and_labels(pr_number: int) -> Tuple[str, Set[str]]: def get_pr_reviewers(pr_number: int) -> Set[str]: # See https://docs.github.com/en/rest/reference/pulls#list-reviews-for-a-pull-request - data = _query_torchvision(f"pulls/{pr_number}/reviews", accept="application/vnd.github.v3+json") + data = query_torchvision(f"pulls/{pr_number}/reviews", accept="application/vnd.github.v3+json") return {review["user"]["login"] for review in data if review["state"] == "APPROVED"} if __name__ == "__main__": commit_hash = sys.argv[1] - data = main(commit_hash) - print(json.dumps(data)) + users = find_responsible_users(commit_hash) + print(", ".join(sorted([f"@{user}" for user in users]))) diff --git a/.github/workflows/pr-labels.yml b/.github/workflows/pr-labels.yml index c27a0171bc6..06d99b8c557 100644 --- a/.github/workflows/pr-labels.yml +++ b/.github/workflows/pr-labels.yml @@ -19,21 +19,17 @@ jobs: - name: Checkout repository uses: actions/checkout@v2 - - name: Process PR associated with current commit - id: data - run: | - DATA=$(python .github/foo.py ${{ github.sha }}) - jq . <<< $DATA - echo "::set-output name=is_properly_labeled::$(jq .is_properly_labeled <<< $DATA)" - echo "::set-output name=responsible_users::$(jq .responsible_users <<< $DATA)" - - - name: Ping responsible users - if: ${{ !steps.data.outputs.is_properly_labeled }} + - name: Process commit and find users responsible for labeling + id: commit + run: echo "::set-output name=responsible_users::$(python .github/process_commit.py ${{ github.sha }})" + + - name: Ping users responsible for labeling if necessary + if: ${{ steps.commit.outputs.responsible_users != '' }} uses: mshick/add-pr-comment@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: message: | - Hey ${{ steps.data.outputs.responsible_users }}! + Hey ${{ steps.commit.outputs.responsible_users }}! You approved or merged this PR, but no labels were added. From 810811f81ca24b196d08778c9e7f50bc5fe3ef3d Mon Sep 17 00:00:00 2001 From: Anirudh Date: Wed, 9 Jun 2021 18:06:51 +0530 Subject: [PATCH 168/279] [pytest port] test{crop_five, crop_ten, resize, resized_crop} in test_transforms_tensor (#4010) --- test/test_transforms_tensor.py | 261 +++++++++++++++------------------ 1 file changed, 117 insertions(+), 144 deletions(-) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 4e167d64b6a..c85053b9c48 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -19,6 +19,7 @@ _assert_equal_tensor_to_pil, _assert_approx_equal_tensor_to_pil, cpu_and_gpu, + cpu_only ) from _assert_utils import assert_equal @@ -142,150 +143,6 @@ def test_random_autocontrast(self): def test_random_equalize(self): _test_op(F.equalize, T.RandomEqualize, device=self.device) - def _test_op_list_output(self, func, method, out_length, fn_kwargs=None, meth_kwargs=None): - if fn_kwargs is None: - fn_kwargs = {} - if meth_kwargs is None: - meth_kwargs = {} - - fn = getattr(F, func) - scripted_fn = torch.jit.script(fn) - - tensor, pil_img = _create_data(height=20, width=20, device=self.device) - transformed_t_list = fn(tensor, **fn_kwargs) - transformed_p_list = fn(pil_img, **fn_kwargs) - self.assertEqual(len(transformed_t_list), len(transformed_p_list)) - self.assertEqual(len(transformed_t_list), out_length) - for transformed_tensor, transformed_pil_img in zip(transformed_t_list, transformed_p_list): - _assert_equal_tensor_to_pil(transformed_tensor, transformed_pil_img) - - transformed_t_list_script = scripted_fn(tensor.detach().clone(), **fn_kwargs) - self.assertEqual(len(transformed_t_list), len(transformed_t_list_script)) - self.assertEqual(len(transformed_t_list_script), out_length) - for transformed_tensor, transformed_tensor_script in zip(transformed_t_list, transformed_t_list_script): - assert_equal( - transformed_tensor, - transformed_tensor_script, - msg="{} vs {}".format(transformed_tensor, transformed_tensor_script), - ) - - # test for class interface - fn = getattr(T, method)(**meth_kwargs) - scripted_fn = torch.jit.script(fn) - output = scripted_fn(tensor) - self.assertEqual(len(output), len(transformed_t_list_script)) - - # test on batch of tensors - batch_tensors = _create_data_batch(height=23, width=34, channels=3, num_samples=4, device=self.device) - torch.manual_seed(12) - transformed_batch_list = fn(batch_tensors) - - for i in range(len(batch_tensors)): - img_tensor = batch_tensors[i, ...] - torch.manual_seed(12) - transformed_img_list = fn(img_tensor) - for transformed_img, transformed_batch in zip(transformed_img_list, transformed_batch_list): - assert_equal( - transformed_img, - transformed_batch[i, ...], - msg="{} vs {}".format(transformed_img, transformed_batch[i, ...]), - ) - - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_op_list_{}.pt".format(method))) - - def test_five_crop(self): - fn_kwargs = meth_kwargs = {"size": (5,)} - self._test_op_list_output( - "five_crop", "FiveCrop", out_length=5, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - fn_kwargs = meth_kwargs = {"size": [5, ]} - self._test_op_list_output( - "five_crop", "FiveCrop", out_length=5, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - fn_kwargs = meth_kwargs = {"size": (4, 5)} - self._test_op_list_output( - "five_crop", "FiveCrop", out_length=5, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - fn_kwargs = meth_kwargs = {"size": [4, 5]} - self._test_op_list_output( - "five_crop", "FiveCrop", out_length=5, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - - def test_ten_crop(self): - fn_kwargs = meth_kwargs = {"size": (5,)} - self._test_op_list_output( - "ten_crop", "TenCrop", out_length=10, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - fn_kwargs = meth_kwargs = {"size": [5, ]} - self._test_op_list_output( - "ten_crop", "TenCrop", out_length=10, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - fn_kwargs = meth_kwargs = {"size": (4, 5)} - self._test_op_list_output( - "ten_crop", "TenCrop", out_length=10, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - fn_kwargs = meth_kwargs = {"size": [4, 5]} - self._test_op_list_output( - "ten_crop", "TenCrop", out_length=10, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs - ) - - def test_resize(self): - - # TODO: Minimal check for bug-fix, improve this later - x = torch.rand(3, 32, 46) - t = T.Resize(size=38) - y = t(x) - # If size is an int, smaller edge of the image will be matched to this number. - # i.e, if height > width, then image will be rescaled to (size * height / width, size). - self.assertTrue(isinstance(y, torch.Tensor)) - self.assertEqual(y.shape[1], 38) - self.assertEqual(y.shape[2], int(38 * 46 / 32)) - - tensor, _ = _create_data(height=34, width=36, device=self.device) - batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=self.device) - - for dt in [None, torch.float32, torch.float64]: - if dt is not None: - # This is a trivial cast to float of uint8 data to test all cases - tensor = tensor.to(dt) - for size in [32, 34, [32, ], [32, 32], (32, 32), [34, 35]]: - for max_size in (None, 35, 1000): - if max_size is not None and isinstance(size, Sequence) and len(size) != 1: - continue # Not supported - for interpolation in [BILINEAR, BICUBIC, NEAREST]: - - if isinstance(size, int): - script_size = [size, ] - else: - script_size = size - - transform = T.Resize(size=script_size, interpolation=interpolation, max_size=max_size) - s_transform = torch.jit.script(transform) - _test_transform_vs_scripted(transform, s_transform, tensor) - _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_resize.pt")) - - def test_resized_crop(self): - tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=self.device) - batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=self.device) - - for scale in [(0.7, 1.2), [0.7, 1.2]]: - for ratio in [(0.75, 1.333), [0.75, 1.333]]: - for size in [(32, ), [44, ], [32, ], [32, 32], (32, 32), [44, 55]]: - for interpolation in [NEAREST, BILINEAR, BICUBIC]: - transform = T.RandomResizedCrop( - size=size, scale=scale, ratio=ratio, interpolation=interpolation - ) - s_transform = torch.jit.script(transform) - _test_transform_vs_scripted(transform, s_transform, tensor) - _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_resized_crop.pt")) - def test_normalize(self): fn = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) tensor, _ = _create_data(26, 34, device=self.device) @@ -634,6 +491,122 @@ def test_center_crop(device): scripted_fn.save(os.path.join(tmp_dir, "t_center_crop.pt")) +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('fn, method, out_length', [ + # test_five_crop + (F.five_crop, T.FiveCrop, 5), + # test_ten_crop + (F.ten_crop, T.TenCrop, 10) +]) +@pytest.mark.parametrize('size', [(5, ), [5, ], (4, 5), [4, 5]]) +def test_x_crop(fn, method, out_length, size, device): + meth_kwargs = fn_kwargs = {'size': size} + scripted_fn = torch.jit.script(fn) + + tensor, pil_img = _create_data(height=20, width=20, device=device) + transformed_t_list = fn(tensor, **fn_kwargs) + transformed_p_list = fn(pil_img, **fn_kwargs) + assert len(transformed_t_list) == len(transformed_p_list) + assert len(transformed_t_list) == out_length + for transformed_tensor, transformed_pil_img in zip(transformed_t_list, transformed_p_list): + _assert_equal_tensor_to_pil(transformed_tensor, transformed_pil_img) + + transformed_t_list_script = scripted_fn(tensor.detach().clone(), **fn_kwargs) + assert len(transformed_t_list) == len(transformed_t_list_script) + assert len(transformed_t_list_script) == out_length + for transformed_tensor, transformed_tensor_script in zip(transformed_t_list, transformed_t_list_script): + assert_equal(transformed_tensor, transformed_tensor_script) + + # test for class interface + fn = method(**meth_kwargs) + scripted_fn = torch.jit.script(fn) + output = scripted_fn(tensor) + assert len(output) == len(transformed_t_list_script) + + # test on batch of tensors + batch_tensors = _create_data_batch(height=23, width=34, channels=3, num_samples=4, device=device) + torch.manual_seed(12) + transformed_batch_list = fn(batch_tensors) + + for i in range(len(batch_tensors)): + img_tensor = batch_tensors[i, ...] + torch.manual_seed(12) + transformed_img_list = fn(img_tensor) + for transformed_img, transformed_batch in zip(transformed_img_list, transformed_batch_list): + assert_equal(transformed_img, transformed_batch[i, ...]) + + +@cpu_only +@pytest.mark.parametrize('method', ["FiveCrop", "TenCrop"]) +def test_x_crop_save(method): + fn = getattr(T, method)(size=[5, ]) + scripted_fn = torch.jit.script(fn) + with get_tmp_dir() as tmp_dir: + scripted_fn.save(os.path.join(tmp_dir, "t_op_list_{}.pt".format(method))) + + +class TestResize: + @cpu_only + @pytest.mark.parametrize('size', [32, 34, 35, 36, 38]) + def test_resize_int(self, size): + # TODO: Minimal check for bug-fix, improve this later + x = torch.rand(3, 32, 46) + t = T.Resize(size=size) + y = t(x) + # If size is an int, smaller edge of the image will be matched to this number. + # i.e, if height > width, then image will be rescaled to (size * height / width, size). + assert isinstance(y, torch.Tensor) + assert y.shape[1] == size + assert y.shape[2] == int(size * 46 / 32) + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('dt', [None, torch.float32, torch.float64]) + @pytest.mark.parametrize('size', [[32, ], [32, 32], (32, 32), [34, 35]]) + @pytest.mark.parametrize('max_size', [None, 35, 1000]) + @pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC, NEAREST]) + def test_resize_scripted(self, dt, size, max_size, interpolation, device): + tensor, _ = _create_data(height=34, width=36, device=device) + batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=device) + + if dt is not None: + # This is a trivial cast to float of uint8 data to test all cases + tensor = tensor.to(dt) + if max_size is not None and len(size) != 1: + pytest.xfail("with max_size, size must be a sequence with 2 elements") + + transform = T.Resize(size=size, interpolation=interpolation, max_size=max_size) + s_transform = torch.jit.script(transform) + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + + @cpu_only + def test_resize_save(self): + transform = T.Resize(size=[32, ]) + s_transform = torch.jit.script(transform) + with get_tmp_dir() as tmp_dir: + s_transform.save(os.path.join(tmp_dir, "t_resize.pt")) + + @pytest.mark.parametrize('device', cpu_and_gpu()) + @pytest.mark.parametrize('scale', [(0.7, 1.2), [0.7, 1.2]]) + @pytest.mark.parametrize('ratio', [(0.75, 1.333), [0.75, 1.333]]) + @pytest.mark.parametrize('size', [(32, ), [44, ], [32, ], [32, 32], (32, 32), [44, 55]]) + @pytest.mark.parametrize('interpolation', [NEAREST, BILINEAR, BICUBIC]) + def test_resized_crop(self, scale, ratio, size, interpolation, device): + tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=device) + batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=device) + transform = T.RandomResizedCrop(size=size, scale=scale, ratio=ratio, interpolation=interpolation) + s_transform = torch.jit.script(transform) + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + + @cpu_only + def test_resized_crop_save(self): + transform = T.RandomResizedCrop(size=[32, ]) + s_transform = torch.jit.script(transform) + with get_tmp_dir() as tmp_dir: + s_transform.save(os.path.join(tmp_dir, "t_resized_crop.pt")) + + @unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device") class CUDATester(Tester): From 5d614bd19421a3033ccf261d427013709d185e2d Mon Sep 17 00:00:00 2001 From: Vivek Kumar <60113444+vivekkumar7089@users.noreply.github.com> Date: Wed, 9 Jun 2021 21:06:36 +0530 Subject: [PATCH 169/279] Port normalize, linear_transformation, compose, random_apply, gaussian_blur to pytest (#4023) --- test/test_transforms_tensor.py | 247 ++++++++++++++++----------------- 1 file changed, 120 insertions(+), 127 deletions(-) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index c85053b9c48..b365c3f3421 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -143,133 +143,6 @@ def test_random_autocontrast(self): def test_random_equalize(self): _test_op(F.equalize, T.RandomEqualize, device=self.device) - def test_normalize(self): - fn = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) - tensor, _ = _create_data(26, 34, device=self.device) - - with self.assertRaisesRegex(TypeError, r"Input tensor should be a float tensor"): - fn(tensor) - - batch_tensors = torch.rand(4, 3, 44, 56, device=self.device) - tensor = tensor.to(dtype=torch.float32) / 255.0 - # test for class interface - scripted_fn = torch.jit.script(fn) - - _test_transform_vs_scripted(fn, scripted_fn, tensor) - _test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) - - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_norm.pt")) - - def test_linear_transformation(self): - c, h, w = 3, 24, 32 - - tensor, _ = _create_data(h, w, channels=c, device=self.device) - - matrix = torch.rand(c * h * w, c * h * w, device=self.device) - mean_vector = torch.rand(c * h * w, device=self.device) - - fn = T.LinearTransformation(matrix, mean_vector) - scripted_fn = torch.jit.script(fn) - - _test_transform_vs_scripted(fn, scripted_fn, tensor) - - batch_tensors = torch.rand(4, c, h, w, device=self.device) - # We skip some tests from _test_transform_vs_scripted_on_batch as - # results for scripted and non-scripted transformations are not exactly the same - torch.manual_seed(12) - transformed_batch = fn(batch_tensors) - torch.manual_seed(12) - s_transformed_batch = scripted_fn(batch_tensors) - assert_equal(transformed_batch, s_transformed_batch) - - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_norm.pt")) - - def test_compose(self): - tensor, _ = _create_data(26, 34, device=self.device) - tensor = tensor.to(dtype=torch.float32) / 255.0 - - transforms = T.Compose([ - T.CenterCrop(10), - T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), - ]) - s_transforms = torch.nn.Sequential(*transforms.transforms) - - scripted_fn = torch.jit.script(s_transforms) - torch.manual_seed(12) - transformed_tensor = transforms(tensor) - torch.manual_seed(12) - transformed_tensor_script = scripted_fn(tensor) - assert_equal(transformed_tensor, transformed_tensor_script, msg="{}".format(transforms)) - - t = T.Compose([ - lambda x: x, - ]) - with self.assertRaisesRegex(RuntimeError, r"Could not get name of python class object"): - torch.jit.script(t) - - def test_random_apply(self): - tensor, _ = _create_data(26, 34, device=self.device) - tensor = tensor.to(dtype=torch.float32) / 255.0 - - transforms = T.RandomApply([ - T.RandomHorizontalFlip(), - T.ColorJitter(), - ], p=0.4) - s_transforms = T.RandomApply(torch.nn.ModuleList([ - T.RandomHorizontalFlip(), - T.ColorJitter(), - ]), p=0.4) - - scripted_fn = torch.jit.script(s_transforms) - torch.manual_seed(12) - transformed_tensor = transforms(tensor) - torch.manual_seed(12) - transformed_tensor_script = scripted_fn(tensor) - assert_equal(transformed_tensor, transformed_tensor_script, msg="{}".format(transforms)) - - if torch.device(self.device).type == "cpu": - # Can't check this twice, otherwise - # "Can't redefine method: forward on class: __torch__.torchvision.transforms.transforms.RandomApply" - transforms = T.RandomApply([ - T.ColorJitter(), - ], p=0.3) - with self.assertRaisesRegex(RuntimeError, r"Module 'RandomApply' has no attribute 'transforms'"): - torch.jit.script(transforms) - - def test_gaussian_blur(self): - tol = 1.0 + 1e-10 - _test_class_op( - T.GaussianBlur, meth_kwargs={"kernel_size": 3, "sigma": 0.75}, - test_exact_match=False, device=self.device, agg_method="max", tol=tol - ) - - _test_class_op( - T.GaussianBlur, meth_kwargs={"kernel_size": 23, "sigma": [0.1, 2.0]}, - test_exact_match=False, device=self.device, agg_method="max", tol=tol - ) - - _test_class_op( - T.GaussianBlur, meth_kwargs={"kernel_size": 23, "sigma": (0.1, 2.0)}, - test_exact_match=False, device=self.device, agg_method="max", tol=tol - ) - - _test_class_op( - T.GaussianBlur, meth_kwargs={"kernel_size": [3, 3], "sigma": (1.0, 1.0)}, - test_exact_match=False, device=self.device, agg_method="max", tol=tol - ) - - _test_class_op( - T.GaussianBlur, meth_kwargs={"kernel_size": (3, 3), "sigma": (0.1, 2.0)}, - test_exact_match=False, device=self.device, agg_method="max", tol=tol - ) - - _test_class_op( - T.GaussianBlur, meth_kwargs={"kernel_size": [23], "sigma": 0.75}, - test_exact_match=False, device=self.device, agg_method="max", tol=tol - ) - def test_random_erasing(self): img = torch.rand(3, 60, 60) @@ -735,5 +608,125 @@ def test_to_grayscale(device, Klass, meth_kwargs): ) +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_normalize(device): + fn = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + tensor, _ = _create_data(26, 34, device=device) + + with pytest.raises(TypeError, match="Input tensor should be a float tensor"): + fn(tensor) + + batch_tensors = torch.rand(4, 3, 44, 56, device=device) + tensor = tensor.to(dtype=torch.float32) / 255.0 + # test for class interface + scripted_fn = torch.jit.script(fn) + + _test_transform_vs_scripted(fn, scripted_fn, tensor) + _test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) + + with get_tmp_dir() as tmp_dir: + scripted_fn.save(os.path.join(tmp_dir, "t_norm.pt")) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_linear_transformation(device): + c, h, w = 3, 24, 32 + + tensor, _ = _create_data(h, w, channels=c, device=device) + + matrix = torch.rand(c * h * w, c * h * w, device=device) + mean_vector = torch.rand(c * h * w, device=device) + + fn = T.LinearTransformation(matrix, mean_vector) + scripted_fn = torch.jit.script(fn) + + _test_transform_vs_scripted(fn, scripted_fn, tensor) + + batch_tensors = torch.rand(4, c, h, w, device=device) + # We skip some tests from _test_transform_vs_scripted_on_batch as + # results for scripted and non-scripted transformations are not exactly the same + torch.manual_seed(12) + transformed_batch = fn(batch_tensors) + torch.manual_seed(12) + s_transformed_batch = scripted_fn(batch_tensors) + assert_equal(transformed_batch, s_transformed_batch) + + with get_tmp_dir() as tmp_dir: + scripted_fn.save(os.path.join(tmp_dir, "t_norm.pt")) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_compose(device): + tensor, _ = _create_data(26, 34, device=device) + tensor = tensor.to(dtype=torch.float32) / 255.0 + + transforms = T.Compose([ + T.CenterCrop(10), + T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), + ]) + s_transforms = torch.nn.Sequential(*transforms.transforms) + + scripted_fn = torch.jit.script(s_transforms) + torch.manual_seed(12) + transformed_tensor = transforms(tensor) + torch.manual_seed(12) + transformed_tensor_script = scripted_fn(tensor) + assert_equal(transformed_tensor, transformed_tensor_script, msg="{}".format(transforms)) + + t = T.Compose([ + lambda x: x, + ]) + with pytest.raises(RuntimeError, match="Could not get name of python class object"): + torch.jit.script(t) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +def test_random_apply(device): + tensor, _ = _create_data(26, 34, device=device) + tensor = tensor.to(dtype=torch.float32) / 255.0 + + transforms = T.RandomApply([ + T.RandomHorizontalFlip(), + T.ColorJitter(), + ], p=0.4) + s_transforms = T.RandomApply(torch.nn.ModuleList([ + T.RandomHorizontalFlip(), + T.ColorJitter(), + ]), p=0.4) + + scripted_fn = torch.jit.script(s_transforms) + torch.manual_seed(12) + transformed_tensor = transforms(tensor) + torch.manual_seed(12) + transformed_tensor_script = scripted_fn(tensor) + assert_equal(transformed_tensor, transformed_tensor_script, msg="{}".format(transforms)) + + if device == "cpu": + # Can't check this twice, otherwise + # "Can't redefine method: forward on class: __torch__.torchvision.transforms.transforms.RandomApply" + transforms = T.RandomApply([ + T.ColorJitter(), + ], p=0.3) + with pytest.raises(RuntimeError, match="Module 'RandomApply' has no attribute 'transforms'"): + torch.jit.script(transforms) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('meth_kwargs', [ + {"kernel_size": 3, "sigma": 0.75}, + {"kernel_size": 23, "sigma": [0.1, 2.0]}, + {"kernel_size": 23, "sigma": (0.1, 2.0)}, + {"kernel_size": [3, 3], "sigma": (1.0, 1.0)}, + {"kernel_size": (3, 3), "sigma": (0.1, 2.0)}, + {"kernel_size": [23], "sigma": 0.75} +]) +def test_gaussian_blur(device, meth_kwargs): + tol = 1.0 + 1e-10 + _test_class_op( + T.GaussianBlur, meth_kwargs=meth_kwargs, + test_exact_match=False, device=device, agg_method="max", tol=tol + ) + + if __name__ == '__main__': unittest.main() From 50468715e9cc56000ab68ded53a67b627b1dd31a Mon Sep 17 00:00:00 2001 From: Rajat Jaiswal <76243388+artifiitr@users.noreply.github.com> Date: Wed, 9 Jun 2021 22:06:40 +0530 Subject: [PATCH 170/279] port the rest of test_transforms.py to pytest (#4026) --- test/common_utils.py | 5 +- test/test_transforms.py | 237 +++++++++++++++++++--------------------- 2 files changed, 116 insertions(+), 126 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index a95591ae570..a7534f7d3ed 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -219,8 +219,9 @@ def freeze_rng_state(): def cycle_over(objs): - for idx, obj in enumerate(objs): - yield obj, objs[:idx] + objs[idx + 1:] + for idx, obj1 in enumerate(objs): + for obj2 in objs[:idx] + objs[idx + 1:]: + yield obj1, obj2 def int_dtypes(): diff --git a/test/test_transforms.py b/test/test_transforms.py index 49396e78435..8a0fb0f5ca6 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -1,12 +1,9 @@ -import itertools import os import torch import torchvision.transforms as transforms import torchvision.transforms.functional as F import torchvision.transforms.functional_tensor as F_t from torch._utils_internal import get_file_path_2 -from numpy.testing import assert_array_almost_equal -import unittest import math import random import numpy as np @@ -30,126 +27,118 @@ os.path.dirname(os.path.abspath(__file__)), 'assets', 'encode_jpeg', 'grace_hopper_517x606.jpg') -class Tester(unittest.TestCase): - - def test_convert_image_dtype_float_to_float(self): - for input_dtype, output_dtypes in cycle_over(float_dtypes()): - input_image = torch.tensor((0.0, 1.0), dtype=input_dtype) - for output_dtype in output_dtypes: - with self.subTest(input_dtype=input_dtype, output_dtype=output_dtype): - transform = transforms.ConvertImageDtype(output_dtype) - transform_script = torch.jit.script(F.convert_image_dtype) - - output_image = transform(input_image) - output_image_script = transform_script(input_image, output_dtype) - - torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) - - actual_min, actual_max = output_image.tolist() - desired_min, desired_max = 0.0, 1.0 - - self.assertAlmostEqual(actual_min, desired_min) - self.assertAlmostEqual(actual_max, desired_max) - - def test_convert_image_dtype_float_to_int(self): - for input_dtype in float_dtypes(): - input_image = torch.tensor((0.0, 1.0), dtype=input_dtype) - for output_dtype in int_dtypes(): - with self.subTest(input_dtype=input_dtype, output_dtype=output_dtype): - transform = transforms.ConvertImageDtype(output_dtype) - transform_script = torch.jit.script(F.convert_image_dtype) - - if (input_dtype == torch.float32 and output_dtype in (torch.int32, torch.int64)) or ( - input_dtype == torch.float64 and output_dtype == torch.int64 - ): - with self.assertRaises(RuntimeError): - transform(input_image) - else: - output_image = transform(input_image) - output_image_script = transform_script(input_image, output_dtype) - - torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) - - actual_min, actual_max = output_image.tolist() - desired_min, desired_max = 0, torch.iinfo(output_dtype).max - - self.assertEqual(actual_min, desired_min) - self.assertEqual(actual_max, desired_max) - - def test_convert_image_dtype_int_to_float(self): - for input_dtype in int_dtypes(): - input_image = torch.tensor((0, torch.iinfo(input_dtype).max), dtype=input_dtype) - for output_dtype in float_dtypes(): - with self.subTest(input_dtype=input_dtype, output_dtype=output_dtype): - transform = transforms.ConvertImageDtype(output_dtype) - transform_script = torch.jit.script(F.convert_image_dtype) - - output_image = transform(input_image) - output_image_script = transform_script(input_image, output_dtype) - - torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) - - actual_min, actual_max = output_image.tolist() - desired_min, desired_max = 0.0, 1.0 - - self.assertAlmostEqual(actual_min, desired_min) - self.assertGreaterEqual(actual_min, desired_min) - self.assertAlmostEqual(actual_max, desired_max) - self.assertLessEqual(actual_max, desired_max) - - def test_convert_image_dtype_int_to_int(self): - for input_dtype, output_dtypes in cycle_over(int_dtypes()): - input_max = torch.iinfo(input_dtype).max - input_image = torch.tensor((0, input_max), dtype=input_dtype) - for output_dtype in output_dtypes: - output_max = torch.iinfo(output_dtype).max - - with self.subTest(input_dtype=input_dtype, output_dtype=output_dtype): - transform = transforms.ConvertImageDtype(output_dtype) - transform_script = torch.jit.script(F.convert_image_dtype) - - output_image = transform(input_image) - output_image_script = transform_script(input_image, output_dtype) - - torch.testing.assert_close( - output_image_script, - output_image, - rtol=0.0, - atol=1e-6, - msg="{} vs {}".format(output_image_script, output_image), - ) - - actual_min, actual_max = output_image.tolist() - desired_min, desired_max = 0, output_max - - # see https://github.com/pytorch/vision/pull/2078#issuecomment-641036236 for details - if input_max >= output_max: - error_term = 0 - else: - error_term = 1 - (torch.iinfo(output_dtype).max + 1) // (torch.iinfo(input_dtype).max + 1) - - self.assertEqual(actual_min, desired_min) - self.assertEqual(actual_max, desired_max + error_term) - - def test_convert_image_dtype_int_to_int_consistency(self): - for input_dtype, output_dtypes in cycle_over(int_dtypes()): - input_max = torch.iinfo(input_dtype).max - input_image = torch.tensor((0, input_max), dtype=input_dtype) - for output_dtype in output_dtypes: - output_max = torch.iinfo(output_dtype).max - if output_max <= input_max: - continue - - with self.subTest(input_dtype=input_dtype, output_dtype=output_dtype): - transform = transforms.ConvertImageDtype(output_dtype) - inverse_transfrom = transforms.ConvertImageDtype(input_dtype) - output_image = inverse_transfrom(transform(input_image)) - - actual_min, actual_max = output_image.tolist() - desired_min, desired_max = 0, input_max - - self.assertEqual(actual_min, desired_min) - self.assertEqual(actual_max, desired_max) +class TestConvertImageDtype: + @pytest.mark.parametrize('input_dtype, output_dtype', cycle_over(float_dtypes())) + def test_float_to_float(self, input_dtype, output_dtype): + input_image = torch.tensor((0.0, 1.0), dtype=input_dtype) + transform = transforms.ConvertImageDtype(output_dtype) + transform_script = torch.jit.script(F.convert_image_dtype) + + output_image = transform(input_image) + output_image_script = transform_script(input_image, output_dtype) + + torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) + + actual_min, actual_max = output_image.tolist() + desired_min, desired_max = 0.0, 1.0 + + assert abs(actual_min - desired_min) < 1e-7 + assert abs(actual_max - desired_max) < 1e-7 + + @pytest.mark.parametrize('input_dtype', float_dtypes()) + @pytest.mark.parametrize('output_dtype', int_dtypes()) + def test_float_to_int(self, input_dtype, output_dtype): + input_image = torch.tensor((0.0, 1.0), dtype=input_dtype) + transform = transforms.ConvertImageDtype(output_dtype) + transform_script = torch.jit.script(F.convert_image_dtype) + + if (input_dtype == torch.float32 and output_dtype in (torch.int32, torch.int64)) or ( + input_dtype == torch.float64 and output_dtype == torch.int64 + ): + with pytest.raises(RuntimeError): + transform(input_image) + else: + output_image = transform(input_image) + output_image_script = transform_script(input_image, output_dtype) + + torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) + + actual_min, actual_max = output_image.tolist() + desired_min, desired_max = 0, torch.iinfo(output_dtype).max + + assert actual_min == desired_min + assert actual_max == desired_max + + @pytest.mark.parametrize('input_dtype', int_dtypes()) + @pytest.mark.parametrize('output_dtype', float_dtypes()) + def test_int_to_float(self, input_dtype, output_dtype): + input_image = torch.tensor((0, torch.iinfo(input_dtype).max), dtype=input_dtype) + transform = transforms.ConvertImageDtype(output_dtype) + transform_script = torch.jit.script(F.convert_image_dtype) + + output_image = transform(input_image) + output_image_script = transform_script(input_image, output_dtype) + + torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) + + actual_min, actual_max = output_image.tolist() + desired_min, desired_max = 0.0, 1.0 + + assert abs(actual_min - desired_min) < 1e-7 + assert actual_min >= desired_min + assert abs(actual_max - desired_max) < 1e-7 + assert actual_max <= desired_max + + @pytest.mark.parametrize('input_dtype, output_dtype', cycle_over(int_dtypes())) + def test_dtype_int_to_int(self, input_dtype, output_dtype): + input_max = torch.iinfo(input_dtype).max + input_image = torch.tensor((0, input_max), dtype=input_dtype) + output_max = torch.iinfo(output_dtype).max + + transform = transforms.ConvertImageDtype(output_dtype) + transform_script = torch.jit.script(F.convert_image_dtype) + + output_image = transform(input_image) + output_image_script = transform_script(input_image, output_dtype) + + torch.testing.assert_close( + output_image_script, + output_image, + rtol=0.0, + atol=1e-6, + msg="{} vs {}".format(output_image_script, output_image), + ) + + actual_min, actual_max = output_image.tolist() + desired_min, desired_max = 0, output_max + + # see https://github.com/pytorch/vision/pull/2078#issuecomment-641036236 for details + if input_max >= output_max: + error_term = 0 + else: + error_term = 1 - (torch.iinfo(output_dtype).max + 1) // (torch.iinfo(input_dtype).max + 1) + + assert actual_min == desired_min + assert actual_max == (desired_max + error_term) + + @pytest.mark.parametrize('input_dtype, output_dtype', cycle_over(int_dtypes())) + def test_int_to_int_consistency(self, input_dtype, output_dtype): + input_max = torch.iinfo(input_dtype).max + input_image = torch.tensor((0, input_max), dtype=input_dtype) + + output_max = torch.iinfo(output_dtype).max + if output_max <= input_max: + return + + transform = transforms.ConvertImageDtype(output_dtype) + inverse_transfrom = transforms.ConvertImageDtype(input_dtype) + output_image = inverse_transfrom(transform(input_image)) + + actual_min, actual_max = output_image.tolist() + desired_min, desired_max = 0, input_max + + assert actual_min == desired_min + assert actual_max == desired_max @pytest.mark.skipif(accimage is None, reason="accimage not available") @@ -2120,4 +2109,4 @@ def test_random_affine(): if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From 6fc18d63980bd9b0642a801c4ce9bb948ab9d166 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Wed, 9 Jun 2021 19:33:50 +0100 Subject: [PATCH 171/279] Drop virtual from private member functions of Decoder class (#4027) --- torchvision/csrc/io/decoder/decoder.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/torchvision/csrc/io/decoder/decoder.h b/torchvision/csrc/io/decoder/decoder.h index c2d8f163bc3..f289a170485 100644 --- a/torchvision/csrc/io/decoder/decoder.h +++ b/torchvision/csrc/io/decoder/decoder.h @@ -59,11 +59,11 @@ class Decoder : public MediaDecoder { private: // mark below function for a proper invocation - virtual bool enableLogLevel(int level) const; - virtual void logCallback(int level, const std::string& message); - virtual int readCallback(uint8_t* buf, int size); - virtual int64_t seekCallback(int64_t offset, int whence); - virtual int shutdownCallback(); + bool enableLogLevel(int level) const; + void logCallback(int level, const std::string& message); + int readCallback(uint8_t* buf, int size); + int64_t seekCallback(int64_t offset, int whence); + int shutdownCallback(); bool openStreams(std::vector* metadata); Stream* findByIndex(int streamIndex) const; From d486ca7e9570220eaeb31b2f976a4a8a1742fe8b Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Wed, 9 Jun 2021 21:29:29 +0100 Subject: [PATCH 172/279] Fixed some ffmpeg deprecation warnings in decoder (#4003) * Fixed some ffmpeg deprecation warnings in decoder * Fixed clang error Co-authored-by: Vasilis Vryniotis --- torchvision/csrc/io/decoder/decoder.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/torchvision/csrc/io/decoder/decoder.cpp b/torchvision/csrc/io/decoder/decoder.cpp index 6c9a3cdf825..a6361ca79ce 100644 --- a/torchvision/csrc/io/decoder/decoder.cpp +++ b/torchvision/csrc/io/decoder/decoder.cpp @@ -1,5 +1,6 @@ #include "decoder.h" #include +#include #include #include #include @@ -196,8 +197,10 @@ int64_t Decoder::seekCallback(int64_t offset, int whence) { void Decoder::initOnce() { static std::once_flag flagInit; std::call_once(flagInit, []() { +#if LIBAVUTIL_VERSION_MAJOR < 56 // Before FFMPEG 4.0 av_register_all(); avcodec_register_all(); +#endif avformat_network_init(); // register ffmpeg lock manager av_lockmgr_register(&ffmpeg_lock); @@ -397,10 +400,14 @@ bool Decoder::init( } bool Decoder::openStreams(std::vector* metadata) { - for (int i = 0; i < inputCtx_->nb_streams; i++) { + for (unsigned int i = 0; i < inputCtx_->nb_streams; i++) { // - find the corespondent format at params_.formats set MediaFormat format; +#if LIBAVUTIL_VERSION_MAJOR < 56 // Before FFMPEG 4.0 const auto media = inputCtx_->streams[i]->codec->codec_type; +#else // FFMPEG 4.0+ + const auto media = inputCtx_->streams[i]->codecpar->codec_type; +#endif if (!mapFfmpegType(media, &format.type)) { VLOG(1) << "Stream media: " << media << " at index " << i << " gets ignored, unknown type"; From 9a6c8bbebdde22b37255f6a78816839823f28d8b Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Thu, 10 Jun 2021 09:00:37 +0100 Subject: [PATCH 173/279] Fixed typo in audio_sampler comments (#4028) --- torchvision/csrc/io/decoder/audio_sampler.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/torchvision/csrc/io/decoder/audio_sampler.cpp b/torchvision/csrc/io/decoder/audio_sampler.cpp index 421e503b2ce..cc170aa1bcc 100644 --- a/torchvision/csrc/io/decoder/audio_sampler.cpp +++ b/torchvision/csrc/io/decoder/audio_sampler.cpp @@ -65,7 +65,7 @@ bool AudioSampler::init(const SamplerParameters& params) { int result; if ((result = swr_init(swrContext_)) < 0) { - LOG(ERROR) << "swr_init faield, err: " << Util::generateErrorDesc(result) + LOG(ERROR) << "swr_init failed, err: " << Util::generateErrorDesc(result) << ", in -> format: " << params.in.audio.format << ", channels: " << params.in.audio.channels << ", samples: " << params.in.audio.samples @@ -116,7 +116,7 @@ int AudioSampler::sample( outNumSamples, inPlanes, inNumSamples)) < 0) { - LOG(ERROR) << "swr_convert faield, err: " + LOG(ERROR) << "swr_convert failed, err: " << Util::generateErrorDesc(result); return result; } @@ -132,7 +132,7 @@ int AudioSampler::sample( 1)) >= 0) { out->append(result); } else { - LOG(ERROR) << "av_samples_get_buffer_size faield, err: " + LOG(ERROR) << "av_samples_get_buffer_size failed, err: " << Util::generateErrorDesc(result); } } @@ -140,7 +140,7 @@ int AudioSampler::sample( // allocate a temporary buffer auto* tmpBuffer = static_cast(av_malloc(outBufferBytes)); if (!tmpBuffer) { - LOG(ERROR) << "av_alloc faield, for size: " << outBufferBytes; + LOG(ERROR) << "av_alloc failed, for size: " << outBufferBytes; return -1; } @@ -158,7 +158,7 @@ int AudioSampler::sample( outNumSamples, inPlanes, inNumSamples)) < 0) { - LOG(ERROR) << "swr_convert faield, err: " + LOG(ERROR) << "swr_convert failed, err: " << Util::generateErrorDesc(result); av_free(tmpBuffer); return result; From 8ea04d13c647b97f5f2150950296af7e4323ff1f Mon Sep 17 00:00:00 2001 From: Bruno Korbar Date: Thu, 10 Jun 2021 09:53:31 +0100 Subject: [PATCH 174/279] Download and Kinetics 400/600/700 Datasets (#3680) * Initial commit * pmeiers comments Co-authored-by: Philip Meier * pmeiers changes Co-authored-by: Philip Meier * pmeiers comments Co-authored-by: Philip Meier * replace pandas with system library to avoid crashes * Lint * Lint * fixing unittest * Minor comments removal * pmeier comments Co-authored-by: Philip Meier * remove asserts * address pmeier formatting changes * address pmeier changes Co-authored-by: Philip Meier * pmeier changes Co-authored-by: Philip Meier * rename n_classes to num_classes * formatting changes * doc change to add ".mp4" to backported class * formatting to correct line length * adding **kwargs to Kinetics400 class * remove urlib request and download the file directly * annotations and files can be already downloaded * test fix * add download tests for Kinetics * users now dont need to provide full path within the root for new Kinetics dataset * linter * Update test/test_datasets_download.py * Update torchvision/datasets/kinetics.py Co-authored-by: Philip Meier * revert whitespace (3680#discussion_r626382842) * addressing annotation_path parameter which is unnecessary * Update torchvision/datasets/kinetics.py Co-authored-by: Philip Meier * Update torchvision/datasets/kinetics.py Co-authored-by: Philip Meier * kwargs update Co-authored-by: Philip Meier * expose num_download_workers as public * swap os.isfile with check_integrity * nit on private things * special case if there are no default arguments * revert changes to kinetics400 test case for BC * add split_folder changes and support for legacy format * pmeiers suggestions Co-authored-by: Philip Meier * pmeiers suggestions - root comment * pmeiers comments - annotation attribute remmoved * pmeiers suggestion Co-authored-by: Philip Meier * pmeiers suggestion Co-authored-by: Philip Meier * pmeiers suggestion Co-authored-by: Philip Meier * pmeiers suggestion Co-authored-by: Philip Meier * Update torchvision/datasets/kinetics.py Co-authored-by: Philip Meier * Update torchvision/datasets/kinetics.py Co-authored-by: Philip Meier * Update torchvision/datasets/kinetics.py Co-authored-by: Philip Meier * Update torchvision/datasets/kinetics.py Co-authored-by: Philip Meier * Update torchvision/datasets/kinetics.py Co-authored-by: Philip Meier * Update torchvision/datasets/kinetics.py Co-authored-by: Philip Meier * minor debugging * nit picks * only include public kwargs into defaults * add _use_legacy_structure in favour of **kwargs * add type hints for Kinetics400 * flake8 * flake8 * flake8 * rename to make thigs clearer * permuting the output Co-authored-by: Philip Meier Co-authored-by: Francisco Massa --- test/datasets_utils.py | 8 +- test/test_datasets.py | 21 +++ test/test_datasets_download.py | 20 +++ torchvision/datasets/__init__.py | 4 +- torchvision/datasets/kinetics.py | 282 ++++++++++++++++++++++++++++--- 5 files changed, 305 insertions(+), 30 deletions(-) diff --git a/test/datasets_utils.py b/test/datasets_utils.py index 8077a03b910..d7853b46314 100644 --- a/test/datasets_utils.py +++ b/test/datasets_utils.py @@ -416,7 +416,11 @@ def _populate_private_class_attributes(cls): continue defaults.append( - {kwarg: default for kwarg, default in zip(argspec.args[-len(argspec.defaults):], argspec.defaults)} + { + kwarg: default + for kwarg, default in zip(argspec.args[-len(argspec.defaults):], argspec.defaults) + if not kwarg.startswith("_") + } ) if not argspec.varkw: @@ -637,7 +641,7 @@ def __init__(self, *args, **kwargs): def _set_default_frames_per_clip(self, inject_fake_data): argspec = inspect.getfullargspec(self.DATASET_CLASS.__init__) - args_without_default = argspec.args[1:-len(argspec.defaults)] + args_without_default = argspec.args[1:(-len(argspec.defaults) if argspec.defaults else None)] frames_per_clip_last = args_without_default[-1] == "frames_per_clip" @functools.wraps(inject_fake_data) diff --git a/test/test_datasets.py b/test/test_datasets.py index a076b843fa8..bea2a2b80b9 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -944,6 +944,27 @@ def test_not_found_or_corrupted(self): super().test_not_found_or_corrupted() +class KineticsTestCase(datasets_utils.VideoDatasetTestCase): + DATASET_CLASS = datasets.Kinetics + ADDITIONAL_CONFIGS = datasets_utils.combinations_grid( + split=("train", "val"), num_classes=("400", "600", "700") + ) + + def inject_fake_data(self, tmpdir, config): + classes = ("Abseiling", "Zumba") + num_videos_per_class = 2 + tmpdir = pathlib.Path(tmpdir) / config['split'] + digits = string.ascii_letters + string.digits + "-_" + for cls in classes: + datasets_utils.create_video_folder( + tmpdir, + cls, + lambda _: f"{datasets_utils.create_random_string(11, digits)}.mp4", + num_videos_per_class, + ) + return num_videos_per_class * len(classes) + + class Kinetics400TestCase(datasets_utils.VideoDatasetTestCase): DATASET_CLASS = datasets.Kinetics400 diff --git a/test/test_datasets_download.py b/test/test_datasets_download.py index 0066b76ccbe..8c2d575e01d 100644 --- a/test/test_datasets_download.py +++ b/test/test_datasets_download.py @@ -392,6 +392,25 @@ def widerface(): ) +def kinetics(): + return itertools.chain( + *[ + collect_download_configs( + lambda: datasets.Kinetics( + path.join(ROOT, f"Kinetics{num_classes}"), + frames_per_clip=1, + num_classes=num_classes, + split=split, + download=True, + ), + name=f"Kinetics, {num_classes}, {split}", + file="kinetics", + ) + for num_classes, split in itertools.product(("400", "600", "700"), ("train", "val")) + ] + ) + + def kitti(): return itertools.chain( *[ @@ -440,6 +459,7 @@ def make_parametrize_kwargs(download_configs): usps(), celeba(), widerface(), + kinetics(), kitti(), ) ) diff --git a/torchvision/datasets/__init__.py b/torchvision/datasets/__init__.py index b60fc7c7964..e67ba08d299 100644 --- a/torchvision/datasets/__init__.py +++ b/torchvision/datasets/__init__.py @@ -20,7 +20,7 @@ from .sbd import SBDataset from .vision import VisionDataset from .usps import USPS -from .kinetics import Kinetics400 +from .kinetics import Kinetics400, Kinetics from .hmdb51 import HMDB51 from .ucf101 import UCF101 from .places365 import Places365 @@ -34,6 +34,6 @@ 'Omniglot', 'SBU', 'Flickr8k', 'Flickr30k', 'VOCSegmentation', 'VOCDetection', 'Cityscapes', 'ImageNet', 'Caltech101', 'Caltech256', 'CelebA', 'WIDERFace', 'SBDataset', - 'VisionDataset', 'USPS', 'Kinetics400', 'HMDB51', 'UCF101', + 'VisionDataset', 'USPS', 'Kinetics400', "Kinetics", 'HMDB51', 'UCF101', 'Places365', 'Kitti', ) diff --git a/torchvision/datasets/kinetics.py b/torchvision/datasets/kinetics.py index a8986986c17..2543b6c514d 100644 --- a/torchvision/datasets/kinetics.py +++ b/torchvision/datasets/kinetics.py @@ -1,15 +1,29 @@ -from .utils import list_dir +import time +import os +import warnings + + +from os import path +import csv +from typing import Any, Callable, Dict, Optional, Tuple +from functools import partial +from multiprocessing import Pool + +from .utils import download_and_extract_archive, download_url, verify_str_arg, check_integrity from .folder import find_classes, make_dataset from .video_utils import VideoClips from .vision import VisionDataset -class Kinetics400(VisionDataset): - """ - `Kinetics-400 `_ +def _dl_wrap(tarpath, videopath, line): + download_and_extract_archive(line, tarpath, videopath) + + +class Kinetics(VisionDataset): + """` Generic Kinetics `_ dataset. - Kinetics-400 is an action recognition video dataset. + Kinetics-400/600/700 are action recognition video datasets. This dataset consider every video as a collection of video clips of fixed size, specified by ``frames_per_clip``, where the step in frames between each clip is given by ``step_between_clips``. @@ -20,44 +34,101 @@ class Kinetics400(VisionDataset): Note that we drop clips which do not have exactly ``frames_per_clip`` elements, so not all frames in a video might be present. - Internally, it uses a VideoClips object to handle clip creation. - Args: - root (string): Root directory of the Kinetics-400 Dataset. Should be structured as follows: - + root (string): Root directory of the Kinetics Dataset. + Directory should be structured as follows: .. code:: root/ - ├── class1 - │ ├── clip1.avi - │ ├── clip2.avi - │ └── ... - └── class2 - ├── clipx.avi - └── ... - + ├── split + │ ├── class1 + │ │ ├── clip1.mp4 + │ │ ├── clip2.mp4 + │ │ ├── clip3.mp4 + │ │ ├── ... + │ ├── class2 + │ │ ├── clipx.mp4 + │ │ └── ... + Note: split is appended automatically using the split argument. frames_per_clip (int): number of frames in a clip + num_classes (int): select between Kinetics-400 (default), Kinetics-600, and Kinetics-700 + split (str): split of the dataset to consider; supports ``"train"`` (default) ``"val"`` + frame_rate (float): If omitted, interpolate different frame rate for each clip. step_between_clips (int): number of frames between each clip transform (callable, optional): A function/transform that takes in a TxHxWxC video and returns a transformed version. + download (bool): Download the official version of the dataset to root folder. + num_workers (int): Use multiple workers for VideoClips creation + num_download_workers (int): Use multiprocessing in order to speed up download. Returns: tuple: A 3-tuple with the following entries: - - video (Tensor[T, H, W, C]): the `T` video frames + - video (Tensor[T, C, H, W]): the `T` video frames in torch.uint8 tensor - audio(Tensor[K, L]): the audio frames, where `K` is the number of channels - and `L` is the number of points + and `L` is the number of points in torch.float tensor - label (int): class of the video clip + + Raises: + RuntimeError: If ``download is True`` and the video archives are already extracted. """ - def __init__(self, root, frames_per_clip, step_between_clips=1, frame_rate=None, - extensions=('avi',), transform=None, _precomputed_metadata=None, - num_workers=1, _video_width=0, _video_height=0, - _video_min_dimension=0, _audio_samples=0, _audio_channels=0): - super(Kinetics400, self).__init__(root) + _TAR_URLS = { + "400": "https://s3.amazonaws.com/kinetics/400/{split}/k400_{split}_path.txt", + "600": "https://s3.amazonaws.com/kinetics/600/{split}/k600_{split}_path.txt", + "700": "https://s3.amazonaws.com/kinetics/700_2020/{split}/k700_2020_{split}_path.txt", + } + _ANNOTATION_URLS = { + "400": "https://s3.amazonaws.com/kinetics/400/annotations/{split}.csv", + "600": "https://s3.amazonaws.com/kinetics/600/annotations/{split}.txt", + "700": "https://s3.amazonaws.com/kinetics/700_2020/annotations/{split}.csv", + } + + def __init__( + self, + root: str, + frames_per_clip: int, + num_classes: str = "400", + split: str = "train", + frame_rate: Optional[float] = None, + step_between_clips: int = 1, + transform: Optional[Callable] = None, + extensions: Tuple[str, ...] = ("avi", "mp4"), + download: bool = False, + num_download_workers: int = 1, + num_workers: int = 1, + _precomputed_metadata: Optional[Dict] = None, + _video_width: int = 0, + _video_height: int = 0, + _video_min_dimension: int = 0, + _audio_samples: int = 0, + _audio_channels: int = 0, + _legacy: bool = False, + ) -> None: + + # TODO: support test + self.num_classes = verify_str_arg(num_classes, arg="num_classes", valid_values=["400", "600", "700"]) + self.extensions = extensions + self.num_download_workers = num_download_workers + + self.root = root + self._legacy = _legacy + if _legacy: + print("Using legacy structure") + self.split_folder = root + self.split = "unknown" + assert not download, "Cannot download the videos using legacy_structure." + else: + self.split_folder = path.join(root, split) + self.split = verify_str_arg(split, arg="split", valid_values=["train", "val"]) + + if download: + self.download_and_process_videos() + + super().__init__(self.root) - self.classes, class_to_idx = find_classes(self.root) - self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) + self.classes, class_to_idx = find_classes(self.split_folder) + self.samples = make_dataset(self.split_folder, class_to_idx, extensions, is_valid_file=None) video_list = [x[0] for x in self.samples] self.video_clips = VideoClips( video_list, @@ -74,6 +145,88 @@ def __init__(self, root, frames_per_clip, step_between_clips=1, frame_rate=None, ) self.transform = transform + def download_and_process_videos(self) -> None: + """Downloads all the videos to the _root_ folder in the expected format.""" + tic = time.time() + self._download_videos() + toc = time.time() + print("Elapsed time for downloading in mins ", (toc - tic) / 60) + self._make_ds_structure() + toc2 = time.time() + print("Elapsed time for processing in mins ", (toc2 - toc) / 60) + print("Elapsed time overall in mins ", (toc2 - tic) / 60) + + def _download_videos(self) -> None: + """download tarballs containing the video to "tars" folder and extract them into the _split_ folder where + split is one of the official dataset splits. + + Raises: + RuntimeError: if download folder exists, break to prevent downloading entire dataset again. + """ + if path.exists(self.split_folder): + raise RuntimeError( + f"The directory {self.split_folder} already exists. " + f"If you want to re-download or re-extract the images, delete the directory." + ) + tar_path = path.join(self.root, "tars") + file_list_path = path.join(self.root, "files") + + split_url = self._TAR_URLS[self.num_classes].format(split=self.split) + split_url_filepath = path.join(file_list_path, path.basename(split_url)) + if not check_integrity(split_url_filepath): + download_url(split_url, file_list_path) + list_video_urls = open(split_url_filepath, "r") + + if self.num_download_workers == 1: + for line in list_video_urls.readlines(): + line = str(line).replace("\n", "") + download_and_extract_archive(line, tar_path, self.split_folder) + else: + part = partial(_dl_wrap, tar_path, self.split_folder) + lines = [str(line).replace("\n", "") for line in list_video_urls.readlines()] + poolproc = Pool(self.num_download_workers) + poolproc.map(part, lines) + + def _make_ds_structure(self): + """move videos from + split_folder/ + ├── clip1.avi + ├── clip2.avi + + to the correct format as described below: + split_folder/ + ├── class1 + │ ├── clip1.avi + + """ + annotation_path = path.join(self.root, "annotations") + if not check_integrity(path.join(annotation_path, f"{self.split}.csv")): + download_url(self._ANNOTATION_URLS[self.num_classes].format(split=self.split), annotation_path) + annotations = path.join(annotation_path, f"{self.split}.csv") + + file_fmtstr = "{ytid}_{start:06}_{end:06}.mp4" + with open(annotations) as csvfile: + reader = csv.DictReader(csvfile) + for row in reader: + f = file_fmtstr.format( + ytid=row["youtube_id"], + start=int(row["time_start"]), + end=int(row["time_end"]), + ) + label = ( + row["label"] + .replace(" ", "_") + .replace("'", "") + .replace("(", "") + .replace(")", "") + ) + os.makedirs(path.join(self.split_folder, label), exist_ok=True) + downloaded_file = path.join(self.split_folder, f) + if path.isfile(downloaded_file): + os.replace( + downloaded_file, path.join(self.split_folder, label, f), + ) + @property def metadata(self): return self.video_clips.metadata @@ -83,9 +236,86 @@ def __len__(self): def __getitem__(self, idx): video, audio, info, video_idx = self.video_clips.get_clip(idx) + if not self._legacy: + # [T,H,W,C] --> [T,C,H,W] + video = video.permute(0, 3, 1, 2) label = self.samples[video_idx][1] if self.transform is not None: video = self.transform(video) return video, audio, label + + +class Kinetics400(Kinetics): + """ + `Kinetics-400 `_ + dataset. + + Kinetics-400 is an action recognition video dataset. + This dataset consider every video as a collection of video clips of fixed size, specified + by ``frames_per_clip``, where the step in frames between each clip is given by + ``step_between_clips``. + + To give an example, for 2 videos with 10 and 15 frames respectively, if ``frames_per_clip=5`` + and ``step_between_clips=5``, the dataset size will be (2 + 3) = 5, where the first two + elements will come from video 1, and the next three elements from video 2. + Note that we drop clips which do not have exactly ``frames_per_clip`` elements, so not all + frames in a video might be present. + + Internally, it uses a VideoClips object to handle clip creation. + + Args: + root (string): Root directory of the Kinetics-400 Dataset. Should be structured as follows: + + .. code:: + + root/ + ├── class1 + │ ├── clip1.avi + │ ├── clip2.avi + │ ├── clip3.mp4 + │ └── ... + └── class2 + ├── clipx.avi + └── ... + + frames_per_clip (int): number of frames in a clip + step_between_clips (int): number of frames between each clip + transform (callable, optional): A function/transform that takes in a TxHxWxC video + and returns a transformed version. + + Returns: + tuple: A 3-tuple with the following entries: + + - video (Tensor[T, H, W, C]): the `T` video frames + - audio(Tensor[K, L]): the audio frames, where `K` is the number of channels + and `L` is the number of points + - label (int): class of the video clip + """ + + def __init__( + self, + root: str, + frames_per_clip: int, + num_classes: Any = None, + split: Any = None, + download: Any = None, + num_download_workers: Any = None, + **kwargs: Any + ): + warnings.warn( + "Kinetics400 is deprecated and will be removed in a future release." + "It was replaced by Kinetics(..., num_classes=\"400\").") + if any(value is not None for value in (num_classes, split, download, num_download_workers)): + raise RuntimeError( + "Usage of 'num_classes', 'split', 'download', or 'num_download_workers' is not supported in " + "Kinetics400. Please use Kinetics instead." + ) + + super(Kinetics400, self).__init__( + root=root, + frames_per_clip=frames_per_clip, + _legacy=True, + **kwargs, + ) From e27b3925c9c6bbcf7605c0cf8c6119339fec0e4e Mon Sep 17 00:00:00 2001 From: Anirudh Date: Thu, 10 Jun 2021 17:39:23 +0530 Subject: [PATCH 175/279] Port test_datasets_video_utils.py to pytest (#4035) --- test/test_datasets_video_utils.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/test/test_datasets_video_utils.py b/test/test_datasets_video_utils.py index 0a9d3bdfc36..389ad5196af 100644 --- a/test/test_datasets_video_utils.py +++ b/test/test_datasets_video_utils.py @@ -1,7 +1,7 @@ import contextlib import os import torch -import unittest +import pytest from torchvision import io from torchvision.datasets.video_utils import VideoClips, unfold @@ -31,7 +31,7 @@ def get_list_of_videos(num_videos=5, sizes=None, fps=None): yield names -class Tester(unittest.TestCase): +class TestVideo: def test_unfold(self): a = torch.arange(7) @@ -58,7 +58,7 @@ def test_unfold(self): ]) assert_equal(r, expected, check_stride=False) - @unittest.skipIf(not io.video._av_available(), "this test requires av") + @pytest.mark.skipif(not io.video._av_available(), reason="this test requires av") def test_video_clips(self): with get_list_of_videos(num_videos=3) as video_list: video_clips = VideoClips(video_list, 5, 5, num_workers=2) @@ -82,7 +82,7 @@ def test_video_clips(self): assert video_idx == v_idx assert clip_idx == c_idx - @unittest.skipIf(not io.video._av_available(), "this test requires av") + @pytest.mark.skipif(not io.video._av_available(), reason="this test requires av") def test_video_clips_custom_fps(self): with get_list_of_videos(num_videos=3, sizes=[12, 12, 12], fps=[3, 4, 6]) as video_list: num_frames = 4 @@ -124,7 +124,7 @@ def test_compute_clips_for_video(self): num_frames = 32 orig_fps = 30 new_fps = 13 - with self.assertWarns(UserWarning): + with pytest.warns(UserWarning): clips, idxs = VideoClips.compute_clips_for_video(video_pts, num_frames, num_frames, orig_fps, new_fps) assert len(clips) == 0 @@ -132,4 +132,4 @@ def test_compute_clips_for_video(self): if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From 59833e76f8f1440c5a3f4dffcb830f53d0402d22 Mon Sep 17 00:00:00 2001 From: Anirudh Date: Thu, 10 Jun 2021 18:11:44 +0530 Subject: [PATCH 176/279] port test_models_detection_utils.py to pytest (#4036) --- test/test_models_detection_utils.py | 44 +++++++++++++++-------------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/test/test_models_detection_utils.py b/test/test_models_detection_utils.py index a20e0abc965..bb50e237544 100644 --- a/test/test_models_detection_utils.py +++ b/test/test_models_detection_utils.py @@ -2,12 +2,13 @@ import torch from torchvision.models.detection import _utils from torchvision.models.detection.transform import GeneralizedRCNNTransform -import unittest +import pytest from torchvision.models.detection import backbone_utils from _assert_utils import assert_equal -class Tester(unittest.TestCase): +class TestModelsDetectionUtils: + def test_balanced_positive_negative_sampler(self): sampler = _utils.BalancedPositiveNegativeSampler(4, 0.25) # keep all 6 negatives first, then add 3 positives, last two are ignore @@ -16,39 +17,40 @@ def test_balanced_positive_negative_sampler(self): # we know the number of elements that should be sampled for the positive (1) # and the negative (3), and their location. Let's make sure that they are # there - self.assertEqual(pos[0].sum(), 1) - self.assertEqual(pos[0][6:9].sum(), 1) - self.assertEqual(neg[0].sum(), 3) - self.assertEqual(neg[0][0:6].sum(), 3) + assert pos[0].sum() == 1 + assert pos[0][6:9].sum() == 1 + assert neg[0].sum() == 3 + assert neg[0][0:6].sum() == 3 - def test_resnet_fpn_backbone_frozen_layers(self): + @pytest.mark.parametrize('train_layers, exp_froz_params', [ + (0, 53), (1, 43), (2, 24), (3, 11), (4, 1), (5, 0) + ]) + def test_resnet_fpn_backbone_frozen_layers(self, train_layers, exp_froz_params): # we know how many initial layers and parameters of the network should # be frozen for each trainable_backbone_layers parameter value # i.e all 53 params are frozen if trainable_backbone_layers=0 # ad first 24 params are frozen if trainable_backbone_layers=2 - expected_frozen_params = {0: 53, 1: 43, 2: 24, 3: 11, 4: 1, 5: 0} - for train_layers, exp_froz_params in expected_frozen_params.items(): - model = backbone_utils.resnet_fpn_backbone( - 'resnet50', pretrained=False, trainable_layers=train_layers) - # boolean list that is true if the param at that index is frozen - is_frozen = [not parameter.requires_grad for _, parameter in model.named_parameters()] - # check that expected initial number of layers are frozen - self.assertTrue(all(is_frozen[:exp_froz_params])) + model = backbone_utils.resnet_fpn_backbone( + 'resnet50', pretrained=False, trainable_layers=train_layers) + # boolean list that is true if the param at that index is frozen + is_frozen = [not parameter.requires_grad for _, parameter in model.named_parameters()] + # check that expected initial number of layers are frozen + assert all(is_frozen[:exp_froz_params]) def test_validate_resnet_inputs_detection(self): # default number of backbone layers to train ret = backbone_utils._validate_trainable_layers( pretrained=True, trainable_backbone_layers=None, max_value=5, default_value=3) - self.assertEqual(ret, 3) + assert ret == 3 # can't go beyond 5 - with self.assertRaises(AssertionError): + with pytest.raises(AssertionError): ret = backbone_utils._validate_trainable_layers( pretrained=True, trainable_backbone_layers=6, max_value=5, default_value=3) # if not pretrained, should use all trainable layers and warn - with self.assertWarns(UserWarning): + with pytest.warns(UserWarning): ret = backbone_utils._validate_trainable_layers( pretrained=False, trainable_backbone_layers=0, max_value=5, default_value=3) - self.assertEqual(ret, 5) + assert ret == 5 def test_transform_copy_targets(self): transform = GeneralizedRCNNTransform(300, 500, torch.zeros(3), torch.ones(3)) @@ -63,9 +65,9 @@ def test_not_float_normalize(self): transform = GeneralizedRCNNTransform(300, 500, torch.zeros(3), torch.ones(3)) image = [torch.randint(0, 255, (3, 200, 300), dtype=torch.uint8)] targets = [{'boxes': torch.rand(3, 4)}] - with self.assertRaises(TypeError): + with pytest.raises(TypeError): out = transform(image, targets) # noqa: F841 if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From ec40ac3ab84b90b2bb422f98b4d57b89d424676c Mon Sep 17 00:00:00 2001 From: Alexander Grund Date: Thu, 10 Jun 2021 16:10:39 +0200 Subject: [PATCH 177/279] Import hipify_python only when needed (#4031) Do this after the version check to avoid failures on import for earlier torch where that module did not exist. See #3901 Co-authored-by: Vasilis Vryniotis --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 4cc3d0698a4..0b9a5d4ac11 100644 --- a/setup.py +++ b/setup.py @@ -11,7 +11,6 @@ import torch from torch.utils.cpp_extension import BuildExtension, CppExtension, CUDAExtension, CUDA_HOME -from torch.utils.hipify import hipify_python def read(*names, **kwargs): @@ -150,6 +149,7 @@ def get_extensions(): is_rocm_pytorch = True if ((torch.version.hip is not None) and (ROCM_HOME is not None)) else False if is_rocm_pytorch: + from torch.utils.hipify import hipify_python hipify_python.hipify( project_directory=this_dir, output_directory=this_dir, From 2d6931abe9faa3e34179f17ff13520c3dc732f37 Mon Sep 17 00:00:00 2001 From: Anirudh Date: Thu, 10 Jun 2021 20:32:52 +0530 Subject: [PATCH 178/279] Port test_hub.py to pytest (#4038) --- .circleci/config.yml | 1 + .circleci/config.yml.in | 1 + test/test_hub.py | 22 +++++++++------------- 3 files changed, 11 insertions(+), 13 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index c6e45edbfcc..7c79bbcf9e8 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -242,6 +242,7 @@ jobs: pip install --user --progress-bar off --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html # need to install torchvision dependencies due to transitive imports pip install --user --progress-bar off --editable . + pip install pytest python test/test_hub.py torch_onnx_test: diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index fdc5c68c13a..397cb8f9cc9 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -242,6 +242,7 @@ jobs: pip install --user --progress-bar off --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html # need to install torchvision dependencies due to transitive imports pip install --user --progress-bar off --editable . + pip install pytest python test/test_hub.py torch_onnx_test: diff --git a/test/test_hub.py b/test/test_hub.py index 29ae90014d1..9c9e417933e 100644 --- a/test/test_hub.py +++ b/test/test_hub.py @@ -3,7 +3,7 @@ import shutil import os import sys -import unittest +import pytest def sum_of_model_parameters(model): @@ -16,9 +16,9 @@ def sum_of_model_parameters(model): SUM_OF_PRETRAINED_RESNET18_PARAMS = -12703.9931640625 -@unittest.skipIf('torchvision' in sys.modules, - 'TestHub must start without torchvision imported') -class TestHub(unittest.TestCase): +@pytest.mark.skipif('torchvision' in sys.modules, + reason='TestHub must start without torchvision imported') +class TestHub: # Only run this check ONCE before all tests start. # - If torchvision is imported before all tests start, e.g. we might find _C.so # which doesn't exist in downloaded zip but in the installed wheel. @@ -31,9 +31,7 @@ def test_load_from_github(self): 'resnet18', pretrained=True, progress=False) - self.assertAlmostEqual(sum_of_model_parameters(hub_model).item(), - SUM_OF_PRETRAINED_RESNET18_PARAMS, - places=2) + assert sum_of_model_parameters(hub_model).item() == pytest.approx(SUM_OF_PRETRAINED_RESNET18_PARAMS) def test_set_dir(self): temp_dir = tempfile.gettempdir() @@ -43,16 +41,14 @@ def test_set_dir(self): 'resnet18', pretrained=True, progress=False) - self.assertAlmostEqual(sum_of_model_parameters(hub_model).item(), - SUM_OF_PRETRAINED_RESNET18_PARAMS, - places=2) - self.assertTrue(os.path.exists(temp_dir + '/pytorch_vision_master')) + assert sum_of_model_parameters(hub_model).item() == pytest.approx(SUM_OF_PRETRAINED_RESNET18_PARAMS) + assert os.path.exists(temp_dir + '/pytorch_vision_master') shutil.rmtree(temp_dir + '/pytorch_vision_master') def test_list_entrypoints(self): entry_lists = hub.list('pytorch/vision', force_reload=True) - self.assertIn('resnet18', entry_lists) + assert 'resnet18' in entry_lists if __name__ == "__main__": - unittest.main() + pytest.main([__file__]) From 7326623afbc8cdd2221d592b4a340494a55f4377 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Thu, 10 Jun 2021 16:19:07 +0100 Subject: [PATCH 179/279] Port test_quantized_models.py to pytest (#4034) --- test/test_models.py | 51 +++++++++++++++++++ test/test_quantized_models.py | 93 ----------------------------------- 2 files changed, 51 insertions(+), 93 deletions(-) delete mode 100644 test/test_quantized_models.py diff --git a/test/test_models.py b/test/test_models.py index 4f021d323b2..b52b7ecc690 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -8,9 +8,11 @@ import operator import torch import torch.nn as nn +import torchvision from torchvision import models import pytest import warnings +import traceback ACCEPT = os.getenv('EXPECTTEST_ACCEPT', '0') == '1' @@ -36,6 +38,11 @@ def get_available_video_models(): return [k for k, v in models.video.__dict__.items() if callable(v) and k[0].lower() == k[0] and k[0] != "_"] +def get_available_quantizable_models(): + # TODO add a registration mechanism to torchvision.models + return [k for k, v in models.quantization.__dict__.items() if callable(v) and k[0].lower() == k[0] and k[0] != "_"] + + def _get_expected_file(name=None): # Determine expected file based on environment expected_file_base = get_relative_path(os.path.realpath(__file__), "expect") @@ -617,5 +624,49 @@ def test_video_model(model_name, dev): assert out.shape[-1] == 50 +@pytest.mark.skipif(not ('fbgemm' in torch.backends.quantized.supported_engines and + 'qnnpack' in torch.backends.quantized.supported_engines), + reason="This Pytorch Build has not been built with fbgemm and qnnpack") +@pytest.mark.parametrize('model_name', get_available_quantizable_models()) +def test_quantized_classification_model(model_name): + defaults = { + 'input_shape': (1, 3, 224, 224), + 'pretrained': False, + 'quantize': True, + } + kwargs = {**defaults, **_model_params.get(model_name, {})} + input_shape = kwargs.pop('input_shape') + + # First check if quantize=True provides models that can run with input data + model = torchvision.models.quantization.__dict__[model_name](**kwargs) + x = torch.rand(input_shape) + model(x) + + kwargs['quantize'] = False + for eval_mode in [True, False]: + model = torchvision.models.quantization.__dict__[model_name](**kwargs) + if eval_mode: + model.eval() + model.qconfig = torch.quantization.default_qconfig + else: + model.train() + model.qconfig = torch.quantization.default_qat_qconfig + + model.fuse_model() + if eval_mode: + torch.quantization.prepare(model, inplace=True) + else: + torch.quantization.prepare_qat(model, inplace=True) + model.eval() + + torch.quantization.convert(model, inplace=True) + + try: + torch.jit.script(model) + except Exception as e: + tb = traceback.format_exc() + raise AssertionError(f"model cannot be scripted. Traceback = {str(tb)}") from e + + if __name__ == '__main__': pytest.main([__file__]) diff --git a/test/test_quantized_models.py b/test/test_quantized_models.py deleted file mode 100644 index d8fd5325755..00000000000 --- a/test/test_quantized_models.py +++ /dev/null @@ -1,93 +0,0 @@ -import torchvision -from common_utils import TestCase, map_nested_tensor_object -from collections import OrderedDict -from itertools import product -import torch -import numpy as np -from torchvision import models -import unittest -import traceback -import random - - -def set_rng_seed(seed): - torch.manual_seed(seed) - random.seed(seed) - np.random.seed(seed) - - -def get_available_quantizable_models(): - # TODO add a registration mechanism to torchvision.models - return [k for k, v in models.quantization.__dict__.items() if callable(v) and k[0].lower() == k[0] and k[0] != "_"] - - -# list of models that are not scriptable -scriptable_quantizable_models_blacklist = [] - - -@unittest.skipUnless('fbgemm' in torch.backends.quantized.supported_engines and - 'qnnpack' in torch.backends.quantized.supported_engines, - "This Pytorch Build has not been built with fbgemm and qnnpack") -class ModelTester(TestCase): - def check_quantized_model(self, model, input_shape): - x = torch.rand(input_shape) - model(x) - return - - def check_script(self, model, name): - if name in scriptable_quantizable_models_blacklist: - return - scriptable = True - msg = "" - try: - torch.jit.script(model) - except Exception as e: - tb = traceback.format_exc() - scriptable = False - msg = str(e) + str(tb) - self.assertTrue(scriptable, msg) - - def _test_classification_model(self, name, input_shape): - # First check if quantize=True provides models that can run with input data - - model = torchvision.models.quantization.__dict__[name](pretrained=False, quantize=True) - self.check_quantized_model(model, input_shape) - - for eval_mode in [True, False]: - model = torchvision.models.quantization.__dict__[name](pretrained=False, quantize=False) - if eval_mode: - model.eval() - model.qconfig = torch.quantization.default_qconfig - else: - model.train() - model.qconfig = torch.quantization.default_qat_qconfig - - model.fuse_model() - if eval_mode: - torch.quantization.prepare(model, inplace=True) - else: - torch.quantization.prepare_qat(model, inplace=True) - model.eval() - - torch.quantization.convert(model, inplace=True) - - self.check_script(model, name) - - -for model_name in get_available_quantizable_models(): - # for-loop bodies don't define scopes, so we have to save the variables - # we want to close over in some way - def do_test(self, model_name=model_name): - input_shape = (1, 3, 224, 224) - if model_name in ['inception_v3']: - input_shape = (1, 3, 299, 299) - self._test_classification_model(model_name, input_shape) - - # inception_v3 was causing timeouts on circleci - # See https://github.com/pytorch/vision/issues/1857 - if model_name not in ['inception_v3']: - setattr(ModelTester, "test_" + model_name, do_test) - - -if __name__ == '__main__': - unittest.main() From 13ed657ddffb3077db13ff499f8ab06255138942 Mon Sep 17 00:00:00 2001 From: tanvimoharir <74228962+tanvimoharir@users.noreply.github.com> Date: Thu, 10 Jun 2021 21:22:05 +0530 Subject: [PATCH 180/279] Finish porting test_transforms_tensor to pytest (#3996) --- test/test_transforms_tensor.py | 244 +++++++++++++++------------------ 1 file changed, 109 insertions(+), 135 deletions(-) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index b365c3f3421..1a4ecfbf7c7 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -5,9 +5,8 @@ from torchvision.transforms import InterpolationMode import numpy as np - -import unittest import pytest + from typing import Sequence from common_utils import ( @@ -23,7 +22,6 @@ ) from _assert_utils import assert_equal - NEAREST, BILINEAR, BICUBIC = InterpolationMode.NEAREST, InterpolationMode.BILINEAR, InterpolationMode.BICUBIC @@ -97,121 +95,23 @@ def _test_op(func, method, device, fn_kwargs=None, meth_kwargs=None, test_exact_ _test_class_op(method, device, meth_kwargs, test_exact_match=test_exact_match, **match_kwargs) -class Tester(unittest.TestCase): - - def setUp(self): - self.device = "cpu" - - def test_random_horizontal_flip(self): - _test_op(F.hflip, T.RandomHorizontalFlip, device=self.device) - - def test_random_vertical_flip(self): - _test_op(F.vflip, T.RandomVerticalFlip, device=self.device) - - def test_random_invert(self): - _test_op(F.invert, T.RandomInvert, device=self.device) - - def test_random_posterize(self): - fn_kwargs = meth_kwargs = {"bits": 4} - _test_op( - F.posterize, T.RandomPosterize, device=self.device, fn_kwargs=fn_kwargs, - meth_kwargs=meth_kwargs - ) - - def test_random_solarize(self): - fn_kwargs = meth_kwargs = {"threshold": 192.0} - _test_op( - F.solarize, T.RandomSolarize, device=self.device, fn_kwargs=fn_kwargs, - meth_kwargs=meth_kwargs - ) - - def test_random_adjust_sharpness(self): - fn_kwargs = meth_kwargs = {"sharpness_factor": 2.0} - _test_op( - F.adjust_sharpness, T.RandomAdjustSharpness, device=self.device, fn_kwargs=fn_kwargs, - meth_kwargs=meth_kwargs - ) - - def test_random_autocontrast(self): - # We check the max abs difference because on some (very rare) pixels, the actual value may be different - # between PIL and tensors due to floating approximations. - _test_op( - F.autocontrast, T.RandomAutocontrast, device=self.device, test_exact_match=False, - agg_method='max', tol=(1 + 1e-5), allowed_percentage_diff=.05 - ) - - def test_random_equalize(self): - _test_op(F.equalize, T.RandomEqualize, device=self.device) - - def test_random_erasing(self): - img = torch.rand(3, 60, 60) - - # Test Set 0: invalid value - random_erasing = T.RandomErasing(value=(0.1, 0.2, 0.3, 0.4), p=1.0) - with self.assertRaises(ValueError, msg="If value is a sequence, it should have either a single value or 3"): - random_erasing(img) - - tensor, _ = _create_data(24, 32, channels=3, device=self.device) - batch_tensors = torch.rand(4, 3, 44, 56, device=self.device) - - test_configs = [ - {"value": 0.2}, - {"value": "random"}, - {"value": (0.2, 0.2, 0.2)}, - {"value": "random", "ratio": (0.1, 0.2)}, - ] - - for config in test_configs: - fn = T.RandomErasing(**config) - scripted_fn = torch.jit.script(fn) - _test_transform_vs_scripted(fn, scripted_fn, tensor) - _test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) - - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_random_erasing.pt")) - - def test_convert_image_dtype(self): - tensor, _ = _create_data(26, 34, device=self.device) - batch_tensors = torch.rand(4, 3, 44, 56, device=self.device) - - for in_dtype in int_dtypes() + float_dtypes(): - in_tensor = tensor.to(in_dtype) - in_batch_tensors = batch_tensors.to(in_dtype) - for out_dtype in int_dtypes() + float_dtypes(): - - fn = T.ConvertImageDtype(dtype=out_dtype) - scripted_fn = torch.jit.script(fn) - - if (in_dtype == torch.float32 and out_dtype in (torch.int32, torch.int64)) or \ - (in_dtype == torch.float64 and out_dtype == torch.int64): - with self.assertRaisesRegex(RuntimeError, r"cannot be performed safely"): - _test_transform_vs_scripted(fn, scripted_fn, in_tensor) - with self.assertRaisesRegex(RuntimeError, r"cannot be performed safely"): - _test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) - continue - - _test_transform_vs_scripted(fn, scripted_fn, in_tensor) - _test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) - - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_convert_dtype.pt")) - - def test_autoaugment(self): - tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=self.device) - batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=self.device) - - s_transform = None - for policy in T.AutoAugmentPolicy: - for fill in [None, 85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]: - transform = T.AutoAugment(policy=policy, fill=fill) - s_transform = torch.jit.script(transform) - for _ in range(25): - _test_transform_vs_scripted(transform, s_transform, tensor) - _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - - if s_transform is not None: - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_autoaugment.pt")) +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize( + 'func,method,fn_kwargs,match_kwargs', [ + (F.hflip, T.RandomHorizontalFlip, None, {}), + (F.vflip, T.RandomVerticalFlip, None, {}), + (F.invert, T.RandomInvert, None, {}), + (F.posterize, T.RandomPosterize, {"bits": 4}, {}), + (F.solarize, T.RandomSolarize, {"threshold": 192.0}, {}), + (F.adjust_sharpness, T.RandomAdjustSharpness, {"sharpness_factor": 2.0}, {}), + (F.autocontrast, T.RandomAutocontrast, None, {'test_exact_match': False, + 'agg_method': 'max', 'tol': (1 + 1e-5), + 'allowed_percentage_diff': .05}), + (F.equalize, T.RandomEqualize, None, {}) + ] +) +def test_random(func, method, device, fn_kwargs, match_kwargs): + _test_op(func, method, device, fn_kwargs, fn_kwargs, **match_kwargs) @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -339,7 +239,7 @@ def test_center_crop(device): meth_kwargs=meth_kwargs ) fn_kwargs = {"output_size": (5,)} - meth_kwargs = {"size": (5, )} + meth_kwargs = {"size": (5,)} _test_op( F.center_crop, T.CenterCrop, device=device, fn_kwargs=fn_kwargs, meth_kwargs=meth_kwargs @@ -371,7 +271,7 @@ def test_center_crop(device): # test_ten_crop (F.ten_crop, T.TenCrop, 10) ]) -@pytest.mark.parametrize('size', [(5, ), [5, ], (4, 5), [4, 5]]) +@pytest.mark.parametrize('size', [(5,), [5, ], (4, 5), [4, 5]]) def test_x_crop(fn, method, out_length, size, device): meth_kwargs = fn_kwargs = {'size': size} scripted_fn = torch.jit.script(fn) @@ -462,7 +362,7 @@ def test_resize_save(self): @pytest.mark.parametrize('device', cpu_and_gpu()) @pytest.mark.parametrize('scale', [(0.7, 1.2), [0.7, 1.2]]) @pytest.mark.parametrize('ratio', [(0.75, 1.333), [0.75, 1.333]]) - @pytest.mark.parametrize('size', [(32, ), [44, ], [32, ], [32, 32], (32, 32), [44, 55]]) + @pytest.mark.parametrize('size', [(32,), [44, ], [32, ], [32, 32], (32, 32), [44, 55]]) @pytest.mark.parametrize('interpolation', [NEAREST, BILINEAR, BICUBIC]) def test_resized_crop(self, scale, ratio, size, interpolation, device): tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=device) @@ -480,14 +380,6 @@ def test_resized_crop_save(self): s_transform.save(os.path.join(tmp_dir, "t_resized_crop.pt")) -@unittest.skipIf(not torch.cuda.is_available(), reason="Skip if no CUDA device") -class CUDATester(Tester): - - def setUp(self): - torch.set_deterministic(False) - self.device = "cuda" - - def _test_random_affine_helper(device, **kwargs): tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=device) batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=device) @@ -600,7 +492,6 @@ def test_random_perspective_save(): (T.RandomGrayscale, {}) ]) def test_to_grayscale(device, Klass, meth_kwargs): - tol = 1.0 + 1e-10 _test_class_op( Klass, meth_kwargs=meth_kwargs, test_exact_match=False, device=device, @@ -608,6 +499,94 @@ def test_to_grayscale(device, Klass, meth_kwargs): ) +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('in_dtype', int_dtypes() + float_dtypes()) +@pytest.mark.parametrize('out_dtype', int_dtypes() + float_dtypes()) +def test_convert_image_dtype(device, in_dtype, out_dtype): + tensor, _ = _create_data(26, 34, device=device) + batch_tensors = torch.rand(4, 3, 44, 56, device=device) + + in_tensor = tensor.to(in_dtype) + in_batch_tensors = batch_tensors.to(in_dtype) + + fn = T.ConvertImageDtype(dtype=out_dtype) + scripted_fn = torch.jit.script(fn) + + if (in_dtype == torch.float32 and out_dtype in (torch.int32, torch.int64)) or \ + (in_dtype == torch.float64 and out_dtype == torch.int64): + with pytest.raises(RuntimeError, match=r"cannot be performed safely"): + _test_transform_vs_scripted(fn, scripted_fn, in_tensor) + with pytest.raises(RuntimeError, match=r"cannot be performed safely"): + _test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) + return + + _test_transform_vs_scripted(fn, scripted_fn, in_tensor) + _test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) + + +def test_convert_image_dtype_save(): + fn = T.ConvertImageDtype(dtype=torch.uint8) + scripted_fn = torch.jit.script(fn) + with get_tmp_dir() as tmp_dir: + scripted_fn.save(os.path.join(tmp_dir, "t_convert_dtype.pt")) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize('policy', [policy for policy in T.AutoAugmentPolicy]) +@pytest.mark.parametrize('fill', [None, 85, (10, -10, 10), 0.7, [0.0, 0.0, 0.0], [1, ], 1]) +def test_autoaugment(device, policy, fill): + tensor = torch.randint(0, 256, size=(3, 44, 56), dtype=torch.uint8, device=device) + batch_tensors = torch.randint(0, 256, size=(4, 3, 44, 56), dtype=torch.uint8, device=device) + + s_transform = None + transform = T.AutoAugment(policy=policy, fill=fill) + s_transform = torch.jit.script(transform) + for _ in range(25): + _test_transform_vs_scripted(transform, s_transform, tensor) + _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) + + +def test_autoaugment_save(): + transform = T.AutoAugment() + s_transform = torch.jit.script(transform) + with get_tmp_dir() as tmp_dir: + s_transform.save(os.path.join(tmp_dir, "t_autoaugment.pt")) + + +@pytest.mark.parametrize('device', cpu_and_gpu()) +@pytest.mark.parametrize( + 'config', [ + {"value": 0.2}, + {"value": "random"}, + {"value": (0.2, 0.2, 0.2)}, + {"value": "random", "ratio": (0.1, 0.2)} + ] +) +def test_random_erasing(device, config): + tensor, _ = _create_data(24, 32, channels=3, device=device) + batch_tensors = torch.rand(4, 3, 44, 56, device=device) + + fn = T.RandomErasing(**config) + scripted_fn = torch.jit.script(fn) + _test_transform_vs_scripted(fn, scripted_fn, tensor) + _test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) + + +def test_random_erasing_save(): + fn = T.RandomErasing(value=0.2) + scripted_fn = torch.jit.script(fn) + with get_tmp_dir() as tmp_dir: + scripted_fn.save(os.path.join(tmp_dir, "t_random_erasing.pt")) + + +def test_random_erasing_with_invalid_data(): + img = torch.rand(3, 60, 60) + # Test Set 0: invalid value + random_erasing = T.RandomErasing(value=(0.1, 0.2, 0.3, 0.4), p=1.0) + with pytest.raises(ValueError, match="If value is a sequence, it should have either a single value or 3"): + random_erasing(img) + + @pytest.mark.parametrize('device', cpu_and_gpu()) def test_normalize(device): fn = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) @@ -659,7 +638,6 @@ def test_linear_transformation(device): def test_compose(device): tensor, _ = _create_data(26, 34, device=device) tensor = tensor.to(dtype=torch.float32) / 255.0 - transforms = T.Compose([ T.CenterCrop(10), T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), @@ -726,7 +704,3 @@ def test_gaussian_blur(device, meth_kwargs): T.GaussianBlur, meth_kwargs=meth_kwargs, test_exact_match=False, device=device, agg_method="max", tol=tol ) - - -if __name__ == '__main__': - unittest.main() From 093757dbebcc7ab265287d00a365705d305db2a6 Mon Sep 17 00:00:00 2001 From: Vivek Kumar <60113444+vivekkumar7089@users.noreply.github.com> Date: Thu, 10 Jun 2021 23:38:58 +0530 Subject: [PATCH 181/279] Port test_datasets_samplers.py to pytest (#4037) --- test/test_datasets_samplers.py | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/test/test_datasets_samplers.py b/test/test_datasets_samplers.py index 10d8704dbb1..be2fab8e0dd 100644 --- a/test/test_datasets_samplers.py +++ b/test/test_datasets_samplers.py @@ -2,7 +2,7 @@ import sys import os import torch -import unittest +import pytest from torchvision import io from torchvision.datasets.samplers import ( @@ -38,13 +38,13 @@ def get_list_of_videos(num_videos=5, sizes=None, fps=None): yield names -@unittest.skipIf(not io.video._av_available(), "this test requires av") -class Tester(unittest.TestCase): +@pytest.mark.skipif(not io.video._av_available(), reason="this test requires av") +class TestDatasetsSamplers: def test_random_clip_sampler(self): with get_list_of_videos(num_videos=3, sizes=[25, 25, 25]) as video_list: video_clips = VideoClips(video_list, 5, 5) sampler = RandomClipSampler(video_clips, 3) - self.assertEqual(len(sampler), 3 * 3) + assert len(sampler) == 3 * 3 indices = torch.tensor(list(iter(sampler))) videos = torch.div(indices, 5, rounding_mode='floor') v_idxs, count = torch.unique(videos, return_counts=True) @@ -55,10 +55,10 @@ def test_random_clip_sampler_unequal(self): with get_list_of_videos(num_videos=3, sizes=[10, 25, 25]) as video_list: video_clips = VideoClips(video_list, 5, 5) sampler = RandomClipSampler(video_clips, 3) - self.assertEqual(len(sampler), 2 + 3 + 3) + assert len(sampler) == 2 + 3 + 3 indices = list(iter(sampler)) - self.assertIn(0, indices) - self.assertIn(1, indices) + assert 0 in indices + assert 1 in indices # remove elements of the first video, to simplify testing indices.remove(0) indices.remove(1) @@ -72,7 +72,7 @@ def test_uniform_clip_sampler(self): with get_list_of_videos(num_videos=3, sizes=[25, 25, 25]) as video_list: video_clips = VideoClips(video_list, 5, 5) sampler = UniformClipSampler(video_clips, 3) - self.assertEqual(len(sampler), 3 * 3) + assert len(sampler) == 3 * 3 indices = torch.tensor(list(iter(sampler))) videos = torch.div(indices, 5, rounding_mode='floor') v_idxs, count = torch.unique(videos, return_counts=True) @@ -84,7 +84,7 @@ def test_uniform_clip_sampler_insufficient_clips(self): with get_list_of_videos(num_videos=3, sizes=[10, 25, 25]) as video_list: video_clips = VideoClips(video_list, 5, 5) sampler = UniformClipSampler(video_clips, 3) - self.assertEqual(len(sampler), 3 * 3) + assert len(sampler) == 3 * 3 indices = torch.tensor(list(iter(sampler))) assert_equal(indices, torch.tensor([0, 0, 1, 2, 4, 6, 7, 9, 11])) @@ -100,7 +100,7 @@ def test_distributed_sampler_and_uniform_clip_sampler(self): group_size=3, ) indices = torch.tensor(list(iter(distributed_sampler_rank0))) - self.assertEqual(len(distributed_sampler_rank0), 6) + assert len(distributed_sampler_rank0) == 6 assert_equal(indices, torch.tensor([0, 2, 4, 10, 12, 14])) distributed_sampler_rank1 = DistributedSampler( @@ -110,9 +110,9 @@ def test_distributed_sampler_and_uniform_clip_sampler(self): group_size=3, ) indices = torch.tensor(list(iter(distributed_sampler_rank1))) - self.assertEqual(len(distributed_sampler_rank1), 6) + assert len(distributed_sampler_rank1) == 6 assert_equal(indices, torch.tensor([5, 7, 9, 0, 2, 4])) if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From 552a4060d0cc90797dbb3a6f255f391574216b3f Mon Sep 17 00:00:00 2001 From: Sugato Ray Date: Fri, 11 Jun 2021 04:31:39 -0400 Subject: [PATCH 182/279] bug-fix to issue #4042 (#4043) * allow single-channel-images in draw_bounding_boxes This is bug-fix for issue #4042. https://github.com/pytorch/vision/issues/4042 * change made for passing linting requirements #4042 --- torchvision/utils.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/torchvision/utils.py b/torchvision/utils.py index ea197d7386e..90657acee4f 100644 --- a/torchvision/utils.py +++ b/torchvision/utils.py @@ -180,6 +180,10 @@ def draw_bounding_boxes( raise ValueError("Pass individual images, not batches") ndarr = image.permute(1, 2, 0).numpy() + # allow single-channel-images + # shape: (1, H, W) with C = 1 + if ndarr.shape[-1] == 1: + ndarr = np.tile(ndarr, (1, 1, 3)) img_to_draw = Image.fromarray(ndarr) img_boxes = boxes.to(torch.int64).tolist() From fb2598b850b2ba396c63839f451924df720bfe6b Mon Sep 17 00:00:00 2001 From: Zhiqiang Wang Date: Fri, 11 Jun 2021 18:03:44 +0800 Subject: [PATCH 183/279] Port test_onnx.py to pytest (#4047) --- .circleci/config.yml | 1 + .circleci/config.yml.in | 1 + test/test_onnx.py | 16 +++++++--------- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 7c79bbcf9e8..a3fc4ad8ac2 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -257,6 +257,7 @@ jobs: pip install --user --progress-bar off --editable . pip install --user onnx pip install --user onnxruntime + pip install --user pytest python test/test_onnx.py binary_linux_wheel: diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 397cb8f9cc9..f2d2e472a58 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -257,6 +257,7 @@ jobs: pip install --user --progress-bar off --editable . pip install --user onnx pip install --user onnxruntime + pip install --user pytest python test/test_onnx.py binary_linux_wheel: diff --git a/test/test_onnx.py b/test/test_onnx.py index d0140c79dfc..c9455fbd86a 100644 --- a/test/test_onnx.py +++ b/test/test_onnx.py @@ -15,21 +15,19 @@ from torchvision.models.detection.image_list import ImageList from torchvision.models.detection.transform import GeneralizedRCNNTransform from torchvision.models.detection.rpn import AnchorGenerator, RPNHead, RegionProposalNetwork -from torchvision.models.detection.backbone_utils import resnet_fpn_backbone from torchvision.models.detection.roi_heads import RoIHeads from torchvision.models.detection.faster_rcnn import FastRCNNPredictor, TwoMLPHead -from torchvision.models.detection.mask_rcnn import MaskRCNNHeads, MaskRCNNPredictor from collections import OrderedDict -import unittest +import pytest from torchvision.ops._register_onnx_ops import _onnx_opset_version -@unittest.skipIf(onnxruntime is None, 'ONNX Runtime unavailable') -class ONNXExporterTester(unittest.TestCase): +@pytest.mark.skipif(onnxruntime is None, reason='ONNX Runtime unavailable') +class TestONNXExporter: @classmethod - def setUpClass(cls): + def setup_class(cls): torch.manual_seed(123) def run_model(self, model, inputs_list, tolerate_small_mismatch=False, do_constant_folding=True, dynamic_axes=None, @@ -80,7 +78,7 @@ def to_numpy(tensor): torch.testing.assert_allclose(outputs[i], ort_outs[i], rtol=1e-03, atol=1e-05) except AssertionError as error: if tolerate_small_mismatch: - self.assertIn("(0.00%)", str(error), str(error)) + assert "(0.00%)" in str(error), str(error) else: raise @@ -161,7 +159,7 @@ def test_roi_align_aligned(self): model = ops.RoIAlign((2, 2), 2.5, -1, aligned=True) self.run_model(model, [(x, single_roi)]) - @unittest.skip # Issue in exporting ROIAlign with aligned = True for malformed boxes + @pytest.mark.skip(reason="Issue in exporting ROIAlign with aligned = True for malformed boxes") def test_roi_align_malformed_boxes(self): x = torch.randn(1, 1, 10, 10, dtype=torch.float32) single_roi = torch.tensor([[0, 2, 0.3, 1.5, 1.5]], dtype=torch.float32) @@ -527,4 +525,4 @@ def test_shufflenet_v2_dynamic_axes(self): if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From 0e7ae64b44de623b8579e14b3b03c57cdc33f518 Mon Sep 17 00:00:00 2001 From: DevPranjal <72960463+DevPranjal@users.noreply.github.com> Date: Fri, 11 Jun 2021 15:43:33 +0530 Subject: [PATCH 184/279] Port tests in test_transforms_video.py to pytest (#4040) --- test/test_transforms_video.py | 59 ++++++++++++++++++----------------- 1 file changed, 30 insertions(+), 29 deletions(-) diff --git a/test/test_transforms_video.py b/test/test_transforms_video.py index 942bb010f71..81b65ef0a6d 100644 --- a/test/test_transforms_video.py +++ b/test/test_transforms_video.py @@ -1,6 +1,6 @@ import torch from torchvision.transforms import Compose -import unittest +import pytest import random import numpy as np import warnings @@ -17,7 +17,7 @@ import torchvision.transforms._transforms_video as transforms -class TestVideoTransforms(unittest.TestCase): +class TestVideoTransforms(): def test_random_crop_video(self): numFrames = random.randint(4, 128) @@ -30,8 +30,8 @@ def test_random_crop_video(self): transforms.ToTensorVideo(), transforms.RandomCropVideo((oheight, owidth)), ])(clip) - self.assertEqual(result.size(2), oheight) - self.assertEqual(result.size(3), owidth) + assert result.size(2) == oheight + assert result.size(3) == owidth transforms.RandomCropVideo((oheight, owidth)).__repr__() @@ -46,8 +46,8 @@ def test_random_resized_crop_video(self): transforms.ToTensorVideo(), transforms.RandomResizedCropVideo((oheight, owidth)), ])(clip) - self.assertEqual(result.size(2), oheight) - self.assertEqual(result.size(3), owidth) + assert result.size(2) == oheight + assert result.size(3) == owidth transforms.RandomResizedCropVideo((oheight, owidth)).__repr__() @@ -70,7 +70,7 @@ def test_center_crop_video(self): msg = "height: " + str(height) + " width: " \ + str(width) + " oheight: " + str(oheight) + " owidth: " + str(owidth) - self.assertEqual(result.sum().item(), 0, msg) + assert result.sum().item() == 0, msg oheight += 1 owidth += 1 @@ -82,7 +82,7 @@ def test_center_crop_video(self): msg = "height: " + str(height) + " width: " \ + str(width) + " oheight: " + str(oheight) + " owidth: " + str(owidth) - self.assertEqual(sum1.item() > 1, True, msg) + assert sum1.item() > 1, msg oheight += 1 owidth += 1 @@ -94,28 +94,29 @@ def test_center_crop_video(self): msg = "height: " + str(height) + " width: " \ + str(width) + " oheight: " + str(oheight) + " owidth: " + str(owidth) - self.assertTrue(sum2.item() > 1, msg) - self.assertTrue(sum2.item() > sum1.item(), msg) + assert sum2.item() > 1, msg + assert sum2.item() > sum1.item(), msg - @unittest.skipIf(stats is None, 'scipy.stats is not available') - def test_normalize_video(self): + @pytest.mark.skipif(stats is None, reason='scipy.stats is not available') + @pytest.mark.parametrize('channels', [1, 3]) + def test_normalize_video(self, channels): def samples_from_standard_normal(tensor): p_value = stats.kstest(list(tensor.view(-1)), 'norm', args=(0, 1)).pvalue return p_value > 0.0001 random_state = random.getstate() random.seed(42) - for channels in [1, 3]: - numFrames = random.randint(4, 128) - height = random.randint(32, 256) - width = random.randint(32, 256) - mean = random.random() - std = random.random() - clip = torch.normal(mean, std, size=(channels, numFrames, height, width)) - mean = [clip[c].mean().item() for c in range(channels)] - std = [clip[c].std().item() for c in range(channels)] - normalized = transforms.NormalizeVideo(mean, std)(clip) - self.assertTrue(samples_from_standard_normal(normalized)) + + numFrames = random.randint(4, 128) + height = random.randint(32, 256) + width = random.randint(32, 256) + mean = random.random() + std = random.random() + clip = torch.normal(mean, std, size=(channels, numFrames, height, width)) + mean = [clip[c].mean().item() for c in range(channels)] + std = [clip[c].std().item() for c in range(channels)] + normalized = transforms.NormalizeVideo(mean, std)(clip) + assert samples_from_standard_normal(normalized) random.setstate(random_state) # Checking the optional in-place behaviour @@ -129,11 +130,11 @@ def test_to_tensor_video(self): numFrames, height, width = 64, 4, 4 trans = transforms.ToTensorVideo() - with self.assertRaises(TypeError): + with pytest.raises(TypeError): trans(np.random.rand(numFrames, height, width, 1).tolist()) trans(torch.rand((numFrames, height, width, 1), dtype=torch.float)) - with self.assertRaises(ValueError): + with pytest.raises(ValueError): trans(torch.ones((3, numFrames, height, width, 3), dtype=torch.uint8)) trans(torch.ones((height, width, 3), dtype=torch.uint8)) trans(torch.ones((width, 3), dtype=torch.uint8)) @@ -141,7 +142,7 @@ def test_to_tensor_video(self): trans.__repr__() - @unittest.skipIf(stats is None, 'scipy.stats not available') + @pytest.mark.skipif(stats is None, reason='scipy.stats not available') def test_random_horizontal_flip_video(self): random_state = random.getstate() random.seed(42) @@ -157,7 +158,7 @@ def test_random_horizontal_flip_video(self): p_value = stats.binom_test(num_horizontal, num_samples, p=0.5) random.setstate(random_state) - self.assertGreater(p_value, 0.0001) + assert p_value > 0.0001 num_samples = 250 num_horizontal = 0 @@ -168,10 +169,10 @@ def test_random_horizontal_flip_video(self): p_value = stats.binom_test(num_horizontal, num_samples, p=0.7) random.setstate(random_state) - self.assertGreater(p_value, 0.0001) + assert p_value > 0.0001 transforms.RandomHorizontalFlipVideo().__repr__() if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From e4eded485ca7324ed27ba87c03e02973d8a46443 Mon Sep 17 00:00:00 2001 From: Vivek Kumar <60113444+vivekkumar7089@users.noreply.github.com> Date: Fri, 11 Jun 2021 15:49:36 +0530 Subject: [PATCH 185/279] Port test_models_detection_anchor_utils.py to pytest (#4046) --- test/test_models_detection_anchor_utils.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/test/test_models_detection_anchor_utils.py b/test/test_models_detection_anchor_utils.py index 13c399a0c32..c918d3fc8df 100644 --- a/test/test_models_detection_anchor_utils.py +++ b/test/test_models_detection_anchor_utils.py @@ -3,6 +3,7 @@ from _assert_utils import assert_equal from torchvision.models.detection.anchor_utils import AnchorGenerator, DefaultBoxGenerator from torchvision.models.detection.image_list import ImageList +import pytest class Tester(TestCase): @@ -13,7 +14,7 @@ def test_incorrect_anchors(self): image1 = torch.randn(3, 800, 800) image_list = ImageList(image1, [(800, 800)]) feature_maps = [torch.randn(1, 50)] - self.assertRaises(ValueError, anc, image_list, feature_maps) + pytest.raises(ValueError, anc, image_list, feature_maps) def _init_test_anchor_generator(self): anchor_sizes = ((10,),) @@ -59,10 +60,10 @@ def test_anchor_generator(self): [0., 5., 10., 15.], [5., 5., 15., 15.]]) - self.assertEqual(num_anchors_estimated, 9) - self.assertEqual(len(anchors), 2) - self.assertEqual(tuple(anchors[0].shape), (9, 4)) - self.assertEqual(tuple(anchors[1].shape), (9, 4)) + assert num_anchors_estimated == 9 + assert len(anchors) == 2 + assert tuple(anchors[0].shape) == (9, 4) + assert tuple(anchors[1].shape) == (9, 4) assert_equal(anchors[0], anchors_output) assert_equal(anchors[1], anchors_output) @@ -83,8 +84,8 @@ def test_defaultbox_generator(self): [6.7045, 5.9090, 8.2955, 9.0910] ]) - self.assertEqual(len(dboxes), 2) - self.assertEqual(tuple(dboxes[0].shape), (4, 4)) - self.assertEqual(tuple(dboxes[1].shape), (4, 4)) + assert len(dboxes) == 2 + assert tuple(dboxes[0].shape) == (4, 4) + assert tuple(dboxes[1].shape) == (4, 4) torch.testing.assert_close(dboxes[0], dboxes_output, rtol=1e-5, atol=1e-8) torch.testing.assert_close(dboxes[1], dboxes_output, rtol=1e-5, atol=1e-8) From 7dc8a690e8f4a975b8114779df6cd345dd4eec94 Mon Sep 17 00:00:00 2001 From: Zhiqiang Wang Date: Fri, 11 Jun 2021 18:22:24 +0800 Subject: [PATCH 186/279] Port test_models_detection_negative_samples.py to pytest (#4045) --- .../test_models_detection_negative_samples.py | 72 ++++++++++--------- 1 file changed, 38 insertions(+), 34 deletions(-) diff --git a/test/test_models_detection_negative_samples.py b/test/test_models_detection_negative_samples.py index 83ccc58ade5..51749011dd4 100644 --- a/test/test_models_detection_negative_samples.py +++ b/test/test_models_detection_negative_samples.py @@ -6,10 +6,11 @@ from torchvision.models.detection.roi_heads import RoIHeads from torchvision.models.detection.faster_rcnn import FastRCNNPredictor, TwoMLPHead -import unittest +import pytest +from _assert_utils import assert_equal -class Tester(unittest.TestCase): +class TestModelsDetectionNegativeSamples: def _make_empty_sample(self, add_masks=False, add_keypoints=False): images = [torch.rand((3, 100, 100), dtype=torch.float32)] @@ -48,13 +49,13 @@ def test_targets_to_anchors(self): labels, matched_gt_boxes = head.assign_targets_to_anchors(anchors, targets) - self.assertEqual(labels[0].sum(), 0) - self.assertEqual(labels[0].shape, torch.Size([anchors[0].shape[0]])) - self.assertEqual(labels[0].dtype, torch.float32) + assert labels[0].sum() == 0 + assert labels[0].shape == torch.Size([anchors[0].shape[0]]) + assert labels[0].dtype == torch.float32 - self.assertEqual(matched_gt_boxes[0].sum(), 0) - self.assertEqual(matched_gt_boxes[0].shape, anchors[0].shape) - self.assertEqual(matched_gt_boxes[0].dtype, torch.float32) + assert matched_gt_boxes[0].sum() == 0 + assert matched_gt_boxes[0].shape == anchors[0].shape + assert matched_gt_boxes[0].dtype == torch.float32 def test_assign_targets_to_proposals(self): @@ -88,25 +89,28 @@ def test_assign_targets_to_proposals(self): matched_idxs, labels = roi_heads.assign_targets_to_proposals(proposals, gt_boxes, gt_labels) - self.assertEqual(matched_idxs[0].sum(), 0) - self.assertEqual(matched_idxs[0].shape, torch.Size([proposals[0].shape[0]])) - self.assertEqual(matched_idxs[0].dtype, torch.int64) - - self.assertEqual(labels[0].sum(), 0) - self.assertEqual(labels[0].shape, torch.Size([proposals[0].shape[0]])) - self.assertEqual(labels[0].dtype, torch.int64) - - def test_forward_negative_sample_frcnn(self): - for name in ["fasterrcnn_resnet50_fpn", "fasterrcnn_mobilenet_v3_large_fpn", - "fasterrcnn_mobilenet_v3_large_320_fpn"]: - model = torchvision.models.detection.__dict__[name]( - num_classes=2, min_size=100, max_size=100) + assert matched_idxs[0].sum() == 0 + assert matched_idxs[0].shape == torch.Size([proposals[0].shape[0]]) + assert matched_idxs[0].dtype == torch.int64 + + assert labels[0].sum() == 0 + assert labels[0].shape == torch.Size([proposals[0].shape[0]]) + assert labels[0].dtype == torch.int64 + + @pytest.mark.parametrize('name', [ + "fasterrcnn_resnet50_fpn", + "fasterrcnn_mobilenet_v3_large_fpn", + "fasterrcnn_mobilenet_v3_large_320_fpn", + ]) + def test_forward_negative_sample_frcnn(self, name): + model = torchvision.models.detection.__dict__[name]( + num_classes=2, min_size=100, max_size=100) - images, targets = self._make_empty_sample() - loss_dict = model(images, targets) + images, targets = self._make_empty_sample() + loss_dict = model(images, targets) - self.assertEqual(loss_dict["loss_box_reg"], torch.tensor(0.)) - self.assertEqual(loss_dict["loss_rpn_box_reg"], torch.tensor(0.)) + assert_equal(loss_dict["loss_box_reg"], torch.tensor(0.)) + assert_equal(loss_dict["loss_rpn_box_reg"], torch.tensor(0.)) def test_forward_negative_sample_mrcnn(self): model = torchvision.models.detection.maskrcnn_resnet50_fpn( @@ -115,9 +119,9 @@ def test_forward_negative_sample_mrcnn(self): images, targets = self._make_empty_sample(add_masks=True) loss_dict = model(images, targets) - self.assertEqual(loss_dict["loss_box_reg"], torch.tensor(0.)) - self.assertEqual(loss_dict["loss_rpn_box_reg"], torch.tensor(0.)) - self.assertEqual(loss_dict["loss_mask"], torch.tensor(0.)) + assert_equal(loss_dict["loss_box_reg"], torch.tensor(0.)) + assert_equal(loss_dict["loss_rpn_box_reg"], torch.tensor(0.)) + assert_equal(loss_dict["loss_mask"], torch.tensor(0.)) def test_forward_negative_sample_krcnn(self): model = torchvision.models.detection.keypointrcnn_resnet50_fpn( @@ -126,9 +130,9 @@ def test_forward_negative_sample_krcnn(self): images, targets = self._make_empty_sample(add_keypoints=True) loss_dict = model(images, targets) - self.assertEqual(loss_dict["loss_box_reg"], torch.tensor(0.)) - self.assertEqual(loss_dict["loss_rpn_box_reg"], torch.tensor(0.)) - self.assertEqual(loss_dict["loss_keypoint"], torch.tensor(0.)) + assert_equal(loss_dict["loss_box_reg"], torch.tensor(0.)) + assert_equal(loss_dict["loss_rpn_box_reg"], torch.tensor(0.)) + assert_equal(loss_dict["loss_keypoint"], torch.tensor(0.)) def test_forward_negative_sample_retinanet(self): model = torchvision.models.detection.retinanet_resnet50_fpn( @@ -137,7 +141,7 @@ def test_forward_negative_sample_retinanet(self): images, targets = self._make_empty_sample() loss_dict = model(images, targets) - self.assertEqual(loss_dict["bbox_regression"], torch.tensor(0.)) + assert_equal(loss_dict["bbox_regression"], torch.tensor(0.)) def test_forward_negative_sample_ssd(self): model = torchvision.models.detection.ssd300_vgg16( @@ -146,8 +150,8 @@ def test_forward_negative_sample_ssd(self): images, targets = self._make_empty_sample() loss_dict = model(images, targets) - self.assertEqual(loss_dict["bbox_regression"], torch.tensor(0.)) + assert_equal(loss_dict["bbox_regression"], torch.tensor(0.)) if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From 26d6080f8be7214b801761e5aaeca31292e8ce3f Mon Sep 17 00:00:00 2001 From: Matti Picus Date: Fri, 11 Jun 2021 17:16:58 +0300 Subject: [PATCH 187/279] add filter for binary_linux_wheel_py3.7_cpu (#3998) * add filter for binary_linux_wheel_py3.7_cpu fixes issue #3997 * add tag,nightly filter to build_docs * flake8 formatting * fixes from review --- .circleci/config.yml | 11 +++++++++++ .circleci/regenerate.py | 11 +++++++++-- 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index a3fc4ad8ac2..a091e02ff6f 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1026,6 +1026,11 @@ workflows: - binary_linux_wheel: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu + filters: + branches: + only: '*' + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_linux_wheel_py3.7_cpu python_version: '3.7' wheel_docker_image: pytorch/manylinux-cuda102 @@ -1424,6 +1429,12 @@ workflows: name: binary_win_conda_py3.9_cu111 python_version: '3.9' - build_docs: + filters: + branches: + only: + - nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: build_docs python_version: '3.7' requires: diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py index db6b44c089a..e0809de7a50 100755 --- a/.circleci/regenerate.py +++ b/.circleci/regenerate.py @@ -45,13 +45,19 @@ def build_workflows(prefix='', filter_branch=None, upload=False, indentation=6, (python_version != python_versions[-1] or (cu_version not in [cu_versions[0], cu_versions[-1]])): fb = "master" + if not fb and (os_type == 'linux' and + cu_version == 'cpu' and + btype == 'wheel' and + python_version == '3.7'): + # the fields must match the build_docs "requires" dependency + fb = "*" w += workflow_pair( btype, os_type, python_version, cu_version, unicode, prefix, upload, filter_branch=fb) if not filter_branch: # Build on every pull request, but upload only on nightly and tags - w += build_doc_job(None) + w += build_doc_job('nightly') w += upload_doc_job('nightly') return indent(indentation, w) @@ -83,7 +89,8 @@ def build_doc_job(filter_branch): } if filter_branch: - job["filters"] = gen_filter_branch_tree(filter_branch) + job["filters"] = gen_filter_branch_tree(filter_branch, + tags_list=RC_PATTERN) return [{"build_docs": job}] From 3161841da9c522f50379a3660ac42f983430879b Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 11 Jun 2021 15:17:54 +0100 Subject: [PATCH 188/279] Better handling of grayscale images in draw bbox (#4049) * Adding a test for grayscale images. * Doing the ops in torch, adding more checks. --- test/test_utils.py | 9 +++++++++ torchvision/utils.py | 9 +++++---- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/test/test_utils.py b/test/test_utils.py index 3fed2535c77..d850859d3aa 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -131,6 +131,13 @@ def test_draw_boxes_vanilla(): assert_equal(img, img_cp) +def test_draw_boxes_grayscale(): + img = torch.full((1, 4, 4), fill_value=255, dtype=torch.uint8) + boxes = torch.tensor([[0, 0, 3, 3]], dtype=torch.int64) + bboxed_img = utils.draw_bounding_boxes(image=img, boxes=boxes, colors=["#1BBC9B"]) + assert bboxed_img.size(0) == 3 + + def test_draw_invalid_boxes(): img_tp = ((1, 1, 1), (1, 2, 3)) img_wrong1 = torch.full((3, 5, 5), 255, dtype=torch.float) @@ -143,6 +150,8 @@ def test_draw_invalid_boxes(): utils.draw_bounding_boxes(img_wrong1, boxes) with pytest.raises(ValueError, match="Pass individual images, not batches"): utils.draw_bounding_boxes(img_wrong2, boxes) + with pytest.raises(ValueError, match="Only grayscale and RGB images are supported"): + utils.draw_bounding_boxes(img_wrong2[0][:2], boxes) @pytest.mark.parametrize('colors', [ diff --git a/torchvision/utils.py b/torchvision/utils.py index 90657acee4f..72be25403a8 100644 --- a/torchvision/utils.py +++ b/torchvision/utils.py @@ -178,12 +178,13 @@ def draw_bounding_boxes( raise ValueError(f"Tensor uint8 expected, got {image.dtype}") elif image.dim() != 3: raise ValueError("Pass individual images, not batches") + elif image.size(0) not in {1, 3}: + raise ValueError("Only grayscale and RGB images are supported") + + if image.size(0) == 1: + image = torch.tile(image, (3, 1, 1)) ndarr = image.permute(1, 2, 0).numpy() - # allow single-channel-images - # shape: (1, H, W) with C = 1 - if ndarr.shape[-1] == 1: - ndarr = np.tile(ndarr, (1, 1, 3)) img_to_draw = Image.fromarray(ndarr) img_boxes = boxes.to(torch.int64).tolist() From 9766f23cb478e6ebeacb4fc46324fde04f8034b0 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Fri, 11 Jun 2021 17:24:18 +0100 Subject: [PATCH 189/279] Removed test_audio_video_sync as it doesn't work as expected (#4050) --- test/test_video_reader.py | 39 --------------------------------------- 1 file changed, 39 deletions(-) diff --git a/test/test_video_reader.py b/test/test_video_reader.py index e13aeb537f2..e9a1adedb83 100644 --- a/test/test_video_reader.py +++ b/test/test_video_reader.py @@ -1235,45 +1235,6 @@ def test_read_video_from_memory_scripted(self): ) # FUTURE: check value of video / audio frames - def test_audio_video_sync(self): - """Test if audio/video are synchronised with pyav output.""" - for test_video, config in test_videos.items(): - full_path = os.path.join(VIDEO_DIR, test_video) - container = av.open(full_path) - if not container.streams.audio: - # Skip if no audio stream - continue - start_pts_val, cutoff = 0, 1 - if container.streams.video: - video = container.streams.video[0] - arr = [] - for index, frame in enumerate(container.decode(video)): - if index == cutoff: - start_pts_val = frame.pts - if index >= cutoff: - arr.append(frame.to_rgb().to_ndarray()) - visual, _, info = io.read_video(full_path, start_pts=start_pts_val, pts_unit='pts') - self.assertAlmostEqual( - config.video_fps, info['video_fps'], delta=0.0001 - ) - arr = torch.Tensor(arr) - if arr.shape == visual.shape: - self.assertGreaterEqual( - torch.mean(torch.isclose(visual.float(), arr, atol=1e-5).float()), 0.99) - - container = av.open(full_path) - if container.streams.audio: - audio = container.streams.audio[0] - arr = [] - for index, frame in enumerate(container.decode(audio)): - if index >= cutoff: - arr.append(frame.to_ndarray()) - _, audio, _ = io.read_video(full_path, start_pts=start_pts_val, pts_unit='pts') - arr = torch.as_tensor(np.concatenate(arr, axis=1)) - if arr.shape == audio.shape: - self.assertGreaterEqual( - torch.mean(torch.isclose(audio.float(), arr).float()), 0.99) - def test_invalid_file(self): set_video_backend('video_reader') with self.assertRaises(RuntimeError): From cd181889d72ebab77f6657055bd415c2db63fa31 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Sat, 12 Jun 2021 00:18:13 +0100 Subject: [PATCH 190/279] Added warning message for unsupported ffmpeg version (#4041) * Added warning message for unsupported ffmpeg version * Replaced os.popen with subprocess.run * Removed capture_true argument --- setup.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/setup.py b/setup.py index 0b9a5d4ac11..8293a166eb8 100644 --- a/setup.py +++ b/setup.py @@ -6,6 +6,7 @@ import subprocess import distutils.command.clean import distutils.spawn +from distutils.version import StrictVersion import glob import shutil @@ -346,6 +347,19 @@ def get_extensions(): ffmpeg_exe = distutils.spawn.find_executable('ffmpeg') has_ffmpeg = ffmpeg_exe is not None + if has_ffmpeg: + try: + ffmpeg_version = subprocess.run( + 'ffmpeg -version | head -n1', shell=True, + stdout=subprocess.PIPE).stdout.decode('utf-8') + ffmpeg_version = ffmpeg_version.split('version')[-1].split()[0] + if StrictVersion(ffmpeg_version) >= StrictVersion('4.3'): + print(f'ffmpeg {ffmpeg_version} not supported yet, please use ffmpeg 4.2.') + has_ffmpeg = False + except (IndexError, ValueError): + print('Error fetching ffmpeg version, ignoring ffmpeg.') + has_ffmpeg = False + print("FFmpeg found: {}".format(has_ffmpeg)) if has_ffmpeg: From 508b289c6eb55a47095116a854055b261ecf6e8a Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 14 Jun 2021 13:36:11 +0100 Subject: [PATCH 191/279] Better logic for ignoring CPU tests on GPU CI machines (#4025) --- test/common_utils.py | 50 ++-------------------------------- test/conftest.py | 50 ++++++++++++++++++++++++++++++---- test/test_image.py | 36 ++++++++---------------- test/test_models.py | 11 +------- test/test_ops.py | 18 +----------- test/test_transforms_tensor.py | 5 ---- 6 files changed, 59 insertions(+), 111 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index a7534f7d3ed..06e0e16b1ef 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -259,58 +259,12 @@ def call_args_to_kwargs_only(call_args, *callable_or_arg_names): def cpu_and_gpu(): import pytest # noqa - - # ignore CPU tests in RE as they're already covered by another contbuild - # also ignore CPU tests in CircleCI machines that have a GPU: these tests - # are run on CPU-only machines already. - if IN_RE_WORKER: - devices = [] - else: - if IN_CIRCLE_CI and torch.cuda.is_available(): - mark = pytest.mark.skip(reason=CIRCLECI_GPU_NO_CUDA_MSG) - else: - mark = () - devices = [pytest.param('cpu', marks=mark)] - - if torch.cuda.is_available(): - cuda_marks = () - elif IN_FBCODE: - # Dont collect cuda tests on fbcode if the machine doesnt have a GPU - # This avoids skipping the tests. More robust would be to detect if - # we're in sancastle instead of fbcode? - cuda_marks = pytest.mark.dont_collect() - else: - cuda_marks = pytest.mark.skip(reason=CUDA_NOT_AVAILABLE_MSG) - - devices.append(pytest.param('cuda', marks=cuda_marks)) - - return devices + return ('cpu', pytest.param('cuda', marks=pytest.mark.needs_cuda)) def needs_cuda(test_func): import pytest # noqa - - if IN_FBCODE and not IN_RE_WORKER: - # We don't want to skip in fbcode, so we just don't collect - # TODO: slightly more robust way would be to detect if we're in a sandcastle instance - # so that the test will still be collected (and skipped) in the devvms. - return pytest.mark.dont_collect(test_func) - elif torch.cuda.is_available(): - return test_func - else: - return pytest.mark.skip(reason=CUDA_NOT_AVAILABLE_MSG)(test_func) - - -def cpu_only(test_func): - import pytest # noqa - - if IN_RE_WORKER: - # The assumption is that all RE workers have GPUs. - return pytest.mark.dont_collect(test_func) - elif IN_CIRCLE_CI and torch.cuda.is_available(): - return pytest.mark.skip(reason=CIRCLECI_GPU_NO_CUDA_MSG)(test_func) - else: - return test_func + return pytest.mark.needs_cuda(test_func) def _create_data(height=3, width=3, channels=3, device="cpu"): diff --git a/test/conftest.py b/test/conftest.py index 6e10e4ef071..ab60cb5fa41 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -1,14 +1,52 @@ +from common_utils import IN_CIRCLE_CI, CIRCLECI_GPU_NO_CUDA_MSG, IN_FBCODE, IN_RE_WORKER, CUDA_NOT_AVAILABLE_MSG +import torch +import pytest + + def pytest_configure(config): # register an additional marker (see pytest_collection_modifyitems) config.addinivalue_line( - "markers", "dont_collect: marks a test that should not be collected (avoids skipping it)" + "markers", "needs_cuda: mark for tests that rely on a CUDA device" ) def pytest_collection_modifyitems(items): # This hook is called by pytest after it has collected the tests (google its name!) - # We can ignore some tests as we see fit here. In particular we ignore the tests that - # we have marked with the custom 'dont_collect' mark. This avoids skipping the tests, - # since the internal fb infra doesn't like skipping tests. - to_keep = [item for item in items if item.get_closest_marker('dont_collect') is None] - items[:] = to_keep + # We can ignore some tests as we see fit here, or add marks, such as a skip mark. + + out_items = [] + for item in items: + # The needs_cuda mark will exist if the test was explicitely decorated with + # the @needs_cuda decorator. It will also exist if it was parametrized with a + # parameter that has the mark: for example if a test is parametrized with + # @pytest.mark.parametrize('device', cpu_and_gpu()) + # the "instances" of the tests where device == 'cuda' will have the 'needs_cuda' mark, + # and the ones with device == 'cpu' won't have the mark. + needs_cuda = item.get_closest_marker('needs_cuda') is not None + + if needs_cuda and not torch.cuda.is_available(): + # In general, we skip cuda tests on machines without a GPU + # There are special cases though, see below + item.add_marker(pytest.mark.skip(reason=CUDA_NOT_AVAILABLE_MSG)) + + if IN_FBCODE: + # fbcode doesn't like skipping tests, so instead we just don't collect the test + # so that they don't even "exist", hence the continue statements. + if not needs_cuda and IN_RE_WORKER: + # The RE workers are the machines with GPU, we don't want them to run CPU-only tests. + continue + if needs_cuda and not torch.cuda.is_available(): + # On the test machines without a GPU, we want to ignore the tests that need cuda. + # TODO: something more robust would be to do that only in a sandcastle instance, + # so that we can still see the test being skipped when testing locally from a devvm + continue + elif IN_CIRCLE_CI: + # Here we're not in fbcode, so we can safely collect and skip tests. + if not needs_cuda and torch.cuda.is_available(): + # Similar to what happens in RE workers: we don't need the CircleCI GPU machines + # to run the CPU-only tests. + item.add_marker(pytest.mark.skip(reason=CIRCLECI_GPU_NO_CUDA_MSG)) + + out_items.append(item) + + items[:] = out_items diff --git a/test/test_image.py b/test/test_image.py index e5aeef0dc37..d9162760263 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -9,7 +9,7 @@ import torch from PIL import Image import torchvision.transforms.functional as F -from common_utils import get_tmp_dir, needs_cuda, cpu_only +from common_utils import get_tmp_dir, needs_cuda from _assert_utils import assert_equal from torchvision.io.image import ( @@ -335,7 +335,6 @@ def test_decode_jpeg_cuda_errors(): torch.ops.image.decode_jpeg_cuda(data, ImageReadMode.UNCHANGED.value, 'cpu') -@cpu_only def test_encode_jpeg_errors(): with pytest.raises(RuntimeError, match="Input tensor dtype should be uint8"): @@ -359,26 +358,13 @@ def test_encode_jpeg_errors(): encode_jpeg(torch.empty((100, 100), dtype=torch.uint8)) -def _collect_if(cond): - # TODO: remove this once test_encode_jpeg_windows and test_write_jpeg_windows - # are removed - def _inner(test_func): - if cond: - return test_func - else: - return pytest.mark.dont_collect(test_func) - return _inner - - -@cpu_only -@_collect_if(cond=IS_WINDOWS) @pytest.mark.parametrize('img_path', [ pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) for jpeg_path in get_images(ENCODE_JPEG, ".jpg") ]) -def test_encode_jpeg_windows(img_path): +def test_encode_jpeg_reference(img_path): # This test is *wrong*. - # It compares a torchvision-encoded jpeg with a PIL-encoded jpeg, but it + # It compares a torchvision-encoded jpeg with a PIL-encoded jpeg (the reference), but it # starts encoding the torchvision version from an image that comes from # decode_jpeg, which can yield different results from pil.decode (see # test_decode... which uses a high tolerance). @@ -403,14 +389,12 @@ def test_encode_jpeg_windows(img_path): assert_equal(jpeg_bytes, pil_bytes) -@cpu_only -@_collect_if(cond=IS_WINDOWS) @pytest.mark.parametrize('img_path', [ pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) for jpeg_path in get_images(ENCODE_JPEG, ".jpg") ]) -def test_write_jpeg_windows(img_path): - # FIXME: Remove this eventually, see test_encode_jpeg_windows +def test_write_jpeg_reference(img_path): + # FIXME: Remove this eventually, see test_encode_jpeg_reference with get_tmp_dir() as d: data = read_file(img_path) img = decode_jpeg(data) @@ -433,8 +417,9 @@ def test_write_jpeg_windows(img_path): assert_equal(torch_bytes, pil_bytes) -@cpu_only -@_collect_if(cond=not IS_WINDOWS) +@pytest.mark.skipif(IS_WINDOWS, reason=( + 'this test fails on windows because PIL uses libjpeg-turbo on windows' +)) @pytest.mark.parametrize('img_path', [ pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) for jpeg_path in get_images(ENCODE_JPEG, ".jpg") @@ -455,8 +440,9 @@ def test_encode_jpeg(img_path): assert_equal(encoded_jpeg_torch, encoded_jpeg_pil) -@cpu_only -@_collect_if(cond=not IS_WINDOWS) +@pytest.mark.skipif(IS_WINDOWS, reason=( + 'this test fails on windows because PIL uses libjpeg-turbo on windows' +)) @pytest.mark.parametrize('img_path', [ pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) for jpeg_path in get_images(ENCODE_JPEG, ".jpg") diff --git a/test/test_models.py b/test/test_models.py index b52b7ecc690..a3c7ec40342 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -1,7 +1,7 @@ import os import io import sys -from common_utils import map_nested_tensor_object, freeze_rng_state, set_rng_seed, cpu_and_gpu, needs_cuda, cpu_only +from common_utils import map_nested_tensor_object, freeze_rng_state, set_rng_seed, cpu_and_gpu, needs_cuda from _utils_internal import get_relative_path from collections import OrderedDict import functools @@ -234,7 +234,6 @@ def _make_sliced_model(model, stop_layer): return new_model -@cpu_only @pytest.mark.parametrize('model_name', ['densenet121', 'densenet169', 'densenet201', 'densenet161']) def test_memory_efficient_densenet(model_name): input_shape = (1, 3, 300, 300) @@ -257,7 +256,6 @@ def test_memory_efficient_densenet(model_name): torch.testing.assert_close(out1, out2, rtol=0.0, atol=1e-5) -@cpu_only @pytest.mark.parametrize('dilate_layer_2', (True, False)) @pytest.mark.parametrize('dilate_layer_3', (True, False)) @pytest.mark.parametrize('dilate_layer_4', (True, False)) @@ -272,7 +270,6 @@ def test_resnet_dilation(dilate_layer_2, dilate_layer_3, dilate_layer_4): assert out.shape == (1, 2048, 7 * f, 7 * f) -@cpu_only def test_mobilenet_v2_residual_setting(): model = models.__dict__["mobilenet_v2"](inverted_residual_setting=[[1, 16, 1, 1], [6, 24, 2, 2]]) model.eval() @@ -281,7 +278,6 @@ def test_mobilenet_v2_residual_setting(): assert out.shape[-1] == 1000 -@cpu_only @pytest.mark.parametrize('model_name', ["mobilenet_v2", "mobilenet_v3_large", "mobilenet_v3_small"]) def test_mobilenet_norm_layer(model_name): model = models.__dict__[model_name]() @@ -295,7 +291,6 @@ def get_gn(num_channels): assert any(isinstance(x, nn.GroupNorm) for x in model.modules()) -@cpu_only def test_inception_v3_eval(): # replacement for models.inception_v3(pretrained=True) that does not download weights kwargs = {} @@ -311,7 +306,6 @@ def test_inception_v3_eval(): _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(name, None)) -@cpu_only def test_fasterrcnn_double(): model = models.detection.fasterrcnn_resnet50_fpn(num_classes=50, pretrained_backbone=False) model.double() @@ -327,7 +321,6 @@ def test_fasterrcnn_double(): assert "labels" in out[0] -@cpu_only def test_googlenet_eval(): # replacement for models.googlenet(pretrained=True) that does not download weights kwargs = {} @@ -376,7 +369,6 @@ def checkOut(out): checkOut(out_cpu) -@cpu_only def test_generalizedrcnn_transform_repr(): min_size, max_size = 224, 299 @@ -573,7 +565,6 @@ def compute_mean_std(tensor): pytest.skip(msg) -@cpu_only @pytest.mark.parametrize('model_name', get_available_detection_models()) def test_detection_model_validation(model_name): set_rng_seed(0) diff --git a/test/test_ops.py b/test/test_ops.py index f08720206ad..21b0c2039c3 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -1,4 +1,4 @@ -from common_utils import needs_cuda, cpu_only, cpu_and_gpu +from common_utils import needs_cuda, cpu_and_gpu from _assert_utils import assert_equal import math from abc import ABC, abstractmethod @@ -133,7 +133,6 @@ def get_slice(k, block): y[roi_idx, :, i, j] = bin_x.reshape(n_channels, -1).max(dim=1)[0] return y - @cpu_only def test_boxes_shape(self): self._helper_boxes_shape(ops.roi_pool) @@ -178,7 +177,6 @@ def get_slice(k, block): y[roi_idx, c_out, i, j] = t / area return y - @cpu_only def test_boxes_shape(self): self._helper_boxes_shape(ops.ps_roi_pool) @@ -262,7 +260,6 @@ def expected_fn(self, in_data, rois, pool_h, pool_w, spatial_scale=1, sampling_r out_data[r, channel, i, j] = val return out_data - @cpu_only def test_boxes_shape(self): self._helper_boxes_shape(ops.roi_align) @@ -403,12 +400,10 @@ def expected_fn(self, in_data, rois, pool_h, pool_w, device, spatial_scale=1, out_data[r, c_out, i, j] = val return out_data - @cpu_only def test_boxes_shape(self): self._helper_boxes_shape(ops.ps_roi_align) -@cpu_only class TestMultiScaleRoIAlign: def test_msroialign_repr(self): fmap_names = ['0'] @@ -464,7 +459,6 @@ def _create_tensors_with_iou(self, N, iou_thresh): scores = torch.rand(N) return boxes, scores - @cpu_only @pytest.mark.parametrize("iou", (.2, .5, .8)) def test_nms_ref(self, iou): err_msg = 'NMS incompatible between CPU and reference implementation for IoU={}' @@ -473,7 +467,6 @@ def test_nms_ref(self, iou): keep = ops.nms(boxes, scores, iou) assert torch.allclose(keep, keep_ref), err_msg.format(iou) - @cpu_only def test_nms_input_errors(self): with pytest.raises(RuntimeError): ops.nms(torch.rand(4), torch.rand(3), 0.5) @@ -484,7 +477,6 @@ def test_nms_input_errors(self): with pytest.raises(RuntimeError): ops.nms(torch.rand(3, 4), torch.rand(4), 0.5) - @cpu_only @pytest.mark.parametrize("iou", (.2, .5, .8)) @pytest.mark.parametrize("scale, zero_point", ((1, 0), (2, 50), (3, 10))) def test_qnms(self, iou, scale, zero_point): @@ -542,7 +534,6 @@ def test_nms_cuda_float16(self): keep16 = ops.nms(boxes.to(torch.float16), scores.to(torch.float16), iou_thres) assert_equal(keep32, keep16) - @cpu_only def test_batched_nms_implementations(self): """Make sure that both implementations of batched_nms yield identical results""" @@ -689,7 +680,6 @@ def test_forward(self, device, contiguous, batch_sz, dtype=None): res.to(expected), expected, rtol=tol, atol=tol, msg='\nres:\n{}\nexpected:\n{}'.format(res, expected) ) - @cpu_only def test_wrong_sizes(self): in_channels = 6 out_channels = 2 @@ -786,7 +776,6 @@ def test_autocast(self, batch_sz, dtype): self.test_forward(torch.device("cuda"), contiguous=False, batch_sz=batch_sz, dtype=dtype) -@cpu_only class TestFrozenBNT: def test_frozenbatchnorm2d_repr(self): num_features = 32 @@ -828,7 +817,6 @@ def test_frozenbatchnorm2d_n_arg(self): ops.misc.FrozenBatchNorm2d(32, eps=1e-5, n=32) -@cpu_only class TestBoxConversion: def _get_box_sequences(): # Define here the argument type of `boxes` supported by region pooling operations @@ -853,7 +841,6 @@ def test_convert_boxes_to_roi_format(self, box_sequence): assert_equal(ref_tensor, ops._utils.convert_boxes_to_roi_format(box_sequence)) -@cpu_only class TestBox: def test_bbox_same(self): box_tensor = torch.tensor([[0, 0, 100, 100], [0, 0, 0, 0], @@ -940,7 +927,6 @@ def test_bbox_convert_jit(self): torch.testing.assert_close(scripted_cxcywh, box_cxcywh, rtol=0.0, atol=TOLERANCE) -@cpu_only class TestBoxArea: def test_box_area(self): def area_check(box, expected, tolerance=1e-4): @@ -969,7 +955,6 @@ def area_check(box, expected, tolerance=1e-4): area_check(box_tensor, expected) -@cpu_only class TestBoxIou: def test_iou(self): def iou_check(box, expected, tolerance=1e-4): @@ -991,7 +976,6 @@ def iou_check(box, expected, tolerance=1e-4): iou_check(box_tensor, expected, tolerance=0.002 if dtype == torch.float16 else 1e-4) -@cpu_only class TestGenBoxIou: def test_gen_iou(self): def gen_iou_check(box, expected, tolerance=1e-4): diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 1a4ecfbf7c7..2051cc7466c 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -18,7 +18,6 @@ _assert_equal_tensor_to_pil, _assert_approx_equal_tensor_to_pil, cpu_and_gpu, - cpu_only ) from _assert_utils import assert_equal @@ -309,7 +308,6 @@ def test_x_crop(fn, method, out_length, size, device): assert_equal(transformed_img, transformed_batch[i, ...]) -@cpu_only @pytest.mark.parametrize('method', ["FiveCrop", "TenCrop"]) def test_x_crop_save(method): fn = getattr(T, method)(size=[5, ]) @@ -319,7 +317,6 @@ def test_x_crop_save(method): class TestResize: - @cpu_only @pytest.mark.parametrize('size', [32, 34, 35, 36, 38]) def test_resize_int(self, size): # TODO: Minimal check for bug-fix, improve this later @@ -352,7 +349,6 @@ def test_resize_scripted(self, dt, size, max_size, interpolation, device): _test_transform_vs_scripted(transform, s_transform, tensor) _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - @cpu_only def test_resize_save(self): transform = T.Resize(size=[32, ]) s_transform = torch.jit.script(transform) @@ -372,7 +368,6 @@ def test_resized_crop(self, scale, ratio, size, interpolation, device): _test_transform_vs_scripted(transform, s_transform, tensor) _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - @cpu_only def test_resized_crop_save(self): transform = T.RandomResizedCrop(size=[32, ]) s_transform = torch.jit.script(transform) From 2786a1241fec593dcef2e6df297216f8a3d64812 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 14 Jun 2021 13:46:48 +0100 Subject: [PATCH 192/279] Port test_internet.py to pytest and add pytest-mock dependency (#4032) --- .../unittest/linux/scripts/environment.yml | 1 + .../unittest/windows/scripts/environment.yml | 1 + CONTRIBUTING.md | 2 +- test/test_internet.py | 31 +++++++++---------- 4 files changed, 18 insertions(+), 17 deletions(-) diff --git a/.circleci/unittest/linux/scripts/environment.yml b/.circleci/unittest/linux/scripts/environment.yml index fcf61a6e2f8..c0d36f95a43 100644 --- a/.circleci/unittest/linux/scripts/environment.yml +++ b/.circleci/unittest/linux/scripts/environment.yml @@ -6,6 +6,7 @@ channels: dependencies: - pytest - pytest-cov + - pytest-mock - pip - libpng # NOTE: Pinned to fix issues with size_t on Windows diff --git a/.circleci/unittest/windows/scripts/environment.yml b/.circleci/unittest/windows/scripts/environment.yml index 9a916a27d07..11de8e089e8 100644 --- a/.circleci/unittest/windows/scripts/environment.yml +++ b/.circleci/unittest/windows/scripts/environment.yml @@ -6,6 +6,7 @@ channels: dependencies: - pytest - pytest-cov + - pytest-mock - pip - libpng # NOTE: Pinned to fix issues with size_t on Windows diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 748dc50df9e..3fa41efec26 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -49,7 +49,7 @@ python setup.py develop # MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ python setup.py develop # for C++ debugging, please use DEBUG=1 # DEBUG=1 python setup.py develop -pip install flake8 typing mypy pytest scipy +pip install flake8 typing mypy pytest pytest-mock scipy ``` You may also have to install `libpng-dev` and `libjpeg-turbo8-dev` libraries: ```bash diff --git a/test/test_internet.py b/test/test_internet.py index 05496752c7f..772379a2289 100644 --- a/test/test_internet.py +++ b/test/test_internet.py @@ -6,8 +6,7 @@ """ import os -import unittest -import unittest.mock +import pytest import warnings from urllib.error import URLError @@ -15,7 +14,7 @@ from common_utils import get_tmp_dir -class DatasetUtilsTester(unittest.TestCase): +class TestDatasetUtils: def test_get_redirect_url(self): url = "http://www.vision.caltech.edu/visipedia-data/CUB-200-2011/CUB_200_2011.tgz" @@ -26,7 +25,7 @@ def test_get_redirect_url(self): def test_get_redirect_url_max_hops_exceeded(self): url = "http://www.vision.caltech.edu/visipedia-data/CUB-200-2011/CUB_200_2011.tgz" - with self.assertRaises(RecursionError): + with pytest.raises(RecursionError): utils._get_redirect_url(url, max_hops=0) def test_download_url(self): @@ -34,38 +33,38 @@ def test_download_url(self): url = "http://github.com/pytorch/vision/archive/master.zip" try: utils.download_url(url, temp_dir) - self.assertFalse(len(os.listdir(temp_dir)) == 0) + assert len(os.listdir(temp_dir)) != 0 except URLError: - msg = "could not download test file '{}'".format(url) - warnings.warn(msg, RuntimeWarning) - raise unittest.SkipTest(msg) + pytest.skip(f"could not download test file '{url}'") def test_download_url_retry_http(self): with get_tmp_dir() as temp_dir: url = "https://github.com/pytorch/vision/archive/master.zip" try: utils.download_url(url, temp_dir) - self.assertFalse(len(os.listdir(temp_dir)) == 0) + assert len(os.listdir(temp_dir)) != 0 except URLError: - msg = "could not download test file '{}'".format(url) - warnings.warn(msg, RuntimeWarning) - raise unittest.SkipTest(msg) + pytest.skip(f"could not download test file '{url}'") def test_download_url_dont_exist(self): with get_tmp_dir() as temp_dir: url = "http://github.com/pytorch/vision/archive/this_doesnt_exist.zip" - with self.assertRaises(URLError): + with pytest.raises(URLError): utils.download_url(url, temp_dir) - @unittest.mock.patch("torchvision.datasets.utils.download_file_from_google_drive") - def test_download_url_dispatch_download_from_google_drive(self, mock): + def test_download_url_dispatch_download_from_google_drive(self, mocker): url = "https://drive.google.com/file/d/1hbzc_P1FuxMkcabkgn9ZKinBwW683j45/view" id = "1hbzc_P1FuxMkcabkgn9ZKinBwW683j45" filename = "filename" md5 = "md5" + mocked = mocker.patch('torchvision.datasets.utils.download_file_from_google_drive') with get_tmp_dir() as root: utils.download_url(url, root, filename, md5) - mock.assert_called_once_with(id, root, filename, md5) + mocked.assert_called_once_with(id, root, filename, md5) + + +if __name__ == '__main__': + pytest.main([__file__]) From 5d93a87f5799e720240a5eab7f3b2424dbabad11 Mon Sep 17 00:00:00 2001 From: Matti Picus Date: Mon, 14 Jun 2021 18:26:59 +0300 Subject: [PATCH 193/279] always run build_docs in CI (#4053) --- .circleci/config.yml | 2 +- .circleci/regenerate.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index a091e02ff6f..ebbbdebd99f 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1432,7 +1432,7 @@ workflows: filters: branches: only: - - nightly + - '*' tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: build_docs diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py index e0809de7a50..e64d7d37dad 100755 --- a/.circleci/regenerate.py +++ b/.circleci/regenerate.py @@ -57,7 +57,7 @@ def build_workflows(prefix='', filter_branch=None, upload=False, indentation=6, if not filter_branch: # Build on every pull request, but upload only on nightly and tags - w += build_doc_job('nightly') + w += build_doc_job('*') w += upload_doc_job('nightly') return indent(indentation, w) From 496cb40ea0c35fb833e26d1deb95a910171fd69d Mon Sep 17 00:00:00 2001 From: Matti Picus Date: Tue, 15 Jun 2021 13:12:20 +0300 Subject: [PATCH 194/279] fixup '*' -> '/.*/' for CI filter (#4059) --- .circleci/config.yml | 4 ++-- .circleci/regenerate.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index ebbbdebd99f..09b8b57a98b 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1028,7 +1028,7 @@ workflows: cu_version: cpu filters: branches: - only: '*' + only: /.*/ tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_linux_wheel_py3.7_cpu @@ -1432,7 +1432,7 @@ workflows: filters: branches: only: - - '*' + - /.*/ tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: build_docs diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py index e64d7d37dad..ce7cf4cedbb 100755 --- a/.circleci/regenerate.py +++ b/.circleci/regenerate.py @@ -50,14 +50,14 @@ def build_workflows(prefix='', filter_branch=None, upload=False, indentation=6, btype == 'wheel' and python_version == '3.7'): # the fields must match the build_docs "requires" dependency - fb = "*" + fb = "/.*/" w += workflow_pair( btype, os_type, python_version, cu_version, unicode, prefix, upload, filter_branch=fb) if not filter_branch: # Build on every pull request, but upload only on nightly and tags - w += build_doc_job('*') + w += build_doc_job('/.*/') w += upload_doc_job('nightly') return indent(indentation, w) From b74366b82eb20b62ebe4e6e60722c237ff3f6827 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Tue, 15 Jun 2021 11:32:15 +0100 Subject: [PATCH 195/279] Fixed missing audio with video_reader backend (#3934) * Fixed missing audio with video_reader backend * Added unit test --- test/test_video_reader.py | 11 +++++++++++ torchvision/io/_video_opt.py | 2 +- 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/test/test_video_reader.py b/test/test_video_reader.py index e9a1adedb83..0a739673298 100644 --- a/test/test_video_reader.py +++ b/test/test_video_reader.py @@ -1244,6 +1244,17 @@ def test_invalid_file(self): with self.assertRaises(RuntimeError): io.read_video('foo.mp4') + def test_audio_present(self): + """Test if audio frames are returned with video_reader backend.""" + set_video_backend('video_reader') + for test_video, _ in test_videos.items(): + full_path = os.path.join(VIDEO_DIR, test_video) + container = av.open(full_path) + if container.streams.audio: + _, audio, _ = io.read_video(full_path) + self.assertGreaterEqual(audio.shape[0], 1) + self.assertGreaterEqual(audio.shape[1], 1) + if __name__ == "__main__": unittest.main() diff --git a/torchvision/io/_video_opt.py b/torchvision/io/_video_opt.py index a34b023bc6c..e92ac1bd396 100644 --- a/torchvision/io/_video_opt.py +++ b/torchvision/io/_video_opt.py @@ -155,7 +155,7 @@ def _align_audio_frames(aframes, aframe_pts, audio_pts_range): e_idx = num_samples if start < audio_pts_range[0]: s_idx = int((audio_pts_range[0] - start) / step_per_aframe) - if end > audio_pts_range[1]: + if audio_pts_range[1] != -1 and end > audio_pts_range[1]: e_idx = int((audio_pts_range[1] - end) / step_per_aframe) return aframes[s_idx:e_idx, :] From 34a8a37c41d82eaff0d907c2a231293efc326a69 Mon Sep 17 00:00:00 2001 From: Anirudh Date: Tue, 15 Jun 2021 18:14:54 +0530 Subject: [PATCH 196/279] Refactor test_transforms.py into classes (#4030) --- test/test_transforms.py | 692 +++++++++++++++++++--------------------- 1 file changed, 336 insertions(+), 356 deletions(-) diff --git a/test/test_transforms.py b/test/test_transforms.py index 8a0fb0f5ca6..e86b6959517 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -195,100 +195,98 @@ def test_accimage_crop(self): torch.testing.assert_close(output, expected_output) -@pytest.mark.parametrize('channels', [1, 3, 4]) -def test_to_tensor(channels): - height, width = 4, 4 - trans = transforms.ToTensor() - - input_data = torch.ByteTensor(channels, height, width).random_(0, 255).float().div_(255) - img = transforms.ToPILImage()(input_data) - output = trans(img) - torch.testing.assert_close(output, input_data, check_stride=False) - - ndarray = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) - output = trans(ndarray) - expected_output = ndarray.transpose((2, 0, 1)) / 255.0 - torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) - - ndarray = np.random.rand(height, width, channels).astype(np.float32) - output = trans(ndarray) - expected_output = ndarray.transpose((2, 0, 1)) - torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) - - # separate test for mode '1' PIL images - input_data = torch.ByteTensor(1, height, width).bernoulli_() - img = transforms.ToPILImage()(input_data.mul(255)).convert('1') - output = trans(img) - torch.testing.assert_close(input_data, output, check_dtype=False, check_stride=False) - - -def test_to_tensor_errors(): - height, width = 4, 4 - trans = transforms.ToTensor() - - with pytest.raises(TypeError): - trans(np.random.rand(1, height, width).tolist()) - - with pytest.raises(ValueError): - trans(np.random.rand(height)) - - with pytest.raises(ValueError): - trans(np.random.rand(1, 1, height, width)) +class TestToTensor: + @pytest.mark.parametrize('channels', [1, 3, 4]) + def test_to_tensor(self, channels): + height, width = 4, 4 + trans = transforms.ToTensor() -@pytest.mark.parametrize('dtype', [torch.float16, torch.float, torch.double]) -def test_to_tensor_with_other_default_dtypes(dtype): - current_def_dtype = torch.get_default_dtype() + input_data = torch.ByteTensor(channels, height, width).random_(0, 255).float().div_(255) + img = transforms.ToPILImage()(input_data) + output = trans(img) + torch.testing.assert_close(output, input_data, check_stride=False) + + ndarray = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) + output = trans(ndarray) + expected_output = ndarray.transpose((2, 0, 1)) / 255.0 + torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) + + ndarray = np.random.rand(height, width, channels).astype(np.float32) + output = trans(ndarray) + expected_output = ndarray.transpose((2, 0, 1)) + torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) + + # separate test for mode '1' PIL images + input_data = torch.ByteTensor(1, height, width).bernoulli_() + img = transforms.ToPILImage()(input_data.mul(255)).convert('1') + output = trans(img) + torch.testing.assert_close(input_data, output, check_dtype=False, check_stride=False) + + def test_to_tensor_errors(self): + height, width = 4, 4 + trans = transforms.ToTensor() - t = transforms.ToTensor() - np_arr = np.random.randint(0, 255, (32, 32, 3), dtype=np.uint8) - img = Image.fromarray(np_arr) + with pytest.raises(TypeError): + trans(np.random.rand(1, height, width).tolist()) - torch.set_default_dtype(dtype) - res = t(img) - assert res.dtype == dtype, f"{res.dtype} vs {dtype}" + with pytest.raises(ValueError): + trans(np.random.rand(height)) - torch.set_default_dtype(current_def_dtype) + with pytest.raises(ValueError): + trans(np.random.rand(1, 1, height, width)) + @pytest.mark.parametrize('dtype', [torch.float16, torch.float, torch.double]) + def test_to_tensor_with_other_default_dtypes(self, dtype): + current_def_dtype = torch.get_default_dtype() -@pytest.mark.parametrize('channels', [1, 3, 4]) -def test_pil_to_tensor(channels): - height, width = 4, 4 - trans = transforms.PILToTensor() + t = transforms.ToTensor() + np_arr = np.random.randint(0, 255, (32, 32, 3), dtype=np.uint8) + img = Image.fromarray(np_arr) - input_data = torch.ByteTensor(channels, height, width).random_(0, 255) - img = transforms.ToPILImage()(input_data) - output = trans(img) - torch.testing.assert_close(input_data, output, check_stride=False) + torch.set_default_dtype(dtype) + res = t(img) + assert res.dtype == dtype, f"{res.dtype} vs {dtype}" - input_data = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) - img = transforms.ToPILImage()(input_data) - output = trans(img) - expected_output = input_data.transpose((2, 0, 1)) - torch.testing.assert_close(output.numpy(), expected_output) + torch.set_default_dtype(current_def_dtype) - input_data = torch.as_tensor(np.random.rand(channels, height, width).astype(np.float32)) - img = transforms.ToPILImage()(input_data) # CHW -> HWC and (* 255).byte() - output = trans(img) # HWC -> CHW - expected_output = (input_data * 255).byte() - torch.testing.assert_close(output, expected_output, check_stride=False) + @pytest.mark.parametrize('channels', [1, 3, 4]) + def test_pil_to_tensor(self, channels): + height, width = 4, 4 + trans = transforms.PILToTensor() - # separate test for mode '1' PIL images - input_data = torch.ByteTensor(1, height, width).bernoulli_() - img = transforms.ToPILImage()(input_data.mul(255)).convert('1') - output = trans(img).view(torch.uint8).bool().to(torch.uint8) - torch.testing.assert_close(input_data, output, check_stride=False) + input_data = torch.ByteTensor(channels, height, width).random_(0, 255) + img = transforms.ToPILImage()(input_data) + output = trans(img) + torch.testing.assert_close(input_data, output, check_stride=False) + + input_data = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) + img = transforms.ToPILImage()(input_data) + output = trans(img) + expected_output = input_data.transpose((2, 0, 1)) + torch.testing.assert_close(output.numpy(), expected_output) + + input_data = torch.as_tensor(np.random.rand(channels, height, width).astype(np.float32)) + img = transforms.ToPILImage()(input_data) # CHW -> HWC and (* 255).byte() + output = trans(img) # HWC -> CHW + expected_output = (input_data * 255).byte() + torch.testing.assert_close(output, expected_output, check_stride=False) + # separate test for mode '1' PIL images + input_data = torch.ByteTensor(1, height, width).bernoulli_() + img = transforms.ToPILImage()(input_data.mul(255)).convert('1') + output = trans(img).view(torch.uint8).bool().to(torch.uint8) + torch.testing.assert_close(input_data, output, check_stride=False) -def test_pil_to_tensor_errors(): - height, width = 4, 4 - trans = transforms.PILToTensor() + def test_pil_to_tensor_errors(self): + height, width = 4, 4 + trans = transforms.PILToTensor() - with pytest.raises(TypeError): - trans(np.random.rand(1, height, width).tolist()) + with pytest.raises(TypeError): + trans(np.random.rand(1, height, width).tolist()) - with pytest.raises(TypeError): - trans(np.random.rand(1, height, width)) + with pytest.raises(TypeError): + trans(np.random.rand(1, height, width)) def test_randomresized_params(): @@ -537,303 +535,285 @@ def test_randomness(fn, trans, config, p): assert p_value > 0.0001 -def _get_1_channel_tensor_various_types(): - img_data_float = torch.Tensor(1, 4, 4).uniform_() - expected_output = img_data_float.mul(255).int().float().div(255).numpy() - yield img_data_float, expected_output, 'L' +class TestToPil: - img_data_byte = torch.ByteTensor(1, 4, 4).random_(0, 255) - expected_output = img_data_byte.float().div(255.0).numpy() - yield img_data_byte, expected_output, 'L' + def _get_1_channel_tensor_various_types(): + img_data_float = torch.Tensor(1, 4, 4).uniform_() + expected_output = img_data_float.mul(255).int().float().div(255).numpy() + yield img_data_float, expected_output, 'L' - img_data_short = torch.ShortTensor(1, 4, 4).random_() - expected_output = img_data_short.numpy() - yield img_data_short, expected_output, 'I;16' + img_data_byte = torch.ByteTensor(1, 4, 4).random_(0, 255) + expected_output = img_data_byte.float().div(255.0).numpy() + yield img_data_byte, expected_output, 'L' - img_data_int = torch.IntTensor(1, 4, 4).random_() - expected_output = img_data_int.numpy() - yield img_data_int, expected_output, 'I' + img_data_short = torch.ShortTensor(1, 4, 4).random_() + expected_output = img_data_short.numpy() + yield img_data_short, expected_output, 'I;16' + img_data_int = torch.IntTensor(1, 4, 4).random_() + expected_output = img_data_int.numpy() + yield img_data_int, expected_output, 'I' -@pytest.mark.parametrize('with_mode', [False, True]) -@pytest.mark.parametrize('img_data, expected_output, expected_mode', _get_1_channel_tensor_various_types()) -def test_1_channel_tensor_to_pil_image(with_mode, img_data, expected_output, expected_mode): - transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() - to_tensor = transforms.ToTensor() + def _get_2d_tensor_various_types(): + img_data_float = torch.Tensor(4, 4).uniform_() + expected_output = img_data_float.mul(255).int().float().div(255).numpy() + yield img_data_float, expected_output, 'L' - img = transform(img_data) - assert img.mode == expected_mode - torch.testing.assert_close(expected_output, to_tensor(img).numpy(), check_stride=False) + img_data_byte = torch.ByteTensor(4, 4).random_(0, 255) + expected_output = img_data_byte.float().div(255.0).numpy() + yield img_data_byte, expected_output, 'L' + img_data_short = torch.ShortTensor(4, 4).random_() + expected_output = img_data_short.numpy() + yield img_data_short, expected_output, 'I;16' -def test_1_channel_float_tensor_to_pil_image(): - img_data = torch.Tensor(1, 4, 4).uniform_() - # 'F' mode for torch.FloatTensor - img_F_mode = transforms.ToPILImage(mode='F')(img_data) - assert img_F_mode.mode == 'F' - torch.testing.assert_close( - np.array(Image.fromarray(img_data.squeeze(0).numpy(), mode='F')), np.array(img_F_mode) - ) + img_data_int = torch.IntTensor(4, 4).random_() + expected_output = img_data_int.numpy() + yield img_data_int, expected_output, 'I' + @pytest.mark.parametrize('with_mode', [False, True]) + @pytest.mark.parametrize('img_data, expected_output, expected_mode', _get_1_channel_tensor_various_types()) + def test_1_channel_tensor_to_pil_image(self, with_mode, img_data, expected_output, expected_mode): + transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() + to_tensor = transforms.ToTensor() -@pytest.mark.parametrize('with_mode', [False, True]) -@pytest.mark.parametrize('img_data, expected_mode', [ - (torch.Tensor(4, 4, 1).uniform_().numpy(), 'F'), - (torch.ByteTensor(4, 4, 1).random_(0, 255).numpy(), 'L'), - (torch.ShortTensor(4, 4, 1).random_().numpy(), 'I;16'), - (torch.IntTensor(4, 4, 1).random_().numpy(), 'I'), -]) -def test_1_channel_ndarray_to_pil_image(with_mode, img_data, expected_mode): - transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() - img = transform(img_data) - assert img.mode == expected_mode - # note: we explicitly convert img's dtype because pytorch doesn't support uint16 - # and otherwise assert_close wouldn't be able to construct a tensor from the uint16 array - torch.testing.assert_close(img_data[:, :, 0], np.asarray(img).astype(img_data.dtype)) - - -@pytest.mark.parametrize('expected_mode', [None, 'LA']) -def test_2_channel_ndarray_to_pil_image(expected_mode): - img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy() - - if expected_mode is None: - img = transforms.ToPILImage()(img_data) - assert img.mode == 'LA' # default should assume LA - else: - img = transforms.ToPILImage(mode=expected_mode)(img_data) - assert img.mode == expected_mode - split = img.split() - for i in range(2): - torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) - - -def test_2_channel_ndarray_to_pil_image_error(): - img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy() - transforms.ToPILImage().__repr__() - - # should raise if we try a mode for 4 or 1 or 3 channel images - with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): - transforms.ToPILImage(mode='RGBA')(img_data) - with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): - transforms.ToPILImage(mode='P')(img_data) - with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): - transforms.ToPILImage(mode='RGB')(img_data) - - -@pytest.mark.parametrize('expected_mode', [None, 'LA']) -def test_2_channel_tensor_to_pil_image(expected_mode): - img_data = torch.Tensor(2, 4, 4).uniform_() - expected_output = img_data.mul(255).int().float().div(255) - if expected_mode is None: - img = transforms.ToPILImage()(img_data) - assert img.mode == 'LA' # default should assume LA - else: - img = transforms.ToPILImage(mode=expected_mode)(img_data) + img = transform(img_data) assert img.mode == expected_mode + torch.testing.assert_close(expected_output, to_tensor(img).numpy(), check_stride=False) - split = img.split() - for i in range(2): - torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy()) - - -def test_2_channel_tensor_to_pil_image_error(): - img_data = torch.Tensor(2, 4, 4).uniform_() - - # should raise if we try a mode for 4 or 1 or 3 channel images - with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): - transforms.ToPILImage(mode='RGBA')(img_data) - with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): - transforms.ToPILImage(mode='P')(img_data) - with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): - transforms.ToPILImage(mode='RGB')(img_data) - - -def _get_2d_tensor_various_types(): - img_data_float = torch.Tensor(4, 4).uniform_() - expected_output = img_data_float.mul(255).int().float().div(255).numpy() - yield img_data_float, expected_output, 'L' - - img_data_byte = torch.ByteTensor(4, 4).random_(0, 255) - expected_output = img_data_byte.float().div(255.0).numpy() - yield img_data_byte, expected_output, 'L' - - img_data_short = torch.ShortTensor(4, 4).random_() - expected_output = img_data_short.numpy() - yield img_data_short, expected_output, 'I;16' - - img_data_int = torch.IntTensor(4, 4).random_() - expected_output = img_data_int.numpy() - yield img_data_int, expected_output, 'I' - - -@pytest.mark.parametrize('with_mode', [False, True]) -@pytest.mark.parametrize('img_data, expected_output, expected_mode', _get_2d_tensor_various_types()) -def test_2d_tensor_to_pil_image(with_mode, img_data, expected_output, expected_mode): - transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() - to_tensor = transforms.ToTensor() - - img = transform(img_data) - assert img.mode == expected_mode - torch.testing.assert_close(expected_output, to_tensor(img).numpy()[0]) - - -@pytest.mark.parametrize('with_mode', [False, True]) -@pytest.mark.parametrize('img_data, expected_mode', [ - (torch.Tensor(4, 4).uniform_().numpy(), 'F'), - (torch.ByteTensor(4, 4).random_(0, 255).numpy(), 'L'), - (torch.ShortTensor(4, 4).random_().numpy(), 'I;16'), - (torch.IntTensor(4, 4).random_().numpy(), 'I'), -]) -def test_2d_ndarray_to_pil_image(with_mode, img_data, expected_mode): - transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() - img = transform(img_data) - assert img.mode == expected_mode - np.testing.assert_allclose(img_data, img) - - -@pytest.mark.parametrize('expected_mode', [None, 'RGB', 'HSV', 'YCbCr']) -def test_3_channel_tensor_to_pil_image(expected_mode): - img_data = torch.Tensor(3, 4, 4).uniform_() - expected_output = img_data.mul(255).int().float().div(255) + def test_1_channel_float_tensor_to_pil_image(self): + img_data = torch.Tensor(1, 4, 4).uniform_() + # 'F' mode for torch.FloatTensor + img_F_mode = transforms.ToPILImage(mode='F')(img_data) + assert img_F_mode.mode == 'F' + torch.testing.assert_close( + np.array(Image.fromarray(img_data.squeeze(0).numpy(), mode='F')), np.array(img_F_mode) + ) - if expected_mode is None: - img = transforms.ToPILImage()(img_data) - assert img.mode == 'RGB' # default should assume RGB - else: - img = transforms.ToPILImage(mode=expected_mode)(img_data) + @pytest.mark.parametrize('with_mode', [False, True]) + @pytest.mark.parametrize('img_data, expected_mode', [ + (torch.Tensor(4, 4, 1).uniform_().numpy(), 'F'), + (torch.ByteTensor(4, 4, 1).random_(0, 255).numpy(), 'L'), + (torch.ShortTensor(4, 4, 1).random_().numpy(), 'I;16'), + (torch.IntTensor(4, 4, 1).random_().numpy(), 'I'), + ]) + def test_1_channel_ndarray_to_pil_image(self, with_mode, img_data, expected_mode): + transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() + img = transform(img_data) assert img.mode == expected_mode - split = img.split() - for i in range(3): - torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy()) + # note: we explicitly convert img's dtype because pytorch doesn't support uint16 + # and otherwise assert_close wouldn't be able to construct a tensor from the uint16 array + torch.testing.assert_close(img_data[:, :, 0], np.asarray(img).astype(img_data.dtype)) + @pytest.mark.parametrize('expected_mode', [None, 'LA']) + def test_2_channel_ndarray_to_pil_image(self, expected_mode): + img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy() -def test_3_channel_tensor_to_pil_image_error(): - img_data = torch.Tensor(3, 4, 4).uniform_() - error_message_3d = r"Only modes \['RGB', 'YCbCr', 'HSV'\] are supported for 3D inputs" - # should raise if we try a mode for 4 or 1 or 2 channel images - with pytest.raises(ValueError, match=error_message_3d): - transforms.ToPILImage(mode='RGBA')(img_data) - with pytest.raises(ValueError, match=error_message_3d): - transforms.ToPILImage(mode='P')(img_data) - with pytest.raises(ValueError, match=error_message_3d): - transforms.ToPILImage(mode='LA')(img_data) - - with pytest.raises(ValueError, match=r'pic should be 2/3 dimensional. Got \d+ dimensions.'): - transforms.ToPILImage()(torch.Tensor(1, 3, 4, 4).uniform_()) - - -@pytest.mark.parametrize('expected_mode', [None, 'RGB', 'HSV', 'YCbCr']) -def test_3_channel_ndarray_to_pil_image(expected_mode): - img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy() - - if expected_mode is None: - img = transforms.ToPILImage()(img_data) - assert img.mode == 'RGB' # default should assume RGB - else: - img = transforms.ToPILImage(mode=expected_mode)(img_data) + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'LA' # default should assume LA + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + split = img.split() + for i in range(2): + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) + + def test_2_channel_ndarray_to_pil_image_error(self): + img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy() + transforms.ToPILImage().__repr__() + + # should raise if we try a mode for 4 or 1 or 3 channel images + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='RGBA')(img_data) + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='RGB')(img_data) + + @pytest.mark.parametrize('expected_mode', [None, 'LA']) + def test_2_channel_tensor_to_pil_image(self, expected_mode): + img_data = torch.Tensor(2, 4, 4).uniform_() + expected_output = img_data.mul(255).int().float().div(255) + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'LA' # default should assume LA + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + + split = img.split() + for i in range(2): + torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy()) + + def test_2_channel_tensor_to_pil_image_error(self): + img_data = torch.Tensor(2, 4, 4).uniform_() + + # should raise if we try a mode for 4 or 1 or 3 channel images + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='RGBA')(img_data) + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=r"Only modes \['LA'\] are supported for 2D inputs"): + transforms.ToPILImage(mode='RGB')(img_data) + + @pytest.mark.parametrize('with_mode', [False, True]) + @pytest.mark.parametrize('img_data, expected_output, expected_mode', _get_2d_tensor_various_types()) + def test_2d_tensor_to_pil_image(self, with_mode, img_data, expected_output, expected_mode): + transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() + to_tensor = transforms.ToTensor() + + img = transform(img_data) assert img.mode == expected_mode - split = img.split() - for i in range(3): - torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) - - -def test_3_channel_ndarray_to_pil_image_error(): - img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy() - - # Checking if ToPILImage can be printed as string - transforms.ToPILImage().__repr__() - - error_message_3d = r"Only modes \['RGB', 'YCbCr', 'HSV'\] are supported for 3D inputs" - # should raise if we try a mode for 4 or 1 or 2 channel images - with pytest.raises(ValueError, match=error_message_3d): - transforms.ToPILImage(mode='RGBA')(img_data) - with pytest.raises(ValueError, match=error_message_3d): - transforms.ToPILImage(mode='P')(img_data) - with pytest.raises(ValueError, match=error_message_3d): - transforms.ToPILImage(mode='LA')(img_data) - - -@pytest.mark.parametrize('expected_mode', [None, 'RGBA', 'CMYK', 'RGBX']) -def test_4_channel_tensor_to_pil_image(expected_mode): - img_data = torch.Tensor(4, 4, 4).uniform_() - expected_output = img_data.mul(255).int().float().div(255) - - if expected_mode is None: - img = transforms.ToPILImage()(img_data) - assert img.mode == 'RGBA' # default should assume RGBA - else: - img = transforms.ToPILImage(mode=expected_mode)(img_data) + torch.testing.assert_close(expected_output, to_tensor(img).numpy()[0]) + + @pytest.mark.parametrize('with_mode', [False, True]) + @pytest.mark.parametrize('img_data, expected_mode', [ + (torch.Tensor(4, 4).uniform_().numpy(), 'F'), + (torch.ByteTensor(4, 4).random_(0, 255).numpy(), 'L'), + (torch.ShortTensor(4, 4).random_().numpy(), 'I;16'), + (torch.IntTensor(4, 4).random_().numpy(), 'I'), + ]) + def test_2d_ndarray_to_pil_image(self, with_mode, img_data, expected_mode): + transform = transforms.ToPILImage(mode=expected_mode) if with_mode else transforms.ToPILImage() + img = transform(img_data) assert img.mode == expected_mode + np.testing.assert_allclose(img_data, img) - split = img.split() - for i in range(4): - torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy()) - - -def test_4_channel_tensor_to_pil_image_error(): - img_data = torch.Tensor(4, 4, 4).uniform_() - - error_message_4d = r"Only modes \['RGBA', 'CMYK', 'RGBX'\] are supported for 4D inputs" - # should raise if we try a mode for 3 or 1 or 2 channel images - with pytest.raises(ValueError, match=error_message_4d): - transforms.ToPILImage(mode='RGB')(img_data) - with pytest.raises(ValueError, match=error_message_4d): - transforms.ToPILImage(mode='P')(img_data) - with pytest.raises(ValueError, match=error_message_4d): - transforms.ToPILImage(mode='LA')(img_data) + @pytest.mark.parametrize('expected_mode', [None, 'RGB', 'HSV', 'YCbCr']) + def test_3_channel_tensor_to_pil_image(self, expected_mode): + img_data = torch.Tensor(3, 4, 4).uniform_() + expected_output = img_data.mul(255).int().float().div(255) - -@pytest.mark.parametrize('expected_mode', [None, 'RGBA', 'CMYK', 'RGBX']) -def test_4_channel_ndarray_to_pil_image(expected_mode): - img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy() - - if expected_mode is None: - img = transforms.ToPILImage()(img_data) - assert img.mode == 'RGBA' # default should assume RGBA - else: - img = transforms.ToPILImage(mode=expected_mode)(img_data) - assert img.mode == expected_mode - split = img.split() - for i in range(4): - torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) - - -def test_4_channel_ndarray_to_pil_image_error(): - img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy() - - error_message_4d = r"Only modes \['RGBA', 'CMYK', 'RGBX'\] are supported for 4D inputs" - # should raise if we try a mode for 3 or 1 or 2 channel images - with pytest.raises(ValueError, match=error_message_4d): - transforms.ToPILImage(mode='RGB')(img_data) - with pytest.raises(ValueError, match=error_message_4d): - transforms.ToPILImage(mode='P')(img_data) - with pytest.raises(ValueError, match=error_message_4d): - transforms.ToPILImage(mode='LA')(img_data) - - -def test_ndarray_bad_types_to_pil_image(): - trans = transforms.ToPILImage() - reg_msg = r'Input type \w+ is not supported' - with pytest.raises(TypeError, match=reg_msg): - trans(np.ones([4, 4, 1], np.int64)) - with pytest.raises(TypeError, match=reg_msg): - trans(np.ones([4, 4, 1], np.uint16)) - with pytest.raises(TypeError, match=reg_msg): - trans(np.ones([4, 4, 1], np.uint32)) - with pytest.raises(TypeError, match=reg_msg): - trans(np.ones([4, 4, 1], np.float64)) - - with pytest.raises(ValueError, match=r'pic should be 2/3 dimensional. Got \d+ dimensions.'): - transforms.ToPILImage()(np.ones([1, 4, 4, 3])) - with pytest.raises(ValueError, match=r'pic should not have > 4 channels. Got \d+ channels.'): - transforms.ToPILImage()(np.ones([4, 4, 6])) - - -def test_tensor_bad_types_to_pil_image(): - with pytest.raises(ValueError, match=r'pic should be 2/3 dimensional. Got \d+ dimensions.'): - transforms.ToPILImage()(torch.ones(1, 3, 4, 4)) - with pytest.raises(ValueError, match=r'pic should not have > 4 channels. Got \d+ channels.'): - transforms.ToPILImage()(torch.ones(6, 4, 4)) + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'RGB' # default should assume RGB + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + split = img.split() + for i in range(3): + torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy()) + + def test_3_channel_tensor_to_pil_image_error(self): + img_data = torch.Tensor(3, 4, 4).uniform_() + error_message_3d = r"Only modes \['RGB', 'YCbCr', 'HSV'\] are supported for 3D inputs" + # should raise if we try a mode for 4 or 1 or 2 channel images + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='RGBA')(img_data) + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='LA')(img_data) + + with pytest.raises(ValueError, match=r'pic should be 2/3 dimensional. Got \d+ dimensions.'): + transforms.ToPILImage()(torch.Tensor(1, 3, 4, 4).uniform_()) + + @pytest.mark.parametrize('expected_mode', [None, 'RGB', 'HSV', 'YCbCr']) + def test_3_channel_ndarray_to_pil_image(self, expected_mode): + img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy() + + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'RGB' # default should assume RGB + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + split = img.split() + for i in range(3): + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) + + def test_3_channel_ndarray_to_pil_image_error(self): + img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy() + + # Checking if ToPILImage can be printed as string + transforms.ToPILImage().__repr__() + + error_message_3d = r"Only modes \['RGB', 'YCbCr', 'HSV'\] are supported for 3D inputs" + # should raise if we try a mode for 4 or 1 or 2 channel images + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='RGBA')(img_data) + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=error_message_3d): + transforms.ToPILImage(mode='LA')(img_data) + + @pytest.mark.parametrize('expected_mode', [None, 'RGBA', 'CMYK', 'RGBX']) + def test_4_channel_tensor_to_pil_image(self, expected_mode): + img_data = torch.Tensor(4, 4, 4).uniform_() + expected_output = img_data.mul(255).int().float().div(255) + + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'RGBA' # default should assume RGBA + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + + split = img.split() + for i in range(4): + torch.testing.assert_close(expected_output[i].numpy(), F.to_tensor(split[i]).squeeze(0).numpy()) + + def test_4_channel_tensor_to_pil_image_error(self): + img_data = torch.Tensor(4, 4, 4).uniform_() + + error_message_4d = r"Only modes \['RGBA', 'CMYK', 'RGBX'\] are supported for 4D inputs" + # should raise if we try a mode for 3 or 1 or 2 channel images + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='RGB')(img_data) + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='LA')(img_data) + + @pytest.mark.parametrize('expected_mode', [None, 'RGBA', 'CMYK', 'RGBX']) + def test_4_channel_ndarray_to_pil_image(self, expected_mode): + img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy() + + if expected_mode is None: + img = transforms.ToPILImage()(img_data) + assert img.mode == 'RGBA' # default should assume RGBA + else: + img = transforms.ToPILImage(mode=expected_mode)(img_data) + assert img.mode == expected_mode + split = img.split() + for i in range(4): + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) + + def test_4_channel_ndarray_to_pil_image_error(self): + img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy() + + error_message_4d = r"Only modes \['RGBA', 'CMYK', 'RGBX'\] are supported for 4D inputs" + # should raise if we try a mode for 3 or 1 or 2 channel images + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='RGB')(img_data) + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='P')(img_data) + with pytest.raises(ValueError, match=error_message_4d): + transforms.ToPILImage(mode='LA')(img_data) + + def test_ndarray_bad_types_to_pil_image(self): + trans = transforms.ToPILImage() + reg_msg = r'Input type \w+ is not supported' + with pytest.raises(TypeError, match=reg_msg): + trans(np.ones([4, 4, 1], np.int64)) + with pytest.raises(TypeError, match=reg_msg): + trans(np.ones([4, 4, 1], np.uint16)) + with pytest.raises(TypeError, match=reg_msg): + trans(np.ones([4, 4, 1], np.uint32)) + with pytest.raises(TypeError, match=reg_msg): + trans(np.ones([4, 4, 1], np.float64)) + + with pytest.raises(ValueError, match=r'pic should be 2/3 dimensional. Got \d+ dimensions.'): + transforms.ToPILImage()(np.ones([1, 4, 4, 3])) + with pytest.raises(ValueError, match=r'pic should not have > 4 channels. Got \d+ channels.'): + transforms.ToPILImage()(np.ones([4, 4, 6])) + + def test_tensor_bad_types_to_pil_image(self): + with pytest.raises(ValueError, match=r'pic should be 2/3 dimensional. Got \d+ dimensions.'): + transforms.ToPILImage()(torch.ones(1, 3, 4, 4)) + with pytest.raises(ValueError, match=r'pic should not have > 4 channels. Got \d+ channels.'): + transforms.ToPILImage()(torch.ones(6, 4, 4)) def test_adjust_brightness(): From 4658f24d3156b3dd366cfb1491691a38d61c9be2 Mon Sep 17 00:00:00 2001 From: Eli Uriegas <1700823+seemethere@users.noreply.github.com> Date: Tue, 15 Jun 2021 10:23:27 -0700 Subject: [PATCH 197/279] Remove special versioning suffix rules for CUDA 10.2 (#4065) * packaging: Remove special versioning priveleges Adds a version suffix for CUDA 10.2 for ease of installing when installing from download.pytorch.org Signed-off-by: Eli Uriegas * also include windows cmath fix Signed-off-by: Eli Uriegas * remove comment Signed-off-by: Eli Uriegas * fix indent Signed-off-by: Eli Uriegas * actually add the script Signed-off-by: Eli Uriegas --- packaging/pkg_helpers.bash | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/packaging/pkg_helpers.bash b/packaging/pkg_helpers.bash index 826fb525e3a..48f7588594a 100644 --- a/packaging/pkg_helpers.bash +++ b/packaging/pkg_helpers.bash @@ -35,10 +35,7 @@ setup_cuda() { export WHEEL_DIR="" # Wheel builds need suffixes (but not if they're on OS X, which never has suffix) if [[ "$BUILD_TYPE" == "wheel" ]] && [[ "$(uname)" != Darwin ]]; then - # The default CUDA has no suffix - if [[ "$CU_VERSION" != "cu102" ]]; then - export PYTORCH_VERSION_SUFFIX="+$CU_VERSION" - fi + export PYTORCH_VERSION_SUFFIX="+$CU_VERSION" # Match the suffix scheme of pytorch, unless this package does not have # CUDA builds (in which case, use default) if [[ -z "$NO_CUDA_PACKAGE" ]]; then From 05f91a6972f84e38636ff8a2545562effa27eec5 Mon Sep 17 00:00:00 2001 From: Ivan Kobzarev Date: Tue, 15 Jun 2021 13:45:05 -0700 Subject: [PATCH 198/279] [android] Add mavenCentral repository for release publishing (#4067) ghstack-source-id: 7a9c81f1786b94ee9d542a3c4bf1ba87b7e83e57 Pull Request resolved: https://github.com/pytorch/vision/pull/4066 Co-authored-by: Francisco Massa --- android/ops/build.gradle | 1 + android/test_app/app/build.gradle | 1 + 2 files changed, 2 insertions(+) diff --git a/android/ops/build.gradle b/android/ops/build.gradle index df20f6f030d..645f840fb27 100644 --- a/android/ops/build.gradle +++ b/android/ops/build.gradle @@ -3,6 +3,7 @@ apply plugin: 'maven' repositories { jcenter() + mavenCentral() maven { url "https://oss.sonatype.org/content/repositories/snapshots" } diff --git a/android/test_app/app/build.gradle b/android/test_app/app/build.gradle index 76b2d741793..30b147728a9 100644 --- a/android/test_app/app/build.gradle +++ b/android/test_app/app/build.gradle @@ -2,6 +2,7 @@ apply plugin: 'com.android.application' repositories { jcenter() + mavenCentral() maven { url "https://oss.sonatype.org/content/repositories/snapshots" } From 89f8db61f8ecab23d9af8c09e8edb81cbc6c9180 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 16 Jun 2021 09:21:30 +0100 Subject: [PATCH 199/279] Add comments (#4072) --- torchvision/models/utils.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/torchvision/models/utils.py b/torchvision/models/utils.py index 638ef07cd85..132ccff2598 100644 --- a/torchvision/models/utils.py +++ b/torchvision/models/utils.py @@ -1,3 +1,6 @@ +# Don't remove this file and don't change the imports of load_state_dict_from_url +# from other files. We need this so that we can swap load_state_dict_from_url with +# a custom internal version in fbcode. try: from torch.hub import load_state_dict_from_url except ImportError: From 686ff5987eaddbd5f939cc59ca38978b55fc38f0 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 16 Jun 2021 10:22:27 +0100 Subject: [PATCH 200/279] [iOS] podspec file for Cocoapods release, pod name: LibTorchvision (#4055) (#4074) Co-authored-by: Yuchen Huang Co-authored-by: Francisco Massa --- ios/LibTorchvision.podspec | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 ios/LibTorchvision.podspec diff --git a/ios/LibTorchvision.podspec b/ios/LibTorchvision.podspec new file mode 100644 index 00000000000..4f3b2085708 --- /dev/null +++ b/ios/LibTorchvision.podspec @@ -0,0 +1,24 @@ +pytorch_version = '1.9.0' + +Pod::Spec.new do |s| + s.name = 'LibTorchvision' + s.version = '0.10.0' + s.authors = 'PyTorch Team' + s.license = { :type => 'BSD' } + s.homepage = 'https://github.com/pytorch/vision' + s.source = { :http => "https://ossci-ios.s3.amazonaws.com/libtorchvision_ops_ios_#{s.version}.zip" } + s.summary = '"The C++ library of TorchVision ops for iOS' + s.description = <<-DESC + The C++ library of TorchVision ops for iOS. + This version (#{s.version}) requires the installation of LibTorch #{pytorch_version} or LibTorch-Lite #{pytorch_version}. + DESC + s.ios.deployment_target = '12.0' + s.vendored_libraries = 'install/lib/*.a' + s.user_target_xcconfig = { + 'VALID_ARCHS' => 'x86_64 arm64', + 'OTHER_LDFLAGS' => '$(inherited) -force_load "$(PODS_ROOT)/LibTorchvision/install/lib/libtorchvision_ops.a"', + 'CLANG_CXX_LANGUAGE_STANDARD' => 'c++14', + 'CLANG_CXX_LIBRARY' => 'libc++' + } + s.library = ['c++', 'stdc++'] +end From f4ab3e7e51a001b27e9d03434c67292053005467 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 16 Jun 2021 10:25:44 +0100 Subject: [PATCH 201/279] [FBcode->GH] Better logic for ignoring CPU tests on GPU CI machines (#4025) (#4062) --- test/conftest.py | 7 +++++++ test/test_image.py | 13 +++++++++++++ 2 files changed, 20 insertions(+) diff --git a/test/conftest.py b/test/conftest.py index ab60cb5fa41..cc565b07b3f 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -8,6 +8,9 @@ def pytest_configure(config): config.addinivalue_line( "markers", "needs_cuda: mark for tests that rely on a CUDA device" ) + config.addinivalue_line( + "markers", "dont_collect: mark for tests that should not be collected" + ) def pytest_collection_modifyitems(items): @@ -47,6 +50,10 @@ def pytest_collection_modifyitems(items): # to run the CPU-only tests. item.add_marker(pytest.mark.skip(reason=CIRCLECI_GPU_NO_CUDA_MSG)) + if item.get_closest_marker('dont_collect') is not None: + # currently, this is only used for some tests we're sure we dont want to run on fbcode + continue + out_items.append(item) items[:] = out_items diff --git a/test/test_image.py b/test/test_image.py index d9162760263..14fea642379 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -358,6 +358,18 @@ def test_encode_jpeg_errors(): encode_jpeg(torch.empty((100, 100), dtype=torch.uint8)) +def _collect_if(cond): + # TODO: remove this once test_encode_jpeg_reference and test_write_jpeg_reference + # are removed + def _inner(test_func): + if cond: + return test_func + else: + return pytest.mark.dont_collect(test_func) + return _inner + + +@_collect_if(cond=IS_WINDOWS) @pytest.mark.parametrize('img_path', [ pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) for jpeg_path in get_images(ENCODE_JPEG, ".jpg") @@ -389,6 +401,7 @@ def test_encode_jpeg_reference(img_path): assert_equal(jpeg_bytes, pil_bytes) +@_collect_if(cond=IS_WINDOWS) @pytest.mark.parametrize('img_path', [ pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) for jpeg_path in get_images(ENCODE_JPEG, ".jpg") From 562b8463bcce05a958023cfe9c2e72185cb804d8 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 16 Jun 2021 10:26:52 +0100 Subject: [PATCH 202/279] [FBcode->GH] Allow all torchvision test rules to run with RE (#4073) --- test/conftest.py | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/test/conftest.py b/test/conftest.py index cc565b07b3f..3cffeeac88f 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -14,12 +14,19 @@ def pytest_configure(config): def pytest_collection_modifyitems(items): - # This hook is called by pytest after it has collected the tests (google its name!) + # This hook is called by pytest after it has collected the tests (google its name to check out its doc!) # We can ignore some tests as we see fit here, or add marks, such as a skip mark. + # + # Typically here, we try to optimize CI time. In particular, the GPU CI instances don't need to run the + # tests that don't need CUDA, because those tests are extensively tested in the CPU CI instances already. + # This is true for both CircleCI and the fbcode internal CI. + # In the fbcode CI, we have an additional constraint: we try to avoid skipping tests. So instead of relying on + # pytest.mark.skip, in fbcode we literally just remove those tests from the `items` list, and it's as if + # these tests never existed. out_items = [] for item in items: - # The needs_cuda mark will exist if the test was explicitely decorated with + # The needs_cuda mark will exist if the test was explicitly decorated with # the @needs_cuda decorator. It will also exist if it was parametrized with a # parameter that has the mark: for example if a test is parametrized with # @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -57,3 +64,19 @@ def pytest_collection_modifyitems(items): out_items.append(item) items[:] = out_items + + +def pytest_sessionfinish(session, exitstatus): + # This hook is called after all tests have run, and just before returning an exit status. + # We here change exit code 5 into 0. + # + # 5 is issued when no tests were actually run, e.g. if you use `pytest -k some_regex_that_is_never_matched`. + # + # Having no test being run for a given test rule is a common scenario in fbcode, and typically happens on + # the GPU test machines which don't run the CPU-only tests (see pytest_collection_modifyitems above). For + # example `test_transforms.py` doesn't contain any CUDA test at the time of + # writing, so on a GPU test machine, testpilot would invoke pytest on this file and no test would be run. + # This would result in pytest returning 5, causing testpilot to raise an error. + # To avoid this, we transform this 5 into a 0 to make testpilot happy. + if exitstatus == 5: + session.exitstatus = 0 From 09f4b81342549856c8df4dbd027f330908a5d72a Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Thu, 17 Jun 2021 15:12:48 +0100 Subject: [PATCH 203/279] Fix typing issue to make DeformConv2d scriptable (#4079) --- test/test_ops.py | 4 ++++ torchvision/ops/deform_conv.py | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/test/test_ops.py b/test/test_ops.py index 21b0c2039c3..a776268a5b4 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -775,6 +775,10 @@ def test_autocast(self, batch_sz, dtype): with torch.cuda.amp.autocast(): self.test_forward(torch.device("cuda"), contiguous=False, batch_sz=batch_sz, dtype=dtype) + def test_forward_scriptability(self): + # Non-regression test for https://github.com/pytorch/vision/issues/4078 + torch.jit.script(ops.DeformConv2d(in_channels=8, out_channels=8, kernel_size=3)) + class TestFrozenBNT: def test_frozenbatchnorm2d_repr(self): diff --git a/torchvision/ops/deform_conv.py b/torchvision/ops/deform_conv.py index 7dceee96f27..4399d441843 100644 --- a/torchvision/ops/deform_conv.py +++ b/torchvision/ops/deform_conv.py @@ -149,7 +149,7 @@ def reset_parameters(self) -> None: bound = 1 / math.sqrt(fan_in) init.uniform_(self.bias, -bound, bound) - def forward(self, input: Tensor, offset: Tensor, mask: Tensor = None) -> Tensor: + def forward(self, input: Tensor, offset: Tensor, mask: Optional[Tensor] = None) -> Tensor: """ Args: input (Tensor[batch_size, in_channels, in_height, in_width]): input tensor From a40a0ded2651bacf1f7efc8e9e652d9dfe8efb39 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Thu, 17 Jun 2021 15:48:51 +0100 Subject: [PATCH 204/279] [FBcode->GH] Support opt mode for torchvision ops (#4080) --- torchvision/_register_extension.py | 41 ++++++++++++++++++++++++ torchvision/extension.py | 50 +++++------------------------- torchvision/io/_video_opt.py | 43 +++---------------------- torchvision/io/image.py | 45 +++------------------------ 4 files changed, 57 insertions(+), 122 deletions(-) create mode 100644 torchvision/_register_extension.py diff --git a/torchvision/_register_extension.py b/torchvision/_register_extension.py new file mode 100644 index 00000000000..e8cb097d9b5 --- /dev/null +++ b/torchvision/_register_extension.py @@ -0,0 +1,41 @@ +import os +import importlib.machinery + + +def _get_extension_path(lib_name): + + lib_dir = os.path.dirname(__file__) + if os.name == 'nt': + # Register the main torchvision library location on the default DLL path + import ctypes + import sys + + kernel32 = ctypes.WinDLL('kernel32.dll', use_last_error=True) + with_load_library_flags = hasattr(kernel32, 'AddDllDirectory') + prev_error_mode = kernel32.SetErrorMode(0x0001) + + if with_load_library_flags: + kernel32.AddDllDirectory.restype = ctypes.c_void_p + + if sys.version_info >= (3, 8): + os.add_dll_directory(lib_dir) + elif with_load_library_flags: + res = kernel32.AddDllDirectory(lib_dir) + if res is None: + err = ctypes.WinError(ctypes.get_last_error()) + err.strerror += f' Error adding "{lib_dir}" to the DLL directories.' + raise err + + kernel32.SetErrorMode(prev_error_mode) + + loader_details = ( + importlib.machinery.ExtensionFileLoader, + importlib.machinery.EXTENSION_SUFFIXES + ) + + extfinder = importlib.machinery.FileFinder(lib_dir, loader_details) + ext_specs = extfinder.find_spec(lib_name) + if ext_specs is None: + raise ImportError + + return ext_specs.origin diff --git a/torchvision/extension.py b/torchvision/extension.py index 265c989a8ce..ade9cc21980 100644 --- a/torchvision/extension.py +++ b/torchvision/extension.py @@ -1,54 +1,18 @@ -_HAS_OPS = False - +import torch -def _has_ops(): - return False - - -def _register_extensions(): - import os - import importlib - import torch +from ._register_extension import _get_extension_path - # load the custom_op_library and register the custom ops - lib_dir = os.path.dirname(__file__) - if os.name == 'nt': - # Register the main torchvision library location on the default DLL path - import ctypes - import sys - kernel32 = ctypes.WinDLL('kernel32.dll', use_last_error=True) - with_load_library_flags = hasattr(kernel32, 'AddDllDirectory') - prev_error_mode = kernel32.SetErrorMode(0x0001) - - if with_load_library_flags: - kernel32.AddDllDirectory.restype = ctypes.c_void_p - - if sys.version_info >= (3, 8): - os.add_dll_directory(lib_dir) - elif with_load_library_flags: - res = kernel32.AddDllDirectory(lib_dir) - if res is None: - err = ctypes.WinError(ctypes.get_last_error()) - err.strerror += f' Error adding "{lib_dir}" to the DLL directories.' - raise err - - kernel32.SetErrorMode(prev_error_mode) +_HAS_OPS = False - loader_details = ( - importlib.machinery.ExtensionFileLoader, - importlib.machinery.EXTENSION_SUFFIXES - ) - extfinder = importlib.machinery.FileFinder(lib_dir, loader_details) - ext_specs = extfinder.find_spec("_C") - if ext_specs is None: - raise ImportError - torch.ops.load_library(ext_specs.origin) +def _has_ops(): + return False try: - _register_extensions() + lib_path = _get_extension_path('_C') + torch.ops.load_library(lib_path) _HAS_OPS = True def _has_ops(): # noqa: F811 diff --git a/torchvision/io/_video_opt.py b/torchvision/io/_video_opt.py index e92ac1bd396..07795b63348 100644 --- a/torchvision/io/_video_opt.py +++ b/torchvision/io/_video_opt.py @@ -1,5 +1,4 @@ -import importlib import math import os import warnings @@ -9,47 +8,15 @@ import numpy as np import torch +from .._register_extension import _get_extension_path -_HAS_VIDEO_OPT = False try: - lib_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) - - loader_details = ( - importlib.machinery.ExtensionFileLoader, - importlib.machinery.EXTENSION_SUFFIXES - ) - - extfinder = importlib.machinery.FileFinder(lib_dir, loader_details) - ext_specs = extfinder.find_spec("video_reader") - - if os.name == 'nt': - # Load the video_reader extension using LoadLibraryExW - import ctypes - - kernel32 = ctypes.WinDLL('kernel32.dll', use_last_error=True) - with_load_library_flags = hasattr(kernel32, 'AddDllDirectory') - prev_error_mode = kernel32.SetErrorMode(0x0001) - - if with_load_library_flags: - kernel32.LoadLibraryExW.restype = ctypes.c_void_p - - if ext_specs is not None: - res = kernel32.LoadLibraryExW(ext_specs.origin, None, 0x00001100) - if res is None: - err = ctypes.WinError(ctypes.get_last_error()) - err.strerror += (f' Error loading "{ext_specs.origin}" or any or ' - 'its dependencies.') - raise err - - kernel32.SetErrorMode(prev_error_mode) - - if ext_specs is not None: - torch.ops.load_library(ext_specs.origin) - _HAS_VIDEO_OPT = True + lib_path = _get_extension_path('video_reader') + torch.ops.load_library(lib_path) + _HAS_VIDEO_OPT = True except (ImportError, OSError): - pass - + _HAS_VIDEO_OPT = False default_timebase = Fraction(0, 1) diff --git a/torchvision/io/image.py b/torchvision/io/image.py index 4f824abad60..08f6d65b1f4 100644 --- a/torchvision/io/image.py +++ b/torchvision/io/image.py @@ -1,49 +1,12 @@ import torch - -import os -import os.path as osp -import importlib.machinery - from enum import Enum -_HAS_IMAGE_OPT = False - -try: - lib_dir = osp.abspath(osp.join(osp.dirname(__file__), "..")) - - loader_details = ( - importlib.machinery.ExtensionFileLoader, - importlib.machinery.EXTENSION_SUFFIXES - ) - - extfinder = importlib.machinery.FileFinder(lib_dir, loader_details) # type: ignore[arg-type] - ext_specs = extfinder.find_spec("image") +from .._register_extension import _get_extension_path - if os.name == 'nt': - # Load the image extension using LoadLibraryExW - import ctypes - kernel32 = ctypes.WinDLL('kernel32.dll', use_last_error=True) - with_load_library_flags = hasattr(kernel32, 'AddDllDirectory') - prev_error_mode = kernel32.SetErrorMode(0x0001) - - kernel32.LoadLibraryW.restype = ctypes.c_void_p - if with_load_library_flags: - kernel32.LoadLibraryExW.restype = ctypes.c_void_p - - if ext_specs is not None: - res = kernel32.LoadLibraryExW(ext_specs.origin, None, 0x00001100) - if res is None: - err = ctypes.WinError(ctypes.get_last_error()) - err.strerror += (f' Error loading "{ext_specs.origin}" or any or ' - 'its dependencies.') - raise err - - kernel32.SetErrorMode(prev_error_mode) - - if ext_specs is not None: - torch.ops.load_library(ext_specs.origin) - _HAS_IMAGE_OPT = True +try: + lib_path = _get_extension_path('image') + torch.ops.load_library(lib_path) except (ImportError, OSError): pass From 29bdcd2551d13f3a10dec743edc95ff121d37978 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Thu, 17 Jun 2021 16:29:54 +0100 Subject: [PATCH 205/279] Only tag merger if PR isn't properly labeled, not all reviewers (#4081) Co-authored-by: Philip Meier --- .github/process_commit.py | 35 ++++++++++++--------------------- .github/workflows/pr-labels.yml | 12 +++++------ 2 files changed, 19 insertions(+), 28 deletions(-) diff --git a/.github/process_commit.py b/.github/process_commit.py index 33edd74194e..00cbe6abd12 100644 --- a/.github/process_commit.py +++ b/.github/process_commit.py @@ -1,7 +1,10 @@ """ -This script finds all responsible users for labeling a PR by a commit SHA. It is used by the workflow in +This script finds the merger responsible for labeling a PR by a commit SHA. It is used by the workflow in '.github/workflows/pr-labels.yml'. If there exists no PR associated with the commit or the PR is properly labeled, this script is a no-op. + +Note: we ping the merger only, not the reviewers, as the reviewers can sometimes be external to torchvision +with no labeling responsibility, so we don't want to bother them. """ import sys @@ -38,19 +41,6 @@ } -def find_responsible_users(commit_hash: str) -> Set[str]: - pr_number = get_pr_number(commit_hash) - if not pr_number: - return set() - - merger, labels = get_pr_merger_and_labels(pr_number) - is_properly_labeled = bool(REQUIRED_LABELS.intersection(labels)) - if is_properly_labeled: - return set() - - return {merger, *get_pr_reviewers(pr_number)} - - def query_torchvision(cmd: str, *, accept) -> Any: response = requests.get(f"https://api.github.com/repos/pytorch/vision/{cmd}", headers=dict(Accept=accept)) return response.json() @@ -72,13 +62,14 @@ def get_pr_merger_and_labels(pr_number: int) -> Tuple[str, Set[str]]: return merger, labels -def get_pr_reviewers(pr_number: int) -> Set[str]: - # See https://docs.github.com/en/rest/reference/pulls#list-reviews-for-a-pull-request - data = query_torchvision(f"pulls/{pr_number}/reviews", accept="application/vnd.github.v3+json") - return {review["user"]["login"] for review in data if review["state"] == "APPROVED"} - - if __name__ == "__main__": commit_hash = sys.argv[1] - users = find_responsible_users(commit_hash) - print(", ".join(sorted([f"@{user}" for user in users]))) + pr_number = get_pr_number(commit_hash) + if not pr_number: + sys.exit(0) + + merger, labels = get_pr_merger_and_labels(pr_number) + is_properly_labeled = bool(REQUIRED_LABELS.intersection(labels)) + + if not is_properly_labeled: + print(f"@{merger}") diff --git a/.github/workflows/pr-labels.yml b/.github/workflows/pr-labels.yml index 06d99b8c557..33fbeb6fc81 100644 --- a/.github/workflows/pr-labels.yml +++ b/.github/workflows/pr-labels.yml @@ -19,17 +19,17 @@ jobs: - name: Checkout repository uses: actions/checkout@v2 - - name: Process commit and find users responsible for labeling + - name: Process commit and find merger responsible for labeling id: commit - run: echo "::set-output name=responsible_users::$(python .github/process_commit.py ${{ github.sha }})" + run: echo "::set-output name=merger::$(python .github/process_commit.py ${{ github.sha }})" - - name: Ping users responsible for labeling if necessary - if: ${{ steps.commit.outputs.responsible_users != '' }} + - name: Ping merger responsible for labeling if necessary + if: ${{ steps.commit.outputs.merger != '' }} uses: mshick/add-pr-comment@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: message: | - Hey ${{ steps.commit.outputs.responsible_users }}! + Hey ${{ steps.commit.outputs.merger }}! - You approved or merged this PR, but no labels were added. + You merged this PR, but no labels were added. From 70b2edb89c3cd1c2fe1407d204c8e1f4f1812a5b Mon Sep 17 00:00:00 2001 From: Gaurav7888 <60139335+Gaurav7888@users.noreply.github.com> Date: Fri, 18 Jun 2021 16:14:37 +0530 Subject: [PATCH 206/279] Replace deprecated torch.lstsq with torch.linalg.lstsq (#3918) Co-authored-by: Vasilis Vryniotis Co-authored-by: Nicolas Hug --- torchvision/transforms/functional.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torchvision/transforms/functional.py b/torchvision/transforms/functional.py index 6a86a000d65..21f5c654f99 100644 --- a/torchvision/transforms/functional.py +++ b/torchvision/transforms/functional.py @@ -591,9 +591,9 @@ def _get_perspective_coeffs( a_matrix[2 * i + 1, :] = torch.tensor([0, 0, 0, p1[0], p1[1], 1, -p2[1] * p1[0], -p2[1] * p1[1]]) b_matrix = torch.tensor(startpoints, dtype=torch.float).view(8) - res = torch.lstsq(b_matrix, a_matrix)[0] + res = torch.linalg.lstsq(a_matrix, b_matrix, driver='gels').solution - output: List[float] = res.squeeze(1).tolist() + output: List[float] = res.tolist() return output From 68b128d5a9ccfe05d64fc1a93e686f8489fd63b9 Mon Sep 17 00:00:00 2001 From: beet <20266375+beet-aizu@users.noreply.github.com> Date: Fri, 18 Jun 2021 19:53:11 +0900 Subject: [PATCH 207/279] Fix default in docs of references/video_classification/train.py (#3409) --- references/video_classification/train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/references/video_classification/train.py b/references/video_classification/train.py index bcc74064344..11ac2d5378d 100644 --- a/references/video_classification/train.py +++ b/references/video_classification/train.py @@ -268,7 +268,7 @@ def parse_args(): parser.add_argument('--epochs', default=45, type=int, metavar='N', help='number of total epochs to run') parser.add_argument('-j', '--workers', default=10, type=int, metavar='N', - help='number of data loading workers (default: 16)') + help='number of data loading workers (default: 10)') parser.add_argument('--lr', default=0.01, type=float, help='initial learning rate') parser.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum') From b4a075cbc2779318994cf240d070c7335edcbb2a Mon Sep 17 00:00:00 2001 From: Francisco Massa Date: Mon, 21 Jun 2021 13:41:44 +0200 Subject: [PATCH 208/279] Add test to check that classification models are FX-compatible (#3662) * Add test to check that classification models are FX-compatible * Replace torch.equal with torch.allclose * remove skipling Co-authored-by: Nicolas Hug --- test/test_models.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/test/test_models.py b/test/test_models.py index a3c7ec40342..d40b72e55ff 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -7,6 +7,7 @@ import functools import operator import torch +import torch.fx import torch.nn as nn import torchvision from torchvision import models @@ -140,6 +141,13 @@ def get_export_import_copy(m): assert_export_import_module(sm, args) +def _check_fx_compatible(model, inputs): + model_fx = torch.fx.symbolic_trace(model) + out = model(inputs) + out_fx = model_fx(inputs) + torch.testing.assert_close(out, out_fx) + + # If 'unwrapper' is provided it will be called with the script model outputs # before they are compared to the eager model outputs. This is useful if the # model outputs are different between TorchScript / Eager mode @@ -408,6 +416,7 @@ def test_classification_model(model_name, dev): _assert_expected(out.cpu(), model_name, prec=0.1) assert out.shape[-1] == 50 _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(model_name, None)) + _check_fx_compatible(model, x) if dev == torch.device("cuda"): with torch.cuda.amp.autocast(): From 655a2eded44859cfdf0cd1141849cf22c4654738 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 21 Jun 2021 13:00:51 +0100 Subject: [PATCH 209/279] Fix training model instructions in references/classification (#4089) --- references/classification/README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/references/classification/README.md b/references/classification/README.md index 7a3144b7cac..e0b7f210175 100644 --- a/references/classification/README.md +++ b/references/classification/README.md @@ -23,7 +23,8 @@ Since `AlexNet` and the original `VGG` architectures do not include batch normalization, the default initial learning rate `--lr 0.1` is to high. ``` -python main.py --model $MODEL --lr 1e-2 +python -m torch.distributed.launch --nproc_per_node=8 --use_env train.py\ + --model $MODEL --lr 1e-2 ``` Here `$MODEL` is one of `alexnet`, `vgg11`, `vgg13`, `vgg16` or `vgg19`. Note From 11480973385719f0eaba6247e65e149867a0b66a Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 21 Jun 2021 14:54:43 +0100 Subject: [PATCH 210/279] [FBcode->GH] Enable analytics logging for MNIST and CIFAR (#4090) Summary: Enable analytics logging for MNIST and CIFAR Reviewed By: colin2328, fmassa Differential Revision: D29183132 fbshipit-source-id: 67d9f6881354f87659fdec4183b22a1be3ec0eb6 Co-authored-by: Dmitriy Genzel --- torchvision/datasets/cifar.py | 2 ++ torchvision/datasets/mnist.py | 1 + 2 files changed, 3 insertions(+) diff --git a/torchvision/datasets/cifar.py b/torchvision/datasets/cifar.py index 9d939326c76..47b2bd41fb0 100644 --- a/torchvision/datasets/cifar.py +++ b/torchvision/datasets/cifar.py @@ -3,6 +3,7 @@ import os.path import numpy as np import pickle +import torch from typing import Any, Callable, Optional, Tuple from .vision import VisionDataset @@ -58,6 +59,7 @@ def __init__( super(CIFAR10, self).__init__(root, transform=transform, target_transform=target_transform) + torch._C._log_api_usage_once(f"torchvision.datasets.{self.__class__.__name__}") self.train = train # training set or test set diff --git a/torchvision/datasets/mnist.py b/torchvision/datasets/mnist.py index e356f17dd1b..edd2185c984 100644 --- a/torchvision/datasets/mnist.py +++ b/torchvision/datasets/mnist.py @@ -77,6 +77,7 @@ def __init__( ) -> None: super(MNIST, self).__init__(root, transform=transform, target_transform=target_transform) + torch._C._log_api_usage_once(f"torchvision.datasets.{self.__class__.__name__}") self.train = train # training set or test set if self._check_legacy_exist(): From d391a0e992a35d7fb01e11110e2ccf8e445ad8a0 Mon Sep 17 00:00:00 2001 From: Eli Uriegas <1700823+seemethere@users.noreply.github.com> Date: Mon, 21 Jun 2021 13:53:06 -0700 Subject: [PATCH 211/279] ci: Remove mentions of conda-forge (#4082) --- .circleci/config.yml | 15 +++++---------- .circleci/config.yml.in | 15 +++++---------- .circleci/unittest/linux/scripts/environment.yml | 2 -- .circleci/unittest/linux/scripts/install.sh | 2 +- .../unittest/windows/scripts/environment.yml | 2 -- .circleci/unittest/windows/scripts/install.sh | 2 +- CONTRIBUTING.md | 2 +- packaging/build_conda.sh | 3 ++- packaging/pkg_helpers.bash | 12 +++--------- packaging/torchvision/meta.yaml | 1 - 10 files changed, 18 insertions(+), 38 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 09b8b57a98b..83e7ebd0f49 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -311,6 +311,10 @@ jobs: eval "$('/C/tools/miniconda3/Scripts/conda.exe' 'shell.bash' 'hook')" conda activate base conda install -yq conda-build "conda-package-handling!=1.5.0" + # cudatoolkit >= 11 isn't available for windows in the nvidia channel + if [[ "${CU_VERSION}" =~ cu11.* ]]; then + export CONDA_CHANNEL_FLAGS="-c conda-forge" + fi packaging/build_conda.sh rm /C/tools/miniconda3/conda-bld/win-64/vs${VC_YEAR}*.tar.bz2 - store_artifacts: @@ -577,11 +581,7 @@ jobs: set -x eval "$('/C/tools/miniconda3/Scripts/conda.exe' 'shell.bash' 'hook')" conda env remove -n python${PYTHON_VERSION} || true - CONDA_CHANNEL_FLAGS="" - if [[ "${PYTHON_VERSION}" = 3.9 ]]; then - CONDA_CHANNEL_FLAGS="-c=conda-forge" - fi - conda create ${CONDA_CHANNEL_FLAGS} -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} + conda create -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} conda activate python${PYTHON_VERSION} conda install Pillow>=5.3.0 conda install -v -y -c pytorch-nightly pytorch @@ -606,11 +606,6 @@ jobs: command: | set -x eval "$('/C/tools/miniconda3/Scripts/conda.exe' 'shell.bash' 'hook')" - CONDA_CHANNEL_FLAGS="" - if [[ "${PYTHON_VERSION}" = 3.9 ]]; then - CONDA_CHANNEL_FLAGS="-c=conda-forge" - fi - conda create ${CONDA_CHANNEL_FLAGS} -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} conda create -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} conda activate python${PYTHON_VERSION} pip install $(ls ~/workspace/torchvision*.whl) --pre -f https://download.pytorch.org/whl/nightly/torch_nightly.html diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index f2d2e472a58..19539785e9b 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -311,6 +311,10 @@ jobs: eval "$('/C/tools/miniconda3/Scripts/conda.exe' 'shell.bash' 'hook')" conda activate base conda install -yq conda-build "conda-package-handling!=1.5.0" + # cudatoolkit >= 11 isn't available for windows in the nvidia channel + if [[ "${CU_VERSION}" =~ cu11.* ]]; then + export CONDA_CHANNEL_FLAGS="-c conda-forge" + fi packaging/build_conda.sh rm /C/tools/miniconda3/conda-bld/win-64/vs${VC_YEAR}*.tar.bz2 - store_artifacts: @@ -577,11 +581,7 @@ jobs: set -x eval "$('/C/tools/miniconda3/Scripts/conda.exe' 'shell.bash' 'hook')" conda env remove -n python${PYTHON_VERSION} || true - CONDA_CHANNEL_FLAGS="" - if [[ "${PYTHON_VERSION}" = 3.9 ]]; then - CONDA_CHANNEL_FLAGS="-c=conda-forge" - fi - conda create ${CONDA_CHANNEL_FLAGS} -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} + conda create -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} conda activate python${PYTHON_VERSION} conda install Pillow>=5.3.0 conda install -v -y -c pytorch-nightly pytorch @@ -606,11 +606,6 @@ jobs: command: | set -x eval "$('/C/tools/miniconda3/Scripts/conda.exe' 'shell.bash' 'hook')" - CONDA_CHANNEL_FLAGS="" - if [[ "${PYTHON_VERSION}" = 3.9 ]]; then - CONDA_CHANNEL_FLAGS="-c=conda-forge" - fi - conda create ${CONDA_CHANNEL_FLAGS} -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} conda create -yn python${PYTHON_VERSION} python=${PYTHON_VERSION} conda activate python${PYTHON_VERSION} pip install $(ls ~/workspace/torchvision*.whl) --pre -f https://download.pytorch.org/whl/nightly/torch_nightly.html diff --git a/.circleci/unittest/linux/scripts/environment.yml b/.circleci/unittest/linux/scripts/environment.yml index c0d36f95a43..67ceb836a10 100644 --- a/.circleci/unittest/linux/scripts/environment.yml +++ b/.circleci/unittest/linux/scripts/environment.yml @@ -1,8 +1,6 @@ channels: - pytorch - defaults - # using conda-forge for python v3.9 - - conda-forge dependencies: - pytest - pytest-cov diff --git a/.circleci/unittest/linux/scripts/install.sh b/.circleci/unittest/linux/scripts/install.sh index 7058e4d7095..e9b9e80c077 100755 --- a/.circleci/unittest/linux/scripts/install.sh +++ b/.circleci/unittest/linux/scripts/install.sh @@ -24,7 +24,7 @@ else fi printf "Installing PyTorch with %s\n" "${cudatoolkit}" -conda install -y -c "pytorch-${UPLOAD_CHANNEL}" -c conda-forge "pytorch-${UPLOAD_CHANNEL}"::pytorch "${cudatoolkit}" pytest +conda install -y -c "pytorch-${UPLOAD_CHANNEL}" "pytorch-${UPLOAD_CHANNEL}"::pytorch "${cudatoolkit}" pytest if [ $PYTHON_VERSION == "3.6" ]; then printf "Installing minimal PILLOW version\n" diff --git a/.circleci/unittest/windows/scripts/environment.yml b/.circleci/unittest/windows/scripts/environment.yml index 11de8e089e8..fc4d2f89a0e 100644 --- a/.circleci/unittest/windows/scripts/environment.yml +++ b/.circleci/unittest/windows/scripts/environment.yml @@ -1,8 +1,6 @@ channels: - pytorch - defaults - # use conda-forge for python v3.9+ - - conda-forge dependencies: - pytest - pytest-cov diff --git a/.circleci/unittest/windows/scripts/install.sh b/.circleci/unittest/windows/scripts/install.sh index a90e88a71d4..45e381c775b 100644 --- a/.circleci/unittest/windows/scripts/install.sh +++ b/.circleci/unittest/windows/scripts/install.sh @@ -26,7 +26,7 @@ else fi printf "Installing PyTorch with %s\n" "${cudatoolkit}" -conda install -y -c "pytorch-${UPLOAD_CHANNEL}" -c conda-forge "pytorch-${UPLOAD_CHANNEL}"::pytorch "${cudatoolkit}" pytest +conda install -y -c "pytorch-${UPLOAD_CHANNEL}" "pytorch-${UPLOAD_CHANNEL}"::pytorch "${cudatoolkit}" pytest if [ $PYTHON_VERSION == "3.6" ]; then printf "Installing minimal PILLOW version\n" diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 3fa41efec26..75405c94a83 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -33,7 +33,7 @@ clear and has sufficient instructions to be able to reproduce the issue. ### Install PyTorch Nightly ```bash -conda install pytorch -c pytorch-nightly -c conda-forge +conda install pytorch -c pytorch-nightly # or with pip (see https://pytorch.org/get-started/locally/) # pip install numpy # pip install --pre torch -f https://download.pytorch.org/whl/nightly/cu102/torch_nightly.html diff --git a/packaging/build_conda.sh b/packaging/build_conda.sh index 85c7d88273f..9b14c288724 100755 --- a/packaging/build_conda.sh +++ b/packaging/build_conda.sh @@ -11,4 +11,5 @@ setup_conda_pytorch_constraint setup_conda_cudatoolkit_constraint setup_visual_studio_constraint setup_junit_results_folder -conda build $CONDA_CHANNEL_FLAGS -c defaults -c conda-forge --no-anaconda-upload --python "$PYTHON_VERSION" packaging/torchvision +# nvidia channel included for cudatoolkit >= 11 +conda build -c defaults -c nvidia $CONDA_CHANNEL_FLAGS --no-anaconda-upload --python "$PYTHON_VERSION" packaging/torchvision diff --git a/packaging/pkg_helpers.bash b/packaging/pkg_helpers.bash index 48f7588594a..dfde11b707a 100644 --- a/packaging/pkg_helpers.bash +++ b/packaging/pkg_helpers.bash @@ -180,13 +180,10 @@ setup_wheel_python() { if [[ "$(uname)" == Darwin || "$OSTYPE" == "msys" ]]; then eval "$(conda shell.bash hook)" conda env remove -n "env$PYTHON_VERSION" || true - if [[ "$PYTHON_VERSION" == 3.9 ]]; then - export CONDA_CHANNEL_FLAGS="${CONDA_CHANNEL_FLAGS} -c=conda-forge" - fi conda create ${CONDA_CHANNEL_FLAGS} -yn "env$PYTHON_VERSION" python="$PYTHON_VERSION" conda activate "env$PYTHON_VERSION" # Install libpng from Anaconda (defaults) - conda install ${CONDA_CHANNEL_FLAGS} -c conda-forge libpng "jpeg<=9b" -y + conda install ${CONDA_CHANNEL_FLAGS} libpng "jpeg<=9b" -y else # Install native CentOS libJPEG, LAME, freetype and GnuTLS yum install -y libjpeg-turbo-devel lame freetype gnutls @@ -250,7 +247,7 @@ setup_pip_pytorch_version() { # You MUST have populated PYTORCH_VERSION_SUFFIX before hand. setup_conda_pytorch_constraint() { if [[ -z "$PYTORCH_VERSION" ]]; then - export CONDA_CHANNEL_FLAGS="-c pytorch-nightly -c pytorch" + export CONDA_CHANNEL_FLAGS="${CONDA_CHANNEL_FLAGS} -c pytorch-nightly -c pytorch" export PYTORCH_VERSION="$(conda search --json 'pytorch[channel=pytorch-nightly]' | \ python -c "import os, sys, json, re; cuver = os.environ.get('CU_VERSION'); \ cuver_1 = cuver.replace('cu', 'cuda') if cuver != 'cpu' else cuver; \ @@ -265,7 +262,7 @@ setup_conda_pytorch_constraint() { exit 1 fi else - export CONDA_CHANNEL_FLAGS="-c pytorch -c pytorch-${UPLOAD_CHANNEL}" + export CONDA_CHANNEL_FLAGS="${CONDA_CHANNEL_FLAGS} -c pytorch -c pytorch-${UPLOAD_CHANNEL}" fi if [[ "$CU_VERSION" == cpu ]]; then export CONDA_PYTORCH_BUILD_CONSTRAINT="- pytorch==$PYTORCH_VERSION${PYTORCH_VERSION_SUFFIX}" @@ -277,9 +274,6 @@ setup_conda_pytorch_constraint() { if [[ "$OSTYPE" == msys && "$CU_VERSION" == cu92 ]]; then export CONDA_CHANNEL_FLAGS="${CONDA_CHANNEL_FLAGS} -c defaults -c numba/label/dev" fi - if [[ "$PYTHON_VERSION" == 3.9 ]]; then - export CONDA_CHANNEL_FLAGS="${CONDA_CHANNEL_FLAGS} -c=conda-forge" - fi } # Translate CUDA_VERSION into CUDA_CUDATOOLKIT_CONSTRAINT diff --git a/packaging/torchvision/meta.yaml b/packaging/torchvision/meta.yaml index c9b6d04fdc7..222071ede93 100644 --- a/packaging/torchvision/meta.yaml +++ b/packaging/torchvision/meta.yaml @@ -52,7 +52,6 @@ test: requires: - pytest - scipy - - av # NOTE: Pinned to fix issues with size_t on Windows - jpeg <=9b - ca-certificates From 183a722169421c83638e68ee2d8fc5bd3415c4b4 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Tue, 22 Jun 2021 16:44:21 +0100 Subject: [PATCH 212/279] [FBcode->GH] Group all internally replaced utils into a single file (#4095) --- ..._extension.py => _internally_replaced_utils.py} | 14 ++++++++++++++ torchvision/datasets/_utils.py | 6 ------ torchvision/datasets/utils.py | 2 +- torchvision/extension.py | 2 +- torchvision/io/_video_opt.py | 2 +- torchvision/io/image.py | 2 +- torchvision/models/alexnet.py | 2 +- torchvision/models/densenet.py | 2 +- torchvision/models/detection/faster_rcnn.py | 2 +- torchvision/models/detection/keypoint_rcnn.py | 2 +- torchvision/models/detection/mask_rcnn.py | 2 +- torchvision/models/detection/retinanet.py | 2 +- torchvision/models/detection/ssd.py | 2 +- torchvision/models/detection/ssdlite.py | 2 +- torchvision/models/googlenet.py | 2 +- torchvision/models/inception.py | 2 +- torchvision/models/mnasnet.py | 2 +- torchvision/models/mobilenetv2.py | 2 +- torchvision/models/mobilenetv3.py | 2 +- torchvision/models/quantization/googlenet.py | 2 +- torchvision/models/quantization/inception.py | 2 +- torchvision/models/quantization/mobilenetv2.py | 2 +- torchvision/models/quantization/mobilenetv3.py | 2 +- torchvision/models/quantization/resnet.py | 2 +- torchvision/models/quantization/shufflenetv2.py | 2 +- torchvision/models/resnet.py | 2 +- torchvision/models/segmentation/segmentation.py | 2 +- torchvision/models/shufflenetv2.py | 2 +- torchvision/models/squeezenet.py | 2 +- torchvision/models/utils.py | 7 ------- torchvision/models/vgg.py | 2 +- torchvision/models/video/resnet.py | 2 +- 32 files changed, 43 insertions(+), 42 deletions(-) rename torchvision/{_register_extension.py => _internally_replaced_utils.py} (81%) delete mode 100644 torchvision/datasets/_utils.py delete mode 100644 torchvision/models/utils.py diff --git a/torchvision/_register_extension.py b/torchvision/_internally_replaced_utils.py similarity index 81% rename from torchvision/_register_extension.py rename to torchvision/_internally_replaced_utils.py index e8cb097d9b5..0ab3e4e3f15 100644 --- a/torchvision/_register_extension.py +++ b/torchvision/_internally_replaced_utils.py @@ -2,6 +2,20 @@ import importlib.machinery +def _download_file_from_remote_location(fpath: str, url: str) -> None: + pass + + +def _is_remote_location_available() -> bool: + return False + + +try: + from torch.hub import load_state_dict_from_url +except ImportError: + from torch.utils.model_zoo import load_url as load_state_dict_from_url + + def _get_extension_path(lib_name): lib_dir = os.path.dirname(__file__) diff --git a/torchvision/datasets/_utils.py b/torchvision/datasets/_utils.py deleted file mode 100644 index 5661b31a4b9..00000000000 --- a/torchvision/datasets/_utils.py +++ /dev/null @@ -1,6 +0,0 @@ -def _download_file_from_remote_location(fpath: str, url: str) -> None: - pass - - -def _is_remote_location_available() -> bool: - return False diff --git a/torchvision/datasets/utils.py b/torchvision/datasets/utils.py index e6798bd4500..8e27688ef87 100644 --- a/torchvision/datasets/utils.py +++ b/torchvision/datasets/utils.py @@ -17,7 +17,7 @@ import torch from torch.utils.model_zoo import tqdm -from ._utils import ( +from .._internally_replaced_utils import ( _download_file_from_remote_location, _is_remote_location_available, ) diff --git a/torchvision/extension.py b/torchvision/extension.py index ade9cc21980..bea6db33636 100644 --- a/torchvision/extension.py +++ b/torchvision/extension.py @@ -1,6 +1,6 @@ import torch -from ._register_extension import _get_extension_path +from ._internally_replaced_utils import _get_extension_path _HAS_OPS = False diff --git a/torchvision/io/_video_opt.py b/torchvision/io/_video_opt.py index 07795b63348..a4a811dec4b 100644 --- a/torchvision/io/_video_opt.py +++ b/torchvision/io/_video_opt.py @@ -8,7 +8,7 @@ import numpy as np import torch -from .._register_extension import _get_extension_path +from .._internally_replaced_utils import _get_extension_path try: diff --git a/torchvision/io/image.py b/torchvision/io/image.py index 08f6d65b1f4..343c0b3a33d 100644 --- a/torchvision/io/image.py +++ b/torchvision/io/image.py @@ -1,7 +1,7 @@ import torch from enum import Enum -from .._register_extension import _get_extension_path +from .._internally_replaced_utils import _get_extension_path try: diff --git a/torchvision/models/alexnet.py b/torchvision/models/alexnet.py index 0b78f4ee003..156a453c3cc 100644 --- a/torchvision/models/alexnet.py +++ b/torchvision/models/alexnet.py @@ -1,6 +1,6 @@ import torch import torch.nn as nn -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from typing import Any diff --git a/torchvision/models/densenet.py b/torchvision/models/densenet.py index e4f7e5b0255..aef7977773b 100644 --- a/torchvision/models/densenet.py +++ b/torchvision/models/densenet.py @@ -4,7 +4,7 @@ import torch.nn.functional as F import torch.utils.checkpoint as cp from collections import OrderedDict -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from torch import Tensor from typing import Any, List, Tuple diff --git a/torchvision/models/detection/faster_rcnn.py b/torchvision/models/detection/faster_rcnn.py index bf8df3b9377..83f2eb88f88 100644 --- a/torchvision/models/detection/faster_rcnn.py +++ b/torchvision/models/detection/faster_rcnn.py @@ -4,7 +4,7 @@ from torchvision.ops import MultiScaleRoIAlign from ._utils import overwrite_eps -from ..utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from .anchor_utils import AnchorGenerator from .generalized_rcnn import GeneralizedRCNN diff --git a/torchvision/models/detection/keypoint_rcnn.py b/torchvision/models/detection/keypoint_rcnn.py index 0d9a4de6dca..fd9a980b97d 100644 --- a/torchvision/models/detection/keypoint_rcnn.py +++ b/torchvision/models/detection/keypoint_rcnn.py @@ -4,7 +4,7 @@ from torchvision.ops import MultiScaleRoIAlign from ._utils import overwrite_eps -from ..utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from .faster_rcnn import FasterRCNN from .backbone_utils import resnet_fpn_backbone, _validate_trainable_layers diff --git a/torchvision/models/detection/mask_rcnn.py b/torchvision/models/detection/mask_rcnn.py index 589a42068bf..ad8f356ad69 100644 --- a/torchvision/models/detection/mask_rcnn.py +++ b/torchvision/models/detection/mask_rcnn.py @@ -5,7 +5,7 @@ from torchvision.ops import MultiScaleRoIAlign from ._utils import overwrite_eps -from ..utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from .faster_rcnn import FasterRCNN from .backbone_utils import resnet_fpn_backbone, _validate_trainable_layers diff --git a/torchvision/models/detection/retinanet.py b/torchvision/models/detection/retinanet.py index af6943628a4..aab7daa828a 100644 --- a/torchvision/models/detection/retinanet.py +++ b/torchvision/models/detection/retinanet.py @@ -7,7 +7,7 @@ from typing import Dict, List, Tuple, Optional from ._utils import overwrite_eps -from ..utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from . import _utils as det_utils from .anchor_utils import AnchorGenerator diff --git a/torchvision/models/detection/ssd.py b/torchvision/models/detection/ssd.py index b6e620dba4a..3589dd45f4c 100644 --- a/torchvision/models/detection/ssd.py +++ b/torchvision/models/detection/ssd.py @@ -11,7 +11,7 @@ from .backbone_utils import _validate_trainable_layers from .transform import GeneralizedRCNNTransform from .. import vgg -from ..utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from ...ops import boxes as box_ops __all__ = ['SSD', 'ssd300_vgg16'] diff --git a/torchvision/models/detection/ssdlite.py b/torchvision/models/detection/ssdlite.py index 26378d7038d..08d48c68020 100644 --- a/torchvision/models/detection/ssdlite.py +++ b/torchvision/models/detection/ssdlite.py @@ -12,7 +12,7 @@ from .backbone_utils import _validate_trainable_layers from .. import mobilenet from ..mobilenetv3 import ConvBNActivation -from ..utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url __all__ = ['ssdlite320_mobilenet_v3_large'] diff --git a/torchvision/models/googlenet.py b/torchvision/models/googlenet.py index 63066520983..0745ef4eef6 100644 --- a/torchvision/models/googlenet.py +++ b/torchvision/models/googlenet.py @@ -4,7 +4,7 @@ import torch.nn as nn import torch.nn.functional as F from torch import Tensor -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from typing import Optional, Tuple, List, Callable, Any __all__ = ['GoogLeNet', 'googlenet', "GoogLeNetOutputs", "_GoogLeNetOutputs"] diff --git a/torchvision/models/inception.py b/torchvision/models/inception.py index 836a12a7a64..b9c6ab74534 100644 --- a/torchvision/models/inception.py +++ b/torchvision/models/inception.py @@ -3,7 +3,7 @@ import torch from torch import nn, Tensor import torch.nn.functional as F -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from typing import Callable, Any, Optional, Tuple, List diff --git a/torchvision/models/mnasnet.py b/torchvision/models/mnasnet.py index 3c703774dda..ffefab77628 100644 --- a/torchvision/models/mnasnet.py +++ b/torchvision/models/mnasnet.py @@ -3,7 +3,7 @@ import torch from torch import Tensor import torch.nn as nn -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from typing import Any, Dict, List __all__ = ['MNASNet', 'mnasnet0_5', 'mnasnet0_75', 'mnasnet1_0', 'mnasnet1_3'] diff --git a/torchvision/models/mobilenetv2.py b/torchvision/models/mobilenetv2.py index 3938156949f..0cfa4f371e3 100644 --- a/torchvision/models/mobilenetv2.py +++ b/torchvision/models/mobilenetv2.py @@ -1,7 +1,7 @@ import torch from torch import nn from torch import Tensor -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from typing import Callable, Any, Optional, List diff --git a/torchvision/models/mobilenetv3.py b/torchvision/models/mobilenetv3.py index 3ac517d0ced..ebe3f510a49 100644 --- a/torchvision/models/mobilenetv3.py +++ b/torchvision/models/mobilenetv3.py @@ -5,7 +5,7 @@ from torch.nn import functional as F from typing import Any, Callable, Dict, List, Optional, Sequence -from torchvision.models.utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from torchvision.models.mobilenetv2 import _make_divisible, ConvBNActivation diff --git a/torchvision/models/quantization/googlenet.py b/torchvision/models/quantization/googlenet.py index 3a74ccd542c..bc1477d8f65 100644 --- a/torchvision/models/quantization/googlenet.py +++ b/torchvision/models/quantization/googlenet.py @@ -3,7 +3,7 @@ import torch.nn as nn from torch.nn import functional as F -from torchvision.models.utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from torchvision.models.googlenet import ( GoogLeNetOutputs, BasicConv2d, Inception, InceptionAux, GoogLeNet, model_urls) diff --git a/torchvision/models/quantization/inception.py b/torchvision/models/quantization/inception.py index 1475cad5eb4..833d8fb8b75 100644 --- a/torchvision/models/quantization/inception.py +++ b/torchvision/models/quantization/inception.py @@ -5,7 +5,7 @@ import torch.nn.functional as F from torchvision.models import inception as inception_module from torchvision.models.inception import InceptionOutputs -from torchvision.models.utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from .utils import _replace_relu, quantize_model diff --git a/torchvision/models/quantization/mobilenetv2.py b/torchvision/models/quantization/mobilenetv2.py index 72c522a2e46..857d919b1fa 100644 --- a/torchvision/models/quantization/mobilenetv2.py +++ b/torchvision/models/quantization/mobilenetv2.py @@ -1,5 +1,5 @@ from torch import nn -from torchvision.models.utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from torchvision.models.mobilenetv2 import InvertedResidual, ConvBNReLU, MobileNetV2, model_urls from torch.quantization import QuantStub, DeQuantStub, fuse_modules from .utils import _replace_relu, quantize_model diff --git a/torchvision/models/quantization/mobilenetv3.py b/torchvision/models/quantization/mobilenetv3.py index fe434f8b297..5462af89127 100644 --- a/torchvision/models/quantization/mobilenetv3.py +++ b/torchvision/models/quantization/mobilenetv3.py @@ -1,6 +1,6 @@ import torch from torch import nn, Tensor -from torchvision.models.utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from torchvision.models.mobilenetv3 import InvertedResidual, InvertedResidualConfig, ConvBNActivation, MobileNetV3,\ SqueezeExcitation, model_urls, _mobilenet_v3_conf from torch.quantization import QuantStub, DeQuantStub, fuse_modules diff --git a/torchvision/models/quantization/resnet.py b/torchvision/models/quantization/resnet.py index f5ac3d0a486..2f3f50e8013 100644 --- a/torchvision/models/quantization/resnet.py +++ b/torchvision/models/quantization/resnet.py @@ -1,7 +1,7 @@ import torch from torchvision.models.resnet import Bottleneck, BasicBlock, ResNet, model_urls import torch.nn as nn -from torchvision.models.utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from torch.quantization import fuse_modules from .utils import _replace_relu, quantize_model diff --git a/torchvision/models/quantization/shufflenetv2.py b/torchvision/models/quantization/shufflenetv2.py index 3f779db3817..17885015772 100644 --- a/torchvision/models/quantization/shufflenetv2.py +++ b/torchvision/models/quantization/shufflenetv2.py @@ -1,6 +1,6 @@ import torch import torch.nn as nn -from torchvision.models.utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url import torchvision.models.shufflenetv2 import sys from .utils import _replace_relu, quantize_model diff --git a/torchvision/models/resnet.py b/torchvision/models/resnet.py index e772650aaaf..6d708767441 100644 --- a/torchvision/models/resnet.py +++ b/torchvision/models/resnet.py @@ -1,7 +1,7 @@ import torch from torch import Tensor import torch.nn as nn -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from typing import Type, Any, Callable, Union, List, Optional diff --git a/torchvision/models/segmentation/segmentation.py b/torchvision/models/segmentation/segmentation.py index 4f328974543..7b3a0258ddb 100644 --- a/torchvision/models/segmentation/segmentation.py +++ b/torchvision/models/segmentation/segmentation.py @@ -1,5 +1,5 @@ from .._utils import IntermediateLayerGetter -from ..utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url from .. import mobilenetv3 from .. import resnet from .deeplabv3 import DeepLabHead, DeepLabV3 diff --git a/torchvision/models/shufflenetv2.py b/torchvision/models/shufflenetv2.py index 9a4333eb10b..65d60a09e6c 100644 --- a/torchvision/models/shufflenetv2.py +++ b/torchvision/models/shufflenetv2.py @@ -1,7 +1,7 @@ import torch from torch import Tensor import torch.nn as nn -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from typing import Callable, Any, List diff --git a/torchvision/models/squeezenet.py b/torchvision/models/squeezenet.py index c4220173d19..c54e475d412 100644 --- a/torchvision/models/squeezenet.py +++ b/torchvision/models/squeezenet.py @@ -1,7 +1,7 @@ import torch import torch.nn as nn import torch.nn.init as init -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from typing import Any __all__ = ['SqueezeNet', 'squeezenet1_0', 'squeezenet1_1'] diff --git a/torchvision/models/utils.py b/torchvision/models/utils.py deleted file mode 100644 index 132ccff2598..00000000000 --- a/torchvision/models/utils.py +++ /dev/null @@ -1,7 +0,0 @@ -# Don't remove this file and don't change the imports of load_state_dict_from_url -# from other files. We need this so that we can swap load_state_dict_from_url with -# a custom internal version in fbcode. -try: - from torch.hub import load_state_dict_from_url -except ImportError: - from torch.utils.model_zoo import load_url as load_state_dict_from_url diff --git a/torchvision/models/vgg.py b/torchvision/models/vgg.py index 9ed73a4868b..619bce97b2f 100644 --- a/torchvision/models/vgg.py +++ b/torchvision/models/vgg.py @@ -1,6 +1,6 @@ import torch import torch.nn as nn -from .utils import load_state_dict_from_url +from .._internally_replaced_utils import load_state_dict_from_url from typing import Union, List, Dict, Any, cast diff --git a/torchvision/models/video/resnet.py b/torchvision/models/video/resnet.py index e60d27c18b2..fc69188ef7a 100644 --- a/torchvision/models/video/resnet.py +++ b/torchvision/models/video/resnet.py @@ -1,6 +1,6 @@ import torch.nn as nn -from ..utils import load_state_dict_from_url +from ..._internally_replaced_utils import load_state_dict_from_url __all__ = ['r3d_18', 'mc3_18', 'r2plus1d_18'] From eb1b9827c7ac03c87063a3e3f8d54401ac544346 Mon Sep 17 00:00:00 2001 From: "Adam J. Stewart" Date: Wed, 23 Jun 2021 03:46:55 -0500 Subject: [PATCH 213/279] Add bzip2 file compression support to datasets (#4097) --- test/test_datasets_utils.py | 25 +++++++++++++++++++++++++ torchvision/datasets/utils.py | 14 ++++++++++++-- 2 files changed, 37 insertions(+), 2 deletions(-) diff --git a/test/test_datasets_utils.py b/test/test_datasets_utils.py index 949026d31cb..9daed110964 100644 --- a/test/test_datasets_utils.py +++ b/test/test_datasets_utils.py @@ -1,3 +1,4 @@ +import bz2 import os import torchvision.datasets.utils as utils import unittest @@ -51,10 +52,14 @@ def test_get_google_drive_file_id_invalid_url(self): def test_detect_file_type(self): for file, expected in [ + ("foo.tar.bz2", (".tar.bz2", ".tar", ".bz2")), ("foo.tar.xz", (".tar.xz", ".tar", ".xz")), ("foo.tar", (".tar", ".tar", None)), ("foo.tar.gz", (".tar.gz", ".tar", ".gz")), + ("foo.tbz", (".tbz", ".tar", ".bz2")), + ("foo.tbz2", (".tbz2", ".tar", ".bz2")), ("foo.tgz", (".tgz", ".tar", ".gz")), + ("foo.bz2", (".bz2", None, ".bz2")), ("foo.gz", (".gz", None, ".gz")), ("foo.zip", (".zip", ".zip", None)), ("foo.xz", (".xz", None, ".xz")), @@ -82,6 +87,26 @@ def test_detect_file_type_unknown_partial_ext(self): with self.assertRaises(RuntimeError): utils._detect_file_type("foo.bar") + def test_decompress_bz2(self): + def create_compressed(root, content="this is the content"): + file = os.path.join(root, "file") + compressed = f"{file}.bz2" + + with bz2.open(compressed, "wb") as fh: + fh.write(content.encode()) + + return compressed, file, content + + with get_tmp_dir() as temp_dir: + compressed, file, content = create_compressed(temp_dir) + + utils._decompress(compressed) + + self.assertTrue(os.path.exists(file)) + + with open(file, "r") as fh: + self.assertEqual(fh.read(), content) + def test_decompress_gzip(self): def create_compressed(root, content="this is the content"): file = os.path.join(root, "file") diff --git a/torchvision/datasets/utils.py b/torchvision/datasets/utils.py index 8e27688ef87..b03b5c48065 100644 --- a/torchvision/datasets/utils.py +++ b/torchvision/datasets/utils.py @@ -1,3 +1,4 @@ +import bz2 import os import os.path import hashlib @@ -262,6 +263,7 @@ def _extract_tar(from_path: str, to_path: str, compression: Optional[str]) -> No _ZIP_COMPRESSION_MAP: Dict[str, int] = { + ".bz2": zipfile.ZIP_BZIP2, ".xz": zipfile.ZIP_LZMA, } @@ -277,8 +279,16 @@ def _extract_zip(from_path: str, to_path: str, compression: Optional[str]) -> No ".tar": _extract_tar, ".zip": _extract_zip, } -_COMPRESSED_FILE_OPENERS: Dict[str, Callable[..., IO]] = {".gz": gzip.open, ".xz": lzma.open} -_FILE_TYPE_ALIASES: Dict[str, Tuple[Optional[str], Optional[str]]] = {".tgz": (".tar", ".gz")} +_COMPRESSED_FILE_OPENERS: Dict[str, Callable[..., IO]] = { + ".bz2": bz2.open, + ".gz": gzip.open, + ".xz": lzma.open, +} +_FILE_TYPE_ALIASES: Dict[str, Tuple[Optional[str], Optional[str]]] = { + ".tbz": (".tar", ".bz2"), + ".tbz2": (".tar", ".bz2"), + ".tgz": (".tar", ".gz"), +} def _verify_archive_type(archive_type: str) -> None: From 850491eb9c3daff887468718bfa1f90f94042d9d Mon Sep 17 00:00:00 2001 From: Sepehr Sameni Date: Wed, 23 Jun 2021 11:20:13 +0200 Subject: [PATCH 214/279] Support single color in utils.draw_bounding_boxes (#4075) --- test/test_utils.py | 12 ++++++++++++ torchvision/utils.py | 11 +++++++---- 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/test/test_utils.py b/test/test_utils.py index d850859d3aa..4c3d71e3776 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -113,6 +113,18 @@ def test_draw_boxes(): assert_equal(img, img_cp) +@pytest.mark.parametrize('colors', [ + None, + ['red', 'blue', '#FF00FF', (1, 34, 122)], + 'red', + '#FF00FF', + (1, 34, 122) +]) +def test_draw_boxes_colors(colors): + img = torch.full((3, 100, 100), 0, dtype=torch.uint8) + utils.draw_bounding_boxes(img, boxes, fill=False, width=7, colors=colors) + + def test_draw_boxes_vanilla(): img = torch.full((3, 100, 100), 0, dtype=torch.uint8) img_cp = img.clone() diff --git a/torchvision/utils.py b/torchvision/utils.py index 72be25403a8..494661e6ad8 100644 --- a/torchvision/utils.py +++ b/torchvision/utils.py @@ -141,7 +141,7 @@ def draw_bounding_boxes( image: torch.Tensor, boxes: torch.Tensor, labels: Optional[List[str]] = None, - colors: Optional[List[Union[str, Tuple[int, int, int]]]] = None, + colors: Optional[Union[List[Union[str, Tuple[int, int, int]]], str, Tuple[int, int, int]]] = None, fill: Optional[bool] = False, width: int = 1, font: Optional[str] = None, @@ -159,8 +159,9 @@ def draw_bounding_boxes( the boxes are absolute coordinates with respect to the image. In other words: `0 <= xmin < xmax < W` and `0 <= ymin < ymax < H`. labels (List[str]): List containing the labels of bounding boxes. - colors (List[Union[str, Tuple[int, int, int]]]): List containing the colors of bounding boxes. The colors can - be represented as `str` or `Tuple[int, int, int]`. + colors (Union[List[Union[str, Tuple[int, int, int]]], str, Tuple[int, int, int]]): List containing the colors + or a single color for all of the bounding boxes. The colors can be represented as `str` or + `Tuple[int, int, int]`. fill (bool): If `True` fills the bounding box with specified color. width (int): Width of bounding box. font (str): A filename containing a TrueType font. If the file is not found in this filename, the loader may @@ -200,8 +201,10 @@ def draw_bounding_boxes( for i, bbox in enumerate(img_boxes): if colors is None: color = None - else: + elif isinstance(colors, list): color = colors[i] + else: + color = colors if fill: if color is None: From d1ab583d0d2df73208e2fc9c4d3a84e969c69b70 Mon Sep 17 00:00:00 2001 From: "Adam J. Stewart" Date: Wed, 23 Jun 2021 10:33:07 -0500 Subject: [PATCH 215/279] Add support for files with periods in name (#4099) --- test/test_datasets_utils.py | 11 ++------ torchvision/datasets/utils.py | 52 ++++++++++++++++------------------- 2 files changed, 26 insertions(+), 37 deletions(-) diff --git a/test/test_datasets_utils.py b/test/test_datasets_utils.py index 9daed110964..d89eced1241 100644 --- a/test/test_datasets_utils.py +++ b/test/test_datasets_utils.py @@ -63,6 +63,9 @@ def test_detect_file_type(self): ("foo.gz", (".gz", None, ".gz")), ("foo.zip", (".zip", ".zip", None)), ("foo.xz", (".xz", None, ".xz")), + ("foo.bar.tar.gz", (".tar.gz", ".tar", ".gz")), + ("foo.bar.gz", (".gz", None, ".gz")), + ("foo.bar.zip", (".zip", ".zip", None)), ]: with self.subTest(file=file): self.assertSequenceEqual(utils._detect_file_type(file), expected) @@ -71,14 +74,6 @@ def test_detect_file_type_no_ext(self): with self.assertRaises(RuntimeError): utils._detect_file_type("foo") - def test_detect_file_type_to_many_exts(self): - with self.assertRaises(RuntimeError): - utils._detect_file_type("foo.bar.tar.gz") - - def test_detect_file_type_unknown_archive_type(self): - with self.assertRaises(RuntimeError): - utils._detect_file_type("foo.bar.gz") - def test_detect_file_type_unknown_compression(self): with self.assertRaises(RuntimeError): utils._detect_file_type("foo.tar.baz") diff --git a/torchvision/datasets/utils.py b/torchvision/datasets/utils.py index b03b5c48065..45aca08e13b 100644 --- a/torchvision/datasets/utils.py +++ b/torchvision/datasets/utils.py @@ -291,53 +291,47 @@ def _extract_zip(from_path: str, to_path: str, compression: Optional[str]) -> No } -def _verify_archive_type(archive_type: str) -> None: - if archive_type not in _ARCHIVE_EXTRACTORS.keys(): - valid_types = "', '".join(_ARCHIVE_EXTRACTORS.keys()) - raise RuntimeError(f"Unknown archive type '{archive_type}'. Known archive types are '{valid_types}'.") - +def _detect_file_type(file: str) -> Tuple[str, Optional[str], Optional[str]]: + """Detect the archive type and/or compression of a file. -def _verify_compression(compression: str) -> None: - if compression not in _COMPRESSED_FILE_OPENERS.keys(): - valid_types = "', '".join(_COMPRESSED_FILE_OPENERS.keys()) - raise RuntimeError(f"Unknown compression '{compression}'. Known compressions are '{valid_types}'.") + Args: + file (str): the filename + Returns: + (tuple): tuple of suffix, archive type, and compression -def _detect_file_type(file: str) -> Tuple[str, Optional[str], Optional[str]]: - path = pathlib.Path(file) - suffix = path.suffix + Raises: + RuntimeError: if file has no suffix or suffix is not supported + """ suffixes = pathlib.Path(file).suffixes if not suffixes: raise RuntimeError( f"File '{file}' has no suffixes that could be used to detect the archive type and compression." ) - elif len(suffixes) > 2: - raise RuntimeError( - "Archive type and compression detection only works for 1 or 2 suffixes. " f"Got {len(suffixes)} instead." - ) - elif len(suffixes) == 2: - # if we have exactly two suffixes we assume the first one is the archive type and the second on is the - # compression - archive_type, compression = suffixes - _verify_archive_type(archive_type) - _verify_compression(compression) - return "".join(suffixes), archive_type, compression + suffix = suffixes[-1] # check if the suffix is a known alias - with contextlib.suppress(KeyError): + if suffix in _FILE_TYPE_ALIASES: return (suffix, *_FILE_TYPE_ALIASES[suffix]) # check if the suffix is an archive type - with contextlib.suppress(RuntimeError): - _verify_archive_type(suffix) + if suffix in _ARCHIVE_EXTRACTORS: return suffix, suffix, None # check if the suffix is a compression - with contextlib.suppress(RuntimeError): - _verify_compression(suffix) + if suffix in _COMPRESSED_FILE_OPENERS: + # check for suffix hierarchy + if len(suffixes) > 1: + suffix2 = suffixes[-2] + + # check if the suffix2 is an archive type + if suffix2 in _ARCHIVE_EXTRACTORS: + return suffix2 + suffix, suffix2, suffix + return suffix, None, suffix - raise RuntimeError(f"Suffix '{suffix}' is neither recognized as archive type nor as compression.") + valid_suffixes = sorted(set(_FILE_TYPE_ALIASES) | set(_ARCHIVE_EXTRACTORS) | set(_COMPRESSED_FILE_OPENERS)) + raise RuntimeError(f"Unknown compression or archive type: '{suffix}'.\nKnown suffixes are: '{valid_suffixes}'.") def _decompress(from_path: str, to_path: Optional[str] = None, remove_finished: bool = False) -> str: From 959666891589c35e6d225943253f523cffbae4cc Mon Sep 17 00:00:00 2001 From: cyy Date: Thu, 24 Jun 2021 17:51:05 +0800 Subject: [PATCH 216/279] Raise proper error when decoding 16-bits jpegs (#4101) --- torchvision/csrc/io/image/cpu/decode_png.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/torchvision/csrc/io/image/cpu/decode_png.cpp b/torchvision/csrc/io/image/cpu/decode_png.cpp index 315ed611614..b40fd951d5b 100644 --- a/torchvision/csrc/io/image/cpu/decode_png.cpp +++ b/torchvision/csrc/io/image/cpu/decode_png.cpp @@ -71,6 +71,11 @@ torch::Tensor decode_png(const torch::Tensor& data, ImageReadMode mode) { TORCH_CHECK(retval == 1, "Could read image metadata from content.") } + if (bit_depth > 8) { + png_destroy_read_struct(&png_ptr, &info_ptr, nullptr); + TORCH_CHECK(false, "At most 8-bit PNG images are supported currently.") + } + int channels = png_get_channels(png_ptr, info_ptr); if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) From ab60e538961e4bb25e7d8db44a4d0d96155e3644 Mon Sep 17 00:00:00 2001 From: ORippler Date: Thu, 24 Jun 2021 18:44:28 +0200 Subject: [PATCH 217/279] Fix download from google drive which was downloading empty files in some cases (#4109) --- torchvision/datasets/utils.py | 30 ++++++++++++++++++++---------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/torchvision/datasets/utils.py b/torchvision/datasets/utils.py index 45aca08e13b..9ae726edd8f 100644 --- a/torchvision/datasets/utils.py +++ b/torchvision/datasets/utils.py @@ -5,15 +5,15 @@ import gzip import re import tarfile -from typing import Any, Callable, List, Iterable, Optional, TypeVar, Dict, IO, Tuple +from typing import Any, Callable, List, Iterable, Optional, TypeVar, Dict, IO, Tuple, Iterator from urllib.parse import urlparse import zipfile import lzma -import contextlib import urllib import urllib.request import urllib.error import pathlib +import itertools import torch from torch.utils.model_zoo import tqdm @@ -184,11 +184,10 @@ def list_files(root: str, suffix: str, prefix: bool = False) -> List[str]: return files -def _quota_exceeded(response: "requests.models.Response") -> bool: # type: ignore[name-defined] +def _quota_exceeded(first_chunk: bytes) -> bool: # type: ignore[name-defined] try: - start = next(response.iter_content(chunk_size=128, decode_unicode=True)) - return isinstance(start, str) and "Google Drive - Quota exceeded" in start - except StopIteration: + return "Google Drive - Quota exceeded" in first_chunk.decode() + except UnicodeDecodeError: return False @@ -224,7 +223,16 @@ def download_file_from_google_drive(file_id: str, root: str, filename: Optional[ params = {'id': file_id, 'confirm': token} response = session.get(url, params=params, stream=True) - if _quota_exceeded(response): + # Ideally, one would use response.status_code to check for quota limits, but google drive is not consistent + # with their own API, refer https://github.com/pytorch/vision/issues/2992#issuecomment-730614517. + # Should this be fixed at some place in future, one could refactor the following to no longer rely on decoding + # the first_chunk of the payload + response_content_generator = response.iter_content(32768) + first_chunk = None + while not first_chunk: # filter out keep-alive new chunks + first_chunk = next(response_content_generator) + + if _quota_exceeded(first_chunk): msg = ( f"The daily quota of the file {filename} is exceeded and it " f"can't be downloaded. This is a limitation of Google Drive " @@ -232,7 +240,8 @@ def download_file_from_google_drive(file_id: str, root: str, filename: Optional[ ) raise RuntimeError(msg) - _save_response_content(response, fpath) + _save_response_content(itertools.chain((first_chunk, ), response_content_generator), fpath) + response.close() def _get_confirm_token(response: "requests.models.Response") -> Optional[str]: # type: ignore[name-defined] @@ -244,12 +253,13 @@ def _get_confirm_token(response: "requests.models.Response") -> Optional[str]: def _save_response_content( - response: "requests.models.Response", destination: str, chunk_size: int = 32768, # type: ignore[name-defined] + response_gen: Iterator[bytes], destination: str, # type: ignore[name-defined] ) -> None: with open(destination, "wb") as f: pbar = tqdm(total=None) progress = 0 - for chunk in response.iter_content(chunk_size): + + for chunk in response_gen: if chunk: # filter out keep-alive new chunks f.write(chunk) progress += len(chunk) From b3b5137777fe478d57fcb8d61b5da6e1fd7f0ffb Mon Sep 17 00:00:00 2001 From: Anirudh Date: Fri, 25 Jun 2021 16:47:32 +0530 Subject: [PATCH 218/279] Port test_datasets_utils to pytest (#4114) --- test/common_utils.py | 17 --- test/test_datasets_utils.py | 211 ++++++++++++------------------------ 2 files changed, 69 insertions(+), 159 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index 06e0e16b1ef..3f8ad8a7f55 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -240,23 +240,6 @@ def disable_console_output(): yield -def call_args_to_kwargs_only(call_args, *callable_or_arg_names): - callable_or_arg_name = callable_or_arg_names[0] - if callable(callable_or_arg_name): - argspec = inspect.getfullargspec(callable_or_arg_name) - arg_names = argspec.args - if isinstance(callable_or_arg_name, type): - # remove self - arg_names.pop(0) - else: - arg_names = callable_or_arg_names - - args, kwargs = call_args - kwargs_only = kwargs.copy() - kwargs_only.update(dict(zip(arg_names, args))) - return kwargs_only - - def cpu_and_gpu(): import pytest # noqa return ('cpu', pytest.param('cuda', marks=pytest.mark.needs_cuda)) diff --git a/test/test_datasets_utils.py b/test/test_datasets_utils.py index d89eced1241..34ca3da6847 100644 --- a/test/test_datasets_utils.py +++ b/test/test_datasets_utils.py @@ -1,8 +1,7 @@ import bz2 import os import torchvision.datasets.utils as utils -import unittest -import unittest.mock +import pytest import zipfile import tarfile import gzip @@ -12,31 +11,32 @@ import itertools import lzma -from common_utils import get_tmp_dir, call_args_to_kwargs_only +from common_utils import get_tmp_dir +from torchvision.datasets.utils import _COMPRESSED_FILE_OPENERS TEST_FILE = get_file_path_2( os.path.dirname(os.path.abspath(__file__)), 'assets', 'encode_jpeg', 'grace_hopper_517x606.jpg') -class Tester(unittest.TestCase): +class TestDatasetsUtils: def test_check_md5(self): fpath = TEST_FILE correct_md5 = '9c0bb82894bb3af7f7675ef2b3b6dcdc' false_md5 = '' - self.assertTrue(utils.check_md5(fpath, correct_md5)) - self.assertFalse(utils.check_md5(fpath, false_md5)) + assert utils.check_md5(fpath, correct_md5) + assert not utils.check_md5(fpath, false_md5) def test_check_integrity(self): existing_fpath = TEST_FILE nonexisting_fpath = '' correct_md5 = '9c0bb82894bb3af7f7675ef2b3b6dcdc' false_md5 = '' - self.assertTrue(utils.check_integrity(existing_fpath, correct_md5)) - self.assertFalse(utils.check_integrity(existing_fpath, false_md5)) - self.assertTrue(utils.check_integrity(existing_fpath)) - self.assertFalse(utils.check_integrity(nonexisting_fpath)) + assert utils.check_integrity(existing_fpath, correct_md5) + assert not utils.check_integrity(existing_fpath, false_md5) + assert utils.check_integrity(existing_fpath) + assert not utils.check_integrity(nonexisting_fpath) def test_get_google_drive_file_id(self): url = "https://drive.google.com/file/d/1hbzc_P1FuxMkcabkgn9ZKinBwW683j45/view" @@ -50,44 +50,38 @@ def test_get_google_drive_file_id_invalid_url(self): assert utils._get_google_drive_file_id(url) is None - def test_detect_file_type(self): - for file, expected in [ - ("foo.tar.bz2", (".tar.bz2", ".tar", ".bz2")), - ("foo.tar.xz", (".tar.xz", ".tar", ".xz")), - ("foo.tar", (".tar", ".tar", None)), - ("foo.tar.gz", (".tar.gz", ".tar", ".gz")), - ("foo.tbz", (".tbz", ".tar", ".bz2")), - ("foo.tbz2", (".tbz2", ".tar", ".bz2")), - ("foo.tgz", (".tgz", ".tar", ".gz")), - ("foo.bz2", (".bz2", None, ".bz2")), - ("foo.gz", (".gz", None, ".gz")), - ("foo.zip", (".zip", ".zip", None)), - ("foo.xz", (".xz", None, ".xz")), - ("foo.bar.tar.gz", (".tar.gz", ".tar", ".gz")), - ("foo.bar.gz", (".gz", None, ".gz")), - ("foo.bar.zip", (".zip", ".zip", None)), - ]: - with self.subTest(file=file): - self.assertSequenceEqual(utils._detect_file_type(file), expected) - - def test_detect_file_type_no_ext(self): - with self.assertRaises(RuntimeError): - utils._detect_file_type("foo") - - def test_detect_file_type_unknown_compression(self): - with self.assertRaises(RuntimeError): - utils._detect_file_type("foo.tar.baz") - - def test_detect_file_type_unknown_partial_ext(self): - with self.assertRaises(RuntimeError): - utils._detect_file_type("foo.bar") - - def test_decompress_bz2(self): + @pytest.mark.parametrize('file, expected', [ + ("foo.tar.bz2", (".tar.bz2", ".tar", ".bz2")), + ("foo.tar.xz", (".tar.xz", ".tar", ".xz")), + ("foo.tar", (".tar", ".tar", None)), + ("foo.tar.gz", (".tar.gz", ".tar", ".gz")), + ("foo.tbz", (".tbz", ".tar", ".bz2")), + ("foo.tbz2", (".tbz2", ".tar", ".bz2")), + ("foo.tgz", (".tgz", ".tar", ".gz")), + ("foo.bz2", (".bz2", None, ".bz2")), + ("foo.gz", (".gz", None, ".gz")), + ("foo.zip", (".zip", ".zip", None)), + ("foo.xz", (".xz", None, ".xz")), + ("foo.bar.tar.gz", (".tar.gz", ".tar", ".gz")), + ("foo.bar.gz", (".gz", None, ".gz")), + ("foo.bar.zip", (".zip", ".zip", None))]) + def test_detect_file_type(self, file, expected): + assert utils._detect_file_type(file) == expected + + @pytest.mark.parametrize('file', ["foo", "foo.tar.baz", "foo.bar"]) + def test_detect_file_type_incompatible(self, file): + # tests detect file type for no extension, unknown compression and unknown partial extension + with pytest.raises(RuntimeError): + utils._detect_file_type(file) + + @pytest.mark.parametrize('extension', [".bz2", ".gz", ".xz"]) + def test_decompress(self, extension): def create_compressed(root, content="this is the content"): file = os.path.join(root, "file") - compressed = f"{file}.bz2" + compressed = f"{file}{extension}" + compressed_file_opener = _COMPRESSED_FILE_OPENERS[extension] - with bz2.open(compressed, "wb") as fh: + with compressed_file_opener(compressed, "wb") as fh: fh.write(content.encode()) return compressed, file, content @@ -97,53 +91,13 @@ def create_compressed(root, content="this is the content"): utils._decompress(compressed) - self.assertTrue(os.path.exists(file)) + assert os.path.exists(file) with open(file, "r") as fh: - self.assertEqual(fh.read(), content) - - def test_decompress_gzip(self): - def create_compressed(root, content="this is the content"): - file = os.path.join(root, "file") - compressed = f"{file}.gz" - - with gzip.open(compressed, "wb") as fh: - fh.write(content.encode()) - - return compressed, file, content - - with get_tmp_dir() as temp_dir: - compressed, file, content = create_compressed(temp_dir) - - utils._decompress(compressed) - - self.assertTrue(os.path.exists(file)) - - with open(file, "r") as fh: - self.assertEqual(fh.read(), content) - - def test_decompress_lzma(self): - def create_compressed(root, content="this is the content"): - file = os.path.join(root, "file") - compressed = f"{file}.xz" - - with lzma.open(compressed, "wb") as fh: - fh.write(content.encode()) - - return compressed, file, content - - with get_tmp_dir() as temp_dir: - compressed, file, content = create_compressed(temp_dir) - - utils.extract_archive(compressed, temp_dir) - - self.assertTrue(os.path.exists(file)) - - with open(file, "r") as fh: - self.assertEqual(fh.read(), content) + assert fh.read() == content def test_decompress_no_compression(self): - with self.assertRaises(RuntimeError): + with pytest.raises(RuntimeError): utils._decompress("foo.tar") def test_decompress_remove_finished(self): @@ -161,21 +115,18 @@ def create_compressed(root, content="this is the content"): utils.extract_archive(compressed, temp_dir, remove_finished=True) - self.assertFalse(os.path.exists(compressed)) + assert not os.path.exists(compressed) - def test_extract_archive_defer_to_decompress(self): + @pytest.mark.parametrize('extension', [".gz", ".xz"]) + @pytest.mark.parametrize('remove_finished', [True, False]) + def test_extract_archive_defer_to_decompress(self, extension, remove_finished, mocker): filename = "foo" - for ext, remove_finished in itertools.product((".gz", ".xz"), (True, False)): - with self.subTest(ext=ext, remove_finished=remove_finished): - with unittest.mock.patch("torchvision.datasets.utils._decompress") as mock: - file = f"{filename}{ext}" - utils.extract_archive(file, remove_finished=remove_finished) - - mock.assert_called_once() - self.assertEqual( - call_args_to_kwargs_only(mock.call_args, utils._decompress), - dict(from_path=file, to_path=filename, remove_finished=remove_finished), - ) + file = f"{filename}{extension}" + + mocked = mocker.patch("torchvision.datasets.utils._decompress") + utils.extract_archive(file, remove_finished=remove_finished) + + mocked.assert_called_once_with(file, filename, remove_finished=remove_finished) def test_extract_zip(self): def create_archive(root, content="this is the content"): @@ -192,16 +143,18 @@ def create_archive(root, content="this is the content"): utils.extract_archive(archive, temp_dir) - self.assertTrue(os.path.exists(file)) + assert os.path.exists(file) with open(file, "r") as fh: - self.assertEqual(fh.read(), content) + assert fh.read() == content - def test_extract_tar(self): - def create_archive(root, ext, mode, content="this is the content"): + @pytest.mark.parametrize('extension, mode', [ + ('.tar', 'w'), ('.tar.gz', 'w:gz'), ('.tgz', 'w:gz'), ('.tar.xz', 'w:xz')]) + def test_extract_tar(self, extension, mode): + def create_archive(root, extension, mode, content="this is the content"): src = os.path.join(root, "src.txt") dst = os.path.join(root, "dst.txt") - archive = os.path.join(root, f"archive{ext}") + archive = os.path.join(root, f"archive{extension}") with open(src, "w") as fh: fh.write(content) @@ -211,47 +164,21 @@ def create_archive(root, ext, mode, content="this is the content"): return archive, dst, content - for ext, mode in zip(['.tar', '.tar.gz', '.tgz'], ['w', 'w:gz', 'w:gz']): - with get_tmp_dir() as temp_dir: - archive, file, content = create_archive(temp_dir, ext, mode) - - utils.extract_archive(archive, temp_dir) - - self.assertTrue(os.path.exists(file)) - - with open(file, "r") as fh: - self.assertEqual(fh.read(), content) - - def test_extract_tar_xz(self): - def create_archive(root, ext, mode, content="this is the content"): - src = os.path.join(root, "src.txt") - dst = os.path.join(root, "dst.txt") - archive = os.path.join(root, f"archive{ext}") - - with open(src, "w") as fh: - fh.write(content) - - with tarfile.open(archive, mode=mode) as fh: - fh.add(src, arcname=os.path.basename(dst)) - - return archive, dst, content - - for ext, mode in zip(['.tar.xz'], ['w:xz']): - with get_tmp_dir() as temp_dir: - archive, file, content = create_archive(temp_dir, ext, mode) + with get_tmp_dir() as temp_dir: + archive, file, content = create_archive(temp_dir, extension, mode) - utils.extract_archive(archive, temp_dir) + utils.extract_archive(archive, temp_dir) - self.assertTrue(os.path.exists(file)) + assert os.path.exists(file) - with open(file, "r") as fh: - self.assertEqual(fh.read(), content) + with open(file, "r") as fh: + assert fh.read() == content def test_verify_str_arg(self): - self.assertEqual("a", utils.verify_str_arg("a", "arg", ("a",))) - self.assertRaises(ValueError, utils.verify_str_arg, 0, ("a",), "arg") - self.assertRaises(ValueError, utils.verify_str_arg, "b", ("a",), "arg") + assert "a" == utils.verify_str_arg("a", "arg", ("a",)) + pytest.raises(ValueError, utils.verify_str_arg, 0, ("a",), "arg") + pytest.raises(ValueError, utils.verify_str_arg, "b", ("a",), "arg") if __name__ == '__main__': - unittest.main() + pytest.main([__file__]) From d9633fc940faabdd73eb61232011a22de9095ca0 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 25 Jun 2021 15:51:50 +0100 Subject: [PATCH 219/279] Fix failing tests by catching the proper exception from torch.testing (#4121) --- test/test_models.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_models.py b/test/test_models.py index d40b72e55ff..eb8245f3ad4 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -108,7 +108,7 @@ def get_export_import_copy(m): tol = 3e-4 try: torch.testing.assert_close(results, results_from_imported, atol=tol, rtol=tol) - except pytest.UsageError: + except torch.testing._asserts.UsageError: # custom check for the models that return named tuples: # we compare field by field while ignoring None as assert_close can't handle None for a, b in zip(results, results_from_imported): From d16a192041a1122424dc3baf67075547ff219ddf Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 28 Jun 2021 12:15:24 +0100 Subject: [PATCH 220/279] [FBcode->GH] Remove torchvision/test/fakedata_generation.py (#4130) --- test/fakedata_generation.py | 208 ------------------------------------ 1 file changed, 208 deletions(-) delete mode 100644 test/fakedata_generation.py diff --git a/test/fakedata_generation.py b/test/fakedata_generation.py deleted file mode 100644 index 8540410351e..00000000000 --- a/test/fakedata_generation.py +++ /dev/null @@ -1,208 +0,0 @@ -import os -import contextlib -import hashlib -import pickle -import re -import tarfile -import unittest.mock -from distutils import dir_util - -import numpy as np -import PIL -import torch - -from common_utils import get_tmp_dir - - -def mock_class_attribute(stack, target, new): - mock = unittest.mock.patch(target, new_callable=unittest.mock.PropertyMock, return_value=new) - stack.enter_context(mock) - return mock - - -def compute_md5(file): - with open(file, "rb") as fh: - return hashlib.md5(fh.read()).hexdigest() - - -def make_tar(root, name, *files, compression=None): - ext = ".tar" - mode = "w" - if compression is not None: - ext = f"{ext}.{compression}" - mode = f"{mode}:{compression}" - - name = os.path.splitext(name)[0] + ext - archive = os.path.join(root, name) - - with tarfile.open(archive, mode) as fh: - for file in files: - fh.add(os.path.join(root, file), arcname=file) - - return name, compute_md5(archive) - - -def clean_dir(root, *keep): - pattern = re.compile(f"({f')|('.join(keep)})") - for file_or_dir in os.listdir(root): - if pattern.search(file_or_dir): - continue - - file_or_dir = os.path.join(root, file_or_dir) - if os.path.isfile(file_or_dir): - os.remove(file_or_dir) - else: - dir_util.remove_tree(file_or_dir) - - -@contextlib.contextmanager -def mnist_root(num_images, cls_name): - def _encode(v): - return torch.tensor(v, dtype=torch.int32).numpy().tobytes()[::-1] - - def _make_image_file(filename, num_images): - img = torch.randint(0, 256, size=(28 * 28 * num_images,), dtype=torch.uint8) - with open(filename, "wb") as f: - f.write(_encode(2051)) # magic header - f.write(_encode(num_images)) - f.write(_encode(28)) - f.write(_encode(28)) - f.write(img.numpy().tobytes()) - - def _make_label_file(filename, num_images): - labels = torch.zeros((num_images,), dtype=torch.uint8) - with open(filename, "wb") as f: - f.write(_encode(2049)) # magic header - f.write(_encode(num_images)) - f.write(labels.numpy().tobytes()) - - with get_tmp_dir() as tmp_dir: - raw_dir = os.path.join(tmp_dir, cls_name, "raw") - os.makedirs(raw_dir) - _make_image_file(os.path.join(raw_dir, "train-images-idx3-ubyte"), num_images) - _make_label_file(os.path.join(raw_dir, "train-labels-idx1-ubyte"), num_images) - _make_image_file(os.path.join(raw_dir, "t10k-images-idx3-ubyte"), num_images) - _make_label_file(os.path.join(raw_dir, "t10k-labels-idx1-ubyte"), num_images) - yield tmp_dir - - -@contextlib.contextmanager -def cifar_root(version): - def _get_version_params(version): - if version == 'CIFAR10': - return { - 'base_folder': 'cifar-10-batches-py', - 'train_files': ['data_batch_{}'.format(batch) for batch in range(1, 6)], - 'test_file': 'test_batch', - 'target_key': 'labels', - 'meta_file': 'batches.meta', - 'classes_key': 'label_names', - } - elif version == 'CIFAR100': - return { - 'base_folder': 'cifar-100-python', - 'train_files': ['train'], - 'test_file': 'test', - 'target_key': 'fine_labels', - 'meta_file': 'meta', - 'classes_key': 'fine_label_names', - } - else: - raise ValueError - - def _make_pickled_file(obj, file): - with open(file, 'wb') as fh: - pickle.dump(obj, fh, 2) - - def _make_data_file(file, target_key): - obj = { - 'data': np.zeros((1, 32 * 32 * 3), dtype=np.uint8), - target_key: [0] - } - _make_pickled_file(obj, file) - - def _make_meta_file(file, classes_key): - obj = { - classes_key: ['fakedata'], - } - _make_pickled_file(obj, file) - - params = _get_version_params(version) - with get_tmp_dir() as root: - base_folder = os.path.join(root, params['base_folder']) - os.mkdir(base_folder) - - for file in list(params['train_files']) + [params['test_file']]: - _make_data_file(os.path.join(base_folder, file), params['target_key']) - - _make_meta_file(os.path.join(base_folder, params['meta_file']), - params['classes_key']) - - yield root - - -@contextlib.contextmanager -def widerface_root(): - """ - Generates a dataset with the following folder structure and returns the path root: - - └── widerface - ├── wider_face_split - ├── WIDER_train - ├── WIDER_val - └── WIDER_test - - The dataset consist of - 1 image for each dataset split (train, val, test) and annotation files - for each split - """ - - def _make_image(file): - PIL.Image.fromarray(np.zeros((32, 32, 3), dtype=np.uint8)).save(file) - - def _make_train_archive(root): - extracted_dir = os.path.join(root, 'WIDER_train', 'images', '0--Parade') - os.makedirs(extracted_dir) - _make_image(os.path.join(extracted_dir, '0_Parade_marchingband_1_1.jpg')) - - def _make_val_archive(root): - extracted_dir = os.path.join(root, 'WIDER_val', 'images', '0--Parade') - os.makedirs(extracted_dir) - _make_image(os.path.join(extracted_dir, '0_Parade_marchingband_1_2.jpg')) - - def _make_test_archive(root): - extracted_dir = os.path.join(root, 'WIDER_test', 'images', '0--Parade') - os.makedirs(extracted_dir) - _make_image(os.path.join(extracted_dir, '0_Parade_marchingband_1_3.jpg')) - - def _make_annotations_archive(root): - train_bbox_contents = '0--Parade/0_Parade_marchingband_1_1.jpg\n1\n449 330 122 149 0 0 0 0 0 0\n' - val_bbox_contents = '0--Parade/0_Parade_marchingband_1_2.jpg\n1\n501 160 285 443 0 0 0 0 0 0\n' - test_filelist_contents = '0--Parade/0_Parade_marchingband_1_3.jpg\n' - extracted_dir = os.path.join(root, 'wider_face_split') - os.mkdir(extracted_dir) - - # bbox training file - bbox_file = os.path.join(extracted_dir, "wider_face_train_bbx_gt.txt") - with open(bbox_file, "w") as txt_file: - txt_file.write(train_bbox_contents) - - # bbox validation file - bbox_file = os.path.join(extracted_dir, "wider_face_val_bbx_gt.txt") - with open(bbox_file, "w") as txt_file: - txt_file.write(val_bbox_contents) - - # test filelist file - filelist_file = os.path.join(extracted_dir, "wider_face_test_filelist.txt") - with open(filelist_file, "w") as txt_file: - txt_file.write(test_filelist_contents) - - with get_tmp_dir() as root: - root_base = os.path.join(root, "widerface") - os.mkdir(root_base) - _make_train_archive(root_base) - _make_val_archive(root_base) - _make_test_archive(root_base) - _make_annotations_archive(root_base) - - yield root From 1962fddb116f697d7059fd11c2f204839460b214 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Mon, 28 Jun 2021 15:34:11 +0100 Subject: [PATCH 221/279] Add check for fx compatibility on segmentation and video models (#4131) * Add check for fx compatibility on segmentation models. * Add fx check on video models. --- test/test_models.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/test_models.py b/test/test_models.py index eb8245f3ad4..ee4af8bef58 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -466,6 +466,7 @@ def check_out(out): full_validation = check_out(out) _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(model_name, None)) + _check_fx_compatible(model, x) if dev == torch.device("cuda"): with torch.cuda.amp.autocast(): @@ -616,6 +617,7 @@ def test_video_model(model_name, dev): x = torch.rand(input_shape).to(device=dev) out = model(x) _check_jit_scriptable(model, (x,), unwrapper=script_model_unwrapper.get(model_name, None)) + _check_fx_compatible(model, x) assert out.shape[-1] == 50 if dev == torch.device("cuda"): From 3e7653c8c4b5eb0c854251a0fb86be18de55bc68 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Mon, 28 Jun 2021 15:51:00 +0100 Subject: [PATCH 222/279] Fix documentation for SSD and RetinaNet. (#4132) --- torchvision/models/detection/retinanet.py | 2 +- torchvision/models/detection/ssd.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/torchvision/models/detection/retinanet.py b/torchvision/models/detection/retinanet.py index aab7daa828a..4dd95285dbc 100644 --- a/torchvision/models/detection/retinanet.py +++ b/torchvision/models/detection/retinanet.py @@ -256,7 +256,7 @@ class RetinaNet(nn.Module): It should contain an out_channels attribute, which indicates the number of output channels that each feature map has (and it should be the same for all feature maps). The backbone should return a single Tensor or an OrderedDict[Tensor]. - num_classes (int): number of output classes of the model (excluding the background). + num_classes (int): number of output classes of the model (including the background). min_size (int): minimum size of the image to be rescaled before feeding it to the backbone max_size (int): maximum size of the image to be rescaled before feeding it to the backbone image_mean (Tuple[float, float, float]): mean values used for input normalization. diff --git a/torchvision/models/detection/ssd.py b/torchvision/models/detection/ssd.py index 3589dd45f4c..e67c4930b30 100644 --- a/torchvision/models/detection/ssd.py +++ b/torchvision/models/detection/ssd.py @@ -141,7 +141,7 @@ class SSD(nn.Module): set of feature maps. size (Tuple[int, int]): the width and height to which images will be rescaled before feeding them to the backbone. - num_classes (int): number of output classes of the model (excluding the background). + num_classes (int): number of output classes of the model (including the background). image_mean (Tuple[float, float, float]): mean values used for input normalization. They are generally the mean values of the dataset on which the backbone has been trained on From 4a3b9472e480eb96903516f696230244175219ee Mon Sep 17 00:00:00 2001 From: cyy Date: Mon, 28 Jun 2021 23:23:11 +0800 Subject: [PATCH 223/279] use from_blob to avoid memcpy (#4118) Co-authored-by: Nicolas Hug Co-authored-by: Vasilis Vryniotis --- torchvision/csrc/io/image/cpu/encode_jpeg.cpp | 22 +++++++------------ 1 file changed, 8 insertions(+), 14 deletions(-) diff --git a/torchvision/csrc/io/image/cpu/encode_jpeg.cpp b/torchvision/csrc/io/image/cpu/encode_jpeg.cpp index c84ad37005d..1ba730f0998 100644 --- a/torchvision/csrc/io/image/cpu/encode_jpeg.cpp +++ b/torchvision/csrc/io/image/cpu/encode_jpeg.cpp @@ -18,12 +18,12 @@ using namespace detail; torch::Tensor encode_jpeg(const torch::Tensor& data, int64_t quality) { // Define compression structures and error handling - struct jpeg_compress_struct cinfo; - struct torch_jpeg_error_mgr jerr; + struct jpeg_compress_struct cinfo {}; + struct torch_jpeg_error_mgr jerr {}; // Define buffer to write JPEG information to and its size unsigned long jpegSize = 0; - uint8_t* jpegBuf = NULL; + uint8_t* jpegBuf = nullptr; cinfo.err = jpeg_std_error(&jerr.pub); jerr.pub.error_exit = torch_jpeg_error_exit; @@ -34,7 +34,7 @@ torch::Tensor encode_jpeg(const torch::Tensor& data, int64_t quality) { * We need to clean up the JPEG object and the buffer. */ jpeg_destroy_compress(&cinfo); - if (jpegBuf != NULL) { + if (jpegBuf != nullptr) { free(jpegBuf); } @@ -92,16 +92,10 @@ torch::Tensor encode_jpeg(const torch::Tensor& data, int64_t quality) { jpeg_destroy_compress(&cinfo); torch::TensorOptions options = torch::TensorOptions{torch::kU8}; - auto outTensor = torch::empty({(long)jpegSize}, options); - - // Copy memory from jpeg buffer, since torch cannot get ownership of it via - // `from_blob` - auto outPtr = outTensor.data_ptr(); - std::memcpy(outPtr, jpegBuf, sizeof(uint8_t) * outTensor.numel()); - - free(jpegBuf); - - return outTensor; + auto out_tensor = + torch::from_blob(jpegBuf, {(long)jpegSize}, ::free, options); + jpegBuf = nullptr; + return out_tensor; } #endif From a83b9a17e441e6d77e9d59ca14d75fb5ba8c31f6 Mon Sep 17 00:00:00 2001 From: "Adam J. Stewart" Date: Tue, 29 Jun 2021 04:44:32 -0500 Subject: [PATCH 224/279] README: update torch/torchvision support table (#4133) --- README.rst | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/README.rst b/README.rst index db50cae8fd0..2c6daee4cc2 100644 --- a/README.rst +++ b/README.rst @@ -23,6 +23,10 @@ supported Python versions. +==========================+==========================+=================================+ | ``master`` / ``nightly`` | ``master`` / ``nightly`` | ``>=3.6`` | +--------------------------+--------------------------+---------------------------------+ +| ``1.9.0`` | ``0.10.0`` | ``>=3.6`` | ++--------------------------+--------------------------+---------------------------------+ +| ``1.8.1`` | ``0.9.1`` | ``>=3.6`` | ++--------------------------+--------------------------+---------------------------------+ | ``1.8.0`` | ``0.9.0`` | ``>=3.6`` | +--------------------------+--------------------------+---------------------------------+ | ``1.7.1`` | ``0.8.2`` | ``>=3.6`` | @@ -71,7 +75,7 @@ From source: # MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ python setup.py install -In case building TorchVision from source fails, install the nightly version of PyTorch following +In case building TorchVision from source fails, install the nightly version of PyTorch following the linked guide on the `contributing page `_ and retry the install. By default, GPU support is built if CUDA is found and ``torch.cuda.is_available()`` is true. From 993325dd82567f5d4f28ccb321e3a9a16984d2d8 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 30 Jun 2021 10:47:37 +0100 Subject: [PATCH 225/279] Minor additions to Resize docs (#4138) --- torchvision/transforms/functional.py | 8 +++++--- torchvision/transforms/transforms.py | 8 +++++--- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/torchvision/transforms/functional.py b/torchvision/transforms/functional.py index 21f5c654f99..dc3a9f8f68b 100644 --- a/torchvision/transforms/functional.py +++ b/torchvision/transforms/functional.py @@ -346,7 +346,8 @@ def resize(img: Tensor, size: List[int], interpolation: InterpolationMode = Inte The output image might be different depending on its type: when downsampling, the interpolation of PIL images and tensors is slightly different, because PIL applies antialiasing. This may lead to significant differences in the performance of a network. Therefore, it is preferable to train and serve a model with the same input - types. + types. See also below the ``antialias`` parameter, which can help making the output of PIL images and tensors + closer. Args: img (PIL Image or Tensor): Image to be resized. @@ -372,8 +373,9 @@ def resize(img: Tensor, size: List[int], interpolation: InterpolationMode = Inte if ``size`` is an int (or a sequence of length 1 in torchscript mode). antialias (bool, optional): antialias flag. If ``img`` is PIL Image, the flag is ignored and anti-alias - is always used. If ``img`` is Tensor, the flag is False by default and can be set True for - ``InterpolationMode.BILINEAR`` only mode. + is always used. If ``img`` is Tensor, the flag is False by default and can be set to True for + ``InterpolationMode.BILINEAR`` only mode. This can help making the output for PIL images and tensors + closer. .. warning:: There is no autodiff support for ``antialias=True`` option with input ``img`` as Tensor. diff --git a/torchvision/transforms/transforms.py b/torchvision/transforms/transforms.py index 1ec5bee0002..954d5f5f064 100644 --- a/torchvision/transforms/transforms.py +++ b/torchvision/transforms/transforms.py @@ -233,7 +233,8 @@ class Resize(torch.nn.Module): The output image might be different depending on its type: when downsampling, the interpolation of PIL images and tensors is slightly different, because PIL applies antialiasing. This may lead to significant differences in the performance of a network. Therefore, it is preferable to train and serve a model with the same input - types. + types. See also below the ``antialias`` parameter, which can help making the output of PIL images and tensors + closer. Args: size (sequence or int): Desired output size. If size is a sequence like @@ -258,8 +259,9 @@ class Resize(torch.nn.Module): if ``size`` is an int (or a sequence of length 1 in torchscript mode). antialias (bool, optional): antialias flag. If ``img`` is PIL Image, the flag is ignored and anti-alias - is always used. If ``img`` is Tensor, the flag is False by default and can be set True for - ``InterpolationMode.BILINEAR`` only mode. + is always used. If ``img`` is Tensor, the flag is False by default and can be set to True for + ``InterpolationMode.BILINEAR`` only mode. This can help making the output for PIL images and tensors + closer. .. warning:: There is no autodiff support for ``antialias=True`` option with input ``img`` as Tensor. From ac83a2c0d40e0794fcef9b9302b396a81b122127 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Thu, 1 Jul 2021 17:01:33 +0100 Subject: [PATCH 226/279] Explicitly exclude PIL 8.3.0 from compatible dependencies (#4148) --- .circleci/unittest/linux/scripts/environment.yml | 2 +- .circleci/unittest/windows/scripts/environment.yml | 2 +- setup.py | 3 ++- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/.circleci/unittest/linux/scripts/environment.yml b/.circleci/unittest/linux/scripts/environment.yml index 67ceb836a10..c03fd590c37 100644 --- a/.circleci/unittest/linux/scripts/environment.yml +++ b/.circleci/unittest/linux/scripts/environment.yml @@ -12,6 +12,6 @@ dependencies: - ca-certificates - pip: - future - - pillow >=5.3.0 + - pillow >=5.3.0, !=8.3.0 - scipy - av diff --git a/.circleci/unittest/windows/scripts/environment.yml b/.circleci/unittest/windows/scripts/environment.yml index fc4d2f89a0e..15a7ca8a795 100644 --- a/.circleci/unittest/windows/scripts/environment.yml +++ b/.circleci/unittest/windows/scripts/environment.yml @@ -12,7 +12,7 @@ dependencies: - ca-certificates - pip: - future - - pillow >=5.3.0 + - pillow >=5.3.0, !=8.3.0 - scipy - av - dataclasses diff --git a/setup.py b/setup.py index 8293a166eb8..195fdb2e7be 100644 --- a/setup.py +++ b/setup.py @@ -67,7 +67,8 @@ def write_version_file(): pytorch_dep, ] -pillow_ver = ' >= 5.3.0' +# Excluding 8.3.0 because of https://github.com/pytorch/vision/issues/4146 +pillow_ver = ' >= 5.3.0, !=8.3.0' pillow_req = 'pillow-simd' if get_dist('pillow-simd') is not None else 'pillow' requirements.append(pillow_req + pillow_ver) From ef711591a5db69d36f904ab5c39dec13627a58ad Mon Sep 17 00:00:00 2001 From: dgenzel2 <63893845+dgenzel2@users.noreply.github.com> Date: Thu, 1 Jul 2021 11:33:30 -0700 Subject: [PATCH 227/279] Add iNaturalist dataset (#4123) * Add iNaturalist dataset * Add download support * address comments Co-authored-by: dgenzel Co-authored-by: Francisco Massa --- docs/source/datasets.rst | 6 + test/test_datasets.py | 38 +++++ torchvision/datasets/__init__.py | 3 +- torchvision/datasets/inaturalist.py | 251 ++++++++++++++++++++++++++++ 4 files changed, 297 insertions(+), 1 deletion(-) create mode 100644 torchvision/datasets/inaturalist.py diff --git a/docs/source/datasets.rst b/docs/source/datasets.rst index f0cb19ed690..90cc4458d7d 100644 --- a/docs/source/datasets.rst +++ b/docs/source/datasets.rst @@ -122,6 +122,12 @@ ImageNet .. note :: This requires `scipy` to be installed +iNaturalist +~~~~~~~~~~~ + +.. autoclass:: INaturalist + :members: __getitem__, category_name + Kinetics-400 ~~~~~~~~~~~~ diff --git a/test/test_datasets.py b/test/test_datasets.py index bea2a2b80b9..043398a0ca6 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -1755,5 +1755,43 @@ def test_images_download_preexisting(self): pass +class INaturalistTestCase(datasets_utils.ImageDatasetTestCase): + DATASET_CLASS = datasets.INaturalist + FEATURE_TYPES = (PIL.Image.Image, (int, tuple)) + + ADDITIONAL_CONFIGS = datasets_utils.combinations_grid( + target_type=("kingdom", "full", "genus", ["kingdom", "phylum", "class", "order", "family", "genus", "full"]), + version=("2021_train",), + ) + + def inject_fake_data(self, tmpdir, config): + categories = [ + "00000_Akingdom_0phylum_Aclass_Aorder_Afamily_Agenus_Aspecies", + "00001_Akingdom_1phylum_Aclass_Border_Afamily_Bgenus_Aspecies", + "00002_Akingdom_2phylum_Cclass_Corder_Cfamily_Cgenus_Cspecies", + ] + + num_images_per_category = 3 + for category in categories: + datasets_utils.create_image_folder( + root=os.path.join(tmpdir, config["version"]), + name=category, + file_name_fn=lambda idx: f"image_{idx + 1:04d}.jpg", + num_examples=num_images_per_category, + ) + + return num_images_per_category * len(categories) + + def test_targets(self): + target_types = ["kingdom", "phylum", "class", "order", "family", "genus", "full"] + + with self.create_dataset(target_type=target_types, version="2021_valid") as (dataset, _): + items = [d[1] for d in dataset] + for i, item in enumerate(items): + self.assertEqual(dataset.category_name("kingdom", item[0]), "Akingdom") + self.assertEqual(dataset.category_name("phylum", item[1]), f"{i // 3}phylum") + self.assertEqual(item[6], i // 3) + + if __name__ == "__main__": unittest.main() diff --git a/torchvision/datasets/__init__.py b/torchvision/datasets/__init__.py index e67ba08d299..3b4a5408ecf 100644 --- a/torchvision/datasets/__init__.py +++ b/torchvision/datasets/__init__.py @@ -25,6 +25,7 @@ from .ucf101 import UCF101 from .places365 import Places365 from .kitti import Kitti +from .inaturalist import INaturalist __all__ = ('LSUN', 'LSUNClass', 'ImageFolder', 'DatasetFolder', 'FakeData', @@ -35,5 +36,5 @@ 'VOCSegmentation', 'VOCDetection', 'Cityscapes', 'ImageNet', 'Caltech101', 'Caltech256', 'CelebA', 'WIDERFace', 'SBDataset', 'VisionDataset', 'USPS', 'Kinetics400', "Kinetics", 'HMDB51', 'UCF101', - 'Places365', 'Kitti', + 'Places365', 'Kitti', "INaturalist" ) diff --git a/torchvision/datasets/inaturalist.py b/torchvision/datasets/inaturalist.py new file mode 100644 index 00000000000..7b9a911f823 --- /dev/null +++ b/torchvision/datasets/inaturalist.py @@ -0,0 +1,251 @@ +from PIL import Image +import os +import os.path +from typing import Any, Callable, Dict, List, Optional, Union, Tuple + +from .vision import VisionDataset +from .utils import download_and_extract_archive, verify_str_arg + +CATEGORIES_2021 = ["kingdom", "phylum", "class", "order", "family", "genus"] + +DATASET_URLS = { + '2017': 'https://ml-inat-competition-datasets.s3.amazonaws.com/2017/train_val_images.tar.gz', + '2018': 'https://ml-inat-competition-datasets.s3.amazonaws.com/2018/train_val2018.tar.gz', + '2019': 'https://ml-inat-competition-datasets.s3.amazonaws.com/2019/train_val2019.tar.gz', + '2021_train': 'https://ml-inat-competition-datasets.s3.amazonaws.com/2021/train.tar.gz', + '2021_train_mini': 'https://ml-inat-competition-datasets.s3.amazonaws.com/2021/train_mini.tar.gz', + '2021_valid': 'https://ml-inat-competition-datasets.s3.amazonaws.com/2021/val.tar.gz', +} + +DATASET_MD5 = { + '2017': '7c784ea5e424efaec655bd392f87301f', + '2018': 'b1c6952ce38f31868cc50ea72d066cc3', + '2019': 'c60a6e2962c9b8ccbd458d12c8582644', + '2021_train': '38a7bb733f7a09214d44293460ec0021', + '2021_train_mini': 'db6ed8330e634445efc8fec83ae81442', + '2021_valid': 'f6f6e0e242e3d4c9569ba56400938afc', +} + + +class INaturalist(VisionDataset): + """`iNaturalist `_ Dataset. + + Args: + root (string): Root directory of dataset where the image files are stored. + This class does not require/use annotation files. + version (string, optional): Which version of the dataset to download/use. One of + '2017', '2018', '2019', '2021_train', '2021_train_mini', '2021_valid'. + Default: `2021_train`. + target_type (string or list, optional): Type of target to use, for 2021 versions, one of: + + - ``full``: the full category (species) + - ``kingdom``: e.g. "Animalia" + - ``phylum``: e.g. "Arthropoda" + - ``class``: e.g. "Insecta" + - ``order``: e.g. "Coleoptera" + - ``family``: e.g. "Cleridae" + - ``genus``: e.g. "Trichodes" + + for 2017-2019 versions, one of: + + - ``full``: the full (numeric) category + - ``super``: the super category, e.g. "Amphibians" + + Can also be a list to output a tuple with all specified target types. + Defaults to ``full``. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + target_transform (callable, optional): A function/transform that takes in the + target and transforms it. + download (bool, optional): If true, downloads the dataset from the internet and + puts it in root directory. If dataset is already downloaded, it is not + downloaded again. + """ + + def __init__( + self, + root: str, + version: str = "2021_train", + target_type: Union[List[str], str] = "full", + transform: Optional[Callable] = None, + target_transform: Optional[Callable] = None, + download: bool = False, + ) -> None: + self.version = verify_str_arg(version, "version", DATASET_URLS.keys()) + + super(INaturalist, self).__init__(os.path.join(root, version), + transform=transform, + target_transform=target_transform) + + os.makedirs(root, exist_ok=True) + if download: + self.download() + + if not self._check_integrity(): + raise RuntimeError('Dataset not found or corrupted.' + + ' You can use download=True to download it') + + self.all_categories: List[str] = [] + + # map: category type -> name of category -> index + self.categories_index: Dict[str, Dict[str, int]] = {} + + # list indexed by category id, containing mapping from category type -> index + self.categories_map: List[Dict[str, int]] = [] + + if not isinstance(target_type, list): + target_type = [target_type] + if self.version[:4] == "2021": + self.target_type = [verify_str_arg(t, "target_type", ("full", *CATEGORIES_2021)) + for t in target_type] + self._init_2021() + else: + self.target_type = [verify_str_arg(t, "target_type", ("full", "super")) + for t in target_type] + self._init_pre2021() + + # index of all files: (full category id, filename) + self.index: List[Tuple[int, str]] = [] + + for dir_index, dir_name in enumerate(self.all_categories): + files = os.listdir(os.path.join(self.root, dir_name)) + for fname in files: + self.index.append((dir_index, fname)) + + def _init_2021(self) -> None: + """Initialize based on 2021 layout""" + + self.all_categories = sorted(os.listdir(self.root)) + + # map: category type -> name of category -> index + self.categories_index = { + k: {} for k in CATEGORIES_2021 + } + + for dir_index, dir_name in enumerate(self.all_categories): + pieces = dir_name.split('_') + if len(pieces) != 8: + raise RuntimeError(f'Unexpected category name {dir_name}, wrong number of pieces') + if pieces[0] != f'{dir_index:05d}': + raise RuntimeError(f'Unexpected category id {pieces[0]}, expecting {dir_index:05d}') + cat_map = {} + for cat, name in zip(CATEGORIES_2021, pieces[1:7]): + if name in self.categories_index[cat]: + cat_id = self.categories_index[cat][name] + else: + cat_id = len(self.categories_index[cat]) + self.categories_index[cat][name] = cat_id + cat_map[cat] = cat_id + self.categories_map.append(cat_map) + + def _init_pre2021(self) -> None: + """Initialize based on 2017-2019 layout""" + + # map: category type -> name of category -> index + self.categories_index = {'super': {}} + + cat_index = 0 + super_categories = sorted(os.listdir(self.root)) + for sindex, scat in enumerate(super_categories): + self.categories_index["super"][scat] = sindex + subcategories = sorted(os.listdir(os.path.join(self.root, scat))) + for subcat in subcategories: + if self.version == "2017": + # this version does not use ids as directory names + subcat_i = cat_index + cat_index += 1 + else: + try: + subcat_i = int(subcat) + except ValueError: + raise RuntimeError(f"Unexpected non-numeric dir name: {subcat}") + if subcat_i >= len(self.categories_map): + old_len = len(self.categories_map) + self.categories_map.extend([{}] * (subcat_i - old_len + 1)) + self.all_categories.extend([""] * (subcat_i - old_len + 1)) + if self.categories_map[subcat_i]: + raise RuntimeError(f"Duplicate category {subcat}") + self.categories_map[subcat_i] = {'super': sindex} + self.all_categories[subcat_i] = os.path.join(scat, subcat) + + # validate the dictionary + for cindex, c in enumerate(self.categories_map): + if not c: + raise RuntimeError(f"Missing category {cindex}") + + def __getitem__(self, index: int) -> Tuple[Any, Any]: + """ + Args: + index (int): Index + + Returns: + tuple: (image, target) where the type of target specified by target_type. + """ + + cat_id, fname = self.index[index] + img = Image.open(os.path.join(self.root, + self.all_categories[cat_id], + fname)) + + target: Any = [] + for t in self.target_type: + if t == "full": + target.append(cat_id) + else: + target.append(self.categories_map[cat_id][t]) + target = tuple(target) if len(target) > 1 else target[0] + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = self.target_transform(target) + + return img, target + + def __len__(self) -> int: + return len(self.index) + + def category_name(self, category_type: str, category_id: int) -> str: + """ + Args: + category_type(str): one of "full", "kingdom", "phylum", "class", "order", "family", "genus" or "super" + category_id(int): an index (class id) from this category + + Returns: + the name of the category + """ + if category_type == "full": + return self.all_categories[category_id] + else: + if category_type not in self.categories_index: + raise ValueError(f"Invalid category type '{category_type}'") + else: + for name, id in self.categories_index[category_type].items(): + if id == category_id: + return name + raise ValueError(f"Invalid category id {category_id} for {category_type}") + + def _check_integrity(self) -> bool: + return os.path.exists(self.root) and len(os.listdir(self.root)) > 0 + + def download(self) -> None: + if self._check_integrity(): + raise RuntimeError( + f"The directory {self.root} already exists. " + f"If you want to re-download or re-extract the images, delete the directory." + ) + + base_root = os.path.dirname(self.root) + + download_and_extract_archive( + DATASET_URLS[self.version], + base_root, + filename=f"{self.version}.tgz", + md5=DATASET_MD5[self.version]) + + orig_dir_name = os.path.join(base_root, os.path.basename(DATASET_URLS[self.version]).rstrip(".tar.gz")) + if not os.path.exists(orig_dir_name): + raise RuntimeError(f"Unable to find downloaded files at {orig_dir_name}") + os.rename(orig_dir_name, self.root) + print(f"Dataset version '{self.version}' has been downloaded and prepared for use") From 015378434c1e4be778b2d65eb86f227db20bc8bf Mon Sep 17 00:00:00 2001 From: Santiago Castro Date: Mon, 5 Jul 2021 01:02:02 -0700 Subject: [PATCH 228/279] Typing fixes for torchvision.io.video.read_video (#4141) --- torchvision/io/video.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/torchvision/io/video.py b/torchvision/io/video.py index b45e6da9f44..deab193eda3 100644 --- a/torchvision/io/video.py +++ b/torchvision/io/video.py @@ -3,6 +3,7 @@ import os import re import warnings +from fractions import Fraction from typing import Any, Dict, List, Optional, Tuple, Union import numpy as np @@ -236,7 +237,10 @@ def _align_audio_frames( def read_video( - filename: str, start_pts: int = 0, end_pts: Optional[float] = None, pts_unit: str = "pts" + filename: str, + start_pts: Union[float, Fraction] = 0, + end_pts: Optional[Union[float, Fraction]] = None, + pts_unit: str = "pts", ) -> Tuple[torch.Tensor, torch.Tensor, Dict[str, Any]]: """ Reads a video from a file, returning both the video frames as well as From 25bc21dfcbb390f2f215e8f83aa5e028c77a0f24 Mon Sep 17 00:00:00 2001 From: Amani Kiruga <69642575+amaniedu71@users.noreply.github.com> Date: Thu, 8 Jul 2021 04:34:16 -0400 Subject: [PATCH 229/279] Minor grammar fix to docstring (#4159) --- torchvision/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/__init__.py b/torchvision/__init__.py index 9508605b551..3cbdda7af7f 100644 --- a/torchvision/__init__.py +++ b/torchvision/__init__.py @@ -63,7 +63,7 @@ def set_video_backend(backend): binding for the FFmpeg libraries. The :mod:`video_reader` package includes a native C++ implementation on top of FFMPEG libraries, and a python API of TorchScript custom operator. - It is generally decoding faster than :mod:`pyav`, but perhaps is less robust. + It generally decodes faster than :mod:`pyav`, but is perhaps less robust. .. note:: Building with FFMPEG is disabled by default in the latest master. If you want to use the 'video_reader' From 8541c214740f9cfaf2e60ad1579faf6f4af1257b Mon Sep 17 00:00:00 2001 From: Nikita Shulga Date: Fri, 9 Jul 2021 13:17:15 -0700 Subject: [PATCH 230/279] Do not install lame when building torchvision (#4162) * Do not install lame when building torchvision It is needed only for ffmpeg integration, which is disabled anyway * Also upgrade setuptool To update pkg_resources.packaging to version 20.0+ --- packaging/build_wheel.sh | 1 + packaging/pkg_helpers.bash | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/packaging/build_wheel.sh b/packaging/build_wheel.sh index b2c9fcf57de..f41ba4eb73a 100755 --- a/packaging/build_wheel.sh +++ b/packaging/build_wheel.sh @@ -8,6 +8,7 @@ export BUILD_TYPE=wheel setup_env 0.11.0 setup_wheel_python pip_install numpy pyyaml future ninja +pip_install --upgrade setuptools setup_pip_pytorch_version python setup.py clean diff --git a/packaging/pkg_helpers.bash b/packaging/pkg_helpers.bash index dfde11b707a..ba5ecc99fe2 100644 --- a/packaging/pkg_helpers.bash +++ b/packaging/pkg_helpers.bash @@ -185,8 +185,8 @@ setup_wheel_python() { # Install libpng from Anaconda (defaults) conda install ${CONDA_CHANNEL_FLAGS} libpng "jpeg<=9b" -y else - # Install native CentOS libJPEG, LAME, freetype and GnuTLS - yum install -y libjpeg-turbo-devel lame freetype gnutls + # Install native CentOS libJPEG, freetype and GnuTLS + yum install -y libjpeg-turbo-devel freetype gnutls case "$PYTHON_VERSION" in 2.7) if [[ -n "$UNICODE_ABI" ]]; then From 23b8760374a5aaed53c6e5fc83a7e83dbe3b85df Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 12 Jul 2021 11:10:44 +0100 Subject: [PATCH 231/279] Catch ValueError due to recent change to torch.testing.assert_close (#4165) --- test/test_models.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_models.py b/test/test_models.py index ee4af8bef58..72ae68f5615 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -108,7 +108,7 @@ def get_export_import_copy(m): tol = 3e-4 try: torch.testing.assert_close(results, results_from_imported, atol=tol, rtol=tol) - except torch.testing._asserts.UsageError: + except ValueError: # custom check for the models that return named tuples: # we compare field by field while ignoring None as assert_close can't handle None for a, b in zip(results, results_from_imported): From a33d6e2d16b639a9268a3a7c18662f0d0cd649a6 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 12 Jul 2021 12:26:53 +0100 Subject: [PATCH 232/279] [FBcode->GH] [JIT] Add reference semantics to TorchScript classes (#44324) (#4166) Co-authored-by: Meghan Lele --- test/test_transforms_tensor.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 2051cc7466c..84e9bd7408c 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -649,7 +649,7 @@ def test_compose(device): t = T.Compose([ lambda x: x, ]) - with pytest.raises(RuntimeError, match="Could not get name of python class object"): + with pytest.raises(RuntimeError, match="cannot call a value of type 'Tensor'"): torch.jit.script(t) From bf2fe567c80e61e7adee94163f04bfd346892393 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 12 Jul 2021 14:26:01 +0100 Subject: [PATCH 233/279] Don't check transparency channel for pil >= 8.3 in test_decode_png (#4167) --- test/test_image.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/test/test_image.py b/test/test_image.py index 14fea642379..0ed778ab1ea 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -7,7 +7,7 @@ import pytest import numpy as np import torch -from PIL import Image +from PIL import Image, __version__ as PILLOW_VERSION import torchvision.transforms.functional as F from common_utils import get_tmp_dir, needs_cuda from _assert_utils import assert_equal @@ -22,6 +22,7 @@ DAMAGED_JPEG = os.path.join(IMAGE_ROOT, 'damaged_jpeg') ENCODE_JPEG = os.path.join(IMAGE_ROOT, "encode_jpeg") IS_WINDOWS = sys.platform in ('win32', 'cygwin') +PILLOW_VERSION = tuple(int(x) for x in PILLOW_VERSION.split('.')) def _get_safe_image_name(name): @@ -141,7 +142,15 @@ def test_decode_png(img_path, pil_mode, mode): img_lpng = decode_image(data, mode=mode) tol = 0 if pil_mode is None else 1 - assert img_lpng.allclose(img_pil, atol=tol) + + if PILLOW_VERSION >= (8, 3) and pil_mode == "LA": + # Avoid checking the transparency channel until + # https://github.com/python-pillow/Pillow/issues/5593#issuecomment-878244910 + # is fixed. + # TODO: remove once fix is released in PIL. Should be > 8.3.1. + img_lpng, img_pil = img_lpng[0], img_pil[0] + + torch.testing.assert_close(img_lpng, img_pil, atol=tol, rtol=0) def test_decode_png_errors(): From 90a2402b11b58705884b564b7bfce325f1c7d7c7 Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Wed, 14 Jul 2021 09:50:22 +0200 Subject: [PATCH 234/279] Cleanup test suite related to `torch.testing.assert_close` (#4177) Co-authored-by: Nicolas Hug --- test/_assert_utils.py | 11 ---- test/common_utils.py | 8 ++- test/test_datasets_samplers.py | 3 +- test/test_datasets_video_utils.py | 9 ++- test/test_functional_tensor.py | 14 +---- test/test_image.py | 5 +- test/test_io.py | 3 +- test/test_models_detection_anchor_utils.py | 3 +- .../test_models_detection_negative_samples.py | 2 +- test/test_models_detection_utils.py | 2 +- test/test_onnx.py | 3 +- test/test_ops.py | 3 +- test/test_transforms.py | 56 +++++++++---------- test/test_transforms_tensor.py | 2 +- test/test_transforms_video.py | 2 +- test/test_utils.py | 2 +- test/test_video_reader.py | 3 +- 17 files changed, 53 insertions(+), 78 deletions(-) delete mode 100644 test/_assert_utils.py diff --git a/test/_assert_utils.py b/test/_assert_utils.py deleted file mode 100644 index e766e2df4b8..00000000000 --- a/test/_assert_utils.py +++ /dev/null @@ -1,11 +0,0 @@ -"""This is a temporary module and should be removed as soon as torch.testing.assert_equal is supported.""" -# TODO: remove this as soon torch.testing.assert_equal is supported - -import functools - -import torch.testing - -__all__ = ["assert_equal"] - - -assert_equal = functools.partial(torch.testing.assert_close, rtol=0, atol=0) diff --git a/test/common_utils.py b/test/common_utils.py index 3f8ad8a7f55..1da5226f425 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -9,6 +9,7 @@ import __main__ import random import inspect +import functools from numbers import Number from torch._six import string_classes @@ -17,8 +18,6 @@ import numpy as np from PIL import Image -from _assert_utils import assert_equal - IS_PY39 = sys.version_info.major == 3 and sys.version_info.minor == 9 PY39_SEGFAULT_SKIP_MSG = "Segmentation fault with Python 3.9, see https://github.com/pytorch/vision/issues/3367" PY39_SKIP = unittest.skipIf(IS_PY39, PY39_SEGFAULT_SKIP_MSG) @@ -268,6 +267,9 @@ def _create_data_batch(height=3, width=3, channels=3, num_samples=4, device="cpu return batch_tensor +assert_equal = functools.partial(torch.testing.assert_close, rtol=0, atol=0) + + def _assert_equal_tensor_to_pil(tensor, pil_image, msg=None): np_pil_image = np.array(pil_image) if np_pil_image.ndim == 2: @@ -275,7 +277,7 @@ def _assert_equal_tensor_to_pil(tensor, pil_image, msg=None): pil_tensor = torch.as_tensor(np_pil_image.transpose((2, 0, 1))) if msg is None: msg = "tensor:\n{} \ndid not equal PIL tensor:\n{}".format(tensor, pil_tensor) - assert_equal(tensor.cpu(), pil_tensor, check_stride=False, msg=msg) + assert_equal(tensor.cpu(), pil_tensor, msg=msg) def _assert_approx_equal_tensor_to_pil(tensor, pil_image, tol=1e-5, msg=None, agg_method="mean", diff --git a/test/test_datasets_samplers.py b/test/test_datasets_samplers.py index be2fab8e0dd..7754c1a98e8 100644 --- a/test/test_datasets_samplers.py +++ b/test/test_datasets_samplers.py @@ -13,8 +13,7 @@ from torchvision.datasets.video_utils import VideoClips, unfold from torchvision import get_video_backend -from common_utils import get_tmp_dir -from _assert_utils import assert_equal +from common_utils import get_tmp_dir, assert_equal @contextlib.contextmanager diff --git a/test/test_datasets_video_utils.py b/test/test_datasets_video_utils.py index 389ad5196af..00db0aad127 100644 --- a/test/test_datasets_video_utils.py +++ b/test/test_datasets_video_utils.py @@ -6,8 +6,7 @@ from torchvision import io from torchvision.datasets.video_utils import VideoClips, unfold -from common_utils import get_tmp_dir -from _assert_utils import assert_equal +from common_utils import get_tmp_dir, assert_equal @contextlib.contextmanager @@ -41,7 +40,7 @@ def test_unfold(self): [0, 1, 2], [3, 4, 5], ]) - assert_equal(r, expected, check_stride=False) + assert_equal(r, expected) r = unfold(a, 3, 2, 1) expected = torch.tensor([ @@ -49,14 +48,14 @@ def test_unfold(self): [2, 3, 4], [4, 5, 6] ]) - assert_equal(r, expected, check_stride=False) + assert_equal(r, expected) r = unfold(a, 3, 2, 2) expected = torch.tensor([ [0, 2, 4], [2, 4, 6], ]) - assert_equal(r, expected, check_stride=False) + assert_equal(r, expected) @pytest.mark.skipif(not io.video._av_available(), reason="this test requires av") def test_video_clips(self): diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index a02636ccdf9..5ce82304569 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -21,8 +21,8 @@ _assert_equal_tensor_to_pil, _assert_approx_equal_tensor_to_pil, _test_fn_on_batch, + assert_equal, ) -from _assert_utils import assert_equal from typing import Dict, List, Sequence, Tuple @@ -187,11 +187,7 @@ def test_square_rotations(self, device, height, width, dt, angle, config, fn): tensor, angle=angle, translate=[0, 0], scale=1.0, shear=[0.0, 0.0], interpolation=NEAREST ) if config is not None: - assert_equal( - torch.rot90(tensor, **config), - out_tensor, - check_stride=False, - ) + assert_equal(torch.rot90(tensor, **config), out_tensor) if out_tensor.dtype != torch.uint8: out_tensor = out_tensor.to(torch.uint8) @@ -856,7 +852,6 @@ def test_resized_crop(device, mode): assert_equal( expected_out_tensor, out_tensor, - check_stride=False, msg="{} vs {}".format(expected_out_tensor[0, :10, :10], out_tensor[0, :10, :10]), ) @@ -1001,10 +996,7 @@ def test_gaussian_blur(device, image_size, dt, ksize, sigma, fn): ).reshape(shape[-2], shape[-1], shape[-3]).permute(2, 0, 1).to(tensor) out = fn(tensor, kernel_size=ksize, sigma=sigma) - torch.testing.assert_close( - out, true_out, rtol=0.0, atol=1.0, check_stride=False, - msg="{}, {}".format(ksize, sigma) - ) + torch.testing.assert_close(out, true_out, rtol=0.0, atol=1.0, msg="{}, {}".format(ksize, sigma)) @pytest.mark.parametrize('device', cpu_and_gpu()) diff --git a/test/test_image.py b/test/test_image.py index 0ed778ab1ea..e7e5b8b197d 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -9,8 +9,7 @@ import torch from PIL import Image, __version__ as PILLOW_VERSION import torchvision.transforms.functional as F -from common_utils import get_tmp_dir, needs_cuda -from _assert_utils import assert_equal +from common_utils import get_tmp_dir, needs_cuda, assert_equal from torchvision.io.image import ( decode_png, decode_jpeg, encode_jpeg, write_jpeg, decode_image, read_file, @@ -280,7 +279,7 @@ def test_read_1_bit_png(shape): img.save(image_path) img1 = read_image(image_path) img2 = normalize_dimensions(torch.as_tensor(pixels * 255, dtype=torch.uint8)) - assert_equal(img1, img2, check_stride=False) + assert_equal(img1, img2) @pytest.mark.parametrize('shape', [ diff --git a/test/test_io.py b/test/test_io.py index 93164a9997f..56cd0af5fd8 100644 --- a/test/test_io.py +++ b/test/test_io.py @@ -9,8 +9,7 @@ import warnings from urllib.error import URLError -from common_utils import get_tmp_dir -from _assert_utils import assert_equal +from common_utils import get_tmp_dir, assert_equal try: diff --git a/test/test_models_detection_anchor_utils.py b/test/test_models_detection_anchor_utils.py index c918d3fc8df..4477e9e1566 100644 --- a/test/test_models_detection_anchor_utils.py +++ b/test/test_models_detection_anchor_utils.py @@ -1,6 +1,5 @@ import torch -from common_utils import TestCase -from _assert_utils import assert_equal +from common_utils import TestCase, assert_equal from torchvision.models.detection.anchor_utils import AnchorGenerator, DefaultBoxGenerator from torchvision.models.detection.image_list import ImageList import pytest diff --git a/test/test_models_detection_negative_samples.py b/test/test_models_detection_negative_samples.py index 51749011dd4..a4b7064b338 100644 --- a/test/test_models_detection_negative_samples.py +++ b/test/test_models_detection_negative_samples.py @@ -7,7 +7,7 @@ from torchvision.models.detection.faster_rcnn import FastRCNNPredictor, TwoMLPHead import pytest -from _assert_utils import assert_equal +from common_utils import assert_equal class TestModelsDetectionNegativeSamples: diff --git a/test/test_models_detection_utils.py b/test/test_models_detection_utils.py index bb50e237544..b599bbeaea1 100644 --- a/test/test_models_detection_utils.py +++ b/test/test_models_detection_utils.py @@ -4,7 +4,7 @@ from torchvision.models.detection.transform import GeneralizedRCNNTransform import pytest from torchvision.models.detection import backbone_utils -from _assert_utils import assert_equal +from common_utils import assert_equal class TestModelsDetectionUtils: diff --git a/test/test_onnx.py b/test/test_onnx.py index c9455fbd86a..c093ccb4863 100644 --- a/test/test_onnx.py +++ b/test/test_onnx.py @@ -6,8 +6,7 @@ except ImportError: onnxruntime = None -from common_utils import set_rng_seed -from _assert_utils import assert_equal +from common_utils import set_rng_seed, assert_equal import io import torch from torchvision import ops diff --git a/test/test_ops.py b/test/test_ops.py index a776268a5b4..5c2fc882902 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -1,5 +1,4 @@ -from common_utils import needs_cuda, cpu_and_gpu -from _assert_utils import assert_equal +from common_utils import needs_cuda, cpu_and_gpu, assert_equal import math from abc import ABC, abstractmethod import pytest diff --git a/test/test_transforms.py b/test/test_transforms.py index e86b6959517..74757bcb4e6 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -19,8 +19,7 @@ except ImportError: stats = None -from common_utils import cycle_over, int_dtypes, float_dtypes -from _assert_utils import assert_equal +from common_utils import cycle_over, int_dtypes, float_dtypes, assert_equal GRACE_HOPPER = get_file_path_2( @@ -159,7 +158,7 @@ def test_accimage_pil_to_tensor(self): output = trans(accimage.Image(GRACE_HOPPER)) assert expected_output.size() == output.size() - torch.testing.assert_close(output, expected_output, check_stride=False) + torch.testing.assert_close(output, expected_output) def test_accimage_resize(self): trans = transforms.Compose([ @@ -205,23 +204,23 @@ def test_to_tensor(self, channels): input_data = torch.ByteTensor(channels, height, width).random_(0, 255).float().div_(255) img = transforms.ToPILImage()(input_data) output = trans(img) - torch.testing.assert_close(output, input_data, check_stride=False) + torch.testing.assert_close(output, input_data) ndarray = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) output = trans(ndarray) expected_output = ndarray.transpose((2, 0, 1)) / 255.0 - torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) + torch.testing.assert_close(output.numpy(), expected_output, check_dtype=False) ndarray = np.random.rand(height, width, channels).astype(np.float32) output = trans(ndarray) expected_output = ndarray.transpose((2, 0, 1)) - torch.testing.assert_close(output.numpy(), expected_output, check_stride=False, check_dtype=False) + torch.testing.assert_close(output.numpy(), expected_output, check_dtype=False) # separate test for mode '1' PIL images input_data = torch.ByteTensor(1, height, width).bernoulli_() img = transforms.ToPILImage()(input_data.mul(255)).convert('1') output = trans(img) - torch.testing.assert_close(input_data, output, check_dtype=False, check_stride=False) + torch.testing.assert_close(input_data, output, check_dtype=False) def test_to_tensor_errors(self): height, width = 4, 4 @@ -258,7 +257,7 @@ def test_pil_to_tensor(self, channels): input_data = torch.ByteTensor(channels, height, width).random_(0, 255) img = transforms.ToPILImage()(input_data) output = trans(img) - torch.testing.assert_close(input_data, output, check_stride=False) + torch.testing.assert_close(input_data, output) input_data = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) img = transforms.ToPILImage()(input_data) @@ -270,13 +269,13 @@ def test_pil_to_tensor(self, channels): img = transforms.ToPILImage()(input_data) # CHW -> HWC and (* 255).byte() output = trans(img) # HWC -> CHW expected_output = (input_data * 255).byte() - torch.testing.assert_close(output, expected_output, check_stride=False) + torch.testing.assert_close(output, expected_output) # separate test for mode '1' PIL images input_data = torch.ByteTensor(1, height, width).bernoulli_() img = transforms.ToPILImage()(input_data.mul(255)).convert('1') output = trans(img).view(torch.uint8).bool().to(torch.uint8) - torch.testing.assert_close(input_data, output, check_stride=False) + torch.testing.assert_close(input_data, output) def test_pil_to_tensor_errors(self): height, width = 4, 4 @@ -420,10 +419,10 @@ def test_pad(self): h_padded = result[:, :padding, :] w_padded = result[:, :, :padding] torch.testing.assert_close( - h_padded, torch.full_like(h_padded, fill_value=fill_v), check_stride=False, rtol=0.0, atol=eps + h_padded, torch.full_like(h_padded, fill_value=fill_v), rtol=0.0, atol=eps ) torch.testing.assert_close( - w_padded, torch.full_like(w_padded, fill_value=fill_v), check_stride=False, rtol=0.0, atol=eps + w_padded, torch.full_like(w_padded, fill_value=fill_v), rtol=0.0, atol=eps ) pytest.raises(ValueError, transforms.Pad(padding, fill=(1, 2)), transforms.ToPILImage()(img)) @@ -457,7 +456,7 @@ def test_pad_with_non_constant_padding_modes(self): # First 6 elements of leftmost edge in the middle of the image, values are in order: # edge_pad, edge_pad, edge_pad, constant_pad, constant value added to leftmost edge, 0 edge_middle_slice = np.asarray(edge_padded_img).transpose(2, 0, 1)[0][17][:6] - assert_equal(edge_middle_slice, np.asarray([200, 200, 200, 200, 1, 0], dtype=np.uint8), check_stride=False) + assert_equal(edge_middle_slice, np.asarray([200, 200, 200, 200, 1, 0], dtype=np.uint8)) assert transforms.ToTensor()(edge_padded_img).size() == (3, 35, 35) # Pad 3 to left/right, 2 to top/bottom @@ -465,7 +464,7 @@ def test_pad_with_non_constant_padding_modes(self): # First 6 elements of leftmost edge in the middle of the image, values are in order: # reflect_pad, reflect_pad, reflect_pad, constant_pad, constant value added to leftmost edge, 0 reflect_middle_slice = np.asarray(reflect_padded_img).transpose(2, 0, 1)[0][17][:6] - assert_equal(reflect_middle_slice, np.asarray([0, 0, 1, 200, 1, 0], dtype=np.uint8), check_stride=False) + assert_equal(reflect_middle_slice, np.asarray([0, 0, 1, 200, 1, 0], dtype=np.uint8)) assert transforms.ToTensor()(reflect_padded_img).size() == (3, 33, 35) # Pad 3 to left, 2 to top, 2 to right, 1 to bottom @@ -473,7 +472,7 @@ def test_pad_with_non_constant_padding_modes(self): # First 6 elements of leftmost edge in the middle of the image, values are in order: # sym_pad, sym_pad, sym_pad, constant_pad, constant value added to leftmost edge, 0 symmetric_middle_slice = np.asarray(symmetric_padded_img).transpose(2, 0, 1)[0][17][:6] - assert_equal(symmetric_middle_slice, np.asarray([0, 1, 200, 200, 1, 0], dtype=np.uint8), check_stride=False) + assert_equal(symmetric_middle_slice, np.asarray([0, 1, 200, 200, 1, 0], dtype=np.uint8)) assert transforms.ToTensor()(symmetric_padded_img).size() == (3, 32, 34) # Check negative padding explicitly for symmetric case, since it is not @@ -482,8 +481,8 @@ def test_pad_with_non_constant_padding_modes(self): symmetric_padded_img_neg = F.pad(img, (-1, 2, 3, -3), padding_mode='symmetric') symmetric_neg_middle_left = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][:3] symmetric_neg_middle_right = np.asarray(symmetric_padded_img_neg).transpose(2, 0, 1)[0][17][-4:] - assert_equal(symmetric_neg_middle_left, np.asarray([1, 0, 0], dtype=np.uint8), check_stride=False) - assert_equal(symmetric_neg_middle_right, np.asarray([200, 200, 0, 0], dtype=np.uint8), check_stride=False) + assert_equal(symmetric_neg_middle_left, np.asarray([1, 0, 0], dtype=np.uint8)) + assert_equal(symmetric_neg_middle_right, np.asarray([200, 200, 0, 0], dtype=np.uint8)) assert transforms.ToTensor()(symmetric_padded_img_neg).size() == (3, 28, 31) def test_pad_raises_with_invalid_pad_sequence_len(self): @@ -502,7 +501,7 @@ def test_pad_with_mode_F_images(self): img = Image.new("F", (10, 10)) padded_img = transform(img) - assert_equal(padded_img.size, [edge_size + 2 * pad for edge_size in img.size], check_stride=False) + assert_equal(padded_img.size, [edge_size + 2 * pad for edge_size in img.size]) @pytest.mark.skipif(stats is None, reason="scipy.stats not available") @@ -579,7 +578,7 @@ def test_1_channel_tensor_to_pil_image(self, with_mode, img_data, expected_outpu img = transform(img_data) assert img.mode == expected_mode - torch.testing.assert_close(expected_output, to_tensor(img).numpy(), check_stride=False) + torch.testing.assert_close(expected_output, to_tensor(img).numpy()) def test_1_channel_float_tensor_to_pil_image(self): img_data = torch.Tensor(1, 4, 4).uniform_() @@ -617,7 +616,7 @@ def test_2_channel_ndarray_to_pil_image(self, expected_mode): assert img.mode == expected_mode split = img.split() for i in range(2): - torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i])) def test_2_channel_ndarray_to_pil_image_error(self): img_data = torch.ByteTensor(4, 4, 2).random_(0, 255).numpy() @@ -721,7 +720,7 @@ def test_3_channel_ndarray_to_pil_image(self, expected_mode): assert img.mode == expected_mode split = img.split() for i in range(3): - torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i])) def test_3_channel_ndarray_to_pil_image_error(self): img_data = torch.ByteTensor(4, 4, 3).random_(0, 255).numpy() @@ -778,7 +777,7 @@ def test_4_channel_ndarray_to_pil_image(self, expected_mode): assert img.mode == expected_mode split = img.split() for i in range(4): - torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i]), check_stride=False) + torch.testing.assert_close(img_data[:, :, i], np.asarray(split[i])) def test_4_channel_ndarray_to_pil_image_error(self): img_data = torch.ByteTensor(4, 4, 4).random_(0, 255).numpy() @@ -1152,7 +1151,7 @@ def test_to_grayscale(): assert gray_np_2.shape == tuple(x_shape), 'should be 3 channel' assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) - assert_equal(gray_np, gray_np_2[:, :, 0], check_stride=False) + assert_equal(gray_np, gray_np_2[:, :, 0]) # Case 3: 1 channel grayscale -> 1 channel grayscale trans3 = transforms.Grayscale(num_output_channels=1) @@ -1170,7 +1169,7 @@ def test_to_grayscale(): assert gray_np_4.shape == tuple(x_shape), 'should be 3 channel' assert_equal(gray_np_4[:, :, 0], gray_np_4[:, :, 1]) assert_equal(gray_np_4[:, :, 1], gray_np_4[:, :, 2]) - assert_equal(gray_np, gray_np_4[:, :, 0], check_stride=False) + assert_equal(gray_np, gray_np_4[:, :, 0]) # Checking if Grayscale can be printed as string trans4.__repr__() @@ -1240,7 +1239,7 @@ def test_random_grayscale(): assert gray_np_2.shape == tuple(x_shape), 'should be 3 channel' assert_equal(gray_np_2[:, :, 0], gray_np_2[:, :, 1]) assert_equal(gray_np_2[:, :, 1], gray_np_2[:, :, 2]) - assert_equal(gray_np, gray_np_2[:, :, 0], check_stride=False) + assert_equal(gray_np, gray_np_2[:, :, 0]) # Case 3b: RGB -> 3 channel grayscale (unchanged) trans2 = transforms.RandomGrayscale(p=0.0) @@ -1600,8 +1599,9 @@ def test_center_crop_2(odd_image_size, delta, delta_width, delta_height): # Ensure output for PIL and Tensor are equal assert_equal( - output_tensor, output_pil, check_stride=False, - msg="image_size: {} crop_size: {}".format(input_image_size, crop_size) + output_tensor, + output_pil, + msg="image_size: {} crop_size: {}".format(input_image_size, crop_size), ) # Check if content in center of both image and cropped output is same. @@ -1625,7 +1625,7 @@ def test_center_crop_2(odd_image_size, delta, delta_width, delta_height): input_center_tl[1]:input_center_tl[1] + center_size[1] ] - assert_equal(output_center, img_center, check_stride=False) + assert_equal(output_center, img_center) def test_color_jitter(): diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 84e9bd7408c..0bf5d77716f 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -18,8 +18,8 @@ _assert_equal_tensor_to_pil, _assert_approx_equal_tensor_to_pil, cpu_and_gpu, + assert_equal, ) -from _assert_utils import assert_equal NEAREST, BILINEAR, BICUBIC = InterpolationMode.NEAREST, InterpolationMode.BILINEAR, InterpolationMode.BICUBIC diff --git a/test/test_transforms_video.py b/test/test_transforms_video.py index 81b65ef0a6d..1b6b85a29ba 100644 --- a/test/test_transforms_video.py +++ b/test/test_transforms_video.py @@ -4,7 +4,7 @@ import random import numpy as np import warnings -from _assert_utils import assert_equal +from common_utils import assert_equal try: from scipy import stats diff --git a/test/test_utils.py b/test/test_utils.py index 4c3d71e3776..37829b906f1 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -9,7 +9,7 @@ from io import BytesIO import torchvision.transforms.functional as F from PIL import Image, __version__ as PILLOW_VERSION, ImageColor -from _assert_utils import assert_equal +from common_utils import assert_equal PILLOW_VERSION = tuple(int(x) for x in PILLOW_VERSION.split('.')) diff --git a/test/test_video_reader.py b/test/test_video_reader.py index 0a739673298..10a6c242a1e 100644 --- a/test/test_video_reader.py +++ b/test/test_video_reader.py @@ -10,8 +10,7 @@ from numpy.random import randint from torchvision import set_video_backend from torchvision.io import _HAS_VIDEO_OPT -from common_utils import PY39_SKIP -from _assert_utils import assert_equal +from common_utils import PY39_SKIP, assert_equal try: From 1e0f7942d06a00c74020bf775b9c7b7bd8d9851b Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 14 Jul 2021 13:40:19 +0100 Subject: [PATCH 235/279] Don't install torchvision as editable mode when not needed (#4179) --- .circleci/config.yml | 4 ++-- .circleci/config.yml.in | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 83e7ebd0f49..32b4077e93d 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -241,7 +241,7 @@ jobs: command: | pip install --user --progress-bar off --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html # need to install torchvision dependencies due to transitive imports - pip install --user --progress-bar off --editable . + pip install --user --progress-bar off . pip install pytest python test/test_hub.py @@ -254,7 +254,7 @@ jobs: command: | pip install --user --progress-bar off --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html # need to install torchvision dependencies due to transitive imports - pip install --user --progress-bar off --editable . + pip install --user --progress-bar off . pip install --user onnx pip install --user onnxruntime pip install --user pytest diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 19539785e9b..15cb7eb6a07 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -241,7 +241,7 @@ jobs: command: | pip install --user --progress-bar off --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html # need to install torchvision dependencies due to transitive imports - pip install --user --progress-bar off --editable . + pip install --user --progress-bar off . pip install pytest python test/test_hub.py @@ -254,7 +254,7 @@ jobs: command: | pip install --user --progress-bar off --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html # need to install torchvision dependencies due to transitive imports - pip install --user --progress-bar off --editable . + pip install --user --progress-bar off . pip install --user onnx pip install --user onnxruntime pip install --user pytest From c332a7f589a70cd1b305db41d1c2566b6c340937 Mon Sep 17 00:00:00 2001 From: Joe Early Date: Thu, 15 Jul 2021 15:07:29 +0100 Subject: [PATCH 236/279] Removed copy=False in torch.from_numpy in MNIST to avoid warning (#4184) --- torchvision/datasets/mnist.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchvision/datasets/mnist.py b/torchvision/datasets/mnist.py index edd2185c984..0467854e9b3 100644 --- a/torchvision/datasets/mnist.py +++ b/torchvision/datasets/mnist.py @@ -496,7 +496,7 @@ def read_sn3_pascalvincent_tensor(path: str, strict: bool = True) -> torch.Tenso s = [get_int(data[4 * (i + 1): 4 * (i + 2)]) for i in range(nd)] parsed = np.frombuffer(data, dtype=m[1], offset=(4 * (nd + 1))) assert parsed.shape[0] == np.prod(s) or not strict - return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s) + return torch.from_numpy(parsed.astype(m[2])).view(*s) def read_label_file(path: str) -> torch.Tensor: From d993ce568576306168d24ee597fefa3d8ba40998 Mon Sep 17 00:00:00 2001 From: Gary Miguel Date: Fri, 16 Jul 2021 01:21:48 -0700 Subject: [PATCH 237/279] Use test images from repo rather than internet for ONNX tests (#4176) --- test/test_onnx.py | 33 ++++++++++----------------------- 1 file changed, 10 insertions(+), 23 deletions(-) diff --git a/test/test_onnx.py b/test/test_onnx.py index c093ccb4863..a63c2f09e16 100644 --- a/test/test_onnx.py +++ b/test/test_onnx.py @@ -18,6 +18,7 @@ from torchvision.models.detection.faster_rcnn import FastRCNNPredictor, TwoMLPHead from collections import OrderedDict +from typing import List, Tuple import pytest from torchvision.ops._register_onnx_ops import _onnx_opset_version @@ -365,32 +366,20 @@ def forward(self_module, images, features): dynamic_axes={"input1": [0, 1, 2, 3], "input2": [0, 1, 2, 3], "input3": [0, 1, 2, 3], "input4": [0, 1, 2, 3], "input5": [0, 1, 2, 3], "input6": [0, 1, 2, 3]}) - def get_image_from_url(self, url, size=None): - import requests + def get_image(self, rel_path: str, size: Tuple[int, int]) -> torch.Tensor: + import os from PIL import Image - from io import BytesIO from torchvision import transforms - data = requests.get(url) - image = Image.open(BytesIO(data.content)).convert("RGB") + data_dir = os.path.join(os.path.dirname(__file__), "assets") + path = os.path.join(data_dir, *rel_path.split("/")) + image = Image.open(path).convert("RGB").resize(size, Image.BILINEAR) - if size is None: - size = (300, 200) - image = image.resize(size, Image.BILINEAR) + return transforms.ToTensor()(image) - to_tensor = transforms.ToTensor() - return to_tensor(image) - - def get_test_images(self): - image_url = "http://farm3.staticflickr.com/2469/3915380994_2e611b1779_z.jpg" - image = self.get_image_from_url(url=image_url, size=(100, 320)) - - image_url2 = "https://pytorch.org/tutorials/_static/img/tv_tutorial/tv_image05.png" - image2 = self.get_image_from_url(url=image_url2, size=(250, 380)) - - images = [image] - test_images = [image2] - return images, test_images + def get_test_images(self) -> Tuple[List[torch.Tensor], List[torch.Tensor]]: + return ([self.get_image("encode_jpeg/grace_hopper_517x606.jpg", (100, 320))], + [self.get_image("fakedata/logos/rgb_pytorch.png", (250, 380))]) def test_faster_rcnn(self): images, test_images = self.get_test_images() @@ -456,7 +445,6 @@ def test_mask_rcnn(self): dynamic_axes={"images_tensors": [0, 1, 2], "boxes": [0, 1], "labels": [0], "scores": [0], "masks": [0, 1, 2]}, tolerate_small_mismatch=True) - # TODO: enable this test once dynamic model export is fixed # Test exported model for an image with no detections on other images self.run_model(model, [(dummy_image,), (images,)], input_names=["images_tensors"], @@ -468,7 +456,6 @@ def test_mask_rcnn(self): # Verify that heatmaps_to_keypoints behaves the same in tracing. # This test also compares both heatmaps_to_keypoints and _onnx_heatmaps_to_keypoints # (since jit_trace witll call _heatmaps_to_keypoints). - # @unittest.skip("Disable test until Resize bug fixed in ORT") def test_heatmaps_to_keypoints(self): # disable profiling torch._C._jit_set_profiling_executor(False) From 835c2c3562cb7cafb46c379f97d78c6d5b34106d Mon Sep 17 00:00:00 2001 From: F-G Fernandez Date: Fri, 16 Jul 2021 11:12:55 +0200 Subject: [PATCH 238/279] Added missing typing annotations in datasets/coco (#4168) --- torchvision/datasets/coco.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torchvision/datasets/coco.py b/torchvision/datasets/coco.py index d59a23efb4d..a211f2f4f51 100644 --- a/torchvision/datasets/coco.py +++ b/torchvision/datasets/coco.py @@ -26,7 +26,7 @@ def __init__( transform: Optional[Callable] = None, target_transform: Optional[Callable] = None, transforms: Optional[Callable] = None, - ): + ) -> None: super().__init__(root, transforms, transform, target_transform) from pycocotools.coco import COCO @@ -37,7 +37,7 @@ def _load_image(self, id: int) -> Image.Image: path = self.coco.loadImgs(id)[0]["file_name"] return Image.open(os.path.join(self.root, path)).convert("RGB") - def _load_target(self, id) -> List[Any]: + def _load_target(self, id: int) -> List[Any]: return self.coco.loadAnns(self.coco.getAnnIds(id)) def __getitem__(self, index: int) -> Tuple[Any, Any]: @@ -95,5 +95,5 @@ class CocoCaptions(CocoDetection): """ - def _load_target(self, id) -> List[str]: + def _load_target(self, id: int) -> List[str]: return [ann["caption"] for ann in super()._load_target(id)] From f96a8a00a1e30ed89772aaeb876fab4c6734ad9c Mon Sep 17 00:00:00 2001 From: F-G Fernandez Date: Fri, 16 Jul 2021 11:14:20 +0200 Subject: [PATCH 239/279] Added missing typing annotations in datasets/kinetics (#4170) --- torchvision/datasets/kinetics.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/torchvision/datasets/kinetics.py b/torchvision/datasets/kinetics.py index 2543b6c514d..68f7470e6ab 100644 --- a/torchvision/datasets/kinetics.py +++ b/torchvision/datasets/kinetics.py @@ -8,6 +8,7 @@ from typing import Any, Callable, Dict, Optional, Tuple from functools import partial from multiprocessing import Pool +from torch import Tensor from .utils import download_and_extract_archive, download_url, verify_str_arg, check_integrity from .folder import find_classes, make_dataset @@ -15,7 +16,7 @@ from .vision import VisionDataset -def _dl_wrap(tarpath, videopath, line): +def _dl_wrap(tarpath: str, videopath: str, line: str) -> None: download_and_extract_archive(line, tarpath, videopath) @@ -90,14 +91,14 @@ def __init__( frames_per_clip: int, num_classes: str = "400", split: str = "train", - frame_rate: Optional[float] = None, + frame_rate: Optional[int] = None, step_between_clips: int = 1, transform: Optional[Callable] = None, extensions: Tuple[str, ...] = ("avi", "mp4"), download: bool = False, num_download_workers: int = 1, num_workers: int = 1, - _precomputed_metadata: Optional[Dict] = None, + _precomputed_metadata: Optional[Dict[str, Any]] = None, _video_width: int = 0, _video_height: int = 0, _video_min_dimension: int = 0, @@ -187,7 +188,7 @@ def _download_videos(self) -> None: poolproc = Pool(self.num_download_workers) poolproc.map(part, lines) - def _make_ds_structure(self): + def _make_ds_structure(self) -> None: """move videos from split_folder/ ├── clip1.avi @@ -228,13 +229,13 @@ def _make_ds_structure(self): ) @property - def metadata(self): + def metadata(self) -> Dict[str, Any]: return self.video_clips.metadata - def __len__(self): + def __len__(self) -> int: return self.video_clips.num_clips() - def __getitem__(self, idx): + def __getitem__(self, idx: int) -> Tuple[Tensor, Tensor, int]: video, audio, info, video_idx = self.video_clips.get_clip(idx) if not self._legacy: # [T,H,W,C] --> [T,C,H,W] @@ -303,7 +304,7 @@ def __init__( download: Any = None, num_download_workers: Any = None, **kwargs: Any - ): + ) -> None: warnings.warn( "Kinetics400 is deprecated and will be removed in a future release." "It was replaced by Kinetics(..., num_classes=\"400\").") From 642ad750c5eaec259d423270b2680eb0b383ba2e Mon Sep 17 00:00:00 2001 From: F-G Fernandez Date: Tue, 20 Jul 2021 13:21:03 +0200 Subject: [PATCH 240/279] Added missing typing annotations in datasets/ucf101 (#4171) --- torchvision/datasets/ucf101.py | 40 +++++++++++++++++++++++----------- 1 file changed, 27 insertions(+), 13 deletions(-) diff --git a/torchvision/datasets/ucf101.py b/torchvision/datasets/ucf101.py index 71f62257bcb..2c2952fab1a 100644 --- a/torchvision/datasets/ucf101.py +++ b/torchvision/datasets/ucf101.py @@ -1,4 +1,6 @@ import os +from typing import Any, Dict, List, Tuple, Optional, Callable +from torch import Tensor from .folder import find_classes, make_dataset from .video_utils import VideoClips @@ -42,10 +44,23 @@ class UCF101(VisionDataset): - label (int): class of the video clip """ - def __init__(self, root, annotation_path, frames_per_clip, step_between_clips=1, - frame_rate=None, fold=1, train=True, transform=None, - _precomputed_metadata=None, num_workers=1, _video_width=0, - _video_height=0, _video_min_dimension=0, _audio_samples=0): + def __init__( + self, + root: str, + annotation_path: str, + frames_per_clip: int, + step_between_clips: int = 1, + frame_rate: Optional[int] = None, + fold: int = 1, + train: bool = True, + transform: Optional[Callable] = None, + _precomputed_metadata: Optional[Dict[str, Any]] = None, + num_workers: int = 1, + _video_width: int = 0, + _video_height: int = 0, + _video_min_dimension: int = 0, + _audio_samples: int = 0 + ) -> None: super(UCF101, self).__init__(root) if not 1 <= fold <= 3: raise ValueError("fold should be between 1 and 3, got {}".format(fold)) @@ -78,27 +93,26 @@ def __init__(self, root, annotation_path, frames_per_clip, step_between_clips=1, self.transform = transform @property - def metadata(self): + def metadata(self) -> Dict[str, Any]: return self.full_video_clips.metadata - def _select_fold(self, video_list, annotation_path, fold, train): + def _select_fold(self, video_list: List[str], annotation_path: str, fold: int, train: bool) -> List[int]: name = "train" if train else "test" name = "{}list{:02d}.txt".format(name, fold) f = os.path.join(annotation_path, name) - selected_files = [] + selected_files = set() with open(f, "r") as fid: data = fid.readlines() - data = [x.strip().split(" ") for x in data] - data = [os.path.join(self.root, x[0]) for x in data] - selected_files.extend(data) - selected_files = set(selected_files) + data = [x.strip().split(" ")[0] for x in data] + data = [os.path.join(self.root, x) for x in data] + selected_files.update(data) indices = [i for i in range(len(video_list)) if video_list[i] in selected_files] return indices - def __len__(self): + def __len__(self) -> int: return self.video_clips.num_clips() - def __getitem__(self, idx): + def __getitem__(self, idx: int) -> Tuple[Tensor, Tensor, int]: video, audio, info, video_idx = self.video_clips.get_clip(idx) label = self.samples[self.indices[video_idx]][1] From 1dd5d1f6a581c42f32006014f46fae11ecd96c70 Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Tue, 20 Jul 2021 19:08:41 +0200 Subject: [PATCH 241/279] add `pytest.ini` (#4196) * add `pytest.ini` * use native traceback --- pytest.ini | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 pytest.ini diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000000..b8f0709b571 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,10 @@ +[pytest] +addopts = + # show summary of all tests that did not pass + -ra + # Make tracebacks shorter + --tb=native + # enable all warnings + -Wd +testpaths = + test From 75970b61784f2e2c98fe5549cd7c59f3951c7cd5 Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Thu, 22 Jul 2021 08:42:53 +0200 Subject: [PATCH 242/279] Mock redirection logic for tests (#4197) * mock out redirect behavior for testing * revert unrelated change * simplify * move tests out of internet tests * replace urls with dummys * improve checking of mock calls --- test/test_datasets_utils.py | 38 +++++++++++++++++++++++++++++++++++++ test/test_internet.py | 13 ------------- 2 files changed, 38 insertions(+), 13 deletions(-) diff --git a/test/test_datasets_utils.py b/test/test_datasets_utils.py index 34ca3da6847..0c2dc5260de 100644 --- a/test/test_datasets_utils.py +++ b/test/test_datasets_utils.py @@ -10,6 +10,7 @@ from urllib.error import URLError import itertools import lzma +import contextlib from common_utils import get_tmp_dir from torchvision.datasets.utils import _COMPRESSED_FILE_OPENERS @@ -19,7 +20,44 @@ os.path.dirname(os.path.abspath(__file__)), 'assets', 'encode_jpeg', 'grace_hopper_517x606.jpg') +def patch_url_redirection(mocker, redirect_url): + class Response: + def __init__(self, url): + self.url = url + + @contextlib.contextmanager + def patched_opener(*args, **kwargs): + yield Response(redirect_url) + + return mocker.patch("torchvision.datasets.utils.urllib.request.urlopen", side_effect=patched_opener) + + class TestDatasetsUtils: + def test_get_redirect_url(self, mocker): + url = "https://url.org" + expected_redirect_url = "https://redirect.url.org" + + mock = patch_url_redirection(mocker, expected_redirect_url) + + actual = utils._get_redirect_url(url) + assert actual == expected_redirect_url + + assert mock.call_count == 2 + call_args_1, call_args_2 = mock.call_args_list + assert call_args_1[0][0].full_url == url + assert call_args_2[0][0].full_url == expected_redirect_url + + def test_get_redirect_url_max_hops_exceeded(self, mocker): + url = "https://url.org" + redirect_url = "https://redirect.url.org" + + mock = patch_url_redirection(mocker, redirect_url) + + with pytest.raises(RecursionError): + utils._get_redirect_url(url, max_hops=0) + + assert mock.call_count == 1 + assert mock.call_args[0][0].full_url == url def test_check_md5(self): fpath = TEST_FILE diff --git a/test/test_internet.py b/test/test_internet.py index 772379a2289..8b1678f7b58 100644 --- a/test/test_internet.py +++ b/test/test_internet.py @@ -15,19 +15,6 @@ class TestDatasetUtils: - - def test_get_redirect_url(self): - url = "http://www.vision.caltech.edu/visipedia-data/CUB-200-2011/CUB_200_2011.tgz" - expected = "https://drive.google.com/file/d/1hbzc_P1FuxMkcabkgn9ZKinBwW683j45/view" - - actual = utils._get_redirect_url(url) - assert actual == expected - - def test_get_redirect_url_max_hops_exceeded(self): - url = "http://www.vision.caltech.edu/visipedia-data/CUB-200-2011/CUB_200_2011.tgz" - with pytest.raises(RecursionError): - utils._get_redirect_url(url, max_hops=0) - def test_download_url(self): with get_tmp_dir() as temp_dir: url = "http://github.com/pytorch/vision/archive/master.zip" From d62c1df3540a7b3393971ae96fbbe05ff680b495 Mon Sep 17 00:00:00 2001 From: Gary Miguel Date: Thu, 22 Jul 2021 02:19:53 -0700 Subject: [PATCH 243/279] Use pytest.importorskip for onnx tests instead of custom logic (#4185) --- test/test_onnx.py | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/test/test_onnx.py b/test/test_onnx.py index a63c2f09e16..ce0bc5c7b97 100644 --- a/test/test_onnx.py +++ b/test/test_onnx.py @@ -1,13 +1,6 @@ -# onnxruntime requires python 3.5 or above -try: - # This import should be before that of torch - # see https://github.com/onnx/onnx/issues/2394#issuecomment-581638840 - import onnxruntime -except ImportError: - onnxruntime = None - from common_utils import set_rng_seed, assert_equal import io +import pytest import torch from torchvision import ops from torchvision import models @@ -20,11 +13,13 @@ from collections import OrderedDict from typing import List, Tuple -import pytest from torchvision.ops._register_onnx_ops import _onnx_opset_version +# In environments without onnxruntime we prefer to +# invoke all tests in the repo and have this one skipped rather than fail. +onnxruntime = pytest.importorskip("onnxruntime") + -@pytest.mark.skipif(onnxruntime is None, reason='ONNX Runtime unavailable') class TestONNXExporter: @classmethod def setup_class(cls): From b8a8fbc9933de1df3b269ac723e0dc66eefa4d80 Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Thu, 22 Jul 2021 15:42:26 +0200 Subject: [PATCH 244/279] Update PyTorch version in android workflow (#4202) --- android/build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/android/build.gradle b/android/build.gradle index b905bdf3a17..b5fd44a2b12 100644 --- a/android/build.gradle +++ b/android/build.gradle @@ -15,7 +15,7 @@ allprojects { androidSupportAppCompatV7Version = "28.0.0" fbjniJavaOnlyVersion = "0.0.3" soLoaderNativeLoaderVersion = "0.8.0" - pytorchAndroidVersion = "1.9.0-SNAPSHOT" + pytorchAndroidVersion = "1.10.0-SNAPSHOT" } repositories { From fbf0f066dd0ebdeb1cde51fecca44e9c57856dd2 Mon Sep 17 00:00:00 2001 From: Gary Miguel Date: Fri, 23 Jul 2021 00:52:09 -0700 Subject: [PATCH 245/279] Ignore direnv files (#4200) --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index 3a1e8b6232a..0f82f69402b 100644 --- a/.gitignore +++ b/.gitignore @@ -36,3 +36,7 @@ gen.yml ## Xcode User settings xcuserdata/ + +# direnv +.direnv +.envrc From bdc88f5245b276143f23da6a5df8f3f1fdbf9c7e Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Fri, 23 Jul 2021 11:02:04 +0200 Subject: [PATCH 246/279] Fix for macos wheel build by ignoring missing dependencies after delocate version update (#4201) Co-authored-by: Nicolas Hug --- packaging/build_wheel.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packaging/build_wheel.sh b/packaging/build_wheel.sh index f41ba4eb73a..f53b4ae431f 100755 --- a/packaging/build_wheel.sh +++ b/packaging/build_wheel.sh @@ -19,7 +19,7 @@ if [[ "$(uname)" == Darwin || "$OSTYPE" == "msys" ]]; then env_path=$(dirname $bin_path) if [[ "$(uname)" == Darwin ]]; then # Install delocate to relocate the required binaries - pip_install delocate + pip_install "delocate>=0.9" else cp "$bin_path/Library/bin/libpng16.dll" torchvision cp "$bin_path/Library/bin/libjpeg.dll" torchvision @@ -49,7 +49,7 @@ if [[ "$(uname)" == Darwin ]]; then bin_path=$(dirname $python_exec) env_path=$(dirname $bin_path) for whl in *.whl; do - DYLD_FALLBACK_LIBRARY_PATH="$env_path/lib/:$DYLD_FALLBACK_LIBRARY_PATH" delocate-wheel -v $whl + DYLD_FALLBACK_LIBRARY_PATH="$env_path/lib/:$DYLD_FALLBACK_LIBRARY_PATH" delocate-wheel -v --ignore-missing-dependencies $whl done else if [[ "$OSTYPE" == "msys" ]]; then From 693e0ae8d4ad5c48b5586fc84f6caa6b0e2fc704 Mon Sep 17 00:00:00 2001 From: Prabhat Roy Date: Sun, 25 Jul 2021 11:22:07 +0100 Subject: [PATCH 247/279] Fixed missing audio with pyav backend (#4064) --- test/test_video_reader.py | 36 ++++++++++++++++++++++++++++++------ torchvision/io/video.py | 17 ++++++++++++----- 2 files changed, 42 insertions(+), 11 deletions(-) diff --git a/test/test_video_reader.py b/test/test_video_reader.py index 10a6c242a1e..7029f6502ae 100644 --- a/test/test_video_reader.py +++ b/test/test_video_reader.py @@ -1,4 +1,5 @@ import collections +import itertools import math import os import unittest @@ -1243,16 +1244,39 @@ def test_invalid_file(self): with self.assertRaises(RuntimeError): io.read_video('foo.mp4') - def test_audio_present(self): - """Test if audio frames are returned with video_reader backend.""" - set_video_backend('video_reader') + def test_audio_present_pts(self): + """Test if audio frames are returned with pts unit.""" + backends = ['video_reader', 'pyav'] + start_offsets = [0, 1000] + end_offsets = [3000, None] + for test_video, _ in test_videos.items(): + full_path = os.path.join(VIDEO_DIR, test_video) + container = av.open(full_path) + if container.streams.audio: + for backend, start_offset, end_offset in itertools.product( + backends, start_offsets, end_offsets): + set_video_backend(backend) + _, audio, _ = io.read_video( + full_path, start_offset, end_offset, pts_unit='pts') + self.assertGreaterEqual(audio.shape[0], 1) + self.assertGreaterEqual(audio.shape[1], 1) + + def test_audio_present_sec(self): + """Test if audio frames are returned with sec unit.""" + backends = ['video_reader', 'pyav'] + start_offsets = [0, 0.1] + end_offsets = [0.3, None] for test_video, _ in test_videos.items(): full_path = os.path.join(VIDEO_DIR, test_video) container = av.open(full_path) if container.streams.audio: - _, audio, _ = io.read_video(full_path) - self.assertGreaterEqual(audio.shape[0], 1) - self.assertGreaterEqual(audio.shape[1], 1) + for backend, start_offset, end_offset in itertools.product( + backends, start_offsets, end_offsets): + set_video_backend(backend) + _, audio, _ = io.read_video( + full_path, start_offset, end_offset, pts_unit='sec') + self.assertGreaterEqual(audio.shape[0], 1) + self.assertGreaterEqual(audio.shape[1], 1) if __name__ == "__main__": diff --git a/torchvision/io/video.py b/torchvision/io/video.py index deab193eda3..e39b0dae301 100644 --- a/torchvision/io/video.py +++ b/torchvision/io/video.py @@ -283,22 +283,25 @@ def read_video( info = {} video_frames = [] audio_frames = [] + audio_timebase = _video_opt.default_timebase try: with av.open(filename, metadata_errors="ignore") as container: + if container.streams.audio: + audio_timebase = container.streams.audio[0].time_base time_base = _video_opt.default_timebase if container.streams.video: time_base = container.streams.video[0].time_base elif container.streams.audio: time_base = container.streams.audio[0].time_base # video_timebase is the default time_base - start_pts_sec, end_pts_sec, pts_unit = _video_opt._convert_to_sec( + start_pts, end_pts, pts_unit = _video_opt._convert_to_sec( start_pts, end_pts, pts_unit, time_base) if container.streams.video: video_frames = _read_from_stream( container, - start_pts_sec, - end_pts_sec, + start_pts, + end_pts, pts_unit, container.streams.video[0], {"video": 0}, @@ -311,8 +314,8 @@ def read_video( if container.streams.audio: audio_frames = _read_from_stream( container, - start_pts_sec, - end_pts_sec, + start_pts, + end_pts, pts_unit, container.streams.audio[0], {"audio": 0}, @@ -334,6 +337,10 @@ def read_video( if aframes_list: aframes = np.concatenate(aframes_list, 1) aframes = torch.as_tensor(aframes) + if pts_unit == 'sec': + start_pts = int(math.floor(start_pts * (1 / audio_timebase))) + if end_pts != float("inf"): + end_pts = int(math.ceil(end_pts * (1 / audio_timebase))) aframes = _align_audio_frames(aframes, audio_frames, start_pts, end_pts) else: aframes = torch.empty((1, 0), dtype=torch.float32) From 8d540228b8ac8b52749d32ecf5782aef45391775 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 26 Jul 2021 10:46:45 +0100 Subject: [PATCH 248/279] Remove TestCase dependency for test_models_detection_anchor_utils.py (#4207) --- test/test_models_detection_anchor_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/test_models_detection_anchor_utils.py b/test/test_models_detection_anchor_utils.py index 4477e9e1566..694ef315a1f 100644 --- a/test/test_models_detection_anchor_utils.py +++ b/test/test_models_detection_anchor_utils.py @@ -1,11 +1,11 @@ import torch -from common_utils import TestCase, assert_equal +from common_utils import assert_equal from torchvision.models.detection.anchor_utils import AnchorGenerator, DefaultBoxGenerator from torchvision.models.detection.image_list import ImageList import pytest -class Tester(TestCase): +class Tester: def test_incorrect_anchors(self): incorrect_sizes = ((2, 4, 8), (32, 8), ) incorrect_aspects = (0.5, 1.0) From 30fd10bd04a1890886c33b71b743987cc19f0102 Mon Sep 17 00:00:00 2001 From: "Edward Z. Yang" Date: Tue, 27 Jul 2021 15:14:51 -0400 Subject: [PATCH 249/279] Replace set_deterministic with non-deprecated spelling (#4212) Signed-off-by: Edward Z. Yang --- test/test_functional_tensor.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 5ce82304569..e641f8ca62e 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -719,7 +719,7 @@ def test_autocontrast(device, dtype): @pytest.mark.parametrize('device', cpu_and_gpu()) def test_equalize(device): - torch.set_deterministic(False) + torch.use_deterministic_algorithms(False) check_functional_vs_PIL_vs_scripted( F.equalize, F_pil.equalize, From e2dbadbf4f47b7b59e9a7c1b8c9bf9a34a582f8f Mon Sep 17 00:00:00 2001 From: vfdev Date: Wed, 28 Jul 2021 14:17:53 +0200 Subject: [PATCH 250/279] [1/2] Added backward pass on CPU for interpolation with anti-alias option (#4208) * WIP on backward op interpolation with AA * Removed cuda tests and reformat cpp code * Fixed clang wrong formatting * Added channels last test case Co-authored-by: vfdev-5 Co-authored-by: Francisco Massa --- test/test_functional_tensor.py | 47 +++ .../csrc/ops/cpu/interpolate_aa_kernels.cpp | 333 +++++++++++++++--- .../csrc/ops/cuda/interpolate_aa_kernels.cu | 33 +- torchvision/csrc/ops/interpolate_aa.cpp | 59 ++-- torchvision/csrc/ops/interpolate_aa.h | 20 +- torchvision/transforms/functional_tensor.py | 4 +- 6 files changed, 407 insertions(+), 89 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index e641f8ca62e..9b4c1b5f9af 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -1,3 +1,4 @@ +from functools import partial import itertools import os import colorsys @@ -578,6 +579,52 @@ def test_assert_resize_antialias(interpolation): F.resize(tensor, size=(5, 5), interpolation=interpolation, antialias=True) +@pytest.mark.parametrize('dt', [torch.float32, torch.float64, torch.float16]) +@pytest.mark.parametrize('size', [[10, 7], [10, 42], [42, 7]]) +@pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC]) +def test_interpolate_antialias_backward(dt, size, interpolation): + + # temporarily hard-code device as CPU, CUDA support will be done later + device = "cpu" + + if dt == torch.float16 and device == "cpu": + # skip float16 on CPU case + return + + torch.manual_seed(12) + if interpolation == BILINEAR: + forward_op = torch.ops.torchvision._interpolate_bilinear2d_aa + backward_op = torch.ops.torchvision._interpolate_bilinear2d_aa_backward + elif interpolation == BICUBIC: + forward_op = torch.ops.torchvision._interpolate_bicubic2d_aa + backward_op = torch.ops.torchvision._interpolate_bicubic2d_aa_backward + + class F(torch.autograd.Function): + + @staticmethod + def forward(ctx, i): + result = forward_op(i, size, False) + ctx.save_for_backward(i, result) + return result + + @staticmethod + def backward(ctx, grad_output): + i, result = ctx.saved_tensors + ishape = i.shape + oshape = result.shape[2:] + return backward_op(grad_output, oshape, ishape, False) + + x = ( + torch.rand(1, 32, 29, 3, dtype=torch.double, device=device).permute(0, 3, 1, 2).requires_grad_(True), + ) + assert torch.autograd.gradcheck(F.apply, x, eps=1e-8, atol=1e-6, rtol=1e-6, fast_mode=False) + + x = ( + torch.rand(1, 3, 32, 29, dtype=torch.double, device=device, requires_grad=True), + ) + assert torch.autograd.gradcheck(F.apply, x, eps=1e-8, atol=1e-6, rtol=1e-6, fast_mode=False) + + def check_functional_vs_PIL_vs_scripted(fn, fn_pil, fn_t, config, device, dtype, tol=2.0 + 1e-10, agg_method="max"): script_fn = torch.jit.script(fn) diff --git a/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp b/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp index 97b025aafb4..32652466916 100644 --- a/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp +++ b/torchvision/csrc/ops/cpu/interpolate_aa_kernels.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -141,6 +142,41 @@ void ti_cpu_upsample_generic_aa( // Helper structs to use with ti_upsample_generic_Nd_kernel_impl template struct HelperInterpBase { + template + static inline void _compute_weights_aa( + const int64_t i, + const int64_t input_size, + const scalar_t scale, + const scalar_t support, + scalar_t* wt_ptr, + const int64_t interp_size, + filter_fn_t filter_fn, + int64_t& xmin, + int64_t& xsize) { + scalar_t center = scale * (i + 0.5); + scalar_t total_w = 0.0; + scalar_t invscale = (scale >= 1.0) ? 1.0 / scale : 1.0; + xmin = std::max( + static_cast(center - support + 0.5), static_cast(0)); + xsize = std::min(static_cast(center + support + 0.5), input_size) - + xmin; + + int64_t j = 0; + for (; j < xsize; j++) { + scalar_t w = filter_fn((j + xmin - center + 0.5) * invscale); + wt_ptr[j] = w; + total_w += w; + } + for (j = 0; j < xsize; j++) { + if (total_w != 0.0) { + wt_ptr[j] /= total_w; + } + } + for (; j < interp_size; j++) { + wt_ptr[j] = static_cast(0.0); + } + } + template static inline std::vector _compute_indices_weights_aa( int64_t input_size, @@ -187,43 +223,30 @@ struct HelperInterpBase { empty(new_shape, CPU(c10::CppTypeToScalarType()))); } - scalar_t center, total_w, invscale = (scale >= 1.0) ? 1.0 / scale : 1.0; - index_t zero = static_cast(0); int64_t* idx_ptr_xmin = output[0].data_ptr(); int64_t* idx_ptr_size = output[1].data_ptr(); int64_t* idx_ptr_stride = output[2].data_ptr(); scalar_t* wt_ptr = output[3].data_ptr(); int64_t* wt_idx_ptr = output[4].data_ptr(); - int64_t xmin, xmax, j; + int64_t xmin, xmax; for (int64_t i = 0; i < output_size; i++) { - center = scale * (i + 0.5); - xmin = std::max(static_cast(center - support + 0.5), zero); - xmax = - std::min(static_cast(center + support + 0.5), input_size) - - xmin; + HelperInterpBase::_compute_weights_aa( + i, + input_size, + scale, + support, + wt_ptr + i * interp_size, + interp_size, + filter_fn, + xmin, + xmax); + idx_ptr_xmin[i] = xmin * stride; idx_ptr_size[i] = xmax; idx_ptr_stride[i] = stride; - wt_idx_ptr[i] = i * interp_size * sizeof(scalar_t); - - total_w = 0.0; - for (j = 0; j < xmax; j++) { - scalar_t w = filter_fn((j + xmin - center + 0.5) * invscale); - wt_ptr[i * interp_size + j] = w; - total_w += w; - } - for (j = 0; j < xmax; j++) { - if (total_w != 0.0) { - wt_ptr[i * interp_size + j] /= total_w; - } - } - - for (; j < interp_size; j++) { - wt_ptr[i * interp_size + j] = static_cast(0.0); - } } return output; } @@ -475,6 +498,151 @@ void _ti_upsample_bicubic2d_kernel_impl( output, input, align_corners, {scales_h, scales_w}, antialias); } +template < + typename scalar_t, + typename scale_type, + template + class F> +void cpu_upsample_genNd_backward_aa( + const Tensor& grad_input_, + const Tensor& grad_output_, + bool align_corners, + const scale_type& scales) { + TORCH_CHECK( + grad_input_.dtype() == grad_output_.dtype(), + "expected dtype ", + grad_output_.dtype(), + " for `grad_input` but got dtype ", + grad_input_.dtype()); + + auto grad_output = grad_output_.contiguous(); + auto grad_input = grad_input_.contiguous(); + + auto grad_output_data = grad_output.data_ptr(); + auto grad_input_data = grad_input.data_ptr(); + auto input_sizes = grad_input.sizes().vec(); + auto output_sizes = grad_output.sizes().vec(); + auto ndim = input_sizes.size(); + + // treat nbatch and channels as one dimension + int64_t channels = input_sizes[0] * input_sizes[1]; + int64_t input_depth = (ndim == 5) ? input_sizes[2] : 1; + int64_t output_depth = (ndim == 5) ? output_sizes[2] : 1; + int64_t input_height = (ndim >= 4) ? input_sizes[ndim - 2] : 1; + int64_t output_height = (ndim >= 4) ? output_sizes[ndim - 2] : 1; + int64_t input_width = input_sizes[ndim - 1]; + int64_t output_width = output_sizes[ndim - 1]; + + int64_t output_slice_size = output_depth * output_height * output_width; + int interp_size = F::interp_size; + + auto loop2d = [&](int64_t begin, int64_t end) { + const scalar_t height_scale = area_pixel_compute_scale( + input_height, output_height, align_corners, scales[0]); + const scalar_t width_scale = area_pixel_compute_scale( + input_width, output_width, align_corners, scales[1]); + + auto input_indexr = [=](int64_t c, int64_t h, int64_t w) { + return grad_input_data + c * input_height * input_width + + h * input_width + w; + }; + + const scalar_t support_h = (height_scale >= 1.0) + ? (interp_size * 0.5) * height_scale + : interp_size * 0.5; + const scalar_t support_w = (width_scale >= 1.0) + ? (interp_size * 0.5) * width_scale + : interp_size * 0.5; + + const int interp_height = (int)ceilf(support_h) * 2 + 1; + const int interp_width = (int)ceilf(support_w) * 2 + 1; + + std::vector wx(interp_width, 0.0); + std::vector wy(interp_height, 0.0); + + // NOLINTNEXTLINE(cppcoreguidelines-init-variables) + int64_t xmin, ymin; + int64_t xsize, ysize; + auto filter_fn = F::_filter; + + for (int64_t oh = 0; oh < output_height; oh++) { + F::_compute_weights_aa( + oh, + input_height, + height_scale, + support_h, + wy.data(), + interp_height, + filter_fn, + ymin, + ysize); + + for (int64_t ow = 0; ow < output_width; ow++) { + F::_compute_weights_aa( + ow, + input_width, + width_scale, + support_w, + wx.data(), + interp_width, + filter_fn, + xmin, + xsize); + + for (int64_t c = begin; c < end; c++) { + scalar_t grad_output_value = + grad_output_data[c * output_slice_size + oh * output_width + ow]; + + for (size_t y = 0; y < ysize; y++) { + for (size_t x = 0; x < xsize; x++) { + *input_indexr(c, ymin + y, xmin + x) += + wx[x] * wy[y] * grad_output_value; + } + } + } + } + } + }; + + if (ndim == 4) { + // upsample bilinear 2d + at::parallel_for( + 0, channels, at::internal::GRAIN_SIZE / output_slice_size / 4, loop2d); + } else { + TORCH_CHECK(false, "Unsupported tensor ndim"); + } + + if (!grad_input_.is_contiguous()) { + grad_input_.copy_(grad_input); + } +} + +void _upsample_bilinear2d_aa_backward_kernel_impl( + const Tensor& grad_input, + const Tensor& grad_output, + bool align_corners, + c10::optional scales_h, + c10::optional scales_w) { + AT_DISPATCH_FLOATING_TYPES( + grad_output.scalar_type(), "upsample_bilinear2d_backward_cpu", [&] { + cpu_upsample_genNd_backward_aa( + grad_input, grad_output, align_corners, {scales_h, scales_w}); + }); +} + +void _upsample_bicubic2d_aa_backward_kernel_impl( + const Tensor& grad_input, + const Tensor& grad_output, + bool align_corners, + c10::optional scales_h, + c10::optional scales_w) { + AT_DISPATCH_FLOATING_TYPES( + grad_output.scalar_type(), "upsample_bicubic2d_backward_cpu", [&] { + cpu_upsample_genNd_backward_aa( + grad_input, grad_output, align_corners, {scales_h, scales_w}); + }); +} + } // namespace internal_upsample } // namespace native } // namespace at @@ -484,7 +652,7 @@ namespace ops { namespace { -at::Tensor interpolate_linear_aa_forward_kernel( +at::Tensor interpolate_bilinear2d_aa_forward_kernel( const at::Tensor& input, at::IntArrayRef output_size, bool align_corners) { @@ -515,7 +683,7 @@ at::Tensor interpolate_linear_aa_forward_kernel( return output; } -at::Tensor interpolate_bicubic_aa_forward_kernel( +at::Tensor interpolate_bicubic2d_aa_forward_kernel( const at::Tensor& input, at::IntArrayRef output_size, bool align_corners) { @@ -546,26 +714,109 @@ at::Tensor interpolate_bicubic_aa_forward_kernel( return output; } -// TODO: Implement backward function -// at::Tensor interpolate_linear_aa_backward_kernel( -// const at::Tensor& grad) { -// return grad_input; -// } +at::Tensor interpolate_bilinear2d_aa_backward_kernel( + const at::Tensor& grad_output, + at::IntArrayRef output_size, + at::IntArrayRef input_size, + bool align_corners) { + c10::optional> scale_factors = {}; + + // Copied from UpSampleBilinear2d.cpp::upsample_bilinear2d_backward + auto grad_input = at::empty({0}, grad_output.options()); + auto osize = at::native::upsample::compute_output_size( + input_size, output_size, scale_factors); + auto scale_h = at::native::upsample::get_scale_value(scale_factors, 0); + auto scale_w = at::native::upsample::get_scale_value(scale_factors, 1); + + auto full_output_size = + at::native::upsample_2d_common_check(input_size, osize); + + TORCH_CHECK( + grad_output.dim() == 4, + "Expected grad_output to be a tensor of dimension 4 but got: dimension ", + grad_output.dim()); + + for (int i = 0; i < 4; ++i) { + TORCH_CHECK( + grad_output.size(i) == full_output_size[i], + "Expected grad_output to have the same shape as output;", + " output.size(", + i, + ") = ", + full_output_size[i], + " but got grad_output.size(", + i, + ") = ", + grad_output.size(i)); + } + + grad_input.resize_(input_size, grad_output.suggest_memory_format()); + grad_input.zero_(); + at::native::internal_upsample::_upsample_bilinear2d_aa_backward_kernel_impl( + grad_input, grad_output, align_corners, scale_h, scale_w); + + return grad_input; +} + +at::Tensor interpolate_bicubic2d_aa_backward_kernel( + const at::Tensor& grad_output, + at::IntArrayRef output_size, + at::IntArrayRef input_size, + bool align_corners) { + c10::optional> scale_factors = {}; + + // Copied from UpSampleBicubic2d.cpp::upsample_bicubic2d_backward + auto grad_input = at::empty({0}, grad_output.options()); + auto osize = at::native::upsample::compute_output_size( + input_size, output_size, scale_factors); + auto scale_h = at::native::upsample::get_scale_value(scale_factors, 0); + auto scale_w = at::native::upsample::get_scale_value(scale_factors, 1); + + auto full_output_size = + at::native::upsample_2d_common_check(input_size, osize); + + TORCH_CHECK( + grad_output.dim() == 4, + "Expected grad_output to be a tensor of dimension 4 but got: dimension ", + grad_output.dim()); + + for (int i = 0; i < 4; ++i) { + TORCH_CHECK( + grad_output.size(i) == full_output_size[i], + "Expected grad_output to have the same shape as output;", + " output.size(", + i, + ") = ", + full_output_size[i], + " but got grad_output.size(", + i, + ") = ", + grad_output.size(i)); + } + + grad_input.resize_(input_size, grad_output.suggest_memory_format()); + grad_input.zero_(); + at::native::internal_upsample::_upsample_bicubic2d_aa_backward_kernel_impl( + grad_input, grad_output, align_corners, scale_h, scale_w); + + return grad_input; +} } // namespace TORCH_LIBRARY_IMPL(torchvision, CPU, m) { m.impl( - TORCH_SELECTIVE_NAME("torchvision::_interpolate_linear_aa"), - TORCH_FN(interpolate_linear_aa_forward_kernel)); + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bilinear2d_aa"), + TORCH_FN(interpolate_bilinear2d_aa_forward_kernel)); m.impl( - TORCH_SELECTIVE_NAME("torchvision::_interpolate_bicubic_aa"), - TORCH_FN(interpolate_bicubic_aa_forward_kernel)); - - // TODO: Implement backward function - // m.impl( - // TORCH_SELECTIVE_NAME("torchvision::_interpolate_linear_aa_backward"), - // TORCH_FN(interpolate_linear_aa_backward_kernel)); + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bicubic2d_aa"), + TORCH_FN(interpolate_bicubic2d_aa_forward_kernel)); + m.impl( + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bilinear2d_aa_backward"), + TORCH_FN(interpolate_bilinear2d_aa_backward_kernel)); + m.impl( + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bicubic2d_aa_backward"), + TORCH_FN(interpolate_bicubic2d_aa_backward_kernel)); } } // namespace ops diff --git a/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu b/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu index 4259fa2b0e8..46525f4dd01 100644 --- a/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu +++ b/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu @@ -62,23 +62,22 @@ __device__ __forceinline__ static accscalar_t bicubic_filter(accscalar_t x) { template __device__ __forceinline__ static void _compute_weights( - const int64_t i, - const int64_t input_size, + const int i, + const int input_size, const accscalar_t scale, const accscalar_t support, scalar_t* wt_ptr, - int64_t interp_size, + int interp_size, filter_fn_t filter_fn, - int64_t& xmin, - int64_t& xmax) { + int& xmin, + int& xmax) { accscalar_t invscale = (scale >= 1.0) ? 1.0 / scale : 1.0; accscalar_t center = scale * (i + 0.5); - xmin = max( - static_cast(center - support + 0.5), static_cast(0)); - xmax = min(static_cast(center + support + 0.5), input_size) - xmin; + xmin = max(static_cast(center - support + 0.5), static_cast(0)); + xmax = min(static_cast(center + support + 0.5), input_size) - xmin; accscalar_t total_w = 0.0; - int64_t j = 0; + int j = 0; for (j = 0; j < xmax; j++) { accscalar_t w = filter_fn((j + xmin - center + 0.5) * invscale); wt_ptr[j] = static_cast(w); @@ -164,7 +163,7 @@ __global__ void upsample_gen2d_out_frame( scalar_t buffer2[256]; // Compute weights - int64_t xmin, xsize, ymin, ysize; + int xmin, xsize, ymin, ysize; typedef scalar_t (*filter_fn_t)(scalar_t); if (interp_size == 2) { _compute_weights( @@ -213,7 +212,7 @@ __global__ void upsample_gen2d_out_frame( for (int n = 0; n < batchsize; n++) { for (int c = 0; c < channels; ++c) { // interpolate on x-axis for ymin to ymin + ysize - for (int64_t y = 0; y < ysize; y++) { + for (int y = 0; y < ysize; y++) { // copy data into the local buffer and use // interpolate_aa_single_dim method for (int x = 0; x < xsize; x++) { @@ -372,7 +371,7 @@ at::Tensor interpolate_gen2d_aa_forward_kernel( return output; } -at::Tensor interpolate_linear_aa_forward_kernel( +at::Tensor interpolate_bilinear2d_aa_forward_kernel( const at::Tensor& input, at::IntArrayRef output_size, bool align_corners) { @@ -380,7 +379,7 @@ at::Tensor interpolate_linear_aa_forward_kernel( input, output_size, align_corners); } -at::Tensor interpolate_bicubic_aa_forward_kernel( +at::Tensor interpolate_bicubic2d_aa_forward_kernel( const at::Tensor& input, at::IntArrayRef output_size, bool align_corners) { @@ -392,11 +391,11 @@ at::Tensor interpolate_bicubic_aa_forward_kernel( TORCH_LIBRARY_IMPL(torchvision, CUDA, m) { m.impl( - TORCH_SELECTIVE_NAME("torchvision::_interpolate_linear_aa"), - TORCH_FN(interpolate_linear_aa_forward_kernel)); + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bilinear2d_aa"), + TORCH_FN(interpolate_bilinear2d_aa_forward_kernel)); m.impl( - TORCH_SELECTIVE_NAME("torchvision::_interpolate_bicubic_aa"), - TORCH_FN(interpolate_bicubic_aa_forward_kernel)); + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bicubic2d_aa"), + TORCH_FN(interpolate_bicubic2d_aa_forward_kernel)); } } // namespace ops diff --git a/torchvision/csrc/ops/interpolate_aa.cpp b/torchvision/csrc/ops/interpolate_aa.cpp index 90bc26a1fb5..7f1680246a0 100644 --- a/torchvision/csrc/ops/interpolate_aa.cpp +++ b/torchvision/csrc/ops/interpolate_aa.cpp @@ -5,54 +5,69 @@ namespace vision { namespace ops { -at::Tensor interpolate_linear_aa( +at::Tensor _interpolate_bilinear2d_aa( const at::Tensor& input, // Input image at::IntArrayRef output_size, // Output image size bool align_corners) // The flag to align corners { static auto op = c10::Dispatcher::singleton() - .findSchemaOrThrow("torchvision::_interpolate_linear_aa", "") - .typed(); + .findSchemaOrThrow("torchvision::_interpolate_bilinear2d_aa", "") + .typed(); return op.call(input, output_size, align_corners); } -at::Tensor interpolate_bicubic_aa( +at::Tensor _interpolate_bicubic_aa( const at::Tensor& input, // Input image at::IntArrayRef output_size, // Output image size bool align_corners) // The flag to align corners { static auto op = c10::Dispatcher::singleton() - .findSchemaOrThrow("torchvision::_interpolate_bicubic_aa", "") - .typed(); + .findSchemaOrThrow("torchvision::_interpolate_bicubic2d_aa", "") + .typed(); return op.call(input, output_size, align_corners); } namespace detail { -// TODO: Implement backward function -// at::Tensor _interpolate_linear_aa_backward( -// const at::Tensor& grad, -// at::IntArrayRef output_size, -// bool align_corners) -// { -// return at::Tensor(); -// } +at::Tensor _interpolate_bilinear2d_aa_backward( + const at::Tensor& grad_output, + at::IntArrayRef output_size, + at::IntArrayRef input_size, + bool align_corners) { + static auto op = + c10::Dispatcher::singleton() + .findSchemaOrThrow( + "torchvision::_interpolate_bilinear2d_aa_backward", "") + .typed(); + return op.call(grad_output, output_size, output_size, align_corners); +} + +at::Tensor _interpolate_bicubic2d_aa_backward( + const at::Tensor& grad_output, + at::IntArrayRef output_size, + at::IntArrayRef input_size, + bool align_corners) { + static auto op = + c10::Dispatcher::singleton() + .findSchemaOrThrow( + "torchvision::_interpolate_bicubic2d_aa_backward", "") + .typed(); + return op.call(grad_output, output_size, output_size, align_corners); +} } // namespace detail TORCH_LIBRARY_FRAGMENT(torchvision, m) { m.def(TORCH_SELECTIVE_SCHEMA( - "torchvision::_interpolate_linear_aa(Tensor input, int[] output_size, bool align_corners) -> Tensor")); + "torchvision::_interpolate_bilinear2d_aa(Tensor input, int[] output_size, bool align_corners) -> Tensor")); + m.def(TORCH_SELECTIVE_SCHEMA( + "torchvision::_interpolate_bicubic2d_aa(Tensor input, int[] output_size, bool align_corners) -> Tensor")); + m.def(TORCH_SELECTIVE_SCHEMA( + "torchvision::_interpolate_bilinear2d_aa_backward(Tensor input, int[] output_size, int[] input_size, bool align_corners) -> Tensor")); m.def(TORCH_SELECTIVE_SCHEMA( - "torchvision::_interpolate_bicubic_aa(Tensor input, int[] output_size, bool align_corners) -> Tensor")); - // TODO: Implement backward function - // m.def(TORCH_SELECTIVE_SCHEMA( - // "torchvision::_interpolate_linear_aa_backward(Tensor grad, Tensor rois, - // float spatial_scale, int pooled_height, int pooled_width, int - // batch_size, int channels, int height, int width, int sampling_ratio, - // bool aligned) -> Tensor")); + "torchvision::_interpolate_bicubic2d_aa_backward(Tensor input, int[] output_size, int[] input_size, bool align_corners) -> Tensor")); } } // namespace ops diff --git a/torchvision/csrc/ops/interpolate_aa.h b/torchvision/csrc/ops/interpolate_aa.h index 0a9ffb4b168..283418b3935 100644 --- a/torchvision/csrc/ops/interpolate_aa.h +++ b/torchvision/csrc/ops/interpolate_aa.h @@ -6,23 +6,29 @@ namespace vision { namespace ops { -VISION_API at::Tensor _interpolate_linear_aa( +VISION_API at::Tensor _interpolate_bilinear2d_aa( const at::Tensor& input, at::IntArrayRef output_size, bool align_corners = false); -VISION_API at::Tensor _interpolate_bicubic_aa( +VISION_API at::Tensor _interpolate_bicubic2d_aa( const at::Tensor& input, at::IntArrayRef output_size, bool align_corners = false); namespace detail { -// TODO: Implement backward function -// at::Tensor _interpolate_linear_aa_backward( -// const at::Tensor& grad, -// at::IntArrayRef output_size, -// bool align_corners=false); +VISION_API at::Tensor _interpolate_bilinear2d_aa_backward( + const at::Tensor& grad, + at::IntArrayRef output_size, + at::IntArrayRef input_size, + bool align_corners = false); + +VISION_API at::Tensor _interpolate_bicubic2d_aa_backward( + const at::Tensor& grad, + at::IntArrayRef output_size, + at::IntArrayRef input_size, + bool align_corners = false); } // namespace detail diff --git a/torchvision/transforms/functional_tensor.py b/torchvision/transforms/functional_tensor.py index a0e32d4237e..5a13bd5d392 100644 --- a/torchvision/transforms/functional_tensor.py +++ b/torchvision/transforms/functional_tensor.py @@ -545,9 +545,9 @@ def resize( if antialias: if interpolation == "bilinear": - img = torch.ops.torchvision._interpolate_linear_aa(img, [new_h, new_w], align_corners=False) + img = torch.ops.torchvision._interpolate_bilinear2d_aa(img, [new_h, new_w], align_corners=False) elif interpolation == "bicubic": - img = torch.ops.torchvision._interpolate_bicubic_aa(img, [new_h, new_w], align_corners=False) + img = torch.ops.torchvision._interpolate_bicubic2d_aa(img, [new_h, new_w], align_corners=False) else: img = interpolate(img, size=[new_h, new_w], mode=interpolation, align_corners=align_corners) From b29ed34f46ba328b46f3aadc5ac15f2a9417a3b0 Mon Sep 17 00:00:00 2001 From: Yiwen Song <34639474+sallysyw@users.noreply.github.com> Date: Wed, 28 Jul 2021 15:58:32 -0700 Subject: [PATCH 251/279] Port test/test_datasets.py to use pytest (#4215) * Port test_datasets.py to use pytest * A better replacement of self.assertSequenceEqual * Migrate from equality check to identity check --- test/datasets_utils.py | 21 ++++---- test/test_datasets.py | 116 ++++++++++++++++++++--------------------- 2 files changed, 66 insertions(+), 71 deletions(-) diff --git a/test/datasets_utils.py b/test/datasets_utils.py index d7853b46314..ca182b8d25f 100644 --- a/test/datasets_utils.py +++ b/test/datasets_utils.py @@ -14,6 +14,7 @@ import PIL import PIL.Image +import pytest import torch import torchvision.datasets import torchvision.io @@ -519,18 +520,18 @@ def _maybe_apply_patches(self, patchers): yield mocks def test_not_found_or_corrupted(self): - with self.assertRaises((FileNotFoundError, RuntimeError)): + with pytest.raises((FileNotFoundError, RuntimeError)): with self.create_dataset(inject_fake_data=False): pass def test_smoke(self): with self.create_dataset() as (dataset, _): - self.assertIsInstance(dataset, torchvision.datasets.VisionDataset) + assert isinstance(dataset, torchvision.datasets.VisionDataset) @test_all_configs def test_str_smoke(self, config): with self.create_dataset(config) as (dataset, _): - self.assertIsInstance(str(dataset), str) + assert isinstance(str(dataset), str) @test_all_configs def test_feature_types(self, config): @@ -540,23 +541,21 @@ def test_feature_types(self, config): if len(self.FEATURE_TYPES) > 1: actual = len(example) expected = len(self.FEATURE_TYPES) - self.assertEqual( - actual, - expected, - f"The number of the returned features does not match the the number of elements in FEATURE_TYPES: " - f"{actual} != {expected}", - ) + assert ( + actual == expected + ), "The number of the returned features does not match the the number of elements in FEATURE_TYPES: " + f"{actual} != {expected}" else: example = (example,) for idx, (feature, expected_feature_type) in enumerate(zip(example, self.FEATURE_TYPES)): with self.subTest(idx=idx): - self.assertIsInstance(feature, expected_feature_type) + assert isinstance(feature, expected_feature_type) @test_all_configs def test_num_examples(self, config): with self.create_dataset(config) as (dataset, info): - self.assertEqual(len(dataset), info["num_examples"]) + assert len(dataset) == info["num_examples"] @test_all_configs def test_transforms(self, config): diff --git a/test/test_datasets.py b/test/test_datasets.py index 043398a0ca6..a8a7f2b0e5c 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -16,6 +16,7 @@ import PIL import datasets_utils import numpy as np +import pytest import torch import torch.nn.functional as F from torchvision import datasets @@ -88,20 +89,20 @@ def inject_fake_data(self, tmpdir, config): def test_folds(self): for fold in range(10): with self.create_dataset(split="train", folds=fold) as (dataset, _): - self.assertEqual(len(dataset), fold + 1) + assert len(dataset) == fold + 1 def test_unlabeled(self): with self.create_dataset(split="unlabeled") as (dataset, _): labels = [dataset[idx][1] for idx in range(len(dataset))] - self.assertTrue(all(label == -1 for label in labels)) + assert all(label == -1 for label in labels) def test_invalid_folds1(self): - with self.assertRaises(ValueError): + with pytest.raises(ValueError): with self.create_dataset(folds=10): pass def test_invalid_folds2(self): - with self.assertRaises(ValueError): + with pytest.raises(ValueError): with self.create_dataset(folds="0"): pass @@ -167,23 +168,19 @@ def test_combined_targets(self): actual = len(individual_targets) expected = len(combined_targets) - self.assertEqual( - actual, - expected, - f"The number of the returned combined targets does not match the the number targets if requested " - f"individually: {actual} != {expected}", - ) + assert ( + actual == expected + ), "The number of the returned combined targets does not match the the number targets if requested " + f"individually: {actual} != {expected}", for target_type, combined_target, individual_target in zip(target_types, combined_targets, individual_targets): with self.subTest(target_type=target_type): actual = type(combined_target) expected = type(individual_target) - self.assertIs( - actual, - expected, - f"Type of the combined target does not match the type of the corresponding individual target: " - f"{actual} is not {expected}", - ) + assert ( + actual is expected + ), "Type of the combined target does not match the type of the corresponding individual target: " + f"{actual} is not {expected}", class Caltech256TestCase(datasets_utils.ImageDatasetTestCase): @@ -363,26 +360,26 @@ def test_combined_targets(self): with self.create_dataset(target_type=target_types) as (dataset, _): output = dataset[0] - self.assertTrue(isinstance(output, tuple)) - self.assertTrue(len(output) == 2) - self.assertTrue(isinstance(output[0], PIL.Image.Image)) - self.assertTrue(isinstance(output[1], tuple)) - self.assertTrue(len(output[1]) == 3) - self.assertTrue(isinstance(output[1][0], PIL.Image.Image)) # semantic - self.assertTrue(isinstance(output[1][1], dict)) # polygon - self.assertTrue(isinstance(output[1][2], PIL.Image.Image)) # color + assert isinstance(output, tuple) + assert len(output) == 2 + assert isinstance(output[0], PIL.Image.Image) + assert isinstance(output[1], tuple) + assert len(output[1]) == 3 + assert isinstance(output[1][0], PIL.Image.Image) # semantic + assert isinstance(output[1][1], dict) # polygon + assert isinstance(output[1][2], PIL.Image.Image) # color def test_feature_types_target_color(self): with self.create_dataset(target_type='color') as (dataset, _): color_img, color_target = dataset[0] - self.assertTrue(isinstance(color_img, PIL.Image.Image)) - self.assertTrue(np.array(color_target).shape[2] == 4) + assert isinstance(color_img, PIL.Image.Image) + assert np.array(color_target).shape[2] == 4 def test_feature_types_target_polygon(self): with self.create_dataset(target_type='polygon') as (dataset, info): polygon_img, polygon_target = dataset[0] - self.assertTrue(isinstance(polygon_img, PIL.Image.Image)) - self.assertEqual(polygon_target, info['expected_polygon_target']) + assert isinstance(polygon_img, PIL.Image.Image) + (polygon_target, info['expected_polygon_target']) class ImageNetTestCase(datasets_utils.ImageDatasetTestCase): @@ -469,7 +466,7 @@ def test_class_to_idx(self): with self.create_dataset() as (dataset, info): expected = {category: label for label, category in enumerate(info["categories"])} actual = dataset.class_to_idx - self.assertEqual(actual, expected) + assert actual == expected class CIFAR100(CIFAR10TestCase): @@ -573,33 +570,29 @@ def test_combined_targets(self): actual = len(individual_targets) expected = len(combined_targets) - self.assertEqual( - actual, - expected, - f"The number of the returned combined targets does not match the the number targets if requested " - f"individually: {actual} != {expected}", - ) + assert ( + actual == expected + ), "The number of the returned combined targets does not match the the number targets if requested " + f"individually: {actual} != {expected}", for target_type, combined_target, individual_target in zip(target_types, combined_targets, individual_targets): with self.subTest(target_type=target_type): actual = type(combined_target) expected = type(individual_target) - self.assertIs( - actual, - expected, - f"Type of the combined target does not match the type of the corresponding individual target: " - f"{actual} is not {expected}", - ) + assert ( + actual is expected + ), "Type of the combined target does not match the type of the corresponding individual target: " + f"{actual} is not {expected}", def test_no_target(self): with self.create_dataset(target_type=[]) as (dataset, _): _, target = dataset[0] - self.assertIsNone(target) + assert target is None def test_attr_names(self): with self.create_dataset() as (dataset, info): - self.assertEqual(tuple(dataset.attr_names), info["attr_names"]) + assert tuple(dataset.attr_names) == info["attr_names"] class VOCSegmentationTestCase(datasets_utils.ImageDatasetTestCase): @@ -704,16 +697,16 @@ def test_annotations(self): with self.create_dataset() as (dataset, info): _, target = dataset[0] - self.assertIn("annotation", target) + assert "annotation" in target annotation = target["annotation"] - self.assertIn("object", annotation) + assert "object" in annotation objects = annotation["object"] - self.assertEqual(len(objects), 1) + assert len(objects) == 1 object = objects[0] - self.assertEqual(object, info["annotation"]) + assert object == info["annotation"] class CocoDetectionTestCase(datasets_utils.ImageDatasetTestCase): @@ -789,7 +782,7 @@ def _create_annotations(self, image_ids, num_annotations_per_image): def test_captions(self): with self.create_dataset() as (dataset, info): _, captions = dataset[0] - self.assertEqual(tuple(captions), tuple(info["captions"])) + assert tuple(captions) == tuple(info["captions"]) class UCF101TestCase(datasets_utils.VideoDatasetTestCase): @@ -940,7 +933,7 @@ def _create_lmdb(self, root, cls): def test_not_found_or_corrupted(self): # LSUN does not raise built-in exception, but a custom one. It is expressive enough to not 'cast' it to # RuntimeError or FileNotFoundError that are normally checked by this test. - with self.assertRaises(datasets_utils.lazy_importer.lmdb.Error): + with pytest.raises(datasets_utils.lazy_importer.lmdb.Error): super().test_not_found_or_corrupted() @@ -1369,7 +1362,8 @@ def _create_captions(self, num_captions_per_image): def test_captions(self): with self.create_dataset() as (dataset, info): _, captions = dataset[0] - self.assertSequenceEqual(captions, info["captions"]) + assert len(captions) == len(info["captions"]) + assert all([a == b for a, b in zip(captions, info["captions"])]) class Flickr30kTestCase(Flickr8kTestCase): @@ -1513,7 +1507,7 @@ def test_num_examples_test50k(self): with self.create_dataset(what="test50k") as (dataset, info): # Since the split 'test50k' selects all images beginning from the index 10000, we subtract the number of # created examples by this. - self.assertEqual(len(dataset), info["num_examples"] - 10000) + assert len(dataset) == info["num_examples"] - 10000 class DatasetFolderTestCase(datasets_utils.ImageDatasetTestCase): @@ -1578,12 +1572,13 @@ def test_is_valid_file(self, config): with self.create_dataset( config, extensions=None, is_valid_file=lambda file: pathlib.Path(file).suffix[1:] in extensions ) as (dataset, info): - self.assertEqual(len(dataset), info["num_examples"]) + assert len(dataset) == info["num_examples"] @datasets_utils.test_all_configs def test_classes(self, config): with self.create_dataset(config) as (dataset, info): - self.assertSequenceEqual(dataset.classes, info["classes"]) + assert len(dataset.classes) == len(info["classes"]) + assert all([a == b for a, b in zip(dataset.classes, info["classes"])]) class ImageFolderTestCase(datasets_utils.ImageDatasetTestCase): @@ -1603,7 +1598,8 @@ def inject_fake_data(self, tmpdir, config): @datasets_utils.test_all_configs def test_classes(self, config): with self.create_dataset(config) as (dataset, info): - self.assertSequenceEqual(dataset.classes, info["classes"]) + assert len(dataset.classes) == len(info["classes"]) + assert all([a == b for a, b in zip(dataset.classes, info["classes"])]) class KittiTestCase(datasets_utils.ImageDatasetTestCase): @@ -1742,15 +1738,15 @@ def inject_fake_data(self, tmpdir, config): def test_classes(self): classes = list(map(lambda x: x[0], self._CATEGORIES_CONTENT)) with self.create_dataset() as (dataset, _): - self.assertEqual(dataset.classes, classes) + assert dataset.classes == classes def test_class_to_idx(self): class_to_idx = dict(self._CATEGORIES_CONTENT) with self.create_dataset() as (dataset, _): - self.assertEqual(dataset.class_to_idx, class_to_idx) + assert dataset.class_to_idx == class_to_idx def test_images_download_preexisting(self): - with self.assertRaises(RuntimeError): + with pytest.raises(RuntimeError): with self.create_dataset({'download': True}): pass @@ -1788,9 +1784,9 @@ def test_targets(self): with self.create_dataset(target_type=target_types, version="2021_valid") as (dataset, _): items = [d[1] for d in dataset] for i, item in enumerate(items): - self.assertEqual(dataset.category_name("kingdom", item[0]), "Akingdom") - self.assertEqual(dataset.category_name("phylum", item[1]), f"{i // 3}phylum") - self.assertEqual(item[6], i // 3) + assert dataset.category_name("kingdom", item[0]) == "Akingdom" + assert dataset.category_name("phylum", item[1]) == f"{i // 3}phylum" + assert item[6] == i // 3 if __name__ == "__main__": From de96b977112e092510207950615103292e618b89 Mon Sep 17 00:00:00 2001 From: F-G Fernandez Date: Thu, 29 Jul 2021 16:49:08 +0200 Subject: [PATCH 252/279] Added missing typing annotations in datasets/hmdb51 (#4169) * style: Added missing typing annotations * style: Fixed last missing typing annotation * chore: Fixed missing import * style: Fixed typing * refactor: Switched file selection from list to set Co-authored-by: Philip Meier Co-authored-by: Vasilis Vryniotis --- torchvision/datasets/hmdb51.py | 36 +++++++++++++++++++++++----------- 1 file changed, 25 insertions(+), 11 deletions(-) diff --git a/torchvision/datasets/hmdb51.py b/torchvision/datasets/hmdb51.py index 4912eb01600..8d90c916b84 100644 --- a/torchvision/datasets/hmdb51.py +++ b/torchvision/datasets/hmdb51.py @@ -1,5 +1,7 @@ import glob import os +from typing import Optional, Callable, Tuple, Dict, Any, List +from torch import Tensor from .folder import find_classes, make_dataset from .video_utils import VideoClips @@ -52,10 +54,23 @@ class HMDB51(VisionDataset): TRAIN_TAG = 1 TEST_TAG = 2 - def __init__(self, root, annotation_path, frames_per_clip, step_between_clips=1, - frame_rate=None, fold=1, train=True, transform=None, - _precomputed_metadata=None, num_workers=1, _video_width=0, - _video_height=0, _video_min_dimension=0, _audio_samples=0): + def __init__( + self, + root: str, + annotation_path: str, + frames_per_clip: int, + step_between_clips: int = 1, + frame_rate: Optional[int] = None, + fold: int = 1, + train: bool = True, + transform: Optional[Callable] = None, + _precomputed_metadata: Optional[Dict[str, Any]] = None, + num_workers: int = 1, + _video_width: int = 0, + _video_height: int = 0, + _video_min_dimension: int = 0, + _audio_samples: int = 0, + ) -> None: super(HMDB51, self).__init__(root) if fold not in (1, 2, 3): raise ValueError("fold should be between 1 and 3, got {}".format(fold)) @@ -92,15 +107,15 @@ def __init__(self, root, annotation_path, frames_per_clip, step_between_clips=1, self.transform = transform @property - def metadata(self): + def metadata(self) -> Dict[str, Any]: return self.full_video_clips.metadata - def _select_fold(self, video_list, annotations_dir, fold, train): + def _select_fold(self, video_list: List[str], annotations_dir: str, fold: int, train: bool) -> List[int]: target_tag = self.TRAIN_TAG if train else self.TEST_TAG split_pattern_name = "*test_split{}.txt".format(fold) split_pattern_path = os.path.join(annotations_dir, split_pattern_name) annotation_paths = glob.glob(split_pattern_path) - selected_files = [] + selected_files = set() for filepath in annotation_paths: with open(filepath) as fid: lines = fid.readlines() @@ -108,8 +123,7 @@ def _select_fold(self, video_list, annotations_dir, fold, train): video_filename, tag_string = line.split() tag = int(tag_string) if tag == target_tag: - selected_files.append(video_filename) - selected_files = set(selected_files) + selected_files.add(video_filename) indices = [] for video_index, video_path in enumerate(video_list): @@ -118,10 +132,10 @@ def _select_fold(self, video_list, annotations_dir, fold, train): return indices - def __len__(self): + def __len__(self) -> int: return self.video_clips.num_clips() - def __getitem__(self, idx): + def __getitem__(self, idx: int) -> Tuple[Tensor, Tensor, int]: video, audio, _, video_idx = self.video_clips.get_clip(idx) sample_index = self.indices[video_idx] _, class_index = self.samples[sample_index] From a839796328cf4f789c9de5da0b3367b742b5a00c Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Fri, 30 Jul 2021 14:06:31 +0200 Subject: [PATCH 253/279] fix MacOS cmake workflow (#4203) * fix MacOS cmake workflow * try only mkl * only pin mkl on MacOs * fix Co-authored-by: Francisco Massa --- packaging/build_cmake.sh | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/packaging/build_cmake.sh b/packaging/build_cmake.sh index db4cc88b63f..5950c176b5d 100755 --- a/packaging/build_cmake.sh +++ b/packaging/build_cmake.sh @@ -28,7 +28,15 @@ fi setup_visual_studio_constraint setup_junit_results_folder -conda install -yq pytorch=$PYTORCH_VERSION $CONDA_CUDATOOLKIT_CONSTRAINT $CONDA_CPUONLY_FEATURE -c "pytorch-${UPLOAD_CHANNEL}" +if [[ "$(uname)" == Darwin ]]; then + # TODO: this can be removed as soon as mkl's CMake support works with clang + # see https://github.com/pytorch/vision/pull/4203 for details + MKL_CONSTRAINT='mkl==2021.2.0' +else + MKL_CONSTRAINT='' +fi + +conda install -yq \pytorch=$PYTORCH_VERSION $CONDA_CUDATOOLKIT_CONSTRAINT $CONDA_CPUONLY_FEATURE $MKL_CONSTRAINT -c "pytorch-${UPLOAD_CHANNEL}" TORCH_PATH=$(dirname $(python -c "import torch; print(torch.__file__)")) if [[ "$(uname)" == Darwin || "$OSTYPE" == "msys" ]]; then From 16b9a40c1ca9cc3be3587625d3d58271f9fd88c2 Mon Sep 17 00:00:00 2001 From: Vincent Moens Date: Mon, 2 Aug 2021 11:45:51 +0100 Subject: [PATCH 254/279] Pytest for test_videoapi.py and test_video_reader.py (#4233) * test_video_reader pytest refactoring * pytest refactoring of test_videoapi.py * test_video_reader pytest refactoring * pytest refactoring of test_videoapi.py * using pytest.approx for test_video_reader.py * using pytest.approx for test_videoapi.py * Fixing minor comments * linting fixes * minor comments Co-authored-by: Vincent Moens --- test/common_utils.py | 126 +----------------------------------- test/test_video_reader.py | 130 +++++++++++++++++--------------------- test/test_videoapi.py | 49 ++++++-------- 3 files changed, 80 insertions(+), 225 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index 1da5226f425..a8f5a91ef6b 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -3,6 +3,7 @@ import tempfile import contextlib import unittest +import pytest import argparse import sys import torch @@ -20,7 +21,7 @@ IS_PY39 = sys.version_info.major == 3 and sys.version_info.minor == 9 PY39_SEGFAULT_SKIP_MSG = "Segmentation fault with Python 3.9, see https://github.com/pytorch/vision/issues/3367" -PY39_SKIP = unittest.skipIf(IS_PY39, PY39_SEGFAULT_SKIP_MSG) +PY39_SKIP = pytest.mark.skipif(IS_PY39, reason=PY39_SEGFAULT_SKIP_MSG) IN_CIRCLE_CI = os.getenv("CIRCLECI", False) == 'true' IN_RE_WORKER = os.environ.get("INSIDE_RE_WORKER") is not None IN_FBCODE = os.environ.get("IN_FBCODE_TORCHVISION") == "1" @@ -83,129 +84,6 @@ def is_iterable(obj): return False -# adapted from TestCase in torch/test/common_utils to accept non-string -# inputs and set maximum binary size -class TestCase(unittest.TestCase): - precision = 1e-5 - - def assertEqual(self, x, y, prec=None, message='', allow_inf=False): - """ - This is copied from pytorch/test/common_utils.py's TestCase.assertEqual - """ - if isinstance(prec, str) and message == '': - message = prec - prec = None - if prec is None: - prec = self.precision - - if isinstance(x, torch.Tensor) and isinstance(y, Number): - self.assertEqual(x.item(), y, prec=prec, message=message, - allow_inf=allow_inf) - elif isinstance(y, torch.Tensor) and isinstance(x, Number): - self.assertEqual(x, y.item(), prec=prec, message=message, - allow_inf=allow_inf) - elif isinstance(x, torch.Tensor) and isinstance(y, torch.Tensor): - def assertTensorsEqual(a, b): - super(TestCase, self).assertEqual(a.size(), b.size(), message) - if a.numel() > 0: - if (a.device.type == 'cpu' and (a.dtype == torch.float16 or a.dtype == torch.bfloat16)): - # CPU half and bfloat16 tensors don't have the methods we need below - a = a.to(torch.float32) - b = b.to(a) - - if (a.dtype == torch.bool) != (b.dtype == torch.bool): - raise TypeError("Was expecting both tensors to be bool type.") - else: - if a.dtype == torch.bool and b.dtype == torch.bool: - # we want to respect precision but as bool doesn't support substraction, - # boolean tensor has to be converted to int - a = a.to(torch.int) - b = b.to(torch.int) - - diff = a - b - if a.is_floating_point(): - # check that NaNs are in the same locations - nan_mask = torch.isnan(a) - self.assertTrue(torch.equal(nan_mask, torch.isnan(b)), message) - diff[nan_mask] = 0 - # inf check if allow_inf=True - if allow_inf: - inf_mask = torch.isinf(a) - inf_sign = inf_mask.sign() - self.assertTrue(torch.equal(inf_sign, torch.isinf(b).sign()), message) - diff[inf_mask] = 0 - # TODO: implement abs on CharTensor (int8) - if diff.is_signed() and diff.dtype != torch.int8: - diff = diff.abs() - max_err = diff.max() - tolerance = prec + prec * abs(a.max()) - self.assertLessEqual(max_err, tolerance, message) - super(TestCase, self).assertEqual(x.is_sparse, y.is_sparse, message) - super(TestCase, self).assertEqual(x.is_quantized, y.is_quantized, message) - if x.is_sparse: - x = self.safeCoalesce(x) - y = self.safeCoalesce(y) - assertTensorsEqual(x._indices(), y._indices()) - assertTensorsEqual(x._values(), y._values()) - elif x.is_quantized and y.is_quantized: - self.assertEqual(x.qscheme(), y.qscheme(), prec=prec, - message=message, allow_inf=allow_inf) - if x.qscheme() == torch.per_tensor_affine: - self.assertEqual(x.q_scale(), y.q_scale(), prec=prec, - message=message, allow_inf=allow_inf) - self.assertEqual(x.q_zero_point(), y.q_zero_point(), - prec=prec, message=message, - allow_inf=allow_inf) - elif x.qscheme() == torch.per_channel_affine: - self.assertEqual(x.q_per_channel_scales(), y.q_per_channel_scales(), prec=prec, - message=message, allow_inf=allow_inf) - self.assertEqual(x.q_per_channel_zero_points(), y.q_per_channel_zero_points(), - prec=prec, message=message, - allow_inf=allow_inf) - self.assertEqual(x.q_per_channel_axis(), y.q_per_channel_axis(), - prec=prec, message=message) - self.assertEqual(x.dtype, y.dtype) - self.assertEqual(x.int_repr().to(torch.int32), - y.int_repr().to(torch.int32), prec=prec, - message=message, allow_inf=allow_inf) - else: - assertTensorsEqual(x, y) - elif isinstance(x, string_classes) and isinstance(y, string_classes): - super(TestCase, self).assertEqual(x, y, message) - elif type(x) == set and type(y) == set: - super(TestCase, self).assertEqual(x, y, message) - elif isinstance(x, dict) and isinstance(y, dict): - if isinstance(x, OrderedDict) and isinstance(y, OrderedDict): - self.assertEqual(x.items(), y.items(), prec=prec, - message=message, allow_inf=allow_inf) - else: - self.assertEqual(set(x.keys()), set(y.keys()), prec=prec, - message=message, allow_inf=allow_inf) - key_list = list(x.keys()) - self.assertEqual([x[k] for k in key_list], - [y[k] for k in key_list], - prec=prec, message=message, - allow_inf=allow_inf) - elif is_iterable(x) and is_iterable(y): - super(TestCase, self).assertEqual(len(x), len(y), message) - for x_, y_ in zip(x, y): - self.assertEqual(x_, y_, prec=prec, message=message, - allow_inf=allow_inf) - elif isinstance(x, bool) and isinstance(y, bool): - super(TestCase, self).assertEqual(x, y, message) - elif isinstance(x, Number) and isinstance(y, Number): - inf = float("inf") - if abs(x) == inf or abs(y) == inf: - if allow_inf: - super(TestCase, self).assertEqual(x, y, message) - else: - self.fail("Expected finite numeric values - x={}, y={}".format(x, y)) - return - super(TestCase, self).assertLessEqual(abs(x - y), prec, message) - else: - super(TestCase, self).assertEqual(x, y, message) - - @contextlib.contextmanager def freeze_rng_state(): rng_state = torch.get_rng_state() diff --git a/test/test_video_reader.py b/test/test_video_reader.py index 7029f6502ae..74d054c337d 100644 --- a/test/test_video_reader.py +++ b/test/test_video_reader.py @@ -2,7 +2,8 @@ import itertools import math import os -import unittest +import pytest +from pytest import approx from fractions import Fraction import numpy as np @@ -268,9 +269,9 @@ def _get_video_tensor(video_dir, video_file): return full_path, video_tensor -@unittest.skipIf(av is None, "PyAV unavailable") -@unittest.skipIf(_HAS_VIDEO_OPT is False, "Didn't compile with ffmpeg") -class TestVideoReader(unittest.TestCase): +@pytest.mark.skipif(av is None, reason="PyAV unavailable") +@pytest.mark.skipif(_HAS_VIDEO_OPT is False, reason="Didn't compile with ffmpeg") +class TestVideoReader: def check_separate_decoding_result(self, tv_result, config): """check the decoding results from TorchVision decoder """ @@ -282,45 +283,46 @@ def check_separate_decoding_result(self, tv_result, config): video_duration = vduration.item() * Fraction( vtimebase[0].item(), vtimebase[1].item() ) - self.assertAlmostEqual(video_duration, config.duration, delta=0.5) + assert video_duration == approx(config.duration, abs=0.5) + + assert vfps.item() == approx(config.video_fps, abs=0.5) - self.assertAlmostEqual(vfps.item(), config.video_fps, delta=0.5) if asample_rate.numel() > 0: - self.assertEqual(asample_rate.item(), config.audio_sample_rate) + assert asample_rate.item() == config.audio_sample_rate audio_duration = aduration.item() * Fraction( atimebase[0].item(), atimebase[1].item() ) - self.assertAlmostEqual(audio_duration, config.duration, delta=0.5) + assert audio_duration == approx(config.duration, abs=0.5) # check if pts of video frames are sorted in ascending order for i in range(len(vframe_pts) - 1): - self.assertEqual(vframe_pts[i] < vframe_pts[i + 1], True) + assert vframe_pts[i] < vframe_pts[i + 1] if len(aframe_pts) > 1: # check if pts of audio frames are sorted in ascending order for i in range(len(aframe_pts) - 1): - self.assertEqual(aframe_pts[i] < aframe_pts[i + 1], True) + assert aframe_pts[i] < aframe_pts[i + 1] def check_probe_result(self, result, config): vtimebase, vfps, vduration, atimebase, asample_rate, aduration = result video_duration = vduration.item() * Fraction( vtimebase[0].item(), vtimebase[1].item() ) - self.assertAlmostEqual(video_duration, config.duration, delta=0.5) - self.assertAlmostEqual(vfps.item(), config.video_fps, delta=0.5) + assert video_duration == approx(config.duration, abs=0.5) + assert vfps.item() == approx(config.video_fps, abs=0.5) if asample_rate.numel() > 0: - self.assertEqual(asample_rate.item(), config.audio_sample_rate) + assert asample_rate.item() == config.audio_sample_rate audio_duration = aduration.item() * Fraction( atimebase[0].item(), atimebase[1].item() ) - self.assertAlmostEqual(audio_duration, config.duration, delta=0.5) + assert audio_duration == approx(config.duration, abs=0.5) def check_meta_result(self, result, config): - self.assertAlmostEqual(result.video_duration, config.duration, delta=0.5) - self.assertAlmostEqual(result.video_fps, config.video_fps, delta=0.5) + assert result.video_duration == approx(config.duration, abs=0.5) + assert result.video_fps == approx(config.video_fps, abs=0.5) if result.has_audio > 0: - self.assertEqual(result.audio_sample_rate, config.audio_sample_rate) - self.assertAlmostEqual(result.audio_duration, config.duration, delta=0.5) + assert result.audio_sample_rate == config.audio_sample_rate + assert result.audio_duration == approx(config.duration, abs=0.5) def compare_decoding_result(self, tv_result, ref_result, config=all_check_config): """ @@ -350,12 +352,12 @@ def compare_decoding_result(self, tv_result, ref_result, config=all_check_config mean_delta = torch.mean( torch.abs(vframes.float() - ref_result.vframes.float()) ) - self.assertAlmostEqual(mean_delta, 0, delta=8.0) + assert mean_delta == approx(0.0, abs=8.0) mean_delta = torch.mean( torch.abs(vframe_pts.float() - ref_result.vframe_pts.float()) ) - self.assertAlmostEqual(mean_delta, 0, delta=1.0) + assert mean_delta == approx(0.0, abs=1.0) assert_equal(vtimebase, ref_result.vtimebase) @@ -378,12 +380,12 @@ def compare_decoding_result(self, tv_result, ref_result, config=all_check_config assert_equal(atimebase, ref_result.atimebase) - @unittest.skip( - "This stress test will iteratively decode the same set of videos." - "It helps to detect memory leak but it takes lots of time to run." - "By default, it is disabled" - ) def test_stress_test_read_video_from_file(self): + pytest.skip( + "This stress test will iteratively decode the same set of videos." + "It helps to detect memory leak but it takes lots of time to run." + "By default, it is disabled" + ) num_iter = 10000 # video related width, height, min_dimension, max_dimension = 0, 0, 0, 0 @@ -513,18 +515,18 @@ def test_read_video_from_file_read_single_stream_only(self): tv_result ) - self.assertEqual(vframes.numel() > 0, readVideoStream) - self.assertEqual(vframe_pts.numel() > 0, readVideoStream) - self.assertEqual(vtimebase.numel() > 0, readVideoStream) - self.assertEqual(vfps.numel() > 0, readVideoStream) + assert (vframes.numel() > 0) is bool(readVideoStream) + assert (vframe_pts.numel() > 0) is bool(readVideoStream) + assert (vtimebase.numel() > 0) is bool(readVideoStream) + assert (vfps.numel() > 0) is bool(readVideoStream) expect_audio_data = ( readAudioStream == 1 and config.audio_sample_rate is not None ) - self.assertEqual(aframes.numel() > 0, expect_audio_data) - self.assertEqual(aframe_pts.numel() > 0, expect_audio_data) - self.assertEqual(atimebase.numel() > 0, expect_audio_data) - self.assertEqual(asample_rate.numel() > 0, expect_audio_data) + assert (aframes.numel() > 0) is bool(expect_audio_data) + assert (aframe_pts.numel() > 0) is bool(expect_audio_data) + assert (atimebase.numel() > 0) is bool(expect_audio_data) + assert (asample_rate.numel() > 0) is bool(expect_audio_data) def test_read_video_from_file_rescale_min_dimension(self): """ @@ -564,9 +566,7 @@ def test_read_video_from_file_rescale_min_dimension(self): audio_timebase_num, audio_timebase_den, ) - self.assertEqual( - min_dimension, min(tv_result[0].size(1), tv_result[0].size(2)) - ) + assert min_dimension == min(tv_result[0].size(1), tv_result[0].size(2)) def test_read_video_from_file_rescale_max_dimension(self): """ @@ -606,9 +606,7 @@ def test_read_video_from_file_rescale_max_dimension(self): audio_timebase_num, audio_timebase_den, ) - self.assertEqual( - max_dimension, max(tv_result[0].size(1), tv_result[0].size(2)) - ) + assert max_dimension == max(tv_result[0].size(1), tv_result[0].size(2)) def test_read_video_from_file_rescale_both_min_max_dimension(self): """ @@ -648,12 +646,8 @@ def test_read_video_from_file_rescale_both_min_max_dimension(self): audio_timebase_num, audio_timebase_den, ) - self.assertEqual( - min_dimension, min(tv_result[0].size(1), tv_result[0].size(2)) - ) - self.assertEqual( - max_dimension, max(tv_result[0].size(1), tv_result[0].size(2)) - ) + assert min_dimension == min(tv_result[0].size(1), tv_result[0].size(2)) + assert max_dimension == max(tv_result[0].size(1), tv_result[0].size(2)) def test_read_video_from_file_rescale_width(self): """ @@ -693,7 +687,7 @@ def test_read_video_from_file_rescale_width(self): audio_timebase_num, audio_timebase_den, ) - self.assertEqual(tv_result[0].size(2), width) + assert tv_result[0].size(2) == width def test_read_video_from_file_rescale_height(self): """ @@ -733,7 +727,7 @@ def test_read_video_from_file_rescale_height(self): audio_timebase_num, audio_timebase_den, ) - self.assertEqual(tv_result[0].size(1), height) + assert tv_result[0].size(1) == height def test_read_video_from_file_rescale_width_and_height(self): """ @@ -773,8 +767,8 @@ def test_read_video_from_file_rescale_width_and_height(self): audio_timebase_num, audio_timebase_den, ) - self.assertEqual(tv_result[0].size(1), height) - self.assertEqual(tv_result[0].size(2), width) + assert tv_result[0].size(1) == height + assert tv_result[0].size(2) == width @PY39_SKIP def test_read_video_from_file_audio_resampling(self): @@ -822,19 +816,15 @@ def test_read_video_from_file_audio_resampling(self): tv_result ) if aframes.numel() > 0: - self.assertEqual(samples, asample_rate.item()) - self.assertEqual(1, aframes.size(1)) + assert samples == asample_rate.item() + assert 1 == aframes.size(1) # when audio stream is found duration = ( float(aframe_pts[-1]) * float(atimebase[0]) / float(atimebase[1]) ) - self.assertAlmostEqual( - aframes.size(0), - int(duration * asample_rate.item()), - delta=0.1 * asample_rate.item(), - ) + assert aframes.size(0) == approx(int(duration * asample_rate.item()), abs=0.1 * asample_rate.item()) @PY39_SKIP def test_compare_read_video_from_memory_and_file(self): @@ -989,7 +979,7 @@ def test_read_video_from_memory_get_pts_only(self): audio_timebase_num, audio_timebase_den, ) - self.assertAlmostEqual(config.video_fps, tv_result[3].item(), delta=0.01) + assert abs(config.video_fps - tv_result[3].item()) < 0.01 # pass 2: decode all frames to get PTS only using cpp decoder tv_result_pts_only = torch.ops.video_reader.read_video_from_memory( @@ -1014,8 +1004,8 @@ def test_read_video_from_memory_get_pts_only(self): audio_timebase_den, ) - self.assertEqual(tv_result_pts_only[0].numel(), 0) - self.assertEqual(tv_result_pts_only[5].numel(), 0) + assert not tv_result_pts_only[0].numel() + assert not tv_result_pts_only[5].numel() self.compare_decoding_result(tv_result, tv_result_pts_only) @PY39_SKIP @@ -1061,7 +1051,7 @@ def test_read_video_in_range_from_memory(self): aframes, aframe_pts, atimebase, asample_rate, aduration = ( tv_result ) - self.assertAlmostEqual(config.video_fps, vfps.item(), delta=0.01) + assert abs(config.video_fps - vfps.item()) < 0.01 for num_frames in [4, 8, 16, 32, 64, 128]: start_pts_ind_max = vframe_pts.size(0) - num_frames @@ -1160,7 +1150,7 @@ def test_read_video_in_range_from_memory(self): audio_end_pts, ) - self.assertEqual(tv_result[0].size(0), num_frames) + assert tv_result[0].size(0) == num_frames if pyav_result.vframes.size(0) == num_frames: # if PyAv decodes a different number of video frames, skip # comparing the decoding results between Torchvision video reader @@ -1187,7 +1177,7 @@ def test_probe_video_from_memory(self): def test_probe_video_from_memory_script(self): scripted_fun = torch.jit.script(io._probe_video_from_memory) - self.assertIsNotNone(scripted_fun) + assert scripted_fun is not None for test_video, config in test_videos.items(): full_path, video_tensor = _get_video_tensor(VIDEO_DIR, test_video) @@ -1209,7 +1199,7 @@ def test_read_video_from_memory_scripted(self): audio_timebase_num, audio_timebase_den = 0, 1 scripted_fun = torch.jit.script(io._read_video_from_memory) - self.assertIsNotNone(scripted_fun) + assert scripted_fun is not None for test_video, _config in test_videos.items(): full_path, video_tensor = _get_video_tensor(VIDEO_DIR, test_video) @@ -1237,11 +1227,11 @@ def test_read_video_from_memory_scripted(self): def test_invalid_file(self): set_video_backend('video_reader') - with self.assertRaises(RuntimeError): + with pytest.raises(RuntimeError): io.read_video('foo.mp4') set_video_backend('pyav') - with self.assertRaises(RuntimeError): + with pytest.raises(RuntimeError): io.read_video('foo.mp4') def test_audio_present_pts(self): @@ -1258,8 +1248,7 @@ def test_audio_present_pts(self): set_video_backend(backend) _, audio, _ = io.read_video( full_path, start_offset, end_offset, pts_unit='pts') - self.assertGreaterEqual(audio.shape[0], 1) - self.assertGreaterEqual(audio.shape[1], 1) + assert all([dimension > 0 for dimension in audio.shape[:2]]) def test_audio_present_sec(self): """Test if audio frames are returned with sec unit.""" @@ -1275,9 +1264,8 @@ def test_audio_present_sec(self): set_video_backend(backend) _, audio, _ = io.read_video( full_path, start_offset, end_offset, pts_unit='sec') - self.assertGreaterEqual(audio.shape[0], 1) - self.assertGreaterEqual(audio.shape[1], 1) + assert all([dimension > 0 for dimension in audio.shape[:2]]) -if __name__ == "__main__": - unittest.main() +if __name__ == '__main__': + pytest.main([__file__]) diff --git a/test/test_videoapi.py b/test/test_videoapi.py index da73c7cd17d..c6ae32232d3 100644 --- a/test/test_videoapi.py +++ b/test/test_videoapi.py @@ -1,6 +1,7 @@ import collections import os -import unittest +import pytest +from pytest import approx import torch import torchvision @@ -62,10 +63,10 @@ def fate(name, path="."): } -@unittest.skipIf(_HAS_VIDEO_OPT is False, "Didn't compile with ffmpeg") +@pytest.mark.skipif(_HAS_VIDEO_OPT is False, reason="Didn't compile with ffmpeg") @PY39_SKIP -class TestVideoApi(unittest.TestCase): - @unittest.skipIf(av is None, "PyAV unavailable") +class TestVideoApi: + @pytest.mark.skipif(av is None, reason="PyAV unavailable") def test_frame_reading(self): for test_video, config in test_videos.items(): full_path = os.path.join(VIDEO_DIR, test_video) @@ -77,11 +78,7 @@ def test_frame_reading(self): for av_frame in av_reader.decode(av_reader.streams.video[0]): vr_frame = next(video_reader) - self.assertAlmostEqual( - float(av_frame.pts * av_frame.time_base), - vr_frame["pts"], - delta=0.1, - ) + assert float(av_frame.pts * av_frame.time_base) == approx(vr_frame["pts"], abs=0.1) av_array = torch.tensor(av_frame.to_rgb().to_ndarray()).permute( 2, 0, 1 @@ -94,18 +91,14 @@ def test_frame_reading(self): # by decoding (around 1%) # TODO: asses empirically how to set this? atm it's 1% # averaged over all frames - self.assertTrue(mean_delta.item() < 2.5) + assert mean_delta.item() < 2.5 av_reader = av.open(full_path) if av_reader.streams.audio: video_reader = VideoReader(full_path, "audio") for av_frame in av_reader.decode(av_reader.streams.audio[0]): vr_frame = next(video_reader) - self.assertAlmostEqual( - float(av_frame.pts * av_frame.time_base), - vr_frame["pts"], - delta=0.1, - ) + assert float(av_frame.pts * av_frame.time_base) == approx(vr_frame["pts"], abs=0.1) av_array = torch.tensor(av_frame.to_ndarray()).permute(1, 0) vr_array = vr_frame["data"] @@ -114,7 +107,7 @@ def test_frame_reading(self): torch.abs(av_array.float() - vr_array.float()) ) # we assure that there is never more than 1% difference in signal - self.assertTrue(max_delta.item() < 0.001) + assert max_delta.item() < 0.001 def test_metadata(self): """ @@ -125,12 +118,8 @@ def test_metadata(self): full_path = os.path.join(VIDEO_DIR, test_video) reader = VideoReader(full_path, "video") reader_md = reader.get_metadata() - self.assertAlmostEqual( - config.video_fps, reader_md["video"]["fps"][0], delta=0.0001 - ) - self.assertAlmostEqual( - config.duration, reader_md["video"]["duration"][0], delta=0.5 - ) + assert config.video_fps == approx(reader_md["video"]["fps"][0], abs=0.0001) + assert config.duration == approx(reader_md["video"]["duration"][0], abs=0.5) def test_seek_start(self): for test_video, config in test_videos.items(): @@ -149,7 +138,7 @@ def test_seek_start(self): for frame in video_reader: start_num_frames += 1 - self.assertEqual(start_num_frames, num_frames) + assert start_num_frames == num_frames # now seek the container to < 0 to check for unexpected behaviour video_reader.seek(-1) @@ -157,7 +146,7 @@ def test_seek_start(self): for frame in video_reader: start_num_frames += 1 - self.assertEqual(start_num_frames, num_frames) + assert start_num_frames == num_frames def test_accurateseek_middle(self): for test_video, config in test_videos.items(): @@ -178,23 +167,23 @@ def test_accurateseek_middle(self): for frame in video_reader: middle_num_frames += 1 - self.assertTrue(middle_num_frames < num_frames) - self.assertAlmostEqual(middle_num_frames, num_frames // 2, delta=1) + assert middle_num_frames < num_frames + assert middle_num_frames == approx(num_frames // 2, abs=1) video_reader.seek(duration / 2) frame = next(video_reader) lb = duration / 2 - 1 / md[stream]["fps"][0] ub = duration / 2 + 1 / md[stream]["fps"][0] - self.assertTrue((lb <= frame["pts"]) & (ub >= frame["pts"])) + assert (lb <= frame["pts"]) and (ub >= frame["pts"]) def test_fate_suite(self): video_path = fate("sub/MovText_capability_tester.mp4", VIDEO_DIR) vr = VideoReader(video_path) metadata = vr.get_metadata() - self.assertTrue(metadata["subtitles"]["duration"] is not None) + assert metadata["subtitles"]["duration"] is not None os.remove(video_path) -if __name__ == "__main__": - unittest.main() +if __name__ == '__main__': + pytest.main([__file__]) From 3b8d51e7386ec36f4b81aa3aa275d3ee0b95fc32 Mon Sep 17 00:00:00 2001 From: Yiwen Song <34639474+sallysyw@users.noreply.github.com> Date: Tue, 3 Aug 2021 16:14:27 -0700 Subject: [PATCH 255/279] Port 'examples/python/video_api.ipynb' to gallery (#4241) * Port 'examples/python/video_api.ipynb' to gallery * Address rst formattion suggestions --- gallery/plot_video_api.py | 341 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 341 insertions(+) create mode 100644 gallery/plot_video_api.py diff --git a/gallery/plot_video_api.py b/gallery/plot_video_api.py new file mode 100644 index 00000000000..65e03c64bc9 --- /dev/null +++ b/gallery/plot_video_api.py @@ -0,0 +1,341 @@ +""" +======================= +Video API +======================= + +This example illustrates some of the APIs that torchvision offers for +videos, together with the examples on how to build datasets and more. +""" + +#################################### +# 1. Introduction: building a new video object and examining the properties +# ------------------------------------------------------------------------- +# First we select a video to test the object out. For the sake of argument +# we're using one from kinetics400 dataset. +# To create it, we need to define the path and the stream we want to use. + +###################################### +# Chosen video statistics: +# +# - WUzgd7C1pWA.mp4 +# - source: +# - kinetics-400 +# - video: +# - H-264 +# - MPEG-4 AVC (part 10) (avc1) +# - fps: 29.97 +# - audio: +# - MPEG AAC audio (mp4a) +# - sample rate: 48K Hz +# + +import torch +import torchvision +from torchvision.datasets.utils import download_url + +# Download the sample video +download_url( + "https://github.com/pytorch/vision/blob/master/test/assets/videos/WUzgd7C1pWA.mp4?raw=true", + ".", + "WUzgd7C1pWA.mp4" +) +video_path = "./WUzgd7C1pWA.mp4" + +###################################### +# Streams are defined in a similar fashion as torch devices. We encode them as strings in a form +# of ``stream_type:stream_id`` where ``stream_type`` is a string and ``stream_id`` a long int. +# The constructor accepts passing a ``stream_type`` only, in which case the stream is auto-discovered. +# Firstly, let's get the metadata for our particular video: + +stream = "video" +video = torchvision.io.VideoReader(video_path, stream) +video.get_metadata() + +###################################### +# Here we can see that video has two streams - a video and an audio stream. +# Currently available stream types include ['video', 'audio']. +# Each descriptor consists of two parts: stream type (e.g. 'video') and a unique stream id +# (which are determined by video encoding). +# In this way, if the video container contains multiple streams of the same type, +# users can access the one they want. +# If only stream type is passed, the decoder auto-detects first stream of that type and returns it. + +###################################### +# Let's read all the frames from the video stream. By default, the return value of +# ``next(video_reader)`` is a dict containing the following fields. +# +# The return fields are: +# +# - ``data``: containing a torch.tensor +# - ``pts``: containing a float timestamp of this particular frame + +metadata = video.get_metadata() +video.set_current_stream("audio") + +frames = [] # we are going to save the frames here. +ptss = [] # pts is a presentation timestamp in seconds (float) of each frame +for frame in video: + frames.append(frame['data']) + ptss.append(frame['pts']) + +print("PTS for first five frames ", ptss[:5]) +print("Total number of frames: ", len(frames)) +approx_nf = metadata['audio']['duration'][0] * metadata['audio']['framerate'][0] +print("Approx total number of datapoints we can expect: ", approx_nf) +print("Read data size: ", frames[0].size(0) * len(frames)) + +###################################### +# But what if we only want to read certain time segment of the video? +# That can be done easily using the combination of our ``seek`` function, and the fact that each call +# to next returns the presentation timestamp of the returned frame in seconds. +# +# Given that our implementation relies on python iterators, +# we can leverage itertools to simplify the process and make it more pythonic. +# +# For example, if we wanted to read ten frames from second second: + + +import itertools +video.set_current_stream("video") + +frames = [] # we are going to save the frames here. + +# We seek into a second second of the video and use islice to get 10 frames since +for frame, pts in itertools.islice(video.seek(2), 10): + frames.append(frame) + +print("Total number of frames: ", len(frames)) + +###################################### +# Or if we wanted to read from 2nd to 5th second, +# We seek into a second second of the video, +# then we utilize the itertools takewhile to get the +# correct number of frames: + +video.set_current_stream("video") +frames = [] # we are going to save the frames here. +video = video.seek(2) + +for frame in itertools.takewhile(lambda x: x['pts'] <= 5, video): + frames.append(frame['data']) + +print("Total number of frames: ", len(frames)) +approx_nf = (5 - 2) * video.get_metadata()['video']['fps'][0] +print("We can expect approx: ", approx_nf) +print("Tensor size: ", frames[0].size()) + +#################################### +# 2. Building a sample read_video function +# ---------------------------------------------------------------------------------------- +# We can utilize the methods above to build the read video function that follows +# the same API to the existing ``read_video`` function. + + +def example_read_video(video_object, start=0, end=None, read_video=True, read_audio=True): + if end is None: + end = float("inf") + if end < start: + raise ValueError( + "end time should be larger than start time, got " + "start time={} and end time={}".format(start, end) + ) + + video_frames = torch.empty(0) + video_pts = [] + if read_video: + video_object.set_current_stream("video") + frames = [] + for frame in itertools.takewhile(lambda x: x['pts'] <= end, video_object.seek(start)): + frames.append(frame['data']) + video_pts.append(frame['pts']) + if len(frames) > 0: + video_frames = torch.stack(frames, 0) + + audio_frames = torch.empty(0) + audio_pts = [] + if read_audio: + video_object.set_current_stream("audio") + frames = [] + for frame in itertools.takewhile(lambda x: x['pts'] <= end, video_object.seek(start)): + frames.append(frame['data']) + video_pts.append(frame['pts']) + if len(frames) > 0: + audio_frames = torch.cat(frames, 0) + + return video_frames, audio_frames, (video_pts, audio_pts), video_object.get_metadata() + + +# Total number of frames should be 327 for video and 523264 datapoints for audio +vf, af, info, meta = example_read_video(video) +print(vf.size(), af.size()) + +#################################### +# 3. Building an example randomly sampled dataset (can be applied to training dataest of kinetics400) +# ------------------------------------------------------------------------------------------------------- +# Cool, so now we can use the same principle to make the sample dataset. +# We suggest trying out iterable dataset for this purpose. +# Here, we are going to build an example dataset that reads randomly selected 10 frames of video. + +#################################### +# Make sample dataset +import os +os.makedirs("./dataset", exist_ok=True) +os.makedirs("./dataset/1", exist_ok=True) +os.makedirs("./dataset/2", exist_ok=True) + +#################################### +# Download the videos +from torchvision.datasets.utils import download_url +download_url( + "https://github.com/pytorch/vision/blob/master/test/assets/videos/WUzgd7C1pWA.mp4?raw=true", + "./dataset/1", "WUzgd7C1pWA.mp4" +) +download_url( + "https://github.com/pytorch/vision/blob/master/test/assets/videos/RATRACE_wave_f_nm_np1_fr_goo_37.avi?raw=true", + "./dataset/1", + "RATRACE_wave_f_nm_np1_fr_goo_37.avi" +) +download_url( + "https://github.com/pytorch/vision/blob/master/test/assets/videos/SOX5yA1l24A.mp4?raw=true", + "./dataset/2", + "SOX5yA1l24A.mp4" +) +download_url( + "https://github.com/pytorch/vision/blob/master/test/assets/videos/v_SoccerJuggling_g23_c01.avi?raw=true", + "./dataset/2", + "v_SoccerJuggling_g23_c01.avi" +) +download_url( + "https://github.com/pytorch/vision/blob/master/test/assets/videos/v_SoccerJuggling_g24_c01.avi?raw=true", + "./dataset/2", + "v_SoccerJuggling_g24_c01.avi" +) + +#################################### +# Housekeeping and utilities +import os +import random + +from torchvision.datasets.folder import make_dataset +from torchvision import transforms as t + + +def _find_classes(dir): + classes = [d.name for d in os.scandir(dir) if d.is_dir()] + classes.sort() + class_to_idx = {cls_name: i for i, cls_name in enumerate(classes)} + return classes, class_to_idx + + +def get_samples(root, extensions=(".mp4", ".avi")): + _, class_to_idx = _find_classes(root) + return make_dataset(root, class_to_idx, extensions=extensions) + +#################################### +# We are going to define the dataset and some basic arguments. +# We assume the structure of the FolderDataset, and add the following parameters: +# +# - ``clip_len``: length of a clip in frames +# - ``frame_transform``: transform for every frame individually +# - ``video_transform``: transform on a video sequence +# +# .. note:: +# We actually add epoch size as using :func:`~torch.utils.data.IterableDataset` +# class allows us to naturally oversample clips or images from each video if needed. + + +class RandomDataset(torch.utils.data.IterableDataset): + def __init__(self, root, epoch_size=None, frame_transform=None, video_transform=None, clip_len=16): + super(RandomDataset).__init__() + + self.samples = get_samples(root) + + # Allow for temporal jittering + if epoch_size is None: + epoch_size = len(self.samples) + self.epoch_size = epoch_size + + self.clip_len = clip_len + self.frame_transform = frame_transform + self.video_transform = video_transform + + def __iter__(self): + for i in range(self.epoch_size): + # Get random sample + path, target = random.choice(self.samples) + # Get video object + vid = torchvision.io.VideoReader(path, "video") + metadata = vid.get_metadata() + video_frames = [] # video frame buffer + + # Seek and return frames + max_seek = metadata["video"]['duration'][0] - (self.clip_len / metadata["video"]['fps'][0]) + start = random.uniform(0., max_seek) + for frame in itertools.islice(vid.seek(start), self.clip_len): + video_frames.append(self.frame_transform(frame['data'])) + current_pts = frame['pts'] + # Stack it into a tensor + video = torch.stack(video_frames, 0) + if self.video_transform: + video = self.video_transform(video) + output = { + 'path': path, + 'video': video, + 'target': target, + 'start': start, + 'end': current_pts} + yield output + +#################################### +# Given a path of videos in a folder structure, i.e: +# +# - dataset +# - class 1 +# - file 0 +# - file 1 +# - ... +# - class 2 +# - file 0 +# - file 1 +# - ... +# - ... +# +# We can generate a dataloader and test the dataset. + + +transforms = [t.Resize((112, 112))] +frame_transform = t.Compose(transforms) + +dataset = RandomDataset("./dataset", epoch_size=None, frame_transform=frame_transform) + +#################################### +from torch.utils.data import DataLoader +loader = DataLoader(dataset, batch_size=12) +data = {"video": [], 'start': [], 'end': [], 'tensorsize': []} +for batch in loader: + for i in range(len(batch['path'])): + data['video'].append(batch['path'][i]) + data['start'].append(batch['start'][i].item()) + data['end'].append(batch['end'][i].item()) + data['tensorsize'].append(batch['video'][i].size()) +print(data) + +#################################### +# 4. Data Visualization +# ---------------------------------- +# Example of visualized video + +import matplotlib.pylab as plt + +plt.figure(figsize=(12, 12)) +for i in range(16): + plt.subplot(4, 4, i + 1) + plt.imshow(batch["video"][0, i, ...].permute(1, 2, 0)) + plt.axis("off") + +#################################### +# Cleanup the video and dataset: +import os +import shutil +os.remove("./WUzgd7C1pWA.mp4") +shutil.rmtree("./dataset") From c8b12fdbf12fe6ac98e3a5a933ec91f7862b045a Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 4 Aug 2021 09:07:40 +0100 Subject: [PATCH 256/279] Avoid cmyk in nvjpeg tests (#4246) --- test/test_image.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/test_image.py b/test/test_image.py index e7e5b8b197d..2e427af26af 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -326,7 +326,8 @@ def test_decode_jpeg_cuda(mode, img_path, scripted): @pytest.mark.parametrize('cuda_device', ('cuda', 'cuda:0', torch.device('cuda'))) def test_decode_jpeg_cuda_device_param(cuda_device): """Make sure we can pass a string or a torch.device as device param""" - data = read_file(next(get_images(IMAGE_ROOT, ".jpg"))) + path = next(path for path in get_images(IMAGE_ROOT, ".jpg") if 'cmyk' not in path) + data = read_file(path) decode_jpeg(data, device=cuda_device) From a9b38db2d9714b4a707de65f5b13632db821c6eb Mon Sep 17 00:00:00 2001 From: vfdev Date: Wed, 4 Aug 2021 13:45:13 +0200 Subject: [PATCH 257/279] [2/2] Added backward pass on CUDA for interpolation with anti-alias option (#4211) * WIP on backward op interpolation with AA * Removed cuda tests and reformat cpp code * Fixed clang wrong formatting * Added channels last test case * Added CUDA support for backward pass, interpolation with AA * Removed unused buffers Co-authored-by: vfdev-5 --- test/test_functional_tensor.py | 6 +- .../csrc/ops/cuda/interpolate_aa_kernels.cu | 309 +++++++++++++++--- 2 files changed, 270 insertions(+), 45 deletions(-) diff --git a/test/test_functional_tensor.py b/test/test_functional_tensor.py index 9b4c1b5f9af..30ee144888c 100644 --- a/test/test_functional_tensor.py +++ b/test/test_functional_tensor.py @@ -579,13 +579,11 @@ def test_assert_resize_antialias(interpolation): F.resize(tensor, size=(5, 5), interpolation=interpolation, antialias=True) +@pytest.mark.parametrize('device', cpu_and_gpu()) @pytest.mark.parametrize('dt', [torch.float32, torch.float64, torch.float16]) @pytest.mark.parametrize('size', [[10, 7], [10, 42], [42, 7]]) @pytest.mark.parametrize('interpolation', [BILINEAR, BICUBIC]) -def test_interpolate_antialias_backward(dt, size, interpolation): - - # temporarily hard-code device as CPU, CUDA support will be done later - device = "cpu" +def test_interpolate_antialias_backward(device, dt, size, interpolation): if dt == torch.float16 and device == "cpu": # skip float16 on CPU case diff --git a/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu b/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu index 46525f4dd01..f52793408f4 100644 --- a/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu +++ b/torchvision/csrc/ops/cuda/interpolate_aa_kernels.cu @@ -165,49 +165,32 @@ __global__ void upsample_gen2d_out_frame( // Compute weights int xmin, xsize, ymin, ysize; typedef scalar_t (*filter_fn_t)(scalar_t); + filter_fn_t filter_fn; if (interp_size == 2) { - _compute_weights( - w2, - width1, - rwidth, - support_w, - wx, - interp_width, - bilinear_filter, - xmin, - xsize); - _compute_weights( - h2, - height1, - rheight, - support_h, - wy, - interp_height, - bilinear_filter, - ymin, - ysize); + filter_fn = bilinear_filter; } else if (interp_size == 4) { - _compute_weights( - w2, - width1, - rwidth, - support_w, - wx, - interp_width, - bicubic_filter, - xmin, - xsize); - _compute_weights( - h2, - height1, - rheight, - support_h, - wy, - interp_height, - bicubic_filter, - ymin, - ysize); + filter_fn = bicubic_filter; } + _compute_weights( + w2, + width1, + rwidth, + support_w, + wx, + interp_width, + filter_fn, + xmin, + xsize); + _compute_weights( + h2, + height1, + rheight, + support_h, + wy, + interp_height, + filter_fn, + ymin, + ysize); for (int n = 0; n < batchsize; n++) { for (int c = 0; c < channels; ++c) { @@ -239,6 +222,8 @@ static void upsample_gen2d_out_cuda_template( bool align_corners, c10::optional scales_h, c10::optional scales_w) { + // Copied and adapted from + // UpSampleBicubic2d.cu::upsample_bicubic2d_out_cuda_template TensorArg input_arg{input, "input", 1}, output_arg{output, "output", 2}; checkAllSameGPU("upsample_gen2d_out_cuda", {input_arg, output_arg}); @@ -256,7 +241,7 @@ static void upsample_gen2d_out_cuda_template( cudaStream_t stream = at::cuda::getCurrentCUDAStream(); AT_DISPATCH_FLOATING_TYPES_AND_HALF( - input.scalar_type(), "upsample_bilinear2d_out_frame", [&] { + input.scalar_type(), "upsample_gen2d_out_frame", [&] { using accscalar_t = at::acc_type; auto idata = input.packed_accessor64(); @@ -287,6 +272,174 @@ static void upsample_gen2d_out_cuda_template( }); } +// Backward (adjoint) operation 1 <- 2 (accumulates) +template +C10_LAUNCH_BOUNDS_1(1024) +__global__ void upsample_gen2d_backward_out_frame( + const int num_elements, + const accscalar_t height_scale, + const accscalar_t width_scale, + const bool align_corners, + PackedTensorAccessor64 idata, + const PackedTensorAccessor64 odata) { + int index = threadIdx.x + blockIdx.x * blockDim.x; + + const int batchsize = idata.size(0); + const int channels = idata.size(1); + const int input_height = idata.size(2); + const int input_width = idata.size(3); + const int output_height = odata.size(2); + const int output_width = odata.size(3); + + if (index >= num_elements) { + return; + } + + const int output_x = index % output_width; + const int output_y = index / output_width; + // special case: output just copy + if (input_height == output_height && input_width == output_width) { + for (int n = 0; n < batchsize; n++) { + for (int c = 0; c < channels; ++c) { + const scalar_t val = odata[n][c][output_y][output_x]; + idata[n][c][output_y][output_x] = val; + } + } + return; + } + + const accscalar_t support_h = static_cast( + (height_scale >= 1.0) ? (interp_size * 0.5) * height_scale + : interp_size * 0.5); + const accscalar_t support_w = static_cast( + (width_scale >= 1.0) ? (interp_size * 0.5) * width_scale + : interp_size * 0.5); + + const int interp_height = (int)ceilf(support_h) * 2 + 1; + const int interp_width = (int)ceilf(support_w) * 2 + 1; + + // Setup local buffers + // TODO: maybe we can specify dynamic shared memory size before calling the + // cuda code, however we should then ensure that device has enough shared + // memory + scalar_t wx[256]; + scalar_t wy[256]; + + // Compute weights + int xmin, xsize, ymin, ysize; + typedef scalar_t (*filter_fn_t)(scalar_t); + filter_fn_t filter_fn; + if (interp_size == 2) { + filter_fn = bilinear_filter; + } else if (interp_size == 4) { + filter_fn = bicubic_filter; + } + _compute_weights( + output_x, + input_width, + width_scale, + support_w, + wx, + interp_width, + filter_fn, + xmin, + xsize); + _compute_weights( + output_y, + input_height, + height_scale, + support_h, + wy, + interp_height, + filter_fn, + ymin, + ysize); + + for (int n = 0; n < batchsize; n++) { + for (int c = 0; c < channels; ++c) { + scalar_t out_value = odata[n][c][output_y][output_x]; + for (int y = 0; y < ysize; y++) { + for (int x = 0; x < xsize; x++) { + upsample_increment_value_bounded( + idata, + n, + c, + input_height, + input_width, + ymin + y, + xmin + x, + wx[x] * wy[y] * out_value); + } + } + } + } +} + +template +static void upsample_gen2d_backward_out_cuda_template( + const Tensor& grad_input, + const Tensor& grad_output_, + IntArrayRef output_size, + IntArrayRef input_size, + bool align_corners, + c10::optional scales_h, + c10::optional scales_w) { + // Copied and adapted from + // UpSampleBicubic2d.cu::upsample_bicubic2d_backward_out_cuda_template + TensorArg grad_input_arg{grad_input, "grad_input", 1}, + grad_output_arg{grad_output_, "grad_output_", 2}; + checkAllSameGPU( + "upsample_gen2d_backward_out_cuda", {grad_output_arg, grad_input_arg}); + + int output_height = output_size[0]; + int output_width = output_size[1]; + + int nbatch = input_size[0]; + int channels = input_size[1]; + int input_height = input_size[2]; + int input_width = input_size[3]; + + Tensor grad_output = grad_output_.contiguous(); + + grad_input.zero_(); + + const int num_kernels = output_height * output_width; + const int num_threads = std::min( + at::cuda::getCurrentDeviceProperties()->maxThreadsPerBlock, 1024); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + grad_output.scalar_type(), "upsample_gen2d_backward_out_frame", [&] { + using accscalar_t = at::acc_type; + + auto idata = grad_input.packed_accessor64(); + auto odata = grad_output.packed_accessor64(); + + const accscalar_t rheight = area_pixel_compute_scale( + input_height, output_height, align_corners, scales_h); + const accscalar_t rwidth = area_pixel_compute_scale( + input_width, output_width, align_corners, scales_w); + + // We are using static buffer memory of 256 * sizeof(float) per thread + // to store weights. Size of weights array is + // interp_size = scale * 2 + 1 for bilinear mode + TORCH_CHECK( + rheight < (255 / interp_size), + "Max supported scale factor is 127 (bilinear), 63 (bicubic)"); + TORCH_CHECK( + rwidth < (255 / interp_size), + "Max supported scale factor is 127 (bilinear), 63 (bicubic)"); + + upsample_gen2d_backward_out_frame + <<>>( + num_kernels, rheight, rwidth, align_corners, idata, odata); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + }); +} + } // namespace internal_upsample } // namespace native } // namespace at @@ -371,6 +524,56 @@ at::Tensor interpolate_gen2d_aa_forward_kernel( return output; } +template +at::Tensor interpolate_gen2d_aa_backward_kernel( + const at::Tensor& grad_output, + at::IntArrayRef output_size, + at::IntArrayRef input_size, + bool align_corners) { + c10::optional> scale_factors = {}; + + // Copied from UpSampleBicubic2d.cpp::upsample_bicubic2d_backward + auto grad_input = at::empty({0}, grad_output.options()); + auto osize = at::native::upsample::compute_output_size( + input_size, output_size, scale_factors); + auto scale_h = at::native::upsample_cuda::get_scale_value(scale_factors, 0); + auto scale_w = at::native::upsample_cuda::get_scale_value(scale_factors, 1); + + auto full_output_size = upsample_2d_common_check(input_size, osize); + + TORCH_CHECK( + grad_output.dim() == 4, + "Expected grad_output to be a tensor of dimension 4 but got: dimension ", + grad_output.dim()); + + for (int i = 0; i < 4; ++i) { + TORCH_CHECK( + grad_output.size(i) == full_output_size[i], + "Expected grad_output to have the same shape as output;", + " output.size(", + i, + ") = ", + full_output_size[i], + " but got grad_output.size(", + i, + ") = ", + grad_output.size(i)); + } + + grad_input.resize_(input_size, grad_output.suggest_memory_format()); + + at::native::internal_upsample::upsample_gen2d_backward_out_cuda_template< + interp_size>( + grad_input, + grad_output, + {full_output_size[2], full_output_size[3]}, + input_size, + align_corners, + scale_h, + scale_w); + return grad_input; +} + at::Tensor interpolate_bilinear2d_aa_forward_kernel( const at::Tensor& input, at::IntArrayRef output_size, @@ -387,6 +590,24 @@ at::Tensor interpolate_bicubic2d_aa_forward_kernel( input, output_size, align_corners); } +at::Tensor interpolate_bilinear2d_aa_backward_kernel( + const at::Tensor& grad_output, + at::IntArrayRef output_size, + at::IntArrayRef input_size, + bool align_corners) { + return interpolate_gen2d_aa_backward_kernel<2>( + grad_output, output_size, input_size, align_corners); +} + +at::Tensor interpolate_bicubic2d_aa_backward_kernel( + const at::Tensor& grad_output, + at::IntArrayRef output_size, + at::IntArrayRef input_size, + bool align_corners) { + return interpolate_gen2d_aa_backward_kernel<4>( + grad_output, output_size, input_size, align_corners); +} + } // namespace TORCH_LIBRARY_IMPL(torchvision, CUDA, m) { @@ -396,6 +617,12 @@ TORCH_LIBRARY_IMPL(torchvision, CUDA, m) { m.impl( TORCH_SELECTIVE_NAME("torchvision::_interpolate_bicubic2d_aa"), TORCH_FN(interpolate_bicubic2d_aa_forward_kernel)); + m.impl( + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bilinear2d_aa_backward"), + TORCH_FN(interpolate_bilinear2d_aa_backward_kernel)); + m.impl( + TORCH_SELECTIVE_NAME("torchvision::_interpolate_bicubic2d_aa_backward"), + TORCH_FN(interpolate_bicubic2d_aa_backward_kernel)); } } // namespace ops From 876117b5d3c72aa7b2472ab3051bab6380f379d2 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Wed, 4 Aug 2021 13:46:05 +0100 Subject: [PATCH 258/279] Remove old notebook examples and point to the online gallery (#4244) --- examples/python/README.md | 22 +- examples/python/tensor_transforms.ipynb | 388 ----------- examples/python/video_api.ipynb | 772 ---------------------- examples/python/visualization_utils.ipynb | 683 ------------------- 4 files changed, 2 insertions(+), 1863 deletions(-) delete mode 100644 examples/python/tensor_transforms.ipynb delete mode 100644 examples/python/video_api.ipynb delete mode 100644 examples/python/visualization_utils.ipynb diff --git a/examples/python/README.md b/examples/python/README.md index 1e6c66b5219..8047b0c7cac 100644 --- a/examples/python/README.md +++ b/examples/python/README.md @@ -1,22 +1,4 @@ # Python examples -- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/vision/blob/master/examples/python/tensor_transforms.ipynb) -[Examples of Tensor Images transformations](https://github.com/pytorch/vision/blob/master/examples/python/tensor_transforms.ipynb) -- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/vision/blob/master/examples/python/video_api.ipynb) -[Example of VideoAPI](https://github.com/pytorch/vision/blob/master/examples/python/video_api.ipynb) -- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/vision/blob/master/examples/python/visualization_utils.ipynb) -[Example of Visualization Utils](https://github.com/pytorch/vision/blob/master/examples/python/visualization_utils.ipynb) - - -Prior to v0.8.0, transforms in torchvision have traditionally been PIL-centric and presented multiple limitations due to -that. Now, since v0.8.0, transforms implementations are Tensor and PIL compatible and we can achieve the following new -features: -- transform multi-band torch tensor images (with more than 3-4 channels) -- torchscript transforms together with your model for deployment -- support for GPU acceleration -- batched transformation such as for videos -- read and decode data directly as torch tensor with torchscript support (for PNG and JPEG image formats) - -Furthermore, previously we used to provide a very high-level API for video decoding which left little control to the user. We're now expanding that API (and replacing it in the future) with a lower-level API that allows the user a frame-based access to a video. - -Torchvision also provides utilities to visualize results. You can make grid of images, plot bounding boxes as well as segmentation masks. Thse utilities work standalone as well as with torchvision models for detection and segmentation. +The examples in this directory have been moved online in our [gallery +page](https://pytorch.org/vision/stable/auto_examples/index.html). \ No newline at end of file diff --git a/examples/python/tensor_transforms.ipynb b/examples/python/tensor_transforms.ipynb deleted file mode 100644 index 7bb5741947c..00000000000 --- a/examples/python/tensor_transforms.ipynb +++ /dev/null @@ -1,388 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "vjAC2mZnb4nz" - }, - "source": [ - "# Image transformations\n", - "\n", - "This notebook shows new features of torchvision image transformations. \n", - "\n", - "Prior to v0.8.0, transforms in torchvision have traditionally been PIL-centric and presented multiple limitations due to that. Now, since v0.8.0, transforms implementations are Tensor and PIL compatible and we can achieve the following new \n", - "features:\n", - "- transform multi-band torch tensor images (with more than 3-4 channels) \n", - "- torchscript transforms together with your model for deployment\n", - "- support for GPU acceleration\n", - "- batched transformation such as for videos\n", - "- read and decode data directly as torch tensor with torchscript support (for PNG and JPEG image formats)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 35 - }, - "id": "btaDWPDbgIyW", - "outputId": "8a83d408-f643-42da-d247-faf3a1bd3ae0" - }, - "outputs": [], - "source": [ - "import torch, torchvision\n", - "torch.__version__, torchvision.__version__" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "9Vj9draNb4oA" - }, - "source": [ - "## Transforms on CPU/CUDA tensor images\n", - "\n", - "Let's show how to apply transformations on images opened directly as a torch tensors.\n", - "Now, torchvision provides image reading functions for PNG and JPG images with torchscript support. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "Epp3hCy0b4oD" - }, - "outputs": [], - "source": [ - "from torchvision.datasets.utils import download_url\n", - "\n", - "download_url(\"https://farm1.static.flickr.com/152/434505223_8d1890e1e2.jpg\", \".\", \"test-image.jpg\")\n", - "download_url(\"https://farm3.static.flickr.com/2142/1896267403_24939864ba.jpg\", \".\", \"test-image2.jpg\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "Y-m7lYDPb4oK" - }, - "outputs": [], - "source": [ - "import matplotlib.pylab as plt\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 303 - }, - "id": "5bi8Q7L3b4oc", - "outputId": "e5de5c73-e16d-4992-ebee-94c7ddf0bf54" - }, - "outputs": [], - "source": [ - "from torchvision.io.image import read_image\n", - "\n", - "tensor_image = read_image(\"test-image.jpg\")\n", - "\n", - "print(\"tensor image info: \", tensor_image.shape, tensor_image.dtype)\n", - "\n", - "plt.imshow(tensor_image.numpy().transpose((1, 2, 0)))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def to_rgb_image(tensor):\n", - " \"\"\"Helper method to get RGB numpy array for plotting\"\"\"\n", - " np_img = tensor.cpu().numpy().transpose((1, 2, 0))\n", - " m1, m2 = np_img.min(axis=(0, 1)), np_img.max(axis=(0, 1))\n", - " return (255.0 * (np_img - m1) / (m2 - m1)).astype(\"uint8\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 322 - }, - "id": "PgWpjxQ3b4pF", - "outputId": "e9a138e8-b45c-4f75-d849-3b41de0e5472" - }, - "outputs": [], - "source": [ - "import torchvision.transforms as T\n", - "\n", - "# to fix random seed is now:\n", - "torch.manual_seed(12)\n", - "\n", - "transforms = T.Compose([\n", - " T.RandomCrop(224),\n", - " T.RandomHorizontalFlip(p=0.3),\n", - " T.ConvertImageDtype(torch.float),\n", - " T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", - "])\n", - "\n", - "out_image = transforms(tensor_image)\n", - "print(\"output tensor image info: \", out_image.shape, out_image.dtype)\n", - "\n", - "plt.imshow(to_rgb_image(out_image))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "LmYQB4cxb4pI" - }, - "source": [ - "Tensor images can be on GPU" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 322 - }, - "id": "S6syYJGEb4pN", - "outputId": "86bddb64-e648-45f2-c216-790d43cfc26d" - }, - "outputs": [], - "source": [ - "out_image = transforms(tensor_image.to(\"cuda\"))\n", - "print(\"output tensor image info: \", out_image.shape, out_image.dtype, out_image.device)\n", - "\n", - "plt.imshow(to_rgb_image(out_image))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jg9TQd7ajfyn" - }, - "source": [ - "## Scriptable transforms for easier deployment via torchscript\n", - "\n", - "Next, we show how to combine input transformations and model's forward pass and use `torch.jit.script` to obtain a single scripted module.\n", - "\n", - "**Note:** we have to use only scriptable transformations that should be derived from `torch.nn.Module`. \n", - "Since v0.8.0, all transformations are scriptable except `Compose`, `RandomChoice`, `RandomOrder`, `Lambda` and those applied on PIL images.\n", - "The transformations like `Compose` are kept for backward compatibility and can be easily replaced by existing torch modules, like `nn.Sequential`.\n", - "\n", - "Let's define a module `Predictor` that transforms input tensor and applies ImageNet pretrained resnet18 model on it." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "NSDOJ3RajfvO" - }, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torchvision.transforms as T\n", - "from torchvision.io.image import read_image\n", - "from torchvision.models import resnet18\n", - "\n", - "\n", - "class Predictor(nn.Module):\n", - "\n", - " def __init__(self):\n", - " super().__init__()\n", - " self.resnet18 = resnet18(pretrained=True).eval()\n", - " self.transforms = nn.Sequential(\n", - " T.Resize([256, ]), # We use single int value inside a list due to torchscript type restrictions\n", - " T.CenterCrop(224),\n", - " T.ConvertImageDtype(torch.float),\n", - " T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", - " )\n", - "\n", - " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", - " with torch.no_grad():\n", - " x = self.transforms(x)\n", - " y_pred = self.resnet18(x)\n", - " return y_pred.argmax(dim=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ZZKDovqej5vA" - }, - "source": [ - "Now, let's define scripted and non-scripted instances of `Predictor` and apply on multiple tensor images of the same size" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "GBBMSo7vjfr0" - }, - "outputs": [], - "source": [ - "from torchvision.io.image import read_image\n", - "\n", - "predictor = Predictor().to(\"cuda\")\n", - "scripted_predictor = torch.jit.script(predictor).to(\"cuda\")\n", - "\n", - "\n", - "tensor_image1 = read_image(\"test-image.jpg\")\n", - "tensor_image2 = read_image(\"test-image2.jpg\")\n", - "batch = torch.stack([tensor_image1[:, -320:, :], tensor_image2[:, -320:, :]]).to(\"cuda\")\n", - "\n", - "res1 = scripted_predictor(batch)\n", - "res2 = predictor(batch)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 501 - }, - "id": "Dmi9r_p-oKsk", - "outputId": "b9c55e7d-5db1-4975-c485-fecc4075bf47" - }, - "outputs": [], - "source": [ - "import json\n", - "from torchvision.datasets.utils import download_url\n", - "\n", - "\n", - "download_url(\"https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\", \".\", \"imagenet_class_index.json\")\n", - "\n", - "\n", - "with open(\"imagenet_class_index.json\", \"r\") as h:\n", - " labels = json.load(h)\n", - "\n", - "\n", - "plt.figure(figsize=(12, 7))\n", - "for i, p in enumerate(res1):\n", - " plt.subplot(1, 2, i + 1)\n", - " plt.title(\"Scripted predictor:\\n{label})\".format(label=labels[str(p.item())]))\n", - " plt.imshow(batch[i, ...].cpu().numpy().transpose((1, 2, 0)))\n", - "\n", - "\n", - "plt.figure(figsize=(12, 7))\n", - "for i, p in enumerate(res2):\n", - " plt.subplot(1, 2, i + 1)\n", - " plt.title(\"Original predictor:\\n{label})\".format(label=labels[str(p.item())]))\n", - " plt.imshow(batch[i, ...].cpu().numpy().transpose((1, 2, 0)))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7IYsjzpFqcK8" - }, - "source": [ - "We save and reload scripted predictor in Python or C++ and use it for inference:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 52 - }, - "id": "0kk9LLw5jfol", - "outputId": "05ea6db7-7fcf-4b74-a763-5f117c14cc00" - }, - "outputs": [], - "source": [ - "scripted_predictor.save(\"scripted_predictor.pt\")\n", - "\n", - "scripted_predictor = torch.jit.load(\"scripted_predictor.pt\")\n", - "res1 = scripted_predictor(batch)\n", - "\n", - "for i, p in enumerate(res1):\n", - " print(\"Scripted predictor: {label})\".format(label=labels[str(p.item())]))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Data reading and decoding functions also support torch script and therefore can be part of the model as well:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "class AnotherPredictor(Predictor):\n", - "\n", - " def forward(self, path: str) -> int:\n", - " with torch.no_grad():\n", - " x = read_image(path).unsqueeze(0)\n", - " x = self.transforms(x)\n", - " y_pred = self.resnet18(x)\n", - " return int(y_pred.argmax(dim=1).item())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "-cMwTs3Yjffy" - }, - "outputs": [], - "source": [ - "scripted_predictor2 = torch.jit.script(AnotherPredictor())\n", - "\n", - "res = scripted_predictor2(\"test-image.jpg\")\n", - "\n", - "print(\"Scripted another predictor: {label})\".format(label=labels[str(res)]))" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "collapsed_sections": [], - "name": "torchvision_scriptable_transforms.ipynb", - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/python/video_api.ipynb b/examples/python/video_api.ipynb deleted file mode 100644 index 724de2f0a12..00000000000 --- a/examples/python/video_api.ipynb +++ /dev/null @@ -1,772 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Welcome to torchvision's new video API\n", - "\n", - "Here, we're going to examine the capabilities of the new video API, together with the examples on how to build datasets and more. \n", - "\n", - "### Table of contents\n", - "1. Introduction: building a new video object and examining the properties\n", - "2. Building a sample `read_video` function\n", - "3. Building an example dataset (can be applied to e.g. kinetics400)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "('1.8.0a0+7580962', '0.8.0a0+4db3dc6')" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import torch, torchvision\n", - "torch.__version__, torchvision.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading https://github.com/pytorch/vision/blob/master/test/assets/videos/WUzgd7C1pWA.mp4?raw=true to ./WUzgd7C1pWA.mp4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100.4%" - ] - } - ], - "source": [ - "# download the sample video\n", - "from torchvision.datasets.utils import download_url\n", - "download_url(\"https://github.com/pytorch/vision/blob/master/test/assets/videos/WUzgd7C1pWA.mp4?raw=true\", \".\", \"WUzgd7C1pWA.mp4\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Introduction: building a new video object and examining the properties\n", - "\n", - "First we select a video to test the object out. For the sake of argument we're using one from Kinetics400 dataset. To create it, we need to define the path and the stream we want to use. See inline comments for description. " - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [], - "source": [ - "import torch, torchvision\n", - "\"\"\"\n", - "chosen video statistics:\n", - "WUzgd7C1pWA.mp4\n", - " - source: kinetics-400\n", - " - video: H-264 - MPEG-4 AVC (part 10) (avc1)\n", - " - fps: 29.97\n", - " - audio: MPEG AAC audio (mp4a)\n", - " - sample rate: 48K Hz\n", - "\"\"\"\n", - "video_path = \"./WUzgd7C1pWA.mp4\"\n", - "\n", - "\"\"\"\n", - "streams are defined in a similar fashion as torch devices. We encode them as strings in a form\n", - "of `stream_type:stream_id` where stream_type is a string and stream_id a long int. \n", - "\n", - "The constructor accepts passing a stream_type only, in which case the stream is auto-discovered.\n", - "\"\"\"\n", - "stream = \"video\"\n", - "\n", - "\n", - "\n", - "video = torchvision.io.VideoReader(video_path, stream)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, let's get the metadata for our particular video:" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'video': {'duration': [10.9109], 'fps': [29.97002997002997]},\n", - " 'audio': {'duration': [10.9], 'framerate': [48000.0]}}" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "video.get_metadata()" - ] - }, - { - "source": [ - "Here we can see that video has two streams - a video and an audio stream. \n", - "Currently available stream types include ``['video', 'audio']``.\n", - "Each descriptor consists of two parts: stream type (e.g. 'video') and\n", - "a unique stream id (which are determined by video encoding).\n", - "In this way, if the video contaner contains multiple\n", - "streams of the same type, users can acces the one they want.\n", - "If only stream type is passed, the decoder auto-detects first stream\n", - "of that type and returns it.\n", - "\n", - "Let's read all the frames from the video stream.\n", - "By default, the return value of `next(video_reader)` is a dict containing the following fields.\n", - "\n", - "The return fields are \n", - "- `data` containing a torch.tensor\n", - "- `pts` containing a float timestamp of this particular frame. " - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PTS for first five frames [0.0, 0.033367, 0.066733, 0.1001, 0.133467]\n", - "Total number of frames: 327\n", - "We can expect approx: 327.0\n", - "Tensor size: torch.Size([3, 256, 340])\n" - ] - } - ], - "source": [ - "# first we select the video stream \n", - "metadata = video.get_metadata()\n", - "video.set_current_stream(\"video:0\")\n", - "\n", - "frames = [] # we are going to save the frames here.\n", - "ptss = [] # pts is a presentation timestamp in seconds (float) of each frame\n", - "for frame in video:\n", - " frames.append(frame['data'])\n", - " ptss.append(frame['pts'])\n", - "\n", - "print(\"PTS for first five frames \", ptss[:5])\n", - "print(\"Total number of frames: \", len(frames))\n", - "approx_nf = metadata['video']['duration'][0] * metadata['video']['fps'][0]\n", - "print(\"We can expect approx: \", approx_nf)\n", - "print(\"Tensor size: \", frames[0].size())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that selecting zero video stream is equivalent to selecting video stream automatically. I.e. `video:0` and `video` will end up with same results in this case. \n", - "\n", - "Let's try this for audio. Note that presentation timestamps are different so aligment has to be done carefully. " - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PTS for first five frames [0.0, 0.021332999999999998, 0.042667, 0.064, 0.08533299999999999]\n", - "Total number of frames: 511\n", - "Approx total number of datapoints we can expect: 523200.0\n", - "Read data size: 523264\n" - ] - } - ], - "source": [ - "metadata = video.get_metadata()\n", - "video.set_current_stream(\"audio\")\n", - "\n", - "frames = [] # we are going to save the frames here.\n", - "ptss = [] # pts is a presentation timestamp in seconds (float) of each frame\n", - "for frame in video:\n", - " frames.append(frame['data'])\n", - " ptss.append(frame['pts'])\n", - "\n", - "print(\"PTS for first five frames \", ptss[:5])\n", - "print(\"Total number of frames: \", len(frames))\n", - "approx_nf = metadata['audio']['duration'][0] * metadata['audio']['framerate'][0]\n", - "print(\"Approx total number of datapoints we can expect: \", approx_nf)\n", - "print(\"Read data size: \", frames[0].size(0) * len(frames))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "But what if we only want to read certain time segment of the video?\n", - "\n", - "That can be done easily using the combination of our seek function, and the fact that each call to next returns the presentation timestamp of the returned frame in seconds. Given that our implementation relies on python iterators, we can leverage `itertools` to simplify the process and make it more pythonic. \n", - "\n", - "For example, if we wanted to read ten frames from second second:" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total number of frames: 10\n" - ] - } - ], - "source": [ - "import itertools\n", - "video.set_current_stream(\"video\")\n", - "\n", - "frames = [] # we are going to save the frames here.\n", - "\n", - "# we seek into a second second of the video\n", - "# and use islice to get 10 frames since\n", - "for frame, pts in itertools.islice(video.seek(2), 10):\n", - " frames.append(frame)\n", - " \n", - "print(\"Total number of frames: \", len(frames))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Or if we wanted to read from 2nd to 5th second:" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total number of frames: 90\n", - "We can expect approx: 89.91008991008991\n", - "Tensor size: torch.Size([3, 256, 340])\n" - ] - } - ], - "source": [ - "video.set_current_stream(\"video\")\n", - "\n", - "frames = [] # we are going to save the frames here.\n", - "\n", - "# we seek into a second second of the video\n", - "video = video.seek(2)\n", - "# then we utilize the itertools takewhile to get the \n", - "# correct number of frames\n", - "for frame in itertools.takewhile(lambda x: x['pts'] <= 5, video):\n", - " frames.append(frame['data'])\n", - "\n", - "print(\"Total number of frames: \", len(frames))\n", - "approx_nf = (5-2) * video.get_metadata()['video']['fps'][0]\n", - "print(\"We can expect approx: \", approx_nf)\n", - "print(\"Tensor size: \", frames[0].size())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. Building a sample `read_video` function\n", - "\n", - "We can utilize the methods above to build the read video function that follows the same API to the existing `read_video` function " - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [], - "source": [ - "def example_read_video(video_object, start=0, end=None, read_video=True, read_audio=True):\n", - "\n", - " if end is None:\n", - " end = float(\"inf\")\n", - " if end < start:\n", - " raise ValueError(\n", - " \"end time should be larger than start time, got \"\n", - " \"start time={} and end time={}\".format(s, e)\n", - " )\n", - " \n", - " video_frames = torch.empty(0)\n", - " video_pts = []\n", - " if read_video:\n", - " video_object.set_current_stream(\"video\")\n", - " frames = []\n", - " for frame in itertools.takewhile(lambda x: x['pts'] <= end, video_object.seek(start)):\n", - " frames.append(frame['data'])\n", - " video_pts.append(frame['pts'])\n", - " if len(frames) > 0:\n", - " video_frames = torch.stack(frames, 0)\n", - "\n", - " audio_frames = torch.empty(0)\n", - " audio_pts = []\n", - " if read_audio:\n", - " video_object.set_current_stream(\"audio\")\n", - " frames = []\n", - " for frame in itertools.takewhile(lambda x: x['pts'] <= end, video_object.seek(start)):\n", - " frames.append(frame['data'])\n", - " video_pts.append(frame['pts'])\n", - " if len(frames) > 0:\n", - " audio_frames = torch.cat(frames, 0)\n", - "\n", - " return video_frames, audio_frames, (video_pts, audio_pts), video_object.get_metadata()" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([327, 3, 256, 340]) torch.Size([523264, 1])\n" - ] - } - ], - "source": [ - "vf, af, info, meta = example_read_video(video)\n", - "# total number of frames should be 327 for video and 523264 datapoints for audio\n", - "print(vf.size(), af.size())" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Size([523264, 1])" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# you can also get the sequence of audio frames as well\n", - "af.size()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Building an example randomly sampled dataset (can be applied to training dataest of kinetics400)\n", - "\n", - "Cool, so now we can use the same principle to make the sample dataset. We suggest trying out iterable dataset for this purpose. \n", - "\n", - "Here, we are going to build\n", - "\n", - "a. an example dataset that reads randomly selected 10 frames of video" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [], - "source": [ - "# make sample dataest\n", - "import os\n", - "os.makedirs(\"./dataset\", exist_ok=True)\n", - "os.makedirs(\"./dataset/1\", exist_ok=True)\n", - "os.makedirs(\"./dataset/2\", exist_ok=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "18.4%" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading https://github.com/pytorch/vision/blob/master/test/assets/videos/WUzgd7C1pWA.mp4?raw=true to ./dataset/1/WUzgd7C1pWA.mp4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100.4%" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading https://github.com/pytorch/vision/blob/master/test/assets/videos/RATRACE_wave_f_nm_np1_fr_goo_37.avi?raw=true to ./dataset/1/RATRACE_wave_f_nm_np1_fr_goo_37.avi\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "102.5%" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading https://github.com/pytorch/vision/blob/master/test/assets/videos/SOX5yA1l24A.mp4?raw=true to ./dataset/2/SOX5yA1l24A.mp4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100.9%" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading https://github.com/pytorch/vision/blob/master/test/assets/videos/v_SoccerJuggling_g23_c01.avi?raw=true to ./dataset/2/v_SoccerJuggling_g23_c01.avi\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "101.5%" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading https://github.com/pytorch/vision/blob/master/test/assets/videos/v_SoccerJuggling_g24_c01.avi?raw=true to ./dataset/2/v_SoccerJuggling_g24_c01.avi\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "101.3%" - ] - } - ], - "source": [ - "# download the videos \n", - "from torchvision.datasets.utils import download_url\n", - "download_url(\"https://github.com/pytorch/vision/blob/master/test/assets/videos/WUzgd7C1pWA.mp4?raw=true\", \"./dataset/1\", \"WUzgd7C1pWA.mp4\")\n", - "download_url(\"https://github.com/pytorch/vision/blob/master/test/assets/videos/RATRACE_wave_f_nm_np1_fr_goo_37.avi?raw=true\", \"./dataset/1\", \"RATRACE_wave_f_nm_np1_fr_goo_37.avi\")\n", - "download_url(\"https://github.com/pytorch/vision/blob/master/test/assets/videos/SOX5yA1l24A.mp4?raw=true\", \"./dataset/2\", \"SOX5yA1l24A.mp4\")\n", - "download_url(\"https://github.com/pytorch/vision/blob/master/test/assets/videos/v_SoccerJuggling_g23_c01.avi?raw=true\", \"./dataset/2\", \"v_SoccerJuggling_g23_c01.avi\")\n", - "download_url(\"https://github.com/pytorch/vision/blob/master/test/assets/videos/v_SoccerJuggling_g24_c01.avi?raw=true\", \"./dataset/2\", \"v_SoccerJuggling_g24_c01.avi\")" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [], - "source": [ - "# housekeeping and utilities\n", - "import os\n", - "import random\n", - "\n", - "import torch\n", - "from torchvision.datasets.folder import make_dataset\n", - "from torchvision import transforms as t\n", - "\n", - "def _find_classes(dir):\n", - " classes = [d.name for d in os.scandir(dir) if d.is_dir()]\n", - " classes.sort()\n", - " class_to_idx = {cls_name: i for i, cls_name in enumerate(classes)}\n", - " return classes, class_to_idx\n", - "\n", - "def get_samples(root, extensions=(\".mp4\", \".avi\")):\n", - " _, class_to_idx = _find_classes(root)\n", - " return make_dataset(root, class_to_idx, extensions=extensions)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We are going to define the dataset and some basic arguments. We asume the structure of the FolderDataset, and add the following parameters:\n", - " \n", - "1. frame transform: with this API, we can chose to apply transforms on every frame of the video\n", - "2. videotransform: equally, we can also apply transform to a 4D tensor\n", - "3. length of the clip: do we want a single or multiple frames?\n", - "\n", - "Note that we actually add `epoch size` as using `IterableDataset` class allows us to naturally oversample clips or images from each video if needed. " - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [], - "source": [ - "class RandomDataset(torch.utils.data.IterableDataset):\n", - " def __init__(self, root, epoch_size=None, frame_transform=None, video_transform=None, clip_len=16):\n", - " super(RandomDataset).__init__()\n", - " \n", - " self.samples = get_samples(root)\n", - " \n", - " # allow for temporal jittering\n", - " if epoch_size is None:\n", - " epoch_size = len(self.samples)\n", - " self.epoch_size = epoch_size\n", - " \n", - " self.clip_len = clip_len # length of a clip in frames\n", - " self.frame_transform = frame_transform # transform for every frame individually\n", - " self.video_transform = video_transform # transform on a video sequence\n", - "\n", - " def __iter__(self):\n", - " for i in range(self.epoch_size):\n", - " # get random sample\n", - " path, target = random.choice(self.samples)\n", - " # get video object\n", - " vid = torchvision.io.VideoReader(path, \"video\")\n", - " metadata = vid.get_metadata()\n", - " video_frames = [] # video frame buffer \n", - " # seek and return frames\n", - " \n", - " max_seek = metadata[\"video\"]['duration'][0] - (self.clip_len / metadata[\"video\"]['fps'][0])\n", - " start = random.uniform(0., max_seek)\n", - " for frame in itertools.islice(vid.seek(start), self.clip_len):\n", - " video_frames.append(self.frame_transform(frame['data']))\n", - " current_pts = frame['pts']\n", - " # stack it into a tensor\n", - " video = torch.stack(video_frames, 0)\n", - " if self.video_transform:\n", - " video = self.video_transform(video)\n", - " output = {\n", - " 'path': path,\n", - " 'video': video,\n", - " 'target': target,\n", - " 'start': start,\n", - " 'end': current_pts}\n", - " yield output" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Given a path of videos in a folder structure, i.e:\n", - "```\n", - "dataset:\n", - " -class 1:\n", - " file 0\n", - " file 1\n", - " ...\n", - " - class 2:\n", - " file 0\n", - " file 1\n", - " ...\n", - " - ...\n", - "```\n", - "We can generate a dataloader and test the dataset. \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [], - "source": [ - "from torchvision import transforms as t\n", - "transforms = [t.Resize((112, 112))]\n", - "frame_transform = t.Compose(transforms)\n", - "\n", - "ds = RandomDataset(\"./dataset\", epoch_size=None, frame_transform=frame_transform)" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [], - "source": [ - "from torch.utils.data import DataLoader\n", - "loader = DataLoader(ds, batch_size=12)\n", - "d = {\"video\":[], 'start':[], 'end':[], 'tensorsize':[]}\n", - "for b in loader:\n", - " for i in range(len(b['path'])):\n", - " d['video'].append(b['path'][i])\n", - " d['start'].append(b['start'][i].item())\n", - " d['end'].append(b['end'][i].item())\n", - " d['tensorsize'].append(b['video'][i].size())" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'video': ['./dataset/2/SOX5yA1l24A.mp4',\n", - " './dataset/1/RATRACE_wave_f_nm_np1_fr_goo_37.avi',\n", - " './dataset/2/v_SoccerJuggling_g23_c01.avi',\n", - " './dataset/2/SOX5yA1l24A.mp4',\n", - " './dataset/2/v_SoccerJuggling_g24_c01.avi'],\n", - " 'start': [2.9344678384893816,\n", - " 1.6827470772443045,\n", - " 3.9380918322335887,\n", - " 8.400625043794742,\n", - " 0.9696198736175933],\n", - " 'end': [3.4367669999999997,\n", - " 2.1999999999999997,\n", - " 4.471133,\n", - " 8.9089,\n", - " 1.5014999999999998],\n", - " 'tensorsize': [torch.Size([16, 3, 112, 112]),\n", - " torch.Size([16, 3, 112, 112]),\n", - " torch.Size([16, 3, 112, 112]),\n", - " torch.Size([16, 3, 112, 112]),\n", - " torch.Size([16, 3, 112, 112])]}" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Visualisation:\n", - " \n", - "example of visualsed video" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqgAAAKaCAYAAADyCqv6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9aaxlWZbfh/32cM65w5tijsg5sypr6O6qrmYXSTdF0aRJWyQNWIQo2hAM6oMMEJYNeIAswbJkQwSkD5QhgBBEG4IgWTBswwIlyLRlk5TZpLtbcLObbVZ3DVlZVZmVQwwZc8Sb7nDOHvxhrX3OeS9evIjKyozID7GrXsZ79557zrl7r7P2Wv/1X2uZnDMvxovxYrwYL8aL8WK8GC/Gi/FFGfZ538CL8WK8GC/Gi/FivBgvxovxYozHCwP1xXgxXowX48V4MV6MF+PF+EKNFwbqi/FivBgvxovxYrwYL8aL8YUaLwzUF+PFeDFejBfjxXgxXowX4ws1XhioL8aL8WK8GC/Gi/FivBgvxhdq+NPe/Ov/q/9Ffvvtt5lOGtq2495ey+6q4+bN26y7jul8ypWLF5hMLD985/u88+4Pee/DD6m8Z3NWM2kq6srTOPAYsjFgACzWWiCRc4asLxswGDIGjMFaA4BxBmPMcBzI38i5qqrCG5jP5ly4cIE333iDl6+8RNNMcM5ijMFap5+TH7AYW4G1YBwxQ9sFdg/2sa6Rz1pDjB2LZcu9Ow+4e+s2D+7c4nD3Dr/w1bf5I9/8FXY2tyEbcky8/+F7/ODdd7l97w6RxNu/+DUigel0Qt3UuMpRNTXOWIw1GGupqob1es3h4YrJZMbO9lmmk01+4Vf+MNV0zt7+Abdu3OK1l88TQoetKpyvMK46uliGk8eTijQ87nPHTpGf4rjvf3Cbf/l//1/y//kbf+Upjv58x1/7N/+X+fz581S+pusCu7uHXPv4PnVTs7m1wbkz20wnln/8e/+I7//wh9y8fYeUIceEt5naWyZ1xdbGnOl0KnJKxpgMOQLlXzDWAo4ymcYarMqsKRNsiswayAYLOFOeA3DG4H3FZDLhjTde46tf+Spbm5vUdYUxBucczhmMsRjryIjcGufAOMASYmDdJdZtS4yRmBIffPAxF89eoFuvaCrHN77+Zf6Lv/Wf45Phy1/6Mr/w9V9g4itijNy9d4+f/PR9vvO97/LwYI9f+tYvMZk2VLVnOptiKrnfnDMpZUDuq+sSzlVMJ3PO7JzjtdfeZPv8Sxhfs1otWS8PmE8n4ETmXVXr/Y/E5CSJeZoCI0+QtKeV3e+98wn/0r/2/+C3/sv/2XOX3X/73/hX8sWLF4kh8eDBAZ98ss/m9iZbOxtsbsyYNp6rH7/Pf/Z/+3+yd7gmZoCMIVI72JzNmM+mNLXnYH+fuvY0TU0zqTBZdG4mkcmknEkAOeMMWGNEJo2BbAf5BcDirOpTA17fstbinMdbj7WWra0tXn3lZV5+6TIXLpynaRq891jrsM6TFBfJxoExZJP1PDUxRJarFfcf7vLRR1d58623Odh/CDnwq9/6JVJo+dH3fsDHH33MarHmn/oTf5qz587h64qu63jw4AG//Xu/yw9/9ENeff0Vzl86D0Y2jkAiZ0gpE0JkMpnqHuGofM1LV15lPt/k5VdeZ2vnPPiGq1evcWZng8pbrDVka3D17KjslvGzyvBnpHvfeecB//q//nv87b/7Tz9X2f1X/sd/JZ85c4a2jRwerphvb3HmzDY7m1vEruX69Y/5P/0n/ykRR8qiG73LVMCbb7xK13Xs7++zv7+PtVDXFVXlqaqK6bzSvTthR3YAKWIQ3Zr7iTJgLGBl/7flVYszYgdYB0W6izzXVcV0MuHs2bN89Stf4bXXXqWuG7CWjOh1Y7zoYESXoXYF2XBwuOCTm7dICTa2trl+4yoxtPyZP/XHcWSIiZs3PuH9n7zHj77/Ln/hv/MXuHLlJabTKSkl7ty7y2/91m9x/eZ1rLe89aU3wBmSSaScyTkTQiYCVVVTVzV13TCbzXnt1TeZzzfZOXue85dfAtPw3nvvsbO9wdbmDJDPeT8hW33uEPkyJp0sij+n7VA+/jj5ffcH7/Fv/Kt/nb/16//RY890qoFqXFln2ZhtbzSa/v7K5pnIxJSIEVKMmLymXbc0tSNOKmZNI+KQDeRMThHrIKUEOWMy4Kx+LVVgMWOdGKalHJbJxSDI+s0zIQSyNRwsDsm3ErHrcMZw+fJlmqaR+0sZq8q1/GSTRdicwWCxzpLSjMU60XUd0RqsyazXazKwtbXJxqTGvnyBqx/9lK+98SVmkzl1VeNqx5mzZ7ny0hWW7YqrN67z8OFD5ltzNcLlqco5k22ZO4v3nrZthzkv95fBpEzsIqvVgowIpa8rrK/UKCkfOkWW8uPlqAhOzifo29GL+bHnz4zPPouHvHT9N4G/8ri7eWbjiOxa0xuC/fvG4L0npETMyE/MsimnRIiZtossli2T2ZwQOyDjnKX2FTF2JBzoRg9yHoPBJvGCRPGpstSN0RjIOZER+bMpAZCdJQdgBdev38BgeO3VV3WDr3RjtYhfV5y9BFkcPUzGGMNkUoOB9bqlbVuWyyVNU2OIOAvWWf7Qt3+V3/2vfpuPr11lY3OTr771ZbxznDl/jpe7lgf7e3zne3/A4nCJdRbnHTFGUg5i+OpPCInpdIazFc56rDE4pyrFZKw1uGKAey/PmbW4yiMGvYwMjxVS8xjBzqN/T5Xdx57/qOxuuwt8I/y5ky/2rIdFvrjNjMXWZNlUnXF47xm+nehDgyOnLI5WhpgyISRCWBGCOCx1XY2cJRg/2Vn1bMoRYxzkqFcYAQRmWJNoBpAhZ0hWdOzu7gNyiiwXC2JMvPTSFYyxYkLnAMZirSORIBtZKmPIKeCsoXKOynmapmI6aVgvK0IUZ9A5y+tvvsFqueL9H7/P93/4Dt/+9rfZmTTMZjOMs3zpzbf46KMPWRwu2H+4y+bWJjgwep9ikRvW6zXOVQKKODG0rXX9PoEB5+Rv7zzOGpI1uMr3hns/e4+T36NTfGQkTpfd/rgnyO6G2+at8MsnX+RZDiuqzpjcfwWrP1lBIochGwuIgRQTWJuJWeQsYxQogNW6o+0Cznd0uWY+E8DJGnkOcs4klT95NsqzXp4LMeyIYI0Fk4kklV8LI8MsW+iiIS+XpLt3gUzTVFy4eJG6aUQ+g8E6J3rXyD7Rj2yYNDUvXb7Cw4d7TJuaxnu6HIBMNmCt4ey5M3Ttq/zonR/x8bWrbG5uMZlM8FUljt2rr7K7v8vu/i77D/fZOb9Dec5TNr0N5qxVebWklHHOjZ5pwBhSSuQ0fEfnPK72ajuY3vmxg5Z8ZJykf3MRP3PsxROctqMO1lG5nfvXeT3/Sydet4zTDVTrwFox4hTtOeJRjx5i78RDzhlizqy7SEqQUoSU8NZTVwNqUoQqq2dgcoaUVZElTJZNPiGGWjGJM2Cyvl++tCqcnDKHeUG+D/Pr1/G+4uzZM8xmM/F+M+RsjyrnnMTzshlrLHVdEXOkC5EUIwlYr1ainJxlMp/y6uVX+OTGx9y49Ql13XD50mWcs2xubnLxwgV29/e4fe8uD+4/YL45F+WdMy5DygkiJGOwGdn4UxoMcMNgTGXUmJf3rbMYK578IAxGDST6xT+y9xzZhwZpM70HNSiTfl6ObfAF2R4+fPTkpZTu1GTezIOx/TyHsQ7KfKnxVp624YF1YjgZS86m/x4JQ0wQIoQkqEvbduSc8d7hJ7Vs4CSd0SxoFCqhGUwSYyxjRLYxOq2y0SczetBBlV2GAAcHB9y6dQvvPDlnLlw4x2TSlG+GMZlsUm/sGujv32ZH5RzRWWKMOGtpmooUW0yOZJM5d/4cZ8+fZblYcu36dd545TWm0yl13bC9vc2VK1f44OMPefjgIVXtaSY1XdsSrTiDKSZCjHRdxNqKurbU6jg6p3rimIyQM4aiS4x+D5FdcTOPye7446fJ7ui1cp0jsjt+r1/8R2V3bR7ygfm7wFefIFmf/xBkxso+2D+cjKxtBMlEnsuCHokMGlLWTR5DTIJ2x9wRYsJXHfW06hFBg8WQxGjI4myJHOVH5zJnUkpYI89IWbU80lEpGXIy7B/sA/K8TKcTzpw5Q1XX4jSaNHwfXUubLdgExuCcYTpp2JzPaaoK5wwp0jth8405Fy9dZPfhLh99/BFf/4Wvs7m1SdXUTMyESxcvcunSJe4/vM/ug122Njd1Co1sxkaiF9kcgVoU+NA5RRzKI3XCjcEaK06nKMXR54d/joyTZFdfs0/Su+Wa/e/lnaOy25oVH+UfA2+ccAPPbhincmuHPTYrumEQ58J7T0oKQOk8ZHSuMb0jkwXNIWVIMcG6U6Tbkp0VQ3FkJRV9ILMjnxVdWzT0YEz2S5KzmjBGAYBEyJnVOnP/wQOuXruGqyq2t7eZTCaAJacE1omeN0BOvTPjncVOJ4QQ8XWF944YR/uOgaapOXv2LG+8+QbXb1znlZdfYXN7i6mT6OrFS5c4d/sm63bNw4e7nDl3Bu88KWeizYIeW9m3JCph5ZlU58oY9RIwxJgEDNHony3IrylOQlag7Nj+3k/UyXI7mB76ADxG5x6xSsyjcrsyK97jXeAXHytTpxuoxvU/1sbBs2QQjWxML3jeeTEqsyGkqPZfJsVWUEZfY40Rr0a9IDCQkxhuWdRl1q3HIt6B1S/cm2JRVchYeWPlc10m50Ou3/iEytcYK/dX1zVFXiUUkEgZjE2QjC6ceCKTiYPVmraLhBBYrdfMJjO6tbz/yquvcuXKFT65+Ql1XXPm7BnqeoPZbMb5c+fZPzzk9t073Lhzm5deeVnmICUxRAOEHMTgtGIYhRAVSUY38cE/N+hmlHL/oB91avIJvz/GnX/Mp3obovzXjF+U6+aRgD16Dflk4zyvb20/8drPYojMitOULOpcHTkAay11VfUOQXloxYtX5ZjlQWu7QAxBnDHvcLZ4/CKxCdl0cwmZpiSGMUZcyDwYZWSrEQmIZEXMi9Ua6IAHu7sYYwl6zfPnz9I0ZSOV+3PWQIqjtTGkGPHW4J0YidNJQ11VtM6SYiDnRN1UvPbma3z0wUfcvH2TB7u7TGZTrLXM5zMuX7rES1de4r2fvs/m5pyNjRltjiSbiVHkOEb9XX9yLhEW11NzUAdUlFsUmEKADbBlayrjc5JdynVOl92WW9yw/wfgf/LE63/eQ+TWg01YM0aaB4PJjiJBsvyWrIhnkV1wIsMYQpdYrTucs8zNlNxUVN4JElMMTgUL9AkAOIagJHISFNEoKmQAm9GogMoyjrZr2dvfJ4TA1tYGVV2xYTapKtElmRJdKN8jqZFtsBZm0wk7W1s0tcdbSzSiswGct5y/eJ52veaD9z7g/oP77Jw5QzOZ4Lxne2eH1159jd3dhxzsHdC1gWndQEo9ailO/oCQjiNrg/gkoiK3Ze6NRkOOiukpsptP/rM4/sNrJ8vuUTfs+DXkmEN2ecf+BvDfevT6z3BYJ3JrTFIjXvb/rI6ItVaMNglGqXsv2jPmYiyJcZUo6wHZGrqUWbWBECB5h60N3hUbQBF85Dq9cQr9WpUoVxlFT5d932RBHLGWmBLL1ZqPr15jMp3Kd7OWqqrJSbT+4DVkMMWSUQdqPiUxyFYx7NDXNjbm/MIvfp2//+v/gLv377G1vSXGZuU5e/4sly9f5vDwgBs3bhBDYlI3JIPQBACrwIpVADHGYqBaBRWd6t5CoUy9yPbgcnEue0fx9LU9rnPz+J0n6NzM6P3RKy13+cT+p8BffOx1TzdQsxiJzjqS8xgTSTH1CEhKSYzMXLgcuiFjiNmSsxqBxrK7v6SZbuAwhBDwlUxu/1WzhDyj8oTEq5bzS8TU0JNJ+okoKEzC5TLhYvDu7e3x/k9/ynq9Zr1qefnly0Al4f7cOxmYLIa0EaiWnDN11fRzvlqtWS4WXDhzltStsCSwmW//0W/z9/723+XDqx9RNQ2/+o1v4aqKM2fPElLi4PCQ9z/6kMXBIVXtsN6QVoloEjFE9W7AmD0mk9lgmPaCJgtpDWr4K6qRMj1m3q/54KUdFwJGhxwfGUbw++OEQCW4f96LuJlHjjGNYfra/AknfDYjx4zDYSWohDVOEE0N8xkMJhmcFcUyOIti/Bkk/BQjZBwxGdoukdtAiInJpMbXXnmh8jnxk3ovSJ4VGBmnVuSzmLXFK81iHFsDziaIATrL3fv3WCwOWSwW/PIvf0NRKCfGrMmkGHWjFeTJYMFEcjZ4a9iaz1jtbFM5gyUh+Jo4WV/60lu06zUPH7zLD3/0LucunGM6nbKxsYHznq+8/TYfffwR6+WS5cEh082ZRp0VYcP0vMKyaZdQU9FguWAaWackJYwtimswqvNIvnT1ji7m42T3SULwM8juG8z438bHe/LPdCTVvUaQosL7zQnVtQ7vxcD0zkIyxCRWf0pCvehiYqpc5ZSToKq6q+7tL+lCYlJ76sozrb2GYa2ul0augIIylTWT+xAjsqxiSqbf7EwuOlmNgJR498c/AWu5cuUKZ86ckY01J7JVBKuAPsUUMxZbe7a3N5nNJtR1RQi231hzhvlsxisvv8wvf+ub/OCdH7C1JaHSummYzKa8/MrLfHLzBtevX+f2rdt8eftLOA+5hIStwzqHr2rlQ8p39d4Lhcr5fvcuvFVjEi4VvT3MydGRj/56kn41jxx5wjF6bT3+NNltaHkt3z3tbM9kVLbCWYezXnjyWe46anTIGtuH/wsKnXJGsBlxvHGGqJ+zSBTMeYd1gniv12u6dUfXRebTCb4qG3n5Rx0JehMBGC1DMVhz0QsyryFnTLR4pR7l0LG7u8tPfvIey+WSEAIXL17G+6DKzGJRmczFoMg9SrpYrrBWdCQ5E0dIq/OeV156iS+99SYfffQBq9WSP/Qrf4jN7W3m8zkvvXSFxeKQ27dv83B3j1e2X8J5R9JzWO9x3svcxkwInXxH8bzEQA1JzSsBEKyzqj+G+cgwAjaPyW0ZJ/hG+YTDhmOOPhODbj9J52b+2hMMkFOz+FP5MYZsLcZZRaaK4vT9fVeVo6r86N4kcSRjCRFiMvp7Zrlcs/twj7ZLojStE8K8siESgix1JFIKpBRFyaZIDIEYoirKTAyy8YoSzoruREIKHK6WfHztKu/88B1+8pP36bpIIVLL8UGQnZTIKZKT8EVi6HAWGu+onKWuHBvzOU2Pwkam05qvfu2rVE3Nj3/yIx7u7Qlfr/Jsbm/x6uuv8dorr3L75i0We/vkLtKt1oRVS7duCW1Hu+5YLleELmrSie2pEvRh0DLXhpQTOamR+hmMp0keGR+XTxbJftxZ1/xfPjz/c97VZzNCSmIsKsFdQk9Gwxy2NxqbSpPW8hjRF5pKyIkuBDCOGKGLmTZkdg+W3Huwy4O9Qw6WLSEawOGsk3MjIdZimA2jWGq5V97yk3sZjjkTUqQLLSF0HC4Puf7JdX7v//d73LhxneXigJ7enhOo/BKT/JsjZOGbzmdTzuxssrWxQVPXWH2+IGMsvPLKK/zCL3ydd370Djdv3eRwcUhICV9VvPraa3zl7a+wWqy5ce0TXBbek3ee2tdM6ppZM2HaSCKDRE6SoMu+wuAwWecaldlednWef97xFKcY41Cnjesc8O/wuz//PX0GI5FVPE1PiXDWUSnaH1OHMRZnJbmjcPIsBQEsXN9KQv5YkrFk48FVmKomJDhctezuH3C4bIlq/NLLyJBEcbwdtlHAoMhu0v9l/Qk5iCynREiR3b09fvSjH/Huu+9y7do1YlSdnkT/FvR1/LBYYGtjQ5LsVktiCDI3qqONMWzM5/yRP/yHMSbz8bWPuf7JdYnEARcvXuDNN9/k0uXL7O8fUFU102YiP9Mps+mU+WxG09RU3gmKnKKEp12Fcb6X3RQ1TyLlI5y+U8eTVPTTir95suw69tnkv3rKE35+wzgLzpKteB3WeirvZV+0jqpu2Jhv0FQV3lmcExS0x0yV9keMSmnzOF/j66b/sSq7e/sLHu7us1x1hATJDMmihTZyfORhI+vtypLwKdzrRIiBLnSSY5Aie3u7fPjhh3z/+9/no48+oG3XKrdB5TiQUyCnlpxbcu4gBZrGs7O9yc72JjGl3iDMSZwda+Cb3/gG0/mUO3fv8MMf/hDIVM5x9sxZXnnlFd544w3u3btHipnKVzRNQ13XeGtxxkiSrZHob4wBX9fUkwac7XN7CoWyJ6aP14sTNPHPYlo8UYZPP9kt9viP82+cesypCOpw95pEZGyfmyNoihFOBrLxO+XLFO5HRuYlZtk/wZJypA2JEALsHTJpanzllFxd3KDU0/4FpYUco9xHlvdz4Z0q9y5qiDHrOYRU37LKiQcqeN47XnnlZeYbc1xVUfidmCyh/jzw+2AINZ3Z2aH2FmcgGVlw5zyvvfEqq9WKDz/4kPd++j7bZ7ap65rZfMaF8+d58/XX+cd/8Psc7B0wmTRMZo2gc9n0pG5BTHVOzTiZJ+umLx6SQQwAmwRJKetQDA5xh45JzAkOfn7kmONSdvTvUmWhRwZPPoyc4eJO5i//6cgXYugGX/6VEL9S9gX2kflWfrVBMumNIvlkQa06pV7k0YklXxrWbadOUWZSOSa11xAVEg3IaeQBZgXzTIHr+8S9gtKA8K3k+vKZjCPnlnv37vPBRx/RhcDly5mNzQ0KX9AYxRusItkYjCrrzY0N2rYVDqlu7iVoOJ/PuHzlEq++/grf+8H3+Jb7FS5duoSrKubzOa+88gp3797h4e4D9nb3OXfhrDqpYgRlY6mbRhIdzGC4WOsw1hQfQPmJJaELCiw0mOhlwU4fj8huQU6OLPro+Dw+9+myO6Hjyzx44j08k6EbrCAirqeFUFDprLx/X1E55Xxno+igIlEaHg0hSJa/Vn9wlceqYUCOxHbNwf6C0EUmkwrvrVzLWjVR0yNQlDw+Sflu5Z08HJYhxIgtUZ2c2d/fB6DrOowxXLp0haoCcCPQRfIIjFGkM0WMyRKt8MrjN6Y3LDJQV5a33/4yH1+7jjGGi+cvsKlo6uXLl1ksFjx8+JD79x5y8fJ5rPNkNGG2VHBBEnxTSlSVx1ROBBoBOwTEEKNrHKjqDccR7e1xYyy7/dFPI7sCSz/uMJXdNV/O10+5+rMZPf2v6NRCnUMSdKbTGZcuXaJ+sMf+4YJ12wpoFaJEopTiZxVSd84NXGtjFJGssBmSFfrTarGi8w5fe5ETJNN+rLMHpDDL85GV/1vsDVD6RtFI8smYIjlkFotFvx5N03Du3AWm0wmQsM6Q0qATJbs5igM1mxAnHlLU/VPzEAQxYWtrgzdef52rH1/lvfd/wre+9cvM53Omkynnz57njTfe5JObN7l39x5wVpL9VIVa6wSZVupfzkYpBRKdsGpPCTha8nyGuRiDmqeZkSfK7dFFP3r8WOc+QW4rIpdYnnL1J3JQCzdHoXkK94kewElRLHNrjIZRDTZZ9aZlJBJRSdA5G4GlIyyWLSEmLSXhqBtRxpYhflSy+kSUlEidS0qKrJaEZE3/SsKIAQIK3khyx9WrH9NMajKZzc1NrHOycdoIyapxMfCvrDE0dcXmfEZTeyrviEGyAQ2Gzc1NLlw8L2T9qx/x1a9/lS3ncM4xm8+5cuUl5j/5EV3bsVysmM2morQ1iUQMVIdzVg0N03NJxg9OjLF/aHJZ3SeO4+ryMX748RfNCa+XvekRA+Ho8E3g7OsPn+LePv9R0EyDw6jC6EcWL5acVQmW0jqSmJKxwimFHn0VOTSKblmwIiUhQRcixIgFvKLdaIbzeB2KYWjKLj9coXfoUD/AkI4kySxXK27fvqNKyOC8U+J+Ua6KEKQsSAbCE2yqihgiGOGsFo4hRs6xsTHnrTff4Pe/8wfcu3eX+cac7Z0dqqri/PnznD17luVywf7uPleuXMJUo2xRK5tI4R6KUtIs57GjNfrn6Tz0p5Td4+c7SXbLW0+Q3QzEzwLV/QxGn0g2LvOUcu+Dlo16Pt+gbROmDUjMiZ6bLHQRCflnCl3AYn2RHzVEU6JbLDGrVrRprYiXkyRA0aFJd7beb1J5yydMuR5oska9ZFm6ruPg4EAoVHVNVTWcObND00zI2ZAUcDAC4iI4sjzBk0lNirYHE4RbV+xmx0svv8zNW7fZfbjLxx9/zNe//jUq59nZ3uHSpcvcuXuHe/fucfb8GRov8ivfb9jE5bmQKhRm9I1SjCMk6qlW79jfn7/sRhoOee1pbu5zHiNMLhsFkeR1a22PAm5ubmCdZ9Wu6ULH4aLDWTFQRReLHrFlj9Qfi6CyVIbsLOuUCF0gxo6YrHBf64mCDqPbyqjTX0yskTPVP2FHP1AcoJQETFsul9y7d4/r169jjOXMmTPM5hPhfI6UmzEDxaCuK8BJZEudufJ8ZMB7z8UL59nf2+P27dtcvXqVt99+m8p7ZrM5586dZ2Nzg4ODA2azqQBrR+RWjCSLAIVJ+abEqM/QMed/hAeMXM6jx4zn4MkLfmSOHx2ny61liyl/7NRjnpzFj2MgkKMoDX04PYXUk8edkzp5JZRvRpMRUuoN1JxkM123kbbr8F6QmE03wSuVQJDYRFL+FbnYrHJS8Yg0bzohxoV6SEkvGkeE3ZwSN27eFAgcqKpqIEATe7fCyLM1EOe9Yz6bjGr5FSNWjIIL588Tu8hv/sZvcef2bbzzzGYzEb7Ll7hy5Qr3799ncbDg7NkzVFVFtIPn7XxF5TwhFgTKihdfSkFk+gSrAjQMHqE+Xse9k5PW8thx5jHHHXlRjeZ8/PXHnH+RAz9Y3eHPnn7oMxne1jjjscZpoomGLo0GJZNwOL2XMFTlHBEltFsgSY1IYw3WO7IR1DQlhI7ivNB9rMzPul0LmlF56sph1QDIpZZvHrRDcUbK+pbXDcX3MCQjlS1KKZOIYW9vj5wTIXQ0kwkXL16UDdXI+ZICXqgRY0wSDq4XRytYDfeYRFZErqoq3nz9Dd75wTvcuXOL6WzK5sYmtvKc2dnhyhUh7N+9exfnK5x3g8NiHaZ48oU2YcBVlSCoqf9Cx4Yo0h51ePRdhgn5DGT3+HvHhsGwouZ9Lj3+oGc6hB5VrLVS+km+kxiPTSP1GmMyuMMFZrUmpkBKoqOdNaJLc8Zmo6ipRsEUdHDW4mpDWnfEEFkv16QYaCYNVVXRwzXF+YHeSO635Jz7epKYoVJFj0gpupPSYKR+/PHHVFWNc46dncHhKSiZyIzwZo0xTOuajCPHQHalKobcWM6Zs2fO8NKVy1y7dp3vfe+7vPbaq2xubjKfb3Dx4kXeOHyD3/jN32S1XFFVHle5UaSqbN76PaxVKooYw6lY2OXb98imKGBjj8rvcdnlBNk9cZwgu/2fT5DdJdu8Y/7E4w96RkN0yoD0C/osz3j5PqvVirpp8M2EeYys1itibKm8wySovMVb0bU2JaEJZdGfDrSSDfJ6DLRtS4yt6KAcqZzHWf3RCKTcXKIgpmVZRv/o/eu//d9idyRF0pfLFR999JHKd8L7i6pnzfAMZDlR7hNzTQ+gMTpvzgmcY3Nzi4sXL3Lv3n2++93v8sorrzCfb1DXNRsbcy5euMBHH3/U82BddbSee7HNYoqE0BG6jhwCxldKRcj9MaMbHOaBo995GCfL7SPHHXvhCEc6D4/AycddJvE/eOTK43EqB1U4pE64S5q446wSnI0UPo450YaOnJN45r0hO5STAeWyKs+jYKuFa9WlxMFqxcO9Qw5XK7qulfJUmD4bcDwX/Vavm76YHFGK2TJiReXUG3cxJ9q246OPrvLjn7zHBx9+qNB9Uj5UHEKRJDCJUvt1Op2yXC5Zr9d6X/J9cobZfMZLL1/hl7/1Tf7h7/5Dbt78hC50GGc5d+4cX/nKV5lMJuwfHLA4XDKdTplPJ8ynU+bTKdPJhLqupd4rYjw4p5uD1owlZQhJMvkLudHAaSTSMkfj2sXHh3ncT0ZoCGjY5dFCfCdf8z6s//YTROoZjVIXTsLdYihWzVCiyygZv55M2NreZmd7i9pZfGVxTkqi9OfQDTclSTPCiQHqqgpX1Rhfg69YrtYcLBYsVitVdqqwjdWEQAnDQlmf3HOnj/5PS/ZkCT3KtSNt17K7u8vVq1f5/ve/z507d2jbtcrwoF1NUZI5EZPQEJrphNnGnJiD8msjMQu32znDt771y9x7+ID33n+f/f1dvLHMN2a89tprvPnmmzRNw90790lRkh3suKQUSUu/Mco6z2Q0PEqxQwWnFJ7s6R5P/4wPKuSRcar8Ftl9fBHfI6PhCpfNv/jkA5/BSBFysrLhGym7hLJJxeIzVFUtVUPOn+XKlctcvnSBs2d3qBuPr0wvw95KcmAp/WMYbWxYvPFsbGxQNw0pJVaLFYf7B+wd7BNj0Ds6+kwXP6i4VT3Prbxffhe4l6xoqtTOFTTqpz99nx//+F1u3LhG27YIFzWqvi5Ph0SOrFaJybnQVwZEKKsx+9Zbb3Lhwnk++eQGH3zwASllqqpiNptz5swZvPcsFodS03p0r8W4sFoFpus6YteRoiDSoVvpnBUhTH1JrceNI7r3FNX5eNlV/as/TxpTDnmL33/icc9iCN0uEQm97kHLnrVdx/3797l9+w4HiyXWV1y8eJEvv/UWG7MZtXfUzjKbTAZOdc6YnHBkKmuonaWpHHVtmDee2cSzMZuytbHJ5uYme/sHLBZLui4QtSoEir8Colt7wK1EYo+u5VBFRz6bkiQj5QzL5ZqPP77GT3/6ATdu3NBndaAaCvgm+7TVuqUmayMWDG4wZYldwFq4cOEcX/vqV/nwww+5du0ay+WKpq7ZnG/w+muv07Yt+wcHLBfL0TyLlAkaHFmvVqxWS9r1khRaifBF0bXGSHJqKkCcRUpvmDwIXP/l6YvOPEltPtF+UCrj4060wYpv8sGp1zidg9qX2S0eruy1xglnUzhGAoFb66irmqpypGAIKQmKAj38bpzFZEc2lkgkZquIgNEaaobDxYqudUyqmtm0UcPNjmyxUmhXoC5JeBlM15Rz7x0nA+SopS7Ek0irJTdv3pTFbFu+8pWvUDeNVCoAyE54iEkWUh4Tj3eWSVNhbSndIMkzYKibmm/+0i/x4U8/4Or1q7jK8/qrr1NVFS+9dIVbt24SoyQLvPzay8QUxUEx0plEar7RK/rJtFGOaeoVd/F6Sr3YUzVfP8pGAfmE4wfEjn59Hx1DrcoTz92fCS5svco/90/+q09xX5//cKbG5kqz+IfyIjEGyIla68htbm5x5fJlYkzcv/+Qh7t7xOwIUergYiJ15cR7zzKPXvl/1krhZq+1aZedJFXF2BJjpqosk+lMlJKBIf1v/DinI+tQeFByxwmDEN6NE60RYma1yty8eRNjDG+99Rbnz19gY2OrN6YFbc8aVXJi0HgxdmJMWD9SwBrmeOnKS9y9c5e7d+/xO7/zO/z5P//nqV3NmZ2zrF/q2N3b5eOrV9ne2cT7mYSLlZKyTllrWGqDi9DhazGqO00qgIafafQ83J9Rdo/wTp9edjOBaB78bPf4OY2kG55EcwqaGBUhFfc+pcitmzdZtx1VM2Fze4ud6hw7yzN0q0OIkcZbppOK1Vpk3imf32VR/N5JCT6XMj7VBCvJFplIjpH9gwO889q1phpt2nmAUntXSzjXhSMKqkNJPd2joGopJZbLpW7GSxaLJW+//RUqRTaNRucsnpKPYI3FKgfVUpZZEmW70OKc5dKli3z57S/z27/927z22mvs7JxlOplw7tx53nzjNe7fuy/lrrY2SCmpA5oHKmLOrFZLVqsFVdPgqpp2vcYkaVxgStegJ4xSggsEPT5RrT5RdvszHfv8SbL7Gon/zVPd2+c58mgPK1Sioca36MqU4XBxyOFK6nzWtefS2W0mtWUymzCvKyZ1za2798U5txmLdJuqrKEyBm+FwmUnNeSMbyom6oD/zu9+h73lIasqMJlMqKqKpqlQTgqlTnVxHoyRvJJhxgsNqsw+ve4OoRU9v15x8/ZtFqslxhhefvllqqrRiiaJUs1IaHyDkTpW+9YUpF6Qe185Qgj8xm/8Bn/yT1oBtpoJL7/8Mr/0i7/I/sE+q/Wqn+txfWRb8gJyJqdITB0uaYJ5SUA8Pk4Syn4T0i99kmF5qtyOXxzqs5vjH9RXFiz5AT884SLDeIKBevxbDFur3FfCeclebpqGjc1Nzp07y70Hh1jTSQ3JnLDK5bXWSEUAUE6qxfoKW8kG72shrIsXuyTGwMZcwvBGs7DFY4+9F5KPGF9D4Wj5K9PnXGYhPYN0EClI1HQ65eKlS8xnG1SVFr3tM1kTGIm9GwzTaUPdSFcqZ4aH0WQJlX7lK2/zySe3uHb1KufPnmPn3Fk25htC1l8u+OTmJ6yWK3zte5L+YBjLlzHGYr2XbFE3+mYjIxyyVB7ow8dloyjLdoL05SIsRbBPkr7x50bXO3b6x9nGt/0D/uPtv8Nf5esnH/AMx3hbOOIgmuHhlva3RsJEIbC5ucl0NmWxWrJYLlmtVqS4xhuJHDjdGUXhiBKSzdNQ+wo3m9GuV8SuI6w7YhCHqWl0gzcA7uhSMfozj5QnBamSgvw2C8JjMVJRoOu4e/cu1lpWqxUvvfQyOztnlc9sINkCpVJqrhorhcqdsYIsFmWdEs5Zrly5zHKx5OOPr3Lt2jVeeukVJnXD9tYWFy9c4ifvvcd6vaae1NS+7mk/os8EGWjbNW27ppoEcioJfj2mRCk9ZKwfieAJsjuWt59ZdssJ8tE/TzpMxwrPh2yd/OZzGkftldwbZUZ1XohReJ2HSw6XayazGU1lmTYTvMnUznFuZ4e9/UPaIGikzwlvLLUR5e+soXYVjbPk3Ejd6Nrh64obNz5hsVjhbGAynTCpK4xzsomjIIzey3ivKvzUbMQ1HFh6JUHPEGNkvV7z8OFD0CjVSy9doa5FxxtFULHD86rTIBxUKfAq3LuY+uz9yaTh7t27/PjHP+arX/0aZ86eYXM+5+233+bHP/kJVVX1hc37YbIaqmqcpAgpkIOl61rZN5T0mpC63IOcHpXd/nkue/2nkt1ygjz8+rjDgBX3+Cl/i+ddB/WxYzxVxmKcIwIxBELsePAgcnZrhqtrnDHUzrA1nbAOndD0DHgHXnn0zhoqb6grSXhztRio21tbeFdLB0rrSdnQtkGO8U4/q1VF8rhWajFIdaqPqaCxjk45EUNgDeztJX764U9pJg1nz5xjMpnq5zQJ2hoyjhQjnQGTMuv1iuViQVhKNaKUEqv1ivv3H+CM5d69+9y4cYOzZ89x8eIFNjfnfPnLX+LO3TscLg7JhRrF0KpYylOW5046aZLFycz5GEKc6feZYX1Gz++RAxkQ/KeW2zLSKe/J2GPJb/P+qcc8wUA9eRgrXyjl1JecqpuG+WzO9vY2XWdYrpYELRHVBfmxdlQ/L2VKb+bSL9f5CpsyXZRJXi7X1M5hvcN5o12BxupusNaHMZCUy/sl6G+ShoeSoFD379/n6tWrgjqdS2xtbeN9LQqwYNxGuC0Go20CNbFKhWFYUcvrr7/O3Tv3ePDgPh9f/Ygz584wacSD39vf49bt2zx8+JCz589KsosiUD3KXpAHoC9aZgrfdSxCY2P1NCE5yeA8+tHxw/cEPXjsVI9+sg1LPtn78ZM+/QUYZbMXcvlyueDg8JC6njCZTTHe4dXzbleSHd9UntY7uhAxOWGzpTBbrcnU1mEnDZ5MC5KB7CGFQGeKvEuo0ui1RaH0rtbwX12bHoXIhdM3JDnFFFksFty5c4dSVaJpJpKI13ci61MGe2/ewCjIRG+gkjM7O9tsbm2yXq957733OH/+gvR6nk45f+4cGxvznjJTRjH4S+H4EKT8Sk5BOhjFgMsixxL6Kpz1J63Rp5XdJ5z4MbJrWVLl05Xl8x4F2ZGvKEhlGwJdbFmFyLoLbMxq5o2nrj3eGrY3ptJ2dNXSxYgzWRo5QO94TbzDmAqUb91MJzSzGbdu3SGljpwiXRuxxuAzkiNgjK6pznnxd0bG5LiUWr/h6XeJKWKjZblakh5krl7/mOl0ws7OGSaTqda/jpiEyrM0bUkpEtqWdi3l+kw0dG1H17VKozqga1vee+99Lly4yPbONs2k5rXXXmNvf4+ohmwxosdyaG35ElHKDhpJwMlJO2zJIih4YE+RtM9Qdh851Umyu0/Nbz/2br4Io1SfqOpaWvRFMa5yShwsDpjVhtpIEfqcOurKknGyXjZjvcEZ0bXSY0EiRGJriW6sqgbvpXWt8xXWObq2JbUdPiUq78BbARpQZwpO9G1zb8BKhHOwZZWXHDvW68jtO7fZ2dkRNN4amrqhwKQZqQUvvR4Sqe14cP8+d27fYXWwInahd9T29w8wQLtuuXbtOtvb25w/f46mrrh8+bJSI4euUDkP1BpjBLwzRhHU0Gnpq0jJVJMkMW2m8dhVGr1znMLytHJ7zKcaXn/0k5HMrjm98+SnMlCdopllo/LOU/mauq5p6gkXL1bs7e3Rho4uBhbLJWmxEsEwBm/E+7ZWw6OaPW+xuKahwtCZNevVisODQ6qmoZ5Ib2/rPdkMRYD7Xs5lEox4rQlw+rp4GVkNQSsZ+yTatuXGjRuEEKQvs/dsbTpyVv5XTyoRxeu83GtO0k+6n3sV2jPb27z++qu8995P+e3f/m2+9tWvUdUTzp45y2q14u69e9y8eZPtHSlHBabn85aHLqVE6DpRhGJNyL1b6DkjvbKkPAscf8rMiZJiHv39iYaCnOPEMNSxz15eTPgX3vnyU5zwOQ4jD2tCNrsYM8vlioe7Dwkxc/b8eWbzDba3p1izxXpxQGUdG7MpKQQWyzUxRTxVYWjjydQWKuOpJw2xksYK080pD3d3WaxWLJfS93s2m1FpJv44ojJeR3FyJVxaJnnsimQSMYliWK1WykVtaSYNr7z8MlVVy2YbNetZykUUuEs32WIwQgpidPrKs7kxZ3Nzk9//zu/z9a//ImfOnKGpGy5cOM/XvvoVlqulysOxxTfl9FLPMIeOFCKx6/oi7KV3Czk/8p2Pjjxy2EYXOP7708ju+LBTZHcr3+TX+PeBv/50J30OoyAmPd3YWJyvSFbqSS/WK7r1gnVl2Z41zM6dofaG7fmEylmW6zVYcLJP443+WOm0l6xQrSRBY4O6bghdxhhpqtK2gRhFTnxVycaYJaRZ9PAjWijTo6r6Ug8YxCxNKfJqybXr1yRhz8A576iqUdKJESSnCx2Q2N/d5d7du9y/c4+4jqwWS5arFetWmrI0VcMHH3zAG2++wcXLYqRevHiRlx++zO7+Lm1o9cSJpOXkyr0Jpy/JBm8Rh0q5sNlI0mJK0himr612bJXgOOD06WW3P/QU2d3Olj/B5OlP+IxHyT3JJjPb2ubhctV3kcJIO96u7Yi1J5lE1y414qp6xml5S1vWDEIQkCimhI2Rqm7IGa0ZXomhql2WurAidC3BO5pJTV15KUkpd4Adrcl4mzsKCmkuQpFebeyzWkU+/OgDMCLTF85f1ATrUs5QuJ8hwmr/gOvXr/H+e+/TLjrQDnxZedcpS87DT3/6UyDzla9+hZ2dLTY3NphOJzhnCSnQ7wlqSFulmJVchRQ7CJ3SA0tOg1aVUQP3SNOj8h3Vhhxk9+eQ23J4j9Y+KrezXPN1Xj71NJ8OQXUG4yBHfRiNpe06Hu7ucu36VeYbm5y/dAmMQNr7B4fs3kvUztHZqJl6YHLEpij0NQ0/TowYqck5FkAbFoR2RdutOFw4tjc31Ut6dIIfRQCH34oRaZ2UwJKivBnWcPPmTRaLBfsHB/zSL/4im5ubKPeeIpgxBUqnJ/GpJHNZ9lhD6gL7iwVXLl/i8PCQGzc+4f333+frX/8F5rM5ly5eogstH37w/rFwvYyCSMQYWC0XhLCmqus+GYURivok3PRzG6ckBgB0m3Dz104/5nmPsZEnPDSPsV5WNCfuPdzj/sN9msoxn9ac35rhbObi2S02Jw37Bwse7O/jjThMTjf6Cph4i5vMwEk93guXLtJMp9y6fZcH9x+SU+TgcMmkbqjrCl8VbrX2WB4V0qfYksi0x6RcPrUCDJmQOkw00BruP3zA977/PQAuXrjAbDZHKpIYqVOq370NLcZULPb2OTw4YLVcUuWKw8ND7j98wIMHD9l98JDdh7t873vf45e++UtcvnKZ7ck2v/qrv8pPP3ifVbsaHKXcY0tHEqFibIldIMeOvv6EOYqmPdPxBNld8CV+wL/3jG7m043C37TWkgxMN2YcKJ2EGMlJElcX6xaXOy7sbNCtF6QQcSbRVFbj+iKz1mQwiZgCXactTJPD+oDB4qynqhuc0jna9ZouBkJscV1gvjHTFtVD4iyo32FKdnN5hd4hGhyWqFSvRG4TP/3gfVKKrLs1Vy6/ROW1GgSmjyLEdeD27dt8/MGH3Lh2HZckEoXq96B7UgiJ3/tHv8fBwQF/7s/9WXBWi8NbzLEcvTz6rST2pRSwSUpcyTuKohqwTxG+/EzHE2R3zZwP8reezb18ymGsUtcwvVNgECcLTcIWHnNg1a2JehxGS1OGjCVQUk0h0u1KUf35fI5vGqFfOKdVfQR5n84a7BrWywXrdUvbtmxtbhAtVL60uda6qPmoFSFGaikVKDKc+giQUYPYsru7y3vvvcfu7h7tWy3nz1+gaRpytkTo26g+3N3l7r373Lt3n6mbCAChBpxBKA+FE3P37l3+wT/4B/zFf+afITNQTOwjhqXcf+FT9+2VcqTksKSUsF7sFHNCUtiRdTr13Z9xPEFuDQ+Av3PqMZ/KQC0hwiGb0WgPXk/XBa5/8gn3H+4xnc2YTmdsb21zdmOKM9Bah9kK2JRZrFpsTnjEA2hyprEWbxBP3hpMtcF0PmNv/4D7uw958GAX7yomkylV7fG+lClRfmxpEI05kolWzMpi3WX15GPqsMlysDjkxic38N7x1a9+TZAuXwkaZJJuvlZrqiaclj2RK0kqVeUcq7Yl54y3lt/8zd/k8uWX2NraZDZtuHjxAt/85jcVPdU2f+UBMAUgTcTYEdoVvp6QYyAF7XilZZBOpIPAyPA9wbGXGz3+iUfeMOVpeYIJbE444YcfRP61f3mPv/BPnfrR5zuMPqiFC5UkqxPvkTCiIpSrQNcuict9XrtyAWLC28i0gS5WoqQ8WJtxJgm3U9sgG2cxzmsmcU1d1dT1BO9ruhiFwrJe44KhbhotrK7PsxluNCtaZqx6vOX90XEpR0KCHBL7B7v88EfvsFi+xuXLVzhz5vzQTdhkSVCM0AE3PrnBJ9dvcO/2XUyAHCNd6AhBNnnnPP/4H/9jNrY22NzcYGd7m43ZHO+kGcE4+3UwUovRmiTBjIS1eaAEGJQe9KgAP2/ZnfIxX+KvwhPKnjzPUWokW2vxTcPG1jb7q0AXF4Qg5XYkYUI29pQT63ZFSEoTMWrsxUwysaSY0oY1bZDOT1VTc0Fb2HrvsZ00d3DO00xq1ussvMzQMZlOSW0nJalKofWch+pUmf73sryZjBtt9qU0YAlXXrv+MYeLQ1arJW+8/hZWC7Jba3FG2kbu7x1wcLigbQN+FGlIWhoudsLT29vd5dbNm9y5fYcrL1+WOUT2gthHmMZRitRHL4osmzyuOiHh1OPjuOw+In2fUnZPUvMnyW7FXS7wnwH/uxM+8fxHaSphXcdy3fVATwbt7Idw0p0kxa27jsNlK5FSY7XZT5Z6zhTKW8IpcjjJ0jTEOot1pbykJG1aY2mqim5tCEFQ8BAiq3ZNXdU0dU3T1IJE9q3akbrWpV65FQRYDDwt8wSQFGCwWSJZt2/TrTrefjty7sJ56frkPN55YgyEEJSO0uHxCMoHIO1eU0rizGfYPzjgvZ+8x/3799k+s6W2jdayxmI0wlu6UuWkVZSczEPo1sSwpq98keSzMUalVj5e55pHfinjs5bbxEUWjxccfiYD9djdlv1o9FZpz4dxtF0gLVZ0IRNCy/a0wtWepnK4jZlkTZkDMMJLdRbhRim531lLU1fkynD23DmwlsPlioP2gGig7YLcQsr4yg/8ofGdjmfqMaS3UsrHhI7lcsHNWzeZzWdcvnSZzc0tLSQdIUvpFqnpJ0bB/u5DDvYPWC5WmE4U9+Fyyf0HD1kul6zWLdeuXeP1N15jY3OD7e0t3njjDfYO97SrT+9AjaZUFHUMHTlK27QBqpcHT7ivGmJ62vU6Ph2Pe+Pkj+rLA4J7Iopr90jNPzzlnp7fsFk6nyXdCAsn1HnPZDZjOpsTFytpnZtkrkMU7l4MgRwDMXSkGPBOqi9gTY8UYTJdlIL92QgVZUsdN+c8zjmqusbE2Jc1k9a7a1zpMMYQbipZoKKYig4QzyobTTbRkFMxALsOdncfcv2GowuBlOHsmTP9HEjNSkuKid2Huzx88IC93T2M1nWWKAN9PdXlcsnHH33M9tYWO9/4Rl/ybWxg9nKZyz2V17Q1cQyUzNge/XiCZ/1cZJcNDH/4Cff1/EaJAGWyGvm2X2OM1kw1mhinXaMkfBpZrTtChqSITtAqD2VvMUlpA8Yw00zrvrOf7MSAPi/WEhBEP8XIqu0IMeG9gAWVG3qUFyqNSbK5l2SkAmpkrXNqrRThz1bqZD58eF+anUw32N4WOpRzHusk6a5tW0LQDOVspFOWfp+cBow+xsSDBw/5g+99lwsXz4lxb2zPlDKUzoO9ndBvuClL1vZytZDSgjmXqVXONo8RpGcvu54NdvhDJ3/4OYyhiPzwt9WmHtZJk4RcqBVqFGZjpK6ysSRkTROldXkWJ6s0rDEZaxLeCN0kKeBgx20uR/WNpFZpKXspu+i6DYSYCUmaCE1qL3WDpUWmmAuqs1LOmlQKaOS0r7KShI8dQ2KV1jyID7lx4wbGwvbODrPpXJ8HMbBjjMSYoFLq4chx60eGGCQB8vf/4A/4I3/020eSe02xs0AfYPle0sjAYpFkVTGQpbBVb0f2xsaThe/zlts5Fd94Qu3ppzRQ1cssWYplk3/0bYzzVI0gfV1MdMslq+U+bDT47U0mVUXVVKTZhHUnBXbFS5FwqUMsfe+deALOMpvNWa5bJk3DcrES3lVGN3jBcupK/HJrhhIR5GFR+99H1n7JKM3a8aQLmYe7D7h2/SqlyPe2dVSVZHunjMD12RCiwPC3bt7k4f2H5HWiXa9ZrFa0IRBDpg2B995/j83tTTa2NqSF2fnzrMOK1bqUfxg4ZZRWazn1iSY5FfRUFP44I3qo7VY+f5KfMhqPSNzTQFWFVH06KpWBqlpz5cLVU497VkP1TP9jsmQTl5aGKYmB56uKejKhmUxZrjUpQs5ANoYQpX5jCh1taKXmLxp6IvetTg1ZnDLt6OG84yLCs7Zai9I6R+0cIXR0nZTcWa1WTKcNMSsyYGVzLwbCkZqPjH7vw0xiTUpCEqzXa+7evastJS1TLbUiXCUn7XpT4uDgkMVCiz9npRZkMxhCyWCd5eaNG2xuzHn7y1+mbjz9XZQagyWRIBePXLmmuYSOWypfDRt8f5x+laK5nrPsZraI/Nqpxz3PIRt11FagYgC061Y2u0I9str9STmjGFnXddfSxkzEEUKijUE6U+ncW2PwxuErT0wya6UA+XiLEZRJePNBuXNtF+i6gHOBuq4xTY030gVIqpMkrTBa5GYwUFGXLCfJ+M9ZWv0ul2vu3LnLbHoNY6Rj36QxYL0+O51219M76zffMWoiv+3v7/POO+/wh78tBlwpx9Nv1uYoSFDuKudEF6UpRmknWeo7kgqXTz/3nGXXsEXFHz/1uGcxhoY+5pHbNtYokupw3itQIOFoixXs2pZOig7jHKU1aMpa9SfRA96l7qjoEwM4jeKWCM1YFjR/xWq9UmQfEOM0EUMCJjS+UlqUfs7Jutus5SuxaKtBOY8xfVm1lBMkWKU1t27doqqk2oUzDjex5CglCEOIvf7rxUL/Hih8ct0uBL77/e/xla99mRCkG2LJpxkLVQ9iGHoKQNe2NE0jiWF6vt4By/rs2+crt54pZzk9Z+WpDVSpRmaARIpClh+/b5zBVhXVZEK7bqXDVFLCeUw8fPiAmTe42YTKWkhrJpXTPtEG6y3WKhytXyGmQLaSTOSsx/sG72umsw26rtOMtci6XcDGjMrZ0acHIRA1WHh4x1L4DIL25AwpEQLcunWL9XrNweE+b735Zc6ePSvCoQWkrfHkEPjkxg0+uX6dg/0DXPIqrBlbuhBh+c53vsPZc2c5d+4MZ3a2taXmSBiL635EGtQBiJJNmlIcnALVrKWAy9hoGS3Hib8/jhpwHFx+bLjVHPnnkWHXO0w++pOPeffZjiZCHYVrR8pay3AoGF64fNZL2bAQdGNHSnMYY8mmlDaj79TRhUDAEIOli4EUg2T1Rn06VJ6bpiEZ+nJixlpyjlgr9VdBCO3L5RoSWqw8M6lrLQnlivtENvRIlJxeX0tp4PpZSwryd9uuePAg0rYdk0Z6kjdNg3eyUYQgiYvrdSuGsXpIRhVXQZDB8uDBA65evcrHH3/Ml99+CyhGQQmHGUpdrKzWglATpBxLu15SSTyp3+TteP8wfDFklwOm9juPeff5jtLueKgpidSNNqaPWhnrsDYp0pJlg1ejNarzkqyhS5k25KEuI9LMIBFH7WlHzlHvgOTyRv9ememuE6Oxi6KnZhOrLStlMw0k5aPKLjIsUdHRVuUOshUKwnrR8cH7H2KBK1eu4M+eZ1I1kJKWMutIatjC49d13bbcuX2HH/3oR5y7eLbXo73azCV5L+GMlGgrIdEcE5ubm5IUnDTq0gtiiRyMhZQTf/+8ZbfFcOfTsfU+01H00HEEFXQPtgZnLL6qpLFOcliTqZwlpE4So7zUU3dtEHQcSgFq4WgagzQ/gRQzLlhCVKfKV1TOSQUVA5TkoJy12opQAUBqpMcYVa9LkvTGfM6sqagr1++5UrYvq60atXWvIL3WWmKUMpRWncGUEnt7B1z7+BrtuqPrAi9fuYJJmdVqLVVgjGPcma03AUb/Zv3f7Ts3+fCjD5lOJ/0Bg2EuTqJ0U809SJBzhpjE4C7UMDIph8G+Gpscz0luH7LJb/BH+Kcf8z58Sg7q4P1YRWbA1xWT2ZSN7S1W9/eIsSVnabWFteTshUcSIyYFFqsF4LDC1pemOznT5Y522RK6wKpdY5uGS5cuSUvKqlIvTEKmEiZt6VaB5XJNqj21d+KJAQmHLZYpjFAe6L0KCvHZkJLBORHM+/fvSfmhgwO++Y1vMZ/PtQ+6JWsk4f6DXfb3F6RQDEZ6LokY8FIj9p3v/wBy4s/8mT+NMRIuGO/LfZkWdYUkMCaJJil0mDwQs/uHP2V4urrRz2yk1zdZ/Jv/ted9GycOm4T7ZlImxURMsedChRhpQyBhJdTkhlJmxiYJ5VvDOgQeHhwQkjhWQesvFpFyqqi8d/gshiAmaTZqpvCIUWVZWlGGlFiupVTOcrlmNqmZTCYSClM0SuhKQwhdFFXZZa2iumJcJgyhixzuHfL97/6A0AYuXrrI1uYmxhlCu6JrJXrRS24+isdnEOcoZ27fvsOv//qv88abrwnvC0EgSr2W4gxKsgo9Ulr6WI8VlM5qD50et0+f13jAHn+b3+KvPe8becwoG09B7F0lZW0qX4GthN/cdRg6SGtpUuIs9XRGdbgiGnXAtABJUooUXgzNLkiC0KRLYKRs4NEsZhljw9VYK3WrcybGRO5EDy+mLbNJw7SpqHVD9d5j3MCrLnUSDZBtJFtIIeNd1iiYPD8/fe+nHB4csnh5yRuvvUYOEYw4byFGal9Rck1kno7OmVwp8Tu/94/41re+yXQ6oZQ86jsJjVDdcedCm2FzNse70t430yehpNgbSs971Bxwnt993rfRD8MJBqqW2LMWmrrGudIUMeHpMDGD8RhbUdUN6WA16DRTAuri2Nsie21LmyIpZnK2OFtx7uw5QoxS0WHdEkLqS4UZEKfNFMhKwvuRhM2JsLvPelozaSpqJzV1U8p4Z9B+J33ESmRF0N6UjerFQviH/YOIqxxV7Tl7ZofUBslT8R7nnSTo2nJS0+t0C8SsOKS2pv693/tHvPbaq1y6dFH2IgTh72PYqdgyihAnqOtakse0ViyoA1G6U/bowPMbjg0m6dunHvPpsvhRQ0kNPvHepTDuYrECPMYEQYGSWF5m1AJRyPtrugTJWEJOhBjFPgvSPafA5hMrhm1G0B9RcuKRO2vBezorxXBDp15WjDRNQ11bHFYcMCPlVUgFZQBnFCkrWYVGkp2yIqHtes29u/f48Y9/zKuvvsr29jaTZkKXOkJoxbA1qrKS9o4u6GdGUInsuHv3Lh9++CEfXf2Yza15D8nTw+yKTosF3beJFcSuJZPkoUylBpyiZwx68wiH5SRU9RF3KT96zIk83ZMR2vFGUCI652PLX1rceLzgPOPxSCkk6L3JwlUr9Tutc1TVkM1PTpgcyCGAdZiqwbglYHB1Q2gDkUxMpYyZ1nXIiRwNIUl5nqau8JUfhePpJ88qOpvIxJzpQqLLYizPushk0giPyBqMLZimiIyIShRuFRqpsOATfaJgSJHDw0M+/vBD1qslFy9d4vzZ84rMq6EeI9b4viaGEA1yv8YpZ9Zdy70H9/ju97+rEQcEvcvjzb3Mt+lpCpV1bM7m8pzqcb0RrLxuCSc8f9mdk/hGWvJFHrkHBkY1GtWwclUtTU9yR1xnpKWsxbsKSeENJGkDqGaWeBGiowVNCjkSgiBCKWS2t7ep6lo2/PVa+dlDW13ntBKw6s+UxUE6XK4IIdJ2ns1Zg2gnQSclEUUapgDqsIsDaZ2BZHqZBghRIgLtekUIHbHVNqSKJsesSVcZddgU3U2llFUkxcC9e3e4evUqFy9dYHNrk54Tq+0Y+8hb3+dR0MDZbNajgmVYlX2TklAp+vF8ZLfjgDs8f/R/3N1o7HkOzAvZ60LMYBTsKehm9mAsqed36pomqZYXMn0CERi8FT0dZcvsHacudFoTusE6T+giB11UTivK0/SS5AyUij5RbZnlqiXGQJpUdF1iMq2pvMElicYVLmjR96VyHtmSjdAMjYIUs+mE+XyG94LyrtcreY5ihLpmaHotQ9JKjcgtQj0wMXP3/gO2trfY3N5kOpn0AIrp9anYRhra0jnPj8itUdEuK/GIbD5jua24wwXzfwb+uyecR8apBupQrPbYLcgqjBBJUSogis4YJwapGR9rS2EzwNB2HesEMVtCEn5GBkzp9a3fwmtBX0zhp9geiTLQF7vPMWoWZ6Jbt3QpM0lQV5XwXqxySRieH9tvruVVMYpN1tIWMbJarrh98xZ1VZFiZHt7h0k9IYZO+YzjB/Aocg4FReq4e/ceP/zhD/nGN39RNxl6g7SvYZsH6L4YoaSk3S/6Vek3+yJkT8f6ePpxomH3FKM+dFz6/U34739GN/JzjKOIc1Eq+nBkekeiD5Ebg6s8lSpNciLHlpzWEuo3DmM91nmSc32iUlFyWKvolpT26DrJlnTOMWkmzGczQow96tn/d6REUpawVUiBnCEkaGKiqSomeo8lOYtY7l8yoUu+XIzivGXjtLxTZHf3IZNpw2w2Y3tzG6kcLSZASlKDSuz2weCROZR5TDGxWC1598c/4tVXX9GGFbqp93LIaBMSZemdYzKZYHpkYRDynNNnJq/j8Wll17LNBv/1z/huPuORszoWysfLUkMyJnAekSWU80wmW6colNBVsm7ywh22iqFYrBNJjmlIuCudmZxzkqBkLF2ndBalDljnFSsrNVL0PDGz1uiZtVJnFSy5clSevgNVWaohqW54Tq12dnLOUVWVtNBOWh4wdD29BVQDajZ40eY4gy1zYWucd6zWK7rQPaIxc/+fR0dVVZyoWR9z/M8zPq3sNmzzBn/qM76bz3YU+o/UMI1a6UTf08hV4bQLl9pqJ9Dc77FSJCn3aGxrEC616pWcM/cfPKDyVV+o31rLRMPjQZMKrXFYldneMTciPTEl2pBwIRJWS02ElXJUmTxUHSj/K1EjityKPSItVhvqqhoQX43a1XVN5SupHhAz1sg+cbBYiXNopHxVPanJJKbTmmYy0blSA1R/Tzlrvffc21tm5BwM8z8YrkXKnre90GB51WycesypBuqY43b8hmRORobSyHA2zmGcl24gWjeUHIX/4TyQaGMkJDFOQ8q0UQjyDjt0izCGLkr43Vkn8LjTTk4MGs5Zra1mZINeh8g6BLqQmE4mIijeCkcrS2kKa1AkoCg68e5SSpgEJXyTY2R3d1fatEoGAf7MOek0orykrIkFMg2D0swMpU/29vf4wQ9+wJWXLhFCYGg0oOhX4QGq9y9kfO2QoZzFITlttNmj7sgJ4naUHnX8/SOu1JPHsePGIlGehbiYsP/DL0ah/iOoXi/DwywU0M72tUUlC9RLwTggkQOE4ClJUbIpV0Ss1u8rXviQiRz1x9sO6zw5Z+qqZnNjg1Xb0q6lfd+Qke3UubNiICIO2LoNdDGz7gKzScTaWpIHhcVPSZyjtGhUL1WUqKHQAUBQha5r6UJLjJ3wUBgU1oC+yxwNqXipn5uYEh9//DHnzp3FuQ3t/jYkKgzSb3qBsNoCOcXca83MMUVZHFiOitizll3LGSb5zz/lCZ/DKI97zCN+P5rhnKS+mVKbUIdKnBQQS0CoKDHRr6mssKH20skvx9IlTPTM4eEhXQhUdaP0Kk+MiRClmKlzHoPDqCtkFN2VyiiSNMgiUXvhwc6oBdHFDs5jUb0guhDRzZLU4vruaJPJpN98hRsozo83ntpXwgHMotPbLuGdJPn5ylNPaqrK0kwmfd3LwQkbdKkhDxu8jnL8OLFFdp+Rfjm+VM9Ydje4wLf4557yhM9+lCk2+rsk9kXZ47Oi+VnmzahcQUnY1D0vKefdCN3KeY915eSp/7l9+zbWeJrJlMl0ymw21WShii4Eqf6T5Dq2vynAlgYpAhSEBIfLFZVyUm1diV1ibVFZ9JxbJDnJWacVW3x/TWcHIM05y2w2JecdKluzvb0NWUq4eV9z+869Xhc204az586QTGLaVMymE7yXcL3kopi+AYIaLAwlnwYdW/SGACfHFuaY7D5rua3Z4iX+iVNP80QE9fjJ5e+hZEO5GVksCfXXXsJNKUmotBRfNNYpHcBinZRAiDGTQ4JkCbHV/rUSBkgpglmDsUymNVvb2yyWS0FbM4Im6D167wkxKB1DkYXlmnUXqFdrZtMJmzNR1N45vFePKI2QNpOlR3ASfqAgETIP9+/d0zpjho3ZjKrUCbSWLna9IJYHi1wQKgk1taFjd2+Xd955h5devoKvvC6WcGEKLUDKWXkNhwn60NT1eFWQzMexJ9Uv2GiNnkaSyjmGY4fUB3PsqCfL5vLClPf+e196iut+/qPrOt1s3UDcHxmpOWcpJJ8hZ0tMEAkYV0EunrDH+QpcJbxr7R0ldfmsviaogHeenAWdyZoZagzs7x/QrluMcdR1zWQyY3F4SFqtSF3Qu3W60ctmT0ZCPDERYqsZ+ZnaW+qqoq78EG4qRqXJpBzJAUFZjcE5ydyfTBo2NzfY3JjjrPBHW82ELgZ6ztJOkGzImhnuXdVzpqy3zGeNGuBRm0cc9Y3E7hEHC7VJi+Gu8TVKAlVKacR5Nb3sZp6P7J7jkL/Ad5/ius9vFFAgxSQ1TLMFpWokG6XCCKUckqypq8SpNzmQY+p1jMWSNNmunjSsVwuFqbR/t818cvsTdh/u433N5vY2586dY7YxZzKdEkKUc9saa5Jct+CprnhLUnotJzF22dliNp1gjcMYoTCP2+RCqeZiqbyjqhum02nfvtICxlvOnTvDbDolpURlK1595VWsdXRtx+Hhgt3DJSEGptMJk9mEetJgLVRO9DdksskS/s9K6VG96vogXx4QsrExW6JeSUKsMnL5/3OR3cQ91uY/B/7MU1z72Q+ptyv7ujNenCvJbEKQ/kK10uSnlCQiGoXCkYqj7AxqzoIxVHVFTCsoYfrUsVytWCxbwOC9Zzabc/7cObY3tmiaKU1jOTw40KYnsSyaghhgcDgr0bS6aVitWmaTCc5VQsQz9A3ErBUdaZB92juPryucq5g2Dd65/pnw3nH+/DnOnDmDNY7ZdM75s+eYTKZCLViu+OTWXZbLJYvlAussZ86fUZ2qjpPOVSBgsiflSEodhgqTg9hZKSoAYZSbmiEnAQnqQT57x6yYcM9BbgNTHpivnHrMz1BmajRyxiR6HqV4N+hGJ8dKprLcbiYRcyBbSzZeZK2qJfsuZinGaxIQhSiaAaT+WdlEpchty8WLF9nb36fTDLkuSwkK69wIKZBs/kgmhkyILW0XMGaOIVF7L9xAB47Ue/HFe04ZSZgymhmLo649s+mE2XSC84bQtaxXq76IdMnoNAVxkseKbDLWCSq3aluu3bjO2QtnmWuDASvfmt50Moah1bmhqio2NjZ02oelF75jFmPkCzIe3L3O3/mb/y7/1l/+G8/7VrQnfCRGK44OBawTI0wy9xXJDFLcu02ZurH9s21yonKeDOrUVDjrIWSy1C9nXOi7aipIUucupo6UA4eLA27fvsvu7j6TyYSds+eYTafUzZTptMVXNd5UEo7s+YHgRi5ISom9gwU5BrY3NzizvYV1lSpJVZYM2dXOSsTBeWlBPJ/Nqata60BKJuvO9hazyZS6aZjWEy5evMC0mWlL3gesQ6QNHTs728zmMyKJ2kHTVOJEGqnHm42RZhfaSs+CNhYQC9VaeRZyikStt2qsY7FeMK9qrH3+2ccAH1DxPzdn+f3nfSNPMUqpmIGHKqiUVQ48MZJM7rPycymtFqXQOSCIkYGk6fzeOan3myMZqVixWq04ODwkpgW7+wfcvn2H7a1tNuebzOZzXLZ9SNPqtVLOve43SP+LylvWpnS7sVhLH8US1DJLIXfAKy3G1xVNM6X2XspWQX+Ny1euYI2lqmumzYzN+QaVr9nbP+CTm7fZPHeeW7du4WvfG+gKypFtHmpYGiuRsCzzkmIL0sNIkWij5biyRs8kROuNYbVe47RFbPmuz2tELrBrvrgIaqE+jSOyBe0uJciyzRhlAZKkzGIcdfwa8DDhMoeYmTQTFl1LthlcwlamL0GGcaSQiHuHrJYrPjG3mE7nbG1tM51MSJJFiNQMzhhnyTarDAqFYLYxx+Qs3dSsxxJV3oWC4qyh8gJmOee00pBjOpmJsWodlaKpMUZ2zjSAoK3NZMpkNsVbTwiJbBz1pCGkSFodSgUj+bb9PJbGQ2JraQveLNVpBuR0OD7EiAvSGjXESD2Z4BD7C81peJ5yu4vhNzD8t0855ql2h750AWWDF6vcZPEiY4jEkDQ7OhFDxPuRlW3AWS9CYJwS9CVUnyhVATLJWJIih1IdIWnh8Mjy8JC7d+9irMN5KXruqgrbOroYJTO1FdPNKrqlZqMqmMxiscKaTPBSr3J7c9rTT/u2yqaUpJLELmelq0ozmTCZTKjrWmqNaQvSpqnxxjObzmjqhslkQgiRvYMFSZ425ptzqqYmpcDmfEpdeZRx0yNgOtP9z1Fyc+kgVcL8kqygizNC0o6OEdovh5pj7/VvnPTBkwTh6OHlFsvhabbH4S/+fx/z4Wc7YgqEFHBJGis4Rf3HxeJzzjjrtPA5Io86ryZnbE49p7NEDTKFp6cln6zBZyk30tQNyTqSaTGqlI2FEAMHhwv29g84OFyxubnBpJlQ1w0b801CF4XbVJD8LLLXO0454T1SrDplYkjYqhaFfsSjt311AO88vpJWlZX3mmWqBqy3vPzKy4ChqRumkxnbm5vUVcPe/gHrkNh0jlu3bgkvt67wZCqhhvWKUgLEJVlK6P1G0f0i36URRimRZDFUjaVtV8x61HTggpXxrGV3zQHXzHce8+HnM0rFDmutdrIBGKJGfRJEkbWs1A5FR4wVPRZDUOOTgR5ltSRfFoqS854U2r5osHNOOk6pkRBCIsU1Oe5yeLCkrhsm06kkTkk7HQm9YigRNamSAdY5ptOZdP/zNU57jQp3WvnfTmpKOmPw3lA56QBUOac5CVbr+Sa8ayQUrE5Yb2yrrFVeql+gz62zRvYqq4FQXXRLUhghDfJwJBaZhTeYwiAo0VBZKw0okhSOPy5yz1p2r9Px181N/tJjPv48RymFlJTSVpyMrLF0WQFZm/J9hK4xJrKJTFnnsFGVT8r4SaW0ANNXEEmaQJ2gr5uauoQlkNKCECLTyZyoSaWi+a383xaASS7hrMM7S13V4nSlTE9nKYiroU/edt5SV56qtlSVFxpUAQ2cw3qpp16oASWcH1MkxCD2jB8SamWvMv0sZArP21CIWGPrQadJj1fdoJZ9CB3ZGTV3hNT7vOW24z638v8L+NOPOcGTQvyUEGbSzkf5yGzIFyrepQRhRJlpdnFRBAZtR0cPUzrryamlNEUS9FHbnznhRNGCIKKJtms5ODxgtWyppxNmigo555lOZxKyidCi184jLxgxSpLea06yUZrNDUzPd9Uwg4YbRGl65b16mrqR8lZWez9by86ZHTVMJ2xubLG5IYbHcrXm7r0HZGdZLBZsn9lmNp+ScpROWoVH2M9y+UseADuSlD40naVFm9Akcp9AZawbLUn5ro9d0GGYxx15/LWnL7zrsuVMOzn1uGc1pG1nh3OGqG3gBr7piIvKKMSYCy+5JNBJN6SxAyCc47KxFdRbPieIuyiunEVujSm8OEX8u0TXSX3SSTNlPp9TEgJEeVm9RdOXtzLZShvVWvtHO6GfSCu/8pWy9BpX9NQ74Ww32m7PGSmCIrJn2DmzgzVyzGQykzCWrajbQD1pcFXdO44YcRqL4s4m92FQMdQLB0yR02MaTJC7kvQX9TzpyDHPW3ZrEi+xPvW4ZzWOJPiNfuQ9ejV8NEtXKUJ9RQTZmAz06FWJUI8ns5QDc84TndZoVrkTAEG3xaxAwrpl3QbscsW0bWnqaS8jR3Yg/bvwmZ0Tg9JaK6HIsrmKKpU9QoupW2epKqmq4b3Ha2dBq8lWzgocKgawbOYxC/Uk5ahtNHP/HB2xOZGwpimyrOH9oUvakEWAGRyAMvF9yR431EgulsHzkt1gHrDL/xv4Z0899nmM0vijr54zMrnIhe+cRnNUEFZxfHIh1xt1wAuinRLON70MGKsperms67A2UYnyUkoQsnHgbF9FpazJ+N6SttQzfpycrRUfzMCTLgaq0BYllO+9JPZJOcyRkdrnG5jBUKckZnV0MWjrVKm728thFkrK8GwrSNUrA1OmqBeXHtywcr0Y9LlQnV7oKY8Dt8ql+/E5yG1iReCDU487PUlK/xdSp5mTUoLEaHZcjEMBeWetci40o94MBGIRxlLaR7xzXzpFpAxJJlhC5Um8DeUOFk5UJtGGljv37oF1TCdTtre2OXNmh6ZpwBraVcCatlfaVgutF+PDe0sKgZSkL25pj1Y8eWell28pYeW19FBTT7TdXuFOSSLXK6+8grOO6XTKxsYWZ7a2scaxt3dAPZkSgWvXrin3cIJVdEKjzGAyySQJZZRNPkvoQI6zg4LNiXbdaeF3TzSa4Z/toG1PkpmxF3Tc8ymvH5OlT1t4d7bY4evv/KnHvPtsx2q1YrVeofoArHRyGnppG1GazvQoJJi+K1TJkDTKMxWjSnnRKRb8VF83KOaON46oVSVK913hXGbIhhAiBweHHB4ucXaPyXTK1tYZ7Yom55Ebyn03KYuElapqwmQqSX+SLFhQKOVDeSsolLN4Z/HeMqkbvNJJpPyJPPJWS18VZZkKtw60k4uVcNNIkaWRxz6oyuJh9rMqJslQCZ4Ug1yrNJ0wGV/73pAxBnp79TnJ7jZT/nT+YiX4yRi1Aj1yEBIVGH1GfRx0BSTjfmzAoktV0B9kw41J64mqpWidlHXoAQr6DyJodyJHWLcdGEHnjTWKWuZ+c8RIX3QJYSatu1vKNOUBfTIi30YTm1xl8bWlrqW7lVdDtSBPw0ave4Y6hCmnvuQbaNnAkshnigE/OJYDojwgTvaYQFknUYlivDgrKFQ1qftn6ETZfIaye4a7/Dn+JvDvP+aIZzeOcxmlK50mAZvSJmf0wCsIUAwsawUkEofK9orGqF4LWmIsRkkuMip7vbOQS/IQcj0tkZOUcpSM1O7NIei1DMaBw2l/e5H7EMHkQOWUQ58L/1TAAldoKiW8X5wob/qa7XVVU1VV70iKraGovurv3kDtOg4OD3sQxYwMWMbOfJHvEkktFYGK49WvQR6eMSMViQz0JTRzTieXUX+GcuuAreNAxbFxuoGaA+t2SUod7WrZt9vy3uO8pwujMDPy0BeVWTLwDAabpcZeRls+WskKzilIWGYkhAYDkiBNVTvIgRBaQuik40MXgEC77jg4OOT27VvMZ5vsnD2DVPtxw7mcVSNZFE/lHa4S7l7tRUjIGVdQVCvcWW+t8Eo0hDSdTqmdl8QoTY4Cx9lz017Y6roWo9dl2hyJyLnEqz+6CLkUMzVQEqRKeDQrB8oUQ7aESHOi69ZUTYUnkZMiH6cu77Md25fP8Mf/h3/2ed8GALfu3cJPPGe2t5nPZ1T1DOe9KDIz4NZGs4WNtSQCKPJuyH1nJZAIgElZHZysXZ00+x5RhDmJc1X5ijZ2OC/8VbFpJQEP0F73Sbmq4qAUL93aUo4t90o3G6kHKckAeeTxZvWSR968yrJzhqryVNXQ2KIoVGMMXkl5thitRoznddux7jrmk6ZHgMXbj4+GdsjDjxq4BUjr8Qstx2WtFUdUXmU2nfYowhdhbLPDP8F/83nfxiOjR9PHk6rDe993itFCTcLryxGjtcPKuoPIICCveylBlbpA1yamTa1leRy2spjC2eTYsmcpYZatBeskmVXpB9bJHiCVrDXakDOx7XAmM5/F/lzF4CgbfSkn5b3w+Kx3fUKT856qqY8kO5afqhKAASRJMMSWxUJCufJwGAKyOUs/mNyjYKJ+1YCyxZNlNM+itwe0a8jqFzrNF0N+Z/l13o5/9XnfBkDvQEhnu6zUktQ7UN5LaTKUjlIMK2BET5LWzMUISxkq76nrhjZEYtdBNtodzzM4JAVUUAcEQ9S9N0dJ1crJYI1nsVyAA+cN3nipPKT3krU0JDnijXaQNHJGS+6R/mIL9Q2EKuE89xxr7xQUKY6VpXSgEidOHLaUA11Y8/DhQzY3N3s5T70zhTxVY7mFkdod9rLBQRCjVAIBqvetUgXVSH4apPPzHNss+GPmR6cec6qBuru7y927d6mcI4ZOwpFaYLfw3YDeqpdFU6UUByMLkKLGlPClFMEPMUqPXUZKOEvPe5clQahdr7HGkiJ0rdSYTIiQ55BJMdC2uxwuVzT1REpUGKnRN9gPwunLQEiJyhms8zhfk0LsN1XX/wybfFN57dFr+/CuU6EroaYeSbNWubhiXEg4QYW1ZLbSsxcHNCoHRrV6gCTtJ0vWcxTHoG1bptqi0yvC3DsEJo88nrIu49XMR98rfx8Ba04S1hPONXyV/mMGuGXf5/84/Z/yL3wBikbP53NNkoqKligCpI5TzzXFDI5R4T1lRUhzxJksFqV66tYM+KFBlYL1xK4jhEztHVVdETo7IFhGA+AZhORfyqQ5nK1IqgSN9i0XJ1qxBlVCKUVyjISmkrCrQYxpq2F9ZxU5lWQuX3lBoRoxUAYUfzCE+2ocClRkI1UDDg8P6GP6xqjpU9o8DhuARWW8R+8G+Smh5BgFOS6tZY1z5F7+C01IDKwjCvNZyy4r/iPz/hcwSCqjn6dCuwBFEvUL9ap4KEMnrXy1WkiPYgE4qTqBoW07QorMNzZIYYUxUhm9j33lpAklwqdHnTajZOSUkpTuMRlXO5qmwmvIMacScchgxD3zXgwBn9KRWqdimNbqUImTZ7QrYEGDMGAr22+2wjVMg+Hqpaf73fv3BQDRvro99lu4uwiQOo7eFwpDibZlhaPbtqOaNP05rJXWyKXw8Iko0zOW3QrPJXP2hHM8+yGh7lKCTuhMUfvPj3n8ZT1NNsTY4SaNGv9lXgs5BCBrXotQ7mIIkLNS/GwRUyyCSmIHorzoaNG5MXcYddpiiqSYCNGSkKx9tRaVwpU1QU6+U1VVpBAkUcra3qkqBqdzAto5hVflOxbaE5KP5XSpFc3NVqXKSrTaGDhYHACZpi4doBTWUO6CtWbQk1noY1L1CMhCB8tada60a7X6jGUFVYqpYbLYDcUWedZye5O3+Q/49/nLp8jTqQZqIev2HCa97mBY5X5zMorGyMYahYybs3D5oG8JafobLsk+ZWsy+KoidGtikqQR5yvyslj8AhXJOsnvpZCvNZkQIzZE0YVGIX8zSkHKkbYTI4BsqauirAqfpED2SmFwkozlK4tXpSiIVNVv8M4W0rOEjwtftw0ti+WCqm7kPmwxSgux2fT/jtGnvoxJWURd65TyiFKhXnw+RqEYRGM0TtKeTx6PlJx45DTHrpgBk9kyjl97QuHdZzU2NzfZ2NiQWomKZMo4+gAZjhlKPWp69Ev36KYxQ090pYZUVUVoO+Xy1XiTWZlR7Tk9b9JIQ+4fhKzy67REWpBCFjiqWu/KKBIVIwlFbzUEJBSVQXbFi6+lMYX+mCLThSelG0gxUCXslfFW+YokuthxuFwwhHjFRC2kfPLwXBm1vgv3q1AZxBkoc6d0BKuhqxEK3MvvI8L7bGW3IfOmOT3c9EUZfemjE8GPfASRGhAXEcRcnAFDj553bUvla82k7/QUJQRetBWUCwrnU5w4p3IecyJpnUg8vVOYU9KON+LSWGMlCVDlsm8EYJ06WSK31kkUoTe4dVctur3QyeWLovt1JqRI261pQysbNHlA8UfTY3ISQ6LUsS4OGUUn0O9TYzWtDzCjWzp5DT71up52mpNlN5C4b74Y/OmCFtpiB6RU2On9+72to7oxdh05VYOjpYcY5WKSxdFJKap8eGLoyEBVCfI/bKODUVt2XFMcD6W2OCe5LuJEiRHtWqWO6I2Ve+upAhrZEn0rYICU1XQj2S3Ov36HIrM9gjlG/xmSc0GeH61c5J3q/Sy0Pzu2Y7R7WW+bKdjRN1gZAShFRxilIcQYMc4PevuR8WzldpMVv8ZHp577VAO1rmslqVtKVLo8sMVYLUjU8ZvN+t8hG2/gqpUFKgIlIUApSB+7tdT1M4aq9v0mV5CunKVMTgkRyHKIh5+KB6TZxdZZrRcoAhBjwmQpG5VS6jvzjMOihVNincd6L6Emb5Xj5/FV1T+ExYs3xva90rPJhNixWC2YjJyOrMleGiEalCAjo6hf2EFZDkLIEU6JUcMYMxx7XOY+08K7x44dPwfltidLx5d/ss0XIVI6n8/Z3t5mOmnw1tEl3Xz0GRYRMgOKWB7ysaunWs9QyuJIBEDq+5aN3vQh8pSkxq51ujYjx2MwfHW+shp+iizmLElwmUyywn3DFoWuYdQSbSiGZrZYq0hZryi1WLSGl0aW5NBZVBH9/nsXOkFW+U2BsF6JUzkyUcvNF+8bK3LYl9sbK0oGA6KEmIvMxxAxpQxdf/hRQXzWslthOcvsZzjhsx2yT6qB38+XuhA5HzEkpe5smSPT6wyBTACSJpl46qqmXS962TG5ZOXr5qzn6L0Io00hVKtZLRyak1CRCg2sn2OlzKQsD52zDpJQEMZyW57DUge1UFbGe82wwY9Bi/KvgCBd6AgxEGKQTG1NwCmoTe+I9obmaI8q83RslJlWmBXjRtGvY8fBs5fdJQt+wg9/hhN+fqOfP9O/ABydpz4KYARgCqEjjnioZXKNVc5qEmOtbVusr6h8Reg6YkjiVJWGKcVAHS+0PhPGoEmnFle5IRyuTkjXBagMo8vL3gtgRE6zlkgTHWt7w7QYrL3cDpmrYIZkxiLfw3uqfxEjuQtSLSI7acwje0OZtP6biMwyAFoFGBtP+3G7yTmpE9xM6tEaPV+dO+Ehb/L34BQM9VQSzWw2YzqdMp/Nmc/n/YKWIaH82G/W5Ny36uwhFSDnwl/L/YI5hd2TpvFbKwYxRgt556Ro7IDIyLlUYemGnzDSRxenNRkz67aj1VakxWgEqQvWBaEVACOvZ+CUCBeq1vZ6stEX8r51AyHaOIP18mMcZJPAJbIVdGHdrlksF5JoormwPQqVpY6sTfog9AiUfE9rBKYv31mI5srfKYbPaP2PGrpDKOuIdXLiENWf+9848lt/VDFu+lE0yPj0hvXNyNX/8MFjrvVsx2w+5/z582xtbeOrSjegrEkggtKAGnuKRI47bwhCUhRpMWTL2XNvCBhFUJ1Xp8e63rETo9cMM9q3EtU51SRE6wS5DFFqqHZdR9sGuiDy2sWkDSigyEdBQIfuJcWbt5pJquEmRe9zEbKxsapcb03s11CTdCZq27WgZEmSFMu3MEeMbvliBSXBSMasKMVhLbLyrK0xmAyr5XLsgulBw3nR7/ksZXdBzbtceMy1vhhDOvRJ7cYBsdboVum4EyMpRt3wyy5levS6hFGlbWlmMp1oK8kkFBFNqJPEa020KIYwo3aUGsatao/zVv42hpCkW08ISbnzub9X4etXWu3Cj+R20MF94ooZUVEUHSnUqiMbbG+kSl7DarWi6zqVJ+WXHmstXcZxf1QM1fFeo58zg0GQYuwRLTmI5y67++Yuv23+r48Tm+c6+koTI4VQZDUlsR9CCNqGNINW/rRaLacARpBZrpZ4LwX0czYsl0sxUK3TROshO97AgFJqGbKChFZ1TdPUNJNauow1tSYPyZqnFHrZFQS11DmVFu52pHN7G6Kv6mB6lF//kuTxXm6P/hgjNUoXy8XAnS57RC4RK6B/jozWaS8bwhDllg5THBM73TWMYblYDOfs3xvL3bPWuXf5IX/zMdeScSqCurGxwcbGBpX3hHbNYrGA/qFWDwjdABkUZoxReiGb8nWGf0tLMGO0Y41WmAihhFErcmqx1rExnxPWc91oh/aLwqXQsFPOUrKKiJH0IbooodJsDElrQJqibPuFlg0+o0XNXQk3Vf0GL3woKR8hk55FWdkSZj3iKOGsI5igeFNmHVo1QEXojcmUFqpjdyKODJCsQmyOa09KoevRS0kyvXsZeM5jxzX8N6avPe/bGMYI5Qa07azMb1c2+GKpaZKT6YlCum6x7b1QWWvdqnUTDyGwXq+Zzebs7+4CAx3EVfWRjX7wB8WdTEYNZA3H++x6fmlIHTkoOsqIn6mok8NgbNUjqBImLcpSi0n3G79kZ2dNAjTKWT3iyWtptq5r2dt9wGS6gZdegsKBdnr9Yw5qvylrR6Ou7Y4pp+HYslFZI/xVUziR5vmLrzORDQ6f812cPkKWhNJsXN9THArlBMiJ0K2xuaN2lUablA5iLc5mdEVpuzWu8mzUW4BhuVyRs5EGKkX1jHc7UzS4vJQB4yw7OztszDZYdx1tbOlrW8dODOWc+ucH5SCTJLLljHbsU5DA+YF+UgxX4ayCzVA70e/lGbbaAhtrFImLtOuWxcGSuip1K9G20apfrXyXkk8+gsuEkxg0qXWM+By1YocIVnnpc1jrn2Vs5iv8sfg/es53cfIwRiKe0twoI9HLqJFXQ45DVjoFxtGkKqH+O2onSckYSZaqPEwnNd26ZWtjhreQsyVncYBySApaZY4vUjYSqb1y5TIhBroQWLct2Ui+QtdJpBXtFGYcgpj3eTdZEqiNUT0r+nbgUWuVFGN7GZHW02hdVqXXeNlniu1kEAMytB2N38YZKwnQJUBth8+WeZVEJ2nwErpIiPFIRLtEp42RetzCu9bsgWwHxBqeiwKesM0b/JOnHnN6HdTinfalQOyo85OQi0Mute4lS25UxVuGfvEcxPN0iqLI+yV0bUgxsl6tqauKNkkLSF9VfaH8QR2oYtHJzWZI4nC1x2HoQiAgmXEpx77LQ+HDxiy9op31WOO0K4Qowx6Z8lbCpLaUN5G5KGGg3psvGLzSBTBSg3Nvf4/ZdKM3jvJYGnJ5EI0YDiXEpEoy5ayK9MgU4r1ntVpBNsw3zxxZq5E+LRdRAv+xk5y64MMmdEKk69jZj14b4MblNf/ev3idP/EUl/q8h7HS5aXySpxfdVjrsVbayIaQ1HAs9SGNoNZWDNOYg9T+DUEUlp4TJ0iqs7YvDN62LWfOnGP/4Z70LveeqpogxfYVngSyiVKDD5ReII+L856dnW1FFALr0NGzlnMmh07oKRpSH4djiwcvPwPPtEemjO+5yjZLl5SiLKU4thgOOmvEmFmtWlI8pK68crTLBtIfJiPTU39AvPgQSum5AiypkWAz5XnvqQWM7IMjq/cpZPdnGCfJbp3v8FL+T4B//rO92KcYQzjQHvk9Z+maFzV5A1PQE5RipIk+/Tcsm37WaFWmqidkIr5yfQmyzfmcFDKTasK0qbDJQdZWz6YU92aQE2N629U5h5tIM4cu1iyWCyazhtXhgmVY9npP5ESbOTipilFKCg1c1FGESjdfQZlUVi1SLaPM04gzk5M4+l0btItc0ARJicIVRI2RaWmyweGIGXUkxeEsNJU+UbFkKsqHytUfY5k+e9k1HFB9gXqgHUG5YUCXM71jn9VgLVHY8fviVECOUonBOU9dVfiqErqh82xvb9MtD+R1Z7C2kudgdF2hH40RcwWYTCJGKfvkXSb0RfQF3Y3agtooUGRLVR1rcSaN/HozgAKjDHqjyVrOGXwllK+cjhSL6gGHmCCGRLcOfUJZDJsqtxItzUbvRWsmitErXG7RwR7nKt1rRoYD9HtMRBMftUyiPMvjAPqzl9uOHW7n0/mAT+wk5QrvMidWqzXFHM2quMSjzVqIv6CaDMaO3lkMLTkLx8uMEcR+IhLrds3GxlyPLQJrtd6Z0/OPZk4FpfCQmqbCuwpvHeu4JqRO0RlDzlHCjyU0iRoc1oqHYcrmbkZ8w/EmMSBx41CT0S9UDFVjpbzDarnEZMt00gyAaV90WI3dXskVKH8cJnp0GGM0M3Y4vuzyeZjY3mB4ZDwiJePjH4cEPH3hXVtvMLv8rVOPe1bDWKMOhtJE0OQyowZoX0Fi7E3lvgi/SRli1vkeDFSrPeid88rRFIOwbippdapr20wm9IlsPQFngAqL3BaOp/M1tbXkXMNKsqlzzoQoHn5/f3q/xknZpuPK0o6M1MI7HJR2Hp6H8mf/d+4NyhgTHR3euRGSRn/jfVG5Ydcf5Bujhv+AsJZatNmMAqh9yKBsHD+f7HLCXz+L7AaW3M9fHB7fSUZqTlKMvhSkt70+iLJBllBzkRGjDkJxFlLGZqic72tZkxMb8zklQ13K9rjeWAD6TbLX6aMlL7zTpM0wjEV4rX5I2smZXs5TjngNhWZ9HIT/b4/I7bBHZOVMW4qf1IMC5eSl546xlNa5KSqqPII2dHaRxJmyeRQDVnmGI8cKlG+u/OwS3Sid6Mo+1z9e/XN+bHzOstsCN/sids9vlCjJkCNRwBd90DUCmbS+suzLGprWPU2a5NhhL7SSK1LK4qWYqCrDxnzGQViLs64JywOTI0NZ337uh3vJCA0Qra+ecsKbmr66Spn5oq7L7Rdlq++5gvqPonR6B2SSVPDR4v1dKAmyBYiKfaUUa6Uzpin3WCpuMNxORn2jrNHcLEWvSsTOlO5bat8MalmfvJRwthqeq6IXThOvz11uAzd5cOpxT8zid1rny+SoyQ7DIgk5VzPpyz0VQ1W90IRk8pdC/8WQMna4htUOUilHmklDu1qSuo6UMt55rBPuZUmJGitJQLh01lLXFZNmSu0bmlizXC/0vInQtqScsHm4buE2FZ6KNYUHZY9mPffcLbls6QRVJrqcr/ydUqJdt5Ass0ndC7lRr5HeEzK9MI03kaNG6mA8mV5I1FsrttVxnViO+zm8oL622mPOcdLL83bCNz5569Nf9LMcRrimMHyXUn9OastK+LFsMEYTSPpSPDlT+nD3PFR1XHLOeOtIXpSEJCQZJtOJcFuNo2mm5DxybEZyB6pwNPSTVElabN/EohRyhswqDzJQFKokNfX2MFYTqoYEk+LRH90cjuhsin+kxrPc4RFFWbw5QRNGH+o1d4luDAZC24UefSu8vlw2d6M1ZUdy/WhPvU8vu+Nn52eR3ZaOW/nOp7voZzzGBmoxUgvKlFIkaFc/qw5O0kz5I5QL3VCLkUZS2c4ZbyuSgUwixo75fEa3XqhxoM1WxrXBKU59FuS/R8QyISeWqyUxRnHQyL38FaO26NmUpR02tR0lcWl9Ulf4g2NZUJkdJZ6Uc7ZtS9u2Uj5tugEa1arrun+uZC7VoDyC6MnlrfZ1H2RXkmMlkiHJi9I/3vZ5BPIAjTmt5UIMvzxz2XXcYOfTXfQzHMOeMcxBX62HQvWQ8kcyNA+lr4pCry+FT53UGRHDN8ZMCIEmN0wmDetFBZiRUdvfifoOg07rb8gohSp0rNs1kCUsX+myFgKllmoavsNA7SgmkFWqVKm1PrjXeTCG1YbqonC+1+u10mkyO2fO4XyF9xWTZqKUnUJvEKqMLaUnRv812rFTvs/IgVVwIWluxJCgLjZJXZdkgwwjWevn6Dno3DucrnNPrzSsnqtzDm81QQcVIpxY8VnBkD4sYvqbzjGRQqRrW7quI3QaVgWZZDMUuq2qhmnf736C8zU5ZzY2tjFGOCi270MRpb7diFGAlQBSNla4VRsb1N4zn83YmG0IRy7pg2KzFIgm6/cbJ0sVTsnYMNVwFKIzy6SlbEi5JMIYQkrELhGD8FhCCMSgWaRlk6YYBfJNDFIouHTViiFJAkOP9BbStV7cHBOC/rk4wVodv5SPW7L6d86PEdhjFzh2+kc+ljOzm/f5+n/wX5wqUs9q9N07oDesnPb1Ro3UpBt9QSDLfBQCfwkPlc2ZnIXLnMQpk9CTxzlDCIHpbCqtSI3Buapvm6qsH0EIRvM15gut2zX7hwc82N+li53Qa3RTLmVajDXkFAlde9SAMQZnwFe2R43HSAZG5Fx4T3K9npcbpb5qyZqyVuqoHs301LlRl7sXJ0qyjsVoU4t6MmFv/5D1uu3r0ILpw9LGDt2szKgQ9fOUXXWpMU/oavKsxnEDFYZi8SklYujkNVeiPWhrXt0U1bE44kinTOgiMWaMcaQoTnTbtmxubVDVkg0tm3PpNpNHekjvDXpRgAQm04XAcrXi4PCQLibWbTtskvo5p2h8iBGHOlLFuNA9ppfXbCFrGbRs+2exrM5iccgHH3zA7/7u7/LDd36kSVEG76p+/6ibRqMd5ekpbL9xxoRGAVWGsZbJdE5MmbbtVH7VQI2SxFhaq/aTMbJ9hsnmmcouTAl86THneT5jbDT1BiglJC6lIU3JJ8lSCkw+41Q/R40WJIqaTEk47iFoCN4aKdofwWhN3qM3cfzH9Cioq52Ug1ytaLtIF8PQUKdHSeX5KYlcfdWIfs8Yyg8a65Qu6BlqBOt312O7ruPDDz/kN3/zN/j1v/f3OTg47OXW+5rpdCpls7zVByxyLMOnT/juJdgY0M5/UW2QoM1kZN7VRktJk6zpP99P0ZEoGM9MbhNzDsy3HitD8BQh/nKywh+1Rlt9ugFVHLhlCV9KcEh/vL6GoymbnFhr6kALv8T7mqzZe23bMp/PYDYho5n9OffI5QBLm8HYALLJZJNZrhc8uL/LfGNGzpnGOW3/6Egxaq2zgiw49YKMhgnkO3nN2Cst9UwfQoJCKZQ6b7aH67MxGISz6l1NU0tRdKMp0kd1WREIJQKWItjabq/Vnu3GDN6ldRIO8c7jvCHlICWz+nDG06zk5ztSfp1V/ree920cHUba0lU+42yUOSt1kSjITpT5FDxKjNRCSkvC8yzOBECOidh22MrK9tcFVssl58+fo1utyF1L7StqV/fK01gL2pNeVls8WaOybZylDR37B/vMZzOk46kqXX10vJOya10Qw9o5jzFS1mfg7hlVkGWTlw0/RfGui8748IMPuHbtGvv7+/zKt36VV19/EzLUvmFjY1PQqUmlG3Ic0VQLxQeGSr5DuMlYy3Q+IwFdiKWeOd77I4ZzceS/AGILwKts8r/m28/7Np44soolCIJTOUPlJAkudIkYIiCVF2xvIATpUW+yUluE00yWbj/LxZKu7TDW0HhP5Z/cny7nLJ1ytGxPDoZ1J93TkjrsZa2dAY8ldoHlcsF0skltDNkmiX4VDWuOto4Eg7EejKdQaVLO/Pqv/33effdd7t9/wLmzF7h06Qrnz18ihSTdDQ34utYObFH3JJVVNayFCz6U55HKKULNWa1WdGHNVBHSrBbGuILFCJB77kL8Buf5t7+wLSY4gkA6g1CHFJUXaklJ8pT92HtxYm2SqGsILcZUhJCwNrFarjEZ2tWa3Aa8VrUwj4lXG7UTxnVIm+mUZr0mLBYcrhdsbm4CaXAMrdyrAZbLBQ8eGra3N5k3rgfGjsitGdO51FBQYI3s8B6+851/yO/8zu/y7rs/4tzZ81y8eJlf+ZVvY4xnsVgCti9taZxk64vaFatOHKmktkbhqNreqdvc2qKpa/Z39zizXZOidnhT5V1Q5hL9eN6yG2nY56VTj3kqA1UMLQs2a9awdpXRProS+ZAdJ3YdPeZTujLkrP24R9Y6CLwfxRCzzkqrxVXL5uYGlbOsDg/UKJVaplaNUs1loeAewgkaeT/GcLhcUHkNNxZlop8rgaSck7RlM+mIJy+JUUI4zsmIjKFJKk5CDjFG3nvvJ9y+fZsYI7/yK9/m/PmLpNDhq5rJbC4UhVo3eUpfbPGEEgP6lTQMKvFPKba+WK0EPes5p4JADGU35P7LbH7WcnaUU3P6KIhCe+ket/75/zvwRz/ju/nZR9SMRqtly8Y8zL68WXlJDVHpQ2NErlU2bRrWLZVwlJ7D5CyhUzNkEMeuk45PIWByJgXpWHLEGe0RSUGYrJOmFD6BdZ5l2zKZTjWsmY7ILdqGb7laMW9KPT9ZA3csLGytVWRIavjJJl+xt7fLb/7mb3D9+g2s9Rzsr/hnL7+EwUsmaIZkjLbpK3OW1ai04sVnQWaNeogKUGCMYWNri8P9fdquo6lqrBXEDi/KO4SINxkTozhozn1m8vuzyO14LJnzrvllvvUZ3cdnPUrYr3SnyTnpeksY0Fee+XTC3sM1JhXnxarzLesYU8TE0JelMqrHloeHrFcr1jFCzFw4d+7xN2KKo65GhPPMNjexVcXh4ZKU1djQ/cDmUpwqEzrpUlZ52Nmc4W3pZiYgQOH9D6580XlO6116jMvcvn2bh7t7ZKT6wI9+9BOm001iRlr1hkjtFArQEOkQ7izGpnDNRaxtT91xztFMJnShY7luxakzRg17qdUZY8Bj6bN9+sosP98oiGNZbyjQxuljzXU+sv8uv8Tf+Plv4ucYUR3wHgmHHkFNWu6rb8TgVU7mUx7eXQqVb1SSxlcO07V9RCDGjpRk7tdrkaWwPoSUmFT+MYheidbKf4psGWOpvWdre4eqmbBcrnBVDSlICbGk9kTO5JhZr2CfhLMwq3eEDjKS2zFXXHS6aGvvK6qq7q95585dDg8XNM0EMLz77o/48pe/xmxjk1XbsuxarB3Wnl4+FQJUD0sAztRH+Aqf2jkP1tKmyHK17psMlES01PPVve4lkWyl3fun1ZtlvT/NOE/HX3oCreqpDNSeaKtISp+NydEwpUxEkPdySZJShLEk9ugQfn4mEIT3ZJ2GxSO5KIUQabuuxx97LuAJ/Akz4o362rNq15goGa9DTTLBaa1uuqv1io2J1sM0YgD07QNHmGfJnpNC5OIdLRb7/MF3/4BPbtzEVxXz2bZ48Vn0lrGOTNQyR0fh8lx2dEqIKffXsc7RTKe0IVCFMCRFjZQXCGRvXEECj81HeSrNoy+X//aKb3zMCQ95Hwo4dq7x3+Vj6yZy7c29R87xPEYfXjZau7D08wQ05kFJdhAFI6WZUCScFHuldiQhTk4gxqtLiihaYoisVytS15JCB7p247jGkQxTUyIBSHao9zTGMYuJ9XqlFQfAmIBsodJkIqdA17YsFoc0biYJL30HtyE5oST2lRJaJQlEOook7t9/wMMHu9R1w9Wr19jfO2Ay3STGTBcjISa1OIuaL5nj5V9Rkn3ClBqqOWeayYTF4aHW9GuZTqdH6nIWI182geJulqgCn052TxhPJ7vlzC0dt04/4XMfBfnI5Bz71rZV5WkmNU3VsNz3YJImO5Xe30YSOqwh5khOQrvIWVpI7u3tk8IaUqJ2pTnKY9Ao/W+fsWwsdSW1WWO2hFZQVGO0pWKSGtfkSI5BWgJ3nTo1peOQodTsEwOSXq6g1P2VihilPJFzHmdFlm7evKmJhJYuJtoY8Xmgs5TkvFQcw6xzeQKlw1hHU1WY1rBYSz1tslTriOpoxhhxNmtXwlFizWcou/3JnkJ2LR0zbj/phJ/7GNsCR6h+xUjNwvecTWd9E4jQrvGanDdEZIfWzTGK3ZGzVGRIKdK1iS4nUmghpp6f/TRmkmzt4rRXjVYiimC8x0ZZn1wcq5whZkyWUpWldJQ1EtLvS0to9Les8Nhu6JO7syF0Eec8s9kc5zx3795jtVrRTGd0IdB1AVfZvkJGjzIXC7vIrSmh++Ksql7QfcR7LzSbEU2n57DnrM04FEQco6jPWOdOsLye56ee7/QyU2PvJ0U1PiU0UjZdUXaDcOQsvAkhptveoBxCPnKcdVoeKkYwgey9GGMxCn+tM3Rty7IkamjYdaAK9F9dzqe1/nzlmcymtKU2oLHaXhH15qVkRCZysDhg2mwWYIeSZDJk7evvVvi2ScqjYa1jb2+fd37wQ+7cucvW9g7efoc/+kd+jdAF2hAIMRFz1EXLDP3XhwSybMRgTiNlba1jMptyeHhIiEkLb5dyXCpw6gmZlHCP44IcJSmddMATDnl0jp80IhP245tPdeznPbpOuUoGLTdj+nB6edgLN3VIiFOqh/dYMl3qICpFpCTLKTITU8Cm2HOUY4wsFgsxULuOVguHFx6prF2PK9AjUVqU3HuPrz3WV+ztGZyvMEiihvBoRbGkGAhdy2plCdMJNIUHJYj/EEI3faesnE3PEXVOymw1tfC9rfUcHBzy8MEu59yUmJFC67EbKd2Sgw22tNZDogrjRARx8DPeV9T1hNVixeHhIbPZ7EgpGeHmSm1gm506Cgxa7NPI7qO//EzDsWbbfPCpPvvMRvFr1REwRurtTpqa2WyKyVoU3GpL5lF3Ju8ddeVYhsKEVycpJ/YPDrAm4TKESTjVQD3pHWOlJfRkalhmJAKlz4VJCYvDRKHWeGMFVR+hULJPOIUPRmWtih62dhTRSsymG2zMNqSbUEw8fPiQEALW1YQQ6GLqEdOCOonxq00kdP8q3f36eJyRZ6lpGqyxtMs167WgeGUfBMkkT14cRlLUAu2OoVPXadP3s8huMVBOl+maKVfS26ce8yxGoaMNzstxDqpQfeazOSFG1us1q+UC7zyVV9Qd+n3QeY/NUQEcrRRkxDCLQSJVVp+FPFboZYzWYsB0zajijnaMdE4qtKA1sLN2nNS8kElds7O9xfbWplIRGMmtVeCKgbLUV4gwDFxqcL5mMpkSQyQlWC4WtFpaKoRIUPsm6yl63ZsNpkSrZKL13CUBTf5njKGqaqaTKfu7u1IGMSataCGyJDXZpdSU00i30XOVuTp5/Gw692ji1ONOOsHx+uMuCDzBQG3bVh74riN3nWTVGY/N2k85gcumJ0VZTYAwykUqsH1uKg73ViOPXjkR1mj7xgGJjUFCThISWpOspeuCKIVRVvF4akRBiIRUVcX2zgRXNbSrNU3dYNXLMClhk4EuEFZrls6RtjdQ7BSpW2l6pV6ge3BHOrEYY1kslpzZOUuKslFcv36DxWLFsg2s1h3LtlVebBE2ue+I5jTnDLhRizKD5JU6fNWwtV2zVgEOIzg/ZzGSTcrY2JFNM/JORl5OjxYefevpxtgfPDmP7qTTXknn+Svrv/izXOhzG71zZQSh7pIWbx7AGroUtZ6vfB/rxIDbmM8JlWdloVtFvK/peUxAXXmkgVrhVmVS7Lh/bxeTJQlkUjfklKhqj/WWkpGf84jPrJt4No6M1OqtGo+rJORkciR1QbxjgJiwCRrn2d7YpGmkaoAxTguyeyniPjbAtdRV6ThlcBzsL5nNNtnaWBJDYL0O7O8fcOacbOQhRDoSUT3uAWWU//ZoqaJQxSnNIMgrcP7iRXLK3LpxnUuXLmiSVCIb+QntGmzAG2kxjPWDAu4XUf99WtkdH/8IoqIPRY/Oqe4oSA9v0qZ/5ykv9PmPk3S6Hb/oKkLMgKWZTNna3uGT69dwztL4CdPJpHe0ZbOv8JWhQgOQVpJJq6YmdEtyAKMh6xilDu/jb67MW0Hph45WyUCypQxhQWyAnJhNGi5fvMRXv/Y2d+/cwhkNqZboRY+kW016TdLmzHhy1gQuDJXzTOsJydes12va5ZrQRUzsWC4WEs4s3Z9QbZZLFvZ4X+3dLNng+xrCnmpWU3nPtWtXSVlAGAmrirMbu3WPtDmDEN3HUZZPpXePTXJBt3rEdzi1MYOMLDnPu/kv8rVPe6nPaBwpM3WEyifZ7DhHBz1VxZBx1jGbT6mrStvmapQlZqbNFF8bupiFM5wds405xhqWywXL/T1SFwYQDTheBxRENktt3VI03ygamoFkxJBz1snurNFeD3hjOLezw1feeosrVy7x4QfvYU2WmqKUyjriYGEl8TvlgLFTea0U07fm/8/cn8bctmb7fdDvaWazmrfbe5/+VN/cpuo6cdwFNzLoXsXYAjvyJyQLA0o+IL4i+BAhSBBESJCvBoQIEggpWLEMlmMwsUjcxXHse11176329M1u3261s3s6PoxnzrXec07tqjr31HHNqvfsvd9uzTXnmM8zxn/8x/8v+4KtUDPY7/cE54kuEHzED3nwSwnPWt6PnrpWn0j1yEPT8jxqtDKUZcXJySlXT56SEJnCEEXLPSSPjorgRIZNa+lyJGNzMaj+wHE7AZV3A+Nj3yPZz4zFT4nan9riP0iXKMqypBkCPopnuLF5Uk8polIE1MFGVGuqsqK0lr5tqYpSgjDLRgh/CQiRFDzRSIXsvadrpU2qVcLUcwkYfdBCO3zkBIGDnE1MUtHYsmIY/MSxSMoQYqRMGmKi1JYvvf4FylJjzagpmLffyQVCSAEq92OtLSmLGkVB8IrClNRFBQqafU/f9yKMnukJutB5CjHdrbCmG5nRqJTuPFZGa6qiJnQ9XZ7KAyGTixVsQEeN61vsfJ4pD+oPsBh+9Biv70+faj4OvVv9Nn+3/nf5Nn/jszqRT30ciOF5QM45UJmQn9s1KQs7W1tMk+UPHjzADY7ON0Qf7mz0KlNRbGkxw4FQb6ymrmtidESnRD81CUqfpjZgvlKHns10HC/oYzIYYsDkZ8+HQKkUy3rGoi65ODnlj/6hf5X1dsXQNwi/eSwkclt/zMKlghMOahKplrZtqW3Bop4zDANdtyY6n4WcE4MbUIXOcjDj+X4SUp+TbvKsdEagtDFgDS5F9k0jKUcaOeRq4oRvNxvSbo+tamaLObPF2WcTwz+Bj/ZJnxlfriDykmo+gxf/gx9j8iEf6Wi4bORKyvfZssDHyGazoe16+q6jtpaiyCCAGjsvots7m1eUSeODFG1lXbFYLgi+Z7/ZImvIyAMdJZimszo6v6MWv5HiSKc0re2yKUoxFpIM9/36N7/G/fMTThY1pYrMKk0M+qjoNxO//tDqJYNQYoKSlFBvzhZn+LMe7x1P2meUtsAojfOermlJdqQN/LRg0kA2kMmaQsqaPGcghi7JBwgHrv8w9FhTSYem6wkxoYuS+vSUqp7fUU74TI6coNxZi7P+8uHtPUObvwH8kc/2tT/FcdzBGY9Jr1OJ29JqtaHvekgxi+wrlJaWuo6j850GbbFa+KqDjzLtXgg6X/iaXdjIfmvM1NkS6uhYPI3rlnzovD5ZpSdrU4UI5aUUcS5rY2cdVmsNX/7iF3n9lZdYziuCa2XgTo122TZTsfLzORa+Sk0xGwGZ21OUuuSkXjC3JbEd2CVFoYV/PxpEmBx78RPXsHw986Udv2UsNsckQhnNvm2Y1zVkJaWUBPCzWmgyru+lc1KU1MslZT3LfNnP9hBEOf9HwUSJUYmYHF51z/35T4bHxl8+oYk6a6AeIcHqQAxOSaDsEZqPEapqRl1XGKsZ+o66KDN5/lAlG20py4qyLHPSAMvlnLouBVVJwmmNSbiEYqwwWqHlzZ/jrUcejOkGZvQyqhF1l0RiMas5WS549aWXWMxHHp/KNqOyMIsJgfzOUdNxDMAQAkPfM69nzGdzrLb0fZc5IGaaNk3kavG4+j0UPfktZRQqAweidiKTsSiZ5CPJsI3K7Y0YPCmKfNdudctus6Jt98TgclJ0lAkfJfQqHT7GB/iYbyv/zfIfaRS6Hq/ET35gxnvgdgXX//yl537f53UYI9xfpfPmM1WaSIwg90Jnb2WUzp7ILU27l0EIqymLAjXJe6ksk1Qwmy0oihJrNFYrFosFdVXlzfU4epjQxkQkKpEKGZMjraVtiTpqPals3ZgiPkuFKK158cUXee3VV3nphQdUpSVFL+0o4NhgQuROdI6fIA5nWhHR4l4WYVbWLOoZ87Km0gXL2YLSWhTkSfCxOIWxvZ/fyt3nbcT+83pQloWgl9JPEppDZvg75xi6PnMoIz44kaDre4JzxOgzGpvu/P7nxu60GR6t2iPElLsVqESKXp7DTwjjBLS0vJF+/AcJuc/sUNqD8igdstNSVgthfBITWtvcWhSZp/2+EVm7GIjBE4OHKEiPyuuRy5SXSILsTx5ixOpMr8qLuzFmWjxTGlVMBCE6IKdM910QdflQqEOSkFv3VVFwcXHG2ekJs7qiKguhrCgyemoy+ng8wqqzGkC+Jmr8UwAGnaDWBQ8WJ7z24EXmRZm1pEfQIk8sj7rSo00143UcEdFRwkqeyRGldt7TNE2Wx1LoLHIYnIMUiNHj3EDfd7hhIA6eFPy0J/38sftJyXROTJMo4UzvIXk4vAuu2PIfq3/+2QXgpzzu7ifH4Fb+OvIWRi1fH4J0R/NdjlEUJqxNKAM+uGw9KzS4pI6Ghj9a5B/9TdbcPMiaEfqpoILccT2sbyOynnKeIZ17xXK54KUXH3B+eiqJcoasxrhVOdGV1xxjd3xeDofoFEvSqxOU2nIxX/LyvQfMy0poCiHQDYM8Y1kOUYp6GAlV6agrENMYy+lgunF0D3a73XRVYgi4fhA1pSR0Te8H+q4h+IE49ETXE6OT3V+pzNf+NHF7956PPYo7CaqVQLim4/+pHj43pp6LoE6b3ljRqHyxpmRKPpfyhjAmaCMBOgQh5CciRVli7giIS1Vf2mLylkZF6llNip7gB1wIjCK/U89yFFQfuS4jSHR0AY8vmbTEUz4nzWI+5/xkwf2LM85PFsTYMYTM19OHCz9N1eeLPG74KeutRReYlRWumqEjlNZS2YKk7STvMm4Mx4K5I4p+nD9O+2n+0FnGy4+83yRBJsMF0hZJKeCcIzqPqSrKWcJmvVpyov1zo1HHJJO8gXzsZD/2t/FNJfp4wof+X/4EP4wJqpqu5RQ/jMni0QKW77P3gd2+IXqHIVJojcmLmZ7iIyP0thCklDQlZ9YWKLoj/ps6as+NKPdRdZ8Xx/Fbx4s6kvFH1B00VlvOTs+4d7bkZF6ilLizkTJPVR0kpsbhKBF0DjnG1JSYW2OpTMHMlthKEeZLThcLrJbJ5DQpF2Tt3vy8yZ4/Jn5yTO+VA8XnzsakDpJDfdvhtGa5XIAC7xwxSYISfcAPg6heGDs9e5/mSCmSfMQNPUoL742UUeaPrA/jsaPnX/DBp37Nz/IQZ7tRgu4QI7IdSVIylssxd1hCEGWVoMEr8F4G90budExJhjCUEVqSsYKkODclwOR7OYIOIxKFOrTyp+NoYx+3fqVyd2LapEX/t65r5rM5VVVhdU6somio6gwcjD8//kZF1oIZi7sk71UbIzGfoNaGanHKKxf3WRQlTdtjlCbABISMPz+d9vH9VxmpyhKFAEoLZOB9oB8GbFEw6SLnVmxVStLonaN3Dm0LvJNiCyXdu09zHG/s40WOXiTs1qtr6sWMelZTlaWcZ+Y6NnT8IL35qV7zszzuJIFHnx+pUONWIja0cYq3EALBezHyyXJoWou2dFQKZUQmLxpRSzF6zAEyn326bonjBHlcdw+7OB85M+nojGo64/kpLUnZ2dkZJycnlNmAIgTP2FBSR8/EJEOZ33kYi+T8qjFGVFHkwkq6t7P5kmW9YFnUxFz8pBQz3zr/vmOcado/PnJdYcrRDioCSobLtcS/9562aTk7PSVXbcTg6fsWW1UEP+AHWRvLeZFPXR399/nHTxXqT2KMM7SO3fqG2cmCsizo44YP0u8Cf/wn/u7nJqjWmmmaLkWTN10mRCmDMdOFEg97WfjatqVt5GJURUFhhWckYI7cWKMtpihJyuJDIgWP1joL9xcMXX93MnDKnw5Zk8qL3JgkjHIh4xGzcOCYRJ+dnPHKC/d44f4ZpdVo5IEAMFZkWZi0T2WiLqaANiXHRH6SYmZLYllTouECFkVFnxfahEiWjBX7+KdifJATUwLAgauKIisSaIZhwA2Owhq89+y3O+bzOaUV61nnenyIlEBhC7wZsIXNCebHomS8inf/PT5LGS1V4+dCnCRaU4Z3JzxDKY7X0jEo28Up3//2n3xeSH1uR1HYgx/9UctQkNNEJBBGof5cZXkvXEyroTIaWxySfKv1ZFbhnMfoOMW8Uoa+H1A6I/HjNdXjcBRMG7AyH3uKTR6EGi+qVmLfF2OSChZBcmdVzayqqEqRRgtuyAhbFucfkaijpHsUap5Qghip6xqrFLW2zKuCk3slF7M5hRIjAEFl9XSfhaaQT1YlRtx/lEsLKYmusRaf7BGVQilsUaKMJvlEs2+BxHKxQAOu74h5zQjB0zYNC7PMA1/POcYOwScCoomUAvv1ms3mFq01y5MldV2KjuxYEY5vJ1+XPY5/rv/lT0IDUyE+or/jsEkiZc3eQIqyrXnv6YcelYd0vAKTEm5QDP3AfFFhcvx77wkMIgWFJgyBPvXYEW2PYXL5ORRHn3B6yHY8JbajUoDJbVxjZONPstbP5nNsUebvd3RdJ+6Danwm8vpyHLsqFxpqTETE5rWqanRK2JiojWUxm/Py4pSFtmwQHddAlPecwYlDMZX3rmM0KGc6U3qRnzsfPN47TKZRDIPD9Z7SZltsxB2x71rqqsa5nthI6WCL4wT1I+vu8TU9TjY+4WLHEOnalvffeZsf/+h7vPjiA1597VVefu11Cq1lvQEMgXlqf44A+/yOKXZzQBmlGfoBnxMoFHgvDksx5KHTJMVujAmfAkQv9vFK+PhxkjFTeQDoE7p8U54qu67KlIhjJF7cohUmF1ZxLF7yenl2cZ51feVeD0OYfnZMbIVfqqeYlVc8DCKO/1ZZH96imGnDvKopy5KzoqRD5grsqL1O3qNilO6XOrwhyR/Gd5pJiGMnW0nHVehWshYnYBg8+11zZ4YsxUjXtcyWS3H5TOBCpJzPgNFC6/hOfmSx/YkAwseTjxAj7W7P1bOnvPXGD3n1tZd58aWXsMMNr6d/BPzbP+F3/ZQE1WQJExG59/k0x2AbzyORYkBFiD7SNm2eaBa+hjWK4DVRyxJgjaG0FqstzjtImqQiIYIxOSkNeVoyRpIZhfVT1lzNqJXOE3TpmPScL2USyz6r5YMkFdJsNuP83gWL5QxjIOEYugZSyLIl5ogob8SMwAgXb4w/lRI6KEpdMLclRTVDVzNeXp4zA3zwEDzkYZFj5YLDMU6OSvtWbPUSjP66WuF8xPlARESnvY/cXK8wynCyOMHaghQDQ9+hrcY7S9M0vDSrGd04fuYjyc1MGaV1vfDZTu5diHXnSBo8UqD9pEMPb1A//B8D/9nP8eK/uEMq8VHmJqOn40RpyqLlPowwTVaUEB61TxqdFH1M9E0LJyINUlipMJ1zhJw8Bp+AVmgweUH2XrRQQ36tnySKLKcmg3ZGGZLOovtKo1XE543eGANG03uH37ZoK4tRkYsZ2YYPvtBaHc7lgBjLNTg7O6PfNfhtw/l8wdLOOXPAEKmCtKAUIqg9If53IXPGMlGOA4Ixtpy10rmzUKCUYfC9FJ5W1hPnB5wbCEmSgvlywfp2RVXPsMWnRE8zqrVZ3/I7/9U/49HD97EGXnrpRX71W7/Oy69/CWPzQMNHjgt6/hzPbzd9nsdxd2j8t6AxCZdjVudnNvowgq14FdEpEaOmLCzR5w06/76YhNPsfUArjfEGu1hIQqdl+PWTkqWPnR9MHuiikhLpg1BOUta8TEjhcrPe8PDxE85P58wqQ+0sSWmilnuhUNgJlcpoUFZ6m9amJJJYZqZxbY/bNaQiUpuIebZBv7LD9o6Z1gISHJ2nzkW2GrOPkfsPWSNZ1suooO97rLXZYS1KsWgK2ReMFtqa1vShx/sB7wfabo8pa1LsCZ8Rjy/4wHaz4fGHH/L3/7O/j+93rFfXbLYbXIh8+etfn3iz53yb3+LvfCav+9kdhyI5eieSUHGGUqJ44kNAJY3S0PceV8pw0uS4l4eSCXKfQoyEvsN4GQSq6xm2kOJhWoueF7eZFjKCWEZrmaAPXuQIY8jJaRLdVQ0PHz+hMpYHFycsZgWD6yAPooas0TuuJLLmyt6tUpyQ0xgjGjE5qgoLPjA0W05VxenCYm/3MsOQYz2FgArZkl0deLISt1k3Oq+3E/ihZCDRBy/qBt5ljWShUdrScH5+npU9Mk0weRI+yzF6Od8JAU+H7sknQAA/zxFCYHW75v133+Y7v/3P2G/XXF894Ytf/CJhX/AKX33uzz83QT1uP0qRLbvVqN0ZY8wXRm6wntDKlE9OpBq8TgwkuqbFLWfMZxVlFrANMRCAEBMmwqCZvHUVkjT0zuF8GHO+o2PEJMfqSDZma3SWU5A2glbSkg2uw8dI5zyqi8zbDhekNU4m+x/vxMdVkWiJ5YDTiouLc544j2p6alOwoKC+aWgsaOfRWSfCmiLXOZKAHgrpNFVqMfrpGicifd9TVUoWyQQqcwrv3btHXdekFOm7Fh8c/dBhK7GF9W7IE4ufeDfvFkDTAETuWaRE23S88+abvPnGj9ht1nzjV77Jl7/2Nc4u7lHWM3F1+YRj0jVzL/HV6//+80LqcztGX3hjLNHKxjmKbpOpJiMFZUTfY0wyzUMkxEQAPKPIcZREUcli48kLUJLvCskLMmiE06pSmqx945Rp3H3YxztgJ0QgEt2Acz2a4gj5h+2+5Z33P+De+ZKzZQ2FISpD0BalC3QeIJxQqEzPmcrKCZ1VnJ+cclrP2dzuUNuWhY5c/c4PWH79S6hdiw2J0ZN9LEimM09MrYypFTwiBvl58c6hlcJHnxEwQZ1m8xlVWZBI3K5u8dEz+EBQcAFCAZoQg7tcPkE+paibLuWEoo4FK8Q48OzJM95688fsNiuqUvQy16tXObv3AvVcqBh3k1RF4svAL4cL2jGSeMz11+OmnxNxZYQ7HfNak1KAqLOhRMKaghAHlAKrDYUtGBKElIX6lcSXKSzzxYLQDxRl8VMT1KPhYVzfMzgnQuPDAECVKRVai87kZtfx9vsfcv98yb2zJQ/un4nEjxZTFKPtJIl1aBNrVAyILCATbcoozde+8lWeeYW/vKVqWgq1Znj3MVEF5kHRGDUBKNIxOUIvj9ZzAVCPUGqYzDic93RDn99xdpOzZor9vu9yB8vRdA2n5xd5/xiRm4+WbyMCpj6SSKXDQkDmzuZr3O9brp48ZXV9iVEeYxOnpycE52h3O2YnZ0Jl4pJC/UfAH/7Zg+xzPCTBTNkqNmuG5v/EINc/hDAZqoxKCtYGAgmfYzaGrKVaFGhrmM3mOKUyT1hAgTvIv5K1YSxXUkqkEGV2o9+Lzan3xJSoCyMqP3rsAgcub9dURUE/dFycLJjlbkTK4JfJsyvHqL/WCpzc/zEnEcMYxTe//g1mQ2T19gdUTcfSlXRvfICbV5y6hHExG/Uduldy4mqKu8O6d0CMx+fVeyfASYz43AkZZzDqqmbwAyYYvB8Yho5h6BmGjrK0hxxveolDWgwIh3b6xNiFOFDZPgopjCCmArarNZePn3D99CkxDGwrI4Pz/ikX6q8B//OfGDs/NUEdN0hZIOXkjigWuVIQnps2BlsUsrXkyjdEqeiDkoGJGNJUKem80UvrKhGjA5dEh85aEXweoe54uFfjrx8XybGVNFXNMTIMvbSscpLnvUeFwJPLa7xbcO90TrVtxHIg++iSN2WpslRuDOjDxVZ5iVFwcX6OVRo3eExKnCrF5kfv4l88R7WDBHs6cFc5WiTT0XnLenV3wUoZhQhHLTdtDHVdo7TC+YHkZFHt+payniEPRDpIbhGPFr5xc/9Jh7z+zfUNH7z/Pu++/TaayMPFjPN796hnc4qyAnOcvB/9dD79czvwb1w8fs7rfI5HHtiYONTTgnFceKmpFa30OFSUJJlNipAgEMW9LIzcTE1ZlqSoCMRJ/iwm4UqVZSXoeQiZB6uPWjKH+zze/7FQ6Npu8jR3IWDHsiYHvk9wu95JEpICs/lMNE2VuESNLmvHPOwDQzDLnuevlbbgm1/7Go+HxPbDJ1RouFyhLu6hXUfpZVmfktQpAUq5lpHAnWSP8n58QCAC4wN74KIydSRSijSddFr6XjYJaYSJXJXE7hEGdme//yR0dVyoI945dpstzWZNGDq8KmjbPW3bsF2vsmKDmWDhmGTd2LHid9Tf53l8qM/rOCRpdxPUdHSNfQi5EBEEM+UCZ7zfE2c4glAtLDVKZG0QBFXBFPdVNUMVFfO6yvrNRxsi3Lnso0Zjioqm2dN2Hb1zhCjqLKN7mqiXKHyEbdNhraEqC86TwmbJwdE++2ATyfS6Kg8nGTRG6cyRTvzq179Bve14//EVtk2UtiddrdCFZhkU20Ln4Sg52YOWvqAraaxwJr51foNJdLijQmYnRkwhLxwR4dKhxMzCec/gBpGriyHXcukoST26cPmXHaVLd782fq+WZ3a72XB7fc3m5hbXNahS4foux/Ke/X5PfSKcwl0a+G21+gNE3C/4UFLESoKah451Lp3zMO50vyB3MQ1VWYJOqABh5PsbcbVUWlPVNVVpMIWZEtzxuh4ROxjviQwFJoLz7HYbusERk7iuxeAxWfd0jNshJFbbBmtFp3W2mGVtaVlrzVGrfzqkypG1XWWDDCMc+y+++hpcronvP6Put8yUw9xsKV3ktIAaRfJiapSO1m7huDBRAMccLP9t0plNIea4HXWAJR/Q2QV0GAasNfjsitb3PS6DWjo/D3ficnpD8LHO6R2A6+PfLf+IbFcr1rc37NZrhmaPtYq+a2jbPZ2H99LXnxs6z5eZmlYi+edhc7p7/ilrkGkjXLnxO0bXgqjE0Ulu/ih4DLYoCFn8nijkaZ2k1WSNoawqlHNM6J9S3L0EkoTkAX9SjPhhwPlAs99LJaE0KrdzVYTr25VoVSqoqgJrpSJKetRJO7RJx8n96cFRWRIDxcliyf2LC25XO/SqYaYM7XuPSVaj+wEbsgiuljR3dKG6i2OO1zMdrVUpJ0OSXI+WnNqKRVxKga53DM5hq4q2aalnPWQDgjtIXRqv2VHhc7h0R5W93Ov1as315RW3N9ecLmesVzdstyvOuwsWJydMZgNw96Ecf2WRsA/cJ0XS535MxUtOpBQKo8zHzjtkr3udFz1QpJBtTZEE9ZhHpbWiKCpxOFGBUTVBrIA1RVkKZT4EScj08Sb0kWs2filG+qGn7XravkcbQ7AlCin+5DwUu65Ha9Fhve8jtihhlESbYvMYq5FN93iAUCuFVYpX7j+gXzyhHQJF8thdC6sdJvZUITEkpo075SJt1CGXT0vcHi8Ho5PcMPRorSfrQ2B6fmNKeCfayoN3dH2HUoaYhBOcUvzkazUu1EfX7rCtq+m5cc6x325xbQsqkIJi6FuaZkvb7jnxZ6RYye/SZhqOSWlH4Ds/Q2R9vsfxvWPEqpO081AHS9spNU0j/+1QGIDCWkutC4LyJOUBB4pJXs0UllJrqrq8+/Pwkb+PnxEqTGhb2rbFhSASbMYQQyAE6VjElPARusHTdAP73uGjcPHGmVSl0oFCBZO1tUI6FlZJbVwojY6JF87Oualn6MGjh4TuB9J6R1EXnCnNdQQ/SfvlPSOzk8Z/jhvbtJEjSdLQd8Qg9LMRHJACVn7GBy+zAd7RDwN916GtJQQ3tU8/3mr+pA3/qAC7I/CvICZWt7fcXF2x365JbkAVBTE4hr5lu1tzb3gBsp5oSIaBez9bQH1ux/E0t6ynIXrhKluDdvqQSKVRVmlCgdBKS5dVAz4RkiIOCWPNJOVlraUsCqxlei7kyPs2OZ7yfxISDzEE2kZiVmsZLI4hoMhulkHWfB8T+26gbjoW8xkRjVFjoc+E7MMhbsctWCMxbpXGKgUhcu/0lPVsRuEj1nmscuhtg9GG05OKWdJEfzAYghGIGxmth7+NCh7yD+mICII6SK413obcTUOLrj1AyAPWbdtyNia0MYI+4vGOuVY6AjrG5+awCRxe/86dz/c8Bm6urtjc3tLudoRhkFkZN9A0O5Q7QfNbz42i5yOoCB8j5YRS6Wz1NWnXyffFMcCUoqhE1HwMmBAjRonwLnHkOcriOpstIOvMJSVZvS0KsfDTluXylNDusYXonH0cSJbkD6Q923c9bduz3e0ZvKMsK3Q8unRK0w+R1WaPVomT5YzTs5OssXdwXRkr5uNX02oclBG5ibos+UO/+uu81wYePf0BJQXltiVsGso4UIWEWI1nsd6kpxucGO93ysnrYYwqBplmdloRcos3kXU9jcL1Ika9Xq954dVXWG/WzBaLLNHhGZHrMXjSEeScxmA7zvPH9TFp+n3L0DTEvodZiev3bNe3NPsH3Lv/Ail4UBmx+YQ24Pv6nP/l4jf57zw35D6fwyjuOEcJJ1mGnMZDWnkDaIUpCpQxGBTBDyQVJ77eKOiBHnnZBSlr+KIkIS9KSSiNtVRFQW2zj/2YyAHHVajUZIKYJB/puoau64lBugt+kN/rnBeHkdxKN0Og7h2di8wXBqNFI1zrcajmsGAawKSRlqBlwUxQAM3tLW67xXpP8gndDaTbDZbAiVfcjAgYKsduRMaj02Q9HmO8E18hBPquZ71e03UD+6YR4faj5ct7z2a7ERR1v6NtGoqyIoSBYeiFDpAT63RcXI1/GwcH8oIp3yLJcHCRoR1YXV/juo6ikozEDT2rm0teff2LxOAIbiCRdZjzINuLoebfSr/2Bw+8z+C40+LXH13z8kSsH9BWTRu2aCFrQgxoNW78Y/ItHOeysCRtScpN17SqKlmjc/Fl7cd1SO+0S/InVdIIUB4JmcpiC4VB9EhHyauQguwPg8V0jqrpaQbPrCrytpcLQFmEBHUCbJ6OqoAiRmwMlBqKlLh5/Ijts2fEtsV7hRtawm5LxZL7y5p3uh1xZidt3vFZGxOHu1czHdbMFFmvVpiylA2860SZhYzwas0wOJrmmrZvaZodu92e09NTumGgVPpugqoOz8YYrykGpo7N8fU8RqG85+rykstnz2h2O4hRBoxJDF3D9dUTvvTlr5CcJybNC3HOX01/9GeMrs/vGGMwJolZHzzGaIqywHpP8IKihiTuRgnyUK7sVYUtUFajC0haYrsoS4wtcoc7URQWW2SOfh7gHIeeP7YPJukIpQBD74TeUsrsSXCRQMR54aViFNErdPLsWseidbioKBRoNfqdBZIe41hyBINQwAqlKZWiSFDGRKkhNC3NzQ3bq2fUPXhV4PY7ZmXB2XzGLGpaH3NRqolI5zgedy4Zw/VusR68Z7/bZxrbESAQIzGKNnXbdux2e5JODKFnu93yik746FDRUFDIr1Mjp/c45xqT4aP84pNwBIAo3fKubbh89ozVzS1tsycFj8Gikme/XXPanfLn1X/7uTH0fJkpyHqGecPTOk+8ZWK8goS0N6Sq9NiioCxLWZxcJOGJKeJ8xKeQnXzUNPVZKYO2YIxk9UVRMFYKRVlwOr8nbjxjBRRB56p/unQKQlJ458RCbWgBIxfKe2JIOBcwStFFDyphmp5N03N6do5RCasSWkXAI7WP0BFtkkVsrjVVDFjvqZSiRPH9H/6Iy/ffRw+DOGQ0DeF6jdaeRVCsfcD7RCrHDfVu2/04WRrve/CBZ8+eMlsuadp2op5IS0/kT9q2Z7drKFa3dF1HP3R0fct21xx0CY+Oke9KzEmxGTG2w4Pc7BtWqxVd22IAFT2u67h+9oTT01Pu33+R2WyJsmTr2vwuxv51SvzK9bv89b/3v4K/9MtC2D8gQSYPEt2V7hA9OIhUVcHZ+Sn7fYNKBnwkpIhVcu1RIs6M0TLcp0Uc3FpLUlAWdeYCCo/JFgXKZO9zJa/v75xanmBGJFR8H/CdJ6KwVpDG4EVrMSXxng5RoQhYo1g3Leen84yQprzxGhTFxFe0SVMlzQxNTaIkUseIcYF3f/8HXL/7HnboGYJls12xrCzVvObl2YIbF4SrmCKRIN3RET04QitE51ek5EKeOh5iIPgbhmHIm42oehgt/NT333uf3vdiURkC88WC1WpFP2QpF8mEme5UZCrcbm9uuH//fpajynqdKqG0TO+7oWez2Uhy7YJscAk2qzXrm1uMKRmGyGy+ROlAUg6S4nZ4xHf46/xl/me/4Jj86Udp7IQgqnTcQhzbdpGEw9jEvftnNEPH9fUtYZBNXKmET4mIODullDI3zZMyxaFIVd7ErKBbfkCrRBUKGcBTY5v/gEaJbeOhyNWACyFL/TCtVcPQ4fwgigP5d3gizTBgdw2bXcO9sxmkMA40CHVFF/KcKQQ1TQq/bVCLE2ZRM4+auN7xnX/0X3Dz1nvYYcAHxb7ZYVDMq4Lz+gy739PL5RqXvWxznREpxbT2TkOE+XvX6zVJy6R5s2949aWXRbdz8LjOgYq8/fbbVPOK1XolYucattsVtVtQVTV55ByyLbhCSTIfHNeXz5gt5iwWS3SZB6qmQkL4ke12z9D19H3HvtlKd7D3YC3JJ9p9w9WzZ1i7ZHl6SvBPIP3fgV8OF7/jI4RAicimJRy20Lz00gs8fXbNbrsjivwHLqPtowqP871smapAJU1hCmazGdoUKG3wKUF09C5RViW6OAzzjrJqx6Xt2D1S+ZyOKXfkzu7genz0RCVtfqMUnQ9sm5Zya2iHnnlVQfIcdpGIuFCOiam8Vhki2nmUc6h+IPqe7/6Df8yT7/8I3Q0Ej8StF8OMub7gtDB0kcnoZXRB1El9pEZUkxvXiNc659hsNmx2O7FZD0EGy4JQeXwnyP/Tp0/RhXQENtsVt7e3ANSzwwC0SmECdqZrlBJD1xJioJ7N8hqQ8wg1ormSEHsnINrTDx9zfXnJen1L1zTopAiDw5YW1w38oP2A/7P6MX/hOQYTP8OQVJoSmVFTUk98VPKJeWLqScpRVZbz81M22y2kQEwCm6cM+cZ04JH0fU9UFnSeWs7ODCAwPCSqhVibSStOOGo5DO8EiUqyCASfCEPCGBn08BmxjVEE0nWCfojsW8Vq1/AKkoSKtE6UZs84BJIvUHSeYbcn1XNsjKjBEXrP1Qcfsr66pgqRLkRW+zWL7ZxFbblnSlYpt4qT2GyOJDJ9p7LOtIdMzg8+sNvtabqB7XZLVeYBKO+JLrLb7Li5ueHm5oZ939C1DfvdjtXqVjyotZLqLgtlizCvwvUDbduw3+84OzthtljKfQC5LjoTvJEkwQ8OXSjaZsd+v6Nt9yhl0cblISM9fZA3wXc8/AfpPv/X5wXV53wordDWSBETfL4fspsqA5GAtoqqLljOa5wfCEN2kYmRaBT90E+Lnxsc69Wa2cmZuJQphVZWdCVDNlHQ0HuDjw5rTUalDDZqQtLTw51SmoTEx4JYUlYZHnTBTQ4j41LrQqAdBq5vb3n9pQcSrzkJHNcMaYtqCqXYb7fsdzuWQ6Lr4fHVln61Y/X0KW7fYLzEVoOm2JUYqzmbnaDCPhciKW/yoiWsY9YMVof1AfIfMdIPA2Fw7Pd7YhJJqZC9oL0PbLdb3nnnHYahwydPWdeYsuDm5gZT1njXC9VHFSiTF70QafcNN1eXrG5vKKzm5OyMsq6nVtRoraGN5uziDO8HDBrvQPWKdrfj+vqSopphbY21NejA6PV+Hr/CX4x/7fMMzZ94lMZiklx1q2Axr9nsNyLDo+Q5TQh3rqpKqqpEG82QHce0sigKwKIieBdodg3d4KmXp1JMo9C6wOiK4Aa8UwzRMZTDNNiWpn6luFcd60QzomPx0BbUY5HtwsRDJQr3jxiJAQbnWG02pNdeFLRMJ1JGpBIpd7EMFsV2vaNbbTDrhvBszbPiLZrrNTdvvU/YbLEhgY+4EAmmwLcdcSfdMUaqQwIRt4cUc1adE+xDCiMdkuDl2XIh0vcDQ9eRXiZ3sqS93zQ7Hj16hFLgoiNpaLpWEls0w9Djhx5bVWQiolDbhsDN1SWPHr3P2cU56YUXObu4N736WMil4IjBM5tV1FUpCHXwxCh7ovcONzh2ux1931ENM0qv+Vp68XON0Z/lOMTHoSNgiyqLzEvSOkIlWtls1SyDda7vaboWZSuKekaIOWXK2ocpg09975nP7IFXnGcvxqI9aZ3/LjrB+ggUmqT3MjXJDYO0+tMROJf5xk03cLPecO/0pcloJZG5m0cFe6EtuI7d5VPqbc9s26PmK1ZPrnjjd75Df72iCgEfYYgwaEPf7ijWG5aziisVp2R0zHjkH6Oay3T24ysDMiDVe4/zga7v8d5jSyn4SImyLHjr7Sc8efIEnxxJRdpmz3q9xhgrA+i6IA0DylZMnBsSKWmCC1xfXtHst1zcv+Deg5ekE5AO8atSll7re7qmZbfbUdezDDpCiI7gDW7oGfqCLw2W/306fW4M/VSr03wtJlTuWJxZkJTcAs0ODLaw1HXF4AaIgcE7yfbVqI0oQRZipNk36KpG2zK32HWmB4wJm8fFscUqt0Nrkx1GMgJ5NFCQ4rjh589oLUMB2Swg5W6OipHBBTa7ht47ityyTlHaPJN3ilIUSXN7syb6QNlHTOPYPbrCbxr2VzekrocIQ1A07Y6i3aPtgmVVitMPTOcfkWpoaotOrYhDshJiZHAdIba0XSdcvhTz5qTZNw03NzesViuK3hJiZN/sWW028uBHLwM7ZMs+pRh6x2a9YrO6ZbvdMKsKZvO5nFsOMK2kXai0ElpHRqzathHFAO/xzpOcm0jqSums9SrvZ14W/Imvf+VnCqnP7xiHefKAD4xlyJRgWWsoy4Kqqlgul/RNQ3ASY2mU/kITE5P7SeE9QYvloNYWrQwuyaYcQqDrM2XkWPY0P9DSQhlbT0cJHkyk+5BbYCGGA1pJIibF4B3rzY7tfk9hZpT2MASmM3pqUOiQWD15Bp0j3uzYLy+JLuD3De3tGjN4dBTpIu97hq7FdBVhVkIZx8t32EDlVT52fcdzV4APkc459k2DVprlYjFV1yI/13B1dUUIDlOKrFbRd1xeXXJydsFms6YsKubzU8Y2Vd91bFYrLp895fbmisWiljZhYZHR05xmRCmmy6KUZ3n8yELgomU4iA5jNUwOLMoYQirp+MJnGXif+rAZpVZJNkBr9NEaeGj7W2unAY6yKOmnwY3EaMursmQficxT87iUMGWFsRaUwYe87qTA4G0GlWTNnMh2jP08NQ1rHDZqpudJjANcVsg4UnRBNrDBO25uV6y3O8xpTWEzAp7F2XVGokxU3Dy7ZLhc4S5XbOqnpJDw+xZuVxQuMM4HeOXxTpxx/L5CLS1HT9iEjt6J3cThzNVdM4OuH+j7nuCFnpBiyhqTkaZpuLm5lmLeKGxd0A0dV7dXKGOoZzPmswUX1ZgwKkLwNLs9V8+e8Pjxo1zsw8npKYywyGFxykPBUZDYGKXzlulfwTmGvs/yQJHgAkPoufwlGpK6q8M8RkguYoyhsJaiKLC2wLkgCaQZB5U1pDEBDajkUdoxpIQtKuliIa5/Pojcmg+RY6lmWQszyKRgKkjGmM2OTHqM50zl8sFPA0cwJoiSTLbDwLOra1578QKrjeiaKjJ/OiffSlMow+1qw/a9R4TLFe3ja0iJ3fWK/ZMrdD8QlRbtd7xwmvuedrdDV8tM1RnfRZp0gAVIOu55qul9aa3wITKEQNcPtF0n56iyUZBSaGvZ7Xa5azUIOJMC+/0WZTQ+RbQt2G7WLM/uC/0pS1763rFbb7l69pTN+hbnei7u3UeUUNR0j1OCGDzBOfzgpjVsHFYeH8ToAn5wOGcJ6VefG0s/W4L6sSMHnBrTLnnQpbVpKErLfF6TghdEZMg/kTlVKvMr266jzItqUgajxE5PSPaBFDxd3+c20diqlcGqqZKfPpg4L8cPCIz8lvw1IKBxMbDb79nuW2pTU9lMcI8Rk1MSFRMqBG6fXBKbjnizZTd7ihscw2pHsd5ivOjl+aTo+o6y3UNdUM7mpNAfUPIxybgzoDx+UZ4eIXAnhl4kW7xz1FWV7d1i5pG03NzcsNlsKAdLWVXsmz1qdUtCYHijDEYXcj2toe86bq6vuLp8ym674cH9c07Pz6aWv6BwcRqykc1dUJC+a4UbmDf53g3iQZy5ailaUh4uOjOK/+YLy08XUr+gQ9qkZGvFgyTSOHwCSvRNi5KyLFkaw/rmhmBMRrjluo8twRjH+5gXSG2xtkRpI0MjKaKiSIWJHd7R/c4nlNJ4UocqeLoPORkI3okCxREHPGkZlvIBdvuGy+sbTuYvQ51biSky2oiGmBh6x+3TS+KmoX16w6Ut6LYNOkYeaEuR27IxJWJwuKHHty19baEwE9Kfxs1cHUmfjO8jjamAfIyDSkM/iJxTTuxTkinSpmnYbrckAmUsMaWl7Rp6NxCV4vb2mlk1o66kgMIY4Vzf3nD17DHXN1ecnixYLhbMZjOUMrLB62wZm8RpbVzZdUrZiU3uefA+y6s4bJFIWigAXYw8ZvsLisKf7zBafcSUJOX/5+QQQTRHIxVrLbN6Rmt22fQhTpPQSWW9U2OxVpCikKAYp3uVwgXhrqcoGyYkQgqj2g2je9gYr6OBADqLkud1FSXtU3G2OhRWKUlSEJI43KxWGy6vrjmZvYyqS0HSlDQpVBJqhhs815eXxGdr9lEKLt97aq0404YyI2kRRdDCHaTrGJo9enmWn7l0FLvkc4Hx7Uwtyuy+lrKUkXOOwfmp9RvzLfBBOgDb7Ua0iktDqWppxXctRVFQFiV1OePs4r4UTNrgB0ez2/H0yWOunj2l63YUpeG1L3wBRY7frEITvCRmbhgI3k/on4JMWZOvyb/lene+51bd/qLD8mc/FBOPebJLzvFsjKEoS6qyYiikE6mI2VTFZM0GnVvm4jDpvcPFRFnP0doInS8m6XLlRH3SZme61VNMwiFFHhPUcdWVGBEwbJQTnFzV8nIsQ34Dl9c3bHY75tUpozoLY+wCRFm3b55dsnn4hMaU3BQl7b5BDY6zJH0NVCQVRiS0YmAYemj2pPMZKsZDkiqthykpVSoPlE+gQB6FVTqj64HBCYJpZ4vDUHr+4e1ux263IUQvXb1C07R7XBQgxNqC1eqW2eJUVnMr0eeGgdurZ1w9e8JqdYPzHV/7xtew1Iz99SmVibmQCh6tEtF5AfuyK6POiG4MgZtQ8T1+jT//nFD6VAnqYUPVJAxSyIgWYVFWzEqHzb7eKQS2fU8CtBYYHy3SH8YYYkyEfiCgmJ+com0W8faOGBzb/TYL5R/kgu6KLueEIcUjkWlZTGOMk3bp5JCCghhwIdL2iUePn3JSvybcEg7VKiExDIH9Zs+TDx5S7Ae2PJX2a++ZGc09U1DnloRXSrzcmx2p0PQWmHmxyjzKUEbS+KQGlZcfrc0RlwPatkWhiBnhCiFirWHf7Lm9vaVt9+hBc3HvHrvdhmZoiSny9Mkjzk7PmdVLtCnAK4a24+rpUx49+oCm3VKWmvOLe9T1nFH4d+gcwXmRXRHxLUBn0wGPyhI++92OqqooqwqMJGUpO1Y8unzGX//bf4N//6/8Tz9NWP3CDxkm0rmyhBilKDDGYLOAPD4IPwxwXQvJgR5RAY01Vux4kU6AsZayLPLgmAh7K53wweXuwtjCyrrAmcw/Ln7aMLU5EwlPxHgZkEqZZiD3Q5pJMUZ8El3h9z/4kFdfuMfFyUziLEFwA00/0O8a+htpC4chsG22E6d6aQtMEMhBKA/g0XjvUG4gDg6TeVXk5HJqJ6VRakreV5x2fIlVWQcMzgdGi9MxKezahpvbW9q2JSaPTwFTWLTRuCSyPhdnFyzrBZUWC+SqXuLalv1mw5NHH7Lf77haLrg4O2U5n2PLkt5FqqqWdWQYmNUl1mqEYpSmgZQUAq7v6LsWVw+ygmmNjsIXe/WX0Y1H5djTo7azFoMIJUiSQlEYy/nZGV3ToaJDBXfHm1u0HQ06iqakHofM8hFDoCxsFitPxOywZrIKRUhClxrlvyaFCA5dCGEiB0wcKVhS3E16y0liNyRFUPD06TO+/OqLWFugtRg7pBBo+5b1rqG9WjM0HcEHhiCdpxIolKHCYJN0wmKMBGNwOqC8JzmPzpu8UKsiAt7IpqhMhtLQObaZ3lMMTC5+iqzR7ZwAEMGz3+348MMPhVtNxPiCmKCZ7Rli4FI/waBYzubsVteEaCiqiugTfuh5/PAhzXZDigPrxYJ2u6WqKgZ/0Ngehg7XDwTnZThKJUpboLPMltHS3asKK+5HIXLqDP+t9OXPIRh/tmMaMh5pTCggyzhmxNFaK7Mq9YDNvH2VB5SNMZTFDFd5fISgxOFxtK9OQfbzoihE2F5nuoA6mvFIZNlxic8RvErxkMhGso51VBOAxZggToj2SP9IdDHw9PEzHpwuMYsKlXnaOgn1om06Hl+vefLoMaobcNFhaLAhMTOaUhtKJYOq0TmCVng8znvUMKDDOOQ8Dk2PoONo4cqUmIYYsl2wIUaRzxqtgr330s3wjugNMbt7Pnr4kP1+L7FbGGZ6Rt+1NF1Ln2kBp8sTumbHbHGCyfKKfnA8/vBDbq6esdtvaNst2/WK2fwkrzMKrMUqg4oKoiL6yH6zBSUFd2EMlbVYI7JgVVHw2Jf8db3kf/ucWPpUCarJIsuHVrpFG4vSQapRIIYom3ld09UlKtsyKn1QAairCpe3X6X0naoLoCgKlApojQSoltbXpC2qIKqIQYMRhCmqHGgKSRDSAbIfj4Tc0MEFnjx9xusvPeDiZJ7bDpauadhv97imQ/eBl197hdWHT+n3HckFSmBW1BQRdBzb9+C1xzsH/YAaeuxMT9qxoz+v1ToPnqkJhRo3+cNwkxKbSxBdsyDyO85Fttsdm80a7x2ph9lsiU8ROtDa8KMffJ+XX3qJs5NzFrNTUIZu8Gxvr1lfX9J1e3YnS5rNiugdSluMKWl2a06WNYv5TDaLKAK/xhSM9p5PnnyIi5GLiwu0MZNkWIryQF8WFf+fr/0h/v1PE1S/wEMe9JQ3wywllRKgsbYk0UoR4AND76bEk6qk0Nm2UR8S2bIs2feOZEQORwj1MAyOwkJRGEqtJzRLK1GySEbhR0h3PLF8TEOHKSAYvnxDymLqo7koIyKU5DmYzWbM50sK5dEKHn74iK7rsMpwerLgG9/+dbZPr2lzPLNrqCmwPqLzvfMh0qEorMdmYn+RKnH34bBIykuPSo6K0TUK7rb17nQ0RgUQpXKLvSdGT+8dprB0fU/IaJwPV7z7rma/23Bz7xmKgtn8FAI02zW+7Qhdh44RgsP1e1zo2DcOdXpOCh6rE/fvnWGtQWXJlpgdgVIU27+hF26v0pqgAiokPvTP+D+qv8Wf4o/9gqLw0x0KctxJIp4iqKjQ2hLpDsLyzkvMxkhZaObzGq00QYEpCtGUdoEQk1grZe5tUonB98xnc6qiYjEvMSoRvcOkNEkf+/FkkhSu6k63SmcZoQjayPTx1FmT52zCExBE+3S5ZLlYMK8XaBxGK548ecZutwOfOKlnfONbv0a32jI0Hb7pYLOnHMTQReV11wdJqn3wWO/BecqUMDGbxpABgfz8qNFTWo16l2M3xUwDpqNsmT+i14wUgKbZE0LABU+hNDYEtvsdGFitpcvUdS1t1+KjpixrKlOhHbhmj+taThY1pVEM7RatI207YG1JWVYYVTA0O1JyONcL+pafK/EREcTX+0DbNHgfedgt+L/xl/gPP7+w/CnHYS0wxoyljDyDyR14qdpgbEmpE4WVa5xUpsIZJVadSTpVyRREhP4RERpcWVuqqqYqLDp3nRTh0G2AO3vqQYKNXOBJpLoYp88fdF8mBEl+LkgcLxZLTk9OWCxmkBwGxfX1LU3T4LsBNQS++s2v012v6bYNw76FXUthSsGGs6am9wIQODzOO0zw6GHAWIUetTd1kuftoI02aZHHPASlspvYKIkpwBwTKDYWCc45mmbHMAxE5PmwtmK12oJRmbcamFczyqLG2gqyPvy8mHP15DGrq0ucHyjPz3BdQ1UWuJxHlWXNPpsgSP60ETORKHMZwbtsclSitKYoSh7E9/gT/BXg7//ESPpUCao2oxWoIQZJWIU7Kq3PFCO+dwQfIU86V6XGFnaScRKovxDkLkWUHS+0ztUkzOuamYm55ZUgZikHo7OEyMglPJzb1NiPgZRM3lCnBqp8Tzp8T/BIdl9WlJXFkNi2O9wwoK3h/OSM+4tTtvfu49qe1DvMtmP98Olh0U2CajkVqEJEB5mULqPITYz6zTGGnKiKraUavYRjbq8fTSFO6FUOMjEyCMTo5feEQEqK3g04PFFLm+SDh++y3685XZ4ym51AspzMT9lv1vRNQ/Seylri0BGMxhQltrAYAqU1lIW0DWMUFLmeLSjKmr7vaZo9piiyPZwnRvm+FETA/oXG8W8/bj5NSH0uh1xTNZk+ZKAdSNM11dkerq5mUBWUJnsdI7ElJg4ZTWLk4ESCk/uiEC3gk3kp2HiuwkkRozRBCW91auEeJ6lkSoBWspEeI+9Kipqx5WuU5ZWXX2K5WIj9agisNxustSzy52b1gmW9oKwq5mXNaTHjzMH/7//1nxC1DBaMMlAB4c4a79E+UIaIzb3NpFKW5AoZcRQbYKU0fnCkdDywOLbW1GQbLOBuzNqRPUMYslOPxhNRQwcKyrKECH3bsb65pShqXrj/MqUp2W/X7LcbIFEYg9UKrUTpoFCywXX9wHaz4tHDD6UNGj1RRZLVnFbz7F0uXZu+70lTKzzgfEGvfuUXEnef/kgf+evRNVYSd2M73WgxibCqoDKJ2aw6TDNL4Irua/CkpIQm5T0pZd3iFCkLy6yyKBUJ3h2KITWiOiKAH1UaQ/rQ2Yq5U5C7XNNpK6EEyGkIulqWFa+8/DJ1VRF8oOs7YnB45ymLEjsrWMyWnNZLFssli3LGWVlzOsDf+5t/m2Ss0A3y4h+QQZYiBoqUKEMUaapMGxg3aIldkdzRxuCcnwagxkfNqGOgYOSEy3Pgc0dv8IMgWB5Sn+hzl6UsS4beZ7nDDmNrTk/OOZmdUKuC3XZNCA6rNKU1KALJOwqVMCqis6ZydD2+7wXdahpUyvrgCkxZYmyNd9IaVkrjwg1b/i7wFz7rAPwDHYeuJ5BRwJgCRhsKW1LXCmssNg1UJktFjUWH0aLMoRALTiVIfvQD3jtGhH4xn1MUCpInxcx7PLp/TCt3/pis0SXR1+PcSwYsRuTyoIovga60YjGf8dILD8SoJSRcP0yaqiEEbFkwX55ydnLOvXv3xeo5wMIlfuc//8dEXcj7yftOSOBixMVAEQLWBcoo3QGT32HygZifdYW4V5HSRGuQ3GIkWY0tgQOLZTxCFO1p6WLIoHA/DPg9KKOw/UBwgYdK0/cOtMGakvnshNdefIV2t8X3AjIW1jK0LUMp1DYNuKHBmIrCaroU6Jot3g8CRrQNXdsyDs1ZJdJeSb/Chr/63Bj6VAnqHZ0+mBxsEsJxiiETYzP3qapnzG2iyK2KUTpFawNkO8+cOESf3aaSBOysKgR1HAOF7EGdEXg1sojHRSYHc8ritWPL/yAvdLiBKsFiPmNWV9IuiIm279BKUdc1hbHUswXVcgHaMCtKFrpkvh/4Rx8+neI/pSwLlFFSk8BGKFNCp7E9OzpiBaKWfxtj8D7mqca7RwzxoMkKOTkNOO8Y3JBF0BVN14CTJEP0EJ/Stw27xZbl4pSqWFBqS9e1MpWaOXkpelReFMPQsV2vePb0MZv1Sqb4USivqOslRVEzDBLchlGMfchIeOa5GUM9lPz67fNJz/+yjrso+ji9Ocay/CP4wKyuCd6TjEargspI4j9qw43tbjVu1iERQpLNJgNGRmtZOLMT2h3i5nQ+xyc3JqfjM6Wm1u7ISRWJrMTI+NRa8cL9+yiga1ui6+j7gbquhQtuC6q6BmOpzQn3z+/xwvyU2boVG14Oa/CYQ8ckFBcdEzamqVUqC2IgOUdKCWOtyGgphXNeqCQZmApZci5FEb6W3y9Jfj/07BvRKA4h4LwkqHgZFOn6nug9ruvp9y2z+ZLz0wsKpYnB47NsVcgDmBqxri0KRb/fcfn0Ce++/TY//vGPhK5AEsWfkJgvTqjrBcbKRKlzLrfOpPOwd4Gn6pdN7PzoSAdsJ3elUYiurPeews4w2lIWYFWcEgOt1JSESTGlpkG+lItgrTSkRFUWLOZz5nX9sZhV6oCij6hkStmpRmVlBzhM+o88kLFZNG6iWkkBt1gIN9P1uL4heCet7EIGvqpqhi4KCltw7yh2zbSKS9dKj+t9ruYNUESEapAfyJQSbhggyRo5Isreh8N8AuNzkHBOkqBx7Q1REOEQA7umwQXh7EUvXbuU1UGs7emLnqHrcc4zmy0pi5JFWUv3ZOhFI3YYiN4LgzYFjAaSZ+g8fdvy7MljHn34AVeXl/R9jzFCZ0gKihqqeo5SFh8C2nvacMtT/skvPgY/xXGsqTuCASOdyuiEKoS6oREan7DsomCbSla7mCAFScpQQhVRSKZX1xWLWUFVFXnNkTg/HB/v6kAuXDJaLhKW48D13e8fnzujNSfLhXR9+4HQC13Iu16GFEsBemblDFOX1IuC03rJeTnjXjR85x/8k2mtHdfKBFmgT/5uItiU8gyMiPc5JwWkOEKZnNukrDMsakUq/2LpaOb8Ro8zE5FRFnDIrlE+D0EbN0iXWUkbvu96ggv0vcPYgqqac3Y68ODkFNe1DH2Htlo6E9FDcDkfE0KgGPQpiJ6u2dPstlitaduGrmsJQUCKUpUkpRhSy2V647nx83MlqMcWfOPVnqqVvNh5J23usizQPuuD6SW1CViDcPQmXlKegE45yYtJZHqCJAAa2ejt2CZIMrUneiZMCONhgi8nvmpMaA8fRz+S/5tQSfHCgwfM5mIV2ncd282ai9NzcajQBoOmCw5dWe6/+DKvnz/gokv8F3/n702LGgoZFFIyDT/OkBYpoWIgJUlIvffEwYkbUSjFFjamaaBg3BJSEgH5sigmtxUfREC47Vuavpla1bv9VqqyfH+GrmPoeoa2J/SOB/cLSD777/aQEm7oIUUKo4DI5uaK9955i+/9/u9x/ewpg+uJyaAVlOUca2qGwaOt3E/vnERARtKTEnQ8+BP64c/9PCH1CzvuOkYdITojIKRG6Rw9SY+EELi3OKHvBkLwWJWw2mc7RtnEQ6Y1yMYvSa03SYTylSHFhEFxslgIIjiGoDSfkCThcEaRg6qDzgWWypu7PGWjBiXjT4vUkBK7Xdf1bJqB5AeMNcxmCyHAG0lSXUjMbEE9m2OLgtXNI6qigDHBgGxUMQ7gyCZvs6mGyJRJQue7jmEYKKuKKtvueu+wKtf7KjJ4z77Z4b2jKKVFJ8lQYrPbcrO+EX55Sgh5XRQ+fE6iwuDwvSNmtNYohdXifqUSdG1Ds5PqXEj3Gh8Djz94nx/96Ef84Aff55133ub87EyuV5CEu6xn1LOldGqyy1XILiraaDaD4+1fkiGp4+OwJqQMZo6DEcKt9d4TfGA+K0mpQTGqMgRSSFhtpoR03JJl0j5glZ6cdFKEuqg5XZ5wenLCbnvUCVGH0n70HJ80HcZ8NH9NZ1OSSbJv2pXzRq8kQS2Nod3tIQpXGwKnJycUlagLGG3xKVLYaord2xy7I70gkYhKYUQjj1zXYaPcd2LWikxBCvR+kAGduhKx91x4hRiIWabMBUebB0PLqppUCQYn6P++3ROSTHwLsVwTnKPPvPHSFri+zwm5QqdIYTVFpna5rqPZiUGFDI7I9w3DQLOX5PT73/993nrzTdr9Hpv1m6MSAKSOMKsXFEVNiBHnPXvf8jRdfg7R+CmPkTqhDqCVdLLEpEGjScHl8Q+JNecDKZpp/w4x4FzEGGn7KDTEwKysZGhyXiIWo0dlXO6Y5U/kfEHaZ0IVSIeOVRS76KTUtF4fY69Wa04XC0iw22whehkq9D0vvfQSZVWijJWiPUQqbZidLLk4OeesS2Lb6o8UWY5a8qM2vE1gkgy7yvMe6V1P8lKcaGOoMz92cI6EwqYEWsnQrvdZR3rkmY+d5Cz/5HuJ+ew0pb3FO+kGAFhtGHqH8wPz2RKWiTCbQxSO7dB1YrXe9WLhqkEpsfkutMWqhIuOoWvYrVfcXD6jrmt2ux1t25KCJ7jEjFwIpke06T8C/jc/MXR+Bh3U8R/5zzHRS4noBXa+AyWHwGq14vUvfFmCrG1QKmGVPKxj63K8mCq3ULwTCRhdVPK5qFFR8crLrzCragw6+5+rXHEcIPuIENwxo3ezvIY0UXK7dDrxu2/nq1/8EtF5bq9uwTtsYbBFKWYASngzgSQcEmPYbbf86L/8DqWx4P2kMGA/klhYBcYL2qNLRUiRru9ot3t8cMznc+bzOUbbDL0HkgpEAm0mLRdZBN6ngPeK9z94n+vbG3rnKApLiIkCaRu7JI5cvuuFLxMSFssLD0S+vTRCqu/bhtXVM1T0ED236xX/5T/+p/zDf/gPcM5RVzWzusbHiI4y+Xey31PN5+I6k6QFI9OOee+ymno246pc8re//GV+OVJUOWIcN+eMfoZAiiFPjCrUmCRlvmRRVPSDDOgFFWmHHWpeyeZqJGkXyz6LzrVuCIGCGqMtENCm4PT0XK65zQNUSjTtZFOVc5PHKxKTeNHnzHlChUbS+1i6aHWgGozvZUS1rbWcLBYynJgHwY5UzDBG47qeN37wQ6wxBO8kOUs5djMvMVeCFCGK+UZvicng+p7dek3TNixPliQlaFTbd1RIARVjoOv2DEMn3Y4kaHvbNTx58pg33vgR77//LtZqhiADCjEpfIz0vZfkyidSVFhdcH4C+9UaVcviOBIJri6f4VNidnZOSpH333yTv/N3/hY//OGPuLm5paoqXnzxJXa7HYNz7HrHm2+/RXVyxsWDBxR1xWQVGKRIUOkp5/H/Avx3P4eo/CnHVESNm0ychjfy7ZFnPEZp/aIm96ZN15J8R18aXrp3QV3LEJrwVAe0KXJCkEgasVA2Bu8cWlnKIsdxdr7LuuFSSIEkxohDV8re5UydCOlGGCPWtceHxO6IfMUMXAgHvLRakP/STgXEYQjr47EbvWdI8tyO0lTkhMN7WddUPEgV+aGl61uur1fMFzNOOKGwJSFIQWWLAud7ilDSNDt8RppijLjoaLs9Dx9+wDvvvIVzPcaI/E4gCeJPpOmlo+R9IvpEYS3LxQn9fk9j1yRTY5RBp8Bus2K73XBycU/WHu9JLrC9veU//f/+v/nOd75LXdecnpwyX5wK1zRGjI3UQaQXbVmjjCgAnKev8pfN/+FzDNBPPsYYSEcdofEY8wWdJBFsm5bdvqWqC5r9BoPj7GTGybxCZZRUeJqGwljJFwaHqS1aGwxG9quypq7mlEWB712GtXIhn464+2OhlISOMiLriozCG4XXGnWk6zu9pxz7znt0EhBKW4s1BXV9jq1qktFi9atFJlOKMU3XtPze7/5QBtpUYMgqL6UWO6Axzsd1XEXEWTMGAomub2l2raDl1opJibUMfS/AkC1JBJwXabSua2X9RfazmCJ93/Hw4UO6oc80i5wfeU+XAsMgWttGC7dZOquaZT1npgrun5xRmwITwfc9u+tbamsptBLeuxaZqv1uw/X1Fe+9+w5vvPkDHj58jOsHCmPQOYlmCMxdZI7lVf0l/i31P3puTP1UBHVsf443S954YtLeAJSP6JBQWdZAvLsVTdOx3myoa8vt/pZ5aTg9mcm0v7V5EdOZ92cIQ6AoNFGbjAJ4ZlUtC6HKEDdMiBOQ0dQISjZ4pUWPVUqjyMhJkSk9CVRB8mWB985DUWCtxhYlJ/M5Ra6EhLowTq8K1b9vO958801QCqdk07BjhahtNkaRqi+FBC7Q7vb0weGGjpubK+bzOU2TMofIknIglr3INuybHYVRk/POZr3mxvX8+Mc/ou9blssZ3ouAc9JpGvgS7UGF2reUuiTMPDfPLlGdo92s0d6hk2d1/QzvB66vL3n3vXf5/e99l/fee5e6nnH//gPq2Yzdfk/Tr6iXpyhTYOual195RTTTMmqTQpySmhgj5uQhL/+5vwn8Oz8trD6nQ1okfdcDWlxLcpuczN8JIWUZr4R3gcvLS4ZeEOaAx7cdzCsOy5aQ+2M4tINGKQ+tZRI5uoROOuvRIkVUlHgMjEng4RhtgxXTOAlEkUiSxVYQeFnvc1ynRPQBKo02FmuYaAik8RnJmphJMbQD3WbP22+/zTwZaYclcUuJatRy1YJghIhK4PqBfh/xPQTveHb9TCSctCCqIUS0taSU6LqGfmhJRMrKUtUVVVnhhoE333yD29trIHFxdsYwdGzalnEvSFHJoIDSuITI9ijYrmd8GN5HJzGa6JsGUqDd7Xj09tsUSbhqu/2e+xfnPLh/n6ZpafYtDx8+ErQgJTywaTvapPj1b3+LL3zpS1zcu8BaS3QiLfSl2Sv81Z/iC/15HpNWbtJ3TUpSwmRuhkZn15aW4DUxDQTfE4cOr4vsruUorMZalTcekcWJKWTkUqFNgQ8OlEYrK0lEjJik0FM1dXxyssZqQ267ju30TCtATa34kW83xm4iHhzGjM58KHFomxCvJNq0BKHNtE3H/nbHO2+8yVxl33skARB+os2dOUk+LJrQD/j9nqg8fd+yur4WeTMVQEHbtEIjMIayrGnbFq0tzg9UdckiD/je3Fzz6MP32O+39H3LxdkpPkZ27Z5xIHx07Em5PTOkRLNv6eqGq/SM7fUa5RNNuwOEN727XfH+D3/Ixfm5xGyzZ31zzcliwWxWs15v6bqBrvcMbsjIXmTfe4IuSMryxa9+hflywWnt+SLXn0tc/rTjYwPJKWHy/zQapeHy8hk+CBjkh4Fh6KisIN3jBLu1Fpc6fIxEbQUISpGk85B2tKQOtLIYZSGKDTi5wZqjT/ICQCVzJ2kOcOhWIZGr81D12B/IDS0BuGKk2zegNFm9kaqwzGazqQMlj6si+axxpBTdruH3/vm/QLlImhBU0Q43upD1PbftFTJ0TYz4oWfTN4Kst3uS0hTAerPCWkNMMvSbUkV0A227F6tsFyitJXhH0+7peri9veYHP/geZZm7BjHmEUaRVPPBZ36oPJ+2M9TzJc57mt2GH//gB/T7BpMk1rebFdvbFYvlgmI+E4ez7Zai1Lz/3jv87u9+l+//4PsE56mKEmOszBFlIOTxs2ckbbhvvswZ/8pz4+lnR1CngIMJv0yy5EztJ7Klo/fc3qzohyHrysnkbCn3OSdzIn0yDCOXSeNidlxSBmNkwTPGopJoollrIcEhNzgkzgdB4KMqf/o4JBfj94tshyIGj0Kmu0325hZ+Vf5pncVcEmzXG9zNlvVqRR0UKop9aspt4sSoKRkEXfWRoevYpYFm6Bhcy+3qhrIsxJbVB6wtQSmK8ga04fTccHZ6wunJElvI9737/tsMbUPX76lKy+nJCc4HNvs92hi6jD6HEEBFdITGNKz1iugi62c3NM2eoe9IacB1iqcPP+Dk4oLTkxO+/e1vcX11w+XlDTc3K3b7FhT0g+fd994jojg5P+cLX/wiJ+dnglb4SMxDBi7LKbXvab7zf/rX4Pn2up/LcazBGEKYhLNGqSStOKA0KJgGZ/bSUvKeGAai85L05/hW2a+897K5y6okMWyMEW6kNhQ2W6Hm6WCSyLKNKCkcnq/Dop6ft4Ton+ZzGyeNxy+Om2LMiegItgkBP05IfshKEM573nn7HXaPngm/SAUsMQ8aZTcwyIWnDMfpmOibhlYZOh3pmobtbsNivoQWcYELiaIo6buehEbbggcvvAQmT3ZHoc288/YbGK1IyVPVBdoklLXs244+8wBDCEJj0QYVApbEbrcj9gnX9fhhILghu5zNePjB+ygVubh/n/v37/Mbv/Ft6tmCsqz54Q/f4PLqZlyQRA5tt6f88ENefPVlXnrtVZanp8yXS5QXpOHk9oaSv8svQ3H18VU3fz4dviadPVlzhM8r9otu8MgElGzooPPaZibOu0Jnf3SJO0nUZQDDGItCFCim1v30nDDt2h/bGsbQzVq0sh+MVKvxG6TB6rxnnLIev5TyBhLzm4tRiqTBOd584012D58yuIDRIutjtUzeMzoDJTECUAlUSPh+wDUNQ+zY7XdsNiuGwVH1smHutluiF55jjNImLcqSFx/cF4ODLBv3/gfvsVuvIQVS8tSzkpjAWk07DDR5GHjUf9UokrZ0SrptvvfopPDtwND3xDCIwoRK/OD3fo96NuP09JT5fMa98zP++B//o7R9xxtvvMPtzYrHT56CRrSnjaHzgS5ETk4v+MJXv8J8sWA4SbzN0z9IyH0mx0fzhWlfTiPbU6SiQpCkKHiZvPfeU9kxgVFi+JN5qn6k6alREVRmV4pC4XpRmdEYdFIiTj++NiNnOysGZDMIsg7qFJfj0hvjHeDrzt+yydDgXJYsV2Mdhc/DS5J+ZC5r5tzdXt/QX67ZrDbUCWwMYkQxqmiMr5OQ9xhFEjA0Lc5Gbps1rheQr6xqQNF1LUUhQ37GWoKP3K5WokBUiHOU0pqyLHnr7TcJwTH0LSE4zk6XxBjp+oHOuUwTFzm2FEdZq0TX9ey2O8poKPrI9ukt29Ut3jlBdn3g0fsfCC/2spBuq+iGYrXi9GTJ+fkZDx8+ZLfby/BmIci31rJmFfWCsvwxL6n/lOcN9/1UBPUjBdHRHT26iWncNslQrni7jxusGxzOBWJpp59USvzKGfpcZecpvSRci3FASOuRt2LylN9xfSNnc3dudOqMHW3q6rC4jj+lxnPNQrjZkUbwWEGBQRAYhTiMPL15wu7xFX0/oJXBpAhGU2g1BVnKrSGCIIztfs8u9uyHlqFv6PpOqhbnGTrhRGlt2G42VLM5p2dnnJ4usnxE4uam5fLyKX5ogYQxiqoSF50heHHRSHEaThtSolCKvrc0pkVjGLatoK3Ro3VgKDW3V5cUVcniZMmv/Mo3uble8bu/+30uL6+5uVlhq4KUFN1wgy0qLu4/4Etf/Sr3X3pJ+IcgCWoIuLxBVgHSjyO/DMdBIHrkqzE9gMdBPXk0K5nkl0Q/bziDR4V4VAuNChSalAbyuJ5stkraHYqcqObfa42ZOK4pMVnyjVy+n3D2U9E3LpATNCpnPb0XQXHURLqfXD3IOpARhl3P9cNHrD98IhOXmU6glMqxOybZWTIsc7a7/Z4WQ6MCu92WwQ2UWS6EhOhDljLcUJQVXd8yn9eYUuyKu65ju2m5uX7GyXJBTAGlE9YqjK0IMeDjeD+EDkCMOBKD00IZ6Du6/R4/yGCUDw6tAqvbG2bzCmMN5+dnPHhwTzjBIXF1vWL9zrv4KLIfykR8gpvbW548fcZLr17z5a9+laqqMbVCRRjmFQ/Z/5KJTMkxxvBxRqcQNZVje2Lhmgptg6MwFzF/UedI/vj5lAC01kJZ5m6R/HarTS6q8gjRtOT+xKCVc50GU/MrHK+509/UYTwAgVen53OKXenIbbc7nn34iM2HT6iVxK7JusDSudJHz3VO4lPEdR1do+g8bLYbUQqIMrmsUPR9x8TvBvEXV4mT5Vy6AkgRttuu2O22FFbWCGOEMmVtTQR6F6ZhrBiyi5+CwfQ472T410f6fUsMgeh7jDWYjeLhow8xRvPySy/z4IUXuHhwj9def5VvfevX6ftAPwRuN49lN7JCRdA+0AyeR0+esFqvuf/iC4Sy5g1mP1dMfV7HFAsZdTd6NESQBNUN0okBe0QTkTVWOOZMw8cpx5/K1uiqLBkLn3HY6RNOgGkNVYcoOxahEv3Tu8/MhLiNP6EgpMOzI0mqwqeIzVrmY55JgqEfePLshu3DSwbv0UoUDASwgBE4OySnSVr73uO6jlZ7du2OoWvZty0py3C2TUNRGIkFY3BDYL1e8errr0suYaxQTYLnBz96SAyDDOGpJNa5mbOKUYSQGCfrU8z61kEMVfquo8GwHRLDXlQlxqdFkXjy6CGD7zMVEmbzObP5nJPlgi+8/hq961itVzx9ck3vQjZiEFAyKY26uSEUDpf+2XPj57kJ6mGz+wnL0vHNTGOCmiv7NArHarpO5Bjknh8I04W1pNSTUpza8kmBNUVm90nyVRSGwhqpPDggYwcM/u75Hh8jL2pEfiW4UpbXEXmokEYnbyYUFJWIOuGTcC377Y5Hb7zLzfuPOEHTE7GIvFJUamQBoDIKlWIEH9muN+y0o/Edw74BNG3byjDZINPMRVHQNXuC67FWM5tXJMiWgT1Ns6XQGf/LfEVjFMvlnNVmCwgiGJQEmgsDPpRTy2nf7MSVKHnAUVWG/V6m7Op5zasvv8Sf+tN/CpTlu9/9Hm+//Q5tv8dmGYmnz64Iv/c9XnzlVV55/XXmiwVVWRJHO8wkCfyrL93yp//YL4fcybSpH7V1gKl1Oi6cE8imFcaobGXqMoIaMufoMIk6FkuSbB4SX4nnAmMNtiwI3qN1LUlr9jJPalxoj4RQxjbTiEql0b/6+D2kEagVfXElOphSnOT3Kyd3eP95k4/ec3N5yerqhm7fsjCaYBQ6BkE1tToYPudCU7iZkabdsI8FrY7sdlt0JucrnJxMToistUDEWpk9lQE0hfM9+2ZLiD3Om0kmLREpCsusqhh8oB0S1ij8BD7Ic1/Pa9KQMEU2rAgywOWjY3AdTbPn+voKZRQvvvIyF/fP+LXyV7hZb7i+XbPbtww+EIKYB2x3LW+9/S7VfMFrr3+R09MzykIc197X9/l31V/g3/wsg/AzPw5rm1EKaxTWarQRysXQ9blFqaYCW/R/LUVhsyalrCPaWJnI1QpTFBRG0CvnPKnKlseMTjQHSSf1sTM5pAgwJp1MxeFhvVayJ+chmTDqqSoFmaMtz5HEYIiB4COXT5+xXq1xzlEaRTAiHq6UosjPy522spLnud+2tGWkLRXNfg/5unRdixukFdqGgDKGsirRGqrSIlSxPLAXndg8D60M5miJPa0URVlTlZZqMHSDgB1hPB8CLjjKqsQqS0gOpROkQMot5xC9mK1oxdX1M6IIvWGqgl//9rfYt56296w2W5q2Y3BeXtskbFK8+977vPrmm5zfu0cTXuWttPiMY+3nPz6KoI46uVIM57xI51Z69HgvdA+dyGg4kPmbQm28O6gk9r1jAmuoF4uDa5mFKdY4rMvy73gEVh3OaxKgHFH/n/jGQOWBQvm2rFk9dsBy3hJJ056xXe94/Na7rD98wtKIHrHEkCJOLj3qzrOivHRA+7Zln50p97sNzkcGJ+5hMsCnJnMYNzh2uzWL5Teoqjqr6ijads9ud4tWiVlZZnUNkcuazyrKsmC3b+XZjaJhrPP7dK4npbkYZ7iGze2G6AcgYrRmVlVcPnvMw6cPqeqKk5NT7j24x331Ai+88jLnF2csTpdstg3rVcd2u8U5kRK0hcVWFW1/yWPl+U7xEs+z9fmpCeqEOKmMNo0anWMAZKTKKE1pNHVhqWolCZiX9lMYvCRwKrt3xIDOwucqtyUTEWOLrI8qBFyrhdifYpkJ9XZaNFF35XhG/WVG8WUV71qXfdL70+ZOxa+0YkToJ5p+SjTbPY/efIf2ekNSir5UqNIS+jgJWX/0JVJMtJsN+2jYG0+bHME7rC1Yb9aT3l7oHc4bTs5OKAqNMeKL7kOg2e/ZbdcM3Q6nAtqovAGBNZZFMaNtRLu0DwbXh0nmpaxLludLiFDUihiEBxljIiTH4ASZ3e637JuGiwcv8mf/7J9hsTwBbXj8+Bmr9R6lwbmObnjCP/pH/4RvfOMbVEWBPj2dkEKUxRYWdfpFVl/5K88Lqc/1SCmidUFRFMCxS9BBZLwwRtwtNKTUY7XFxTAlqCrzpgSBFgSw0FIs+SQxo4tCpuZLi0ki1I9ShOCyH7mQ1VNWDiClg69ybrOM3yd6wuO/jxLU/L3yp1Tv7dAznxWycE/9WI06it3t7ZqH779P2HVoIlsbOT1ZkJoOFRLFtKiT/cbJGo9iQ9ipgUaL0DLG0nWdGBAoIEgiYYoFWkUIHudakpIkf317zdWzR0DA+U5MBwhZC6+gqg2VMxS9PPNNLtC0NpjScv7gHqun12gLOpKLRjAlBHp6t6MOBbv9LfZGcX5xn4uLM37rt/4s6/WO733/x9ysNrImRE3fOh5+8JiUFGdn53z1S1+i1JpkFMSSGV/8hcfkH+QYY0FrsFbhPDIQlDyFqehTRjDVoYiPWVJGpSRuYwAoirIQDWRr0UaQ/qK0WGtEVikm4QiPKJP8wruAACBuaWMM5cn9KWY/vu6OiiOdc5S2vFss5sG+UTt4dXnFo4ePiPseQ2JjEyenNezk/AqVUEGGXCIKh6imkCANA93e0wxJ5HGyQYxPMvmvQQaPcutXq0RKAe97ohcr3O12S9NsCGEgjTbQeCIapQNFpZmFiqZrKeuSITpQSTSCteL+i/dodnsGtydph0oRWynqumBxUlLNBbH29OzaNWqVSBZefvV1/vAf/jb1rKZpO37wgzcxeb4hREXoEjE2fPe732N5cs78dGCZfgz85mcbcJ/i0FpPwMjhvuZOqIYQHH3fTTq7Kne3RpOElJM8awzWWIwJuJTlzLKKjDJj7iB0K+BgB00UGn3iTloq5dBHj8NzMiKpU2p7J9keiygjyhLjejt+NY2UR4nL3WbLwx++xbDaodEMNmJnJbHrISmMTpNuMDlvCSRsEpWS693AxkGTZclA0fUy/GSUZnA9IQwURUFVFpyezElxICZDStKCv11dQXT44GhihzaakAZRjjAlxlrcILML1urszhWzsodmsZgzn81RbUDXwCCc98Joypmmdx1DDLT9nu1uzW6/xg0dPvRc3L/PV77wBea/OePxwytS1DRNmwcuA0MfUFozswNfLj58bjz9lAQ1HhK8I6Qnf/GoXXrwo01BBnG0KoRPlLU/VUxZeyzgwkDwbhLd11pe4+TsRBZNo7AaKiPC/i442r6j7doJsYeMdMY0uVVIJTQGajpKUD/hzSkZugpp7AvBZD6NIL86KlII7FYrtqsNvm9RKRJ1Qs8qbAwyLDNyn7S0AcSGzEubPyp8cAyplyQlQWHvclA0hn7o2GxWXF8+JSnhiaxub7i5ucEHhzEjkiez4OI/XjJflKhCUc8r2t6Rso5sPZ9TL5fEvqOal3RNQwyOmBzVrKB3HWoATGC3s1Qzw3xxzre+9Q2WJ0v+6T/9F3z3uz8U+0qlICqefPiU3/3tf8GiKplXBXa2yIWCvJ+0v+T6n/014I8/N+g+z0PnwmY8Di1/SVCNHXmhEat11gIdh5PEuEPn9n8MQVY+8r0ICW0188UCW+YiCo2xGq0Rt5e2xTnP6LUtBQR3z0flO5oiKenMCQoTkipP1hjXuVJPIjEzPpsis2OEP5eRLhUSQ5fReu/l2TAQw8AJSdr7+Zg4rLkdpICqNIQw0PseF5xYE2iNSEMpVEqUpiQlQVifPXvE4nQmqGjXim/5bk1Inpj0xANTWvoVSitmswJllixczXwxl00kQKENQ3DMlxUKj9LipMYg6FNMnpgczrUMHTQNGJtQKrBYnPNbv/lnePmll/nxG2/zxlvvcvnsBrOoiSFxc33L7//Od/gzf/yP8bWvfx1t4KvM+Q/Ub/xigvAzOsbYHYECbZS0+6zBDTLpb7N0kc0oTUJN1qZxnGlMovNc1rM8HBcxUWUAXrQUR/1FGJGxj2zaefGanqcMncaYOW0fW3THIksUTbzPia0aJc4MowuhnEZgv99Nai8+RlIBIfXUWjbz8TwUKXfFRD+T4LFaE4KnSw7nBklqlBSjSmsCTC3hwQ1sdhuePn6IMtD1PbvdltvbWwbXSeGYsjrMoc+GsZp6ZjmPC6oQWMwqYhjNOSJRK2xpqecVKgV22xVGgQ+JwRkCAzEmdISYHCH2tO2a7bZisbjHF15/mf/Gf/1PM6sX/N73f0TvPOPYrx8CTx895Ye//wN+/ULx7/Ev32TijptcIjsH6elrWmti9Gh7QNu1Vpgk3auxgzQK0AtwJYWVS4rZrMaWRbY8ld8tbpPyvVqrPEooRYiMYEueMGqLymjQkVNLpvPFMEo7jeVYms5xcmPyLmvijqOr4/6dtd1Tkq7p1S3dbk8axElpUAEzs0Tfi8JDTmhRMa+5MTtgenxw7JxnoxJxcAxhwJoi7xM6U65FOz0mTYiO7faWvt+jrXTN9k3Ds2cf4oMI5ROUOLwlh0a6BFppyspSFoaAIbmIC6I+YZSirAqKqpCOihUKoQIwYKzi/gtn7IeOfhikAFaeFAea7YqyMMzqmq9/5Uv8K7/xbWKAh4+e0vS95AkoUlScxdf58/zF58bUT0lQnxOAh++abqK2BltaVIbyg5KNyBpNWVTMZlWeQJMkYOSNKEQixJZFbsfHkd+fBzgU3gfc4KZW0ng+H+UepPxgoPSEpjLV+EyIq8polh6nR8elMX9tlJdQiDyC0opqPoMQuV3f0u4CD7DSmkijnEUO/yTJhkyJewKekIL4QqNF/lHJBLU42Uhl2XUN680tGNhuBdls2wa0/F65FmOVF0EF4UbpgrIsOFnIdRr6gLGGtmuYlwVFaQnegBJhi/l8RkgDIaps/7ijb2us1ZydLfjVX/lKfk8Fb7/7PpvNDh8Dfuh5/713+PrXvsSLLz5gNl+SUoacgcJ3vNi+99yA+9yOPGQxbXjHR25DjjxMrVTWDbXEqDOlRGNURWUTZ2enWGsYBvnx4IMASXqkjyRCcBBkUjqGIiNQdzfr8VzSx4J2jNuE1NISuxNypUAiTPRX9ZhNKj1yavIvyn+Osauk/b44PcGenuGd4+3332GeZswop4RjdMoZW+uSoKdcoErcBrIuKuNzJ7aDIzqSUqDvO66vLumzZqRMaweR5Tnif8lbli5KUSi0LqirinmsISHmFSHRu5Zaa2xpSMmCClijKAtNWZeyWEdHSpbge4Z+R9tobGH4wmsvMqtmnJ+dUdiCt+y7rPuOLgTC4NiuVzz84H2+8tWvYrTmVl3xN9X/gz/Jn/iDx94v6JhalnlNU0pRFHLtysJS2AKroTCwnBfMFjXe9dlQIgrtJN9z7z30PUoPiE6JiNl7VxEwefs9jDLpEfE/OpRSWWdRBkxSzIhYHJNWcvF0QNIUWZpKiSwPo5c3Rw4/+UEprJVJ4eUJ3jne+uAdKlfxkq5Ied2dzuo4UY7SJg7B45MnEElBAIkUU37CEpiRyhBxQ8d2u6a+qdg1e/b7w9qr4vioiEqM3ImAVjLNPasLKlWLA2IS5HnoBtq+wapEUVoIBV2nsVpQLheEyz0MQ56uDoTgCK6jazdYY1kulnzr177GvJ6TgOvVltvVhifPLrHG0HcdT588Ju5n/K6a82/8guLuZz0OMlOHSDlGUVV2SyyLgrKMsu4YTaELFouasrIZIxKN1DSJzitUlLa2tiYPuErimqI4Ko6p4mF/HGPqAFgdPz+T7ngG2A6d1mPa1vTGDjStnCMwUQSO8ocEpEgIYgphszrFru+IrqUiUmjZL0WnlencRsvi8fxCDHg/4KIgqEYbyFq4kLBWEv8QI+vNLTfXl1T7iiF4NtsdtzdXhChUrJhUNmcZr1UQSawCloua0hf03uN8wGqLH/IQWwoUM0vZlQQn0lUo8HFAW0WBEUa4T6CidH5dQd/taPa3LBdzfv3Xvk7XDyileee9D/BZcUhpzQ17/hb/jL/0nJh6/pDUSCiabvfRZp8XkgnkUUJsLquK2WxOxGKHgC88KlXMC8XZ6ZyqKpHbnBeq8YYjdAAmFwkwSYtdahLXHiFTc/gZNVb3h8AbHU7IVezhAUFuTv4Zjej4aWPzJq9z0I0bcG6VaiiKgsXZKYuqJjjPB9dPmZdGEoNxwjsvYFO7NsggiXMDsZBhDe8iNntAM+YXGcWLKTD0LfvthpgC6/V6siRTOtO3VDx6qBIJjzEy1VhpS1mVDC7SdTJZOrie5azEFoaiKtFG0MCyKkgEwEMyRN/RdztQiYt7Bffv3ecPffub6GgJwfPBh4/Y7feEMHB1+ZTVzTVts8+xIA9uTBFvHN29zXND6nM7kojMq4/EcP4iByREdBursmK5XBKCoSxLqTCtpi4UJyeLXLWrnEDJBP+YnLrBgXdC91DgrGHoemqTle6UyklgZDSxO+ZECXAgi9R0ekdJ7aG4khcYdSi1sbLJHw34jQmtyshZNau598J9zpantF3Hd9/6EaeL+9BHkhCxp1eQcwhZrziJfauKE9c2xIhVhpj7sNoKIV9eO+L9wOr2WooZH0RRQCsZaDgaUshPOzItPip0VJCtOYfBMzhPiAPoUlDuZEFJ+28xK2VQ0IA2UZ6L6HBDS6fBFoYH917kS198haqsACis4kfvfcjtToqtrm24urrEDwNqPqfTHb/P9z+T0PuFHSkPspFtDrVhVs84OTklJZH7Kq2mMoq6MlRVKbJTSbSLfQiAgaQYhp7Be1BQKkWpFV3b0dUlRaomxH9yQdFi63uogeQvk3tN4sCxTocH7ngQSSl9cBIck1Olp7iV2M2ritHMF3PiC/c5X57SdR3/4s0f8OL5KSqIRna+KIc/R4Q5SpyE5AkmZEODSDJZHTHGicuojZxh8I62bbi9uWbX7KW4Ih3lz+n47UP2fNdKURYGW4hxRUzgQ6TVGh86rC2whYJoqWYVVmlBdPP9DMHn5ydlC+meodvTaE1dF7xw/wGny3Nubjd8+OgZ737wkNvbWwpb0PQt69Utff8BPfPPOtp+7kMdAz1Hx3GBbo1luVySKAhBepWVgZNFRV1XeRtWk5Xn4fdmdN57MnMUoxL90DMroNT2aE0dwaaj9fAOLZEpQR330wOdipxbpGmVVpPSSQboRs3o46xISa4gnG7LfDFnZku893z4/hWDN9jcof3oFZI9Kk6uT2S5Th8DPgZBaBHgDBXF3CEnzTElmmbH9dUzbFEyeLHj7boe6VKNLxanOJOOd8AYWM5rsVwN2coazW63zwYWjqoqKGcFQyvScUorfHS4kJ8PAyAJig8OHwaGvmG/s+wXC770hVfEOjVB23Vstnt2bUcI0LLnez9lzX1+ghoDd/zEY4J4QFGkgvZTzaGUpi5nvP76F4XrE8UGq7KW0kQKLRc3ZF5F3/eTD32MitvrKwAKBaVRxLJgc7vhtM4ix1oWEwMikZIHq44rt5G7J0bJKiO1TAvhYdxZJKiMkWk4tJr4UTHf05QTyIsH9zlZnvPyCy/Rdi2//cPv8bVvfgP18BLVDDni1QQSxSS8rxQ8Q+qxsxmFLdh1PTajEePibYzIZynAu4Fmv2NwvXhHW3nPpT0MPIzIiUo6I1oytGMLy3Ixpxs8RufEHgCPLQxK1YKixoEYHIWuslRLIgVP2+0ZXDd1ix88eJk/8kd+g0Tk3sUpb73zDu+89zZdc0q739E3jdj1lSUxCELzaDHwH/7pLf/r5wbV53OkMCCbyBEBfsqREjH7Xo9Damdn57z22uu4II08rWUBtMmjkzsaGgl45xjJyt4FercnkiiMIllNS+Lm6pq5vZ8lfqRHIOyMUaJENEoPJ5yRpzF5nhbRaXtHZerJuMFba1HCQRD+KIeNPinAKpbnpyyXZ7z+yms0bcN//jv/lD/2p/4kT3/794i3m0Nba6zmk7zH5AN90xKriCpkKCD4QFCJDGFMxVzwHjcMGKOJyYlQ+5QEGA6OAWn6mRSSaFKi0Ur4j7PZjME5mZS2o8tL7jSYAmUNfdNgtMIqKIxiNpPCKwWPGzoSAWXgZvWEk+WLPHjhlH/9X/9XmdUFTRjwDyO3qzWb9QY/OPabNfPFgq+aL/G/S/+TX2BE/uzHx5DKHLcphUm/NISELUrOLx7gkxVUQskAik4enUSRQuS+okyQx0hU44S60H1QSihLpWW/3bAmUpydMZ/Xk7wexCzsbxj5zscbfsqxO/EJkeG7cVqfLAyuUnaZUvZQ8E0fR+9dgbKG8wf3OLu4z2uvvEazb5j9V/+EP/pf+xOsf//HqNWe5I+S1ImelcAHXNfRm54409TzOd16J5bEJjF2GIwxWCMGAjE4unZPiC57vYOxotCSpuJyLK6Ey6+UrL9WG6pS7C5jSgzeiYWpFYRV5a3q5PQEYqR0Vji/1hAqkzVqAzE6YrR0vZi5KMDogpOTB/xrf/g3uP/gMYvlghQjq9WKJ88cXdvyFXfFvzdb/mKC8ec4UjIca+p8EpJaljNeffULNK0Tulth0MljCZRWmMTWWoYsUZlSLsBT5PbmRtRSlBjh1Aq2s5oqLSkXc8qyGJGoKY7GpFLidkQdw6Teo/K6muKomToy+A+MVYVGJzPF7Njcj+S1LL+U0hpdwMW9e5zVZ7z84AX2+x1///f/OV+4fzYlmjKUml89O8ORIHrpRnjv8JnCEEJOu2LuZihBjmVfyXtLitzcXGOLkphkoEq6U9nhT3aurIIksSzDrDIYaEyZ3488vUZrjIWQBnxMlDNDvZTiSqMY2o7dfo+yhlE3VusSH4Si4FxH3ymaZs1Lr1zwzW9+ibOzU+7ff8CP3niTq5s1l1c3lPvEb/4U3v9PQVDF21ZNzBfxbrcqiN+zgpg8KYkFp7GGi3v3udl+iOvFcispaEKLwxO6nsW8Zj6vgWz9GcnJIlkoNlFYTWkti6rk6ZMnPLg4zRdYZVtUL3EYNQcAVx0QhvwwjPD+8eJnUCIZrET2YPADm60j1AVnyzlwt0WhFNhZxWxmObk4RW0NRV3xZ3/zt/jtv/l3cLtnpDjWdJmdEsloRaTdt5y8fJ9qXnK73sgQyngyMdL1PT46FnOpHo1VmBgIvkfpUlxdMlKXVGQyUCcRM9cXhHN2/+Kcp5fPqEtNMGLDGZND14Z206FJnJ2e8upL55Q56UDl9nQHoTC07ZbdpsLaiuXJi3zrW9+krAy92/Pw8fu4vuPq8pLryyu+/FVRFIhJySTlPlG99S+/kgcOsh0ZkVdKrlFhFFpFBi8PUtPKmJD3if2u52a1wxjFfF5QFYpuv6MicX5+OmZkB5Q+D/2FbHtotKW0Bk1it93SX5wSvCA6BnBIknFAwQ+LoAC9d+dPx2GXEdkXXdW8KFnY7rYM3YazkzkvPrgAzNRanST9jKawBVhNNJpqMeOb3/o1bn/wBu5mgwry4kmN/KyUZXNgs9nSnRREU6JMlodBkHyAQKDpG3kWVcSWGuUtikPb12h7R13g8H6jICg52dUkCqPxTv40qmDkpGmrSUnjnOf6esMrD17l/HTJbFaiTJacTp4UImkIdAZury7RseDs3HJxcco3vvlVfvv736MqCgpjcNHxD//hP+RXfuUbzJcnPA1P+V/w7/Af808/0zD8tMdUR6uDmnMMHvGa8OKQNiRubtY8/OAx+65jPq84P5nhuoYw9Jwt5hRFQQwJ76PwVAuJs8kyFVGwmFU1CoVzjs71zFWJzmDA6LWdUpZUmqyqD4jp1DLlOMFOudgX/qbOk9C6UNKRcQ0ni4p75yf518nviQgfVheWohBlDE+kC47f+PYf4nfeeUy3bjl+xajyR4qYmOj2Db3uoVhwfnaP1c0GL5tH9j6M9D7R7zrKsmA2q0TVQLnJ4VCrArTE8/Su1Ehpki5KIqBUorQKm01TDInlvBBZNSXFZqktelYx7KWQMyT80PHCvVOUEapLabUMtriILSwJj/MdSsnk9WuvvExZlNRVxe9//0dc3ayILvEWA/9D3uGv/wLj8Wc6EihMBsFlXiIEaf06X9K7gpgU+33HvulAKarSkHyHb/ecn85YLEpB+PuYQZaMwSemln/SMii1qEv6rmWduz4vvvAgn4iekr6xVRmT5ljn9MCdPsb4P36MzGhtNLPZPGdBMvBqjKRPkgdLUaatxS5nLM/mvPjKa6zWKyhL/uJf/je5+t0fsfvgCeF2k6Usc1aV1NTN8sNAQ0M6rXjl5Vf40TtvZpQflJZuVqFq0YnVCqLHJ01MHh/G/SPkLOewh4ydOAW5wxum578qLUUpTpnt0LNMZe7QQFABXUB9sURlh8q6tvTRgXMiYVcYVK5NovK4pGj6hH/2GDubs1zc5/XXX+Xe/Rd5/Ytf4ns/+DEfPnrE02dv8Leu/wn/g+eE1PMT1OBJwQtqarTI8ZCyN7mgQt73kNGotut59OiSt9/6AJ3AFMLnm9WKeanZ7zZoFZnNSoAs0C1kX1S2GVMqS/7oPBEYs3ORnIchojFZGSfmHCtAOrKz5LBIStfhqDeT9diUkhvw+PFTkmu4OF+ivvAKRX0hQ1tKglButTADB5UIhWZ+fkZSotuaO/kfh+2joAphCFkTVgIixIhNcdqAQlIkF4ixEvHsIJ7DIQRwTnxyjcrosZ7eY4wBFaJwUBEe63xeZ3egJBwRYxnDs+0bKmN58OBVilL4iZPoMEz6kn23Z6csYLFqzv37J3T9izx8fB+rA0+fPeb999/l5Vde5ktf/zrn9zQ+WKFf7AdO3149N6Q+r0OYZoGxHfrRQ3IfGUZqe8f11S3vv/ch1s7wyZFCDfMyixM7QhAZF53b/MkzOYNqyA90jlujiVpaKk3XCqKCPGxpRHlIErOje0peSI4YM7mlk2M5HTpLMhxg+eCDD0mu4+WX7rNYzCirgoiIQctkaLb7VYmewKATxdkJjoSLiZAyJpQQBywNOhpSyGiYj7jO4Syo0uRpeCH0Kwsp82LvDkZ4juZrcN6hS0lMlJZUKyUZdLLagE7oQsskafZNVyRBttTYDUn44Om6RowqTpfUdQE6EtUoq8RED/JO0XcN280KlTsvr756xrd//evcrjasbm/ZZyvhRx8+5Pz8Post/Pf4U59tEH7KIyr5+Oi+qXNBGUcESGt2mz2b9Q5lLKubFZWB6AeSFyRQROElZrRWOB/AmCOVkqw5mfmYKKEMbfcNnigi8VKV4I4SQpVG89PxM7nAymihLLwy3CevrzKTShQD3n7rbTSO1159kbOzJVapvObKMxIzxcCnwJACQStmyxNMYQ9+6SOyTIQojlvSLRWL02gSbvDstjsZv8pDqinlTlnSgkpHk5MXsdcclVJCjCTfYwud+ZNiXpB8JEWdZXlA5U1airKAVsKvDnlIaLT/RMHt+pqL5Snnp2csKst8XhFVzFrMGeX2gWHQtI3FqJJZeUJZnXPv4gxrC3a7Bud+d7J5vc89/gJ/9hcWjz/rEeNxPCTprh51r1KUBP7ZkyvW2z3a73UNGQABAABJREFUaM7PFywr0fec15b5rAQl1MEYc4GjJFEcI06TZdayi9248Y4czjgVSx8vjKdzmVr66aOPGSOH1ZBVizIdRBnNw4cPuTifc+9syezsVL7/iB4QlUZbQ7IKpyPeKGZnJ7z48itsfvy+0JjkJCdAYvp5L4mjaweGQhJWPVoOpzgVbj4N7Fuh9xWFwVaGYegpSktKETcE6vkckwGHqcOtVW7OCXUQZI7AmIjRYy4VmdXmAJSMnV5lpVD1kb7rCEQKaygKS1UWlBaqUmc1nCCzxLpkGBrS/IzCQl2WPLh/wa9+8xssF3Mqu2N99fyYev6Q1NHfpdLOwtDS15Ebki3eUkrZNSqw3TScn5xgTfH/Z+5PQ3VLs/xO7PdMe+93OufcMSIycqqsLFWp1ZK7BlW3DOrGbeFGRpK/NAKrjTEYjI2xTWNjsL8YjAcwbbA/GWywscHWNxljY2hsaNSoVahlSa1SV6mGzMopMjLizuecd9h7P5M/rPXs972RpRsasqJiJyfvjXum9917Pc+z1n/91/+PMZXxNGKy8J5S6qX9p6hgyeKIg7MLcmOtw3ppu7dhpqJaXcYaTFYkn/PrkN1KeYFLiKE/Q/7DFBF4FsFl0RA8HI6MxzuomYcPbnj06AGtedVCtxhBAWItxFqwITCXLBtYQxSqoHXVqAZqdTjVTTsdR0HxMIpCldZ9wFltPSjKVKogy86JUHmpGYrRQRPlwlQouQjUj2yIknib86ZgFFWmsj8cqSXRrTrWqw5rI9CSZEkyqFWE1+PM5E6E04lpPLBadTx+fM2f+pd+gd/7vZ/nt/7Rb/Pq1Qt+9NGP+NGPfkToN2B6wGK6Netv/+q7I+4LuqpuQvCHb1NtAZYih1rOhXGcePr0McfxyDxnaj6Sp5HNYHVBIwe4MdJ+alPHVdF568Si0QrihLHEnGUC2QDWLvSORQtVUf8FNV22Vm2LWn0ziHSa0YPeey8qAYcT+/2JeU768i7aBUZ7CMYQS2UuhWws98cjKau3u9JgJOmwi2SKMCOMDthUJdlzHnCs0jXAWj24z3bCtZZFEi7lREkWa6uaT2hCmZNYcdqqyavEbilZ222asGhHZJ5HxvHAk8ePGIaA9XymW9L2ATngU5qZ5yPj2DGOgW645htf/5Dv/MEP+PHHH/Hpp/cc9nf84Pt/wPXNDbvS8R0+/heOu5/J9VbA/nRx1fbD5qLknadfbTkcEof9SI4nLJnderUUOtJSDsxjlnZnFY4dpuohrAmectvGaSTXMyVDDqlW0Jxjtu3Db5FRrNHhJx0woi6AgHSJPNMUmac919c7ctZM01y+cTGhwBhSrcRaIHhSlcRFKAXQ+IOYIlpkmryXIohWKZXxOAlXWmOzolxUi8R8SzxrpZa8GMLknEm1IOoYVu9VFStjFZF3xuj+bJhnQV/l2aDJbyvgDDknnBcgYbfb0Nmi1F6jz0M7ZEWsheM8Mrqj6FzWgc12YLNe8+Dmmr6XzllKiX3Z8/3hhz+7+PsZXcvabPmBujVZ43BWqSanGZsq4zQTY1LqRBPqd/IctWpvWibWqMyUDjgbDazSzn3DuXWuIdXOdC4Kq8v0tOUK7e8i+eeWosoYiYdPPvmU03HA1KfcXO1wSPcJoxbvCogVI6YS0VT80OO6IEYiqrlatbCqKKKpw4ZtviDNif3d/mzyQutGyN9TyUJ3qHahWqbU7ndRek+lNlDDGGq1QtUpCMiAwXixVLdGwAVDxruL1azr21qdddSC1jvHqh/ogkjTBWtwXokCSu/MJTKejoz9HlMD1q55+OCGnCrTNPKT19/mh+a//M4YemeCWqjqMasPzhi1qqoXwaeTZyrnJLyJynq9o191lBq5f3MgTzMoDyrnhnayTHxaW5VnVVWrSyplnMgS5IK4zliLyUbBcfPWptam+ks7cBW1kc1EFOwMzUdaNNRSKkxz5jhGaTtgFkI0LfesYJxslFPOFAP740mGZUpDw6psSEbaDYDYBhrLeJrIpmCdE+vMKtabonwgHCZjz44oOSf6bsUURci/FijFnRNUoOaCcZYEOC+bVc6RfFm16s+7vX1N3zl22wH50ro8L2kIyOgOVdxQUpqJ88Q07pnnjt12w5/8k9/mJ5/8Gi+ev2AcR3780Uf8wXe/y9P3v0ropKio3ZbNL/zr7wy4L+p6CzR96+ADlkSqxV5zKjPc3Fxj7i2n4577w4E4HVivrt+qkp1z1DKr6LbRuNXnbZ2I3zckqF5U9LZxmM5Vv7zWc5IlmnwG4626bwCUpSBphVUIAQ8csKRcSVGGCa0O9+kKkLVgxfEkJhmUefn6DTEmuqKbTm5C2lKuGKqYAGgyIlOnFmNliArO87JGdfNQlEjMm4qodVCZ0kzNFZuRCWg9rGtOGMfi7+ycIaZZJKSWyctG2SlCQyHz/nuPFl95QWlk8EzuqTyLkovG8USMJ6Zxz3TyfPD+Y775jQ/56Mcf8f3vf4dXr57z/T/4Ax4+fES37vn/1N/m3/3ZheA/9/UWunMRx8tfdY8z1Qh3d7Nis9lRauZ4/5r5dCA44PF53/be04XA/hQvnKYkNtwFB19cySwpiwyUdFiMPuczwn+5HoRioVqQqldprdU4EtqT1T3XeTncjDGUkyElcf9aIMblvRoZsnOWVAtzzlRrOI4TMWZ1PGtQG+AKRosniQkFNwriCGedSLfpdi2zHTKgJ5qaVq2DxURiUSgoMmBGOeulliSUITG6UDUYa7QjmGjccTFGUYAEwxRnrnYrrq7WrNc95JF2R9veb5Bcu+ZEzpKkHg/3GNb0/ZoudDx4cMWD6yucgXkaeWlO/MPtb/6Mo/BnealpiD7jzWZNtZ4YE2k6cXfaU3NcZCEBfBfoZkuJ0u0xpSWdiE158JKgNmTbyvncqFe27TOaYIn9eZEEdanhL9HTpvHeCpWCsTIE1Aa3Ssq8vr9lGvds18OSZ1TT5lyUJqUdkFgrsVZs14myyTSRYsYtFZJQR6qqoNBUWqolpcztm1usFvVtANxURJJNC09jrA7nFWoqC41mmk5y1gQZBHRViS1JfqdBZmFMtYuTYi4JUado0qJI215uj1h+I06Aq6FnMww4VVXwoNQvWZc1F3KamU4HDv4Oime1Dlzf3DAeR3a7Df3mm7wy7wa03pmgxpiXg/xShkGfpzzkWpcKG61sg296jEGh8cDzTz7h5nrN4n3cwsIUrA4YyVaoFbs14tBkZIOKVarZBJiw0I0bfXVBjuQ1yoSldyJkG4LwOGOMmCoPph3yzgTW6x1d15OzTAs3TnxTUMpVktpYEnOO5ALf+f3vcjqMrIswXmxWrpiVDRlriSVRZbQPazyuC5ziXgSinXCylgpQb2rVKsWHnpgrJkudlZdDuyy3P6bCIssCnE6nt56VFAOR8XTLN37+27z3+BGlTBiSVm560C0oiCJmKZHmE6fxjuHkMSYTuoF//c//Z5nHzG/8xn/M8xcv+N3f/V1+8V/6M1zfiFh8+fjAo79xB//dd8bcF3LJJqP386Kgks9pEqPVOkiSGvoO4wx93zONI3Ms7Pd7PvzgoSTgRElopUSXODFqtqgi+1w80wKLxduCLhkWD/VGiWqIzcWrZ9X3rNaDmgwUYhSJIK+6rn03cLo/0oeeLvTUYjH4BhIsCUeuEpcxJ+YUAcMPfvAjptNEpwiUx+Arys2WTW+ak4hd63uyLpAVfdLloe9BNCxre08V1Tz1el9UgcNU9YiX+02VtpIzToZRQuB4PL4Vu7Vx/2pmvep47/E1w2CoSBJQLhK4Uo1KIUnRmnOUBHU+MY0dZbvj+nrFv/Znf5nNZk3JM3//7/19nj3f8NGPP+Lh7gnf4Muhg7oc1A0p1auUqq47Vqbqa6HrAsMglq8+9ExzYpwiJRiozVRFPqyVPbY9KEHQ1SEHs3zkWpVfdwE/NTqLOQ+lnhVUhJohfSbHdr0idAGDUIeK2gV75wghELqOGhNdPxB8t8TuMkunLznXijOIcUbNdMOKH/7wI6Zxwqt0jssGD6KlqS3LURw0BAEzbklYYlE6Dbr3YhTEaPQTeaOlqD1s6JnGkxzMSoUqbYCxFNBunFGaS85Z5LsMUArWVk085HycT0e++dWvsVv1GCsSbBVEdrBKAuaaIUCpMmjb1CncG8YxsN1e8/Txhm/93Ff4rd/qefbpketpzb/z5N/6I4rGn+1lrdAh1qyYfeL2dOL+7sB65QV1047sEHrKBsphYjqcwPol13BWXPskQQNjHaUaTuOk+cMiAMUy1qbxfm7Fl4tCRvKNpsW6aA1rImCdU8c2x3q1QcY3AmjSZ0pVKSxoQZyNZVYbcOs8L1684f7+QJoioRhcRVFzQV8NYvpTc8ZR8UXWfug9McVFQ90YSUa985IcqqshVeaBXAishp7pfhQN8yp8Xdsc0nKTwKz4EChxljqvFuZ50o6wEgNMBbVDddaJKUY1BO+43m3wCrgocUse8DJoBuREihPjcS/3qjp22y273cDmvucb/hX/7fKfAn/hnxgv70xQ53limkam4CiqOWatuOS0vSTlogtcHEn6ruPhzRX90MuinQspi0h01w2E0F+I90KTV5A8wi1Qei7qHUshlYpxjhBEoko22+Ye9Ta62342VYYtrnY7drstfS8TbpRM3/cMw4B1gd/77d9jNQxsd1uudlvAkktdhhOMNaSUsL4wpcg4TeScmU4nXIUOS6g6jaeJujEObOBQZ8acOcaKiZZ134kIdi7CX82GnAqrfgBnSDXLIIyF+7sjxcjXpSKWfCJV1FCtIpuqs1RjiCnyk08/0eGsNrQgyee3f+4bPLjZ4L1yV6nULId6SyraUWNU4qKUiWk6cDx4qIWhFHxY82/+m/8Gw7Di//f3f5Pf+u3f5hvf+of83Lf+JO+//wEfdpm/Wr4cUj0tARRE+mzW0A7VXMrShjfG0IWO6+2OaR6poLI8hfVmt7S7pTUlvDVqUvtm1wgbxDSzXgV8EGpLrIK+iKxYO+zb4X6O3VrrMlGc5gRI7F9td2y3a7pOeFnBO7rQiTg1lt/6zd9itV6z3e0YVsPyLAGlHYgOYJssPs0jMUZqzvTO01mPU/RKkDJNLF1gBk6lcEqQYibHCFlaQyDi4jFlqIYQmhRVkYMdOBykgq8Fcdzyl5PftbETBW1eFDSqWGA2BApBrfquY7seeHC9JWcRe5bkTav1i68vFUxpg46KpMaR0+Ee3w1c7Vb86T/1SwyrntvbV7x4dst3v/Nd0u45f55nf8RR+U935ZzJqjl7RinRP41SJeS++c7jO0vKIi03ThOh69htV8wxAasFgZ7jrEODUfiXkkmRUsZ7J9721lGKSv4tDSo9cMzFn/rhvT+L+qt+9Wa9Zne1Zeh7kdDLgjZ2XcA5z3iaePbJczkPul47OWqPrRP/GEsuiVwLMScqhpsHN7x4/pw0zYSKJpkVi1WQQ5LSAky1EIsguCVmfOdkvWaJs1IznkQJoo/qSqEkSW5KTQQPIXhZT8WqKoFcIuuq/+0Mrg/0Qw/3+m+SbVJqo93I63r04CHrVQCbiKpwU3KlVqcPWNZLtfpn1RdMxDJR4p4SHevtNf/Gn/+z3N2+ZjU4po9+SOWvA18OFYrPXguBSalsvvPEnIRWNUfGOXK9W6mQv8a+FXQ4zpMYpCBouHVSdDgnXcNSqxbihfGkboF6/432kmqVBOot9YmFViVAw9B13NxcLbzWGOPiTtX3PUPfUzIEawm2SmGVAa8oZJUB7kadafQm7x3f/MbP8fvf+Q53r18TYmSjryygxRUWmXQRhQFBJOVccl4S1Ib2NtqLyLSJrWnOBeusnkWqesD5VtTcgLwzp78ijBin+3KtdSmuMlFRYy1msZSYCMbTq1qQN23YkOXn1VKExmblvATpBNSSoMxQR9J8S9dt2KwdT1bvc/053Ol3Jqg5RmpOTNPIXApDHy6qZl3oaDsGOfxDH9jtNsJ/oCyZ+c3NjVTlQsZT6Fo3X21rFxAuSU6UHLG2J6cih5axWO+XaWmQH1WMIJgyuGUpxuJUF9IZGSbp+56+Fy9qawQh22w27LbXPPv4U7abDTfXW1brNTFGHS56uw3cpFpadbVoshoL1ZJNJVlFoKwlO0s0lsnAVCvkjBlnKEJXyLWQSksOR/EVKPIasybpQg5pgEfSxZPPUlrW46q4OKdaKCktPJyWcVpvePTwii4YaokNv6LoM9Md+LyBLAFXKXlmmk46RCGmBNfXD/nlX/4VhvUVuP+Yv/N3/g6HY2aeI6ex5//S/Sr/9jtD7ou5cmFpr0ulfD7oCy15tWStSp23+N5zOO4BL0WJtSKSXaH5SS9yZlUOubYGpAUUkSEfTymFaZ6xjSuFDlhZbadqfDmziEdJHCt3D0VqnXNnK0of6PtON8w1XR947/EjHt5cU0vhNJ5w614Q/Cqtopwz1mdKEZjGe888zZCioueia1qsIatOZXWe2BlONTNVK3q8MeEVkQVRJrDWMJq4UBhqFQHpVCFmMbcQpxSDzVpU0ookMM5hayGWzGmapGhbkAKJwWCh6yxdcAvpXzZaszzPJUFdEij9miLvO6dMnGdO04nOOIYh8I2vfY2/8pf/Cv/3v/H/4nA88I9T5jcM/LUvKD4/76p6yF5eTei8rVgDQt/Imfv7A/MoSEfXCSL9WR1J4V9mla2xktoZR4rCVxPudGWcZ/og690oZQRrFGlFuwbS9XJGdG6rFufOSpx6J9w0Hxy2s3Qh0Pc9XegY+5nnnz7n4aMHPLi5EUHzhV6g66l1gGoh5SQuPlnmEJy1BONwRXmlxminQND8EgIjhakUppwxKbGyhpwVFUKGdWydCW1vMGIfi6m4aohWkguRS0w6RCbrOOYor9eKHqsHDuNJijd3IbOklDOQNvGDB9eSuqiRQMWqOgJLO0USkIKtVqldDYUVneEYJ3KOrIaBX/vVXwEM/2D9lP/tT24+x5Pnj/MSzXFxdALjDDEnpnlSQMVirKeh1wYrUku5UdwKhUzR4iWXLDMA3pCrfBQa59QogorUcFiZIbH2LfTfWgtF6EoCUAQ26zX90OtgoXSEnXcM/YC1lufPXlBqZbMeGIaV7kXqUVWhyLCKdiYLMUfmFLHOcjqeIBdc61RltPpT3jEG44RjnWolZkkY16gBhPLIBCjJWCuIqLGWmBPNzSqbwjTNgBOKijGSU8lhr1uKWboizntCFxQkbEmwUs2aUQLSuRuGnk0/iHyVHDIsYJh2AFRDEapBjhylutSIYSanE/0w8OjBlsNTz98xPf+5d0TOu1v8c2Q8jQILl0wpnU7dN45NXTZMfSfiax6ciLamwjSNpBjZbYdFbaYFiNED2KFyQFm0/JxyfWpJzHFeqvkGaffDAMjGPKeo7aqL6T5rFwcfQ/MBNnglXndB+Fjb7Yabmxv6LmCo3N3dUutE9/QxfuFkSVXjq2oJ5ox3nhhnQX8NZGtI2GXMumBIxnCsibEU5mogF2yMuCq0KSmExG3KVLBWbO+8F4u8hFk4Nhh5+GdpDNlUrZP3mXWATA6eczJmjSQ8Q99jEROEhj5pnrEgbuejUH5+S8hTnJhnTwgTxllKjjx+9IBf/BPfZn8c+ff/v/8BP/j+99isN9jVDdOD+3eF1Bd2Cb1BpEpKzrowG7yIEuu1BWQrxslA0vF4ADwpJ9WS8+dqWwUpK1WH2FDem7SuOu9wplJKJM1i5+uCV79zacv2w4qKTLcL5UQ2Qou2/rVFklXoXq7GGTpzh7pOHISGYSCXzOvXr6hsWQ0PRRIKqEYcSVxrmZdKFwJxnjGlkKhEY0iNY2WEU2eM4S5HThSmqnSIJAVT28aMAVsr0agFnhZzRS0hbTY6LGMo1hDQDj91GZK0OeOKk3Ws6zznsvx82VvVeSa0AatzzC69YJbbhGynbfK1LrzAGCNuHrHO48OK6+2G/8yf/tP8o9/8HX7/D77PmztP599dzX9hl0CKy31dLqNo8/JlshfHFDkc7snJq66yKBe0A6QNeUAlBEfGQhJJJmsM3smeK170heQtm9VqGZ5yxtENPcY4pnkSaoy2TC0CCFTrJPHSFiQtga6CnjprtQPgsboHr9crKpVXr1/jwwNWndhji1V51X1XOiBS1BjmGFWtoar2ryUJ9wCrCfVUK2MtTLUwFYNNWbShi0hRVW3LO5OXtqmxkLJoS2rKREyJ4uxyDlgtxHLOksAY2TeyFqO5nDmNlfMzbOfdauggzUsA60qSs0CTg/NaYtnrRbUhKW1lJsYZ3we+8sH7/MK3f57X+x2///GHf2Th+E97/bTLpFyXes6y9yXGcWQcR0rO2lXVroD8JKX6nPfdWqRbgxFULqaZVd9dfK06N110VDFy3i/8dKOugUr5MNae3aqMuLJ1XUcIolPrrBR66/Ua5xyH/ZHiE9vtmtB3ytMOXEqjCRaVcXhR5EmJXIo6h32mYFRKUjGiWlGcIxpDrBBLgZTptAOn4oQUCjZlHXSWWzaliisKLugglqwfloKsgSRtbVpFnatBhnhrXQYbaSCMPjGrA9hd8HRdWCgU0uHRp1p1BqGhyG/lK1lkAEui5JlaZvousFofiPy/gf/6PzGm3pmgTtPM3d2eoe8x6trgnCPlRpw1i895XaBnS66ZcYqMp0mCsE0yWh1QsueOZ+gcpjhsTuRTovOW9eAZgiPHkXkcyZosdMon3W13VOA0noSfsfjoslTxVNTHufG5ZADIGZRYn7EUNts1JSfu93ccbl/z4OGWxw+ucV2QB2oLsUR6M0jbN2VCFziNE7ZkZlOJ1jDjSM6QrSE4R3aWl3cHTjmJ+HsuTCbRGa2K9QFbTXAMiZzlACnBSTVYWNrAHU64Snqz5fBOC+9JOIpuaY9YIwlu8OpgUZciXX/z2+pvRs+z1gKQNr/YI6Y4M80jWMv+7jWrzRVPHl/zr/76r/Dd732P73z3Yz75yUc8fXLHrzz8B+8KqS/sErmuSPCOkssiBSXJjxyYQq/U6tUIN/p4PFKV4eyDxTloYh3twDemMPQdtggNwJaCD4ar3UDwlpyEd2PqI+Hc9R2+C1jXc3V1RYyR47HKpCWihEGVZ1b0ec/zTE6C2FMq1WRqFnOGkkT+LQTPnCLjac/pcItxT3n88FoKWFVnSHmmo9cEtdCHTpI1KrOBk6msrCEZEWjOTjzeP9nfcyAzlUrNhpLV/FIP62oqnko2hrnpcpZCKR7v1I7VmKXLwcUdNLVirBworZ0dYyTGvBRYxla8M3jnGfqBPgQoilwp4lRbtS5PULiZ1VKrUxaMGivkWfmoE855rBG3sPeePOHXf/3XuTuMpJeFP2e/JPhpK1j0Y5HOu7j3jWaVc2KeJ46nA9DRBUmyjCIc9a0iB9abFTFn5jkr19KwW/cEB3GaZBC1D7gQxCnMe1zouLq6oZQiB26edWDCLEVwtVam/mtlnlrsql2lkaG4msU4IzhH34vD193dLc+f7dlsOjq/lZ+FDOKmHOlqrwlaxQfPOI4QZ0KtzNaQrKXaSnUWvCNbx32OHGvmVAtzBZstVkX9i4WaZffLqlFqZpRmY+j67swDzZCT8FGr7rlZE/Nml+2KgBYxRjGyWGY1ZM9wFnwwdD5wlk2/LLLkPyQ5bQXXRZqrYEFKiVxECH2OI9V5VqsNX/nK+/wrL7Z09eEfUTD+018NdDqLMLercRqF33w6jhwOB06juJxtNutlQEmSeWjxKsCSqKZY3SOpohNubQ+16GBlput6mmufsRbnA95LophrUdBQEH9nnNI26iLtJXuI/G5qwftOwYCO1WrFgwcPyHNkrXbuh+OJzVrkIa1SpCqGlCKhdheykRFrFNEE0H2+IFxV6WI5ZuOYjWEuMNcKuXCaZqWSCR0ELSohyv6mKhPOyXuKJMxksMEvd96onSyIvF9FqTQWQi0cTsdlUFJbA0DVtStnpHd2+Sgly6ClJg21FdOgaLc6B8q/LLlEKU3I/4TxlcD3ueZ/xj93gppzZhxHainii7zZcTgciXjh3S38sYpxYIpZusT3hztOJ7m5m/VKJ9UKqNxILiJ1NAwdPgjH7m5/4smTx6zWgwTA4YDtoNYTXWe5vrpif9jjO8/9/YFxHMUXvcXUkrFr7l/FX3oeJ4Y+XCRfEjT393d873vfpe86huDZ7bZcX18ryFgoRrilubbhDrmC98wl4Z3hGKw63ViMQziCj64ZHj3gH/zmf4C7uREf6JRx3sngibpWyOEDOVfGEjEx4WaZkLN6sC8BTaMolOXh1yqLb46RimUY1qRSMAWB5IPl8cOHWiWeDzX5Zg1G0zZGK+GgBzzI64wlY3PEp5mQAiWfKNHg/cCD3cBf+7f/S/wf/o9/nbvXz/nBs57/82/8N/hfviuovqCrbQy5C0L5qE3bFk2a9E6I24SgIHFiiiPWBNbrlVToZRL5jUvOkoHd9ZpiDHPKzFPk0aNHbLYrqIX5BNFZul7I+8MwsNtuGTZbcjLsD3uxoiv1rdf8WfWFWup5bBqEUqBoyjgeefnmJSnNbNcrHj9+zM3NzZLACbqmA85YadfUineOrF7I0cOYLScr057eOezVmu7mmj/4wW8z2spchVhvSmG2DeEpC+KTs3iPp1yxSYqloe/BlLfoJoI6n9tvpkLOjpwdKWWmUbzJSxXyickVYz3rfk2wXjZU9Ictl1l+fjvcz+1smYzNORKjYXJH7BxktqhWSjHsdh2//mu/TC2Vf3/1N/mf//av8u/y/GcTgP8iV82iqGCky5JKJlsZdMsGUsk0uGaaJ07TUR3RKtvtjmAK1iRtA6aFKiDWtz0mRuWPBq6urri63lFrYjzcU3NiNVxjLfR94Npd0Q2CIH3y6TPlsUridem73qhPACnGpehqnxNaRtG9d+LucMs0HQjOsO4cIbi39m9JaMScwpQKOdM5zzTNGG+JqRCpjJ0g9ZOz9L2n3/QcbObOVI45k2YZtPLOLJPepRashZCkdZpSZYoZ6yoblUgD5akLEKf8WeF0WySxLyVQsiPnyjQK+ixJSNb9vWBtYOgGbq53Qs8y9bzstaMgA5dmQVsXZ0SaR3sSh6scmfOMiyeMdQQ/8PjRI777lT3/U/7X/Hf4819UhP6h1/LaP/PvQqnSJLwKP/14PDFHoa31fVicdFHJJmNE8q4PjmHVM8VCLtL5Cn1gs13TBUecZihi19Wem7WG9XbDdndDCIFPnz8jTVLkVD1YnfEyKGWkm3M6jaScqKUTxQYKNUWKtZATwRpurrYc7g+8evGM02mP95WHN78KQdr8rbA2VguZlKSgS4mxJGqKrHNdpKNylaEjjKUUwysih2CZEqIl7S12zDpv06iGVX5WceRYiVOhpI7QgbOSKFtrIakWpxVKRUOZW6FlVQ2mqSq1PKTSaFRwLqcM636Q4fdacI06pJxztFiVoUGWJN8Yp9QH2YdTnkl5lE4Phe+Vmf8hPf/Nd8TU57T4KymKv7P3HddXN5yOs1hb1vNhr9Jt0mbxnliiaJ7miPOeYQikeAIzU8sgcjMUnj6+odqgGiRwfb0jhLBUUNtVx3D1HsMwcHt3z/5wy/F0ZLo9Ms+JlOVAczro0jbMNglojDijxCRkdWecBEfVlgGwWq94/733udluGJTrZi4qA1rCa8SDfU6R6CAeI7vVQO0gGQfdirDuWO2u2D19j+76BoYVRVtf4moEqcFQSCusZLA1LZWjcxaQRLScvxSntmW5tacs6tKRMTbjfMWFTsDhFOm6wPX1FUM34IoKbLVSpwWY/v9nN5SlTeEM5ELMFZ8MfQ3UcmKeMrVkQu9ZrwJ/5S/9F/lPf+t3ePb6t/nf/4/+n8BfeldYfSFXSs2CVtuDFqGpmKq80aoSJYZUCnOaOZ72pJRU9N7jfGXen+hWTnQ3qVhXefjoBtf1UtUqcrgaAt5Jddv7FVdb4eqM40TOE+M0cpxmTseoKEtZ7rygt+WtTUQQxZmUIn0viLppE/EpkX3myZOnPH38mN1mxeAtqz4o/qIyZjiaJqOg4VLBH8aJh12PdUpN6QbC0DFsNwxXV5hhIG/WpDSSalYuUpvyrguKX2qhJJGaAs31AxRmlq2uShvUdcIxa9z04IwO4xSl6iS6rqfGJBW5raxWazbrLd7JSJWtHm2mLcXWOZLbpuqWdlPO4jlt7MyUqySo1krCbj15tAxuw6/8mT/FV78Gf/7PfTlcpCiV7XqDwZLzkVwnpXYtuz+AopUj03gCW1mte/rBUWMklxljO5HKsdAPnp1Zs97umONMyjIJPKw6git46+kePcBQ1SIxgilM88hhHBlPk+y3qnzR9td2wLXYNcYwjjqMV6sIfBuhXdRStdsTefTwEY8ePGS77hmCtFepKiCunLbWeatVCshE5RQjqxDIVMZqmU1PGALVW8J6g715wLbvKJ98jzxJe9XkSlK1lbqoWxSmrDqmWgVaW3FtcBBpfZZacKFppYoaTK4JEBm4tlaP46j/DUVl24y19N3Aqh/ondUi1yzdKmmlnvffizEspKozSzcrxhnrPcY5nPeiOpMmvOv5pUcf8L/69f/aFxCY777+SS1+/ay+X6Q4N1K4r/qeLhioI9YVvBdXv6pFhHMO33WUesIkeHBzxXqzwnWOzjlu5wPeg/eASTx58kh4/saTcuT58+dnoxRn34rdy9ctlt9F+cFNVUWeYymZ4/HAj3/8I168fM2686xWPbvtSgA6jdmW0FWUppLEbnjKic466DwpF+YCY2dJphIRp79uNbD+8Kt88psf8WaeONmKmcH4TrROrST5SX+PTRrHVGJOdNEz9J3mD1mKWKl4cN7SdwXIC/LvjV0ArpSEWpliVvczLRIQ7fvV0HG1XtOpVn1ZqFYN2LqMAX3WOvR47vAKf3qePV3nqabyjfWH/G9+/d97Z0x9jsxUJKl2YkqSZTvnMOWcY799UAjHYZqOlBJFD9HJoT6eRkJvwIjbhg+WzXagYBetVWtFwBfljzr1bHbOacVexd9+Lstk9mV69ZYMlr62XIto05VCdZetP6mcmrxN5wx92OkgEtQiN7vmisnyZ4Ps55g47u95+PApgw34CmFzxep6gx96plXPfZ5woaNap4mocEIKVeVe5H+iDycbkdMW5aw6e60pap0VHoopYPLCqRHBaqOv1bG7umG3WunPKnQObVZbbc/WZQmdUdgG1ZdlcRVE6DrnRBGNIqxN9N4wWUF1rLXU2WNtx/vvPeR4/CqTTfyt31nz77wz5L6YK84zcZrIfSekdwBMo/e9FbMtiU1xJngrwxKIo9c0n7jabDDIhtl1nq3pMc6rEw1AJXQBqk6OGnmewn1W1D5npii87IsTadkwz8iRfsqKOUDWQqr1dxtXW/jfcDwdCc6y2m3kmXw2dtugRZEDN6bM3WHPew8/YOU7umrw/YrVbkO/XpGc436cMF0QbngcKVnQi5plLTeifalGJvSr8pGUO02UTsl5EKwi0seFppUnItyS8Ii0quHx46cE58WxTs00hI+v8krUs77hggZcJqfyO2gqrVVaWiYVjCvkdKIkT/GOkj0pQrCB9eDI5n3+5m//Bf7qzzwS/9mvWipxjhhjpfVo7ZK0Ne7/0g3Kwi0PiojEOJLnI7ZGrO1UUs+wWgV8cITB4z3LXt53HZUqFsB6HBhjsaaqWPxEzKJk0rSb35b0O3euAM671tJv0DfVugKyt1tnxcShdHRdTyuAlt1ciyJ0uCblQsyZ++OBm+sbVnhCNaxWW/p1jw0e6wMxdND1uGGAKN0PGVq5tCiWn5tqG6CUy2GYUsXrAdz4/aJnrESfLOVtW2s5i1ZmqbDqV0JRyGJxaimsV2tWfSe8xyL4q9V71ExoWhegXQanNJXG68uiaJBn7TgI4OOMx4SMLY6tu/7ZB+I/4/VPTFCX+KhK4xenOO8doXPUMlHrjDFSNBtT1Q5dBodc6BWxNmzWga6zWA9D56lXUsAa5JxvknxzPDHNrbuosbS8nHqBHMprs1aKp/N5aM5i/5Xl69977z2G4Fh1nu2mUzZD0ecEpsqgYaOMlSygwHGeWfe9AF3FkvDYYMnG4roBf3PD01/8NuNv/V1mNPxzWcZGRI/A0oYcY25mqQZyM2SxWsyLNBsVjANfnaLLcro7WyjFLXMa0xRxGsMlS3IKYoHsvGczrAnWaSpaF0eqM8R13nVVdJOlyOIMGsaYSEn+xDhM8ew+J24/l4N6GkdpQSAt06KrydAkit5uU5ZSiNMIVay4vAPrqngNdyI8nvKsE5NeJvDOfUBJzPRHNiemJgZu9eefNVkVUTCm3QuMFRHfywnWZbPUzaZaFm5PLWLdNXZBtEa1ymsfRvukpWjLVFGA++MB97U13bDB5Uper6k3V0wGRls5zqNgPdaJpl0Rsn8TabdaaVzeQ1Pl0I8qCl1VVFiAzNb6kOTVVEfj3dZqsTZwff2QD588odZMnE7Mp3vI8xJE50V6hvBbV2XhSXA+aHIWLb9sItFEZi8adN4K36jgcB6GYcPTp494vq+8+MfrdwbcF3XN06Q2pQXRB60qYv+Z5LRdMjIr/Ekr1SamEDpL6ByliPxTCF4WM5bcSIHIfcm53U+9242TxeWGCLQ22HLQF6xuBlY3T3EOY+FPt8Jiad+XIvQV60l91DXTYtcssWuKattWiaGYEvvTCbdZ0a22+AoldNTrHbHzzCnz5pjI1uC8w0QZAsm56EQomixK9OSWoBpAJ2rrpdMbgCKlaMta7DqlNepsXdb4o0dP2a3XssnWzHjck6d77KJXKOLv5fLA02KA8460PF0pQqv4SadCiidS8ORkyd4Iv9BPGNNRUs+zT37pZx2G/9zXOI6SxNeqWp5vJ+LL+0f2EufAWkFAKhlrRVBbXL0MwxDoCuAsznrt2Ah3LSuCYk1D9NVZSgfMcrbn4smYdn4vQ3zGir0vVeooY88JrOy5zcZW1BdKEWRpDjN5JS50nwGhpMiqDT2V+IkpsT8cCY8/ZOjXIu+32eA2K3zXkUrhMM+kzuFCkPeQJVHIjfev+sUizJ91alzOCVuNzlfUBSBok/SpVOwyrFUoVtqtpUAtghjtdtdsViuhfCEqKJ2HzukaqSwFGgbV/lbAoN1buaM0jvUy6FciqVhcduQ8kXNHySehfCRPjO9CL7+Y67O5wPLvF5+3CJIZnOiOWluIccQjRhwNvRuGIKoVxmF9QCiVTjpbSgdwzjD0nZQ2BiqZlCLTFDlNmSnq87U/fW+ETvQ2HTA1FzDdo9uLr0UkYay1Qv3qOtZDYLMKZ8DDNBtdu+zxtYrBSq6Vu8OR3XqLX3shQrsOt+rwxuK6HnfzgPUHT6hdRxkthSyuTy0/avWaJnxCVVkyCIwtWJs1TxCZxFrFCMWoo5oM7skIoC1WE+hKSgVjxfBHIvdsN92FjlXfy+DrkurrBgDyp2H5d9ECd0iSJUlqO7PavEFKWV6rOo++63pngjqOE6/evKI7OE6bFR988J5wUl0nL+QC+ZGHLFVMirMI1lvwvhI8bG52dE4qlXkehS9hPTFJdZxUF60tdmMcXrXOjIrdy+ZWLw55q+WFbj7WEKwI2DZdr+C9DMTUKsLHmoBSZQDoeDxycy1cFUxz/tFqqOjDKAgvRXfmnAuH00QJHWYrMkS3tRApnE4j1nsy4npytd1gihzyKUWpL2xD3mRza20z0TFXPpLVBFkT6ikmOmMVyZNkq6iIrjWi4/nw6jFPH7/HOJ44APl04C3Cekt0LjiEEmJVqx6psLhIqkyS6iyTmEbdYBTNDoNIfljbsd0M/NzjDX/xvY/eGXBf1HU8Hohp1mIGcsyLaD7mjPpURf+cMerUJG1hay19cKx3D9kMjlJELSIESy2BmC5cjqsgtkWR7EU5QqeK5bZqUFGp1Z4PIycHlO86rGrwCRKAHnT6vSZrgiY8n5wSx8ORm901/TBIxb4UVrKxmUYlKVVDuJBi5nSaKCFg1itqhXsgkcmT2LIebeVEXWz7KDJw6MzZ1rShUM2RzGmVn5vmXj3v8zXDnAvesHCoE5ngWsIt0nGPbh5zc3WFs4Z5HknjTK3SGjVvtZPSudRqhgkLXid/lpqXgtYYSXByrMQZnMk4W+hDIM4HrIs88Cf+4nvTH3lc/tNctcBhf6TvBKkHlr0HWPYOY1RQ3ltqyuQ8MnSB0A303tD3npRGvDdYJ4dpzPWtienSlBPU87tpSYsFszz7RdaOiyKJSq4Z6yyhC7jSOKRFZXr0jZQs4H/Tpq2VaZq4fXPLbrOVtjhVY1e7SVm1RjUxLQgfdJ6i6OuGDr/bYYxl76CuekIInKaJ13Gi7zulQzSU84yWWSPIUGtP1iptT1HQsKQqGr8NCzYayHNMtJ3QUsVkwlaxhSxSRDx59D7vPX3CdjVggNNxz93rF8TxgClikiGLqk1BnwELzk93+Y+KdBhyruAEeXPFkrOjloFSZkq25FSI8e1W6x/HVS7i5K3rIkfAGLrOS2fDFkqZmecTrpMEU9y3Cl1n8CGo0Y2oqTgb8F5Aq5ShZkkARZ1H9qVpGqXDmnRArwK4Zc+S7ThrsQItwTLWqmZ10U1UuojNgME6MUh58eIlTx49ZFDKUhtgagCBIAGAJpapFOYYefnqFT/3Jz5gvd4SsPT9mvVOkUnrKF3HKThs32Gcp6amziPzEjqMvySHudYLVQCRRptzxSpYkEuzUTW4KpYnRTXShWKps+KaT4XQsVlvqEVyOFMFrFmtAr0PONMIXooqWwVCis45mOZi6PSMkmHHBiyIhFglpVb0erIOd7/remeCCvDppz8hxZlV17PqV2y3O+pglzajxF+bNpQM3ZpKsJrVEylF9CBDsDhF4fpVzzhGUpw5jRPjPGNMwBqp7pspj8VAlTdbsMsCl4peNMScl7a0VFUiOF2pdJ3TlqGh5oL1DlVqFkQNCfLdbsdut8M5r8R4mUg1NPF/rxWI8uZqJVtkijQEnDHsxxO3d7eM08R2u2O3uyJThNNhRZOy1iqSPbZgNEkRya5W4bAsoqYnZtAEKBXRNqRQUoGa6awsUKpwp1bDlvEQpcUxRuZporPn4Z66PCsA2ayrYUmcRN1QJ/yUK5j15+ciAzNSrSYqM8YVgt/g7Ja+c2zrnoff+w+B/8HnhdUf+fW7v/P7HKeRr3/1a7z/9ANqsbiVTItac+YitTaxcw4fArnMlDRRXcF0HaHr6TqHg8VGdJ4TpzRzmqJSXyrO9ZQq9aezlb7vFKEKeB9wzlFqvOg8cEalVPmhFe2lBKiZ4OX3miLKAeh0sVF0dLPasBpWBB+WBFTQLvk5zfauITH5gjueDOTgwTnmaeIwTZzGkdD1rFYbtfPdg5UERA7LxkHURH9JiFE02QgNoGrduBSDlRiVT+iAUrA1U4Ksh5oLwQVW3YqSDTVWylyJpyhj1LQqW99/25ituZwhg7Ma4pK0VpVosdWQTGKWrEeHbhx9B7XOuOPzL03svnnzhv1+z2azYbO7AjOwmDssMCOAwQcv0lF5IqUTtjf0Q8+692rTaLGK9qUkRfmcBMWgGqz1GBuYDif6rmO1DoSg09AuqPOfoC4gB5rCrTSr5tCdlVyqiFiJC08uGFehtRtrpmZDmiMPHzzg+mrHMPT6bmRvBXTQVrj4Weu6rNzrUgrJGVIQD8oxJw7jkXjIqnNqOY0jb+7v9AzoiGkipYQJRlFZgXxEMMJeWBUL/9G6NkmutWUqOO8W5I5SKbaSrdzPah0Wz2rYMHQbnHIYHR2mOMjNuapiUNm6mpYE47M+cgtIINWprK8kRVU2mWgSc3AEJ5xaWdvdzy4A/zmv29tbQf7du5JlAVPG05GSItY6Hj+5YfDgAws9sOsvkpqcl8n1GGehnxXPPBWZPndn1zCRFhTkdMlPClTVr294wbBaLWtJ5NXi0pmqRVWGrYJgyHPe7/fc3+959OBGHJyMGiqYBu3IPiN1WabZu8aYOB1HkrHkYSB6zxvvSH2gD4F5mtm/ecnx5RW3x70kfM4Tp4k4zZjOYarBOjlbDOeuWKXJajpS4WKYV65chA4wzhNGkVFrHNk4qhfqlbGeBzeP+eY3fo7rqy3OiBb9OB65v3tDOt2J2H6D/XXXvcjv9aMN+p0BaLk0vzBN9k8GfUU67e0d/LPXOxPUbjUw3z7neNhzNAe+9/3v8Ut/8l/G1ctbcBF6RibonLOkqP5tBeJ0JFXPWCpjyWLnZR3jGClFBhaGfqNCzA5UdDbOYg6QUhK7PH3T1pz5RNWoI0dtnupBNABrpdaEs1aSC6ogMcXKBpMyp+PINE189NFHHA97njx5zDp10Dm8NRTXbFkNtVhSEcJv42HNKRFzhtDhwsCUJnABrFcNMstpOjGsV3jnmeMsAVLdmSfYHjRagQKmqtmApOfi3FotMUkLxBpk4KDoMJN1rLoeg6gIeGc53b9mOuwJg8UErX1qaytJ8rkI0FQVjK96GiiqhUkYU1TeArL1pDgxGWnXaQUB4USMjuPJ88mzX35nwH1R15s3r+k+CZSUOdwfef+9Dxm6vqXpb1X7TacweMc0Khe3Ch8nxcqxTJQ4672zjGMkZoOxHmPEElIlqCVJVXQmxrLgJG1yVzhtIoNSjV8OZ+f8ol0p8jxmiWMQBNFUu/CApnlmnic++vFHPLi54YP3nkJ2YgNsDbnFbhW3spgzKV7Ebs7MpdI7B0EGLqrzGB8w3jHGyGE8cXVzRdf3nMYTuSZs8VK81HPXuSpCnMliT9k5cVZZugXa2tU80yjQkHLFWxksu9rsAEdwAefBU+k7z/3hSOdFOqlh/m8VFxeITTtMpJV13kxNKaJtmQ0pSks8WsMcD3Suo9rCPHZfmtj97ne/x3o38PTJU3w/YIbV0n5vl/DmROLJWdVOqqLBm1MlGssxGZyR+5VTZZ6lwzOnirOdmG/gNDF0iv7bBRVpupHy+4oot2hyilrbLqLmy2WkbYkRc5Ki+1htkSsoStd1vLl9Q4wzD6+uoBR6J2cHXlAhcQW0omOb0jIoNpdCxGBdRyowxiRi5cbR+Y7TOHJ3f09Y9XRDR51F6D5n1JJX0bRSMaXxQSEmsF7WqEUoZrL2hGsac8Fpuz5XHRJUJKvvOoldIzJmBlHPEE/yiDFZElwqpkry0g73pUcKSHJaNauqS5vYYihJ6CpTjXRWGcMlUeKGksLPOgz/ma/T6cQ0TXT9P/m1GC2qjK2UGKkl4XCEzsuQqS30XRC77SynVC2FaUraGg4YG6jVcBpndtsN3nd4HwCRvRxH5ZJyHgxuA0W5FjpjWK0koW86nSkZghd+8EL8rMqZr5kUM4f9ng/ef1/UXaqAN844ldFrXQ67FOxCjZJco9ZKtpYcAjl4DjkxHg8YIMZEzIUHZG5PB0qRdrtobRdsaYglC0DX6IYA2RisAmhLEt4K9CQbtQglSQ6UEWOhGBPOdThjGfoVu90N29WGkjLZRLLN2OogWx1NbRJevIWKL7XU0n3VyzbQxGCMrD+hds2kZMjJUdIflkmer3cmqNYiPtlaId8fjlLN/CEwfoO4jTH0fUec0EoRUB5cTkIaLilDjeSEWng6SoZxkkrbeUvVNnIToc9toAKB45eDyZiz9R9tmr+1q93y4qTjVFSMVhosMUY5QJVLdFYCkMM91UqtUZLsKK4QcY4EH5Qf1rj8FusN3lQw4u0ccyLVTFAe6aJL2CgK+oqNZqm1IailUF1Dv84Pu6QqahqaZTYf8oq0RzvXEYwj+A5rPNv1htNmw3x6o4u3PR99HaCCussTpGkmGk1hL1+oVJeZnERJIBqLdUcwjsnvmWbLXUm8+fYH7wy4L+wyjhgT9/d7vA08efLBgpYaFWpeuJoI0iQKEhXx9JQzP0eI2ZDneYmTnCrGCneOaqUFV0RSpqGjLWbPLfcqFfki76U7STsszZljuexDoG1FFqjSKLVlGo8Xbd/z4EpBi7MssSt0EeGPp5gILogmX0UOV4NYPdLhq1VajWW/39Mq3+VD/zAXtYl2Qy+Q+YLJYHDUNtyjHYKcW2LVKAcg09Ayleytx7uAtxCM4b0nT3jz/LuihOGcoleNp1d1k7x86A3ShWpb8lpVrFp55G3IrCRKiaQy4XJlHsyXJnbv7+/wvSWqTE2v8WGtE2OUhbYjtCZrDQZNaEqUwqoh9SU3erWg01V+jliJNgdAK2h0FevqXCreyJ66JHMLXGLPsVbBWnfepzQpsObtZ7TErrZCD4cD1guQ4K2j7ATdT+ZMuylZjEfmOYqLVMp467Go4H5FVWMCJmk3TdfUy9eviDkSTMAq13HOEeXTQG2dOZaFJgVpBhUlb4msqU31RYDgNhDY+KdU2cM3qw3BBbx1BC/KBX674f6NZz4h50gVehG1LJaYLee/uH00PG65d6bqcGQR3cyamecRr0Vtzn/8yWm7miFIK/qb371cshZLmfVDAKpSxaZ3yolkRPO8zJk5VZI0O6Slv7g22TNFY8HvNMfXwkm3gUUyyerXVVpX4fyaqDIU6K2YjgqlCJVQKkvxkJPQxKZp1gFYK90iB66ahY7Xht9yqctci7GWVIo48WlHNuYsNIVSwDhSqWJPbGRdhT4oT7qoxb0I+ktrvZ63ZP1dtdEDC5oDNfMeaURZ3ROLOQM0tRSs0im96zBo/GKYjUN1MeU+WQ3QutzsCxRVS612W40UcK6e9/6cs1hPp6gzG5/bwH93glprYbvb0A9eJWrUJUQ5O4tl2Dk8aP7MxkhCKDdS29sXAxslCcphsMqFyJxOUfT/UsW6rJtfJZdBHnau5wBDNw3MmVN1iS03juqCmbWPdsiLRMpuuyV0A+v1RtBH7/U9yZQcWdrxMYqXdUqJPvQ445bWEEii3XuHtRljHdMcdfpONjOjrXKoy8jbpTf5IimimFuhYL0cHBh1U0lO+COmqkaqBH4IHX23wjut4m1hpS5D+7uZPluMM8s9uUw+zxyo5ldvliBUgOwikS6iZmAK2URmM5KyI+Y3jLPl5ZR48fUvB49vWG1wLpBi5ngatcqVJNBpm79RU9DNxnun8pKtsJJDKSURis45UxLUasVprLTBI0GvrJd4ywaqKaxzf0ZZkE3DOm17G0uTZzofVE3bgeX1tuvM7ZJDuNTK0MtwyHq1FhrBIkNUl3aVKZaUEnMU28BWXKGtKJmodgTbU40MlwCcxqP4qBdpb10mGkgInpca+s9K0C8pY1WWvGhR1AbIdKR64akaIwlqCD3eBpH5ccIT7LY7ve9VPaMl8UWLs5b06E3Ut17PB77eMbO8dEWna3PmmYlppJjK6PnSxO40jfL8qhxwst+JTu3CoaftZeeBHtElzKIYokhonGdRjsAIfcoPOOsFndKDr02hx5wxEbocWNlOYgRoha15q5hqB5I9nwGL6UiBy2dgLvWX9aBCBNAbp7klr5lKTZlExhpHZWZWwxUpvhXhVQjfeUc1nWhKqh3pp8+f0VR4RZNUEtimaHKOXU0Sq/y9lAq5YnGLfKKsJiMc2iy/V1qV9azAYqzo9TqPc17WojH4YEQ7EtEyVQj14qoX+r7ndXTJS22xLhQ6hBJjHDFOxBAIqVPx9T/+S7oljdd/GSfnoqqQSWkil5laI7U65aGK3CI1YU0lzYVULEWHbaoNOOeX5LRqcSSFdlEe5IVKS7uZ0A4wlpt6Af408TyzyKGh+5sWwOX8A1NKnMZRncSgDx0e1TJ18r3JiExeUUpK46+KgZHKqBk5x0sWzj8VgnPMMZFKplLw1RP6jnFK1JqhSOJt2kRzvdgHtKBrVs/GGJ3mr/p5GeDF1GUINxeJYaFXeUX/pYPiXYfF0AeRAZv3MjCsqNayXs57wBko4a1bfR7kMkXt7LOjpJlsRSXo8+L2c2SmZr7+ja+RUuT2zR1xqhj1WXalqoSJXzZ+Y2RYQqb41e1dUZJShEBbNSn13jLNiWkcqdVhTGCeJWjnWfy9+74j71bsrrdqF5bIiNaqL+Lj3fgal4d5w5wFlFa9Vj0sz19isL7j5771bULo6LogH86w2IJW2fTPC0825PV6LcHc8s2KagoOTKPwZKZpZLfZUkoiTTPFyTCXPLa6BNjScm/TnbVqQGV117C6qYtrjM0FbCEr/8Xp67l6cIPrOmy1UArTNHF/f0vMkZQ9zrpFILi1jrjQ4BOkK8vzMYIcGIxu1GLjJv66RhJUErVOzKPhJ8+PTLPh2enAdz/9PeC/9zlh90d/PXjwgPVmRVWLREkIWYSMrbWkNFNKwlqvqhhFNyaNlGqE96bFQ3MtKrUyz+LIkYrwg411TIeTrAML3lu2uw216mSlNXgXpN2vLSTjHNJahfPmybLCjTM0f3RkDxRKi7Vsd9dsryxdL1OWfd8TrMHY83ugFIzXSegkQtV938tbbe3DKkMzIQSME65szrMOlBlyTJJQKrp+OVzWug6t9S5xncnZYa1wThudusQqE//KBUspKRpqcTYw9CtAvOEtlZIn3rx8oUWuERc4nCRjS/ueBsOegSfD8nqMosnQimFRI6m6no4H5bDnxN1+z3c//bt8GWJ3SrOIhp8hNQxV2olL2ViWN904jaZWOci0RS98efRnSJtOtrbCFBNtOK2aUbtTmdg5hqFbaBQ0xBUpQOpnEtTWHmpQQDUs6KZRm1B5lZZSpb379On7OB9YrVeshh4fOrwauLAkOBpnuVBSEgqA8v1lgEoOWOc8w6rHONnfSil8/PFHYMTYgNksgy+6qvQFZW0BXMR10s4SZ9ClGXo0xFSKR2nvSm4hIIHMK3i8lcPemIrJkRxn4jxSy4wPnXAJG8q3jGejSfx5P5YkWp5zba1mpY3JxHl8q9i6nIX947rOCcslknb5wiqQyDVSapLiAems2iLatKVk4jRRq8W5HmOFW2qdx7uOaZL9VNgfkuSkbAml4o3Ynxct+AF1eGoxq4W+lcFrYxowhChb1Ivt9/JVV+mIjePIp58+4+mTx2xWgwwUVYNV7CmlzDTPWOOp0yT2tynTOQG0mtNUpWKdx+ZMIbd8k9v7Owqiye2SY9gO1Km0Mkq+/62MTl57SYViMhZR07BOE1gUIWvFX9IBKlhkOgE2qzXrYRBLY7/SYVjPcB24WnX8J89/SPUXiMQl8/8z9J4lObWyZ5VaFv1fm8Xp17tKtpWSu8+N23cmqMfTHcfjipwT43jg7nYm5qS/lCXhaWhNs73z3uOAjLpp4KhZJ0iN6Jp2oeOwP3E6RUGkfEeOYpHqfGC1Gthut+QS5dCslXEWInMXOknerAErE3HLIEXjTVlDcALseyPTxcaLDI6tKpVTK1e7K0InXunOqvaX1dtSMzVlvBMXKuMDLvTC0zNGTttqMMXgbaALA/OUAUPXDXz9w69zf3/LcToSU1rOVOZCdaLLapwephe8upLE9UgWvMdWizUwzxnvCvIthRSTou8OUz3OekoRfThbK/N0otZEjicgUJ2X4AURfV/qF/2b9rtrNTRBdFuNIlAS9IUiwxZFLDefv3zDDz6O3B8Tdvc+f/Ev/E/eHXFf0DWnTJjFDrRbD4I4a3LqNEFdUEYd/gJk06xF48MwTwVTndq8Oayp3L6+peSRJpMWk1IfaqHve4ahp+s6UkrinZ3EN9l5T+eD0jScJoSWZhFotBWENTiqijOLTrCO7OnGI7a/263ErlMLuuAMbjlQJXatEzHmwViM9xTj9HeJFEhNYDtH36+AWZP4wOObx0Q1GJjjtHRFSIDTglR8g6W6RpLikiu5yvuttS7fl3Tzz1XcW8Q9RdrPYPC+08LIQCmkaeTjj35IyqMIVleH6QI2iH+7DN60I73tci3B0A1aM4pzD0WRjZy1eM7cl1tKPQCPvzSxi9EukXO4C8k8GUwTPrw0LVUeyjbcPWGw1CzDPg0G9M4zTmKHWkqg4rRNLkXu/nik7zv6oQNWnKaRXK7EHlKVUbCOzlQZhrtA/xf+mYHWMjLyYiVJRroBbbCjYnjw4AHDsFHJIKsKGhVvW4tYkGArloPSgvQdm81G2rBWUFBSxYXAetjQhx5jhBIAEIInx4kURUDfOqPcQhVibxbHtiFlZallcpY9/EzNEuQyg8S+yv1VBWk637HZbSXWEa51LYkSjxyPe8Zxj7ORmirGdzoLIPSKn0aQyjJl3fjUUoe0qe26UO/EOnIiqZTgl+a6yFDNW/8kwdEFj7cihWSq/okXG3IEbRQ+m6fgidlRY2GOB1IuOOvoOmkdj6Pw6vu+FVUFY6SQtU2ysnUqL7K7M+pXF1RQnAYFd5fixyFdY0FrP/jgQza7LddX16xVX1voUlmRdckrKhlmSHGm5KyFlcVXs9DqnHMMqzVedYhrqfzoRz/COIutYhd/HEey7quuOsk3lv1OX/tyhAvXVZJsJx3YZtlbZADRAomK8QJM5GpwLmgiK21+awLBeQxSKOzv7yk5qsHFmd5zvtre6j7zb29fIi2XsTURfKVYKDl+bii9M0F9c3dLromcI+NpotKRSz7D6LydWDVZms1mTc0bxlOh5BkqHI8nrA10viOoE4YxVuWdJGnNsjOzWq0YhgEfLHOUpNFr68QYy3pYsb3a0Q09zntKMbx48ULkrQyYIK1Ca+2yQHKWZK44gXBCZ+j7nr4PovfoVGbIiM4nitRUZyU4QOEfOeSHYa3+ugKf16xtjQKdC6y6jg/e/5CnT55SaiblyOl04rDfK7Qt1U8uUVG2JBqSUloTfJCJU610qiJVWStAtFU/TdKWDN4zHg88uPaM93uO929I8xHqTJqjIAa+Ww6Kti7lfV0E1LI3CkpVjZZ3RQMUnaMqMBVDpuP17WvGqfBkPfNrq8PnBt0XcU3TyDwdJY46aVt/dtksU5tIpR28JwRP0kJILDhnhm6NDQHng1TbSOJgjbZKc6Ja2G53YonoBX303ollXW28V8/19TV93+FCh7GeaZrY7+/EscmLRW3XdfJMFN2JUXhZFjDW4UJlGAb6IeC816KKJYHGgK2W4hwOq2ioTGtXG+i6AWv8ErtGuxoUEVAPoedb3/o2pSRimolpZp5n9vd7QWvQJFDbTdIrUVmTKq1Uq1yokoSqI3EjyYCxQuMRExAx0QjOkuaJ7By1zEyHPafjG4x6TudssbHgdCiNoij3wjc/I6lVuzYVGaBc9nLlNZpqFl0ASuJ4nClmz699+OWIXe+dDnw6GYACWa+0g/+MYp+TKF2UGGJM1FTxvqPz4i5jiDqNrvSmnIXnmWG9GlhvNqpbLUNt0xSpxuJDh3VBhzYMLog1tXOe0+kgSacVsMJZg/Fi5NJkz7SzKPSBUvAYVqsV/aB0KieDXN5KsugqCzIoQ0YVnNfiyioFS1q9RWafkGRSUEzvKt/46teBzP60Z5qFLjFNJ0wRRL24gjeehX8KS3JTotCnUKSzcf/ycugJqmqtUH5y1IFGHzDGyUBimukDvHrxKdPpjponqsnkJEVoMWrdqwi5MfZM5gaB9017eYKiXnaoq7YASpqJkyFNE+Q/fpmpd11y6yRGhZKg5UsRACDPIgEpl0hJ7Q8HcrYUPLU6UhbzlJx1ELJUNpsNITj6VcewFuOfECyes1pK5syVfqstbYzw06uBkptspyhX0BBDkZIK3vOVr3yF9WaNDwFvNW612G+UEWpd3ColhhyrlQw5Cj1FWv+dH+iGnqLDjdM88ezZM4L3wsktkVnrDivQrwz1aeHU4BRNp8/LH5k5QLmqRgEnG0V5Qib5xRaVCt53rNcbhm4lhRtG5y0z8ziyv3/DPB9wtsMYGar8w3RlLzJlBbtaEaAD1ZpwiJpIFGm8Uj43bt8t1D9PmL0cwDEl8ZJPZ3mpt15ea0cZcN7R9x0peqYUSVECK/gK/twi8t6xNF4M9J1jtero+g7v7dLOc060N70RLtZmvWa72YC1THHmeBwZTydSSlgDORV8kmEs7yxe0daGNLSkxHu/aGNK61elhAxSIas2ngBEFucEZu8wDMOaWmRCurjz1Lf4VFtWw4onT97TCU7hII3TiePhQFrcTeRhxThxOh11Mjsxz7OaFOgOr4dAW3AFIWU3rktrieVpprOV14c7ptMdhhlLJqeirQuZFhfqwhkz/Gxbox31TU+zKmZfi9GNRfjEczLc3Z8k5J3DpIr5+P6dAfdFXfM0Yy0YM3E6HkUOZmlPv/21zT3EB0/fd5Q0yZBTLcvkubVnaaXQBZnW1w1qIIDzbLZrsYfVhN8pUGONwRmL844HNw9koVaYk7SN5inirJWEoUih59zZVCAhlnOJjFMB5hCCDklYidu2+RqjCK1dfMxNdThfqcbRG8vQr5Gp+kK1wuUWM4mCsZYu9Dx8+ERbjImcE/M8st/vSSmqgoZUxSnNjNNITCK55YxQCZxRlEtJ9sumj8hQVafEfn0YxhhKiipFFInTkZonrMmKzBqhtdTEIr+mz8/oNv1WCXL5kE2TxJLTKitUJu5aE3d3EzVZHpsvR+zGGBlHURhJKeNru0+yx7bCyqmMlHMO7x0lKtIXJfm0tpMk14mTjPde9kFjCEg8187SDwN93wN1cfJpVtDOOfq+Z7u7wgcHTqb+51mmqlss4D0i9WOWddKMSWoFbF2EwLuu073X6rCJxHdzsJH3aNWnvCoy6xiqpe9XLEoDbeBUD2drDcEFHj96inOWm/nIHCdyzuz396SYlr0NI7SRXCJZpW+oVTr/rv1MHXAxSlvQX2aNCJyX3JyoJN4bX9sCxhn2d6/JcQQypiZKMVACWG2/woKOAnqon+k06OfOnNQzR1IE1sXCM8WZy2/50l2N2wnLOSSnvtzPnAw1iRqN81L455KZp0gujbdfSTERZ9lfBImVQbtSm3QRYKwAWbYNoSLmFK5bVFLQ/7eNqmLRdaEDnVUG5ZoJScsXdrsdw2olX6tP0CJOYsv5WaUorqUSSqWvkLSLIXQ9SQBbZwO80BpIOOu4ub5mf7TENGOdVU3SqtJ6WqzYZjkqSZ+p0plqeWDRfKYd7KWq1J4VDepiGv9UpCW9C5oXGHLMeAs1J8bTgTevn1PyLOegkzxg6cu/lafKawPtuBoB0RqXt+UZsq7yRafk3aHzzgS1lMQ86+pXzlpM6byA6vmAOb9M4U/64PHOM1U4jbMgKtoaksnDTAiShBVdmD5YVutBeSOSeZvO4GzG2iIDVIhPdfCBw3jk5atX3N3tyVHtH41htgnnLMFb+q6jDwFCoAuexgNpMlVFW0mtSXauqWU7sBrAopdnBD2rhvVqSy6CAoVOB7ZSohQh86/XG7764dd58/oN1AgmkcuG/OBafi+SFOSSGccTb9684XSSQ2k8jZSiLfxmx1bqgg4JqikJoxj0afsqJYKpzKc70rzH2YTRVnxGDgHjO95qvph6btMt71wDqZXx1Wjrw1CrWLfl4pgjvHh5T+gGjDOMOfNbH/+AX353zH0hV4yZvtMhqeOReZqWeP2pDz0AvHMMw8B0PDDHKIe8kY2lDVZhYBh6TuMsMevFS7lfr+n6TjhhsgPhnbQtnVbPXfBcXV1xv7/jdDyyP47c3d1SsxQ1yVlicth5FH1L5wjOYWsQekpRkj1qOayH50IPMOf4NSBDJraAUkSckdhdrTYyNZ2yDB5oclpyAWfou56nT94X/2+bMYiTTdTDvknrpJxVK++OcZrEaS6JQYZQQOTgqE3gskjsVlMFkddJ3Lb+ak44igwvTRK/tWSJuWwoiLuRjgvIqbAoT1RNqM9p61usPkWsKsgBUcRYY54z+/2e42nmOH85Ylf44/ccj0dijHRFuHkNhRKaQsEHFPEO9H3PmCZSTOSU25TdkqCGEBiGXmlWiDd4L4f5arXWjpEgdd6DbgA46+j7gccPH1FMYU6Z+/2B/X7P6ThiDYRQCDlTqsdRCdY2XEePDoNxstasUsAkkW2GFuf2r6QQelbU9t8Obzw9lvVqA22Sv+gQS2nJpCV0HQ9vnmhnTmIn58T9XjQ6S8kKDAgQME0n5jgzRz2ESxG1ACOavm19VYoiUIBFJXPOrmbWGHKKZOfojKHGwulwSymtyEoyYOkbJ09juAnHNY43oAuF9g8Kmp/PKOVr5jlCrtLxyT8NGn1ZriWPqRKvDRTKilrPcyLHLMPH6nQWqyTdBnGeKkXWukGE+fthYLNZq8yaaPWWUoRP7zt8kO6SMQbfd3jfKU80KvIv8WKtlba6AVtVc1ZVCHIp2NJs1aVrFTQpNqZlEjJ3syQPtS6a58Y5jO8oOLquOyP/CggYrKpySDJ3c31D6Byr/cA4jUDleNzLvqwjfk0qElS1vHV6m7IFOjBl3QUbQNm+OWOdJKg169eVNuwkPyOlSBcgxYnT/o7b18+hRmo2UJzMTRQjKGo9kwQbQoqCPcuvbsCB0rFEHUE6ADXnz43bd8tMmcp4OmCdIYSOaqryHkXX8Kc5HSLVcXd3y3YlVUwplcP9kccPnmIN2qqX1qYMRVVp4Qdp91gmDWpFkrCYmjA1C5/VVFarjtv7O97c33M4HEhppg0dNQvTlCFGgdNrP8hkpe+0ne+owPF45Hg88v7Tp/j1qnUsae5CkpvqoJAepFiDrY6r68fElJjTTFc9tc6U6qk1slrt+MbXv8EHX/kq/+Hf/FvS5mHWatxhbBvqOpcgH37lQ+EsqvXXPM/cvnnD/d0d93d3HPZ75hSpZOGxFKjFaAtO0GZvIM9H5umOUo50QbiRKVZqjqRk8UmrJd6u+ipL5NM4fPIpqfaFmC+baKkyHDSnwHEqmNBhTOX7Vz/mf/dr/w/+K/y33hl0X8TlvFsqX9ESbHFbf6qwqoquNWTSWEucRTd0t1lJUaUHfa1iwzfPE9XIGrG24t2sA0HCb6wYggWr2n7eWa62O3KcefHiJXf7e+aY1HRBgEZpMcnm55wUV5thxapfi5WkclSNtYtE2jD0F7I+erzXM0qBkecnFANwxXJ1/YhcK3OK+M6Ti5hppDTRd4Grqyt++Vd+nb/9H/0G87Sn1hlwoGvaqDyWFJdFubaCbAz9wDzPnA4H7u/vefP6Dcf9nnmeSSVRNH6FDqPJfT/Iv+VIno+cDq+4v/sU52YwwneWjoOhpBnrgqKiqu+rb73SNsj2YJEOSD3zytqVSyXmRIzSCvvB9Sf8n/6V/8WXInatPl+ZFpbp4YY4QDP80ARSEc6yXgst4nRSPdAzzcla4SxDZb8/SFFqRVu26yD4rPdHTEX6rsPUxHromFUR5MHNA/7hb/1D7o9H5lkLZ/U8MZPEvpHBBLarFUPf03c9buik3YjQBbq+F963Mfim8/zZ9w+0WBautlBYQnXsdjdSXMUkfG6g1ESMYoLhnOPJ4/fBOHKO1CL0pu1mh1hUsehEzvPE/f0dh8OB4/HE/f2eaRwXJDSp5E9Rrq/EUyvcZegr5SL6nFVQJ09h8I7D/UtivMMwYU2i5MicC32XdNraNfiUxbBjGeM9F1ntz5acLiVohRSFtjFPkfI5lpF/7FcD0iwLmp+TGP7kFCmxErzBGI+1gfU6qKw8GOOZp5nNugcjFKj1aqVSpbLeW6el8471ZsV2dy20Fe+x3nE4nLi9vePu7p4UI/SiDRqsJ1iPdw5TsoBwMVGKo2gb3DqPNVYGTJ2RD9NSRhCXv4Zvi1QgRd4LprDGsVnvKDpNH5xZUH9JdC196Hj//a8yjic+KLPwWnPhzd0rDoc90zgJOEijK8prLbWQq+gNW4Ta5bCQig7hKmJsKtnIMK8MYcv31lpUVz0zTScCntA7jqcDp+MdOR8xqkxQi6cWSfobH8LQUoVK87he4lQLsSbNZnUgzdQMJOVp/wtYnWILmCSTdN4spVxtfJyL3aVJhVAK+9s7SB3BW652O9Ik1WrwQYG+IoGSZmnzOI/3Fh/AmLLA5846CEEg5hQBmdp89eo1L9/ccponkWVIhc9y0cAtItNF63njHQVp8aWSiXkmOBmQ8s6pBiZYrE7Vm+WGVyy5WBXgraRsuD/MZONZbz2l6mLLmTlGDscT+2Pk6voxB2fJaY8xnkrUDanpcEoF4zAE32FWBq+yR08ePiTOkTjPwlU8HSk1kfLM6bhnf7iXwKwOby3Bwu3dC8bpnlImSVqtEdkj3UDTPOK6QVBYzcIXDtuyl1Q9+BVpVpmWpkF3Ok3MKZEIDP0VV4/fpwCPhx2/fP/l4EI5A+N0VCHx1ZKASuiek5jGoY4xcTgcyPGIs4J2GpXhIOuzMWd0q9ZCFwI+WLWbrBg7Ly19rJUWtVb91lRC5/joxx9zf39PjLNO8V4soqVA0tZTVd6ms6IbaSrDsKLrez755BN22w1Pnj4h+EEoBBcHWvtDcETVDlT5HOfX7I8Hqin0Kyt2eqUQowxJrbdbjAs8ffohb14/Y5rusMaBjTQt4iYb443wyZsihLVIUv/ghpwy0zSTYmS/3zPFiTnNjOORw/FO+GfFyvR0lsG0aTwwTnfksseYiO7lau2XKEkP+EVDtrXyymfuo1bxdcHylk+X0uTBYJwTpVq+UR/yP77/9Z95HP4LXT/Vnbp8F/r3ev5ME+S3zmKNCJeH0Kk/+cQ4noBCFzrRbnSV4AtwxGM0zjzeCk+47xzeB7rO8+L5pzx79kJahcYgx6EeRkXVenULnueoyhAdznX44HCmLgNf3/ve93jv6RPlYwe80bn5BoxzpqvU2vztLI7Ag4fvcX+/Z04zoXpSPpGSJeeJ6mX+4d/6L/xlfuPv/F1ePH/GNN5jzCzAgml7GRKvmzWPHzxYRM9jjEshcDoeef36NbevXzOeRqYow44pRzE4LwYyODxXVzfkmKjzTO0cxRjubz+FesTaCWoC5arHOBNAh7MMGHdOR1ulhZgwtCbB0uUqVYZbnXxNzNKJPI3z0kn4UlyfAcWaZFrRTsow9KzXA7VMHO9HUqw4nAwa+04RVlgNHfM8E+NIIeN9R99LPPZB9qxiMs57+s5gTWS33fLw4WN2V9dY5/n000/45OULxnEkRUHsUs5M00RzrGxgwHpYMXSBThF+4y1Yi/OBTpVSYjNsMW/t3EtqakyzLpecyVnoNUaoKhOmCH5KEhfCI7dsNzs222tRjskRyFxdXavLVaaasqD/03Riv99zd3/PeDpxsiPjaRLrKCvnW82JVr0bi9ArixT2BaPzE6I9T8mYMnO1WZHjidP+BfPxNc5EKlEKNidos3Otz3GZPmq+tNyNi3tjFuxLvrKo21dOnxu370xQnXPYENRSUCZscy1LgiW/3Jy5QDpQE2PkcIhc7zYMnU40z2LTNo4jcZ6Ypkm1CA3N9mropf1jnEiUSNJbMdrWa5PUd3e34n2uQw8KnywormxBBawT+N5Z2RwVJZR2gEwuP7y51qEUef2S1F5m9dIoLMVwe7vn9e2B+8PEi1d3nKaZWA2+H/B9T1Ah7P3hwPd/+ANevDzRefGJtqZTbqDRxSo/XSoY+b5GgG5tpRBE9qcfejZ5w3V9QCFTaiKnyHg8EDrLg5sbrBE+3cs3L5jTSK1ZdBFrFeqIclRynMmqF3g+6FkOl7cjS//Qdr9Ub5WUKofTzO3hjuPR8OoHP6brB3bXA+9/+u13BtwXdRlT3iLFnzUwL1BiRaMEkS7Mc2Q+HlkPPTUVSpJDS9QZIqUkTuOReZbNTarpqoLU4qBjjRW5DwoU0bQ1VToLt29uOYyRlJIi4MuLRRIMeQTtdTd+oXZgKFTGeQQjKMSDBw8Yul6oG9b81OOz+h5LMRyOE/eHibv9yItXdxyniXWs+DDQdStycZRqGefIixcv+fHHr9msrvB+kAPWOIyxuv5b7iTt4oZ5tbcicSwWwc6LfMt6vdZqP5FyZByP5BgZOs/D6yucc8Q8EeeR8XQgFdmg5VAWrlcxlZxmMQlQjpkxjTB4LppbcSUJjqaurYZVLnXOME2R0wRzstS6YvPpV/8IIvFnd30WbSylMs+RcZxJMeG9J+j9LklQ55Qyp9Mo+26cl3zeOeH2G5N14KNNrTdT6UKKM1OEOVZeTq8kzlNZNELbriD7rVXtWwUrpFITqSmgGpEAmuaZnDPr9Vr91e2y917Gb4soOUjlMJ1j5niM7I+RoVqGlaMUSZTnaRa1FeB3fvf32W4fMB4n2QfVmlfoSQ1Nl9dpW3sT2W+pGYNls15ztdkyPn4iCUGciUkGhu/3r5miSClaF6CKNJqplRwjxzhzHPdg0jK0WPV5lRwpxsq8rZNkYZH/W/YAieA2WNMktzJNtkfmJEQ+TmyEKZ9d/V/89VnqVPu35fP6ZzP/CcFRasVbD+W833nvmeeRnCIpRXJOkjQ68L4I9UeRP2PA2ype8abw6MFDQvAcjweOp5FPPvmEwzwpx5ilkC5Z+cW1Df1OUCrObgmhW1QorJM9rNbKJ598woMHN4uaxgUOcD67McvnLQ6coRTLbveQOWZiSnQ6KFZ0WMwawzCs+PbP/yL7w5FXL19yPNwDkdAZqL3mDqgOsiSpMQp4Nc+RaZ7Yawcgxsh4OhGneaG0VIR6AKrpq5P9q9VG1kAumFywNZHmI9N4R4x7nJX9/tLgBBtkh20t58/GwR/2rwZQMK5WUVLJOX1u3H6OlL/DOpkoViR94d20SpdG4hZYRf+QjTPOgaAOPXmeKCUzTTK9l5TLKoltwaRKUvJxNV6mS0x7X0K2d2qjOs+zwNMNzeU8ePUW1GzOTRFDaweqRV2phBBYrVbi56ub5GXIyV+rooYzz1684pNnL7k/JeJcyQU4JfzdyGZbGTqZDi4p8vr2lh/98BV/8pf+ZZwNONchBGdUW1W7kToZrxIIyyM2OqzVfJ2t9DEWvVRDpVxd4YNht1kBhpgmTqc75jyKzlwjJ+tCrqUsbg52sejUiLosZMz5L28leFRBjwscjjMfffya49QxV8fVzUPCes3z0/DukPqCLlHDMW0+Rj6KtDSklrpQn6h6b+LMNI5crVeLYcMcEykLjzUXqVwXu1s1nTc6EeyNPxcYy9pgGQaZp5mUMotrmHm7sFqeFVqRK0+vHVlQxQACw8ObB6zX62XwRYOI9v+GlkQYxjHy4uUbnr18w91+4nSMxFKozPhwYrXZslaOZy6Fu/t7/tE/+i5/9lf/nGgeex2gsRVb22CMvJ4lQb3sSmpcCx1GkN2u68BWJc9Xcrqi5EznLJtVj7VOEKrpyDSfZNK3NhFtvS9VUKiSLVSRaGv9jeXXVwNKsWD57EVQUKTbUSoxVcYR9mNidpmw/XLE7rsuo3qhzQY3xcQ8TszTxGoYmI6TgAE6pd+Q03meyDlinej/iq2p3COvbfQzr046WLVU0pwoFE6nSeXQPtt+rsvraihu23vP1r0iaRVTJCbPbrel7/u3eNQN3OCiuwFyiI5T5HCcub098ub+wP4wkjGsVonVepDWqbr2xBj5u3/v7/GLf+LPYF2g71ZS/NtKrfJeam3Fa/stkqA6lZ6SKezA0HVst1tJCEpWDnhmv99xGmXw0jvHdrvDWuHnT1NiigfmONJ0PluLE4rw7myiNqF4I5JWl+t3ub/VYkxBOllloZ61+1yrOn/lc+H9x3ktVJSf4vhfXrpvtKFlc/7XRWLKGOYYleaStFvlxa3RIcM+lEXhwlkZXGv61fM8sT+O3N7ds98fyG1TrZfHvHYE9Y7mIm57Z+cnZbDr6yyl8ObNGx7cXOtw1blIOL8zs3SSK00SQN5PP2wYp1txh8uZULK6RCWwotZxc/OAzeaaOCXiHCWZFlmLhT5z5ixrqVVFFi2lJAO348g0CnVlOkmymnIWTWBmksYkcrvk/JDDEVMkPufpyDQdyXnCmrLoKteSqDmC687AVnt4l4iy+exh0M4z+eI25JnzT88wffZ695BUlYm6WpPyhsqSGBqalmj7EGJ3KVlbTYXj8UTNhb7vmMeZlLPyybK+WLMsOpkelUWOukdYWFydqh5S1rYN7JyooYjjZ91N5HWdb0gtdREuLyXjvV/uY0sU23trD6AAtRpevLzlxx9/ysefPicR6LstvhuI2XM8GeY5MCXZ4JyVoPnHv/s7fPMbv8Bm7cUas2ZdWGdx88Vju0lM8fZ7WZ65kcMVK25H1lrCek3oLL0XdGuOYt2YykitUQ93hHfVCoxaSDGqsoFsgG2ApEXYEjNWpmnlH1U7rch04/1h5A9+8BFT6rh59AE31hO7wO/6L4cbT0PL9dikoANeNbOMO7ZuQFUbQa1IS5aNziq6E5PwM1vVZ4zEeJ0TYHEU8I5s5ZBrB79RLVvvRfd3TvozmzQAZ6/ztlM3zQTa1GaV9nd1WpAVGcR4+PAhVoXQq26J7QFexi4VXr2+54c/+gkff/qcKRtW/Q7rA1Oq3B8nHmbDnLQ6N4Zxnvl7f/8/4Zf+xJ/h+motKFFJWH0/Rje5s0/7+ZRpif8lT9U1hFjGXmVQZhh0kNHRBZF+E6HrSRzbSpat2LBsMsLBV2crj66jloy2u4c+V11b5qI81aGs5sqTM9wfCp++HLn1ifolcZL6wy6JhiJ7m5odNCQozpHT4cTD955w7/ZEIwoUOScOBzm4RNouy9BkiQy98ACdlxamKE1o/NS6KE/UKgdJ25Ncc0JbYs0vQ4HVqOa1JlDSGWo8cOms5a7jK1/5ivqxS/yet7pzOdEGQVOs3N0d+OTZK378k2cUHHOsJERNY73bkKqhqInB4Xjkb/3tv81u9x67zUq6AwlJUJkpVXnQiInLedPTmQoDps1nV0cIjWeIAgTw6NGNoj+C4g1DwDopsGIeyac3pDQve42pddFalglm5QxWJK5N0TVszmupva6i52JRaaWKvm6rSX+R2YA//vxUgCMd5FzO3IakLv9fEItT2QOlYKpLA6TWhrSL0H0pWShUwRKCdJOskYRNaPmti1WhFO5uX5OL4X5/5H5/lPOrtaZohVRLLOWutxmndiZfnr9FE+xSi/K7rZjeaPElA3T5nO4aMLgLKmAWTWJjmGImFQhdkoFt5e/j5eXdvrnj/Q++xmZ7y+F4oGSLdVUVNc4JKZjlbAJD7TpqrVxf7aBKoXC4u19Q1mmeOI4jMZ3YH/bMcaSUyOKmSMuTpMA7HPVrsihS5KrKljWLJmqJYm6jj1S297IUp9DyCb1HyA4s9YR6ZRbpxn5e3H4Ogurpe88cI/M84Vy7SQ3VMHwWiSqKfKQY2c8TeU48ebJht9txf38v7XwJAwBCcAyrjs1mhbdy8Htr8OqhLBqPrUVTpVVVDKW6cyK1nPGtZd1aTXUJtJySPugmswSr1UqGYt5CTqu6PrQFI37Av/+d7/H85S0xGbIRjpcLG77yjW/xrW/9POu+482LHwCG4C3WBj598Zy7+z3ebQihqoSV9NJdQ0GWZpY7V3gX+nz1YuG05Nc5sYd06GS+9Yi3tsf5HcQjlRlrxDrOOaeBUSAVYp4wEawLag/IIlzN8ptaUnv+3aUkUjGMU+ZwTNztZ/bzRL9+TIqVEgbmrz19d0h9YdcZEm7PsRRtuxchbFvAlKp2mkk5YpFXr1+zXm3ZbnaUeEdMCVDkU5Mf7w1d5+k6RwjqtFMztYreaQgejEiQlJKY4yixs+gdto9zW7Q59rTXXktdeM2hej3gBB1DecqXk/y0xFDRrFoMMcHv/t53ef7yljFmsumZqmPwW55+5UO+/rWvse46TqeX5GIXy8v745H7+5FVv6bvAjQ0iIJ3Wvi0JKVtI7Uusdtatpf4ibEqMu6ccK6DJ3jh8FINEUt1HdWGZhPBIgpvigJsMtFuRCpSUBQdLpPq/Ky7d94azfL5UiqpGFKBXC2//4Mf88nzA/HxY5587Rs/m9D7WV71bZQGWPbbooZ3OYuH9+FwkCFUV4gxczwdkYRAkgGjqELVn1lLIs2VuSa8qzjXa/ELEoMypmKtwXojOqJvHfbyrJ215xg06HSu+IxTKsbL3i120ZGuu0SqLwfdWjWtu44xPHtxyx98/wf8+JNnnGbohy1dv+FwKozTLcPmId2qUK2nGsv96cTv/t53+Ff/7B2rfsPQryhWgAGjoXLurrnlNVxa2ghtRO5BmxE4b4hGhMxNj3cO72T9W+sEYc2JTCIyq6A/src6+fZcZtGNg4VnuiQamnwsv7+KAgcWHfhsoIzs53M0grZN6UuRoLbWbb1AUeUT+harIJGHw4F5PgGZoe84xkhMmZSyUlZOnE4nks6dVAzH44FhFfDe4VT5oRo5U60kHsR54vknzzA+kIrBWIc3Dsnfz10oUAlLTZgBMAbrRdKq0durgSlFhpTYrNd8+9vfoutUX/0CPzJIsnl55Wy4P5x4fXvPi+evhV51f2Q1DFTj6dcrUrFMc8ZYT8yJ/+tf/7/xl/7yX2Xoem5unnDYv0SSYKECXEok2uXWVmlg6f021uBcT//wnNdUAGvIVSgT+/tb9vtbcs5shyuC7xQgSLx6+YLj4Q0pnoAERmYDcjuL7EzOHdYNUoCh92I5c7gADHXc8TMC/23gOqXPj9t3JqjCBXWYLBVnm96/TGTON034YMH3lKze26UQjcDV6/WKGNWebZ5xqgzQdY6+E/cCcWaQqtQ1PoqTheytJTgLJVGrvGz71iHYkgetLrSa6XpxINlu1qSYFpmDWsUpIutEqUIutB2jHcAFOJxG7g8nplSoxlOtxwbPGCtzsRi/xvoBF7YYJqzPpAT748inz18QpyNX28DDh2u8wMC6CKR+883/sbZESgeUlg1JOIaGgvdWheAdnfM4J+hQRmSFjNvh+0JxnpreUOoJa5K074yh2KryVkUEfRVVYtlQ9KBX+EqkXAy1OHJ1pAjTSZ7BzcPHzC/3vHjxksPhxMPk+Ma/9tfeHXFf0PXWBvk5l3CfRIJsnhPkE8F19JuOq+sdb9680SpfDpyuE/HzzWoQNxwrkRKc0edj1e0lSHJQqzhKRcDK8MqS3+mKbjyfc2UOofMiXdUSL70aP7UURREafmoa71R50wbu9yJnNaVCwVOsI2zWTKlS3cD66glX6xXTp0dy2ZMxxFxIJfPi9StSnNhtep4+2cpxbo0mjZJcB/s2VaSUijVOudLl4r0arBPuo/eeYJ3oHmqSnbG4WrBuTeiuMSZS5jfUMgpnsiZMKYuzSikGYzO2JFgS0DOC2u6TvKy6iFiXXCWhS3A8ZV69PvLqzYFu+zXeW/2Ff/6A+yO+2hlQi/hpW1T6r2RyjkzTzIsXr3n04BHWOE6cRCqtTdLqT/HOsrva0vnGIctYa3SvdQSvahWIvuY0jaRizxPBFx0ZuDyIGuLPMnRZihxCPnTKXTXSGbgQ+r4srmzL4pDtOBX4nd/7Ds9f3XKaK4lAcD3Fr/jww6/zzW98nSEEptNrcp4UdfcM2x239/dcX11jzAqDAB4gSYuxLPu7afsfRlCg1kI1UHQU7JIqJdxdR7Bu0ZS1xlON10GxinEZzBHYU5kxJqmUmgI56pQlllPN+rg9IafIq6C12RSVZDsP+pUqRWqMlilm5ijufl+W67IorQjn1HuH87LPzfPM8XDAmcLVbsf9m+cYI+YqRdvVc4yIQUElZ5inEWczOaoaiQU39Liul/1BW4Sb7ZpUDK4afDGkaoReqBuUIHkCqnl75o0WxDact5BfUcsQNHfi4YMHqLj2WQq0UQx1HxNDHcvr2wPf/9GP+fjT5xyOE8b1VDzxlIgv9th+TT9UKp5U4P5w5NPnL/j973yPb379m2xWK6xdSWFlZiBBzTRpYP3t8rHUM6VhwJjgJaXRXKaaCs7jzJqb3RXUD7HWsBkCm/WKXBOH8Z50PJLjSK5poWNJPSS0SHQwzy/xWN5O9Bs310rMWsSeVXSwjbq0yTqYY/3cuH1ngtq4diJcK7+oDXCc4VxU8qC14IVX5F1YnKWyQsUiM+UwvfAxm/6h7rUii2KKCje3QQtZ2CF4EZM2ULMgU+1Aag417fWIZlnP9fWGq6udVC2lcEyC0LZgSilRu7AkMk1SagGm9dD7+ONPiOruYYzBh8B6s+LNfeT17Rt+8uxTvvr0A9bbHdPpjlQScxIO2E9+8hNIDwj+GmM2mjxLXImHs1tI8tLCaVwopCholVGtqsVplo/Gd2kt5WoMxq5wQQV5kfYcHLXFJFuxyP3JgJrBnJ0hFGWShyqvJ1c53HPOpGKYZkfMDh/WPHkccN0VMcrrXsc93/qD3wB+4Z1B90VcTcqmyS01JERDckEtQNFomRihSXDEmMg5qzxPQ7udIoBNy0+SrOAt1qjmqbtANpHBPmNE77ahQ0InMguyC5zXFJLA7XYbHj54QN/3HA97ahWLP4w5x1DDCBvCw0/H7kcf/Zg5CWRjrLgUrTcDr16PvLm/49nLl/ThK2yvH3B/ewck5ZsbfvKTj5mudtTH1zx9utWXr/wrayR2rXQympSTW9zb5N4ua+sibu1n4lZ4WpZiDMb0WLchmEQEyvSa5jpjTIF83oRLNlQn009ntqnR33cuugqVWqwWAZaUDfNsOB0Lu6sHTKVnHfjSxO7nXVXXpFfkjiqUqkml1EKQPU04gWcetAygWDof6IJVS01RmHhLON8YqpV9PeckVC+NuXaXK0XNPs4oPqCSVh3r9ZrVMGiBq0hkO8Tboc6Cb8t+qHEr6wKOx5njaSJGaaBiPbbrmFKVgqbfMqw2zPOJmp14jNeKD57Xb94whJ4cr3jwYGDhMRskdo3uvbQzo6GoF3txS7j1BVoL3ls17XBqmSydDykZKsYEjFvjuxtyPFLSQQay1MGnDWSKsLzobNY2kKB3uOo5I3JWLQVoY6pGCxNIWmylUojl820j/6ivtwakLvin8t8yLNqMheKcSDXRuZ7tZsM4ztRamOOsZkDyM43SprrOKyVPeekgCZDmCta29Z1Fo3bRAjI/RW0WPV7tXAGYupyNKFJYvagAlawT5+X8PeddRn52Q+XlZ0v7+vs//IiffPqSu/2JOYHvDL4b6Ddbtrsd1m+Zop7nuYjmauj45JNnPLh5TOcDonHuMSbJ2rAXlLC2d2KoVulPy7nAske2F2uoOC/3yaLGMc7SeenAlmrJCnQVayhW9gCqwajAf+VcXNWiLSzdy2lUgeW/24uooDTCiuaKmvinnD43bj9HqD9T1ObTmrYAz8mpFL51Ee/GyBCTUbtGg8Mbs0yAWWuFe6ST+wZtr+qkWHMiQYeYQAjgzoh+6jD04vRjDMaKD3rNzZ+moaKWEDqurna89/QJu90GZw37+3tJHjRB9S6IzM9Fa4cFgWqBKwGw3x8UPVNh6c4yrAPl7sTt/Ruev3jGk4eP2Q6eXITjGaMgZ69fvWK7cjy4GfTMFl1GuYdWUE9dNOfFool/1VaGEnSaoHVDU857qD1vaDZgzVo3swQxUvN4rviMBE0pGYO484iV69sHPMhGkrWFmDPEXInJgu3pVwOPvWNYJ+YoLcXBwviP/y7wX31n0H0R12fR01LOblrnxd2MI8QKVDQjHW2QLueMNeJqJlzchqTIPZJ2lpcE11Scfbv1DdKCasgUWIptiZNOjy4r2aiIuWO7WfH06RNurq+wxjCdDho6UrDJtPECYS0H/bIttSy8Gl6/uaXkvKA9LjiGwVNI3O1vefbiOU8fPWG7XnN/a0ilCEJnLK9evsDkme3aLwd8GxCQRNm99Xsv33njdrUDShJTluR0SU2UhNiQB2vAugHriraFJ6pJVNK5W1KrbnQGX+piGCO/WPmPoPdYhe2L8E5LMcRsidGSS+Dhw8f4fsIZ96WJ3XdfZzqVc14OTe1JplxIOTH4QYbSEEAAyjIdLR0XVFpPnp2zVWX23k42zzy8DEV4mW0EpD3Xc+dOvm8YBq6vduzUm35/fw/1XEgJ8l9gUWnhAj3U/9ck9cWLV1LoSzUviiarjrv7xP544u5wZLu5phs2pNJRTZI901pevX6FrRVD5OGDr8Bl/Gq3zzQpwmUdqtUjDbBo+4jR79Vui67D5QO3pE3WGLVvvaJykATdFGCirRPRr5QEtXH/9A5qMYYWy8olb2fA8v2SCKUMMUmimuqXJ0FdktOWoC760437rwNVacIbz2Yt3MlpjmI0kYvOpIgIv/eOoe8JXUOXRdXHGqNC/fJ1IpeXyKlSjJNuJ42k1vaodsad9+jlNGhA0UU3sYFvvPUz4LN7fNVKplbLOCU+ffaSN3d75lTJBEHZbaBfX/PgyftcbTaUdKSUGVsK1lZW6w3PX77gg9tbtus1OVX6IAmlLoFlMMwsKbWhmLyI97f3KmMllxtjxTvZsy3iMmg1V0PjVyQNA9QA1oN12mGoOiwlz060hZtdrYIDbdj7p6MCWlQrRS6r0UhM6XPj9p0Jaq0FH5y07JXIbHgbQc3KkQPR3/NeHKT6wdN3HmcMx8Oew+FANwwYYxjLSZANFYttk9bysy1xnslFtPS8rwyrgLOB9bDi8cNH3B0jpUp7o44iaC0bH3Rd4PHjhzx58oQP3n+CNYZ5PHFswewczgkaaxcP3Zbsi7/uUjYbaQHtdhud5gO8xflCCICNTNOe+/s3VFPYH/eqkXlaAniaRuZ5Ev08ncSzuCVBbYeANVUD4Jyw6EM4H/oNKGuFdJHl1SYOATIOZzqsr2AqNiRqvqeUqAM1shmLJp3BZEvOoiUnP1dDvEgHKqWqSaolZ0vKnjCsuBp61jWwnpMswlR4cz/zN/7ha/777wy5L/a6VCE4n7znf7+Uc/JB9O6cEfpH0fu0Wq20EEuiSVdEk3OqBW+l1W+1Yig1Y7JOlTr5vavVwIObG27vRqIKfDdkqV3OWfq+Y7fd8MH7T/jggw+wFg77fTv61BGoo+9XZ0T4nCGIQPNSMsvHMARQ7qf1DufBu4I1kXHa8+buNalIm/B4OmGN2Ox67xjHI6eTY44noEp71BRVRzjzqUXo2bwVu+Ziu2oFlSoPXSAZZ6RoKcqsAzrpuASDDSM5R4pJVBPVJ12sT2vN5FLxyF7VCkp7BpokKc2Ih3exUmglmJOj32x4surZTokXd9OXLnYvr8s4bvbG1sqgUStsyqzi/kj7spTMer2SSWFUsqiK9FRf5dC0FoL/TCxVqKVKUuAn5lOi1IQLA8vgYa2IRI5fktoQPO+99x7vv/cE5yzj6cTx/l6KFXW8CiEs7+PyfUEDBVgKoN/7/e8Qk9CTDOA6y3a35s3+NS9uX9J99EOudw94cH1DSi8x9aRLvPDixTPm8UjwhZ//+fcF/dffJ8NzjkVBRYueVlxWpBUtEIkMIIkohbA/5QZocdW2bHPehwsOHIT+kcZfIrOn2JZcCqKUc8Zmx7JekaN8QaCMcFBrhZqbi5zIFpXqiHNhmirTnJnr/EcTeP8M1+Vk+Vnpg/amz23zUkgxiylCrFxvH7LZbCj1QJwjFdE7917pFMExDCuct9SaEEJQpfOCYjt9psUYTYDEdQ2lqtil6GhtafuHFFei6tPcpxqCUHVg1jlHzuVcbMm3XcRQe/aG12/umWaxtm2ibSYEYrHYbsX1w/f4ua9/kx99/3eYxhPZFLz3rLdbPv7xS168eMl2vcbbQt/ZC9TfLFJ5TnOIChcglg6Av9WVkz26deCc94iUv12oPRVDLmIvY91KAAq/pdQZ8kFjUp9dLmQTgQjVSXxql7s5YFTN46hQTRZrab2fuWSRjUtilPJ5cfvOBPV+vxdej/UI3HzOyNuhk7McEsaKqHP1QQ7aTY+zkOZZNbpuubm50da6ZM2FwmqzYr0eWK1WGAM+eA6HI6fjqDqgmVICoXOsVyt+8U/8At/5wU8Yp0Q9jpzGKPplnefhw2vef+8p3/j61+l6T03Soso5Cb9FJ/dTytze3mGtYz30PH70gM1mLQLMF3hUO+u315tlctZ5CAFKPDAEIyLPOYrzwv0L4unAeoD1eoX3hlImnENtXfNbCJOpjQNzeVPbOV/PH+3Txmr1r65WCPLUtlKD079ZDAHMmtA9JOYjpThyOVLtJGLnVVoZqVqszVjXiCyAMYo2SVI2R8M0Q66Bl3cn1lcD/Vr4YMZ3rLQ1NtvCp3X1zoD7Iq+lxX+RjAKyiEpRzqcUCYJc7igPHvDgasfpdOBwf8+r05GbmxtOp5MgplU2OB88m/XAMPRURRNvb18BVZGVmdXaYG3HowePWK2u+e4PPiJmMTqY5khzeTPGsFr1PH70iK9++BU22xXBO/XYlpgtpdL3PbXCNI7M0yzognPnZ0fjG0HjrV4/vMb++AXGind75ytxvKPzVTRN88QcT9zdveHu/p7NSqbEQ3CkOJFyT6lClpffIBV9i93lUhvI2kRHPxO/MvjR5mXb91xWh289Oage6AndjXieV7G3xFQZNNFDMJeEK4rG1TOaKsYZEscpFVK0xCwLOmXHOFs211uCWbHawslmPq1f3in+dtUqHvelFLAs1KfVaqDfrmXgjErwgaePHzPOEzHKgF9JSbR0XWVVetqzkHbbhDFWPMM7Ry6Jb33zm3T9c37y7BVYS66ecY4i7s25uOv7npvrK77ywVMePXrIeug5HA6MZU+jcjknScZ6tcWirca2PrnsACgwoJ03KGI84CyuM4SughmZpsLd/RsKhWmeGMcRwwR4fLBM05GDSRzHLcbW5bXahhArOCDtWdHYlfwlc7n/t7TRVKMqEg2TK4DDVP+ZDRx1irI6DyDdmJiOYI6isFL0wK9WEiLrLtZSuUh60N8jWsZFbTdTLpQM02TItaOajpz++BFU4KfW8uUANVhC6EFl3nKuJJOZ51mcHnX4KARJSr13i/Z5rRLrFuH8emtp3N72sAxwtdsQX94Rc6HWTHFSmC31MyDDb+ezIQTH1W7LN7/59UVDNM1xKfLFJngQWTTOhc4SG/rf1ThSgt/8R7/JOEeJZmsJXeDx04d8/Okdz1+9oP94w9XVIz78+rf45OMTlCOrdU+uiXE68uz5J6x6z5NHV2DX2LeKK4cxlx5sVZNU7W3o6yqqDbV8n2vKA+YtJQI5ExutRWVWvMUbg3GGOB7JZk8xeVE0SimSYhQtX4PycFlcvYS2KdQV0ZhVu/YsxUnMXhLUVD43bt+ZoB5PJzAG7zuskVZm0zpDW/7w1pEjm4tzTHHGUclxIsYZ5xwpR5o+IlR1KQk0a79UMuv1Q7Ul9SreXXExYm3C+UAIHe+//x6nKbK6P+JDz/F44PHjJzx5+pib6yvWQ5AWCkUmVVMUq8WU1a6yMk0jz188o7OWq82KzWolOmBWp+ltQ1B16liRBu8qlsQ0Hrje7Silgxr55KOPKOUez6Rto4oxmeAN283AdjPIFpwyOEubyrMY1X7TB2vOU7aX15l3KHc8V1E7WK56bk21doMxDu8G8I+heEwNpHoHNjUolVIyMaYLuL8dWhCTKBjkYogZnr94yd3oKK4HN+CHnksVh28OT/n3vv2ff2fAfVFXqgVrpFKsxi4t/ja72dB/692ivWeUP5eyqFZM00iKkRD8RatHDjjnAsF3OCuWqq7vEWcw0VksBQ6HE6uVI/SBzWbF17/6Ia/3M69fv6HUIzEXgg88fvKYD95/j4cPbths17K+6tltpPFpnXPMc+Q0jnz88ccMfcfXvvohm80GkIRNQcRlM+u6TvmxhuAsxmRynFmvOnINWBIvnz9jHN9ATuTiOJ2OIqTtLOtVYPX/Z+9Pgi1bs/s+7Pc1uzvN7TLzdVX1CgRAAiTCEAhRpEyFqN6U5JAYpgYaORyeOUIzRXjsgcMTh4eeeCLa4bBJayDJcphiwApTlhS2SMoyxAYgAVQBhWpek91tTrObr/Fgfd+397mZLx9IQq9ycFbFq8w899xzdrP2av5rrf9qagQdnjAqn6Mib04hJVlF+x45qZIgkLVrgRipCCqc2JCMzoEi6gpbrSA6QpxwwYF2gj7HKHvn6wUiFyRpjEomT52TAZLJaQYnA4+744F9r/m42aCbmqg0P9N9xP/m5/+VP3Q9/EcR54VIPsZHAT0JQY0BnfgLrRXn2a3WXK077u5ec/fwgFGK1XqNcyNlxasS5oSry0tqK73vWsHDwx2ZGswYyzQFjN3SNi0fffQhzXrL69sHHnYDw+RmJ601bVvxyUcfcvPkmu12TZXoc7yfcM6X3taqkpaq/nik73uM6QjGiHNTana4ObkicHlzwcPhpRTercaYwNjvsFqSZ4LDh4nbux0P+z21nbC2pm1r7vc9rlIQPXkYLEsOPpfmc9ZfBYlKcc64ljMXuQ3icY1gWaWJsvEpgqGhNheE6imDewVGmFViSK1xIWISXJt5iyW2SIFwjAQHPpjEeQrOq5SsrTHW4G1LUD/9Iamlzzpl+JkZCnRKVI2uqKuG2lbJ3gXatkapDeMoG+2CF2J7B4ToWLWVbLUkX3EjPdaLfrfvfvdTfPghD/sBFxS2rtkPcm3kmZIEJK8IXq87rq8u+fiTD2mbmrvbW4bDMYEWEh7VdS12NFEz5j8FpIsFn1VK/HTfD2IfNYLiWWhqi1aO3e6Wz79s+Pmf+0UClYB+qZK73z/gp5HXr1+w6WqeXHfzMLV6XHVNekZME/3J5yMMNWBPuxeTjc7vlWBSk/nXY7pfXmlhuDEVig6qC4bhlqAiaVUEMfENV8oKTyuqXFeFmp+jkBMUeYyCy61W0kMdI1+rt+8MUMfJYUZHjNJcr5RMZYYofWrkMqOeezfysU2Tw0ePd6MQcjdN+VnmNpV+VVFi52XCfhodEYXJQWqlaZq28OZpY9huN7RdoOtWXFxs2R8OXFxecbm9oG3EIZOcnAQLIaFfoUzoicPXxISiFc6+zDvHHHg1dUVlFbZqqZqaw9jjnaJtpKfQOc+rl8+pm8CmCYx9oN/vUQSMVXRdRdtV5UGay1uUm6pSVQclK/lK8J+UTJ8UQkk9qKKUpX81ybzkQoGyWLsihoEQBlQwRGVSIJxg+9QXohfpb4g6UfFYRg+HwfGTL18whgbbbKjaLbrJZkGutVmP3Hz68p0K903JsR9omg5j04OQkioWZ7ksk+cr65zDT8Id6RJJtE8r43Jwq1NflARB0j8tDiM7MNLwRC65S5JzfXUF1YAxirqpqVOV4OOPP+bm+pL1qsMagycQnOyoHoaBcRzpuq4cs/MTD/f3jHWF+/DDuYSWdWmBQtW1rJrURmFrg1cy9V3VHQYLBF6/fon3B7ra46bIYX9A64A20K0aulUDKm+Qyv3ikRh1CVCZT19AqIVklCojZCfI6+JeAKVsFdKGHaUs2tToqsHEmmkUOiE5HqkCBB+KDcq8hYKSpypAClonD7cPe16+PvCwD3SbC7bXDbqqseuJm199P3R39JHjmAYtodgjUuIbo7RTkdDAPNgkk90T4yBJclUn559tiZbXhLGCVIrL1RJ5X0hsBzUOW1V0XYsyNTFqotozpXkDrQ2b7YZnz57y4QfP2GzWMmSlJOl1TipXQApSDT549ocDr169wrst19dXmMThKA4+BWrZ7jZ1KW8KtVAk+pGm1vggvbV3t7dM/R1ulM1OwwBt0/Kgjmmxi4LkB0RiLvKS/pJEyry5x5lUrp5zqdn+5n+nCKXYk4yo5XOQ17RUF6uKYZCSr6yZjqkP1WOiFqBUxRNkLHNju0l4baXHWOEcTFPk9cM9UVVEbwnVTz9AzatMs0mQAJUTnwuKumpYrTb4SpDQ/nhAxbQcpW2kchQFbdMKjDWyejonMikxDVEArxjFl6OkInp1eQn6yHGY0NbSj0Nh6Ilp3qKuay4vLri8vODm+ortZkP0vtxDpSiVqzwQJ49futsZrMiedlaM9HPxN5lKTBtpAJD2hpFpmnjYPUjPP7JqW66h43DY8bC/o5+OwDobUHLrSyzXV15fEDykY0l94oXSEMQwU7IzlTkqguJkD2mZypfYQdkGZToBtfT8bMg99ZS+QYXoq1Iz1eBi66DYGOGe9j4Q8tDU1+jt1xD1Bybn0Ua4sEKQJvwYhIYohhToJUc8b3eCcRjR+OStYpp6nlG6CGgjwZUPARUDVlv2hwPeR4wWxLaqa7rVCpSVKU6j6OqGBthsVgQUx2HA2obKWLmXuZSenWJ6ODIXX/CCSF1eXECa1M7UExl9zI4ApNfFWkW7WtF0K/Zf7AAte3WVKN3hcMc6WFZWM/qR3cMdKkbqSlCGprFoHWcjNoeQCZ5P91oLOXZWpJizI3Qh21flENOE/1LB0kfHCLmRWplWaLBCjXMVgs0HwEloGfM2kox2aXwkZeuGYfLcHwa+ePkKpdest0fWk6OwGSqIBJy95+Hy/wf8M+9Uum9CjsOIMjWmyqTlMlQTVTZUGSGZjSlA3w/gRyGd9vO2EkFYEV3SMggRYsB56cF0k0vJhZ4p0uoWY5JhNZquXRFSC8xqs+Zw7GmalqdPntImHVRR1kyG6HEur7Ib6bpV0cdiDENMJOBzYnjKfB5p6lq2sJgK29TcH+4IXkjZjZYp1fv712jtaYxmmgJDf5B2FBXoVi2rTVe+dw5O569U6fpk0SqhufkN5Cd+Rq++TmJpTLdyH1VLRcvxKAhMRBXmAO8DJqMAOY2IajaKQXrDjuPE6/sdX7664+HBcfXsGc32mtpYvNm9N7o7hggpQD1Bo1NMRZQBkVmXxTYfjgfGcZTAUGumadHflYAEayt5f5QkOOjcpyaOQuyxBE8xBqqqwVbCs6xsJT2/R+kjffbhB3zr44/ZbtdYa2TiP8gyFglQZRAo2/5pGmWb2jSgiVxsNtIvxawSsj1RTlRWoaZKUGUIBIKfaJsKHyo0gVcvXjAOd3TNgNWKvvfUlcVYaGoJbFDZg8fyTTNHLuKLUxnglM9yLt/OQWpJb2eU9UShMxYby7OotKzaFii4PDEFDc+2SKWK2jxolO6t80L87iMuDfj1g+PzL+5RpqGpDZX96feg5gB1YRXk9YSi5YC1rlOAOlWo6Ll98VwGd9ZWmEqi9DpCQKUYoG3aVN7XxOBEzxPZfPCJXcFYjLZcXV2CqTH7owSAemRe0iHo6eXlBU+fPuHq8pL1eoVJVdy8bRCgqiqm0RN9TMnfiFI1NscTzAOzYuESfZU1RNKinLTNkDChE9UjqYJ76yb8OGG1cLRL9UE4s4fhgPOyqrfomZqv7TIgznZ5KTPTQf6dORtTebtS0dPFbVvSRWFQpsXYFWE8EvW8eCJP8sd0Hcg0btn/ZC73xNog1KP5z0AMUtUMX6O37wxQc++HrDcNqZ9rXnXocxahc09J2jbkA/cPO9ra0NZWsnYrvKdGm5l2Lj2gJN5Pay23t7fiVJtKMnUrva3aVKANtrJElQNeQVWbpsK7BC7HkFZJptCdiDGKrm142Dn64xGfSk8ff/Qxm7ahbeoSLgoFgk+9LTkTAKMUN1eXrDdbfvzjH4KeGA97UJMwHTjFNHjGxqLCQH84AoHtRUfX1amvRuDzkwGdBNkrnaeeRRl9YjAo6EdacVgqTW+RYhqz3cxUG9piqksEIZlwUy/9aGlCT8WY+oBsodIYJ5i8YnSBh0PPi9d3PByOKKXpx1GQFDJqFiFE9Jc97a/9LvyP36lz34hEIpP3GOeZfL6WqmTmxIixmWBf9EWcqJTgBP0JWCttDDPFiLwvT4fn7PZ47FEYrFHYKidWG5QyoC3KWJTVdG3NxcWGqKSnMkZkt3aqgxQkKwUI2ViW1hqgbRo++fgTGqNoO1lDKucBIa2rlKphpG0qbGW4urqmXXXcfu8FqICeBlCK4D3DMGJsJKw6+n5kf/+a4CZUHdhsWi4uVqmHVUFBSbIeC2XJqXNPCU9ZliAlTx1z+entd2xpSFVChKFGG5MotgLYO+J4JCZSFBUT+pCPJ6b+qwguaCavhB7NwfPbe57f3nO72zNOit3+wDBOmKpFfTHS/rX3Q3cnH1DKM4VY+pRBzitXfJaJVYyR47GHKHyNNg9NBZ9sc0gDp5W0WjkHMeC1DPQoU5XhNa01Vd2UYSatNVXb0G1WtJsNV1eX9KOsT7y6umKzWgs4FRwqenQUDl2fll5M0wSo1K4yMbmR4eh4dn0lOp9KtBEttFVpE5tWkbqu6VYNxlRoa9kND0zDkWbdCa9kULx88TkxDtirCl8ZxuCZXE9lFdtNx3a7KhSHMURpKdGgVLIHGRVF3qSiKuuks//IVZETgGyxKU291SDLdDQI/6/WEWVvCVEI6qX+6WWBTFXlmLwAPMELU0VIrDCeSrb4ecXoYXcc+f0f/Zi623Bz2XDRPP/DVMF/JFlWUFEnPwBiCVAlDrB4pO2u70e07tHGFL3NH2StpW2FlSJGYfOZgud4lOBNaysthBa6rsYYxc31JXW3pnk4cr974GE/EkcZUlbGcHl5yR/7+Z/n6upCZlKmkegd0zTIEGyU5RRVVRHCgf3hwOtXt/Rdzc3NjVBllhaGcqhSbQuOZtUQH3rQCmEvdEyHB2qbkg4/cXv7GsuI0XusmTBMbC9WyI404Yxt21rsXMypki7PqVjLfL3VIkjNrBAp6Smr1PNbFzcnl23LS7MfEXL9GsMFtj4w9LtELRWARD8XXPoIeRZkIZBQNRaKNCf/eZ+Wo3jF5CTuG93A5N+tt+9GUAGjPCE6vDdErZhCIGT3EFxB9IiKGBTew3HocT6gTUvTtijvUEh2I4FfBB1xbpJp3ATdH/Z7Hh4eUNst1mr8FOlWEXSiQPABXeVpPVWm3lUEm+5aYEZ3rNFQ11hj2aw2HI5H9rs9MUbWqzUfPLnGpgxgSeweY2R0U9rnboQPs6roD0fGyeOdx1QWN4yJTN8ADd4FXr14TXRHght5en3Jn/4nf4UPnl2zWjVUlaY2duHcRS+cm8DL5GE2VKjTQPaxqIWOLfuh8t7gZBJQEq5gVIeyAqmP1YR3ARUHVIbpyby3EentUbgJ9oee51++5Ae/+yPu7/ZcP7mQndeJEqSqbTlG/2nPi3/1t96pcN+UjH4iTkeUVvRjRz9NZLoukKzeKpVW0UmbxuQ8D7sd21WLNRWkPqSuW6cSUkwJ2Ew2LFcYnr94zsX2ghCUJG5K0wEqtbFkWh8fQkKF5M5IPBpyaiRBFxIY1HXFer0ixMjQD7x++ZK6rrm6uuLbH3+EPWURASUohgzQJPQmColIbWXRxXA4UrUrpn4g4glBE0ONB+5evyb6nn5/T5gc3/nWh3zw7Jrtpk09VAGrMh1XmoTNSkskbw6JMVdcFk4rDX8salOLaoIMgrB4tfwo5n3ZHeiIsU+IZhQrGseEtnjcNPPDZkRxcpEpaEaneHV34Mc/+ZKf/OQLdseJbn3J/nikHyaaLuK+c+TFn//7f2j6948jMrluhIM4vRbSYFS2DSgZUE1+gHHy1FYGSkxiWLC2ErXQ+UpL8Kijw2pLjAo3yfNvtWyVq+uK9WaDrTopAlrpM4sxcrFdc3V1QYgU2i4bFRDILW0uIVD5Nud+f2Ns4Ufdrtd8/MEz6lpaTERFgsyvR7FXMQQut2s2q5b19hJbV+x+cItzA9r0KKMJwTH2wj0cJkW/GxiHPcfdnuBHrq83PH16AdohbFspBFzEUSb14ZKCDWUURuXgML0xenQ0iSotgTILvZ8/7bHkamEDSmH0E4wdJOmIg1QavPSalzYzrfFOeJjLIFFQOAyTM/ROs+s9n7285+5woIuaqroH9360p/xBZJomdrsdh/09wY2pCukYhgPTZMiT59ZWNE1LUzeFizvUFcpUVE3H2B9KBRbvmaYBY2uM1VxdbtlcXLJ9WFM1Dbe3D2ht2F5c8Mkn32K7loHCGKWVKToBafq+ZxzHMhSltbAQ9Ye9rGU2lraqhSEgJJ1VErcJuCXcrFVlMFWDrWucH9DKsWotq1WHqTtev/yS4HtWXaCrI7UNUkVTgdpqurSlUOxmigHUTCP1hrY9qvoCpbqq0kICXaoAuSIQUrvU3H6RDYpgjxajO1CXGP2AEEt5NE4YDkIUDtZ0CNGXCY80QB/B20JT6ZNv9M4wusDhOHC/f7fefs2qUznXECKT87IJgtlopqtA8HOA54NnmjzTKFmOUWL8nPP4AJObGMZjgueF2qGyFcpaDseeqq4luh4nrDGsVyu6rmGaApMLxQ5oTZpC03Kx0Gk6Mu2vjQFlKpoqXXSluLq8IDgv/VlVVbZPaObiTYTE/xrKRJxKwe/t61uiUqyaFdrW7I55YKySdaOpBGUUbLdrfukX/yhPby7o2gqrBQV9Y7I8CsXQ5KZU1ojMiw9m0nfRwZztR1TqcZkxAE7el9IuuVcxISW6oaovaP0BP+3x0RN9jhdmBY/IxN3kAvtjz91ux+v7+9R6YfDOM05j2lIj10Yp+OzY8R/95i/wb/9rX6tV34jECM47hnHA+blUknU1BEHbXdLvfhiZJqErMsamth0JUicva+IkOJWyZTQWgsbFwG63Z7PeJHRL+HiNNSXR0CqtVl2QdhqlSpsL+bnSOtF8WMx6xarruLm+5njoBU+shdi6tkYCXJgrBsg5hRhl+xfSl2i05ng40g8jIKuD3TQJSovQU0QXOE4HcD0xOJ4+ueRP/PE/xscfPGHVNjJVWyl01G/or3dpQ1w+j/gmBdackKWkUucUKluTWY/LtZBojNx0pVRN3WxRbodPPJKkga1MvUSqyoRoEi1aZOg9t7f3PH/xkmMaYAhBgoCMTH926PgP3xPd9SExLERmarhcr0tJgXcBb/IAmKyI7JqaqGUVZFVViR4Nec5L+5UEuVIqDRzHHoWsZ5YYzpYAWCtBRbSxMtBX5fXS8sArUjtHug8qxmIv67pi1XVlMCqGyOXlJU+urvjgaWppSQhOdrohtavksqHVmflEqgv9fo9pavw0gesJwRB9RURxPDj6ODAeH5iGng+f3vDRB0+4ud5S15rKgI6mVNgzYfmsg6oEqXkxBPmSgzjxHBgUB7gMUJevyQ0rWxejAlVR1VtCuCBGJ9zEqX+1+E8V0+pljfPCPuG9UAe6aDgMkYdjz4vbA9//we/T9z0+ahSvUd1P/vAV8R9SpgQCLCuDBeovuB9l6Y93jmkcpC0qoZJAQrKFq1cpSeonJzMqwyDrT4kaWwnXb9001HUr7Si2FsaHSlPpCm22rLcbDocBUNR1Q9etEgew+FtNwMW0DhfxD4U+U0mlzSQqpa5tU8VAUN4ZBMr/itR1xeXFhqrpUFpze39g7A/U1QXKGoIK7B5u0crTVTXRKKYwcdjdopSnbhTtyrJa1an1UEDBrFrGxISMKhYms6CguZIlaGvW22x/59/JPqPY3XKLFihoAFutqdoLQpQ5lph29XrnyUGtrEFOA4UZekhLDnwa7vPREJBFKZOL9MPIbnf/Tp362gA1kptaXXqA33wos6OPudcvypThMEwYpWkrg59GycZTgDBNk6xpTOVTi7QK1MaUckrTtegF5C8BqSAuWtnSu4mWCxpUHhBJBPipdJ53wQqxuBhnbfK6xnTbVL4x+fzEGcRAMfi73QHnA+vtJVXdsj/cErxL+2+F8FpbTVs13Fxt+eTjD2gamwhyFyRdycjnBziXJssQV5pg1kbLg65zxq7mc36bcSwtCfJ6ngSNyUhqZdCmwdo1tloTgyfEHsqEO6XvKQboh4lXd/dCODxOoGqMrcr1NGV3vHxlf1vz/b95Df/u12nVNyFyTZ0LjM4Vbjhgvt5eqDikt1q4+SbvZf2aURAUY1qT5ybHOI1MTiZM66qWwZTkPI01ifKowmjLqlvRtDXjkBFRMYh5j3NGbYiykjSPYGilUzAiCGqe2tx2K5TSVJUgUVl3dVRp6w8lAAkhLclVcwlyt9sRgLZuWbUrHvZjSYiU9Sg8wTs0ga6p+dmf+TYfPLtmvWqpjE4DJxqdFncU1D5GgpIAMSRkeR6WUCf/ZWq0uR81/5n/HhdubPFn/ou2VNUaVW8ZXE/wk5BGI0m0SkFFiLH0vXkf6MeJ5y9fs3s4pHtbA0KB4lKf5PGu4vt/6+P3Qndz8pTcUtFdeT4TQpwQ1WmSNafT5NB6lVZ5St+mMRXOZ95eCVA9HrTs3Z7Gkf3+ge1mI0NpUIK3HMmJTmb9laNIg8XyX0pO8zig0YrKWjbrFXVVsepWDP2AAq4uL7m82LJetalSlJOKxXmnADoPhxEiLvXVBh+o0KU9KYZEMA70/QS+xw09tTX8zHe/zYcf3LBZd9QmJVeLUr1K1QWhwEkjxennYfGeElQtISsV37DBGX8qdYEy8EWKfTWmWmHDljANkLd8RY/zQSb5tcKh8T4Kg4qLafjS4oJid+h5fX/g5at77u52DFMgMKLCnunw00dQXdpYp5ViuXFyDlblHusMvCR7YLROg3R5ECqhogp8DAm88dTGMk3C4OGcTyu/ZeCpaRuqqkUpi0q0ZMpoKlWxsnVK1iSY1EqjEotOLENBaZ7GyoYl5xJPq/d0XcfFdotVirZtJLHJ6LpOyHvSA62ga1sIhna1IqK4v4+4caAy0oQZ44QfA9GAnzROAXFg/7BDE2gaTddaqkqVVdZqoWswF6LkMdXJNiRUkxR85viChKQuDetSn8vnzvoeE2AVUChdY6oNetyB3hMRsERY4CIkEKRUalL7m3cxMU+EMgcQ0LioOE4j9/sjX778xwhQ520QgehAJUqdha8HSIiF0AeIo5Ce1HGSbVHRW9zYE7WiW8k2qMkdRQHT7t2qqmi7FbncaStL23Wyxu3YJ+LeOmUHalHaVkkxJOCMShSwsrYkbo9RS0G18o0Rw1Qi/wJ3p59HKcmuVivu7h7wwySGd7XCqFuid8SoMQ3UlaJtW7armmdPr1gnLlhpjk79d4nLcTZrGXGCnP1Ia4EE7JnWQidtVMsy9fImZNR0qXIpGQDpZZOp3QqtV1T1ReojCRAyArY4bR85HHqeP3/F7d0DEY2xNdZWVJUtVGAp1oMYsfeRm//3su7805VAhDSwkYEMFroQMtVF4hcMAZwPDKMjVglh2h25upGeO+en1CgviYI1KRhAsV5vBFFWYJMuN3XNMOxRypTWC2PsTFivNAsQGvRiTerCiGvJ1hbbayRbFZ8mQ0NKZQQzD8AEcuuG0YbD/oHJebbbCy62lxwOLxn9KAgBssnEGE1laq63Lb/wCz/HetXIGledkU8SeFZScEmmEmtG7plLYJQkgjpz9i5RVKT38CtUpSRLC/2VH2i06bDVlsnsiaqXrD3KJH/etCbtP5A5UA99z+fPXzAMIwGLwQjBfGrfiTFS3av3RndLgHribKBEPKm85l1gHB3jMDGO0hYgfLNA4kseJ9HZELzQ3hiLriqGceB4OLDb7bi82EKUNbWVFTL9UKhA5Ai0sIFTBoYSL6gktzNOI4tQDF3bolCEqBiOPU0tdFht22I0ECIzuVhyilEGGkPqP85J0PFwICAzEXVV049eyofRghGqodEdiX5AB8fT6wv+6M//EZ7eXNE1VSJ71ylAVRkgRsxDLPQ3J8OmzH5jyZlZQAUSN+pJsGpm3WVZaUzBi26w1ZZQ9YQx8VGHQPR5GlqSU6H3E4q/EEAZxThF7ncHXr665dXLe/zkU0XREfzIq/u7P0QN/EeTHKCqxXP/2PcuGXSstXhj0ASqqhZaJyWIoUoMEN7LQhQNKFszjaOsKI9RyvlGyOdtVWGbCmJawJCMrI55gMoUm5BW+KV2wFiWiFijaeoaNzn6YRTua+fZrNZ88tFHNNbSNk1JzPP5iP1TZUXtuuvwLtIljmwVI36a0GaEIK07BGl3GodBtmH6I4fdHq0im1XLdttSVQprVTaEKdDMPmJmi1FRC2d+yFWS1OZXQoJ4Co4tHjul0mII5vghJJS1hKrKoM0KYzu0afDqkILXWMAtiU1tavP0UjF34KIs+glRtlYGFGOIPPQDL27v+ezzd+vtu2mm3IStdckOfZB1lyHmx292VCHk4RMAhY95nZnDjUJWb71npTRt2zJOR5wfpWyanNonHz4BhDiXENjtDgzTBApWqxVtC+M40LQbVAgYHdPeehkGMtkBaqisbLHKVRb5gVz+EhwWC6KSwqbeQhMTVUKaFI6RD5894+H+gcPhwGG3h6jxfkI2W2gqG7ncrLjaWK62LdfXF1il0LrAA4mWSBCfObsUkyZ7sGtB8zJEv1inJwNMMjwSfCilyeWO7NM0P7+arLEWJXEeMBeYyhGOPZMXxMGNR2L0s3OfAg+7A69u79gfjsJb13Q0dU3TtGXdZu7TCjHyUfcF/84v/cfwHuzjmbyTABJ57nxGFUkDRFEeyxAD0UuQqk1FDJq+n3CTBLfDNPGw33F9tcE6iFFWbjo/MXmNti1N3dLWLSFM1E2DMprXt7eMcWLoJ7pOAZWwAtimoAuFUkarhD6JgRRj/ngYKYkCch/c8qX0F0EBktEKUFu4urrk4WHHMPRYa3j69ClffvmK6B2YSG2haS21NWxXNR9cb+maakY48zHktcIpAD1xwCpP+QfI6IhOPYxKUel5IC2k4bCYhsyW5zcPWpw+nzFGSZKpQG3wocX5ikpFiKP0BseMwIpRD2PgsOt5/vI1Xzx/iVEr0JaoDcpY2rYryOAn6+f8O7/0H/I+6C4RYdGIM3pagiVUAW9kQtmidcXkPLtdj1UweWlFWW1W7HYPOCe0PUorVt2KqqpSqwo0bcswjVTGctV1XF1fsb3Y8Pp2l2wOadufATxGWUmsIqioCNEnh2lOzE9eG6y1ge0ao1KyZRSRsNB/VQAOQf+Xa7MNEHnx4gWT81xfX7O+2PL5l68ZpxGIWF1LcpaC6FXT8qv/5C9zc3NB21ZpvXVMDChqCRKl6yrbiYTmJw/nSGlXayE4P1lQk+x13lb2tnt38gXIkxyCQkeLNZf08YALe7R14IP0YYZASMHuNJEGKCU4dpPn/jDx6vaB5y9vefHqns2k2MWI00Lif7/76RP1L+c48rV5w34h9lipvBmvAu/RWrbkaS2NSzZYJjcQgiN4qI3FjRP393eEGFiv17JdS5uS5OcvtTYlLoA1mWpN7r9VOjVwxMKlrJTEC03bcKGE9/R4ONL3I21t2a47ri62aV4l+YyYEcsUMyRzFWJku9nw/MtXGFujtObh4YHVaiVtVU7hgwMaglM8POzSLMiIH0euLjb8/M/+DH/05/4I21UnyH+uoEYKj7u0+mTkf/YjQcm0/DK5Or0fMwAnjEfZfyT7nUEzcpIlQI6mxdpLYjXSDz0+SBVAKY/X0iqmymIU8ZvORSJGeMhR+GAIKF7ePvCjz7/kh5/dcb9720M0y7uHpKaIx0kGojVhchLtlywol/vAak1lLD6X05XCI4TpYfI0yiYnIgFY1VTEQSgcgvf0h56Hhx1d18kQiVZUTc04DSileHh4oO97Li8vy/Fl+h6AgGQkuRxlUxBQerhipr0ps/LpaZF+1ry6zsdY0NgcgE1uxBpF21gUgefPP2d9OHDYH1Cmoms7Vl3Fh89uuFobtuuai+2aphaet7IwJ87l/Kw0ChYPmBj2mYp4dk7l9/N5a432MuGptC7IxamI8ooiyiTtoT+kbKwGtcFYRwwDnhGfwTAPx/7I/vlLpuOIc4GgAqu6Yr3e8uTJUy6vrjFaS79sQnaefBz4N//F92MbT9ZdY3XqtxOEQlYHyr3WYseKs8yGbJxGYhDkW6VyaAiyKq5pGsapF9oRN0mbQ92yWm8Bn2hPPLvdA0OaCM2E+9bW2EqWA2gt/ZzRgFFGUAOde1UVStlFcrXEZbKkIFWnoDA5N2Xlc3WU4G/oJ549ueH29S0PDw/cvb7lB+F3OfZ7Ak5mjXVkveq4XBuuNi3Xl1sqLaU3rVIRNYojVCopCczPPxJc67TKMmfvOWLRWoNJG6igoIOZWUGhCkPFyemRMSkS0bPjcPsa3AG8p6FFB4tzQdo1smFV8tnH0XO3O/Dy9YP0VibeP4ulqRqs1hglPdXbDwb+R//u+6G7gGzBc7KXXClDjBoh7p8RZVmVK+X8EBX7Y48hENwkgECz4/Lykofdbdrepxinnqo2NG1Ht1oDET/1bDZb0IZ+mFCHnt1+z/W1LGiIwZX986ropwz0RDLtmsEaA3H2D7OTjIUP8sT4LSUn7CYVNANYLcBEZe9x04S1lidPnvDy1R19L7RxSkdWndBRrdo1Ty5WklylSlxBfEOU6fw0yGFMDjoDykBVSWndOVeSpqg1ysxDgTq3BaTWr5zsvn2Kf7YrBnAqsL+9Q3nH1Dv0ZDCxJgQHUQjQfUKlQ8xsOYqoLMcxsDsMvLrdcXd3wE2RwSm8MqiYaNe+4hh+2pIDuWXQLuu/J7yLySZ7aQe0FqNISZVM3WuV7IytuN0/cOiPQiNWWZz3tF1Ht5JefdD0Y8jMZUXfjEnV1MLPCXhVONhz28y6bdmu1yilcS6gItSJRaD0KXN6v5VSTJNftOOQ2gmCAFkoKmNpbMPgPC4MeBwxzdAQJqIbidORrlH8mT/9q3z6nW+z2axKDFMZW+CIEvDHSPACAKZ6Q/EOkizGZDfShVAqzVTIyeocfJzerXKOOorNdZNnf9yhVcQoTaTDUVMZ8FERg7Te+HFiVNJUmKviwSuiUTLQGKGfPLf393z+8oEvX7zm7v5AVBfv1J93BqiZDL5wLSY0W0UD0RKjRWGTAiYnadIUXnJQQlQMMU3iZ+NlrWUaZwPm/cSxPzIMA23bsN6suLy85LjfC3dpCKioxLGYStxaVJhc4tTi/gT2jmWNnhyZZAfy71BuQkrUKWlEwYzkpZgCakHXFN16xdX1FcbuOfYDSsNq1XB9s+XmZsP1xZrLdcWqrWjrRhCIbNDzE5MTzJh7QnLfqyhRVpFlm0HexlEyHJWcfpj7Z/K2oXw95ZPn/duBgHt1y/43v4fuD9SdZdV6dOw5vrojcOSis4TRMR4G9DCxed3TjBEVFJOGoBXdesMHH3zE1fUT+nFgt98LIuYjnw0V/97LT/ifv1PlvhnJuqtDTBWYnMkvUOX8r0yAnByFCyH1HotjlRKFTAsbo9CTVAj8NDFEjbUD1vQYa2jbSgKfROeTA1TvPU0jiJAA2ipNwkuPtPQIzzyqSqnSHQUzclPGoWLWaTmLnFDJqWmiikQvw35Gw6qTDTu73YEQI/2xRxlD0zZ0reV6u+JqW3GxbrnYrITcX73F+cZYDGKuiGYjmPVTmaTnj0qmp6iK/FucfSgI3Ky76X2pijG+vufh+z8gvHxJbRWrVUSrkeOr16CObDpLGCeGfuBQBbAdU9NydJ57HyWBjeLwYoz4SSbZpQAR+Gyw74/uhiBFuQAElRyNKjbAGOmV8xl1TJsRxnGkUkBq7xjHEbNN1Q5kR3nuW61sQ20NdVXhrKaqa/p+ZBhlo984Cpm4MWJ7ZDBDFZobhbQgRWUpOq1AK5vsbXpXKtkm/GABMGaXOqPvEhjqkpM5F3j65Ib7uweOfc/Q99y9umMcpGVBaHwCTd2yamsuNzVPri6oayuoE2kAKlWFMn2UUpTKjzDyKLSx5BJ/TMOz89Bp3ro121ehgcvpwtxqVoKERC2rQmS627H/4Y+ZfvIZK63pVhAZGF6/YlRHNiuNnybG40gkMFWG4cMLaDuMM0wu8PLFPfvdmNBVw5D2THqX+qj1Y3Dim5eZB5UTEFnax9KiHKTn9tj3DENPYy0+wP6wBwVN20iA42UYSibpDSgwVlM1NUZrvPdYo+i6jrZtMNYy9NJ+VVhFkh6WGqMCwtzQF3O/PxGUrJ0V1F8ngEI2qxmjk73K+vT4NBfDxcmuE+Hu9hYfIhfbS7aXV3z54haXWhe0BqPSYJyRbZ0fPbvgydOnMsSl7axzi4Uo5bkiJOgp8bEXSsKIDCulVrDMJJHjuDz8l0ORkjgqMl1UTH8bbu959du/S73bUatAu7GgJ8LzL/BqZNNp/Dgw9D1OR/SqxT/Z4KwWWxOBaKSPPAT60fP89o7PPn/O/cNB6Kb0Ix/xSN4doDI7elLWKGen5//QJ2W73DNZjJBKDispcPAeYqRtG2l+n+RBl0kvz+QntFGsYkfXdegIh8NBECht6dqVZJop+NLaQNTlO+R6ZweYAtYFGjm38zM72pxhkIPWtPc4UfYoJCDcbDaEEFmt1ry6vWMKkc12y82TC26uL9isOzarmraxMvVsTKIxKVDYqaT+3hlSV+U5mlebzkE9+chTZKK0RqV+mjJwsLx/SibFVUrt4sOe+L0fYvZ3mHVFd9VS6UD87EuMdlxdrXH9wOFhT+0jFwdP5SCi8UoRjXAiXl5d8fTpUw7Hg9yb1N4xPax4/Ru/+k6F+6Zk1t383yI4Tf9lJCSvtQXknsSU1ETQqZ86hIi1YK1h1KJRznliHBnHgX3U1HVN29TUbYNSsNvvSpAlfdF1ai1IiQMpOE1OWSsZMsn7pVWc9fZtAMmcVZf/S8G46EQmY1da0XUtFxcbvBeGDKVk/d563bLddFxdrrnaVGw62eteVVZ0l4yY6XJ9yIld0bccnJYrPyd+6bUocUJ5NpWS6x7DzKhwUupH+GZ1WqIdHnYMv/0DmttXVLWlu2oxxuM/+wKlJy6v17h+RO32TB3ExhFvNMPoOTpPiDZ3RpBBYK2EL1QrxbRfc/+e6K6s2szXBrKTmf9jgWTmjFemqJHOCpQRJwHCEuKDls1FMTCOA7Vt8LaGqsZWNcZajsdeKI+skJb3fZ96A6vT6s3iWJQS1DTbXZ1644q1TXRkhf42J1EzWENOvZSZNwVJMBlYdx2rVYu91Rz2e7S2DENP8AFrNJVRrFcNF2vD1bblcrumqauS5JXPL5GxfHEMlGpWeY60ACcZDSvPVElq07IUlbhSs60IudUsnWL6VpXOJdw/cPyt79P85HMaa+luOqgC8bMvUHrk4nrN1I8cHw5EA1MN41VHbFaEqJkmeP36gf1+ZJpkM1o0KTgJqiyM+WlL3hiVJSfRZXAzyuCfD4FhmuiHEY3CT7LdzliLtkJ1NrmeSFoiEz2BSN1UlOFMJb3+Km2I8kGYZaqmhQRLkXuEsx5kndNSipbPMmnBoAz3aZ3ZBFJkYAxza0hOXPIZ5iHUNIwcU5iXBkrHYWB0ju12y2a74cuXt8QgSzSMjlRWuHKtbljVLU9urunaLrWmic0Vq7toMcl/zxUKcmyV/X9MNkCDMmUwtVSQF/I4NMwtRBHpR4+7Pfvf+h7r/YFGBbrrFaoC/9mXTNpxcb1i6nv0fs9gNdV6JLYNfjNvhxOkNzI6z2FwvLq95/XdPWPviK76Wr392il+MRg5C1ILyD4jIao48CiTOIvyiVxI6SsRao1pnHDjxJObG8LkmMYJkH4iWdlny+YRay2qbQvZc1U1rFcbbh92hcbHWk30s1HQijKNeopIasq6xuQw0REdVepVTU3Oi8GZ4IUY26Sp/6vtlvV6hfOR64c9wzTStC3b7ZaLiy3btqFra+rKJONpFgq/UIKY+wsp23BKZLq4rotLSLrXc6CqNMZkWpTZyT+mpbKVQYcIHmo3sb6742o64I+ebtpQWwX3O8I0chU10zhS7SeoG54Pcn1CKndpKw3p3WrFzc0N1+qGz7/4gmEYCD6wub/il//BP/11KvWNSXF2i14dhUFhIFMThWx3ZqQKlFCdpP9CkJ7fpq6o6oZxnIQ820ty5SbHNOxkQO5iQ9d23Fxds//e97DGUtuatmppq4bBRaSJI2fFqeE9624yqCEFeIqsC+H0/i/KqBLDRBk/ToF14UNF0P/1dsNTFKvVmi+ev6SJ0K1XXF5d8ORqy83VlotVRdtY6rqiqeqUYGVDmfgps4NIMpPzZ6NOmebMxzkHVpp8F5QGEyHqeRXx2/Q+r0XW/YB9/oInY496cHRuhbXA/T7prmUaJ8zR0emW/TDwuhX7Mh4dPlaoICualYXaNlhtaJuWyljWu2v+id/803/4SviPILnHv/T0xay3KtkmQf6k7GxKH61PAEBttdjFZKu1VZggvISKyNAfsboqetc0QoSvtCbEwDAMOOfY7/esV4LuiN+LRR/mwE2ACq2E+MKk3r98/Cq9P6o8hJmNXKa3mZ1/0bGYZxqEirBra7q24vmLW0mw+h5tLZXVdG3F9dWaq7Vlu2nZbju6tklOXsj/y/bCkGkK5TpopdKxUoysNgaiWaZWpzen2NbkT0IkOIdK61wfv1XFSNztCT/6MTfHA80UaMIGVS/truhuc3DUqw3s7ggHz9CBi4Zpitw9HDgcB4YxEJUhmIQA5iN8DwLUxwBJFrFFvtA3ZtaUcZQeXJwjKgli2hi4vNwyDHtclNK5C47JT2y6DXXdIi1qka7rGMYR0x8x1nAce5quIwRHRvhL7j5rG9oopuBRShc/HZLuzsBQkvxLJ6j/IqlSs7/WqdJpNTRNg7WGaRoF7bU2abcwpmgTaVtZ7NI1lqttx8XlGqNK6JJAAKR8l5DOSDwpTMnMgU5JQJpcUBqlM5vBzCuLD7M9joroY3mWS5ChpPWgUgY7TqjPP+daKerRUweHrt4SLxw8Ydvi9kf40OObyGSEY9hHxeg9hyFydxh4dXvP7tijR1CT+Vq9/dopfkE2pOQkhsOXMsb8PgqVifdS1hR0T87bGk3wEZD9uT5MVHXNxeUFw9AzjUOa/o1sLzaC/oTAOE28+PKL1F8pU+OTc4BmterKoA5L5JbsNNO0W77ZGnI7gtDQQEqjyXNsJgYMyLCFB+WVlNhSltXamk6Lk73YrPFAVcvqyqauWdmKKvWCGpsnGGNxILPz1SmzI2XwQmL7qHpQMrnHuc7SEBhjysDDclq69Kkq6dNdb9a0lxu2z674F//Nv8j3/5tf5+7FSyqr+Sf+1C/zN/6vfw1Dg9lsuPj0kl/+1/88P/xf/2/xrselozDG0HZNmsA0rDZrnj59yn6/x3vP74aJ/z17/q13qtw3I7PupolnLwsWHhtRaR2Zi+miu6QhHxkCceMofH2bhu3FGgVM43hynUOMbLarNK0v1CTX19dM00TXrmiajsl5FAprNdbYVIGgGIXZMGlKlbzEa6l3OqGiM/KTdFdpIjJg4pyTXdXeY5RQRF1tN2w3GyYf+OiTjzn0PdoIbcrVxQXbdcOqayS5ykN5OXguTjll8GV1ZCgOvOTnaqnnbyZbBcwGGabyM7WU9/6ED1EnB6KiQbWW9smWf/Xf+Av84G/9Oq9fvcJUb+ru9juf8kv/gz/Hf/SX/jLHYcR5TxNM6SP0IeKVxtQtl9cXfOvjbzGOE793iPx774vuBkFQc5LxuHRadHvB8iFldIWKRoYxkfYkjMZqS/Bmngtwwg0cAhwPPVVlWa1XPH36FO8cr169oqs7ap0TqxYfxRbmoSFJVEQ/MiuFKQk2iP3NN1pl5UnUk1lbZuQ9J9r5fF2mFrSK7cWWj+JHrDdbPvviOU1bsVqvuLq+5NkHl3zw9JLLTc26qWiqlFxpjdVpwKTopgzgSIwqsw/LYd9iGRZBQnrrG+9RKXlDzS08sLDBWlFpDUw0VvHxB9f8D/+1f4uf/I1f5+Xrl1C/xe5+a8sv//f/Wf7j/+P/GeM6VGyIaJSyMnwSIh7Q1hKiIuRtVkpWxbyP4r3H5jQgLXAIweGd0Pa5CaxKg51aYawkyMbqsirXucB+t0Mrw2a1pamqwmX+6tUrDsceW1lClHYPrTXGeIytaZpu1suESsYATaIJ1FrAJ4Pc01lSKXzxyuyO5wHWCKi0ITIChIBz8O1PPqI/Hvnx8cjrl68Y+pHdfo+PkapWVCbSNZbtpuJy23FzuWG76oQ1JWNVKeD1SD9s2vCQbOQCKESuhQ8hcVvP6RVIEis0UOnMgpdqik8hkMkVmpSQKVAqsm4r/sh3PuZf/zf+ZT77r36dFy+fw1ts7sW3L/jv/fN/jl/7S38Zx5rJ1BzVAUWFo6KfJu52PZ9/9prXdwfGUfxF0F+vt1+LoGZn4YMnRkPm2ipbNpijfaXBKlOg5hgF0bu8WNP3SOagRUHHcWCzWdP3a0IcUYdYPiNGmUR9/fo1++MRBaxWa+q64fXta5p2hUolIDLCtEgCfIyJz8zMGW85JshFf22kjFaajqFkeEohivsIkVRapabfiE6rA6212FrK+dZmBFihzMKgFSc999+JvD3rnH8nLt6nTgIslcv32qRsTp0cK0p4OqVjJTD6if00wHe/xWf/r/+Coe+5+fAZ3S/+Mdxf/c/xZsXTP/ELbH7+U/7ub/8OfRRyYpOQsy7xbw5jzzD1bM2Wjz76iB/96EeSUKyf8/rP/AfAX/g6tfpGJF8/yd6FdzD3Qcfcj5j70pJ+aCOBntYyQCWTY1CWCgMXlxccj3umaSBG6Qlcr9dooxinifuHBybncF765EY3wfFI267YXmxTNg0gvZdkOhbkLmub+1KzEZJp7ZimnVWM5IUA6pF+EyIqcEKoH1Xe4iTI7KpruGJTqhRdU7NKyH9JsIxB6Sj/KVUM13xdVQn+Y9n2JIFRfs+b07tx8fsp6dEKlCno/xuUVEpRNzXeGvbTSPz023z2//wvOPY9V1ePdfcX2fzRT/nN3/8xew9HF3BBylXZWHsVmZTCEVBVxfXVNeMw8jnPeb15P3RXhsx0Qe7zkN5cxoNM7ZWTFrEOGm0laAohMo0jQ3/k8rKjrgwaxTQ+kLkolRJn1bQrQgisN2u01hwOB4yRQSph7KiZ+qHoheielAO1PuVm1sacWDSl0hCKStUeLcemyVNxMaGzKSB30itLiBhlUCZyfbllvVoxPpt49sEzjsOArQyrdcf11TWXm5Zt19BURioWdX3CgJKRZ4nnJNHLmpmWESZsTCSzbEBCoIsPWDL35j/nxHbJ/0sQTuxus+HQtbwceuKnn/Cj/8d/xuF45PL6gzd0d/tz3+V3fvw5va5wusIrTVCK1WbNar3h/uCEUF5XKczOtsk84hx8v8T7mAAquco5kMpl/wgoXUmrXwgc+yO6UpjEre68bIU7HvbSclW31FVF23VoY1JSLq2DD/cPXF1dYU3iVUUGIWf7KsizDjKYmfUXsxw0i+Sm6RhPMXTpLV6+Jv5VK0HohY5wRBtZvdp1Fff3e3zwHPseW9dUVctmXfHxB1d0rWHTVVysGzZdQ13LDEOuUejEcUqptKbDi8haXnKbT04eTfFvpX0RIMUu8qwlV6bleK2at/CBmBZdGSYNh2kgfudjfvhr/xmHY8/lGzb3F9j+/Kf8/d//EXvAJV+gjMZ4iw+Gw7Hn1es9n39xyzgqXDCEqIn+6/X2DxygxpAd1ClZf0YJc6O7yX2hCQzXGtbrFq2ExkOnZn2ZyN9wfX0JeIahZ95GIw/85IQ6YxhHbFUzuonhbuTj9frRMc4O0Sfey6quU2lnzg28DywOnRNDU7LlefJTa1IfII843aSNQSd2A6NJNzkFsNk55888OQp1+s3JxmlyWZdHjv3UCC7/lAA1sxOoN4KCvBEDJOgehx6361FTZP/ygTBNoC2q6RiVwaOx6zVmteJ3/85vgzY0qqKJEYyirg3Re1zase2DZ7PZ0HUdh8OB692av/jle9LHx3wdQyprhKRf+fot+3wXvwUxYI2lbS3BgVHS5D+5Ceccl5dbNhdrhumIm6SEbitJErx3DGMUQzVOtG2D9wPOBeqmLT2PM4KkSuITo1CIVYnnLlmmue0gBVkSLKZhPzWXnUrrCDN9We4r0onmJ+aKTkLfjDE0tbTK2OTQM4qZv3ZWKbXQ29STqPUcw5+84/QewJslQJWPVW7GSXtKfr/3nkl74T/c9ygP+9c73Dt09wd/93dwk0zyR6MwdS3tOgltyv8ZU0lfeRf4mUPNX/zhd/+gqvXfqWRkJqb2lIwq5m1QywCfk79JgpWHj7yf8M5hrZW1oiFwOBxkiNQgqBWapm0YnXD91sZgKiutK14WV1Qxls8Q3c2Jz2wPSci+JPQU3V2eT8hh9GOaNIGLKPQ5QclgiBb7ZioZ5vKxoW1bJu8xRlE3lvV6xbqtqSuLtRKg6sSccpqwp28sNnauQhQkjFMdXf5+yQuWtjn93GgtVInLe4gg4U7JMGV4yLq7Z/Lu7bq7XvE7v/Hb+MHjjh4/BeKqwqqKmydPeP3QcxwPYg9yi0GKOGwZXX8/RdBxGQoqk/MAJNunEn1TagMwxuC1BmS4SqbChTzfT56xqthsN1zdXDP2A945sVtR0VQt1jayxjOSUP7Z5sZcWdSJPSQFrY9MF+KYVcqh8iBgXqySWlSSzpbNhKn9wGrDZrPm5uYKrQ37Q0/b1rRdw8W24/pqxdXlmlVt6BrLqmlo6ppKC9ppcttXeZpnOR1OTbylS2ugFHO8mRKrSOFpJfWJK60gc6Ez94ubKFRYbhzwDzle2Ek89hU29/f/3m+hJmHJIGq0rmAU8CFGzTRGHnYHhini/JzofZ3e/oED1PnExfrMD3JEvXFxbDFcWivapsJ7i9GW4CeCdwyDZOSXlxf4MPHixQsxxt5L319ksaNYp4DVMfUDwSeC45wlJLQw943CgvA86dkp7B3LjY4nr8jP881LS6uKocpbgIQjL5e2YmJhTTaDOWDOhPwyU0cKJigKc7rJSrKmeQL2VPIDnY348gdR5fNavizvcSHgIyhkc0w8jjB4UTyFMDKYivrqIpU4RKF1LzQV627NJlpiECcVE6ozjSPjIDuLLy8veXh4oGHFv6z/1LsV6huU0iIRmUsiedIxyVKHcr4ZY6SuDKuuwU0KFYXKQ9Csiaapubq64HB44BgHSbZzgBnEDfsQGPpeENkAk3Jst648F0sMJic1eaiJbDwK03Ish51RgGVSlT+oJC466/3sYIX0X5Vj1QkJ06ldw2jpVzKpZ6n0ti6/4LEFV/Mfxdk8fssCiVpec6BQ9ig4yeDTJxFjxOXJ83EgHifoHX43yPTrG7qbjmZIS0Oi9BRWbZMQ5vmySa+vDLZVVUV7uOZn9Hd4H6RURgB43I86v140IdubuGgninlaXaaG67pCqzUPuwf6XvhIjdVYU6deuYlDf0zTt0mPJ5nkDzEIsmOFtkaFHHjq0ppSSM/zwGE51uQg8//HpX071QNSIpmDSaUUvvCsKqJWNG0tCJiWqe6mbWispbJpKDUjvOUhO7Wn+a+5uvJGkJ/Rp0XC/zixehzEaiWJ3/J3FIKET3imcYBD0t39KPvL32J3AzBMjnGaGA+DrPXsKqpKc3VzTfvFK9RukEpvRtaUVHCa9eofRsW+YZkHT+MjkECQPdErn/i9iYGmrglO+Glzj3qMsoEy+Nwq4Hny5AkPd3ccD0ehuPPQ1C1og/Mp8CoB6oyiSmvMzEoR9FJHEttPpCiMHG8GB+aYR0WZKYl5N32UwVprItu10Li1bceLV7dEIk3XcnGx5eZqzXbdsqotTWWpKyuDqSbZ4gWKP9fW8p+pEhzjiQYv7a/WOgWeqvwX45wMyDOa/M4S+U/f4LzDjSMcRugdbjd8pd4CQkFaEHEF0RBdhEqCVaUM0xTwAWS5rNCUrpt36+07A9SMpuT+ILLDT0FaRk5LcBhCKXnnjTfaZCidNLkfGfyUeCErVpuOfhwkkg7g3Cg9EV7hRkfbdFxeXCTqB4+KsL/fsWo6rKlSpiAB7DAIZ2rXdaKU5Au+yORL34bcJKNUeWDy1CHIQ0+UoOG0+V3yGpP7WzOCuXCA+RrlGf3MG6BiNtNz/2lUkpWVrqyvRJzE4GdannKP8jF9hSENIeBdQCmHnxzaBeIEVTRAkN4ZU/HxL/0xpt//gnHfs57gn/3n/wV+/y//ZT549oxeT/Cwp0oBqncTw9Cz2+949vRDPv74Yx4eHoj1xC/8qf27VOobk1l31eJhz3owO6pl9misZHNGR9q2YrPuGAYwuiJ4Wbc4JT7GZ8+ecXt7y9A7YUjwISGU0sSeqVD6vpc2AG2ZUpUgT2VL+VEXrlW/oApbmiWAvJIvlyPLCWSUVc4s8YlKICoURbNeFd1Gl/WDmihjY8bIlqtHQ30zEJZ1Oh8ZJXhGCeIlun2KJL1NJ09ei48+M/9OOnnnIwqH9w7jArH32CjjBm/T3dUU+af+pX+O/+D/9FfQxlA3DSutaapa9pyTuRUVRI+LjuvLa9Y3LatP3g/dVVqjombu4UztTNneQrG1S30BL8T1aaVzZTXeO8ahp+tqthcbDv2a4/AgwWllaeomtW9F7u5u0UoLBZlSGG1pmo4QIm1bzzGfRoJhs0C805Y8lYGBON9rAfZTwsV8DqSXH6OtSs9cqwVoSL4EReImlb7FqqpkoKMEp2oOULPkpSsKSVBVCpZPniFVfMLJvXhkj5dVrOWzZZRQIS3vR0AGvVyYUD4Q+4ANwi38pu4eaV3kl/+VP8f/7X/3l3g47Bl2hth4ri4rLq63rDcbqrsjfjzVl7qp+OT62R9Qu34KokiIdQ5g5vuvtUZZS0xb+sZREULD1ZVsN5umiZho1FTq77fa0nZCR7VerxmHgWmcRF+MrD6dvMd7l/pZFQpT2Gxy3/aszypVfdPhSt+c+E9kYE/iCUNMXNckJNiTEiyXwLFk6zGei+2GzWbD06eOZx88ox8EsOi6lpubS7ZdTVtXVNbI0HcGDUolFmIUOqlcJ5P2kbA41jR3U/49PzP532+ryMb0s0yHmP2gMcK/7fD44FEuEPqAjamt8S0217vIn/zz/xx//f/wf2EwMGqFCxrcgK8jddPQdR113eAmjxdCVuq64ZOP3q237wxQ83ASICutlET5qkCLAfBobQuELr2hE3UtqKCtRGkuL7cYYzjEgD8e6fuBGCPWVjR1S9N0DEe5UDF4QUA8tGkarrKVDDlUsnpMayB6pM020wDZVIqq55uZ5KsmDCFB2yHinT95Tcjcc3/GvApUZ3L3nDUjD1/0QqOhSBuecvAQAp65lylTUsw7nTNOkt30svQ8o6yRGT19nIVmZGIZqOYAdXJyT1zwBOX57D/9L4njhO0qjl+85Df//f8E83TNEBVf/O2/z4vv/YCf+zP/NNfXN/zJP/lLfGdt+L3Pv+Tubid7rRPH4Dj2DOORp0+fcnd3x5ff/4K/9Wt/m5/5C//Mu9TqG5Elkl+2byA9lTK9l4Ya1HISU8qeBkOVJqEnJxWAPummrPNTbLYb1qs1h32fyslesnwcWhtiVXGx3qCsYRomopf3jMce03Uoo0ogFpxnmsTAtquO0jZDuuvLTQ4nOrF45VHbTU4mS4UhSRl8IsU7+TOC6GnMawKT+BAIKYma+XwfXWtUiT0ey1c9dTKsyFs/T34umfjkPCGOTMHj8PzkP/0vYZzQbcPh81dFd0c0X/7tf8CL3/k9vvunfoXoYF2vCZstVhk+/XTg+Wef4d2ENhFt4Tgc2e12XF9fs98d+Xu/9r33Q3eBqqoWi1DmQFUp+Y+Yk7AKo6tkHTzPPrhCEZnGnhgdzvccjgdW647Lyy3f/c6n3L5+IWjH5PHKybIJJTrgglS3AJq247DfYZTi4mJTDk4lBCofW5/e33btyUkoVJlVWN7n2aKd/jtX5ySGTZbwUTCRS+pKC55lUvCqtBE/tEDiJaF7m4Oev7UgavknC8fOG1WEU1lS96iESuUnJBKZPPjgOIZArwM/+Kt/XXR3daq72e4+/+3f4zu/8suoXojrh9FjoqHbXDKNgadPn7E/TPzky1fzOSi4ur7iX/iX/vl3HOk3K48tVAm6kMUb0i6okA16AWNVonSMeCe8nk3TcHV5QYzS/qeUw1qF1hVt09B0Nceh59AfJXXXisFNWFNxHAcUmqqSFh5B/T0kvc1rQiGxkizRSpWfN1lCoxAfUXJ0peYEK0hSOJf2U2uVklZHkk+J1KxWq+TWxU+v1h2rrsamkn4G9aw1pbqVpaD+KUxVVtDQ3B/rF7nWUt5gJOBNKjBN7nOdX4tR4T1MwFEHfu+v/nXiOGFWDccvXvGb//7/HfNsw0Dki7/9G7z87e/z83/yV6hHxcEYBqXoe8dxv2cIhqa54PrJU7773YHf+t0fYBIb1PUfQG/fGaDapsbUNdZYGqWYRl+GJ3JwOiOPiUHLS99p8ALVW2WTMQtCG6Vlot9NnnGUHlNbGeraMvYpQCXmdbnpgslF1UrTrTuZljbS8xeC9KgYW6XdvDbdzLfLsuT4ZnaRA85Fkq+kX4vEYrBonjkp6WSanKB1KgQsynSJLUAyrpCCBmEGYnm05Y8UYD4y5XP2GYsR8Lk0pk5RqHx8UhoO+QWij3z/v/k7KOdomgb10PPqB1+gVy2VNYT+yPHLl/zWl78GeJ5ePeXyk2dcPfsWD7s9TVBsNysJzn3ATxN1IxPA7pXnR//fF19x5b9ZWVKGzLc4XScNknDkcqIQGCsC1ib+SZk0omktXdcwDAeCC7gpME0Ooy1101LVtaCrQdgrIqCCtH9sV2vRLx/AwGazSgTfuXwERI+PORk0hXs098vlTHdewyiiFn+JUbL8nJxkA5uDc8owU/qVXAHN8YAX5segI1rH+djyVYvCR6jS6lgpLc3VhryLWq6lWRzgEil9C5K6OBf9lsSrBOZRjGaY4Hd//TcJLnJlLNXtxBe//zvYruLi8hI1OnYvbvnhZ/85032PjobNZsP26poPnn3Mw6vv8PvPP+ehP2IsONfTjz3jNDLtNT/63uuvV6xvQAbnWddyPcsEfyL1nUv9smIxo+XaRFnX2FQEP+EcVMYyHkemSTZSaW1Zb1pW3SZtYsoIp2z+Es5nScgztZ8kZRPOS+VgWdpUSpYDECPGmjmQzMgU4hfCo3s/o6aL9Dy9R+fWlgBLBokUnpb/CQtoDghVqS690cOsYlpWseSSPDmIIgaNxy+Q1aWGzvo5f8HynBa+JC6e26hQQaHHyA//7m/jAly5quhu1dVcXF0yDo79F5/x5e/t0E1Hvx8Ydj1rZambFe3K065b6q5Ca+ELj1o+u647Pvr0596uTN+gzLo5Aym5dUqAJJuwlMRdHjUKT1tX9GGkrg22MhyPe7R+RrdeMUwD3e4BjWyrrOsaW1W4tG701d0t0zAy9j3OezZdxfF4pGka8W/Zp6ZlKChVeE9zO2DuW1bx9FykMiR+QFQgG9D0fyrrHInSam4XO2m30opKU9Y+K4WU87UW5DQtB8hD3SEBXtKHuvBh+dkqvgMB0dQSpJjlbej/ybElB6DS+WQ0VitNiFIVM6PiR3/3d/AhsnWG5vXAlz/8AvU7msurS9TgOb54zuvP/yamXXF1MIS7wPM4cbs70ugtTVtxdX3BH/+lC373J58zhBFCoG6br9XbdwaobddSVW0J+mIYxfGXDOSxBDGEClAhlfZ1oYTwiwGb6D339/c8eXqNNZXsMFfHhJzIRaraRgJi+fbkFE+nfCV41anEY0tm/wbKFGek7FE/+xxoxtnBn9LryJ9GS+TvnGRjOQhQSl7TeqZJkdWY81YU6W1afGdGnfKx5mhhceRvor7zz2emhOToUwC/DLxzLG2SodR1i765xo8e07ToyzVYA7sdPsKkYLSaMSimYY9+eoOpW2y34rppWK+36NFRt50Y/AhumjDWsV6vuPrOhh//ym+9TTG+cdE5EzWGumnnLH4Z2TE/pFJKkU0nOvVpGqOpq0aSoZCGRqaJw+EIKKpaVnsOx7TZhkRZVzLlxClXVVhjWK9Wspo3Z+8JJVTKLNgfZv1+3Ov22FGW+7xEqdTca1UGpZVKiC3pvbHod9bteRBnNmQJ5k/fmYaM8gFFykIA+dqEVs0HMr+RUwP6xp9yAOVcl+dtxJtQ1y110l3d1HQ3N9RVBWFPVAp7fUk0in6/J/Y9rq7SrhVDt2rZPL1AfXjD9sNrXt7ecdj3MtgWUq9VHfC/8or3RbQ5RbJnlH95XeW+KBWx1lBXAWPk2lmrqWvDeJxRE601bdvStB3O9QQvJVPnp1zswRqbynF1KuGLzvSHI03dFmeWg0Lvveh3JbRk+afL4+aNfy+Cw3QacwvO0u4+6ksugACnuq+yA065upoDjNyGEr/q+3NAMWOhnLTQlIM8lRgjC/U/AQfytdTI2uG6bqmubwijRyuTdNdC2IO1VDdXYOC42/NwGJi6mn46Mo6OLgqnpakNq/WK7cWG7XbFq9t7FCbZGEPVbt44xm9a5uf5Ud/0Iq1QWlpHVLrPdVWxWa8gTtSV2NzJjXgfaNqGzXrFcLHhlbsFKHZpGoXYf5omxnFkGIVv1Dee/X6P1prVarVIorPOCGWkxHZz+1dpgYqUY17smiaDG/mzchKf36tVMvzx9DlVeRArBaMqxUMmtcfI5qrMl55pMuOJPsp35ckDNat1SbUULNX1D3KPFv5Dp41a5d8AURIf8+wpcfBYo1lf3tBUllda2t3M1SWx0hz7npf7HeMTYWIYx4mDHznmlkI0ddNx011weXnJYXgp7Wx/AL19Z4DatC1V1aCUwO7aJM4wY9KK0WwQ5hvig0t9QHKRTTK0ddNwf3dH3wti4VG8fn3Lt8dvUVWy7zb3NhllsJXA4lVli6HO2XIIASOahDAFJFL/5NRD+pnWp6hM3qowD3olFVCzUZpLS4uMIgUNRgmK6vDkgmc2rN4HrIXgPT4poNRGE38lJEor4Qssg03Jqce8Zi++GZzID8r/ZW9fzqso3eJ85/OiOA6zXtN999s008TkJ7jeEq3GKuhD5PXQE3RFVUnPr7q4wFcWgxiSqqoxjQczP0zTNKKtxVYV9UeGuz/7xTsV7puSqq6xtWzBabq2ZKgpNiT3gao0uRgTZ2qIMiGstZQSm6bC+Uka+CfPoEYOhwMxQl3VEiQRC4IpZZ7c/yr9plVV0TQNdV0LV6XKiZU45KquS4lH7v2bfZxlcCk53LIJJetuNpQsg9mMls4JiwtpRWPMRjn1jsZ5EjVPc5YNbIpUreCEGSNGQdKyDX1jtSlvJllv6Oyjvy9FpV5ZMFSrNc3PJN11AfP0A0zXUG9lQNE/e8q0rhmNhKXTnWz8Mj6glWJ7ueF6veHigye8vL3jyy9fpmsVcW7ErYb3Rnezrpq3LPk4TZpzYhUxRmGtVLesEsSqqSv2ijRkEggxtVS1LUPvmBIfonPxBEFdr9coVNneZ4xh6kd5RvQ8V5zDPmstla1Oju0EIVc58QeyrhaAIZ7YqxLMZPu7QK5OA9Q5WCHmPsH0zyWSGudgaRlz5hBgmbCmdLEcQ/79x87/ZGYhn6Q+fZPEFPIM1W/T3bal2UpbGh88w7+qmXRgcJahf8Hx4cDkHOPkxI9aw3q9lnaUY8/D/kDUply7EE+D+Z+WLK/N2wAWrU3x1Vor2q5mtW5x7ojVEWNk//s0eYw2rNcrgr/i/v5+tlGplU6bmYptSotTQgzs9rsT9DTjP9LLLEmXm6bCZFJ0KioWWiv/n3qXlu5XqdzStAAQEt9u9PM0/KyvMVXGEnuAUlidKw7CU1oI8xfXqujsQkfl0TlpSpnlK4LUk+cxH3Ocn4HSCpCgWBVABUWzXlP93Ke0w4SLkermGVVb091o3OTg6VPCfcfYwO0hsK9GnI08TI5Df2Rwjsp5UJq6bjB1ywcffMCL23uhYFTqa/X23atO0wWWPsaJgAcVBc2oGjQHYtCgZrRK+dS4XtV4JydvK0NV1zzs9+z2+zQQEtntdvT9QFWt6dqVOGEtK0VXqxV13aT5gIg1hrqqWa9Xsq0krQDSStE0TZpai0IzFTxEQRDgtO9CnQSCszIoRcqsMmqUlFpnRjJQ5lEZIK9Ti4roPHZlZNeuj8Roi+OOcW5wjpHUexdLqVUOcn4w5k1Tb2rc44d/nsCDR89WeSH3U1VPLln96T+OiRHdpGbocaL/8CnP717z/c+/4PrZB3z6R77L1eUFL3/8Q3RtqSeXNh/Jlhii8IaqIFtnotKYaeL3p9f8lZff53/5LqX6hmRzsaWqWpSS4SdlNE3TcTxM5I1ooEuyQjJ4RofUsJ42lVWGw3HPlJB/YuR47PE+0jQtTdsQlTh/jaZuWupaykshBlQI1FWFNTXjONKuumQsAkTpc23rWtDJmMuhM6fiSemT3HskxzgbQYpbBUGecrBbgs2kx94Flg2jSskzFGNM/bWLgHaBhEqCNROaKCUl0aULOqW2fluCxck55YBYEoRs/U8Dap9K2ebJBat/6k9gYkDXltdBVibGn72CpuKzYWSYnmD0z7O52DD9jf8PD4c9Nni6UaiWVqsN9XrL9uKGD599QvSeuqqIwfHZ8Z6/8vB+6G7upRdUfWmikzFXBmUUwXmZDYgyuKg7CeirWkr9Gd1xk2cYRvpjTwzQti17e2QanVxjL6skrRG9yPe4rRtW3Yr1aiUE6EBKVcpnr1ar1LqVQYR0iAvoqiCaj36mlMJ5oR0srzEjQsbMAbkEJiT9eIz++4SC+vR8zMlcfiZ84iTWj/16igCWmNUy+E4vlGNYvlbssFKoR2W5kPiBCZH6Zqm7Fa/TOcefu8Rs13zpPMfxKZX/eey6Jfz6f839b+zZT0fC85epOmfZbNZ8EBV103I4HPFRcXt3J4CPP36lPr0PIgw9TkAurdAGqkrRtZbgBoyJCRgAJuj7HrhmtdpirOWzzz7HTQlIMFBZqcgej4eyJEG+B/wktHTjONA2XUFrc1IXggxUd6suAQNZS5YMLxl5T3by5GQWIKpSCQjLjSfwGPnXSqbdpRZECVJ1Wp1b9HQOPYSvOzEEKTKcIl++RE/lUZltNMzA1HxN3gQJcuUiz/nnBCs93QCY6w3tr/4CKkTqynKXBuP1Lz5h3TTsJkc/DFj/x7Cbit3f+W95eHjg1e7Iw/5AP4y0Gy9DUqs1pqr52Z/9WX78+XNZEx781+rtOwPU4/GIc3LV8q5spTJFjSX3m/m0Qs5WGq0bLi+3PH9uGcMkGZOpmSbH0I9MoycGoVTqjxOHfU/brui6DW3b0bYtXbeiqisUQj0haGFAG9hebFAxlB4prMVNY+qxU/i077euGnIWkh2hMfOksThtmWCTclrasz5KZP9GQkMO9Aoemhqi5Tu9nzBKM/rcG1a0oXxO6QEhlUPDMkheTObrr7otsoEKLcXWJdr1lZLQWo3CNzUPteUQA1obIQ9W8LJW/DCMuA9u+OQXfp6nv/RLVE3F/cMrmTCMgI9oLevU5KEJECWgmY5HYmU5/tYrvve/+K/gf/ourfrmJCdXIW0osnlKXYpvYg+0MDJUVUXb1TRNC9FjjBVks6q4vRXk300ONznubu+4u7vDGCNJFAoItF3D9uKCru3EiEVBzY3VNE0tw3vRk3uhTCq5giJ4j0s0HdloCsoaHt3fWbfmpCvTivgTdGnZLqAXSIG8psvEs0ExTA5tlitS87edSogzUnxqtNMJ84eI5KRnTStFaBv2dc0x0Q6FZEgdHhcie6O4uLrh5tkztFGE3/9d/OdfoCqLV5p+8hyGCV1Z4Shcr9BR4bwscHj47Vd873/1/uiu9CTP96ig6wjKr7UiBhnKQ/nk4BNlmNElaPMx4J0kVfv9AVBcbC95uN/T9z3BObSqUtlRUB3nHbWpAdEdYwxN15B7/kUrpP2lqSvS9AEZkxFwaUaATkqXJ2jpm0m4IEqnnLiZrcD7tH46OeiywhFOghR5zpb9qOKGcy+sgsQTzFsQ0q+Aochvz21V8xxAivIfVa6kYUhrCG3Noa6S7hpC6ot1yvOgLRMNm4uPeXZ5hSdQffE5V3c7zO4epSpevnzNzfVHNE3LjW24ur7mo48/wlQ1P/rRj3Buvg7vm5QENBlEGSj2WAOh0hgD2kbazsrSjhgZe8XxKDSITdNQVYam6YhhKjoYfcSFSIxHuqZldXEhdtxWKO8JzjHse+LKoU1d7F4IgePxSNfJJsoy3A0LZ7xsx8vc0vPPY0Ifl/dbl4BhkVQtACIJvufnOQZZXiCLUE5i03wIct30Y9rJjOg++g1VYLWv1uCFH1lyZmNOWS989GjA1RUHazgEl5gxABXxWgKXqWpYffgBVxdblA0MP/gBtw8HXg+B3dEzOXhar2nXl7SbLaD45Fvf4uOPP6DvDzymfHybvDNA7fsRsCkISvQ0Wpy8NrKXnQXHWL6oGf1QqdRpbcU4Clm5UHNJM/DkAofDSNcOTM7L69qWLTwxSKNwbWYyV2st93e3KcO2gKfvjxjtMJUcq1GJkqTcjIRIKTjNjAIhOLSx8noMRHzabiPvz8lGZaqSlZf0I2dKceYd03lzBQqtZJCrKMbiIVEyhrrUnllBvD8JLpZSMsFk5JRSafNkMZdlgEFOVwxESA+ih9SgAE5pem3YG8NgLFXdcNcP/N5PPuPmyTWjC4lAPZ13uhgqCmIgZj+iVCC6xIXWvx8rTYZhIIRkeiolpUpbYasqlZhmR6JU4lRsGmKMGCW9eNZIT01/HHEuITgajseRh4cjl5dbrKnRukJVmm61Er5JrcT4KOGTy6skq7pmmnp8kEFCo4yQeCsJtkIM+BCplLQN5AQrUwrJ7u85uQrBp14mCuKpU3I1l4aSAS5GM9GWlPMX8c4RQ9owtCBPzsZz2ZeaUSOf+qmWhu9ku9tXyHI9b5YZqVj8XnJsWXddOh+d2mbkmoFXkcNwZP/8Ja92B1bbDbvJM8bMUanpp4njOGFJSzaUBCx5sCeG+N7oLuQhP6FNyoGj0hodU0kQUp+0EZaTWu6ZMgpbVwSvuL29Y5hG8LDf73l4eGCaJln/mOcKYkSZyHZ7ibUVRtuUyOdSpYABUt4Xu6415XuFLjKU4K84MuZgbmZ9OtULSSB9Ys+S51AryjmX48vAiNa4ybMcTjZaOFy1saUKUFXVW/QvVZyYdSw/IrEEqac+Y3mc75K3lrNVDiWE39TJDZOKnJJAPkRFxOAivLy958XrB2EAoeHZB99ic3GN8yO3rx/omiu5P0b8m7VrNhdb1qsWH+zJNXn/JAWmCrybyEwUSgUyWX7brgjeMw4jKCWAgJMkq6pq6qZhHCQJ8MGjkA1TGZG0RkAHo7Qsb1itWa1aqVQVoCqkGQEBJHILzRKlL0f86H7OKnDaDrW0VwoFmnkgL8cP86wns9bJK6leRgiJ7/cU+ySvNJ5tcC7V5/ctmSbUyR8nd+DRucV0QCfxCSmhSFzekVxJM4X2CiX2mETU//rugVev72lqwzgq7nYj94eJwWsCFlN12HqFsXIvthdbLi82NI1N9//NY13KOwNU7wR9kqusQBuMsqkvQwYvhA813eRFgFpQVWuoqordbof3kYgufXE+wuE40KZsKaJTP0lIPYHQVg1WG6qEIhwOe4ZxoKoqUB7X90y9Y7Va09rU05GD/eR48g1QKUCVcmLad71AqYTUOq2+LHoUU7aRglikFJE3Z2URPrFp0es497PERUYmnKdZMRaOP70z//kYaZgzpBSMxLl/UoLR+fuSHmVtnEsD6eyIQv8yxcgYAoMPHIaRbd1x7AdevnyF956mbsrDlpU6k21n1ERIihVBuTIo9D6IMEQYSRJMFMer8oDfnOnKbvmYEh5JMqzRmLQqz7mRafJphkcmQd3kOR4GtpstSqWVemnNbQiZuw+smifpjRFkynufglBJ0oZxQGsvw1NIv1LR05N2jozc5EEmce46lWXlJgfmbRFzjj2XzLM+hvn5gESCHfA+YvzCYpSa0eLCLu69jpn1NCVHUa7R8rmYA+PTf899iSoNmzwy3zElP4vvzJuIcoAckc6YEBXHfmCcHGp3oOsHJpeHuiQQdUHWnupkV5SW8qtOf74xOflTlFlnTofmZvRb9FZrmQYWSiqN1qLn1lrGIMMibvJEFxjMyOFwZLfbY219EvTWdc1q1aXqQroDIchmJisbmkjIVa6aZXuf2wNkhTBUlbz3FC1lcexLf7hkUln27MkvKKXKfZEAdXbp87WilH1jCMJqcnIx57/Gxf+V7WxqtsX5e94oicKjJIxSJl3yvZbrUn6JEozGdL1ygCxIYAQtp9j3A8djzzg6QlBsNpfUTcOx39P3B3a7fVr3LWtc67phteqkRzNWvD+W900pvkNJIqxyqViJL5UZlI5h6Al9T4wyBDUMY5rtqKmbGqUPBB+JwRcfBioTXJQ2k6qq555/OYIFYmio67qg8jyyVW/cx0fR3kmss+DJy8j/snKVJeR1vxEy24lcFyRoXpie0r+6DGLT4HhQMbmq5UEve73fPN633Yv0sRLzQKIQTXY6hKLrQqYhz2LZQkUC2FKvzDRM9H3PARjHwOQjQWls1RABY2u0rdBWVnW3RphV1qsVxtbExwf4SN4ZoGZu0Ji2rigUhooY5snhmGmTkmHL5UEfBCY2xlJVNcfjgA+xZJE5IN0fjzSHhrZriTEyjAPTNBJTqbPSBhcsK2swVvPy5Qt5vapwk6PvB/rjSNN2RTkkSZUHIGbtJRvHFJzG3H0hO9ZlkMCRg9PsKEPZeS20RHM/30zZEKOQ+U9uom07bEInXHBYY6SpO71HE2Uv9UJZsoFeysmwynI6Nj9TSiVkU8zdCS9XuYGz0z9RyCg9Ui56JucYxpG7+3uapsNNE/3xyOtx4ur6AqtNeRDzZgpVXH/OEIUr8/0KUB1GS98ZQaGxQia/uEY5eMvWQ5GQT6sLaf0weCYvk4h5fWKI0B8H6aNBWjKslevbJwMrAyuypUhrIUzv+2MJgo2WIarDoZcyFpUExTq1cST8ZVlSnL1oRNYcemLMnYFeXkvoekmuJJQ8Qf5jDCWDkd4+yd4zYXMxjZGFMY3FMGeek1AM2+OgYW4pKL+XlFctPmsZnM5DKdnE5hx+ZuUoWX+IpV/ce3H0/aFnnCaUsYyTLE8QSjwtK09DKielex1DGnBJe1qjf390t/SfWkFRi5RbGEsiXtd1ccSih1VC1yP73V6ujwuM48TxOPD69T0fffQhRtv0fuHerZsaYq6UQAweWxnatkltKKmlKA2Kxph8A7FskQoxUlVyLHOJf4EwFV1a9NirWHaEqwKhInZOqwVDXo5yA6h5a1gkBahR2k/yeuxyyR4HrOn3QohzZahc3EfHxsmP3iILfXp0ruLdTqIfOd5FMhZCQhaFDR4/TLx88Yq6a6mbRlpVoixa2O125Ro0xlAnBhHpda+5fXiPEqz85yPgRWynSwOo4DVoKzMkbdswjkOpnhIcx8NR+vY70UGlIbpAzG30yiyQdhlIjSGglTD6GGsWQafYKqMVddueJBI5eF7e6FKlCY+TLVWqpWU+ILWkPG5Nye83BsbByfOVrpBUniQ4XT4rp/aScgyFkSWmFHH5lsVGytOzOL0f5RNjLGu/AYRZbY6azcIWZ7u9iGtnvU3DX0YpDocjMYKxFW0r9kQpJW1yaeAzRIW1movtluvrK1DtSTvZ2+SdAeo0JURQpy8AxuMkK6wsxCCT7aXXLxkw7z3Bg7IGjMUH2O0OTJNPAZWUrkLw9EPP/ngg6ijbH8IkqC0RE4XcvHCjBs/d3R1PnjzBOQlO9/sDlxc3XFxcLDYxzKhfxtg1gTA5lEqcizGAV1hFQlAdEekRqmw1K01GMJIDz3ynIGsEx2liGh1d14kTzJ3QEYa+x67X0svrPRcXF3LRtSKo+aaDZGASPLx5H+IbKhfThCgJAUhKqU6zq/xbOSiNYR6qijEyeMdxGDn0PS9ePKdrWy4vtmzWa7qqoq7qFMyGeRq8fK44FnFOHkLEx/fHSEYf8VMAHQgm4EdP8CnjVnOy4tNqXRLqL8MUNcZaYtTc3+/xIW99EtQ6oDgcjxyOPT56fEKp9/0x9UbDuu1QVrNer9FGMQwDt7d3fPDBU5SS37+9fcD7yLNnz5IhS4ZOzEBCDPM1zaUqn5KXPEyXh4zkmUm7qVLqlZNFYShQZAaLeTo8RkF8t9sL9vs9YjwXfc2JkzLGUHavn1zneFpJyDqcg9fHPdL5b+X1tInuzUAia1lKHOLi2Ygwh22K4GJBW1pd09Q1ra0xeaGHD7JBRs4ck1GXHBgX2Pb9kEw5Zsqk77KHWHovRXfna+Ymh1131HULMTIOnnGMhGDkGfYw9BP7XZ9QUFnCUtctVdOkAcB8KeR76qqiqmu0tXg34WOgrmVRSwg+UcXoYnOtteSFJkunHqITO5UMVdneZlJZX2vZCa7C7BwXQW9OUZa3SJ5hcd5S1k+BovOlLMoiwZKPPLWkc5vJqYMvqHWJAuZa2FKyzX2LeZaEPocjEWJQ6bjnhNgqm/x/xGuobJrujmCiEtSpbrj3keMoy23W6yMffPjhiY+TJPPrsKj/7mXWUT2DKklntVJCGVdVtG0rAJOXilbdtpjKMo4ju4cdYfKMceL+4YEn/Q1XV9dsNxd8ob4kImuntTasLza0VVsYhZZJhvdeWCgqi48eo6sCbKmTRCEP8aVPKIFoCj4NAkwFdXKeebBKlcl8aX3RiSlmGXhlWxfnkaREWCQAWozzWvcZmjjV9xRjCwpNREcK888ji/zGK0t5nETlAL1QFarkcdQjvQWklxCxHyFIclFrjJbB4GmaOB731E1VVmg/e/ZUttARhL0oRC4vLvjudz6VAPVr9PbdCGqMpV/SRCldZ2J8MhKDZvKpZzTKQAjaEHxks16zWV9wPI7sjwNjQmpUJZtLnHc8HI8oa0q2mHfxGj1PEkcVOQ5HvA90m640OssQl+fDDz+gqmzKdrJizMiLZCFuRpsSYjpNAzaVpEL0REKif4Bx8kQUVhm8n4h1TcDjg5C0K6WYnKBiwzDSdd0JBD76if3xSLvqcD4bTUEIlDHFwcbieJfB6TydvQg/k2Fjtro5YNQJYQuzQ89KtcQHZgAmMkbH0Y3sxyN3/QOf/Mx3ePrkA1arTrZuKAvRy45pPXMyRj2Px8QYFgr/lj6sn7JEL4FcZS1ohfMT4rWE983HgPOyclchCyRCgKpqQVtG77nf70VvtCYvbvYxsj/2jE5aQlzwBCcJHUE443LC5mIQ3tQo04qZDuWw7+n7iU8++RabzeakvBnjnAwoQEWf0N+UmMRAdB6p7ife3eiBgNbxTb0JEHPp//QKEYJnHKViUciiAYLHR8n+nfc87HdcXV0BKbh/42qfIqlzWfekAWsuAyC9iVEpMbSeU2Vd1oTzn3nZQCSV98Q+Hfqe589fcP+wo2lafuGP/yLXmysiwvHpg0ufv7gmGXVQJQZ/b6SU39Uc1DxGZkjY5TD0HI8HXNpGRlRMk6M/TuRpdl0Z0IrJi93c74+M3kmTk5LP6J0M2BltqG1F16wTwb/Y9X4civ0fXJDqQVRsNttSfp9poU6H7bQxi2OOZb1iDg4klgwQ8/tykJtH4eZgTHquT1Gt2U+R+meDoJf5ditZcpIRzZB0/U30X958MhBMfm7S+1Rq04oLtEprTG5FSN+noAAVMiAU5oA3Bd1ViEStsA4YAsPgqZSiqSzGpr7DqsIoRT/20j9J5OG+5frmptgIcjXgpywFHFKIb1K5f9qW2RVUoO1WaUOlVKps4jMdxolpckQXCc6z2+05HntAmCfKIggj8wI3lxeQ1mbmNaZ55iUzk+RVoaJTnhg9CnkWYlqgY3RVWFGWFVEg/a709WcqwexDlDalqih2RM3nvtiEJoioxFG5vUwYJTRDL1vYbFWXZy3m+7qQOYCmDImq+JaA8w+caYelSp9+V+p6W+ptzODXUtHyBi0l4YKuFNurC6quBhVZrdfcXF/TWCsLD5Bnta0rLi82QPu1evu1AWpMdE5KK7r1CmV0GehQqVQdfEjBYbp4XpDI3Aey2+8Z09S9kjSDiC8lGXHajsk5QlIglGbOnXNsFqnrupT2QSZSm6YhzbUXrtG5xDgHpDmwTl6fyY0Y28hEXV4QkJy07wdCjNRp+CDTEeX1Z0oZ+qFnGPq04lJoimI6J+88Lp3TNE0y/ayL1z5xPjlIXaJR2cGrr9C3+OgzVHb0j254RlsyFhfQRAI+xQSjdzwcHti0Hf1xz9EaurpCqaYcR3nosirnACVdxzws9ibS+9MUedDrpmW92UoJu/QhZafmZb1ts8iqA2w2F1hbMw6TrORNCYNW0j8dQ6AfR/aHg/Qjw4yuk6+1BBDTNIKdewOdcxwOR/p+RCGUapDvIcyhUi63ph7pUqLOiyCErzXikxP35TPE8M4lduEFdmURRUYuJydrLV3wOO+FRs3I9DFOpmSbhCwP47BAGt82KRof/f30HWWgL0UwbxsqAQqvatZtzYJzML0nhNTzqAJT8NwNB8YIQRtiKm/n3mmtZRBFoYQajRz4p9aY91DeNpSzTGAy+q+VbMPxPvexGZSyjGPP4TgSopGEO5XRpVd3ZPKBIEUPdIxSWp0GKiN8pkbnFiPY73fsdnvaVrh6+75n6CfG0XF9fVMIx5VSmLxNkLnvfQ7uclIr/Ych+gVaKjounNnyO8t+6fxzqV7l65F+MwWTkiybMsG/jDuVFh8l7RJzUHuK/s/HqJbfr+Kptj/6/vxSXLxnkbKXF3Lf6dwOB14JR6830KvIwTuOxwOb7ZrKWqmhBNn49+r1Lc55gvd069XJOZB04actxR/lZ0zNk+uQqJNiejbLdTRUtma375kmh3MRlXpLj8eeh4c9u92+LAyytk6Ucas0bLlMLcVfd6smDcpBcL4M0IUgXNZKSWNiCD6xuKTfjjO936wn+e+z3VIpSdFGC92lJgXkFNAOFgE7nNg7pSgK5L2HCMZE4TGPC7qzNwCfrOeL/v2QF8NQjvGxvPEpxb5+lf2Lxb8v9TYHJBn1zb2xmbVQxpQMtq6Et3e7Zb3qBLSMc1ulUYpV06LN6mv19g8QoGZnImT7PnihcopzX1xu+BYfIvx8lTXUicZh9/CA967A/yjp48uGKKTPE6Jdj1GmnHhG/CQ7lp4TPwoiWVcNq9VKIPLgZp5GNW/zWQanufcuG88QPCE4maIOYbFlJ138cHoDQ8jUToqI5ng8Mo5Dytqlly8oQeKGcQQopYaEK7F03EtFW/75+B68rax6+sL8V5Wjx6Jc6VlY2OyYhn2EsSqgnae/vWMIr4nDkdpoNttNQh1MCehyUJw/M5dIZgT4fXL4cmzGVtRtiw++9AKXgl1c8HCSnJjSrLoVKsLh2Bc6M2FdUAVtG6eJ/f5AVQtTQyaJNimizw+4Dw4TDVYrrDHSM90PEBVt10kP2aKfCZbOLzXIR0+M2bnKf86PGFOn5yet+9VGjGYaJFCZnSLpd4J7Cro1TSN936OUlvYMRQpkAuMwyqaVhAb7RKxcEIDllf6HuO9L1Kvoaj7vAj0t/p1v5fxiuodCyTUFz244gtHUTUPTpsQq/Y7WCqWtsBOIMTl5RuZjen90dx4se3RcCaEJUeytSVvJQhQ2g6qWRH2cPH0/4WOkMiZR5sl7joNs3XFBAAIfoqwydRMKQSB9MDKVr2SV6TR66toKWn04Mg7yTGRUS9pfHlu3bPEWJFQFIJiDTsjl0DAn5czl8fI7RLx3i3uVngPn0pSz2Eljrdi6GOYlElESSFM/RqHhTaceSwVj+RrJbmSH+vhj8lD1G6lbtr3Fvs9fl7u9R+AYA7tp5P7hgZubG5qmRmuFMxJ0hxCl0gFM44SbpvQcvz929+SanVyG8qARo+ib2COFoKgVw+AYRxlG1VGqmNPoOB57GUi92KKUwVYVVerRdt4R/DwDY5Q+GRokSiKrjOhyCIHgEkG/tckGLStOy5jHJD2d041HxgqjFY5TfcwJWAnw3uLTT78nJsoph7GmfFXRyvx/i8953LdZPv4rwYM/mIhvn5Oqpd7KUcT5uNTie9OrIUbQKlE0VidUXjnBzIwglbWYqn58CG/I1wSoabo9BTfKKPb9UYYpYkhObQ6sROk0fhppq5rKWILzPNzdpww2URal4FD67fKghAQIzjvQlD64HAznHqeckeThAGMMwzAw+TyUpdGpFCW9sQ6fynwhWnS5qAGQCxZUSE3DCu8zEjYHufP6Uo/3vky1Ho8HQvBY26GAY9/TNhLIjsNA267S1LYvE/dvJVh967V/W+P96c+X74sLhKk8L0lhywtq/qFRiipGVlHztGr53m//BsNw5PjsGVopnn38CdoHtJ6HBpTSbzxsuQE9O8r3RUJISE5qqzj0vSRXIcxcnkqVrD4GT/AjTV3TVBXTOLJ7eCD6tMfbKKIWdDEqGFLZu3EVqJjWRUaMrqRxKWXR80MrydXd3QMxRtbrDTc318XTZQ5TrU1ykHMALYlUmJMCJfRoIZqUNOW2G6H+6adRmAKM6KnWimmUAL2yNdmx933P4bBns90C83Psnedhv58XYCwGR/JqwJislEqGP1cAvkqWvaiPdZfHuruQRdhOcQIqT+9Lm8axP6C1om1quqaRa5HKw4Q4t6fkz4w5CZVXY8wtA++HzNflzZ+FpKvee5pWWo1IPXLrzQXOR/phpB9HfAwok4cpxV7348D97oHJT2LDp5CC0zjrW4wENS9usNakwMKx3+9RSnN5ccV6vS49+fN2vkVgmqpvhFQzJFXjEEQFJMAqw6lREPP55qQEUj6ZyU2YhIJGZFFD3x9p206Sx4S+ajTeudQPmBbNTBNNXaVNWEvnugisiqPPVTgJlTNyFUmHvdTKfKyakz6R/HJMyIBUaKSHXMXcA63wHnrvOYwjD8cDr25f8ezpE5pWhkustVKJrCqOh0PxvcfjgfW4wWrZcf8+Dag+llO7EDgc9kyjE9Q/KrS2HPYj4xiIWOFZVxC8Yho8/TDROVlpboxFGc0UPO5wED+thP+0rvO6aLlfsswHDGlLoBMaq6q2VFoGpoTJIhZgaz7eudoq902Vn0knS+Yv9WnxTgJusp3KwWL5Uy0+V5ekKQeF0yQD1ukSzdlezCFjKJ93qrvp3zkBJye2j5Ost9wTNetl+bysp2/obR5MzQnach7h1FBJ/6noLcln5Wfw9evX5bwVXz9Y/TUBqhDlKyXrxO7vb2nbjsmNRFqUmkufIEbep+nIdtXgwsT9/Z04EKPk/QSIMrBitUElzlCVhhgIMtwRvJdNKcbKxhgE3Rmd48sXz3n29Bl1UxMJ9MMRNwn/nTYVMkIhjtu5icmN5P48yGTXElR5fMnM87T1OA0F/p8z9Sm9b+6/lcAgU9VI8ZwY8E72e+t2xfEovbNWy/CYXU7lfo3MDdvq5N9fJcsS/Ft+KNY1ZwMKvFJM1uBXLe0nT/j8h99jnB5Y9Xtc8BilCNGk5myVpm0TjybqdLtfQqfeFwmJgaKqLKtVy+G4k4BFJQOjKSXvjIyHENhsOpSKHPY7Hu7vCtVtLqNED6BT6VQoikqrABBUGTsWw6WFzL9pW6Z+pO8PXF8/YbPZYK1l6Hucm0oAK78qPW4huLRmdaKKibcyIU+RSD/0RBWKeZA2S3H40i9VJ5qWCucmxmHEbgRRG4Zj6l0cqayRdpcFl+Q0jKy7FT71l5cEa9F2k+2TDDzGk9v/WHeXr51INuDJyC5gg0eyDAryvYPoAl3QfP7lC16/ekWIgftPP+Xbn34Ha03aJ68XyfEid1t++nuku8652Uk8kqyv3ifnEaQvua4rnjx5wvF45HA84r2jthUYg4uhnPNxGHnx4gXg8X5imgaUQngktUFZi6mEo/A49tRWyqXep21U/ZHt9pKrq+uTgH9GHZONTci//FxsZhoDxU8jRigUiAQCvqC3kbiY3EeqB3jpVY5SqTB2Djrv7m9l4j3qcs1ijBwOB5qmwVZV6jWfiOTWr9PrmSuE2Sm/TUq/J2/qSkw/L7HJYxC16LVIZj7MCPIwTTwcDtztd2irGd0ofJqVIWpx9DdPbhjGAecd0Tv2ux0Xl5fUlUWr6r1KsJYifZeSsIuHF1YNFyJoS9ttGMbAbt8zTAGMTZUfiEYxOM9udxD76T0oWcwRhyNunKjqirZpUBpcMBIP9EdyMFdXFeMoFGs5KH7y5ImMFGhVgk0gVWBj8mvx1FBEScJ9cAiLRJThP1LlKi8hIM5BVwKjQghUlXnDPXrnqOsa7zx9P6RKRLJQsYS6BbmcD2iZ4J8y/MDJX77inghgEnxueXs7yvtYb3P14jFQlVFxYh7elRYIozXRSyCcOW7vbm9l8Ucjla6v09t3B6g+pGl9T/ATzo1YDTm7KHxf6YZm49l2Le2xxvmJcRplS5POjsKA0jg8WgmNVG1r6qqm0paoHLlfzDvHZC3GBw7HHjcJU3rTtti6QmnFNI0Mfc9ms5UtKlqUIjM0huAIwZUyvFIhGbFAZkr0XiavtbZoA86PaU1lTCsux3JTtJEeThkakOxPemGcBBqVwQeXOFHh4X6Hrix1XZ8YuDzkkRXhtJ3i1LE/Xnt5qjAUtGU5IJXuCMTcD5mamRcURErLpKiqGi6ePGP1cAvKMDifkPNYlDgjaSrK+cujpE/6td6nADXGiA8TD/d3vKpqLm9upL+5ADSxIKj5+jZNTbdq2B92DOMRVMBWOpE7Lw2M9JQ2dUttFePgCjIffSA4R/AerzXOe/p+JHoFIbDebmnaRmioVORw2BNjSPyGkAPAGL3siHcDcq/iI4Mhrn2pR945pqllnMbkKMWhS4AhvdC5faXvj6KjSmG1oj8eaesGjE3BvYMYGYaJyU1oI3RjPqERWb4qeXpbOept75l1B+YO1dRbmDlqM9KZkdMgCFrqrmWKke5yy8uHW758/pzj9wa2lxsuLy9PNiLJwCXp+c9ohCqG932RzFzytkPKVyij1m6aCN6xajuaqubF8+dMozg7Y7NtymgeWF2lEqpcgzh54eJEwIj8n/OBuhYOa6ul93S/P7BZX3B5eUXT1EQkmZE+7LnnFyjgAICxBQwieGkt0Uahg0mVK1+2Zk1OWg+snZdFyDZBqRJkfRvHgcPhIOivigKA6BS4qondYU9QUEVZx9y0daE3fBuyVPRwgaKVsvw77tUbLSvpPJcBw/JnofQoqlTDgykGxjDicFxcX+KCY3/cE1XAWCGVv766pKlrhrHHpe2K49Djqgpjqke9mD8deXuSl68PEKCupd+/NhW6rrm4uOKw7xlHsU0FZIpS7ToOI/f7PdurLVHJeUsl0wmibi0+RmFgSe13L1++pG1bNpuNVMxCYLfbYUzFxfaqDDSXnvicFEfRM2Ik+ohKE/mJSC2dh0/ggQBRElMkkK5U5HLFyYKOTP1UrsXcsqWZnBOu8SU4EZUEwShsZdnv99SN+Iv8bBVV/YpEC97kYn18n5bti48rW2/T2/L5WvrWM3PTMm7xwSd0VA5SeIklnuuPPa9fvSKGiAspxtMjdvWPQTNldNoSpSTgc+MoPI3ME3qZrzOLTgPPzsku3NGNEgBqkzgeJZOaSW3TxhQlWyCMtulGqtK/6atKSvFegtr1ai2BaOob1VrIfnPDPjFvecj9ecnQqFjQUx99CUJzxhOjSeXQtJNcCFWJMTL0R6HbSkq73+1TI7asFRyGId20NHCVhrDcNNLVVsqtkTSZoMqa1DeUIyvGwvG/G4WKb/1rkcflK+SBU0mJjTbUVY3aXPLBs0+YJkdtG5mYTtuqculKgtSU/qds7xQ1e5c2fbOSEY9x6HnY3XPz5EnqUTOFx65c11TOyw59mkacmyQxiwFtpIcxMKObJumz1rIxzChTEoXcs2mtoP/jNKKi7I+um5rKWrxzPIz3NG2XPiffKgm+SET80goz59Ilp85IbUKn5thVDG0O8jK3qQzShBKcyzKBiE08rcH1eJP6aV2uDgTGNES1aYW+SNT2FIV6bKhmNoKvC2Tn4LQEocv3R3Xi7TOKIEM26ZcURK3ptlu6iwuq3T0OnzaJPdpWlYym3MeUyJY+yPdHebP+hLjsgWNGVZNzyNfAWMNqJfdnGgZ8mcjPVD/pfkVJwgVd0sX2isOcE938+bIaeDlBb6kbKT0775ncMaFAeXNT1oFQdDeFxWIbYgQlaKZVVqplaTZAtmJp+l42rS3XlTo34hIilt8/jiPH46EknNM4Sqm3qsq1yYhr3/e0q/ak3PpYTpIlZtBASqenNvpNBPVN3XmMf7/x2VJfRUUwMWJ9QA8jr2/vmdYbVquV9KEa8bNt22KMoXMtY0osvXOJ+N6/oes/DXncS38qsSCBJt0nWxnapuX21WvcNIkvN6KXMZAGNmEYJw7Ho9xT7xe6dXrtQwj0wyCcoXpG3IUrOdA0MlwFyyQlI5+qfEZMSKDKz1+QliEJZlMQmxJkpYTcZYm+K0UZnI5IVTbzqmZife9cateQ+EVbTVQpyJscJF917HvhKH50LSH727CApWZ0NQMDX6nrX5V2qdNr+rb7GecvX7wnMnPJzyweQQWiz0DfVH42TRPKjLT/OCX+zWaDTg49BzJ5T/hpDwKLm6NK8z5K4PKqsmhbYW3uaZNGWqsNdS2To1ppIbm3VpxpDEQd5yb89F1aa5q6nlcsRmjbJn3GHJzmAYNiJFN2g8rZli9GaUk4rrVmmoa0HQhyeWoYBpq6Kf1Yh/2Oy8tLVDIU0zTSNO0iqJAsPyLTqcbkACajnfPNnXsNw8lrj6/xVxnI8lqk0FvkewEU1oX8PaVvDFkB2lYNldF8/OG3GIeRRlvJfnApeJvvwUnwoU6D568j3f0mZbVaYVXqWUIGlLRSxDfoehJypzTGiiMPQcikq7oCH6jrBmMqQgBv5d7Ili2DNRrddpRhPBXRVngAy7YSKH2v1lq0UbIQoe9p2rYEzSVAjadbzsCIYVNk3DR9nrw/Z/EqVzdUJJOuZ3aBediEogcgg4exDFpIe8AwTuXv4zgSiELVxWyMliqYdTfr7en2o6/X36/U3QiZnSCLL71l8hlKK5Q1NKs164sLtvtL4jQWtOH0nOXZl89fPB+LZ+99kNxr/+a4QzrnXHEJMW2CskJ0Po2SdFiDMi3WWmLqd8uIbNO0GKOprAzuaSVggrJppWQtyyWskWRKK42fpOdV+CstEemxDyH38s7bo+RPT4hSuSIFkHMCsGiPKoFkkJYFpURfF/cIhJothEBbt+k+eqmcDYP0SSvF6AYCGqN1QmhEpDVBGF++rvQJbwICxHhiq5d/Lt7yxmfEEEu7j0Kd9qeiyvON0ugQsQG0D/T7gySQaZAoP0+ZeqyqKurYEDxio70H5Upg8NOUksy8LWCPOfjTNHVF17bYymATIKC1oa41xlZUVZ18csTWFSgl7Vq2wqcEVSeqx7puhFbKWpQx9ONA1cgUeb5P3nuMsTSNLECQXGlmcJgn75ete3rppAUMA/nTJMYgQuI/1TgvP59XCIdi1zLfbtmMHmUhUUgAiErDrbkiMaaKbd3UDMPwhs3NevFGDPZIx9/8ebkbJTHHL/Q5xbeZP/ux3maWIFmCNCOoZcB9YUfLv1VITCO+2K0Sg5jpa/X2nQHqd7/7XRnw0AZrLHXV0HVtKunMQdQcEJKMYMPNzQ3TNOC9Y5t2JVvbCOIYI8FLp6jVUBlFU2muPv5EBp6mUXptlNzUtm3SxgJN162prWTsMRGor1ab2WhHceTOTeTJMZAgzXtZDenclIxWzjbS5F0UZTseJXBQRuNHCcScc0JcryBERz8cuVQXiTpqLp9P40jwQVAG5yQAzyhV8MRoCV5ofZbbHAoHWowlGHzMffi2DHV53hmJyvC9EP+qdMxzEFGURWmMMqzqht5pvvXJU0wEEqfiBJhEIFy2Wi2OySzImIEyVPE+yLe//W0qY6hMTV0L3ZlSEP18DaWEIZLRfJ+WRGy3G26qawbnqWuhOAlRNk3pKLpbW2gbQ9dd0fdbcaQIGmStpUolUqMMBmnkNwg1UAzSg221oanqEpDlpCo74nxsIQVUIUZ8qgrIOeT3yErKaZIGdF2C42w0cjARyzORh0D6vi9OcJwmDsc9TdUwTUI/pI2hSgbfT062vWRevYoAAQAASURBVKXybUa6lgjU42QG3t6m8k7dVYsSlUpOXSXSoVS1UVpsQlu3DMGx6jZcXz/BDz0XFxeJOJ7yveJ8Mio7B3uCsvz0Eags19fXbDabtCFq8bwvrme+bjZNeTdtxcPDHd2qpdu0aGMwVpCXzFBGFINfW1h1FZUVpzxOR9BgUxUKYLXasNlsOe57docHHm7v+PTTnykrnb13WFOnazz3fkpfqSTpPiXqOYES3ZZ3T94l3EB+rx8Cq9VU2DZmzyjoi3OOtm4KOpUTL2OMIJwJnY0x4EcnOZqXwbBcLQjxbaETb+hv/vNxFeBr/570N4QgAeaSA/gkQDXSqkIQ/kvAG4Ndrfj429/i/v5+Pt7FM5W5tE00mERZ6JzD+YHjcW6J+GnJdrtNfnk+2aUNyL2nm8stkx9KMFg3FU+fPhGKoqrC2jolKQGrFW1VserWVFYzjcfUTxwwpqJtm/Id1laEwcvwtDYlPhnHkc36gq5byTBdAqikojtz72ZwSf7ToEKykaIH0zTOtiglyrWtZFB7mgghSlIYH5+3P0k4Q/A8PNxR142gymreTjUNE8MkMwltqoDFKMtWcoRaWoCYk4J0tXmchH1VgFoSSv9I3xMEUt620NuQWh3m7V3zczP5x0uMZsAmH2dVVSXgzihq5rn9KlFfDcmf5SxnOctZznKWs5zlLN+8fHUn7VnOcpaznOUsZznLWc7yU5BzgHqWs5zlLGc5y1nOcpb3Ss4B6lnOcpaznOUsZznLWd4rOQeoZznLWc5ylrOc5Sxnea/kHKCe5SxnOctZznKWs5zlvZJzgHqWs5zlLGc5y1nOcpb3Ss4B6lnOcpaznOUsZznLWd4rOQeoZznLWc5ylrOc5Sxnea/kHKCe5SxnOctZznKWs5zlvZJzgHqWs5zlLGc5y1nOcpb3Ss4B6lnOcpaznOUsZznLWd4rOQeoZznLWc5ylrOc5Sxnea/kHKCe5SxnOctZznKWs5zlvZJzgHqWs5zlLGc5y1nOcpb3Ss4B6lnOcpaznOUsZznLWd4rOQeoZznLWc5ylrOc5Sxnea/kHKCe5SxnOctZznKWs5zlvZJzgHqWs5zlLGc5y1nOcpb3Ss4B6lnOcpaznOUsZznLWd4rOQeoZznLWc5ylrOc5Sxnea/kHKCe5SxnOctZznKWs5zlvZJzgHqWs5zlLGc5y1nOcpb3Ss4B6lnOcpaznOUsZznLWd4rOQeoZznLWc5ylrOc5Sxnea/kHKCe5SxnOctZznKWs5zlvZJzgHqWs5zlLGc5y1nOcpb3Ss4B6lnOcpaznOUsZznLWd4rOQeoZznLWc5ylrOc5Sxnea/EvuuH/7P/yb8db26e0nVr2mbFxfaCJ1dX/OjHP+Dv/r3f4G/+1/8tU9T4EICAMdA2NZ9+8gmfffYZwzDgQyACxhqUiiitMNawqivqStPWFqsNSkEII0RQ+QCUQqEABUqlPxRa6fQzEa0USimM/Ir8qlEYZdBaY42laxu+/e1v8Sf+xJ/g8vKKuq4Bg1YWYxRKa/lcPX9vjJoQFQ+7A+1qxe/93vc5Hnf82T/7pzAg3xfBT47nX7zgr/0nv8av/sqv8nN/5Od48uQJVV2xOxz4ne/9Dv/gH/wDfuu3/j6/+Md/kc3FGm0UQUGIkRgjUWlsVVHZiqgsz5494/r6KddXT3ny5APWTz9AKcuXX/yE8bjn2dOnTN5TVdX/n70//7Usy/L7sM/ae59z7vDmGHKozKrqypq6i93NwRJFwiZp/2DapiSSkm3YEGTANmBYsgDLMAzDvxiwzN/kXwzYP3riP0DYFCCALYloW6TYbJJV3V1VPVRVZtaUmZExx3vv3nuGvbd/WGufc+6LF5GR2ZmRCcO76mVEvHvvuefsvfbaa/iu78JXDRJqskAWcGQgX7umcs2vc9Ypnibefiny9HvR75j+NXuPJJAdVXXy9Adf8vjv/c2/nr/5jW9y69arHB+esFo2/N2/+//gg3sP2bQDMULKA5B59ZXbHKxWXF5e8OHdu+TsQDLOCVUdEO9wXnACjkTqe9aLhkVTE4LHiZBzBkk6jTlDzoh4xORWpynjnG25LDhEp9heE5PvnBNBHM45vHNUIbBYLHjrrbd48803uX37NnW9sOtP78MJ4mzPiAM8GUfbD/z85z+j63b8hb/w60iKVM6pd5qBLnH3/n2+993fJ6XEW7/yNX79138TvGO323Lv3l1+9KMf8bu/+7t87a2vcXbzjOVqwZAjAvgQcM4jzpNF2OxaXn/9DU5Pb3KwPuKNr30TVzWQHbvtlvt373DzxhEpZcR7fKjwdQM2N1n0thzp2rWdy/BVMc3lv9fI7nykK+/5gx/c49//X/02/+//9L//ucvuf/C/+V/m1197ncvLLT9795d877s/4NGTC4bcq8xK4vjokNPjY+7dvcfjJxdkcYh3LFcrXBBw4L0jeEceBmLfjz9VpTJV14G6qfFeZcHlPNO/qlN1ivTv436XDA6T32yvo/pdBOecvob+PQTPerXi5o2bvP7663z1q19luTzEe9XPzgnee5VdKd/lgIokjvOLJ8Sh59btU2pnJ4LdZ5UEEcd2u+Pdd3/KD77/A15//U3+6l/9KzSLhmEY2Gw3vP3OO/ze7/8eu92O9cGab3zr68Qccc6N+h7n6ePAru1ZHxzyxhtf5uzsNW5/5at4VxP7xG6z4cnjexysFnqmeU+oa1xd43xFFlHZys+O/th2v6o90V9/tOxmMnn2nt/74Y/4d//X/yH/9B/83z9X2f2f/Fv/dkag3XVcbDZcbi+4f/8uZJXXG2c3+OnbP2Xbdrq/vcfXNa4JeOfwwROcnuOkSE6JHAdi39F3O+LQkx2EqmK5WHCwPtAz2w4+MeGVok/tvsQxTrQwvQ6qb1X4ofJh1C0iDsg0vqKuKlarFa+99hrf+Ma3OT09pWlqtTm8mAyVzwUQTxZPjJFMomkCixBGfStkfAYvAQFiTFxcXPJP/+nvcv/eA/7iX/yLfPOb36Kua0Qc9x7e5wc//AE/+vGPaNuWP/vnfoOqqWb7RR/wcrNjSIm6WfLVr32D269+icPTWzSLFXkY2GxatptzKi/UTQBx+CrgqxoJAXGBnIXk0rjHnhplfq59QWa2wXWft/egS/a9P/xouX2ugSpOD0DBTgz7QidFqcAQdX1tufUWnAcREpAyZBF8Mf6ckBGGlIi7HlKmqTIheEANg3HjCuSUTWFND5lN+Mrz56y/T6PRmpGkhkG2d223mQ8//JCTkxNiTJycnFLXC3ARyR6fM1kyMtMaIhknjuVyQbbDUg2IchcgqHI9Ozvj9ddf4/79e9RVzWK54Lg6pm5qzs7OuHXrFu+99wsePnjI8fERVV2RSMSU1Dh2Hhc8zgVighj18HduNMPLqtjE5NEwH5W6mzagXCNCNlF7z1EMI/ulXmB26uf5+2d3MJ+oPBfadL1R8bKHOAfO6dwgpJSo65oqBEKfTK4cKamRWuTEzmhAwDl8VYMTfHA4MjkNxNSx2baknKmriip4vHcgTo3T6S5m1nwuy1ZemRyDnBHJ8+UhkUzGhRgjbdty584dVYbArVuvUNcNzjHKo5iiziJ6H6KK1nvHctkQPORseyerREsGJ3B2csqrr73CnTsf8u677/L1r3+T9cGapq45Pj7mtdde48aNG2y2Ww77nsNwiJm4OO9xzoM4stkv2eQgVBXiq5nnqCeIQ/WAE3UMxZzO8j6RPF4fu99xVsX00Vx2MQd2duzPZXc+Mhl35T2D1Nzl9Jny9DJHyiDeEYIexGdnZ8SU6VNLN7QMfYt3ooaliM2kPrUb51Dl2+HIzuMCeBEGMnno6VMkxp4hDiwWDU1VqZFLmeurHivjnBeZzXsvzARbpvemnEkpsd3uePDgIQBVVfH662+wWq0R0UMRhJxUh2UTIl1nT1NX5MqpI182UTGkbW2XyyU3b97gtddf49133+HXfu3b5sjVLOoFt2+/wiuvvMIvfvELzs8v6Nqe0KiBLBQnUlQvZFNvWWWbnGw+9Ut90bmmZd2eDhZcLrLIbD5teuayO/0WsbNKPkp2s76nOHEAiZpzbr2YcH2GY0iZGAf6OOCc5/DwEEjEvmO5aPBOqIOn74WYMkLG5YhLqqd9zngRPIIzZzeTcdmTo4ccVRc7DQi0XUvla5wLpk8m0RPyeIzpdI+u67j3y5yrcSszuZ9GjImegc1my4cf3uXw8AjvHUdHRzRNTUpXnDfVqhaAyLpOyeSnCIXJVs4avHMirFYr3nrra7z3y/e4c+cOZ2dnvPHGmzjnWTQLzk5POTs95e133qZtW0Id1DjnimpFrzvEgSEOpDhAjmbM6j2I6V9EcOZQzvWvk6vacSa3kme/Lg7sNG9peuWKn7Wvl5O8mNw+10B1PozWOcwONefM+xVkXCDbrlmjkdkMoJT1dvEB59HJcLrBuq4lp0xMiWWuCZWMD6066qoJPjOR5lGUYlyMh7wKXTY3VTIMOXF+fs7PfvYzYkyICCcnN6hrUa8hWwQBQSyCBnrAL5Y1m+0O5yAEb/OQceU2RKirwLe//S2+//vf55e//Dmnp6ccHR3hvefo8JDbt29x69Yt3n//fRCxSGkipkgIFc5PESj6SIzRvl+VHjjdcKb2cs52fM/UXDZ76DrX/Bkz+fR0jprf/lk29tWDf99pKMM9tWaf01BhA5m828PDQx49uaQfEuRIAgaiHfCj1hgNO+cCoarJkjXCI5kcBed6+r4jb1vikIh1RbOo8OIn42DmLeowoZ6vTS4LZu+QcpiVCIkexjFFRISHDx+Sc2YYIiGo41NVNSKZlESdmQyShWwRALJoBGu9ZKg9KSW808h9iUJ5JzRNzZe//CZt2/LHP/xjPvzwQ76yfJOqCqxXK27fus2bb77Juz/9KZvNlpPTRFVXeqiWw1nUOCZnjY4KhLoCX+Zles49R0r2p4QXlOGnRx7343Sxfdkta7FvXEEgcsLm437hZzJiyogEQgXNYsHB4Zp+iLRxy3Z3yXaTCF6j5t4J3qJ2qg9mTnaeIpoiqpcDmTYOZpwm+r7FSSY4h3cB1b9uOkRnBil22WKcptHQN5kFXC5m26QVYkxIjmw2l8Q4ANA0S5xzLJdLRDwpmROcKBthXEZVf6KGYh41oH6HOXciwtHhIW+++Qbf//73effdd1ksFty8eYuqqjg5OeXVV17j3v37XNy7x+XlBcfN8Sxia8GAlIr5Ytszk2MEl8yAtMAAsvfZUbpeRP1d857pDPsI2d0LHOh/a1a8ln7tBb74sx0xZbZtS9/1pJRYrZfcOD1jGFq8QOUdq2VDHAa6IY7ZPpcTPgkehweCFCMU1E31kGvqyqthFlROLy83pBqCB+8D3okF1MxIRLOTe0EC+6+J2HjUqWgV3V+0t56zKSWGIXJxccF7771nkU3w/pgQLPKfixLTvTB3GsWCAjK/DYGczD5xUFWeN998k6apuXPnDuv1Aa+99iW8D9S16vpXbr/Cuz99h81mw3K9xGusGZh0KpiBOgwMQ0+KPTlFxFfjOTeX1fEeGUXuWr37LHU8ualX5/hpnXv1My8it881UCtfAULK2dL4EONACIGmaVg0DYlEX4xqyUA0XRLJ2aJAIlR1g5jN4JzDkxn6wLZtaduOrulZHyypqgo3ep/FlS1TOM1B+b65MkmpGJX6piRmcCSHiGcYBu7du0fXdVxcnPONb3yLV155VTdCTqgRKEiOaMRSlRIxs2hqjg4PaLuwt5LqVCQkw5ffeIPHjx7x/nsf8L3v/QveeustnMDBes2rr7zCN77xDR4+fMhms2GxbFiulsQcZ963IyNqNNkju+CpmnpPAzozpEQ8mkybjokpsLlnwU/jGpnJ17xteo/svTIeWE8pTRW7HMLHtys+gxEk4PFjqjGEitPTM7btgA9PuLjY0KeOXTtQBU/lPZXzeNTI0rS5N+Np8jqdr/DLFcl7hr6jazuGvmPXOg4PD5AQNFtQNCAwj/ePa5TLgV5UqUmyOUajD2uvq1MVR/nZbjf82T/75zg+PkZE9ykCEs3AkGy2uYeYWS8XsKzVMI+Ct1vSuwhA5uzklNdffZUPP7jDb//2f8bf+lt/m+PjY+pQcXZ6xne+8x3e/+B9Hj96TBUqvvTl1wxuowa9iBshK5reDYQQIPYQ6vH53OhgFafWIqV5Jm5Fhp914D9DieY9+d6X3T0Hd3yfvueQD/hL+f8G/BvPEqmXNnJUmfPiyRnu3b/P8ckZa1myaxdcLipcTlQO6uBpgqdPWQ/m2CPiERzOZQLgndfXJFOJgxgYBkg5gmT6vmfLlqpqqEJD5QN5jIXMHDewRI6e6JMzIKOcqi6148kyWgnskAfouHPnQ7yvEIGbN2+yXq/IORKqoMEB2yRqECacmLGakmaZ7NqY8ZBSwounritu377Fr/7qt/nDP/whp6ennJ7eoKoqFrVw4+YNTk9OefLkCQ8fPuT09HSc8z1DM2dySvRDT9/3pH4gu0jOEFNPeWyVeZ3rMlfXpkWvjmcoSJvpckM8U3bHP/Q9BzzmX4q/DfwPX+DLP7uRYma369jtdvTdwOMnjzk5XLFcBJoQqL3n9dtnPKorzi8v2fU9iMM59WErh6b4BSoXEElkL6TooG4Ii8DB4Zq6aRhS4g9+/w/Z7QaqUFNVDcvlgkXtEfHkHKfIdXGuRKOIV02nmWYe314ChplMShHQIMX9Bw+IKXK5ueSrX/0qN85OyUOPd8GySOX78nh2OBGNorqZ7MLkiJvdUlcVTV3zy1/8gq7r+cY3vsmrr77KwWqFu32bIfa8/e4t7t+/z9GJZmGZXa8kTwSIw0AaBtLQkVKPryp1DnOkmH26hWQyZ2yoDO+78Hsi+9wDXtTQH8+14theDRC8mNw+10BFhJgzQ0x4lywND4vlkhtnN3njjTe48+EDLjaXo7JT3JPg8yzVEQLee9R41YM/CNAsqL0n9gNtO5DTOVVds1g21FUFYoF704/56mNmPfC8PG/GdNVy1rS5c44nT57QdZ2m0QXOzs6om5qMvp6jIJL0oHcazSANHB2uyLmBrBHYlGKBY6mx6Bzf+uY3EeC73/0eb7/9E77+9beoqorDgyO+8uWv8v777/PB+x+QUuK111/FVx7nnaVuNZKbol7Xu4D3JvjFMyu5p5xAPHPpunYWXkRhPvcCH+Ni4sjuC1J3J2qsJIHshOArtrsdoQqcnp1yfHbKk/NHPHgQVV4d1EEIbkoVBTISdYFdymO0SnzAL4XOCcOgctTuLkmxY706YLFY4H1F5Spzmso2jZhfXsSSpw4e29ZTRGxSoEMcFB8LvP/++4QQeOutr3Pjxg3W6yVkR7aogZRoKqBwEL12GiJVFcbzTRBi0mi9d55XXrnFb/zGr/P3/t7f4+23f8I3vvEtzs5u4Fzm4OCI27dvc/fePR4/fswr3S2qRTU6WIoysfR9Tpru63ry0NuhkcmxJ+fBDG6Hd/kpsSsi/umWcObnSu+Z1PxNuflpfuGfaqixLaQEjx894fH5hsOjFatVze0bN3G5x+XM6dEBjsyTJxf0KeFywiXwAgGhFo34eVE9k2JCmga3WlDVgcVyQb1Y8M47P2Oz6fBuR9MsWZoOFslgh72QpwinzOV0fwVznmBZZS+Vg34YMs557tz9kD72vP7kNb7y5Tc5Pj4mDlGTHuJmqW2VD1fSkinPYE9CSTmmlHAiNHXNt7/9bX74/T/k+3/wA3IWfvM3f5O6qnjl1m1+5atfpW23/OTtH/P1r399vOdRfh2a4cuJfujYbi7pui2+rskIfdcS0zAK6YhZRMaHvWpavvB4pv69IrtX3ndK4q9/AaL/oao0w9MPmh0l8eDBA+oAxwcrbp4cE3zmYO1xfsGi9bR9QgLghOChchkvjuAywXuCr/DBa6hIEsvFgsVqZfLnGIakDkWOxLQlxUhVB60XkGIYFUPVbnTPSL0uyre/empDZobYkwUePnpEP/S0ux3f/rZiUtWBmrIYmQHnNF1eIsOkREzZsLWJ1CdiPzAMA7vdjvfee49HDx8Sh4HHDx/xO7/zO/ztv/03CZXnsDrgDf8Gf/kv/SX+6E/+yOyPZHbVlccTq0UQiCkyRA0abncbchzwQU+3pyzTYmGNoeWPL8d5tjXzU9efXVNeTG6fb6DaYZ3LFe3HOY/3nrqquHXrBgftARebS9p2Q04D3gkhCMFPWBOJUTevU/vZiVCHCpwjOocTxfdtd5cMsWXRLFgv15pqnclQHn3ySbxiThq1KqqweEB58ijK72NM5Czsdh0ffniXpnmbvh84u3HGwXpFFo2kjmomAzGBKIgacaQYR2O9vCdnPXCbpuHmzZu88caX+N73vssrr7zCwcEhdVVxsD7g1Vde5Zfv/ZLtbkvbtqyr9eyAtxRXMpyRRa5jigR9wXArk2coMGGmXkCo5uD6pzcoxWqa3j+P+8/DA1c+NscBe74AQ0oSUGU25sSu63j8+DExQbNac3Z6g/WyofYeSYnBCaumph3UY5accFEj3B4hiLNUqNfyo+wZXE3OiaWraJYLum5gs9kRfITFSu+lHFziQNKkF7JQMP5i8aIpEmWYKFfWU/GtKWVVykQ+/PAeIVS0bcfrr7/K+mCNE69flkGSmhBIKcgyzBzYfqGEvFRpItRVzY0bZ3z5y1/mhz/8Q46OTjg6OqaqKo4ODnjzjS9zfn7Og4f32e12hCaMh/uEhZpws5vNJV3b0vjKvieqYzcD+kl+Gnv3lFgyye78cNnXgbL3x57s8gzZNT1xwUN+1/2n/NXnydTLGmN0DFWYLjCkzMVmQ9dv2VaO40XgYLnkYFXjZUXt4XLbKrTDgfNC8I6gtXME0X/7ekFeLsgCofYsVysOj094991fMMSBGAcyrToTy0zwppuZ+wvzlKVh9+3G92J+lqafRwYTmZgGuk54/PjRqJ9/5VcC6/UacNg2wUkmWUaO7ExuTQaSRk99Boc6P/0w0HUdjx48RID33nuPZrHgy1/+Mjdv3uDgYMXt2zfZbN+k61u6odNMi/ejUT26k4IVP0Zy1GxgzkLfd6OklndLRi3bmWBdNXv2ZNfW99OS3XPO+ef+n/FfuypHL3lUlUbFU0rEmMBl+jRAjHSV1/nOPTn3FvASdcO9Qv68yarGOKaaDy/qfGQrpHPO4UOtGa6qpqprvNeipE3b4fqOOnjqSn+AMSqv19y/7wKrVCfMnKM8e5+ZPnMn6/Lykg9SIgt851d/jcPDQ6qq0QyslCCEM+dJTQiXYXNxyeOHj3n84BHtdkvXdvS9RuqfPHlCv92RU2K72/Czn73L2+/8hK985cvUdc2yaXjjjTe49+AuSfIokzqc6nqy1bSonZRThKhrkIah1ICPc/EsqR2lbj5Zz5JbmX9yqs15yhKZz/sLyu1zDdQ8apbJOBVxpgx6trsdvqpZrtf4KtC1NX23JXhHHQJ9AZhnkJS0yjgnJGvRlPMe8ZBEwdJ9n8aoT0qJXddShYZgofPpwZ91vxNuKVt0tfyvKE+NaClGY7vd8eGHd63YRHGkTVNPVV8iJry2mE40ElSA9HY/4x3lhHeO46MjvvSlL/Ff/OPf4c6dDwhBqwAXiwU3b92kaRYGM7jg4PBgbwUnbFVisBRTHAaLmGrkNKfRwik765rZuDpPz48gPT2Z1/1upkRnBvHeZ1Lii2ChqqLwYwquyPJu19ENkQF1fBZ1Q3AgKcKioTs84Pxyw5DUKXGkgoIiiFA5UYyUeIKrybXOa7UIrA8P+fDDBzy+PKeXBAQrIFJMlbMyzqvpjv3J3l+nOW4/2y9KdHK73XL33j1EhKryVFVlsqxWr14n6feVCuu5xFqxif5VD3xBCN5zcHDAT370Nr/85Xucnd3gtddeY7lY8MrtW9y5c8p2e0m723F4fHh15sc9mFJU+Y29xtrsO0ac7/SR6ZlnhsI8ovGnlt3n6A2AHuHBR7znpY1ZBEQQfKgZutbmMtG3mRADh4uaykOuhLwMqjOSOTxeK4y906iOc4Y1rirEG2Y1eMMYry1L49RgEEc/DEgnVM7pdYKbHBDYixZOoRtMPstjXD3cdKSckBTZ7VoeP36MICyWS9740pc0+6DeHNmpvsNNMpvJkKDve9pdy7BtyTHTdR1919O2O95//44WZu0uuHPnDj//+c+5desGIXhOTo55tXuNzXZjUpX3Ir5png52xcCICllLQhwilRPmsllYOya9uH8Sf9ayGznkEX/h43zLZzJ8CIDCfKLB+xyqW2KMxGHAy0CM3YhRdxbqzK7g2KEEoHJO5KTYVt0TdvYiijk1BpBQ1zjvyX1PjB2xt/XKHu8XI2SwWPRSCjXm4pnV6cmzQuOra5ENvpRTYuh7NjnzwQcfcHpywuu8ztGRI4RiFUzvj1ENxwrH40eP+em77/L43kO6XUuMmk2KsejKAXImDpEnjx/zwx/+gFu3bipbj/ccrNcsFgu6oS2WwojDLnp0b99lM1JTZOh7qmqGWy1GVXn+mfx+TKm9dsyDDteZCy8it881UFPMMwudkRIkpcTGqjKb9QHL9YFSPhys6HcbgnesFgvSkIBeo6i5VO0p/lSjUVilm6OSQOdAnApcynBxuaGptIBjAvrDaEFK0QuGV7pSCQ0zoZp5pmnE00bOz8+tcAmapuHG2Rk+WJFUUicoWUq/RKDKj5PZfQyWZnKwXq94/bXX2G63/PjHP2a9PmS9XrNoGm7evM2NszMePLrPo0ePeO2N1+Z3i3pAQowaDei6Hf3Qkom64EkLfK5+5iqyZn5m6L9lf0Need9THxzfJ0+9Pvosef99GdRV/AIYqCk5HAHnCn2Gw7uaLELb93Tn52wvz7lxcsDhsmZRBRYHK8Wg5kjb9aYYNbUfHASBSoTKOyovOGfV6SIsj1acnd3k4smW+8MjhiGSslGHVUFxrgWvB1Nkf2+hpnS3yq2M8zxif81zjhZBOj+/sAMhsl6vOT091aI7S1OWKn9V0s5SpWjENGdV+DGRYx7xg9vtlr5VLNnPfvouB4cHvPraq9R14OzGKV/+ypdBoO3aa89OcVmp2wwGk3MEM1BznkFynvpscSSvSqXMHNT9dz9vXCu7c7kdzylBWOP4zY+44ssZOTtEAkIkZ8VP77pOddcQSXngIu4YTg8g9ZAHgs/UtUcG1XVilGOuRM3VDtBCEqf4+nKQ1XVD8IHgIrhAVTd0fc+u7elEi1sWixpXjFT1lKbD7eo057l8l2p89qKDKSVEYLvdMgwDMUXWqxWnp6csl+WcASFBViFOKTFErfbeXlzy4P4DHtx9QLfdsbm4UCO173n05Amx70gx8eTJY/7oj/6Q3/iNP0Ooag7WB7xyGy4uznl08dAeZpoLdaD0kHfj70oUFWJKVN4X6O2UVCpz8hTcTJ6S82eFE/Lev58tu8L870LFa9xM/+41V325Q7yzOgrNajoxSsis7B4xJZJTQ2yImWT8TmLFpeVzZf5j0kCDixZhzRWh1gyUt0Jt8QEfvBZ0e0ffZfoU6bqeOPSEUFF5dbLKTh9ZIkbv3B7A9P1eBGa2niqzGvXNGYZh4OLigp+8/TbeK97+4EChfqmkcFPCSakhCNy/d4+f/PjH9JsWyRBCsMxpsufNY+Bg6Hu+973v8Ru/8RtjgEtZJ9T2uBLKsM8ak0cxDi2gkWNP1+5wribnar5qkwW5J5jy1K9eJAz23BDi/ALuxeT2+QZqwkDo6pFoRWjA+xoRT9v3PLpzj6p5QlNXHKwabp4cElzm1dtnbA7WXFxc8uDJE0TUwAriqERoHGqker2mc0sA6sWCw+MDdm3LH/zgj3h48YiDgwOqqiIEBcKPYOfiBMlEyyNXJqjI3JiQl+KdZVKCYXA8evKYtu948uQJv/ar3+bmzZuEUFuYXIBhpF5QPJdMIADzvEo9VjmEyZnDw0P+xT//FxwdHnN8fMzJyQm3zk75xje+zo9/Apebi6eXVzTSVlWBlCKxH8hDgmGAqh6/Q1OkEYgo/+jMI5xPwGyvfdR4vmBN3tB0wO+LrKREHlqoP/q7PuuRoiBS46U2rtsK5ypCtcBXUbE5CR48eEg+WMJ6wXpR49yOo7VnVwldD4kIXuEqwZUiPwziEhAHET2EV6sVdV0bnlhT693QE1MkRk/OFb6alJ6UNNbMKJOZYtlfuAJrGWPsikkVuLy8oO87hmHgN3/zNzk6PKaudI/EWPhVjR03Z4acYIj0Xc92u+XR3YfErufxxTmbzYaLi0vef/8DRBy//OV71IsFv/Fnf52mOeb45ISvvfUWB4cHvPOzd4mx10Io9DuiHfDYPYJVQZuBOhosM9c9u2SQsjx+Sq/HU7L7lCg/HQy5fpgMF5FNJa9nH3yUW/4BP+XvfNR1XspQnThIHh0RySWBpxIQDc9GHBhSzxC1eMd7YwJxgnh9ONV9iZTtEEwRVwUwjKtzTquFG/C+pmpqXBXo2y1x6BmGnq7vOT5eKXuLzFODV0yrbI463vgnS2RnconHQzNrsKPve+7evcvv/cHv8+1vfZvXXn2N5XJlsCnbETnB0DEMsAgVv/j5z/n9736X7WPFsEmhi7LonUbaYLu55Mc/+RPu3rvDq6++QggVTVWxWi053z4ZgxXYHJWUhTAZ8uWATzEx7LZQrSwboYhrFXN3jXE6TtIV43P2l2eo7b0xbpV996z885A/5r/EvwW896wrvJSRBJKD6DPJqYEa0XMeC+bEnBmGgS5CtGI6Uq986RZdCjIFgVLS1PSQE4vFgtuh5gBdb1+FKfAiiqH3yyUO6GkZho5HT56wXi6pfSAET6i8FabKUwpGAEkZRKkfdTkLJKs43EkzEBYYQ+DR4wf8+O0/4XJzzte+9nWOj48NL+0VciO6h9uoTACPHz9mXS3MwdFAWE6ZkmXSoVCuJ/cu+N3f/WfKT/31t2z/KTWfFnZfPS+mMerZHCH2tN0WCdCkBSN7ingwB0H9yAmWA8x27fy6PFPnXqebr76zOK4vIrcfkeLPZshlUp42cjJeLx8CXjwpZ3a7LbHbEneXvHn7DIfQeCEvauCQzW5nhOduxJoEL9ReCEHJnJOArz3r9QFVvaBplgx9j/iKIWb6vqPvB5plowS5oqkqb4pJZsJaJlU9JsaFL+/JYl5ejgyDsNlsGIaBfuj4M9/5DjfObpqS1AumNGgBleGdhpzIfaRvO7bbLZePLsgxsWt3XG62PH78mL7tyAl+8pOfsFgu+Ut/6V+hqiq+/vW3WCwb7t67q+n60dDTTTxScwlmeCaGrtXiFpmeSWZrJPNc8LSAzxKd2Xtm7xil8bpfTsVDRcCyXBHjnPFtC+vrv+rlDmfOVCD4gBMF3COehBBNwaShZ7sTmgCr2tF3O3KOeBHqSjkk8W6MQDlTWooFzQpTCV6hI1lwPlBXC02nrlb0xkXX95Gu61g02jTCBTviZ4B0ubKEpisNGjCrGBrl24oDYqbtIu9/8B7NouJrv/IWN27ctGYUE6+jZKEbOmIUJGZ++cuf85Mf/4T7H9wndv0YRYop0e9aUtQUwr279/jPf/v/w9/8W/8aHjhcr4lnN/jw3h3iLJpf9lihnipR3JQisWuJMVu6/zpffP/Z9uAHxSi/qi2vEW+5Vnb3vyDPzKUyjlnzX45/9tn39VLHRA0VKZXqykqSraK9HN5x6Om7HV0/MCSvTGZOyBHSkJUo38jPJcNmc8Gubanqmma5YH14pPRTIeCDFdeJWEpRiF3L0Cq84PJyR1V76hCogxoHI9Zs5qwqkkUDAN4/Xek2ZrVsrWKMiMvcf3CPn7zzI7bthi+/+RUO1geQIcZMToqtHYaBftty/9597nzwIat6SR0qJAGGz9fswABZDfDtdsdv/dZv8Tf+xt/g5s2b410HccQRlGf3dq03n0lpICXNDKQ0oFXi+0ZpMXPm8j2hc2dn9VVbYibzk/F6vb6eM4KUd/ySQ/6P8hf5r1z7iZc3lNsSpZgsoHQBkWARzoCjo+07Lnc9fQKkIian8m2MDCWirQwOCgNwCKFgPE1eQxWUMlASpahZsjppg81fcE4zvsNOISshcLBajsXNeo8GK8oT+4Q+yfWyG+PEvCMmxw8ePGC3a7m42PCrv/qrnBhuX4MVjqFX+em7jmHoib7GiyMOqj9T1iBbocUq9SdVVfGjH/2I1157lTfefJPlemk3UgIbMKYsrrnXUY/EHudgiJ0yUchVAZzkVm9BrjcZniG346+eAvgWH3WfRz2TX0hun18kde1d6c2LD1TNgu12p5yKwJAS292Wvu9MMHrIPcGh6Sfz6r0TpQ4h6cKkTIwaiUpSIoQe7wNVEOqqmeHZEpvNlqauqColId8zsq569DbSWP05s2ApylIP+a5LPHgYefudt8kZbt28xWKxtOhTNj0s9ENPSkLuB+5++CHvvfceT+4/IfWaqur7gbbt6NsWAe7evcvPfvZTvv3tb3HjxhlHh4fcODtjiD0X28sxmlAwswoVKJWsGXJiGDpCWpByNM+pCKWFbve03nVh9jwKtb7lOiPheXGotPdqvuatGmkYvggZfsZK4PKDFveprKXRA/YzntSM8kIOKROzJxngPaHpvZQTiYSPMGDKVLQzWr1aqYyJKLm3FRKKd8TkNBLVquyWiGPKWRsAmFzNJ9gb/ll/V7xk/bs+km3zrM5jjjr/d+7cIYSKfuh59ZXXLN3vDPcHgkY5u82Gu3fv8v7779NvejwTfCVZasrIgdlsLnn77Xe4d/c+J6cn1h1I4QJzU0+LvMwtlLITNQKVht4yMoNxYRqtG5mrButTomX6ZSrw+5iyeyWie924xPMHsnr2NV7iGPf+LO08lh6IA+dHQzKT6OPAZrejSw5E4VHJAgt6SFmPFDKgeLc6ZfCeVWY87F1fuJezEqKLdkpKdshnYOgjOWaGPtLUNVXl94o0x0YmFg1PqfDk7juz5aAvjQWEzDD03L9/nxQTKWa+8pWvsFosLSqsDALDEJGYaLuOrutYVguLMGOqcAqm6K8yOWZ+/rOf88tf/JLFcslyvTKc9kwflmjeNeKh54YaqTH1xOhGY0Y/mp4tfXn23PKML3gh2Z0/0f7oCLznTp59jZc0xi5iM91bGshk40YXCWPzHkRIOIakKXCVVzQKT0Ib5YBLEBz0UQs5i27XKvliWuUxojm9Nt3HruvJORP8QEywamrVYYb1dpJHg7rAq/Yhg3vhGZUdx2RMxsh2u+X+vfv87Kc/gzfe4ODwkKZulOZNlPqpHwaGGE1+sp6q2SKoszN5ypQKF+cX/PIX7/Hz137ON779DUqXq7G2xm59bGQhU7RXbYtEjJBTpPJ6P9MoeZnZI2JzOtsf+ePaC9fI7dXxInL7ggbqldsyAzVUFXmzA5QYPOWkHaJSxOVEjJ1SM2Qj3jW+7kwiJehzGo1TEaFLkaqpVQmJ15B9UEC0FmfpAdf1rYGga5aLRg1kZ97lOKlPexUqdPvPkkhgUaoYM3EXuXPnA1arFSF4zs5KJMoumWDImTgkhl3LvXv3+Om777I93yn+Ur/IImz698vLSz688yHvvPMOp6cnysu3UB7Zze6SIZWIwr5gupFOM2lHiNST46C8bDKqX92cV8G3ulLzp99/qRwos1euNW/z/mt7l81PvymmgTnC5fMaE2Z4ehbnnB1gM0/ZOeuYpq5eP/R0MZFyMDJ7z0AcDxrJhbvUmikIBB848F5lyQnOa5GSOKzdruE++8h22ykeCUhxoKKi9mFGnTOPopSo5Fi1x/yAmhc2qVw7Li7OuXPnA8iZOjQcnxyPbX1VWXniENlsNjx58oTHjx+zkIZQVZDy1Hp3vBvoOjUcfvzjn/Abv/lnqBdNuYGxm8kY0R/nH5Mv3ZspprF1oUag1KopNHJ72rE8/DiuE8I/pexeeTFScSmv8kUYEyenjJ3DRpaPwjtblIMoT3Xb93RJeZSjFZaUampn8yyildLiIA+ROuop62aNV7RISFOHSpDvpntAD9J26CnvytIQDOs6p0XLJhDzwlWY7LUS3Ukj5ENIkthut3pYZ2G9WnHr5i2apiF4bdurONxBeR5N35Y9UA76687N8/ML3n7nHY7PTnl9uaDwqMoVcRllxXRjMXZErOiva6mqanzPqH/3V5D9qz79z08su3kW67IXA5EjnoaLvexR5Eh/NHgkmCFnzqzzYdK5CGSv9oAVdaas57SZouoj69LSx0wumNUxfqhwEUmRbJAWZ9Rqbiy8EgYrRBpiYrCamKZR2KAGOWWWutZCqqtF11AcsOJ8MWK8c87EYWBzeckH77/PqmmU+/TwkKZZUHlHbxHinCYdO28bbsHTp0y5vh+4c+cO77z7Dm985Y3J2cuTMI1Z4rGRRTG01ajQTFZSUMpe86XJuZpKtPV+Pmp8XLmdC7/wYnL7iQxU57WbQxaNMoEp1dJ7HIh5UK6wviNaKiRFGcPY5qTrlCQ97Nu+5+joiH4YtAe60+iUiLZC9V6I0TH0LZebDTknFouGPirNVM5FUeaZgil26uS5j/eLHfBW+CWim+lyc8nPf/EzpRRxjrOzM+Mb04X2Rvq/vTjnwYMH3Lt3n4pAE4xKpwhFUq9fnPDo0SN+53f+Kd/5zq/RSEPJyGvb2KmKFDNS9V5kNFAhapXi0BPHA36sd+TpA/6KxZC58rrs/fGRY7Sf8nitp4z9nOlTYvGCl/wsx9TdaPrdFJUu1pNFdpwHr219+xi53OyIOZClImWhN5qZolyEjPcaWfEihDDQHByQQTltg5AHWxMxJRYCuarIpqT6nOl2LV1MsHQEvBawoAe9FubNFWJmHoXKWfFcguCSGPxEu0w9eviQvuvp2oG33nqLk5MTjZA5T3KqSLu2p922tNuWZlmr8Tg6SjP1Yoq063r+0T/+x3zlV77CWR0ogPxRxIr4JsbIHcUo8oJG7rSDkbaXZbY2WT84IcX3ZVcXdLaUn77sHuY1f05+/QUv+NmOsuYioql3w51ll6xDn1qa2XnEBXCBCOA8wzAZqDGJVp5jhVOSNRplRSMJ/byIUjs5KQdnwrSoyu/YMhiyHfZt19EPkZhgWWu739GSsOipMxjQBP1g3H+CG7lLKcalHbJt2/Hg3gPeDe/inXByfMJysSI4j3fQDpFhiIZbnBmW2QzGPD+71ZxLGX74wx9yenZqLTivO0mL8i3nWTnb9LUUB7bbSxbL1bRHijoZL/XsQIFGmf90sluMiDkc6CBf8hfSH7zgBT+74b3XaHwIVjOiOE6XIhnFnIaqIdQ1PvYKszLbIMuUoRqSQqfA1latVgtkaTtw7wLjQlt0f4zaUuBYk+mF6PkUY6SPWtuxGpYsFjVNHShVZ1k00yplvm2yzZ8ZuzdqUMjCBdZsIOXMkCIPHzzkl8EzDD05Jc5OHPViYberhrpmdG0J8yyOWeTZzq+Ivu/u/bv8+Mc/5hvf+oY1DpjL29PCNGbZzDh14uzsKZzGspeO171+1TydadyS4ftTyO3V8SJy+wkMVMEbif6u7Sjg5+nPAUQFs4+Ji+2Wto+IqzR1al59ScMIyShQFCsVVSPivOJS+yGpwhQ1Pr2raL3XqreYGPrIkydPqBcNy2ZBbfyk6p2pJ4ZRrEzDBNoA7jmm0ZJV/snIo0eP2G13PHl8zq995zucnJwYLivYId/T7jo2my2bzZaj5aHSSeQJt0s2jzBldm3Lhx9+yO///u/z5//8n7fuLqpuQqFBwpqRlQiWYX2d12icksJ3ylWYtRDB27y8sOD8aca1UdrZy0D/Mu7jBUceDRL7N0qFEoLKYqFpSBaZcqEmOUcU7SudUlbscypLYQepy8iQ8U55Io1ZlGCYIydY4fFU5CGSNXrFFMntU2JzuaHrBlbLJU1T60EvU4REye21oUSJsuZUWCWKJ6w/FpQkDpmLJ5fsNj/DO8eX3nidk5MTVss1WtpRoAGGLyfTD8YSMTNQRZjxN2Y++OB9vv8H3+db3/4mq4MlhUpV3zAd6HncXcXgFrRj0Y52t9VsAMZpWcIWHyFbf+rxEde/Lz/h7/Hv8X/+AnSSAsP5C+OBH0Iwh0qLIjPaqtdXFfWi0Za8MWib6ZwVh5qtIA47YKzCOkXBDTBE0F5TzhxqjXKnqPIq4pGsnesqJ3jv6WPSgzhnYt/RPenZhJrlYsHBeoV3UBIOeQazHrtBuazZMKIaqRnIEUfBc6oB1saW9997H58zr73+Ojdv3uTo4BCH1yIossn/5NAXQzVjelefnCKR55sLfvz2T3DBcevWjf0JLxe5bi0iZG9XTkoBRM5WImVtCkrE4Xnjk+rGj5Ddc+n4z90vP+HFP71RIqjqVIWRycNbl7mcxKBPC+N/jrM18phGJuPHbn4pmmObEq3vySgHalU3nJycsGtb+mEYYVsqx7MuUjBlYNHaA3JmFyP9sOFys6NpAsdHhzRGPeiKk5bLc2GwRBRil/SexbIGeUgGKfB6fsfEnQ/ucLnZcHFxQf2Nbym3ebLiO/a5RM2dA4kmtyoopeonpkTb99x7cJ9/9I/+EV/5yhtT9HLi0KJMZQm+FbiNZhoSp0fHmrEwmsrxo2PqdrrW1fjAJxqfgtx+AgM1T0IYPL6qxypdEe1ulJ22hMw4YlL0YtLCYWISYlIPIotNUsy4GMlVBTkgEkblo1Gjgo3SzkklogAWtYuJYdcxxMyirlk2tWL4yixnGErXJ0txuSzEHHHijQHAGbhfjduUzJO//5Af/8mPePPLX+Ls7CYH60NV3DYXBfOkFbJuBE2P0eyiOLNy9f2Tf/JP+NIbXyLUFm02vSZMBlUpMimHu3d6b0PfjpyoJXktSQ3s7BLip6jAVV0r43/213L2qv0tP/Xm58QE9n6Xcmbbdde8++WPOMP5zH/nvSfUldEqKWVMzj19jIh31HVNaHuyeHKqNLKXo0WuDJeTtRgFU1R+MMJp0Silc9agQlTllkrTCaMlo8fcx0jMHX1K1G1LUzccrpZ4KUc1xgOpEQZn6qu0Cy3Yo5ST9mYun8uZYXD84hfvEYeB9pWWGzducHx4hOTMdqeFNbkYtxT50+9MeUaeX34H/P73f5/FuuFrX/sqgjZAKBHJibq8mAmK+80547IWCLRtq1JtjpuzKGsaBsSiJtfK7lPj05Xd7+RT/n76b1z7TS97TK0L1Sis69q6fTmyC9pALm5J2eFdhfONUp7F4jE4WzPt81SiS1osoUaoJ40RqSpUrNdrLY4bBoPAyMifmFKySI5DLM1aHG+XEym29ENk13aslgvWiwpn8u8tuq9cwBZcLZXzM6Ou4Oc0C6aRpi73vP/+e7T9ju1uw1ff/CpNVZP6iGS9boxJITXjUAtZC1hsn2WFcg1D4oMPPsA55Q2OMZpfNUEpsDsqARGlAFJ6L49wfHSoXRDNEKI4ijHaYbYvV5+23p3LRxlfyYG/k8+e8e6XNya7oDhVep9ehKoKNIuFObyiKf00gUKyAqRmiEjDWVtjD2dZGX10hRGu12sWq5XRMfb0u46u7+kMZhhTtMynQ1utRLw55lBsh0hsI5w7Dg6WY2OLKgSEZDUuecyclVF4fESEUHmTMdVzynLhGPqOvmsZrII+iLYs9z4wpIT3eeaY6V5ISa8TKXKrej8PkfOLS95+522OTo7UGQylckDvKFsUWIzAy8tkhGagrmuGYdCvS0aY7DOmCDSTOBtzMSv2DkwGtH3rC8vt/ILCi8ntJ0vxO8F5Tb+HCmPoTDhJeBeJOeMrBd57F3BETTeJiqJG5QUcRiOuv4tJiEripzAC53AyqxK2g6/gqQqhd8qJ2JtQRv1ZNI2msmbT5cxzcWmKEMUcEXGWjrKYj7Nq+ght6jSFH7zywsbM0eEhOUW6tmfQMIRFsufp0SvIJNsY9x8+4O133ubGzTNKv+kSPUUYjao5l5mgBTNd16mB7mZeu6TRINn3ep4+1ueCI8964fqPjvdR3n5dvCCnRNvurv/w5zAmR2E6BL1XQnucrlXwUVNE1rGnCg0iLRSvnykSUw4679RR0sM+E1xGeVY1OltVFUJU+R4Ps2RQDZTCxNKT6rxFUqeRmWGICLBuAsnpXgveuutI0hSUiUYB8ovRjmD36gynmKNiTe/du4vGSROLpsGZVy2oAVSKu5g/Z7IVNiM8ow7l4ydPeP/991kuFyMcQGxfqzGvBlD5HFk07S/2fRqWtQXS90vKV7hzX77sPmHDP8k/+ALQnU9DDVSrWPYGqXIZkYhLBZufGbkkRw2gOiTmPBpo3rJSg0YJGCQarEmNzeVyqQf2oK0Xu87oqyzrNZLZS0n3K81NzqXKPlJ6MDjLFuhB7/E+T8WseVp+lQ8ozV80g6WcmWrIRjoiu+2OdrdjGDrVdUkNQTEMKzIdmtm8c63xkzEqN0Q9tC8uL7l77x6nd064ceOMkfllNrSWQXVqMVLLeiwWC8hu33kbfzDCc7lyvdmaPuuFp16c//r5svuINf9J+o3PvYp/wk4zOs7zuXPGwSt+wvznLJbazyZPWdPbDjXAciJp6JKCuVdsdeTxoyc0ywVOPE3tqEKAi0tl/pkbQ2JnaAkU7GV7IMVM23X4bem+JqSYqSrbTzlPGQC7nl7KUzhMpRTb2qV98CyWC1arFb7SVq1DHDRzLFNBeLlLtWNKuRd6Zpjx571mRhLQGjXgcrlA+xkmyAaHyGnaB9Z6vjx7CSzmXHS92iNePU0kKx/SswzNz0tuP2GRlOHvnNNFzGpkOkl4Ue+oUPz44JGecfEQp7gke4Bsi0JSQ14Loz0+BI0cDCawdtCnrJyAYxGMhbGHFPVniAx9JGVhUSsLQDl08YYtIYNhQApjgIKvzaOJagRqIilyebnh3t17agg4z6KpcRk6YxXIdv0xWmfKKpUIQS5mtW6Et999myF1nJ6e7EVMx+hTmkWvysRlNWBEGA2k0vZ0TjgsRTtcN56SuOve95TZOZrJzxsaGEnsdl8MA7U4LmVNCp7PeTUisRS8F4eTpJ10JOCMikqNsgK5MHLmcjXntJdyMkMgTtHCutZ05xAG+hgZcsEipxE75AxSUAy4ZGuZYiJaKyDHkipo1IkccF4NVGd8t2NTL6NXyVIwW3nEAEI0Mv8n+OBYLBa8evsViHk8PAp2tWC3cpm80c8yZWYKrW1bPvjgA0Lw3Lxp3m8xwguPZLmIOQcajdMua1WorAHI/k/BfBUn7Sm6ks9Ydh8Q+Y+44H/23He+nDHHyYsVMTmn9HyF6QO045eYg72PJ8ujQ5xN92AtInWt0shxXQ4q0FaVPlTa8YeObUxES8POYR8TeGPSTQkgJnZth/cYb7Aaik3tyo2pIz1bjkLV45wjJUuj2vrmnBFjw3BO4VoxDkq2iTp6UaVOU6128BZRGkVmPHuEYYhcbjY8ePiQsxun47zlPZmyQIiRzReYjnOOqqpJMY/ZL2UXKDCKEpS4chx/xrL7mGP+Yf6r/O+e+87PfoxzSR47Re3dva2DGzlGs+npkoW0AI/ovHpvEBPvNUuYtdVoSpGYBu7eu896vaZZLKhrLXhqFrX2u8+TjhPjMC94ZBEhF8ifCUrJAGhTFiGGSAgLUoqUgJjuIZmL0/iMgoz8pM5B1dQsVytW69VYgBpTRJxQN7UWWIVAcNWs0DTTDnE02B0VPniqOuh3C9SV4f+LtZChkLDnbFBFMjnrfU8KnVGPiCu2RsKXoEI2HFvBoZndsrd2n4PcfsIIqhvTNnVd4YwoXnLER8GHhpSnNOZ0uE9Bck1JinnNmiLv+2iHvaMKDYcHx7hwSdsqJ2OOCQrI1w5XDeGLeWKaKIhDS98PDMuG1bKBqkQaVMEnyTiXcUWxlCiU85r6xZSmeeY5Z56cn+O84gxvnp6qRwdjtxb1jEoUq2BM8nhO56xRpDwkfv7znxlFluAMM6vyYFEoxokrDhxDSgTnqH2FHhH6PCW963KEHM24mo35YXDV8ym/v2oL5Hz9a7L3x1NjyInztn3Gqy95iIHiMeoygcPjI/yDB+S2Mx7ShMRMHSqaSrlSKZ1PZulu0L0bbS2d98b/qRHUGNOYIlwsFhwdHRFj5HK7ZbfbKaF+ziPsYCrg0rTTSJGDYue225aUIstFYFEHUk6EpIrPFdm1RVCFOaX6Xc7kpEa3kDSyVgVMv4JkhqFj6PuRpDyj8yPWsadgZ8v+LZ2qhtST28gv33+ftm85PD6waLGVbqT50fy0gVmFAI1G3PYiB2g7zslIfVrQPmvZrfgVXnH/4TNefbkjxvj0L6VEV4ozaq1zs9JOOQN/jtzVuZB+6wnqvBKb+94w1xaFUjx75MO7dyFry9FmUbNaLsiiUfeUIrsdZPEWiIBy5GeyHfbqiMSUubzc0tTaPa3b9fjjFUU4JDO1cS2HaXk+yzoWaiIB6kXD4fERRycnetDnrJ2I0gCiRSTRbEI1GhxDtB7lZkB48VRNhQSPF0dd1dZ+cjbKWT4+iaZKvWeEH6iT67XojALesZMtZ8vWWejlJcruCTf5r7v/7jNeffkjpzwV8jiDvZFHmsnybHnmvKveiUAe6QBTToiDqnJ0Q5nxSMoqt/cf3OfDu3dZLpcsl0t1wF+7zUmzYrdYsN1u6XprsiOzLmjmcBQLU6c9MkQNbrU5s3PCweFiNMxG6ioY9fdIUYWzQIcbixpXzZImVHhxeMTyV5n1wZrbr95mt9lRVQ2HqzVNXWuzIh94cv6Evld8uasCJ6cnNE2NBN03tfccrLRgMCdMqWsgreSjNYWvWNM9WMIsG6A6XmXZKy8dxKTdwPSRvxBy+wkjqB4RbR+ZEvhKCcHJmp50IRj21CE+QB+tlVe2lJEYqtThi/WforE0TfjLlBLL5ZIQAkM/0Lfam37XD0bV4/C+UsqKiIaps6a2ckqcX+7o48CirmgqT8rBohAaeQquFJ4MFolNCF4jZhI1lWZ42LoSnMsED7jM0A0Mfa/YFEs1JdD0wcxrmWKcmirrY8f9+w8VBynCV77y5lOLWPxQikDZ+nvvaRbWBcLGHpAgP0OiXtLwVcXi9o2PfuPLGE7UMIWRvBzv6PueruvwdTVGm5NF77XLjgeCeZUKUB9GYJRQUpwhVBqpTyVVqo7bgwcPeP+997WbU9OwXKxpdzs2l5cMQ6KqGsTXODJBAt4AMtkUWLT13HXav77relKMnBytqRvtvEZSg2NU9Ex412SUaSLOumc56rrh4OCQw4MDbeXqPbvdlq5t97zkKUo2tSbEK2Sgoubo8JicEk1dsVgs6bpeDdQx5zVKLhQew9H/mhzKfQWn960Fa/K09ntJ46s84u/k/wz4b30u3z8faUypz387pUARlRW8YdSDZqwg6v+ydVPKkWwFSSkJOXnqJtB2rR0+iZSVk/bevXs8eXKB94GDgwMOj7Rt7mq1JvaRg4MDsng99IfBIp7WIrT8mN6LOdNFxbNuLy9YHSzHiu7x0JJipBbjQYtpvLMqbe8JzrNcrqkq7c6m2TnV7VVdcXRyyKJesVqtOFitFQaRNW18udlolsKaw3zpS68x5KhBleBpmmqcVyhGqOpozawpc4eWQKbxxp1zRK40p3ARPdE+Hwbom3yXf4N/HXjwuXz/fKSURudIYUKzwJSoU6VFTVE7c0WDkIBB6wDDdw4xa1vpuqbb7kYWleJEd0NP1w3sup7H5xd473nw6CGv3LrN4cEhJ8endMPA5mKjsDjRLGmBk5Sh+ku7VJIjse/p2i1kwftqxHIqrtMiu2N3LM1kOOcI3lNVNZXzVrBdEZzXTAIeguP0xhnrwwPqULFaHnB6rMWrVajo+oGf/OQnpAy7ruPu/Xu88soruKpAvKzYMCvzkApnHvdeqc4fkb0lIk2eOWzTe8FqK/Cj7fQyte+LyO0nMlBzUixmStD2PXXBmRi+IqOeklbyVWiq0XC5qUyObvs6BHIWjS6NOL3Mrt3x81/+nLpuWCwWisOqa9ZOD96LTaCuF6rMtA5e701vRNNWGXZtbxV+NZvNlvXBgrryhFGXGN/f3mmg9+dMYYpzVHU1eml6yAtd1zIM/cyjcobx0Ghs30fzuLQKsPENvj4meOHg4IAw3cReNF1T08mMjintAUZZNGtb6d2UHnhKuPJ1/5D9f++F8Z8Twr8S7p/bwmOawznq1ReD7HzfWJpGzKoQizCKETSrd+9wIYA4MkkxfFPAyjSEdiBbVIHUiTkoRREnNtsNd+/d48N7D1itVqzMu1+u14R6QbNYslgu2e26MRNRDEOHTPBMBsXOpUS721FVgbpZWxqJMZUE+ndt9VhkVpRD2PbgcrGwLmSW+fAqzweHB9wYepqw4OT4GO+C9bgOpJS52O4YUsQFz3K5pF7WeKfdgZq6oq5rCoehiO7nlOJoLCtYfyoyG/dIidyazEqhJ6IELOSly+6OM37Mv8ob11zl8xp7VDDjPRdIRIkYquQN5dCfUXwBOJ+JSekAY86sm4ZusyHHOBoSmUzX92zblpxb2q7n8fkTHj56wuH6gMP1Aev1IQnouwEn3Zg6LdH2sje0yNVaSpIZ+p62bVku1oqDFathKIEII3Z34uygnw775WJJUwXlWc2WLRBPs1zw+uuvc3JyymKx5HB9yNHhEYumQbLwwZ0P2bYt3TCwbVsuLi5YrJbWhUv1vfOFx7XUMxRO1QHnwhgZVRFKmlUp6yICyYx75xVqYdb3mD2YrVdZzb1/f4qy27Piw/wdfu354vQ5DnVAc4441IkoRUy5BKUoEBTFIffRnO1KHRWcul/ZJSQwNjvJZmwpn/rAMJzT7XpWyxXr9ZqDwyMKtZNGQpW2UmuTSiTV8gFWfB2CZ9FUmnXwAS+aA3ailHkFS6tYf0/l3Kg3q+BY1A1VCFTWca2uNaXvYyb4oC2xQ0VTL6nqSpOeHrxUNE1DEmEQey4N800OHXrfeXx4s5NL8x77b6GLg3n71FlxYtJgiDdO2n1KFmaC9vnK7SeimZLZTSgNhHE25oQnM2GirAIyYZ7vlKIqHJUueCQLQ+g1jGUHfYw95xfnxPiE5WLFYrlQcvuFHviICoRz1pvWkjJFNxQuwZgzpEiIiXa7pVnW42FdFrukm0qxiROjtBIlG3bO01SNcruZMnJGRLxcLjk7O6UJC1bLJcEXDriax4/PLWqqFcrrgzW+VsNhtWxYr5dmiBoEYkzNqWAJVgA1oqxmww6huVr8tMZT+L8X/+BYif15j9Hwm+H5SiFQAdtL1qIjfDaiZpWflBIxJSv6KJbThApOKRNCoA9OO3SUuktJDEPPZrulbQe22x2XiwXrtUZ5qtCwWK60u5MozY7ulcLjNzfWNJLkJON8YNd1ZA71d+Mes4p+cXb4hzHS5L3iuKtQU1fqyTspVDCO9cGaWxkODw9Z1EtOT05p6truzfHgwUMOhsjl5pKUM0fHh4Q62H6wiILXSOuY6syZlKMd9kVuLX6SZykmKYwIGfHmWH1K0f9PKrsDiYd8MfDTV8fYFYakafdxrizKmiEO8YqBqg6jZnfQQzpDqCrtbhYHrZsWTb0Wnl+NaHW4Trlv223HbtNxeHRI3TQjxQ52aGpx4bSuisUTY1pBK7dRfLY6UUaiXvgmi4HqPMEXB0m7CDZ1TWXttOdwruCFKlQcHR0RQs16tWa9WtHUCwTHk4tL6uWSbduSRLi4vNDe7Qb7VqMkmzO4FxqAonNtXidx0tT9iJtWlnZzcj8dDfxJZXfLAT/iz/HXPoV7+CxGMZgweFPpkqcBKatBQQ0/nOpUSuofrR0QJ+oQyIQrhYmloWCbY0zEuNXIatvTdgNVaBhihDFvPUUT53I7sqzgrNGAtckmI8SRpGF0ciyq6b3T4qrgqUIgVF4ZjszZctZJyokQgn598FpELt6NkfuUhdDUyinU96pXDfNKCVKJnve5eKhljudp9vKn25eneQSanBlipK4LD+0nl+DPUm4/cScpI2UyA7RQGxR+OjGBUuLwNCsoKSnXMSLovBZPxMDQ95g4k3Kk71sePtoQwgWL5YLDgwPOzoRFWNA0SyXzzcwwJlP43omMi1ay7m0/GP+lmw5/0UpoVZrmwYsQnLMolMcVZem9dahQ42exXHLj5hkHB2sW9YrjoyOWi6VFfCve++X7tDFycXmJeMft27dJRBX+oFHVQgSjLSExIt0484jUkCoH/BgZzJbmyyWJMkvR2jrN25E+rUJl74+PXvSrMjD9fc+0cFcM6c9pTF2jFN804qZB56xsVDNQS7o/l57QJrOK09RDtLgLMSWc1zTk4EoVqlZNxpS0Crrv6fqBy+2O84tLlgvFVN84u6UGacozA1XTn4UkGkvU+KBcgmTouw0FJ10wp6UaU2bV/t7kNjiPrwKLpqHyQZ0tKV2BAkdHRxwcHEKGpllyfHBkkdaanGDbdqyqingv0bYdVV1T1d4+r/OWXUGWl5kRw56p3NpuV1mWwk/MZMymNBJy74388mV34JKHfA/4YlBNXR0pzY3TMrOGoYeRvaTAeLGIlLiAK3jAjME+vOFLVWZHHD/GH1ramg4d7W7g4nzL+cUlR8cnug+sFo6xqxWjzhesfaQ5RE2zsKhTsMhp4YxUWS8/3nsqP0VRQwjqWAV1irxzFjVTPa0BBkux1oFE1kCAwVOqpmHIWZkL0sTxO9Hi5FmgczL4FWpSRGYfw4cFWWIJpORETrYPZwZCLovCy5HdDSt+4L7zghf8PMYU0ReRsfWnpuqhFPeogehVN5dOfSh3tfOOODC+b4yRZW1KkQFn7Ao5ZdpuoO8v2e5aVssD5Qcu4TEpXRqnQmulZhMYu01aBjgEre8oxPoyYZfFjFTt86Ltn+vK5NUrLlwzAlY9732xcMcgF2JxzZwYIvjKTDLvJmo3JnmcxzWLYS9jIGaWVmFmgBfnys6zoj2GrkcOij02OWXza0zj85HbT2SgFu95bqSOG9apV+7EkWNk6JVYXjGa84kLSnqbtYq+aZYM7ZYsCXGZLIm+78kZuiEyXGzZbnY8fPiYJiy4fesV1uu14Vb82DpNK/zzCLJ34gle8HVFs1hSSPD1oE/j4hdKl6ryePSAd9a2rbaQvRePF1WeIsKNG2ecnSlVSbPQQ76uarzzWtHeDXQx0g3aVcsFZ1FZ9B6l+OxJ6dNFn1tTSoUVrkRUzTCYefJ93yumsaxBSnuC+9GjqOfpvbK3BebveoErjhvi8x9jCqgorxKBEW2KkKNGqNPobuqzS86kaNjSMXiaFdyfy4KpQnVePfu+68dr5KzR1zKTMSk1SN/1nD/Z8uD+E42mVrXeC4APJoN5TD05QVNOTmgWC5YLlV8fBJcGix1g6XzFRzunmE8fFBdVV4GmrpTuzatHX+alUKQU5UwQ+jSQB9sRwSPBK2OBFEMUMzbtWUd5nKISOceRe6+Y2tNni2EaSUNP2/YgjqpuJqdqL2r1vPHpyu59dvy/3Lv8j17kq1/WkCk6kVIiSSRZ5YKziSo+60QFOlqoFt3xFlXSIlMxvVbWy/vCN22Fpmm21ogS2aSe7vETLi53NIsFPuhBO2XDilEq5nSVlRfEBbwTqqqi8oLkaOCuycnyTghefRgflOmhaRqchxCqsfAkBMWNeld4svV7ysGfsjp+XRxYrlZIipiyHQMRxTgd7x0o/MajoZknQ6DMo9hrIjD0A955umFgGDpW64Nxva4Cra7XxJ+u7O5wvMMXBFr1rGFBAV/gELlU79tc2Nw676i9Z7vrIJptUC+oQo1GMc2KkjKH2bIDYnhKK/S0SnWH0A4R54vxlkc86hTsUb09WNMSIeNFq2KlQiP/RueogY79QnHnnZ4PXvHgIYgFoczAtaCN1rOIZhycsbnYs2eUp/dys6FaLMfPaHQzjWdTcUtHx2cuHFl/Xz47ZwMpcKoUo2U4HF27Y3TKEKay2GdJ3MuX209ooOrXl4MkxXlveCP5dqXCWMCig9PnBMTjCpBaRIuGyGTP2Pas7wfjkdQOEClDHwc62bLd/Zy60pS/96XVn1I9ZCC7NEbMtGrUsVqtWa8WLBcNVeXJQw+iRM8KhFYDz5mABe+oqopF01BXlR3y6sk7S6lOBpkjiXZuSdF49yotxEmiuEURJc9VGRCbs2LMWAVuiiO1ibM+JeLKJoYUB3JSA6zbtSxWCwJKQzER009UGC91zFLqX4RR5qM4IKOLmCM5aboxSSIn0YpHS02KhVamtIl5u2nqcZ5z4er11pLXXANrb5vAWvlZbaWlAdNuy5AyVejwlm4tEZc9nBEyTqcTB9ZUoLKqTYfgXDJlWTgxZVKcXqhqLYppmpqmUYhKUV7ehxm9yZTqSkZBFFEZK1G14KfmFKMRdEXACjn8iJHCMNPldSCmSN91rFYH2vY09mCpa1KPGEvFyx6XfIk/4H/x0r/3RUY5YKYcVKE1MjNwZtGnNPU1J8cZrk/9qhACdd3QdZsxOgMW7zZDLWZGbHsEsH8nF+jTRHcnVqhXvr4c9CLaHrgn43KkcgtrbW0GLGpQOw9znlHnnOHAjaGAiPeihSd1Pcq3RuBslxTD0+4/WoTz4uIJ0TxMH4K2iS0YPDNCNHVbbl7v/foCGvuMA8mKofbewaD0hhhUgjyYkRDmbttnPiJ3OM//F+Dffgnf9jFHZmxkM01GsrnWs2/QcDwuZeUot7MsZWX8iCnjQ2Do3ZhaiSnS950FDpV5JZWz1fQwTukjwdP3SlDvgscZP7WD2b4Sco4MqTSyiEa3q0wrOlTW5pHX0ta1QKokeOMbHT9C4d/2I3O+M8SemsNJ1DTsGHj05DFhu9XOfvPNNZ/Q8YwXs9PL3i0wK5N7mfh6y/E3Qi+zOnJ7wQNGu/+ljBeR2xc2UOckuZKS0TAVWiUj25Zs3WEYF9BpWxBbsHL66mYvfbtTSlRVGD16UQYgw/LKGLkGneiYEy57hpjYdR1VQLlqTVFpBKpw9WHeW1HmjlIsgqXsfelyMks5iUMP+cpR1YGqrpRrrQqjIaOKcopAlIWOWVuwdkNvh36eDA07YKbog90gMobpRWbG0RX5jAp6xDlH1+0YC6jGt08GwXjpsoaza+1d9qpQPt+BmjykK05cef4vwiiV0GXDRmsXqhG9CWSuaVMz2kxmC9deIZvRtJQexjE5hr4onUCoKlWc2BmFuWkZUsTof7Kl9FVBpSzKZtEPuKRUYwoXmlav0FKliFb8Ey26aB54Ll68pYFMJku0yQePGE46BE8ImvIfjdhCuL5nuKuqHlJiu90gzjFEI9URjfRPa62/K3Esu+mn1n9S5nnMQpWOXuMajR/PFhks+2G6zmctu6dc8tfzd4FvPeMCL3dMFbiMFfPZFf0wPbQun4z62T48xge9VRiLqAPcdcOIj1MMqervOBZNqRGZkoxqRfeEXTqJpVSVJjAEiwLJ9L0uFScmMaRBZUj0YBajwlEZnOgCq6oy7L5yZ7vK4/K0SHtGrEVrSwS58GpjgY1t29JvBsR5YhzGYtSiK8UyVQpHG2ueR9Et5wco5/RcrAtzgTpuaUyZStnjMgnaaNp+xrJ7SMVfltvP+PDLHUW3gOrRLEXjFvSXsYub0ZpFjU4NSmk0tA4NznmYsQEEH+hNz+WMtj+ddbEbj0/9pnF9Ykz4Ruh7/T6XIjk7at9MfLuj012MPH3vHj5Vc5wUaqm5kTryFHsNDLjgcV47VQ6x16yYQwNNgkZEZTIcS1AYlFu97QeFRo5OUTFKbf8zmlH2tDJFVUWY2ySg81KgD6PUmHE98cVCCTBi1/4iyO1zDdTJKp8MVD1civqTvWBKCVU72+DOwPOF2nM+nMjIx6fhZzczBCbgtGTG/rRTCt+Rsvq/KStthSCInwnObCJyViysL310S+TBqkrVOC0HvpigubEQKphXVNJNY8je7pWi0ESXOGf1rHdtS9U0o2iV9MTks9m9FAF9Ckuyb5iXdSgG6jAMJgDmHLAvK0958HPBEq6+On9h70Ny7e+vvms6zL4IY8+jLI7VqA0muS1GGaDy4AoXaLbrzNdgivYMQ2RRafeStsjB7Ht1HTUdoEtWlIuMcovhXL1RPWgLVMf4xVbhyhx/KAY1wGAAVxSl98HkNYwyrBFVP8qr4gXnn0Xlx1L5Ssi/A+dHGUNkqiidKcvy2ijZmfGa8/marczMWbMryNSkYlRmTy3o7O+fgewekfjLfDHa9MK+/E5FUpmxCcOsSKLwTGrjDjUBUhbF5JUiDRfJKdP3g3b3c/NUazLse7bfzTuoMe6VcU+kzJCiYde8QkzyJP+ppMmtq1g2JTfXZePhvye7BfOvBVWuoPPnEThhpNwZu0SSx2p8EnRDz65tEYNajSlPZpjSrJ8paft98ZqizhNpz0z/2pw4mbFwqDLZd9Znn5tdnE9bdhMDbb7/3Pe9jFHWUYozb1yzzox279RIUrsgj3IBFuGPkDzG/hM0u5KzRaynqLlmAyaHYh6gsRsBpmCBs4hsNGaARMLXtRrMxbDNea9NeQKFDVpQQyjR/sImMeFLS3BAqf+M29yp45eIzBippp/ZnBX50+yHMnL0xp09GU97O/Lpw70U9O7Js+y9fU47JTAaqJMed+Nc5mst1Jcvty9koJYDW6lMBgrflthhWQSheM3Fi3JW/KE9xN2YYNFFVkMgJou6WiW+9p2fgurODFQoia2MRytTE1pp3w2DRpRQjOiIjiqfy1p0lfKg1BagkVTiKHSlMrBEofTH44PTH4tKzTElIhM/mXfODg1VfAltM7m29mLT7UxCltFosxM3RpL2KnCvhPhLAQ3k0WvSN9v8u5E2eu8wGN921fO55j1l3a997YoHdN2F8hekSGoyMPNISv7Ug6KHbS57USb8TvFQlVtUFYfMXu/anlWz1Kp3N0VoygGt+sMprdpkSew5a+rwDYSQyGLVyvs3R2kdKjla6lamvSdF37nxsHTOW2RXZZhRmbrx3s3RpvQlGPHQ4z7TjlFDzPRDj3dupquMSk5MeQqMDBNSDKp5XHVGiWLDWXVpiYbps+57ZJm9f37msruk4Vd58xmvvvxR5HbPQB0PYo0ATh0e0ngYFhMsYYpTrNjDafedYYgsFpVBQiyNH5O1My0OpuzNY4lupZRwQdP+w6CtpZNU1KWwz+4TDC9XuBVlpssylMSjbjm35zg5o+zRBFdQPt4cGfKgBqm2Vt8TiFLpXD4/xKjwsNyrNrTIXWGVsKcyG3/cUVN8wA5jnQ93xcIcF0gLu+papzlnXC5O+v5bP2vZveCcf57/2TNefXljvn4iGvUnWzFvUhuAnKkqc54FC0wBWYtPfcyjo4Kd1Smn0dE2WxLy0+dMmT1nilGMfm+EDETVV4NANSR8mIxDStR/tGOwYrwiq6KQFAu6FaYJ70vGSoNZIkpFpVAAw9UWuS2OmjlVc0eePO2d4jDqfej8uZIdztY5bWaUJytUTylpBsrmbIKv5FGgSkQ6gxVHlsedIq/jej5zna/M+2coty9koE7Euwa2R5VCwSnpBJjHH619pBeL2vg9k6wsblVVbHc7pHSOMnyctyr6JJZ+cuAMBK1Sp/1nY+oJeFNIA2nISByo6oBb1GQR66pjXnwcIEdLYV1xuUYDdRI8xZYEfF2Bm1Jl00IY7tBh6SaLPjFhTp88eUIWYRgGay9mwl8MhCvzrVxuefTOpjSAfbYoTJv/qi6YQv0Z017PEYrPfHxBIqgwbcYYI8Mw7NFMFYMrDoM6NqVaUmQ8UUqEiay4u7qpWFYL2u2WYRioqkDwjWKOMLIpS/shmuZJBZ5mqxKNZLngCoeU6DeRZik0bt9AjTmRU0RyZoAxM6FKsyi3UgAWjHZNxqpn5xTbXDB64zM5kFA+b2kk9J61Cls5YGPf0vWtpUitc9Zobtv1Mgbv0c2qUd5JJp0TckShDSnpYY4HYTyIxGlluCsN3Hn58pt4j/P0fwL+qy/5m68fE/TBDNQSpTNnO5iYlsCG6oiESLAD37DSSajrGnKmTYm+61mcHHC5scKisRZzfkCb45ELJMkOISe4yludoAKt07aDDKGeCq7KSDmTosqDRptEu5WRrEahOFTVeNA7P0X3lZ4xgyhfcTDCcqRUfRe9nccGLClnYuo1SGBR4RCcQnzGAoA8c0DL/E2YxPKLMaBiYbZyDpe9ax8F8t4h/bLHV3iF/638Dz6375+PYBX3OVtQICvLR7RWpeP+Fs1gZie45IiDZpMGGRj6RFOvac3uGIbIerlie3luLCwKBXAuWEFqOVetMNWcjkKrV1XVnoGWB23JHarKIIW6ds70arb1Vm5sK75OBaYw2QLOaeV+CGG0hUbYkhct1Co/JWMAFKosyGPQEqfGfTcMI7ygMBGNxxB5bAWRZ9JJdsQ07DlSyQp155pURNSm8c4irZMm39O3L0n5vojcvniRVL5iKSN7D+jU1WGI2kJxfH124CervnAu0yyWhM2GGJXovjYQfIlWFUqEUXvkmYdkJGTOO3womBSjUkGND++dEvxqPkCFetYz3fsASav1fDnUfcBZ+muq0vOKlx2r6e0uHGQ3pSt0UvIoWL7S6ufNdsOQBqrgSajB4Xy5jHrdZK0sTGPBlEY9wOARUSxlgG14/V8IweZmggy4mQu/77nPtPH83/P3XGtcyjXv2w8qjJG8nJGSEv7CDNvaVw8Q+2ff9wyDM+96JrPenrvXNp+p6whVTbMIuBBMNj3eZ8NLgct+xE6DGX04qy7V640FcN7h8KSuJUumazvFYtcB8R4vtt+yKikH2rs5eIjW4cbwp8WpGv8+i/qHoFGobNF93ARNmQfolavSnj/CkHsQb86pdkqTMRqVi59F8fXKgR+HSKhLBFT2IgagdG5VXZFzNqe0YFEtumbyO+qU+WJ9hrL7Ey75n7vf5/euucoXZcSYSDGSc0/l0+hQTThi8MFrGnNIpJjZbjccHZ1QVZmu6zUiHmqq0FizkmRrH5gaKOtIMkV5YDrs51mAnBXuolHWClyecMljQUsaI2vkZDy9MnJMl/Tt2Cv8ylrOMxdjGnnvFHWj5owpcX55QYyMfKwiszR8Seuj51JKGclmLFkUawrKTFjBMcwHU/e0fI0cPvXvz152f8QR/1P5K/zRNVd52aNQlg1DOY/Lf2cRepnZDjkTQkXMyoSScmaz2XB4eEyMLTH1dH3P2clar+2M7qFIWdYzHzEsZpnKUY87VssD2rZl5zVAEHMCpyGFqIJLTtGytygbTkoa5BK3xztd5FONU7MTfIFQFee6BBL2swMlsDA3HJPRV2GBrMvLi3FPaOA54Vw2WcxTwxhVsGqKWzfDbPM5DHHKCl6zPlcjpdeNp03Xz0duP2EVf0FRmsfgLJsUE1wxUEaj0judyKwck6DeVrIwPgh1Vc+UrVXsCSpAopFWRB1+Lxhdg/1ksdR6HjdH8XzJmhLPdvgVQn7crLOJmw754iV5EzpnvDljENeipmN/X7HvKnyW9u3aLlJb5mWsNSB5jHxMQpDtPlFjM2kFY7pqVMGecq6raowQi/eGTZw7QJ/Mq38KN/jUZa4o3aL4KVQYn/8ouNOCoQZGbBy2eQt3pHYay9N7KArF4b0Qh15b91qlSF3XtNutpp6cU+cKN15DIzkw4YFm82nk5Mrtpy1Hs7eITc4MloHIUjBRSdNjUuTNFKRogdQkpwWoPz/oZ6lV0wpuHsEYnUcTaqTofM6fPGG5OhwN+5Q0zTSPHIk+ojpwOVuXOMZsSym6KXOCRX1LVl8PM41wO6PamsbLld1Tjvnr+a99ou98KSNP+OCcMkkK56kd+HMDTso8aMDAOaz4KNB3W5UDr9XMgiPnSVbGzj4yMxRnf9b1guArYkrquI3YUCsGjQpFKJEuxiKiidqn7K0pEDDD/btJfnPW+ysO+SjT5ZnHNZwO/Zyh3e3IWfdYMSTFAiiT4t3H7JcOh3rLeWxAY3YAsz/G7VQ4sa9ZrE+0xJ9cdh/w1/PfB/47n+h7P81R5ns09JNCQUoEVVklJiOFmHGVnse5UEelyKKp2e2CQjVSHFlHnGVmyAXHnkYjVb960k8lMOGC4/D4iEUcRp7qtt+NjnAsNQro5yVnfHGYxFoAmb6dw6WKrHo/1dvoHLjRxhjlfq+c1JSszOU203Udu+0OHwJ1VY+rrcV39ndBz9grslLgD4Xee2zYMXubhWpGnX+dofpJakg+S7n9ZK1OR5uqAPkNP1E8jzwms8ehHkU04Y0MfU9VNwyD9rNPMVPVNVN6cAqDTyEaRqHKUrxpz6JpaAct4ig8kjA3SPIofFNUZ37Qz5XlXPgmXNQUCbJDfuYFTv/V3+ekXRq6TgnOyzyknPAlfYzMIpxTIRrjxo5jNHnczcWWsO8NPjAMWvQQ/HS98bIzudmPOMxe/DjyOL9euR+ukccvwBhlM9mhPlOaoMZUGoYRuzNvvzlNjR6cEmNRI4gITdOw226JKRG8M8fKWaVzOU5N/grufD5Xwohz7obWcHZGHVRkN43WnmYAvB+dImbefAHqjxGpmbKcoADT6pcK2/KjKS27KSlYvMzl5SXO1zovIY8PkE2/zXWSvjQ5AgVakaJlQa4RPRF18lKMpK6nWS2eXsPZOjx1gdkfLzQ+QnYPqfmXePVjXPDlj7wnxxP1DcbFWMImInZguQwoSX0I2mu83WlnMO+VH1oL+WDCDV9zsM0OxFAFXFODF2KKtH1HND7rjNAPwzSpRfeKjLCWojeLsXlV54562c3ltBimE3q1YEZh5vzYTSt/tgUEcqapKrufKxNqn9sLNWXG80gN1Lmwm9ljdQbitLb7qfP5JevdA3b8+fyzj3HBz24UONrcQB2GwaJ6ebauOnIq2aBiLGnRXRUCi0VDzr1mHXFUodZI/8jsI9fML2MAYrRBHNSLhkoai/gP5EuVy5gTqdW9VOTF5YyEmR7NRZ/uM/1MAYEiz5OcTMGESW6v3quaM1aQl1Ru+05bswsTg0RZ8wJNHIN4Ml1JqQjR/Y+ziv1xUabzsMC9ZApWPGMhr/5i748XGp+C3H5iov6CCU0Grk8W6fFMdCeZYsCCZF1EJeePbLaXHB+f0rVbYkx0fU9dN5CFnEwJicMRGfJs08+VpxNCFThdrNh1W7qh14NeZtXbdl+6JnmiKIHJE58pyb2D3oDZk/duOFXnZwZqkZ5pNWKMbDdbHj98xMmNUxNEGSECxQjYdyjyZNhn6PuBENTz3BcKS+eLYoDb7Y6FC/hmtunH0MBHSZMZHbP3XUu8+5RsXiesk4H+RRh7+OlZNLWsGDkTh36U0WKklu5cljPEB09VNaSclK7JCX655Mnjx8RhAF/R1A0iwfaEecwjLU9RCjLdlxm5hwcHhFpxR13fWSGXtudNpdVfibqbQhHnIKkDt8+WUVL9bqSaKvjkUXZN5JzI3jxNnj/j4dLuWry/JPhAU9WTSZuEgrfWw0hMKepQiqI8dtxRFoBx85p8q5IUtAd86gaW66Nr1PdzV9j+++nI7o6H/Cz/x8D//iO+9/MZBYOusqwFT4W/1jvlbCZDihHxgcqoy5SDVw3LJUsunjyGmKh9TV2pg5PirCJ6/p1jWlz1V0JluWpqqmYBLnFxeUkfewqHaHfejtEb3Q0TO4pGRd0Y4R0j/U5wY8p/7vgXuZwcqv2f6aZHWxONfvadQsdYZNbL1WTQSIFIsRfFciJkcYqRzZruL0fHU983s1evjzi9XNndcpM/8v/6R3znSxwZCgY17xmo4JzxHGcgKWe4y4kqBHLWaqK6qnFOODw4gBzZbS4RHOvlIZVvRgNsnPtii8w9kFmELDEYxj2MNJHBVyyWizFYljDHyqLsAmMBtBNBkjbY8YBH27U6L9q0wsZcFvbS+rMAwRy/PLchCtVb+SFnmrpWe0hKSfS8/Jlx/4MgzppvYN24sjUtsMityFQ4VU6j66P/H7GwvFy5/WQR1JK+K23fvNPIX0rkIZKjkswGa7lYkPjeBRA/KrCmqamrmjQMdF3H0WqNoG9PSQzbF0fru5QNkCEVYLNzNMuaZlnTdR3d0DPknqqquLi4oG/jVGBgAlQ6KUiSWUp08oQU+OxnXpEbhawYm3ofeX/uRamvsiGfL63F6aJZsGoaPAI5k4esgH3BeOJmC5kdMapFrqwJcV8o7b9JIslpu8I5sH+Uvv//mBTBTG6GYWCwBhCaVunpO6cHO3aYClZBqgTRTagUF2q0HCfHx7TbrbXGDawWK3M6SurSKdwFYFQSs/sikkSrklfrIxax5/zynExmuVpwsdlwcX5u1ftYlCaPcooXQpFhRaoQgljLPX/lu0pqTYn7fSjQmakApkToS7/2OGSGPtG2LdENNAZhcPPOayUUzKTsLBEL2SGmyss1FQdo2RW7SJoZKoByzBic5mWL8JYL/jD/85f8rR9vxDQQY88Qe/rUafHloiH4StPuMeJcxIWA+KCdw6pATongHMuDA3abA0SE9eqApgp4qSBPuGRyYUCZKZLsDEIViXmg7VtihOWqUYiL1Np1LwQuLy607W/xtLHSUUEN0ewITggCQRjx/yOez01BAWCk9ZuwttMoh30261SjpkK7UzxjqUvo+54kapyO8bvxUrYXLIKcZWq1GoJipWNMeC8jzeIYXPiCpI42JH5I/3nfxlNjTpWm+OUamAJQADlFUoyEqgavxPopa5fE5apivVrhih5uFqOMlvahir3cj8qaK2KRVnO424Fh2ADQNA1piFprlwWHYVotE1SilJK0kt8hiMTiy0y2gukvDQYESraqOP16llj8NLNXIAYYLKfQZaqd4X1QTmIz7G0i9x5vP3Og/x4SpOzwOEQU9hUNXlH2TjS7rNhCH99A/XTHi8jtcw3UuUIoxqE+6ECKg0Z7orY2JA6k2GvfWkqxkHUqMcPVV8pxlxFCVRO84/DggL5ryUNi2SygWPkz6oSpdg3GQ9E4VyKRbbuzVKIaaY7AslmxudgB0ZSuinEJfWurU493imf1Yi33ikK85ogUKa3MnPGpFetUxp9Cx9W2yqk49AMpDNb7XQ2YqRJaLPiqQuzE413G0eFdhXcVGKWWQ0blOAeYq/LOkAuJ3Lj1bcNd57386cdcN+9dujB6f6HGpBiKUsMKJ5R+THHCUwEGY/TVo3OcwCKCHSLCwXoJ1uNbxFN5rxbX6LnPD/jpr+UehpjY9S2XF1vqOhCjUqkEVym9yaxesxin5GzKciJtU7ErFaXBHClNKxXvOeepIjWEoF3ORnlN4z0WwvNMZrU6IJNsD5aCBxlxYoyOlTlluVQ9Fy5EPRyKzO6lpxmDHnr/OUMakBwZc3OzdXsZsltxyivhv/npftGnOKKlSAvdE14hPs5XiOtHxyGlqBXHXg+lYcgIHU3TEMKS05OTWYpdFN/s3AjLGJGZe46u/qMcbtH02263IedMFfRwzlLWT7GBY7wlZTweX9KZWJSqGKSld3kpSh2JTmeRKDvk3WwficjYVjhhcoRwdHTE5eXGInbOnK/pQJ9GgQkYA4dtBec8TnmB2HWa2SuHuToB08E+GmDjFaf7GH/xKY7rZRdeSfGad7/c4dBztHSP86J0kc55Y+fxYGx/et6ZQReBaoKYxBjpuh3LZaCuAjQ1sR+oQ6U1bknbVJOjVlIqlx88ZScYTM/rmdv1PW3Xsm13Wv9SpN2CAKYEzWbJDN1ArvQ7CgTGj9R8+gy+ZLHGKD9TxjirJvYWZ3Raoao0fl3HkwePOTg8pGmWOHFUdc1isaDretPrhZlDMxclKFcyAJMtUOpbZvtahN2uVR3R6P6KMSqjAfao2YqvchwzB+QwOV+foux+Url9roE6bsQSgMpzEtg82WWlK4SlsCsLoxfipWxYJGeHKWYEkGGxXFB5R9e2E+9Y4Z67Lu+0F03U/8WcuNxcjt2d9lqNlc9kEyxmRUoGgHblOdyELx3dJcN0Fa9ZTKEmpirjFBNt27FYHujrWXBJDxDyDLCMzslVRWnQMX32K9is0fOxyvGrUcFiTOdUuNLmkcMr4ykpmSJg181v+dB177ru0oW78Ys6mqYU4U33qB3RJoLpKWqu8pftdV1H9UjJmbquGbpW5SoDaYrwlLnA/lXSs7ZZbA8l4hDZ7jb0g0YDaqkZMZ5QaHUZL2oIeMnmfZd7t4jjnIaqqLGcitE5RXc136WHcz9E7j94wOnpDULtx/1ZVRXDMJByiYYVA3by5id8lJiRCjHnqcOapYX7vqdpmr1oysQrq9RWCo1Ks++6InGfsexesuD76Vee+76XOUT2J0B5HOOITR5Jwq2YVFWvYiclJiTooZqSFo3GQTMEdeVJMZFcglQKkYquLQbqXOhkb+6L7h/iQNu2dkYsFA6VLIZeaAFNZyqmUzv4FAerHPJyVXZn/xv1trlb436wAqrdbsc7P/0pIdTcvv0q64NDRISqbvC7jpyzwQasmGY8Ma5Khn6X2qrmuImlQkV5VfUaeeyCVqBruo8HfCjcr3mctiuTxvSFn7LeZUfk7ee+72UMMaOzrFXpNV/OTHHq4DqxbmBSnCrVM2XNU4r0Q0/f9wgRIdN3rbGnREvvu31Zfc40jZRtdo7vdjtWy7UyOFCYKkznlywrjr7rGZoeF9xkI4jM4lEmqWpMUKB7KU3BvHKOFwOy63sePX7Md3/v97i83PDW17/Jl770BifHZ+QMVd0YH7XSo6WcrKbJziOb5yJHpQh1VMbjj6NuFtYNUPW9du+yOROz16yydWpSkNRQfQ5R/8uU2xcyUCcsaZ4OJfOSlALUqo1JOFEajrFr0mwSMAMXsXTJMLBaLcle+xuTGXuh6zzOdvbV55XpR5xj27Y4cdR1xcIvJt41mw0xb2q8j2zGshURTIUlBTw8qsUplK4vGg5Qr7Hb7Tg/P+fxw8d8+ctfpVmuCaKh9rqqNf/KVNg1kvkzxWh1fmd6zAxVjTYrHrUoxf0l1mpcTZ8atqUox8wUbviYY49O7BmXeNaVv3AG6mzKmmaxz9VoStS7KYJTDINCDDWBzW2N0nRIJT19tXLZX13R8uXlpyzKdCjHrET9XdcqD2RQXj+NttthnIvXjLU+jUYGpNcT0WV2oh69uOLkmLFc5KoUVzlH6Tq23e24f/8+P/rRj/jmN7/F2a3b1PUSESFUlTpTsWBNJ4PdvLu9J4Wpw4uIn2TYebq+J1TVmLry3o9y4n2BA6De/Px0/wTi+0ll94KKf55vfvwv/AxG0bVih8I88l/0pEYa59117Kks8yQx44MoY4rhAYdeuRKHYSAIRJGx14JG/Wbk/+M6lB8bUnylrAVRgA8VVTJ2ltF/EVQisznwOyqXqZwWbImbAhyFf7Ic+uWLsilNjbYZT7Fd9/zinPfee5/f/d1/xnK55s/8OnzpS4G6WoxwA8jjvi5dtkAhAcnubpr06XtHg1WEUFf0QxyhP2NHOrsWZIMHKd+njBuuTMSLC/Enld2Knpvce+Hv+ayG2gMWXBFHFkcSRwjqKKjs5BnWGI0OMpBzr4aRFbfFQfWiI5NjpI0JDNOu+GaZxPR5N1QMTq+sDiFU9H0/Vu6XKG6JOkIpaXK0ux1t5XFNha/8+B41A2bBDLOF9gpcKU0Livyp4fT48WP++E/+hH/4D/8hOQltOxB8zfHxDWLK2iZ1UGfIV4GUrWjLjNSnH9dsi9HQnuAw64M1cRh0nzpG/ZHH/yVrwW1XGg1UebYAXjM+S7n9yBR/qYQuN5FNo6lgJaqgJLvFYAtVwQxNRPMZiEOLq+vxEB8GLcRYr5Z4K+roh4HKa6WdtiW7YuyIKqhsMzHHColzuhC9UFcY1dRc6aginEDIin8qnSxEBC8zUP8sxQResaLOKxjZCc5p+v7tt9/mu9/9Hh+8f4d/89/8b/OVr/wK3gXEOdbrA/o4EColoFay80wSJp5LmR4u52wt1gLiPKGqyQjnlxu8d6ODABoEExGqUBG8N104P0jkyuadDIm9f+9599eJkVzzviu+Q3HovkAR1OK1ji0igaqutM+3c6ODoO1rK12zolRKpNE6ehSC+YzO+3azpar9WIDVti3LujLM0zVzWOwta9bgK494xWJUTU17cUHKEPqBIeqhP0bQDJvkxLHb7lg4IdQBzz4IfzQLzOAu3a00bWl8kyHYc2sL0x/9+Mf8zu/8Dj/84R/xL//L9/grf+Wv8eqrSyQLi+XCMgeBuqnJFsmYDt1y3MsI39ICs0nZO++p6wW7tif4dsQEYp8eYUBi+6tEBmyfTzL32ctupOKx3LrmGi9/FEPeiR7m87ScQ8B76qpRgntX41030o2lpHpEseuJGDPeCX2vHIvBQ+p7GCIuQVqkMZP0zCOpyO9MJ4YQqOuay4sNsbYWkqL7zduBreuoqcV7H96lP1xxfHhAXa9mETC77p5jpYsUzTkqfL5Fpp3AH/3hH/Ef/9Zv8c4773JyckpMikH96le+Rnaqq11IuBDAO2I2zmm5UhA2PnQe0UkFIiPiOTw85MGDB0in8zgGaizY4RDCFdx3cWYRmdHufXay+yUO+PfdX7jmGi93KKdpoAoVVRXIWQMrlQ+Eqh6Lk6vgzWDVFDYYvV6O9oyJFAfa7U6d8RwhJnY5cXp8iIV0rrsDgNFBRhjb5jaLBaFqqKoFQ1RlXrivCxd5sSnMXeb88WNy3xIP1rijFYvlwmyfUsHvkWBZX6cyUxh4Sn2C88FsITXe//iP/pi//x/9fX72y/c5OzvjD77/A5rFml/5la9be/SeISk3u4rAs8/TOQQzpTy1NcbjfMVqueL84pxd22mxtdlx2ndONbZyuKfpp9h5FNP385XbjyySuppqKrcwL26o6gC5h+ipgieEelQqVR3wXiA7hqHT9LeviTHTdQPn5xc4gaHroBOWhjO5DgM6fv+MRsc5T9UsOLt5i/Mn5+oRjFHFGU4PxcR0ux0X5+cEEoeHK5bN1JnHOKpGgStp34xDRA1hBXorQfvv/fD3+Ef/+B/zve/9HmfHN/gH/+C3+Nf+1b/FzVu36aMhTZ3HVxWuCsScCVKipfPDXohlq+ZShYdurOWSo+NjthcbmiZYAFhU8Zoxo/trlmL6GN7P/68OKVH6FEccZPAeJ86aMniWfsl2M1CFSjkTnXHaWas6BfAPyDAQsxVSSGa73TL0jtS1xKGHDEcHa0rl8lP3ojdUbgwRjY5XTcNRqEjZKTUOWkBQDmLQw9g7XdcH9+7RXVQcrhfcuHHKovIjIbSm1D3aR738T/endxXOVRapFLyvuHP3A7733e/y27/929x85VV++MM/5NatV0lZODw64XLbQso4j9FgKRRGFY3uq5HoKBYYjBmmiEEePPWiGYtnPGKFJ1fI2AXGtph7XJUvbyz4BW/xfwD+vZf7xdeMZE5PtW5Yrw84PDzk9ddfZ7u9ZLO9ZLu7YLFY4AvG36IhzaKivWyVlicn7S6ThBgzfT9ATkjqSV1PjgPDwQEnx4cfGYUqBmRVVabTG+rFklWfGOKH0++DN9dFyccdot38YqRtWy5E8W6LRcVi2RBK+0rRKLrKhc1BLrClQCm2C6FSBoOYuHfvHj99911CU+NDxdtvv83x8Slf/epbdO3Atm0RybgqjB2kNLA5M4pnozj/GlzR7eoRfKhYHx2yu9zQblu8OBIWlJHpc8lwkSJJZfgTZq8+yfhDVvw7/Bn+i5f2jc8e3nuapmGxWJLSgABV5TVqLqXTU9L5NTtSW3QOpKzKJsVE3w/0XUeOKqtehCZ4w59qAdN1Y25SqX0geF8jzlPXjmYJvq64PL9kuTrAOw1asdsxN9Cch2Ho2VwOkHpEIut1Q+W8whXEjYVN2H1rfEK0exrGAmFKsgQISvDu0LCnMUYuzi+4/+Ah4Oh6LX6sq2CV+SVQbGc7om2OCxXn7NkFy2gX7GEILFYrUkxsNxv0EiXbOnW9SilbAWwJQuYSQfjTC8RzxovI7Uem+OfVk8V7LK/Vdc3Z6Qnee84fQbvNVDPahYI9raqKbtcpPY6LWiGdNNW0ubxEcmLoBzZDz/HhAZq6zPtK5No5Ez2UEZarA8Ax9D1OHMvlivPzxyO2rfRKTkPPdnOJSwPOZZbNkXo/5Uc8OYlmG1BF6RCLsHnDVulN3L9/n83llqZe4H3g7t37PHnyhIOjY2KK7LqOLFATTF8ZPY8Zo6USWkQJy7OlhgqptIgjVBV10/DowcMxjO9FZkKWkaSKscAXxqbdn1DArqdO+eiRgf6LEUDdi/6XA9g5x3q15OT4iCpUXDx+iBdH8J7g3ZgRGh0gJ8ZYEUcPMA6ZbRzYpAFJcexAkpOlR0enY38oltVZJ6YS/a8IlXB0KlxebAjesVqtaXcbQ4KYd5vQ1G3f0Uti54R217JYrMeUvqbvPVnUocpYOt+iBCorGBG7EGOirmuOj4+1O1DO3LnzATdu3uLw6ERTwnGgEj9lfOatyfL4YKYwlXljnCgz1tVIXXBxcUGKWiFRUe3NS7ZCLOdnOKhCyP4J1v2TjENe5S/yP/5En/20R9/35rAo1nkkA/f6Z+UDtUVVS+FUTtlaLvZEAWa6mpzoupZ2GyH1uJQsg6MtR7NRBV61U8thX9ZBYQdTIZM4WB0ejhGypq7UUUrD+OFS+KbV0hUOR+wHcm4ouq/AFZQFBfugKPWPlNiuVjgPfSSmyGKx5OatW/QxErynbTvatiNbp6Cu73FeqC0lPyv/2h8ymq4GAygZQstGhIq6bhjantgPdMPAkiJnVgMRI34eIMiJ/YKdFxufVHZXtPw6736iz36ao6SyfbDgVFUp/KEE1bJW44tN8B4m3s6+4vwOQ9SwjenYEsQB2Zv760Ymj0WgI484YmrUbAbvlO3CvjamwlGeGRM5ObOoG1aLBU1dWxV8haD6tkQrcdotcE4nZQcJVkoFkhn6iHeBw8MjhpSoqgbEsd3teHD/PuvDE1LKVn2fxiYYBWKJnf/JNPyYt8pa7DrPsGphrCOEmrpZkFPi0cOHNMvVOE8lU5NS1CivOZNiXSxfdHyWcvuRKf75z5je0BfxzrNcrthtL4FMMLqQuarTdFDBmGkKWA80YRh6gwcotk6G4Zkp4hJ4LvgTGa0JFT7nFGOS7HVfK3k6lIM+GxWWHqIi+vvp+SwS5axMr6jmWeTLbF1ADcSui3jnWa/XhBDo+57Ly0t22x05o5ADb8pRpqeYP5PkyWhV/TYdLCVCHKwl5G63o6prarCiNMWCSUqIi7hUeAXyFDa+Zg71CcpzPU8Cpju+KoN7vkNJC6RE17bPv+BLGhO8ZD9islqtWC2XxGEgDoNym4ZSSKEKsNCQuejIg3XqMoUj4uiHlhx7nfecET95o9eN8bcy4ZlF1KvOQFXV+EodKxc0LWRhcUu9ZnJMEBx1VXGwWtFU9QxKU6KokyyPe0NG+9ZqrKxrSdsRfMXJ8QmYQnr8+Ann5+eAELMW13g/VV3nmcduRwWjf190w4j1g7J/qlBxsD7k4vwJbdexWC5nxpM+5+ho5YRkM1T2/VM+S9ld0/DrvPH8C76kEcdiqOkRVTdo5Kmqwojhm+upEplPSaOPBecZgraT7eMwceuaPnciWg/x3DDq7BCaUTJhBpyIQ7zHec3wyGhsmLGWEpXzHB0ccnZ6jA8WIreCPCdT5mqyDkpcWONE2Q77nIW27XHiOT44Ytu1kIWh7+k6TWXGQTsGYYf5qJ+YjO6cM0ksGkep9C/vYLwPZceoWK3XkDPnd+9yfHw0Qt1sdQy+IrgUkey1Krpo45nu/2xk95LvpD94/gVfwhhlxNa/FET6ETKnTlQRjxKAkTirUbFC5bqqEPHEXhgKdjLP51Cmr7o68v7f5/jSOYa+rPboVxQj0GqEUhw4Ojjg5s0zDg9X9EO7Z1yLm+tcuyfHxIYi5b1Kl6mFio5FveBgfUDOwjAkYtez2WxYro9GIzNjjud1j5fzRLhvO7cYqOPD21p477XTYU5sdzsOC4tKnnS21g1EdRAHw7d74y+0ko3PS24/0kCdd0goxulIwWwg4PPzc5Id9pVxRY6PNRKIe0ayGqPNSSmSonaKICV8EZI8E8LZfOfx80xGqr2oQUfzkkfhcaX4Td+bEyRh0dScHB1xuF4rDnUWQS0dTgp/peIGtfrNYBwIxdN3NM2Cw4ND7TwyJDabDdvtlpwzMam2TnmqHh2fIk9FNZIz2RVhMc9pZlh5rwryww/eZ6W5VKX+yWoUJknaRlYGfPHe8/RdthRXxuRtyVPv+WQeUYqJ3cXFJ/rsyxg5ZxaLhioENpeX2s2s0v72fkzJiaX6PcFDF4eyStbnviKm1hx9W1URo2KaHW4qiOWbbc9kPQyLA+GUfzXPlFweo+OmsLMZGlnwGY4PDnjtlVeo64rohj3WBwzPOdFMFQM1G8JISFmjvbtNi5PA8dEpu76l7yK7bUu3Uxqt0ZPPyQjaS2FJKZS8aj3mPZnLZhyLcwQfODs94/L8nN1ux9HRkab1nO0jk3uJg0JXrlzrZcjuioFfzY8+0Wc/7TFvdFIcnxE7j+H89xwdGaFIVVWRB4hJ0foZzXQh4L3QbxM5F+5BGWX0+ebpNIqjVpxjYNa1R5QSz5pcKGOKFnmsFgtu3TjjtVdf4cnFI7MRijNVaKWmIsUiAwUdl6VQQgnbTUtOsF5qf/auG7i43NG32uyia3stLjFZUGOVSabsmVNOuLFieZqFYmsUh7LgbWOMbC4vydlaY7rpXCwwohKekZQ12uaEfUqKT192l5zzq+l3P9FnP81Rzq8Cq4ox2v43/ZqTZlgt6o8Idd3QxUgyeIdzIBJYr1c4B+12y2ZQO+Hp+Xn+fMn8T2MtQaZX4iwYVvRQYfnxCDkO3Dg75Y3XX+PgYMl7H/xSxWLESxfHagZZsr2gcptJYyQ1W0GiFk8frA7o2o5snTTjYAVgY1Gu7NlRe3bDTPcWE/VqcGSkJbQAl2RlL0gljZaLk5pGec4yMPQ9PoGrgsJjpES8Px+5fUEe1P3DSEQLILzz3Lt3R0HiDrwYzm9sESpjj+jleqVAdjNsK1ezWK7ouy1du6Pf7SDqRk9jFMYMYftrmSgk4/xEaeHtoJuwpIm2a63Vot6zF6idI8fI7bMb/PqvfZvVasEv3vupbozRK/J7naWw9NAwHtZ6T7rfMl4Cy3pJ13UMXUvfD9q+FW96TyyMXgRMJ7EY3PszXERbDYJ5K8vbr3+JH//xHxNE4PCAPAxKEGB8cGmAPiZNXfgarDjgmeH3FzyRrrENnvEeYeg7Hn/4/otd+DMez4pm9n1kt+vYbXY0TaPdQXzhvi1KViuTV6HBL9TQ64dM3TQs12vWBwvOHz2m2+6UDxjsrC9OVUntTN1NpICmTJkVkH1MGe+VpzTmRNt1JJOzQh3kBG4cHuJJvHLrFt/6+tfZbM65++iuOmtjml+Mqq2kx2W8j9JBrdBBta1iZ1eLJSF4LuKGg9Wa5UK77vRtNy31zDHfs7vn8w0UiMMUzXWmG4SwaOiHgXazwcsUXRliUqxacgzdzsjcFUeefaXFM/ON8jHGsz4yV/tlfyzZ8U3e+fhf8hmNOe9mwaSmNEF8QhWUv1CC6S6V3YODQ4bo6YZMyjBEWK10jfu+4UlMdIMdnxnVkYVaZnYQXnc/BfaibCjmo9kkl6p+54TUK4RABFzOHK/X3Dg75ez4mMPVgtjXtKmzYj6r6MaPNINQoo4mu/a7IWac0zS/w3G4PuRgtVaoVVKHP7jAbtcaW0TQs8GYNiRMBuXeIW+6IqFYa660rhQRiJHU9wxdp0VgOY+R15QjkiIxDrS7lj5lXAgsDg5olitjFPh4AvxxZHfNht/k+x/r+p/FGPp+7B7X972yRQRr0YwGUwrjiOotT+UajuuKflBO2wQ4qVmvtQI9dr0WN2fjHZ9lBouGM1eIEtZSBn5BnLEClbM8m1Gate2IBpGSMqMISHYIicoJB8slPg3cOjvlYNlAjjS1coTOG0oYUnmKMAI5zWfFjHGDBVShZr1YsWoWXHDJsIssfM3J+oh209J1Pb72ahziVG79bF/KFP0cFXMuTpzJbvD4sl+9I/WZi8tLa06QrUGB7q4h9kb7B6kbOL/cAI5qsWCxWrM8ONJ413XFv9eMT1tuP6JIShdArXlNr6jS0804xIHNbovkTHAZXzm8E1I/4EWrHp1ATJnF4pAhq5JJGepmwWKxUOqOIdEmpZRQPJJQMFR7aQMzAoz8aTQInL1/NPMM35pHTKAaoDdu3mAVHDdPT1g2FWnocdZmzxU6EqB0wikcg5BHAyDnzJDU4A14DhYrGuc5P7/g4d0HLKqGRb3kfLNTUmeLKO+nPp+3mDIaMC4UQLYaMNt2Rz8cTB28pGxIFf7dbsf55QYXAtViSb06YLFYPOOLSkr7RWMnz3mrTX1Oic3l9sWv95KHiLDZbLi4uGDXd3giS6cefU5aOVp5TYnuWhiSYgCVnacbnSAnirHqKPQ+bjQoil3sRLQYAAHxe9GWOYmzCAw941KklOj7vmgQyNpA4q2vfY08tBwerIjDDiGaYzVXlu6pZx7ZH2dR/AxUPrBerDg9OCL2A9vHFxwsl6wXC1zMtG2Lr652R8nPNRZzVidJHModGJxWOwOpH4h9r+waWRVvO+wMZ+WoQsWu7bjcbMlO8KFhcXjEcrl6RsFJ+d3HkN+r9zu7ygcc8n91/wr/wSe+2qc5ChZeSfGVuLyjj50evt4Mtn5g0VTa6rTSwlMf1cmuKqEbrGCnyGlWWNYY+YSnsmQ6Zoc96HeOpONu5Lcsc++9GxlSxopm0SKYxju+9c1vcnK45PhwTRUcVeUZ+gJNsSgqs4CIpYOvRu8HUSaOqq5pqprGVTiB1jcM9cDaN1RZiF3PkHryUrsTCV6NSnnaAC9nTPltStbu2M6Ewtc7xEQ3DJoFzM5w0/0YNawXgRgH+m6g7Qd8XVPXNTlUqp/Dx8ekPm/MZfc+3+T/6f8u/86n+g2fYGS0k+QQycbsk4eEJIVRiAht26JnnNZz9H3EVwsKXD5nzRDEGDWDg7LeRMsmaFap+MIyweLnZoKdi5IzkuPEoUuBBuY9ysnJ6FXHrWlWvPnml6jJrFYL6rpSRg1EA0BP7ZdyD+X6jDIbc2bISaknfcnMBWrvCUNGusjJasXxcsndJ+cK5UJ55BNpgp5N1rh+VTFQy3OX7CvZMLFWfGYY067vcCaDKWmB+uX5hsWypgqKq80padMk56hSRR4Guu0l9Wo1Fmx9CiLyseT2uQZqTmKhcYu8JCEOymunqSejgkoJR8G4lXRHGqM7Kauyydnak2UQ56yftClQmPAhQIn+pLFWuERnigSom+Lc7LNzeytbNFIUU4IXjo+PuHG05vjkUO8rlT7nU9sy4CnhmwfjiiA4F6wHtsdVNbJa88qNmxyuVlQhAIlu6FmuGi1eUVcb58vTYmFz0T/R1L6mo/wIOWDEz8BI4YNW5j5+9JDDwwOapQcSfezYtT0LtyTFnqHdkiqPhIrZt86itlekfkyB7T39lU/tvzbGHjIMOfH4k9sLn+pIaSCPUAmVBXHQ9y1tp5RHWRI5O4Y40A/aT7xU8WtESNvJDhH14IsSSKWKsoyn52aM4MpsvkVjqpNtVaKrJV9gAIBC5ebU069qz40bp/S7SxaLZoyGOmeUUjK6bCNUgAIZoLBDWMGYgLcChtp7KvE0Qbh9eMqrJzc4Xh7Y4ZKsKZCMXL4uT4+dLdJk/9L/F0dstpdKh7d0xdhIQ+LRo0eEKrBarxAiMfW0XTdmMVK3JdYeLzWI3zMtphnfbyaiL45K4Jnrc3WtAmteyb/x3Pe9rDGHaOgZqgEB5eAEvJAiiMtkMQ5J65jXDwr7yGbggmLhjfVQVScFw57G2JMTcFmQJBNT2ohzBUxPzgvlRselBAtytAJDdairquLkaMXJ6THL2hPqgDMeYuetC085zZkbqPqfUo86V+s+eJarJVVdgWRq5zlZH3KwWHP7+BhfcMwlGyaOVHqc7TlXMu3ggvsbI1MlE2f6Pme6vjM+ai1Oiynz5PFjtpsNN2/dxIuyWhRe42WtBUJ9uzOHUItTks3hvjaeWVfjDaZxHp43MhDxbPLyue97GUPXshSmFkNS7YUYoxbHRS2gK5R8Q0zgMzEKZn+qQ9b3TOJg9S8FkSwFm6/XGJ0lUWf36sh2LzPjYDRiAZNZB5IQ8VS1QuqOl+pkFGdp0qsWrBJhpGoyw3fMJE3fToyRUGuqHdF220vvWTUN4dBx8/CIg2bBRb1T39NwoYUSyqNBjeJejQ4d6K7OMspweZ6MBhLFOaKxIpQmLCln4q7j3t27vP6l1ywboPfadS2+bkhZuyYOKZKd0CzXYxBmf3LLJD7zF9eOF5Xb5xuoeWac2d9L+1FtEWmGaop4UaVZ8CcpFeIkHaokdWNHw1wYTGL6rnQlopeZCV95baYgmRmV0y9sy5tAm7L03nF0dMTp2SGL5YJEpB+0HamzA5+ZgVqwUCKlnd4UM0im+X0BgDtP0ywIJ2cc1AsqBEnFkDV8K8Vjm928/VlM9GTK0EnZNHZA2EJoNw6NMKeYePTwEavFEhb2+TTQdi31oialyNB3dO2Oxvgvx68ep/B6IcqzHMVTgZW9903vj/3Arm3p/Ecyl72UoZjQEj9UeUXyaIzGGFUxJmWQSEPpU5zN6TG4yRCJUeU+DhrJKgYheSocfGpurr2reYFfWXcxH0Ts9enTImqALhYL1gcHDEGoG1VyMUXrvlNkdT8KNfdrLIY6uhPOORZ1Q+UCLmUacdxYH3JrfcRh3SBDtEYWpgzFzVJKM8F9Sn7mBSlTtDZZhDpTsJLKc3xxcclquWC9WqqyNQ/ehYo618S+o91taZbeYDz2bHuTK1fvYGb4X7sI10r9Lp/zDv8M+DPXf+gljrE7VC4GaiLnODoYincvUaBISsOoIochKlOK6YiUoe87MpVFPscWFIDpmnFmy6E3l8VppcfggP1WZnKqkCUzYk13hRA4Ojqkbmqcs4r3NCj2swjozJmCSX6LLkeYya5mshbNAu88se8JlWe5WOJ9xdlyTZWgQhgAVzCtZTfuGaj2Ndm0hHUxm1PFje531oLBFCPB0vUpJtpdx3azm25VsC5IHYuk0JW2TUSEarEwR29+K/s3NLehrov2wvWyuyHzg/288ucynKj3Kcmw87r51UAdIilOxPCle1wcErhEjGobZKCXHtdrcdrYE5mZroTpP3n6Q+UPRv3J5ETNORymzOxM9jIgDufBV4Fm0bBcLUGEfhh0j41yOtsH02X0HsbKe7svM7j/v8z9ya9t2ZbmCf1msYq9T3Eru1a82sM9vAplBEplQAapBISULRIaCPooWzSQEA1S/AGIFjSyi+ilEEokEEpEkiJRFEgRkREp94zS3d979p5bbbc45a5WMYtBY8y59j5Wv8qfLdOxe++55+699lpjzTnGN77xfQKLSUwOEdvo+rvuGx73a859S2c9tuQIphZJX7C31EMWYOAYq6dP6CmgkmKizubUa6Aybss7KbgYQ+n6qkxdChHbeLp+/aWpp8btL7Dmlhf6JnH7tdnE6YYDuomoeLmipCGVAScgWSHNQS9Iijr8VOSi5qAJqgKumYEBy0o3wBMHic8moQ8/XhkeyAZwy8ZeL7I1mjBCUYAsEkPWqDPO+fkZ3WqF8ypUPgwHfXV7hO0NRx5Ufd90oqeq10TzgcZ5PKp7dm49F2eXnBtPEwUXFda3J+dXJ/SW11ne5RhWIqLtpSVsDCkLJiXVU/VFSkiE/X5f7NpQyD8L8ziQ1j3WOlISUk606zO9Dxi91l+SPn3x8ZmTLd86RZVzymw3G+7v7vFt9wu89m/uyFILpIyQiiafELNSU0KKGGPUVaTRqWfvnGpIFkRdH9hIUnCKMGtBs+5X6KCcKXzzOoL0ZWLngqLMJW5Pvq1T+KeJabVW1QvsvWe9XuNbT2NWNI0jZdWVNLUgM3axOH3wZc3D+yYgknCu5Xx9poXLNNO1HRftmsdtx5mxECONQRfsys3N+QganziNHLdRKc93eUZLQqubdiYX1yFrdYOv11bycVgQ0QreS0ZkRQiBKSacb1We5liF8s1i+Otjtz6L1/yc/xv/K/73/M++wev+po+iVZil8PHLVzGdiJJIwWBdaTWnkvBhSTEhNoLRJDYbyzTqUFHbdrpJ4VCKiP0MKiInTKmTgsQ4LEWY/Ji9LQkdJWk4tl4LH9o71mu1lEyi/uMparGHq8NROmyir/1w00dYUNSMkEQ3+q5psVmY9wNu7bjsL+ibjkeuoYuZznimFHTM1djliTOnj8NJYvNgzzmhP2QRTSpP5iKsrch2pmka1uvVyd4hSE6kqNqdOUemkGgFzi8voA4u1jdYslG+JJzN18auAW4F/vPffn6qTMyKamWKwySkEMmhKOhklr3aiCXHQCaW9r6uITHp3uds5e4qJaDOnXxZEqRH2asxqqZwgpQCizufLfRDzQ/qDItdHKdc0VKfQiTEjOSgBhDVJa/8V+PWmIc3R066ODE/dL/KMWHmSOca1tZzaTyrBG0UTMpq/mAtzpivXuZEn4tjxNYk+ZiEK882FSmpei01H3r27Nnx/EUgR1KKuKKmJDkTYqItHZgFUvmyTFU/+Oe/99m4LcXtN4nbXwruOooflAUt65R7lMREpHFeNQ8FvFX5kQqm1jZ2nmZm52iaTsX2m4aYpgWRyvKZJ/PBn4qgd/kRawyNdcwoFK/hpjw3lROBmDLvffQxw/4Rz5894vxsxWHUdmLGg7ii1VeS3sozqa1KUeS33jhrDOfnZ1yLYX+74XF3xmXb028HGtvQDDPEULUAFkT2eA1Pf6dt/eXPhbeS0Qoopoi3ltb7ZQjNGsMPvv8D+r7VhVcyWSIph+OmJpEcBaS4ap1In/xiSeoXH1IW2aurG/78X/1r3n/9CfZ3Hv/Kr/vrPOokdJ2AlkVnTiBJSTD1mlcpE0Uu1Ywh10U26XSqiNA27cIlyvbIQ9Pr/uVxC2BFh7K81clWI8I86+taDI21BMxSOMec2A4D733wMevGcXnes151TCkjpiEXHeAlxpZ3NlixmlOWz2SKKLW1lvP1GTkkbl5f8fTxcy4bT3O1wzb3mEcZlzR5thlMOn6qarlnRDhtuz9skUrhSedlCEFEbSfVBlnP8Hvf+94RPc5CllBi2JbzVF3dnKpCwik+8JW71C92SOZvSMN/lr//63vNX/PhnGOaghYKTrl8rq78osVV0zRMKS73IWUBEkHSUXfXN8q1T3Wd+wbcMslAWjpqlTs9zZNKVhVJqzK8v6Ce0zzz8avXPLk853zV00aLc6Iq6KWwMp+JW30/fZ2C9SwJQCx8XG8gTjPD3QabG9xouVw7+usD0wcvWQG7GHWzF4rAfyZbe2zrGz3fWoCZ/LDLUKlq4zhqolWkuZxzOpaRDY8fP8ZaHTQBRU9TDqQ8E6VSjOpXuY7mdA3+gpbpL3H8rrH8R67/tbzWr+X4zNYS5wAp0zctoPdDh5ceAjM556XnOocZ33QYDE3jCbMCIcCXw3T6QuXvdV+V8m+s0YJPYiDFBClimmZJ8uudSFnY7g787L0P+NF33+HibEXb6CCfGEc2Dmd0qNZ/Qcv7OK4FlV99KqnnjaW1lvHunjPX0zdr0kdXvJj/nObpJW6csH1PYz1No/JwcnKddO3MVIG0+sKLwpIcfx9jxHgPJZ86fc6stfR9V/ZFLYTVRjYxzgN9WhUb9WOu90X39lc5vknc/tL92CVTLy3+ZPXmznNFNbUqbnxD27RMKRJSbWMr7BxyS19EfSUlZikTZSUJBDC4hzWC5DIGeNyuwjyzOxwYJk1w+7YhZ20x5azV75wyH798rRB6WTytszjjyEV097Qaql3TZQIRKa4UyqP13vOD732f+WZDfHVLtx057xzzux9jnh5Yrzv8nHBlMMEaW3V6lDOSH6zCC4KWq3tPrYDQDTppxrD8sLGWi4sLxGRCmbKJcWacR0WhvMe55qTy4fO/yvGdTyswPlOlflaN7ciG0V/urq65evEpd/dXXPy1p79ENP1mDpVLysX2Vo+cBEmliVk4PilGYkplbTvKSXmvU9DZ6M9JFkVTENb9ihwCpqgoaNxKed/CIbT2eP0r7F58QatJxeFwYCwQbeNduZeqdZmjELOwH2Z+9v6HvP3sCTEn5pRUS9KqLatasyod4IuWbu/KkIjoIm+M4eL8nOdPn/H2k2c024lVY3Gf3GCCwz/PPE4wJDlpgUKNlSVi5KhGIRVC48jnKz9VbDdrQqTIHynTdz0xBZJEYo6EQklxORPCRN+vOVJg63U8idcHYXlybifB+zklwQcxfzxemqf8n+y/z//hC67ft+FYELrCOZvnREyJ1plFGN17baVnqT9Z5JBQPqfzyoOb+pE4xS8f9viCQ9BO0TSMzNPMNAUO00TMWdEeWh2WdZaQDBFhjIm7zY73P/qUy/MVjx+dc3lxhmsU8VdXnqPqy+lnrYezTuNbWCy3vW94+803+f3f+WuYj6/onWMdBhq5JUXLm9KyjwPMiRTSMRkuicuxW1Fldh4iPLlyKEELVzmRARJVn0g5YqzanIY069BwVPrQHGameeTs7EwHf5dng4fxu8C4x97L8smFZe14iAF+vgC+JvD/MC/5n36jO/mbO5aW8iIaX75SIiRdY4HFcMI5j/M6ZaJrMcu/NaKa6s5oURHngJP5MzSTLzvqXqZzM2Ge2e8ODNPMOOkQUNd4Ugo6g2+hbTwhRqLAEBIvr+9onOeNp4+4vDxjte4QLE21INUF7RirtcVd1vc6smrMqeERvPn8Df7w9/46H//pv6INgfUcWOeB3mywTc8zaTkkkBCR1pUOM0WprKx5pmYklfNak+CC0Oak1uglj9IWvxZMalGvMdV1PYnCT8+JmBQgmEPQjqORwok9UhwXVN+c4raapx27hMe//9LDGK7N18ftL4eg1gf45EIpMqq6X3oNlW9mS2XfJFum6nVoQmJcEi1nHd2qp2+PeqYVQa2E4GMlWqKjVKI5Jvb7e3b7g7pBeId4i8EveUHKEIBxjtxud6p92XjOz9dFr9Eek+qTaWxTHFCqLIMv9q0GkJR548lTwjvfxV5tyO9+SJ8D7Wagcz0Gw7nxuHgaVGZZk06l95Yp68LBtdZwHPDJi8ZmrYxAE2drdGo6hkgW5f4ehj0X82WRUPKFE1MWwyoK+4VHXSAfbumy/O94LG3cLGw3G7a3txy2G8I4fvnL/5YOEVkQPI1TLVg0QVXpsNoCEVg4w03T0GVHCpkkaUl2KUikc5bVel1E0MOCsNcWSsEwqTzY+pwYa5EM8zSTx1nlP4wWU744V1mqDqkussEI2/1A1zb4xuG7ht43OtBV+NMaxubB565Joq0UAFjMrrxzfPftd5C//ge8+kf/NW309Ey07QHbtDyzLa+LTWZtw+tmXp8/SizJMbbLt+rkqVStvZyWRfQ4PGbA6rBUCGG5vvM8YXMmhJm+Xy33rXyqL7jDn92s6rmcxPFJPVVf56FWs2Gi4ec8/6Zh9Vs56jqRS2ElCLVFXoeS2lbRQB2i1thQOSi1R258w8XFOaE1dN1X03EqZl3TJETvV8yB/TDo4IX3pDCTrKFxKtqvVo9a3Exk7vcDxhn69Yo1tX1buddlXTKne8oxSbWlm2WtVZqBtdgM77z5FvIHf8xP3vv7tDHSxYB3A7bd8Ubb8EosQ8wFdbMPP1D9PfLFHcmacyBHF6OsCWptlWaRhX6QUmKaZkJSeaVpHGn7cekmHIOv4oOna3HdF05P7HTw58vvT12HH8vIv58/+sp7+Vdx1A7UUQA+l85QjdsTcMlavPf0nWVKRoehRbBiVerLaCHb+LYY/WRkHrDuyxF/Q80QTnFMyFEUCJgmYsq4tiXFQE4tzqpaT0pKQxERQhAGEe52e84vzlhn1I7XVjT/eF+NoXSTzIPi2FIMX0wZZHXKuX3+9Bnur/8++d1PsLcb2hhxTNh2oNmNPLYtKVGk4DgJxhIXp0OKnHBpYenSHrtYqi+rXdi0JP/1Z62FeU6Ekj+EIg82zDMxHdv6ys/+grV3KfZr/NqH66w9OdcHNZYmP0/z9LVx+8slqOWDVp1Q/V5BRq1ZArFeO+89XevAKpfSREWWXNFItM7StA2tbTR5XTayU6T0iB5WYWfltyR2mw3DOKsLjzGakOSqNqALesiZORq2+5FVP3J2tub8wmGsHHXZioHAUiDVL1EBZm8tjXNaGeXM5fqM8fycTdezCwmfZtxhoulGTKvckqHKbWAW7qiR04XxeP0qR7WicTklcoz6MOV2Efzn5J/qxONMSIGUE8PhwBwmVUgoWocPF8nTWn1Zicvr1Sv95VlmTkmLh4Jo3Fxfs7u/Yx4GcgyKDH+LjhqXmiiV6hw0fvQKFdm0siBY3UC993QYskkkiTjnFGVFdJG0lqZr8Y1FcnOSSBkeVvkPK35jlDcYZkVbpnHEeK98o1xaOgIpJqWUGDBJGKbAZj+wOltxljItBm9qclo2vArRl0q7Tq+6ulBS5sMFvDFcrlY8v3zMzRxw0WHNhN0P2LblebNmmyODlIgxthRNJyvNUtmffrcOmSkaklMiorqyp4VnzXOzJEJQBCqlxDiN2JRK2zSfoFmyRO7xYh7P4/iNz8bfsQNyWgwqkkxxMRImGfn0W2AX+XWHJk1CdpXPrjEgUn3QLTYJNguYRJJMzHmR0XPOsT5bERvoO51Q/sLj5FIfOXbVJ13jFiyN1/U2xoi3vsgvHSX1DMJ+mGi7hjEmolC4+SU5XUAHWTaxyhu05We9MaVToDFvs3C5WpOfPuXnIeGIGDsjdsS0B56dPeXCNgShtHjrsNlxdTN1Y6lJoICcbsJGQDIxBjBG4zOnJYlZkgBk0fyMokOqwzjQzysqvagmkkdU4uQay4Pd7eGF/wx2usRARXULjc6kmUfsvzRm/soPOSmQ6/MOyzpMSay8c/SdGkuIibhSeJlCp1j8602Ds0IaKJSUz8fsMTksCVjNGkprf54m5mnWdRuQpENvqjetdKRMLf60GNseRg5z5DxrS92bY1F1jN3TqqfErhzVUS261rqy7l6s1jRPn/K+86Qk2BgRmciHA80w8bTpOZikz2xdd2uqKLKoHyxIQ/28Bv278nNSinwwxGJbXde+UtdirFm6Akl07R3GgXGelUctqYzxnCjPLIBEvcqnxdXnFuTPxIUsv0gWbA5fG7e/cIJaxW1BW0bOOcgGSZWnSXHZUCZoLsG26jqMz7iYmG0kI3R9T/XvFYGmcfjGqTDtifTOCdaBKZw70AGVGBLDbkCMxTZaZecoTKgsiIr/6iIxiPL8dsPEfgo8xeC1E4s1QpUAMrCYANgSB42xtMbSGENjDF6gBca7O15/+AF9mEkGwn5LajxN1/DUtryIuagwmYW+LVLvaeHynVxbkYw1tqBJM+M4loCwCyF6SVOtctEOw4E5zrjGs99uiXEukH3iJG3Sdz/dw00FwUolJsKxFbX8yPJwkNUic2nZCrx68ZLd/YY4zyrd+S0g69fj2H4pv2Qp7Xunrf4IYpS3HCUd8/VyPbz3rGxLMjr1b4uFoiLTuqE67wrCs+T3mgbays8s1bU9bkQiQMqkOZJipnGK1OcEc+EZxhRKAm1IGcwErgmcj4EhJM6dLfypugELlQ5z4iOFRaeaGwytMbTW4nOmA15dXfHhuz/BxUhkYpIdrTH0jeO7bz7lk+GGmTKdW4YZT+rGJWWsbahj/BS94BAZDqrL23eqoFDRvxpzKWWGYWKeZ1zn2R92NG23JARVzo569b5gDVwGED6DOB3BhnonNDGttpi+DkOQ2If3+Rn/R+A/+pXj7lc9HiRKn/m+ZFHKSeFDV/Q8ZW3Zd53Hi8FnwboyDFimz4215OLm421H2xbXrs8ctYC1xqimrbHHoU0pKOoc1efbN5DVZzzYyBSjrreSyVmdy3aDOtOcjYFHMbMqqiOUQS2A+rScrruNGHocHYYWdO3N4FPi/u6Wq48/gmkgkRltxuWMdYY3f/B9nk17Di4RjJ63to8BI6WEk+Wzap5oUKGoovwhKnt0OBxIIoQ5LMVVTThrsjVNk3JVHewPew6HHWfrM3KOzDFgUlNENuyxA7pc7OMEtW4MKv5vPhfnpwGvLe9xHDEG/nwS/uf2TT742sj6qzxOuhRSZk9SwjmnsVsUbrquA28wXp/1JBkToyamTjsDzliavoWiUf2lRynEa+vdVvAsC7HQPaxTLV8FATKSAjGEMvOhcat7smc3zNzvBi4uz7mUMngthf15UpVXWKAOQzs0fm0WnEBjLT5lWoE4Duyub7j+9GMeRUjZEXJmOhiehsA7l5fcxwNDyQMkQ6q5AkUF5qQgX2LHnPCnUdWk/X5P00amaWYKhSddlZes6vxO06TFVYqM88jd/S0GRwgzMQZigq5kHWZJTh/mCOUi8xDWky9aWpYCNsfEj6P52rj9pRBUI9oOrwt8Cg8RopxzcTJQXbjhcMB3OoTkjKVxHmkNxnakrJI5khNzEtauVY7aaWL+4IMW//NSvNTkVpBlQq+6r2RTkmZR7kvKiSEYNoeB9W7Hdyr/KAewFmMaTlvc1hgaA2e2oU0ZO82YcaJfgx0mPv7ZX/Lxj3/C3ScveD7DZCL7lGkaT3dxzhvn59zkEbIsxbPKSH1JhaEXl4oi7/d7phDx+z2GG612KNVemmgbz263Y7PbMM0j1hn2hy3393f4puUcMMZjSmflc+W4nhA5hGIIYB4Mmh4vuVZk0zSx3+9JYdbkxzquXr3gfnPPNI7k5ovq/W/TIVxeXnB+fs79/eaYXJXNt3KFYgxMYyBlh7iOxliErHxq5xAsc8yIFbwrKhGtX9quNXHTVO0UTdLDFvS/clbr5i85E6pMGyebFjBn2BwOrPYdj4ZzjLlQpMFmTYiNX97DlOSiAZzx9Bh8StgUWRmrsTyM3Hz4Ee/9y3/NO7MhEDnEhEMlcR65t+gxDGKxYjGi0j0uazdhaTuUanjp3C9ZPozjyOvXV/i2wxnDsD/QeK8tpznQekcIutHe3t7S9I7N/R1N17E+v2C1XjHPOoX6EE2S5ZPWGA7zqO52jT/NTI8/jk4TazIxMA0H2r6jbTvImcvh9/gP+E9/9RD7NR2nCNSCYFITq0KxKTSqisofDgea7gxjPd5YTNOSc6ZZdTjXqKQPWU0ULF/Y3j49jm25vDwbdW01xfXJYoqedS6ONCfcQxHECCNgh5Htfs9+OOPRhZ6XrxrkpszZ62KMMZbGWXrX4GPEhYgPkTWGJiVWwI/f/Rn/1d/9+zxLGckTEwGXE83BM9/e8PxsxZ1M3KcCXBqICD6Xz1WAuEUbVVh0OGviGULg5atXCJYYZnLKtE6f83EcMShvfJombm6uwFk22zvu729pmpa7uxuSGKxvlufYAkc+dUm2ciZME2Gecc7TrlaYBzF83Ox1sjqy2Ww47LfKhz3c8aNviU0vlEJwcU6UBWfE1BkORe7mWbueBhWuz1YVSmJKdN0KEUOYE5lE41NxpbIPVoIvOxYEFVd42Mc5E9DrGGNRcklHFJFyrlEyU0ochpFhmgkx0Xv7IBGrSH8FApzUnMEhQeOxN4a18fiUcTHz4U9/zo//6Z/gQ0RCJmVLtJkI7G+uePT4dzjD0qQivr1cUy2fNJblCKDWJDnJgzUjhsjNzQ3WOkKIbLdbLtYr/Ww5kadEzlpcvX79milMZEnc3tzQdh3397d6v5qWftXrOvS5i1zWX8lITBzGA41vcE2D858ZIBOWGI5zUC3yYfe1cfuLJ6hmUb/DGkfXdcR5QLJdNnk52bxSSuz3B9zs8H2vjhwh0q5XhXcmSLE7HMdAuux1g7do+z0ZvTEnFZFyLwqsXWD3KrMDFEcTFg4MWdHB7AxRMsMc2B5G9tO8TBbqNTwRAS6Llyvcp/lmQ3Y9trsg+B3Xr675+T/9E67f/xATIyRLNJFIIMwTcRh4fP6ENo/ErOhjrdHrwnja0lq0WKFA8zpIE1JGxoHxMOKcK2hWqeKz8PLlS65vrxjnAWvhcNgzDAcOhx3GGtp2pTyqBdo8XkPEMA4DLz/9hK5vePr0DZquKzJHCYzT5CMnUo5MYWQaDsSo9nPeec7Pz9n4V4ud9lek3t+Ko2lb9SuXI4ay6MMZkMLl3e/3jJPQnz/BNS3zrPpwbecBq8Lpc2A2maaB9foCYzV5qGT0pQVystmcitiDFH6oeSCxlsrE9NIZBKLVBXAYZza7PTG/RePiMfkt6EHFElWqxGERDjf3XNgGv7qEw8z1q1ve/+f/gk/+7Ce4KZKSImvRQ4gDYThwMcx0SXA5U0nyX35vj+jl6c+oRefIYRzZ7/Z0bcuTx4/1k4tuYnd3d3zwwfvc39/hOstmc8/ZxQXjsGe72SA0aicrddAts6RqRSd0v7nn+uolbddy+fgx5xeXsBh8qByYEaXyhDgxjgfGw4F5nrl87CBl2nDFH8rfA/69XyygfgPHcRJXr/niFGZ1c6pARhX0N8XrexwPjLM687imA+uY55lV24FVbl+MiTBHvBO87Qty+E3OKS36z3X799Yuk/VqbhHRrfZYkCPaB0hZxcLnKSgSr6v6gpjWzoLK7IG3nnXbMe8HpFvhzwWmwOZ+z/XNLTcfv4BhhlykC43qQKc4Ibs9K3dB41Tk3NW28kIvOfblKqe6xu0Jyx8RYRhH5rl0AozhzefPF2QwZ2EYJt577z2ub16RycxB+Xvn5xfsdtoNENGpcRCwxRbT2OX6pJTZ3t9ze3OF844333qLfr0uyVQtcG3ZNwRDYpwOHPZ7vHc8ngf+J2x/qVj7dR4JUWMfY4os2BGlrmmcMZokppQYhgMxjTT9Obbp0BnUjLMOrCvgVSTkxBQjq8YrnSIlfPPFqcsCCphqGFK1eUvHyyi4NhdbXi26gnJgKz3NHGNqPw5lAPucVdcXE7eSmIquyQuaZi3eWHrX4TO0WBqxMEWMczDN3H36kg/f/RnP5qwqMqLGRSla0jgh2wFvIk0LYqqOhZQuUa2mlnpnee/l2dGrTIqRfYqkqPzo/X7Po/Nz7UCf/OyLFy949eoFwzToAG4cuXCP2B52GO/p+zWPHj9dBq4U3T/OBcmS4215/733ePT4MY8ePeL8/JymxG+dF5J6zbwhD4HH8/5r4/ZrE9RaJZy2neoAlHeaoA57B1bbNJU7YoxuDDkLKQREArl4viLgXQPWE1MgVp3EFEnp4VSlWc6hQvdlETktXUwh0hdeoZShoiVBLUEkWduLc4wchpHrm1uenr1VbilHn+Bi5+eNpcGx291z9/EL8u2O+fUdr9dn3L56ze3P3yfcb3AhaUsIHbaJ88w0HGA+1+1RSkiX6ucYZnVa/pT1aZZrHUIgZiHmzPZ+w9Onz5abnUuvdbPZcnd7yzQPYCHmyOGwo2lbYs6cnQnjMLBaWaxvqUNqOQlpjhx2W16/+ISm86xWPc5bjPV1d1mmAHPKhFm5VmRFRmKatVXj6jTul+mAfjsOlTrSCVJj6nSlaIJq7FKS5pxIMRJCxk2hKJzqg+msJ+OI00SOEUMkZVMmVE/aGmZJ23jQmtZqqmhaHp8lkUxKWrlkPdmTRUiTvZQt4zSz2e7ZbPf0j7ryfFTgu7a2LN6qS9ThsGX76gru9uTbPeOTW+6ur/n4X/8Fh5dXGrto2ld9tOM8EfZ7Fa0ui1/9YDpoVlyl5PiRlhg+1qakmAh5JqTM5v6ex48fL/zcyrU97A9cX1+x220xDcQY8G3D7rBTJYVmxTQOpHnGulYLCXvUFJYId7fXvPj0Y1brFcbA2dnZSVGgDTipMRxiEVgf6PtW9Spjpo23/CH/5a834H7J4wF6inJLbVFsSCW5qhI29c6LqL5iZMaJxYnBuEo/cVjryFkIISJppnFCbL+5R7yUFmImLxbSxlp9VlJAxJK8olWnGyCmOAmmyGEY2O52hPic9mRyv2JdFWVxKAqVUuL+9RVsD+S7A8OrO3Z3d+w+fcnth59g54DkYuvIcZBp2u8xqxW2SdjslJ1SUNT6bNlqYW3KXiOacFakT0Ttsqc5M02zov9No9QdfXBBIMyB6+tr7u5vF3k/5x3zPHG3uaPrVnT9Sof/jFLYsIWmZpSiFoaJ7eaem5trnDOcnalTlq1CncfAKDQPmOdAmGcke9Zh4t82d79q2P3qhwHjHMbZZRgKKohUy+bj/pVSUuqEaXEcjSlc22CN0pVSFlKIIDM2VbWVr4ZBFjOKkjdWNMuUAl5KPKakFIJUNN21VU7heWoBPU4zd/cbzlYNTy6+UwrD+nXUNpWCnnauAZsY77YckmGfLNfBMA8j6X7Dq5+/T9zsgVafWYQkkEwkzjPzfgedoWk9abHH5nOOagvEcfIXla4HapE8F5rgNE5M41TokceEN2d187u7u2OcBk3SHfRxxW63RQTmEHj2/C3GaaAVnSVw1pdnRPeleZq5u7vl5uYakYizsOoaLYAlKVizmNtofzFlYZ2+Pm6/NkG11mpCclIN6RSmOj30fa/JJhZb7U1PbOYoFy2LkOeAWKfyEtaTjSNLKLqURbczH4dwHiydC/JUeJhLRsnxYShleMrxSNY/cac6ViuJwzjx8uVrfuc7b4KcJqhl+q7gEyZm7l695vX7H7GxDVerFY337O83dPtBUSYsYtW1JZWhj2kYCOOIafNyinCCjEitfMqDIyzfq1GZkgrlTiGy2x948uQZdTOqCOB+v2O73TKHUS2fO8/hcABrGcNMFthvN9qetl5bW6VwGA4H7m9vuH79CuPgjTee0XUNzp0VZEF5Q8pbEVLMpJiVryuK8ErOeOsLupv49TpO/3qPLKKyNYU77YxW29Y4fXgLv/kY64YYE5EJs3xGR8YSk/IAKeLhqchUwREZ/6LDGJ3EXG512eylcC3rZPay2FSk1yhFZZxntrsdr1/f8MblO1qcmUreZ0EJHAabYHt9zdX7H7Nzr7i/eMGjy0vurm+YXr7GjTOrXBAPa0t7rUxy7nbYC48T7TTVCr4+ezVnNacLp5iSJGtGEFNkmgNzTAzDwPn5JVT+V7FDHoaBu/s7xvGAceq2Ms8T+92WmDKr1Tn73Zbz9Tldb3FNuUco2hKHmevXr3j9+iXr9Zq2bXjzrTcXx5S6iuSciFF5aDFE4hzIzhSnsIRLM9+1355Bk5qAA0VCSjl5LmlvXnOcip4e1wwpKGkmIDGp6HhZixOq+CE5QbkeX7TVHwvoctR7bKRMEZcvU4q5wodNMRe6x4ksTdk4U8ocDgO3dxv2h4GztuNYoB8LW9VfsXgs827P9fufsLWOu9Wn9O2K7e2NFlbTzKquhc6QjCGik8jjcIB5xpiMzQ1115AFIHi47prl8hWOX/kXMWXmwvWcpmn5uyWhFR1E2Wzu2e8PCIokt3SaoN7d0nYH2q7lcNjhbcvattrmL6T1MM/stxs297fc396AES4uzjg7P6dp/FKsLBSPqi8c1OUuC7Qp8wPz29dBNdYua6utSaqU7maxL9a1oWzWop8nhEQ2M1K4+531WoyVfSeECBLVnTF9LjofHp/561xQ3apprhQ57Qim7LDUYrdyBkvRJMr3nkPg7n5D6wy/8713oDGnufeyJhoEh6EzDTEduP7kJbHfEG623HWv2NzcMr++YX99QxMyQkSMVXtcA9Fo3jDu94jtcTQPPlRNnrNUOK1+0JLY1wn6kjepe1ckzEGLmZiWfSWXxTvnzHa7YbfbMc0jmITrPPM8s9tvCVGH/g7DHr/dsD4T+n6Na4rJhihtajzsuXl9xX67QfKMt0b1Y9um0IFkAYJyLjz6JDTJfG3cfm2C6pwjSTyK5JbDWkvbNioh1baKJuWEOpSoxI46M6gYv1hHrCtBlT6hkv3B2wZLwBjBUluk5fbIZ7PVuncfE+coCZvjsV26oD5KLDodmKlZ/6vXVxz2I+u2L5wqgLzkvXGa2N5s+MufvovbzgxR2HJLJ1arBDF44/AWFQDGkpxyaEIIhMOI9RZnpDgT6UJpEEW+SyVua4hXiN75BwlszijyIarHF0LQYQ+fuN/cs9nckXLAe0fvzhingZQTu/2OMM/cPHubfrXGt93i6ZvnxO3VNS8+/ojN3Q0xz7x68UwluJwvdYXavFZfYIdhHicsCWt001mvVuybltZ5Asf78W069LPogIz3DX23puvXpGHESMIUMwnnPMaolFjjW5JTMnmqm1jdJErB5Z1Kjhmr7aKFF1LfFJbNvXYCPnt9tDBLS4J61O4Wamu9auvlnIlBOBwyH3zwIX/4o3eo+o51kt9bTU5zjGzu9/zsxz+F24FNEq55QWstTuCRQGscjbXYUiAmpxywEALT/oA9O8OaTC792lxWQFOLKTR5tfm4WIK2o2v8GOOIMRBimWaWY2cj5szusOfu9paYA85Bt+pp5onDYcfusKfvdzx98pS+73nWtLimQVDqyTyOXH36kleffsyw3TCPe5yDH/7ohzTd6oiy1rWicMEb59TsYD6Qo177Ub7PC/63/OA3FIO/zCEle2qapkzgNySr19A3YK3HWkU0ahw0tiE7x2kvoyZip4YJ2pA9Fu5fdpjTmC+od33pmIMyh7LUXqfGYq5xW/4tQhLDME/c3Qsffvgxzy9/d0HWNHfIOrCWiwXmNPPxex9w/f4nSEg01tE5j8SZy2xpraN1DiNClIizlijKHw/TDOOAOIuR7hgHy3/l+mbAVcQNCgRYEqmSBJgq+ZaPsw0Fic+SOUwDNzfXZNFBE9+oCcHhcGDKqaDXlqdPnrHqL+m69ZFHmdVw4PrlK25fvWJ7e80UJiDy9NlT+r5d2t7G6I6ZsxDnoLKH1mLIjOkZt/If8PavHnK/0qEDUHofnfML31w7kg5nvTrJlS6PXRLZMihtTq1KzbLvaIx4cp4+H7NflatWxFlqCimIyQXxr393guQX+UGMivInidhkGcfMdrvjsD9wubp4oPqjWqEGshZWVuD+9Ws+/PN3cQm6YlpkUqafEytjWTkPkklGbXCjhWjVRttMI6wcNneKrqaELe2qRaMlo65WpcBbRkitJvg6zJpKQl7iNyVy0gHcJJp31QR1GA5MYUJMpqVjnCcEmMeJYTjw+tWnTOPEkyfPMY+gbRpNiDOMw8DtzTUvPvmE/e6e25uXHPZbnLOcn50Tl4FCuySoOav76MzbvPyauP1mLX5TW8rH79WESkSFk3OBxtvisoDRJNY7TWDHVEi+1oBzpR2tGpQGoWk9jevwvmy2JKxR4rKpkP2DaJRlsahHTOlYFQsnSxEPEoZc2jcmZ8ZpoGkf0fWtJsYC+92WMAWm/cDh9p6zR5fMcUuaAzEk8jzx2K9ocDTGYsWQUyRIZBKDd4EmBiRMuNxTGljqQc3xPPQhOqrj1YXQlEpHMMv1r62N2mLIKRHTzGG/YxhGsskwR2zbst/tcc2Esdomu756Sds2hHmi686YQ6BzK+5vr3n94lPubm5wDsb9nnk4EOYB4xyxVDu6WCjlYB6Hcm/0yVAuqwZ/lrAYLHwbD0EIUZ22mqZB0ozNLANitYbxvqXtEiElpqTc5bqQZnRCMqeM7RyNL4YUTmforZGymWS01Kq32hyTuhO01RqrGnUleVNZatUEfCj3dUy2Uspl+jJhjbpaqSsVyuuaA+PuwPbqFt93xC6Q50hOKvPWOk/nG1qKDWT5PFMRdfc+sE4Jl9UliNKNUFBSltaOdSVxLmeYC+rvXLUzZfn0sci6SFYJuDpFP44jwzCCyYwIOI8dJ9VTNoZ5Dlxfv1Q3mSnwne//iP3tHmcbwhTY3d9xe3XF7d0VZ2drHl1esL2/5fJJKU+lCq+DMQ4RneLfb7aI1UFE5xzvyY/53/G/5B/w6jcWf9/0OE0KJRdns7KZ28aj5X1i2baM4Jxu/rG0z7JJGKee4lh15grFbto7jzVCU2T56rCIDpHkwvJVVOY0d7VWxdPTibZoyEmVLUydbi/dAanDgvpaMSUMasV6f39P169oG1VR8WVSO6fENA1sDhPD/Zab2xtMX4aSQiClwJlpaJuGznkaYzAhkWNmthm8TviHFHEhYHKDlSLrd5Ky12RbqTUldSn2vUvLtgxMqWIHZWPN5BhwJaHKMSoCut8rr658dhcSwzBiUsC5hru7Gz788D0eXz7j8ePHjOOBGDPON0gQbl6/5PXLF9zdXSM58dabz5mHPeOhA+eJOWGp6jXHgmsaBjDCy3ng/y4/5b/J3/mrCM8vParySdu2tG3DPBerb8yy7+rPFUtRq/SLmLMOkzXa3TLOIUbX6lQskr1zeNOW4leKt3x1QisSjsApsrg8N9Yu3xPRASgdNC4mFhUSLyASnK7Zet8VSb3nu289xXnV8XVWFQGQrIoP48z29RU//vO/IIeZOSSmDL3z+JKs9t7TGouZFZCIUAA0mFLAxQg54aR0kpFl34ey7toi3k99ClWjWocNzdJdrXnEqTTa8gxkQUhsNhumaSbmpAVCSEzjDALRRUwIvHz1CUm0vd80DX3fcX+/pfU98ziSxoH769dstrcYC+u+YzzsCPOo3blSCFhbr7Uj5czH+Z7/WP7JV8btL291WqZ8rLH4tkOSw5HpvaHaeyVRvpJvWxjLjbelagLmeSLGGc1ZPWdnK60KRZnvpwJT+r4WcxKAlRwMFB5eacFgS73BSf9xOXlFqpyh63uevfEG636NdwayJljX19fK74nKJ/r+7/0O7geZeT8wbffEuy3T9V3FZ8vCZFSORDJTCvg4Y2PAxgZyafOLwRbhfb1hxSDA2ZIEnFSMJfiqMsFpJVj5kilpSyumVCJViCEzz7HoICqn94MP3md/GFivz7G2BWP5a9/7EcN2w7jfk+cZ2zekMBPmkXkaVIB7gRpskUCamKdRHTico2s6hoMOTcUQCCTkC+zfvi3HKYLpfUP2LY2FxqvwPqKLpQIpDuttIYa7wq3SKnyeR1Ka8a6n7xUpaJyK2VTnmBqx+n+9mwaOE+9yPCddG48bpJz8gJHj6xRYEqRqXva0TUfjzMJ1fv36NfM8I0EX8B/+/u8i+4lxu2e43zFf35GnWCHhslDp54oIc06MYWYOMyZlnIimQkcoUtukVq2ErVfEq2qe5jLNDVavBbLYRB7vg/5aOa8pJYzV9SKEhJsj2IBYTcZfvHjBNM7cP9pwdXPDOATeePacvmnZ3N4w7HeEcYbVSl3mw8w07sEqklhN24z4xRFomiZs4xiHA03Tch7f5r8r/+vfWOz9IkeN09p6rGuCdQ4nSknpvEpEpZIgGqOSZyEashgyGtOmgAE5pmIlnWjaHm+NDpoY5R5Xjh4lDk/lPAQdGjm2v/W7yyRx+aEHG+Dx0yCAk+OQksXQNi1to90lZ5R3evX6NcMwEMYZmSLf/93fwUyR/f2W/d2GuNmTxqQgR0l4VDuTIg0pTKJyOV0MSLQaw2iCacrPYI4InClAwIIQ16EkY7DYRXGlAgWfRZulyCfpXqCJwRwjc4hIilhfBh6jsHu0J6ZMjGp48ejRU56cP2K3uWPc74jzhHeW1jnCNDGOe0zTELPgK0qOrsUpROZZEUUf7vgD8y9/XeH3Sx9VUtJ5R9t2XFxcEOagerZNg5ZTytU3xmCcit/HWaAkptZ5jLOKWMeg8mkY2k55qpqcyfJeqjt6goCfflUqQTnqn9T286jhrqBPNbSA4widrmtqh62gQFPiVumAghPD7e09cQ7EKRL2AxdPHuPOLxi3B6bdgXmYsLhFNksbI0XHvUSOlcwcIz7MSND925fEXoGL8knK+otUIooe+prHZOhUarB27+AYx2UzYpom7chKJptMtrAqg+wmZYxNXF1dMw2J8TCy2255+eIFm82Ot9/6DhIzd3c3DIcdYRpZrVc0zmIkcThssU1TMjHl0OslVpCgifdfG7e/tNWpQauTtulovArgeit0Xi9JtSutLRVjbZlaKyiQ5EKw1+TKGLWPPF/3eOcKgnS6RJ5yysxJC//knJaLX9C9Ewu5I2SpVb6zjiePH7PqlQMR50gME/Nw0DZg02AbS+sa+otzVr6lwdJmw9ks/MP/93+xnNmSTphCekY3W5sytqBQy2KelRuC1STIl3+nVbq2GwtBojwmp8j1kldoAZBy0SqLi0jvFGbyqNdbjMGZCSuvGaeJvlvjXEvfr3nnyRuMhz3jcGCexiI4nxdjAExp3xqj7YgkpBiYppGYVHMxzpHtZss0jsQYVDXlqwiYv+Xj6BbmaZpORZRtpi0IFFJa7ov2jAFT24OmDPjlE95dwlnPqm85P+upRk6f1d9cbhrHttNp/H7O5jHno/nX6QeQXJLThqdPn9B1nXJiU1KLxWFAkkq82d7TrhtWjy9pLw28kTBTxO0n/vKf/Ws0OT1GVy6LYULpMjknbMoqKyU6C48IOaperLG5tJRU6D4nKchaLaLUqcSKffDZTr9q7MYcFTcWlfZhskSRYgKgGsvzOHPYD3Q3N0h2NM6S1+fst/cM+x0x6MCeESGFWYdSfKOTsGVDMBlyCsTy963pig1uYIiB62Xy/9tz1PvjnMN7NTKx1tAX8ZHadckIrnFYcQrAlw06l5hOuTrJZLw3iqA3Hrsgn3Uj++wZHL9xChec/lgd2Cp76UmywHH9LQoAjfc8efKIxjflWdLnaSrDHDGqhWh7tubRG8/wGB698Yw8zpjdyMt338PFfNxLDIr8UAdOMjEnmhgxyS+yaLHEb+V5G8raZo+FYy5WnFrMmAX0OPmgVGMEY47DlLkI+Geja78Egx0GslEpvnkMzONMDJlhnJBsaJqOnDIr4zjstoyHA3GacV2DEU3OYgh6fzBV80BBmYh27IKu0/vc8TPze794cP0GDn3ubbENV6cmB7RtC5iig5zVCdFpASCmaDlTDT6ElMPi8GetpW2USufssXg77Xp9PiqPRy3BH6SvhZet9/H035sHryVZsI2jazvOzy5oGrUTNqIIbJpnhsOBaZp0mCsLz7/zNg2GaT8wbfbMN/ek3aixJHo+tctQAbeEgiO58MNdUgi/Xo8C9S/USIvTZPfh1S8gR7kPsNDRNHcwNRsHNMkPIejAWKEcmAjDNOFjpErzpJiJs1qG77ZbnGuZp8iq7XGYEr97wjSr+UdK5BCYpwFXpvh1LskX9aFImCf2yX9t3H6jFv8Xf1+HpLq2V4s57/BGN/x6Y2tbRGWfygR/EkzU5E0k68VLQBbWfc/jx4/o2padnC6H9ZoeK54jm6jwO6mLR0ntxBQC9GnwUTYr5aG99fwNrbqHEYmBcTyw39zz/PmbNF2jvEQsIQurzvPs6Zt879mb/Oj8Kf/kv/h7SNUeQzdXddA5ZpEmCz4XC8ykiHDKyjXJkjHOqllB1ge0cpwWUnxp8elDelL5oJadEhNz0k3eik6zjvPElCJaJJSKMWYOhz19v+JsfQmXmTANzOPAdFDJna5rKC4LSFIkVGDZ4CUJkhR5iklbwmGauLu5IRy2ijh3R72/b+OxJKe+pWsNNB5LwEtSaRNAJB15t1ljJuWMjRlrE7nkWzklUkxYYN31PHnyCGfs0XhB5FihV4QUSrujNsVPKmPgiKDWn/9scaXOMY13fO8738E7RwrqJDaOB7Z3tzx58gTftsqjdQ1ZoDlb8+T8Ec8vHvPds0f8X372PnY/LHSMDEdpOFPKItFF0udCzC/PXCiezhQEpF30MXUBW5CpWsWbvKAdxxg+TkmHqC5oVrQgMsEQyZgw62aWIIyRcZjZ7w903YpVf87w7BmddYyHHcNur0hiCPoVo3pPF3vCWtxKdWYrQv3OOWJOpDnzcvqIvyv/CfC/+fUF3C95PChYyv+tdbRNW6ZoDX0nS6dK3fKO3D9bbKdTKgNTonrUSF1LoOsaVl1L690Jn++LN/kaiw+Su5NzNcbps2Xsg39VX6sOo1tj6NqG77zzDtZYwjyTwkSaZ9X0NJa+72malnW/plmvWPUrHq8veLK64EnT8fd2/ynh1TUyziqsTi2JWH4vgCkUFSdZ2/xGn9k6hGtSwjeq2QiF3500DdTCsMoS2YW68GCTR69pCDMhhwVBtaICWiElpb2hihpd0yEZ7u5uaZqOi/NHXJ6fE88fMe4PTIcDcZ6wqLqKpKQuWFkF2yl7pSQhzRnJGuPGWW7NE/5e9z/4FaPu13NUxZ1atHR9Q1N0beuelMrGpLbS1HmbZQDMLPugItogNN6y6j1N4xaqUXlHviwxPerNZk6hKluACrV/PgUMTkCwBRwQ2qbh8uKCN5+/iXcOiYEYIinMDPs9McSyLgqrVc+b3/sOrfPKz54i4XbDJ3/xLvZuA0GLoNO4rcotGU18bdKvnLMmwjVPKl1pnF0SN1OctZSycrJjGKV8KQ2y6Egv+UNF/lWLNqaghV2J8d1+XyxgtRsztTMpCeM4cXfr8a6hbVbsd1ta65iHgWm/V6vUtiFMM3GaifOMLAo/ip/HFMizEMPETb742rj9ygT1KAPyMACWACyJYE6CGJ1ozmkinfmyURf9uxSBBmN0448B5ZoZVyQdEhIzq25F3/XF795hpbQJhdKmk5qdQjZILrw+OVZSS5dKKq/QPMiZ9LwFbywXqzWH3Y5Jsg7LmMzjZ09Zna+xTsnyzijy62xD07SkmPjLd9+ldR6TgvI7siwPWa2uC+aGLXZ5kgJWPMM0cNjv2R/2pJx5/vy5Cts6R4hR+WM5antTVEdyt98BmtikGAhhIuXAeNgzTANTUIHnjEFMIsmsraSSQM/TxHrdc3F2TmMbzPkF67al9w6P4DIMdxvm/Z4cA94ZxCr6Yq22gROC951ydLf3bDb33N7cQMrs726ZxxH/5FLlwr4Fh31ANSgVtzV432KNI4UB64oCQw4FvdYNJgS9flmU2xlSJoUAGGyBvHNSorczjnW/Yt31WOOoupsCqr1JXUJr7BoQbYubfIxbWyZcTUlyTTjlVJWfKQuqM5ZH5+dsbm4wpeJGEpeXl5xfXjyQFyJmjPG0Xc/Fo0e89eZ3ySFSaSOhOKhUsv+pKLzPgk+JmBOVlzBOgyJdKeEaz+XlpXJzywa/IMSmvH4IbHebZVPRTV3jd5qmYq03lWFMyFhMziQyYc5FbWKk73as1x1vPHvOqulxkmlAE+SUiePA4e6e3aN7OtfQen8idaMFXxBtrRrrsU3LZn9gCLrRH64/4Hf4Z7+5gPwFjsqdPyKTZXLfeqw1NN5hjPISrWQdtomi/t2ivLiEFgxhTPjuiDqFeSKnRN+ec3lxyePHjxRxFx76G5Q/V71m6wyG4hpYEmJLkcByqhfNsgbrpnlsoxeKglEu4cX5GVevXkHSgiKGCci88847uOJ45awjIsrVbFoevfmc3/3BX+P/9R//J/iUFiv7LFWb0SwanCLaHm1EB/FMToiFaZ6IYS42wpnV2Zqm66gzFtM0YV2zQB9IJqbIcNhpm9VUKbaZlAIhBsYwMc2zvjc6MGhF1wxNWkqS6tSC+vx8zVkv5H6NzZnz9YrGa8zHacLkrBI/sBjhHG0vDdkYdc4aR5z3pJx5uz/wH/7tT4G/9VcUoV98LBQRLIhFskMKPcqW/0gZIqSoBZSIxduGIKpMoCw2p4IqiBaa6IDu47MLnlxecLbq9V5RQ64w/Ysaj8k6KGqyVZAhcRKzOsTWNL4MCwom655lMYWvzBFoMdC1LZfnZ7TecXt9Sw6BFCbCPDJNI2+//TZPvdcizXn2YUKs4+03nvO952/xo2fP+X/+n/+vXP3rH5Nm7dDmk/ZY7QJkiZAzvtAb4jAgrIoCia5TMUYysFqtlKJTOLjzPNOaY7GZUiJmKRP8ka5pSEnKrIOaFMxhZghDobYo0mqxTARgLrQtw84Y5mGg63v6vmfV97SXja7BxmtLH0jjwOT0Z3NKtL5RmlEBPyzKNRejah/fWY/8h3/7jq+K269MUKtAdD7h3xyn4bUlst3cEVJA4oyEGYkjb79xqR6uUib5jWHMQTcgAYmCxMCqX+G9JwcVOPZO9RUtYJyAE1Koi1xa0DzKKMmDtLmcYxXsXzioerLHB2hJrDP77Q77xqVakdmGtnGsz9aaHJbP7qzTBNroAnXY7vnzf/RPS2sKHSJByNbRlglmY06gdxEVuk+BGAzDNDDMA8M0kXJmPwy0qTpdKTI1hoGctbqpHBGRo2d8KnyYf/iP/xHjOCk6IBq4MVvmMhARUsRaj5lExa/bhosciOPE9u6OMEw4MbTGEeaZUB76vuuwbaMor/WMUyAcBrb7LR98+HM+eP8vef3qFZu7DeerFX3X4qxlnTO2WKr9to+aoJ7K9QCkODPPI+M84p3hcNjjiHizJoSEMQ3OtIgcSJIQ24HJOjCWLI1ztG3LwXpiGdBbda3yppc5d5b/K1vgyIf2pi1mC8opzEkHVHTQSS0lQ7YnPNRSZ5fctqJXOSZM29A0Fu9amsaxWq8xvnCrSoIqGIxTzl+aZv7FP/4n+uyKEIutnxi1Ql0UAah8MrQ1myI5RcY4cZgG5QmGqBP1xtD3PVmUtwRWEaVsCTFzmMYyiWqXadIQAhnhT//Zn/D+B+8vUiSCJUtEkiEkFUk3VieDs0SExHp14GJ1wXQYmLwWs71vyYzMh5H9dsv55RnduojQG4NYsKbhLpR7SqZpHPf3Az9996fcXF3z/tXP+Oe/4Zj85kfWmDFVV9oToyacKSfGnNiFA08fr4vEHwtXNeREFFuw+awc/4YFsUrR4KRj3a9Z961Kw1lFXY8MTO3Q2Fx5ehZTqBq5xA4FnfHeqyGE1TWZWNbE2gUous+VT28K4htzwCH4xtOtWs7OVtreLpqt1qmBQvKQPYQ08uLlB2zCgWch4VLS89W30KSytExt7ayJYHNWIxgnzHFinieGcWRzv+Xx06e0pdtgi6lB0xjtTpGXoivlozNizrq5Y4VPXn7CX/zFny8tZMksw8KSHGMog4kYfBmsssbSt2uMgTQH1v2KVdvROI/FEuagvGhnWXUNeItJlYJkiJJIZJ5cXtBYwzhOhOHbQU2xOIw4yA5JjjhFshfGcKD3Bu/Weo0WVDAX3qc619epdUKg8y2Vn5+jYIzj7Owc56s9r2KQqcSsaEAq5UgM5Y0wJxKZlbt6qissWTDJlIHf8tJ17UYTXUmJeZqZ57lwYhWRbdqWyyePaNYKTii1wWunxgmBTJBEQnjvw/do5glvSmF1ct0MR2Qz56iIbxYkpmJtrMjjNA2Mw8Rhmjg/P6dfrQq3F0IMuKYhlXVSpbRSeb2EtQ05R/0zwmE88NOf/KTYoVfteYGiXBBzUlnJEnt7JgXjEJWZEqH3Def9ClaB3jUEMeQ5IlFdv1brHtv40ucoRkvZkq2uv2q1/NXHN0JQ6/X7rLRDzjp1mVMmhUgOMybHggpVno/FNR4ZY2ntlcGinLHeq++2iLYvDZhFauIh8lkRySK0sPxcHR6ovBdnFbqP5jQEjq9RjyzCNE/lwxmUqW+1vVgFbcUs70cWwjQTNiMf/Pw9TCj82YqMFVktc/JWtU2RU9QBIwLjNLLf7zgM+t7TNLHdbcoiafFNQwyReRqZ55GcI62zNE2P5MT9/S273T273Ua19bwlJeV2pFIJxTLJGpOSrQ0ZMxmc82z8hjPb8fOf/JTd7YbpcADR1sJue89htyXNE03bIDnjGug7z9zpNOqLFx/z8ccfcHtzS46RedpzfnaG9w1uOqPLD27ab+04lRU7HTKbJvV9r3Ibc5honEo9URYeay3GGbCZTPUWt6XdIrRFl1Jfv0qI1a1doZ3Tq/CgWV/3fKMcLCe6GfsyUa2IlflMkYOem2GhAIzjCGctpigMVOQpn75nQYYka3E17Pb8yT/8L5XrFiOSpDjTOMQ9RE/VkxpMVt/kOAd2w5ZxHDkcDsxzYHV2phq887QMPlrnSVGnQOc5Mo0D3lqatsUgDMOBq+vX3N3dcnd3S4wzTeNOhoLUgSbERMhRh2sQJGaYDfthYBxGbq5eE/cD815RJ50CD0z7HcNmo63AxmOc11+NBVH0a7fb8emnn3Jzc8MnH37I7c0NeXvFv/ftCF2qJmO9h3UtzIVGkVOAOahXt2gnCdE1MJeBHYwKyqec8KIJlnNaQKeU8cbqYGiV9CtrduXGHYsjOCYEtdVdBrbKV+P8MtleD3PyLx9+OCCr1FVrLb6x+EZdBisQgtE2rBjtSPnGMw4Df/rP/4w8zeQYFegorVFrKMXIaXEoix86KTIMI9M8Mc0j4zQyzppw5Jz0sxSbVltkgWKYGaaZcVZ+dHUxjDGw22+5unrNp59+wvXN1YLgSukaUNr7MUUdzgKyWCQI7TjRHwZ2zZZbe8W7f/7nTPthAWZyTtzdXJNTxLce23f4FDXBSOBsVIkp7+j7nmmasTLyIZtfXwD+kseCoJaYjFGvfZhG3KrF2QYVK3EYtEuq9AmLtaYkVboXGaN8U1toLCTovPJQrdF1OpeEqSQnaDvfHPMPU+P2uKZSwIDGKeKZiCdc0PI5lt+VaCr8ZGt0AKyxDd4ZnDc0qx4pIB5WefeSC0DgLTFHPvnkEw6HA49SxhR1CEHX5OUZN0p3yClj6uxKiuQUmMPENI1LxykUy2aMWlinpBxo5xt1OMyJeR6JKSM5LblbRWKH8cCLly/4y/d+Tpa0dJ2zUKYhc6FfJVLSAUchFZMO6PueGGZurq9IqwvSHGis0nxyiOy3O25vrukajz1bseRymdL5MZizMw5nAuy+Mqa+WYIKn9tw64KWklaJMUZyjHhzMrFbFpimdcgwI3K0d6vTvk3TYCXjVXDh2N763LtW1P0ouVB3ft30KxHhs4SEk39fFv3Ks4uF+1lF01XzUopN8+mUnCFH4fbqhuHVLZv7e86dJ0o+DnLUk6l8lkrkLk4Y8zixj5lhLm4qIeJcwzRNbDa3dF2nvMG25bDbsd/vsM6zXvcIBuc91sLV9WumcSCEGZFM17VYi/L/ZkUv6xBP5frEBGYOjHZi8AcOfs/H9x8wHUbmcUKHFQLbuzuuXr3i7PKcdr2m61rOHl0AlhxmwjTiXXU9Ui3WOQTEGLxvaA8DeZ6/KqT+yo5FqqdE1NL6KIN5IrrZxxhp7ElhVNqZKiuVFp5mJZsLurmqNmXhrD3Y1B9u7cumWSgG1AW1uvGYY+wum7ocn4HPik3p62nrXMomXi3QFAHTV7F6EXRK3wjzODHeH/jgvffpk+BSKsmfyqXo1N7DczCiiWGadQBrt98xHA7shwMpJtq+Vw29uVHJIq+J4HazoV+dIVjaxuP9OV3X4bzVzf36JcNwIMQZ3zhWfa+LbIkdRa7iguKm8pllnhnHkXF/4EauONgNMiWVOomBmCP77ZaXH3/MHAN4R7fuOb+8pF+vNRHOif1+x4uXL3j96hXXN1fsNltkOvDsWyNAcRpBpwmqyuvEEHGFm1hpVgaN2SwaF9WOMFVOuzV4oxrHyLG4F74kbqlrsVnW+7o2W2Pw3pU1qSS+C1ez/HCdfseUoUMWlEZEsNYvyalr3CLhtigFFDBDpbYyh82On/zpv4QhEGMubJkya2DQz1stFUsSbFKCpMXVdt4QY2QcBg6HQVH8nDnsRzCa8FnnwVimcVDKVUjkJKxXPb5paNuGaRr46KMPub29YbO5J6dA1zYFWU6awheu4CINiCbTEoRxmhiGgb3z3CfDz3Yz82FkHkdyCLoObzbc3lzRna/x656+bWk7BRhM49W9z6iLFSj168tmRf4qD1MoTCJVlkvNOmKI5M4vck+G2um0iGgLv9p8LxJghkX0X6z+K2+MyvjxsAA6LaOOKj8oel/W3ypJZZ0CWd650hX+mofemGU9slYLmcZbnLe4RlUyBIp9rlnOQD8TzOPIu+9+SBxnNVZYiNKqb62UwKo/RHlIMmTly0/jyDAdmOa56JIOiLFM06Q51Kyyb847mqYlxll50WFWaogxdG1L17aEMHF9c81ut+H11Sv2hx1tU8AtUXnE+nxWkCvn+tyrvJcxhmGcGIeB1y9eMHZbldkMQXOdHBkPBza3t+w29xBG2m6l/HnjaJumFGOGvtBrvur4pab4rUHF560gkgjFnUVSxjlTFj/VhHSO4n1+WELomEGqbpo30Nr2YSW0BNrp4nlsFx2/W9AvMeQal2WxPEWEPpvsKo/WkTGFD6IDVnLyXpnKy4A4Bd778H1uPvgErC1TobkMYpjF07omI5JFSe4pE6eZ8ZDYm8B23LHZbjDG0feWaRzZ73akGHXy0XlyNqzW53zvBz/k4vJSOVnOcnt7x3svPub6WjUfnTOcrXpy12gbdT8wxComXbQ1l41CiMER58Cw37O5PzAdRlIIWKsyRa5Vm7rbuxtCTvzghz/iO9//Ls55druBVWP567/3u8yToq5XV3eEeWC7H3Eu0Oz2bLe/fU/orzqcs1gHkpNOXqYMou0eWxYLX52mbCKkk7gpdAHnPF3X4yUUHb7698v/jn9cSq3j8ln/JpdpebI6ioi1C7H9wYua02jXYaLq7pTFLG2uKBlDdVqqbV6LxMz1yyuGVzfM86x8tpzwxuCVQMjRHorCwwGbIjnANGSG+8R2LK5l06RonQib+/ti2KEJasrC2dmnPH/zbR49fsLjp4+XhH673fLy1UveffenXF6c4S2cr1e0Xj3dw33UxSVVrVhZ/N912DIyDAOHZk/cDTAn0jCXWYhYWlqBn/75X7B6+SlZMo+fPOGHP/oR73z/e5yteqwRxnHPzc0VH370AdM8MaeZjST+5Le/x3/lUa08Qwg4VYjSgY+SmznvETMhJOrERLV3ttbiradtu0X39wuPWl/DEVkyWrQv3HprtCApSaXUZf2Ew1y/VxFX5Ji4pYzGnFM+YAZVYLBlgzfq2S45kubEsDmwvdny6Z+9y9o6ZhGyKXw2GnyhY2nSUz5DiuRoifNM3B242d3inGW/36vrU+lU3N/fk3Oi7VqatiXEyN3drTo09T2rdcuT7pK2a8k5cXNzy89//tOC+mcuzs9A1JlQpLRBjbblVXZNCqVHY3iaJqZmZDCO+yFyP14hUTWCc0rKz2vgp3/xYz598QLftbzz3e/y5ltv8+jJM5qmw4gwjgdub664ub7j5mrGmEe/8fj7uuOBzJjIIoMouSY+dU9W4EqN+9RBEtuUjV0HiU0BPaRV5M8XYfq6BuvxeQBNzBGIkpNzsdbSeK8UAWsK//QhsvrZ9bsWcCEnpS9ZhzU6pFTNhnL9TKJxi9EiOKdMjpnN9o5/9o//CeagjnrVCcoW6qMzxwRVsp6H0kUSYZq4v79nOw3EpNa2m82O1dk5IsI4DmSUstCV4cJp1A5tTvrc931L27SsVisOw56PP/mIYdwzzwMXl2ekODCOI3MIem1L9q+ugkVrOWUEp7KhGPx2x5nxpJuBG6NuXGGeyfNMkkgYLdu7O376F3/BlBPP33yTp8/e4NGjp/Rn51C4wdbym0lQK4SZc9KprKJ/uJDkTn7MGUPrlJCcpQjQi3I7pUyyG+uhSLxUrmuVRliaS+Yhb6Mmj0dkLGqrslSyKaVlk/ui8xfnCLlOtx0/E1DaniWdSAkZIx+/9zG3H79iuNnQWaO+0ygP6uElNsU6Uh8MJ8J+u+FuFqa15+7+rjyAKvgupng+T2MRwvbMXcuqb1XI2gvGgUhmDgdiGMlpRpJXtISoFqfW8ejROXm7oxkMwS55DVU0uzIWsiTGeSSmESnOX9Z5xunAq1efcnX3mpgTtzdXbDY3nJ2dIwJPnjzj7T/+fX74vbf5yU9/zt/9e/+Ijz/+lGGeEMm47YFPrl//UiH1V3VYozzPWCYYy25ZEBtdRL0ryF8jEOYFuV9KFxG6VY/LlqZtFgWAXHWb6vMBJ21HijrvkYRfq1V1W1HUQYo2aNW81Z1fnw0pUJZOV6ptb1nt1Y2FYzqcC4JjgMPdhp///ENuPvxUW56N16GE0vZZu6qZVwKk8HdNhjzOBDMzt4ntZsM4DloMOc/hsCflyDBGQnB478gijIc9zsJ63XFxsUIwxBDIeSLFkRQnkEaHAkxS4Wvf8EbzhN1+UGFyo0VEAkQc1hqcM6Skrl1hmJl3B9I0K381Ru0mmIaPPv6A3Xsjq7OzYnsqPHp0zu39nnG74fH5mv/Gv/E3+MEPvstP3/05r15e0dwPPPt2UPm+9EhJ76nSNkrXpHc4Z2kaz6rvsOagxgTFYMOYMiiCxzc95xelELO1BcpixlG2xiI5VhAde+ww1Q07i677HkMsXL9UkCZ9wZP0oCRnFc3SUysSeU6VIFz5kYXBXehKYLBT4t2f/Stu3v+kUG8sU05EyXgxrCyKRFUktexBqTxTKQRubq6ILnF7f8s8TWqy4Tz7/Y79YacybaGlbVuG/R5jlHbzozef8+jJY+1CxcjhMBPigWHYYu0KTdYTq3VL1zeEsGKcZvaTDhHWAR+xmtAYlCKQJYEocHG436qyRGnNGgtn7oL33/s5pnFkY/jkkw/5G//G3+SHCJcXl4Qp8OrFJ3z04cfc390z7B3w209QgYXfKSUEY1JJsBRV/1V/xhYOYkPbZcKQj2Pt1FVW0X7TOjBRW9G2FPm1cNUA1dYzRQi+nMfSFTUsFr1CdVACK0fnKymdpFNi1oPucQEEMpkoym0+SkEuMBlVaQEMLhquP3zJ/sUVNx+/4ixBlOoGJTTG0pbk+HSeJhdYgSzEGJgDjJPSU+Z5YphH2tUaaw3TNHIYDnRdp0jrYWQ4DMQY+P0//Bt065Ui0KI5xt3mNZ9++iGQ6VoPElifdXR9S4yJeQ5s93ty4eamGEmihh4SS6GVMwNgzh+x224WzqmkQJoDeMM4dsxh5DDviQaePnvGW2+/ww9++Dv89T/4I6XKFTWVrzt+qQTV1CBJujiJaMvUUD4EdeOVZdO3Vh2XKrqjE2hFMw3wpTlZuXeniaWyn4pTh6hw+hJ8Jehs2f51cUa1Rr8gN10eAhHGadbAssfhEK1uSnUlWtlv7+54/fGnxM2gHvRGyOuOPEQV869StKVbILYkzaKE5H2YuMmBZBrGMC/JwDzPbHdbjBFinIumZEYk6EaeJlJuMUZ5Y9vdHdO8J6WJOUBGNSSNNYqONC3+UB5+8eCiDv54de5oGk+/blWNwEWiU+UCYx3WC76z4DJRZgRht73lo/d+ztnZGev1Gokj1r3F82dPaPwfsttO/H/u/j4hQsrCLIaPd98eP/PPHnXDioUeIUshsjRYlrirrUXr1G3JiMH6Bu89YgTnHTYd0QAoCSafbT8V0wgRwC3o/PJ+lPdR8lKZ1lRM9HjWbnk1rCFbwxhi0fIzDxbTRShFhBwScT/w4ic/Y7i6R2blgWdnIdZFFbUpLl7ZVcw1ZNVA3Q97blNk6M8YplGr6qzc3P1B73VOgSBBebrGslqV5J5AShMYByYxjgcOhw05j8zRFT/sSLWN7ZtGF8oQ8d7iRAer6ii5djgy3VnHmCPhEIlmVi5ja7ENiE3MaSQRGIYt203D9u6au5tXvL6+YzgEGuP40fe/yx//8R/wx3/0x/zpf/0v+K/+5cifvPh1R9yv+SjVuhb5akOszR9FD31BqlNIqmUrNXYsNdKb1pNlxlq020VF7D+zWBb5msrxyyd91ZyLfFUOUFQupHCVc6qxe1q2F0zLOnCOOUZEHFmySotlowmc2JLP6uZoQuSjv/hLdi+vme60M+OMobGq2Swp05usyQbVqEVjOBYZnXHKXG137NeGwzSqykg2WIkM41C4+yr9Bzq0teoaVqsGZzNCKJcmE9PEdntLjAMxFs6gJKLMGOPoeo/1WuBN8xbrSp2AFCBAZc+sMxivjl8zAYgYJ3ivbXwhEcNESqo88fJF5Ps/+D773VOsUVrCzevXzOOBs3VH351x/S2I3ZwztilDwqVYr/bCIpAqNUM0SW0bT9vCdr9XxFuAsv/mbBF7pLZlAtaLCgRw1KzVo6g3lDJH01VZhiQxZVA5JpLR+AhZGMdRdWzjUf/2FKjSFgUY77DeEULG+qxGGKKvaTOLNa4p52VS4nBzz9VHn3L3yUsImbkUdwa9HrbIQjnRLkiVyFQec2aeR65vBrbrx+zGA9M4EmZVl1G0UwfL53ku678+wzmt8N7hG4N3YGyRJ5PAdntHjAPGCCnr0FSUGYzBtw7frDDWsDlMD7DpU/MgI4KkyDCPiERyVoUicsQ48M5qZz0H5unAIYTFjOmtN99k2u0QgXE4MI5fnyv8wgnqKURvi92XLpB5kUDxZdLOFMQnp/wgATTOsV6v8K1XXkkGt7QmYeFxHuPv+KuUimi5fEeEkPprZpFOqM1V/bdWS6cie1DneY5tKVNSB31DK0DWaf95nMriJiSTaBtDnjUuVBbyiBjoPpKP4uZG1AZ10paHs2ZJJKZpLOeven0ilpwim+0djw6XuEYRjN1uz+3NK8bxQMqRGC24pPJelPM2Qtt5usmR8eprjUpQeWNpvKPvOwzQ9I6clVsrRhHw9VlHd7YCr/abcZrIeSbOluhhHDzT4QwuLnj86Jw/+qPf5yc/eZcfv/s+wxTAaPvt23zoxKLu8qaEQm2RHu3gjnSNWlgZlHfXNF5j36icj3UPpLz57EYvy3dkaQfpn7Tirj8lkosOYN3ga98UMLVaL5xpEV2kyt/VNdVW/xApj0xK3N/ccrjfkMYJUiYgdJ0n5xmJWkRSBwOLrpAOn2hZGFNkDBPbQQuqaj1sxejkaEWei5qF90ZleOKkBVbqEZnZHXbc3V/pIpkicxj1mmSd5hVjsK7Fe6vJqVW91ylUG86io4qwOluRpgkc2LYkK+iAVtt5nrzxiLmobpyv1xgiN9ev2NztmINOtDoPT54+5kc//AGH/cDH9x/yn30LNvmvPmQJCeeUE1Y1HGtxvwjJi1G5ndKVsVaLeu8tLltNkurm/YWVfG2IlRLOmpPVtP5O6TE1WaxOTEA5T1POTaVlMAUYmGfEdAWlNeXH6wZI6S5kDrsdm9fXzJs9BHWQigbl2kYFSCQr1Wx5JVOpWbl0ETK78cDoG+Y4I6n4EWbDOI3L58kSSAmMFd10c7VuVqrUNI8c9lt2u42aYoRJqUJkco44C8Y5HKYkmsprjUVTOaWEbxVdbLuWbtWR8kS2GWzZK6zB2MT67Jz+co04y5wTjXPFXVFNVMI8EuIIkmgaT+P8t4KDChwTvJKYG+RkMLR2PMv9qpQRY47uSIUrSmn/WmtwxiEEjWso+/zDOfjjex+R/1Pdz8oRVv61FkcxxpOC6ti9rb8//Tg5qwZ068yDt61I6nGhz0yHge3Hn7J5fUPYTzRGhfidd7rmR5XuM4shzJFKU7vHKUaGNLDZNxzmQVvoQVvuOuRrS6ctE9Os2vLWAAlvBSQhEnSPz5kQJ6ZpT4yTvqVNCvlJ1E9gdE1oWo8ZRpw3+GSL9Hb5cGWvsRbW52sO871aaBMxJuOtwTqhaVT/VtXxMiFMHIY92+0903SgbTrG4cB+t6Vy5b/s+IUS1KPdprZKvff0fUcSS7YWb0TFdFuvF798rur1TGlJOuvourZUzccxECne76cdomWjrt8wfO5hPC7UslRtD1r7J9V/1RasclQsCFQ9i5KcFtAfEXX0cA7fd+SU2AwjJk00lAlu85nCC1jE2KVqpArTPBfagcEZQIoP9sK71QDIWdHSzeaCTCTlzM3tDff3t8xhRMgkiZpA16SlJBRt6+j7FuMsTVaBY4MORriiC2ms0PYNKc1EowlHlkTTWs7OV7SrnjnM7LdqQ6iyFYEYRsb9lnE45/zyCd//3tv88R//AVe3G27vtuS2IX9NwP22jyNPrnKpDa4gzEcBfWrlQy0lrLM0rdc2stNyyqGk+SPjqRZWn6d9VApBTSrVpCKVLFg3ZJUue7jJ11/0qybDZrFXrEWgxk5tOpWNPmd2d/eEecaUgblJEo03ZAfHCq2WOCXxMKqNqiiztpWHeSzyULnoAxtMSsXP/OiIAqjhxX5Lt+pw3hNi4Pr2iru7Kw7DjkzW5NbVuK38NE2gmsbRtQ02q/lEFYFXrU2jU9+to+kcyTpkKmoaNuO84fHjC3LjaLx2FZrGcXd7xXY3EmOZ1JbEkydPePr0Kd995y1++P3v0P7TX0OA/SaPcp8q3cGYuvblJd5qfFujnSpTUFXni64zilbbqlsqSwlf34KTW7kE37GwOoICVeRccl7W3OW1avIhDzl+OQshRKqxir5FLcBqQgvkzPbunmF/UMUCAGcJzmjCI+BSRXdO4ApT5bIKoiTCFAPDrNJ7RgSxDsiq4rJ0TPR5FLEqQzcdmKcDMfRM88R2v+Xu/prhsCPlSEizdlaMoIaVimJZYwpFyNF37WJFnZIsSi1t6+n7hjEEXFuQ8JIAiBGa1nFxeYbrGhJC4xpWfQsipFmHVU/7ilWO7NtwnA6b1tt+5Pfr/l6WQD0qOleSUUxRNHG2zEaAE02ebMl0l61eTtbck2S0Jr/mJG04uk9lBYFKUZ2lqlOUf/lZBJWC/hbHttOUqcatGgKVdr8Iu+2Om9dXpO2IyaLmLhly45Eci+xkHVQ8jmMvglmFpx1CZD8OjHEkh6QmR8YW2UmrlBAjpBSwVsjiEUlkibq3ly7ZHAL73ZZx3BNj0IfHFvH8KqGJ8r4VHFCgMWaPGO2Oq5IFiwPYxeU5835PnEFiLuu3doCdh27d4s56pFG+r28sIUzM00DjHfM0MB4OGHPxlfH0jZykDJ8Pfuccq9WKJ0+e0K8UEm6sYd0auq7BmaJBVjyDqUyLYr83TzOCShg4Mo0Vlf1I60XqZNnQj3FWJgHd8Zul2sCoVaWpRCc5+XdyTBmsaCupJti6KNjFSccuDkrls1vo1x0Xbzzhsj8jhpm//Bd/wv31yFvdmtZ4DcDCPdFCsbQ14lHgXCQT4lxaSlotW5dJSRc27QxV7crEOOx5/fold/e3xBi5326WZ6ZW7jWhrYNixgiNM1ysV6wFIpSWrGGaZkSEu80d7zx7SrvuSBIwTuitI44Th8Oedt3RrBqcUzFjESGRmHOgT5Ht9rbQBDwXj57z3/l3/22ubu748KNPuSex89+OhfKLDmN0arhpHM4ZHe5xnq5tlUBvtXDIIZFDLBP8+nlccfLp+16/lVNpzdhlwSzTHvoHo0WOlJ5WRWNPNflSyrW+WNAl/bv6I0fErHyCsvgW2zhj1PHLWPLiR30srrKIPnvWYvuGlFR3N4SBhkhn1W/84bNShhBEUZ+aloSkbilZVJZHheMpEnF1OFLbVJvdBvNCEaphOHCYBq6urnTytDgZ5Zyx1ukGb1TnFDK+sZyd9TRtQ8iZ8xCLi4omL9M4MYwHXANnlz3DXp8rZ5UTPgblYPVnHedn57RNgzGG6+tr9ruJkFLRlMxs7q9YrRtWveP3nj/h3/mNRN2vcCyFb0lGDGV4z+AbFDk0haZjUB3Icg+MsKB1q3WHa1q0VM10xRRCMkjhmNZ+U1WcOsVUddN2peiRZeglFzJfYfcVRv7phktJ4KwKpFOeE+tOMpTaubJlk9RzkJS4v74h5UR12pHGkr0hScYJtK6oVCyIbuHPHjMYrNHE8HDYqcc55bo5Q3GcVoDAVMTOMowD93e3rNcrjLHcbm65ub1mu90whwmMqtfUJArJpDzjxWFtQ9t6zs7WGKt0hliulzMeKd1E6yyrs5Y4rdjHCbIWHtlkhunA885z8fgS37Vcnl/w+MklOUV224nt5p7G6QR8CIJI+xljkt/OYZwiZsYKriCNzjkaowmPrhFRu1ao5jmiqihidI01VgdQ27bFG4MTNV3omu5kISwDSeQCcGlHZwnaumbWWC6xoOup3i/Vac91235QYMMJgopdeNN1IHoJsWx0YApb+M8gKXN7dc14GLFBZR6TEfAW2xhyMuQE62yWPtkyQFvWXjlZg+cYCHNQ3etMkZIq6GuRNjS1K0gm5pn9sGMc9wiJaZrZlKn9zeaOkJXeY1LGWg8lAc1isLgiX6aFVS6DizFFPCrL5UtHpl/pukKcmCQR5gkxWQepTKZpHW+8/QZioG3UJvbJ4wvmeaBxljAP5By+Nm6/WYJaC+BabaIuF+cXF7zxxpsYZ1ScOSeszFgSloBB/crr7i0U3lEI3NzekpLQGKHzhvPes9s03HvL44vLZdJYg8YfK3uAY729JM+q21iIzosWZ5EI+oIEu+JRdWrNnARlzTWMMfi24dEbz3j+6DnvvPk2+/2Of/Bf/xP+5r/5t/A3W9xugCGUQCstrxJkJmv7ZwozQx6JolJaOWuFn03ZYBBMWewUVdJJxt12o8lASYh0mr9ytSree/KrJJwx2FbVAKxrtL0kmXluS2DDzIzrDL3t6VYeL4bgLQlhPxyIZE3Y03FTrEhE03vGac9uf0vTdrTdGf/9/96/y4efvOCnVy/5h4errwup39KhcXy2PuOtt97kzbfexojgLawaQ98avMt4o0xRrWyPyHaMie1ux+4wkEVoEBoS5vKMJ+c9502vsZj1Phijw1e1kWCkRK1QJvV1o0eMOp2Y2ibXQ8wxZpeNVzExDHWPr8/Acb8/La5cY3nrnTeR8ye8cfmEaZ75z//+/5ewHXm7P6PxTp3Lgi7WpjwMJmeaBDEEgssEMsM8lwnsrDFmlMRiyIUiUXSIvcVIYhoP3NxEtrt7baXVoRerVAlrBevKgpwFkQhGNZTbhuI775Qoc8ILfv36msO80cHLvqGlY9U5PFYpOMayGw7MVri7v18K3XmeVWbGWIzNJNmz273iYudZnZ0xNoF/8JsPwl/wEIwVmlY4O28wriMlvebnK6/PrlftRES5mKrMoAloypbVaq0IUDFHQCLZTEyhI2SDsR4nbkFETUGss9GuisY0S2J1eiy5MzVJ1E1SjGPhxJUYdUbxJpGi0FCSDDFH3jOUJNFo4nxxds78OHPR9cQU+NM//zN288CbT59w0TRYb5BgSEZI1ViAMh0cCypEkROMGYmJZJUP6jFIBTo4Is/GOVKKbHcb0seJu80d261KVKnudca5RYBguU/KPy/JmXGsWk/TNkvKjuizv9vt2O23SJp5dnlBv+4Jc4fNmcYoR30OM8Owx3WOJncYycxTZDyMzNOsNsulRd33HdZ0v5nw+yUOYwTXGNreYXaiXGevBZWrl9uUrglqpekaX5BM5UKena1wbYshYbLq2bqmrnyl11NxACtlgv40Np0WPV9AN1t2eNHCuPiscyzLPhPjppowSAGQ/AIofOEhmVicxUzbkGLmdrehPV8zxgmH0LnyTC1s2SrhpOoPRME6S1tsQ8M8q2yaMZhsSVR6wAkYUoC1cRq5uXnFT3+SObu40MGq4cDhcNB7447DwJiMwZTBMYOIxzrHum9o2wtCEuaUdWi1uB+mlBjHkeu7a3wD7aol50BOgab1qtxAYoijIrtti2ucdr28Y7u7ZxxG9qUT8XXHN0pQj+2ZY9taJ8OE11c3OkHaeazJzMMWe+ZwfUOVrpGUgGJ/mkERP0VurDXqzmM90ziyvbec9avPtyxEQ9p+UQu5JITZ6CZ7+hOnG/fCgzVKRl+tzgghEr0pQrMnEH9ZJMUafN/SrXqa8zUmB6Rv+W/9O3+H6z97l7v3PmIcbyCrjWKdFgSwSZAkjGFklBHTN5yvz9lstqQsWJswUqQmyiIdo042p9wSk7aRrbVIjljnta0ELE09Y5aNBTIYdXRpvaPrO7LAGGacE1JScrdxglgdzDFNi9PRQkwWYo7IrNqA1qjemzGATWATSQLDeKAZWs4uJy7XT3j29AliHBsr7P/s/a8Lqd/KYUrStlqtiUkTwBQmUhgJUQfX+qZZvLdzSkhOZVikcJpz4esmHZ7qGh3Gu7vf0JvE40fKvX7Ij+IhHPXg25XSYsDYE/TKPKjotcqvDFOLNSo0vSAJi03qscASowLn60eXdJcNbz1/i+1ux8HD//B//D8ifHrF/cefMry8WhbbnEUH/KxdUKoUI1OYGPzI97/7PT558Skx6lCiN5aUdHH0TqdyjVGr3pQjLjsl4qdQkugirWJtmcit96agzAWVBm3nt11P07bKh06JmCKPHq2VMuNyUa/wuKBWnTZpQrLZbenkqGEL6pvetg3Ge0QMKU3EODCFDU00vC2B/8WX3Kff1lHbpet1z/e+/13meSClgEiitZmz3mMJBCIpjKQUNUkymgzlJGw2G6Twq00SGptYt8J+d8a68biVRRpKCZRLrvi5CNbzqQ2tsv5XhyXJBa3ELP9OFt5TGV4Rbc8ac+wUVfCjdgpqOYgx+Nbz7K038JfP+O7zt5jmiT/94GdcPL/g8cUlzRTJ++E4FSj1eUKHl7IObqWy/kpRUstJHQCdTSARsYbGmkJXawsXXYX6p1FbyyFMS7LjjA6bVuteTUrBJBWYRxIW5U+3zmO9urnVgUxrNIn33pJMxPWW9aMzbFI7T7KSE+YQORxGfBbGYQLZEGcdoDSSMQ6lGkXBmVndkH7bhwPjDU3nOTtf4b0hpZnzVcu6b1mvPMbW4l195lVRwmjOWmhQh8MBxoHG6mzLTMIkYc7PsKZZ1GlMmfM4znoU1PMzz/Gp6ckihbVwtzU2j9QUHgBWn2NO1HyocsTM8T0sgLU8efwEoS8d18jrf/XP+eT6Je88f8KZb/Q+i11ivj5Py3OQKzcf5hgK1zoXUM7qoFbSD2owZTjS6VAUiRBGtts7pjCTUiya5ToI1hTuuinxe3yo85JjeG+xYmlay8rYRVHDiBDmQEyT8rS9xfWOznR4b2id0+FG5xYqj8kKSI6HA/e39+pah2MOM+PQY9I7XxlS35iDenqD64R+SipNMI0j5J7GqVNP6FqEasGnkh95IUjrXan7k3e+iCTrxG610stL9fNFsPspJirLTeZkoVvw/ZPDGW3h6qKYCGHmk08+5e3nj/GPzulbT51Yk+XmWW2jOkPyhtw42otznr/1Fof3PmXj/MlZlCrsM3zYFHTaXhqnyBAssHoNu5QzRCGJSj5p20jbnlAGEbItlWLlPh3vjN6TCFk3f2c72sYRopKmjbE4p5wb5/VcjeiXF6PclaT3CdGNyjhNUFWUu9q4qmdwiBPjuOf8bKZrO548fsTjYUeM326tnhgT4ziTcsbbrAnYPCAeLtZK+agastXSsd7Hik5KVukvZx1GpGjPWR4/evywuhb5/Gr5mUNqd+H0dkpltdb+Ux0wLIum1Tiaw0zbtJoMlNeSshhrV9bi+pbG9vjzlbZ3Ly/4vT/6Qw6rT/jgMHF4cb083Kdc7gzYrEljyoGYA0+fPOPlq9eEFPQZLRuEyslE5gCYjGt6lXrLAROFnCJQhMatTnme1FdQngGRhCmGAdYI3hlWXcM4F1QaOD9vVZaqcDBtVsUAm9Ap8piIOcI0PthcFl6cNYo+W4g5MM0jbezYp8CHv2RM/eaO0r0qBg++TDSnJIR5InqhcVXtFuZZKRTgl80+Fe9uyZoQeA9GLONhZOc9JsPq8WqJgWXz/uxR+X5lfVtQ7byklWVjrxf92NuxmIUqZgq1akEWK3JZ7o/Uvds6uvMVq3XD5ZvPGOeZ9RtP+P2/+cc8NZ67Dz/h5ucfLAjEstGbutnruUhOTMOEf7QiZ1WnkJSXjoUg5II+5ZwhJ5IzpGxJKWhREEM5z9LlEgMnMl36qFV17rxQBZyj0AQM46RSfKuVLyY1BkUGDO1Kky4nQKLYq0ameVKN40IFylEKjUOUg+1AJ6kjiwj4b/EQjsjf+mzF+dmKnGYaB603eK96Es5Qpur13I0pe2JWJDxm7VJ5Y3BWaGymyYZxGHGtFqV2ud4nqOhpriAnXzWBLRQYd9JWNsurLI12KrprcKWo1s6LLXSYB8op5thnwxpc47h4fIHvL3j++BlzCLQf/SW/8/23eePynHm7Zby6wRS0/DR/kWW/0UIrkxjTyMXZmTpRTlM5/4ZkdP5F18pqOqCKRilFYpxhruhoURkqEoJSbJRZOiamgHMav9Vy2zqHb7tiuqAFv7PCWWoRo9q1trV4UyiBxuCiLch4ZhwnVbVAwQnHgLqMaf4j6RH2a+L2myeoJ1n+MsyRBW89u8OAt4bsNcNOyWuzx5jF7UMe7MBHDbE69a/OPVkrTkMRhS0DUw9C72Fyemzja3ApUb/gUMYsa60xxTrNaqDlnNjtttxeb+n8j1j3LRdnqwV2r0EvBrKFaIVgMslZVhfn+K5TbbTalq2/yPFa1W/klLWtFfIy3AJ10lQDPqpiF1YMXed14cwJ7f/aYi5Rrqetld2RMG4oOnNJBY6NyWWiWpERb0WTL6FqshS02eDEMs/HB89Yg/dK9K88Te883lm9xiYR08xw2DOe7WjahvOznsuL85PC4rd7PLgHVIK8YRpnNpstcwicr1vIgfkwII1B5EIfrlwl0mqOWTjFtbiCxebRGEOKUa1HT7JTqdwROV0Ev+A80dfXuDs5aq3DUYZERdn195KF+/sNrb+g8xZjNGY0OdVENRswXoX4szPQei6ePuHxszdYHxLXZx+dJBQsi2TOAo7FbKIm7OvVGm8cQWIpInUCOQnMUXl4GOhXHdXiN0gqCBtL+7aqEVTdZFMSm5wT2nbSDNKaTOMdIQixTKe6lVdqzCLybGjEYBOESTc4gJACzhUqkFFKkvNW3WmKYLfKC+nCfx0D/7/f/h7/BYeundvttqB2mRRnDtt7PGvsuqEOfU6jShPJ0kuV0gUsRS2q5NF6yzzNbLd7LIY3njxbYqfukfWomEJ9OVXBOHLksPLFwV0mlBVZqkmqIv2gihCVV6gSaxwfn7JvmMbjXYdZNVhvefTWc/6t//bfYTXM/CRkrn72wUleIsu1SjnhivKG5Mw0jDRPznGt0pxinAtSWxJUUWHyaQZjMq6xZHFkicQoZRjFFlk3iz3pktVCsgq/V8tj7XFZzlYd1jpiUOefrnPH2cRitmC8wwm4snnHMZEkIUEL6ZgSVrSwMOiktDE65HLUcPrVouzXcVRBfN/oMGnfduQ0E+dDaQNnrOkUaY8KEMUYEdeUdac4/aGUoEBWlz9vSM6x3+xxZ4ZVbzid/j5NU+thTr+kDnxWMKf+r/6wSmQu62d9FmquYmzRE61d5CP6/yBurSoQrB6dszpvefr8LeaUOH/zDf7m3/43WYnwwY9/zPsvXwPNCQBR89KyT4modmyOTHHku2+/wyZvOOwPWJeLAY8my86BFP33lBJY0c6VqCVytVtXgMoer9fyzGgXu+4tNZ+yxtJ6y3rVEWMiRCmDXRZje41Bn8u8lYPGqGRWUm3ZjDAUR7aaUTnjSFHd2Yw1eHpWXxO33yhBrZOa6uaSsEkXAu8sjx5dMgd1eNnHEUkjTy76ohOtD7VvG4glc67XRaS02jVBNU50UyrkHqEMYHCc8q/4qQHkNMDKXy4SEbobFnHkk8TY5MXmzFnLbrdjc3vNO2++yfwsLidXJ+tqsgmA80QMM4J4z5gzwzQWGLu0KCqnRNAqpQj36kavG/71zU2RzGF5IBKijj5VT83WgbKs1bNRQvM8q26rsUZdn8piry3pqkOrp6uiz0LTWqaQ6kUHe2ze6TxZ4YYRF7tV5zyt93SN12tlXGktF6HjmImzZRz23N++5uLSc37xmFWnarTfhuNhMXU36E3cAAEAAElEQVT8vYi2Pucpss8J74R5DsWVRmMmG7W8TVnIZfEwRpETRX0sbdvhG4P1gAXfNsQcl/c4rpelWDqt7s0C/JxU0XJcNO2R8lGRU2dtSVQhxZlPPvmED8OOv/U3/4hV15bXWyADFmF0hGQhGEG85ezxJSEndocDIcw0lGGF+szUpbnoGqfSJjUYXr96TSrT9oqyavxaq9cJKVzD8iWSybFO7VpiDJgc9O8bW57jUsCmVIopwdsG2xmcyTStwU7K1caWGHeKLpQUSO9XTogVbKPuRiTBOeVsO2vo+5bO93ivA36N9zgDcZ6Zx5F2nvjjX38Y/krHaQt8s9lgDGqz6GC/23HeO/quausWW1MUWdI9sxQGoimid0ZVDTylANZBvZAix5X2YX8KyrNUf63gRAnVlI87zHHDLYMrRt2e9MMoWpNz5vb2ljht8N95TuvPqunVET0qVV2N3Uky0cHls6d0Z2su+3NW6/WJvE95irTSUcTY6OeaJar/+G7P00eXNCGSQizPhiL7iK7N8zjRNp6+7AEimRjyktCIUw3To6kMJWmXkhBkZUKZoqVtDW1jMM4gEoCMV0su5fiXQaLFYCAbcog6TCOxmA1E5QSL4Gyj7dy2oes8bdvgGwfBVi+P3+qxuL+lTAiB8TDQNIZhv0HiRNdYHp91WjfFpBz3EBFCSf7qeqCv54yj8ZaudTTOcH19o5deKPeh/uznY/b0WKhP5YXzKep//CmdSQGQstbWLbNQqMZxpLGerlES8umaLiiInS24rsVKC73Hm5Y3f/A9vvvXfsR5hu3r17zPcZagAmqCztFoLOlzOU0ziczjx0+JMXF/f687hdE8Q+nfQkgGZuU/N8bT5KZYoR9BGmME69ySiC8dkZPLIFlBBs1BPM629J1nr6P6GJtorNB0re5PZQ7CYrHisbkMGBcazTgfyuZptXNW5ZnE4nG6nv86ElSEctHS4ryAUWs95yxd3zEOew77AYkDOT9TxxOg7TrefOMZ6WZHGkMR0tdMtV316mnuHIISZo11HIaB7XbLQtxf6ho9mSMk/ZAzejzdgpqUfn6Vo1BIPOO8Tm63zhPHgdZ3OBpEbJnqLC3V8tSIgFhDlKTtTWP5+MVLXl/fMB8G1nJMJAoAsLR/rLG4bHBJPzatLUimtpNMtsVpUqsv71QPdhHPFm27X15esN1uSSXLT5MOI1hbJlmzLg6td8QYFxHfvu/J20QyqaAaWRfGUsbXylwk4psVfd/RtZ22V6iJ0Wk1qhWe2rnN5BwI84EYGnIavmKZ+Ks9HiSnpcUhotZv6/WKEDPDuCdOB6xMNK4nxKxVcIlJShKEoQw/FTkXY2i7Bue06MFajPPKa0UK+n+00ltKqyVej9+Dh0tlAcZx3iyJtTU6UOSco/Ueb9WycXN7zX47Ep5mco+2bxGKDEYF0BBrCVkIwNnlBbth4PXNDYfdAf+Asf2ZawgLiowYPvrkU9UlLRt6iBHfFJmpIj/iXVPiWwp6p1ze9dk5c4xqGSh1cMYh2KLHmxDUfjUXx5iEsFr17Pc7tTFlseuAqhpAkXjxFX3JavtnW7qizGARusbhncdZrwWXFPpiSkgMbEPkn//KUffrPWpimJf4hTkk8qj6jbVNLsaQDEQySoTICDr8YU2jLUAs3lmari988oz1Ht+0xKxDN7laN6sIpbYEOW7woG5WKR/R/iwVAYdajB2HnurwiSbN1ung1V/+5c9xBC4v/i0uz85KcVWMWvTdsaYU3gadgnaW/vyMVzc3zNEwHEa8ceV9j0hUzVmTCLEUmZKFKQTuNpvC3yxOOYbiMgRYgzcW65vFM77KrFGK+JxgGmdwAesbaschiZBCncmun8FwXhRZ6tSAllWpnKp2EMTWBKUkHDYjJhSpllzoAI6+62hcS+tbuqbBNx7nHd5ZcnQMv9bI++WPEALTPDGOI2GaWfVdmUKfMaKfMUkm5ETIxYGSoy6qtuW1ve7Lete1HueOlJAEhKQT4/VfL0EotdyXk3NKJx0tc7r0fubIRUuCEsaVRiDEMPPBBx/w9puPWbWetlk92BfhmKHMYaZpGoIB13qevvmcm80dq/NLnPc0rtXEbOn2coxblAKREdXtdbDbH4gp4RqPMfbk02nsxRyJs9B4LV4UKc0KCMBSSdkYVG9Wkxvqc5OyEOswu+ge753aV5uiymBM2fcLPcBYRy5dv4yu5VjITvMMk4E682JKdBtdC/q2UYBAPMxfHU/fDEGF5WFc+D1lo85lIi/GpK5FWRCrmytF+kC5qpOKwiuwiOp31WxbKxa1M7UaTFJ0z2S5f8sCdloRHYnFx/O1Bs7Pzzlb9/pzWWWY6r3qmo7Gt8RpZrVe0/Ur9bEWraMstgx0nczIi0rtYAzPnj3jg/c+YHO/wYdYFiRbluLysJUqTLIK8HsgoDIRgpCSbjxJlueqoL4WrE7N12RDgHmOxfZRIYIsgNVKRRGvkn9WwbJyzvOsbaIkBYGyiuZyihJHnf7vGk/bOLxTtNCdPssPNqESDzkjaQaZyWnUNlb4+sm8v9rjYaWcS5LpG8/mfmIeBvqmVtZJBz+849GjRzSrxMu7HdVnV0QHIpqmLe39BKYUM9ax2+8JcxkIKnzKr6bYGB6MoxjKuSnpvdJolFJgMEYn5n3b4NqWYb/Fu1YlfMrCXlGlKnhOQX1DCoQUaZqOly9f8/rFSw77/YLkLvSOuuXnoi6RBZ+hczpo5L1bniddnOoGrxOuZimwZNEzzhmdfkXbOyBl+lqTKBFTFA0yyarIZeLIGav8akVvH16vbAxKu9dFwCD0bUPX9AX9l8K9dGVAi6U1uiDBOTHnyM0vF2C/2WNB/oUYIiFEpulAOOx5/vzpQrWorjnOerJ1S9SbslZbp9xP33hVRzFGkQ2niPNp96m2BL9oLzfmWHTVRGDZpEuS4F3VxtWfsla0+PYeZx3TqNaNaS5rbN0zayxWpAsQY1WmyRj69Zqb2zvCnDkcDnhjjmvSye+Fk/kVQbtXSfcoZ5XhlHJSGkG19cXiGl+moU0BZEQT/Sx0bY+xlmmedJiv7juIzhLEhwlq47VgVYk0/btU2sxSNIkNeqK27hrG6JpuMo33YCw5Q+ssfdfTOq+OgV7tbZ11RxT5i6bafltHKWBzzgzDyDROGIk0Ze9THuRxz1Mhh4KCapZeWtKNOkl5h7FRb+piparggya15RqXmF14gfV0CsBW+1jqTld0UcoapcBSoaLU3ONkCCqEwCeffIqVwPOnjzlb9yWR1vetuYkrC2otrJyz9Odrbu/vuTSeEBLelPyChyYvp7huVThADLf3d0zTSMyJ1urz4KzlCN6VwUN3qhOrKLzKzemzF8K8JKjGUIqjoyYsRYnClbwrxpmYIqtVyzyr/rqU9UHpXeZIz0K0tKyyc6JSbjaXtaVwz1vf0PuWxjfY1BK2Xx1K35CDeqxHFnHccsQUlynbLELr/CK4j+jPhzAXQrSujRpLOowSY8Q7o5IhS6VeruDJ7TsKrNdl6ISO/wWr6Gq14uL8rHCD9MJbKNPXHQbLqxev6PoeXyuTrC1vBXCOEH9N9moLY9X1bO/vidOMW6brHjRx9bNYnYDLJ8k9NThFq7qUBZO0PRKNK4K7QswFUSgL/TjNpcAp3EjMkoTUagp06EqMXl9jTNGeVOF1JC+mAKZCg4WrtV716j9frGeXZ7N+qGXHM0t3AElK0JegwsBhIk5f76/72ziOBhNHR6IwR+Y50DWNttHKtKSzKrbtrCApkZMtxUpJ/sxSbC4oIxhCKNpxJ+9bi4+H0Vw3+uN56feUmH5+tqZtm7LQ6D2zVoWZG9/Q+AaToe9XeN9ijVuKOr2fctSsLM+g6uEKfd/z6Sefsr29g3GiXz7TafSaxbLYSJF5KWfvfaOmDWUqVHnUVTvYlE1Zha1tWbxq265Kw8AJd3u5QSe/nDzr4zQRYtDnyBZh8qpzXJIlMULOym/1hZrSNsoRtqgMjS3E/2Mifnx/yRmbE09+0aD6KzikJOoAMWrbbzgU4W7q9VcEe7VeY7NjSkffc11stevkvV4TTmOXMsBTHMWQI0VAPpuh6i6+nNfx15IclyS4aVxJxIqvuNHpd0X8PLnpkDDrhlZ4l+oSZI4nVuIjiRBSwhhD23a8fvWawxAYtzuq+cviMFT+r3QkU0CVXLpE9flXPkEKQbnZUpD0kqyaotEqQpleLudS5heq85laZJvl+ZfKcVmE1/W8lk6OnNCM6pCKQW1eCxCBGExWnVC1jNRhgdZZurbBW6corzUlQdUkJX9BIfFbOeTheeSsPMR5GGi8sF61RU8Ubfl6h8sO4x2iIjGLe5k1DueUbmadUtDqPcqiw9gP07kjK9icbFwLPQWzhNUy1nSszpcEVUGmY/pRB97AMAwTh/1IinlJgo2p788ylIWUHkbpTDRdy9WLT7jEMY9TSQBleb86xGWKxfopxdFg2R8ORQ9YE3C1dq+DhfrsWecexG6NNS1QNUGdh4lsKlBn/v/M/VmvJFmSrYl9e1JVMzuDDzHkVFlz3aEf+o0EAQL8JXzg3yRANMC3Jgii0X1v4/Yd6lZlZmRMPp1z7Jip6h6EDyJbzTyyqqIqKqsyNODhHh7u56ipyt5bZMlaSyA4RUH7vmwJqvcgLlhcN+0OWtIphpvK5rnc35eeAeo8ooHgQX1iRdSVJSWmYWT0kRQDuMD3wVk/aNQpFhrSlGuy2oQk5z3jbtRqsl2CJ2f18cIS19b0wVdLUEvwOs7NKfqC9zah5vI9ta2vVc3WOHKdeN/TgMtP0zSy2+2ZxkGtkryQQmQY1Gy95Mq3X3/Dfr9XioG1g2rTiUsdJb64mOjM5lLVwL3mqma3Vq5L1T/ZrBEpztNiJFvynpuQm2jlbSh0U3oppTSyK1uSEdUvQtEHdMOtdVF+nRjm5gS/hXdfcJfESatNz/k494doDl8aQDohSivGIUVevLgzNSCK1G2f/JLEbkd6Tzj69KOaqXmhrDPr/D2Y/R/g0kNEF5hOjXKmdKx2+E34EDUJqjoNZl0WTsdZ+WrErbIHLaxqKSZWwPhsvbFnLdJe2fZiAjbe0UfFVj+fLAmNMfLy/iW73XQV17qZlbzgnAfxHB+eVLSUkhn16xKLHT1ol/fVRDdLwbHf7fni17/BPT0x5YLavVmSIX3TdjgbfLEJYgzliVEFDRTjm7WqbV9fCc5TfVAaSrsoXhHHsmRqtSLKEDEdn+ku6L+tZxUyKh/94fGBZV2vnD3EyjC2Q6Kh4sAhJsZhJMWoY/fcZfPsJW0/FAA6c02kMbTKn/+LReAPvXSv6AlqbY2cK+taNm6ndAqLc7x48YIPp4X1tKhgQjzqzVxxXt1SuuVOp260JhyPR/ORviAymn9d4hiworsDCddNVBVaqEH9QRNU46pqRiBIFYYYSWkgukBoheDNKk2rG0vWbEk0dS+prZJrIXhPSgNf/Oa33J5X4sMTyWLW8XGG1kVj6nxSiSJEhyLqUb2JMyvOoe4ym9UOhu4ZIiSdnOAQ8fazJToKO18K1C74Q8+lrifodlzV2tnN9wZtU59p6S1bo6KVwhgHUlDrqxgS0TvlHrugU5l6ke2vkqnv1Ht/iMvLJUkTgVoaj49H1vnIYZdwL+7IRTsvIUWGcaR4R/NBiwFDNfXxXXyVvXebCMw5R66Fx6NCbz1m5WpV63Vp9F/0qpeiyvUE0Sm1buPOywXXdB5cDEQbJxtDArzGQufKir1vCwQxZFQEcin4Wggx8uVX33CThfX5Wa0ixWiKVi3q5754veKscHaOZV1N3JmUe9/6nmwf1yhmutd6qiWWmDhdgbmwAVW21UJHT3HWrpAtZ/fepm2KmI+10gm6nWen5BiADC7SZypqCmef0SviHXxgTCqci6hXc+sCj3/g+icnqKAbVRWd0f3w8MDxdKbSSMPAYb/fTLm7IElaJUQHpZrQSggUzaDLSkueNOyIXjeAGBIxDhsy5T2bd14Pvt7q8z7ifSJ548eCGjZbW7EJuNoYrDXgnONwuGFMI1+++i3/5i/+nLaulFZZS2YYNHHWqYrdwKVv5o1aKnUtLBSklI0WIOga6htaw1FxFOdZRFhKJa+FNi/KG+2JZq36kmlm5VAIoY8x61xYC5qsG5+YRUl0+vqaVHoSE6ryvHLNzOtC3c6bC5F8e64CKUVe378wtKlnuGJVZWf/WtRt1WkXZwmlrORyhlVHXC6n+YeE1L/odU0W3wj866xjZg39ERGkFkUbS95+0JQzWavQvUpLqSzrgk+qDO8xEvoIyZ51Gmcy+K5eBicV7xriPfiIY7VpU/pXgk9aWE0jaVDlZXBuE7CllFiWzH/4X/4D97e3W3HVqiAxaNXdNxnUbQCn7cXWALM9G+eCy3ofo03/6vwvwVHs7ktTQ/A5Qltn4m6kgjpY1IpvAlJotVF8ZRgdKVxGG4IQxLMsCyFGXNCBENK44nsJVXQccvUObwjVmlcT4SjBv22JkfIDtYDTz7yfRvbjxDSOaglD06lxW2Jq1imWg2+ezCod5tSE//CvEIv/2Ouau2y/Q6m6R+VW8cFTS6AUd1GFjzB/mFnWmVqqoXo2LEKSFZT6PPuM+QbsYh996q5QMNkO9V406IEe8L5eshC7pnHi09cvub+/ZRiGKwQKUoycnmdKVh/PfJ7xu70hkiB4LfDs3TTLKrz35JJZ8ko0f+K3b9+yDxOpd9R16gUSnE7086LFuSFttTadwNMcY0yEFLWAWuzVe1XIN/FA0mS46DnU6VreOeZ5VpQqeKQYeNKFrqK7fy+GvO8OH2FLyGq3qZOqCGovjsw2qiOoADf7PcMwXg53HIGPx3Nv+4sl4z+GBFWLwKCFUdWO47JkdUIQ66zUqhPOdiM3eCYibz48byiz5kmXscch+A0RbbjteOrfD/rWuZ1udJG0plEXoAx6kmq4v1eq1zQNvLy5hU0A2LbivCGkpC3pF+4FN/sbgo9bgurFa2FlaHhrDhd1IFFpBd9UkPfFF79mP5+ZnhcddGLF56Vc0fvrIJ0TR3KewTL2FCMhBNZ1oZLV850+/No+ufNUVOArVQWrIsobn+eZOIys67oVVq3K5cn0JBkFtsTr5/Ap8Wwc2CpKP8FVTUrtRYg4nKjk0FfruLlASqNOEouR6JOKX71243yfEf/7TlBrq0QBaUoaf3p8JpdKSokxBhV3oFm1bx0298ToubmZKFUoVXASCUnHah32I/spmkl6McGFHbbec3Nzw253IMbE+Xw2NVuA5nHVkVyieOXoqZeY43Q68eLFC7DKVIqR40uGWvCGpL59+44Pb7+htZXbm4n/8X/495DMhwlFG0tdcRI2xLdKo6xqfpvsxTQsQd0QXcezwCPCc4O5CrU56tJI0W2bv2AIgzRSEfW6Q0glbnNxvehhL01J1OIhxrBx08SSEh8cJXhCU9S2FvVEa6UhXtTjFCz5duYmcFE6UzvWr+hTb8PKFerUn2e3GmutKULuIa9nltOPha5/fV0S1GVdVWD0+AQ+MI475UfK5TDXlLMTu+XKS04TKhFPXlb2YyKmAR8jVTzj7oCPIxdWnj7jYNVosaLDXjnRB7LTARbiRTllVjyICK1oiyYkFb6llJimHdO45/bmwL/7N39FzTNPx0cce4bhsIGgnXJSa8WPOu6z1sLT4yNlzTCfcaWxdwlzNrcnpVt8DQGXItk5ZlRglWuD5xOuv38UbW/iqF5nTjeZ8cEs3YK2IhU5bZrMBmsFxUAIVZ06jK/W60/v/Ta5Z7O0E0F8s1iXDZmtqH/kzW7POAymvpWPuypXQjCx76e1WNsGDXzWhP/Hj+KQ/7uvWivrkslrBYnc398AYgbcimY8PTwwz0fyWo3j7oBGwJPXhdkLITQCyh8Tc693BPV6JGxuRY4uXNFulnOiwqquyPUe6sVLwft+ICWzYNO9JaXIkAY+/+xzTscz796+48O88LOf/4xpt7PkyikXvyOQWyEt+BQRB2teePrwQBAY8eqoIULyYVtP7irJcyGQ28qSM0utnEuhzTOxDTjnWCt4ZyLIhiZUpTEME06gRqPKOLVSlCVr0jREpaTbPtk7iq1ogSUx4Exh3hCWdbXneQEuBH2eDqVo9OTAe8/9zQ373aDJKZ2Wwva5rr+nfuiGWJv2D34ZB95bwT+vmbVkgzk8SKAW9fEN3oNrHJ+eOJ1OGq8Ws7rHVkQK3eUD0cK6tYZHhyB8XL7BFZrCBUypSiWIAV96F0cXeoqR25sDn7x6we20J6VED6YYIk4cc8mczjPLaSakxO3tHcEHRTGvOq19txFEiykPuVVYM8u8kJeVhCeJtw6yXBBHYPPL9tCt0uqa8YNT7c6IHdyetRZ81b8dxJn3uNOOrPPkXMF1rqtDzfsz0353oZso1A9W7IMh1ziivzj3qPtKNTTWbYi0q2L7tUBTwaaXQC0Z7wPDoHld9MEQaotn41wH64Z/X9z+IAQV7CGWSs2ZlAaGYWCIHucqymNwtE3NKQwpgdfRirVCjAO3d7c6F92rhdFyfma4O+DQSRu3tzekcUccJkTgfD5znmcNUi8bpO69JqrX50stRnbdxoK6rR1Qa2aez7x794Z5tyMgm5sAG3dJ/06vcBxsnNncdGKLT4FWHbU5crhsIOIDEiPT/R1ffvtrHteVVfSeYvF6IJgCqRueI5pgY63YkhtpUD5X8l5tTBCKKMG+t/2avWHvFImorVJbNPsYbb9K1TbTRpDG4zwMMbEbRzU+BrYpWAJIo5sJfxfL2apLQ9dyzjbbOtPWHzMHVUULuVTWdSWmgWkIpORsxrIinr01B7DfDdQWzG5GWxVaWEWmMTKO2h7qs7lBNvJ+8IGXL18RQqDkzMPjoy70qptaIBB9BKwdKoo6VJu8pmWuGBfEKcLb1HYmjYmn4yMP79/iXePlyztuDn9Ksy5EcM1a/3Vrt5ZSmNeFkq24AnCaHJhFPirs0vksT7XyLDDjWGqjVWFeirXD7MysmlwrIqyeqd4XfFAv3RRVbCed6GQbZJRmn9MgkSZ4ufD8Ng6V85Siit3azaUN7PNO22sxKNKiLf3r5LRH70cnF71g2dZQazxK4//3rxCHP/TKOVNbxYXAaK1yruLUO6+DCprhRoacIAnniqr8V6hjJESngjavVKI4JDrcuclCbbpSR05V7KMHZHCB6CLNF2sLWgJRTVzVsL3Gio9aFVW9cVQTZN4fDszzmUfXuDlM7OOoinWc9Yo7kqafsdSqiUwuFFcIxmvzTYeaAHpWCnrO+EBpgewcqzjWJlAaRfKG0kpv0/vu9gGgAEkTr2iPd2rsb6heA5swqAmx887Eom1DN4NpD0opLGaurtSrzgnn8oxkw/wAGJK6CATX1yMbLcPAtN+5HI4fg1H/dtobHWddV5wLDHFPShNiYrJWG3ldWZdZxT9l1SmHzSEbNcmTV4f3TcEs0ZjUc9IEmd7jajOPai0mvPE0g+s8eo+TTo/QbpIi2g3vAjEMJnqNG2DTC6sUB17t97x585Y388I07rm5vSHEbmB7kSlt7CiUOxqC/plcCsfjUd9llY3mGIxOsL3TqwKkIuTWWGslV+2c1LUQm67pnBshVqUaOActU5uQot7EJrbrRSa2/zq/OR9g39Nt4I0myz7q9/BetKu8rle2cj0Fl493VFFXIhFHSoldSuyniSHpc/e9e0XfP6wb84+I2396groh5rLZ96QYGIagLfq6gtOZr63pQRZTZIcqfEtt5FIZhsj97R4f7CG1Sp4b3qyQvHfc3O5xfqDUxrJkzvPCav5e2+PaYGZ70PbftRZUuX/dctUfrTVKzqx55fb2wM20Z0ie3RS3CqYbp9sgNRyOPj2rGPf2MI44J9QMS586haOFiEwTh1cvePvb/8Zzq2R0bKSrkeLV6cl5yz/QHKQgiGs01BHB9k8kKjG60Iyro5/EB79tnMqzka3dW6ry1VrPCyzvdHayO2BMid0wmPJQtqDFAlhFCxfepJ0a9kcuKEf3x221Kgr7I72cMzGaCYaGKTKMkRD0GfZOWV8ywXv206AFyKqcvhgS425k3I1MY1QhVcv2tzRuY4rWDhw4HGwWutmAXclX6ZzIjopo+Op0K2TYviadZycNqYWKp9TCh4cPnM8nYoB5UYVsF330n8USwGajQnPWFnHwjuoxeyLjDOFM6OQJMXIOgbN3zAJrFaQo0i+GuveqvX8P14utueCDovwyaJKqJH9Tt0pjJG4CRtBDJrpAt/ZprZFLIYRk3HBF61zPX8ytwnvHNI4Xn1iR362muMT05XcvRH8RYRHhiz/8Gf/3XqVkBD0AUoxmqt0XtWz7k8cZrcPWfVWKVHCdFtUIYdim94lAGjTWtIbTNnVMicNhr8h7qZzn2dAY7QaoHqALPoEm5KzrQMzBQccCq0+tQ4ghME0jUveUWnjz7oHdlBBestsN+k768sDiCpDWXWIypRaWUgjSNu/iyw8AR3OB7DyrdyzesYpQKlCE0OqGVnb1cmtNwRRx4CxBNe5jCsqt624bTaBa7IWgXQKxwquv4xZMr2B2f97p6MfO/0PQ0at060MNPC224sZi7x6TPUGFLS+6oKj0hPcPD/9fCz7FzoQQIuOUtKASm0hkhXjO6lHbaqE1bwmqJXsEcoYQhNgF9U4THOcCvnMue0fKfhmMqtIpPf0fbzQVxG+te7Bd2F2GLCCXpnkIntu7G+b5zPPjpJSqGDgvC8413G4kmdAOZ/ut9K6ovt9aM6fTSXdy09+A+eT252XrznB0ilO/9aU1luqU458rxawOmziKIcHNqduE/q9+lqjmpvUkEIAGazZnDMw9oieobVt03kGpDR8M0JhnPdul29qx7TmdloM9SRFhSAPTOKqoLyg9xduADt8VNfbr6r4/bn8YgmqHgPdOEb7kbQ5sJtezmrxGR63a4ru9PVCI4GBdM34VYhC8K1qNh0CKyQLRIajJ/G4aef/wzPNpIZdqth8f30dHhnRCkxGTnNrqXEPXWBIsdoiF6Lm/v+dP//TP8KKTlsYhoPM/OoJjVZtRFaSqCbEAD09H7m5ekvaeNheWueBTUvQpDfjDDXz2glPyrDko2b9UBly/S6v89CrmBlDBvPTFFHumwKaZX6EYQd4T7eU6aZ12ZYugUUxM4VwAUUPqjgk7UQPtMY1Mw7i1hDfVbs/WuKT3+hxtAVhAXgzZZZs6tJFef6RXWTNSCilF5XkGwVFxTn3kclF6RwiRYYC035NLI/qMd4Fp2vH69StdoLXoCLr5zO0+UVtmGAfu724Jw0CIEyKN59OZ4/PzFR/qijLRAeuORDl0tKK0LYF19m77ZlJr5fH4SOCGV69ectgP7Hej2Z+a5RDhqtJ1xr0trLWySmMckk5Ia441WbKJqa1DgN1Ie3FgWT5wPgtLE8hVp+nQD3PjMjU0SRJFhcqaFaGvJnQRZ3Pi9WBoouha6gdLb3w6jE4RKFVH0k67RK19aMLlUME5Ao7kAy9ubkgxqe/51nq9ftJdHOW2/94evx0SSYSf/YtF3T//KqWQYsCHpD/7usE2m6F/1TGIuxTBB5a5kNfGaH8npsgQPbtpsDnnih4Pg9FS7GuFELm5OfD69WtqbTw/P/N8Pm/7fr+USWduAlb0m4fgVhV3VXbNq6JjrZDLyttvvuH56QM3hwkfGp+8vt8OaY9s/E5FZgu16DCB0ipzKySEZAd5cP3oc+AC1QWa9zw3x5MIpyasRWjBHDq8w4eIUBU5NRTJ4Y2bi454Dh6GgA9WmCG41sjSLmdfF0TawIJahVq7CHPFl0DwSteptG2KXy9SceCiUqySaTa0M9CnVmnCsbl02Lnb38CmTv8R4ALXtK/+I40D4zToQAFs2lE/l4XLrx3b+3DiwFdaEWrR8eJuSMSoXU4fg4pDe1K2xa0npXQ5k4QtgXLY0AivRXC0or1ae1w67Yem5251ug+3yjSOvHr9ik9fv+bN11/y/t033B72/PTzTxnSYTP11wTRb+dhMxHueVbaW26NiFpPOQkXIbm9ThGP+ED2gbP3nERYqqNV8LkSROkDMQ3Kca2ynecOs/4Th5AJwegm9m4E5fl39NR5R7JOKtaxckApQoyNWgvrunI6nTSnEB2E0rYDS4uQjlVFyxfGmBhSsnGpmLWf8rK17NIF0Pfi74vbHyaSQvAeko3CdK5R60KrK8tywt/fg1Scq6TBcbhJVAmUpv5u02gjwcZ+eIj5LmJKU6HkmYcP71lWIdesrWoBrqwY9KVefAKbVS5WVFFaVYTRWE3a/tK2d0yQUuLLL7/kk1cvGPaTwvJYy0UU7pGiL0SkW5401rXw7bdv+ZPXP2U63DIAe584TBPR6yJJ48SbBu7+lugqYXbM57NyYIKj2zE444G0q97PNo3Jq8o0iBLpS+2CEU9szv5b011NUJXfUotoW7TCzc0BkrkPiFpINFm5vblhNwzE7enIVSvJFlo/2LsMEi4/22K8CorLjx/pJYKN4UuMQyJEcBREVnBmj1MU5TkIpNKI445cMifT6Y8RHCveefaHEfYD6zJo5VlWhjEw7UfmeeXh6cg8r7bA+z2ItRibqSPVVL13AHLNzMsZOFiRINv5V437NKTEL37xC37x+edMUX1rU7zYqKhTQ6XPZfBOxyu2oinyh+ORn93ck1yE3DgeV6akKu/gg1IfXr3ip//mz9m1E/X4XtvFxqPWVht2YGoysjYhq8GuIVSO2qC5QiigW3/bKCkuOJzXwxiL72BqexEoubG6zDBdoWN2QLcK0StX6mY3sbPk9GMBCdvm2WO2b4tYgi1XiezsHP/1XzL4fuDVl5P3nv0wmVm3QF3w5onp8ZwlgET2u4E07YhpZJlXzqeVl3c37PcjaUzaRVhWlnmmFo9zidYKu/3EtN8zjDvwgTWvvH37Rn0slxWCv0IdOxCgsaW/FkpeFElX5ZvRr8ScZipiyP9vv/yS2/2en3z+F9weJg77yYo0Q88l0JpnU0Q35dnN60IWYa6aYPgAS9D3WoHoHDkE8hj47I9/wVf/5X/nr9++IUfPUgoSHERtDQeFIbZphUGcOqqgRZwmPCDO4YszOy9NUkurxBgYJdIk4r3gmglrRWiiItd5nvEx4ZLX4sqSUkVc9ddOm3bsx4n7w57oPdGBdxHnVB7VCyxFDy+x0TnC32kZ/MGu6+l9IjAMA2mcGJLToSZmDt/V5mIt/d04EdJAKUJem+pKUmAYo3GY4bBXBFZoOO+ZdnudsoglnzFyuLnhk08+RUT48OGBx8cjKSk9ZmtTb/ZQ2hnIOdNK1m4AaJfKFPBINXS3sKxnfvXFr/ntr/6WdX7m009ecbjdcXd3oEmf4Phx4VtrpeTCsq5kaZzKim+V0XmyCMlZumZt70agDCPv28o3eeYJOFfBlUZ0Cgi4gE2EsslxonSBtTR8LReNj4dxGhRRNmjAO89aMtrhBhjNJspogmi815ZxxZwUUrK9XAXhm/9kh2I34FepXDFG5bCiFDZvHFRH3JDqDeb6u/gq37l+MAcVOjHeU8qCc5AGx2685XCYWNZnpFVSADcEKp7aPDKop1Z0wfhxSuPXW+5K0a4Sb9QiUIRuWL8FuNN2uNBsPGegOatyHUY3UIWuPnSIA3gntJqZz2qvIrsJ5N5Un1CyBoHzYuKggNgYu87lW3NmzZnsHXWaICXOwHh3j0+JBXhcM4+nZxYnhGEg1YqczjrVYrNgUJswRaQ8fV5wQ9tHFQ2EKgKubh0B72AtFV8ACkrkd5SqqlhdjI4hjfzRL37J3c0tXZxDqzw+voO2kDoipaeDhU7fRADXPWG5tABMMOGD+yi+xFp94UdQyf9DV1fChwBNFpb5SHSV/bDbEPcYHbsx6JSkADjhsFOLnmFwTIMtMeNTqsekx/nGusycn4+sRRHLVpu1gC7iBq2wLxt67QmV04ozl2ziiYunovoJ60aLc5zPZx4fn/B3N4SgHMJrT0fluhqyLTZvHC2w3r974Od/+injzR2jD+wK7KeJGNWrbkgjMw7/6p5wOODjAHkx5X6jmj0UToi23QidS22OBr1XW7QoUp2qqZed8l5z02LMiXJ/Bx9szTcIYoXkwDTu6MKBGNWAOjphGgK3+wPRX7XznNqgdHGmzuPTFpNrnt5Dvlh9aUxX53jzrxSDP+Ta7/cmbtB2G3XFW6veiRa69/d3FHGENOh+llcWVlKoJN9IVmSlISE1W0u0kfPM3d0Nx9OZ0/nI83lhzV2kpvroXoo2acavNOcQe6Su2XQ8equbzYu0GqUGhGEY+Ku/+is8wn4cGFNgGLqKXzRp6QihFcbNvt+aM+c10+5vYYxIrJxkpYXAlKLyTmMkvHzBJ//+rwhvf8vyzRcQHbksxDRQjaaQBYtHvcdSlT6ztXi9I4rndC5dS2LoWkcHZdu/ccoPV4eIaJQnTQg6tUoh4UYt+svNocU5bvY7bqaJKSY9BZ0Wig6dtLb5Y8L2bJFrZwXP93RK/9Uv52AYImmIBF9xTul70zBwmgs0h3OJadyTpj1xGMlrJS8ZqvDq9Z1NRdI1neeFZZlpdU/3nBqnicPtHTENioyiI4HP5xPrWj+iQXREt+8/3Q/YoR2pTXhp5XBwWlhhyGTOhefnZz77/DNu9hN3t3sOhz1VNHvpbX7XBwKhqHeP29KE1cHqHS7AaolmEyE7r6POQyC9uGXNJ871zNnrhDgv1pg0677UBUsGaukUScPTq2iy6lU6GTvdhwqCTTmshOCIaSDS0VPNnTyOWj3OFUrzlLKShgExn1NEcE2pWj2l8Db0ZL+ftkmHfdJn8Okj4fjmK2v87e+L239SgnrhmPQXqfYH6/qMFxWF7KdR+Q/S8K5pFapPiE6elqb8CN0A2ZAMbWn0GfNsC13s70rPlHoWbyhkGlO/Q7Ryb9sfsQJ5A1Z6zPZBArtph06mkCszZTGqgeV0hoCpwMsSVdHmlgT1O11EeGqFkJUvtcxqQ7SKipWaCDFGdFpRJ3C7bfqP5ojWmkCDUsU2TQn5/fk7vXcdjGBOAyKaPARNIJq3ZNEHXty/4tX9y+2ZutYYU+L0+BYpCzrxSJ+dbKURdIYKbkuR2BDTbd13TpF6w/VJPj/Gq29WalmmIdRKxnvU1D1qoVVrJkQYXSDIxZlh8OPmU+poSHPqodiREEuC+mFackNssAP2VLxzxjvWJDMENVBWk2Mjqdu7phcNrZ/TGuvNiOvz6Uy+zRYTyh1tVbY/q4lYt/GxxKL2+ddZE4JxJIyTJoQ3N/gUIUSKc7x9/8CLWlikcz8D0rJ6HDuNe+c6H9nu14opf+Vv2tv/HVHrxU+pjVAr4sSGAYgVV0Lz5heM47C/4eWLV4zDoBynIZHXMzmfkZqVAywdTdJb0T1EEf7OW2NDT9lQVefDdjANzvHzf9EI/Kdd215ryXQIgVaytaDV/swHwCyLgnfsxkgRIJi9TID9lBiT8oCjcScdjmka0ARTzbpzXky4UljXhVzaFrs69MNfDL23JX4RkfbEVV1ezM/a9erWPofXA+r5+Znbw17RlXDlzdq/tPT9+VKcFeMs5qwT9eJux/4wEIaZYRyZxkGteGIk3txT9iNtTGoFFzySl40D2KqOUBXfHQOcHd5Yx039Opyoc8VGD7QiS6x3XAVKpzc1Ub5dU/ueZrQwjyfGkZQGReNwmhhLHwrSmNLIGAdVPOM2jp4+l+9yUN2GQH7kpfwjuHprvXuLds/k1iqEuomP/OIYhoH9HnwcSdMOFwJeVlyruCDsp6Q8aW8xFjw1eNRVRe3db+9udEJSq5S8kktlWVZyzogoTetCQbskqN3PzKEJW6kZmOwz9McpGyjlvWe3m9jv9wSEu5sd+91owIAYtuO2/a3bXWK5RCmN2oS1NkoITNPEamJXH4IWkz4Qxj31dscYduwGqB++oaG+6655K/S1uMcAIcT0JVU7xbiGa6oBCqUanUrR4L5OexFZN4uzhuvia2/TorhoAaztun1W2c4kh7chIGNMHKYdKXTV/pVAyoftfLx0AzoQ+Q9f/2CC2rk511ze7/5/55wmKU3RRrU/KjpzGLHEtCFN+T21iKlLq/ma6Qf3XrkZ/cNsqMxH39wetnOb+a73kIaom59YFS7W+t6QQez3Lxumc1pdjOOIkpmrOg+I181WVADQP3MzBd1GNbDX3JxDQqCUyuOiLa6cC+tS+PTTT8mtcV5mcs4MQ2Ktqy4W+xx+M4Dut/txsqq2Gs44Wf2Rygbvb5WT08DpdAcQvAvspwP76YaNzwgqSHt+opSCSVnZgPetRXrN1+uJqhUSG6rXLAnRKrP7sf6oru/cTkctvBNKzQxjZBoDaYjGW86EAC54vDhKU2UowW+LrdVKab2s6M/NhCNYYVU6anS5hX6w4SrORRNTeTaznu7taZwmOtLq0LFxDqQ1SlMVfj84t0JKDBOSjnh1LpZutt0hYPPgDQE3jaxrYR0HJAYySh15vy48LDOnddmM0tcihjbYBmWAaRd46Vq/imH6f9vmtj2HZqIxMym/iqNmiG9PfPb7Gz779Cfc3tzgnGMcBtb5xPH4yPPzI+vpkW10Jxce78cJqt6wcz0Ceix0hw9I8KOZJHWNtF//XhNtN4oUdEZ2R0YUCBgH8Nv+IeovHUaN7+AsodWvPSTd+oN1RGrJOjTFxk/3F3jh7uq76olmMP9dCfrSNQb0vbLRQPSdePt/Dl073377LdPwc2Qnl/jtn7WjCgZcYGdAlUqpuq5Ka/hxZDq8IAxnxpsbpmlkSEkTFjwf6srqBJeickl7R8Hr3ls9WmCh+1m/h55sACpGaV2drxXYpmvAvIDBWsLqctDaxSFA10ZgGnfc3r/QboGPxrMu1LJSyswYJ3NS6WM+wvYrh+4FzdD+rROzKaEv8fKHvi73Yeb3PlBapbmKhIYLYRsWkYbIzjl8EMIwanHjQbxSK1LoyQ/gHC0G/DTaEB3dw8YhsZbC+bwwLyvlaoKa91f3JLLtgyKyuUQ4jGpl/HiRyzNullhLU/u/aZoYx4m6LozjqKM6bZjQZWf7+Hv1ZFU7CI21FGQaibcTtZ1pMeDGAWe0k3i4Y70ZGQ479klwv0rUpeCtsOrxabMv6GfPRRzeNlAJ7008ZSJqaeC0kMIrClpFu1e0to3ubVd7bwfstkS8dQeAi7Cqd28P08h+mEje2zAJHWvsnFrYbUWu9Dj5uAP7913/YIJq9SLGktPnERRz1kOuUspCaxmRSJNKaQsuN9Z62ia51FIRNyBNSbg5a6I67G4QUdKstG7KG/W/8TgfgXV79xoHPeuWrT03xP4xTNhjSZcUVZW7YG9042fr3FofA/OyEKO3HUUV7Sqw05euFjkKRRdTQjvXDwwQFyAkWtHFUUuhZOVrxHEgN+Hx+ERthdeffsZ61Pat7zB985u9k22BmmiqJHBDobqqE3umrcGahRgu+Kf+XOmcRl2gAZojhGRVDEQ3UNeilkD92W4/uS3xv/zupiu9/N6WeFhC1ioXv9Afz3VVowAXBMJ5T6uZ3e6WcVCqSqPhvHJ69NnreFwxV4QqxTaJQBN9liH4bc553yxaq5SihPWPuLpXC9IHp0bI5ifJhjA2Q9otVrugQi4lg3ee28MNu/3OENlKFYcaVnVEXYs1UFS9VDVJ78VFQxDvaCGQo1DzDFnFOHkpMAw8nReezs8seSakUW98I9Oip7Pv6m/UAaCpqtTZJogz4cNmcWZfppkNlqsgFe8clUqlKHqkbp3EMDIM6v3qQQdzDB6ZBCmFfDrSC+Eel9uEaxe25Oq6yOqbiW6QisbMwH//EdVWPRYwugIIta40KYQAMThtJ6rfET4I0f6e/uNUre+1EFdU3ugmEnRPMSW6c8LhcOC8VFiqGo9LL0S1O+Jpyof3Hhfj5nXZrOXtnSLntLaBAVs9hg70oFbOZx3u8qd//Es1szfVda3Go7ciYpvYJI0ildL66Ah1gSneUQ8D2VVuXtxQpwkZBpqPfPPlN6zv3vE4zxpDPhIJSDFgwNZUHyN9eeZqcr4tOZHNN9N5oU86ArHJUJ0rq/tEFSFsCTV4S9z3+wO/+PkvefXiBSmNCJVaM3k+8/7dt8zPj/hWjS/eC6dLpIKisza0nh7LgE29+nFcIfTORU8MtehG1Ecz+D4sB7zvoJQQolDXgnfCkDxDCsRgYqJtgEQk7gZSUopgqSuPj4/kKixrJdeLBFW//xXC3Dqqa34MV2uqiYr7CuCa7feXx6sFjNNW/Zs3X/CTzz77CLUWEe0COV1zVUwELSosKsZhFYR1Lfjbgf3dCwhHhpsD+8NercVSZLi95e3xGb8b8HlPHHcwz+oP64XqDdxAn5+zvf5S+Osdd0vzUrFOVMdEjZaDgHhKt/jZSJaX6Z36v/RBHA63IM5iXr9eyZlaM47GGD13h4Oq9p362QfvCT4a4HgFcl3Hx/cDqN+XoCpv7TpJ1XNAN6fcCvNypNSVKIp+lLXQZLXqMNOq+mniMjFOOJ+Iw8g4DWixEyxRw9pKDd1q1RKC4C+QuS3Z64XQP2zfTLWCCEjryURHCC2YmlVGBZ6fn3n39h1/9se/ZBpGpOoB7WyjKDiW80waB9q6Ms8LOWdiGIg+aZu36SY3xhFnpvje28brI+8fPvA8n/HRU6n46BFRNX5rDmd0h05WEuPI1aI80uYdLirSOvgLybgHURWbee4uvo5UGMLA7f4WL5HodzqdKwRSdCQnHA83nJ4ztSwfPcfNnO3yu/Z8w8d/hv5sbT51gVbKR6jPj+OSj+5JpFDrmWV9pMqCtL0VTpooTSmA6PQZJ4Iza7F5XpjnlVIrt7evgbC1j0NQEniz4sf5gJIDLrzpnp01pwd99JCCydNc3FpLjqaIT+ulsoOKmX9j6EPis598Tl4zi3Gta6yEYdRlE3SzwSt/LbdGLmo7pjOs1fe0ughhgArnrOhqLZrIHg47Tq3w+HzmdFp49erANE3UYuitFwjePiXQ2EQLItrmRCpNHD7ZUAj9BIBOtaql28rpFyitKVdc+rNwjMNkiFIkxZEUIs1V3Oioa+GZ9xau1Q5EKwr+js3vYpXGVXtJ//ZnAv/3f16g/d6vS9RW5vlEXhecb6SUuDscIEKWFS/qiiIOok3WatayUxFaNXW5kGskRWcFg7MDJPD2/XseHk7k3AV9vSC9bAZeNKn1MeoUO+njlrWa6ri5GJJEP+RAFdOGJP3JL/+YmCJNVNSh/sIR4YLqdMueJjZOe1lNAW7nkVe3lCVW3tXC43wirgtOHL/98I4/e/mKc6msuSjfLqpARFzTiTZKMDSUs6O1oJ6Omlk7D10X0JNn6Z+x6J5Ror4paSpeFfMhBpVOVDw+DOynW3bpoIhS8PjoqCHT1kaZV1o7g3UAth8dXkaBGPFuq8Ourx8Hfqr32C8RYZkzYWB7ds41cjnjfSN5h0SPDyCuEQYYggqnUgyMyW3JUMfwW4Ww88ToqBVevHjB+4cja2707g1wAVy2rp8z3YGeYcWKUieV6BWh9r2aAhBnE/90ctPptPDw4QPffvstv/jZT3U2vfM09B3HDv5f2fIISu1bqwmwnGMtWSfl3RzwYcDd7GmHHTKMECMPtfDl+ZnDOLDaOhrDwJoztWdfbjBKoMXkRoOBPlhHcySv9JRm92U80a0DUFVMTTCKn1Muqe7dVsKbwPbVy0/5yec/256hj1EF8adnTs+PzOdHXMuMKeIJeFGqZgjRgDWugnR7OUZz/Ievf7JIqh+4IhUkA03NdFHBU229YdKRC90Y0zBQazc9rggreW3ElPA+bFV0LolkbRYRdOMKzdSRcH3y6H920q1++B6Uatgsm99ch5Y3v8km7HY77u7umPZ7QlTvSugg0aXSkKUQIuZPCbtp2gx9AdvAPNMwEEMw9wBFqZZ10cI3OuZ1xkedCtRf1sbzcn0zEvoM3T4P2uHwUTmPW/uvgRSoJgrBmx+agSpYMq5Va8RvhrmeKY6MKTE7nXahXdCePvSgMdiuCwlc296n/UENYrHqsbdEav9sP7brgjA3lNrgEVpdKMWDCGXJnCUr4i8OEU9tjhgmnB/U+xRPCIP69gE0sTGGAlc8G9NEfIQ0d1cEJaVfJkxtdso9FjDiOaJfxNT8znmzD3vmzdt3PB+P/OJnPyHe3CDO2u+2DkQKtdih2XRIRLb4DSFs9mW1NYYwIC0jKPLa25wfHh44rzO5ZY7LM8NusDpKE0lXBSyu9LLDWbqS1yl674J12XtbR2e1l6Ioiu/dA+vMdGFXCIHkIykkohsILuExZW/0RN+Yn96ynN4rbcP3Auq7r/6S6vUD62Lgpz9/AP6n32e4/TOuj1u2ug5rXal1sYM+4Pq0Lt/U4zR4ZNVWeBOBqjO0l7lQSsX7RIwTgteiAWcbhbalS6nKYd4yIC2+rd5XOhOVGKLRAvr96XHpUN4/VYs6+l5lbCtne533nteffsLp+YiTiWFQ94jkAsU3VdM7TzDVSTFEvlTlXgsgLugPH3BxZC4CpQCZVgSXRloIVO+Ya6Y8njnc3VGOxVquhVC1iyI4WgcFNnqUHva1Vhr+6n3YiMZuKSViQj/l3zqvI0mr7TIRRW9TGIhhBAmkOFlB64gkDtMdT+4thUKgbt25Ln5ycuHsWXD0W2ELdIG69hlgf9hro/NIo7as2pToiMnho1CkaJcqNKLrjiaKHndbJI9Xa7Fmww2bJ8bB+JOX2Hx4eOB81lGq3QNU6MLS3oHQR5aGPiUKRga0oNUOpI9GQRFnx13XFmhhJdIYUuJzQ08vlCT1KO06myZqM9aa6lWKWfvN82zUAk8LgZJ0CMuTc+RaiXnFlcLD8UgOiaU0jqeZ0+lEipFlnXWaFBCC0pmC75/XQWvmg4o+G3EqhjLk2BmdxSAO3Z/FaIJUm2So+VpATJDVCCI0AsO447C/02EblvcE52jjLfN04Pl54vnxW92DjVblv0NBMZYVnWZl7J/vjdsfqOLviYu2RC9NBtGWtTbjtoO1VoFSLyKIpu3SdSk4vxj8rpXTtE9MMumHDJ4oAaFhup8NUofrhew6trsFqT2Z7W478rslviHw6tUrI2vvVW0YAiF07ODS/hFLMjSpiIxmDN6TjVobMeh4rwjkWrYJS96r/6DzjryuDNN4OTC3XO+SnLortwJpF46UIm99hi2KxrU++Ui5IfpsFT0LITGO+hydzYK/ntzbmkL0rakXbecT95tSZK9jgBb9F1feq0O/i9iMG8SPY6P8+y7p1mNOUZ/WMq3podJaIa+reeOpAlxcn7KjSJNzgVwvW2FFcNUOKNeH1zmct1F8fVO9PmS2ilt/7yJI67uMxe8VhiZW8NWqXCaNLb+1UBxXnO1qQyVotn68OQpU8wnU9dnFAz4EhpSUJ9Q9dmPk62+/ZlkXxEOuK1OYcNG4fNIuXn7hco+9UNTY1VZa8w7xwf7cJUnvopvm0AI0yCZkkQZD1E5F8IkQIsH1QqvhfaTEZJZGzTbhngDbAuHjZ9i3hEuUXz9fyD8SKOrjLoQdMF4PE40PHUJSSqOR8WYhk1cdu6wJHZRc7cAMNnlnQFqkVmdufdq+35LSLTwvtI3+0FRx24wWoOIy/cNB90rnCZ3jdr13tt7ZUW/QZV4R5zgdjwwxEIMq+Gvo/CuPK5VsNmC9kCo2JUtBAbfFSYqJXIv9ng7h8DGB9+Sm1lRLXrh7/VKL/HYppp3oMJlt5sFW3Il2BFznMyrM2g/Xfq61BqWq4pum084uX7/homOMA2OarPU5aCw7TcRc8OzHG/bTnrn1buPH51rn/W/v4hIWl1+I0PIfHhi49j8V21ulQQg6tts5oUnBuYr3QjQUsDTRgUL27IolebhEsy5ljGZnZtS41lAT+SK0Zt1WYDux7MwWGj70xKm/Ou0IipgvrtOCGWfkoGbZVAcXBLwP3N7uKSVTinUUvX7d6qDzRpy/LnCaFlY5b92bhqM5jx9GFoFSGr6oFeHxPDOOe4roSO7T+cTN/T0em9TUmgny7Lzt8dgdgPr+K7aHup6YKlqps1U8XZ9TqwmmbLF7Z+vKcp0OCA5pIrhE9KMiqN6TfETcqFTFWjk/vd9oiF3g990E9brF33fh74vbH+aD2jdQg+2ds/aOCK0KdePQ6MlVa2bOM86NVnUItcGy5A1NjDGw240clp2NzOutJJ2K0A/+1pSp1lVhfUFvamY0jjUxuyQFXW3cxUfeez779DN88Jt5c/CO0JWdveLQSMdj5u1pYBorKV4UgrVWXBx0Iot3uKwIVc6ZabejSqZKodZCq/GClElfLIaeCZYoXhYYTWjicK5vzrIlM7XaPF8nVHcRSDkXGIeJ3e5GkxHpTRJdvqWszOcjeT3T6gp+vFRXPXycQ60nerLerv7vFgl0rm5zDrWi/nEnqK019dy1sabSdIqJh21ht6uJHN4ntUezkq/RKLlhlrma7AdHKZGuFsd5fNDJTt5cEjYHiv6X3N+B9tn/Vj9fZ4b7btvcnDMzkCaM48jtzS3jOG1j+vrGXJFtwk9rQmiQ14wITOOkSV7QpHg7SMdElEQskRAz4zTx7Zs3LHnBRxuZ6rTFW6XTJoIJE/VD9VXauVD6bzUpl6Bj+S4WQpqPNLdhImrGbz9oqBAhRPPS0w6HmrJbLLZGLSv0iXEO5YPZ1++bc6ek9DjWtddZ3/pno8iPRiTVrpA85y7OE87rgSKtUOvC0ppO7hPdD+uqLM3aFEVpzRPCiA/Rfh71/1mBpdPANPnqSVhPSNUt51JYORe4KLQvCGr3SO7PtnXydPfwRTZhaSlq1fP+8ZHoHe3uVg9bs/rpk0vE27x2o3LpkJa6uWj0Z9RKZZd29NHC1XYsH/VzrDmrQLVlGpWQgjkUWdJcba+ypLcXV1h8NxHoIjCCrsctGWkav0XAN1xrVC/UeBElhsEzDiNjGgkuEsOwCaA0YfDsxp1aiJUTy7x8tNb1VVyQfk1WL+tq20hEJ439oa9touAmml1pTQc/eLPrq23F+YYPVoSL4J1sAuTugALdjN8jEhBD+zE6YBctX1Pir8u6zsRu0oxn3XMFUE61Url0yppXS8pre7N2+aJiyaHzjmVejBYgKpzFUuJgf08qziu/cyusaiV4HQLUrBOc0siyrpfPnTNraUw7T23CkjOn+czt/b3u1U0tzlSQp7Q6XB/v3DtXtveaU4X3/mJV2rPzHj+G9uIvKIF3bqMHeYM7vQ+kMIAEPJHoEsF5pThKgNioacW7EaQYncNtoOOlxtV3cNV60WLke+L2ByWo/ZsH3wniRtatSsyt0tEdbZ2ua+Hx+Mxud6cIVGnM88o8q7J9HAem/cR+P14ZIuummGK0sXyBEHRjUM3zJeBAqzShe/RgXAituJptPKUJXiDnivOFm5tbXPBG7nV4r8hwV/4BpkizzStEVWG6wDjudNNubJZV0Ud8DKo0zZk0jnz6+hNS9JzmZ5a8WMVgAg31rgIfrg5R+v63VWEips713gA5s9sQQVy3ioAS9bmEGAlRUSdHpGaD670mzR/ev+Htt19SyomUIgobR1Vm2YHYbSWgk8AvvMqNZiGNlnvN6hSd/NFQ9v/uq5uBg5jIpCASdQNsnuATiA45KL1F3xrrmul2Y+taKVKRquKecRwYpsCtoHYpMTE4WIsQUkcWVAAk1sK8eMOxPTGHXAqjq71StoJFx1KOuwN3L19qJRvUqD96neYGtibsL3SFsfeeFAcO+wPJ1pJgk12AcTepj2rWGe33L+549/49tVbGlCitkJdZn11TpKcPlLhMa9FPs/H0LEmurRmC4rjmhHtXjR6kRW7JRRG/CDjlJSrZXmkEOjvKkZxXjvsys5ye8K5AM6qEdQs0qTBx1lYFVJR9y8cYa2ucW+Nvfo9x9s+5minHO8LuvafVotJRJyDa1mzY6NuSyWtBmqdKAJcIfmCaJva7F5zPhSYBV+OG8C21gIfRRHw+aELQUITc+UuSfH2JFQHbnug6l6yZ+4mORLxmyzes5VuVZrLmzItPPyUNo7W7VTGMIZv6jvR8CcnTSsEB4zAaoq6cg1Yawy4itapquak1lAtwXhbO80yplTQNHJ+PpGnABUe7piHplr+txR6zbPfUEN/0MzZ/2fpQnrh0SykwtNgKLIEhjptQRFXfcYtpfWQrDqi56F5C56D+nVEB9E4J2MxBu2dY1/WHhtvv7epdnda02Ig6EpHaVmoL1AqrFKZp3D6JciEbec0mngaIpHFPCDsTosGaG0PUqXSAxl0IuNrBlO3INoxABWWCia3cpdDvXrdI5xXbKOaeblqBkktlhxZWD0+P/ObL3/Lzn3zOMOg7RExEbahmMfFVHzVccqa1alMyEw6vFmSlEYaAa4IPwbjFZZuU9Xw68XB8otbKh+ODPq8KuWbzQK5bwYgPGvPXvqi9uIrOak5LlAJ0z0pN3kGKFe1WMAnoOe51XacQCS6Q4kD0gw6QMH1Q8Ik4OLwIt/tXzM9vdN81tHbDtC2gN/S0A4nI98btP52DuqEnqsoLIVCdIjG5ZUouJD8yDjvlpomKIQ6HPSklMIN6kUBKgd1uZxYOSauupi+1E9NdUOuQmCJpGNgfDoQUeX4+8/x85Hw+4fGkNKla1XuzCKpQtNUurW6mxr4UDV50klRIgeDRBHV7gJdDFNSs3kvQtrBPTC5yc7gDiZSqiIWS/d2WmHvnub97yS9/8Se8evWKZZ1Z14WHhw8sy5mcVx3/2DA+SbAWhB6flUJrghez7CDgCpd2D1B9Bd/M11ODP6+9AtXKdSmZcVl1YEFw+Lbw1Rd/QynPiKyWVKYLkmtV6gYoWCDhLmnU5d+XulVKY4iRv/zjX/5TQ+pf9Qox6Bg4Ud40kmi5kkVb9JotRtZl4TSfKfVEintyVaFRKTpCNgSdopamkWk3aJyJno4xasziq/qmOlV0rmUF/LYRdT50MAcART0jzqltW+1oClpAVdBNTeBmf9CizV9ECMoTNiRT+MiuKuAYRH0b97sd3hSbYvY70QV8UqP8uVbdkEJgGkZyceRTJs+LimSu+YUOXNfdO0eh3wNbq7M1oUZNMkJQOgkiFOfwruLQlp+Yf6cnMKSRu7uXxDjgXMBJUHW5h1wW3r/7hm++/hXv3n7Ni/tESBPOJUuWe/p5nYZCV+xvyKAFeWuNpTXe/yvE3z/16nevXo2adIsUNhsmQzm8EzIwpEkNtpvjvFRO8xN5VdTIObXBW9YVWLm5mdjtBiAQ40BKmmmVIkQ7XnQ8Yi9Mw0egQL+6t6JzWDB2yLfHr06Rubu7Y3+4pQH73cQY1aM0WEz1DpF2jpS25KpymWMYuLu9I/mviTEiTshNn8n+sDdkqpLGyDAMPDwdcQH2NzvtLkjdHAb0/hvuau76RlPrFjq9yGqQs3pWdu62Irb6x0V0opU3pDf4Solq8h5CYhp3TONOOwC+z3zXYtQ3oeaFsj7T2qKoIh+LjS6HOpcHv/1aq1fBCo4/8PVxQaPPTym7K3kRpDTObeXhQYdx1KL4zLo6dodbYpxIw0DwI6UpQtdpFFrgrAw7teZzzuFDwvAEPZ5avSx5d/Xs0GeqSamzATx9NTWagRQIm1dv/wjOOUouzOczpRT2NlbZWwLXR3/mjsaLOl3EGE0D4tlNO5JpbXrXdQgeN47gdDpb9IF5XUjDwLsvvuDbb78lDomcZ+5f3uKyoyzqZAF9yIDbur2d03n9LmouCjgFFfR28Z6+Gmf1lnlwO/Vr7ULfXlTtdztiCFtrv6+DMQQbrCFUA0oWmgF9bFSHy3VJTvtPW6H8D1w/vMXvtDLZ7Xa0fKaVldraZhYeQtQfXri7u2O1qrKZofFuSqSUmKYdMeoIPsECxPD1YUi8ePGaYRzxMSBoILx9+5anpyOLKTtXvxLTrIlsVBRzl5JaXGCHdDMOh20+3kaSYmiAuwro4JX3qrHe27/q5xWdMIhnvz8AbjNllqb35m1En1Z1nhf3r5nGPbmu1JZ5cfeCeTlR8rrZNogosplzppRshtTZrB70WXvcFS9KrvYqSyblwgG6bg+KWOuMpv6d6zPHp7dIW0GU91TKSoidkE9vJv3ue9++p3znZwBhmkb+5C/+7IeE1L/4tbFS3GUCi3KZmvk+OuOH6aep5hsawkgIRjxXmATv9IDd7yc1nvY2a77bmwGtFsZxspgMiiBGh3OJ5+cn+hCKEIJ+T2tBeZpx4wwZx4MUnAghKo+zx64LTkn+6AF/ad8oCuudv5gyOOWGTy5yc3OHcxGpzgj92jIzJiwOiCHxRz//JcfnR+blzPP5qGttPVNL1gS/qZWU75u688SQKCYsEEOnotfk0rWPY0pqU2svQx660nwblZh0Rnyt6i0sCC4GpKw8P33g+PgWx6pjYENiE2zJ34dC2dUFaHTOsDDS+LGUVn1wiDTtkGzr2eA+bc9VgusJj9rz6XjNrBPlJFjcCudTodvG5JxxThgGTy6JXDLCRIiJmOygc41u01MlUKXgXNjWzbY3ODa0+nJ/DjEShsMhJqCrrRFiYhgjwziSYiB6TU51771Qm8xk0A7hRhBISRibsN/vt85cq5Vlzdzv9uA0UQ5NubklF4aU2E87W5u9W2BdMgRvyKkLWmDh9bn6fgKJmGBSQZYaqt2XWBfYUhwB8RUI2yAaD4r2hkTwER3iobZ0CLRSKXnh3Ztv+PDhDcjMOARC6obx18/5KpjdZY1ekui2uXP8oS9naLrSqDQeWsvU1tecPtOaG605hIALiVJ15yxe1b8lK+DTpJvdZ0Ks7PaDFa06hjMCrqpY2HePWadc5o6G9kvgskde3fPFDVCrLwWwzOIKx26/45NPPqEB0zQR07DZs3Uv3f4dnH2tzWbNmTYlBPPHVWpKKYVhnHBOkfqYIlUawzCwrgvn8zM+QEFYczYkONKHFLjtoxh9z1DT68/VOrRvAGJrPYtVh4paG71j1xw0o9rUljaEdEgT3purUqdubtCoAVRSyeszzuka2EAsd0n2vyv0E/Rzf1/c/uMSVHep5C8Iqm5OwzAwx0DJaqLcHfRjjEQj6k0OZF3IuY/Hc6Tg2e0Sw6AHtJJ8m6rpnarr7m5vubu9xcXImlfO85nj6cT79++Z58VsRxyFgi9ZN7zgCTEgoyKqQ1LD2B6sXYXWK5lLoX/9UPuLt/+2QPBeicm+OfaH2y0pFOOVlFaIVb9uCIGUBj799HOenp6YlxMihcNuIpdVp4rYdIdq04HWdWZZFh2rdjyxLMu2uXakZ2u995cvYtY6xstpl1YQCK0WhdudILWwzM/UMuM2v1QVTAV0sozQ1frfCQCwVS2XYDBqQf/PGCMvX7/+R4XUv/S1bUzbiu0x2/lIyprrtkpOPC4F84tVJDyGuM0iDuKJxrtMMXI47Jhs1rGKrvrB5IhBvSJ3+wMxJaJNs2k0lkVV1bUUmm/EqK4VPmqi6+zAVlNkq/PFLN6McBWsonXBGfpk+1C3zNnMxDerb5o4Ih7xjcPhBu8v9m6tqaJz21pE7UVevnzNOI7kPLPke9Z15XR6IueFWvpsZm/IUEdLlYNWbMyqfi2/JY4b6G6CsO6w4ZveS7VZ0q3qXqDiPxWh0TT1qcvMfH5iWZ5wLlOrDtfwW/zaZug+CoCr63LgXw6Yjz0x/5BXR9D6uFs9+Cx7E8GJR6pxja8wwFoKa16pNRgSGCh1ZV3zho7UqhZiyWKydrcFs8bzXgUpCjB4xEUaDe+TxfnFowWwjo+eyr0D1YxbDJiFj6qaA44YItNoU9ls+IS2WXu09+JKO1cihjCJMIj6tWYTAXZ3CtDOiMcjxVGKmvTs9wfu71+w5oVcV92rbc/bGkIeHWxhtClxSp1wZvPW1dxdULidf2K7pdOpZ9Kafv+qCZXHBnvo3GwrtJqN+G5IKazzmQ8fvmU+PxF8IcWRyIjrEIFxqK/Tjp5iuD4pA5BWfhQJqnQU3VB+57pw9PLcLkuyx62OaV1zxVdNCHMu1KJcTLGkrpTMODlKuaGP340xfgTGaCLmKVItLrsmYDuwPrrf61QfUI68/egItQDDOHEfEiFGM+mPOqLc/a42w/W1aj+cUzQ1xciabQJl06lo425ningIrRGWQBqGzbGir/mcV6Mu9W3taq/azl/Zfug20Sdn2R8LcaMAXD4vFqsax811obUW7yFEhmE0u6iu+fFbkdakUsvKOp84n57wrho/8NK5uk5Q5arQUqzn95Wg6ne4fDCRLb6STe+YpavZ9YBPKRGDzSVu+WrCk27AIUCIjmCKPo9apAwxElzDp8gnr14Th5Hj+czbt+94+/4dp/lsiak+YWnWgJJGsUQB78nzwm7aEQ4HSGqP0LD5s2nAOce6rux2qtLeklGno/88W23SISik2354x+HmjqfHoxqgN6G0aiRvRZdiTNzd3XF7+4Ivf/sl7969odbMbkyYySZ95BpOD46cV/K6ggjH44nT6cQ8z8zzzPPzM8s8mwjBFvtW+tn9WTukK/c7zB+8EB3ksnI+PeC9Vbc2DYKm8oLeIr6880ugbQf9dZvp+mfA+cAwTP/okPqXvLbJIT39sOTau07DCJSi/OhW1PNOq0VN/sZRcEGVz6VUYlAlZ0qBlBKH/c5I4IZyGvIfg2c/TUz7W25v77ZWZ2mVx8dH3rz5lnleaVUHAsQhMaZASGpC7WIkeC0f9JTXEXfioYv7dP2o1ZBHE1ot/nVa0Danme7b4AnRIwTEVW4Ot5SqfKMqilCupRBbtIRRi5TD/pZhGFB3BqGWlXk+sayzIfzV4r5u8TvPZ+XbVt0gnLP2mtP0t3tDOy+6fulqbTYniporOVebVmT+f6LWVrVUTqcn5vmJmk84MqUEBksYZEOSL+4Jfz+aetnAC8L7vyuX/QNcW4K6JVQq0Og4pcNT88cFtTQoubGsZYuTEIzfKJXaCrU2xjTw8sU9aXCkoc9418JBbOrMMEZSGkkp4KNy/WKcOB4fTGTYwPd4svWEWaPZwI4K5gmq7/paYBVDxMerBJVrk/XOb7YR0K1b7sHgPHd3d7x5+2QOBmb1VFb8sLN9r2mxFwP3L17qMJZ8YjnPnE/PlLJSah/Z67fv08cNh+CQkm1fVKoMJvbQZyTbVqhiKIu1ntxW5aU6e0/9oGyi430jDU+hlIXT+YnHh7fUctZWdQ3KiyduiPLHhZO7+rdsP0vzzPMfnoOKKeZxjSZZoU24enZgY/E2DV2pjSXbXudBpDCfdZBPaR+DMiEm6zrqV40p2hpxmx2j8xFfs+7Ktu987Lfptw5F7xl1MXCTS9LaQIGBJqSUGIaJNOognxS8beuCUAm4S3fRvpA3LYt3mkgPw8Balm3wRM59ner6Up62il8dWpzGlFTPUvJGa3DSiwAbQiKW/PUEVS6o+nU3VdTtX39t574QdFw3ShNs/oI4O6/3PU2TdQD60BOnHT5ptFqYT088Pbzl+Pyem/24USVAO2tb+kRP9zsFzUFr3xu3P6zFby/P44hJx0SK5TtpGBjSnt20B4Rl0QTrfH7GOZ3BO4yDWXAIwVXUdsIRHQwDBC+UVqh15fhh5de//i0PT4/MJdtEG7+plPWDYyO8/DZsI5dCzJkGpgLWxzSOIyklaq38+te/5q/+4s83PsmW7XeVEj1gvWX/CnPHmDjsb3n/4UjLlaEUcvI2TUnvaRxG/viP/5Sf/eyPcQysa2WenwhhtYWr7eCtkB8G2O23e/jsM7ZEtOTMmzdveHp64nQ8cj6dWdeV4/lkyUSvUJ2aulsbSM3eK4GGlMxyeuTp4S04NffWBVlpZcG5g7W33eVzW1KnlWJ/BrYAtmdziQrnIA7DDwmp3/t1jfRfqkvwQdvjaUiU1Qz6WzOls25EIQT977Iyr3lLkkLwTCmx2+2ZUtQqVVSxGscBR2O/G6kv7tnv7njx+hO++uor3r5/x/vHB47HIwCu6YGVEXzNnJ7VGTmEwBATu3Hi/vYGF3RiD7bRhqRVfDecDldA4aWdInS6ipLZATHLNg/kyt3dC969P9qM6Moqaiqdi/GigSqVP/3Tv+Dx6cjp+ZlSZo2zu2pIiQpp+sbamhqqPzy8t4LqzOn5xOn5eRuvKjbbGjqYqoWut8LP01HUZtxxEwki4HWzGoPj68d3rMsT3i8gFWnFNmbHxW7mHxUl26/unfB/+8HR9i9ziRX1rSkVpOC1IC/ayvdeubox6LQ4EZimPd4P1vJXwcZuCkxjAuDm5obdLiJSQCrd09MjKp4bE7vdgWm/YxxHE07Bw8MTx+PZFMmeIUWGYUL9VaMqmxEkQ81VhUXeEX1gqVW9ow1NijHq6F5vJAuz99FJP2o31a1qtu6XD1Aar19/yuPTik4cDBRD30Iu+OA2EGQcJl7cv+Bw2G/I3jKfWZaZdZmZ54VSKksuGzWqlJXWCp0b3vfyZBoALx5XL4im4haKuCqopA4JJTfyUkxgy1YgNBpeGtE18nLiw5svWZf31PKMd4HS4lVxtX2H3/n1FVRkcfIxWvaHu9r2Y6OWdScN87PVaUXK5V3XzMPTiVIDMe7UGUUCS8ksy6oWTDiGmHj54p7DIalTjvEpPUqd8uZGEUIiREdpme5JfW3Z1YuFj228MOGhEj8wWp2OpbUE2dBaBd288kedbL6s2vI28KMXe1UQpz2OyXtevHjJ8fi1dZqFOjTyki/m9+5yZt3d3/P5T36C8/D4+AERBb5qKfS2evBO9Sm2doQu5m5KAzD0WcOij2jv+50Vfa3iilKslI7QUW5HdInkR5KftGODs4GHTcVnZUHKmacPb3j39gukPCMFxKiY1prYutGXvVYuOgHhe+P2ByWo2tXR6iHnGeeENERqKSwl8+rlntq0sj2dzzyfTrRWdXqHE521Gx2q+mGrNIL3OCm0unJ8PPOf/9N/obSR5/NMFUhhwFtLQBlAdlCiEx16PeS8w7XeqjKEEkUVzstMk8aQBj755JPtz1wI1VcVa4fp0RFmuTTO54V37594Oj7z/uFICAlxUaudJqy5WIVW+d/+t/+IMIJP3N29xgHBn4CiIx573dOuN7zOQWN7qeOQSPEnfPr6E21Jm5XH8/lEk8qyzizLybitC8mPyqc0ZKOsmZrPPJ8eeD69M1N2+/5NqE49MptvxgFms+/o9+C6cKATULp/Rb9zp4slhY7K/DivEDzDmNjvJs5HtQ1JYSCkgRgT0zSZ4EkrxLLM2qpL3ibSQIpFHR8EG8gpqqB3mf1+B06HMfzNf/8bvvzqS87rYsMb5DtWp4q2gAr7wFFK4dzO7HbGzfYBnH6XaTeB0wlozsGLF3eXDaCD3bI5sXKxsbL2iqjDw/7mXlGolok5k5Kn1oxauTR8gJv9Df+n//P/lf/yX/+a//bXf82Hd28IYTWFqh483qmps8ilKHr14gWKlGrCOs9nllknsZQ1sywLx+OReT2r8Md1ZbRQC6rgH5QeM46jjh9slUQlecfjwzuOD19T8xHvDAmoDaTipFpXIVyQfviIh/axSb/9nsCTwP/8LxJx//Rrs827erYxRFbnaKWxlkpeVoZxUhTQKx/5008/ZSmNWh2lCPO8kqLDx0BKkzqmDIrQlKpCniEKSGG/27Hf3zLtDhxubqmt8XR84ps33/Lw+MS6LtT1cpjM3oF/xgdHipEhJhtU4hlToA8B6CBiL646Ohw79xSHd02RLy+I9MEVBkKgxVXyalUU40Tw3+rXtu+RS2No6h6gaNOOw+GO/f6OWhvLOoNkbva3IN0CSRPZNWvLXxCW5cS7d+94Pj5zPp+t0DpZq167VWLUFZEGQcw+yQ5j6XunkIvuqdKU+78uC0MaCCFS15nz8QNPj9/QqolVZbTizQCAjdf7cUfrOk0V20zcBnj8GC5Lmrmoyktu5KZOBUOacF6FRzqoI7IbdvigwFOrmhu0pmfJmBKH/Z67uxuEbKxx4/obz1O7uIkQA+OYGPcqSqu18f79e9Z1MTRVkc8QgolXzUkABXLWdd3sv9jszBTgGoaBIaqo2jlNYEM/C511H3ruIOqXTv+dGHnx4p7f/OZrFdh5dRzKRX17A9E8SAshRj77/HN8VCpIKSslr6zLwjyfOZ2fOT0/69e9ssxMKVnnCisA1AkjBXXo8N5vA1BAt8cm4FtTV46A2mOtjTZoF0saOKcTqbIBF81pV8PLyvv3X/Pu7W95fPyGJjNVdsReoOjT4yPAy8C+doX+f1/c/nAEFW3HzecTwTumMSG1klf99Mu6ssxnzqczOWd6Qrmu4FwD0gUCDgr7a/YeUeNpHQVZLNG8Jtzroc5VVSTGs7w6lyzhhR48+ut1XUkxMQwDt7eqhOaK6Ny5mz05Vejek1fh3ftH3rx94Ju37ykVTudCiA7CQhonDrd2L8bP+Oqbbwj/6T9z2N8T046YJpwUnBn89iQRa3dsdIKL7mC7pmmipbYtehHh5u6WhlZMtWZ1BsiZ25sdd7f31lKDeT6yzkfO8yMiC/TvawQrraZ0ZrAHjPzV8077M4bObY/X4aRzfC4I5d/fTv1xXN0izYfebEAP+aBoVAiRdV11vOKqgwyGYVBrkaDVuvcVnFrPOEMsg284qcynI48fTiy58u3bB56fT1RRdB8xxSTXz7XhfGCj8gmbIfpV734rBkoplFxULOI68s9mM3IFgm+bQnMm8qqwrJVSYV51ipSPmd1upDZFiZso/xPnePvuPc4l7m5ecjo+E4Ij+AKuF4c9VDpnztZzNzIfB/a7kVaFu8ONivRKUepKXil1ZV7OzIs6XAhFHS2aAnveECiPqA9grRwf35kDhc6BpherhoI5r4K3zhun/9yfE5fOS0dUQJdg/JHE7kZPkS60UCuz+eQV6c6rciTtIIxp0G0jOCIdRayIVHyMpMj2I3oz+3fVVLmKot7eHHA+EeJIq5U3b9/y+PTI8XRiXmaNiY1Yigoumo5SbLVSc6HmzJASKR7ohvpVYAhKiwGMGqIilss66PI8s9fqjiJOiw3n/aZW7tzpVkxQJ85G5GrQ5Fy4mQZ+8Ud/Rmuep+ORr776LbQV7wvd0qx/+VLtNHOOVm95cXfHPC8sy8q8zDw8PGqCua6UnBERFgNMsGk92n5FE4amP1oTEwBHLUpbYYgTSCYvzyzzE6U841yP47olqP3w3kLX/nvbILAHt4FS/kex714jk71j2UR0BHYt0CopOgKBGPXM93HA+ZEmOoREWmNIQX3JQ2QcBnbTRIraWfEbKgcpRaZpYNrtlSsZg3rotsb5fOJ0OnN8eqKVYp662t6PSTmhMQQFcbzb+PfNcWW23zbLt4uKvRf/RrfE6ArX76bpxEYfItGQzdvbROiOJASaaG5TWiXWYoUZOB843NxTmyOXTKsZaZVaMyUvul+ezza9sANoylM9z2frDJz1XkST4T5BUkmmVkDo47fGk+Y7YjoAtc1SmoATnUhXq3qc6sAOR1lPPD18w3x+T6tnhGxgYc8FNPlUAafbwJPeOe6L//vi9of5oNrKERHm85mbfSLFSE2JajO912VlnmdT2hs31DVT5DZCaNq+8eBEicJdINLP5RgDvnkSES9mxNzscNQ72RCk3u78GEXCuK9ioyN1g1SOqPJCrg9/+1RctgSrUnC8//DIl1+/5etv3/H+4YiPI5BIzjNn4XiuvCyW3opWZMfnM//lv/43/uSP/5IXdy8IYUTawpWLiHqM9uS030G3aLhKUsWDxMvhqh9bN21ntg6d/5JSYBoH28yF0/mZdT6S8xnn64VzulWh6g0ooSjS1rp/5PadEPrElXahEHDFWTVEkO8JuD/0pfFlrSfbBHXjUtSuibDmlWVdWdf1yvJMkX/vhT4tSwnjFq9WhZ9Pzzx8+MCahePTkyWnZmhvMp5NRW7Epa1Nv92jbfSb+b4e6LlcrJrGMW0J3HbSN/nOhwXwSPPk3DjNmYfHE+taeZ51XYoP7PYT0ySm5jeeqHP8p//8X9hP9wzDnnE84BATk1TEOgB+Q/r1Rtz2fVXAlaLSE6ZxNPTYHCtaodTC8+nI8/OReT6rX2JRUd84TPo1jHcltZDzyvPzB2o9a4sa2dZ3E03I1M/WNm6RbdqK34R/122n60clP3Ss3u/92nhjcrE80kl36te4zAtTmgCv6GVKiEBt2WgnBRFF+UOEGPRH8IJ3Rd9jEFwQvE2o2u0malNU5+n4yJs3bznNJ7KhgIrmdgHm5QhSUxH9M9KpHNzSh1Y00aRSTdeFeZ7Z7/doKu2uPrMipkb0YNvB+wQ3nd+M94Fqw17W3BhrI3bRlDTrYAU+ef0pIe2Z3j/w7u0DtID3K8518Y6usyQA3Zd44v72VpEtm9b2dHyi5MLz8Zl5nmmt8vThgWL8YFDv1yr5qpuhaygNyUASAamk4JF1YV01QW0GFjgDC1qrdnZdPGSu11VnIYMWpNuL4Dvr/g90Xe9b3pkGolbEElS3caMjATQ2RRASy5qNzlOJIRCHgZQS4zAwJOXmimsE3wzAErUqmw7sdgfiMNBa4+n8zOl04vn5mdPzmWVWTcfmQOE9vgSS96SoeoNok/T85oqhhXpw7ju7hDV7rpIr58LFUqnTDg2M0I6xll8pRWJIgIlTpY/xteEGUo3Sknj96jN20x3vP7yn5JltlLyUrdVfrXjFCtJ5PtvnPnFMR5ZlUY9Rh35mp5SA2pX8l9DSc8gmVHaayvYxUfBKaW4W2yLM5yOn5/esy6N2APqY3qu/p6J0ezRXhdd3c4t/6PqBe7LdQhWW05n94Iw8HMleWOeFZV02JOrv+tvSmrY9HSCe6B1xVD5V51LkrK0PrUL7A5SrhalfbePcuf4oZHtAmg/0zD1oa6HWS/Epsi0sRKtW3VL6o/bUBv/5v/4N33z7nuN5JTdPGoRhGnFpj087zmtkyQFHpfoGFJwP/Pe/+RX3t59xs7/HkXAuaaVhk4x8cFv1beF/NQ3HnrOzT9U/P7DxDT2GbHmCswUXnXmXRXMHWJC20lyzxdSrGBNcVZ32FUQNsL0LmlQB2xxLrnmnXWdqb7O/E3fh+v5oL4e17zMpRXa7kVZVVJZS0kV+OjHPZ51y4Souz/hQEYnEpFNNQvDgW+e7KCrTMut85nw66ThU50ghIc7Z+Lgei/3v6IF7qS4B7zZEphv394g+nU7c3txwf3fH/f39trc4+/v92fc1ontloBR4PJ759tv3/O0XX+F94vF5BmCpat007vZMGfMaDQiO//n/8//lz//s3/H5pz9lf7hnnbOhI+pdCnUD1bbaRLTA+q7Jux+GTXg4TRPihUrlNt/oHmEH83w6KdqUIqoMR9XpzNTlzHl+orUVEeUG98SpdwBcs2lCvp/dDkxJjFzQkV7N9tuvNB5/37H2A6+PEVTliinqr6LQdVmZhsPGmR6HkVILy+nMui7aXm7COCaGQffWFCFGUaTfdjcfIAYH5l94mmfef3jiyy+/5lyKcs0EtkkRW8vusleq+E3vs0pHsU2kafxDF5R7uswz83xWZNf57+wVTrVG/uq9uIAQ1Kxd/DZOOFdHzpXzUkhjJsbOGRXWZQUcx+OJz3/yKS9fjuym39BasOR3RdDiBizRw13avzjiGGlDorWJu7sbvAusy2LT2IS3b96oUNerA8uHhw8cnz9Qa6ZzLmtHoro4w+zpasss85F5fkBk1YJfzCGgFuVTk8A0AhjqF+Cyxlx/Yv1Z/TgcKDp9wxuCqrzegpSMa83OpESKCgyJE6oItTnOs47e3rj+U2QaEzGokNoZqBJ8w7tKcMKLu3um3YE4TNTW+PDhA1988RvOsyH+W5PQxq07kAqSIVt3MXhPiondbke6uVVHIVS0PO12ynnFOq9J0yX30dnH9nv9V12r4kPABY80RwgD3qvfuE7AUt9RjVtFjmNIjMPEL/7oT8lF+F/+l/+VuT0SUzVhc8GZvefl+ygHthRN8Odl4enpiXVdefv2LfM8s64ry7Kosqaul9ypYR26To70tOqopuJX31avPvJOO0yeBnXlfHzLMj8aWrsaNdDyGtOs1Fa1I3ad6Mu1A4H/3rj94T6oItBgWRY+vM8McSD4wDQMnM9HchXj8qFtdKuMdtPEfjfig1aMTurVmFH1ddRWY1XSupghrNnUNJtiQ/uu+Qb0ur4nrHFINCesrTCYAjCXbPyXcnWIXgdXb1eCMk08x9PMt2/e8/h8ptlsc3EJ8QO729f89Gc/549/8Sd8ePtbavug6IVr7A43/O3f/opXLz9jv9szDZEhBZuJax5khnGHoHpSTUi76Ek/knNmKeNsIciFuhCDV2NgH4g+goPgdCwZ4pWY7gd8cARXkDJR8yNGqdoQulZmqOpo0FwluKiuBUBPnGlq03Wp5i/voFYhS7zksz/Sq5aiEz5K4bDbUXOlWXV9nmeOxyPn00yplgC5yrJkRDK1RFIxex4P4zBsk8569ei9U9qHDxziQCWQS1UOT+3Cu15Q6XN1VxQJ1UY7pFQkNp1MZerK5+dn9vs94ziZR2v4aIF3Lp3GlNc14wJff/OG//43v+HLr7/lea3EMOLTgTgkiou8+1D55JPE6WxzxZ3ntMz8r//hPzKkF9wePmW3u6XkIw5H8PkSt7D9eitcLWnu21K3F+nFIIBQiHiGGHD7ie784bHRw8kzDSPOOY6nR06tInUlpEArynFs4hDfqLlR80z3hxeniVy3RBJpJixTlE3gO8peKK7y9vcYZ//cq6OnzVwSnBfle46J6bBDgJu7W8bdjhASa63MeWVelq0tqSrcRAr9fSh6GsCEoeDJSFn5r//Hf+bxODOvjbUUJEQ80XZEoVHpTgwYAGAOp3rAOTvignK1t0mn5nF7ns/EELi/v+f+/r5/Suhf0WK32n7nLXYRTymNp+OZL776Bu8Tx9NKzhVxJ27u78jNUQ1IWHMjppH/5//rf+Lf/tv/kZ/+5I/45JOf8f7db+nevLrTapHedebea39jAzzwWnRaDO+mid2oDiUvX7zQhBwTGS4LT6cnpBXm05nT8YlaslrXdWClVGpeWZeZ5fzEPB+RmpXbbyr1LjbU5NcWkYESl76ebdrfOdk326wfxWVJiVOnHNeqopFOQYBxGtX1oxa6P7lHhT8Bx5C8of6N6CE4wXlhiokYNAkK0XN7ewAS337zDW/evuPD4wNZ1Fv84nCzQVFcGXnTOiBVK9KEYRjUD7drMND8YbffM5/PPD09cjj8Ed0XRc9h3fRdVSBBv7TaiuESSMCMqxEirQZKbZznypCENCgQUM2aLMaR3e6Gn3z+c0IYePPmgb/9m/9K9OoB631AyFrYib+0zxHG/QGA25sbXr98SWuNP/uzP1Ov4Hnm8eGBvKzKsT6fWFa1sKxNaWxq5SXECLV7WPe14JQzHpyj1czp+ZEvv/rvlHIEWaEpGCe10Gq5dFidUKvb0OvwHaDf8/1x+70J6rVhcLftuR4LV0rhVCuMjt2olYja1pzpggslMQ+kGBiHqJN2kgMqXiw79/7qoLt875oLLgjiotWJzdyPLhB3vzpfC1Stfzgc2EQRYr6CmFraOFFcJan9UPV07qmjVscXv/qKWhUtEDzNeT3cm5KHqziG3Qvu7wvnU4bW1CstBuZ85vHpkXfv3zOmyE9/equ0hq1qNz4LlwS1uZ6sqEWR2uwosipX4iS1FfKb9ZCPOmM4btMwzKVNoS2cm/DxFgnvdaScVfatqTinlgKo7YWOsHVWgvYWhtMt/Qrl6IMGalMUKv/IE9S8rpyfnzk+PnG73xOdV+J3KRwfHzmdTldToQC6Tcio/qaGwOrsY201pRBIQUnxrRYdwiCJ5qLF0YU31Z9lR8P79Bxg+zObUbvNgBavs6JL07nO14dTT3LZPPnCpfART6nwn//Lf+Obt4+cl0KRACEyuMQw3nJze8v9/T1x2FtrWEV85/Mzz88nvvr6K16//JSf/exzcAnvVo1Xb+0bZ/zuzhv0RmPo1ZXenJJBtuTUWrlmY+a9crxi50vZGGXnIrlCaVXtVcQRhkQtkSaGuNn+JCbCaLVSXSFsyKkhfv2h9QpeXYbULgbHwcFf/j4D7Z95bUmJ0+KkGL/zcNjjBJZZbFoNzGXh+fjM8Xi0olvpK8ta2a0OH6OemYDQcFFV/84ehFTl0scUGZzgQqC47sV6UfZeo0QXqoylTaLoZww6J3x7j0G/zvF45OWLF9zf318KlQ1X0D1aOhlfHOIC3iXWAl9//Y4vvvqGL9+8AwmsGcDDUnnz/sgnr+5ZsihVLA4sy8Kbb9/wN+OvkTby+aef4uNobiXVkmtDUTuS7hxemu7xNt1Cbc564uE3JCg49TSOThAiwxDYHya2aUU2ueXFzYHdbsKhFm1Pjx+o56N2q7ypMprxuFsfW1uIg92aqD+lNFWIS3/Qdj8fmdB/p2Pxh7q2Fr9X3rHed6dQjeymPTFEStHJTGtZzR9duachaOt9GhzRC8EVnTLW3Q1q3y8D5+czb9898f6DcqVzE8R3cd12R797jwBUmyilGViMkb4zAfp+WqPUQoiBXVA+cYgBd7WH65ldwKgpuscFmuieV6qi+t4LzUXWsnI8zYy7iViiKuOrusl4N/D8fOZXv/4tw3jDNN2yn17Q2iM+LKZ96Hxn7eRp7F4EW+Iw9NrWZYpMw8Bh2gHw+eefq46hVpastoGn85O6W2RFW6nQMkh1eBc2SyikUfPK8fENtZyhLagXTTXf2saGXdqQAO/UhcXJBeffurDyu522717/YIK6tb7/DhxWQM1d7Waq2QX0ZMnZg/LeEaMZ6IewVeGK/jhD+2TzcewhlGLi7vaG9d2sH9zXrWbvdZHbLDmCfW8dP3lzs+flizv2ux3zrJZM17WUNzP/y6PqqBaXjdiSEwF+++WX5KonmrN7P9weeDiuHM/PfHh8YFkK43RLqztaXQlhpZRMo3I8PfHu/Rt2w8hPf3pDT1hU5OK5+I26j77/pYXT78UG8lklqFX/lVDG9aGTW05uQWH2+y7g4oiPE7I+bu9RaNRqIilR1Fi90vq92aGBXP7TAqz1gKym3Uv/YLz9q1/XaRKAVJ37vCwrU0ykqIVGKZU5z8ZRFkMAvCFRYbMY6TGnRs2XDVnBDuVHN2s5ixVHIp0eqj0n4cKd7n6lnZ7SkS86/9SJdVi1fdquFvXFBBk6bOm331Ce0/sPH3h8OrEs2Sa3OHABcQFCYtzf8rOf/QWuZSjvkDKjiuaFUlaejo+8f3jPi5d3BBNmK/rf+rfZ7tvbZg9sRdaGNPQa52qb6mOPvUPbf5gQzXdvTZ2+o6IntZVxYcT7Hc6d9F1IH6dYzV6lKrqwTYN36OHRrgLBVoZ0qY7+zvPvId5+H9clKWJDomKMSEq0MlAGFcoBzMtMWQvn85m6DULRxV8b5LxAK1oIe4gIMYz0jPXiatDpQoq8e2cHji7srZDvcXs9JabvMm7bH8QKAf0z1cZA9gEml+uCaH1U0FgHABy/+c0X/ParN7x5/8DT84JziRB3KgwLiXkW1uqYV0Xb8IElL9RW+fbtW8bdPa9efwp+AB/xEtDxupf91jZb46H6LUHtxUHfB9git68zvWfv01ZkeefVXso7xhjwISnfsFSO6xFf5k0E2dXgVR+OxnApW4KlT9AIa9I+Mjq/FLX6/tyPgkDdtuIyBLcVKBcesjqliKg4KOdsSF5H/Dt4pAMjXBfzItuzAl3ftTa++fprHp9nTueVsp3PF4vI381belxebQUOS6gvezC2p3cnkmkc2U2jxa7r9VQHuK+ufnYr7/98zhyflTYDnmWt5Cqc55V5LYxj1Qlblv85L5zOM//9b35FGg7c371kt79lns9ApnNo+/fo+hjNI9juTQgbsuqcg6AuIA4F7kDButIa6zpzmu+oJVNb5nw+0/LKfhzN8UN3yFYbBes+1mJxKbY3Xzq6/Xk0xECAnkf0nO2yZ+D53rj9RyWo/cf1BI2NF0l/2xf9lpoxB6rrL96I9a1Pm2l4l5Qo7flImdcrmiENvH75kqfjG/WqA/AqfOibhVxtat57pmnk9vaGTz55xWefvCLnvKnb+2PpJud9Pm2viq/O2i057Sfwt2/eUNE2pPcOgudws+f988zz6Zn3H95zPi3sXuxIw0StyqNb1hNC4/n5kXfv33J7uLEFcNkA3eWDb/d4xXC5/Mo5Q+0ubXUPm9+/RchHycr1QlRExuP8SEgHnI9Ul6/oBOrV5yWqKMUQPvVIu1q8XFol0nqB4ilFqD+uPpNe0qPU7llUpb6umbOfub25g1apdaUUHZ3bW4y6cYlOe4qJmC6+hsG4QN6qcGfroXOhW6uWoBopfruHS/UNcDn4LDkNgf1hr5uhNz6lsBWA17T9j+PD0Mi+Dp0KNb766hvWUjvrGAFiVG/L2gRc5MXLn1GWZ9bTTOYZmtcRmK5yOh15/+E9rx5f8PJe0aA+4s9txdV1aeUQD1789vuCs0NXvnP3+u9u7RLwBPMs1nGWFvM9qQYcI97v8f7RDnYVTNZWCb3Iamrwr4+kt2rZ4na7A2FbT02E8uMAoT5CFnpypLQSLfRjCMSgApSyLqzLyjLPZlenHFMMMW21kKVevJ49iERLfHU/1HGSNqrXBW21hgCmkq9c8/rh0uqHXmzDtq0pFSj0xMIp6g8mBvkY3dL9apuZZr+r/y658Te/+g3fvnvgvBRy84Q04H3Ep4k0TsRhIsSDqvFNaLKWlTQkHh8f+Pqbb/jTP/9LGkHdMiQQrvb2Pp/8unvBFU9ZREdf08+/7c6N12x/J0brYrmLFiAEpSk0ceRSqXkmNUXbfNCkVgGHbjfYqCXb87C1JYpA6pkr21m7JR92nrgfBTBg+4IVOikFG+Gpk75iUkFqLosKUbPqVC4DSADxeBetkLccQ+wzenDmsVqL8P7De3JVC0js2Su16XeLeOjn2VWRhe2hzm3vv4eGc5cE9eawZ7/v3Vh95trIdDaOGDpfXsEHz7I0Pnw48u3b93z97TsdObwWEMeSK8+nhWk3shZ9jx3wWZaVr799gw87/od/d8e4O5DLgLTFxE6dcOe3gkXPH/s67iLz7tGqSaqOvY79v52m8fv9yL7sFYX1TidZLjNBhJvDgT6MpqyZ5oScF83xXEdE+xoSmxx4SVwvBUHfI0SBkX4G/iPi9h9Vd123+FurOKdcRZrDe518Ewz1qTUzjgkXDqzrqguuNRVUSaNW+/N0Yq5uqvq1L4X0MAx89tnnPJ0K7x+fqeJoziNzoSCbgS5o1TVNE59//jmvX73g7vbAzc2O92/fbShJT0xba9sY1tCnM2y8yu8mAJpAllJwseH7POrk2Y0RL5U5Z57nM3POzHMkuAgSmBedpyutcHp+5GmYGLyhOq6rRvtnuCTd/XtuiJtdHnfNRth+2n4YJ1g/8Ecp9/YVRCIwEcdPkPMHWm3boYbolB7vC5160FXRznk7mDClbdumVpXWlFtTGtkn5fb82K6rM1FED8p1XnicF26nG3bDSHCBdVFBX4jexGZqBD0MiZQiKXrll9K5057YET9DfYYhMiYVVVRBLdTQsY0OELPf0SkfFVASvnIwIzc3B375y1/y4cMHcll1A0TV0Wp3lTYU6vpJO3eZW9N32drgv/31r3S6kG1ogufm9oaH48Lx9Ez48IGH48ynL14S3AnvF3JZcUFIg+fp+MCXX33BNCVu7/6EwasAKThtwVtvF8XuPY6gfEXvNuRT80uxz9yu7tlvnRPnnJm3B1Pu90/otjJbkegBH/e4PHApUqEVoVAILuNjoNarNjSKQDn3sXLcSe/+CFOp/F9+L8H2+7m0RdYFcyqQa2W1sbwwxcg6z+S1sKyZZV0vhyxaSA9D3PwRZTvw1aM5+KTG/E59pVVkYYNinXKqQwgqTGrKl++sFz3or4u+rrVQHvGFCqZ/ttSKq5VSqo1R/PjaOgEEOvdCxPHm3XvePzxxOmeqeMQF41XrhLdhf8+f/cVf8eL2wPHDl+TlPd4pIPHixT3v3n3NN998xePDA/jGFI124PQzauj0Nil0m6suPdY8phefF94iXNCgbkEUggoivf3d4DzRRVOzK0cfIgRPcHtoC8VrWzngoGmRoB2cuhW0qr1QUe+Fi2rtG7kkG79D8PtDXE61I7hGTIGbmwN5XcnOEYMW+SLwfFI6yrycrXhRSoq0FamR4CoxeqJDARTHNrDhIvAVbm72LCusFbJ18NQ54LqYuMSp6+3xLbWyAvnqgOjIqPfeBMbdhejv/shiNDmcri01xvV88+23/O2vfsvX37zluOqZmoaDelu3yNsPR8bDnmnfbQa9OulI4+uvv6GUwJ/88V+ymyZCGGle6SnRKCoQLgW30+ei3VgPHryO57nsrZ1hvQGMjWBfJ6ZeUAXubjXRHrwnWc6ECMen95p8ignZXM8HbUiE8/ouRS7fQ5pRs/wlZjuoiQfXvjdu/0mNAb2ZzoP0OB/4yec/h5ZpOVPWhYenZ+5fvGSIkVYytY8opDGOI/vdxGE/4UCnjCxnal0RGsEn2mj2DOgUkV/+8S9xX3zJac6spZHXooevU85fCIHdbsef//mfcXd7q8q/qAmnugBUazd4xnGi5IIjbMm2WoxoknoJZUvGgie6oItHqh6gQXCuInXGuarobys8PT+RfIH2RC1P1PVZE3Uq8/zM8fiBaUw4X9iyld7K2r7pBQ695tFs6LXrm/4GAHx3udDbnmITH/qf0cTf49yowRxe4nyl+QqxQmmbqbTEiogmyWKzer2N7GxiXplNKNZRVRFQI6em441+1JcmTjp5zFFLUzNze8bjlLZ46W2fPr0nRhvT6BzJD2ow7pRaAoAIr1++AhJf/PZb3j+etw1PEzBvyLT5nBIIPjJOIy9f3PH61Us+/fQ1IXmOz4+0qs+yc1L3+z3TtDNrLLfZh1wu81Zw0McJfvjwAUl7NUnHk0LixctbHk8zz/MReQy8f/jA/X7HbneAtuf5pPy84GCZT3z48Javvxn4d//+l10VZQf3pR2sJedFxbslMXZ/wZ5Pu+4AdJW3iArIuv1WD26P9b6u0ABA/ED1A8UnmodW9evWWllzxpdkPOq/G0m5vvJayU14Uxr/739+cP3+L1uDp6dnaj4TnCeFAXGZsq6sWe26ELF9U0ecxuAZbNiBiKGjxpsM1hJ0XqxIVl6fOiEIuKCT5pDNYgqc8QA7wttf7QXpTSmxuzkQkjf0H7wlqOqDKpttW9hiqB+yTb1dzVaqiuev//pX5CJbwtoEdmmiCsxrZlwbdy9+zuFwwzqfKOVEqYuGp28s+Zl5Lbx5+5YmmV/8ZIePDefqRcR1ZVmI6Frrk4E2hxd7FdrJ6B0D/czBqV1EsBIt2qhkTQkc6g/oNrV0Q4WIPuxwYUC88lnV19KM2VshhGTFVH8/jT6KduNZbQ4KjtJO/0IB+E+7ig0owJKXmCJSmxZCrfH+/VuOx6Mip/Wqr9Ns3KhrqKlHULc424di0EEGeg5qLC/LQq5asAxJ0epcCxt/XwSuyva/6+p0DWVuNQhhe+eLuRDVdmldXygfcAGWdK9VPUCgFsd//N//D94/HjVxFvVExQ34tGPc73n9yaek6CniWStED1Iy4uDN2294/+HML//kL/j5L/5I0WH7J2Dcf0IHKPUMcBcxUr8C7gJWNcP7+/Fge2yInVLljDfujXaJft8QWXPDiXqkexGCeKKPV14YAlUoy4rsLel0okNmxECtrtu40kwI7Xvj9h+XoF5vJFevVkeIRmot5FJYloXlfGba7fDe24jD/iI94zjq+LwQQYQQI/Wk86MdQvUg4onp0jLZjZGf/uRTHp7OfHh6ppTC81ktE6bdxIsX93z66Wd8/tknZugv2rI1c9nOf4oxkmLi+PTM09MTwxA5PydevXplE6wu7dl+ieiIMO042Ciz4HC+UvOJMQHOE3zj8fE9sj4T/SNOnkEWdrsbQlQVYogwjio+ak1n316e6wX2tu+sB7G7/m1DOh1XzYnr/9cjrzdG+lvq/zasWsC5REoHanmmlhmd6FWMO1lptdC8I3lvkH1Dure/HTK1CbWIzZg26l+Q7/CkfnyXd4EYE+O4I6IJt1p8RO7ubjkvy4b81NJU+FUX3GFUPz6briGilIbezu+I0jiMvLhzlALH0xd0mxid9a2cSt2/dU3EFPns09e8fv2K+7sbtb1qTbuMcmkhAkzTjpTSFqMXrqyzVkp3BcA8Xju14KotHywh9xUolLJyPB5ZygqSOc0Lp9MMr+9M3ekoZebx+IFcFnb0PaZH4SYRv7qsWbutfWcJjds+i1ytt4/3lo+tjLhC6jSGPd6PhHRDqLeUPNPcCtaIxrh8iBj6rBt6M5Nvrr5fFchVWEtDcuX1jzB0t3Gh55k8n0gxknaRw25PLrrvdscCnYrnjfcfmMaJGLS1rV2SRnAm4DS+ZEfe724P5PzMaS5G/8AsETSB64WQJkmeiwOF2obdHPbc399xf3/Hw4f3ipY7EOtA3dzcMAzjVsxdH6ad0+dd59A5Smn8+jdfsFZVQXfR3P3LO94/njkvZzg+8f7hyDTecLh7DW7m8eGZab9j+eYtpSzkXPjiy99wcztRZQDftnao9wkdWmLcQUtQ++CWjjxt23AvumxztaP2CpXXWO1je/X56BrdothVXbM+4uOO6rxFrs3XEfWTVQBI2LyT6UI1tq+rHE2PSGEtPw4GdWuNXApr1uSudy6pUNaVWoV5UQW5xpIoIBACKXZv0svB52zNKq1qIHqvJJbWFNhqceNdXg/q+YifvyH914XVZT9yZsKve4O+49aaoafVgDn9+8GAmv51dWldkO3WHL/+4ivmNVOa7jHVuhLNByoe8SOffv6nvHr5gtPTt5T1gcYZZ/SSUlbm84mnpyeejk8cdsIQvBaWHe2/+iA94ey0tIuAnKsP299Qt6+zvRdnI3n1R/QKfgT7etK85Qz2cL2ADITxlpAfkZahaoem5FWt0kTBw157iKjV1qbv7kiqFNay/IPx9I9s8f/u73Sz1ZLVxiAvixJozb+0t9N7IKSUGMdJSdJoy8N1zoh0RVevbiveNw3c6Lm7u8XHhDdjXfwTzgVub295/clrXr96xTQO0CfK0NROqBRrK/YNUZOJ0+kZ54QhBu7v7nAp2oHaELpKDmu7dEK7J6VISJHSMrWsSuY2Zd/z8ZFycux3CyksBFd17J4XgheGwXM4TGwtCnuOIh8/z8sjNmQJofNBL//vGhWyTXFLdnt17T463HvKqnHtCXGvVbx/Rjhv99JtTkIIijI6NeMXRD3kaPZn1JaiCdTqtwX8Y798CIzDjpubO3xTF4rsM0Ma2E8Ty7rQeU/NRCJDsjnM3pAR51jXWVF1B8FQdWctvXEYefHintu7D+SsG1QV80YUFVrF6BiGgZcvXvCTn3zOzWHPOESCs/buVcHSyfnQuxhVBU9XCCFcDkzomxb46KiinrtqoF1xZLyr6KjQwtPTI6fziezU5Hrp3sVW5da6sq5nRM3ODFBz3/muffeR61unx+c25Yoeg9cHCB/H7vaDq83HdcALcREf9sThlmV5RnIF3+y7tS2p6l9HW9NKleiISjN/xJwLa1Zrpfr94fOvcn2Xg+oJ5LWQ14IXh4xCHCOlVuXvBg9B4yQYl8/3osWZQMLQ6RS0ybEZl9vecX93x7w0cj2zrEY/sVfrXdcgdD76pcOw3++5u73l/v5WR+/i1E9WMA63FnPTNDGOo4qwvotqSxdUYeeavq3n8wniHhcu97rbDXw4nigtMy9n3j888MmrTxjDoK1QcfiYjF62sszCm7df4+Nrmryid6mc62KTbhHX//HIFZdeb6kXS1owyBVNoTtCax7VP08/0A1kcEIzVK5vy84HfJxoPiF+teEs1vlq2hrVv6yghB4U7up7bsGCUFll/j1H4Q+7qk2Ly2umFBXyhQ501EbOxQS5l2EJnU6VktowKuW3YdnBJqTshT6uFxRdjMr2fv4+/unH14WzGaN6Yadx6LojBS3sc2zf8xpRv/q62smyncbpOfjb337FWmyvtCLHR3UhWksl5koYDuz2r5BamF2l5kxMg9E7GrmsvP/wjsPdLUMcSB7zGjUdzNU266Q/G/c7YIHrSJc9I/loW3UXH2CMBnl1xmmRZQi0uVs0p78Owx4XR8gWdyIKCEolWhG73WRHT21d93tp0ljl94CgCh8fOv399Crj9HyilQVaVTJ/rbootSRRReM4kdJA53Qqv9HpQvURaYa2bhBwdwFQ5DWkRJom9vs9cVSz39vbO16+fME07HDWAunGx7UqinrNVW3ScB7WvFIfMtF7G+elDwwRGtqO6JuLtC6GiUy7kRAjz+eFkldtoYURfOL09MCMqUPHgvjK8/EZh04gGsfA3d0BG71C/wZy9Ty358vH6KkuuCsBUg+ybfKW4zoqu7XRVqlcgPit0nNhIsQdPkwUedTqT0l+uKpUju6naGUP0qC2svH2SrUK0az8FHS5TpN+TJc+gxgS027P3e0LpGQe3r3Tz+w8+3GPFjmyjXoTEfYHtYtJNnI3BHial81APYQGREJMmvyHwO3NgU8/fc3j08yaVb25rJnaPDE4hnHg7vaGP/rFz/npTz7Vw79VpGlh05NUby1DcKxLZpkXlnGgpUqK8YLsYBjLFWIA6hdYcsVtCEOllTOewhDBBXg6PvD49EDkyDo/bx6FMTpWV2miCk8f9Wtekk4rjK53SmCjpFwlp9fxe4n3q0O3oxIbzeUa6rA10DqoGvB+R4i3EB5p7gzOeJYbz/XSPuwHi3J+FQ1pTfeDZVlZSuOUK+9+T5H2z70uKv6eQHpqkYvjm30eDNFJ0fyPuxJZQKoa+o9TsoPHuGVRrdAuqZf+c397x7w2coWcn6nSnUb8lsQqF89bjCs3+5PXn/Dq5Qvu7m7Y7yc+vHuPNI1H7zDnFsdut2Mcxy1hvb62JBArqpxyb/WjKldOBy80hsHjQ0PR/0Vnrf8iE2iU2syQ3enY55JZl8z792+4uRsRyrY0+mfqyNDmQiGXqOxher0/e1y3ob7c/7YHY504O3MsI21gdlGddeV0PYYd4kckzIgUA0TUUk1vpF3gZXEmumSbGqjnpVClcmrHf3bc/T6u1hol69S3nuAlrzzGasb92nHqgmXj+6eoPP8tQVVqmaNZHBna6ZVKEbwnBc9aqqL9dl43x0fx9d2i+No1JcXIfrfj/v5Wx6QaoKbnoO79wzCQUry8X/pxqAutK2ma/V4V4cuvvkIdG3XtIp5xGpQrmzPMZ5ZcKcUxTbc4Vk7yzDBCaQXnhVpXvn3zNeN+z4vbT9kNF6eUYMLGXoQ7cReObr9BJ1fryn6/oesaLjHvenFl6857vLjt72oI6xoR25sbHh934M03XXqsdgpPxYkCbJgdYN/DdcywUYqkfG/c/uNa/KJpTreQuj5UAG0z1UpAtKXkjGgvDXGCDwEfA6Vm3WiriijmeVXah4+4oLey2x9Iw0iISX8/BuIQcQnSOPL61St+8tOfbhtlb81obtVHxImhKPqPINtEqxC09TWNI7SiPyNqp3LZvSyoFa06TCNpvGF/c4NzsK4P5OVE2o1KbpZCXt/jHNQ80QJUX3nzzTuCF2IQpinw6WcvrDJ0VkHoIVBr22w5fLcv6kF//RJsQfQr0MUq+sPbZvidIsoS7775qkBHZ1wfCHEh80iTMzTlD4mox+LWnrFsWSvjQm3NElPlhWWx+bwJXPxR+J38ztU7IuM4MY17jj6xtoVlmSlZD80Qu/+oWDKjtjj7/d7oI3o5H1mLFUNVuwFVzuwm9fcNwRNT4C//8i/51a+/5Ol44jwvyo/EsT/s+OST1/zsZz/h5d090Yq6hiLS63pmWRTVjjEwDAMlV56fnyl55fn4hAP+/b//t/SSuKNO4LTAEKEU42I1s28ZEtIyNZ8ZEqqCng6UvPLmq6+J/oR3R1JofPPttxwOe+r6pCjyoIeHc6pC7lPOrlEd+Dju+p1dzouOon4HgfgIlbhag86ShY4e2SarictAbXsaNzSeUD8+s0UqmVSrtsywZM6poU+tzdqQlVqF89JYcuO05h9VgnptNdVV/ISkxTzqDz0NIz4ElnyZ2Kf2U43eFn5xf4ONnt+oDiJKyXGoRZc0FaV+8vo1IYyczytVIKZIEU+x7kitiv4rhSDy+aef8LOffs5+t1PxnnOUsuKuUCwVpA4En7akGtcHKFyj/1uJhQ+eYdQWt3YpeoJa8RS8dQBqzXz77beUWvkwP3J6OrLmQms6XSoEobaV4/GBp9ONCXiCdTq0DXmJP7YpY75e39t30AP6uXfhIl4SVF1vTWwkMHpIe+cU4G9sljyOARfv8OmWWhZzU8mUXMmrdiAJ6qIgPaH1lviL7v3ZEoLzsvLF+w+/vwD8oZdYnLRKtmE4KaVtnKiExuPz0bpO3kSohp7GqD9SIKauUy+Yk7d29PpUIucZh4Gf//yn/O1vvuG81G3/xBD6C12v7+Wma7HBJ9H//9n7kxjrsiTPD/ud4Q5v8uEbIiIzInKugZXdxcrqIiiBoro4NDiIJAhoKUAQtdBCEEBBC23EhbTSTgABQQuBIEBR1MANQUFscRBFNptSk8VmV1d315RzVQ4xf4O7v/fucM4xLeyce6/7N8SQmZEfG88C/nn4G+89164ds7+Z/c3w+uuvcf/+PXa7De+9+64GNwtQyHvP2dkZq9WawqZxF0Etzq41liiWECJPb/Y4t9YeAbTR7eLinMc3R4Y0MISejx5/xL2L1zhb1bTtmpg2IAPjMACJKCOPHn+IrSre/sKWs001oZoGDTjnI5iDyOVuMNnafD9qSWjRa5k69NXU5nNPcx+DaD2b3gvR5IBBcPlvMyg6pQNtoHIOK7mGrQAX4rREIOX7XgobTaIb+o/V20+MoN5OO+k/xWGt64o46LxY5xzb7VnmbIzEXBSfUqDr4+SZt67ien+TKaeMolNmLgVwXkdEOueonSMIBKtz5smTFBajkLTbVDLVc1Yg7y1NUxNzh+TQJVJM3H94wVtf/KKOZ/Uuo6fzxYvZucVoI8f5xY6UPKumRkj0xw5fAfaIiYJQYUSL2rvjAQmCc4Grx08I/cDqbMfF+YbtpqWpdRyqkRICMylJiWAKiGytnZDMadpIQZYWhP1L0eBpLu7Pp6Z9WQKMkWE8EvobrAnY4JDeUdlG60RyJB+dnnsMgTLHdxxGDt1RUyDGkmyVaY2UPsOkhOfVQVBnZ3PeCGOMHLuOp9c3dIcnDGGkqSpCDBwOeyjjHTPqtF1vaduWMA4MMWCAuqlo6hUhDJMjCyZT9Wi0rciB4eHDS7ZnW47HnnpV0x1H3njjDe5dXnK23WFyyUSxGyUrkRbTZay1hNgRU2C/79nfXGsgKFq0PkPqLld1KLqZUqRtdYrYatNQ1RX7Q0fXH7QesGqx3tPtDzx+HFg1gbYJuNZwPA4467QprPZcXG6orcEZn9OP5HRazOdLHpOqx1OM44ykLsOtBWqKIRP/MJcLFF0387rEwLHvUVtosEZJtI9HQxodViw2ZmqYOGDoaFuhriq813GyEpPSLo1Ba8RCYhjVAVsl4S/+fNXvM8vz9Pa1195gOB50GtE4ksY9m+0mU3QZBolTmY0xhrquuLg41w0ZdQCNJG6u9+jm5LUuvwJoiSFhrWV3tuZLX/4iT54eCTHRjQEZgm5N1rFar9nttty7vMdbb32RuqlyrXK2sZk2CMh7Q01KN1xfXwOJcb2ibRvqqsrZo2Vl5fL8g/7gJgfVGBj6a5xJ1B7GmNgfnnJzfUV3eEJ3uCaFgQ8++EDTtpXFmkjl4XyzwmVu4SgGP31lqY+GCfEvz92iJburw7Csl570PJcPTIGVMZghIF1Q2i4LUhmS1+EmfVcRRkMKFqIjpch+f8Q4R1VXYHTwxmz9dbcIQRhiJETh5nDk+vjLR1AN6oiYiRw7p9dKA7cpjAfFsTfTFETJ5VbWCnWzos5ZyzJlz0jC+1onFomCOffv3+dmP/D46YFjNxIyArqsE01lsDyJMjxgu9nw5S+9xW63pWkqJQwLcbK1pfxF0dOKMnWtsCiUc52c2fzAcjCFzqbXPUQMbFYV+67jaIRhGPjJj3/C1770q/Sj+i2Vrznc9Bjv834gkAJdd2CMgSQVah8jhZZqGWBNNc/FRyhbwgIQmAfDLLI0kyNfeM1jzpqAJGGMIwEwNnIWYDUmJHZI2OOvR8IgEIUhjVR1bmRLUR1Y63LJpforpoBvmaEkhvCxevup4K5pAkiW4lA55xE3YlIm5PU+R5IWJ3rThRRmJ8xY+iFxfXVF2zY0dY2IOmbzj16AAutrZlwX0U6LbrLq3U7nIYJ3ls1mg+u1UD7ESAqR892O892OzXo99fdJSQvkuohyZUs9yna75cnjGwoNSQgB55S01sTMUZfAGMfQB8IQIPUMfU9dNbzx+hu8+eYX2W4bqtrgbFVyjNosRSHaVdUmdzfr+es0kSiK6BbKJ7LRngGnYrpmcy9T9KQK3D9+wuPv/pD2Zk8tgXrrwYyMH7xHtCOrlSMOPUPf0dUO2a0xb1zgNg3OOoagFC4JMp2Gm51l0VTG3VLaX5aIqMHTCVlxiua1ySsxhlGnZsBkbULK9EhZjDE47xiGQQvAJeGsZRyUNNk7R+FRrKuWum7xVT2lNbGwXrU07YrtTri4vGAYAuv1hqZutBlALDHlfshsIDQFO59HqYf13uHrisp72qZWY1Qi0hLplq5NUaO+26w5Dontbo2vKg77J4Shx3jlISYlnOmJaWQctUZRu8aPDMNITJG6rjnbbClNW9PmY7NN0KhQNwVMpoxZXozixJfTzOnjkpLOHbCTKk3grHaeumQYHl/z5NvfZ33oaI1QbypqG4kfvM8oN6zXhjR0DP2RYA1c7Ehfeo10pkWXkgwp6ljUMASGo5ZeRNMiOEYM7/9cNfCzS6Fu0Q3RZAS1oq5r+hi0ez9E2lWbO8AjpQGkkOFroN+gdfVSQmBirgP0Xmn9YjJUXgNv7yqqesVqvcbYp+yPHWnfMY46BGG73fLa669xcX7O2XabA3a9rgnt1i91/1OGK+vlfr8nxUB3PLBerTjbbid0RordKg1IIjmr5JBkaJuWZrXieLzJOphoak/r1hwHw9MnjzjcfEQKNzQ1dN1RU4k2YlyiqSy1txMLATCVp6gPWTb1GYCRpR29C87ckRlBnZKilBI3K9A9vuLRn3yPzf5I44T2rMU2Frm5wXRP2VQjoT8wdAfEQro4wq/VUOlIKYNBTGbQMZqtQoR+jPTDyOHQKQ/sL1mMaJCjveyg7Xa5nibXSLZNTchZurKWY+5dqSqH9znruSwDydnGFGUiEUG0efDy8oJhFMaQIBokE9Lnt1F6O0zuDdjttrz99tucn+2oK493JjuxpTSo8A47ZVIws3M3bbYLR3WuwBcw5LHXQpSkbA0W1G8QdLiJ+irH7kiSxLHrkHiA2NN1A83WqZ6KZgiGsc/HVdZLHaRJz1iURk1nbiZAawkGzKVOd2tp59cA5CQ+3aMrPvr291gdOlprCJuWwVvCzTV9OuLciO2vMd0V1gTSWYf86gqp6+xP5Xy2WEwyU2BRFk0brF+ut5/aQb3bCQfMqX+ZlWFCLJJO1hnjqCTGTtGMvhs59h1VXU3pnlLbZJ06q5JyTeMUDWSc5Zl0oMk3LpMT7L3PEVLDGIJuTiFytjtju9noVCDJdWkyB8uStNhXioOahM1mw+OPrtQxycejvGUJiWN2jS0pd+BJGkjjEZMCDx8+4AtfeIOHD+7TNhXOFtTWgt636oRnB1QJ82cEt5xpmqKcOymGiSNjUTivZ8JSQZ2xpJsD13/6XVb7A5UxNJcrTJUY3/mA0QZ2FxvG/ojZ7xkqh911yKYlekd0kX4YCHltQKd9xLwparPUAs37JcvE0RbnzV5FY8wkefqZMcqDWyrxTd4oF9Fp3/dIirkIHfpeEc4y7Ug57lqaZoXzXj/LWYwzVM5RG58dejM1B07lJ7kmaL63FJ10Vif5xBinbtKmadhtNpxtt9RVdTuKF21oKhFxwVxWq5bIyGrV4qsKJDEOPc60xHHMHMDqCMQI42gYehiOB4Ze5yq3bcPFbqeNCtm+FDqz29vyMl1qssM0D30oh1t6mg3qpOY3MJem3L6/rbHIzZHjt3/Abn+gMonV5QZTQXznHUYbuMi6u9/vGSuHv47Yy3NYNYjPdYBBiCEyDiNjPxBCIvkKjKUW4e1XQ3VnXcibHui9FXKgNYaRNEa1a5ODOq+x956mrnHOEwcl1iY3eoIjxkE3ShPBOlxK05hS31T4qqEbRKc1WdXnvh+4f/8+Dx8+5GyzoakVWYoxZnAxTQ0yxflYpr7HcUBSYBz8rZr/IklkSluWgS7eeyTqAJbVqqXvdEyoNeCbGl+3RLE8ffqY/niFMwNNZbTcIYV8zwp15VivWuU/Raa9vAT6ZMQpg3wLq3nHMXmBLJvNCnJXwH8nlnSz5+rb36Xdq+PsHuzwrSN8+BGNDOx2K4bjkeP+hlA7zFXAv/UGbgcxUxKWa6s0j4q+dkOg7wa6vl8u5S9NDHoNvcuTpBBIiUQgYamcZ9U07I8dkkElbURNmXUkjzvOF0eEzBiTA3YJlPnzmZqX9WrFdjswRmUDCqJNoWmhXgZoVxt22y33Li947eGDnJaXKcgvCLgGzlaHmeR7bhxzFtFWz4B0i5NHSxcyhpkpwaxTxoGks0OxRjPGCpD0xOGGFG+wcmTse9i2WIfurWlE0sg0yMiAKfmQBTIKWWeLM84S/L+lzbd+zywqsz9Xek6cscj1nps//i7r/RGPxT04g5UnPnpElJ71boXtD6T9FcaBfTLi3voi9gzEaXAilA4y5qlSogEit03Ac+VTFwzGTClgFn/rxdYurxglT6jRqQh932lEkQKurnJHJuz7jpjRkoQ2NU2dnt6TMFMHfco1JNPc+txuJwKkvD2aORUkJKyvqOo6pwnzZbVeHQZf5YhH64Oi/u9kWEs9i6DPrddrAI77PRhDU1W0dcux1znhCRTONrmrMOoEq9oKv/IrX+OtN9/g/GyrI19NQZ6dZm9MRo8AcppORwySjWeJnsoGYyfUrmhjCaAUzVrePHN3bGUtfhgw777LpTHUQ6ROPbYycHVDGgcuxDIOA9UxkrYt6XBgfGugaxxHExnDSBTd1IwotC+USCgSQ2Q5yPCXLdMmn6U4TsZmmpzC/eYdrtKUZ8iNfknU2YuZNsVZl8fjWvaHPdYoKb/NFCV1U9OuVmDthABWlSPF/H1OaZGtNUjM+IyorkaYHQwp9aI1/aDE7MfjnhiE890ZD+/f57UHD7JDOGcMUg4SilNdzFLTNBy7QFN5qrqaUOWKnhgMYgISFUUMIvRot213s2foI+tVy+XFBa89vJd5YCWT76vjUVJGLtNp6dpqBCsAyaDMDzPKV/h8y5S5yStA3dZlot9gqK2j6u/qbni57r53gOsBcxFItXZej6M6++MwEIdRG/sy0naZhP/e56CTn1SKLpS7uetHusOeoTswjCNODEPfg8tNChggTmn1tl1h0MYmMYJDm1Gdr7G2mxwvm/XVO4fzOnjCe8fF+Tmr1Zb1puPmeOR46HnzzTc53+20KUvKkI9Z/2Ic8/4gt35K41vhazXlek9sFTllKXmYRFJwo21r7GhZtTVtW2NMYhx7vKuom4q68Qyj5erpRxA7Vo0BvDoVXacpYwN15bl3foa3JjeAFBuad8hsF4ApSJrYKvRqzL8XG6rJAzpsrjW8W65g0Aahqh+x777HpTU0Q6Qm4lqHffSEehg4H2HoR+qjILuK4eqKZh+wUdRBzd38KSPL4zgyxsQwJPp+JIyjcs/+ksUiVM5SV0oZFTJ/+DD04KFynrZuOHZdnkCo5wPCZt2yWa1YNU22jZLfGxiGTmkrPVSVmSgaU9LhJpcXZ1R1w9PrPYfjoIwc2R4C1L7ijYcPePBQG/ra1Yox9BDjBAAsUUXnPJWveXLzhMP+qPdRqHBuC9XspCqwsHTugDzpStB9ofI6xCaGDiNj7knRrNn1lZamSDrQVgMSepJoc2pVGSDgXMI7MlPADAWo2hpKfekt55SZDk0dwJIBkMVxsvi71Nfm7LR5vt42ZsStPPbRR/i+Z9dfMAwD9hiRzZr+yQ3tPmKjMPg58CvmSY88Ial0+MvH6u1n7GiZcZC+HxVpEYEIMWjh+u5sSwijTsPJrUskh6ApqM12yzB0JKNNVs55NpsNu+2OIUTlRrWSR/NlZxKZeODN4uQzG1zmMlMH2FbqdExolWS+L1fg8RlhtORqomxsSg1IGWXX1jWI6MjTlBRFuLzkJ+98SDwOJIn4ulbe0OwA+arh3uUFb7z2Oqtmrd+fa+3MYgJE4RNUyf8v2sld1lqRMX3eWDfVm4jkeh+jm9B0RpOhXBBFGGHTVnz17S/wz/7z/yTv/Bd/mw8/+gAqyz/4O7/Jf/nv/vs4Gtx2y9lbZ/zmP/aX+Q/+9f8rKdRItHTpOF/H/L0lkuzHxOEYSabnnnuVXNRnpTR++ewEShjxzlNVuqmXcpSYIpKEYeiRlHC10eL/YeD999/n/v37uSMZTB4XmzK6aI3WUjvr6FPIN36mLDM6TQbRDEEEjGTicmsR59hsN/i6ojv29P3AOAaEyP3Lc862Gyqr+qt8gDJlIEAIYZy6faMYLi4ueP+DR1Od69XVFbvdmVLAxB5B6wutrYgSCcPAfjxC6HBGePvNL/Cr3/gab7/5Bk3j1HCK5DpnctNB1sgkjGlUHsdiTC1EtLFqTjEVZ2CBOJH0JnQLx8BIHnTwaXX3d/n3//V/i9h70mCQfsRZx/5mT9f3hHHB7pGd+p9aw78O/C8/P1X8eClInIEYA8OQS2xipG5qHU2cx3AqQurx3inXtPcc9nuQhHFq0ybaH1drPZ5vaJo1db3KTTlWR1J6x8ZXbLae+/YeZuK0XoYPio5rB7AiZRJT5rcsZSmq8845bTZpGlZ1zf3792+5f8UOp4xupsxocb7b0I3Cal1T1RZLZDgecM053oAlYuXAOB7yxKYKiY7jMfD4w0d0hw6Hoa089841A1Cc4mR0LUx2UAWL8RpcmUzjo2wPkjMFBREi77ulozrbW+spJSqaKM57khG2q5qvf+VN/rl//q+o7j5S3f3KX/pN/st/9z/E0tDusu7+43+Z/+Bf+zdJR4P0giz2QOUbHzPwM9KNMIwR6yq+8Y03PweF/HgpE4m801K/cRzpuo5gAgZDu14pzZQUZ1/1oK4aZfmZuLe1Ol3E5GbPkRgNIWrzm/cV4FitGnbnZ1wGYfXoKR989ITDoaPvtQzGW8fbb73FF7/4BTabFd5ZSAEraQLG+r5nHMfc0OWnBuEQA48fP2Z/c03b1KQQWL3+Wu5TKKVzOYjMgXiMEWsVQd2sW9brDU+ePkbSiCGxXjVsdxuOfc2jj95jf/2YykXsRQUxcnN9TZKBqtFSqcY7mtrhrdXaf2My77FlcmPQwD9XC7Kg6p2euxVZZZnS/KJvNMYSBarsa21XDV//ylv8c//8P8k7f+Pv8MGj96EyfPW3/yK/9//4D7Gppt1sOX/rjL/4j/2j/Af/2r8Jg4M4N6+r/5Id4Vz2NaZAiNq5+Y1vfOWl+vSpHVTrLGXOeDLQDYqSunzzj93AKIlzf0HrwbhE1x+JkghxpA8G4yzNak3TNBiEylpWlY4uPPQdXa/jxdrVinEcMjJToSP4SnIUSmqfQrKbi3CttdhcX7JsvDCS/1xeqwJx55TB5NFl9MIJeKtpzspbQq/j6JqqVqOcRrAWY0bapsZbT115NquK1+7tqKtC8TJpE5JKGlTXbApp8ndqisHnsXd5U0eRvlLA7XJhOSWCM+XA809OAZRTtd4xWjiMPfL2F/jRf/ifcjh2nF88ZPXrv0r4q/8Z0a158Bu/xu4bX+JP/vzHHERTiykp4hvK3OH8uRIjCcNxTDy6viFFy4PnpT9eIUmZeJmC3k08vOR0d9IAQjTFEqMauSSJ/qiUaiFGTZdPUaCO8dPIOCHJTAjizDdJHgiBbogxpzWxOQWWFF33jqrZcm7cVJ5gRDubz3c7mrpiKunINT1aOmUnDtsokuunld6n8p7DzQ3dsWPVtGzXO/oRxrwWxvrccxeRNJLiiEkj3/j61/j1X/sab37xDSqvk6IMOgAgh0i3zs9oZQNjiIqwLQIpdeRnxomp5GLiTsqNTJT7QYNKg/kMuvsj9gImJFI3ZgfZcOw7xhAUVRRRgm6jTtdfEMO/93kq4ktk4hk1Mx6XgCB6bXFWkfvKZ/R5Nmjee5IoGXrXdaybFus8ISb6bsjTfZQwv2oa6rqlzRkirOQATj/TarpH1XyBcpfgvpRUFWovYwyrtuVwVIR2HAeur6+RJNy7uOD+xQWbVcs0iWdRyqCUbXlqX7Yhu92OeHWgrSt85RmGXm2fNKQIthsJg8XQYLD0Q+DxkxuI1xz2PSKG3Uap3DZrtd8O1U21s/Mmba3a1KmRw+S+ACMZ7UszIpxbQ5HCm5FXRUpMoesjgKkc0cE+DMiXvsCP/qO7uvufq+7+A6q7f/rnP+JgLISIHwKx1olAIdMmhn6kOxw5HI8EqUhYnF2x253/wvTx08iU6cv3uDK/DCQr1CEQj3mgQA5gRISmqdlutziTKdCMBuzOe7yvcW7MpXMZTc6f771mRL3Tzv8H9y9IYmjbI/vDkTEk7t+/z9tvvqkjQ61CUak0QScd6jGO2otQRjFL9lWMEY7dgb6HMDRaGgCYabLU1N6cAxpttlq1DdiG7WZF09ZcXUe67ogzHl97fKMO8KOPfqJlKK0njprNu85TtgxC5Q2XZ2sl6QdMMiRTav4zHaIUnlhdl7kFoZQazMjp1OQnsw+lTZRlaEax6mDqordj1tu/xqE7cn75kNWvf4Pxr/51ot/w4Ju/xlm2uUfrsCHhh4i0inCnArBZoywHY+I4BoYh0A+O3e7ypfr0mRBUdYy1dmQYR4Yx4IxGo1HyyDrA1xXGJobxmEnKFYFCoPKt0qRYTT9X1nF9c0MywhhGMAZfVcSo6KqvHNrAn432NG51mp+Ta2HJaVw31QyWlM10nSZfMdfrlfqTXEZrc/OKiGg6VoTL851C8l3HYX/Dow8/pO8OxKijU51NNJVh1dZs2ordtuXyYktTq6Nc6mbVoBcHIiPDJRqiwPUz0leatqR4ALnm0To3RfqT4yu5aTKHUlpcr2hnTIEw9MTrDjMK+49udJ2txzQrBqNTLvxmg1uv+bM//FNMiEjIXeYTsmUoFMqIYYyJY594enNEUv0K86CqzMhOqXESxhDwQbs9u77XcYMxTGiQa3SusRjRutK6JuYxud57Vu2K3W6nEWjSjIECAZnqzDCl/mwOb9OE40ueDZ4pkazORrbWTxlFg6FyHl/5vL6qrzbXeab8+QX9NwXpQagrnT//9MlTEob1esv5xQUfPXrKGEZlbmCksX4iqnbGsal3vP76A852O5qqzgTwbip5nseYzhH41OyClkZMdaeizR3GlBIAO9chMmGtEwn3FDXm13wW3bUhEceoBPdW68RDTJr6o6xr9vWT8G4S/gbwO79g/fskMtPZlG5kvbbeecR7tMrGUdcNZDvi8gAHa41yFQ9xQi9TSvTHI8fjkdWqxRhNU0qmfimTpgqxvq5/yrZTvS6XR3WWrJWIMkgUXkVnlBJtt9vinCOEOdW/ahs2q5ZV2+jI00zFNKGRoohTjKrMYrS8a7PZ8PjJTdYNOBwOrFcbJVFnhCCk6LHWIUYzHLHvkXBgHAZ22w1feP113n7rDdrKU7nMNjFtznPHtjqkVgtuJmQ4p0RE16SUBZTBMmVvMaJO+l0CdRDGFLTW8KbDBOHm0ct0d8UP/t6fQlTdJegkN1BasXHUxs6xHzQLYB2S6azSXYKBX6KUPXUYBq3fX2R3rHF50Yz6mVjW67XqaVCGDedtLrPKSLXzOBGMcfiqpq4bfEY7nbd5uqNlvWq5f89ydnZOPwwkEXa7MzbrNhPQyzS+m6xzOvTktq0qA4aUz3qLt5amqtmsVjmgLgBZtiKTqcrI6arF+BXrVYOvdPhKDH0OiMGSMDLkseuGGGrG0VB54fqmYxi0FMYBF+fb3DgGlLRbtrcTomXmCVNTiVcOqmYXoVDPTVdpzoVMAJfadbmlt4est9fP6q0xVJs1dt3yg787662EAFFLMsVkoCJBNFpy1HUDXT9y7PzH6u2nd1DLxiKCJI00QghE0ZRGqUcqlAbiC6WE1ptIjKSYaJuepm4w2RGzxrE/PAWjNZjWWUWlfOasyxelIB6UzmHJUUPmBjP5BzdDpVNdkbntqE7lb1MNR3ZljcVmA54yAfh2s2G9anli4Xg48JF8SNd1iDFU3lBVlnXr2a5rtuuGs13LbtNmB9VmgmbJqSimGjOdMlJms7M4Ni0aN6Lzm6fqkwmFcrppFCBKSsF5iZoWDjEQcvcvhwG6QLjpNX0kDlxFfXGGWU4sGnSEYlxsJgXZ0ASAJYlhfxzZHyNX1x1Gmsw9+epKEq2F64chB00wDgFnhzzlRGmeQppHSJZdyHlL0zY470gi+Bzl101NVdcMQ0a8rQYJIRX3ckbCpt+lDhMyX56mFq3Lta3GTYbPYPDWT37bbckNKZPHRX6HXiWfaV2OxwNDiJydnevG//gq10oZjIx4v841oR5vLPfP1lxc7GjqOtfZLdNBC9wok4hPxhJyIJXyBpA38qn8Rp1UayxTkRjF5BsKG0Cp8v+suktKhJQYY2QY45RomvhizYKLMwmPRfiPn1nbX47MBPJMZTTWKqOERKcoakaQTCa+T6LpdWN0Hnqx0cYauuORm/2e7nikbdtsK0p8oBubJhXKdUZRlknfJDtfuT4024OUV9MatbcVjvOzHW3dEGIi5br0tm3ZTIMuNCjPH5uR+3zdcj1/aXhdr9dqg0LQ4G8MVLuaBMQy7AUBkwnD00gMPanv8M7w2sMHvP32mzy4d0nlPd4JrjSlloZc627Z3pi0W7ygoZjSlGsX7AR3m1WL42Cne6DgVmNS0nrJujs+o7vnGiBklY9jzLobldA+T+krzunQK+dtitnhcDCmxAfDqzHqFJiCjmHIZP252SJJyt2+ZV9Wx7Jp2oy2xnmKIRBCJOUhKs56jPXUlaL+Va0DKEzmNS2k/7vdFmuUezOJUNeqG1YWCLeUxqicSYFpwlnKg1KM0YDw3sUlbV1Te6fIKAUbL+eZpgxSsTDr9QrjGq2htsoeEcYBZxok6tSoFEKu4baEAF2XiFXPcDwyjgGMoa4c9y52VJmBotyLkz9pctNfrh01009xoC3YzHucpmXP1ntprxeXTnSoxJAC49i/RG/P1Pbk/+Ko++UoEReVvjIaW8Bl5fhOiTEkjkd1UG86/7F6+zOxqktS/tExBmSMWiRdaQ1iEj2YlAacs7rhi04gSpKUc1IsbV1j25a69ZkDcpwiGBLcu3ePxjdYo8iBqx0Om2su9a62maLKFcOeHdR5nNoiqpVZwW7tRznqkEVaTYxk2hvBVZ71ZsV603L86An7Q6AfIlVTU1crtquay4stq9qzbj3rtmLV1DTVPPdaiZm0DndqHihfn0p3+cJRLohVOR65TQ+RUMJhAUhJnYAcEeqe4SkfF9C6Sk17JrzoNAorBnEVX/jmrzL++XsM+44YhG/9U3+Z/+Tf+L/TOyG4spEoAUUyliSWMRo+enLDoTM8vTriTPs8D+qVkpgS3TBwvd/TZB1JQemUbOW4OD8jhKM2LhnVFbGCWKjqmtXKMw5Kht6sWppWz/nYdxyOB5zTaBsEyRNTHCwQdCUr1ojXghWS0ZShzTOpa+8Xm1+W4nzK/GdxAvUa5ycduURB1csZw2a94unTq6nWymaEKsWcTjcR54U6d39vVxWv3T+jqSvU78sORYqK2Jjsg5Ih+8VNlkS7VPEWgtZ4GXfLemKMwft60a0rCJEUUXQq5eYd9Lx+Jt21Sn8Ein6XxSvOWUzKV3iZ4F94RTh8J0qjxd8igrOO5Bwpb+SSr69xFownBMMYen1ugZ4+fvKEw36f2U3sBB7ohClFOlLKVZXT0I+cVlwciTFMwyQQ5V+VDKRbY3G+5qxpKKOWCrG495661lGSpUCuUFkjJrMQ5WEVMpMGtm2LAfb7Pc73NE3DZrNh32UnTbtTKSl1cp1oSgMP71/yK7/ydb709pd0TLFTonudXATOedTxXtbMC85VpJCm2m6lBiKfv9IgqTO8aAIjMfGjlV/qexBRLnAWuitJdZeq5s2/8GsMP1TdXUX41j/9u/xn/6f/G9iIl4gfFLzouo7j8Tg5fSW4shj2MvA39z/++SviZxZ12EvNM1Z11FXqbpQ9qYAwWJR2KcRpbGcSYRxyWj+jqNb5Wwiqov6qwybvg5XToRPaCKdfH3M0ljKAptBVDuDQBsH1esXh0DEMIyFoDf1us+XB/UvOMopa/IZljXUBm4q9EoHVeqUTA70G5TEp44ZjIEYDZmSMHkMNAmPfcT0GrOtIww3jEKi84/x8x8OHl9SVy3qbj98qmlwYMlKmRywm1mXn1ZmMQmfUt2Q+Zm9oPp8SUhXHN8qn0NsgfOuf/l3++v/532awiRqhDglr0zQuPSZteOv6UYejDIFHx46/uR9eqkmfwUGdO4eLkk2NGsbkjmTdmGpxeKvzoZ1zSgORlbaplRuv746IRHabNV/+8pd5+vTpZKCttey251lhyQuou6Maz1yKnsiRMdlaWi1UX6B5Mx9aiSZk2vMLMmSNjgID5nq+vBE03nHv8hxjoWlb3nv/Q9rWslqvuTzf8eD+GQ/un7NpK1Z1RVtXtK0a5sp5bdAydxqIpiBGMpfrdLRQkJ5yfIvfmmLSjT7lJiuxJm9KmYUgJZAcjYoOdxiBo0388K/+J8gw4tYNx/ce8cf/9r+He7ilR3jv7/wRH33n+3zjW79FPRgOzhI8YDQFHnEEsfQhcXPT0x0D+yMMo9DKq9kgVa5xMSwxRvpuIIhgiKQw6sSmIehm2tTImBiC6oBuhgmpdQb6ZrPFmETtauKYeHR4QhDtrl2tGkKwHI9HBE9VWXXwbDa0GARNzWlA4RZj/Cw4Q5kTrfdaIQPPsfPCSQWmRi0RbbjyGX1Qx1v5/b7w+gMO+z2H/Z7+cMOPfvhn3NzsGYM22ay3LXVl2K60dnq3aThfr1jVFkvSsUN5UylBlMS5eWNC3cxyzdVAW+sImV+Q4tjkqUJ2AQmnZMAmrXMu938mPI8JRvMJdfe73+cb3/pN6lE4OIgTr2JOzZmCL2c0VZxmAlLifffq5EkLSln+H3TiXMrMGX3fa+NTNKRQbJXOpy+TnqyBfXdQZy9Pe+rHEYNhu91ydn7ObnfOEHQKl46dLhkbluX7+VfKNitRGje9y2UI2cZXlb/l9Jls9zJIeEuMMXlKmIqWqIDJNaLO6qb43nvvEWLCuZrX3nidn/7kPcZReSSRgHdhqps1lWNz8YC333qD87MzKueVAzX3ARhz285OtEEyP6a2Qtd0qtszpSlQF8V7t3BQZz3Wdco2WQyp2F2T+P5f/U+QLuA2FcNHT/nz/9d/jqvViX3vD/6Qj77zPb7xl/5B6pDYk+jjgNuPYKDvO8YxO08lSM3lCS3w1TRzJ/+ypdxbpTTFGeXl1aENCStz6VrhFR/7AWd0bK8IDF3H48ePqaqK3W63cKmyo2m1Rr2utMW91Ltr/FxYhlQnbE5vGxGszOMWrDHU3sN6TV3XHFYHxjFO++cX33idddtog5Ixc/ORmZ061ZPEGJWWMqbE5eUlP/3Je8SVNqx++P4HXFzcR6IQ0kiSQEoVxmvQYyQRxwHpbkjhgLPw8N49/uJf+A3uX55TeUvl7dRTo4hxmdhp1CEVrVEXmVIj0/qC+kZzOt1MmQArM6JqM+gnOWj8pHr74Xe+xze+9Q/SjImDQZttjz1Vmu/LEALHrqPrBvpgCClRRcNX08/QxX+XLmSiiSk7Yon0c4onn3qG9zvaZkXT1FSV49HTJ5ryy2OwQGexWttoBzOwuzhnv99Pn5kSVFWVDYV+tss1UiXVb4xV6HmCtcvNMV+c4lQrM5tMGUQz5UaZNi4bNKWtszwV2XQW8JbdZkNd1ex255ydnTGGhPMafT24f8F207KuPU3laeoqb9DzOLxJPfLNpemp9GzqdFIwMwUBz5thXa7Rc3nZyFMhAGs8SQxWHG4w/PjvfZeYhF1wNI973v/Re5jvWs4vzjF9pPvwA57+5Peom4aHR8fNAR6vdZFM9KQAQx/p9gNBYLPZYj/aM47xOcfxyxWz2Dwko+cpZVLxGJRMOW+wiDJM+NoTksUFdcbC0DNmD6yqGmqDBl7OEEQ7rG+ubxB0DnGMkaqqqSoQ8RSiZZ1zbCfkCEpzRilN0UBjDqwSIkoDJGmBZpn5vpuHWhZkYtafKCnXIXq2mw277YYnT665ublh6AeEUqLg2K1XnG9XbNY1m1VFu6qyDpfGxIRfME4I5NKPBf9uKha83HtlssrtiF3p4yzJluKHecMxVnJmJiJOdVczJQ4zGn70h98lROHyBbp7/OB9nv7ov6CpK97oLPuj8NFK64etzXZEgGi1lto6+lEYxg1t+kd/bnr3s8jk+CyuY0yJEJX/Mgl03cCxU1RRSHTdgRhyStXrtD0rik6tNq3WSApICpxtz1m3DXXlEIn0fYf1GVfKZR/FDuVKgxwYSW6OLTWyDiGCnWeql3Tr0iZNIICeHaWcqqRcdRxkgSlzEUbW9/Wq5WZ/pBt6jLNInJuVkmhAbkzEV42OynQN93c12+2ZTgEqjmVpfgKdqpfy2FNmndWqEqE0TYlACGkKFjEmAx+KCJpcBqbn6BZnm3/ne8DgsMHwoz/6Ltf7Gx74c+zjAz/48R+QHJyfnSNDYP/Rezz+yf8PX3nu7YXD1cjjttd7rNA7mpJ9MxMyaVyF0P6ctfDTy93rvhRdU0dV6XCHWGo/Efr+SIoR42sSwvF45NHjDzECTVNjMn2l9zocpfIOZ4w2Y+InW6N7/ELvylrBBAaZ7Kg6FMiylaeqNajabTZMlXfGcnl2phlhox0D8/DGTMeU9+QYEwnlXo0Cq1yycHNzMwFedV0TJdNSiiFGRURd1veEDo/xVnjrzS/y5S+9xWuvPcyjgs1iFHopw5kHYRgDJiVctg3z9KyyM8zXJ6U5oJqemdZIfSRyM9nz9NY83vO9n/xdxMLF2RkyBA4fvcfjn/wNfF1zfy8M1yM3m0hyCZ8cMYTM5qA1yaNoeWBKNcLZS3XqYxHUqVZy8feUnc5oVNloC7iTJGnnXqrxXukjjp2SaBf9Kd5/U9fKPxljHr1XTailza8pnca+ctnXyAZySj2Z2QE0ebNfpMLV8JoprWfI1s9Yyuiw6XrmC1U65C1a/ycINo8+a1t1vMegM2i995xtV6zbmjbPE1YkwUydqQt7NRt8yrkUYKys4OSKTChqOc/l75m25/ZrbDak5dppNtZSNy324QOkjzpp6/weTeV5ZAdtRrs4h8py7DoeXV8zvlZrKi7qTGitMnYcjz3XN0duDh3WOlarFau2JapH9nEq9bnLvEHmQCYjfylGxCh3n5D5eHVI+RxUiBDiiGAY7EBf9XjjIfPpVpXXUb8pkiRO06mUakXH3zJdh3nEnxFLGVDnpxQ4lIByrnODnPcCmIyw9sGZmRVAn51eM08i0lTvbrdhGC5IIlzfaNbCeU/bVJyfbbm42HK2blmv6lye4mganVrl7KKG1kzJE9XN5T2zQJRmQCrX4D6zb5npdYa5NMcmtLC+dKjqVdPxx0V3rWV9cY/W39ZdqRS5fnR9Q3yjwnszIy6UEcYZ2UKRriiGbgyMfceZXP3MuvbzFDWxOUgKgTHqVLQYIl0/sN8fsE6b6pyzjENEJxhps2pC6efqplGkMoludt4Rkw7eSNbSDz0r306brdKOzQ1vt5xLm8tRsiGTQuvncs28KXYbFkYO/avYt1sPzk6wzftK5muzBs7Pzri+3nM4HDCSuHrylKHvFXFKgqvAOWgqS9uo3l6crVm3LT7TsZX6PLK+St4PdG6uXewdM1o9MSmU+25xvMU4WHPbIdP7rXR2k9Epo3b3tQcwJOrKsr33gHVd8Sgc1Mm+3EFl6Lo9H11fE97wGKvNgUOKYJJmMsp357qvacqiOWLND342Zfs5yPODkhkcUD/BllsfgDHo/atapfa3P3YMw8CqbTPCqrWoxT8oelao4ub9uwQLJtup+WpIft6g+qkZLMC4iTVHWlO8U5x1tE09AUz6ubOzq3ZtmenKwbpo9gJBSzKCDjs5Ozvj+tATex0alMRSZdTS5BKqtvFsVg0PHtzj/r1L2rY0p84g1+0AsPhBZD2eA7/ZJyjV98yvLw49mhUxywuCeaHebu7dZ93UPIo9KSbcxVnW2wOPrm8IX6xwFh2KlCdlppgIg5bkjKNm0BPa1Ciyx5oPXqpTn5kHtTiqc52nOkaSR9EVmNwYo0XymxVPrjxuHBG0295aTada73Q6Sm6OCkF50ryt8nSSRNNajaYmQGbpnBoUbSoOiOW2g6rvSZn7zGQDWAjHi+Ita0zKN5jMFCAL1EqMYbVuM7KhEbp2qXoq6zXCy80pyhGZndBSt7dwSvUzmdIHBWIvB73oI3n2nFgq4vwamxHZNIMSWDG4zYbN179E248EEap7D6namtU9SxgDPHhAvFox1PD0EDiuBmgMnQWd4OGIyXBz6Hl6tWffdVxcXNKuVpyd7wjN6jNp0+chkyNf7nRTNv9EsnPDTEhhMgSls14HN4ANI0PfY6IhuYr1akVd12AMh26PxEVtJ4a6qnWUmxgsmuoqTUXG5ClUNn9XjtCXTSNzgxYYmRF0k4O3wrtatDemghCnmYIM8N6y3W4wxuB8RYzv4CqLryq2uxX3Ls+4d7Fj09a6ybcVtYWm0do9VyiP7gRIZVMxd3TwloM6rf889nJ6jZRzzJuYSZPDYLKTanLXddHdph+JRXebu7rbMtTC1WGk3/aMK8vgmRC/lPJ6ibpYMRm6GLk+dMTDE97k+z83fftZZHb0VVJKDGFkGEfiOBKDcqIeDkfazZq6rWmahr7bZ/uk2ZNSR9Y0NUomoyl5Yy3HrmeIiTol+qGnXdVzSts4Jj9iqY8ZddI/8uacgcOix8A0irrsC8+GrHccVVt01WCTpWQ5rDGcn+149OgxV1eGKMKjjz6iG0fCqPy93kHlLW3t2axqtuua3XbNulXaN636yjZ+VjWtHyRN06uARYPp7KB6X+XmrYLKLNKjxuk9jW70OjUx61cOrgwGv9my/fqXaYeAHUZW55c0tWd1psdh3niYdTdxdYiqu62hs0IoiHJxfcv1KCgaFiESePIzaNzPR16Yyct8uJpZcnmN1BkdR52SV/uK0qPSDx2gwI86qNr93zQ1dV1pk2puEluCU9P6TH/PcI+qpD7hrBYBmFx/7TJna2E11dpYOzvTd85n0umynViTaSolH7cyCPV9x7HrMcay2+3ox8QwBKXpRBufbAYsjVhqv+L+5ZaL8zPW6xZvrWbqjF7l4lwXh1JjrsyQciuYNHkwCuj9vMjgaVcuBjP5bouxU+rEywv09qLorSUFVG+vVwwVXB0Dw/lIbA3RKrsHUkZLK2NBGXE79d6Y8WP19jM6qNmxMzanj3u8lcl2WatTdEIY6boDl5dnnF1c8NGTJ4xRESbrYNU2GKcFuWM0PHr8iD6MdGOviFNb8fjqKVXVsPKKSqonkakWTNngtVapUJ7UZRZ6VqIS3SjipIZP6/lKBFYoT3TyxeToOnuLFB+ysbNqMlzVZAcX6qaicpbKlXSXRmUa6i51YI5Wpqi+3FSy2LTzNSxUWbdWf/H8kh5j8QLd2PNDKX+Hv9zR/vavYZLSDz3N0Zv99ftsmoabMdD1PT7+CnZTc/zTP+A4XpOsUmnhPMd+4ObmwNXVDfuuZ7W+YLXd8tbbK8xm89wyhF+6mNl4ThkAazHeqVEyOo0n5o7huq4gBcKowxJijARRJDKmwH5/Q/IN5xdnrKuKdrNmHAbaqp1S6qt6RVPVhJi5G71T7kq4Nahh6iAuAx4WulFQAMnBhtZ657SNzawZNiOayRJJjElH+qY8grLxDdFEqrVjs1pxeXHJ5eUFx34gpoirHA/ubTnbrVjXFW1da2rfgbVuGl3ovZ0XkyUiYuairumY8+/88BKJunVfMvOo3s0ClMdSTjP7yx3Nt34NmwRbe64Qru/obt93VPFXcFtP992/S0gdowvYymOCTuzShfWkWHHsRx7dXPPBR09obz7kS1X/c1S6zy5zWnJ2mMZMmRXGAClOfKeQ0fpKdQwJhKS1quM4aprUV1R1S+28Ni4Zw+FwIB6PVEMPCHXtJ5J15yqStZAHnWQgMtsdjbRttpuK4pEbCufrOzsKWV+mf+bH525ojdBdttsJrZ8XidSNZ7tp2axb9oeem5trHa+MwVWepqnYrCrOtis260YbVFcV67aiqVR/i5/hc2ZN66gVV0+iPMOTTS0/WQedNVi0ZrLY5sI7bCYE02oAT1InRTQlLXlMqbu3Y/2X/gFcTLTechMjB4nU7nWqdct1jHR9h4u/ittUdN/LuuuL7gqgjZnZe9CmIXRcdy/f4M/4n/+i1PETy1yaskysiAYTacBaj69r9vtrQhiVsD8FyE5iyOOkq6bGu0prkPPetVopVVldVyRjGMdAVelgCm1Emp3VssMW7FTLe3JtZab+U9Y0m4OQ3Gg10dwt9HeKpZb7WnEWb2e8TMplYgbquiI8fspxf6CuGgSoqwpne21qch7rhKpGS1O8Z9taHtw7Y90qLZb3VseeTv6BTJN5Z+/YTMhx2ed0BHFJ9WfYy+pRKyPCDOBN9/QieisUas/obYrsJVK7L1C1a25ipOt7XBxxG0f3Z39ISj1YBRhjp82tMcUpm2OrHFQZw+h+hT/jf/1SnfrsDur0W+HwpnbUtVI9hXAEmxjHgb53eF+zWq94+OAS7+Fw6CbevHEciSFCDYeu47Df6/gs66iqlqdPn/Law9fmjRy02SiHHsVIDCFis4GdQqhbKrX8Z7rK+TSyFk6bLlPdXzHMWstY6myg8JQW5KBEXEpbUhoFZihegDwA7QVryYS05iypdikzI7vPvO2Ok7o8WUU/9LtSZi6NdcXxYsshhkWqRYhWO7HHqmH9+kMuz3ZgB/bvfId4jJjYQxoIXeTx1Z6Pntzw5PqIiKGuVzTtlvPLLX63e56yvFISY8jGMWKMU15So/WUQ9/TdwcuLu7TthXOWR3TR04TFqolK5xdbhWhksT5ZsPTx0+oqoowjnjnaOqWYzdgsp577yjxCHDbOV3IEiUv9kfJ+iW3PhcFSXdvQ/3wmPLUNJ/fq93rxmfdwrDdrBhTJMRIEmGzXXG2qWmqCm8d3pVj9rdKVG4fZ9ExCj3mIsjLtbFyuz76eQhLybLcOv+8gYwSlYLNGNXdyy3HGDItFy/UXecj/aMfMxyfIuGIyTXsKVms84AnJsPjpwfe/eiaq+s9TYj8abX5NKr0C5PCYpKSUu+kvGEM40jfdZACtc82MK+/9RZXWWQEK0n5iceB0VXKn5oEqRpWdTNNi5IIKQRCClxdCW3bsl5tWLcNGJcb4fJQEBQxp2SEKH0Ai/ikIFTOQUYc1ZTpxq0o4Gy4igOgdja7FCW7kV9TeceD+/eoqopHT5/y3vvv0/XazLjZtrz28JyH9+6z2260xKp2rGrlxPS+1hIVU1Dd22Ip/NRzgLSk6Jv+L7Ma3EqbCnlQQf4vZ0GMJEweFL/U3Rvn2MdRy1gQDEnHmBrDaD2roruV0D/5MePxCkKXp++MeV8hBy1qGGKMGLEQr6j5m8A//XPRv88qBSUNMRBDmJqM+z7Qy0iICd80ucFnRHdEvdJDGjHJ0tQ161UDESTqqNrKex3aExNm7NVWjyOb1UozYKmMeV5MtSNfc2exeR/X2MFmWjSZOJknYG1heycD90KZny8OnzVCzMwq9y/PuX76lKurAMZx9eQJx26k74/E0NNUFZVLrFunZVWrik3rON9tWDUeb4CUFGWdvzEzB6Q54M/PFaa/4q+Ue7DYkilWtHoPW+epsBN4J4UXHF6otyYHSClzIo94tbm7HXWd+P7VT4nHa0w8YmNHaf2WspEV5yZn5Jw9fKzefmaaKUnatQyCc4btdsW6rRhDj0ibb6aUO00jq6rl/oOHRBH6PtcdLKIekTQV05a6VkHouo4YwkzktcDv53SN3hjO62x0LbTP0dPi4hbjUy7WVEOXDc3UQFWc0owOFaM5RWhmmebJdCqmoETFgBeCqFnLJx49FmmJxeaczfb8DnP78WfkeU6qMEVUpRxiou0CgjGIcRMthRpSA5kw+vHTax4/ecp6WxFE6bWESOgDMRoefXTDzU3PMOq4uWa1Y7s7p11vMevV81zpV0rkVgTKouxCdWUcB0IYqeuKzWbD8XCg7/pccqKdlFXdYFyhDxm12co7xhhUr4yhHwZcVbFqVtqsYbNiZXSG7Gs6Y4h5hJ01SjNlFgdbkMoy9pP8563f2VhqE8VMaWWNppFupS2dlhI0tqZ0iteNNvY5O6P/zvkZUTCLzbr8zhu7yZu/btjZBTG3q5qWKevnlag8W6ai/xQERYSMflqScRNrgOEFurv2HKMg1gMOG3T+tbc6NWwMkZsu8fhqz5OnN/R9wNjIU46fUpt+MVKaQgt5fUGRJK+LmDyce1pgRfecM4SRvOGk3Igi9H2HhEhvOuJqzYMH99mdbemHkWPXUbkKi6VyNU3d0tQtQwgTMGOdRuw2X9WSSnRmOa2GqbRqrtvLm1/mENVj1YB+muaDybS5kZJ2lFyioiWClu1mTV1X7HYbdts1x34kiVDVnsuzDWfblu26ps20fk2l2Sv9mVHUcjxQli6joSWiz88Jc1nCHE/OzYsplb6Fcg/MexKUmtyi29mBNyidnJnre4WEOMcohuPTax5dXbE729Al1WlrnDbpOo+RMKFnIhZQ9glJQpve5XfS3wD+lZ9R8342CSFolik7plqeVya3gRlGQoys2xpkJCVLMjo4IyZhjAEbDT452rrFSpUZIzUCvrq6ohlXGGcJMVJXXtkACi+4B4eH3PhqC5tCRseL7fdWmwfz/IXp+ln77H582zItDHABtYq9S2XcuOr5atWy2a5ZXdd0feCjDz9AcIwhgCRqZ2lrq7SUjQ73OVtn5N9XVNYp27jAbZaUEkglCpPPVI9ajo08vMDYjPynzJpQUrnlvtM1ElGUOSUt14o8X28LTZxmnx1BDI+fPuXJ06ecn68ZogYJzvgc1HmdlGW0jM6aMkgGMJYdH/A76d/gZXr7mRxUncgQiWHU9FvlqCtHVWlsaF2F5CkYIsI4jFjn2G637Pc3PM5FxCJlrKHNHKhDTqto3dvSaQ1Bi4ttYQtYKJYiroV4eb5Mz802z2j4rTNaquP02dPM8GdRz3kCCZOSmJyqkuIAyVLZ1RlPktMNi+OZdH1xJPr/+tcSUXuZyJQC0A+dbyGZfCPJDpQs1k+b0FRpxz7Q90eGHpq6RYbAOIz0AxwPI/ubnq4fM8NCQ7va0LRrqrpBnGd8+SH+0qUMOdDhDyEbvziR68ekhdyrVUNdtWy2K25urkmiFE7eOpq6VmL0FBnGkf3xCNbQdz3ee5wR+qGnycT7zhX0Er0uxjI38llSCDjj5tppoKA003EXjV06nIuN9NYrc311cSTu1tVhyakxdT6rwrOX0z/O+VsduYI6nyX00qqIpctK8ZEpxs9OAeKzSOpduZveL+TZS0cdMkmAMdPkLMPzdPdA34FzFTFVaKe2o9TxxSh0Q+TqZuDxk2tubjpEDPfqh/y6/BMfpz6fq5R1B55xAktKPWa0SonoHWPezCUH7cbmAF6U2D7WDdZamrbFVzqcQqnohLpqaKomB7Wiqc+cdjc2I1HMwXnRaTNlnooDNjttIknr/UypRVE7O9m0cqI5UEmZSgvRAAvAVkZRtLahbRv6QRvGsLDbamPfqvU0lXZ4V5Wi/2U/KPdacR5MQSi4dYNRAq5S9/+8zNUMTjzbsb589bSj5CBQ7a/JG35eu6R7HxhiGBmHHolBSyycR6Km8C2ORJwcejGanYvGEBOEeMDzg0+uWL8gKX0niqIW51S71kUyhaOBqq6ISZlSYohIYgKybDBUPkDN5AeUOuGu64mIsjmI6qc2TWlD5AJ9mDIxxRnKlRfKDe20A6/wnE+vL36nPpA/brEb5+dK++AC7tLH85cY1L6uVy277QaRA0N3JOUBAs4qarpZNew2rZawrBq2K6/c6bU2p1qTQ8JyXIZnfJqZuWCpywXVz7t/Hmg0n1/RI3UaVUGTVjOnlPthntVbKWCFZADOGJ26OPSYGKhcRUoVpEG/zzoMCtrYbLMg1/8agzX9x+rtZ0dQJc9PNlDVTulhiFiXtMNdIlGU0Lg4kFXTslqtaOqaccw0SLn5Iwp0qaNtWvB50VVzCeNIGEdSDFhb68llWCehn7/b7dSYltt4MpC3DfyckMqbnDVTbd+taBmjKIV9noPKZIgn2odyMUWjqJRmJGHayhcXPsczM5qHbuuLnb4c5O0/n7PRL2nACipNcYiYuxjn+81Mii7kNDB69zqjhCn7q2vOtmccng50sePQRT766IauC0onZTxNu6ZZrfFVi7WeV49kimnxprpiLMZ4rK0wJOpax60Zk/CVI2UH1RhLu2o4O9vx+NEjHSfpHNbphJEYAnjDMA5c3VzjMBy7jtVqhfc6C91M3ZeLzdi6iW+yXMooedxprucz8KxOUmr2FrROd3xEWBhaMZCyfpdzzz/WMpFbWwPe+SkDoKlE3QALOlDWD+yCamWhi9koS84OAHkcqs6OvlW/vUQoFtZ2eZ/OTsttJ1VyhFWysCLP011Lt79h2244ykgcPcZWICMhCkMQDl3gydMDjx5dcegF72vOq7f5K/wvPrFa/aLl7n0eY9R1npA8bQod+56hcWw2FU3dEMbAMAykXEtvzdxcYw24TNTftg3eew7HDmcdIddee1/lrumU/3aTfSsbzXwMeUPO130ZtNscNKTSfI7JQU0qcdEUzFtjMKLdv2mMMzm7tYusgaG2hu1mzRgjY1TWjKpW7t620bnspfbfTveYLco466YpKf8Svt+RjB4ZbtdGl+ui6dP80kUG4JYdhunYtZZ6duaXTg0CzlhqX2FSot8f2bYrDqknjj2gdFYplZDNksRjjBCNowuRqxHeMb/88qoyCSrGOKX4Q8wFZrmQ0hhDVTli8ozRQRjzfZzHjUrCWcuqCjhfKd95DgZSSvR9z1wlJ6zXa9rGZ39BlJ6sTJgo+/iCtN+IZpGw5lZpSrGLk7rl7OkyRa7If0G/5+urh6JpcjLy74xhu14zXlwgWJ4+fUIfRoxxNHXD2W7Fxfmai7MN242y4GwaR+VtbgbzOOvmYG8K7MrRFCdc12HqO5LboZfJGaZZY5ek/ZkyLlP8IbmLNBW2kzt6Ozmo+h3OGGpfYbPebrLNTWOe7CM22x5BSg2stTkDYBmM/1i9/YwOakahrAe05sYaTfUbW1FVDeNx1FGhEfb7I85VtE1N22rncxpHiGlKCyIJMRG/3kz0Hd57mrZmu1lR1/pdRTeTpOkGqDNV1d058Kp4z6YQpwuXRYvmZUI5p+czHK4oQtktNS00v91g8h1R6ukkafWFsdqtN0W++dtSjJpqhcmxVYdygSRRHrstL21CKtF6pt9QOGBOrSELCuNU/gGD03oXb2hqh7ctTWNxfmA83hDkmqtD4KOne/peCaFtZfF1RVOv1JA4D94yvOz4Pke5hdqVwEEkU5hFrBVWq4Z7FzvGviOEAe8NKQ4cjx0pJZrM4/vhBx8qSkruRs2d+talCTHoup7jUVPEKepIP5OE9CCAqYGic7cj9a7rcJn1wdqlaZnPY/6dFsanOL2SAx8VvQVUd+fH5galyUnH5OaQheNoZjaDSWdLAGVACULcLb01Cx29dfTlBMvnc2djzsfzjJOaHVGRNL1/gv7LJySNw/XpZ3V3tXIY2xPCERk6xHn6PjCMhnEwHG5GPnz/EX0X6frAqvWI+Qmd+d8B/5fnK9TnKJOjl09+HhqSMtNJGcYQGELPODqSrLm4uAASw9jTDeTGNt2AqtrTVjW+qTmMPduk001cVRGHEZ3klBjGATFzitzmXbugpMCkv6WsQ502SyHoXza5lQtYRqWqlBKG/GfeXSdnIDsW9k5w5b2mZquqyuiX7jltRpy8cxpsLbIAxYZO5V1TdJVLDBbR+3S/MAf4z9RHPwcgWJZQIbNeL5vdbt3WeS1NZgDwNjd8eYusW8ZoSaGjHzrEOoIEksxlBTFHiV0yXB1HnuwbRvndj9GqX7wEgZBgjMIQEn3IwYYpo0j1fIdhVMfc5ga8DAoIMGZu0co6euNpqop127Jer9nstvRjT4gBEZmAhLqqaaqWKHpPGFOpc2dKx8cUImXO62Ln0iLYYrK/BczRQMtO188YMme7Oqo6zS4jx0G0bjaZiX3g3r0L1ps1u/MzHj1aczj2YCztquXB5RkXl2fstmtWbUtT6XAf70xGhS1+8ipLEK5/3VVBWzyLrBfFgZ7QYVj4RreH6Uz7pDGINXoOL9RbM6HHoGwIrla9tW1LFIfEnm7siNES04DypcCUQCFnUzAIFx+rt5/aQS3evHeW9Wat/GGm1+jaOVw2bjHXPYQQOR460hhw6xVN1dC2a4bjVU7paOJFEviqpnCLFSO92+04Pz9XLr+p0j07YHlxV6vVcw3HtMa39vzbTsBEgJ/IJLYl+LILxdVHy2ZuK6epCZk5x2YOMskTTsCkeePXT5B8kTXaSraQ/xbstBzX3E6w3NgLQvn8M12cMMCy43uhqOWTJzqjZRiYEuSb1vsKDKy391ndBLy91iN0DusrnY2MUogZ47Ssw7/0yD53ueV4lTRxUq7IqnZs1w1N7THi8ZXQ1I6bp31uokp5TnTNF9/6Ij/+8x/Td2EeLON0WllIERkG+q6bdDDEyNiPbNcbZBSkAqp8Fe3scGpaK7Bdr551TnNwpTHGbRfwrmNnnnlr0ZyFU7q4P0pUXpr7EPJGktPgkp7bVKIfqBo0zbeSpY7Oxks175MFK7MTHid6LAQdbX7LcZjvC16ou4X5omK9PsOkyGHsiFhu9iNXT4989Oiap08PhKDvqWrHt9vIX+HbvEoDI4votbNgCiKoj2uG2BBS5ObmRms0z3aMYWQMgWHUOejGOWxV4+qGhDZe7Y/dlL4fYqBpGkJKDGOYho84l7udKVhj4XW2GcUyxHGgbrwOB8DcRpUgvzOphTPFPCkCrE8XRy7PNM+oqeVuaYoiXzY372HUhjln8GVS34SaZh2cSkNUb0rKdJl5UCCgdJ+b6Zjvls+8rETludeM20hr+S5FovJ+Ycp3lHGqWgPojafxDamq6EeTgRwDeSyH8uLC8ThytT8yHD7kbfdffqrj+0VIwBNsxWGEp4eBAQ8GPJ4ymlPCSAw6dta7MqZU7/2YUgZ0KrrjUekgVytWTUPV1JxdnPPRo8dTKVVKibP1GU29AmOJYaCu27lECbJjOXOJQg4gQBvMKPo1p8CFQnif8msk2+3FddI3Avq68lPEGktdWeqqYrfd8vrDB+y7nn4cSRJZr1dsVlVu7PM6ztSSh/vkEpCsMDLZb9UBKBR/MEGmMDmUy91C/ZZ5L9CXzQGhkvenW4+/UG/L3wWUKCCC1b3DRKdr7xzB6JE6Zqd59j/0U1v7lLfd336pTn1qB/UuylFm0DpvdeoCZFoFQ4yaxh/6wOHQszvb4YzD5YMt/JKl4mzeeGVaFKX2yRNxrNNIUshOkUbMZUGnGqNSHD0ZOFXSCeGUstC3N/ESdixRpTltVaJ5dWqjiXkdCu0Ik/IW52N6vyxVpiiDIq0lJTYdj0BJyYnccTY+bstfRD4zkpUfKjyu+VPUOc3Om1miVrLoCDRUdUvTaBrf2IpqtYKqwlc17XpD1bRzzfAdx+mXKXebb4pelWjUGXQMKRHrBGt0gpSuu3ZKItDUOv+7rhvGUTl+RRLGKddcGhURb5qGptFpNgikEFk17dzA53y+FqpPpYGgaZoFYjYHI1MoUYzmdPwqc33ojNbc0md0YtVUE2gnRVg4rXb+xvL5OVUlJk7PL0OilARjNG+rXdBFl8pmX45rDvama7C0nreuy+J3eY3uB2WsezlrJu/iRbpbfB8x1FVDateEcU0/jhy7Pdc3HTf7nnHIw0CspWka3mzhn5AfvkSjfrkyIT2iNc1K4B01gBGt39fmtpZ21dIeDxO5ucPo1CMR+r7HGMexVwd1HAcOxyNVXTNm8vuaehrpaSigREb8cuOcoDRWSp9Wav/tXMA5H/mkH7ev/W3NAA2cpj1v0TVvbakl1XpEk1EwY5jsv7Vz/fQyKJvvE9WtafgFs9NdgiBz62iedUpfVF71ouv1PClaXhC5smlP9YsSIQmVd4zeM9o8/tUYyHRWMRmuDx1PjsKT6xvYO367+oef+32fpySjg1wiiqYmyTWOWWeSCH0/sF63VK7CGej9gBv7W0iStYYUE6s8HUyzkolV29LWjWavrNIVeV8hQMyNa3WtRP6ulBtlB3XWh1yGQQnULcvSFGCyhdO+b8q+fVtDngEKijNoADu/31pHQqiaRidJpYivdEhKU1mqymoT58QEpPWbM/IgKI0Zc9kY6g9kqzcdwWSHdSVv2eTpOM28Z9zdJz9Ob0vrwaS3E5qg2XDvdaDS0KPlhpT9aHZMM0bDTnb8Ni/X25+xBjVNa+icFiwXBzAGRU+NGCWVvjlOUxaqqpo+oxgbazUyvn3B9d8YAqnyuV5VoyxnmAh2l8dkFldoXvyCyhpK59vdDZ1yAaYFvT1JROemL1JQ1k7F/NNjZkZQy2eWBoRJcadvur1ZF/ag2VlgWsv5hcLyr2cke7XL52X60Pk7Z6M916fO6MZ8PiLgrGe12nB+fo/1+jHiHUl0Os35+QVN287NEZ8SZfj8ZHbuDPP0DucNxqT8Ox+/MRO9T8zTzZqmxWcOOxHtkMYocbhIRKxj3a6xVomVy2azWa8yh6SUaGMqQC8R96paTc0gkzOQxUwNd7dlqb8lzXo3PWqMQVxJac0Bl6Fs/M+5VmpnMFamLuu7aXkhd+SKdtDfckrvONH6+k8WsJi87i9+uSwCto/R3YwuWOOpqpa63hDTDV0fOHYDfT9OI/9Mzvhs/T3ejl//RMf6uckiNrDW4p3DeEvTeIxEhDEj4JruBCU3X69WDNs1Y06BTmUgoiN+Y4pTQ+o4jnR9xyZukChEE2+hTXocWRMW6GRKSQOs1Xz/Fy+vZJXm08iAwYsurpkBCrsg7b8NINiMgBZ6K3UoZk7H4gjN1H7PitrCuQVPJgUqG+7L5PmlYuVCffxrbx1H+W4zv1bIDAao4105z+AcKZTzUwc7JOHmOPDkqufq5sCmv+SB/2deeuyfi5gMUlD2rawzeU8uafkkEWMd3nqauqbrj8opmuNOZTOx1E2Frzxi0KY4dDRzQU+tdVq7aqKCZM5NjCkaeBRmnhLQqM6kmH2CXG///H1LFjpY7GWxc7DcUyjPFJAhZ2WnfdFZvDVUJg+hyP5B0yjdm3elwXvhoC6Oad71Z3tcuNvnOudyzHo0wot189ZZLvyg8vfHvGE64XK/6H6nnKvOucympGT+8xHcDf+g4oIH8pde+nWfHkG95VVlWoWMpFa18s49fXJN13WEPmCxWDNyda0p4rbVRqni3CrJdEXV1LR5s16aF4PWRsUYtLiZKk9gUBJlZwwxTwWZwwe5fcRTCv62UzpfC1l+4S2Fnmo3zO3IWqHxiDGSqYoMzljGEPVYrGXMDs7d2tjbSqBNBrc332w+bzmnz+7dz6jSdDMtHiJHS8U5ZYG42YVKl2gxa73JkWdKwmZzxltvex4/fkJ1PGCdZbVac3n5gO12qzeXKfWtr6qTqmJKB7rJc7ydpZoMl84VD0FrSvu+wxhL07TaVekcMegIQhGlRgGdk+wnTj01LpV1bLZrjDE5MtZrYwRCDJnQ303B2sce92LTXaJDKdd53Y2CCyI7IWH5Me894xByExY5faRprJQEa+da3VL+MjvEcwpL1UTuOKdMFjPH/Z/i3OQ5j/GpdJdipLMjnpLFmZq62hGGDxn6RBg1lViOuzjhj/hV/p/mf8v/5BMd8ecvzlnq2tO2nrOzDd3hmhgLgq1rp/PKYbPd4Jyh6zqGYTGXO9uYGIPWmoow9AMhaGMVCbzx1JVO9SlOQAncytqWrEBKCe/8dK3KJv1sY+pdi3xHZjXCudzQkmYduIWIKm4/lR4sqddK4Ges08/MCQA9jogYNwU008a+/PI75zE5JJ9Qj+fzWe6RL3jN0kzmoHUOfmXaF52vCX03OSQiMMbE4TDw+KMn7A89FV9hL//spzvGz0HmDGLZg0rZ34CIjuhdrRr6oabrO53+npHyuqqp2grjHYFEnwMpk58P40hdVfTDgK8q9SFy7aZZ+gD58s5oKFOG0OYSg8VLZ3AIphS7kfLw0k7lLBszMGDsbeR/mYV1VUFFC+6YpjHvJQOp/LAla6USEUzhPTVaLONAgbbpOMqRzY604mHPY3mZr005o0lkcYbPfaM88+est/pcGfHts96WjjZziyNR9SFyyfgxevvZaKasxVrJHey6WNaq5+x8xdX1FcMwEsI4LdyTJ084HjuqytE0bS5UNviqYr1esd1udTTytFC6xXmvhLPTItiFoymJEHR0apARsHkCg57W8+HrgpwYYlzUXpQNsGxwRiZlmqIWOxvKkgaWgn4Zi1ij0SHamXnYH2mb5gWrOF8wVXRD6e0vzundwO7uNn7r6fLijPS+sDHsVnxR1nJxU0HeBCIGh3Vat+mc4/6DBzTHA7ZyrNYbzs8vldbFqWF5ceHiqyOSAoaAd+rk1E2lo+9ipAvqOCLC8dhxfb2n7wfaZkXTtlTHDkRpzwQYU9SJJ02bI2bVDZdTkofDge12mzvpNWpOudbKe0/btixK8ic9W4oxJm/aBU1dbPoi2SlWehDIaffJ2M0bfPldDKnEgnTpZ+p0tVyju1C+khW5m3UoRyJCnlT2rMH7pNpQNM85R0QnYC3INuZz+Bjd1SeKy6nohKtbtqsdlorDTeR4GLjZH6l9BaiDTzLs5Jqv818A/8InPOrPV7z3NKuKqgLDiDGJ9bpCUiTFAEk4HI6s1/doVzVN23A4Hnj00dXk2CvfruptGoYJIVqvVjhr1WnNYebYjfj1su5fRUTyXO2R3W6HX9armVl17tpeeH6AnTKiBPl9LB3E285pebg4HFPgn+uns4uqbBKFr3GhsyX7tvx8+QRa+lms2gwwvEBk8btkIqQ0zjqcq6mrNW090B+OQEWSRB9GbvYd10979lcdx35g4/+cDf8H4H//GY705y+KIuYRos7p9Yk62hRTceyOtI2nbirWmw0xRQ7dETPGzMRjcdYTEkq7heBSzZObGyTJNG2ybldZZ0UR19rfPgYUvZzqtq0+1nUd27PdXKdarvCd7OOz1/0u+KMyMVokpnuqPD4johksMMWPyJOlnMtN4eqYPs9u3/3O276BlqktXzHfR/OO8rIg606sdKvu/4WSHfaJm5eF3tZrQr2j2x9yIFk47PN7nUcHHX74sXr7mWpQtSNPf1fOkIzSk1ijJL37/RFE+b6KonZdz/5wYLNZ41yli2ytOrUujwQlEKM6hN7qaNPd2Xbi6tLud4uxFSnOdCQYJTv33t4yqMvCZUWS5pSplijEvPHmSthMsSC5HUNH7mWESTLJfun0k6WFyaZWMqqaN4QwDvPTsx9y9ypTIgp9RKeDlDrUu+jS84ylLJ94iVWcu7MXG4gFKzMyUvTIiibmkmhXeow69aNqa6q2Yb3ZsNlt8bkTU9E1m+t1fvlyq7N2+XiMusEOPW3TUNdab9d3R65vblhy8h6PR47HThvGyjVNIwWzquuaumqoqooYc4o1N3kUlFS5KOd6R2uFtq7zRCMWl9bcuri366dBwd0SfebXT40mTPQ186Qzpq5qjMnMDvPGLlONdA5JnFNnrRyHwPFwgNUa2z7L+VgOXURpsoquTt33+btMOdQXbPNLw1n073nW8ZPrrmQnFTCZ14/EZrPlq1/9KiJQ1Q2PnjylGwb2x47NaoOvW568GpNOnyvWKsendwljBF9BXXvGMZEiOjpwHNE6vJq2rbm8vMf104P2j4lmoXAmT4jSNHJdNVhjqKs6k/V7ttsNGrTInWOw9L2WuTRNM3UrFyk1+ksEaboPZ0CS2ZNluta3NuWUK/7uOKfL7ym13Ew6UX6KbsgL3qsE5zJlteTWZyxeqM+ZUpv4HP2VspM/64hPaOhzpASltwYaSKml1nvIYnCuoqk3tNUW8TXdGEjHa26urugOIxIFCQIccOaPn/tdn6dMiKnJIWJuwrM52yHZvEzX3qrd2ew2rG8aOjMiuVFNkhDDiOC0f2IcsJ0ljIF+6BnHkVU70h072qaZvguY6iQnyp/sEBZe1qZpFDllNk1Lv2Bpa2Bpo+5CROW8F13y8iwgoIfgMjuEmZzV8h5B91lv5/Vbrmk5ruw0LeypHs9d8GBqsL51ci/Zl+/Ujaf4fMLI8qpJb6XU86ruJok6XMB66npDXW2wacDIiJCzVg4ijiFEiAc2H6O3nw1BzSdujNYohjBkUn510IZ+JIw5hZ+Ryq7r6buRVasnIAKrtqauFaEZhjyjVkx2bCttOqn8hHSCNlbVlWHM/GnWWHxV5Y1JG1h0LYpDOjcilfQ1d4zZjGLl/zeysKcZKWXZ2VwUY45kSlq0GJoY0xxZlUtb/OnyPczvLUo2f/qsAJ/kghSjeFfkOd/17GtYWOd5fZbv0ak0OiihqmrqpqGp68kJkTz/uxiYX7aUa3FXUkbiC2G/9xUly9Mde0yypKCR/NCPhBBp25a2XeGcz46QGtb1qtX0f54bbZk75MsqpFwUr8ZDx+otB0qUIEodynnTvHvsc7DC9JqFhs5BSv6R6U1Zn0wxWou6qkUKClAC7KjDMbyviEGP/aWF9ItzXb7ulpF9gWFfHvvPU3eXX1VSUAbDdnvGxcUlfT/iq4ZuGBhCYL3ZYKsV7w3tc4/x85bnBQPe67Qsa9W5rCqPryrGME7cjClP23NW06dN285jR/M10PrqhPFQOZ/LT5TmrAyhWK3ayfk0E0RSRmvmWr+6vnV8z6b1X3zNp6fvouRFeY3JM8gX5OLGME/BsZONsoU3eKF7Wp6gn3l3wy+yrNnmmWO/cy0mJ/UTSnYmnoci5xdgDHMPx0SFKLdKFgqiVtcNya/oQ4dIhTU1hpw6j4Ixjgt58CkO8BcjVUYEfVVR1zXWaBBjRSBFJEWcz+VEkmttvadtK3a7HcYeGIeIs9r9nogaWCXt/vfOE8I8tGcMo27nSZCYkJgwTib7q0uo1y/JPESgbdvcvMVCRWXBlvIxUm4JZgDJYJTrMz4/MDKzaj/3+SKltGpZFrgs2VqWAd6Ojcz0W+19OVa5/ftlp7W4D17kd5SgcxlYlcUooABkFoO6IQ0RUtDAi/xjLELCU3EhLx8v/ZmbpBaHPDUcIJYYA9phL5nLy03OQIxqHCWBy8X83leaNgqKNnrndHxobroCNYzWu6n4OEnMkTx4r4XUtjiSKWr3sq40c4gOtzay23DVrY2w2MNi+HSbSxl1lcnxnHVM36tkw6ClByEjw/NLiiOakuRi+BdE+dyO4D7+Epi58/4OZcSEBJNVd0nZl511I5riLentXN2ARaf2FCeqpJRLo5ubiNq0+H1IgshtiopflrxoY7LWUlW58clXNHWLsULXKUedzWPwrHGIGMYxUNcNbbuibVu67oiI1lKf7bbUdaPIpVHnzuXGJGurXMOZ1EG1dkL7bA5SUlKET5ux7C19uuXoGZgmN2W9nI3prN9TzdHkpM50OXcdXMnmYkZusm6iyL/Ob08TEhSzNbyrr+YOyna3/mo6hxdIuuWgpls0U0kEMZ9SdyGTTpONZUJyAb9e+4r1Zo31FWOMkJ2zONYM19cvPM7PU+4ik5A3f6PE+XVjMKLsA+M4EFzATQWXGpx752nqJjeNCAVxDKRcq6oZqqryWKv3s7eOti5ZhcyMUhwnNEjVZi2v+jFtaHqMZbN+XjAji39fJAV5w2gzqzUWs0BCDS6PSlwG5OaWg1qAgtLgWGxWWU67QF0/iTwPzfoksrSZz8q8d8yHU1CThDERQ0RyE673FcnVeCe07ZZ79+DJkxtW/UhKhp294Av8+ic+tl+UFFS9qWvW6zUpkh3UlB3UABJwJk0Ol68qVm3N+cUF1jmOhx4RT13XOv0MQexMEWatne4PZRGa75UU4zNbe/kj5Tr9YgP0qWf1tchcU/+Sa7542/SyO3bvZc7o3Q+TlAiZ+qkwU9yuv9bXzY/NB2Gmf+f/K70JL3M4n3feLwJ3yjndOt8JzSp6qxzhRW9DMHnIxPJM1aLUrPgC33jp8fxMDqqIjhk11uF9g7WeoT9wfnGJQZ1Tl6mg6kprVPth5DgM7HZn7HY7YgwaCaGNJRrd5NoVowXVXddh1ytWlWccA8fjkaurG5zz7HZnk7IaUYL0hME4NWMm0wVJnJud4DaRcjF2y+77Z881EYIoYltXtyPw6TW69GqYklKeYCbuO8neQwghc23G6TOWn2MLkfonNYjGaBpDT+TOuc0Oqjqw89tSdg9ubUZCnoRhM1uPaGpQ5u9y+bpqCYAa4a7rOEiAi1cDhdpsNs80pwGsVisuLi6JaeRsd8HZ+TbXXVoePDhi8VgMtXes2oa+G0nR0DQrdrvzKejY7XasVqvM5qA6lka9sZ11tO2a2tf5uictSbH63rJxxSSZlzIwczjOUex8/RNTsc/CCEFe/8zPJ7J0CHI2gRJMWWWiYH7NbIjSZLhT0hpD7wNlkk8cIzGNk9O7NF6OFxvhT2KcE8wbdD5ySYLetqq9lKc/ge4aoGLBK2wKNZhwOHR0nQ5hWLUtZ22LqzQLUN9Efuf9/wj477/0eD8Puby8fIaLsGkaXCu0raFdeSSGaaOtqgqHzfR+eo2dc6zXG9brNSJ2QgKDCCnBZrWmzpRo1mo9dOV8rs2dkUURXcOSVndVpU4H5M/S+nkzoZ1Z/2Qup7olC8RyiWAtEaIyuU8/b96kvXeMA/nzF05EJlPX0dgCSQiSlAbLOpx1023jjJ2mYX1S+TQb/Cd7z+29w+ReBz2pCAQsEZMi5ODWAJvNlvPzB9RfbTgeezabLV0/8uXwJr9u/tuf6vh+EbLZbAgh0LYt9+/fR5Iym0gYkBiQGICIJdI0GhTVdU1d1zx48IDVes1+3zF2UfdA12rZnbM4W1HmIUkGeAra6L2uzziOtO3C7pg5uycitxiE7sqcZX3ONbuFtPKs3hqTGQPMRIv3afRLT0p0rHvOtmkDbT190VSqiLlFTVgydgVNnQIfgWEcp2Dt0zioH/faW3orxUEtejtiUkByMPsiB19Sokkbft29XG/Np73xTnKSk5zkJCc5yUlOcpJfpDwLMZ3kJCc5yUlOcpKTnOQkv0Q5OagnOclJTnKSk5zkJCd5peTkoJ7kJCc5yUlOcpKTnOSVkpODepKTnOQkJznJSU5ykldKTg7qSU5ykpOc5CQnOclJXik5OagnOclJTnKSk5zkJCd5peTkoJ7kJCc5yUlOcpKTnOSVkpODepKTnOQkJznJSU5ykldKTg7qSU5ykpOc5CQnOclJXik5OagnOclJTnKSk5zkJCd5peTkoJ7kJCc5yUlOcpKTnOSVkpODepKTnOQkJznJSU5ykldKTg7qSU5ykpOc5CQnOclJXik5OagnOclJTnKSk5zkJCd5peTkoJ7kJCc5yUlOcpKTnOSVkpODepKTnOQkJznJSU5ykldKTg7qSU5ykpOc5CQnOclJXik5OagnOclJTnKSk5zkJCd5peTkoJ7kJCc5yUlOcpKTnOSVkpODepKTnOQkJznJSU5ykldKTg7qSU5ykpOc5CQnOclJXik5OagnOclJTnKSk5zkJCd5peTkoJ7kJCc5yUlOcpKTnOSVkpODepKTnOQkJznJSU5ykldKTg7qSU5ykpOc5CQnOclJXik5OagnOclJTnKSk5zkJCd5peTkoJ7kJCc5yUlOcpKTnOSVkpODepKTnOQkJznJSU5ykldK/Mue/Gf+u39Fzu+dg0kM/YHD/prXHtzn8YePePrkipvDkSQCxuKqClt5nHfgLHVV4S1YBBMTSCCFgRBGwjgyjANiElVVU1U13le07YrGNdP3CwIkAAyCAbAGIWIwGGMwSxfbgDHgncViMMYCBoMeh8Xgvcd7T103XFxc8hf/4jd58OABbdvgvMVZlz/IYazD5CUyxiAigIARNpsV3gAiIIJN4HC31u/m5sD/5z/+/2Ct58tf/jL/yD/y38EYS5LE9c0NP/rxj/lrf/0/paoqvvrVL7M52+C80/Myevx9HzgcOza7Mx689joX91/j4vIB9+4/BFcThoFHH33A/uaa119/SJJAjGC8wzcNvloBhmQEeEFEIp9AU8zHv+6dP3rKv/uv/D3+5f/or5hP8Im/UPntb/6mvP32m5zvNrTeYYeB4/HI1c0Nh+5INw56OtZhrcF7R1PXGKCyFkcCiaSshc5Zqtqz2rRcXt7nT7/9XT788DHDEPC+pmlWtOuWxnsqZzFWkJgo+osxYISsjBhj8rXI18VarLFYmxfasNDfWYedsTjrqaqK1WrFm29+gTfffJO33nqLum4BizWCMQbnK/1qDNYYrLVgoXIOb/Uxg8GU2yxJPlS9T65ubvjP/7P/L9/59nfxVcX/6F/6H/PgwQOqqiLEwM3+mr/21/9Tvvf973P/wX1+5Vd+BVw+N2tJKTEMI1fXR3a7HbvzC7ZnF+zOL/jiW1+h2ewwIhz3e37wgx/wla++petgHc568B4xBjEunz0ISe+5fJy6Mh8j/w3T3X/2v/WX5HxX462Q0sgwCiIwJotgEGvAQOVUZwwWawzeGipn1P45ixgwlefe/Yc4V7HfH/j9P/h7hAB1u8J4T0yJ4/GIxJHKO+qqom1ramMxVpfOIBhDvrZA/ttg5nU1YKwunff2lu6SP0M/zGYbXOO9Z9XUXJ6d8du/9Vvcv38f5+p8b0jWBY+1Vr/XQOU93hokJcZxpD92XD25IhwHusOBm+tr+r7no8eP2e8PdN1AP4z0IfIP/UO/w7e+9Vt8/etfw1WOiPDOT3/Ku+++w4ePPqTdtPm71P4CjGPg5tCxWu/YbM/Y7Lbszu5x794DVusNztcMw8gf/8nf5eHDh2w2G+q6BrEEhLpt8U2DcXVehaR7pp7OLHl5nPkYzOg5upyA4By7dfNL1d2/8NW3pN7sMNYgKeINxBgJIWAAX/TDLfbzIkZomoaL80u++o2v88Ybb/Dtb3+Xd9/7kOubA1XdYKtsD0RIKSJDoDvs6Yce5xz3Lu/BOFBVFc6pXcdkXbW6bxtZfK8BY+2kX8bM116ts0wXqdg0ay0uv85aaGvP1772Db78pS9z7949mqrOr3f5GCwu65JNiZura979yU/5m3/j9wC93jbb4CBCTEKUREqJmBIJcL6iXbW89fZb/Iv/4r/A5eUlxhhu9jd88NGH/Pi9HyGkWW+zfnTdSD8kvK+5//A1ms2Ge/fusdnsWK83rNdbUoTvfe97iElc3DunXW0QIKSE9Z66XWOrFmMgSfpkvgLoOS0v7+K4ivzXf/QD/of/q/8j3/1//6sv1NuXOqjvfvABycB2t6JtW7brhtpZzrYbrIBzjpvDnpBU4awkEIMTQ2XUIbTGYL3DpEjEqSF1jnZVs1q1jDHR9wM3NzcMQ2Szgso7nLU453RTkjQfVBIwRt0GA0g2gMVZxJASWAsiqpxl/7WgFz4mxhC4ur7m29/5DmMIPHzwgN1up85mMYgJ/cdkZc1fZO4YCZOtRkppuhjGGNbrlvPzc37y03f44Q9/yFtvfYmvfe1rGDHUdcXZ+Y6vfOnL/O2/8/u88YXXWG1WOO+QfAyg5+GdIcbIGAaGoWcYe2IYca5GUkAkYkw26NT4ymC9x1YVxjkMDjHlBn3+tX72cV3LfILz6crSsC5eAzzyj/i3zL/Fv8xfeZlafS6y3x/54MMP6Y837Nqae+sGSQN1lcA4Kl/TDQnjdCO21uCM4KyjMhbvLN5VOO+IKSEknHfUVc1ms6Ft1zh3AySSGBIw9AMSItE76srlpVHdmA3y8y+AiCAkJFnEJOzdjUrKL0EkEpKlHwfefe89YkpYa3n77S+r3ueXSwj5vCbP4tbnpXJfJcGJw4ggIkQRhmHg5ukVBkNd13Rdz+///u/zu7/7u6xWLc5bfH3Gr/7qr2KdejJjHPHWT5u7GnEzG31rshNjiGFAjEybjV3c46a81znEWsgOKhjERNXBxfn8/aa7AM5ahJFhDMQoJHXxIAcxxtlJo0xx3QVi0h8TwDiHxEiMEV/VuFoDGww477HOY52QJDEOQoyRru+JMWI3KxyO7Aszr9dyse8ufH6lAHnD1F2AW/pXrnkIcJREioG/90d/yG/95rfY7XZUVUUEJEGSgJXsGNjsnERh6HuePn7MH/3dP+TJR09IMUwBFkkYxpExjKSoK+es4Qc/+AGXlxecn5/z+uuvYQ3cu3dP7WroGOI4B5FGzzfjD5Adm1m31d467zBjwHtd26ZpdI1xVNbg6xpbVeA8iAWT8r3+Agf1JQFX3up0f1i8LhmjG8UrIiKQotDFREh6v1qDOuYCIQrGpOwU6lI7ly3k5DBaYkyQkjp4AlZ0DcQYjHWIVwcTAUlJ9bfr8WOgqjxVXeG9UycnmSnIWeqt6mLCubvrp9doaTwkBxYFqEpJGIbEj3/854QQ2N/s+cIbb7Ber4FIjPm1RvdvEyNdd+R4PDIMA42vMC7b/pTuuuyLY0x0Xcf777/P3/pbf4u//Jf/Mt4X4AwclviCe3E6j+UzeQ2GoSeVe8zmwNFZsA5v1Ieomgasz3ZUA+XnHaX6WsUelR/zzGuWevvAPeUfS/8O8K8+97zhYxzU7jiw3x8QAkPt2LaOdr2irT1m06qSEemGAFbRTGPAGcEb1Dk1ikgZ60jWIpUujq8M5xcXHLuex0+ecnV1jaQBZwdi8lTeUxmDyxvu9E+xkdYsg3eyHiwWQ43ItFwmg52oQY4x0g89Hz16RNu2SHYuz87O1CAlKNCSGlhFKYrGSkp6zmbeUDHMKBSGynvW6xWSEh99+BF/8sd/zBe/+EWapqGpay52O956602+/8PvkVIixEBFdffSZzStGP9EipGYRhxCilF/UkSRDZOROP0hIxkFOi1LNEc0S/U1k/Le2mzM4vXTvv+MiUVMzTUPX6JRn5+kKPTDQF8ZVt4g4klpwBBxNoEzRG+xziAGrFNds9nWW2twBY2yutFap0FTXTdUtaL+ziecq/FVTQwBkUBMkZgcVWVxJdhhAv6yQ5UNh5lv46KfTH/PAdbSsUoiGEmEEDgcjzx6/AjvHav1mnv37mnkXvBZsZMjKHmDKJ+dUiQMI0PXMxwH4hgI40A/DIQQefLkCVdPnyBJI/of/OAHfPObv0FVOdabNc7WvPHGGxyOBw7dYQHPLxDOjDYUA6ZrkZAUMSRSElJcBKBLKQbNFPc+Z0Vm33Mhf//orvNOA6MYiDFw7EeM84AgxkIySND1cIAzRsEAC70kRZdEgy9fNcQkmLwBVZUnSpquhTEGX3lEKqIIKQSGYWCoK3xKecNS22dksfBSNvCFFV5sUrflrq0WtWMJQs5UfPjRB/zkpz/mjTfe4Gx3Rl3Xig+ImWy+SYYQAkmE7njk6slT3v3pO/SHTnUl2z6DIaVEkogkmbaNm5trfvKTn3B5ecGDh/ex1lBXFXVd45yDNDLZ92VUM/+Rz6/8ndSLFg0onSs/HrCIMfn+zxujMfnxFzuodtJdWXzf9BIk23hz6/1mAjReCRFIYojo7qm2Zna/rBGsnfdrgyDGTMGVbsV6DaW4bZJykGDydm5mvSx7Y4qICMe+ZwiBOkbaRpFXWzCmxcLdupSy/HuZFlicVnZmTQEPREgIh8OBjz78ECOK8L/++uvUdY21kJJ+aYwRQmDoB7quI8UIvpptcvmVIyLJDwjZsY+R/c0N3/3Od/nWt77F5eWl2sXnofHPvQVNtsPlTwU6YtT7xBX99U4BgRwEmGx/TQYFxTz78XLnvjcwZefuvmapt9EYnj7XXszyUgc1JqHrO0Ls8TYRVp5tU1M5g2kchhpSi3c9IWmUr2gU2UEFZw21szhTZSdOURTfOC4uLmiOPX0/ImIIMTGOaoD086CtXDEZt9c7/6OvKhhmfp0sXsDszRfDUJxUYuR4PPLee+8SQgBgtVpR1xmtkZQdbjCSl3txY7Hc8BNIzGndbLytKalZw/5mz5/88Z/wrd/+bV577TWausae7fjCF97gq1/5ClhNh8DS0c5FDlJSwEZNvURiDGCEkDexmKKuhZQ43Dxj3JYidx+g7APLrSQfgzAhCvPrloql76lY84X0G89+8C9DjJ09FKuptRh6YgoUBK7yTtNRlozugSFRLrQISAroBpARQAzeaQDlq4oqCL5qqOuGo4heixAYQ2CVPHVT4dyc6Cy6aO5ekXyoc5ReAix9n5jl1SkbfCJG3XhDHGnahrqpWbcrvK8mUMWgx54kYZJmEQwwdD031zc8/uAjnjx+yth19F3H8XgkxsT1zTVjiMSgKNQH77/PD3/4A9brltW6xRnH5cUlDx7c5/FTy7E/TidTVO8WgsocvZP1WJGPkM/57prI/GNu6+VtXf37S3ed9zjnSNEQU+LQdbiqBhKCJQJRNFj1xqiDaoy+JwzEOOo1tob1dqe2yDlcEg1eTF5/dD2cc1BVmJQYY2QcFblN0ZCco8rHU1KVRorfuLxe04NZ7mw8C4+sBEtmQtDheDzwZ3/+w4zSJC7OLzISabPDopJSwsTI8XDg+vqa/dUN3mrGzQAmlWBsRirLxh9D5N1336FdNfwDv/FrrFYrRevQbIJ9ZrOcdx65dUp5F0kJiQHJtrg4/NZaRObNOPvzs2Q7fmtLz9mtZ+z0XVd2kSqVu+v/XM/k8xUDaquMIRkHzpCSTIECRtFsJ2YO1LOdDgFCyM5s8RYlUYCisr9N1jTbldlJ1UCs7zoYR8YQkaRpdO80ILNGbf3kMBSdTDKVqEjK0cIdmyOS9c8qmqtXwJJi4mZ/A3lvWK/XnJ+f453TUi/RkpQUI8M40Pd91s0FaLCIgxY+84SuAgzDwE9/+lPeffddtmdnusYp5QyzetgmK+r0GbI8A8PyG4xJiIT8+YKzFm8dMu03+gHzMtzW2/nh244od54v772rt72p+HPzclDgpQ4qYnRxBcaYuLnZ0w8djRMkjZA6mlqwpmIIQix5dAvOCt5qdO+soakqKq9QcRR1Aqy1NO2Ktl1T+ZoQLdZXJBFiCX2b+wABAABJREFUPzCOA6muqZpqQrempShIpb2zFJId0eJQ3sGki1LoRbWIJG72e4ZhYL+/oV2t+MIbX8C5svBaMoAVjc5Fo+LytSlFYgiEIdAfB9Iw0ncdN/s9V1dX/PSdd+iOByRFrq6e8t3vfoeLizPa1Rlt1XL//j2++c1v8pP3fqJOppQIbY5KSomDsYoOSErEcUQMOf0suXaRWxHi9Dc8kwYV7kSQL7JtS8fIoGlgmIzE/GZhK0/5h+JfA/6lF3zY5y0zgiyS6MeemCK5KAlB08jG2hzsSHYSoyLawJjTNM47TPJgK6zz+Eqd1FAJvqrBWdrVijiOhLFn7I9ch5GVCE3tqb2b6pwA1c9ScrG442V5TTB39p0SARcnNiICISQOhwPf+953sdbx5he+yPn5OU3TEGOcjKEzDitq6Dzw9MkTfvKjH/Mnf/ePOe73WlZj3YTiRBQxkMlDSPydP/gDttt1RqAamspT1zWVr7T0ZHqt3NqUnZtrsvTYEzKMhGFkHLocaKrul72hRO8so/Hn7cN/n+mu+AqsJYkwhkAfIoSelMtJQhKGqMhdcU5tvsGdmTMAPuu5cw7vqyme1iWVHIxpjZz1HgmBkFGZGAOSLP0wYoyhXbW0TYOjZBkWSrsAAyRllMWycFhlGXXr6xaIfjLCmBRFDSGw3+/52le+yr1797K+WESjSNXHEOiOHcf9gTCO+NpOn5mi6p26M9nWJ93IsYYPP/yQEAPf+c53+eY3v4kvUVy6rRfzpvt85dKUcCKEnhAHUgpqp0WmMrQXySdS31vGeRmazmBM+b/ZDf8lizFqS3FTpkSdAbW/kgEYUPtns1cmYjGSGEJiDImYLFVVT6hd+RyRNDlgWv8sU2BmjJYO9iZhrCPESAwjYa8Zxs16RVV5zBQ8aElVCZoLOqqnYab1ZrK3JUNjptdZY7IznQhhZL+/5qc/jXjv+dpXv8p6vZ6yWTY7kyk7g6qrKZdtqJ1PS4OZsxXWGC2TyGvW9yO///t/m4evvU7dVIQQZjubHWtjDEmY0djF56pDO/s/RkQDrOQ161Yyx8X5fwkyb5nXabp3llnmxb88R283cuRb8v0Xfj58nINaJBfiIxDHkYghhZFh7IhRlcU5i1GokWQMtqBGRkACKTliClMtmnUeaxx1bRX5qRtqU7NarQkpMYaROPZcH4/UMdA2FU3jMeRqtIVRfObmTAJWb2WzfIkpgMwyyraa7pfE4yeP+IO/8/tYZ7i8vEfTNDlVqspkxeKdIyWIUQu/nzx6zLs/fYd3f/wOV0+viOM4KUEMikaMWowCAv/Vf/V7vPnmG/jKstlsWDUNr7/2GvvjDYfjQWtFFwanIGV67U32NFXxTByJQ5dTy/ONPN1Uk2I+BzP6NMH2AjmQcgjPkUsS/xSHT/HBvzhRw5NRz5ymH8eRfdepergKa4TYJU1D5Y2+qXyueYqkGAhxJIRA5T1Nu+LiwmCdNvJ473E+glWjYyxUlcOZGmIghJHD8UiMNanRNGJVOUzKToJo8MayPiX/v+TXLPJgijpRXqYXQVNO2jg4jAM/+P736I9H3njjC7zxxhs0TTOlU0VkQsFiCFxfXfPoo0f0x6MW62c0qaiO5NrbgnBIEn704x/z9/7wD1mtV/zmb/6mbtRJN2UrqBMxBYFoHRnqoFqN+vQ4nCWGgRRHRAIxjgvEOK/DdCBLJ+hTbsT/DdRdvZMtIQljiLqBGkdMjiAQUiRhiaJZLoM6jZCd0yQ4KySxiGizp26savNsbhZRu6CorM0lTKU0SFKkamqOfc/+cOTQD2zXGzarmspbpkSDMbeBA4re2AmRms9q/rvYyJJlEqMZpOvrK2KMDF3Pb/zGb0w1qdbkgClGyOVZx+NxsuUxRpZNWzI5bvmvbI/BcDx2/N7v/R6//uu/jq+r6ZiL3TVzon063oKOmuJoSEH0QFLQ4C5v8BIT+GWqbZZPY3bnlcv3+sJnvqXHH5Mm/dzEANYpqmhScf+yoxMJCbWrYhdodUJr6hMhxJxFNFjj2G62DOc9x65nGEZCEs3/m4LCGBDN7lijzZTGhOlwUhICkevjkW4YaeqK9aphu14tNkEhRsE5M9nSCbxdpM8l7yWaHbUko3uzsU79wqTZXwlHfvj9H+Kt5Y3XX+d8dw7GsqorfW8SQoh5T5+v223UVE3q5AXkY0moL/Cnf/onvPn2mzx87WEu7bstxV6npJlil8GuqexPQKIQZGQcepx1OOs0uCx7UbG7dy7v8y75i+W2i3pXb79sVvxv0ldf+gkvdVCttRoR2aIMGtULQkyRYRiJqRTsewwOrDaYYECMXoSEojxjSHPWtao4v5Rcu6ObvRg/1URZbwneEI5HxmFEUiTEirapqGzuyc+bPKZc7EXEKaLOXo6WKKjqwkktRrLUZogknl495Tvf/Q5vv/0lHtx/wHa9QYwilKrwgAgpBaIYHj9+zI9//GMevfshY99PXZiSlTGlqJFSPvGbmxv+8A//kKqu+PrXv461lrqp8bnrsHQp5q+ZPuu2Mmj9iIw9YRy0QaBEMiW1JHq9Js3ITurdQuxlXcr0LcsNJzvWJcV869134oMbc81/7f4m//jLlOpzEmstJhd864+mPaIkxiiUrEhAOxa1RkqovcsBkKYgyY6/GIsXoRRPKUpksqFVNMAYdVyTFUabkdukaewQtJykbdtc82axaEOStRndK6mqbKUU7VpkAhbR6OSYiuqmFUty2nD4/vsfkhJ473nt4UOqqgby+RQEIAT6oafvtCnGW6fXmexg5Ig+iSJRpJz5AN59912+/e1v841vfIOzy8t8uElTY9oNQWmCzYc7I1KSm7OMkERRJ4NgrKjuLtPEEXC5hnopMn/m34+6S3bGsIpsuioRxaPZIZDscIpEYkoYEZIp+4oh5ayXMYaQYAwFXDG5Xl17B4xRzS3kI9aUmsmZ9WHqZo+B/eFADCOrtmHV1hm91e9UuV2Ldqtkw6A6LcXRmzksRECsyQFNpO87Hj9+wve//32+9tWvst1s8FWFNXpvTrELMmUIWKA5qQAQZt6sjTGT/g79wI9/9BN+8IM/4ytf+7IenmHWl1mbFvvEfCqiuV7MVMurzu9Ui2cKQ4fFiJ3vg7sXWe78fcufv3UU8//NMNTCqxGmDqpfomigPDuPs8Uy6qwak9HScgOX9dUmSSlBi7WICKvViu1uh68qbm5uoBtzo5XcOv3iymn20eUgOeVAGYiRlNRnCVHrLldNjXMl21D83uILaMNscfwn7RKQbNhsvp+iRIzVMpQS3khKvPvOOxPTxNnujDo306SoewHM+/t8y5jJ5kr+rd9i9GyyLe7Hke9897sM48Drr78G+WwpOKYxuXHXoDjnfB9r6ZdHxCBRm2udswukNIHx+h6xSAT8UjWfr7dLm1uuuSy90efo7Qc4/h13xv/sJTr1UgfVZMjeWIMxDpNsri9Rb36MgWFMGOentJEkA1Hr96wRrUPFaBd/inlzMlR1Q5Jc4J879lM+U2sNBocxFQwDQ4wanSC5aF9m6Nxmp8wsa37yzZEklwAsd6OsdIsUk5jSjGLo+573338P7zwSBfNQ61LntEVm5EmBmGB/s+fJ4yccDwfdBVwuLBaZIpiCJokIIQS+/4Mf8PC1h7z22mvszs4UfTZFvXLCphi7WxD9Qk0MGX2K+kNG8YqyTJb/BXr1meR2xHfXJAZ2POEv/czf8vMQrTNa/GSaInUudbViSozCZLT0+iR1ULPhsqgeGyukpJ+jzkE2RyZfMVkgWdZM6eyS1RIRjt2gzQMCdaV0VN4ZSunw1Lxj5ut/twC9fNZMe4bWP5tESmow9/u9osF1xappODs/x+E1DVzSpLm7WxtxtEh+uicSkzEs56Z7sm7IN9c3vPPOu7z37ntsLy5uHRey0L87xzs7qbL40bToRHkFs5Na9Ff0A0uDxJ2P/3hdyP8We/mq624RYxzOV5ghafBfjtqUCqcZJ1S1y3XTGTG0MRFjKXdaAAGUtGBe3FQ2Nw3SFPjMtj87klpuMCoan/WhqTxNpfvDck2n2rrpPIxe5/mR6dWqbqJd1lYp+MYxcEhH3n/vfc52OyQlNusN3tdUzlHqS9NUb7r46GmDLOpT6vHMpN8paVnXd7/zHe49uNQMVFmO+YP0vQv7WzS03HtazqDrZ7m9B93ajBNKc5RP/U5s9PF6UNbqE77+lytya82WdbLF/uoe77AWQgrTq5bvU5RasNbR1A1plTD0jDlDiahu37n4M5gG5AiFCJistzHNe3FdeypvcMIEXs01rZoJnvZUk+1StkPF4TbG5Hss3zcSGWPk6ZMnNE1D2zas25ZY10hUVFezSs9p1Sz6Uvbu5ZkJxPxYiIH33nuP1apls1mpnbbzpy2dyZmyUh911mWGGLWHpUTCWaOBg5DLzsx0LKUM7dPq7WRzb0cTkzxmx7/PP/yzOqhapwdgjQfrMEaNTYyRfddP6VJwBBIhl+JYozVRLl84RUx0s9qsc9CXo2nnlF6ppLCNMVTWId4TQiDEQBgDoUqMKVDXNd5nHjHR7xBbHLxccG6L4j0/ulQkIaNgVi9IjImbmxt++pOfMnQDBnjjjTcy6qV2NgqEoLQRx+OR4+EwbfLaYa03znQzwGxQMbzz03f44Q//jNdff51fOz/PBtxMTs4ieLt1Leb/1xqoGEN+nUwpqvJdytGSZjRL3/lMoH1Xb55ZKXNb6W89fyeSqvgCD9L/9Llr/XmLcVb1IaPSKVsZ4zT4QSq9llGIYolGI19CDpBEMEnj5VLXp/1vedNO+e6Vgt7PHLh6fXJtK6rf1jnGGAldx5ASq7pm3TZY69VBs2UTLE1xLJD0pZG/7ZyWhpVkgRinTf76+ooUA23TUDUNbdsqx+8C2SxReoyRZD1TCUGh61lgIMXpMBiGYeTxoyf86be/w5e+9lWWDSkF3prbwHKDxEJUPQWsTGml59f8yVRXRQkEzK1nb1/zZ5RgfqT4B9N7XmXdNepQGuuw1mPMmPO7+jPf43OPgGYMlFZKMroXxWS0xmCtx1nDZrOm6zpCTFmfE1Zy4JXfZ412X1vjZqRTspMqgRiV33a7XmNti8dMXdJi0pRtshnulFLGAotdLlLqwxNq8Gz2lUUCEg1XTyM/+fGPkRDhgbBZb3BNPVEKxammcQ7k7u6HQvnM2w6QAf74T/6Ir3z9yzRtrXqY9atYvGWZwATWTGtitf4/I3+V98qPWb5V7v7w0k3+ebo7PXbHB5v+18zvfCWy/ItARMjgDKielpdkVhNbacBsQq5zjPHWNQqi/Lx93+OsZ73e4lxF1x0Zh4EwjoSoAZN+X17iOzU809UulyEljlFr5TfSkMRROW00VFBCQThBMne4TCUspe5aEUmbM14gWJzLiD1Aihy7SN8fGcaBJEoRSdJywiSCWFc8leUCztULE1xV7j0t5wHBBOHq6ooPPviA1brlwcN7E4PS8/TAmGwfUgYCss9g8pPKLezUsogGi1MzuJQmKcn39+0veJHelvvwFlixiBvAcMM9fl/+mWcPeCEvr0E15AaSHFsbTddLMSxJFXCIkSQDMRnGHCGISEafFLsyVol6lRTdKtJotEs1Ji0WtrmzT1OsGq1OaaasuAI8ubpSovK2Zb1aUXtLMjIhL6VXaxa5dVJLCo/JBJUi+cy1d3O4ZghK7m6t5bXXXtNaKGu1LjVv7CEEpT5JKafYMtIjGWllRg5KEb+xlnfeeYc//fa3+bVvfvP2kS6dBLtM8+ivlI2z5HoUi1B7TxKvgwKk0ProZ+g9Fqdr+NxVMUz0fy9Qg0/0zFa+ze/wPwB++sJ3fG6i7ZpKBeYFW434VrDRYvPGnixEmzkmE1Nq1KaC4pfUCrik/H0h04zEmClsEGymm1FKp7m4XEB7BLzHuxqwhASxGxiHkb4fON/taLzDicG6+SJo2bHk9FPWLbMs7tdbN2WjYpOFaAgyYq3TiPvmwB/9yZ8A8Prrr7PbnYEHnwOpZZlLMfFSdlFhujeeFzHf3Nzw+3/r9/mt3/pNhr7Pm3sJMAGbsvNZavuMRoyUwvtyPyeUWuB53zJHarIARhb78nSsn1R3zQueeaV0F7KdNZMTp8G7nQOMVJ6T/z95fxIjy5bm+WG/M5iZu8d0hzdkVVZ3VU/V1fMkggQhdhOSQG6ohkCwJS0oaUd1bwQJ0FqAAC20kAiQ0EYQuJAESgstxIY2pJoUQaBFsrurW2AN3ZWVWZVZOb98w703wsPdzeyc82nxfeeYedy49718VfnyVfI8xIu4Hh5uZsc++8b/9/9Q2q4WdSi0yBpKUlqSAjFEnj17pt3vhyPjNGsWqga5KJdq1RniihprH5E0k0WzSJnc2ENSmthseoYuKruLXzqqtYEEal9iu39ucbLNFQfnSKkQQs3gZiRnPvjBDxlPI/eHA7/4R/4IXbhR/NycmaeF/eGxJEQ17u3fojAVAYJ4Pn75gt/62m/z7rvP6frQdLVzVgWzp81VVhST8c1mq4GlHcQ5bUg7c04pOAmLgRdYoGi2PkV2Hy6/upay+iM5eyB+ektVVn3eK8nUuY+OaLe8lpVRKFSDUQrVaoLwySef8PFHn+Cc4+nTp1xdXRGCY+4ih/t7xtNkQUL1NZxiMovgysOzOz/COCpscB4i217p15RaUFkG6hXV2qQHxRWjTrDmUJ1hN4thRpURhpIZri+5vL7i+uaazW6L4JjGkdN0Yp4mxCm0rAtVslQYxHylOjxFzfg6Ky3MkwATH3zwI+Z55vLmgm038PiqNkpwkllCBczuO7qogw2Wv8ia+BAHJSEScMUtQPfPILcP1PPZ2dQ1uB/wJ9z/Cfgbb/yctzuoloXSzKSVjyy6LqiTGaMAPcreYxyjmKBIbZyA2EFOmeD11k5Txrmg+MyStWEF0JK1OqTafLV0/gL0XafNAdNMysI0J3abgYvtwFLVVSdiKekoETDweumJqsSklW2wKGOeJl6+fMk/+2f/jGkceef5cy4vryBEorPScFEcWM4ZF8BbJq12sz5cYpHIxx99wtd/+xv81m/8U37hF3/+0e2XM8Fcv44C8UPmNB6Y55kQbYKFOcdNK5hzIPD6+ayl5yxxtRZi99qvcSuFU48JfJ8r/h33z/MvPXo1X+zS6WRBG5qCR1zAx0EdJwRxZpBMtgHwhZKSKguxWSKGVk9OSBlKcQTfcXNzw/FwoOSs2ag8a9e0yWpw2pmqZRTlRvTOk8S66rNytc7zCzZ9x+Vuw9ArUbJGw7W8WK/IaKKcqrJCajfUGeZKYUiGe3Uqy06Eb3/724ynE++9+x7Pn71D2G6MKF0ZKOziX3NELcYxMarm1xpOSmZ/f8s//Me/yi/8ws8tjmn74+qR1PK+Bk7BB/q+R8SGT8wz0zTbdbgzR0ZPwJoihEVBrk9w2R577RHZfcT3/TLL7utLzAA2BaxmXGTF+mClZwd1Yk7NSFVZSkkhGjdPnjBsNpyOJw7HUQOMlJGsGcGFMnzVZFqTBKa/HI45Cfv7kdOU2Gwil7uB6LAqwxKoeWogssBgapYYp/YgO0eI2q2vcD1HLonoe06ne+4PtxRJpDyRxkJO2nCLC9bmhQVVK1xyTUQEj9T+B7SjfE4zXY584xtf53S656u/8POEYZXWeGBZK748gOG1NSHiAReVySL4WjcwR1SyBRKPeEufUXYfrlV/+YP3/PQdVKuDLw66q1UX3+bAyUpGvfcMfcdpnqjnL6IBOSVzOJ745OVLTqeRjz55ycVuw+XljovdjovrKy52Vwy3r9gfDuQiNnWsLNPARKxrX1pTVgPECEwpkyUzpxkvwvXVDuei+RuL3dNhJ67pJ+/PJ0bqe4JBbBwhdGw2A8MwEKM2dle+clDKt8YyYWlPb9CrUgw7SzXjii/H6y7iMLumTu2UZo6nE5tdXx/R10RHEH2W6ECyVknEtxTnMPR6TVVfmO9QIT/u/MPOL7zetLUM1B9l/TbVG7VqDnDJnr/Cr75VpN7eJGXOoZY0Sjs5Fzy+i8Sux82CKxXwLmbrXXOixEiMtZxkJRhtxFSBCkoPQSma1SprQ+WWaVSWdQnesH3G2Sdjzdgqri9Grw2UXpqj5lnbucrR6FrjgCpxGv+as2PlDFNJ3L665Qff/wHFDPrV5Q1x09u9kVbiXEoZVhwSWFENU7WeGv7Cfn/Hb/zmb/D0nZvm0K9LSuvlqlK31/V6ilEDGe1VEcM6LdkUFR5nRsXKbVVgllNand8b1mOC2V7U75MLfN8/efNnfIFLcTVhUVaVicIyhFLLmrJsk16FGSmTwWJZxiKuZamcd0QfuLy8wofIeBo5jRPGVqX3sWRc7QyumTDjZpVW+hJmKYjMgCOVwraPBMOmliabzoYFiJbFWDkrTvO8jb4JbEAD+pmSuH31ygy4cLHd0UVPSYWSSuuyr5+3SLD+/SInqgMqBpGiYP1vf/vbbLcDF5dby0Bps9ji0Lh2/rUEFULQ5hFUN0TDRrIWXVPgrilKt/IqH/E4P8VArykN11f4ZZTdR5ftTc2o1C/AxjU6ur6zAMhZIstkrSjWeJ5HvvPd73FxcUnf9XTdwFXoOAbPYX//2iEr768WtLUUv252E7TsKHPCgMsMXaDPwcZGKzWQOqF5MXZ+MfbOsqeg5ywWiEHWZyh4hu2Gi8tLNtuNJUGyjoNEyM4GV1QIz9pBZWk6sZ77FnCJc0zzxIuXL9lsN1xeX/L8vaeP770zJGs13G5ltC1zutlstJO8aGm4cRC/Jqo/puw+9vbP/7af7Kqy0YJMWV52iuusZXKx57qLkSmsWEugQTjqls8pk8qR4+nE7X7PxW7L9fU1N5c3XFxeEbqOOSVciExTWTirSw3gXc3TnEFWoFK5FY77PV0fCTHSUYer1Dy66TDTY3oJC3wrmnNaR/N2ITB0A12IROfPeERjFxm2A7GLxNARQ7SvDpyj63vmNDOnpCV955hLpjaPb3f6DHQx0PcdFxdbNsPQnEvbQfu/rGR3CRBr+1p1wVuV2unea6MZy3vOhOtRR+D19UAg3esvcc8FvyZ/8c2fwac4qJq9DFZmXG6284EQIiF2CDO17iQWPevd9VSMhffB0tRFG48wehQf6TubzNN1kGuUK5p9qtxnaPoei2K9CyQ0OpuTNrg4PHNfGPrIprcu1xrNem8PgLSHQFdZWCtqo5VzRgPk8K6QS+Z0OumkCHtihm5giEbLUDCw/nLDltsvq3/DIhrquJ7GE7/37d/jz3z0p5nniYbzeyR6ftgEpjJX6EIk+3XpqGY5pFHJvFGQ5PF/uvX75dG3nv/S3h5c5pr948f6gldloKhcts7kR83twvrQ7ocs91B5Ho27jrndlzMQfy6EENlsNsSoVD4lKT6vFJ3s1UoziI2aXYyxOm968JQKRzc1B6/vDKrhq3OnDrUDNX4abbBkUBfYiq8pNVcDwsLkCofDPYfDjixami1JGkRHLFg7S1C2z68yWwMrGpMHWfjoo494/vwp4p6yudi0ZKddGjULsJZf37B6juA8XQgapIq0J6gGjfUevSaT7lzpvU12H/x4/sqXUHaB1x7ZiodUZwtzlrTMqEMmdAqM5ICUrFkXAQwjmXNinE786EcfstuduLy8YLvd0Hc6DnIYNoB+jnBC/CoLynmjRb2XNQjPgmUoJ3L2pBDYbHpczzJ9yk5nrdoWR29xeitmvnbghxjYbDZst1u6TvGnpe2G2pyMykowu+N8sQDUtcBTeymUR9r7Dh89IUDs1DFIuQ6LXNqqdJvNhqy+zg287kfX2SCala7AvY4yXN/ezyK7r7sDq7+sDskbsq1fhmV+D3gaeRcW7As61tx7RzbbrG0kC7WiiGH/raHzeBKOx5HTaSbPwvX11eKLOM/Jz61ac9ZIWgOi5kQri2edqDTNieNpYrvZGPZalYxnoZ4KrIYCOO1lcM64o606FLuOoe/pY0f0/qx5zjsdG31xuePm5prNZsumG9j0A8OwwYXAxcWlQnCOR8WdUjieTgyDjtjeXWzJJdOFQN9HhkGP12y+q37PCvfbvrvVoyaLvFW/p9olEXDaubt80mvS9/uWW0dP5OfeKj9vdVCjTRDBspFLqS6A7/BeJ33w4ARL689xmjIPEclpoXWyDrxg0cN2u+HmyQ2n08g4zYvtkNLI68FS7aHO5famfCE7uD+eGKeZqY/IxcBuM7QSaVlPhDKD7701LRWaQOu9UqMeggcXcKJNWfu7pGTMJfPs6RP6GKA4JIt18dEcjuW22E2RxcgXUeehlMJpKrx89ZJvfOMb3Nxc6Zixuo0PcvUVqF0FvZYwdH5ubtNWNDI1r7tGQtUneqQk9JlVW/N/TRYe+ctLueevlV//rJ/4E106MWc5S+f9qiJQMxtiD6TdG6QxKsROh0Pk5JRiKass1u7Swzhyf3/Aecd2uyPGnuPhwOlwJBkQvvKBLlCL88zLOmCZjRuvlMJ26MhRp+P44IjR4bMpOV8sQ7NE+VjAoiT56txKVfYIzg2ELhCHjn7oEWPgKFLwPpAdVtatTkjNZqkaKyh0p5aVi11PFtjf7/nBD39A6BxfuXifxyRqwbgqOCjU8xKdOR9DBemv5Re0c72sMjJt886+faalH27Pp8M9+Nsvk+xWY1ENY4MqiXH2Sm3utPezhFp93+EkM2enDqxTOqqSE2ma2e8PvLo7Mrzs2W43XO52XF9fcnl9za5kxnHk7m7PaU4KS/HzIw6QKqPGqWjnN+fMNI04KTzhiq7bURtt63/eaYOno8ZrtSHMW7XM+FidI+E10xsjsU18WgILFzw+BlwI1lAWGv7a4SAnyDohSrwjlEzXdwybDbvLHTF4dtstNzeXXF1dLZCAtRUGCyY1q+tczehn1o2RjWOy3g3JViV46KT+mLLbzmWR3Yd/+1hT7U9jPYSi1eWc2m7xvlEuVgqlEEKThXrfkYLkQsml9ajkvDCn5DIyTRN3r/bcPL3h+bNnXF5dEjvzV1RTnm1Mdc5a5t5V+iUBPP1mw3gatanQK8xEN1wdWZVbd/731jQXvfIIhxiVa3WzVd8JlWnlug6UIGy2G548e4r3gSc3T3lyfcPlxSW77Y4QO7YXO77zne/yyYuXhK5nf7znw48+5NmTpzx//syoO4tVllxjmBHzK7CrxyCOuv8rOwisQNGre2S6phRtwrBBMhVT3CjE/gDl9l1J/A958daP+VQe1FparA6qNycVjS3QU6hZu2LnUzm47KQ0BURJBVdUyVbKmlIK3gWur664ur7mcH/kdDoyjRPTaTLeSjWmiJZBnYAvletriXvnXLQBJc3kAjFi2Rk15qFhSYp9LU4ppkBD8JTsoKiD4b3SDpXo8dHTbXqG7UCWTJozSRLOe2YSUUSxh01brMr81QkStAxEwRXhbn/Pr/36r/Pn/8Kf48mTmxVY2aJ/ERRFLlDSaoqLRXjGo/qwLUzt1RLrrCD8bf3YOu0NCqiuWzfx9/33ftxP/cmts7jJ4krv9YHGiL/PyqVFI+ugeLgueHIMOilGCjnN5DQhJfHRRz/i+z/4AMTxzvNnPHnyhO12YDsMzJNOw5nSrDyVPuCsqeLsPpzdAC03HUftTN3Pxje5G4ixozq3DtcUuWYnfPVP9XNLQXw18qpc+03PxeVlIz3XTtKiMiyJgs5Er5PKNKCyDv+Gd9Tz9SHQxZ7Q2Wx3G/kqTrOw5+isuvMFIavDJOqW19IvOEIM7Ha7lWewCn9WyvX3tf6wya4toVZoRI2H0OSg9Ug5/XfKmU1wTRO07FUt8xcNQ2YpzPcH7u7u+REfEYPn6ZOnvPvOO1xdX/Huuzte3e8VgnWczoN3WfStrwew6lMIqp/3hwP9MLDdbtn0nQYlaFSoTbP21eBj6lQslINRkxc+cLnZse0Goo9mlPV6t7stz995xvF44OryhuvLa3bbHZthIEvhYnfJy9tb9vcHShFOeUZK4ebmmqvrK4oUYnT03ih2POr4O4MIrOaOrgdYvKZnwXB/i87XpgffjH4Ljj63JL9Zdh/60j/NVZsui6A9EvaaOLXxMXpGc1C10iR0sWPoek7zbLbNwnYL7KUIKauLXzlIEWmjfj/6+AUvXtwyDAM3T27Ybi9bHLoe14nBC3yoDmtYDafouLqC6MQy9R2uaJMX1TldwVKqX1RL411UOFmMkT5qw5VmhvXzlXtU8E4zvcNmw7vP32Gz2bHbbBn6nhg7XIz40BH6jm63oR82HMtMlkKSTJFsDvXCLPCoSK2v23yI0koJj9+7ZcoVuBJtzoSzYRufV8LeLrcjz/km/723fsKn0kw99snOO3z0xC5i5oZCIYs0oy+GefAhaPam33IywwjYaLjMOCU+efEJ3/vu97l5csNms2W72ykxc4jke8VGFVmaptp5YI0sXo1qdUNSLtzdH9huemaXiN4zDFEJZ139epiF0g3VyQsKU1iYBALDMHB5ecnl5SUxBFJKFt1lsiRSySSnRl4nETmdBYyKea7y4dQgh35DiJrlGzZbIydWQVHCfoOVt7KyRk7e6Vdj9zNHZHFml3KqAXggvOk2VyDCOr6X1yT/jWL2QD5+USL/G3n2pnd/oeuMlkucZprj4szVTGjNPHl7ekN9tkGZJ6Inj1rq8Vbe817YDFvSnLnd33N/PPHRxy+4vLrg+uqK3XbHk2fPCX3H7d0d/bCxWeaRTFrCBTvHmi0Xy46lIhyOJ8Z5JpXMdvMUY8yyL73HAcN0uWryrSGrNnTYeNHdZsum61sWqq7NZsP1zTV3d/f0sWfodGRp3/VstjtKzpymkSlldUA97LZbhmFQvFYIDH3k4mLLsF0w2bU5QgPoFQbq4T2qWQ2WctyaUUBT10UrOF4eYBCkfcryeW+QXYHXNNmXWHahZjTqIIgl0KzOe1DFR6WZklKQ4uk2g44sNT0cK8WTlpIAyKnYCFuFAZWihv7u7sBut+Xp0xtunj3D4a1b3eFcUL7odVYmLBl3h9Nz6gcuRAewpJQ1C0sd4byUz0NwZxAc7yOdc01uY9cRfaTrDKfnvAXmgT562DpCiFxdXnFz85SL7Y7ddsd2u8PFwDwlhg8/Yru/Ixf45OUL5nmiGyJdHwCFrjXanTcY+jNYX1OE638s90ekEvZj5d2677rfLjycUPXZ9O7rp7ZKlX1ZvFNb0pyi+rMlt7zqJh80kHIGjcN7uq7jYJhibSj1Te6Llfuz89aAvLCOJGyCVCnIOJI/ecV2O1E5nKuvEuo9rn1Bzq24rvUZ6zc7ghc6C4a8d1C0gdS5YpSZpnc9xrOtWGMfHF0XGPreoDJlVa3ThJ73gotq+wWIIWqW09tQDpv4JCUj3hNipz7QmkAfMVpBqUxQmKthNmXtkD9kZym2d5rsOvPtSgYXWsU5GJ6cYn8X7N9L1oDlp88vt55v0vG/BP71N8rTWx3UdRfx22K/NT6vljMqhqManthF7abOyyVUMPTheORHH33E/fHE5eUlfd/RddFKp9pVdxoncL5x87l2A+zsVpsnzjGnQkzZIjMhxEti1E61dTmhlZlcpZAwA1+NvEVGm2Fg6Hrt4Fxdd9d1XFxeIHKg7wc23UC0Bp0QO8Zpsm5BaxaQwtPnT+n6Hm/NMBc7Nfo1Sm9tKxYlIrUjspwZ/NqA0hSVoNkqcTr9ajnR1+/gY7b+sd+dvbyo18eCsZdc8B+Xv/il6ITOJSMlnl2bNwqxkrLKYdZSicei7QBLhkT/sIuRqXWmstyjItqoNydSUV7c0zRyf3/kYrvj8uqKvotcXFwSY0+ulWpH6yzVLNTambYSp40CTilxGifmXOj7XgMTu90eaZF80744M+QKZ9CIXjMUMSw8jVVJ98PAk6dPEYGL7SWXF5dsh41h/nYcjyfu7u85jCfmnHl5e8s777zDsBm0k9RDFzxdF0yh62lI9SVtz7Rs1y7xjeVIrSipM1rdnrbhZw4Ci/B9RtldsgqP//rLJLv1ma5YN2C5/pXH5EMNakGy0TqZg+dDIM2z4VMXw6U0dbLQ+GpyiWwBd8oz85wYU2EzbBjHcVEfq/tYy7bUEr3pU99r5aHvAl0XVecaRt9RTPfS3q+63KAszoKqloVSJo7gawNKaPLvvE0cvLxku92xHTb0Q0/oAqHrEBz9dsOQdXqQjxHyvEo8yJJhfuuS85/kofwutowaaIro/QgLu0Cj/KuZ2cecyzeezKef5ZdpVZeo+gQ12xe8MzadOvdeO+9D7DRYMXtXn/2aYX+stUeP49XJdepMuZwZZx1BXlP1Tpwi3dqjpAZWTKdXHL5zHoxhBecaWX1rkKry0vwFy/ZXppgYCFFHWdckU+Xgbvht1zxkQvQr+jVL8ZWCcxrg4J3BV7QPpyWfVo5iHTD0mjEWqDzomijE9nFJyFRBblURc75zzvgsiFUZtcHsEf27Xp9Tbjc84U/wr7z1PZ/qoFb8nFtdVMv82P91sMOqOQczSiZYpRRC0A64YiToLUUNzPPMq9tb9ocTd/t7drstFxc7nlw/0VniQNdPpFyWzuwVEdw5Oe8a7wnjrHxnu4st203NBnAWPXtXS02qMBeFuJQxN/1gZMwrPIdzbHc7nj1/Tt9v2PQbLncX2vQVOy4urvjo448sE6bdnTllvvpHfoG+7/CWoetDaLgsXBW8mlEyB5UF8E/b/QcCYAGC2IjTSmHRpjkg0Kb08Prf89hrDxoZ3rAEeMUN/6n8Df7Xb33nF7OKGE+p8YmKZXXEpihJVqOirp1b9qp2PxtpRRc7qq/V5LqIjYzUUaWSlBx9nCbu7w7c9nuuDieeP72hH3q7l9qY1ZyudTnbbnzNhvvg6PuBNOnrRYxRAzOsSIN6LE6M/m2wqWxaio/0XUcXOw2anNd5FM7jg2jncfBcXlxweXnNzdUNF9sdm2FDtxl49fKW3X7P/fHI4XTi9v6e3eUFm81gZVFZzTeSts/VgC8NaktZtL23Zq/t2a2KsGZedXyyKXVxjfpkoSl5rPT/GWT3ETH+ssnu0pB0nhU5Sy770vCW1XhV2FTFYhYrWS9wEONRlqWJCFeb3gApiuMfb5lS4vLychUk0+S2OXeuBhGrwMrKqH30RONX1NKka1cTfJXdxdEN9ncherqoshtjxY3XDupg+wNePBGl3HHGd1ynXRXntAk3qLOqlLGrG7+SUamJFGxfz7zPCqtoM9VWSZH2BzjH2Wz1SlfYYEWre1jH1da9X/yNzya7cv6W187ly7BaA1t7nlXX1YxlhQyqL6jZwlATP9YXgtDkuMIu2uW6xWHVP1FBWlga1j7I4hcuHgu0zLadS3GOIHUMcA28zD+g/lyrrgvMqtJg1qTA+VRIWqC5plXDKQ67Oo911xrsUZYR7D6ElVMJD256k6+1NqzPcqnPLTU5s8S3bhF4rRobNVwt9S+5vwVX7SpL0fpRek0Pf3a59dww8N/kbeutDmqWRMkFH6RNGMEF6vzW6J12BGeN4qtz6hxYUy5QyMUwStT3CF0IhODMmXLMKTFnbRZ5dXtH8I7t8AHv/9xXePbkCbtdp3g+F1rGSYG7dTMWBeEso+S9YpmyCKfjxNOrC5sKpOewbprSv9FQqwpcCOqgRh/MyEfDrSjPpQS4vrlm2AxQhIvdFc+ePGO33TH0PZvdJf/Vr/+adj4j3B+P3N3vubi6oO8itYs12J7pnG27g26VvTanuP7/TYpISiaLw/f2gRZ9thFm1Rl6oMseZrTOuWJXv3Bn315bT3iHf8X/99/w2y921Ya8mnUGCCFqsF2sqaw9KFCzkOI0O6q4P2cGcKF7Cr7i5XRvK6F+MtqvjGNOJ47HkY8//oh33nmH7fYCV50Jp819VCO/Kjs5TNkFx7DZKJdep13MVaad0fU0GpsWodOCwC5a41EMNs5PM6ldjNb4AsF3dDGzkY2W9ruB7bChi9rhLA7mkgldpGfDaJmoUq3HA7lwVGO/vKa6XxZ5MoP1GmWqpaZynhEcnmjj5xR3Vg+1VtH1tc8ku5/Bbn+ZZDfYEJNKl9MwZIUlwCyKdxenTVBJTOYR4/4NBosq5uBptjWXYlmnymghiOGQq9EPTonM4WAT0ZxR7HrD4lU7K2jDRpVfZ46HNdmV2sihx6n6R40+bZaG8yrPLmiGLUZP10dyTkvPQ3PaDQ/oFWLgvScn05dOq0qKccxKYRajlpSrDpUK5zHj7Gh6WGnW1tIm5DTZxCq91iIJi2J1x2oiwYYSqNOZSZLpRBttMadGqoNUo4UHevjT9O56ndd5vhxrXTZeM57USqwUWTWSOZvkl21Ko02WstGxAe2Or2N0z67Ufqwy6TGZs/tXrHkap8NPZGX3zpxmc9jEso0BPU9NgK0DMD1lrd6u7HHNohqUqvoNa7jS+T01ZpZAm5x5NpIbHVedsk7O1KbdYIGRbVt1AJvTp+fiV/svLMOStFKve6NVk7X/oJ+gz4peQynKDRuRBVNmdIxNYP0DufuccvsRH/B3+T/zt/g3X3+jrU/NoKpXL2cPk0YoStuhU5TWEY63ySAe81kpWfCxo+t7SprJ86yKZ5U6FlGi/jKrAU7APB3ZH77J960UeX1zQwy9UkPVaKTyfprjqDfMykExsNluKblTBzt0eLLiOP3imColUS03BYYQm+B1Q8cQB/quow+RoeuMUqQQA/Rdz+XlJZtem1m2/Ya+75TX0UHoIjFqE8mYM+kuPRBa0W5PU5TnCqdSm9BKESp+53g+aQ5VYZoTXd/jfDDhKudR/E9wvcP/j3+dvwl88hM/1qetM9hJWeGNS1FAcD4P65yD2EXmKTcDV3Kg22xwIZLnCRDN6uAs472isXFgs3XVKXAgyfPhhx/Td3v6fmgjgyt9VDVo6yx+bbLrh8ECOX1v33VIUW7ApZN0cVCrPPd9pAvmlPY9IkUdFr/AVkBFIxC1VBojzTl3QkapsqaU8F3HECOnWcH63ihVarmy+kuPJIAopZh+WCb+tM5SrwZfXy/MaWIYNqR5JgjEbjBFmHB0PwkROVtfJtkFNZLFLQ6Tjo009W66WLOPlforQ1Ysp+8C/ZAIdfIN6pS1ca8+II020NNcNhsrq81yQqnY9lSM+cSZo1hPwj5PtDJU7D8nGYmBPlpzYMXyYXLXzt06oa1SFSzjGbtOsd82YUgseK+6GuOpVIc2AKkZxvrsjtPIcTwx5Uw39Nq0ZFTEukr7h8iiH5uRX0EpMCc/eLc0kjyQ93meLfsF85zpozkfD0huXvvDn8F1pnutZJ6Nuzb2AyFMYBjU02ni2Y1B+cT0REvQ1MSKvqprvX8LmWNB9PO9J82ZTMaVhHMKFanDATRgXuyqiE53lFIIZ1AAXW28aZO/2iSlMD7n3CK70eM7D9nsulsCGAAXRNkqzNH1XpMKwXyPAqRcOJwO7O8PdJvN4vC6aver0+8e6FxNIuKcTXur+HKzZdZcvkxeebiXy2qVmFX29CexAn+cLf/7t77n7ZOk6npwflpasklRgKrAdYODpaZzxXioNx9C1FnhFFxYNkcdYUhSCC60gwYKxcFxnEgfv+Buf2C72dpnurOJO8HGRNZ4woeI0pcoRUkXjKuu1Ohdzgy8Yl5UWEJ0BO/pusim78EtlFt1KpABWew8qpB2EHx7WHKacTESenVQfVx1dlr4VpwQbERkdUBd5YlcG/Tq3DjXSheATjKaZ0qBeBWZ9/eU7QVnWa56Xx6Ur167t48qT/fI+86Cplq1YGbHj+TP8Wcf+ZQvw6qZKc1IYRk+fQCDc3QhIFFISTGsOReiBSRprvJWjatGtjrhJyjTQyvjW6AqYsoCUtEudnEoPY6r/JLUE9H77bTRULIqHNeFNoimwmZUhsTgJlbCNSOvGVhlnPBeMUUVh+gs6NLIXa218zWa1zKpXpMgOSt7RjbQftcZUftiuJ2V3JVQv0qKGX0D5EuxUZseMzqZpaxfRVPIc9JmiYPy/w3b+oGPyeTPtuy2bOSDaxJXlpncTml0KoZTt9GRpsTQB21iM8xm+1yzN87VvEDVL255XawJ3TiwFbNayBk6b/34zjR+zUBZFhV0NDA5Eb1rTiVrHQvNyK8bwUII2hAVIz4G5SlN/rXb6s3AY533IThyBhedya9x/6aZ/f6OOWcub270WKE2ZUnTr+vhA07EppE6y0yfZ8LWFS39Xr98y46uz3M5+aZsVub+gVC+LgU89rbHZFeWK/qpruaQrpJO1X7VqlTXbYjdSJoM85wSfT8QYoRUaiRizdZlcSZt0pFbbYCYDFY5Ct7jYyQfT8qN7mEiE2My3U97TjSzWAxSIEhJuBjbPV0j4Zx1+y/yagmw4JtNqR3vPqh/Iw58MG5iUTpI/dslSKp6nBasB3DCPCf29/eI8wxGwq/nor6USZ9VBCr8oD5d9rzhqE44iFVNlmOL1Gw27X7V5Ee9ppqxfU1iKy6lbujZ+uxy6/kGW/mfAX//jTL12RzUh6dgJ+ect3nbywNc8RIh6EObi5LzgyOYk9dKISxOojpjlZ5qyRUGcaRcKKLUUYK3aKNpCyuF1b1wbZNKWTXAoBimWiJ1teFknYGyqMZZZ14I3sbvmbAZts85r12oVCO/pPpr6r2sMC6xZmitXLbcxmYmaGCFeln1123P15bGrb+dZQnnObHMPzeEiFQs1Ge9v59P2R255Ov8Ff7lz/XXP9lVcXgLNsqMqyyOuw8el13LJul9t+jYL8YNtHt+uZOuzWKuq+rpiovKosFE7Sq1tCmNCtmenYo/SkVwoiOA9eHWWT7N2BtOuSrOOm2tNpkoebWnlNV52uk1I19lN9QJbjT5FYQ5J8ZptuAqIvVjGo/eOsukv6yGn7ZXKosVblEN+flzj+HUg0X6xZ5nac+JyvTrFD8P18+S7D68Eq3y2+Qk+x68J0TLLIo26w19bPjPGgDJsvP6WSsapbMjuiXJ4r23DIw5Gl5xnZrpdzWmao6CmtDSSNhrMFUN5lIapWVD6whRV5v7Vo1/PnjLoquj0hzC2vhV25gr7EAxaFQow2k8cZwmfNdZ40pl8aiNprX9ZrXfNrFinUlt+sLV9Is727O1UwYsf99YCwza8mn3+2cmu1qf8RUtmWXznAvEEMlOewTmlHBOIXTFMoB1j0XWmuX853qUZtmcUzo/4/9sWNKcGUcxViCjqdJPbzaAmrBwFb/tDbpVAzffHFD9Wnh3nclpTZZ57xUSYs5gfb05fA0iY9AVloty6DMnCCklDocDpWS9xqa+ZVXuX3k7ZssqJMEBkrPq+EcczXrtbrWxjnoNK+fULb7Ym6qwn19uRxzffus7PpeDCqYXvOI92vg4qRFHMeyE6ISOJFAwqp/Yyq3iSnuYdRv8mactUIEmKlIOUhFAZ4077whG8mz3i2phSymN8sojZ1MgmrJ055F8vaaWgTJMX238cIbtgpqNs0ijgvgbbm4xB3NKhJK19GY1hMotVsc4Fkorv7UO07dtvqyEohoK9FrySqDrs7vg/hYnpf3wmb3W1+//2X0CDuz4Tf/nPuMHfnGrGral2aFqPptvX+sA6/D2QURZldESWPmmYJbsiRqlGhoUsKZd/dw5Jevu9K3BqA5+Oss2mJF3JZMsq7k0zawM/Jlz6hoWSp3UoJkoq5OuGxe0EhAWhRv0qK0caYo055n7w54isNld0KijgJqrqpLuqsAVpVpj2RFqF2pZYsr2vUKialmpBVZupWjNe3Znn7pkOT5dAF6Xh7q+7LLblpx/CTo8oh+CNcZNlJSVaBxPjH3DSy/Jg+XDHIvstc9fovzWYOVwSBEdUjELoYsE79rI5GKOXnVQc1mwb1Wvtqagajwtm69G3zenoDqnzhIOlcqnkClkfKivq+4XZ8/YGfSgEooLU5o5HA767M2zVhw8hlWtDSqO5exc05W1sbRVsFpWauU82TWvnTDnvSUiqjNUPYGyEjz3SHDwhvUZZPeRt/2U17l9ratYtjLGjtknckqkWSFVXT9olcn2xq/gF+cDZs6Ps9YBFaZXfQiFvhVOp5lOdCpZzWyHeu+d6Wobfe19wIdIKb7x/De2iVD1pSaqGnRqBdmqDnJz8hwrua2wLj3jCh9YPMVKv6Z2aZ6nlmxqrCj1T6i+o9kbEeMl1gddig46qFh+oHHJs/q7lrSx/VvGnlriTDRAXBqtl/N/qwx/BrktbLnnT7/lQz6ng+rrNUsxbERW8n1Tgh4dXajpaH2Yx9PM5nIgdr2W32uEYQ4oTmlGSm08syxNnbPscGQj509pbo6kc6IGtkW8JphkdLx9xotA8S0SWj9AwEo5+lZmijESuqhleVkUVfPrnOEQK5DYgzGaUQjGw5Y5HO6ZcqIfNuocxEjlhNRMVGkRTT03rHHMmSVqZTgW/2G9zl5rktBckrP3nSu1Gh25115bH+X1Vx5fJzzfZPcp7/opLBWKZbBIrb5JbVyopPRF6b+OI5J1RGSaMzF0BB/bw6vzthfnyhD56D1b5KrYsWtpvWRRDkoRnFOcXfUSKrWYRvO5ZRxLJdCvgRWLQ+qo+GnFTmtTYDCFqFY29AEXdBZ6zrkZDL8auCJgypcl4veeLMJxHJnmmTmX1TNjnHp21h7XJpusm2U0cy+tnHTW3NgM/Po2GW9yrTTIis/wNTluvcGr13+WZHfJeJy9VPt1fKXq8QTf0fc9Yz4xzwlE2SdCjFbKXDWanAXCK71mPxd0uhfUbE4iZw16JcM8Jm3QCoq3W2cPSzGZL5VUPeBdtKpYqA+dfXdLFspr93OoHftmKLVUKgrtVuipPrsBWqkJlvKtaJY02nhu5yDlxO3tK0QKu02vMZiIjR6mBacIqyY/y6wKSKq4SHWUVO58G8ZTJ7lmCwS998qYYVMBy+J7tM95XCo/v+x+GZfqJnX4ve1xKZlpmhiGLfOswVRKiXGc2Q5bRsl6f3FadS1oCbvpaZAzTaCrYpTxSj22JG/skSmZMo6ErDY9mHNZP6+4gLhsTloghI6SAw7lsnVgOnbNLKDOrPoKS4ClY0/Nb4heG6I6dfhq8OUfBj7Vd6k32ijJvFdfp4vR+F6lNVGrj+Na4O6cXqfSYSlPe5Gi/S1SByiUJveLk6hyvWSGvcEJ7ZxYe6aPrc8vt7c84z93/923vudzZ1DXyq4S4IJrqfUs+osQOpxLzHMi+Eu6rjc8hkcL7gtSAqTRfkCNBozKJxe8F2IMjKeJJFlvvni23bZNulmSDDbZvNSsmZXZ8VpCfDSDWiOb2plnAuY7nIdUZlKetXs0OoXFuMVYaomAdgY4x/14Qk4n+v5EZ8S79W90uo7557gFx1dEM7iyYLtCiIpr8YHgI7Wr/AwjZXyZ1YmCGkFl3CMzfv6gV+YD7uTfA/5HP/FjfeYl6qjVsrg2iyicRJezCBpSKlxcbDj1I2maKEUYp8QwbDgejM4GVZYpa3SrHfVOMT5UeXCtq7KWfSqeT0SQaSldD0NPxWA3uiCDbCg+Sr3IGAOSMohvTrA3+fVmEKs8L2MXjf7G6Zd4LZ376BT39DDacSsIgZFie6eZj/v7PVipVYErWTPAOOvWrpmlAmKYLXFQRxS6xcn2LrbEUi3vV5hKtOyE/ruAN2zWY7eWT1eCn3V9+WT3sVB0CYMEw/VlbWDquoHTYWSaEjkLzkf6fqvOURG8OKJXcnDIZ46pfnDNsmimJfpopctzWMXxeGSaPd3QEaWjUkAt4XNEmBt1VYwdOXu8ExtlaqX6Rsuzck5DTTosz41rjCoaaDljmKjB2nnDqWvXEbuoPKneU0phHEcu2rNWLHMEkCzh4vCiTrSU3ErSbSY8ChuYc7bQTJ9Vi3P1+KumL8CmJOrzoG/MQHwtUfCztJxbZQtrJtNUTRFhnmdubp4y56SUYPPMnBMbm6KkOq0j1UlzDbfuVZ9gz4BzbTqSF6PYk8Du4oLLcSSlWf/WBY7TncHvnMGnaoJImVWwBmQfqoNmXzm3KpWVUC1IYZFPp8wuCgGMS8a46lGv2H4XjIliSUPSMgS1WmTZk9PxyP1+z9X1NZRCb0xClMVXEkrzZ8z5aAFnMfmtOraIYX0rbIHlFJa+ofN7qM1j2aBgNTKGN+niz7M8PVu+8tb3/BgOqj2s1XcEzV56h8/aDOIsrVRwlFyIsccNgfF0atmbGCLB+yVnJDbdwK3ySBaZVkGs+A+cNiOVSkAr2nUcp6zTQVag9uWzlylBIlWZ+oY3bbxmvgqYzXQOtRSv2SbNSKmh13/DUguiCVkd50fFVolOtpomfWhiqPkfG6W6DmdqnGiCk2t3fn3/mp/MoqmHdBYLzko38iw1/+Zbe77e9H45+7aUau3fV3T8i+69TznYF7NKqfyxmtkLzuPRTnZne1Qj9Pr+PCcwejIlTFbA+pOnV9zfvaRWA8BodFb75ry3jCF2byFQS/C+laxA5XzOQjlpBsyFGuKYwrKmwtqEpw+cV2iA2HPnpHb7rTDQFZayZCu9Kcj6PmO9WZAM9R42xxRV5IgFaLXUptmp1RmpHJQVpMFKSI7SHM+aWWp7bM+klo8WuXVGJ1WdnSLWleppOZPH8k0/i7ILvH4dNfjA47M1soli+Hzo2W523O/vtWkyZ0ou2mDhkt0LoWRM36ySAKu13AuVodj1dBm6TqmWfOdaBqaF2EUQv8hNnXHX0MZV/vTXRmdjJVN3jj0N4TxZoFWBVUZ9lYF3r0dX1V2khi7zNDOPk0JdoFUdammebDrUbIPYda0D/5yLNr4WZbZwtaJn+r7ChdbOMVIbr84hMW90Sz8t5fQpsvtlcXbrfZQieFcIzpvPUKniloa4YdgwzzNj0ibKruvIc9SkTN1/MCdrFYSsjtd+rk3GTrPp19fXOhgH1W/55ayZVWsaPZ1OZHE4Z5CCprVrgqF+bs14rqgnrZG6NqN2XWj61zcmIJNd+2qpf0xGZKmyqRBV59XbsIyse3M64b2nj9YIKVCnO7maAHiLba8Ocj2XGuxRnWxYJiqKVgzP2St4/eeV7H2q3H2K3H6FD/m33P8deDO939tppupNs6MUS3l4O4prXv8S0eozrg9213lirMDholnToBOW1MFfd//XS2np2LaJZ11yvoKg1UC7JEzjhPMDDTtRdSiuHQdzFmqXYKUqwdWoNzQsVAiVz8zOQ6SVc1tZ15zRs47O1eZXfVpvfAZyntkOvTkyFvHYT+tSPLW8W3Ij21UM31KyFzvmeRH//O4t71uaA6pH4izqen09fE3aXr5tqVFKjPLxW9/3Ra1cMiIZ52zsoKtyVOfUmyEGioaeRseRNQhKiZIy87x0ma5B/+qI2Y/1HlTD72iNLB7OnMgKoK8lF58SwdXGwYWPUf+yOndVXtfYLmd+a5XfRYk2An9YIADVUag+cGWNONNx5jiiD1DOhZwSJScEFNOoIXlzYut7pUmyWzJUZtRxbikxtYdTzjCQrWHAqBLWzpJtzpkddz/DsluDmgWTW/Wg6SdZAvucNZDqh4HQdaSclYGiFDXKWfHSlR90yRw+WLVUT9VljhA6ht5RdpmcslLoTCeEopQ6NvK5NsE6MMjXym7YB7Z7Vp/DMwyqX+H5Vl+u6uEa4LnXvpYGDWfFEn3WSs5M48Q0jgx+o05k/bu14bQE5+sisrZJ5tSXRZeud7HJ9LqaJcuetE9pQWrV/Wd3/bXjf1bZPTvPn+Kqzo9joTQLIarzD5Zt1D0Y+p40bJjvDzjnGqzOtfFK8DbrBquAam18HfRDX50TDbRvI/0wWMk8cTqeDGalx6iP2epJ08bQmslvXyyvtb6TlV5e6+j6OS3jxOq6WJ41VvILpJRI88w8TYyxclgPq/348e6xJuMU/rVy2pqOfY0SDBrdnFBNWqW6el3rvv7KZ5dbT2HD8a3ve7uD6qRRyIiA5AIla4ncbqz3VjLHNSdNKKSUKaIzZ72PhukD7yN9NyBlZplmsigN75yW9O2FpYXFFFtYskPVcTseT+A9oavzmi0f4yyqFkCMA1LC4nF7WqnJNyO/GPqW6rYSgGgKoH21MWYsjnqL5uweKQ+kWKm0LKqp+opijmPLTKgXrGTySbkvzYkXM+pVoaphXcfpUOumItWuO/ChCdejZv3Bi+dls/Ubz769tvbc8Y/lV9/w2y92zXmmlBnvNnTB5KLdX0eoU0FagODIJTNNM30/UHJhykfjNwwE3+F9LUVz1nSmWNOl+FKrJuKWwMYFxTcDEKzsIplUMk5CjXeArJgr58D51ePuFkPveN2Yr5zTM7wnS0aqZlPFnouqoKuG1rxvdTzhdDpxOhyZThNd39PH2Dh3vdPr8ytjreN4F0dIsbQZEUfJaeHydUqQ7s2AYBmoglDBg1IE56U9Y825tuVe+8F2/2dAdheIxsopd8a8IMoUUnJqzXSgJe1hs1Foiqjejl1PLtma8pZMekv9C20MwhLUVznU43Xbjq7vyFlpeLi/JUsySIljnCakBmsOvJf2+VV/OucUUVJjDXM6WTmpMS6UPeuqlmpyy7ZimG2pz8KqKiG1aVGvYpomxvHEOE4KGSntoTW7szh0a1TZstYu5OIMGznc2f0qZv8W3SsLawDVedLnuX7a+nv94fPK7pdl6RjwWh0t+AKx2xr7jtjIUQ1Wu75jWzYcorogMUa6rsOoUAEz267lVM5WhV7U5Zw2KWcpKjFm18UC6L4biNEzu1H1jmjTpsUVtIZPt9j2h8GUVlwXW99MviW8qows1FplxZtrDutZgHVu9wVhmibmaWKaZrwfka6w6YfF0WWVwf8sEuGcYkuD9cVUHWB/2ipc5kspPLAgtfvfqh1i1Y5qg+rZwOeX25dc8J/KX+Z/8pbT/9QSf8EAtmkm5LllRxQCD9F5ghOKCxSvtDZZhHmeyCkZ3U1HztpsMXSezbBVQvSccVnwhrOTtZZcKY28coa7rmsAdO3k199PaabzvTJS2t95+7mgpcUYOkpJOBFCI+tfl5iC8Zk6ls68lZL1ixJ9436Jll+Dgy5EDis+s2DZOymyjNZcObPVOYUVLs++pnmiz8O5M4xld9fGxS9OTV3rDtSf5PpF3ud/5f7HP/HjfJY1TxlJCVcqjihQS5cajAg9A4XUGqIkZKbpxPXVNVK0izKVzGmeiUNPdAWHNfLZPTjLnNoLC1dfVWSeoR/YfGVgHEe890xp5ng6gtcgLBcBKY1WyjnFgFanrTm6YlngB7K74KYXXj4s+q2/W2NTa0l99T813G4p/4zjyPF4ZBznJnMiGK4bc7RVadcs50oyG/chOOZU6Ao6ZrU7VzvOOWJXm7dqBvVx7OlPSo6/TLIL4FZZ8PPXPZ0LOpEsRLqup++0ieLZ82ec9nukKP3U9dUFLz46fa49ywiZrBPxwqZBPaY8kfJM12tF4e7uzoJnlaeclcaveqOq2jWKU6aJpYIRLKNWm0wWvHaV1/KGs1unPNfyvLx+Oo0cD0cO9/eUku3snjYnse3nZ9kacRqgusicZi35O3d2Fs4vSZXmpLQU1H89VnU+SzbbXhTq7mM0p0gNVUmJvu/Z9AMXF8oOEnwghm4V4P54MqtNy4pdv7fSeNdpcAUQQ2DoB2Lo8P6WlBJLaqdm/GtQ6BFR7KUmsIwf3ddGqerj1fNcMxUsAwDWWcnVmeoxTO+W5vCpnszZmhJtH085c7HVHpti/kK1Y7S/e3zpvmrT3rpBde3aKk66BoXLa86vvIifkOvwLt/j3yj/NvC/feN73uqgOswYiY7Hc2uMgqV8vfcUSdqpLIG5ZvwoGr0DFxeXvDgdOU0TXbdh2GyYpj0ZR8KoQgBz41dl1CUzrtlCwbvAe195j3lWEHQBbu9uCVEFq4h2SovXkqSUQrDI1nlvxLac37DqfNYsalgUplg2IYRo+NlAnfqjQVZNCyxfNcqueBfFgDhKUPxsveCGI3RwPoLMIkIfcE6JsoOPOvECjejW2MGK3aoUQo8/3A95zOTsW72nj0vBw/ed692aOf861/xt99f5rUc+5Qtfhn+soznX5XHNciqeOMYOnDb+4AtdjHRdZLvdkNLMuN9TSmYzbIheIBiwfikXtLWOrcCqgrWpKAjbzZZhuwHnOBwPJMnETrFB+/0985zJBj3xCM44htdBkk4iMaVY6XosWxC7xVltDmXBnHP90uzTg1JjE6b6v0r8LszTzPFwoORC33VUeIo4dcR9WPZ1/Uytl8PThR4RyCmv3mPZJlllGni9S3f5nAc7/DMqu489vxqwZu0y7nq23YbiRpwRmJdS2G023FxfWcXAs+23HPvtyph9tmNrqVZ1+DhPjNNM10Vi11GSThPb9Ft8DMTwgpyyJQ+tdFAHMXgdFZyzx3tpRl5Lo6sG1bPn0y+yyrx6/aFsLfpS6Z3qcdUG1AAf+3lOSekOBcve12s1AXirQ1SjQ4/3XTtPXdrMl+vs5IcZJPf6JzXDtmz6G47JZ5Jd3fWffALiM61ikLacIQshJW3OE2f489yoyGKMXF9dQkkko5lTKiiD8rEAh0yyWjLHe6/d7ivnqlYUU0pM04SIsL3YUccCK/5Y2Gw27Pd7aga+DQ+piSgLnFxZ4051v+vkJ7+WSapuck2XrpuvoTqGFkS1+yaWFKjBlSdlDe7q31cIT/0MdW5tX5pzXCsD9Xt1kCtUrLJyRGXasP4zXxkBRAxbrn8fglb01sK2TjysyjqPCMBnl9sXXPAf8hf4194iTm8v8Zei2SVRb94ZB1TdqJql0W5bbZiKoY7R0xsbQ6DvB25fBuVEFTFcihlGm+qgpaqw4sxb7UfdcDRr2vc9/aDjy3LJ3B/vGTaDpsjnWZ1XmwftLOXf8KulloyKdo+2sqjOgQ7hvExaI2HHUkLS70sG6gx4Dw3OVUox5a1zoUPMIJft+s4xzovide37UubzPi6lY6qTce4d6QMU3qCqPrsCe81AvuYxnGcINYoQnvIJ/6r8v4C/9ZmP9ZNatUFHSmmKopXcqrw5c+h9VGXhc9u/vu+53O0opxEpwtBvCF4DhUUlmcNb/aWWtawvuppiRcfQzguNkuF6hmGLD57j8WS8d2Lyo5QhVDq1hsWTBbS/MrJrma34RWFVfmzLPfiCh/ez/n8cJ5XfosTRSh1nSvLMJMpKMbuzzwJzkmtZtwV9Vlozg9CqCM3R/XwG92dFdqEqcksCFKteIQSp8AhvkItsHbeOi93OYFgAbiWv+u+Hu9qSA6uua7CGIqfUQGlWurztbkfOWTv8vRr84AOVJ8WJVZAqnHh1Da79o2ZJ2z81JFo7qG9wFhvG0Z1Lav0gNf4eXHUYaTaq5NLe61YHFlzbq8XoQzPcrN+vX0o4X+2zmEwrnEdpfn68+13X55Xdz/us/EGv2hBVz7NIYc4JyQknwaAnhXmetbpqNI7H+5Hj6URE6C1Tv4bxna0zVXbuJyC1cU8bjXLO5Ls9OVsALGKy5ldJosWpXK+WEKiJKGcVAAuwdHiLNR+586TA4ies7c5yvPV9dq3jevmbGDpi7Oxz8llixdUs9Cq3pQ7g41nnivuu/5qmuVWKH+5p6yl4dNXw4JFjfE65vWDmL/HiDcfT9XYHtUWiGSnZyjd6oHX5u+J7PFrWFgMcBa8k0pvNwNAPzXPT1ztzwPSiX2s0WRs4oTmASrKMYqC8w2U13sNmQ+3aP3GkFFVUTsSa5Cq3XqXpWWH23GLglwap5Rpzqjd/+VqcyHOF1qIcwRz7YvQaEyUHdYyq4nttv+szV50AwwqKa5N/hMXAt9UU5aLEH11nr7uzb59prd575pjZa5ec+Kvy7R/jA39ySx3UpB2lVV5rKaaozOp0T6fOv6fhdEspSgm23TJvDiCFLg4Ey8rDAz1p36Uqg0ce0OqgyjTRD71mGMTRd93SXWnGsiry5rD5SpF2LqvNWXVu5axW2a0ZnsVQty/OlUoLxOozbVc0T6k5kcWcfYTWZ/i6Xn9EmCoTQVPMrj3PrirsdTBo+uA1ET5TCT/bsiuy4pR1S3NdkYB3CldylMbwkbLKOiL0fUeatHqVUm7OXPUPHz2eW+ShubIWNEhRaqDD8YiIBSoxGNReCD6SKl0etICsOgvO1XqSnMugq3C48+s8y6Q+OOEqu1R5Yi3DK2qKpt+18fXMkV1d5Vl+aGV717zTGiP6pumdd6SklIdrx6ZVBFhnu9603B+o7D54y09tlVLwcXGmshRcSVCSWngxAvo0Mc+TwpkQ5jRxGk/03tM5Lcmf7d+jF/eGPbRbV/XJ6XikNkfVSXVVAS176VqKr+RMTglKsVK+b7Iaqu6tjdUt0eDP5PUhBMs9kDvnlCLrxYsXhNgzDBuGza4F98HwuEDD0urzuOTKNfv6MMn1YIeq/Vgdd5rnNrCgNiBWft/HKKfON5bVM/QZ1qfIreDIDyA3D9dbHdRKrSGS1VFNCSrFQQXNinLxOa+ciSEENi5aQ4o6oEPfc311RR6POIHgI7vtTgltXY1GHbR5tOdXWNWJGEv1aTzh52A8d2rUN8NG31WEe/a6CXXElQMoLSug2dBFYaowqX5bMHzaOapym86U64O9txvgmmKrhjivMkW5FNKcyCnrVZpOLNhEIaogLda/0p/Uo/kQW2a2Og4L5EIptxYl/lmWZXzXiv5htMPiiKzf9fomOI68w2+Fv/mZj/6TXDlnclaZ0k7LAM6oyMyA5iz4SMuQiKgiS4aRGvqeq6vLGibg8QQXW5BRd25xUGFRnKsQxj4/p8zt7S3b7db+QEmsRSC4QCAo3tqqBc4tf98cbJu/vlCf1PfRHHFqBA+s8XoOLZ4unu+ib9Qp0ki+Gt4KbwGveqCUpiQXcD9og4ruQJXLddRcO7CrI5pSwvt+cXItS1yos7fPd/Tx9bMru0CTocVBTRTxFAngZyQqM4oGM4lpnsh5Bg9ZMnnKHE/HhfmjeahvNvxnwYv9ndLdqcN7d3eHc46uMx5msa5sTdUb1RrK12hQLYciiY0gS3H4oXZE1wBxNTay6l5vz+ynaDPvPXNS3Kv3ixZVbO5gEJ56fSxyas907XtoEvdIJqo5GXYvToYj7zpaIOjDAoup/MhvXn+wsvtlWTnPilUWTG4SgUSRpMMbROVqnhPH05GcEzFoc+rpdKT4SOffLqPLktfeV+9bjLFVXE+nE04ch+OpZb7znIzOzp4NKeajCqfxyOHQMXgNvoJTnelZkhN4Zf2pNGgteeWWAOthf0C9lGqz9/cH/vP/4h9weXnFz3/1q/zSL/1xdt2OUrSxvO97UsqEUPAxgAel5q+2XxMqsmoMPNsdYXGaq/3wgWlOhDBrRdegjPX9uqvVSTX7Juf/RuRsstfvR25/6C75P4a/xt9+0y3mUxzUnGcz3IWSEl7ysumgUwpAcSdJM5WhC+ADWcSi+BlEeP7khsMh0MeId54hbpR30rIF5a0PtCkXr7yMZU5NWfZDr1Gu8djVjs8lGMhtc5xXBSmSzekIzTn1jgVm3zJQNRo8f2g8Vhbyi/MhYCDtmigWEM/Tp8+4v9eHMa8mlRgJJ+IME3UOuUfMcVEarGDiIUxzMkyYYqEqfU+0bPVCTfTFrwOFf8r8Uzv+erUmM6rDZh3AFomUUijMzMmCHBeoDY3jONLFSBg6XHCM44kueFwXwcXFkD9y3Kok11jt6kEWhFQyd/s9jkWRlqwDGTzOsmIYbMawVZKppcoli7o4p/XfOFrp9UxeRUcCh7MAS9QB8J4CnE4HzRBHR4hqZC4vrzgcTraXYZl2ZY4oXsgIAcVBVqe6Bmq16uHt3EW0Wer2bs+zp09olHHmFOjY5GzMALVJ6u164Q9qfZlk97ElQCbjJCF5QlKd3OdwpZDmmVd3d0SEnGYohbv7PZ1bqG5+nNC1mF7GYXyPneL2nMePI93xQB87JGUaxNUpvVDAQS6kceL+bk/vMt4audbZqBh1wEQIBkOQpe5fqDK+zrqeJwlyLry83fMf/Uf/b7a7Hb/4S3+MP/dn/zyxUzhU1/dsNgPzbPoy1ExRwbmiGT3T+7zB0NedA8yBjozzTNf15oisyPxt7HeRtFj8/xotbabOIKVB5jQRZMNCRO3YPM04hDSNSkMnif040/lArU+taeYek9tiAXWFBIp3OjwnOja7LTt/qffFBw6HgwUxozqolfPTdKYg9N5TcuLFRx8xvXrJ5dDz1a+8q3JbR9fWZlBLdrRR1y0LqWvJpJ7La0D54X/wwQ/5d//d/wMfv3jBZrvjl//0r/A3/vq/zF/7a39N6Ti99ryoQ230W2br/bpv9IGPfv6LygVu3ovAdtjw7jvvMKfEPE8MpfLEn3+MK8X8EuUS5w0Nq7/f9Styw/+Dv/HW93yKg5q1k3IN0nWVSsKKGXbTckmUPEMKeCPTB0dKOt6ss+7NkhPjBJ113C34isK6G+7hWj/uWdQpS7N+dj1XASQrQfDKU1QhTCBzwhUh4InOq0Nqx69ZKamK0aKiNZ9dcJ7OB6JNBTJqcVIp3N7d8Zu/+U/5ys/9PM+fv8vV1Q0IhK4jhDpTN6gDXw28ZRheS5ubYa8CFnzNe3lrkHLMKTPEBUTtzBCVkigSbfQkmtlofBr8gQXcj5WXOuD98tNzkNcrhEDX9Ta9Kza4SstoipDyjPeRkD1YI2CxMuY0TyhtkjDlpJE4PVsZaB2a0LImxTIz5jKcZberkooxst1uub+/N1wU7O/u6WIgzwkRVUCSNVvrxNl4yZmySfQeYrCI3nuijc9TQx6aHNUJI6U2EbS50YHKDoD9/ng88PXf+Qa/+o/+Mc/ffY9f+qU/xp/6U3+a7faCXATvtMu6FMdmM7RgzHFenVjW689w4wpEnfKbmyfMk/HJFJ1YouTVCzcflr3zRafItDnK8PuW4S+77Na1VJY0CKEI4jK4jNg9lKIT89KccJwY00zJCUpmOh55enNDbRb6cZevZcwQ2V5c4FzQrGwujOMMguEJrfEtOEKA4ARHZjze88H3vsPNxZbnT5/ifa+y6xTrj01LcX4xkYs9WIK8Vo4U/RMclFT48IMP+b/++/8+3/v+D9ldXvKjDz8Ccfylv/RXmOdkelHlXiumDjFmDOOBacd9qwmuWTHn6fued995h5cvXpLTzNB3psdX+HY7bxGd/EZZ9Sz8PtdjsvtlcYXznOmi0ffFaHhkb5l0xSanJJATclKMvcIHExGP7/sHZPFvXxoQuwVq5GhjTB0awD958oRpmnjy5Bm73RaP8MEPf8jIEdCMarDhJZQZsrJXnNLIq0+iMmQEr9P3GjVaoFaQFyiVLYvWikHLOh+Izreq3e/93rf4R7/6j/jggx+w2V4Q+46PP/mEX/3VX+VP/alfZpxm5pSV1aXiXysDQgPOmnxZ0kPTDyvOVZQZRrxvuXq8Dt7otzvm/R2n08jQ9UoKlkEiTffWDn5l4yjU0au/H//hMbn9Gjv+p/Ir/MO3/N3bHdRU6Do9YY8juK5hHBX/UOmYzGDnzJy1ay9l3UwflK7HEY08veiEmLWD2i7CNmRhPl1yiqtoJIRA7DpyLkzTRPCB0zgSnNMIbsXT2HJJUtjf3dH7Qh+DThdpEb05qpX8vEU96yS1OQXWzT+XCQRO08hHH3/Mf/b3/z4f/PADvvoLf4Q//sf/JL/8y7/CZthRidIb3jXUDlmoOBj1gde3cJ1Wr4GBZnU3w4ZhGBhPow6jzLnd/doNLSWDGXZ1VoyNeiXAuOXnc5l7KIGfnXhXOJH53be+74taIapjVcfPZaNGqhNplD5NJ8MUc0yKKDdezhr4SMlITsotOc94J2iTG8wptW7UdgPaVDF9yZlMLU5i4PLympyF8TSqc1EDCREjArdgyJqgSs7c7/dsKFzvemLfaUnc0br4m4y1kmi9x67VWxxrjJS+ZxxHfvTDD/hP/t5/wg8/+BFPP/qY43Ekxp4/+2f+YsOl1jLQQkVSS6QVB6XveyghepjKRqHf+65nt7vgxSef6JvEMOzVylQDL/b3FsjV77La27rVqyM+OIM/nLJ7tiwjrQ6agJN2D4y9SYP1bH0C8wQ54aRQvEdWXcCfdqCl5Fz1oNLzKO1e5PJKeXuDD2y3O7bbDfvbOyocYF2dFcnkNDMeC4eSudooH3Hsev19nU2+0m1Li8YCNagVg+iDJTUKDnjx4hO+/vXf5rd/+7dxIUIIfPDBB3zta7/Nn//zf0Gfz1xY458tkV9TK8u5AkrpVmE0+mKpfMT1/aLDPLa7C+4PB0pKzFMy17OZ9JZgWJIkQhs9J+tM24MbfbY+u+wuP/0BZR8+5+q3OzaXW6RkptOJUAd6WArPIcTgSWnWKYnGsCLGrZ4rX62t5hQB6+urMtJcQ6tQqT0Ndp/14YhRM6Ch6+j6gWC6qupdTSbUT1WH2YsjOk+aZ8bjidgFYr+qUK2y+lU/rv2TCm1spX7nmy69ffWS733nu0p7tRno+45cEi9fvmC/35Nz0klSyXwlX7WtfRdo1JQCUCiuXok5wrj2fW0Kgg1D6IaBru8Zp5mAWIO63qdsOtZUt92PYsNZxPZ4LWefX24de7ryj4H/1hvf91YHVZ2xAF4vInpspizt4l2lJLGspssJFzPZ6BJSzozTCJKVQy5nknPk4JdIsx1Rh3+edyaulFXNRHWRjWwRUQB/NiA/JuANV+RWAiiFV69ecDn0hN0AXR19uYCfK4ZED6vKcYlKXJtsEkIgJS0V393e8fWvf52/9x//Pfp+yycvbskZ3n33fb7y/tacTzTa8rJgPihtGxdE1Jrayp5Ow/pVRb3ZbNgMG+73e0avGeMaxdURsGrwbW67+DPl+Fl02BuJd1frsZc7Zt7ho08/wBewQvBWPlScTRbFTzZD5eojX+lojKTejNA0TeQEZZ6RNDPlwhBjE9YpGV0K9f6cL+dWwY73mgUPHcPQkZMAe6bxROw6y/JWuIzJrfeqbkrmeL/ndp7o5ZLIlhitg98mVDlfs6NLN2g19i3JqWeF+rX6nvv9nm//3rf4h//gH3L95ClTUpkZ+i1/9s/8RZ0cV//O1eY7WWTX1vppXQedtTy3VtwxdgzDhoLCVZw5HOpc66dXw9TM0drg6+Y+ihWsx1/uweOy8WWXXWDZN/u3954gZcWbSNNxNeufS6HMExTLTnmvzW3yZgDVGRSlfijO9E4NqD3eRTbbDd3hqJWA3SWXlzs+jD+CaaKVAmvELQUpCbJjsoEPw9DRbzojX3fLhLNVUNWcVMtYevsevKeLHXMa8QKvXrzg27/3LU7HAzfP3iF2kcPxwHe/+23lL07JmseKZZlqDHSeTW6GHGcOqmsOp7nd1CEpBdUNXT+w2e4YDwfyNKvttuRG1SpnWWApOpZSFFZwvt+P3IvHf93uzpd1Dbsdm4sdaRqZ55ko1ofRpm/B0HU4FIbSqiUG83nI/Y3IUglcr2qT1/YdmhNYHakWnISFR1obtWrvR3Uspe29E8E7YTv0DF3PPE2kuQeGM/uh6t03OdXlmhOr/zR8tVsYItI0cbw/cLm7YBh6YhfBwZQmbm9f4byyHc1ZKwDBnOlGGyWLPlzgZIteqNqhJk7OIAZmC4dhYN5tGQ9H0pQUQuAX1pfq8FcMurMkQh3nzQOd8XnlduDIH+UbbxYoPsVBfe+99wjRM84nxtOBoVP8KF6dHhcMvBuUjiQza6NH1hm3UpST7Hg8kkdHmkYkZxClk6ib/TDCb05dvawHfI99jGy3ka7fgHgOhwNDt6GPgbF+lFhpCCM/B25fvcINA7Fc0nvP0HfWpGXjwFzAu0jLNroaESv2SMSTiyqpGBVr+4Pvf59//Ku/yn6/5/nzHff3B374ww/45je/xTvv/BzjPCvliTmpPoalJPFI1Ftd9poZwbBgGoRqKcnHSOx7DocTQTRbWAqkoqU/Z5Rf3poWik3lWR/BnR9Q16PS5R5535mObwHsV7nkf+7/2iOf8dNZZ52KIgaB0BMPlsnGSqZulW1MJSNzIUkhjSfISRXFG0vAKwW1CC917zQ4iUZh5bi6ucIFz92d5/rqhqHvuL8/cDqeyOioP+cUlexFkCkxzYnbPEPSxoKLy0E/3oNrXKShyaxWBpbyUy1RxqCPfCmFH3z/B/zGb/ymBj2bLX03sN8f+N3f/aZCG1JiSok5FWpB4aFprz/pVVf6qYV/z/vQ3tmSSd4xbLcc9nvIhYDDxXVwKEZ8jkF2Mq6YcqwOkHtECF9bfzhlt2beawdvq76wTOpxkmgVkiykeaKkTEA0e2qbrdAWeU3HAmf70hx+jRb0PKwZBDxJtLLlfdRmzeCRivfHnDKWjIsTdfSCh+gckzktiv9UzKlztbrklmPrkTVQtxcqxjqEwJxsjHEp9MHz7vN3iJuB0Ecd2lK0P2GaE6dp5DiNeMNWLxN0lgzUWaOpbcqSIDDbVH1o20/fdfT9AEWY0WEFm80GfePC6SsUpWas8xBrFmrxqOoNf0wKXrtHb5Jdc0Ue+YwvdmlApZnxvusgesYpaSYf1U83NzfKD348MI4n5mkiF01wLb6A7vNsSYDHliYGFoew0ULWbLwFFU2WUczynDPjnBCpdJPVscsKP5FC5x1PnlzzlXff50cvPqKUBHXy4KrS6Zyj813zFfQe1wqztE7/ek3BOS62O54/e8bt/p5hGMhenedE4Yc//CHvvv9z5Jz1WXHgY7dMpHpAm7LmyNbzWX6nz7xtUfCId4rDNnzrZtgSnedHdx9wES80iBC/ehZq8kYDTS8d60rWmR4+l4L652cvPSa3e97jn/BvvlWm3uqg1kaMzjuIkT5aOtvOsR41hIDLovUme807yKLl0sPhwH4aLbLX2ejdrnYyP35sFbBybmQBnAGWLZvonz1nmgsXV1fmRAh1hlnbYCdIKqRZuLfyV3DC1c0l3rKa1fkFdcDbqLMQWLr4PYpUCiqopjiHfuDdd95ns9nQdZH7+3u+9a1v8c/98/8i85wYp4Rz0Pd27qtGpipkhWKQBJ1WpJmEoq6q84sRiIFu2LDbXSJzZjyd1KH2muWomFQpQiFrB2DJGkVUj+YntP4ZO/4Of57/4id2hB9v1eh6/Qw5U2g6dSkvD5wox5wD5nFkzEo1EgAvylwhZRXdU5vq3GttaWfGvjl1uvcZNMgpaDBkOKEshWxlfs0AVPJoCOLZDgMX2y3BOaZxqhdIxUOp7Cpfrl6nGuTirCqBvq9RrVC42G74uXff4+fe/4piDWPEBweuMI4jORXGcWKcJroYKPQtgDp3VbPmVI1w2gYDU1xtANSMhdiM2BAjfT/Q3QRevXjJ3f09T548QcQxz0pjpMYqa8WmFMSVcxTMH/D60snuWdY5stlsCQVSEVJpNpFt3xtnItzv7yjTTElOEwFUTtXPsHEiyzjkliWqqSKHK2iToBfVp6JjGYtUSJbJH5lgYz5rw9Rf/ct/mWmaSGJUZc5pF3TrjtfAKljw5LyzQF7UhuDAKxY2hI4s2Rxwz7Onzygew9spJv/FixekomXSeZ4VQ2hDUooAUrSh1D1u5KsxFRHrdxDVr13UjFdKDMPAZrdjHEd+71vf4ud+/uc1k1UyKSVzgGVVqREkz2ZPljj2Z2mleeJ0FMMYa6Kn6wIFr7oNxeH3fUfXBcK958Xx1GAbqoqXwKDSRtZVK4Xr4EVxySsYkWDNy1AziKXULv3KwVp0DKrTJJqXQnSKQyclhrDjT/2xX+T95+/x9J0nHKYjU0lnMrLOTC6l/CpHnuIgiZBKQdN1jpyFlDSrv91uCV3fYDqkwgcffsjTd94lizRUf6XTXIIaVuehNgnv2v7VLL2IOuMFfZ4qO5EU5f7e7naEq2u+/rXfZhgGqPq5fq451bUEV0rSvgin+phVz8PnXZd8j7/i/m3gX3rje97qoGqZJINkm1YkKF2TZkVqNqpyMtZO49qE4b1SS0zziMu5ISSKRfWVBLdGzI8O3T3LMtZSY2gMUgI2hk+Ftoh2RXtL9DoRPNbs4T3vPntH0/dDtE2PStVQucxqw8mqhFAoJFFlKSj5taCKKCe91svLSxOCyDzN3N7eqjMAbaJWEJtyItrtWq/s9eyGnP9kUZA6APpADsPA9t13+d1vfINSVOBxmt2tnf21RJLTrFgcQusOfyR529ZjpdPPsnaM/AW+9bn+9ieyLGutCqTCOBwuOGIX6CUwZ2g5CO/Y9YORk0+keYZcEK1TmR/78F7VrJ9+rxlE/c1S3namtFU2PS6o85iBOWXUjzA1I6o0gygdGSXz7MkNf+TnvoILMJfZjrEmv1cHkdUxm+9dP9o7nIs4N4N4ctLu791mg3hHdjrGdZ5mxlEzXslkqeAbZZEYVdeCxFGFVozKrYbMNXvnvOgQjBgaI0Xf93TDFbe3e46HI0+fPIEaUIoFZKUQfM2uaDOF8oK9Ocj6mZFdoWHeQwia4XaBLDDnYo6qmPM6ELtIDJ67l68YU7Z9XyjpHl2m35pMW0akOafUQKuZP4pog5H3npSS2gBH6+Goruo2dlwNPRd9x1feeYcQA3fHe14d7hD7ezWk1cirzl3yXfpV9JeI0yqRiGJxJWtGrIsdxQkJqL746XRiHie9duea7LeysTs38uf7blnO9T+da05QiLGdvwdk1melIkvXAayosUPxrZk86aQ6KaaH4rn5/byy+2VZkhOSIxm1PZt+Q+g881wQy4amrBjPnBXvL04oUnsAsvI/n6X29dvaGWzOU20iYjFl3lhJ2p+LGOf08nMpecmcSgvf+aWf+yr5sOd60/P8+gonhavtVoOy8Wh45NXXykldL++DVjHtXFMWOr8EZd4Ftt0GHyOTFJ2iJXCx2SoNZSnLMbyxpzQlLi3z/yADYht1dvGWkHEtYSGITdgUToeDNjjWZ4FzmAU2BdE7YRpPyDi2Ee3D7oLQdS0L/XnWli1/2v3KW9/zVgd1miZit2ShQgggmsLXRKV2PsfY0QmQPULQBiWg6zqCj0zRkY4nJCV1UR8Y+qYQ32T7q+JyS7SSizVMOG/dbLSmE6lKt5jb6hYh/MpX3udqt8VJZmLSLKhbSsFnU6JQ5XZu6GumSFrJ0jvPbrtVZ9akaZ5mi1gK2YyF6quFrAekKcDH1tohcnWiUHN2Ap33miGoxkSWDJ9yVupcs5Qy+IC37EXoB8uWuE+N4usteXiK63/Xc7zgnj9Xfv3tH/gFrlWL3RL1VoC71+EOfi4U540qRIdKeO+Y557pdGI6HnX/LCJ/U8NJU5wP9sm7SlRu2KS88HzWzEG28cAarTjlCi4QrTwaBd59+pR3nz3DR8cpT+yne5p2XilN156W5er1mYDaFqAyql38ORc2/YbsNDM35WxKC9I8GzuGMye4VjZWBlh/ajIs1QGglpatOc25ZYoWtEkslKK0SOYXuPbBq1xtKSCJLCjGPXTGDfh25fiHVXbXztMy0a4oTMQbrCoVcpkX6JMPhNg10u1iOOG30/ctBvYcni7GE1kzM/r/po/EXrEmFxMPnbuOOqg3Fxe8e33FzsG2i4S+Yy4zp9QzSR1h2s6C2hBVX1mSEa5dU7LuZi9GGYfjYrNlLoWpJGYpeIEudkzTfWN2cdZf0BL/Dx1UWZ6g2m1dHfeaYa1l5GAZ0JqNKim1ATY1r6f+bYUKaGlWsnCaJmbRngEfIv12pxnVR5zlH0d2cStc8k9xBQeSsyWPhBIL4hcMZRFRCr+uWwIn6w/AEkHyBnkVq3CVtjGw3FDa94r3rKvCLepbxLLa6/1yopCv9549o2x6ttGzsSZspcHS56G0YM3+qDUsrs/F+kzccqJ6TAvAXKCLPVe7S33msg5vcUXYDgNlzs1J9TE2GsDVp7WfWjgnNFtefRL1VyqjzNLkqn+gkj5Pxi60jsnMH6kMQmKZ1dPpYMGow4eOEDvFp1dC97aZbv3t4cvtXgJ4BrZ8lbettzqo4zgSuw3Vd4xRKZK0Q57WkNT1PYRAyDpLVpyn4NgMA5vNlpQH9kUYi2hXqauqYOWkmhNxLp7nEX29JT4EnVLhiuEsa7ZGozTv3Wq2tzqnfQz00fNz77/Ls5sb0jzy/Q+/j1QcV2uQMuVXNxpnGaP1o1A3wOMIxNBxub2klKzz1LNU7l8j0y6WHl/zu53frPU+yOp3+vtiyjG2sljwOl0mp0SJQZkRmuFQZYANWpjnkVwyLkS8DwxBqcCaflsO/vCHH2ttuePPlH/0uf72D3qtM5c1sMFVvlC9vs1mR4iFLFo6zUUze8PQM6dE8EE7+Bk1gwgrmV3L7vLK0tii980RV4bY3icLLtA715qtmnkWHWfZx8A2Bnbe8/6zZ1ztNsRNz0YS+w/uz8AaenlLw0l1UltVQWqjh/rI3uRcimO32So2KyXFwBahi1oJKNnw02aYFyO/YJzalVXF6EU/21glgu1/qAbe7kOZZ5tQVZkMaA1SUqoTXJAiyqs8jrjgif2GTjaEvnvEkP/hl926Wibcyum+C62SgmUfiyhkBMuaalwuiLNy9nkr9PrT256p3NbXxQzyufNfneTmtLEY/xYnmQwH53j+5Am/8P57hOmEQ4MQh9DHoAFQ++yVM7pyVB2uQbkwuzAlHffaGRY3uMDNxRVjmjlOIyeZ8DiuLy75wQ8/1MASFEd7RjGw+lFWp7Kq4K0Dfd+qMIapNqe1TusSeRga1m20YLRoIuf+fo8bT8TQ0Q8bYuyMuxoLAB9v/PvDsvoQmJImZEApyIRCytLs4Ol0WnSkM1tOZQRRWZXXVaz+0wJt9cXWPoQORjhvzlyCDPtjKsRoyYSCpbbou44nV5fETU/vlLWoSGEaR1JO6odUBiNXRcWcVDuXxUHVzL9bCwOVOcDRdz3bbtCBJdMJciFn4WLYqIM6p+bHVAjYuZ6T1eeC+iwscr3ex1WW14ewsl6qU862WMDVKYtl2beSM+PxQCpaPe83kKaR0OkgA7ee1vZjLE/Hlvff+p5PLfEXqeMUNbNYbPazo9BFpW+YjokYe2LXM2c1gtOcDGvWE3IgbTZMx5Nhh+qGSNvYJWu/MrC+3vjSOjn9OsoUlC0AKznlZN1mNN5EKZmhH/ijX/0qF9HTWeNUFz3D0DEhLUvx8Eul3RSkfRUgSaHM2vEcfGTTb7nY7ri7u2OfD4zzhEsZZpgmpTvx0RoeFjk+X/VSTfhadmJ9s2LUt1kmdJwmdW4KSDEFJ/Z70WapUmbG00Fpv5wndtqNuL26UsE6e1hfX2/6zTqQrQ/ABQf+Er/xxs/6ItdyH5fzczgbGxdISfAp43zEiVNyYklkEea8lEWnnBGb7V0km4I8v4GyOqYdaFEkq9U63O3va5e8TmtbApf6dbHZ8O7NFe9dXfHk6gLnhHE8csoT/RDJVB7fpjGXKJnFma7yXUQY50kdEB/wPtLHnndunjHNM6/2d5RxxhfharMlTUlnN/eRru8XiHnLLLEoQXu9Ks66Q1Up1+yT94ZhQpvRCmIjA11rBC8U8jwTug7JCqUZp4nTOOFi5OKyGGUbuNi/WQbe8PofCtn1Dieatcs2V7y4WRNyBKY569hI44HurFwcuoCbPTktAxDqjXqYnZKqb6Ddz7NzWJ1LKcv7pAYQUlpmsQYjeMfFbsez58955913GG9f4rtgWE6lqVLnZOE+refRMIYreWluhBSmPBFdVMMYI33s6C4uuUbL+nf39+QivHN5zW9NiTTNpJzphkGbTt0CwAn1kXFLILdmTViraedslpCoPkmlEEJgmmeOpxP9sME5r7KbVbzncQQjq6/JkzSPSle30wrcPB4JQ2cJj5X+4MeT3cfCj5/GCt5rL4ox+oxjQsikQqPkExFlZOh6HAt/s1TnytVgaCWtZ1FEfc2+r2X2YcIFzerHxqOsXwUh1DKvAAHeef6M7WbLdruhd+qkDbuersyMkzpszi3Z8zV8aznN0jDZzllwYs+dYA263hH7yIaADAO77ZarzY6Sha8+fZcf3b7SJB7GIevPk2P1J4e0IQXLc2SOKRXeVQPNoOPa6187/f3d4Z6u3yjeG0dOhWlK7G/vbNxqjws6eCKliTllQuzY+AumccR5RydbYj+Yk/rjye27XPI/kL/0hr/Q9VYHVS8aEKP7sMlRKc840TnP0UdKnikuW44pWDOJdc2lRClFhdRBdhrFJIJqCaelaKmh0YN19opo1O6l3QJwxUhxOVPCzkEIkSiO65sr/tSf/BMcb18Qh0gmM6eRIsrLVhtNagPR2qF5+PCLKKWLc8YRGAMhqON7vdnRZSjDlsurJ7hcYE44zHHw2kCyRHr1xnnD82m+d4EPLI7AuoRaRJhz5nB/wIfYmgvSXHj54parXLi4VEA6OHKemaYZHyLDZkBSouTcxgp+3qyT3ZL21x/zy/zd8H/h73zuT/sDXhZUiWk/QXDZQYaSYBxnQlQqlFwEyRrh56zNfEWErutI46Fh4XxQjrtq1NbyUWlOHA+c0VVZtL7vtcx5dSRWDt6Tp0/4+Z//Cu9cXpIdbHodDZxSQY5CiApJ8TjrNNbngXquRvCcPUhwiHdMKRG8J1ojSuh7SilcdB2d91zEARciPR6MFcKY8IxNY4EtqCoMeFljB7GAs0adWIWiGqJi2MWi7B65KK7P5mXf3e0pOTHttjx7911wxeT3xOl0YnNxieTCPGr03wePdoX/+OvLKrs1W0cpy7PvDLeXFaenDReWNS0F+r4ZfWcRkga5ZQlizlbTlOfHBrxhApFzyi9nxj6sAnp921IKB+G9995nt9vivOfi6pKTzUEX4zptGLAaz7lFl9sLC+uIWxwCKQ6CynzsO+Jm4LQ/sPGBi+2ObT/QdwO7fqPYbZvUlxFi9BT3uj5fm041QeHsOVW8Ik0fr68Xt3SQF6dQnWma2N/tOe4PvPP+88aakXPmdDoRQo/kQs6ZdDqRRNhcXOJj98jdePNay+6XZcUYiWK1oJwpZTbd6lvZ32OQhlIBR0bz6MCHGsRWvHDh9bBK11K+Vi3sHnHwPVBchcmojDnnCeI0krBkWCBw/eQpmB4qCPep4E8zp5RIoNh3oFZ/amP1+TlZwqyrbqOo/hVhMOaj0EX6zYZ8nBhipN9sudldMvjI+1fX3N7eEotCvKpPszAUPDzayjnGGzRfnf3ckA36rBXRkcXFgt1sjYy61EbWQPhHP3jBs+dP6K/V3hTRQSDa/OcoZcZ5bQaPc2KzK2wvLj+TjJzr3O/wd/nf8Xf49974/rdq9lK0S1yGntB3Na9p8AsxZabNFlIyLiTtvCwaYc/zbByQXnEfvu6X/a2vIPklki4itO4Ly76sn0QpRQmrTWqr0lDMhL1YMQgO+mFgd3nJsN3g5dKoSFb0Fe2zV+WCdSjmwOiw9XWnI1yDDw3PKHbyQ+zodxdshi3vvv8VcposqhIyWiLIruUsUAyLNMFyOGvcXilCoM1IRxrQvP6+gZ+dKsHxdGK72SBZM7DeQ7b58tEyFHNKpPs7trtL+mFjRL+rh0qE825/+VRtKEAmcJDt29/4RS2BzkfrrMyqGEsdZLDITMkJEWed9ZqR8oCssWaOZuzrNtQGP/UnRccb1j1rynKVh6lOajX2rXxbHoSXpki9o+s7NtuBftORSmZMEwVhTvVY1hxoWaB1IFMNe3VSqwNbJONRlgqlK+sYDweGEBn6LTdxw3azI2Yhik20MmVc2ddasqNaAcEyUPqLhbev5XBbhaQGmQUouSxYtPboujZfWkpReiBTrClphSTnjMyjAvi7SDdE47BctrHdiBb42v14RI6/bLK73EPXDKJzqlM1mHc29axAhmyQJmcZPu+U4xlXVtRKqJw+oO2pGHsPzelqIxybGnSLk6onog2mTp3hJftf8fyBbHjmkAvR7tuYjO3Bx+WWONo5rhthnHMWgJ1nqvR5dMS+Z9huefXJC/p+Q4cjho6rYcsVnh2BHs9Irja6XgxLFsp+bs9qHS1cnVOhmpWaOfYrh7M2pC7Psh6izjmnmjIEKZk063NbSrKJf6qLu2FQCI17OMfSzvLs5M9lWNr3n77L6kOkDw6ZZsqYqXFOPW0x+cul0GFy6jzBRZzk9u+aQS0ijTnltQxq/Wi3NtOuEf07Ubo1kfMKqQeDVZlltWfr9m7P/eFEjp7Og+s8jsJctCnUWTW3fY53Z9Vc4EyH5bLISEs+eM9mt+Xy+pIPXnyPUIRu1smX297THSZ24unq9eBWmFsVpmJOee3laXZmdSqtemcwoCq/tSJeSiHPOoBmGYzgGg798vKSLvZU2KWz5tVcCpREKRmPIyXB+UDOiTbl6rVwoiYtFj+Plv1NRF6+SZyAT3FQRTQDGoInR08phjUwpV//k6IlGJFkXXlOgc+TzrYehjXJrd3oajirQ+awDOhyXU2BNKdJBbYZ+fplTm9VCE2gHcS+0/KkCCGGVmqYS7JHejnKooXrOazogqiRvDq4VTn72uyRMr0LdHHg5uKK96+favbUgMVVSIWKDbGMWlOYK7Nq+7sG7Nd3rY1/scyga5lQHa5Qz63uU1WkFTOccqKcMn2/geGR+94M+8pYPhC819SFwAH4TXmct+4LXyI6KrSN0tScX91r57wFKVnxpUUf3DTPxGCk961zRImSYLFlVedgn1jL27K8sraFtPvEkjnw5oSdlYmsoc8HT0Yz5amoonRJ8YVzNiaG5iE+cE6Xo585ygpRseM5T+h7+s2GF9OHbHrPIIFt6LkadvjTRFe04UWoDvnqWWzXvzIe6+Pbs7wuCctyWlRskxRp5wM61tc7Txd7ata5YgG1YaEgkkmz0nLFOdENy/Phmg5x7bl5KK2PmboD8uWR3QdLMx12jc1ZEtrs91Io2RwlIz+rwxjW2dNGhv7IMZoGMoVag7iqX539PfXV1Ye0AMNk8jROHE4jh9NA7wohKUxmLnWyk0Y1VR4elkrriSzXvShlbxSAm+2O6+sbvvX1b7AjMODpfWTTgbzcsxVPXxxBHvn81y56jSNUQ1uTJYuzqrrTGc1irsFudc5XDnQMge12u3ocxJz6TC6JLBkd8YkSslcv2C3271x3tFdW5/lg/XR9Uz0F74lebeycnNo+aDa+2q9cm3W9Dl+IoYOiEIFgjt+yt3K+F2cqbtGkWOWgZHWkcsmtgru2YQ7N2K6bAgV1UD95ecvFtmfbB0Lvia4n1SSRPQjOLQMkHt3yVaWsFKFkw8La/uwuLnny5Anf+M2vMeygF+XIjjkwffgxfcn0GWLVi8Jrsru++6uOFUNCrGV9afRDRKfNVV2aNWBaGu30+iptpjYDms6xe1Gy8sFqVSEssIlHz6z+U+/RCp3d3jcz8SHfeWwX2/r02pgJVE6ZFNKyETi8C+2G5eqZIyirg9I9iQhd7NTY+2Cg34Kz8n7t3Fvf7kUW7eGXyuNZf2GGXlQsg4mAMyeXIk14axr7dDrhy8xxmjSrmBNiM8sX5bzwha3P5aHyLKXgolroLka2w8B0uCV62IWeayJX4omnRJchdQrod6BOk6yN9fpYZvVlUZL1/ldBq5QRNSsKhic0fN/V1RXDMGiG1xygkrPiWqJmAZX4d6UEnGYPWDmmr8vBm/+pBszxQhz/4ZfExouINTEkg2T0LJRTOtkpFb2X2bIluWakciZY9tU5vXfS0gEWAFWj/NqBabdUY7BainJn76mRfJHqWJgyqErXRQ7HkRevbum9h4seiQq+n7OAV9xQY554YIQdS/mRmgXG3OygjYHDdsvu6pLD4cBF8QQivXcMXSG9uGMr0BXUOcaGG3B+HbVZwLWjskAqVsqxWCOY2P7neSanhNj11+e04lQ3m81KnYkxhlQKtUzOQBF7BuzYUm/Aci5nr5ttf1124YXwpZHdus5i5Qf68eHe1kxNCMv0NCdLRgowJ//BRT7YLofKZW0drgbNSW7QJm8TzCRrcwrVeXMKYXpxe8fFbksMgd0m4rsOH7UZsGAjUVtgvWBd11eu96Wm7B2Isk94r1NvLq8ueefdd7i7u+MJHRDwLuNT4MU3vs1FhqEIISvnZYU96CXXhqS6AUsVTDHTFeq1bJAmBEqLTCt5eguw8I2uMMbIbrdTAKRbBRVkcnGGOa9TpaqDq9+LNKCZ3Z9VJcs9SB7Ylz7bP30P1XsPIRKCYnQpYphUSwr4JUhyQXGoW9HpZzk5Ygw2994v/L1Vr9WguF77qjxd6fZEoOTM8XhkToo/rhRT+kv9Hq3CWm9vRtjvD3zvRx/x9PqCm6strgtcdT3GA6Hur6tuME2nL1Cumv5YAhmoGVALrpzn+uaGd997n1cvX3JZHDsCwfXEOfDqW98mPn/KZs4MxVG8YWdX9mNJJtfrX+Rz7ZjWxMT6ma/JuSq7LehaVSmc8S47S6Y5hw1eKqQ8Q1FuYR0hXm1preYt2dgzucWdyaf6QXDgwK/xtbfK1GfCoJacmWeY3NINDIsB7LvBSk40DnolxxVcUXxD13WkubOsyWQj+N7kDa2O3y4JMN4/Bzp3OqUGI6hGP1h0U0/l7nDEffQJ227g+dNLCo5hiKowfaA4T3Ta3R6N7LfdbEejW3lwQvigJfftZsPNxRXf+Gdf52J3Q+cH/BHm0cPVUzYpUUJn3OsV91G1/3Jp+jCeRyNrSp/apFA799cZqNpdm1GDXUt1gjCNI0JmTicU/lOFKODQsW6v2+U380y+bf0JPP9O2Hyuv/1JrIqbqcbbOUcXO+Xg7DPzVDNQRsht2cyUEkO/oes6+rlnCgGpLAyrz38MSwrVptaSt0aipRQO9wfFqaWkXdnWCFLyXP+q/f2UMx9+8pI0zzg8x6njvXee4b3TRpNQnVJVWOvSWM3Wa6k3qLKwL+eCdSLDdrvh5vqau48+4dl1IcqWbSjs5siL3/w6T7LjrjjuU0FyIfrOrknPVar1bcpzMfpr5FhrehDVC9M8N8dqPeVoyQya/Dp0bneeSWlmmk+MaaTLPUKd/uYQMprrfRilPzDaj7xU159wXy7ZrdmT+nMInmRRRsvaWYevNgBB6CJbt7XxsQVtPn6QfZHKz0jz2TEnXSHbDqnGtWT2d3ecxlH1ivOkZFP0LPD1CF3Qkn62XoK7w8gPP/iE4/2Ry8uBP/nHf5HOKXf2OmNTJ0TVIRPNWNo1e2+ZXDvZEAPitVoXu8h2t6UcThR3wEtg63su50D65g+4uuy4HDN70CAObO9ca/YTNGGgp7MSDodhrRUiVZtJKwRMeU8xPF9aysgsqHSxREnOWhIdpxPzNCIhM8wjQ+7xviO4mniuslsx7n84Vx0s0ceOyThycZ5g+mlKyWjRPLHriDGw2/QcD3d48lmT52s1kBYQP1zLM386HLm9fcWUZgSMhF4bvoPzeNGR7ZIXOSgCsxQ+fvGS4/HAcbpid33JcZ5ZO5+tZrwunz08CwtEHEGDqlw535XPdNhsePL0KdebHXHObIpn5wq7NDF8co8LPdeTsCdynyGL6N7h1dYHoBhG++Ep1JimPWPShmrUbLQmX5amxnUFoH5c13VWEVf5HacjKc+M04kCXM7XbDZb6oS7R6sTn2E9lT/Lv8p/8Nb3fHoG1dG87hal+0Cw0V9d1+PjhJ8FLzY9BiNIXqXzt5uNOkQeZhuEUyrHIsv9bqImqnQjWCpKb1JOif3+wP1BO9Odc1AyeVYaE+e1zJ1K1hJpgfvjyHc/+IDDcc8f+YWvcBUu6H0koyUF15iHVuX0VeZLVYdYNkzhCeKguML1k2t+6Y/+Ah/9+m8RjxNb57lIE1sOzN/6Pu8z8KHAcc7a+Y/NUUc0U1ozpHYMWf1LFbgKTyna2LQm4U+VV3a1f9vt1qh81Bk9no4mZCNZhJQ0+tGJVa39hUqvVQOC8yyyOiLtlTfI48dM/AfuA/7WpwrVF7Nq1k2QNuatAvG7GImVAQGdM9xwT6ARft+zQ/AUxsOtRvjrfRHF5jTieLEfV86pZrIcaZq5vdszJYW94BwxdpSU0Mk2jhh8m/6Ri3CaZ17t7/nuDz/g3XeuuXp2wxCjOsuWkXANCyWr8zJZdTVDWP9t0JqgUIHNdsP7777Dn/yFP4r/6JZNmtn5wEWZ8R+84P2+505OpFRwc8a5DQ3TxHk81eTW7GzNtHnbc6EY9m4pM80WPGgwpnLoQy1P6xrHkTlNzGlkHI/00xbZ7fBex2j6OnfbVbFsBTVaZoxVBrK9cO4EfMz8pZLdehUiOvml7wc1zsUyQUGIWFYEdcJ8CMTgiTGw3Q6M495YK5ZstvceUp1ts7qPjT3FKJxChALTaWR/tydLZthsNVta1DFzaMbWhzqAREOTMSf2pyPWVcVcaubJPL86oOWsk3/JAFXnTp1nsUAaui7aoyaETsdm/gt/9Z/j49/6BhcTXCJcpETX3fOke8Jz6Tg5uE+F2XC62TiuQ42ramJ9zY1ZBbwlYpReotrAitvLOS9lU2voWWIkWb1nZs5Js3ppZpd22uzbRlKrvnjolp7XJerNci0j+VqE8VNe1Vnpu45g45dzEYIEStUbzrHZbo3ySLvpQxzwsSBpInbxLBPIwz3Abk9Rne2siiBFZVdEdEiDFELszLEz6iZnQx6KNcW2z9PM/mGaccGzS4U5oxSUmA5dBRALs/X6nM4pwqwdEO8dfd9bwkiDspvrK/7bf/1v8PX/7z/iYhJ2JdMz0XcnusPEu3TMPpKmwiFqFrUV7SyJr06qHbsetMJAbZPqdKuKX61QkmJym40toEhmGUG8BLWCNrSeThqgTtOoI5g8LYngrJrilqktreq73LnHPenOOZ5/ynjAtzqoNYpfMDga3a0nR3kfGPpeo+dsNEdeH+Ykmsr3MRK6jg1bQvTMU8DnqZUCl/LL4q3poRd8pbdO+5IK+7s7xklJ9kPsQIo6Xkb1kbM2EjnvSE4YRbg7HOli5DhnLV1aZ5+WQEFn+Tl1VlZFlgqwrk6lc9BF6zR0cHV5yfDzv8DpT/4yL772TfqpEGTC+xP+5R3vdhuObmaq3Ki+ApcN2CDneqc1Ta08gDqytYhOwahjDGs3dI12vLMu85rFksLhoFm74/FATIlcEiHEFlGtM3eL8KyErT5ZZyWFc0qaGoU9Y+RfK999q8B9UeusjGGZ0coW4b2n7ztmhCCOuRSSwVGmpPRoOu3J0w8DIUDwmb4fFmPPg12zLWvoEtvHpbyq2ewpJbqu05Gi5kBXZbZ+wIvoBJLTlNgfjlzNlyTRh9o5EC/tDuEWpdLunmVQm4OKYltjCLW1ir6LPH/ylP/Gn/+LfO0/+y/oUyGS8Exwd+Dpu094EgYObmZMapTX5USRRU5eC6JlkZOWGS3aLFJyAlzLLlVC//VM7bq7x+OhGffj8cj2cl45Axrwavf36+nR5nK489RL8x+cfCllt2WQZTF8MWi1x4kjFpisTXdOytGoOH/AQ/SBEAZCFIJbMHAVItTW6sdKJwjaXFINS8mFNCecd0QfFT+ZleS773rFeJfG6oeTwizCac6EMNOPiVkgorPIF7z8Svc/vHZb3qkjoQ6qow/xrMnwYrvhL/3Kn+G//No3GVKmKxmfZ/L9PdubK573W46+Y0yFKbYshOZBZVUnEnPXq5w0u6eOvx7Q9qUsDWLVYS3moNYSqQ++NVameWJKsxn4SRM4pQ7+0OELIGe6ZJ2qMO952a8zXdxefiyh94WveZ6VBixGutiR4owv4MTb2HOtgMbQIeLIWcd765hSj/PLyOa3raYdRDPaD4NzEfA21tmLylBKSXWf80bALw2eVErGCUxeCHPmNCV9vloEUx3TB+fxhk3XOFIbGivsBudaY3nnPO9cXvHdgurcrLq5HE/Ew4mnF1fMnedFOnKYy/KUyPkxavb/Yeao5r2cd9aiYJ39ORkfsdrHZIMsWmJGaKX9IhlJ0tgn5nlmnmajvbKEgiuL7RGhNnI/OEt45PwBPpTI/02u+ZtvvNOfxUGlAsWro2plGL8Ywq7v6DH8nqDEs6VA1lKkN2qQru8J0dF1DhlbMeR8j5tzuigiWkZPU+an45Fs5X5VdYrJxOuc8ZyyEfnbeEZxuClxP86c5kwqmury1pnvWgBq2cQHuIz6Gk4joi5Eqp7f9j0Xl1c8311ywhHSjGQo7oi7O/D8+TWfZOFOZmbR4xZrbmg0rzXncybv51F8xUDllKxrDo2CapnUnDAfnI7VKx6XHafTyJgmjqcjnWU+SijmsghN49t5OM7/vehJd35uD5cIgcQN928TqS9siU1JqspIuRpXBj9qY0UShzesWi5ZG29i1zBEIXq6uMHJTD90Z9ko4NHMRbOxIu3xlCKKuSyGGXYeLKPd+2U+dynqULTMGIXTnBiTyq3KjSy36JHV1ELN/tt5eOfovKeagOA9fd/zztU1vycQU8HLjEigHA5cylOedD13OOZcqC1eQn0c7EhulUFYPb+1pNsI3kuhpExKM8pFa/K72k9ngWPNfp9OJ+acOZ1GjscjKc2K2234KQ3qlk1/ZD+ac9rSC6+9J5C/PLK7CNCS+Qyeznd4bK55luYcYZUspdsT498MWkJuzlBdVZ+d/7O+WFk8nD37YnVQTyT6gGRRmq95po+9PmPWma1CKbgiTLkQ5kw/JeZcGGRVDnRVNpf/1qdS3YFijC0eR3SerhodC7a881z1PUOBLhV8TpQszMfAbhq5ubrg2PV8XO45VBtiz29heS5qMKB2doUnbBmpJSBLc2KeJkIIJHM819AFrbqpVarZp2meGOeJcTxB8I1xpsLglnB3HWRZgIdbzqGJ7etK583S/8WtcRoR14FT/lelv/MIXqm1pKjNNohRSsV0mcptwILq+oFVkbGYo/Yrt+id9apBRZ2uJsbbrh31BYIzTt7qfUgbFDIXIaTCaUqcpqTZQlfv6eq46xNrPy26D7EqMlglyVgxnMKSJWXGV6+IORFSxmcPTsjjCTkcudxdMYeOi3nkRSqrfO3a7ri2KdUP02e2wndW77N9mqeJ0+nIMKjumA2/v9bT+u/SGAhEhNPpyDiemOYJH4IlKy0qbXvS7gCLt7B6XaovWZ8T4SiJ3/39dfHTnJUaLea8NIuUOinGK+l9EEcSYEqawQw2jtAHSsmEoNOoutjjuwoyfsvx7f9eFmoppUjIqkiCNrAU50hzpnhhmmfmkslOrLmqwmId++OJ++PImDKXgNdagVLp1Kh+5Rwr3yNW1qodgJ7ee7z5sj4nTre3/Pav/xqb45GcIJEZEfr9wPOff48P58TLnFuZoz10gjaNrBTgEiUvgtP2ozjmWTNJ4BRnI9UV0PMOMXI6HVWZJuXlu71XbA3API86E15CK1XVuMe5h46o3YV20quI7UE0B/ANOv62f49vv/mWfmGr1Ex6UsWk2EuLDot20HY1I+PBe2FOjq4T+mEwqhwtP/sQGIYNXb8qlz5sNrGlmVS7J3K2TSAQ8EQfbU56YjydiJsLsk1byUVL8ZXKAxxjgvvTzDhnNoMOolji0nrn6zGsslFlV9ShqByWvQvEoifjC5z29/zTf/KPcacRl4zJoAjTAZ5ME88uBg6+4zYfCaJnVERIFDUo6wdGd2D5ElgGTqhSHKeJw+FACJFxnhRP66Tta3UOUk7GK5nYH/fc3b3iNB4Yj0dyng3vblRv0KI7t248YbU1q6ygekiLQwFfNtldZKuIzRLH+EftHkikYdqdV1yxjjQGCaB0vTr5pVLk1MzselVdE1z1L8/lSSFdkb7r1FBKISf9nDxoZ34q6nw4BMlCQLFzUykcx5njOLHdeKILLAkHmsO4TgR45whOg6icsxKt4+jxhFQIRpEmOI6HE//VP/gvYTzgEkh2JDyjg/H2FZfXlzwfNmxPJ+6oJWhMLi3Z4qWdT80gIYrRy3W/nEfEkZJWpPr9PV0XOZ5OKx1M63bW+6acyqfTyPF0ZH/Ysz/c0cWBPE+kkhTX3RqyFC9YExPnt8lO7lFdrP+WAnx68vEnuk7TTGFkyga3y0LsN3ptorp4M2y1wdP0UsqZ8ZgYYmATHW5QiEmtCC7l5tVy1VaJ5U9LE+RaIatsCylNypyQs05TrMT3jhY4Vz1RStFgeE7c3d9T5IkBhPWgFW73GitETTbZz2uqK29BW01++QLz/ZF/9qv/hHA8wgwle7LzTE6YD3suxmsuh4Fnw5bvz3vlifWV+UKTW27tODnfqnrwwG+w8yy5cH9/T0qJy8srnPOcxtMqL2yNwlb2n6aJcRzJObPfHzic9kzTSRmRKk2nq02uyx1q8dz6hkndGJBivpuD9+VD/i3+n8B/540y9Rm6+KtRh5lMmm20mxn8aTpxGkF8B77Tkn/Xk9ORLnb4rlc6jZIpWfBeiEHoY4f235eHOrNdaLu3mg5aypjGMxeN4qmkrBNvglEHeQ9iTVi2UUmUh+/ucOQ4TqRS6MirzIt+/llvYBGCgyFEgmhHc1ccIdskEu/Yf/IJH33jd0ivbnGTesPZBSYKebzHH+659IVr5xmzzoqu5NGI6GSpJU25Eny/KFL7fUqJl69ecXdQB/X21StrdYIsSpGU5ol5nrm/v+c0nnj16iWHcc/xuKeUzMuXL7l54ijFkfKNHrSsMCQtVNXzy/PEbKPXdtuLBX6wvlECFGFTZn5JXn6qSH0RS4cvRBwRJLQHNqWJw+Geu8NEP1zjukHJmUtiGke6zYD3UUtSc8FLQaLgyZTgl3K1OaCLKanDFlCnUDK1zLCoDlU0NWrPuTCNib7LzEWNfZZiJVYVzVyEMc3sD0f29yc2fSAMAZwY4b4+A8H7JrsOlV2XFcLQOU+PoysQs+K+XAE3z6TbO779tW/wngR8cornlkKZA+PdLdvtOzzpOob5QGX9ERxFHM5pJv4hIksqZcBZR4M2nx3uDzZ72/Pq1SskF7abgWIOrI7fE0JwvHr1itvbl0x55nQ6cX9/x93+lv3+jhB7NvXZLU0Pr3ZgbUAKaTpxmhLDMOjUpQdKZyP5SyO7DQ5hgdA0TewPMxBxocd3G/AarLoQCbHTDnKBeUpMJeMQuuDY7SLaUbvkNB6HfakTVDjPSjWGBQfH6cg02uQqOsVXGhMDJtN6/o6SISGMsXC73/PkemfP5EIKpI6oo56dRzNMXkRxd7mofOPxAl3Sa+pRtoDTeOJr/+TX+IrvccnjinLojiLMxwMXh5HLruPSOz4pWXGn5uNVl+EBL4WeP7SqISwNiKVkDocDyWkAPJ5OzONIF4Lq9KI8yqfjkX5QIvO7uzvGaWTOM4fDnhBGbu9e0Q0DoeuJSTlRW4agRXvrQE9PJM+T4VgLu90FtZ+o5MxpnNhefTay9J/U8kZmP88z8zwx3R+5vH6KeEe2zHQfI7hAKpm5KF5UUiIHh9/2bZpcg6xZwsagx42NRLepJpWWDGcpS6OVOsCJLMmy3Xp+1Tmu8IBaDUpZA5bTNPPi1Svm/FU6D0o3ma0ps9H2PrpaoCUQxRGKI9Q2BQdyOHH48GNuf/gB79JDdiQRRoQpO07TxHA80u12vHd1RT/dEazhSpwsclszkY/BDJre1QZZQSEnp9OJcZ65PxwpubDf77m6ulJ9XiBJ4jSNXJQt4zjy6tUrnY55uGVME6fxRJ8T+/0dzntK8YS+YyeXQG83ZU0Ntz4nEEnc370CcfT9wH15wa/x/3mrTL09g1qcZkBtW7QEiZEXq0pJeeZuf8T5Ad9tiP2ARK9dc0GnLIllOJONSI0BwiYQnWJTRNTDh7h49ELDiNSHtCnOilNzykl6mk90MVJcIEky0nQWYJR9ZglwOBw4HU+kOdNFp0B1tyhuZ+X/mt10zjG4nsFFOvHEIsRUCC4QKXz7977Lr/2Tf0KYCy4XShayK2SvXeTT3Z7ucmDbeXyZUbVte4lqOucX0ncxLEcj2a08l2hqfRxHyjgyTYnbly95/ux5o5hKRo+03+/58MMf8dFHH3KaT2RJzCVRnGN/2BO7Dh+GBeDfZKmssrt6A+6PR25fvWR/e8d7X/kK11dXWj6sG2bOn5TC8zLzb3D3VoH7olY1rBpN2/0vFXuTGMeRlA90g0AMmgXKmU3UIKuIZnDmeeJ4TAxe6C1zI85YFczSebfQaDjLuDgLK4rTACNTGlexzlpWXOUw6EzmkjOUrOTSlt0EWnA4jRO3d3sudx27zQ6ViZrt0ueiZTPFzrNAb2XhLnRsul4DLfGQJl786CO+941vsZkzocCc4YSORPUpMB4PdKcTvR/oxZpDihhhv55XCKsYjyUbVVvwwINTFoRUFJM37xPjOLPf7xn6nu1mAziSqPzllDgcTnzta1/j/nRHQbSLdJ44jUfu7/c2oi9aNlVw2AjN1gUtzVGWUri73/PBDz/g5skTbm6utWnTuF1FHO9I+tLIbimr5xCsGpI4jSOEiX5TcCFQJNOFnhgjIQTlzE3ZGu8yJUDZ6ISimjEMzp87qA/tmwXe4gVs6p+qII+kmVy0yc9bNaeQW7lPLKgVUQcyi8JmPvn4Je8+e0YfI9q/KcZ3qQmL9WlU57Dug/jQOv1Hr13Mmczdx5/wg9/5Fpd4gsFfjgIJx7bAlBKn0z2pd2xCIlRC3zVhuOm480ZdcwFqKkgqmbu34RKJab9nHCd11kW4ublRp1w1u46gnRO/8zu/w+3dK+Y0kV3heDqwu9hxf7xnuL9js71gTprZEym4YkHtshP2k4Mi3O333N2+4nA4qC6+vNBZ9unE7e13eXr15z6/0P0BLB/icv8EfT7LRJEOnE5dBK2qZmuQrCa6VrtSw/QucrB2AzwLZR5YIsIypiGog7/g3m1qnbOeGGO40UpCsUY8YxdBoVOlaOVxf3dkf39kuO6JlnnXytUai7pkd9Wh9mcQheA9nQ+4IkSnCYSPPv6Y7/zuNxnEE3JBirUrizAZtvw0J7qU2XlHlIyXhBOlFdShAdKgKPrIVW7rGnKprfOtkqbVqfF00mNlTWaN48jl5aWZMUGcNRKmwne/812+9/3vcTjeM+WR7Apd13EhF7x48bFmWl0gDj1XN0/oh0wLPVeYad0fI/qfJn7wgx8gBa6urzkcniL8L94qU5+SQXXt+1lXd8seqzHIKSEu4JkpOKSowxWczqovaHkkp6QlIi/YJHFq6ve8rLHQOlQ0R7ESiKvhi9ebSlFMm/cOzAFZ09a0TbKM1eFw5NXtHdeXW7ZPLzRryapTv2bGVtFzwJNPI6k7MQ9HDi9vFXx9f+Cjb3+Xlz/8kGdJQcVShOyFXBwpzYz3e+i0wcA5LRnX2yer/5b8xpKBapGinYs6TDNz1ozx4XDk2TOoIOgiBe889/sDn3z8CR9++CGzzBBEx1p2Hfv7PeAYtpeM00nxgEE5DJf8vGYDXHbs93e8fPGCu9tbhk3PbjPgXa9GTBZaGAEuSfwL7uXbReoLWtrI59u0r3VZRiw7k8iIn6AoBUhtLPI+NMaEnBTW4r3iWaucVjB+Xeedp+Y+OpaHnwVrpiUndVJzCa1ZqBr41ZPWHIspJT755AWXu47riw19Z0FNC67Eyj6+KXdf7BksopN2xJGPE95nxpev+OCb3+Y7X/sGXdIGECmQncJ0UsnM0winIwShc0Jaw02wTGqxRqW1ka9QlrMrqTChhExwPJ44Hk/2XGgJVblStXnicH/kww8/5DQftPTpBILjNB55dXdLP0y4EEkp4eeJGFsjejNeRYrqhJR4+fIlL198AhRicGy6zuZMK7b2SuYvjezW1Z4ty/gUyyyqHKo0eVdxe85KdMUGU2Tmhiszoyw1kGn0isCyX+fL9JKjdQKLQZ00X7CiqbES5lJ2XEqRc8m8ePWKj1+8pAtPGS6VzcU5aZko37IRqxMqS1a1i5EuRqRoBcqVwosffsDvfe3rhCL4ZI6F7dlcPHOaOB0PpM7R7QK+qK0QOXfQiyj+cdEPpnDbexRTKliG1Ajgj6eReZpbGXrRB/rveU589NFH7Pe3pDKr/fJC7COHwz2x65hzout3Kyq82pQbTHeYo2bnvr+/48WLFxwP9wybjt3Q0bueNM+8ePGSX/yF36/E/f5WHRZTk0LO14bSylYQWqmjNl7rez1igc6aoF+MrUY/zT7XGQSuVVNVbpwz6kerprTG7izgxQa2lHbstqo+X1nklDOH04kPPviQq827DLFrMKQatLjqJduJiToSygkq6kgPcUkK9Hg6gf1Hn/Dtb/wOsYDPBWowB0zFMefEaTwhxyNy2qGcLbLaV1S/Lol1zn9Ju8bWZG7/1sEFWvWYp9k4pNc9Fca8kAuvbm/5+OOPOI1HMhnXO7Zs6eaOu/s7sgg+9FxcX5stU3+u+hHqo9qUwCKUlDidTtze3lqAINweX/Exv/FWmfr0JilnHezOt++0jNFijItAToXMrGNug0b1SnIupFwoSafAFFeYmzNUaWvON3jlKy2i4wRMxutrOSdSnokS8OLPFPH6DirNjeP+eOLFy1sutz3vPblsN3AVC6nbLDQnOwrsP3mJO0z44wz3M8yJ+w8/5kff/A7p7h5S1Bshmj1KOTOnifFwT9n2+A6cN2LrlUg9cqoLNvcs06GNYNOcGC36maaZKg2lqJNRPNzfH7i9u+P27laFq4NhM9CNHff3t8zzzEXKHO73HI/3hNgzdA4XA7UsnXMmn2ZevXjJy08+4f6wJ0Z4enOt2QiUCcB70QyZCIM4/qj7cnBJaiOfo5Lz19dgyZbnApIsA+Q9IXSti7yIGqSc1UjkOpZz0RLts+yIrDF+S4BFU7iATVorjdqjYrOKWMlJZDGgzjXHNuXMJy9ecnO15d2nN+y6jcntElytDWttLvE48uHEfHfPMQywn/ACtz/4Id/5rW/ww9/5PZ7kYjJUyPY8pKDBkJyO5Ch0gyOvrleTTxVc75vyXvkoi5Nqgl6KXkdK2vw0TRNlq8FR5UMVNINxPB559eols0yA4KKjGzqFrdy+pB82+BAZT0eSODYboesgBGflbj1WSZn5dOKTDz/i7vYlIjNdgJvLCzo/NO7bAfnSyO7Zahg8ba6TSodWREnr3dKQsCbfRpZgvemYelPWzhfenNh1KnXBFlc8M9jgFU3NmMHLi96Udff/kiBIOXO73/Phh59wuRl4erkBc05rSb82K0l1PMThxRHEISnjUsGlwnx3wMeEHA786Jvf4btf/1121mRSp2ol75izZ54nTsd7pPOEYdccVFdcvcR2TIXr1IB7CfAWiJg9h0UZDeassIt5mnWKIL7tc33S05y4vb3lcNiTJSGuEDaRae45HO/BOcZpYneROR0PhNDhQqTvnI73xZmu0OchTSN3r17x6v/P3J8927Jl6Z3Qb8w53X01e+/T3C4ibiiVWZUmqQATnYGBgRkGZgUPvJQZ/wF/Albwzj/AO8YDr7zwBBhYVVEylUlVwkqiJFJKZaPMVGbc5tzT7W417j47HsaY7mufG3GiVJkZ93rYiXPPbtby5T58zjG+8Y3vu33PeTwRfOXls2cEJ8Q58u7dj2DA74N28zKY6jRvEK986EJTWWmazdZxatfc4mfVSJZVBn4pfFda0fK3rML4dYl/AxU007fu78X8gMX2gvXVQsowTpVvX33Hb/3kGXXrl3h5uuZeno/uKc46FJILoTo6HGWcyb4gU+T+6+949ed/wRdZkCwat0ASRU/nHPHTSD2dqKctneUj2NqI1opcZkwrMXG5dE9Shwom2K/PY4yROc7kVNai4uJ6xJQ4nY4cDgdimilSCAS6LhDTzPF0UIfRsOH56cg8j8jZ04UtXRDw3hJ2ddIqqTCPI4fHB46HA6VEao3cP75i4h9/NKQ+mqB67xHf0NCKvnfAeZPhwdm0qKcadK9BJNa2NiFpawGLcxgjgnV44unFWa7oEuttk7+outCEs9meLrzAJ6hWMURUHwCwCjhV7u4fGDz8rd/+cuGVNDSqkZrFFsjOWu1/8gd/QjnP9D4whJ4SM/HuAZcTG3GaW+hjRioawJOL9PNMmSbodeFp59kI1NouLgtvpmXfenXaYvo0iNrmcCmlVMzVZS6JcTqr4PD5TJGMFG8OERPHwyMnd2aKM/vXe0QgdDt+8pMv6d0Gcdqmqinz3Tff8vqbr7m7e884nnn7+hueP7vGuZ+x3e60tSpKk6i1ciqf8Rf1f81PPhpyv7nDmfGCtvYtiZfW9g9a7TpHEUGcx3cBRO9hLjrlKCi3SuqanrXCwju162vFWm7JmEBrtYhbW4TtyKWaF7Qudou5gn53eYm6eKQ1uY/M/f0jt3d3fHL9M7yICn1j+rzt7IqqOXTOkVPhmz/9U17XP2MIPaF65vOZx9dvqOeJIVUktSKzkKhUl5nFEeNEPZ/JQQjdgEeVOVpjYikUl7aZnoXjYnNfpqIrjZ9U7PPrAJuix7p5KDVojhPTfObx8UEHP1zFZw9OGMezJmenI6Vk3r77DKTn5Sefst/fsNnscX2vVJt55vBw4O7dW1598xXH4yPv373mfHzk2c0Nz59/Ymofwil/+qOK3V91rMQOQUJQjoVTjlmM0dp92jlwH66vNHvk5Z8sOKXJK2mh0dZ1EwhXyJTUWtFVE4/m4qVx0DbM9f9FKzsKcHt7x+cvnlHrJ+pyV0D8ZRVuv1cU8fLi6Gvg7vVr3k2FcnekpsLp/sDjd9/x/utvmd8/cJO1d9+mxGsRvNNN1o8TdAHZ9zhDTtu20oQEBStm5UJ6SlS3d+lEOEWoNcTbhH4mxgQBFpWK2oTNZ0Tg4eGOaZ5QwfRCkIF+EzmfT+ScOZ1PTPPMm9ffcDwe6fsdL19+qutSMy/ImdPhyPs3r3nz6lvev3vHeTzy/u0rXr54jnz2Becx8urb8a8ivP5SR2UtlnSXNwStSXd5T3XVulNKL3Mi2vovK7opcjEpzlN90cvjSZJ4kSi25LSUsixSIk1f2S3gz9OnQxe1epHIHg8HpmmCsqGTjs7W4lUtvCWL63sEZYxyfnhg3N5xIJCmxHQ8c/fVN3z1r/4Ef4qEotSbRhWrAgmYcyKkiMQz9XzEb1g6Ey1HWT6/yIWjFlRzXNO41eKzibxX4/E5S+JbR5uc1qK1QEyRSuZwPHA6nYBKIulQbAiEMOG8ZxwnfDhyd3fF1dsrnO94/uxTrq6e0w0DLhiSWCrn44n721tev/qW+/dvOZ4ODMNAvt3zP6r/+4/G1EcT1BCCBo9tgpvOq4uIJYXidMLT+0A214OSKzV4HYIKjoJKkuSc6bzXn3eOzpSS1VGq4J03hMY/2dyWadsLTmELzVybU4e9rwdp7cCLalZsc2y1fbYW+RQTV/sdPjTRb72JQRw40+FLkfPjI/fv7kjHMx2ebeiQmLnCsfWewZtAMGpMoO5Mmd51pDlS5xmJnpACPitdQewcG+/pw61kQaNEzCoWHTITvYbZZGYwHc3VvzhyPB04n0/aOhLT2nQB71U7tokk396+VX/g7TU//enPmOezKg0URcPH44H727fcvn/LNJ0Jnefu/Tue3dzQ92Gx4nVOE6yv8zv+j/Uf8d/nf/jRoPtNHJthi4SOavxH8V71eIMOlQSv+oylVKpNQoe+B99cNhKgln3BOTBh8tZ10kJJLv60wxarC5Sq/akVVYygWGH1yxdegCr+Ijlo71kZzyPHxxN9Zz7ny5SHtmODC1QqAUco8GzY8Uffved0+4AvwvWwpc4JxpGusgxZpQtN1lIdnctM0wzjRO0DfqvT/84W5MZLFy61S+3cL5bxUirB9/pcm8i8855k8kTlYhNqm/w0TTw8PCqiW5X64Izwej6NxJiM7yZ89fVf8PzZZ3R9T9cNbLcb4ngGnLaVjgfefveK23evOZ0eVcR+CLx/95rr66vFTeYX8f2PJnbbWlerWvI2Q5TqHRktqEA1j6VpbhptRIflBEHpDTmXZeikzTx/f6158u7A6jXf7Dxb9V6ztqB13fdL4nbxq+s/pClJwHQ6MZ1O5CnSb/b0YUXMxJBLsdZph6PHkcfIN//yT/jFeaITh68OYiY/HgilsDGHolorseqwrafiS2aOkRAjPiZkjoTcK4ra2scXwvwadzbJv+BjTS1Y9yRNbGSRiWuIdUoRKQVvqL0+q4XHh4eldV9FOeh5ivTjjCDElBHniSnx+s1rrs4Tu901w2Zgs90qpaOgWpTzxNtXr3j73Svu794zzWf2+x23799ydXVFivDmu/d/JbH3lzmqBAVcvDkoVZV+FKegVgiadKcUdZgZve/D0CMFOjLOEGxYgYB2qMb6WtgDSNGd3YmnAaMfSk9BK0JWoOCXPQMV5YmKLlxM55m793e8vNrwfL8lSOPV5wsM1RmX1QAtHPU08fXv/yu++Wd/SECYTxOkTDkccTGxQ+OUqgVjoS7FU4qZHCJ5jtQpEgaHb+Ac1fi3yjUtVgas52J/hItunn2tJdKiEl/ZOLnt2jSaIBVOjwemcbQ5IkfKieod85wIIeFDBEkQI+/evcE5x/Wzl4BnGLaETuXoMHmxeTxxuL/j3evvuH37mnE6s9ttuTu94f/JH/G/4d/9lTH1axNUdXbQqfXN0CnX0yrmUgviRZGnakMoRmh3XrllpRbmeQSKJknB0XlHcLrTP/GDfXIx28W1ISFzksKqd+cafNMu/CXgb6mo3aDakgNRLkpKlWmeOJ1PfPHJMxPer8u71aRJdZoit+eZu1ev2T+74pQL8/GMK5neNuYggpmvqmA+ZdElSDmS5gmZZ2Tu8IOjr9CMLaXpWTZfYJ4+XNqSW/l8yjW75Ch+eOjrnE9nTqezto4lU7yY7lnBxYzkAoy8e/eeOWaeXU98/fUvOJ9HRDxDv2G/23N4uON8PDKdz6Q8c3P9ks4JcR4ZzwflABboQwcIm/LI35bf+1hI/caOzWaL+EB13mRNrEgX5SqFPjDPTm0dDVV15sA1z+r4UmvWBbQPlBg0IWgJqL2PNLrLkxXv4t/L1zVrvWwM6IKq1oBzvMB2vtdI0LjFK0o2jiPBezoJlqA2owZHE/+f0sx8PPL4+i2nw4H5POELnFPF58q2wMY5BpNjqVV5UBpqlVQzKc6EOFNjj089ne0YGo91OcFV264tnrqBt/Zpu06uXujCNtTVrs+lpMw8zxyPB+0SuEKhKG0oZTVUkIyUipzPvHv3jpKFzWbHebOl1sL9/YGrq2eQC+fjI493t5wPB6ZpZPfiGbthwFE5nw+I91TxdPn+RxO7y1q40FQUZXLJUaqiQHjBhWB2p5XZBu8cuvYGQ/1X6oVxSC2Ru1xlYEWiGjWkZQZ6yzX+6sW/gcWxTtffdThtmbpsiV+FHCN5TpArfRjonHEOl3JG1s9dKmmaIEXOD0fmxyOhCoMLhKLi5hsnbLwWcbrurs9kKjpUl+IM84zEhE+eYBM55ZcsoC1JdU8vzvKqikdd0sHadeGD/UuLssPj46IjWWqxIdU2DFRQxqwORd3f36kTkigf/Xh84HweAUcXenKeOdzfcjo8Mp5OxDjxky8+wwuUODGPhfN5+q8QaX+1RzaVBt0FHal6ahUdFLK2b+Ohq6tcoTrNK6QKgULXd7Q4Wm5TXac0sMSrjQ+7i7xBi1yTeBJZu5KsKHmlLGjhmicsd3R5n3a/+9Cx6QY23RZPITdQo16cS9XzCOIYxHM8TZzuHpgej7hU6HC4XBhSYRBh4/zSlG8dDSeqxJOTDubKNME0IWnAV4UClr1guT4NMdYBpwaKtAFf553NOMrySLrlMjYN6YthKwv8aZpVb7pkqivEnMhJ6HJHyir9V6xjdjge6fo7coHddk9MI/WYGecZJ4HO9UzjmfGsSeo0nik5InXDM/dT/jvyP/loTP3aFn/X9XivrcSu809Jt7VoK8l71ZNr+43o5H5BeQ+lTQALeO/oOkfvW6u+RRDL5v+0uvkQoWrCvmK6cSh1wAYF2nK7boXyJLhrrXhzv9oMW3r7fErU16RZE7wT03nUjT14Xv7kM7rQ8fjulnw8qbZm00WDhf/SYPjKikL4nHE5E0rBF8iurmu4UR9YgsyCyfpLl+BEk8FqsP6TpN7et2RUVHeeKEWh+YJ5IM/zks+nqBV6jIk0qz7c+TzRdxtubp4hn3zG8fGe8/HIfB6ppnuZYyROI3MXkE4ZMtnpeRxLz5/I73404H5Th1qbehDl1a6oPEvM4iw2RFRbURqPLy8av0Uyfd9RnXqQN93Np3/qkw0SQKos/LpmVSdWoq5izyytp3bLL19FkwbLhi0B7fuO3XbL0A+qKKFCvbZJV3VeSok8J+Jp5Hx4YLPfUaZEPI7McdIJUpOm8sb5W5Y9DSWt7IsN3KSMzwV/YblXqNYTteT5A4eixie9/CxtMXziyXKxSLZnqbmXqDVlMVkqIEbGacYnRUJSUn3bWgTvO07nE1038HB/4IsvfsbQ9YznE/N41iIrzprYVk2A4jQiXYe4wKn+eGL3iZi9bZ7OFpZStVPVxMgV7Cnkopa5per0dN8HXFWb1PYapa6Sfro1P93opCE5FodrysXF1y/QqO8VYpevbl+uijhebbfcXF1ztb2iDz3B1ExK1QKkijrdUIQSI/PDI/ev39AK/3nOeF+Qsor2+7YXWVnUHqtclaJTSoZccLkQSlUkyn5e1VrWQZKF61vt642KJW1N1xd3C2fy+/er/XDrAjTtzVxVOaQ45Z1WwCct4nKB9+/fE2elDIQu0HfDshY/u3lOyWVJTudxJJekCjjTRJwm5qkw/ggS1OXzSyPyreBQo9/luppwlJzVCtWpykjvCttNRwgOJUxdoNzLCns5/aLfeVJu1fXe6Sm15LXJNjaef6tEVi0UTTYt6RTH85tnvHj2jP1ur5KZJeseuMRt2/Ct6M6F8Xji/Zs3xGlmPJ1hTuxCR1cFj4FzS15SmzXQch656ppbUkJiwmWVuKR9+qo5Q7V4u0zin16DC54t6+8vg8J1TXnXF9fvz/NITIlUEpIU3CpJJbBkoXHqL4nToet5TnivCazgGMeJvt/yyfNPmMeReTxxPDwwj6Pew1qJInwlHxfv/WiC2iwhQ/B4J3RGdm7Xo+TVB7q11otl7LkWdVQqyo1MWXlm3gvDENgFt2xI9lHbNVqPy12/ZfhSL0PK2v7e+K2XQxqy/O6ysFaopTL0Ay+ePefls5d0vkNqpllilpR5fHjgcDwyTRM1FX7n57/F9bDl6uaG7dWO+29eUx9Phqi1CmZ9y4VbKhpI6lRU6WxzXBIPS4Yk6IPtSgMfbOqwKIgv60dZ/XXbdVsWR/u9qlJUc5wpVaW9chVknkz+JFJRasY0J8Y5Mo0Td3e3lAxX+xvSHLnabBlPR6bTkfl8xomQ5pnpdCZOE2lQ20/vvXEIhfc84+8N/8uPBtxv6ghmV6pVtCWoZcHzUHkSrYZbEbMUUybGV0sh10jfd7iusuk9wQtBBCkX+r2GKF4+8I6K0yDQuidXFnDRDq3y/QdJw9pGX45WZTvPzfUNn3/2GX3XI3PC2zvrQIoOZqSUiNPMdBrZdT2f/fxn3PrAXXlHTYmamwg2i2SL/q2xWey/syXpLhdcrrgFEbKkvFRqyeBUz9f7QFto2/O0fNa2uYg80RNf2tnLRRBySUzTSC6ZVNXdqw0TyOmovHHndEhqSioLczgyDAPBd8yzuq/cXN0wno7kODOfz6rbOc3M48T5cCS/aHbJwh3PfzSxe3lcliu6gakFbuiUYkOT/jKpp5ITMvT0XSB4z6bT56DF84ev3ewYQdYktDYUdFUJda0Qt83e6cPDInQOBp5eJK1oHDnn+OkXX/DTL77g+bNnBAeu+qWoz0UVIsbxrJrZ08zp9p5Xf/4LXl5f6cafD6SqCYI3De42TLrEsD2DRXSjpxqYkQvBFACah56USirJBCuD0njaGVtxdmlK05JfNS5Y2b2rTmxDu3Xzn+dZB1JyIqMolEsq2zenpNQNPH5KxJg4Hk48PDxwe/se7ztKrjy7eUH5acaL53w6Mp+OxHFEgDTNnA9H5nEkzsLpNP8VRNtf7mix8eGu3vbV4jI40/sqVV3lasZR2HSB/dBxsxvY9J6c8pOiSJfEtlLb3W6JL4YrtsSsof+1zUiENW/JRaUd2+uK5QVykbRWLUR+9pOf8Omnn7Lb7WiKQ53zuGruaSbAnNH9Yp4jjw9Hvv76K5sAtGFpKsF1CgpYnFTbDsrFw9LkpmrV+JSU8TnjLbkXAdV0TlQn+Krx7nyLR4UOdB+rSiNgfRz1eooCX2Y8tIIDLb+CcTxrBzllqtN9RQTqOJGymhl4UW3WGDPjeeK4O3F4PPL6u1cICh7c3LxQykPKTKcjp8dHptOJEAI1Ze7LPf+h/GfAf/dXxtSvmeJXe9K+63BSCdjUVwHVEVMkLibtnTrT+kpTVE7fhSD2PM+k4HCbwLbb8unzK653A2kacaWu3I+lBdVcnFjaLsqNbIGpwSEi9F2n7lRSyUYqEzvF9bOwRPrNzTVf/ORzai0cHg+UeVSR+xSZppE+dFzt9zx/9pzNZsvzm2ds+g2fffkl/87f7dnNmT/5p/+CN3/wx5ST8d3sxVvAtRGwWnWzDFVwuSG+YiLXkTRHxEe6vieEDuc7CsUkIRJKGK/L5GOu6vJwOp0Izi0PZc6JNM94qYzzmfN0ttZSMekvDSadrNNn2IeOYei53u3oh4HNZsumH6hphhQ1Eas6bDLFmeP9lpSUi+mdUy1DZzprVP7G1cT/7r/3LfDf/FhY/UYO7z2h65ZEtWRDtZNSPHKxZB+dMowlAdG0+iwWTZaDEtltOp5fbXjxbI+TDKbtVrlsGV4gUkvlzlJANJ4lGHLqHEGc8rCz6fKVy9dqKKv+qwuOm5trnj97zt3tLR7ogJIz0zxyOD8u4uklF5wPfP7lT3l29YzPv/yS8/0Dj998x+O3b2CaF8/mxXiAVQJtWTyNI+iUuKRnVtVXO0VFicQHQtfR9RpTTZkgpkyuusmrB7kOSFSEcRytQHUXX9dCcZxm7h4fmExnM6PdBb137QLpZui9J84Tm2FjJP6O/faa8+GRUCunhwPHhwfqHEnTyPHhkdN+T/lcEYRgun0/348/mthdXLU+/LoC1rpVToXo0kLBat2VOM+UocdT2W86Xl7t2G87inlwt2NBjBYFdCzc1qHHVmSIGSs0GowmV0LNmZqzyWFcFGhLjOs5d53nZz/7Cdc3e87zifEUCajbVaWSyYzzyLt3qq+YUyZPkd/+3d/lxf4Zj2/fcfvdax5fvyPNBTpRmUHaBn/Jr1U+oqLNuhGHKkgqS+JdqzDHyHg+47ynG3rYqAtfaydrK17b0KXm5RrlrDzJ9j0XgiWzEefQrlWO3N69Z5onckk6OFszqjLoiLNKShVrMw9Dx+l0Yrc5ct/dEvqB/WZP7zsOD3f0LpDOJ/I8U+eZUjKH93e8eP5CUa9LYOYHPKRcqDMIC8Kt10rjyXfazm80nxSVy7h/tuHTF9c8u9kSfGaFFhVM0MP41lJsaNUKKBtCy7KQlPSnnbMOghpCXMpQLmCYxb276A44dAD2pz/7AhHheDgylkwvwn5/vQyPgw41nY5HSipMp5GHt+9JrvL5b/8Wt9+94fbVa6bzyCA03XxbXzXRbvlC1W8/AQy8WM5g8mi1VFIpnM8juRa8DwxDz7Df2X6jDonZ7IhRvEBRbVRvdRxV/afUSuc9bVywXgAKd4+PnKeROUctJKwAVnpEZjRllZy1OxJC4HQ6cbUbef/+LSF0bIcdne8Yz0fiOHE8PJDnkTLNlFyYz2d8dPzdXxO3v95JSpQ/4gTiPFGqYNJiF9B9pdrEmNRKjhFkhqHig1rcObGHmMp+GHjx/BrvCmpEqhemXPA3DUtC9fUMFNfyFOpqU+e8SkF13lFr1on8p6i//sOge0dRFYFcODw+cC5FA6Akasl473j24jk+BMR7vA+c8kypnuvdMz55+Rk/3T3jv/hH/7ku3ghZIDxBDdbnS9tNhVoyCu7rg9Vcc+Z55vR4pht6+s1Av9GNVsW5Z5zvUFeiSimJOSVinJS/asHcHv5UCofTI6fxzJwUHco5U51ORZKVIZtiIYReJ04nfVCufWXIASmZznme3dzwndcEyoue9TzP9KFju9mouLpXX3DvhQ/AmR/B4Yyc36m1a2kb2Jp+aXqitqKlJOIEzvVrG8S+5yp8+uIZz6+27IaAOEPC6/peTbhRC3gxfl4xwfPKInpuXYAQVF+3UUtqzjRv4/W4TMbsXufMHCfu4pmQEzUn43QVus7z4uVLFVAvhS509Fc7Si98+vnP+PzZf4Of9Dv+0//gP+bV7/0++XDWc14+Ldg6bk+lJeGmlpFyVCmzCrlE1ewbR6Ypstlsubq5pkcR1hgz2TZxpNDsDmNKzKmZD7NIgVWg1EypmePxwJs3b7S1ZKlHGzQvqaxXRSq5Cre3j1xfZx0woVJLxAtc73e4nOmCX9C/EpOuT6WamgM4V/EfqK380MfCGcXkegwccCb3F1PSAbaS8MEvfNBcNZbFVZ7fXPPZJ1cMPcylEJxoxMmSQ7YS6CLBsW6QqyRJZLWYUEDACZ0NuTbnuWWIClYU/GLTdeKoJTPFicPpSE0zvahod4yKkuPAB88wDJzOJ0rO+OB59tlLbm6e8/Pf/R323cD2FPkv/sF/xunb7yiTyqU1WaGLOS4AslQy2k721RRTauO9avIZcyKez/ipYxMzw6YH8ThnovFp1o1dVsAhmWtTysrvlQXJ1fvVqDH3jw9kQ/+LZRzVOR3mtcJWeeOB85QoZaLkymY7MFTY9Vv64NlvNlTTYi45q5angRQlZ+ZxZPrhwVM9qgJNHpUJyw0BLZrY16JdFgU3tEBJaAK72QwMfVClIIFcL/U5QXBmWa5xp5z2S/T84jSaBo4BWMEpt7jkRI4TLT28wBbtr9bd1J+IcebhcCB3jkGEVDKnx4PaUXuHdI7D+czxdNRnIFecE377b/0uL29e8Hf+63+HAQf3Z/7Rf/T3CCnjjJNdba8o9oZONEUVl81+V2k7UgM1q55rdhoH4hw1Fs7TmePhxE25pLRZJ7CtnG0gG6NOzWdT+9CvtcZBS4qdg+PxoI5+Rt1q/OxaNNdIySgaRRBpduKKePfDoKCDb0i15j45p2VYXmqlpMjP8yv+t/XvA//+rwypjyaoLfGZ50jJkXQ+crP/9Eky0qBzrUxWzlROCR/c8kdwlFTxODZDT+dESfzohxBUpxSDm7XSLSYBZRt8g/FtU18tTwNd8ORcifHi3D74PI3MjCXWzuwhffA46XAOhr7D9535W+uUbCyZ5CrFC9ULicLt4Z5tLsoPWdqe0GQdlIuDtZaxCVVdxFIqZr2WmOeZ83gm1aJ/cmbYbvVmlkpAzBmrGjqmgyLQFkWTNymZ83ji9/757/Hw+GjuOq2PoS2IkoU5J+aY6Uy70jld+PousO2VAjCejhzuHxi6Xqe8bWOcx4lxVGrDdrsxGgMIeu278Ovrnd/UsciRVb1ubZp5dY6xNoc4TSRN47DfdHjvcF4Ro1KUotE5R/CCdxWHTu1ecknXRY4nq+Uy3W5C5LXqkJYXdRnpvLqf8fRVvne0Kc+WaAHgRBUJql733Xag2wyEvteK3HsInuwFOkfY9myurnlzf6tJgGWnS5tpOVUx7cI22VmXydZam6Ocxso8zxwPR+YYqU7o557Qddq2LSZJZQVBMVONadaHtIF2zlC8lCJv373h7bs3HI5HdaHDUufiqJIpOGJOtJFG5wpRCs7rV/rQ6bNdYTdsYZPZdD2brqfEaPyujHeO/bCFTtGQPqzt3B/6WIcWWDNJtAWpFqFiG3tEvK5fIthQhEBSJ7KrzUDnHU4K3lWCDcRpQaABVcTafhZgjaq0/qOBEHqfnKi9btdatR9Cdyvwr/+slTjPPDzcc73pGPzeuKE6yV0tkdhfX+FEGDYDJRc6F+j2W2IQuustn778jM+7HX////0fIyUTDCQpRQ0CWukpaCK4iO5b9uKazq79iUk3y/M4Umyo9PrmhtB1+BDIpTDHaBCzYbVVtajH81lR1WXocdWFbdSAN2/eaIuUdv207CvFGX2rEnNWg4nsqHm0wkJjWGolOM9+u6Vzgf1my9gNlBBJMRLnWWcpuo4Zsdb5D3tcDvheroz6PZb77bwQQqAENbfJKV9Y3loA2X178opPCqALsXpp66zeq3a9RYQQHMG5hXb3pJV6ebL2tWpt9hQj72/v2G8+JQm4qnMJ8zTr8DEV8cLu5hpxirLmnOiHgeFqT9123HzxGT/95HOuw4b//B/8Q+Q00Wa0ajUApHFeEZOLEysItc1fDdxqUmbqvlWIKXI6n5mmGbHizoeA2EBwSomua50NnSnIpt+bS1oArnbfir0PwNu3b3UGoCpNrZQKkqlFyKkZBiVEgrl46Xl5r7lP8B4oiMBut4OU6X1g0w1kPytSWyvfkfm/yD3/i4/E1MetTquKM5ecmadRJyvlYjCHJtugD29FEBcQp7aFuRY6dAH1LiBF291ds8okW/toWY0voqUuwceaUqxVuejf3nmCWapqRv+rtvg1kJvtWfABJ5m+09/3QeiH3pJLUX1MaRaMgnhFPt+/ecvp8ZEhpQX1ypVlyvOCWb9s8Bj/NCedcJuSbu7jOHIeR/Mr1k2/iAo9K6/JLYTyGGfmOZJj0s/udYJ1HEdyidzfv+fVd9+Sc8S7VbNNF451KGqOWYsJ53BOKDlxHnu2G/WRPtw/8Oqbb2DS1nMTfE9x5n6ZxEu44FQCC50mD8F//Pr/Bo+UMr0h7cUSeo3XdfRD+XEs4t1Nm0+cWDzohDc0KZO2vjXd2otEwpLVag9mNSSqtU01H5AFEQvea2fBCZLlAsnU4/tX0eCituF6Rba7zl4DYdgOBiG14sORRT9j9ZqUHM8n3r1/z1XKygWttkhai7YhmsvnaYu9ZqWUlMkVE9xXBPV8Hsml0vU9MSU2241pnWoRWWxgJSetouM8P/mMyo2eOZ2PvH7zmrv7O6v+m3SPxm8t2pGYY6RW0Y6NyyoRd54IPjD0AylGzocjp8MjcZqtwxLw4shRE4zz8UjXBcQS1B9T7IIl5cavW87LNhVv9zaWtBTsztmkv3hNZIvQ+UDj7MnyOrJuTG29vaixGiLVCMqXMem8rbfi8cjiwrUMw9W6xvvF55hTZhwn1Q21H1OdVf1R33k2261ubkOPIPS+R7pAciCdp9sOhG7gMJ3YN/53S0xrY59iMWEPqiXXNIqKDf2lmhdXvnEcybng56g0lZJx0av1ZEyq8d2Q1yJL56upIbTPU4qSFU6nI+9v33N3f6/uOhd7QC2ZUrSbFXNmSom+6sBmzkoP8N6x32wN7YvEaWaz69n2A5uuJ/mOEhPTeSTNE94JfddT+RG1AKQBTU9SVEvKtEAKwVNDR/WXfEj9ubXKv8RGG3UKWnwtP2EoOpUFNcXWMjULsjmOqnzNX33aLWZUbeHu4YEvv/hk+VqFZcC2ogpG292WLg+AFi+7YYvb9NTe011t2b94xs4Pqrgh2hqvsHBNl+frMm5pRY3lRzZUlmtZiqCWO4zTxHZSN7JuGEwCTfe/ZdjXdF1Vu1d//1I1pVEEY5p5f3vLu/fvVL8XQ/trUUanFDO4KYxzxPtqyjdqW+y9Uv+GrgfrpDtg6Hr2mw37zZZ4HpnLpFarsTLzs4+G0q9JUNW3NefEPM1IZdHlE2yS1PS4lvrVVc3ic1wm3bwP9H2HmDWcCUYBl848a+BdrKCq+LVU9Xo0LpQLzhZNd3GxLwL5lxFznCOmxHiecC7gfEtGHC44inNL4KsIOqZZp+2tdJ746p/9S/L9mRQLzgjVyon1NqG8TmZLRblaJSFZLVMfxgeiBdvxeOBweMT3nW36kTnPpluqny/nqNJO44lpSuQqbPqerg+Uknj//h3TdObxcItIZbPpqTUvUH57GHKpzEmtUmstJgfmKMVxPI10/hGfKm5KnO8f2Xc75uMJUsYVdbl48+oVb7/7lu2mZ9ht2T+7wXdBuVxd+NFs8jEmcsrqXpYvhumWhUA3FOcDrpo8U1bUr5ce5wNdqEhnsiU8TRrFFspGHCj1cuO3n1kcINrvKGfXGzfKW0um5qdx+vR99HW1rW6+3Rj3xwuh1+JKRKiNP4ss/tQxJ4Ib8EEHD779i7/gdP/ILiVrPbKsvt6ErJsxxEKpKQVXC6RCijNj0liIKXI4HHS603ttm6ZExew4gRA67QbEmRgnYpzJMapep6wTz7d373l4vOfVd99yOh/Z7TbklElldUOSUtTFJ87WrdHno3rPNIM/jQTx9CHw+tW3zKcznQQt6Kx7EueZx7s7vvnqL8j5v43veyPM8aOJ3cujJZYCVCng9br5GlTupa284ui6jq7rdNNAB/WayPeayK0rbhuua+LzTwGC1TK6Tbl77+ldWLtQZU0I2mb7oWsb1VqC1ZJor+oRQx8QKUoB6wOYsHfAhhtDIAlqbuIdc4p8++6VckANPVXmqckdilx0NS66DKVAzrgSIBXiPDNZ7J7OJ8ZxNPDBM00TqdjALFgBH5bnLmeISdv7XMRKKQoeVDJv3r7mT/70jxmnM/3QtSu/ILdton+KqsNdS9XCwjly8YicmfZ7pnHk4e6W78JAfP5SjQt8oHOeGeF8PPJwd0uKE74bSGsT5kd3yMX/V4PinQ90Hdrjt+8vND6gcQPWgegMKDp42bh6Qtm313e2h3vvCD6Y3YnqL/uu0zV3fYmL91zHu2qtHA5H7RyEgK9CcJVhs1EVHSdIcPTbLSFnNtvBEu8Otj0yBFznmeeRX3z9F4utr9ham9Q9BlCg7UncVhQ5zVnzpKzdvalGYo5mGzoxzZO65RUFqYaSNXkuSrnMeSbnaG6bq7JEqaC4i75nk1Q8ng780R//EXf3dzq87dbiUx33lPg1p8w4T3hfde9pH45CcJ5NP1ByYjoceby752qz43q/53q3Y3w8UNLMeDhxc+7498v/7KOx82t7stM8azWXM52XC9kSrUZ8cGy2A7Eo9O1qWBa0thCG0NH3A+B1EMitm3nwwSBhEPWq0Xpf1vBbt29NKqSJ6teqYrIXiyTtun+Qm152WluyVkxdrHptaWarGDSpcCqW7oLatU6Z8f7I+fbI/+c/+k/oz5lkzVElhVsr3GnC2uiGNRhZP+sU6cPhwGE8MFdFce/v75YFL8bI4/2d2oraZjNPkxL9/cDu+oar62u6fmDYbOi7jtvbW/78L/41r19/y36/gZq52u/YDB0pJR4PJ47jWZHjquLrBVYHrixqb1kyN8PAXM/cH2ZuzxFXqvIITS6lSOGhD/zxH/wBX3/9FakU/s5/7d/hk88+59nzF4tQ8o/hmOeZ82lk0wWQLaB5lw+eLgT6rnCKyjv+MFZAixbpoHpFrxt61TqHIbhlQKyIFnNYYqikfZbktKUFznszvqgLwiqAC8rzxqeF7wmXaAAguqjNKTOnzNAFijOk377fwl4sfr0LSK6QKhLh8eE9//j//h/QPU7MtRgbWjcGj7dCzy3i6jUDZrtIKaRp5Pb9yFkys+mkvru7xYlns9lQc+Hb19+yv9oTgg6oDZstOUcOx0dShuAd3dWO7W5PCIGcI99+8xX/+s//jL5XHvlu2yP1xhAC5WlnzRgoMS+DUuLq8qFdhTRHZjcRu5G3h1fcfvtaC8hcqSkT46TSKVI53N/z//v//mOk9+z2e+Zx+GuKxL/sITbsERBTQnmyIrYk0jmC9HRdXBJ/6rruaRFizj5PvtEGTdoOKku7uE34e+9xnW+nY1Jroq/nmr0kT5K25eylgvOcxpFpTkqd8iBBCyi8UA2FUXqBaAKDIo9dEfrqOL2+5R//3/5Dwt2o9rUNlbTPH5y1Gy9QsCJmVxxnejacTifuTzOPeSJ4z5t3b4gxs93s6Ae4v7sDZzrJIRBCT29oZooTMRbmeaIPivh65+iCZ5pO/Ivf/+fEOHI+q5Xjz372BeN5ZJpn5QtLpdWhs1lV5wpJFODxJjU4CxwfHhmyIx0n3nz9im2/xaeiAyYx4nVamLt3b/n6L/6c2V3z3Xf3fyXR9pc5WqxoF+pCg9Q5xPbbNqTkvUOCJ7m0AO+6vmoRX9B10TmHVKX0FLIVU3L5pvZnjQVvmqutk9U6kVIrvnrEW9pb17X2w89RcYzjTDIjl+oBL4SuB6fAjgRTH/Gdrp1oSm2ippRx5t3dN/yD/+v/g3IYde0qbVhP38ubAhEsj6hZSGuC2lehTDOP8yPv0hnxnvP5yOPjkTgnVU6plYf7e8L5aEPBOvgX00DOMymNTHNmnA44UblELRSFeZ54/eY1MY48Hu55f/uGzz57uVhRz/Nsqi566JB2IsZMrZFSnGrhe888Rc5uVBm46pBd4Z//03/KfrMl4MizDke6Uolp5l9OA/8H+dv8/kdi6qMJaoxRSbJG/hYc06zyA8GbHV0f2AwDx3OilGjSSVhT2KN3NtANAyEIYRBwySokuYCaNZAKlRUNBShLS7+1DXTYYrbKV5gR48nmC3/oi836Ipa1da9cj5x10CoXDapFAmr5feWAdOLpzpm/+PM/4ParV8zjrDMvovIoAvTOMQCumAWmmGaeW4dNqJW3t+9JG8dpPHM6n0hxJhUYpzMpRuY0U+KkVmDmRJJzZr9/xpe/9XOGzc4GIrQ1H9OZaToxTSd2Ow9kxKsjUEC4udnhg2Ne5CFEnTxog22G5OXCOJ7pqxDomcczZZ4veIeF0AXi6cC7717x/rYzFG3id//W30ao5Lj/WDj9Ro9pmpQ/nDY62GfSGF1QpDd0hVJmbbvVi03aDuUfq7d3KhGxVnlLAhchYytRLqt6aMWZah22hlQqEWLV6rUWatYEIKWkjkqXaOvFZ2mvXZ1nzoXzNLMdBnxVNQKlEDY+U3s3Q70KhLnw9s+/4vTde95++5ouV7Ksv0cpDNb6UvxfpaB0Ia9LO/Ph8MgoHaNUxhyZzLKxmpzKnGa1cSyZLqjTUHc60YWel59+xmef/5TrZ88JwXh+uXA4PnB3f+L97Rs+eXlt+01h2ASc39B1gfPomWNizkXpClWHHJSigK45VW1aZyAOPZI9eYzUmCElas7kFHHeU9LMXYA//P1/gQyOzW6L4wXwb/9VhuBf/pCLNmXI1NnQPWkb9dOfVWT+Qk5e6mrTKbIMZMClsHxbe1tBdJkAaJsxl0SdKwSIVGr1q9SSiA1SWJJxEbm6rOuanYsWWLlkRbicLC1+tZu1rUgcVdTZzZdKN1fe/elXnL97z6s/+tcMyTh4ds61ouaSFx3h1kEz1ic5qW7o+XzkWCPHMqtsniH+PkX6GNU1cBrxoSmAzByOj7x59YL91Q3b/RVffvkTQr+h6zttd6bE4XDgX/yLf8Z20xOCo9TEdtsTvKOfA9M0cx4nqg24gMnbWVLjRTSBK4lUCilM5G5mmhPzeeYhV9wckaSUq1wSeMfDpuPbX/ScueJ0/OF1UJuj3IfOcsthTlxUp0WQA+eE0AvibaDHsM1mPOLa1HMpDfbDHnpYsFEDWyjEEolptt9X1LR6jyuNw3kJNcuThVae/J+QKsSsw8chVHUZDCbz6NdnSiynoEKOiU2s9AK/+P1/xePX33H359/QFyHV1NIePT/rtyqYKcv5NNBBSqUPHXfHA2cXmaru2+fT0Wh9lQ5ZdHIleEIX6LqOPg1AZb/fm0594Ppmp0o9mw1910OpnI4P/Nkf/hnjeKLrHCXPbIbeqCOBqes4HY/EzHJf5hgvG296e7JKas7jxCyO2fecqnB4f48rolKFMZGmWZVdpFDmaxxffjSmfi2CWozQ3UZplzZRq1bEEfyqzbm0R5oeml3s0HV4ybrBsE6g15JtWtUtbdMnEdMWzaXCtwGYilYqxVGkUAzpa3zDy+fjsu0kGGG4qEd0sY3d2dUupZi+qZYzRRWkefftGx6+fcPxza0uEgjBed0sS8aVDN54fGL0hwv0rPE83j2cyGw5TcY9TSa7M41mb6ctIN2IVY6kDgN973Xy0VcDOLS1NU4nYjxTSiTGCedNy5MCrhJCYFsH6jjrkI93KnfSEGVrlCGeYTPQDz0uC5lMLhFngwDOQQhaHMzTSMkzpzgh337DZ59/xicvX0D58fD4dDGy2L3g+zhMGquJ95cWy3rP1M9YW93ihG7Qqf42rduumxL+Dc0Stfxc3/wpctX+V0ohi1mmVkeVVW+xDXXpGnW5zWNtLd3NU87rkFFtrVt9T3uK1vfNKrB/vr3n8fV7Hl+9Ic6zTtg6dyEjVejtxBcUAwwJtj8lc3v/yNTtGV1ljDPzeSSVjEOY08w0B3LOTOMIw7CgJefTkZpfELww9AHf+Za9EOPI6XQgp4mUBpy3rAOd/u96D9JrK3/StiiiWXnjvdfWFsumhoAqAsQcKTFCiotaguoyZuI88Xh3x+wivgv03czgfxxC/e1oMbAkjsaprmLFiC2ITTkC5/BdUGPOoBu72Bq68iRbJtf0Ty/jti3KTxHaUtSuk2xUg1yYa9NpvqABLOd9ARE0UAFFWotJ/ZRSL5b0ury9ovf6gyHD6d0db1+/5/HbN8zjRCfe3tNG+6omIVTrZBk0oolze+4y0zTyeCicQ2GuTUElqU5lTMwxUnJinEZC9jSb11IKDw+3OO/Z7Hfs91tc6DXJLrrfTPOZ0+mAk63CAlJVGSIIPUE7N95xOI82VKonroWW3lOVWawgOqCTY6TiNNmaEzJOeJtjqKXgqmc+n7l7945THXH5h+egtuS0XGpEX3xPgHoBBjgf6IceH3RwypnWZNsvWxuy7VFN0PDDYx3OWk0Aaqk67GnfyU3pJudWj+l5wff3rPbMYAh8qco/xoo8/SCqaGJUPuccZOXT+lQ5399x9/Ur7r/6jjRG+hCUrtTOqELXhhZZY1c7CXVFUWvm7v6ewwBjqIzzqPzjqHmDcwrWxZzU7rise4nzcHf3HnGel59+zmcvXy7ggBNHjpGUZx4e75inM7vdRmPXqzQb5gwm7DiNURF/G6RqBYGivmsnr5CVjjBNBCCeI8SMxIxLkRI1OfVeiOUt7+Q/Af7HvzKmfo0OanOBWG/kwktDEzp3mfwZAgoYf8eroDMmL1FV1mVZOGsl20Vd5yG/X9U/4YZcBKT+VONXFs3iS2uB/YqBKWkTlyYL1BZHLoJ2iXe9CdN55P3X3zK+e6CcJhSnrNRO/X9zTLhc7BqtSSoX51eNe/RwPkIP4zwxxRlXNPmYTStEP18hZSVUq39xofNCLZFaOqqD5gN9Oj0yxzO1qvxUcE4RD0vIgvP0Q6dIgRNCENySoLZKVNHe/X7Ltt/AnKgeiivLJuKcqKRX53Cd7iSSK+fzkfF8ZDyf8LL98SSosHAXNZasf8KKsOgPtg2bCzcyXTKcA9/3eJ8ueDZ6qKD/+rvtWBe+pQJgXZO0eJBim4lzi193WYTFf/X1a+R9pYSwIEhL7LZyFo2hEgtlnLl/9Yb3X7/i9PaerkLCJrqNiO8sidZ73U7YqvnlOhYez0fi5JgojHEmTlHVEWpmjjN+NG1D83BuyVBKs06AO30+tB2XyCUyTSdOpwNUlfUJxocstjh739H7DnGOnMtCD2qbVq2W7NtnBuj7nlpnimhBQE2GRGoMO5P+inHimE9UKpthw+bFjyN2L49l3f0AKaoNKWyC+lXpGSF0BMn4wFLItmON1/Zn1ZhZefv6Z3G6oxVwBaozGSXTKs3ZpPbamf6ys9cjF/uDOTpVJVi5ZSqrxa35k+cMsXL3zWtuv/qW87s73fCwmYTK8t49y+OgiZ7lp4rwaqRM05lHEudBmF3hcDopqFF14nmaJ4tB5eMtCWTV3y0l2/rp7LJlQ5cj03SklEgugVyUa6sFVsYF6H1HCJ2aEcRiRUOzxnaLHqr+mpotKAdQ2+K5JCSrkot+Pr13JUfOpwPHXPD1+b9paP2VH6vouywV+iW30skqKSc4vAfX93iZcV5UAAdoQbgOERmAUG1w8iPHEyepWpWC0oY7rRvJ8pp6Zpfnv/4DA8NUoafglrU201RN4EOOgORCHWfuv/mO919/x/HtrXa6aqVxvkstOCC0XOki67n49JoHpMjD+Mghe8aN43g6EqcEjYPvMuM0mgOVdWptLfdeOJ8ObLc7vBNurvfr018qRQpzHInzSEwTpfg1dp2eYyceH3YUzkwxE/M6BFyqDk0VBLGByiqineyUSMGrVFtUVyyJCbIqNrnqEe7YyH/60fv5axNUrbTNkcGDXOo5Nv3SUlhccZxWuNJaqSbW771afXnvl0QAGoLZksom+9OK+GXuGXAWFBp8epH0VXJDYU1Mti6/sy6d64PCgkRoEuvaXqwcmsbKq/qHknn/9h2P7+/AeJnJO2ouDH0gZ5gT6trwAexVRQXy9VnRyregrfQ5zqQY9ZoEtcDzzhlSV+1h0MUpponzdCDlSFcSJSop+nB+5P7uvS6gZOY84WtPJS2yX6U4+m6ng2Bep8eHEIjL8InKxrig0lGbricL+F5IkWWRqFJJdeaT51+wfX4DnWM7T5SoyXCKEVx84n/8Qx4lK1rvze1UNxRd5EE/l3KVFJlSh5iAc4HGWVKJLRCbzLdfBKotBpeL00WJ0zb3y4p5+d0V3W9yIjUrWgjohv301TQ5bv/dnpw2aM+6OS+PpZ1XjoW7N29584tfkB5HTUSdY6qV0DskqyFEtyy4lzGsaEB1ZY3dmjieToyidJE8NzqNYxpnck4411qnI6V4augRKQQvSM3UHKkOYk5M05lxPDBPJyqFmCZwQTfvogL9upEFut7Rx0A4K/83JksQctVNy7osPjhevHjGw/09Mp2psSrL6IL363zHZjtQe8HFoEVCKT+a2P1Vh3Zlim1y2QbhVGy7AiJajIZS8V61dgFLaJvg/uXG3DLSpvixJsHt7+W/eVrTLcgqmdWl/sPzbRACut41eTBn8lYtvwZr4eraV2pmjoX5/sS3v/gF6f6EL4BzzLXQdUH1f0smIKqQ4lviVlSoX1mMy/qVYuQxnThkYQ4wThNkXQOS6fl6I1/nnJbk00mg7wL77cC2C5Q4QWjT+YVSEuN4pNZEShPOF3xnUkUlK0hj3PMrtsyPR3vW9V60YZSCan92YkNwvTltzZUqhepVeaWBCc6p+kExiR9Xv3/9f9NHm09pSGp7nowFgojXIT7b55w9rx6lpyzwQNU/pQ2s1TbE9/2j/JKvP+mI0WK1Lp2GerkqP8EqntILc2mcbZstQKyDAWAylUarKrmoGcSceTi856s/+XPSwxFJGeeEGb1fOVdyMoTScBPNblqxuHbcEKWQnMczR+cYq+c8TZSpmGGGFlcPj48LiKDDqfrfXe8IQdgMgU4qJc1KZWxJvmQeH+9IaaJk7cD6Ti3qs2n1Ou/p+8CubqjnmTkmVqVszd8arl0RVH2t0nmHD4EJlWRzFLxTe/iWB35eKv9ePn00pj6aoHrvVSoD5VU66oKkXSIty4PTuEUIwQuboWOz2+JDYCMVovLS2oYrOHLRgaWl9STWoqctcKvUTQugajdS2hiyrFOk3zsugCz9u9oi2dq2F2lsaz/U1V605KqWcgWkiL1nhs5xFkuIpVWP7U3qgkJUsRY6apMmOOZ5JqaomwYVVzqKq5ATNNcSKwA0Wc28e/+a5++esZuuEPGcp5Fvvv2Kx8dbUp4Rp17WpeqgSSXb8IIKyw9Dz43o1OEUE3NO6g+dVEIieM/hdMTvYdMHNjcDuUzUabZk25GoSKj0u47t9RWfbQY+f/k5L158yn635/DQMI4fw5EYBs9g1AgWHjA0/SeHUOyBcehk5tD1bPpBhyScEDwEMk+85tGiqNQWt8sue/HfPEFP1y81dKBg3ZJlk37yDh+8zLLViyDeJqmX15K1dWb6thgR/e7ujnGK1KRDetVpuysK4ArZFfwCTLSWDQrK4RYKgqTCgCOlzIyKnGNuVU608GqfR5wWWCpxokjpeToyxiND7JGqziNv3r3mzevXHA4POA8xR1xRhLPSJIkami10vf7Zpp7QmdvaHLVLYzInQ9+x2WzIaWaeR9VvLhGqUKSCy9RQ6PaBz3/6E2aK6gfWF5xu/w3C66/7aEVt5YJiYqw7a6c55+n7nn7oCTZQ0nWBUDQ5VSRLb2gpantclqKqJeN6820fNkBWLrpIRnsy17pF6/OyG8Evw6OeHo0OIF6Hay9R4VIVVV1S5lw4n8+8+tM/I8/mZlMryambGM6G83Ulx3eqJeOq6gsvJ9PoPdRFbH9OkdHUUqSp+4tuuE7hdZPn0aKst+I255mUZ52zSGr/eDgduH3/nm+/+QoXhFgipEJvOpDKpQqAtk19V/Eu0XfCZuiZo+pppqRSaN55RDyb7cDLTz5Bn+3MY5pgZqUHCOAyw9WGzfUOxv6Ja+IPdbSk1Mk6W9IGNtvkfu+d2abr31UcImqIo7dO6TseQz6rJfPiwHeX7/ZLz6EswIvt9FaTldwoKTqQ3FbPjx1NdQHvcV0PqEnJklPYPi/WEUgxMZ9PvPpXf4pMSqWSoglxNJWfLGbVU01VwF3qv0KRqmitnZ+zdSClwuRUprJwsY+ZK5o+n4VLzfiUVIKvCwKSSXk0SUUh5cLDwwPv373RBLUmpgSb0C2ygCDgqt6fAMEXvMuEDlLVLljFWWOyUl1HlUo3BG6eX9MNPcfTkRz1c0E1cystUH7Kmf8Vf/zRe/DRBHUYAjHqHQhe6HoInVrhKaqkwSSYtWRQ7dBCZbPZqruBoAtkLXg7SXWXUTi4VeONQdcq3yci6Kb/eDnVrOusSjXUlqDWdZnUxFFvva25y/e0opNlY1OuyppsNL5Me7Y84LrAcDVAKnz75jtkFziPmU6EwQsUO4dlBdHNVSyRlqoIc02o/Z1ZBBYnFJeoWXkcbQoVWOQsSi3EeeTbb79m2GxA1CryeDqSS0Sk4NxaOUF7CX0gtVUqyufzwrDpFg9sdZiCeZo4no50DsJuSzd0dENHrip14U2G5eF0oJv2hF2PryoyP6eZeoLjISD5hxeMBtjten0wSZQygwRLeta2SghBFQy0wsCFwH63JQyDVfSVzlVU9dEOC4qVf1e1qBD4de0n9UdeY7UudJmLjf6ioFJWwYpIiIA3ZFeTijZYpTtXs0+1sg5XhXGaiSKIaffNNVO9IhU6ROA0KbRzrMb/q+LIVR3SpFTImc735DSRq6of1Kx6eiU7MtkkVCz+bGK8mqj0u/dvccExzSM+dLy/veX+4Y7j6aTTud46Mo1vXqFiCyAR5wL90HF1tWOz3ZNq1cGsmMiT6u15HKkWHh7v6YLFee6gRmoseNFnKdVMqonsKvvrK57dPEPSC/712x8ehfreISxrnnceHyoUpzbEzrMdeobdjmG7IXhHyAnJgu+s7LakRtHmaOuDsBZTS3l+URfXD95fv9k24pYEtF9heaWmjNIQ1bo4X7kguM7jQmizgxeDrzqW19rApWqSWivEihqTpMIweJIHJ5XilKe3wSnqaL0F7STUBQQpBSQXgh+QoohULJGSzAmqFqQoNznliw+D7SeuMo5nHh/v6PrAZjvgfMf5fOTd7Tvevn/LOB0V+S156cxpNy9ZG7QCjhAcw9DzzAV2u8KYlPs6jTMUNbHRHFlwQRO4YTfoAO3sFk2lSiVJIXSe/dUOui29++GNJpYWvw1Jtan+5sjou57ddk+wIRwd0OzUrdB0nZv5ptZWtp60zVjf5Xvvu9JQzLHq4jtUtPtTyoWoZcs1NEaf6pmw7P/OON0u6NQ+tazAVm3xZhYDtSq3PeqapalJhVKZDXQrLlAQSoYOWTio1UAGGj2wWveqDdI5R8qJeVLXJsGG7KzTmprGmDPebNU9qVbtDJxOB6bpSBr3IMKctBP2+vV3HI+PFDTpTWmmFKeFlWRbv0GcDv85r7Jvu82AC445Z3JSWqV3QdX6vLDZDFzfXFM8dJtATbNajVvOV6hkyfw5X/AP+Xf5P38kpj6aoL58+QydBBW8h8EXdrueEICkXIIUZ6gF1wTBLYCS8Xtk1gnonkInic4lpilQ6tXC6bgMtfXvDwLRKhXNd8sH36pGQ3jakloSCPS8RNqD49bW/hPO5MV/W4XvvHB1dU3/aeC630GpPBD56t23vBxuVOTbKbRdpIGnCp8un60FW1UB/oyS66XoEFb1ikDpYq0baWvJOydUsmlOPjDNEyLCHCdy0qTAO1kSFnFVKSSaM1vCUBAnBMQcsjTBKQ11LnB2lXnW5KNIwXWObtuZcxKGjpuOX0rEOVJFuL275XyeCa4jHndQvvhYSP3Gjs+/+ISr6yuudht2+06Hvax9WIrK9ei1bdWq3u85ziTjCHkqWQq9zNYGDnhz6mjc1gWR/1X1+AUyRCkqWWJtoYaSrdG64KT2q0+fAbEYdubYcTk82BLZ9l5i0kSb7RauC/2VKjW8vX3H/fGRvRvYeGHjgSRrq7W2BZMLZ1YzO5BKqtEsHIspdmihWk0uZ2n2tLzZCblExvHI/d0tMUZCF7i7v2eaRkVnrQC+TIZYitmk6LBpx/adp+tURqZY8hKHGalCjglq4TSd2PsB1wndECgpgMt0xvmtDuY0EXMkFBWolhjtgflxHq17pBqPiqDqJL1Nf6dkQ0wJKYlSnA3y+SXWGs/ZXtH+bgnq9xPVp2AAStFg/YHL9RXKEq/rz9gaaImK98EKrcb/X4tDMcBAk1R1asMJ0vX0e0+JicN4Iolq4UotKFApFwXNxfpfZDXKsOSvZkV+c9OgFDEajqbVpayDZM1pRwTmeeR0eiQE9R0X5zkeDzwcHjifDtSacR5zprNCy65Nqdn4efrZ+z7gPfRVGEohpsw4TNbJas6BhTlOdH3A955h21OnCZc02XWivupziWQKLjj2ww8PDDzh3bOCLZcTJEo3yRSd4TWEuxhFrymJuBW4qutr/7IVtsXr8rMX/FP9/gckALmMz8vVdj11xZhM3i2ERYxe41mWdXgBBKTJDer5Z6z97wOlwilGqhedXieDq+wuikNq+7/WDWNZd1sno+ZCMmBLQBVWSqHYsySXD+7yHLQh1Ece7t8rN1+E8zjx+KhfSzmqdn1pe5lpz2o1qo5p1l3oOs9m0+NCYJMLU0rEqGuPw+NrNfAEUkn4LjBsOmoMOsSVdd8rVIpUTi7yp/LuozH18QT1k+dsdz3eC0LBE+m9EFyhiFo+xjirVuZSmWuwTONMYdbEq2Q2rjL4SieZcdMxzwnXe6scLjaGevHXZb7Y/tTGebWvLq0iWx4b14wL3ooFpVZmxo8xG0UsGBeoQS7IC05tu25evMBvn/Py5gVOHEef+fPDW3YvntFVKMcz1a0V2sI5bfVaoyNUGKeREqyyqyj5vrQEVU/DeR0qC15RvFoyKUfm2dxbnNMWlSEOiHpjL0oIsn5Og0R08XfKdQleeVG1sdJrxZHBZVwQqlOXjG7bIb1yf6VC6D3VeXIuTNPMnJJV/+8JrsOll5B/HAnqT376GTc31wydp5OsRHwbLluGEKxixVqpORcOhwM49Xn2VAZf2HaVcRrZbtRH+vuFlR5LW/SDuG2TxboZquaufvOSuWcL5gVSYJRVaq2KZGKIZwhPng+5+G99WWux9YFnL56x73bshz21FB5q5O7+DV46nA/4AtXZZn7x7F22r6ha5+SUiDVSgm4+Mbd2mafN0zvR5F5c0+90qiOZIofDI/M8EbqO03nlHvmmquDqk0fRibMhLCuyLJEVQw8RS1Q3A9TK+XRWb/I00heHC0IYgqKoXtRCMqp6whwjc5zgrKR+iQ7yT/9NQuyv/VhqF1gmc5fn2vhxcU6kcsbHiK8w+Ewgm5D/TNlsAVn48HBZuP/yhLyVSm3Pay3+YhzlJe9b1tcPtvlqr1D1Z9QxLdiMglPDgaVDZht+4yAK6LBXIPQ94eaabejJMXP3F3/O/XhkJx29d2y8rvrN8rLWdQKhlKo87QpSwFUbSKxZ2425WBKiHFoQSpEFmVpqP1eZ48j5rAlgzgmc53Q6ql1qyQgV7yzmbTCtzW3UWmygMiG+o++cWmajOtulVrabgWwSUtVoK6fpxMYNiIdh35NGj8zVjGEcUgtjmhjjCLLjevsjkPhTXg/UlUcKOvDWIm6UMy7NipSK7snFZeYYSX1r/bul2PhlxD0FgPS/pXE57XtCXalcoGtKC/Vlff4+oCBr5mo/oh1P1W33LRjsu0+TU0VbjUdrJhNus2HYqHPdd28PpFLZ5koQ6J2+xiWgtWAWpa5re7XPVwydR7nyapK0UmQQtw5ESl3s4UWUPnI8Pur5dQGq43Q+czgeGM9nkKJoNtZ1Xqg71ZQEMqUmxOhD4oShQKnCXArzHNUhLlftqBVVSDqeDuy7K4YhUOZATZ6UtHNdi3ZApD7Su3/60ZD6aIKa8kwIW5xU4hwZpyOlE/qrXtsQzlFT5nw8EqunuG7ReVOOni1iOVM7deVIufJwHHnz/oHPXn5ClQ6kYxHI+SWb/OWxyFiIygW1AF2RAQsYoMH4UpragCDV0XU9fT8wx4T00LmwcGdajYRUTSS8Y7jZsbnpeP7yc4Zhw3Hr2P9bX/Ll8+d896//NX/2z38fmeKTzljjJ+acCdIpy1Ecp+MR9+wK3wco6iTlfEKC8XREIXr1La9a1VdHN3RU1DlKdceykdIDbnkCCyXV5QFT8WBPtUVUtDYlOM/V1R4RT64qPi3bQNdtEC9I0GTZ7wOSrQVcQeiZc2GaRmJJePOtrllbeSEHNj98pwmAYejZ7gZcLZQUweSyKA0BnsnZpqiqyT2lTAZDWBKOQgmOsPPcPx7x4uHK0QdHdUGNHMT9qlBdjsZPVuRAlt8Ro7a0Vs2T3zHk4XJINLiOvuvpu47v/YIdS07jhBB6nn/+Kd1nHZ+9+JTQ9fhPrnldzvz2z7+kns4cX72hxrTQbWBFPGoptkjpwplS4hzPbD55xma347tXr7T4ct7QR6cSh0Ho+47QBZvmb1zU2RxvdLjEm+XxmocZgmznsSRiRT3MvVc1CxGnrx0CPnSUokN6joR3WePXa/Lsnaf3G+qoQ4hu420DcExTVK3DOePToJTBH9VxIUOWL0X2K00tIc1R14uaqSmy8TB0QtoP3F5v2Q0dYattSE0OudjcL9/pKU6ADT+0Z6Mljg3LclJNlepJOtvSTZZ2qf3deS3uFACQ9f2cLGP5RazR6h3DZsNP/sbP2BSNXRDmbeAP/uHf53ee/wzXddQ50eS1oNgQTLX3qMv5UCtehGmcSCFDJ8saK85R0UGdZnncCqu+17Zlc4oSgZgmum5QLenaFFCgC94oWusldNYVViQ1AZmgPB0aL7NU6Lxf96xaefXNt4zzEel0uDAMjrAJKhRf1dwmm0vjnBLeJfb9D4+gkmzPj5FiSYv4ql3DqB23elKdZCkFjw6p7Taeu5stvVzT7bcE74hNOu1idZXKGr+X11nMRcwoAcV0kpffFky+TmltUsu63rRiGNY8wrVBNK926JYwIysxZjFiaecmLTl1/PRvfEmYKp+9+JRxmvi9/9cvePdwzydXO66Hgesw2O/8kmX8EiQoCihN48zETHSqWqFgYNY4woE0ZYiyuLUFMxEoORGniaMcqPUViCMXtakuORl5TYweYCdkn00MjS45EYIi/yIOnwHn6AnkrlMKDuAKjKczqczc3t8incpJhW2glI6SRqOg6Z7QTTt+q3xce/qjCeq3337LPM+qj0Xh4fY9z/YDu+E5QfRmJ3TYJlWoVQnPgnEoLCXyztN1g2bwzjEn+O7dA9v9M4p4JARam6Zhfpf37VI6IudMKhDc+vXFRcoqtmWYBGl0J13XTctSg87z5rs3vHx5Re/32hJdt2aLOgtKgew92QulD/TXe3qX2D1/xu76hmHY4Iht2V0RKGn4pRKK53mi5sIUI8/3ezZdx+l0MqeGgq1lqBhuYorKHR02PTsqKUW0OmeRywiGki5aghcRXlC71pIzznbfUoSuc/S91+rHPHdDV3GdNxTA6UPg0KW7iiERlS4KKUdSjNQ0q8dw1SSsr3s2Hw2339zx1VdfcT6/ZL8d2A0qsKy827JINeVc8a7FzEWdU8CJp3Mq2O2D5+FxIsV7ximxv3qB6zZLMWYgdAvhXxG7kLPq2JaibbqlIK/t99ZNtTGkdIFd+VwhdMoHnmd8M1mgcfD0RNq6LiK4PuD9gL/asN3t+cL/Fn8nn/l3/uZvc3j1HV/FjBxfr8/MZZGFyqM4a8ON45lUM9c3z3j+6Se8+u47qhOyVextyMoV0Uo/K82nOk/IfpGIcr6S4oygBY7SAOw5KU27U/90fTBEWM8IAUdhO3RsthtAebaUynYX6DdbqgMJZUU3Og/DVgn60qSwMofDPa7vCV2grwM/AgzqybFO5ma1K0xQWIdMU66WnCrVggJ06qiUiuPt+0ekVn72ky/IBMT3S1x8H0Pi4hmoH5yDDb2ZhJJc/Ewr6fW/Wb7WUtlWKG82G0LotPjz9YnT0GWJp/mm4H3H3t2wC1tefPYFw2bD78qMfHbD3/r5z3l4/Yav/uCPkG/fLwgUCxpVl8/REoucC/M0k52o80/XEaeJ2FrCVCSry5hK7bRkU9fdFDy+ODyeUiLJjGKaCHq2RF3RPaNrmVSdbgL6Hs6jyb/F9na7pYosNtcpRq6fb/C9IC4jZl+8udkgsahiAeBdpVang1vxzJX/tZLmf/2HmQ2UmCHpHyeNn6k7XEU/q6MqIIOnOo3VEhPzs8jnn30K9nWa/vQHx+XE/dPKSikwrcuVSqUTTLZuuUP6a6zFOCtEtny977WdXUU7l0+UBttmIRqz1Vek8wz7HdefXXEVdnz5ky85TxOf/fHv8W9/+pKfPn/O4c0bbv/sF7ixxd36/itLoeUyepxPI6ObyFvPdthwOD3iKxSETkRzgCILLWWR4ss6gJ6KapCezkeceJpUnUPb7V4UqS3tOi57mW5o6raYzThB39cHp2SATofkvfdIhc7DOI86pyAZ8Z4wBGrtyEldOTvnqQLPXeZ/IH/w0ZD6aFQ3oeIYM9REjomYPbmqNZtqXhniZze+JYSCtlVA+ZR9N+ikqdcb2lx2z9PEOM+6cF7yNn/FsXCMGiekthn5+iT0FAavC3IJUO3G5Zx4fHzk69u3/Lf+7t+hXG2X1243WdHWNd2oQHHg+sD1Jy/5o6//gp9/+jlFIOWsg1CwwBJL0mw3ulZ1pRAc4zSTckEG44O286/FKjS1xRMxDhlii6Y5YVihk3M2fc6y+FHjGwKlgZPrjF5t2zjEUevAsOmJSb16RYQq2WBSlZlQ9QHRRdg2Gi3f7H1yJeWIN3RCJV3yQuT/oY+UEimZCDdC3Q5WsTb9wcaY1KgRa0+JzfQH5+g6R9erKHfBkaqQCjag0wwpwPbAJ5V92yjbZr60aHFQZUUm2xnYz4qh+F4uyiW9DTgv5Bx5fHxkOt3z27/1M6i6AejvF9v47d9irV0vaosaPP3VFbFWuu2GYbdTC+LLxFTaudOGRClSzS1K4wKLoyYhhyVS1WR9slMifrJkc+sHQ/3Uz3yOZUm8NL6cobUsG0hbrI1ebe+TFWwrsNn07HYb7u7vlVMsGed1Srw2YPwi23ahWbhWm7sQQ4VndeZhYv8jid3LY0m06hov7Ru1Ft2YTKQmhEDfdXSdx3tHzMLDaebFHA3d6Ww9WYv5VlSt++TK48w56yBl1XX9e/x+W3tbd6LJ9GksruhXMC79HGeOxyPbrWfTbRbqS4vddedQKkDoO3X880IJnu5qx+bmiqsXzynzzO5qT67vtIXcHItl5Xg3cABgmifll1ZNfq+vbnj9+rV1N9pPin1+FjAkS9E9y4qAeZ7o+36JXUQIQZfO0qaZLWXX59Yt3Uaq0QlEhwu9K2w2vZoElIKXQvWVZ892uOBVtzfo9XUuQN8GbpUWk7IO+OQ4m7rMD3y0U2gxVFnoYWsKqUl+MDvZruvx3pGKcBwTXTfxIsNkBjYiag1NvkCvLt6uFVvtUGOWtVR6cnq/BK5c0FOsUBJZ0VD7U9EkzzsdTnSGlJuWxvpytl6GvsMPPaX34Ho++xtf8rN/62/yxX7Pt1QefvENkFRRw65PA7OqbSgVa0o1l7yccK7jp1/+jD/+4z/SnMM5vOVeDX2vNAqkWDfQUYpbZi9WA4CqEmjOzGnAKG91+SAOXUsbVcXqNlNhCPhOaWLivOmyz+SNgPe69vuCBGcqOh5hj8t1UXhw5YGT/LOPhtTHdVBRTs48zaQ4M40TV1fDkhTaqqQJosBaYuhJ6DKlyEnoBoWInSWOTtujWjmmX3UC69/fL6IWL/OVTN0utFURdTlF1I5Mp8xE1Mb1/e0d85y40PZXkMbWcP1gtmGK5V4idMPA/eMj0zwrEmfjn09O0aqR5ZkFk93Rh2iaZ23tuCbeqydrabfx8dwyEdmeLRWRhia9k1Oi2hRe053TTc3kv4oR9bE2vA+IqKxUS3pLVdHeBX1bnnFZPvMymWucnmVRL8qtCk4I/Pp292/y0NhNSK5UNBGrxlFWjprYNV+3U4fycoP3dKEjdJ3Gg4A4nUjNJZNysk2+Vd3rtW+HXcIlwdAvrm4oH6JVC+KHLI+ShrUYqqQSOtM48eq7N/zWz3/KB1G3LjDttQUjpQPe0W02PJ7ONDGzUkzi53ITkctkpL2etUVRxPJ4Oi2felUlsGtbqyU21SSnhuW1Ss3UqBwxVZBIOihYiy2GF4mlCLlqLBdzrHJOubzqeGK/VzONKoHoQKBOYKyfZyl9iy7CYlJ5Jel0YyH9aGL3Q+7dKpuzlsuCFlVLM110iKHvB5u4FUOQIOaKqzpctL6m/ccl+mQB2wrS9X0vfqadm51Mi/FWv7q2iC1rsSwSWHGOHA5HhJ6r7bDEe1uj11iry0sUK5Dwjs3VNeeUkKAIqHNe47isRfkFCGSOPPrfKeucRM4a67vdXtdLWa/p8ntop0WSxlPftW1SHbByjlYUOcgZX9uQj8E07ZnHCqF26UpG9WiFavHXDx3TdKYW1ZcUpza/1TosYqYSOLVebvrcOrhaKNk4l/mHT1DXKKkXAfbh95V2o8lpR9frjEtVzINoHyUZx/oiwlvUr+/RruxlCH+Ati6FXVvPGvLv1rRioaRI47cbf94GM1NMpPlEf7NXmbR6kerI+jrLfTYwIDugCzz77FP6/Y79s2cM2x1t6p/ahqAuP8BFN4+6OEMpAOV4+emnuD/5EzM3UiS0FWNI63QUu1qeWpvzWjWdameAib6veG9AnvJKn9w3adRIaMiTLM9YYbsd9BksqqiSSyH0ig6ECj5ozOIqQQTveuWpouvEEOG6Pn4vTi6PX6OD2pFiZsqR8Xwink58+ulz40EbydzrnXbeK4/SFqs1QXV4CfjQa8tCMuKwRUtQEq49uOIvbnRt18hu6IcV0Bq2K66wtmWUv9YWP100nHPmsayLW0qZNKt+Y12yXcxJ0cqhRZhXE0zl/jgeDgclGo+jTtMvj99FS+Iiamtttmk6/HEeR3JWZKPkTHGWHtnvinMGqeswSDYf8vZ5pYLrHHOctK1ipHxsQ1/KuVJpzijeeYLrlOrQqnqRVffPCNKadbSNXu9jsQfJORUlxibday744OlDT1/6pxnaD3g4F5TDmyIllUXarG2EudaFC2ZqY7higyQiBN8Rup4QOnAJccqXCl1Hysk0Z21DlaZDCmvcrhy89ZzsZ1oRwNrWaTvrMuDEWs2KVfLeq9xJzoXX371dEKFl6W8+fEsc6Lk0O1+cI/ie2/sHpnlmmiPnceSqobdL0nKx0LeuhjjMQJfHxwPRLHk3PqzJk4DyTY10IBefrTZJOaveq1703KY7geqrKSvotXHOmx6fXldXq/GuO+UAGg97jrMlyGY/W0UX22XwcJ3ldW1jsqRCJ9tFpWZ+JLF7mZBe/rtByU3tQcT0e6t+qK5TjrJ34JyqqjivnNs5JvWDB1pUVlsjWjInVZOihnDAGo/t0JgvC0p5Wdg4K1hkKZS1BR6CUqpiShwPR2qZ+fT5jRUJrTBbKSpy8V5iBY8Lgatnz3l3+8ictcM0p7T8zoeFWksUW/abzLJyTomaEiF0y3q5gBB2dau9tyb0BdhaIqtXT73e1yQ0x0RpT4ejVfdLASpocirV9sXaumsDfR/UTTFHO1eNYeed6YJW+xpI0Kvkiiq7QCu2qg59/ViOZa9YpkF5kmo6Txd646n3ONFOoPh18r0h92vh0WJ/PZakEpbkUjmOSx9GC2H4IGFuyKkYGGDdFUPEndFSnNe/x9ORx/tbbq52+pwYqCutDpYlzHQ/rTqlngUkBPbPn/N4PFFevER8oLXOpVz+8uWlExrHK9WyFPxeHLurK1MVaMu8qh/UhbZjlJ+cLGHtLmhNEe8VbdEObCV0xl2uOtS2XCXRz1jt2qrqRbVkWN0qd7sNuVbiSQus6jK+A9cFQM0ppA1QeqUFSGlWSDBMW17Wn380lD6aoO52O3KuzHNkmibSVPB+AJxtjtXIsx7f9xD6hTC7VCqWGKp7xGrz1lCP83hmPJ9Q4QxjLi3oY3stcwQxcvD6/YuAtSxDLQ0Ny5OyVjliThdLMDvVTKuY25NFiGc9E/tedyGdEPNM9R2v337Ht68+Id7fQ810dtGbIHShKoezSVoBMTZNPK0Yi9MFPMYZa44tn19E0TqtcDAkyeK4QqmJ623PnCblP9WqifVlq6yKJppc/J59TG1JqeVrAR0waCiqoWEAvqgkVdviVV1I9djGSZHvq+0VfTfQl+FHs8mDI86ZTd+zGTpWdxF9jEvNiHfgLU5Le+AzSId4HcBRBoa2Ab1Xu8wpTlQioPqnVeEQTTjlYmG0+3652Td5ccEQKkNs9dzWirUlp22GxNNQb9XSm6bRkuInbNX1+peGwosK8cdMjQnEcfv6Dffv74kPB6Zx4trUB5+gCMvL1eU1G+9rnGeya3HSwAB9Vgu2zvvmGie0tqsO1+pznGtm0wXjSKn0mhRdxJaPYsoXigjo63dFTSeUwhEZho7T+Ui1BKE0jknJS3LqWDe3NsiiBXRRbdAMifSkW/dDHs2SUWwauaFATgK4DlxQ7hhxWbtEHKHfKLIoplHtTfbIOUqKzHlGbQkHu8RNYgndMMXey4kllTq06T+4LkvHbNlfmxrkanACFreixXSOETY9uMD97QP5y59S3coVtQkpHQCtmalWOterGUNOpJKpwfPu9pbTPHOeZs7nM9d4pDpbZ/XNixh1YDmTSqya8MxzYj6eeTgcybXgrVBa1jypgFv+6P6xpK2GUFnhVwo1Z2KeIdg+Z8Noix4wVdFVK8J07lZ51bk2OpneX5GGnGvrvr03AJLsWgmIh6o0ltwGZn4s3CpYEj2x66b5ln7e5mTkgraIfaf7C76q3qgLlFrNzCapic+yb5WW+645QNuvqoJSWgSsHasWBY0IiK1X2lZ/2uJfEn6U5+5EOJ8nHu7vuX//nt/6rS9X6T13WcSzAA6tDx5jJOWk7e8qzKnoHm8Sj3byT+qq9YyXCwlVlmQ9xci3r74zO120+9pOoWoCqWCSIaupgSi2r6FzEOtt8sQ4Pem8YtdZP4/Y+quJckvCdUh1wHsFq3KZiabHXp1xdUVA0nIHbCaQS8esP+t+yv9J/qf8w4+E0kcTVOcC8xyZp8w8mrWenXQ1seZuM/Czn3/J/WnicJ5VqLa27Dsj4gnB62ZFsYpfhxRKUe6RExOUxyE8ldD58PgehG//H0JgGDq22w3b7ZYgzizrrNovyinqfEcXOroQdLLZB8Kxjk8AAQAASURBVGt1t6T6+6/vugBZ4fYxqt1XrcLtu1vk4YCkixaTVUQa/2pFKE41ItXatNI58EFt3zofOHGkaYOplWETZtcHvYpek1VeS3eTeU5435GrOpsIOgT1JEu0Z8C3yhCdeDyNk9EbKolCdbllGlCLJjeoDqjawzmCOFUkECVFb3pPzpnee5Ufq/KjKeRjTKQ8KeeWHrAEyymX03lHNwykUk0UfLW1UwTKqnYHYkicuj9FchRVU0AXt9b8eJqdXyalfO+/249XmsmFowuezgdKTsgvuZA5J47HA9PoiFEtHRf0SYTqLpc4TciCbdypJsZ5ZC6Fw3jm66++wh2OpGnCujDKV5X1U4hb40aLGEXQU86k7AgbpfsoH89sY8mWLHhUddxSocsCC0etCd97KNW6GAmHIyXjP4tK6kgrstpCG/wFciL2Wmt6Wm3Tb640YrItygFsYtyrrWIxN7VcI/XSqOYHPJbhT1hQIeeEPvQU1+mEc1It39padeLwTUXFQAAnLGYpMc6cTyeNV1mLWOWkzpaKfT9D/2UDKmLuXlVUH3tBTmkgS0XEP+HxOR/03ha1GJXqachvSw6ldSEsSS29hk/KmSlGcvC8uXvP6/dvyfcPjGPkufdIWYXhl+LDmR4lIM4Rc9Rkx0ExFx0V6q+LL7lz3hZ8lSFUJLlCdepcZXMGuWgh73yHd56YMykql9/5Rq+wh9vQ0mqdrOAUwQpW7Ck/Vd9HJbDQkqFWq39taMtje4EmIOsQmq5dafpxLLyL9JKAD0Fb07AgmC3pFu8Q762loSo2znvr6qk8U8kN/lyNUi6mBp6873r/vx+v2qVy1mFpryNrUVOf/r638xDRQeLzaeR8ntRJMjTEkUVByDmeaJaCovtTjITQ0e12/OJP/4Qv9lc8Ho5abLqgHQtL5qS9KKy83VrVscniLc2Rt+/eGV95zcOK08/lWdeLUpobxvq6xRzlWmVZyRpj1gUXLwQJSkWxX1soA1ZwNZpg6AZiSiRzlsMyONo0Um3xeVE4WinbwMOXYeJ/fv3mo/H00QQ1Zx0yiSmTaqX3nQpAZ72CuVTVzSyFOc5M00iKGarpm9aAoDpapSTVIdDVh2SpvDqNONzikVuXC3jp6KTFhIDzi0bdUrrYsd/tuL66Yrvd0PtAQ2A1oXKkqMKytcB5VMmDzWaD4AxBFO0KtoWg3caUCaGjirbKHsaJOM14hCH0hGED5/HifDT7aByoVgWnbENEpVKzoSJeK6yYjcAsynFJKasQtQhSiiLTbfHXJ4zD4YDznlyUG1Vg1dhsLY2qfGC8LK4UiGOOcXHdqO3HrTwUWBZVlQHSDbNQqRII3uvkYK+tgu2mow/eprd/RWXxGz7O5zOhE8oA4MmpUhI459nt97h+z+NcSDGSospzlSJQvBLhTdNwkcWoyYYGDZUUY5ddtiS5GHSStcBox+XiubRIBbbbLVf7LZu+VyFwE8FXV53COI6kWOi6XmOzVBVdXqAsWYqrZfJS1oq+FBV5nmPkNCe8ePKckGh8uAtUoJ1vw3va59AFS7lEFX2m+r6HnIlJBfK9KT94YZm+VTMBt9r72YuXAvOUcCEQQkeMcUlMG2uhWNsJ/aduymKTEqLnPY4jOauunqplNEkkfaOKta6yxXZLSkRjuAuOVKtKTP1IYrcdbbMJQae9s+uYkyIpJZucTgWVkGLpVmmSVqmSKTmZk05Sm86mKYtvT/qK8CPfj1E+iFss5HB0nWe33ShdC1niVh+LunTZcl5lbaRkbvab9mPfO1rrPOdCwJCjkpjSzJQ9KWfevn2LezhSYlopBi1mBBsaMQRUdKo7ZTPnsD17Ltrmb+YOrlEdAKtiLzoJsiCn9eIcVRDAQ/CkKdGGIdvwpa6jBtm1IaZSlzpgTTL154slylUuJs6bBF1pFKHLWfP1XEr94RPUCoSuU3pEVMWZJU+ngTar7rGzYaRia0opmZqTDeK2QqcxT5tueYua9nn/y7c9nDSVGtVEbl1SLox/WpJa7TM8Pj5wPp0pueKkVbDtTJRmo/dA0c6LXiPJ5LRc8DwcD3z99TfE21tqKctAFhegQL34N/bvbC1+gFoqp/N5KaB0BsTW/XoZu6KjaLb2loJavdb2TOsz3/cdU4w6ZLhoeGlhv+S1lgTXVmi4SnVWMBQ1Ceo6TxxN815/wVIgMyxoD6ezODdwQKTSu4/fv48mqDFG5pisbe/ohy21imptSl0kYeZ5Wv40LbpSGj9JJ49jnAmhEezbDL+63XgfGhBMS5CWSgtsUh0aNNKkTgysXKZyh35gu9ky9B1D6AxWVrH9rgt4F5hj4u7ujof3J4ZhQ9/3yyKmN6UhC3UpQGopNBuxlBKHw4GSMp04Ot9RnV7GhiC0fywLsCXXsRYjFFdEpxfwPpMrlNQI9rq0TvNMF4Kta44Yrel78cDGeST0+tAU03Zrwzq6SbS2hnEkWyVTIc5RnWZaHrv0LtYSgdo4klY8lIILqvnnfTAEz7HpOzrnKVHsgfnhj/P5zM4NNCUC1ZKsiHP0Q490ntvTnRlNVG2VFjElCaOTXJhP5KybZms7N0vR5YEHi0fjkDapGmeLzi/bjqsucLvtluv9FZvNQLf4MyvfslIZzyPzFKnogEEtmf3+6rJyYxWntuLog3dU/l3keJ6NcyWK1nYDtcanCAcXL2WLZrGkodWFtaD6p1XpJ6VkfHUqV9IQI6MBFGtTVTECinGqpinSVUVT1taUHmIrZENdF6TBuXa1dSOcI20kQGPVENOLFbZaoqvJSZu9VX7Z0Ae8OEIK1PjjiF1oSWGjLHn6wTNGHfaJcVaqjfFnl8JSWpK6UkhyygsCI5b0LBUJ7X7L8rsLCvWkULk47IaIEzabDTfX17a22vBfsYEL01qcTR+6mtyN1EzXtY7Gmsi1zhysnGl9vpTrPMWZY9IkcTyeGeYZf1E4wepfXlDMbUXZtUiTqngxxu0MXa/e5uYsVZaYset/wRmvtdE8LaYKFq9C13ecx9OqJVwu1gTL0L7PntQEreSsCG5tn1u7Vzr7UFhWDktyhaY/4vB1RRbL9+/Ub/yoKGraUUlReeKXw31t+E8s3rhALRsgUkzSqC47cvvT6BZwGZmtgGjHymeu37vi+hwNbDcdgxX7VHV0BNG9wPSGNfEsnE8n4jxroU6jbrR8hCU22h8sJmtVUICsCg2n88j79+/xx9MyYNVyHOxZXz6VAWSaO5elGJIK0zThgtc1M5uW7/L7YsN1ip6KTfc2Dus6KKbNrdB1FJFF4QKqWpe6ZmVs+6GtH3p+Syasa4pTvdim+96oBizJqr2OCK4KTaFWsHjn4/q9H01QT6cTc9QCw/ue66srwDQ4JWlA5axewXGilkTOYhfV4aqS2eMM8xwoWQhGquuCtta7rqcLfYNvaOmhRtXKLfLLNHul890yPCEIGR0AEkw43RxoOqft7Faxff75Z3T9hj/70z/j4f0dn3z26doSs8DItsG3kqTWuvBKSlVppePhsHJUc9YqHFj9eXWxdbXxstQ1Yq6FMRfGVCAmZoE5q91pMZFj0LereSaFQtfpw+mcWNvdHtVaoSbj/FllYsiJa5y/RjixTSs5jy+VmCJu9ipZZZ+1fc5WQDx5YNpRKkPnDenrcKIbU+eCtmedXBajP+gxjiO73Vrc5Kg+5CobkhnnM6fziRizJu/FWVElxm+ciUmUK0WlpkxKjpQLzW9bjxarupk4aQmqtblbRVxRVLEVBEtCKOy3O4ahpwvqHha8Y+iUhhJCwL/0lFK5vXvQBXOMfPrJZ3QhoANBQHWaYAtrBW7v0Uj1MUYeHh+ppRDEsxu2dPsryrtHXd4uk0HWLxTUeCPFSO490eLXx0zn9ZpQKi5kfBWkZmZ7Vn3ocClb604XQQeoYcJEzAnXBU0Aal0ktYSmFmGfRdC2oNNrm0ujCWmxsJpw2nPbnmMaN1s3jSpu4Vc7p3JVDIKfN5Tbv/o4/K96rButoaheOB+OHE8z85zBElBVNrBYaouSffSSC+aLsA5cVuXX5QWJ02N1pLucAVjPpR1NMcU5x7ObZzx/dkXfqTZv8EoD6mzwIsbE4fHAOM62Rjl6H9jtdggat1LFdPqFJ6tNrba2Z1LO1Gni4TBSc6H3HbvB0W33lMdJ77W1zJe8QS7a4O31qlJWcMqY7fqeaZpMTivjUJpT08y0D0/B6ZB8NYTetocUMxDZDxva4FNDw5ZnyOK4rRguNGUWvR/jNDOnol0AKlmqqVRc3M/aYjiTKVTxIIrCtYLkx5CgFkEdCH1PBQ4P90q9MUWPRqW4bNGXWrXVXy2ZtRZ0ShNtTsVenZak6vVdOzSNi1mtcBJpmQSwvJvQdz3Pb254+eKZzs00QX5Uou329pZxnExVSOhCp5beKFXmEh2vVYySYnf5ImEFfU5iiqR55Hw+M50n5n5im4uCWjWtP/wrjmUPL5YIAnGeFWBxYnFbnq73llzjG4nJaHcmL7U8ZUbbu7q5Id3fkeMMBkI00KUll63obDHd5nUWxZ/C4g5VafMC+jyWajMXZaWneKN9qfbQx+P2ownq3d09w/aaYTPQd4EQjD9aVIS1GvcgnmbiNJsuZ4Bi3t2oZ3JJEMcTbuigD2qxGHQx7Lqe0PWsLCYLMudtYle/5rAMPENwgYJWOA0wLsnatSnR90ED1ryXtbUj1KLC9/vdlpefvOBnX/6Md7fvePcuc3O954vPPlHlglqshbtu8rVkckqkVJimCXHClCJpnogpWsVlf6TRFZQ/mlxgdDCGjmPJxOKRXPFR0YEgAe/1bkdDcbIzSZ4ilDLThsC8U12xany7mvQmF2sZ+5Lx3hm3qiGobQq8kHNSC0SbYM41K7IRGiptGNTFAGa1Cii4ys1+T9f1OPG4um5yTi6nNn/4I4TA0Pd4hBQnYhe1VVFUN3A6nyitwi/FrrNay5YspFiZfUGkQ0rFk8jF6zLpm4OUOnW1i+CsUPJmJVtwSwyXtoEKS1tG7BXiHKnbjS4o2RZwL6rt6ATf9/zN3/4bXL1+y5vXb3h8eODlsxtdTHqMutHG42wRKisSJK6SSyEVpQt4GxA8nCfGhwc+ac9etcq9oWRFW50Fx1gLx5I4Z2HKWlCl80gQ1WPU8j7jgyM7IaWZ4BNdl3Fup8LdLUFthR86me9yRYLTIQosuRCTqku6jjQbQb3+QelH87y8TqnZugjV0OtWCawxYdiXFWCqY7kZdnShR7or8o8oQW2DYSozo8n4OI5M00zK607YNokUYRyPQKcyUwC50rsmFeeWCd4nxZVoAhB80NagqXuorJ4WreKdqYFYYi+OYFSfpuMsteKoBO+U4991DM8Hfue3f4e7+0f++A//kPPpiGw2PH/+zCb9ZSkmLrepiiZ6KSsFBIF5nrm9u8PjCDiCE0rodNJezCmrWmGDggOtfa7qLQOlClMqyk8fZ4bNjmQDLDlnnZwXOJ1GZh9VV3YYcE6HC9ULwdqzFTNdSYyzDthVYaFaOYcaXCxoaiX4xsvWNmwV4Xg8Ksrdiipbb9t4uBhCXusH1wejMhg/+QMo4Qc5qijvN+fMaTozp8icVQ+51HU9KkWNJ3LW6+FRG9q5JmavfPCUZlXWeJLC6NrmnMN3DbDSilY7K4YDeFX/WOUnAYG+79nv9zjv6YJRfKy7utlsePniOTkXxmni9vZOO1fzxNB1PH92rYVAQR3RWMe6l8+PgudykTvEaeLu/S3n04mbL3/OLmyYDxO5Hqn4tXKx1NFd/lNE6Q4Xc58lFzqrXkqFOWUGm7D3gLvQ21bprorLhVKd5Uq686QcGd+94zkvSSkbMKymK5TWvYA2ZI1gajLeJLh0sDamzDhGGl24WGIrqFX4Jcy16rW2Irjy6+L219hP1KU9HjrdaHNJ5FRBVPiVJMyT2gjuNz0+DJTqmMeCFw0AFxw3N9fUmuk7z9D3kKO9gwnRFpOZcoIPge12x4sXLxARXr16tQRcm9ZT2aC2COmCroLNOv2q4t9Gk7f2UymZnGZyiYzTyJ/82Z9yvL+llJmffP4pNzc7+k3Qn724BmuSWkgpEnMi18opzvQ5mQODI7dkrmqLyZcOfOAE3JXMuzwzWkXjcmvhCDk4nHi9hUWreXBI1sUoVfXbdp0ia8HkG0rRRzjnokkmhd1uoC2IS5Iqes1SioiDaR7BbVHeU1merhX91FZVa1V7EYI4dv1g/FOPF7+g24KihcXLggL/0EcfOoYuaDJfivIki/LNcsyMp1mduZw6a+Qiai1XPeILNUXyWMgUuiCE4BYN3dB1eNehWXxqc0C62JqsTgiBlDLB2umNX6RoyspbrRXGaeQ673TxtbZTTlF5hEWgZkqOiFSePbtmf7Wl5swf/as/Zr8fePHiGZ9/+slCO3C2SC4oUIGatN07ns744Ig5UWJUVxfvIemSouCi6fUiVPFU74neccyVsVRiNk5nzFTncb5HnPKOctJrFpzYYIhDJNLrALfuz7ileGoLJjkvz7Ym2yo2XXPWa+KEJJXg1ap2Qb5SJtZEER2TWskNTocOqaaEYHxYtJvS+45Nv6UPG7PrDfxYOvzZBg8qxSxOC/M82wS4I9eyaC+3iQopQowjTjI5e7wIXgrObzTJdB7ve1jKIitCAAz1X3iBUi8QKENQZS3WNccvTOOEPLvWdcDWvVoSNTuqVx3J6+srrq+v+fqrX3B9fcWnL18SU2KcZzZDZx0N1b10rHzYxvdsG33KiWk847tAypnTeWI8nnjpA7U42/pgIWxWDOHyJBGic0wIU4E5VbJP3D88WOdKYyZGpUkUUURTaf/OBpuqItXC0sFsibQrFd+FJfI0UVHf9UYfkLYGm+A6om5rvq251jWgFqpky3TQhMHQ36Yx2/RWM4JI0HslPwJwwNDjOap8XS6qRpEbVayCr4WcZmL04CDgKRIgRnqvIEux1rH+TovXFqzKI268RnHgvfseOOIM0KkKH9pYpGHqInZ9rUgG5fx7z7OXL9gMG8afzPyTf/JPcM5xdXXNi+cviDERNt2TtEpz4LIAvSHo4LDrTI0gJcZxhFIJEih5Zpwm9nbfpCq6qIi/0SLbcCgVvCdXUUvmoi34kCpO57bJBaY5EULjSUdyyQzdlq5zZOeUFlgSxRW87e2Nsnz/cKDJcOrv2yBx+3Do87dQjrRCoDq3aMArBcHTpM9aF0x/2RBXTZFohkJaqNRfG7cfTVA7H4wT50w6oNJEW5x90JIF73v2m95kTgZqrhxlovOe7aZn2A70fQdkw4PzUh3ZSoI3/2Xf93gTSM85MY4TuRa7AHXhZLToqG1Rq6s8y8XKaxQPm44vK5FdhW6F/X5PCDuurq+t8iqobW9dqrNlAMUmOVNK6mGfk/K6nLqdZIRkiUhFkWC6gH92Q8kj3/3iK1K7McW4eVU38mDs/WaCkIvWaFqRqXORy0ZxKMGquQy5LC0qkUqfu2UYRWwgQpPPskzxxahtgmpclzU5bdetUjVHXugVnQ/st1ud4HOKnDiUrG2y0VZZ/jgOL0JnybSrFU/QYb1sSVTK9GHAhZ5ahZy1ZhpcRzcEuk4Ls77ziBT6oC1Mh6JNwSw6lUulfNF+M7DZbNVhCXh4eFx4V8CTh/xSv7Q01FTagmDKCXb/alm7Fc2NZzweuX33lpj2bLe9dWKsQrX3qZjeqN3/lDJznAGIOVKKFlrIipi1J1zvpKM4RxTHQ0qcK8xFN27JUJxOboagiJAi/g0x0g1XZbt0gjp0KiMVvCK8lYqjLJxUqKr4gaGotRVQWojqkFpW+kV0pt2rheciWbTEs111wQYHNbZFVEJpt9kxdAOdH/A+kFPH6a83JP9LH20dcxSam58mrTag59UjPueMq05pTFJxpeBqRUoGZ1xxp4OBrWharsPybip1p9P+rVxw9h353rm1r9WqfPyFJyi6XqrslfIIMYMQRNhsN9SSiWnm3fGB716d+elPPuf5s2t2u629anttbRU2XnVJhWQdMgekHCFpt8xLQ3DXs1M01VAmhKnC7B1TrcylkIqDVBlJyoATry5tFoPVknGhMJPovJpJeA/iLXloz7Vo16NIXjsPZncmTrt2miTpJu4dFF9sADkqQFEy1ToApa0DYou4De5ZTrzcGe3aFnA2z+E/zuX7TRy1gUilIf9lAZVa11gdjbTDooN9gULB1wzL9LxoV+OCWiKNG2UJey3FulOmtnBxHgs6d1lQwfIcNZ1pTDYsZyjFQdU1ftgM+BDYbAaur2/Yb9TA+/3tLc+f7dX63XkbqL5IxmDJL6RCSZk8J9LU2ucJclIuv8qM0Na29tF8FXxtK7CnukACosVuyYVpmiF77VKLopiVZiAgNnUfqQSj1hgn1zW3v3ZpKjXGRcseWt5+McFQNVdRrTkt+lsellKyORajsVhRjRSTYF8H2muDl9t7tE7tr4nbjyaovfHg2lCSGOeps41a2+zCdrun22zphi0udKQ5kmb1y77eb9ld7ShkPIEYJ8ZxRrXbNKnqgme727Ld7RGvUimlFg6HRw6Hk0LDnQ5SlVyeBj7QJulS0w+0iGktVTFEsZRMaR72IbAdNlxte7abjuurLV0X9KYtKNcKVNe6tnCaa0LMmsyG4Em+ErFWg6ivbfEOt+l5/sVnbOYjb//wSNnq1L1Ut9x7SiVXMQ1Avfa5avXnCuomkjO+cQwXFFmn79omJk4TWW8YsFRz10GMV6UBlHJkFf5eHyzNTWXhg4mhKt4Fhq5nu90QfDB9S1M+tEEp+HG1+KXqQJEWV4UggWQ8TX1AHLvNljBsERwpVaZzZL/ZsNkEuj4oB9RVUp4Izhl3xtr4QeXTQvCItTS3u721BB0xRm0JloJr7fZWprYM4WkZ3k78yc9UjOphra7zNHJ3f8d0Oi8FxDJoYHHaRrukFVqWvGabuC8msk9TcRAojkVFom30FUftOmbvuBtHJlFv61IqrqgbSbZWvFjMNXH1NlBSKJSaNS6zI3Qeneuzboh9VE0OyjJU5lrctk5JEZrnfErRWstiiXFZZhdagtrkplph2Xjk3nn6rme72dCHns51OBeI4UfgZW5H20gbb2x5vkWsQFT0fp6jbmjO0fWevg8MXQeu4ET54gKquGHP7WWxpJ1Cx2a7pe/7RaUi54sBHzQc7bLq76JxlXNeEUv7TiusWjGcczSqi3AaZ+ZxJI5n7u/ecrUf2O83UDUBwPZs2ztbraxc2piIc9TYso1+sXe+OK8FlKiN+++YSuVYMlMpJFd1otlXUirQ9Hqdp+akxaITaNSxmpn8TC76GVznCGY1WO0kq1RqTLYu65Q4ovMXNa/KBtk1HVXd3OdZi8VckiZ0yjBdktx6+SDbsRRh6HxF8J4agg3G/MCH0eCyfd5GO3OWUOvaKcsQqFTdo2pOeG/T/SbvpzMOq5ptW8uUc+sWdQug4atLgNaLU7II5lJNYk0qlfNapFCrp9ZgPE0FzLa7HTc310itnM5HHu5vyeUFofsUHzZo0dHeXZZntW3sJRXSnChJrdDneSLEaGuTW9f5dqLS5lZUjKngKeJIqI5vspwgxmSdJczZsECybMVoD0KygrxSqqO57DXJyuW65Iyz+7SydW0QzzLZZfBZsHV/LbBWityanLYEVbtnF/fDPuN6f+TXxu3HE9TQ0YcAorqPDnCuEMKw8Nicczx/9gzX9YtLwnQ+I2R1ixg8QiIsk11GRqdCjTgKu92Gn/70c+Yo3N0/Ms4zMcVFUxXv6MF4JnVBE9bPra+ds3rLsySX63UpVn2Mk8pLvXjxgk9ffgIlstt09L1xg1jYo7bYKpW32PmXqghOTpUpJgbnCduBHCdiEXynmn/iPbkPyIs9P/lbv0MZT5z/0d8DceSalxutSZ3ahS0SUoi6S9HgectmRLUEqRmxQCg0lMmI9AVqk9wxWzF8banCUv3oQFULR2w63bLw6pYBVieOvu/ZbXeEbm3tOyP6r20T92Qh/aEPjzdebOPHivKjCQTfs99dMVw9p9vsIAvzFHnkwCfPbri63iycYHEwTTo9WUqyBzHjvLDdbum6Df2wod9uSCVzPJ44n8+qMSuOEDWZapzd3JA9MBOA1hWwtqQtnssU55LktWRBF7cXL17wxWcvCA72u81SperCUKyhZcQ4/U1FNmaVKBrnyKYUvFML4OqtjKu6mUyiFpXhak9ylbd3R1IQEtayLI5SBYoguS7xkixBbVPJztqzRP2ZEDx5MxDMIKFm3ZAb1cT7YLFkn7lmML3Akj25JCSDy6ovLNUGWBbkqm1k7b9boqPXY9Nv2A5beh/ovHKpnFPe7I/pKNYWXlY5USBg48z/Wjzn00jnPZu+Y7vp6TedimfXSC2RIN5490of8oZWNDUEH/TZ/uyLL6i1cj6fOZ9HlQiqdSmomtRR/eASKUBgRU7VRC1XR8bjalJqUtb183Q+8/72PWma2XSBYdOz3e1ULm3hTaM3qyjy74xHVwx9mudRtSHNDSrb0IpUbPjGLSiwnr2Kok+18vZ4YC72TgvFqpKrolk+OO2iVOWjYzMOUir5rM+7947QB3Z9uCjG1Wg6LfHrCHi8GGPSgBSxoqntmSnFNUGtuq8UWnLslkIPGvNylaXCOgH7zZ7dZksJz7j3/V9DFP6bHULidDqQUlFerNPuasAZ3aeyGToFvrqA7/xCN7ruOjZBTLYoLDzO5uokXv3knVOL1H4z0Pc95/NZ39yQP7yjNhdqVjWeTCVVncEQmp647YcVCoFUEiknUtaZkv3VlsfDA9P5zPHxgbffvWKaHrm+1qHWxTFtwRNMv9zuXStCStGkdzqfKdOsQ3AL27QlhY4VJNacoOCIFKZaiRRyEe2IofzsEDx9MCeyUpZi3yGqOVwj1EzOSiEQDzWsiC1o8UduslJVdXyx3ECrKc1TRHBFDZpagjpNk55LUdOUajSvZoZS6truF6syrMlg5+CMdvSrj48mqNvt1lrmoNZ5mph0XYeXSo6RzbZXtBCD73NBcmS/8Wx68KJJaPBK0nWDZ+i2qtFFodTEPJ95uLvlOFZO07jIH4l9IN/0O636bG2/yyMjxFyJTTbEt2aIPdgiC6k/eOUdvn3/jhc3V/ZSsgT1srM1Lojl07kWFSlPiuAexhM3Lz/l+adf4DcPBOe42u8Zuh4XPMOLa9Iw8PjJFQ93CbYbheDHRCJrgieVWlXPz7m6tB+KuGWYXmyDEO8g28bvDGlhtYbwQZhrxmWsQjVNypIo1S2Vewg65R/CgHOdts5Mo9YAfCiZrg/sNhuuNhu2/YDHG6Le3LG8JQ+28X1wT37II4Sgj3mF4DzBd1RfCT6x3ezpNteE4YaKY4wTKWlFut11eFcNwdMEKUgmO6WJQKTmme1mw+efd4xT5HAceffuHeM8EaO2cADEm25e5elkME+jt6GtusqZhIyzbbY2wrpSST779FM++/RT4hy52gZ6E/gvteIamx6ljygX2rVToDHXUi6czzPBOfrtwJwmJvMCys5s/pzHXV3hP32Bl0q8f02Jvbqe5Yp4Xai894r2m2Zue69cdRraFeXu1ZrxRRflGAspWYLaKnuL867LiLTHVxMEXEWqkEm2kWR8ybiaEDq9dg3JrU4Rq2XITxdJnHaEtv2GTTcoV9gZnxtH+jFw+OxYxMNNYmoYBlJ2uO4ZYbii67eUmHg9fcemD+z3G66vN+Q00gXlg+ecOB4e6EOPmOOZ84qy3jx/wbDZ4sym9nQ6cHt7z5wioFPYHx66NFrRptspOSZqzU/UFnQVyKiqhM4p5KpGKp9++im7zZbdduBm17O/2uKDtw3eSnOpWmBL0d9DY7+YWopyX0e6FBfENXnoaVKBOp2cxVO2W/L2/8/cv/5ckmXpfdhv7b0j4pzzXjOz7t1TM9Mz4ogUhxqaggHbgGCIFGwLkgH/e5Y/2BAE2x8Mf5BNmpQBkjYFCoYsw0ORM5zp6e6pvlRVVma+t3OJiH3zh7V2xMnqZtVYQ3ZlFDIr8833PSdOxI6113rW8zxrw5hP/PTz10yhLKimDx1CYE6JLHlJvrMlLDkpJ9Z7RyogSdE7HyOOLV2vaFsuhRpbQaEFWK0FsWeyCU5a0uB9QVzUdXnS6UmZhkSzVAG1WDdD1sJAHQL08wURNkPP0Pek1HNxefuvfyH+/3l0TghhoO+hloFcC9fXN+SkdnBpnrm9ueZyu8F5e+6p5DohST1y2zX03muRJNB1Htf3XF5ds9kYZxzh6elp6Sy0AtfVf/X51aJc/gYKOEP6sGS1jZyNKS4F9p9/9hklRoYu8Pz9Zzx7dkvf98s+vSz71jcvRQWuVVQIFqNqH0phniYkJpq0WOlYaxGt1LyAp8dJT3aBV8cTp5KJUpYuK1WTerx1R4oQU9KSzCn+6aqKqqYM3lWqZHUswS3dJ0V7Gwdbz6Hre0JFEwdDtwVZOtMi6nIT48w4KkjQaGylqQMbyFc562ytiWpGvxZ8YPMt6/Zb+1qNINvUgm45gQKu0gUhWgtSTXhh20PwvVVLXknMXoxz2YY9slg9BONA1eNEMZrqeZ5tBDnaV7uug4b8td/zGR+qFFRcrWV/W0YxRaSowf393R0Xl5eqrBRnvM+irZxm1YKiiYpUqg1Uqsng8qpq0Ap1s0FeeMLQU3db6Ht813O63PDy7p56fOT1aU+slc0wMI4TNUOOBecUKdXLuprjUGRZ8xUI3hm9QDd+yYBkW1h6PmT161wXiHEKvVooFRuLWIvQhQ3Pnr3HzfUzhqFHR8xpJRTnmWk80XUOL4XeQe8dnaj36TItRO8ibZSriJDns1lq3+HRhB1YBd73PTnNutaq2c1g3N0SCWT8xtG5TBBFFluV7cUTgq6hPjhECimOHPYjxzFyOE2MkxnGNxWlPTNL66Q28YttwoLyOGvFu0QuSTnFfomYa/ue1sYSjqcT4ziy6QfK4G2N6KbqzvpcjYaVSka8Pp/RqB21Fp6Oe7bXt2yfP0f8nup6Qt/Teb23rgv0L54zX14x5sTuk/dxpzvKPEM25X024QiV4jhLkA29NDQW27yr10glsSi7pJqy36K8OH0GXZEFQZJGA6DgjLunL6n/H/qBeU4gTRkqZqptbS0zZ5fquL64YTdsGEJHkDYjXhM6h3tn1q5u0A7voRY9z80m4EKvVltFNwhI9H3PZnA4yYTO2Thpvd5D701oF6m5EILwve99TCEwzpHpdGKeZqY4M8+6KX9Ty63hubWaOLO4t4qu9l3aFtSq3gfH6TDy7NktVLTApTJsN8Z9a4pntDhropEz4/yWCFJV7HgYJ3aWoM0501WnLVFRG0MvTodaXAx0tzc8v/6Q+PkPycW8n1OhdPacOq8FlfkbYxw9quESKgYAFBWsYqp/s0VSMdt6bUoDEpK6qdRi/qtv0XCa64T9vejPLShWEGpRIZs0uoGonVSbBnix3TF0PX3o8EPP9mr7l194f8lDxLHZXJidWcWFDu8dc5koEilS6YPgfNECXLRrmHNhikdtNRfl7Yqr3Nxes7m4oN9cUpznNE4cj0emeWKcZlLSpKnrvlZc1sZHx3i8jsZbVQspGxXKEmm162TxqKJtdO8d3//+9xBg6Dy7Tcdu29P1/drZaPff6XuY6kP33mqFRsrkmplSwtVC5yB7SHYvPQqwZSCKovTd5Y5wteOHf/pjTrWQhSU3yjkvg4RSVtplMcRTZ2VUBZycnYsJnyTq5ElXND7nkimpLvuTCCooN7GzUJVni065XAZvlESME13fa5KNrt8iK8K/5E+FdViR6O0IDqXgef+t6/YbE9SUEoiijt45m0VugZ8MUvDOLCQskRUH3bZbPB21q1RUaVmwVpturN6r/2FKOuUmpWRPqtjGvkIyLfvWLL9bllYLDD47tVexXmdrqWA3TmolJ93IalFRS9ep0EWDIIYCm6qvtVgtyVMl6UoMFjGUSJSnl3zHGDx+01O6juA9c63cjRO744nH45Fpnuk3W11QWZPeHESn89iNVPpn2+DrkqC2c6E0o2YrVoSlWinVxvAJ2saoFWTlupaKJqlOA/Nud8mzZ+9xdXmJcwGsBZJTZBpPiBQOTw+QJ+Xaus7QtZYMOENQ9eY4oJgn7Hd9SFNwLypPU0p6wVvCU1E+kpfM0GEjcAvBy5Kg6qbB4perDgranq/WbowxkmJeNrbz4qrljGuh10qQNTGraMKlJtWBFcFHg54FVp1s8sT+ac8nH3+0BIJlbdg6XdCsyrIhZuOdFjvJOSWKE/zlhSZo3YDbbvBmuu6HjnSx44DjaU5wsVXU7XBc6DIlF4pvDUjdB1rZcp62WO6hKKgl6O1i6SZl94xKKlWnrzgW9BgsLKw/ho4DDlxcXHF1Gcz6S/0g4ziRS6KSzcmjMHSBTTfQOZ2wEpwJLJxHbGTsu7J2Q/A2MhN8Eby3TdihRWkplDSx6YWhhy4UPIXgAFcW8KDvzIu36nXApmylGBnHE+M4MdvADlXUNleUFd+XtsCweFrX1nVTadfQqD76/UthbWtSNzbISRHQ3WZ422ZKYDHmt4je7rcKWs3asOp5HqeJzW5Hf31FcZMmyp1aRFRR7r9cXjIPO+TZFbuP3yf3gTIlpYMWTYpKsZZ6tTGmi/1bXfaEliC3r7kqVohaYdbQo7ryI3O2salFOwtigqnWRVmTVGuRLQ+yxQQDZGq7osbFpCiq3odOaSpBvZPJAfrvnoPqvbacndMY5oNOlSo5UXLES0FQRE5pV9qVEirZqy2Xl6r84pLZbAfEZ3DCOE+crDif5pk5ztQqy9CHxbu31l+OPRaQ1Mc8sXJVZEmk2noVWYVGfd8zDINSTgQutw1w82+9/vkf6lnMLTWTS9IpakVjbo+j6wMpF2anhVWjdIGjSofbDnTPr7n+/ke8+ef/NbNAQkV8oa1Vr/qfVAqhfQZbQrVAK5u0u6Ex1XshprJej7LS/nSPE0IuJFl8E6C0iYbrmq1V3Zx0UIhbn9e2/7SYsYB8dqlF7NKvXuHftm6/OUHNEz5oMHEeS1BFofmqOb9zlVDXTUlEzIbH21cyjUvfVKjOeeNfKsF3nGYOhyNxbje6CXVkXWC2ApwI/dAsftoyE22TU23STl0uLlbZCGqzg3Fcri6v2O2U6Lwo78QsoBzm1dgSVE1Gc1YldEyJZjxdnKOEQHaeg1lqhKyk6DxHDoawnY4T8zRTcrEJKNUGHRTliBZWVT0LTXl5AFoAz5bJrpt6+10XWSrKrWoEdPGKWvslQW2edI6+23Cxu+bq4lp5WBYIa8mkFCl1pkyReVTRhTd7KRFFu8Swe62aNAFMKX7jgvv1HcrR1QS1GYcVtTlakA9V8fah4IIwDB19VxfHCj3WzbqZnTtrveqeUi1ZazmlVVJtw6EVUbKoqJtfp254lWa50WYea8Cwqt/OdZ4j0zhxPBw4HvaLgrWK+f9V5Uy/nZyyoDa5KWvtnHIpFOepmw10A3UYKLstte+REHCbjqcYOUwzTzkxO0ffDQQfiMVGbaZC8Vm5roKiD7LovJdP3jbgYsIpNfYrtoY0EbXwpnZDbeRoNeshp56D6jO8xgbvO66vb7i5eaHevGY/Nx2PHI57Vfxn9VQcOk/nu0XQ5ZwK/JwEM06Xd2btKoKqG3hxZqUT0DVcE7mClInLXcdmEILPBFc1QRWz6KoVvIpNQON1yYlxPHEcM0fjmurY6jW5PDfqty/ylmWZHW3N5ZyorahaypO2/sVGOleOxyPj6UTwnovtB8vjUWprjtkEKksU2hOSSybmbG1XXTfjNFEur9jc3OLCqN2D7RbXBUUYu4B7dsMxV/LllquPX1D6jhKV/1eXWK7xsb3vygrU34tlqK09WRF8FbX0lfpWHZmLIqzJF3wp+KocVpqiW1iS2bavtDG+PnT4ZvTvLMmtmcZLXzojteLFsxkGtsOWoevpQkdJnhK++wS17zzeVbWcq+BQVX+OIzXPdEGgznqPxNlIZI3R9B4pOpCilEgpUfnxpXA6HXj18MA8a0FUDLhZgABZf63rdC0y7FYZd1ITLAXU3FI416LJk+CWX32vtmylWVeGYACdrhQDfC0PaxRBi9kUW7valcy5MKXEtt/gd1tiHokEgleQrNh4XUKHXG65/PAZz//KD9g7IdqkplytMCpFfYurckiz6Qd467Ma99m6vU4KOcMc87p223NmnlPOiToMOKeIv+1twcRrmpw6E1A14aYCeKVYDsB5/r/ahYEmwLiVV+wJ37puvzFBrZxsM1U7C+dVMBWLVkLVZfpeFp+uYsilqvnyYjVRsrfWnPFX+w7lKXlSgmlKHI8TpQaQYNHgLDlDp0UVMj4MBOesCnCsw+c7vBQdD5rLKhAyu6RajBBcMsMwsNnuqGjC6ZwoN8EJEh3iFXXD2qEVVJFnKNQ4jtgdJRttYTPsOB4OxDFRq443yymtU2+KTpAYTyc2w8CUhDlNKlxJykupzqvwBL3Liz2HXlLlQDqn+7trybtq9hvxOzX+Y21iKkdwpqqthUJrnwaCGwiupyRh0w0Er1YzUivFaYJ6tb3mVCo1TzaWdk3eFjifVqXWhfj/XR/iE5UIkhDXAQmRhHNFW6dOp5FTYQjql9oFpXM4GnKtSZUTb+4KFrzE87Tf8/j4xPE4E+c2x0jW9SiyPPht4okGPD0aaqSoVFzgwZaw1ZbxFqEmJaTHGNltd2w3myUH1sCliEt2LcCuG6eTFVmPSdeviCLp2TnK0JOc46FWolR69Feo8OXdA84HYqkcjifG04neB0rKxBzJoptSbX4rC+q8QGgAxKL8tGrWIslQfjUuaUtIM5VcVMxQqtJ2FB0IuKJFYsytogfxge3FFR9//CnbbmPuEg5KZZpVPJHyzDQdeXp4DXXEVw24oQt41+mkK+cQ59+Ztdv1HuetPBVz36gViLo+vTD0hYvdQN87fKh4M9QWsfzfqE1io6G9U9Fb3w88HZ40PttYx4WIZ88wsGz0i/ADtCVvCA1V13XOlkghi+rXN6OyoqhpiYU3r9+QS+bm+poQgtI/Spss5BcUxomiP9nilVSvFlNp5YnGnIhA2QyEq2ttM17scMNA13Vshp5DB1++foNjZuOArsN3Pa5U6xIVZpnVuaVaZyNYctqgU6pNkLL9ACFXFceulOW6rPdMVdZKAh/8El8ExUoaPTo3tFrAuY5nz94n2MhtL55UZsZxJBpSWIoi+14q227g9uKGbb9h6DtNcOrA5c3wb3RN/kUO5wtOknGPi3pFl8oQYBM8/eDo+0qQSBBLgkRBF/GCC069O3Mk58zpdOSwP3Ga1Vop57qGFdHo0Rx8lvXaCqwqNLNPRfqqFbiY+w0arxAoghSHeE8xC0InjnGc+PKLL7jY7njx4tmy15VabB84h4cUCNB4nCnZEWMmxqQ+zSUy54zbbtld3VD7J6rv8FuNWwJI1xEuL4k+MH38gvBbn3D0QvVBC72SdRSpKJ2qVkG8tfRpIGFD9a0lKyZgdZ5UBEkN9oOWxGcDCHx1zDkjnZifvK7fVjS2PUWvAaZB0E5WLmdjsPVpRhBKEgMAVBdDqXhxOpY+bOmHb16338JBHWm2AeIyVRy5BkK1dn/vqKmqCszaGSkW5nG29lFCxHNz81yhax+o4slFKQO1YgF0rUpYlLh2CYWlfVcBF7xuWpag1mpG6JSl9ilmdL9YUZUm4lBIfJpmDqcTr1+95nd++zehDmoJJUAXjK8VKF45XM57ipllTza9pus6qNh0qcTgO1LoNbiaDVUqKtYRryhNroVXX33BD37nd0hzIkdFnzRR8WoTi1bQnFeJVXk5uWoQwAlSlCYhwSIgKkIrCWIpqANgwTmzwyoVXwolC67X8aSd6+hcz+AvdFBAVS/T4B34nnmqBNfjXSDntnnLQuXQG9T4p7owp/xutElR9zjdLWRmSoUiEW9m0L6qb616x+nGm5I6NNRStTUqnpwqm+GiRUVqDeQsHPYzh8PIOEVbq8aLtrXb+gfNSi0ER9dvtOI2DhCgCUhWRXkLCC2/K83ZQeqyzrbbLcNmMDQgodWXighT1ip14UPlTDd0SNG2ZDLTaO1caHFVqiMMl0zTyDEWjnFUdDlnDscTl5dXdn2EV69e8ez22dIiBSEnDWhSHFJWq7HCkusAlZz1C7XUNRmoZxxEu04lV3KqVF91zJ9zWhyTydXjayZrCaHJk3SaPDmPlw7nVCG8Ga6Y40hOkUEG8nE0/YJ6DnemhBeLLSLyDq1dPRrvMAQH2Zwy0Md9dzUQggog/LJ1VOtWOaiWrKMG/dOcOY4TDw8PjOO8IkmtPLAumHYH1nNoIi3ANnQMhKhUc3bRjcmKKuk0oS6yeDamnLm8uMA5x9XlBSz4qI1hTJUQtGBsNKdq79dKmFKr+oaKrtnqPWwG0mbDcZ5JTjhRCCUxEHh6PHKalT//8LTn8LRXXnKtlJSoVQVjmoHqh1jM/jWlXAtIGrdf6W2RrJOqjBMKNtjFLNiKtVjVy1bLWhwEVIchRnPxTrUaL977iBcv3ufq8pLgex3GkCPzPDKNo4EiR+bphNREH4SLPjB4rx1DP0D47lX8mOexdikUXQuuErY22W/oEKl0Hh0ioVw6tTWzXEAHSqiF1Ga34zgV8njSKUqN4m57otYSCQgLDaqJoZvjj6tVhcXZLOzqOtXPGJpIS4OyTmyb58Q0R+5ev+GwP7AZBkJQQXCuLNaP4mSJ822tNNCoFTO52njtigrynMDFDrfZ4Ict/mKj3P8Q2HQdyTnePD5ySCd2hwcmCn2/JU6qeclOi9Zio24BCNLqqYVioH9d6TKlgiuNMdqS+XbO+rVCRqKjGywAtM5zgWIUzVIgJ0HNnZQmeHFxrcCaVHMVyqQ4cToe1NGhytIFECqbbsv19opNf810/Euo+FleVEtmbZlpNZIEGx+qJ50yxKQ3OJWCDxsGy659f0FNbeSjEDMgyi3SYtITQod6kbnlgmlOIOcnQxO/LF89q2KU42C+kTUs+uVSq71XYZoih9PI0+HA4/7JMvvVemHxE03NUFfWcZVZq4KhHwi+h2KTVxQvoPN+4YeWUpCsFi+lFKZZJ0j44DhNR8Q7tjtzSVg+j/7uqqMsJKQViapFEVCphlY5bXc6sQqy6v0QhKoqFDUhljOkRFqwGFQkYtOgdBSqX4j4TiA7x8VuS81HjvmA95hdk60LWVssup7rYj3xnR9NQlgTxYoVbwInKbbhGKettWDmOXI6HQmupx+2hM5aPEqu1GJKvG7upVh3Aap4Q7wbegggKsAQFjW2iFaPC/yJVbNe/WZrqbphtthZZGGyNIR6mia1LsmRLjyDEpR36IDiDf3XAFMrlkjOpBzJDYnx3jh4St5vLW7x6q0bU9I54+J0yhRKzJ+niVyVJuO8mE1P1YAtBcmyWK+0GZyNd678JSXvF0CSUH3Bej6I0e2LJdO1eZsCkqtOafNnXCcExNF5nerlpMNJry17nCFLQkYnsVztrjgcR01QfWvxt9agoa7vyNqVuuzEFldW+6SG3AQHYq37VDQIl6rCS0STbx2coQVMzjBNkdNpJKVqHYGWAGL7lq7hNnLWOVWLO/wSI/T8QEo1WpVgGZm+TFEUEWu3xqiiy8uLS5wXOvNb1bjnwHyKc0YFYJiQszaldYvfKpDy3pOTDjIpVRA/UKUwZ524R43IOHE6nkA8IRT2jwdOhyM3t7eU3JOjCe2yWe9UXXclNaS0LMlGW7u4VjAWi7+29ziNC9iAmPbMZUO8CuDF4apflOGtrayT2oSuHxj6gT70BN8rP7ob2PY78laR7hhH5unAPB1I88E0HnqPezxXF21H/O4O50TpUk6pOLhCEMGLOaN4FK0G2v6uLXinMRT9JU5V+qdx4jROzCnZ/WiC02YjeYaowgIciTlDNKs+V9WVQSiETqg1W5yoNP6Gs/2yZB3D2ih/z58/4+JixzI8AgWrcrG9xFrWS5onGLorVsirXyjoI5Kdo/ZqpXcEEGEGeiCJY4qJpzkxnSZePzwwxZmw2ZgfuV+KoJrLQgl0WVSAaq2zWnTrsGRAn0URqjvTAHDG+S5VkdZqQl6zYMNoKGIUg1UHUI0mAX0/cPvsOVfXz9hsekVNayHFmdPhwOl0JKbZrmkmxombqw2X2y1d2NDLN6/bb05Q69qCEws8qSZMwwlWKdfqSNl4CHiQQDdsjZfgQHTBKdKu8C9SSOZl6rwjdB0lu4XE3pLit0h1djSS73miun6PtcYF/bO0CmcVELUaYrPZ6FSWZbOyG1bNaaBmyw/VYquWjIKsKiRpk0f0nQt9FzSptbOKlqDGGBltc3fBM80Tw2ZD13eUqfCvOlrHrc0b1wfS/E4rS/JQ19MwgnQT48gS3HWSlGF9QVtDznmbhtTaTcoNEjH0RoS+V2L4SUwN3TiGy//dcrL1Hdrk9X4Wak3kLGRR5SjSeDlogmom4MotLrpmQwDX6boVIVczjBYz/24JKM0AuXGSVheGSrWBE3Y+TgOaJmQrEqa/ztZtVWpKtedgGe8rWvQcj0dijAydX4R2LbFY2jxLABdyVrPxmOJqGWcer2pwv45hbK2xas+K8x5n6/fh6YlS1UfYh0A/9IxpWjwyF+S3nIu01qezAipyafYsbkEWlsiKUirEElShJSrGnS7rezXOdPABLwF39gsEJ57O93hDMupmx3hSVwqH2Bo/2yxLeWfWbhOLitd1HLwsCR+LZ6hNkMuRUjJSRYekZFN6ex3/qYJUcwCJybylBa1oVn5Yq6varxYDvNPiW5yCDYZZGNqvCC1Vuy+1JXZnirZiHLzQqS1TjDOhJSvOK6JpWFCRiuNMgGLt0lzWX86rTVmxgkfMhaFgiWEyL8s50vfDUjSnGMkpm6NHx5yigRG65sVQsba+dL226yErOnVWhLraeN9u2fS184HyWyUb4lyNWtXoGvLWtfbNj1cCjqDFlrP73mnS0IeewQdGgUMaddx0M6z3js2w7o/f1SFUfLDzrpokBUE5jAINlT5HQnVNW3IqXhNV0Zbx6aQJaozZ0H4tHmiAjB214fG27h3enhLtLEmplFCQmgm+dSbrWQ5hAAttUp2CU10XGIaevutMxKpOERkFaUqxvc+3V2hXQV+71NUzVAWcVpQ4h3QD8zTjciY7YaqFY1YrqjFG6HsOp5OCBTmDAWUxR5w5HdSs+ZWmWWvP7vzj1XWrW3QsKp7WjvKCoNaW7NfFQaUlqGX5ta7/9r3Oe4bNlttnz7jY7izR1/g0TyPjeGKeJwOBEtN8xBPZdB2d72jkuH/V8Y0JqiKDxmqrUBNkieQayXkmxtnEIYFaPeI6+uEC3w34bqDEQoqVOmdKtFGFtQCZripfsoqN2usDJTpSbvwJy9TditCtO+Hbmaluyut0Kawy5Sw7r6Lv1/cDWyucbm5u6PreuGt2Vy1JXd/AbpiR1rVdqyKGGDPFxramnNn0AyIFZ/6QKSeC94ynE8fDAec91QtzjIS+x0v4GkB8noQ33ejyCfSzlboQs0M1m5dqKxAoqULXEhZNGCLGga06MaMPaiu1Uiv0BLy17ldEtNjrZpy1ZGR5oNsm7xe0IVdsSth3f3inbaZSkga4Ei1wKkKTs1p0xFSJWRX4PvRs/ZZ+s8O5oGh+UfNxR/Pq1I1dxGtxk5uA50z1zwIoLYFUC4CmXLZNUb/DEjEz67c1uCSsTTyFEGNkv98znk68/95z/TdZ10jzjixnQpdibaaYIqmkhfi5qjxV4dkHr89jXQO296pYPR4PfP7FF4gXHveP3N7est1tGR8n+wTn2U1dP6P963IBsLEDRWNLrd1b36KARrX2lRaZUmRB0Zrhua5VR+87+tDppo4z5F9MmW/dG8DXigzbpRjQNdwsfJpfX3ln1u48TtTLjdIPnBCCcscS2RDKQpwj87wagTsXuLwcKCiCrI3/AOJBVhGerqVfFiaozT2Lmrhx18QQmIZyi02HQXT8tHI1OhbEvMUpKrVmalbajPjAOI6keSI8u8EHRdhwnmU0aQG3GImr4C2jCn79kwa1KtVs/7Tg8uawUaoZiM9xUQnXCmmecaVyPOzZ7nZsd1umx0lBk+qMZy62SbdN3izSlq2nGjKl8ddqPBt72pKnSkOwUkz4YMIvKcpLrJ5Ss619fR7AENY2Ptr1ONfTuMParJqNQwx0M7PzVmS15/xcTvsdHlUnRXVek6Vcm8NHWVxKUiqQqw1NUWqVs05etfVUxROjUlLGabYuYLCYaYWQxeParLrsufZei9NicdpLQMdEFxyBzhvg3xz9sJTSzrXYNKyUCsMwqHCoZOa50PcexcnVljLZHtvAHLsEtm+2mG5xqwFGRgFxXU8eJ+aSSVE7eXFO5DjjQ88gjjnmxRA/9OrZPOcZFoqVxocqBVdbW16f4doKv6X7ina2rZjSq9bOua7nXuqSyIIVV4uVmkXw2rQ5GuudU/cG7zq8qEuK6x27zSX1qujQoZJ1L04nXn35UzoPnfOM8S+RoK4LDyPer1Bda/mUXAldTy6BXBzHU8QHT9wnok6koxYVFdWsNx8K19cD83yrG7vzSPAEbEyfqdoBMsmipANx59M57dQqbU45i1jDNjdvLA1rdbVc7ur6hhfvfaCWWCJmHaSRRbkzYgsXWrtHF6HyuXa7yqbvmSddQOM48cgjm/c+pN9YS7Soif7NzQ0//dnPubu/J3RBA20tlBwpeU2gHbK0zvCq/NRKsX02PZoKv9ZM1/t1cZ0BsSJCttnkzmsbNqdCDoq/+BC4vNRpGO4tsrmqGZUSEInTiVcvP2eaHgjd15Is1kRWLLhTVx/Q7/pwQK3KhaEUpnpimk6K0Fdt2+fs2F3e4H1Hv9mwGS45jVqtx6RjUTUQmEudC3S1EkrBd4F+s6G6QsqYlYiR8fk6st8Ow0yldV5sU29VKXXp6i/pXa0mRKlM80QuhW7oubi6UvTQKBeN5pFrGzKgRzMQr1mpDX0IS5Bq6yqlxM31DeM4AfNypl2n/M5pnjmeTjbNxSayUOmHfhFwfNvRMNJWqeeSF1qJflA736TVo3SGqmWdTuWkkq3PL3j6MDAMG4LfGG+vs6JL52l7ETB02+HJydlaz4p9f83vU5Had2CTR4Vd4zQhBONmqopfMsxVPRrH02S8SE8IA8NmRwg2dEQ8jd/pKwuVStF7j1RvRf3Xlc/64865hZriGiVFjFrUvs/a2yUrTaQQls2krVlflHt/Op7Yn048PT5CyTx/dkPNrXjKul4tdOeUFB0PQb1ZBWJUz8vmW+t8NRWwIFU7VymbV6qJs8QcDHLOfP76FUXgab9nc7Fju93y5v4NbqGTsRT6y/Nydj/On8VinNVyNtWHsye+oglIKpWatOvktfVEKpFcHb4uTwNOHMF3mrQWVfSD0+JXFL0O4hXdDR1SZk4+UJv3Qa2Mp8qf/9lfetn9pQ8fRN0ygoJRtVbImXmemeeJaRqZxoSTjt32ir7fAh5Shwu6x1dRXcmcCtEStPpWRMT+bDoNUTcdTdab1WVLsKzzZZQD57RLmJNQQytAKhn1XfWdIbRVjfV98Lz88kuohYvdlmEIFFExVTVP+L46UskK5BkNJ6VElUyuiYyOIxcPOC1UUtaJWAWHuE6ph/NEKuqN671y41vH8/7+jvc/+IDrmxuOL4+UqrzOXMFlRU+bpWZ7VmuzdK5nz7crFN+uoP0nbWpk63ypj7ScU4gopBLUnaKYnz1WXjnBB0/fbfB0plnxNhbcbpNvwsSZQGC32SE1MZ/ct67bv+AA6nUzs5wZQTfH7CvjGIkpE7OQIvQDpCyMU2KesrU9dJkF740sLctEiGIVqHMej5qi67xzx5zHBblqm5mz6QWI+fw5Wc39BUW+qiMqXU5BI5sDFlOmG4Su63De0XlDDs2OAXQKgwE1ishUtGJLiQBsZMOzZ894ehpJyfz0qjDNE7uwJXSBTsS4M7I4Bbx49oLD6XFpK6RZk3Xrb2kFXZ1xvqohBI3sYAlg0mqrAjkmivNW/aMPbDHIviFRRVW/re0WnCe43jYpRVhyKXQWIAuZWhI5nXh6fMPT02tKHbnsNktb4Bz21cS2CVZqW7bf+SGWsDVEvVV6raXsgwfXMc8Z5zzTPPO4f2CeypLAake1EueJEBzXNxd0Q6Arga4f6LqknEyBirOW30JNP7tORis4Q+UbYl7NOqdVp7WhVQZfFTF+pgg3NzdcXl3hQ+Biu9E1LNi6bUGlbX6GjoqY96sjdJ7NZkMfAsF5qDrF6ng8cnt1TfCeTd8TQiA6p+MIvUfsGoAG+JQi03Q2YlCWLcOCtE7fNhzNIoe1N4t2R1Ib+ehU2CC2dqVBElkWBK+WSkqVHLRF6MXR9wP9sD3z5G00Fex+rAVmKRocRSrrmF5ZkGqW/70ba3ccTxyPwngqlBJpVn06UzsQQo/vB4awUyRONEktdKSadXwsyoF0ISjFQUC8Z7vZkqpHUhP0lMUi6et0sHPbKUuHNHa1EFBVsLmImuyoFN3EiiJnx+ORmDOh6+iCKu2D87TZjrlU8MoV1ERatQ5tKExJqpDxzuElQDXPYdTT9dnNLceTgiCqiyjL+YzTyMuvvtIOcoXD8YkqhZsXt4ynk32eteOgjgWGprLSopbPVg0QseRe9yQ9z4bflFptQpZbFORCJjtvKv6CM/3CEAYVq/qBzm8ALQy9U9GuPt5q5Y7RYlqB246SYXx8N4qraZrISbtXrgvWolcFvrBhuwkMm0v6XrtUMWtBmpsynmAKcWyhubNuzJrYL39f/kmQ4Jfrs4o0G6C20i9yTuTWRbBiynkF4Zw4U/Af2Z+OfPHFF1xdXnJzfY3ZfhpgoOtsLtAFz5gn1XN4p44TiDowWJzzrvnJi1HlYDChtWI6jpISba/KObE/7A0cc1qw7vfLHlalocl6HuvY9LoUW+dXq6Li0+aHKqFF7MKZ1Es7DuaVKlKgZh1PnSPZDPxbtFd6iQr1VEzcIcZ/V8Gbs/NQsTXSk+XErt+Q04npL7Buv9lmaoF+TXhUZBEBYbymkjPHw0iuQVtKBBBHTtFMsjMpqtq473USw263VVN9v8LiYN5Y3uG8JqMhBHad8kRzzqRkULG4JfsXG8uopYH5JiKkmKjO6eivAtRECL1ZRDQzbK+m7JagVmmqvvWieVrDs7HVhOoqlxdX1PqFVtTVIP+k6n2Pog/qA+boh4Gr62uQyjhfqnAgzmrwbgRiytrQV4qkohfidPNWknFdVpzuD5aQLs+poXG5gGtJEVQnxu3FFOR1CaTZAmjOWd+rZEqeiPOJN68/Z573hFCtHVv0M51v7LYeFqeaXw0dfkeHnVRVzqOYh6vO9tapXCnPlggVVecfoyWo7fpqP2iz6Zljp16ZslV7Ih/0Z13Vh/5so6vkZc53uygtaW7G25o72z1dfo6z9qKG7Ipu4n2vIzq7vqezEadiia4WD2efvPGN7J74Cl1X2W6Fi4sL9ofJ+Mm62c8xKbc0BELJ6uSAog86tz1ogSSaVOcYWedOG/pvnRbnmzerCndatrhs4En9CJNX0Uv1Jgg0o/SK8tcUFCjqB2oTZ3Skq6fvBjb9Rq1sWixoTiAFbQOXRI4Tcdxz2N9DTcvafWsJn12nd+EoSYdlFCnkPFNrwfl+vZZGkaAoVaWUAvOs8bY2X17lX/tuQ8obKgoIdENPjYaqqJxci6Iz4c+CuJytZ8DiTNsTAIqKMdteJw718VWWsfK3KxeXl7R5MV3QscM6RWq1xgIV3bXl3NZPezMRMe5/41mrZdo8zwjqMVxREQq2rrvgGU+F+4d7XYJOSCUzp5mLTb9MaWoLQex5awWOnRVtt2/0hVJUwNd8d2vVYm/RCoh2orAR0AVVQufSnAH0vbquo+8HjSNtU5cz8V47J8EcElg0A6vAz5Cw9N0XV/Np5oRS+JFCOaK8ZT+oJVYYKEnwYQDXkc0rtmlRcKgRvV4gfAiEriMXByXYCHRLOH/F+69rtW1GsCwm9M/LLrsuPBuiwAJMVXQ/PB6PDMPAbrfT+2Q0ooVegK4etXbUzqsrzsAlyDZ23bV8hfU8qIXLix3jrC4wXQiLS4V6MmceHx+tsBTmFHGx4/LqmuNxrzuEFebts7d3UArCCiq29yxFBX5Cyyv0u8/phLVqweNce95VtJqNppKrow2l6LqeLvQEFwi+R4WZfqUPnrl+SC1IELwUHTueJw0/37Ju/+IJak5EqagdjKVxxZlKLYEhntpq09zdOaELQs1VDZovBnbbDdtND5Lf2hCctdpD1+vCDJqgdpueWmEaR7JZQOAr3nd4Q0ycd0v1oAb1ZsrvNXmsZqeAVdfKVfF487/01mpd1vWysOti5SA4XLXZ5hUuL6+WtjjGKcq1kHLB14JH7a7EOYbNhqura4bNQCyROI7W7jgxTSOn07E1fBQpdoFWzVQr+0x0DtVSZWfeAXVNbJbFXyy4i5UTVXTHL7KKb1D/uVQylUQqqkSXEilx4ri/5/HxK+BkE7/SgvbZHFlYHoKWfbw7hwpqlBtaahMNaWssp8Q065jalKyl4oScKuM0U2xkqXIeK5u+s80MmyJ2Xhw5vNe1rhwyt2x8qXHkzn17WDf99hxRlW+GKEcpO7vvhv4KmlQ3H0vlRun42zVBLZYWrO+jYKQ9w6jNzSCey8srXn51b3QRTYhjTISuI3QqWHDO6XONos2Xl5fErG0oK9OMWmPvVkGqPhveOFrFWm6tra9x2WggpVJTpYZi6D4WHW1FZVG6izPsLrMUaCJqQ9N1Hc3SBTH1d1n5tSVF5unE6fjIfn+Hk0h1Otr4LLa3y/XuHIYmaxdTLKFpXFIhJ53gF0sizqoYL1Vblw5MPJVwUtleGLcYUR/jEPBF+ZrVECo1VrcEcXGNWDfUBTTRf1jWpkbNpl7WhLRNlWsXuFbYbLaEvtME2QSx3usz0jjBTbi2xJRiCI6IuWA4+q4j2FS4WivJQIuUsj3D6kLhvWOeZ4Z+4OCO7Pd7S+7cknwUm/v+Fsq2xIn1PNbf7aul8cIrxRVKMMVqu2dowVpyU3fL4u2a2kAPr+fSdzqpyNtUM7H43/bFRZyFobklknNcOiVLglqB+btPUKdxwksldw5xlZiyjujtOlzYEvotc0nEoj6b6pGOIuSSqeLxxVuC6rQQ79UdhGSF6wpTL7Ht/FjQ/hZb4Wxvat1Ft3SqGprZkk0F4+znRbi9veXq6oq+75fOyxJT7efy2fNQrBtBi49Vu8bn4aXWSoqR3dW1Ca31+enUJgfvHClGnvZ72+xlmQTY9z3T6Jc1qbXdKnRu8Jo0zUQrriyXqK3KddAt2Z/lEIZ0tbAusu4oeRGpGqdWRCcv+k4TVBcWsNC7NqHPxMq1amIs4FGBeWoP37es279ggqoWH3EaFdY1iwsx+H3oB1y3JXQbkI6UC13n8V5Vu33n2G4uuLzYKjJTM7VmTdUxYnUIbHdbttsL+qHHBw04OOHu7o7Hh0cO+6MqGnutPIdNr/OpDZbXh1UgZ+OTGSfQrQ99Q1u81yS43QJt8WvVq5yMdXSlF08tqowPFkyH/gLvezBkDpxaaKWETzp5S9E2oe83XF7eoMtFycKqbp2Zp5H7+zc6yjJpa0tEmOdRWxFqILksjmWD9kF9H23ikLak7PAo2kVVBDjo09TsW9CPpQhEnAgeeq9uir5Gcjzx+tXPmKd7RCIhbKBu9J4ZWmdXElZM/exr3/2h1xJ8tuAhUKun5Mo0JR4fj0jY4N2wjC2d56gcpTkuhUwInpubK4ahZ2OcXaWY6IMlztEZCTSEzoRFDh/0azknSs7LRB2xwCetwrT2nUmvtBUmljzUSnWGjNamzvaELtDEeiuXVDRJbclvS1BtUdSqLeLOBW5ubqH+3Ph0inbGnOhLIuDpuk6HbMzayuq6ng8/+kh9GeNEnCfjlE3WscBmqLdE1VAeE9vQhAnNOqqoMKQxQowloee5FFg6F9t5LTQKaOu6KFLgbAQzaJqjs9QbGqb87zyfGE9PHA93HI537HbeuMn+rWJUN/v6jqzc1mZWD+bqKqkoSpNrUFFfjHRdIJeR05h0UETFxIBagFEL293AbdpaUeXwoVO+vxecDWBx0njlUESFSE1kBq1Galy1VRC5IFOtCCyQXaP6WHKKWAFU2e529F2nYh/nlgQVE2y4djMs6Oq61SKxof+bTdWE7jDREKECnKaJ3W7H0HvWWAm73Y7j6cg0zWs3yql4Jc7zIiBp2JNkRatEaB4yy4bfCqhaCjXXRZntvY66JltlhXGspSyLuiHDKWUbk6rlY98NbIYt3oWz5NTTJh2111LNwszx8Mg4PiKSLak19KvAfHwHEtQp0gWPC0rFqDimVAlWeM/zzOk0Mac2zUnXXZpnQhBy6QmdAgXOBzbbHTEJ45yVdykOiluQmtYwgTVX0b+bEhSsmFn/fd3nm3uC6GTBqnEmFy1UQhd4dvtM0dNOBUreOlayrgorxOp5ADNwSNdR8M60HiwdLnUoOHFzeUPfKd0x58x2uwVDxw/HA7/4/BcLYl6lkovu11YZLodDi3nljle1iJIGcHB2Ymh3pWjBk0Ow63MmMBdrRi8Fo9IAcn3bZgpEk9PQmbtH62o3hJ+zPwuL95Wdm35JvnXd/oU4qBVt5adp0mBWBcETgmMYNjqVSTpK1TnE0zRDLXTB04Wevh+43G31pjYlqVeT6d4Lu83As2e3vP/B93RzzIXD8cjLly95dfeGGKNNUtDzOZ0yx3GEJ73pwVqT20F5eSEEfVCMi2pbqBnuV50Z3Ol4PkUK6lnlapMX8JrYnCEYvvOGjIL3nXmpBUDtMWLO+OKVX5fUSxXg+uoZm80tU5yZxgOuFsSpib6TwgfvvaANIrBBUEzTiePxYHy0kTdv3nA6nTidTmYAbYpl2zAaMqqVI4YStWTFr23rKloNUiEnXMlsN55aI04883hkf/+Suzc/o+QnFInySzAvKEF7Vf+DKeh0gZa/IK353/Axx0iMUdX4viyKTa2JdKJZGLb03Q7E6f7SBYRMt1NxhXOO25sbbq+uKDWpD6wZmOSoRYba1vR439NvBh2X2uu0tJQqL1++ZBwjJSVCcGw2Fwua5EQUSawZqToet6RCalZTZvPkvCemxGbTL50FcaZCXWyzdI034ZWuXSsYxEYVoxNSbq671asQtQoqRRMc57IlfnpPt5sLQjfwG3FmnkeKZFKcmaeJ4+HIPE3s90/EGDXwlVVooiPtvFoE1RV90sDl6Tol1MvXY5QUqiGnysJWP9mStRuQkwY7qWL+rpk5zsprdB6hkMuJND3y9PAFX331GaGbkXKpabuYTd6Zml2ov3we39mh6vIG0eSUeHp6oKDtzpKF3WUgpUqcM3NMi0ivpELfdew2G66vL3DmxKAdAX3tEAIihRD0XjQ0Oled16d+yG6hXGhL0CPeLY4umr3pOlVen8ZKJzBXnWyFZGSre0Lnw8L7Dw6CA/MNQJZNSx9SZ8VVQ9srulFtd4H33nuP+/sjtTbKjlOHihwJnT6LBcgPD4gThs2WZ8+fEdOW43SyNq0Kr0AfG+eKdRscNWXlMooWMblmPEH3wKqKZAUtnN0bnTzUnOvANvHcwIQCTrnXfed1bCaBzgW2/ZZNvyWEAdUCgKvKFSwlWeIOKY7k9MA43ZPyHnE2oIOGdDvSO+CQFvqNtu6Lp2RHypnpOOpwFJfI1XPYn8g5asFcFEmcxxObTc/zF9eEXriqV4TQsxm2jFNhzhHns64Zcz9pw3mq5DOrRE0dPbJMigKQ0PxQ3dIRzVUnf1kZBujekPV2UQrc3N4w9IO1rR3BtzDbTKzWYxG8Gs1GRAgV+goXiBZWPijCWxUYmKaJbuhVPF0KpfSM48h2uyOlxN2bN/o6ImQKOUcOh72Bg+v7CiitT/ziJlBoCKiJdltymTXZLyXTdR1d1y2JZ7sSLulUwvMCPmd9xtV/WEfuamwJeBu76t1KiLRc15piOna95kScTuSsegDvvn3dfmM2sVjVFH0wc9KK3m8CfVCjd/O5JYvTynKOlBoNSRJ8ELoOnETLqpUf6YJAmXGusN1tGLYX9KHjzd09j09P7Pd79oc9c4pQ1G91DQHrBc21UpMmAHGOBO/p+57nz5+/PZVEhO12yziOC1rW922GNPbahhzUtADlDXGlajJaFi6qTq1RxXdhAGIq9Fa91yKkqOPe/u2/9jcYNlf8yz/5U3765z8mhIr3Be8TziWGTZv60maNQ728pL54oUhoKTw8PTHPM/v9ntPpRIqR0+kEtTJPE/M4mSVLQ/awVrOzql1/5VTp/LC2RsGEMJmSTkynB46He3IcKSVaImqoRkERBKNTfL16XS1mvvtDuWYRkUxxheAdXejwPrDZOrphwIUd4M0bUk2Xh66zhFur5ottjxfz0HNCHwRPZug6LnZbfOi5uLyh7wfECTEnxmnk8fUr9vsD02lWUn0peO84TpHu0OGDIwTPEDShVbTTAmZG20+GorRA6K1iDY37WvNiC6aPqkecURMMhVKWgfK9g1N++GboCKFXVwrxVoRVMxjX9uc4jmqe7jy967m8vNXrSaKWSC2J8kI7FafDnnGatCjIGpxjHBeeNRHmOem5GLraFNlaEzaV+YqCLHyyrF+v1uqqRTmsVFWYzvNIqckSpUIsSa1R4oHHuy94fPiSeXpQzKNu9XoKaAi3Vh8NIHs31u4cC2lBJ/W8FAHsCF2HqvsDOSW8FzocHs88Z66vL7i40HG43jtzbRASaMJZ1AvUd0p1cM7TdYHtdkO/GfBBvZxfv35DnE94F+i6nlqrcUAtbhSoJLw5V+SYVNksSueiqL9ja8m2zpvzslCzWhFkTANUyNL4zHWhbtUKVRT9vr6+pdaf6sjHs6I7xmRdMfNYFSvGhw2ffPI95nkklqhAS4wcDk/EaSamqOhRVusqJ4HGERVRjcK5k0ajNzThS3Beef2swiyAWlQgK5JxRh2oCmybDsDOHY1VsSRqCQoaiBatauWTqWXk4f4V8/yIyETfV53Z3opT3g33lDlpcRtTodTEnBJUve+lzkyxMMVEzSYsNhrV5eWO3W7LZhiUbmfFdc7qtR4c1M4ENxIWn1/nRRX4otqVc/50o5oIGsO0h29uLNaRMvacJXDagWm0p1IqXT/gQ0dwzuiKq5ioFVQtI1nB3IBOstSjAkUc19fXHE9JP0PRNZ5yYmDQqXad6ntOp1FjfKcgydXFJVOMiooapxOjp4i5PEipiyBJByGsnY4WX2vV6YDNRopaidOse/8Zwuwo5Pa5bH3FmnEiNrJen1EfVHA7dANBWhqp+UZF6Y5m86FJcY6UfOKwf01MM95e+9vW7Tf7oFqLUmgQsJ7EslGGQGkPZilWPWjbKHhHCE5FSF7UR1OgeXA5L9QaFYU1o//j4cCbN294Ouw5TaMip3bRz5PT5da3LlPF5iAnMIR03bT1nMWQrjaJ53Q6MfRXBkuv36eRzS1/axddrVustjcrDOc0mMdZTdC9NG5mW/xVA3wYuLi44oMPPuaLn3+u1aBPeFcR30QzrS0hhmyZAtuqwK7viSlxc3NjptOJ/dMTtVaOhyP7pydOpxNjnLFUUVtLJmpZKlZDAFolWdsGgaG2hwcOhzsqEWpepkuVqiRpqfrai3igVV4G+8u7AaAuBsnJCqJg/KHm7amcuU4fOAzFFCF0Hu+U/tF1HUPvEfOB9U65fzUndpuBMPR0/Zbd5TW1wtP+if3xwP545MkKiprKwumptZLqZMiu4B1MPthkMlVE9l2vNiaWtLkC0rnlvJ1bBym0ZtN5NS9Us6SUtduFWuK07/Rnooz2TJfSpq3pYAcdG6jdj67fUKpw9/iA1Fk7B9K4qHCxG4z3aB0AgRgnS1BnxnHm4eHRTJvj0h51Z0rlsljF1eUxFER55O1zVRVrOmldDlXkUtWKrl2zWjLzuOdwuGc8PZDTiRICC4lbqgmCVr5qFd6ZtTvFSLTRjGL3Rpy2GJ3XwrhYbPB2X5VPmtluB7abgc3QUdFr5Y0Hpj7OYshJjw+dCVGCDg2plXGcOB7Ut1mFcEo98kFl8F2n9kdenLUtre1NXTZ7L1AXpxWAuq5fr9pj1+6xrGK+tehtm6XXjo3zJlYVnUhlVg3aRXJLbFMzf+OZYALVftCYmXZKYSiaoF5d7pSLPunzGFNimmbEeeODK1EEzGWgdaiM4NhGdDtkFbiecyLrEoXXbqvIIpjx1dFJsDGcSgMqktTQzpL32ma4n/bsn15BHem6aiqkNgGuIq7g/XefoMaoAJFzigDXWnUUK6p3yPaMl5ptqpwwhI6bm0v6zjP0naKVWEywEepOHF3Qe6JWj1bcb3pcUC/lnBPjaSQbBxmLK9qWtwS1fc1pSz3blusaMADqg2pt8OAbGCCLxmBxY2liYbvnrsVbQ09rtXXrKx2O3faCcdwr0FaN/mLT/JTzvwpexVxKbm5v2aUtU5oMYMrM06iUsaKWmNiUw+byI7Vxwd36mUysuhZYlqPnlTeNnXsBqGpJiIA4BUhy2x+KosdevLb4bdARmNajVtUOVKWqUasOE0mzKvfnAwX1Kcbxrev2G0Oy90LKmcbTrBWrUjXAOe+oOeriax6ntRCcpwuBLjizjNJA1n41ELqUZAuyMI8Tr18/cffmDWOMloFDEwH9Kr++M917+8KChDTRlP4sNglFg2abY94W6/KarU3aWp8NRkeNr6nO7FO0ihLnKVHHp6aUrcKyBVP1pnrf8fDwRKXn6uqGzfaSWk44V3EuG7G4napVIGbi3MymRYTNMND1HRe73UJ7Ga9vNEE9Hnl8fOTx8ZHTPNEMuXNJpDJTicqVqrxtxm4LVp+zyjSeOB4fGU8P6Cz7Zj8jVnk1M/kztKD9QWEHpPvG9fZrPKolqJb6nxG3lQPqSdWRcxN/6doMQXSCSN8ZZw4dY+gq3joAOUd22w0b3+GCPgfH44m7+3ue9nuO44l5shbi2fNfDKlpvGKRyoxbKtnNZmMVuyGFRflATYwFa5DR/HQtodYSblVzriegCH1dnmSPc+q3qAIbbd/4yjKOsZRC3wcuLi65unrG5eUt++OsxvnO47wmPyKZzbYzazSvqm50lnjJiVwy0xS5u7vTIQPjyDzPOq3FKDA6dWQ2R4GyPMfijX7TnnZDTV1Dje1n2zCJdt9LmRmPT5xOj8zzgZLnt3yCW8prF3R59N6VtRuzok/eK+ddcPi+V3sprwjqZFz14N2ioO96YbvdqGLaqbDCIlczpCF0HRcXO4ZhqzE8eJIldsfjkaenPY+Pe+VhWxx1MRJCIOWZvu8I3tOZy8papK5rcrFas0KqcTVVyIQKWQWLbdg9Xh8UK1PQteyMzqLJXd91+hxbctq2YY15FqOSTUxzQvAdV1fX5qepMa3WRI6XiAjTODEZn/ppfzK+riYqKU06/SZH3bhbfcNqrN+KvKUB0Pj55/t+sdjYflX9FURpFCUpyoQ3f2xE0byaSGnkaX/H8fCGPhSCV8N6alaKg1P+tPffPfqfS1pcckQ0V+iCqvUVANREr9j9DCFwsdlydXWJo9AFsalTunCaeFKHFAS8C+q8ExyhC2y2G3zoSTFxOp20E5YTXaceuc4StdCqIdtnHWhH2FDJSrVCp5oFmO5zwdZ4AwSca5MDWdZt43aI9rItV0AHEDnwDjqp7HYX3N0fl7XSEsZsYjFveW8Tc/fDhvfef189gKsCUinOHA57pmmiJB0dWpqtZGV19JFViEtD75uGBcsyxIZurPm25kZAm+IHmC+7jQJuCW1RVxwv6juNqEVlLmqn1mwDi8XsnCMpjszjnnk+4kICMZrat6zbb0xQuz4gyTaBrDeo73s2w4ZhGEBgmkfmFJnnmZy1ahiGoG1Er75fwYMj65jBJUEVpERq0lnJP/vZl7x8c2DKSSF519DI9Ti3PFl6/FJRodL6PQ31O/85cY5xnhDnuLy84PmzZ4u6+hxBbcG1VUr6nhriU3ZMc2a/P1CoFOmINbMfJ7Zzph+wtpOouW2Gvt/wx3/yQ6if8Vf+yl/l2fMP2T+8NMQu4byNwFxQ4qWha/ZXAA7fObzxW/RMHVdXVwBcX1/zwQcfGA9Qk9OYI3OcORyfmOOR/dOeaRpxBWpRjpUUaRNroSTmcU+aD5Q8Qh2ByjJMyhLaUoGsU6WcWbrAmqfyDgRK0Hsa44RUR+d7hm5DZ9MGats9ilX6ZESUezf0Qtc5C5ZF2/vekoFQkRrJ2XN5taNIz/448cXLX/DmzR2P+71aySyw8vkCXqBm2hVr6y4mFcPphm8n79Y/apAUjscjoFY9nCWt9p36HvU8PZW1uLJfpero1q7bklJmGhPDIGSj0FhKQE6V/mLDB+9/wve+/1s43/HTn31FSR7nZrxPhJCpzNaqd1B1EkzOlT5sDHVQcUpbn+3XdDrx8PDANFlycP/A8XhU70DLJtscOw3k1gFIigYYCKqbhHVtvBTImZxHDvtXzNMjOZ2oNVKrTZpoiW5DHOQsuf/lAUvfyVGBmGZdg31gu92ydQHxHbV6coY6z1SKcpJ9oOsCm02vCHwtuoFR6DvBS6YXuOg6nl1d8uKjDwle7bnmOfHTz3/Bm7s3SwwnsyAtOmq0KNVqNGGQJcYbc5Ro4yC9WU7lqqitxmGvAxWC7gUN+W9IkW6WVoQ0EnDr1hWd0iZecGiC4r2JMsQjotOIlnG42XhueUJEr2PXDbz/3ic87PekeMSJdq7OixwsMRmnTMwJqMQ4czzueXh44PFxb9x/ja2dD4uvpZhvajXEUJFb1g5A1d2/UEw0aIlAVhN6QcgpIhSCU3vEjFNUtUzE+MTdm58TpyfVP+SBSgckRLqlAHgnJH5OkxkXPJ0LhH6jxdSsz1oNmpRHpzFt6Hsutzt6EysHV/GioipHG5MKVRyb7YbtdkfXd7gQdAiPCG/evOHh7oHD/rjYNA1DJPQdXd9bV6xXUZ6YnqRoQdTswoSqcd41YRU01D+YkAhpk6fKUli1npSyLItlviayK/o6oXNQhNvb53z+xd2StoDmCjkXUiqETkVQWCI8bDpevHhPARRsAl+KjOORnLKtzxOHw0F9hlNW8Z1xO9eEW0GRVcPjaAMLQghGT1ntt2rb85uQyZ7J2qg2uRrqrxBrqTrSPdcC0RyW9IkglUKtM7XMnI73vPrqM5yP7C480ul5fNu6/cYEtVkrVOOgkhMXFxd0/YC4QCqJMc4cj8fVlkccw9AR/KAjzU1AU9GMH6uinHikZsbjif3+kcN4wHnH4Dc2HYJFbfarDlXuV4O37WvohffeLJ4Q8yPVf396euJit1N7muYvYWfXLlOtdZkPqw+JIkKnMfHqzQMvX93x5VdviDExTapgj3nG+Sd819H1CZzgPQTfM6fMn/zwRxwPmdtnH/HBBx8zTwdiTIgZ33tZzd6bd15LLRTU1ckuLelu7XTXEnOrfvq+XxcZNgazfoD3WmTUkpFauBw29F3ASaWkmePTAzmeSGlEyHhXSUWheqVtZKhKDVCZoyXyje969pimcvzGBffrOrpeg4vOrA70vQroUo4kazHNo1aiQQQxpWYf1H4jeG3ne1lZx43XGaQwJbh7esPru0devnrN4/GoaIo0Pf7XDzlbY8XWnpiVEFaVy1nRZGWtc3ijG9zf32si4JuCfd3k9SgoPaU9EY1nHKgmlDOqFSKdef1N9JuZ4DeGVimCP46R29vAq1d3hO6S733vUz784Dd4uP+CnPeITHhXVZRkz4jOZFc7o3YOztCL4BzSm4DMe0rKfPj++1AV/TocDnz55ZdMs3JZp3nmcDiQa1TkSzT5VmFQVLGV3ZlS1HZbamGeT3z5+c+4f/0Lan1CiDjKkswr0qVrt40f1MI0k8o7oDQB+iHQDx1dryKGPngN9nhrsyXrPimVquug74W+g+CVs+9CxrmCd5mUjtRa2G06Lm4+IeF5c3fP3f0D9w+PHKeRlI0fV7EOjh31vFOla6tQiEk7ZvM849wNXdctcVb3QbUJur6+4osvvuR0OiGCqpYbeFDXLpV6MahCWzs8qkjx0ryAlVol6NSwWh1xLnS9EFO1JFCRq5QqXbfl6vIZn3zvN/nww0/4v/2Df0DE4VzEe41xbchFo5vcoMbx4qwYz5p0NkrYaRw5nU7c390xzTPzrBxrKZVxylrwVii56rQocwRQZxgxS6VqKulmySPWHha8E3ynlKKUZk6nBw6HLyl5T4xPdKGjFHdm71ZQK8GyTg76Do9hGNhsNmz6ji4o2jnPKkh0AkOnbvi7YTAP2J7t4CllhJQR5wmu0knBl8zlxY7txSX9sGVzsSOEwPE0cjieeDw88dVXX5mAmqVVXWtVnck0KqAtQm+e0X0f6PuOznuGrlceq+2fam0ZFhqV0mCCfk9zATI3DJF65hNgMdpiK5hI1HktSKh03nFxcWnCao8nIMVoKbl1OwtpKXIUfd7trs3ycAJRquXNzZXGrqoTAGOcmGPm6XiiZO0Mx6TF1TzPjONEMncP1UGY8NY6s+ct/pY3VPNvP/sHfBUdY+oCoXoGekIN1DmTTiNcZEqeSUW7aM6ohafTPePpidPhNePxJdtdh9QdDg81f+u6/RYOqqkic6FIwvV5CURznDmNJ477I3OcDJrWhGsmMfqqBH2zcqhkzcb9OimpzR+XCsE5NkNPqurpV6padSgpV7W8rQW/HpqpO0tSGxpCbehIm82tF3ueZ66vrhdEqv1Mq+hrIxPTBIBCxSPS8ed//mM+/+oN9497juOsaj+nLdniAk9j5mKsDBtwAXpLjqd54nA4cHd35Ge/+Jzn732E+B5XtFXnXV4U5s0eo01mWlpCzhkYty4m5zxt/nV7MPVzlLcWm3M2lMBez6OBQpy31urIfDria6akbNWk8VbMA6hmVawLBqcWx0JSqU6DPAIlM6d3I0H13tvmHtgMWn2LE9KYSFFV3/M8aZrvlC899IGhU29cYwmh/FNZKlsnyv15/eorvro/cL8/cZp0is3qbPB2gnoO/Gv763zttcKq+afWs+/Vb8hZx+NdXV2yu9iZvdRaeLWe6OpMybL2wZOLI6bCaUrc3T0SU2IuMGdHPUb6baLvIcZKF3XtT3NGXOBnP/ucV68PzNFzeXHLNB2YpkQtyfh6DQl2lhx7Y3sYgV8/nLaLzxIfRUGCnnGtiqgMgwXrTEqJ0ziSa2SOk1pcTSMlzQS3QSSwKHZTgq5o16Mk5mlPrSO1ROPCFbsyZe28NE6mbSK1ZuZ0+EusuH99hzehZ9f3WrBY2zOlbHOtI4Ii7iFA8JXgK76p0V3RrowH7wpU5QZuNgPJOV69euDlV1/x8PjENM9khBUH+BWIRutLujMwoNF+WpHa+qCsLUZnKH/j/W+GAdevrdf19UFN/i3ONxaizWZfsXKvOKQfSLFwGiP9xji2EnASLIFTE/Ht9pKbm+d88MHHfPrp7/L5z35MSge8jwSfrV3bpuYo2tk16NUJ4hWB2wwDF7sdKWdiSnzv44+Z5plpHJlGpQG8fmWiyHkiZXVDaDHcNb6zAvyaqBagWpLQ0Px29WtmnvZqj/b0mjQfSfFE3ay+naDPSUWoJZNj/Ne3AP97HiEEFc706lFeUf4hViB6D84cdPouELwgRIQIrlh7P5PSCSeVF89uqT6A65hS4vXr19zdP3A4HplSXArVc1QSoOll1K2rEGMhp8g8ixV0gefPnhk9xGJsLWy8ov193zPPcclPmntdU8i3wpil06rfIGCtfXMOWkK0x2+bTVsjsxjyX7XjUEo2m8OADwO3Ny948eJj/uWf/CklCeIy3meCq8sjque3gyo8T0XRUjvn43FPTpmnw4Hj4cjpdOLx8fGMFoCBhAaY2CdT9MI2FCvgxazkln3GkmNsyI+u3ap0OPT9S6nEOHJ4esM8PTKNd6T4RE5boNfzyOlb1+23+qB6b/T0Wimi5OJ50lbQ6XSytlBeHnStYAspOqRmDRjeKTHe6YZQndqoLAmhfVD9kDqtQVvJq6edRbG3t/5GoLCtuZGrpZE8/NrCq6USi4pT3qoOOBdJ2fdbRYs4Ko5pinz+5Ste3T1wmqLOWRZF55zrcWFgc3GJhAuKbMg2n7cK6htpKPPnX3zB7/zuSMEhPuBQW4hGnLdUxXg8RoA3xFmRNlnOualbFf1RaH9lmNjvYolaaMIGndbVe7WNyShBP6dI14K00+SVdsntHpU2yUSxbTVlx/5e9f+VzFzfjQS1KcX7flAbqBDM7FiT03EcSSmZAMNBFZxTVLk9hbVWqmTwrRVpXL5aOe73SsqP0XbtZnPCLwXMt6gp2Pd+7d/POUO6ntfXSzbP+uZa/VjPk4F2NB6SrmFdu22Dj6lw/3jkzf0jX72+I86J4ymSEqRSeNyPDNstfV8IqeoYPGsRPT4duLs/0fVXfP97v0XfX5DziZwms6RqzFa3dgDaZmtrSnywIrMVUmiLlnap64JaIDpMQ+9VpJBJKZKSTl9L08Su91zsLtW2BYjTzOyDmoSnGWeitjbTqF2hFmPeirRGyCg1vTNrtwEDXdAkvBjHX6+DoiHBC32vItTOK+qvFKpiIqRqCGRSr92qCeXD44HXr9/w+PjIOE7mJLU6erx1LAXUuTq6JaPQ1loTkVRZY0/7npSTKqDN/m+NvW29tw7W14AH0eK3WFLarKwqBaQnlZnTGNnOmS50eqdtI40pMwyBFAvHw8Tj45Hb6xfcbV8xjY2fCuKa5Zm+fyliQ1vaObDwIUMIdLUy1KKuCCmT5qiC1ZK52O6UsmL86pgi4zzZflMpNVJqQqozOgLabTABj06sK3ZZC3E8MJ0emaYncjpSauS8eF0dUxqw8rWg8x0cza4shABF16tS2XSJeQ+h03XbB3VzaPx/cdB57VjlPNN56ENPwjGmzMPDA1+9esXT/sAck7aUlwEfv3wuC1ffqTpex4Eq97TBN7ACW7VWs01yJg7PjKcTu90OF0x0tABk8rU3leUrbSw1OAPOtGh3PkD1xveHEtRz1Vv8U4edvHT7nj1/n08++T5fvrxj/3gHTJqg+jbgyNodKBiwqd683/XfLnc7KnA7jpzGkWmaeHh4IMXIOI6M06RJZim2hluyCWp0YDmQa8+/LO4GxYRr6x6kN8FZfqAUlkicj0ynB2J8IsU9JZ0oi4+tJf/fsm6/MUEtDRK24FNrZZpmUqyklBnHk05sWmyNW5ltsHW25LI6XYxFxxQGQ1qWBKhknfVaHS50i6lyMTJ9C4TnkyNW03pbImKCCgugzRQdW47FeBLn+NSv+l3cGXHYUKG7+3te3z2wP46K7iJIUO9TXMD3O9776FP1YQ0VJJLLiYKitrkkpmnk5csveXh8pJKVj+U83hJHPdF2Hmsi3oRSzreqGzB0rLTr0LJRe0SsR4Ya+vtlXm7zTvU+gHj1pqQs9AFXA9V3iNdlsVhnlErNxWyPynp2561AEWpNHMv+m5bUr+2otWqbpu+Ue4oo93GeF0SnWuVaizO6gyM3t4lqLo0uU5zXFjVtpahZOlULquCVq7ckqdICpJXe7b7Y0YoPOF/DleZaZ7TqhZ4SY2SaRvr++TLS8fzVWrBcKmFpCmdFT5/2B7748hWfv3zFm4dHUiw4t8X5Do/wsJ/YXkX6YaBTrQY+9OSSiSny+Dgx/fBHfPTRb+H9hhCUB+ckWYJalmeFZsDfyiXBEIW3D+d0jdVSlop+6RYAoRa2MlCkrCpacZAzoWr7r/nvTdMJL1iCOplziFLiStFxm1JXiZjYtVriBJDfobXbiisfAjXrqGhtJ8+q6EfoOs/Qe3N/cHQBXFUbnWYKrih6xaEG8dMp8uXnL3n15pExZkq1QqaeF+m/VPss59Q4oss27QQxPtuStK4Qq7oCTNM6LnIYLMNtcQrWtQvNP1IsdlUcpTpiLMxR+dKpFHLxxCwcTjObMTFsnXGUoRZhnDK7nbDfn/j885ccT4Wh37HbXlOLJpDizsR2iy6ijctdP7ODZe9zmLOGxdCNig4AuLm+Yb/fq/gvZ8Zp4v7xQffOmpnikXE6IrloexP16VbvSMBodMHrlKAUj8RJebMpHZEGcS8IzJqE/coM7Ts4FCVVQCuXQpwnpBa8tciDX395VxaroSag0tkmmVpm+tCRqMR55nF/5Msvv+T13Z1FSbtHxrdv8fato2lJWPOGZr3UqIi0Qr8a8mnjnVsxeDwe2QwDYp7VK9BwVk5VPY9m6tQcecpCr9I1LNJTi1c+91zoewzxhIan5VwIoWcYttzePOfTT3/ARx/+hJ/PiZiccf9nXVNYl0SvPM3rvK2FzaBjscvVleZiVUWQOSX2j088PDzoes2Z4+FInCdiUivAXMsi5JMq+CLKVbXCqmTzgV+8NYBaaAM3SrV2/3xgGh/J+YmcDpQyIXVgEUX+BYqqb0xQm1m5MySn7xWazakaB3NeLhBVYfyuD3gvpraEt9yvZV1eQ+hwXm+iWtsknc2bwPlqCU+rds+Dxtufq7UTW2LqQ6DfDuCFIhZUik5C0IWnhtbUqqT+5YW1Ve1NWamgmG7wf/6Tn5m6U9uXmqI5qg9kPLiOF+9/yvc//pTDw0tOh5dM40TxwhQnSknkOrM/PfF03DOe7rm+FG4uw0IxWD/iGRJm/7XWwlsTM9HqK+ev04zb5BPjNUnz6wuLNYzgIFfj1FTlyuSqFX0JFOkRszHxlhy0RUiN1JIVBRZbkoZ2jCny87v7b1pSv7ajDUlwJtyYponHh0eOxwPTPFrrSW87TogkjiRK6ejc2p6u3sQ30i2BLuesCnNnRPggFIIidjZPW30TzwLI2VpbLLksPgqaTLnKmUXHGnjHceT6+pqzksGyiHVKx2rThBUOKiIZp8gf/rM/4tXdA+OcyDaVqfMO53uq70kI+5Owu3QMBUIuuC5o+7cU9scDn/3sS/7qv/M3CZ364DqjjYTmHSwaJM/7wC2eqx2vX5e2NHaWUJzDS1WIxfqXglJNqvHzvFlwBZvx3KGm5yoEKGppJTCXTJxPxDnqXG29DJqW1rziHObRV0qyrc4R47uzdttRbdM6nU5Mk05PasW6RxgGVdNrzmeToUqiLV7vwyI4OZyOvHn1wOPDPbmZyIPeC5Fl44az4kfO/2b4kBVTbSjIYkFXMkHCkjCI6HNyOp14/vw5ITgrCt6O5cBKFRB9fe8E5ztyckxj5NXdI6/uHri7f2CeEw9PE7lUUo2Ew8T2ukIs+FDpemGeEtMUqex583Di+C9/wt/8g/8ht7cfUph5eNrbdfOKMNvwDWeWSO08Wo9IM9m3k0IR36TYNP7/8+fP3/qe7xsyqI4AM6fTgcfXd+Q4s+07tWt0Qad6lUjJM7geJ/o5fCgL/1DjtzfdQRPzrMmX/MVm7vwbPYrZ0yUKcTqR4oRznXrfmli67x2dMxDAKWmj823NZLXMwlOkEqeJ+/s9n798zf3dHTEm63KBIjBncNPXqirvNRot32OL0iEE35vV3lpoqTOJVy520pxju7tg2GwU+W8vXNf/yVIctAK7gWNagFSar3kgzpCKEGPlNEY2m2rT1LzdOyGlxDDo+Ob9/sSP/uzP+eSTT3m4u+NwUOQ3hHL2cXSd5mI+HbVlDa3wKmrxaRzZ/voKEeHF7TNyyosn/Js3b7i7u+Pu/p5xnpiy5Ugl09XMTdROG94jwaJzlcVuLiCEVDRvM+72HE88Pr1hig/k6ZGaTzgKQXTwgLfY8W3r9psT1Jg0qTEUbru55ng8chwnUo4LhN484XQjCQybnqFv7VK1hgkCzlWbpayZlmt7ElUDbMokB5ILVRxFWAnhtiH/qqS7Vgih4+bqkuvrK66urnh4uDtrgawJyzIlhfayrfpvuIDaO1UtGJjizA9/9Gck2djIVK0mvM3XHeeJ+PjI/eOe57eRzcUN4jOpHCjTA0PfcXm5oR8cD/f3fPnll8S4pwvXPLveWZs/m19c48Aad4k2wtVRJK/niyzopTa93r4oC3dVFlwAZws4xmwtlMJWAj02/jGPkCdKHpFYiMmI1HhcPSNTL0hUQweF1jLJeebp9G6gULBWwuTCdJgWlbgmjw3dY0EzHWLk84hgqs1aCa7HG2UEp1YeKapNUq1iSmWnrSTa2M16xuv75WNR/Frx501UAKwIE2dB3wqrrycRy50XUX53deCE6oRY4E9++GPe3O85TtmmMQq4nuo24Lb0w44X73/M5dUFlxceFxJjPIITUk7sdhuGPvDFF5/z5s0bLq42JiLr8TLjaYR6LVKW02knJ/qcn2O+7TuWz2BZel02GWcxQQhBZ1N7o6V4gU4cIUVkHslFOW7T0FOq0jemfGKeJzpJelmaFVNNSLOlKGmJQ5BJ79TaDeQkGujHkcPhQJvO1QYzEAvzpL1939w0SqZQ6EKLsY3uoahIzBnfBYYqOK8K31ybKEjfeR0Z+TZOb19UBLcVHoiOWCyoX6+FAx/UxzfGiCC8/+I9zvnZrThbfGnbUTMiAVXnBzKOH//kM372+VfcPTwRS6YWj8iA+IFcA/ePM7urRLlw+B58Bt/1zGnGd5mnpyN/9Md/xu/8W7/P89trun5H121tc9TxmQrAOGo5p37Z2drgAaXgre105RNCsy101YAUaYhrYSNKqapSSSVxeXnBi5sbpGQ8lU0IHE9PzGlknA4cD4HeexyVGE+LSDcvvti6H3hWFuRySX/51H/tR82FaZygFnKMiqQVFfCF4Bk6R2cGPUbcsH2klYmCt2d/Oo3cPRy5uz9wOB7Iizn9+V79TQhcc/YxCgEW7z0Mux7ntCjWZqNSUEAfI+ccwzCw3W7epqScx966cl/r0uFVDUmpatI4zZHTFDkeI7V6xqkSY+XpEBm2BemELlWlVXk4HEe2O9g/HZmmn/KnP/xzfuP7P+D22QfgMof9BKy5B6igqZ3VygA8R3vrLyfvi/OHfubLy0s++ugjpnki5sxpmtgf9uTDif7hyOX9HXNO3DnHwTty0qJSreYEcqR+/hp+432dOGf3tZaRWkZCKEqfAIawdiOp5VvX7Te3+HOiZG23B+fpvNPKs1Zs9MsC6yuSpFMj+q6nC86CqSqLvXEUdAJEwOBV+qHXSVLDwJwSpTRYqS5qfrv8b0H550T8vg988P4Lbm+u6fveyONv85pqrWy3Wx2390sJaruVy5tpiylDnLMqaBuf1RLGZ8+fM0VIo7be3ty/5vuf/DZD7xkGNea/m7+wDoISguNcefXmNSWdeHGzQeqVmXEXFPFq0zAs6TekFqMvLGKkFuCpNEVhC56ruIrFP7C1+qbXj7z5kx+zPRwRL5TrLaX3xMORqc5s+kCeD4ynB6bygAye4bc+gs1Wk7hi3nvV2tBWxbYHtdRCyu9Gu2kzDIqeVm3nxjkRY1ySUz13/TzeixlMe+XrLdd72U5pNYF2RZ0i/qVomxQxIUujy1drwejCOg8QKwIDS2B2QugCvguaXFrQaQnpuV9em2Tz1mEbrEg15FBooxO/+uoVcyzU4tSH1YqeKl5xI+m4ff4BH374AV3IzNMDx8dR140T+iHQ9Z6UI/cP98x5y9Wl42IrSNDRsI3Dh5xxFTkvkEytvWws7VrI0jalofQLMOIVxXKOzgfi/RNPP/oZl1MkC7iLTud37w/MkvC7DXmeGE9PTByoYaL79DlyOSwJMPK1La02m36xIRbvxtoNLiyoYpqTeQ+WdU92qgafpxmKTklzgIqMCsVGw+Ic1UMR87at2i1xFhcscICzqUZtug/rJqyx5gy5t0OWXyZgWvyqsQ6CCs+8L0vMbEnqGm9lTa6MblCsSKyl8vNffM5nP/uc+8cjUzJvFdExo84FxPcggTnBXCpTyfRFrYYa13CaR372i5/z6tVr+l7HcXdhgyPhiMb/r6xWTevnXK0G189cEYqcx2ATg2lmY59fEWrvhN474v2e048+42qa6VJluOjxQchPB6ahx+8uiTUz5pniHd3NhosffIDrqsYV8+V+6zYo5L3Gk/DdZ6jzPKtDDm1EbQV0Mh3Vq/jUtfauCaQpVNda7k10VNkfDtzdP7I/jOqXbOhnO2y1saRn0h6Or4M17Q+KSDhpHcn1HjYe9TzPqOq/W7m0tC4tZ7HJ0PRWsGB+6iKI6Njol6/vbCrmkWmGWj3HOVELHMaZ7ulA6APOJR2h3gdyUc52KpHD4wM/+ckvePbsEy52W7puoIpDfNuf1BFBqLZnnI1tljMHoJbKnu0Z6iPsdD+vLEM0hmGgoraHz29umF7fMd4d+aAGigTepyNlR92P3JRHfPwRY/iMqcKp2+A/es77v/97dDdbLT7KWWEgzXVIln3VCd+6br8lQY1aVVa/iEe08lz/rAbMTiF1r2iHxkYdRdYuhhpOq8rfeZ3rLKgwYrdVs97j9ESKWGa98taa6X41DiSsU4H6vuf25or3Xrzg6vqSWpRQTX27cqi1sjOLqZagnnNKdA2fLW5pC84UecuDoAH46uqCcphw88wcI2/u1HoqZ7XUGYYNOalQqk01qgUeHh/wJFJMtBb+gorSFPEW0Fm5qOfpdrvpFRZLFE1zz8UpxpVy+hpBHOP+wP6P/5Td4aT34f0rZBvIr19TJOMvLyjjSD0+gsvUvtJ9+AHdszYCtiHSWnRIG5FyluC/A1x9AIauXys16sINa8mhov6KhATvdZrO4uVoxjaCmdE3Q/Gza191Ay5FraWqS1hYoIn+1ngqfH3QxLK9O53TfHV1Rd/3NBcJYUVnYOVxvjXC7vy1RFfAkiBUmOfI/cMjKTmKJYnVEoFadWjDnDMu9Gwvbui6grjCeLyjxie8t4TBa5H1+s1rTvMWJ5ds+wExNwF3TpVpQd8yeg1Ebq3u3zrzlsDWMxwFe+6wCXSeTgJpf+Lwx3/G1aQJm39xSRg86c0bRBLh6pI6npDDI+InpK90798gl57YlK9fE8Atp2DL+F1Zu8Fp+zhHjRM12/m6ljiyWP8lqdSiHH9XlbKjOgSBEpadtYAVVPoebfqL1kmOlJMJptZCVw/5pfNr661SVvT8a0fzY04pLAjPL73KEsSgOi2qsLZozoWf/+Jz7h8Oypdt6YlX3j+uw3dbLnZX9JsL+l2H64U5J5rJmfNKP3h4fODN3R3XN9d4X1QpTUBINHcT0ILecvIlAVpQuzNaTl1+5iwpt0Rff6oiotzL3gXyYWT+k58wTJEhVXYvbug2gdOrVyRguH5GmidOpwOjd2yeX3DxfIt70atgtThaO+Zch7Huid++0f86jpyUL+0cyqm1eFSy7os5y+Ibq8WSfo+rthalLgt8nKZFyIrt9corbXuxnN0nWJPTtx/i5TFf4rdYGGg/v3YbY4y2ZyqC+nWf6bWAXkVWxeK8FltqsfS0P/Dzz7/k1Zs79oeRUjsET84OEU/MsD9MXFypHVyXK30BjBqWS+FwHPnJn3/GX//rB+XbhwEfesSl9fO0YNBs/tqZNoBluS7nuQ5mMWXBxJLIZjsFMPQ9UJn2I0/HifdOiUIldEF5/fsZOT6wGwM5JqZxJm621F9c8fx7H9LvAuS80tbadbNibt1H5S+XoMY403XBtg/132sPiHOCeIXum5DKWTKUUqLvdcqA94KXQOdB1d/N/kk3txACFxc73nvvBftTJj6eTLmvrcNmE9XUfqtPmC6i66srvvfJx9zeXtP3gWk8UZJ60mmStl6Ay8tLS1B1kf+qjf68EeW9ozfVtI5mY6liN0PgOM84p1Yad3d3xBTVlDgoH1fbHZZUlELFsd8/qvebbSZ6o8xLslUX0qqk5bHQ8Lygx+sZO+eWatUtnpjrQ6fJrqeXjm6MuC++5JkThjkzkPDbAK/fEGJkdzsT54iME9uLLafXD+xGIRDI1kasrbVvO/pSuFoS57vvPlAC9J03nqJQknKPl6lZ4s5MmB2d+XP2QTl7SHOFUCqD97JM9LI00SZzFTUHd0KOxlHGbEOqGnO3BPnryD/oM6TctWe89957IHB/92b5vqWwqZXNZkPzwW3PUHudWqEaf1pvh6OkzNPhyNP+iSSXVFGFvJhbQUVpL2U88XQ4MM3KMe+HSzYXN+zvviJ0HfOcKDkiUvjyyy/YHS4YeuH2esBJMBqKnCFQVhgawV4/p1toKC0pqdg6bvSRxQqK5R6pR7BnkEAaI/LllzwbNtT9yK7MdBtHffPK1u5oa3dke9lzev3AxQgFTyI36KPdDW3123lWS7jelbXr7P6lORKniZQ17nrN9mlejFrEqONBrZVOhCI2Uam04kA/W6nVZr5navU2517bguIDdcqa2NaGtqxJ2C8XV2sCF0KwDboswbElp4CNq17Fq+2n13pF77r3Lb6Zc8pc+PkvviRlT7UBEwg4AlUCSIfvLvjg40+5vN5xdTtQypH9w5cIld7ptCHvhThP3D/c87h/j+1GLQ07a5MuXtJ2NF3jEkdb0X+WrKysf1n4u28dVXcSh2fjesoU4fPPue0H3GFi6wvdxUA47pkOM5fFMY0z8/5A3vbI0wH/cKTe6HAGUgDi+VXTt6nLEqZ23z0HteZCjtlypYyOiq0mOM2cSGxqB87bpCEVStEF26dsrYkwp6hFhnN0JrycSQtNaUHh3xI+vw0AyNmfW0LazlPs+VAdgb73gqB2/eJHDefJoLz16ufdsAYw5eL4+S++4sc//imHcdaOlat4N+D9gHMdFc9pqowRfBb6AnOuyrs27cI4jvz8Fz/n9d097714gfM9/bCFGnFqDGfUlIIY6eP8ET2fpPn1Y+1oiKLXFRZbQg0q2u2uFf945ON5Zj6NBAr9rifkwuHugeduy2mK8HTE94nHhwfk/gH33iXkiYBY8QFQwMkyhh600/dt6/ZbbaZaYKqYOERgayMZU07L95akKvm56ALdbgfNoG2iQuPjFYPIvQMxgn8XOm6urvj4YyGlL5hiMuRGA5OiUs7mwGrFcH11xYcffsD3PvmIzWaAqq2uGdTE2usNal58bf53ax/VVcuxfEbXKnr7xN47drueUqK2CVsbWIqqQMkIERG10zhNB4LriDKR4yPTGHHe4YPgfCHniTdffcl7799SSGa3JWdPgNlNvdVPqO0kWbfvds5nic9bC3Ctriqqbnaucrkb+J3f+j7/8X/yd/j8n/4hL1+/hA7+xv/g9/l//Rf/Ja72DBeXXH//mr/xH/z7/P3/9D/Dpx5fOoMX7OFGOX2rSl03me1m4Hd/97e+ccH9ug4R6PsApTLNavECdRl521D/LnQMnRpL+0ZhURqnbZWapDrvkBDAHA5un11znCJzmtU4HaU4cGa3s96vX0b+uy6w22744P33+PiTD6DC/rByIJ33NhJVE8fr62uCD2vhIefBUivVZa2IWlMdDurr6YNuBqU6CJ6bZzdU17M/jBxPBz772U/59NN/ixg9fRi4uXnO6y/UEHW/f+Lx8QGA4zhSHJxOI2lOuAtZ3r+J8mjIv6wJDiv+dXbOrUhsbT1d004aaqUFkBeNFVfbDT/4/if8R//Jf8gv/un/h6/evILe8ft/62tr9zeu+Rv/wf+Yv/+f/meE1JOqijX1HKsGIIHqdPpQS1w323dn7eYSyVNkNrcJbMoZsBT1Xefp+wHMWsqjohBVSLMggwteUVVQWbJZ9CRDP52WUU04CmdF/a/Y3xZKlKDeqrsdoe8Qr5oBBwslpTlpKOCg68PJ11/vLJUQATzTXLi/f2IaIzFDrn5FYcXp34vQI1zefshvfPop0kX2Ty/ZPzxQ/InN5ZauM5/eUPnFF19wfXvDduvYdJkPn6swReQsea4Cfu1gLBCB82+dc+sUOdZiS79+DsXr2nVSudpt+b3f/W3+4//V/5zP/8l/yxdffQVD4G/9T/49/tF//n/Fuy27Zzdc/+B3+IO/8+/z9/7X/1sGp76uLgvLGcn5GdifqnLi6/AuFFeVlGedokRBXNJCOxeiqCVddHYnTctQPToQpROq87qGnBZUmHuNK0KPx/tAKsVGMWNTllbg5uv9qfNj7eo0MVGm2eIpGFCZ5wQ4+j5rEV81mfvlV1NeMaJTs0CoEogZjseRP/qjP+U4JXLVMaAlK13RSQd+wPUD282OJAMldEQJHLMODskmdk1p5vWbV3zxxefc3F7T94LzF0hJOGak6vQxWVr76zmqeO7rV0H4+udoSepCNxdBxdEQnDDsBj745EP+w//l3+Hn//T/zVdfvsR3nr/213+Pf/R/+Ht0rsc/u+Tmt3+Tf/dv/23+z/+b/50CQfNEN0+UqekmMiJZRX7nncC/wLr9xgR1t9sZtI61qIsaam96JCbKKVGrQvtNsdx1HVfXlwxdv6j/aymczNBYRP3GUqxsd54UdfJHLZXb6ytO700cjhNzypQKc2oL0uxVQuD7n/4G7z17psblu60uVFuwMc6GlmnypEhZxzRG9k9H+tDrSMC+4/LychGmNJS03e5SC65mwDFOJ0Lv8M5GplGI8wHqTOcrQ+eornB394bTk6NzEc+RUiqPD28IvrLdBe4fHhi6SzaDow/6EDfek2EW9sCxBM6GmpWziQsrmvF2S0O+FsDE2nAVkODIDg4pUj/9mJ/+l/+Y43Ti5tl7bH/vd4h/9/9BDhe8/9d/j6vf/ZQ//uynHL3HlUqXMlK0RehF1lGhFWvzKV/RO8/V1c03Lrhf16H1hKfUbPPaq6pJfUNP1aLHi5hVmla5zQt1be9DG0nb7HRqdbz//nuk6gl3Tzw+nRjtNRbupROCeJrHXUtSnevYbjbc3Fzx4vkznj17xm675XQ8qOF8Ue6qd45igr7dbscwDAvi+6/sRDdksiXhzpOxCtlpkSJSubocGJPgxkwuE49P90xxYpptBVaYJ00wUtZpJTlH9k/3FC45ng6c5hPITkUNSyLqluJKXKOnLFDHcl/aQl1FBvZd8vWNQL/mek8Mwikl6m99n5//3/8xh2ni5vmvWru/wR9/9tmydkvWOKLSE0W2qdpWrKzPkXfyzqzd5jaS5plabZxpMK508Ax9z2Yz0HfNK1nRVeX568bvZW3Z4cAHR9c7Sp6ptVOdmGSbGhOIORqP9KzooEWmZvenxX7XebabnufPb3nx4gVPT49M08TiO2nIv3OOzUbHnILFLVnITHrYzQ/Oq2DLe06PR37y55+RarFhU3pepapLTAbmNJGeHvji1UuevfcR28uOfrjh+vlH7F/f45wjpokYR7yHL7/8BduLLbc3O17cDnzw/AWd0XyW9StuicPtPd2yps+PavmiJrWlmOjS4vESH0WQIZA9PI0j9fsf8ZP71xzHA7fPP6T/ze+Ru54SBt77q3+F3Q++xz/74R8zdZ7kPFRPVwIRv/CFV1/wdR8otTDlme/6iEk9YYMXK5TqMlRER916Rfyrzbgz/YIOnuhY6ELVvNRzJCbjzVuXtg+BgqrK85R0eF4TpZ4fondv+asoCu69J3SdPvkrkqNjnyedJNfWrnDeKv/6a4tSnEo1TrJjHCNfvnzDGAupqgysLvQFrxi4BDb9BR9//wfcvnjG9kJI8YnDw0uG0BkoV8g2gvvu4Y7H/YGLXY93lSF0eJJ2XRuIJZW3TlO+/hSf/cNyPfTPrrp1vdr+FZyjD54IvJmP1E8/4kd//zVTPPLivQ/hB99jGjpy53nxV3+XzW9/j//2z/6IUxCmFBmm5quqz0+2Z2spfEsxgCB/67r9xgS1Kd5zycxTQWwWfNcPRjSuS0uomW2HrmMYNm+38py3CkXNhr0vZC8gEZp/l8B2GPj44w+4fziwP5wY50SdZuZZie+boefFi+d8/MEHRhzulvSuUm30V1wUz4160G7G6XTk0QvjqWOzGdhut8pTFFncAopV+WKJYkE9Wl3NujFst5xOB2qeySniHWy3PYSe4/6BkUrvC5sumUXMAZFC1wnUiYuLju0mEJwo59UI8GsLwhC3+nbNo4kRXwtOZ5v+Wa4qbuW1Kt+nMJfEHCfy/oSkyv7NEzHO4AKy2TKba0J3scXvBn70h38EuZBTRmKElDXYYBZBNqZQRFt76mepJtTvwrHwN6si4UPfqYfh4qmp9zzadewIuM3GXBPMn0/U/qsUQ1eq8qbFOULouL2+oRJIBeL+SM1ZWxiG/CsBueKdPifihMuLLR9++CHPbm+4urqg69TuZJnNbWiO934RynivFjMi7Vl7+7OuaM96eO/ZXWjx5lxaKThS6IIQs3UAJFFr4nTc0wWUspAOpFQsYBe8h5JnpmnPsO2oJUJtNviGjbZhE+eIQ0PbEOugvN0FWP/eCP1fa9GJPtmxZuI8kQ4nJFee7p5IcdZW4S+t3c2ydksuil7Y67U4VUtRPLttUFIXVOZdOBq9o7U4mxA1BJ2CE3wwZwOvPH/RNqo3ey5nP7fMiUd5ztfXV9w9HBhnSMU+s5nmrZPo2j05Lzwa2gK77cDl5QU3N9e8995zHHCwFqzWZW7prHnvV5Dj/POdbZ8N+1o7QY6UC0+HvbVPLelDEAc3t1ccxkI8RcZ44vMvP+cHP/i36VIg+J6L3TX3LxWcGE8jp6MOX4hRJ/r1HVxu1inq51zEUrFW/toF+Dry/7U7BbSG/ypKaWdcUfV+ijPlOCIZDvdP6iziPXUYiK5SyISLHr8L/Oif/XMkVxyeKkHFYAt/XLtWS2yzDb+Uokj7d3w0Kkjzz3c2Znpdux4km82QWQ1JtZCh6aTTkKmTDLPyzUv1FCJm2K1xp5zHjHp+EmdnpOu42XEF7xmGjmEzIN7ZpKm6UFLWTqpb12xdX/LrGKRYIa7JruN0Gvnspz+zLnErw2RJsHOFOWX6XOm3V1zdfEC/qYwnz/Gwp5YTLrSUrOC88PruNY9PT8xzoPOJD9/btHc+i1/FUoY1HzCjxK+d8TlaaTzzXyLeWwfLgZRM2Z+QDMf7vTozeE/dbJgFEgV/MeB2PT/8Q123JEi5knTD09dzzY1I3uL1tjHC33R8Y4La2nSlaKJCVsheXKDYzOSVG6pBcegHQuioOdHsF5xNJ8q5TQ/QNry4aPw+v6jxd5c7NRAPPeE0msJUN+nLiys++vADbm+uVfwj2NQlFe7klEgpLornsNxsvQnzPPP0pOT13XbLhx98oLevZX61op44dmNr490WnIPtZmC32zKOT+Q0U0smeKcG1KHjeHiAUhg6h+w0QRnHkVKyoXGJ7aZjN3R0QZFYsUSmBWqpZwpwfYKWZHNFnupbn+tsza3VHWuSWoFYEnGeqccJxkTcT1RnvoSho7+9XkzSa4UcZ2rWyUs1JyR5XQdWDogZnesYVt1Mp5T46h0IlLAK09T+RRWKSrhfi49c8mLf01VvFV5DT9aRbc1aR58tWYqvzWbDVYFxnpmijarzOsJTvX1tfYqKBze7Le89e8ZHH77P1dUlXRfUj7U2lX6zEtOpLMVM7EtWq6kmRBQJX+MEvp2e1troKRtSmul8QiTYKLqKk4yQcJIJXkPo4fBE8EL0mTw9kVLWUbBSCUGodSalkVpnnA0z0Fdb0f9fhYAum7a17N9uxtnmIq0gaxXW2ylsLIk5ztTTDKdE2o+Upvz9+tqlrmu3tCl19hRUs3GzrxnlcXmPr+Z3Y9QpsKDoYu4oDfVvxu5azHQ2ea+CTTiSWhb3A2liCJTrfHV1yc3NFfn+RIktedeEfbl3VRP25U5WTU4bLeX29pZnN9fc3F5ze3vN4/2DtWtZYk47/67rdBJPE7m+VZy0zwlnd35FtIp1JMyq0AE4FafGesBNmTxn7h/umONMTL3Osg+d7S+qoZjnWZ+vkhjHI8ejMF50NHu3t2JrbevYClH51Qja+bVpnxW+Zudj2EOsmqByijBn8nFW1FpvLMOza1uDhSqVkhJStGxQ1baOem0gTJsW1Pj07c/ljG73XR2Ny+mdAgHBB0LoCMHTdV6dfcQRxER9Ak7Mi3tBM61gMApZyXYtalKtmGuuEbwdA5ck0n6+np+XUrl22w0XFzv6oacN+mnoYbHOlYq7zxLUc0z9LFk9e8ulQJ/nyFdffUXFL+upfUPXdYyxEnNiihNzKvhuiw8Q+ki/vSIf3uC8R0cy6zCfu/s7Hh4fOHaOoat8+N5WX1JYBmVQjUt+pnPwooDK8s3LmZ4NFVjicfuc9v8moMoZd5pgypSDUo1EvMbcZ9dGUdR1W1NGSiVndUOJYC5MsiTyYjHpPI/5tnX7LczqlqBW5hhxVqk1XqguFLOLEEWVdrsdThwxZ3MO8XShJ3VRE9uclD9SEl1vyCvYxCNtBVxdXRC6DRfjzPD0SNd1XF5e896L93jvxTML0lr5SEt4kwaCtFgJ1aU6EinmxVg5jSeFmEuhb5ZZZxV8tTYTaOsgpcjQeTZDz8Vuw3bX8+YuM00npOr88H6zpeK4u3uFp8PVgdx3dBKYpolp0hGFzkHn4OpiS995qGrzUHJZns0FJV3EEPIWkrciDWWp1fWTtRew+t/ZZAzR18rYuNJUKGMh1LP56F3H937/95h//CXzYWSbK3/zf/Y/5Z/85/8nksv0UhkylNz8TysUqx6r8stKTbyZJv6bw5ffvKR+TUfOmRgjnQ/q+xY6jsejFVQKlTVv3M3QMXQ93nltGTm997Vk89msqGWcA9GJWjllqI6+Czy7uSYlOJ5OZLtCra0vRQP3xcWO3/zN3+KDF8/Z7lTwlHPGgY2yTMY51WS473tSVIPvw+HI4+Mj223PMAxshoFqHnZtc6xnwVNbrdB1gTlO+KEs7eFas/rT1UwXKtvBEUk6Ti8ngiuU+dG6EWpkHxxmMZaRqlwy79GEryGkwDqK1wKorJt2ddUsCc/XbEtOy9fzFtukNPCmmsklQc7UUyKgAjVXHXT922s3na1dKQQqvhifuKLoac16DwGqR5zjKU38N4ef/etZfH/Jo3E3q3dIzfRDUBs0AWolzYk5ZvVp1FQKcY7O6wybZnamfHl1mfBe2G63fO/jTxjjLyj7iVIirmD8uJYV6H1sXUN1u/B0Xc/7L57x6aefcrHb4J2KjUoxbre0KXV+6V6pl+RWfVrPduumxV42/oaE2ZpxXhiGnibOFaOmeCdsBk/w4CRDjZQSGeORIfYaAfOEq261GnQVKZk0jzw9PuAkcnPlbS6LLN0mcGeDUBrasxaja8FUV1S11mY4gzat69ny1iQltzHRuVAt7hYKvgp0Pb/x7/415h+/ZD6MbDL8e//R3+a/+t//X3gqmQ4VCku253zRhLS9yq5brXT/Jhbif49jGIalxR+C8qU3Q0fXBbrO2foURDLqLeK0wHErqi0OtpveOoOFSlbP3lzMMk73ujbXrN0jTceaUHRFE4NzPLu95fmLZ9zcXPPw8MDx2MYaN2vHunQqvHvbK70dS5q3FCRr+oooRXCKM8hmWdMKpmYuLzdMDyNzHNmPwpdfveSj7/82LnSEbsf19Qu+2v9YnSds/HgIjqenB169eU3feS53gSof0gYeNXu/ZT1al225JiI2tp3FYQLOQFO7jjk3r/kVIFCZiXq01rHSZaGa4T9dz6d/8O8w//gl02Gkz/A/+l/8bf7R//G/4KjJnVkltgukQm28cG41LPCt6/ZbRFIwz4l5nJjHkW3XkVMFyZYJ25t75YZutwObzZb9/klHEhqBOKWEk0DX9RashFKFzXCJ71oLICyzcHfbns3WU4rw0UcfkWsxR4DAsowtgJ4nluv407Wdp5u+cVF94OL2GcFavsCCoK2fuS4cFET99DabDe+/d8vlhS48L5U4HpHu0nzVKrFESp4QyaSYmcae/rrnNB3ZH0bGccJ5YbvpePH8mt2mg5JAMpjaUQ+9g+LcstiwIO69x0mBou1IVTD+MiqhPyXL61UcqWRmKicp/Ojv/kPqmPAXgfnVA5/9vX+C7yFL5ss//O949ac/5Hf/4A8YUuVkbVYfI3NyhKKuDeLcYn+TcybmQn6a+O3y3VfyoOrhGKO22MXhQ0dD7M7tm/q+52K3Y7PZGNpUDK9QG6bD4Yi4yjAMeF/wMdN1ek1d8FxuN9w8u+X2+Qs+/+IrTmNkmjOnaSSnia7reP78mQr6PvqY4DVwVCOPU9so04lpmtTqpIkyRO/xPCdevX5NF9QS6/Jiyw9+8AOgrXtdAesccWtjl0yukXHcs9tt2QyecZpJcSIlbd1fX26pbsdhf0+aFR0lHRi843DYs+nEZmhnri4GLrYDu6Fn03UoznRu/8JyjZuKv33Vi6PIr5q9/CsQqqUVZH6tJWt7rGR+8g/+MWWK+G2va/fv/lf4Xiiu8PIP/wWv/uTP+N2/+ftsYuAkgSoeXwEcKWV8TXhXAbWEoagwYijxnVm7oIhLLY6ahc6EeSnFJV4NG7VRa408d4YaNSFqm8bVuJJSdR3/xief8PPPX/Kw3yPZvBWd8uUU+c/UrIlYCJ7tZsMH73/A7/zOb9P3vb5uyeodm5IVR3qnQ1AhX25iSlqMtpjMuYXVeiydm5QIwfHixTM+++yniNM9Q41NFPmXGvEu04eCc4XXX72kD4EcYDy85ngc2Q+F3aan6z2lTMzTgZx3iOyss+bUDeCsyNfjXBSzWswtg0q+8bCCyzoAVZRXOwuMJD77u/+QOkX8ztbu3/t/4gcHvvDyn/1zvvrTP+EHf/NvsImeGjqS7yhpVGcB2/DUgzyr+riqSKjW/Cuu6K//EIHNpid4h5DVF90GGoB2slxLI8VZgpq1sAlh9efE8f4HHzBneHO/5+kwk5Lxx1ub+qwwXtypbLyoc01MqlZ1P/it3+bFi2da0NXCw5s7tT+yoqp1ib33XF5ecnNzrc9fLayqlF/6tPa7dl3FBU3CakMIlY/tRccSf/jRCx6PP2eMkZQdX3z1BX9lPOD9JUPv6cOWlDR5jzHqKO5SKHni6fFe3YfY0Sh20hIgfStbc42acpaq/4qFodQpLG6bO5H9TC55WbdRYJLEF3/vH+LGhFys61Y6AV/46r/7F3z1Jz/kd//gb7GN+kxFH3SNCmpRKCocrk7pcF172M+6AP+q4xsT1JQrp3GkpKwtenSyxRn+sUDZPgTEeaZpZJomJfw6rcjHcbIL4+1iCJ3v2V7sloCmZ6MVvxNRtCM4um7D2hrUQCHWqitfT04FnFdv1WmaljavVgmZ3/7N32Q7DATfRgSeITyNn3a2gbYE+OLigqurK/U+rdCFwDzPeGlCBk8sqqorwFwKMo+4QyGlA6fpRCpJkeCrLVdXW/rBg2u+lW2ByerFRzWU1Cohg/JFnP6cExtZ2DiJsiw+acRpWGF1dAa0S8JP/8UPeTrsedFdw/2RP/v5P6c6uL2+ok6Z46uvuPvZf003DFycoOwz87WipKnx9HImZ0WjUkw6NeNQqFx/y5L79RzjOBNCTw2aHPWiZPBSWvKmwWCz2dAPG3wIinSIswDr8OLxkyfnREo6SlI3WC1gFClwhM7ju57r6yu6PjJOEd+rR+/NzS0vnj/n+e2tcaZXvpNUG26Q4jJEoB2K7iqa5IpwOh2ZwOywVuS/PRtKZw5L5V/REYudD2x3O50INXTM85EYJ6R6htATuoEsgf3+kZKzTc8a2V16pmkmzYnT6UjwwtB5Loyi0gff3t7W7lknoirO1CavgaG6YsHRuMGyvAALAizY/62L0MyAdOqL4yd/9KccTxPPQ4fcHfizn/9/wTlur65gjJxe3vP6syNhs+X9U0few0kypdfkp03j0ba2bi61QqF7Z9YuFOXrVUdJ7bqulmPee42vwLJDVTP2ydE2clX0u1C1oM1KFQHYbjc8e3aL7zrGUX2cdfMoC5pSXV0269vbGz588T67zaDDHhbRX0tQdUCAiGMYek7HiRQjpzry+PBEzRnnFMH1m43yL2n7qnVxbAtYLLM6b21sddBQ9N/EqUx0obDpHVESp+MTT/f3CJnj40uIM9NY2fZ+cYGoNVNrUnqK2QwWQ9UXxIn2Z5YER79Uwa1r+/w+NZT3/NDcSWjdTIfgUuUn//yPOY0nnnUBd7fnRz//EkR4dn0D48Txq9d88YsDXSpczI6aHRF1LehdskHClVqS4rjGQ00F7uLmX8vK+8scIUDXO4Kz56sqrSxnj3MbNpsGUBUFDcTRbL4aJcU5RxHdw188f4G4nsKjIv4pK2oqgninEyjAHoEVoVchn3ZzP/rgPU1ONwMhOHJS/+qlMymr9VHzVR+GzQJQLbQgUTGUyLpWC3X5PnFa5KVScJLV612KUnS6nkoidJXglZc8TgfG6cSw2SARajwxjun/x96fxFrWbHme0G+Z2W5Oczv3r38RkREvMiAyK6KyzyQhgUokEL2qJlBMkJAQQhRixACpikExBJVESsAABFKNGEEJxACJYoKAKlEFSWZlvohMIvJFvP5rvbn3nmbvbWYM1jLb+1z377q/F+99zyN01qf7ufs95+yzt9my1a//qiOrpzQR4wRT5OXLF6z6nu26AdHhqBWVsmQ+KDxbynoKpOIicrrgU8l6/ydlKZTgQJHFAlPm//ed3+N+OHDTvcq3eXfg8OkX/PjHd6ymkU0ccXFiLwq/qWkJT3aZbIG4TCJnxxjljXz7+KjTnJmiCgxv9QR1gO2i3kGspiaTORwPGoFsOwRHtPFnMUaaRmtRFQxXIZucD1Ux4Tzeio5FnX5VmGa1aVH/LBzLJpBLrasyZt93NUIWpwmyRspuLi9pmjKTXk430K6vEcFMTM5A9lVQ1wLwlGrHKimRp4mYB6bkSNkhhkM4DIkX0w7SvdXywcXFho8/ep/1pqNpPT6INkvhF3hszgzR0sQxn8HSHT5Hj92iq3M+oAt2oxb6Z0fbr3AfvAdDom0cm6dPWHctX06DRhqvr6BxHA57vrq9Jz7pFEA7JnIUTXlDNa6mSesmD4cDx2FkOO5x8tWjDPdN0RSTKl5zKHxaRHEq72qXsQ8KKRJjREJJ9yiP6mvWDJjQuhs0qhUMmso7hw+By8tLun5inCJXKTGNkcvLSzbrDau+N56b64VU2WszwDSNteSgjIks0GiaHgsEcaxWPavVyrZ74VDluY6q1NflnOjawM3NJdvt2prDkvKj7y3tr8pkmvYaSXCeIBHndCLK8bhnt9ujWQhhZWOM1Yg3gz0vUkSZmsnQOs851abKA/Li9+X/JStSUn1VyZsAbroV26dPyVFrYjfXT1i1DV/FIzlCuL4iB8dhf+DZ7Z70/prsPXmCOESmMTGFiHMKDo6lFYsTmuIdTn7vF8uUb01aolEmyeU0Ws2/yrkmBNq2NdzjIg+0Xvw4HI0PnOH0DzgPMUr9fN+3vPf0hvVmw+3dnucvX2q39Dhqak6EbqXNfNdXl2w3G9arHpsJYoouV7SBImsBi04OtXHn9vaOFEdV5DnTtYoxWXd/EQiqshwdx5iy1r+HFMEm5ygKwUTwgusbOtdw3N9xf9uT08T+9iXrNjMcR+I0ImTa1jOlTNs42kYnItpX2X3MWapCajQ9iEA9DGAUJ3H5ucVfvMleaXv8zQ0pC8FfsLl5wqpt+Wo6kmPGX1+QQ+awv+fL/R35yTWpCSAOcYGcC9awrllOEXIsLqE6L+9Ag5/ZaIhTuRbjVINXzi11rtZNFwi0OsZ3kTEkW930dsuUhMPhC2L2aiQ6hwRPjMqQiWS45/rZrmu5vrri5uaa954+oesaG9qycKJt552TeXhPpqb3Hxpu2K2Vvhqol9CX7HcxJRCdSy9Wz9oEsaCGRvwlJXKa2N3fsV6tIcKw3zEdtcm7CQKSgImcJobjgSboOBONBy4T+3OmdQlBWByjQieZ1hoAK/xt9eEWVS5827Qd/uaGeMK3zQO+hf3hni/2t+Sba1IQM+YzkYQTTxJtjsvkRYLCbK038O3jKf7FfyVvUeAeIONy1jSZbXRKiXGctCnIAOTHcWC32xFj5OLiQhUiJWIyh0wEbMasRVwKxA+WqtKYDKWLsQjJItgErEuvZZs3iDgVnlGbomYh6+o1616JhqEFIeVIjJC18IeUEpeXlwzTxDiMFV9yvVprJCwqePAYPZlGBUeGKU8cxnscO0gTXdfywfvv88lHH7DqG5rgCEHhpsiGlerKBClXzkOFnJA8h+xrS4J5TM5ZZLA8URUEKkRLlCBstmx/88/RDxNuGFndXNO1gdWFJ0dBPnyPeLtiaODlLnG8jqReu9pz1FS0dnUrM0+GmLDf7xnGkeO4Y+L54xz3DVFMmeMYQTzeq7O1sOUArY/qug6w9GmM1pxUhJCO7k3R4MCsHi+EQGjUQHUh4Lx69JvNhn6lZ8WHQIrZvHHbr1Sg7GfZVhoQS2OfOkJ6bnKmOl2b9ZquadisVmy3GwqsG8wGYU5pIVzVou7awPtPr+n6DeMwICSm4UjoOnMyE+SRnEbidFBg8KBSZJoyu92B3f6gxqKnRmJLw5VIqXlcOkilPmphfWCOLGjjI4Z1SKlrhtMu09mLF4Sw3dD8xq+wmhJuGumvb+jahtWlJ08CH75HfLlmaDy3B5ieeA6rhiSZaYxwTLRNJPhEIuqkJZfUCcUxjPt3hnfF1hZTNKWZDzLeB7q+11S71YyW9Y0xMRxV/oo4Sw0POoDAgJ+d8/RtYL3ZsJ0yXb9jjIn97lCNL+8CT57c8PHHH7Fdr2lsPvw8UEGdq1LnXTMConWv1WiKifv7e6bhgBOFCLq6vFxEzc1pXEQsSyOKTjFLuBTVIEsTYkNRFO7QE0KLa3r2+1vuXYCcOBx2bDrHMA4ch4GURvrWc4zQt55Vp7jHyrIGVC7llgRK1oo5QrXM7hdopFwcMWyv6h9zRKFI8rBZ0/z6r9DHjEsT/c1Tum7Bux+9R3zZM7RCGhLx4pLjSo2mnNVAFdw8iMXqWsXbfeZEyOPPmQt/eqoDcCzqOE3RZGVD4w2NIJtsyAqBmEqNrk0mLB39RQavVivENbx4eQcHIWbAOcQ7RiBZmRQW4GnblpurCz54/z2evveUvu/IRLIF2mY5C6CBiJLFzVm/tzheOskuLGqOixGtJBbwUGWbq75NKdF4vUfnRQ3OrDW3XjLZnOT7u5ds1ltGB/u7W6Zh4ng4ENat4sSTVC7HgZy7Kk+LLtJ7knr+Z0erDE2i3vdslC81kPGtyepyKYdmsMN6Q/tWfIvy7faC40p1g2oWHa2s62QNUydBt/xGvn3r8RMa1ZxBxp1ITSWVdxQlX+BhDvsDty9fcnv7guvra31X1qikd2iNqqX8Ys60rgOEqDk3nXyXNUWvHdWl5jLPhqtNZApe5zM3jWe9WrFdbzTCFxNNCNzc3OhnJNWtLCmmur0lhI/BW6CGzuXlJT/64accfKuF0PsDN1dPGXFa0JwmpuhxwSEymbE7qTEwDvSd56OP3uev/9W/xnrd0XqvUTdR6A1n/FY7Ssu2ZBWW4jQKNEePU+3wdpainAWnGVclPWGYYwj4Jxes/9pfwMdEHxx3eeQ+J7q/+AlNt+U2Rg7HIz6O+I3n8Mff4cgR5yIyRfLLkTa0ChAOHI8HDocDu92eKUZuh1/jj/kfvi1L/UIplvpcsaMYo3lFJUqn9VLOylLGYSA4bzA5OhJSxysHNchxNI3WWK82awqCgXjNAjjRxoAmNHjf0DRtcRS14apaxyULoC8mg27zztcGkxgjx+NQG02uLy754IP3WfWdGguynH5ToF3UeIgxamQWk9vO8fTmhvX2grv7HT/68ffJeUT8yDQ1IANTTHjRZoQkDlzmbjdCvuNw2DNMIy4IbRCePr1ks+kQr42HRTYWlhOvwmiOmMwRpvl8leYVMXlQbZZKcxRY+bm9ueTir/1FHQsYhJ0kdiRa/wltt+UuRg7HgRAnmm3P8MM/ILqRLHtihuk40vUT3o8aBcFwUVNiiImv7j/ij/mf/6LY8aeiUhMHM/wY6F6uViuuLq9qmZM6A8qnzmecD4Y8ocD8h2GgTUF51Gs3tQ/qEPvgwK25u1coqHBUUP1+teJX/9yvcXlxUY1TYnGUi1GRaq3cNE01gqRyaaLMVR/GA8NBN/j66pLg/NxhbVjVucLsqZGi2Qudb950ev5yjnhgt78nuI6m7WjblhF4fnhGzkmBwHOkCR0pHbi7u2V3f4cPQuehaxzbdcfltselaAZTNGNoTuGXAQZlPq+j1D8+6HouDt4ybJrnAEHOWgPcPL3i8m/9DiFB2zl2OXGfs/Juv+XOMDi7OHFxteaHf/R92psNPjjiBNkL4NVYEoWfy1H1HmgTWCe/fPQUrT2O4GbYsrZtaUOjQ0YW9nyypt1hPAKZ1EBO3oRBUoMSzSJ2fcO3vvUxz57fsd8fGGMkkiFFpugr7vNqteKTjz/ikw8/ZLNWCL9xmsocTMNJH63O39WAkHOOFBVH/e7uHu8c0zjSNp6L7Rbftjb5Uu+dmKqhpdUu8zn03jHEyPV6pTZLjnjJDIcdjSgPOoGRkcPulhfPv4Q4cf/yM9w0sdvtWXWO4KBthDFNOKeNqU70HJRoZ7HJ5qCAQSjWRvkSY0edvEqWZudU6BY2TkkHznRPL41vhaaD+5wf5dsffPd7NDcb2iAwZZLZojlaVDmoHJn96vRGvn0rA3Wp7EqzkXealk4W7RnHgZi0WLttWvbDnrvdLXe7WzKZ1ao3ZawNT23XslqtGMZRO/7J1lHpFFoilyk+cnoTix8HtIbTKmag+uCt1s9VQ8SJI/hQPZ1qtSw3p+wzmoLQmiV902a9JqfE82fPGGOkaVo+/OgjPv/qOfe7A+MQSTkAR4OEcQq4HmDd9Xz84RN+9Vsfs92sCV7TxsHGwFZGM5Bs9TJmlhG0JCLmaPVhqSqm6u/I7NnV1GlK5o06oigETWwb7rznPo5mfQWQTHIO8Ey5Yf3BBzy5vKBtI3/04kfk4y1+2hPSyJBGixarghqOh6qgUs6QXtLy7wP/2bdhq18oOaSWcrjFYa2H2Qm+adnt75nGSd2CEEgJDodDjehrbZSiALRNq41+vkEkW921M8QFA0p3OslnLq1PapDWkXzZgP4Wk3ucjtQdp4nhqAd2GkcE6ELg4w8UWm1uxCyer/5VlWGyMgV1kHCKFbharcg5s9vtePHiOS9fvGC9vsSFqJOKxklnRNNaPezALkaGtEfYEcc94uC9p0/4nd/5bb71yfts1j1tI4TG4Z02JSzxhiuEj91qTMUptPd4iDFZlsWMgwpDZaP7ipJ36ilMbcP9tWefNLORXdJIhHOQPSMN6w8/4Obqkr51fP/+S0Le4ybBjQNjOjJOR3X2osogRRRJ7I8Dx9vxneFdoBqoy5TyarVis9nQ9R13L16C6IjQ4FSeOOcIYVAQ/qRDRoSg0W/nbAJVo82mZoT1zvOtTz7BB6/lXOiox7bravNJmVKWzdkiGaTfONQIatnL3W7HOI5a/tLpUAGPDn25ury0MgENOmCZsJIpcGIRR+dpm0Dbet5//ynBB8Zx4OXtM45HR9c1c3AiH3GMxOke8ZqZUgrc3b/k9uWt7ncQejNQNyuNqglJz6HVmNZntDpb7ckpY7aVSqmXOma5nuFqnJrGcsbnIkLqWnZdyyFFs3sTyWEA754xN2w++oCbywuaIHx/d2QMKw2SiAcnDHEiTJZG90KOUbOXdsja9oFC+yVRSjY1zvZ0u93St10FaVenUIf7jOOR4/GAiDA1MAYITaJpVjooR3QwQ9N33Nxc8+TJkZ989iUvX95zHEbidIQ00nctF5eXfOuTT3j/6RO6oPIopxkXOIM5/kfGcbKhJ+bs4xQrfBjY73YIcDjs8QLpgw+Qq0uCX1GMwEK5qpOogao4kZKinzx5csVut+Pu7lZtiXREZKJvtEwKv2J//0xZKE4cdi+43gSOx5Hd7p5xOrBeNdwfMuves+48fWMtZnnmyWXtdKHZHliW/y1cqwelKg+pNDJOTcPddcchJ8TpOckOojvl2+vLC5pGSLsjU7vSNi6JZKejX8mlsSuR80RBfZK34Nu3i6Ca4igpneAt8jmpB7nfq1DKZJq2UaPVujub0ODazgSmFvg3oeViu9GI0XgEyXXUZImYuxKmFjlZTCk7cLIZXhtaClZg8Opp5lyVonPLqJN1k9ZUaMFyXG64bqoDmqDC/3h/z/444H2gCQr9UlKy6tlEvEsEL0hwtKHjcr3h+uqSdb+isftrvCcYWDzZ6m8WED11EVAXRHJZh5LqS/W14kUtI8CacqNGtrCIWrJLpjJlxmdlOsxABZ69fMHzl8+5vlgzjOAl4FxDyqOuKXCwSHlK5smKfvel+5y/nv5N4F97K7b6RZK3RrjGexqnTkMs8C5C3bejjWNrvPLP4bDj/k5HjrZty3q9BkTrT/N87ZQmSr1c5RlLUekUJfU8kqVFsbpHXa65e9GhOJfrVY8X4di2qphiZLvZ8uT6ivWqsxq0NMuZIoCUw3FOu9TLbOochWmKbLdb9rsd/XqjZ1E8fbciiRmz00RMWu+mY1wVc3CaBnI8ktNI3wY++vB9Pv7oQ9YrnWAUgig0XAi18bHUQjlXwtYWkVpEBAvp+mMRDIWdyQWb1KJZukZWqwSMYlE2L2Sv5UUZhTCZcuHdF1xdbjmOGd+05NCSokeSVzQRnKV1HSlpKu9wONIcP+Wvp3+Hd4F3a2NZVTCWvTJc5+NBHUOtgVZXKKZk9XMBHzKSVAa23Yq27QhNU6foOKsJRBRmqWtF53ybG+GsBi1ZlFA7x+0npxkhIs6lXJrajOz3Wsu8Xq3YrNdsNmv60LDqVzqSeuEkZgocW6pR4sLeIQQkJd5/7yn9quf+/o4vv/qMJB7vFUM7ZYhZh1toJaJmmfbHI407Mh4P7IcjiUzjMpdXa7bbjq7zwISINndpvV+u+qE6+6nGn2r2ENBIViqY3kXZu8Wp5qRZMZJ1ipDpouwhuaype+eZEnz54gVfvXjB5XbDbkisJgeNgDQgDdMUmcbMpNMzaZw1G4rWJrpw/Dly4M9GJTUuXhtNu6Zlvd4YrONcBem9J7lo9+6sXlVHj6Y8QY5QIJ+8jaUOgfUaLi62iHiOw4hvdsSYuL7RiXw3N9es2g4vaoQl03oFkrKgpcwlKa5CsaWYrDY6M45HhuMecuaD996jmtYLW6pmKk32qlMTEUk4Mqu+1WZUSQqFdjjgBHzXEJqOlB33uxcK4IMaqW0IpDSw3+/Z73dWHpBpg2PdNwq9lZM2FWY9QyklG5qEjV8t9anFpin8W8Wx6a2lkTpH50qdMKi9MEhmwnjfaSAhIq/w7bbyrZCdB2mIBD1aSaP9euVUHVONqj7Ot2+AmTrZkZp+jKkYrBMpjYzDoNNDnOCy11nPWVNI3arDWwMVomn9rlM8x2z1Jxmd8lAWq3TXlZobsf8p7mbxAGSeeW51K2qcatNKqSkpBm3pejt9wCKAFgrWfsRpzSAZvFNYqpwS41EbnsZhIMVocCt62LzTqUGlGH/VeZ5erbncbui6FjXQLepUFTpVEZdoWBXiZUY5+aRwu3pF1UC1ZxQxiCLjRnOlxPay2gxm3GokCnIqpQXCNA1MxwE/TXRNR55GSNpBTYGfMCzJYgxhUDZOBgLffZThvilyloJX4GVfnYwiaER0CEOcNOqfvSPlyN39Hbv7+3msqCkgZzzmvBa+xzjzzRwJnIvUq6q10ZosCvOhxL6Vt9pWjYe+6xjHiWlQdXZ5ecH11RVNE1iC2C9JqLJqIYTKZKTEdrPleDgYBnHE+4bVqmc/JMYYSUnHBjoXEG/drQaBFeNI8LDdbvj4k4/YbHS+efDaqasdsO6El9X4L9Ol9F4cpxHBwovFoC3Gai1RYXleizEjKstNNuSv491hwMVE8K2WpiSFmiLphCPBkRzoxKKB4ThyOB6Zxtt3hneXJDIDoDtRY/BwLI1Q1nSXYIwTGixVg10Ve0PbdoZSoWVFLoQqH1V+aEoweKdpTCxCWNFSLLKdscl3Vlpgfw8hVHSBGCMpDtrcstnw5OaG9aqn9cEaUZbnA5vel824tQZGUU5vQiAnbapa9z3TqBBs4hsdmT2NWi9oqfqiS6YY2e1HWn9gGo5MY8R5x8V2zZMnl4qg0jqcn4dNyKK0AMBReNqVLD9l+hwIWTQFmvJctzhHqpbPWBxVrbMtNXjZKR5k4d2MECfVo5IywbeQvZ1ptUgLDmictEPcTQoxlXLSz/lffpdUncYkgvOetutwzjGOk5UklKCTZTu9NmMqOxUZoHzgnbPxvqWZWkdHX2w3NE3LOEVW2zU5w9XVNZeXF6y6Xk2zknI3Ho5myOnwkVLzWKYbuWp4BoO8LPw5w1/O46WrTWSBI/0+sQBcpAlCTBoddE5RheqkL2ltApxiv6Z4ZGCHw+MlWUOcItDs90e7B0frhVXXsO5bSjnBnG2yAFPOljWTGvkvZwsWAQGWfFJ01KxAiiyvThoQixFmVS8pz3w7TQPj0Zqsg/Kt2goGE2i2SCrBlVyCD2Y4v4Fv34iDWjuYjQHHcaRptCZimiLjsKvR0YxOAAk54nA0bYNrGwv5R5rGgO27HpwwTgPTNJp3KuTlAa+evH65c0I2cPkYY21qwiIiBYpkTjWWWowiYU4jlHON27xRujHZGkbFBJ/OZd+sVgQnpGnEBc/ti5dauzgOxDjiG0/wWh+36jzrVct2BddXW7brFV0bIMd5vNvCU6EwmCniwoCGzA25gAgr00XDH8WUTA2VmjGmtVV65VIHoo89j6FT2/fU2tFZxw0+ZabdnsvtBbu7QVMpWUP1MU8K+m8Mpu6lCp3RN/xYLh5luG+MFBZBUSO8Ao03YN3Q6mhNcTCjzQOJYRq4vb3luD+wWq3oe4XAyJai1giUpY8WB79Ac7gshu9HdS6qk5Hnip9qnApICATRqD8IcYoc9gf6tmO73So0j59hQ063zCKOnCp+mCM/lxcXfP7Fc6Z0R0yawVhv1wwvdozWnDVFTa0FiVZrlUmiXaerVcfNkys++eRjxTX0OqvZlxquYh5aZPrEKy+Ok00dS2luoFDXuty7KWIeIBG4kyVcrB6veJtL3h33Ry42W0h74hhAPDkJw6RQQ0G07OcwHDjsB8ZxYh/l3eFdIzGnHDHnShR+LMZYp0WpYZ4YxwOpae1zaoA2TUtoGkLb2sSpgqVshhJFPmiZhY5M1TNSoyy1AU4VTEn719rgtjWYNM1EpJjou47Liwvef/rU0B5e8asAjW2Z1jKZjjrNQAiKU10HrpSxy1nrcidGRJKirdCCaJRuSpH7cWT0A2k6MqVE1zZ89NEHfPj+Uy4vVjSNWGnEchDKnLETQ1ERtJEvia23qPEa8xypSoY8rg7r7JiedHrbwZ3RtObVELAGsgafIQ4T29VGh4bYuQFHytoEF2MixMzxcMSFxDgl9ns51W+/JCoRdW8IJ03bMsVRGz4jeB+UnxEzUDMhjMQJKxOy0a6llDCEGR/VCV4824s1m406BkNKiHN0ba8OULahN8X4seh/qZkuw0fAgl+iMld7OZzW+IcyFENYdx39qkcWqBNVFOUSyzJjMWnJSNcHJGRiGvHB0XaN1vEPI03TUoJH6m6rQ4c0hCDWEA3H48B+fyBFDWi1jWOz6tisO40ui6I4FF7TtLnypkak53NbzR+D9yJapLXob+Z6YbH3Sf1PSbl6EcDLM982Xp83Gd86M7JVvlgJimjENBXjI2n0dLZxvp4eN1CTenlaLpeJGY7HkZTuWK1XbLZr9i+PHDAv1r57GAZc6/CNFke3QTvh+q4HEfaHAzElus2aYTgSvNfIbLTOKAu9zx6ueaM1mlW8HvX6vfcFo5e5JGAhKERmxlqScLIN2TbIU6K4Gik8krm+ueLZs2e8ePGcaYr85Cc/QUKjEa8p0jU9XfD0rWfdejZdYL1y9J12jvZtMIQoXStPgdAperxER/PMMAZ2XozoWtTtA9FqZGu1X9Z6VRFPaIQSHY4512hf9TTqBjN/DoVFCU3QFE3XEgmM4z0p7mZQbmaQC1dqoIqR6p4w5n/hUYb7pihlR86KHAiz6e9EGGPieDywP+zoug6HJ6akk6BipGkb+lVH2zZaCyrQtUFB6vtVXcKSgqom2WyTvULLUpWiELEIfwiN1QZqWcrFelvTt87Ja69HfSq75kLpFeHkRbi+vuYnn37Jfn/LZJgefdvRdWpUDDGZ15ssoquNhK1vWF0/4cn1hg+e3qhRatOovDX5BRGrLbJ7LPxYUzhlQdSYjXE03MzS2KMIFHlxDpdz28WGAJy485gvl7DI/Snv4h3SK7zNMEykFMA1RMNNjDlqF3/WBp5xGplyJnLxzvBuicoX8P06oSkmq0W37miLXh6PBw77HUMYtOu5GKC2Xk5K9G/h5IjU86+YjZgvXFTxjPFZxkFmQWHn8gzpt9msTCYfdW/jwNObK7ablZY62dWqE12vbz0HFjmNcdTCJesYTVmHCqSYGEct/7i8uCD4FVPOTONIZiTlBnDQTIhTFJYUD0zDHuIO7xJX15f8zu/+RW4ur+maQOOFLjQ07cK5rCVgBZZPeTiSIC6UeNmLnDUCWpwHEkkWIrasLxYYWDhkVe6K8m7wgrgAQfVajqJT0nLUCXOTlspOU2SQkomITGnPcZy4v8+E9hfBiT8dtW1P03QadTTvcrffkUdtYCt8PcZYDcTgW8Bb2VxL03Z0veKQ+oKSEgyaUixiaX0cF9Iqz9SIfDS0CSsdsZ+YIuM4aIbFGvpSjmQS46TjcNfrNdeXV1xebFivOoJzdF1nsJRS61hzceDQkqtSmpfQqO/V9oIIrFc9/brDucTty2cK+eYmGCdiUgQDi72RScSU2e0mGr9nONyzO+zJRPrGc3m54cmTS66vtohExBADypEqsJS1Qz5r1B4pZQzOZKSOJU8pVmSKYkwW3n5IJTjgkqhN7KgZsuCFpm+haXTN0dMD2aaNav17lozkqIG1KZMYwSWQ6Y18+zhQf9YfhfbK7IaRrm21XlQyXnSTxTkbIZjJUwTvmVLCx0g0L7UJTY2wJJvQsxu0g69tGp1/6zyhafGhQcSRRBulqiGZZ2PMZUMJtEhOdrPltcQCK4ufWEZ3TmkOOGcbUznXFhVsVO89F5dbbg7XvHhxz3EcyKmMvMyERlitAtdXG64vL7nYrtm0sO4aVm2n3e/S0iZfU2xixcbOLTyarAX6iJUYlEgvc2TEiSDZL4zZ2VNSYehqhIScFiP8bH2YIyHFG1JDJ+oLXjvwUlJjWJxnIqH8mfDWuWp4wJSSmN4/41f9/+NxjvuGKJIZU2SIETcJjde6ypgi4zAyHBWbd2oCojlfnAjb7dYaAQ0YfBrYbrast1u69QoJKL6qz4jXpoVE1rIp0Ag81Bq+ZY0eYEJFJZNHnbCmCQQbUgHQhtJhWkMur6E56o99r0NLmiQLLqF62wtd0/Dy5R23d/cMkw0EqCleE7Yu4r3WO4XQsukaLi4arjY9m1Wv/JKzzdGWKvTme1jyMHUEqmQdX1FT+0sDRRKlfcrZWZXSuJDNsSxhVKDWASBIDvhUPPUF77psYcGMD53WoQ6OkUwjWscNihqSAILgY2btnvGr/t/72Rnu50kGoyNCjeaVprdUh0yg6ez7O+7vbznsD1xdXdX11SirlmwUtJQpTkiaaETFflGOoWm0rs1CpGVCXV4YXGpTJYuy6IAKstC1LawzTfBMY8RvtvzKxx+z3WwWUZiFk1HtNvMyTBDVmsGobYXTFGnblt3unsPxyH6/Bzyrbc/+EBknQxKIR51AKAqt5SQTJx1+4Uhcblb81n/oN7WRwxpYgzl+3jWKx1kMHCsITEg9iy5rSj5Hrb3Vqvu40CUlnetwC1ZVjVPct/JLgexwSfBm5GdQBYvZFFJsiwgp4Uu7pSTGnIhDZhgiOQ9kDKc8rvDN63XbN0ltb9FGkZpWFxFwqkOKAz5NE15mh6DwaNOURtRG9Zy3RudqOEn1rZzzCsVkY3kp9ihQSlKypcHTNGpTWe3fMASBYSBOCgt5sd3yyccfsln1Wu6CWGp/1q01aprmwEBEEWMSit17fXPJi9t7+q7VoAfCMAx0roEUyVFrp8cUSegks4Qa0bvDES93xPGgJTvOcXm15up6y2a7ouuCZUEAnI0AnuudNVakQbvsBNxoGVs1HGPWxmknugy1T/dBkAwbMa1LOTeGuexwyWmpJZzwbXbY4IRYF8o3PXlqSVEhF4+HA8fuSIoalImpeyPfPmqgasg5EZMeFlLCxYlMWw0l33rkOAOMK3h70oiLqCBLSVPCknNlsJQScdDPlTrU9Xqt3aPmwaaYEDNc5yihbo7Lbo4MSK01nhdzEXnK5nmdGAqL9+b6P1Q4RwtJm4EK0AbP5XarNUCu4dnzZxynhA/QhYbLixU3l1tuLtZcblds1z2rxtG3gbbVpqqmeJaLiFBNY5ZIaAnNl3ust+ZKO63+y+rRSr1j1d1YLc8ygvwaKkpCKoPm+h+mvFPO5sV6y/CrFNDqkwIaXASrsJVL/ip/6zGW+sZomjLTlBl9IrjElNRojdNEilM1sGOKiBk0wQfavqNxXp9RpKaqxnHgcHA0qeUwHAlNYwGhXJvysUiiE8UItqVUr1+kCmRAdZelFJugpQiltOWklvWV7Vv+ItfvLNF/R65GYemu3qxXPH/+gpwmHJnnz5R3h+NRS2yC4CXTeOhbR98HtivHZuVZr3tWneLyufJ8FUJKkJouUh6uUeI8319RQs4LnmW9rjmHhpHnvKbzvJQap5IGXjiXMjc0zlUuC94FcCZrBJwPhKYn1YiiKqiCueiyYrJu3bvDu+KsxtYM/wyMMc6NSmZIHoY997t7dvs9OSYDyZ/rfZ3TQRRd2zLFqGOqKWNkBcXTxKJZZZ0Xa132MOe53h8bqesdzrV0/YppXXB8M33Tsl6v1Ch2ucpVfbDyv5lf5qyDmOKfv/Pq8pLdbq/oFsOAiKgRLjvS7qCR1SQk0TlgXrC57hD6hnXX8t7TS54+ubGIs6NxmtoPVakXq7Jwld2jRXvFskSS9JxrM1c6eVsJIiwp5/q/Ku8rAkDV/rYaUjIOi2UigySSJJxviPZZBTfXkxGz1tymNNG2jl82+dDgvK8GzmQNPF6sjtQ5huHIOA7WBD2XCmkafy7LKka/OFnIiqWTX/zRvIDxS9Y3Yhjtmaq/5yE+vSFPKIqAtk362ozaGoRmsVNO2VeDDmK8oXXPeY4eOsdmc8GzZ7cqvQzDNzghINpYG7X8boqelBziksnNyHE4IGlHjgdyjqxWHR9//BEfvv8el9uVNac6mhD0cwJloMxsQej/9T5nCXqKolAyB57Z8Jl59FVuNjK7ooywLnxrITJEyt9BbOSriFcZb0HOOGbIVj8e38y3bzBQ1bIvBqordXRVcWZ8EGRUCzEtPPwpBIJzxLiIIGXFmPPBETIMw04jTFHnzwqCd4ECQJ1TNmxRm5hSF6/U+gllukkyQVAUe6nbq8pssehLoVgWvDK/KYG8iPo4cTif2a7XClnVtngv7I5HHX3aBK4vN1xfbrncrtmuW1Z9oA9Bp+4E9dpryla5/YGildmdKYxSBNvp/xa/k9n7X5QGLL2ex+Ak7A31grN6yJRibGfpFOcVk28pRMvdFd3V8oT38t98/Pu+IUpZp0lNUyJ6re2pzUtmUGujgzVamOHV+FaVa7basLZDxGn3Z85MKXEcjqycq+lq1UVa+L+sLV4KuYwKI7Kv3+2cRtGdL3u92POFgaoH3q5ZPVv7BjuHC9m9eKPywXaz0uEQdiZuX7wkOscw6iCLEFqCF9rg6LvAtm/ZroMaqF1H1zaG27sQXjJ/Ty6OzoJOz1x5JlezBSeNZFW0lme2yNND3l0YSfPZya/yLhj/qmAOodF589NivexyzspTWveUVf6P8U7QImKU0QhNnOJcC+00sjOMA+OkwPWl3KR0w3vvadqGruvwXktYyu9nuWKRa+YsTZUHFkxY+AVWey2VH4PTiValsUWArtG06Cxj5+d40yMXpUdW/+3y8oLPvnzB/b2ixPjg6bueEI52bwoFDgkn2qCqyHqBphEuL1purq8UIcM6y7V+ei55yCz4sN7kA7Nk4SguswAa2V4+QymtyPPCLeVxlRV5ft+Sd8vvWdb/JjX6oP628H1KURt1URScXzY5bxADImAg/DmXCJ+u2+Go6AplrGhFOzjhM2+ZDsy4On191j32QauZLpH/InFrtkVmmLW21XKqaZootULBN1xfXdI2wUaxLiVX4d1c72f+arV1SjWooKOzU9R61+PxyDgM9PacKWWiYazHlEk54CWpDM2RmEbSdIQ00Hjh4uKCjz/6kOvrCx3V6kV/glvUTLvaGF2lc9bGMIWkLEvx0FO051zI8VoqUJ926bQtn3vBt5lq3C67LOpqiSdnbSiUBNOoteLRR6ZxfCPfPm6gmrEZY0KygRF5b1E/rc+EZbRSlX02TzM6YZocU5hoUoN4q6sL2uG3+3KHE4OTcJ6+XdGFjimVyGWZ8uDVGK2sqQaoFrRrnaXkOS2qHtm8aMWT8lbrWs3cYhQUAb0QPtrQoTUmjfdEokaT1iu2VxfcXF+xszQxQLNqubnast30rPuGvvW0vlHjtNTteU9NaZkUNij+hV54vVLWg3oq6HXy1vy5EjmRYtWwYLbXaoj8yj+zCZIc9T513GdDCC3jQZuJ1AhzVIgscx4iT9jn//xjLPWNUWmmm6LoSDysEcJ7XDLhmWyaUSyK32qZjb+C17RTzonBpoiN08SYop6BFK3bPyhvh8YiKsal1hAw10R7yGHBow7xtgsLOSCixhxY/U75Pcv3zE5ViZjHsndVaGu0Z7Ndsd2uuX3Zcb8/st/vwAdNDyZoVmXKTmDTN2zXPZerRh0tm7zTeG+zs6UqT+24Ludy4bwu7vckVYRoE5abFXQpBZgNS6zj+WQz62sndKItZoFZeLhYOs45gm+QeKiLLWSch5zVSUjyhPt3hHeBavhrJimqIWpT8bSeV0uLdJiDTpYCHZaiDSYayWyaoCnErBBMJX1aOs9FRCOPmAGVYVmgVgzMwpMlWpKzs7Rse4Iw4l0o/oVdY/H3rzNTzWHUYKXuoQhcXV3w6adfctztGIaRft2TY1xMXlPTQGTCSVQDNHi64Oh7uL5Yc7FZ25pZ/bRobW9p3KjofrlE3U1illu1MqYa7RUMj1prV2swtWKSGndJ/trHfYWWvJvnM81SFzyYGpYss1mM2vAuFKFC9chzVgiwnBLSOFzUCWf3uzuG/YH1Zm2yVZtnvEvGj04xeUeb+FR5S0tcVH4sJU6J4lnNtMmOhGWcBYJzZCtLaZvAqu9r05QTx8Vmy+XF9kSfzott31SjBPaddZ/KYBT9ZBMaRdo4HLi9vePubsdmfUFMmcM4D1IZU0ak1VpM1KBXI3XC5UjXtXz80Ud89OEHbDY9jY2Bd8aDy2bHmoY1PSw5o5o6alOUZcKrAZ+BrDB7pQZbqtFqPGiyYemYvZKNzbPuOeH1GmhTYZ6SECMQk43w1g8P45HQPM63b2WgKqyIMR/CNE0M05EmmvHkPb7J+JzABgPEGBmdw8nEYRjpu1UN2Xvvub6+sRnf5u03Dev1Rg2LScHG29bPnoLOJKyCstQIZTP4ApYiYDY8S7d1qmbgnDZzFvLxxeh7sMYOIeUqnXQwAWjXYNdyebFlnGKdMBJJbFc965VGTdsQ8DZGrRojzkLvpTuzMAGWIijK0zAKSwuU0quB9xODBame9kN6K1lZvrt4XICguIpN6GnbLXu5t3sHKcIgz6laz4/Z8L8A/mdv+rZfOOWcFdojTTROo4QOFE4qOSQpfmCcoqZ/UwYmXD5qmjw0LIt3RXTU63EYiESmaeDYHum6jtVqTesDZcSkaD58lmem2JUDnTYMOFmMtCzHS6rAWHqhXxcFL6ZipZhIk43vzOrkOdEU0OV2y/B0xL+84+XtLYfjnpQV9m218txcrri6XHN5seVqu2HVei7WPSGIQRb5qryrQKqpLv3nqw2Zs3Ml3leFu3yenKnp49nxWVyh8O5Dv+1ks201lsIyJ4RkGJ4JUnFxK8KnnWer13c/IbwjvAtQIkJxmoilbtiiUnHKrLzK0dVmhSRVLTGOhKAwYpvNlr7vSDkqhuY0kgpmqAHlmyh87CaoUW0oXrLJYLGhJHPt9CvRlrz4s9QS1V+U+jm9VsLhkiq0MhJXsYGz1YlqLeEPv/8DDpNODRvHCd90dF5oA6x7a2RcBfoeLtY9m/VKSxJyRIcWUKGsKEagRY+KIXKih2u0VLvTi9FSGv30NX32si7I/LjFCVhmRrCAxJxEWPDuyfdad0S2hqzlPc9/qANm0/1+6WRyJ8URbIxlzomBPXFSA5UEXVIsmMIkzmlEdbXq6buWl8MBA9SxCCHEPFkNZdGFuXakn6ydOSDYSNUmaFDNeUfbNKy6vtaf9l3P+++9r+85YdgHtDgsteQgWwlI0sYl77QU0Dvhs88+4+7unmmaePr0KRebNc9f7NgfJqaYLWCmdfgeEFG57duGzarjg/eu+XO//uusVj1d2yjSC0J4aCSe3GtZFWUshSgrY4nnMkzN+hUzfhFRWezhzONy8rnC50tHfynny1/qXYmrUIYC3B+OkGzKJps38u3jTVKWwlySjsEyoH4B8ULwDUkEnzKhsVnmfq4pwTkkeCasmDx4dvs9TdPUCGSpfZiiRmZCCPR9VyOhZTnm6FNZSx2v1rZt7QB+VaHP13Cikb9iGNRXjann1GOZQKSbl7A551Y3I0FoLZWVyUSJdG1L2zSazreUQjFQZSnNll77aVjMhOViGGZ9lFMrU06l42sYrH6KFJdjzjh5DRYdrIV5zehINvkk+EDbbGjCRrH9OSrWnFjkVyyKJnuQ33vtd33TVLvFs2MczOjP0QSVINGRIzUShY0Qjc4zpawHw6k3X8ZiEiOkiH5ElbcXTxsa2tDauNFirZkjZQe5YCA6mWdqaw2P8kOpyVLhpxcoojctpk6d1E1DVWxz5BSbgpNxWUfmSQNPbq5ZrVZc3+/5/IvPOY6RmBLOO26eXvHkWuHQtpuOzbph1bZ0XWPHd+4qL8bFqRSC0pR3eva+hmfLqznXesil+VLqVx/j3dIT/QrvUmrSIt4pcHbOMsPcpJGcF2fcOXUa2SPvCO8WKiVTNauTTVGQGKcRab3C4jgxrPnEarWmaVpijHz17Bnriy2IaO111m5m5TlfHX0zmfRH0JrzGMF5k7kKMecsa4XBHBZjqxibYP9cyiRLB9amTU7E3xx5DV47csseWrT46dMbxmnk+XONnN7evmCM2DjirEZNHxTarw9s1x3rzrNZeTZ9x6ptaby30v7FfS1t5frPZS1unm+Sk4ej8M2S9GyfGqNfR0W+zsp+GZHLdY9FtHShDQ3Het7maF2RISIauX5XqOClkxV2aiqZ2CniGs9mvVXknqSDf0DYbNYW8S/N1BAab5nSmVdO5CcmH/LSkVV+0/KpAs2WtczHdWrsLvbc+4au7S32lk94s74p1z/0VyX4UP5tclzQKYKbVceLuyODoRUdDgc++vgjdruJ/UFh4qaUFQdWIs7r59q+oW0uuLroub7aasY6BJbN0SE48rKBVmZmlgfnrmQ2i14pddz1vTLz89LByml+T7G3ypqcGqlzpmrJ89nWxC6i48CdJ5thXtCYsmBO39fTGw3UeqN14+YDlHKkaVu0eFgqjM18m7NnpFhiZcE8CWi6ljwMygxOtJA/zyC9zs84i0WDFQFZhGBGcc5K1FHsfpcHXoWsFSOLWMRmHhdW0im5rmkpWZjrK5dpWecE8aIKT7CUpKdrWoUHsoLwGuV9YFyc0Gtfe1zA1Xc9FKavXPpU6H3dNbTZCmDxvmR3YY0LTjxt05LjAUWZLswrhqUoBBo2efNW9/6LptIglKGC1vtFQ0/xSkqjWTEGi9JVr1ONcK3h8zQieAIyOivwV2iUtukRcTZJxNVyDsEp3JtxcQH/9iZckhmXs2FahEFRikUYPIhi2R8len8aW5cTnirCpe+EpmlYrVas1x3746gGqhNWmzXb9ZpV17HqGtrgCV5qCkkjXQU+JGk5TXntT7BHM8+f1u3Cn5R3S52eNjEIQggNjiO1fqAEzuxbAw0X+fpP8DQ/P3r58iUXFxeLKI3tv9V6ppiIXlP/2Su0nPM69a2k8KfJege8ZWOyNqzsj3sddSoB5wM+FLQAVH6agx5ZRJztu4MP5nhRoeVmyDBZnCN9rUbZa+QJYClnF/Zf+X5mh0skc7ndcH+/5nA4cL/bM9lo7GjYld5FtuuO1aph0zdcrDvWfcN2pdB+TaO9EK50MhZlW87dgvdmRfxqVKr+a6HwH7638OpptPTr6XW8W5zMMka1rIVzCpN20sxicjfLq5PafhlU+RZzPis/lbZayGJY3Qskm67t6PpWcdO906xW1qEizps1WJ97sSMFVxPUNmB+Uc+2/lvxVG1QhTWjFl4rMJXL/oRT2fB6EleQWtRoLvrDOR2w8uVXt0zDoPrHynOmaWKcRk1z50BuNJLobbTvxWZN3yautj0Xm7U6ViUTVBoZRRWHoezpv6uvtDAU6+M4MxYVLrRCVHEqdaUY/k5eee7XBSkL39b1OF2dGtHWY23OQlw2uGqGaIZfez09aqCW2c1kXQOfMyF42tbba4F+pSPyfKMgRMNRZzM3IWhkycZFlutorY6rOGc+abTQh6AdiTkRQmewO/a4NWBj3nwxCi2dICZhc1Hor3kWs0cMGmmu+VQhOxdXz4aCCZuF0apTiTR6q2DCC0/GeRvX6munfilXKIJfZ2DPBofeaXxFkL2xsanc+RsEYLlWmfTy2DXmS81RQB0FGBViJasXGrPTCJQpraKcAFpZ8zG//Vb3/osmxbBrCE7oOgN+9k6jp86TXSQypzFCCLRNo8KyaesYTwWX1mlPoDwYzOtrfEPwDU1oGB9MlvIGw6NCQoV0EQDFcSmjSytMyEKg63dRPeHC49grGigoQmDm2+K5lu8USXjRxsRWhNXKs9muOQyjdQNrxKxrgtaaWtSikJzclwmnlBT5gHxy1h7n21wNrocGQBW+Dz/xJ+XdFBVexnhX4tc062RoWb0zvDuOOrykCQoXo4DwSR340uxk2LlNqQ/GKQRg09j40EjK6vSD2mVZHMM40oAB6C/aGuoaGt84VW6Ogi5RolJikX9OeK4qz4Wjv7AXHlX2NetQI8TZ0r+wXq+4urjQch1QJIJpIJvhsd30XG57urZjs2rZrnXy1MVKm0q0y9kZwH8iuVRvSps9ZoieOXv09Q7/w9dP/z0r28cjqfMZX/JuDWSYgSpEyBMpRq1nXxRnL42szBxM+mXSCd96wTsNEiBizrDycdO2BBSXs2tatpuN9ZqoUzmZgVpWqa5LcSdmn4cSjJLlehbnwS4QbMR4aSqiTLqzDzzcJr3mq89XLQv7o9RuOikTB1X2b7dbmuAsw6rrkaaoEVBnDdOupWsb2jbQtQ2rznOxdayaxMWmZ933NMFr+UAxf3NpjMvmKJph6Wc9NmeAs7W7FKjMwqvUxZttEfM6xUqsFsNlTh2f1/OtXmvWGRmZy7YqZuz82XLtmBNTfpxvHzVQ33vvPdbrdT3goT7UkaaB9aZlvb3Eh4bDMLLbHejbXhWCD0jW7sLrq+ta2J+zTvtY9x2H4UjTtdZdpzWCx+NYO0+rfS+ObJ384hUaQURT++M40q16q//LdXzZMoqqSzt7zo+RRovM2+CUeTXNWX6WAvpBeke02zWmSJqmCibcNA1OghoR9v6CHHXiQb+BHjLOQ6/+4XvfdM1Z0Zc0sf0wIRyRNJDjZMLGac3mwsMUW7i1XPLb/m+/8f6/Cfrkk09YrRQsvHGZy0tP27ja9DeMkcNhWDgkpuDF0QRtDGqDFvHvdjuuri4AjUyVwzgcR1WAPnAYDmYo1iDNKzTzRxUh1jX6JoVGjRAU/hUDYY7WKFK61vU1qvPgxGsNdnGwgpbBdN2KKUXF2xN0cIQrjWRfD/2hjWcRBihiPi948WHqc6ZU09Xp5P0zBM1D+nnyri8RqMq3C9NJYPUO8e6HH37I1dWVKqiccKJG5nGcBx20bcvFek0ZRRGcZ90rSH8xZqeYLB0vVR7WRso6bjkbJI1FadDlU1galXVeHLUHaHnuq/yj6i5BDGPxNDIyp/gX1sWC0jSRbcpNgQ0K4vB9x3tPn7Ba9dzvD+x3R4Y44UOg7VvW2zUrcypXq57tqtMJQH1nQyfqNygOco7MNbMFI7IY1gsjcXEWl2fzcTl9KpMfXqeQflRe5d35Rb1W1pr4nIY5wiyn6yeipSCHcXjN/Xyz9JBvvTPoM1FHaTT+vdxsSOOIy7DuV2zWazJwtIhjRrFSY4pIdIbhF6qeWRpJxejFfutFo/5YlnN+n7yyJyUFXh0W+3m4YzPvzoZyRg1gbxPwSFoo5JxjvV7z0Yfv60jiLHRdj/eem+tLVusNUwJpNzRBSw6a4Fk1nr47sm4z67bRgRIhWB+D9khMOTIadryhGqqBKo3dwqkO0MfPdZ1A+XaapgUUHXW4x8namBwpjqF+1p7+NXz7MMWfDee282nRsTavYgk+HOLjfCtvG60705nOdKYznelMZzrTmb4Jehwl9UxnOtOZznSmM53pTGf6hulsoJ7pTGc605nOdKYznemdorOBeqYznelMZzrTmc50pneKzgbqmc50pjOd6UxnOtOZ3ik6G6hnOtOZznSmM53pTGd6p+hsoJ7pTGc605nOdKYznemdorOBeqYznelMZzrTmc50pneKzgbqmc50pjOd6UxnOtOZ3ik6G6hnOtOZznSmM53pTGd6p+hsoJ7pTGc605nOdKYznemdorOBeqYznelMZzrTmc50pneKzgbqmc50pjOd6UxnOtOZ3ik6G6hnOtOZznSmM53pTGd6p+hsoJ7pTGc605nOdKYznemdorOBeqYznelMZzrTmc50pneKzgbqmc50pjOd6UxnOtOZ3ik6G6hnOtOZznSmM53pTGd6p+hsoJ7pTGc605nOdKYznemdorOBeqYznelMZzrTmc50pneKzgbqmc50pjOd6UxnOtOZ3ik6G6hnOtOZznSmM53pTGd6p+hsoJ7pTGc605nOdKYznemdorOBeqYznelMZzrTmc50pneKzgbqmc50pjOd6UxnOtOZ3ik6G6hnOtOZznSmM53pTGd6p+hsoJ7pTGc605nOdKYznemdorOBeqYznelMZzrTmc50pneKwmMv/tZvfJzbzQWIJ8ZMjpnxOODJODIi4AWcyzgB74Su82y3Hb/2a7/GRx99TNf1fPe73+VHP/yMlBziAs4HshMQkAQpRcZx5P7+ljhObLYbnHM8f/6CDITQ0LUtq65lveoQB46EQ79bRO9X7C8ignPu5N/lTeIEkfnHO4cIOPQZRIQmtFxf3/DxRx/x7d/4Nk+ePCHnXD/jcMQYYZr47Mc/4bt/+If8s9//A9b9iqZpECDHTMIRcyKRiCkTYyIBCPV+nBf+pX/pX+S3f/u3ubi4YBgH/uE//gdMcWJMI5ms73MOEc9ud+R4nBDx/Oq3v42IZ3txwcXFBW3bslptGMeJL7/6iq+ef8W3vvUtNpsNznkyQsqZSGa1vcT5liyOnJN9i97aYySAQ9ehfsjo//2d7/Jf/1f/l/zBv/333nSZXzj91m98nMNqQ0oQxwkf9WbFFZZPQMaT6FpH37dcX1/xV//qX2G16vnRD77PD77/fe53RyDgQkCcB+9w9tzH/YFhHBiniRQn3n/vfV7c3XN3f09MmZSBrGfEO2HVdlxvN3Rti/eCSKq8i2RETnnZOZlfh8rTIg6P8u3ydR8E7z3BedqmZbu95Hd/93d578kTmqZFxOGcwwHD/Y4//IM/5Pd/7/cZXt7TdSu9tnFAAnLOJDI5Z2JS3o05k1Kq3yki/N3/1L/AX/rLf4mPv/UJv//7/5gXty+YovJuub2YYbcfOBxGchbe//Ajbp4+oetX9Ks1H374Id7pd3766Wf84Ps/5PLmho8++YS+7xEXSNlOgxfa1YamWZFwZBLkB8z4U9Iffify9/7Vgf/1v/3+O8y7Ts9vjDiga6BtPBcXW771ya/yd/7Of5x/+vvf4fnzr9jtd+x3Bw7DOPNNFqaUOO7vGcdITHru27an73tudzt2+wPJ5IGedfAidE3D9XbDqmvxweGcMTdZ5bgIzsIdyqPYj8m5Ko8dvjyo2Hc440sH3gW8C7Rtx6//2q/w7W//JpvNhhAagijPD7s93/lH3+E/+P/+Q3ofaNseJ/rlyrNKiUTKmRQzEVQWG+/mrHz967/+6/ytv/U3+ct/9S/xz/7oD2fezak+S8zCbn98hXebrqfrej766CO80/d+/vkX/OiHP2a9veCDjz+i73t8CKQsuloO5d12bVr0zw7v/savf5h9u0bw5JjJUwQSXbcip8Rw2ONRnd13LU+f3vBbv/Vb/I2/8Tf5D/7B3+f27iXDcOTlyzuOwwiAZF2eaRo57nZMSXUpwNXNE2IS5dvjkZgT2GtifwYcjXN0XUPXB/ou0DUBJ+Cc8awAJk/NLAEHTgTvigwT4NR2AOVdLw7nPE4cwXvW654//+1v8/57H3BxcUHTBNrQcNzt+c4//j3+0T/8R6x8q7aCCDnPqjRn9IznjB17Yp5IKSlvG6+sVyv++b/0u/z1v/HXeHn3gv1wT4xR34c9gAjDMHEcJqYp8/TpU9774EN8aAhNy/sffsC6bcAJL17e8sXnXxJz5oOPPqJfrQmhIYuQUVum69c0bU9yHsj1jPys9O98Z89/8V/7IYf/y1/+Wr591EBN5UFxQCInFVupnidVGC7pxgJMU+Z4jIxjJGc9tCklUprIOUCO5CTgPCJOlTRZhZP3xGmqihSEBAxxIh7UiJ2miYuLNU6Mk7IoFz+wllJKeO95jHJWo9GLXiYhOJ9JOXJ795L840ScIn/hL/wFVqvVLGQFNepSYooT0zhVwZdSstuRykzz//PMjCYgc3Z85zvf4Vd+9Ve5uLzU58p6b06EvDgMYocEMMbOaqw7RwiBtm3x3hEjhGCHstOD4FxQZstqMTVNo8aaaZWU84lxWgzyh+Tqfdg9Lj71nn/B303/FvD3Hl33b4KmnPAZchZS0jV1kpVdENUUKRJzYhwz3kXGIZGTw0lgvd5yc32DDzuGITHFSM4JmfQMqKEWISXISa/vvPKtCJUfsxqqOcP+OCDApp/ou4amcbhycGYRVZ8hpdlgdc7p3mG8J+AXik1EkOiBiGRhyBO3t/d89w//EKbI1dUVfb8iO48LnofnBZb7unw1VydJX8v1z8Lzv/97/4TNesNms35wvcW9LT2g5VdX/s6Q9NucczRtS991dF1L26pxHbO+37eB0Hbq6OLJ8tMreZVN87+78B22+V8B/r2f6jq/CPo63hXnTVsnUk6Mk57ZOCVAnfK2bdlstzRtQwgNvLxTQzQlVShViavcJRep4vRHBPAqp/PsqDBMvLi9Yxhaui7QtgHvPM6ZCJFs/CroRpqctGBBLr8jMwFenBofQIxR5Q2OlBOkyMjAj3/8Y/q247333ufy4pLUBLq2rYoYKSa0aaJ8yrvZjMLZ3C6/z/Xn888/54+/98c8fe+GaRrtPljwZTVNTOaWIIX9mPx0mAwVMVkc6LqOrutwzlfedY1X3g0B/gzybsapMZ6Mp5zgxJFOdPT8d3ViMs6LnfWGtu14+fKO8XhkGidiiojtl25wIj/Yz9fJMxUpiZRgmibckPEeGh8Ql0qYza6ZwS2uUr5KivRT/jz9TtOTHkjK71PO7O7u+cEPf4iYwSqrFS5agKqcw9fca0Z5KC34UzlPnbeUkuobYJxGfvTjH/OPvvMdfu3XvmVrnKqeEK+mnXMJZ3ZWoWIvNE2Hd45IqkG9FCOtyV2Vr3YGzKj1IZBdADNbfxp6yLefBPivpQ8e/cyjBmoRMOBsD7P+HY2mlMhkJhGTHjQniXGMTFMiZ8F7FSpN0zBN2dSdCasMYgKh/lhU0zlv184qXFGFDRnnhK4JNMHTeKdG3fKm64Lk2ZBDmU2FZBU5J4uHQE5qUE/jwO7+ni/kC37y45/w4Qcf0PU9IQSNwqIMk1PmVGlnM4ByMUnr/5f3VT4TY+QHP/ghP/nxT9hutvSr7uEWPIhq5tcdRQCLQAipCPCMraXDeTUtM4AJDSxilkW9xYcG6sl9lMgexcAzw2Nxf1GEF68xan8ZpN6mKpSczalygrdICwshEJPyVhUITmjbhvVmQxbP7v7A4ThURUrKKijsx6VsyqmIEyGZJVbMO0kwpsg+D5A0CtZ1ga5rVUC7YrkVXjKnz36UlzM5zyteFGLh8aK0oyn5nAe++OILVl1PSomba9SJca3Z1bk6nVA4S068+aLwk/0pJ+/V+/rq2Vf86Mc/4v2P3tfo28K5KTJiGSlLWepaeXEEHxDxJnzNQA0Bb3wq4nDeV57TaIUsru2YLeBTHtB7WP5WHghKi0hIw5/n8qdntF8AfR3vBh8gJSYGVdKJGlkp0faUozpOwGrVkzMMxyPjMDIMg0aWckZsc8tuuhqNL3yrvy+Kc8qJw6DybYqRKSVWXYfPGicXMz5FyrVs7Y2vXTUcTYK4zKnEUZMZl0ES0zhyf5f49LNPaZqGrm0QOgJSZe6Sz8rZnXk314hT+d6Sfcg52U/mcDzw6aef8off/S4fffy+6ibBgid2rzkjzlVjtHyLRtg83vYF1EAITaNyoEaG3fz9xrsOyO7PFu9GXQLIYgEWp5FK7229zaxJqfJt2b/7+zvu73d69puGzXrN4DyDPzIcB6bRIqrMPq5zQkyPZ/2K0TdOUY1NyQQfCC7jczZdnjVIlqtfBSmb7VPko2iGCzFZbc/oHBHAlUgjuOC5390zjEfLnk6M5UrGU1XS5/n6ynivOizFMVrK/SlOvHj5gh//+Md88MFTXCO4rA5ecQz0nl3VEUuZLG7B3ygft21L3B+UP8XhnSObvhTn8eaY5fIMr1n4n4ZvJ3F8zuNBxMcNVKCYjxo1FRCnAkLAowcup8mMSN1oP6l3n7LgfMOqX7Ner9nvB6ZoHoRFS6rhm3WzRMB5p965OPXkKcoycRxGUkys+p511yJdg0dTTroI8wKllE42JmfjZtu0LK4ye0aNZXBISkgWxjxye3vLD37wA9oQuL6+YbVekV2m9YGUlgJwuWbzZqXy76xrKSKQphMj9asvn/Hd736Xi8sLvvUr35q31S60FMKvOtuLCJwpnTiNxGmEBLLw+NXgL5/Jr7mKHtb5IL1qqNbvW6T4ywocpeF78v7DG/ylUMqcKHkwXl4YdIXvkqXjS3Rcz58g3tH3vTmtwjiNTFNkiiOkhCRV9GJevTpcILnEleNi7zOSYZgmUkyMU2SaGhBP8JngnS1pwrkilPRZsmMhtCzeJXrPRWlC4Xf1pEH37u5u5Mef/oSmLcYwBPOykxmoqrSX+1zWS7+2rGV9ReaIUsqZw+HAp59/xh/98R/x8ccfaqR5qeSN706VNVYWpFEG5zykXA3ZpmmqbqiGfynPqTdnnGw3JQuefr0TVwT0/Jvy2D1P+Db/hUd56puir+NdHwIuRkYLEehxd9VAdQ4OxwO3t7dMU2S93rBer2ic5yAHSJkxDZRSDlfOetmvoojzq+uYcmbKmTxouceUEt4p7/rsFyl9jEVN0mhqyowxyot6buqblaK9nkW/z5F59vwZNzc3TNM10XuGXM7FwgFcGDqFN5dRKJVn4MSRJc2yDYgp8sVXX9L80Xd58vRKz0F5FuNVl1UnzQaqfto5h3/Au9552tDouSqrJ8XR0nUvwcQaL/kzwrsxOVyC6uo6NZR8MVCNb13W7FNKkRIR/eqr5zx//hznPJeXl2w2G7q+w3uPd55xmgiWQS06zDmncpfKVcYWeWYrEYsjZOIwMcWJJgSC0yxjLS0RE3RVvamNk00vLB2WvLDMcpX/9p6cka5Ree8F3zhSjkyxOHFFHpr+EWf3XZ5gdlhmrpidL/UBMqTIbrfj2bNnPH/+nJunV5rVZ75PizypLnOzTp9vfv6L956ubdnvj+ojFh0oc9x4Nq2XwYqfnW/v2PP/4Z8CH772k/AWBmr5Ygt4Liz/2bMnFmGQiCJMYyRFyEkPZL/qefLkCXe39+wPR45HTaWkaTIFmElxQuIEVl/lnWMWo8YItqlTmpjijnEcGceWvu/oGmepJkH80rCqVpQuqhdAo7vkpDVsRQGKEGOsgiknIaeRT3/yE4JzjOPIkydP6NuOZrVCMqSoZQAqvNyJAZmLEE1F6diWicbYYL7P3/8n/4TVZs32cktKkVIXWoShPT0lzbGssy3GBhmG44FhOELOWusY/Bw1LNcz42E2S0+pHna92WqA1sjwrAtOGHWT9/yV/M/ehqV+4TRGR4gqOKrBbULEWaFRmmBWciV6BzklXrx4wU9+/Cldv2G92tC1PeM4cDzuuZsi0xR5eCRPo3qzEVeFplHMmcMwMsVIlMyqDzUToHWoQnBWYmOC0gmEVBSkebEiuORsP4sj5sniVRnERAiOFy+fsTs8YUoT4zhYetJZ9Dia93/i6jCn0HRvi4DJdioFNB0rWtv3xRdfIE7YbtdIKAKprEVxDJzxfp6zHkWuxFTXrPGBru3wvsE74zmLDmtqtERg5zss913WR7/+Vd6tn1gosExmZOKz/OLtGewXSF/Hu03TkvyEHFwVJnGatCbVOVKKvHj+nO9974fc3++4vr7m6dMnbNYrrlc3pMvM82dfMU4TAFOM5pjN2ZTZkbU/zYkry5UyDFNkyrofXSMa7fYO70FMBpcPScwkAe/dicyKaa7xFISctFYgOzUkBaAN+OBo+4Z21drajEguPO9mfUS5R2dGhSdb2FaKkW+GbUaNYeW7yH6/59mzZ3z66WdcXF3g28K3+gw5m6wUAZe1Ht2eUfVYrKVPjfd0XUfGnhnAgjcuhCoTluUD8GeDd0ccIaN6NSWy0/1putYi5vNuxRiZpkkDKnHk2bNn/OTTz5hipu+/5PJiw8cffsjF9oLNdkvbddzd3bHb7Tgcj0wxEbxnkIni5mghIlUGa6aAqvQymSklXtzv6IIQnKMJnr5vwJ92jJvUo5QPSI1ylyxW0XtJIwjlubM6bpeXl2w3G7q2g5xJU2IYJqY04ZxTB4+MF7vzvLSvRGv/ZQ5uJQt2lbLLlDPDOPH8xUv+4A//Gb+z/ou0fTD75sQI0X+Z7BQLFtSssvGVB4LzBO/xweuzpUwmgvfzmv4c+bblO7yf/8vAs6/lqTdHUHO2YvNkGxBPLHHnHNNC+WroXhaetKZMm6bl6qphtRo5HA7s7u8Zh4k0RXJMEOMiAlW2SVlOo51z/aZkGGMi7geG40R3HLi63NB4IXhnG1jqKkSdiMwssIQqYCT7WWAU4TnFuRIgZeI08P0f/DGJCVziydUNbQjklIlTZBgnQL12XyOPZQNnhiikakDIRLtPuL275Xvf/x6r9YrVqsXaU2wV9JpVhZs3501oBq/1JM415KgREu80Eow6qFonY8yh96V3NqdsXzVU5/utzFDfW15YZqf+nKz419NvvIGjvhkas9DGjNgaO/Faz+scofUEJ6TpSJqo6fGoNf3klHn54pYf/OBHDBNc39xwud2yWa9Yby65unzC8y+/5OXtLYfDAVAjjWWErxzSouRFrL5YvWYyTClxe78j5xVCInihaxvaRnmrFumZDCuGSPUd0JSuoFElrSEyw0KUcwKOy4tLrq6u2F5slWeyCsuUEs55xjThfabUm5vYBUSbGTWktXgqFql/IafEcTjy4sULvvvdP+ZXf+1bhN7jXCl08AvVlMFlfGhn52pxNpwTgvc0IUDOOJwZamoMKBs7DZxIQmROEb2Ofx/y7utIgM/4kv8N/zv+G/zrj7HVN0Jfx7sxTTjJdF3LfjpSZI7uvWcaBy1Pmibu7vfc74/85PPPubm65MnNE26urrm6vmG13XB3e8d+f2AYR2LKOFe8iq9Zp6pcnCrcnNkfjwyD1re2TeBiu6Lrm2IP6NvF4a38YGmY6Wum1orCz1T5GWPEe8/FxYU2n1pNXcyR4XhQ40aEIUU8AS+e4u0UrptNFuboU87MMTf96uM48dWzF/zj7/w+f/mv/C6r0OOdxvskV8FZjXjxHrwniaheXDxP8IGuaTiM44J3qUqbkq3IfzZ5F3QdnDiSOaIZ1XGhCaRpYI7Ua4nPNE2WHXGkpLx7d3/Hs+cvuNxecH11xdOnT7l5+h7dasf+sOc4HK0Uq8UfDrjFroMt2UJ8Vtc6qwNzHEZeHg+0TeBpuGYdmtrkVxxyja7a3xfucIkpqliWWkaXszaSb9dr+qbR+lMKzyVithyB94zjRFuaF5nvM4PW7WY1YgvvZHOWfPC1ucoHT9c2HI4HjscB32o2avEU5mi6OThgUe3SLFuewwetmfZyWyP8OakVEkJQPk6ZVBp7Fzrolf2vN/A43zYErt5QmvJGAzXlkqa0WiewThl9yK7vSHEgjpHStpxKLZkAKXJ7e8v3fvATVt3aCsd7mqZhd3fH8XAkHxPm1M9hdFQWuqjeRN08U/KqHDNjiqRjxt3v6VpPG9QLyCRCEFyazcEkCSd6aMS694W5ji9lNSKyeegqOzM5x5oOKEw3xZE8qUGuDVuaMEvF6JOSCsjVgyn2STFYS/o0mzf5xRdfEJrAt3/z1/Gts7D8UmUUL2Q2foSMd1oSUVijCYHJB402MNf41k9mB8ktihyXjCYnzk5Z6/n42N8enirgczz/lr/kv/smpvoGqBzqEhnXYijq4fReuy9TNfjNMIulhhqmKAzDyJdffsXd7R2rVcfFZsN7773ParPFty3H45H9fs/t3T2+eprMyv7BGc1lQwUTlpEpRva7e7yD68sL2iYsnCgL3NQI5OxgVYWfTRZENK1k+5pSorVmozYEgkXSY4qMUb35lBMj2ijopPA/894mFmlmfRgVuNl4PCLiiCmz2x/4yaef8uHH7+O7HiwCIRbGyMxlNXq25hRSTR1lTZ12bcs4TVqiUhavRtuo5/NUQr6Zd3n4Eft1w8c8lX/lLbnrF0tfx7sxJVxwNG3DfmcyMi/yTElr7aakAYU0wTCOTOOX3N3t+OrLZ1xfX3F1fcVqs6FpOw7DwPE4EEJTI5IPhI7JSVkcfDnZr+OgJUsbVngXbL/1x0lxqnkgbx1l54sBoOlyNSAcwna9oQ2NIa1YWY7JWBccTddwPAwkEXNc5tKRhAU7khrxSajlWCKiTWRNQKw5twkBhNqA5bSuBiRbREuIzOVSmoOwDu66cRnntTxlGMfKu2UpnfGuLqEFYeqH//TzrhprNa4465ykfBBC4BhHSsjFie25yaqYElPULv1MJO32DMeR29t7nr+45cnTJ/Rdx2q1Yb1aM4wjOY1Wq16akm3fwHSunovZMRJt/kkZjdo4tFem0R02mVJEuGQtpxLR/o4sTiP49nReRH+8NeuJo+86mtAQxFf+1/UQVusVN0+vuX1xh3iHeK81sb4BgaZpGePEOE1MMULw2lOSM74JXF9datlEcLRBy7ZWq97Kt6T2ITiTIMmir0UW55RnvpzDy2rwWvRfHwTqklmZYI4mnyVppFaFxc/Mt57AlTx5lKceN1BzEQpmnJa6jKJYvDbfhOA1HV7DJIv6uZzZ3e/58ouv6Lod69Wa9XpF13es1muCD3gf1OAsdaxW76MMUphlYUItolI5q+A+HAcgqOctQtNobZAGq+Y0bpZM1pY4TeXLLGgxBZpTJjnzudWi00L9rqNtO3zQmpqpdOWh1YbFkK4CvfxfLBLMXJN68pO18eD27g759DOePL3m5v0bjXY93JI88wVQBbKv/1aPTvck12j0K4ERS3880EWP0mls8FV6xgX/Z/7WO2GgSrZ4oEAyo7FGzSmGajHOy38amUtTJsasMD8pM+yPHA9H9vsd+92elGC73dI2Df1qhQ+BKaNCriI9LBd2wbvOfp/LwfakDNMUiSSGcTJDtKTV8ysGqRQnyxQ9gnXNzo0ZxYjou16VvPh5/zLkrMZO23cch9FKBqjr5FST63mptdZW052Udxrv6awT1AdP2zSEptEHLUazlBjAnOCb6wVdsbYX3rYKyqZpanSqBJKX1d611OU0TPL1/LDg3de93QHda5pVfhn0Wt5FiDERzAAq9WvGzNVWTzFq2VHKxII0Mo0Mw8Rhf+Q4jIwxsVr1NEHhnEQ8zgWc1whLTsW8OFXsLP5KLo0YpdFQmw2deESiGbQWtbL7L2q9NGGocJbZWLGazhKd6LuOxgfVBcXZsWt0Xcf2YkvO94Qm0PiG4IM114ILQRFWisEuQoxav+i9Z7XWhteiv5rgaRpteKqoEpQU74LfCupGsYGWili0PCGEQChIGUUPzn8xByuXYPRsCHwdP/wp4V2PKHwezOc5lyAONE3D8bhnaUDWko+Y9CclYrIATtJm6+MwcbSSqO12y2a9Zr3qaEIgp4S38qiSNco5Lfg2L+QmFkX0CEEjthnGKTGXXszyqTb8oVlYZ2etWLGCGafOW+bWUtdNS2O85RQTE5ed9jSsVzx5ekPX9gQfWK/WWjLYtIgTVv2al3e37A57syuEu/s7mqZhvVlzfXVJFgjeMk2NNjf5YJHTXJPtVZ7DrDvIs57QbVo09xoKiIUByCkpnGbojJX1dy7Pn3tM8L6JbwOeSy4e5alHDVSXPUTzlS0VnaWEv4vASjQhkCZPNMEkooremok5Hifu7va8uL2nCS/o+57rq0s++egj2ran7QYthvaevBPrlPe24WURli491kBVmEmbTpwTxnEijyNXVxfktoS7TZGdKPm5jk3XeSF4pBwyLUj2TlitVqxWK/q+U+WZElOaiDmi/p5i7bmqcK3MAYuEZoNTKXekb9GIgVht1zByd3/HZ599wfV71/W555pvmaMr5XbLYcq5QlCUVBONmH2Q5joq7P5SiQ6css4r7CYy/24pAxd/L4X+dzzh7+f/3Ndw0zdLLmHYhAC5OjolpSyADw4ZzDjKgkaWRQvqrZEppkScEmOOHIcj97sdd7f3PH3yhJubGzabDW2/YpsyITR4F0z5asPSfJCLLVHWXveipDTVq48LA5VFJCpRuzGLKb0QpoKA1fgFO0dqSMJmtaIJzQlKQ3H4VqsVVzdXHA92/lwwJa+C3zWBaVoqeVMcVgPddA2byy1OHG0T6PuWzUbx88qXLbM8pQ67GBz1ECy4sERVyhmrVAUkWrKVtCO3gAzpcz3g3q/j3cW/s70v8hX7/H8C/jtvzWO/KHIZvC/QfWYYiaJzgMLJ5ZTBUxWrc7rnOeVFJGre8RwzMQ4cjl/x8v6O68srLi8vubi4oOtWGqEJvqYqhdPGuRPeRTNQiqyQNeWNVLgrsUh8fR5XjFK9RpgDUPanGhjBeULQwILLQhsaNTyt810dJs12rNYrnr7/HiG0eOdZ9yv6bkXXdYgIm82W+909+8NBMXydY7/f44JntVrx5Ok1KWc1TIMaGN572jbMUc2lA28GqiYPF6l9UR1Rq8OdwUw1rQVsaicCKZlNnhMpScUSfw3n/qnkXeeCGWoGcBJVfk1Tom08bd/BnT4/zvSi10xeTNF4ti41U9YzkK15vlO4AAEAAElEQVSc5Pj5Z7x4+ZKL7YanN9dc31yrQ15S11kNUNJcOwqzc1/KCFT+qI0Rc9TgVgYRzxKLWt+fDTOVGgyam/scjVN5G3xA0BKUpmnwPqgc9trz4AVcyqy3GwTh6VNYdSue3jxhs96ozeMdq9WGH/7oRzx/+YKm7bg/HvnRj37I5cUFT5/e0LYNikpa7AuFuVJZWGL7S+ErNaUQQqjrUQKASlJ/3zStZR60P+F4PNL3a73EFEmSCZUhzS4zm8ku8ka+LZ91OHqaR3nqUQPVi1MInlL8K+YR2CJ4Cyk779XzFrFmE1MbCWLMjJMWFk9jYhwP7PZ7bl++5OXLlzy5fsLFxQWXN09YbTfI8+e0bc80qdGQjUHLw9dFt/XJefZiY0pMw5H7u1v6vqVfN9U7KItWCvCLfa0MWNJNusGN4VmWTuqLiy1912mKJp42NzVNQ79eqXFtvy8GpMleJIHEYkzmEpTVGpK+o+lbgjjarmG97mnbAoRrysCw2CKeJIEkQGipEQ4RkoCzRIL3nhwypfmhCsOT7vDCXEUKPOYLnZJbMFpafKiTH/Ob8r8C/pNveaVfHM2ZMwHDXJQKg6IPG4Kl0q20w1k5R5r0MGohf2JK1qRjjs4+jvzwR5/xxRfPWK17Lq+ueP/99/HBE5pAaBqGWDrZ06miNylXHDlE00OhaRnHI4dhYkyZ0BRxk01w1oZM6zq156xM5jRz4HzNSngfaHwwyCZfIwOl+3i93vDe0/cgCl3bcnlxyXq9oe9WxKjYqS9uX7Lb7TTSkBMvX76kaRq22y1X15fEnPAOgkWiCtzRMoKhCkexDB1oc4AZNxXBw6jUo4YQLNWqwhKZ99Q7r2geU6Rpm9fCnbxCxu4P31q+epRLnuW//RYX+sWT4A3ZQBVhnOYFapuWi4srM+yLQ5qRoEMkhmlgmEaNnjLXT0bLHKQMcXfkuP+cr758xmbd8+HHH9P3a5VJzlnEy1UooHKNkjWbHV3w0uBDQ5xGbu/3XF9fWLnRzK/1Hk8UvBkAqMEZRJ2S4INiNIaGpmlougbfBHwTtE/BaXR/e3VJ13X86q/+Gpt+w5ObGzbrDW3bghO6dsV3//iPePb8OX2/4u544Hvf+x6Xlxc8ffqEplUsxzk7YWdVTAvkUjOOpngtHZuzBVBqlG3BUVkjxmrodricK35nTokcFK1jvzsQU6Z92tnKvpEh/lTwrtZFBkMGUd6MMTGOI+tVx9XVDV998bnpxxLF05IezUYaYo+o8ac6b46+xQRxd2C/P/DVV8+4vr7myZMnmgrHmjYdihihF1L9jqGdiKuDelwT6FgRp4EpRZO5wUoAZ/0tEheBAA0ReX1BedFS7W2r0GJxiiq7g6vZtKJzmwB+67V0pek06NX19F1P368ML9jhm4bQtmwvL4l3dzjviZZlbVG+LdnaBYjLK1FKR6IMUSqZg1zuu2Q/SoTZ6To1zczbcYocdnuurhMimWE8EjN0m9Vb2wrw9fy948g/5fuPfvZRAzVIR84eZ23oEpRxLKhDjhq+75rA6IRJg3IECUgKEIU0ZcYhMpmHVOAljgwcDkeeffWcVd9zeXnJhx9+yGazxYeWYRhp25bjYaKkd04et1jqokLOh0aVuU80Xc9xmtRGF2/GaCZag1eptXNObBML61lUy6JQ3mlUabta04VGDVfEYCX0VrpVx9X1FZfXL9isNmxWa/q+p206huPAdrtV7284ajROhOPxqHV2XcfN0xs1/r3QNoGubSw9ND/zHNzNBm+UkBRJol7IafQX8xI9MyCwNa6V0UbOuoBLuc6DpT0Je8nr2Wvu1Zvfs+WOv8K//xhLfWMUkkOieYoOsEETKWozVEpC13Xs7+9rSsj7hlLjnGIijvpeneihdc2gEVhPZj8cOY5Hbu/uePbVC66f3KD7tlgzp8qOupcmHEotnwjZeULTWQRMmwjX3YV67bZBzqni1FTTrFidFb0LohN4mlZTjD7QNE1N/xSYnPlHhzS0fcv7H3zA1fZSy29WazabDQkIvuF7P/gBz1++oO06bu/vud3d02/WXN5c03UtKU8WITP2EcjOumeTRSyKPaMhNKv58uZ4z0DuYh5n+V0xBHJOxKxFMj5nUowKel2yFTVlyOO8WxV9fvBLuObAf5p3A4Gi80ExB50HL8TxSE7gm1adAO/p+55pOtgAlEQIloEqGKGLQx2lRAFt8p/JljSOTLeR3fGPubi4RJyvk+4yzI5rlSu63iIFYUUV9NpvyHECEsE3Jl9T5d0yZaluF3YfluZG9DreC13f0ATDEfXMETJRw3CaJsXV9gFWG9q2o+97+rbDNxqxkuBJkslODZF2syZYE6POPShCz/Ava4hD1+xVhFZO5aQvSAGWNl2YBuIEjycEDRbkbFOBihEVy9CEheJ+G7n7p4B3G3M0CAbrNB4haxBLLH2s6zDzZ+3/KFOQsiKUFCMVihum61dq3KaceHl7rxkn57Vsz2T0nLHKOOfVoHQz/4kI4oVVWONljXeZpgvV8deghUVSjW9LyY33YmhB9oMOGWg7jTwelljZeS6RUez2htzoDgYXFMUlRp2SdQTfdiBegz7O45umZsNcwYavtFDa9XlfQwYlmB+wTckSqJHrKqZ7ilO9dowT+8Oh2l8pThV3tjxXvewyiPgaOoVR0/e8z5H/avoTGKi17sZqvcSUTI5az5liZhozsuoJ3jM5KVnmeRPNe5zGyBQNe9FSHylFjbCOieNx4ngc2VxcsN5sALHCfV9rJUHTehh8VR1bathf4sDnRguNp4Im4GZFn7GufrGaJ6mLrdGseVxZSZU2QZV88OGE2QIesmi5wvUV7tu/zuXFFRebrdaV9CtiSvTdik8/+4yXt7eEpuF+OPLZp5+x2Wy4vr5ite5JOeKdFmEHmWu7Hm7xyd+lNBgU47SECO0dJigF7bKuJQWIrinLr3hoob6OGR7jFKV7NvzD/M+/+Y3fAOmhSgge7x1T0kJzSWI1egnXaudymd5Rzv+yUS/mTEwqpArUV/2OrFikMUUye3juaJoWxA40s4Aq111CUUHpABV825C9I+emRj+9A1FYAYNpmQVsSTuVKJXiDTqch9A441+xscAlYluiFspfnRXzex9Y9WuFdmqC2s5OO/izpeGarsOP4xw8c0A1lKnC+iELlV9nKWqpWjv2DtP8NR3FgtfMk0+JmLPWviOLaSze5PMb/Pm34N07Iv8vuX3zG78BKka5TiYLihSRC9JEMvQFXagiowtfLfGVZ2hAGxwhIIaIUBCgc04wJfaHI85knFW6zPyaa8DIti6b86/RTx8ceG8GpzUg6k5BxfU1ZYj1fLmScqVGdFxwGsVyOtGmOItlTUCjQOIAr5BNTWgUFsfJXDGCGoWKGe9sTLE74dEl5NHMk6f7cDIIIGlwxZVpXmXtOOXF5Wfnz6VqoMYYrUHn1e97Lf0p4l19ZoVZaprAYbcHSiRey5h8UKSZDEWYPeDbsigFiBEW1iBzaERB+scoilZjUW6klBCVUkSoJlG2a9nUM4Xwm8tRtGEr6WlZyLZiI5Tov9oaDmf10c77CikmMpc/lq1bjvktb/LimYaJLKonYinRE+pEtjIUqNT/17mvOdaIwMI1YuZn/U3KNqI6zlM9s2TFPc7avOqqg5W1YXYcWS0wRfV4CqQ0N8HVdSxH6jVM+lb2wpp/IP/co+95KwO1CgmL5EQrJstkFO3DNsk5JoNSqPBOJuBKd14BoC6TR3RfIuO053gcOAwjx+OomH8VWL+Itkxp4ZUq4AzVsQi5BiR3kJNFlwxEmqh9lyKnNVG13k+vqcDhZqSGoN2eZqwWT1vEK+Yfjtx1OOe0eHt7wcV6y6pf0XU94h3Bt9wfD0xkVus13N3B55/TdC3r7Yag7l1NRZTHnadYPKTCGCqN50LkU1aVhcDN5gyoIeHmGhI7gOVbZjN1KWlPXyvXXx6ImT9aAh8/xlLfHEnpIEfTkpMZSFkPYooJ7ztbAEsJ2GOXiA0U4VCeVEzZ69/nBj7FlDwcB6Zk6WuBJNnwfHVvqkIG5gYS89CLY5I9TjRy75wKkiIlnbzOSDUjwol592qo+lB4ffGdPBDe3kOjkVIXtJg/kRjjBNmRs3bnZ1EMPeetjKdeL9Vnm9f91a3I5hzWCVxOqiFRQ3RF+CLVGCsp5qLkCwKAQt4ZOkBhQSlf/1PybokWcOSOH3wNM33DZAaqpkyt3AeNwk0WPQ5Nw3GQ2nRZ0onLARRFw5QKSfsNhaU0AwMgllWIqkO9hpIKFM0ceaqcX3lIZbg2PakxYFF9mKcE2uercSqz0nZOm0d8/VE9kuK0cO5mI1XlsMpebQjVs1YcoJSTdSnbTHIrZxFnhk0xsC3KXHm5Gq3z91UzNmvpD4YZXI3TIgDKZ4ytqkFaZIcZCcq72Yyo2br4meXuO8a7Ba6vaQOdb7hdGD6lk7xpO4bDeCJTSxRaWdaM/+qblNdUji05UJ0up6N8MSzaEpCSoqvNaLMJS5ANZzwTsWCV9We4Ygss+LbU7lvypxqodYpY0B8XDKTfS428FtL3W1OgoLJanJbuGO8mtGFH1ZHBS4mAV8jMh1H/15c1nf6yys4cqbA7Oamxm2fZXURxzlkhv6RoOmZUhpRrmUS9fv3Wn5VvhVtpX/cgld5ooKY0Jz7Ic22GCgPItqg+BCQE0uGozGKQTMFC05OlShVqRsB5yvSdjDJFmibGr55zvztUOKoSiZonbjhlAg8l/F4YwHuHw9OFACTattMJPSi8VE5p0Ti8rIly1eD1XgjB0TSBptHZwN4rqK+3dJP3BdQEOtG54QpWrd58JjNOA0JDlqii0jl82+KbxpqijHGWno8Znl9XU1dM0dkuzPX3dYIWpglyCe3rGscpIS7hDU7l5KpfE5Z/5cuL0lt4UEt6P0/8y4+A7n6zlE1nqDAQD0yGRxcjcZrw1hCUZLSPWKzJlYi6q4bUfOBchYoqWLXGYWSRWugvDgh2NMVqocyb1w/r+s2OgwlCW1TvtTQlx1iNgSooxaBuinHrVFgWVA0VmmpAl7qj8gQFR7UAsougKBpZsxMFxkfszzIfzjcahaqCUmaEiFxHni3Xv3Jr/VdR1Frbl6rBUNAUsnn0KSdinBSPuMyRT9EaAbIl+ywaW3Olj/BwtXMW1uyDt1/ne/5u+gdff41vkIpsLQ03CuepDv44atNav1pxv3upMUoNoauBunDCSjmWrvPSOVLDtrhOMYum93MiR1Vi1eCsQAGz0VsweksGrPBtE8zcFbEJdszNfCx41xfeLZBvGgzwIeBL7bVo9CuXs1GM2UXUTQ3UgjqgRkrKAlbaU6JGLmiPRJkupXejUbKi8oVc32+bUHkkJePDXBoEUf637xc7N048OUdinJhGHUYjzIaCB+vAduACDxtUX0t/ing35lTxa5u2A68lDWTr0k+ZfrVmOO7JxoNlXDOgjmnh15wpzHcSppHZTCvGbc7a65JyxElWyCdz3M0rAFTnZkvxJrTswItoM/jCjBJR+KilTpUa2CrZ2rnsJIRQp2WV4ITyr1s4YjYZ05xzL5rdUntEz5ziHGtQZEqRYRxw3s4l1LGslD+rUl4af4UKr2tEuAT4dIqndbAzj+jOUIMCUqPOmeAcpTO1TE17+E2vpbewFzb5lr+c/t1HL/MGA9W6zmW2kfu+Y5/32tWb0Kxy1po274OlpxO1+61CxpRHhtruII5YSwi0/iOJMKUMY2SMB1ywNGMNk+cHXv3MVPPiKD6dwqdoBx0563WsCLp48tVLsGt575DgCI2nbbWrM4RQmxBKWQHoe32jKSfnPClq1Cw5g+OxiRo1Pem9NRlgAm72KMpRyCczqvUQFizJOA3EOFWc2Rr2rz9UJihDBJqmgZRIccLlgFu+yb77jULy5L2vJwGOPOW7/Itvea1fMIkZTiYoQtOT4oFkZSYxZdpeU9pp9GY8RoiR7CdKval8zTMXJAD1NYtiVogczTAAGbxXaJoqLMEkbInCSJ2oovBCQhPEANrniBOVz0v99CJSYEreeU/TtYRWsSNznOuxiiFQMgUl5VmM3BQLD5njFDVTEeM0l0cEbzKheN9J16z628tHTDbxR38TY9QolJjQEJUvLIzvkwhWjTplc2QzZW5QEEHaluyXNVlvoKrgX8MqgOM3aPkfv/31fsGUstbPNU2LDy1p0kEmMWammHnvgw/48tkXChYvzBN0XnOWl7qi/gIqh3sgeM9xMDQU74go1qHDn8hWTailii2ZiZZ8ELAxpFp+Zc0p5StlwbvFuPSeZSQ1VGgeIbSNydqZdxXq0JuTpYEO74UpR1P25UnVtdIRkyOHo3bvp5zIkjAMtXpf+lymqM2ALcGC+tDG6zllDcqkjMvLOGBxPAu/Gm6mav7qzHkEmgZ8eHvR+6eId4/jyBah63tC0zGmsRqo0zRxfXPD3a0GMUwMGh+9+nga9Z5fWCJpZWMsrUvW/hayOfQScI3oeKTFtqRcyjHUmM5RiCIQYpWLReZLdXqLcVpsBBvD/qDptAQZXFN4kxOnqtoohZ+d1lz74BaNh+qkH8cju9093aoHp6NSEcXYPeWXUwZSh2jWM854Lye1x8bxqPbAMqiwsDHKkI/ZqbUAh2W9fHDg9N9S7JhH6XFT9vu0/I/kY/4Hj7znDd+innhMUWskhAoEW8PyVlXftA1d39E2DWVGbja15QzcvhgNySIErwau3fyTxepTI7FgrIJFiKSG3muN6zQxDAOHYWB/HNgfDmbIzdEF5xR6yMv8+SIknff4hTfkG49rvAEvh+qxsxCu2m1qXadNY0X9tnKWFko5WndixgVPFoh5qgdFBVckSxGqScP91QA6vV5R8qVOrRjWLISlppgmYpl+wGL9nEYTbHtfIeGBsSss0qcP5WmxnPRPx3dp+O8/zlLfEKnssPQSmdVqpVF7EUtlJFJ2BqtkBmbOeF/SpEWYmReakiklFAcUMM/EQMBrTM+uHzXaNRrwdC5KXPWXzodWB2aKI9M0MsWJlCdTxLbWJXpUPHJD0hDm6FOBKlt67DU97FToFceqAOGr0axNhFrrhEa2vMN5Aa9J0uM0sD/suN/dAybYzYvXRTsRkYuf5a+KgtU0VooTKY7W5WzdluQq9AsucErK5ynpOMllo2RJsdX95nHefQ2HnPxM/JBn8j/9KbnsF0OCNoKNNnt8vV4rlJN11o/jSNf3ul5vdb2q/kri+wT3VoW0nuOUM8M0MQyRadRSGBUtMtteGZVXWZs8osmblKJGrwpUjyl0Ve4eRAVkRiOI4gPiQpXPc32f1qOC3lcpbwBq7TN69Ga57LF5jTPvDuPA/rDncDjiva+NIHpdqDBui9r9V6jIYSt1E+eYptHSsArfX6J9hXfLGE8RhU+KKc4hB9GMjl8Efcqe/+nnXY2gjuNInCKr1bq+Mo4j93c7rrYX6sBkNaAEcMlZI6m+tzzZcsxuQUMoJVcOlVXibM0tw5BiZppGxnFiHDWIViK1Re5Ok/bExClqfWZKVV/MPp5m0Zx4hbx0NsfXpohpDeoCr91kr90sweClCjlfsrTz70uzlmuU38UXyMnMOI3c3t1VJBlSXvCI4bnLzJtS7YU886pYKQ6J4OYJZlTkooUTZvejte9zg7YPJYbp5ubyYnDnn9FesDe9T+K/IrtHOeoNEdT5mzKlWUTwPpAC2kGaYBwjoVcjbQZvTvUQ59cprhr6pbqxhl88vytnpphwMgHeoqgKBH2yF2kB/WRMnUq91FIOS4maWjp1EQ0tZQLFk/fe1dfFLzvql+mpuWDae0dKUr3+slExJ6Y4MUxqhIgxSvFQINfRYiw2tqzPMvBWQvP6LMpsUp5ZTmsNc8q1mSLGXI2EZdNO/Y58ujNfr/UeV4c91/wm/5lH3/ONkSlVxTTNrHyDd9bda1PRSNg851k4eq+je+cGiLI5blZULOC1SgSgusgqYKaodT/jFDVqb8gMtc7drpOtyULLrbMiBkjZzyKxZz4tHolU2BSrsz4xTvUar/gfi0sUJn1wWWpzgJ2aZHVJh+OBpu2UBes9zs/u6he83mteKnlnadlceNm+rTSl5Dwb706c1VGVgn7jYZmjsyXKIotnfPX7H+fdQOIJx0ff802RilDFFZ2mSNv27PfHuibDcaBrW4L3jCLU/7JUeJ2HqeDlzsyiRqvylsq1TgmLmWmcFJ4u+1rWVKMrxVhIYFEKywjMhp/uRzHeXI2cql/nrAlsiSxhfQTOqfyet/hE7hZZV/mh9jvM78+o7B2Ggdv7O9brjTbGlPWtLTi6GvV7ThdI368PBznhWJROlc8u9m7Ju+pcqZFP5V1KEe5Czy026TX0p4V3Hap3xmFiGEb6bsWdvyfHRLQAUt89oQstOU4V2HHubpMSvzzRU6+TKiVCWeRPKroMGMdJA2TJkXMopZ/KN2UqXoaKbkMwfqqFA8rHC75d8mYJCpQglTNboZaUlOjCCU8ulLnpm1JvXSOxYlX9OTGMI2l3D6IZttqwlyNLhtGmJ1mcNfsuBEqgK2W19Ipey7aqik1ZS1f0FpUvS/1/EwJzFVX1CqvN8fCsnNLjfDvS8SW/9uh7HjdQyxfYc5dDF0JDMlzTTGIcJ9a9gpSLLTBmoKas3Y9VIOTFOj74LhVlsyGrae1MIoKAC68aVznPxmPO1iGZ1MNfFtlXRinWP4v6Vedqo0mNQjk3G5uoIQG5emzFECjp0mqwWqpJD4568mOMjONQ4aXSiYGKHYb5seyI6qGx71L4ztnQrDWAVcnbr4vSNqZzTmcdv6Kcll+4ZPiquh5ywam2O9nCGpS4ouPvvLq5vwSqTU4x2wx7nRIzTfOwBHLWCKpI3d9y+E4dK+ZFq7wGylfGf2XPUQU+JW3K06JzbewIwcr0bf/VKEsV2aJ0Vs7GYjEGZ+VW5ilTyl6cevgl+rgUjuVxHnq4ld+kPNKCn+39xfcmwzRNCnJutaqnxsd8raJIlkr+xGkqaU6DNUnlWos3Fb6tEGlmNOVqoJrycgZHA69j6nK1N/NupRaRj177yjdN1sbGNKls3fZbnASyjDWC2vqGNgQGw/h1GVW+aansjarxJQ/+NDlYDFSUd4trM03TouPXGT/OZyJFe2/SvFfOBehcKg8U166ME1Ylz4lhWmD9nF/Wmc76fO6eLs8zG6uFL4qTI1gTow3JGKeJvLsHDO6ovnMZNZ0zHNrnlc0CWmhf02nqPGRKKFlVitg1Tn/0Y/p370udo0ag8jKL9WeEd11WFJ9pjAzDxGZ7iffPmabBYPtG2qalazpGC21KMU4XPJsXjTiFThrmil20FJSY44QQY0RyhGT19uIUHUcvZLwzV7Nr894yK1uu7yj9KdVOMMfKW+f+HMxyVY5qRitrmUs1jnO912KjFrvDlXsXqecwxkg8HlC+tVKo8vyVlpGlhW6ywS6ZXGunl/yJnUd9cz5ZP81+U7PPTbPoWTHdM5+K11mnb8m3ApN0PHuDgfpoij9bkb2GjxOly6uktKshViEIFF6kGmCoAp6mEUQWXie1bLKsceFRla/FK0LxUy2SME2TKXMhW5dxTpCIJKY6UCAzUWo8pUZ6MOYwJnGzMKwG6YIJy4FIooZKtrSSPNwP4CTS5dBU0wIGIib1iA6HAyWMXgW9m++vFDmUzdda29n8LOtXSgyqcZQLbIwJcjvoKelwhTqLWMdZILVwehHbXsqJB0J2yVQPf5Z1Zl/wKf8H/s3HWOobo7bpdU1SIhs2Xdu2um4Alorru5XBmZWGESrv8vD5KYqyKFBZ8E/pXj41tnTcov6M41gbj+xqpIilnjQVmFIpi2EZJETVZ8BJoMAPzQreVWHp/GJCSDE2rUHLOW1QKRJSLJJT+cm7On6rCNCUE8dh4Pbujru7u4WSB0uemXFvZzvP9vAJ5Qg5IlkbFkmaIlY+lwfrdjrcoBgPIZSpI3P0uD6n/fnQQJg37vU/JQv3ghX/N/78K/v9yyDBm2MwcjwOdTLNkp8F2PRrGhdwVoquE3SkOu5JPEk8dXrOQgkXeVHgpCjpxYVMKHWD4zgyDANTTlbXPdfP65mJ2j2PyoIgOqee8huZ90ubTAMi/sQ4bRaYjydnzM6Bq2fBmjgWRqy3spSaERPwoQQHNHL38uVLomE8ylLGsYge5aKM5uyJ8mK0OlI1WsrceEoggTkD8JD31IDWRlolpwZYNa7qpv8Z4F2Hy440aar/5uYp3gVUzqn+Dj7Uee8xlu5yVTx5Fov1+R46M6W8qRibyjNzbWbJ4MYUGaeJMWojX0xWOidW9uc9wiyvfUEFqv/5ehMl1b9seCp8G4LK41IaWDOy9Yay8jBqsMrC8JGloK5RVHdigwzDQcsFROoo+IzySkpzyUNiUQKx/Cmnuag0ci2PKg5+tXVSwpdyNyl1sv6BQ+CqbZbt1n9avrXtZgv8R15jTy3p0QiqnrpyUf3HMAy03UbnwIaRIR4ZxxEQhavxjjwVfomkPBGXEdQHVCIgZa+q0AqeaHVoGgVUI6PxLX6+HbtNpx2/YBHUhHOhPsM8MhLqyEjrpiv1Jc6r0i8GB1AXPLuMJKs7bRbvccKyts87p4xum5bQms+YIne7Hcdx5Orqmhj1ATQiVCJ3erOvRJc1l6GCn6yeYS6QVMmUfp6xyeofpwzjRBSb8CQgaFGyNzDJ25Ln26z4N34+F/uTkhOFQjNDdL/fs9lccDwOTAzknDkcDrz/9JrhcM9wyGbwJJyldrJbRKEeUDXRzNFoXINvG2RK+IJmjP4xDgPjMdG2LUl6RITgBC+lo9RM4pJeJRMM/zcuDuFSSHtfym0aE5Szsbp0sApYuQtWu+0UAL3sv1iYtta52ndlMr4Rm6CjRu/Lly+rN/+QSvTCWI8lbBeYI1Wbx3QkcWgKJJ17cK3i2JfsyNftArPw/Pp3vBVtuOR3+E/8Ca/y8yERQdISG9LR9z27cbTaXF2P95485bi7V15CzHE3I/Vtyfa+bRrrFZgRH0BH/uYUSQKNqJPjTZZQ91zrTrMrOKVikYZiTCyyUgusSm2s9fjgCM1srII1nljjn3ixaNRi6EOpc13oAKpRbPJ3ijptrGmIcaQNmi3RTnN7QrNXyqCIoohLzX8xSMtelPr+bB98yLvlbmbeLfcrdW/r6i7F9Z+A3hXeXZZgJJO7YiM8FUpyxAHbzZp43NNYDfVsSL1yxa/9nkJdu6Lvo2Ypp9EigLlGrmPB06V07JvTgCKvkDUr2gSPZEMYEQ3MeYBiMNrZqJFP52oUUiEBfd3vmBONRfZL0MIh+FxKF2Rh2JVQkT7TMBy5vbvl/u6O9cVWHzLPa2v9SjPvFCMTO40mPLNLTDkz5cSYIhInxmmkTQqtqI1Z8/3GpJk8he4qxjTg4Hg80Lb6fEVv/Dxshg9Y8S/zW4++5w0Gaklbzg07c+rYKxbfYWAcJmJM9G3DZr1hdzeZmrVoXooPL8zigvMfdpAVJidU0P9sDAeZu7t7Vl3QiSrF286oZZ+KN6wr64xxhFKkniid/SXVVKdGLUL2J964fdJ5g7dy6p3jck3pKwyMMRHFnlfG8cFqWe05bm9vyTlREmrl+ZOldxOiaX3Eflc6QB1xso684iWW2i8MaH7hQcHiIDvFeqth/bLgZheXta9c/nCvePB7OQ0uFn51/AGr/N8D/u8PL/KNU0m5FItJG0s6HUN61Fnzw3ECnEKiJJs85hrrOC97s3xQqielWUDjcAtlOKcj7lKTcENJxWuTSc4QbZ8kZ6bCphSFZYJRMiI6iF2ywyUzGZ02mZTSExZ4f8Wpa5pQ66OK5VZS/2JwAOJL6GU+g1XWlFC6GX3DMHI8HBgOR/r1Ckg0NoJT62Z1fZN9VrGG5wj+nF6q0tQcOr+INiiOcd2rxboXoa/ZDTWAlsZoFZgnD7Gkt+fdI/f8Ef/gEY765qjwbjnXMUZWmzWH3T1pXET9HjQXvZFe+57Cu4FVvyKjmL4ajYnkNKr8tqzWFKP2s9e0YGkw1KiT98HSm97gxOYSglJz54TqSHnDnK6ZCJO5TgzKT6QatpXvRWY+s3B9iRTV9GbKDMcjh8OhQuuFRtEtNHti7y8lCWZYlehUleHVyJxTw/rc1MhazllRWqrsXUTH1KLRkpQqT0oJS5kM8trNon7R4lfvMu+WKKJrdD/v7u64uNiSp5HxeFQdGTztIlquNOvZhXdqr8iDJRCTNQ6Syrf1eoNvG0UWipFpHKysYNIJa00gThMxGYqC5d2zfU/hW1WrSctapMjYuQRQDdWi52c0irlESuojyIJfagkhs5NS/qwwamiwqGtbUtLgiTMc9iLXyZkcM7Gg05iHlt0pX5SbWNaWxqxytwS8ag30Qn4UfhJzRPWjigbUdsXxm2uvH5Mnb8O3X0rP/1G+zV9/jKceee3EO0xop1tKiThFXBto256d2xuAtBYcd/2K/e62RkZJr1m85b3LA5uobqqnCfOmC6X7emQ0/avYYhh2WNGvxTMw7DHnKVA1pei5bogpSzHvfk7VLpir1E55e78p+SVo7yt7JeXhqV53Mhy8aRorrBUpmYDUt5szv6h1zpXRoMBkUO3agqhAPRj6ohqpi30UIZWocS7GlX7i9bJRXv/7N9IR4Xs/0yd/3rRU8uUwe+dp25ahGRiPR4vQZ1WqTWvKz6nhvzTeoRptYgz7Ct+iyrikY6O9KZOYxoEUx9oRWVM1JphmAw/1bg1tgKKcbSLazKcmIBddofPfZ0ekpMYLcoPUmgHj2SIWl5AjlQH11WmcGI5HxUEtzqOUOiWD5lmUuBQb11TJnIUoNaXFIBK/WNuihGzNZI5knRpgQpwmpA2V1x/SWxlqr6GBHZ/xnZ/psz9vqnI3Fwc/sbm44GV4DhyAXPEKZydaf06ffrGvr6NcjDA1tvrVShW9NWWMcWQcDsSog1OcE0ZLbycwnkpVQWcR68qP5li76ri7ZbOJFCWvdzbL2xKRtGcxGVxrDcvvWAYPZt6bBbG+Pk3Ku03TEJq58ZXMK/xT2CZbWCVXBfZwyQSRwKyn57pzTX/mE4Ol1uOikVsX5m9+uCt/2nnXOadoNo1GK/e7HRfbC467HdGm0E3ThCvp8ArVJMVuN9VZDKDXf8/Jzgs0XYvvGmvaSxyPR46HHeM40PctCMRpqsEbkSqd5h0uZSjMsk9eka8ly4TJzdnQLA7NUlZV3j05nwtj/OTfs5GYYmQcRoaDnvVi4M6h9/LxXNctPzjqUnpzzBbIFqzI+TVNaDKvtTx4DXTIUrU786vb8rPy7Zjv+CL//Uff80YDtSjkZaHtOI2EplOBdnvLFCPTFEkJ2q5TxlN8GzOo3IksgYWyZ/HAhVdFcN4TfKNA1QCizVJp1MhhCdWX7l41RkpNmgoqV3D2cEiei6Sp3pGrirt6OgtFP4foXYWVkBpJLbV6JoAWufmlWEs5MY0jcRxp2oacE42lmtIiklocR4qgMy9bUmGYIhHnGpQadVqcWPUJTlMm4hbPztwGUf29WjD9CDM84MElT5aPJVbc8x9+5CLfHBXeTSSyU+9egK7rGQY1UFNOTDHqqMTcVl7IJ4tqVBbM9qhAbOg/pa691rkGxVdF9/942DEcD7XgfIxTjdI4EXWqsjWaUOp+Ci+7RZPIAgNVlth85s1XZB5L9ZrLU+CkytQ1NWDtszUdXKIWc0S3CYGUIofjERc8bdfVyJcaqCDOJGTxZYtx+WA/UpkRX7AyxVufyRyB1sddRDegOpLlouM04tqOsuBvFzl88M/X8O5E5Fl+8eZrfQNU8UFz1EhHVpi0tmk4OAWgH8eRGl08KVaW6mNIbTSbMRaWVN6XTdN3fUfnxOor4XA8sN8J4+joV73B+Y0KOWj8r7Z0noEDvDZKzVHw2akq/DrXSc97XAzTZeRUoW2UZ+fzuFT6xj8Zaq3rQtnHGBmOR9UhuTPwdWcKW6B0bZvBUjulOeWRZNAVOQs5gfeNwhc9ZHRj01R41wIeYnGEaZrwra3NY1Gbh5u0/Oc7zLvLmmIQhuORDz78kNuuZzwecYJGBl0ZE+rB+lxgabapFisR5tfxrUJWqnMcQlBAebF7CIEy6Wu12TCNI8fDkYrrnmac8oKuXAp6cy4NUxbhXwauvDlXqJFbM7jVkZrlbZW15fnqGXWULFWRw7UOFxtoMOmgh2F49fmLI6/8aq+kfCIH1T4oZSkzn3g/Nzw9FJvZ7KlS311sKxEqxFsNIrxOwD+kt+Dbhuc8Tf/XRy/zqIEqopMSXHbkeGrWeO9ZrVY0XacRImtQCs7TND1tv0K8r/ip1QJbWOsIOBaRrgximGjeN2w2a2wOEzFFpmnguN8TWq1zKiMrwdJItevKLH5n9UvZqaHHwyJkFdzOeR1b5p1NjvKV6agCa/bwXZkktSjYLptXBqphQi+EhmmK7A97fBPU8G68AakbHFYR1mZs5NdmfhbgwbbDWht16pHBbLyW9EPF+ZTiVSWy5Utf5bNXoy5viMNUeskT/p/yX3rDu74ZKrxbmtuC96Q40a96pjix3+2sHDLT92toGtJ4nFN6r7tmns03PcxzxEqb6cAFT9d3NCttBMjA7Uvl8bZvEbTRMI6T8o0Abm4ezBQl7zRluPDOfemAFi0zKYapPxGWBYqtdGIC1Zs/VeDl78VAmX9UwaSUagRVRMjJgKDL81OOtNQmyddTrvO49VSUphlfu0JPnLqkTQ5dY2dNpCr1cRppZ1eUcufle978m9dT5COeu//2G971zVBtfiNoWn0cIWfW6zXTNDIc9zx79oz1qic0DSE0OB8oVmKBnTldhYcayf60erPskjr+aFqxyIrheGCaJjabC+J4ZNgfiFlxnXPSyU1a5WTumn1xiUO5ZZrUlXG8Jp5d6dA3+bqoIS33KEtlL0tDtbjXmZTAlxpUe9SCxzkcB7wPjOPIuu/qMIzlmhQkmFednZnXa4YuYwa38a7MKeiyZjFGRbQp0TSLqk7TQMN69uVevyGP/Ob19K7wbuM1CJCmRHKKjZ5SYr1ek2NkPOx58eIFjbNMTBNesZTqv14Xqlu+L4NYg+YwHMlA07Y68VEs0imOVb8mNhP7/cH6WHTgRQkOZaj1nCX7Da9GTkv03UEtAXQiBOcN01YQbFoUc5R/GVEtcjWDDXwoZ1VfT2izbEE4ySkzDaNyawIWvPbK4JdXDEI7Z1YDWyKo1BIxOT1qluktZ7FEo8V5bU5He6x55at+dr694JL/KH/70fc8XoOKGqLBBXx27A73NE2gDUHn0zvHe0+e8KN7BfF23rPqe25D0I0qVjklwvlmyqjwEyd0Xcf1zU2NIgzDkS+//JzVWpX/cDwyTQfImsZPVmtaAi5q9poBKVrYXzHMjKm8t6iUL4XDZXNLxKlErDxOAmSnI5lLpOeBierwNkFHAaljjIzHgePugBNtdiheGZgnbw1kJTr2OGmKKfiuCtacDdJM5miyONFaWai1NuXvavCAyNvsyNuTo2XFLx/uBFQJNT4oiL5kg+eZ2PYrZLNlOByYDgckQdd3uNAwvCGqkdE60ppuSZkCL6VKzzBvbcxh2/fUhmMR+ranbVvGIZLT3potMjnODYTZOXB+jkhldeK0fg9txAsaRQpOFLtPtB5aLzCLhSUvLZ0WpQJyv3jm7CC7eokyEjZOE3Ec2cVI1zZIFuvSnpuc1IacI2KvrJ3BaZHtDHptgiloF8VJq2mplGtAzMxo5lr05Y78fGik5Us++bld709CXhxNaBRD2Yz7cRjYbDbknHgRFRHk+vKCJjS1tvNnoYpAlhLRoPBSzlxeXNB4T3Ce6Dx92xF94C7sYJrmvoKsYD0FDs97TybWgIA6+5jMm89C44uz7074ZXaqyuUfdgdrc4uYFaw5B1cEPsU6niY16sWcGwGOh0GnvHlPTjZR0JWSL/vsaygZugZZaEKjuq1a169+LOeMC3Jie5WIlP3rjcr7p6F3hXeD03KNKUbilAlNyzQMrFcrSJGX06D11G2nxmQIi/NsC/kGnVQRQpzQ+AZBYZiGYeTu9pari0sts7LRoo1XE0enXDqdTieenKY6gS0LEBpK3UbhW0URUFvBiyaJap9KwfAVMahCm75mpQIPjb+H/FXsilwzdkpl8EVOqY7YpRqP5dolVFgctvjgu2a7oGDEt01TDeWMnAyBUOM0GjyXrm20Mca+0dGmb5Oo+mnpD/gN/pv8T/jhI+95VKrpDHtdyMa3rFYbmqbTNInBnfR9z3qzqd5Q23Ss+7V5El9DJkyW/jDMUcp5TJ0q8OBcLcAmZ1arDX3fK9RV8XJjSSGWBLc1m4irU1Pq1ChLG/qKu2ce/SIKVbyg5WrMqajF714rasy6yBCte24YR8ZhZL/fk2M2Jb9g2OppPU6lDEAFryPFZHO354Us88v1nSV6tUz8vypV34r/SoD6QYaqXO0jPue/Jf/bt7nSL5xStskzot6jdt+qdxpCYLvZandvmg23Mk5R5DUHssjPksIuvALWxGavpcR4HNjvduzu7ojjpCmYrFFc732FuwJYum1Z0K57b5EZ+ylGcK0/FU7qTjWSw0LZLuugHnrypw+VcTa4dFk/amu48ORTUkN6HEZiShrlXUJaVS54EAUr5qXxbfGOalF+iQqYAFdFPvP0QwiTbAyoNbyLr3kYhn1Ib+Ddb/Ml/wb/+0cu8M1RmjQdqQJkns4jojXObdvVrFLTNrRdtxi9S80YlmdbBlqWy1R0ZoWcSZk4anbh5fPnDMejRlGAMoPch5KaRRV91tG+kUzS8BIZ499a0+8UKsoi/sFrZLV0P2vavoD2+5rZWtb4vZbsAQrIWS2CkjkiVDrwx2GsMIU1M+aKolZZOq9ScbZyVfQsznjpUzi5D7tHhf5JNSCT8iJ7kE/3otKfEd4d45FhGhjjyJRGm+ik2VXfBLq+YxhHppjwztOEAGLSx0RHNgckldQ7p3xb4RAxpOqcrJFQB1i8fPmS3W7HNOoUxeKgeOsvgPknZRuMYpHFXKadmc1QUvsFqWe2F06hoOZ+ljmrNdefPiCZbYblXmZx2nyYZgSCwsPTpE3op+83HrUsw+s0uOp8qp5yCx2gEVkzpFOuiDdlgtvyuwpO96tfwJ+Ib9fs+efknzxygTdEUKfpSOMbgrQ4H2iDVCOnHP6261iteryFisQ52qb9qYyt5U3XeGRW7NNx+v9z96extm1Znh/0m3Oubu/T3HPfva+LiMyozMquylWuArv8pbAQtku2kG1RgEBC/mIhgfkAksHwyVhCSAgkZCQaS/UBZBobAYIqY0wZFa7OVNoqZ1WZzIhsIqN9Ea+73Wn33mut2fFhjDnX2uc270VmxItXzBcnzj3n7GbtucYczX+M8R+imAvNAxm6tpO/N14iFy0GKq+XyNWwFyTT5FKvpcGvZSVUS2RfDTuvV45HsH1B04DFAVxWmSSStcPQk2v9LPeciM9yE0sdH5hqJMruVcHLSyd/SR0UQeYlFLt4tLn++LLD/Qri3VesDFgSA4c3Pu4LW3mFxOSsE6VktJ11jq5rGRtHSDJrvvLp8dnO+ktGvv5SlEtEi9xnL1RRQZxlp00BTulzRHnY6pRRIluFmnJeFJ0ER2oczfIlXdFLHfW9qzqS3+XfquVNqaJV2VEnlWyqAiyd+Gu5KrJb0vv1Fer0ory6hnzvnC8SuHyuZWRp2cOluWpp+pPPd58RZL3+4LI7EPllbt/4uC9qhTjjUivGOmdIMujD2UECnL4jJY8PQfRyK7XtpqRFBQg/xumqg7++M+W+L3XpKSXC7Nn5ICnGYuhZ0BmjsmmNK9pWgwwrGYCkF6GO20s11MWAr+r/1ynR+4HVetWa/9XK5LUKk327L0MatOeVXlhTn9c9WQEA5TVrZmB1Deg5lrq+lR5dZSoqYKKvk0qdQEFEjj/ZS5/q7zfZTUqOXwKWGAMxBqnx15S/nw/MPiinrDiPRvsEcm1gWz55fo3cFoktDaYZGQ98OBwqImhdccYWbZ2T0d9bClVY0bFZI+W107noWrv4CyUVwOv063HjX/2bWR5XssRZwYF6fSofpjYLCofr0j2/2onV6y3XwNFrmdVrl8fNs+dwGNkMm/q8otcLCLj+TEdn8CX05g8utx3P+DnzF4F//LWPeyOCOo87/DyRgnDElc7bMkYzJKmf7PsBq7OOU0pKhr7coJfq+tQXq0Yw50rcb/JCflwEbrfb4edZD7/UfbRNS9N0GNeochThTiWVUqFwQYnQmc+VkNcUeh5Jk5Z4zawczvKY1zupIkQJbXTRKKiSXRshuy5uYc4SqXjvxalW5GJBlMwrb0mJQErXOdnWTm9beAdXq3SJr/c/aWRWFOjRZ9G9L7ORy2Ned99eklFdV5zw1/KffvkPP4ulyE/5LDHG+pVzUhREmm5CEK7euo+v+IA1glenLWb5SsX51znfxYlLKbHf7djtdszzXGUpJ0EPKnIkUx00iFXHz+gxL52lxlS5XWqfSvF+YaoojVCl7k1N9SsM/CujbRSFykuT1EvoZRYjsKSsqDV4Rbnrlq+eS/3dOhgt17IgZqtGPX2utToqMmnZjz7uuO66vJh83b/m+39/nezesuE38ps5+b6oJQhUJKRIzGLk/TwTUsA4Q9/10qHuhRrN2YYyq9to84iUtliSNgWVlQuqCGi8rxyIqQ5YSSkxjmOV3ZJ2zzEtAwFSqb8oQV3Rh6hOW1AdYzmSXVNQgpXuWyZZHQfdr84AHBvNKtNZdT1G9GtxPPQxgkTF1buorNSgaakFXy8JyPKR3BT9Xxt9MJWDEsA1bnmuyu7CrnLfCef/L2S3Xj9ZG+pCBQVMFodsDoHDODLPnhgLxU8JrIw4qavXW/1QUWn121RfcqQKCuf1pCwt6z3NKySw+gXG1qa9gnSblX6V9P6iY4tOrrXHBRjS9y9yXOj9KI+pTm9p3lX/x9x3UqWht22a6qfcH1xST4hB6scpm3IsV2UdM2HAfr/j8upy9VqLzarAl9qighRT3qN8Dv7wctvwCW/xF17+w2q90UFNYVb+MB0hipUuM02VlsHcw9BiDJXWwzXd0Q3K8HpHb6W0lhsqEVFpJrm+vOLy+Qvubm6lL84szT9lKsVLxpFiAM3RvNuSnpGiZwFZm0IIXSL7VSRfOuXWcP7r60SLg1mUlkSVxXGPKcpEljpbV/3qYuSL165ruemLg1AEbaGYWhvtVZpKkVZjS12XvsZRjdernZU/6HqbD/kvpn/1J/Z6f5g1jneEeSKHRI4QY9apOMKPZ63BtQ0+eMZpFCfyD/meRuU25kTQYvfb21v2hz0hhPIouTcJsiJNUh1t672MISF8+AUdXaaYlNqlJcq3i7HXVePsVxr3+9d8z9CvnIsQYeEsVSMfo6abFrnkNf9ar6P61NV7TtPETmvY148tmYLXN63pWX3NX3/cdcJH/Fr+n/+EXu0Pt8Soe2JSPseU8H4meBl1SiO10PvDgcN4YPbFidSRUpbalQxLYHW/vrOslHMl0M85Y53UPO/3ew6Hg+h1dVTX92N9TwtN3+RnckzYBA1GUqvW4ozFGUEcDYXazyENfaV5ZB2ss7z2Wn5X4EHl3dQmsaOJQsYw9D2bzWZlh7TUKUcqRU990VfvjbxWccD1OjQovb6+5uOPP5bHrPY5F8epPB9W11B0809ufVlkVzKXSYbzRE/0gekwchj3HMY94ziSc2a333G3u+NwGOstOEbp5NvRfr5iVaRaf7aN6Kp5nvE+4OfAzc0N0zQRZg8pSzlLlSFtwrSOy8tb5jlIf3V2mu5vALeSSYdZIeZ14qVBMgq2oe9F3spUvmwL4ICUajnJMhwOEz/80Ufc3d0piLWszWbL6ek5bdPX4UDZZELSCZkqryknlVrziq/F1kumrbAhGQ6HA5eXz7m+vlwhs6I/2tbVc26AprEMXbf4Pj9Bf+FrGP470b3xMZ+R4pf6STPPJGtpmx7vowbOnmma6IYBrCWRiMFzd7BsnQMjN0rmnN8TsAVxFwja3Pt1ccI0gYQxTEq6XNAwoCJ/KSTatlk66OWlpT4zSkWLdPZZLXxe0KhGicetc9p5eY/GZHXZL0UmKgxr3lQUmi8RkfglSyQSojgqBRWVQEWnThUncvUZ7m+aNZZG6w5BEFofAj6EWuOI6t5sMuSEuRf9/3jr3s3RX611htFbeMkJ/y5/kn/6D/pWP8EVgwQCkoaEmAW5HscDKUdsY3XUXmS335FnT3O2fa0jV9cbbEsx0hlTa033+33lr93t9nRdqwh6VIom6vmQCVGWaRo57O/Ydi1tIzPKZXqPdqhadWadqQa+IDkS1SsDwMqoFvlbSkRMDSKnaeLZixecnJ4zbLbCZaj1rsNmw3Z7oowZUQ2C1IjLThXlaslazaq78fp9opxFy2F/IKXEMGykJm3tyL7hBtS/5tV0k1e800v37LWy+1X+Cv8SXw4OCukyFiojyVSN44FsMq5xFQW926ncYuvQBGAVoax+/oxVZKRpW/qcmY1hX3gYfeDq5hpnLNM4aYAnyrekT8tbXT59yra1nA2DNB8aQ4NTOjPhYy5TpNYc1MWwrp2H2jOwQnEkmyBlAdM88zu/+y2+//3v8/Vf+EW+9tWv8fbb71C65tu2Yxi2wtMdZgpKF1LEWe1TQJyLaE1pvVqtvLqmgtaZem3TODHPMycnp1w8ePDj3+Tlw77qjiyXsPrVl192c7WF1lrGcWSOszYyTeQYaDC0xkrqmiwO3vL0l+R17aCuQawSNDdNA4PUZ3vvdbxpJKTMOM04K5RjZSyoQRrfnBPuhzBPfPLRh5z3jofnZzSnJwztRonwBThKHNeZFt+mXHIqRldXpacqwJj6Fbvdjg8//Ii/9H//tzkcDvyxP/4n+ON//E/wx/7YH6tN2s7aqoOnKdL34qgK93GZayx6VIKhyqAuX/lYdjIShMogmYa3z97GOccHH/yQP/En/yS1jArAWJKBqP1Hxlja1gn/QNL3KgHYKyfWfX65/RE9/5r5I2+cPfmZXfyCCMmoLBNcTdvFKFH9eNhjnHRN5hA4MJKxPHrrXC7s/sW+6vPcR4ZX6JBzjtQk/CyOWAYOhwPWWvzsSSHq+c6aBtAtyplxPODo6Fzp1tcaVFPq9xQtsoWaRwupK5KkxcX3mk/Wjmr5W0yJJ59+grFOIqCzB7hGInppbOiqkEpaXiJ6NKqvUP4bUaEFVi9Rec7gfWAcJzZDX0cNllKFtOpMfFkPlvSWoq16w9ZBA6+8f/eckAyYzAmeP8Xl/Qf/TFbOiZgCOTVSF4cgU/MsRfvGGaZxxOQoUza6xOl2uO/+CF+tvKL+5h7iyJLqWRpCBNlv25agDS4ZGKcJkMAvRc1KuKW9owQS07jn9jqShwGzGeg3G+1KBbTrU6hCFgL+iqbqda0/x8syq65lSux2O/6j3/i7fPzJxzx+/C4///Wv80d/6Zfo+4aUZI540zSknAk507baDavK0mgmIMsoD3E+j++E3g9Nr1mROqNRvVC2WXa7PQ/Oz5c9rjWKCwOI0eDSvEGhvOTYfk7ZPSPyj5jd/Qf/bNZCTloJt33wMBnMLETe0U/yMC8zzkNKR4ZeHK+1p/qyVpEgVt6v6iU1+MOwIYSk4yMdjevo20YCilxq3OX1i7pM0bO7vSE3liYGWjKDc9imWaHzRvVtKeRafgfr+yfBVM2uyR8rO8zz58/47ve+x1/963+TcZp4cXnNYT+y3Z5wcnpylKIsurU0YWXVi9aoTBox6ukeQlQACJFdBR209MRZR3c6YAw8efKU09NTGuuqNpWvXEvOjBEbVF0eRWHX9u8Pqne/PLK7ZPyKjpnnGYJmlWLA6sAca+R3qfpTWcv7StgAb5JbKWzOSi+pAXrO9MOGlIRvFQPnDx7SWMM0zsw+LmCZsp8YEjl6QoQxZnZAS6ZvG7qurZchzVJLMGUoPsFxg1L5nbNO82JGnWlD9JHf/71v8bd+/df53ve+R9f1fPDBB5yenvH222/z3nvvalBa6pglYMwkPZu6x6ppxXdAgDlTNK9Z7ZMpYH/1A8iGzbClH3qePH3Kfn9g6DpKmUGxIZJtMfWeZp2wVcf5sbzV/bDu88rtFS1/xbz9KkGq67MdVKP9cjnqHG5ZJV1tnQWTCH4ix0j2kYRZ8R6+wpisPs+9bEiNjErUXCIJUdKRrMThbdNUQ6/bqA5fEe/E7u4OGzpM1zJsemwrlD2GpfC5RMQU4St1VKvDcTR9av2lymueZ37wwx/x/e9/H9e0vP32u/zCL3Y8OD+DDE3T0rZCLp5sFCOvSrN0Mao+JZs1Dlw2adm0grrKbwQFizExjhNd29brLWT/pU5ncaXyvRcuheKvd4tfdd/MSrGWV8wY4pvYG77QJVyalDGNWYrN51m6TDEQ5rk6qC1GOHU/K/12P6BaBzPGaHq0rbU8ISTMOErRvm0kxVlkLGWy03tSgiwSfprYhxnjZ1wMnDYNZjPUt1/eb9UcVWRU/76MXWT5ffm3Bi/X19f84Ac/4Nd//de5vrnh7XfeYw6Rx4/f5r333pMaMaSeypIhN2Qk4yCjdYU3r2QBat1sNcNLo15Ky5nK+jxjLV030HQtd3c7TrYnOLcMShAalqUxE4TmxVQDLwr35Xvymvu2umX3ZfcEy58y/f1n/YyWOn4rA+F9FE5pIKVAjl64P0OUsoucV8b++HVevSH6CCP3CXVQrXPaUOo48YHxcAAyw2bLpu+4ubmlNG+Z6oyIbokhMEWZlHfImQ7DSddhhm51Tso/CwBwHDwt38VIOi0PKI+3RtCwD3/0IX/7b/9tvvGNb3B2fk5KMAxb3n33PX75l39JeEtX8u+cI5t1PV1xAupPQKFYM3XbDDKlsBQApJzq2TvZntC0Ld///vc4HCa2m6Ea+kLlU7Inxki6VGQ3gU6rk3uwIGKvXH/fyO4qsDKABT/NJKN1qVm+S0bT6uz3dXFF2YeXwYCjVeTcLPe2kI9b69ieCCF/SontySmdtTx3L8hIBrbwVxvNMOYov4s+Mo8HxsbhT7aYk02V2eqkrq/LqFOnD6hyjTTEOq1hLTHQ8+fP+f1vfYvf+s3fZPSeruu4ub3hk08/4cOPPuT999/XZt6kwzKWmtX7fSZFYkt+en3S61/UOZXv8kNOmaZt2Z6c0PcDNze3uIuLGkgVKrTaWFjqS1Mmm0jJzsmGvFm3fJbcelqemDfTUr7RQZVmpwREMJJwN0aUU4qJOXlACIhj8piU8FiSa6WZh/xKe39cU2IqGfmivZTUuXUMdqOppw7MjsM44n2kca06YWhdUXFOs/Cgxsjt1Qti1xCHgY4Lhq7F0ijJbSaXOllTaqFK4f/6WleOai7lXZpmTYZpnvno44/5N/6Nf5Pr62uaruNXf+XX2GxOeHjxsI7S7LquFuj3/YBzVtOkmTLRJNdPcNwJV45tQicjUWpEDEPXkwzMwSsRcUmxyBMr+a6WZy01J0e3gGIQF1dgFYmZ+7956ReA4RNzyl9w/xA/e8roYgBZOX6yF2MMlM5aQ8KqLAbXrDp/V1FAeb3Vvtx35rOxMizNyhSTtm3JGW1aEqM/e8/Dtx5xsh148fwF8+xJHHBIZGxVbsmBFA0hZg5+xnjPSdtydn5aPpg8vvJH3kOiUOO++tyudElnwAqnX0rw3W9/h3/v3/t/8x//vb/H43ffJZsnbL635a2HD/nKV75amwwKUt+2HZhUB1WUsHDZIyuBrFFi9eot2YoK1FAyC3PBZrthe3LCBz/4gGma6Pte4zGN5g2LsjYsHLQ5ScqpKNQjkfzxZRfzAGP/03xZlkyaM2JAkWxVDrbKivwvQYrCWZgTsTib5KOhEmW9FISKla4GcGGyEA/g7OxMkJ8Y2Z6ese062u4FdjwQYq7XYvR6UhRZCT4xpkSTM9u+5/T8hKzjlCwLNVkBIhrTKK8uiuAs1926hs41tNaRyDgD4zjxrd/7Pf7Wv///Ydie0LUtKUWePv2Ub37zm/zar/1apUZLZdyT0e7tSi3FPdldMlhF/xZXtjTfy45LeUWIka7vOTk9o+0GXlxe0jZvqzgWh6UwdMheOWvVIRJNjsvVsVr01N/Hsls+gwajTduw3+8o0xgM4pcnsjitqhPWuuqoNLi87Epu1/0hNcixRnWPPLftOppZOFczYGqPiSWnqNpSwZmcydEsv9MSwnkcSfmMxpTCj7yS21x1rf5CkHq9vpylSc65Rmte5Vx88xvf4Aff+z45JrabgWHTg4XnVy/41u9/iz/zD/8Z6VXRCYcpATbRtLZcbTVplaWnyHJ1/orbSjVjxUFOkvpWJ/6Ut99+hydPnrDdbCTjWJuIlXeVpXkq56h9EWC7DspELAq48uPL7WC2/IL5lTeK1BvhLqHRsKt0tBoY5ZQMwbPf7xkPB8JhJk6+jukSaqU3vndN3a2vPiJdqNY19N1A1/d0/YbTs3MuHj5kGAbeff+rfOWrX+OtR49ou0EjsIi1EqU2jQEipEA4HLi7vuLpJ5+yv7tT1BKNfuS7M43WKhqNyJo6wabyaSZBDCzCIiDoJXzrd3+Xf+sv/iW++Vu/VUmuf/TxR/yNv/E39IaLU980DU0jjmrbtTIJKy17Ksc2knIgEYk6sKAoxnK7iomHBNZycn7O48dv8/Ctt9gfDpUmRpgXltR24UItY/vIEV7lrP4h1q/lB/xf+BIoSlBOU5kcUjOIRpyimJM6+koBF7PKq9zrhSz5x9ubpclOviLgmkan/Uia3LU9TdthrFudj1KCIWeLGOmto28aXIZxtxc+yoXqYgGkSjmqddT/TIvFETOahZDhGq0aegvkGPj4wx/xO9/4bc7PT9luNmyGgcurF/zdv/d3AHR8sZb0ZAgpVdaJbO7pG1hJa8ln5FqhmmqKVOpmyz43TcN2e8L25ITr61sph0jifEoZgKOk+WsHdpHdz1IwP8b6PX6Pf47/yk/s9f4wqwQtWXXa48ePdLABrBMUNYNfftbvS0j9WevlmnqD1P6HnAiagk0GYk7MMRIy6jiXTFNW3uWISREHXJyecH4ijuN+f1eZH+RN1mgpS1kMyo2qg05iFovj2rZSDBZs/Rvf+C2efPopDy8uODs74eR0A85wdXvDBz/6AOec1hzKWR/nmSmGijDfb7xZ/1z1o0AdisRpPzDIsBZEdo21nJ2f8yu/8itcX98wjtNRI1rJ/BUO5vJeIXj8PEEOPxH1+2WRXYvTITkJ6yzvv/8e5xcP2J6c0HXdS0F/3WPdo1pP/hnLqA1e/yxL5DaSpTnJGpFbn5hDUjrKkr2KEBOEjI2JxsDDs1Muzk7pm4arq8uFDYfVdRlqQFdS/nVk+qokybhGOYHlmc5abq+v8OMoQdvpqTR4G8PusOfJ0yeS3QsR7yOTDxymkSn4hWUjRnGoda8KKl0+Oyv9K99NzbgalkZbrMU1HRcXb/HgwUMO+5G72z0pgrNtBbgkVhUtnlJi9p7Zz2h0/IeW3V1+zDfif+GNj/kMBLWVTkuMjuZSRMbphCQfpI4TxGhlmSVLGTn6eT5BhYsBu9QM1WWMkEAjUUvpjosoQXQSR1gQUDXgKN4YpQmqd47GWqb9SHoQkc48Lb43bnHwi9WXF6jLWunGK4Tpzgj62VjDi2dP+c63v8WDB2cMm46ua4nR8+LyOU+fPiXERIiJGDMxaYRFqTpc7dHq/UrElQyUJIII2kL3ZVyDMdA2DcNmQyazu7tjmjwxqDZt5CAtVCcIYpgCJCtNOhlytnwuzbC+bat/l6f+Hlv+6/nX+Ns/3kv9VJZ0n2tFWc4Mm4GTkxPudrdMs1CQxHkGCmrNUXqjKIBXLkVJlmaAxZEqaZ5yb0sXZ5laMs8zk5JV51zMrjjSKQAm45yldZaH5+dsu545zOz3O7anG5p7fZRybI7PTXWUBZetdGaFzg1ruL2+JobA2fk5NJbtdoNxlpASh2ni+fPnTPOMj5FZm/CMhb5ptYEnkSw6XvgVtodCcXUPxysK3pRJQo6263n06DEvXjxnHKVbPWiAZe45FKUeKoYgI5GbIETbKzThs9arZDdlwy62n+8FfsprM2zoh4EpBELKPHz4UND/eWKaZyHQ9wGnOF9mQR2Vc7siKW9ahUd3SbnLU6wCB6XiSQxiwnvR+YUiDywmShbNkHBWGjEenJ7yzsO36LuOm/0tOSfl6z1+/1zZR15GyaSusCEbSwB8Fv5oazPbYeB0s+Vks6XZ9LRtRzQGHwO7/Z6rqyvZJzX0s/c4DE2yKyrEz7oLReaWiGBdjrBwuTr6fuCttx4xjhMLtZqpzko+0iuJGASp7VME6xQ1/Hzy+2WW3c1mK/LjPTHL+X7r4UP2uwO7/R6fZ0xKi6xR+G5EDlKCRDqOwl6xjlHURXakfKD8brGyIQQZ+kMJMDIuO5oErYHeQBMzP/f4HR699ZCmbbjZ3wJJh0mYBbU0ksl02VL+M2V6ZDlzWpoUUmSOAWcge8/JySlnZ+fc7fZ0m0FGwSNN3uM0SyNvnKVkJ+kQgWy0/lmp+HJc9kdRguW65DMXYKoM+5Byi1x5Zo0pU/wcP//1X+B3vvFbjIcDD87Paa2rOlZeXHyJko3IMTHd3dKfPajXIOJeIdxjdJnl1/X+6fef54f89/kfA//n197rNzqobduqcSupdHnpvu/IZNrQEoMnRaT+NOf6GHm8fLAQ/FHEWg7u/bUgUAWlMVBQJcT5LIZfENygXKzaOAKKqiQZtWczbSPjV8+2J4TgV5yKKxTKFKUoVChyE81S4G718xtb90JS6FLE37UtuIau7WQKEBBSZD8eMKYhxISPMhnLOq1LKp9EswWv3A91ypfaveUOlwNqnZMuRgNt10vphfc4dcxB0IiGAr3r3qe8IFW2vM9afMr6/MS7hjva9HeAf+yNj/0iltEudax8rq5tGYZBlJhzTOOeOC6R8XE0ujpQZl13pF+GulfltwUtETnRwCNLU09mIY4OIehEm1TTqTmBzQZn5D41Boa24fHFBW9dXDCHmYOfqqxSDJ8pzvXxvVljYiVLEHOW7mVjcXpG26blZLOBxsncbCP8kSFGoWYJqQZYIcZK77amPyvyu17HtX3LFVXxXQWERVlaJ0jqfrfDT5O64cUImfUdUe7ZhCFggse2ThTkMky73sXPK7uWnq35+Tc+7otaUTlJJS0twfRmewLGkkLGxwnJmJfmhYU7unAdH9+Y44Bfvi119PVP5af1NtYcISSVWxByNFXJNNbSO8tJ1+Jy4MHJCY8uLjjZbjmdTxjDrHWkhQ5tJbOitKljl++DBUUPa6lSTAlrHG3b0rcdbddjrCNl+VuMAWOlQ7xQosUk41AXGj9TjfvqoOuWLcGlqUDLS9sne+ecjMg0jseP3+H73/suYfacnZ3StR3rTIc96iQXEvv9bsf2QUsp8MpHd+PvP9n13kvpW9beiJTrtDBpblM9oE7qOnQVkV3LwGd76+Lnmvr4RWTXdGiie7PKsVFVYbA4A9uh49GDLeP1FQ8fnPHowQO6oefBxTlPb15Uispib+s7qZNdK1DNUvMp15B1UlVS2RO++GHY0Pc9TdOR1LbHJFM5Mcv0vlIC1TU9UvdZPg3HUlJLnESGRA2KVVg68+V6TfEl9HvOhmF7wjQHxnHm/PRlUGbR3yKPiYyfJvqzAuKU81zuSbmvny23CUtg88bHvTFU6TqJTivfnN4kqb055ez8jH7TS/pJXPmjTQNkGknlgFxWjXrMAkmLoS+1JawUZdY/qvCRJE0SAiHGegNqyitnRQpldvjF+RnvPn7MMHSyeTlVk1nLTo1EFoX+pjRTLX9U59SUrm6ZVtJ3PRfnD9gMA502dJU6p3GaCFGu0euM9tLQUI38/Tzd+iauovF6v+VS1MFe6IOcaySChfo+RimPhC9twWuTRkg1UsqZdeFILWh/hdPMchn1q6yeAz/Pt1/7nC9yGet0LKOUqLQqw/0wMPQDjW0WpPQlIuRXraVbvhz2RWeVOk3dYZVVWORXuojNUZ2PqTIrFFK9bdh2HZ21nA4Djy4u+Mq77/JHvvY1+q4V8uh7TsVxM9/agK6uC9TxTDXlbq2rTvtmGGjKcA291uJE1wyA8u4eiew9OhPK38rpysd/Xm5O+VbOlUT/p6dnShCvvLHrmMCs93KpjQpe6INMri1FfyDZNZzQmz/92ud8kcurzsgYsE5GQ7qGxrVSExdZ6m9zSY3q3cuok7q8XgnA738tf1/O/n1jXM6INTKfu+gLwQ605MlYtl3PW2fnkuI/O+XB2SkX5+e8//Y7tM4pzZ82phZ9Vs9QXt3nY+Cgji1VXZiSfNZG6/rbpl3q/9T5c20jBVNJnNNExrq2Oqf1/OS1JKihrf69BmDrFp610Iixqmnci4u3uLm+5fLykjAH2qal2Jc1TfGSpUns9js9R6k6UH8/y+40jkyzJ2VwtsFrgFuDeUFiVD7TUSNnYa7PGvhAoWtcB7avkFtTK/ApzZ9rvl4BmqIGbKVzX7MHxrAdNrz/9tt01nC23bIdBk6GDY8fvkXfdpTRptglwJIUP8t50Sst4AEcy2wxCE3T0vc9w7Ch63pc0y5+k7JMCK6x6LemWZBx89KdX61j71ifvzippcnK2MVBTRlM0+Ljcp+kasos96vsK4vf4f1M9BN+ngSgTOsG+vzKr1fJ7Y6B3zR/5DXSJOuNCOrJ9hTbDcSECBtgQhKuvE2HsYa2dTwfR6n7yJlsEjEvaNLL6/iDLx69fDiZmatCp46hqYSzSm+DqXU9UuMp0ZnJBpvBmYx1megjD062fP2rX+Hn3v8aV4cbnt9dk8zxla0V+PK7ez87RcLK58plwk9D2/Scbh22bQjGELNEidfX1zx8+EgJ4mWkpnyGMhFKbl7l3F8J9+LwHHf1r2tdSqNMqXF9cHHB3YsXhBCOHKbiEIkCVPQ2I9OWypSYBcp96X7prTn61fphJZ644x3+Lv/cq4XpC15tM9B1G1I2lQMuZKkrlfrhMjGjtJ2lI2NU1yqqP47w10vHOep/JQmfyMcOKWalOKkIjcuiLE83G37unbfYXb3g/cePuTg75WQYGDYDt/s7xuil9M9aMEuOMpO1CUVTO6ZUf6Z6fSJJQEYK8GMWYumuJ7tSeyiRuDGG0c9krPJwRkLO9E1Be8pY1QhZOp+lodNUJzWZjDHl/Rf2j9p1C9rckKXAD3hwcYH/dmQcR/pWDHw1KlYu3mgAJaKa8FOgOzWLfB4F759fdhOPuOOfffn+/wyWMY5Mo+VHTvifYyZpoG8aS4hJynRyubu6auC5MlhH26B43QqxqtkYRA5TFvfgCC0v+iSXeml5zcZYXI6cbQZ+4Wtf5du/fcX7jx5x1g/YDH3f07UNwVDrl1G0Zxld96pNoNq3ElQvDCuS3dtsTkg6lMBGcZZtRekWBCsnaUzNYZYwfaXXq7is9qoYUtmeZW9Fz6rsYmR6XJQaQescPkSCjjXOa71rUM5j2UNr5TolCMuCnlkn57Cco3Ixfx/JbkiZhkzbNDRdz2EayUHL8AxCXB/Qe2KWehSgBPYloK7oXPVsFhqy6j9ASXxTgmdbnqty6jD4HKkMP3qznZGGu9Oh5auPH7H/6Eecdj0NEOeZkCONtUs9q/ol+qKUoFnMSNKsmWEZN30cbGT92zBsuHhwAa1j72fibk/Wcz00HTHlWlqfs+jK6H0NbIpoFLk1RUZyRtMqGGNF+6suNtZgG6d4wkKjWbI0cwhaX24JGfpceIpBOH8txmSsdaScmeaRmxfPCdnQdj39ppda8U7uigQZBQS09d6UVbZxh+fvmCdvlKk3OqgxRiEHd0LEn+IyFSnImBmC8nbFHElEbIZEGSf3+lUdovKRjPyrOGpSH+VIeSG2jzFV6pGC8JCF5oSca5d9bx2/8vWf5+rDH/LOxQXvPX6EzZH33nkHnzx7PykkLhuXslWnIq9113KdKN8plhTB+wTO4GxL23b0fU+cDM61MjlKqStubm44PT0nxCg8hVAFpQqXauFSGlFuYO3SW2nwGKPypBpcI7cupSgNPk2mcU6IimevNVLyHqVAX+RGGoIwgRQCJgvtVfIztu2Ow/0fc53yIf8J868C/+gf6Pk/yRVjJIZlKk4IgTSOwucZAyFncFbSUizIxmvXOuBaKcj1MkaK4RsrQYgozjWvnFAEaQivMih1dTZnWmPYdh2nZw945/wBW+uYdzvurq5WfKMrmTDip0olw0p+oKLr63T76q8Aiv4/JFsIZPbTRJ5mTMxs+4Gbu/1RcNP1G8K4X6aYrbfn3n4cNbrm1bdq5BeHPZW6tJzrFJio6EMIftlys5wJY4QPdNwfaNorYso0bUc7DJjmMwsMX1rv0fNf5es/9vN+GiuEgAuBtpPGhsP+UIm6szr4M6o3c15svK7qYOnPqZD4m6JzFh1bJOqYQfH+64kzhpG64+T0uTmRTMI5y7bveXh6xs+9/Q6bxmGUhvD65lJ8DwslC6UXsHCcWrt6M9X9rlXZiJqiRY2vMGP0/YZHFw9p+5a78cDVzS1pjpgIvXHEEOskHQHkLD6GSp22XmvZrT7zPdkFOWNN01ABZm1o1INPBi2lEbtUB8qYJTCVQTGWGAPzYceTj36EsY5uGOg3J9I44950N15eXxbZjT7gbIvtJAs5jiPOuOogWWsIBqEpsoCzuEZ0syEXv+8e9dSyVm571S2vM1VLY2WQZikD0ZSaV2k4fXB2yqMH55wPG37u/a9w0rc4k/EhMAapJy5ZyFJKUHpQGudoVoXMpSbZapYtpYD4E5aE2ITNZsPJyQmzspVs5onBOvbjSNd2OJBG8xgECDOQnSWHJTh85WeVK1j9RtuoNTCQyZmN/kUcX8rkSeN0CpujjrxKSevbWXwHUOQhEmYZUNEOPdZm/KTsSZu+PuzzrF/hBf86f/mNj3mjg7rb7ci2B9sQc9YuOIQix+TaLWmbBnzhkRRkY9m4+yuv0NWlzkbdxVV6R3DDuIp6jtPiigRas6KzEYXtrOX9R4859TNvnQoPWgqBy+fPSTHgrCWVDoAaPhe0Rl4p6bSc2sUP1NFVZEE5kqBQJ9tTthuJDPd+YpxnbMqcn5wSg46GRCKjtu3Vob+3B2bZhQpDoZ16Sty9dgwMRtOutgba1lpu7+4IMdDT1STJ+j5kTXWQs07dOGD2B7KBfrOl6QftMrf18S/R07xmbdjwq+bXPtdjf9prmiZcM2ObFuMcJkbiBKYRhWOtkNxnY6QLmVTl7iVlkFE+4BK+5krAXB6wruA1a6nWUox1zZW+m9KvaJRrDJt+4N1Hb2P3O7bDQNs4nDWkxpEOSZr09JrX6a3CgVqWOKZQyKTX1GLJQGMdzrV0bSelKV3H7L0YZ5233ruW5GOtm0sgip5XN4+tJeTVE3lWj11lCjIFFdHGghBr7VpxQuV8FJfLVJQkpsg47ok54ZqWrt+AgZYe03wmxfO99Qwb/0/An/oxn/eTX9KAOoOxktKfDaZjQRRVXqojpTopxwQpKxIqTRv6lLoW5EWNClnT7mv9s3pcgTtyDaUp1EDSN2o4PTnh7PSMzTDw3uPHNNbRNE6aQCykg6dQEJRrPhp+srq+cn6sWRpTwCjxu5RPnZ6ecnZ6yvWwoWsbnHF0tmF/GHGNlEHM08wcgjB2OENypafh5f1eHJ9F/xrNBlIb0Bagojy2oH0hBNCGP2eFND4DOSQZvEMm+iDONVlQ7iTTraZxT9cPxOAI80RjDY3rjxGnz3RWvxyyW4JZ4c1M5JBo+laQvIgCI0KRVybVWYOgqHq/V9Uex5y+NSYvaXrJtgoriMhVAG0slmxANlZRVVO5dLMitWS4uLjg4sEDcs48fvQIa4UaigZ81Dc1tqbFjbV6f+2RDiuXZwBnJQtRJbkEYAbOHzzg9PRSuEcxnA5bNk1HPElsNhvSNOOnSUa8q2+TnDmetPXKdeycSiBvKU1iKFi13sfCilKu3ipFYtM0UrcdEvMs0zsvLi70+YmUgtCKZkPbtzLVTvVVFzzGfn69u2PgN/Mv8mff8JjPHnXqPVhxqJJONZEDqZsBegOqBIlDZRbk+f7u1l+tUJaC9CwtQaocBXZZKVWUTWAx9rYaL4l4+q7lwdkZw/wW22EjZLnOkKawpFyMqSknoYxY1b6iF55zTQm/pEWV29EYQ9d29E2Lj0EOXxZk9rTfEMJCeIsB5xpSnrXTdmUS1FEu/vLa4Sh7KHuke27K+6/cI2vZH0ap01o2FrJOnzFBHRfZuRg98zQL+tR1QtRtHVmnUZUP+yondf1jRQfo2fDVlwXpZ7BKCUhWYmETLNaJAimytXzpk+7bgXtO6iIbx48V8Stya45inqwehcn3Xm/l5hkDjWvo+4Ht9oTWWdqmFWXopPs5FRjKLGetGvl6EcvHKOhU5Q0tf1FHoRt6ur6naRr6ppU6QWvoFJLtbUMKis4XZakNX/eV5ct2ZDHymEI19TICsA4E5JutAz5kTrslxUTwkpUQ5GFLCVZTDPgg1G7DxhCjJ3hhb2gad2zk1/vzCtltibzNni/DKgY+JpngJw1JZS6NlQDJCOm76DL5Kohh1Z/q3FURqP9njiDTdVXzuhnjyGXLJdBa5E/0vGWz2bLdbrHWcXp2JiCMpmjLFZXnLQHJy84p+jepVT3OCtQPCvQboR90zokz3Df0TcdJO9A0LS5novJgRj032ZllJvrxq67+cdzeYVgAidffrIIyLTW2hWYuxcg8zYQYMBi2p6d6f8Woh+CxvqHternfweNng22bkjtWO7Vc4pdZdiXgFNQ7BC/BkrWYZCoXs8XilK2n6Kic0qKTQTLVcCy3RZZLLeXyrlWH1D47U3yHxXm0ZjUGXd+373vZe2Pp+o0AcDqRLca40rWm/O/o6xU7QOkNEbu5BngMTddiGkdG7EHXNFjXYDNshy1dTBgv0zFzEhpJyuCS+/b33j/yvd+v/aojGrUodjGVTEKlnSx7Ltm/aZrY73ZkkjioSEYrp0jwnoiRgFiDLe8Th7sd/fZEnPx7wvoquU10TLz/yp0s6zPd3RAS2QStI5EblkIk2gU6XnM/ls5zvRKk8/7+yvX/NdFHUaTLRukHy0YcDP29ZcUAYErXtDwxZ2gax8l2y3bYsHnwQFImCOl/m1uyH+v7FkdVAiWzmjJyvJmmEJ3rVct7UqMxay2bvqdLrYw1NY4YM6fDhqvdSI5Sc2oah2kcwUuN3jJB5HiJg7McDLmOpZBeHiQH8AgVMEYCCkTQyEapITLzOJPahCspqpxIMRD8xOwjTduQQyQGjwsO4wzgllv5iuu8vywtG979jEd9UUunYiTlzAyWxhhcdmrmNbo2FmMK9YmpCOqCBOTlNuTlnldXTP+QtTa6Coc6aWsv6Qj5Wn4BGNq2E4exbRicUD5lDaKSKfIqFVeGpRSmfl998vL74ozLWxW0UpzafuiVj1co0od+YGh7TrsNjWsYrCOHKGU9OYNzauTNK87zetcl1Vn9H42uqpiulaX+O5XsjO6dUYcmY8kxMh5GMebAZthidFBFSoHovaSsVKaDn3GNxaVWnfFyanVvXnPdLS3v2sdv+GRf3JJpRZmcIzEGMJJwE6om2VkpSkoLD2PRi2tEZ6Uu6i/r97WhV+2WS1OQBhj6lxIc26w1pxg5U1ae1/UDbSdTlLphgy8BMTCGUOW2Xpcp1dqvqPtncbhLR3j9u+rnpmsxrSOaDCnTdy3btsP2G4a+x4VI9l6ZZdTJs/YYkXvFKnsl4qQa7w3PEcleAIiS3i2OfIqB/W7PNMmUxZPTE4zJOi0oiEy7loKqphCYc1ZWjQHrms+UW/jyyO7S8xBIM+J8yY3UyUoN2Sap/9QJYdbYWs5mjNGgatG3yw8c6WijMizDoMogj8KVexy0myz1pkqFreitHJWYIRoZijH5iE2ZaDJj8DJmeO2O5tV1rFaxGetSDrKpwyKKjjeNIxnwwdM7g8uGHmixnGTHEBLOB2wIwtFa/apjX+CltZrolFc2YQn+c9W1Re5iELYLKVNJgoRqUEnOjIeR/X4vZQxplcXWxtRknNznFDHJEkJkmmYeNh12cC/t0atWh+W9PLzxMZ/poKYUdWRb1m44JG2qQtAYp7Wfqjy1uFg+ziK096PQfPSvKoF1Rrlk03MtgFYRFAJ2hJJBaKEsKXktZBZl+ejRYzCGYbsFZxljwJA4TJ6svKdrJGCdbipLUGF51yVlmet/WKmJ9TkQspQNtE3DidtwsTmhMQ3vnT3k9u5DSEkiOOeEi6wcHFaRxZEH6Orfj+9FEqfDSMe1kBSu9jVn4U88jGQkHTvPnv3+wDxNDEPP43ce44wUtIcQmOeZ2QdOOSclmaARQqCNG4bt6WsV5Pr3Zd/e5pT/cv5T90XoZ7TkPkUlW5YpPIa2aaTD30nNjRh3p2jMkroptdZrRWlghcLkqjxsSQGpsoxRppU4Iw6bM1bKSlLCGSN1UDljkihOZxxNI+NRA5BswyHK/HWTDD5GYlFyaFCn+qpK5j2U2yxiJgh7Zim9MQafElMMjH6iN5bGOtrG0XQDJ/2GB7ahCwkbozYxZeEgXsnvG5fukzF54Up+6RYt4/US0iwi9Yeu1lySEi+ePmeeJ2mcykIzlIpBnyZaZEJM1EAwas33sD2VWkZTL4nV7TyS3T3XfIO/xp/jX/7sz/bTXibXMZkxeB3qkCSIbKBrWuYQhKw8CvougykWXVAkpSS6StxkSllTQTStGr+YSDYqcm1ojM6mN8IlXQyezQmjtD3lPsWY8CGRTMNdnLVhKRFzZs5ReSHlqjBLCchRQ8tK/x53shtiyMSYMb0EU00/EIHdYU/jenosnXO02XLqDNsxMPiI8x4TAkZ5cpdpga9bS81qUgBm0fwv46gSWImjToyUBkBrF0dlnktPQAMxYZss75MjfpqxtiFGj3HakDgndoc9bz1+l25oyEYGTpV1jKZ+uWTXNgaclMflEGitU1GzNK6hbRrIGWczbWNwzT3Oc3Tv9VfaWqIBw+L4o4F7zovOzZV9J91zWCFEoVOUMmhtkjWWq5s7ToaB06HnbhyZc6TrO0xj8IXvZIW3rTNWa6cUeOk7lGZFMBooXzx6TNP/kJvdjrbPDFEAwDZb2iGz//5HbA6e1kdcTFhnMElKsuz93pC8urAV4Ici7nL6V+dI/bCUS+Ou9kIo+X9ZMQYafd2hH7i4uCD6CP3SHJmzsLr45GlSi81SQhkRxiB5YR1SkBe7Ccdye84N/6n8t94oU5/poMqMba1lyJJqDNGAB2MNm16Mq3OOnJw2RyyjvwrqVybSFMu6orXVu79Ksx8tETqjCkZoFzQ60H1NSZphGiXODckwx4wPkWQNnbEQI5OmYgzrBpVVZL96V2cMOEc8qjeBnE0dYWkaK41FznGYJjZtK8rSNJz0Gx66ltMIjdJqFNXotBP/Zbevqu1XrpASRrvOI4lEGViQMFrMHLyvE6rkugVrKamnSp6VIyl6YpiJUcbVynSrQJwnGj8zDCfa4f36tb6Hz/kh/xb/U/4b/K/f8IwvZjnncNqUEXUSRmlUaqw4ZNt+wI+CVjl1NF2jR7sijixpprIytX5U9tjhbAtW6oJtjLVTvaRSCh1YVqfLZkESZFkm77m6veXjT55ycbrlwWagzWrsTBaux3uHvNTqrSXmPmG/XK8hRQGTBYWwNN1Ato4xBIY80SZ5vQaLHTL5+TUb72lDxMUMWeiNGttofePr1lpZlmswq78sqwyRSEHqTFNKSpnmtOZQGzUbx6bZcn52oa8TIQvlUYwRq5G8Q343T5lx9jTtgHNt3bNXXeliTgIHLt/wub641TqpBZMauoWxxPTCuXyy2eByBiLZZZrW4Zrje1KzRKtVxG0h0DM4GtE61hJDIBO0btDIZLyUhU1AMwStNXTOEguBN5nnl5eYGCB6zk+3HPzMyXZD2zUEVvdd5eE+GPCmVSf/oX1aznF2dk7X9YzTRJMDzeRx0dKaBrdJfPhb32Q7ewafaUPGdBaXBFhx9vM20C3Xd2zo1V5Yo2iS6NscZGiNU2c+5YQ1mX5oaVvH6elpTYHXz2+SErN7XGokfZ0iMZVgw9Q79SqA58smu5t+kJQ5hhgVCbWGthX/wDqI00QKM85lbKOkpKuZc9nYlxRFkdvK/oHBaiYs58xht8eHQNs3GNtoalqoBed5prGOrm2I0RGzBFfRGK7vbrEpkqaRB6cnzNFz7gx90xOXTmaRW/UT7Dryv7eOgizKxzA107Ddbthuepy17O92NOlAky2N7Wi85ZPf+h02bz1gOya6KeFbAerarsM5oxzuyHCUipzcu5YMOne7lhiILFk5y7Y0cWVpRo2AcQurDVJZ0HYNXddwcXEhY5bzMhGtTJXqw0xKLTlLplUuq3x+tRlvkNsDv8jv2v8ZX3uDTL3RQTXOKKWRxegMYRClkZLUSThr6ZqW4BpQugThMtUESC7Ex4uZMtkKIlqiaj2IFqE3sFbqx4IPMvTTB8ZpZpxmcX61/tLmTKt0BmVzvA9cXl3y8ZOnnA4tc2wYUqQfBkGnWCKMpd5JrqHczHVtopyXREE1C1wuBftw/uCCd997nyc/+CE29DR4WttgveHmRx/R+0gXEi5KfawE3DqdC2pCbbl9qZKUl/IHqw06QuIrjnJKkKwWoxchTAk/z1qjq9GmlbnAZ/0ZXd8t71TSqynpwANPQ6tj/TI5C5dgoT1ZN6JR6YOW+yd3ONBw9SaR+sKWcw7baM1mNkRTkDqDsQ2tczK8oW3w/kDbukrblVKR15cNw9rZsqsUTKmXDsETgvDegqR4wjzLK6VUmSacopZo9B9T5m5/4Ecff0J85zHTNHJ6umWz6WkaRyzOaVGYRUZf8dnXDurLGQwRamNhs9lwfn6Ov7plmiN9dhjT0sSG59/+Pl0Dvc+0EWkqTFRjs6yCEpT3XH5fQ26KvCUN1hW9LgwHSHo0qgKWcycaL5PYbjeSoegayMs5LXPqZz8R4oyNVqlQyhCEsgrRdYHCj/cjZ+gZ+cX8g9fK0xe5rDW0riVbS9SzXlL5rnFYd0LfdRwOd0SfaBphWilZA0CQlJV0FElOSWgCj5rqNM16GCcZ8jHKFKdxHMk50zSNMAsYWwOtpCUZGYOPidv9no8+fYIPDzk96TCd46Rrqr4tFD0l/Vg7+I9Qf3P0dSS7ptgiQTf6oef09ITw/BbvI6SGxmTaPHH3/Y/oHpyymTNdlOYZUqJrG6wr46tXu6PGvqSQ69IUb04qu4UjUmU3Z0HAoo/Vkbe2GPtcxwxnlzWAkNeu9fFZOCVD8LRtc3yGSooEoxYhsbCCfjllt2kdfTeQMswmVDo8ayyuBFHDwGF3hYmesp2FSL80jyazuOVFbsuYbmsMhQfNWdEH8zyzH0da3whbgw4MyJpVKHsnfoLa3ZyZ58BN3gvokxOJLd3phsZAqimqlS/wGUFVAeaOfy7+hfx8en7G22+/zeX3fgTR0OaG3kYGIu56D23HSYJT13BnJGBxTq6huPF2XQZRJm+ZRZ4Lcit/zhCz0q/ZykeccmIcRwU4bOWRLj5P4wrDkdT/G2vx2jSVjUxEnOeJfujpCiih3mcBxparfLXcXnHgr/Nt/ok3ydSbNtw6g3VyxVIWJQ1JhTyZJD/3bUvuBxoyMWp0VNN6K6dPUc86x7t+oLLZgpKCpPqncWQOEz4E5lnGQzprV92q0EoHiaSKMPgQub3b8/HTp7z98JxNaPFpwA39io2xbNOSwjn6/UqgCqRNbsTZzotqM0Y6Sh89esS3f+ub9NszNtliTIsNjsNHn+I2He0caWOJDnN1bGQLlnqaej8lzj66spLyK8KX1LEpEyeKAk0xrRS/bKyzTgvCW0qJQqFvSdpNGkKgjFI1iNFaHIzFWdaL1gDkeO88M0/54ZtE6gtbrnG4RngkyYlCUW+NIHRN07LdbomxY54trY5pBCpaUqJCieyX117rqaJExXDJ/vvg2R32GIM4TClphiHVOrXSBFInyyQZd3eZItvthtmPmNbR6HAJ6Sde7umCwhzfg7XRX5RlXhm9etg4OT3h0aNH/OjTZ/TJQm5oDLTZc/jkGc1bZwwhM2TDbAwmJ1odflD4dBfRzeuLKG9Lme5Ua3pVAaSKQpv61Ky1TsUJks+R6YdOkS/VHyr/MqM6Co1b8DRNq0hHPj4D9wINEd2Vww74fMoz/qHPEqsvZDln6dqObC0+RXzIQgWjnbautdi+JeKZ86xGtJxJqW0XTtuVsQTK/q2X8HI6UhKKr/3hINmotmOeZ3GKS3mKWzmVWd1hI9PHxjlww55+6DANnMTEgAACejQEuV07pkd69liO14bemjLvvLxW5uR0y6NHj/n0ybXQ4iTojKXLAS7v6Luek2Q4MQ13Bi2RsBVwqKMc1/4o6x+NgivULGDRy1V2kfGcISjPsZUAqXSVGyPlF8mk+urGGEIMFZWavSCoKfU4t9I7L51t3aucv7Sy2zgJukMG63Q4glka4xrnsK1jnhtKmV5p9C0HO7/CrlD/rI5QLa7WWt+cpaYSQ8iepBms5JSTVrO3C5ooJYMhJSYf2B0mhmGk23TMKRPVQZU7fCwja1CgyO2RrJaMbEZLu1x1Lg1wfn7O+++/z933PsKGSJcyvcl0OdCOHg4zZzjOm54pQw5RCP01vhG9u3KWVR8WNVps0VHJVy7OudhFKUFJ+HlapnTqC0liV8tWknTtSxbDsNvtuL65JgPjdGAIQ21qle928UOr7tW9eoXcxmzZcfJGmXpTrk5S942jaQyulSi9bZvFeKgx6fues7NTzs7P2Ww3muaw1TDBvbPGPRHMGjEr8kcSWo7dbsfz58+5fHHFeJBmI1ImeE/OqdarlQkMKctI0cPs+eTpc55cXvHidsfdOCkP6YoMaKUU3+SkAlWoC1uPZamx3Z5subg45/ryCr8/YA4TzWGm20+ET19gru7opkCfJH1qsjRyVQc+l8i6HofV97y6hoKvCvl0SEkNUapNJpVPcn2DzfGc9lIsHUIgJvma/bQ4qEbmcztbygH02o6CIEvOjpxXs7SBPXt+k997vUB9gattHW3b0batyLGVOr3CX+eahmG7ZXO65fTshO3pdhlXWmX2FYpS/qJMXQW5XrzYFDPBBw67PeM4Vb7egprIs6kHooxxjDEzh8ToI9e7A9d3e6YQSMbgkxjGfHzmF6lZGfr6N7PiQS0/Gw04dT14cM5X3n+PeZwwU6CdI/0c6EePu9nR3o5sA5yYhjaLwpLOUw2WUhmzuQhHPhYUcjbEispT5SUpKlZFa5W9sNoMJGck07aOprG6f/K6xcinlPB+IvhQa4al1kzLaGw5SUKqJJF9kd/CvAjXfI2/wX/v8wvYT3H1rUyc6TqZ4tc0raT8rdSMuqah6TqGzSC1i+qsF5+m6IlKd8ixXyr80bGGndY4coIYIn72zJNnUtkNISxcuEnq1UrtZVKdE0MmhMwcM/txxsdMYpm890qHg2PZvb+K7ILQEonOhEL1d3Fxwdd//ufprKMJmd5n+jnTT4lTn9mMgYeu5WE/0GdpBnFWpyGWumftYK7AiX4VZ6ik9nPOevZEGxaCcylJ047vDEtDi1xzzgnXiByHEMjINXg/cxgPilrvdQR3cRS0q/pVu6Yz2b+ssttYR0HwrXP0/UAyELRmMaQEVsvxWvEtYgxyr1n2vqxjzE37ArI0vWb92RgjTA62kcxqSKSYhd4xREyGFLN+QYxZXyeRkjRHxZSZQiQkUxFcaU5VMOBeYHX/q9jXdb2nw9IaR+ukdKN4H29dXPALX/8655stfZQMVTdH2inQzYHNFHloOx51G/osn6dMsyqmZtkcOVuSTDIsBkLKTyz3HOcMTdNgrWQRYgiEMJEJpFI0aIwMUkCyBkEzgTlnLi8vefr0KcYY7u7uhGtYwbGUQgUOl1WUz6vldstD/nj+c2+WqTf9sR962n4D1hFSZm5kooGJEesahmGQ5LezdO1AN3QMoWW8uao1qK9bVfAUzSheukE2OidIITLtZ5qu1J2iBj/gGonOknbKlUYQQ8anzNRmbu5G2q4nYPGaTyg9AfXa3nSRrIw/CWOkXrEfuvrEk5MT3n//K3z9K19jczeyjXCSMyc+0Lsd27bnUXaMtuU6Qo4Ja5qa3qzCVcOy4ruUHZLIRJSbXTnkJZqkNoykppH7AxxTUi0jURNR6KXmqdKI7fZ3nM0Xkv5rUHQ3Y1XmS7HzS/DLvfWQP84/yV9684Z+QattW7pO6vhIkRwtwzBgXSsNkjHSNAZIEoQZmQm/bjSBe34561AC6ohCvXdFSeUYISbafoNJBW1M+Glm03TqxCbmMl7OZEEUsPiYud0d6PoHZNuRTUM2saJPcg2vT++v10sOqyvNYWJGLh6c84tf/zrff/QOPLti6zPbnOi9Z+g97hB423Z46whBrtluSkCVFPmV+l05t1kaYvI9BCgjU95WTicr5CEhhmaeZy1Z0WSftWQUPcQQYqTXIH2cJnZ7GYl6e3fLW48fUWbTy+c9wkwVXXi9/P4RvsH/iP8sMH/Grn4xS5wi4evdnmwwrpEmmjCToqFtdNRy39MPQ0Xpy9lfy+UaWbGKwqRssCtDr38VYnWUXzKJkxi9J8dAoiX4SPDCVWsUAZMgWR7b9Z73ui226cRB5dUq9vh3y30pdchlD0rAsUZSGuDdx4+56LbkD57y6X/82wyzoFBNnDCHkc3B87jvmdqWu3hgPATa0xNtsi12VEuY1OaI7Bqllhauj5jA5MLfaqvTL6hYJBFo24ZpGklRishgGTxhnavoHUYCq9u7Hdc3t4QUub665r333tN+16T2IEIOyAS25v4WvbS+LLLbtmKng8qfdY0EPikSs+xN8HL2+2EQB7boilzCW7VrL716JiepVc/GHtlIY4S/VPRbxCg1ZC1jQxsOcySusoQxR+Ysgy5aH+hPTnBdr4Hs/Xzrq1YJwnOV2yLX0vchE8NMNjik1OHi/IIHtmf6lV/jg//w79H5iNPMxnx9w8V2y+PmnGgNL/LM0zHSPHCLvwCEXKRCd8mo76Mwawm0SjmkfC20ZTLcx9MPDSHOxBgwNtO0yp2ac82cFz0avSd4T4hC1bk/LIGVZCSkHCDXMQt68t/oN7wA/h3gX3jtDr8RQe37ns1mYNBxdV0ns2mbtqXrWpxrtNA2Lo051tBvN1hXKF5WEbRZLn25xZkl5XLvw2QRtK7paJ20QJGR99SRYCllfMw6wSMyx8gUpWN/N3kiFtu0q3TX/cT+MZq6XuvUkwi5okQ11EtYZ3l4ccE//Y//Oc5dx9ZnNlOkPXjsYWQ4zLxjOt5rNmzmCFPCareLKKOCvik4UPrRkn6VsoKkKSRnVXjSStjiUksawkLfk2QEn+aT620IIbAfR6Z5Zvae3d2dBAlFQdisUV+hnViLi3lZ3vT6G+CReZ0wfrGrbdtV97Gkgpxr5YCnyDxPHHYHxtHj50SKVAqfdQfx/VXQqYQMZkj6BUvnP0hq31WFtar3TbFSg0nqqdB/yHS2WWXXuEYmIllRFNXZWwNSr0jxA0cI8FphNlDRXgu0znFxesqf+RN/gjPj6H2imSN29uS7Hf1h5G3T8n6z4TRk8hS1DrHUcS3OkHwZjZvKRcp+xpSJCLk7zmA6RzLKN5iToChO0kaJWOleyXGVARADHmNkPAh1z+w9PnjGw6FS/cj3qNR0q/CiIA6vkl0ME7/Md/hffg7J+umvruvImkUKIeJcQ86SSp5nzzhOHPYjOQW6tqXvOhlo8Bp5gBXgAuQ6hERSquX+lQa10uhTSc0qeqP6oAYeip7kJFmdnJl9ANUdKcVqAu43R5lVVufoOo/kSRB1ZyxOs086Y4TGWDpjODx7RucDTfDgZ+I8Md/ewm7PRTK8azouoiHPqY7RhtKvv0JNj67BrNKWKrsWaIrsZrIzhCQE5U1j2I87fJzJNtN0dnX9S6lcSolpmpQgXUoqpnnCl3nmuWiXdVhcrvQV91Vld+SXvhSyO88zwQdIGWcaJW0X2Ykp4efANHmiz1UnVxEwRWuYRX3ccx8SZWhIXoYeVQRPuGXL+U55yVqV7OOyh1rvmpVmKiem2as9nAnrTNf9dSQrxY6r3lHdT8kErRB1sRWRNM/sr674xn/0GzCOEDzRz/h5Yh4PzDc3tNPMAyzvdBucT+rksvKRlkzo0aWVc6NAZh0x2zroHNlmmZ4Yg+jaFMSpNBGjI6VjCmLPSgbBJHyU6VbOiaN8c3MtTCkhLPXDKRKTlG2UzIIyuL5mDw09DV81D14tTLre6KAG7zXtLqlip+TDgoQI/6l0gyXmOTDPkRRAmPIW77kWNud7F2xgaVjIKyW6GHQhK9emIq05SzHJlyIxmazeexG8LIhviPiYiLnuCcvBL0pzdQ5WqdKXivVLqlQPUFYOVpMzzJ7Dixe0IdAE4THLYSYeDrDb8wDH2+3AaTQwBS1MNvo5gUqrJUhTGUNWUkYidOvuz+VgRB8kstFUXIlw1umpQm5cDLz3gXEaRTn6Ga8lE8VhKoGGRFP3FeRy1Iurr/NoeJpb/s18/kaB+6KWGFtFqrMMSHBOSOpTypW3bTrMzGMg+jJ9o9xv3eYSQJRVFGPF5PR+lPSjPsgqmrUOIGKMojQUuQJqcFaa72LOzDEy+0CIxYlAt3/tna5/XuShrrwcL2eWSSrL3zOkRDiMfPL9D3BzwIaoCnPCjyNpv2cTEg9Mw4XtYJYReNKbWbk9XjLy8nMx8iK7xUFN1pKtJeREQKi0BM33YuDJ1UGNZYwk6IhaL0Z9muRrHjVFGpSvddUwWI17+feyT8eyKz+9IPPv5OnHE7Kf0iqBTs5K3+d0QGMSyhyvTmrwCZPLeMU3qvK6qo+eC56sd7IqIFP1WtGrQkuTjurdIbOuiRekTLIC4zTjNVA+ktiVo/qyHJcLpOraYnOssavBIfLoHAL+bsflx5+C9xADOQnHo59G4mFPM82cJMNb/QYbE40CE0U+1jqSnI9kmLzIdVDZLSUWISehaZtnDoc947QnpkA2MkITk4nJ12A156wlKZ5xHCW4mrThpPYAiJPqlQKo1HeLfXqz7F7Cl0J2p0lGYKaYqo0zRphNQgj4EPCzNJEmmZFeoSJT9KiYRQVsxBYeO5iGZXJeXhypLO+R1WkqZ8gr6pdSrnKb04r3U4OukDK7w4HJe+Uh5hWBlTYer2qtCsp/BDJhKi1UKSXJACnjDwd2zy+Zbm4xIQg9Xk74GPBhxo8jjCNDTDweTmhiwuWCLxmV0xXWXN2ZY+HN6gdlpLnQNk50bk6M88TdfsfhsGN/2Esjl2YP08oWlbPhvcj5PIvzPvuZGD3eT1JeFTyT6vCsOuR+tuoluc0Gy46N+btvlKk3pvinaaLrA6bRaJJMipG26xUhteSUCSEREFqNxkJvjxVQnWajdsKwRPNVKNHmK+UALFtuXSGhjurxJ1GWKmSZonCWiQgS7YOPkTkE5hCkyeR1NYWv+bVcnqlYkMOsDLR+nJRIh5GPvvtd7DxjhfeJTCZMauTPHnBhWx64jidzEDTALFG2GAS9EGOqohTndDmg64Jt+VtiGkcMhrZpMV0vHKatUOssdVaymynnGvWMB3FQJWIsdWbCzJC0vmpZqxv3qo3T6x0JfPdL0sVfa7r0RjXa3CN1R+iEoiCF4M7QFVLwTJ1Uth67V32cFSsFRWmUWqUSWxiRW7Kcl5gj1uQaRCzRbzGMgihImWciJMM4TcyzJ6ZE46q2lOO9gh1qKb+pl1T8jEVZKnJU8Nwaasye8fqWD7/zPc7nCBFSMkRjmOeReDjQnwZOhg0Pu4EPwm5FwC//J/GVcgyK/lxQkVxUpcqiscqJaYg5SyQ/T1pz6pR0P4ER2pKgCBbkGqlbe9/IH4jBC/l0DNrFX8NddaXzYvjuL/3dBPyI9IoHfPHLe082HmyDda3wvpq0OIshQgqYVqjHcl5ngF6DWsifdJUg1xwH7vrEhFCh5RRqvWUIUisYi2Ff1UrmDMlIuUcIkf1hZPaelAcZRc1inJYruO+kVpOv5SDyeCF0X2QXRK6nux1Xn3zK4fKabbakaAlkgsn4AH4acdPEMAw82mxwu3GJIauDijqCpgIjLznOxVgrZR3GahAZsPMkzo+PFA4FeYqM4TUprYIN4XKd51nkd54Zx71Mm5pnvJ9xrmX2EWs7PUjLnrzyphbZzV8O2fUhkE2gbVo90wXJk0ZGqQmNWGdr1rUCQMUZLDqqfGSzuDqGklpRXWi0fTSv66EDMUelTDQE7zGY6niZGlSVulBIWUoYd/tRxrjnYm31P3P0E/eBgrVk10doeVIBHwwy6GK8ueP606c0hVovW0LOeJPwUZzBZhppwwkPu3PalHE5L9iHnsfiN2T9nVnJ7/JQdRa1Hr/o3DxNME/Mh4nr6ytSzji3pPNrAKf+w93djpx33O12zH7CJouPnmkWH0KAgomm7ZezVezb63wuYJdv+Ub+D/jPvEGm3uig3t3dYZsNTdeD0UhSUc2macA45qiF9MFjcqJ3lm5ojqOMevNY6QB77y+rKFGCJDGqjZMoMwrCUmrVnHOCMGmhe0X+sjh1MSR8k9kfZnb7A1EHCIjA3T/wK2G7t6HF4NsMTTZ0WFptAA2AjYm43/PB7/0+b0eH8ZCTJZrM7CPzuKc/7NlsBt47Oee7dy9orNbilQPMMv2iCBVUHVX/vV4ZcaRubm+Z55mhH0RxTxN931d0JCmq2iYHGcZx5HA4sNvtmIMIV0qBMM/EFCCKY7Upd6hGE+UCtE5ldWONoqzv5Wf81/iL8EbiiC9m7XY7rNsQlZaobRpMUqcxJ+YYSEGnTCUIrTuq786Fz0tXqY3GHBtadQEpdaFlU6w1ZEVDEkkHO0S89xoMaJ1liT7yUsdnrETzu8PINHs2Xe2HVlTJYJSqiZVzYgpqAQsghvBqOpV9q+fPZsO0O3D35Bnzi2upGUyWkA0+W+Y4Mc0H2vHAsN3w7oNT2he3NBTfxogYmFwDKJHdrDq0BC/FEVo1QDlHzuKEkxEicy3pjynRgtKdafpYjXwIMs/89vaWwyTGZJpHfJg4jHuGcQNI40NX4AxKgLw+82vjAuTMRTrjn+Af/UNK3U9mjdNME2VoQufaapxiioQgzQ2kSOPABzHKR3rrXoBpyj1YIgvqlJpqhIvsyAjZ7CMhe0nXIRPqpKRIEdT1+chUgu45Ru60dCYmaJ2E84W1QlovS51ruUD5ZjFHXK0gU3ZsNpiYaUrwFzNPP/yYb//WbzOQaUIk5MyEdB93CWY/044HupMT3u4v6O8uMSkeB5168RVwzxmImDLMZdG+kiQx4jhnYJ6magv9YcZPMz54Gq05TQlBx1R2jZE9vLq6Yj8dmP3EYdwxx4lxOjBOBzCG/WHm7OxiuRyAFYfHfdnNKfEgnX4pZDckIWO0jaPpW73A0gSqgFKGQGQOhhBidVCPJibVqGlx+xaMZMlqWrOmXsyC6oUZchKO1VS4fal+QpFbce8syaJNf5Hd7sA0e2Es0vKDQhP1Eupf9GhhbLh/xapzUkw0ChJZ4Pb5Cz753g/YYjAxEZLQYGENfYIpBNw0MviZE2PZILXiEjCa1Vur3rW5AivFSS26oDT2ocwSOSNlUToMKcyBH334IYfxwOnJSZ0KmpVWCmRIxscffcxud2AOMyFJQ1WIgpoeDjucs+z2M6enjeiG2pthEFivrCX4yCnx/XTDv5L+Lv/NN8jUGx3UkKQZwaUMTiqS+s2GxrXY7JDOLCHEzzFiskyn6Ztl/Jukp6XD9BjBKLfz2PNqap1QrrxnOUZSCNJ80rhq6H2YSVp8jaI48tKJjCOkyN1hz83twDQluq2rby2Zcksphj9Ko1RlbQi5bGhWgRQjb7IcxhefPOGH3/wdeh+xMRGSY0Q67bvUcJgnusOBYZ555+E5/U3AZSSFpihf1gO2VkNHKxspnK8HFI0KM4fDgXny7OyBy+eXHOaJU/FktEMxMY0TTeNIKXJ9fc3Tp0/Zj3tCmpnDxDjuud3dMtxtBLFxLf0w6HsWptZjXsn1mv1E8J7n+w/5Tf7qm0TqC1vzFNjt97imw+gEk5ii1iZJ2h0Wx6qUjdRO+3s1c69c99vqdRUHMQR1gi2CpniZ3FU6+5fc1fEZyMBh8tzc7bi53XO+3eiUKx0ZWuTQrlO7+fj9V69nrdTwuQxNKtmAzJNPPuV73/xdCUa0HAYgW0OXOyG73+/pT044MxcMKWFCxAQJ8oqSLH1POSGTWoojpKiIFnoh5QwLYZmfZ1KIjGYkx8xhtyPGyDAMyuspdZeNk+Bqtzvwve/9gKfPnynVXWI/3mEc3O1uaZoGHzzZWDYnZxpkJFWUlvv7XJb3nut55Dv2Z58mBbGhyYBtHe3QI0bnXmoP6U4OSWrByqrZl1fpEf3LMeZTnlf0kETNpevc4DApi+zmXDvWbb6/m6UpJXFze8Pt7TkPzk7YuI2UbLiF6mxp9zBVRqxew/3zlq1i4ClV57Kzlptnz/nB7/weZ0EuJMdIUEfGG8s4B8w4MowjbU5sjYAJJFsoretVwAqhesXKMVGsi9HGr9lLzWJOmTRHPvnoI5xzbDcb2lbMaoyRTuuDb293fOMb3+Bmd7fYLQPJJO7ubmlaQU/n2TMMJ8ToyckjvQbt6t4drxACN376UshuRrhQm0ZqFcso76QNysY24mgRhDEixtecSFmlBA+0/2PVj3EccMq7l1I4fbbE0MpDXZkoXnXdKvvzfGA6jMzzzKbbqK4t77P4BrV7XwfflCq4owoqa6BQo+mzO2d58eQJv/vNb/K2lvVJ+ZNhBrxpmILHzTNmPOB2d2xY+TXqVK+R3dVuvfS5ChUlUAcNeO+lJyBE/Dhzd3NL13ZwoghqkvIGay0heu7u7vjggw8kYxW8ZAMbi2lgv99zc3NDjInZZ4bhlBhmpvHA5CNnZw/hCNkvoIXQgv0RP/C/MG+mR/sMHtRGjUqkpCAthmzFcy81jVThMUsauXBz5hJpv0Zh3jPyUaOnSoCOjN+KUdLPNsts2KC1LDFoB+o957dwtc7zzO3djucvrjjdvC2bD0uNDBabbY14QJSvNQthcLnZZH18yljlx7159pwfffd7uAQuitGMWQR7NtBGmbrgvCDMLkcZF5hLA4++fpZu6IzsV+nIKx+uIFCSB5Y9S0m696csdT/T4XDPwRJkw7WWeZ64vr7mO9/5Dtc318zRy+saKUfY7W8Zbjc0XSfMB2FWov60OgyGInBZ711OicPdHS9evOCjjwyZf/GNAvdFrYQ0ajg9bDFnjNEie03xWNOQc8CYCKY0MWX6vsM1SplSnJsilyWoWjmv5TWlhEDqJq11eCRFbxA/PxPJypm4OBp5pXZkxSw1a7e3t9xsB/I7j4DKvkuZd7+kdfTKUqmRgrxS/cbomTUFMZRA8PLZc77zrW9xUR8qjQMhiePjY2ScZ/Jhj9nd0RhwJh8pxvv++1GKX19TmqTE0ApPpFyD9545e0GwfeTm8oqzs9OV7JfuVEcIM5eXl3z88cfc7u9qMX8ykWHo2d3dSlYlJVKC8wdvEcIEsyEly9Cf1L24f8ExBLz/fab8LwN//fMJ2E9xJZRTspHhEdlmKGo2C3pudCBByJGQMm9I7CviVH8CymtpUFzQVrPcu5IGLdYx5yxp+wI81Nda3jcbCFnmeO/u7jjsT+F0oLBAivzpc43R3r9ibp2QhaupyGSVlVL6pZeYpKZ62o9cX11yEhuyjlXMSh0UoqQyGx+w04S9u8XmgC1k5knq4FxJEb0mCM05E5KMbDXVJsneee81qM3M08zt7Y7z83PIYq8KKphyZpxmrq8vefbsGaMfpU+ABC7R9T273Q7XtEqBZEQv58g0jfiQOD19qLp6daazUCd5PzP732PK/wo/a9nNxuC6Ftc2oIFF1NpwkTNloElJm44XVqLqKxR8cF3PDzLuNy+6p9R5LhMrqQ5o1rhUqJdWgbIppXmqWxA5M2iTTxDAZ7/b8+B0c/zh9DXuezIJkUejnM6JTLYWYzPZZpLV988ZB4RpZn9zA/Rk4yQvlhMkw2xkwEupo55vb3BtEuYN/VzJiPZPBaxigYvySo+D0EWxagzMoPXkWTLMPjHPXhxUspZJSammTJeMTNPEs2fPACtc4iZho8Fli/cTd3d3jNNMStB2oofn2bM7TGyGDa7pqE2+K772aRqZJocz//AbZerNo06tLaplwTrNwsdYoHPxPwvUvUJOVd5KZFycnFcr07KJ+UgIyvtm7do3eieyNl+sg6ICfZdoPuWMD4KkffrkKT/37mNQxqpSdFzq9dbXUP9VojVdQvDe1EO1dQ3jzR2ffvAjLkKE7CSizkL2G0zGp8g0T9jDAbPb0yK32qgjunxYRVS1FrJQRC2nr9yA5cNmDQaC1lOOh4MqUTHwKWWMA2MNwQfu7oRXdn/YE4nKSWdwreMwHri5vabpeoZhqw09EZM9Mk+9UUFboy2COu73e25v77jePeU533ijSH1hq9S+lVolzbsVvtiShrYrxVVqQ0uHcV45pbkY0hq03K9GWmNbK2WRj2W01EplRRXWTuriPAiiOx4mDvuDjALV8iu7Cpqqs4yhpvpLPFgdARaZUAVqcsYZRxwn9jc3PMwdpds2Z5TEWursmjBjpwmz39GaTM0c65SdV52dtRNUzmLZ75K1kPpo/QqZWRufTk9PqyIthiblJIHm7S2Xl5fMcZapUyZhdKb3OB1wuxYfFwU4HvY4HwjR0Lc9uDLOT3c9yXS8aRrZj1fs+MHnl6+f4soYbKvNoRq0FseQso/3gsXCL5uLJbu3xEBDiQ4KB2q9nRXNr0+owIJBz0PNit2/3uXu55QJBKmzPIx1FkM9J/UaVs9eT8HIx9huLikDI06LTHmzmJQwPmKRdHzpPCZDsuqgxhk7j9jDDiHEWDvUpsSZmHuy+0qgraafFxQvp6y17FJHWvaiOvFJ+CalyeQgaFOOonur7LrahBKiZKumaZSAq5mYQ2K7OcU2DWt9EZOMCN7d3XJ98/RLIbvG2mXSnN7jkrUCcS4b10i2VR23Y6dqZfP0d2uZEbnPa0Ka6jTmAoIZ85L815Q3RfJXjn55u5yBxDxPTPMkDvFR8d0CSBT/R/K062h9+WdWm1H8JWOUeiqDTQL8oEFm8T6Dido34zHzBOMB17oKli08R+t9eeWdoLBT18eoM5bUjyJJBsbPnrQpYOLCRpMzhJg5jCN3dzsZYWvEQTUJOtfjfcDYEasNkZeXL7i9vabfeMYpME8HBmsxTmXXQNQmz9vbG65vPiHyO6/6AHV9hoO6RBmgzUt2FYnkvNBLKeRtstU6hGUzazdnOeQlSl/dzvVeGu2Qr0K3+msxdOW1XwXbZyNiJd1xmcNh5NnT5/g50DuL0YLg8rXEIpJkL4qoOKhGT5LVzyiHDvKcma5uuHnynLfsRhpAtBM+FQc1CqWROeyxd3d0TiPCldNpdDJGBulsXE0AKh9PHr64RGXvY0zEECunadv2VeBrMXjWhpRRlKQPnmwl9WwbQ297pmnkmmuapiMEmcwzTQesbXCuw7QI4mgKYijk8n6auLm5FcRkesrEb7xRpL6oJSTtmdK9Uxp5shbUgxom66oTWZuXcnHCsypGQSWLUig2VrBMqbKxpT16tff6JgBVbqtxy1m7VGHpnlaBTBJ5B6+E6fOMaVtxTu1SB1deXCWCpTNb31qvYU0gLk6ZeqFzxMwRaxPYsgfyPJ9k6IUPXo38nnbLUTQPS83goijvo3XmSG6L1qzTXbTWNChdne7WijYqE2JimiVav7u7Ixkl+rIZi4zhnKYZzJ0gvtmwP+wY7m6wriNheHB+jnV9NZxSsxbw08zd3S37XaAzv/QHE7af9FIyfplVvjL02qhqjEyHE+L84l6p67JmMtB7Uv3BYr/JS6JwtR9L24VZ0CKVf1ver6y1U0lBR1W2SczTzDROygfJgl6u3nN12fL+R3WzIqsFX5XHqM0JARsSHUbKz6xmRbS5UdD/QBs81s/YcaQ5McsUxLonK+HVw10yALlm9sQeFCelonNZHpM1iySDThYOahCAIKbE7EOt+8ehsgs2O9pW6tQPhwPjNJMz3N5dM1wL+pSyIbz1mM4acLa+foyJ8bDn8vKS66vxSyG71lqappHskxEm0ZgVLUb2tW1bkok0tvDdFrlVe1Vl1tS/GdV7RpHsdbapyEStY1XybrN6nTVgVh03Vv4GIp/OQIrSsCbNWBIw5AKu2SVAWF6hugqLXBnDETWgPifPARcznXWYQLUTUW1OIGo3v8fOM2aacaebOiY4Ld708v4l+qv7obKqYIWp5+vedzSY9LGem9IwGBQciDFyGEfGcSZb4WLPRLLL2K5jDl65mgMxZ2K85Ob2mtMMMcFh3Es/jK0WipAi+90dl5cvuLr8kMxvv1Gm3uygIsbDpIwERaZOkiJnhYtjddzE8UoSHRZi2aRTBljulyAvx1FMIWM2dSLCsqFFQEuuR2rvHNbEZbdXUdLyZHmBlBLz5Dns95z2J1LIjaQrARV8fYkk/8hZCvp719JgyHNkvtlzaG/Y9gPJe77/ww+5+ehTHrQDzSyfPadMyAlLxic5sHOQjk972NGeOpwaiRrBl+/GVOe0+jeqOKM6ypImafTegNBRSYDgY8baKE0OWpidQsZ7zzSN3O3vuLq6khGgTtBVl2Sqkp9njeCFTuL65jnZGDbbUzabEzE0bdaC6wxJalieP33Kxx/+kNuba+zNBX82/w8+S6S+mOWkYxy7pLejBkvl5ErnopSMWGe183MpTakOKiyFluqUYpY65cXwWnKOlWVCxkQ6oaTS1Gzbtkx+VS+WDWS3jpYo0UrOkn6+u73jwcnFYiaNqUjq+guy8n8WpDLTJOixNCFjRg8u02QY73aY3YFT20jTH0LNZrOoIeehsw3Ba03UYcZuOqGaK0isBitFRlexJzmvOm7L/ugOxlLrWkETMSLzPENKlZ7GYrRcSBqqbm9vmKZJU00SfNiUaNtGWAdSJHMgxsCnn36In2dOTs/Znj5g9iObxmJdQ0ER5xi5ev6CTz7+mPDpln+K/8lPUgL/wKtwkVprNHDIlJnY0hwiSBUpSbnRagJaoc85Mu6myG2RMVsDq0bHMTqt803aIOIaRXcUuXLO6lB7XWt4psrtUs7i55lpHKUsy2rdfn1vrbRXR6IE6KZ4hyozDkNnHDZCngPYTG8d0/Mr0u0dvcQoauhV3wGHMNO4huADbvak0YvsYpRGXM7/kqsr51M/RV6dqnzsQJXgtm5xNqQo3NyUch5jccYy6qSdUl4lNemJrDzTJie6ruVwGHE+gDHEmHj67BOcazg5fcCwOWGa9+L42U66w3Mih8izJ0959umn2MuHXwrZLfy5zlqyccRMZS4xGbCW7XbAT4nGRGm01mC0ZgjWo05XcuWM6MjKG66uaimzkIfLZEmfFrkFYReQUsRSDmjKrRMZMInGGJw1kBMheOZpZOidoKALZsnq6jCgpWPmCLhrMPJ6WdBSfKRNcPvxE+YX1wzZCfKqNloo3ZCRzcp2EGPABo/znejkAvqZXCkO1wMsJCgqzKNqkXIu3abFI8WkDFmAxGKnCt5anll6JGKIHHY7aZCcZUhFQl5DQIFASkZL2xL0hsNhj7WOmGC3u+Xi4oH4I3rN2UdePHvG00+fcHdpOcv/zBtl6jMd1IIEGSXoFyGEMpmhKEIZISkmu0mlhrK+yOoVS3RTMCBToyIBuwpiaeoGrqPuwi3Hij9yCbuW98j64SSqT4Q4cXd9w3uPzunbFmtKeizjiPVKAOFURHpNe9cRrvc8+9GH3H73Iz7uN2QfuX72nLuPPiHt9gwh4bLDKDRe0qRTjrQhEvxMmGbsNGNPhiNFeRy7KB3Fyu0QzjChrPDB0+WyPxZTCtMQ5CuEwKZpqpdehC1nGKeRUWtUJWWYIUKTMq6VSKmMnJvDzAc//AFfTUZoN1KWcYutIweNRGMk+Zlnn3zCi6efcnd7w0fXN/xV/hr/bd48vuyLXUtzBqjcJpn0hMtsBiFF75ypc+Z9SjUzcBSegkI7Brt6/fKVNWVd+PaASoBQkKhyDTkJe4BZvUzOiPEyCIo6e+ZRUtWNe0xjJdJHC29MPk53VTc1Sz1zYztcgE+//X1+uD+QfeTB5oTd5TXx+RW3T5+yxda0kwwdkFdKSA2S9xLN23miCQ0uKF+uU5VT+IDVaS7vL05Hqqlno/Cs0eYAm8GJCJITBJ8WXaPBWh13mYWT+XDYS5E/IsPGGSxJeX0DOnpbeBZzZJoPmIOOPOWxsIGsSnain7m5esHlsyd8cP1d/h6/wX+e/+OPLWE/6VUmKVkjYxw9Bq80WjlKhmUzdCKHydJ1nSAsKeFDXOlIWWoaEGhAmybIqmvlJ3Ip8VhkF4rcqqH3XlDN4iQs/kONs+rzUsKkRGOtpNfdgl6JZjMrbkejn9eClIPTNS2Dabj+0Se8mH5I9oE2G8I4ky6vuP7gI05zi1ManvKRy2kU2Z2x04gZO1x0uFim8q0/YWGXWJ9p+X2lgE5i6I06oEV2QxaWFB88kIUpw8geWmsJweOcIYbI7e0t4zhinKlUijZZfOiYfZQx2EY6/QHmecKN+xpMYTKH/a3UCNpGnJh5ZH93w4e3v8//l//9l0J2vfdSO9xIkzUI4p2inP/GWZpNT2sTw0Yc7uIQ3c+GlvtkpJBDf1nQULHZOS8A01pVWyPgUE4ZP80VsDH1NVflVSmRVjXQLkPrSnaoZFXfsFaBl1BRWvJu5uCvOITn7F5c469v8Z884/KDDxmwWGQcagmsMhCVinCeJ+zU0M4e4z0uZe3NYbnmoitfqqEu9keD1pTJsbb41VbRrMhy5eUuTjCCnBZZfPHiBcF7ULlNJkPMtN4L1zHFx8pgGp49e0YIidOzc6bDgWkc2e/3HA4jKWYeXLyFH/fsbi754Po7fIN/m/8c/6vXbu1nOqigdC/aBWcUPYkpEYvSzOC6nr5vJRqPJdrQiMgggqWzmcvva8ya9bH6nKN0U0769HJTllo7Spp8uTeyXRlBHihFxAZH5mSzYWg7uqbBWbkxMRlQYdcqEYnwNaXfWcfZyZYfPPkml3d72mzosiEcDpj9SJslqi8TZtcTHgoBb5g9vp1w04zxLU0WMCKKhGmly7GRT5Stk0OYYtHAxdAU2hOtRMvUWeVCjbEmZs815RZCwCEUXeIvCQvD7HUmchYal91OiHz7Trr5rc2EMHF9fYtzLdZYKYa+uWZ3d8d+t6OdLvhPmn/q84jUT30tlDi6tyXKy5mcIilEkvV0zQnOQNcYhr6hcZaxFuwv9+J+W0gGea1i+q1OOCnyWyLr1bLWSDZBDbxZvW5d+ntJUohR7NuOTd9jjAaEOtLTEldXtHov7XJ11jDg+MF3v8PVJ0/w+5GLfkucRtrDjPGBPlqavOrE18uJ6Pxs7Spt5hnje1yWsxhBh1XIHpSu7gVBFee0BvBlUEde1L30qOj4zbK/amnKeSipuRACO43mkxEEVbIciTlEWu9pUhYUKkSur26wRibZtE1PCjPeOPb7A94H2lZGzs7jyDQeeDYafp1f+4MJ2094FYJx1wZwgaBlUylGckhEI/qs7VoaY9luelpnFYmKR7ILCxQgGAuQpQRJXDVlOShCrYpHaoAFOnBWgt4Y4rHsVsRTu+CTlvnmiDPQtzIOu7WRnEMNykv9K6syBNAGkygCE42laRv2L654/uEn3D2/YsiOOHu4ucVMM2024rjIYVxk11DJ4Z33NN5j5kCjshRz6Y/QBii1I1LniZ7rBZypZkwDK6OG3hlDcrYGFDJBp9T+O+GOdQ0pJcZxlNStsYrgCtI6Tp6mnYkaOIUQefbsEkMjwzpCZHd7y2F34Pb2Fu8Dfb/l5OSEw90t+7sbnhzyl0J2o3K6WtfgjLD8gJanREEpc/L0XUNjE61ztM69tsN+/ZtQ0WkKbF7vURl7Yo3BxyQ23AqKTSn90HtcXITyrbxmipEQEo07ZehaiEHqLl+6kuXaYnku0usSjaFzDQ2OOM48/fQJV58+4+bDp8TbHfb6Dg4TTVTHstgLVbylzjTrOcg+whyxMWKzExq+jAJuStHlGkwjQ2jSSudaq30XerRNFtQ+x4SxTtBi5LXKOFTZS8nAWGOIMXK33wl3apAmqWQSxhp2uwOu6WhaSauYlIkJXrx4IYDBODIeRq5vrtjv9kzTTONa/uQ/+KcxZKKf6acH/Bn++TfK1OdyULOm842O0rTOVY7CpJxahkTrLF3r6DAqhKV/U+5ordUwL70DpigopFPNrIp2F2HSzj3WxLuvEexcFIylbRwPtxseXTxku9kytAaDENMLt2u5pgXNLcirD4GbuwN3VzdM17e4mNmYBhcjm5xpraPVVFWJ+EpUIeP+BLFLIWC9x4ZIk7MiVXpislAGF7J+V2bC61w/AZ80Glo2Q/alIBzqkC2cmFAaI8TBVU7OFKVrOgfIstfMM+046fuKM3dzc8vz58+JoXS9i8J//uySs/MHbDcnEGEaD4y7HX4cOYQNPzIrGOVnuGpKLoqjZUtOTjnlUgyE4GicoW9ahs6xHQZN86w8NUx1wkAl1Sy3IKvlKipT+E2X2L84qtYK9Upho5DXX2q1YQFLQBTEpu95cP6ARw/fYtMPpDST8woBr+6x1sgao4pPPn+IgZgi10+ecfXpM9J+wjR32BQ5yTKcoHGOQmCe65lBlGVeBmIQEzYmQavKZ89okJdJVlCOdYOZOAkSzadyD9YoKQtd1nJe12dpqR2LUSZ/hejJVrMPCciWaRKj2DSitGNIvHhxiTEW7wN+DpxsNxjTcnt7S05wdn7BZtjg/cR8OLA5NPxj+R/5aYjij70K56ufZzCOaHWOdhaqNNmcyNANbLqO021PowHY/dpn0LpiRSuLPhbZXb6S8vLCEliV0i1nDCZlofmr9WpQlbr+u8hi17ZcqNxuhw0mTYSoZy9naRItPnRRaKtMQC7UQLlhd3XF5SdPuP70OdvsMCHRTjODtdWhzJQqx1w/b+1PEKZ4lV0x8MU1KFRHGKMpdKkbzMjoYxkz25LyCjVGzxniYBpTOtULHCKvLnpfzndMkXEqDqqre25yUtl1tI2k+IOPmKtrnHVM08zhMNK3HSEkbm/vAMODB2/RWBmmMR72DF8S2S2BlXUzjbFE05Q/aKmf6N7N0NE3hu3Q4axZye26bU/kwGgNXNlfpz0FsofiUBV9W57t1DktOmrxTIuyraGaBgrQtS1nZwPvvP2Yd99+zKYV/yVUWX/FMkV8hUEixsycPF22pHnm+skzPvneD9h99Bw7eobJMxhLa131D4qlqF9LhC/nLQRtqqJ+hhgjfpZ65dBEkVtApiRCjFKSWdDlvJLblJIwsSAIacpZ6bBUb6sNQ3ttxnHCx4CJjiguKsZCGieGra++ATExzQKYeB+YZ89htyeRmCZPzrDdnJCiJ/iJeRoZ5zsCz94oU5/LQQURvkKQ33Rt3US0ViHrB990LSd9w8mmo2sdwWv0WWtEc6lUWky+MVVplLoQEbxSd6HOqRbr2ywj/3JcOjeLwLDC+rN2sQ9Dz1fe/wqP33rEyWaLMxHiDNlis0TrUd0QV4y8Oqfz3Y6bj58yHg742eNCojUJi5Y1FGcWcUzL6xiMjHZEjHhOwhXrYsSlXFqx5FMHGUGGsTQ502iqnbwgcsvM96wGXH5vrVXlmbXeqwjaEhBUhVmcVJMJOZKTzkI3UuPbulIUYYXyJGZur2+5ub7m8sVz7m53XF/f8tWvfo3Hj96mcx3zdGDa7QjzzGW85K+Y/wB4M7fZF7HK5zU2kL3HmQZrqem6nKWxzFnD0LecbTrOTzY00kmlr6IbaFZoT61fSjiVtQVoWSH/lOhcjbyiCj7MMmkspaUOuxjr+gMY47h48ICvvP8+77/zLn3TEVOWFGWWyW119rO+t6OkTVWJTR4/Bna3d4RpxoRIjDMuZ5q20wk994y6KnNt9KTW4OaMVSez1D5lMjlEfAhgLK5J2K6vRifGhPdRa5IiLhWVvP7YthJuL8jfOv2kAVqKeB0Jma2VeehAjomDncjZ0LRSAxfjkuq+u72j6y7ZH3ZKIzPStT3vv/813nn8Dn48MO53PDpk/nz65Z+A5P3hV0xSWmGsIxuLaXtNYyZQQ5hiYNO3XJz2nGw6AQPqHmoDntFADSgeYM0o6HuVGruYI0nz67VK1FpcSX2XzFAJ9GoPQaqRVdFJ56dnvP/ee3zl/a+w6QaiTxgiJmrNsriHFBJvQXjkp2wtyQfGaWbnEtfPL7m7vuFwt8NGS4thMJbGipyvwQDU+c6a5ZM6RNVoWpqwdoLn2TN76b6PbasTkIQ/2ofIPHn63mrKM9UUKLCaNmTxs1f+SK39NoYYZXRpRuR4rwiq0/R+6fC2zpMyQilmDSGI3SkTfIa+5+72mqCUQH2/IWd4+OCcMM/MhwOP9/Bf+hLIbpFbrCMiPQu1v6PITsqcbTacbBo2XYOzgtQtrr2s2qyKegrV5ql+UH8iViBLtYk6W9YK4LNolOJMvuxuOmM5OzvjK++/zS9+/eu8//gtsh+Z0oJsF5DtCH3Vn61eT0zSdNl2mSnBzfNLLj99Rry8ZUjgjMO5ojvNkb8jL1quUj2gFCEGKS3JEgymrIw94yTlHs7SukYpt5yW+i0TzArxftnZIssgTCcZhPFGKbvKAJmMISkDUYyBmBpxUJUSy2SvXMmKPs+erGWZs45iHrqWyc9Y42i7nsYJD+40HpgOB57PP+Kb5v/Kv8hfeK1MfaaDekTRkBLTNNX6MJOlJm4OgeBnSBu2m56vvHPOtnU0LkGWaRolYqk6bl3WoamiYgilm28dmQsChbE4p9cTozqoq5epjxfJFK5cw2Y78JWvvc+cIof9jsZIerR1LZ1rpd4uRXyKlETttB/Z395y++KSzsM7P/dVXnzyhNvnl9js6WwnjTUlmstr0dIGkuKkiqciyGwUZ5XsNLpOzOMkRt6al2g6QJCi6AMpUr9qE1qGaZrZ7/eKprqaGo3RE6PUNO33B253d4x+xkZL1AjURmmXODAxN8JnlmLG7Rpyzux3B66uLun6jmnyNK7j5GSLs5ah6bi5viJ4mSHc7iP/YB4/S6S+kFVTIHhiBoejqY6mqKwQPK2zPDjbcnG24XTosCatSs0VUU+G2r9skNKIe0iV+K8yslNMuiBdjXL/NYqYHJH0G6SG09y7eGPoupa3336bd999jxCE91eMmDQ/eYSFIWQtELEWp2hAmGfG3Y67F1ewm+hPNkz7A9M8M5lA37SUmpSMpETRACiTF45gW5SZfgWvZOeSdQg5EibPQafqNE1Dd9HJpCNraz1ujCzz4s3SRSvlV1J3NY6jNgZpes5ZUtIGC2PxIXC33zPrOcnIuTLWErxnNOCCfCjvA8ZIKn8YBoau4/bmGh8yzjWcn59zenfG2ekJN5dX7G5v+Pb0Cf8b+z/kr/G//ekI5I+xMmJ45xBI1rNpe6lbt45oRZ+GOHO23XJ22rPpHE0DMXkJ/zNVly6o1Mr8r0pPjP5/1og2Q72XoKlCra1fSqFedcWLrfjKV7/KO+++y3Z7ynSYcaprnZHhKVHLtgo4IQituJkW8PPE5ZOnXPnI1dNnTN5D45hiqOcpW0M0YMs16+uVKdvGpiPZNTFgYoDUVOqynBLjNOF9wNmG7eaU8TDRtC0lWzfPU2XPqFRdlL6TJfBHgyZjWdKtikjHKPKdsqRqc9bMlZajmFJrjdT8Hw4T4zgz9D1D33NzfU3TdTRNR9O0hCA2uDjuvx8+5n/3JZBduQ+ZoMhf33TahCdcvlIGkjnbbNn00LiMM5GYJgF1tARIuSoQBaXOaC7ZwVJCp9Z+VXucskyQslaYerLy3LrWCgqec31skRiLADNffec9/tgf/UUeng64nGjaBlIm+1m67FnKY3Iy1Q5YY7Q5LhPnietnzzkYy4fXO3bPrwk+6seQRlwJ+HLNDse8MHNk65TKSYO9FAV8KnWiiOM+pyi6fJxrL0mMke12SzcM0ijmJUCy1pDRyYVZzldOUXmpha/VFX/OuBrkShPUxOFwoJxTlCLRKPdsClK64WMgedERPiQOo/gjfd/SdR1DN0AS0MQ5J5mgMDPNDRN/+o0y9Rk0Uw1d35ORyC5GpI4hZExjaGyjRkXIicmJ02GgtxZnwRlorGVoe0Fdspj+bIxsfj3vmUjAyYBCDGUcniPhxWA6SSFa7U6WVOdq0lGtZyohjsbVOjVoCp673R3ZWxoiLkU653Bth2ukNjYpz16aE36aCOMMc+SP/vKvknPm0duPOLy4xuxHLn/4IdEYIoK4in7NCxJlMuAwJmJMo9FfFCUfy8x7OVTGSBPE7AMlCnS21Rm6MqYs5oh1IBMCojhR6ueUyVrZGqkRUeSgNEtYC1OQkXohehrb6WSOVRlCjMSIclOCMYGnz19wMgx0bUvTNmxPzqTz3zoxFBjCJJORfPC8F5/x381/E/iX3ihWX8xSttlsyBFsjthuwERB9sQ5EwFsm5auabA240wiJQ9ZENKlH8Qq/10xhwW7WfHqKSqCBgiFxqsYuIymV0yq4fdRPK+pFwd6PXahCJvAzoHGQlv4eI0U9JeaNoygUDe7HdP+wEm/4eLtd3n7T73Fh9/5AR999weE6xs4zGSnZ1ERykxWVHJ5rWRErjOIss5oN3lUkm2pZTzME9Nh0uBSXnOz3QpVkgUfwwJBZFGIUTwhnenssQ5CNDIApBohyIhsTrPwpMYUhO6MBR0sJUiCGihKYBtud3um2TP3LYfpwOlW+CRNFnSg6zoO44FpmriIn/Lnzf8TvgQOKjg08yzGEEPb98KyEWxFQNqulbHJZKzJ5OxFv+SIyaWuTIKXBQJKLKOUFsS/lg8hmRfjBFmyNdWTadt2NbWq1LgtgZrFMjSWs+0GR8ZPB6bcMjQLo4W14qQWdKdwui7TyNKiTx495ld/6Zd58clTnn7wEXcfP8HsR6mxtxLcJS3zSkllTCc9FaaJBJXSLGnmRLDoTLSGOQQO+wNREfeu69hstzStZAlnRYnEwMflxMbIHAKTF9ltGsmlCb+v9AzklBnHkdvbW65vrqpjlbNcU1JEO4ZA0CBB2D8aJh9Jearn7UQbjwxZ+xESIcyEGHiYnvDnzV/mZy27xjTEKM13ubFgHE1nsdOspSFGnDoLjYGW0jkv2rrYa2M1yFfwp+Yms3bV2wLQlHS06NiUM9aBc9qIbbQfQ5vXSuBWNDegTnFiux3I2i8SsqPpHZu2A2N0WEMqCW5pVNX3R/W8Kh6yj7iu45f/gX+AJhnGFzd8/K1v8/Tb35NBJ/q+CXSAgchEPWYFEMzFN1DHPSVMFHuVQmQcR2JMNLbh6upK6JyMIebMMAwcDqNmoBTcSgnrRDeGOciIVZME1ay6GS1tSezubnny5AlPnz1VlFoHACEy2toO72WM+jx7soHGteqIBryfSGmQKYAIqU6jmY8ycv6t/C7/DH/2jTL1Rge10B45I9RCYRRnpG1bjAHnlPfMScRJzkdE4ks6aHFE5UMutSYl4W/1hsnvCsxapUi7LLXbUr/WTUCLxNU3r5HA/nDg2YvnbCyYoaUzGZcDY5SuZdc6sIaQs5DkZsN0GMk+MPQ92Rn6s1Peeu9dzpuB82z4v/3r/wdMFNi98OJRjTyaIlNnpXxWJXbOSesQrTqRVhCi/d0OP0tt6FYNvGsEUQ3ei0ORkiJTxZnMSuURqvIsRrs4niEkbq5vuLm9q3+Tule5FykBIYkyTHqHbEM6eGyW1GFHZggB0xmathHjiJERqlkMxUcE/pa55p98o8h9QctIs4KwTcnxt1YQNue05ka0hDTEaVhUCuYlYmeRYWCR7LLPgpZbljIVeZwuK2mdxrja4ds0DdZbTRHqo9eglCoL7z3j4cBuf8e2MbiuweIJJhOsoXEdprE0fYtMrBG0JmVB5OdxYthsaU+3nL37iF88OeFrP//z9IeJv/n/+HcXRcjS2BdXl1Ci5JKay1kojYil60men9TAzt4TQ8Td3DAMA2YcabtOaNbmWeQxBskeFAwjCVH0PE+gKAIqS1WuU2Q3Hri9vWOcp8rTWp1YdQhyKJ2owpvqnCHEUiMf2ZCJgyAd1gphuCHhdKDDLY7fNA/4b/2hBe8Pv4zWQmILk4HoYuccjRMnICuSjf7NWmR/c6Qkvu9nM9c/FuetDgIoqVgNrgTFbnAFf9Wu6JI6lAtdZFf8iIAPjtu7O677DkfGbbfQJDbIdDbrLJ1tBAwwJXMmI5kdjnmemaaJnDK2a3nw3mMePnrE+++9xyff+i4f/NZvI9CYfg5VvskUdphFduVDr2RXy6BKEFUD8ySo9OFwwFrLOI606qzOWutnjJU9V6c+JTmjRXZr/kydzJTEnXn27JJPPv2Uu91OdW2uaF9h/UgpCo9kknpu9Y2JwRCj9CNsNyfS+W0tbdPQtS193zN0HWM78FtfBtk1BVa0VY4wUgqXbMJmIyVCWTrYBcSScghyWigqWQZqGA0nanGFipwpAGuRf+cwZFyr5H9G/QxjZbKV9wU0XZ6vByKEyOWLF0wPz5lNxqWWxnS0vaMzDuesNDwnaaqzSkkmGWSpeY0hYDGcn58yjzPbi3Pee+sxeT8T7nZc/egjSAoKqGNdy28U1BBqvcK7S20otYo8pySlgKX5OvpINInoPX3fVwaIlDP73Q7bOJqmJcUgX1aCv2kOUntNWiby6Zjv0mj54Ucf8sEPf8Dd7k5eU8+8mCfRO+P+QIhRRt1bSI2hkDdZL3tzuj3Re6ulDTnTtx3np2cczna05skbRepz1aAaa6QjTi+0OJLWSnF520hX9wp8qWDmmr6gYFELB+pxAfK6axJDdUCtEW41W8Z2FYG0lvU6svOmGFAYp5kXLy557+IcHwzWKLIaArMPSv2hIyZVcUyHidY6Li7Oya3Dbnreevcd3nvwFsMhYFuHSbEagVSMZbkSFbjCA1Q4Ck1J71YFJUrPh1Bh++5wAGDYbMigEYnHWLvUkWZ1PleCtd7HhVsu8fzFc549eyYNIlnRgFSwE3lMCJkQvTZvWawzGp1mLYzWn1PCGUPXtmyalqHv6doWP01kOma+8nlE6qe/Voe+NO2U+tymabQeJtfDBtS5yXldK5kVDV8FPiV4quTkoIhsUX6mZhacc7jSaIKhaVvspJRk5GW04+og5Azz7Lnb7bi5uWHbWto84PAYRXEsI7Z1DHEAZwkpiUOTLfM8S7qra6FrMJuetx8+pHsf0tMrTOskr1+CquLwrfathJEFKSsNiYVbLyUZhBHTQi4dvET2bduKYVcJk2YfIXROMUggFG1F/otiLdeyIPoSoT979pQnT58IbZC0iasc53quCqF/SBp06jS2mKR5yDmjzmrSgCTTuYa+a+nblq3b8M6XUHZB5couDqpxeWFFoBhio4wqpd7sSLPKyx79bv1e5U1M7Uh3TnVudVDl3Pjga3Bi1lkrFeAQI5dXV3TW4HJicBaiBIptairHq7EsvKzGaj21kISnlAQE6VvcpufxOxfE8we8+OFHNF2L9UmPoWqwrCVh1fOAGk4WvZulhjqnRAwy4U/Qn5nZeymjirHW1ZXzP88zpckxJWkyTdloE5tnnkV2xc5x7PTGyNNnT3ny5IkOUWkpslsCsaxk/iFKw5a0VZhiQghRbF4Inhhaog9E7zFq6Id+4Kw7+3LIbpHbtSVWuSnDQQqNk9PSDmulQ798XkDBvFxH44LezZKdWp2PQtNUav0x6wBFHuOaRkeR1lfSvy7Zl8sXV1w9uqHhXPwNvTbrpJ5VUL9ISGnR84gDZTP4KKUa29NTstnRbXpOH5xDK+V7TdNgQmmOpspAnVBYMdRy5gvjiZE+n9kzx8hkkgAC80yYhXmHKABJAap88EzTRJsk0okKDERtcp/9JGwHq1kCMlBiZp4ndrtbnr94xtX1FSkXdp9Y984gNtJ76T/wKUkGOonfUI6im6RJNYZI8EKZeHV5SYqRvm3phpYdby4J/Pw8qKwUpnr+xgoHX5iXur2KmFYFm2uxuDwpa9STkSpNdSRBagS1Rq0YbGut1m5IWrk6AG2DiwH8wq13/L6AEWPmQ+LFiyvcr/yidgwLtG6skbS4QvgRGLYDu92ebDKuaxkenGFPB0zX0A4dyWS+/8EPqmBZNdqlWDuDorsrmqdiRGOUCDJmaYzS9GXOCe9nmeCgn2FUBMoon97sZ5xrJK2j9F7ez4xehE4UtqChMlkqikLNkd//9rf48OMPubm9oW0dy1hELROIAR+RguiM0FC4IE57kvdyGHgg041SCDTGcH56xtnJCWfbE9I4c5Hf4p9Nv/JZIvWFLLkPZeyryrEa4KZpaduovLumys1CzbE4b7Vxx6ATylZOaQlECuKFKFprlUjdJHFUWUaqOifyTNK6Pz3MdR66ni3vPVfXN/Rtw6Zv2JiMI0CKJB+kzrIxdLserBW6HGtoXcscPG3X0J5siM4w50h/sqELmd//xseiLJM03Mgp1M+pAaCped0VZ2SS+iWXBL3zRMYwE1KQ9LufxQjptSvORIi+dtlbK1OfQvCEYPF+Fgd1DkiHqdQ/y1S0mRhbpmnk+z/4Hh/88AekFHGNIWdbfbCs+iVEmdgzh0hpNsRIcBu1GS6dB1HS80ycZ4auY9tvONls+dX+If9C+tlP4ynLOcEuK+WecTiXya2c2aNpOagzo3pgzeYASRqtKnaDKNdVdqe0eRpMJVu3btH5VoW0bVvGeSLndMS/aEy9CnKOPHt+iYkRmxNnmw4aiyURnBNe1KbBtg7XtRjbUNifi+63bcP24hx3upGU5XaL94kPfvABXdNiw6x1efJ5InKfzX3ZVaS0yK5VbuHRB/ZhJpPYHfaMhxGDZeh7gg8kEjGLIZ/mUGujQ/R4PxFTZJqkNCSEICViWTICUflXvZ8Zx5FPn3zC8xfPpPawXFrO9UvojSKT91V2Mxmc2JAULY2dOewPNNnS4Lhyzxnv9jTOsel7fqV7wD//JZDdyl2MAi9qB5umxSSjCLTeq4JyGqEmc85gnKnBT03EV+Ne36UG0EDlSpfmP1M5PAsYAUvjVC5j8FYvmbM4Z5c3d3zw8afC9960te5zs+1obSOlhc5gjNRvgiCCjXKZxiS1pt3JFrvp6fqe4D13z1/wvd//ffq8CmIA9LtFwb8ynpwlcMkkHJY4zYw5sTOBqYGQPPvdjhACXdvRuk73wmtnfpKBJNr0GONMzoEQJ1LypOjJKdP3A4PWrKYUORwOXJrMJ598xH5/h7HCEx60pMQYR2m4KWUzIUqtPMaQspRxFprLefbs9yOtbaRBcgp853e/xWm3IUwzMTVc8+CNMvX5aKaSOpOriD7mTMbiGiuoRoylzEQctDreajWdB3VuzUJFX2J6QRu1VspkmfmqSB0mawRkairVNQ7bOvBWhIl1bHQs0AmYfWA/zZwNHca1NMbRtQ1DtjRdW6lr+mHg2dNnxBDoh4H24oTRJDY5M9/t+eijZ/z7f/n/BZOXWbZSjKfKMokTbW1Fd3PSSUZZip47DHme2d1NXOZZG6gyLy4vORxGrHW8ZR4yHUau06Wgu8V5cI7tdgMEYhoZxzvuDiNCpG9pjdAmxRTY7W/ZH264ubni9vaS7bYn53Mx0FFSSQX9jTHL3N1pllSfdbXsIUaZtOQwXF9d8+Ak8smPfsh4fcf59gwDDE1H7Df8oO/418yvfsbwsi9mlWYboKaCY0y4psU6Qf2j91jbaG2cIG4ZUVilzCQXtC7ZlVHXVRSlWeQuJiHuFooUeW9perN1brN1DpuslhKwKlVZVjaO292Bxl3z7ltvwbkgOAakoCc7Eonb3U7qoxR5NMayGTZszk5x24E5Rlpj2T2/4uOPnvAbf+s/JPkgxrQgOIoitwaoPfpL6j8nQdx7YwmHkcv5lmd5gs6RSdzeXGsDndbtTRMhCIIaY1QEQ4x8jP7/x9y/9VqSJXl+2M/WWu6+L+cSEXmpqq6u6utwMJrhUKCGEIURRAEkhqL0wg8gCNCTBEEQ9KyvoAd+BD7pSdSDIAgERsIIlERxpKGgGbKnu2d6uroqK+8Z13POvrj7Wsv0YLbc94nMjuprVXgiMiMiz9lnb3dbdvnb3/5GyRPTpJzPtrUMdcRMBoKYRt7xeOA8HvjpT3/C8fjAZuh4cnvDNE+WVBd/Pmq/n3NlnBsnMJIpyzYmLcL5BK9fvobrimRlPk2kIpwPB6II9933+E/41/mf/5Vb4p//agmRgSe2iGAzGPpOhTobGcOSfjEIR5Wui9biNOhweT0LdkZt8L9ZksLmM3OxQjR7q7JW51WKFfFWfrURUszsvwOQxbU9X76+J8bA9z76gE3qOY+TtXAdWazAZr9l2O7otzuC2Ha7EAP9fst2t4cgPL255cXnX/LpH/wRr778mo+6ja139qTENuFAUnxDUEuUV+UTVRgkcD4ceX448U0diZueUmfOxyPTNPsmLWUcR2LxaWmPARZ/hTxP1JrJswV7mElRli5SnyLTdObFixNffvUpn372Mw6HO672W4QPORwPHqeWqGe+tyqzB3rxYatIJIgyUxnPyv3rOzqCibvnyj/9L/8JMivzeWTiGf8Jf/NXbrvNblt7f5pm+m4geds9nw1tDjHQNnmZrD1c39xwOM2czpfrdHkrOXUVXZW1g0KmVLNbUaATZslU52ADy2Det14O+4uqkXPJ/OyLr7i7v+frD57y2z/6IbebjpJ7hr6j6zpSP9CnRA0OoJW1m1ZLtQQ4RcJcud7s+OyPf8of/7Pf4+H5K7bdZqHCLduw1JcJrS+z5ERWSAodgVdv7njdZd7ECrue0+lgyw9yZqrQ7wfTHR1P5DwjItw+2XE8PjCNIzEEDscHVBIpwpMn13SbLZthyzBsyPPE4eGeL7/4lM+/+IzNECgls9v2hA+fMc+ZcbRZgTwXo/2IA3tVKUVt3sLjhQ0QFrLC3WsrVmV/TbcL/MHv/R4bOuo0U18P3PDRO23qF3JQzQE4p6m1zZc2hK8ODCer6GNDRteHr2ByCVItWXPneeE+oVXQrIkrqsxlRmoTna2UUI3L55VSyRdcKFiwgEdvQEArTLNxMatgAT4G6CNogm49WDPQ7/bEEOmS8b1Chq0m/uS/+kO++qM/4fTp1/RFaVuGW+ItKkiFReapSb20r6lKFzsejicexpE7JqTrmacz0zSSSyZibbLj6UA9rojc/uqKaTxx6CJdl+hiQkLg+npH328YBvulJXN395pPPnnF3d0ruiTkPLHdmvzPNE0cT2fqWBxRsQM/z5m8DJerzWIJhoJlZazKw5t7uhoo81e8efGKXjrqlGHKkAux7gj88J0G98u61grawQqXPaIPpJgICNNsMh0SjTDentfyxNZC/VEx1a5mddpkHLAENdfZBJEVxFvMNQSy220ueeGiNVu5DFoi1lsoCuM08+r1HT/+wYeEZM89hsjOC5YpT4b+a+XlN8+Z5pltvCJ2HYFATyLfnfjDf/ETPv39f8nxi+dsVMkC2R1jdU5YqI6ltc/dQF0sae8l8uZw4Jgy55ARjUznE3nK1LmQK8x5MuRvXqknV1dXyxaiGISr/Y7Y7+i6QL+5ph8Gdru9aXmWzIuXz/mDP/wK1UItZ0qZGTY9sOc8Js7n0ZZHyNrhmebZpaXMZkN0rle1zzeNE6fTiSEmogrkyr/4/X+OjgXJlauD8nf1xV+1Gf6FrrVg8YTLuyMxJeih5NmCRPDVEFUIIYEqHzz7gMNx4s3diYbR+EtdXBfedylSC7lmsvtcS/bUtpv6+ZlrMV++JKlv+Vsv2LLCac7cH848f3XHs/33KHWCklEfeCtVOc0j/Wlkt88MfU/d9IQUiSFChTjD3eff8Cf/1R/ws9/7QzaTUvPILA0QuLBdhLAIjLLCyliS30vkxcM9Y18osZKnkfPxQJ5mai4eI2xi/+izFm1dcc6Z6Xym5Im+69jfPuP29sqFynt2uysEW+/65Zdf8POf/xQRNcRbZ/ohIGFL3yeOxxPjNKNalg7KnDNzqVS1hRftGamClkJWU885PDxArpR+4icv38BpJlR4dk78PX23nuQv9/IHoADOAUWoc7Z10xRKVWKFIB3jNLHdbGzt69hWkoZHtrVEeG+vNsqWPSezSxsgs3Z5aX0BtbkSW3Xaurhut+7sFGWaraP24s09tVae3Nyw659yHkeyKznEGNk/u6XbbFFXUClVEQlsdjtLdnOFsfDJ7/8rfv4Hf8QXf/QTrkjoXJm9a2x0wEaJFPNH7bNFL0y9M9QHuLt7zcOgHIfAPJ94ONxTZrefYPJ70xyXVdBtIUyphv7f3yuf/OwnfPz9H/KjH/8Wm/2eEKN1oqpyJvP89MCXX37G6fRAlwZUKzHCZtORUluHnJjizDjmxyCcqt1H71a0cJhzJWObvE5yROfMNI7oaSbkyjB+zAd8752W9M4EdRE7d/j8EdKj7eFaZd8l24ltHAQL8MazaPt1wMJuKz9ae+giWV2gY0sOSi22h1mxiiiuaE7OmezKAUs7663ySC4MUYUFOawY98OQAVcVcL6oCnSbgS4ZyhqrkrLy+tOv+PpPPuXFp1/CWAxdpC5CvqpKh+35DlhVtFSTARsK0ErQyuvXr3nYKlMPOU9Wxc+zI2CVOXuLaBpRVfq+N4OqmUOMy2T/r/34t+k3G1LqidHu/XQqnMcD9/evePP6JdfXO9BCSgJEJHTuuE1epVR8whwPhK0LZYMwWj1ZSsbHGs8n6jxzVrHgXgqpWPvsbjzyQv7vwH/3nUb3y7hWwfJmZ63qdiQ+RFu/2FbE+HamFStqnPqlvFjKnwsK9dKqu5wob5PFC9fMecdmt2X5s/hNb60oe3GW922JoXKeJwqGxEoXTEpFIiFFuhpJajy27X5PXyr9ZvABl8D8cOSzL1/z1R//jNdfvSBONpw3t1W/nqAigeStYVHXUxVXtqAS1QaM3rx5zWEnzJvAfLD1udmnREHIxVDe02mt5ht1opZMCMLzb77kBz/6TZ598IRuGIipI6UeqZXTSTmfD3zzzRcMfUc/mGRXisCQQCpBhGkymoPORg/QyuI7WoGrtXgBBkpgHifGOJI0UKfMeBx9wxB8PV7x/5bf5e/9Ndjin/dqiVGbcF8QI6xlGmKEmpHgdudDG1oq2+3GuY6nR6+5Fv48gmkapWXd1KeLLzA7ZRFZz21LlbazcHHGlj+Kt/tMfvB4HtHgKaQkJEU0CiEmTtOZuWaO5xPTeaTojrTp6ZJJ8ZzevOEP//hznv/0Uw6v7thU0282Xryf0mq2q99huybkrkS1r379+o77nTBuI3MtHA8H0/BWU4cxIX3hcHjwlZ0mdwaQusR4jrx+/ZKrJ0+4vb2iGzaE2BFDB7WQ58o4Hnj9+iXDkNjve6zzaC3s1EV2uw0xJabJdpmrAy7tWbRgX6sN46ghPMzTxBijqXbMZrucJpLCXb7hn8nf+JXb7qXdhhCtaHL7FTG/VX2IT9UUNwQlpZ5xnJjni/n61v+HRc90be27J24zA/5Fzd/i920dRGsw0neAsn4pgbkYKnOaMi/v7/nhxx/YXEYtxrtHKSmwV+9moMb/TIBWalE0C/dfveDlV3/M/ZffMD2c2GSlRvVOV+vO2VR7+3zrmEOj9KwduIfjgbtZeSiBnITD4WhaxRLQaHE5CIzjaCtyY+BweABR+t5WlJd5pOsCXSf0yWS4SlHviWTmfOZ0emCeTuRsw072PuzsdF0gxJ6uS6SuMHoXZ41/9uyqtiLCbLo49zQpSCmczyc42ta/nB+45y85JLUcGrkI0M6XUHdIXdfRUUid6ZS2feEGxazt/UfoFCvh1i5Z/F272nCVVJZEs2KyCaUUihYuTe67DO+y/ZqLt0Lt3S1Gv4g8K6iTqlOyKfVQC/P9iec//YxXn3/F+f7AoJa02WutYuIpqvtqWRqlyzantgqiVu7u3vCgibN0jPOZ0+HocjJ2YMfxzFxMh6zpl7XzKjEQU2Sz2bLfb9jt9kiI9n48aE3TifP5wDyfqdqjmJ5liJDUpF602vThnCvlEirz3xjPLFCLKTNosX3o0zhSZIas5OOI1EJXQaoyltds5LNfZFK/lKs5SwtWK8cHWJyfaequA3z2PfZ793Z/umVd/pUuLpOVGuBf5i9VVKk5k/OjRunjl5T1DCxatmrtv6KKhoAGR//FOFUhdfbza2V7fW2cppgsicmFu69fcPr0ax6+fsl8OluAU5MjadxTVSHGdeCm3QJg2dhiH6Rwd3fHgY5z6DlPI6fjyRID/+zTPBOA49HWkqZkCiAhRFQNsb4/3PGjKNze7umGDRCMmzUrUJimM4fjPUF2pK4HChKUkITe7TfGaEWbyMKxbL6ltf+kTUz72Spuv1Ehx4nj3cGku1R5lYX/TLo/h4X99V3LxOzCpbsYBvWlD6KTFzZ18dGy+OTvut5KKNulevHHhuqvQd4KrHXocj0T7VXXE7J0LGRdhz2XbK1P8ecWhKA93TBQHoRxnjnPEzoVZIj0rsPTKbz+8jkv//jn5LsDMhcbzIviE/Lme6lCSvwZbLdy/3DPA4lz6JnyyOF4sgHGEEHU1j1j0lA5z3Rd4nBUozqEDbVm5vlMjMJuN9ANAyqBmtv9mcl5ZJrPpNhTq4uki8sFBWUYeo8vGZGJqTROptI44YZsVQ/2BgKVeabExCw27DeeRsI0U6ryumz4f74Httu25qWUbBFI169qO8Gk8ZS8ftZq3xNC5HQywOQylrf43LoI7Wq21hDSxW5RQyYRL1BxxRv3DZ5ErIDZGg8EVyQRmKtyOI++r96pTtVkxcr9PYit8I3JkH6id8bmQp0nXn35DXc/+YwwzqRiwicliasANKpBpZO0kGzaCW8gL7QYUDmeThyrcgqJkk33vIudMb0QpnlGUHJuIBem3xuNNYkW61Z1EShUnQnVqQaYRFspMzlPlDKRS+d0NAcoMZpWFFvSlDql3B8vfO5ju1VMcg415YuSZ3IKlBqZ54lYrdNV6wNH/RfvtKk/4yYpfVR5BzF9TvWbGGMkqLXv0qU8DS6hcTFhfmEW/sry1t+0B9Uy80amXts1BiX719kPoxne+vqyvo4nttM0UqtQ1YZKcgWR4tIOlvxRTWLF1mOCTJkvPvk5L/7lTynHM6FY2yu5zmaulnyEi4GDRlYwhGxtV4g7l+PpxH0QjprINXM8nOhjTwgRiZWHw8GGkWp2DhqoFlIX6aohpVf7DVrP1JoI0mECFcYzm6YT43QklzPT1CEJ52O5LFIKXF3vjZw/ztwfRxcPtuq21rBMrQYVtFpFn+uZOSZmMP6Nb7poE49Pa+E/LO+HUP+jFaMhuYMMC7ofQiB2HVGMOyPOsw4hENT+LirMS3KwQJuor57E7bJN/7f6Sxs6Ko7YejVUC+Bqejaluia1bSCm/ZTqk60FGwTI2hQ0rJvQKlwxtWgkCMPVNbthY1Pzc+X0+p5P/+gnlG/eIJOtzJuxtlrWYCL/2jT42lpLr+bDxXnyRCmXwnmceDhkjlg7+Hg4m05utCB/Po+ImgRPKRkROJ2PJkeXBAkbdtsNfRcRLWiZrXiopu85zUem+YyWzDSdSb2v1vOERINvcOsGuqGn6zseTnnhXaqLwCtcVPNQcyFXZQoBUdP/y3UmFJOVu9Hn/Lv6nwL/i78We/zzXiJibbWUSENnE8WerEpXiRrdxxiKqLXS9wOvXr7meDjjBgKwDOjphatthfPlmln112lIVVGgKOq/EC5eYwmjtD812y3abFeoEmxnefSORQquRBAZrvaU05nD4cRUMn2Zbed3qeTDgS/+5BN4cyDmaprLWunCQHEk1ZX6vmW7ls88tt1SCtOcOY2VY1RynpjGTJeSCXZLsfYoa4wxqTNbL5ySEMKW65s9mz6idaZmS7xREzwv1Xw2NTPNlXECV7YzzVPxZSwpknqT6nt9f4bmezWbH2g3uhUHagmeaqYWk6jLzPTYs3oir94b2w0hsN1s2O2uqc47j7GzWC5C4mxqPJiyQi3eBp68Db8ohcJiW5d2e/nDWiHittsS0Fp9a1hVNBd7RI8sVH08275HllTLNkoWbA5DY0DU99Yn+/PxPII8kGejpXSpQ5PxXM/nE+cX97z6+jldNeqJiJKjyWTOarrp1m1lUQuIFwWjtg/sVBWz25k5CrkEzvNkaj4+RBUAMr7V8KL2XADoSgjC1fXets2ViTwLEhMipjVvW88yzcvO88Si5LPYrXVuEgb69H1clmFIaPJr4QLFtuHMEKPlLV2ybkRQE8Etyr7e8Tf0//NOe/qFCepawVum3w9to4UN5CSBmhJRCzE530RWNKZDGASi2O1UsfV9KOvAXkMZ3/rZrd1caYiIIEXQ2YJVleKmFoFV19My+LgkKfYjBEmJ0CVDmLxP21YqLg/VFaOLFqbjyOGL53zxk59yPVU6jQblS+WshYKQxV5jo2FF7BzFQTyPu0DUcslMpTBnQy+neUYkugqAfVirJP3eByGmZqwm1H69H/je9z4kePVj790+7zQdmafJtjzUyjie6V1LsQ1yIYnUd0iMEGwzhd5PSDDKRGvRSRWbvrQ3w2az4/bJNafzyHSe0Kgruk3gB5z49/ijX2RSv7QrpcR+v2O3u6JiwSRGU4OIKlTNJlsTwNcaEbBCJue8oFJmQ941uESi/Hr0p6oW1BHn8Doy7yiUJab1cQX/1msJdjYqFuxnLYaQY1qlbRNJ0LBuR7EYRlaTWsqnI2++ueP45o5NsU1aQjXdvGAoQXY6QgeEKBY0ltZaxHR3fWqeaFJkag68aGWcJyRB0YIWWxIQinObHZmT4MWjWhDuu8D3Pn5KkAo6Oy/dXr9qYZpGSpmQUKmayVltShqW+5eSEKSzhFeE8zgRgtoWsFD8rHhy4ui2ehH10UcfMHQDz5+/gGBcVRRObPij90Gqx6+UElfXe66vbqlENAhDSL65picNuhRGdn9tsOl4HJlms5L1+radfffVIr4Pq17AsapKDaadePmaZYEYVh2XdkKaHJBG2yTU5gxVjPJESsS+J+XCeZrQmCgqzIcTx8+eM53PbNRLb1FKgFEqo8Ds52ir4Tts1yb4a4EazJbnXJeuWdXKlGeI5ue1CrUExLeUgcWBZrvgcxRUrna9F1aZEgSVjGDKKMfjPeN0IkT7+mk60fURCTYMBbaFJ8XoyYHQd5CS0kUWAKEUX9jiQVGj6cd++NFHDH3PN89fgiga7RmddPte2G4Igf1+z/5qz3a7A0nml/xzSIp0ahQdz8RWahRg/tV8ARcqEZceVvHht0VG8QJyVMFkacL6bWrIQJW62Onj13wLIHPwLfYdoetIBBJKCsJ13yN3rzmdR87jmRgim23PbfeUkivTOHN/d0fJmc4qEuueUdFSDGwAEF9LHVlOzSrisuK7hkBCTB0E10BtMpUNSCKaZrC6SoFFB3JVm+GSmTmfmecjeT4xnX0zVOpcMaXy+Rc/58WLr8jZhgDPU0ViT4o2BGs/K9N1trEupog8ZFKo2MKtwFiK6TD7c1CgBKPb/M5v/xZXV1d8+vOfU6m+6AAG+R1+Pfwv32lTv1io3zlkEiJ9tNVVfbdx9KKni2LVSzEB9yhC5HLXvCwaoRevfAlI4c/MzU+X9mZVSz6lPTjVZVJMXeTZjPit1FZXVKptVWowfogRSYkGSy8zBP6Wlo6QWrvy7vgAMVC1+LS+tVuJ9oUZpQZloyzocXsTtWbf5hL8c9n/Cf75cm7Th0r11oSIycWk5Pj8MqGdSdF5VVqYxiO7qz21mjyVccArX37xOXd3rzlPJ5MAmpU49H4PmrFVSImUbMVekJkuCakLUNr0tq1WDQTwlurVfseTZ8+QuzdULcxlhurJrFY+ke/zv+V/wH/8TpP75VzJNzGllBiGgZA6JFqxFRBCgRozXTIR/ShCUJfSWFChx32ltwuo5lmbfbbvqQ1RV7Ad3vbN1SsuXb7Zgn1jXjX8fW1W2D8Vdf1It51qdlC8ndPGs+192PTxeRw5HQ9WuNTsw0Iwu3ObBLLYOeqCLxJ4+xi5gw+0ZQc2qWuyaL6LufpqPptYYpom+s4QMmrb5OOIWs3kYlp7Va2tVMW6JHlWTucz33z9JQ/3rxFRxulM6Dr66ImZVFQzxqWOJgBeQWQmJUg1oDmYlrEWX4NoMi4SEtfXV3z44QfEEHj+8jlVKhjwy22959/hv/xL2dxf1WXLT+KiLhFTQqLtobfCXhDprGMl0fa7u/TUt430T7ku/BywJApLeqkN4W9tPr/k8Ws0T9usFbhYNOAZaerMDsWk/BbOexT6TUdIgZCE/fUVZc5kRjR4d6rogvBOtVAlMofqm3AwZIdVckvd97duxCLxhph8kJbFdhsCIt7RyDlDl6wjocFbu9bv6AnUOnM43vOkTOQyEsQ6GtNUOJ3OfPmV+V6jC0yEEglVXZ/TCi5FkJCI0eKXSCZGJXWBGtKyaMK0mC3uItD3HR988JR+GHh1/5o5N+QQbuSOf4fP/yKm9ld6NTColMI4nqkYwNIFb2Wr75eHRZVnTU/XrlJxyTF7at+O7c0e2kIJYAWj1DSOubBtxEXi/fdL/scKgEUxiTIRMRpd1yEpLR1YDUIN0G02nHMlT5Otd0fZF9MIDSESYiJXXWZTEPO5IZreqxHqlEFXBY2WcxQtJElLUd3u59APxDihNRvVK2cHw2SxgWbP7STWUm0hjURyUZPZjD2p72xOICZU4cXzV7x8/pzT6YiEtUCqulJGSskQodbkdEOh6wO7fU/sIkOpjLNJpeUpI0HoY2eSmiFwc2NrpT8PyjB0iBZCrez0J/yt8r8G/tM/1ab+TAlqm45vBrDwSrXQFsMIpqtYa0OHLiuVb5nZd1/KEiQFWoS8+F5DGW2141pdPa7c/eC79bVENYhxN2UR+G/OdEVYw8XqvdZyHaeZqSq9mrNTESaq75gs5AYhtj6EXn5mXcjPbfoQ57iqZltBlm0KLARFNCytpVpXDUQTgC5oTNSSOZ8PvHj5DcNuS68Z1cQ8V47HAy9ffsM4HVEfJsh1plZLbnAMzgjNBQlWxaUobLcDJCOKl1KZ80zN1e5bsB3CXZ8Ytj1D7pnmjuqcF7WdfZxk5ifyfkxC22pFQ+pLzt6u9BRQcQ6OE+AvUMi3K2r91m8e/e/l/y0OpTlPQKQNsLTgvf53eZ0lsbW/uHzpRdNXXJqlybO8lYdI+/nIMjBoK1ILc60ETzBUYKymhjHXShUlRH38Uy8SluUd6fr3XeqA0QajPJBaPPHlF+AdCbWhw1ZoBoBKzjNv3rzk+uaWvk+ElKgqzJMtlLi7e8k4naytv6zfFdNIbEJH6pzqELyiD2y3PSEF5pxsI9w8mf3igvNRbPPOdjDh7T5SXS+mlsooGx7eAxQKcLu1DV3jOFInW8sSyyoN14fZVl52nvCpd20aWsWjWAwXv3/bfBf/5AW4ehtvMVVRaCtoL75n/f3q4y9bjASxgb6YEPGhClmpLcEW1/swDWyGgUlhjsa1riLkIC6JBicqk2bn8VVicNuVNTH91uditeWUTBuy2S662q6I/76U5aSCoa3ir51L5uHhjrs3L13SqzOljXPm9etX3N+9ZprPRiMSdR1qJ5A5ONBWdItY8dGlwG63IXWdrdREOY8TeTbZJNtCZyBR13UMQ0fqA2m2oppcmfKWr98D9RSt1eYUZCTPhbkayp9cZSGibGQml2K8YbnMCy6M9i3rfdtul7xE1zxB1Tm78fL1LrsMK+ywvPRbrXUvCRYt1JAi1GIFuAhFQDrXQ0d9LapCMA58jJFu2JCGAcmF0Fni+OruAalh0cJNXjCJ8AgUuMSLl46nqi2VYWLObvvFu61xLaSKL6NYD+16n2qtnM8n7u/v2L+5pjuPgOmWvnr5ivPpsAywWor3mJIJOFUzE53y0HWRzaYndbCpMFWz23ma3fULodiwcJ5ncp6JXWDY9kCm1omvOPC/46f8b95hU784QfXwpdUcpnjwzdXkDToUJBAlM8WeaZopvVX3TRNLvuUSWSoTyyflWz/P7wrqYvtgfLvlETx6yTUhtAdtO8QfsVl8qYBtMWnT+86n9eTCNlUF961NXD2gIVI7QxhLydwfXlOrIW4IdEHAUVKlSUy5O7+wOlX7eSklqLPzTMtFMmB82Iq1KKu2cS7xz2/bno7HB54//4r9/orNdodIxzQXXrx4zv39q6VFavKI7hS1pUmtiGhOElIX2O+3DHXDXCtzzpxOZ/KUjRiNEJPLNgWWRLXOJnptKAtIeKAP//RdJvVLu2xYwgaTxvOZydUbQktQVUlSmfY9tW6bhTnqFhbn1eqNBaHhInm7cHDLxDW6PHttSCqAGD+4vJ0ySHtVJ+TDI/treq4hRojW6hRbMeLoTyusfNMaeEFhxVgNgnYJCJRauJ+PRJ/elKCGytXmDFc1B2pFYlycZVvNmmICdQqEr2k063R0QMLaevPP1yY8EVOtePnqBbe3TxHRJUGdxsKLb77keLgzqaMI0qZM1ddTepO2epBHIiEKXZe4CpHBt0kVVR5OR/Jkm94SgdS0mQUkCv02oXSozqjCgT0/4b/9V2iBf/HLGCeVeRqpVRmLbcqSUpbnu+1tancTkyHEl3Yla5LaivUW6pdgf2m7zRXrisqb2op9D3KJB6gjX/6N3wE+NL6fFRDucxexR0sDTFi/AQIQ+kCfOjRmUozWXt1sSGI0onmeeHP/ANNMCjbg2EtcGQfts1z8auoHrYMXxdqhuWRDR0tBkrjtZiAYV7RNWvunad21UjIPDw+8ePGNfbauo1RlmgovXz5fA32E6HJnC+riPqRWW72rLqXUdZHrkChqdLACHE8nxvOENh6jbwcrdaaSSENkqLYIpDLxML0ftquuNmBOLHLOTlWr5neTCLVTzuNI0ECfAslM5eJqiDcXhfGF3bZuUUNYPZGrVUEKgbiCQs5UuWSlLD9OHmclitJ4n0Fs0UoMASVgmxTtqyQG+s2AUQHMvkJKJqHXdWy2W3Y31/QD9KnjeDrx4pvPqblyvRkYpLNZk/Y5L7Lv9Yi5aodzwgWh5spcZwq6rNy1BHTljRtybDlD9A1YLeGc55nT6cSb16+IKfnG6srD8UjOM2jB6kXxbVctxtk8yrLBspiCTEqBTd9RNaASKCpsNwPTBXARqjI9HLi7e4OSiV1kEwdUhHGe+Lkk/k/yo794ghoJi7FoKUzTzBwCjKOlOrVCnq2N2gk6bnm97bnqbknbRK0mZK/BhMr9OTzijbSqvE28BzHujQX4arIiAXfCgFRCciI+jY/hN/TCsNciSfwmB/pua8LWF9QAVUOn2jrVZcgpBIZ+4OnTp9x0O7pj4dnNE47jiX/yj/4h5zrx8ZNbroaBKOmx0bcDshigcRfVfVXbljNVX5OH8R8livN0bWDEpmaNJ5eStdm1KnnOzNPEz3/+M3b7a8D04B4eHsht40/w8kyacHJLcg1uqHVGPfnp++RkflMDKFWZdjumyfQ8tVSkKMfzkfPZWgHDpoPSM08nmKx/PIQ9P65/410m9Uu7RA05PeuZacqc50KuBUpBqiWOmz5xu+s577fMfUfXCXNl4UlXJ8wttoT9prag7S6lOZsmL2YDaY4QyIWaQxCWXXfrK1686fW3ZjbWNkqdTf7aM3Jv60VWCNES0yBLOzOFwND33Nw8YfhBYFMjXey4Ozzwz//rT5keRp5dXbHve1JIdI3iwEWyQuPErYNaFNt8M5eZuU4QLek1f2ZpwZIIucKGhLbX3TjSpZiz/PyLzzgeDyDC7MN65/FMLgWhEgX6LjwS/xZPFkrJlOKfOXRst51N6osxunJVttuNbVVx29VcOBwfeHP/ht1+w2Zr3OOpFLJm+vnEr/OTv0oT/Atf6qjupDMyV8ZsEk9kE8nuOktK39zdE8qGq03PZuctueaDzAERLwtmVX9MjwsrLv5/bW1CPyMLN275+scoqv33LdTWz0aUSN8Pvja5fVerrCzwtT5bSubfazGt6ydPbrjtt9z0e7qu55tXL/j//aOfcBgP/ODpM243G7Yxmu2yJivN5Va1waSC2ZxU27A35ZGpTsQ+GQqWrX0pEihU48jSONTqfteAkVLNdu/e3Bk1S1x9ohodTEshiPoQiX3OEFpEsSUaZa6UZEhUCIl+SEiudAQQQ//7FJk2VjgFFTQXjm/e8PzlC67Lns2mo0+BUY6cSyXx8F7YbsnFNmNhswyTDz6lEEghQkyUHr765iU3m46r/YauH3xgp5ECVwQQcGDnsd02MAAu7NYTTK1KlEtlCnsRyztY/LZjmIvfCv7yUWzou+sGcK3QctFNkhjYdEZ1zNsBCZGu6yk50w+Qbq/Z9QMf7Z/x7NkzXrx+xT/+49/nOE8k6emCcaqTiOsN+4e8PKe+xCCXCsWKs7mMVkR10cqe4uoQwWKviC/twM5as9tLxaV5nnn56oWhwyF5K1+XhSyiSp8ShTXpt+IyoNV0rA0cyMQINdr0D2LyUjF2dL6JLsVAksinD/d8+c0XHMYr9ldb+tRDjMynI8qPuI7/s3fa1C8ekvIHqy5LoLi2mLpOqYJxLIVxLnzz/DVMEz/8tR+QUqSSTAqnTZUuMLSshsfa9nm8TnWtzlsRFBd4/7JdemFki5ukdaZcZDeQ+kRbO7AQEBYblfW7/T30Q8/H3/uI7uPIx9cf8KMf/YhvXr3k//CP/2/85u/8TT7YDNSHA/nV3TL92ajY7YDUdv/UnGYMicPhyElP5FTpu55xHCkh2kAVYjwUsdZWy6X7vvf7YgK44ziRiycOyIKU4jqAKQYCHevaVXuaniqT5wwSSLGj84lqm9oTahVSSGyGbuES11x4+eIFD8c3dF1CBLptR3/qaFq0T2Xkvyd/+ItM6pd2CbJoj2oFZz1gn8i0Fu6PJ774+gXj8cTtkyuePOl8955NOQYNNHm+C1YJBjyuz8cQlrJuofKr1OqIvX2j/eS14d9s9XKkxb7UjEZE7FCLGMEcs9eq9ozFi6rmdIOjp5vthqthR/jwGT/6+Ne5ub7h0y+/4P/6+/9fPv7hD7iKHf1cSWMmIaZioM3+149pb8UHCdW3RJWRGgqpM2qJViDZJLPUalJYHpSbswy+57FWXThqL14+J0ZDd23zlKFF7T2E2BBkpzpU+5Sl2ErJGIoHk4itijbkO7rD3gwmjdJJ5Hw68/z5V7x4/RVTuSIm4aobuJ/s8zyVJ/wH/Id/FWb3l760mqRWK2ZRsYG44MhjSBACXz9/zf0reHK144e//kOuYKGEsNi5XUvyyOMOwIratEAFCz/qrWvVo1xfe916vl4JpwWlSN/3hrBUt3txXRN/Q2uyYO+n6zq6fWS46YkVfufHv8P++oqf/PznTP/4P+Pf+vv/LeLhhN4diPcns133P5fdtyYduCCoVZlOZ3KdIBZiHJjGQqapDWQSxmle0KMAm80AGI+06W/PeeJ08nkGhDnPIE2Wy0AFwZC1GG16uVah+lrOmis1FkeYBTQgztdMVZhQUhxIMdLFBFV58+ob7o6vka7QDx1pE9HcM01nnsUP+B+9D7brhVVwTdKabVg5hc42bfU9EpXnLx84dMKz+Yrr22fshh6b+IJGhVhbpPotu728mrLJJQS5pLieazS7vewaXGqzrACEd1JDIKVIcSQzshbuts0rOkLZ/Jqd2RQj2yc79Kryox//DjdPnlC++Jz07IZ/8Pf/fdLxxP0XX3H4/CuTsLx4XXGArfg5bKi/VmWeRqYyQQ8ffvQhX3z+BVWLLT0Qi9WlmgKEuCzl06e3nE5no66o+tKUYrmaBmq11ahNAzu40xWBELrlc9k9Cgs/FzWwEsRt1+5pxQa/Nl3n6iORvuv5NBY0zkjKSDQkOktGNpF+v+P6ePtOk3p3gtr0+Fgdkd1H+1MU6GJH1w90nYm/zkW4P02cxkyP+MCCECQuE8cLeuqG/PaqxwWyx4K4XJLuhAtHun5PaE5TV+mRljm0wJ26bkGGDNCSJVVZ0QDj9ksQG4uWQEdiuL1CtgP12NHd7Pnv/w//ATcKP/2v/zn/6vk/WzbXNE3I9mKNg1dRCMYHGc9nzjqiVx0ffe9jPvnkZ4ZUign5By2UGtzZKapLOu1ckLCI/uc80Sok4/qllSqxRh9ahiUEglg1b2LyxRN4S+LFVRu2YTCnWyu1mPRE6BQV0zUUN+pua3SOAHTnB47yT99pUr+sq5Ti1R8gZr8puCSMFyzGBY6cxswbThAD10+eMPoq0BAiQdcQaoP+uthtXNAqWQ+0XKSgLpHWCo2FVwSPbLeVRnKhp9Ja+ymYREcL7HKRQTYps/ac2zOXIMS+Y5M2aM7sP3jC/vYJw3Qk7Db8/X/332U7Trz4ySe8+Fc/s8pbQfSC08dF0oL/uVZOxxNnHak74fbpE7784mj2XUzrJGmwARYUcRrBdntFKcURVHOUpcx+T4y6U0p2TR4/ywFbRhDWzxhC8KEopxWoojUTJVCD+rkNJLUKXjGpphQcAQiZojNVsmmJCqRNIpXEl9PIf8Qf8A/4t//abPLPerUJ5YYcR/XAGU3jtkuJFCNzMRWVrJYAfvfVUBW/X/FC2YS309C1CmtITq3qfsiv5t+aX/Xve4ucZX/n1BOTStLvtN3FTYvHgwCxSwybLSVn0tUW2W7QoUO2PX/37/096ouXfPOvfsqru0+8cMEzDI8ZIhe2a/Zba+V0OnHWM3qV+Oh7H/PTPzkYHUUKoiYvZ/fRYQyBrusoJXtMsudiK2HFlldIMOpbbMOVrmoQhBhWelyz8xjq0nqt1RRcTDvcznsnwib0NJBDELsPg0AsVPFzEgNpiGx2Ay+mwn/08v2w3Xa1+JpiR9/7cHXf0wUI0aQOJdrwnH+H/VLxIfwW9+Utu9X1qxtYJasRGZpa16FrbXmEv6bf12VESaz4WzpW/suAIOu4haCIDyUtySTWpRTXNrOlEAKdDTfXITIHyCmwe3rLD37zx2xPI5+dJw6ffumWot558D89AufMbkspnM8Ts84wdOyvbxi2rzidTi4YUxE1ul5bECPA8Xj0zqx57w4b+JrnbDlStHkARUipdaNWfWxLntVXdostLvJOsyWqFRY6pHqXrzO0FbsnXYKr694kqaJ6giqEThj2Pd30KXdf/q+A/8ufake/cJNUS/RELgWaXQJDAl2X6PvB3nww55Ar5KrEqrartVaHmi+zSl3tcjXPJamz38rylcYKeEzUp7V0/DVCq8j9IeGJmrU9TSjYtBnNSFNrFWjLZdt78sRWzABFAvSJOcAssL254Ye/9ZvclMrLTz5zG2hB+eITenBvEDrguqYzMxkJA88+/JDPPvvM9rfropBpyabzDZtEjyFZYsMd/lrFq5l1qjEuxPCwcAov77ssA0TiRtj4kUEqKSW6rred0LR2qn3/dt+7odlQFwrDtjOKBLDRwLXev8ukfmlX40HqRXIeHEmOPt2foomHV1WyB6fqjqlWRS7q7AVNfOvnSNPaXL6y/fvxd1iCcBnoW6z2zTd6EeTlgoManX+KFTcBkLjytN62uVaSBwmkvqOIEDY9MtivuN3wG7/7u2xPZ8rre17wsxXib+++OfWF/2XP+tJ2kYGb21u++eYbyjQZUV9tglaqoyiiRDDHV1viJUuwb4FfxISuLbBHT3zEqMB+89qtE086w6KYUR31MEcZA154iEkg+X3sc2TYdMROIOiiT9kNkaoDYR55of858D/9sxvZX9O1tONb8S6mRBBTJKWOLnW2ZELU4ntsitzvuC4Looay0ooaf+7try8Cpa/ook3FN6Tp8uvF36c0aSCRJeCJ4JxP47glvst2/ZVXF2UDgURqCtQopp+62fDB97+P9AOnr17wkvb+ZIV2rXLx998+Ax6cZ2YKIj3XN7d0Xc84jReFY/O7DRjAtahtUEZKBGyS2aSglMa5XjWXZbkxjQfffLCorJQVLMgL6l1B86lDPxj3e2ldGyd4t+/p+kBIEJIP1faBQXvC+H7Y7lr4rLS61HX0/UDXd6TYkYLFj5hM41dpsopmWUvXtD3Kt+22FTbaOJir/a5p6Ppqb6OuzWZDs3u9AHKavw1NZWemzjPSibXmG4rotrqAQM382g+IYioUKEWEzfU1sR/Ypp5+2NhnrAZIPeqdXbzXVX5LmXMm40BfSnS9bd5qw+LtfqnnIAicx9EHo6H9RlBf+V1oFE1VTMZMknFqS/U45T/dQcog631a/r/PFoQQuN7vkNSRc6bUYqi2FPZXW1KK9L0NaosAXaSnZ7c5cPMLqCm/sMW/rGFsxrA4JzPCzg0whMb9EEISCE270G5ww2BbEFbm9bVYnvkjh3npVRsvqC4UgXYPxQYqkGXAaa2UxDJ2154LIXA6Hel7IUoHmHi0OHrUfPwqmG7vsIrp6c1ayQL72ydITKRowdAKiiZR1LLmiw92cbX95CYdlLh98tSqdJff+Jaj9ntRiglXSAnUagZnztO+cNntTm3lw/JyhvgtEd6qwdDa/oohBoLWTBc3bLeD7ZTPBQ1G6E+dcPt0T4qBmAwdAIihR5NNnPZ5yzP99V9kUr+Uq6Em0vhIASCQYqBLySvCaJ8nKqlLdJvBJTuKra1TmgqcJasXATxcnIVHl0dsWUx0DZbfmuiwl/IZVxbUYWkWtCGSYMj2NGckQhe6VVswrDSDx2/HLTgal3bGJH7idsv29oabzYbNdsfqhPwmtSqRxtuy/9+SypwzRSohRPbXN/TDwJzzcj6bFV7KGM55XuRlgm910loXrhMIpdSFBx7Em6R+1h+deVYJMTtm7iSRJUHd7TbWwvJhFKXSD4Gb2z39kBqDA1C6IRFT4OPywN/jn7zTpn5ZV0OvLwOuCV535m9TImB6sDGJ85PjglJbPWH6spfDHwjf6VvXjVXtofl9B9dprKz3fy2gwG3XeSfhIlY05Q9VZRwn8/cpLLJQl7bb3l4L0CarVwjR+H8FhRjpdnuk79nsr+iHwe5NNSRnvVbbbQjaWhAV01+VSNcPbLc7G/azm/B48NY/yvl8ujj3HvcwrmyTObIzYsln9EFFdV3rttmnva+VU906eX5/PYG92m+Zi/ne2hKOBLdProgp0PUuB4j7hzjw4Xj/XtjuUvgIrhBjm4e6obdtXLj2ZwyE1BFih1I5n+clfrXtTcsTbfZxgfovxdWj5LRdLa2T1ed6ptsQ6eD/0ApAt+1lOYYvdhjHmTyeoSb6GHwZyTqMvSTRXBRC4MOYYWnBb/dXPJxG9n1vq21DsMUX6CKXuQx9+Udor1nFB+uwbsZ5nJFoGubBJZ8ubom9VhCb+C9eOLHarSMNi0+ttfl3l/QUjGWx0AzqcldrU/lQ7x7qyrO+vjGt8fv7B5qCUKlwdbUjJqNMxGRPNUTbOHq9+YDflHcP9/3CBLXWaq02d2LmLU1fKwSTVeg6d5jYNqkYTKcw58r5PJnkS60UTNpGMSfRHubbJrbC9h7opVUK4kil8/zEZHcWFp6ugyKAi3MH15CMnE5nvv7qC26uN3QfPWPYWlsnhosqyj9zjEbgb1qsRQtzLRCE69snnMaZm76naYRqky0RYeEgIRctYrVd1u3wYEjzeZ4piqFiYUWqG2rV1vWdpwmthc0woP36XkspiLTDKNRckM4+zyPR3wXmExRbG9gma4VWQAipD+yvttw93NvUqFY0WOGx7QZCShc1n1WLqRtA4efzM/5j+ff4z3+RUf2SrpUZ0lBUfRToQY3nmITQJbp+oNbKNE2WnDuy0iSSlvKqeZJWPV86THeudfke4FsWvl5mJ4Ega1C1oB0W2gWqpNjx/Pk9mz7SXV8ZpcZf4SJ1MEfpxlyxqVOCkGtlrMVFn5Pp5Jbi31Q9oVkDjH2wtqa4UDWDtE1Wpk855kKpFoikBZEliHtLLtguaQG6YMMBsSUo1RCrJbktJureztCaktZHd7DU7Fwq8Q0qrjVLJMSep0+f8uLFC7SWVn0SItw+3dt07gItQIi2KvY0/YBP+J/8Wczql3KtoKA6Jzq47rTpYkZw/dCEpA4V5fX9PTlnqjaCBZjNrm1n4FtB/TLQX4TfX3gFDcSWHJrx+f22AgIRztPENM4mfbdJ9CF8y3alvQfwYOnJbwhICmSUrJVhsyHEjuM0MWaTyaPaZjaJ0V/HX7HZrhZKnUEGqoKqMM/Kyzf3nCffkHNhu+2zmFA/TDmjtVjXxQeyGgaBtj3vmBxRNUF9xGch3TYv72dVK9hKMdstvnpDMLTx5ukNL56/pK24Vu+g3dxeLQo0y3MLJpx+HH6XT/gf/xmf2l/j5fq2Kvb7lJJt60s2kFiLfdaYrLsTukTRyt39nRW5DUFcN/gsfmRN8v1HhTb8a4nW23ar2IDco7+tVhRFWe2uXeaHK8GTtuP5xP3DkZrPxLCh6rB8bfatVSm5FasDQLp2iSvWUZIY2F9fowKTx5QUItEl85rdtbMueqkgZLZVXE96PGc+/+wr3AVc3Jd1YYbdG883ZgNozO/aTABYTqNq0m0onEcllLwkkISWzDfgAu9AuHoKbUtW+2UDWFPJzGWiaPbbrQzbtPgXdfBNQjVQtxt4xQfvNKk/kw7q5Z9t2oslIMWu87ZcoUHk0VunJRebkmwcHK9fLNn0g60sAdUS1rBC955UXF7KOkXtdY8lVhIvhqTWIBlRS5pj5PBwBN8wMo0ZhmHRohIVpPrPE9Ds1bZvpJpKYcwzsyr9bscXX37F5sktuWRS7AjZh2GWak8enwAFKbqIPwNM55mf//wzTuczXfL3ribhFUMTnLKj04y+fbZ2XyxYs7Qr5lKIZbakKqxE/uUOO7oy5dFoA942DiERQ0fOtpO36yKnoyUlIurtCAXN1NZqkWbIZtjPuol/cP3NOw3ul3bJ2380PEh8UUPsOsQPZYzOVYzRhiCmiVwyTQpGlmD/p6eay71YKtX1akmyumC3OkgesdatCTOH5awpkFwvL2BFyP39kbvX93C1Qa+uLj6Xf7/Xa549LkkfmE3UMtuqyO2WuVRO93ecxskS1rE6qu50Fi+RHOw0JEibs6wmEzIWfvrTTzmdTsRgQyTiDq+KOfrW+gVM1zEZamTBxQYuGz+xbUIqrSAQUKnELi3ari0z0GrbslSrH19rrabUM2hl2HTkOlMoNtCJaVz2KS2ISZs0x7U0b7uJf/v2sz+LZf31X+2++78EbNgmJUIMNi0esMHPZN2QUiv3D28Y54lKRSWh3x69WxCa1uSpAm8nrJeXevvB9JPtFYLbrTiFaGnxu+xODJisl8J0HikVTg9HElt0d/leLmlGLdCrpyW27WzKxjHOqnTbLRn45sUL7g8PhJjAtZrt3IUlnNSLe9iSlKoVFWspf/HF15zP50e2W6tSY1sGs8Y+W4xhr9dsF6olDg3F0kSuo88u2IGMKV34AzuLpboMjxYbvpGGqIYlQZAolDlTNFucNN0xlu5Ei6MhoxK46c/vhe2azizGuW35QQgYWNkSnUIInT1hp60dDvfkmv3TvSW/hKxFh19GJ1q7UQ34f5QpqPogdfAu2sovNUNeY6t4kdWArCAO9EiAago4KuGiq/P4zIgq0hBRdX9ZXZapVrphw5uHA4dXbzi+fLmcygasgYFQDVZoCbffTDsf6goq08zDfGKTTDovFPv5thDPfLaGSJ8iBcHko0w+TTyNL75syBD64NJnGc1+R5INKxr9jaVwaBJpUNFGxQqRXBKn04HYd1TN1GovpKFSKBf0gIZf2yd8ejPxH/x33p0v/LkSVGhO06eRfTJ3bQ21A12gFmubLw+iJahr8rYyTtbXePTTlpv61s9HkBCdc2obnBqpt1XmbWgluIiuQfaj63T1mECChbemJmCfzRxrdf5nCOIDKpW5mFDusN/x4s1r6quXvH7x0vmc5vUvKRFWTcry2iom2VM9ecg5c3d/760ev0uXPBQM1ZIY3PlaFqKwtOwb17JJSUkMllwVSypDNO7tEplQIPhEaVkg/D6JS08U02elEb9bJW/VvPGmGsrl71OC3Tep9L+IC/dLuh7zktQ/9cqNagF1LXRsArXG5rZ8yEesXvQSdwl238VKXR6dCI8qem//gCAxER0RjE0eqq7Vb7OfuHCeAlrhdDpTcgVsTeKKtzYCgljBLTb5LWHlP88lo97eTJuBr1+84PDpZ7x+84aVG766xRYomkyW/ZLF7iqVkgvn0xl/R/4xjWMaQvSBLnGEKtj2TD/j9j0ux1UNacDPIFpWVCE0Kkz052BIL8qitVdQQqguIO0beNRPmbf3Fbddm9f2QnB9L8ann0nh+Bc3uL/C61u2W9c1nsszakm8WqDH/cmi4bm8hP+mVQ+LVX47KX2EIrar2W1ILqEUFhqGyeToGnykbaaTC4RRORyOzmMP37LdBjDgVCV8ELGqLQCZ5okYhKKmM/np55/z6vMvOd4f3Gc2sKIlkStAYf7rYsjPg3LJhfN5pKCPbLcVQm1Fq3XHzLcFR2WaDJdNj1f33ZZEqTYpNluHnbRe2K6fsYpTMWz1arPdINEHYk4Lelpdqk2lrfW2jlzrMNjrBuD9sN1G+2sF7vJ37g1ri7NO4ai2/tDmKHT1Pm/nAHa1LsplvrH84CV3uERMW8s+JaH36XJrbBXKnBf6h7mpFZHNOTNNM/d392w6s9mmEaTq6iItzvscknqlZoN5lfM0ExHmWun6nlevXpFevkaPJy+oPGYvH1MuPgve+tclvnORM1gRJMu9VFcteXS/QjD5Lg0gkVIqJbLY7HouKv0wkLUyTpPZVGlxslElvKtbTcHJOlY256Bi9n4+n3l6ted4PrkygFMHqNYhpv1y/VgEicp236iN3329M0FdH9p6wLW1cRaD9GSzGaJn+u2QWdvbg73LHC2SUv6vR0nqI9t0Q/+WL7VNDymZYGwXookZ1zXhXRM3R8BqZZ4z43mk7rZEMXmbi3wQ9SQadX5QUNfFM+RoyjO5Zls39+YNp7t78ps7YohAWau4i4S0vfcW6G0Liv9dqRxPJ98QFJY0YQ0jfvBchB3/PKqWhJjckAd3tXe/6RLTPFuljm0RsgDjA2aqFiTaFiAnPNdgJ02r7fsNKayBYh3dauntI5S4NtRDlIZp/aqvldDuA2TQbufyqzmD1qqzhB3sX+sE5NuyO42G0V7C/9J/xsonekTQd+SuS52htkFWybSy/twmmL+0b9SkxB4e7pfBrcfrWB+Fg4WWgLahD0tQFwS17/nm+XPuv/ya+f7Bi6vy6OwttvvWpRe/0epToJdJvv/sJQERQAIhpjb0iZ1NCwq1tfhV/Rwaulq1Oea6vJZ4kWjuR3wyuknSGE1CnVuVs21FoVRHzaojwKWlQ/ZvR04suSmY6NCv/jKfFdbETS9WRwsenFry6qiGtuLRC3+1ApuLBMGuy2LoWz94CdJv+9wQAsPQ0Xe9d3dwn9tk7ppCgy62VNU0SO/u7hhSMCWX77Bd8GeqzZYbql6ZsiWouZoqx9fffMPDy9dwGtn+GW23+cnlDqjvuw/hW7bbolGTHpQQbSDJfUCu1bb3uK21uBhiJaWeUqttCKQsr2kBWZck2PjtrWgy9yLRZKjG8WxJsSe8ze9Wt91ldNMRvYBSye+F7WplUQQxTqn7ySXhN19Rlg1xK7ddYM30FnkHe901T2i++yJXWIqjVmg0MMC+uK3o3m4GUnS98looviQnZ1t9uybWbh+58HB/z+bZE0KI0NB52sCQBXRhBaCsbLBzOeeZjDDPhgwf7h+I9w/048RWZH0NuDiZrJmcn9nVav1rayVukp/dFi+cWrgkamCLBEC0KWlUHwJucaG9pDJsN4Riq0qbgpIVUXYP7ZE0GoPFxTa8p2KKQjlnkxET8dxvtVxL4ZzYKAFxWVLAO7N/+vXOBHWB7D1LbyR8Q0S82nGHtvAMFmjbpGTmOlLrDNICvj3NFWhcA9CKEvjDigGpFx/AA34QYbvZsN/v2G4H+hgXB92StePhaMZRlQbhl5w5HY6Um2vfy/z48wqtbWXqA+Giysklo9PINE1EEb5+8ZLdw4H+PNJH4yatc8VwQRVanLBiPBzbqicEVaZpJPadP9D6KLGx+27TrBLD6phUTMT3wrm2n7Pb7ajHA2UqUG2Tl6318wSzIR5VLcC0JKq2IsReZxiGBXFoptb2IKk4t9afuVVIYhzjt2/qr+pSseqxBR4RVvYvmFPDnCmWnNpWJKHqTBOabxhF9USWi+9tnz+EsHLDPIEQljpu+Z4QAtvNlqurrYut+5kpJv1RS2GaJqZpMv1LrK0yzzMvX7ygT3Gp5lu77yLdso/NY5sAJeeJeYRpmhm6juffPGd8/Zo0TvSOKC96fu0zYJ9XFvNQG+QTWSSCcsmEPnml3OrxdqYVg/l8MCbGRQouX6yTrLre1hBg2GzIpXAaT1CNLlDKZYKq/lwVPLBVKaj45LNvs0mpY86TFVzOoyXUxfdIaNxfC/TGkH8/bFerc4frY46d+VtsV3gUqlqbuZS0BIW1Jr78LI9RKbNZK3wXlBxWoOHCmNrvY0x88PQZ2+2GFNOaoLrDmKaJh4cH5mm2YgSjYkzTxPl4z/c//tCkvWiokSz/oG4L6IKCen+IOduq6XGciCFwvD8wnc90pdhyiTZ0Jd9lu7L472XSHlk27H3bdnUJ9OqtXQlxGeaCYMN8YT1nS05QCzf7HXPOjHkE9UKsNn6krZC24RxdftWmP+00uJoLm/2Ow+lhKd4qBaIuz3cBCZY+z/vhd8tcbBBO1eK2YNu6BFOgCEIgk/NEjola+yVBbUnmRW65mHDLpRpCG7y7tCSGwaiFVdVoeu2hCHQx8fGHHzIMg3Va3TcHLxjO5zNv3tzZUhoFk/0yZZfDw4GPP3rmWs1e/AtLYtqKqSWZvHgEpRbbtDiOjKcT0zgjpxNhzt8C4tpnfMSXlfXUN5SsfVff9fZ/SqFWH1AVL4aUpg5q9Aq/maVA9i5F+1kNzBi2O2LJHE4nBxfdvV4k+y0HbPHQcgOTEURx7VjLF9swVRW1+RVtxYq9OWUF3Ir+JRDUNrVbq1KLLktwCtkqwZosqAu2DlSVmidEZqqa5qCtZ8vYDuLoD8Er/RB8WIWVbN6ga2EJ/pV2c9rhhCc3N9xc7+m7RD8MRNT0Af3XNE3cvXnD8XQm50qKiXGaQIUYEqkzIr89KHNGC6J2Ub0pkH39Z1Y4nc+cTicOdw88G3akrqB6aBH0kWoEsPIDm91VJSh0Eugkogr7/RVRC/P5zDie6aNtNRF33E2oXJzTpMiy3aIZriUltn2iH7aoCKfTCTBS9zI7oPYEUZx+4c+0VpKjVrVWpvNkz53W5s+OyJh8VfWXEYXqB7aWjsWif8VXzcazCRfVuATbimU7zNWfbUHrxBwiVTfM1YcYakbJKLa/2yghHrxDoOs7D3rr9POC8AnbHgAAytpJREFUushahC2adu48P3j2jP1+Q5eiy11F+hjoUoeIMM8zn33+OTkbWtiSxzwXutim/YOdJ4VHXLn22bWuCDEwl8KcT6adVyvn44kuRGJMVCb7pqIrh9pvWZNiaXheuRTz9581+Nkr00SeRmKIlpe2ar0d69h2GplmZztubSBGscGrDz74kGmeGL+eVhHu0gbH3AfUtbC6dJYNec3TbLxMVbJa2eSq9ysSozjiavez1CZ186u/2orh0HikUqk5+8Bn8rMIeZ4QKcy9+ZHsmbwQWEfjG9fOuhxd3yYsw+JfYfW3YtMs65tR4+bdXt/w5PaWPiXvXEUCymYYSCmhCtM08vlnn5Ndli6EsChE9H3vNr4Oa7DkESvCW1qy4u8rl8I0zhyPpll6Pp090bjQfnV0/p2269mF/dkD81u2G4JRUbRRbtw2Y0r2eu1n5roeAMxH56nQ9wMxJV8fmd2mqz+ClZIFK1DWOo7ieqBtorrJMxqfuIK3dkO4AHByMcWL2vM+2G7rhFjSD1A5n44Mm4EYfGWoCKfTkSAdU+6Yc/b5h4jIqkDTUlXFaBhNCWCaVmk6+//ffdkpsA16KfVEMbpGFyMpwGazcfqF8IPvF16+fMnheDbFCS8WTHw/LduUQL+1WQ3s3FQv1MTl73K2mZWHhwfO5zN3b97wGzdPSDwwH1/a9y0SV5f9DXxWwey/OiAYCQRVZoWu69ntNpyPR+7evAYqg8eZgCPTFZecxO3aQC25dN5i63WfP3/hVMCOyTdUtW4VHvkawLV8IzgivoI0Jed1GUVo6LhtApVguvni7691036R1b4zQZ0vIN9aPdER0220htjIOJ5sk4uaw2LODAOsWloXwFNrW/mjEOu9WFvgYjjq0eXtUgQPdkLX9cRo67pMKLnQdRbwgwvqXu33fPzRR5zOI/f3D7x8+ZLTw4HNZmAYzEmX0mRCYNnbbGbBSmcwB11RW/c6ThwOB6Zx5ObD7yG5cs9LmtsxAQtDmIwE71iBoz4VQC2ZyWpVZ58r/aZnnjLjXKgysxks2au5oicYOjugIVlymIu1N1dqhRnzixcvSENPaw400BpYVA7sL4qXChbkY7JDGGMi+LarUpTqsc47jSSBJjUhnpQL4snNerB+1Ze1Gy35CC3wqpLjaJqZQek7G4pC7WtNziOu0Kc2TpUnV7I+ZXVZpCaw/fbVnjuYbQWEPnaGPonzn9WfiSe5KSU2mw1/52//bd7cPfDq1SsOhwO1Zu6OZz768DfYbLdLS0ydA77ia86ncsdr7cVA0co02/ameZ4ZT2d++PH3yEQOdwfaEN6lPFnUFvC9WlSr0kMIJCJdMBK+qgWPWgpjznQi9LCSQtSS0thQOxeDtoNw2d4Rcs28ePGC5jmccEPR9WvCWo4t7s0WTDRE387zNE7kbBxXDfZsiT42tBLO7VUWCbb3x3anaSYEk/MKEm2bzOlIKcYn3+x2zPlISu0+V1LsbO2yrBJ+Zrlt8AIoDfGH5Ju6HgVb7BkvgAGONBMIwcGEYshf6tsApq1i3m43fPjBh7x4+YpXr15zOByY88R0OrHdbun6fpETM06zJ8faEhFcYcHQ1xAjtVbGeeJ8Phs38Dzy69//NXJ8wfHhM/58titEAlHalqAL250zUa3w1FqdEjsTJju3JixvYImxf5p8lMcO4Muvvjb7fuR72xfJRfRr3tn1Yl16yjiGlYfD0W1XLGFWkytaCCm6PquF/PEe2G6tljMEMXUHlUDNM6fDA/OUkIgN0tTqg3Z2P/q+J8VIZF6SLH9F2lmvc+Z0Hu1exeFbdvtdl1Zlmrx9b9WAdV1iXP7bxchut+Pjjz/m7u6Bz7/4ktevX1GrFYF939t5KBV85e3yDhUUG2JqyiC1FCvYamUeJ6bzSM6ZPGee/OAJQQOHV3dQWgLYBgXdf+MWrYJWH8wKEco6K/BwPAOQ50LFaAT9NDuDQilUW/c8DHRdokuBWMEGHVt5Y53lXIVSTkiKhORnj7qcG5xXvtqcUgSGmBw8ibS5jvv7g834+JBcdQ5465wtDI5gKCuXHdw/5foFm6TKctCsqmhmU5FaKCrM80gggUYiitRCjB2N/5FS5+hn42u04OJ500UAaxN0l4ThNZ11HtDStl05phZ0qg9nCXileX19xX5/xWbYME8TUpXr3dbaiDkTkqOYHq+KkS2WCrt9bjzZsJaaoY91tmpBlhZc9JjX3rv/y5MQcSdagg1KzapMtVCKcDqPUDJ5ts0O82wagEEgVEHLtKANiBlEFlApy+uKWiKSiw3NiB+mhj6/DQ43RNok29YkqSGC9fJzt6MhLaAv7GDaR66tVRbfDw5qcx6oVaSCtYFrMf5RDhDoQIuJR3t7yRL0eEE9cXzHP/Cl3baFB6Z9uBZWK161Op1WJVTnIDeqgbgzaGlmDMLN9bXb7cDLFy959eoVu92W3X5HijbIFn2KUj3RajjZGjTtmcQQoCp5nsnTTAyReZyom7q8pyXV04sPsNhuK2zCMvBX1YqrXBQdJ6iFPJu80ZwL82xDShUQnQGxAsvPc3WivdEo/I6qUGrl4eEA0XeceyK7TFCrc7z0Ysp1sdmGcghaTQfQeHCtweq/c9Ri8dPLs39/bLc9u4ZVVxGXPxsJZQJR5hRte1e3isP3fU+IK8IdFo6jXry2fd4Y2rCTfOvn2/d74u58XxNTN63nFghtaKKgVSDaOXhye2tIYjBN0NPp5IGyswK9ViChsg4ctZ95cQcMeXXqVpmy225gHkfqxqUALlG0P4vtIr59R5lrhXGCUs12scntJqUT2muqQC+oJKPuFGx4rzbuq9luVeV4OhOirXlsBeMaP+wFzXd4gbnY7vorxsh5mu0++U1pxZ7F4sZvh/YmFd4L2200ChFLrMV1cLVmaq5IgRqEvkt0y1YiLzBFFl8rrVNyYR/NboNYYhv4LrsVzw3U/f8FR/OCgGeAmziNw87BzfW1LW4YxyVB3nQJRZmmCUmBvt9aTNWLRPKt97AAW6oWZ6aZFCJ5nJjHiVTyGje1pYo0k13O3jKIvOimeie3ZGSGN3cTUXxQSYWcXfObtasUHfQLImQxnnRtwKE7warqa4jXzYjqUqANjNRGe/HPZSFllfcMIdB1PcfjyRJ5aZGv0mhcYfG94dGHfnuRwtvXL2jxF2ikdmkB0B+0NE6B73ctJnHQh4ZoBALJ2z+edC5PswVpWW5gW+t4ibGuTx2Wg+hoQfGNByJO0dDqwvXq2b+R6jebniDC3X5PFxP73YYQTFB26CN9byhsG8dYVqbSXrOhlMblrMWCfsmGSMVpYtWe/I7Zbm31vU+whkgWmLUy+0GZpokyOT8yBHIphNk0ZYO05CMv2nw2TSsUX/kYiItMigaF0iRMxIR+1YJdWyEpqmhxR7D8ZavC15MiXH4Ya5NeJqdrvdAcCkj41TtKaO+9tflYkktzmIWShSxCiuoC8fb8Uuweofgi61N9+yi11kbbyvXom1q5qO122l0qF8i3SZ408m/wX5WuS1xvdwtn73A48PT2hq5L5JI5nwspbmhDfi0JjoJ3Ajw8tgpVDakvudCnjulw5nQ8EubJkzNPROTbn9HvIoIhIkWVWZW5FtsQNCl5Gu0eBVOQmObiuq424WmC0TZNSgiEuvJ+GyMMf9+n80hoW2bUOKjqgYz2LOrKtQzeKgqyysXYcE5ZP8wFHcZsGC44BrQ2w/tiuxdlkNntEugbYFCZx5EkLqHnU/V9360KFdUSevOXa7EJq90Gid8Z6N82AlUL0uZvff2ssZJNnqaCVkNa+r6z5Q3zTC22me5qtyWXzOF4pE+Bvr8CPEF1XxMvnI1eABBLcTVn+thxejhxiA/EcVxsV/+MtluB7H53ykIdIY8jbXjDqDBWXBnv3N5LWPgDrWBfbdcCbvC2qtG32tdW1w1e4orbm3iC2jovTWKuaXaX8bwkWQgem+qC1GrrI1wgBO+D7S5Ah9tv50ts2kIUaiFS2Q4dneuMRz/bLca2KKoNDBBxzrWvQQ4mYXlxQuxnt6ika3Kr0jo49SIy+31UsSRV4+JzJQRub24WQxpS5Hg4cj48sBkSfZ8YQmfP48Jul3hhh3PxufM8M48jXYzM45nD/QP96exgDjQoY41WVlAtgJY0UMC2Us01M2chJhiniaFLbIbBcoZcllgVPObNc/ZzDkGMXlkuhwqrOhBl+YtE5/R7sDSfW9dlFKUpCpg2awi6zMWEmBiPR/cRDfDQxd/aURZbEFdbvnRhw3/K9c4EtUwTYbMnxGQtntKyasvOu65j09mmiKqFKLDb9ERRUoqsLVIBVk049X6xxIayNjHXxz//EvZes27j1JVSnKTrW5DIfiMSVYVaAnkarZIpma7rubm9YTqfef3qBXevXpIC/Ot/52+x3W5scrJVw3jS5UmvkaSVnAvTlInYasbD4YH+7MRiKz0Wg2oP8vIjRQJJkgV4LZTqHC2xAZa25Uh9GtaWJBjZOeSKTNkdWSJoINfqjt0qyqYpGWulekXaVAMk+IGt7vh8y1LUQA6B6K9VtDJ7IGQRUi8gPsiDV47iFlywpNjfR4wXWwR+hZdgre4YDJVXVboUSNH2tHddRETpU6RPYi0m18u9tLV2LRzohj4tG2G+I8C371lOpt23or4iUa3tYcMWharF8b1w0YKB7XbDkydPeHh44Nd/8H1evXzOm/FEChC+9xFdf+2DKriws33yNvShakoNUk2HNE+ZTeq4P73izZzpTyOp1iWJXgj/CkXacw4edGzYaVaYamYsSsmVPhk1Jbkmp03R24CZiAUgVBmnEeixU2DZk+LT5rShFIXo4vv+zIp5bYvt4uoRbYuPABIJtdK1ew5ktULVKNO6TPBforFLwexcTdHw3thujBdbiUQY+kTWyq7v6TobiBIq++2GTRI6gS4GiP3iR5fBniUBB/FBBrPbhjjznVGihU7FyECzI4bqkuD2WPOC7FlxVYgpUqsN2O73e25ubugCfP75p0znE9vNwN/c/65TEWSphxdM3J19s10tMJ1mptPEput5fv8lL89ntmNm+HPZrpCrMtbMuRh1KnbCOI100WchqiFR7d0Yhacw5dkDdjWOtbdKF5KCrkUAVZbhkqygLleouE9WaAgqAlKqF8eWBBdWaSFdEi5XaUCdn8jie+0Rvh+2u9kOiERqUYIKt9c3HM8Hnt5cs+k78jzSRRh6IdaCqH32tlmxaYE6AIcEW+/b9T2Dbw6r6/j5oyT1bSROMaQ8aPUhurraVrNZCVTNvpPevj91HZvNBoD71y/54ovPOB7uGbrEv/nf/Lt8+OEz60o1u/WOY5TWwjbqYsmF4+HE4XBARJimkVd3r7nKlcGzmjazgCd0gvi0fSWqEkOkKExaOdfMWTNagy3ICNbpUxFS11Fqto8oVlhZcVoQZkANG6DFcpbOc3vP3lrACtqyINrlEpWtDUWN5OB892CJb65lWaG6Yqd+stvBVlt5LcvwiwEY77remaButj3b6xtiNyASmMaM1spus2G/3bDfbYh9QkKl1gmtM1IylEwKwSFda5caqupczgh9P/C9H3yfYbDtPYfDkdev7ywpU5t+DFg7HCwham3WNvmntVibUALKTCWaXh7VNj+VmWgK+BQyn372c169eMnp4Z7pfAKd+Nt/528uxr4ISTSHftFK0Ayn48jxcDIEpxbGwwk9T8RqNe3j9Zf230gkaECJ5Jg4AMeSOVEYVQlqa9VKVVsRmyIyB6/8WjFWiaLU0YTHtRR0E6mSKcEki1phUlWR4gNW7jitRjC0OfpEoBaXLQkgVFI0Ga7z+ewtfhuQU/FJKAzdU22CJ8bjbJ9UPJHeXz15p8H9sq6rfY+kLSEkuhDZDAM3+50pECRLpnIe2fSBJMWUGJYAHpdT1J5ojJGu69hutzx59hQRQzanaXan6QNx34VI+VVKIZfJnMTSICo+Re76olqY88ygzbZNeP4P/vD3OZ+OHO7vqHWmlr/B1dXvkhoVBMATh5ZceCHMPBfG08h0Hoki1DxznDI6ZWKzM4z91RrLqBBJBBISEhITSuRUMg86c1CjnySfkg8SjMdUkw26+OvWAJHENGYPKAkJkYiQtdC6C6gN+AUiNZjjsjqq+gCMUluC6uv5xJ1eFFukIbGQq+kdN51KxQY8EXV6UYMG9NFAYwyR7Xtiux999BH39wdSiNxcXfOjH/6YTz/7GT/4+CM2m548n1EyfRTUUfCuS86ntmcePfBVlM1mYH91zc3tDV3X+cT9gZwtqHR0LDXmxXU5VV1r9WLInpWiIDY4GtqmvTwv3NWqhTmPnM6Zzz75hNevXnI83LMZEj/4/jOGDz9ahiYajagTC77a5NSAPM7M55EyToSqaC6c8kjMlW6FEN9pu8RE1cipzJzrzBTxldHV5hhCcDmpusj2gVJF6Upkqq4rXQNIR4xig8IIQSqBZDMBQQjVBtoWmsaF7YZgCwHUg7JWkD4QYkE0Uhak2hMGVUpbkCLqrVZfZuGFW61KQt4Lv/vhhx/z5s0buk3i6e0TfvzrP+KrL7/g5mrL0AWkWq5w9+obQlU2XaTvB7RGpEYiHTEkakhIJ1xd7bi9veHq5ppSCnd3dzw8HJ1uYpnBu5LU9neqZR1UXsiUdSkcpmzdgfN0pujMcTzwyU9/xqvnz0lBQAtdso7lWk55e53LGlAXP2zbCP085EIKkZoLuVSSGqYrEtbCjBZL2xif0ZwO08SYs4FymL58nS2nmmZ7va63otBAJ0PmczCtauvXOYARvTvgIGNIUE2ehlqyDUR7cRSiy1QFJQUrumpbpexzQ0IgS+U8Ttzd3RFjNM3taoNWzRk1UMC6EaC1AWcrbfRPu96ZoO53V9w++ZDUDeRcuM9vKHVm0yW2Q8cwRGDGtIwrpWam6UTQxi8zBENE2Wx64nZL1w+k1NHWer5584bz+ewH89sV/eKC3BIF40TVasoAZiJ5+WqbBLSfr+rT98X+/9dff00XI88++IDNkNAy+VSrt0NFjOm9QLbm4JMK6tzFMs9WTfhmKanFETpxErU1ZEzOxHhPEhIxdeQYeTmeOaJWXVcIBUq2iU0pSqxKdd08PNAHFVDbqFJrZc6FMQvEzLYf0GRIS9OeI1tio1irM3WGDiLu3NwQW1LdNAxDyEzTaPfZt9OoV7Y0cd3lQciSmHmHgCiB7fX23Rb3S7p2uyuGzTVOkGW3Hbi63qHqqHSEmhLoTJnO1BSJ7IBKTNGlTCD0HfvtlmEYGIYN/dAjIXA6nRlnW4kaXOKo+vMSR3UIsnDQWsb4WJS6APb9FqItKS05G7G+FI6nI5988gnj8cR207O/2tN3gZvba1gQFvFgxSIg3f4BMS7UPFOyCfajMOdMX7z8E3OM9l+ljZyoiK0ejQlC5KDKuSFDb9tuVZKCpETxLVx2jAJTqUQVkLzYk+nyFhsyk+jDXBhyVtwhul3atiR7HtJ0VNzWS3HEoVab+J4mTqcTbYK0aPGfZ/dC25kUj1Wi753t3lzfkqdMcg3H6/2GJzdXdAEShZiEUgvnhwdDm4e4dDVyma0z0A/EfsOw2dD3A/3Qk7rE4XDieHQJPmXlhMH6X6sBFqRFdPURXbr4Ym3SlgqOzpSSbUtNLZzOJz79+afM5zNPnz7l6dMbNn1is93Sgrw0QEDba+iFjmmwjUpzpuTCPE2WtGldVUx+ge1qTIhEHqicgUmNhxoVNPv6acF4uilSqoEAqAXyMec1EXHkKySjOxm9JxLEaSzeQWvbd3LJtoM8ek2EJ54tiRehFLuvOWTC7LYLjxZOSAj49hhLaJRFb9Sc7/thu9vtlvu7O4auY7/bUMvMbtszdEInFSUjFKbTkSFFolTX6zVAZBh6dlfXdLsr235UZ6Z55JtvjhwOJ+Z5xtQnvHNlD4VLnevFdoK3ytV8RJOGatfCO0ddkN5kBhstSlX53ve+x3azYbvp2O8GrnyD35IUWxWCRmfcO0AE1hHNudBWZxMETUYzKcFGZQpyceTsvVUJ1BApMaIx8nI88HqaOJVKcQ50KUrqrINaSyZte3/vGDpflFoDIsWVTTzuhIxEoU+RLiXLJ1wrWkpAQlNDKXRdIsVIUBuObytgUcvnbKjYqC6lzJzPJ7q+d79dqE3iJ7SBSGkmbOHQO48th/jTrncmqMMwMPSdrZSripZMl4S+E1JSMzBcykcUiUoNNo2Jry4jKFfXe/rNDTVE4wL5dN18OnI6nR2FqnTd5t0nYEGHrG1fy0WrZKmejTsbnJNTa6HUQkqRDz/8iCjCbjuw2/QEivGAWobvPya4h24cJPUbWbINMuU8O7m4mnOLwafW1mn3KkJhnc6O2w3h5ppPPv0jTo5CtlNVSrVKX1zfNNiUuMcIG0oplRqgqBA9SZCYiSGhYgoG6i35SrYE0o0FbwOtK8fMUVru1lQaKqXOzNla1zF1LpaNlz0CGpwb1A7WUru6oxDof/VcKIC+6+hdlw0NbIbo62Rti0eQugyQFc2+J7pQaibEwG63RSXQba+Q1NPI9uPZEtPTabTWnwpduoDiPNgaydz+ahkcULMhbYVEe8CwtjSDOclSy1IgpJQYbm/Y77Z0yT7L7mr3iBLTKnj8P21AAFwY2213GselfagGAyz8PUsRzP4rNpxTYqL2PWm34+uH55y0kNsXv2W7c7Fqu22dQo2rpFSq2oBkxduhoaz8tGTT1cUH/BpHSXHtVSIxWZIQWhFZWe6pOeBKCJmcgwWyi4LN7nW70Y87HO1+VeW9sV1bvYvxNbuI6sR+N9AlCGLFpwCnMvmmPB9Kq4XdzkCAfrOjxo6mSXg+nynHwuFwZJos0NtqR/uZly3lNvze1EgMYSkLPegizJut1WqdFgcGSjEkMsTAZrvlarfjye2Nx45A6owy1VLbSwSsoSot/5xnL9ZyZhzPdmYDlnA0mUD50203DQNxt+eLN19wqJWMGheuDZZEQ17n2paTGMgAlmzM2TaVKd4FJSO5IEHpUqRL1h0sTdBXbY5AtZJd1gwJPicB4jJSgnh8cd9bCjnPNgiXukU2ze6HB5YlpZcLDMfTpffAdmudCVRSNNvVOjIMJuskqCf1SoxC10VSF1FMV/b6eo/Ejs3+irnCOGdyHpnmiWmeOPrkekwdKXVEVqUSdRjT7PYimKsu/uGiHFpQ9gX1XKiHliwPw8DHH39MCpGhTwZu7Ae6rmd9eXGggQUnWG1XmefZlWQq8zw57SaYeEuInivI2ktr6UAIxsHfbemf3PLJ7/+UN3li8qHToNiih64t0rHOvEqz2wZuNZTdbLdoBSksVGX/eqv1rSvbQC3VsqiiKOZnq7bFPlbsl1oI1aiOEoRpNoWFVVGmGYV3rGQFCC7+L4/88Hdc7xbqjyYdJbVQy0StI7vNlq5TYjSeQgogtvMOiXZQkgCaKdWy7dvbG4btE+7PZw7HM6eTaYlOefZhJ8UEctfJxcVhPrrWhCjn7GiUeVNpmap60uWaX5blK13X8Vu/9VucTsbh23TR2g4XUV5V2pTUmtl3PnntSUPOszn7UkyoKQihS5S5kqVNwjWUMVIkIpue9OSG3Q+/z09//x9zCkpZKm0L8kO3ATF+bUoRFmNjUWMwp+8FuPNrUnY4PfoWnVKQxpdUSw6C62cuwyY4Au/8qFKtajLR75lcrDWm9WK6u2XgHlIEd7iygniIUNOv3lECpGiBO0hwhwiCUU+sDW4HVpKQgw0uqGZKzsQoXF3v2e6vCP2O0zTz8HCwVbnTxPF8ohRddHxT7Jaf22gVpvkXloOJO7R5nr2NaBBeWAaEPNA7N7htUuq6jo8+/pih6xiGjqELDF1k2HTr6/Io170Q+NbFJkq2SfvT6chcZtul3Jnof52tYCqt0GsVbwiElOj3O7oPnvKzz/8lh1rIYkH+u2w3hGTOz4OHOC+6qicO1Vr5KjMpBfoOmpRJLmW1OXe0Sl5uod22Bu+5s5ZWYJkihoTZ1gFG2yPdCsaGmtL+qxe2/Z7Zbi0zQSzQd1GZpgPbTTLusXiC44G+DaOhhTlP3N5cQ0h0w46HceL16zumaWKcRsZpYp4zIoGU+nVI5yLQW1x3/3H574UXCc3uggfkWh2k8NZ441FvNht+/OMfQ622UCUFW6ncpKTawKW0pAEvsluwN5pRyc3vnkzrdeiXz17n8gttd/jeh/z0Z7/HQ8nMS1EOWipD36PAlAt9dGUMfw5afcBUnb2nhVkrwkyw2RrauuxcnR6AgBRPHvKyTjkGf38tiRWlVLkABwqhWGu4k9ZNsMESPM60dZvtqUjjPUp4L2x3Go+IZBs8jRXViT4FR0orGgz53Wx6NkPjU2eQys3tNTENSOq4f/GKu/sDVU2POhdD5kUCoRVJHsjaco5mm8vkvzrPU9vUvdA4PUZ/DBe5g8XHtklws93yw/0Vp8OBILDd9gyb3lDrBaf3eIoDNp4ItzZ5nids+Yupb9jmMJAYkb6zzZTq70V8z6YIJUQYOrZPrrj5jR/y0//XP+Rh2zNHd3tVCS0pFx+gapJVi/GKu0jj9ht27XxcBQnFO1ZCG05tHSuL55WQbL7HrMqHImt1qkQllGLD4rXQRlQGNRTfTr+LoinIggG2vEgX//uXavErE8Js1XMe2QzCfgcplsaSoPcp2opVldIF+hhRLZ4cWnX48uULXh8OjFMm57q03e35BH/4eDWib70P9Qq2LsLf1hrxXciO7rWkUNQHtLC94BqFWuF0PnE+nxm6QJ8GCNGSUvGKyH9accSyVTXGd82Uau/7cHjgeDxS9nuk722qbj6RRCAaPJ9DQEJHSIlys+f6N77Pj/6tf5PX/+j/yAjMtRpUvzALmoG7+HtLCldQzIyjOolfbIJwLlaHZb+dZmjz4mRFKqlPKJUYPXlWoFRSEBOvxxEPNQ5kqZmonX92TzSWIsA4rX4+FkQVLPBcXQ/vtrhf2jWDmq5rlxJCXtx7lEAUqKUwdImw6cEHT6jWWu37nvOYef78G+6OR19PaK8cJKLBE1Bd0dNm74uuJi3gW/tH1PdwF10ciTm3ALV1F8z5BpNrYLPZ8PH3PubhzZ3FqWBc2CCJpoy4CEZ5cK5NaFpt29OcodRMqTOn04k3d3d88L3vMcSO7pzJ04kJJ7wHoYhtfpolUXc9u4+ecv2v/TZ/8l/8Qx6iMqlJTF3arnpSnqNxyG3oCUcxsMl9V6RYGqZSrbilgswLSv04SarEaFKA6kineufEJoCVqpFaraqXAnOe6MKwJl0CUg2xMjfjHvPCq4cY3hvbLfOJFCp9B11SYiguZ9bSdkGlsh16IpCSkMvE8fgAjnY+HO755PMvjfbhsEmUSJZVCghkCfStXVeNJ2J/p5bhiycE4zyyGaLp73pCqDVASED0RHXlbF9dXfH06TN+/rNPTIy+axxv28wDq+1ebhE0H2bvJ5dsQ4Rq9I3D8cj3b28ZuoFuzEzTgdhsV8x2iZEpJPK+Z/vxU67+1m/z8//H/5lDhFlt4UTy86fVNuAVrUgsBPWJRiNyLXI6WnVZnhKkkgSkVHS28wUtqV4HppRKTK2F7G15R1ptsroBA966DZDLTNIek64yJJZqPnuZaWs+3Kkr8X3xuzrRd5UuVZJkotNnbIioucrC/mpLiiYin7Ntzru/e2OzLqnnm2++oSKkZPZpeudrTtCknNY8QVe0hIv8QfDB4Aw4+qk+/KY2GxLEdYbnwnjOJk+nikblcDgYVUF9syRQo/UPG6+zSe+5R1sQ8blYHK01L8DGucwMmy2hTxz1aIBQ6OhDNOAkQgw99XbPza9/xNO/+69x978X6qYnl+yUESOGBR8sq2AFuYif1bWAQbEhpIp3DaELvlFqrkSpS77V0Pp232LBtkS1V1vAE3MP1WUBRW2BQOP7W+IZFt8rUS1nu/A5TepPEOvwvuN6tw4qBWQixsCmr1xvdvRDICUhRUjRkp6F1L1M2MkyFZ8ClJIZx8w0zkxzdtmZBrE3eZiWca+GGMS0PVeDXLA7bz+7WdRqHDWNJq8SBCFSstEO5jlzf3/PP/+93+M3fuM3GJ7crk6Y6qIiTabHP7lXutVlE3KdHXGUpeWUge7mhqvtFbV/iWwH+u2Oznf+akpsnt4wxcjxBx9QfvQRb7QS+ojOVhXmWkkuBKze8inUR/IVLeGpqs4NdxhehFwsW4yL3EpdBhXEi8YxZ/ouQbVKSLDpaWuNQoxt5i6sfBWgLS9gcYiAS4q1HxCaBTXFhvSrnyYFC+RBZroEm40hN1309Yj+HLsgaM0+aBR9elw5HQ/c3R85nTPH48T5NC1bR1abFZpAMXjlLi6CLqHBK17d4yt0L2SmsPMi0bjKQW1AxBh0kZItaB6PJ7784kvKPPPRhx+Y5JDXUnXRFG7FnS6keG+sA8EI8BfFYi7WWJJhg/bwMGVC1yMpoqkjdYlRod/tCNc3yG9+n2f/xn+Du5QoyRLEUsu3bLei1Lza65IDYkMzNUMWc5YiJk+HRi8yjYCvXsHXakkjwSTZpFpbFtSWJIChShIcsTYUvKglqskRXnVUjog7TytIG7LVrOV9st0UFNlUdlvYbgOBbMopYtPCIOSCtctjpOsieZ4o08Td3WtCHCD2nI5nEEP5pRU/7vLlrWBuVAF59D60IU9eqa/KJOr2bcEpWLRGsAnukpU8F+4fHvj88y/oQqS/uXLEx1HSaHZraaD5tuL2q269RY3KVWpZfnYphSIBHQboNxzHmX6zZQ4RSRHpOiZVhus98/4G+c1f49m/8be4i5GaBM1mu3OtpCqmOGFoADXrkngL+th2jcHgiVJx/qA5xUBdbLedsxhto9pczXYTvvygFpP5E0twlt3oGLd2zplhsVtBNYLYxHSjsy9Nv4agxPfDdjc9XO927Lc9XadIyKaaEnzkrdgzTskTsiCUkpnOR+7v39Bvr+g3VmAX96eN+9yKStU1QW0SkLYRzxjM0b+nAXVB2vY99x1aWBWFjF8tVTmfbKPeNE68fPWSn/7sZ/zWj3+Dq6vdsla1okvHOmBtc9uq2Epu+5pJs3nfWpZOb86ZqQrp+oabmxty94LUJTb7K6OiefK3ubqidh3zrz2jfv8Zxy6x2+yQ6UQpsw8KVqIUQoqE0JnG7AVK2RJx1UZtYInfVQOlWr5VFkmoxj11vx2UmIPPCYdlNbB1bT2+pAa+rM8CsOJTGxdXEfV743WfOGd6pRq+26be3eJPwRNRQVOkT5EYm/wGixC0lyrQ9NmwqV/UdFRT15PLbHw059K0QO/ubsUvLz5sSomqhaBhIfuKigUoF6dWhRCDQ+gXyGtVcp6hKtM4czqcEVxOKHpr09GmIs2glbZ1Ymk7tUPhCOdl9aYAqUN2W8LTJ7AdCFdXpK4zflfXUzcdD6cDZTrxxf0b5pK56na2hrEY97GoSUqYZpjrMHT2g9+mOag29NL4UjkrBJsEh5XXtEB2qsQspBQW0niTORHaXmo3oOoIkxr5vx92DjIpjZ+S58mpFZYQ1+KoiQhJAtf7x0HuV3V1XWC7SaZflwIpKDGoa8haMLahs4JgGzFisjbOZrflcJ7Rs/Gctba9W+3Z20hTjM0trQcVrEBSNS1gWxO3BngJ6/0R8SGqVqn6I6s5UzWQS+Vwf+CLzz/nex9/7EmVJVkmReLINSt6sJa4awIy+yDRUnyVQhEhbrdshg1KZHu1Z7cZ6FzFoIRA2m8ZFe43kbsEp5rp+x1xKlCMDiFqckhNNqRIJsRHA/LrWblo9JjqhPjqSHPtKGho7bKyFFKlBIqpUnsu0dp54vSXFqwg1LYFSVmVErwjIZc8dUepfaItvke2OwzQpR2boSeG6qL6SgxeV9dGC28oerRVhX1Hv9lwHivTdDZUUTEfQVkQaPOX689rBWmIgYih6G14EsULJ1alksaprtWgbfy51Mo0zZ6gZg4PBz799FP+xu/89rIustmubcjSdfIeD3hLYe4C5GqJW73wuxICabtl6LdUiWyurhbbjTEyhEDYbzgV5XUHL+vMuWY2/Z5AgdH8bgVHg+3gaalo8ndycX8ubVcdgYNIVWEudT2+stLBarHUoJRAjcaJRR1MoaHPj9HAR4OWEk0QvVoCEWPy4S1dun7tNMUQ3wvb3Q4911cDfdeToqvLiA2lBlWIQp3bubNfqesYtlv6YWNLPg4nVE1+0dY9ty6I0lrpsCavIkJMtkShokRdz7io2WxbpLJQQC6MX6vRBR/u37DZX3M8CnnORv/YDL6CVTzpqu43BA0NKlvt9pJnWYqhrrVxkRErJLoO2e1Izwqh64hXVzY4HqyLLEPHYRx5kSe+uL9jEmXfd4SaEYnkWm04NUak1nXLlcSF6mmb4EqLTH7WnbstwehZtck/OZBCvbi3rYvhgFnrpNCScPO9Dbiu1YtUFfrNhhCTUWiotPXoWmwFdb0ELyyKvtOm3pmghmAJapes2uiSIFKWdq9NgyvLLnttoUcQF4Y1onm+2OzCmtXTEvvv4pviIv8rn229O8bNi0EcKZMFXb1EHUvOED0gl8yTJ7cuZi1eTazGvxCs3egXOJrmLOvCFVoqB3xStO9gvyN3iXnoiYNxaaTrOFF4yIXxdOT569c++NIeET7oJdSc25k1Y1rujl2tImmPV8Qqt6pgKH7T22MN0N5iaTzcENwRVjW02AuF9ZdjAkHohw03tx/QdbadBudFnk8PzJMNitmk+bxUlCklNsO3n+Ov4uq7wG7b0XdpES5uB9ijqT2C6qm6RJNT8oBr3M26PK+Fk9ySIxohviVDdoUQTKUCRb36bD+yabGuW6pY9FXtz2Z/xQe28pz9Xmf6vveFAOIJ8gVnCJYKuT3zy5bKpeQS4AOAIF1H2u8MUb2+Iux2pL4jhGi82k3H+XDgTZ15NZ0YNTPEuN6jUm3q9GJYcTkXbz2Phmosf6YJ/0sjVdvf+1BPW+fapkerV++t9moF5WP7bQEfQkx0/eBJ6VoYlLwOL4gjskaXCe+N7XYp2FBGTAaORStCWptTnMNlA55epMRoKxxFmOaZ82gSXrWBAdps9tJuvTPjgS4lk1xSi3LmC1mLguBBWeTyUV74coXxPCLR1lnWUqjFFqaIv9fF3/r7aDQh5OIUyerHV2R1tV1EkK4j7rdGS7jawX5H6HpiisTYUfrI6eEBzSMvTg9MtbAN0XUbPUmW4Ool0jYPPwJL7DPp8vf+1nwQxxJUahtNaeDBChCIF/0N4W+oFnKxcf477FdCYNjsiL40RKQQU0fJtrDApsNdhg6TDnwfbLdLie1mQ5fsZgbX0KyeoDVQqNmsuMB77CISA/M4k2tLmGRB7cz8jFJl6jxxSehjjDYHom17l+l7LjYLy9zBUjQvrtwTsJLJx8Lu+tYR2cjt7S3DsFnXWDtYZIOsFwWe2614sWs+XMhaXW2iDbuJ8U9jNCnJ/Z4iMPc9aegJKSExkgMcTifO5xPfvH5NEVySSVxZJ7vCQfEFGdC6GY/hdf98sn7o6v6gBYymE83iFwzLD0GWOYbldrXcYDn863R+y2dEAtvdnt3uyvOG4L7KhoPH89lWUJfsNqF2P95xvTNBtYcFKVo7ojmolko3R5ezIpIuEkQ7wKqFaS68eXPHeWr8vJb0OSivbrBSH/3cZSOKP5gm8k81iZouGBpqCaUu37cK/tsEsFW7dtN/8IPvmyCzZ7q1QnVtOnEv01rla3A3RKwCubpklSfMKsECdIzIZsOpZEJVclVSVSRnDuOZh9PEQODV6zc+1Zdd+iKYkQVbixaSVcMqfl8u0IWWYCjNCF3+BddMlQtyuBuaHfPQaE/oxSELwaaq2zlbAj8mn7K7uub73/8+t0+e0vf9gpgc7l9zPp85n88cDg8cDg+oowabYfsdqcmv5upStKURMXgygh9ggHVwRyWYviOOSkvgdB45nkbO4+Si8y34rCgKLtZtxdlqu13XEWI0xFUsYQjuLAGGDk8sdHkvdrjx9yCUnAlE6wCI8vTpU3b7nXMJzQGqJ24NJFxQGV1fr+3pbooTxVtiqFMBoqBdIg8952RTtfS978buOVN5yJnxdOSbN6+Y20IKsQGDWoyrpW2rTlxxU3UUSriwOyMjIY5gK9Fts66IkNrXrV/v1T26Bi2alFd7Hp4Y0IIZ9P2W6+snDMOGlCIShFoyp+OB8+nMPE2uEGCGb6tj3xPbjR27zdYQtGIcXPHBT8QQqKrtGVvC1IbCzueR0+nEODfkxCkoiyLJikrV6iMQHpTFV8wuwVQvB05MVF3kMl1bQYHmc8+nI9urG/scXeKjjz4ipriaur2cxQKXZ7NnL49e11NjD/JlaUcuWW0MlC6S+8QpWWyqXWQYBmLoOGvhYZ45n4588+YNU8nY6JKhAKb6UAlFQWzrYWvZX+Qe6yR9+xu/58kR3jaF3bpVzRe2edtmj41f7R/uInGQFSjwWBBTx9MnH3B1dcNmMxCirWAeTyfOpxPH44lxPJLzRCmVvuveC9s1br9LHlKMsxhso5J1LzunmZjfRYLbrYFY0zSRa6BqQ2qcEqIXRatET1J1sduAJzISrCXd5JDUirmUVv62IzDLe7bh58o0Of8aYRg2/PCHP2QYhgVxXeiE2p7pRXXlsdq6W/a+ixbbtrdwRQ0Fl2BJetj0nM8ToWRKCfQCEWE6z9ydJkKuvHjzmqK2Ct30zJPFhmpJfy2GtGto4NRqBW31eK26DEdrNTBLl/BTV+qD/1NrgRIX+SlItEG0NoAIeHIalj+DgQLX1zd8+OH3ePLkqZ3FGNBSyNPMeTxzOBw4Hh+YZtsEt99fv9Om3p2gAl0ILqNTqWWiaKZk2/CBAiFRZ4vFMUZStEqmaiLXzJiV43kmZ6VoXB7gWq9iyZgGFvFdN7yYEtEffNtIJT5p13f4ytFMjabpZZLfbVhKXY/REquUbO2qEYrtgXZdsqGjaMNSQQFvhZsvsYOxwPUOY4Ol16XCXIx4v91uOR0OPMwzh5KxqWTI00SMiRR6aq6U2eR+upiIfeA8nU16RBRqcGqC0RraViOtniS1O6bqqIdrlLmeXPQEoWgb1NFVRoZ1WhTFJCI8sakL3cGMWCSy2Wy4ubnl+uqalDqEQB8TT6+fmbNQ0z+bJhOeH88n7l5GfvbH77S3X+q1ttxxpFLIc1kQtBg2CNEkaSQ4MzRyPI8cjkdO55G82Cx+88122/2/DKrR6SNdQ1lkbQ+1CmBo7e/aBghWHqt4pTTniSjCPM+klPjN3/yNBf01bU/7saUsGQoSdUEmYkwLkgnCrIXzPDHlmdg3xQH7zFMyPt+hVqbTyFBhqIpI5s3pgcNpZEvgxes7VJVxnNCiRCJTmUmqlDzbLvZF8NEXHYj6VLa7v5aEY9IowQfMhAskuBUP1WzX9PZYzl0xXRSjT9iaNUcGrI3XHsf19TW/9ms/5NmzD7m+vrZ7XG25xziOPDw8cHf/mlJmjscj58PuvbHdlXeHFfmTyRWdT2dEorW2Z0NMQopo6BAZmErl4XjiOE42OIYXNOsrA2s34AJsoeu6pYsksqIaC9zgEKHWNkTUCiFZbFNEGaczcR4AZb/f8+GHHwAQoqAUV3bxVr8nfm09aFvs4vgjCrZ4YZ6Y5hlJLaEOFAnMIcBm4FANue1Kpc+ZIIm7wz3naWYnibv7B1SV8zgiCF3sOE+j3Ytia3ntUEZqDRfSg5cJs/1bVLAYLn4b1GWULObYKIauiOqCAJrmqlR8DbjPPjWN1YsCdRg2PH36AR999DFPnjyxeMjans45czodyGViHEcOb/r3wnbtXCkpKlptTmO/2/JwfyRIYr+9YTwVUhK6oUMlgSTG2ZY8ZM1UiaxNpWagFwVRA2AbeVHEhpO97Q7JXI9rd3a+pbIllm2tentdKwwsAT083FPyzDAM7Pc7xvGEqKHuEiwXqcFb3iK2UEhkaVv7KwKmbtKGo7quo9bsPGN759thYD6PjJPN5VSFfrPj/v4eQuR6M6BOV7q7e8PV7S1XN9ecvxmpUijOnSWD9GHlPQNzo4JcFOx4EZRzG5Y2kw9xpUs0NSUI1pWt7Rl4hxxQMZ7/0gUE2qpeiYF+s2G727Hd7OhjZ9JcCOIyvcYpn2l0t/CXQVCHwXbpooVaJ47HE6fTiXmuoJGu23BzfeWcpYS1wo38XFWWNk9pMgiebK6BviUR1RAZjGTVNhis6xvb8IgboRb/WZFaE5ptk4mkDKgd5mjImFbbrhKC8NXXX1NL5ub6ivjkxqosD1zRSLXkAqHrlyNh771SqpLrzKwzTpf2XcvFE+AOJRBcM3McR4qadmBItqmkIUoPb97wwYcfcn11w/mbkyFb0QnzvvVGkqELAhaES10rpDa8pCy0ieZP7WcJNNHh5TMYvF9QVDNCRGqi1rDwpoo6IyQEYjcQYkfQtuGjpwsd2sZ6FUjKti9M88gm7tCT8Cd3v/pKHuA8nri7L6RoQd4CUVzQ/r4bHJVXYgoMqaO4+sM8Vea5kstle291aoC3dAxx9Yk2RFyBIYgHHht4WqIVVkRoDdTsq/hEqVKWgIUnoZRihYk7wdevXzH0tnt5qD1d9FKsig8SYcsGSlyn6l10vEnZtIG/gqH8uSpVA93+mnk6M2JBRuaZGDuOhxMhRvrU2xHNhfPxwNXVFdvtDc9fPreBKZ8MDxVq9hV4F6ia4c3LrVuG7FJSGzZRtSUVfk4kyHK38RZZqRUJds4pBSEZalbX5EFpGpjQ9QNd35Ni8uHJSBcTROjTnv32lg+ffWRKILXw5kXkn/8X74/typvJ9TeN6jH0Gw6HM13aEG+uOBwnUopsY0JCj2Kb/qapUrLdq4usn0XctF3B0CZoq1UtWTLUyoqMhp6K45la3XarPVvTpHVbM1gUrZXz8WjPRdWS//OJ6/2OfujoOlv6IN49soUtZruhrPzA6oNR9UJ2SsRap3Ou5GpoaLc1252xYdjjnImp53QyYMBsV6FUzscDt7e37Pdbzt98ZQshxHmFbt+S2u1ZiWcNi8Fcs7+/FX3K1YQMgg/+BAyZo3ERS7UWPYpNW1nLudSwJLAWGwMaIjF1xM432hUhxM5kwSQgKH1Utv3e9LhL5bUGPnkP/G7JIw93Z9AZW6QjbPo942g0hO2m4zxlOo2koSPGHpFomui5ekeo5QirrdoiBh+fk3VyHhHbB+95Ql2+Xi4UD6xTUKrQuouEbJudtOUaVpSM55FSDCB6/vw5b16/4qMPn7Hfb1GtdCESJVk8cftPMToyvPrcWox3WgXUu6/Fi85azCfHbmDW4HkD1tE5nymlms/yfKFPHaezgVixdZrVOgCCieuH6nJ+bdMeQPAhUWDhNtc2N6TO4NGFeiM+t6BqdB8toNVsb8pHmwVC0Wq5mNWUft9FjZMriRS75ZdIRwibZcOmYHTRWjO1WK4W0rvn9N8tM1XVblxWSs3Mc0XCQNfZ7t++3xLSzt64hEYPpUt2Yxr/qX0QYTW8BSZvJiXiwsstpKk7QYeR/UvN5/rrXziwgKMrGcAg/RBs0GSabIXnV199yfXVFVf7nVsuPumsnvSZCP6kk7lkEd+4Usk+5WbGb4cohiaPZaLNwbkpi7EWXT8/tr1HfZJ6mibS1Pn3NHjeXkuQRxVRu0fLc/H3W0vbM8xFaelS1SFim7nWiq4iVv2VSo0mrxKc01O1sGxkCesucCsMEkIHkhztkgaQoVoINVI00UtF8i8Yy/slXe0eZ1mdxnazt6Q7dLa3nI45FwJWySPRk7bWHrWg0Wx24ct5tHr0bPwZNIFjEdYBkKWCWG3fKAZevdeZGgtJow2paLcMs03TxMPhnlcvX/Lxxx/Sp2RJIVDE+NAh2GYcEZgx3qqC0RtUyWU2jvKiXLG23FUrqUvMs3n0qkqZM6Gavl4fbQJcnRs2ns7stjuGTVqE0q215XZfdSHvL5/XE6UW5Jv9arngSDVeWhu2vECUtFqgF7FCUdQGZ0ItFM0YnSgsPiKE4N0cc/RCJEpv0lxtuKFW6LaU2bYTTb28X7Y7V0zpwPRdb25vOY8C0oEM1iGqAMnXdUYrqJzi0dDzJpcEDSlZkdOG3LVg09hZS6C/nBSl+Vsb3BGarMzMsgpZbNiwrW4+nc+8ePkSLZn+h79GSpEiLkeohoBrWHOS2Yc3DMcw/t7sW8l8etM0m+Wx7U6TddiqWnJR1CQBYzJFjbYBZzyfmXc7p+GEJclRXMi8GioGDXXyovEiWTJUFJfOUQ/Q+LY/SyAXUMUL+VJh9q1CVDu7tla1gQguut5iXoy+ocqGeQMdQbpluBOpjsJOaKj0Qd8L2y2+dlOkI6iBH1e3H3AaA1oEQk/qHUTxDV8ES7aWJB3xmB8WgOZbqbfnE0tq73ZrazSb/dtl1DgD1MC7B1qY55kYAyEF43mnjpIzUy4cjkeev3hOniY+eHZr58QlIHPO9nMCiw7qOE0rz1ayJ7kzqPO23cCb/7VBu7AovIApNFhbnRY1FkUdrZXpPBr1brM1RaEFHfXh8VpXcX2Hi83frhBLe81HdICFSriCgXb/6vLapfgSGQGC6R69TakC7yCGaPlLsSF7we3Yl1UIQpSIOqVGw18iQZ2nmXOwtZCKImFg6DdAIIaO1G2Azt60etVYK1HbpBfmtFqrXldiubZktQV2eHRzxdHW5hr04t+WKHgSiDpPxad/XfqhBc6qhXmeOB5ta9Xtzc1yE83N1pYxLImw8ZOsPWu8lEp2z9RkhFry3FKOEIIlDw36lgC6UhZqtW0u7X2N80wYJ/phwzSdaTm4tMSofdxHDnI9xoouO8ZF2kyDfMe9M/Q0l+rApz2cGvBpWlkkJtqUbgyR1Byk68S137cEXTC5JtVgm1QIJJlh+tU7SsCn7wM1gPHOIt1wZckploya05ox2RF/3o5oWPvBJqTVJ2nX6C6XZx5Yg73VCW8xwhYvuwoiu9CUFzQeqEQbbdW+thp14uXr1xweHkxmqiV7VX1g7/JnFbQ450tgzubo5+yrR4NAU3lwB69qsi+qNsVNqV70ZVeNMytqLed5NlpHN9i0bqnzcjuaJrFNdzv3sSX3SzhpxaC1kBqnUaKsNxC81bQmC7UoWYoreYDUatSMWpYBwnZ01hWUkYDZbQy9/Tm0xM1QhFBtGKgThWn6ixvcX+GVi9p2LT9zKXTsr59yOitaLdDHBLaZx5Pw4OoFzsOTEAmEZfHBhQnapet/3g70rUGygAoeipaiSh0kqBW0uM1HQjREKdfMPBeOHuiHrjP+7AUoUPwNGYVPgIIGKwwbqpor5DyjtMl5vAugj2zX3nsA5yma7cqSfOZsWw1LLozjROp6hmFjSURwVK7dD11PU5sDsHPfOlVmp7Xqcr+CtOzIbmKQ6IoyhaZ0ksVXUVYrtIyqE1qaf9FiNf9rXM7g/jcZSCBtFkOJIZk2sChJCkznv2Ir/PNfqmJdi9QG0QLd5pp+M5OnCtKRukBM4gs91sInBNNeNgjb84RWDUh9O89i8SjNZh/53GbVl2mUfQ9qNpRzxjTTzXZTFzmPhWkaOZ2O3N3fs+l7O0cu/N2oN8tbc5g2e3FgRbkP1xaTLwsxLEPZj6TdxBYhtVgvEux1Vg4D2ZVSVJVpmggpcn1zw+s3r2gzJy1nuLTbR7fhUc7QElpD9yV4wep5WFvp2xKPWpXZlymtlLSmZuBqFVUWu+xSRwrJfK66uojbb2iDaiJQA4qvBw9/iRb/4f4IxbYo9MOGze4pw/aKabIhn6zW7qnFptCLTxaGFI2zCUgI9MNASIlp9ocnxT6ANA7amogud/PRfdZv/R0+16mCyTfoZXLQlv+ZaeZizvLJkyfc3j5hu91aAPNhFfcbNtgd7Q3UUmh+B/wQidiGokUqSJcHXkvher/jPM3MCpqUPM82XSum93Z/f2cEZQlMJRPyzEcffsjrVy9R2uKCZrDrXTHCvfFXDNBYD7Y0/dTqDWXf5CML98mqmYwa6imAGqogVEoxdKoF+RijiWCHRJSOJD3x/8/cn/1asm3pfdhvdhGxmt1kc87Jc25bVbdYxWKVRNmgZBgyBNAWBcM2/Ga/2ID/LfuBLwYMG7ZhGLItUID0IFMiIMmUxGKxikWyunvvabLdzVorutn4YYwZsXZmnrz3sqruzTjIPDv3XnutiBkjxhzjG9/4hhqYV33XJUAHDfKk/NE4w3Q6fcikfmmHcBg9TdtgvZQbLi+fknSWcYyZHA1WxvOolp3IHhkr0mihOFISJ5KKMOaEaC8bfw11qh3IoYT0pVJQcVRZXxlFm5SjagV4Srp3azneWlHAmOaZU99zPB4JTUPTtKIQoE2DOSf1GPL+KWco0qVeHba1TpxxKQvaLqPsFjMieIdRGZeKstX3MEY6nvt+oCZix74nGcPFxQX397e1nwH1wnINutnqdzUAWJ2oQYONIhtuFQARDnQ9zwJYcjJEo2ufVlq+tZWvWht/Ku/a461bBngIHUCTLR2RiBMNV6ebliMynX71mzxI4B5CQ7dp8U2HsR2bqyd0p8w8JjANTRtwDlwjJc/KfXTBE0SigVwc0RSoShPKMTNn/4aHd2UJys6SA5Cgatns6w1QQKF2qgN0m46b2wP9aaA/nUgp0e4vZNyzk5HMVRGk3u+iNiYAgPjlGKU6sEhg2epwdNCAnpxUrjRp1suK57abEv3pJNfgLMM4gnM8enTNrW70Z5e/2FK1XalH1YrKctmLyoS6U7IGpkuJtRRE0gdKKkvDmUHOM5m8UG8EnZLgxlqjvlc2eovHuSA6zQqaiOiAFe3TAt7MH4Xftc6z2V7Qtg3FGMbo6MdCMQ3GZaE0GG2mVJtNqsoQmkaROa86nYbaDEUBWxw5xgUJMLpeSzOznMGZs8kreLNUtkBusnIojbyPtTKY5Xi6ZxxHYkzsdjsu93u6tsU7X1lca7NyNovmeGHlttaBOYL+mpXCovYiwIMEsLv9lpwk6QshME29BOoKaE3TxKxvmKJIXz26fsTNzRuV+pS+maplWg95etWvLv+vYEhWPyAUm2RqQrhmp0VL0jFlTv0gZX/EhtFrijnhksEViQWcc2y6DU0IBNfgfYOzAee8VJo1iJUgXimaQKrPy7ccP0Oo3yBdXJ6UHcc5c+zv6PtROCMIL2meJsZhIMVICJbPPrvm4nIHWELTcnV9zd1hIpPAFkxWHkdRGL+wZMj1xi4POtKJviZQZ6mUhSpCJ9N1WLKukiFGcVSb7ZZnzwKb7VaErb1XdKys0LNZlQOEcFcduLx/5UyE4Lnc7YQRq0YeU+LNmzc8++QZRafwOB2bV9+3P/W8evMKp2hVIZPSxDj3MrHhoZ/EFgWhjFIleH+5QxyqsqSKSD0tt7yIsSVTg0qjEYAlapefraRvfWOj5dEmdMumbqjjQcWYq0Ebqn/PWu5wxPHDFvXLOrpuS9du6TZbfNsxRcOruxM5Co9G0CWY5oGmsRQT8K3DG2lS2OyE09wPmWxlYoaYhNw36xw1RK2b1yrBAXDe37geFUG31slM8iJ8Y4qgiMaL6LSzThqxjOHTTz/l4uKC3W6nAapu0FVjDrERKXGtPKScovBYc1wcdVHSpqud9GojVxcXTHNkmmaKd6JBqNc0TROvp1G0CIMIkGcyTdfSzg1Jn43lMGdJp6m2m1fHqeccY1yD/CjXWgciKHwrNlyQYoRkvBQ0o08Zb5WjWvISc226LcG1BC9/6iharzQcq8FEDT4o0mj4sdjufr9nu9my2W5wTcPL+4HTn39FToJ2xNPIMEw0wbDJAesN7ZywLnCxv8SHiZhhnAo+V6Q+y31aEA9VeMjvq3jo2i9fK4IKZFcozmDtSkMxRjnXVkZ+iX51xgXPD3/wQy72ezabLc55RbCzBh96m5fEWTfQxZbkxltT7VWO6n+y2u7lfs80R2a1FxfzQlOYppFh6MFKslZsIZVIMeCDW+RuqFdszLfaLme2u0irlcJcolK1pLPfqEPICogJRiTtqLU5DMC6JNMJ5cYSjKfrOrq2I3jd6J0I8J/b7iKDmKwGvuYjsV1HSoaC8Pm/fP6SYHrR+M6FON1yd3dgv294+uQKG65olDN8cXGNGyWuGCf0WRY5pZQKGI/zFaWsA09YTbWobz3zulb/aRuL8frcc6baYo1ysWW0d4wJ7wOPH2/4zm6LRfYCofKBBL3K/de9f7XUFaSQEn7BW0PjPNuuW7Tbz6up1xeXDMeBmJIoMSioYa0lzTOvTidc8EvCNKfIy1cvaZpGHGJZ62dVFKbGJclI62idzFePutUnnRpnLYvPrWN4q5hlTvosWFQeTOkEUSZleaeNmip517UbvGskyVRFB1FZMBoHabXDOQHkSl6+923HBwPUjGOaEjFNMGRKgHkqjKOgNAJ5i8ZVirMGMC1zmplTLW+LLp21GesMjoJ1RR9mL1lOLW8sASK6yemGZk3t0ZXzKnFFNnMmGxYtuvUuCHetzkfe7/e0XYs1VkWE1UmbquO5ilCf3U4N8hK2gC+Gtli2W2iCTNwxdpX2SSkJUuA9OSeaJtD3PU3T6rjX14CoD2SE1zv0DzNfYzToq1wsa3GmIAyXisLJuZUiD36KOqYwJpqmoVgdmFDbIbUjryIgFiH1m1KIJp81sVm89TRB5nTb2p23bGhldcKmlg6LZqLyQe/f8H75xxgL9/3MlAfsWDj1hcPpRG0WKbnQH3pSGtlfdDx6dEG3aXG+YbPdM86ZGAecjYKuqmZm1d7LZcYox2jdUGuShaDY1X0sHsKolumaZtUyzyLjkQV9jTHStC2PHgfarsN7T9O2i+1CRdlXtF1oOEX5ogWdSYd1juADbZvZdRtqxyVGPudwOHG530Mthzu/oDvOOaZ55pvn3whvr2a+STqJq/xKvb7FSWq5X8KR6iTraw2r/JkS/FMietnoKx9cymmChBQtlVX5nqzZf8xVi3k9DWd0pGZNrjCrpqSeYd1cpElS/MXHYrv9MBPjgdMYwQe+enGAJBQiSmEeZ47392w3DZ989oimk4oViH7xnCHPWRU8DLUkLnZrNWE528jPEZQaitVITL8WX5AfJN3WFIzSXyoNwxrPME1stlsur65puhaLoWk66R6WmqoIqtdgC85BW/G5pqhMkVXbb9i2naJSsqnFGLm7v+PR5SOE8ykbYs6CvDrvmaaRr77+Sjibes9TShK0yofp/9+1XWuEp/+u7TpBVbOcY4qJyU2cT+NKSZofSRawQjszkmBYNVbRMz3juwPeeg3k/ZJEmAWZrX/k+9Y6bboqH4XtHo7S5BPCiWQCr14dMQy03kHJxHEmxYhzmWHaMEUZey73zWNtwpgkdqJVoeIk4YFCSaOsYZWdXEy4YtMCxBQFtawRGk9FOWuAsNCk0MpDloraNM80bcdut6fddGK33ou8mq0wQMYpD+s8PK1vX8jkGHHe07ZgnMf6oO8j9zSnzDzM5B00bUtQqqL3DX3f07YSL7x89UqCXfX3OWdOpyPOW0VBi8RP9cJy0UhVJs4JA9DoVmC0h0ZAjNprYMhqtyITmrPYrdd+mpSK8Ks1ArZGhtbEmMheteiN2LhQGLXaochupcKshQVJautz9H4YZz0+GKBOc5RomAIpkXJiHGbR8dRNMMZMSRnnLE3wtG1DncdcN42abbrqCFXDby2vKGLprGaKFW5enVcFpwqI9MNZVosKl5szJLAodC7Zl5FpDT4ox1KCVLFTv5YBWDO0M1ISGaPjQEX7q0lZJ+6oQyqy8cUYaX2run+e1ATGcWCz6Zjmmfu7e+HtqU6eaDMmfR8tAS0BFKJoUB2bZn5y/dpIpZzfkhMppmVTpz6uyw1Yy6lLKUBJ1SVLNlrJ2d57FYV3q3aCMYpc1YdSJbcA6jmkmZQnnPvVO0qAaYpyTzIUEodjZJii2mWhpMw0jXhvtat9FeVfeca1BCTvqeEnFCsJg3KJBFXWny2biAZD9UEw4uSqA11mztdH1Kyc1FKM8rJEaq3ruuXr88Y8FAXkHLFEA9TqwDQwadoGjEy+kfcQJ1tlawxWSO0aEAAMw0Dbdip1cqeNGbXkKev3wL0YZGOpJMalyeatQ81Sqs/a+JKEFyYVAA1slZeb1amtSUJW/qjabl7RC6GiSJC9NJXoPT+/Q9VV1HTBmPLR2O4wRuIcGadEMo7+JB3Rs42QM3Ge5d5ZsZ+snccry6QmldI/UIPAqgFayorKyOZxdpOMeeeegtCDVlWVlddXFv1PASskUS80jafbdDRtC7mIgH7VUdVEoSbA5/JjS+WqCA3Ge0+L+J85Zilz23V4S4zCp/M+aGOoBDynU0/XVdu9F5DDCDCAkYl4Cxaia2Bq41O13bOjLAgddfCUIrir7QpYIhaVc6bYvDzL0qiTqRP5yBJbJg1QCxJcBV8RKKcbv5ybuhp9nfqwumrGfBS2mzKc+hGGRCpC6TNI57rRfaLbdPhW9UBrA46uJbB01C/3RO0Nw8KnrhWoWqWU57f63SWrAvXLlbYha1UHnKwxSj2PXKRZqmlbqcgiI9sf2q1dutKXoCSrQ1NgzLoi44Wtw/pMMZOI1quOdWUgpCjIqTVWNcmlWtW2LdMkfTPBeVHg1DXIOsb5/KjbvApHSCKfkestNcwyiwxfVkAgpYSZtTnLyuCKpbenAmTUxsWsMZtU6lLUEd61GqgqE2tjtZHkX+9I7REq+nybxX4tHzo+3CSlKE4NKnOUsnkV/ZampIR1lm7TselausZL92wtwRQhFlsjXcW2VKRSyNKLkxRRLiAvumRSelujg7UDV+dwmIp81IApLzejBgBJI3jvA9Z5LHoeTjsuMQsfb3koaqSA3tyipXMRsaPJZZlvDQZTZOOOMdKWRrhtzuncXkMIDSEEYozsdzvGOK0ZXdENt7A+jFUSpnbYFXHmBW0QqRt4lg6/ktYhCLLW2o2vlitkZg1ajUwRKlknWGmWI42yInvRVHme8w1ebFuDYtZQNSUoM3EemOdRx3/+6g/JzBNEGSl7OM6kGqBLyyR1rGloPNaJPBPAIratCGlFe6S0A1CWjchYaS6qzRrU15wlVPVra82C/Mta6qZX1gCrIiEx1TnTQdBA55Vwb5fhE1R71c8QJ1SUz5Y1uUpKCxA9v03WRr/zyT6KQvrGL8FpQYj5XdcRo6hgBB+IRUqeGEFRvfPrRo8Ggpnlgaomzfn/1ambohUQtd+6yddnUOg/WWMWpQPVgFXMUDeWstw7YywhNMrXq/N6lvSdGlyt2n/VvsvHY7upkGIil0jMjpi8CNvN08If3e62bDZeNW8rt0yVTIrYmjS3Gq0OaSBqYWmUg6Xztx7nydLyPcOy2S9JkJCFqcV0k6WKU9DhJorae+8lQNUy6fp5dtG4Ft8ieEp9FopiFqvte0muXLXdqu4igY4PAe/Fv1kraE7XtcxxZhhHmqZRzWhRs8g5rTQs3m+7eqlUb1f039WvUrT/QDmFNSilggeaVEkAqs+sNuWK/zZLclXBkbZthX9qtIJFrcIIqnyecOUzQOZjsN2CZZ4noS2UTEEklGLOeCODG/YXF4RGEgqwyzUklRWzRppuCzIByhq7cNyNFbqDmI2lTk40WlIHqywgHcW+BKh6n+yZXkKpflTWslYgnHOE4JfStHNGA1Q08VtEls6ChjVCLIpiNk2Dy0I3SYUFPVVeouy9MWNCRY/NElw2TUNSGsB2uyWVqL0LkiiWsrTY1oWHfPadxXbNme+reh4FtGdG7FZAsqy9NXWoytpwuT7zS6tBNtr0KPbojKVrOhrf6nWKlipL01VdZ63UauO57D9/iQDV6PBn50XmIg0iAp71QgWtK1zstlxe7OnaBkOmazzBOeYSZfNLsiF4ZzCa+VhrCcETQiC0gaZtcK7h5uaG0+GeOE/YphVE00pAaZ1wG6Q5XrrIDTDPE9Y4RVHFnWR1cnWMX/BeHgqTF5SlSoKInZWHMHSuiGbNrqV8alzBOK+NVjILWxyuWzKPlAqVWlGzQxc8j58+IZeZfhS+bpxn+v6kXabrrbQFQVI1i5GoRjZbp+co8hNQkmRApExxljRH4X6ofFW1zhKTvI+tWqcStKYC2XtKFnSidQ0bv6Ft6pi3NYhJqghoTdFSGIxDDwzM05Fxmil0HzS4X9aRioVZOV9Z6Coxq1B4yXgK24u96DMGS6sZYElRNpsoD6APFpdXgreMbVy5uKENdJtu0QgW5BIMRctCZnFs3jq8ZqqUtRHJVu5PQREXmTbWth1N0xKUB2WQ5MovCGpFC+r/NSDL6+aJiQSUD2dFP3KhbSDldIuV5KptZBSwE6Tp9vYW74UrW0rh0fU1h9NRUShFcUpahEnqUbIBZ9ZMuhJ0tMHAYqXsn4SWIuhfwUyF1NTpb9UJJhbIyhgVVM0aqEpFIystwhRLsJ7NZqs6fPpwW6t6hLWMW5O2NdCQrx4iE7+qoxQj0n7FEIsl4dUmE94U2q7h6uqC4KRztjZiUArEJEM7jIOw0nSq7VpFVK0zuCANOIfDLZU3V5P2pIFcTVKdc3gj4a5wfpPEWpoYU8SvREXEnAuEtiNU37IgUXKNIh+sDaqLPa62m1LCWHk+pJrg2WzqNCkr9JEiAvbzPNM0MtbYeacKMtXPC1jy5NFjDqfjIi0V46y2WzS+UBkd3me7RYNK7Yco0gQYoyDdOWfilEldUvUIlF5VSAhFyNawxmhHgQF8RbMQ23UN282OpgmEOgPe6Fhjs7JYReMaRSUTKcePwnZLQZUJhJYQggxE8M7StYGL3Ybrq0soibZp8C7oMBoZY+xqAOhEgaLGCdYKmLXb7bBekLlSDK9fvyCOE2iAZ6zFWwvOKJpndIiCoIXRZGmCLpUG5VVF0BBTFBsPAR+C8jyFR7pyUCVOqLJo+XzNz3yuw1FcJGdwvlCMp2naxaLECzm122YZIlTBj/osx5T47PNnjNPApINWYozM86hhgWru5iSN4noPSuU75hW8WBJS1kpzBQ9TSrjklu9BHaWdaye00C5qomBUQajIsxOs52K3Y7PZCZWKKhMmT0xVeDIqXWVLxhrxxil/2G4/GKB2XUPbBhm/mcXJBSulmuItqYjxXOw3bDae4A22CEOnsZLN2JIJmqL6NqiAdstmsyUEmaObskxd+PKnX3M6HJln0fnyfqTrOnzT4BtPMOC8JTQWssWUtBDS4zwDK5e0ZjbGVDTBEZogjkvRBHmdZuV6dw1QjI50LOI4pIPfgxU+hrFwff1YYG3dfOVmS2BhncXV8qYtWOfZ7y/5wQ9+yDSNZJvJKRKnib4/cTgcmKeRcRgZhlEIzCmpNVhtipFrEH1VycJrFlObu4QqUKdPrS6rluONooeRgvdoQGPJs3DJiAhUauQ9sinMKVKleZf306YsUzJz7DndP2ecbrm7N5T0vQ8a3C/rOA2jODRFI7rOEFJkTjOND1xst1xdXeJNwZJpG0cbLF5Lfcaw8JRdq92IyocKIbDZdLRdQ0yJm9s7bm7umAcpK8qItyCTNZqgm5bVZo9CTjMy8jYj/bg1ExZZNEFVhFTvvcc7pxM3iqKwslUJZcDUBJVKwagOrvI5k1U0qhiMD3Q659vqnUUDVGkS8GtyJZ9CaDo++ewzpvmSKU7M08w0DpxOR/q+X6oVVeeOYiEJUmGc2iQyThQ0sNVEriThoJZSyFFsO5ssfjGLQoUMo9D6FQVMxBgr6D+Q5gxBgrLGN3ShE7/hFKVRncBsVlS7WIvJMMWBkmamYaqqcL/yox8num6DNw5bLN4EpmmQOdeblv12y6b1UBJd62m8UxFx1S/OhWKUyuTFdusm2LYtl1d7CoZTP3Dz5obhKN3DTdPKdD0MbdtIgKB+0loLcZJgbAYcUokpZdl4UypC+zBFm1EDzuu9N4JEreytopt+RX6M2KyW2GvTkbM1yTcY1xBCq0Hz+2231jEKUIyl6TY8++ILprkn5USMM9M4cTzeczweVcYnV0xMaFBRBiQY5xbbXSp5CNoX57TYrvQMWHLMZLVNsoxotUZGbyaFdartOuNI0YjvbUGGrTqCbWRkdJ3ImAQUSTGJEDvil2wxTFNPTiNj/3HY7hST9C+4hmK9gARl5GLXCoi137JpGuZpIDiZqtc5sVuvo3qLsRjnaIKU2UMTaJqWpgm0XcMUI/d3B168eMHx/kBK6cznZtrthq7t1E9K4Juj0OBiNJLvmspXLVhFwAUwczRBejCkcUiCZmtWNR/rFOBZ3K5UawFBLI0kTskopQsDJnB9fU3Tdkqdq6V0yzTNkkh5j1P0KeWCaxqeff45MU0UsvT1xImpH7m9lXHjUnGSiV2krMCAVk+dxTlDHRELErjmOhChyDNpncooJklOc0oCRFk0mV2b0kyGbA2xFLzzyORL4QvbEgjGy/NTVqUCSXwrhiJ7bUw903Ag5UK7+/SDNvXBALVpmmXcpmyI0DYK3RoLxtE2DW0TJEvRrNSFFkvGlYw3ht12i+s6yahDg/MyVu/U99zd38ns6HGkPw7KpSxLwBdjxDiLdaJLGbynDYHGO7xTFMufzSI2kkk536zZV4Xta3MJspGKk3QrdC1gCyW7KmLF2hBUFuNzQNO0FATKLqzlwiobUlGA9bQcIbT4ZgPMUBIlRy72Ox5dXZGVEzmMAzEmjqd+aSLJJRLnSdakKBc21/KOlios2thkWPZyRFw4UwX9z3iKdWxU5fOoLI8tElynOZLmGeOtnoPDeCdkf9XJTGlgGg68fv0TYCTNW5ImCr/qI6aRQotznuAsqch4wqZ4muDZdB7DrIlAhtLQ1OlMKqvhncWGhrbb0rbiJL2OCp3nmbv7ew6HA69f3zANo2aj0kTovKftWnz00pHrncyEl7o2WmwhzSrHpuiBNLLUudPiuIIPGugpqm8QjppdBzUo/UnL4LBErTgNZGXzDTjpTD1rICpvZ9PeknLUBE/429fXjyklEfNMSjNxluSqP53IOhRhGAbGSaaxVEForGL/dpUkKlrCXigsRhoBvfPCA9QAC5RSUqRTtMppoaoXQvkRNQZTxFGSlLedavlVghKrGnIaHy3c0zQPTOOR03EkzR/uKP1lHSlNGNNqGVQqVt44No1n0zpCgBhHSpppfUswLZ13mFzw1pKcdCY3XUfXbaS5zisdgML94cDheOR4OHK4OzBNwscMYUV0AlkChIUOZRcEpPqhRWjBWEUr10Yzp2op0oWcqYUgq2Upe4amojz7nJfRFgByb63XsqqgOl23kZnmCIpam4wW2y3uoe2GhouLK+BCJ/tFcpoZhytOp56SxXb7vmcYBqY51otaUCrMmZyWNkUV/dzFdr2X0b3ZUOx5NaF2RStgAgIgWFh4k7rJy0ZvJBhNiZQisxkFbXIrN7sG83E+Mfb3HA8TaW7/mq3yZx8pzdB4QrCq5GAIpuVi39E1jhRH3hzvKWkmXF3idh3BWrVbQ3EO4wPtdsu220iDnZXAdZ5HXn39ir4f6E89/bFnnufFHudZAr1+HOi6RqqzTmIEBxTlZUq/jyTvTjkr1tqlmiX+1mM1saqxgfhcpcpoBamWzE31bxmWDR+z/I4vhu12j7UybZMlXtDmwlxUMrCW14XwIr8jNJpUJlKayTFydXnBPEujeoqR4+nINM1M06yURgHe8tKMZJhTUp8r52Y1ULY6kAc9D0kG83INTispyqCQiptxC/2EDCUWXJFGXxmKE0l2xswSt7lKmyQT88zQv6Y/3lAwtJsnH7SpDwaoVbuOYoS/Y7PoC1qEAOwcm67BIjpdOUUKCWsCJc9QIo03PLq6xG22WB/U2CK3h3vujwcO9wdGDcpyXLlRwMLvIerDbWFyjlkbsryXjMft3EK1rTwMadoKFM3GrZZIMfWWVQdZN34tISoCpSJUGCvTlyy1qUSKNdvtToSzS+28ZuFvVIQo5kgls3vvubi4ZpwiOY0Yk7AmAQ05yaDaFGfmOFOK4dgP2gCSiSkyDieGYWCeZymlp0JU7dTK67LKm6mEUQ2x5W+rWYw622Wh1ISFG4JqCRalIEyKQqWV51uEIJ3SyDTdcjq8YTi9xvtCTu7B/ftVHqJsmnGm4Ax4A1ivqKSjCZYUB+I00jhDaQwGCZoa79h0HU0B325ouw2hacDIRtiPI/f3dwzDIA6zP6rqR1l4lDZGYkq4UbRzg5bKg7UEVxt53OIMziWWhFc4SfIV/GK/lWO9FAgQfpah8vi03GoerkQde2kwuFKWDnewS1mnLFzuOto3Lu/gnKPrtlJhz5FSZnKe2e22TMMgmn3juGzy/TgteLsxRYKChbeedIiCImXSfYOUkdxqi0UvVKsBGdYyWy1hCRTKGSVQbFiTqFKdZZWm0oDeFC2VlsTQ3zGcbjkdI6U8+us0yZ/7KFm6a50tywhmawJtE/DOUvLMNJwwOVJasVtrpKLRNlKitKGl3Wxo2051qTPjNND3PXeHe/p+YBxGpmFaERYN9Jxz2DjKZq2223jRgvTe4Sw6lEG5vBap9Di7cIidqyVaSQeWErlZN/sljzLqp9RG1y2+8g9lU3dO9GGtrQ1E5uEmXwQcSDmqMSDanN1WAuASQf9sNx37/Z6SM7MmV8PQc+qnpVnSmEJKswQD2oyaU5YJaBqc2vfY7gKo6aJKOf6tm5zl+qpPFXstFS6m5ERJiWJlktjCXCzanFUSw+mG/nRL3ydK+eSvyxx/7qOUiDUFZyGo3Ta+YdM6nC3EaeJ4uMVRSLsOUzIO8c/bzYZiLK5paTZbgoJY4zRx6ntOpyO3d3dM00ycI2lOi91W/q+xhilOxFmaX4MTUKANga5rhHtc0ObWquIhfncYRqoGr6CvCuiUVbli0XU2tZLz1gKcAQNWo9qCPB/b3QXGeOqQkiVeWKhdRZ8deQtrLE3bYbEkEr5OGCSz6Vq5dvXXfd8zx8gwTDKxrGRKiQzjQJoj0zzL+OOi/VzU62MZWlTPS25kTazQ3hS93iXPqlU8s9qtgnIl12EZ8qdok7pQESLTeOJ0eEPfv8GYIMMyPnB8MEAV5DHIxZmIs2CtjJBz3uCDo20sJc2UHCFHCQpsJqcBSqHxjvbRjuQa5lw4nnpubm/46vk39IMgposY3nuNvqwRfZbGoDQXplEaU7quYbvdiQ6noYaa2rncSoewlkwNZwjqkr6v/18DVRa4vmCxy46ovIpSuLh4xDTd1SZ2yuI4UAmppFQFsbiu2/GdLy756VdfM48GayLOJZyVgEBOp0OcnSemQkyrEPlwOijaPHDqBw7+IDyYtApLL2M2y7p2pQi53tYuJzVAI7PaqJI+OVW5Hnl6clIEtRMkrJSozVSGFCPjeOTUv+b+9gVpvhf+Zt5+0Nh+mUcTpMRhXZEgVfmiwTtFhAynaWQa7nFNAzlQ8oQxlm3b4kJDcY7QbpAxqIZTf+Lu7o6b+ztubm4EIdcHdGm2OUMix3kGk7W0L0lK23g2m45N27GxZhGx0UcY64QkX8pJaRuK9Bvt5FVHaczaibqYsiZU2odBVQgQZym2a23G+/aso/R9DlMz+spbMo7NZielpzQhclRBgs/dVqsFwqmepsj9sV+mqcQ0M88D4zgyz5G5iArI4t+tFYSjFEXG1vOvF1ebSIR4X2E7vV79uqhTpdSSa6HkSM4zNuvs6oooFAShyiPH+1f0pxv63gAfR4AqlR1JroKT5rWmkSCx5Mw49ozjPR4opQUSJc9YU9jvNhjf4NsOF1pKgTnOHI9Hbm5vuLm9ZRzHJUGQXFXuc93ox3Ek90IxcdYQrKNtW7rWsd3taLzDqZMpRWpIVhOrvHCcjaL2ZRlssiBRtjavVVcr7yVUMn1fRQsNNYER2aCm6YRuxbnqBQsokKveaz0369jtLpliJMURcFjrlTqgVKksSFRMkVMvm7zQASLzNHB3f8c8RyYjwZHwYEWRw2iwLrJQLAFpZaNUvYNKEZCpPbo++vxVqaOctF+jVCWOhEETvLpWSvGa48D9/UvG/o5hsMCvPkA1CFfRGSS5Cg7nHW0wlJyY08Q8HVVtYUY4ZYngDNdXlxjf4EIDzjPPkfvjgdu7O97c3nDSoQ8rsLJGh0uDaZSxpmmeliYp7y3b7Y4QnPCy9VgmBmqVKqWT0FtMtQup7NjzLMqcw2BndCpNlBZ/laXChfrsbAoXF9ecTvM6ia0GgYuNlEVqsIIUXbuF4oSGVARo8K5g2ob1rAzp6hKDYZqTSHep/vX93S3jONH3g3B6rUgG1uQ/lyw+t24glYVSVv9adZOXoCLrpxr78NlLWXopUpLkyhSyKVjSUgkucaY/3XM8vmYa7/BBp2h+4PgZQv2LCQDC1bRkrJWuzGAtjRVyubcGGhnLF1whxQGDI3hHojCOA189f8nrm1vuDgemWTvZs1k25289coWN1nWkZKx2QVq3BrcKouCcXFqMUsJ58+YNn33yyRKcrrPCdcMDdS55cSCVj+nwLAGqEc7sxeUTXr0+kVKWkiYigxKKIRdDTIV5ynjXsu0u+OH3f4Pf+72/zf/9//H/5PbmFSUPWDPjnKoSGzToKDgnpb0alxtj4NE1xhiibiDH45FhGHj9+jU3Nzfc399rwLRyP1Slh2LF0Oo0h0W0H5mIlJKgotbKnPpqfHVZhD+mK18yJU/M44HbV9+Qy4FpvgcbSHnC/Lwm9dd8XF5esN1uZeJKFr5b4w0+GKxq2rUtOBq2bcOmNZQ4kIphv225aDpMaBli5vmL19zd3y0l/SlJ89/53HhjOJMzOQeohR6Si0wWy2mWUpLzdG3LSroQB1g5rsBSeqzIas3s69YtgZp+SuU7gZbTq6MpWBPUIUlC8/jJZzjbCGdJk5SUs/YYCwo8jjPC74PNdsuv/9on/MVPviSOJ4yZcS7hvRLf6khf1b/LalN1rGtKM2/eSHnudOq5u7vj9evXiyQaINJsVd9Qr2tB4605eyZRRFioRsY4UoIYdYNfgllRtzBFqikprzPgc0pM48D9/Q396RtSPJLT9qOx3f1+R9dJg5EzhsaL7QaJSCXAbh1d8LTBYPJMHHs2TeDq0WOKD0wZjqeBH//4xxxOR4ZxZIqiQynGuVI7zsvqpej4aP15TokpCRIdo6dpO0H/zziZuYCxlq4TDmuMnpTiIrGnLhXO7Xb9xDPXbgRsrYhjAW9WtYlsElfXT7E2kCtDxEoTlWhhFx1nKrabEuzbHT/60Rf8qz/9c2ZO6nNX26147Xo5npx0ry4SHN7d3arsT8+rV6+4u7sT/qrab7BWaGimbuwLVCUplLECCFCog0/AIRPpVLKnEfvOUX2IqjVYpxxIRAoupchwOvLm5gVxfkFOp4/Gdvf7rfStNI7gDN5LgOi1WGM3FvvoAlOgDQbyRJoHdpuOZn/JlAunceb27o6f/vRLjqcTY5yIKdVMikoLAkl0VvS/7t0aQyEJi0mFOAsDmFqqfnCUZb+c55nb21tSSjx58gRyxjhFG1l12CV4rXSNsgRzxRgKQlLNNV7AUIhcXT2mP70gxUK0hRCcaMjr85YUFEixUJLBNw3X11surx/z9VdfSsWEmdBEnK2BcVUkkCrbHtE5Frksi+F7mtCO3NzdLfHC/f09p9OJ0+mkfpUl/Fp9gaREtgjfue5z1li8zNiVSoJRSmNKuGwE1S1S6nfaVC3uXACBw+klh/vnUEapxMS/RIBapV9kjrcEqN4ZQrAEbwkOYMYbZGSkZpaYBEY77ouU9H/60294+fqGYz8wxVkmj/B+3PQcSq8EZpTPJtG7NkNZt3brLmiPyB644JnnmQeTQlTCot6K1VHWcOKsNlPTfZ0pW5HZUgzWeKZp4HAYFcF0ON/SWbciUFru9aElNCIzhbH87t/6N/n9f/KPOR7fQBHtRWuhkMTobb2nVmdT17KYlMw80DYNu82GOSU+//xz4f+dTtzf33N/f880jJxOtflqYsozBoOrnZHegk6aqEfSYF8euMQ09pS8x+ZJeFFGSPslTZz6Ww7Hl4zja5yZSHHANsJX+RYg/Jd+dJuGphWJmxKzdDyHgrep8shxrcWEbuEqYTLBBzCeKSaOhxt+8vVzvnn1Rjb3Gvibing+PM7LQHWj15/IOEoUUUJKlOfVePEB0tRSqS3393fknOiahjY0iyzKue1WVtpan6nnctbapvdOYoTC1eUT+n5kmiLOOHwAl4rQFJI4+HlKeNfSdVueffYFf+O3fgcf/glf/fQvBAUxM96P8tnSGqsJlsUQFj4TiNTLk0ePFn9yGgamaeLu7o5xGBj6npevXzNNk6L3iagomK3C26WO6hAuel19GY6xblTWOFW4SKgAiDYqapBTZPDIMN5x8+bHpPgKYyYptX4ktru/2LDdSvJSUhIU0xm8yRiTccEQdi3OWYIHYyKZmbbRkcqHE6/vDjx/+Yo3d3diTxUnPa+ksPra8+Nsv1qAAWG+V/RR5QD1tUZly6qG9KC0j5wz2+6Z3od17vh61FLP+Sfa5Tky2VBUDzQDxSSuLp/I1Kg54awno6OaswADKUOcBRjYdDueffYFf/N3fg/nd/z4L/6EaTxgmPBuouoEG1MBAgPFgVe2dzFgGi73OwrSKDKMowwIUNvtTyeev3wpIuU5CxIbo470VL1ZVcqwxkoXel3jWrHILFJvUWevS+lb91Ir0wdTmZnTSD/cc3f7FZTXWBtl+MJHYLu7fcdm04gWZskEX3A+E6wqpxiDwxGsyFEKOjwTvOF0OPDm/sirmztevr7hNA5Lgiu80Yd2W48HEmnqU1eEU5rMqq63DDxg0ed0LpBS4f7+ns1mw4sXL/H+QIqRx9fXtF3Hw4XNDy34wfkYwFFFqMoSnBqMbQkeTv1EyQXvglTZnBPKVi6QVPZRRfQ//fQZf+ff/h8yJ/hH//l/zstXz5mnA87NeDdrdbfKmKXF31fPWPsZjDG0bctutyPlzPe+8x3meWYYBl69esWN2vE0jisgApRil2eis8JJ16dlCVoNFlscrngMTpvNC0YbeDEiurL0E+TE1B8xzFgTKXngcHz5QZv6YICa4izOxRi8tXgPXmVu6mzamklUmSZBepRjVKSZ5PWbW+7u7himgVk7mLFnGcmSXddMW95HdCjlZ5XfSS17IqPqmrZZt2qjHad6Y1IW4nPTNOx2OzXMNYigyGLWrLeKTlcPXfkghUpkFhmVaU4MU6YfhQvaNJlJx7ymnJWzWpjmkabdUkrh5uaOf/7P/wXed1xcXpKSNIYZlSsqdYO3kPOqH7acq60ZuDo4b1UGRjiT2yaw3255+vgRcY5rgDrPHPpepLhiZDdGPjtMRG+J3oj+Yz9zERs+MbAfXzD/+I427Hn97BG7v/O7hE+ewvLwZ4b+nv50C2Ui52HhVGIdxn8EnhJI80T2MvvbecnmnZNUwyL22jojyIdqRlqEPJ/izPE08ebQc+hP9MMg5G/dWipSWI+16nQmtmTMmnNb3QRLUa1ZfyYkr860BrfGkFIdQSdoqm+aRbxa31x+h7KYK5RF0WJ9sESFQJnKVbES5zzTdCTbQuMbqQJYSyqJlC2m1ClSgbZp2Ww2bDZbPn/2HW5ev6TkCcjKBSyS7FQpqKI93WblNNVGRYDQNDRtyxwjl5eXpBiZxpHHT55wPB5Feu3UczwcGKZxGUvZGsN1cXw2ZEp20vGaC3EeMS3sZ8dmnLg43mJv/4RXf3HL7u/8m/jPNxQyszW4JAnCNI8c7m8YxzssvThL5o/GdsmJkuKi/OC9oP615mOdIWw8FJHVMbCUB/u+5/5w4u7+nntNUIvalWwuZ1vse/d8gQ0Mq0KE0c76EIIOODlL7o3Rio+lH0Z2W78g35JzWbUT1t95++FBk+V6btqEUc95xSJF4/ZwGMhOmuqil8lDJUZylIBWTsusjWEFPn/2BW9eveCQZ3LKOJt0E83L3iU0HbeeBxL01Elb3he8d5Sc2W46mSA1TTx+/JiD2u7Q9xzuDxz7I7FIsNlieFQcXxwSufXgpPElTiOmLeyiYzNF9qcjm/svuX8x8cm/87fxF5dkA9EWkbqLljTLkIFUBmyZlV73cdiuqOrkNQ4wGWesUkCk/B/aBotTkECQ+VIK9/cHbu8O3B8OnIaeOZUHZfNzlB8e+ty3c6zFPNUHN21YKzScBbVVQWgY2Gw2bLcb9vs919fX0nNQ30sgwAfooti46nme9bGUpQKk56lVipgL0zRDFo3umAqhCHKaStZRzSKx571njokvv/yaJ08/5/LyEafTkfs44GxSwK6CJIZcq9BV3WIB+FjuhTEOVyzFO9q2EZrZZsPjvhfK3jBwOh65u7tnmkbGecLEmc2c+H5fSM4xOwOp0PSZtsls+oTz0BxG2tNPefVNz/bf/tvY/U4oC0YGV1Q91lIMUxrRWVSkNNKf7j5oUx8MUEvO5Jjkxipc3zjRBBOJVI2W1R4sdTHk65QSQz/y+s1rhr5njrOWQVlv4hla+vbxjuHpX+I3V1FdltKK0WzeKP+tBqiBtm3OAuGasZ8XYWsJYUVi66dmCsM40Q8TwxgZhszpJF+TC/04s4mFORfl3omM0zhNXBgJbm9v7/jyq5f86Ee/zXZ3QT/cM8UjxkS9HrtkHUsDwLIOdbhBOVsTKbsLYuzASlMYbEkpsd/vuLy8IKXMUVUS7N2Bi69f8xvHgd5m0kacZZgKfp74xGTymzum00gxHYfnL8i/9QPs08daigBjpUEqpgGImBJxThKY4uxH4SgByKJx6DSZCt6opFStGIvMRm3EWJIqCuM0cjz1HE8npnkW6aeimJEx70zyWPCf99ir4ewH2hHptEHqnMtWh1fkIvxlay1d17Hb7UQj74zHVxEnc+4FgTp2VBDamrmqELNyjVMy5GKZpkS2MLcZHwWFTDmJdFyBGGdC2GCtY54Tb97csN3u2O32xNgzqzzKij6p8HLWJFA8qJxzRcSMuHJnDc475dVKWXa33XDqe0mujkfu7+45DuIzYo5spsTnfeRH/cicCraRwCFHKwNFYiK4mcYcsV9OnF7e4H7nNwkUJlNIuhauFFKcGYYDOfdYO2NI4sc+FtstUZQkVIPR21Wj1GpJ3FlLSWfNn9rcNgwDJ21Wm1NUrp1ZE249qjLJu4epoCmV61wDhKrqIuNh183POkcuhVPfs9/t8Tr9rNtsFtrGYg5v51BLYlXWf1OkhIhdef0FhILoFtttQsb7ROOdJJDZKr0qivKFtUzTxNdff0MIW/b7C+b5xDCMGnhKUiWomgADnAuHmwp6yAlbfU5LEfk44Ztv2W239ENPiomh77m/u+fueM84z8Q0s50i3zlEfqvvGWKitJ7irNpuOrPdQvv1c6abA+73fptgYDIy0hcEUU4Zco6UMmGI+id9HLab5TmS6iZYkxdfK8qYRrrji+5daONZThxPJ06nnmGciDkvvEUwZ5Wj9xxLGFF94up3jUHl0xrW0bH5zB8JiCU+PrPdbrm4uODi4kJl/SoWu8YJ6yE2W4eHFPRZ0VeKH8/ElBnGxGEYGTRAbaeZ0LaqJ5xJWhaP8wgGvPMMp4E//Gf/nL/1e1vadkvX7ehPB40X1tK5EcOkcmbPQa01QNWzOksspVG4YbvZAIV5EmDg6vKgdKAJ7o9sv37N3+h7Bg+xkcb4bczYOeP7KLQpmwnPZ06v7rF/67fwpaoHaUU1L0Gb7G0kSklIX8v0QZP6MHElF9KcwEkm5FwgBLs4S+lwkylRtrDo5Rlt7Jjmifv7e16/fs2UHFllDoyxOo/Yrk7wvc7yzA7PyqeV5FvRqMX7VYeijqlKnXgfdNJPeftNoaxuehnDVbMRIzyhaZx5+eaWV29uuL8/MY4QZ+h77XS2E7t9pulgipmQMk32DMMkWo+l8Obmht//gz9mu3/C40dXbDaX9P0dhvlML01RVOcoZe2IlyB0fQDWMYVnhoh9QLL23rPdbjHGLNO/3Fcv2Pz0Fb+B4bYfMaXQbhouQsebV/c87R4xDJH72x5nIvf9G2x/VIOS0oMlgU0YE4FZsmRkCEN2lhJ+9VwogBAsbesE8QGCRxr4WJMpd7Y5OU0CyJnj8Z5TP4psR4wq9UElpi3BYj3e3ugfJlt58ZhGZT18EIFq+a06kUqehZQSs478vLi44PLyEu/9WdFKHHGd5718dq4VhodBcSowTjPSi2hIs2WMhWFMeFcIU5SpP8Fpk4wjZ8M0j+z3jpwzr1+/4fXrO37wwx9xcXnNOJ2Y4wnqJg+LiHPGUoo7O496bQ8d5erLDa7xdOGCy/0eYJGs6qdJE8Oezc0d3//yNX/TRO4H4W03XeBqf8GbV3fkMaqMUabkSJyOhHEgkJi1OSpnsDqRKsYe7Igjqlic+Whs15Lx3hC86IA6m/Uca8OdFhItWEXnTcnEOHMaTgyDVExAmpdiWS3t3HaXxOqtY7lPrPxQa5GRuzWxWvjs4s9TivR9L8oumw3X19dcX19L0kK1XQCZmnduu8WsZ1FbVWvgMU1RhokkwzSWh7Y7J5zPNI1MLgrIRj+OPW2zxWC4ubnjxz95zm//zd/l8uoR43Rimg8syJuxklzBasRnoIlca1lt+XwfQtDtxnVs2oZKSZs+meiniX6cGPoTmze3/GB4wW/7xO14IpqC3zS/kO0uE36KKmGUEWdnFT3/OGzXIPQp781bdivAgDcoMq7sTCE5M88T/XCiHwdpoNRQMOvvndVaNbF61+eu56B2TlWZgK7daAWnSJhspIG23q85ikrDbrtjs9kQQlD09gE7W99dm5L13Yra8nmFIAPjPDOOM8M4c38auD9OnMZZeLHHgbbb0qSCS1lR1EI/HsE0WOe4Pxz5wz/6fS6uPuXy4pKu29N2IgmHiWvQrGv5EHxjqbg9DE7P1kkTL2+FIrlpW/a7HY8fP2LO0rxivnqB//qeH5mR+2kEY2h94Ppiy/3rA3mOCt85ZhLj6UA3zjTAlFnWqfbWGFtl6hLoNCwfPhz3/QyrLqQ8K+JpOZ0m3G4rsH01sjzLIvnauFDVFSGqxIEPDY0zy7i6mKQho47k1CL6h0+FGpcK0imlf52WU85vjfxdm0uCD0t58Ty7WFyhOdO4U0cuAu0OcKRs+elPX/BP//hPuDsemVPBuQ5nNlgnY2D7CN+8usM0QXiEoRBawHlijiQy98d7/uAP/xm/9Tf/e1xdPSaEHW13SYqjBvmiFmDJxCIP0VLCQLLN5QrfMra6aRSVnpBShllKASGIsfj9hqsnl/x7/5v/FT/+r/5rXn/5FcFbfuvf+G3+s//zP6A1Fn99ydX3v8O/8Xf/Lv+Xv//3Fy3JQsG6wjQcoUzSBav6adYYESD2jtJ+BJk80DWeTdvgvZXMXrN70TiVhMo4o7Zc9e3EEl++fMn9kJiLY55HgW+iJBGVv3R+LDzQ9x7rkAODfJ7XCSk1ilub9oSvPQyDJoRuGT26fs7DTHhtJqqf7zDGY/CU4ri9O/BnP/mK46lnjkKo7/vI8TRii2GYCl980TJGMFPG+ozznlM/cf1InsqXr17x+//0n/PvmY0kV7tL+vGAcIlAEk1Fb23lbOs51wDnLRDknGduYGkqKaUswttXKIepQPP8JZ+OkX//f/k/409+/5/w4vk3+OD43d/9bf67/9d/wZw9drdl/8Uzfvff/7v8n/7+3yflmRxnTHGEjQObIc6UMhNCUekVva/efjS2u99tuNhthNOVkyBkJGzOCgSwUlOMWabLvXz5kpubE8dxZpojOUaV1VkizreOb7dbGXgCFZWCOghE1qjoRJ1Vz1Q47OM4PKwQvHOsn1mDrvPGFaMd+6nIJv+Tr7/h1I+MY+R4jGK7xwHLh213txdbfHN7wz/8z/9Lut1jPn36lKbd07R7UXeoQIvSU0wWYKIicqvtfjuCZ0DaIxZeo8M5mWamTdG021d8OiX+R//bv8ef/1f/Jc+//CnWml/MdpVF7ExZ1F8M0jltLB+F7X7IbiUXOKPhGaULes9Pf/pT7g8TcV6boUyuNvjta//u8e5rjVZr7Zm/NDoAxeogFrDEeZbpVt4/sNvV55azsr3a7Zkty/s4MpbDceRPf/xTXrx6zf2xJ1tPypZxTJgCsQy45oRpAsmA8ZnQWYY50TYF6y3Hw5F/+od/yPd+8Df5tR/+BiHsuLr+lDdvjsDM0kqzUA3q9b+LoL6zJktlwGrlRYJv5wyhCfgsz7bf77h89oT/yf/uf82f/f/+a17++Kc4Cj/6nd/kH/9H/4h2f4lpO7afPOV3/4O/x//xf/9/kLU1ZlE3ImeMcTodcZB+gYnl/Oy7XWsPjg8GqOMkhHBnobQOTKE3hdZ7mQoCOOXwZCMdioUCTUuxRpgGRRyFMxrRW4t1hZjzmRQHD7XjzheT88CzLDegUgRKzNSRoNY5bYIyjOOE9xObbot1VSBXPuH8ntWiaDHmrE5rKcYxx8Kbm3v+m//2n3GIWcdyORIGvMHZBusC1lqGOdLPFl8soRhsKrhGuHYpRfqh58svf8pXX33F40dPpcOx2VM4YfOIlXdVtLR2KLJkcs76b1mdMyM0BpwTp4WRrkV0nryB2RRejz3l+5/xL/+TV8Q88PTxp5hf/y5D54jB8vhv/jqbX/sOv//nf8i09Zz6EXd7T2oic0l04wE3JumDq8iMU+kmA2P6MGT/yzru7+8opbDdtLSNo+QZR1EkWFEo67XUoLw1hCeUk84qLqjd5kUUvvKY5fXaQWrOXeM5deQskNTDINSZktcM3bravFeYJpk0s99ul03v/Jdrh/vyacoXrVlaTa5KsfTDzD/9p3/M169umFJCJHZajGkopSFT6OfMi9cHnjy9oliDbwxtcarKkChkDqcDf/wv/pjf+b2/w+XVI0LYsdlcMM+TBqlGgn+KxpnLbCx9VovqRb57LM7Uy2jTumKSDIgGsaFQvOGuJMrf+hF/8V//F/R55snVFf7XvstNGrl8dMXT3/ttdr/5A/6bP/tDptZxGmbafqJsA2aepYFqHiFOy8ZXUZZc8kdju8fTAR88267BO0OKk2hHqj4nxuKtB1NVFBw5ZU4nES/PKctAEeuWTnNjLda4tVpVBAFailL62edb80LFMjqGsv5I4jnxS66WTmX8ZoyJbtedgQKsdlt9r5ZjS0X9Fel1VjijuTimIfMHf/gv+fHXzxnnpFhawFBtl2+1XeMa0d0ticPxwL/6kz/l629ecn31GB92bLbXDEOPZaY2dViyzCM3nqpdDTwYz/rggs5WzRiR6avX58SBU2Xesi28HI6U7z3lj//Bc6ap55PPPv2FbFcSTq1Y1vWXVfxobPdDdguQi8U6yEhzUNGZ8H0/EKdIUUmjamnOroi/WYCsdc3lKGf/F89REfvVXjNGqzpis9J4N8+RaZo1QKu9AU4TsTWpMxoXSMG1SvOtPtdXVZFimafCP/7Hv8/ruwP9FJlzIVuLDzuM6zDIKNibu56w6UimxXWFNoNxQVVPEtM4cXd7x5/+2Z9zdf0JT588pmkvCM2FcI7V3wrNwDy4/ro+1r4NZp2vpf6OtYsyjEGoCY2X6uJcEq+HI+W7n/DH//Fz4tzz6WefsvntHzH9g3+EaRyf/u5vcP03fo3/7s/+kHnjGaNUUlLO5HnCb1ppZM8TpHm5hUWff+YPA5MfDFArulgKOiFA9A7nso4NDFazaeos3QqwC/W96MlQZGqTr4FtyRRjiUnfF3Q+7jtnweoQzlCXasgLxL6S96tyQIxRxcHX5qL1Rq7vX6oDtUoDMMJlOvUDX371nH7IJCNuTKSZBJVIxWJdQ2iFYB02HX7jKB7GlLC+IRUJesZxZJpH3rx5w/3xyGbTAg5n2zU4rUiUzqkVWZxKW3g32Hn473qNVadlDeudlZnEKWfiocfkwunNgTJHivXkrmM0hrkU3K7Fbhv+5J/8AS5l8hSZh4mcHalEbIwanMpaLKU+Ne5p+tU7SoC+H5Qj1pI2HmcyjbM6LQsN+mszj1m67jOrzJgFGdmYtWMSo93IsIy3W4LRBRd6cB41SJWGv8oXLJJeKh2mZvJJJzIZYzD7/Sq79MAZ17JoBRuMOMdKJZBCMMMw89XXr/nmxRtOYxSmuCkYK8T22qRVDBxOkd0kqP+UC1MuuMYzzZPouU4jz1++4OXLVzx9+qkgZ67D5k42S+WdGT0HY0TSSqEo5de+vdG/G7DWtV1+akUZwhsZ/xdvxXbvX92RxxljPaXr6CnsnSVcbLHbhj/97/4pNmbynJiGkWwMcZYRt2UaIcZlRGXRoDrrRKGP4Rj6AWNuSXPLpvNQojxqGjAWbUYrSRr3jMlYm5WvKUFRHUiRav6uDZU1INS488xa305+1+Ro8SSidr/86BzhT6p7m1JaBM8fbI6mPBgUUkBkeTTZykXPzzimMfHi5S0//fIF9/1AyiAT0azYrvFiK++1XXDBMceZOUbGceT29g3ffPMNzz77nKZxYALWVttNujVXGR05lxoAmg/Y7vlQkvMErNquVbAhpky6GzCpcHp9T5l/cduVfSJT0oTVMdYKNgqt4COw3W+3W90fDBSnep+Ys4l54gOdBm/OqrddVBbOvetqu/Cuz11DLQlVqzTdeXJUPy/GtNjsAilU8Gv5jIdPSNHEuRQrqJqByrAdp8jz53e8fHVHP0diQdjtxWB8wTvhwla/O0VHkw2pOIrxFOtIOTGMQtFpu4avvv6Kv9H39OOI96I8kPGI7JhEWeWcN13Te6MhgDkPUt8DEpwFpwaEOqa0ETsn8v2ASdC/vodpBucxXcepZBpnaC62mG3Dv/pvfx+fRDEnTpHZiE+NJRJ8g80RM83Ys9I/RSmkHzh+ZoAqU2e0nLNwILOCltK1losYXUkZ0addN2WRisjkzCJH4uzqjEQqQZxvec/6nS/7+XktQeoyXmZ1GnWiT5XsqOZqzl53/q7yt3BrKUUksIrl1E98/c1LCk6CGMxijNkYYjE4PL7Z8uTT77DZtrTbjOHEPN4RnKeQmePEPI8UMje3txxPJwoFayKbEBbZFkOhjgKkrGVRw1pGe3isqPDyOrHIFRHRkoZ10iDiThOMmXKYkKHzDnxDcy0oRKnwyDRjUibGxDzNyMwPmQZEPltTSdOWBCCnyMdwpJQYhkE3IE/XGGyR2eY1qMt1NKyxCypZyOvAA2QiTsCCzRoMWJ2KBOf8ZXh7w6/fXJGjxflR06SyOMuFD6Uj+1ieofW9zz9o2RuXzVMQ2IIEh8fTyFdfv+B4mmWSklH9AtVvtcZjfUtwnpQmYvFE45mxjKngQiAmEX2e54nj8ciLly/4/O67bLctmAZr1fGQsBrYW2REq4wrRYMl+/Cxo55vPWrQZN+5TueMTAHLmXgYYIjMd71uZRZ8g7++Au90ohGYGKUZKkkDRDIwu4gJEZciJkoF4PxmCZrzcdjuPM+UY4EcoXiCK1LSpzZBWIrzQBauioadS1KqSUEwqC6idhcbu06E491U/d1jRVwWMKD6U7Xbtzd6aUxdwYIVGNC3W56Zsx20rNI8ORuO6ndv70/MZwQZOWmDsZ7gq+bq/JbtZqz3xJykG3kamOaR58+/4fb+nov9TsJR0y6bvPjXFRiw1G7sikS93+8KoiZBwvttVyfYlUI8jjAk8v2o1IJfzHYbJ5PFSpwgZmozl4YoH4XtfpvdOpXVw8qelrKcf9FmGhllLtWqYsXfylCNvDTI5ZweoP3nIdeZK3z43bPkvioCrCV7AQTq5L/avH1+LLZbP3f5YBF0KmonBUvKZvG5p0FmPObqGY2oZzgs2AYfGrp2Q+haQufBe6YE2VgKiX6QJqXNtuPl65ec+hPHvid4gzNepnhSB49UelU90SVoWLjda4D60OeWUmUB6/OtAb2W+F3OlOMIYyLfqd0WS3EOf3mB857KjTPzjNOhNTElplkCXZMi2SV8yfhZ0P+0JKqiy/2h42cGqF3X6ci9QtuADwa3zFY2Szf/uXOsDzbakVxSJCdLyQXrMgYHrooknCNE559NTfSXxV+4E1aEzp3OzC3WkEqWDEyF6qvRWXvWSFVv4ZJV6TvruDpbs3kcMRv6MfLq5haZ1l5BdelaxTgiBpcNxTQ8/uR7fPLZJxRz5HD/NTenkwSezsg0nThiTOHlm5fcH6RTzprI559sqALCRmMlZ+uUhhWdU4yM8xV5sDp1/ZfKw1oHMsZgvcUbg5mhjIY2GoozuGIgNHz/3/odpj97yXgc6BL8D/6n/2P+4//bf0hfuWxmoDWOE4lZO7crYi5cNJltHD5kUL/Ew3uvtiCzs7MrzEm4vg7lGFsLxi2j2wT5y/r9NTgMweGaKnZfmGIiTWlBXs881wNbXrdmfYitXbpDq+OrZfxqrymlZc5yrsPOa0Z8dn2mpsj6+bWonrGMU+L27siXX7/C2CBBa1a9DavCy9mxbfdcXlwKKtU4TGNJrjDGhHMNqUTZ4KcRTOGrr7/k137jt7De4S14GpybFwdnTFk1PdT26kg8OeflyqnO8gEKpQnWWciFt9KAVwCGmTIUwlR0xrODpuX7f/tvMf3ZC6bjyCYb/t3/xd/jH/xf/0OmUvApU6bE7AsuRTaATVkDVKkAYMSXfSy2a60jZ2kydWPEtgaShE4OS7GOxjXLMi92pgCAyBFrL4DTIrZRKnUs5LnyzlZUoKJG8vX5Rr7arn5DNU9X264bvVQA6ujC8/tu3rJdSdmsNqGK6BKAZ5wyNzdHfvKT55QSkCRN0hGKEclda9k2Oy6urnDevGu7tiET6ceeYTzhguWrb77icOrxocHbQrDSm2B0WpNUMpJoki4htH3LZlm+jzm3XfNz2G6k9JlmBuOFiy62K373Z9puNBSbKGkkzxGroIlV+tzHYLvfZrfFOBkAE8R+Ia25SQHjPNYmkQS0ntA6YklgIeasvPwoANE7CMBqu2fh2ZK4rxz+h+lYFeafpumB/SYdY+vP4pmHv25Uq1ynkAHgmKbCzd2Jn3z5nIxT1RfxuTEZbDaMsWC9o9lc8MX3fsBmt2G3N6R44O7uBa11eAfDPDFOI03refH6htv7W5rNhk3XsG3AG481SfeEijTDugJyznmpqtUleehzZWgE8lwtr5E9zTv92fjQbm0xzFh++G/9LYY/fc58GiEb/t3/udotBVJizAlbZOxtSRmTMy4m9Qp2Oc8PgZLwMwJUa6Ftg8jCLAGqJZgq1QPBgNEN0laeaXVqTkoyqUSVAJEN2DgHzlLMrB3m5cFGVZ2b0exzXWBDCIH9ruXZs2cYY2Qagh61oy6pvJRzTgR6raXOG1/fjAfvq0UI/ZHl+csXfPnVlzIWkFbKP1pSKTnTeMdpnjgO99hTg3GSBYVmS9M9ptufGA9/yi4EnLeEYNluWl6+es7LN6/w1uNt5tOnX2Dwqm8m5Y7Iqikr62BxaAZW1u+vF6FTNIpkTaWsAzQFE5Smg2QNE4nX/+//FNuPmH3L9PKWv/iP/r+UANYZXv3BH/Hyn/8LfvP3/k22k8HYhhJajPfElCjZkouMzcyl4DAYb8nOkM66XX/Vh7WezaaRgRK+iO4hEKzD6xAJ0Hu/aHmKw5nniWmeiRrAONuy9DQZCeqtRQPI8mCjYvlq3fhFqFzQpnbTEboW692CmtbxqDUw9d4riV+cxVn+957r1Ay4yPtYPPd3t7y+uWWYpoptkk1Nrqxq08FcCqVp+f4Pfp3HT59g/cDx+JKblz+mc2CbhjlF5nnA2sI333zDzc0bxuGENYnvfLY/C2RqrCf/thq0S3JVqMMC1nVaN4CKQpkahFAtVyYEFQslGKLJvP5P/iF+mHH7jvnlHX/+//mHlADGwYs/+ENe/NEf86Pf+z263pDwDJgF9Z8ziLSNlB4dFlfQZ8t8NLbrvQz2CN4ICkWkAB5JAmtSIz5CNygL8zwyTaN00BqL861IqDm5vlQgRvHraUEu3nfVeg9NLXtLJU18tkwIKymLEsVZtQpYqlY1ALZvr2vd+Kl+V3Z5HQjK6zev+frlS+6HnkmrHVl/z3onlauUGXPBNN07tvvm5Y9prME3wqFOKeK94eWr57x585LT6Yg1me9/95oG4fEaI0Md8pmTXxLCGuyfURbS2TjWXIOWD9hu9oaxRL76D/9TOI34y43a7n9GaQzWG17+wR992HbLhCVBijJyGNGKdaXgsR+F7ToXaFsRpa92CzXQF3qUAW1MlcC6OMMwDIzDTLEe44OUu43wRp2B4qU6JPl4bRZe7Qg0UdP741S5xVmRRsvq1x1qc1b0yqu/rX643uMqgP+QovLwWivyKHbruL17w4tXbzgMI/NZcFqH9SUF62xKJON48ul3efzkKcaOHA8vGYaJmAa8dTLuuvVcXV/yZz9+yYuXLzHWs9103LmR7z5rNSUqb+0LD0J0WeezRHIJXI02hJeH+3UFFYuTwDG7h3YbLjZML+/4F//xP8T5gHVity//6F/yo9/9N+iG2nMExnptkoJsRFYq17hM6ZlSvzzjqr/n+BkBqnYSO+GCNY3D+Ro+Vk6HjJ4pWBmpuWTaADoGCx3JhSBUJWXRxrJWNMDOFsi8BzWtHNIQAo+ur/jud79gt9tyOp3o+15eWR52W9ZOUqvC0msQochBvSFqZuoxJfPCcXN74PXNPRjpzC9FbqwIlBuun1wyvjwwTDP92PPq5g3d/hIXAiHs2F884njzr2iClO9zjhhTGIaeFy+eY61n23lSekb2EWukIQVUTNtAKXY5LXRtqGXi9zwwgEwDsvWaDFkn6oAaS8z8wT/7Z5ymmUexxb458Sc//QMw8Pj6mnwa6G8P/PTLf0SImd1ssBF6W2SeeRapjiVio6iKgCMWx5u5+6DB/bKOEAIhNDTe0LhC42X+tlNnvtAnjM5BLmdk/iyzzUu2JBTN1rFExUCc0lsJVX0e3t0mrNUmNWfouob9xVaQdSNNhFZt/Bzxt4qC1ZJqKdLg9G2VBk1jMMaRiuPrFy/46dffKPIvpXNgqRoEZ5lS5P54xDX3+M0lhC02BPw8YcOeKQ5srQjiO29pu8DhdM+b2xvGaUvjDcPU4huPs1kz+gIkGTdaEwDWQOccVVsyaHRazLk4ev275PV9sqHEzB/8t7/PNEceZ4u7OfGnX/4+xVieXF/DaeB0e+DHz080MbEbCzYa+mDIyZEpRD0Pa4I2Tsh5RD4e2xV95yDjTV2h8Q5nzoT6NXIy1iy0qYwEhzGNoudpPKmM4Bwla6CXIae3bTdTi3znhzS2KQXFscwpB3T2PEuwWiesWQUCFkpH5cQa817brZ8klASR1vvy+Qt+8tXXJIMkvNYsHnvx1jlz6k+8ubvnR2/ZrgsXxDjhtfEwBMdut6UfZ17f3LLfZbrWc+oH2q3oN1v168sZ1XM1tUr0cHVqclunFr3fdjWIldwXYuaf/9EfMcWZi7zD3vT8q5/8ATjDk6tr8rHndHfgJ18fafL7bLe++VoZqx8VsR+F7TrnaJpGpp5ZAXGcNdK0q9SonLPYrLPCgTCGYToxp0xJSWa5G0e21T+YRV0Hzu4NReXK3rYrIeJ5J1q12+0WU7Q5tiLiBuZxIs0y9jf48OB9v+14WB1T8ME4SvE8f/mar5+/IBl12+ecZFNoG880ZeZx5P5w4P7Qs78uOBOwYc92/4TxcMS5AYPFe8d+t8Faw4tXz7E+cLHfU+KBz599V6qh5szegDp1soJ70tj7IAQFVLbLrMCKKgWu/66C/8Vi5swf/9EfMc8zl2WHux348ss/wlrLk+srynHgdHvPT7460uTMbjKYaBhCgWylSKUSlfNCs2CJYYz9SwSoUorRcWxGAtaqKynyLDqFQz9wcZjqStu2Ybffsjn0xNNMzso7KOvUkLd76pcctKw8U+cMm82Gy4s9Tx4/5tGja6wxjP2gskpyQ6qDrE5xs9nQNu3ZeFP5jFIeGvrqkDQgRkoVKVUBXl3UIjc9BMtm22LtPSCjE5+/+IZPP/sOTQw0oWGzuSDGuAQfy9zxkjn1R4JvacJmCYrqSmhoqTGzOu8zRNkUwzses/6j6ElWszWiTiC6iRCaFvvoETEbnL9g9/gxm6bhdRwpqWCv9hRb6E9HXvYHytUl2Ss/s2QoRXEuXSfRGhNE3Aqq+jMoJb+0I4QG74OO5S0EJxIttRBnKELBNZXDWXeSgjGqNZgjubgHASpGxJ0f3IDzh+49h/eS/T558pimCcLpPeu8hzPnoJSUh01962tWU30ru6+jTZPhcOo5nHrlUqvDVLNxztK2nvEk3Oh+7BmmyDZbHA0u7Oi21xxvXgjHyFQHGxjmmTe3bxjGkU0bGKcd21ZH3J6h55Lb66WdO3Xz7hrlt76zPqly3TpT6IHthutL9k+esu1aXucREovtDqcjL4cj8eKS5Kr7ll2jsLbE1Aa0NXjmo7Fd0W0OMhjFF4LP6wQ0bc6zOoHOOrN0OguqPwudyhSReCmFYu2y0a/NfXrUDe09G721lq5t2G47Hj96zDAOS/m6eqtKpwJJCs+7oB8ytN8XZNSPF0RtnAuHU899P5BNAFWHWT7RQtN4+rEwxYnj8D7bveJ481LVBcpiu6chcXN7wxwTu03Lo+vA9a5Vpy4h8NKEBu8+yabGhWZZs3W/kuNtoacHtvv4ETlbGn/F7pOnbLuO12WmxIy9uhC/2x952Z+IVxfvsd36rAiR0xhN9/RcPgbblcl3DY23BJsJLi7DP22pko5rcMICDkh5PZdM0dGuWTvjK9Xt7QRHMBv1uvr/2nwTgme33XCx33FxcUF/Oi3Jfj1kDLo0A/kHsmjvPgcsn6VVoSXHFrtN2XDsZepgUa4txix2a63h6mLH65uROc6Mo4wZffTJMzoTsHbLZnNN7p9jiJrgReI8A6LLfXd/BxRKPMp716Sq7vcV9Tfr81X36fqv86qqEGv0MpagQ9ZIxsJaQtOwe/yIXCyNE7vdbDpe8z67PRKvLklWel1MEYqBjCs+W3ujQOLie78tcZXjwzqoRtCblDVbqOjOsslL6bluTiLSr3PGMbRdx9VV4dhPDNMtOaocR5HAd7nParAVQWTJjKxqym14/OiaJ48fcXV1Rde1xKlKhLCgUCLNJFmas47dbkfbtYtIrxjxgz3zfRcNGHwI+OBXVBPxCFadZNNYpJ09UcrE8xfPmWNknrNwj2wgRglKc07Cxc0yo3YYekoLObdLE9diUsZqxod23q6d3EaqYO9sJott1XLfch1iDJWP5nZbmh98hy6DzZHu8RMZe3bpKNHAs6fEuw1TY8hTZt7uGDeeYLOW4QRnqE0YWKOBm1OnWfBl5mM4nPPaTexkipTLrNORyzK9ZmnoqEEqwm/EVP1XEQkvxUKWQDwXbS7T413e6erEQgjstluur6549uwzkeBIMj0FWO5vTazq5BOZHnUWrpVa4nrorBdnZMV2cjLMc2KKkUKruZ5eqxVEqds13A8nYswM08DN3S3768di837LdnfN7cuM807oIjkRnKMfE3d3t4zjRNxuGOcJTEMxedlsTK6rUP2CWe13XZ2Fe1Rx1jqv2VbUWM5Y7LcY3G730HafPKXdtGwvPTkBnzxR24U4wthu6DtPu+gXJopO6rLq062RzUPzrI/Kds2ig2sJXtjvDkkUS9U6rkNRrAAGzqOJVRKVh+oZsl2bWc+S12XDVX9bzaoUCYC7ruPqcs+jR1d8+smn/Plf/PkDOkuhkLVBCiQRq0Hq2072PLmqx2K7AveQkoyMnlMC22CtkBsKcq+ct2y2DcM8EdPM+C22e/cq45w0sVAyzhoomfvDrVDK4oZh2K22q8zpuu98q+3q/6vtlho8vmO7sq5Ofbbf7dj/8Hur7T59Srvp2D5qyFOGJ4+Jdx1zY8jT+21XWwIXgEIaVqpv/zj8rvdBg1RH48AbmUonDT1Fz1153xooFaS/peSoAWqtqBSMFVpQFqIqcG63ehSpHBkj4JSzhf12x+PH11xfXdB1HcPppL0CGs/lQpznxZd672nbdqFVPXj7d0CBs0RL1Vcyhhgjc4wUGtkLWfMY7wzX1xfcHUbmmJjjyIsXz/ner/2m0nkamnbP6FrM3OOCpZTM4XBHKYlh6DkeD+oLx8U+tSUW8V7nlDXz4OvF51KXfaXNQE28VBLNVKlCg99t2andumq3259htxundlvrHnbNC+qeq1rHSxzxIZv60A8r+geqLmKMok6ysVoLjXEU1cATSoAI4GadMtO2DZ99+gmHPsJxhjKTkzI3nBMeSjGLUdZMAATt6bqW73zxBY8fXbPf72QCRBaDrht6jddWbpYY3W63o2srgrpm4u/Jj8+OQsqRzaZjv9vwdXklULd2ZDoHbeehTJQinfk5e4bhqN36gTjNzMMrQRRTQfpiEqnMlDjx5tULtrsLthtPLnVsmQWr3aOVV6gBa+WR1ErtOd5RN4wq5SUvWGVIMFUn09A+vuTy3/k9fIbQGo6mcCzQuC9ouj2HmBjHkTZFLi63/Pmf/Bndoy04g1HdWgmmxNHUVKUiY9ZAa371ciewSq9422Ctcj61M5SiAaoBnFuTKi1dtl0g9I4pCnNJOp+TBgKcBbMa2GqSIbfRqsOU0cBPnjzh6ZNHPHp0zW634XQ8Lq9X6uDynFXJld1ux3a71bLqcqd/9kVrxcHoOMqSJQBTn4y1sOk8u13Lq5sDxMQUe/7sL/6UTz77Dk3wdE3LdnvFNEYoMoZ0mifmeQY88zTgrCflhnGcwbTLckj14TxYt+onzpznW+lV1oThrQtRU5bhE9lC++hisV3fGo4GjkD47Wc07QWHmBjGgZAjF/stN3/y54yPdhgHtiQJgHLCGd3w6n00gkA6az4a260NHMGCbT3GaVdzSYAVP6BVC/0FDYxkoAZaFZAJTBHUHgVJXT4FWDdRibrsAkIEb3j26ac8/eQJl5d7CYrrZ51tKpXHV33xbrcjNM2iRy1JVV6QPniY0NV/FyPlwFIHlJCXhq/6XO67wNX1nrvDS6acmdPwju3uttekWIMciCkyDCdysczTSPANMQWGYYRydUab4q/Udos+08YYmqsLdv/938Fk2HSWgzMcLHj3GU2z536KDOMopf2rHTd/8mfv2G6uPQZkbC4i7eisSBGa8lHY7mK3zmCCx7ogdpuKlnAqTar+keRqs2059pOIuyvKWnJSpFARY135WgE4vw8VnLLWcrnf8t3Pn/Ho0TVd13J/uNeTk/PLWWiHFUGtUmmPHz9ms9mooo78wnnJvL7H+qHrZ3vvcT7IfVJN9op5WGvYdA37baAJMM+JnAeev/iKKY6EKOOkpWHQC5e7C8Q48fLVc2KamaaR4+EApbDtKiVGkxPjKKr5WcGWuh71/N6220LVI1q+sViyM2sV2l2/ZbfecP+L2i1Z7nPR5EoblA1R/cBfosQPwmsKzhFckICk2GXxDeLsp1nI0NaKfmjbeDHGnDHF0jYt3//ud/iLnz6nHHpsEnJ903bELGO+coEUK0opKNLl5QU//N73efL4yYLm5BIXYr5k7rLTWCsc1RQTKYrhzVNknmbhwaggrVtkFaqBnRm7Ot9SMt2moe0COc04L41iIF2Zm9aR5oHGFaJNZEbm+cT9/WvNFCPT6cDh/sj9neNy38iUKJOIZQImKjG/0TJqFiVY3MNH7537sWhpljU4rcifoZBNWh8kU18nsh6z99w+ajgVhDPoAGtIVgxlLoHds0+5vrzAB0M5DcztRiSJVM5GhiRH1YIFoqrDGnC20DQ/RyD1SzhSSux2OzabjiZ4DJEmeBEHUVQwpSSdz1riAUuxnu9//7v48JJvXrxhnGEY60yYZYvl/N6YZYOXn4n9Br7zxRc8ffqE3aajbQPe6bjfvMpOQQ365f29D1xfX7PdbrUD9T3rWWPj92SfoRHUzRhIOWJcEC4h0ATDZhMwZYYyApmcLG9uXjLHiWH0xCmTJnHq0gQmFJZTf0+xV7x585LNdsQ5oQjIBWhXs4GqYWQ16K8OvlIpFldZ6nqa95i5BFxOg5uUYLCWm8stJyuVC6OgQXHi9Obi2T77hE8uLwjOQj8S2w3ReFxFyBQBsUX4VU4LkGgi9zHZ7mazoe06QghYk4QnVyIlK4fUyGQ+Yz3GOKw1/Pqv/5Bcfsz9aWScC2VUepYmwNaYOrCLigTUxAqKqHA0Mp/713/tB+x2W7quIQTHPE767K/Wb1iboqy1tG3LJ598wqbrFIn6+dfTGNjvd4QggvQ5zvjQ4p2cXlD01JqZXEZ5TXbv2G6e7oVGJmU/Upo4ng6UvOXm5hXTPGNMYk7X6wdbRfDjX43trjqP8tLROV7vN7zJWUYuB4MNFhkHZIlNx+7Zpzy6upTvn4b32q6MmpZAzyt2SknYj8R2cymEptFGKYcpE2Hxq7Vs4bDe4rwMZSjW8KMf/QbZ/AX3R7HbNK2+Vp9YeURrAvzArmTIw6btuL664jd/8zfYdi3OGXKKD3paKpvDKh+2NlLXKpdfAIFKA9RzqO/xLbhWKgUXxO+eDgO+7eS9DXgvI7dLicrVj8LbzgPH+wMhbCnJcpzvSVPEgtp2JKUJysw0njhZBybRNTtJ+ngroaoOkZXyUMv9S5n/Qcxwdhg4158oiBsfnefN3nGTM96DbQzmF7TbvGg1Iaori79hoZ996PhggFozjqCyIrVhQSLuQk6yCY6TTJOpm7wPULJoZi7oXdvwyZPHbLqefhiZ54RxXjUJlaNpLNZZHinP9PryksdXl7SNl89T0kRKkgHFqDwSa3AunP0sknPh9es3zPPEpmvx3nF1eYnfdMKZBC3zGmpJEWO0qUtIyt57afhIM5eX1xoQZ6zJpHnAG5m6EMnkNDH1Rw7JkOaR4fiKkgrDMLDrnKCLjSMO0hBlkDm2FeGq1q8Kee8cqkt9BuFVPtl5kKrHCq+KkRY0eIXJGLIK9+PkyUsINSNmeHV7y+vbW3YXO05zYZMMIWsDXFFErsxCOC8WYxIUHWtnEtaPP8PkfjmH07JNCEFkcRbuXS3hiX6cZOuCLjnvCcawM5anTzPGBl69PhBTDzlJhcB70fCtlIciNJj68LVNw36355MnT/nii2f4JkgXf3V2pjxwHLUR0SxlL/PAiYizyFjr1uBguacsm6h4loRxWvJFnt060g/AW2gbC3kiuEK0hUwkziP96UDwnlQy00nmuU/TltaDNRljM7nMpDSScwsm0zQNVqdt10Ou72EzlDGo/zhzqMUswdOD/H55FvXfWQMNYxlNoTjRUcbkBXGrtvv67pbXd3dcXl7SR+iSJSgto5axRLsw443DFIfJBSGufDy2a52j22xomgbntMkECZwK6MStWr+wCx1gu93xne98zqs397y5PVLKTBon3Ygt1gUh2horlZtS9Bk2OO+EinJ5xaeffsr1oyuc05nlBSA/KB9aY2l84FT/rXYsQxmUhmIkybFKSzJnrmoFCNT/lYR1RihlaSYVgw8SNBcK3kHTWEqe8C7jU4Yyv8d2jxyPR8bRyj02GedgijM5T+Q8YUxmu+n0s+3Ci/yrst0HqBvSHjzJDk2yRobV1EpL9bt3t7y+v+Py0fW32m4FHKxxkJx8jjYmfgy2G9qG0DQ6uXFtADXOiU56gZpZ1olMBkHdv3j2jOcv3/D65p4Ykw5uWLnT1vkH8aFMP7Jst1uuLq54dHXN08dPuNhtpbBQZMZ9tcVVWUJoV+c+NufM8XAkeKfKP5LMBWd0UI68boElzlCtUhLFZHlOnSEXrSaYoj07omgQpx7KDEQomVJmDocbdvtLjPfMw0AaR0wa2bYNwXuuH13x1YtbYuxJqcWYTNc1aou6jrDEBOvzaR7Y7DkYck7RWYtzK1tcQ1veZ7f2F7VbaoBaPz+J7cJqzn+ZJimAtm3p2oaua5eHsZbiC0WE3GeVD8giDG3cLIT9tE5x6trAk8dXbLdbjqeR+4N27hm5aTkJb/Ti6oJPP3nKk8eP2W46uhAWSZ+VQXUuxC9l2DpaL+eVtH86HYHMNAzSHBICu7aVzjIqU4g1OK3lcg16jTWkHMmzYbvdMKkmZM4TKUrpvsHhcRgLw+GW6GfiPDEe79g0lmkSoXNKous8/TBLZ3mwBFcDFzV9zShqV6gEMvWPOcviKirCUt5bMve349QlE1SzM8IzSVbKQxhk0gWSnc7zyDROlFLwvqEgslJVYqtqwQotQ7T+zGLkGeM+ArY+4ELAeLeU2txyo2tgqbGPKSQr6+b0PgTv2e/2pGzph0g/RcwkiJUPgSnJJDW1FqW3OPb7PRf7C64vLnn6+DEXux0JabgSp/SuIPQibVLExnPKHO7u6ZqWpgkE7wjeE5w7r6yeoQhKmNfU15jKIZJM3BoIXrjUVbM451l0TF0hkol5ZBpPDKeGkmb6+1vGcWQYRsLWCzruIM0RUyIUEecPQfWF9eMls39YTpIgXDfttwCnB7SU5ahJVzl/IdVh5hqVW+FbFHNuu5PYbgZjA6jt1sSu2qkxmWLlZ059iinl47HdRmwXK/Pt3XkMpBs2pZCyJK5S0nd457m6vCIXJ7O/p1vmKJuJdwEbArnMkpyptJMxhuADl5cXPLq85tHVNY8fP8K3fkmAyxn9pPrzCkgsPlPBjPu7e6wRPqp3Dts0S9Wq3n/zgEddHthP9WMgm75zwsdzFrwppCTUh+QKqSTSO7Z7R5xlct8mtGr/lmFMq+2aTKO6xktSiJzgX8Z2xULfsl3OqGVGSthJNRoXTiuoJqfem2+1XfFXxcjMd1fWnoOPwXad9xKMGpV1KuJnxa/KfRS1lIKxqjtepIv++vqacUoM48w096RsaIJMYpxj1tJ7oY6wtMbSdR1Pnz7h8dUjri4uudzv8c5RSloaAmssAPV+ShNqDVgrLeHu7g5jpMEqeA/bLaFrH4A9+ib69VkToMnLM6FPKN43GKOC9xbmqYcckTl/AgycjjccD9dMLjD197Q5kueJGCUxvLzcYUjkNGNIEuyGWlWr3RQsfr9+f0H814haL6Ha5sJER6z2Xbs1b9ltOgtGfm67pVCDaLEAK1SzUt9fezs+cPxMDup+v2e32dAFT47jEl1XgnjSaUPGSANUTmKcjTc1jMJZy3bTYF3HRTachgnz/DXHflQpBNmcQ2h49tmnfPrpJ1xeXGApuBrdC9S1cJIEQa2ae1IarZs8oFNNZvpTYbQWZwzXV1fLz98PddcbmbXyk0lphiwz3SmRaTwR5wEMIhLtHcY0+Bw43L3G+ZEUI3E6cbltmGPPMAzEOLHpAremp20cm8bTBdF5M5mlE3c1s3pbWVQKqlGdB+qlEpIrr3L52Vv+U4PcmlgUldyoY3wNaEejp7hEGmf22x3O+iUGLiA6Z2rLOesUkPrQlgJn1/GrPFwbZApLFiXQ4GSzLwZVVYgiu4N2jhqLcV4eKQtt23BRLIfLgTFm+tMkXCEn/CAsddIdqLzKs2fPeHJ9zeV+z6btVFVCR1AiY4JrUiUlJLM4y5wSKSasMbx69UpLpg1tE9huNuy6bnVEZxlvLfdKbUjvoxWJHYx0qTaNJ+UoNI0cKTnjLTQeTJYpNONwpCSYx5HT3SvyGOlPPdtmi7OWNjjinISqouqqjZdNo55C5Y1mNYOlvFRp4mdohjz0arfV4kthmTRRy6jnUXnV71P8sNa6Ftu1jmwt46ln23XCz1LXmElrMxBGm4bkoTJFJ7h9JLbrW9FuXG2XxVal4VK7841qShewupZt23J1Kdvg/bEnZwlenW+w3jNrGdso19M5x+XlJV98/ownjx5xsd1J5YhELIaS5FkRDjL6uyvyf86dnqaJFy9ekNJM07R0XYuzVoYKwHJPCw8RHW2DAsqCWIJsxoKqChhgSJSUZaPORtYgP7Td/v4VLhWGfiB2InO06QLH47DQrJwpNP6MKsXqW/9Ststb48nkLdfAtr5njRyq7aK2axLD4fSttisAg9VmP0Nt5KoNq7/ywwmPWIZCSAKVdcoWuaj2rgxDQBsrnaLW2+2Gq6tLpjkyxkKcDe1mQ5yzoObek0te1tsH4Y1+5/PPudzv6YIkQkUTXAlO02K358FptduqPz2OIzc3N0Jn9I62FV79rmuXOKHiG2uT6trIKbup/DGmYEpm07XkNFMpGHEaMSXhbe1XKBwPt9y1r7F4pv6Ozy6lMjzPFm8z++0GU7L8niu0wRK8aqSoL6uxQKV/LGjvWYAqvrlwrljBt9ntubtdvlCb/dew2+UoGrqnov0sEq/k/Nbz8tbxwQB1s9sR2hZjLTGLDARAMAanHdIy2m4EHQUaU6JMFlMS1svknBACVjtSvfWENlCwXPQDc0r0w8RpGHj22ec8enxNG5TzqenBMie9SDY/TZPMtp9mYpRMO/h2oROIBqpdzq9ME9ZI+XUpKdXMXQ3OaOZRsKqXKc+8t5LN5xSRJoXEOCdicTi/ITQtPrS4ueF0vMG5iMHK7PfQUvLA8XCiPx2hSOOMKZnWO7Ztw9K2kBHjsVkfBPn8Oq+6ZG2AMWj2UrOeNe8v+kZr6ekB9LIYFgXRrpWeC6rosLfgNw20jRDWq9QXrA8+tbwln5OVy1lF633zQXv7pR3rjG/RX/NFy4dxJqVZR+cJ8j7PCecTrahu47zD+cCmbfnuF59zcfGYm5t7+mFmniMxFeFOq8JDCIFnn3/Or/3g+7Qh4HW/SNoAV9GlnLOO1jsfB6mNJvrzeY44Z3n9+rVqEDu2mw2fPnl6VqaqFnyGV+rGmdIk8ljKVQyNIzgjCHhOzENPKtDYjG89yQRC9Ny+/oYmXDCPE6fDG653Tp8xaYZ88ugRp9MNjXdsu5bdRnhmIvMGLPb2LbOVzToycnH6BQ3W8xIklLOfL78KUAwmWw0UzrNygyminBHawDYE8tKl6uRJKXFZolybjUqikJgVmSDw0dhuPartBnSgQ5713macJkrSiAmFKDQglQK8utzz6z/8Ad+8vGEaI1IJMYRJOfw54UPg4uKCX/+NX+P66orOe+H9Ijx2WzKpVLucVct5DbLqmMjaJDWOowYiSex2u8GUwvaTT9Z7aiogociWQTYrCjnNlBRBn83dpoOSmOcMOTHNA7VTe9N6rG0Y0kPb7Q9v+OSRYxxnhqEHCo+vH/Hy5U8J3rJtW3abjsYH7RyUk1hBgfccH7DdrPJ7HzrWJEv3zWIwWYZmmFLwxhC6hl3bftB2KYVEAiK5JGYi3oDxH4ftLv6pyNL2fS8UQa/NZsXoLPZEjBkfMj54bABrAlcXF2w2ez759Atu7gaOpxOn06BKFTIoJpFpW0FOv/e973F1cYFXZSex67z4P5lsJv7QWo+zHmcDKcp+GqOgk7VZ6s2bNwBsupYmeD55/Jjqv88ycPm3rd8ylKjPZUmi5eoLjy529P2JoT9SYiKSaRwE6zGuIbkdcTgwng7kbOgPb3i66yDD6dDjnFLKjMU7R9c0bDcdu67F5PSWrb6bnEgS+DDBP/evcp8+PB733G691alvWekDpYjPPbNbiZkFtFjsdgHM5L5Q5B5KgpKJ+Vv2Cz0+XOIPjmQKQ5oxKeGRKTd1e7RWmjKmyYuEkoEHnWTKjaraeM5LuckZw+NHF8TLPaUYYpYNf7fbS2NIlkC0IiRVz8+oAc7zxDTNIhyvi2itCFE759hsNoTO462TBq+gKNR+h/EPwGtZQJ0A4ioAaHSOsjc0reOTTz7HWNXkM1ZKnVZKFwucbrOiZDMGi3XVgAzDOHE89kzTvLw+BNGjVNVVgeO0w7xGkVkDSZuQkqSt3LOyoBYA2WRWfcP3OUtVSsgrn8oYJ9ebzSKGvWaFBawVVObB8fBBEJ8zk0tL0de68GFn/cs/pHw+GxEkTxlSEqTdubLoOIoPinjvFuHiEBzbi0suLgyXl4+4uz9yf3+k3Uzcnw5QDPv9Jc+efc7jx9fKydSiRtbSflb92JwZhmHJ6NcJH5YU4zLQAsA6yzRPlCEvnKiafDw4Sl5K3EuAmAX1T2nW4C+RckQ6vCW5o1hc8HRNwPqOZvJMhzeMdhbaQ8lsNjtS6rm/PzKPPV3XaLmzLDQCb42KnBsWikc9tSLcXNnQvd6HmnQK/Fw3s9p8U/vMzNnf9TvCYaz8tfV3BCJYG0mM1SekgCVJ4qyJLrqGhSQNCESh+ziL9e6jtF0xJblvcZbmIJHTmxWhNzgvFSRrCsE6mrZlE1qurgJX1095+eqWUz8yzTNYw/39kaurKx4/fsSzZ8+4vr7GaxJjdPNKeX5QKRnHkZR007QegyMnMDqHaymZAkdVqpimif1uz7o1nm2ORpK72qRVtHzfBEfXePoxMZyOtI0XDdgM9PL+++DwocWGjuP4tu3qHlUmTqeeeTwBBecsXisL3js2XSNSTdTAY733v4jtmlxqxbfeMc5tt2qdoGCD0Q2cGh+YtNA0MEV4xu+x3eXsSiZmuY8ZqvjCR2O7FQAqOnTk1J+YJrvI4DljFq4/SaI8Zyw2FNquYx9ajG/4LFlub+85HGQOfT/O3N7ec3FxwZPHT/j8s88E6bRFeOQ1SchxteGUFv9uTNLGIwlavZeO+YLEDMbJvi4BdR2N/tBuQZI3Y9QX1QoMRe024K3sz/d3t5SSJJ6YC8yWzjtC1+HbDcPs6PuJ4+ENKUGaehKBVGCaZ8owcHt7h7WOrmtog2PbBr7znc9knXlXQUIk5qSHxhUvNos5M+0amCqK+QG7PQdQijUUnQJGrrzyJL5IYz1nvTZgikb44nOXqFheL8uaz6QJP3z8DB3UKuZagWwpaVOEi5hSFlTQerKWQJyTclLbdFjvFFYPWCM33SyvE56FtV6y+yzNAdZUdFAyVLKWrs+MLkb5k7OgKdY4cha6gbWOi4sL9hc7Nl1D4wMheJoQaELQB2gNx2omb7VULmUU8RfOiIbZF59/AqFlnCdSTswpY1LCJpn1bmwiCzmOrLOdc8nMs8EbGKfIMEhA7ZyjbQKX+x1Xl3vsosOnTnJx3iywekXgpJxzRmhW45BBCkaDXDUMHhL7q2HWbFE2E/MgQC8L/L8aV1Fneo7UFV2jYgTIj3EmuoZSiujDfgTHgnRI9qBJh5VGt5wg2/VGwzIRx1lRoBANVU/wgRAcxXhtvOpIpdAPI8Y6Npstl5fXbDq5/sqr0j3pgd3Wuc9GJdqcc2y6DSkmcdqlSBOWkvSNg6ZpuL6+kk2RxV0+uNYqGWKMISOlfO8NwRq2bavE/Qw5E6eIMYGuMQSdtDbZwtD34KSy4ShqI4ZpnOhPA/0wLhrIjRdnHOoAjOr07LmL0wa0upGfl+oL2jRxtrFUmz8Ptuv11RLTglQZ1sXIqkNpFhk2TFLayfqOy8x5RaKKyRSbyaqPap35aGz3vIFuKc/ZWkQEkCY9KZ/K9B1rPbbIRDfvAiFoZSe0FAy7YWLWsdK3hyMX+wsuLy+5vLzUudvlgQ96ewSvBKiZqjlZtSOrz7fWqHavWZql2rZlt90sZfEHtrs8I0Xlcgw5R4IztMGRYmLbNtrMJecyjzPGe9rGE7zDOod7j+3WwH213UE788V2N2/ZrqGcUajk5M5t9yxO+YVt9+wtl6mGS1BcwQhTnx1DeY/tPqyHFTCFbIWDaxG//THYbuXTC/IXRAppGnXvKggAYzBZR59nSylVMUE41CE0uNAQVH6o7Rr24445Fq6urtjvduz3ezabTjmfGuiUgpb9yCWTUxJt0nnWgMoI6OIsTdvQdp1OQATfCEXLhCD66dsN+/3+AZB1/rdd7oeMd48lE7SvpPGO66srvLf6jEKck9DAnNhtcJaU4ZAGyngkF4cpVarTkTKM/cTNmztKEbAsBEvXenaaWKEVy7eVXGoC+A53/R27LT+f3Z7d1wefo/GIdABD5eEW/bDKUV0b/PT+KM2ggid/qQA1awljOX3duKWskzVABIx0qRtr8XXEpFIDjNIBahm58iQtRctRMjGiJkGmaOm4lrBLkbucCyUnclrLl4ucB4Z5jhKgKp/lyaPHbLpA8F6CYetUKmq9YSvakxdOT0IzXQTlcgbhUrVb3rg3xBSJsWB9xqVMiqLXFlOhlNpYIKjDqR9o/MQ4TozzTC6Frm25vNhydbVnv9tgEPH+2txkLBgHMgtYA5UHbkopCWcZjpRPigSz5xe4eNf6LQ0kamakP183EHXIRfnDZwHBeRXrDGtAZICqWHfR7PNXf9TEo5ZnpFM54JKglaIRapX7W1QwXzrCrW7C9XvWWZoGMB0hNBhrmaOoUATf0DTSjJHTKvFV11roGWuZVJIogT2sdTrxytO1HTk0hOBpu0aCR93kr68vVaxa37u+v96vKuljkGfEO2i8JYbCfrthihPDmJhjJieZmb3Yguy40tDIjDEerGpJFMM4z5xOPX0/UBsBgnO0weMtYr+lNhrVv+Qs6yZ/Xvqra/OgjF+bQOrFfctx/qP6LNQk3SwvEAdoSp2iVX/L6mvX5LRYFl+D4aOy3RqkOuuxgCML0p4qugFmUfQwD/yzUf1O76WZZr/f0ratajQ6tvs92+2OrutomiCSTPksQVafn4tQeGKMTNO0xmPWLaL8ojTg8N6J3YYgQw+cY7vdstluHiAl3267RmzXG5rgiJEHthunBDniVMnAaHBLKX/ttks+s6Nf1HarDZrzBqw1wFmSO91/4D22+04jSRFzTlnj2I/D7y6ggPZ8eOcITUuMM6UkiRWWrviVi1vtVfyvgFemGNrW45z4wFIcu4s9bdPSKAXQAiXBkrqfgTBJA1Shocj6W+twXhpdN9sNbRaN9KYRO26cJF6brmO73XDuPcrZ9S2gXan6JRnvHE3wBG958vgKY+F06jmdelLMy7NaQQtDIceRbCcKAWclpvLGkWKhHybu76USYa2RALixwp2utBLDsu/L8XCvf+Bn/wrs9qGShcZ+1XbPn4+agNXfPOe91jgD2YN/hgzqhwPUGngYo6MyQ8AYJxqSMVJiLfmbJYMOvsH7BudXtNIoErCUVChQkgqk6yapSCA1yq/dvLUhQKcxpRQBuWkGFmM8nU4YYxbjevL4WknLLOe/rP0SvLEgFFLWUuUBLYMLEgCnYeTpxTUGZEwlIsCfUmaOkZQLc8nkbKlyLLkkbu5u6cJImk/MccY4eHR9yWefPeHxk0t2uwZskgaAIg+2tagM1totV6+zKhVUY7HKR7AIuV9mY0d1bubM8M4bWc6yLjXCh/8+C1TXBeMhjLCGvqVASlGbjgo+fARkKFh0cq3eQ+e8TjlpFxTNO3MWLHrRXQzixITnWEt9cl+91yBXUX9qAIuRBKp+uAalJWdKWrP5dZOvyYdSX5zn4uJSx5BKR3UbvJTRtQFrkRerTjJnCqvcUG1EyFmI/pu2YY4jF5d7Usm8ep04nQaQfIoYEy5GCo6UjPSW5ig2YjOlyICCoR85HE6cjiMgSV4THE3jdJqNIFxy3bw3Ca8cxXcRfRbk6DwoeMfWamDEii7Wd6qTSOrvmeVXV/bT+xzweaCUk0jifUy2u3TLW1EfsdZQYiLbWSZfqXSYdQFng9q3w6pMkvg0qc60raNppcO2FMNmL82P1thVgg5kUXKhJPG5KSeiVqymaV7WuNosGJl1bkRGcLvbsOk6Wi+0qhA8bdssifC/lu2SefUq0fcjMTk6zxJ8WKzQdf6abLciyG/z+JbE6OexXc7iXh7arzl77RJnfMB2y3mCVc7/bz4K262ouzGCFrsCXbthNIZcouz1BbzxOnUqLBWjVcKyBi/CFXdOAl1jGzZ0CH6p6CUCosngnpXnX7n+9Q9I17+zDu8DxlihE+ogoP1uu2i3egWzrHcPTaJwNiq4SIyAwRhBh5vg6UIgeHjy9JrNZsNf/ORL3tzcQrRKJyvEmMFEYsqkHIFZg0BpMnRBKq6nfhB/DXhnCY2jCRbvEY52Dcg5h/7PmqRgmfCm+cCSxH+73eoL+Ha71U+p+OhS5a2/W5Z7+BC+rfVadbxLYvWzjp8vQLVWujGbBmsM/TQxjQMkJcQrZyNnkZ3CJhoAZ1Y4XLMlSdDLMqBLYdPlM3NJ0hB1nr3klTsBLKLQMWaGftSOfgkM99stn3/2Gd5ZLYjVyH591s/yZM0SEN3WKJO6cXZBUTebLaZkpnlmnmdKyjRtC0W6smUqViKagLMtxug0FyIxThzGAyUfIUf2uy0/+tGv8cMffo+L3QVtIyPhmhDwXkrQtZtf7rtuNlk6EtfSjwbXQClGlDdcke7e7EQHDuGcvs1BtmYdL3b+NzVwOnssz+x+WTNrhMdZ6nQlU8hJVRXyjG/aD5nUL+04D4qslh2D95QUyUo7qVNE1uC1WWe0W6fJWKaYqNmy2It3DUYlMySDjNrjlqhNPzknpaZoF/Q00vf9WlFApo7c3x8opbDf7bjY77m82NF2nlAngXCeIetRHlqwSGalpdiw2264vNwzxcgnnz7GOsvd/S19P9D6rTjxZBmHiWwiQ/QUNmTV5s0p8/LVHZtmZhpHxlm5WtZwsd/w9Mk1Tx9fUcqsCU5teHl4nuIQRTA2p5W2cv4yQcI00bJGUM0stvv2UVGw2q16jkmta8OS9S9JqVm+jS1nGGoRPyMJVv5obHfhl5tV1sk7T/KBvNizjPKVEZ8B7wIYdMMXnmOKUVZWG6mtszi8pP4VBNA1sGiz2oJ0F3KMzNPENI260Qv/lCIVqxgTIbQ8efyIi4sdXRtomyAjPuuG+Je0XR88x+OB59+8pLFWgo7Zk/JEKtNfme2+U8Ks51gVN+prfmHbVRTKFOFanvnWpZv/3Ad/i+2C9kcUUZ9YGi/1px+D7Va6WU6ZhKH1nqYRilEqdmn66UJL0AC12qpRHelc8hJU1jWyTqYUFqCkNQkQICU/+FOKUM6maWQcR2k6tQ0ojVAaq2VTvLy45PJyz3YjSKpbruPhdRUe3v+lAKAJTCaz2264uNhivsqamLWkFDmeTjRug5kzblaq1ThxmiEXh8ieWVIuvHj5Dds2U+KBcR4xXiq4267lk8eP+PSTJ0rxEymrKoO22KSpccPDYFN+pHZnDVarScJ5/vnttjaSy3PtHry03i97toD10xc7z3LfxL8V3lrm9x4/l1B/KtKcJHJJM3c3b5iHCWct19fXlCK6pGJsFpszxmrnF5BT1HKqPHY14BRBXXUCcDblZDkBuaAakNWygQ/SIYqgUNM0keLEfrdjt21pmlWHqzJOi2ZoZQl818C1GluN9HNMpCKds00TyPPM0A/kXGiawGazYZyF51H5HtEkXAsYKdlDUmHzCfJM11g+ffqUH3z/e1xf7gje443Ma3bWLOLAFg04MYtRoeNOKwNtkTrRtVyNQK5Y1rT+6urhrGExttrQ8BB5qmWAt9AuwGiZLqsUkmSYHpPkFVV/1tlffampHtJMkpnmhMuZOE7kGDEUvHcEdZTWeuGz6Szmh2iflhCX9bTIaAMh+NcRvbnEJa2qwVCMM9PZQAmvZTgpO0kQPQwjm7aje/yY/X7HZtPK1I5qnmfPRKZQjPxZ5ELJlFyH4Ig+6267Y7/b8/zlG3IW5Yl5GBn7ifZiRymZFDMpG1IpDJM0KBgrzrKUmWN/ZBx6cpQRvj44Hl094vvf+5zPP3/C1dUG50RBwxgJAISL6M7OuyyISj0qKrgcykXKObOAAry7SRhFDStfUb65IlrSi6YVk7eAhWq/aDBUS3IlBGxWeSPMR2O7VQqnlMI4TVgdECKIkpX53b5Rvn8QEXNjKLVZjFreS5ofrN5k2WAKSzIlXLD1v1zSAxm/SheYxroHiN0aY7jY72l1+lSnTZ/vY0P+69puSoVpGBj7iWa3U06sgZhJxfyV2q7TaSjntqtlJ+AXt9366zVoqD6++tzqJ0pZK1zfarug42Y1YfEeZzyWRMofh+02jVA8cs700wjOU0oCUxZ+aeMaWi+0JrlfteqncUCWKX9Z7dY6oQsY1n6YGphK3JCXfohcwYGl8VXWLefM0PcSrA5C99hutrqOQk+xZk0KzqvmSffDYs7UGkqWiqVSHIsR7ewmNALxlEJKE9MwMA0TzXYLFOY5KeJfOA6FprsgmwxmBpuZpp4cJ0giZelsYbtr+c53PufzZ59yfbXH2rxwvKvUm9Akz++EWfaxqq5zziMtOS0V6Z/Xbt253SskW2OPUpQdv1S2JIRet1BtAK/n4T2U+Sx8/vbjg1Z9d3fH1dUVxjsihX4snI4HDvcHSkp0TbtoPcpiAEW5SSFIp2FS2SOzLppBkbx6rXWBaqB4HvlbaX6wWDyO4qT01ARPbpQ7lxOpwPXVJdeXlyIM/SGOhQTyFCSDSGdRQEVVJNiy7Pd7Tv1AcmrgznN9/Yi7w4lhzCRVahDHdY4G58UQ2uC5vt7y3e99h4uLnYy9NA6HSMJQCiVp175BKEfvbNBroHkePJlqLJiFH8yZcVhrZFKSOsHaEVzPuQZx5vxGvPPxa2NZNVoRwC840LLKzJymVT7mV3xIOV0C+ZwTw5TI84wFWh8IoQPEAckSamOUM6ScFrSOuu6lyHQMuyY/payb+nLUB9uuc82XxoizF+WcGIYIxSwahzLJROkoVd/2DEE5/0IkyOyCFJOlOx0rSHHTBAyVAiP3xDsvSFuRchNFxmQLUr86YglgJ2LpmYcDeR5p2sCnn37CZ5895epqT9sIj89ZFI0W2kINwh9s8m8d5+Ui4ZWXJayRZFuz/Hq1Z7YbY1wCBasq6vXn56+vaMf6pJzxvPW+5pxVfVMbKz4S25Vk31JSZJpHSDKpLxhpUrXOyRo5SaysjiqrPmKxXT1qwVjW/ME2T3lbGcJUn2uWZ/38D8A8i8yfwXJ1cSFBs9Npg0WT2fP8/4EJ/GK2myexD2ctTfj/t3duvW0kRxT++jYX3kT6Jq93vfuW5P//qTwk2RhBbIuc6a48VPdMk5KFGMjGeugDCAIocUj01FRXnao63ak9zwL2f2u71mhVBcNis7e/lxLnf2G7T12jVCQXn2Bu1+bbtptvDcXnC4WxhFtB+h+FwvwnSVphLe1V3mXfo0L+1juc8xhrs3RkmcRnIcUkgXFlYNRq4Ap5GHhhlQodAKwJxJLM2lWWEaN2+3B+wGAZ+0FL/uUzFsJqXd+Cxb/ne5LQYLrM00ieB3F5CC7OM5eL1aFCLN4FrYJGtDVQBETVGvSBUfY3xpk4P5Cmz8TLFyDy+vVb3r9/m+1WddOt0XZLHTK3BN+thJXI8qwua1m9BiWYF9I3fG7du7qwxFmVoQzKlsrCeu+l2hvLul3D5A8zOXaQHLA+h2cD1GmaWMRtJRFzZi1Gp427TjOhlLT8Y60jdJ5hHPAhEIvjWQynPFllEq7qZrjZZMiBQ3GW5QxiLUZlphZlbJyzyJx4dTqx3++XcsBiyzerluPTlfam9KrmRc1satcFTndH/vq3T9iLHhnYDwO73Y4pCsjEZA0JR3I9wXcY63M2ZkjiEd+xGy2vTkfevX1D13eatem318GtzFKbpMeQPlm6ZGXV1iUqhlQShKcCAlP9nzDPKztYJMCgZqz0/bXhCCZPSpOPDI3LWfaGpMF1gilelvLMj4aITqJ7a5ij9qNO84XehbyZr/ZYnL2yqJY0FdmiOhlg3bwNWRaqIK1GVb3POYeXRBSP9zNdCFkE2mkf3TQhkiWbyrGS+u2hME5AVfADtCldqgQs5V6OJDngtVpp8M4vG9dm3PLqNDP2W87nizLgxqBHZQ74rkNcUOcuOqiRoiaHoXMcdns+/HTP69dHNuNAl48ctdkxW7MGNHBFPF3dk/JT7EtS6deV5TnVpVzfvJ6+tcqrFWepTGPFcOdEq3bIAMmIPj9ZSBtysJAbiuIcX4ztAosweZKU/ahR/1IqIOQ1MkY3hnxUmsSYS3FZAeAmeVojR7naiKAE7qw+f57xSfDZ19scvM3zjKQZa6Dv9bQza1c/qhcrFZoSaen3+17bTSkx9APHuyP77ZYvX77+Ibarm83T96Le7IHKdtM3bbcEBbXNp6TEQJFdrIPUtfXladst11YeMS6Dl6T4omzXe79ops8xqY5nZkvLeoAm8M55nUifdQ8zN+tfJ/mxDPFVgeSKTHpVPsE7p6dCBW29E2TR7bXoQGQIPitYsF63SgdEf63fp/xnzfaKgBUkH83ahaAJpnf0Xc/hcGC32XI+n7HOIXkwz4YeGwLiA9ZZLImEJ87k+MrSdyMffn7Pm9cndtsBn4e2na18Lixtgbd9/jXqwUutYD/vc2/tdlXreOxzQZNSe3VPDKkm0vJR6KqpFbXiiqohPYdnA9T7+3tOpxNDF3CSmM5f6Z1HkuCtYwgd3ltSKhOdPcMw0g091lliUhmBEBzO6+IUxkolHsxCiV9vZuXBlcVhAsukow8Ou/HECNOkD2fnPMfjkXEcKhZzHZp4xONcEVqyOqh8ipT3lu12gw89n/71leA8x8MdMRvm2PcM/Y6YHLM48D3ODcpqGHDMWBGC2zEEuNtv6HzITIPN+nia/WuPTmaZsbnPZu2jXFD18V1nOaVmln+K0ZlVv28dcHDL32pGSl9br3lb4pdyXKEIKX6G9BnHhDCTJlV0uMxnHs6X50zq/4bD4cB+v8cBk3dIjMTgOGy2KosWI951uOApfU4uOIYQiNNEDsspeqUx3faq5TJGuQf51Zpl8d4jWd7E5E1/3OxADPM0M10mnDEqn7Lb6OR+uVod8N7iib8tLGOcSVEDuHEcidPMuN3w8ddfuX+XuJwn/vH333EhgLUk4xA74nyP+E6naOVCvAhxdhhG+mA53Z347beP7HdbQi6162EdEKe4lMJcp1+sZO61/ZaAowSoxhg9ACNV9psZDxFT2XdOJ03J+FfbLJWZdSKYRxtdbb+aCD+AfMbKTIoXIHJ+QbZ7d3fH4XBgOj+QpgtWIiRR9tSq/FfKwzsudFivCU6aI1Nd0rPaHw5kJmndghZ3V32uMSZrIgveePquo5xKpr46cD6fSVETOGcMb9+8YjP2qv8o8vSFa3yn7XZ9xy+/fOT+nTBP8Q+zXUE4m0v1fa4368IiQdbNNEosmBu/W2y3VhFZr7VqhJf11vPN3RKgfst287tBLiT5jOVCjGdMmjlPlxdhu4fDgd1ux+XBIZXdqsoMOiBEUiWFfsR3AdUBh5lZD/bJov5zSrnXOgeoJs+HpOs1XWIIu+6LXQw6IyGJ4/GEd/2iP11UJg6HA+PQ5YpVVVUwa4CaX3yEZZ4m/1mrVNr/fTweVa7QOX768DOvTvdIgn/+/gnfdVrRNCBuANeRXJ9VDxJMPeevBmd6vBfGvucvf/4Tx7s9XT5Eo9henCIxB+ZzfMrWrvf4MmStAWo+UOA77HZNqMwjnwtwS4QKdtW1NoIejnLGpK/4dAbRYfNp/vezNmWeKsE1NDQ0NDQ0NDQ0/Cj8eHXfhoaGhoaGhoaGhgotQG1oaGhoaGhoaHhRaAFqQ0NDQ0NDQ0PDi0ILUBsaGhoaGhoaGl4UWoDa0NDQ0NDQ0NDwotAC1IaGhoaGhoaGhheF/wCOFTSJ5YxtrwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "

" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pylab as plt\n", - "%matplotlib inline\n", - "\n", - "plt.figure(figsize=(12, 12))\n", - "for i in range(16):\n", - " plt.subplot(4, 4, i + 1)\n", - " plt.imshow(b[\"video\"][0, i, ...].permute(1, 2, 0))\n", - " plt.axis(\"off\")" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [], - "source": [ - "## Cleanup\n", - "import os, shutil\n", - "os.remove(\"./WUzgd7C1pWA.mp4\")\n", - "shutil.rmtree(\"./dataset\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5-final" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file diff --git a/examples/python/visualization_utils.ipynb b/examples/python/visualization_utils.ipynb deleted file mode 100644 index 2f042cf02c8..00000000000 --- a/examples/python/visualization_utils.ipynb +++ /dev/null @@ -1,683 +0,0 @@ -{ - "metadata": { - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.6-final" - }, - "orig_nbformat": 2, - "kernelspec": { - "name": "python3", - "display_name": "Python 3.7.6 64-bit", - "metadata": { - "interpreter": { - "hash": "b59c5859fdaa326f162dbe4b890c245edf044b3a52376874fe660daf6e3b88fe" - } - } - } - }, - "nbformat": 4, - "nbformat_minor": 2, - "cells": [ - { - "source": [ - "# Torchvision Utilites for Visualization" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "source": [ - "`torchvision` provides utilites for visualizing images, bounding boxes and segmentation masks.\n", - "\n", - "All the utilities do not perform inplace modification of inputs.\n" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torchvision.transforms as transforms\n", - "import torchvision.datasets as datasets\n", - "import numpy as np\n", - "import random\n", - "import scipy.misc" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "%matplotlib inline\n", - "def show(img):\n", - " npimg = img.numpy()\n", - " plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')" - ] - }, - { - "source": [ - "## Visualize Grid of Images" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "source": [ - "Use `torchvision.utils.make_grid()` to create a grid of images.\n", - "\n", - "You can also pad, mormalize and scale the images on the fly.\n", - "\n", - "This utility can take 4D mini-batch Tensor of shape (B x C x H x W) or a list of images all of the same size." - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "from torchvision.utils import make_grid" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "torch.Size([3, 768, 1024])\n", - "/home/oke/Aditya/PyTorch/vision/torchvision/transforms/functional.py:114: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at /opt/conda/conda-bld/pytorch_1614931498178/work/torch/csrc/utils/tensor_numpy.cpp:179.)\n", - " img = torch.from_numpy(pic.transpose((2, 0, 1))).contiguous()\n" - ] - } - ], - "source": [ - "lena = scipy.misc.face()\n", - "img = transforms.ToTensor()(lena)\n", - "print(img.size())" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "imglist = [img, img, img, img.clone().fill_(-10)]" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-24T23:32:48.421838\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "show(make_grid(imglist, padding=100))" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-24T23:32:49.291422\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "show(make_grid(imglist, padding=100, normalize=True))" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-24T23:32:50.133283\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "show(make_grid(imglist, padding=100, normalize=True, value_range=(0, 1)))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-24T23:32:51.060394\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "show(make_grid(imglist, padding=100, normalize=True, value_range=(0, 0.5)))" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-24T23:32:51.844460\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAABpCAYAAADBa2OhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACky0lEQVR4nOz9d3Rj933n/z8vgIveQRAECPZehzOc3vuoWN2yJUuWbbnGdrLJxo7jxJs4ieM4Tuy417gpKpasYnXNaHovnMYZ9t5AAETv/f7+kDcnu7+d2axX/kabw8c5PODlJXHveYF488PP/dzPR5AkiWXLli1b9p+L7D/6BJYtW7Zs2dtvubgvW7Zs2X9Cy8V92bJly/4TWi7uy5YtW/af0HJxX7Zs2bL/hJaL+7Jly5b9J/Q7Ke6CINwiCMKIIAjjgiD86e/iGMuWLVu27MaEt3ucuyAIcmAU2APMAxeAByVJGnxbD7Rs2bJly27od9FyXwuMS5I0KUlSDvglcNfv4DjLli1btuwGFL+D56wE5v7N9jyw7n/+JkEQPgZ87Debvb+D81i2bNmy/+wCkiTZ/1c7fhfF/d9FkqQfAT8CEARheQ6EZcuWLfs/N3OjHb+LbpkFoOrfbLt/87Vly5YtW/b/kd9Fcb8ANAmCUCcIghJ4AHjpd3CcZcuWLVt2A297t4wkSQVBED4N7AfkwE8lSRp4u4+zbNmyZctu7G0fCvlbncRyn/uyZcuW/TYuSpK0+n+1Y/kO1WXLli37T+g/bLTMv9cff/ovsFqMeGfnqW1vpcJRTX//FUYmB2kvK8NW7eLY6T7Wr9uExWKhsaWZvlOnmPQlUIp5Wt1uQukE7uoqxieGCC36KZbyzM/M8+BDH2do9ByhYBShWCCRylDldJHMJYlEIhiMdvLpGCt62pHJdcikHNMTQ/T29pIVBIxqPeNjkyRTUVpbOvHMz5PMJ9GqzMj1BlIhH75whHw8RVoAZbaI0WZkbGqRTEEgL5VIJEPEYjFUKhWiDpTWJcorJQSzlsYWN0/+0/Nkgga++q0/5ev/9D1QSwi5AumkDJlOQWN7Pc32SrIJH9/56uEb5vjnf/wVlEoI+5Zo6OpAQI3fv0gg7MUmSNgqXbx57BS7d+3DbLNSU1PD1fPnOXVxhLaOWqxKJTOLCzS1t7LomeHSuQu4KivwzHl46IOfYmjoDIsePxazkZHhMapdleTJU1tbSyicwqBR0NBYTSicxllmZnpqGLvdjr6sjEIqw+jIJLYyAxWOaqYmJpjxz1HjbEBbZifm8xDLpIj6guRFBVIshdqgxhdMEk3mKCCRTIWJx+Notdq3crT5sdjzqJ1mausdPPn1X5MJGvjiP3yK73/3MeQ6GVImRy4jIteL1DbVsqa2hfn56/zoG6dumONffu4fKRRSZON5GrubWVqKk88niSdC6PN5HDW1nLp4mbW967Day7Db7Vw8fZpJT4TVa7vQlHKcvXiZmsZ6wiEf1y9epr6pnumJaR7+wEeYmRtibtaLTJC4fm0Qm8mM2W5m9dq1zM/5cZVbSGdiFNFQX1lOPLbE4OgYDS3NpCIR5DINaq2AQqZjYW6ORX+QmpoaVBYrhXiEvFTCO7tARiYglkrkc1mSWYFYKk8ymyGZCpNIJFCbDeiUEooyLwZzHmOtlaqacp7+5quE/BY+8oktHHj9LAqDglI6TTGvRm1V4aiysadjK0OjZ/jB10/8LkrCsn+nd3zL/fq1S0wPTlDT2EwqnmDg0iWy2SwajYakRo3BUklgfo5ssYDFYScUClHX2oRdr6OjoZn+4UHkoo6wP8DC6CTBaILu7m56V63j4uWTLPkjyDUadt52J7v37ODsuRNEIhEcDgcnDx+gs7OTiYkJrly5wvlzJ2hsbESpVJKMxpjzBvAG/Gg1ZmKxGP5YHKveit/vp+/ceVLxHHKZilC+SDQUp6DWoFTIqa9xkU7HKeVjKBQKSgoZMrWSdDhL3C+R8JkxmdU8/c3nSU47+eyffZJvfv0HiFoF0aU0kXCC+jYnK9e3YqvUc903QKhw8xzPnz9JcilGJJkmFo4wOzmOSqUhlUoRAmQqE4H5Oabn5zBazJRKJRo7m1nV2Y5YhNHpSQRRi06pxj8zj8FSRnd3N81N7Vy9dpax0WkCsRgbt+xi85YN+JcWMBqNBAIBxgauolarGRoaYmFuhsPH9uN2uxEEgbGhYYbGZwlGw8zNBhAEAV80xprOXkKhEIf2HyAaSZDPlYhJAj7PEgqzhTKrhXKrGUnK/w85SqKcdDhL1FciFTCiN4i8+N39JKYc/N0//jk/+MbPUOmVRPwpopE0zV1VtHRXY6/Wc3rqPGFJvGmOb7z+MuqSiCceIhIM4ffMY7NWkE6niSkUzHmWCM55GB4fQ63TIkkSa7aso625ieEr10hmc8iVBjpb2oj5AlTWNbJu3Tqq3HXMzk1w9cowUwsLrFm/lbXrenG6ymhsbGRmbJRiOk4wGCSdTqNXi5y7dAqj0YhaLhLw+fGFUpztO8/Q9TmcTieCRsvq1asJh8OcOHKUyalZAkthkjIFkWAMpcWFw2ZGr1ZSKGT+xxyLSdKxPPElKKSMaPVyXv3eUaKTNv7qL+7l0MsnEI0iYU+YWCRL66oaKqqtiMY8r189iCdTfPuKwLLfyju+z/3l548zNjaBUafn4PE3SEUTlNlt1NXUUsynmR6fZGXvak6cPEn3qk48i0H23PYugokE6USctqo6FuenOHP2AvZyM7Fslh2bt/La6y9SyAtcH7hCR3Mnx04cYkXXChpbOwhHltBqtVgNFnxLXuxlJor5ErlCHkd5GXK5HKVSSSQax+8LY7JZSUQTuFsaiPgDOG128hIsBYIYNXLGJ2bIZFMk01msZTaCSwG0aiVL8TiqUh65KGMxkCJeyqKWxclrZYilFKF4mN/7vbvQWlV86/uPIRNU9K7uxhdcRKexUpBlSBVyeAYThBaX8A/Hbpjxi88eZWRkjCpXJWcvnSQTT5Ev5LCYjAhSkaFrA9x197sZHR9BkhfRaM2sWreBZCHHhbPn2LFmA0H/AnPzHrQ6Jf5olC3rN/LyK88TDiWYX5imzGQnEPLS1tJGMlugWMpSXl5OMVNAEkrU11VTKhQJhkMY9FoMBgPV1dV4fUtcvjJAU0sLAV+AmtYmlDI5SmTEUmmGR0ZpbajCtxTA6w9QzGfRG80Eg0H0WjWBVBIhmQR5iaVghlAhhVGdpWSUI8slicRjPPzINswVJn7yixfI5Yqs6u0iFAugVVvIkSJdzDN3LYp/3kN0MnfDHJ/8xatMTEzhcjsYHLqGTqlhfmEOuQB6rZoTR46xZedGaqobuXDxMo3NLfSs2cD14QH6+vp4//13MD8xT75QYmR8BLPVQkdbK0eOHsTn85PP50lGUlRWOSgvq2B4fAKlSkZrYz2zM4uUV9hpaqxDkiSCwSByGagUIt3d3Xj8QU6cPMOKlSvxeXwYym101jeRSCSY9SwQCEZorqskm88xPDpNNJLAVmYkHomiVCmIFIrkg0GypSyRdIFwKoFFlweriJB+K8d97+qksbedX/z4GTLpIl0rmomno2hUZrJSEllRzvUri3hn58jM/9/VhWX/Ljfsc3/Hd8vU19dz8dIFXnn+STbt3k3fiRMsLiQx6+RUuerQGU0YTSbmFmeYf2mUe+59kLHhIU6cOkm908nxNw+wdfN6quorkWRyZs+d4qRMQK0xY6owMTY9idqgoqOjE1uFHb3RAICUS6EQBWqrKulZvZWKOjdCPs/FK5dJBP24XG6mp0/T2NqGSiFCtUiuUIC8xIzPT2tdPadOnWLX9m3su6uDxFKAi5fO4/P60epNRAMeVDI5FrudoH8JjVZBKhgmlEqgymixVGnwBGb5yU/2U1YhIhQVJOOwFIwgk2tJp9NIJSWBQS/xUBatTAfcuLhXVlZy7PgRDr/xa6pbWpidGKPS7SSXDtHY0EE4FCVfzHF14DK5dIR3v/sRBvqvcuTYUartDn4x8hN2796J3VVGKBpjZOAqQqmI01WHqAygMeoRijnKK2woVCJrelah1+q4cPo4zkoXOo2aO+55iJIoIEoS5y/2EQ/4UCr1LPlHWLVyNXq9HoutHJlCQTwQIqfXIcrkKOQyDEYrok5HW0szV/svEY3E0RtNLM5NUCyWqGmsZ3F2Ho1BiSYcJRxKoisaqag2MO+f5pe/PI3dqSSdyCDDQCAURSaqSSaTFPJylkaCpMI5LEobURZvmKMokzM3P8XoxACLi4soS3kcDjsloUBzczfhUBSHs5JjJ4+y5J1ly6YNjI8McvXCRZrdlbz2wiusWr8Wh81GOJPk8vmTqEQF7R2rSGROY7M6Cfrn0Wu05Mlz9733YLOYOXvqMCtXdSPKFey7/X5KokApk6F/oJ98PEQmDzPTs7S3dVJuK0cSFDicTpb8IczOctRLQUxGAxqtkcnRQVZ0tDI5MUo6nUZrMuBbmCGdzlDd1IBnaga9XkkuEyUWzWKQaSirNuINzXPowBB9V8aIheOY9S4i8QQyhYpkMkkyUSI4HiEfz+I0uJjC83aXg2X/B97xLfc//eO/4+KZY3R2dpIIeRidnMFoMhOKhFm7bgWHDx6huqqFcxdOc8fddzI3v4hEkc6u1Rh0KqzWcp575kW6epporG/A4/HibnDz7BPPsn37drzzYxitTrxeL9lUlN5VaxmbmsZu1rNhw2a8Xi9l1VWYLGYW52Zpa11BrlBgZmKc555+ErlKjd5iIRFPoVFKJOJZFBoVWrWFxjoXGoOJ2dl5OtoaMZvN/OqJfyGRyZLLpBDEAiatFdQqotEooSUPmUKRdCaHpJCh0csQbXGSySSV7hoMFSoUohq5XEbUs8TkYJB8Mo9cVFPVYOLkyzcecfrZP/wSV86fZMWKFWRifvoHR1BrtCRSCbq627hy6TK9qzZz7sJp2rs68C+FWAr42LHzVmKRAA0NLRzcf5SG5krWr11HJBJDUAs8/pPHueuuu7h84TjW8io0WhUhv5+O9k7O9l1ky/rVKJUa8vk8Vncl5eXlxMIRWtq6SMRizE5P8dzTTyJqtJQ5nfi8S1hNaqKRFGqDDoVCj0ZRwmwpQ1CIrOhqJZPJ8MwTv6CIHEoFMoU4ZSYHGSQSiQRB/wIFBLK5AkUZ6EwCcnOCRCJBS2sHollCkInI5BL+SQ8LEwmK6SJyUU1rdwVvPHXhhjl++uN/ztDVC6xfu5JcIsz5K9fQ6U3EkhEcDjvhYIjmlk68Xi+iqCAYjRMJB7nvPQ9z8cIZVnSuw+v1kkgH2LdnL2azlePnjnPi4Ak2rl/LxNh15CojjU31eOfnqaut50r/Vfbs3IXH48FisWCpdGE2v9V11tTYxuLcLFNTUxx841UUah1mu41YOIZepyCSyGCxWBAEDelYgHyxxIqVq1nR1UokFOb5p58gXyqRz+eJp0M4rC4imTSirMjCwgK5kkQ2VwBRjs4kIRgTpCI5OnvbEfRFEBTIhAJzI/P4ppMU8wUUch0r19fy65+e/L8rDMv+Pf7fbbm/8sor/NEnPszFS1fp3ryDYOxVUskYVouZbEaid81q6pvbaW2rYXB0kn179hJOxGisa+bSxavU19ppanQRi4Y5fPAAm7fvQEqm6e7upESRubkg1XI19dVVWFzraaisYN+tt6EUZQyPjKIQRY4feJ1wIkJ3+0oMehPV1dUU82FUahnzXg8tdjuFbB6lyUEu6sVuqiAUijDnCRILT1FeVcHJcxcpFvOkkGN3ubAaDCjVGtw1LsYn5ijmxlA43ATDYUpSHIUoQ65OkwlKVHc0obaLqDUGZEKBoYuDRKYLCJKEXq9l4971KDTiTYv7yZMneeT+u/H6AqzduoHZxX8mm0nirqykVJTR0dWJ3W1nVamLfEnkgXffx9j8HM4yF9lyFzJBQWODk0DAz5FDb9LevQJVEdraWkik4ogKC4VcBq3JiK6plZWreti1Zy9KUUYwFCYYDPKLn/8EvcXExg1b0Ov11NbW4vfkKLObGJtcQGk0UMjm0ZvqmF8cxuEqRyZTUCzmiYRT6KwGXj94lGIxj9JUhlKU01RbiyQoEBRFvL4wvoVZtNUNhKNRQpEwalkRhZgnEypS096MzCIgagwo5SWuX7hOeLoApRJGo5aNezciVyt46z68/7Vr167xrn37UItanFs2c210GlEhUF/TiFyUYzQaKQoF5IoSjsoq9u3rYC6wRD6b5T33v585zyySJ0EmnaTv/FmsZeWUafXYLCbCoSXq67qZmh0ll0yjt1ewqncle/bdQqlUoL2rk3Q6zTe/8TVUei237LsdjVJFldvJ0uI4K3o6OXjkJEqjjmQihdVSQyHnR6u24HZXMzYm4dKbSWVzPP/y6yQzaUoqPSpRRrPLhdFsIxjzo16KEfDN0dzSyaLPRzgaQSplkStKpENFqlZUUzJIKFV6FEKOkYszBGbSUITyeitrVq/7TY7Lxf0/0jv+gurenTtwVNfQ1NaKb2KRTdt2o9OoqHJWoFeqWZhcQKsQiUQzqFQmAn4/xVSGf/7nH9HQ5MJoVrFhy1YmJ2ZZ2buOZDKJo6aWdDxGxO+nY2UX/kSSqqoqQosLqJVqLl6+SkmuoqmhGXddDeUOEz6fjzcOvsq5c0cYG7vKylWd9K5eiUGr5UrfBebmFqivr6XcXoFcLmIwmlBqdBhMViYn5sgk8hTycvRKM3JBTypdQKO18srLBxA1OqwuNyaNGZvZhsvmRKXUoJKbKGsow2TUoREMqASB+Ys+QmNZ0vksG25bzY57t1LudqM32G6a465tW5nz+smUClw41seOPbdhMuhoqqvFojOwOL1IPBhCpzVTU9fK6Og4UirLCy88RzA8j94oYrM7CIfitHf2/GuOWqXI9Ogoa7esxVZZRUdHB/JCDqkoMTQyhkpvxqg1YrJa6OhsZGnJxyuvvsDx42/Q33+WxqYajCY9CpnE2MAAoVAEtVqJVBKYm1sgEo1RkAQkQcn8nI9MIg+SCrPaRi4jZ3BokkQyz8W+a6h0Bgx2BzZDGWpRTWN1LVqdCVHSYG9wYDEbUMsMqAQ5Z166jG80TSqXYsud69l53w7slZXo9Nab5viuPXs4c/4ik1NjjF4aZUXPamRAZ0c7Jo0Oz9QisWCW3lXrWbd+JyMjY4QWvFy/3s9rbzyHSWugKAlUV9VjszvJ5NMY7OXU1VQTy+VZuamXvXfcwa5duyg36sln8wyNjGGx2cmn86h1Wlpa64hGw7z40rO8+eaLjAxeoaW9gbGJUaRijomhIerrmikJJZLJNNPTs8wveChJMsLxNDPTHpLRDFJOSYXZRToJkWiGyakFFmb9aI1mtHozRrUJoSTQWF2L3mBBXlRR3liBw+pALTOgRMbhp8+zMBInR4kd925m0/Zd2JxONFrz21cElv1W3vEt93vvfYQLF87RuXIls/YZDr/xOmvX7aDv3EnKV1RiNZdTTOWoq65i3+0r+Zd/+RkmrZIVXZ1Uuhv41QvPo9MqWb12Hc2dnTzz+OP8/OeP8fnPfobGzmZEuZ39rz5NOlPAYrHg8weQyWQMXLqAWqvilVde4Z57bmV4eBjPvJ+p8SmsJisuRwW9q7p4/fXXcVgrcJbbeePV13j00UeZXYqQXgoz71ukIEEuncKkc1Aijd5kwu6qQKVSMTM1TWWFG9/CPMlUBLPFxuTkJKvXrSWeiWE1m6lrbGfTth0oFAqikTh/c+ELdG4woDaBwWRAo7FRLGWRy28+XKa3dwuvv/46H/zY+zh29DCzs9NUupsZuDZIVV0tRr2VcpONUCJGW0sj//KLn2Iz67hl7z5qGho5fvokJr2G5vZO6ltbOfjaa/z854/x6CPv56GPfIh8Tkvh7EECkTiWMhtj45NojSZOHzmI0Wzg4MGD3HrbTmZmZggH44wOjeIoc9BQV8P2bRu5dOkSNa5GKuw2Zian2LFtEwuhJOpCiTmvB5lcJBIKUG6vQCbkUao1dDfUkS8WSMTiuCtq8M7PUSimUSm0FNJ5mlasxBYNoBJF1m7YRs/qtchkMgYHhrn22l/TvEVAa5RhMBlQKs0UihkU8tJNc1SozKRSMm5/4CEe/8VP2bJ2DbNTkxw7dBhrRTkmo42WBhdezyL1zR1cvXoZq8XInt23o9JomV+cpaOnk0VPgMb2dvrOnuG73/o+G9b08JnPfIG5WS+DV68hFEBvMrIUCKHS6Tl+5AA2m43Bs4P09vYyvzBDOlFkoH+A+upmautruPfuW/nud3+C3V6HrJDCoNPT3d5GvATpUJSCHJLJKEgSOq0BUaVGosDatWsJRcLIBRlKuRLf/DySANFcFpulDHddDRqDHrfLxbqN22nrWkEul+Pll15lpCxKeXsJnUGNwWRAoRHIF9KI7/jK8p/fO77P/aXnzyEq4Gff/jp1zfUotToqXW5Grl+hvqmZibEhJiaHuf32ezh+/CTtPd2cOHGGTNTP6t4tFJHoWr+al554hsamajweD93rtlLjcNA/2s/ivI/O9haeeeZZPvv5P0PKRGjtWEUhHWfB42Mp4MFoqeDAa6+Sy8VYCszyvve9D1tZPXOeYc6e6gO0VNfW03fxCna7nYbaNmz2MrxLfvoHBqmudFHurCASTuGdm0Cl1xKJRGhtbsE778PqUnH+/BmMujIy0SgWs5n7H3mI9tZG1DoLAyNjeL1eDAYt9ko3X//5H1LusGA0lqPWKAgsznHl8jUuvj5xw4zPn57h2NGDeEYHKAhFWjo6SacyXLt0HoutjGIhg88/T1fnKgpFiWQuRSYrMXy1j54V6wiEQ6zftY0rx0+h1orEYjGaV6xFns8RyUQZHRqnd2U3A/0DPPToo2SiPtw1zSiFItMz80zPjNHW2cuTj/2CTCaCSl3itttuw2iq4tjJ1/AuBCiV1PSuWcehw8eora2lp2s9Y9PjiKLI0PAojvIytAY9GrWFhelh4qkkHu8i3Z1d6NQatBYZJ04chaISsVTCUV7Otlv2sKZ3BSqtmaGxCcLhMHK5gLOmim88/seU260YjeUoVTI8M2MMXB/l8v6pG+Z4pW+Rr/7932IzqNCpldQ1NrDoCzA6cA0As1FDJLBEuctNZ89K5rzzOCqqee7Jx6iubsKfjtHb24u+JBCKLJHNZimvaSUTCeLxhZCEHE0NtZgNZlpXrMA7M4arqh6zXsfc3ByXr5xn87bd/OSHPyKVCtHcUsWGzduRoeXQ0ZcI+uIIgo61G9Zz5ep1KlzVNNW2cGXgKlqtlqHhYVxOJ+lclo3rt3D88AHiqSSFUhFRrmBldxcFIcn5C5dJJBIoAbkEq7ds5L577kCtszAxM0cgEKBYzFNRU8kPnv8Cdstbv48KhYLZyWuMjkzdNMdlb5v/d/vcX331V5TpNZRUekZGZlAp9cSCYawWK5KgYGXvOurc1Rw/exadVo3Naqau2o5nrkg8HWL37Xdy+MDrrFjdQyDgJxiLoFWKvH5kPxRL1NfX46qs4PN/8WVkxTQJSSBXyCNTadEbNExOhjh5+gSPPPwhDh56DbPJSjpVIhH3UWEpw6SVcfrcWbQWA/VNzYQWQpRVViGXy5HLgzRUVpPKpzl/8jQtzR24K5wkMmk6N2zl3JlT3Pfgezl74QzKooAoyEjmU7zngY/S1dHI9aFxLl8dJBiLkIpFGJ6c5RMf+wgVTicGvRpRBcePHCafyiFJ8pvm+NTjP0YlKzHtC1PjKieTkhHyLVJd04DOoKfcbkPKdvHc/tfpbGqioaWRC2dOUl1Tj9Yosn3dLoauXKKupYlYPMSFK5foWbOJs5fPEwiH2LltOzVVbuqae8gkkgQjSTTGEJWVlWi0SkrFLL/4+Q946MGHOXJ0P9FQAp83QlVVHTs2bOTZZ5/Bs+RnbNqG2VZGMS2gs1ioEVrwLc7QWt9IMpdifnIadyUYtRrUajU2azlqUaRjZQ/Tc1Mo8hI2q5Xg0jwf/fijlDsdTM56uHTlMLOLC6TjUYYnZ/ncn36G8goXJp0amaLIqeMnyCWzCKhumuNzz/yCCqsGoaTFZDbR3LqGyYkncVfVotWpMBqNSCUZx84epTJYQymf59TR19iwcSt2hxW5aGFhbpCMzoxcreTEsSN8oKWL09cuEw362bpnH85KN0qNmaDPSyyZQVr0YKivRyFKaDUiP/nxD7jn3js5cvRN5ueCxCMRamvN7N26jV//+nmCsQTeoI9oNM7ajXUYy6zs3H0bwaUFipkCRpsJn8fD0PUxRAHsVhulosCOnduIZZLkC2liiwdwuSvJZaJ8/s/+HFOZhUAkwalzRxgYvE40GsYbivHHn/k0ZbZyjDotElkOvfkGsqIMJOXbWQaW/Rbe8X3uc1MTaLRa6urq+f0/+BNqO6rYtHkXSm0ZfWfO4JtbIJpOImWLbNt7G4def411qzeBJKFQqJgYnaClvYdyVyXpYhGZXMVLL/ySDes3YbGX09rexcTEAkadDJPFzLr1mwkv+ckmIix6Jrl0/hzX+wf466/8HTZDOVabnpdffhVRlHPkyHHsrno++OGPoVXpCS55qO9upLKykkw+R1vHCtKFDKKooKqmjnQuTTydQqXTkS9k2bRuDZPjQ9Q6rPT0rsRmFvnU7z9KpbuMQDDCvHeO5198iQOvvsC1q300V1ei1mRRKUROHDnCm68fIZMuUd3WwM47tt00x8CSF4WoQiaT0dK2hlDCS1NLD6YyFyODQ0wMj5Iu5mmtb2bzjr3sf/ll9uy+jbm5GTzzXjxzHooKJTqTmUAshkqp46UXfsmuPfuob2iia8UqrvYPUWZSYbZa2Lx1GxpRQTISYMk/y9mTJwj4l/j5k0/gsldiLzdx4sQpvN55Ll2+ztrNu9m0dRsySYZBpyaYDWM2G6ltqKe5tZOirEQmk8FsLUMmyijJ5DS2tuKqrMBuMTE+NohJKdC7djVVVRY++vH3kStlWfT5GJsa5qlnfsVLzz3F9f6L1DnLGR09i0YucvTgIQ7tP0YqWaC+q4Xdd908x1g8jCiqGBwfIZKQePPoK9RUtbN6w1aK+RJzk9NYzCZ6O3roXr2WSxf62Lf3XZw9e5qBa9eZW5xm1udHqzeQFwS0GiNjw1fZe8ttGBwVrF2zgb7zF7EZ1RjNFjZu3kJDTTX5Upol/zynjx9jye/l1TcPUl/ThN1u4dTRE8zMTDA372PzztuorWtgYnSCcqedQ6+/jiAISHIZnqUQ1Q01b91wlUijUckwl9lZu2kDBouBsyePcvzEYWJLXjq6GunpaeSDj95PJBVhdn6ecxfP8OOf/owDr7/CyFA/BlHGhUuH0Ikqjh48xNE3T1OSoGVVJ3vu3v42VoFlv413fMv9449+lGgqi15U8dIrT9HS0kYilaKYi3H73Xdjszl4+fknaW1uYWZ8ipqKKva/+jLRaIQ/fPgDnDp1ivIyKzPzM1iMWk6P9lNT08D5g4dxVLoI+T2cPnGYKreT1vYOJiamUCjUXL54GVelhawkoTdY0StFaurKiUdAUeogEEihVOvJZCAelaipbqSmvoPRkSmCoSXivkXioSVsVjvuKhdBr5+atk4CHg++JS/FUom0DMaGBhDlBSKRCOl0CEuZjdHRYTR6A9PDl7AYVSRLejQaE3qdnSd/9TizgTEEmRxnjZ2KWhdueyMy4eYtzh2bt6Ez21i7Yh2esB+NQo3FXkYo6GHnnt0UJQWH979IW1sHVy9doaW2iZeee450Ksneu+8llUphCOsYHb5OZ2sLF08cwWZzcP7gYfJSCc/sJNev9lFXW0Vn9wqGhkYoFYr45qeodJeRzOcpFGU019ZgLzdSZlXgsFgAPaJKR9+5fixWJ2aTHZXOSKfFQQGJi0cPshQJU+5wolAoKLfYUFvt5JNJovEIjU1N9F04i1DKMrU0y+joKHq9nHUbe1lcnEOhUDB06QwmvYg8b0enNdNQ38lrB58jlg2BIMfdUEF5dQVuexMy2c3fEplokq2338nG7bvxzM5w9epVtm7ZzfTIVfKFArWtXVy83E9NlYu+cxdwWO08+9QTWC1GXPUttLe2oNNoOHP2GHv27OGqskgwsIR4bYDFqVm889MUcikuX73C+vUbuXKln0QsSjGToKraQSybhaKWXVs2k4wt0dlSy8xiAkEwkM2nGDx/jWAkjd5oIxLNcP8D7yeSSjBy6iQj42Ps2XsL0WiUhppqWnrWMjU6RCyaZNv27Tz11C+odNiZn50gl0uxFFgkmalkKTKJVqulv+8ERp2CQkKNTmtmw/rtvHbsZ0QzERDk1DQ7cVabcNg6eWsp5WX/kd7xLXdfJEN7Tw8L4RBlZgtHT52gWMpSVl7O1bMXWVpaIhBI0dTSCTIF9S3d6M1W6mobOfbmATKRHFKxhNtVwczUNH/0J39BOBxmMbDAxPQUCgTkcqhtauD64CDOChdarZaauioEGSiQMOnVfOiDjwAlKsscuKvriEYyOCuq6e5Zy5PPP4/WYCXo8dPe3s7gtREKMjkGq42dO3fSf+k8CwEvw9ev4pmbJZWMMHCljzfffBOlWkVBrkCtUbL39lsYGhjE7w9w6vgxnnrqFXKpJNX1TWzbtoM979pOMOzBWK6huquaqhY3blstcmQUiv6b5qi3VWKy2znSd56ha/1Mzs2w6JlFpdHQf+ka0WiUQkFJU0snjc2tyFRGtCYL69ZuJBEKMje2gF5rYMf2rVy+eInPfeFLhMNh5rwzDI+NEvT5EUUZK1av4uq1a9TV1uN0OqmqqaQk5VHJFFhNOlb3dJFMxik3W6iur2du1o+Aki079jLp8WC2VTA3Pk06nWbg0gAzi15aOzppamgkEQnQd+0yIf8i169eIZWM8OqvnyWdy9N//Rp5mZzqGjdbd20nGo5w8fxFTh47zv4DJ8kk4tQ3t7Ft+05WbminUEyjd2ioX1mPq9GJy1KNHIFiIXzTHO998EPMer28eegAfs8CRpuF/a++xOTEDNl0kWg0jCCI1NQ1sn7zFlR6K87qerq7VtJUVwNyNVIJ3n3vfbzx2ut89BN/xNzcHBMzo7gcVhbn5hkbHWDbzh30X79OR0cHPT2rqKgpJ56IIEoCBr2IXi0SXApgN5nZuGELfl+UZLxAz9qNdPWuQasxIS/AtSsDzAxPE4rFWbdxE/lsDpVcYmB8mP7L55idmkSjlvPMU4+xbvM2Dh89gtJgJCdJ2CpsxKMxjh46ytFDhzl7tp9EJExbVzc7d+2hsqmCfCGNoUJLY28jFfUOyk1tyBGQStG3sQos+2284y+o3nLLB3norl2MjIzR13ed3//jz5GIBRkZ7EcoKdh7732MXLuCrCQxMDyAFoGSWkM6HiaXz7B24y4KZPjZ977Jx37vk/zk5z+hp6OL1es3cObMOWYnx7jjvvuodLpIJ9I4ysuRa0QUuRwDA30UZRooQbnTSC4WxVxeT6kEL7z4HI117RREA6HwEmeOn+Q9D72XJV+Cjq5OJsaHKebiDA+NohBlCMiZmpwnm4qzftN6SrksZ6/20dLcwdTsGLJSklW9nSx5fRj1BoYmxsgmclQ1tNHavpK163p55tUfMhsbwGCzYTHaMem0SKLIa8++QCElMXbhxncEbt38bu6/fRvXrg1QVdXC1j27Cfq9HD/yJnqdmXsefJhzp47hdlUxNj6Ay2zj4vVhjAYlWp2atq61RJNBnnvi52zdvoOXX3uZVV0r6FjRw6lTZ5iZGOWhD3yQarcbfyBEldOF2qhFSsUZGryC3lLB9OQ0vWs7yEYjGGw1pFIZXnntJdzOBtxNnfj8Hp567HEeeP+DeD1Rmpub0eqUnDx2AJfTzeDQdZSimkg4SSYR57Y793H8yFHmA4t0dq1kZnacxblR9uzdSiqeJBqOMDI1hUahpra5k6aWbjZv2cAPn/wyoZIHvdmC2WDFYtCDUsnzTz6NLCNj7OKN71DdtunddDVVUJIU3HnHu/FFQtjMJn75xC9obethy67djA1ewWZ1EI37IZljdGYBk1GF0+WgvKoBz+Isw1cuIBcVXLxymXWrVuOodDMxNcvItcvc/+D7aG5oZnxqnOb6JjQmHVIiwrXrl7FXNjB09Rpb924gH42jMTkplIo8++yvsBgr6Fq7hWQqxlf/9u943wcewjO1SENzO0aLhqOH3mDL5m28sf81NGodmUQcUaHl1jv28qtfPo0n5KO2roF0JkEyOk9XdyvFIkyOTOAPBVEpVDR1rKSzfR2967v5xk//nKQijN5oxmS0YjUayIkCLz7+KxQ5xU1zXPa2ueEF1Xd8cf/EBz9FYDbM3nveR0tXN2++8Cvae5uxiXpGZhcpFbMEQ142rt+FN7LITP8A3Wu6CYSDDPZdY8Ot2xElgbPnzyClMySkImJRxsTEBAsLC7Q019LY2Mz0whKPPPIIjQ3VRCNe4pEg5AUc7loUSpHFmRG8S2H8i0s0tnXiqGnmxIFDGGx2+i9cpH9sEKtWB3IlNdWVJHMpPBPT7Hv3XQxcvohCEslIRWQyGZs2b+M73/42G9et49LAFXLFNG5HGbHAPJu2buPUyfP0Xx2k0u1g7ZZt3HbLLn7wy+9QUEcoyUsYjDbMejlHfn0cqaQgVwRlUcHE0I1XM/z8H32B8f4perbsYduuPRx/7SW27FpDLpYlni0yNjrEgmeGbVtuIVlMkFsKYXPZ8C758E15aFnXjbJY4tylPgqpDPFCFpWk4OjRowB0dTZjNlpI5OGDH3yEmupKQsEFUvEIIV+YzpVrKJSKJEIexqfmWJz30tDagb26Cf/0HHO+JWKhMIdPHqWjoZF4KotWoyQnFBi/OsBDH/8o504ewaK3YnNVkMnkaO/o5Dvf/jbNzU3IRAVXr52ns62ZyeErrNu4iYHBMSZGp7HbTKzauJk9e7bx3Se+SUkboyRK6HUmDGoFx1858a856mQahvunb5jj1/72G5w+coHeLXtZs2ET186dorndjTynwOyo4OqVi8wsemmpb0WpB11BoCiXmJgcRcqDs6ERkSTT83OE/SEShSxmtYEf/vCHVDjL6O7sQKfRY3a4ufvuO3E5y/F5p9EpZFzsu8qWnXspFAqkE0FGxyeZGp/G7m7EVF5BmdbAtMdLPBxhdHocUQKlvIioNiGoZYz3X+Puhx7mlReewaK30rpiBQsLC7gq3RzYv5/ychvbd+3hu9//Ght62jh9+jhtnV3MznmJhhLYLUa61q1nz+6d/ONP/gb0KVAJ6LUGVDKJMwfOgWAkm8ugE1UMX75xjsveNv/vjpbZs/0+hmcm0agEZDKJ6honJw8doK19DYIgkohnsFkr3prNLpvHUG1Eq9FjEUV0ZfNcPn0Og70ClUxBZXc7Tz/2GO//8CfQmI0oDTp23HoLolxk5+0tmPUaMpkMhUKByspK1Co98VwRtVqNvcLNgjdMa1cPp85dpHw6SKYkw6JQcMc9d2O/6ESukLEUiiJkoszOzvLA+x7gjSNvIMvLuPO227k8eJ1AIMBLL73GXfe8l9GRAfweP9t3bODYoQO89/33k0vlUKpVfPJTH0Wr0mAwG/niV/4KwR5Dhwa5As68cYRCXIFcKSIqtORLQd73B3fw95984oY5runZhUJ5nZaGakqlPC2t9fz4+9/FXdWOQhShJFBT3fDWRUujnoNzx1itX4fN4QRJzoXjpzA5KnA7nGTIc+XFF3nfBz9KlhKxWIy65mYaauuwWCvQaDRks1ny+TxOp5PGhlbiuSJGvRGhVECSFmhfsYrzl/ppzamYnl9AFOV0r1iBQqvEaDIwMDqOupjm+tVBHvrA+4lE/ZhNZTTVN3B1eJB0OsuCZ4k77rqPvgvnCCx5cFe4OHfyNO+69zZkRYFsOsN7H7gXhUKkrMzGn/zF51BXZzDKDRTTOfqPXUVKKhCUSkSFhiIhbvnYVob/YPqGOVY7O1Hsc1DfWEc8HqHSXc4vfvITyh31uKuqMBst1NfXEwwGaXfU8quXn2TLqu1YyyvQqjV45icxlTtoqKphSlQwdeoUmsY23nXfPYQWp7BW1dHd0YnJXI4kSeTzefL5PAq9kX2330Y8V8SgMSCXioiimlXrNjI656dKNHLh6nXUaiXuqipEnYpcNoNnYobJqSEGxyf5/Gc/g1IFVe46jFod165dIxgMUigo2Lh5O8cOH+Lk8UNolWqOnz1PT+8adEot2fQ0t79rL6JKhc1o4jN//SnkZTnMKhOFTJb+I9eQ0jIEpRK5sohEil2PrF0u7v/B3vHFff/Bp9EKeoqJOK8deJWde7dTVKiYmZljfPIKD7/vEyRSMTyL8yAV8Y4vsKZ7E3atlcDiEqVsCkElUlbVRUqQ2HfbPTz91FO0tbXR29GG21nL5MQQfs8MYbWKnu42klEZ2ayAzWYhtDBLMBlHrVTT3tbDxNwEa1b2UO6sYX56ivrmFg4dO8XI1X4++gef4tSpU9TWrKKutpVXXnkNrV5OMODlwuVLLC0t0dnZTbFY5OCh14gk02xctxaD1cmd9z3E1OQ0G9auQy1XUma1Uelwc/HycQRKFAIZBq/NU8yCXKYDZYEHPrEDuTZJXimRKAZumuOzL/wzLmsN0aCDw0f2Y3XY8EcTuNwCYyN9PPqRP+LixTNkc2kGzl0iE0jS0tkKJRXRYBS9Vk9bQwPpZIxkNMzd972Pp596itbWVtpWdFBe1UIhn8QzPYlMqMJebkYtaslmBaxWE8HIHN5ICJ3aQGtLJ6FEhC0b1mG1V6ESoa61jeefewn/3Az3PvxeCoUCdbWNdHb0cvT4UdLZEAa1nr5YDJfLRX19Iy+99GuuZRKkclnW9K7EH0vy/kc3MzU+QFdXF0pBgdvpwmKwcubCIXRaJWlvkGveRUpZkCu0SGKO9//e9n/NMVu48eRrAOf69pMM5tDolCzMTDE+PYrGbGHlqtVcuXiQTQ9+gmeefpIN67dy9OhRitE8q9b1EgylmJ0eA0FDTUUF8USIiek5etdu4Y39r9PR1k7ntp3oLdWUWQ0szs+j1chxusowG6woRBVyhY5cZBFvOIheY6TC4UYS5VSVl3DXOJFKKSpqannhuVfJxIKs2bYRq8lIl2odG71eBgeG8XincJZVMDg6gs1m587b38U/feMfePiRD1Pb2oTDqMIXcvHu976Xkev9OJ1OjBo9tVXVKOUiJ04fQlRoSS+GuNbvp5gpIVeoKIpJPvipPRSUYeQqJelC5u0sA8t+C+/4C6qL89Os2LYb1CIB7xz7f/USVa5K3HVV3Hn7XUg5qKptQSpmmBwbpbqqilNnz6NSqTCZrLT3rieVSpHN5hElgXwujSCVGJ+ewuquQiZTUFVZQX//efr6LjF4bRS5WonWZCCaiqJQyMlmsxQlEaVRQ3NLJ3WNrRgsahwuB4V8kn27N7Fn3z6effZZasvtnD91iEgygl4tIaVz3Hnfezlz5hgrV3YgCjJWrujlzjvv4pbde4jmctgc5cxN+7DaywmHwxgMJhQqFQNjY4TzIvlEFt90gly0hNoAW95Tza53txBNL1KS5ZHkChQl9U1z9C/OseVdd4FaxKRXkw3G6WjpQNTI2bBhE+NDE2zdeTuZbByKBXpX9nL0+BlUKg1+f5C123az6F8kGAxjUGmIhAMIUglfMIDSbMPlclNT5WZsop++vkv0Xx6kJBfQW0zE0hE0GjXFYpEicpRGHY6KKhyuGjQGOQ6XE6WswH333kJ7VwenTp3CZTZx9sSbTMxO4FsYR5aT6OjqYWZmDLvdxMTIKB/64MfQ6/Xs2radUCpLU1srp0/0obGaWFpawmAwIZfLGZ+dJS3oSYaSBOay5GIFTOUytr63ip33txLN+ZDIUUBAVrj5+OyB/kvsvOfdVFY7cTlsbF+zBbu5jFgqQlNbJxdO9/Hghz+OJMtSbrPSu3IVV64NY7PZuXZ1gLaODi5cucjUtIf1q1YTjQTpbG+jgEQglmPNmrVYTEZGRvvp77/O1cvXyVNCksuIpsLo9TrS6TT5koS+zIbRZKWxtQ2lFqz2MlRiibvv3kVdYz2BQICgz8/i9AiiXuTqxdPMjc8QT2aIRPzUVpXjm1/kwx/6JKdPn2b96jVIKj3t3V388umXEbQqAoEAZWVv/RcxvxREYXSQWAoRWsiTi+Vx1uvY9kA1e97TTSIfpCSTk5UkxNLyOPf/aO/4lnskokIUJV597il27tpL54q1DFzvp8ycJxEv0lBjJSsXMBos9HR1E44l0YtyfOEgSDIGBoZYs24Li3Nemjqb0apVuNxVvPjii7z0+GPUtfZQ3VDN0OAENe4q9BYLFrOdUimHKMiYHBylobULpVZDNBXB7W4kl8uRSCRo7GimUMhjMespt5vZvWc7X/unr1PT3MDenTuJb1vJX33hb/AszbBn+ya8Xi9bNm7miZ/9lJVbVtPV2UbPmh5OHDqEf2kOtaaajo4OFhfnMMmVmC16UukYDTW16F0CkjmGSi1DUhRRmVTIdJClhBBMkV24+W3zcpmb4eF+3nj+GZqa27jl9nvx+/3Eo/N4F5e47dbNRNNJjFoTrU3NKDR6nGoVwVScluY2PB4vrW0rCS0FaVvRycDlMzgr3Vy6dIkX/+UX8B6JZC6JTmsh6FnAtH07Vks5hUIGtULk9LFTrNu8g4Igkconqaxs+Neum/q2egQBDHo1JqMGqaTg69/4J1ZvWMOGNWu459bNfPlv/wFBJbF720ZCoRArezr45lf/npVbVqNWKXjXu25n/8svg5AlvpSiZmUVklQEmYjJrMMcV9FUV4+/pEBmiaPSKCkpwWiUI2iKpIUSsnAeTcp40xzrGrbS39/HoZdfwmq1cvf9D7Jx43Yu9R1BqTawef1qUuk0epWRrFaPq76RZDRCPJtmzdr1LPqCNDV3o5QrKKssRyETQCEyMjTE9b5LDLW0EY4F6e5exeW+i2zevBmb1YFCKCBJEodf3c+W3beSymfJFbO4XLVkMhnkcjlVjUaUShGdVkQmFFCrDFy40kd5eTmuCjtrO+v5x3/6NmqjkjUrO1EoVei1Iq++9CqWKhsjgwN0ruri1JFj2Cwm8okCZqeVnFJBSRAwm3Qs+SWam9oJFacp6cNo9ToklYTeIKeozJIvCqgSImJS93aWgWW/hXd8y33znq1ks2n23n4v7sY6MrkovevXYDDbyZdEZBo56XiMM33nSSTT1Dc24vMtEQz4iUZCKEolpmdmsVhNaGQlZDIFM/NT7Ni2FZ3Njsmsp7O7m7Xr19HUsQqdTkM6myERiVIsQHVzA7YqB3lBQqszo1GLpJIxDHo9ckGAkkQ+X0Sh1lDIpWmsctPgcqPSivi9PkIxHycOH6Whto73v/9B2ld14mqqo7m5m7GxcTTI2b59Ow6HA4vFQiQYwO5wI1MZUMiVdLQ1s3XHLZgNZmSCErlCAUKJTF6BlNTy6g9O84svX+CV587dNEedXYfJZOB9H/gYKpOeVCZMVX05OoMVhcqITCVncX6aIyePY7RYsZrNXO0fYHRwgEQ8StjnY9Hro6qqilw8TKkEM/NTlJfZUJksDA5dY/vOndTW17Fy3VbMZiOpTJp4OEIhL9HR24PKogOliMFoQ6dVkcumsJjNqJVKsukM+XwRtd5AqZClssyGQSai0auYmZrA45vl8P5DVFdXc999d9HS04nFWc4DD3yQfL6AlMqyZ88eNBoNGp0etUKNzmBFbbAhiiIrutrpXLEWjUKDhAK5AoSSRCYrp5TQ8MRX3uQXf3eOJ37y+k1zjKQDWC0G/uBP/gSV2YBncQZRWyRflBGNZikIRWbHJzl36Tz1He14PR6GR8YZ7L+KRqsiGYuCTMDpdKGkRCKRIhINkM9mSBfznDh5lLbOFah0WtZv3YPJZCCeTBAI+JFKMlpX9yLTqVFoNVisdowGLUpRxGoxodNoiEdj5HJF7E4XxVKOsUtXUeQK2Cvs+L0eZucmmB6eoK62lj237WPF+tUki1k+9ak/prm5GbWk4NZbb8VmtYAg4rA5MJptWMtrEEWRTevX0+SugaIMmfyta0AUIZ2VU4woeeKvjvDTL5/ilz9/422sAst+G+/4lvvalWv49ne/yj333MfjP32C2+/YzrmLfezZdQuNHXayJQXhwBKtLe3UVDuZnV/EVdtINBhAJlNQ31hNVpLhDfjI53OkcxLZRI6sEGN0epLtu25jYWaGckcN3b3rUIsFLDo14XyaXC6HSqMjGUsSi8Robmknk8vgclcyPjxCJplDrVNgsZcTjydYnJtiMexn/Z7NVDodXM8kyRXkNJZZWL1hNeYyG5PjPu5/zz2UJIH73nsvhVyRTDrOli3bKUpxpmdmmJ2dxe2swF3lpKKqAoVOxwMVH+V7v/prIoUg+Wg5I5dPYC+rZPum7djebeTiuQssTI/fMMcPPPIIX//Hv+Xuu+/m2KET2EwadH47tfXNGJ1V5BGxGExsWL8Jh8PB5f4hetZtYHJ8GKXOSEtrI0qdgaVIkGwigUzUkk3kUCskfOEwK1ZtoO/sWdIZ2HfbFoqFJGatimAmQSqVQmcwkUvniEdj1NU3kysUcDidXOnrQ6PUYbbpyRcLRKMxosElro70s+/dt2KzmGiqqSFbEDCpZPSuWYnObCW8lOOLX/oLcvki+27fSzadI5tJsHfvrYiqLF6vHzErko2G6OhspSQUWKFWU9/k5vsvfomiFCM8n2Fu5ArOihruveMOzOU6Lp45z/xU/IY53nLrPp74xU9p61iBrKRgfm4cp7uS9tVrKMlk6C3lOAUZSlknMgn0Jiu7u9cwcP0iUkkgl01TZrMTikeIBYOUO6uZnhhGKZPQmUyUBCXTY0MoNTbWrF8PUgajKCOcTxKLxSgrK6OQeyvHSncthVIJuUJB3/lzqEUtDpeNQDDMUiBIKZtmYX6SsoYHMOg0JMNhkpkiRq3Api0bMGl1RPxpvvzVL4GQZ9O2jaQSafLZDCtXrsRolhNcCiHkM3iiYdasX0koGqJ7y15aerr44at/S6GUYWE0RGg+iNtdy3ve/y70RhmXzlxkdmJ5rPt/pHd8cV8q/ozGpiKvHDiAWh6i78Rxalq7+NmPf0BtfR27b7+HZE5iYmAESa6mtr4WpSAi6jQIlLh49jw79u7EqtdTkoMmq2dmaoQzC7Osbu/ixz/4NlvWrUFrdlHprsNVVUZaVkChVSNDhqDQMjU5i9FoxOv1sRiOUIj6uHTxKocPvEkiHSWek0iF/QhaC26nnvvuvRNBkhi43o9MBbW1NVTWNjIzNsHk7BzdK9owGs3kiwVEnRyfN8SKFd384Pv/hCgTmZmdxF1hxxfyg1LB5cuXuT58hcSChmTRjK5JxF1lIakPgSmG0aRnxyNrOPzijYu7N/EjelcbuXR9kHR4jAvHVejtLo4cOMC+W96FXJChUZsIBieZXgxT39KEoihj1doNFIt5Aos+rDodQrGEqbKSfD7PzNQI3sV52mpaOPD6S2xZt4ZETsGKlWuxlmnIKkqojXqkokRJJjI/s4DVaiUej+MJhRm/eoajR04xNzVNNBEhV5JIRMLobRWIijQmjQ5RLueff/IjFCrYsWMH5ZU1XLt4melgis7WRsrKykmmU5gsekYGp1m5sodvffPvKeaKJJJh1qzt5crAVapr6ui7fInRyUGMuQbmFqapatZRXZsha4pQ1IawWPXs+OBajrwyecMcE6Un6e7RoVHZOTn0JClHNfFYhmQqwcc//l/w+uYx6bWo1XpQG3BUG4iHQ1S4qxAEga0bN3F1aACdTofObMBgMPDsUyeIxyLYbdUsTI0xX6Znau4SDU1tCPIMqgozokZHsVgknS+RjEXQarUUCgWGJv08/9hP8fv9zI5PE0yEEEU5Af8Szup6krEwf2OyIMrlPPnU44hKWLN6HaayCn7wj9+ibctO2uy1GAwmEqkk1jITVy+NsWH1Wn7+2A+JR+Lk8knaO1o5fuYUzS1tXDj1JoFYgO6K3Zy6eJSaVgM6uRzBkaIkJqkot7Pr0fUce236d1ARlv17veO7ZWpqLOzeXcujn6tFJi8i8da6nNt3bEGuUnLpwlmKmTi37t5Gd3c35IuoNXIOHTqETCkiVysZHR/D7/cTi4UoM1lZtW439U2rCcbjfOFLf8Xw1Cw1DVU89vj3eOXF58iki8SiybcuXOXzNDY2Mjo6yi+ffpy/+8u/4NX9x3nupV8jiEokmY4KrYUnnx/CpDYzOz6LyWQik0hy6NQpLDoDnW3tZLNZ7r33XlLpJc6dO0c4soQkSUTCCcorakDM88iHPsYjH/gwt9xyC4loDI1Cyekzx0kkI+zYtwdnXTkGm4qwP0haUGOng+d+cIJfv3yaiCd/8xzrbKxZY+K2D6ipb6hi/frVNDQ0sHpNLwVB4szxo+QzMTavW4XT6SSyFAShwNGjR9GbTSSyaeb9XlKpFJlsDHlJYNW63WgNbryhAJ/67H9lYHyK1etX8Z1vf5n9r71CIp79H3J0uVwcPnyYf3n8Z/z1n32exaU0g2MjaI0mFBoLDrWRJ58bIrQUIeKPoNfrCfmXmFnyYtbqaW5rpVQq8clPfpLhq2cZHBwkFg8BEArGcLkbKAhp3vu+D/HxT3yarq4VlPIFDGotJ04eYSmwyPqtm8kQR2OSs7SwREpSYCm08Mz3T3Ho2FWCczcf5VFda2bVSiVdm+epcNp48H33I4oiNTU1pPJZXnz+WdQGG401TpLJJPFAmGDIx9TUFFV1tQTTCbQ2MxqNBoQcizOLbNtxN4m0kqiswIMfe5T+gVHWblzJD3/495w7fZJoJIUgCP86TNdkMvHMM8/wgx9+hz//4z9EphIZm57E4rBTKGkwo+Gp50eZnVkklUohl8uZn54hK0jolWrWbFwPwCtv7OeVZx5jbGyMSPStqa7DoTh1De0E4z723no3H/7IJ6iurkYmgUah5MjRN8lRon1FF1dH+tBZlPjmlkiWZCijbp756THOXZ7CO3nj/36W/X/jHd9y/8afjXPrA7UsXj7EXz75AEdemcE/0E9LUwMbe8qRG7sYvXIJ06atBJY8eKdm6d20FofZTDaZorOzkxISk6PjpBfjyGVaVq3ogXyI40fGmR6fwWoxEg9FuOfuB6hwVJKMJLBYy0jnMwT8Xrx5Ca1aw9z4FAcOvczk1CgOpwOZQonGqAWpxO+9v40MRmwVFSx5vKT0Ibau3YLeYmLTjm3MTUygN9v4h7/5CgVZFq3GiNtdzcaN69mz71asVitqlQQyBZJSg93tprzcQfT8aVauWc3+/c+xFFhkdHAMUVAjlEQms5dRKg2Mng4Qnz110xx/9CUPO+52MPvKm/y3Jx7iie+fZ23tevLZNKIYpHr7djKhJWQ1dcjzWTKJJLbOViw6HdFgCJPJhFKtIuBfIhAIYC0rZ9WKHsL+CY4eOkwpU8TlLCfsD/Dw+z+C2WQj5AvirnKSLeZYWlikJMmora7hscd/wcVLp0mlYxhMBmRKFUqNkXwuzac+2IZKpcRWVkHI7ycU9LGuax2Icqpqa7h28SLZIjz12JPkhZ+i05qoq2vgllv2sm7DJoxGIwqnBkmQ425oJpUKUVbmgJEB2js7OXn0FQKLcyzMeVGgopSXMZn3o1ToOf/qJAtDkZvm+Nz3C2y53cqVAy/zp499iD/54D/xxT/8a/rOn2J28CB33n0XS7MjyGpbMOi0eANh6lubWTpxCt+Ch/nZBbRGPTKthojfRxGJ5uZGOtureebXb3DPrXdhsRrJJvPce+/DKOQqgt4ACrcdrcnKwtQUmWyJ3pWr+Po3vsZSZImDB4I4Kp3IVVpMtjJi8QC//2gbokqB0WYg7POzODfJmq61JDJZdAYtF06dwpcI4Dt0lINH9qPVGGlqauGue+6hu7sbp6uGTCZDvijRu3Eb8/PjlNmshOJhzCoFA5dOEPItEFyKIApq8hmJ6VIAuVxk/+MXcTdY3r4isOy38o4v7ll5kad+eJwHHv44i2em2dxRgaKpGaGkpVBMc/bQc0RzJb7zza9z77vvQVKrGBufRFDKGOofpLqhjsErl9iwZSvBcISB/gtUuevo7NrGiy8foZApseeWuwgHl3BaK0hlYhw7fAK3243D5aSqppqFqXFGR4epqatl2+bdrF+/nhef/xX6RhNmo5FYNEVN21aKeRWB4BCiKHL65BmyhTzyWIJUNsOd992DTK5izZrbmRs+zR0f+ANOn3iBV14/yPXhETp7VrFjyy5K+Rxr1qxjaX4Gf8jHjh3buHTtKufOXiKXLaIS1GQlAaW6iEIQkQQwGwwo9OJNczQ6yvjVT86w+5b3sHjWx/37uon7EtitVaSSIY6/+QShVJ7hyXnWrl9DSipx/nwfzmoXIV8Qs92Gd3aW1vY2Fn1+BCFNOBymvmENZ84NsDCzSENLB/Pz86xds4V4JsbA1Uv4fLWYbWVUuCpYnJlkfHyUtrY2IokkDoeD+ZlJ1CodDrsFv0+iunULrpySQHCAYqHE3NwciXSKKkslqWSc933g/cjkKjZuvJupa0doXXsrvqUBfvb4Lzl17jz1za1s27QDrUrJqlWrmRq4SigWoaOjjQtXLnH0+DnyuRIqmYp0SUKpKSET5AhyGVaTCbn65hNe6crM/PLHZ6lrXM3iyXn+9r89jHf6Kru295CIhzjyxpP4wkVW77yL6moXC6El/BdC1DU3YtIaWbGql5g/iKhVIopyqqsqmJ+Zp6FxLe+5U8Pk8BRGazl9F87R1NhOMhshmklSREKj0VDmqnorx+lJuru7GRobZ3x2Fo0/iMypoarSgWdBwFHRQmVOQTw0SakokUymKUgl2psa8XkW+OgnP4GEjMbGzaT81zG5VpArRfn+j/6Z1pZGelaupq21C7NBj9PppBAPkcynMJuNnLt0njcOHKOQl1DJlGSkEgqNhJQVkMvAZLIgU73jS8t/eu/4V2DtPg2Our3oEwF+9pM3+Px//TQzC/3IRT0iGVx1CjyXxmkoL0MvLzIRCpJPpBH1IlX1bubmZmht62B6ZoLKSjcyhYbFRS8btzbx+f/2l/z6xRc4ePQNPvDIx/i93/s47334QarqGjGZTJhMFoaHh1ErVdTUVzE1t4BSkJiemeAvvvR1/uYvvkBtowJBKJFJFlArkvS09/Dir3/NrTt3EFoMcOd77+GJf/4ZTW3tqFV6rl/bT0FQcuDl55Hr5RRKccbHR/F6PQSXPOzbtw/vrJeR4WuUO23MT83x0qvPYrCpUKjU6PRKJEGGKIrI5EXkGgGVooRGY2bw/OwNc6zuCbPyjl2U5oN89e+e4ntf+zKzkQvIlSLJiJeKKomipwDx8+jlq0jEolSWVeD/zXjxUqlAbV0ds3NTOJ0uPJ4ki4tedu7dg6umkm9/65uEI0t8+NFP8Nd//UXe89AD1De3kU6nKS8v5/r16xj1BkxWA8lCFimXodxh4+EPfIwv/9VfEtckUau1pBNxNKKMzuZuBgeuU+NwM2ucpWttL1//+69TXd+A2VTG5UuvgFLPyNAVFHoBSDE6Osz8/CyLC9O85z0PcOnUOWLRAGqdyMjkMAcOvoreqkSp0aLViUiCDKVSiVxRAmUJnVqGKOoZPDd3wxwN9dPctWsrubEs3/3Oi3zj776IV3aZbCGOPziJsyaPUqMjNPUaNRXvRSUqMKp0pDMZTpw9yYoVK9HotFy5eoG1Gzbg9wfxen30rl9Nmd3CCy+9SCjg5d3veYgjhw/S3NGKzW7F5w3S2FTL4OAgOo2WbCGJzmwkHgqwbeNq9t5yPz/98Q+IS1EMRj2peAyVHBrrq4nHohSSBaQCKM0G/ulr38PudEFeYtHTh9JYga6YIptIUyolGB4exLMwx7nzJ/nwhz/K3NgMsWiATD7JlYHLnDi7H4NN9f+Xo6gEuVhAoxUBFUPn59/ucrDs/8A7vrhbVyhZq4Z/euPHLOnS/Neffx6zqKPOWE+Dvpodd9VybNBDYmoeR0uEztY2FgNe6hvb8fnnMGjUyEQFzS3tzM5O09axAs/CHFqtFo2oxGS2cK1/iLbuFTz8kQ+yvmc1g+PzqDVFrl2/zqWL53G73VS4HIyMDFPX2sbo0ABf/fJfsn7LDqbGh9ApoaqiEpVKTZWrAo0oIxBK0tzayujV6xw6fpq8Qo6gEnBUtuJyO5mZmiUWiJBMZjHplYTDPo4dfpOpiWFW9PQgKeD85bMcO3MIg1GDVmvEYNSRl2URlFlUShVqrQalUk5RIVHMZ2+ao6EZusUMX9j/XSS3iUe/9WlchjJ63KtQxgT23NvMyP5TlLwCx/uGWdfTzWLAS/eKNQSCHnwL81TX1uN0VzMyNIiEAoPFiiAIVDldNLW20ncuzOoNm5EpBeora/EGk8jkRU6cPMmVi+fZuHkz0WSCkZFhbK5KFubm+emPvs3HP/2H/PTH30NeTON2unA4KjAbdCx5fEg5AWdlFd7paWY8PgpFgYwE5a4WGpsbmJuZxxeYI5lMYTWZiUT89J0LEA37Wbd+PSV5kYv9Vzh4/A3MFi1Gow21RklaSCGqcmg1GtRaLQqFQEkuUSjkbpqjrVGgRRnhK6efI2nN88g/fpwqk4NtnTtYGprj1gdW8KvXXscSreflw+fpqKuloM5jM7rp7rESWlqisrKS9p6VDA4N4fMt4Xa70Wq1dK9axeTsLPNz02zesRuNToVZZ8JgcpFMDnPi5EkiQT8rVq4kmc0xPT2FqdzBki/MuVOH+eu//Spf+NwfIWWjuJ1u2ts7MOpFrvZdJpcrsW7DJnLpCFlJQq5QYy13YcpmaWiqZ352gaAvSiQSw1FmZ2lpEb/fw5OP/4TuFSsoygpcutbH0dMHsdr0mM0mRKWcrDyDTJFFr9Oi0amRixJFJPL/m9/HZb97/67iLgjCNBAHikBBkqTVgiBYgaeBWmAaeI8kSWFBEATgm8BtQAr4oCRJl37bEyxfkKPc1Iha3sCWNQom4/MIMiX+godw0UP2VxK737UGRVyklE1z8vxpamtricVDyOUio3Pj7Gtt49TJYzTVN6DVqTEatKSTOTy+RXZt38H997+X//ZHv49MLaOivAIpl8DjC1HucCHItTR3rMBi1lLIZ5mb9/Hgg4/SsaqTL/6Xz6GyOynEl+hqb2PLrh3oVXL8s15KQgnvfIhIIsmf/9mf8MQTTzPr9RAKhRDVRWKxeVLpPIIckvk0iUSccnsl1dVu5hemaWpu5fzcHMV0mmA4wVJRhiRXoNdqkYoFEgk/pVIJSZJQqjSIppvfxNRYNHLdn2DdqjtJFZfw5H2IGi2Dyeto1QK6A2bWbW9Gk9EyMZzh2z/8Lvfffz8z0+OkMmmCwSDV9Q0cPXSQhtpaqhoaWZyfJR5NceXqBapclXz0x4/x7jv30tHdxnse+BATQ2PYqsrIFAUclfXoLXbkooLurjZi8Qwdbauob2vgv/3h52hasYrF0ev09qxg+97daBTgm/IgapUMDwzjWQzz5b/9G77xjW8RTScJRz3ML0AotEg8GkcmL4EcoukkDpuLykonI6MDOJwVeGdnkbJZgjNpAqUIRUGGUiFDo1ITifj575PnqdRqFMabT6TXbSnjl8/2sWl3L/MTAfyyIAqtjhOLx9CXKTh/2M2eB28jPb7EoYMeXjs0xHvf8wCjIwMUpRIauQxBriAY8EKxyKZNm/D7FkknM0x65hgZHuZzX/hLPvTAPXT3dLFp6x6OHT3Jtr27OHb6PPXV1SSyRYpFiSp3BU1NzaxatZlkLs4ff+oTfPqzf8YzP/8ha3tXsffWWyhkM3jGp3BUORkdGiWZLPJnf/I5vv71f0TUqhn3TzE5lSUSXiISiiAqBQxmA+l8Ao3KiMGgY2JyDKVSRsjrhVwO/0SEJSFMAQFRLmDQ6RkMjrwVkFRAqzeB7uZr+i773fs/abnvkCTp305g8qfAIUmSviIIwp/+ZvtzwK1A028+1gHf/83jb8WxqcjoeSvjl0Iszpr5+Jcf5I03X3mrhSBJ9E2eoj2wlc989Uf8/l9MY9XcytTMFNcGrlNXW0lNhQ2/b5HLV86xalUPpUySSDCMpkOHw1pGRbWbj3/8wzQ11rN+/XquX7/O5s2bEQQBpVrDtq1bkSSJM+cvIy8WMVjtDE+N8A/f/Dseeu8HSOUS7Nr8Abq7GpCpRIrFHPnRGYr5DHmhxMoVXcg1ejbu2UbD7AKvvvQ6c3NzFCQJq8VAKpMllciyd9duZrxTiAYlRpOZpcwUgjtOV60buVzO3HyQSqONS6cGkZIqipJEUdCgVhTRGuWUEG6ao6m9SPDQNk6+9lUErZIHP7eL/sHzyC1KihQ5PnaARxa38aPXXmbzu3rpaV3L2MQYcrmCfC6JEhmRwBLBkIcNG9YSD/iIBMNUuGqoc1ejt5n5+7//S7bt3EJzawfPPvssn/3sZ/F4PGCXE7daUSqVTAeiLPpirFq7hjMXzvLFL3+BL33x78nlk7Q+8m6qKssoCBKSVMDv82HUa9AY1DTZ6kglstR2NKEWFOx/LYxv0UsgGkFJCVHUEo0m2b11O0sxHyWlRFt7B+PTl6EyRmdVJaIoMjcfxKE1ceX0KIVYhhJv5aiSFVDr5ZSkm/+R1LoVtFa+jx/96IfkM2F2PtpAQYijsqopSFmOTx4k82ItCVGOoSGHWbeDi/1X0ChVzM6MY1SZeNed1RRySZpb25kcGWB6Zp7OVavIS0ne9/D7ePbpn7NmfS8GYxlvvnmIz/7Jf2XR6+X2ve8im0sQS0XQm8pYCkTZuns7rzz3NEMTY/zd1/6RsdEBvvX9b6NUFMlTwqI20efxICsV0Jm0JFNx/IsBNFYTBpUJo8ZEPBbH5w+RikcoK3cQCEToXdlGDpDrlFhteqYXrlJyRmh3ORHkKvy+EBaFhmvnpoiE8yCTKEkalAoBuaqEwPJiHf/R/l1T/v6m5b763xZ3QRBGgO2SJC0KguAEjkqS1CIIwg9/8/lT//P33eT5b3gSm+52sHfPNnq72/nuN7/F7fffQmw6xXh2CoNJQC6YGB6aJzY3zS13bOLAj0tkigU0OhMN9eUM91/H5qqnd2U38USRbZt2INdoETLgi/mwWa34fIs8/diP2LLzdsKRJHa7A7lcjrOygj/6vd/jk3/0aUKeMfbsWE1lvRtJkshKebz+IPUNNczO+8hmkhRKecwWHZFCFIQsMkEgFk2TTCeJLcUxa/RE5xL81T/8Mz29ayhlUrjcLvQWHRl1iDxx0tkMao0WpZAnlk9TkqWRy+UIJSUFmQydKKAUJaRigUI4TzYuMTrkRUKJZyJ0w9dwy11V7Ny9jlVdbXzvW9/kjgdv5+SvL6JrVWM0KxEkHaMjHuSJOBu3tfHqd4okS1k0GgMNtXbGh0dw17ZR31CLzx+ld8VaaptbIC0xOjdKhcOBz7fAC798jDvufT/FkoTfH2LHjh0Icvjzz36GRz/+YYYuH+fWPRsxlZtRKpVkpTyxRBqnq5yZOS+5bApJKGE0aQhmQyjEIkpRJBiIEUtEyMYKmNQ6Tr1+lpcPXmLrzl3452dxVjrRW3SkVQGypRiFUpF8oYhBLSNRzCLJM8hkMoSSkqIgw6gVUcgkspkE8pSM6FKa6YkQxZKCxckbL9ix591trNvUTHttBz/7xbe4+5E7OfjEGWyrDBhNKqSCgcX5RWxqEzVNRl75Zo6ElEUhE3GW6/DMh+no6kSr1ZLJlTBqLXSsXIVGpmJmcYbm5mauXbvM4ddf5OEP/T5ldjsnT57l3nffyZXLA5w5dZT3PHAfLz/zE+65cw8asxqDyUheKpFIZzCZDMwt+Mnn0sgUAgpNnmQxh6gsQUkgHI4RT0YppQX0opoffuVHpAQ7K3tXseRdwGw1v5Wj3E+yFAGZQCabxaCRkSzmQZFFjgJQIJUEdEYlShkk4mEM6Bm96CGSyFEsyW6a47K3zf/dfO6CIEwBYUACfihJ0o8EQYhIkmT+zX4BCEuSZBYE4RXgK5IknfzNvkPA5yRJ6vufnvNjwMd+s9l7o2M/9OFVkJeIlBLc9fAWjj93HXuTC6tVjTcwTS6XwqKtZWhqiLaOauYvLZCcNdHY3EAiFsfriWIyqqlyVhDO5HHoLMSzSgT1WzeQ6ExOmpoq8S8FicVidDa3gixN2D/Pr1/ez569D+KN+lkKJOhpb0GnV6DRaDh15gLXr/dTX9/Epz/9KUqFHEIpTzwQIpKIQy6Po7oSjUFLOJQiFg/i8XjoHxxkYu4MKrkFQS7j+uBFBDGHXCmSlgLozFp0WgPpUhalUkSjfGvKBFGUI0kSCrmaklpCrVKRTOQoFAqIyhJamYqnv3r6hq/h+z64CpkEGVWOTfs6uPjGDO7OGlTqPP6Ah3whiUVby/TCJDV1VkZOzVIudGJ12BgbGUYhMyCVMlS7nEQzBSpNNtKSgSwibrebaFJi7dpOzp0/j9VahsNiw+W2MDc5zLm+fjo6tyHXi0yMzdPZ1oROr0ChUHDx8jXGJkZxOir5/d//NMV8llI+Q2jRR14mQywU0NvMGCxGYtEs4YifwcFBrly/TiQ1ilpRRjKdYHp25K3CoxRJEURn0KI3Gkjl0yiVImqxiFwu/muOcpkKSSegVqhIJDIUi0VEZQmVpODZr914KoeHP7Aa5FBZq8VQY2LsTAh3Zw0yYixFligUU1gNTSz6ZzCZBcbP+mgwrUVj1HL86BFa27pIxxPoVErUJjsmuYjV3cbUvJ+167bhC4RoanLxq189S2tnFzatjp5VrUSCCY4cPYBa48bksKLTmRCFEnqDiEJp4Pr16yRSMTQqHR/5yIcp5tPkM2kWZyZQG8oRMnGUZhMOVxnRcI4FzzRHT11g0TNNpjSLTuVg0TdPMOyhQJpMMYpMK0OjU6Mz6MkUs/8mRzlKpZJSqYRcLiJp5ShlIslklmIpg0olosjD89/ou2GOy942/9fzuW+WJGlBEIRy4E1BEIb/7U5JkqSbtb7/VyRJ+hHwI7h5yz0VTRIuRWlobiVTlFj3kI1nfnwCpcyFy67F50syGBtAU1bi3PGrVFeWE5QtsXBmGrHMRE9FA5fODxKLBshmc+ScVmyWamYmxmlubieUDHNdusTazg76fT5GxjW0r+hENMrZuGUfX/zSn9LU2IbVZmfbhg60dh+5wAxmXYk1q9ai0ejIpfPoDWoGrk7ywx99B/JF3v/+hxg6foJbbr8TtbZIUTJR1WjGUe0g/lIMq1nO+Qun0RnzyDQyJKmAVNJSqa/GF5hDb7SyOOZDrSmARo9GqwBlCaNOjqokkcmDVi1SKEBJEEFx8/iTsSQpMUWduxmNyciaB0289POTSCUrFWUi0Uie0cgI6OIEvIvYysxcH7pGcTyNYNCxrdXNmZOzFPIJkskMUmU55WU1RAMpdGIevdGKP3KOnZscXO5bJKzQ4FI2Yqpow16R4Nev/JKx0Sn27L0FmcyFrapILjBDjctAIVtHQ0MTQkmGWq3kjYPH2H/gFURk9PauxFJexs49exFVRay2cjp7TTR2NPLaG2+gUKTovzYO8hA6ix4oIKCjwd7A8MQ1LLYKfDNL/5qjVieCsoRGUUInyckqQa9Vks/nQa5CIb95t0wikSCnLqAuuKh1lWN+UOKln52hUNBTbpWTSpYYjV0kU4phM2jQOtScHzhPKZMBkxqXVcmlmSTysjzhuTBZs4F4OkauqGLq+jmUeg1FeZqPfmAzp09NoXPVEk0KiCYLibSAqEnzta98iUc//AmclQZam60szQ7SXFfOyKREd0c3QkmGSqXih9/9Z+bnRtGpDRRLOW676x7MNjuiSkF1fSN32SoJRqY4c+4C4fAMBSlGtuDDaDehKpmQxCItFU0MTw2h1BoJz8VRqbPkRRlGoxFBVUQtL6FDQU4poNOpyBflyAQlKnXx/6QcLPsd+HcVd0mSFn7z6BcE4QVgLeATBMH5b7pl/vsingtA1b/5cfdvvvZbCcTzdN7VRWO7Fbu1yL98c46Guhqaa9sJRr2kpAj+8AihQRkVVS6uX17CoC0jJ0vgbC6gb5CxZ/tqasrMaHRa8po0j3+2j0c+dytOk5KTL0RIzqf5/pu/JC+pURvH0WgEjh3Yz4o1m7j17s3c83tdjC5cIpEboBjopJCvIBS9gNmUY3R8DNmbEvfefSf/9PVvgkpAAfzsyWdIZ+L0rN6CwaQgVyjhXZwlwxKzs+cZHImh1umpq6lDKsrIJiIEEgtEctNU1FkpUKLeaqWEQCaaQimquXCin2xEjqwkgrKApMiy+/btQIKk8eZ97skiNO9po7nLil6X4vXv+6iuc9PobsYfmiOvSDEyOYpsAcrdTiZHEuh1NuLpPLUrlYgNRR581160Uh5RI4K+xM//6Ayf/Kt3oywl6D+YYeZKiP1DRxBEEzL1JHqdyPjAdZR6K2u3t/DH39rBhOc6peQCC5ONxGO15DIpzOY8l66cJJ1LcMftt/LKy6+RkfIogWNn+4gnovSu34pClIglUngWpgmlppmYOonJZkSmlWipakOvNREL+ggkFgkmx3A2WJArJOrLrOSLJYqpPHJB5Oyx/rcWO5HUSGIWQZln3527yORC5Mw37ysuKJXUbalhZZcJUZXghR/PUV3vpLaiHk9gmmI4yNLADBqNmlhRhT+RQmO0kCxB/Todqk4TD7ynEUU2DSpQGZV88yOv8Vc/+CSjF/pJemoYPDXMpYv96M0urg5OU1tbi0VvxVlRid6d4ceHPoYnOIkq3Epo0U7/1Wna253o1COc7zvKot/DXXfczvTULJmSglQ6Ql4Q+PZ3v8eP/vln5PJpYtEEnoUJ+gZPMDLch6AUQAPNna3UuuuZnL5GNBHGnxjHXKlBFGVYKkwk0xlEmZpSpsiZQwMUE0qUMg2SmEWuznPrPXuJxX3krTe/72LZ797/trgLgqADZJIkxX/z+V7gr4GXgA8AX/nN44u/+ZGXgE8LgvBL3rqQGr1Zf/v/Tu97G6lpU9LldvDznx1h5apOlGod/vQQKqOKxZkgFm0ZOoueYDiF2apm912bGe3r4+Cpy/SsbmJ2fJ6N3bWcfm6U3tvdPPCdTtRXjHzpy88iF2RUO6w0dzQxOjHIvoe7sTSPsqvDhL0gMfVUkcjFSsz5Woanp1jdLcdaZqG6ykUyFcZZZuTsqcP09vQiUytpaO2hlMkwPTVEOBzmwJtv0LmylWQ4jD8xwcnzv+ae+z7EY7/8R/LaKP6UkpKUpyBJpJAhL0jIVWoUhQxKuZrK+lo8QQ9ytZwPbb6fSCBMNpRAKCp56ZfHOPX6JeTIkcSbt5S676mhtlVNV7WTx39+gp6VHZRkCvyZUUSTioUzfupcFVCQk0rmqXCZ2bhvI+f3H+Ho/lFa/6SGUydO89A9W3n1hxfY94mVPPCdTq7/coyjJ4eRAeUmLV2rVjA2OcDtH1mByjVMe1cKW66Ob3zxJbpr/wtV+lXsP3SIO2+xYdQZ6btwGp1exKJXcubkEWSSnKJcoKVlHalImLnpUfx+LxcuXsBWZiAeDpMXQ7x+5DE6u7bRP/YGeXWKcF7NUmiaQkFCodOSK+Qw6gwUMwm0Ki1VjfUshhZRKGV8dOuDeGbnUOYFMnGJN54/w/FXLiCTZJQUNx/l0Xa7i+omDbWVep7/5SCrervIS7K3ctQrmTm9gGQAg8ZENlWkpa2O1jVtHHr2NV55bo7eNb28+MJLfOiBXfzqaye478+28OGfruHvP/ktMnk9et0oKlmRNRs3MDJ1jYd+bw8FUxwpGscgufjOl55Gm38Qd9UGLly6yL7dVhqaWxgc6EdUSqhkOU6dPMjxQ0dBFGms7MC/tIB3YYLx8XEuX72MQiwRDYfxhgYYmztNJq1CoQmQF5IkBT2XpuZAkmOvriIaC6LXasmnYmiVOtpWthBI+EAQWLH9IeYnptArVAQWkxx7/QoHnjuDiIyi/ObTYSz73fvf9rkLglAPvPCbTQXwpCRJfysIgg14BqgGZnhrKGToN/3v3wFu4a2hkB/6n/vb/xfHuOFJfOPcLVSVV2NSKfjmF9+gqtaBGMrQ3LaBWGmcZFzL5YEBspE4GkuB+fkC733fPcxO+Zk47EO/qsgtd6wklojT6Xaj0bqZ9J4koZV4/W8GeeAjm0kr5TQ4Oxg+PMuLL5zGHwpTXduFXC5SU12Hw2qnzOWis3sF03MT+KeXaGxroL//PLGwF5VBw8xEkDmPn2w2i16vJxEPE4/G+NTnP8PkwGXmYucoyASKYprJU7M0r6tBYzDgC06iVKgoFAoUyCEgopCZ0WgkFPoSer2edDpHvdmCodZBOBzGqDfhdLnxewMMXh7E7rDy0+8+j3/gxoXpWxduo6q8Gr1C4PtfOYLFokETL9HQuga0fkIBOaf7LiElMthqlETCMnbt3cHClJ/JYwHqbyujZ1U1gqKAXdJgczcwOnuMglHLq397hbseWk1Bp6W9agXHnrnE8aMDeANBautXYjabcTnd2M02dBYLtXVNxNMhLp64xIrV3Rw69Co6tYDOYqCU0zI5s4DX60Wr1RKLBkjEEnzkDz/NwuQA3vQVErksqHMMHhtl7a4ektkMicwiSoWGQqFAXpZHVhKRC0Y0GgmVSUCr1ZJMZqi3mDDUV5KMxRFFFS53NSFfiOGrI1jLjHz/a78iduN5w/jexTupdlSDTOLnf38Mg1bAXNLjqmlAoU8QCsG1K1NEQ4vUryrHbHDhrqxmZszLzNkovQ/ZcbucGKwq5EsFrNVuZpf6EK0VnP7edVbsqAKdkVZXJ/v/5Qx9FybwBkLU1K3A6XTSVN+E0WAhlkpT39BENBlgcmSS6upq3nzjRerrK8hToqG2hzPn31r9CyAU9BANx/nEZ/8L8xPXCBdH8GfnUIp6Rk6O0bujh2AkTF4KoRK1FKUceZmEkFMhoESvlaO2ylGr1WT9EWqqKjDUO0lFkyCT46ysIhoIMzM+jUaj4bv/8CzJmZu965e9Tf7fXSD78fEPUW10MLM0z8QhGWoRorpRfvJfzvKnX/0v5MUpvOMJLg+exlFh4e73P8jSaIqJoJ9T+0dIecJ85qfvQidVoVJ5SISS1NibuZ6epU5r40/e+xTRcIZipoBar8Zqs5NJJxBVZThMZdS3tSEiZ8e+fZQkOem4n1CySHtzA7NzU0i5BLl8CZXOyfFDz3LkyBGK8hyCTEnAH+Rdj2xDZ8uSCMg5f/wsXZ11mBwuYsoF1CodxUyOTDGHXC5HpXhrojNZEWTyIiWZiFGtxWiWk9MI6NUqZKkcKrmWhp5u5MUc8byEKIooZRLv6fnzG2b8xMSjODVWhmZGCV2yIYp5MqY5fv5Hx/jQZx4lmh9CXTBzpu8Yrlo7++69ndBUgZngEmcPTRGc8PCH/7wPh6YdtXyetJDBIavjenqWKqWFz73nKaLRNLICqPU6yiscxGNhVJoKHKa3FmMmX2LV+vVYbQ78nilmfWG62ppJpmKUsnEKKMjmRPovHuaNN96gKM+RyxdxOty0bK5E1MZIh5WcP36ers4aFEY9BWMEtdKEUiYQScaQyf773ZIa5FIRhQgF5BhUGoxmOQWdHK1SRF2AQl6grXcVQj5HPF9Er9dTyiZ4oPeLN8zxqYkPY1UYOXFyGH2yCrkyTVbr4fHPn+eOR29lMXSZqkoXZ4/3UdPiYu//r703D7PrqA+03zr73Zfeu9Wr1GqptcuSLVve9wUDxoQ9+AtJIAwESDIwBIZJJplkJiQDgYSwJRBwIGyOWQx43y1Zm23tai3d6n3ve/uuZ6/5oxuPyTMR3zAGKea+z3OfrlPndj/nvH3P79ap86uqO25g4kSViXyOZx4cxB8s8ba/20ZHegsJbZpKpEys2MTpYAbGDT75+/ewWLKJSAszbtHY3MRifoGE2UxzczPrt2zBsX26e1ezek0fI2cGWFgs0dLSgmlpRHVJruCwkLc5eXQX37z361iWhe14XHXF1VjtLsIokZ8KOHP4CM2tGazGekgUMPU0MVNjbnEBQ1FRDB3diKGJpQf+oRTEDYt4WlnyqCsYFfCkYMP27YRVh8DQiUajVAvzvGX7n/w/xYUa/7/497tAtqFG8T340hfvZ8Vilouv2k57eh0f/as2PL3AkUNnSWkWLtC7oR0tHjJenqFtdZybg0v45J98nY/ddQ+/99/voGNVA5GFLKebZmhL1TNf8bnubc309K6nNG9RKs6TTGZRNYO5yRGOHDvNdHmWO27+Hc4On2JqcpLujk5as+0sTIzT2d7BzMQ4q9etRAYW3V2/ixlroKWjhUcfvZebb7uYQCshAwijJXa+cTPDu8bRm6YoDRsMDJ2kf+dKEmYcO/RBVzGEiqZHCaNVpBGC5lNRBIqn0ZhuJedOk2qMMjZ5BMeZoyG2kvq6Pmz13BN86oqJplp87579tBezbN25mfbISt7/x40EEY8zhyo0RDWMWILV61agW4ITk4N097VwyebVfOHx4zz5z0UuvnGcVFNAYrSZ0/0zrEjUkat43P7uVTS3dpKbUgn8ColYGs20mBkf5NiJs4zOz/Da297NYn6BwTMn2bp5I6aepDg7Q31bC5WCQmtXN4W8x+reLoSeQhiCI0eeobsnje0sokUVRKLK5W/axNlnJkilAqojEcamR+m5qI1MNE3Zc1B1gakKDDWLZy6iGZJAOFTVCIoL7dlOxmbO0tyRYXzqKNXqDPXRHpLxJgq6+TM+jwbxeJSho7MkClNs2rGOJr2V3/7gTejZKLMH4oQhxNN19K5tJfAlh0ZOsW79KurjBo8NjxCMvp05r8h8ukj8TBP53iJtaj1TLUV+/Q8vJpVpZH5CEgZV4tEUumExeGaAkZFTnJyY5JZr/z8QOkcOHmBtXy8Tw3upWibprg6qlQpd3atIzJXo6V4BkSRjY2NUKpMEygz5uTKZxijRRoUNr+7j7KMziFSOmVMOUdOhZV0dDcl6Fp0Kqg6mKjHUelwzj6aFOKKC1GJYrqAzu5KzxZOs6GlmfOo41fIkaXUjjb11uFbDyxcEavxcXPDBPWqY6HqAMtvAjx4a4fH7T9KZXcVvfPQiCoZHzIDuvixDOYuKGxJOCbKtCSKxkJlSmWhSpzzrIQ0fZ0pnRW+WQPEYP7NIc0cD17z6DfzTFz7PZdev4+/e9RyGGZKKptF0WCyXiCuC+71dxNIW2Xgz9ak69j3zCHUtLUhF0N6xEtcOUY2QxWKJ/vVr+cSn/pqKM0E1XBosEqnkqd/SQSE3Tyii+EIh3hKydfVaJofmmDydZ3h0jLfe9SrCqI+iB+hhDCeo4IkQDQVhSEbdcaIpmFiYoKNuFZloiva2ZhaK0zS7F5/TY9xM4Psl/Ik09z0+zv3/coSMUcf7/+pKjo+OEtFCWldG2T8wT8nrxh+V9G/pQig2Rw4fJJYyeOCeR9ly02sQhRU0dNeD4nHm+BQdfZ3suP5m9j3xJNl2nc984DiaWiUWSRKNGSwUSkSBgw2DCCNEOjpOqcLBfftYs3E9IghZ0d5DpexiRU0WCwus29DPX/zVX1K2x3G1dmKZBLGZIvG1DeRnc+hWgkgqQiwtaVrdyeipGWaGipw6M8q73nMHtlHFF2XMMI4bVpGagGWPg5WzRBthdHyYjsZVpKIxujpXMJMbxcyvOqfHmJnEcUtMjuV4+OE8P/jW8zSYjfzOX17Kw489TX0mTms2wXP+HOWwC6bg4iv6ce0iB/bvx8rE+PM//CT/8e9up8PqobUtzbTuMXBwhJ5VK2m6rIPje/eTboPP/sFRUMpErRh6TFKt+MSEyqHUEJH4GHZJEtM0rGiM+sYmLMMgYkTx3YBoPEKpvEh//zp++MMfUSiPsGZTJwktgTvuIDotqlNVkk0NZFp0EvUVdNPg7IlJZs+WGJ+e4Dff+TpKeolAK2L6MXzNQVUFQkqEFTBYGsJq1jg7MkhH40rSiZW0tmaYWxzCmawF9/PNBT+fe1SPMOOUqIs0YSVDjOYEr35nF8eKZ5g/u8jNb91O3QqTG+68mdbOFRTzZdINOhkJf/vJb6IqcXRVpU6spVxwmPZsInaUeGuSSFXDzgf89jvfy/fueZoPfX4nQehSrtiUyz5RM44Tuhw/vo/F+QU0XbL3wLNYySiZpMnA4Ak0RWBYOq5jo+LT3dPFx//8v3HXW97LdTt/jeNPn2Q+rzJ3pII22s6tl74B/9QKhh+QrFFuozXdw3Vv7uXGOzZycmCIgw8N851PPczD33sGxRcYKksDolDQQxAySrS+ESOeRDfbqBYjKFMaR599/JweLU1nsriIYmtYSRuZVnnTB9cxUBwjrmTYeHUHqVaL7dfvYMtFm5mtLBLNCBKBZNcTp1CVKGqo0BBZC7bCrHCWPLZkybgR/JLKNVffxJEjE7zv0xsp21VK5SqFgoMIVezA4cknf0Rudg4/KLP3wF70mI6h+hw6fpBCIY8UYBo6U+PDNDU38tH/9EHe/ub3cPu1v86hx44zu6CwOBCQXOjlktU3UD5Sx8yTEfrErbQ3dHDNG7u5+c61HDl8imOPTvL9zz7Jc08fQwtVdEUSyioKCmoImkgRb2km09SCbrZjl6KICZ3Mz7gidDTmKx4UVVJ1HhUN3vpfNjBUnGF9zyaMhgrpDkmyrY6t2zYxHeSJJgPSqJTyBpo0ET7E9RZkWbCgekS8GJHGFHVWClEx6ezuY3K6xLv/Zx9hCKVyFacMdtml5JTZvedhquUynl/i+MnjVMtz2JV5FhbncF2Xil0lEY/w3L7dtDY28f73vJu3vfk93HzFmzj4+AnGJj2csybNwVZWZTaTeyHJxOMRusMb6O1axTVvXMmdb7mFQy+c4uSTc3z3s09z8oWzGKhoAoQMUdFREehqknRrK22dK9HNdgIZQZ80uap/y8sWA2r8fFzwwd1zfLANXti9j95Vrbz+xm2EnRFW928gavn4lkbMbCKrarSvbKAadYhELJRKFNOMUFzI41Z9fvsN/4m56iiO75EfWkSqCvN+CVWTOAtFVjZ3MXG2xHs/fRMuVRRP4Drh0oAiO2B+LseRoy/QvKKTQrWIEFWaGldw6PhRBgYGCANJ4CvMTiwwv1BmXf9m1q3dxn/9r5+hv/caoloHsxNlHn/yOSoVn007tvPtH/49JwZOsu+RMYoLKum6LN3rm7np165m/YZ1mNUWgpkIfXVXYU/4ODmF+lgGw4sQjafQUipqsp6wK0PnLeduceZnc5RzAUPHTrKqp5N3vO1KzN4MfWs3YJpVWns7yURb6GtvQ4sH6BkNQ9MpTLrouklhvohnB3zkvf+D6coYdhCQH1pEixrM+SWk8LFzRRpjdYR2nPd8+joC1SWsBiA1opE45YrH2aExRkbPkmloZrFSIGJ4JJJ1DI0MMzo6zNDgWerrWqgWXBAW11x9I431nfzRH/0NbY3bkE4do4PzPPfCaSoVn9aVnXz13r9h4OQwBx6bwC1HyTZkWbmxmRvuvJLW1lbMahv+tEV/47W4MwJRjVIXTWP6UVLpRrSUCrEMYXeKYnv5nB4nRsfZ99QRjj47SFNTA+9/31XIFQlW9fahagUuv+kaUvVd3HTd5WjREDMRwVJNBg9NoqoqxbyD74Q8+K39TJZGsIUkP1wknk0yOz+LHVTIWHH0UEdTsvz2J3citZBqxUPXIphGhHLJ4cTx08zl5kjW1TEyOU02pTEzU+DYwDHy+TwnTw2yafMlOG6IFUlz43W3UJ9t5yMf+QR1yfUU5gz27T/NiZOTOI6kZ+1K7vnxFzlyaJDnn5hg7OwMmfoMPRuauOX1V1NX10AiWEkwY9IdWYc3q2AGabJWBj2IEk3UL30ezQbsjhgH7AMvZxio8XNwwXfLlPM+f/UX36ShawUb+hrYeNUW5vVhBo8Nk/QjBHaZiYkAIxGwItZEzpohYoTYBR9VGoSah+cFUFVwsBgdGqcrmiIIIR6P8MUPfY53/vld3PaWuzi8/0GMIM07P3UNEw9O09e0gc999VEsI8LMzBgTsyq69hSJpM/zx31On3mCi7fvJJFKozBG+8puqlWHKCHDo2dZ2dPD4NQATrmEXy1hxU0sr8rlN13HnhMP0LulBd1QiUUTzJaH8CiSy+VRtTipRJKyt0gQ+OzZ9wx24KDMVRg7M0MYqOwOjiCExDAMBBCJnLuvOGrV8+mPfIW12zazcWWK7dds51juMIf2H6M32YWuBAxNVaiGFbpEK+WkTUyXVIMQJdTRjADX8QnGBLMFm+hMnjrVYKmrQ2HP13Zx2Zu2cflNr2bfvvtIRFv5zU9cych9o+zov4a//sKPMVWYmR5jdCokm2lkauYoj0rBocNHuXTHlWTq6mmqU2lp68Y+O4IIJMePHmFlTw+npwfQVIkSuOiWgeWVWbe1n1OT+1i3rRNN00hl0kzlT1HFZX5qGKFEyaTSlNwFPC9g17NPYgcOU+MLHH/hDKpisev+w0CIaZoooSSWjJ3T44r2Pj7+p//CHW+8gZZGlW1XbeHQ9HGeP3aQnb07sXSHhYmA3GKRplwKIQSmEtKQMhGBhqp5uG7Ik9/by+rLmkjnyjSYGRZx8E2H4HSFymqNK6+7jd0Hvo8aprjrLy9m6oFRmqJr+O79RyCsMDE+zOCoR+eKbg4cehojYvD8C0e49pqb8MMJGuvqSbe2cPr0GZxqmaOHD9HZ0cHIyFlSySiBs0A2ZaG5JcyGBAv+AGu3dCCBhqZGpopj2H6e+YlhFBElnU4zV5jAdX32HTmI53mMnp0GJKqqsev+w/i+SzwZQzoe9U2NL1MEqPHzcsEH92yqmbCoEvFC1u5cx8z8HPXNHeQJueSK7YwV9mNYBqu6+pidLlGpKrRaSar+GKgKaqAQKh6GahHVktgVh8b+PsYqgxRjAXe89yaiagPlUDB0tkBT7yAJI0XLDfU4sxpB4RBuZh1JPU0ko/HsUw/Rv/1SZmZ3UZ/O8szT92F7CpdcdA25xQUymQx19Umcwgx7943z6EOPM7UwQ3tXH83RCIHh870TnyGdaqTsjNOQbCNnjaNGBXFNJakk0CwNISoE4VkMK4Jt20RQGB+eYUVHFhFJorsWmq5QmCuwWC5Q8ZPn9GgYBpEwiSjbtK3fyqmzZ2hv7cSx4KLLLuLs3H4UTbBh1XompwrMF0vUN7cRM8tLHqUkUH38qkIynmH07CRrr7iW8eoQ5agkukoQMxvJVTyGTxVoX6OR0NK03dLIoUNDCPc0IrWSSJCkVBzkgfu+w/pLdvLMnmeImRH27H4QzYqzad2lFEqLZDIZkpko02MDPPLoCXY99Syzi/OsXL2BBsvCEVX2L3yHVFMLFX+KbLyRvHUCMyKIGSqByKCaAkWx8YJBdNPCdV0SKIycnaa9sw5pSiIyihCCxdlFFsslSrn4OT26QYkoScbPHGLjZa/j+OBxGuszkOmld2M3Y+XDVL1F1q5ew/xCBc00sMw0bQ0Coe1CDUMgwC2GJJNxDuw7xI1XXo10XBxV47mRx7lt01uYL9tMjzg0d9hovkXjVQ3s+8EpVDFDNdRpirZx/Mwz3PONr7Jm8xae3b+XiKrxzJM/JJFtZF3fdip2md7uLsZnQsZOn+CRR4/wzJO7WawWWd23iZZ0grnSJDOxfbQ0d5O3h8kkWphTj2BpCjFNkNH/t0c3OIOWMQkISfswP1shndWRZoyEGicMI8xO5bBDm8rUuadOrvGL54LvlnHCWYL5CJsubqd4dpbMqpCZ0iLbtl+EYZi0tHcyt1jCV1yk45FMxQjVgKaWDgAURUHTNNSo4OgTp6lUbPKVBeZmbHwnih1zKZenqeQWuP21b6Yh0oQmBbg+084+PvJXH6a9NYIRKRC4Ve569x8wPzdDOpIlmaqjvqWdgVMH+NY9f8/XvvY19uzZw5HnXuDMmTMcO3qSrpWraYxHuXbdamaMUXKZI/R2bAZHoym9mu7GjaSNTmJaEvwsm1deguJlUYM0ipdCl2kSZjPJWBfr12/EiEWIGTGsiIKv+GSaMvStW0NP/7kfYJWcGcrjgv4tzYiZIh0bEhQCh8uvuARdixJNpql4Ia5cWqezuaWBUA3INrUhhEBRFFRVRY0KwjkNQ4+TryywmAvwHYuGNQ2cHTxClJDbX/9WkpE0ge0hHQ+RGOIv/vZjGEqVbKNH/5qtvObNv8n01ARxNUFjUxuZhkaeP/gU3/jWF7n77rvZtWsXpw8f48SJE4yNTrGqr5/WdJLrN/UzF51gMXuC7RtvIKhAS3Y1W3qvI6m1E9OSuJUEG7q2ElFaUIMMJvXoMk3caCIR72bDhg0YsQhRPYquCwLFp66ljjUb1rBy3blbnFV7gYUzVdbesB4zX6FzbT1WOs5F29cjgwjFigdqFJcKjueSysYINA9PLo18FUIghEC1FLJ6G40N7WAIykUBis7qnX08+vD3ifkB1972OlTTYGZ8BsMw6Fzj8MnP/CG64rGq3+KyS1/FpdffyvhcnpgSJ1PfQjSd5Nm9D/OPX/0b7r77bv7pnm9x5shxDh8+zPTUPH39G2hJJbnxog0UMqOUGge4+uLXMjOZpzndx3VbXk9cacM0kgROmjVt69DDBtQgQ8JoxRRZEn4j0UgHPT1d6BGLqB5FUeXSdddex9pNvT/z81jjF88F33KfdQuUygUiLQb1KxsYm7DpWmXgKXkGzkyz/eLNGEzhlcvYqkosohLxTWzPxrZtLMvC8z1kIBkaOkO0W+Xs2SkMKXFtD9u2KEibpx7fx/Yrd+IVVLSsycDhw6xauYbCYo5snSCnJFksG4ycPcOaNVvxvCKaZnPq2EmKBZuKPoOr5Bh/4ACaTJGKJwhCuHjHJVh1Bk+M/ZhkJIpdUAjyHkpep7G+kYhiUslVCDQVxfM5fWyOMNBw/YCmdAd+SeK6Li5lhOIRmo2YukqlUkYIiGTiaEoM/WcMVyiEAboh0BsU9NURhsehrt4jL0eZHiqyes0GconTqKEHsQiaHhLzYhwbHMBxHEzTxPckSPjBvd9n600bOXs2jlMsYsYjLCyEdGXinBwaJdGQZeZsgda+Oo7tPciGdZvZs38Pb37rDfzwvucZn5qmeUUX/f3bqFbLbL2one98/bvLHqdxlHnGHti/5DESQ7Mi9PatRksJHjh5D8lojEpeMD8yQ53SQLOeZeT0aapelVBXUX0YGsgtdSkJjUS0Ed8N8TyPgiyhqD6OkiYTNSmXy2iaQiQdRxXR5Zb1v818KSTbFMdUTOxVEsPPMDN3Cr2zjD1tsrp1C+NGlXRsgULKQFVC4k6SH+96DM/zUBSFUAqQkr/71Ge54tU7GDxtsJjLs2JjD/k89G1Yy1SuiOo6zJwu0r1xBU8+uJtLdmzlnnv/hQ9/5Lf4xy89yujsMDf0dNG3eiOeY/PO37ye97zrQxQLSwtonB5/mjPTT2DKRtLROKpp0dHViRL3uPeFu9FjOpqtc+bQCdqjHayINPDoQw8QxBx0LYEaVhkbrOCFAl01UY0sYRjg+VXcgoOq+XgiixnRKVdKmKZONJFBDQ30sDa3zPnmgg/ug4fnaO/XsWcKBNvLxGI2Z46Ns2PrNohNoClJBob3sLHvNoK4RI9FSQnJwwcfQ1d0Qi9EVxUCGeIokpb6Vvbuf47L+9dRLZSIRxvxvEXK5WlK+Srxxk5u2tRLwgj48j9+g7vueheXXncRowPTjI0rtHWt4qv/8Fn+6uO/yWe/9BCHTxwDRZJMxLjq0u088dRTBMoCE0UH4Tncd/89oCiYQsELVVRVZ/TkSUp2nsPPnSEIAgJ8NE1DGBowjqpJFKmghicxzdTSqvSLYyBdVvav5NZXXUsQD5mbKaIWfdyChy3OfRP24Lf30LJaxZktEmytEEsG5Cdc6npbKRkTmMYWnt7/17z15lcjDRc9Fifmhew6tAtNaPiOj6YIQinRYjEaM03s3f8cN158CZVShfpUB4XSNPv27uOinTfTvXYrt2ztJ6b5fO6LX+XOO95GSrXoX5vEGlZo7VzJP3zu03zv+3/K+37/s5wePgOKJJ1KsHPHFp546imEtsBY0UHkqoxOnwGhoRPiizyGZjJ++gQlO4+pmYRhSIC/dIdhGUg5hlACNKGhh0fRzSRCCBbyo2gqbL5kI5fdsJ7FxRKFvIMouLgFB0UY5/T4rc89SMMqHbXsQswjF5xECyxEKMl5x+mybmLPD/6J269ci6L56FEdreAyujCOIhUIAxQkQlUwrRiZZIaBk4Ncc9E25ipVMvE2SuUpdj/xDJt2XEv/pku4dlMfaQ2+9b0H6OncCEaV9evjJMYbaFrRxXc+/Rd8/Wsf4mN//LfM5GaRIiSTTnPJto08/uQuQivHyKKN8Jc8CkVHkwGhohGPpRkZGKLiFjBUAyklAUtjLnRdJwz/t0dD+mhGAonNYmEe01DZfMlGrrz5ciYmprErkrAg8Ys2qlKbW+Z8c8EH96d+vBc9HaEx28zRg4N09KdpztZjoqKoDr6/SG//ZszGFEauRFmZwPF7eP7gc2R7VjA7MI9p6XiqR0TziIQZ+vr6CA2Lsi1QLR/dihGLG9SHCoXA45GjewjVOt5wx/V4ocuT+5/mhu23Mr94mv27nuEtb347H//kjxkfPYlpRQkJqNo+Dzy0G02zkAKkUwUhCAOPUKo4gb3U+nWhXJgDJLYqEEKlri2NaYVoCR1Fl1TLJaKxFAN7x7EiLuk6lf7L+ji+b5izZ0t88e9+iKJZGCZEIhEUTcUtzJ/T49zIIlrKor2lk2cff561F7eSMhpQ/BBN95BBiUxzB34qhlVUWAxHiVVW4HkOifYo86dyRKImVenilRZI6PX09RnkylVsxSBjekQSdUQtlYtaOzk6PcU3Hr+PaCLGr736WpSIyrd/8C/8zpvfx4lP/TPPPbubO1/3Rn7rnZ/j5MB+ghAsy6JUdnjokT2oaoRACqRfRigKnusShj6OdDEMg4pdpuj7qKqCLQuAQlNnFqG4RLIGqAHVShHDsBh8fgLDtKlvMth67SYO7Rrk8OFJjh2+F1WPvOhRCijOTpzTo7B11Iwg1ZbiuScOsXp7I9FQJfQlZgwUfDy3wKJuMDU0ipo0kbk4bSuasBqGKU8uHb8tHcrz82SjTRSMKoPDYxidaWKGSjTdSNTSuH79FnYNnOAL936dliaFqy/dhG808ejex3nb63+Dj3z00xx7IcPnPv2f+Z33fomh0/vQdBPTNFksVHnksX1IoVN1VAgqIASet+RR4CEUFadSJgwCVFWhKgOEUGnprqfslsg0RUFVsKslFDSGj8yhGUV6N9TTuXkdJ/aOcvjwJIee/waaYWFaKqquoes68+NnX7YYUOPn44Lvc/ccnVBRMTo0ervXo7oJigsFfCNEjUQphhUaOzLYizp7Hj5OVLYwcnwULUhyx7U38JpbduJ5Lhe/aiVH907x4d/9c6YmRlAjJnahRBAE+OUK29ZtZO/Bg5QXyuSLcYaOn4VUkkp+ntveejuPPfMI179+B6bhk5sa4aYbbqFtRReaKpFSIIMQ33epVh08z1tabd53CRXQdYHnstTtUKqiqDogqJQD3LKPV5RgG4iIRhh6tKzMEqmz2HJLL1fetpGZ2TIH9w0RazbZeW0HueokhcVJpsYH8eUc229vIdN/7geqs7NFQqEgW0K2brkELUhgF0oolgGGSTmosnJtK86ixne/+jBJpZXZ0QUy0RbeePNtvPbWywkClx23r2LwaIF/+PTdTE2MICIGdrlCEEiKc7Pccu21fOcHP6C0WEIzu1iYKBJpayI/O801d97AP33ja9zylp34fo6wUuCG626go6OXiKURhiCDEM9zqFRsHMehWrbxfRehKaiqxHUkxYJNuVgBoeI4LuWSj1MJsPMhzmKINBUkLk1dGRINUbbc0suOG9YwMVVk3zMDRJs0rrt1Nbnq9Ise61t0Lr2jndTqcz9QnVzIIUIN2RSwYctWMrEm1CBYultQNEp+ida1zbgVg+efPklCaSVmZGmIt/G2176Om265Agi45LaVzIxK9j55GE0JUZNRynlwvZD5sTGuuOQivvz1uymXqjS2bsL1G9CbMowPD5LorOPjn/oUV75qMwdfeJSHHx/lVTffRPuKlZiG8lMe3YqN67rYFQffd1F0FSkD7GqAU12qF4pGteJSKnpUSx6VBR+qEQJLQdV86ruypFoSbL21hy2XdTN0dJYDu0+hZn0uvbqDvD3LYn6KqfEzdKw1uOQ1bVgd587eqvGL54IP7jP5Ak3lJKGqg1KiIZ5CI4amwNSUw2L+LJlEiqAMbtmloZykPtECMZ37n3yIHz+7m2tft41DDw0TVFX6VjUTz2SYmJmmgSKlhTyOFiVMZ1EiFRYnzuBQJdXQSKUksecrHDs5gJ9ymZWSN773UiZKwxzavw9Dj2EYaVzbwXN8Ag8Cz0dKD1UJUXQVoYHjeEi5PEJSqLi2h6qqWDGNtvZO7KrPts2bmdxTpDjroSgG2YxJOhVjrrzAzlf3Mzs7y+yZErueGqSts4lXvWEnyZY0M3mX+z7/FM/cd+5laqteSJ/RTtn1UXWHlJ7CVFMIxcetmhRKwzRkGvDLkt6eldTlMnS2diESgh88/GMeee4AV792G0cen0A6KjFLEM9kWCwW6TRcnGIZLdXEydlZXJnD8ipUwzKhplLIO8Rci5mFeab8ccJsmhvf0s+R0RdYnJ0hkaxDUWLYleqLHgkl4KNqEqEpoMqf8qgoGp7jY5omVkyjo6MLu+qzY9t2xp/NE1ZNgkDS0BgnmYhQ9MvsvH0tudwsc0MFHn/kBCu6Grnr3a8m1pjgyIlRvv/ZJ3j+8YFzelQ0gw0NqylPx1B1m8J4lUyqA03xMPUs5eoYre2NUBFs2ryBxESCbF2SMGZz7/0/YO/J59lyTS8nds/hV30GTx3GF4Kq41CfWCSoVIk2tzNRrpArTpBWA+zQZXZmgcV8hdX1q8g0NZBT52jfuoE3v+9aDp/cReA4dHavJgxNquXKix6llAix9LxF0VVQ5dLc9SgvvlzbIxI1icR1urp6qFYCeuvqmXx6AS1IIf2AlpYE8WiMICLYdstGKuU8hXGb3U+foa2znnd+4A0YmQgvPDvEj/9+F2deGHlZrv8aPz8XfHDXgyhNHSnGT7pMnJgiP15HU3w9GWMlQyPjnBkbxy/5zDmLdPavJiwXUeIeVixL/5pVKMLhke89j10uETgBdStSGFoK1ylwcthGhnECX0fogsVqmX1Hn8OfKaMYKaRTh9YcxzQMWjobaIg38cf/5W+48s2reP17L8PxfKK6iqJAIH2CICAMQxQRoihLahUFnKoNoURBEIYhYRjiVHxSsTSz+TEEHs/s3ovjlymOuzz/4HE838A3AtpW1xMYKre+9Ure+AfX4lUD8nMVDhwYonVFhmtu2kwiDZ19Hef2KGOYKQV7NsnU8Rkqcw10Ne0gq3cxM19iaGKSsBIy5y/SsqqLmOYjozb5ks2avm4Cv8Qj3zuIUyoRuiHxhiSGlmJifJDRWQXPtXBsQXNHG6Gh8q17vo7MOUSTTQSlOrQmDc/x6NvQTV0swyf+55d54+/vZNVlURzHwVIVNE0BRS7dTfk+igjRdR1NVxBC4toOQoIqlBddV0suyXiSmdwoSJdILIkfOowdmeP4M6OUbUFghrSsyuLrCje84QrueO9VOGWP/FyJhx9+jo6uBm573Q7iSZXutd3n9Cg8E2k6xKN15AYKVPNZOuq3k9LaqDo6Y9OzRDyLnCzS1N5GKhbiKgXGZxfo6W6jPF1k76ODBLaLiiCeTmFoMU6dPIw3ouA6OnZFUNfaSDyb5fOf+xu0cki6pxe/UI8dKZGbz7Fx2xoSqsYXv/At7vjgZsy2OeZmp4nqS6t2KZpYckSAIFjKGNOWMnV810Nhaf9PPFaKDvFonOmFEZAOXeu7QJcM7BnmxK4R5ooeMhrS0JUk1Cpc+dpLufyN/RRzZRYXitx//x5W9q7gzrffSDSu0rFq5csUAWr8vFz4wZ2AxMo4tm2zqn0VpqoRqatHCZvQdIWrtv4G9akEYyfGSTZEyDVpmM316FGN3bt3A0vpkOl0GkUNidYL8nNnKBd9ND3AdSqIIMQpe2xeu45ULEtnQmN0+AilXJGC7fDkk0/S3t3PCwfvJ6ZbfP6vv4YXzvKO370Y319em3M5xe0ns2xqmobv//QUvFLKF1MzhRBUKhVCV2D7FRbLeRLxLKVSCRSDff98nN3fHsCvCFa0ZNB0GDk7y8bXdON6FSbGZ5mbcTg7OEPbyg284ZYbzunRlAH1a7PMLcySTWbJJlMUg4CI3s34xCjb+l5PwjJ45ke7sJIqEykfN2JgJi0OHDiAoigoikImk0HikmrUyM+dwdAS5PJTOG4JJZRUCg51sSSNTSvoSZmMnj1IfmaORS/g6WeeYkVPP6XSMKVciU/82RdIZSW3v3ENqioRYunL7197DILgxf+jlEvBX1VVNG1pqT7btvFtiRNUGR4fJGKlqVarhB688K1TvPCjYXB1utob0A3B1MQim17dieu6jI1OMjfjcOTgCB1r+nnL7Ted02NEhtStyjJ0dBdCSNqbW8lVbJKRPo4cOURv6/UEeHz/q/ehRCQjCYeypqAYcPz48aX1cMXSFMRCDUg1q4ighKknOXLyKGW3jBJKpC+wCyVaOnvoyRjkpk5g5/OUQsnY+CjN3WvQrSqFuQpf/sLXWdEZZ822OPUNyReD9k8+cz/xKKV80W8Yhi/+T1V16eGp53nLHisYpkBVlr54A0fh+L+McObpGUwRZ0V7M4YpCDyLS97QR+ALRobHmZspc3DPIM29PfzGnbf/X17pNV5uLvjg3pJtQNdiyOI4w3NjdKxoIZkJETJKc2sSv6yilDZx9MwwqhWiOZJiOEOgQG7SxXc1NF2gRlQuuq0bu+gzOjJLsVLCzJjkxufwypJQNZFaQFX3eWbPQeLJBohEkDJCg9pEEASsWdnO+z78LkQ5xZe/+T2cRMAffeUDSxdQKIEQRQGhmAhVYCgqS7MZawghkTJ48b2KClJ4eGGAocbpblpNqTqHoi9dkHrUIkWSZ79ykMnTDtGIIFUXQYQ6l965k/d/9NdxKlWmx+fJz07x7MDxc3rsblvB5MQ85bGTLAY56urj1DUqaCQpLM4g3ChycT0iGkcqNpoHC/44XhCQn/JwbQVdV/AVl003t1OYKTE6MkuukCe7IkNhIk9QFYRCpWtlK44WcmxgmES6hVi2gSDQ2dyxlSAIqM7P8Wf/82O4+Sjfvv9h6tZk+dO7P7T0BSl50aOiWkgh0aRg6UZIA8JllxIhQRKA4uPLEFNL0F63iqqz5DGQoJkGeknnmS89R24CElFBPG0gsNhx5w7+w398K5ViienxWQpzszx95Og5PfZ197B71wHK+SRmVqWhJY6VqmAqdRx54XmiopGo20ZTbxehYmMEGhPFIUIRUpiRBD6YpkbVLbLh+lbmR/OcHBjGDXyaVrcg5z0CV+AGgiuv3k6owdjkPKhZjFQ9rquSVZoIXIdDz+znnb/7dkrD8NC+vVz26ot4ywfvwDAMFAQQQqgjFJNABqghqKp80eNPAr0qFELpv+gxZmQJqwGOt7DkEYlqmFTGXB77/B68kk46oRFJqMjQ4KLXbubX7rqR0mKJsfEZqvlFHjv4/P/7xV/j/4kLPrhvXLeax3Y/yC23vp10fQpNlczkx1AVi46eFTw98gMCdZZ0W4yk4mGaURbmT2JFErSvq8crBHSvzeIFeXzVI5VJIBWThuYswjMRqk3Rr+LZAcmGZiw1wnTJQQ3KuEoBQ42z4+J+zpw5w/ceeJQJb4ZtO9ZRGAz45te+je0V+eO734/QQoRQEWJ5mTZNBVPBWm55BhKkUDA0nWQqipRLi1x3t6wgHU8Qb9QJXdCFiuqpaBqYRoJQ1dh3/3M8/dURUrKBxkwMEbocOXmQi29YBUqO/EKO2Ympc3psasuw6Mxx+x3vIBpLETE1CpUpFBKs2rCKxwfvJZ620VOSuAioOiEjp49gmEliTSpu0WfVpizlSg5hSfSovuyxnsVZG83wqEgXGarISBRDjfD8iUEMKgR6GU1EqUsZDI8Msfvwcab8WcyIz8SRAt/5xneoeDn+5Kt/AIp80WMYQqgIMLWf8hgiMDSdeMJCAqZmsrKtg5hpIWIuItQwVR3V09ANgWnGCFWNJ77zDE98ZYR6s5X6VARFegycPc7Wa7qo2OPMz84xN3XuRcOMpCDVGOPqG9dRKgUYhkbJnkaESeo7Mzww8A0a4iZK1CMR+Nh+yJH9B5dmA7Vcynno3VyH65VR4gq+9AiFSTRhUV60EbqDG/ggFRY9G0OP88ATz5IWLqFRQWCiBRWKpUUWwpB4Z4yzR8cYfS7Hww8+QqxO40//8UOEBCiKhqKw9D9RFaShYmk6Ukr8cOnLUVc1rIiGUBQMXae3vQtdVQkVHU3RsXRt2aPEsqKEquC+Lz/M418aojHWRjZhosmQXGWejVeswC6OMzs5zczUubOOavziueCDe54yV2y5jinvEAf3HcANCpRzcwSihBWzSMZb2bP3xyTrNarCYWJhjh/fdxwtotC7vYdt1/cx8MI8odSpuCX2PX2ItBUlkIJHn3qUpvoVyEqVWDSB0A0cb55Zf5qxo0N4FZNSqUSg6+iqgZ6OcGbsEJOFOYreFMU5g+9+/z4y2Rj/+esfxLQEoQZC8dEQyMAnCEJUoaApKpqikkrHsD2XeDyOGY1QtCtMzkzTuaIdVUiUqEVCNXCrBRbLOQD8sMiGK3oZmx5nfCKPKaIYehRNTdC/egOX33IdO1+185we1bRFnHrmxFEGDh+m6hUoLy4QUKS1rZmoVc/Dj3ybxhVRHNWlGjh85+vPITWP5rWNXHTNao7vn8MLQSqSA7tOkrai6KbJ0ZNHSSUbCEplAl8QiccJZIGSUWDmzBSlskKpVGFsdhZdNSApGBo/TMvqbhSzytw4fP/73yWe1vjw3R/AtARSFwjFRRdLueG+J1GFgq5q6KpGMhXFCwMSsSR6zCRXKjA7n2Po9Blk4CEiJhnTolwukCvmEULgBgW2Xd/P2ZFhZmbLGEQwDAtdS3Lx1ku5/JbrufTWS8/psb67kfJMyKI2R3F+jqpdwCkW8SjQ3bUSw0jy8LMP0tVTTxgBH8n3vn0YLywTbYY1F7Vz8Jkp7EAiUBk4NIkpBKlsioVShSBUcCpVPFeQyTYiVBtbKzE9MUqxrGDbHp6qYlfKFMhxbGg/V712O3rUZehYgb37nkGNB/zZPR/DMCFUfFCqKAiE9HEdHyHB0HQURSGesBCauuQxYjGTm2duYYEf/eBHuK5NYJpkrQilSoGFwiKqolPF4eKbN3J6cIjpmRJKoKLrJoae4vIbb+DKV93EZbec22ONXzwXfJ67GleYGszhR8ukY2kUKRldnGSTzCMDC7fqIhWD/vV9KIZLwkjzwv5hbrmtByPt8/TXjhLaDp4S0pxMMlSax/cEqjTY2L+JtBLl1PQwVipCzJdcdtlGHnpoiFi6mSfu/QFX3HkjJa/Cj775GNtv6WGxoNLensKMrGJyNMfIQJ7HH36Qq6+/kT/4/Lv41O99BdvxSCaWWpt21cO0VFxbkMkmcZ0AVSy1qCqlKp4tkabCkROH2HL7RoThko4kcZQAXRVEEnF0Q8UObGJGCk3qpOrSLM4vEOoereub8WWI/zNW1JopzdJpNTMyNU1TtgkChxl7AYc8yXgTswWFWF0dzb3NKKZC3EhQLOikrDSrOwUPf+04ge0Qa9GpMyKY0sL3BCJUSMWypIlwYuI0etxAUSXr+zt5dt8M0UQjQweO0rZtNT39Pdz9Dz9i8/UdlKoqdWkDVWSYGi8xNexz+Pl9rNu4nT/88u/y5+/8HJ70iUY1FFWlVKyiapLQF8RiEXxvaSi/qgrsso1flgRGyGxums2v2oAeDcnG0pRDB8PUiESjqJrAwyOp1hHVY8QzMWbGpzGNOKnVTQSq+jM9Hjh6kOs37uTsyDCZWBpNBORkCVvmWbmyj/kpDTVhkG1M4+kG9Yk4zY09xLUMG/t6OfDgMEqgsPqiVhJCYCkRDNUEX2Xw7DA7ejdxbPwkZnQ1qiapzxgUywpBzMKcKeM16vSsaef++/bQtCFKGAoSdVFSGYPTA3OcOrpIS+tRmlr7+Njdv8cfveMvCYRKIm4gUSgsVpcSAHywIjpIjSC00XV9yWMlxNd9OjavxchaWAlJOrLk0YoYWJEIuqHgSo9G0UBUj5HKJhgbHiMRz2KkU3j4yODcC7bX+MVzwbfc58am6VrXxNjgDKZpEGgei3moOEXm5hZQgioiJvDRCEIL1TBJJHswYw2MzE6hxFWsWJQrbruYg3vHkIqK61SYGBkmkrA4OXcWqauUPIcwgEpOoEUVDh57jsuu2oFpOwRWHM8vU59uQ3iS5t5e6lrbWbt5FUroMXwox67Hn6C1LsEffOYdeFqR0JFUKy5OqYLrSWINIUQqoHuosRA1LsimIqiKT2tdlvx4wMknT7Dv3n08+u1HuGTNZurrMmAspVTGInFQBaFhsLCYx9MEzQ3NKBEFVVFY0XbuPHfTV0mtiDB+ZhorYuJqHgsLLrZfxPGrqKGHK1x8aRFIA6kIUpkeoqk6AkOgxHXMRILLbriEpx4ZIBQKrlNhcnyCru42xipTJNIpXCHxPWisayc0An784HdBV9A9h4owKBZzxI0M0gno37GDTHsn19xyGaHjcGz3BKeOPk9dwuTDX3gXoeoT2CF21cMp2QjFINEEatxZer4SBTUW0JBOIBSfuAL5CTjzzABPf2M3D33jQXauv4i6dIpQ81ENDcuILA18AuYW8sioQUNTE3rcJKIbP9Pjmo5eSHjMj89hWAae7jI5MQeqgxYRWJqOq0dQtDSB1ChViihGA4m6OlJNWax0DCsZp3vNSp5+5DQBEqmEzM/OsWXrRibcadpa26kGHq4TsuOiS3GFx4EHD7Fn/z5Ur8Jsxcf2XNTQIqgE9HR3oCTr+fXfuhO7UOL5p4ax86MkTMFHv/A+FFPBLTs4totbdjAjFulWFaFLFDPASAjUWEBTNgWqTxTJqQNjDO0+xWN37+axex7h8k3bachm8JWlwK2rxvLAJ8n0/AJqMkqmro6IZZC0orS1RV62GFDj5+OCb7l31HXi6A6RpEHSTBCxUuixGAgNEarMDM+QaLbAk+hSwfOmiccEuhahWKhiiID2HV0YFKjmQnRVxa86iISHUFy8qkLS0lAciY6JFUmStARG8wqEYTM+OU/Cs+nf0odTVokkGpkrLBDkXbK9TXzw9pv4yz/7PENH53C1R7hs4/X897//Mw48sY8n7n2Kal5iWD6xVBKkhlRtTKKYwiQZT7MwneNVN9zA5/7hGwSBh25ECHzBxz/y9yAl0bhFEDpoVoTX33kVZrtPIXBY1bqJRebRbB98n6mR0jk9NkQbKYUFGlqzSFcQM9JokQSqFkH6ktNHT9DSYyID0FyBmljAjPhYRgLPlUi3Qt+lazBlEfylGSn9qkPV9ik5AqUQIRaJEPNBDzXmcxUaEiaJDZtp78owMzlLKghYv7kPVSaIpy1GpsawPElV+Lzng3fxyY9/iUP7FGzVZXXrZv7sCx/jB9/6IaefPUkpsLAiCpFEFBmq4HskSOC6IZFEPaE/S3d3O0dPjhPkPKxIEs+G//YfP4siBNG4hR/YaFaEu95+M3q7wfjCIqs7NrEoc2hOgOvaTA6fezbDBHHmqvO0NXcivBBdiRFJNSFDAyEle3c9Qf/OniWPvoYRL2JFQxJmHZFIjuqix6ZrOzHcEiI00TQF4boUirMktHrmyy7lqEuqrRlD6oyMjVMXM0msW0t9m4FbgWJQZFVPOwmrDiPmsGjbJFQ4Onyad77vzXzuM19n95ODbLomIJ1q4Y8+/UE+/Zd/SzDtUQwjmAkVI2pgWhUCLyQuE5SKNno0jetP4ZZshCFYXAyJxlJUCiF/8oG/Rdc0rKhBOQgxNcn73v9GKgmH8fkFejs3UVYKyKpHtVJhaqTWcj/fXPAt92LBYHpmhGLBYXY2h6ZDtVRmdOwsZU9yeuo00ogs9dMaYEUlhh7HFxLfd5cGvWglDjwxTuAv5UtXyxD6ERTiHDt6gqQ0WFiYIyyHoCvEEgLbdihXlobE4wl61q1BhgpRw8S3HQ7tPYombZ5+4QjvuOtNVB2bwpjF2bkB6qyAdZdt4C2/8WuksgrRmI5b9sjP5vErCtWKhyYFJ4cGEELyj1/6NkHgIaXEcZwXU9YAPBd8DxQPfvDtp/nhZ57muS8d51O/9z/IKjESgUEunyeaPPdcHorMkstPMTE+RxAIND0kcD1mZ6eZK1SYry5ANEk0poEp0I2QqJFAMw3y+QV0zSBQCjzxw9OI5W6lahkCz8LU6jg9PE5GMcnlFhG+hhmLIdQqdtVjobiUlhc6klX9awgDBV0ouJUq+586TESH3YeO8eY33EGxWGJ8wKeiLBA3XG5+4628/bfeTKZewzAFbtkjN5PDLYXYtk/KjHJyaAAVh9MnJwkCbylvu1IhCAKEED/lUfUF3/zKg3zrz3/E4btP8okP/HfSREhJC9txiGfO7VGQplhaYHRkkky6AU0XKH6I41QpOiFSD1CVKOlMBMWQBKGNoZpY8Rizc9PE61Q8scgj3z0GqKiqimMrhIGJr0SZzpdJqSalfAnhK1ixNEKtMrU4zVzRZ3Z2lsCVJOuz2LYLXkA59Nn9yEGScYvnTp3mpuuuJpfLM3AgT1StEjFd3vuR3+PmV19Ptl5HUUK8ik9xVsUpBvg+ZBMpTg4N0Jo1iVopgmAps6tUWhrFrSgKYRjiewLF87CEwZc/813u/YuHOf7Pg3z+o58k7utkrRihIn6mxxq/eIT8GX2Mv5SDWMoXrFGjRo0a/3cckFJu+z/tuOBb7jVq1KhR4/+eWnCvUaNGjVcgteBeo0aNGq9AasG9Ro0aNV6B1IJ7jRo1arwCqQX3GjVq1HgFcqEMYioB514loUY9MHe+D+ICp+boZ1NzdG7+vfnp/Ld2XCjBfeDfytWssYQQYn/N0bmpOfrZ1Bydm1eSn1q3TI0aNWq8AqkF9xo1atR4BXKhBPcvnO8D+HdAzdHPpuboZ1NzdG5eMX4uiLllatSoUaPGy8uF0nKvUaNGjRovI7XgXqNGjRqvQM57cBdC3CyEGBBCnBZCfPh8H88vEyHEl4QQM0KIIy+pywohHhJCnFr+mVmuF0KITy97OiSE2PqS37lr+f2nhBB3nY9z+UUghGgXQjwmhDgmhDgqhHj/cn3N0TJCCEsIsVcIcXDZ0X9dru8WQuxZdvFNIYSxXG8ub59e3t/1kr/1h8v1A0KIm87TKf1CEEKoQojnhRD3LW+/8v1IKc/bC1CBM0APYAAHgf7zeUy/5PO/EtgKHHlJ3ceBDy+XPwz8xXL5VuDHgAB2AHuW67PA4PLPzHI5c77P7WXy0wJsXS4ngJNAf83RTzkSQHy5rAN7ls/9W8Cblus/B7x7ufwfgM8tl98EfHO53L98/ZlA9/J1qZ7v83sZPf0+8HXgvuXtV7yf891yvxg4LaUclFK6wDeA15znY/qlIaV8Elj4V9WvAb6yXP4K8NqX1H9VLvEskBZCtAA3AQ9JKReklDngIeDmX/jB/xKQUk5KKZ9bLheB40AbNUcvsnyuP1ljUV9+SeBa4DvL9f/a0U/cfQe4TiwtV/Ua4BtSSkdKOQScZun6/HePEGIFcBvw98vbgl8BP+c7uLcBoy/ZHluu+1WmSUo5uVyeApqWy/+Wq18Jh8u3x1tYapnWHL2E5S6HF4AZlr64zgB5KaW//JaXnu+LLpb3LwJ1vLId/TXwISBc3q7jV8DP+Q7uNc6BXLof/JXPVRVCxIF7gA9IKQsv3VdzBFLKQEq5GVjBUmtyzfk9ogsHIcSrgBkp5YHzfSy/bM53cB8H2l+yvWK57leZ6eWuBJZ/zizX/1uuXtEOhRA6S4H9a1LKf1murjn6PyClzAOPAZey1CX1k7mjXnq+L7pY3p8C5nnlOtoJvFoIcZalbt9rgU/xK+DnfAf3fUDv8pNrg6UHGN8/z8d0vvk+8JNsjruA772k/u3LGSE7gMXlrokHgBuFEJnlrJEbl+v+3bPc1/kPwHEp5SdesqvmaBkhRIMQIr1cjgA3sPRs4jHg9ctv+9eOfuLu9cCjy3c/3wfetJwt0g30Ant/KSfxC0RK+YdSyhVSyi6W4sujUsq38qvg53w/0WUpw+EkS/2EHz3fx/NLPvd/BiYBj6U+vN9kqX/vEeAU8DCQXX6vAD6z7OkwsO0lf+cdLD3gOQ38xvk+r5fRz+UsdbkcAl5Yft1ac/RTjjYCzy87OgL8l+X6HpaCz2ng24C5XG8tb59e3t/zkr/10WV3A8At5/vcfgGuruZ/Z8u84v3Uph+oUaNGjVcg57tbpkaNGjVq/AKoBfcaNWrUeAVSC+41atSo8QqkFtxr1KhR4xVILbjXqFGjxiuQWnCvUaNGjVcgteBeo0aNGq9A/hdBhOQ0JUuYnQAAAABJRU5ErkJggg==\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "show(make_grid(imglist, padding=100, normalize=True, scale_each=True))" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-24T23:32:52.624197\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "show(make_grid(imglist, padding=100, normalize=True, value_range=(0, 0.5), scale_each=True))" - ] - }, - { - "source": [ - "## Visualize Bounding Boxes" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "source": [ - "You can use `torchvision.utils.draw_bounding_boxes` to draw boxes on image.\n", - "\n", - "You can set the colors, labels, width as well as font and font size !\n", - "\n", - "Note that this util requires a single image of dtype `uint8`.\n" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "from torchvision.utils import draw_bounding_boxes" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "torch.Size([3, 768, 1024])\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-24T23:32:53.654506\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "lena = scipy.misc.face()\n", - "img = transforms.ToTensor()(lena)\n", - "img = transforms.ConvertImageDtype(dtype=torch.uint8) (img)\n", - "\n", - "print(img.size())\n", - "\n", - "show(img)" - ] - }, - { - "source": [ - "We will draw a few boxes on lena!\n", - "\n", - "Note that the boxes are in `(xmin, ymin, xmax, ymax)` format\n" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-24T23:32:54.157276\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "boxes = torch.tensor([[100, 400, 500, 740], [500, 200, 800, 580]], dtype=torch.float)\n", - "labels = [\"grass\", \"lena\"]\n", - "colors = [\"blue\", \"yellow\"]\n", - "result = draw_bounding_boxes(img, boxes, labels=labels, colors=colors, width=10)\n", - "show(result)" - ] - }, - { - "source": [ - "You can also `fill` the box with the color.\n", - "\n", - "Note that after filling with color, one needs to save the resultant tensor in PNG i.e. 4 channel color format.\n" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-24T23:32:54.542848\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "result = draw_bounding_boxes(img, boxes, labels=labels, colors=colors, width=10, fill=True)\n", - "show(result)" - ] - }, - { - "source": [ - "You can also plot bounding boxes produced from torchvision detection models.\n", - "\n", - "Here is demo with torchvision's FasterRCNN. You can also try using RetinaNet" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "from torchvision.models.detection import fasterrcnn_resnet50_fpn\n", - "\n", - "model = fasterrcnn_resnet50_fpn(pretrained=True)\n", - "model = model.eval()" - ] - }, - { - "source": [ - "Let's load an image and get predictions from model." - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-26T09:33:29.242197\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "lena = scipy.misc.face()\n", - "img = transforms.ToTensor()(lena)\n", - "show(img)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[{'boxes': tensor([[ 67.7731, 21.4386, 953.7158, 699.8793],\n [ 202.9559, 4.7902, 940.4207, 679.3505],\n [ 29.5735, 21.2866, 376.5114, 424.0385],\n [ 0.0000, 301.0412, 1024.0000, 768.0000],\n [ 52.2440, 281.1678, 784.5737, 733.5809],\n [ 57.0902, 18.2170, 954.9303, 709.1071],\n [ 27.6776, 359.6552, 814.2780, 753.4029],\n [ 78.1657, 32.2182, 938.7345, 703.4693],\n [ 50.6699, 31.5133, 918.5210, 722.1469],\n [ 0.0000, 260.4532, 729.0366, 768.0000],\n [ 480.9375, 512.6833, 784.6242, 616.1514],\n [ 0.0000, 268.2257, 953.8960, 768.0000],\n [ 100.8516, 354.4102, 766.3854, 718.2952]], grad_fn=), 'labels': tensor([17, 18, 20, 15, 16, 23, 51, 16, 20, 64, 16, 62, 20]), 'scores': tensor([0.3728, 0.3323, 0.3065, 0.2696, 0.2288, 0.2064, 0.1333, 0.1174, 0.1026,\n 0.0963, 0.0725, 0.0574, 0.0549], grad_fn=)}]\n" - ] - } - ], - "source": [ - "# Get predictions from model\n", - "outputs = model(img.unsqueeze(0))\n", - "print(outputs)" - ] - }, - { - "source": [ - "Let's plot top 5 boxes detected by our model" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-26T09:34:59.912114\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "boxes = outputs[0]['boxes']\n", - "colors = [\"blue\", \"red\", \"green\", \"yellow\", \"orange\"]\n", - "\n", - "# We need a uint8 image for plotting!\n", - "img = transforms.ConvertImageDtype(dtype=torch.uint8) (img)\n", - "\n", - "result = draw_bounding_boxes(img, boxes=boxes[:5], colors=colors, width=10, fill=False)\n", - "show(result)" - ] - }, - { - "source": [ - "## Visualize Segmenation Masks" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "source": [ - "You can use `torchvision.utils.draw_segmentation_masks` to draw masks on image.\n", - "\n", - "You can set the colors as well as transparency of masks drawn.\n", - "\n", - "Note that this util requires a single RGB image of dtype `uint8`.\n" - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [], - "source": [ - "from torchvision.utils import draw_segmentation_masks\n", - "from PIL import Image\n", - "import requests" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [], - "source": [ - "url = \"http://images.cocodataset.org/val2017/000000281759.jpg\"\n", - "img = Image.open(requests.get(url, stream=True).raw)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "torch.Size([3, 427, 640])\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-26T10:46:04.209868\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "# lena = scipy.misc.face()\n", - "img = transforms.ToTensor()(img)\n", - "\n", - "print(img.size())\n", - "show(img)" - ] - }, - { - "source": [ - "We will draw a few maks on lena!\n", - "\n", - "Note that the masks contain tensors denoting probabilites of each class.\n", - "\n", - "Here is demo with torchvision's FCN Resnet-50. You can also try using DeepLabv3 or lraspp mobilenet models." - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [], - "source": [ - "from torchvision.models.segmentation import fcn_resnet50\n", - "\n", - "model = fcn_resnet50(pretrained=True)\n", - "model = model.eval()" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [], - "source": [ - "output = model(img.unsqueeze(0))\n", - "masks = output['out'].squeeze(0)" - ] - }, - { - "source": [ - "Note that this utility too needs uint8 dtype image.\n", - "\n", - "You can vary alpha to get more transparent or filled masks." - ], - "cell_type": "markdown", - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [], - "source": [ - "img = transforms.ConvertImageDtype(dtype=torch.uint8) (img)" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-26T10:46:11.418103\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "result = draw_segmentation_masks(img, masks, alpha=0.2)\n", - "show(result)" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-26T10:46:11.879624\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "result = draw_segmentation_masks(img, masks, alpha=0.4)\n", - "show(result)" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n\n \n \n \n \n 2021-03-26T10:46:12.511543\n image/svg+xml\n \n \n Matplotlib v3.3.4, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "result = draw_segmentation_masks(img, masks, alpha=0.6)\n", - "show(result)" - ] - } - ] -} \ No newline at end of file From 7e987bfde253cf457f5f6d4d1c35c560f1711a00 Mon Sep 17 00:00:00 2001 From: Vincent Moens Date: Fri, 6 Aug 2021 08:55:22 +0100 Subject: [PATCH 259/279] Use torch instead of scipy for random initialization of inception and googlenet weights (#4256) using nn.init.trunc_normal_ instead of scipy.stats.truncnorm Co-authored-by: Vincent Moens --- .../ModelTester.test_googlenet_expect.pkl | Bin 543 -> 939 bytes .../ModelTester.test_inception_v3_expect.pkl | Bin 543 -> 939 bytes torchvision/models/googlenet.py | 7 +------ torchvision/models/inception.py | 9 ++------- 4 files changed, 3 insertions(+), 13 deletions(-) diff --git a/test/expect/ModelTester.test_googlenet_expect.pkl b/test/expect/ModelTester.test_googlenet_expect.pkl index 2b10ab1f17635604df35221c9148690b0ab9d0ac..46d23d955d4986d57582b073e751a5c2bfd4cb44 100644 GIT binary patch literal 939 zcmWIWW@cev;NW1u00Im`42ea_8JT6N`YDMeiFyUuIc`pT3{fbcfhoBpAE-(%zO*DW zr zf)S|3ppZF&8AvA=loqmh8ZvUemW=jY_4CYNO9=M{7L z7p0^YrKY%KCYNv(a%ct>a+VZw1r>7Z1$eV_Fj*X^nFTZrgadH;l#f9R#i#lPZcb`w z{zUOK62~Cg#wJ01gUyqqm^~FrqI(Q@7w-A9?CBnZBMC8mV__fqwpZgW}n5PJ?~^%_qg0p*mGdI)-I{5O*XR*UbaaR-D%UaqQpkQWP{C` z^kSPe3peh$w({H_m4{RJd|10+cZ25VJzu`7?>RSd*`9r~zu3qeDBiOs`sp5y7cDjo z*^6x|ru^N#<4FH*77MmLfAW^w1aL&|-ZAOL?sXk|_FP+XeNURev^{zM58G@wWwrZ< zN|z1Cr1Lfo+jd%kLaX6O=JFH3kOE=cp~cT&4G*od)S_ZwEVwzD6B%4cAqQa^bAfEW zI4?bv31}+_2Y54rD0rGgjza;E1PVY;q3F7i{ltf&^A(VXtXtmzT`#h$_)+vq09^>v z3k`z+Z#Fg^s3JLLUAS^kVg>;iy&b}3m<0AD$h&NyyusiJRRGEa0p6@^ATeej1gVFp F1puvZ15W?| delta 226 zcmZ3@KA)w&fvJlt=g%Csp9)zk0wnbsn0#L{1IgM#28{>-1_p+LqWqHl2AUMxcTSUZ6})W=Tm-YJ6&5N@ikSAyY>L7f`UIvLH3SII}9XxRANFkVPYc6)0Go zkzZ6&$m-1$!3^YO=9Lt(d9y^YfXv{^&r2_4_huE+{Qz@iy|CINw^efho3-Ap)CP#zZ|Mpb;Q2*@5u{0PtTs%>V!Z diff --git a/test/expect/ModelTester.test_inception_v3_expect.pkl b/test/expect/ModelTester.test_inception_v3_expect.pkl index 38574f498a5db5800efe91f4d77d4e2a78179f14..51b95f6dcd5b51a038840aac32f89512b9451814 100644 GIT binary patch literal 939 zcmWIWW@cev;NW1u00Im`42ea_8JT6N`YDMeiFyUuIc`pT3{fbcfhoBpAE-(%zO*DW zr zf)S|3ppZF&8AvA=loqmh8ZvUemW=jY_4CYNO9=M{7L z7p0^YrKY%KCYNv(a%ct>a+VZw1r>7Z1$eV_Fj*X^nFTZrgadH;l#f9R#i#lPZcb`w z{zUOK5{GNrpP&nGvM=TzdmfbXf6Ybij6WB}Ucb8d=f2UUoFdV{d5+5iJ&rY8YFm5e zVoW|`;JThafehx+{u?;t{TZ&b1uajry(BWvEoi#%(xA6%HG@=?x`H@$9|Y>Pd=2Cf zR}7l8r8!8ziRF?X4k`se1SdgyDu(TFBG)kqtr!__%|=P!x41PZNyyy*oefFT9KxI>Gd!5SV~WvNBQz*ul|GAA;)kU|c^H0A=?d~sfS zC=<|D5DxHW1X1ubi5!OlAPE$JooXBrWYCp z0p4tEI#5M&%(`&ppu`LUFnT+L%P-1_p+LqWqHl2AUMxcTSUZ6})W=Tm-YJ6&5N@ikSAyY>L7f`UIvLH3SII}9XxRANFkVPYc6)0Go zkzZ6&$m-1$!3^YO=9Lt(d9y^YfXv{^&r2_4_huE+{Qz@iy|CINuuR=Ga1p2yAK@6ZMRMMu5PAjrON~&CSl8NM=4KuyoTo zvGnP_K2P1x?b2>PyTb9D_rZf~ej&UE&vDd$@rk!_^b2{`eAZ#h?Q<;?SkGC9PxR$U zi1SC;;hLx7w{7vCGX^Qw&WH#;I_r8q@SKj|!L!!S zW}cHu={Q#yGxOa2?Hp&~J_VkeJm=+ETkBrm*7~=;A@^>ceH8WR?3sxDzTcc&&iz+b r^2@g4JNL-;tuM>+B)@yP27bI763=BY9Plwcd-?2}Eplgrqy_x|ex#pg diff --git a/torchvision/models/googlenet.py b/torchvision/models/googlenet.py index 0745ef4eef6..6c34f521a81 100644 --- a/torchvision/models/googlenet.py +++ b/torchvision/models/googlenet.py @@ -124,12 +124,7 @@ def __init__( def _initialize_weights(self) -> None: for m in self.modules(): if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear): - import scipy.stats as stats - X = stats.truncnorm(-2, 2, scale=0.01) - values = torch.as_tensor(X.rvs(m.weight.numel()), dtype=m.weight.dtype) - values = values.view(m.weight.size()) - with torch.no_grad(): - m.weight.copy_(values) + torch.nn.init.trunc_normal_(m.weight, mean=0.0, std=0.01, a=-2, b=2) elif isinstance(m, nn.BatchNorm2d): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0) diff --git a/torchvision/models/inception.py b/torchvision/models/inception.py index b9c6ab74534..b5cefefa78d 100644 --- a/torchvision/models/inception.py +++ b/torchvision/models/inception.py @@ -120,13 +120,8 @@ def __init__( if init_weights: for m in self.modules(): if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear): - import scipy.stats as stats - stddev = m.stddev if hasattr(m, 'stddev') else 0.1 - X = stats.truncnorm(-2, 2, scale=stddev) - values = torch.as_tensor(X.rvs(m.weight.numel()), dtype=m.weight.dtype) - values = values.view(m.weight.size()) - with torch.no_grad(): - m.weight.copy_(values) + stddev = float(m.stddev) if hasattr(m, 'stddev') else 0.1 # type: ignore + torch.nn.init.trunc_normal_(m.weight, mean=0.0, std=stddev, a=-2, b=2) elif isinstance(m, nn.BatchNorm2d): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0) From f88985b5204b2a0f9ec5f4fc0231bb53b50a9450 Mon Sep 17 00:00:00 2001 From: Vincent Moens Date: Fri, 6 Aug 2021 10:33:35 +0100 Subject: [PATCH 260/279] ffmpeg version query (#4254) * string manipulation for ffmpeg version retrieval * ffmpeg version 4.2 control * commenting solution * removing all escapes for spaces Co-authored-by: Vincent Moens --- setup.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/setup.py b/setup.py index 195fdb2e7be..60fd4ac3e0b 100644 --- a/setup.py +++ b/setup.py @@ -1,5 +1,6 @@ import os import io +import re import sys from setuptools import setup, find_packages from pkg_resources import parse_version, get_distribution, DistributionNotFound @@ -350,10 +351,10 @@ def get_extensions(): has_ffmpeg = ffmpeg_exe is not None if has_ffmpeg: try: - ffmpeg_version = subprocess.run( - 'ffmpeg -version | head -n1', shell=True, - stdout=subprocess.PIPE).stdout.decode('utf-8') - ffmpeg_version = ffmpeg_version.split('version')[-1].split()[0] + # this splits on both dots and spaces as the output format differs across versions / platforms + ffmpeg_version_str = str(subprocess.check_output(["ffmpeg", "-version"])) + ffmpeg_version = re.split(r"ffmpeg version |\.| |-", ffmpeg_version_str)[1:3] + ffmpeg_version = ".".join(ffmpeg_version) if StrictVersion(ffmpeg_version) >= StrictVersion('4.3'): print(f'ffmpeg {ffmpeg_version} not supported yet, please use ffmpeg 4.2.') has_ffmpeg = False From 3fa2055b5a4807a8ffc577c53da180382cafd17c Mon Sep 17 00:00:00 2001 From: Vincent Moens Date: Fri, 6 Aug 2021 11:29:21 +0100 Subject: [PATCH 261/279] using `np.random.RandomState(seed)` instead of `np.random.seed(seed)` (#4250) Co-authored-by: Vincent Moens --- test/common_utils.py | 1 - test/test_datasets.py | 3 ++- test/test_image.py | 6 ++++-- test/test_transforms.py | 30 ++++++++++++++++++------------ test/test_transforms_video.py | 3 ++- 5 files changed, 26 insertions(+), 17 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index a8f5a91ef6b..5936ae1f713 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -44,7 +44,6 @@ def get_tmp_dir(src=None, **kwargs): def set_rng_seed(seed): torch.manual_seed(seed) random.seed(seed) - np.random.seed(seed) class MapNestedTensorObjectImpl(object): diff --git a/test/test_datasets.py b/test/test_datasets.py index a8a7f2b0e5c..5b7eabc4cb1 100644 --- a/test/test_datasets.py +++ b/test/test_datasets.py @@ -444,8 +444,9 @@ def inject_fake_data(self, tmpdir, config): ) def _create_batch_file(self, root, name, num_images): + np_rng = np.random.RandomState(0) data = datasets_utils.create_image_or_video_tensor((num_images, 32 * 32 * 3)) - labels = np.random.randint(0, self._VERSION_CONFIG["num_categories"], size=num_images).tolist() + labels = np_rng.randint(0, self._VERSION_CONFIG["num_categories"], size=num_images).tolist() self._create_binary_file(root, name, {"data": data, self._VERSION_CONFIG["labels_key"]: labels}) def _create_meta_file(self, root): diff --git a/test/test_image.py b/test/test_image.py index 2e427af26af..47023a45be2 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -272,9 +272,10 @@ def test_write_file_non_ascii(): (105, 105), ]) def test_read_1_bit_png(shape): + np_rng = np.random.RandomState(0) with get_tmp_dir() as root: image_path = os.path.join(root, f'test_{shape}.png') - pixels = np.random.rand(*shape) > 0.5 + pixels = np_rng.rand(*shape) > 0.5 img = Image.fromarray(pixels) img.save(image_path) img1 = read_image(image_path) @@ -292,9 +293,10 @@ def test_read_1_bit_png(shape): ImageReadMode.GRAY, ]) def test_read_1_bit_png_consistency(shape, mode): + np_rng = np.random.RandomState(0) with get_tmp_dir() as root: image_path = os.path.join(root, f'test_{shape}.png') - pixels = np.random.rand(*shape) > 0.5 + pixels = np_rng.rand(*shape) > 0.5 img = Image.fromarray(pixels) img.save(image_path) img1 = read_image(image_path, mode) diff --git a/test/test_transforms.py b/test/test_transforms.py index 74757bcb4e6..c5cc80ef87e 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -200,18 +200,19 @@ class TestToTensor: def test_to_tensor(self, channels): height, width = 4, 4 trans = transforms.ToTensor() + np_rng = np.random.RandomState(0) input_data = torch.ByteTensor(channels, height, width).random_(0, 255).float().div_(255) img = transforms.ToPILImage()(input_data) output = trans(img) torch.testing.assert_close(output, input_data) - ndarray = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) + ndarray = np_rng.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) output = trans(ndarray) expected_output = ndarray.transpose((2, 0, 1)) / 255.0 torch.testing.assert_close(output.numpy(), expected_output, check_dtype=False) - ndarray = np.random.rand(height, width, channels).astype(np.float32) + ndarray = np_rng.rand(height, width, channels).astype(np.float32) output = trans(ndarray) expected_output = ndarray.transpose((2, 0, 1)) torch.testing.assert_close(output.numpy(), expected_output, check_dtype=False) @@ -225,22 +226,24 @@ def test_to_tensor(self, channels): def test_to_tensor_errors(self): height, width = 4, 4 trans = transforms.ToTensor() + np_rng = np.random.RandomState(0) with pytest.raises(TypeError): - trans(np.random.rand(1, height, width).tolist()) + trans(np_rng.rand(1, height, width).tolist()) with pytest.raises(ValueError): - trans(np.random.rand(height)) + trans(np_rng.rand(height)) with pytest.raises(ValueError): - trans(np.random.rand(1, 1, height, width)) + trans(np_rng.rand(1, 1, height, width)) @pytest.mark.parametrize('dtype', [torch.float16, torch.float, torch.double]) def test_to_tensor_with_other_default_dtypes(self, dtype): + np_rng = np.random.RandomState(0) current_def_dtype = torch.get_default_dtype() t = transforms.ToTensor() - np_arr = np.random.randint(0, 255, (32, 32, 3), dtype=np.uint8) + np_arr = np_rng.randint(0, 255, (32, 32, 3), dtype=np.uint8) img = Image.fromarray(np_arr) torch.set_default_dtype(dtype) @@ -253,19 +256,20 @@ def test_to_tensor_with_other_default_dtypes(self, dtype): def test_pil_to_tensor(self, channels): height, width = 4, 4 trans = transforms.PILToTensor() + np_rng = np.random.RandomState(0) input_data = torch.ByteTensor(channels, height, width).random_(0, 255) img = transforms.ToPILImage()(input_data) output = trans(img) torch.testing.assert_close(input_data, output) - input_data = np.random.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) + input_data = np_rng.randint(low=0, high=255, size=(height, width, channels)).astype(np.uint8) img = transforms.ToPILImage()(input_data) output = trans(img) expected_output = input_data.transpose((2, 0, 1)) torch.testing.assert_close(output.numpy(), expected_output) - input_data = torch.as_tensor(np.random.rand(channels, height, width).astype(np.float32)) + input_data = torch.as_tensor(np_rng.rand(channels, height, width).astype(np.float32)) img = transforms.ToPILImage()(input_data) # CHW -> HWC and (* 255).byte() output = trans(img) # HWC -> CHW expected_output = (input_data * 255).byte() @@ -280,12 +284,13 @@ def test_pil_to_tensor(self, channels): def test_pil_to_tensor_errors(self): height, width = 4, 4 trans = transforms.PILToTensor() + np_rng = np.random.RandomState(0) with pytest.raises(TypeError): - trans(np.random.rand(1, height, width).tolist()) + trans(np_rng.rand(1, height, width).tolist()) with pytest.raises(TypeError): - trans(np.random.rand(1, height, width)) + trans(np_rng.rand(1, height, width)) def test_randomresized_params(): @@ -1180,10 +1185,11 @@ def test_random_grayscale(): """Unit tests for random grayscale transform""" # Test Set 1: RGB -> 3 channel grayscale + np_rng = np.random.RandomState(0) random_state = random.getstate() random.seed(42) x_shape = [2, 2, 3] - x_np = np.random.randint(0, 256, x_shape, np.uint8) + x_np = np_rng.randint(0, 256, x_shape, np.uint8) x_pil = Image.fromarray(x_np, mode='RGB') x_pil_2 = x_pil.convert('L') gray_np = np.array(x_pil_2) @@ -1206,7 +1212,7 @@ def test_random_grayscale(): random_state = random.getstate() random.seed(42) x_shape = [2, 2, 3] - x_np = np.random.randint(0, 256, x_shape, np.uint8) + x_np = np_rng.randint(0, 256, x_shape, np.uint8) x_pil = Image.fromarray(x_np, mode='RGB') x_pil_2 = x_pil.convert('L') gray_np = np.array(x_pil_2) diff --git a/test/test_transforms_video.py b/test/test_transforms_video.py index 1b6b85a29ba..5ae9192c4b6 100644 --- a/test/test_transforms_video.py +++ b/test/test_transforms_video.py @@ -131,7 +131,8 @@ def test_to_tensor_video(self): trans = transforms.ToTensorVideo() with pytest.raises(TypeError): - trans(np.random.rand(numFrames, height, width, 1).tolist()) + np_rng = np.random.RandomState(0) + trans(np_rng.rand(numFrames, height, width, 1).tolist()) trans(torch.rand((numFrames, height, width, 1), dtype=torch.float)) with pytest.raises(ValueError): From 3d9d264198e2167030dc04bf453aeca47daa37db Mon Sep 17 00:00:00 2001 From: Nikita Shulga Date: Fri, 6 Aug 2021 04:49:13 -0700 Subject: [PATCH 262/279] Add CUDA-11.3 builds to torchvision (#4248) * Add CUDA-11.3 builds to torchvision Also mark `.cicrleci/config.yml` as autogenerated in `.gitattributes` * Add CUDA-11.3 install steps for Windows * And here as well --- .circleci/config.yml | 592 ++++++++++++++++++++ .circleci/regenerate.py | 5 +- .gitattributes | 3 + packaging/pkg_helpers.bash | 15 + packaging/windows/internal/cuda_install.bat | 21 + 5 files changed, 634 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 32b4077e93d..03f47e473ce 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1008,6 +1008,12 @@ workflows: name: binary_linux_wheel_py3.6_cu111 python_version: '3.6' wheel_docker_image: pytorch/manylinux-cuda111 + - binary_linux_wheel: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + name: binary_linux_wheel_py3.6_cu113 + python_version: '3.6' + wheel_docker_image: pytorch/manylinux-cuda113 - binary_linux_wheel: cu_version: rocm4.1 name: binary_linux_wheel_py3.6_rocm4.1 @@ -1041,6 +1047,12 @@ workflows: name: binary_linux_wheel_py3.7_cu111 python_version: '3.7' wheel_docker_image: pytorch/manylinux-cuda111 + - binary_linux_wheel: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + name: binary_linux_wheel_py3.7_cu113 + python_version: '3.7' + wheel_docker_image: pytorch/manylinux-cuda113 - binary_linux_wheel: cu_version: rocm4.1 name: binary_linux_wheel_py3.7_rocm4.1 @@ -1069,6 +1081,12 @@ workflows: name: binary_linux_wheel_py3.8_cu111 python_version: '3.8' wheel_docker_image: pytorch/manylinux-cuda111 + - binary_linux_wheel: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + name: binary_linux_wheel_py3.8_cu113 + python_version: '3.8' + wheel_docker_image: pytorch/manylinux-cuda113 - binary_linux_wheel: cu_version: rocm4.1 name: binary_linux_wheel_py3.8_rocm4.1 @@ -1097,6 +1115,12 @@ workflows: name: binary_linux_wheel_py3.9_cu111 python_version: '3.9' wheel_docker_image: pytorch/manylinux-cuda111 + - binary_linux_wheel: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + name: binary_linux_wheel_py3.9_cu113 + python_version: '3.9' + wheel_docker_image: pytorch/manylinux-cuda113 - binary_linux_wheel: cu_version: rocm4.1 name: binary_linux_wheel_py3.9_rocm4.1 @@ -1158,6 +1182,15 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.6_cu111 python_version: '3.6' + - binary_win_wheel: + cu_version: cu113 + filters: + branches: + only: master + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: binary_win_wheel_py3.6_cu113 + python_version: '3.6' - binary_win_wheel: cu_version: cpu filters: @@ -1185,6 +1218,15 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.7_cu111 python_version: '3.7' + - binary_win_wheel: + cu_version: cu113 + filters: + branches: + only: master + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: binary_win_wheel_py3.7_cu113 + python_version: '3.7' - binary_win_wheel: cu_version: cpu filters: @@ -1212,6 +1254,15 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.8_cu111 python_version: '3.8' + - binary_win_wheel: + cu_version: cu113 + filters: + branches: + only: master + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: binary_win_wheel_py3.8_cu113 + python_version: '3.8' - binary_win_wheel: cu_version: cpu name: binary_win_wheel_py3.9_cpu @@ -1227,8 +1278,17 @@ workflows: python_version: '3.9' - binary_win_wheel: cu_version: cu111 + filters: + branches: + only: master + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.9_cu111 python_version: '3.9' + - binary_win_wheel: + cu_version: cu113 + name: binary_win_wheel_py3.9_cu113 + python_version: '3.9' - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1247,6 +1307,12 @@ workflows: name: binary_linux_conda_py3.6_cu111 python_version: '3.6' wheel_docker_image: pytorch/manylinux-cuda111 + - binary_linux_conda: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + name: binary_linux_conda_py3.6_cu113 + python_version: '3.6' + wheel_docker_image: pytorch/manylinux-cuda113 - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1265,6 +1331,12 @@ workflows: name: binary_linux_conda_py3.7_cu111 python_version: '3.7' wheel_docker_image: pytorch/manylinux-cuda111 + - binary_linux_conda: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + name: binary_linux_conda_py3.7_cu113 + python_version: '3.7' + wheel_docker_image: pytorch/manylinux-cuda113 - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1283,6 +1355,12 @@ workflows: name: binary_linux_conda_py3.8_cu111 python_version: '3.8' wheel_docker_image: pytorch/manylinux-cuda111 + - binary_linux_conda: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + name: binary_linux_conda_py3.8_cu113 + python_version: '3.8' + wheel_docker_image: pytorch/manylinux-cuda113 - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1301,6 +1379,12 @@ workflows: name: binary_linux_conda_py3.9_cu111 python_version: '3.9' wheel_docker_image: pytorch/manylinux-cuda111 + - binary_linux_conda: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + name: binary_linux_conda_py3.9_cu113 + python_version: '3.9' + wheel_docker_image: pytorch/manylinux-cuda113 - binary_macos_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -1352,6 +1436,15 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.6_cu111 python_version: '3.6' + - binary_win_conda: + cu_version: cu113 + filters: + branches: + only: master + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: binary_win_conda_py3.6_cu113 + python_version: '3.6' - binary_win_conda: cu_version: cpu filters: @@ -1379,6 +1472,15 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.7_cu111 python_version: '3.7' + - binary_win_conda: + cu_version: cu113 + filters: + branches: + only: master + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: binary_win_conda_py3.7_cu113 + python_version: '3.7' - binary_win_conda: cu_version: cpu filters: @@ -1406,6 +1508,15 @@ workflows: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.8_cu111 python_version: '3.8' + - binary_win_conda: + cu_version: cu113 + filters: + branches: + only: master + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: binary_win_conda_py3.8_cu113 + python_version: '3.8' - binary_win_conda: cu_version: cpu name: binary_win_conda_py3.9_cpu @@ -1421,8 +1532,17 @@ workflows: python_version: '3.9' - binary_win_conda: cu_version: cu111 + filters: + branches: + only: master + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.9_cu111 python_version: '3.9' + - binary_win_conda: + cu_version: cu113 + name: binary_win_conda_py3.9_cu113 + python_version: '3.9' - build_docs: filters: branches: @@ -1741,6 +1861,37 @@ workflows: python_version: '3.6' requires: - nightly_binary_linux_wheel_py3.6_cu111_upload + - binary_linux_wheel: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_wheel_py3.6_cu113 + python_version: '3.6' + wheel_docker_image: pytorch/manylinux-cuda113 + - binary_wheel_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_wheel_py3.6_cu113_upload + requires: + - nightly_binary_linux_wheel_py3.6_cu113 + subfolder: cu113/ + - smoke_test_linux_pip: + filters: + branches: + only: + - nightly + name: nightly_binary_linux_wheel_py3.6_cu113_smoke_test_pip + python_version: '3.6' + requires: + - nightly_binary_linux_wheel_py3.6_cu113_upload - binary_linux_wheel: cu_version: rocm4.1 filters: @@ -1894,6 +2045,37 @@ workflows: python_version: '3.7' requires: - nightly_binary_linux_wheel_py3.7_cu111_upload + - binary_linux_wheel: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_wheel_py3.7_cu113 + python_version: '3.7' + wheel_docker_image: pytorch/manylinux-cuda113 + - binary_wheel_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_wheel_py3.7_cu113_upload + requires: + - nightly_binary_linux_wheel_py3.7_cu113 + subfolder: cu113/ + - smoke_test_linux_pip: + filters: + branches: + only: + - nightly + name: nightly_binary_linux_wheel_py3.7_cu113_smoke_test_pip + python_version: '3.7' + requires: + - nightly_binary_linux_wheel_py3.7_cu113_upload - binary_linux_wheel: cu_version: rocm4.1 filters: @@ -2047,6 +2229,37 @@ workflows: python_version: '3.8' requires: - nightly_binary_linux_wheel_py3.8_cu111_upload + - binary_linux_wheel: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_wheel_py3.8_cu113 + python_version: '3.8' + wheel_docker_image: pytorch/manylinux-cuda113 + - binary_wheel_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_wheel_py3.8_cu113_upload + requires: + - nightly_binary_linux_wheel_py3.8_cu113 + subfolder: cu113/ + - smoke_test_linux_pip: + filters: + branches: + only: + - nightly + name: nightly_binary_linux_wheel_py3.8_cu113_smoke_test_pip + python_version: '3.8' + requires: + - nightly_binary_linux_wheel_py3.8_cu113_upload - binary_linux_wheel: cu_version: rocm4.1 filters: @@ -2200,6 +2413,37 @@ workflows: python_version: '3.9' requires: - nightly_binary_linux_wheel_py3.9_cu111_upload + - binary_linux_wheel: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_wheel_py3.9_cu113 + python_version: '3.9' + wheel_docker_image: pytorch/manylinux-cuda113 + - binary_wheel_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_wheel_py3.9_cu113_upload + requires: + - nightly_binary_linux_wheel_py3.9_cu113 + subfolder: cu113/ + - smoke_test_linux_pip: + filters: + branches: + only: + - nightly + name: nightly_binary_linux_wheel_py3.9_cu113_smoke_test_pip + python_version: '3.9' + requires: + - nightly_binary_linux_wheel_py3.9_cu113_upload - binary_linux_wheel: cu_version: rocm4.1 filters: @@ -2435,6 +2679,35 @@ workflows: python_version: '3.6' requires: - nightly_binary_win_wheel_py3.6_cu111_upload + - binary_win_wheel: + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_wheel_py3.6_cu113 + python_version: '3.6' + - binary_wheel_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_wheel_py3.6_cu113_upload + requires: + - nightly_binary_win_wheel_py3.6_cu113 + subfolder: cu113/ + - smoke_test_win_pip: + filters: + branches: + only: + - nightly + name: nightly_binary_win_wheel_py3.6_cu113_smoke_test_pip + python_version: '3.6' + requires: + - nightly_binary_win_wheel_py3.6_cu113_upload - binary_win_wheel: cu_version: cpu filters: @@ -2522,6 +2795,35 @@ workflows: python_version: '3.7' requires: - nightly_binary_win_wheel_py3.7_cu111_upload + - binary_win_wheel: + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_wheel_py3.7_cu113 + python_version: '3.7' + - binary_wheel_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_wheel_py3.7_cu113_upload + requires: + - nightly_binary_win_wheel_py3.7_cu113 + subfolder: cu113/ + - smoke_test_win_pip: + filters: + branches: + only: + - nightly + name: nightly_binary_win_wheel_py3.7_cu113_smoke_test_pip + python_version: '3.7' + requires: + - nightly_binary_win_wheel_py3.7_cu113_upload - binary_win_wheel: cu_version: cpu filters: @@ -2609,6 +2911,35 @@ workflows: python_version: '3.8' requires: - nightly_binary_win_wheel_py3.8_cu111_upload + - binary_win_wheel: + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_wheel_py3.8_cu113 + python_version: '3.8' + - binary_wheel_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_wheel_py3.8_cu113_upload + requires: + - nightly_binary_win_wheel_py3.8_cu113 + subfolder: cu113/ + - smoke_test_win_pip: + filters: + branches: + only: + - nightly + name: nightly_binary_win_wheel_py3.8_cu113_smoke_test_pip + python_version: '3.8' + requires: + - nightly_binary_win_wheel_py3.8_cu113_upload - binary_win_wheel: cu_version: cpu filters: @@ -2696,6 +3027,35 @@ workflows: python_version: '3.9' requires: - nightly_binary_win_wheel_py3.9_cu111_upload + - binary_win_wheel: + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_wheel_py3.9_cu113 + python_version: '3.9' + - binary_wheel_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_wheel_py3.9_cu113_upload + requires: + - nightly_binary_win_wheel_py3.9_cu113 + subfolder: cu113/ + - smoke_test_win_pip: + filters: + branches: + only: + - nightly + name: nightly_binary_win_wheel_py3.9_cu113_smoke_test_pip + python_version: '3.9' + requires: + - nightly_binary_win_wheel_py3.9_cu113_upload - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -2786,6 +3146,36 @@ workflows: python_version: '3.6' requires: - nightly_binary_linux_conda_py3.6_cu111_upload + - binary_linux_conda: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_conda_py3.6_cu113 + python_version: '3.6' + wheel_docker_image: pytorch/manylinux-cuda113 + - binary_conda_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_conda_py3.6_cu113_upload + requires: + - nightly_binary_linux_conda_py3.6_cu113 + - smoke_test_linux_conda: + filters: + branches: + only: + - nightly + name: nightly_binary_linux_conda_py3.6_cu113_smoke_test_conda + python_version: '3.6' + requires: + - nightly_binary_linux_conda_py3.6_cu113_upload - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -2876,6 +3266,36 @@ workflows: python_version: '3.7' requires: - nightly_binary_linux_conda_py3.7_cu111_upload + - binary_linux_conda: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_conda_py3.7_cu113 + python_version: '3.7' + wheel_docker_image: pytorch/manylinux-cuda113 + - binary_conda_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_conda_py3.7_cu113_upload + requires: + - nightly_binary_linux_conda_py3.7_cu113 + - smoke_test_linux_conda: + filters: + branches: + only: + - nightly + name: nightly_binary_linux_conda_py3.7_cu113_smoke_test_conda + python_version: '3.7' + requires: + - nightly_binary_linux_conda_py3.7_cu113_upload - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -2966,6 +3386,36 @@ workflows: python_version: '3.8' requires: - nightly_binary_linux_conda_py3.8_cu111_upload + - binary_linux_conda: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_conda_py3.8_cu113 + python_version: '3.8' + wheel_docker_image: pytorch/manylinux-cuda113 + - binary_conda_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_conda_py3.8_cu113_upload + requires: + - nightly_binary_linux_conda_py3.8_cu113 + - smoke_test_linux_conda: + filters: + branches: + only: + - nightly + name: nightly_binary_linux_conda_py3.8_cu113_smoke_test_conda + python_version: '3.8' + requires: + - nightly_binary_linux_conda_py3.8_cu113_upload - binary_linux_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -3056,6 +3506,36 @@ workflows: python_version: '3.9' requires: - nightly_binary_linux_conda_py3.9_cu111_upload + - binary_linux_conda: + conda_docker_image: pytorch/conda-builder:cuda113 + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_conda_py3.9_cu113 + python_version: '3.9' + wheel_docker_image: pytorch/manylinux-cuda113 + - binary_conda_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_linux_conda_py3.9_cu113_upload + requires: + - nightly_binary_linux_conda_py3.9_cu113 + - smoke_test_linux_conda: + filters: + branches: + only: + - nightly + name: nightly_binary_linux_conda_py3.9_cu113_smoke_test_conda + python_version: '3.9' + requires: + - nightly_binary_linux_conda_py3.9_cu113_upload - binary_macos_conda: conda_docker_image: pytorch/conda-builder:cpu cu_version: cpu @@ -3224,6 +3704,34 @@ workflows: python_version: '3.6' requires: - nightly_binary_win_conda_py3.6_cu111_upload + - binary_win_conda: + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_conda_py3.6_cu113 + python_version: '3.6' + - binary_conda_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_conda_py3.6_cu113_upload + requires: + - nightly_binary_win_conda_py3.6_cu113 + - smoke_test_win_conda: + filters: + branches: + only: + - nightly + name: nightly_binary_win_conda_py3.6_cu113_smoke_test_conda + python_version: '3.6' + requires: + - nightly_binary_win_conda_py3.6_cu113_upload - binary_win_conda: cu_version: cpu filters: @@ -3308,6 +3816,34 @@ workflows: python_version: '3.7' requires: - nightly_binary_win_conda_py3.7_cu111_upload + - binary_win_conda: + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_conda_py3.7_cu113 + python_version: '3.7' + - binary_conda_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_conda_py3.7_cu113_upload + requires: + - nightly_binary_win_conda_py3.7_cu113 + - smoke_test_win_conda: + filters: + branches: + only: + - nightly + name: nightly_binary_win_conda_py3.7_cu113_smoke_test_conda + python_version: '3.7' + requires: + - nightly_binary_win_conda_py3.7_cu113_upload - binary_win_conda: cu_version: cpu filters: @@ -3392,6 +3928,34 @@ workflows: python_version: '3.8' requires: - nightly_binary_win_conda_py3.8_cu111_upload + - binary_win_conda: + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_conda_py3.8_cu113 + python_version: '3.8' + - binary_conda_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_conda_py3.8_cu113_upload + requires: + - nightly_binary_win_conda_py3.8_cu113 + - smoke_test_win_conda: + filters: + branches: + only: + - nightly + name: nightly_binary_win_conda_py3.8_cu113_smoke_test_conda + python_version: '3.8' + requires: + - nightly_binary_win_conda_py3.8_cu113_upload - binary_win_conda: cu_version: cpu filters: @@ -3476,6 +4040,34 @@ workflows: python_version: '3.9' requires: - nightly_binary_win_conda_py3.9_cu111_upload + - binary_win_conda: + cu_version: cu113 + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_conda_py3.9_cu113 + python_version: '3.9' + - binary_conda_upload: + context: org-member + filters: + branches: + only: nightly + tags: + only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ + name: nightly_binary_win_conda_py3.9_cu113_upload + requires: + - nightly_binary_win_conda_py3.9_cu113 + - smoke_test_win_conda: + filters: + branches: + only: + - nightly + name: nightly_binary_win_conda_py3.9_cu113_smoke_test_conda + python_version: '3.9' + requires: + - nightly_binary_win_conda_py3.9_cu113_upload docker_build: triggers: - schedule: diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py index ce7cf4cedbb..157cabca433 100755 --- a/.circleci/regenerate.py +++ b/.circleci/regenerate.py @@ -30,8 +30,8 @@ def build_workflows(prefix='', filter_branch=None, upload=False, indentation=6, for btype in ["wheel", "conda"]: for os_type in ["linux", "macos", "win"]: python_versions = PYTHON_VERSIONS - cu_versions_dict = {"linux": ["cpu", "cu102", "cu111", "rocm4.1", "rocm4.2"], - "win": ["cpu", "cu102", "cu111"], + cu_versions_dict = {"linux": ["cpu", "cu102", "cu111", "cu113", "rocm4.1", "rocm4.2"], + "win": ["cpu", "cu102", "cu111", "cu113"], "macos": ["cpu"]} cu_versions = cu_versions_dict[os_type] for python_version in python_versions: @@ -115,6 +115,7 @@ def upload_doc_job(filter_branch): "cu110": "pytorch/manylinux-cuda110", "cu111": "pytorch/manylinux-cuda111", "cu112": "pytorch/manylinux-cuda112", + "cu113": "pytorch/manylinux-cuda113", } diff --git a/.gitattributes b/.gitattributes index 22d0452f8d7..f9d672d7fb5 100644 --- a/.gitattributes +++ b/.gitattributes @@ -6,3 +6,6 @@ # To ignore it use below *.ipynb linguist-documentation + +# To exclude autogenerated files from code reviews +.circleci/config.yml linguist-generated=true diff --git a/packaging/pkg_helpers.bash b/packaging/pkg_helpers.bash index ba5ecc99fe2..b0f2bc0580c 100644 --- a/packaging/pkg_helpers.bash +++ b/packaging/pkg_helpers.bash @@ -46,6 +46,15 @@ setup_cuda() { # Now work out the CUDA settings case "$CU_VERSION" in + cu113) + if [[ "$OSTYPE" == "msys" ]]; then + export CUDA_HOME="C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v11.3" + else + export CUDA_HOME=/usr/local/cuda-11.3/ + fi + export FORCE_CUDA=1 + export TORCH_CUDA_ARCH_LIST="3.5;5.0+PTX;6.0;7.0;7.5;8.0;8.6" + ;; cu112) if [[ "$OSTYPE" == "msys" ]]; then export CUDA_HOME="C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v11.2" @@ -283,6 +292,9 @@ setup_conda_cudatoolkit_constraint() { export CONDA_CUDATOOLKIT_CONSTRAINT="" else case "$CU_VERSION" in + cu113) + export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=11.3,<11.4 # [not osx]" + ;; cu112) export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=11.2,<11.3 # [not osx]" ;; @@ -324,6 +336,9 @@ setup_conda_cudatoolkit_plain_constraint() { export CMAKE_USE_CUDA=0 else case "$CU_VERSION" in + cu113) + export CONDA_CUDATOOLKIT_CONSTRAINT="cudatoolkit=11.3" + ;; cu112) export CONDA_CUDATOOLKIT_CONSTRAINT="cudatoolkit=11.2" ;; diff --git a/packaging/windows/internal/cuda_install.bat b/packaging/windows/internal/cuda_install.bat index 9ca08e1cfbb..1ddd6c77340 100644 --- a/packaging/windows/internal/cuda_install.bat +++ b/packaging/windows/internal/cuda_install.bat @@ -21,6 +21,7 @@ if %CUDA_VER% EQU 102 goto cuda102 if %CUDA_VER% EQU 110 goto cuda110 if %CUDA_VER% EQU 111 goto cuda111 if %CUDA_VER% EQU 112 goto cuda112 +if %CUDA_VER% EQU 113 goto cuda113 echo CUDA %CUDA_VERSION_STR% is not supported exit /b 1 @@ -147,6 +148,26 @@ if not exist "%SRC_DIR%\temp_build\cudnn-11.2-windows-x64-v8.1.0.77.zip" ( goto cuda_common +:cuda113 + +set CUDA_INSTALL_EXE=cuda_11.3.0_465.89_win10.exe +if not exist "%SRC_DIR%\temp_build\%CUDA_INSTALL_EXE%" ( + curl -k -L "https://ossci-windows.s3.amazonaws.com/%CUDA_INSTALL_EXE%" --output "%SRC_DIR%\temp_build\%CUDA_INSTALL_EXE%" + if errorlevel 1 exit /b 1 + set "CUDA_SETUP_FILE=%SRC_DIR%\temp_build\%CUDA_INSTALL_EXE%" + set "ARGS=thrust_11.3 nvcc_11.3 cuobjdump_11.3 nvprune_11.3 nvprof_11.3 cupti_11.3 cublas_11.3 cublas_dev_11.3 cudart_11.3 cufft_11.3 cufft_dev_11.3 curand_11.3 curand_dev_11.3 cusolver_11.3 cusolver_dev_11.3 cusparse_11.3 cusparse_dev_11.3 npp_11.3 npp_dev_11.3 nvrtc_11.3 nvrtc_dev_11.3 nvml_dev_11.3" + +) + +set CUDNN_INSTALL_ZIP=cudnn-11.3-windows-x64-v8.2.0.53.zip +if not exist "%SRC_DIR%\temp_build\%CUDNN_INSTALL_ZIP%" ( + curl -k -L "http://s3.amazonaws.com/ossci-windows/%CUDNN_INSTALL_ZIP%" --output "%SRC_DIR%\temp_build\%CUDNN_INSTALL_ZIP%" + if errorlevel 1 exit /b 1 + set "CUDNN_SETUP_FILE=%SRC_DIR%\temp_build\%CUDNN_INSTALL_ZIP%" +) + +goto cuda_common + :cuda_common if not exist "%SRC_DIR%\temp_build\NvToolsExt.7z" ( From 7d52be76c8eaf02b12338afe0822396ab3547fe2 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 9 Aug 2021 10:36:58 +0100 Subject: [PATCH 263/279] kitti docs (#4251) Co-authored-by: Francisco Massa --- torchvision/datasets/kitti.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/torchvision/datasets/kitti.py b/torchvision/datasets/kitti.py index 8db2e45b715..c26a5aee066 100644 --- a/torchvision/datasets/kitti.py +++ b/torchvision/datasets/kitti.py @@ -9,7 +9,9 @@ class Kitti(VisionDataset): - """`KITTI `_ Dataset. + """`KITTI `_ Dataset. + + It corresponds to the "left color images of object" dataset, for object detection. Args: root (string): Root directory where images are downloaded to. From 7de62659332effc3d1848d8b84dbeb6b8cb4ea21 Mon Sep 17 00:00:00 2001 From: David Fan <30608893+jiafatom@users.noreply.github.com> Date: Thu, 12 Aug 2021 00:05:03 -0700 Subject: [PATCH 264/279] Import ONNX utils from symbolic_opset11 module (#4230) --- torchvision/ops/_register_onnx_ops.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/torchvision/ops/_register_onnx_ops.py b/torchvision/ops/_register_onnx_ops.py index 8e8ed331803..e8dd90b4672 100644 --- a/torchvision/ops/_register_onnx_ops.py +++ b/torchvision/ops/_register_onnx_ops.py @@ -8,7 +8,8 @@ def _register_custom_op(): from torch.onnx.symbolic_helper import parse_args, scalar_type_to_onnx, scalar_type_to_pytorch_type, \ cast_pytorch_to_onnx - from torch.onnx.symbolic_opset9 import select, unsqueeze, squeeze, _cast_Long, reshape + from torch.onnx.symbolic_opset9 import _cast_Long + from torch.onnx.symbolic_opset11 import select, squeeze, unsqueeze @parse_args('v', 'v', 'f') def symbolic_multi_label_nms(g, boxes, scores, iou_threshold): From e1f22ed10bad2d37eab35731cc5017fccc2bb608 Mon Sep 17 00:00:00 2001 From: Vincent Moens Date: Thu, 12 Aug 2021 09:14:31 +0100 Subject: [PATCH 265/279] deinterlacing PNG images with read_image (#4268) * interlaced png images Co-authored-by: Vincent Moens --- .../interlaced_png/wizard_low-interlaced.png | Bin 0 -> 175422 bytes test/assets/interlaced_png/wizard_low.png | Bin 0 -> 171554 bytes test/test_image.py | 10 +++++++++ torchvision/csrc/io/image/cpu/decode_png.cpp | 19 ++++++++++++++---- 4 files changed, 25 insertions(+), 4 deletions(-) create mode 100644 test/assets/interlaced_png/wizard_low-interlaced.png create mode 100644 test/assets/interlaced_png/wizard_low.png diff --git a/test/assets/interlaced_png/wizard_low-interlaced.png b/test/assets/interlaced_png/wizard_low-interlaced.png new file mode 100644 index 0000000000000000000000000000000000000000..3badd9264dc77f6f0b3f59cfeb1dd6e5da94b6f4 GIT binary patch literal 175422 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
#GT4rST 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�uw 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%0D3CKy)ZQK9P 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%0Dq7+4ufVA4QueaHKLh4&ldoU}nSe zgQ{xFSE1Uew#mq<+ULW2&~LZoK-m8X&Ix`6=W4s&n?Fx*s(%hxDJz&I&XvjOxzhb5 z^jp_=*JYhPq?VwzrGHZWXb^E(nHk}p+p~-Oa*J_Fnq(HGv|s{fb$MnP)3aX72{ z0O%~|E@Mhshw+Z+Y-Gn6Nw&dOkcZwWE5`An5JTPsQ{km8_u`h>icV8;RS9Pa7*v)o zqjAk35uT?ZiH9ur*C^%Hqu)$8l|mX+G-7aNnEjEM8e6hel=Q}ptFaU&0>RM;3`SFo7mXpZ*HZKWjV33hcAfxRu zjAwFY$)rc@FaPo{Y{gPQECI6w&qqbPQ*b2_`{}`GHpHk#GN)Vx+fnRar5%!SOK2uJ z4@jpxz=3m0kc6w?N25~aIK`yEgAM_zn5aG-!y((Tzu!%7n~;2ayUDTwYQ`xu%>6xo zE^EL1wQjqsxyE7`H)k+(whpr$W=0iyZLvvCbWPd)+ed8Ap)qK589R0cDIVZWVOJ=C zfzy8efW70Re?bzED53&!k!Qz`H%nfv-W$R#DN6{gaFeEL%zh|uWw6v%s}dC5CNWHjR29jAxuOIqO^Qn#f`p%r>IVAox0Ilt#we(N#%J;TuF5R5ryKK6UZ| zq@C5)*}fA%>9)0N-a~9$JhlKrxlU_Js0`2JiK9qog8;qM6sQCM-BMT?l3vtFGi2>Z z5_7n*@m8nj%_3z)%Nne$?Mb9tm=OR{A=0!w^zw;okpfU%kR1SLn&&Gb51yuN(nse5 z^a?^FNncUe6mwbEXcG^M+)@R;%Cw-wkCKYzF8;)mkJ(qh_RmBf+suH*0Eo0-h>A## z5mO90`GAijU%PdTcq6!{^L%ngo`f-?XBRC|9bFhuh#90FsL;nzi3u+(@5|eoFC5HMeIla{0e9s5mZI2BP5P|GDTePT= zFq>64Dv*c?uo2LydVF05-vUn!9=>k?8r+o0lwQ@We3(-n0t- z(wDwyfAs19;$kc79H|m?OIKS2zNM%l6zWpx$ue-+<-j3Ipa58m3DMLlslP0Y8NF+o z6pLnm*MazI^?Ge?cWqCoAjQ9eNh2W=`7BL(qAXFiiZO_lm9{`bBXlJ%SDtQSCS(cz zGYMa{w78M|OX*A-u+n4np{2?VGfO;(B4S1)QEA9CZrQRo({QjLckKlj07qCDhNL

_C>;|5 z96{klzs+E|mt@}Eb-;y#oSl}_L&_QEBE>uhO6h@tcEAX}D*&jB9x1rRa`ITbWIdj0 zxL(719m$s256G0TowVd*1Sgk1St*XRc*#mle*WWjXZZUBwCXE)T$IBvMIO z`p7`1v_yFTq0%80V4xE#q!^(}9OAO#0;{ee6;x54?K?4Q_y6-n%SS~0#H}Uv>;G}H z-MF;^djJv8&W_nL&kft(eSg$;;2zzGPI44g#_(*`hH-bELLyhP%TYjE?^8~51-$<; z*dGEsO`{d$Cc_zZGX%g;; z#zo?EJ_`UMF=Fjjiu5U%4^AS*O<1nN%BX>NJKs>HNLMs8e1@oIcnu*9XEDmfqxFC` zsg2Mv#|oB^eDi${H2VimVb~$mC4qjTL}#lmUqu>tvg85Q6*zuqwmmw01ZKu@rp*2P zmK${%UaVZ8F&q+eViv%{Ea)ul6;RpQJD#=LMK_?AM$G}MB1;^LI9WZUiV#I;lFY@U z#GlBfMlmM#(m+eOHU>X*!OCSP0L%hta`zPorU3P_vKlvVNLRUR`D*){zx{%pKKva5 z#EWKx{*q20-Jql=ZrMv}0XVo?eBqw}l!HBVTeJ{lTtGLQm4t(yJuGJuCu-;0_rLc8 zdunGJOcl7HNJ9B|sO5(xy~AAw_=@l_j3eDjl1_{ft!xOx8#4ldusYx*051zWy8YbKp`kX0MK@w2#5KXP%{ zZmxoZjPcn(A<&r7Ww$T9k8pT0F% zx_|oZ0G$<(N?vFRjH4eO=zY1tx-XkES@G-M1zf5lofEvz0El&r%9HWz_=#hV0VC?A zoGcWqr=zpYKL6Rz+FyV13(PuKxB=%%DhUdAOHi(K{nDe4k0;TeD+Wv))e)sH(QN<# zKmbWZK~z~zU`&Y9u4fVFT%U0QL&@kZAx4t%!( zfhO#}Q}fsh7S*FVq?yO%P zo0>_II)EM!17u3qq^>5y*4jB^ZKw+n{E>uUNwBUOap64GG0{T^RF$$`6sB2b8Ui`F zoXglZOnJlf;o*^too`PtfF^8F7{d?VU!|qfwrFYCnrjF$gM@ytYtsIfM4>m;mRJSA zFR*b_-Wbzfbk%a)P<#kUcFIeqOqpCq+*KWKq|yZ z(i$|STW64x)X2Aj@JK4!;}|;S7^3@djxfFmf4jl@>-?LG>Y^!g?Cqo z&N-oJszN$e1EAG(fML`ShtX+bOheref@NVu`IQIZIAh*K0UnHdj9ZOr(fhFnm5%490PPeRFfnEd?(&^>dLk~XaP7K3hndrj^Nv3K^ zLz?zZ(DCvJo;s> zYOO>Bst?MfedzgpoeDVT7bhWdjd}G%us5h#fobp#7JLUUC|8<*S7j-axawSsD?4|o z7hBgmUbx@CRb30vM*@{w_RbyHD{v61uUiCI;(dzBD*-?J@$dYzee=iPrH$dP&pll3 zL6^Jy{8z3$Nx~MudglzT#r6!U9(jsNGM409LW-m@-jAf>QRtQmP^HHWp3gnHuaf!l zU#GR}K>QLF?;02{OA=2{_c$+J)8W;;%qgfhP{c}C(t$4`O|{}+A&L<+DjY6mFuu_R zokW=j=eQh(L_t=DFo@+c#}Q9J(|IYdLInh~PF_Ho9zt@0;wIx6Y=>$>V@}}wF@_{7 zkQ*C42`l2DRn}1sVL2yKM1+eFteyK414344>9A#^jvy7!^c}@G@;u4SCiEtNn?+JhQ*JT(=-D`LoB>K1S7u;TWO=|0ZqQ1HB!JO` zzkm!VqvJ3Fpw-FN|Dlim63u`&#&e!MdE9zByIfZ05C+pyfJD;#9Ao&@9fuq?>B7A4O=;dL1#g`3Cg(Iw+2=X+R_8Zk$PoN7L9G3S&UR#VrTSg zux1hGUaB_d4xOXAxgEaQxz*SE&vhVvu{Quv1oDSE?l6u4bydpdJ4zsS!tBvuW%(7Q zD~>y}Mp((vvq)M+vBgL@t$+oco=9pl%E*joTtr}<&qxk9EXsx;zqHYj}PPUFA(tO%1$t+mYZ%o^81;k!j%|ZktHSMBG`3TN zVmS=jnf@|+_E^RaogT5TpCh<1Y?u{QajW6}Wcd^~HVdGZm-8-|F@<4Wq)_h9pcs}b zw)D~R#!PdpFi=5?G$pUAZ?I>cJZyjScYjWt<4p`|dahx+h*#bE4V##yR3W_~VI#qN zY1r4N2f7@3P@d{cAK4IsMa&Gpku3|h>&N9l85}4fBbd4Pa&(O=9Uol9f4{K2OZR)> zb;fq>d>VuFa`*hALQY_x*u8tZvk`viBOl=;NzPbfG)20~qHD=07X<8yLzgTg^ni5Q z8bk!ll9HXx2KAwA3}R1=j*=mV3MxT`A+VOZLR2;_PB^&A^2(VQ6$S4wN35*Hn0f!+e zo$0cYiWWv|yzrouDWE(IVYGxzHiFb!itF+;I?9=ue)OMhbmR%LI1|weHbwp{(kT*F zAz2!_+n>QJ>uwiva~hzLBSu~x*&fgvCnwG^onOPifIbZ1pU$g;KTO8wzQY&_E0H9- z0oP`9)F)wah&~1P78D36XgMyrS)MTu{cj|$>%jmR=(eiHCK@|ZI@bO1(SGi;+S*%> zSY`c6u0?{!RFN%jTyA^!A0~MBTXRy4M*wvm$Ln=982r&RHdvoqak^9)Uj#@iT2=uA z#5_jYEX0%U{PAb)AAap`t##E(JNDdZ+qSXBN(pCn{QL;dDmoqv6`n_4cOy{4L}#nT z*<^x2MN%lkjWgnf0jWjhqgN?(BuzBq?4l{pzrV$M||Og8g7DDh}BM%P19lTNO#Lut{#Ir^9T~4h@@A6u>U=O4Cl=){+PL+3swXa z3(pDG^&Nmn@U7DV5MEHkC96(CrCyXrZu|D_cFWD%+)O}HspxszpLonZ`JX>wZ+zq3 z?z|k9UsA^9KXm;-8rHMw9L3#`l&tD;_r!{ey~6BA?NszY&yRdQ}oZ^2riA%69`V7*zv?ty!!>1H-5Bep^SY zfD%PdOgiaw8V|W+goI#}&a`nnKnw+|3Q2X00OqN5uTA6wp13~e<i`0X+}oRkA$NGG6; zAqpLwyr7g}1R>8tJj>GM+bmXEO`UY0uBafZLKBHNNe^`N1V+0h4iwbD7j|R^Cb>rM zx67I?_JWL+04P&TMc-;+3hTiK=>~W1=brnK{pjz%YH$6(W?NS{Y6D|ccCn|x&Rj@P z|5>DT)D8Jq`!SN~1|tkKrSO~;XP^;PK?dXGI82tsWz)8G*)+@)>IHY^6e*6F_+ymA z7zXH zoIpgMV82RG>H4kuQck`n9)HwHyowx1<73ba*^^H^jV}Co`|O{7hTk#_N+scEo%7eY z@|wyHuBq>eN@k=;xY{mNPKr>iVn)c$AW5{pKgByCFc32%@tnos*R@_sO>pI_|72T( zdw!|2uLJRm){q*TKVYD@jTMY!ibtF}K#NP7&JD6a5%;aJ-P!7(MOq2uVW$^+{#VNFpJUbt6io zwMbzDAN0Az6vnxX^GL(QXe;X6G~49#5#!#nY*&v6A-yTVsh9(0wd>J6_X1icnbH>l zU}tc3u0Y6=Pn9GtFSV7B8A6Sg_DY!;IH2bZlY*uMDRh!)yCmZRVkS>>163I6hDT7* z@EnR%Ce^^f14ry_Z-2WJSLhqLP7_pcuG8}+un|giv&>m^sv$|Bl92$3%=7hT_}$o z;SfMkg%C2|35aiMl3kcptHc|Mo}cY@8chLS4x= zAW$u&!{_mS)WN42?84}U8z{KA6nYubwG2h2WaLmh+(A6+Cb+HuUh%2Z*b?OFRSei4 zfVuejFMbkQUJ2zQ4R?3hnKNhXwp;IVRK18S{?v`8&$2gocvBtb8X{}z+0E$77A4 ze$JdZVUK+KoAztJ^&7;{*ueXK`35=}Ib2Hb=XYtpl*tHr-27 znOxu&OLEpbQlKo&zFwhS=ozVCW9XQM{z05jP4mC)&OzjD2 zIYHcmk)cD3ytQ=fGExT}05Geq3SI0hssqJ(2$3Lk8fsVshYkUAL41e~s({udNS|xz z?4wA_14vsK$r9*}2|YQEge!?xnV}PH zv~KW0aW07w4w<$T*FZ5ZVQHLookPCwWgZ$%R=DOq}nymVCNN%@tbtMfK|U-i+1JveQfbN=DvgN0f5Y(r#&ib z{(gdW-%}{t6)y>O#(wuXKdw~mG-{({k*@7za78+5`WdE zf_qx{t?-!we$9X+UF%*1#3e8(MhGV4yiRG0auIhb6ZD1}OtrjBjC_eZ^SgCz-B)mL zFYBZQ2l=6G!G`}6SA)hFJiC6Yjp(mnWO!uEcI@i2ja%xG6i3}l)=L#+3s#?1NeY=0yyZ zL?M734%egKR0iUU{3hBPMnL75D*=Q@NsE-pkdP87U~u59GY%?GUI-UpxzUD63M!#R zQgS#wma^+(+=)G;O?P_tQAvC`IQQ4Y_Q!PedxnhM~si&oWYvpZK<}~ZfdYMZ!EVh%^~7IPcm>~G(<&{=6wrfm6I+F=%>6 z^Nt;&(;`%FZehhaV+23>);`}xa~s{Z-~_+T9pg5sn|lzwVq4E$$RAIuSJ@0$UcayN zg7a0FW>6Yr-9h^4kLMUg_>+O|^y%a7JvR_5V~7x@5om%Pofqx##~!nf{K_w*Qc#8( zAEcdvUe=|BKp4)qf;Dr_}Xl>kMSP9s`bFQY7gOWcNf zf~HSFCo3ngyCkGkrjt$yrEGQ-;~MV6NJnyz&=8yf$Q9EVIgF`O(s|lVO^sl*8DKh< zV7sI%r5X}`*EpWCj~`r)wVo^?h+S!z7b#R4(sf0O@Q|YeD}cKiqEjo-$Q6A`y(El^ zM2SfA2^18=X(SI&nMe+x*Q`b#j9%HL3&LHRm=s~aSd_Ljs*ZwC1p+4$J%*_S!M4Y6 zHYg#rQcT9jPzhdc=*KJTQA;GyPmjSx9<}2gaB{o#yz!XRhE6sTwu{|U#K=fmIi&qX7=G3? zMQznmR2ZmDQlPLBKGmXnz+}mwm`~P|h~2p*YU`JWF@nkg1=m_s3DW6Ch&^0c8-sxo zvx@qtRRG47fO2VhzO7vpviEL{+vcV4QlX+2LFWroxk}HT!YG z(cl`MMtu@x(CsI_a9>w9>WN_tcZ!o-Y(1xU+h70H|4s1xwY+l%K?aEZ`=2An;9|0$ zH1W;>60Q-ny#R3BZ)zlvLxcTnnp=Wx0)t?EAt(gf^sVJ;zdbbRm=}KhIUdY)Hx8)X zkv;&@EbmqUcZLaA^z5!(cFVTgndOn8glAHqr2~X5{rO*buWh^K7Ttn>R=4)b{>)39 zvsQ(USk45eiogd0M0#UTTJf7zCrwRF4y@Iw)HXHfY4LNlS9blY9WAwq$`0!I zYR6q|`*qdCRcgk`#J=6y1^AtMZDB0yef^{zVua76TLCPxXb}5BDuas3WlWJJ`QjZ% zCo4f!5d!?CnbIn-NeW|>Xk{U!)fiIrIJC4RdRyh{DlcvUOpIMOUS zN?Cmso-*c)dvf1IADmAd+r(KKJ^AV?H?s{-GC0a&YbaRHG}71h}2hERd%lgO0El8?e*D)(M};|j79kE0{6 zVEqO(8FHAwz_gg8mqcGLB%4Lk(mEucE(RE>I@DP&tz7+-sz?0JeMA?#=biU5mzcF> zD^|Jl`XT<;)Go5q$4}Tte)ZqGlP^5FXReTSiyLk0TIgK}J5f|EVlZT=>t&0IY{!{V zYa&oj1#uo2g@9rPEMg8c)x@|@a?I6L;rYfpB>IkwM6<*RnT2*%f-X6P^psJy5p>FN zoIpaNLB+;!3@NpzE_Pd8tOVnn<_$=`NZ$F>OIObb>6wa%%iK?=r~K+NT%rj)pGN(& z5;YH8=ImslGvG~!Fqo3=>gRs$gABwlVR-(*flm0f&)CoY?0ZptNcV}6PNVOY7AkI* zdvf)c+kbh7*Y7}}Sh#QDx=vmA+e^H@KyCNe*FES;l8p7ea0!5T!8UieXClOL>;B;n z9&-bWygf%zw<)g4o;^?7KySBw;&*-%5X2=}(|Ad^3yOKUtMm71jw@VRg^CQ;51o#> z%>cyG*&~4PEq$^ibPaHlhV`CAW7E18)#xh)ePis0uXzNjRZ;#h7+R^TjkEUs?TD!cUTM0k1a(YXEqh z7ms8>M^oDR!O?c4YMFx4Fd`ZOU^yjJBkdjsrIcI}l>{sb=_IF+oJRq|;?g?wU1xPi zoF~bw7$=Lf08IzH=FJ?Zgrpei0CJSXPD0MZZC8@F0?M-yl}R;D9=+TLe)p_rGDvT@ zN{Iun-*JB~B zt;F`IC6r}eXbN2}iAK>sD=DiSBovxdl(PtGoJrIOd8kO33RnREEoa9Wo~fujWc5?U zR&!?9h$2lLN(FADnfhd!9Zim$*; zozEY(-}=jcz@xDNV`CDET-^5TCMXlp*6K(rB@agFEf-3$dS_aKHpy+|HVGiL=TaEc zwg3eDcL1c9m7`Nx7J{%ZE132#EO+6$Kkw4NUNRQ26`^XmaQ=*o5pvgEZ=!v{9>MYF z#EB!;)zN0}`nmVm@|CN&?#pLMTzaibf5|p6$$%e$H>_A5>9hnC`UdYdh_t5q3?Zqi z?lfzZ0aUXZuUgSlztr79!&Y7-gYBwfjyPV9^+Vj~aqKMxJ99u$%r zE&*8p_{l7WMAA8>P=mw?6f{g)r((Wc4m;vuL}4dPqH9ZxGaZwTbTVX{mNwZ}|Mvqh zC*ErHwKYiC(gXSm=J9fiBA_7!uUu^>jvYmcUV{1~L&|y5&ch$uz2_aD;(58kSw9~to2^=v%(~RNFZditHmOw?z zmlYztqnKePI)(1IklBdXBm(P90_ll5%BN#aigQh8R)C(&1bR+98z<2(Cx|bxuCB&9 zaAhx~gF~obFp`wT;7R`;BmGhmC!Ezy(&fW8q0vN<(uaG}gzm)Mobo%4AGURGxZU3T zrgyn)9Aah+4D=Cu;c5HOhd#>tAuvC5x)%ds-zI6BszLW>t}=7&6-YtqbGvf~IjM8L z(sTRVPS$mPur5&6$4kTlsQ}R3Nmuw2^bxlUU2;DCWR}5n*RCC?ByQ!ME0)HPUA%A_ zR!ArBw!-fF*?0NFxz=U3b%iUu^d@J#<1qK!JdWPw3~D$3+&Ew%6eUR-P*hxmv6&d( zsLI@Paq;;lf9dPIR!3Y1;>&6}0Aqob7Df4bcK?VqEg}RYOo>7aZ6VkLBMH*Flr+%@ zp(q*gX7Q#|oQG+QU>cQ`VT0fUu7PO2KZ)Kqj6QY@dRhU7yRykRGIw+XDCi&5 zq437b$DO(mbpjWlkqT%=C=W&i@f$L@fmYYAv3&M*wm*k-c7v1PMdwly&M72*1tQAe z`KO>p3ZdE8bqFv+o`-_uv055|ge6tOo3%Z#)Q4MO`?^2zotDXVrC4e^pF-aYtq%Z>K&cvm6;Z$d`B-bG{kQ-5DT~9m9wDk*8G7s8PwyuS z_F8L1cPWl`0fVi8OgeJEc%aqPS^qq6vW->EE40jmq0W&$UJ|h1r~LsiYhBCy@$T0p z+jwjbQf$2v2w!@xJJtW;a#_>?ig5PSQ;#_VY!ojy8RABU2GOGr*oAXv?RS3v_iVKhdhZ@v@=~;(-_lP5C(9NJl)&J1QdJyqFSM*fB|YJW2qeel#nS`r=w! zuDv_D25QJPMzw903#}KJewNviCV?S3MVupATJA%?`m8g?$YphsP?+)QdL%~zs{>e- zguomj5Kut@v3{|cN%|}T3=3f}M50)18NC%aTp=lycPoQybZIG>n~7npxC-5{DC%l9 zqFNYps){f%kk!Td296>vBgLW@g|ud^T|c%Jt3QO)y&SzPhPna_b~Lm|0f{LmIsiuu zRD{qJ@XpRaqmqOVXSu9&8C@4WatP`jP9re}k-ou`Hcaf~DCi}xx-8P{6x_{OVlU(| zb)O_)k%9rqjW|OVYsJs#=sIaDHoOJ>=u&jyNbd|V?|kUPi<|BE$g?vW|`p zJGk$lJ$Uv327)A6e%Eu2wJwf8ZOa;41uZQ0LA1_Oe`c8>!g!)bFW{4(Iz`}~ddws8rw20~ztqa$C^0FS!}FFc;NmV9+FJQ+I&p11${TfbtPx7@+(guwt^^ziVA z%TWA|d*4l6DykkXw;D7Z2n$TPzq#5{O=+12SpR$BUmc^FoZq$(G=ufvI{@e4Se+p! z9<}#Z1i=1Mv^miSW3XD;VG1cYmIM#Q*UZR}jRNq+Y9D!+SFgS=Bhtw$@FEFd%Ka$Fm6XXSv zM*1q^o)g^LaQ{iGBW`jGbx0PclO)n_33=M4kuIhL??1Q$cE6YV5g5A zc2iLi@gnFA8YySZ+Lbmj3CFbJ4YuyKkApZ2io;zN#$`GSjW9cP0uJ>lEI#NpvSh?a z$l8wQN2mq$4QY?6D{N&8`f>uuJkvFVrzG5L460`dMo}1{V`G@2ns`T0)^HA~=A$6` z0suLg6cEee#8I<9`NpqdBrL{|mqxV|wH@1cGjNpHisdWaEWzOj_btkr$5IVhe%NvV zyg;1cVUfWG33M2VxED3jJMVj^8;D;`X*jr_Lg|0q{rfFE4gG^Y#6X~|+ydkv;En(Z0>jhrv<-b@h_{NkQ_FwG4E9}$tf){j!-B;YC(R&J=?a7m) zR=;W-Nit=XWNerv(2j!O6k*WH!nIY@w6fAA1dt(iFl>eyvS%a`q!SY0(z%o+Snkkj z>KRlFg%JFs(FT6w(mUQ|i>hzIh=zm-C`uY0C62K?=|V`s6WLD65TijxJXjAH^`ySg zKT&i_0OK$zjO0Q)AqNvY-^LQ?h0#Oi1KuTMbWVvzXG4^Oo)oo5ajYJYX38cDGg&!e zNa=(PL(Q_-8L*VKVvvxTp%7DRm=QCR#bm6&$cAw*fWmbr?WbokhJw z(_7KsCK;I2)0|Tc=SzJsi`u0S7v_~~HX_}KtBrd!z%66V>62#}z@XDXH+=HZc6

YM~j5<@pW(SL~e#Jjm_2dWpd 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 a_5T4FJF8YS_3;+~0000().data(); - for (png_uint_32 i = 0; i < height; ++i) { - png_read_row(png_ptr, ptr, nullptr); - ptr += width * channels; + for (int pass = 0; pass < number_of_passes; pass++) { + for (png_uint_32 i = 0; i < height; ++i) { + png_read_row(png_ptr, ptr, nullptr); + ptr += width * channels; + } + ptr = tensor.accessor().data(); } png_destroy_read_struct(&png_ptr, &info_ptr, nullptr); return tensor.permute({2, 0, 1}); From d7fa36f221cb2ff670cd4267b83a801cece52522 Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Fri, 13 Aug 2021 14:12:00 +0200 Subject: [PATCH 266/279] lsun docs (#4239) Co-authored-by: Francisco Massa --- torchvision/datasets/lsun.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/torchvision/datasets/lsun.py b/torchvision/datasets/lsun.py index 75b284b597f..592806d30d0 100644 --- a/torchvision/datasets/lsun.py +++ b/torchvision/datasets/lsun.py @@ -55,8 +55,10 @@ def __len__(self) -> int: class LSUN(VisionDataset): - """ - `LSUN `_ dataset. + """`LSUN `_ dataset. + + You will need to install the ``lmdb`` package to use this dataset: run + ``pip install lmdb`` Args: root (string): Root directory for the database files. From db530d8c619a52753f4ce5207af7083162b4228e Mon Sep 17 00:00:00 2001 From: Nicolas Hug Date: Mon, 16 Aug 2021 11:05:02 +0200 Subject: [PATCH 267/279] More robust assertion checks in test_to_tensor_video (#4258) --- test/test_transforms_video.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/test/test_transforms_video.py b/test/test_transforms_video.py index 5ae9192c4b6..975b425f6a5 100644 --- a/test/test_transforms_video.py +++ b/test/test_transforms_video.py @@ -133,12 +133,16 @@ def test_to_tensor_video(self): with pytest.raises(TypeError): np_rng = np.random.RandomState(0) trans(np_rng.rand(numFrames, height, width, 1).tolist()) + with pytest.raises(TypeError): trans(torch.rand((numFrames, height, width, 1), dtype=torch.float)) with pytest.raises(ValueError): trans(torch.ones((3, numFrames, height, width, 3), dtype=torch.uint8)) + with pytest.raises(ValueError): trans(torch.ones((height, width, 3), dtype=torch.uint8)) + with pytest.raises(ValueError): trans(torch.ones((width, 3), dtype=torch.uint8)) + with pytest.raises(ValueError): trans(torch.ones((3), dtype=torch.uint8)) trans.__repr__() From 091cbcdaaf2c342b6d22d319a5e9b5f483ce5949 Mon Sep 17 00:00:00 2001 From: F-G Fernandez Date: Mon, 16 Aug 2021 13:55:39 +0200 Subject: [PATCH 268/279] Added missing typing annotations to transforms/functional_tensor (#4236) * style: Added missing typing annotations * style: Fixed typing * style: Fixed typing * chore: Updated mypy.ini Co-authored-by: Francisco Massa Co-authored-by: Vasilis Vryniotis --- mypy.ini | 10 +++++- torchvision/transforms/functional_tensor.py | 34 ++++++++++----------- 2 files changed, 26 insertions(+), 18 deletions(-) diff --git a/mypy.ini b/mypy.ini index 040b52dfda4..5cfd4056ba0 100644 --- a/mypy.ini +++ b/mypy.ini @@ -28,7 +28,15 @@ ignore_errors = True ignore_errors = True -[mypy-torchvision.transforms.*] +[mypy-torchvision.transforms.functional.*] + +ignore_errors = True + +[mypy-torchvision.transforms.transforms.*] + +ignore_errors = True + +[mypy-torchvision.transforms.autoaugment.*] ignore_errors = True diff --git a/torchvision/transforms/functional_tensor.py b/torchvision/transforms/functional_tensor.py index 5a13bd5d392..3e4069bb0c0 100644 --- a/torchvision/transforms/functional_tensor.py +++ b/torchvision/transforms/functional_tensor.py @@ -11,7 +11,7 @@ def _is_tensor_a_torch_image(x: Tensor) -> bool: return x.ndim >= 2 -def _assert_image_tensor(img): +def _assert_image_tensor(img: Tensor) -> None: if not _is_tensor_a_torch_image(img): raise TypeError("Tensor is not a torch image.") @@ -317,7 +317,7 @@ def _blend(img1: Tensor, img2: Tensor, ratio: float) -> Tensor: return (ratio * img1 + (1.0 - ratio) * img2).clamp(0, bound).to(img1.dtype) -def _rgb2hsv(img): +def _rgb2hsv(img: Tensor) -> Tensor: r, g, b = img.unbind(dim=-3) # Implementation is based on https://github.com/python-pillow/Pillow/blob/4174d4267616897df3746d315d5a2d0f82c656ee/ @@ -356,7 +356,7 @@ def _rgb2hsv(img): return torch.stack((h, s, maxc), dim=-3) -def _hsv2rgb(img): +def _hsv2rgb(img: Tensor) -> Tensor: h, s, v = img.unbind(dim=-3) i = torch.floor(h * 6.0) f = (h * 6.0) - i @@ -388,15 +388,15 @@ def _pad_symmetric(img: Tensor, padding: List[int]) -> Tensor: in_sizes = img.size() - x_indices = [i for i in range(in_sizes[-1])] # [0, 1, 2, 3, ...] + _x_indices = [i for i in range(in_sizes[-1])] # [0, 1, 2, 3, ...] left_indices = [i for i in range(padding[0] - 1, -1, -1)] # e.g. [3, 2, 1, 0] right_indices = [-(i + 1) for i in range(padding[1])] # e.g. [-1, -2, -3] - x_indices = torch.tensor(left_indices + x_indices + right_indices, device=img.device) + x_indices = torch.tensor(left_indices + _x_indices + right_indices, device=img.device) - y_indices = [i for i in range(in_sizes[-2])] + _y_indices = [i for i in range(in_sizes[-2])] top_indices = [i for i in range(padding[2] - 1, -1, -1)] bottom_indices = [-(i + 1) for i in range(padding[3])] - y_indices = torch.tensor(top_indices + y_indices + bottom_indices, device=img.device) + y_indices = torch.tensor(top_indices + _y_indices + bottom_indices, device=img.device) ndim = img.ndim if ndim == 3: @@ -560,13 +560,13 @@ def resize( def _assert_grid_transform_inputs( - img: Tensor, - matrix: Optional[List[float]], - interpolation: str, - fill: Optional[List[float]], - supported_interpolation_modes: List[str], - coeffs: Optional[List[float]] = None, -): + img: Tensor, + matrix: Optional[List[float]], + interpolation: str, + fill: Optional[List[float]], + supported_interpolation_modes: List[str], + coeffs: Optional[List[float]] = None, +) -> None: if not (isinstance(img, torch.Tensor)): raise TypeError("Input img should be Tensor") @@ -612,7 +612,7 @@ def _cast_squeeze_in(img: Tensor, req_dtypes: List[torch.dtype]) -> Tuple[Tensor return img, need_cast, need_squeeze, out_dtype -def _cast_squeeze_out(img: Tensor, need_cast: bool, need_squeeze: bool, out_dtype: torch.dtype): +def _cast_squeeze_out(img: Tensor, need_cast: bool, need_squeeze: bool, out_dtype: torch.dtype) -> Tensor: if need_squeeze: img = img.squeeze(dim=0) @@ -732,7 +732,7 @@ def rotate( return _apply_grid_transform(img, grid, interpolation, fill=fill) -def _perspective_grid(coeffs: List[float], ow: int, oh: int, dtype: torch.dtype, device: torch.device): +def _perspective_grid(coeffs: List[float], ow: int, oh: int, dtype: torch.dtype, device: torch.device) -> Tensor: # https://github.com/python-pillow/Pillow/blob/4634eafe3c695a014267eefdce830b4a825beed7/ # src/libImaging/Geometry.c#L394 @@ -922,7 +922,7 @@ def autocontrast(img: Tensor) -> Tensor: return ((img - minimum) * scale).clamp(0, bound).to(img.dtype) -def _scale_channel(img_chan): +def _scale_channel(img_chan: Tensor) -> Tensor: # TODO: we should expect bincount to always be faster than histc, but this # isn't always the case. Once # https://github.com/pytorch/pytorch/issues/53194 is fixed, remove the if From 38175edbe61440866a8feda62e0eadcb5c7a0b7b Mon Sep 17 00:00:00 2001 From: F-G Fernandez Date: Mon, 16 Aug 2021 16:03:20 +0200 Subject: [PATCH 269/279] Added typing annotations to transforms/autoaugment (#4226) * style: Added typing annotations * style: Fixed typing * style: Fixed typing * Remove unnecessary any. * Update mypy.ini Co-authored-by: Francisco Massa Co-authored-by: Vasilis Vryniotis Co-authored-by: Vasilis Vryniotis --- mypy.ini | 4 ---- torchvision/transforms/autoaugment.py | 22 ++++++++++++++-------- 2 files changed, 14 insertions(+), 12 deletions(-) diff --git a/mypy.ini b/mypy.ini index 5cfd4056ba0..52ddce8ec51 100644 --- a/mypy.ini +++ b/mypy.ini @@ -36,10 +36,6 @@ ignore_errors = True ignore_errors = True -[mypy-torchvision.transforms.autoaugment.*] - -ignore_errors = True - [mypy-PIL.*] ignore_missing_imports = True diff --git a/torchvision/transforms/autoaugment.py b/torchvision/transforms/autoaugment.py index 97522945d2e..3b6c927a4eb 100644 --- a/torchvision/transforms/autoaugment.py +++ b/torchvision/transforms/autoaugment.py @@ -3,7 +3,7 @@ from enum import Enum from torch import Tensor -from typing import List, Tuple, Optional +from typing import List, Tuple, Optional, Dict from . import functional as F, InterpolationMode @@ -19,7 +19,9 @@ class AutoAugmentPolicy(Enum): SVHN = "svhn" -def _get_transforms(policy: AutoAugmentPolicy): +def _get_transforms( # type: ignore[return] + policy: AutoAugmentPolicy +) -> List[Tuple[Tuple[str, float, Optional[int]], Tuple[str, float, Optional[int]]]]: if policy == AutoAugmentPolicy.IMAGENET: return [ (("Posterize", 0.4, 8), ("Rotate", 0.6, 9)), @@ -106,7 +108,7 @@ def _get_transforms(policy: AutoAugmentPolicy): ] -def _get_magnitudes(): +def _get_magnitudes() -> Dict[str, Tuple[Optional[Tensor], Optional[bool]]]: _BINS = 10 return { # name: (magnitudes, signed) @@ -144,8 +146,12 @@ class AutoAugment(torch.nn.Module): image. If given a number, the value is used for all bands respectively. """ - def __init__(self, policy: AutoAugmentPolicy = AutoAugmentPolicy.IMAGENET, - interpolation: InterpolationMode = InterpolationMode.NEAREST, fill: Optional[List[float]] = None): + def __init__( + self, + policy: AutoAugmentPolicy = AutoAugmentPolicy.IMAGENET, + interpolation: InterpolationMode = InterpolationMode.NEAREST, + fill: Optional[List[float]] = None + ) -> None: super().__init__() self.policy = policy self.interpolation = interpolation @@ -163,7 +169,7 @@ def get_params(transform_num: int) -> Tuple[int, Tensor, Tensor]: Returns: params required by the autoaugment transformation """ - policy_id = torch.randint(transform_num, (1,)).item() + policy_id = int(torch.randint(transform_num, (1,)).item()) probs = torch.rand((2,)) signs = torch.randint(2, (2,)) @@ -172,7 +178,7 @@ def get_params(transform_num: int) -> Tuple[int, Tensor, Tensor]: def _get_op_meta(self, name: str) -> Tuple[Optional[Tensor], Optional[bool]]: return self._op_meta[name] - def forward(self, img: Tensor): + def forward(self, img: Tensor) -> Tensor: """ img (PIL Image or Tensor): Image to be transformed. @@ -233,5 +239,5 @@ def forward(self, img: Tensor): return img - def __repr__(self): + def __repr__(self) -> str: return self.__class__.__name__ + '(policy={}, fill={})'.format(self.policy, self.fill) From 8e2bd0e070dbac1011134b0a71e88313a406c2b6 Mon Sep 17 00:00:00 2001 From: Bruno Korbar Date: Mon, 16 Aug 2021 15:42:13 +0100 Subject: [PATCH 270/279] [docs] descriptive comments of the decoder C++ api (#3754) * document video_sampler. * minor docs for decoder.cpp * descriptive comments for the stream.c * descriptive comments for decoder.cpp * per-stream descriptive comments * Fixing CLANG hopefully * addressing prabhat's comments * typo I think Co-authored-by: Francisco Massa Co-authored-by: Vasilis Vryniotis --- torchvision/csrc/io/decoder/audio_stream.cpp | 3 ++ torchvision/csrc/io/decoder/decoder.cpp | 18 +++++++++- torchvision/csrc/io/decoder/stream.cpp | 14 ++++++++ torchvision/csrc/io/decoder/video_sampler.cpp | 34 ++++++++++++++++++- torchvision/csrc/io/decoder/video_stream.cpp | 5 ++- 5 files changed, 71 insertions(+), 3 deletions(-) diff --git a/torchvision/csrc/io/decoder/audio_stream.cpp b/torchvision/csrc/io/decoder/audio_stream.cpp index 3baebab9430..0f6c57e5588 100644 --- a/torchvision/csrc/io/decoder/audio_stream.cpp +++ b/torchvision/csrc/io/decoder/audio_stream.cpp @@ -68,6 +68,7 @@ int AudioStream::initFormat() { : -1; } +// copies audio sample bytes via swr_convert call in audio_sampler.cpp int AudioStream::copyFrameBytes(ByteStorage* out, bool flush) { if (!sampler_) { sampler_ = std::make_unique(codecCtx_); @@ -95,6 +96,8 @@ int AudioStream::copyFrameBytes(ByteStorage* out, bool flush) { << ", channels: " << format_.format.audio.channels << ", format: " << format_.format.audio.format; } + // calls to a sampler that converts the audio samples and copies them to the + // out buffer via ffmpeg::swr_convert return sampler_->sample(flush ? nullptr : frame_, out); } diff --git a/torchvision/csrc/io/decoder/decoder.cpp b/torchvision/csrc/io/decoder/decoder.cpp index a6361ca79ce..f5ad8114899 100644 --- a/torchvision/csrc/io/decoder/decoder.cpp +++ b/torchvision/csrc/io/decoder/decoder.cpp @@ -218,6 +218,12 @@ Decoder::~Decoder() { cleanUp(); } +// Initialise the format context that holds information about the container and +// fill it with minimal information about the format (codecs are not opened +// here). Function reads in information about the streams from the container +// into inputCtx and then passes it to decoder::openStreams. Finally, if seek is +// specified within the decoder parameters, it seeks into the correct frame +// (note, the seek defined here is "precise" seek). bool Decoder::init( const DecoderParameters& params, DecoderInCallback&& in, @@ -384,7 +390,7 @@ bool Decoder::init( cleanUp(); return false; } - + // SyncDecoder inherits Decoder which would override onInit. onInit(); if (params.startOffset != 0) { @@ -399,6 +405,8 @@ bool Decoder::init( return true; } +// open appropriate CODEC for every type of stream and move it to the class +// variable `streams_` and make sure it is in range for decoding bool Decoder::openStreams(std::vector* metadata) { for (unsigned int i = 0; i < inputCtx_->nb_streams; i++) { // - find the corespondent format at params_.formats set @@ -485,6 +493,10 @@ void Decoder::cleanUp() { seekableBuffer_.shutdown(); } +// function does actual work, derived class calls it in working thread +// periodically. On success method returns 0, ENODATA on EOF, ETIMEDOUT if +// no frames got decoded in the specified timeout time, and error on +// unrecoverable error. int Decoder::getFrame(size_t workingTimeInMs) { if (inRange_.none()) { return ENODATA; @@ -601,11 +613,13 @@ int Decoder::getFrame(size_t workingTimeInMs) { return 0; } +// find stream by stream index Stream* Decoder::findByIndex(int streamIndex) const { auto it = streams_.find(streamIndex); return it != streams_.end() ? it->second.get() : nullptr; } +// find stream by type; note finds only the first stream of a given type Stream* Decoder::findByType(const MediaFormat& format) const { for (auto& stream : streams_) { if (stream.second->getMediaFormat().type == format.type) { @@ -615,6 +629,8 @@ Stream* Decoder::findByType(const MediaFormat& format) const { return nullptr; } +// given the stream and packet, decode the frame buffers into the +// DecoderOutputMessage data structure via stream::decodePacket function. int Decoder::processPacket( Stream* stream, AVPacket* packet, diff --git a/torchvision/csrc/io/decoder/stream.cpp b/torchvision/csrc/io/decoder/stream.cpp index 37dd5805d5a..275275c9701 100644 --- a/torchvision/csrc/io/decoder/stream.cpp +++ b/torchvision/csrc/io/decoder/stream.cpp @@ -24,10 +24,15 @@ Stream::~Stream() { } } +// look up the proper CODEC querying the function AVCodec* Stream::findCodec(AVCodecParameters* params) { return avcodec_find_decoder(params->codec_id); } +// Allocate memory for the AVCodecContext, which will hold the context for +// decode/encode process. Then fill this codec context with CODEC parameters +// defined in stream parameters. Open the codec, and allocate the global frame +// defined in the header file int Stream::openCodec(std::vector* metadata) { AVStream* steam = inputCtx_->streams[format_.stream]; @@ -93,6 +98,9 @@ int Stream::openCodec(std::vector* metadata) { return ret; } +// send the raw data packet (compressed frame) to the decoder, through the codec +// context and receive the raw data frame (uncompressed frame) from the +// decoder, through the same codec context int Stream::analyzePacket(const AVPacket* packet, bool* gotFrame) { int consumed = 0; int result = avcodec_send_packet(codecCtx_, packet); @@ -134,6 +142,9 @@ int Stream::analyzePacket(const AVPacket* packet, bool* gotFrame) { return consumed; } +// General decoding function: +// given the packet, analyse the metadata, and write the +// metadata and the buffer to the DecoderOutputImage. int Stream::decodePacket( const AVPacket* packet, DecoderOutputMessage* out, @@ -167,6 +178,9 @@ int Stream::flush(DecoderOutputMessage* out, bool headerOnly) { return 1; } +// Sets the header and payload via stream::setHeader and copyFrameBytes +// functions that are defined in type stream subclass (VideoStream, AudioStream, +// ...) int Stream::getMessage(DecoderOutputMessage* out, bool flush, bool headerOnly) { if (flush) { // only flush of audio frames makes sense diff --git a/torchvision/csrc/io/decoder/video_sampler.cpp b/torchvision/csrc/io/decoder/video_sampler.cpp index 5b9726b7c6c..7816d70b706 100644 --- a/torchvision/csrc/io/decoder/video_sampler.cpp +++ b/torchvision/csrc/io/decoder/video_sampler.cpp @@ -7,6 +7,17 @@ namespace ffmpeg { namespace { + +// Setup the data pointers and linesizes based on the specified image +// parameters and the provided array. This sets up "planes" to point to a +// "buffer" +// NOTE: this is most likely culprit behind #3534 +// +// Args: +// fmt: desired output video format +// buffer: source constant image buffer (in different format) that will contain +// the final image after SWScale planes: destination data pointer to be filled +// lineSize: target destination linesize (always {0}) int preparePlanes( const VideoFormat& fmt, const uint8_t* buffer, @@ -14,6 +25,7 @@ int preparePlanes( int* lineSize) { int result; + // NOTE: 1 at the end of av_fill_arrays is the value used for alignment if ((result = av_image_fill_arrays( planes, lineSize, @@ -28,6 +40,18 @@ int preparePlanes( return result; } +// Scale (and crop) the image slice in srcSlice and put the resulting scaled +// slice to `planes` buffer, which is mapped to be `out` via preparePlanes as +// `sws_scale` cannot access buffers directly. +// +// Args: +// context: SWSContext allocated on line 119 (if crop, optional) or 163 (if +// scale) srcSlice: frame data in YUV420P srcStride: the array containing the +// strides for each plane of the source +// image (from AVFrame->linesize[0]) +// out: destination buffer +// planes: indirect destination buffer (mapped to "out" via preparePlanes) +// lines: destination linesize; constant {0} int transformImage( SwsContext* context, const uint8_t* const srcSlice[], @@ -41,7 +65,7 @@ int transformImage( if ((result = preparePlanes(outFormat, out, planes, lines)) < 0) { return result; } - + // NOTE: srcY stride always 0: this is a parameter of YUV format if ((result = sws_scale( context, srcSlice, srcStride, 0, inFormat.height, planes, lines)) < 0) { @@ -153,6 +177,12 @@ bool VideoSampler::init(const SamplerParameters& params) { return scaleContext_ != nullptr; } +// Main body of the sample function called from one of the overloads below +// +// Args: +// srcSlice: decoded AVFrame->data perpared buffer +// srcStride: linesize (usually obtained from AVFrame->linesize) +// out: return buffer (ByteStorage*) int VideoSampler::sample( const uint8_t* const srcSlice[], int srcStride[], @@ -221,6 +251,7 @@ int VideoSampler::sample( return outImageSize; } +// Call from `video_stream.cpp::114` - occurs during file reads int VideoSampler::sample(AVFrame* frame, ByteStorage* out) { if (!frame) { return 0; // no flush for videos @@ -229,6 +260,7 @@ int VideoSampler::sample(AVFrame* frame, ByteStorage* out) { return sample(frame->data, frame->linesize, out); } +// Call from `video_stream.cpp::114` - not sure when this occurs int VideoSampler::sample(const ByteStorage* in, ByteStorage* out) { if (!in) { return 0; // no flush for videos diff --git a/torchvision/csrc/io/decoder/video_stream.cpp b/torchvision/csrc/io/decoder/video_stream.cpp index 79e4a2dc399..fa08c65cac1 100644 --- a/torchvision/csrc/io/decoder/video_stream.cpp +++ b/torchvision/csrc/io/decoder/video_stream.cpp @@ -82,6 +82,7 @@ int VideoStream::initFormat() { : -1; } +// copies frame bytes via sws_scale call in video_sampler.cpp int VideoStream::copyFrameBytes(ByteStorage* out, bool flush) { if (!sampler_) { sampler_ = std::make_unique(SWS_AREA, loggingUuid_); @@ -112,7 +113,9 @@ int VideoStream::copyFrameBytes(ByteStorage* out, bool flush) { << ", minDimension: " << format_.format.video.minDimension << ", crop: " << format_.format.video.cropImage; } - + // calls to a sampler that converts the frame from YUV422 to RGB24, and + // optionally crops and resizes the frame. Frame bytes are copied from + // frame_->data to out buffer return sampler_->sample(flush ? nullptr : frame_, out); } From ddd14ffc0a83a8f1ab8dbe6379c2f383e54be18e Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 17 Aug 2021 17:16:38 +0100 Subject: [PATCH 271/279] Don't download backbone weights if pretrained=True (#4283) --- torchvision/models/segmentation/segmentation.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/torchvision/models/segmentation/segmentation.py b/torchvision/models/segmentation/segmentation.py index 7b3a0258ddb..0f2f14c97ba 100644 --- a/torchvision/models/segmentation/segmentation.py +++ b/torchvision/models/segmentation/segmentation.py @@ -186,6 +186,8 @@ def lraspp_mobilenet_v3_large(pretrained=False, progress=True, num_classes=21, * raise NotImplementedError('This model does not use auxiliary loss') backbone_name = 'mobilenet_v3_large' + if pretrained: + kwargs["pretrained_backbone"] = False model = _segm_lraspp_mobilenetv3(backbone_name, num_classes, **kwargs) if pretrained: From af16236dc275b524a9b46b84567490afab25cc61 Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Tue, 17 Aug 2021 18:00:25 +0100 Subject: [PATCH 272/279] Skip test if connection issues on fate (#4284) * Skip the test if the failure is due to a connection error. * Add todo. --- test/test_videoapi.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/test/test_videoapi.py b/test/test_videoapi.py index c6ae32232d3..734620e8f74 100644 --- a/test/test_videoapi.py +++ b/test/test_videoapi.py @@ -2,6 +2,7 @@ import os import pytest from pytest import approx +import urllib import torch import torchvision @@ -177,7 +178,11 @@ def test_accurateseek_middle(self): assert (lb <= frame["pts"]) and (ub >= frame["pts"]) def test_fate_suite(self): - video_path = fate("sub/MovText_capability_tester.mp4", VIDEO_DIR) + # TODO: remove the try-except statement once the connectivity issues are resolved + try: + video_path = fate("sub/MovText_capability_tester.mp4", VIDEO_DIR) + except (urllib.error.URLError, ConnectionError) as error: + pytest.skip(f"Skipping due to connectivity issues: {error}") vr = VideoReader(video_path) metadata = vr.get_metadata() From f3aff2fa60c110c25df671b6f99ffb26727cb8ae Mon Sep 17 00:00:00 2001 From: Jithun Nair <37884920+jithunnair-amd@users.noreply.github.com> Date: Tue, 17 Aug 2021 12:01:38 -0500 Subject: [PATCH 273/279] Make torch version check numeric (#4285) Co-authored-by: Vasilis Vryniotis --- setup.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 60fd4ac3e0b..70570b0935c 100644 --- a/setup.py +++ b/setup.py @@ -147,7 +147,9 @@ def get_extensions(): ) is_rocm_pytorch = False - if torch.__version__ >= '1.5': + TORCH_MAJOR = int(torch.__version__.split('.')[0]) + TORCH_MINOR = int(torch.__version__.split('.')[1]) + if TORCH_MAJOR > 1 or (TORCH_MAJOR == 1 and TORCH_MINOR >= 5): from torch.utils.cpp_extension import ROCM_HOME is_rocm_pytorch = True if ((torch.version.hip is not None) and (ROCM_HOME is not None)) else False From 98cb4ead4a40b4e60cce8981049ec8ce76ca3899 Mon Sep 17 00:00:00 2001 From: Alex Lin <75946753+ccongge@users.noreply.github.com> Date: Wed, 18 Aug 2021 09:09:12 +0100 Subject: [PATCH 274/279] Replace get_tmp_dir() with tmpdir fixture in tests (#4280) * Replace in test_datasets* * Replace in test_image.py * Replace in test_transforms_tensor.py * Replace in test_internet.py and test_io.py * get_list_of_videos is util function still use get_tmp_dir * Fix get_list_of_videos siginiture * Add get_tmp_dir import * Modify test_datasets_video_utils.py for test to pass * Fix indentation * Replace get_tmp_dir in util functions in test_dataset_sampler.py * Replace get_tmp_dir in util functions in test_dataset_video_utils.py * Move get_tmp_dir() to datasets_utils.py and refactor * Fix pylint, indentation and imports * import shutil to common_util.py * Fix function signiture * Remove get_list_of_videos under context manager * Move get_list_of_videos to common_utils.py * Move get_tmp_dir() back to common_utils.py * Fix pylint and imports Co-authored-by: Nicolas Hug --- test/common_utils.py | 20 ++++ test/test_datasets_download.py | 19 ++- test/test_datasets_samplers.py | 155 +++++++++++------------- test/test_datasets_utils.py | 49 ++++---- test/test_datasets_video_utils.py | 87 ++++++-------- test/test_image.py | 191 ++++++++++++++---------------- test/test_internet.py | 53 ++++----- test/test_io.py | 57 +++++---- test/test_transforms_tensor.py | 60 ++++------ 9 files changed, 317 insertions(+), 374 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index 5936ae1f713..79fce27110d 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -15,6 +15,7 @@ from numbers import Number from torch._six import string_classes from collections import OrderedDict +from torchvision import io import numpy as np from PIL import Image @@ -147,6 +148,25 @@ def _create_data_batch(height=3, width=3, channels=3, num_samples=4, device="cpu assert_equal = functools.partial(torch.testing.assert_close, rtol=0, atol=0) +def get_list_of_videos(tmpdir, num_videos=5, sizes=None, fps=None): + names = [] + for i in range(num_videos): + if sizes is None: + size = 5 * (i + 1) + else: + size = sizes[i] + if fps is None: + f = 5 + else: + f = fps[i] + data = torch.randint(0, 256, (size, 300, 400, 3), dtype=torch.uint8) + name = os.path.join(tmpdir, "{}.mp4".format(i)) + names.append(name) + io.write_video(name, data, fps=f) + + return names + + def _assert_equal_tensor_to_pil(tensor, pil_image, msg=None): np_pil_image = np.array(pil_image) if np_pil_image.ndim == 2: diff --git a/test/test_datasets_download.py b/test/test_datasets_download.py index 8c2d575e01d..0cf86918575 100644 --- a/test/test_datasets_download.py +++ b/test/test_datasets_download.py @@ -22,8 +22,6 @@ USER_AGENT, ) -from common_utils import get_tmp_dir - def limit_requests_per_time(min_secs_between_requests=2.0): last_requests = {} @@ -166,16 +164,15 @@ def assert_url_is_accessible(url, timeout=5.0): urlopen(request, timeout=timeout) -def assert_file_downloads_correctly(url, md5, timeout=5.0): - with get_tmp_dir() as root: - file = path.join(root, path.basename(url)) - with assert_server_response_ok(): - with open(file, "wb") as fh: - request = Request(url, headers={"User-Agent": USER_AGENT}) - response = urlopen(request, timeout=timeout) - fh.write(response.read()) +def assert_file_downloads_correctly(url, md5, tmpdir, timeout=5.0): + file = path.join(tmpdir, path.basename(url)) + with assert_server_response_ok(): + with open(file, "wb") as fh: + request = Request(url, headers={"User-Agent": USER_AGENT}) + response = urlopen(request, timeout=timeout) + fh.write(response.read()) - assert check_integrity(file, md5=md5), "The MD5 checksums mismatch" + assert check_integrity(file, md5=md5), "The MD5 checksums mismatch" class DownloadConfig: diff --git a/test/test_datasets_samplers.py b/test/test_datasets_samplers.py index 7754c1a98e8..c76fd1849fc 100644 --- a/test/test_datasets_samplers.py +++ b/test/test_datasets_samplers.py @@ -13,104 +13,83 @@ from torchvision.datasets.video_utils import VideoClips, unfold from torchvision import get_video_backend -from common_utils import get_tmp_dir, assert_equal - - -@contextlib.contextmanager -def get_list_of_videos(num_videos=5, sizes=None, fps=None): - with get_tmp_dir() as tmp_dir: - names = [] - for i in range(num_videos): - if sizes is None: - size = 5 * (i + 1) - else: - size = sizes[i] - if fps is None: - f = 5 - else: - f = fps[i] - data = torch.randint(0, 256, (size, 300, 400, 3), dtype=torch.uint8) - name = os.path.join(tmp_dir, "{}.mp4".format(i)) - names.append(name) - io.write_video(name, data, fps=f) - - yield names +from common_utils import get_list_of_videos, assert_equal @pytest.mark.skipif(not io.video._av_available(), reason="this test requires av") class TestDatasetsSamplers: - def test_random_clip_sampler(self): - with get_list_of_videos(num_videos=3, sizes=[25, 25, 25]) as video_list: - video_clips = VideoClips(video_list, 5, 5) - sampler = RandomClipSampler(video_clips, 3) - assert len(sampler) == 3 * 3 - indices = torch.tensor(list(iter(sampler))) - videos = torch.div(indices, 5, rounding_mode='floor') - v_idxs, count = torch.unique(videos, return_counts=True) - assert_equal(v_idxs, torch.tensor([0, 1, 2])) - assert_equal(count, torch.tensor([3, 3, 3])) + def test_random_clip_sampler(self, tmpdir): + video_list = get_list_of_videos(tmpdir, num_videos=3, sizes=[25, 25, 25]) + video_clips = VideoClips(video_list, 5, 5) + sampler = RandomClipSampler(video_clips, 3) + assert len(sampler) == 3 * 3 + indices = torch.tensor(list(iter(sampler))) + videos = torch.div(indices, 5, rounding_mode='floor') + v_idxs, count = torch.unique(videos, return_counts=True) + assert_equal(v_idxs, torch.tensor([0, 1, 2])) + assert_equal(count, torch.tensor([3, 3, 3])) - def test_random_clip_sampler_unequal(self): - with get_list_of_videos(num_videos=3, sizes=[10, 25, 25]) as video_list: - video_clips = VideoClips(video_list, 5, 5) - sampler = RandomClipSampler(video_clips, 3) - assert len(sampler) == 2 + 3 + 3 - indices = list(iter(sampler)) - assert 0 in indices - assert 1 in indices - # remove elements of the first video, to simplify testing - indices.remove(0) - indices.remove(1) - indices = torch.tensor(indices) - 2 - videos = torch.div(indices, 5, rounding_mode='floor') - v_idxs, count = torch.unique(videos, return_counts=True) - assert_equal(v_idxs, torch.tensor([0, 1])) - assert_equal(count, torch.tensor([3, 3])) + def test_random_clip_sampler_unequal(self, tmpdir): + video_list = get_list_of_videos(tmpdir, num_videos=3, sizes=[10, 25, 25]) + video_clips = VideoClips(video_list, 5, 5) + sampler = RandomClipSampler(video_clips, 3) + assert len(sampler) == 2 + 3 + 3 + indices = list(iter(sampler)) + assert 0 in indices + assert 1 in indices + # remove elements of the first video, to simplify testing + indices.remove(0) + indices.remove(1) + indices = torch.tensor(indices) - 2 + videos = torch.div(indices, 5, rounding_mode='floor') + v_idxs, count = torch.unique(videos, return_counts=True) + assert_equal(v_idxs, torch.tensor([0, 1])) + assert_equal(count, torch.tensor([3, 3])) - def test_uniform_clip_sampler(self): - with get_list_of_videos(num_videos=3, sizes=[25, 25, 25]) as video_list: - video_clips = VideoClips(video_list, 5, 5) - sampler = UniformClipSampler(video_clips, 3) - assert len(sampler) == 3 * 3 - indices = torch.tensor(list(iter(sampler))) - videos = torch.div(indices, 5, rounding_mode='floor') - v_idxs, count = torch.unique(videos, return_counts=True) - assert_equal(v_idxs, torch.tensor([0, 1, 2])) - assert_equal(count, torch.tensor([3, 3, 3])) - assert_equal(indices, torch.tensor([0, 2, 4, 5, 7, 9, 10, 12, 14])) + def test_uniform_clip_sampler(self, tmpdir): + video_list = get_list_of_videos(tmpdir, num_videos=3, sizes=[25, 25, 25]) + video_clips = VideoClips(video_list, 5, 5) + sampler = UniformClipSampler(video_clips, 3) + assert len(sampler) == 3 * 3 + indices = torch.tensor(list(iter(sampler))) + videos = torch.div(indices, 5, rounding_mode='floor') + v_idxs, count = torch.unique(videos, return_counts=True) + assert_equal(v_idxs, torch.tensor([0, 1, 2])) + assert_equal(count, torch.tensor([3, 3, 3])) + assert_equal(indices, torch.tensor([0, 2, 4, 5, 7, 9, 10, 12, 14])) - def test_uniform_clip_sampler_insufficient_clips(self): - with get_list_of_videos(num_videos=3, sizes=[10, 25, 25]) as video_list: - video_clips = VideoClips(video_list, 5, 5) - sampler = UniformClipSampler(video_clips, 3) - assert len(sampler) == 3 * 3 - indices = torch.tensor(list(iter(sampler))) - assert_equal(indices, torch.tensor([0, 0, 1, 2, 4, 6, 7, 9, 11])) + def test_uniform_clip_sampler_insufficient_clips(self, tmpdir): + video_list = get_list_of_videos(tmpdir, num_videos=3, sizes=[10, 25, 25]) + video_clips = VideoClips(video_list, 5, 5) + sampler = UniformClipSampler(video_clips, 3) + assert len(sampler) == 3 * 3 + indices = torch.tensor(list(iter(sampler))) + assert_equal(indices, torch.tensor([0, 0, 1, 2, 4, 6, 7, 9, 11])) - def test_distributed_sampler_and_uniform_clip_sampler(self): - with get_list_of_videos(num_videos=3, sizes=[25, 25, 25]) as video_list: - video_clips = VideoClips(video_list, 5, 5) - clip_sampler = UniformClipSampler(video_clips, 3) + def test_distributed_sampler_and_uniform_clip_sampler(self, tmpdir): + video_list = get_list_of_videos(tmpdir, num_videos=3, sizes=[25, 25, 25]) + video_clips = VideoClips(video_list, 5, 5) + clip_sampler = UniformClipSampler(video_clips, 3) - distributed_sampler_rank0 = DistributedSampler( - clip_sampler, - num_replicas=2, - rank=0, - group_size=3, - ) - indices = torch.tensor(list(iter(distributed_sampler_rank0))) - assert len(distributed_sampler_rank0) == 6 - assert_equal(indices, torch.tensor([0, 2, 4, 10, 12, 14])) + distributed_sampler_rank0 = DistributedSampler( + clip_sampler, + num_replicas=2, + rank=0, + group_size=3, + ) + indices = torch.tensor(list(iter(distributed_sampler_rank0))) + assert len(distributed_sampler_rank0) == 6 + assert_equal(indices, torch.tensor([0, 2, 4, 10, 12, 14])) - distributed_sampler_rank1 = DistributedSampler( - clip_sampler, - num_replicas=2, - rank=1, - group_size=3, - ) - indices = torch.tensor(list(iter(distributed_sampler_rank1))) - assert len(distributed_sampler_rank1) == 6 - assert_equal(indices, torch.tensor([5, 7, 9, 0, 2, 4])) + distributed_sampler_rank1 = DistributedSampler( + clip_sampler, + num_replicas=2, + rank=1, + group_size=3, + ) + indices = torch.tensor(list(iter(distributed_sampler_rank1))) + assert len(distributed_sampler_rank1) == 6 + assert_equal(indices, torch.tensor([5, 7, 9, 0, 2, 4])) if __name__ == '__main__': diff --git a/test/test_datasets_utils.py b/test/test_datasets_utils.py index 0c2dc5260de..3d147608a59 100644 --- a/test/test_datasets_utils.py +++ b/test/test_datasets_utils.py @@ -12,7 +12,6 @@ import lzma import contextlib -from common_utils import get_tmp_dir from torchvision.datasets.utils import _COMPRESSED_FILE_OPENERS @@ -113,7 +112,7 @@ def test_detect_file_type_incompatible(self, file): utils._detect_file_type(file) @pytest.mark.parametrize('extension', [".bz2", ".gz", ".xz"]) - def test_decompress(self, extension): + def test_decompress(self, extension, tmpdir): def create_compressed(root, content="this is the content"): file = os.path.join(root, "file") compressed = f"{file}{extension}" @@ -124,21 +123,20 @@ def create_compressed(root, content="this is the content"): return compressed, file, content - with get_tmp_dir() as temp_dir: - compressed, file, content = create_compressed(temp_dir) + compressed, file, content = create_compressed(tmpdir) - utils._decompress(compressed) + utils._decompress(compressed) - assert os.path.exists(file) + assert os.path.exists(file) - with open(file, "r") as fh: - assert fh.read() == content + with open(file, "r") as fh: + assert fh.read() == content def test_decompress_no_compression(self): with pytest.raises(RuntimeError): utils._decompress("foo.tar") - def test_decompress_remove_finished(self): + def test_decompress_remove_finished(self, tmpdir): def create_compressed(root, content="this is the content"): file = os.path.join(root, "file") compressed = f"{file}.gz" @@ -148,12 +146,11 @@ def create_compressed(root, content="this is the content"): return compressed, file, content - with get_tmp_dir() as temp_dir: - compressed, file, content = create_compressed(temp_dir) + compressed, file, content = create_compressed(tmpdir) - utils.extract_archive(compressed, temp_dir, remove_finished=True) + utils.extract_archive(compressed, tmpdir, remove_finished=True) - assert not os.path.exists(compressed) + assert not os.path.exists(compressed) @pytest.mark.parametrize('extension', [".gz", ".xz"]) @pytest.mark.parametrize('remove_finished', [True, False]) @@ -166,7 +163,7 @@ def test_extract_archive_defer_to_decompress(self, extension, remove_finished, m mocked.assert_called_once_with(file, filename, remove_finished=remove_finished) - def test_extract_zip(self): + def test_extract_zip(self, tmpdir): def create_archive(root, content="this is the content"): file = os.path.join(root, "dst.txt") archive = os.path.join(root, "archive.zip") @@ -176,19 +173,18 @@ def create_archive(root, content="this is the content"): return archive, file, content - with get_tmp_dir() as temp_dir: - archive, file, content = create_archive(temp_dir) + archive, file, content = create_archive(tmpdir) - utils.extract_archive(archive, temp_dir) + utils.extract_archive(archive, tmpdir) - assert os.path.exists(file) + assert os.path.exists(file) - with open(file, "r") as fh: - assert fh.read() == content + with open(file, "r") as fh: + assert fh.read() == content @pytest.mark.parametrize('extension, mode', [ ('.tar', 'w'), ('.tar.gz', 'w:gz'), ('.tgz', 'w:gz'), ('.tar.xz', 'w:xz')]) - def test_extract_tar(self, extension, mode): + def test_extract_tar(self, extension, mode, tmpdir): def create_archive(root, extension, mode, content="this is the content"): src = os.path.join(root, "src.txt") dst = os.path.join(root, "dst.txt") @@ -202,15 +198,14 @@ def create_archive(root, extension, mode, content="this is the content"): return archive, dst, content - with get_tmp_dir() as temp_dir: - archive, file, content = create_archive(temp_dir, extension, mode) + archive, file, content = create_archive(tmpdir, extension, mode) - utils.extract_archive(archive, temp_dir) + utils.extract_archive(archive, tmpdir) - assert os.path.exists(file) + assert os.path.exists(file) - with open(file, "r") as fh: - assert fh.read() == content + with open(file, "r") as fh: + assert fh.read() == content def test_verify_str_arg(self): assert "a" == utils.verify_str_arg("a", "arg", ("a",)) diff --git a/test/test_datasets_video_utils.py b/test/test_datasets_video_utils.py index 00db0aad127..9671d1d8f4c 100644 --- a/test/test_datasets_video_utils.py +++ b/test/test_datasets_video_utils.py @@ -6,28 +6,7 @@ from torchvision import io from torchvision.datasets.video_utils import VideoClips, unfold -from common_utils import get_tmp_dir, assert_equal - - -@contextlib.contextmanager -def get_list_of_videos(num_videos=5, sizes=None, fps=None): - with get_tmp_dir() as tmp_dir: - names = [] - for i in range(num_videos): - if sizes is None: - size = 5 * (i + 1) - else: - size = sizes[i] - if fps is None: - f = 5 - else: - f = fps[i] - data = torch.randint(0, 256, (size, 300, 400, 3), dtype=torch.uint8) - name = os.path.join(tmp_dir, "{}.mp4".format(i)) - names.append(name) - io.write_video(name, data, fps=f) - - yield names +from common_utils import get_list_of_videos, assert_equal class TestVideo: @@ -58,40 +37,40 @@ def test_unfold(self): assert_equal(r, expected) @pytest.mark.skipif(not io.video._av_available(), reason="this test requires av") - def test_video_clips(self): - with get_list_of_videos(num_videos=3) as video_list: - video_clips = VideoClips(video_list, 5, 5, num_workers=2) - assert video_clips.num_clips() == 1 + 2 + 3 - for i, (v_idx, c_idx) in enumerate([(0, 0), (1, 0), (1, 1), (2, 0), (2, 1), (2, 2)]): - video_idx, clip_idx = video_clips.get_clip_location(i) - assert video_idx == v_idx - assert clip_idx == c_idx - - video_clips = VideoClips(video_list, 6, 6) - assert video_clips.num_clips() == 0 + 1 + 2 - for i, (v_idx, c_idx) in enumerate([(1, 0), (2, 0), (2, 1)]): - video_idx, clip_idx = video_clips.get_clip_location(i) - assert video_idx == v_idx - assert clip_idx == c_idx - - video_clips = VideoClips(video_list, 6, 1) - assert video_clips.num_clips() == 0 + (10 - 6 + 1) + (15 - 6 + 1) - for i, v_idx, c_idx in [(0, 1, 0), (4, 1, 4), (5, 2, 0), (6, 2, 1)]: - video_idx, clip_idx = video_clips.get_clip_location(i) - assert video_idx == v_idx - assert clip_idx == c_idx + def test_video_clips(self, tmpdir): + video_list = get_list_of_videos(tmpdir, num_videos=3) + video_clips = VideoClips(video_list, 5, 5, num_workers=2) + assert video_clips.num_clips() == 1 + 2 + 3 + for i, (v_idx, c_idx) in enumerate([(0, 0), (1, 0), (1, 1), (2, 0), (2, 1), (2, 2)]): + video_idx, clip_idx = video_clips.get_clip_location(i) + assert video_idx == v_idx + assert clip_idx == c_idx + + video_clips = VideoClips(video_list, 6, 6) + assert video_clips.num_clips() == 0 + 1 + 2 + for i, (v_idx, c_idx) in enumerate([(1, 0), (2, 0), (2, 1)]): + video_idx, clip_idx = video_clips.get_clip_location(i) + assert video_idx == v_idx + assert clip_idx == c_idx + + video_clips = VideoClips(video_list, 6, 1) + assert video_clips.num_clips() == 0 + (10 - 6 + 1) + (15 - 6 + 1) + for i, v_idx, c_idx in [(0, 1, 0), (4, 1, 4), (5, 2, 0), (6, 2, 1)]: + video_idx, clip_idx = video_clips.get_clip_location(i) + assert video_idx == v_idx + assert clip_idx == c_idx @pytest.mark.skipif(not io.video._av_available(), reason="this test requires av") - def test_video_clips_custom_fps(self): - with get_list_of_videos(num_videos=3, sizes=[12, 12, 12], fps=[3, 4, 6]) as video_list: - num_frames = 4 - for fps in [1, 3, 4, 10]: - video_clips = VideoClips(video_list, num_frames, num_frames, fps, num_workers=2) - for i in range(video_clips.num_clips()): - video, audio, info, video_idx = video_clips.get_clip(i) - assert video.shape[0] == num_frames - assert info["video_fps"] == fps - # TODO add tests checking that the content is right + def test_video_clips_custom_fps(self, tmpdir): + video_list = get_list_of_videos(tmpdir, num_videos=3, sizes=[12, 12, 12], fps=[3, 4, 6]) + num_frames = 4 + for fps in [1, 3, 4, 10]: + video_clips = VideoClips(video_list, num_frames, num_frames, fps, num_workers=2) + for i in range(video_clips.num_clips()): + video, audio, info, video_idx = video_clips.get_clip(i) + assert video.shape[0] == num_frames + assert info["video_fps"] == fps + # TODO add tests checking that the content is right def test_compute_clips_for_video(self): video_pts = torch.arange(30) diff --git a/test/test_image.py b/test/test_image.py index 7c6764dce64..5630d5d8226 100644 --- a/test/test_image.py +++ b/test/test_image.py @@ -9,7 +9,7 @@ import torch from PIL import Image, __version__ as PILLOW_VERSION import torchvision.transforms.functional as F -from common_utils import get_tmp_dir, needs_cuda, assert_equal +from common_utils import needs_cuda, assert_equal from torchvision.io.image import ( decode_png, decode_jpeg, encode_jpeg, write_jpeg, decode_image, read_file, @@ -197,74 +197,69 @@ def test_encode_png_errors(): pytest.param(png_path, id=_get_safe_image_name(png_path)) for png_path in get_images(IMAGE_DIR, ".png") ]) -def test_write_png(img_path): - with get_tmp_dir() as d: - pil_image = Image.open(img_path) - img_pil = torch.from_numpy(np.array(pil_image)) - img_pil = img_pil.permute(2, 0, 1) +def test_write_png(img_path, tmpdir): + pil_image = Image.open(img_path) + img_pil = torch.from_numpy(np.array(pil_image)) + img_pil = img_pil.permute(2, 0, 1) - filename, _ = os.path.splitext(os.path.basename(img_path)) - torch_png = os.path.join(d, '{0}_torch.png'.format(filename)) - write_png(img_pil, torch_png, compression_level=6) - saved_image = torch.from_numpy(np.array(Image.open(torch_png))) - saved_image = saved_image.permute(2, 0, 1) + filename, _ = os.path.splitext(os.path.basename(img_path)) + torch_png = os.path.join(tmpdir, '{0}_torch.png'.format(filename)) + write_png(img_pil, torch_png, compression_level=6) + saved_image = torch.from_numpy(np.array(Image.open(torch_png))) + saved_image = saved_image.permute(2, 0, 1) - assert_equal(img_pil, saved_image) + assert_equal(img_pil, saved_image) -def test_read_file(): - with get_tmp_dir() as d: - fname, content = 'test1.bin', b'TorchVision\211\n' - fpath = os.path.join(d, fname) - with open(fpath, 'wb') as f: - f.write(content) +def test_read_file(tmpdir): + fname, content = 'test1.bin', b'TorchVision\211\n' + fpath = os.path.join(tmpdir, fname) + with open(fpath, 'wb') as f: + f.write(content) - data = read_file(fpath) - expected = torch.tensor(list(content), dtype=torch.uint8) - os.unlink(fpath) - assert_equal(data, expected) + data = read_file(fpath) + expected = torch.tensor(list(content), dtype=torch.uint8) + os.unlink(fpath) + assert_equal(data, expected) with pytest.raises(RuntimeError, match="No such file or directory: 'tst'"): read_file('tst') -def test_read_file_non_ascii(): - with get_tmp_dir() as d: - fname, content = '日本語(Japanese).bin', b'TorchVision\211\n' - fpath = os.path.join(d, fname) - with open(fpath, 'wb') as f: - f.write(content) +def test_read_file_non_ascii(tmpdir): + fname, content = '日本語(Japanese).bin', b'TorchVision\211\n' + fpath = os.path.join(tmpdir, fname) + with open(fpath, 'wb') as f: + f.write(content) - data = read_file(fpath) - expected = torch.tensor(list(content), dtype=torch.uint8) - os.unlink(fpath) - assert_equal(data, expected) + data = read_file(fpath) + expected = torch.tensor(list(content), dtype=torch.uint8) + os.unlink(fpath) + assert_equal(data, expected) -def test_write_file(): - with get_tmp_dir() as d: - fname, content = 'test1.bin', b'TorchVision\211\n' - fpath = os.path.join(d, fname) - content_tensor = torch.tensor(list(content), dtype=torch.uint8) - write_file(fpath, content_tensor) +def test_write_file(tmpdir): + fname, content = 'test1.bin', b'TorchVision\211\n' + fpath = os.path.join(tmpdir, fname) + content_tensor = torch.tensor(list(content), dtype=torch.uint8) + write_file(fpath, content_tensor) - with open(fpath, 'rb') as f: - saved_content = f.read() - os.unlink(fpath) - assert content == saved_content + with open(fpath, 'rb') as f: + saved_content = f.read() + os.unlink(fpath) + assert content == saved_content -def test_write_file_non_ascii(): - with get_tmp_dir() as d: - fname, content = '日本語(Japanese).bin', b'TorchVision\211\n' - fpath = os.path.join(d, fname) - content_tensor = torch.tensor(list(content), dtype=torch.uint8) - write_file(fpath, content_tensor) +def test_write_file_non_ascii(tmpdir): + fname, content = '日本語(Japanese).bin', b'TorchVision\211\n' + fpath = os.path.join(tmpdir, fname) + content_tensor = torch.tensor(list(content), dtype=torch.uint8) + write_file(fpath, content_tensor) - with open(fpath, 'rb') as f: - saved_content = f.read() - os.unlink(fpath) - assert content == saved_content + with open(fpath, 'rb') as f: + saved_content = f.read() + os.unlink(fpath) + assert content == saved_content @pytest.mark.parametrize('shape', [ @@ -272,16 +267,15 @@ def test_write_file_non_ascii(): (60, 60), (105, 105), ]) -def test_read_1_bit_png(shape): +def test_read_1_bit_png(shape, tmpdir): np_rng = np.random.RandomState(0) - with get_tmp_dir() as root: - image_path = os.path.join(root, f'test_{shape}.png') - pixels = np_rng.rand(*shape) > 0.5 - img = Image.fromarray(pixels) - img.save(image_path) - img1 = read_image(image_path) - img2 = normalize_dimensions(torch.as_tensor(pixels * 255, dtype=torch.uint8)) - assert_equal(img1, img2) + image_path = os.path.join(tmpdir, f'test_{shape}.png') + pixels = np_rng.rand(*shape) > 0.5 + img = Image.fromarray(pixels) + img.save(image_path) + img1 = read_image(image_path) + img2 = normalize_dimensions(torch.as_tensor(pixels * 255, dtype=torch.uint8)) + assert_equal(img1, img2) @pytest.mark.parametrize('shape', [ @@ -293,16 +287,15 @@ def test_read_1_bit_png(shape): ImageReadMode.UNCHANGED, ImageReadMode.GRAY, ]) -def test_read_1_bit_png_consistency(shape, mode): +def test_read_1_bit_png_consistency(shape, mode, tmpdir): np_rng = np.random.RandomState(0) - with get_tmp_dir() as root: - image_path = os.path.join(root, f'test_{shape}.png') - pixels = np_rng.rand(*shape) > 0.5 - img = Image.fromarray(pixels) - img.save(image_path) - img1 = read_image(image_path, mode) - img2 = read_image(image_path, mode) - assert_equal(img1, img2) + image_path = os.path.join(tmpdir, f'test_{shape}.png') + pixels = np_rng.rand(*shape) > 0.5 + img = Image.fromarray(pixels) + img.save(image_path) + img1 = read_image(image_path, mode) + img2 = read_image(image_path, mode) + assert_equal(img1, img2) def test_read_interlaced_png(): @@ -427,28 +420,27 @@ def test_encode_jpeg_reference(img_path): pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) for jpeg_path in get_images(ENCODE_JPEG, ".jpg") ]) -def test_write_jpeg_reference(img_path): +def test_write_jpeg_reference(img_path, tmpdir): # FIXME: Remove this eventually, see test_encode_jpeg_reference - with get_tmp_dir() as d: - data = read_file(img_path) - img = decode_jpeg(data) + data = read_file(img_path) + img = decode_jpeg(data) - basedir = os.path.dirname(img_path) - filename, _ = os.path.splitext(os.path.basename(img_path)) - torch_jpeg = os.path.join( - d, '{0}_torch.jpg'.format(filename)) - pil_jpeg = os.path.join( - basedir, 'jpeg_write', '{0}_pil.jpg'.format(filename)) + basedir = os.path.dirname(img_path) + filename, _ = os.path.splitext(os.path.basename(img_path)) + torch_jpeg = os.path.join( + tmpdir, '{0}_torch.jpg'.format(filename)) + pil_jpeg = os.path.join( + basedir, 'jpeg_write', '{0}_pil.jpg'.format(filename)) - write_jpeg(img, torch_jpeg, quality=75) + write_jpeg(img, torch_jpeg, quality=75) - with open(torch_jpeg, 'rb') as f: - torch_bytes = f.read() + with open(torch_jpeg, 'rb') as f: + torch_bytes = f.read() - with open(pil_jpeg, 'rb') as f: - pil_bytes = f.read() + with open(pil_jpeg, 'rb') as f: + pil_bytes = f.read() - assert_equal(torch_bytes, pil_bytes) + assert_equal(torch_bytes, pil_bytes) @pytest.mark.skipif(IS_WINDOWS, reason=( @@ -481,25 +473,24 @@ def test_encode_jpeg(img_path): pytest.param(jpeg_path, id=_get_safe_image_name(jpeg_path)) for jpeg_path in get_images(ENCODE_JPEG, ".jpg") ]) -def test_write_jpeg(img_path): - with get_tmp_dir() as d: - d = Path(d) - img = read_image(img_path) - pil_img = F.to_pil_image(img) +def test_write_jpeg(img_path, tmpdir): + tmpdir = Path(tmpdir) + img = read_image(img_path) + pil_img = F.to_pil_image(img) - torch_jpeg = str(d / 'torch.jpg') - pil_jpeg = str(d / 'pil.jpg') + torch_jpeg = str(tmpdir / 'torch.jpg') + pil_jpeg = str(tmpdir / 'pil.jpg') - write_jpeg(img, torch_jpeg, quality=75) - pil_img.save(pil_jpeg, quality=75) + write_jpeg(img, torch_jpeg, quality=75) + pil_img.save(pil_jpeg, quality=75) - with open(torch_jpeg, 'rb') as f: - torch_bytes = f.read() + with open(torch_jpeg, 'rb') as f: + torch_bytes = f.read() - with open(pil_jpeg, 'rb') as f: - pil_bytes = f.read() + with open(pil_jpeg, 'rb') as f: + pil_bytes = f.read() - assert_equal(torch_bytes, pil_bytes) + assert_equal(torch_bytes, pil_bytes) if __name__ == "__main__": diff --git a/test/test_internet.py b/test/test_internet.py index 8b1678f7b58..fd552961714 100644 --- a/test/test_internet.py +++ b/test/test_internet.py @@ -11,35 +11,31 @@ from urllib.error import URLError import torchvision.datasets.utils as utils -from common_utils import get_tmp_dir class TestDatasetUtils: - def test_download_url(self): - with get_tmp_dir() as temp_dir: - url = "http://github.com/pytorch/vision/archive/master.zip" - try: - utils.download_url(url, temp_dir) - assert len(os.listdir(temp_dir)) != 0 - except URLError: - pytest.skip(f"could not download test file '{url}'") - - def test_download_url_retry_http(self): - with get_tmp_dir() as temp_dir: - url = "https://github.com/pytorch/vision/archive/master.zip" - try: - utils.download_url(url, temp_dir) - assert len(os.listdir(temp_dir)) != 0 - except URLError: - pytest.skip(f"could not download test file '{url}'") - - def test_download_url_dont_exist(self): - with get_tmp_dir() as temp_dir: - url = "http://github.com/pytorch/vision/archive/this_doesnt_exist.zip" - with pytest.raises(URLError): - utils.download_url(url, temp_dir) - - def test_download_url_dispatch_download_from_google_drive(self, mocker): + def test_download_url(self, tmpdir): + url = "http://github.com/pytorch/vision/archive/master.zip" + try: + utils.download_url(url, tmpdir) + assert len(os.listdir(tmpdir)) != 0 + except URLError: + pytest.skip(f"could not download test file '{url}'") + + def test_download_url_retry_http(self, tmpdir): + url = "https://github.com/pytorch/vision/archive/master.zip" + try: + utils.download_url(url, tmpdir) + assert len(os.listdir(tmpdir)) != 0 + except URLError: + pytest.skip(f"could not download test file '{url}'") + + def test_download_url_dont_exist(self, tmpdir): + url = "http://github.com/pytorch/vision/archive/this_doesnt_exist.zip" + with pytest.raises(URLError): + utils.download_url(url, tmpdir) + + def test_download_url_dispatch_download_from_google_drive(self, mocker, tmpdir): url = "https://drive.google.com/file/d/1hbzc_P1FuxMkcabkgn9ZKinBwW683j45/view" id = "1hbzc_P1FuxMkcabkgn9ZKinBwW683j45" @@ -47,10 +43,9 @@ def test_download_url_dispatch_download_from_google_drive(self, mocker): md5 = "md5" mocked = mocker.patch('torchvision.datasets.utils.download_file_from_google_drive') - with get_tmp_dir() as root: - utils.download_url(url, root, filename, md5) + utils.download_url(url, tmpdir, filename, md5) - mocked.assert_called_once_with(id, root, filename, md5) + mocked.assert_called_once_with(id, tmpdir, filename, md5) if __name__ == '__main__': diff --git a/test/test_io.py b/test/test_io.py index 56cd0af5fd8..150d66f0814 100644 --- a/test/test_io.py +++ b/test/test_io.py @@ -9,7 +9,7 @@ import warnings from urllib.error import URLError -from common_utils import get_tmp_dir, assert_equal +from common_utils import assert_equal try: @@ -255,37 +255,36 @@ def test_read_video_partially_corrupted_file(self): assert_equal(video, data) @pytest.mark.skipif(sys.platform == 'win32', reason='temporarily disabled on Windows') - def test_write_video_with_audio(self): + def test_write_video_with_audio(self, tmpdir): f_name = os.path.join(VIDEO_DIR, "R6llTwEh07w.mp4") video_tensor, audio_tensor, info = io.read_video(f_name, pts_unit="sec") - with get_tmp_dir() as tmpdir: - out_f_name = os.path.join(tmpdir, "testing.mp4") - io.video.write_video( - out_f_name, - video_tensor, - round(info["video_fps"]), - video_codec="libx264rgb", - options={'crf': '0'}, - audio_array=audio_tensor, - audio_fps=info["audio_fps"], - audio_codec="aac", - ) - - out_video_tensor, out_audio_tensor, out_info = io.read_video( - out_f_name, pts_unit="sec" - ) - - assert info["video_fps"] == out_info["video_fps"] - assert_equal(video_tensor, out_video_tensor) - - audio_stream = av.open(f_name).streams.audio[0] - out_audio_stream = av.open(out_f_name).streams.audio[0] - - assert info["audio_fps"] == out_info["audio_fps"] - assert audio_stream.rate == out_audio_stream.rate - assert pytest.approx(out_audio_stream.frames, rel=0.0, abs=1) == audio_stream.frames - assert audio_stream.frame_size == out_audio_stream.frame_size + out_f_name = os.path.join(tmpdir, "testing.mp4") + io.video.write_video( + out_f_name, + video_tensor, + round(info["video_fps"]), + video_codec="libx264rgb", + options={'crf': '0'}, + audio_array=audio_tensor, + audio_fps=info["audio_fps"], + audio_codec="aac", + ) + + out_video_tensor, out_audio_tensor, out_info = io.read_video( + out_f_name, pts_unit="sec" + ) + + assert info["video_fps"] == out_info["video_fps"] + assert_equal(video_tensor, out_video_tensor) + + audio_stream = av.open(f_name).streams.audio[0] + out_audio_stream = av.open(out_f_name).streams.audio[0] + + assert info["audio_fps"] == out_info["audio_fps"] + assert audio_stream.rate == out_audio_stream.rate + assert pytest.approx(out_audio_stream.frames, rel=0.0, abs=1) == audio_stream.frames + assert audio_stream.frame_size == out_audio_stream.frame_size # TODO add tests for audio diff --git a/test/test_transforms_tensor.py b/test/test_transforms_tensor.py index 0bf5d77716f..5081626fec4 100644 --- a/test/test_transforms_tensor.py +++ b/test/test_transforms_tensor.py @@ -230,7 +230,7 @@ def test_crop_pad(size, padding_config, device): @pytest.mark.parametrize('device', cpu_and_gpu()) -def test_center_crop(device): +def test_center_crop(device, tmpdir): fn_kwargs = {"output_size": (4, 5)} meth_kwargs = {"size": (4, 5), } _test_op( @@ -259,8 +259,7 @@ def test_center_crop(device): scripted_fn = torch.jit.script(f) scripted_fn(tensor) - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_center_crop.pt")) + scripted_fn.save(os.path.join(tmpdir, "t_center_crop.pt")) @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -309,11 +308,10 @@ def test_x_crop(fn, method, out_length, size, device): @pytest.mark.parametrize('method', ["FiveCrop", "TenCrop"]) -def test_x_crop_save(method): +def test_x_crop_save(method, tmpdir): fn = getattr(T, method)(size=[5, ]) scripted_fn = torch.jit.script(fn) - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_op_list_{}.pt".format(method))) + scripted_fn.save(os.path.join(tmpdir, "t_op_list_{}.pt".format(method))) class TestResize: @@ -349,11 +347,10 @@ def test_resize_scripted(self, dt, size, max_size, interpolation, device): _test_transform_vs_scripted(transform, s_transform, tensor) _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - def test_resize_save(self): + def test_resize_save(self, tmpdir): transform = T.Resize(size=[32, ]) s_transform = torch.jit.script(transform) - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_resize.pt")) + s_transform.save(os.path.join(tmpdir, "t_resize.pt")) @pytest.mark.parametrize('device', cpu_and_gpu()) @pytest.mark.parametrize('scale', [(0.7, 1.2), [0.7, 1.2]]) @@ -368,11 +365,10 @@ def test_resized_crop(self, scale, ratio, size, interpolation, device): _test_transform_vs_scripted(transform, s_transform, tensor) _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) - def test_resized_crop_save(self): + def test_resized_crop_save(self, tmpdir): transform = T.RandomResizedCrop(size=[32, ]) s_transform = torch.jit.script(transform) - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_resized_crop.pt")) + s_transform.save(os.path.join(tmpdir, "t_resized_crop.pt")) def _test_random_affine_helper(device, **kwargs): @@ -386,11 +382,10 @@ def _test_random_affine_helper(device, **kwargs): @pytest.mark.parametrize('device', cpu_and_gpu()) -def test_random_affine(device): +def test_random_affine(device, tmpdir): transform = T.RandomAffine(degrees=45.0) s_transform = torch.jit.script(transform) - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_random_affine.pt")) + s_transform.save(os.path.join(tmpdir, "t_random_affine.pt")) @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -447,11 +442,10 @@ def test_random_rotate(device, center, expand, degrees, interpolation, fill): _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) -def test_random_rotate_save(): +def test_random_rotate_save(tmpdir): transform = T.RandomRotation(degrees=45.0) s_transform = torch.jit.script(transform) - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_random_rotate.pt")) + s_transform.save(os.path.join(tmpdir, "t_random_rotate.pt")) @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -473,11 +467,10 @@ def test_random_perspective(device, distortion_scale, interpolation, fill): _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) -def test_random_perspective_save(): +def test_random_perspective_save(tmpdir): transform = T.RandomPerspective() s_transform = torch.jit.script(transform) - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_perspective.pt")) + s_transform.save(os.path.join(tmpdir, "t_perspective.pt")) @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -519,11 +512,10 @@ def test_convert_image_dtype(device, in_dtype, out_dtype): _test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) -def test_convert_image_dtype_save(): +def test_convert_image_dtype_save(tmpdir): fn = T.ConvertImageDtype(dtype=torch.uint8) scripted_fn = torch.jit.script(fn) - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_convert_dtype.pt")) + scripted_fn.save(os.path.join(tmpdir, "t_convert_dtype.pt")) @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -541,11 +533,10 @@ def test_autoaugment(device, policy, fill): _test_transform_vs_scripted_on_batch(transform, s_transform, batch_tensors) -def test_autoaugment_save(): +def test_autoaugment_save(tmpdir): transform = T.AutoAugment() s_transform = torch.jit.script(transform) - with get_tmp_dir() as tmp_dir: - s_transform.save(os.path.join(tmp_dir, "t_autoaugment.pt")) + s_transform.save(os.path.join(tmpdir, "t_autoaugment.pt")) @pytest.mark.parametrize('device', cpu_and_gpu()) @@ -567,11 +558,10 @@ def test_random_erasing(device, config): _test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) -def test_random_erasing_save(): +def test_random_erasing_save(tmpdir): fn = T.RandomErasing(value=0.2) scripted_fn = torch.jit.script(fn) - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_random_erasing.pt")) + scripted_fn.save(os.path.join(tmpdir, "t_random_erasing.pt")) def test_random_erasing_with_invalid_data(): @@ -583,7 +573,7 @@ def test_random_erasing_with_invalid_data(): @pytest.mark.parametrize('device', cpu_and_gpu()) -def test_normalize(device): +def test_normalize(device, tmpdir): fn = T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) tensor, _ = _create_data(26, 34, device=device) @@ -598,12 +588,11 @@ def test_normalize(device): _test_transform_vs_scripted(fn, scripted_fn, tensor) _test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_norm.pt")) + scripted_fn.save(os.path.join(tmpdir, "t_norm.pt")) @pytest.mark.parametrize('device', cpu_and_gpu()) -def test_linear_transformation(device): +def test_linear_transformation(device, tmpdir): c, h, w = 3, 24, 32 tensor, _ = _create_data(h, w, channels=c, device=device) @@ -625,8 +614,7 @@ def test_linear_transformation(device): s_transformed_batch = scripted_fn(batch_tensors) assert_equal(transformed_batch, s_transformed_batch) - with get_tmp_dir() as tmp_dir: - scripted_fn.save(os.path.join(tmp_dir, "t_norm.pt")) + scripted_fn.save(os.path.join(tmpdir, "t_norm.pt")) @pytest.mark.parametrize('device', cpu_and_gpu()) From 759c5b6dc2dfe46735bf724839f815b5cd79af09 Mon Sep 17 00:00:00 2001 From: Aditya Oke <47158509+oke-aditya@users.noreply.github.com> Date: Wed, 18 Aug 2021 14:02:33 +0530 Subject: [PATCH 275/279] Added typing annotations to transforms/functional_pil (#4234) * fix * add functional PIL typings * fix types * fix types * fix a small one * small fix * fix type * fix interpolation types Co-authored-by: Vasilis Vryniotis --- torchvision/transforms/functional_pil.py | 93 ++++++++++++++++++------ 1 file changed, 71 insertions(+), 22 deletions(-) diff --git a/torchvision/transforms/functional_pil.py b/torchvision/transforms/functional_pil.py index 3829637fdb7..0f3d1d87bb4 100644 --- a/torchvision/transforms/functional_pil.py +++ b/torchvision/transforms/functional_pil.py @@ -1,5 +1,5 @@ import numbers -from typing import Any, List, Sequence +from typing import Any, Dict, List, Optional, Sequence, Tuple, Union import numpy as np import torch @@ -34,7 +34,7 @@ def _get_image_num_channels(img: Any) -> int: @torch.jit.unused -def hflip(img): +def hflip(img: Image.Image) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -42,7 +42,7 @@ def hflip(img): @torch.jit.unused -def vflip(img): +def vflip(img: Image.Image) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -50,7 +50,7 @@ def vflip(img): @torch.jit.unused -def adjust_brightness(img, brightness_factor): +def adjust_brightness(img: Image.Image, brightness_factor: float) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -60,7 +60,7 @@ def adjust_brightness(img, brightness_factor): @torch.jit.unused -def adjust_contrast(img, contrast_factor): +def adjust_contrast(img: Image.Image, contrast_factor: float) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -70,7 +70,7 @@ def adjust_contrast(img, contrast_factor): @torch.jit.unused -def adjust_saturation(img, saturation_factor): +def adjust_saturation(img: Image.Image, saturation_factor: float) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -80,7 +80,7 @@ def adjust_saturation(img, saturation_factor): @torch.jit.unused -def adjust_hue(img, hue_factor): +def adjust_hue(img: Image.Image, hue_factor: float) -> Image.Image: if not(-0.5 <= hue_factor <= 0.5): raise ValueError('hue_factor ({}) is not in [-0.5, 0.5].'.format(hue_factor)) @@ -104,7 +104,12 @@ def adjust_hue(img, hue_factor): @torch.jit.unused -def adjust_gamma(img, gamma, gain=1): +def adjust_gamma( + img: Image.Image, + gamma: float, + gain: float = 1.0, +) -> Image.Image: + if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -121,7 +126,13 @@ def adjust_gamma(img, gamma, gain=1): @torch.jit.unused -def pad(img, padding, fill=0, padding_mode="constant"): +def pad( + img: Image.Image, + padding: Union[int, List[int], Tuple[int, ...]], + fill: Optional[Union[float, List[float], Tuple[float, ...]]] = 0, + padding_mode: str = "constant", +) -> Image.Image: + if not _is_pil_image(img): raise TypeError("img should be PIL Image. Got {}".format(type(img))) @@ -196,7 +207,14 @@ def pad(img, padding, fill=0, padding_mode="constant"): @torch.jit.unused -def crop(img: Image.Image, top: int, left: int, height: int, width: int) -> Image.Image: +def crop( + img: Image.Image, + top: int, + left: int, + height: int, + width: int, +) -> Image.Image: + if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -204,7 +222,13 @@ def crop(img: Image.Image, top: int, left: int, height: int, width: int) -> Imag @torch.jit.unused -def resize(img, size, interpolation=Image.BILINEAR, max_size=None): +def resize( + img: Image.Image, + size: Union[Sequence[int], int], + interpolation: int = Image.BILINEAR, + max_size: Optional[int] = None, +) -> Image.Image: + if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) if not (isinstance(size, int) or (isinstance(size, Sequence) and len(size) in (1, 2))): @@ -242,7 +266,12 @@ def resize(img, size, interpolation=Image.BILINEAR, max_size=None): @torch.jit.unused -def _parse_fill(fill, img, name="fillcolor"): +def _parse_fill( + fill: Optional[Union[float, List[float], Tuple[float, ...]]], + img: Image.Image, + name: str = "fillcolor", +) -> Dict[str, Optional[Union[float, List[float], Tuple[float, ...]]]]: + # Process fill color for affine transforms num_bands = len(img.getbands()) if fill is None: @@ -261,7 +290,13 @@ def _parse_fill(fill, img, name="fillcolor"): @torch.jit.unused -def affine(img, matrix, interpolation=0, fill=None): +def affine( + img: Image.Image, + matrix: List[float], + interpolation: int = Image.NEAREST, + fill: Optional[Union[float, List[float], Tuple[float, ...]]] = 0, +) -> Image.Image: + if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -271,7 +306,15 @@ def affine(img, matrix, interpolation=0, fill=None): @torch.jit.unused -def rotate(img, angle, interpolation=0, expand=False, center=None, fill=None): +def rotate( + img: Image.Image, + angle: float, + interpolation: int = Image.NEAREST, + expand: bool = False, + center: Optional[Tuple[int, int]] = None, + fill: Optional[Union[float, List[float], Tuple[float, ...]]] = 0, +) -> Image.Image: + if not _is_pil_image(img): raise TypeError("img should be PIL Image. Got {}".format(type(img))) @@ -280,7 +323,13 @@ def rotate(img, angle, interpolation=0, expand=False, center=None, fill=None): @torch.jit.unused -def perspective(img, perspective_coeffs, interpolation=Image.BICUBIC, fill=None): +def perspective( + img: Image.Image, + perspective_coeffs: float, + interpolation: int = Image.BICUBIC, + fill: Optional[Union[float, List[float], Tuple[float, ...]]] = 0, +) -> Image.Image: + if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -290,7 +339,7 @@ def perspective(img, perspective_coeffs, interpolation=Image.BICUBIC, fill=None) @torch.jit.unused -def to_grayscale(img, num_output_channels): +def to_grayscale(img: Image.Image, num_output_channels: int) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -308,28 +357,28 @@ def to_grayscale(img, num_output_channels): @torch.jit.unused -def invert(img): +def invert(img: Image.Image) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) return ImageOps.invert(img) @torch.jit.unused -def posterize(img, bits): +def posterize(img: Image.Image, bits: int) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) return ImageOps.posterize(img, bits) @torch.jit.unused -def solarize(img, threshold): +def solarize(img: Image.Image, threshold: int) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) return ImageOps.solarize(img, threshold) @torch.jit.unused -def adjust_sharpness(img, sharpness_factor): +def adjust_sharpness(img: Image.Image, sharpness_factor: float) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) @@ -339,14 +388,14 @@ def adjust_sharpness(img, sharpness_factor): @torch.jit.unused -def autocontrast(img): +def autocontrast(img: Image.Image) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) return ImageOps.autocontrast(img) @torch.jit.unused -def equalize(img): +def equalize(img: Image.Image) -> Image.Image: if not _is_pil_image(img): raise TypeError('img should be PIL Image. Got {}'.format(type(img))) return ImageOps.equalize(img) From 84888b93f1467e3111c2dfa36c6151cf827e642f Mon Sep 17 00:00:00 2001 From: Philip Meier Date: Thu, 19 Aug 2021 13:18:59 +0200 Subject: [PATCH 276/279] remove dependency for dtype getters (#4291) --- test/common_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/common_utils.py b/test/common_utils.py index 79fce27110d..1a2e3042365 100644 --- a/test/common_utils.py +++ b/test/common_utils.py @@ -102,11 +102,11 @@ def cycle_over(objs): def int_dtypes(): - return torch.testing.integral_types() + return (torch.uint8, torch.int8, torch.int16, torch.int32, torch.int64) def float_dtypes(): - return torch.testing.floating_types() + return (torch.float32, torch.float64) @contextlib.contextmanager From 16caba5e72d4995a1743c72824b923920060cb26 Mon Sep 17 00:00:00 2001 From: zzk1st Date: Thu, 19 Aug 2021 15:35:50 +0100 Subject: [PATCH 277/279] =?UTF-8?q?Unpinned=20the=20libjpeg=20version=20an?= =?UTF-8?q?d=20fixed=20jpeg=5Fmem=5Fdest's=20size=20type=20Wind=E2=80=A6?= =?UTF-8?q?=20(#4288)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Unpinned the libjpeg version and fixed jpeg_mem_dest's size type Windows BC issue * Temporarily get back pinned jpeg lib in order to run tests on CircleCI * Revert "Temporarily get back pinned jpeg lib in order to run tests on CircleCI" This reverts commit ab18a354150f750256b61911e54aa48621ef24cd. * Used using instead of typedef and Fixed comment typo Co-authored-by: Zhongkai Zhu Co-authored-by: Vasilis Vryniotis --- .circleci/unittest/linux/scripts/environment.yml | 3 +-- .circleci/unittest/windows/scripts/environment.yml | 3 +-- packaging/torchvision/meta.yaml | 9 +++------ torchvision/csrc/io/image/cpu/encode_jpeg.cpp | 14 +++++++++++++- 4 files changed, 18 insertions(+), 11 deletions(-) diff --git a/.circleci/unittest/linux/scripts/environment.yml b/.circleci/unittest/linux/scripts/environment.yml index c03fd590c37..ce3fe3be6e6 100644 --- a/.circleci/unittest/linux/scripts/environment.yml +++ b/.circleci/unittest/linux/scripts/environment.yml @@ -7,8 +7,7 @@ dependencies: - pytest-mock - pip - libpng - # NOTE: Pinned to fix issues with size_t on Windows - - jpeg <=9b + - jpeg - ca-certificates - pip: - future diff --git a/.circleci/unittest/windows/scripts/environment.yml b/.circleci/unittest/windows/scripts/environment.yml index 15a7ca8a795..5b0d3f5462d 100644 --- a/.circleci/unittest/windows/scripts/environment.yml +++ b/.circleci/unittest/windows/scripts/environment.yml @@ -7,8 +7,7 @@ dependencies: - pytest-mock - pip - libpng - # NOTE: Pinned to fix issues with size_t on Windows - - jpeg <=9b + - jpeg - ca-certificates - pip: - future diff --git a/packaging/torchvision/meta.yaml b/packaging/torchvision/meta.yaml index 222071ede93..da061c5cc2a 100644 --- a/packaging/torchvision/meta.yaml +++ b/packaging/torchvision/meta.yaml @@ -9,8 +9,7 @@ requirements: build: - {{ compiler('c') }} # [win] - libpng - # NOTE: Pinned to fix issues with size_t on Windows - - jpeg <=9b + - jpeg # NOTE: The only ffmpeg version that we build is actually 4.2 - ffmpeg >=4.2 # [not win] @@ -25,8 +24,7 @@ requirements: - python - libpng - ffmpeg >=4.2 # [not win] - # NOTE: Pinned to fix issues with size_t on Windows - - jpeg <=9b + - jpeg - pillow >=5.3.0 {{ environ.get('CONDA_PYTORCH_CONSTRAINT') }} {{ environ.get('CONDA_CUDATOOLKIT_CONSTRAINT') }} @@ -52,8 +50,7 @@ test: requires: - pytest - scipy - # NOTE: Pinned to fix issues with size_t on Windows - - jpeg <=9b + - jpeg - ca-certificates diff --git a/torchvision/csrc/io/image/cpu/encode_jpeg.cpp b/torchvision/csrc/io/image/cpu/encode_jpeg.cpp index 1ba730f0998..89d05ea4079 100644 --- a/torchvision/csrc/io/image/cpu/encode_jpeg.cpp +++ b/torchvision/csrc/io/image/cpu/encode_jpeg.cpp @@ -13,6 +13,18 @@ torch::Tensor encode_jpeg(const torch::Tensor& data, int64_t quality) { } #else +// For libjpeg version <= 9b, the out_size parameter in jpeg_mem_dest() is +// defined as unsigned long, where as in later version, it is defined as size_t. +// For windows backward compatibility, we define JpegSizeType as different types +// according to the libjpeg version used, in order to prevent compilcation +// errors. +#if defined(_WIN32) || !defined(JPEG_LIB_VERSION_MAJOR) || \ + (JPEG_LIB_VERSION_MAJOR < 9) || \ + (JPEG_LIB_VERSION_MAJOR == 9 && JPEG_LIB_VERSION_MINOR <= 2) +using JpegSizeType = unsigned long; +#else +using JpegSizeType = size_t; +#endif using namespace detail; @@ -22,7 +34,7 @@ torch::Tensor encode_jpeg(const torch::Tensor& data, int64_t quality) { struct torch_jpeg_error_mgr jerr {}; // Define buffer to write JPEG information to and its size - unsigned long jpegSize = 0; + JpegSizeType jpegSize = 0; uint8_t* jpegBuf = nullptr; cinfo.err = jpeg_std_error(&jerr.pub); From ef177c56f853f409bad11f07ac515a175555da0f Mon Sep 17 00:00:00 2001 From: Vasilis Vryniotis Date: Fri, 20 Aug 2021 14:15:51 +0100 Subject: [PATCH 278/279] Add StochasticDepth implementation (#4301) * Adding operator. * Adding tests * switching order of `p` and `mode`. * Remove seed setting. * Replace stats import with pytest.importorskip. * Fix doc * Apply suggestions from code review Co-authored-by: Francisco Massa * Fixing indentation. * Adding operator in the documentation. * Fixing lint Co-authored-by: Francisco Massa --- docs/source/ops.rst | 2 ++ test/test_ops.py | 28 +++++++++++++++ torchvision/ops/__init__.py | 3 +- torchvision/ops/stochastic_depth.py | 56 +++++++++++++++++++++++++++++ 4 files changed, 88 insertions(+), 1 deletion(-) create mode 100644 torchvision/ops/stochastic_depth.py diff --git a/docs/source/ops.rst b/docs/source/ops.rst index cdebe9721c3..ecef74dd8a6 100644 --- a/docs/source/ops.rst +++ b/docs/source/ops.rst @@ -23,6 +23,7 @@ torchvision.ops .. autofunction:: ps_roi_pool .. autofunction:: deform_conv2d .. autofunction:: sigmoid_focal_loss +.. autofunction:: stochastic_depth .. autoclass:: RoIAlign .. autoclass:: PSRoIAlign @@ -31,3 +32,4 @@ torchvision.ops .. autoclass:: DeformConv2d .. autoclass:: MultiScaleRoIAlign .. autoclass:: FeaturePyramidNetwork +.. autoclass:: StochasticDepth diff --git a/test/test_ops.py b/test/test_ops.py index 5c2fc882902..c64ba1fd0bb 100644 --- a/test/test_ops.py +++ b/test/test_ops.py @@ -1000,5 +1000,33 @@ def gen_iou_check(box, expected, tolerance=1e-4): gen_iou_check(box_tensor, expected, tolerance=0.002 if dtype == torch.float16 else 1e-3) +class TestStochasticDepth: + @pytest.mark.parametrize('p', [0.2, 0.5, 0.8]) + @pytest.mark.parametrize('mode', ["batch", "row"]) + def test_stochastic_depth(self, mode, p): + stats = pytest.importorskip("scipy.stats") + batch_size = 5 + x = torch.ones(size=(batch_size, 3, 4, 4)) + layer = ops.StochasticDepth(p=p, mode=mode).to(device=x.device, dtype=x.dtype) + layer.__repr__() + + trials = 250 + num_samples = 0 + counts = 0 + for _ in range(trials): + out = layer(x) + non_zero_count = out.sum(dim=(1, 2, 3)).nonzero().size(0) + if mode == "batch": + if non_zero_count == 0: + counts += 1 + num_samples += 1 + elif mode == "row": + counts += batch_size - non_zero_count + num_samples += batch_size + + p_value = stats.binom_test(counts, num_samples, p=p) + assert p_value > 0.0001 + + if __name__ == '__main__': pytest.main([__file__]) diff --git a/torchvision/ops/__init__.py b/torchvision/ops/__init__.py index 0ec189dbc2a..606c27abcbe 100644 --- a/torchvision/ops/__init__.py +++ b/torchvision/ops/__init__.py @@ -8,6 +8,7 @@ from .poolers import MultiScaleRoIAlign from .feature_pyramid_network import FeaturePyramidNetwork from .focal_loss import sigmoid_focal_loss +from .stochastic_depth import stochastic_depth, StochasticDepth from ._register_onnx_ops import _register_custom_op @@ -20,5 +21,5 @@ 'box_area', 'box_iou', 'generalized_box_iou', 'roi_align', 'RoIAlign', 'roi_pool', 'RoIPool', 'ps_roi_align', 'PSRoIAlign', 'ps_roi_pool', 'PSRoIPool', 'MultiScaleRoIAlign', 'FeaturePyramidNetwork', - 'sigmoid_focal_loss' + 'sigmoid_focal_loss', 'stochastic_depth', 'StochasticDepth' ] diff --git a/torchvision/ops/stochastic_depth.py b/torchvision/ops/stochastic_depth.py new file mode 100644 index 00000000000..f3338242a76 --- /dev/null +++ b/torchvision/ops/stochastic_depth.py @@ -0,0 +1,56 @@ +import torch +from torch import nn, Tensor + + +def stochastic_depth(input: Tensor, p: float, mode: str, training: bool = True) -> Tensor: + """ + Implements the Stochastic Depth from `"Deep Networks with Stochastic Depth" + `_ used for randomly dropping residual + branches of residual architectures. + + Args: + input (Tensor[N, ...]): The input tensor or arbitrary dimensions with the first one + being its batch i.e. a batch with ``N`` rows. + p (float): probability of the input to be zeroed. + mode (str): ``"batch"`` or ``"row"``. + ``"batch"`` randomly zeroes the entire input, ``"row"`` zeroes + randomly selected rows from the batch. + training: apply stochastic depth if is ``True``. Default: ``True`` + + Returns: + Tensor[N, ...]: The randomly zeroed tensor. + """ + if p < 0.0 or p > 1.0: + raise ValueError("drop probability has to be between 0 and 1, but got {}".format(p)) + if not training or p == 0.0: + return input + + survival_rate = 1.0 - p + if mode not in ["batch", "row"]: + raise ValueError("mode has to be either 'batch' or 'row', but got {}".format(mode)) + size = [1] * input.ndim + if mode == "row": + size[0] = input.shape[0] + noise = torch.empty(size, dtype=input.dtype, device=input.device) + noise = noise.bernoulli_(survival_rate).div_(survival_rate) + return input * noise + + +class StochasticDepth(nn.Module): + """ + See :func:`stochastic_depth`. + """ + def __init__(self, p: float, mode: str) -> None: + super().__init__() + self.p = p + self.mode = mode + + def forward(self, input: Tensor) -> Tensor: + return stochastic_depth(input, self.p, self.mode, self.training) + + def __repr__(self) -> str: + tmpstr = self.__class__.__name__ + '(' + tmpstr += 'p=' + str(self.p) + tmpstr += ', mode=' + str(self.mode) + tmpstr += ')' + return tmpstr From 7947fc8fb38b1d3a2aca03f22a2e6a3caa63f2a0 Mon Sep 17 00:00:00 2001 From: Nikita Shulga Date: Sun, 22 Aug 2021 20:07:08 -0700 Subject: [PATCH 279/279] Prep change for changing def branch to main (#4306) --- .circleci/build_docs/commit_docs.sh | 4 +- .circleci/config.yml | 76 ++++++++++++++--------------- .circleci/config.yml.in | 8 +-- .circleci/regenerate.py | 4 +- .github/workflows/bandit.yml | 2 +- .github/workflows/codeql.yml | 2 +- CONTRIBUTING.md | 2 +- README.rst | 4 +- android/gradle.properties | 2 +- docs/source/conf.py | 4 +- test/test_cpp_models.py | 2 +- torchvision/__init__.py | 2 +- 12 files changed, 56 insertions(+), 56 deletions(-) diff --git a/.circleci/build_docs/commit_docs.sh b/.circleci/build_docs/commit_docs.sh index b923b0edbc4..04e3538fefc 100755 --- a/.circleci/build_docs/commit_docs.sh +++ b/.circleci/build_docs/commit_docs.sh @@ -6,7 +6,7 @@ set -ex if [ "$2" == "" ]; then echo call as "$0" "" "" echo where src is the root of the built documentation git checkout and - echo branch should be "master" or "1.7" or so + echo branch should be "main" or "1.7" or so exit 1 fi @@ -20,7 +20,7 @@ git checkout gh-pages mkdir -p ./"${target}" rm -rf ./"${target}"/* cp -r "${src}/docs/build/html/"* ./"$target" -if [ "${target}" == "master" ]; then +if [ "${target}" == "main" ]; then mkdir -p ./_static rm -rf ./_static/* cp -r "${src}/docs/build/html/_static/"* ./_static diff --git a/.circleci/config.yml b/.circleci/config.yml index 03f47e473ce..66c16edfe3e 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -29,7 +29,7 @@ commands: # command: | # set -ex # BRANCH=$(git rev-parse --abbrev-ref HEAD) -# if [[ "$BRANCH" != "master" ]]; then +# if [[ "$BRANCH" != "main" ]]; then # git fetch --force origin ${CIRCLE_BRANCH}/merge:merged/${CIRCLE_BRANCH} # git checkout "merged/$CIRCLE_BRANCH" # fi @@ -936,7 +936,7 @@ jobs: command: | set -ex tag=${CIRCLE_TAG:1:5} - VERSION=${tag:-master} + VERSION=${tag:-main} eval "$(./conda/bin/conda shell.bash hook)" conda activate ./env pushd docs @@ -982,7 +982,7 @@ jobs: # https://circleci.com/docs/2.0/configuration-reference/#checkout set -ex tag=${CIRCLE_TAG:1:5} - target=${tag:-master} + target=${tag:-main} ~/workspace/.circleci/build_docs/commit_docs.sh ~/workspace $target @@ -1159,7 +1159,7 @@ workflows: cu_version: cpu filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.6_cpu @@ -1168,7 +1168,7 @@ workflows: cu_version: cu102 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.6_cu102 @@ -1177,7 +1177,7 @@ workflows: cu_version: cu111 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.6_cu111 @@ -1186,7 +1186,7 @@ workflows: cu_version: cu113 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.6_cu113 @@ -1195,7 +1195,7 @@ workflows: cu_version: cpu filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.7_cpu @@ -1204,7 +1204,7 @@ workflows: cu_version: cu102 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.7_cu102 @@ -1213,7 +1213,7 @@ workflows: cu_version: cu111 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.7_cu111 @@ -1222,7 +1222,7 @@ workflows: cu_version: cu113 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.7_cu113 @@ -1231,7 +1231,7 @@ workflows: cu_version: cpu filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.8_cpu @@ -1240,7 +1240,7 @@ workflows: cu_version: cu102 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.8_cu102 @@ -1249,7 +1249,7 @@ workflows: cu_version: cu111 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.8_cu111 @@ -1258,7 +1258,7 @@ workflows: cu_version: cu113 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.8_cu113 @@ -1271,7 +1271,7 @@ workflows: cu_version: cu102 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.9_cu102 @@ -1280,7 +1280,7 @@ workflows: cu_version: cu111 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_wheel_py3.9_cu111 @@ -1413,7 +1413,7 @@ workflows: cu_version: cpu filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.6_cpu @@ -1422,7 +1422,7 @@ workflows: cu_version: cu102 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.6_cu102 @@ -1431,7 +1431,7 @@ workflows: cu_version: cu111 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.6_cu111 @@ -1440,7 +1440,7 @@ workflows: cu_version: cu113 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.6_cu113 @@ -1449,7 +1449,7 @@ workflows: cu_version: cpu filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.7_cpu @@ -1458,7 +1458,7 @@ workflows: cu_version: cu102 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.7_cu102 @@ -1467,7 +1467,7 @@ workflows: cu_version: cu111 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.7_cu111 @@ -1476,7 +1476,7 @@ workflows: cu_version: cu113 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.7_cu113 @@ -1485,7 +1485,7 @@ workflows: cu_version: cpu filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.8_cpu @@ -1494,7 +1494,7 @@ workflows: cu_version: cu102 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.8_cu102 @@ -1503,7 +1503,7 @@ workflows: cu_version: cu111 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.8_cu111 @@ -1512,7 +1512,7 @@ workflows: cu_version: cu113 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.8_cu113 @@ -1525,7 +1525,7 @@ workflows: cu_version: cu102 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.9_cu102 @@ -1534,7 +1534,7 @@ workflows: cu_version: cu111 filters: branches: - only: master + only: main tags: only: /v[0-9]+(\.[0-9]+)*-rc[0-9]+/ name: binary_win_conda_py3.9_cu111 @@ -1609,7 +1609,7 @@ workflows: filters: branches: only: - - master + - main - nightly name: unittest_linux_gpu_py3.6 python_version: '3.6' @@ -1618,7 +1618,7 @@ workflows: filters: branches: only: - - master + - main - nightly name: unittest_linux_gpu_py3.7 python_version: '3.7' @@ -1631,7 +1631,7 @@ workflows: filters: branches: only: - - master + - main - nightly name: unittest_linux_gpu_py3.9 python_version: '3.9' @@ -1656,7 +1656,7 @@ workflows: filters: branches: only: - - master + - main - nightly name: unittest_windows_gpu_py3.6 python_version: '3.6' @@ -1665,7 +1665,7 @@ workflows: filters: branches: only: - - master + - main - nightly name: unittest_windows_gpu_py3.7 python_version: '3.7' @@ -1678,7 +1678,7 @@ workflows: filters: branches: only: - - master + - main - nightly name: unittest_windows_gpu_py3.9 python_version: '3.9' @@ -4075,7 +4075,7 @@ workflows: filters: branches: only: - - master + - main jobs: - smoke_test_docker_image_build: context: org-member diff --git a/.circleci/config.yml.in b/.circleci/config.yml.in index 15cb7eb6a07..980332d3ea9 100644 --- a/.circleci/config.yml.in +++ b/.circleci/config.yml.in @@ -29,7 +29,7 @@ commands: # command: | # set -ex # BRANCH=$(git rev-parse --abbrev-ref HEAD) -# if [[ "$BRANCH" != "master" ]]; then +# if [[ "$BRANCH" != "main" ]]; then # git fetch --force origin ${CIRCLE_BRANCH}/merge:merged/${CIRCLE_BRANCH} # git checkout "merged/$CIRCLE_BRANCH" # fi @@ -936,7 +936,7 @@ jobs: command: | set -ex tag=${CIRCLE_TAG:1:5} - VERSION=${tag:-master} + VERSION=${tag:-main} eval "$(./conda/bin/conda shell.bash hook)" conda activate ./env pushd docs @@ -982,7 +982,7 @@ jobs: # https://circleci.com/docs/2.0/configuration-reference/#checkout set -ex tag=${CIRCLE_TAG:1:5} - target=${tag:-master} + target=${tag:-main} ~/workspace/.circleci/build_docs/commit_docs.sh ~/workspace $target @@ -1029,7 +1029,7 @@ workflows: filters: branches: only: - - master + - main jobs: - smoke_test_docker_image_build: context: org-member diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py index 157cabca433..7e2fa25cb9d 100755 --- a/.circleci/regenerate.py +++ b/.circleci/regenerate.py @@ -44,7 +44,7 @@ def build_workflows(prefix='', filter_branch=None, upload=False, indentation=6, if windows_latest_only and os_type == "win" and filter_branch is None and \ (python_version != python_versions[-1] or (cu_version not in [cu_versions[0], cu_versions[-1]])): - fb = "master" + fb = "main" if not fb and (os_type == 'linux' and cu_version == 'cpu' and btype == 'wheel' and @@ -241,7 +241,7 @@ def unittest_workflows(indentation=6): if device_type == 'gpu': if python_version != "3.8": - job['filters'] = gen_filter_branch_tree('master', 'nightly') + job['filters'] = gen_filter_branch_tree('main', 'nightly') job['cu_version'] = 'cu102' else: job['cu_version'] = 'cpu' diff --git a/.github/workflows/bandit.yml b/.github/workflows/bandit.yml index 93bae80f9bd..84200b438a9 100644 --- a/.github/workflows/bandit.yml +++ b/.github/workflows/bandit.yml @@ -4,7 +4,7 @@ name: Bandit on: pull_request: - branches: [ master ] + branches: [ main ] workflow_dispatch: diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index 3c8bc96a5bd..99460b11228 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -4,7 +4,7 @@ name: CodeQL on: pull_request: - branches: [ master ] + branches: [ main ] workflow_dispatch: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 75405c94a83..55880ae5d70 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -60,7 +60,7 @@ conda install libpng jpeg If you plan to modify the code or documentation, please follow the steps below: -1. Fork the repository and create your branch from `master`. +1. Fork the repository and create your branch from `main`. 2. If you have modified the code (new feature or bug-fix), please add unit tests. 3. If you have changed APIs, update the documentation. Make sure the documentation builds. 4. Ensure the test suite passes. diff --git a/README.rst b/README.rst index 2c6daee4cc2..35cef0c19df 100644 --- a/README.rst +++ b/README.rst @@ -21,7 +21,7 @@ supported Python versions. +--------------------------+--------------------------+---------------------------------+ | ``torch`` | ``torchvision`` | ``python`` | +==========================+==========================+=================================+ -| ``master`` / ``nightly`` | ``master`` / ``nightly`` | ``>=3.6`` | +| ``master`` / ``nightly`` | ``main`` / ``nightly`` | ``>=3.6`` | +--------------------------+--------------------------+---------------------------------+ | ``1.9.0`` | ``0.10.0`` | ``>=3.6`` | +--------------------------+--------------------------+---------------------------------+ @@ -76,7 +76,7 @@ From source: In case building TorchVision from source fails, install the nightly version of PyTorch following -the linked guide on the `contributing page `_ and retry the install. +the linked guide on the `contributing page `_ and retry the install. By default, GPU support is built if CUDA is found and ``torch.cuda.is_available()`` is true. It's possible to force building GPU support by setting ``FORCE_CUDA=1`` environment variable, diff --git a/android/gradle.properties b/android/gradle.properties index a8105544f30..9c5b8f61212 100644 --- a/android/gradle.properties +++ b/android/gradle.properties @@ -9,7 +9,7 @@ POM_SCM_URL=https://github.com/pytorch/vision.git POM_SCM_CONNECTION=scm:git:https://github.com/pytorch/vision POM_SCM_DEV_CONNECTION=scm:git:git@github.com:pytorch/vision.git POM_LICENSE_NAME=BSD 3-Clause -POM_LICENSE_URL=https://github.com/pytorch/vision/blob/master/LICENSE +POM_LICENSE_URL=https://github.com/pytorch/vision/blob/main/LICENSE POM_ISSUES_URL=https://github.com/pytorch/vision/issues POM_LICENSE_DIST=repo POM_DEVELOPER_ID=pytorch diff --git a/docs/source/conf.py b/docs/source/conf.py index 6bbb05c13c7..e8e17edf283 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -82,10 +82,10 @@ # # The short X.Y version. # TODO: change to [:2] at v1.0 -version = 'master (' + torchvision.__version__ + ' )' +version = 'main (' + torchvision.__version__ + ' )' # The full version, including alpha/beta/rc tags. # TODO: verify this works as expected -release = 'master' +release = 'main' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/test/test_cpp_models.py b/test/test_cpp_models.py index 6deb5d79739..2307051ff60 100644 --- a/test/test_cpp_models.py +++ b/test/test_cpp_models.py @@ -45,7 +45,7 @@ def read_image2(): @unittest.skipIf( sys.platform == "darwin" or True, - "C++ models are broken on OS X at the moment, and there's a BC breakage on master; " + "C++ models are broken on OS X at the moment, and there's a BC breakage on main; " "see https://github.com/pytorch/vision/issues/1191") class Tester(unittest.TestCase): pretrained = False diff --git a/torchvision/__init__.py b/torchvision/__init__.py index 3cbdda7af7f..a5a6f568151 100644 --- a/torchvision/__init__.py +++ b/torchvision/__init__.py @@ -66,7 +66,7 @@ def set_video_backend(backend): It generally decodes faster than :mod:`pyav`, but is perhaps less robust. .. note:: - Building with FFMPEG is disabled by default in the latest master. If you want to use the 'video_reader' + Building with FFMPEG is disabled by default in the latest `main`. If you want to use the 'video_reader' backend, please compile torchvision from source. """ global _video_backend