From 9ad1c71a1538fde9bf2318438e77ddc3c563f80b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Florian=20F=C3=BCrrutter?= <90468339+FlorianFuerrutter@users.noreply.github.com> Date: Mon, 26 Aug 2024 23:04:25 +0200 Subject: [PATCH] update to genQC 0.1.0 (#3) * changed LICENSE * add cudaq_export * added pre-trained load from huggingface_hub, fixed torch warning, updated examples, included cudaq export * updated index.ipynb and README.md * rm metadata * update RELEASES.md --- LICENSE.txt | 222 ++++++++++- README.md | 94 +++-- genQC/__init__.py | 2 +- genQC/_modidx.py | 40 ++ genQC/config_loader.py | 2 +- genQC/dataset/qc_dataset.py | 13 +- genQC/inference/export_cudaq.py | 240 ++++++++++++ genQC/inference/infer_compilation.py | 4 + genQC/inference/infer_misc.py | 4 + genQC/models/config_model.py | 2 +- genQC/pipeline/diffusion_pipeline.py | 14 +- genQC/platform/simulation/qcircuit_sim.py | 22 +- .../figure-commonmark/cell-3-output-2.png | Bin 9383 -> 13161 bytes .../config.yaml | 12 +- .../qc_unet_config_SRV_3to8_qubit/config.yaml | 4 +- settings.ini | 12 +- src/RELEASES.md | 33 ++ src/config_loader.ipynb | 2 +- src/dataset/qc_dataset.ipynb | 20 +- src/examples/0_hello_circuit.ipynb | 66 +++- src/examples/1_editing_and_masking.ipynb | 74 +++- src/examples/2_unitary_compilation.ipynb | 70 +++- src/examples/3_dataset_and_fineTune.ipynb | 266 +++++++------ src/index.ipynb | 91 +++-- src/inference/export_cudaq.ipynb | 364 ++++++++++++++++++ src/inference/infer_compilation.ipynb | 4 + src/inference/infer_misc.ipynb | 6 +- src/models/config_model.ipynb | 2 +- src/pipeline/diffusion_pipeline.ipynb | 16 +- src/platform/simulation/qcircuit_sim.ipynb | 44 ++- 30 files changed, 1431 insertions(+), 314 deletions(-) create mode 100644 genQC/inference/export_cudaq.py create mode 100644 src/inference/export_cudaq.ipynb diff --git a/LICENSE.txt b/LICENSE.txt index 40cf89b..261eeb9 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,21 +1,201 @@ -MIT License - -Copyright (c) 2023 Florian Fürrutter - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index d174668..80df770 100644 --- a/README.md +++ b/README.md @@ -6,20 +6,24 @@ awesome generative-models diffusion-models -python-3.9 -DOI +python-3.10 +DOI

Code repository for generating quantum circuits with diffusion models. -[\[Paper\]](https://arxiv.org/abs/2311.02041) +[\[Arxiv\]](https://arxiv.org/abs/2311.02041) [\[Demo\]](https://huggingface.co/spaces/Floki00/genQC) ![](https://github.com/FlorianFuerrutter/genQC/blob/main/src/assets/inference.png?raw=true) ## The codebase -All weights and functions are contained within this repo. For the CLIP -model weights we use the +The code contained within this repo allows the sampling of pre-trained +diffusion models and includes our pipeline to fine-tune and train models +from scratch. Pre-trained weights can be found on [Hugging +Face](https://huggingface.co/collections/Floki00/generative-quantum-circuits-6550e926c67f60a368b02bc3) +and can be downloaded automatically via our code (see minimal example). +For the CLIP model weights we use the [OpenCLIP](https://github.com/mlfoundations/open_clip) library, which will download (and cache) the CLIP model on first usage of our pipeline. In case you prefer reading a documentation rather than notebooks or code @@ -27,11 +31,10 @@ see [\[Documentation\]](https://florianfuerrutter.github.io/genQC/). The repo inlcudes: -1. `saves/` the configs and weights of the pre-trained models. -2. `genQC/` a full release of our used diffusion pipeline. -3. `src/examples` examples how to reproduce some figures of the +1. `genQC/` a full release of our used diffusion pipeline. +2. `src/examples` examples how to reproduce some figures of the [Paper](https://arxiv.org/abs/2311.02041). -4. `src/` the source notebooks for +3. `src/` the source notebooks for [nbdev](https://github.com/fastai/nbdev). ## Examples @@ -39,19 +42,18 @@ The repo inlcudes: #### Minimal example A minimal example to generate a 5 qubit circuit conditioned on a SRV of -$[1,1,1,2,2]$. You can try it out on your own with our demo -[\[huggingface-space\]](https://huggingface.co/spaces/Floki00/genQC), no -coding required. +$[1,1,1,2,2]$. You can try it out on your own with our +[\[Demo\]](https://huggingface.co/spaces/Floki00/genQC), no coding +required. ``` python from genQC.pipeline.diffusion_pipeline import DiffusionPipeline from genQC.inference.infer_srv import generate_srv_tensors, convert_tensors_to_srvs -model_path = "../saves/qc_unet_config_SRV_3to8_qubit/" -pipeline = DiffusionPipeline.from_config_file(model_path, "cpu") +pipeline = DiffusionPipeline.from_pretrained("Floki00/qc_srv_3to8qubit", "cpu") pipeline.scheduler.set_timesteps(20) -out_tensor = generate_srv_tensors(pipeline, "Generate SRV: [1,1,1,2,2]", samples=1, system_size=5, num_of_qubits=5, max_gates=16, g=7.5) +out_tensor = generate_srv_tensors(pipeline, "Generate SRV: [1,1,2,2,2]", samples=1, system_size=5, num_of_qubits=5, max_gates=16, g=10) qc_list, _, srv_list = convert_tensors_to_srvs(out_tensor, pipeline.gate_pool) ``` @@ -60,13 +62,13 @@ qc_list, _, srv_list = convert_tensors_to_srvs(out_tensor, pipeline.gate_pool) [INFO]: `genQC.models.frozen_open_clip.CachedFrozenOpenCLIPEmbedder`. No save_path` provided. No state dict loaded. ``` python -print(f"is SRV {srv_list[0]}") -qc_list[0].draw("mpl", style="clifford") +print(f"Circuit is SRV {srv_list[0]}") +qc_list[0].draw("mpl") ``` - is SRV [1, 1, 1, 2, 2] + Circuit is SRV [1, 1, 2, 2, 2] -![](index_files/figure-commonmark/cell-3-output-2.png) +![](https://github.com/FlorianFuerrutter/genQC/blob/main/index_files/figure-commonmark/cell-3-output-2.png?raw=true) #### Included examples @@ -91,39 +93,48 @@ Example notebooks are provided in the directory `src/examples/`. ## Installation -The installation of genQC is done via `pip` within a few minutes, +The installation of `genQC` is done via `pip` within a few minutes, depending on your downloading speed. -#### 1. Clone the repository +#### Method 1: pip install + +To install `genQC` just run: ``` sh -git clone https://github.com/FlorianFuerrutter/genQC.git -cd genQC +pip install genQC ``` -#### 2. Install genQC +Note, this will install missing requirements automatically. You may want +to install some of them manually beforehand, e.g. `torch` for specific +cuda support, see +[pytorch.org/get-started/locally](https://pytorch.org/get-started/locally/). + +**Requirements:** `genQC` depends on `python` (min. version 3.10) and +the libraries: `torch`, `numpy`, `matplotlib`, `scipy`, `pandas`, +`omegaconf`, `qiskit`, `tqdm`, `joblib`, `open_clip_torch`, +`ipywidgets`, `pylatexenc` and `huggingface_hub`. All can be installed +with `pip`. In `src/RELEASES.md` +[\[doc\]](https://florianfuerrutter.github.io/genQC/RELEASES.html) and +the release descriptions specific tested-on versions are listed. -This library is build using jupyter notebooks and -[nbdev](https://github.com/fastai/nbdev). To install the library use in -the clone directory: +#### Method 2: clone the repository + +To use the latest GitHub code you can clone the repository by running: ``` sh -pip install -e . +git clone https://github.com/FlorianFuerrutter/genQC.git +cd genQC ``` -Note, this will install missing requirements automatically. You may want -to install some of them manually beforehand, e.g. pytorch for specific -cuda support, see -[pytorch.org/get-started/locally](https://pytorch.org/get-started/locally/). +The library `genQC` is built using jupyter notebooks and +[`nbdev`](https://github.com/fastai/nbdev). To install the library use +in the clone directory: -**Requirements:** `genQC` depends on `python` (min. version 3.9) and the -libraries: `torch`, `numpy`, `matplotlib`, `scipy`, `pandas`, -`omegaconf`, `qiskit`, `tqdm`, `joblib`, `open_clip_torch`, `ipywidgets` -and `pylatexenc`. All can be installed with `pip`. In `src/RELEASES.md` -[\[doc\]](https://florianfuerrutter.github.io/genQC/src/RELEASES.html) -and the release descriptions specific tested-on versions are listed. +``` sh +pip install -e . +``` -#### 3. Run example +#### Test installation You can run the provided `0_hello_circuit` [\[doc\]](https://florianfuerrutter.github.io/genQC/examples/hello_circuit.html) @@ -133,8 +144,9 @@ this inference example notebook should run under half a minute. ## License -The code and weights in this repository are released under the MIT -License. +The code and weights in this repository are licensed under the [Apache +License +2.0](https://github.com/FlorianFuerrutter/genQC/blob/main/LICENSE.txt). ## BibTeX diff --git a/genQC/__init__.py b/genQC/__init__.py index a4e2017..3dc1f76 100644 --- a/genQC/__init__.py +++ b/genQC/__init__.py @@ -1 +1 @@ -__version__ = "0.1" +__version__ = "0.1.0" diff --git a/genQC/_modidx.py b/genQC/_modidx.py index 3047ed4..33f1bf7 100644 --- a/genQC/_modidx.py +++ b/genQC/_modidx.py @@ -112,6 +112,42 @@ 'genQC.dataset.qc_dataset.Qc_Config_Dataset_config': ( 'dataset/qc_dataset.html#qc_config_dataset_config', 'genQC/dataset/qc_dataset.py')}, 'genQC.imports': {}, + 'genQC.inference.export_cudaq': { 'genQC.inference.export_cudaq.CircuitInstruction': ( 'inference/export_cudaq.html#circuitinstruction', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitInstructions': ( 'inference/export_cudaq.html#circuitinstructions', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitInstructions.__init__': ( 'inference/export_cudaq.html#circuitinstructions.__init__', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitInstructions.__repr__': ( 'inference/export_cudaq.html#circuitinstructions.__repr__', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitInstructions.add_instruction': ( 'inference/export_cudaq.html#circuitinstructions.add_instruction', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitInstructions.data': ( 'inference/export_cudaq.html#circuitinstructions.data', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitInstructions.length': ( 'inference/export_cudaq.html#circuitinstructions.length', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitInstructions.max_gates': ( 'inference/export_cudaq.html#circuitinstructions.max_gates', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitInstructions.num_qubits': ( 'inference/export_cudaq.html#circuitinstructions.num_qubits', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitInstructions.print': ( 'inference/export_cudaq.html#circuitinstructions.print', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitsCudaqBackend': ( 'inference/export_cudaq.html#circuitscudaqbackend', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitsCudaqBackend._construct_kernel': ( 'inference/export_cudaq.html#circuitscudaqbackend._construct_kernel', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitsCudaqBackend.check_error_circuit': ( 'inference/export_cudaq.html#circuitscudaqbackend.check_error_circuit', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitsCudaqBackend.draw': ( 'inference/export_cudaq.html#circuitscudaqbackend.draw', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitsCudaqBackend.export_cudaq': ( 'inference/export_cudaq.html#circuitscudaqbackend.export_cudaq', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.CircuitsCudaqBackend.get_unitary': ( 'inference/export_cudaq.html#circuitscudaqbackend.get_unitary', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.genqc_to_cudaq': ( 'inference/export_cudaq.html#genqc_to_cudaq', + 'genQC/inference/export_cudaq.py'), + 'genQC.inference.export_cudaq.tensor_to_instructions': ( 'inference/export_cudaq.html#tensor_to_instructions', + 'genQC/inference/export_cudaq.py')}, 'genQC.inference.infer_compilation': { 'genQC.inference.infer_compilation.check_correct_gates': ( 'inference/infer_compilation.html#check_correct_gates', 'genQC/inference/infer_compilation.py'), 'genQC.inference.infer_compilation.check_correct_unitary_distance': ( 'inference/infer_compilation.html#check_correct_unitary_distance', @@ -386,6 +422,8 @@ 'genQC/pipeline/diffusion_pipeline.py'), 'genQC.pipeline.diffusion_pipeline.DiffusionPipeline.from_config_file': ( 'pipeline/diffusion_pipeline.html#diffusionpipeline.from_config_file', 'genQC/pipeline/diffusion_pipeline.py'), + 'genQC.pipeline.diffusion_pipeline.DiffusionPipeline.from_pretrained': ( 'pipeline/diffusion_pipeline.html#diffusionpipeline.from_pretrained', + 'genQC/pipeline/diffusion_pipeline.py'), 'genQC.pipeline.diffusion_pipeline.DiffusionPipeline.get_guidance_condition': ( 'pipeline/diffusion_pipeline.html#diffusionpipeline.get_guidance_condition', 'genQC/pipeline/diffusion_pipeline.py'), 'genQC.pipeline.diffusion_pipeline.DiffusionPipeline.latent_filling': ( 'pipeline/diffusion_pipeline.html#diffusionpipeline.latent_filling', @@ -496,6 +534,8 @@ 'genQC/platform/simulation/qcircuit_sim.py'), 'genQC.platform.simulation.qcircuit_sim.get_number_of_gate_params': ( 'platform/simulation/qcircuit_sim.html#get_number_of_gate_params', 'genQC/platform/simulation/qcircuit_sim.py'), + 'genQC.platform.simulation.qcircuit_sim.instruction_name_to_qiskit_gate': ( 'platform/simulation/qcircuit_sim.html#instruction_name_to_qiskit_gate', + 'genQC/platform/simulation/qcircuit_sim.py'), 'genQC.platform.simulation.qcircuit_sim.optimize_circuit': ( 'platform/simulation/qcircuit_sim.html#optimize_circuit', 'genQC/platform/simulation/qcircuit_sim.py'), 'genQC.platform.simulation.qcircuit_sim.plot_svr_stat': ( 'platform/simulation/qcircuit_sim.html#plot_svr_stat', diff --git a/genQC/config_loader.py b/genQC/config_loader.py index 1c037d9..8db4012 100644 --- a/genQC/config_loader.py +++ b/genQC/config_loader.py @@ -50,7 +50,7 @@ def instantiate_from_config(config): def load_model_from_config(config, ckpt, device): print(f"Loading model from {ckpt}") - pl_sd = torch.load(ckpt, map_location=torch.device(device).type) + pl_sd = torch.load(ckpt, map_location=torch.device(device).type, weights_only=True) model = instantiate_from_config(config.model) diff --git a/genQC/dataset/qc_dataset.py b/genQC/dataset/qc_dataset.py index 4d9fa67..077004d 100644 --- a/genQC/dataset/qc_dataset.py +++ b/genQC/dataset/qc_dataset.py @@ -9,7 +9,7 @@ from ..config_loader import * from .dataset_helper import * from ..platform.qcircuit_dataset_construction import decode_circuit -from ..platform.simulation.qcircuit_sim import schmidt_rank_vector +from ..platform.simulation.qcircuit_sim import schmidt_rank_vector, instruction_name_to_qiskit_gate import qiskit.quantum_info as qi # %% ../../src/dataset/qc_dataset.ipynb 4 @@ -32,12 +32,12 @@ class Qc_Config_Dataset(Config_Dataset): def __init__(self, device: torch.device=torch.device("cpu"), **parameters): super().__init__(device, **parameters) - self.gate_pool = [get_obj_from_str(gate) for gate in parameters["gate_pool"]] + self.gate_pool = parameters["gate_pool"] #[get_obj_from_str(gate) for gate in parameters["gate_pool"]] @property def params_config(self): params_config = super().params_config - params_config["gate_pool"] = [class_to_str(gate) for gate in params_config["gate_pool"]] + #params_config["gate_pool"] = [class_to_str(gate) for gate in params_config["gate_pool"]] params_config = Qc_Config_Dataset_config(**params_config) return params_config @@ -129,8 +129,13 @@ def plot_example(self): params = None if hasattr(self, "params"): params=self.params[0] + + if isinstance(self.gate_pool[0], str): + gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in self.gate_pool] + else: + gate_pool = self.gate_pool - qc = decode_circuit(enc_tensor, self.gate_pool, params_tensor=params) + qc = decode_circuit(enc_tensor, gate_pool, params_tensor=params) t = self.store_dict["y"] if t == "tensor" : label = self.y[0].cpu().tolist() diff --git a/genQC/inference/export_cudaq.py b/genQC/inference/export_cudaq.py new file mode 100644 index 0000000..d0bc009 --- /dev/null +++ b/genQC/inference/export_cudaq.py @@ -0,0 +1,240 @@ +# AUTOGENERATED! DO NOT EDIT! File to edit: ../../src/inference/export_cudaq.ipynb. + +# %% auto 0 +__all__ = ['backend', 'CircuitInstruction', 'CircuitInstructions', 'CircuitsCudaqBackend', 'tensor_to_instructions', + 'genqc_to_cudaq'] + +# %% ../../src/inference/export_cudaq.ipynb 2 +from ..imports import * +from typing import Sequence, List, Optional +import cudaq + +# %% ../../src/inference/export_cudaq.ipynb 4 +@dataclass +class CircuitInstruction(): + name: str + control_nodes: Sequence[int] + target_nodes: Sequence[int] + params: Sequence[float] + +# %% ../../src/inference/export_cudaq.ipynb 5 +class CircuitInstructions(): + def __init__(self, tensor_shape: torch.Size) -> None: + assert len(tensor_shape) == 2 # ... [qubits, time] + self.tensor_shape = tensor_shape + self._instructions = [] + self.instruction_names_set = set() + + def add_instruction(self, + name: str, + control_nodes: Sequence[int], + target_nodes: Sequence[int], + params: Sequence[float]) -> None: + self.instruction_names_set.add(name) + self._instructions.append(CircuitInstruction(name, control_nodes, target_nodes, params)) + + @property + def data(self) -> List[CircuitInstruction]: return self._instructions + + @property + def length(self) -> int: return len(self._instructions) + + @property + def num_qubits(self) -> int: return self.tensor_shape[0] + + @property + def max_gates(self) -> int: return self.tensor_shape[1] + + def __repr__(self) -> str: return str(self._instructions) + + def print(self) -> None: + for instruction in self.data: + print(instruction) + +# %% ../../src/inference/export_cudaq.ipynb 7 +class CircuitsCudaqBackend(): + + BASIC_BACKEND_TYPE = type[cudaq.kernel] + + # Has to match with insides of belows kernel + KERNEL_VOCABULARY = {"h":1, "cx":2, "z":3, "x":4, "y":5, "ccx":6, "swap":7} + + def _construct_kernel(self, + gate_list: List[str], + target_1_nodes_list: List[int], + target_2_nodes_list: List[int], + control_1_nodes_list: List[int], + control_2_nodes_list: List[int] + ) -> cudaq.kernel: + """Construct a `cudaq.kernel` from provided paramters.""" + + num_gates = len(gate_list) + gate_list = [self.KERNEL_VOCABULARY[g] for g in gate_list] + + # Note: `@cudaq.kernel` decorator has a overhead of 20ms, regardless of the for-loop inside + + @cudaq.kernel + def place_gate_kernel(gate: int, + qvector: cudaq.qview, + target_1: int, + target_2: int, + control_1: int, + control_2: int): + if gate == 1: h(qvector[target_1]) + elif gate == 2: cx(qvector[control_1], qvector[target_1]) + elif gate == 3: z(qvector[target_1]) + elif gate == 4: x(qvector[target_1]) + elif gate == 5: y(qvector[target_1]) + elif gate == 6: x.ctrl(qvector[control_1], qvector[control_2], qvector[target_1]) + elif gate == 7: swap(qvector[target_1], qvector[target_2]) + + @cudaq.kernel + def kernel(input_state: List[complex]): + qvector = cudaq.qvector(input_state) + for i in range(num_gates): + place_gate_kernel(gate_list[i], qvector, target_1_nodes_list[i], target_2_nodes_list[i], control_1_nodes_list[i], control_2_nodes_list[i]) + + return kernel + + def check_error_circuit(self, + gate: str, + num_target_nodes: int, + num_control_nodes: int) -> bool: + """Check number of connections of given gate. Used to check for error circuits.""" + + if gate not in self.KERNEL_VOCABULARY: + raise NotImplementedError(f"Unknown gate {gate}, not in `self.KERNEL_VOCABULARY`.") + + if gate in ["h", "z", "x", "y"]: + if num_target_nodes != 1 or num_control_nodes !=0: return False + + elif gate in ["cx"]: + if num_target_nodes != 1 or num_control_nodes !=1: return False + + elif gate in ["ccx"]: + if num_target_nodes != 1 or num_control_nodes !=2: return False + + elif gate in ["swap"]: + if num_target_nodes != 2 or num_control_nodes !=0: return False + + else: + raise NotImplementedError(f"Unknown gate {gate}, implemetation is faulty!") + + return True + + + def export_cudaq(self, instructions: CircuitInstructions) -> cudaq.kernel: + """Convert given genQC `CircuitInstructions` to a `cudaq.kernel`.""" + + # num_qubits = instructions.num_qubits + num_gates = instructions.length + + # @cudaq.kernel can only take list[int] and no str directly + # -> we have to map everything to list[int] + # set default value to 9999 so an error wil be raised if we have a faulty tensor encoding + + gate_list = [] + target_1_nodes_list = [9999] * num_gates + target_2_nodes_list = [9999] * num_gates + control_1_nodes_list = [9999] * num_gates + control_2_nodes_list = [9999] * num_gates + + for i, instruction in enumerate(instructions.data): + + gate = instruction.name.lower() + control_nodes = instruction.control_nodes + target_nodes = instruction.target_nodes + + if len(instruction.params) > 0: + raise NotImplementedError(f"Only support non parametrized gates currently.") + + num_target_nodes = len(target_nodes) + num_control_nodes = len(control_nodes) + + if not self.check_error_circuit(gate, num_target_nodes, num_control_nodes): + return None + + gate_list.append(gate) + + if num_target_nodes > 0: + target_1_nodes_list[i] = target_nodes[0] + if num_target_nodes > 1: + target_2_nodes_list[i] = target_nodes[1] + + if num_control_nodes > 0: + control_1_nodes_list[i] = control_nodes[0] + if num_control_nodes > 1: + control_2_nodes_list[i] = control_nodes[1] + + #-------------------- + kernel= self._construct_kernel(gate_list, target_1_nodes_list, target_2_nodes_list, control_1_nodes_list, control_2_nodes_list) + return kernel + + def get_unitary(self, kernel: cudaq.kernel, num_qubits: int) -> np.ndarray: + """Return the unitary matrix of a `cudaq.kernel`. Currently relies on simulation, could change in future releases of cudaq.""" + + N = 2**num_qubits + U = np.zeros((N, N), dtype=np.complex128) + + for j in range(N): + state_j = np.zeros((N), dtype=np.complex128) + state_j[j] = 1 + + U[:, j] = np.array(cudaq.get_state(kernel, state_j), copy=False) + + return U + + def draw(self, kernel: cudaq.kernel, num_qubits: int, **kwargs) -> None: + """Draw the given `cudaq.kernel` using cudaq.""" + c = [0] * (2**num_qubits) + c[0] = 1 + print(cudaq.draw(kernel, c)) + +# %% ../../src/inference/export_cudaq.ipynb 9 +def tensor_to_instructions(tensor: torch.Tensor, + vocabulary_inverse: dict, + params_tensor: Optional[torch.Tensor] = None, + params_4pi_normalization: bool = True, + sign_labels: dict = {"control_nodes":-1, "target_nodes":+1}) -> CircuitInstructions: + """Convert a given `torch.Tensor` to `CircuitInstructions`.""" + + assert tensor.dim() == 2, f"{tensor.shape=}" + num_of_qubits, time = tensor.shape + + instructions = CircuitInstructions(tensor_shape=tensor.shape) + + for t in range(time): + enc_time_slice = tensor[:, t] # contains all bits at time t + + for gate_index, gate in vocabulary_inverse.items(): + + target_nodes = (enc_time_slice == (sign_labels["target_nodes"] * gate_index)).nonzero(as_tuple=True)[0] + control_nodes = (enc_time_slice == (sign_labels["control_nodes"] * gate_index)).nonzero(as_tuple=True)[0] + + if target_nodes.nelement() > 0: + params = [] + if exists(params_tensor): + params = params_tensor[:, t] + if params_4pi_normalization: + params = (params+1.0) * 2.0*np.pi # [-1, 1] to [0, 4pi] + params = params.tolist() + + instructions.add_instruction(gate, control_nodes.tolist(), target_nodes.tolist(), params) + + break #break on first hit, per def only one gate allowed per t + + elif control_nodes.nelement() > 0: # no target but control means error + raise RuntimeError("target_nodes.nelement() <= 0 but control_nodes.nelement() > 0") + + #else we are fine with tensors that have time steps with no action! + + return instructions + +# %% ../../src/inference/export_cudaq.ipynb 10 +backend = CircuitsCudaqBackend() + +def genqc_to_cudaq(tensor: torch.Tensor, vocabulary_inverse: dict) -> cudaq.kernel: + """Convert given `torch.Tensor` to a `cudaq.kernel`.""" + instructions = tensor_to_instructions(tensor, vocabulary_inverse) + kernel = backend.export_cudaq(instructions) + return kernel diff --git a/genQC/inference/infer_compilation.py b/genQC/inference/infer_compilation.py index e90de66..23fae46 100644 --- a/genQC/inference/infer_compilation.py +++ b/genQC/inference/infer_compilation.py @@ -12,6 +12,7 @@ from .infer_gate_hist import get_tensor_gate_length import genQC.platform.qcircuit_dataset_construction as data_con from ..dataset.dataset_helper import check_duplicates_in_dataset, uniquify_tensor_dataset, shuffle_tensor_dataset +from ..platform.simulation.qcircuit_sim import instruction_name_to_qiskit_gate from joblib import Parallel, delayed import qiskit.quantum_info as qi @@ -162,6 +163,9 @@ def check_correct_unitary_distance(qc, target_U, norms): # %% ../../src/inference/infer_compilation.ipynb 13 def get_gate_and_U_acc(out_tensor, allowed_gate_clrs, U, gate_pool, num_of_qubits, max_gates, norms=[], no_bar=True): + if isinstance(gate_pool[0], str): + gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in gate_pool] + #------------------------- #decode qc_list, error_cnt = convert_tensors_to_circuits(out_tensor, gate_pool) diff --git a/genQC/inference/infer_misc.py b/genQC/inference/infer_misc.py index 58ada17..d6caf85 100644 --- a/genQC/inference/infer_misc.py +++ b/genQC/inference/infer_misc.py @@ -6,6 +6,7 @@ # %% ../../src/inference/infer_misc.ipynb 2 from ..imports import * from ..platform.qcircuit_dataset_construction import decode_circuit, gate_pool_to_gate_classes +from ..platform.simulation.qcircuit_sim import instruction_name_to_qiskit_gate # %% ../../src/inference/infer_misc.ipynb 4 def get_rnd_gatepool_subset(gate_pool, min_sub_gate_pool_cnt=2): @@ -22,6 +23,9 @@ def get_rnd_gatepool_subset(gate_pool, min_sub_gate_pool_cnt=2): # %% ../../src/inference/infer_misc.ipynb 6 def convert_tensors_to_circuits(out_tensor, gate_pool, params_tensor=None, place_barrier=False): + if isinstance(gate_pool[0], str): + gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in gate_pool] + error_cnt = 0 qc_list = [] diff --git a/genQC/models/config_model.py b/genQC/models/config_model.py index 9aaa6a6..6b39be8 100644 --- a/genQC/models/config_model.py +++ b/genQC/models/config_model.py @@ -58,7 +58,7 @@ def from_config(config, device: torch.device, save_path: str=None): print("[INFO]: Found no key `save_path` path in config.") if exists(save_path): - model.load_state_dict(torch.load(save_path, map_location=torch.device(device).type), strict=True) + model.load_state_dict(torch.load(save_path, map_location=torch.device(device).type, weights_only=True), strict=True) else: print(f"[INFO]: `{class_to_str(type(model))}`. No save_path` provided. No state dict loaded.") diff --git a/genQC/pipeline/diffusion_pipeline.py b/genQC/pipeline/diffusion_pipeline.py index 3cf5a27..d2fb1c7 100644 --- a/genQC/pipeline/diffusion_pipeline.py +++ b/genQC/pipeline/diffusion_pipeline.py @@ -10,6 +10,8 @@ from ..config_loader import * from ..models.config_model import Config_Model +from huggingface_hub import snapshot_download + # %% ../../src/pipeline/diffusion_pipeline.ipynb 3 class DiffusionPipeline(Pipeline): """A `Pipeline` for diffusion models. Implements train and inference functions. Diffusion parameters are defined inside a `Scheduler` object.""" @@ -96,11 +98,19 @@ def from_config_file(config_path, device: torch.device): pipeline = instantiate_from_config(config) if exists(pipeline.add_config): - pipeline.gate_pool = [get_obj_from_str(gate) for gate in add_config["dataset"]["params"]["gate_pool"]] + pipeline.gate_pool = [gate for gate in add_config["dataset"]["params"]["gate_pool"]] pipeline.add_config = add_config return pipeline - + + + @classmethod + def from_pretrained(cls, repo_id: str, device: torch.device, **kwargs): + """Load a model pipeline directly from Huggingface.""" + model_path = snapshot_download(repo_id=repo_id, repo_type="model", allow_patterns=["*.pt", "*.yaml", "*.safetensors"], **kwargs) + pipeline = cls.from_config_file(model_path+"/", device) + return pipeline + #------------------------------------ # Inference functions diff --git a/genQC/platform/simulation/qcircuit_sim.py b/genQC/platform/simulation/qcircuit_sim.py index 03dde97..3084670 100644 --- a/genQC/platform/simulation/qcircuit_sim.py +++ b/genQC/platform/simulation/qcircuit_sim.py @@ -1,11 +1,12 @@ # AUTOGENERATED! DO NOT EDIT! File to edit: ../../../src/platform/simulation/qcircuit_sim.ipynb. # %% auto 0 -__all__ = ['get_number_of_gate_params', 'gate_pool_to_gate_classes', 'schmidt_rank_vector', 'rnd_circuit', 'optimize_circuit', - 'plot_svr_stat'] +__all__ = ['get_number_of_gate_params', 'gate_pool_to_gate_classes', 'instruction_name_to_qiskit_gate', 'schmidt_rank_vector', + 'rnd_circuit', 'optimize_circuit', 'plot_svr_stat'] # %% ../../../src/platform/simulation/qcircuit_sim.ipynb 2 from ...imports import * +from ...config_loader import * import qiskit.quantum_info as qi from qiskit import QuantumCircuit, transpile @@ -29,6 +30,15 @@ def gate_pool_to_gate_classes(gate_pool: list[Gate]): return classes # %% ../../../src/platform/simulation/qcircuit_sim.ipynb 6 +def instruction_name_to_qiskit_gate(name: str) -> Gate: + match name: + case "swap": name = "Swap" + case "cp": name = "CPhase" + case _: name = name.upper() + + return get_obj_from_str(f"qiskit.circuit.library.standard_gates.{name}Gate") + +# %% ../../../src/platform/simulation/qcircuit_sim.ipynb 7 def schmidt_rank_vector(densityMatrix: qi.DensityMatrix): """Return the SRV of a `qi.DensityMatrix`.""" systems_cnt = len(densityMatrix.dims()) @@ -39,12 +49,12 @@ def schmidt_rank_vector(densityMatrix: qi.DensityMatrix): trace = list(total_trace - {i}) red_densityMatrix = qi.partial_trace(densityMatrix, trace) # r = np.count_nonzero(np.linalg.eigvals(red_densityMatrix) > 1e-14) # was slower during testing - r = np.linalg.matrix_rank(red_densityMatrix, hermitian=True) + r = np.linalg.matrix_rank(red_densityMatrix, hermitian=True).item() rank_vector.append(r) return rank_vector -# %% ../../../src/platform/simulation/qcircuit_sim.ipynb 7 +# %% ../../../src/platform/simulation/qcircuit_sim.ipynb 8 def rnd_circuit(num_of_qubits, num_of_gates, gate_pool: list[Gate], rng): """Create a random circuit.""" qc = QuantumCircuit(num_of_qubits) @@ -62,7 +72,7 @@ def rnd_circuit(num_of_qubits, num_of_gates, gate_pool: list[Gate], rng): return qc -# %% ../../../src/platform/simulation/qcircuit_sim.ipynb 8 +# %% ../../../src/platform/simulation/qcircuit_sim.ipynb 9 def optimize_circuit(qc: QuantumCircuit, gate_pool: list[Gate], optimization_level=2): """Use qiskit.compiler.transpile to optimize a circuit.""" basis_gates = gate_pool_to_gate_classes(gate_pool).keys() @@ -77,7 +87,7 @@ def optimize_circuit(qc: QuantumCircuit, gate_pool: list[Gate], optimization_lev return qc -# %% ../../../src/platform/simulation/qcircuit_sim.ipynb 10 +# %% ../../../src/platform/simulation/qcircuit_sim.ipynb 11 def plot_svr_stat(num_of_qubits, min_gates, max_gates, gs, samples, sort=False, opt=True, rng=np.random.default_rng()): svr_list = list() for i in range(samples): diff --git a/index_files/figure-commonmark/cell-3-output-2.png b/index_files/figure-commonmark/cell-3-output-2.png index 3d35113fc29ecc18117a0e6d3f55dbe162552754..23dd0f38f63474bbe7ce674ac016562c03e279e5 100644 GIT binary patch literal 13161 zcmdtJbx>SUx2N4mfS~CFf;#~M1eXxp-5r9a0|a*nF2RCJ(BMgc;MTYW4<4MxH8=!^ z0JC}T%sY2x?)|%Y=L=Zvoh;a>l~HEEKY8dNtLF@X;F;e4AQgz@zk@(HC*>r?G(A4=&HKF8 ze0wW$J2l|I<^KqIJ3G6;KhQ~os&LPWD9yaUV4<|I2JW_Lwf@thv7*?G>z6GbSO08f z`VFh8eu;Qe(pO7!Ms*BExm>Eqm&iYb1_lrC{2Jmr2C=!EH(oVm#)RTg4)IUbFD#|L z&)E6A^I0uLk^V_oSQzTp#0CfrP42!)EEF0yLIjhPq~k^-hC&}kiAhUJiof}P_i4gH zEGnlDliIXHmOCRO1)=JN{wi!bsHew);yJMm+%((tXvBT-eXt+y^`B%BdXXKMum0+4 z27fb`NO$$Tu3P>V28j&citx%0HMJ~{k(_v}=FX@{pCGqQ6K2z8!ftkKA+lOijr>o=0y_vo7@nV)MYC>&V4B7Aq zy>GARA|vpsFX7?6ZbUG;>cK36WxQe7jP3P;QR(#cK6xDnO`Dz1Beiq(URhm{td_78 zy{z1d!kzplRb$`8o-92qDMiZLusu*u52J4BmCM4d5n#A{%ul=UNJ*TND6;M#l_f$P z8^Vp0iLt%;K*`@C8G(PR9yDQ3R#PoW;}lB)g}utaeg6D81`bZJeu=b$1A7viarD)d zCyP-N5oRzlDX&dzgJNY{C^3WM(r^CI)7rCULHtjzU3C56=A5aAwr&r2zYv)0ZDf^S zR?%o0Std5H(4@!S)W^@wy;e-+e4tHOBaQ3vEA+5&SJTsqs|q} zNbKW;0`c7agwrs^{4r{NeqwMCX6<58DX9lePEOeqR&i-*9|r~$VHOq=IjU5zUg>W; z6-HFXY{hDLv@hS--R@d&b8nL`l+~meV5iiZ;oVkmEV)vnK}tMnZ;#(|NH12Q7*jAN zWQ)@vVqIfj7{IaLzJ06P;PQO3!~osi{-CH|U0warlP4(6MlrFmk1j3_k0f(1en*(e zU6mBtwwDI2crUTNw-XUYI5&))Zj+wY?NpS-X=FQ#YDvNw5LC=8ERvp{uaJ?E%gqN# zs&+cNx{x4dW@fWZzT4x^71Mcf78VwM&o}ZtWqlonMMx%sOm&RAsc;^^{B|+vrG7yN zx`49V`J9k%b(uTaz?XVGjw|lt$Bu^0tYK7EtOVQ#_f(I9y8YiOIEw|^+QNlbhO>^ zi}s0$iNn*=W;-umU*DIGD<39mVr_}=Gk;s!6ix8BOfSSkQ~6otg|2WMZV#BpNWPn@ zp2F)g$}F&&P%kcJeH)JXpChOg0emDO6VXm zqobQa(^FM_R9RWc?z*j6FkzLLnAkQvjF--9D{gL1|MBBT$ZJX%6bdyj3nswFr=p?x zL0zNK)7>e1{x(_t%r@Njmcqk%;)S7+h*=oh?N$Cu0c}Z`NF@&Ek`v=w7%UqOe_B&h z^U~$_qa+r+K(Nz+1Be!CnyvN5+0NeI7t^hNcN2w|5QpC*)cAyiwEX-tqaw(u73}=@ zOrLU(32be2dvSeUDMm(9Et*wt9Pe+rVDJVZR`Ff4RUjkF^x1NJfUSxE`bPH!X&4 zN>-;5(FKYOkwrg2SeUIhs~tAx*s4ZFj4kCQKXE);s%C=LOO|DFIudHzHkDGGqG1$fRtgxjW*?x?ny>gOL z7_^T7)LBB2Ts+(+KZX?>kGzw)K8eFY0r%{ftk6NYoa9+M6|Ei-?=&I0h+?;Ka(DYg z*VTMOSr!Sxs2=AX8^a2kz3_UVEUJ*xBu!sJQPE?S7vWt$-sN~$?>ua3-a{QSw7hF? znl5!h|Nf430vaEjKYXOy(}QP9bd#l_jw*MDb!XY+_Y3a8;}_7mQp7GDaFJNwmV z#nE9l!Bf3qVX~IkoHR6#NrEE7!aj6U(bCZ5aQvTtx?a{0l4`-3>c3%L*#G;LyE`L3 zW?>N(F?3%Da_B<^MN6%+vJ3G&qbV%<&6)h-0L7|i{B7)Kj57+zg>WpU%8SSUKC`~G zj+5>F$-Hx9X!k4{e>>Kz3Ga)yeg_4`_5-}N-7h_e%Jc)%=r@zGhHPm8gbl`zCo1k;hK@)=`6H*+m;Q$He1bF%WpjY zL8RGbhO-=mCQbVi~?TFr9 z*=ji4?B?n;h06jL6AKFoQc+Ry>!}rkm+L17M8$(Ld`f$F@>+5O_Eps+l%m}ItBp|1 zzYe=i64#18=M14|7R=swy;;RU|8a5)Z?JjenbUFo_cs5ycdL8cm&PmZKLlkLvbxXJ zrnHPKJ1rJJCw)1nt<8x2Vw@Y@%i9ayd0b{@w7);3Sg)#k_m!igBg8)?C8em$@L|h` z52$s=*8P1C$$tvq1?5<)?3UM{)PMe{G9&{Z)>l+e2pYBQ{CjykTBO5Pwd3L80kI^7 zF{osA!fg@kR^yCy_4Uhb0VueIQwt>6Xus3azp@6|WDBV5|1J$Qwz_X!@+TrayY9uxdFQ}Ag_l_ zcCxnJi_25T8lv7;o-^Tjb2i68!TVH%x*#=n8ieW@IcNm zT5HH_5xp)X#V{#@x1^)+Gz}6{H$;&hMEK6{xYG@P(6_&42>+XAd4MGP z`8v*$8g_{OHT z-S{~hn@mu^ zg$F@y#)C=2#lDSNsu~(bef~@a=<2MXG&dKSS*H{gA}J$-@DUG{&a0@43MH2gIU8^F z^P`TIWY%ONLSocnLd7Mba^=?^t$#kc@QI?NG^Yce2EnTbI)x?hd3^v5A~)E_c4PjFDEC*2!P(oiiuwNbJ*db14Pu#jrS>wE+k|B&jV+f zISkuDhnewl)SF!?w}NhAz%bdWMPFI-G{ofIy)>Bd7geJA8U5-0ic@$mLwJ2`Za0ja z^O4K68oXEouilFlSxX*v#uRUhY+kcHD&`Og_?dKn&MQrLYtl^;nXK}1asjQaBJv6f z9A=#ul2TICEG*a$A3h}FgkjJtra-dyPC00xol+MHlkQmyRz)guk7pu4!@$Uhp{J*p z^2(KI+=@qDUVdqFGgK*^mzs;~iIkKS1azdC7f_`5Q*uJ$HZSJBt=_Y78i=H%Bo!^~ zYQxmd_O`0JI`UWb@Hko-c~#=LQ?roEHMVq)B1=kT%%XS3K4-J6<1;5akjIRad1JNN&4+Dp~n-;XkK`>so`$~^VvJXb2>aKYUG?n!srvYhbw5enOaHbj%r1^R*z~z$$lA|P^t(v z(@j$QK=tI|2|}-a>BU0BO=b>g9s8rsn%mDm)@IiKgX?|~#(ni%3)}taOcXBpP5t@N z0@f<~Rpwru>R3(avQd3seHCeb+3DeDj5&VaY%QM0{NgcS)33)M{~g4(P)GhG**hR@ zHc5HvU^isT`1*!iqT-e4|5Vze zK#PcEEvV&|;<1k0xDPgGE=AjfR(PDLuX?f=j1U~|-xN~`LZ3f13cQ9lvAGf$ZVsXU zjE@Tc7f`?m8jyRAk11M`)PPOXcPJ!k*rgHie~ajP{e{&(Y`5Q%JE!jCaWqA%|F*&l zuuG^m7P14B=99YU$WKlme-@unQ%&NqyJ@vXsFPPJcHajWWtN7KZATQai_|q1eqpUJ zxJQ^TQ>1Yf2iOa1)HpFyf8S2ks$ercR9Bpz(P9?)>?GR$64w7@y-#3 z=LMbq;g!q-kN3_LKZhm^#O;1;tv3QdgAk=&-8I6J1lv!bv9q=>O7ns+ zCHLaGw%OTFA>})<$%N*!EblKZ*9r6RR_YQ6Tl1UNJp?jfKGi5CPrzx$ja8!qeah(} zpgoQQMX=vic$lffz(7S;gJx#tNP|cBQXVd4TRelFIpcv^-@~S>pV`6Q8-{v%5<<)P z%4al}Hw~h4uPEu;#&X^6cQZzQ15orT*?``<*4~qFj(D4&STcit;`wCXum zmRX3V*X0%Yy<;LF!K~4bT3Rw;F>WCP)l|31g99J)0k6$8m1`=Dfj;5kHLlK5J0b3p zxDpp+$;=SzqdW^1l7-W^T->|A?kycxMb?&G&i1pnB-ncPJNu8l@5bJTo}RCUGyN6F zn>M}C6F=jV+}zkO`RQmo^n zYiO+T>#>c~1~j1%CB(<@H&<^~HEO9`vSYX(=x>#j^q6wLI%}AaG5#Cq%KUigpvcX# z6}HfQA|85v36>w&po#D?gFCMG!-{3@?PFhGA2_gXh1mlpCZ^bg1QfuTMtzTbtYwgIJn(xjpG7=N< zJ3Bi?%cf}Q=um})&B)_4dVG5YVx&|Kg4#ze3#4@BKiqSAM9mA_g5qo3%^g*}2|BsO zRK2h9CknQ5mv>8%*Zwv^#pUIXwzjq~FfiKEc&rCXpAZtFL&Czt>#t@(v+sC5@BU^a zTkP=Ur1NmO<7iw%C8xA>h}t#5w%F%@p?bSfIK6E5wUF>Mb+_fJY=ClQi!-JxuEtiQrylt2L^}MXOC*MoiV9pNU^rLeHxl3xd!cu~+ugP>fS*!`1iqZJ5 z9U9KVZ5X_O*8A^}G@4vsBwr<~=#E0fR}kompv&XUH+Q!;M0|FiGnnWNF1N4$ux6GlWu7;z3?|ofT`qy}kafY{-iZ?KOJZzaZ*$5H}Kq&K>K#P;G~Abpu*tTJ254)aF1so@)_NzUg`| z>Vp&CB7~t`kxzE>ogajV`z5~o^jTV^bYA;%M`(!^GlHt9to85GKzFxvRsY!7SkBni z(%xQFdl0&NU5S0mB^u-r6l$vVLce5k`w<=Ui7>i{-qcAG9N)6A+Exh8TZi-yMjb5u zC!-E!p={TSD0~Mbn{vmgD6@+~u>RFw&R)yFE7msl9XE-ljt(sY1Nxip$ahu6|B6@L zJybepsw^t3CYTg61!uOs2DwS1wDx*mm3&9jME37dC2>gtApJ5cfSOX%|QGQ@v(*M>#69P(;@J>n~Qu!f-_ z`8Sm;Ts}U&rtAGi?J2W8ht%S8gcR{pzps79Nppd%FAVJRKiX`5b@%OjQkJ%uKPy1s zBDJ+&e;-1WltSB|h*Z|uyYmtJRHg__FS;Cs@OO{Pv~+Ijy){ps@uDQ+V?teQv2L+1 zymwEamHm5jqo%L_5lSmf#l(bZYHBJgE87-JEx~U30~KOh7GqdcQ2_<}$V=C4e7C*X z;I=kVnIx6@6Ht>_^o{pQf5fMD>}p2Yc1fYhPP)5z*oUM%iFKlktvtBDp#lQ~V?TWg zF4V{uFVW8X@&y&h*XinaPdK@_)HF3w+q`3IK+n4|kP0+0yW9R;IOu|9l2zti&O6(6 zD;!|SlUhs!7k<`uUD>xoLIy`4)AO#{Bwi?`&_%BxWpKs*xoamrN1DmhM`cwR0_Lx7 z|Fogu)jzc(oYGBaU+DU3r|jr*GmDm*x?OEOKB~kp&VNC8-@|uo)U9=!F1wcGp!v{1 zk=(-fX*SoNt@V&a72=QX!Y`aGTQMJ$!!{g3&*V1dUok!E5Vvc4h%R#BX_8I&?Js?A zj*nZgjSP&uZ+JMg4<@dwOC%_SP}cBSi<3D#>Y-e%=%EP8&u3@>uCT~&D9gRYB2w)d zl$cEY#}QS=gB|@bQQ`yaA}7b^ZT>BpM1=Y6p={AITc!Ns!P5kI!xeUDw(g28&oCr{ zE*beOvQ-)BX3!}<6Ci#1d1)pwNn3fgw!V(U?x*hvb|r{^vXSRQw&oM{^tb7J_TA0r z3)bgXy>MjDqKZE)mc>mf!gwJq&p9DucI07uiH_l(Y^3&GRxHr(mWh0>!VlHEBE0m1PhuV>$ZybN1gn+dh+JdT-z9q)yl90WHX zD8CKk=jYQQ5WeiOt#f`|K3FT{sOSf?Nm(1GMstvqrX$VrH4H>Ierb}xHvgHQ1GP+q z|EbT7kc}!af1r`QoaONTQnI>SplX(=3>l&U**1APCCusqqC~kb|vKt)R;2>GqB&9 zdM_4c-N^2#uwi>h#Y z{(ID=L*m~@5eyamH~WtN^EvsT)HZV107t5#sB_i$Tixz?a?D`yZKg0!GBjfT{0;Np z7Hshim=Se0?LUL+p%VU&DtWepe7a>V!0NB%{XMyXb zdUnUMH#zX-uMIcG`U&`?P^nmdP~LxFiHoRWUso!c!$8+T$L!e*rSv(%;{8UrvJ~@a zuhbooz@oX%5@Hu@wn1-*h<*p7o8$JNRE2abCfBNkeF&wLq$7RMH9^$qfc{jlzP95L z*QTPBP^RY|2F*A74)}cjt|s*i3h>jg z+G>)|JOQuzaGxG`7R`8^tV>wF4a-;BaZ0Z_SYIAdNm8Pq?%9HheH+_~jgJo;8Bqlx6Dm6To6A4z1!ZMD zD_s#es*L5P9cYF9bTn9k=iO?FiBo!W%1@TUvwe+5P(9r0qed-%P-Y?6PL#&)mp*}3 zP6e14v5Xs4TCT*a1j#pWFs6I6HGpgHlW%Kl=KJKE-+3b&5aK^+`hQfWvFkEtbQxD6 z+D$io4@1vV&z*T%E^~h5_{@rf{p4=e4fzO2=#$IHzc4)E@w;qs87{KlMB+db{~xxlP`!HxAAfQ^ z!&aq{M&;M9 z$sknp^c&mOz)i`5DAUA*YHofWijP0OflmjO>o;Lvk!?TC!|FM){V}@w>%_LOdf2a> z0!umAH`yS3Fzd#q=i{ynTr4Rm2`z6l41j8$PMMMU)Y0J~WQ4c(dr=V-1eK>dQ*Wk9 z4P}*-qZO9~h;OYNWT(i6 z?}Qv?LrKyEayE!42<;npUO)V19b_|G{Vs*KWUqQoEl=8Xy4-XcZc7S=DeOY6`W7-p z;$k*c))WlUW<-4*U1Na3iO%}oj@L6}Ft-o(H*mc{y5Ud$y^?YUZDwmM9|;nKhQrzT zx@>9{sARzRsr(>lg+K@icYF&Cs{v+ZES)k)Pn+92bP`K%H`nLxx6oAi2ego{^1*FLC|_86n4(HE3#=?s zwWmgg;_pWPHBgJz=GngYEEqxb`MH)hiwYRaWI*Up`Bt%^Ni-Q~;M&7GmmFTk-r zfBrByI2bImuFmi$P+&kIy+cFYfe)~<#|&Fc5DQTw2TjMgR#sLHVDh8bu<>aEz0!{W z6m)inCD91$3b(qsgw(XO>@3^)LTDjA0fAT!7|noT%gcAn{6s^wLRNEA9OzTH-#Bl9Az>!$T^Jjla)dFN@Zb2Z1gP0zWAoB z8xSvF0Ay7&Fo;Mt_MM3nL58Msu&kkZyq9&yX8kD{1|n?T3F+!bC@?Y@Sb4oafBqOR z)BuT;8j!{!A|l{^d6=4-%E-ioJOUIg1k621Sz0nGXC`jYE7Dw1ev*H#mr_^9=&r4M!6j7w0&?R*2nZ#`rH zr&^S6FX_pwR2Xw&G=3pDE!*Y+GeO>X9*o_GpzLx5mm3HeIe}$H&*n z(=@=In~F};^jjWhB*2V&gQ_8S(w~ zU$_!W(m^uy>Har||3{>`ea}-B>9gzgwmDf=_kAzZOTv3|h+u1<)6#RYnq{|{SXL_6 zeg5I+b16depN9W0oli*H{YN?sW{Yxia#V{ZFmQ3Z|E%|`85_rRMG%6CK9i0R9Q9;5 zw@MwIhahS`ls`Ihn{ou{GZ*e#{&J=sD_b5j#J)yK9gKm=1qTAz3zq)U^asWFc_W>p zYjm7nB}vTRJ%JC3$}*Ri{jEV*JcAcze#DW|37r#a?tNF+y-v=~9B+T(gYhzt_wT7W zIUldDuj{t@3Vn=-P}9{5xAs25Hv5nAo)6b#al*-O<(N8hPSgY+;QWM z(*a_cwn43DYM;(D7Dqk;mDm94%X5+yvjIdFG|BnK+xr|joPEJfw z5&OhbNL*ZeX?2y>^s6L%YNVhia@`n^?a0^DT0bu|Hv6F}XRYW{zq^6%fV|CyYP*Rp z^S}F}Wgcm2s+HLP9>{&0-@Bg!1s)fq*>IWEHBlTi6qmt4^SfTP*&#DcZ63XG^A4E@ zmbRaI3U&d5F5Fc2=JMV*iTx;V-M)wI$|X(x+tL%S5{zb2@$pR=J&O}Vz4+Z*HAy_w9*%6Ajx>vi{4T4-7?HG`f&%iw~@xFQ_+h3m_ z9MI8nX3xPO_(>}H=Vwjd8oul(YQ#>5B8nu01#VYXQ6Hee2MVWIJPJ3Jz0mlCo%;{q`-J>OVdamZV)U zwI`%|_6!LE+8i~_lh#y)nVA_`Ma2)w`6v!IQ6pf4xvk!L^QA)EhjS3kMj+q`YnEc>rYRZmYjn{+OG8fQnfmA-34Yfbm(wIdWL*TAAOL7Y$@ z=l_>~EQ|hCiUVdLImag_R|3!}L=P64%WjcaV|G2y_oKKhSVXiW=pKAk57;YH>MV~X zZK%GT?Rj$8h!Ed3NDLCMj*-YsheXMb+%@)MgE$B%+z*-P z41PO`xq->bND3hmu#I;dt?r3HZ-5U8u*mXBni?dF6f-y2WaS3q_);(3DoKp4gSjC*?@Y&^QMe|4be&SsWDF zrw~ILXZRkM7Ce*y55adVnt)OGpDu4g`_`{zv4I<~v;*waU)R{bL7EgU`Qsmhdq?9m h|5trqWA6^dWdikRs3&h7eC-7yC#5V|DsB?^p8&<}wN?NC literal 9383 zcmd^_cTiJbyYE2+1O!BiAU!lu0R^NJKtSY26{I(%iu4wGXiAqNy-V-C6M7MpCelkt zkc6P2V+cq)o8OtabKW`Uedo-*f1Eq_{;_6HR(96fS$pm0`Fy|6j?>p(MXcPC!6F zsrp<=hk$_49cV5$NPr##M|pMNAnB=W=&9>s>*@X4-G)HpwWq72i>IT#B?rXD-NW9+ zSwv7$@bN>AH=drZ9#TR=PXFr!K^J#Bp=qWaPGAr+*XKqa1O(KtuNq;QT&X<)0XLnh zlEO=$>}`0^%a{0^%Y6*NeU4ki>cclcHw=}a+y&vHS=SAgjk84U9X@`j-IECuVB7vqxXPd?AoITCkGY>m?c-8hR`&{M5pN zou8jy%-|vDwu}nti7b9aQA2|=B_%~>e~>oqp^$(8dR!dAEiIi@s1m=VogX=Zl7z%| zR#$&mS~C7VJ-t|OrPAw_Dr7+=ud4bb9no{T16zSCJ8|>ziFogrcJI9x+Up}_SL(E- zNz|4Q8*zC1mXVd!X8rRAZXOCit_VAw1WOj z$Hv7yD~8Y{zLGe4WfvGIOF&Ogzh1Mx?-N|FaDhtF`aU~5q$bog*#Dk_aAafz8P4pC z%&^N{J6d*$H=P23I9(kRygfY$5>is=T~GG*9)0-mp?84;0rM6TU-el(xkY+UNQjS* zFTyS_P^^eU=)r>lERF=OsZ>JUx~$>h;qlywl^GQl7DjNBl9Jfe+{7ei62m1anX$FC zb=V{4v&X?K=GbO^-rxU}icN-5N5H%`t)`|XVJSM&G|DP$Wg9ZRysW0CMuA47tx~dXqm^9qck+9uFwpvSCX6DyrmmXGk0T3unBqJNR>RO}5@Rk;_ipokO z7)0RYh<>kf-Mz+#q3^xSVDkJw0V(VW*hqWtpn&^~+MFu1wzekN`-83ZILFN&Cgq*Iliq0?sA*7Ex|W%$02NG6 zduY^e;?niRb}@>U@813UAX(WQ752bn-BQgLdU`{hzK1@zS%au3x2-frn#VIu>cxSl zM}%oql>|jaMcNh?lV>M~?Z7rWIY{dnqZD81UG4Ix{{a%_k%Y{BMVkta5Hbjvj{%*9 zMjs=ekCdPVH&Q}Pl?J(|-D81+Y6+SR2trBsMwFFqmU7&od7ORqtt+`Z4b1@m|8t!h zF&y}lfR}oDiCI}{0Rb`@85xf7j+DMW1u>V^*ip14eg_UoV{#kddgQb8haWUSW9Lnn zIJdO)wZjX$=hrosE1OlUmgc^-@EEeaG?d7tvib8T;isminboIUsI41KklxXV`~mMZ zywOirE4F0YzF5Q4U$lu|JWkG`J#b~E=t<1_l0)s#`hK0$vKSlm`1Qx6BtoC9`e7er z2x(+YjFq+ZyY6nVj*gCFjYMb1De?>A=`QjZJC;L6a~|I^4Qzb0c_Isf2PkF0r+_`GtvznxCJPG-T^W+r$BSl<*!uzvQKK{IH^p z4G-|dSkF}%wVBqG%`iL5`Pf);QqB3v`S3L0BA=uFY2e!JJfzZ+I~R3s&7yyxuT(te z>c2~brTHla5`F^w2#duMmX(z;db7q46U9;|qe{@;9+ zk)nwS^X%+wl^HDc>@0vFGc$9c$(|OR=LJz0)x1uQ!|IfoOWu_GW45>5;@t86(r*O;nmYEo4i)RKITiepWkfLIhx-KCyVmH*s7ai(w z7zL`#iA*1!a)F12UOU=>`+wObB_Vm^;=;$v8*Ve2x~Of0f*-t)czj)`$;=lXea#_| z=5bPCSbz*E6-)0fJ}EEnD!lQG=K1~NCjdgc#Kvw6gFr!5)kDAcnxUh_dF@m+8ALeJ z{L=xo`3yNy{X4zU*>4Q^Kx?7`VF8Hlz~1A5`#_Gkaf}y&?#Be|`XgfAIIXpSNWV6$ z!R7j;cL!>z`!imr%hFbWZHT)g(=`;>f~RY^Hry2^X6Fj`>*!H#_2h0erLJ3j6Qk`q z05qjr8}B6M!Kh*)BWcw~Wr488_u~I%mTHrLQQV>-8{CZ$;er^@WM|YP-IaSR0O(U! zwR?sPF@{y%(8QTN8V!Fr`z`wa91lyB6HWub6%`dDoteRU4qb- z!|4}Q_d8jFn3m_}^yjKgBIdC+M_Y>z%{r2;hU4lT<^|(eB%f+&Q4wCU(GJ_V)IDSe%ZT znTDAetA>U~o2ei`3EP4O+*M$f&>&wnV+2feaPlW>)6qmwvs_2Bs*j}9NUP&w=LqvQv-7>(9%75j!MR%hY4U)_NmgP1 zjNncXvbY)DfE|xKt_Kfd1_zbEf2QIO#$BLEAt51UGXl4%Tv)>a>} z#vlBM5jyy;CPYKKzAy=POGu+8MwC?ESqe;$6*|MI6W7X~KLT1E+(zjgaJk*xY{Ajd z(QfnmJ~F_VK}U;r8REPB4^B3+Tx?f6eH~ZY64NZ889;>Pe@Y+oE&@UA;uSI1vYqY` z7GN|Kh^k(?<+`ZV(!eQkiAnO(qhf}84ekCOd^SISc#-UDHaPxQ6YSk5RxJ4Q-p`~LyYux5I}q5< z?QLM!y+1fOcsvShrN!<*X@a4lAt05xwN3+otVk_8$R~I5B>|HOgYP6PDL-{|+&aml zV0c*9em5#PcS2uBL@mtOy9GaTHOIvBI$#bnk;_cg?Zk+$^$Oj#<9C;qmda{sY`2%1 zQ5X!-x0#v25{<0AlPa#+Gzv^e2qE||WAc&5hI;oYd^g-wt;`|~w6>OKco>6$Ve;gj zaZDWkp(*nfXcP0ey*6ucMq00n^11l=+UL{U&izo2&Ar#QiwPCFD1M5bii-Q+zklD{ z+A6B6ODHG+0e{P|-JM5LQnJdt>n@`-7+Rm7&*|KS(_an5o8<;w_-;(*v5y}p^P-m? zK98fW8Mi=**gQ22U0)~_;Nl7k4=0(cwa@~{XM20QsHCL9Zj$ZSuU`_LBbj;h_eKER z9mU99`etTj`R=r13_CpSn?~HGc)G$T@gFxow}r-Wwz)KluuY7QC~PK#?bq z<>$Z7OI7_6@m@gjK^!YrPc{)L6%v2?Wpa|8_6LE*$ybBp{rI4<`JM}}+qAU4+szb2 zA7btZQAx3Jo0r4 zCfA=T*d^$6IXNvY-WR}nBo!v6_u^7WwBolN=AbTJyR{sA^)Q9gBXJt%kw&&g zJLTF{S8X6KTlvVnWA7&44ZIbwyqctq=j}XZa5N<2p%}2RC;~*tAdPtdMXv9_5?5Yq z$n;(wrK=gkN}%kRC0Z_Rur}qe!o4XJbsZYDyD+aGWlxo?8Q*FmY8baIU z&N!hHQ*!-1JvZ!BK#k|FS1eFZ<-2w#DAJLAx0C$@%&P{hv1QS;-CB=1MK^pNOvX>< zYI)=0=N(!HT?C18M%_Kx`z8rOkcV)C+gOh8>u$u-e082~ z;yQlB#Kgp?)tMF0!HbP{jh;Vs;#j3W*Oztw04A_|r)Fl}jiL+M+7@=)m90aK zm#S&~3aadQwSne*S%fR1}|Z8myD$ycta^>PR7e@Z=Audq5b zMJTVYuiuLv7#I*06T4;=CX)bQHo=b{PfvI6|GSo$5nBP{UeQJwjF&DiYdrf*4jWCp z=h1)IQ?@1eRqPBAJUTH>)03TiOd-eKZgqzHoMm_MJ4jA#HoPbIRWmIH0<(8^rYf(t z3JY-kmibCbRFuxu*U3o$oEMKmSvNE`3K@Zgh5G>*U}a?uSZ7A`ZbLjUIo{zfW9G5N zm6Z>QTGqsbh21YOFUwU6hRG%`^RWxYA36>(~)BMo0>a(0lgN+}#gj>7!qw!j^9x1$bqp1Q{ z)|a)d?E%)}GV?!Z8kKl9G$1nq&<`xgeDpDZVWR=KXS>~}f|tkfmm~Y@!vIHEuRRSD z)M4ozkgMPM=&pB7=8qAqGVu+tw7ciGy1T@GAH}b{-j2fOyiZFfEMv8@OUj32I7 z$W2UCP*fzs&e!q*2z+z|(b3ffo=9phFE17;>zo3wVxk-ZkBu=-aq%?o)u;o>K9GA< zI^$`-=w}-^#-qY*i&0WuL4nX8Z~lkX@ztwfUOB~hVy6~%N&d!1Wr;KHYL<~ew zA5LDLO#&X|erwQatC-$H&>fgF&DjwdlXP2>96%!&Sr6atUEPM?BBF^tYoVF`W7I z_&9|x@4fZ@Y~2ZOWXy-LqXC=06Q@U;>0bHm=W!8stHF)0I|iMM#8%qBuO`Lweht2@ ztW>illq!D_Q07a&6qxVA$HTT`N<4bA0~ZYBNtSgk{yLlLCt1b&uC9EP#XNn(2gpA| z2@((7pF9h_I)R7xv()R&4&^xw4k}M0Z`}TG`ALp!nEEFQ2WqfYjn_BNF98mj`B8xD z{=@JPV;Jvo2E~#m@M#*&3tnPpA$knvnav>3bol5KFRfo0H~**Hc)^LCYf9JlPuIpG z;d_aM8dk90;A1sI@ygUgA69$V=hrl$7nG2WK#V->bgHR`OAw0>2FAT zpYt1??u-FMA@hu#-PkT@~4?jBj4$b7Yb}GnrIn!hR zBbm0x)PFHNHFf;`D|t^lL3(8GhD;B;`J2YoGFmiqu-$6i>OyM(9r#6&cw_mW2;@)O zH-SQJkll+Zzq2M{=N_t5q3^AtfHBEh&`1hBCie_t{3A9I*IP@~3#DGsrOL2htJDJ3 z7Q@N+`=;|yGyz#Oul57{ka|XRA!D-xI`J>t2 zb3uNwz<%MR=EFZiIS036tz*Hd*q#Qs1=P%ynJ}Z)J6YB$CzS>UQb$UOU zN^Dl36t$We?w3C<)yq_sd_6shaYdmD53c)@RE}1u9VluyJD(fY zgWmTyJL`7Fv|(kSwJ~|yXP$JGnVooWaM*Ccd>*^Q+sbmlf-Fb$6<$)ZQyKLz%TPKE zgTzIdG~(Ed?VX%#;2mComu5SeJN~^`O%k%j2!m|@7)j*%{o4@M^tb%KTO=-ZEe}Pb z$~S4K`(1xSsnvq4YTxzuX+Y)jUE7Q_mh)~!FTaJ%)KlAFCc}ZkIt+1}6tNiMI(z&5 zKe+cXR``)XFnjB&-va=noR(Xr;BXC~h5&r{_3JI5UEaKX+mCjCVQT8=-LBv}6fXW) zex1|*PfC6GgrUdh?N{>-LUeZFYlvS&5ywMud37brnE~1eK*-sQGRUw|1I3-KmG&eQ ziULNXr>B>kocu^eW~@Lt2C($&>%Swj!484dEd&0tb8K-7mFrD}dNmwUNR z%@g`Lkx6z)m{5lF*pHEahEKvfkSm*H6#XMng)K@cgY)OF=Fbndk$96k=E75Z8A&&B zr`N#h)ArM(lD+j{tj;Z6_%|l3pJJZ`^xA6l54Q+ccNC*9P>KT7)s?mftp8vvH@9KL z_Atc(`}w8{U?V)M7)+urU0z^SICHC(&%==Z=?gQU?gK)OjL%rqWz&351AEjWRH zqnZ$B3ooYVx6mq*6#fTeR?6nFc0!(nTWBp5S9!HE{<~e?-*L$)DQh@CzAo0_Vu#DP zVu$X#u8ZxG{b@qJpHCi5Vc0(hQLY@d_xw0s3n$Zeh;N|0 z94u&%4s)JgIReM8!ep+|n`JC-m$XZc&=Oq?CjMu*3kf>|NPrh85CN<7_@TlM&hO{1 zUzxul1Pz*T>~xro8(K>0V}tWu3&=0|b>}96e9rnehRi;*c(YNYRg+=GE?4SztZwFk znWn%56LGOYvf)wPBu@h`2>tx!V!t}P5{_16xroY0e1yJq3Xu>73}#Y7#=GP!e$CCz z#{pn~v%gGCur*e-w`c4IV5HA3@IBNfvd*p2j?0-jk1mJ@wA5eOJ>psQqm7R>j=PUiT_}E)LSUP{)6Qq*s*yqGI9ft2$BPKIZzJ^ug=x(5hOlXqB*Xezb2G5 z!ax5vf8|IJ$DfHFUtHo9Ev#no-3$Q(964;^q;I)aH4Is$0@96M_^6!k>0$3a2)Vkb zMGQMK&EKK)%=AFc)3{MPw7JBQP|I%&rjyNOS6yXf75E;g`)z#7r%1}n%FF~j|6WX^ z?ftWpD0!fYyK#<3A@tZGibRFP z7clSuGtd(P(J?f9{^A9Vudi>FX**!{cO3cy&Z#(g7jGr3jdSUyc4AV)nzzmCipf8D5C<0<);w?A~{}Dlb^X9kJRZVsE zo1>{_$0HNttrAIcx)fm4W3DAcF=X`-d6?#kd&sQHEIM_2XwnjHZ5X zs8}R|5xabHa(RP;6o<7RKYnaOrmDEQ=J8$a)oLMatsFdDgWIh(fmu0*pK;-O%!S z9JDljjK5PjkJ+9#I{!NJh;QnySXumcuOC1~LaMPwK>V5G&E$toY??(JJ=c1I-a@y{ zQwePr=gLPCTR_a@A|OQkbvrY%t=)zin%nlRLJ{qaT!{F0wo9xX?)_{hlHLy^W;hV0 zeBo6l?=(;-&bpSM2wA&_qx55u??0gX#x2Q@PDmZZhH)`rwOR$k=)4M8wlHVVRs31?H`Tx=~4ueXGij=;6mp zx|Y{qRW8{t-M7+^bhf=|E>uAa45o#*#NUUm5PnZu+XdTeLG9N5&A%}N*Kr0TwxSjfwmOFkzhvB)>%&BeF4(gjy_cvnP zj1XmC@0f_ILD8%degS7$UNF5XZX7mKw*#iE^Pw6fNkXab!J z0%tS`6-;}w_0hIhkAg>3YJva1cxk0{b2J%+AIP}1`_4HnquzE!RwY~I@7G%>t0VuX f-*nlzBzpM?7fPm|tOmR^M4+mysZ{gyRp`F~ei&dZ diff --git a/saves/qc_unet_config_Compilation_3_qubit/config.yaml b/saves/qc_unet_config_Compilation_3_qubit/config.yaml index a7b7690..9da2141 100644 --- a/saves/qc_unet_config_Compilation_3_qubit/config.yaml +++ b/saves/qc_unet_config_Compilation_3_qubit/config.yaml @@ -67,11 +67,11 @@ params: min_gates: 2 max_gates: 12 gate_pool: - - qiskit.circuit.library.standard_gates.h.HGate - - qiskit.circuit.library.standard_gates.x.CXGate - - qiskit.circuit.library.standard_gates.z.ZGate - - qiskit.circuit.library.standard_gates.x.XGate - - qiskit.circuit.library.standard_gates.x.CCXGate - - qiskit.circuit.library.standard_gates.swap.SwapGate + - h + - cx + - z + - x + - ccx + - swap pad_constant: 7 diff --git a/saves/qc_unet_config_SRV_3to8_qubit/config.yaml b/saves/qc_unet_config_SRV_3to8_qubit/config.yaml index ae45721..9a8065c 100644 --- a/saves/qc_unet_config_SRV_3to8_qubit/config.yaml +++ b/saves/qc_unet_config_SRV_3to8_qubit/config.yaml @@ -53,6 +53,6 @@ params: comment: 'Generated with ''from_datasets'' with 6 datasets. Qubits: [3, 4, 5,6, 7, 8].' params: gate_pool: - - qiskit.circuit.library.standard_gates.h.HGate - - qiskit.circuit.library.standard_gates.x.CXGate + - h + - cx pad_constant: 3 diff --git a/settings.ini b/settings.ini index e0dc7e1..2ddb75c 100644 --- a/settings.ini +++ b/settings.ini @@ -3,9 +3,9 @@ ### Python library ### repo = genQC lib_name = %(repo)s -version = 0.1 -min_python = 3.9 -license = mit +version = 0.1.0 +min_python = 3.10 +license = apache2 black_formatting = False ### nbdev ### @@ -30,11 +30,11 @@ custom_sidebar = True ### PyPI ### author = Florian Fuerrutter author_email = f.fuerrutter@gmail.com -copyright = 2023 onwards, %(author)s +copyright = 2024 onwards, %(author)s audience = Developers description = Generating quantum circuits with diffusion models -keywords = quantum-information diffusion-model generative-model +keywords = quantum-information diffusion-models generative-models language = English status = 3 -requirements = torch numpy matplotlib scipy pandas omegaconf qiskit tqdm joblib open_clip_torch ipywidgets pylatexenc +requirements = torch numpy matplotlib scipy pandas omegaconf qiskit tqdm joblib open_clip_torch ipywidgets pylatexenc huggingface_hub dev_requirements = jupyterlab nbdev \ No newline at end of file diff --git a/src/RELEASES.md b/src/RELEASES.md index c7f57d7..5f37151 100644 --- a/src/RELEASES.md +++ b/src/RELEASES.md @@ -1,3 +1,36 @@ +# genQC 0.1.0 - 26.08.2024 + +### Description: + +- Upload of `genQC` to `pypi`. +- Added [`CUDA-Q`](https://github.com/NVIDIA/cuda-quantum) kernel export. +- Added hugginface model loading. +- Increased minimal python version to 3.10 + +### Tested on: + +- Ubuntu 22.04.4 LTS +- nbdev==2.3.27 (for notebook development) +- python 3.10 + +**Libs**: + +```txt +torch==2.4.0 +numpy==2.1.0 +matplotlib==3.9.2 +scipy==1.14.1 +pandas==2.2.2 +omegaconf==2.3.0 +qiskit==1.2.0 +tqdm==4.66.5 +joblib==1.4.2 +open-clip-torch==2.26.1 +ipywidgets==8.1.5 +pylatexenc==2.10 +huggingface_hub==0.24.6 +``` + # Arxiv submission release - 07.12.2023 diff --git a/src/config_loader.ipynb b/src/config_loader.ipynb index 5b043ff..8c94d19 100644 --- a/src/config_loader.ipynb +++ b/src/config_loader.ipynb @@ -205,7 +205,7 @@ "def load_model_from_config(config, ckpt, device):\n", " \n", " print(f\"Loading model from {ckpt}\")\n", - " pl_sd = torch.load(ckpt, map_location=torch.device(device).type)\n", + " pl_sd = torch.load(ckpt, map_location=torch.device(device).type, weights_only=True)\n", " \n", " model = instantiate_from_config(config.model)\n", " \n", diff --git a/src/dataset/qc_dataset.ipynb b/src/dataset/qc_dataset.ipynb index 0b19de2..87c7984 100644 --- a/src/dataset/qc_dataset.ipynb +++ b/src/dataset/qc_dataset.ipynb @@ -39,7 +39,7 @@ "from genQC.config_loader import *\n", "from genQC.dataset.dataset_helper import *\n", "from genQC.platform.qcircuit_dataset_construction import decode_circuit\n", - "from genQC.platform.simulation.qcircuit_sim import schmidt_rank_vector\n", + "from genQC.platform.simulation.qcircuit_sim import schmidt_rank_vector, instruction_name_to_qiskit_gate\n", "import qiskit.quantum_info as qi" ] }, @@ -78,12 +78,12 @@ " \n", " def __init__(self, device: torch.device=torch.device(\"cpu\"), **parameters):\n", " super().__init__(device, **parameters) \n", - " self.gate_pool = [get_obj_from_str(gate) for gate in parameters[\"gate_pool\"]] \n", + " self.gate_pool = parameters[\"gate_pool\"] #[get_obj_from_str(gate) for gate in parameters[\"gate_pool\"]] \n", " \n", " @property\n", " def params_config(self):\n", " params_config = super().params_config \n", - " params_config[\"gate_pool\"] = [class_to_str(gate) for gate in params_config[\"gate_pool\"]]\n", + " #params_config[\"gate_pool\"] = [class_to_str(gate) for gate in params_config[\"gate_pool\"]]\n", " params_config = Qc_Config_Dataset_config(**params_config)\n", " return params_config \n", " \n", @@ -175,8 +175,13 @@ "\n", " params = None\n", " if hasattr(self, \"params\"): params=self.params[0]\n", + "\n", + " if isinstance(self.gate_pool[0], str):\n", + " gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in self.gate_pool]\n", + " else:\n", + " gate_pool = self.gate_pool\n", " \n", - " qc = decode_circuit(enc_tensor, self.gate_pool, params_tensor=params)\n", + " qc = decode_circuit(enc_tensor, gate_pool, params_tensor=params)\n", " \n", " t = self.store_dict[\"y\"]\n", " if t == \"tensor\" : label = self.y[0].cpu().tolist()\n", @@ -224,8 +229,8 @@ " 'device': 'cpu',\n", " 'comment': '',\n", " 'save_path': None,\n", - " 'save_datetime': '12/06/2023 19:06:49',\n", - " 'params': Qc_Config_Dataset_config(store_dict={'x': 'tensor', 'y': 'tensor_list'}, optimized=None, dataset_to_gpu=None, random_samples=None, num_of_qubits=None, min_gates=None, max_gates=None, gate_pool=['qiskit.circuit.library.standard_gates.h.HGate', 'qiskit.circuit.library.standard_gates.x.CXGate'])}" + " 'save_datetime': '08/26/2024 21:37:39',\n", + " 'params': Qc_Config_Dataset_config(store_dict={'x': 'tensor', 'y': 'tensor_list'}, optimized=None, dataset_to_gpu=None, random_samples=None, num_of_qubits=None, min_gates=None, max_gates=None, gate_pool=['h', 'cx', 'x'])}" ] }, "execution_count": null, @@ -235,8 +240,7 @@ ], "source": [ "init = {k:None for k in Qc_Config_Dataset.req_params}\n", - "init[\"gate_pool\"] = [\"qiskit.circuit.library.standard_gates.h.HGate\",\n", - " \"qiskit.circuit.library.standard_gates.x.CXGate\"]\n", + "init[\"gate_pool\"] = [\"h\", \"cx\", \"x\"]\n", "init[\"store_dict\"] = {\"x\":\"tensor\", \"y\":\"tensor_list\"}\n", "\n", "a = Qc_Config_Dataset(**init)\n", diff --git a/src/examples/0_hello_circuit.ipynb b/src/examples/0_hello_circuit.ipynb index 7707580..19a5d0e 100644 --- a/src/examples/0_hello_circuit.ipynb +++ b/src/examples/0_hello_circuit.ipynb @@ -82,7 +82,7 @@ "id": "742ae430-46f2-4099-ac8f-f422a4ddc1dc", "metadata": {}, "source": [ - "Load the pre-trained model" + "Load the pre-trained model directly from [Hugging Face: Floki00/qc_srv_3to8qubit](https://huggingface.co/Floki00/qc_srv_3to8qubit)." ] }, { @@ -91,6 +91,20 @@ "id": "e5d60c23-9514-4432-bc82-622c088fced6", "metadata": {}, "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dc1b8a80999f45f1a474f9ee25f32f4f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 2 files: 0%| | 0/2 [00:00" ] @@ -469,6 +481,7 @@ "source": [ "fig, axs = plt.subplots(2, 4, figsize=(18,5), constrained_layout=True)\n", "for qc,is_srv,ax in zip(qc_list, srv_list, axs.flatten()): \n", + " is_srv = [int(x) for x in is_srv]\n", " qc.draw(\"mpl\", plot_barriers=False, ax=ax, style = \"clifford\")\n", " ax.set_title(f\"{'Correct' if is_srv==srv else 'NOT correct'}, is SRV = {is_srv}\")\n", "plt.show()" @@ -481,6 +494,25 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52132fa0-9208-442d-a31d-af65bcfba714", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "genQC Version 0.1.0\n" + ] + } + ], + "source": [ + "import genQC\n", + "print(\"genQC Version\", genQC.__version__)" + ] } ], "metadata": { diff --git a/src/examples/1_editing_and_masking.ipynb b/src/examples/1_editing_and_masking.ipynb index 1bd25a1..40bd51a 100644 --- a/src/examples/1_editing_and_masking.ipynb +++ b/src/examples/1_editing_and_masking.ipynb @@ -27,6 +27,7 @@ "from genQC.pipeline.diffusion_pipeline import DiffusionPipeline\n", "from genQC.inference.infer_srv import convert_tensors_to_srvs, schmidt_rank_vector\n", "import genQC.platform.qcircuit_dataset_construction as data_const\n", + "from genQC.platform.simulation.qcircuit_sim import instruction_name_to_qiskit_gate\n", "import genQC.util as util\n", "from qiskit.quantum_info import DensityMatrix" ] @@ -63,7 +64,7 @@ "id": "742ae430-46f2-4099-ac8f-f422a4ddc1dc", "metadata": {}, "source": [ - "Load the pre-trained model" + "Load the pre-trained model directly from [Hugging Face: Floki00/qc_srv_3to8qubit](https://huggingface.co/Floki00/qc_srv_3to8qubit)." ] }, { @@ -72,6 +73,20 @@ "id": "e5d60c23-9514-4432-bc82-622c088fced6", "metadata": {}, "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a1c55308f7c94327b24b9df417f05117", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 2 files: 0%| | 0/2 [00:00" + "
" ] }, "execution_count": null, @@ -160,7 +174,8 @@ } ], "source": [ - "init_qc = data_const.get_specific_rnd_srv_circuit(srv_init, desired_length, pipeline.gate_pool)\n", + "gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in pipeline.gate_pool]\n", + "init_qc = data_const.get_specific_rnd_srv_circuit(srv_init, desired_length, gate_pool)\n", "print(\"SRV is\", schmidt_rank_vector(DensityMatrix(init_qc)))\n", "init_qc.draw(\"mpl\")" ] @@ -191,7 +206,7 @@ " #-------------------------------------------\n", " # prepare and encode\n", " \n", - " gate_classes = data_const.gate_pool_to_gate_classes(pipeline.gate_pool)\n", + " gate_classes = data_const.gate_pool_to_gate_classes(gate_pool)\n", " \n", " emb_org_image = data_const.encode_circuit(qc, system_size, gate_classes, new_length).unsqueeze(0).to(device)\n", " emb_org_image = pipeline.model.embedd_clrs(emb_org_image)\n", @@ -255,7 +270,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "34bb668415dd401f92272e6a4e5334a4", + "model_id": "7748783c52314ec895ba506bd45150b2", "version_major": 2, "version_minor": 0 }, @@ -290,7 +305,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "We found 13 correct distinct solutions.\n" + "We found 12 correct distinct solutions.\n" ] } ], @@ -317,9 +332,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": null, @@ -354,9 +369,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "execution_count": null, @@ -377,7 +392,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -444,7 +459,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -566,7 +581,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6449e687cd8449a7afeb2a8558ce96f6", + "model_id": "184b7eff29b44d74a8d61a69e310e53f", "version_major": 2, "version_minor": 0 }, @@ -600,7 +615,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "We found 13 correct distinct solutions.\n" + "We found 19 correct distinct solutions.\n" ] } ], @@ -627,7 +642,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -663,7 +678,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -686,7 +701,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -709,6 +724,25 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c48bb0e5-b8e4-4940-b7cd-4efd81c438e3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "genQC Version 0.1.0\n" + ] + } + ], + "source": [ + "import genQC\n", + "print(\"genQC Version\", genQC.__version__)" + ] } ], "metadata": { diff --git a/src/examples/2_unitary_compilation.ipynb b/src/examples/2_unitary_compilation.ipynb index 706b22a..e6d40fe 100644 --- a/src/examples/2_unitary_compilation.ipynb +++ b/src/examples/2_unitary_compilation.ipynb @@ -28,6 +28,7 @@ "from qiskit import QuantumCircuit\n", "from genQC.inference.infer_compilation import generate_comp_tensors, get_gate_and_U_acc\n", "from genQC.printing import display_colums\n", + "from genQC.platform.simulation.qcircuit_sim import instruction_name_to_qiskit_gate\n", "import genQC.platform.qcircuit_dataset_construction as data_const\n", "import qiskit.quantum_info as qi\n", "import genQC.util as util\n", @@ -63,7 +64,7 @@ "def str_cond_to_gate_indices(y): # helper function, used to check if only allowed gates were used by the model!\n", " assert y[:15] == \"Compile using: \"\n", " c = ast.literal_eval(y[15:]) \n", - " gate_classes = data_const.gate_pool_to_gate_classes(pipeline.gate_pool)\n", + " gate_classes = data_const.gate_pool_to_gate_classes([instruction_name_to_qiskit_gate(gate) for gate in pipeline.gate_pool])\n", " gate_clrs = [0] + [gate_classes[ic] for ic in c] # 0 is empty, always allowed!\n", " return gate_clrs" ] @@ -81,7 +82,7 @@ "id": "742ae430-46f2-4099-ac8f-f422a4ddc1dc", "metadata": {}, "source": [ - "Load the pre-trained model" + "Load the pre-trained model directly from [Hugging Face: Floki00/qc_unitary_3qubit](https://huggingface.co/Floki00/qc_unitary_3qubit)." ] }, { @@ -90,6 +91,20 @@ "id": "e5d60c23-9514-4432-bc82-622c088fced6", "metadata": {}, "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95b3e6a8ad944d45b38703e92799bc84", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 2 files: 0%| | 0/2 [00:00" ] @@ -346,7 +355,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -410,7 +419,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -447,7 +456,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -505,7 +514,7 @@ } ], "source": [ - "cs_1 = f\"Compile using: {[x().name for x in pipeline.gate_pool]}\", \"all\"\n", + "cs_1 = f\"Compile using: {[x for x in pipeline.gate_pool]}\", \"all\"\n", "\n", "cs_2 = \"Compile using: ['h', 'cx', 'z', 'ccx']\" , \"no x, no swap\" \n", "cs_3 = \"Compile using: ['h', 'cx', 'x', 'ccx']\" , \"no z, no swap\" \n", @@ -544,7 +553,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABxMAAAF8CAYAAAAEvpV0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1hElEQVR4nO3dd3hU1dbH8d9k0gsECBB6D4SiVAHpFhDpKsWrICKiItixYAHxviI2rCA2UMQCFhAQ6VVBaVJDCy1EAgQIKaTnvH9wiUQmkDIzZ2by/TyPz72css/KzOSszF5n720xDMMQAAAAAAAAAAAAAPyLl9kBAAAAAAAAAAAAAHBNFBMBAAAAAAAAAAAA2EQxEQAAAAAAAAAAAIBNFBMBAAAAAAAAAAAA2EQxEQAAAAAAAAAAAIBNFBMBAAAAAAAAAAAA2EQxEQAAAAAAAAAAAIBNFBMBAAAAAAAAAAAA2EQxEQAAAAAAAAAAAIBNFBNNZrFYNH78+Nx/z5gxQxaLRYcPHzYtpiv5d7xmGzp0qCwWiywWixo3bnzFYy++tps2bXJSdAAkKSEhIff31GKx6M033zQ7JAAAAAAAAABAAXlEMTE6OloPPPCAateuLX9/f5UqVUrt2rXTu+++q9TUVLPDg4OFhYVp5syZeu211/Jsr1mzZpELn507d9bQoUOLdO748eNVs2bNIp1bEMX5uYYOHarOnTsX6pxVq1YVq8BtsVg0Y8aMQp9XnNexuDHbg7vHXxz//pwFBQVp5syZmjx5snlBAQAAAAAAAACKxNvsAIpr4cKF6t+/v/z8/DRkyBA1btxYGRkZWrduncaMGaNdu3bp448/NjvMfKWmpsrb233eBleMNygoSHfffbfZYQDIh4+Pj+6++24dPnxYjz/+uNnhAAAAAAAAAAAKwbWqQoV06NAhDRo0SDVq1NCKFStUqVKl3H0PP/ywDhw4oIULF5oY4dX5+/ubHUKhuFu8AAAAAAAAAAAAKDq3nub09ddfV3Jysj777LM8hcSL6tatq0cffTT331lZWXrllVdUp04d+fn5qWbNmho7dqzS09PznFezZk317NlTq1atUsuWLRUQEKAmTZpo1apVkqQff/xRTZo0kb+/v1q0aKGtW7fmOX/o0KEKDg7WwYMH1a1bNwUFBaly5cqaMGGCDMPIc2xB1yBctGiROnTooKCgIIWEhKhHjx7atWvXVc8bP368LBbLZdttrc24adMmdevWTWFhYQoICFCtWrU0bNiwK8Z7sf0DBw5o6NChCg0NVenSpXXvvffq/Pnzec5NTU3VI488orCwMIWEhKh3796KjY21+Rrs2bNHR48everPVxTp6el64oknVL58eQUFBalfv346deqUQ651qa+++krXXXedAgMDVaZMGXXs2FFLliyRJK1YsUJeXl566aWX8pzz9ddfy2KxaOrUqQ6JqXPnznnWsrv0v6JMTXo1qampatCggRo0aJBnCuIzZ86oUqVKuv7665WdnW336170xx9/6NZbb1WZMmUUFBSka665Ru+++26eY/bs2aMBAwaofPnyCggIUP369fX888+bHv/+/ft1++23Kzw8XP7+/qpataoGDRqkc+fOSZJuu+02NW/ePM85vXr1ksVi0c8//5znNbBYLFq0aFFu7E899ZSaNGmi4OBglSpVSt27d9e2bdvytHVx6tXvvvtOY8eOVXh4uIKCgtS7d2/FxMQ45GcGAAAAAAAAAJjPrYuJ8+fPV+3atXX99dcX6Pjhw4frpZdeUvPmzTV58mR16tRJEydO1KBBgy479sCBA/rPf/6jXr16aeLEiTp79qx69eqlWbNm6fHHH9fdd9+tl19+WdHR0RowYIBycnLynJ+dna1bbrlFFStW1Ouvv64WLVpo3LhxGjduXKF/zpkzZ6pHjx4KDg7WpEmT9OKLL2r37t1q37693dZUO3nypLp27arDhw/r2Wef1fvvv6+77rpLGzZsKND5AwYMUFJSkiZOnKgBAwZoxowZevnll/McM3ToUL3//vu69dZbNWnSJAUEBKhHjx4224uMjNSQIUOK/XPZMnr0aG3btk3jxo3TQw89pPnz52vUqFEOudZFL7/8sgYPHiwfHx9NmDBBL7/8sqpVq6YVK1ZIkm644QaNHDlSEydO1JYtWyRJx48f1+jRo3XTTTfpwQcfdEhczz//vGbOnJnnv27dukmSKlSoYPfrBQQE6IsvvtCBAwdyC3TShZHE586d04wZM2S1Wu1+XUlaunSpOnbsqN27d+vRRx/VW2+9pS5dumjBggW5x2zfvl2tW7fWihUrdP/99+vdd99V3759NX/+fFPjz8jIULdu3bRhwwaNHj1aH374oUaMGKGDBw8qISFBktShQwdt27ZNiYmJkiTDMPTbb7/Jy8tLa9euzW1r7dq18vLyUrt27SRJBw8e1Ny5c9WzZ0+9/fbbGjNmjHbs2KFOnTrp77//viyW//u//9PChQv1zDPP6JFHHtHSpUt10003sT4tAAAAAAAAAHgqw02dO3fOkGT06dOnQMf/9ddfhiRj+PDhebY/9dRThiRjxYoVudtq1KhhSDJ+//333G2LFy82JBkBAQHGkSNHcrdPmzbNkGSsXLkyd9s999xjSDJGjx6duy0nJ8fo0aOH4evra5w6dSp3uyRj3Lhxuf+ePn26Ick4dOiQYRiGkZSUZISGhhr3339/nrjj4uKM0qVLX7b938aNG2fYepv/fZ2ffvrJkGRs3Ljxiu39O96L7Q8bNizPcf369TPKlSuX++/NmzcbkozHHnssz3FDhw69rM2L1+nUqdMVYzGMC691jRo1rnqcYfzzM990001GTk5O7vbHH3/csFqtRkJCQoHaKaz9+/cbXl5eRr9+/Yzs7Ow8+y6NIyUlxahbt67RqFEjIy0tzejRo4dRqlSpPJ83R/vtt98MHx+fy95Pe3vuuecMLy8vY82aNcacOXMMScY777zjsOtlZWUZtWrVMmrUqGGcPXs2z75L34OOHTsaISEhl73mlx5jRvxbt241JBlz5szJ95iNGzcakoxffvnFMAzD2L59uyHJ6N+/v9G6devc43r37m00a9Ys999paWmXfS4PHTpk+Pn5GRMmTMjdtnLlSkOSUaVKFSMxMTF3++zZsw1JxrvvvnvVn+PQoUOGJOONN964+g8NAAAAAAAAAHAJbjsy8eLom5CQkAId/8svv0iSnnjiiTzbn3zySUm6bG3Fhg0bqm3btrn/bt26taQLI8iqV69+2faDBw9eds1LR7tZLBaNGjVKGRkZWrZsWYFili6MpkpISNCdd96p+Pj43P+sVqtat26tlStXFritKwkNDZUkLViwQJmZmYU+/98j5zp06KDTp0/nvk+//vqrJGnkyJF5jhs9erTN9gzDyJ1W1t5GjBiRZ+rXDh06KDs7W0eOHHHI9ebOnaucnBy99NJL8vLK+yt3aRyBgYGaMWOGoqKi1LFjRy1cuFCTJ0/O83lzpLi4ON1xxx1q2rSppkyZ4tBrjR8/Xo0aNdI999yjkSNHqlOnTnrkkUccdr2tW7fq0KFDeuyxx3I/6xddfA9OnTqlNWvWaNiwYZe95v+eKtjZ8ZcuXVqStHjx4sumD76oWbNmCg4O1po1ayRdGIFYtWpVDRkyRFu2bNH58+dlGIbWrVunDh065J7n5+eX+7nMzs7W6dOnFRwcrPr16+eOkr3UkCFD8tx377jjDlWqVCn3HgsAAAAAAAAA8CxuW0wsVaqUJCkpKalAxx85ckReXl6qW7dunu3h4eEKDQ29rJD072LCxc78atWq2dx+9uzZPNu9vLxUu3btPNsiIiIkqVBTk+7fv1/ShSJm+fLl8/y3ZMkSnTx5ssBtXUmnTp10++236+WXX1ZYWJj69Omj6dOnX7aeZH7+/XqVKVNG0j+vy8XXv1atWnmO+/f74QxXi9XeoqOj5eXlpYYNG1712Hbt2umhhx7Sn3/+qW7dul22ZqWjZGVlacCAAcrOztaPP/4oPz8/h17P19dXn3/+uQ4dOqSkpCRNnz7d5tqe9hIdHS1Jaty4cb7HXHwg4ErHXOTs+GvVqqUnnnhCn376qcLCwtStWzd9+OGHueslSpLValXbtm1zpzRdu3atOnTooPbt2ys7O1sbNmzQ7t27debMmTzFxJycHE2ePFn16tWTn5+fwsLCVL58eW3fvj1P+xfVq1cvz78tFovq1q1rtymXAQAAAAAAAACuxa2LiZUrV9bOnTsLdV5BO/zzW/csv+2GYRQqjoK6uBbjzJkztXTp0sv+mzdv3hXPz+/nzc7Ovuy477//XuvXr9eoUaMUGxurYcOGqUWLFkpOTr5qnM5+XYrDlWNNT0/PHZEZHR2d7yg0exszZozWr1+v2bNnq2rVqk655uLFiyVJaWlpuUVzd+Ls+N966y1t375dY8eOVWpqqh555BE1atRIx44dyz2mffv22rhxo9LS0nKLiaGhoWrcuLHWrl2bW2i8tJj46quv6oknnlDHjh311VdfafHixVq6dKkaNWp02VqwAAAAAAAAAICSx22LiZLUs2dPRUdHa/369Vc9tkaNGsrJybms0//EiRNKSEhQjRo17BpbTk7OZVOf7tu3T5JUs2bNArdTp04dSVKFChV00003XfZf586dr3j+xVF3CQkJebbnN6VnmzZt9H//93/atGmTZs2apV27dunbb78tcLz5ufj6Hzp0KM/2AwcOFLttV1enTh3l5ORo9+7dVz123LhxioqK0ptvvqlDhw7p2WefdXh83377rd555x29+eab6tSpk8OvJ0nbt2/XhAkTdO+996pZs2YaPny4zVFw9nLx9+hKDx9cHElckAcUnB3/RU2aNNELL7ygNWvWaO3atYqNjdVHH32Uu79Dhw7KyMjQN998o9jY2NyiYceOHXOLiREREapYsWLuOd9//726dOmizz77TIMGDVLXrl110003XXbPuOjf91DDMHTgwIFC3dcAAAAAAAAAAO7DrYuJTz/9tIKCgjR8+HCdOHHisv3R0dF69913JUm33nqrJOmdd97Jc8zbb78tSerRo4fd4/vggw9y/79hGPrggw/k4+OjG2+8scBtdOvWTaVKldKrr75qcy3DU6dOXfH8i0WUi+uoSVJKSoq++OKLPMedPXv2spF5TZs2laQCT3V6Jd26dZOky9bie//9920ev2fPHh09erTY13UFffv2lZeXlyZMmHDZSK9LX/M//vhDb775ph577DE9+eSTGjNmjD744AOtXr3aYbHt3LlTw4cP1913361HH33UYde5VGZmpoYOHarKlSvr3Xff1YwZM3TixAk9/vjjDrtm8+bNVatWLb3zzjuXFckuvgfly5dXx44d9fnnn1/22bv0fTIj/sTERGVlZeXZ1qRJE3l5eeX5/WzdurV8fHw0adIklS1bVo0aNZJ0oci4YcMGrV69Os+oROnCSN1//+7PmTNHsbGxNmP58ssv80wv/f333+v48ePq3r17sX5GAAAAAAAAAIBr8jY7gOKoU6eOvv76aw0cOFCRkZEaMmSIGjdurIyMDP3++++aM2eOhg4dKkm69tprdc899+jjjz9WQkKCOnXqpD///FNffPGF+vbtqy5dutg1Nn9/f/3666+655571Lp1ay1atEgLFy7U2LFjVb58+QK3U6pUKU2dOlWDBw9W8+bNNWjQIJUvX15Hjx7VwoUL1a5duzxFy3/r2rWrqlevrvvuu09jxoyR1WrV559/ntvGRV988YWmTJmifv36qU6dOkpKStInn3yiUqVK5RZii6NFixa6/fbb9c477+j06dNq06aNVq9enTta89/TsUZGRqpTp065U366gs6dO2v16tWFng61bt26ev755/XKK6+oQ4cOuu222+Tn56eNGzeqcuXKmjhxotLS0nTPPfeoXr16+r//+z9J0ssvv6z58+fr3nvv1Y4dOxQUFJTvNS6OCivsunX33nuvJOVOcXmp66+//rJ1Py9atWqVunTponHjxmn8+PGFuuZ///tf/fXXX1q+fLlCQkJ0zTXX6KWXXtILL7ygO+6444qft/Hjx+vll1/WypUrrzoq91JeXl6aOnWqevXqpaZNm+ree+9VpUqVtGfPHu3atSt3ytL33ntP7du3V/PmzTVixAjVqlVLhw8f1sKFC/XXX3+ZFv+KFSs0atQo9e/fXxEREcrKytLMmTNltVp1++235x4XGBioFi1aaMOGDerVq1fu71XHjh2VkpKilJSUy4qJPXv2zB1lef3112vHjh2aNWtWvu992bJl1b59e9177706ceKE3nnnHdWtW1f3339/gX8eAAAAAAAAAID7cOtioiT17t1b27dv1xtvvKF58+Zp6tSp8vPz0zXXXKO33norTwf3p59+qtq1a2vGjBn66aefFB4erueee07jxo2ze1xWq1W//vqrHnroIY0ZM0YhISEaN26cXnrppUK39Z///EeVK1fWa6+9pjfeeEPp6emqUqWKOnTokFsMyo+Pj49++uknjRw5Ui+++KLCw8P12GOPqUyZMnnOvVhc/fbbb3XixAmVLl1a1113nWbNmqVatWoVOmZbvvzyS4WHh+ubb77RTz/9pJtuuknfffed6tevL39/f7tcw5GSk5MVHh5epHMnTJigWrVq6f3339fzzz+vwMBAXXPNNRo8eLAkaezYsTpw4IB+//333NfC19dXX3zxhdq0aaMxY8ZcNqrzUikpKapbt26h4zp16pRSUlI0YsSIy/ZNnz4934LSxXU0K1WqVKjrbdmyRa+++qpGjRqVp4D/7LPPat68ebr//vu1a9cuhYaG5ntdi8VSpPehW7duWrlypV5++WW99dZbysnJUZ06dfLcI6699lpt2LBBL774oqZOnaq0tDTVqFFDAwYMMDX+a6+9Vt26ddP8+fMVGxurwMBAXXvttVq0aJHatGmT59iLoxDbt2+fuy08PFx169bVgQMHLismjh07VikpKfr666/13XffqXnz5lq4cGG+U+yOHTtW27dv18SJE5WUlKQbb7xRU6ZMUWBgYKF+JgAAAAAAAACAe7AYhR1mhasaOnSovv/++9yCC/L3119/qVmzZvrqq6901113Ffr8oUOHasWKFdqyZYu8vb3zLeIUV1JSksqWLat33nlHDz/8sEOuUVS7d+9Wo0aNtGDBAodM12vL008/rW+++UYHDhyQn5+fU64pSdddd51q1KihOXPmOO2a9uTO8V8cjTpnzhzdcccdhTrXMAydPn1aMTExat68ud544w099dRTDooUAAAAAAAAAGBPbj8yEe4jNTVVAQEBeba988478vLyUseOHYvcbkxMjMqXL69GjRpp586dxQ3TpjVr1qhKlSouOZXjypUr1bZtW6cVEi9e88UXX3RqITExMVHbtm27bL1Pd+Hu8RfHuXPnCjW9MwAAAAAAAADAdVBMhNO8/vrr2rx5s7p06SJvb28tWrRIixYt0ogRI1StWrUitfn000/r7rvvliQFBwfbM9w8evTo4dRiXWE8/PDDTh8tuXHjRqdeT7qwfmh6errTr2sv7h5/cQQHB2vp0qW5/46IiDAxGgAAAAAAAABAYVBMhNNcf/31Wrp0qV555RUlJyerevXqGj9+vJ5//vkit9mwYUM1bNjQjlECsDdvb2/ddNNNZocBAAAAAAAAACgC1kwEAAAAAAAAAAAAYJOX2QEAAAAAAAAAAAAAcE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UEwEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE3eZgcAOJJhGEpMzlRCUrr8fK0qU8pPfr5Ws8MCAMApDMNQSmqWziamy8tiUZlSfgrwt8pisZgdGgAAAAAAANwExUR4pEPHkvTRnCh9Pne/4s+m5dnXoXlFjRwYqdtuqilfHwqLAADPc+pMqj6fu08fzd6jw38n59nXqE6oRg6M1N0966pUsK9JEQIAAAAAAMBdWAzDMMwOArCXv/ac1vPvb9Kidcd0tU92hbL+emhApJ6/v6l8fJjxFwDg/o7Fpei59zZq9uJDysjMueKxwYHeGtyzrl59pKVCS/k5KUIAAAAAAAC4G4qJ8BiL1sao/1MrlJKaVajzbm5bWd+/dSOjMwAAbm37vjO6deRixZ48X6jzGtYJ1S8fdlWNyiEOigwAAAAAAADujOFYJomKitKQIUNUuXJl+fv7KyIiQq+//roMw1C5cuVktVqVnJx89YYgSVq2IVa9H1la6EKiJC1d/7d6PLxEaemFPxcAUDTkQfvaeyhBXe77pdCFREnaHZ2gLvct0onTqQ6IDAAAAAAAAO6OYqIJZs+erWbNmmnmzJmqXLmy+vTpIz8/Pz3zzDMaNWqUzpw5o/r16ys4ONjsUN3C/iPndNvjy5WVXfRBtuu2ntADE36zY1QAgPyQB+0rMTlD3Ucu0Zlz6UVu41BsknqNXqLs7CtPjQoAAAAAAICSx9vsAEqa9evXa/DgwQoJCdGvv/6qzp07S5IMw9CYMWP01ltvSZJatGhhYpTuZfLMnUpKySx2O1/OP6CXHmymOtVK2SEqAIAt5EH7m7nggA7FJhW7nY0747Vo3TH17FTdDlEBAAAAAADAUzAy0Ymys7M1bNgwZWRkaM6cObkdqJJksVg0YcIEeXtfqO+2bNkyd9/+/ft1yy23KDg4WOXLl9fo0aN1/nzhpzHzRInJGZq54IDd2pv6XZTd2gIA5EUetD/DMPTht/bLXVPIgwAAAAAAAPgXiolONHv2bO3Zs0e9evVSly5dLtsfGBioKlWqSPpnREZCQoK6dOmipKQkff/993rrrbf0zTffaNiwYU6N3VV9teCAks/bb63Dz+fuU2oaaycCgCOQB+1v9aY4RR1MsFt7v/52TNExiXZrDwAAAAAAAO6PaU6d6IcffpAk3XXXXfkek5qaKi8vLzVr1kySNG3aNJ09e1Z//fWXwsLCJEne3t6666679OKLL6pRo0aOD9yFzfol2q7tnU3M0KJ1x3TbTTXt2i4AgDzoCLMW2m90viQZhvTNomi9MKKZXdsFAAAAAACA+2JkohNt2rRJUt6p2y51/PhxnTx5Ug0aNFBQUJAk6ZdfftGNN96Y24EqSbfffrv8/Py0aNEixwft4o6fSrV7m3HxTJ0HAI5AHrS/4/GOyIP2bxMAAAAAAADui5GJTnTy5ElJyu0g/bevvvpKUt5O1qioqMumcvPz81OdOnW0Z88eu8d4ww036OjRo3Zv11GOBDwqWQLt2uaL41/V2y9ssGubAMxTvXp1rVixwuwwIPKgI8T63SVZq9u1zS++mqNfPx9i1zYBmIc8CAAAAAAoLoqJThQcHKzU1FRFR0crPDw8z76YmBi9+uqrkv5ZJ0qSzp49q9DQ0MvaKlOmjM6cOWP3GI8eParoaPtOHepQ9VMlX/sWE8/E/60zp93oNQAAN0EedICa56QQ+zaZfC5eyX+70WsAAAAAAAAAh6KY6ETt2rXT3LlzNXHiRP3444/y9fWVdGHURb9+/ZSQkCAp/+nfnKF6dfuObnC0Y9YMpdu5zQrlghUSWsfOrQIwi7vd1zwZedD+TvhKyXZus0wpH5UNIA8CnsLd7msAAAAAANdDMdGJxo4dq4ULF2rhwoWqX7++WrVqpfj4eK1Zs0aDBw/W8ePHlZKSoqZNm+aeU6ZMmdzO1UudPXtWDRo0sHuM7jYF0sRPt2nse5vs1l6Av1V7181RaCk/u7UJALiAPGh/81YeUd9Hl9m1zRU/vaGmDcrZtU0AAAAAAAC4Ly+zAyhJWrVqpaVLl6pdu3aKi4vT4sWLlZOTo1mzZmns2LFKTExUZGSkAgP/mbYzMjJSUVFRedpJT09XdHS0QzpR3c19/SLk422/j/Fdt9ahkAgADkIetL8eHaqpWrjtNSiL4vqmFSgkAgAAAAAAIA+KiU7WqVMnrVu3TqmpqTp37pxWrVqlgQMHatOmC6PrLl0nSpJuvfVWLV++XKdPn87d9tNPPyk9PV233nqrU2N3RRXKBah/11p2a+/hQQ3t1hYA4HLkQfvy9vbSg/3tV1QdOTDSbm0BAAAAAADAM1BMdBEbN26UdPk6UQ888IBCQ0PVp08fLV68WDNnztTo0aM1cOBANWxI4UuSnhjSWN5WS7Hb6Xp9FUZjAIBJyINFN/y2+ipbuvij6mtVCdEdN9vvAR0AAAAAAAB4BoqJLiK/ERmhoaFasWKFgoODddttt+nxxx/XwIED9fnnn5sRpktq0TBMn47vUKw26tcsrW8mdbFTRACAwiIPFl2FcgGa9+5N8vMt+p91ZUv7adGUrvLztdoxMgAAAAAAAHgCi2EYhtlBlHQ5OTkqXbq0UlNTlZSUpICAALNDcksfzY7Sw6+uV05O4T7SjeqEatHUbqoWHuygyAAAV0IetI/Fvx3THU8uV/L5rEKdV7FcgBZ8cLNaNirvoMgAAADMkZaepdmLD2nZhr91NjFd3t5eqhQWoLt61NX1TSvIYin+LEcAALiq7OwcLVp3TD+tOKL4s2kyDCmsjJ/63VBTt3aoKquVsWYoOIqJ8Ci/rI3RE2/8ob2Hz131WG+rRQNvqa0Pnmur0FLFnx4OAACzbY2K18Ovrtf6bScLdHzX66vooxfaqVbVEAdHBgAA4DxnE9P12mfb9OmP+3TmXLrNY5rUK6PH7m6se/vWo6gIAPAoGZnZmjxzp6Z8F6Wjx1NsHlMtPEgjB0bq8cGNmaUIBUIxER7HMAyt/PO4pnwXpbkrjyg7O+9HvGrFID3Qv76G31Zf4WGBJkUJAIDjbI2K19TZezRrYbTOp+UdqRga4qt7+9bTQwMiVa9GaZMiBAD3tm3bNr300ktatWqVDMPQDTfcoKlTpyoiIkI9evTQt99+a3aIQIl19Hiyuj34q/YcOieLpPw6vSwWyTCkoX3q6ZNx7eXtzegMoKDIg4DrSkzO0G2PL9PyP47n5jpbLu7r0qqSfnrnJpUO8XVuoHA7FBPh0U6dSdXRuBT1Gr1Ex0+lqlp4oA7+MpAvCQCAEiExOUMHjyWpx8OL9fepVFWtGKi9P/dXYIC32aEBgNtavny5evbsqRo1aui+++5TQECAZsyYoaysLG3btk0TJ07Us88+a3aYQIl0OiFNbe+er/1HEwt13v2319e0l9oxQhEoAPIg4LoyMrN168jFWv7H8UKd17lluH796BZGKOKK6EmCRytfNkDlywYo0P/CR93Xx0ohEQBQYpQK9lXTBuUU8L886OdrpZAIAMVw6tQpDRw4UM2bN9eyZcty1/kdPHiwatWqJUlq2rSpiRECJdvjr/9R6EKiJH3yw151b19V/W6saf+gAA9CHgRc29tf7ix0IVGSVm2K0xsztuuFEc0cEBU8BVUVAAAAAAAKYNKkSTp79qymT5+e24EqSaVLl1bz5s0l0YkKmOXk6VR9++vBIp8/5bsoO0YDeCbyIOC6srNzNOW7KBVlkL3FIn00e4+ysnLsHxg8BsVEAAAAAAAK4Ntvv1WHDh0UERFhc3/FihUVHh4uScrKytKjjz6qsmXLKjQ0VPfdd5/S0tKcGS5Qonw+d58yi9EJumzD39p7KMF+AQEeiDwIuK5f1h5TTFxKvmskXolhSLEnz2vBmqP2Dwweg3muAAAAAAC4iri4OMXGxmrgwIGX7cvJydGOHTvUrNk/U0O9+uqrWrlypXbs2CFfX1/17t1bTz/9tN57771ixZGVlaW4uLhitQF4om9+2SeLpCL0oeaa8dN2PTygtr1CggsJDw+XtzfdoMVBHgRc25c/7yp2GzPn7VbLCO6Vnqq4uZBPBgAAAAAAV5GSkiJJstiYO2revHk6efJknqndPv30U73++uuqUqWKJGn8+PHq37+/Jk+eLKvVWuQ44uLiVK1atSKfD3is+q9JvmHFauK1Nz7Qa0/OsVNAcCUxMTGqWrWq2WG4NfIg4OJqjJZCrlGR5jmVJMPQjz8v0Y/v9bBvXHAZxc2FTHMKAAAAAMBVVKtWTVarVatXr86z/ciRIxo9erSkf9aJSkhIUExMTJ5O1ebNmyspKUmHDx92UsQACq+IHbBACUAeBFydPXIYeRD5Y2QiAAAAAABX4evrqyFDhmj69Onq06ePevTooZiYGH3yySeqWLGiYmNjcztNk5KSJEmhoaG551/8/xf3FVV4eLhiYmKK1QbgiW59ZL12Hkgs1jSnTz/1sEYPfMtuMcF1XFzHD0VHHgRc2+Nv7dD3y/8uegMWi/r2ulnvP/2k/YKCSyluLqSYCAAAAABAAbz33nvy8fHRvHnztGLFCrVt21Y//fSTJkyYoAMHDigiIkKSFBISIkk6d+5c7pf2hISEPPuKytvbm6n6ABsG3FJXOz7YUqw2hvRpoqpVy9gpIsDzkAcB13Vnj6ziFRMl/adnJL9fyBfTnAIAAAAAUADBwcGaNm2a4uLilJSUpCVLlqht27bauXOnmjRpIi+vC1+xQ0NDVa1aNf3111+5527dulUhISGqWbOmOcEDHm74bfXlbS3a9GwWSZ1ahqtRXQqJwJWQBwHX1btzdVUKCyjSkokWi1SxXID6dqlh/8DgMSgmAgAAAABQRAkJCTp27FiedaEkafjw4Zo4caL+/vtvnTp1SuPHj9fQoUNltVrNCRTwcOFhgbrj5lpFOteQNHJgpH0DAkoI8iDgGry9vfTQwEgZRZjv2zCkB+5oIB8fykXIH58OAAAAAACKaMeOHZJ0WSfq2LFj1bFjRzVq1Eh169ZVZGSkJk2aZEKEQMnxzjNtVLNycKHPG9yzrvp3LVohEijpyIOA6xgztInaN6tY6PPaXlNBz953jQMigiehmAgAAAAAQBHl14nq7e2t9957T2fPntW5c+f02WefKSAgwIQIgZKjYrkALf24u2pXvfqabBengRt4Sy19+nJ7WYoyLxwA8iDgQvz9vPXz+zerXdMKki5M452fi2mv7TUVNP+DmxXg7+34AOHWLIZRlIGvgHup22O2omOSVKdaiA4sHGB2OAAAOBV5EAAAlCSnzqTqlY//0oy5+5V0PtPmMXWrl9KjdzXSyIGR8vKikAgA8Bxp6Vl67bPt+mjOHp04nWrzmApl/fVA/wZ67r5rKSSiQCgmokSgExUAUJKRBwEAQEmUfD5TsxZG6+eVR/TLumOSpDturqkH+jfQDddVpogIAPBomZk5mrvyiL5acEA/rzoqSerdubru6lFHfW+oIV8f1jBFwVFyBgAAAAAAgMcJDvTRA/0bqEeHaqrW9VtJ0uQxbVQ1PMjkyAAAcDwfHy/171pLba+pkFtM/HDs9eRBFAlrJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwydvsAACgJDIMKdswOwrXYbVIFovZUQAAnIU8mBd5EAAAAADgyigmAoAJsg2pzQKzo3AdG3pK3nSiAkCJQR7MizwIAAAAAHBlTHMKAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCbWTAQAAAAAAADc1ON/SLHnzY7CvqoESpNbmx0FAMAdkAedg2IiAAAAAAAA4KZiz0sHk8yOAgAAc5AHnYNpTgEAAAAAAAAAAADYRDERAAAAAAAAAAAAgE0UE1EiGIZhdgi4BO8HADgX913XwvsBAAAAAADcCWsmwmPk5Bjaf+ScNu2O1+bd8dq8+7R2RZ9VSmqW0tKzJUkHjyWpbo/Zah4ZphYNy6llw/Jq3rCcypTyMzl6z3M6IS33fdi0K15bouJ16mya0jKylZ1tyN/PqpBAHzWuW0YtGv7v/WhUXnWqhchisZgdPgC4HcMwdPR4sjbvPv2/+2+8tu07o3PJGUpN+ycPVrv5WzVrUE4tGpb73/03TJXKB5ocvedJSsnQ1qjT2hz1z/sRe/K8UtOzlJVlyM/XqkB/q+rXLK2WjcpfeD8iwxRZO1Te3jzvBwAAAAAAXAfFRLi9E6dT9dmPezXt+z06ejzliscahhQdk6TomCTNWXJIkmSxSD06VNPIgZHq1q6qvLwoZBVVVlaOFqw5qinfRWnp+r+veGxaerbS0rO1cuNxrdx4PHd7nWohemhApIb2qadyof6ODhkA3F5SSoZmLYzWlO+itGP/2SseaxjSsRMpOnYiRfNXH83dfn3TCho5MFJ33FxLfr5WR4fssQzD0NrNcZoyO0o/LDusrKz8RyCmZ2QrPSNbG7af0obtp3K3Vyjrr+G31dcD/RuoeqVgZ4QNAAAAAABwRRQT4bb+3HFK787apTlLDikzK6fI7RiGtGBNjBasiVGtKiF6aEADPdC/gUoF+9oxWs925ly6pn4XpWnf71FM3JULulcTHZOkp976Uy98sFmDbqmtR+9qpKYNytkpUgDwHPuPnNO7s3bpy/kHlJSSWay2fv/rpH7/66Qef/0P3XdbhEbf2VCVKwTZKVLPl5aepelz92vKd1HaeeDKBd2rOXkmTa9+uk2vfb5dPTtW0yP/aaQb21S2U6QAAHdhGIZiT5zPneElPSNb3t5eCvT3VmTtUDWpV0a+PjwAdDUnT6dq8+547YpOyN32/dJDan1NeV0bUU6BAXSLAYCrij97Ydazv0+dV1p6tiwWKcDPW3Wrl1LT+mUVFOhjdogu71xShrZExWvrntO522YvOahmDcqpeWSYSofQ/42Csxgs2gI3k3I+U8++u0kffLPbYdeoFh6kT8e3V9frqzrsGp5i3sojemDCbzpxOtUh7Xt5WfTUPY318sjm8vfznC96WTlSmwVmR+E6NvSUmNUPKJisrBy99eUOjZuyVekZ2Q65RukQX00e01pD+9Rj6umr+HPHKQ19cY2iDiY47Br/ubWO3nu2jUeN2CcP5kUeBCBd+K779S/RmrvyiDbtitfJM2n5Huvr46Um9cqqfbOKuv/2+mpUt4wTI3VdGZnZ+mHpYc1eckibdsXr2In8H3a1Wi1qWDtUba+toGF9I3Rdk/Ju+3fPgJXSwSSzo7Cv2iHS7C5mRwHAmTIzczRv5RF9++tBbdodryN/J+d7rJeXRQ1qlVabayro3j711K5ZRbe9h9tTTo6hpetjNXPBAf2585T2H0m84vF1q5fSdY3La3DPuup6fRW3nbGPPOgcFBPhVlZvOq5hL63VwWPOuTsMvy1Cbz3VmlGKNpxOSNMjr23Q179EO+V6kbVDNX1CB7W+poJTrudodKLmRScqUDBRBxM09IU1+nPnqasfbAe3tKuqT8a1V9VwRin+W1p6lsZP3ao3ZuxQTo7j/5yuWC5AH714vfreUNPh13IG8mBe5EGgZNt/5Jw++Ga3Zvy8X4nJRZttoFPLcI0cGKnbb6opq7Xk3VCOxaVo6uwoffrj3isWYa+keWQ5jRwYqbt61HG7B1npRAXgzuLiz+uj2Xv08Q97dfzU+SK10aReGY0cGKkhveqVyFHnCYnp+uynfZo6O0rRMUVLCLWrXlh66r7bIlSmlJ+dI3Qs8qBzUEyEWzAMQ2Pf26TXPtvu9GtXCw/SvHdvUrPIMKdf21X9/tcJ3fb4coeNRsyPl5dFE0Y219j7r3X7p43oRM2LTlTg6j79Ya9GTVzvsNGI+SkV7KOvXu2sXp2rO/W6ruzgsUT1HLXUoaMR83Nv33qa9mJ7+fi4902TPJgXeRAomTIzc/Ta59v0yrS/irV0x6XaXltB0yd0UP1aoXZpz9Xl5BiaNmePxrz9p1JSs+zSZmTtUM14paOua1LeLu05A52oANyRYRiaMW+/Hn/jD51LyrBLm3WqhWj6hI7q0CLcLu25gwWrj2rEhN+KXIj9t4rlAjTtpXbq06WGXdpzBvKgc/CVFS4vKytH941ba0ohUZJi4lLU+b5ftG5LnCnXdzWLfzumm0YscnohUbrwRfGFDzbrsUkbnDIKBABcxaTPt+n+l9c5vZAoSYnJmer3+DJ9teCA06/tinbuP6P29yw0pZAoSdPn7le/x5cpNc0+HaYAAHPs2HdGbe7+WS99uMVuhURJWr/tpJoOmKu3vtih7Gz7teuKDscm6eYRizTy/363WyFRujATRNvB8/XsOxuVlk6+BQBHiD2Rop6jlmjYS2vtVkiUpOiYJHUatlCPTdqg83bMDa7obGK67nl+tXqNXmq3QqIknTidqr6PLtPdz63SmXPpdmsX7o9iIlxaTo6h4ePXafrc/abGkZicqW4PLtb6bSdMjcNsyzbEqvcjS5Wa5vzO7Eu99/VuPTppgxhYDaAkmPT5Nj37ziZTY8jONjTk+dX6eqFzprZ2VXsOJajL8EV2/aJWFAvXxKjfY8uUkWluPgYAFM0va2N03V0/a0vUaYe0n5aerafe+lMDx6w05UEkZ/hzxym1GDRPK/487pD2c3IMTfp8u7o+8KtdO7kBANK2vafVYtA8/bL2mEPaNwzp3Vm71Pm+hTqdULSpr13d0ePJan3Xz/pyvuMe+p21MFqt7/pZh2M9bMgfioxiIlzak2/+oS9+NreQeNH5tCzdOnKJduw7Y3Yopvhzxyn1fXSZMjJd4+nWD77ZrZenbjU7DABwqE++32N6IfEiw5CGvLBaC9ccNTsUU8TEJevmEb8q/qxrfBld/Hus7n5uNSP1AcDNzF1xWH0eWaq0dMcX+X5YdtgjHz5Zv+2Ebrz/F6eMlli75YRuvH8RBUUAsJMtu+PVedgvTpnxbOPOeHW61/MKiodjk9T+ngXafyTR4dc6cDRR7e9ZoEPHKCiCYiJc2LyVR/TOV7vMDiOPhKQM3fmM5z7dmZ/k85ka9PRKu04dYw8vf7RVK//82+wwAMAhdh04q1ET15sdRh4XRiiuUVy8uSPznC0nx9A9z6/RsRMpZoeSx5wlh/TR7CizwwAAFNDKP//WwDErlZXtvAdBFq07prufW+0xs7rs3H9Gt45couTzzvtuunl3vHqNXlLi+gEAwN72HzmnWx5arAQnPqCxKzpBtzy0WCnnM512TUc6dSZVNz/wq2LinPfdNPbkedOWvIJroZgIl3TmXLoefOU3u7W3/NPu2r+gv5Z/2r3Ybe2KTtAr00rWiLhn39moQ3Ya0m7P90KShr20Vske8gcBAFyUlZWjoS+usdtocHveey/maE/plCyIaXP2aOVG+0yjZu88+PTkjTwlCgBu4Gxiuu56bnWRcrvValGVioGqUjFQVqul0OfPWXJI0+bsKfR5riYjM1v/eXZVkTqhi/sart1ygplxAKAYsrJydPdzq3WqCDO9FPcevmlXvJ57zzVm/CkOwzD0wCu/6cDRwo9ILO5rePBYkka8vK5E9QPgchQT4ZIeeW294uLt97RD9fBg1a1eStXDg+3S3mufb9emXafs0parW/nn3/rwW/uNerD3e3H472Q9M3mjXdoCAFfxxowd2rQr3m7t2fveO2/lUX3zy0G7tOXqDh1L0pi3/7Rbe/Z+L1JSs3TfuLVMdwoALu6xSRuKvOZueFiAji29U8eW3qnwsIAitTHm7Y1uv+bRfz/+Szv2ny3SufZ4DSdN366NO0tGPwAA2NvbX+7Un0W8h9rjHv7+17u1epNj1tl1lu9+Paiflh8p0rn2eA1/XnVUX/8SXaRz4RkoJsLlLFxzVLMWuvaNKTvb0L0vrlV2tmusH+goaelZum/cOrPDuKop30VpjZv/QQAAF+09lKDxU7eYHcZVjX5tvcusH+hIIyasc7lpvv9t5cbj+vTHvWaHAQDIx4LVR/Xl/AOmxpB8PlPDx7vviIKtUfF69dNtpsaQk2No6ItrmO4UAAop6mCCXppi/nfcYS+tddvpTk+cTnWJZVBGT1xf5Iej4P4oJsLlTPp8u9khFMjOA2e1cE2M2WE41Jwlh+w2vamjvTFjh9khAIBdTP5ql92mN3WkM+fSPb6AtXl3vJZtcI+1eSd9vp3RiQDgggzD0PPvbzY7DEnS8j/+1io7TdvtbOOnblW2E9eazM/u6AR9u6hkzM4AAPby34//cokHMQ4eS9KMn/ebHUaRvPPVTp1OSDc7DJ1NzNDkmTvNDgMmoZgIl7Jj3xmt3XLC7DAKbMp39pv+0xW508+3cG2M20/bAwDnkjL01QJzRy4Uxkdz9nj0KP2pbpQHDx5L0pLfY80OAwDwL+u3ndT2fWfMDiOXO33Hu+jI30la4EIP8rrjawgAZjl5OlVzlhwyO4xcU76LcrtR+ukZ2fr0x31mh5Hrs5/2KTXNtWfvgWNQTIRLmTrbvf4oX/x7bJEWvXUHW3bHa8N291kPwjCkad/vMTsMACiWmQsOuPyUmpc68neyFq07ZnYYDnE2MV1fL3Ltadf/jc5NwHm2bdumPn36qHTp0ipVqpT69u2r48ePKyQkRIMGDTI7PLgQV7s3/7TiiP4+mWJ2GIUybc5elxp9/+fOU9q0y32+KwOOQB5EQX320z5lZrnOA6i7oxO0ZnOc2WEUyvdLD7nUEiNnzqW7VIEYzuNtdgAlVVRUlCZOnKhly5bpzJkzql69uoYPH64xY8YoLCxMCQkJOnfunIKDg80O1WkSkzM0c4F7ddpJFwqgbz3V2uww7M7dCruS9OmP+zTuwWby9+PWZkv6icPaOaJWgY5tMc91vqzDM5EHL2cYhst1OBbEh99GqWen6maHYXdfzNuv1DTzp+IpjAVrjupwbJJqVgkxOxSXRB6EvSxfvlw9e/ZUjRo19MILLyggIEAzZsxQ9+7dlZycrKZNm5odIlxEUkqGy3W2ZWcbmrnggJ4Zdq3ZoRSIYRiaPs91RmNcNH3ufrVsVN7sMJwiaccq7XuhyxWPIW+WLORBFIYr3sM//2mfOrWsZHYYBTZ9rutNzfr53H0a0rue2WE4BXnwH/S4m2D27NkaMmSI0tPT1aJFC3Xo0EG7d+/WM888oyNHjujMmTOKjIwsUR2okrRq43Elu+EiuPNXH/W4YqJhGPp51VGzwyi0+LNp+mPHKbf6g8CZvEuXV83HZ+a7P/GvpTqz8ksFNbjeiVGhJCIP2hYdk6Sogwlmh1FoSzfEKjUtSwH+nvVnpTvmQcOQflkbo5GDGpodiksiD8IeTp06pYEDB6p58+ZatmyZAgICJEmDBw9WrVoXitV0ouKirVGnXXIdZHeagebI38mKi081O4zLbNh+0uwQnCaowfW6Zsbla22mxURp/yu3qnzXESZEBbOQB1EYpxPStP+I683o5k55MCfH0B87XC/ejTvjlZ2dI6vV8ye+JA/+w7N6fdzA+vXrNXjwYIWEhOjXX39V586dJV0o3owZM0ZvvfWWJKlFixYmRmmOTbvjzQ6hSPYfSdS5pAyVDvE1OxS7OXYiRSfPuM7w+cLYtCueYmI+rP5BKtf5bpv70k8cUswnj8g7tKJqPz3HyZGhJCEP5m+zm+bB7GxD2/aeUZtrK5gdit3k5BjaHOWe78fmqNNmh+CyyIOwh0mTJuns2bOaPn16bgeqJJUuXVrNmzfX8uXL6URFLle9J7vT3xyuGuuO/WeVnpEtP1+r2aE4nJePr7zKhOfZlpV4Woc/HK6Qxp1VddjbJkUGM5AHURiueg/fd+ScEpMzVCrY9fty9x0555KDb86nZWnPoXNqVLeM2aE4HHnwH55fOnYh2dnZGjZsmDIyMjRnzpzcDlRJslgsmjBhgry9L9R3W7ZsKUk6cOCAHnzwQTVt2lTe3t5q3LixGaE7hasmmILYusc1vyQWlTu/F+4cu1lyMtJ0cNIdyk5NUu2nZ8u3XGWzQ4KHIg9emTvfv9y18Jaf6JhEJSa73he2gnDnz5FZyIMojG+//VYdOnRQRESEzf0VK1ZUePiFzobZs2erffv2Cg4OVs2aNZ0YJVzFpl2ueU+OiUvRqTOuN9rPls27XfO7dmZWjnbsP2N2GKYwsjIVPel2efn4q/aY72Sxen5BFf8gD6IwXDUPStIWF33g599c+fudK7+/jlSS8yAjE51o9uzZ2rNnj3r16qUuXS6fZzcwMFBVqlTRkSNHckdk7Nq1SwsXLlTr1q2Vk5OjnBzXmyLFHgzDcNkvCQWxeXe8OrfynNFw7v1euG/sZjk6bZTOR29R1WFvK6RRR7PDgQcjD16ZK39JuBp3jt0Wd/55dkWfVVp6FusHFwJ5EAUVFxen2NhYDRw48LJ9OTk52rFjh5o1a5a7rUyZMho1apROnDihyZMn2y2OrKwsxcXF2a09OM6uA/lPS2a1WhQeFpDv/ktVuuS4SgU8Jy4+VdnZ+a/f89umA2rZ0PVHE2zfm/9n3ezXcMPWwwovnV6gthwtM7OiJB+nXOvoRyOVdnSXGrz5p6yBpRx2nczMTB07dsJu7YWHh+c+uIiiIQ+isP6KunxqyIvMvof/ue2w6lbKLlBbZtq841i++xz9GkpXfh037zymG1sUvC1HIg8WTHFzIVnUiX744QdJ0l133ZXvMampqfLy8spNvr169VKfPn0kSUOHDtWmTZscH6gJTp5J04nT7vFkpC1/7fWsAta2ve77hOW+I+d0PjVLgQHc3goifulnOr3sM5VpP1AV+zxudjjwcOTBK9u2z33vvX/tcd/YbXHn9yIry9Cu6AS1aBhmdihugTyIwkhJSZF0YTT9v82bN08nT57MM7XbzTffLEmaO3euXeOIi4tTtWrV7NomHKTueCmgqs1d4WEBOrb0zkI3ufGbvgU6rurN3yj2xPl89/e7bYCUsqfQ13e6GqOlUtfa3GX2azj6kcc1+uxvhb6+IzR8f6cCqjdy+HVOzJus0yu/VL0Jy+RXsZZDr7Vv3z5V62a/WUliYmJUtart30cUDHkQhVZthBR6nc1dZt/Dn3n2RT1z//JCX9/pwm+Xyne3vcvBr6F05dfx/Q+m6v0XXGOJCPJgwRQ3FzLNqRNd7AC9OHXbvx0/flwnT55UgwYNFBQUJEny8ioZb9G5pAyzQyiWc0nuORVafs4lu/f7keSCc4m7ovPRW3T041Hyr9ZQNUZ/ZnY4KAHIg1eW4Ma5MDHFfWO3xf3/LnHv+J2FPIjCqlatmqxWq1avXp1n+5EjRzR69GhJYp0o5GWjw91lWNzkbyyXjtOVY7O/c5sX6diMMao+cppCGnUwOxyYgDyIwnPhPOg293AXfg1dOkfbH3mQkYlOdfLkSUnK7SD9t6+++kpS/p2sznDDDTfo6NGjTr9uuqWCFHBfgY5d/ml3VQ8PLlT71SsF5/7v/gX9C3Xu0bhk3Th80RWPWbZiterWfahQ7bqyY373SNarrxfkiu+FJF3Xpr18jHOFatvpvLwV+qZ5TwJnJZ9V9KQ7ZPH2VZ1nf5TV3/Z9yVkaNGgg5WQ5pO3q1atrxYoVDmkbhUMezJ8hL2UHPlOgY13x3nv4yN+qW7duodp1ZSd9e0je11z1OFd8LyTprsH3KignulBtOx15MA/yoHvw9fXVkCFDNH36dPXp00c9evRQTEyMPvnkE1WsWFGxsbFO6UQNDw9XTEyMw6+D4rv1kfXacSDR5r64+FRVvfmbArVTKSwgdxRBqzvn6nj81Wf1ibvKMd/P+VatG7v+NKf3/3erfv39pM19Zr+G777zpm67wTXW2R29u6Ji0hzXfurRXTr45iBV7Pukwm4c6rgLXSIiIkKL7Xivu7iOH4qOPIjCeuzNHfphxd8295l9D3/1/17W4B6fF+j6Znrjy/1679uDNvc5+jW8eI38PDxyhJ4d+maB2nE08mDBFDcXUkx0ouDgYKWmpio6OvqyNy4mJkavvvqqJOWuE2WGo0ePKjrahM4n/3SpXsEOrR4erLrVizYfsa+PV5HPvZLU8+cVfdjFO+0Ko06aFHj1w1zxvZCko0cOS5kuPkWd1Vtm/aYbhqFDb9+tjBOHVPvZH+Vftb5Jkfwj+mC0lO2YTlS4DvLglXhJTQp2pCvee7OzM0163RykSqJU9uqHueJ7IUlxccelJBd/P8iDeZAH3cd7770nHx8fzZs3TytWrFDbtm31008/acKECTpw4IAiIiIcHoO3tzdT9bmJGpVL51tMzM42rjj9Wn6Ox6cW6bx/a9qohqpWddw6P/ZSp/pRKZ9iotmvYeP6VVW1qmsUE332S3JQJ2pWYrwO/LeXAms1VYWejyrz7OVr1XmXKi+L1WrX6/r4+HCvc0HkQRRG3ZrHJdkuJpp9D28UUdktPkcN6iRJsl1MNPs1rF+7osu8huRB56CY6ETt2rXT3LlzNXHiRP3444/y9fWVJEVFRalfv35KSEiQZO6IjOrVq5ty3QxLWRW0zn40LrnQ7VevFCxfHy9lZObo6PHCnV+Q6wUG+KhSnTqFjstVxfp5F+j+64rvhSTVqF5F3nLxp2y9zLv9Hv/uFSVu/kUVb3tGZdr2My2OS9WpXcehIzLgGsiDVxZtZEuWq//x6Yr3Xm+rRTU8KA+e8gmU7a7fvFzxvZCkyuFhCqjg4u8HeTAP8qD7CA4O1rRp0zRt2rQ823fu3KkmTZqUqOm5cXUtGoZpwRrXGz0TGuKr2lVDzA6jQFx5DeDmkeXMDsEpzm1aqIwTh5Rx4pB2DKti85jGHx+SX8Wazg0MpiAPojBc+R7uyrFdypXjdOXY7Ik8+A+KiU40duxYLVy4UAsXLlT9+vXVqlUrxcfHa82aNRo8eLCOHz+ulJQUU+cXN2sKpFNnUlWh89cFOrYg03v92/4F/VW3eikdPZ6sej3tvzDsHf1u1Rf/N8nu7Zql76NLNW/l1af5c8X3wmKRonZuUYC/a9/esnKkNgucf91zWxbr+HcvK+SaG1Tl7v9zfgD52LNnj7z5zuHxyINXVqHTLJ06e/VHOVzx3ntt43ra9O0Bu7drluff26RXP9121eNc8b2QpAXzZqtZpGt/sSMP5kUedG8JCQk6duyYevTokWd7dna2MjMzlZmZKcMwlJaWJovFIj8/P5MihbO5aidb88hysrjyeo6XcNXXsE61EIWWKhm/y+VuuEflbrjH7DDgwsiDyE+Lhq750EXFcgGqXKEAU7K5gGsiysjb26KsLMPsUPLw8rKoaX3XfH/tjTz4D9fubfcwrVq10tKlS/X8889r8+bNWrx4sZo1a6ZZs2apefPmmjFjhho3bqzAQPe4mdlT+bIXbuJ/nyz+EGszNGvgWTfPpvXLFaiY6Ioa1Ap1+UKiWTLPHNeht++SZFHplj11Zm3+86qXanqzfEIrOi84lAjkwStr2qCslq63PQWMq2vWoABzgrqRpm6c1328vdSwjouPzjcJeRCOsmPHDkm67GGYmTNn6t577839d0BAgGrUqKHDhw87MTqYqWUj1yyEuWqBzpaGtUMV4G9Valq22aHk4arvLWAG8iDyU6tKiMqW9tOZc+lmh5JHy0ZhbvNQjb+ftxrXLaO/9rjWck4Na4cqMID+15KGd9zJOnXqpHXr1l22/ZtvLnRmmLlOlNlaNgzTzyfds4DlTl/GCsKdvxi56lNPriAtdq+yk05Lko59/sQVj43470o6UeEQ5MH8tWgY5rbFRI/Lg2788zSpV0Z+vvZdq8FTkAfhKPl1og4dOlRDhw51fkBwGZXKB6pD84pau+WE2aHkMfCW2maHUGDe3l66/aaa+mqBa60FPLCb+7yGgKORB5Efi8WiAV1r6aM5e8wOJY+B3WqZHUKhDOha2+WKiQNvca/XEPZBMdFFbNy4UdLl60SdP39ev/zyiyTpyJEjSkxM1Pfffy/pwgiPGjVqODdQB2rRMEw/r3K/YqLFIjXzsLUS3LlT2J07gB0tpElntZjnWtMiABeRB6UWLj4t5ZW480MottSsEqwypXx1NjHD7FAKzZ1zuKORB+EoI0eO1MiRI80OAy7q4UENXaqY2LpJebfLFSMHRrpUMbFqxSD16sR6tMBF5EFcyciBkS5VTAwr46/+Xd2rEHZfvwiNn7pFGZk5Zoci6cJsOMNvq292GDABxUQXsWnTJkmXj8g4efKk+vfvn2fbxX9Pnz7do57wcdcRZfVrllZwoI/ZYdhVpfKBqlQ+UMdPud+0s+72xRjABeRB971/eXtb1KSeZ01zarFY1KJhmJZtcL+Rou76OQIAT9XvxhqqWC5AJ06nmh2KpAuduu6mzTUV1LRBWZcZlfFA//ryZqFbACiQJhFlXWqU/n39IuTv514lkQrlAtS/ay3NWugaD9bcflNNhYeVzOVpSjr++nEBOTk52rp1q6xW62VTAtSsWVOGYdj8z5M6UCWpc8tKKh3ia3YYhdbvhppmh+AQ/W5wv9E+4WEBat2kgtlhACgk8uAFNasE69r67leU69GhmkdOq+mOedBqtahnx2pmhwEAuISvj1VPDG5sdhiSpBqVg91uNIZ04SGfZ+69xuwwJEmlQ3x1/+0NzA4DANzK0y5yDw/093bLh2ok6ckhjeXlZf46j15eFj15j2v8XQPno5joAry8vJSUlKSsrCwFBASYHY5pggJ9NLR3PbPDKBQvL4se6O+Zw7ofGuB+X5BG3N5APj7c1gB3Qx68wGKx6GE3/GLjrl/GrubunnXdbuaBfjfUUJWKQWaHAQD4lyeGNHaJkeOfje+gAH/3Go1x0cBbaqt3Z/OnFn3n6daqWK7k/r0KAEXRs1N1/efWOmaHoUmPt1L1SsFmh1EkzSLD9PS9TcwOQ08MbqyWjcqbHQZMQq87XIq7FbB6dqymGpVDzA7DIRrXK6uOLcLNDqPArFaLRtzhmYVdACXHf26to1LB7lPAqlu9lG5qU8XsMByiVLCvBvc0/wtvYXhqYRcA3J23t5emT+ggHxOnxnywfwPd2KayadcvLovFoo9ebKcypcybzahHx2q6x80egAYAV/Hes21MfRijc6tKbv99adyDzdSwTqhp169fs7QmPNzctOvDfBQT4VLq1wrVTW70Bcfdk9DVPDzIfX6+vl0YjQHA/bnbKP2RAyNdYqoVR3GnPN+gVml1blXJ7DAAAPloElFWrz7SskjnxsWnqurN36jqzd8oLr7way9G1Cit159oVaRru5JK5QP10YvtinRucV/DCmX9Ne3FdrJYPPfvHgBwpHKh/vp0fHsV5TZa3Ht4mVK++uzl9m7/3dXfz1tf/Lej/P0Kv8xIcV9DP1+rvvhvR7ed4QD2QTERLmfs8GvNDqFAWjYK081tPXM0xkV9b6ihyNqhZodxVV5eFj0zzDXmXweA4nrs7sYKdIM/0CuWC9C9fdyn8FkUjeuVVZ8u5k+pVhDP39+UDk4AcHFP3tNYjw9uVOjzsrMNxZ44r9gT55WdbRTq3GrhQVr68S0KCTJvRJ89DehWW+883brQ5xXnNSwd4qsl027h4VUAKKaenaprWhEeCinOPTwowFuLpnRT7aqlCn1dV9SyUXl9/9YN8rYW7rtfcV5Dq9WiOW/eoNbXVCjUefA8FBPhcrpcV1kP9Hft6U59fbw045WObv9Ey9X4+ljd4ud86p7GatWY+boBeIZaVUP02mNFG7ngTNNeaqfQUn5mh+FwU56/XqEhrt0B26NjNd3Vw72mZAWAkshiseitp1rrqXucs+ZR7aohWv15D7ddHyo/j97duEgFxaIIK+OvFZ9017X1yznlegDg6e6/o4E+fqldkUYoFlbo/x4G8bQiWI+O1fXTOzcVaYRiYfn5WvXD2zeqlwusWwzzUUyES3r98VaqXsl1n/ob/1BzNapbxuwwnOK6JuU1Zqj5C/zmJ7J2qF4eyXzdADzLw4MauvS6tXf1qKM+XWqYHYZTVK4QpHefaWN2GPkKDfH935dx137wBwBwgcVi0etPtNIHY9sqwN9xnYBdr6+idV/0VK2qIQ67hpkevbuxZr95g8qWdtyDTS0bhem3L3qqecMwh10DAEqi++9ooHnv3qwKZf0ddo1rIspq7Yweur5pRYddw0w9O1XX8k+6q7YD83zNysFa9vEtJea7P66OYiJcUqlgX332cge7tXc0LlkHjibqaFxysdtq2SjMpYtrjjD+oWZ2m+7Unu+Fl5dF0yd0kL+f608HCACF4eVl0ecTOthtulN73nsrlgvQe8+2tUNU7mNwr7rq2bGaXdqy53shSe8+00aVK7juA1gAgMtZLBY9PKihtn9/mzo0t28nZ0iQjz4Z116/Tu2mSuUD7dq2q+nftZZ2/XSb3ack9/Xx0quPtNT6mb0UUbO0XdsGAFzQq3N17frpdg28pZZd2/W2WvTSA8208ZvealyvrF3bdjXXN62o7d/306g7G9q97ZEDI7Xjx9vUvrnrPuQM57MYhlG4SXIBJxo/ZYte/mir2WHkqlguQOu+6Km61T1jnu3C2Ln/jDoMXaiEpAyzQ8n19pjWenxwY7PDKJKsHKnNArOjcB0bekrePN4CXOa7Xw/qzmdWylX+WvPztWrxR93UqWUls0NxupOnU9V+6ALtP5Jodii57usXoU/Gt3fLUYnkwbzIg0DJlZNj6JMf9mryzJ3ae/hckdvx97Pqzu61Nf6h5h43renVGIahOUsOadLn27Ul6nSR2/H2tqjfDTX10gNN3a4DesBK6WCS2VHYV+0QaXYXs6MA4AzzVh7Ra59t04btp4rchpeXRb07V9dLDzRVs8iSN6J89abj+r9P/tLS9X8Xq52b2lTW8/c3VedW7vWdnzzoHBQT4dIMw9Bjkzbova93mx2KQkN8tXp6D10T4V5fKuxp/bYTunnEr0pJzTI7FL0woqleGdXC7DCKjE7UvOhEBfI3bc4ePfjKb2aHIavVop8m31Si10o48neS2t+zUMdOpJgdivp3raVvJnWW1eqeN0/yYF7kQQCGYWjln8c15bsoLVgTo/SM7AKd16BWaY24o4Hu6V3PoVN+ugPDMLRxZ7ymfBel75ceKvD31uqVgnRfv/oafluE2472pxMVgCfYsjteU2dH6bvFh5SUklmgc6pUCNS9fSM04o76qhZesh6msWXf4XP6aE6UZi6IVvzZtAKdUy7UT4N71tWD/Ruofq1QxwboIORB56CYCJdnGIaeeutPvf3lTtNiKF/GX0um3aKmDVh0/fe/TujWh5fonIkjFMc/1EwvPdjMLUdiXEQnal50ogJX9vH3FwqKZv3V5udr1Zw3byjRhcSLDh5L1M0jftXBY+Z9U/nPrXU045WO8vFx3xsneTAv8iCAS2Vm5mj3wbPavPu0tkTF68jxZC1YHSNJuv2mmmrRMEwtGpZT88gwhZVx3HpT7iw7O0f7jiRq8+54bd4dr+Px55Wali2r1aIAP29F1Cj1v9cxzCOmg6UTFYAnyckxtP/IOW3efVqbo+K1/0ii5q8+Kknq06W6rokoqxYNw9SyYZgqVwh06/5BRzEMQ4djky/kwah4HY5NVlpGtgzDUICft2pUDs59DWtWCXb715A86BwUE+EWDMPQG9N36PkPNikry7kf2Qa1SmveuzezVsIltu09rdseX+70jlRfHy9NHtNaIwfZfy5wZ6MTNS86UYGrm7PkkO4bt7bAT2jaS4Wy/vrujRvcbpoTRzp+6rz6PrpMf+4s+jQ8RfXEkMZ644nr5OXl3l/2yIN5kQcBXMmxuBRV6/qtJClmySBVDXfP0XNwHDpRAXgy8iCuhjzoHHxlhVuwWCx6etg1+nNWb6dNM+rlZdHT9zbR1tl9KST+y7X1y2mbgxb4zU+rxmHaOruvRxQSAaAo+netpZ0/3qab21Z22jXv7F5bu+feTiHxXyqVD9RvX/bUa4+1lK+TRgfWqhKiFZ9211tPtXb7QiIAAAAAAHAvFBPhVppFhmnjN7314gNNZbU6riOtQa3S+u2Lnpr0+HXy9/N22HXcWXCgj95/rq1WfnaralUJcdh1fH28NPHRlvr9y15qWKeMw64DAO6geqVgLf7oFk17qZ2CA30cdp0KZf314+Qb9fWkLioXyvRptnh7e+mZYddq6+y+atU4zKHXenhQpLb/0E9drnNeIRkAAAAAAOAiqiRwO74+Vk14uIXu7F5HH367W1/OP2C3Kd+aNiirhwc21N0961BELKDOrSppxw/99MXP+zXluyjtik6wS7uhIb66t289PTyooepUK2WXNgHAE1gsFo24o4F6dqymj+bs0cff79WJ06l2abtWlRA92L+Bht9eX2VL+9mlTU/XsE4Z/f5lL81ZckhTZ0dp7ZYTdmnXz9eqQbfU1qg7I9WyUXm7tAkAAAAAAFAUVEvgtiJrh+qDsddr4qMtNWthtKbO3qPt+84Uuh0/X6sGdK2lkQMj1fqa8m6/4KwZggJ9NHJQQz00MFJrN8dpyuwo/bjsiDKzcgrdVouGYRo5MFKDbqmtwABuUQCQn8oVgjTh4RZ6YURTzV1xRB9+G6U1m+MK3Y6Xl0Xd21fVwwMj1a1dVabQLAJvby/deWsd3XlrHe3Yd0ZTZ0fpq4XRRXrYqW71UnqwfwMN7VOPUaEAAAAAAMAl0FMPtxcS5KsHB0TqwQGROnk6VZt3x2tzVLw27z6tXdFnlZKapdS0LHlbvRTgb1WFsgFq0TBMLSLLqWWjMDWqW0a+PlazfwyPYLFY1LFlJXVsWUnpGdnasf+MNu2K1+bd8doSdVqnzqYp9uR55eQYslotqlO1lJrUK3Ph/WhYTi0ahtFxCgCF5Otj1YButTWgW22dS8rQ1j2ntXl3vDbtite2fWeUmJyh1PRseXlZ5O9rVZlSvmoe+c9999qIsgpy4JSpJU2TiLKa8kI7vfdsW+05lKDNu09rc9SF9+PvU+d1LC5F2TmGrF4W1agcrAa1Sqtlw/K570flCoE82AQAAAAAAFwKxUR4lArlAtS9QzV171DN7FBKPD9fq1o2Kn/Z1Gx1e8xWdEySalYO1t75d5gUHQB4ptIhvurcqpI6t6pkdiglnre3lxrXK6vG9crqnj71crfn5sEqwTqwcICJEQIAAAAAABQMxUQAAAAAAADATVUJNDsC+/PEnwkA4BiemDNc8WeimAgAAAAAAAC4qcmtzY4AAADzkAedw8vsAAAAAAAAAAAAAAC4JoqJAAAAAAAAAAAAAGyimAgAAAAAAAAAAADAJoqJAAAAAAAAAAAAAGyimAgAAAAAAAAAAADAJoqJAAAAAAAAAAAAAGzyNjsAACiJrBZpQ0+zo3AdVovZEQAAnIk8mBd5EAAAAADgyigmAoAJLBbJm45DAEAJRR4EAAAAAMB9MM0pAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJsoJgIAAAAAAAAAAACwiWIiAAAAAAAAAAAAAJu8zQ4AAAAAAAA4V9Z/X5dx/ITZYdidpVJFeb/wtNlhoIB6j16q6GOJZodhd3WqltLP799sdhgAroA8CFfhibmQPOiZKCYCAAAAAFDCGMdPSDHHzA7D7gyzA0ChRB9L1O7oBLPDAFACkQfhKsiFcBdMcwoAAAAAAAAAAADAJoqJAAAAAAAAAAAAAGyimAgAAAAAAAAAAADAJoqJAAAAAAAAAAAAAGyimAgAAAAAAAAAAADAJoqJAAAAAAAAAAAAAGyimAgAAAAAAAAAAADAJoqJAAAAAAAAAAAAAGyimAgAAAAAAAAAAADAJoqJAAAAAAAAAAAAAGyimAgAAAAAAAAAAADAJm+zA4BnMwxDys42OwzXYbXKYrGYHQVcgGEYysoyzA7DZXh7W/jdgMciF16CPIj/IQ/mRR4EAAAAALgyiolwrOxsZd12l9lRuAzvH2dJ3vzaQcrKMuTbYrrZYbiMjM33yseHTlR4KHJhLvIgLiIP5kUeBAAAAAC4MqY5BQAAAAAAAAAAAGATxUQAAAAAAAAAAAAANlFMBAAAAAAAAAAAAGATxUQAAAAAAAAXtGPfGc1ccCD334vWxSgtPcvEiAAAcJ4jfyfpm0XRuf/+cdlhJSSmmxgRUHJ5mx0AAAAAAAAALsjMzNH3Sw9pyndRWrf1RJ59Iyb8pufe3aTht9fXg/0bqGaVEJOiBADAMQzD0JLfYzXluygtWH1UOcY/+x59fYOefXej7u5ZVw8PitS19cuZFyhQwjAyEQAAAAAAwAUkJKar24O/6j/PrtJv/yokXnQmMV2TPt+uhn1/0MI1R50cIQAAjpOZmaNhL63VLQ8t1s+r8hYSL0pNz9YnP+xVswFz9cE3u50fJFBCUUwEAAAAAKAQtm3bpj59+qh06dIqVaqU+vbtq+PHjyskJESDBg0yOzy4qZTzmbp5xK9aufG4JMlG/+mF7f/bkZaRrT6PLNMva2OcEyAAXIJcCHvLyTF099hVmjFvf4HPGT1xvSbP3OnAqABcRDERAAAAAIACWr58udq0aaO9e/fqhRde0Kuvvqpjx46pe/fuSk5OVtOmTc0O0SXct/VP3bJ+lc19vvNna9axI84NyA08/Op6bdodX+DjDUPKMQzd8cRyHT2e7MDI3NeyT7pr9fQesljybp/77k3a+E1veXtbbJ8I4IrIhVdHHiy8t77YodmLDxX4eMOQLBbpyTf/0JpNxx0YmfsiD8KeKCYCAAAAAFAAp06d0sCBA9W8eXNt3bpVY8aM0ahRo7R8+XIdPXphukk6UFEUx0+d16yFBwp9nmFcmO7t4+/3OCAq93fPC6vVuG4ZPTPsmtxtI+6or5vbVNHdz61WVlZ+4z8B5IdcCEfIzMzR5Jk7Lyt6XY1hXPhv8le7HBOYmyMPwp4oJgIAAAAAUACTJk3S2bNnNX36dAUEBORuL126tJo3by6JDlQUzac/7lVWdtE69CwW6ePv9yojM9vOUbm/2BPn9dB/f9PLI5uraYNyiqhZWm+Paa0xb/+pvYfPmR0e4JbIhXCE+auP6nh8au5U3oX188ojioljlP6/kQdhT95mBwAAAAAAgDv49ttv1aFDB0VERNjcX7FiRYWHhys9PT13lMapU6dUqVIljR49WqNHjy52DFlZWYqLiyt2O+WyMj2yQyArK1Mnjh0zO4xC+/SHKFksKlInqmFIp86m6at529S1TQX7B+dAWZmZDr/G7MWH1KtTdc2a2Enn07K0ZnOcpnwX5dBrZmVm6pgbfg49WXh4uLy9PfGu53xm50Ly4JW5ax78aPb2Yp2fY0gfztqiUQNr2yki53F0LiQP4qLi5kJPvGcCAAAAAGBXcXFxio2N1cCBAy/bl5OTox07dqhZs2aSLnR0hoeHa8mSJapdu7a2b9+ubt26qWLFihowYECx46hWrVqx2pCkvzp3U8OQ0sVu50pWnz6lMr/86NBr/Nu+ffvU1A6vj9M1+kjyKl4XzX0PPCmdWWWfeJyl3suSfxWHX2bUxPWKXTZIOTmGeo5a6vDr7du3T9Wq3enw66DgYmJiVLVqVbPDcHuukAvJg1fmtnmw7ouSf3UVep7TS0x6e5omPfW1HYNyEifkQvIgpOLnQoqJAAAAAABcRUpKiiTJYqOTa968eTp58mTutG5BQUF65ZVXcvc3bdpUvXv31rp164pdTHQn14WW1WfNrrtse8MVi0yIxpVZil1IlCR5+RS/DQ91d486ssiiQH+rWjQM0y9rY8wOCXBL5MLCIQ8WgsUOOcwebXgo8iDsgWIiAAAAAABXUa1aNVmtVq1evTrP9iNHjuRO2ZbfGlGZmZlau3atnnrqqWLHER4erpiY4ncAlXvlden4iWK3cyUBVqvqBoU49Br/FhERoZiZnzr1mvbQ4PZlSkkt3pqHb0yaoEFdP7dTRM5x44PrtO9oikOv0aBWab3++HV69PUNalg7VJ+Ob68mt/+o0wnpDrtmRESElq+go9aVhIeHmx2CR3CFXEgevDJ3zYN9n/xDW/YkFHnNREkaMXywXhz+X/sF5SSOzoXkQVxU3FxIMREAAAAAgKvw9fXVkCFDNH36dPXp00c9evRQTEyMPvnkE1WsWFGxsbH5dqCOGjVKISEhGjJkSLHj8Pb2tstUfZnenvn0vre3j1tOZdi5VWUtXFO8TrdeXRqoatVQ+wTkJN4+jv0centb9NXEzlr2R6w+/WGv/HyturltFU17qZ3ueGKF467r456fQ+BqXCEXkgevzF3z4I1t/tbmqIRitdG9Yx23/NkdmQvJg7AnL7MDAAAAAADAHbz33nsaMWKE/vjjDz355JP6448/9NNPP6ly5coKDAxURETEZec88cQTWr9+vRYtWiRfX18TooY7GDkwsljn39SmsurXCrVPMB5kwsgWqloxSMPHr5MkpWdk6+7nVqlXp+oa3KuuydEB7olcCEd4oH+DIi+XaLFIVSsGqmfH6vYNygOQB2FPFBMBAAAAACiA4OBgTZs2TXFxcUpKStKSJUvUtm1b7dy5U02aNJGXV96v2I899piWLl2q5cuXKywszKSo4Q66XV9FNSsHF7kjtbjFSE/UrllFjRnaRMPHr9WpM2m527ftPaNxU7bovWfaqFp4kIkRAu6JXAhHqF21lLq3L9pINsOQHuwfKW9vSh2XIg/C3pjmFAAAAACAIkpISNCxY8fUo0ePPNsfeeQRrVixQitXrlT58uVNis48nzW7Lt99Gb0GODES92C1eun959qqzyNLJYsKtWbULe2qqlcnRmP8229bT8in+XSb+177bLte+2y7kyMCPBe58HLkwcKb9Fgrrd18QsmpmYXKg5G1QzXqzoaOC8xNkQdhb5TrAQAAAAAooh07dkhSnjWijhw5ovfff18HDhxQrVq1FBwcrODgYHXv3t2kKOEOenaqrk/Gd5BFKvAIxfbNKmr2m10YjQHAVORC2EPjemU1772bFOjvrYIO1K9dNUSLpnRV6RCmzwUcjZGJAAAAAAAUka0O1Bo1asgozCP1wP8M6xehiuX89eikDYqOSbpsv+V/oxZ9fbw0rG+EJj/dWv5+dO0AMBe5EPbS5brKWvdFT90/fp027Y6/bL9FkqEL+bB35+r6ZFx7lS8b4PQ4gZKIvzgBAAAAACiikSNHauTIkWaHAQ/So2N1dW9fTcs2xOrDb6P029YTOpecIT9fq6qFB2lY3wjd2zdCYWX8zQ4VACSRC2FfTRuU08Zv+2jjzlOaOjtKC9fE6GxihqxWiyqWDdCdt9bWA3c0UM0qIWaHCpQoFBMBOEVSSoa2Rp1WSmqmJOl8WpYOxyaR+AEAJUJGZrY2745XSmqWpAt5MOpggiJrh5obGADAJXl5WdT1+qrqen1Vs0MBAMAUrRqXV6vGJWutTcCVUUwE4FC7DpzV1NlR+nL+ASWlZOZuP34qVbW6z1a366to5MBI9ehYTVYr63wAADzLsbgUffzDHn3yw17Fxafmbj9+KlUN+/6g6xqX18iBkRrQrZYC/PnTHAAAAAAAuB56LAA4RExcsoa+sEYr/jx+xeMW/x6rxb/HqnqlIL33bFv16VLDSRECAOA4SSkZemDCb5q95JCys/NfK+bPnaf0585TeuLNPzT+oWYadWdDWSwWJ0YKAAAAAABwZQwDAmB32/edUZu75l+1kHipo8dT1O+xZfrgm90OjAwAAMc7fuq8OgxdqG8WHbxiIfFSZ86l65HXNujRSRuUk1OwcwAAAAAAAJyBYqJJoqKiNGTIEFWuXFn+/v6KiIjQ66+/LsMwVK5cOVmtViUnJ5sdpttaHX9SvvNna8qh/Tb370w8J9/5szVh704nR+b5DscmqesDv+rvU+cLfa5hSKMnrtcX82y/byi+yU+3lrH9PpsjQEuH+Cpm6SAdXDRAQQEMXIdjkQcdizxonsTkDHUfuVjb9p4p0vnvf71bY9/bZOeocBF5EAAAAACAwqOYaILZs2erWbNmmjlzpipXrqw+ffrIz89PzzzzjEaNGqUzZ86ofv36Cg4ONjtUoFBycgz1fmSpTpxOvfrBVzB8/Fpt23vaTlHhUmPf26QDRxM19YXrFRrim2ff5DGtVbVikIaPX6uU1CyTIkRJQB6EJxsxYV2RC4kXTfp8u75fcshOEeFS5EEAAAAAAAqPYqKTrV+/XoMHD1ZwcLBWrlypTZs26bvvvtP27dv15JNPasqUKZKkFi1amBwpUHhL18dqx/6zxW4nK9vQe18z3akjpKZla/j4tapYLkDvPtsmd/st7avq3r4RmjZnj1b8UfDpaYHCIg/Ckx2OTdLsxfYpAr715Q67tIO8yIMAAAAAABQexUQnys7O1rBhw5SRkaE5c+aoc+fOufssFosmTJggb+8LUyq1bNlSkjRnzhz17dtX1apVU1BQkK655hpNnTpVOTk5ZvwIwBVN+S7Kbm19/Uu0ziam2609/GP1pjhNnR2lIb3q6dYO1VQq2Ecfv9ROR48na8zbf5odHjwYeRCe7uPv98qw03KHG7af0pbd8fZpDHmQBwEAAAAAKByKiU40e/Zs7dmzR7169VKXLl0u2x8YGKgqVapI+mdExltvvSU/Pz+98cYbWrBggfr27atHHnlEzzzzjFNjd1cp2VmKT0+/7L9zmRlmh+ZxjvydpAVrYuzWXlp6tmawdqLDPDN5ow7HJmnaS+300YvtVC08WCMmrFNSSqbZocGDkQedjzzoPOkZ2fr0x712bdOeD+kgL/IgAAAAAAAF5212ACXJDz/8IEm666678j0mNTVVXl5eatasmSRp/vz5Kl++fO7+Ll26KDk5WR988IH++9//ys/Pz7FBu7nno3bo+SimCXOGhWtilJNjp+EY/zNv5RE9PrixXdvEBSmpWRo+fp2WfdJdd3avo89/2qfFv8WaHRY8HHnQ+ciDzrNh+0mdOptm1zbnrTqqT+3aIi4iDwIAAAAAUHAUE51o06ZNkv6Zuu3fjh8/rpMnT6phw4YKCgqSpDwdqBc1a9ZMaWlpOnPmjCpVqmTXGG+44QYdPXrUbu15S9rR0Lx1r0bWrKte4VUu237kfIoe3L7J6fFENmigLKdf1TnOeLeTfDvatc31f25X3bqP2rVNV2HISwo0d2TVmcR0ZWXlyNvbS7+ss9+o0qJoENlAFjlm2srq1atrxYoVDmkbhVMS86Bkbi4kDzpPsjVC8rvdrm3GnzmvOnXrymLXVl0DeTAv8iAAAAAAwJVRTHSikydPSlJuB+m/ffXVV5Ly72S9aO3atSpbtqwqVKhg3wAlHT16VNHR0XZrz9tikUwsJkYEh+jG8hUv274z8ZwJ0UjRBw8qy16LKbmaitdKdv5IZmRZ7Pp5dC1WqYl5V/f2tmj6hA5KTMlU8vlMvf1Uay3+LVbJ582Z3u1g9EFJ2aZcG85TEvOgZG4uJA86UWh5qZqd27R46eDBI5LhiSVY8uClyIMAAAAAAFdGMdGJgoODlZqaqujoaIWHh+fZFxMTo1dffVXSP+tE2bJp0yZNnz5d48aNk9VqtXuM1atXt2t7fMDyqlO7tseOyDjrHaAzdm7T1ztb1erUsXOrrsGQlw6aeP3n72+qa+uX0+CxqxWfkKZFU7rp9SdaaeR/fzclntp1ajt0RAZcQ0nMgxK58FKenAdTrKUVZ+9GjSzVrl3DY0cmkgf/QR4EAAAAALgy+recqF27dpo7d64mTpyoH3/8Ub6+vpKkqKgo9evXTwkJCZLyH5ERFxen22+/Xdddd52eecYx00LZewokIytLWbflvzZWSRO1Z48s3p75a/fVggMaPHa1Xdvs2rmV5n/wvF3bdBWZmTnybTHdlGs3qVdGY4dfqwWrj+qrBQckSV/8vF8P3NFA3y46qDWb7d4dflV7ovbIx8fL6deFc5XEPCiRCy/lyXlwa1S8mg+cZ9c2a1Uto+hFB+zapqsgD+ZFHgQAAAAAuDK+sTrR2LFj5ePjo4ULF6p+/foaMGCAbrjhBjVp0kRt27ZVqVKlZLVa1bRp08vOPXfunLp3767AwED9/PPP8vHxcf4PAFxBny7VFRJk38/lPb3r2bU9SFarRdNf6ajzqVl64JXfcrc//voGnTyTqk/Ht5e/n/1HewESeRCerWmDcmpct4xd27ynd127tgfyIAAAAAAARUEx0YlatWqlpUuXql27doqLi9PixYuVk5OjWbNmaezYsUpMTFRkZKQCAwPznJeWlqbevXvr5MmT+vXXX1WuXDmTfgIgfyFBvhrSy36dnpXKB6pPlxp2aw8XPDPsGrVoGKan3v5Tf588n7v9bGKGHn51verVKK1XRpm3zik8G3kQnsxisWjkwEi7tedttej+2+vbrT1cQB4EAAAAAKDwKCY6WadOnbRu3Tqlpqbq3LlzWrVqlQYOHKhNmzZJunydqKysLA0YMEDbt2/XokWLVKMGxRW4rocG2K8TdcTt9Znuy84ia4fqpQeaaen6WH32477L9v+47LC+X3pIj93VSK0ah5kQIUoC8iA82d096yg40D7TuPa7saYqVwiyS1u4gDwIAAAAAEDReOaiNW5o48aNki5fJ+rhhx/W/Pnz9frrr+v8+fPasGFD7r6GDRuqVKlSTo3TXXQKq6CMXgPy3d+4VOkr7kfRNKpbRv+5tY6+/iW6WO1UqRCoh+w4ugMXRB1MkH/LGVc8pv+T9l8vDigI8qB9kQfNERLkq+fuu1bPv7+5WO0E+Fk1dvi1dooKF5EHAQAAAAAoGoqJLiK/ERmLFy+WJD399NOXnbNy5Up17tzZ4bEBhfHZy+0VE5estVtOFOn8kCAfLfywqyqWC7BzZABcGXkQnuK54ddq/9FEzZi3v0jne3lZ9O3rXdS0AdP5AnAsS6WKMswOwgEslSqaHQIKoU5Vz3wwzFN/LsCTkAfhKjwxZ3jizwTJYhiGJ9433UpOTo5Kly6t1NRUJSUlKSDAc4ooRlaWsm67y+wwXIb3j7Nk8fb8Gn5SSoYGPLVSv/52rFDnhYcFaOEHXdW8oedPLZaZmSPfFtPNDsNlZGy+l2ltSzBPzoMSufBSJSUPZmXl6JHX1mvq7D2FOi/Az6pvXu9SItYMJg/mRR4EAAAAALgyvrG6AC8vLyUlJSkrK8vjOlBRMoUE+ern927WpMdaqUbl4KseH+Bn1X39IrThq14lopAIIC/yIDyNt7eXPnz+es14paOa1Ctz1eO9vCzqd2MNrfuiZ4koJAIAAAAAAPfi+Y+GAzCFj4+Xnh52jZ68p7F+WXtMU2dHadWm40pNy5YkWa0WRdQorRG319c9feqpTCk/kyMGAMB+LBaL7ulTT0N619Xvf53UlO+iNH/1USWlZP5vv1S1YpCG9qmn+2+vr2rhV3/4BgAAAAAAwAwUEwE4lNXqpV6dq6tX5+qSpLT0LGVm5Sg40EcWi8Xk6AAAcCyLxaJ2zSqqXbMLa5dkZGYrNS1bIUE+8vIiDwIAAAAAANdHMRGAU/n7ecufQYgAgBLK18cqXx+r2WEAAAAAAAAUGGsmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALCJYiIAAAAAAAAAAAAAmygmAgAAAAAAAAAAALDJYhiGYXYQ8FyGYUjZ2WaH4TqsVlksFrOjgAswDENZWdx+L/L2tvC7AY9FLrwEeRD/Qx7MizwIAAAAAHBlFBMBAAAAAAAAAAAA2MQ0pwAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwCaKiQAAAAAAAAAAAABsopgIAAAAAAAAAAAAwKb/BzE5rB+bbDfuAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -554,7 +563,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABxMAAAETCAYAAAD9HCj7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABT+klEQVR4nO3dd3gUVdvH8d/uppOEUBIglID0AFJFBKkiqKggKFghoiJilxcLKiD2Do88YBcUVBRBBQRRAVFRRIq00EIVkBJISCF15/0DyUPMAtlkd2fL93NdXBfZ3TPnZnOYe2bumXMshmEYAgAAAAAAAAAAAIB/sZodAAAAAAAAAAAAAADvRDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERZWKxWDRu3Liin6dOnSqLxaJdu3aZFtPZ/DtesyUlJclischisah58+Zn/eyp7/aPP/7wUHTwVv369Sv1uAEAAAAAAAAAwBUoJpooJSVFd955p8477zyFhYUpOjpanTp10sSJE3XixAmzw4ObVa1aVR999JFeeOGFYq/XrVu3zIXPbt26KSkpqUxtx40bp7p165apbWmU59+VlJSkbt26OdVm6dKl5SpwWywWTZ06tUxtXcFR/A8++KA++ugjNWnSxLS4AAAAAAAAAACBJcjsAALV/Pnzdd111yk0NFSDBw9W8+bNlZeXp59//lmjRo3Sxo0b9fbbb5sd5hmdOHFCQUG+M3y8Md4KFSro5ptvNjsM+JCuXbtKkt59910dOXLE5GgAAAAAAAAAAIHAu6orAWLnzp26/vrrlZCQoMWLF6tGjRpF7919993avn275s+fb2KE5xYWFmZ2CE7xtXgBAAAAAAAAAAC8AdOcmuCll15SZmam3nvvvWKFxFMaNGig+++/v+jngoICPf3006pfv75CQ0NVt25djR49Wrm5ucXa1a1bV1deeaWWLl2qdu3aKTw8XC1atNDSpUslSbNnz1aLFi0UFhamtm3bas2aNcXaJyUlKTIyUjt27FDv3r1VoUIFxcfHa/z48TIMo9hnS7sG4YIFC9S5c2dVqFBBUVFR6tOnjzZu3HjOduPGjZPFYinxuqO1Gf/44w/17t1bVatWVXh4uOrVq6ehQ4eeNd5T29++fbuSkpIUExOjihUr6tZbb1V2dnaxtidOnNB9992nqlWrKioqSldffbX27dvn8DvYvHmz9uzZc85/X1nk5ubqoYceUmxsrCpUqKBrrrlGhw8fdktfp5s+fbrat2+viIgIVapUSV26dNGiRYskSYsXL5bVatWYMWOKtfn4449lsVg0ZcoUt8TUrVu3orUD//3HnVOT7tu3T7fddpvi4+MVGhqqevXq6a677lJeXl7RZ9LS0vTggw+qbt26Cg0NVa1atTR48OCiJwmHDBmisLAwJScnF9t27969ValSJe3fv99t8QMAAAAAAAAA4CyeTDTB3Llzdd5556ljx46l+vztt9+uadOm6dprr9XIkSO1YsUKPf/880pOTtacOXOKfXb79u268cYbdeedd+rmm2/WK6+8oquuukpvvvmmRo8erREjRkiSnn/+eQ0cOFBbtmyR1fq/mnJhYaEuu+wydejQQS+99JIWLlyosWPHqqCgQOPHj3fq3/nRRx9pyJAh6t27t1588UVlZ2drypQpuvjii7VmzRqXrM936NAh9erVS7GxsXr00UcVExOjXbt2afbs2aVqP3DgQNWrV0/PP/+8Vq9erXfffVdxcXF68cUXiz6TlJSkzz77TLfccos6dOigH3/8UX369HG4vaZNm6pr165FBVxXuvfee1WpUiWNHTtWu3bt0oQJE3TPPfdo5syZLu/rlKeeekrjxo1Tx44dNX78eIWEhGjFihVavHixevXqpR49emjEiBF6/vnn1a9fP7Vp00YHDhzQvffeq549e2r48OFuievxxx/X7bffXuy16dOn69tvv1VcXJxb+ty/f7/at2+vtLQ0DRs2TE2aNNG+ffs0a9YsZWdnKyQkRJmZmercubOSk5M1dOhQtWnTRkeOHNHXX3+tv/76S1WrVtXEiRO1ePFiDRkyRL/++qtsNpveeustLVq0SB999JHi4+PdEj8AAAAAAAAAAGViwKPS09MNSUbfvn1L9fm1a9cakozbb7+92Ov/93//Z0gyFi9eXPRaQkKCIclYvnx50WvffvutIckIDw83du/eXfT6W2+9ZUgylixZUvTakCFDDEnGvffeW/Sa3W43+vTpY4SEhBiHDx8uel2SMXbs2KKfP/jgA0OSsXPnTsMwDCMjI8OIiYkx7rjjjmJx//3330bFihVLvP5vY8eONRwNz3/3M2fOHEOSsXLlyrNu79/xntr+0KFDi33ummuuMapUqVL086pVqwxJxgMPPFDsc0lJSSW2eaqfrl27njUWwzj5XSckJJzzc4bxv39zz549DbvdXvT6gw8+aNhsNiMtLa1U23HWtm3bDKvValxzzTVGYWFhsfdOjyMrK8to0KCB0axZMyMnJ8fo06ePER0dXWy8udsvv/xiBAcHl/h9utLgwYMNq9XqcKyd+j7GjBljSDJmz559xs8Yxv/+Xz7zzDPGjh07jMjISKNfv36ljqVr165Gs2bNyvCvAAAAAAAAAADAOUxz6mHHjx+XJEVFRZXq8998840k6aGHHir2+siRIyWpxNqKiYmJuuiii4p+vvDCCyVJPXr0UJ06dUq8vmPHjhJ93nPPPUV/t1gsuueee5SXl6fvv/++VDFL0nfffae0tDTdcMMNOnLkSNEfm82mCy+8UEuWLCn1ts4mJiZGkjRv3jzl5+c73f7fT8517txZqampRb+nhQsXSlLRE52n3HvvvQ63ZxiGW55KlKRhw4YVm/q1c+fOKiws1O7du93S35dffim73a4xY8YUe3pVUrE4IiIiNHXqVCUnJ6tLly6aP3++Xn/99WLjzZ3+/vtvXXvttWrVqpUmT57slj7sdru+/PJLXXXVVWrXrl2J9099H1988YVatmypa6655oyfkaRevXrpzjvv1Pjx49W/f3+FhYXprbfeckvsAAAAAAAAAACUB8VED4uOjpYkZWRklOrzu3fvltVqVYMGDYq9Xr16dcXExJQoJP27gFOxYkVJUu3atR2+fuzYsWKvW61WnXfeecVea9SokSQVW6fwXLZt2ybpZBEzNja22J9Fixbp0KFDpd7W2XTt2lUDBgzQU089papVq6pv37764IMPSqwneSb//r4qVaok6X/fy6nvv169esU+9+/fhyecK1ZXS0lJkdVqVWJi4jk/26lTJ9111136/fff1bt37xJrVrpLQUGBBg4cqMLCQs2ePVuhoaFu6efw4cM6fvy4mjdvftbPpaSknPMzp7zyyiuqXLmy1q5dq//85z9um54VAAAAAAAAAIDyYM1ED4uOjlZ8fLw2bNjgVLvTn2o6G5vN5tTrhmE4FUdp2e12SSfXTaxevXqJ94OCzj70zvTvLSwsLPG5WbNm6bffftPcuXP17bffaujQoXr11Vf122+/KTIy8qz9ePp7KQ9vjjU3N7foicyUlBRlZ2crIiLC7f2OGjVKv/76q77//nvVqlXL7f250po1a4qK6uvXr9cNN9xgckQAAAAAAAAAAJTEk4kmuPLKK5WSkqJff/31nJ9NSEiQ3W4vetLvlIMHDyotLU0JCQkujc1ut5eY+nTr1q2SpLp165Z6O/Xr15ckxcXFqWfPniX+dOvW7aztTz11l5aWVuz1M03p2aFDBz377LP6448/NGPGDG3cuFGffvppqeM9k1Pf/86dO4u9vn379nJv29vVr19fdrtdmzZtOudnx44dq+TkZL3yyivauXOnHn30UbfH9+mnn2rChAl65ZVX1LVrV7f2FRsbq+jo6HPeBFC/fv1S3SiQlZWlW2+9VYmJiRo2bJheeuklrVy50lXhAgAAAAAAAADgMhQTTfDwww+rQoUKuv3223Xw4MES76ekpGjixImSpCuuuEKSNGHChGKfee211yRJffr0cXl8kyZNKvq7YRiaNGmSgoODdckll5R6G71791Z0dLSee+45h2sZHj58+KztTxUjly1bVvRaVlaWpk2bVuxzx44dK/FkXqtWrSSp1FOdnk3v3r0lqcRafG+88YbDz2/evFl79uwpd7/eoF+/frJarRo/fnzRk6annP6dr1ixQq+88ooeeOABjRw5UqNGjdKkSZP0448/ui22DRs26Pbbb9fNN9+s+++/3239nGK1WtWvXz/NnTtXf/zxR4n3T30fAwYM0J9//qk5c+ac8TOS9Mgjj2jPnj2aNm2aXnvtNdWtW1dDhgxxyZgFAAAAAAAAAMCVmObUBPXr19fHH3+sQYMGqWnTpho8eLCaN2+uvLw8LV++XJ9//rmSkpIkSS1bttSQIUP09ttvKy0tTV27dtXvv/+uadOmqV+/furevbtLYwsLC9PChQs1ZMgQXXjhhVqwYIHmz5+v0aNHKzY2ttTbiY6O1pQpU3TLLbeoTZs2uv766xUbG6s9e/Zo/vz56tSpU7Gi5b/16tVLderU0W233aZRo0bJZrPp/fffL9rGKdOmTdPkyZN1zTXXqH79+srIyNA777yj6OjookJsebRt21YDBgzQhAkTlJqaqg4dOujHH38selrz39OxNm3aVF27di2a8tMbdOvWTT/++KPT06E2aNBAjz/+uJ5++ml17txZ/fv3V2hoqFauXKn4+Hg9//zzysnJ0ZAhQ9SwYUM9++yzkqSnnnpKc+fO1a233qr169erQoUKZ+zj1NOuzqzHKUm33nqrJKlLly6aPn16sfc6duxYYt3PU5YuXaru3btr7NixGjdunFN9Pvfcc1q0aJG6du2qYcOGqWnTpjpw4IA+//xz/fzzz4qJidGoUaM0a9YsXXfddRo6dKjatm2ro0eP6uuvv9abb76pli1bavHixZo8ebLGjh2rNm3aSJI++OADdevWTU8++aReeuklp+ICAAAAAAAAAMCdKCaa5Oqrr9a6dev08ssv66uvvtKUKVMUGhqq888/X6+++qruuOOOos++++67Ou+88zR16lTNmTNH1atX12OPPaaxY8e6PC6bzaaFCxfqrrvu0qhRoxQVFaWxY8dqzJgxTm/rxhtvVHx8vF544QW9/PLLys3NVc2aNdW5c+eiYtCZBAcHa86cORoxYoSefPJJVa9eXQ888IAqVapUrO2p4uqnn36qgwcPqmLFimrfvr1mzJihevXqOR2zIx9++KGqV6+uTz75RHPmzFHPnj01c+ZMNW7cWGFhYS7pw50yMzMdrltZGuPHj1e9evX0xhtv6PHHH1dERITOP/983XLLLZKk0aNHa/v27Vq+fHnRdxESEqJp06apQ4cOGjVqVImnOk+XlZWlBg0aOB3X4cOHlZWVpWHDhpV474MPPjhjMTEzM1OSVKNGDaf7rFmzplasWKEnn3xSM2bM0PHjx1WzZk1dfvnlRetDRkZG6qefftLYsWM1Z84cTZs2TXFxcbrkkktUq1YtZWRkaOjQoWrdurUef/zxom137txZ999/v1599VX1799fHTp0cDo+AAAAAAAAAADcwWI4+7gS/FZSUpJmzZpVVHDBma1du1atW7fW9OnTddNNNzndPikpSYsXL9bq1asVFBSkmJgY1wcpKSMjQ5UrV9aECRN09913u6WPstq0aZOaNWumefPmuWW6XkcefvhhffLJJ9q+fbtCQ0M90qcrZWRkKDc3V3379lV6enqp1mcEAAAAAAAAAKA8WDMROIcTJ06UeG3ChAmyWq3q0qVLmbe7d+9excbG6uKLLy5PeGe1bNky1axZs9iTrt5iyZIluuiiizxWSDzV55NPPumThURJuuWWWxQbG6vly5ebHQoAAAAAAAAAIEDwZCKK8GSiY0899ZRWrVql7t27KygoSAsWLNCCBQs0bNgwvfXWW2Xa5qZNm7R//35JJ6fGZFpLlMa6det06NAhSYwbAAAAAAAAAIBnsGYicA4dO3bUd999p6efflqZmZmqU6eOxo0bV2zNO2clJiYqMTHRhVEiEJx//vlmhwAAAAAAAAAACDA8mQgAAAAAAAAAAADAIdZMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADgWZHQDMd+Bwtr74fpcOpp5QkM2iBnWi1f+SugoPY3gAAPxfekaeZn23U3sOZMmQoVrVKujaS+upcsVQs0MDAMDtcvMK9dWS3dq8M115+YWKrRSm/j3rqnb1SLNDAwAAMJ3dbmjx7/u1Yt1hZecUqGJkiHp3qqmWjauYHRrgURbDMAyzg4A5Nmw7qvFvrdHs73fLbhiy2SySIRUUGoquEKw7BjTWE8NaKSaai6kAAP+z/1CWxr+1VtO+3qac3EIF2SySpMJCQ8HBVt14RX2Nu6u1EuKjTI4UAADXy8rO17Pv/Kk3P0/WseN5CrJZZLGcPB+UpKu61tHY4a3VJrGqyZECAAB4nt1uaMpnyXrtww3a8VeGbFaLrFap0G7IbpcubBGr0be31NXdE8wOFfAIpjn9R1ZWlu6//37FxcUpKipKSUlJmjp1qoKDg5WTk2N2eC635Pf9uvCmuZr9w24V2g0ZhlRQYBSdOB7PyteE6RvV4ea5OnA42+RoAQCeEEi5cMvONLW74Su9O3uLcnILJZ28eFpQaMiQlJdv1/R529X2+q/055ZUc4MFAHhEIOXB1LQcXTxknl78YJ2OHc+TdDIP5hecPDc0DGn+T3t10S1zNe/HPSZHCwDwhEDKg8C5FBTYddOjS3XPc79q574MSSeLiPkFJwuJkrRy4xH1vf97vfDenyZGCngOTyZKKigo0CWXXKL9+/dr3Lhxqlq1qp577jlt27ZNlStX1oYNG8wO0aU2bj+m9jd+rZy8gqKd35nYbBY1Oy9Gv824mmlPAcCPBVIuPHIsR60HfqkDR7JVWHj2wyCb1aLKFUO19vN+io+r4KEIAQCeFkh5sKDArs5J87RywxEV2s+eBy0WKTjIqp+nXakLmsd6KEIAgKcFUh4ESuOe55Zr8qfJKm3h5P3xnXVrv0ZujQkwG9UhSRMnTtTatWu1ZcsWVa9eXZLUpEkT1a1bVz169DA5Otd7+u01ys0vPGchUTo51du6bcc089sdSurLDhEA/FUg5cIpnyVr/+Gs0uVBu6Gj6bmaMH2jXnqovfuDAwCYIpDy4NdL9+i3dYdL9VnDOHlOOOa/q7VgSm83RwYAMEsg5UHgXHbty9DkmaUvJErSI6+v1M19Gig4mIkg4b8CfnQbhqHXXntNd9xxR1GylKSEhAQFBQWpZcuWkqTk5GRdcMEFatSokXr06KEDBw6YFXK5/H0kW198t+ucT2KczmqV3vh4kxujAgCYKZByYUGBXf/9NLlUhcRTCu2G3p61WSdyCtwXGADANIGUByXpjU82yWa1lPrzhXZD3y7/Szv+Ou7GqAAAZgm0PAicy1uzNstiKf2xkiQdPpajr5bsdlNEgHcI+GJicnKy9u/fr379+hV7/cCBAyooKFCrVq0kScOHD9cTTzyhrVu3qm/fvnr00Uc9H6wLzPlnjURn2O3S6uRUpezl5BEA/FEg5cJf1h7UwdQTTrdLz8zX97/td0NEAACzBVIePHz0hJauPOD0OaHFYtFn3+50U1QAADMFUh4ESmP6vO2yO3msZLNa9MmCFDdFBHiHgF8z8bvvvlOvXr20ZcsWNWr0v2k8P/zwQw0ZMkSHDh2S3W5X69attX//yYuImZmZio+P1/HjZS+uJSQkKD09vdzxOysnupdyK/aULDan21b4+z8KyuMOCwC+qWLFitq9m32YI2bkQrPyYH74+cqOHVKmtuGpnykka4WLIwIAzyAPnlkg5cHCoGrKjH/Y+YZGgUIyflF42teuDwoAPIRc6Fgg5UGgNNJrvyBZgp1uZ8vdpciDb7ghIsA1ypsHA/7JxCpVqkiSUlL+d+dAVlaWnnnmGdWoUUOxsbH666+/VLt27aL3IyMjFRYWptTUVI/HW36FJrUFAHirwMqFTsxvWgJ5EAD8UWDlQc4HAQDFBVYeBErBKON1A4OlUeDfgswOwGzNmzdXQkKCRo4cqYKCAhUUFOjFF19URkaGWrdu7bZ+zboT6rNvd2jQqCVOt7NZLdq15Q9VrRTmhqgAAGYyIxealQc3bDuqFgPmlKnt9/NnqGOrai6OCABgtkDKg5nZ+araZbpy85y7SGaxBOm/r47R7QNmuCkyAIBZAikPAqXR6ro5Wr/1qJyZ6TTIZtHQm/vorTHPuy8wwGQB/2RiSEiIZs2apfDwcA0aNEjjx4/XE088oZiYmKI5wWvVqqW9e/cWtcnMzFROTk7RnTu+pG/3BFWKDnGqTZDNov49EygkAoCfCqRc2LxhZbVvHiurtfSLqVssUuO6FXVRyzg3RgYAMEsg5cHIiGDdcmUDBdlKnwclKTwsSIMuq+emqAAAZgqkPAiUxohBTZ0qJEpSQaGhYdc2cU9AgJcI+GKiJLVr106rVq1Sdna21qxZox49emjr1q1q2bKlJKlatWpq0KCBvvrqK0nSe++9V2JRYl8RGmLT8OuaOnURtaDQ0IhBiW6MCgBgtkDKhffemOjcYuqGdN+NibJYnLvwCgDwHYGUB+8a2FQFhaXPgzarRUl9GyqqgnM3pQIAfEcg5UHgXG68or4qhAeptJcAbFaL2jStoraJVd0bGGAyi2EYTtbZ/d9vv/2miy66SJs3b1bjxo0lSRs3btSQIUOUnp6uWrVqacaMGYqPjzc50rLJyMpTp8HztGlHmgrPcRJpkTR8UBP9d3RHLqICQADx51xYWGhX/wd/0Lwf95zzbkOr1aLuF1TXgsmXKTiYe7AAIFD4cx6UpMcmrtQL76075+eCbBYlxEfq94/7qnLFUA9EBgDwBv6eB4FzmbVopwaOWixJOlv1xGa1KDTEpl+nX6XzG1X2UHSAOSgmOvDmm29q5MiRysjIkNXqnxcOD6We0BV3f6tVm1JltVpKPKERZLP880RiU/3n0Q6y2fzzewAAOObvufBEToFuGf2jvvh+l2w2S4mba0691rtjTc167RJFRgSbFCkAwAz+ngftdkOj//OHXnx/XdG53+msVslul5rVj9HCKZepVvUKJkUKADCDv+dBoDRmzN+upCeWyTCkQgd3IlssUkxUiL75b291YFkUBACKiQEsN69QX3y3S298slG/rTtc9HqQzaIBPetqxKCm6ty2Ok8kAgD8kt1u6Ntf/tKkTzdpwc9/FbvbsGeHeN1zQ6Ku7FKbG2oAAH5rxbpDmjwzWZ8s2KH8AnvR622aVtG9NyZqUO/zFB4WZGKEAAAA5knZe1xvfrZZ73yxWemZ+UWv16pWQffekKih1zRS1UphJkYIeA7FREiS9hzIVOI1X8giafe31zOFDQAgoBxMPaEGfT6TJG2de51qxEaYHBEAAJ6TdjxXtXt9KkPS+ln9Va9WlNkhAQAAeI0TOQWK6zZDhqQ/PumrhnWiufEYAYdbDCFJqlMjUkH/7AApJAIAAk21KuFFJwIUEgEAgSYmOrQoD1JIBAAAKC48LKjoWKlJvRhzgwFMQvkcAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4RDERAAAAAAAAAAAAgEMUEwEAAAAAAAAAAAA4FGR2AADcY3+2lJZndhSlFxMixUeYHQUA+Cbj4CEZxzPMDsMplugoWarFmR1GwGCMlMSxEgB/5mv7OIn9HAAA7uRrxwYcF3gfiomAH9qfLV27WMqzmx1J6YVYpVk9SBIA4Czj4CEVjHhIys83OxTnBAcraPJrFBQ9gDFSEsdKAPyZL+7jJPZzAAC4iy8eG3Bc4H2Y5hTwQ2l5vpUcpJPx+tLdMQDgLYzjGb5XJJKk/Hyfe1LOVzFGSuJYCYA/88V9nMR+DgAAd/HFYwOOC7wPxUQAAAAAAAAAAAAADlFMBAAAAAAAAAAAAOAQxUQAAAAAAAAAAAAADgWZHQDMV1ho14HDJ1RoNyRJh1JPKLZymCwWi8mRmSc9I09H03OVX2BXaIhV1aqEKyyU/y4A4I8Mw9DfR/6XB/cfylKN2IiAzoMAgMBy5FhOUR7c+3emalSNUFBQ4N57nJdfqL+PnFBObqGCgiyqFB2qStGhZocFAIBHnLpWfCK3QBaLRdEVggP+WvHxzDzZ7YYMSbv3ZyiucrjCw7hWjMDCiA9AhmFo2aq/NeeH3Vq16YjWbE5V1omCoverdf9Y1aqEq21iFbVvHqubr2yg+rWjTYzY/Y4dz9WM+Sn6afXfWrXpiFL2ZhR7P8hmUbMGldQ2saou7RCv/j3rKiTYZlK0AIDyWr/1qD5ZsEMrNx7W6uRUHU3PLXqvZs9PVTEyRG2aVlG7ZlU16LLz1DaxqonRAgDgWnsOZOqjudu1Yv1hrUo+ov2Hsoveq9NrpsJDbWrVpIraJlbV1d3q6JIL42W1+u8FxMJCu+Yv26tvfv5LqzYd0bqtR5WXby/2mTo1KqhtYlV1bFlNN19ZX9WrRpgULQAArmUYhn5efVCzf9hVdK04M7ug2GfiKoepbWJVtW8eq5v61FfDhIomResZacdzNeObU9eKU7V9z/Gi9+pe9plsNoua1a+ktolVdGmHmurfs65CQ7hWDP9mMQzDMDsIeEZuXqHenb1Fk2cma1NKmlNtL+tUS/fdmKjLLq7lV3ehrN96VBNmbNTH81OUk1dY6nZxlcN0x4DGuvfGZqpWJdyNEZbNpjRp8DKzo3Deh12kxBizowDgr+x2Q58v2qlJn2zSz2sOOtW2ffNY3X19U93Up75sNu96UsO+LUWFI0ebHUaZ2F59TtaG9c0Ow+8xRkriWAmBavGK/Zo4Y6PmLdsru730lwIaJVTUXQObaNi1TRQR7j/3JKcdz9Xkmcl6a9Zm7TmQVep2QTaLBlxaVw/c1FwdWsa5McKy8dV9nMR+DgA8KS+/UO/P2arJM5O1ftsxp9r26lhT996QqD5davvVteKN249pwvQNmjE/RSdyS3+tOLZSmG7v31j33pioGrHed8ORrx4bcFzgXbzrahjcZuWGw2oz6Evd89yvThcSJWnhL3/pirsX6dqHFutg6gnXB+hhefmFenLSKrUe+KXen7PVqUKiJB06mqNn3/lTTfvO0oz520VNHgC8286/MtTzjgW6/uElThcSJen3DYc15IllunjIPG3emeb6AAEAcKOj6bm6ZfRSXXLHAn29dI9ThURJ2ro7XQ++vELnXztbP636201RetY3P+1Vs2tm6/E3VjlVSJSkgkJDMxfu1EW3zNW9z/+qzOx8N0UJAIB7rN50RO2u/0p3PbPc6UKiJC1avk9X3fudrnnge/19JPvcDbxcXn6hnpqyWq2um6N3Z291qpAoSYeP5ej59/5UYr8v9OHX27hWDL9EMdHPGYahsf9drQ43zy1TEfHfZv+wS836faF5P+4pf3Am2bIzTe2u/0rPvL22aF2Qsjp2PE83P/aj+j/4g45n5rkoQgCAK039aqtaDJitJSsPlHtbv607rFbXzdF/P93kgsgAAHC/xSv2q1m/LzR9Xkq5t5WyN0Ndh87X/72yQoWF9nM38EK5eYW6bexP6nP3Iu0/XP6Ln5M+2aTzB8zWyg2HXRAdAADuZRiGnn5rjdrf+HWZioj/9tWSPUrs94W+XLyr/MGZZNvudLW/8WuNm7JGBYXlu1aclpGnIU8sU9/7vld6BteK4V8oJvoxu93Q7eN+1vi31jh95+nZpKbnqt/932v6vO0u26anrN2cqouHzHNJsjzdl4t365I7FhRbcwsAYL6X3l+nW5/8qdjawOWVm2fXPc/9qicnreJuQwCAV5vzwy5dPuJb/e3C2WUMQ3r1ww268dGlys/3rYJi9okCXXnPIr0/Z6tLt7tzX6Z63PaNlrrgxiUAANzFbjd01zPLNea/q8v9gMXpjh3P04CHftDUr1ybXz1h/daj6pw0T39uOerS7c79cY+63TZfR47luHS7gJkoJvopwzB097PLXX6SdEqh3dCQJ5bpi+92umX77rBlZ5ouHbZAR9LcU/D7Y+MRXX7Xt8rI4q4TAPAGkz7ZpEcmrHTb9p95e62ef/dPt20fAIDy+PaXvzRo1BLluang99m3O3XrmGUuvXHVnfLyCzXgoR/0/W/73bL9zH8KlSvWHXLL9gEAKA/DMPTAS7/prc83u2X7drs0dMxPmrlwh1u27w7bdqer57AFOpjqnoLf2s1H1Xv4Qmazg9+gmOinps/brjedTA67Fg7SroWDSv15+z8FxZ1/ZTgbnsfl5Rfquv9b7FQh0dnvQzq5ptbIV353NjwAgIv9vv6w7n/xN6falGW///gbq7R4hXsuSgIAUFYHDmfrhkeWKL+g9IXEsuTBGfNTNOWzZGfDM8Uzb6/Vwl/+cqqNs99J1okCXfd/i5nWDADgdWYu3KE3PnZuuQ5n86BhSLc+uUzbdqc7G57H5efbNWjUEh06WvpCYlmOlVYnp+q+F5y7NgF4K4qJfujA4ewy7aQqRgarYmSwU22yThRo6NifvP5u1GfeXuv01KZl+T4k6Z0vtmjRcudOUgEArpOTW1CmJyXKut+/bexPyszOd7odAADuYBiG7hz/i44dd66gVdY8+PBrv2vHX8edbudJqzcd0XPvOD+bQFm+k71/Z+n/Xl3hdF8AALjLwdQTuue5X51uV5Y8eCK3UEPHeP+14hfe/1NrNqc61aasx0rTvt6m+cv2ON0O8DYUE/3Qvc//qjQP3gm5dOUBvTd7i8f6c9bG7cfKdOJYHreP+1kncly3PhcAoPSef3edNqWkeay/Xfsz9cQbqzzWH8xjGAbrZALwep8v2qm5P3ruglV2TqHuHP+Lx/pzlt1uaOjYn1y6NtS5vDt7q5b8zswFAADv8MCLvyk13T3LPjny85qDetOLZy7YvDNNT7+11qN9DnvqF2VxEzJ8HMVEP5Oy97i++H6Xx/t9ZdoGr724NmH6Bo+eOEon70b9fJHvrCcJAP7iRE6B3vhko8f7feeLzUo77rmTM3jOodQTev7dP1XvspkKbv2Bglq9r+rdP9ZjE1dq1z7vn+odQOB5eep6j/f5/W/7tdbJu/s95fvf9unPLUc93u+rH27weJ8AAPzbrn0Zmvmt59cxfPXDDV77dOJ/Zmx0aip4V9h/OFufLPCd9SQBRygm+pk3P3PPIrrnsnV3uhavOGBK32eTdjxXM+anmNL35JneewcOAPirmd/ucHpaN1fIzinUh3O3e7xfuNd/ZmxUrUs/0eNv/KFd+zNVaDdkN05OE/TSB+t13hWfadSrv3vtSTKAwLNyw2H9sfGIKX1769qJZp2XffPTXu38i5tOAADmenvWFpnx/MeOvzK0aPk+z3d8Dscz8/TRPHPO3SfPTPbah3GA0qCYeJqsrCzdf//9iouLU1RUlJKSkjR16lQFBwcrJ6f0i7GapbDQrve/3Gpa/+/MNqeQeTYff5OiE7mFpvS9Yv1hrd/q+TtgXS116QytGRRZ4s+qflbteuM2s8MD4EK+ngelk+vWBmLfrtRz+RK9vav4ydX2rAyFzP3MpIjM8dL763T/i78pv8BwePJtt598/ZVp6zX86V8C6qSQMVIcx0r+gzxYPtPnpSj7hHct9fD3kWzN/XGvKX0bhkw9P3cl9nNAYPCHPIji7HZD783hHPl0MxfuUGa2Occrazanak2yd87k4AyOCwJXkNkBeIuCggJdccUV2r9/v15//XVVrVpVzz33nBYtWqTGjRsrLCzM7BDPafPOdB314PzX//bLmkOm9X0mv6w1N6Zf1h5Ui0aVTY2hvKp0u0lVut1U7LW0FV9r5+s3q1rfkSZFBcDV/CEP5uYVauUGc57GkKQN248p7XiuYqJDTYsBrvHbn4f0yISVpf78O19sUbd2NXRjn/pujAreimMl/+APeVA6ef5hluycAv25NVUXtaxmWgz/9tu6Q6Y+Pf7LGvN+H67Efg7wf/6SB1Hc9j3HdeioeYXgX9YelGEYslgspsXwb95wrbhNYlVTYygvjgsCF8XEf0ycOFFr167Vli1bVL16dUlSkyZNVLduXfXo0cPk6Epn1SbzLqBK0l8Hs3Qw9YSqVQk3NY7TmTXFj7f07w45+7dp18TBSrj7HYXXSTQ7HAAu4g95cP22ox5f9+DfVienqseF8abGgPJ745NNstksKiws3QVoq9WiCdM3UEyEJI6VfJU/5MHM7Hwl70gzNYZVm7yrmGj2+djq5FSvu4jqCuznAP/jD3kQJZl9rfhg6gntO5itWtUrmBrH6f7YeNjk/rlWDN/FNKeSDMPQa6+9pjvuuKMoYUpSQkKCgoKC1LJlS0nSnXfeqZo1a3rticAaL1jwfrXJSep0mdn52ro73dQYVvvBo+unK8zJUsoL/VXlkqGq3HmQ2eEAcBG/yYNesM/1t/1+IDp89IQ++3ZHqQuJ0snpg1ZuPOJVx0EwB8dKvslf8uC6rUdNWRPpdKuTvWs/aPY5cnpmnnb42bqJ7OcA/+MveRAlmZ0HJe86NjiRU6DknVwrdiWOCwKLxQikBV7OYNOmTWrWrJl++uknXXzxxUWvHzhwQPHx8Vq0aJEuvfRSLVu2TI0bN1b16tXLvS5OQkKC0tNdu/PKrnKD8iu0c/jeroWDVDEy+KztK0aFSJLSM/LO+rn0zHzVvWymw/fCj8xQSPbqUkTrfnZbjDJqPunwPU99H5aCo4re/2wponWt0HqtVPuppS7f7o5Xb1R+6j41evoHWWyuf7B579huyt251uXbBSSpYsWK2r17t9lheCV/yYM50T2UG9PH4Xue2u+Hpn+vsPQFpYjWdVpGRuv7Nhe5bHs9ly/RymNHFWL93z1ndhnKKChQ3lUDXdaPJPVc/av+zDzu0m2WV0FoA2VVu6tMbcNTP1NI1goXR1R+jJGSAvFYiTx4Zv6SB/PDE5Ud63idGk/lwaDsDapw5INSROsZmdXuU2FogsP3PPWdVPh7goLyPLtuo7v2cZJ37+eAcyEXOuYveRAlZVceqPzICx2+57FrxamfKiSr9EtIuJPdGqWMWuMcvueR78MwZCk8ruj940sVrysF4vkPSipvHmSaU0n79u2TJMXFxRV7/bvvvpMktWrVSpLUpUsXj8blPJvZAUgWL4ihiMkP3hqGvOJ34iIH505U5vqlavr6arckBwDm8Z88aP6EC4bFP/aPLzdrqWF1GxT9vD0rQ4mLPVskNYthDSljQ3vZ2/qgQB4jZ8Kxku/ynzzoBeceXnU+KBkW848N5CfHBhL7OcBf+U8eRAlekZe9IYZ/eMP34Q0xuAjHBYGH37KkKlWqSJJSUlLUqFEjSVJWVpaeeeYZ1ahRQ7GxsS7v0x13QiU9sUzTvt7m8L0z3R1yumM/3yxJqnTx9DLH8N47b+qGK7xjvaB9B7NU69JPHb7nke/DYlHdhFrasSmtbO3LYVOaNHiZ67aXueln7f9otBo+tUjBlaqfu0EZLVmyVIkxbts8gDPwlzz40vvr9MgEx3c8eioPjhp5v56596Myty8L+7YUFY4c7dE+XWXJkiWyNvSO44ZTflr1t7rcOt/5hharpkx6VUl9G7k+qHJijJTEsRJO5y95cP6yPbrynu8cvuepPHjVlZdp9uuvlLm9q3W8Za5+/fOQw/c89Z0sXbxI7Zq5fgydjav3cRL7OcCf+UseREl3jPtJ787e6vA9T+XBN6e8ocFXNyxze1c6lHpC1bp/7PA9T10rrhlfTXs3ppWtfTlw/gNXoJgoqXnz5kpISNDIkSNVUFCggoICvfjii8rIyFDr1q3NDq/UanvBYrbeEMMpsZXDFBJsVV6+3bQYvOn7KKv8oweU8tJ1qjn4BUU27WR2OADcgDzoyhgizQ4B5XRB86qKiQpR2jmmrvk3q9WiXhfVdFNU8GYcK/k+/8mD5uegWtXMz8Wnq129gn790+wYzP+9lBf7OcC/+UseREnekIO84Tz9lMoVQxUeatOJ3ELTYvCm76OsOC4IXF4w54f5QkJCNGvWLIWHh2vQoEEaP368nnjiCcXExBQ9yu8L2jStYmr/FovUqom5MZwuJNim8xtVNjWGtone832U1eFF76jg2N/a99FjWjMostifbU9dbnZ4AFzAX/Jg28SqZofgF/v9QBcWGqRh1zaWzWopdRubzaJ+3esoPs73TwzhPI6VfJ+/5MHE82IUFmru1Fltm5qfi09ndjw14yJUrUq4qTG4Avs5wL/5Sx5ESWZfKz4Zg/ccGwQFWU2/du0N1y3Ki+OCwMWTif9o166dVq1aVfRzdna2tm7dqpYtW5oYlXPM3hk1qRejyIizL1TraW0Tq+qPjUdM7d/XxV8/RvHXjzE7DABu5g95sEGdaEVVCFZGVr4p/QcHWdWiobk3sbjC9x27l3itQYUo5V010IRozDFiUFNNnpms7JxC2e3GuRsY0sO3nu/+wLwEY6Q4jpX8gz/kwaAgq1o2qqwV6w+bFoO33VRj9vmY2f27Cvs5wP/5Qx5ESWbnoQZ1olUxyrvWlW+bWPWMU6B7pn/vOlYqC44LAhdPJp7BunXrZLfbi92Bk5SUpFq1akmSatWqpVtuucWk6ByrXb2CGtetaFr/l3aIN63vMzFzujGb1aLuF9QwrX8AKA9fzINWq0WXdjBvv9+lbXWFhvjPYuqBLCE+Sl//51KFBFnP+oSixXLyz9RnuujC8+M8GCEAd/PFPChJvTqalwdrxkWo6XkxpvXvyIXnxyrKxBteL2X6awA+ylfzIIqrERuh5g0qmdY/14qLs1ot6tHe+74ToLR4MvEM1q5dq4iICDVs+L8FYqdOnWpeQKVgsVh018AmeuClFab0f9egpqb0ezZXda2j+NgI7T+c7fG++/VIYLozAD7LF/OgJN01qIlm/7DLlL5HeGEeRNl1bx+vZVP7aPjTv2h1cqqCbBYVFJ58SvHU38+rFaX/PHqRruhc2+RoAbiar+bBOwY01rPv/Fm6p6pd7M7rmshm8677lSMjgjX46gb676fJHu+7QniQbrmygcf7BQBX8NU8iJLuGthEdz/3q0l9e9858hWda6lOjQracyDL43336VxbdWqYv44lUFbedaTvRYYPH66srCxZrb71FQ25uqHCTVgno0f7GmpSL8bj/Z5LcLBVw65tbErfXFQG4Mt8NQ/2aB+vRgmef0o/PjZCV3er4/F+4V4XNI/Vqpn9tPKTq3XHgMYKsllks1l085UN9MM7l2vbvOsoJAJ+ylfzYO3qkabkoyCbRbf3N+e861zMupB585UNvG5qNwAoLV/Ngyjp5isbKDLC888TdW5TTS0aed8yIDabVXde28SUvrlWDF9HRvAzMdGhevCW5h7vd8zw1h7vs7Tuvj5RVWNCPdpnl7bV1b09U5wCgKdZrRaNNSEnPXlnKwUFcVjlr9o1i9XkJzqpQkSwIiOC9cHTXdTjwnhZLGeeAhUAzPLEsFZnnaLZHYYPbKoasREe7bO0mjWopOt61fNon+GhNo1KauHRPgEAcCQ6MkQjB3s+J40d3sbjfZbW8IFNVa1KmEf7vKhlnKnT0QOuwFUvPzRmeGs1qx/jdLv0zHylZ+Y73e6eGxLVtZ33Fs6qVgrT5Cc6Od2urN9HRJhN74/vzAVGADDJDVecp77dnX8qo6z7/R7ta2iYSXc2AgDwb20Tq+qRoec73a6sebBezUg9f387p9t50qTHLirTDaZl/U5eeOAC1a8d7XQ7AADcYfQdLdWysfNPCZY1D955XRNd4oXrJZ5SuWKo3nzSc9eKw0Js+mB8Z1k9fLMX4GoUE/1QaIhNU5/poiCbczuoupfNVN3LZjrVpn7tKL3g5SeOknRdr3oa2Nu5u1HL8n1InDgCgNksFovefLKTqlR07qJhWfb7kRFBeu8pTgoAAN5lzPDWatGwklNtypIHLRbp/fFdFBkR7FQ7T4urEq4pZbjBtCzfSZe21XXPDYlO9wUAgLuEBNs09ekuCnZyNp2y5MGEGpF6+aELnGpjhn496uqmPvWdalPWa8XP3tdWjb1weTDAWRQT/VS7ZrH68NmucufDcbGVwvTNf3urgpefOJ7y3lOd1eH8WLf2MWJQU04cAcALVK8aobmTLlVEmPvWEQ4JturLCZeqbs0ot/UBAEBZhIbYNPeNS1WrmnunHn3zyU7qdoH3zlJzumt71dP4u9075VqTehX1xWuXcJMRAMDrtGpSRTNe6CZ3LoNZpWKoFkzpragKvrFm8NtjLtbFrau5tY87BjQ2ZUkywB0oJvqxG66orw+f7eqW9TJqVA3X4ncvV6O6FV2+bXeJjAjWgsm91clNSWLEoKZ647GLmN4UALzERS2raeGUyxTlhptewkNt+vo/l3r11C0AgMCWEB+lJe/1UUKNSJdv22KRJj/e0eem+X5iWCs9NcI9BcXmDSpp8btXqGolz67BBABAaV3Xq56mP9fN6dnsSiOucph+ePdyNT0vxuXbdpeI8CDN/28vdWlb3S3bH3ZtY015oiPXiuE3KCb6uZuvbKBFb12mOtUruGybPdrX0K/Tr1Lzhs7PtW22mOhQLXrzMt19fVOXbTMizKY3HrtIk0ZfxB2oAOBlOretrl+nX6U2Tau4bJvN6sfop2lXqnenWi7bJgAA7tCgTrR+nX6VrujsupxVo2q45r5xqe4a5LpzKk+xWCwaM7y1ZjzfTZWiXffUxI1X1NeyqX1UI9a9T4ICAFBeN1xRX9+/c7nqxrvuZqOu7arrt+lXq2Vj1513e0p0ZIgWTumt+2503Uxz4aE2TXj4Qr35ZCfZbJRf4D8YzQGgx4Xx2jCnv+68rnx3jVYID9Lkxzvqu7cvV0K8707pFhEepEmjO2rxu5erXs3yJc6u7apr3Rf9dc8NidxlAgBeqlmDSvpt+tV6+p42Tq8RcTqb1aLRt7fUqpn91DaxqgsjBADAfWrERmjepF6a+nQXVYws39P6g69qoI1fDlCfLnVcFJ05buxTXxvnDNDV3cr376hWJUxzJlyiGS90U6Vo59ZqBgDALF3b1dD62f3L/bDFqQcsFr97herV8t1rxeFhQZr46EX68f0rVL92+f4dF7eupj9nXaP7b27OtWL4nSCzA4BnRFUI0ZtPdtL9NzXTm58la+pX23Q8K79UbevXjtJdA5sqqW9DVYnxnylburePV/JX12r297s0eWayfl5zsFTtgmwWXXNJXY0Y1FRd21UnMQCADwgOtuqJYa11a99Genf2Fr09a4v2H84uVdu4ymG6vX9jDbu2sU/fTAMACFwWi0VD+jZUvx4J+nDuNk2emazNO9NL1TYyIki3XNlAdw1sqhaNfG92mjOpERuhLyf21MoNRzR5ZrI+XZii3Dx7qdq2blJFIwY11Q2Xn6cKbphOHQAAd4uMCNak0R11343N9Obnyfrgy21Ky8grVdt6NSN118CmurVfI7+a3rtLuxra9OUAzflhtybPTNayVX+Xqp3NalG/HgkaMaipurevwbVi+C2LYRiG2UHA87Ky87Vk5QGt2nREqzalauvudJ3ILZDNalVUhWC1aFhJbROrqn3zWF3UMi4gpu9M3pGmX9Yc1KpNR7Q6OVV/bDwsQyenBqoVV0FtE6uqTdMq6nZBDa+fvmZTmjR4mdlROO/DLlJijNlRAAgE+fl2LVv198k8mHxEG7cfU9aJAhmSIsKClHhejNomVlXbxCrq2q6GQkNsZod8RvZtKSocOdrsMMrE9upzsjasb3YYpRbT6SNJUtovt5gciXMYIyVxrIRAZxiGfl9/WCvWH9aqTUf059ajOp6Zr0K7XWEhQWpQJ+qfPFhV3S+ooehI100J6q1S03K0dOUBrdqUqlXJR7RzX4a27zkui6RWTaqodZMqaptYVR3Oj1WrJlW8+kKhr+7jJPZzAGCW7BMFWrJy/8k8uOmItu5O15ZdJ288at6gklo0rKy2iVV0QbNYdWpdLSCuFW/eWfxa8ZG0HOXl2xUWalPNuApq27SK2jStqm4XVFd8nOuWGHMHXz024LjAu/BkYoCqEBGsK7vW0ZVdfXt6Gldqel6Mmp4Xo9sHNJb0vwuGW+deZ2ZYAAA3CA626pIO8bqkQ7zZoQAA4HEWi0UXnh+nC8+PMzsUr1ElJkwDLq2nAZfWK3rt1Dnhqpn9TIoKAADPiAgPUp8udYpNZX4qD677or9ZYZmqSb0YNakXo9v6NzY7FMArsGYiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgJ+KCZECvGx/90h1pNxAwCcY4mOkoKDzQ7DecHBJ2OH2zFGSuJYCYA/88V9nMR+DgAAd/HFYwOOC7xPkNkBAHC9+AhpVg8pLc/sSEovJuRk3AAA51iqxSlo8msyjmeYHYpTLNFRslSLMzuMgMAYKYljJQD+zBf3cRL7OQAA3MUXjw04LvA+FBMBPxUfwQ4XAAKFpVochTmcFWOkJI6VAPgz9nEAAOB0HBugvHzs4VYAAAAAAAAAAAAAnkIxEQAAAAAAAAAAAIBDFBMBAAAAAAAAAAAAOEQxEQAAAAAAAAAAAIBDFBMBAAAAAAAAAAAAOEQxEQAAAAAAAAAAAIBDFBMBAAAAAAAAAAAAOEQxEQAAAAAAAAAAAIBDFBMBAAAAAAAAAAAAOEQxEQAAAAAAAAAAAIBDFBMBAAAAAAAAAAAAOEQxEQAAAAAAAAAAAIBDFBMBAAAAAAAAAAAAOEQxEQAAAAAAAAAAAIBDFBMBAAAAAAAAAAAAOEQxEQAAAAAAAAAAAIBDFBMBAAAAAAAAAAAAOEQxEQAAAAAAAAAAAIBDFBMBAAAAAAAAAAAAOEQxEQAAAAAAAAAAAIBDQWYHgLIxDh6ScTzD7DBKzRIdJUu1OLPDCCiMkeL2Z0tpeW7bvFvEhEjxEe7bPmMEAAIHebAk8iB8GeMX5+JrY0Ry7zghD5bEGIEvY/ziXBgjJflaLiQPlmT2foRiog8yDh5SwYiHpPx8s0MpveBgBU1+jaTpIYyR4vZnS9culvLsLt+0W4VYpVk93JM4GSMAEDjIgyWRB+HLGL84F58cI5Lbxgl5sCTGCHwZ4xfnwhgpyRdzIXnQAZP3I0xz6oOM4xm+N9Dz832u0u/LGCPFpeX5VrI8Jc/uvjuGGCMAEDjIgyWRB+HLGL84F58cI5Lbxgl5sCTGCHwZ4xfnwhgpyRdzIXnQAZP3IxQTAQAAAAAAAAAAADhEMREAAAAAAAAAAACAQxQTAQAAAAAAAAAAADgUZHYAAAAAgDfKzSvU+m1HtWpTqjZsP6bsEwWSpBHP/KIm9WLUNrGqWjWurAoRwSZHCgAAAAAA4D4UEwEAAIB/GIahX/88pMkzkzXru53KdbBK/ZTPNhf93Wq1qE/n2hoxqKl6dawpq9XiyXABAAAAAADcjmIiAAAAIGnFukMa8exyrU5OLXUbu93Q3B/3aO6Pe1S/dpQmPtJBfbrUcWOUAAAAAAAAnsWaiQAAAAhoObkFeuT139Vx8DynCon/lrI3Q1fe852SnlimY8dzXRghAAAAAACAeSgmAgAAIGAdOZajLrfO10sfrJfdbrhkm9O+3qa2g75Uyt7jLtkeAAAAAACAmSgmAgAAICAdTc9V99u+0coNR1y+7Z37MtV5yDzt+IuCIgAAAAAA8G0UEwEAABBwCgrsuureRdqw/Zjb+jhw5IQuHbZQ6Rl5busDAAAAAADA3SgmAgAAIOC89ME6LV97yKk2uxYO0q6Fg5xqs+OvDI18ZYVTbQAAAAAAALwJxUQAAAAElA3bjmrclDVOt6sYGayKkcFOt3tvzlYt/Pkvp9sBAAAAAAB4A4qJwL8YhqGfV/+t3LxC5eQWatInm7Rtd7rZYQEAABd5ZMJK5RfYPdrngy//JsMwPNonAKBs9v6dqSkzk5WTW6jcvEJ99+s+2e3swwEAgeHY8Vx98OXWk3kwt1Czv9+lvPxCs8MCYLIgswMAvIVhGHpv9la99tEGJe9IK3r9vud/lSGpZ4d4PXZbS/W4MN60GAEAQPns+Ou4FpjwlODmnelauvKAurfnOAIAvNXv6w/r2XfWau6Pe3T6/R+97lyouvGRuu+mZrr3hkQFBXFfNgDA/6TsPa5n31mrj+enKDf/fzdfDnjoB1WuGKq7BjbRw7eer+jIEBOjBGAWjoBPk5WVpfvvv19xcXGKiopSUlKSpk6dquDgYOXk5JgdHtyosNCuIY8v0x1P/azNO9OKvXfqHHLJ7wfUc9gCTZmZ7PH4AMATyIMIBG99vllmPSA4mWMIwKuRBwPb54t2qtOQuZr/016HeWL3gUyNfHmFrr7vO+XkFng+QABwM/JgYFux7pDaDvpSH87dXqyQeMrR9Fw9/946dRo8TwdTT5gQIQCzUUz8R0FBga644gp98803ev311zVr1izt3LlTo0ePVuPGjRUWFmZ2iG7Rc/kSvb1re7HXtmdlKGTuZyZFZI7/e/V3TZ938ns40wXGQrshw5BGPLtcny/a6cHozMc4KS516QytGRRZ4s+qflbteuM2s8MzBWPE9wVqHkTgmf3DbtP6/nrpHr+YHog8WBJ50PcFch5k/EpLVx7QDQ8vUWGhocJCxyeEhnHyRtNvf/lLQx5f5tkATcYYKY48WBJjxPeRBwN7/KbsPa7ewxcqM7vgjHlQkux2Q8k703T5XQsD6sYaxkhx5MGSAmWMMM3pPyZOnKi1a9dqy5Ytql69uiSpSZMmqlu3rnr06GFydHCnXfsyNHHGRpX2IQWLRRr5ygr1vyRBNhv1+EBUpdtNqtLtpmKvpa34Wjtfv1nV+o40KSqgfMiDCARpx3O1fc9x0/rPy7dr4/Zjat20qmkxuAJ5EP6IPBjYRr36uwyd+cbS09kN6bNFO/V/Gw7rguaxbo8N3oc8CH9EHgxsz76zVlknClRYivWBCwsNrdl8VJ8u3KGkvo08EB28DXkwcFEJ0cm18l577TXdcccdRQlTkhISEhQUFKSWLVsqNTVVl19+uRo3bqwWLVpo6NChys3NNTFquMpbszbLarGU+vOGIe39O0vfLt/nxqjgS3L2b9OuiYOVcPc7Cq+TaHY4gNPIgwgUq5NTzQ5BqzaZH4OrkQfh68iDgW3VpiP6Y9MR2UtxAfWUIJtFkz9l6mqcRB6EryMPBrZjx3M1Y36KCs7yROK/Wa3SGx9vcmNU8CXkwcBBMVFScnKy9u/fr379+hV7/cCBAyooKFCrVq1ksVj02GOPacuWLfrzzz914sQJTZo0yZyA4VLTvtpWqjtvTmezWoqmRUVgK8zJUsoL/VXlkqGq3HmQ2eEAZUIeRKDYujvd7BC0ZZf5MbgSeRD+gDwY2D7+JkVBttLfXCpJBYWGZnyTosLCkmtKIbCQB+EPyIOBbc4Pu5XnYI3Es7HbT96oudXPzm3gPPJgYGGaU0n79p18wiwuLq7Y6999950kqVWrVqpcubK6dOkiSbJarWrXrp327NlT5j4TEhKUnl62HW7LyGh93+aiMvf9b6M2/qnHk9cX/Wwv9YSfzunevbv+zDRvarEzSa/9kmSxOdWm0G7oszmL9M1b17gpqvJx9RiRPDNO3DVGQuu1Uu2nlrp8u5K0+793KCiysmolveSW7Xfv3k25O9e6fLuBOEYqVqyo3bvNWyvNm/laHgTKKjeqi1Spr8P3di0cpIqRwWdtXzEqRJJ07Oebz/q59Mx81b1spsP3/jPpTb3zdK9SROs65MGSyIM4na/lwUAcv+6UXeUmFUS0dPqcML/ArkqxtWS1Z7spsrLz1TEiuWeckAdLCtQxQi50jDzoG+PXXXKiL5Eq9nY6D0pSmwu7Kyh3hxuiKh/GSEnuyoXkwf/xhTFS3jxIMVFSlSpVJEkpKSlq1OjkXM9ZWVl65plnVKNGDcXGFl8HIScnR1OnTtXLL7/s8Vjd4eVmLTWsboOin7dnZShx8QITI/K0Mv7HNgLrLlTGSUkH505U5vqlavr6alls7E4ZI74r0PMgAol7Duad4w0xuAZ5sDjyoO8iDwb6+C37eZ0lgM4JA3uMOEYeLI4x4rvIg4E9fk/mMuee0C9CHjQxIvORB4sLhDHCb1lS8+bNlZCQoJEjR6qgoEAFBQV68cUXlZGRodatWxf7rN1u15AhQ9S9e3dddtllZe6zPBVg+7YUFY4cXeb2ZlmyZImsDeubHUYJTa6epa2702U4cW0vyGbRbYOv1ptPvui+wMqBMVLcpjRp8DLXbjNz08/a/9FoNXxqkYIrVT93gzJasmSpEmNcv13GCE7na3kQKKv3Zm/R7eN+dvjemZ4kPN2pJxIrXTy9zDGMfOBuPXf/B2VuXxbkwZLIgzidr+VBxq9rPTVltca/tdapNRMlqVJ0iI6kHpDVWsYLsG7kq2NEcs84IQ+WxBjB6ciDnuON43fWop267v8WO93OYpG2bvhF8XEV3BBV+TBGSnJ1LiQPmsfM/QhrJkoKCQnRrFmzFB4erkGDBmn8+PF64oknFBMTo1atWhX77N133y2r1aoJEyaYEitcb/h1TZxuU1Bo6I4Bjd0QDXxB/tEDSnnpOtUc/IIim3YyOxyg3MiDCBQtGlY2OwS1aFjJ7BDKjTwIf0MeDGxJfRvKcObOUkk2q0XDrm3ilYVEuB95EP6GPBjYrupWR5WiQ5xqY7NZdPnFtbyykAj3Iw8GLp5M/Ee7du20atWqop+zs7O1detWtWzZsui1hx9+WHv37tWcOXNktVKH9RdD+jbUoxNXKjevdI/m26wWtWxcWW0Tq7o5Mnirw4veUcGxv7Xvo8e076PHir0XmdhZDcf61yPsCAzkQQSC8xtVUpDNooJC86Ya9YfjB/Ig/BF5MHAlxEepT5faWvDzXyosZX6wG4buvNb5m1LhH8iD8EfkwcAVGmLT8Oua6sUP1pX6Kf3CQkN3X5/o5sjgrciDgYti4hmsW7dOdru96A6cjRs36uWXX1aTJk10wQUXSJIuvfRSn58f/PuO3Uu81qBClPKuGmhCNOaoFB2qKU900tAxP53zs1arRSEhVr077mIPROY9GCfFxV8/RvHXjzE7DK/CGPE/gZIHEVjCQoPUomFlrdmcakr/MVEhalAn2pS+XYk8WBJ50P8EUh5k/EoTH+mg5Wu/VnpGngpLcSH1ufvaqV6tKA9E5h0YI8WRB0tijPgf8mBgjd9Hhp6vr5bs1pbd6ee8scZikW7qU1+XX1zLQ9GZjzFSHHmwpEAZIxQTz2Dt2rWKiIhQw4YNJUnNmjVzeuoT+I5b+zVSbl6h7n52uaxWx08sWK0WRUUEad6kXmrd1PefKgCAsyEPwl/dclUD04qJN1/ZgCnxAB9BHgws59WK1o/vX6FL71yog6kn5OhXferJ9qdGtNEjQ8/3fJAA4EHkwcBSMSpEP7x7uS4b/q3+3HpUVov073trbDaLCgsN3dSnvt57qrMsFs5rgEDDM+lnMHz4cGVlZfHYfgAZPrCp1n5+jW7v31hhobZi78VVDtPY4a2V/NW1uriN+xaVBQBvQR6Ev0rq21Dh/8rznnLXQKbEA3wFeTDwNG9YWRvnDNBLD7ZXnRrF14AKDrLqxivq67fpV2nM8NZcQAXg98iDgad61Qj9Ov0qvfdU5xJrzVssUu+ONTX/v7304bNdFRJszvkUAHPxZCJwmhaNKmvKk5304oMXaPPOdGVm5ysmKkQtGlZWcDAHUAAA+LpK0aG6+coGeueLLR7t95IL45VYv5JH+wQAOKdyxVD9X1ILPTS4udZvO6qj6bkKDw1Sw4RoVYkJMzs8AADcKjwsSEOvaaRb+zXU1l3p+jv1hIJsVtWNj1TNahXOvQEAfo1iIuBAdGSI2reINTsMAADgBs/e21ZfLt6tw8dyPNJfaLBVbzx2kUf6AgCUn9VqUcvGVcwOAwAAU1gsFjWuF6PG9WLMDgWAF+FRKwAAAASU2Mrhmvx4R6fbpWfmKz0z3+l24+9uq6bnxTjdDgAAAAAAwBtQTAQAAEDAubZXPd3ev5FTbepeNlN1L5vpVJtLL4rXyCHNnWoDAAAAAADgTSgmAgAAICBNeaKTBvau57btd2pdTbNf7ymbjUNuAAAAAADgu7iyAQAAgIAUFGTVjOe76c7rmrh823261Na3U3orMiLY5dsGAAAAAADwJIqJAAAACFhBQVa9+WQnzZlwiapVCSv39iIjgvTmk500941LVYFCIgAAAAAA8AMUEwEAABDw+vWoq41zBuju65sqMiLI6fYhwVbd1Ke+NszurzuvayKLxeKGKAEAAAAAADzP+SslAAAAgB+qEhOmSaM76rn72mn6vO2a8U2KVienKie30OHng4Osat6gkgb2rqeh/Roprkq4hyMGAAAAAABwP4qJAAAAwGmiI0M04vpEjbg+UQUFdiXvSNOG7ceUmZ0vuyFFhNnU9LwYtWhYWaEhNrPDBQAAAAAAcCuKiQAAAMAZBAVZ1aJRZbVoVNnsUAAAAAAAAEzBmokAAAAAAAAAAAAAHKKYCAAAAAAAAAAAAMAhiokAAAAAAAAAAAAAHKKYCAAAAAAAAAAAAMAhiok+yBIdJQUHmx2Gc4KDT8YNj2CMFBcTIoX44N4uxHoydndgjABA4CAPlkQehC9j/OJcfHKMSG4bJ+TBkhgj8GWMX5wLY6QkX8yF5EEHTN6PWAzDMEzrHWVmHDwk43iG2WGUmiU6SpZqcWaHEVAYI8Xtz5bS8ty2ebeICZHiI9y3fcYIAAQO8mBJ5EH4MsYvzsXXxojk3nFCHiyJMQJfxvjFuTBGSvK1XEgeLMns/QjFRAAAAAAAAAAAAAAO+djDrQAAAAAAAAAAAAA8hWIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIcoJgIAAAAAAAAAAABwiGIiAAAAAAAAAAAAAIf+H8OUAZTnzaTyAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -564,7 +573,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -574,7 +583,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -584,7 +593,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -604,6 +613,25 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef5f0dc2-ad3a-467a-89dd-36d296d458ac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "genQC Version 0.1.0\n" + ] + } + ], + "source": [ + "import genQC\n", + "print(\"genQC Version\", genQC.__version__)" + ] } ], "metadata": { diff --git a/src/examples/3_dataset_and_fineTune.ipynb b/src/examples/3_dataset_and_fineTune.ipynb index 77849da..459c84d 100644 --- a/src/examples/3_dataset_and_fineTune.ipynb +++ b/src/examples/3_dataset_and_fineTune.ipynb @@ -24,12 +24,11 @@ "outputs": [], "source": [ "from genQC.imports import *\n", - "\n", "import genQC.util as util\n", "import genQC.platform.qcircuit_dataset_construction as data_const\n", "import genQC.inference.infer_srv as infer_srv\n", "import genQC.dataset.dataset_helper as dahe\n", - "\n", + "from genQC.platform.simulation.qcircuit_sim import instruction_name_to_qiskit_gate\n", "from genQC.pipeline.diffusion_pipeline import DiffusionPipeline\n", "from genQC.dataset.qc_dataset import Qc_Config_Dataset\n", "from genQC.dataset.mixed_cached_qc_dataset import Mixed_Cached_OpenClip_Dataset" @@ -69,9 +68,13 @@ "metadata": {}, "outputs": [], "source": [ - "def get_preTrained_pipeline():\n", - " model_path = \"../../saves/qc_unet_config_SRV_3to8_qubit/\"\n", - " pipeline = DiffusionPipeline.from_config_file(model_path, device) \n", + "def get_pretrained_pipeline():\n", + " pipeline = DiffusionPipeline.from_pretrained(\"Floki00/qc_srv_3to8qubit\", device)\n", + " \n", + " # -- use this for local files\n", + " # model_path = \"../../saves/qc_unet_config_SRV_3to8_qubit/\"\n", + " # pipeline = DiffusionPipeline.from_config_file(model_path, device) \n", + " \n", " return pipeline" ] }, @@ -80,7 +83,7 @@ "id": "742ae430-46f2-4099-ac8f-f422a4ddc1dc", "metadata": {}, "source": [ - "Load the pre-trained model. Set 20 sample steps and use rescaled guidance-formula." + "Load the pre-trained model directly from [Hugging Face: Floki00/qc_srv_3to8qubit](https://huggingface.co/Floki00/qc_srv_3to8qubit) or from local files. Set 20 sample steps and use rescaled guidance-formula." ] }, { @@ -89,6 +92,20 @@ "id": "655756d0-1619-4e8e-acc1-3f76a507a73b", "metadata": {}, "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ae624c9e361843a3825700d689af6234", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 2 files: 0%| | 0/2 [00:00, ]\n" + "Trained with gates: ['h', 'cx']\n" ] } ], "source": [ - "pipeline = get_preTrained_pipeline()\n", + "pipeline = get_pretrained_pipeline()\n", "\n", "pipeline.guidance_sample_mode = \"rescaled\"\n", "pipeline.scheduler.set_timesteps(20) \n", @@ -160,7 +177,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f2b2e6a4f21343758fb4f28e5345db3c", + "model_id": "8e5d53aa4d1b404e8daa907868ee287d", "version_major": 2, "version_minor": 0 }, @@ -176,12 +193,12 @@ "output_type": "stream", "text": [ "[INFO]: (generate_srv_tensors) Generated 512 tensors\n", - "Not valid error circuits: 16 out of 512\n" + "Not valid error circuits: 6 out of 512\n" ] } ], "source": [ - "g = 7.5 # guidance scale\n", + "g = 10 # guidance scale\n", "max_gates = 16 # how many time steps the tensor encoding has\n", "samples = 512 # how many circuits to generate\n", "\n", @@ -200,7 +217,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy on requested 9 qubit SRV=[2, 2, 2, 1, 1, 1, 1, 1, 2], with a model trained on 3 to 8 qubits circuits: 0.03\n" + "Accuracy on requested 9 qubit SRV=[2, 2, 2, 1, 1, 1, 1, 1, 2], with a model trained on 3 to 8 qubits circuits: 0.02\n" ] } ], @@ -250,7 +267,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "edf10f623fa04090b56cd611c5d5963c", + "model_id": "c406df27ac754e53b1058490b22770c3", "version_major": 2, "version_minor": 0 }, @@ -275,7 +292,7 @@ "num_of_qubits = 9\n", "min_gates = 2\n", "max_gates = 20\n", - "gate_pool = pipeline.gate_pool \n", + "gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in pipeline.gate_pool] \n", "optimized = True # if qiskit optimizer is used\n", "\n", "x, y = data_const.gen_qc_dataset(samples=random_samples, num_of_qubits=num_of_qubits, min_gates=min_gates, max_gates=max_gates, \n", @@ -289,18 +306,15 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "tensor([1, 2, 1, 1, 2, 2, 2, 2, 1], dtype=torch.int32)" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=torch.int32)\n" + ] } ], "source": [ - "y[0]" + "print(y[0])" ] }, { @@ -310,19 +324,16 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'Generate SRV: [1 2 1 1 2 2 2 2 1]'" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Generate SRV: [1, 1, 1, 1, 1, 1, 1, 1, 1]\n" + ] } ], "source": [ - "y = np.array([f\"Generate SRV: {srv.numpy()}\" for srv in y]) # convert SRV to the trained prompt\n", - "y[0]" + "y = np.array([f\"Generate SRV: {srv.tolist()}\" for srv in y]) # convert SRV to the trained prompt\n", + "print(y[0])" ] }, { @@ -344,16 +355,16 @@ "output_type": "stream", "text": [ "Example circuit with prompt: \n", - "Generate SRV: [1 1 1 1 1 1 2 1 2] \n", + "Generate SRV: [1, 1, 1, 1, 1, 1, 1, 1, 1] \n", "tensor([[ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 2, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 1, -2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=torch.int32)\n" + " [ 0, 0, 2, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0],\n", + " [-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 0],\n", + " [ 0, -2, -2, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 0, -2, -2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, -2, -2, 0, 0, 0, 0, 0]], dtype=torch.int32)\n" ] } ], @@ -393,7 +404,7 @@ "paras[\"num_of_qubits\"] = num_of_qubits\n", "paras[\"min_gates\"] = min_gates\n", "paras[\"max_gates\"] = max_gates\n", - "paras[\"gate_pool\"] = [dahe.class_to_str(gate) for gate in gate_pool]" + "paras[\"gate_pool\"] = pipeline.gate_pool" ] }, { @@ -435,14 +446,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Label: ``Generate SRV: [1 2 2 1 1 1 1 1 2]`` SRV is: [1, 2, 2, 1, 1, 1, 1, 1, 2]\n" + "Label: ``Generate SRV: [1, 2, 1, 1, 1, 1, 1, 2, 1]`` SRV is: [1, 2, 1, 1, 1, 1, 1, 2, 1]\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -539,7 +550,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cf6b9849288d422b8e2102eefa9c80ba", + "model_id": "35ad3ab92260493d9c23fe58ac7c5f2a", "version_major": 2, "version_minor": 0 }, @@ -589,7 +600,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -631,6 +642,20 @@ "id": "ec9b63c0-a92d-416f-994b-ea1ef6fae0c7", "metadata": {}, "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "edc00be4377647e6a2e602cfd7b28022", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 2 files: 0%| | 0/2 [00:00" ] @@ -1506,7 +1531,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c9ade90fdaa045e889a91d9a78be190d", + "model_id": "124bcb31245849ad9b210d5bf0a295dd", "version_major": 2, "version_minor": 0 }, @@ -1522,12 +1547,12 @@ "output_type": "stream", "text": [ "[INFO]: (generate_srv_tensors) Generated 512 tensors\n", - "Not valid error circuits: 4 out of 512\n" + "Not valid error circuits: 8 out of 512\n" ] } ], "source": [ - "g = 7.5 # guidance scale\n", + "g = 10 # guidance scale\n", "max_gates = 16 # how many time steps the tensor encoding has\n", "samples = 512 # how many circuits to generate\n", "\n", @@ -1549,15 +1574,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy on requested 9 qubit SRV=[2, 2, 2, 1, 1, 1, 1, 1, 2]: \n", - " - with a model trained only on 3 to 8 qubits qcs: 0.03 \n", - " - and with fine-tuning on 9 qubit qcs: 0.26\n" + "Accuracy on requested 9 qubit SRV = [2, 2, 2, 1, 1, 1, 1, 1, 2]\n", + " - with a model trained only on 3 to 8 qubits qcs: 0.02\n", + " - and with fine-tuning on 9 qubit qcs: 0.57\n" ] } ], "source": [ "tuned_acc = infer_srv.get_srv_accuracy(srv_list, srv)\n", - "print(f\"Accuracy on requested {len(srv)} qubit SRV={srv}: \\n - with a model trained only on 3 to 8 qubits qcs: {acc:.2f} \\n - and with fine-tuning on 9 qubit qcs: {tuned_acc:.2f}\") " + "print(f\"Accuracy on requested {len(srv)} qubit SRV = {srv}\")\n", + "print(f\" - with a model trained only on 3 to 8 qubits qcs: {acc:.2f}\")\n", + "print(f\" - and with fine-tuning on 9 qubit qcs: {tuned_acc:.2f}\")" ] }, { @@ -1567,6 +1594,25 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a13b3bcc-b957-4d25-9090-df469c5f6d42", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "genQC Version 0.1.0\n" + ] + } + ], + "source": [ + "import genQC\n", + "print(\"genQC Version\", genQC.__version__)" + ] } ], "metadata": { diff --git a/src/index.ipynb b/src/index.ipynb index 752b085..fe55add 100644 --- a/src/index.ipynb +++ b/src/index.ipynb @@ -17,8 +17,8 @@ " \"awesome\"\n", " \"generative-models\"\n", " \"diffusion-models\"\n", - " \"python-3.9\"\n", - " \"DOI\"\n", + " \"python-3.10\"\n", + " \"DOI\"\n", "

" ] }, @@ -26,7 +26,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Code repository for generating quantum circuits with diffusion models. [[Paper]](https://arxiv.org/abs/2311.02041) [[Demo]](https://huggingface.co/spaces/Floki00/genQC)" + "Code repository for generating quantum circuits with diffusion models. [[Arxiv]](https://arxiv.org/abs/2311.02041) [[Demo]](https://huggingface.co/spaces/Floki00/genQC)" ] }, { @@ -47,7 +47,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "All weights and functions are contained within this repo. For the CLIP model weights we use the [OpenCLIP](https://github.com/mlfoundations/open_clip) library, which will download (and cache) the CLIP model on first usage of our pipeline. In case you prefer reading a documentation rather than notebooks or code see [[Documentation]](https://florianfuerrutter.github.io/genQC/)." + "The code contained within this repo allows the sampling of pre-trained diffusion models and includes our pipeline to fine-tune and train models from scratch. Pre-trained weights can be found on [Hugging Face](https://huggingface.co/collections/Floki00/generative-quantum-circuits-6550e926c67f60a368b02bc3) and can be downloaded automatically via our code (see minimal example). For the CLIP model weights we use the [OpenCLIP](https://github.com/mlfoundations/open_clip) library, which will download (and cache) the CLIP model on first usage of our pipeline. In case you prefer reading a documentation rather than notebooks or code see [[Documentation]](https://florianfuerrutter.github.io/genQC/)." ] }, { @@ -56,10 +56,9 @@ "source": [ "The repo inlcudes:\n", "\n", - "1. `saves/` the configs and weights of the pre-trained models.\n", - "2. `genQC/` a full release of our used diffusion pipeline.\n", - "3. `src/examples` examples how to reproduce some figures of the [Paper](https://arxiv.org/abs/2311.02041).\n", - "4. `src/` the source notebooks for [nbdev](https://github.com/fastai/nbdev)." + "1. `genQC/` a full release of our used diffusion pipeline.\n", + "2. `src/examples` examples how to reproduce some figures of the [Paper](https://arxiv.org/abs/2311.02041).\n", + "3. `src/` the source notebooks for [nbdev](https://github.com/fastai/nbdev)." ] }, { @@ -80,7 +79,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A minimal example to generate a 5 qubit circuit conditioned on a SRV of $[1,1,1,2,2]$. You can try it out on your own with our demo [[huggingface-space]](https://huggingface.co/spaces/Floki00/genQC), no coding required." + "A minimal example to generate a 5 qubit circuit conditioned on a SRV of $[1,1,1,2,2]$. You can try it out on your own with our [[Demo]](https://huggingface.co/spaces/Floki00/genQC), no coding required." ] }, { @@ -88,6 +87,20 @@ "execution_count": null, "metadata": {}, "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "18bd4685d5ee43d1912f11ccd3dde9af", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 2 files: 0%| | 0/2 [00:00" + "
" ] }, "execution_count": null, @@ -135,8 +147,8 @@ } ], "source": [ - "print(f\"is SRV {srv_list[0]}\")\n", - "qc_list[0].draw(\"mpl\", style=\"clifford\")" + "print(f\"Circuit is SRV {srv_list[0]}\")\n", + "qc_list[0].draw(\"mpl\")" ] }, { @@ -174,14 +186,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The installation of genQC is done via `pip` within a few minutes, depending on your downloading speed." + "The installation of `genQC` is done via `pip` within a few minutes, depending on your downloading speed." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### 1. Clone the repository" + "#### Method 1: pip install" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To install `genQC` just run:" ] }, { @@ -189,8 +208,7 @@ "metadata": {}, "source": [ "```sh\n", - "git clone https://github.com/FlorianFuerrutter/genQC.git\n", - "cd genQC\n", + "pip install genQC\n", "```" ] }, @@ -198,14 +216,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### 2. Install genQC" + "Note, this will install missing requirements automatically. You may want to install some of them manually beforehand, e.g. `torch` for specific cuda support, see [pytorch.org/get-started/locally](https://pytorch.org/get-started/locally/)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "This library is build using jupyter notebooks and [nbdev](https://github.com/fastai/nbdev). To install the library use in the clone directory:" + "**Requirements:** `genQC` depends on `python` (min. version 3.10) and the libraries: `torch`, `numpy`, `matplotlib`, `scipy`, `pandas`, `omegaconf`, `qiskit`, `tqdm`, `joblib`, `open_clip_torch`, `ipywidgets`, `pylatexenc` and `huggingface_hub`. All can be installed with `pip`. In `src/RELEASES.md` [[doc]](https://florianfuerrutter.github.io/genQC/RELEASES.html) and the release descriptions specific tested-on versions are listed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Method 2: clone the repository" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To use the latest GitHub code you can clone the repository by running: " ] }, { @@ -213,7 +245,8 @@ "metadata": {}, "source": [ "```sh\n", - "pip install -e .\n", + "git clone https://github.com/FlorianFuerrutter/genQC.git\n", + "cd genQC\n", "```" ] }, @@ -221,21 +254,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Note, this will install missing requirements automatically. You may want to install some of them manually beforehand, e.g. pytorch for specific cuda support, see [pytorch.org/get-started/locally](https://pytorch.org/get-started/locally/)." + "The library `genQC` is built using jupyter notebooks and [`nbdev`](https://github.com/fastai/nbdev). To install the library use in the clone directory:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**Requirements:** `genQC` depends on `python` (min. version 3.9) and the libraries: `torch`, `numpy`, `matplotlib`, `scipy`, `pandas`, `omegaconf`, `qiskit`, `tqdm`, `joblib`, `open_clip_torch`, `ipywidgets` and `pylatexenc`. All can be installed with `pip`. In `src/RELEASES.md` [[doc]](https://florianfuerrutter.github.io/genQC/src/RELEASES.html) and the release descriptions specific tested-on versions are listed." + "```sh\n", + "pip install -e .\n", + "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### 3. Run example" + "#### Test installation" ] }, { @@ -256,7 +291,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The code and weights in this repository are released under the MIT License." + "The code and weights in this repository are licensed under the [Apache License 2.0](https://github.com/FlorianFuerrutter/genQC/blob/main/LICENSE.txt)." ] }, { diff --git a/src/inference/export_cudaq.ipynb b/src/inference/export_cudaq.ipynb new file mode 100644 index 0000000..9446ddc --- /dev/null +++ b/src/inference/export_cudaq.ipynb @@ -0,0 +1,364 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a8980c24-d62e-462b-ba89-3195cfdcc374", + "metadata": {}, + "source": [ + "# Export to CUDA-Q" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8832bdd-f61c-44e1-8619-a9cb352ba768", + "metadata": {}, + "outputs": [], + "source": [ + "#| default_exp inference.export_cudaq" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06272f6f-b4e3-4504-a90a-feebbf6ad821", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "from genQC.imports import *\n", + "from typing import Sequence, List, Optional\n", + "import cudaq" + ] + }, + { + "cell_type": "markdown", + "id": "d968941a-c24b-4e2e-bcce-edf497476aa0", + "metadata": {}, + "source": [ + "## CircuitInstructions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5667d650-74c3-4116-95c5-642bb1e69cd0", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "@dataclass\n", + "class CircuitInstruction():\n", + " name: str\n", + " control_nodes: Sequence[int]\n", + " target_nodes: Sequence[int]\n", + " params: Sequence[float]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95130627-b530-4580-abec-35c77f14d094", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "class CircuitInstructions():\n", + " def __init__(self, tensor_shape: torch.Size) -> None:\n", + " assert len(tensor_shape) == 2 # ... [qubits, time]\n", + " self.tensor_shape = tensor_shape \n", + " self._instructions = []\n", + " self.instruction_names_set = set()\n", + " \n", + " def add_instruction(self, \n", + " name: str, \n", + " control_nodes: Sequence[int], \n", + " target_nodes: Sequence[int], \n", + " params: Sequence[float]) -> None:\n", + " self.instruction_names_set.add(name)\n", + " self._instructions.append(CircuitInstruction(name, control_nodes, target_nodes, params))\n", + "\n", + " @property\n", + " def data(self) -> List[CircuitInstruction]: return self._instructions\n", + "\n", + " @property\n", + " def length(self) -> int: return len(self._instructions)\n", + "\n", + " @property\n", + " def num_qubits(self) -> int: return self.tensor_shape[0]\n", + "\n", + " @property\n", + " def max_gates(self) -> int: return self.tensor_shape[1]\n", + " \n", + " def __repr__(self) -> str: return str(self._instructions)\n", + "\n", + " def print(self) -> None:\n", + " for instruction in self.data: \n", + " print(instruction) " + ] + }, + { + "cell_type": "markdown", + "id": "4adddad8-46fc-4241-ac39-b4ca430ae0dd", + "metadata": {}, + "source": [ + "## CircuitsCudaqBackend" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b3aed961-03b0-4158-8d3a-3188d92b39ac", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "class CircuitsCudaqBackend():\n", + "\n", + " BASIC_BACKEND_TYPE = type[cudaq.kernel]\n", + " \n", + " # Has to match with insides of belows kernel\n", + " KERNEL_VOCABULARY = {\"h\":1, \"cx\":2, \"z\":3, \"x\":4, \"y\":5, \"ccx\":6, \"swap\":7} \n", + " \n", + " def _construct_kernel(self,\n", + " gate_list: List[str],\n", + " target_1_nodes_list: List[int],\n", + " target_2_nodes_list: List[int],\n", + " control_1_nodes_list: List[int],\n", + " control_2_nodes_list: List[int]\n", + " ) -> cudaq.kernel:\n", + " \"\"\"Construct a `cudaq.kernel` from provided paramters.\"\"\"\n", + " \n", + " num_gates = len(gate_list)\n", + " gate_list = [self.KERNEL_VOCABULARY[g] for g in gate_list]\n", + "\n", + " # Note: `@cudaq.kernel` decorator has a overhead of 20ms, regardless of the for-loop inside\n", + " \n", + " @cudaq.kernel\n", + " def place_gate_kernel(gate: int, \n", + " qvector: cudaq.qview,\n", + " target_1: int, \n", + " target_2: int, \n", + " control_1: int, \n", + " control_2: int): \n", + " if gate == 1: h(qvector[target_1])\n", + " elif gate == 2: cx(qvector[control_1], qvector[target_1])\n", + " elif gate == 3: z(qvector[target_1])\n", + " elif gate == 4: x(qvector[target_1])\n", + " elif gate == 5: y(qvector[target_1])\n", + " elif gate == 6: x.ctrl(qvector[control_1], qvector[control_2], qvector[target_1])\n", + " elif gate == 7: swap(qvector[target_1], qvector[target_2])\n", + " \n", + " @cudaq.kernel \n", + " def kernel(input_state: List[complex]):\n", + " qvector = cudaq.qvector(input_state)\n", + " for i in range(num_gates):\n", + " place_gate_kernel(gate_list[i], qvector, target_1_nodes_list[i], target_2_nodes_list[i], control_1_nodes_list[i], control_2_nodes_list[i])\n", + " \n", + " return kernel\n", + "\n", + " def check_error_circuit(self, \n", + " gate: str, \n", + " num_target_nodes: int, \n", + " num_control_nodes: int) -> bool:\n", + " \"\"\"Check number of connections of given gate. Used to check for error circuits.\"\"\"\n", + "\n", + " if gate not in self.KERNEL_VOCABULARY:\n", + " raise NotImplementedError(f\"Unknown gate {gate}, not in `self.KERNEL_VOCABULARY`.\")\n", + " \n", + " if gate in [\"h\", \"z\", \"x\", \"y\"]:\n", + " if num_target_nodes != 1 or num_control_nodes !=0: return False\n", + "\n", + " elif gate in [\"cx\"]:\n", + " if num_target_nodes != 1 or num_control_nodes !=1: return False\n", + "\n", + " elif gate in [\"ccx\"]:\n", + " if num_target_nodes != 1 or num_control_nodes !=2: return False\n", + "\n", + " elif gate in [\"swap\"]:\n", + " if num_target_nodes != 2 or num_control_nodes !=0: return False\n", + "\n", + " else:\n", + " raise NotImplementedError(f\"Unknown gate {gate}, implemetation is faulty!\")\n", + "\n", + " return True\n", + "\n", + " \n", + " def export_cudaq(self, instructions: CircuitInstructions) -> cudaq.kernel:\n", + " \"\"\"Convert given genQC `CircuitInstructions` to a `cudaq.kernel`.\"\"\"\n", + "\n", + " # num_qubits = instructions.num_qubits\n", + " num_gates = instructions.length\n", + "\n", + " # @cudaq.kernel can only take list[int] and no str directly\n", + " # -> we have to map everything to list[int] \n", + " # set default value to 9999 so an error wil be raised if we have a faulty tensor encoding\n", + " \n", + " gate_list = []\n", + " target_1_nodes_list = [9999] * num_gates\n", + " target_2_nodes_list = [9999] * num_gates\n", + " control_1_nodes_list = [9999] * num_gates\n", + " control_2_nodes_list = [9999] * num_gates\n", + "\n", + " for i, instruction in enumerate(instructions.data):\n", + "\n", + " gate = instruction.name.lower()\n", + " control_nodes = instruction.control_nodes\n", + " target_nodes = instruction.target_nodes\n", + " \n", + " if len(instruction.params) > 0:\n", + " raise NotImplementedError(f\"Only support non parametrized gates currently.\")\n", + " \n", + " num_target_nodes = len(target_nodes)\n", + " num_control_nodes = len(control_nodes)\n", + " \n", + " if not self.check_error_circuit(gate, num_target_nodes, num_control_nodes):\n", + " return None\n", + " \n", + " gate_list.append(gate)\n", + " \n", + " if num_target_nodes > 0:\n", + " target_1_nodes_list[i] = target_nodes[0]\n", + " if num_target_nodes > 1: \n", + " target_2_nodes_list[i] = target_nodes[1] \n", + " \n", + " if num_control_nodes > 0:\n", + " control_1_nodes_list[i] = control_nodes[0] \n", + " if num_control_nodes > 1: \n", + " control_2_nodes_list[i] = control_nodes[1] \n", + " \n", + " #--------------------\n", + " kernel= self._construct_kernel(gate_list, target_1_nodes_list, target_2_nodes_list, control_1_nodes_list, control_2_nodes_list)\n", + " return kernel\n", + " \n", + " def get_unitary(self, kernel: cudaq.kernel, num_qubits: int) -> np.ndarray:\n", + " \"\"\"Return the unitary matrix of a `cudaq.kernel`. Currently relies on simulation, could change in future releases of cudaq.\"\"\"\n", + " \n", + " N = 2**num_qubits\n", + " U = np.zeros((N, N), dtype=np.complex128)\n", + " \n", + " for j in range(N): \n", + " state_j = np.zeros((N), dtype=np.complex128) \n", + " state_j[j] = 1\n", + " \n", + " U[:, j] = np.array(cudaq.get_state(kernel, state_j), copy=False)\n", + " \n", + " return U\n", + "\n", + " def draw(self, kernel: cudaq.kernel, num_qubits: int, **kwargs) -> None:\n", + " \"\"\"Draw the given `cudaq.kernel` using cudaq.\"\"\" \n", + " c = [0] * (2**num_qubits)\n", + " c[0] = 1\n", + " print(cudaq.draw(kernel, c))" + ] + }, + { + "cell_type": "markdown", + "id": "fecd2687-2986-4a2d-96fd-ea2d55aae235", + "metadata": {}, + "source": [ + "## Decode" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "101024b0-3c9c-40de-9e56-7f55de3b7673", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def tensor_to_instructions(tensor: torch.Tensor, \n", + " vocabulary_inverse: dict, \n", + " params_tensor: Optional[torch.Tensor] = None, \n", + " params_4pi_normalization: bool = True,\n", + " sign_labels: dict = {\"control_nodes\":-1, \"target_nodes\":+1}) -> CircuitInstructions:\n", + " \"\"\"Convert a given `torch.Tensor` to `CircuitInstructions`.\"\"\"\n", + " \n", + " assert tensor.dim() == 2, f\"{tensor.shape=}\"\n", + " num_of_qubits, time = tensor.shape\n", + " \n", + " instructions = CircuitInstructions(tensor_shape=tensor.shape)\n", + " \n", + " for t in range(time): \n", + " enc_time_slice = tensor[:, t] # contains all bits at time t \n", + " \n", + " for gate_index, gate in vocabulary_inverse.items(): \n", + " \n", + " target_nodes = (enc_time_slice == (sign_labels[\"target_nodes\"] * gate_index)).nonzero(as_tuple=True)[0]\n", + " control_nodes = (enc_time_slice == (sign_labels[\"control_nodes\"] * gate_index)).nonzero(as_tuple=True)[0]\n", + " \n", + " if target_nodes.nelement() > 0: \n", + " params = []\n", + " if exists(params_tensor):\n", + " params = params_tensor[:, t]\n", + " if params_4pi_normalization:\n", + " params = (params+1.0) * 2.0*np.pi # [-1, 1] to [0, 4pi]\n", + " params = params.tolist()\n", + "\n", + " instructions.add_instruction(gate, control_nodes.tolist(), target_nodes.tolist(), params)\n", + " \n", + " break #break on first hit, per def only one gate allowed per t\n", + " \n", + " elif control_nodes.nelement() > 0: # no target but control means error\n", + " raise RuntimeError(\"target_nodes.nelement() <= 0 but control_nodes.nelement() > 0\")\n", + " \n", + " #else we are fine with tensors that have time steps with no action!\n", + " \n", + " return instructions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d81b862-99c2-4f71-ba05-0acfe7f5d20a", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "backend = CircuitsCudaqBackend()\n", + "\n", + "def genqc_to_cudaq(tensor: torch.Tensor, vocabulary_inverse: dict) -> cudaq.kernel:\n", + " \"\"\"Convert given `torch.Tensor` to a `cudaq.kernel`.\"\"\"\n", + " instructions = tensor_to_instructions(tensor, vocabulary_inverse) \n", + " kernel = backend.export_cudaq(instructions)\n", + " return kernel" + ] + }, + { + "cell_type": "markdown", + "id": "f41f26a8-ac40-4e91-8c0e-1ef07a0fd4f4", + "metadata": {}, + "source": [ + "# Export -" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0474216-8e0c-4ba7-9a37-571ac7d8e82c", + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "import nbdev; nbdev.nbdev_export()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/inference/infer_compilation.ipynb b/src/inference/infer_compilation.ipynb index 8c52851..6fec960 100644 --- a/src/inference/infer_compilation.ipynb +++ b/src/inference/infer_compilation.ipynb @@ -32,6 +32,7 @@ "from genQC.inference.infer_gate_hist import get_tensor_gate_length\n", "import genQC.platform.qcircuit_dataset_construction as data_con\n", "from genQC.dataset.dataset_helper import check_duplicates_in_dataset, uniquify_tensor_dataset, shuffle_tensor_dataset\n", + "from genQC.platform.simulation.qcircuit_sim import instruction_name_to_qiskit_gate\n", "\n", "from joblib import Parallel, delayed\n", "import qiskit.quantum_info as qi" @@ -270,6 +271,9 @@ "#| export\n", "def get_gate_and_U_acc(out_tensor, allowed_gate_clrs, U, gate_pool, num_of_qubits, max_gates, norms=[], no_bar=True):\n", "\n", + " if isinstance(gate_pool[0], str):\n", + " gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in gate_pool]\n", + " \n", " #-------------------------\n", " #decode \n", " qc_list, error_cnt = convert_tensors_to_circuits(out_tensor, gate_pool)\n", diff --git a/src/inference/infer_misc.ipynb b/src/inference/infer_misc.ipynb index bee933e..b6a69ba 100644 --- a/src/inference/infer_misc.ipynb +++ b/src/inference/infer_misc.ipynb @@ -27,7 +27,8 @@ "source": [ "#| export\n", "from genQC.imports import *\n", - "from genQC.platform.qcircuit_dataset_construction import decode_circuit, gate_pool_to_gate_classes" + "from genQC.platform.qcircuit_dataset_construction import decode_circuit, gate_pool_to_gate_classes\n", + "from genQC.platform.simulation.qcircuit_sim import instruction_name_to_qiskit_gate" ] }, { @@ -76,6 +77,9 @@ "source": [ "#| export\n", "def convert_tensors_to_circuits(out_tensor, gate_pool, params_tensor=None, place_barrier=False): \n", + " if isinstance(gate_pool[0], str):\n", + " gate_pool = [instruction_name_to_qiskit_gate(gate) for gate in gate_pool]\n", + " \n", " error_cnt = 0\n", " qc_list = []\n", "\n", diff --git a/src/models/config_model.ipynb b/src/models/config_model.ipynb index 2482093..4351f3e 100644 --- a/src/models/config_model.ipynb +++ b/src/models/config_model.ipynb @@ -104,7 +104,7 @@ " print(\"[INFO]: Found no key `save_path` path in config.\")\n", " \n", " if exists(save_path):\n", - " model.load_state_dict(torch.load(save_path, map_location=torch.device(device).type), strict=True)\n", + " model.load_state_dict(torch.load(save_path, map_location=torch.device(device).type, weights_only=True), strict=True)\n", " else:\n", " print(f\"[INFO]: `{class_to_str(type(model))}`. No save_path` provided. No state dict loaded.\")\n", "\n", diff --git a/src/pipeline/diffusion_pipeline.ipynb b/src/pipeline/diffusion_pipeline.ipynb index d2e97c3..48651e4 100644 --- a/src/pipeline/diffusion_pipeline.ipynb +++ b/src/pipeline/diffusion_pipeline.ipynb @@ -30,7 +30,9 @@ "from genQC.scheduler.scheduler import Scheduler\n", "from genQC.pipeline.pipeline import Pipeline\n", "from genQC.config_loader import *\n", - "from genQC.models.config_model import Config_Model" + "from genQC.models.config_model import Config_Model\n", + "\n", + "from huggingface_hub import snapshot_download" ] }, { @@ -126,11 +128,19 @@ " pipeline = instantiate_from_config(config)\n", " \n", " if exists(pipeline.add_config):\n", - " pipeline.gate_pool = [get_obj_from_str(gate) for gate in add_config[\"dataset\"][\"params\"][\"gate_pool\"]] \n", + " pipeline.gate_pool = [gate for gate in add_config[\"dataset\"][\"params\"][\"gate_pool\"]] \n", " pipeline.add_config = add_config\n", " \n", " return pipeline\n", - " \n", + "\n", + "\n", + " @classmethod\n", + " def from_pretrained(cls, repo_id: str, device: torch.device, **kwargs): \n", + " \"\"\"Load a model pipeline directly from Huggingface.\"\"\"\n", + " model_path = snapshot_download(repo_id=repo_id, repo_type=\"model\", allow_patterns=[\"*.pt\", \"*.yaml\", \"*.safetensors\"], **kwargs) \n", + " pipeline = cls.from_config_file(model_path+\"/\", device) \n", + " return pipeline\n", + " \n", " #------------------------------------\n", " # Inference functions\n", " \n", diff --git a/src/platform/simulation/qcircuit_sim.ipynb b/src/platform/simulation/qcircuit_sim.ipynb index 9fb3b77..2f5e73b 100644 --- a/src/platform/simulation/qcircuit_sim.ipynb +++ b/src/platform/simulation/qcircuit_sim.ipynb @@ -27,6 +27,7 @@ "source": [ "#| export\n", "from genQC.imports import *\n", + "from genQC.config_loader import *\n", "\n", "import qiskit.quantum_info as qi\n", "from qiskit import QuantumCircuit, transpile\n", @@ -74,6 +75,23 @@ " return classes" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "84e71331-15b4-4877-a331-e67ebb44ba3a", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def instruction_name_to_qiskit_gate(name: str) -> Gate:\n", + " match name:\n", + " case \"swap\": name = \"Swap\"\n", + " case \"cp\": name = \"CPhase\"\n", + " case _: name = name.upper()\n", + " \n", + " return get_obj_from_str(f\"qiskit.circuit.library.standard_gates.{name}Gate\")" + ] + }, { "cell_type": "code", "execution_count": null, @@ -92,7 +110,7 @@ " trace = list(total_trace - {i})\n", " red_densityMatrix = qi.partial_trace(densityMatrix, trace) \n", " # r = np.count_nonzero(np.linalg.eigvals(red_densityMatrix) > 1e-14) # was slower during testing \n", - " r = np.linalg.matrix_rank(red_densityMatrix, hermitian=True) \n", + " r = np.linalg.matrix_rank(red_densityMatrix, hermitian=True).item() \n", " rank_vector.append(r)\n", " \n", " return rank_vector" @@ -156,7 +174,7 @@ { "data": { "text/plain": [ - "'Rand: svr=[1, 1, 1] num_gates=8'" + "'Rand: svr=[2, 2, 2] num_gates=8'" ] }, "metadata": {}, @@ -164,9 +182,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -175,7 +193,7 @@ { "data": { "text/plain": [ - "'Opti: svr=[1, 1, 1] num_gates=8'" + "'Opti: svr=[2, 2, 2] num_gates=8'" ] }, "metadata": {}, @@ -183,9 +201,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -243,16 +261,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "[1, 1, 1]: 58.2%\n", - "[2, 2, 1]: 11.5%\n", - "[2, 2, 2]: 11.3%\n", - "[1, 2, 2]: 9.6%\n", - "[2, 1, 2]: 9.4%\n" + "[1, 1, 1]: 60.2%\n", + "[1, 2, 2]: 11.1%\n", + "[2, 2, 1]: 10.1%\n", + "[2, 2, 2]: 9.9%\n", + "[2, 1, 2]: 8.7%\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ]