diff --git a/.envrc b/.envrc index 01f5f41d0e..3af52d88ed 100644 --- a/.envrc +++ b/.envrc @@ -2,8 +2,8 @@ if ! has nix_direnv_version || ! nix_direnv_version 2.2.1; then source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/2.2.1/direnvrc" "sha256-zelF0vLbEl5uaqrfIzbgNzJWGmLzCmYAkInj/LNxvKs=" fi -nix_direnv_watch_file flake.nix -nix_direnv_watch_file flake.lock +watch_file flake.nix +watch_file flake.lock if ! use flake . --impure; then echo "devenv could not be built. The devenv environment was not loaded. Make the necessary changes to devenv.nix and hit enter to try again." >&2 fi diff --git a/.github/workflows/capi.yml b/.github/workflows/capi.yml index af0d6d4027..cae687e22c 100644 --- a/.github/workflows/capi.yml +++ b/.github/workflows/capi.yml @@ -13,11 +13,11 @@ jobs: runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Python - uses: actions/setup-python@v4 + uses: actions/setup-python@v5 with: - python-version: "3.10" + python-version: "3.11" - name: Prepare virtual environment run: | python -m venv env diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index 854ec7f7ca..c1ee242dae 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -11,12 +11,12 @@ jobs: build: strategy: matrix: - os: [ubuntu-latest, macos-13, windows-latest] - python-version: [3.9, "3.10", "3.11"] + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ["3.9", "3.10", "3.11", "3.12"] uses: qiboteam/workflows/.github/workflows/deploy-pip-poetry.yml@v1 with: os: ${{ matrix.os }} python-version: ${{ matrix.python-version }} - publish: ${{ github.event_name == 'release' && github.event.action == 'published' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.9' }} + publish: ${{ github.event_name == 'release' && github.event.action == 'published' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.10' }} poetry-extras: "--with docs,tests,analysis --all-extras" secrets: inherit diff --git a/.github/workflows/rules.yml b/.github/workflows/rules.yml index 462f544195..cac9eaf99d 100644 --- a/.github/workflows/rules.yml +++ b/.github/workflows/rules.yml @@ -11,12 +11,12 @@ jobs: build: strategy: matrix: - os: [ubuntu-latest, macos-13, windows-latest] - python-version: [3.9, "3.10", "3.11"] + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ["3.9", "3.10", "3.11", "3.12"] uses: qiboteam/workflows/.github/workflows/rules-poetry.yml@v1 with: os: ${{ matrix.os }} python-version: ${{ matrix.python-version }} - doctests: ${{ matrix.os == 'ubuntu-latest'}} + doctests: ${{ matrix.os == 'ubuntu-latest' && matrix.python-version != '3.12'}} poetry-extras: "--with docs,tests,analysis --all-extras" secrets: inherit diff --git a/.github/workflows/rustapi.yml b/.github/workflows/rustapi.yml index 8f49712533..3b3ac52aca 100644 --- a/.github/workflows/rustapi.yml +++ b/.github/workflows/rustapi.yml @@ -2,29 +2,25 @@ name: Rust API on: - push: workflow_dispatch: jobs: tests: strategy: matrix: - os: [ubuntu-latest, macos-13] + os: [ubuntu-latest, macos-latest] runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Python - uses: actions/setup-python@v4 + uses: actions/setup-python@v5 with: - python-version: "3.10" + python-version: "3.11" - name: Prepare virtual environment run: | pip install . - - name: Install Rust - uses: actions-rs/toolchain@v1 - with: - toolchain: stable + - uses: dtolnay/rust-toolchain@stable - name: Check and lint working-directory: crate run: | diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 8896d83bfa..3264c6b1c1 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -34,7 +34,6 @@ repos: - id: pycln args: - --config=pyproject.toml - - --all - repo: https://github.com/adamchainz/blacken-docs rev: 1.18.0 hooks: diff --git a/README.md b/README.md index c1bcc12f1f..b3a7e2f17e 100644 --- a/README.md +++ b/README.md @@ -10,10 +10,9 @@ the automatic deployment of quantum circuits on quantum hardware. Some of the key features of Qibolab are: - Deploy Qibo models on quantum hardware easily. -- Create custom experimental drivers for custom lab setup. +- Create experimental drivers for custom lab setup. - Support multiple heterogeneous platforms. -- Use existing calibration procedures for experimentalists. -- Provide a emulator backend equipped with various quantum dynamics simulation engines (currently support: QuTiP) for seamless emulation of quantum hardware. +- Use calibration procedures from [Qibocal](https://github.com/qiboteam/qibocal). ## Documentation @@ -26,79 +25,94 @@ The qibolab backend documentation is available at [https://qibo.science/qibolab/ A simple example on how to connect to a platform and use it execute a pulse sequence: ```python -from qibolab import create_platform, ExecutionParameters -from qibolab.pulses import DrivePulse, ReadoutPulse, PulseSequence - -# Define PulseSequence -sequence = PulseSequence() -# Add some pulses to the pulse sequence -sequence.add( - DrivePulse( - start=0, - amplitude=0.3, - duration=4000, - frequency=200_000_000, - relative_phase=0, - shape="Gaussian(5)", # Gaussian shape with std = duration / 5 - channel=1, - ) -) - -sequence.add( - ReadoutPulse( - start=4004, - amplitude=0.9, - duration=2000, - frequency=20_000_000, - relative_phase=0, - shape="Rectangular", - channel=2, - ) -) +from qibolab import create_platform # Define platform and load specific runcard platform = create_platform("my_platform") +# Create a pulse sequence based on native gates of qubit 0 +natives = platform.natives.single_qubit[0] +sequence = natives.RX() | natives.MZ() + # Connects to lab instruments using the details specified in the calibration settings. platform.connect() # Execute a pulse sequence -options = ExecutionParameters(nshots=1000) -results = platform.execute_pulse_sequence(sequence, options) +results = platform.execute([sequence], nshots=1000) -# Print the acquired shots -print(results.samples) +# Grab the acquired shots corresponding to +# the measurement using its pulse id. +# The ``PulseSequence`` structure is list[tuple[ChannelId, Pulse]] +# thererefore we need to index it appropriately +# to get the acquisition pulse +readout_id = sequence.acquisitions[0][1].id +print(results[readout_id]) # Disconnect from the instruments platform.disconnect() ``` -Here is another example on how to execute circuits: +Arbitrary pulse sequences can also be created using the pulse API: ```python -import qibo -from qibo import gates, models +from qibolab import ( + Acquisition, + Delay, + Gaussian, + Pulse, + PulseSequence, + Readout, + Rectangular, +) + +# Crete some pulses +pulse = Pulse( + amplitude=0.3, + duration=40, + relative_phase=0, + envelope=Gaussian(rel_sigma=0.2), # Gaussian shape with std = 0.2 * duration +) +delay = Delay(duration=40) +readout = Readout( + acquisition=Acquisition(duration=2000), + probe=Pulse( + amplitude=0.9, + duration=2000, + envelope=Rectangular(), + relative_phase=0, + ), +) +# Add them to a PulseSequence +sequence = PulseSequence( + [ + (1, pulse), # pulse plays on channel 1 + (2, delay), # delay and readout plays on channel 2 + (2, readout), + ] +) +``` + +Here is another example on how to execute circuits: + +```python +from qibo import gates, models, set_backend -# Create circuit and add gates +# Create circuit and add native gates c = models.Circuit(1) -c.add(gates.H(0)) -c.add(gates.RX(0, theta=0.2)) -c.add(gates.X(0)) +c.add(gates.GPI2(0, phi=0.2)) c.add(gates.M(0)) # Simulate the circuit using numpy -qibo.set_backend("numpy") -for _ in range(5): - result = c(nshots=1024) - print(result.probabilities()) +set_backend("numpy") +result = c(nshots=1024) +print(result.probabilities()) # Execute the circuit on hardware -qibo.set_backend("qibolab", platform="my_platform") -for _ in range(5): - result = c(nshots=1024) - print(result.probabilities()) +set_backend("qibolab", platform="my_platform") +result = c(nshots=1024) +print(result.probabilities()) ``` ## Citation policy diff --git a/capi/src/wrapper.py b/capi/src/wrapper.py index f002e299a8..9fc894554a 100644 --- a/capi/src/wrapper.py +++ b/capi/src/wrapper.py @@ -1,7 +1,7 @@ # This file is part of from cqibolab import ffi -from qibolab import execute_qasm as py_execute_qasm +from qibolab._core.backends import execute_qasm as py_execute_qasm @ffi.def_extern() diff --git a/doc/source/conf.py b/doc/source/conf.py index a874daf96a..50591064b4 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -18,6 +18,13 @@ import qibolab +# TODO: the following is a workaround for Sphinx doctest, cf. +# - https://github.com/qiboteam/qibolab/commit/e04a6ab +# - https://github.com/pydantic/pydantic/discussions/7763 +import qibolab._core.instruments.dummy +import qibolab._core.instruments.oscillator +import qibolab._core.instruments.zhinst + # -- Project information ----------------------------------------------------- project = "qibolab" @@ -32,7 +39,15 @@ # https://stackoverflow.com/questions/56336234/build-fail-sphinx-error-contents-rst-not-found # master_doc = "index" -autodoc_mock_imports = ["qm"] +autodoc_mock_imports = ["icarusq_rfsoc_driver"] +try: + import qibolab.instruments.qm +except ModuleNotFoundError: + autodoc_mock_imports.extend(["qm", "qualang_tools"]) +try: + import qibolab.instruments.rfsoc +except ModuleNotFoundError: + autodoc_mock_imports.extend(["qibosoq"]) # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom @@ -45,6 +60,7 @@ "sphinx.ext.intersphinx", "recommonmark", "sphinx_copybutton", + "sphinx.ext.todo", "sphinx.ext.viewcode", ] diff --git a/doc/source/getting-started/experiment.rst b/doc/source/getting-started/experiment.rst index 8317fbcc54..4066e5ab7c 100644 --- a/doc/source/getting-started/experiment.rst +++ b/doc/source/getting-started/experiment.rst @@ -12,16 +12,15 @@ To define a platform the user needs to provide a folder with the following struc my_platform/ platform.py parameters.json - kernels.npz # (optional) -where ``platform.py`` contains instruments information, ``parameters.json`` -includes calibration parameters and ``kernels.npz`` is an optional -file with additional calibration parameters. +where ``platform.py`` contains instruments information and ``parameters.json`` includes calibration parameters. -More information about defining platforms is provided in :doc:`../tutorials/lab` and several examples can be found at `TII dedicated repository `_. +More information about defining platforms is provided in :doc:`../tutorials/lab` and several examples can be found +at the `TII QRC lab dedicated repository `_. For a first experiment, let's define a single qubit platform at the path previously specified. -For simplicity, the qubit will be controlled by a RFSoC-based system, althought minimal changes are needed to use other devices. +In this example, the qubit is controlled by a Quantum Machines cluster that contains Octaves, +although minimal changes are needed to use other devices. .. testcode:: python @@ -29,41 +28,67 @@ For simplicity, the qubit will be controlled by a RFSoC-based system, althought import pathlib - from qibolab.channels import Channel, ChannelMap - from qibolab.instruments.rfsoc import RFSoC - from qibolab.instruments.rohde_schwarz import SGS100A as LocalOscillator - from qibolab.platform import Platform - from qibolab.serialize import load_qubits, load_runcard, load_settings - - NAME = "my_platform" # name of the platform - ADDRESS = "192.168.0.1" # ip address of the controller - PORT = 6000 # port of the controller + from qibolab import ( + AcquisitionChannel, + Channel, + ConfigKinds, + DcChannel, + IqChannel, + Platform, + Qubit, + ) + from qibolab.instruments.qm import Octave, QmConfigs, QmController # folder containing runcard with calibration parameters FOLDER = pathlib.Path.cwd() + # Register QM-specific configurations for parameters loading + ConfigKinds.extend([QmConfigs]) + def create(): - # Instantiate controller instruments - controller = RFSoC(NAME, ADDRESS, PORT) - - # Create channel objects and port assignment - channels = ChannelMap() - channels |= Channel("readout", port=controller[1]) - channels |= Channel("feedback", port=controller[0]) - channels |= Channel("drive", port=controller[0]) - - # create qubit objects - runcard = load_runcard(FOLDER) - qubits, pairs = load_qubits(runcard) - # assign channels to qubits - qubits[0].readout = channels["L3-22_ro"] - qubits[0].feedback = channels["L1-2-RO"] - qubits[0].drive = channels["L3-22_qd"] - - instruments = {controller.name: controller} - settings = load_settings(runcard) - return Platform(NAME, qubits, pairs, instruments, settings, resonator_type="3D") + # Define qubit + qubits = { + 0: Qubit( + drive="0/drive", + probe="0/probe", + acquisition="0/acquisition", + ) + } + + # Create channels and connect to instrument ports + channels = {} + qubit = qubits[0] + # Readout + channels[qubit.probe] = IqChannel( + device="octave1", path="1", mixer=None, lo="0/probe/lo" + ) + # Acquire + channels[qubit.acquisition] = AcquisitionChannel( + device="octave1", path="1", probe=qubit.probe + ) + # Drive + channels[qubit.drive] = IqChannel( + device="octave1", path="2", mixer=None, lo="0/drive/lo" + ) + + # Define Quantum Machines instruments + octaves = { + "octave1": Octave("octave5", port=101, connectivity="con1"), + } + controller = QmController( + name="qm", + address="192.168.0.101:80", + octaves=octaves, + channels=channels, + calibration_path=FOLDER, + ) + + # Define and return platform + return Platform.load( + path=FOLDER, instruments=[controller], qubits=qubits, resonator_type="3D" + ) + .. note:: @@ -72,7 +97,7 @@ For simplicity, the qubit will be controlled by a RFSoC-based system, althought .. code-block:: python import pathlib - from qibolab.platform import Platform + from qibolab import Platform def create() -> Platform: @@ -83,66 +108,77 @@ And the we can define the runcard ``my_platform/parameters.json``: .. code-block:: json { - "nqubits": 1, - "qubits": [ - 0 - ], - "topology": [], - "settings": { - "nshots": 1024, - "relaxation_time": 70000, - "sampling_rate": 9830400000 - }, - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 40, - "amplitude": 0.5, - "frequency": 5500000000, - "shape": "Gaussian(3)", - "type": "qd", - "start": 0, - "phase": 0 - }, - "MZ": { - "duration": 2000, - "amplitude": 0.02, - "frequency": 7370000000, - "shape": "Rectangular()", - "type": "ro", - "start": 0, - "phase": 0 - } - } + "settings": { + "nshots": 1024, + "relaxation_time": 70000 }, - "two_qubits": {} - }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 7370000000, - "drive_frequency": 5500000000, - "anharmonicity": 0, - "Ec": 0, - "Ej": 0, - "g": 0, - "T1": 0.0, - "T2": 0.0, - "threshold": 0.0, - "iq_angle": 0.0, - "mean_gnd_states": [ - 0.0, - 0.0 - ], - "mean_exc_states": [ - 0.0, - 0.0 - ] + "configs": { + "0/drive": { + "kind": "iq", + "frequency": 4833726197 + }, + "0/drive/lo": { + "kind": "oscillator", + "frequency": 5200000000, + "power": 0 + }, + "0/probe": { + "kind": "iq", + "frequency": 7320000000 + }, + "0/probe/lo": { + "kind": "oscillator", + "frequency": 7300000000, + "power": 0 + }, + "0/acquisition": { + "kind": "qm-acquisition", + "delay": 224, + "smearing": 0, + "threshold": 0.002100861788865835, + "iq_angle": -0.7669877581038627, + "gain": 10, + "offset": 0.0 } + }, + "native_gates": { + "single_qubit": { + "0": { + "RX": { + "0/drive": [ + { + "duration": 40, + "amplitude": 0.5, + "envelope": { "kind": "gaussian", "rel_sigma": 3.0 }, + "type": "qd" + } + ] + }, + "MZ": [ + [ + "0/acquisition", + { + "kind": "readout", + "acquisition": { + "kind": "acquisition", + "duration": 2000.0 + }, + "probe": { + "kind": "pulse", + "duration": 2000.0, + "amplitude": 0.003, + "envelope": { + "kind": "rectangular" + } + } + } + ] + ] + } + }, + "two_qubit": {} } } - } Setting up the environment @@ -163,7 +199,7 @@ for Windows: $env:QIBOLAB_PLATFORMS="" -To avoid having to repeat this export command for every session, this line can be added to the ``.bashrc`` file (or alternatives as ``.zshrc``). +To avoid having to repeat this export command for every session, this line can be added to the ``.bashrc`` file (or alternatives such as ``.zshrc``). Run the experiment @@ -179,44 +215,46 @@ We leave to the dedicated tutorial a full explanation of the experiment, but her import numpy as np import matplotlib.pyplot as plt - from qibolab import create_platform - from qibolab.pulses import PulseSequence - from qibolab.sweeper import Sweeper, SweeperType, Parameter - from qibolab.execution_parameters import ( - ExecutionParameters, - AveragingMode, + from qibolab import ( AcquisitionType, + AveragingMode, + Parameter, + PulseSequence, + Sweeper, + create_platform, ) # load the platform from ``dummy.py`` and ``dummy.json`` platform = create_platform("dummy") + qubit = platform.qubits[0] + natives = platform.natives.single_qubit[0] # define the pulse sequence - sequence = PulseSequence() - ro_pulse = platform.create_MZ_pulse(qubit=0, start=0) - sequence.add(ro_pulse) + sequence = natives.MZ.create_sequence() # define a sweeper for a frequency scan + f0 = platform.config(qubit.probe).frequency # center frequency sweeper = Sweeper( parameter=Parameter.frequency, - values=np.arange(-2e8, +2e8, 1e6), - pulses=[ro_pulse], - type=SweeperType.OFFSET, + range=(f0 - 2e8, f0 + 2e8, 1e6), + channels=[qubit.probe], ) # perform the experiment using specific options - options = ExecutionParameters( + results = platform.execute( + [sequence], + [[sweeper]], nshots=1000, relaxation_time=50, averaging_mode=AveragingMode.CYCLIC, acquisition_type=AcquisitionType.INTEGRATION, ) - - results = platform.sweep(sequence, options, sweeper) + _, acq = next(iter(sequence.acquisitions)) # plot the results - amplitudes = results[ro_pulse.serial].magnitude - frequencies = np.arange(-2e8, +2e8, 1e6) + ro_pulse.frequency + signal = results[acq.id] + amplitudes = signal[..., 0] + 1j * signal[..., 1] + frequencies = sweeper.values plt.title("Resonator Spectroscopy") plt.xlabel("Frequencies [Hz]") diff --git a/doc/source/getting-started/qibolab_workflow.png b/doc/source/getting-started/qibolab_workflow.png deleted file mode 100644 index 59d30405ae..0000000000 Binary files a/doc/source/getting-started/qibolab_workflow.png and /dev/null differ diff --git a/doc/source/index.rst b/doc/source/index.rst index 7a0b2f9069..c1649fb8ad 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -12,27 +12,20 @@ Qibolab is the dedicated `Qibo `_ backend for quantum hardware control. This module automates the implementation of quantum circuits on quantum hardware. Qibolab includes: -1. :ref:`Platform API `: support custom allocation of quantum hardware platforms / lab setup. -2. :ref:`Drivers `: supports commercial and open-source firmware for hardware control. -3. :ref:`Arbitrary pulse API `: provide a library of custom pulses for execution through instruments. -4. :ref:`Compiler `: compiles quantum circuits into pulse sequences. -5. :ref:`Quantum Circuit Deployment `: seamlessly deploys quantum circuit models on quantum hardware. -5. :ref:`Emulator `: seamless emulation of quantum hardware based on a emulator backend equipped with various quantum dynamics simulation engines. +#. :ref:`Platform API `: support custom allocation of quantum hardware platforms and lab setup. +#. :ref:`Pulse API `: provide a library of custom pulses for execution through instruments. +#. :ref:`Drivers `: supports commercial and open-source firmware for hardware control. +#. :ref:`Compiler `: compiles quantum circuits into pulse sequences. +#. :ref:`Quantum Circuit Deployment `: seamlessly deploys quantum circuit models on quantum hardware. -Components ----------- - -The main components of Qibolab are presented in :doc:`main-documentation/index` - -.. image:: /main-documentation/platform.svg Key features ------------ * Deploy Qibo models on quantum hardware easily. -* Create custom experimental drivers for custom lab setup. +* Create experimental drivers for custom lab setup. * Support multiple heterogeneous platforms. -* Use existing calibration procedures for experimentalists. +* Use calibration procedures from `Qibocal `_. How to Use the Documentation ============================ diff --git a/doc/source/main-documentation/index.rst b/doc/source/main-documentation/index.rst index 8bab6ae22d..579d2778e9 100644 --- a/doc/source/main-documentation/index.rst +++ b/doc/source/main-documentation/index.rst @@ -7,7 +7,6 @@ complete overview of the code, for that we suggest to refer to the api-reference section, but rather to help a new user to gain a basic understanding of all the elements. -.. image:: platform.svg .. toctree:: :caption: Main elements diff --git a/doc/source/main-documentation/platform.svg b/doc/source/main-documentation/platform.svg deleted file mode 100644 index a63f845ecb..0000000000 --- a/doc/source/main-documentation/platform.svg +++ /dev/null @@ -1,18 +0,0 @@ -
Platform
Qubit
NativeGate
Characterization
QubitPair
NativeGate
Characterization
Instrument
Port
Channel
 diff --git a/doc/source/main-documentation/qibolab.rst b/doc/source/main-documentation/qibolab.rst index 13715609f7..74fdec314e 100644 --- a/doc/source/main-documentation/qibolab.rst +++ b/doc/source/main-documentation/qibolab.rst @@ -5,7 +5,8 @@ Platforms Qibolab provides support to different quantum laboratories. -Each lab configuration is implemented using a :class:`qibolab.platform.Platform` object which orchestrates instruments, qubits and channels and provides the basic features for executing pulses. +Each lab configuration is implemented using a :class:`qibolab.Platform` object which orchestrates instruments, +qubits and channels and provides the basic features for executing pulses. Therefore, the ``Platform`` enables the user to interface with all the required lab instruments at the same time with minimum effort. @@ -13,13 +14,12 @@ The API reference section provides a description of all the attributes and metho In the platform, the main methods can be divided in different sections: -- functions save and change qubit parameters (``dump``, ``update``) -- functions to coordinate the instruments (``connect``, ``setup``, ``disconnect``) -- functions to execute experiments (``execute_pulse_sequence``, ``execute_pulse_sequences``, ``sweep``) -- functions to initialize gates (``create_RX90_pulse``, ``create_RX_pulse``, ``create_CZ_pulse``, ``create_MZ_pulse``, ``create_qubit_drive_pulse``, ``create_qubit_readout_pulse``, ``create_RX90_drag_pulse``, ``create_RX_drag_pulse``) -- setters and getters of channel/qubit parameters (local oscillator parameters, attenuations, gain and biases) +- functions to coordinate the instruments (``connect``, ``disconnect``) +- a unique interface to execute experiments (``execute``) +- functions save parameters (``dump``) -The idea of the ``Platform`` is to serve as the only object exposed to the user, so that we can deploy experiments, without any need of going into the low-level instrument-specific code. +The idea of the ``Platform`` is to serve as the only object exposed to the user, so that we can deploy experiments, +without any need of going into the low-level instrument-specific code. For example, let's first define a platform (that we consider to be a single qubit platform) using the ``create`` method presented in :doc:`/tutorials/lab`: @@ -35,57 +35,65 @@ Now we connect to the instruments (note that we, the user, do not need to know w platform.connect() -We can easily print some of the parameters of the channels (similarly we can set those, if needed): +We can easily access the names of channels and other components, and based on the name retrieve the corresponding configuration. As an example let's print some things: .. note:: - If the get_method does not apply to the platform (for example there is no local oscillator, to TWPA or no flux tunability...) a ``NotImplementedError`` will be raised. + If requested component does not exist in a particular platform, its name will be `None`, so watch out for such names, and make sure what you need exists before requesting its configuration. .. testcode:: python - print(f"Drive LO frequency: {platform.qubits[0].drive.lo_frequency}") - print(f"Readout LO frequency: {platform.qubits[0].readout.lo_frequency}") - print(f"TWPA LO frequency: {platform.qubits[0].twpa.lo_frequency}") - print(f"Qubit bias: {platform.qubits[0].flux.offset}") - print(f"Qubit attenuation: {platform.qubits[0].readout.attenuation}") + drive_channel_id = platform.qubits[0].drive + drive_channel = platform.channels[drive_channel_id] + print(f"Drive channel name: {drive_channel_id}") + print(f"Drive frequency: {platform.config(drive_channel_id).frequency}") + + drive_lo = drive_channel.lo + if drive_lo is None: + print(f"Drive channel {drive_channel_id} does not use an LO.") + else: + print(f"Name of LO for channel {drive_channel_id} is {drive_lo}") + print(f"LO frequency: {platform.config(drive_lo).frequency}") .. testoutput:: python :hide: - Drive LO frequency: 0 - Readout LO frequency: 0 - TWPA LO frequency: 1000000000.0 - Qubit bias: 0.0 - Qubit attenuation: 0 + Drive channel name: 0/drive + Drive frequency: 4000000000.0 + Drive channel 0/drive does not use an LO. -Now we can create a simple sequence (again, without explicitly giving any qubit specific parameter, as these are loaded automatically from the platform, as defined in the runcard): +Now we can create a simple sequence without explicitly giving any qubit specific parameter, +as these are loaded automatically from the platform, as defined in the corresponding ``parameters.json``: .. testcode:: python - from qibolab.pulses import PulseSequence + from qibolab import Delay, PulseSequence + import numpy as np ps = PulseSequence() - ps.add(platform.create_RX_pulse(qubit=0, start=0)) # start time is in ns - ps.add(platform.create_RX_pulse(qubit=0, start=100)) - ps.add(platform.create_MZ_pulse(qubit=0, start=200)) + qubit = platform.qubits[0] + natives = platform.natives.single_qubit[0] + ps.concatenate(natives.RX()) + ps.concatenate(natives.R(phi=np.pi / 2)) + ps.append((qubit.probe, Delay(duration=200))) + ps.concatenate(natives.MZ()) Now we can execute the sequence on hardware: .. testcode:: python - from qibolab.execution_parameters import ( + from qibolab import ( AcquisitionType, AveragingMode, - ExecutionParameters, ) - options = ExecutionParameters( + options = dict( nshots=1000, relaxation_time=10, fast_reset=False, acquisition_type=AcquisitionType.INTEGRATION, averaging_mode=AveragingMode.CYCLIC, ) - results = platform.execute_pulse_sequence(ps, options=options) + results = platform.execute([ps], **options) Finally, we can stop instruments and close connections. @@ -99,9 +107,9 @@ Finally, we can stop instruments and close connections. Dummy platform ^^^^^^^^^^^^^^ -In addition to the real instruments presented in the :ref:`main_doc_instruments` section, Qibolab provides the :class:`qibolab.instruments.dummy.DummyInstrument`. +In addition to the real instruments presented in the :ref:`main_doc_instruments` section, Qibolab provides the :class:`qibolab.instruments.DummyInstrument`. This instrument represents a controller that returns random numbers of the proper shape when executing any pulse sequence. -This instrument is also part of the dummy platform which is defined in :py:mod:`qibolab.dummy` and can be initialized as +This instrument is also part of the dummy platform which is defined in :py:mod:`qibolab._core.dummy` and can be initialized as .. testcode:: python @@ -112,160 +120,61 @@ This instrument is also part of the dummy platform which is defined in :py:mod:` This platform is equivalent to real platforms in terms of attributes and functions, but returns just random numbers. It is useful for testing parts of the code that do not necessarily require access to an actual quantum hardware platform. -.. testcode:: python - - from qibolab import create_platform - - platform = create_platform("dummy_couplers") - -will create a dummy platform that also has coupler qubits. - - -.. _main_doc_emulator: - -Emulator platform -^^^^^^^^^^^^^^^^^ - -QiboLab supports the use of emulators to simulate the behavior of quantum devices. It uses :class:`qibolab.instruments.emulator.pulse_simulator.PulseSimulator`, which is a controller that utilizes a simulation engine to numerically solve the dynamics of the device in the presence of control pulse sequences specified by :class:`qibolab.pulses.PulseSequence`. The emulator platform for a specific device requires its own platform folder and can be initialized in the same way as any other real platforms: - -.. testcode:: python_emulator - - import os - from pathlib import Path - - path_to_emulator_runcard = str(Path.cwd().parent / "tests" / "emulators") - - emulator_runcard_name = "default_q0" - - os.environ["QIBOLAB_PLATFORMS"] = path_to_emulator_runcard # can also be set beforehand - - from qibolab import create_platform - - platform = create_platform(emulator_runcard_name) - -An emulator platform is equivalent to real platforms in terms of attributes and functions, but returns simulated results. -It is useful for testbedding and calibrating pulses, and testing calibration and characterization routines for the corresponding real device especially when access to the real device is limited or when it is unavailable. - - -.. _main_doc_qubits: - -Qubits ------- - -The :class:`qibolab.qubits.Qubit` class serves as a comprehensive representation of a physical qubit within the Qibolab framework. -It encapsulates three fundamental elements crucial to qubit control and operation: - -- :ref:`Channels `: Physical Connections -- :class:`Parameters `: Configurable Properties -- :ref:`Native Gates `: Quantum Operations - -Channels play a pivotal role in connecting the quantum system to the control infrastructure. -They are optional and encompass distinct types, each serving a specific purpose: - -- readout (from controller device to the qubits) -- feedback (from qubits to controller) -- twpa (pump to the TWPA) -- drive -- flux - -The Qubit class allows you to set and manage several key parameters that influence qubit behavior. -These parameters are typically extracted from the runcard during platform initialization. - -.. _main_doc_couplers: - -Couplers --------- - -The :class:`qibolab.couplers.Coupler` class serves as a comprehensive representation of a physical coupler qubit within the Qibolab framework. -It's a simplified :class:`qibolab.qubits.Qubit` to control couplers during 2q gate operation: - -- :ref:`Channels `: Physical Connection -- :class:`Parameters `: Configurable Properties -- :ref:`Qubits `: Qubits the coupler acts on - -We have a single required Channel for flux coupler control: - -- flux - -The Coupler class allows us to handle 2q interactions in coupler based architectures -in a simple way. They are usually associated with :class:`qibolab.qubits.QubitPair` -and usually extracted from the runcard during platform initialization. .. _main_doc_channels: Channels -------- -In Qibolab, channels serve as abstractions for physical wires within a laboratory setup. -Each :class:`qibolab.channels.Channel` object corresponds to a specific type of connection, simplifying the process of controlling quantum pulses across the experimental setup. - +Channels play a pivotal role in connecting the quantum system to the control infrastructure. Various types of channels are typically present in a quantum laboratory setup, including: +- the probe line (from device to qubit) +- the acquire line (from qubit to device) - the drive line -- the readout line (from device to qubit) -- the feedback line (from qubit to device) - the flux line - the TWPA pump line +Qibolab provides a general :class:`qibolab.Channel` object, as well as specializations depending on the channel role. A channel is typically associated with a specific port on a control instrument, with port-specific properties like "attenuation" and "gain" that can be managed using provided getter and setter methods. +Channels are uniquely identified within the platform through their id. The idea of channels is to streamline the pulse execution process. -When initiating a pulse, the platform identifies the corresponding channel for the pulse type and directs it to the appropriate port on the control instrument. -For instance, to deliver a drive pulse to a qubit, the platform references the qubit's associated channel and delivers the pulse to the designated port. +The :class:`qibolab.PulseSequence` is a list of ``(channel_id, pulse)`` tuples, so that the platform identifies the channel that every pulse plays +and directs it to the appropriate port on the control instrument. In setups involving frequency-specific pulses, a local oscillator (LO) might be required for up-conversion. Although logically distinct from the qubit, the LO's frequency must align with the pulse requirements. -Qibolab accommodates this by enabling the assignment of a :class:`qibolab.instruments.oscillator.LocalOscillator` object to the relevant channel. +Qibolab accommodates this by enabling the assignment of a :class:`qibolab._core.instruments.oscillator.LocalOscillator` object +to the relevant channel :class:`qibolab.IqChannel`. The controller's driver ensures the correct pulse frequency is set based on the LO's configuration. -Let's explore an example using an RFSoC controller. -Note that while channels are defined in a device-independent manner, the port parameter varies based on the specific instrument. +Each channel has a :class:`qibolab._core.components.configs.Config` associated to it, which is a container of parameters related to the channel. +Configs also have different specializations that correspond to different channel types. +The platform holds default config parameters for all its channels, however the user is able to alter them by passing a config updates dictionary +when calling :meth:`qibolab.Platform.execute`. +The final configs are then sent to the controller instrument, which matches them to channels via their ids and ensures they are uploaded to the proper electronics. -.. testcode:: python - from qibolab.channels import Channel, ChannelMap - from qibolab.instruments.rfsoc import RFSoC - - controller = RFSoC(name="dummy", address="192.168.0.10", port="6000") - channel1 = Channel("my_channel_name_1", port=controller.ports(1)) - channel2 = Channel("my_channel_name_2", port=controller.ports(2)) - channel3 = Channel("my_channel_name_3", port=controller.ports(3)) - -Channels are then organized in :class:`qibolab.channels.ChannelMap` to be passed as a single argument to the platform. -Following the tutorial in :doc:`/tutorials/lab`, we can continue the initialization: - -.. testcode:: python - - from pathlib import Path - from qibolab.serialize import load_qubits, load_runcard - - path = Path.cwd().parent / "src" / "qibolab" / "dummy" - - ch_map = ChannelMap() - ch_map |= channel1 - ch_map |= channel2 - ch_map |= channel3 - - runcard = load_runcard(path) - qubits, couplers, pairs = load_qubits(runcard) +.. _main_doc_qubits: - qubits[0].drive = channel1 - qubits[0].readout = channel2 - qubits[0].feedback = channel3 +Qubits +------ -Where, in the last lines, we assign the channels to the qubits. +The :class:`qibolab.Qubit` class serves as a container for the channels that are used to control the corresponding physical qubit. +These channels encompass distinct types, each serving a specific purpose: -To assign local oscillators, the procedure is simple: +- probe (measurement probe from controller device to the qubits) +- acquisition (measurement acquisition from qubits to controller) +- drive +- flux +- drive_qudits (additional drive channels at different frequencies used to probe higher-level transition) -.. testcode:: python +Some channel types are optional because not all hardware platforms require them. +For example, flux channels are typically relevant only for flux tunable qubits. - from qibolab.instruments.erasynth import ERA as LocalOscillator +The :class:`qibolab.Qubit` class can also be used to represent coupler qubits, when these are available. - LO_ADDRESS = "192.168.0.10" - local_oscillator = LocalOscillator("NameLO", LO_ADDRESS) - local_oscillator.frequency = 6e9 # Hz - local_oscillator.power = 5 # dB - channel2.local_oscillator = local_oscillator .. _main_doc_pulses: @@ -273,138 +182,91 @@ Pulses ------ In Qibolab, an extensive API is available for working with pulses and pulse sequences, a fundamental aspect of quantum experiments. -At the heart of this API is the :class:`qibolab.pulses.Pulse` object, which empowers users to define and customize pulses with specific parameters. +At the heart of this API is the :class:`qibolab.Pulse` object, which empowers users to define and customize pulses with specific parameters. -The API provides specialized subclasses tailored to the main types of pulses typically used in quantum experiments: +Additionally, pulses are defined by an envelope shape, represented by a subclass of :class:`qibolab._core.pulses.envelope.BaseEnvelope`. +Qibolab offers a range of pre-defined pulse shapes which can be found in :py:mod:`qibolab._core.pulses.envelope`. -- Readout Pulses (:class:`qibolab.pulses.ReadoutPulse`) -- Drive Pulses (:class:`qibolab.pulses.DrivePulse`) -- Flux Pulses (:class:`qibolab.pulses.FluxPulse`) +- Rectangular (:class:`qibolab.Rectangular`) +- Exponential (:class:`qibolab.Exponential`) +- Gaussian (:class:`qibolab.Gaussian`) +- Drag (:class:`qibolab.Drag`) +- IIR (:class:`qibolab.Iir`) +- SNZ (:class:`qibolab.Snz`) +- eCap (:class:`qibolab.ECap`) +- Custom (:class:`qibolab.Custom`) -Each pulse is associated with a channel and a qubit. -Additionally, pulses are defined by a shape, represented by a subclass of :class:`qibolab.pulses.PulseShape`. -Qibolab offers a range of pre-defined pulse shapes: - -- Rectangular (:class:`qibolab.pulses.Rectangular`) -- Exponential (:class:`qibolab.pulses.Exponential`) -- Gaussian (:class:`qibolab.pulses.Gaussian`) -- Drag (:class:`qibolab.pulses.Drag`) -- IIR (:class:`qibolab.pulses.IIR`) -- SNZ (:class:`qibolab.pulses.SNZ`) -- eCap (:class:`qibolab.pulses.eCap`) -- Custom (:class:`qibolab.pulses.Custom`) - -To illustrate, here are some examples of single pulses using the Qibolab API: +To illustrate, here is an examples of how to instantiate a pulse using the Qibolab API: .. testcode:: python - from qibolab.pulses import Pulse, Rectangular + from qibolab import Pulse, Rectangular pulse = Pulse( - start=0, # Timing, always in nanoseconds (ns) - duration=40, # Pulse duration in ns - amplitude=0.5, # Amplitude relative to instrument range - frequency=1e8, # Frequency in Hz - relative_phase=0, # Phase in radians - shape=Rectangular(), - channel="channel", - type="qd", # Enum type: :class:`qibolab.pulses.PulseType` - qubit=0, + duration=40.0, # Pulse duration in ns + amplitude=0.5, # Amplitude normalized to [-1, 1] + relative_phase=0.0, # Phase in radians + envelope=Rectangular(), ) -In this way, we defined a rectangular drive pulse using the generic Pulse object. -Alternatively, you can achieve the same result using the dedicated :class:`qibolab.pulses.DrivePulse` object: - -.. testcode:: python - - from qibolab.pulses import DrivePulse, Rectangular - - pulse = DrivePulse( - start=0, # timing, in all qibolab, is expressed in ns - duration=40, - amplitude=0.5, # this amplitude is relative to the range of the instrument - frequency=1e8, # frequency are in Hz - relative_phase=0, # phases are in radians - shape=Rectangular(), - channel="channel", - qubit=0, - ) +Here, we defined a rectangular drive pulse using the generic Pulse object. Both the Pulses objects and the PulseShape object have useful plot functions and several different various helper methods. -To organize pulses into sequences, Qibolab provides the :class:`qibolab.pulses.PulseSequence` object. Here's an example of how you can create and manipulate a pulse sequence: +To organize pulses into sequences, Qibolab provides the :class:`qibolab.PulseSequence` object. Here's an example of how you can create and manipulate a pulse sequence: .. testcode:: python - from qibolab.pulses import PulseSequence + from qibolab import Pulse, PulseSequence, Rectangular - sequence = PulseSequence() - pulse1 = DrivePulse( - start=0, # timing, in all qibolab, is expressed in ns - duration=40, + pulse1 = Pulse( + duration=40, # timing, in all qibolab, is expressed in ns amplitude=0.5, # this amplitude is relative to the range of the instrument - frequency=1e8, # frequency are in Hz relative_phase=0, # phases are in radians - shape=Rectangular(), - channel="channel", - qubit=0, + envelope=Rectangular(), ) - pulse2 = DrivePulse( - start=0, # timing, in all qibolab, is expressed in ns - duration=40, + pulse2 = Pulse( + duration=40, # timing, in all qibolab, is expressed in ns amplitude=0.5, # this amplitude is relative to the range of the instrument - frequency=1e8, # frequency are in Hz relative_phase=0, # phases are in radians - shape=Rectangular(), - channel="channel", - qubit=0, + envelope=Rectangular(), ) - pulse3 = DrivePulse( - start=0, # timing, in all qibolab, is expressed in ns - duration=40, + pulse3 = Pulse( + duration=40, # timing, in all qibolab, is expressed in ns amplitude=0.5, # this amplitude is relative to the range of the instrument - frequency=1e8, # frequency are in Hz relative_phase=0, # phases are in radians - shape=Rectangular(), - channel="channel", - qubit=0, + envelope=Rectangular(), ) - pulse4 = DrivePulse( - start=0, # timing, in all qibolab, is expressed in ns - duration=40, + pulse4 = Pulse( + duration=40, # timing, in all qibolab, is expressed in ns amplitude=0.5, # this amplitude is relative to the range of the instrument - frequency=1e8, # frequency are in Hz relative_phase=0, # phases are in radians - shape=Rectangular(), - channel="channel", - qubit=0, + envelope=Rectangular(), + ) + sequence = PulseSequence( + [ + ("qubit/drive", pulse1), + ("qubit/drive", pulse2), + ("qubit/drive", pulse3), + ("qubit/drive", pulse4), + ], ) - sequence.add(pulse1) - sequence.add(pulse2) - sequence.add(pulse3) - sequence.add(pulse4) print(f"Total duration: {sequence.duration}") - sequence_ch1 = sequence.get_channel_pulses("channel1") # Selecting pulses on channel 1 - print(f"We have {sequence_ch1.count} pulses on channel 1.") .. testoutput:: python :hide: - Total duration: 40 - We have 0 pulses on channel 1. - -.. warning:: + Total duration: 160.0 - Pulses in PulseSequences are ordered automatically following the start time (and the channel if needed). Not by the definition order. When conducting experiments on quantum hardware, pulse sequences are vital. Assuming you have already initialized a platform, executing an experiment is as simple as: .. testcode:: python - result = platform.execute_pulse_sequence(sequence, options=options) + result = platform.execute([sequence]) Lastly, when conducting an experiment, it is not always required to define a pulse from scratch. Usual pulses, such as pi-pulses or measurements, are already defined in the platform runcard and can be easily initialized with platform methods. @@ -413,39 +275,23 @@ Typical experiments may include both pre-defined pulses and new ones: .. testcode:: python - from qibolab.pulses import Rectangular - - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(0)) - sequence.add( - DrivePulse( - start=0, - duration=10, - amplitude=0.5, - frequency=2500000000, - relative_phase=0, - shape=Rectangular(), - channel="0", - ) - ) - sequence.add(platform.create_MZ_pulse(0, start=0)) - - results = platform.execute_pulse_sequence(sequence, options=options) + from qibolab import Rectangular -.. note:: + natives = platform.natives.single_qubit[0] + sequence = natives.RX() | natives.MZ() - options is an :class:`qibolab.execution_parameters.ExecutionParameters` object, detailed in a separate section. + results = platform.execute([sequence]) Sweepers -------- -Sweeper objects, represented by the :class:`qibolab.sweeper.Sweeper` class, stand as a crucial component in experiments and calibration tasks within the Qibolab framework. +Sweeper objects, represented by the :class:`qibolab.Sweeper` class, stand as a crucial component in experiments and calibration tasks within the Qibolab framework. Consider a scenario where a resonator spectroscopy experiment is performed. This process involves a sequence of steps: 1. Define a pulse sequence. -2. Define a readout pulse with frequency A. +2. Define a readout pulse with frequency :math:`A`. 3. Execute the sequence. 4. Define a new readout pulse with frequency :math:`A + \epsilon`. 5. Execute the sequence again. @@ -457,9 +303,8 @@ In supported control devices, an efficient technique involves defining a "sweepe To address the inefficiency, Qibolab introduces the concept of Sweeper objects. -Sweeper objects in Qibolab are characterized by a :class:`qibolab.sweeper.Parameter`. This parameter, crucial to the sweeping process, can be one of several types: +Sweeper objects in Qibolab are characterized by a :class:`qibolab.Parameter`. This parameter, crucial to the sweeping process, can be one of several types: -- Frequency - Amplitude - Duration - Relative_phase @@ -467,99 +312,89 @@ Sweeper objects in Qibolab are characterized by a :class:`qibolab.sweeper.Parame -- -- Attenuation -- Gain -- Bias +- Frequency +- Offset -The first group includes parameters of the pulses, while the second group include parameters of a different type that, in qibolab, are linked to a qubit object. +The first group includes parameters of the pulses, while the second group includes parameters of channels. -To designate the qubit or pulse to which a sweeper is applied, you can utilize the ``pulses`` or ``qubits`` parameter within the Sweeper object. +To designate the pulse(s) or channel(s) to which a sweeper is applied, you can utilize the ``pulses`` or ``channels`` parameter within the Sweeper object. .. note:: - It is possible to simultaneously execute the same sweeper on different pulses or qubits. The ``pulses`` or ``qubits`` attribute is designed as a list, allowing for this flexibility. + It is possible to simultaneously execute the same sweeper on different pulses or channels. The ``pulses`` or ``channels`` attribute is designed as a list, allowing for this flexibility. To effectively specify the sweeping behavior, Qibolab provides the ``values`` attribute along with the ``type`` attribute. -The ``values`` attribute comprises an array of numerical values that define the sweeper's progression. To facilitate multi-qubit execution, these numbers can be interpreted in three ways: - -- Absolute Values: Represented by `qibolab.sweeper.PulseType.ABSOLUTE`, these values are used directly. -- Relative Values with Offset: Utilizing `qibolab.sweeper.PulseType.OFFSET`, these values are relative to a designated base value, corresponding to the pulse or qubit value. -- Relative Values with Factor: Employing `qibolab.sweeper.PulseType.FACTOR`, these values are scaled by a factor from the base value, akin to a multiplier. - -For offset and factor sweepers, the base value is determined by the respective pulse or qubit value. +The ``values`` attribute comprises an array of numerical values that define the sweeper's progression. Let's see some examples. Consider now a system with three qubits (qubit 0, qubit 1, qubit 2) with resonator frequency at 4 GHz, 5 GHz and 6 GHz. -A tipical resonator spectroscopy experiment could be defined with: +A typical resonator spectroscopy experiment could be defined with: .. testcode:: python import numpy as np - from qibolab.sweeper import Parameter, Sweeper, SweeperType + from qibolab import Parameter, Sweeper - sequence = PulseSequence() - sequence.add(platform.create_MZ_pulse(0, start=0)) # readout pulse for qubit 0 at 4 GHz - sequence.add(platform.create_MZ_pulse(1, start=0)) # readout pulse for qubit 1 at 5 GHz - sequence.add(platform.create_MZ_pulse(2, start=0)) # readout pulse for qubit 2 at 6 GHz + natives = platform.natives.single_qubit - sweeper = Sweeper( - parameter=Parameter.frequency, - values=np.arange(-200_000, +200_000, 1), # define an interval of swept values - pulses=[sequence[0], sequence[1], sequence[2]], - type=SweeperType.OFFSET, + sequence = ( + natives[0].MZ() # readout pulse for qubit 0 at 4 GHz + | natives[1].MZ() # readout pulse for qubit 1 at 5 GHz + | natives[2].MZ() # readout pulse for qubit 2 at 6 GHz ) - results = platform.sweep(sequence, options, sweeper) - -.. note:: + sweepers = [ + Sweeper( + parameter=Parameter.frequency, + values=platform.config(qubit.probe).frequency + + np.arange(-200_000, +200_000, 1), # define an interval of swept values + channels=[qubit.probe], + ) + for qubit in platform.qubits.values() + ] - options is an :class:`qibolab.execution_parameters.ExecutionParameters` object, detailed in a separate section. + results = platform.execute([sequence], [sweepers], **options) -In this way, we first define a sweeper with an interval of 400 MHz (-200 MHz --- 200 MHz), assigning it to all three readout pulses and setting is as an offset sweeper. The resulting probed frequency will then be: +In this way, we first define three parallel sweepers with an interval of 400 MHz (-200 MHz --- 200 MHz). The resulting probed frequency will then be: - for qubit 0: [3.8 GHz, 4.2 GHz] - for qubit 1: [4.8 GHz, 5.2 GHz] - for qubit 2: [5.8 GHz, 6.2 GHz] -If we had used the :class:`qibolab.sweeper.SweeperType` absolute, we would have probed for all qubits the same frequencies [-200 MHz, 200 MHz]. - -.. note:: - - The default :class:`qibolab.sweeper.SweeperType` is absolute! - -For factor sweepers, usually useful when dealing with amplitudes, the base value is multipled by the values set. - -It is possible to define and executes multiple sweepers at the same time. +It is possible to define and executes multiple sweepers at the same time, in a nested loop style. For example: .. testcode:: python - sequence = PulseSequence() - - sequence.add(platform.create_RX_pulse(0)) - sequence.add(platform.create_MZ_pulse(0, start=sequence[0].finish)) + qubit = platform.qubits[0] + natives = platform.natives.single_qubit[0] + rx_sequence = natives.RX() + sequence = rx_sequence | natives.MZ() + f0 = platform.config(qubit.drive).frequency sweeper_freq = Sweeper( parameter=Parameter.frequency, - values=np.arange(-100_000, +100_000, 10_000), - pulses=[sequence[0]], - type=SweeperType.OFFSET, + range=(f0 - 100_000, f0 + 100_000, 10_000), + channels=[qubit.drive], ) + rx_pulse = rx_sequence[0][1] sweeper_amp = Sweeper( parameter=Parameter.amplitude, - values=np.arange(0, 1.5, 0.1), - pulses=[sequence[0]], - type=SweeperType.FACTOR, + range=(0, 0.43, 0.3), + pulses=[rx_pulse], ) - results = platform.sweep(sequence, options, sweeper_freq, sweeper_amp) + results = platform.execute([sequence], [[sweeper_freq], [sweeper_amp]], **options) Let's say that the RX pulse has, from the runcard, a frequency of 4.5 GHz and an amplitude of 0.3, the parameter space probed will be: - amplitudes: [0, 0.03, 0.06, 0.09, 0.12, ..., 0.39, 0.42] - frequencies: [4.4999, 4.49991, 4.49992, ...., 4.50008, 4.50009] (GHz) +Sweepers given in the same list will be applied in parallel, in a Python ``zip`` style, +while different lists define nested loops, with the first list corresponding to the outer loop. + .. warning:: Different control devices may have different limitations on the sweepers. @@ -568,16 +403,16 @@ Let's say that the RX pulse has, from the runcard, a frequency of 4.5 GHz and an Execution Parameters -------------------- -In the course of several examples, you've encountered the ``options`` argument in function calls like: +In the course of several examples, you've encountered the ``**options`` argument in function calls like: .. testcode:: python - res = platform.execute_pulse_sequence(sequence, options=options) - res = platform.sweep(sequence, options=options) + res = platform.execute([sequence], **options) -Let's now delve into the details of the ``options`` parameter and understand its components. +Let's now delve into the details of the ``options`` and understand its parts. -The ``options`` parameter, represented by the :class:`qibolab.execution_parameters.ExecutionParameters` class, is a vital element for every hardware execution. It encompasses essential information that tailors the execution to specific requirements: +The ``options`` extra arguments, is a vital element for every hardware execution. +It encompasses essential information that tailors the execution to specific requirements: - ``nshots``: Specifies the number of experiment repetitions. - ``relaxation_time``: Introduces a wait time between repetitions, measured in nanoseconds (ns). @@ -587,13 +422,13 @@ The ``options`` parameter, represented by the :class:`qibolab.execution_paramete The first three parameters are straightforward in their purpose. However, let's take a closer look at the last two parameters. -Supported acquisition types, accessible via the :class:`qibolab.execution_parameters.AcquisitionType` enumeration, include: +Supported acquisition types, accessible via the :class:`qibolab.AcquisitionType` enumeration, include: - Discrimination: Distinguishes states based on acquired voltages. - Integration: Returns demodulated and integrated waveforms. - Raw: Offers demodulated, yet unintegrated waveforms. -Supported averaging modes, available through the :class:`qibolab.execution_parameters.AveragingMode` enumeration, consist of: +Supported averaging modes, available through the :class:`qibolab.AveragingMode` enumeration, consist of: - Cyclic: Provides averaged results, yielding a single IQ point per measurement. - Singleshot: Supplies non-averaged results. @@ -608,37 +443,24 @@ Supported averaging modes, available through the :class:`qibolab.execution_param Results ------- -Within the Qibolab API, a variety of result types are available, contingent upon the chosen acquisition options. These results can be broadly classified into three main categories, based on the AcquisitionType: - -- Integrated Results (:class:`qibolab.result.IntegratedResults`) -- Raw Waveform Results (:class:`qibolab.result.RawWaveformResults`) -- Sampled Results (:class:`qibolab.result.SampleResults`) - -Furthermore, depending on whether results are averaged or not, they can be presented in an averaged version (as seen in :class:`qibolab.results.AveragedIntegratedResults`). - -The result categories align as follows: +``platform.execute`` returns a dictionary, mapping the acquisition pulse id to the results of the corresponding measurements. +The results of each measurement are a numpy array with dimension that depends on the number of shots, acquisition type, +averaging mode and the number of swept points, if sweepers were used. -- AveragingMode: cyclic or sequential -> - - AcquisitionType: integration -> :class:`qibolab.results.AveragedIntegratedResults` - - AcquisitionType: raw -> :class:`qibolab.results.AveragedRawWaveformResults` - - AcquisitionType: discrimination -> :class:`qibolab.results.AveragedSampleResults` -- AveragingMode: singleshot -> - - AcquisitionType: integration -> :class:`qibolab.results.IntegratedResults` - - AcquisitionType: raw -> :class:`qibolab.results.RawWaveformResults` - - AcquisitionType: discrimination -> :class:`qibolab.results.SampleResults` - -Let's now delve into a typical use case for result objects within the qibolab framework: +For example in .. testcode:: python - drive_pulse_1 = platform.create_MZ_pulse(0, start=0) - measurement_pulse = platform.create_qubit_readout_pulse(0, start=0) + qubit = platform.qubits[0] + natives = platform.natives.single_qubit[0] + + ro_sequence = natives.MZ() + sequence = natives.RX() | ro_sequence - sequence = PulseSequence() - sequence.add(drive_pulse_1) - sequence.add(measurement_pulse) - options = ExecutionParameters( + ro_pulse = ro_sequence[0][1] + result = platform.execute( + [sequence], nshots=1000, relaxation_time=10, fast_reset=False, @@ -646,32 +468,28 @@ Let's now delve into a typical use case for result objects within the qibolab fr averaging_mode=AveragingMode.CYCLIC, ) - res = platform.execute_pulse_sequence(sequence, options=options) - -The ``res`` object will manifest as a dictionary, mapping the measurement pulse serial to its corresponding results. - -The values related to the results will be find in the ``voltages`` attribute for IntegratedResults and RawWaveformResults, while for SampleResults the values are in ``samples``. -While for execution of sequences the results represent single measurements, but what happens for sweepers? -the results will be upgraded: from values to arrays and from arrays to matrices. +``result`` will be a dictionary with a single key ``ro_pulse.id`` and an array of +two elements, the averaged I and Q components of the integrated signal. +If instead, ``(AcquisitionType.INTEGRATION, AveragingMode.SINGLESHOT)`` was used, the array would have shape ``(options["nshots"], 2)``, +while for ``(AcquisitionType.DISCRIMINATION, AveragingMode.SINGLESHOT)`` the shape would be ``(options["nshots"],)`` with values 0 or 1. -The shape of the values of an integreted acquisition with 2 sweepers will be: +The shape of the values of an integrated acquisition with two sweepers will be: .. testcode:: python + f0 = platform.config(qubit.drive).frequency sweeper1 = Sweeper( parameter=Parameter.frequency, - values=np.arange(-100_000, +100_000, 1), # define an interval of swept values - pulses=[sequence[0]], - type=SweeperType.OFFSET, + range=(f0 - 100_000, f0 + 100_000, 1), + channels=[qubit.drive], ) sweeper2 = Sweeper( parameter=Parameter.frequency, - values=np.arange(-200_000, +200_000, 1), # define an interval of swept values - pulses=[sequence[0]], - type=SweeperType.OFFSET, + range=(f0 - 200_000, f0 + 200_000, 1), + channels=[qubit.probe], ) - shape = (options.nshots, len(sweeper1.values), len(sweeper2.values)) + shape = (options["nshots"], len(sweeper1.values), len(sweeper2.values), 2) .. _main_doc_compiler: @@ -687,15 +505,15 @@ This procedure typically involves the following steps: The transpiler is responsible for steps 1 and 2, while the compiler for step 3 of the list above. To be executed in Qibolab, a circuit should be already transpiled. It possible to use the transpilers provided by Qibo to do it. For more information, please refer the `examples in the Qibo documentation `_. -On the other hand, the compilation process is taken care of automatically by the :class:`qibolab.backends.QibolabBackend`. +On the other hand, the compilation process is taken care of automatically by the :class:`qibolab.QibolabBackend`. -Once a circuit has been compiled, it is converted to a :class:`qibolab.pulses.PulseSequence` by the :class:`qibolab.compilers.compiler.Compiler`. +Once a circuit has been compiled, it is converted to a :class:`qibolab.PulseSequence` by the :class:`qibolab._core.compilers.compiler.Compiler`. This is a container of rules which define how each native gate can be translated to pulses. -A rule is a Python function that accepts a Qibo gate and a platform object and returns the :class:`qibolab.pulses.PulseSequence` implementing this gate and a dictionary with potential virtual-Z phases that need to be applied in later pulses. -Examples of rules can be found on :py:mod:`qibolab.compilers.default`, which defines the default rules used by Qibolab. +A rule is a Python function that accepts a Qibo gate and a platform object and returns the :class:`qibolab.PulseSequence` implementing this gate and a dictionary with potential virtual-Z phases that need to be applied in later pulses. +Examples of rules can be found on :py:mod:`qibolab._core.compilers.default`, which defines the default rules used by Qibolab. .. note:: - Rules return a :class:`qibolab.pulses.PulseSequence` for each gate, instead of a single pulse, because some gates such as the U3 or two-qubit gates, require more than one pulses to be implemented. + Rules return a :class:`qibolab.PulseSequence` for each gate, instead of a single pulse, because some gates such as the U3 or two-qubit gates, require more than one pulses to be implemented. .. _main_doc_native: @@ -703,16 +521,17 @@ Native ------ Each quantum platform supports a specific set of native gates, which are the quantum operations that have been calibrated. -If this set is universal any circuit can be transpiled and compiled to a pulse sequence which is then deployed in the given platform. +If this set is universal any circuit can be transpiled and compiled to a pulse sequence which can then be deployed in the given platform. -:py:mod:`qibolab.native` provides data containers for holding the pulse parameters required for implementing every native gate. -Every :class:`qibolab.qubits.Qubit` object contains a :class:`qibolab.native.SingleQubitNatives` object which holds the parameters of its native single-qubit gates, -while each :class:`qibolab.qubits.QubitPair` objects contains a :class:`qibolab.native.TwoQubitNatives` object which holds the parameters of the native two-qubit gates acting on the pair. +:py:mod:`qibolab._core.native` provides data containers for holding the pulse parameters required for implementing every native gate. +The :class:`qibolab.Platform` provides a natives property that returns the :class:`qibolab._core.native.SingleQubitNatives` +which holds the single qubit native gates for every qubit and :class:`qibolab._core.native.TwoQubitNatives` for the two-qubit native gates of every qubit pair. +Each native gate is represented by a :class:`qibolab.PulseSequence` which contains all the calibrated parameters. -Each native gate is represented by a :class:`qibolab.native.NativePulse` or :class:`qibolab.native.NativeSequence` which contain all the calibrated parameters and can be converted to an actual :class:`qibolab.pulses.PulseSequence` that is then executed in the platform. -Typical single-qubit native gates are the Pauli-X gate, implemented via a pi-pulse which is calibrated using Rabi oscillations and the measurement gate, implemented via a pulse sent in the readout line followed by an acquisition. -For a universal set of single-qubit gates, the RX90 (pi/2-pulse) gate is required, which is implemented by halving the amplitude of the calibrated pi-pulse. -U3, the most general single-qubit gate can be implemented using two RX90 pi-pulses and some virtual Z-phases which are included in the phase of later pulses. +Typical single-qubit native gates are the Pauli-X gate, implemented via a pi-pulse which is calibrated using Rabi oscillations and the measurement gate, +implemented via a pulse sent in the readout line followed by an acquisition. +For a universal set of single-qubit gates, the RX90 (pi/2-pulse) gate is required, +which is implemented by halving the amplitude of the calibrated pi-pulse. Typical two-qubit native gates are the CZ and iSWAP, with their availability being platform dependent. These are implemented with a sequence of flux pulses, potentially to multiple qubits, and virtual Z-phases. @@ -723,35 +542,25 @@ Depending on the platform and the quantum chip architecture, two-qubit gates may Instruments ----------- -One the key features of qibolab is its support for multiple different instruments. -A list of all the supported instruments follows: +One the key features of Qibolab is its support for multiple different electronics. +A list of all the supported electronics follows: -Controllers (subclasses of :class:`qibolab.instruments.abstract.Controller`): - - Dummy Instrument: :class:`qibolab.instruments.dummy.DummyInstrument` - - PulseSimulator Instrument: :class:`qibolab.instruments.emulator.pulse_simulator.PulseSimulator` +Controllers (subclasses of :class:`qibolab._core.instruments.abstract.Controller`): + - Dummy Instrument: :class:`qibolab.instruments.DummyInstrument` - Zurich Instruments: :class:`qibolab.instruments.zhinst.Zurich` - - Quantum Machines: :class:`qibolab.instruments.qm.controller.QMController` - - Qblox: :class:`qibolab.instruments.qblox.controller.QbloxCluster` - - Xilinx RFSoCs: :class:`qibolab.instruments.rfsoc.driver.RFSoC` + - Quantum Machines: :class:`qibolab.instruments.qm.QMController` -Other Instruments (subclasses of :class:`qibolab.instruments.abstract.Instrument`): - - Erasynth++: :class:`qibolab.instruments.erasynth.ERA` +Other Instruments (subclasses of :class:`qibolab._core.instruments.abstract.Instrument`): + - Erasynth++: :class:`qibolab.instruments.era.ERASynth` - RohseSchwarz SGS100A: :class:`qibolab.instruments.rohde_schwarz.SGS100A` -Instruments all implement a set of methods: - -- connect -- setup -- disconnect - -While the controllers, the main instruments in a typical setup, add other two methods: - -- execute_pulse_sequence -- sweep +All instruments inherit the :class:`qibolab._core.instruments.abstract.Instrument` and implement methods for connecting and disconnecting. +:class:`qibolab._core.instruments.abstract.Controller` is a special case of instruments that provides the :class:`qibolab._core.instruments.abstract.execute` +method that deploys sequences on hardware. Some more detail on the interal functionalities of instruments is given in :doc:`/tutorials/instrument` -The most important instruments are the controller, the following is a table of the current supported (or not supported) features, dev stands for `under development`: +The following is a table of the currently supported or not supported features (dev stands for `under development`): .. csv-table:: Supported features :header: "Feature", "RFSoC", "Qblox", "QM", "ZH" @@ -766,7 +575,6 @@ The most important instruments are the controller, the following is a table of t "RTS frequency", "yes","yes","yes","yes" "RTS amplitude", "yes","yes","yes","yes" "RTS duration", "yes","yes","yes","yes" - "RTS start", "yes","yes","yes","yes" "RTS relative phase", "yes","yes","yes","yes" "RTS 2D any combination", "yes","yes","yes","yes" "Sequence unrolling", "dev","dev","dev","dev" @@ -794,56 +602,3 @@ Quantum Machines Tested with a cluster of nine `OPX+ `_ controllers, using QOP213 and QOP220. Qibolab is communicating with the instruments using the `QUA `_ language, via the ``qm-qua`` and ``qualang-tools`` Python libraries. - -Qblox -^^^^^ - -Supports the following Instruments: - -- Cluster -- Cluster QRM-RF -- Cluster QCM-RF -- Cluster QCM - -Compatible with qblox-instruments driver 0.9.0 (28/2/2023). - -RFSoCs -^^^^^^ - -Compatible and tested with: - -- Xilinx RFSoC4x2 -- Xilinx ZCU111 -- Xilinx ZCU216 - -Technically compatible with any board running ``qibosoq``. - -Pulse Simulator -^^^^^^^^^^^^^^^ - -The simulation controller that is used exclusively by the emulator. It serves primarily to implement the device model using the selected quantum dynamics simulation library (engine), as well as translate and communicate between objects from ``qibolab`` and the selected engine. - -Available simulation engines: - -- ``qutip`` - -Currently ``AcquisitionType.DISCRIMINATION`` and ``AcquisitionType.INTEGRATION`` are supported. Note that for ``AcquistionType.INTEGRATION`` samples are projected onto the I component. - -Currently does not support: - -- Couplers -- Flux pulses - -.. admonition:: Qibocal compatibility - - The following protocols are currently compatible with the emulator platform (``default_q0``): - - - `1D Rabi experiments` - - `Ramsey experiments` - - `T1` - - `T2` - - `T2 echo` - - `Flipping experiments` - - `Single Qubit State Tomography` - - `AllXY` - - `Standard RB` diff --git a/doc/source/tutorials/calibration.rst b/doc/source/tutorials/calibration.rst index 2da46cd398..e180b5ae15 100644 --- a/doc/source/tutorials/calibration.rst +++ b/doc/source/tutorials/calibration.rst @@ -7,8 +7,7 @@ characterize a qubit. .. note:: This is just for demonstration purposes! In the `Qibo `_ framework these experiments are already coded and available in the `Qibocal API `_. -Let's consider a platform called `single_qubit` with, as expected, a single -qubit. +Let's consider a platform called `single_qubit` with, as expected, a single qubit. Resonator spectroscopy ---------------------- @@ -22,59 +21,53 @@ as follows: 3. We plot the acquired amplitudes, identifying the peak/deep value as the resonator frequency. -We start by initializing the platform, that reads the information written in the -respective runcard, a sequence composed of only a measurement and a sweeper -around the pre-defined frequency. +We start by initializing the platform, creating a sequence composed of only a measurement +and a sweeper around the pre-defined frequency. +We then define the execution parameters and launch the experiment. +In few seconds, the experiment will be finished and we can proceed to plot it. +This is done in the following script: .. testcode:: python import numpy as np - from qibolab import create_platform - from qibolab.pulses import PulseSequence - from qibolab.sweeper import Sweeper, SweeperType, Parameter - from qibolab.execution_parameters import ( - ExecutionParameters, - AveragingMode, + import matplotlib.pyplot as plt + from qibolab import ( AcquisitionType, + AveragingMode, + Parameter, + PulseSequence, + Sweeper, + create_platform, ) # allocate platform platform = create_platform("dummy") - # create pulse sequence and add pulse - sequence = PulseSequence() - readout_pulse = platform.create_MZ_pulse(qubit=0, start=0) - sequence.add(readout_pulse) + qubit = platform.qubits[0] + natives = platform.natives.single_qubit[0] + sequence = natives.MZ.create_sequence() # allocate frequency sweeper + f0 = platform.config(qubit.probe).frequency sweeper = Sweeper( parameter=Parameter.frequency, - values=np.arange(-2e8, +2e8, 1e6), - pulses=[readout_pulse], - type=SweeperType.OFFSET, + range=(f0 - 2e8, f0 + 2e8, 1e6), + channels=[qubit.probe], ) -We then define the execution parameters and launch the experiment. - -.. testcode:: python - - options = ExecutionParameters( + results = platform.execute( + [sequence], + [[sweeper]], nshots=1000, relaxation_time=50, averaging_mode=AveragingMode.CYCLIC, acquisition_type=AcquisitionType.INTEGRATION, ) - results = platform.sweep(sequence, options, sweeper) - -In few seconds, the experiment will be finished and we can proceed to plot it. - -.. testcode:: python - - import matplotlib.pyplot as plt - - amplitudes = results[readout_pulse.serial].magnitude - frequencies = np.arange(-2e8, +2e8, 1e6) + readout_pulse.frequency + acq = sequence.acquisitions[0][1] + signal = results[acq.id] + amplitudes = np.abs(signal[..., 0] + 1j * signal[..., 1]) + frequencies = sweeper.values plt.title("Resonator Spectroscopy") plt.xlabel("Frequencies [Hz]") @@ -98,72 +91,68 @@ typical qubit spectroscopy experiment is as follows: the qubit parameters are not known, this is typically a very long pulse (2 microseconds) at low amplitude. 2. A measurement, tuned with resonator spectroscopy, is performed. -3. We repeat point 1 for different frequencies. +3. We repeat point 1 for different frequencies of the drive pulse. 4. We plot the acquired amplitudes, identifying the deep/peak value as the qubit frequency. -So, mainly, the difference that this experiment introduces is a slightly more +The main difference introduced by this experiment is a slightly more complex pulse sequence. Therefore with start with that: .. testcode:: python import numpy as np import matplotlib.pyplot as plt - from qibolab import create_platform - from qibolab.pulses import PulseSequence - from qibolab.sweeper import Sweeper, SweeperType, Parameter - from qibolab.execution_parameters import ( - ExecutionParameters, - AveragingMode, + from qibolab import ( AcquisitionType, + AveragingMode, + Parameter, + PulseSequence, + Sweeper, + create_platform, ) # allocate platform platform = create_platform("dummy") + qubit = platform.qubits[0] + natives = platform.natives.single_qubit[0] + # create pulse sequence and add pulses - sequence = PulseSequence() - drive_pulse = platform.create_RX_pulse(qubit=0, start=0) - drive_pulse.duration = 2000 - drive_pulse.amplitude = 0.01 - readout_pulse = platform.create_MZ_pulse(qubit=0, start=drive_pulse.finish) - sequence.add(drive_pulse) - sequence.add(readout_pulse) + sequence = natives.RX() | natives.MZ() # allocate frequency sweeper + f0 = platform.config(qubit.drive).frequency sweeper = Sweeper( parameter=Parameter.frequency, - values=np.arange(-2e8, +2e8, 1e6), - pulses=[drive_pulse], - type=SweeperType.OFFSET, + range=(f0 - 2e8, f0 + 2e8, 1e6), + channels=[qubit.drive], ) -Note that the drive pulse has been changed to match the characteristics required -for the experiment. - -We can now proceed to launch on hardware: - -.. testcode:: python - - options = ExecutionParameters( + results = platform.execute( + [sequence], + [[sweeper]], nshots=1000, relaxation_time=50, averaging_mode=AveragingMode.CYCLIC, acquisition_type=AcquisitionType.INTEGRATION, ) - results = platform.sweep(sequence, options, sweeper) + acq = sequence.acquisitions[0][1] + signal = results[acq.id] + amplitudes = np.abs(signal[..., 0] + 1j * signal[..., 1]) + frequencies = sweeper.values - amplitudes = results[readout_pulse.serial].magnitude - frequencies = np.arange(-2e8, +2e8, 1e6) + drive_pulse.frequency - - plt.title("Resonator Spectroscopy") + plt.title("Qubit Spectroscopy") plt.xlabel("Frequencies [Hz]") plt.ylabel("Amplitudes [a.u.]") plt.plot(frequencies, amplitudes) plt.show() + +Note that the drive pulse has been changed to match the characteristics required +for the experiment. + .. image:: qubit_spectroscopy_light.svg :class: only-light .. image:: qubit_spectroscopy_dark.svg @@ -204,51 +193,48 @@ and its impact on qubit states in the IQ plane. import numpy as np import matplotlib.pyplot as plt - from qibolab import create_platform - from qibolab.pulses import PulseSequence - from qibolab.sweeper import Sweeper, SweeperType, Parameter - from qibolab.execution_parameters import ( - ExecutionParameters, - AveragingMode, + from qibolab import ( AcquisitionType, + AveragingMode, + Parameter, + Sweeper, + create_platform, ) # allocate platform platform = create_platform("dummy") - # create pulse sequence 1 and add pulses - one_sequence = PulseSequence() - drive_pulse = platform.create_RX_pulse(qubit=0, start=0) - readout_pulse1 = platform.create_MZ_pulse(qubit=0, start=drive_pulse.finish) - one_sequence.add(drive_pulse) - one_sequence.add(readout_pulse1) + qubit = platform.qubits[0] + natives = platform.natives.single_qubit[0] - # create pulse sequence 2 and add pulses - zero_sequence = PulseSequence() - readout_pulse2 = platform.create_MZ_pulse(qubit=0, start=0) - zero_sequence.add(readout_pulse2) + # create pulse sequence 1 + zero_sequence = natives.MZ() - options = ExecutionParameters( + # create pulse sequence 2 + one_sequence = natives.RX() | natives.MZ() + + results = platform.execute( + [zero_sequence, one_sequence], nshots=1000, relaxation_time=50_000, averaging_mode=AveragingMode.SINGLESHOT, acquisition_type=AcquisitionType.INTEGRATION, ) - results_one = platform.execute_pulse_sequence(one_sequence, options) - results_zero = platform.execute_pulse_sequence(zero_sequence, options) + acq0 = zero_sequence.acquisitions[0][1] + acq1 = one_sequence.acquisitions[0][1] plt.title("Single shot classification") plt.xlabel("I [a.u.]") plt.ylabel("Q [a.u.]") plt.scatter( - results_one[readout_pulse1.serial].voltage_i, - results_one[readout_pulse1.serial].voltage_q, + results[acq1.id][..., 0], + results[acq1.id][..., 1], label="One state", ) plt.scatter( - results_zero[readout_pulse2.serial].voltage_i, - results_zero[readout_pulse2.serial].voltage_q, + results[acq0.id][..., 0], + results[acq0.id][..., 1], label="Zero state", ) plt.show() @@ -257,3 +243,7 @@ and its impact on qubit states in the IQ plane. :class: only-light .. image:: classification_dark.svg :class: only-dark + +Note that in this experiment we passed both sequences in the same ``platform.execute`` command. +In this case the sequences will be unrolled to a single sequence automatically, which is +then deployed with a single communication with the instruments, to reduce communication bottleneck. diff --git a/doc/source/tutorials/circuits.rst b/doc/source/tutorials/circuits.rst index 7982e86965..7e758aeac3 100644 --- a/doc/source/tutorials/circuits.rst +++ b/doc/source/tutorials/circuits.rst @@ -40,8 +40,8 @@ circuits definition that we leave to the `Qibo simulation = simulation_result.probabilities(qubits=(0,)) -In this snippet, we first define a single-qubit circuit containing a single Hadamard gate and a measurement. -We then proceed to define the qibo backend as ``qibolab`` using the ``tii1q_b1`` platform. +In this snippet, we first define a single-qubit circuit containing a single GPI2 gate and a measurement. +We then proceed to define the qibo backend as ``qibolab`` using the ``dummy`` platform. Finally, we change the backend to ``numpy``, a simulation one, to compare the results with ideality. After executing the script we can print our results that will appear more or less as: @@ -92,7 +92,7 @@ results: circuit.set_parameters([angle]) # execute circuit - result = circuit.execute(nshots=4000) + result = circuit(nshots=4000) freq = result.frequencies() p0 = freq['0'] / 4000 if '0' in freq else 0 p1 = freq['1'] / 4000 if '1' in freq else 0 @@ -129,8 +129,8 @@ Returns the following plot: :class: only-dark .. note:: - Executing circuits using the Qibolab backend results to automatic application of the compilation pipeline (:ref:`main_doc_compiler`) which convert the circuit to a pulse sequence that is executed by the given platform. - It is possible to modify these pipelines following the instructions in the :ref:`tutorials_compiler` example. + Executing circuits using the Qibolab backend results to automatic application of the compilation pipeline (:ref:`main_doc_compiler`) + which converts the circuit to a pulse sequence that is executed by the given platform. QASM Execution -------------- @@ -150,11 +150,11 @@ Qibolab also supports the execution of circuits starting from a QASM string. The measure q[0] -> a[0]; measure q[2] -> a[1];""" -can be executed by passing it together with the platform name to the :func:`qibolab.execute_qasm` function: +can be executed by passing it together with the platform name to the :func:`qibolab._core.backends.execute_qasm` function: .. testcode:: - from qibolab import execute_qasm + from qibolab._core.backends import execute_qasm result = execute_qasm(circuit, platform="dummy") diff --git a/doc/source/tutorials/compiler.rst b/doc/source/tutorials/compiler.rst deleted file mode 100644 index a445e8e7f1..0000000000 --- a/doc/source/tutorials/compiler.rst +++ /dev/null @@ -1,104 +0,0 @@ -.. _tutorials_compiler: - -How to modify the default circuit compilation -============================================= - -A Qibolab platform can execute pulse sequences. -As shown in :ref:`tutorials_circuits`, Qibo circuits can be executed by invoking the :class:`qibolab.backends.QibolabBackend`, which is the object integrating Qibolab to Qibo. -When a Qibo circuit is executed, the backend will automatically compile it to a pulse sequence, which will be sent to the platform for execution. -The default compiler outlined in the :ref:`main_doc_compiler` section will be used in this process. -In this tutorial we will demonstrate how the user can modify this process for custom applications. - -The ``compiler`` object used when executing a circuit are attributes of :class:`qibolab.backends.QibolabBackend`. -Creating an instance of the backend provides access to these objects: - -.. testcode:: python - - from qibolab.backends import QibolabBackend - - backend = QibolabBackend(platform="dummy") - - print(type(backend.compiler)) - -.. testoutput:: python - :hide: - - - -The transpiler is responsible for transforming any circuit to one that respects -the chip connectivity and native gates. The compiler then transforms this circuit -to the equivalent pulse sequence. Note that there is no transpiler in Qibolab, therefore -the backend can only execute circuits that contain native gates by default. -The user can modify the compilation process by changing the ``compiler`` attributes of -the ``QibolabBackend``. - -In this example, we executed circuits using the backend ``backend.execute_circuit`` method, -unlike the previous example (:ref:`tutorials_circuits`) where circuits were executed directly using ``circuit(nshots=1000)``. -It is possible to perform compiler manipulation in both approaches. -When using ``circuit(nshots=1000)``, Qibo is automatically initializing a ``GlobalBackend()`` singleton that is used to execute the circuit. -Therefore the previous manipulations can be done as follows: - -.. testcode:: python - - import qibo - from qibo import gates - from qibo.models import Circuit - from qibo.backends import GlobalBackend - - # define circuit - circuit = Circuit(1) - circuit.add(gates.U3(0, 0.1, 0.2, 0.3)) - circuit.add(gates.M(0)) - - # set backend to qibolab - qibo.set_backend("qibolab", platform="dummy") - - # execute circuit - result = circuit(nshots=1000) - - -Defining custom compiler rules -============================== - -The compiler can be modified by adding new compilation rules or changing existing ones. -As explained in :ref:`main_doc_compiler` section, a rule is a function that accepts a Qibo gate and a Qibolab platform -and returns the pulse sequence implementing this gate. - -The following example shows how to modify the compiler in order to execute a circuit containing a Pauli X gate using a single pi-pulse: - -.. testcode:: python - - from qibo import gates - from qibo.models import Circuit - from qibolab.backends import QibolabBackend - from qibolab.pulses import PulseSequence - - # define the circuit - circuit = Circuit(1) - circuit.add(gates.X(0)) - circuit.add(gates.M(0)) - - - # define a compiler rule that translates X to the pi-pulse - def x_rule(gate, platform): - """X gate applied with a single pi-pulse.""" - qubit = gate.target_qubits[0] - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(qubit, start=0)) - return sequence, {} - - - # the empty dictionary is needed because the X gate does not require any virtual Z-phases - - backend = QibolabBackend(platform="dummy") - # register the new X rule in the compiler - backend.compiler[gates.X] = x_rule - - # execute the circuit - result = backend.execute_circuit(circuit, nshots=1000) - -The default set of compiler rules is defined in :py:mod:`qibolab.compilers.default`. - -.. note:: - If the compiler receives a circuit that contains a gate for which it has no rule, an error will be raised. - This means that the native gate set that the transpiler uses, should be compatible with the available compiler rules. diff --git a/doc/source/tutorials/index.rst b/doc/source/tutorials/index.rst index c904d19324..c3e11046d8 100644 --- a/doc/source/tutorials/index.rst +++ b/doc/source/tutorials/index.rst @@ -12,5 +12,4 @@ In this section we present code examples from basic to advanced features impleme pulses circuits calibration - compiler instrument diff --git a/doc/source/tutorials/instrument.rst b/doc/source/tutorials/instrument.rst index db30ce6416..9c5a43374f 100644 --- a/doc/source/tutorials/instrument.rst +++ b/doc/source/tutorials/instrument.rst @@ -1,15 +1,12 @@ How to add a new instrument in Qibolab? ======================================= -Currently, Qibolab support various instruments: -as **controller**: +Currently, Qibolab supports various **controller** instruments: * Quantum Machines -* QBlox * Zurich instruments -* Xilinx RFSoCs -and as **local oscillators**: +and the following **local oscillators**: * Rhode&Schwartz * Erasynth++ @@ -17,22 +14,21 @@ and as **local oscillators**: If you need to add a new driver, to support a new instruments in your setup, we encourage you to have a look at ``qibolab.instruments`` for complete examples. In this section, anyway, a basic example will be given. -For clarity, we divide the instruments in two different groups: the **controllers** and the standard **instruments**, where the controller is an instrument that can execute pulse sequences. -For example, a local oscillator is just an instrument, while QBlox is a controller. +For clarity, we divide the instruments in two different groups: the **controllers** and the standard **instruments**, +where the controller is an instrument that can execute pulse sequences. +For example, a local oscillator is just an instrument, while Quantum Machines is a controller. Add an instrument ----------------- -The base of an instrument is :class:`qibolab.instruments.abstract.Instrument`. +The base of an instrument is :class:`qibolab._core.instruments.abstract.Instrument`, +which is a pydantic ``Model``. To accomodate different kind of instruments, a flexible interface is implemented -with four abstract methods that are required to be implemented in the child -instrument: - -* ``connect()`` -* ``setup()`` -* ``start()`` -* ``stop()`` -* ``disconnect()`` +with two abstract methods (``connect()`` and ``disconnect()``) that are required +to be implemented in the child instrument. +Optionally, a ``setup()`` method can also be implemented to upload settings, such +as local oscillator frequency or power, to the instrument after connection. +If ``setup()`` is not implemented it will be an empty function. In the execution of an experiment these functions are called sequentially, so first a connection is established, the instrument is set up with the required @@ -40,168 +36,99 @@ parameters, the instrument starts operating, then stops and gets disconnected. Note that it's perfectly fine to leave the majority of these functions empty if not needed. -Moreover, it's important call the ``super.__init__(self, name, address)`` since -it initialize the folders eventually required to store temporary files. - -A good example of a instrument driver is the -:class:`qibolab.instruments.rohde_schwarz.SGS100A` driver. - Here, let's write a basic example of instrument whose job is to deliver a fixed bias for the duration of the experiment: .. code-block:: python - from qibolab.instruments.abstract import Instrument + from typing import Optional + + # let's suppose that there is already available a base driver for connection + # and control of the device, provided by the following library + from proprietary_instruments import BiaserType, biaser_driver - # let's suppose that there is already avaiable a base driver for connection - # and control of the device - from proprietary_instruments import biaser_driver + from qibolab.instruments.abstract import Instrument class Biaser(Instrument): """An instrument that delivers constand biases.""" + name: str + address: str + min_value: float = -1.0 + max_value: float = 1.0 + bias: float = 0.0 + device: Optional[BiaserType] = None - def __init__(self, name, address, min_value=-1, max_value=1): - super().__init__(name, address) - self.max_value: float = ( - max_value # attribute example, maximum value of voltage allowed - ) - self.min_value: float = ( - min_value # attribute example, minimum value of voltage allowed - ) - self.bias: float = 0 - - self.device = biaser_driver(address) def connect(self): """Check if a connection is avaiable.""" - if not self.device.is_connected: - raise ConnectionError("Biaser not connected") + if self.device is None: + self.device = biaser_driver(self.address) + self.device.on(self.bias) def disconnect(self): - """Method not used.""" + self.device.off(self.bias) + self.device.disconnect() def setup(self): """Set biaser parameters.""" self.device.set_range(self.min_value, self.max_value) - def start(self): - """Start biasing.""" - self.device.on(bias) - - def stop(self): - """Stop biasing.""" - self.device.off(bias) - Add a controller ---------------- -The controller is an instrument that has some additional methods, its abstract -implementation can be found in :class:`qibolab.instruments.abstract.Controller`. - -The additional methods required are: - -* ``play()`` -* ``play_sequences()`` -* ``sweep()`` - -The simplest real example is the RFSoCs driver in -:class:`qibolab.instruments.rfsoc.driver.RFSoC`, but still the code is much more -complex than the local oscillator ones. +The controller is an instrument that has the additional method ``play``, +which allows it to execute arbitrary pulse sequences and perform sweeps. +Its abstract implementation can be found in :class:`qibolab._core.instruments.abstract.Controller`. Let's see a minimal example: .. code-block:: python - from qibolab.instruments.abstract import Controller - from proprietary_instruments import controller_driver + from typing import Optional + from proprietary_instruments import ControllerType, controller_driver - class MyController(Controller): - def __init__(self, name, address): - self.device = controller_driver(address) - super().__init__(name, address) + from qibolab._core.components import Config + from qibolab._core.execution_parameters import ExecutionParameters + from qibolab._core.identifier import Result + from qibolab._core.sequence import PulseSequence + from qibolab._core.sweeper import ParallelSweepers + from qibolab._core.instruments.abstract import Controller - def connect(self): - """Empty method to comply with Instrument interface.""" - def start(self): - """Empty method to comply with Instrument interface.""" + class MyController(Controller): - def stop(self): - """Empty method to comply with Instrument interface.""" + def connect(self): + if self.device is None: + self.device = controller_driver(address) def disconnect(self): - """Empty method to comply with Instrument interface.""" - - def setup(self): - """Empty method to comply with Instrument interface.""" + self.device.disconnect() def play( - self, - qubits: dict[int, Qubit], - sequence: PulseSequence, - execution_parameters: ExecutionParameters, - ) -> dict[str, Union[IntegratedResults, SampleResults]]: + self, + configs: dict[str, Config], + sequences: list[PulseSequence], + options: ExecutionParameters, + sweepers: list[ParallelSweepers], + ) -> dict[int, Result]: """Executes a PulseSequence.""" + if len(sweepers) > 0: + raise NotImplementedError("MyController does not support sweeps.") - # usually, some modification on the qubit objects, sequences or - # parameters is needed so that the qibolab interface comply with the one - # of the device here these are equal - results = self.device.run_experiment(qubits, sequence, execution_parameters) + if len(sequences) == 0: + return {} + elif len(sequences) == 1: + sequence = sequences[0] + else: + sequence, _ = unroll_sequences(sequences, options.relaxation_time) - # also the results are, in qibolab, specific objects that need some kind - # of conversion. Refer to the results section in the documentation. - return results - - def sweep( - self, - qubits: dict[int, Qubit], - sequence: PulseSequence, - execution_parameters: ExecutionParameters, - *sweepers: Sweeper, - ) -> dict[str, Union[IntegratedResults, SampleResults]]: - # usually, some modification on the qubit objects, sequences or - # parameters is needed so that the qibolab interface comply with the one - # of the device here these are equal - results = self.device.run_scan(qubits, sequence, sweepers, execution_parameters) + # usually, some modification on the sequence, channel configs, or + # parameters is needed so that the qibolab interface comply with the + # interface of the device. Here these are assumed to be equal for simplicity. + results = self.device.run_experiment(qubits, sequence, options) # also the results are, in qibolab, specific objects that need some kind # of conversion. Refer to the results section in the documentation. return results - - def play_sequences( - self, - qubits: dict[int, Qubit], - sequences: List[PulseSequence], - execution_parameters: ExecutionParameters, - ) -> dict[str, Union[IntegratedResults, SampleResults]]: - """This method is used for sequence unrolling sweeps. Here not implemented.""" - raise NotImplementedError - -As we saw in :doc:`lab`, to instantiate a platform at some point you have to -write something like this: - -.. testcode:: python - - from qibolab.channels import Channel, ChannelMap - from qibolab.instruments.dummy import DummyInstrument - - instrument = DummyInstrument("my_instrument", "0.0.0.0:0") - channels = ChannelMap() - channels |= Channel("ch1out", port=instrument.ports("o1")) - - -The interesting part of this section is the ``port`` parameter that works as an -attribute of the controller. A :class:`qibolab.instruments.port.Port` object -describes the physical connections that a device may have. A Controller has, by -default, ports characterized just by ``port_name`` (see also -:class:`qibolab.instruments.abstract.Controller`), but different devices may -need to add attributes and methods to the ports. This can be done by defining in -the new controller a new port type. See, for example, the already implemented -ports: - -* :class:`qibolab.instruments.rfsoc.driver.RFSoCPort` -* :class:`qibolab.instruments.qm.ports.QMPort` -* :class:`qibolab.instruments.zhinst.ZhPort` -* :class:`qibolab.instruments.qblox.port` diff --git a/doc/source/tutorials/lab.rst b/doc/source/tutorials/lab.rst index ffb52ad53d..f79a2358da 100644 --- a/doc/source/tutorials/lab.rst +++ b/doc/source/tutorials/lab.rst @@ -4,233 +4,47 @@ How to connect Qibolab to your lab? In this section we will show how to let Qibolab communicate with your lab's instruments and run an experiment. -The main required object, in this case, is the `Platform`. A Platform is defined -as a QPU (quantum processing unit with one or more qubits) controlled by one ore -more instruments. +The main required object, in this case, is the :class:`qibolab.Platform`. +A Platform is defined as a QPU (quantum processing unit with one or more qubits) +controlled by one ore more instruments. How to define a platform for a self-hosted QPU? ----------------------------------------------- -The :class:`qibolab.platform.Platform` object holds all the information required -to execute programs, and in particular :class:`qibolab.pulses.PulseSequence` in +The :class:`qibolab.Platform` object holds all the information required +to execute programs, and in particular :class:`qibolab.PulseSequence` in a real QPU. It is comprised by different objects that contain information about -the qubit characterization and connectivity, the native gates and the lab's -instrumentation. +the native gates and the lab's instrumentation. -The following cell shows how to define a single qubit platform from scratch, -using different Qibolab primitives. +This is permanently stored as its constructing function, ``create()``, defined in a +source file, but whose data could be stored in a package-defined format, for which +loading (and even dumping) methods are provided. +The details of this process are explained in the following sections. -.. testcode:: python - - from qibolab import Platform - from qibolab.qubits import Qubit - from qibolab.pulses import PulseType - from qibolab.channels import ChannelMap, Channel - from qibolab.native import NativePulse, SingleQubitNatives - from qibolab.instruments.dummy import DummyInstrument - - - def create(): - # Create a controller instrument - instrument = DummyInstrument("my_instrument", "0.0.0.0:0") - - # Create channel objects and assign to them the controller ports - channels = ChannelMap() - channels |= Channel("ch1out", port=instrument["o1"]) - channels |= Channel("ch2", port=instrument["o2"]) - channels |= Channel("ch1in", port=instrument["i1"]) - - # create the qubit object - qubit = Qubit(0) - - # assign native gates to the qubit - qubit.native_gates = SingleQubitNatives( - RX=NativePulse( - name="RX", - duration=40, - amplitude=0.05, - shape="Gaussian(5)", - pulse_type=PulseType.DRIVE, - qubit=qubit, - frequency=int(4.5e9), - ), - MZ=NativePulse( - name="MZ", - duration=1000, - amplitude=0.005, - shape="Rectangular()", - pulse_type=PulseType.READOUT, - qubit=qubit, - frequency=int(7e9), - ), - ) - - # assign channels to the qubit - qubit.readout = channels["ch1out"] - qubit.feedback = channels["ch1in"] - qubit.drive = channels["ch2"] - - # create dictionaries of the different objects - qubits = {qubit.name: qubit} - pairs = {} # empty as for single qubit we have no qubit pairs - instruments = {instrument.name: instrument} - - # allocate and return Platform object - return Platform("my_platform", qubits, pairs, instruments, resonator_type="3D") - - -This code creates a platform with a single qubit that is controlled by the -:class:`qibolab.instruments.dummy.DummyInstrument`. In real applications, if -Qibolab provides drivers for the instruments in the lab, these can be directly -used in place of the ``DummyInstrument`` above, otherwise new drivers need to be -coded following the abstract :class:`qibolab.instruments.abstract.Instrument` -interface. - -Furthermore, above we defined three channels that connect the qubit to the -control instrument and we assigned two native gates to the qubit. In this -example we neglected or characterization parameters associated to the qubit. -These can be passed when defining the :class:`qibolab.qubits.Qubit` objects. +.. note:: -When the QPU contains more than one qubit, some of the qubits are connected so -that two-qubit gates can be applied. For such connected pairs of qubits one -needs to additionally define :class:`qibolab.qubits.QubitPair` objects, which -hold the parameters of the two-qubit gates. + The main distinction between the content of the Python source file and the parameters + stored as data is based on the possibility to automatically read and consume these + parameters, and possibly even update them in a calibration process. -.. testcode:: python + More parameters may be introduced, and occasionally some platforms are defining them + in the source, in a first stage. - from qibolab.qubits import Qubit, QubitPair - from qibolab.pulses import PulseType - from qibolab.native import ( - NativePulse, - NativeSequence, - SingleQubitNatives, - TwoQubitNatives, - ) - - # create the qubit objects - qubit0 = Qubit(0) - qubit1 = Qubit(1) - - # assign single-qubit native gates to each qubit - qubit0.native_gates = SingleQubitNatives( - RX=NativePulse( - name="RX", - duration=40, - amplitude=0.05, - shape="Gaussian(5)", - pulse_type=PulseType.DRIVE, - qubit=qubit0, - frequency=int(4.7e9), - ), - MZ=NativePulse( - name="MZ", - duration=1000, - amplitude=0.005, - shape="Rectangular()", - pulse_type=PulseType.READOUT, - qubit=qubit0, - frequency=int(7e9), - ), - ) - qubit1.native_gates = SingleQubitNatives( - RX=NativePulse( - name="RX", - duration=40, - amplitude=0.05, - shape="Gaussian(5)", - pulse_type=PulseType.DRIVE, - qubit=qubit1, - frequency=int(5.1e9), - ), - MZ=NativePulse( - name="MZ", - duration=1000, - amplitude=0.005, - shape="Rectangular()", - pulse_type=PulseType.READOUT, - qubit=qubit1, - frequency=int(7.5e9), - ), - ) - - # define the pair of qubits - pair = QubitPair(qubit0, qubit1) - pair.native_gates = TwoQubitNatives( - CZ=NativeSequence( - name="CZ", - pulses=[ - NativePulse( - name="CZ1", - duration=30, - amplitude=0.005, - shape="Rectangular()", - pulse_type=PulseType.FLUX, - qubit=qubit1, - ) - ], - ) - ) - -Some architectures may also have coupler qubits that mediate the interactions. -We can also interact with them defining the :class:`qibolab.couplers.Coupler` objects. -Then we add them to their corresponding :class:`qibolab.qubits.QubitPair` objects according -to the chip topology. We neglected characterization parameters associated to the -coupler but qibolab will take them into account when calling :class:`qibolab.native.TwoQubitNatives`. - - -.. testcode:: python - - from qibolab.couplers import Coupler - from qibolab.qubits import Qubit, QubitPair - from qibolab.pulses import PulseType - from qibolab.native import ( - NativePulse, - NativeSequence, - SingleQubitNatives, - TwoQubitNatives, - ) - - # create the qubit and coupler objects - qubit0 = Qubit(0) - qubit1 = Qubit(1) - coupler_01 = Coupler(0) - - # assign single-qubit native gates to each qubit - # Look above example - - # define the pair of qubits - pair = QubitPair(qubit0, qubit1, coupler_01) - pair.native_gates = TwoQubitNatives( - CZ=NativeSequence( - name="CZ", - pulses=[ - NativePulse( - name="CZ1", - duration=30, - amplitude=0.005, - shape="Rectangular()", - pulse_type=PulseType.FLUX, - qubit=qubit1, - ) - ], - ) - ) - -The platform automatically creates the connectivity graph of the given chip -using the dictionary of :class:`qibolab.qubits.QubitPair` objects. + The general idea is to retain as much flexibility as possible, while avoiding the + custom handling of commonly structured data by each platform, that would also + complicate its handling by downstream projects. Registering platforms ^^^^^^^^^^^^^^^^^^^^^ -The ``create()`` function defined in the above example can be called or imported -directly in any Python script. Alternatively, it is also possible to make the -platform available as +The ``create()`` function described in the above example can be called or imported +directly in any Python script. Alternatively, it is also possible to make the platform +available as .. code-block:: python from qibolab import create_platform - # Define platform and load specific runcard platform = create_platform("my_platform") @@ -241,491 +55,341 @@ that contains this folder. Examples of advanced platforms are available at `this repository `_. -.. _using_runcards: +.. _parameters_json: -Using runcards -^^^^^^^^^^^^^^ +Loading platform parameters from JSON +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Operating a QPU requires calibrating a set of parameters, the number of which -increases with the number of qubits. Hardcoding such parameters in the -``create()`` function, as shown in the above examples, is not scalable. However, -since ``create()`` is part of a Python module, is is possible to load parameters -from an external file or database. +Operating a QPU requires calibrating a set of parameters, the number of which increases +with the number of qubits. Hardcoding such parameters in the ``create()`` function is +not scalable. +However, since ``create()`` is part of a Python module, is is possible to load +parameters from an external file or database. Qibolab provides some utility functions, accessible through -:py:mod:`qibolab.serialize`, for loading calibration parameters stored in a JSON -file with a specific format. We call such file a runcard. Here is a runcard for -a two-qubit system: +:py:mod:`qibolab._core.parameters`, for loading calibration parameters stored in a JSON +file with a specific format. +Here is an example .. code-block:: json { - "nqubits": 2, - "qubits": [ - 0, - 1 - ], - "settings": { - "nshots": 1024, - "sampling_rate": 1000000000, - "relaxation_time": 50000 + "settings": { + "nshots": 1024, + "relaxation_time": 50000 + }, + "configs": { + "0/drive": { + "kind": "iq", + "frequency": 4855663000 + }, + "1/drive": { + "kind": "iq", + "frequency": 5800563000 + }, + "0/flux": { + "kind": "dc", + "offset": 0.0 + }, + "1/flux": { + "kind": "dc", + "offset": 0.0 + }, + "0/probe": { + "kind": "iq", + "frequency": 7453265000 + }, + "1/probe": { + "kind": "iq", + "frequency": 7655107000 }, - "topology": [ - [ - 0, - 1 + "0/acquisition": { + "kind": "acquisition", + "delay": 0, + "smearing": 0 + }, + "1/acquisition": { + "kind": "acquisition", + "delay": 0, + "smearing": 0 + }, + "01/coupler": { + "kind": "dc", + "offset": 0.12 + } + }, + "native_gates": { + "single_qubit": { + "0": { + "RX": [ + [ + "0/drive", + { + "kind": "pulse", + "duration": 40, + "amplitude": 0.0484, + "envelope": { + "kind": "drag", + "rel_sigma": 0.2, + "beta": -0.02 + } + } + ] + ], + "MZ": [ + [ + "0/acquisition", + { + "kind": "readout", + "acquisition": { + "kind": "acquisition", + "duration": 620.0 + }, + "probe": { + "kind": "pulse", + "duration": 620.0, + "amplitude": 0.003575, + "envelope": { + "kind": "rectangular" + } + } + } + ] ] - ], - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 40, - "amplitude": 0.0484, - "frequency": 4855663000, - "shape": "Drag(5, -0.02)", - "type": "qd", - "start": 0, - "phase": 0 - }, - "MZ": { - "duration": 620, - "amplitude": 0.003575, - "frequency": 7453265000, - "shape": "Rectangular()", - "type": "ro", - "start": 0, - "phase": 0 - } - }, - "1": { - "RX": { - "duration": 40, - "amplitude": 0.05682, - "frequency": 5800563000, - "shape": "Drag(5, -0.04)", - "type": "qd", - "start": 0, - "phase": 0 + }, + "1": { + "RX": [ + [ + "1/drive", + { + "kind": "pulse", + "duration": 40, + "amplitude": 0.05682, + "envelope": { + "kind": "drag", + "rel_sigma": 0.2, + "beta": -0.04 + } + } + ] + ], + "MZ": [ + [ + "1/acquisition", + { + "kind": "readout", + "acquisition": { + "kind": "acquisition", + "duration": 960.0 }, - "MZ": { - "duration": 960, + "probe": { + "kind": "pulse", + "duration": 960.0, "amplitude": 0.00325, - "frequency": 7655107000, - "shape": "Rectangular()", - "type": "ro", - "start": 0, - "phase": 0 - } - } - }, - "two_qubit": { - "0-1": { - "CZ": [ - { - "duration": 30, - "amplitude": 0.055, - "shape": "Rectangular()", - "qubit": 1, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 0 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 1 + "envelope": { + "kind": "rectangular" } - ] - } - } - }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 7453265000, - "drive_frequency": 4855663000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.047, - "threshold": 0.00028502261712637096, - "iq_angle": 1.283105298787488 - }, - "1": { - "readout_frequency": 7655107000, - "drive_frequency": 5800563000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.045, - "threshold": 0.0002694329123116206, - "iq_angle": 4.912447775569025 + } } - } - } - } - -And in the case of having a chip with coupler qubits -we need the following changes to the previous runcard: - -.. code-block:: json - - { - "qubits": [ - 0, - 1 - ], - "couplers": [ - 0 - ], - "topology": { - "0": [ - 0, - 1 + ] ] + } }, - "native_gates": { - "two_qubit": { - "0-1": { - "CZ": [ - { - "duration": 30, - "amplitude": 0.6025, - "shape": "Rectangular()", - "qubit": 1, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -1, - "qubit": 0 - }, - { - "type": "virtual_z", - "phase": -3, - "qubit": 1 - }, - { - "type": "coupler", - "duration": 40, - "amplitude": 0.1, - "shape": "Rectangular()", - "coupler": 0, - "relative_start": 0 - } - ] + "two_qubit": { + "0-1": { + "CZ": [ + [ + "01/coupler", + { + "kind": "pulse", + "duration": 40, + "amplitude": 0.1, + "envelope": { + "kind": "rectangular" + } } - } - }, - "characterization": { - "coupler": { - "0": { - "sweetspot": 0.0 + ], + [ + "0/flux", + { + "kind": "pulse", + "duration": 30, + "amplitude": 0.6025, + "envelope": { + "kind": "rectangular" + } } - } + ], + [ + "0/drive", + { + "kind": "virtualz", + "phase": -1 + } + ], + [ + "1/drive", + { + "kind": "virtualz", + "phase": -3 + } + ] + ] + } } + } } -This file contains different sections: ``qubits`` is a list with the qubit -names, ``couplers`` one with the coupler names , ``settings`` defines default execution parameters, ``topology`` defines -the qubit connectivity (qubit pairs), ``native_gates`` specifies the calibrated -pulse parameters for implementing single and two-qubit gates and -``characterization`` provides the physical parameters associated to each qubit and coupler. -Note that such parameters may slightly differ depending on the QPU architecture, -however the pulses under ``native_gates`` should comply with the -:class:`qibolab.pulses.Pulse` API and the parameters under ``characterization`` -should be a subset of :class:`qibolab.qubits.Qubit` attributes. - -Providing the above runcard is not sufficient to instantiate a -:class:`qibolab.platform.Platform`. This should still be done using a -``create()`` method, however this is significantly simplified by -``qibolab.serialize``. The ``create()`` method should be put in a +This file contains different sections: ``configs`` defines the default configuration of channel +parameters, while ``native_gates`` specifies the calibrated pulse parameters for implementing +single and two-qubit gates. +Note that such parameters may slightly differ depending on the QPU architecture. + +Providing the above JSON is not sufficient to instantiate a +:class:`qibolab.Platform`. This should still be done using a +``create()`` method. The ``create()`` method should be put in a file named ``platform.py`` inside the ``my_platform`` directory. -Here is the ``create()`` method that loads the parameters of -the above runcard: +Here is the ``create()`` method that loads the parameters from the JSON: .. testcode:: python # my_platform / platform.py from pathlib import Path - from qibolab import Platform - from qibolab.channels import ChannelMap, Channel - from qibolab.serialize import load_runcard, load_qubits, load_settings - from qibolab.instruments.dummy import DummyInstrument + from qibolab import ( + AcquisitionChannel, + DcChannel, + IqChannel, + Platform, + Qubit, + ) + from qibolab.instruments import DummyInstrument + FOLDER = Path.cwd() - # assumes runcard is storred in the same folder as platform.py def create(): - # Create a controller instrument - instrument = DummyInstrument("my_instrument", "0.0.0.0:0") - - # Create channel objects and assign to them the controller ports - channels = ChannelMap() - channels |= Channel("ch1out", port=instrument["o1"]) - channels |= Channel("ch1in", port=instrument["i1"]) - channels |= Channel("ch2", port=instrument["o2"]) - channels |= Channel("ch3", port=instrument["o3"]) - channels |= Channel("chf1", port=instrument["o4"]) - channels |= Channel("chf2", port=instrument["o5"]) - - # create ``Qubit`` and ``QubitPair`` objects by loading the runcard - runcard = load_runcard(folder) - qubits, couplers, pairs = load_qubits(runcard) - - # assign channels to the qubit + qubits = {} for q in range(2): - qubits[q].readout = channels["ch1out"] - qubits[q].feedback = channels["ch1in"] - qubits[q].drive = channels[f"ch{q + 2}"] - qubits[q].flux = channels[f"chf{q + 1}"] - - # create dictionary of instruments - instruments = {instrument.name: instrument} - # load ``settings`` from the runcard - settings = load_settings(runcard) - return Platform( - "my_platform", qubits, pairs, instruments, settings, resonator_type="2D" - ) + qubits[q] = Qubit( + drive=f"{q}/drive", + flux=f"{q}/flux", + probe=f"{q}/probe", + acquisition=f"{q}/acquisition", + ) -With the following additions for coupler architectures: + couplers = {0: Qubit(flux="01/coupler")} -.. testcode:: python - - # my_platform / platform.py + channels = {} + for q in range(2): + channels[qubits[q].drive] = IqChannel( + device="my_instrument", path="1", mixer=None, lo=None + ) + channels[qubits[q].flux] = DcChannel(device="my_instrument", path="2") + channels[qubits[q].probe] = IqChannel( + device="my_instrument", path="0", mixer=None, lo=None + ) + channels[qubits[q].acquisition] = AcquisitionChannel( + device="my_instrument", path="0", twpa_pump=None, probe=qubits[q].probe + ) + + channels[couplers[0].flux] = DcChannel(device="my_instrument", path="5") + + instruments = { + "my_instrument": DummyInstrument( + name="my_instrument", address="0.0.0.0:0", channels=channels + ) + } + return Platform.load(FOLDER, instruments, qubits, couplers=couplers) - def create(): - # Create a controller instrument - instrument = DummyInstrument("my_instrument", "0.0.0.0:0") - - # Create channel objects and assign to them the controller ports - channels = ChannelMap() - channels |= Channel("ch1out", port=instrument["o1"]) - channels |= Channel("ch1in", port=instrument["i1"]) - channels |= Channel("ch2", port=instrument["o2"]) - channels |= Channel("ch3", port=instrument["o3"]) - channels |= Channel("chf1", port=instrument["o4"]) - channels |= Channel("chf2", port=instrument["o5"]) - channels |= Channel("chfc0", port=instrument["o6"]) - - # create ``Qubit`` and ``QubitPair`` objects by loading the runcard - runcard = load_runcard(FOLDER) - qubits, couplers, pairs = load_qubits(runcard) - - # assign channels to the qubit - for q in range(2): - qubits[q].readout = channels["ch1out"] - qubits[q].feedback = channels["ch1in"] - qubits[q].drive = channels[f"ch{q + 2}"] - qubits[q].flux = channels[f"chf{q + 1}"] - - # assign channels to the coupler - couplers[0].flux = channels["chfc0"] - - # create dictionary of instruments - instruments = {instrument.name: instrument} - # load ``settings`` from the runcard - settings = load_settings(runcard) - return Platform( - "my_platform", - qubits, - pairs, - instruments, - settings, - resonator_type="2D", - couplers=couplers, - ) - -Note that this assumes that the runcard is saved as ``/parameters.yml`` where ```` +Note that this assumes that the JSON with parameters is saved as ``/parameters.json`` where ```` is the directory containing ``platform.py``. Instrument settings ^^^^^^^^^^^^^^^^^^^ -The runcard of the previous example contains only parameters associated to the qubits -and their respective native gates. In some cases parameters associated to instruments -need to also be calibrated. An example is the frequency and the power of local oscillators, -such as the one used to pump a traveling wave parametric amplifier (TWPA). +The parameters of the previous example contains only parameters associated to the +channel configuration and the native gates. In some cases parameters associated to +instruments also need to be calibrated. +An example is the frequency and the power of local oscillators, such as the one used to +pump a traveling wave parametric amplifier (TWPA). -The runcard can contain an ``instruments`` section that provides these parameters +The parameters JSON can contain such parameters in the ``configs`` section: .. code-block:: json { - "nqubits": 2, - "qubits": [ - 0, - 1 - ], "settings": { "nshots": 1024, - "sampling_rate": 1000000000, "relaxation_time": 50000 }, - "topology": [ - [ - 0, - 1 - ] - ], - "instruments": { + "configs": { "twpa_pump": { + "kind": "oscillator", "frequency": 4600000000, "power": 5 } }, - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 40, - "amplitude": 0.0484, - "frequency": 4855663000, - "shape": "Drag(5, -0.02)", - "type": "qd", - "start": 0, - "phase": 0 - }, - "MZ": { - "duration": 620, - "amplitude": 0.003575, - "frequency": 7453265000, - "shape": "Rectangular()", - "type": "ro", - "start": 0, - "phase": 0 - } - }, - "1": { - "RX": { - "duration": 40, - "amplitude": 0.05682, - "frequency": 5800563000, - "shape": "Drag(5, -0.04)", - "type": "qd", - "start": 0, - "phase": 0 - }, - "MZ": { - "duration": 960, - "amplitude": 0.00325, - "frequency": 7655107000, - "shape": "Rectangular()", - "type": "ro", - "start": 0, - "phase": 0 - } - } - }, - "two_qubit": { - "0-1": { - "CZ": [ - { - "duration": 30, - "amplitude": 0.055, - "shape": "Rectangular()", - "qubit": 1, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 0 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 1 - } - ] - } - } - }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 7453265000, - "drive_frequency": 4855663000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.047, - "threshold": 0.00028502261712637096, - "iq_angle": 1.283105298787488 - }, - "1": { - "readout_frequency": 7655107000, - "drive_frequency": 5800563000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.045, - "threshold": 0.0002694329123116206, - "iq_angle": 4.912447775569025 - } - } - } } -These settings are loaded when creating the platform using :meth:`qibolab.serialize.load_instrument_settings`. -Note that the key used in the runcard should be the same with the name used when instantiating the instrument, -in this case ``"twpa_pump"``. +Note that the key used in the JSON have to be the same with the instrument name used in +the instrument dictionary when instantiating the :class:`qibolab.Platform`, in this case +``"twpa_pump"``. .. testcode:: python # my_platform / platform.py from pathlib import Path - from qibolab import Platform - from qibolab.channels import ChannelMap, Channel - from qibolab.serialize import ( - load_runcard, - load_qubits, - load_settings, - load_instrument_settings, + from qibolab import ( + AcquisitionChannel, + DcChannel, + IqChannel, + Platform, + Qubit, ) - from qibolab.instruments.dummy import DummyInstrument - from qibolab.instruments.oscillator import LocalOscillator + from qibolab.instruments import DummyInstrument + FOLDER = Path.cwd() def create(): - # Create a controller instrument - instrument = DummyInstrument("my_instrument", "0.0.0.0:0") - twpa = LocalOscillator("twpa_pump", "0.0.0.1") - - # Create channel objects and assign to them the controller ports - channels = ChannelMap() - channels |= Channel("ch1out", port=instrument["o1"]) - channels |= Channel("ch2", port=instrument["o2"]) - channels |= Channel("ch3", port=instrument["o3"]) - channels |= Channel("ch1in", port=instrument["i1"]) - - # create ``Qubit`` and ``QubitPair`` objects by loading the runcard - runcard = load_runcard(FOLDER) - qubits, pairs = load_qubits(runcard) - - # assign channels to the qubit + qubits = {} for q in range(2): - qubits[q].readout = channels["ch1out"] - qubits[q].feedback = channels["ch1in"] - qubits[q].drive = channels[f"ch{q + 2}"] - - # create dictionary of instruments - instruments = {instrument.name: instrument, twpa.name: twpa} - # load instrument settings from the runcard - instruments = load_instrument_settings(runcard, instruments) - # load ``settings`` from the runcard - settings = load_settings(runcard) - return Platform( - "my_platform", qubits, pairs, instruments, settings, resonator_type="2D" - ) + qubits[q] = Qubit( + drive=f"{q}/drive", + flux=f"{q}/flux", + probe=f"{q}/probe", + acquisition=f"{q}/acquisition", + ) + + couplers = {0: Qubit(flux="01/coupler")} + + channels = {} + for q in range(2): + channels[qubits[q].drive] = IqChannel( + device="my_instrument", path="1", mixer=None, lo=None + ) + channels[qubits[q].flux] = DcChannel(device="my_instrument", path="2") + channels[qubits[q].probe] = IqChannel( + device="my_instrument", path="0", mixer=None, lo=None + ) + channels[qubits[q].acquisition] = AcquisitionChannel( + device="my_instrument", path="0", twpa_pump=None, probe=qubits[q].probe + ) + + channels[couplers[0].flux] = DcChannel(device="my_instrument", path="5") + + instruments = { + "my_instrument": DummyInstrument( + name="my_instrument", address="0.0.0.0:0", channels=channels + ), + "twpa_pump": DummyLocalOscillator(name="twpa_pump", address="0.0.0.1:0"), + } + + return Platform.load(FOLDER, instruments, qubits, couplers=couplers) diff --git a/doc/source/tutorials/pulses.rst b/doc/source/tutorials/pulses.rst index 51fa61d763..94a17e92dd 100644 --- a/doc/source/tutorials/pulses.rst +++ b/doc/source/tutorials/pulses.rst @@ -1,48 +1,37 @@ Pulses execution ================ -First, we create the pulse sequence that will be executed. We can do this by -defining a :class:`qibolab.pulses.PulseSequence` object and adding different -pulses (:class:`qibolab.pulses.Pulse`) through the -:func:`qibolab.pulses.PulseSequence.add()` method: +We can create pulse sequence using the Qibolab pulse API directly, +defining a :class:`qibolab.PulseSequence` object and adding different +pulses (:class:`qibolab.Pulse`) using the :func:`qibolab.PulseSequence.append()` method: .. testcode:: python - from qibolab.pulses import ( - DrivePulse, - ReadoutPulse, - PulseSequence, - Rectangular, - Gaussian, - ) + from qibolab import Delay, Gaussian, Pulse, PulseSequence, Rectangular # Define PulseSequence - sequence = PulseSequence() - - # Add some pulses to the pulse sequence - sequence.add( - DrivePulse( - start=0, - frequency=200000000, - amplitude=0.3, - duration=60, - relative_phase=0, - shape=Gaussian(5), - qubit=0, - ) - ) - sequence.add( - ReadoutPulse( - start=70, - frequency=20000000.0, - amplitude=0.5, - duration=3000, - relative_phase=0, - shape=Rectangular(), - qubit=0, - ) + sequence = PulseSequence.load( + [ + ( + "0/drive", + Pulse( + amplitude=0.3, + duration=60, + relative_phase=0, + envelope=Gaussian(rel_sigma=0.2), + ), + ), + ("1/drive", Delay(duration=100)), + ( + "1/drive", + Pulse( + amplitude=0.5, duration=3000, relative_phase=0, envelope=Rectangular() + ), + ), + ] ) + The next step consists in connecting to a specific lab in which the pulse sequence will be executed. In order to do this we allocate a platform object via the :func:`qibolab.create_platform("name")` where ``name`` is the name of @@ -50,15 +39,12 @@ the platform that will be used. The ``Platform`` constructor also takes care of loading the runcard containing all the calibration settings for that specific platform. -After connecting and setting up the platform's instruments using the -``connect()`` and ``setup()`` methods, the ``start`` method will turn on the -local oscillators and the ``execute`` method will execute the previous defined -pulse sequence according to the number of shots ``nshots`` specified. +After connecting to the platform's instruments using the ``connect()``, +we can execute the previously defined sequence using the ``execute`` method: .. testcode:: python from qibolab import create_platform - from qibolab.execution_parameters import ExecutionParameters # Define platform and load specific runcard platform = create_platform("dummy") @@ -67,11 +53,25 @@ pulse sequence according to the number of shots ``nshots`` specified. platform.connect() # Executes a pulse sequence. - options = ExecutionParameters(nshots=1000, relaxation_time=100) - results = platform.execute_pulse_sequence(sequence, options=options) + results = platform.execute([sequence], nshots=1000, relaxation_time=100) # Disconnect from the instruments platform.disconnect() -Remember to turn off the instruments and disconnect from the lab using the -``stop()`` and ``disconnect()`` methods of the platform. +Remember to turn off and disconnect from the instruments using the +``disconnect()`` methods of the platform. + +.. note:: + Calling ``platform.connect()`` automatically turns on auxilliary instruments such as local oscillators. + +Alternatively, instead of using the pulse API directly, one can use the native gate data structures to write a pulse sequence: + +.. testcode:: python + + import numpy as np + + from qibolab import Delay, Gaussian, Pulse, PulseSequence, Rectangular, create_platform + + platform = create_platform("dummy") + q0 = platform.natives.single_qubit[0] + sequence = q0.R(theta=np.pi / 2) | q0.MZ() diff --git a/examples/fidelity_example.py b/examples/fidelity_example.py deleted file mode 100644 index a2f2e56127..0000000000 --- a/examples/fidelity_example.py +++ /dev/null @@ -1,16 +0,0 @@ -from qibolab import create_platform -from qibolab.paths import qibolab_folder - -# Define platform and load specific runcard -runcard = qibolab_folder / "runcards" / "tii5q.yml" -platform = create_platform("tii5q", runcard) - -# Connects to lab instruments using the details specified in the calibration settings. -platform.connect() -# Executes a pulse sequence. -results = platform.measure_fidelity(qubits=[1, 2, 3, 4], nshots=3000) -print( - f"results[qubit] (rotation_angle, threshold, fidelity, assignment_fidelity): {results}" -) -# Disconnect from the instruments -platform.disconnect() diff --git a/examples/minimum_working_example.py b/examples/minimum_working_example.py deleted file mode 100644 index 3213c70aa5..0000000000 --- a/examples/minimum_working_example.py +++ /dev/null @@ -1,44 +0,0 @@ -from qibolab import create_platform -from qibolab.paths import qibolab_folder -from qibolab.pulses import Pulse, PulseSequence, ReadoutPulse - -# Define PulseSequence -sequence = PulseSequence() -# Add some pulses to the pulse sequence -sequence.add( - Pulse( - start=0, - amplitude=0.3, - duration=4000, - frequency=200_000_000, - relative_phase=0, - shape="Gaussian(5)", # Gaussian shape with std = duration / 5 - channel=1, - qubit=0, - ) -) - -sequence.add( - ReadoutPulse( - start=4004, - amplitude=0.9, - duration=2000, - frequency=20_000_000, - relative_phase=0, - shape="Rectangular", - channel=2, - qubit=0, - ) -) - -# Define platform and load specific runcard -runcard = qibolab_folder / "runcards" / "tii1q.yml" -platform = create_platform("tii1q", runcard) - -# Connects to lab instruments using the details specified in the calibration settings. -platform.connect() -# Executes a pulse sequence. -results = platform.execute_pulse_sequence(sequence, nshots=3000) -print(f"results (amplitude, phase, i, q): {results}") -# Disconnect from the instruments -platform.disconnect() diff --git a/examples/pulses_tutorial.ipynb b/examples/pulses_tutorial.ipynb deleted file mode 100644 index 6076a71668..0000000000 --- a/examples/pulses_tutorial.ipynb +++ /dev/null @@ -1,1188 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Pulses Tutorial" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Pulse" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Overview" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `Pulse` object represents the radio-frequency pulses that are used to control qubits. \n", - "The new version of `Pulse` object includes the following changes:\n", - "- It includes a new attribute `finish` that returns the point in time when the pulse finishes (start + duration).\n", - "- The `phase` attribute was replaced with `relative_phase`, since taking care of the global sequence phase is now done by the `PulseSequence`.\n", - "- The attributes `offset_i` and `offset_q` included in the previous version were removed, as those are parameters of the instrument.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from qibolab.pulses import Pulse, ReadoutPulse, DrivePulse, FluxPulse\n", - "from qibolab.pulses import PulseShape, Rectangular, Gaussian, Drag, IIR, SNZ, eCap, Waveform\n", - "\n", - "p0 = DrivePulse(start=0, \n", - " duration=40, \n", - " amplitude=1, \n", - " frequency=200e6, \n", - " relative_phase=0, \n", - " shape=Gaussian(5), \n", - " channel=10, \n", - " qubit=0)\n", - "\n", - "p1 = ReadoutPulse(start=p0.duration,\n", - " duration=400,\n", - " amplitude=1, \n", - " frequency=20e6, \n", - " relative_phase=0,\n", - " shape=Rectangular(),\n", - " channel=20, \n", - " qubit=0)\n", - "ps = p0 + p1\n", - "ps.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If one of those variables change, the pulses that use them change automatically:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p0.duration = 80\n", - "ps.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "or" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Initialisation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The main changes in the initialization of Pulse are those related to the changes in the attributes: \n", - "```python\n", - "def __init__(self, start: int, duration: int, amplitude: float, \n", - " frequency: int, relative_phase: float, shape: PulseShape | str,\n", - " channel: int | str, type: PulseType | str = PulseType.DRIVE, qubit: int | str = 0):\n", - "``` \n", - "The argument `phase` was replaced with `relative_phase`, the `shape` argument continues to support `PulseShape` objects or strings. `channel`and `qubit` support both integers or strings, and finally, the `type` argument supports a string or a constant from PulseType enumeration:\n", - "```python\n", - "class PulseType(Enum):\n", - " READOUT = \"ro\"\n", - " DRIVE = \"qd\"\n", - " FLUX = \"qf\"\n", - "```\n", - "\n", - "Pulse `type` and `qubit` are optional arguments, and default to `PulseType.DRIVE` and `0` respectively.\n", - "\n", - "Below are some examples of Pulse initialization:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from qibolab.pulses import Pulse, ReadoutPulse, DrivePulse, FluxPulse\n", - "from qibolab.pulses import PulseShape, Rectangular, Gaussian, Drag\n", - "from qibolab.pulses import PulseType, PulseSequence\n", - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# standard initialisation\n", - "p0 = Pulse(start = 0, \n", - " duration = 50, \n", - " amplitude = 0.9, \n", - " frequency = 20_000_000, \n", - " relative_phase = 0.0, \n", - " shape = Rectangular(), \n", - " channel = 0, \n", - " type = PulseType.READOUT, \n", - " qubit = 0)\n", - "assert repr(p0) == 'Pulse(0, 50, 0.9, 20_000_000, 0, Rectangular(), 0, PulseType.READOUT, 0)'" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# initialisation with str shape\n", - "p4 = Pulse(start = 0, \n", - " duration = 50, \n", - " amplitude = 0.9, \n", - " frequency = 20_000_000, \n", - " relative_phase = 0, \n", - " shape = 'Rectangular()', \n", - " channel = 0, \n", - " type = PulseType.READOUT, \n", - " qubit = 0)\n", - "assert repr(p4) == 'Pulse(0, 50, 0.9, 20_000_000, 0, Rectangular(), 0, PulseType.READOUT, 0)'" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# initialisation with str channel and str qubit\n", - "p5 = Pulse(start = 0, \n", - " duration = 50, \n", - " amplitude = 0.9, \n", - " frequency = 20_000_000, \n", - " relative_phase = 0, \n", - " shape = 'Rectangular()', \n", - " channel = 'channel0', \n", - " type = PulseType.READOUT, \n", - " qubit = 'qubit0')\n", - "assert repr(p5) == 'Pulse(0, 50, 0.9, 20_000_000, 0, Rectangular(), channel0, PulseType.READOUT, qubit0)'\n", - "assert p5.qubit == 'qubit0'" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# examples of initialisation with different frequencies, shapes and types\n", - "p6 = Pulse(0, 40, 0.9, -50e6, 0, Rectangular(), 0, PulseType.READOUT)\n", - "p7 = Pulse(0, 40, 0.9, 0, 0, Rectangular(), 0, PulseType.FLUX, 0)\n", - "p8 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(5), 0, PulseType.DRIVE, 2)\n", - "p9 = Pulse(0, 40, 0.9, 50e6, 0, Drag(5,2), 0, PulseType.DRIVE, 200)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACTEAAAPkCAYAAAB7yuiYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd3wU1f7/8fem9wRCSwi9NwEpIqh0RFAUBCtNEfu1fLEXxIJey9WLXvXakGL3XlEUK4qoCAJKkyJdSigJkEp6zu+P/DJ3N9lNdpPdbCKv5+Oxj8zunDlzdnLmzOzMZ86xGWOMAAAAAAAAAAAAAAAAAMBPAvxdAAAAAAAAAAAAAAAAAACnNoKYAAAAAAAAAAAAAAAAAPgVQUwAAAAAAAAAAAAAAAAA/IogJgAAAAAAAAAAAAAAAAB+RRATAAAAAAAAAAAAAAAAAL8iiAkAAAAAAAAAAAAAAACAXxHEBAAAAAAAAAAAAAAAAMCvCGICAAAAAAAAAAAAAAAA4FcEMQEAAAAAAAAAAAAAAADwK4KYAAAAAAAAAAAAAAAAAPgVQUwAAAAAAAAAAAAAAAAA/IogJgAAAAAAAAAAAAAAAAB+RRATAAAAAAAAAAAAAAAAAL8iiAkAAAAAAAAAAAAAAACAXxHEBAAAAAAAAAAAAAAAAMCvCGICAAAAAAAAAAAAAAAA4FcEMQEAAAAAAAAAAAAAAADwK4KYAAAAAAAAAAAAAAAAAPgVQUwAAAAAAAAAAAAAAAAA/IogJgAAgFrq+++/l81mk81m06BBg/xdnGopLi5Wr169ZLPZ1KNHDxUXF/u7SAAAAKgj5s2bZ50XT5061d/F8dhFF10km82mhIQEZWdnl5u/efNmBQYGymazafbs2X4oIXxh6tSpVr2dN2+ev4sDAHXamWeeKZvNps6dO6ugoMDfxQEAAD5EEBMAADhlDRo0yLqo7OwVHR2tli1b6sILL9QLL7yg9PR0fxe5znr11Vf122+/SZKefPJJBQRUfhqampqqZ555Rv3791dCQoLCwsLUokULjRo1SgsXLqzVF60WL15crj7t3bvXozy2bt2qO++8U6eddprq16+vyMhItW/fXlOmTNG3337rm4JXQX5+vhYuXKhRo0apRYsWCgsLU0JCgvr3769nnnlGqampPl3/8uXLNX36dHXs2FGxsbEKDw9X69atddFFF+ndd99VYWGhT9fvbS1btqywXXL2OnDggNv519b9KisrSy+//LIGDx6spKQkhYaGKikpSUOGDNG///1vZWVleZynMUaLFi3S+PHj1aZNG4WHh6thw4bq3bu3Hn74Ye3bt69KZV2zZo1uvPFGde7cWTExMYqJiVHnzp114403as2aNVXK0xt80Wb4or74u83w9/o9UZuPA+6cQzVv3lwjR47U448/roMHD/q1vIA/ffnll/rkk08kSbNmzVJkZGS5NF26dNHkyZMlSY8//rj2799fo2V0xVfHUm/Yu3dvhe1QUFCQ4uPjddppp+maa67RV199JWOM38pbF1TWtnv6atmypb+/Uq1V0XYLDAxUXFyc2rVrpwkTJuj111/36Fy4Ov9HT4NEH3jgAYflb7jhBg+3RMXlDQsLU+PGjdWuXTudddZZ+tvf/qZ58+Z5re1Zu3atHnroIZ111llq2bKlIiIiFBsbq3bt2mnkyJGaM2eOR7/jy7ZLnl4DsN8Ws2bNcvp5Xdw3vXX+/fe//11SyTnyCy+84MsiAwAAfzMAAACnqIEDBxpJbr9iYmLM/Pnza6x8y5Yts9Y9cODAGluvt2VmZpqGDRsaSaZfv35uLfPpp59ay7h6nX766eaPP/7wcek9l56ebpo2bVquvHv27HE7j8cee8wEBwdX+P0vv/xyk5GR4bsv4oatW7eaHj16VFjORo0amSVLlnh93ampqea8886rdL/t1auX2bp1q9fX7ystWrTwqF2SZPbv3+9W3rV1v/r5559Nq1atKixX69atzapVq9zO8+DBg2bIkCEV5hkVFWXefPNNt/PMy8szt9xyi7HZbC7ztNls5rbbbjP5+flV2BJV54s2wxf1xZ9tRm1Yvydq+3HA03Oo4OBgM2vWLFNcXOyX8lbXX+WcrC578803rf/BlClT/F0ctxUVFZkuXboYSaZZs2YVHh927NhhAgMDjSQzderUGiylc744lnrTnj17PD5n6tOnj9m+fXuNlXHKlCnWuv21nTzhadte2atFixb+/kq1lqfbskGDBuajjz5yK+/q/B89aV+Li4tN8+bNHZavV6+eyc3N9WhbVKW8AQEBZtSoUebLL7/0aF2lNm3aZEaOHOnWuoKCgsyNN95oUlJSKs23bLvkyTWAstvioYcecvp5Xds3vX3+fc455xhJJi4uzpw4ccK3hQcAAH4TJAAAAKhPnz7q27ev9d4Yo7S0NK1Zs0Y7duyQJGVkZGjKlCnKzc3Vtdde66+i1jlz5sxRSkqKJOmee+6pNP3XX3+tsWPHWj3oREREaOjQoWrYsKF27dqlH374QcYY/fbbbxo6dKh++eUXJSYm+vQ7eOKuu+6qVo8TM2fO1KOPPmq9T0hI0Nlnn62wsDD9+uuv2rx5syTp3Xff1bFjx7RkyRIFBdX8af2BAwc0dOhQJScnSyp5mvicc85RmzZtlJKSoqVLlyonJ0dHjx7VRRddpC+//FJDhgzxyrpPnDih/v37a/v27dZnrVu31plnnqmwsDDt2rVLK1asUEFBgX799VcNGjRIq1atqnNPg0+ePFnR0dGVpouKiqo0TW3drzZs2KARI0ZYT5cHBwdryJAhSkpK0v79+/Xdd9+psLBQu3fv1ogRI7RixQp17dq1wjwzMjJ07rnn6vfff7c+69u3r7p06aL09HR99913SktLU1ZWlq666ioFBARYvV9UZPr06VqwYIH1vnXr1urXr58kadWqVdq9e7eMMfrnP/+pjIwMvfHGG1XZJB7zRZvhi/rizzajNqzfE3XlOFCq7DmUJKWnp2vDhg3atGmTJKmgoECzZs1SWlqannvuOX8UE/CLd99919pnZ8yYoeDgYJdp27Ztq4svvlgffPCBFi5cqHvuuUcdOnSoqaI68NWx1JfKnjcVFhbqwIED+vHHH5WRkSGppDfFc845R6tWrVKLFi38VdRaa+zYsRWeZ2VmZjqcC1V2rhofH+/V8v1VXXTRRWratKn1vri4WKmpqVq5cqXV42pqaqrGjx+v//znPxo7dqzbeTs7Rlek9NzWHcuWLSvXI9KJEye0ePFiTZgwwe187JUtb3FxsdLT05WWlqbNmzfrzz//tD7//PPP9fnnn2vq1Kl6/vnn3frdJEn/+c9/NHHiROXl5VmfRUdHq3///kpMTFR+fr727dunlStXqrCwUIWFhXrppZf06aef6ssvv1Tnzp2r9N2qo67um744/77nnnv0ww8/KC0tTc8884wee+yxmvgqAACgpvk1hAoAAMCPXD3lVtZHH31kYmNjrbShoaFu93xSHX+Fp/5zcnKsnjyaN29uioqKKkyfmppq4uLirO89dOjQck88rl+/3uGJzyFDhvjyK3jkhx9+sHppueKKKzx+CnPp0qUOy9x5550mLy/PIc0777xjwsLCrDQPP/ywj75Nxc4++2yHJznXr1/vMD8lJcUMHTrUSlO/fn2vPSk5duxYK9+wsDCzYMGCcml27txp+vTpY6U7/fTT60QPIPY9MXn65K4rtXW/ys/PN23atLHW2b1793Lfec+ePaZ79+5Wmvbt25uCgoIK8500aZJDvfv2228d5mdlZZkrr7zSShMSEmJ27NhRYZ5vvPGGw5Pfzz33nEN7VlRUZJ577jkTEBBgpauJnvt80Wb4qr74s82oDet3V105Drh7DrVixYpyvTSsWbOm5grqJX+Fc7K6rq72xNStWzcjyURERJj09PRK09vXtWuuuaYGSuicL46l3uZujycZGRnmpptuckg7atSoGiljXeuJqTLV7WUG/2O/HZctW+Y0TVFRkZk7d64JDQ210jZu3NhkZ2dXmLe7x+jqmjx5srWe8PBwa3r06NEe5eNJeQ8dOmSeeuopk5SU5LAN+/TpY06ePFnput566y2H8/UGDRqYuXPnOu096tixY+aBBx5w6BmzXr16ZvPmzS7z91VPTJWprfumL86/i4uLrV584+LiTFZWlg+/AQAA8BeCmAAAwCnLkwtEn332mcNFoXvvvdfn5fsr3DB7/fXXPboId+edd1rp27Rp4/IC7YYNGxwuJn711VdeLrnncnJyTPv27Y0k07ZtW7N161aPLyTaB91cdtllLtO9/PLLVrro6Gi3urb3piVLljjctNq4caPTdFlZWaZ169Ze3W/Wrl3rsF3feecdl2lPnDjhcPP8rbfeqvb6fc0XQUy1db968cUXHW4IHDp0yGm65ORkU69ePSvtK6+84jLPTZs2OdyYcDXERFFRkenfv7+V7vLLL3eZZ25urmnWrJmV9p577nGZ9u6773a4UF82+MTbfNFm+KK++LPNqA3r90RdOQ54cg61bt06h2EYp0+fXjOF9KK/wjlZXVcXg5jsgxI9KXPbtm2NVBKoXdP7tjG+OZb6gqc37cePH++Qftu2bT4vI0FMcMWdIKZSc+bMcUj/9ttvV5i+JoKYMjMzTWRkpLUe+/OSoKAgc/jwYbfzqkp5MzMzzYQJExy2yyWXXFLhMtu2bXMoc7t27czBgwcrXdfy5ctNRESEtVy3bt1MTk6O07QEMf2PL8+/H330USv9v/71L28XHQAA1AIBAgAAQKVGjx6t7t27W++XLl3qx9LUHfbDKV166aUVpi0oKNBrr71mvX/kkUcUERHhNO1pp52mKVOmWO9ffPHFapa0+h555BFreLOXX35ZYWFhHi2/Zs0arVmzRpIUEBCgp556ymXa6667Tu3atZNU0nX8woULq1jqqrHf3lOmTFG3bt2cpouMjNQjjzxivX/llVes4amq6sMPP7SmTzvtNF1++eUu08bFxem+++6z3s+ZM6da666LavN+ZZ//HXfcoSZNmjhNl5CQoBkzZrhVrpdfflnFxcWSpOHDh+vcc891mq7sPvbBBx8oNTXVadrFixdr//79kqTY2Fg9+OCDLtc/c+ZMxcTESJL+/PNPLVmyxGXa6vJFm+Gr+uLPNqM2rN9ddek44IkePXpo0KBB1vsffvjBf4UBapAn58H2Sodhys3N1bvvvuv1clXGF8fS2uD+++93eP/tt9/6qSSAZ6677jqH35a14Tj63//+V9nZ2ZKkVq1a6brrrlOPHj0klQzl+Pbbb/t0/VFRUXr//fc1evRo67MPPvigwm0zffp0q8zR0dH65ptv3Bo++5xzznE4z9q0aZOeeOKJapT+1ODL8+9LLrnEmp47d241SwoAAGojgpgAAADc1L9/f2t69+7dDvOmTp0qm80mm82mefPmVZrXvHnzrPRTp06tdtm2bdumu+66S/369VODBg0UEhKisLAwNWrUSL169dJVV12l+fPn68SJE5XmVVBQoIULF+qSSy5R69atFR0drcjISLVq1UqXX365Fi1aJGNMpfns3r1bK1eulCS1b99enTp1qjD9999/r7S0NEklFxUvvvjiCtPbb7evv/7auiDpDxs2bNDTTz8tSZo4caKGDRvmcR4ff/yxNT1s2DA1a9bMZVqbzeYQPLBo0SKP11dVWVlZDjd9rrrqqgrTX3zxxYqKipIkHT9+vNoX3X/55RdretSoUZWmt7+wvWbNGu3bt69a669raut+tXPnTm3ZssXpeisr18aNG8u1wZJkjNHixYut95XVzQEDBqht27aSpKKiIodl7dnvm5deeqnLoB5JioiIcLio7st90xdthi/qi7/bDH+v3xN15ThQFaU3NiUpOTnZrWW2bt2q++67T3379lXjxo0VEhKihg0b6owzztDMmTPdzqdUUVGRPvjgA02ePFkdOnRQvXr1FBwcrPj4eJ1xxhm69dZb9e233zqc48yaNUs2m02DBw+2Plu+fLl1Dmf/atmyZbl1FhcX68cff9TMmTM1YsQINW/eXBEREQoNDVVCQoKGDBmi2bNnux34Yb++Un/88Yduu+02derUSVFRUYqJiVH37t117733ehxQ8uGHH+qCCy5Q06ZNFRoaqqSkJA0fPlzz58+3bii6c847aNAgK833339f6XpLt7PNZtOsWbM8KrMzv/76q5544gmdf/75at26taKiohQSEqLGjRurf//+uv/++90+H2jZsqVVtr1790qSdu3apfvvv189e/ZUw4YNFRAQ4FDHJSk7O9vap6OjozV06FC3yz927Fhr+q233nJ7OW/w1bG0NujevbsiIyOt92XPJZztXxXxtJ5XxBijjz/+WFdccYU6dOigmJgYBQYGKjIyUi1bttSQIUN09913a9myZVaAWUX279+vRx99VGeffbYSExMVGhqq+vXrq2fPnrrjjjusBy+8bdGiRdY26dixo9vL7d69WwEBAbLZbAoNDS3Xdjnb1vv379cDDzyg7t27q379+oqMjFTHjh11++23a+fOnR6X/dtvv9X111+vLl26qH79+goNDVViYqLOPfdc/etf/1JOTo7HeXpLaGiow29pT49/vjB//nxreuLEibLZbJo0aZLT+b5is9m0YMECRUdHW5/Nnj3badpffvlFP/74o/X+0UcfVYsWLdxe17hx4zRmzBjr/YsvvujXOlHb+fr8u3379urcubMk6bffftPWrVurWWIAAFDbEMQEAADgpnr16lnTGRkZfiyJo1mzZqlr1656+umn9csvv+jYsWMqKChQXl6eUlJS9Ntvv2nevHmaOnWq/va3v1WY1/fff69OnTpp8uTJ+vDDD7Vnzx5lZWXp5MmT2rt3r9577z2NGzdO/fv318GDByvM67PPPrOmhwwZUun3WLZsmTV95plnKjQ0tML0ffv2tYIJcnNzrYCpmlZUVKRrrrlGhYWFql+/vp599tkq5WP//e17rHDF/obqzz//rLy8vCqt11P264qMjFSfPn0qTB8WFqYzzzzTev/dd99Va/1Hjhyxpt258Ny0aVMFBgZ6bf11TW3dr+z/D+3bt6/0KeimTZtavc6UXb7Ujh07dODAAeu9p/uRq7pRnX3Tl/XNF22GL+qLv9sMf6/fE3XlOFAV4eHh1nRubm6FafPy8nT99derW7dueuKJJ7RmzRodPXpUBQUFSk1N1erVq/Xoo4+qbdu2+te//uXW+n/88Ud17txZl156qRYuXKjt27crLS1NhYWFOn78uFavXq3nn39ew4YN07333lut71qqoKBAzZs31znnnKNHH31U33zzjfbv36+cnBzl5+fr8OHDWrZsmR544AG1bNmySsEq//73v9W9e3fNmTNH27ZtU3Z2tjIzM7Vx40b9/e9/V8eOHbV27dpK80lPT9eIESN0ySWX6LPPPlNycrLy8/N18OBBLV26VFOnTtWgQYN0+PDhqmyKGtW3b1/17t1b9913n5YsWaI9e/YoOztbBQUFOnr0qFauXKnHH39cbdu2rbC3M1deffVVde3aVY8//rjWr1+v1NRUp8H93377rXWDe8CAAQoJCXF7Hb169VJsbKwkWfW/pvjqWFob2Gw2a7tKtef33JEjRzRgwACNHTtW7777rrZv367MzEwVFxfr5MmT+vPPP7Vs2TI99dRTGjJkSIXbuLi4WDNnzlT79u01c+ZM/fTTTzp06JDy8/N14sQJrV+/Xv/4xz/UpUsX3X///W49mOKJCy64wOpZ848//tCKFSvcWm7u3LlWWS688EI1aNCgwvSLFy9Wt27dNHv2bG3cuFEnTpzQyZMn9ccff+if//ynTjvtNL366qturXv//v0aPHiwhg0bpldeeUVbtmzRiRMnlJ+fr0OHDunrr7/W3/72N7Vt29YhCKameXIc9bU///zTIXBv4sSJkqQrrrjC+t21ceNGrV+/3udlqV+/vkNQ/TfffKPjx4+XS/fvf//bmo6OjtY111zj8br+7//+z5o+duyYPvjgA4/zOFXUxPm3/TUm+2tPAADgryHI3wUAAACoK+x7MbK/AO5Pc+bM0cMPP2y9b9Cggfr166eEhATZbDYdP35c27Zt09atW1VUVFRhXh9++KGuvPJKFRQUSCq5UNqvXz+1bNlSAQEB2r59u1auXKnCwkKtWrVKZ555ptasWaPGjRs7ze+bb76xps8+++xKv4v903Onn356pemDg4PVrVs3q2eerVu3VqkHpOp67rnnrBuETz/9tBo2bFilfDz9/j179rSmi4qKtH37dpddtHuTfTm7deumoKDKf1KcfvrpVn2o7lOSnt5sKftE/ebNm6u1/pr066+/6pNPPrECBuPj49W5c2edddZZDkGVFamt+5Wn5SpNt2PHjnLLO8uzSZMmSkhIcCtPZ8uXSk9P16FDhzwqq32agwcPKiMjwxpizpt80Wb4or74u83w9/o9UVeOA1Vh32uEq/MGqaT3mnPPPdfhxnebNm3Uq1cv1atXT8ePH9eKFSuUnJysnJwc/e1vf1NGRobD0KFlvffee5o8ebJ1fiOVBE/27NlTsbGxysjI0ObNm7V582YVFxc73Bzu27evbrrpJh08eNDqVScxMdGhp5xS8fHxDu+Lioqs9jsqKkpdunRR69atFRMTo4KCAh04cECrVq1SRkaGsrOzNWnSJAUHB7s97Ni8efN0ww03SJI6dOig3r17Kzw8XNu2bdOKFStkjNGxY8c0ZswYbd261eW5a15enkaOHKlVq1ZZnyUmJurss89WVFSUdu3apZ9++kkrVqzQuHHj1Lp1a7fK5y+lPSyFhoaqS5cuatu2rWJjY2WM0aFDh/TLL78oNTVVBQUFuvvuuyVJd911l1t5f/jhh1baxMREDRgwQLGxsUpOTi5309zT82B7AQEB6t+/v7744gsZY7R06VJdccUVHuVRVb44ltYWxhirt0GpdvyeKyoq0ujRo/Xrr79an3Xt2lVdu3ZVXFyccnNzdfjwYW3YsMHhfMRVXpdeeqn++9//Wp81bdpUffv2VcOGDZWVlaVffvlFu3btUmFhoR5//HGlpKS4HezjjqCgIF111VXWUFtvvPGGBgwYUGm57Xt1qyy4ZO3atbr//vuVn5+v+Ph4DRo0SPXq1dPevXu1fPlyFRQUKCcnR9ddd50CAwM1bdo0l3lt3bpVQ4cOtbatzWbT6aefrs6dOys8PFwHDx7UDz/8oMzMTCUnJ2v48OH64osvHAL3aoq7x9GasHDhQus32RlnnKH27dtLKmkzhg8fri+//FJSSW9MZXup84UJEybohRdekFSyn//0008OvSZJjoHiF154oUOvbO4aOHCgkpKSrEDP77//3qFXTPxPTZx/n3322VYw+zfffKM777yziqUFAAC1EUFMAAAAbrK/odaqVSs/lqREYWGhHnvsMev9E088oRkzZig4OLhc2uPHj+uTTz5RSkqK07w2b96sKVOmqKCgQDabTTNmzND999+vuLg4h3S7d+/WlClT9NNPP2n//v266qqr9PnnnzvNc/Xq1db0aaedVun3+eOPP6xpd7t2b968uXXzfNu2bW4t4027d+/WQw89JEk655xzKu0m3ZWjR4863FRx5/uHh4erYcOG1v9027ZtNXLzuqr/p1LV/T81bNjQysOdoWAOHjxoDYEj1e6ba2WNHz/e6efBwcG67LLLNGvWrEpvJtfW/coX9cjXeZZN706epXlU9vSxp3zVZviivvi7zfD3+t1Vl44DniosLHQYUqRfv34u0954443W+Vb79u31yiuvlOsJpqioSK+++qpuv/125eXlaebMmRo8eLDDE/yl1q1bp6uuusoKYOrZs6defvllnXHGGeXSHj58WG+99ZbDUE2jRo3SqFGj9P3331tBTO3atXOrB6iAgABdddVVmjx5sgYMGOD0/CwvL0/PP/+87rvvPhUWFur666/X6NGjrSFVKnL99derYcOGWrBggUaOHOkw74cfftAFF1ygjIwMHTp0SHPmzNHMmTOd5vPYY49ZAUwBAQF66qmndPvttysg4H+dt+/evVuXX365Vq5cqd9++63SsvnTuHHjdP7552vw4MEOPZeUKioq0sKFC3XzzTcrOztbDzzwgCZMmODWuf19992nkJAQ/etf/9I111zjECRdtic0++Fv3TkPLqtHjx764osvJJWcU9dUEFNdaTOrYv369Tp58qT1vjb8nvvss8+sAKaEhAQtWrTIafsklfxeW7hwocvA6IcfftgKYGrSpIlefPFFjR07ttzweB9++KGmT5+u9PR0vfbaaxo2bJjDULjVNX36dP3973+XMUYffPCB5syZ4zDcV1lfffWVFfDZokWLSoPnSwOY7rjjDj322GMOvUYeOHBAV1xxhdVj0i233KJBgwapTZs25fLJzs7WxRdfbAUwnXfeeXrhhRfKpc3IyNA999yjl19+WXl5ebryyisrDAz1he3bt1vDWUoVH0drwoIFC6xp+yHkSt+XBjG98847evrpp90KYKmOXr16KTAw0Hpoa9WqVQ5BTAcOHNCff/5pva/O9uvbt68VxPTTTz9VOZ+/upo4ltgHyK1Zs0bGGLeHAwUAALUfw8kBAAC4YcmSJdq4caP1fujQoX4sTYlt27YpNTVVUskwFffcc4/TG2RSSTfrV111lcsnzW+55RZryIt//OMfevrpp8sFMElS69at9eWXX6pz586SpC+++MLhJk2pw4cPW0Nf2Gw26+nMihw7dsyadvfp0tLhCiQ57Tbe16699lqdPHlSISEheuWVV6p80cz+u0u1+/v7+//Uq1cva7r0AnlFygbZ+aOeeFtBQYEWLlyonj176tNPP60wrb//X674olzVzfPkyZPlbkLb5xkTE+P0hnhZERERDjfrfLENfdVm1Mb/S3W3n7/X7666dBzw1N///nft37/fen/ttdc6Tffjjz9aN0bbtGmjFStWOB3KKjAwUDfccIM1NExRUZEeeeQRp3n+7W9/s3pW6t27t3744QeXAQJNmjTRHXfc4XavPJUJCQnR3LlzNWjQIJfnZ6GhobrzzjutoPS0tDQtXLjQ7XUsXbq0XACTVBJY/fjjj1vv3333XafLnzhxQs8884z1fvbs2ZoxY4ZDAJNUcv731VdfqUWLFrV62EJJeumllzRq1CiX7XVgYKCmTp2qN954Q1LJMdV+mKGKFBYWau7cuZo+fXq5cz77QApjjDZt2mS979ixo6dfQ506dbKmN2zY4PHyVeWLY2ltYb9PSLXj95z98GSPPPKIy/ZJkrp06aK///3v6tu3b7l5e/futb5f/fr19dNPP2ncuHFOf5tMmDBBixYtst7PmjXLq8PKtWrVygpEys7O1vvvv19h+tJ9UZKuvvrqcu1PWfn5+br++uv19NNPlxv2NikpSZ9//rm1z508edKh12J7zz77rPVww9ixY/XZZ585DXaKiYnRSy+9ZPW4c+jQIbfbDG8oLCzUrbfe6lCeyy67zO3lP//8c918881uvyo7l/j555+tnlGd9R540UUXWYG4R48etYIxfSkiIkLNmjWz3tsPPy7JIQBMKuntrKrsl7UPjIKjmjj/btu2rRUgl5aW5tYDTgAAoO4giAkAAKASH3/8sSZOnGi9Dw0N1Y033ujHEpXIyMiwpqs6hJlUcmPku+++k1TSQ8Ftt91WYfrIyEg9+OCD1vu33367XJo9e/ZY040aNVJISEil5cjKyrKm3QkUKJvOfvmaMHfuXKtniXvuuadKN6hKlS17bf7+/v4/XXjhhdb0unXr9J///Mdl2szMTP39738v91ltFhQUpNGjR+vf//63fvvtN6WlpamgoECpqan65ptvNG3aNOtmeEZGhiZMmODQS1xZ/v5/ueKLclU3T2f5ViXPsml9sQ191WbUxv9Ldbefv9fvrrp0HHBHRkaGfvzxR11xxRUO5wy33367hg8f7nSZZ5991pr+xz/+oQYNGlS4jqlTp1rH3q+++qpcINgvv/xitY82m03z5893q4cjf7DvyXHp0qVuLXPttddW2MPP5MmTrZt7f/zxh8N5Y6l33nnHCvJq0aKF7rjjDpf5xcXFuQwWq4vGjx9v1Qd3t3nfvn115ZVXVpru8OHDDsMSJiUleVy+pk2bWtNlb8D7ki+Opf6WlZWlm2++2eGc8bzzzlOHDh38WKoS3vo9N2fOHKsXmpkzZzoNxrE3ePBgnXvuuZJKeildt25dldftzPTp061p+yClslJSUqyA/ICAAF199dWV5h0dHV3u/N5eVFSUnnrqKev9hx9+qPT0dIc0BQUFVo96oaGh+ve//11p8NTjjz9uBYU5+/3rTcXFxTp69KgWLVqkAQMGWA9uBAUFae7cueWGL63ImjVr9OKLL7r9cnassDd//nxr+rzzzit3rI6IiNDFF1/sNL0v2feMdeLECYd5ZQNi3B2W2xn7ZQsKCmr9b0t/qYnz74CAAIchT2vyWAkAAHyP4eQAAABU8oRiaa9GpdLS0rR69WrrScNSzz77rMOTfv5iX4Zly5Zp+/btbvV4VJZ9TzWXX365W70JDRkyxJp21o26/dOP7l5ktb/Z407Qk+T41HtpT1I14ciRI9aNvvbt2+u+++6rVn72312q3d/f3/+nQYMGacCAAdaN6alTp6qwsLDcE8l79+7VlVdeqd27dzt8XpP1pCp++eUXp/tMfHy8hg0bpmHDhmn69OkaPXq0jh07pry8PE2bNk2bN29WYGBgueX8/f9yxRflqm6ezvKtSp5l8/XFNvRVm1Eb/y/V3X7+Xr+76tJxoKyHH37YZU8XpeLj43XnnXfq7rvvdjq/sLBQ33zzjaSSXibOP/98t9Y9ePBgbdu2TcYYrVixwmH4GPve+oYOHWr1IukPxcXF+vXXX7V+/XodOHBAGRkZ1hB3Za1fv96tPCdMmFDh/OjoaLVp00Z//PGHjDH6888/yw03+P3331vTl156aaVD/owfP17XXXddufpaW23cuFHr1q3T3r17lZGRUa6HoNJz3k2bNqm4uLjSIAZ3ez+xPw+OiIhQWFiYhyWXQ2DA4cOHPV6+qnxxLK0pDz30kENPiIWFhUpOTtYPP/zgEMTSqFEjvfjii/4oYjn2v+dee+01nX/++U7P5ypj/3vO3aEHhwwZoq+++kpSye+5008/3eP1unLRRRepUaNGOnr0qFatWqUtW7Y4bYMXLFhgtYXnnnuuWwF/Y8aMqXQot1GjRlnDrebm5mrlypUOvdatXbvW6jV46NChatSoUaXrTUxMVMeOHbV161b9/vvvSk9P99qQcoMHD640TYcOHfSPf/xDo0eP9so6qyI3N1cffPCB9b7sUHKlJk+ebAUvffrppzp+/Ljq16/v07LZBymXDSwq+z4yMtIr65FKAhErGi7xVFVT598NGjSwevusyWMlAADwPYKYAAAAVPKE4po1aypMEx0drTlz5jg8Le9PzZo1U79+/bRq1Sqlp6erV69emjRpksaOHasBAwYoIiLCrXxWrlxpTS9btsytbtHthxywHyKmVHZ2tjXtbjnCwsJ08uRJSSXDBLjD/maUJ72kVNfNN99sPeH5yiuvlLt546myN7fy8/PduuHlj+9vXy5//Z/eeust9enTR6mpqcrOztbll1+uBx98UP369VNYWJh27dqln376SQUFBYqIiNDZZ59t3aSp7ReZ3Qn6O+OMM/Tuu+9qxIgRkkp62Pj4448dnnouVVv3K1/Uo+rm6SzfquRZNl9fbENftRm+qC/+bjP8vX531aXjgKcCAwP15JNPatq0aS7TbNy40Tp3CA4Odhg6pyL2525lz0dWrVplTbtzg9gXCgsL9fzzz+u5557TgQMH3FqmbFC9K2UDkpyxP6Y4613DPmCqomGsSkVERKhr165au3atW2X0l/nz5+vxxx/X9u3b3UpfUFCg9PT0SnvnsB/StiJVOQ8uy3653Nxct4KsvMEXx9KaUjocZUV69eqlt99+W61ataqBElVu/PjxmjVrloqLi7VkyRJ17dpVV199tc477zx16dLFrYdLjh07ZtX1kJCQSoNKS23ZssWadvZ7rjqCg4M1depUq0ekN954Q//4xz/KpbPvpemaa65xK+8zzzyz0jSBgYHq06ePFdy1bt06hyAm+9+/Bw4c0M033+zWutPS0iSV/BY+cOCA14KYKtO4cWMtWLDA6VCClXnooYc0a9Ysr5Tjk08+sbZBXFycLrjgAqfpBg0apKSkJB04cED5+fl67733fN6TtX2gUkxMjMO8sr//7NtoT5XtIajsulCips6/7Y+V1fm/AgCA2ocgJgAAABeioqIUHx+v0047TcOGDdPkyZMVFxfn72I5eOONNzRkyBAdOXJEWVlZevnll/Xyyy8rKChIPXr00DnnnKNzzz1XQ4cOdflUb3JysjX9xRdfeFyGst21l2Uf8FSRqKgo6+a5u0/e2aerqSFiPvnkE2s4iqlTp2rQoEHVzrNs2XNycty6ee2P72+/Hn/9n1q2bKmff/5ZF198sTZt2iRJ2rlzp3bu3OmQrnHjxnr77bf1ySefWEFMNbUPP/TQQ+WGNrIXHx/v9k0mZ4YPH66zzjrL6gntiy++cBrEVFv3K1/Uo+rm6SzfquRZNq0vtqGv2gxf1Bd/txn+Xr+76tJxoKw+ffo43FjNysrSvn379PPPPysvL09FRUW65pprtHv3bs2ePdtpHvbnIseOHatSLyllz0fse8Np3bq1x/lVV15ensaMGaOvv/7ao+XcHZrGnZvnpcOPSnLa81NKSoo17W4vo0lJSbU2iMkYo2nTpunNN9/0eNnMzMxKg5iqMtyXu+fB3lquunxxLPWXwMBAxcTEKCkpSX369NH48eM1cuRItwKDakqnTp301FNP6c4775QxRtu2bdNdd92lu+66S/Xq1VP//v01cOBAXXjhhS573D106JA1nZ+f75X20xumT5+up59+WsYYLVy4UH//+98d2qSVK1dq69atkkrO2V0FxJTVvHlzj9PZt3WS4zFn48aN2rhxo1t52vPmNrvoooschpA8duyYdu3aZQXqHjlyRGeffbb++9//ut1ToS/YDw03YcIElw/yBAQE6Morr9STTz5pLefrICb73tbK9vpU9n3Z4eU8Yf9/Dw4OrvUPyPhLTZ1/++tYCQAAfI8gJgAAAHn3CcWa1LlzZ23YsEGzZ8/WggULrIt3hYWFWrt2rdauXatnn31WTZs21axZs5w+4Wp/wa8qioqKyn1m30W7uxet4uPjrW797W88VsS+y3Bfd1EvSSdPnrQuwDZo0EDPPPOMV/It2/vOkSNHKr2RJtX895ccy+rP/1O7du20fv16ffDBB/rPf/6j1atXKyUlRaGhoWrdurXGjRun66+/Xg0aNHB4yrumhoKcP39+hb2atWjRolpBTJI0bNgwK4ip9CZQWbV1v/JFPapunhEREeVuxpTtxSQ3N7fSwJKTJ086BCH4Yhv6qs3wRX3xd5vh7/W7qy4dB8oaNWqU03Oow4cP6//+7//07rvvSpIef/xxde/eXZdcckm5tNU9F5FKzn3s2e+H/giqePjhh60AJpvNpksuuUQXX3yxunXrpsTERIWHhzvc0C8NrHD3hpw3AjHse5Rwt8eg2hKg4sxrr73mEMA0cuRIXX755Tr99NOVlJSkiIgIh2FtWrZsaR2ri4uLK83f3Z4hqnIeXJb9cmFhYTXSC5Pkm2NpTdmzZ49atmzpl3VXx4wZM9S7d289+uij+u6776w24MSJE1qyZImWLFmiu+66S0OHDtVzzz1Xrhc2X7Sf3tC2bVsNHjxY3333nVJSUrR48WKHgHv78/PJkyc7tIcVcbetst8PywaH1rZtduuttzp9MGbjxo2aPHmyNmzYoPz8fF1++eVav3692rRp47V1u+vw4cMOQbkTJ06sMP2kSZOsIKbVq1dr27Zt6tixo0/Klp2d7dDbYZMmTRzml20Xfv/99yo/iPT7779b0y1atCg3v+ywrJ705Co59kbk7j5RG9XU+bf9sbI6wwQCAIDap2Z+AQMAAMCBOzdK3NW4cWM9//zzOnLkiL7//ns9+uijOu+88xy6Nj948KCmT5+uW265pdzy9hd7PvroIxljPH6VZX/h0N1hUTp06GBNuzOknSTt27fPmvbVRVF7R48etZ7ctdlsGj16tPr16+f0NXbsWIdlx44da8179NFHHeY1atTIoYcgd75/bm6uw1PFNfH9pdr1fwoICNBll12m//znP9q3b59ycnKUlpam3377TQ888IAaNGggSdq8ebO1TJ8+fby2fn9LSEiwpl3tZ7Xp/2XPF+XydZ7u5mufp7M8vMFXbUZd+b94wt/rd1ddOg64q0mTJnrrrbd07rnnWp/dcMMNTnuvsD8XOe2006p0LlI2kMq+d4Syw7/4Wl5enl544QXr/bx58/Tee+9pwoQJ6tixo2JiYhxuTrrb+5K32QcklfbCVhlfDNfirfNi++Dyhx9+WF988YUmT56srl27Ki4uziGASfLddrc/Dz558mSVApns9+2yN+R9qa60mbWBN3/PDRw4UEuXLtWhQ4f0/vvv65ZbbtHpp5/uELz27bff6owzztCKFSsclrVvP2NiYqrUfs6bN89r38Xe9OnTrWn7oKWsrCy9//771nt3h5KTqtZWle0tx36b3XLLLVXaZt7ojbcyp512mr7++murl6asrCyPtpU3vfXWWw4PLw0cOFA2m83lq2vXrg7L2/fi5G1r1651KFu/fv0c5iclJTn0zGU/3KynVq9ebU2fddZZ5eaX7SXR0/MP+/S1rRdwT9TUscRfx0oAAOB7BDEBAAB4gf2NKHeeyvTG059lhYaGauDAgXrggQf0+eefKzU1VV988YXDxbUXXnjB6pa+VOPGja1p+6ffqqNVq1bWdEpKiltPIHbq1MmaXrduXaXpCwsLraHEyi5fE1JSUvTLL7+4fK1fv94h/fr16615u3btKpefp9//t99+s6YDAwNdDjHhbfbl3LRpk1v13b6sNf1/SktLc+ilqH///jWy3r1791Z442Pv3r3VXof9zRlXT57W1v3K03JJldcj+88OHz7sVntWWZ6xsbEOwWKe7ptNmzZ1CCj1Jl+0Gb6oL/5uM/y9fk/UleOAJwICAvT6669bbdTx48f1+OOPl0vni3MR+zz37NnjlTzdtXr1autGZJcuXTR58uQK07t7g8/bSoN9JTn0YlERd9L547x4//792rFjh6SSG7/33ntvhekzMjJ8MoSWVFL37Httcnfb2jt48KA1XZO9C/niWFpX2Peg4q/fc40bN9Yll1yiOXPm6Ndff9Xhw4f1z3/+0+rVJCcnR9ddd125ZUplZGS4HeRTE8aNG2e1M1999ZW1L3zwwQdWG3n22Wd7dPwqGyzuyv79+61p+7ZO8s0xx1caNWrkEBT7/fffa8mSJTVejuoGIb311lteDfyz9+GHH1rTAQEBToOLBg8ebE0vXry4SgG5y5cvd2jP7fMsFR0d7dBrqyfnH2V/I1ZlCNPaoibOv4uLix3237rYEx8AAHCNICYAAAAvsL9JfezYsUrT29/09ZXg4GCNHDlSS5cudXgS8tNPP3VId8YZZ1jTZZ/srarGjRurUaNGkkouxm3fvr3SZewvAq5cubLSwKc1a9ZYF+nDwsJ05plnVqPE/mf//b///vtK0y9fvtya7t+/f40N3WG/ruzsbK1du7bC9Hl5eQ5Puw4ZMsSn5Svro48+UkFBgaSS4Rd79epVo+v3Jfsgh8TERKdpaut+ZV+uP/74Q4cOHaowfXJysnVzWnJej9q1a6ekpCTrvaf7kau6WZ1905f13Rdthi/qi7/bDH+v3xN15TjgqaSkJN12223W+3/961/lbhr36NHDKv/Ro0e1c+fOaq/XvieG7777rlp5eTp0W2mvjZLKDf3kzA8//OBxmbyhR48e1vQvv/xSafqcnByHoXRc8cd5sf0279ixY6XD8Pz0009uD93nKZvN5vB//+OPPzzOwz4Au3v37l4plzt8dSytCzypt/n5+W79vqmuhg0b6tZbb9Unn3xifbZ582bt3r3bep+QkOAwXPLPP//s83K5KyQkRFOmTJFUEnBQ2uOTfa9M06ZN8yhPd3rRKSoqcnhw5/TTT3eYb//79+eff/ZZW+AtY8eO1YABA6z3DzzwQI2u/7fffnNo+/v06aMzzjjDrVdpcOCBAwf07bffer1sx44dcwiwGjlyZLnekCQ5BP9lZmbqtdde83hdzz77rDUdHx+v8ePHO01nX98qO++0t23bNoeemOry79aaOP/esWOHFRwVFxfndHg/AABQdxHEBAAA4AX2T32V7YGnrNzc3HKBRL4UGhqqESNGWO+PHDniMP/888+3pj/66KNy86uqb9++1vSGDRsqTT9o0CDrgmNGRoY++uijCtPbD3swfPhwlz3ReFPLli3dHmKg7FOXe/bsqXDIhosuusiaXrp0aaVP7dvnYb+sr0VFRWno0KFOy+HMRx99ZA3XUr9+fZ1zzjm+LJ6DvLw8zZ4923p//fXX19i6fe3YsWMON7RcDWlRW/erdu3aqXPnztb7yp7utp/frVs3tW7dulwam82mMWPGWO8rq5srV660bkAGBgbqggsucJrOfv96//33KxwWKCcnRx988IHTZb3NF22GL+qLv9sMf6/fE3XlOFAVM2bMsIbzyc3N1VNPPeUwPzw83OGG1UsvvVTtdZ533nnW9LfffusQFOIp+14VSgNjK2I/BFRlvaIUFxfr1VdfrXLZqsP+2PHBBx9U2lPCf//7X7eGRvPkvDg5OVk//fRTpXlWxpNtLkkvv/xytddZEU/Pg8uyX8Y+L1/z1bG0LvCk3i5evFi5ubm+LZCdAQMGqH79+tb7in7PeaP99KZrr73Wmn7zzTe1ZcsWK9AqNjZWEyZM8Ci/xYsXKyMjo8I0X375pY4ePSrJeZD1gAEDrKG6Dhw4UKO/zavKfsjU9evXa/HixTW27rLn4atXr9aqVavceo0cOdJpPt5gjNGUKVMcAn9cBXideeaZDoFgM2fO9KgXxI8++shhm990002KiIhwmtY+KP3DDz90GOquIu+88441nZSUpDZt2rhdvtqmJs6/7Y+Tf6Uh4wEAQAmCmAAAALzA/mnOzz77TKmpqS7Tzpw5s8L57jpx4oTbXbLbd6df2kNSqb59+1o3sXJycjRp0iS3hn+TSp5CdjUUx/Dhw61pd25OBQcHa/r06db7mTNnurxR9vvvvztcCLvpppvcKm9t1qdPH+viW1FRke655x6XaV999VXrhlF0dHSlw9R424033mhNz5s3T5s3b3aa7uTJk5o5c6b1/tprr3UYqsOXjDG64YYbrCfVu3btWuuDmOwvwFekqKhI11xzjXUDJyQkxOUNoNq8X9nXo2eeecZlAOXhw4f1zDPPuFWu66+/3rqR/dVXX+mbb75xmq64uFh33XWX9X7ChAkuh2wYM2aM1StFWlqaQ2BcWY8++qjS0tIkSS1atHC4qehtvmgzfFVf/N1m+Hv97qpLxwFP1atXT3/729+s96+88opSUlIc0tx9993W9AsvvKClS5e6nb+z4YD69u1r3bA0xmjy5Mlut7NllQ7lJDkO8+WKfaDl8uXLKxx26umnn65SkIs3XHHFFVaA1p49e/Tcc8+5TJuenq4HH3zQrXztz4vfffdd5eXluUx7++23uxUYVplWrVpZPWb9/vvvDj3VlPX+++/rs88+q/Y6K+LpebC94uJiK8jDZrNp2LBhXi1bZXxxLK0L7OttRTfcMzIyKmyfPeHub8K0tDSH9qvs77kZM2YoMDBQkrRo0aJKAwbs+Xo4tfbt22vgwIGSpN27d+vqq6+25l1++eUuA0FcycjI0H333edyfnZ2tkO9HD9+fLmeeUJDQx16CLzxxhvdattLeeuhH08MGzbMYVjsxx57rEbWW1BQ4BBcM3HiRI+Wt0+/aNEiK1ClurKysnTZZZc5DK03adKkCnuRfe2116z6lpmZqREjRlTaG6wk/fjjjw7nWd26datwyNJrr73W2h937dqlf/7zn5WuY9euXQ7HYPtz17rK1+ffP/74ozVtf8wFAAB/EQYAAOAUNXDgQCPJSDIPPfRQtfIqLi42bdq0sfIbNmyYOX78uEOa7Oxsc8cddxhJJjQ01Eo7ZcoUp3kuW7bMSjNw4MBy8998803Tpk0b8/TTT5s9e/Y4zSM3N9e88MILxmazWXmtWLGiXLpNmzaZqKgoK80ZZ5xhVq1a5fL7/vHHH+aRRx4xCQkJ5tNPP3WaZteuXVZ+7du3d5mXvdTUVBMXF2ctN3z4cJOamuqQZsOGDaZly5ZWmsGDB1eY5549e6y0ksybb77pVlmqq+x6Xf2P7C1dutRhmbvvvtvk5+c7pHn//fdNeHi4lebhhx+uMM8333zT43K44+yzz7bybNmypdmwYYPD/NTUVDN8+HArTf369c2JEydc5ufJ/+mrr74yM2fONLt27XI6f+fOnWb06NFWXuHh4Wb16tWVfqcWLVpUul/6UpcuXcytt95q1q5d6zLNxo0bzaBBg8rVk4r4Yr/yhvz8fId2s2fPnmbv3r0Oafbu3Wt69uzp0JYUFBRUmO+kSZOs9PHx8WbZsmUO87OyshzShISEmB07dlSY5xtvvGGlDwgIMHPmzDFFRUXW/KKiIjNnzhwTEBBgpZs/f75nG6QKfNFm+Kq++LPN8MX6jfFNm1FXjgNVOYdKTU11ONdw1nZNmTLFYd98/PHHTWZmptP8cnJyzKJFi8yYMWNMnz59nKb59ddfHc65evbs6fL85tChQ+bpp582Tz31VLl5hYWFJiIiwsqnsmNKUVGRadq0qcN+dPDgQYc0ubm55sEHHzSSTGRkpMP/yBV30tiz/z+VbQtL3XfffQ7t23PPPefQvhlTsr/169ev3Dmsq/0uOzvbREdHW+kmTpxoTp486ZDm2LFjVltsn6er+mRfj13tb2eeeabD/3rbtm0O84uKisy//vUvExwcbAIDA01YWFil+4X9fu7JvpOVlWXtp9HR0SYvL8/tZVevXm2ts2/fvhWmtf+9UNH/2VO+OJba10dnv208VZVz7Yr8+OOPDvm98MIL5dJs3brV9OrVq1y9dbXd7ds0Z/vL4MGDzejRo82HH35osrOzneZx4MABc9555zmcCznz0EMPWWlsNpuZMWOGSUlJcZq2oKDAfPXVV2bixImmSZMmzjeIE1Xd5m+99ZbDcqWvis557dnXnZCQEOsYUna/OnDggEPa8PBwl/UyMzPTdOnSxUrbpEkT88EHH5Rr/0qlpKSYV155xfTs2dPMmDHDaRpPjrdV2W+//PJLh+W++OILp+m8eZ3j448/dqhX+/bt82j5kydPOhwP3njjjWqVt/RY3axZM4dt0b9/f5Obm1tpeebPn+9wbaRhw4bmzTffdLrssWPHzIMPPmjVOUmmXr16ZvPmzZWu59Zbb3XYbg888IDJyMhwmvazzz4ziYmJDuepaWlpla7DXnXbw7pyzcBe586dreW2bNnilfICAIDagyAmAABwyvLmxT1jjPnggw8cLvzExsaacePGmWuvvdaMGTPGuimcmJhoZs+eXemNGHeCmOzX17x5c3P++eebq6++2lx99dVm1KhRpn79+g5prrzySpfl//TTTx1u0Ekybdq0MRMmTDDXXXedmTJlijnvvPMcbspJchnEZIzjzSR3Lyx9+eWXJigoyFouIiLCjBkzxkybNs0MGjTI4aJj06ZNy90ULKsuBTEZY8wDDzzgsFxiYqK59NJLzZQpU0zXrl0d5g0fPrzSgA5fXZDcv3+/SUhIcLg4O2jQIDNt2jQzZswYh7oUFBRkli5dWmF+nvyf3n33XYcbORdffLG59tprzeWXX25OP/10h3zCwsLM119/7dZ38ncQk/36GzRoYIYNG2YmTZpkrrvuOnP55Zc7XKgtfY0ZM8YUFhZWmre39ytvWb9+vUNQQ3BwsBk5cqSZNm2aOffcc01wcLA1LyYmxmzatKnSPNPT0x1uSkklgZlXXXWVufjii029evUc5s2bN8+tstrfrC1tH6+88kpz5ZVXOgRjSTJXXXVVdTeN27zdZhjjm/rizzbDF+s3xndtRl04DlT1HOruu++2louKijLHjh1zmJ+bm2tGjBjhUN6IiAgzePBgM2XKFHPttdeaSy65xPTq1cshgKBXr14u1/nWW2851GdJpkOHDuayyy4z1113nbnsssvMaaedZgUh3nrrrU7zueKKKxzKNG7cOHPbbbeZGTNmmBkzZpjZs2c7pJ87d67DOiMjI83w4cPNNddcY8aOHevQFr399tsOaV1xJ409d4KYcnNzTd++fR3ybtq0qbnsssvMNddcY4YMGWJtvzPPPNNceeWVVrqKgjWfeuophzwbNWpkLr30UjN9+nQzcuRIa5/r2rWrmTFjRqX1yZ0gpqVLlzoEkwYHB5tBgwaZq6++2lxyySUObcDs2bPdClCqahCTMcZcfvnl1rKff/6528vde++91nJz5sypMK2vgph8cSyt7UFMxhiHIHhJpmPHjmbq1KnmqquuMv3797fq19SpU93avyoLYiobnNOzZ09z6aWXWue1AwYMcKjTgYGBLgNXiouLHdZXmmf//v0dzifPPPNMh8DJ+Ph4t7dPVbd5bm5uud+lPXr0cHu99tvpqaeess4PGzRoYMaPH2+mT59uRowY4RBsIsm88sorFea7a9cu06pVK4dlGjRoYM4//3xzzTXXmGnTppmxY8eaDh06OPwf/BXEZIwxZ5xxhrVc//79naax3159+vQxN910k9uvO++80yGvsWPHVnu/nTx5spXHOeec41F5b7jhBnPllVea0aNHl/tflb6mT59usrKy3C7Pe++9V66uxMTEmJEjR5qrr77aTJo0yZxzzjkOv0MkmaSkJLcCmIwxJi8vzwwePNhh+fDwcIfzmXHjxpW7thIXF2fWrFnj9ncpVVuDmHxx/m2MMdu3b7eW69mzp1fKCgAAaheCmAAAwCnL20FMxhjz8MMPO72wVvrq0KGD+f333926EVNZENOHH37ocCO5oldAQIC58cYby/XmUNb69eutp4vdebVs2dKsW7fOZX6vv/56lbbx4sWLTYMGDSpct7Mn7J3ZvXu3w3ILFixwuxzVUdULicXFxebRRx8td9G07Ouyyy4z6enpleZX9iaqp0/PVmTr1q2mR48eFZazYcOG5rPPPqs0r6oGMVX06t27t/n111/d/j7Nmze3lr366qvdXs5b7G+UVvaKiIgws2fPdvm0uDPe3K+86eeff3Z5U6L01bp1a7Ny5Uq38zx48KAZMmRIhXlGRUWZuXPnup1nXl6eufnmmytsd202m7nlllsqbWu9ydttRilf1Bd/tRm+WL8xvmsz6sJxoKrnUEePHnW4ef7AAw+US1NYWGgefPDBcoHVrl7BwcHmpptuqnC93377baXtTOnr/vvvd5rH3r17TZMmTVwu16JFi3LL2Pdy5OwVFhZm/v3vfxtj3AtQcieNPXeCLIwx5sSJE5W2mf379zeHDh1yCOZatGiRyzyLiorMNddcU2Ge/fr1MwcOHHDoQaY6QUzGGPPyyy+XC1qzfwUEBJiZM2ea4uJinwcx2fes5kmgY7t27az64aonnVLfffedw/f74YcfPCpjRbx9LD3nnHOs5YYMGVLt8vkiiOnYsWOmd+/eFX7nadOmmdzcXK8EMZ1//vlutUtSSSDgxx9/XOl3eP7558sFmbl62Ww2M2bMGLe3T3W2+W233eaw7L/+9S+3ly27rT/++GMTExNTYdv60ksvuZX3sWPHzIQJE9z+XR0XF+cyaK8mgpiWLFnisKyzoA/77eXpKzY21sonNTXVIdjntddec7uc9r7++muHOrd79+5qlzcwMNCcf/75bge9lLVhwwaHHoAqegUFBZnrr7/eHD161KN15Ofnm//7v/8rFzDl6tWvXz+zffv2Kn2f6raHdeWaQanHHnvMWtZZr3kAAKDuI4gJAACcsnwRxGRMyQ35yy+/3CQlJZmQkBDToEED069fP/PPf/7TGhLFG0FMxhhz+PBhs2DBAnPdddeZfv36mUaNGpmQkBATEhJiGjZsaAYMGGDuvvtut58YLPXVV1+ZG264wZx22mmmQYMGJigoyERGRpqWLVuac88918ycOdOsWLHCFBcXV5hPTk6OadiwoZFkmjVr5lHAxdGjR82TTz7p8L2aNWtmRo4caebPn+92kIB9F/ixsbHlhvnzlepeSNyyZYv5v//7P9O1a1cTGxtrIiIiTJs2bczEiRPNN99843Y+9jcMnD35Wl15eXlm/vz5ZuTIkaZZs2YmJCTENGrUyPTr18889dRTld58K+VJQEJmZqZZtGiRufnmm02fPn1MUlKSCQ0NNXFxcaZTp05mypQp5rPPPvOovh0/ftzhCevvvvvO7WW9Zd++fea9994zt956qzn77LNN+/btTXx8vAkKCjIxMTGmdevWZty4ceb55593u5v9sry1X3lbZmamefHFF83AgQNNQkKCCQkJMQkJCWbgwIHmxRdfdDmcVEWKi4vNf//7XzNu3DjTsmVLExoaauLj403Pnj3NzJkzzZ9//lmlsv7yyy/muuuuMx06dDBRUVEmKirKdOjQwVx33XVuDVvoK95qM+z5or74o83wxfpros2ozceB6pxDlQ6tW3pcdtWeHT161DzzzDNm5MiRpnnz5iYiIsIEBweb+Ph4c/rpp5spU6aYefPmuX1TMT8/3yxYsMBccsklpnXr1iYqKsoEBwdb52m33357pQEgR44cMQ8++KA544wzTL169RyCZZwFMRlTMkTVpZdeapo2bWpCQkJMfHy86d69u7n77rsdblba12dX3Eljz90gplLvv/++GT16tGnSpIkJCQkxiYmJZujQoWbevHnW/j5y5EiP8lyyZIm58MILTZMmTUxwcLBp0qSJGTx4sHnjjTesPL0ZxGRMydCrV111lWnZsqUJCQkxsbGxpnPnzubmm282v/32m5XO10FMxhjTrVs3I5UEH7szPND3339vrW/atGmVpv/nP/9ppW/Tpo1bve15wlvH0uLiYoeeeDwJInbFF0FMxpS0FS+99JI5++yzTf369U1ISIhp0aKFGT9+vEPvnt4IYiouLja//vqreeqpp8zFF19sOnfubGJiYkxgYKCJiIgwLVq0MBdccIF5+eWXPQpEzsjIMC+++KK56KKLTKtWrUxUVJQJCgoy9erVM926dTOXXXaZ+fe//+1xoEJ1tvkPP/xgLRceHu7Ruayzbb13715zzz33mG7dupnY2FgTHh5u2rdvb2655ZYqBYJs2rTJ3HfffaZ///7WuWhYWJhp0qSJOeuss8wtt9xiFi9ebHJyclzmURNBTMYYh0C7yno28vRlH8T0wgsvWJ+HhoZW+fdHYWGhQ288Zdv5ispbej2lTZs2ZsCAAebmm282b775ptm/f3+VylLW6tWrzQMPPGDOPPNM06xZMxMWFmaioqJM69atzYgRI8yzzz5b7bblwIED5oknnjDnnnuuad68uYmMjDTBwcGmUaNG5vTTTzd/+9vfzLffflutdVS3Pawr1wyMKWk3W7dubdXXqvxOBAAAtZ/NGGMEAAAA+Mjjjz+u+++/X5K0aNEiXXTRRTW6/ltvvVXPP/+8JOnRRx/VAw88UKPr97fu3btr48aNkqQff/xRZ511lp9LVDstWrRI48aNkyQNHTpUS5cu9XOJANRmdanN4DgAb2ratKmSk5MlSYcPH1bjxo39XKLa7Z133tGVV14pSXruued02223VZj+0ksv1QcffKDAwED9/vvv6tixY4XpL7zwQi1evFiStHDhQk2cONEr5fa2devW6fTTT5ckdejQQZs3b1ZgYKCfS4Wa9PDDD2vWrFmSpIkTJ2rhwoVuLzto0CAtX75ckrRs2TINGjTIByUETl116Vzxiy++0KhRoyRJ9913n2bPnu3nEgEAAF8I8HcBAAAA8Nd2yy23qGHDhpKkJ598ssbX/91330mSGjVqVOmNo7+a1NRUbdq0SZJ03nnn1eqLkf5WWk+kksA7AKhIXWkzOA7Am3766ScrgKlZs2YEMLnhsssuU5cuXSRJzz77rAoKClym3bVrl/773/9KKgnyqCyAqaioSD/88IMkqWvXrrriiiu8VGrvs28zH3nkEQKYTjHGGM2bN896P336dP8VBoCDunauWHpNKS4uTnfeeaefSwMAAHyFICYAAAD4VFRUlB555BFJ0qpVq/TVV1/V2LqPHj2qzZs3S5LuvfdeRUVF1di6a4Nly5bJGCObzcYTipUovbl24YUXqm/fvn4uDYDarq60GRwH4C35+fm6/fbbrfe1OWCmNgkICNAzzzwjSdq/f7/mzp3rMu3s2bNVVFSkiIgI69y5Ir/99pvS0tIklfQ2GhBQey/zlraZPXv21IQJE/xcGtS0Tz75RHv37pUkde7cWeecc45/CwTAUpfOFX/44QerV7YHHnhAcXFx/i0QAADwmdr76xYAAAB/Gddee601hMTdd9+t4uLiGllv6QW5Zs2a6YYbbqiRddYmpTeMxo8fr549e/q5NLXXkSNHtGXLFgUEBOixxx7zd3EA1HJ1qc3gOAB33HDDDZo7d64yMzOdzv/99981ZMgQrV27VlJJgPqNN95Yk0Ws00aOHKkLL7xQkjRr1ixlZ2eXS7NlyxYtWLBAUsnwOM2bN68039L9u0+fPjU+XLMnCgsL9eOPP0qSHnvsMdlsNj+XCDXp+PHjuuuuu6z3p1rPuEBtV5fOFe+55x5JUqdOnXTLLbf4uTQAAMCXbMYY4+9CAAAAAAAAAKh5gwYN0vLlyxUaGqoePXqoXbt2ioqKUkZGhjZu3KjNmzer9PKhzWbTG2+8oauuusrPpQZQWz3yyCM6fvy4UlNT9cUXX+j48eOSpA4dOmjTpk0KDg72KL/SNkoqeUhl0KBB3i4yAAAAgFokyN8FAAAAAADUbjt27NCcOXOqnc8jjzyi+vXre6FEdc9bb72lVatWVSuPdu3a6dZbb/VSiQDAUV5enn755Rf98ssvTufHxcXpxRdfZCg5ABWaO3eu/vzzT4fPIiIitHDhQo8DmAAAAACceghiAgAAAABU6ODBg3rxxRernc8dd9xxygYxLV26VPPnz69WHgMHDiSICYDXvffee1q0aJGWL1+uP/74Q6mpqTp27JgkKT4+Xl27dtXw4cN19dVXKy4uzr+FBVBn2Gw2NWjQQIMHD9bMmTPVpUsXfxcJAAAAQB1AEBMAAAAAAABwimrSpIluuOEG3XDDDf4uCoC/gL1793o1v++//96r+QEAAACo3WymdFB7AAAAAAAAAAAAAAAAAPCDAH8XAAAAAAAAAAAAAAAAAMCpjSAmAAAAAAAAAAAAAAAAAH5FEBMAAAAAAAAAAAAAAAAAvyKICQAAAAAAAAAAAAAAAIBfEcQEAAAAAAAAAAAAAAAAwK8IYgIAAAAAAAAAAAAAAADgVwQxAQAAAAAAAAAAAAAAAPArgpgAAAAAAAAAAAAAAAAA+BVBTAAAAAAAAAAAAAAAAAD8iiAmAAAAAAAAAAAAAAAAAH5FEBMAAAAAAAAAAAAAAAAAvyKICQAAAAAAAAAAAAAAAIBfEcQEAAAAAAAAAAAAAAAAwK8IYgIAAAAAAAAAAAAAAADgVwQxAQAAAAAAAAAAAAAAAPArgpgAAAAAAAAAAAAAAAAA+BVBTAAAAAAAAAAAAAAAAAD8iiAmAAAAAAAAAAAAAAAAAH5FEBMAAAAAAAAAAAAAAAAAvyKICQAAAAAAAAAAAAAAAIBfEcQEAAAAAAAAAAAAAAAAwK8IYgIAAAAAAAAAAAAAAADgVwQxAQAAAAAAAAAAAAAAAPArgpgAAAAAAAAAAAAAAAAA+BVBTAAAAAAAAAAAAAAAAAD8iiAmAAAAAAAAAAAAAAAAAH5FEBMAAAAAAAAAAAAAAAAAvyKICQAAAAAAAAAAAAAAAIBfEcQEAAAAAAAAAAAAAAAAwK8IYgIAAAAAAAAAAAAAAADgVwQxAQAAAAAAAAAAAAAAAPArgpgAAAAAAAAAAAAAAAAA+BVBTAAAAAAAAAAAAAAAAAD8iiAmAAAAAAAAAAAAAAAAAH5FEBMAAAAAAAAAAAAAAAAAvyKICQAAAAAAAAAAAAAAAIBfEcQEAAAAAAAAAAAAAAAAwK8IYgIAAAAAAAAAAAAAAADgVwQxAQAAAAAAAAAAAAAAAPArgpgAAAAAAAAAAAAAAAAA+BVBTAAAAAAAAAAAAAAAAAD8iiAmAAAAAAAAAAAAAAAAAH5FEBMAAAAAAAAAAAAAAAAAvyKICQAAAAAAAAAAAAAAAIBfEcQEAAAAAAAAAAAAAAAAwK8IYgIAAAAAAAAAAAAAAADgVwQxAQAAAAAAAAAAAAAAAPArgpgAAAAAAAAAAAAAAAAA+BVBTAAAAAAAAAAAAAAAAAD8iiAmAAAAAAAAAAAAAAAAAH5FEBMAAAAAAAAAAAAAAAAAvyKICQAAAAAAAAAAAAAAAIBfEcQEAAAAAAAAAAAAAAAAwK8IYgIAAAAAAAAAAAAAAADgVwQxAQAAAAAAAAAAAAAAAPArgph84OjRo/rss880c+ZMnXfeeWrQoIFsNptsNpumTp3qk3W+++67GjFihJo0aaKwsDC1aNFCEydO1MqVK93O4+TJk3rqqafUp08f1a9fX5GRkerYsaNmzJihP//80yflBgAAAAAAAAAAAAAAAGzGGOPvQvzV2Gw2l/OmTJmiefPmeW1dOTk5Gj9+vD7//HOn8wMCAjRz5kw99NBDFeazc+dOjRo1Sjt27HA6PyYmRm+//bbOP//8apcZAAAAAAAAAAAAAAAAsEdPTD7WvHlzjRgxwmf5X3311VYA0+DBg/Xxxx9r9erVeuONN9SmTRsVFxdr1qxZevXVV13mkZmZqdGjR1sBTNOnT9e3336rn3/+WbNnz1ZUVJQyMjJ06aWXav369T77LgAAAAAAAAAAAAAAADg10ROTDzz00EPq06eP+vTpo8aNG2vv3r1q1aqVJO/2xPTdd99p6NChkqQLLrhAixYtUmBgoDU/NTVVvXr10r59+xQXF6fdu3erXr165fKZOXOmHn30UUnSU089pTvvvNNh/s8//6yBAweqsLBQAwcO1Pfff++V8gMAAAAAAAAAAAAAAAASPTH5xMMPP6zzzz9fjRs39ul6nnnmGUlSUFCQXnrpJYcAJklq0KCBnnzySUlSWlqaXn/99XJ5FBQU6Pnnn5ckderUSTNmzCiXpn///po2bZokafny5VqzZo1XvwcAAAAAAAAAAAAAAABObQQx1VGZmZn69ttvJUnDhg1TUlKS03Tjxo1TTEyMJGnRokXl5i9btkzp6emSSnqJCghwXiWmTp1qTTvLBwAAAAAAAAAAAAAAAKgqgpjqqDVr1ig/P1+SNHDgQJfpQkJC1K9fP2uZgoICh/k//fSTNV1RPr1791ZERIQkacWKFVUuNwAAAAAAAAAAAAAAAFBWkL8LgKrZsmWLNd2xY8cK03bs2FFff/21CgsLtWPHDnXu3NnjfIKCgtS2bVtt3LhRW7du9bi8Bw4cqHB+bm6utm3bpsaNG6thw4YKCqJqAgAAAAAAAPC+wsJCpaSkSJK6deumsLAwP5cI8K/c3Fxt2rRJkrg+DwAAALf54rcVZ6J1lH1QkKuh5Eo1a9bMmt6/f79DEFNpPpGRkYqLi6s0n40bNyolJUV5eXkKDQ11u7z2ZQAAAAAAAACA2mD16tXq06ePv4sB+NWmTZvUt29ffxcDAAAAdZi3flsxnFwdlZmZaU1HRUVVmDYyMtKazsrKcppPZXlUlg8AAAAAAAAAAAAAAABQVfTEVEfl5uZa0yEhIRWmte8xKScnx2k+leVRWT6V2b9/f6Xz+/fvL0n67LPP1Lp1a4/yB7wpOztbH330kSRp3LhxDgF8gD9QJ1GbUB9Rm1AfUdtQJ1GbUB9R21AnUZvs3r1b559/vqSSobOAU539frB69WolJCTUyHozMzO1cOFCSdKkSZMUHR1dI+vFXxv1Ct5GnYK3UafgC/6qV4cOHbJ69PTWbyuCmOoo+7EE8/PzK0ybl5dnTYeHhzvNp7I8KsunMpUNeWevdevW6tSpk0f5A96UkZGh2NhYSVL79u0VExPj5xLhVEedRG1CfURtQn1EbUOdRG1CfURtQ51EbRUUxCVywH4/SEhI8Oh6fnXYHxuaNm3KsQFeQb2Ct1Gn4G3UKfhCbahX3vptxXBydZR95FxlQ7tlZ2db02WHjSvNx53h4SrKBwAAAAAAAAAAAAAAAKgqgpjqKPsnIQ4cOFBhWvuh3Jo1a+Y0n+zsbKWlpbmVT8OGDR2GlgMAAAAAAAAAAAAAAACqgyCmOqpz587W9LZt2ypMWzo/KChI7dq1q1I+hYWF2rVrlyQx1BsAAAAAAAAAAAAAAAC8iiCmOqpPnz4KCQmRJC1fvtxluvz8fK1atcpaJjg42GH+WWedZU1XlM/atWut4eQGDBhQ5XIDAAAAAAAAAAAAAAAAZRHEVEdFR0dr6NChkqSlS5e6HFLuo48+UkZGhiRp7Nix5eYPGjRIsbGxkqT58+fLGOM0n3nz5lnTzvIBAAAAAAAAAAAAAAAAqoogplpq3rx5stlsstlsmjVrltM0d9xxh6SSod5uuukmFRUVOcxPTU3V3XffLUmKi4vTNddcUy6PkJAQ3XLLLZKkrVu36plnnimXZuXKlXrjjTckSQMHDlSfPn2q/L0AAAAAAAAAAAAAAACAsoL8XYC/op9++kk7d+603qemplrTO3fudOjVSJKmTp1apfUMGTJEl112md577z0tXrxYw4cP12233abExERt2rRJs2fP1r59+yRJTz75pOrVq+c0nzvvvFPvv/++tm/frrvuuks7d+7UZZddpvDwcC1btkyPP/64CgsLFR4ern/+859VKisAAAAAAAAAAAAAAADgCkFMPvD6669r/vz5TuetWLFCK1ascPisqkFMkjR37lxlZGTo888/17Jly7Rs2TKH+QEBAXrwwQd17bXXuswjOjpaS5Ys0ahRo7Rjxw69+uqrevXVVx3SxMTE6O2331aPHj2qXFYAAAAAAAAAAAAAAADAGYaTq+PCw8O1ZMkSvf322xo+fLgaNWqkkJAQNWvWTFdccYV++uknl8PR2Wvbtq3WrVunJ598Ur1791ZcXJwiIiLUoUMH3X777dq4caPOP/98338hAAAAAAAAAAAAAAAAnHLoickH5s2bV27IOE9NnTrVox6arrjiCl1xxRXVWmdkZKTuuusu3XXXXdXKBwAAAAAAAAAAAAAAAPAEPTEBAAAAAAAAAAAAAAAA8CuCmAAAAAAAAAAAAAAAAAD4FUFMAAAAAAAAAAAAAAAAAPyKICYAAAAAAAAAAAAAAAAAfkUQEwAAAAAAAAAAAAAAAAC/IogJAAAAAAAAAAAAAAAAgF8RxAQAAAAAAAAAAAAAAADArwhiAgAAAAAAAAAAAAAAAOBXBDEBAAAAAAAAAAAAAAAA8CuCmAAAAAAAAAAAAAAAAAD4FUFMAAAAAAAAAAAAAAAAAPyKICYAAAAAAAAAAAAAAAAAfkUQEwAAAAAAAAAAAAAAAAC/IogJAAAAAAAAAAAAAAAAgF8RxAQAAAAAAAAAAAAAAADArwhiAgAAAAAAAAAAAAAAAOBXBDEBAAAAAAAAAAAAAAAA8CuCmAAAAAAAAAAAAAAAAAD4FUFMAAAAAAAAAAAAAAAAAPyKICYAAAAAAAAAAAAAAAAAfkUQEwAAAAAAAAAAAAAAAAC/IogJAAAAAAAAAAAAAAAAgF8RxAQAAAAAAAAAAAAAAADAr4L8XQCgrLSTBTqWlefxcpGhQQoLDnQ673h2vowxVSpPeEigIkKc7yppJ/NVVFy1fEODAxUV6jzf9JwCFRYVVynf4KAAxYQFO52XkVuggsKq5RsUGKDYcOf5ZuUVKq+gqEr5BgbYFBcR4nTeyfxC5eRXLV+bzab6kc7zzS0oUnZeoctlM7PzlVNcUpeOZ+erIMCxPsZHhTpdLq+wSFm5rvOtTL2IEAUE2Mp9nl9YrMzcgirnGxserKDA8jGrhUXFSs+per7RYcEKCSqfb3Gx0YmT+VXONyosSKFBzvflqrQNpWgjStBGlKhOG1GZv3obUVkbWYo2ogRtRAlftREnKziO0UaU4Dzif2qijXC3jSxFG1GC84j/8WYbYV8fi10cx2gj/ofziBK+bCOOe9hGlqKN+J+/2nmEq+8DAAAAADh1EcSEWmfCG+sUFLPf4+UeubCLJp/Z0um8Yc8u1/Hsql3ovHVoO90+vL3TeRP+vVI7jmZVKd9J/Vro0Yu6Op137YK1+mXP8SrlO6pbE710ZS+n8+7570Z9vulwlfI9o1V9vX/dmU7nPfnFNi1c9WeV8m3XKErf/N9Ap/NeWb5bc77dUaV860eG6LcHhzud98Ha/Zr5yeZKcugkSZo355dyc/b+fbTTJZZuOaqb3vnNo3La+/WBYU4v4P365wld/tqqKuf79e3nqH3j6HKf707N1ojnfqhyvu9O76cz28SX+/zEyXz1emxplfN98YrTNfq0BKfzqpMvbUQJ2ogS1W8jXDs12gjXbWQp2ogStBElfNVGtGkQoREu5tFG/P/POY+w1FwbUXkbWYo2ogTnEf/j/TaipD5OPVmguNjyc2kj/ofziBK+byPcbyNL0Ub8z1/tPMLV9wEAAAAAnLoYTg4AAAAAAAAAAAAAAACAXxHEBAAAAAAAAAAAAAAAAMCvCGICAAAAAAAAAAAAAAAA4Fc2Y4zxdyGAAwcOqFmzZpKkn9duUPsOHTzOIzI0SGHBgU7nHc/OV1WrenhIoCJCgpzOSzuZr6LiquUbGhyoqFDn+abnFKiwqLhK+QYHBSgmLNjpvIzcAhUUVi3foMAAxYY7zzcrr1B5BUVVyjcwwKa4iBCn807mFyonv2r52mw21Y90nm9uQZGy8wpdLpuZmal58+ZJkqZOnaro6GiH+fFRoU6XyyssUlau63wrUy8iRAEBtnKf5xcWKzO3oMr5xoYHKyiwfMxqYVGx0nOqnm90WLBCgsrnW1xsdOJkfpXzjQoLUmiQ8335WFZelfOty21ERkaGXn75ZUnSDTfcIBMcThsh/7URlfmrtxGVtZGlaCNKcB5RwldtxMnsLL0z73VJJe1jTEzM/+bRRkjiPMJeTbQR7raRpWgjSnAe8T/ebCPs6+NtN05XXGxsuTS0Ef/DeUQJX7YRx0+ke9RGlqKN+J+/2nmEq+9TE7Zu3arOnTtLkvbv36+kpCS/lQWoDeyvz9fkPlH2mpf9bzqgqqhX8DbqFLyNOgVf8Fe98sV5pPMrFoAfxUUEe/0ihquLR9Xl6mJXdbm6OFddri4mVldUaJDLC6DVERES5PKCbXWEBQe6vMAsScHFeQoPKLlYWT8yRDFu1sfQoECFRrnOt6pCggJ8cmEvKNA3+QYE2Hx2IdJX+dJGlKCNKFFZG1FVf5U2oqptZCnaiP+hjShRnTYiuNj1DWfaiBKcR/xPTbQR1W0j7dFGlOA8okRV2gj7+hhgKx+cINFG2OM8ooRP24jIEK+1kaVoI0pwHgEAAAAA+KtgODkAAAAAAAAAAAAAAAAAfkUQEwAAAAAAAAAAAAAAAAC/IogJAAAAAAAAAAAAAAAAgF8RxAQAAAAAAAAAAAAAAADArwhiAgAAAAAAAAAAAAAAAOBXBDEBAAAAAAAAAAAAAAAA8CuCmAAAAAAAAAAAAAAAAAD4FUFMAAAAAAAAAAAAAAAAAPyKICYAAAAAAAAAAAAAAAAAfkUQEwAAAAAAAAAAAAAAAAC/IogJAAAAAAAAAAAAAAAAgF8RxAQAAAAAAAAAAAAAAADArwhiAgAAAAAAAAAAAAAAAOBXBDEBAAAAAAAAAAAAAAAA8CuCmAAAAAAAAAAAAAAAAAD4FUFMAAAAAAAAAAAAAAAAAPyKICYAAAAAAAAAAAAAAAAAfkUQEwAAAAAAAAAAAAAAAAC/IogJAAAAAAAAAAAAAAAAgF8RxAQAAAAAAAAAAAAAAADArwhiAgAAAAAAAAAAAAAAAOBXBDEBAAAAAAAAAAAAAAAA8CuCmAAAAAAAAAAAAAAAAAD4FUFMAAAAAAAAAAAAAAAAAPyKICYAAAAAAAAAAAAAAAAAfkUQEwAAAAAAAAAAAAAAAAC/IogJAAAAAAAAAAAAAAAAgF8RxAQAAAAAAAAAAAAAAADArwhiAgAAAAAAAAAAAAAAAOBXBDEBAAAAAAAAAAAAAAAA8CuCmAAAAAAAAAAAAAAAAAD4FUFMAAAAAAAAAAAAAAAAAPyKICYAAAAAAAAAAAAAAAAAfkUQEwAAAAAAAAAAAAAAAAC/IogJAAAAAAAAAACgjKNHj+qzzz7TzJkzdd5556lBgway2Wyy2WyaOnWqT9b57rvvasSIEWrSpInCwsLUokULTZw4UStXrvTJ+gAAAIDaJMjfBQAAAAAAAAAAAKhtGjduXGPrysnJ0fjx4/X55587fL5v3z69/fbbevfddzVz5kw99NBDNVYmAAAAoKbRExMAAAAAAAAAAEAFmjdvrhEjRvgs/6uvvtoKYBo8eLA+/vhjrV69Wm+88YbatGmj4uJizZo1S6+++qrPygAAAAD4Gz0xAQAAAAAAAAAAlDFz5kz16dNHffr0UePGjbV37161atXK6+v57rvv9N5770mSLrjgAi1atEiBgYGSpD59+mjMmDHq1auX9u3bp7vvvlsTJkxQvXr1vF4OAAAAwN/oiQkAAAAAAAAAAKCMhx9+WOeff77Ph5V75plnJElBQUF66aWXrACmUg0aNNCTTz4pSUpLS9Prr7/u0/IAAAAA/kIQEwAAAAAAAAAAgB9kZmbq22+/lSQNGzZMSUlJTtONGzdOMTExkqRFixbVWPkAAACAmkQQEwAAAAAAAAAAgB+sWbNG+fn5kqSBAwe6TBcSEqJ+/fpZyxQUFNRI+QAAAICaRBATAAAAAAAAAACAH2zZssWa7tixY4VpS+cXFhZqx44dPi0XAJyKiouLlZubq8zMTB0/flxHjx5VSkqKkpKSlJSUpKNHj+rIkSM6fvy4MjMzVVhY6O8iA8BfTpC/CwAAAAAAAAAAAHAqOnDggDXtaii5Us2aNbOm9+/fr86dO3u8DmcOHTpkTWdmZiojI8OtfKsrKyvL6TRQHdQrlDLGqLCwUIWFhQoNDVVAQPm+PXJycvTnn3+qqKhIhYWFKi4udppXaft88OBBh8+bNWumBg0aOF0mOTlZAQEBCgoKUmBgoIKCghxeNputmt8QdRXtFHzBX/UqMzPT63kSxAQAAAAAAAAAAOAH9jd+oqKiKkwbGRlpTXtyc8o++KkyCxcuVGxsrNvpvWXhwoU1vk789VGv/loCAwMVHBxsBQGVTlf0Wan169crNze3XJ5hYWHq0aNHlcu0dOlSnThxwum8M844o8JApcLCQhUUFDj8LZ1OT0/XyZMnq1wu1B20U/CFmqxX6enpXs+TICYf+/PPP/X8889ryZIl2r9/v0JDQ9WmTRtdcskluummmxQREVGlfPfu3atWrVp5tEyLFi20d+/ecp8PGjRIy5cvdysPY4xH6wQAAAAAAAAAAM7Z31QPCQmpMG1oaKg1nZOT47MyAYCvlfZQVDbo6OjRo057Q4qKilLXrl2rvD77gCZ71R0OztXy7vS0VBp45cyuXbtcBjF16dJFxhiXAVD20656lgKA2owgJh/69NNPNXHiRIeuV0+ePKm1a9dq7dq1ev3117VkyRK1bdu2RsrToUOHGlkPAAAAAAAAAACoXFhYmDWdn59fYdq8vDxrOjw83O117N+/v8L5hw4dUt++fSVJkyZNUtOmTd3OuzqysrKsngImTZpUaU9UgDuoV7VLcXGxsrOzlZWVpaysLOXl5amwsNBlpwnnnXeeQ7tYKjc3V1u3bq1yOS644ALFxcWV+9wYo/Xr1ztdxn7Yt9JhOZOSkhyGqRs/frxPyjts2DCPy+uMzWZTUFCQQkNDFRUVpZiYGIde/eAftFPwBX/Vq4MHD+qJJ57wap4EMfnIunXrdOmllyonJ0dRUVG69957NXjwYOXk5Oi9997Ta6+9pu3bt2v06NFau3atoqOjPcq/adOm2rRpU6XpnnjiCb3zzjuSpClTplSYtnfv3nrzzTc9KgcAAAAAAAAAAKga+3sDlQ0Rl52dbU17cmMqKSnJo/LExMS4nd5bSm+uA95Evap5hYWFSk9PV3p6utLS0pSVleXRKC8hISFO/2eeBG56kq8kdezY0RqqrvRl35NSRkaGli1bJqkkuKg0n9Lv5azHpeDgYDVp0kQFBQUOL3d7foqNjXVa3sqCXcsq7bGpoKBAWVlZCgwMVEJCgkd5wLdop+ALNVmv7Dv08RaCmHzk1ltvVU5OjoKCgvT111/rzDPPtOYNGTJE7dq101133aXt27frH//4h2bNmuVR/sHBwZV2m1hUVKTvv/9eUskPj7Fjx1aYPjIyslpdMQIAAAAAAAAAAPfZBxgdOHBAvXv3dpnWvkelZs2a+bRcAFAV6enp+v3336u8fEXDs5UKCAhwCDiq7BUUFKSAgACX62zcuHGVylrRcHHh4eFOR8ixDyqq6GU/fKi9goKCKpW1VGxsrMt5f/75p8LDwxUbG+ty/QBQEwhi8oHVq1frxx9/lCRNmzbNIYCp1IwZM/Tmm29q69atmjNnju6//34FBwd7tRxLly5VcnKyJGn8+PHVjlIGAAAAAAAAAADe07lzZ2t627ZtFaYtnR8UFKR27dr5tFwAUJYxRrm5uUpPT1d8fLzT+5oVBck4Y7PZHIKNAgMDXabr169fhWnqApvNppCQEIWEhFRp+ZCQEHXq1KnSIChXvV+5+v8UFBRo79691vuwsDDFxsZar/Dw8AqDtgDAmwhi8oGPP/7Ymr7qqqucpgkICNDkyZN17733Ki0tTcuWLdOIESO8Wo4FCxZY05UNJQcAAAAAAAAAAGpWnz59FBISovz8fC1fvlz33HOP03T5+flatWqVtYy3H4oGgLKMMcrOzraGh0tPT7eGM+vcubMaNmxYbpmgoCBFRkY6DH8plYwYUzpEWmhoqBW4FBgY6HZwDL0DlYzU06hRowrTGGNUVFRkBTTl5+crPT1deXl5LoOn0tPTHd7n5uYqNzdXR44ckVQSPGUf1BQZGUlQEwCfIYjJB3766SdJJcOz9erVy2W6gQMHWtMrVqzwahBTZmamFUzVsmVLnXPOOV7LGwAAAAAAAAAAVF90dLSGDh2qL774QkuXLtWBAwcchpgr9dFHHykjI0OSNHbs2JouJoBTQHFxsbKyshyCllwN75aWluY0iEmS6tWrp6CgIIegl7rce1JdY7PZFBQUpKCgIGuUngYNGlS4TNkgprLy8/OVkpKilJQUSSXBajExMdb/NyYmhqAmAF7jegBQVNnWrVslSW3btnUYo7Wsjh07llvGW/7zn//o5MmTkqRJkya5deDYtm2bzjjjDMXFxSksLExJSUm68MILtWDBgmqPsQoAAAAAAAAAwKlm3rx5stlsstlsmjVrltM0d9xxhySpsLBQN910k4qKihzmp6am6u6775YkxcXF6ZprrvFpmQGcGoqKinTixAnt3btXGzZs0IoVK7Ru3Trt3r1bx44dcxnAJFUc9NKmTRv16NFDrVq1Uv369QlgqgOioqI8+l8VFhbq+PHj2rNnj9avX19hXQEAT9ETk5fl5uYqNTVVkpw+LWGvXr16VpeK+/fv92o57IeSmzx5slvLHDlyxOoWUJIOHjyogwcPavHixXryySf1n//8R506dapSeQ4cOFDh/EOHDlnT2dnZ1hMlgD9kZWU5nQb8hTqJ2oT6iNqE+ojahjqJ2oT6iNqGOonapOwQN4ArP/30k3bu3Gm9L732L0k7d+7UvHnzHNJPnTq1SusZMmSILrvsMr333ntavHixhg8frttuu02JiYnatGmTZs+erX379kmSnnzySdWrV69K6wEAexs2bFBmZqbHywUHBysiIkLGGHrf+Yto3LixGjduXG4IwbS0tEo7uoiIiHA5xGlWVpZyc3MVGxvLMKgA3EYQk5fZH+yjoqIqTV8axOTNizf79u3T8uXLJUn9+/dX27ZtK0wfEBCgoUOHatSoUerevbvi4+OVmZmp3377Ta+88oq2bt2qLVu2aPDgwVq9erWaN2/ucZmaNWvmdtqPPvpIsbGxHq8D8IWFCxf6uwiAA+okahPqI2oT6iNqG+okahPqI2ob6iT8rbIhU4BSr7/+uubPn+903ooVK7RixQqHz6oaxCRJc+fOVUZGhj7//HMtW7ZMy5Ytc5gfEBCgBx98UNdee22V1wHg1JKXl6f8/HxFR0c7nR8TE+NWEFNYWJjD0HDh4eEEL/1F2Ww2RUVFKSoqSk2bNpUxRjk5OQ5DDObm5josU9E93cOHD+vgwYOSSu6J29ej0NBQn34XAHUXQUxeZt9wh4SEVJq+tIHOycnxWhneeustGWMkudcL00cffaS4uLhyn5999tm68cYbNX36dM2fP19HjhzRbbfdpo8++shrZQUAAAAAAAAA4FQXHh6uJUuW6J133tG8efO0YcMGpaWlqXHjxjr77LN1880368wzz/R3MQHUUsYY5ebmOgSb5OTkKDIyUr1793a6TGxsrBVgYi8iIsIh2CQsLMzXxUctZbPZFBERoYiICCUkJEgqCY6zr2fO7jGXsh95Jzs7W9nZ2UpOTpbkGBwXFxensLAwguMASCKIyevsD+T5+fmVps/Ly5NU8gPFW0qfZgsNDdWll15aafqKDi7BwcF6/fXXtWrVKv3xxx9atGiRDh48qKZNm3pUpsqGyzt06JD69u0rSRo3bpzat2/vUf6AN2VlZVn70aRJk9zqVQ3wJeokahPqI2oT6iNqG+okahPqI2ob6iRqk+3bt+uJJ57wdzFQB8ybN6/ckHGemjp1qkc9NF1xxRW64oorqrVOAH99ZYf9Sk9Pd3pfMjs7WwUFBU6H8irtQSc6OtohaIlhv1CR0NBQNWrUSI0aNaowXWFhYYU9feXm5io3N1dHjhyRVNI5iH09jIyMJKgJOEURxORl9l0yujNEXOn46966cLN69Wpt27ZNkjRmzJgKA5TcFRQUpGnTpumuu+6SJC1fvtzjH1FJSUlup42MjFRMTIxH+QO+EhUVRX1ErUKdRG1CfURtQn1EbUOdRG1CfURtQ52Ev0VGRvq7CAAAVElmZqaSk5OVmpqqwsJCt5ZJT09XgwYNyn0eEhKis846S4GBgd4uJqCCggLFxcUpIyNDxcXFlabPz89XSkqKUlJSJElNmzZV27ZtfV1MALUQQUxeFhYWpvj4eB07dkwHDhyoMO2JEyesIKZmzZp5Zf0LFiywpt0ZSs5dnTt3tqaddS0JAAAAAAAAAAAAwLuKi4uVkpKigwcPVtizjTOBgYEqKCiocD7gC+Hh4erevbuKi4uVmZnp0GtYUVFRpcvz0ANw6iKIyQc6d+6sH3/8UTt37lRhYaGCgpxv5tIekySpU6dO1V5vQUGB3nvvPUlSo0aNNHLkyGrnWYru+gAAAAAAAAAAAICalZaW5nBPsSLBwcEOQ3JFRUVxjw9+FRAQYNVHqfxQiGlpaU4D7UrTO5OXl6fQ0FCflRmAfxHE5ANnnXWWfvzxR2VnZ+vXX3/VGWec4TTd8uXLrekBAwZUe71LlizRsWPHJJWMm+0qeKoqtmzZYk0nJiZ6LV8AAAAAAAAAAAAAztWrV0/h4eHKyckpNy80NFRxcXFWkEh4eDhBS6jVbDaboqKiFBUVpaZNm8oYo5ycHIeemiS5DFLKzs7W2rVrVa9ePSUmJio+Pp46D/zFEMTkAxdddJGeeOIJSdKbb77pNIipuLjYGvotLi5OgwcPrvZ67YeSmzJlSrXzK1VYWKi5c+da78855xyv5Q0AAAAAAAAAAACcygoKCpSfn6/IyMhy82w2mxITE7Vr1y5JUkhIiBISEtSkSROFhYXVdFEBr7LZbIqIiFBERIQSEhIkldybdiU5OVmSdOLECZ04cUKhoaFKSEhQQkKCQkJCaqTMAHwrwN8F+Cvq27evzj77bEnSG2+8oZUrV5ZL849//ENbt26VJN16660KDg52mP/999/LZrPJZrNp6tSpla7z+PHjWrJkiSSpW7du6tGjh1tlXbZsmdLS0lzOLygo0DXXXGOV9YILLlCzZs3cyhsAAAAAAAAAAABAecYYZWRkaNu2bVq5cqV27NjhMm3jxo1Vv359de7cWWeccYZatmxJABP+slyNNlRYWKgjR444fJaXl6e9e/dq1apV2rp1q9LT02WMqYliAvARemLykTlz5mjAgAHKycnRiBEjdN9992nw4MHKycnRe++9p1dffVWS1L59e82YMaPa63vvvfeUn58vybNemObPn68xY8ZozJgxGjRokDp06KCYmBhlZWXp119/1auvvmoNJdeoUSPNmTOn2mUFAAAAAAAAAAAATkVFRUU6evSokpOTlZWVZX2enp6urKwsRUVFlVsmODhY3bp1q8liArVOdna2y6HjjDE6evSojh49qsjISCUmJqpRo0YuA6IA1F7stT7Ss2dPvf/++5o4caIyMjJ03333lUvTvn17LVmyRNHR0dVeX+lQcoGBgbryyis9WjYrK0vvvPOO3nnnHZdpunXrpvfee0+tWrWqVjkBAAAAAAAAAACAU83JkyeVnJysw4cPq6ioyGmaQ4cOqV27djVcMqBuiI2NVb9+/ZSSkqKDBw86BAHay87O1o4dO7R79241btxYiYmJTodqBFA7EcTkQxdccIE2btyoOXPmaMmSJTpw4IBCQkLUtm1bTZgwQTfffLMiIiKqvZ4dO3bol19+kSQNHz5cTZo0cXvZu+++Wz169NDKlSu1ZcsWpaSk6Pjx4woNDVXjxo3Vu3dvjR8/XmPHjlVgYGC1ywoAAAAAAAAAAACcCowxSk1NVXJystLS0ipM66qHGQD/ExgYqCZNmqhJkybKyMhQcnKyUlJSVFxcXC5tUVGRkpOTlZycrNjYWLVv394r9+YB+BZBTD7WokULPfvss3r22Wc9Wm7QoEFuj9fZrl27Ko/t2alTJ3Xq1Em33XZblZYHAAAAAAAAAAAA8D95eXk6dOiQDh06pPz8/ArThoWFKSEhQU2aNFFISEgNlRCo+2JiYhQTE6M2bdro8OHDSk5OVm5urtO0mZmZCg4OruESAqgKgpgAAAAAAAAAAAAAwAt27dqlgwcPVtoBQf369ZWYmKj69evTCxNQDcHBwWrWrJmSkpJ04sQJJScn69ixYw5pGjZsSBATUEcQxAQAAAAAAAAAAAAAXhAaGuoygCkoKEgJCQlKSEhQeHh4DZcM+Guz2WyqX7++6tevr9zcXKs3tIKCAiUmJrpcbt++fQoICFCTJk0UFET4BOBv7IUAAAAAAAAAAAAA4AWNGzfWnj17VFxcbH0WHR2tpk2bqmHDhgoICPBj6YBTQ1hYmFq1aqUWLVroxIkTiomJcZqusLBQ+/btU1FRkfbs2aNGjRopMTFR0dHRNVxiAKUIYgIAAAAAAAAAAACAShQXFyslJUXJyclq3769IiMjy6UJDg5Wo0aNdPToUQIiAD8LCAhQfHy8y/lHjx5VUVGRpJL9+/Dhwzp8+DCBh4AfEcQEAAAAAAAAAAAAAC6UHZpKkpKTk9WuXTun6Vu2bKk2bdowNBVQixljlJyc7HReZmamtm3bpp07dzIEJFDDOHICAAAAAAAAAAAAgB1jjE6cOKHk5GQdO3as3PwjR46oVatWTgOVQkNDa6KIAKqpbdu2Sk5OVmpqqowx5eYXFhZq//792r9/v+rXr6/ExETVr19fNpvND6UFTg0EMQEAAAAAAAAAAACApIKCAh0+fFjJycnKzc11ma6oqEgpKSlKSEiowdIB8Babzaa4uDjFxcUpLy/P2u/z8/Odpj9+/LiOHz+usLAwJSQkqEmTJgoJCanhUgN/fQQxAQAAAAAAAAAAADilZWRkKDk5WSkpKSouLq4wbWxsrJo2bar4+PgaKh0AXwoNDVWLFi3UvHlzpaamKjk5WWlpaU7T5ubmas+ePTp58qQ6duxYswUFTgEEMQEAAAAAAAAAAAA4JWVkZGjnzp3KzMysMF1gYKAaN26sxMRERUZG1lDpANQkm82mhg0bqmHDhjp58qSSk5N1+PBhFRUVlUubmJjohxICf30EMQEAAAAAAAAAAAA45WRmZmrdunUVpomMjFRiYqIaN26swMDAGioZAH+LiIhQ27Zt1apVKx09elTJycnKysqSJEVFRSk6OtrPJQT+mghiAgAAAAAAAAAAAHDKiYqKUr169XTixAmHz0t7Y0lMTFRMTIxsNpufSgjA3wIDA5WQkKAmTZooMzNTycnJqlevnst2ITs7WxkZGWrSpAltB1AFBDEBAAAAAAAAAAAAOOXYbDa1a9dOa9askTFGoaGhSkxMVJMmTRQSEuLv4gGoRWw2m2JiYhQTE+MyjTFGO3bsUHp6ug4fPqx27dopKiqqBksJ1H0EMQEAAAAAAAAAAAD4yyouLlZAQIDTeeHh4WrVqpUkqWnTpi7TAUBljhw5ovT0dElSRkaGfv31VyUlJalFixYKCiI0A3AHewoAAAAAAAAAAACAv6TU1FTt3LlTbdu2VYMGDZymadasWQ2XCsBfTVFRkXbv3l3u8wMHDujo0aMVtkEA/odQYgAAAAAAAAAAAAB/KXl5efr999+1efNm5eXlaefOnSoqKvJ3sQD8RQUGBqpjx44KCwsrNy8/P19btmzR77//rry8PD+UDqg7CGICAAAAAAAAAAAA8Jdgs9mUmJiorVu36tixY9bneXl5+vPPP/1YMgB/dfXr11fv3r3VokUL2Wy2cvOPHz+urVu3qmnTpk7nA2A4OQAAAAAAAAAAAAB/AZmZmerWrZsiIiJkjCk3PysrS8YYggcA+ExgYKBatmypRo0aaefOnTpx4oTDfGOMmjVrpgYNGigzM1MxMTF+KilQOxHEBAAAAAAAAAAAAKDOys/P1+7du3XkyBFFRESUmx8cHKw2bdqoUaNGBDABqBERERHq1q2bUlJStGvXLuXn5zvMDw8P186dO5WRkaE2bdooJCTETyUFaheCmAAAAAAAAAAAAADUOcYYHTp0SHv27FFhYaHTNImJiWrZsqWCg4NruHQATnU2m02NGjVS/fr1tXfvXh08eLBcmqNHjyo9PV19+/ZVQECAH0oJ1C4EMQEAAAAAAAAAAACoUzIzM7Vjxw5lZmY6nR8eHq6OHTsyVBMAvwsKClLbtm3VuHFjbdu2TSdPnnSYn5SURAAT8P+xJwAAAAAAAAAAAACoE4qKirRz50799ttvTgOYCgsLtWfPHnXo0IEAJgC1SnR0tNq3b6/du3dbvcdFRUWpadOmfi4ZUHsQxAQAAAAAAAAAAACgTrDZbDp+/LjTefXq1dOGDRt05MgR2Wy2Gi4ZAFTOZrPp6NGjWr9+verXr6927dq5bK+Ki4tljKnhEgL+RRATAAAAAAAAAAAAgDohICBAbdu2dfgsPDxcp512mlq2bKmCggI/lQwA3FdYWKgWLVpU2GPczp07tWHDBmVnZ9dgyQD/IogJAAAAAAAAAAAAQJ1Rv359NWzYUAEBAWrZsqV69+6tevXq+btYAOA1GRkZOnTokNLT0/Xrr79q9+7dKioq8nexAJ8L8ncBAAAAAAAAAAAAAMDe8ePHFRoaqsjISKfz27Ztq1atWik8PLyGSwYAvmWM0Y4dOxze79+/XykpKWrbtq3i4+P9WDrAtwhiAgAAAAAAAAAAAFAr5OXladeuXUpJSVFsbKy6d+8um81WLl1ISIgfSgcAvpebm+t0aMzc3Fz9/vvvio+PV9u2bRUWFuaH0gG+xXByAAAAAAAAAAAAAPzKGKMDBw5ozZo1SklJkSSlp6fryJEjfi4ZANSs8PBw9enTR82aNXMaxHns2DGtWbNG+/fvV3FxsR9KCPgOPTEBAAAAAAAAAAAA8JuMjAxt375d2dnZ5ebt3r1bDRo0UFAQtzUBnDoCAwPVunVrNW7cWDt27FB6errD/OLiYu3evVtHjhxRu3btFBsb66eSAt7F0R61TtrJAh3LyvN3MXAKy8zOV05xoCTpeHa+CgKoj/Av6iRqE+ojahPqI2ob6iRqE+ojahvqJFypFxGigIDyT5cDAE4NBQUF2rNnjw4dOuR0flBQkFq1aqXAwMAaLhkA1A6RkZHq3r27jhw5ot27d5cbZi47O1vr169XkyZN1Lp1awUHB/uppIB3EMSEWmfCG+sUFLPf38XAKa+TJGnenF/8XA6gFHUStQn1EbUJ9RG1DXUStQn1EbUNdRLl/frAMMVHhfq7GACAGmaMcXlDvhQ35AGghM1mU5MmTRQfH+8y8PPw4cNKTU1V69atlZCQ4IdSAt5BEBMAAAAAAAAAAACAGpGdne10aKRSkZGRDI0EAE4EBwerffv2atKkiXbs2KGsrCyH+YWFhcrMzCSICXUaQUwAAAAAAAAAAAAAfKqoqEh//vmnDhw4IGNMufkBAQFq2bKlmjZtqoCAAD+UEADqhpiYGJ1++uk6ePCg9u7dq6KiIkklQU6tWrXyc+mA6iGICQAAAAAAAAAAAIDPGGO0bt06ZWdnO53foEEDtWnTRmFhYTVcMgCom2w2m5KSktSwYUPt2rVLKSkpatOmDUNwos4jiAm1zofTeqp9hw7+LgZOYZmZmZo3b54kaerUqYqOjvZvgXDKo06iNqE+ojahPqK2oU6iNqE+orahTsKVehEh/i4CAKAG2Gw2JSQkaOfOnQ6fh4WFqW3btoqPj/dTyQCgbgsNDVXnzp2Vnp6umJgYl+ny8/MVHBwsm81Wg6UDPEcQE2qduIhgxUeF+rsYOIUFF+cpPKCk28X6kSGKoT7Cz6iTqE2oj6hNqI+obaiTqE2oj6htqJMAACAxMVGHDx9WVlaWbDabmjVrpubNmyswMNDfRQOAOi82NtblvMLCQm3cuFGhoaHq1KmTgoIIE0HtxYCyAAAAAAAAAAAAAHzKZrOpXbt2iouLU+/evdWqVSsCmADAx4wx2rJli7Kzs3X8+HGtX79eubm5/i4W4BJBTAAAAAAAAAAAAAC8ori42OW8mJgYde/eXRERETVYIgA4de3atUsnTpyw3mdnZ2vdunXKzMz0Y6kA1whiAgAAAAAAAAAAAFBtx44d0+rVq3Xy5El/FwUAIKlhw4YKDg52+Cw///+xd9/xVdX3H8ff547sHRIgEIYkGJYSWVJUQH1gC7j4iaMqo7gnlEorrRa7bIugtK7iADdW60LcFhARC8EwwgqEHSCMhOx1c+/vD5rb3OyE5J7c5PV8PHg8zv2e7/me972cnNzkfvL9lmnTpk06efKkSamAulHEBAAAAAAAAAAAAOCsHD58WGlpaSotLVVaWprKy8vNjgQAHV54eLiSk5NrzIDndDq1bds2HTp0SC6Xy6R0QE0UMQEAAAAAAAAAAABoFpfLpd27dysjI8PdVlxcrG3bttW7tBwAwDsCAwM1ePBgRURE1Ni3d+9e7d69m/s12gyKmAAAAAAAAAAAAAA0mcPhUFpamo4cOVJjn7+/vwmJAAC1sdvtGjRokLp06VJj39GjR5WWliaHw2FCMsATRUwAAAAAAAAAAAAAmqSkpESbNm1SdnZ2jX09e/ZUUlKSLBY+igSAtsJisahv377q3bt3jX05OTlKTU1VSUmJCcmA/+GdAwAAAAAAAAAAAIBGy8/PV2pqqgoLCz3aDcNQUlKSevXqJcMwTEoHAKiLYRjq0aOH+vfvX6PQtKioSD/88IPy8vJMSgdQxAQAAAAAAAAAAACgkU6ePKlNmzaprKzMo91ms+n8889X586dTUoGAGismJgYnX/++bLb7R7t5eXl2rx5s06fPm1OMHR4FDEBAAAAAAAAAAAAqJfL5dKhQ4e0bds2OZ1Oj32BgYG64IILFB4eblI6AEBThYWF6YILLlBQUJBHe2BgoEJCQkxKhY6OIiYAAAAAAAAAAAAAdXI6ndq9e7f27t1bY19ERISSk5MVGBhoQjIAwNkICAhQcnKyIiMjJUl+fn4aOHCgbDabycnQUXHlAQAAAAAAAAAAAKhVRUWFtm3bppycnBr7unTposTERFkszJsAAL7KZrNp0KBBysjIUOfOnRUQEGB2JHRgFDEBAAAAAAAAAAAAqJXFYql1Ro7evXsrPj5ehmGYkAoA0JIMw1BCQoLZMQCWkwMAAAAAAAAAAABQO8MwdO655yo0NFTSmaKm/v37q0ePHhQwAUAH4XQ6lZaWptzcXLOjoJ2jiAkAAAAAAAAAAABAnaxWqwYOHKjQ0FCdf/75iomJMTsSAMBLXC6Xdu3apVOnTmnz5s3KysoyOxLaMZaTAwAAAAAAAAAAAFAvPz8/JScnM/sSAHQwBw4c0PHjxyWdKWjauXOniouL1bNnT74noMUxExMAAAAAAAAAAADQwTmdTmVkZKi0tLTOPnxYDQAdi8vlUn5+fo32AwcOaOfOnXI6nSakQntGERMAAAAAAAAAAADQgZWXl2vr1q06fPiw0tLSVFFRYXYkAEAbYBiGBg4cqLi4uBr7jh8/rs2bN6u8vNyEZGivKGICAAAAAAAAAAAAOqji4mKlpqbq9OnTkqSCggLt2LFDLpfL3GAAgDbBMAwlJiYqISGhxr68vDz98MMPKioqMiEZ2iOKmAAAAAAAAAAAAIAOKDc3V6mpqSouLvZoz8nJUWFhoUmpAABtUbdu3TRw4EBZrVaP9pKSEo9iWOBsUMQEAAAAAAAAAAAAdDB1LQPk5+enwYMHKyQkxKRkAIC2Kjo6WoMHD5a/v79Hu8Ph0JYtW3Ts2DGTkqG9oIgJAAAAAAAAAAAA6CBcLpcOHDhQ65JxwcHBSk5OVmhoqEnpAABtXUhIiJKTk2sUu7pcLu3atUv79u1jSVI0G0VMAAAAAAAAAAAAQAfgdDq1a9cu7d+/v8a+qKgoDR48WAEBAd4PBgDwKf7+/ho8eLCio6Nr7Dt48KB27NihiooKE5LB11HEBAAAAAAAAAAAALRz5eXl2rJli7Kysmrsi4uL08CBA2Wz2UxIBgDwRVarVQMGDFD37t1r7MvPz6eICc3COxEAAAAAAAAAAACgHSsqKlJaWpqKi4tr7OvTp0+tH0ADANAQwzDUp08fBQYGavfu3ZLOFDcNHDhQfn5+JqeDL6KICQAAAAAAAAAAAGinTp8+rW3btsnhcHi0WywW9e/fv9algAAAaIq4uDgFBARox44d6t+/v4KDg82OBB9FERMAAAAAAAAAAADQTh06dKhGAZOfn58GDRqkkJAQk1IBANqbqKgojRgxgqVJcVYsZgcAAAAAAAAAAAAA0Dr69eunoKAg9+OQkBBdcMEFFDABAFpcfQVMLpdLx44dk8vl8mIi+BqKmAAAAAAAAAAAAIB2ymazaeDAgbLb7YqOjtbgwYPl7+9vdiwAQAeTkZGhXbt2afv27XI6nWbHQRtFERMAAAAAAAAAAADQjgUGBio5OVkDBgyQ1Wo1Ow4AoIPJzMxUZmamJOnkyZPavXs3MzKhVhQxAQAAAAAAAAAAAO1cYGCgDMMwOwYAoIMpLS3V3r17PdqOHTumw4cPm5QIbRlFTAAAAAAAAAAAAICPO3XqlPbv38/MFgCANsXf318DBw6UxeJZnrJ3716dOHHCpFRoqyhiAgAAAAAAAAAAAHxYQUGBtm/frgMHDmjnzp1yOp1mRwIAwC0yMlJJSUk12nfu3Km8vDwTEqGtoogJAAAAAAAAAAAA8FGlpaVKS0tzFy4dP35cmzdvVkVFhcnJAAD4n5iYGPXu3dujzel0Ki0tTSUlJSalQltDERMAAAAAAAAAAADggyoqKpSWlqbS0lKP9oCAgBrL9gAAYLb4+Hh16dLFo628vFxpaWlyOBwmpUJbwrsXAAAAAAAAAAAAwMe4XC7t2LFDBQUFHu1hYWE699xzZRiGSckAAKidYRhKTExURESER3thYaG2b98ul8tlTjC0GRQxAQAAAAAAAAAAAD5m7969OnXqlEdbQECABg4cyCxMAIA2y2KxaMCAAQoKCvJoz8nJ0Z49eyhk6uB4BwMAAAAAAAAAAAD4kCNHjujw4cMebTabTYMGDZLdbjcpFQAAjWOz2TRw4MAa37OOHDmizMxMk1KhLaCICQAAAAAAAAAAAPAR2dnZ2r17t0ebYRi1zmoBAEBbFRgYqAEDBtRY/jQjI0MnT540KRXMRhETAAAAAAAAAAAA4AMKCwu1ffv2Gu19+/ZVRESE9wMBAHAWwsPDlZSUVKO9rKzMhDRoCyhiamUHDhzQ7NmzlZSUpODgYEVFRWnYsGGaP3++ioqKzmrspUuXyjCMRv1bunRpg+MVFRXpr3/9q4YNG6aoqCgFBwcrKSlJs2fP1oEDB84qKwAAAAAAAAAAAJqvrKxMW7duVUVFhUd7jx491KVLF5NSAQBwdmJjY9WrVy9JksVi0cCBAxUXF2duKJjGZnaA9mz58uW65ZZblJeX524rKipSSkqKUlJS9OKLL2rFihVKSEgwMeUZe/bs0fjx42tMP7pr1y7t2rVLL774ot544w1NnDjRpIQAAAAAAAAAAAAdU0VFhdLS0lRaWurRHhMT4/7gFwAAX9WjRw85HA517txZISEhZseBiShiaiWpqam64YYbVFxcrJCQED388MMaO3asiouLtWzZMr3wwgtKT0/XhAkTlJKSotDQ0LM63+eff15vNWL37t3r3Jefn68JEya4C5huv/123XjjjQoMDNTKlSv1+OOPKy8vTzfccIPWrl2rwYMHn1VWAAAAAAAAAAAANN6uXbuUn5/v0RYWFqakpCQZhmFSKgAAWoZhGOrTp4/ZMdAGUMTUSh588EEVFxfLZrPpiy++0MiRI937Lr30UiUmJmrOnDlKT0/XggULNG/evLM6X9++fZtdaT9//nylp6dLkv7617/qoYcecu8bOXKkxowZo9GjR6uoqEgzZ87UqlWrziorAAAAAAAAAAAAGq9r167Kzs52LyUXEBCgAQMGyGKxmJwMAACg5fDOphWsX79ea9askSTNmDHDo4Cp0uzZs9WvXz9J0qJFi1ReXu7VjJXKy8v1t7/9TZLUr18/zZ49u0afH/3oR5oxY4YkafXq1dqwYYNXMwIAAAAAAAAAAHRkkZGRSk5OVkBAgKxWqwYOHCg/Pz+zYwEA4BWnT5/W0aNHzY4BL6CIqRV88MEH7u3p06fX2sdisWjKlCmSznzBrVy50hvRali5cqVyc3MlSVOnTq2zYn/atGnu7ffff98b0QAAAAAAAAAAAPBfwcHBSk5O1qBBgxQcHGx2HAAAvOLYsWPasmWL0tPTderUKbPjoJVRxNQKvv32W0ln3kwOGTKkzn6jR492b69du7bVc9WmMqvkmae6oUOHKigoSJJ5WQEAAAAAAAAAADoyPz8/hYeHmx0DAACv2Ldvn3bt2iWXyyVJ2rFjhwoKCkxOhdZkMztAe7Rjxw5JUkJCgmy2ul/ipKSkGsc01/Tp07Vr1y6dPHlSYWFhSkhI0OWXX667775b3bp1q/O47du315qnOpvNpoSEBG3ZsqVZWQ8fPlzv/qpTvxUWFiovL6/J5wBaStVvfHwTRFvANYm2hOsRbQnXI9oarkm0JVyPaGu4JtGWFBYWmh0BAOrlcrlkGIbZMQAAMF3174cVFRVKS0tTcnKy/P39TUqF1kQRUwsrKSnRyZMnJUndu3evt29kZKSCg4NVWFioQ4cOndV5V61a5d4+deqUTp06pf/85z9asGCBnnrqKd155521HldZXBQcHKyIiIh6zxEfH68tW7boxIkTKi0tbdJNIT4+vtF933vvPf6KAG3Ga6+9ZnYEwAPXJNoSrke0JVyPaGu4JtGWcD2ireGahNlyc3PNjgAAdXI6ndqyZYtiYmLq/SN1AAA6gp49e6q4uFjHjx93t5WWlmrbtm06//zzZbVaTUyH1kARUwvLz893b4eEhDTYv7KIqbl/gXbOOedo0qRJGjlypLtQaO/evfrXv/6ld999VyUlJbrrrrtkGIbuuOOOOvM2NmulgoICKhsBAAAAAAAAAABaiMvl0s6dO5Wbm6vc3FwVFxerT58+zMoEAOiwDMPQueeeq5KSEo/VnPLz87Vz507179+f75PtDEVMLaykpMS97efn12D/ykKg4uLiJp/r2muv1dSpU2t8UQ4bNkw33HCDPv74Y02aNEnl5eWaNWuWrrrqKnXp0qXWvE3J2py8Dc00dfToUQ0fPlySNGnSJPXt27dJ4wMtqaCgwP1XobfeemujivyA1sQ1ibaE6xFtCdcj2hquSbQlXI9oa7gm0Zakp6fr8ccfNzsGANSwf/9+nThxwv04MzNTTqeTz0wAAB2axWLRgAEDlJqa6lGPcfLkSe3du1d9+vQxMR1aGkVMLSwgIMC9XVZW1mD/0tJSSVJgYGCTz9XQkmsTJ07Uo48+qkceeURFRUV66aWX9Otf/7rWvE3J2py8DS2tV1VwcLDCwsKaND7QWkJCQrge0aZwTaIt4XpEW8L1iLaGaxJtCdcj2hquSZit6ozzANBWHDt2TAcPHvRos1qtiouLMykRAABth5+fnwYNGqTU1FQ5HA53++HDhxUUFKSuXbuamA4tyWJ2gPYmNDTUvd2YJeIKCwslNW45t+a444473DM1rV69usb+yrxNySq1Xl4AAAAAAAAAAICO5PTp00pPT6/R3r9/fz6PAQDgv4KCgmpdPi49PV05OTkmpUJLo4iphQUEBCg6OlrSmaq/+uTk5LgLg+Lj41slT2xsrDtPZmZmjf2VMyQVFhbq9OnT9Y5VuSRcTEyMx9JyAAAAAAAAAAAAaLqioiJt27ZNLpfLoz0hIUFRUVEmpQIAoG2KjIysdZnVbdu2eUzKAt9FEVMr6N+/vyRpz549HlOZVbdz5073dr9+/VotT/VKxKoqs1bPU53D4VBGRoak1s0KAAAAAAAAAADQEZSXlystLa3GZ0ndunVTt27dTEoFAEDb1qVLlxqTxFRUVCgtLU1lZWUmpUJLoYipFVx00UWSzsxutHHjxjr7VV3ebdSoUa2S5cSJEzp58qQk1bpucmXW6nmqS0lJcVcutlZWAAAAAAAAAACAjsDpdGrbtm0qLi72aI+OjlafPn1MSgUAgG/o3bu3OnXq5NFWUlKitLQ0OZ1Ok1KhJVDE1AquueYa9/aSJUtq7eN0OvXqq69KkiIiIjR27NhWybJ48WL3FKSjR4+usX/MmDEKDw+XJL3yyis1piuttHTpUvf2tdde2/JBAQAAAAAAAAAAOgCXy6X09HTl5uZ6tIeEhKhfv371rrABAADOrEaVlJSk0NBQj/bIyEi+j/o4iphawfDhw3XxxRdLkl566SWtW7euRp8FCxZox44dkqQHH3xQdrvdY/+qVatkGIYMw9C0adNqHL9//36lpqbWm+Pjjz/W7373O0lSYGCgpk+fXqOPn5+fHnjgAUnSjh079MQTT9Tos27dOr300kuSzhRCDRs2rN7zAgAAAAAAAAAAoHYHDx5UVlaWR5ufn58GDhwoq9VqUioAAHyL1WrVwIED5e/vL8MwdO6556p3794UMfk4m9kB2qtFixZp1KhRKi4u1rhx4zR37lyNHTtWxcXFWrZsmRYvXixJ6tu3r2bPnt3k8ffv36+xY8dq5MiRuvLKK3X++ecrNjZWkrR37169++67evfdd90zKz3xxBN1rp/80EMP6e2331Z6errmzJmjPXv26MYbb1RgYKBWrlypP/3pT3I4HAoMDNRTTz3VvBcEAAAAAAAAAACggzt+/Lj279/v0WaxWNwfwgIAgMbz8/PToEGDVF5eroiICLPjoAVQxNRKkpOT9fbbb+uWW25RXl6e5s6dW6NP3759tWLFihpTnDXFunXrap3pqVJQUJCefPJJ3XHHHXX2CQ0N1YoVKzR+/Hjt3r1bixcvdhdZVQoLC9Mbb7yhwYMHNzsrAAAAAAAAAABAR1VaWqpdu3bVaO/Xr99ZfVYEAEBHFhwcbHYEtCCKmFrRlVdeqS1btmjRokVasWKFDh8+LD8/PyUkJGjy5Mm67777FBQU1KyxhwwZotdff13r1q1TSkqKjh49qpMnT8rhcCgyMlIDBgzQZZddpttuu809Q1N9EhISlJqaqmeeeUbvvPOO9uzZo7KyMsXHx2v8+PF68MEH1bNnz2ZlBQAAAAAAAAAA6Oj8/f2VlJSknTt3yul0SpL69OmjTp06mZwMAACgbaCIqZX17NlTCxcu1MKFC5t03JgxY9xLwdUmNDRUN998s26++eazjegWHBysOXPmaM6cOS02JgAAAAAAAAAAAM6IiYmRv7+/0tLSFBMTo27dupkdCQCAdqugoEB79uzRgAEDZLfbzY6DRqCICQAAAAAAAAAAAPCSsLAwDRkyRH5+fjIMw+w4AAC0S6dOndL27dvldDqVlpam888/XxaLxexYaAD/QwAAAAAAAAAAAIAX+fv7U8AEAEArOX78uNLS0tzLt+bl5WnXrl31roaFtoEiJgAAAAAAAAAAAAAAALQL4eHh8vf392g7fvy4Dh06ZFIiNBZFTAAAAAAAAAAAAEALKikpUWpqqnJzc82OAgBAh+Pv76+BAwfKarV6tO/fv19FRUUmpUJjUMQEAAAAAAAAAAAAtBCXy6Xdu3crLy9PmzZtUnp6usrLy82OBQBAhxISEqJ+/fp5tFV+j2ZZubaLIiYAAAAAAAAAAACghZw6dUrZ2dnux0ePHtXBgwdNTAQAQMcUHR2t7t27e7SdPn1aJ06cMCkRGkIREwAAAAAAAAAAANACKioqtGfPHo82u92unj17mpQIAICOrVevXvL39/doy8jIkMPhMCkR6kMREwAAAAAAAAAAANACDhw4oNLSUo+2Pn36yGazmZQIAICOzWq1qk+fPh5tZWVl2r9/vzmBUC+KmAAAAAAAAAAAAICzVFhYqMOHD3u0RUREKDY21qREAABAkjp16qSoqCiPtszMTOXn55uUCHWhiAkAAAAAAAAAAAA4Cy6XS7t375bL5XK3GYahxMREGYZhYjIAAGAYhhISEmSxeJbIVP/eDfNRxAQAAAAAAAAAAACchaysLOXm5nq0xcfHKygoyKREAACgqsDAQPXo0cOjLT8/X0ePHjUpEWpDERMAAAAAAAAAAADQTOXl5dq7d69HW0BAQI0PSgEAgLni4+MVGBjo0bZv3z6VlZWZlAjVUcQEAAAAAAAAAAAANNO+fftUXl7u0ZaQkCCr1WpSIgAAUBuLxaLExET3Y8Mw1K1bN75ntyE2swMAAAAAAAAAAAAAvigvL6/GMjSdOnVSdHS0SYkAAEB9IiMjFRsbq7KyMiUmJrL0axtDERMAAAAAAAAAAADQRC6XS+np6R5tFotFffr0MSkRAABojL59+8piscgwDLOjoBqKmAAAAAAAAAAAAIAmyszMVGFhoUdbr169FBAQYFIiAADQGCwf13ZZzA4AAAAAAAAAAAAA+Bp/f3/Z7Xb34+DgYHXr1s3ERAAAAL6NIiYAAAAAAAAAAACgiWJiYjR8+HDFxcVJkhITE2Wx8NEbAAC+rKSkxOwIHRrLyQEAAAAAAAAAAADNYLPZlJiYqPj4eJaRAwDAh1VUVOjgwYM6dOiQ+vfvr06dOpkdqUOiiAkAAAAAAAAAAAA4CxQwAQDgu7Kzs7V79273LEx79uxRZGSkrFaryck6Hua0BAAAAAAAAAAAAAAAQIdUXl7usYxcaWmpDhw4YGKijosiJgAAAAAAAAAAgDocOHBAs2fPVlJSkoKDgxUVFaVhw4Zp/vz5KioqOquxly5dKsMwGvVv6dKlLfOE0GwVFRVmRwAAAK0gNjZWERERHm2HDx9WYWGhOYE6MIqYAAAAAAAAAAAAarF8+XKdd955WrhwoXbt2qWioiLl5OQoJSVFc+bMUXJysvbs2WN2THiBy+VSWlqatm3bptLSUrPjAACAFmQYhhITE2UYhrvN5XJp9+7dcrlcJibreGxmBwAAAAAAAAAAAGhrUlNTdcMNN6i4uFghISF6+OGHNXbsWBUXF2vZsmV64YUXlJ6ergkTJiglJUWhoaFndb7PP/9ccXFxde7v3r37WY2Ps3PixAmdPn1akpSTk6OePXuqe/fuHh92AgAA3xUUFKT4+HgdPHjQ3Zabm6usrCx16dLFxGQdC0VMAAAAAAAAAAAA1Tz44IMqLi6WzWbTF198oZEjR7r3XXrppUpMTNScOXOUnp6uBQsWaN68eWd1vr59+6pXr15nFxqtwuFwKCMjw/24oqJChw8fVteuXWWz8VEbAADtRY8ePXT8+HGVlJS42/bu3avo6GjZ7XYTk3UcLCcHAAAAAAAAAABQxfr167VmzRpJ0owZMzwKmCrNnj1b/fr1kyQtWrRI5eXlXs0I79m/f7/Kyso82hISEihgAgCgnbFarUpISPBoKy8v1759+0xK1PFQxAQAAAAAAAAAAFDFBx984N6ePn16rX0sFoumTJkiSTp9+rRWrlzpjWjwsvz8fGVmZnq0RUVFqVOnTiYlAgAArSk6OrrG9/mjR48qLy/PpEQdC0VMAAAAAAAAAAAAVXz77beSpODgYA0ZMqTOfqNHj3Zvr127ttVzwbtcLpd2797t0WaxWJSQkCDDMExKBQAAWlufPn1ksXiW06Snp8vlcpmUqONgnksAAAAAAAAAAIAqduzYIanhJcOSkpJqHNNc06dP165du3Ty5EmFhYUpISFBl19+ue6++25169at2eMePny43v1Hjx51b+fn53ttloGCgoJat9uSkydPKj8/36Otc+fOKi8vZ/nANsoXriv4Fq4ptDSuKd/RpUsXHTlyxP24sLBQGRkZio2NNTFV7cy6rqq/T2oJFDEBAAAAAAAAAAD8V0lJiU6ePClJ6t69e719IyMjFRwcrMLCQh06dOiszrtq1Sr39qlTp3Tq1Cn95z//0YIFC/TUU0/pzjvvbNa48fHxje772muvKTw8vFnnORuvvfaa18/ZELvdrvPPP9+jiK24uFgffPABszD4iLZ4XcG3cU2hpXFNtW2GYWjQoEEKCgpytx08eFAfffRRmy5m9uZ1lZub2+JjUsQEAAAAAAAAAADwX1X/ojwkJKTB/pVFTM39q/dzzjlHkyZN0siRI90FR3v37tW//vUvvfvuuyopKdFdd90lwzB0xx13NOscaLoePXrUmIVr3759FDABANBBuFwu7d27VwMHDnS3Wa1W9ejRQxkZGSYma98oYgIAAAAAAAAAAPivkpIS97afn1+D/f39/SWdmaWnqa699lpNnTpVhmF4tA8bNkw33HCDPv74Y02aNEnl5eWaNWuWrrrqKnXp0qVJ52hohqijR49q+PDhkqRbb731rJaua4qCggL3TAG33nprowrGvCU/P1979uzxaIuMjNTNN99sUiI0Vlu+ruCbuKbQ0rimfM+BAweUnZ0tSYqIiNCAAQM0btw4k1N5Muu6yszM1OOPP96iY1LEBAAAAAAAAAAA8F8BAQHu7bKysgb7l5aWSpICAwObfK6Glm6bOHGiHn30UT3yyCMqKirSSy+9pF//+tdNOkdDS+JVFRoaqrCwsCaN3xJCQkJMOW9tnE6ndu3a5dFmtVqVlJTUqKI2tB1t6bpC+8A1hZbGNeUbkpKStHXrVvXq1UtRUVFmx2mQN6+rvLy8Fh/T0uIjAgAAAAAAAAAA+KjQ0FD3dmOWiCssLJTUuKXnmuOOO+5wz9S0evXqVjkH/ufw4cMqKiryaOvduzcFTAAAdFB2u13Jyck+UcDUHlDEBAAAAAAAAAAA8F8BAQGKjo6WdKagpT45OTnuIqb4+PhWyRMbG+vOk5mZ2SrnwBklJSU6cOCAR1toaKji4uJMSgQAANqC6kv/ovVQxAQAAAAAAAAAAFBF//79JUl79uyRw+Gos9/OnTvd2/369Wu1PHxw5h12u13du3f3eL0TExN5/QEAALyEIiYAAAAAAAAAAIAqLrroIklnlorbuHFjnf2qLu82atSoVsly4sQJnTx5UpKYEaiVWa1W9e7dW0OHDlVERITi4uI8lhcEAACoqry8XHl5eWbHaFcoYgIAAAAAAAAAAKjimmuucW8vWbKk1j5Op1OvvvqqJCkiIkJjx45tlSyLFy+Wy+WSJI0ePbpVzgFPQUFBOu+889SnTx+zowAAgDbI5XIpKytLGzZs0LZt2+qduRNNQxETAAAAAAAAAABAFcOHD9fFF18sSXrppZe0bt26Gn0WLFigHTt2SJIefPBB2e12j/2rVq2SYRgyDEPTpk2rcfz+/fuVmppab46PP/5Yv/vd7yRJgYGBmj59enOeDprBMAxZLHyMBgAAPDkcDm3evFk7d+5UeXm5ysrKtH//frNjtRs2swMAAAAAAAAAAAC0NYsWLdKoUaNUXFyscePGae7cuRo7dqyKi4u1bNkyLV68WJLUt29fzZ49u8nj79+/X2PHjtXIkSN15ZVX6vzzz1dsbKwkae/evXr33Xf17rvvumdheuKJJ9StW7eWe4IAAABoMqvVKqvV6tGWmZmpzp07swxtC6CICQAAAAAAAAAAoJrk5GS9/fbbuuWWW5SXl6e5c+fW6NO3b1+tWLHirD6wWrduXa0zPVUKCgrSk08+qTvuuKPZ50DtXC6XSkpKFBgYaHYUAADgIwzDUEJCglJSUuR0Ot3tu3fvVnJysgzDMDGd76OICQAAAAAAAAAAoBZXXnmltmzZokWLFmnFihU6fPiw/Pz8lJCQoMmTJ+u+++5TUFBQs8YeMmSIXn/9da1bt04pKSk6evSoTp48KYfDocjISA0YMECXXXaZbrvtNvcMTWhZWVlZSk9PV3x8vHr06FFjVgUAAIDaBAYGqkePHh7LyOXn5+vo0aOKi4szL1g7QBETAAAAAAAAAABAHXr27KmFCxdq4cKFTTpuzJgx7qXgahMaGqqbb75ZN99889lGRDM4HA7t3btXLpdLBw8e1PHjx9W3b19FRkaaHQ0AAPiA+Ph4ZWVlqbi42N22b98+derUSX5+fiYm820WswMAAAAAAAAAAAAA3nT06FGVl5e7H5eUlHgsCQMAAFAfi8WixMREjzaHw6GjR4+alKh9oIgJAAAAAAAAAAAAHYbL5dKRI0c82qKjoxUdHW1SIgAA4IsiIyMVExPj0XbkyJF6Z+NE/ShiAgAAAAAAAAAAQIeRnZ2tkpISj7b4+HiT0gAAAF9W/T1EWVmZTp06ZVIa30cREwAAAAAAAAAAADqM6rMwhYSEKCwszKQ0AADAl4WGhio0NNSjLTMz06Q0vo8iJgAAAAAAAAAAAHQIJSUlys7O9miLi4uTYRgmJQIAAL6uW7duHo9Pnz6toqIik9L4NoqYAAAAAAAAAAAA0CFUn4XJarUqNjbWpDQAAKA9iImJkc1m82ir/p4DjUMREwAAAAAAAAAAANo9p9OpY8eOebR16dJFVqvVpEQAAKA9sFgs6tq1q0fbsWPHVFFRYVIi30UREwAAAAAAAAAAANq9EydOqLy83KMtLi7OpDQAAKA9qV7EZLVaWVKuGWwNdwEAAAAAAAAAAAB8W/VlXSIiIhQUFGRSGgAA0J4EBgYqKipKTqdTcXFx6tSpkwzDMDuWz6GICQAAAAAAAAAAAO1aQUGB8vLyPNqYhQkAALSkAQMGyGJhQbSzwasHAAAAAAAAAACAdq36LEx+fn6Kjo42KQ0AAGiPKGA6e7yCAAAAAAAAAAAAaLccDoeysrI82rp27coHjQAAAG0M784AAAAAAAAAAADQblksFiUlJSkiIsLd1rVrV/MCAQAAoFY2swMAAAAAAAAAAAAArcVisSgmJkYxMTEqLCxUXl6e/P39zY4FAAA6iOLiYgUEBMgwDLOjtHkUMQEAAAAAAAAAAKBDCA4OVnBwsNkxAABAO+dyuZSdna0jR44oOztbAwcOVHR0tNmx2jyKmAAAAAAAAAAAAAAAAIAWsm3bNp06dcr9+MiRIxQxNYLF7AAAAAAAAAAAAAAAAABAe1G9YCk7O1vFxcUmpfEdFDEBAAAAAAAAAAAAAAAALSQ2NlZWq9Wj7ejRoyal8R0UMQEAAAAAAAAAAKBdcTqd2rlzp06dOiWXy2V2HAAA0MFYrVZ16dLFo+3YsWNyOp0mJfINFDEBAAAAAAAAAACgXTl16pSysrKUlpam9evX69ChQxQzAQAAr4qLi/N4XF5erhMnTpiUxjdQxAQAAAAAAAAAAIB25ciRI+7tkpISnTx5UoZhmJgIAAB0NEFBQYqIiPBoq/oeBTVRxAQAAAAAAAAAAIB2o7CwUKdPn/Zoqz4TAgAAgDdUfw+Sl5en/Px8k9K0fRQxAQAAAAAAAAAAoN04evSox2O73a6YmBiT0gAAgI4sOjpafn5+Hm3V36vgfyhiAgAAAAAAAAAAQLtQUVGhY8eOebR16dJFFgsfiQEAAO+zWCzq2rWrR1tWVpYcDodJido23rEBAAAAAAAAAACgXcjKylJFRYVHG0vJAQAAM1UvYnI6nTWKrnEGRUwAAAAAAAAAAADweS6XS0eOHPFoi46OVkBAgEmJAAAAJH9/f3Xq1Mmj7ciRI3K5XCYlarsoYgIAAAAAAAAAAIDPy8vLU2FhoUcbszABAIC2oPp7kuLiYp0+fdqcMG0YRUwAAAAAAAAAAADwedVnYQoICFBkZKRJaQAAAP4nIiJCQUFBHm3V37uAIiYAAAAAAAAAAAD4uLKyMp04ccKjLS4uToZhmJQIAADgfwzDcM/G5Ofnp549eyohIcHkVG2PzewAAAAAAAAAAAAAwNk4duyYXC6X+7FhGOrSpYuJiQAAADx17txZfn5+io6OlsXCnEO1oYgJAAAAAAAAAAAAPsvlctVYjiU2NlZ2u92kRAAAADXZbDbFxMSYHaNNo7SrlR04cECzZ89WUlKSgoODFRUVpWHDhmn+/PkqKio6q7GLior03nvv6e6779awYcMUGRkpu92u6OhojRw5UvPmzdOxY8caHGfMmDEyDKNR/wAAAAAAAAAAANqS7OxslZaWerRVLtcCAAAA38FMTK1o+fLluuWWW5SXl+duKyoqUkpKilJSUvTiiy9qxYoVzVrncMuWLRo1apQKCgpq7MvOztb333+v77//Xk8++aQWL16sG2644ayeCwAAAAAAAAAAQFvkcDjk5+ensrIySVJISIhCQ0NNTgUAAICmooiplaSmpuqGG25QcXGxQkJC9PDDD2vs2LEqLi7WsmXL9MILLyg9PV0TJkxQSkpKk99M5+XluQuYRo0apYkTJ2ro0KGKjo7WiRMn9N577+mFF15QXl6ebr75ZoWFheknP/lJvWMOHTpUS5YsafZzBgAAAAAAAAAA8LbOnTsrJiZGp06dUmZmpjp37szqEgAAAD6IIqZW8uCDD6q4uFg2m01ffPGFRo4c6d536aWXKjExUXPmzFF6eroWLFigefPmNWl8i8Wi66+/Xr/97W/Vv3//GvvHjRunn/zkJ7r22mtVUVGh+++/X7t37673TXtwcLAGDhzYpBwAAAAAAAAAAABms1gsiomJUUxMjFwul9lxAAAAGqW4uFhHjx6VYRjq3bu32XFMZzE7QHu0fv16rVmzRpI0Y8YMjwKmSrNnz1a/fv0kSYsWLVJ5eXmTzvGjH/1Ib7/9dq0FTJWuvvpqTZo0SZKUkZGh1NTUJp0DAAAAAAAAAADA1zALEwAAaOsKCwu1detWrV+/XocOHVJmZqYqKirMjmU6iphawQcffODenj59eq19LBaLpkyZIkk6ffq0Vq5c2SpZxo4d697OyMholXMAAAAAAAAAAAAAAACgcaxWq7Kzs92PKyoqlJWVZWKitoEiplbw7bffSjqzPNuQIUPq7Dd69Gj39tq1a1slS2lpqXvbarW2yjkAAAAAAAAAAAAAAADQOAEBAYqOjvZoO3LkSIdfFtdmdoD2aMeOHZKkhIQE2Wx1v8RJSUk1jmlpq1evdm9XLl9Xl507d2rEiBHatWuXSkpK1KlTJw0ZMkT/93//p5tuukl2u73ZOQ4fPlzv/qNHj7q3CwsLlZeX1+xzAWeroKCg1m3ALFyTaEu4HtGWcD2ireGaRFvC9Yi2hmsSbUlhYaHZEQC0gJKSEklnPgAEAADwRXFxcTp16pT7cWWtRHh4uImpzEURUwsrKSnRyZMnJUndu3evt29kZKSCg4NVWFioQ4cOtXiWzZs3a8WKFZKkQYMGNVjElJWV5TE9WWZmpjIzM/XRRx/pL3/5i959990Gx6hLfHx8o/u+9957HfqLEm3La6+9ZnYEwAPXJNoSrke0JVyPaGu4JtGWcD2ireGahNlyc3PNjgCgBRw4cEDHjh1TdHS04uLiFBkZKcMwzI4FAADQaJGRkQoICHAXZ0tnZmPqyPUSLCfXwvLz893bISEhDfYPDg6W1PJ/gVZaWqrbbrtNFRUVkqQ//vGPdfa1WCy67LLLtGDBAn311VdKTU3VN998o6eeespdtLR9+3aNHTtWBw8ebNGcAAAAAAAAAAAATVFeXq7jx49Lkk6dOqWtW7cqMzPT5FQAAABNYxiG4uLiPNpOnDihsrIykxKZj5mYWljVCjk/P78G+/v7+0uSiouLWzTHfffdp5SUFEnS1KlTdeWVV9bZ97333lNERESN9osvvlj33HOPbr/9dr3yyivKysrSzJkz9d577zU5T0MzTR09elTDhw+XJE2aNEl9+/Zt8jmAllJQUOD+q9Bbb721UQWJQGvimkRbwvWItoTrEW0N1yTaEq5HtDVck2hL0tPT9fjjj5sdA8BZyMrKktPpdD82DEOxsbEmJgIAAGieLl26aN++fXK5XJIkl8ulY8eOqUePHiYnMwdFTC2s6trLjamOKy0tlSQFBga2WIbHH39cL774oiRp2LBheuaZZ+rtX1sBUyW73a4XX3xR33//vXbt2qX3339fmZmZ6tatW5MyNbS0XlXBwcEKCwtr0vhAawkJCeF6RJvCNYm2hOsRbQnXI9oarkm0JVyPaGu4JmG2ytnxAfgml8ulI0eOeLR16tSpUX9YDgAA0NbY7XbFxsYqKyvL3XbkyBHFx8d3yKVyWU6uhYWGhrq3G7NEXGFhoaTGLT3XGP/4xz80d+5cSVJSUpI++eSTs/6h3GazacaMGe7Hq1evPqvxAAAAAAAAAAAAmiM3N7fG6hbVl2EBAADwJdXfy5SWlionJ8ekNOaiiKmFBQQEKDo6WpJ0+PDhevvm5OS4i5ji4+PP+txvvfWW7rnnHklSz5499eWXX6pTp05nPa4k9e/f373NutIAAAAAAAAAAMAMp0+f9ngcFBSk8PBwc8IAAAC0gNDQ0BoT31R/z9NRUMTUCioLfvbs2SOHw1Fnv507d7q3+/Xrd1bn/OijjzRlyhQ5nU517dpVX3/9dZOWcGtIR5ymDAAAAAAAAAAAtC25ubkej6OiovgMAwAA+DTDMBQVFeXRVv09T0dBEVMruOiiiySdWSpu48aNdfaruizbqFGjmn2+r7/+Wtdff70cDoeio6P15Zdfqk+fPs0erzbbt293bzMtKwAAAAAAAAAA8Dan06m8vDyPNmZhAgAA7UH19zT5+fmqqKgwKY15KGJqBddcc417e8mSJbX2cTqdevXVVyVJERERGjt2bLPO9d133+nqq69WaWmpwsPD9fnnn2vAgAHNGqsuDodDL7/8svvxJZdc0qLjAwAAAAAAAAAANKSgoEBOp9OjjSImAADQHoSFhXk8drlcys/PNymNeWxmB2iPhg8frosvvlhr1qzRSy+9pKlTp2rkyJEefRYsWKAdO3ZIkh588EHZ7XaP/atWrXIXNk2dOlVLly6tcZ5NmzZpwoQJKiwsVHBwsFasWKEhQ4Y0KevKlSuVnJysiIiIWveXl5fr9ttvd2e98sorFR8f36RzAAAAAAAAAAAAnK3qy6oEBQXV+HwF8KaysjIVFBSosLBQZWVlNYrs4PscDocGDx4sScrMzFRWVpa5gdAqLBaL/Pz8FBwcrJCQEPn5+ZkdCR2QzWZTSEiICgoK3G15eXl11nK0VxQxtZJFixZp1KhRKi4u1rhx4zR37lyNHTtWxcXFWrZsmRYvXixJ6tu3r2bPnt3k8TMyMnTFFVfo9OnTkqQ//OEPCg8PV1paWp3HxMbGKjY21qPtlVde0VVXXaWrrrpKY8aM0bnnnquwsDAVFBRo48aNWrx4sXspudjYWC1atKjJWQEAAAAAAAAAAM5W5WcilTrah3poO1wul06ePKmTJ0+aHQWtzOl0umd8czqdcjgcJidCa6ksSszKylJMTIyio6NlGIbZsdDBdOrUSYGBgQoPD1d4eLiCg4PNjuR1FDG1kuTkZL399tu65ZZblJeXp7lz59bo07dvX61YsUKhoaFNHn/NmjU6fvy4+/GsWbMaPOa3v/2t5s2bV6O9oKBAb775pt588806jx00aJCWLVum3r17NzkrAAAAAAAAAADA2XC5XMrLy/NoYyk5mOXo0aM1ZgYzDENWq9WkRGgtLpdLISEhkiS73U5RSztVUVEhl8vlfnzixAmVlZUpLi7OxFToiHr27Gl2BNNRxNSKrrzySm3ZskWLFi3SihUrdPjwYfn5+SkhIUGTJ0/Wfffdp6CgIFMz/vKXv9TgwYO1bt06bd++XSdOnFB2drb8/f3VuXNnDR06VNddd52uvfZa3ngBAAAAAAAAAABTFBYW1pgBhSImmKGkpMSjgCk6OlphYWHy9/enwKUdqqiocE8sERsby+el7ZTL5VJpaany8vJ06tQpSWeWMI2Ojpa/v7/J6YCOhSKmVtazZ08tXLhQCxcubNJxY8aM8aj2rG7atGmaNm3aWaaT+vXrp379+mnmzJlnPRYAAAAAAAAAAEBrqD7rTUBAAB8swxRVlzWMjY1VdHS0eWEAtAjDMBQQEKCAgABZrVZ34VpOTo66dOlicjqgY7GYHQAAAAAAAAAAAACoj9PplM32v7/NZxYmmKWoqMi9HRERYV4QAK2i6td11a93AN7BTEwAAAAAAAAAAABo0+Lj49W9e3cVFRUpNzdXgYGBZkdCB1VRUSFJstlsLC0GtENWq1VWq1UVFRXur3cA3kMREwAAAAAAAAAAANo8wzAUHBys4OBgs6MAANoxwzDMjgDI6XSqoKBAubm56tSpU4cp4KaICQAAAAAAAAAAAAAAAGgDdu7cqRMnTsjpdEo6M0NYRylispgdAAAAAAAAAAAAAAAAAIDkcrncBUySlJuba2Ia76KICQAAAAAAAAAAAAAAAGgDwsPDPR6fPn1aLpfLpDTeRRETAAAAAAAAAAAAAAAA0AZERER4PC4rK1NJSYk5YbyMIiYAAAAAAAAAAAC0SSdPnlRaWpoOHTqkvLw8j6VVAMBXLV26VIZhyDAM7d+/v1XOsX//fvc5li5d2irnaKvmzZvnfu6ALwoMDJTdbvdo6yhLylHEBAAAAAAAAAAAgDYpJydHp06d0t69e5Wamqrt27ebHQkAAKBVGYZRY0k5ipgAAAAAAAAAAAAAE1X/wC4sLMykJACA6rwxoxTQUVHEBAAAAAAAAAAAALQR5eXlKiws9Gir/oEeAABAe1T9PU9xcbHKyspMSuM9FDEBAAAAAAAAAACgzcnLy/N4bLFYFBoaalIaAAAA7wkJCZHVavVo6wizMVHEBAAAAAAAAAAAgDbn9OnTHo9DQ0NlsfDRFgAAaP8Mw6ixjC5FTAAAAAAAAAAAAIAJqn9Qx1JyQMc0b948GYYhwzAknZmlbd68eRo0aJBCQkIUGxur8ePH67vvvvM47vjx4/rNb36jAQMGKDg4WNHR0br66quVmppa7/mcTqdef/11jR8/Xt26dVPPnj01cOBAXXbZZXr22WcbtZxTTk6OfvWrXykpKUmBgYGKjY3V5ZdfrnfeeadRz7ny+c6bN6/efmPGjJFhGBozZkyjxq0uLS1Nf/jDH3TFFVeoe/fu8vf3V0hIiBITEzV16lR9//33tR63atUqGYah6dOnu9t69+7tzl35b9WqVbUe/8EHH2jy5Mnq0aOHAgICFBERoaFDh+qxxx5TTk5Og7kPHz6se++9V+ecc44CAgIUFxenq666Sl999VWzXgegrar+3qd6gXd7ZDM7AAAAAAAAAAAAAFBVRUWFCgoKPNooYgJw6NAhXX755UpPT3e3FRYW6tNPP9UXX3yht956S5MnT9aWLVs0fvx4ZWZmuvsVFRXpo48+0ueff65PP/1UY8eOrTF+dna2rrrqKq1du7ZG++rVq7V69Wo9/fTT+vTTT9WzZ89aM+7YsUOXX365jhw54m4rKSnR119/ra+//lrTp0/XJZdccrYvxVlbtWpVra9BWVmZ9uzZoz179ujVV1/Vr371Kz3++OMtcs6cnBxdd911+ve//+3RXlpaqo0bN2rjxo169tln9eGHH+rCCy+sdYw1a9Zo4sSJHkuOHj16VMuXL9fy5csbLPwCfElERITH48LCQjkcDtls7bfUp/0+MwAAAAAAAAAAAPikvLw8uVwujzaKmABMnjxZhw8f1sMPP6wf//jHCgoK0rfffqvf/va3ysvL04wZMzR06FBNnDhRxcXF+uMf/6jRo0fLbrfrs88+0x//+EeVlpZq2rRp2r17t/z8/NxjV1RUaOLEiVq3bp0kafTo0brnnnsUHh6uY8eO6f3339eHH36oHTt26LLLLtOmTZsUEhLikS8vL09XXHGFu4Dphhtu0NSpUxUbG6v09HQtXLhQS5YsUVpamvdetDo4HA4FBwdrwoQJuvTSS5WUlKSwsDAdP35c27Zt09/+9jcdOHBAf/7zn9W3b1+PWZeGDRumrVu36sMPP9RvfvMbSdLnn3+uuLg4j3P07t3bvV1aWqrLL79cP/zwg6xWq376059q/Pjx6t27t8rLy/XNN99o4cKFOn78uMaPH6/U1NQahWIHDx50FzBZLBbdcccduu666xQeHq4tW7boz3/+s+bNm6ehQ4e24isHeE9oaKgMw/B4T5Sbm6vo6GgTU7Uurxcx7d69W6+++qrWrVunY8eOqbi4WJ9//rkSEhLcfdLS0nTw4EEFBwdr9OjR3o4IAAAAAAAAAAAAE1VfSi40NFRWq9WkNEDTuJxOVXSAJX+qskZEyLBYWv08mzZt0urVqzVixAh329ChQ5WYmKiJEycqPz9fI0aMkMvl0vr169WnTx93v+HDh6tTp0669957dfDgQa1YsULXXnute//zzz/vLmCaMmWKli5dKqfTqePHj+u8887TLbfcokcffVR/+tOflJGRod///vf6y1/+4pHv97//vQ4dOiRJ+tOf/qSHH37YvW/IkCG67rrrNHHiRH3xxRet8vo0xeDBg3X48OEaM71I0hVXXKH77rtPEydO1JdffqnHHntMU6ZMcd+Hg4ODNXDgQKWkpLiP6du3r3r16lXn+X73u9/phx9+UEREhL766isNGTLEY/9FF12km2++WSNHjtTRo0c1d+5cvfHGGx59Zs+e7Z6B6fXXX9dNN93k3jd06FBNnjxZF198sUcuwJdZLBaFhYV5vC+iiKmFOJ1OzZkzR4sWLZLT6XRXihmGUWPd0MoKSpvNpn379qlbt27eigkAAAAAAAAAAACTVS9iYhYm+JKK06e1+0ejzI7hVYnfrZUtKqrVzzNz5kyPAqZKEyZMUM+ePXXgwAGdOHFCzz33nEcBU6Xp06dr9uzZKikp0Zo1azyKmJ555hlJUkxMjJ5++mkZhlHj+Mcee0zvvfeedu7cqRdeeEG/+93v5O/vL+nMMmwvvfSSJOm8887Tr371qxrH2+12vfTSSzrnnHNUXl7evBehhXTq1Kne/X5+fpo/f74GDx6sAwcOaNOmTTUKjxqroKDA/fr+/ve/r3Ocnj176pFHHtE999yjd955R4sXL1ZwcLAkuWfDkqSJEyd6FDBVCg0N1eLFi2u9RgBfFR4ertzcXNlsNoWHh9eYAa69af1y2P+688479eSTT6qiokJxcXG67rrr6uxbOW1cRUWF3n33XW9FBAAAAAAAAAAAgMmcTqd7po1KFDEBkKQbb7yxzn3nnXeepDOTaNxwww219gkMDFRiYqIkae/eve72I0eOaMeOHZKk66+/XqGhobUeb7PZ3Muq5eTk6IcffnDv27hxo3JyciRJU6dOrbUISpK6d++ucePG1fk8zFJaWqqDBw9q+/btSktLU1pamscSVps3b2722KtXr3YXp9ZXJyBJl1xyiSSpvLxcGzdudLevXLlSFRUVkuSxtF11w4cP14ABA5qdFWhrunbtqqFDh+pHP/qRBg4cqNjYWLMjtSqvFDF9/fXX7qrTuXPnav/+/frnP/9Z7zGTJ0+Wy+XSv//9b29EBAAAAAAAAAAAQBtQUFAgp9Pp0UYREwDpzJJldalcFq1Tp06KjIxssF9+fr67LS0tzb3d0Cw+VfdXPW7r1q3u7WHDhtU7xvDhw+vd7y2FhYV6/PHHdf755ys4OFg9e/bUgAEDNGjQIA0aNEjJycnuvidPnmz2eaou79a1a1cZhlHnv4EDB7r7Hjt2zL3ti68v0BICAgIUHBxcZ2Fke+OV5eQWL14s6cwMS3/4wx8adUzljWXbtm2tlgsAAAAAAAAAAABtS/Wl5IKCgmS3201KA6AtCQoKqnOfxWJpsE/VfpWz+khSdna2e7uhWU66dOlS63FNGaNz58717veG/fv369JLL9W+ffsa1b+4uLjZ5zp+/HizjisqKnJv+9rrC6B5vFLEtG7dOhmGoRkzZjT6mO7du0vyrK4EAAAAAAAAAABA+3b69GmPx5WzpgC+whoRocTv1podw6us7ejrtCVmO/GFGVNuvfVW7du3T4ZhaPr06brxxhvVr18/xcTEyM/PT4ZhyOl0ymq1SpLH0nJNVbVg7Icffmh0YWplzUB1vvD6AmgerxQxVVZW9urVq9HHVN64HA5Ha0QCAAAAAAAAAABAG9S7d29FRkYqNzdXubm5LCUHn2NYLLJFRZkdA00QVeX/Kysrq96+VSfhqHpc1SXssrKy6l36rqFzGIYhl8tVY2nN6goLC+vdX5edO3fq22+/lSTNnTu3ztWUqs5+dDaio6Pd2zExMXUWJ9Wn+usbHx9fZ9+GXl8AbZfFGycJDg6WJJ04caLRxxw+fFiS540fAAAAAAAAAAAA7VtISIi6d++uAQMGaOTIkYqJiTE7EoB2buDAge7t//znP/X2Xb9+fa3HDRo0yL29YcOGesdoaH9oaKgkKScnp84+LpdLe/bsqXecumzbts29fcMNN9TZLyUlpd5xGjsjUnJysnt77drmzVLWkq8v4OsaU+Toq7xSxHTOOedIkrZv397oYz799FNJ0oABA1olEwAAAAAAAAAAANo2wzBYNghAq4uLi1O/fv0kSf/85z9VUFBQa7+KigotXbpU0pmZgS644AL3viFDhrhnC3rttdfqXH4tMzNTX3zxRb15evfuLan+IqJPP/20xvKbjVV1NaT6ZnN6/vnn6x0nICDAvV1aWlpnv8svv1xBQUGSpL/97W/NWppu7Nix7qXtXnnllTr7bdiwQWlpaU0eH2jrCgoKdPDgQW3dulXfffedMjMzzY7UKrxSxDRu3Di5XC4988wzjaoG2759u5YuXSrDMDR+/HgvJAQAAAAAAAAAAAAAdFT33nuvpDOrCz3wwAO19nnsscfcE3fcfvvt8vf3d+/z9/fX9OnTJUmbNm3S/PnzaxzvcDh0++23q6ysrN4so0ePlnRmVqjaZi46duyY7r///kY8q9olJia6tyuLsqp77rnn9OGHH9Y7TteuXd3bGRkZdfaLiIjQfffdJ0n67rvvNGvWrHrrBrKysvTiiy/WONfVV18tSfroo4/0z3/+s8ZxBQUFuvPOO+vNDPiqI0eOaN++fcrOzpbD4VBubq7ZkVqFV4qYHnjgAQUHBysjI0N33XWXR2VndV9++aXGjRunkpISRUVF6fbbb/dGRAAAAAAAAAAAAABAB3XXXXdp5MiRkqQlS5bosssu03vvvactW7boq6++0uTJk/X73/9ektSnTx898sgjNcZ49NFH1b17d0nSL3/5S/30pz/VZ599ph9++EHLli3Tj370I3366acaOnRovVnuuOMO2Ww2uVwuXXnllXrqqaeUkpKi7777TvPnz1dycrJyc3M9ipGaIjk52b0U3j/+8Q/dcMMN+vjjj7Vx40Z9+OGHmjx5su655x6NGjWqwXEqZ2N65JFH9OWXXyo9PV179uzRnj17VFxc7O77u9/9TiNGjJAkLVq0SBdccIGeeeYZrV27Vps2bdLKlSv19NNP65prrlGPHj1qnQVqwYIF7qX2fvrTn+ree+/VypUrtXHjRi1ZskRDhgxRampqg68v4IvCw8M9Hufm5jZrVrO2zuaNk3Tu3FnPP/+8pkyZopdeekmff/65JkyY4N6/aNEiuVwurV27Vjt37pTL5ZLFYtHSpUsVEhLijYgAAAAAAAAAAAAAgA7KarXq448/1lVXXaW1a9fq3//+t/7973/X6NevXz99+umntX6OHR4ers8++0yXX365jh07prfeektvvfWWR59p06Zp9OjR7lmbajNgwAD99a9/1c9//nPl5ORo1qxZHvujoqL0wQcf6JFHHtHu3bub/FwNw9Brr72mSy+9VDk5OfrnP/9ZY2ajQYMG6Z133lFcXFyd44SGhuqBBx7QX//6V/3www8aN26cx/6VK1dqzJgxks7MVPXll19q2rRpeu+997R582b37Ey1CQsLq9HWq1cvffTRR7rqqquUn5+vZ599Vs8++6xHn0cffVSGYdS7FB/gi6oXMTkcDhUVFSk4ONikRK3DKzMxSdLNN9+st956S2FhYTp06JD+8Y9/uNcwfvHFF/XSSy9px44dcrlcCgkJ0TvvvONR6AQAAAAAAAAAAID2q7CwUAUFBe1yVgEAviEqKkrffPONXn31Vf34xz9W586dZbfbFRkZqdGjR+vpp5/Wpk2b1LNnzzrHGDBggLZt26Y5c+YoMTFR/v7+6tSpk8aOHas333xTS5YsaVSWWbNm6bPPPtMVV1yhyMhI+fv7q3fv3rr33nuVmpqqiy+++Kye6+DBg7Vp0ybddddd6tmzp+x2u6KiojR8+HA98cQTWr9+vcdycXX585//rBdeeEEXX3yxoqKiZLVa6+wbGhqqf/3rX1qzZo1uu+02nXvuuQoNDZXNZlNUVJSGDRume++9V5988om+/PLLWscYM2aMtm3bprvvvls9e/aUn5+fOnfurAkTJuizzz7TY4891uzXBGjLAgICPJawlNQul5TzykxMla6//npddtllevbZZ7V8+XJt2rTJY2m5AQMG6KqrrtKDDz6o2NhYb0YDAAAAAAAAAACAiQ4dOqSsrCxZrVaFh4era9eu6tSpk9mxAJhs3rx5mjdvXoP9li5dqqVLlzbYb9WqVfXut1gsuvXWW3XrrbeqoqJCx48flyTFxsbWW6BTVVRUlP7yl7/oL3/5S637p02bpmnTpjU4zhVXXKErrriizv31PZdevXo1WBTao0cPPffcc/X2aWgMwzB022236bbbbqu3X1UXXXSRLrrookb3ry4+Pr7GDExVNfaaAXxNeHi4+54kSadPn653tjRf5NUiJkmKjo7WI488okceeUROp1PZ2dmqqKhQVFSU7Ha7t+MAAAAAAAAAAACgDaicTaCiokLZ2dmKiooyOREAAEDbERER4VHElJub2+5msPR6EVNVFouFCnoAAAAAAAAAAIAOrrS0VCUlJR5t4eHhJqUBAABoe6q/NyorK6vx/snXWcwOAAAAAAAAAAAAgI6tchamSlarVcHBwSalAQAAaHsCAwNrrHBW/T2Ur6OICQAAAAAAAAAAAKaq/gFceHi4DMMwKQ0AAEDbYxhGjdmY2lsRU4suJ3fOOee05HCSzvwnZGRktPi4AAAAAAAAAAAAaBtqK2ICAACAp/DwcJ08edL9ODc3V127djUxUctq0SKm/fv3N6pfZeW8y+VqsJ0qewAAAAAAAAAAgPbL4XCosLDQo40iJgAAgJqqv0cqLi5WeXm5SWlaXosWMU2dOrXe/Zs2bdLmzZvlcrkUERGh5ORkde7cWZKUlZWlTZs2KScnR4Zh6Pzzz9f555/fkvEAAAAAAAAAAADQxhQVFXk8tlgsCg0NNSkNAABA2xUSEiKr1aqKigp3W/X3Ur6sRYuYlixZUue+l19+WW+++aa6d++uBQsW6Nprr5XN5nn6iooKvffee3rooYe0fft23XvvvZoxY0ZLRgQAAAAAAAAAAEAb4nA4PB4HBATIYrGYlAYAAKDtMgxDQUFBys/Pd7dVfy/ly7zyDjAlJUV33XWXOnXqpO+//16TJ0+uUcAkSVarVZMnT9a6desUFRWle+65RykpKd6ICAAAAAAAAAAAABNU/+DNbreblAQAAKDtq/5eiSKmJnryySdVUVGhuXPnKi4ursH+Xbt21dy5c1VeXq6FCxd6ISEAAAAAAAAAAADMQBETAABA48XGxqpXr15KTExU//79FRERYXakFtOiy8nVZc2aNZKkESNGNPqYCy+8UJL07bfftkomAAAAAAAAAAAAmK96EZOfn59JSQAAANq+zp07ezzOy8szKUnL88pMTCdOnJAklZaWNvqYyr6VxwIAAAAAAAAAAKD9qaio8Hhss3nlb/ABAADQxniliCkmJkaS9Omnnzb6mE8++USS1KlTp1bJBAAAAAAAAAAAAPOxnBwAAAAkLxUxXXrppXK5XFq4cKHWrl3bYP/vvvtOTz75pAzD0GWXXeaFhAAAAAAAAAAAADADRUwAAACQvFTE9Ktf/Ur+/v4qLS3VZZddppkzZ2rTpk1yuVzuPi6XS5s2bdKsWbN06aWXqqSkRH5+fvrVr37ljYgAAAAAAAAAAAAwQZ8+fZScnKyBAwfq3HPPVXh4uNmRAAAAYAKvLCqclJSkV155RbfccovKysr097//XX//+9/l5+enqKgoGYahU6dOqaysTNKZgiabzaYlS5YoKSnJGxEBAAAAAAAAAABgAj8/P4WFhZkdAwAAwOe4XC5VVFSYHaPFeKWISZKuv/569e7dW/fcc482btwoSSotLdXRo0dr9L3gggv07LPPavjw4d6KBwAAAAAAAAAAAAAAALRpDodDqampKi8vl8PhkMvlkt1uV3l5udnRzprXipgkadiwYdqwYYNSUlL01VdfaevWrcrOzpYkRUZGatCgQbr88ss1bNgwb8YCAAAAAAAAAAAAAAAA2jyr1aqioiKPNpvNRhFTcw0dOlRDhw4149QAAAAAAAAAAAAAAACATzIMQzabTQ6Hw91mt9tVXFxsYqqWYTE7AAAAAAAAAAAAAAAAqN/SpUtlGIYMw9D+/fvNjgPARHa73eOxzWbKHEYtjiImAAAAAAAAAAAAmMJut6uoqEilpaVyOp1mxwEAAPAJ1YuYqj/2VV4pxfrmm2/O6vhLLrmkhZIAAAAAAAAAAACgrejUqZN27drlfhwdHa2BAweamAgAAKDta68zMXnlWYwZM0aGYTTrWMMwPNbxAwAAAAAAAAAAQPtQ/QM4q9VqUhIAAADfQRHTWXK5XN46FQAAAAAAAAAAAHxA9Q/c2stSKAAAAK2J5eTOwsqVKxvsU1hYqPT0dC1btkzr16/XqFGj9Nhjj1FxDwAAAAAAAAAA0E5RxAQAANB07XUmJos3TjJ69OgG/40fP14zZ87U999/r7/85S9au3atXn75ZY0ePdobEQEAAAAAAAAAAOBl7XUWAQCtY+XKlZo6darOOeccBQUFKSwsTIMGDdJDDz2kI0eO1HrMvHnzZBiGDMOQJJWUlGj+/Pm64IILFBoaqtDQUA0fPlxPP/20HA5HjePfeecdxcXFyWaz6csvv2ww45133inDMOTv76+cnJwWex5NceLECf3mN79RcnKyIiIiFBAQoF69eunWW2/Vt99+W++xvXr1kmEYmjZtmiRpw4YNuummmxQfH6+AgADFx8dr+vTp2rlzZ6Oy7NmzR7NmzdKgQYMUHh6uwMBAnXPOOZo2bZpSUlLO9qkCHVZ7fQ/llSKmpnrooYc0adIkvfXWW1q2bJnZcQAAAAAAAAAAANAKmIkJQGOUlJTopptu0qWXXqpXX31V+/btU3FxsfLz85WWlqYnnnhCffv21fLly+sdJysrSyNHjtScOXOUmpqqgoICFRQUaMOGDbr//vs1adIkOZ1Oj2N+8pOfKCAgQJL05ptv1jt+eXm53n33XUnS+PHjFRkZ2SrPoz5ffPGFEhIS9Mc//lGbNm1Sbm6uSktLdeDAAb3++uu6+OKLdd9999V4nrV5+eWX9aMf/UjLli3T4cOHVVpaqsOHD2vp0qUaPHiw3nnnnXqPf+KJJ9S/f3899dRTSktLU15enkpKSrRv3z698sorGj58uB599NFmP1egI2MmJi+bMmWKXC6XFi9ebHYUAAAAAAAAAAAAtIL2OosAgJbjcrl03XXXuSe/uPLKK/Xaa69p7dq1WrdunRYtWqQePXqosLBQ1113Xb2z+0yaNEnbt2/XAw88oC+//FIbN27Um2++qX79+kmSli9frhdeeMHjmJCQEI0bN06S9N5776mkpKTO8T/99FNlZ2dLkm6++eZWex512bRpk6688krl5eXJbrdr1qxZWrlypdavX69//OMf6t27tyTpmWee0cMPP9zgWHfddZdiY2P197//Xf/5z3+0evVq/fKXv5S/v79KS0t1880315lz/vz5euihh1ReXq7zzjtPzz33nL766iulpKTojTfe0MiRI+VyufT73/9ef/vb35r8XIGOrr2+h2qzpVg9evSQJG3dutXkJAAAAAAAAAAAAGgNzMSE9sjpcup06WmzY3hVhH+ELEbrzJ/x4osvasWKFbLb7froo4/04x//2GP/hRdeqFtvvVUXX3yxtm3bppkzZ9a5ZNqGDRv0xRdfaMyYMe62Cy64QFdccYX69++vrKwsPfvss7rzzjs9jps0aZI++ugj5eXl6eOPP9Z1111X6/iVMzWFhYVp4sSJrfY86nLHHXeorKxMVqtVH3/8sbv4SpKGDRumyZMn66KLLtL27dv1xBNPaMqUKRowYECtY23evFk9e/bU999/ry5durjbL7nkEl1xxRUaN26cysvLdc8992j9+vUex27fvl2//vWvJUm//e1v9dvf/ta9nJ8kDRkyRDfeeKOmTp2q119/Xb/+9a9166231pi5CkDdqr9nslgsslja7DxGjdZmi5iysrIkSYWFhSYnAQAAAAAAAAAAQEurrWCJIia0B6dLT2v026PNjuFVq29YraiAqBYf1+Vy6S9/+Ysk6YEHHqhR+FMpMjJS8+fP1/jx47V27Vrt3r1biYmJNfrdf//9HgVMlaKiojR9+nT9+c9/1tatW5Wbm6vw8HD3/rFjxyo6OlqnTp3SG2+8UWsRU0FBgT766CNJ0v/93/+5l6BrjedRm/Xr12vDhg2SpNtvv92jgKnq+IsXL9ZFF10kp9OpZ599Vs8880ydYy5YsMCjgKnS2LFjdfvtt+u5557Thg0blJKSoqFDh3ocV15erqFDh9YoYKpksVj097//Xe+8844KCgr07rvv6vbbb2/UcwVQ+3um9rCkXJstw6q8WVbOyAQAAAAAAAAAAID2o7YP2trDh28AWs727duVkZEhSXXOflTpkksucW+vW7eu1j7Vl3irasiQIZLOFBzt27fPY5/dbnef/9NPP9Xp06drHP/++++ruLi41vO09POozVdffeXenjFjRp39Ro0a5V4+r+ox1UVGRurqq6+uc//PfvazWs8tnVmWTzpTzFVbAVOliIgIDRo0SFLTnisAyWq11vj6ag/F4G2qiCknJ0dffvmlxo8fr48//liGYWjSpElmxwIAAAAAAAAAAEALq16wZLPZ2sUyKABaTkpKint75MiRMgyjzn8hISHuvseOHat1vKSkpDrPFRX1v5mk8vPza+y/6aabJEmlpaV69913a+yvXEouLi5OY8eObdXnUZu0tDRJkp+fnwYPHlxv3xEjRkiSdu/erbKyslr7JCcn11tYOnjwYPn5+UmStm7d6m4/cOCATpw4IUl6+OGH632uhmG4X5umPFcAkmEYio+PV69evRQfH6/09HSVlJSYHeuseaWc3Wq1Nuu4xMRE/fKXv2zhNAAAAAAAAAAAADBb9dkC2sPsAQBa1vHjx5t1XFFRUa3tQUFBdR5TtYiyoqKixv5Ro0apZ8+eOnDggN544w3ddtttHjkrZyO68cYbaxRktvTzqE12drakM8VYDc1qV7lEnMvlUk5Ojjp37lyjT2xsbL1j2Gw2RUVF6dixY+5zS955rgDO6N27tyQpLy/P4+vQl3mliMnlcjWpv81m0+TJk/Xkk096rDUKAAAAAAAAAACA9qG2mZiA9iDCP0Krb1htdgyvivCPaJVxqxYTLV++XL169WrUcQ0V4DSHYRj66U9/qscff1zffPONMjMz1a1bN0nSP//5TzkcDkm1L1nnzedR3/Jt3hin6nN99NFHNXny5EYdFxwc3KzzAWhfvPJu8Le//W2DfSwWi0JDQ9W7d2/96Ec/UkxMjBeSAQAAAAAAAAAAwAzVi5aYiQnthcWwKCogquGOaFB0dLR7OyIiQgMHDjQxzZkCpccff1xOp1NvvfWWfvGLX0j631JySUlJuuCCC2oc543nUbkc3qlTp+RwOOotDK1cus0wDEVGRtbaJysrq97zORwOj9mfKlV9rna73fT/MwC+pc0UMQEAAAAAAAAAAKDjYDk5AA1JTk52b69du1YXXXSRiWmkAQMG6Pzzz9fmzZv15ptv6he/+IX27dundevWSap9FibJO8+jsliorKxMmzZt0tChQ+vsu379eklSYmKi/Pz8au2zadOmeouhNm/erLKyMo9zS9I555yj8PBw5ebmau3atc16LgA6LkvDXQAAAAAAAAAAAICWlZmZqa1bt6pPnz5KSkpSly5dzI4EoI254IIL1L17d0nS4sWLVVJSYnKi/xUqpaamaseOHe5ZmCTppz/9aa3HeON5XH755e7tl19+uc5+69at0/bt22scU112draWL19e5/6q56g6jtVq1fjx4yVJX3zxhXbs2NFweAD4L68UMf3ud7/T7373O508ebLRx+Tk5LiPAwAAAAAAAAAAQPvicDhUWFiosLAwde7cWREREWZHAtDGWCwWzZ07V5K0d+9eTZkyRaWlpXX2z8vL09NPP92qmW666SYZhiFJeuONN/TWW29JkkaOHKlzzjmn1mO88TyGDx/unn3phRde0Ndff12jT25uru688053prvvvrveMX/+85/Xuqzc6tWrtXjxYknSkCFDNGzYMI/9Dz/8sKxWq5xOp6677jodPny4znNUVFTojTfeqLcPgMaxWHx/HiOvLCc3b948GYah6667Tp06dWrUMdnZ2e7jHn300VZOCAAAAAAAAAAAAABoa+666y59+eWXev/99/XOO+/ohx9+0J133qnhw4crPDxceXl52rlzp1atWqWPPvpIAQEBuu+++1otT/fu3TV69GitWrVKzzzzjE6fPi2p7qXkvPk8XnjhBY0YMUJlZWUaP3687r//fl155ZUKDg5Wamqq/vznP2vv3r2SpF/84hcey8BVd/7552v79u0aMmSIHn74YQ0fPlylpaX65JNP9OSTT7qXmnvmmWdqHDto0CA98cQTmjVrlrZv366BAwfqjjvu0KWXXqrOnTurpKRE+/fv17p16/Tuu+/q6NGj2rp1q3u2KgCNk52drYyMDJWVlWnEiBEqLi42O9JZ80oREwAAAAAAAAAAAAAATWUYht5++209+OCDev7555WRkaE5c+bU2T82NrbVM918881atWqVu4DJZrPp+uuvr/cYbzyPwYMHa/ny5Zo8ebLy8vK0YMECLViwoEa/e++9V48//niDY9133326++67ay2m8vPz0yuvvKIRI0bUevzMmTMVHBysmTNnKjc3V/Pnz9f8+fNr7evn56eAgIBGPEMA1RUVFUk6c4+x2Xy/BKjNziVVXl4uSbLb7SYnAQAAAAAAAAAAAACYxW6369lnn9XmzZt1//33a9CgQQoPD5fValV4eLgGDx6sGTNm6N1339WOHTtaPc91110nf39/9+Nx48YpJiamweO88TzGjRunPXv2aO7cuRo8eLDCwsLk7++vHj166Oabb9aaNWv09NNPN2rZqdtuu01r1qzR9ddfr7i4OPn5+albt26aMmWKUlNTdeONN9Z7/O233669e/fqscce06hRo9SpUyfZbDYFBwerb9+++r//+z89//zzyszMVEJCQrOeL9CRVa+nsdvtcrlcJqVpGW22DGvTpk2S1KibPQAAAAAAAAAAAACgfRs0aJD+9re/NemYefPmad68eQ32GzNmTKM//I+IiFBJSUmTclTVnOchSdOmTdO0adMa7BcTE6M//vGP+uMf/9iMdJ4uvPBCvf32280+vnPnznr00Uf16KOPnnUWAJ6qFzEZhqGKigqT0rSMVilievXVV2tt//DDD5WSklLvsaWlpcrIyNDLL78swzA0bNiw1ogIAAAAAAAAAAAAkzidTgUFBcnhcMjpdJodBwAAwOfUtrIZRUy1mDZtmgzD8GhzuVz6zW9+0+gxXC6XLBaLHnzwwZaOBwAAAAAAAAAAABOVlJTovPPOkyRt3rxZVqtVo0aNqvH5EgAAAGpntVplsVg8CsIdDoeJic5ewwtdNpPL5XL/q62tvn92u12jRo3SRx99pNGjR7dWRK84cOCAZs+eraSkJAUHBysqKkrDhg3T/PnzVVRU1GLn+fTTT3Xttdeqe/fu8vf3V/fu3XXttdfq008/bfQYDodDzz//vC6++GLFxMQoMDBQffr00Z133qlt27a1WFYAAAAAAAAAAHyFL/2e35dU/4DNYrFQwAQAANBE1Wdj8vUiplaZiWnfvn3ubZfLpXPOOUeGYejzzz9XYmJinccZhqGAgABFR0fLarW2RjSvWr58uW655Rbl5eW524qKipSSkqKUlBS9+OKLWrFihRISEpp9DqfTqTvuuEMvvfSSR3tmZqYyMzP1wQcf6LbbbtM//vEPWSx116ydPHlS48eP14YNGzza9+7dq8WLF+uVV17R008/rdtuu63ZWQEAAAAAAAAA8CW+9Ht+X1P9A7balkMBAADedezrr7Vp4UKd2LVL5cXFsgcGKubcczX45z9Xl8suMzseamG321VaWup+TBFTLXr27Flre1xcXJ372pvU1FTdcMMNKi4uVkhIiB5++GGNHTtWxcXFWrZsmV544QWlp6drwoQJSklJUWhoaLPO8+tf/9r9g01ycrLmzJmjPn36KCMjQ3/961+VmpqqF198UTExMfrTn/5U6xgVFRW69tpr3QVMkyZN0u23366oqCj95z//0R/+8AcdP35cd955p7p166af/OQnzXtRAAAAAAAAAADwEb70e35fVFFR4fGYIiYAAMxzeMUKrZw5U1l79tTYl5WRobRPPlGXhASNeeopdZ8wwYSEqAszMTVD1fX3OooHH3xQxcXFstls+uKLLzRy5Ej3vksvvVSJiYmaM2eO0tPTtWDBAs2bN6/J50hPT9cTTzwhSRo6dKi++eYbBQYGSpKGDRumq666SqNHj1ZKSormz5+vn/3sZ7X+Ncgrr7yib7/9VpJ0zz336JlnnnHvGz58uH7yk59oyJAhysvL0wMPPKAdO3bIZvPKpQMAAAAAAAAAgCl86ff8voiZmACgbdq/f7/ZEeBl6YsXa8W996qigeKXY3v26J1rrtGEZ55R3zvu8FI6NKS9FTG1n3lH25D169drzZo1kqQZM2Z4/GBTafbs2erXr58kadGiRSovL2/yeZ566in3Bfj3v//d/YNNpaCgIP3973+XdOZCffLJJ2sdp/IHpKioKM2fP7/G/oSEBD388MOSpD179uj9999vclYAAAAAAAAAAHyFr/2e3xdRxAQAgPkOr1jRqAKmShUOh1bce68Or1jRysnQWBQxoUEffPCBe3v69Om19rFYLJoyZYok6fTp01q5cmWTzuFyufThhx9KkpKSknThhRfW2u/CCy/UueeeK0n68MMP5XK5PPanp6drx44dkqTrr79eQUFBtY4zbdo09zZFTAAAAAAAAACA9syXfs/vqyhiAgDAfCtnzmx0AVOlCodDq2bObJ1AaLLq76GqL9nra1p0TbCf/exnkiTDMNzrN1dtb47qY/mCyqXZgoODNWTIkDr7jR492r29du1ajRs3rtHn2Ldvn44cOVJjnLrOs2vXLmVmZmr//v3q3bt3jawNjdOlSxf17dtX6enpWrt2baNzNoclZ590ohn1dfYgyR5Y+76ibEnN/MHOFij51V7cpeIcydXM5RJt/pJfSO37SnIlZzMrJK12yT+s9n2leVJF0/8aSJJksUkB4bXvKyuQHKXNG9ewSIGRdYxbJDmKmzeuDCkoqvZd5cVSeVGdR1oKChTlPHFm+9RuqbTa/1NQdO0HOkrPvBbNFRApWWq59h1lUll+88f1D5estdzuKxxSaW7zx/ULlWx+NdudTqkk5yzGDTnz9VGbolPNH9eH7xFGUb4CXYX/3T4llZ/gHiGZdo9oUDu/RzR4j6zEPeIM3kec0Ur3CKOwyPP+aC2rMi73iDPj8j7CzQv3iEbfIytxjziD9xH/04L3iKrXo1F4wvMe6R6Xe4Qb7yPOaMV7hCU3p2n3yErcI/6nvb2PqHw+gVG1nx8wmS/9nt9XUcQEAIC5jn71lbL27GnWscf27NGxr79Wl8sua+FUaKr2NhNTixYxLV26VIZhSJJH4VHV9qZwuVw+WcRUObNRQkKCbLa6X+KkpKQaxzTW9u3bax2nMeep+sNNU8dJT0/XoUOHVFhYqODg4EbnPXz4cL37jx496t4OfvcGKYxfXMA8IZJur3zwygsmJgHOCJX0QOWD5xeZmATgHom2hfsj2hrukWhLPK7Hf3A9wnzcI1GX/Ls2yVVXgVYrKSws9Or54Jt86ff8DWnK7+fz8/OVl5fX6LHPRlmZZ5G1w+Hw2rnRfhUUFNS63ZIcDoecTqdcLpfPz3aBhlX9P+b/u+NwuVxyOp2t8r3JG/epxvrhiSfO+viLhg1roTRorupLGpeVlXntPVV+/ln84UsdWrSIqUePHrUWK9XV3h6VlJTo5MmTkqTu3bvX2zcyMlLBwcEqLCzUoUOHmnSeqj90NHSe+Ph493b18zRnHJfLpcOHD7unr22MqhkAAAAAAAAAQJKWLF2iYqPxfyzZEnJzz2K2OHQIvvZ7/oY05ffzr732msLD65gBr4VdcMEF8vP73+yLn3/+uU6fPu2Vc6NjeO2111pl3MGDBys8PFwhISE6fvx4q5wDbdOpU2cxgyt8SllZmQoKCpSbm6uPPvqo1c7TWvepxupUpaC6OY5u26bnnnuuhdKgucLCwtS/f3/34+LiYq/9v7TGz1YtWsS0f//+JrW3R1UrzUJCGp4Wu/KHm6ZWWTblPFVnTKp+npYaBwAAAAAAAACA9sDXfs/vq6xWq8djX1/6BAAAX1NR2szluSuPL6tl6Xp4XUlJiY4ePary8nI5HI4aMzP5mhYtYsKZC6RS1b8gqIu/v7+kM9VwrXWeynPUdp6WGqchDf1lyNGjRzV8+PAmjQkAAAAAAADAt02fNt3ry8mlp6fr8ccf9+o54Vt87ff8DWnK7+dvvfVWdevWrUnjN9fWrVs9Cpeuuuoqr80ChfaroKDAPbPJrbfe2qhCxKbKzMyU0+mU3W5XbGxsi4+PtqWiosI9A1N0dHSNAky0T/n5+QoNDVV4eLhGjhzZomN74z7VWB8sXqy8s5hRLjAkRDfefXcLJkJzmXVdZWZmtvjPVhQxtbCAgAD3dvX1nGtT+t/qxsDAwFY7T2mVCsrq56k+TtXHTRmnIQ1NhVtV4XVvS4l9mjS+JMkeJNnryFWULcnV9DElyRYo+QXVvq84R3I5mzmuv+RXx82jJFdyNvOvTqx2yT+s9n2leVJFMysvLTYpoI4fIMsKJEczK3UNixQYWce4RZKjaT+QVxlYCoqqfVd5sVReVOeRBQUFemvZW5Kkm268qeZNvq5frDlKz7wWzRUQKVkstYxbJpWdxXqi/uGStZbbfYVDKj2LKf78QiVbLb9ccTqlkpyzGDfkzNdHbYrOYqpWH75H5Ofna8nSJZLO/HI31O7kHiGZdo9oUDu/RzR4j6zEPeIM3kec0Ur3iPzCIi1Z9r6k/94fQ0OrjMs94sy4vI9w88I9otH3yErcI87gfcT/tOA9our1eOO0uxUaVstrzD3if3gfcUYr3iMKcnOado+sxD3if9rb+4j/Pp/QwKjaz9+Kqs5oA9TG137P35Cm/H4+NDRUYWF13M9bmN1u9yhistvtXjs3OoaQkJBWuaaysrLkcDhkGAYFLR2M1Wrl/7yDMAxDFotFNputVb83tdZ9qrFik5J0fO/eZh8fk5TE9+42yJvXVV5eXouPSRFTC6v6wUljpnQtLCyU1LgpaZt7nspz1Hae6uPUV8RU3zgtyRnZW4o5t2UHDe7UsuMxrpfGbZ1hG+L0z1O2JebMdnSi1K6/+XZpnWFDW+mvT3zuGm6ZcV0Vfio2znxBuIKiW++abOOvQ81xW2dYVFXzHtEi90juEYzbQuO6/PM874/BVa5H7hFewPuI6uO26PvINvg1177GbZ1h25Kq16MrOMbzHukV3CMY13Ncp60VftbmHuHDWukeAbQQX/s9v6+y2Tw/ovL1pU8AAPA158+apbRPPmn28YNnzWrBNMAZ3v0Tlw4gICBA0dFn/oro8OHD9fbNyclx/+ARHx/fpPNU/cuJhs5TdarY6udpzjiGYTTpLzcAAAAAAAAAAPAVvvZ7fl9VfTYTipgAAPCurpdfrs4JCc06tktCgrpcdlkLJwJaeCamc845pyWHk3SmYCYjI6PFx21N/fv315o1a7Rnzx45HI4af01QaefOne7tfv36NfkctY3T1PNUH2fw4MENjhMfH8+UywAAAAAAAACAdsuXfs/vqzp16qSUlBQ5HA5dddVV7sIxAADgPWOfekrvXHONKhyNX1rcardrzFNPtV4odGgtWsS0f//+lhxO0pkiJl9z0UUXac2aNSosLNTGjRs1YsSIWvutXr3avT1q1KgmnaN3796Ki4vTkSNHPMapzTfffCNJ6tatm3r16lUja9U8N954Y61jHDt2TOnp6c3KCgAAAAAAAACAL/Gl3/P7qtDQUJ08eVKSFBwcLD8/P5MTAQDQ8XSfMEETnnlGK+69t1GFTFa7XROeflrdJ0zwQjp0RC1axDR16tSWHM5nXXPNNXr88cclSUuWLKn1hxun06lXX31VkhQREaGxY8c26RyGYejqq6/Wc889p507d+r777/XhRdeWKPf999/7/4LjauvvrpGUVjfvn3Vr18/7dixQ//85z+1YMECBQUF1Rhn6dKl7u1rr722SVkBAAAAAAAAAPAlvvR7fgAAgLPR9447FNStm1bNnKlje/bU2a9LQoLGPPUUBUxoVS1axLRkyZKWHM5nDR8+XBdffLHWrFmjl156SVOnTtXIkSM9+ixYsEA7duyQJD344IOy2+0e+1etWuX+gWfq1KkeRUSVZs6cqcWLF6uiokL333+/vvnmGwUGBrr3FxcX6/7775ck2Ww2zZw5s9a8v/jFLzRjxgxlZ2drzpw5evrppz32Z2RkuH9YS0hIoIgJAAAAAAAAANCu+drv+QEAAM5G9wkTdMuECTr29dfa9OSTOrFrl8qLimQPClLMuedq8KxZ6nLZZWbHRAfQokVM+J9FixZp1KhRKi4u1rhx4zR37lyNHTtWxcXFWrZsmRYvXizpzExIs2fPbtY5+vbtq4ceekh//vOflZKSolGjRumXv/yl+vTpo4yMDP3lL39RamqqJOmhhx5SYmJireNMnTpVL7/8stauXatnnnlGx44d0+23367IyEitX79ev//975WXlyeLxaK//e1vda79DQAAAAAAAABAe+FLv+cHAABoCV0uu0w/plgJJqIapZUkJyfr7bff1i233KK8vDzNnTu3Rp++fftqxYoVCg0NbfZ5/vjHP+r48eN6+eWXlZqaqhtvvLFGnxkzZugPf/hDnWNYrVZ98MEHGj9+vDZs2KB//etf+te//uXRx9/fX08//bR+8pOfNDsrAAAAAAAAAAC+wpd+zw8AqKlXr146cOBAnbPhmWnevHl67LHHJEkul8vkNADQdljMOrHL5VJGRoY2bNigDRs2KCMjo93doK+88kpt2bJFs2bNUt++fRUUFKSIiAgNHTrU/dcTCQkJZ3UOi8Wil156SStWrNDVV1+tuLg4+fn5KS4uTldffbU++eQTvfjii7JY6v+v7tSpk7777js9++yzuuiiixQdHa2AgACdc845uv3227Vx40bddtttZ5UVAAAAAAAAAABf4ku/5/dVhmGovLxcBQUFcjqdZscBAACAibw+E9Nnn32mZ599VqtWrVJhYaHHvqCgII0ZM0b33HNPu5nxp2fPnlq4cKEWLlzYpOPGjBnTpKKu8ePHa/z48U2N58Fms+nuu+/W3XfffVbjAAAAAAAAAADQXvjS7/l9icvl0tChQ2Wz2ZSWliZJGjZsmIKCgkxOBvieimPHVLZxoyqOHZOrrEyGn5+sXbrIb8gQWbt0MTseAACN5rUipqKiIt1666364IMPJNU+LV5hYaE++eQTffLJJ7rqqqv0+uuvKzg42FsRAQAAAAAAAAAA4AWGYdRoKy8vNyEJ4LscmZkq+fxzVRw6VGNfxeHDKktJkTU+XgFXXCFbt24mJAQAoGm8Mveo0+nU+PHj9cEHH8jlcslms2nChAl67LHH9Pzzz+v555/XY489pokTJ8put8vlcumjjz7S+PHj290ScwAAAAAAAAAAAJAcDofHY4qYgMYrT09X4dKltRYwVVVx6JAKly5VeXq6l5K1jiNHjuhXv/qVLrjgAoWHh8tut6tz584aNGiQbrrpJi1dulR5eXmSzsyEZxiGDhw4IEl65ZVXZBiGx78xY8Z4jJ+Tk6MlS5bolltuUf/+/RUSEiI/Pz9169ZNN910k15//XWVlZXVmW///v3usZcuXSpJeu+99zR+/HjFxcXJZrNpzJgxWrp0qQzD0GOPPeY+tno2wzC0f//+Fn39AMBXeGUmpn/84x/65ptvZBiGrrjiCr344ovqVke1b2Zmpm6//XZ99tln+vbbb/X888+zvBkAAAAAAAAAAEA7QxET0DyOzEwVvfOOVO1rqO4DHCp65x0FT5vmkzMyrVmzRhMnTnQXKVU6fvy4jh8/rrS0NC1btkydOnXSxIkTm3WO5ORkd9FTVVlZWcrKytLq1av11ltv6ZNPPlGXBpboc7lcmjJlil577bVmZQGAjswrRUyvvPKKpDNrGa9YsUIWS90TQHXr1k3Lly/XqFGjtH79er3yyisUMQEAAAAAAAAAALQz1YuWKGICGqfk888bX8BUyeFQyeefK+RnP2udUK2ktLRUN954o/Ly8hQaGqq7775bY8eOVWxsrMrKyrRv3z599913ev/9993HLFmyRIWFhbriiit05MgRXX311frDH/7gMW5wcLDH44qKCo0YMUITJ05UcnKyOnfurLKyMmVkZGjJkiVauXKlUlNTdeONN2rVqlX1Zn7qqae0ZcsWXXzxxbr77rvVt29fnT59Wvv379c111yjoUOH6tlnn9Vzzz0nSdq6dWuNMeqaEAQA2juvFDHt2LFDhmFo1qxZ9RYwVbJarfr5z3+uG2+8UTt27PBCQgAAAAAAAAAAAHgTMzGhvXK5XHIVFbXK2BXHjze4hFydxx46pPJ9+2SNjW3hVJIRFCTDMFp83LVr1+rIkSOSpDfffLPGTEsXXnihbrrpJj355JMq+u9r3rt3b0mS3W6XJEVERGjgwIH1nuff//63EhMTa7SPGDFCl19+uZYtW6af//znWr16tb7++mtddtlldY61ZcsWTZkyxb10XHURERGKrfJ/0FA2AOhIvFLEVHlz7tu3b6OPqfwm0Rrf7AAAAAAAAAAAAGAuZmJCe+UqKlL+E0+YHaNWRa++2irjhv7iFzKqzW7UEo4dO+bevuSSS+rsZ7PZFBYW1uzz1FbAVNWNN96oV199VZs2bdIHH3xQbxFTRESEnn76aT7nBoBmaHhapBbQp08fSWfWJW2syr6VxwIAAAAAAAAAAKD9YCYmAA3p2rWre3vJkiVeOafL5dKxY8eUnp6utLQ07dy5Uzt37lRcXJwkafPmzfUef+WVVyo0NNQbUQGg3fHKTEw33XSTUlNT9eqrr+qKK65o1DGvvvqqDMPQDTfc0MrpAAAAAAAAAAAA4G0UMQFoyEUXXaRzzjlHe/fu1cyZM/XGG2/o2muv1SWXXKJhw4bJz8+vxc61YsUKPffcc/rmm2+Un59fZ7+TJ0/WO855553XYpkAoKPxykxMDzzwgC644AItW7ZMf/3rXxvsP3/+fL311ltKTk7WzJkzWz8gAAAAAAAAAAAAvIrl5AA0xG63a/ny5erXr58kacOGDZo7d64uuugiRURE6Mc//rHefPNNVVRUNPscLpdLt912myZOnKgVK1bUW8AkScXFxfXuj4yMbHYWAOjovDIT07Fjx/Tiiy/qzjvv1MMPP6y33npLU6dO1bBhwxQbGyvDMJSVlaUNGzbotdde06ZNmzRs2DAtXrzYY53T6nr06OGN+AAAAAAAAAAAAGhhzMSE9soIClLoL37RKmOXfPmlyhtYzqw+9sGDFXD55S2Y6AwjKKjFx6zUv39/bd26VcuXL9fy5cv1zTffaM+ePSouLtbnn3+uzz//XAsXLtQnn3yi2NjYJo//8ssv66WXXpIkDR48WDNnztSIESPUrVs3+fv769SpU5KkOXPm6PXXX5fL5ap3PKvV2vQnCQCQ5KUipl69eskwDPfjLVu2aPbs2fUek5KSogsuuKDO/YZh1HhzCwAAAAAAAAAAAN9QvWipoqJCTqdTFotXFhIBWo1hGDKCg1tlbP8LLzyrIib/ESNkaaVsrclqteqaa67RNddcI0k6evSoPvvsMz3zzDPauHGjNm7cqDvvvFPvv/9+k8d+4YUXJEkJCQn67rvvFBgY6N5XdYan7Ozss3sSAIAGee1doMvlavF/AAAAAAAAAAAA8E21/bE6szEB9bN26SJrfHzzjo2Pl7VLlxZOZI6uXbtq+vTpWrdunXtijI8//thjqbeqk2zUZ9u2bZKkq666yqOAqSqXy6XU1NSzTP0/jc0GAB2NV2ZiWrJkiTdOAwAAAAAAAAAAAB/hcDjkcrk8PswvLy+Xv7+/iamAti/giitUuHSp1JRVa2w2BVxxRatlMovdbtfo0aP1ww8/yOFw6PTp0+5CpICAAElSaWlpvWNUFlQWFhbW2eezzz7T0aNHWyj1/7JJZ/Jx3wOAM7xSxDR16lRvnAYAAAAAAAAAAAA+xOFwyG63ux8zExPQMFu3bgqaPFlF77zTuEImm01BkyfL1q1b64drYWvWrFHXrl2VkJBQ6/6ysjKtXr1akhQSEqKYmBj3vq5du2rnzp3KyMio9xyJiYnaunWrli9frj/96U+Kiory2L9//379+te/Pstn4qlr167u7YyMDPXv379FxwcAX8WiwgAAAAAAAAAAADDFwYMH1aNHDw0cOFDJyckKDQ01OxLgE+x9+yp42rQGl5azxscreNo02fv29VKylvX111/r3HPP1ZgxYzR//nx9/vnn+uGHH7R27VotWbJEF198sX744QdJ0owZM2Sz/W8Ojx/96EeSpA0bNujPf/6zNm/erD179mjPnj3KzMx095syZYok6ciRIxo5cqRefvllrV+/Xt98840ee+wx/fjHP9bp06fdy9a1hMpskjRr1ix988032r17tztfbcttAkBH4JWZmAAAAAAAAAAAAIDqTpw4oejoaIWFhZkdBfA5tm7dFPKzn6ni2DGVbdyoiqwsuUpLZfj7y9q5s/yGDJG1SxezY541p9Op1atXu2dcqs3VV1+txx9/3KPt7rvv1nPPPafs7Gw9/PDDevjhh937Ro8erVWrVkmSHnzwQX355Zf64osvlJ6erhkzZniMExAQoEWLFmnt2rXugqmzlZCQoOuvv17//Oc/9cUXX+iLL77w2L9v3z716tWrRc4FAL6EIiYAAAAAAAAAAAAA8FHWLl0UOGGC2TFaxS9+8Qudd955+uqrr5SamqojR47o+PHjkqQuXbpo+PDhmjJliibU8vy7deum9evX6/HHH9fq1at1+PBhlZSU1Ohnt9u1YsUKPffcc3r11Ve1fft2uVwudevWTZdddpl++tOfKjExUWvXrm3R5/b6669r6NChevfdd7Vr1y7l5+fL6XS26DkAwNd4tYjJ4XBoxYoVWrNmjfbu3av8/HxVVFTUe4xhGPr666+9lBAAAAAAAAAAAAAA0BaEhIRo0qRJmjRpUrOO79Onj1588cUG+9lsNt1///26//77PdorKircRVMvv/yyXnnllVqP79Wrl1wuV5Oy2e12PfTQQ3rooYeadBwAtGdeK2JavXq1pk2bpoMHD7rb6ruRG4Yhl8slwzC8EQ8AAAAAAAAAAAAAAACASbxSxLRp0yb9+Mc/VllZmVwulwICApSYmKiIiAhZLBZvRAAAAAAAAAAAAAAAAADQRnmliGnevHkqLS2Vv7+/Fi5cqP9n787Doyrv//+/TpZJJtskZCEJS0JIkC0SVkVU0Fr1g1LrjlIUF0RbF6yKH2t/alet2FrXFtQW0Wjd/Uq1LdoPoCIqKCCQAEkgbNlD9n2W3x80U4bsIcmZJM/HdXFdZ+77Pvd5HTgkgXnPfd9www0KDAzsi0sDAAAAAAAAAADAyzmdTjU1NcnhcCgoKMjsOAAAADBBnxQxff755zIMQw8++KBuu+22vrgkAAAAAAAAAAAAvFxYWJi2b98up9MpSQoICNDpp59ucioAAACYoU/2cquvr5ckXXjhhX1xOQAAAAAAAAAAAPQDTqfTXcAkSU1NTXK5XCYmAgAAgFn6pIgpMTFR0rEfPAEAAAAAAAAAAACp5XtHJxY1AQAAYPDokyKmH/7wh5KkTz/9tC8uBwAAAAAAAAAAgH7Abre3aOND8QAAAINTnxQx3XXXXYqLi9MTTzyh3NzcvrgkAAAAAAAAAAAAvJzD4ZBhGB5tFDEBAAAMTn1SxBQdHa2PPvpIVqtVp512ml544QVVVFT0xaUBAAAAAAAAAADgxXx9fT1eU8QEAAAwOPn11YVOPfVUffrppzrttNN066236rbbblNUVJSCgoLaPc8wDOXk5PRRSgAAAAAAAAAAAPQlPz8/j23lKGICAAAYnPqsiOmdd97R2haEHgAA1YtJREFUTTfdpKqqKrlcLrlcLhUVFXV43olLiAIAAAAAAAAAAGDg8PPzfLuKIiYAAIDBqU+KmDZt2qT58+fL4XBIkhISEnTqqacqPDxcPj59sqMdAAAAAAAAAAAAvBBFTAAAAJD6qIjp17/+tRwOh2w2m9LT0zV37ty+uCwAAAAAAAAAAAC8HEVMAAAAkKQ+WQZpy5YtMgxDv/jFLyhgAgAAAAAAAAAAgBtFTAAAAJD6qIiptrZWknTmmWf2xeUAAAAAAAAAAADQT1DEBAAAAKmPiphGjRol6b/FTAAAAAAAAAAAAIAk+fr6erymiAkAAGBw6pMipssuu0wul0v/+te/+uJyAAAAAAAAAAAA6Cf8/f09XtfV1cnhcJiUBgAAAGbpkyKme+65RykpKfrjH/+oLVu29MUlAQAAAAAAAAAA0A8EBQV5vDYMg909AAAABiG/joecvNDQUP373//WlVdeqbPPPlt33323rr76ao0ZM0aBgYF9EQEAAAAAAAAAAABeyNfXV8OGDZPFYpHNZlNoaKh8fPrkc/gAAAD9SlVVlQzDUHBwsAzDMDtOj+uTnwB9fX2VkJCgr7/+WvX19Xrsscc0efJkBQcHy9fXt91ffn59UmcFAAAAAAAAAAAAkyQnJ2vkyJGy2WwUMAFo1cGDB7VkyRKNHj1agYGBMgxDhmHo/fff16JFi2QYhhITE3vt+uvXr3dfc/369T02b25urnveVatW9di8AAam3NxcffPNN9q4caN27Niho0ePmh2pR/VJhZDL5Wr3NQAAAAAAAAAAAAAArTl48KCmTp2qkpISs6MAgGlcLpcqKyslSQ6HQ0ePHtXQoUMH1OJAfXInDz/8cF9cBgAAAAAAAAAAAAAwwPz6179WSUmJ/Pz89Jvf/EZnn322QkJCJEkJCQl6//33zQ0IAH2gpqZGdrvdo81ms6mhocGkRD2PIiYAAAAAAAAAAAAAgNf65JNPJEk//OEPtWzZshb9q1at6vWt2ObMmcOOQwBMVVFR4fE6MDBQAQEBFDH1la1bt2r16tV68sknzY4CAAAAAAAAAAAAAF6naPt2bV+xQsXbtqmxqkqW0FBFp6Vp0pIlipk0yex4PeLIkSOSpDFjxpicBADMc2IRk81mMylJ7/G6Iqb8/Hy9+uqreuWVV7Rr1y5JoogJAAAAAAAAAABgEHC5XKqtrVVFRYWqqqo0ZswYGYZhdizAK+Vv3qx1S5cq74svWvTlbdqk7X/6k4bNmqU5Tz6puOnTTUjYcxobGyVJ/v7+JicBAHO4XK5BUcTkY3YASaqrq1N6erouuOACjRw5Uv/7v/+rXbt2sRwfAAAAAAAAAADAINHU1KRNmzZpy5YtysrKUkFBgWpra82OBXilnA8/1Btnn91qAdPxjmzcqDfOPls5H37YR8l6zqpVq2QYhkch4y9+8Qt3m2EYWrRokSRp0aJFMgxDiYmJrc7VPP6RRx6RJG3evFnXXHONhg8froCAAA0bNkwLFy5UZmZmm3nWr1/vnmf9+vWtjtm7d6/uuOMOTZw4UaGhobJYLIqPj1daWppuvPFGvfHGG53a9unjjz/WvHnzFBsbq4CAAI0aNUq33XabDh8+3OG5AAam+vp6d0Fns4FYxGTqSkzr1q3T6tWr9e6776q6ulqS3IVLcXFxuvTSS3X55ZebGREAAAAAAAAAAAB9wN/fXz4+np+/Ly8vV3BwsEmJAO+Uv3mz1lxxhez19Z0ab6+v15orrtDVn37a71dk6gnPP/+87rrrLtntdndbXl6eXn31Vb377rv6xz/+obPPPrvL87711lv60Y9+1KLIID8/X/n5+dq+fbv++te/aseOHZo4cWKb8zzwwAN67LHHPNpyc3P15z//We+88442bNigcePGdTkfgP6tvLzc47W/v7+sVqs5YXpRnxcx7d69W6tXr1Z6erq7UrS5cGn48OG6/PLLdcUVV+iMM85geVAAAAAAAAAAAIBBJDw8XIWFhe7XFRUVGjZsmImJAO+zbunSThcwNbPX12v93Xfrms8/76VUPe+HP/yhpk2bJklKTU2VJN1222368Y9/7B4TERHRpTn/9a9/6euvv1Zqaqruuusupaamqq6uTu+9956eeuop1dbWauHChcrKypLFYun0vIWFhbrhhhvU2NiomJgY3X777Tr99NMVFRWluro6ZWdna8OGDXr//ffbneeFF17QF198odmzZ2vJkiUaM2aMysvLtXr1aq1evVrFxcW68cYbtWnTpi7dN4D+78St5MLDwwdkTU2fFDGVlpbq9ddf1+rVq/XNN99I+m/hUnh4uMrLy2UYhp544gldddVVfREJAAAAAAAAAAAAXsZms7UoYnK5XAPyTToMXC6nU3Wlpb0yd8mOHR1uIdeWIxs36uC6dYpqZxWg7rJGRso4YSW1kxUeHq7w8HCPtpiYmHZXMerIl19+qblz5+q9997zKFI666yzFBkZqZ///Oc6ePCgPvzwQ1166aWdnvfDDz9UTU2NJOnf//53i4xnnHGGrrvuOj377LPtzvPFF19o8eLFWrFihcfXve9973uyWCx68cUX9eWXX2rr1q2aPHlyp/MB6P9OLGIaiFvJSb1YxNTU1KQ1a9Zo9erV+uc//6mmpiZ34ZLFYtHcuXP1ox/9SBdddNGAXOIKAAAAAAAAAAAAXXPiG3KNjY2qr6/nvST0K3WlpXo+JsbsGK1689xze2XeHxcVKSg6ulfm7kmBgYH661//2uoqS3feead++ctfqrGxUZ999lmXipgKCgokHVsZqr0iq46+lsXFxemZZ55ptXDz3nvv1YsvvihJ+uyzzyhiAgaRhoYG1Z+wAh9FTJ305ZdfavXq1XrzzTdVVlYmSe4K+VmzZulHP/qRrrrqqi4v7QcAAAAAAAAAAICBzWq1yt/fX01NTe62iooKipgA9Ijvf//7immjwCw0NFQpKSnatWuX9u3b16V54+LiJEllZWX6f//v/+mSSy7pVr4rrrhCAQEBrfadcsopCgkJUXV1dZfzAejfTlyFydfXV8HBwSal6V09XsR0xhlnyDAM96pLp5xyin70ox9pwYIFSkxM7OnLAQAAAAAAAAAAYIAwDEM2m00lJSXutoqKCsXGxpqYCsBAMXbs2Hb7hwwZIkmqqqrq0rw/+MEPFB4ervLycl166aWaM2eO5s2bp7PPPltpaWny9fXtkXwRERGqrq7ucj4A/VtrW8kN1K12e207udDQUD399NO6/vrre+sSAAAAAAAAAAAAGGBaK2ICgJ4QFBTUbr+Pj48kyeFwdGneyMhIffDBB7rmmmt05MgRrVu3TuvWrZMkhYWF6Xvf+55uvPFGXXzxxabkA9C/tVbENFD1ShGTy+VSdXW1brzxRj311FP60Y9+pGuuuca9jB4AAAAAAAAAAADQmhPfmKurq1NjY6MsFotJiYCusUZG6sdFRb0y94Zly7Rr1apunz/xhht09u9+13OB/sMaGdnjc/Y3Z511lrKzs/XOO+/oo48+0qeffqrDhw+rsrJS7733nt577z1dcMEFevfddzssVgKAZi6XSwEBAaqvr3cXMFLE1AXr16/XqlWr9M4776iqqkrbtm3T9u3bdf/992vOnDlauHChLrvsMoWEhPT0pQEAAAAAAAAAANDPhYSEyNfX12OlkYqKCkVHR5uYCug8w8dHQb30vE69666TKmKactddvZYNUmBgoBYsWKAFCxZIkvbv368PP/xQzzzzjPbu3at//etfevDBB/Xkk0+anBRAf2EYhlJTU92LCVVUVCg0NNTsWL3Gp6cnPPvss/WXv/xFhYWFSk9P1wUXXCAfHx85HA793//9n2644QbFxsbqmmuu0UcffcRSdwAAAAAAAAAAAHAzDENhYWEebeXl5eaEAbxMTFqa4s84o1vnDps1SzGTJvVwIrRn1KhRuv3227V582YNHz5ckvTmm2+anApAf2QYhkJDQzV8+HD31pIDUa/dWWBgoK655hr94x//0KFDh/T444+7q8Nqa2v15ptvat68eWwxBwAAAAAAAAAAAA/h4eEerysqKswJAnihc/74R/kFBnbpHD+rVXNY/cc0YWFhmj59uiSppKTE5DQA4L36pDwrNjZW9957r7Zt26atW7dq6dKliomJkcvlUklJiQzDkCT99Kc/1V133aXPPvusL2IBAAAAAAAAAADAC9lsNo/XNTU1stvtJqUBvEvc9Oma9/bbnS5k8rNaNe+ttxT3nyIa9Lx//etfys/Pb7O/oqJCX3/9taRjqzMBAFrX52tMTZo0SX/4wx90+PBh/f3vf9dVV12lgIAAuVwu5eXl6dlnn9WcOXMUFxenH//4x/r3v//d1xEBAAAAAAAAAABgotDQUPeH4JuxGhPwX6MvukhXf/qphs2a1e64YbNm6eoNGzT6oov6KNng9PrrryshIUEXXXSRnnrqKf373//W1q1b9emnn+r555/XzJkzdeTIEUnSrbfeanJaAPBefmZd2NfXV3PnztXcuXNVWVmpN954Q6+88oo2btwol8ulwsJCrVixQitXrqSyHgAAAAAAAAAAYBDx8fFRWFiYqqqqFBYWJpvNJqvVanYswKvETZ+uaz7/XEXbt+u7lStVtG2bGquqZAkNVUxamk695RbFTJpkdsxBo6mpSR999JE++uijNsfceuutuvPOO/swFQD0L6YVMR0vLCxMixcv1uLFi5Wbm6uXX35Zr776qnJycsyOBgAAAAAAAAAAABOMGzdO/v7+8vHp841FgH4lZtIknffcc2bHGNSefPJJff/739f//d//6bvvvlN+fr6Ki4vl6+urESNGaObMmbr55pt15plnmh0VQD+SkZEhl8slm80mm82mkJCQFitVDjReUcR0vMTERD388MN6+OGHtXHjRr3yyitmRwIAAAAAAAAAAEAfCwgIMDsCAC/hcrna7V+1apVWrVrV7fObrV+/vs2+OXPmtDlPRESEFixYoAULFnTqOsdLTEzsdL7c3Nwuzw+gf3I6nSotLZXT6VRJSYkkacKECYqKijI5We/yuiKm482aNUuzOtjHFQAAAAAAAAAAAAAAABgoqqqq5HQ6PdpsNptJafoO628CAAAAAAAAAAAAAAAAXqKiosLjdXBwsPz9/U1K03coYgIAAAAAAAAAAAAAAAC8xIlFTINhFSaJIiYAAAAAAAAAAAD0Ay6XS3V1dS22VgEAABhIXC7XoC1i8jM7AAAAAAAAAAAAANAal8ul/Px8lZeXq6KiQo2NjZo8ebLCwsLMjgYAANArampq5HA4PNooYgIAAAAAAAAAAABMZBiGjhw5otraWndbRUUFRUwAAGDAOnEVpsDAQAUEBJiUpm+xnRwAAAAAAAAAAAC81okrD5z4xh4AAMBAMli3kpMoYgIAAAAAAAAAAIAXa62IyeVymZQGAACg97hcLpWXl3u0UcQEAAAAAAAAAAAAeIET37iz2+2qqakxKQ0AAEDvqaurU1NTk0cbRUwAAAAAAAAAAACAFwgMDFRgYKBHG1vKAQCAgejEn3EsFousVqtJafoeRUwAAAAAAAAAAADwaq1tKQcAQG9gy1KY6cSfcWw2mwzDMClN36OICQAAAAAAAAAAAF6ttSIm3mSGGXx9fSUd29bQ4XCYnAZAT3M4HO6/281/34G+1FoR02BCERMAAAAAAAAAAAC82olv4DU2Nqq+vt6kNBjMgoKC3Mfl5eXmBQHQK47/e33833egLzQ0NLT4+WawFTH5mR0AAAAAAAAAAAAAaI/VapW/v7+amprcbRUVFbJarSamwmAUHh6usrIySVJRUZEcDofCwsIUEBAwqLb7AQYSl8ulhoYGVVZWqrS01N0eERFhYioMRv7+/kpLS1NFRYUqKipUW1ur4OBgs2P1KYqYelFtba2effZZvfXWW8rJyVFDQ4NGjBihiy66SHfeeacSEhJOan6n06nPP/9c//znP/XFF19o9+7dOnr0qAIDAzVy5EidffbZuvXWW3Xqqae2O88jjzyiX/ziF5265rp16zRnzpyTyg0AAAAAAAAAANAVhmHIZrOppKTE3VZRUaHY2FgTU2EwCgwMlM1mc2/3U1paqtLSUhmGwdZTA5DL5VJjY6MkqaqqikK1AcrhcLTYotRmsykgIMCkRBisfHx8ZLPZ3KsvuVyuQfd1hyKmXpKdna25c+cqKyvLo33Pnj3as2ePXnzxRaWnp+viiy/u9jUSExN16NChFu1NTU3atWuXdu3apRUrVujee+/VY489NugebgAAAAAAAAAAMHC0VsQEmCEuLk4Wi0XFxcXuNpfLJbvdbmIq9Aan06nq6mpJUmhoqHx8fExOhL4QHR2tyMhIs2MAg7LGgyKmXlBVVaWLLrrIXcC0ePFizZ8/X1arVevWrdOjjz6qyspKXX311dq4caPS0tK6dZ28vDxJUnJysi6//HLNmjVL8fHxqqur07p16/Tkk0+qrKxMjz/+uHx9ffXb3/62wzl37NjRbv+oUaO6lRUAAAAAAAAAAOBkNK9K0Kyurk4NDQ2slIE+ZxiGoqKiFBYWpurqatXU1KixsVFOp9PsaOhhdrvdXTBps9nk58fb6wORj4+PLBaLgoODFRISIovFYnYkYNDiq2wvWL58ufbu3StJevzxx3Xfffe5+2bOnKk5c+Zo9uzZqq2t1dKlS7V+/fpuXWfGjBl6+OGHdf7557eowDvzzDN17bXXaubMmSouLtby5ct18803Kykpqd05J06c2K0sAAAAAAAAAAAAvSkkJES+vr5yOBzutoqKCsXExJiYCoOZxWLRkCFDNGTIELOjoJdUVlbqgw8+kHTsfd6wsDCTEwHAwMZ6dz2sqalJTz/9tCRp3Lhxuueee1qMOeOMM3TTTTdJkjZs2KDNmzd361pffPGFLrjggjaXEBs9erQeeughSceqhN9///1uXQcAAAAAAAAAAMBshmF4rMZkGIYaGhpMTAQAAICeRBFTD1u3bp17ScHrr7++zX1RFy1a5D5+7733ei3POeec4z7OycnptesAAAAAAAAAAAD0tqFDhyoxMVGTJk3SrFmzNGLECLMjAQAAnBSXy6W9e/eqtLRULpfL7DimYju5Hvb555+7j2fPnt3muGnTpikoKEi1tbXauHFjr+U5/hMIvr6+vXYdAAAAAAAAAACA3sbWcQAAYKApLy9Xfn6+8vPzFRgYqPj4eA0bNqzNRXMGssF3x70sIyPDfTx27Ng2x/n5+Sk5OVmSlJmZ2Wt5NmzY4D4eN25ch+PPP/98xcTEyGKxKCYmRnPmzNFjjz2msrKyXssIAAAAAAAAAAAAAAAwGOXl5bmP6+vrVVBQIMMwTExkHlZi6mGHDx+WJAUHBys8PLzdsSNGjNB3332n4uJiNTQ0KCAgoEez1NbW6o9//KMkKSAgQJdcckmH53z88cfu4+LiYm3YsEEbNmzQ7373O61atapTc7Sm+felLfn5+e7jmpoaVVZWdus6QE+orq5u9RgwC88kvAnPI7wJzyO8Dc8kvAnPI7wNzyS8SU1NjdkRAAAAAEDSsd21SkpKPNri4+MpYkLPqKqqkiSFhIR0ODY4ONh9XF1d3eNFTPfff78OHjwoSfrJT36i+Pj4Nsempqbqhz/8oWbMmKH4+Hg1NTVpz549Sk9P19q1a1VeXq7LL79ca9as0f/8z/90OUtX9qR+9913ZbPZunwNoDe88sorZkcAPPBMwpvwPMKb8DzC2/BMwpvwPMLb8EzCbBUVFWZHAAAAAABJngu+SJKPj4+GDh1qUhrzUcTUw+rr6yVJFoulw7HHFy3V1dX1aI709HQ9++yzko5tI/frX/+6zbFLly7VI4880qL9tNNO03XXXacVK1bo1ltvlcPh0M0336ycnBwFBgb2aF4AAAAAAAAAAIDuqq6uVlBQkHx8fMyOAgAA0ClOp7NFEdPQoUPl5zd4S3kG7Z33xNJbf/3rX7Vo0SKPtubinsbGxg7Pb2hocB9brdaTztNs/fr1uummmyRJQ4YM0TvvvNPu/B1te7dkyRJt3rxZL730kvLy8vTOO+9owYIFXcp06NChdvvz8/M1Y8YMSdJll12mMWPGdGl+oCdVV1e7PxW6cOHCTq2sBvQmnkl4E55HeBOeR3gbnkl4E55HeBueSXiTvXv36tFHHzU7BoAe4HQ6VVxcrLy8PFVWVmrs2LGDeuUCAADQv5SWlraoLWlvh63BYNAWMfWW0NBQScf+Y6Yjx++93lP/cbNlyxb94Ac/UENDg0JCQvTRRx9p3LhxJz3vkiVL9NJLL0mSNmzY0OUipuHDh3d6bHBwsMLCwro0P9BbQkJCeB7hVXgm4U14HuFNeB7hbXgm4U14HuFteCZhtuDgYLMjAOghmZmZKikpcb/Oy8ujiAkAAPQbeXl5Hq/DwsIG/Yd+Bm0RU2Zm5knPERcX16Jt+PDh+uqrr1RTU6Py8vJ2VzlqXp0oOjraY2u57tq1a5cuvPBCVVVVKSAgQO+//75OO+20k55XksaPH+8+PnLkSI/MCQAAAAAAAAAA0F0xMTEeRUyVlZWqqqpyf+AcAADAWzXXlBxvsK/CJA3iIqaxY8f2yrzjx4/XO++8I0navXu3Tj/99FbH2e125eTkSFKPrJSUk5Oj73//+yotLZWfn5/eeOMNfe973zvpeZv1xPZ7AAAAAAAAAAAAPSUqKkoWi8VjG5b8/HyKmAAAgNfLz8/3eO3v76/o6GiT0ngPH7MDDDRnnnmm+3jDhg1tjtuyZYt7O7lZs2ad1DUPHz6s8847T/n5+fLx8dHLL7+sSy655KTmPFFGRob7mOo/AAAAAAAAAABgNsMwWuyaUVhYKLvdblIiAACAjjkcDhUUFHi0xcbGyseHEh5+B3rYnDlzZLPZJEkvv/yyXC5Xq+NWrVrlPr700ku7fb2ioiKdd955ys3NlST9+c9/1rXXXtvt+dqyYsUK9/Hs2bN7fH4AAAAAAAAAAICuiouL89hNwul0tnhTEAAAwJsUFhbK4XB4tLGYzDEUMfUwi8WiO++8U5KUmZmpJ554osWYTZs26aWXXpJ0rCBo+vTprc5lGIYMw1BiYmKr/eXl5brgggu0Z88eSdKTTz6pxYsXdynvjh07lJ2d3e6YlStX6sUXX5R0rPrvZIquAAAAAAAAAAAAekpAQICioqI82vLy8tr8kDkAAICZXC6X8vLyPNqGDBmiwMBAkxJ5Fz+zAwxE9913n9544w3t3btXy5YtU3Z2tubPny+r1ap169bpt7/9rex2u6xWq/74xz926xoNDQ266KKLtG3bNknSggULdN5552nnzp1tnhMcHKxRo0Z5tH3zzTe6+eabdc455+h//ud/lJqaqsjISNntdu3evVvp6elau3atJMnX11crV65UcHBwtzIDAAAAAAAAAAD0tPj4eBUXF7tf19XVqby8XBERESamAgAAaKmyslI1NTUebazC9F8UMfWC0NBQffjhh5o7d66ysrK0cuVKrVy50mNMWFiY0tPTlZaW1q1r5Ofn64svvnC/Tk9PV3p6ervnzJ49W+vXr2/R7nA49Mknn+iTTz5p89zIyEi99NJLmjdvXrfyAgAAAAAAAAAA9AabzaagoCDV1ta62/Ly8ihiAgAAXqexsVEWi0WNjY2SpMDAQA0ZMsTkVN6DIqZekpycrK1bt+q5557TW2+9pezsbDU2NmrEiBGaO3eu7rrrLiUkJJgdU3PnztVLL72kTZs2aevWrSosLFRpaalcLpeGDBmiSZMm6cILL9SiRYsUFhZmdlwAAAAAAAAAAAAPhmEoPj5e2dnZ7raSkhI1NDQoICDAxGQAAACeoqOjFRkZqdLSUuXl5WnIkCEyDMPsWF6DIqZeFBwcrGXLlmnZsmXdOr+9/ZoTExN7ZD/nmJgY3XjjjbrxxhtPei4AAAAAAAAAAAAzDB06VPv27ZPT6XS35efnKzEx0bxQAAAArfDx8VF0dLSio6N7pO5jIPExOwAAAAAAAAAAAABwMvz8/DR06FCPtvz8fI+iJgAAAG/DKkyeKGICAAAAAAAAAABAvxcfH+/xurGxUaWlpSalAQAAQFdRxAQAAAAAAAAAAIB+LyQkRGFhYR5t+fn5JqUBAABAV/mZHQAAAAAAAAAAAADoCfHx8aqsrJTValV8fLxiY2PNjgQAAAa5xsZGOZ1OBQYGmh3F61HEBAAAAAAAAAAAgAEhOjpaFotF4eHhMgzD7DgAAAA6dOiQDh8+rCFDhig+Pl5Dhgzh55Q2sJ0cAAAAAAAAAAAABgQfHx9FRETwxiAAAPAKDodDBQUFkqSjR49q586dOnDggMmpvBdFTAAAAAAAAAAAAAAAAEAPKy4ult1u92iLiYkxKY33o4gJAAAAAAAAAAAAAAAA6GF5eXkeryMiIhQUFGRSGu9HERMAAAAAAAAAAAAAAADQg6qqqlRVVeXRFh8fb1Ka/sHP7AAAAAAAAAAAAABAb6murnavgjBmzBiT0wAAgMHixFWYAgICFBkZaVKa/oEiJgAAAAAAAAAAAAw4NTU12rt3ryorKyVJhmEoMTFRFovF5GQAAGCga2pqUlFRkUdbXFycDMMwKVH/wHZyAAAAAAAAAAAAGHAsFovHFi4ul0sFBQUmJgIAAINFYWGhnE6n+7VhGIqLizMxUf9AERMAAAAAAAAAAAAGHH9/f8XExHi05eXlyeVymZQIAAAMBi6Xq8VWclFRUawG2QkUMQEAAAAAAAAAAGBAio+P93jd0NCg0tJSk9IAAIDBoKysTHV1dR5tJ/5MgtZRxAQAAAAAAAAAAIABKTQ0VCEhIR5tJ66MAAAA0JNO/FkjKChINpvNpDT9C0VMAAAAAAAAAAAAGJAMw2ix8kFrqyMAAAD0hPr6+harPsbHx8swDJMS9S8UMQEAAAAAAAAAAGDAiomJkZ+fn0cbqzEBAIDekJ+f7/Ha19dXQ4cONSlN/0MREwAAAAAAAAAAAAas1t48LCgokMPhMCkRAAAYiFwulwoKCjzahg4d2qKYGm2jiAkAAAAAAAAAAAAD2olbytntdhUXF5uUBgAADESGYWjKlClKSEiQxWKR1PJnELSPci8AAAAAAAAAAAAMaEFBQYqIiFBZWZm7LS8vT7GxsSamAgAAA01AQIASExM1cuRIVVRUKDg42OxI/QorMQEAAAAAAAAAAGDAO3ElhKqqKlVVVZmUBgAADGQ+Pj6KiIgwO0a/QxETAAAAAAAAAAAABrzIyEgFBAR4tOXl5ZmUBgAAACeiiAkAAAAAAAAAAAADnmEYiouL82grKipSU1OTSYkAAABwPIqYAAAAAAAAAAAAMCjExcXJMAxJx7Z5iYmJkdPpNDkVAAAAJMnP7AAAAAAAAAAAAABAX7BYLBo+fLgsFotiY2Pl58dbZQAAoPtcLpe+++47hYaGKj4+XoGBgWZH6tf4yQwAAAAAAAAAAACDRlJSktkRAADAAFFRUaHy8nKVl5fr0KFDioyM1CmnnCJ/f3+zo/VLbCcHAAAAAAAAAAAAAAAAdIHL5dLBgwc92mpra1np8SRQxAQAAAAAAAAAAAAAAAB0QUlJicrKyjza4uLiZBiGSYn6P4qYAAAAAAAAAAAAAB1bUQEAAKAjdrtd2dnZHm0Wi0VxcXEmJRoYKGICAAAAAAAAAADAoFZfX6+dO3e2eDMSAACgNbm5uWpsbPRoGz16NFvJnSR+9wAAAAAAAAAAADAoOZ1OHTlyRLm5uXI6nZKkoUOHKiwszORkAADAW1VXV+vIkSMebREREYqOjjYp0cDBSkwAAAAAAAAAAACtqK2t1eOPP67p06dryJAhCg4O1tixY3XPPffowIEDJz1/bm6uDMPo1K9Fixad/A2hhcbGRo8CJknKyspiWzkAANAql8ulrKwsjzbDMJSSkiLDMExKNXCwEhMAAAAAAAAAAMAJsrOzNXfu3BZvUu3Zs0d79uzRiy++qPT0dF188cUmJURPCAwMVEJCgvbv3+9uq66uVl5enoYNG2ZiMgAA4I0KCgpUWVnp0TZy5EhZrVaTEg0sFDEBAAAAAAAAAAAcp6qqShdddJG7gGnx4sWaP3++rFar1q1bp0cffVSVlZW6+uqrtXHjRqWlpZ30NX/961/rkksuabM/IiLipK+B1g0fPlyFhYWqra11t+3fv19RUVEKCAgwMRkAAPAmjY2N2rdvn0eb1WrVyJEjTUo08FDEBAAAAAAAAAAAcJzly5dr7969kqTHH39c9913n7tv5syZmjNnjmbPnq3a2lotXbpU69evP+lrDhs2TBMnTjzpedB1Pj4+SklJ0fbt291tDodD+/bt07hx40xMBgAAvMn+/ftlt9s92pKTk+Xj42NSooGH30kAAAAAAAAAAID/aGpq0tNPPy1JGjdunO65554WY8444wzddNNNkqQNGzZo8+bNfZoRPS88PFxDhw71aCsqKlJZWZlJiQAAgDepqKhQQUGBR1t0dLSGDBliUqKBiSImAAAAAAAAAACA/1i3bp0qKiokSddff32bn6xftGiR+/i9997ri2joZUlJSfLz89zEJCsrS06n06REAADAGzidTvc2w818fX01evRokxINXBQxAQAAAAAAAAAA/Mfnn3/uPp49e3ab46ZNm6agoCBJ0saNG3s9F3qfxWLRqFGjPNrq6up06NAhkxIBAABvERMT41HcnpiYqICAABMTDUwUMQEAAAAAAAAAAPxHRkaG+3js2LFtjvPz81NycrIkKTMz86Sv+8wzzyg5OVmBgYGy2WyaMGGCbr31Vn377bcnPTc6Ly4uTqGhoR5tBw4cUF1dnUmJAACA2Xx8fDRy5EhNnz5dkZGRCgkJ0bBhw8yONSD5dTwEAAAAAAAAAABgcDh8+LAkKTg4WOHh4e2OHTFihL777jsVFxeroaHhpD6Nf3yxUkNDgzIyMpSRkaEVK1ZoyZIleuqpp7o1f/P9tCU/P999XFVVpcrKyi5fozuqq6tbPfYG8fHx2rNnj/u1y+VSZmamRo8eLcMwTEyGjnjzc4X+iWcKPY1nqv8bOXKkHA6HqqqqzI7iZtZz1Ru/BxQxAQAAAAAAAAAA/EfzmzEhISEdjg0ODnYfV1dXd6vIKDw8XJdeeqnmzJmjlJQUBQYGKj8/X2vXrtVLL72k6upqrVixQlVVVUpPT+/y/CNGjOj02FdeeUU2m63L1zhZr7zySp9fsyMJCQmKi4tzv66qqtKbb76po0ePmpgKXeGNzxX6N54p9DSeKfSGvnyuKioqenxOipgAAAAAAAAAAAD+o76+XpJksVg6HHt80VJ3thuLj4/XkSNHFBQU5NE+efJkzZ07Vz/5yU903nnn6eDBg3rttdd09dVX6wc/+EGXr4OuO3z4sCIjIz2eg4SEBJWXl8vpdJqYDAAAYOCiiAkAAAAAAAAAAPQ7PbGt11//+lctWrTIoy0wMFCS1NjY2OH5DQ0N7mOr1drl61sslnaLpVJSUvTqq6/q7LPPliQ988wzXS5iOnToULv9+fn5mjFjhiRp4cKFGjZsWJfm767q6mr3SgELFy7s1MpXfa2srEy5ubmSjj1vCQkJmjFjhnx8fMwNhjb1h+cK/QvPFHoaz1T/0dTUJH9/f7NjdIpZz9WRI0f06KOP9uicFDEBAAAAAAAAAAD8R2hoqKRjbwZ1pKamxn3cW28WnXXWWRo/frwyMjL0+eefy+l0dqmIZvjw4Z0eGxoaqrCwsO7EPCkhISGmXLcjoaGh7m1SkpOTW6yYBe/mrc8V+i+eKfQ0ninvVVNTo+3btysuLk6JiYny8+s/pTV9+VxVVlb2+Jz953caAAAAAAAAAADgPzIzM096jri4uBZtw4cP11dffaWamhqVl5crPDy8zfObVzmKjo722FqupzUXMdXX16u0tFTR0dG9di38l2EYGj9+vHx9fXtk5S8AAOD9XC6XsrKy5HQ6deTIERUXFys5OZmfv/oIRUwAAAAAAAAAAKDfGTt2bK/MO378eL3zzjuSpN27d+v0009vdZzdbldOTo4kady4cb2SpRkFNObpTysvAACAk1dUVOReiVE6tsVwVVUVRUx9hE17AQAAAAAAAAAA/uPMM890H2/YsKHNcVu2bHFvJzdr1qxezZSRkSFJCggIUGRkZK9eCwAAYLBqampyF6k3CwgIUEJCgkmJBh+KmAAAAAAAAAAAAP5jzpw5stlskqSXX35ZLper1XGrVq1yH1966aW9lmfjxo3atWuXpGMFVj4+vLXjLRobG82OAAAAelBubq6ampo82pKTk+Xr62tSosGHn3QBAAAAAAAAAAD+w2Kx6M4775QkZWZm6oknnmgxZtOmTXrppZckSbNnz9b06dNbncswDBmGocTExFb733///TaLpCQpOztb1157rfv1j3/8487eBnqRw+HQvn379OWXX3psNwMAAPqvyspK5eXlebRFRkYqKirKpESDExv5AgAAAAAAAAAAHOe+++7TG2+8ob1792rZsmXKzs7W/PnzZbVatW7dOv32t7+V3W6X1WrVH//4x25f59JLL1VycrIuu+wyzZgxQ8OHD1dAQIDy8/P1r3/9Sy+99JKqq6slSVdddZUuu+yyHrpDdNfRo0eVlZWl+vp6SVJWVpamTJnCClkAAPRjLpdLWVlZHm0+Pj5KTk42KdHgRRETAAAAAAAAAADAcUJDQ/Xhhx9q7ty5ysrK0sqVK7Vy5UqPMWFhYUpPT1daWtpJXSs7O1uPP/54u2Nuu+02Pfnkkyd1HfSM2tpadwGTJNXU1OjIkSMaMWKEiakAAMDJyMvLcxeON0tISFBgYKBJiQYvipgAAAAAAAAAAABOkJycrK1bt+q5557TW2+9pezsbDU2NmrEiBGaO3eu7rrrLiUkJJzUNT744ANt2rRJX331lQ4cOKCSkhLV1NQoLCxMSUlJOuuss3TjjTdq4sSJPXRXOFnDhg1TYWGhxxudubm5io6O5o1OAAD6oYaGBu3fv9+jLSgoSMOHDzcp0eBGERMAAAAAAAAAAEArgoODtWzZMi1btqxb57tcrnb7582bp3nz5nVrbpjDMAylpKRo69at7jan06mcnBxNmDDBxGQAAKA79u3bJ4fD4dGWkpLCVrEm4XcdAAAAAAAAAAAA6KSwsDDFxcV5tJWUlKi0tNSkRAAAoDvKyspUVFTk0TZ06FCFh4ebEwgUMQEAAAAAAAAAAABdMWrUKPn7+3u0ZWdnt1jJAQAAeCen06msrCyPNj8/PyUlJZmUCBJFTAAAAAAAAAAAAECX+Pv7t3iTs76+XgcPHjQpEQAA6IrDhw+rrq7Oo23UqFGyWCwmJYJEERMAAAAAAAAAAADQZUOHDpXNZvNoO3TokGpqakxKBAAAOis2NlZDhw51vw4NDW2xXSz6HkVMAAAAAAAAAAAAQBcZhqGUlBQZhuFuc7lcys7OlsvlMjEZAADoiMVi0dixYzVp0iQFBwe3+J4Oc1DEBAAAAAAAAAAAAHRDcHCwhg8f7tFWXl6uoqIikxIBAICuCA8P19SpUxUaGmp2FIgiJgAAAAAAAAAAAKDbEhISFBAQ4NGWk5Mju91uUiIAANAVrMDkPShiAgAAAAAAAAAAALrJ19dXycnJHm1NTU3Kzc01JxAAAEA/RRETAAAAAAAAAAAAcBKioqIUGRnpfh0dHa0RI0aYmAgAAByvrq5OjY2NZsdAB/zMDgAAAAAAAAAAAAD0d8nJyaqvr1dSUpKGDBlidhwAAPAfLpdLu3fvVm1trUaNGqW4uDi2kPNSFDEBAAAAAAAAAAAAJykwMFBTp07lTVEAALxMQUGBKisrJUlZWVkqKCjQ+PHjFRgYaHIynIjt5AAAAAAAAAAAAIAeQAETAADepampSfv27WvRZrFYTEqE9lDEBAAAAAAAAAAAAAAAgAFn3759stvtHm0pKSny8aFcxhvxpwIAAAAAAAAAAAD0ooqKChUUFJgdAwCAQaWgoKDF99/o6GgNGTLEpEToiJ/ZAQAAAAAAAAAAAICBqrCwUHv27JHL5ZLFYuGNUwAA+kB5ebn27t3r0ebr66vRo0eblAidwUpMAAAAAAAAAAAAQC/Izc3V7t275XK5JEkZGRmqqakxORUAAANbbW2tdu3a5f7+22z06NEKCAgwKRU6gyImAAAAAAAAAAAAoBec+Oapw+HQjh071NjYaFIiAAAGtqamJu3YsUN2u92jffjw4YqLizMpFTqLIiYAAAAAAAAAAACgFyQmJio6OtqjraGhQTt37pTD4TApFQAAA5PT6dTOnTtVX1/v0R4ZGamkpCSTUqErKGICAAAAAAAAAAAAeoFhGDrllFMUGhrq0V5VVeWxzRwAADg5LpdLe/bsUWVlpUd7SEiIxo0bJ8MwTEqGrqCICQAAAAAAAAAAAOglvr6+mjhxogIDAz3aS0pKtH//fpNSAQAwsBw4cEBFRUUebQEBAZo4caJ8fX1NSoWuoogJAAAAAAAAAAAA6EUWi6XVN1EPHTqk/Px8k1IBADAw1NXV6eDBgx5tzUXEAQEBJqVCd1DE1Itqa2v1+OOPa/r06RoyZIiCg4M1duxY3XPPPTpw4MBJz5+bmyvDMDr1a9GiRZ2a8/XXX9f555+v2NhYBQYGKiEhQT/60Y+0adOmk84LAAAAAAAAAAAwWAUHB2vChAkttrPJyspSWVmZSakAAOj/rFarUlNT5efn524bN26cQkJCTEyF7qCIqZdkZ2crLS1N999/v7Zs2aKysjLV1tZqz549+sMf/qBTTz1Vf//7382O6VZXV6eLLrpI1157rT7++GMVFhaqoaFBBw8eVHp6us4880z94he/MDsmAAAAAAAAAABAvxUREaGUlBSPNpfLpV27dqmmpsakVAAA9H8RERGaPHmyAgMDlZycrMjISLMjoRv8Oh6CrqqqqtJFF12krKwsSdLixYs1f/58Wa1WrVu3To8++qgqKyt19dVXa+PGjUpLSzvpa/7617/WJZdc0mZ/REREu+ffeOON+uijjyRJ55xzju666y7Fx8drx44d+u1vf6ucnBw98sgjiouL0y233HLSeQEAAAAAAAAAAAajuLg41dbW6vDhw+42h8OhnTt3avLkybJYLCamAwCg/woKCtK0adNabN+K/oMipl6wfPly7d27V5L0+OOP67777nP3zZw5U3PmzNHs2bNVW1urpUuXav369Sd9zWHDhmnixIndOvf//u//9Le//U2SNG/ePL333nvuv9TTp0/XD37wA02dOlUHDx7U/fffryuvvLLDoigAAAAAAAAAAAC0LikpSfX19SopKXG31dfXa9euXZo0aZJ8fNhMBQCA7qCAqX/jJ6Ae1tTUpKefflrSsT0W77nnnhZjzjjjDN10002SpA0bNmjz5s19mvFETzzxhCTJz89Pzz//fIu/1FFRUfrd734nSSovL9eLL77Y5xkBAAAAAAAAAAAGCsMwNHbsWIWGhnq022w2GYZhUioAALyfy+VSdXW12THQSyhi6mHr1q1TRUWFJOn6669vs1J+0aJF7uP33nuvL6K1qqqqSv/+978lSeedd56GDx/e6rjLLrtMYWFhkszNCwAAAAAAAAAAMBD4+vpqwoQJCggIkGEYGjNmjJKSkihiAgCgHYcOHdI333yjI0eOmB0FvYAiph72+eefu49nz57d5rhp06YpKChIkrRx48Zez9WWzZs3q7GxUVL7eS0Wi04//XT3OU1NTX2SDwAAAAAAAAAAYKAKCAjQxIkTlZqaqri4OLPjAADg1YqKirR//35JUnZ2trKzs+VyuUxOhZ5EEVMPy8jIcB+PHTu2zXF+fn5KTk6WJGVmZp70dZ955hklJycrMDBQNptNEyZM0K233qpvv/22R/Ie32+325WVlXXSmQEAAAAAAAAAAAa7kJAQRUREmB0DAACvVllZqd27d3u0HTlyRJWVlSYlQm/wMzvAQHP48GFJUnBwsMLDw9sdO2LECH333XcqLi5WQ0ODAgICun3d44uVGhoalJGRoYyMDK1YsUJLlizRU0891er8zXkltbmV3PF5mx06dEjjx4/vdL7jr9Oa/Px893FNTQ1faGCq4/dQZT9VeAOeSXgTnkd4E55HeBueSXgTnkd4G55JeJOamhqzIwAAAADogrq6Ou3cubPFqktJSUmy2WwmpUJvoIiph1VVVUk6VjXfkeDgYPdxdXV1t4qYwsPDdemll2rOnDlKSUlRYGCg8vPztXbtWr300kuqrq7WihUrVFVVpfT09DbzdibziXm74vgCqI68++67fKGB13jllVfMjgB44JmEN+F5hDfheYS34ZmEN+F5hLfhmYTZKioqzI4AAJ1WXV2tnJwcjR8/Xv7+/mbHAQCgz9ntdu3cuVNNTU0e7XFxcR0u1IL+hyKmHlZfXy9JslgsHY49vmiprq6uy9eKj4/XkSNHFBQU5NE+efJkzZ07Vz/5yU903nnn6eDBg3rttdd09dVX6wc/+EGreTuT+WTzAgAAAAAAAAAAoHOOHj2qjIwMORwO7dq1S6eeeqp8fHzMjgUAQJ9xOp3KyMhQbW2tR3tERIRSUlJkGIZJydBbBm0RU088zH/961+1aNEij7bAwEBJUmNjY4fnNzQ0uI+tVmuXr2+xWNotPEpJSdGrr76qs88+W5L0zDPPtChias4rdZz5ZPIeOnSo3f78/HzNmDFDknTZZZdpzJgxXZof6EnV1dXuT4UuXLiwUyurAb2JZxLehOcR3oTnEd6GZxLehOcR3oZnEt5k7969evTRR82OAQDtKioqUmZmpvt1RUWF9u7dq1NOOYU3bAEAg4LL5VJ2drbKyso82oOCgjR+/Hi+Hw5Qg7aIqbeEhoZK6tx2a8fvvd5b/3Fz1llnafz48crIyNDnn38up9PpUaXfnFfqOPPJ5O3KMm7BwcEKCwvr0vzSsS9iNTU1qqysVH19vRwOR5fnAKRjSxKmpaVJOvYPw+OffQwsPj4+slgsCg4OVkhISKdW0TNbSEhIt75GAr2B5xHehOcR3oZnEt6E5xHehmcSZgsODjY7AgB0yGazyWKxeHwAvbCwUFarVQkJCSYmAwCgbxw+fFj5+fkebf7+/kpNTZWfH6UuA9Wg/ZM9vnq9u+Li4lq0DR8+XF999ZVqampUXl6u8PDwNs9vXp0oOjraY6u2ntZcxFRfX6/S0lJFR0d75G12+PBhTZs2rcO8kjRixIjeCdtNTqdTBw8eZJs79Ain0ymbzeY+ttvtJidCb2psbFR1dbUKCwsVHR2tyMhIKrcBAAAAAAAAmCogIEATJ07Utm3b5HQ63e25ubmyWq2KiYkxMR0AAL2rpKRE+/bt82jz8fHRxIkTPXabwsAzaIuYxo4d2yvzjh8/Xu+8844kaffu3Tr99NNbHWe325WTkyNJGjduXK9kadbem/Hjx493H+/evbvdeZr7/fz8lJKS0jPheoDL5WpRwGQYhnx9fU1Mhf7M5XK5Vxvz9/enoGUAczgccrlc7tfFxcVqbGxUfHy8iakAAAAAAAAA4NhuGuPGjdOuXbs82nfv3q2AgAD3h3EBABhIqqqqWl2UZuzYsazqOwgM2iKm3nLmmWe6jzds2NBmEdOWLVvcW1TNmjWrVzNlZGRIOla1HxkZ6dE3ffp093KkGzZs0P/+7/+2OkdjY6O+/PJL9zn+/v69mrkrampq3AVMvr6+io2NVUhIiMe2eUBXOBwOFRUVSZJiYmIoiBvAXC6XGhoaVFlZqdLSUknHthCMjIzs1RXyAAAAAAAAAKAzoqKiNHr0aPcH46Vj/6+5a9cuTZ48WVar1cR0AAD0rPr6eu3cudNjFUJJGjVqlMeOUxi4qPLoYXPmzHFXvr/88sseK3wcb9WqVe7jSy+9tNfybNy40V2hf+aZZ7Yo7AkNDdX3vvc9SdInn3yiw4cPtzrPu+++q8rKyl7P2x3NuSQpNjZWYWFhFDAB6BTDMBQYGKiYmBiP5ZfLyspMTAUAAAAAAAAA/zVs2LAWq8c3NTVp586dstvtJqUCAKDnlZeXq7Gx0aMtNjZWI0aMMCkR+hqVHj3MYrHozjvvlCRlZmbqiSeeaDFm06ZNeumllyRJs2fP1vTp01udyzAMGYahxMTEVvvff//9NoukJCk7O1vXXnut+/WPf/zjVsfde++9ko5tcfeTn/xEDofDo7+kpET333+/JCk8PFw333xzm9c0Q319vaRjv1/NW4ABQFeFh4e7j2tra80LAgAAAAAAAADHMQxDycnJioiI8Givra3Vrl27WqxWAQBAfxUbG6vx48e7Fy0JDw9XSkqKDMMwORn6CtvJ9YL77rtPb7zxhvbu3atly5YpOztb8+fPl9Vq1bp16/Tb3/5WdrtdVqtVf/zjH7t9nUsvvVTJycm67LLLNGPGDA0fPlwBAQHKz8/Xv/71L7300kuqrq6WJF111VW67LLLWp3n3HPP1fz58/W3v/1NH3zwgb7//e9r6dKlio+P144dO/Sb3/xGBw8elCT97ne/a/FDstmai658fX1ZgQlAt/n6+srX11cOh6NFMScAAAAAAAAAmMkwDI0fP17btm1TTU2Nu728vFxZWVkaM2YMb/ACAAaE6OhoBQQEaN++fR4FTRgcKGLqBaGhofrwww81d+5cZWVlaeXKlVq5cqXHmLCwMKWnpystLe2krpWdna3HH3+83TG33XabnnzyyXbH/OUvf1FlZaU++ugjrVu3TuvWrfPo9/Hx0f/3//1/uuWWW04qLwB4M/6RDwAAAAAAAMBb+fn5aeLEifr222/V1NTkbi8oKJDVatXIkSNNTAcAQM8JCwvTpEmTeO9uEKKIqZckJydr69ateu655/TWW28pOztbjY2NGjFihObOnau77rpLCQkJJ3WNDz74QJs2bdJXX32lAwcOqKSkRDU1NQoLC1NSUpLOOuss3XjjjZo4cWKHc1mtVn344Yd67bXXtGrVKm3fvl3l5eUaOnSozjrrLN1+++2aOXPmSeUFAAAAAAAAAABA9wUGBmrixInavn27xzZy+/fvV2hoqNftpgEAQHdRwDQ4UcTUi4KDg7Vs2TItW7asW+e7XK52++fNm6d58+Z1a+62XHvttbr22mt7dE4AAAAAAAAAAAD0jLCwMI0dO1YZGRnuttjYWNlsNhNTAQDQNdXV1XI4HHz/ggc2DwQAAAAAAAAAAAD6kejoaCUlJUmSRo0apTFjxsjHh7f9AAD9Q0NDg3bs2KHt27erqKjI7DjwIqzEBAAAAAAAAAAAAPQzw4cPl81mU1hYmNlRAADoNIfDoZ07d6qxsVGSlJmZqbq6Oo0cOZIt5MBKTABwMlatWiXDMGQYhnJzc82OY7r169e7fz/Wr19vdhwAAAAAAAAAGLAMw6CACQDQr7hcLmVmZqq6utqjvaysTC6Xy6RU8CYUMQEAAAAAAAAAAAADjMPh4A1hAIBXycnJUWlpqUeb1WrVhAkT2BYVkihiAgAAAAAAAAAAAAaU+vp6ffvttzpy5IjZUQAAkCTl5eW1+L7k5+eniRMnyt/f36RU8DZ+ZgcAAAwcc+bM4ZM9AAAAAAAAAGCiyspK7dy5U01NTcrJyZGfn59iY2PNjgUAGMQKCwuVlZXl0WYYhiZMmKCgoCCTUsEbUcQEAAAAAAAAAAAADAANDQ3avn27nE6nu23Pnj2qq6tTYmKiDMMwMR0AYLBxuVw6cOCADhw40KJvzJgxCg8P7/tQ8GpsJwcAAAAAAAAAAAAMAAEBARo5cmSL9oMHDyozM1MOh8OEVACAwcjpdGr37t2tFjCNHDmSVQLRKoqYAHTbunXrdP311yspKUlBQUEKCwtTamqq7rvvPuXl5bV53iOPPCLDMNyf+Kivr9fy5cs1ZcoUhYaGKjQ0VDNmzNCzzz4ru93e4vzVq1e7z//44487zLlkyRIZhqGAgACVlZV1eC+hoaEaM2aMzj33XC1btqzde+ms4uJi/fznP9fkyZMVHh6uwMBAJSYmauHChfr888/bPbf50zGLFi2SJG3evFnXXHONRowYocDAQI0YMUI33HCDdu/e3aks2dnZuvvuu5WamiqbzSar1aqkpCQtWrRIW7ZsOan7XL9+vfvPZv369Sc1FwAAAAAAAACg60aOHKkRI0a0aC8uLtb27dvV2NhoQioAwGDS1NSk7777TkVFRS36hg0bpsTExL4PhX6BIiYAXVZfX69rrrlG5557rlavXq39+/errq5OVVVV2rlzp5544gmNGTNGa9as6XCuwsJCzZw5U8uWLdPWrVtVXV2t6upqbd68WXfccYcuu+wyj2VvJenSSy+V1WqVJL322mvtzt/U1KS3335bkjR37lxFRER06l6qq6u1e/du/eEPf+j0vbRl7dq1Sk5O1m9+8xtt27ZNFRUVamho0IEDB/Tqq6/qrLPO0u23397iPlvzl7/8RWeccYb+9re/6fDhw2poaNDhw4e1atUqpaWl6a233mr3/CeeeELjx4/XH//4R+3cuVOVlZWqr6/X/v379fLLL2vGjBl66KGHun2vAAAAAAAAAABzGYahpKQkpaSktOirqqrS1q1bVVNTY0IyAMBgUFtbq61bt6qioqJFX3JyspKTk9neFG2iiAlAl7hcLl1xxRX629/+JkmaN2+eXnnlFW3cuFGbNm3SU089pZEjR6qmpkZXXHFFhyv7XHbZZcrIyNCdd96pjz/+WN98841ee+01jRs3TpK0Zs0avfDCCx7nhIaG6gc/+IEk6d1331V9fX2b8//jH//Q0aNHJUkLFizo1L18+umnWrNmjX75y1926V5as23bNs2bN0+VlZXy9/fX3XffrXXr1unrr7/WihUrNGrUKEnSc889pwceeKDDuW699VbFxMTomWee0VdffaUNGzbo/vvvV0BAgBoaGrRgwYI2cy5fvlz33XefmpqadOqpp+pPf/qTPvnkE23ZskXp6emaOXOmXC6XfvWrX+npp5/u8r0CAAAAAAAAALxHfHy8UlNT5evr69FeX1+vrVu3uv/vHACAntTQ0NDi/VtfX19NnDhRw4YNMykV+gs/swMAfa20uqHb5wYH+CnQ37fVvqM1jXK5XN2a12rxVZCl9b+O5bWNcjg7N29kSEC3rt8VL774oj788EP5+/vrgw8+0IUXXujRf/rpp2vhwoU666yztGvXLi1durTd7dI2b96stWvXas6cOe62KVOm6IILLtD48eNVWFio559/XkuWLPE4b8GCBXrjjTdUWVmpv//977riiitanb95paawsDBdfPHFnboXh8OhoqIiTZ06VbfddpvmzJnTqXtpzS233KLGxkb5+vrq73//u84//3x33/Tp03XllVfqzDPPVEZGhp544gldd911mjBhQqtzbd++XQkJCfryyy899og9++yzdcEFF+j8889XU1OTfvzjH+vrr7/2ODcjI0MPPvigJOnhhx/Www8/7FHhPHXqVM2fP1/XX3+9Xn31VT344INauHBhi5WrAAAAAAAAAAD9x5AhQzR58mTt2LFDDQ3/fX/E4XBox44dGjNmjOLi4kxMCAAYaCIiIjRmzBjt2bNHkhQQEKCJEycqJCTE5GToDyhiwqAz9defdPvcX14yQdfNTGy177w/bNDRmu7tI33X91J09/fHtNp35Z83KauoulPz5D52Ubeu31kul0u/+93vJEl33nlniwKmZhEREVq+fLnmzp2rjRs3Kisrq9VlayXpjjvu8ChgajZkyBDdcMMNeuyxx7Rjxw5VVFTIZrO5+y+88EJFRkaqtLRU6enprRYxVVdX64MPPpAkXX755QoMDOzVeznR119/rc2bN0uSFi9e7FHAdPz8K1eu1Jlnnimn06nnn39ezz33XJtz/v73v/coYGp2zjnnaPHixfrTn/6kzZs3a8uWLZo2bZrHeU1NTZo2bVqLAqZmPj4+euaZZ/TWW2+purpab7/9thYvXtypewUAAAAAAAAAeKfg4GBNmTJFO3fuVFVVlUff3r17VVtbq6SkJLb2AQD0mNjYWNXW1qqsrEwTJ05UQEDvL8aBgYHt5AB0WkZGhnJyciSpzZWPmp199tnu402bNrU57sQt3o43depUSccKjvbv3+/R5+/vryuvvFLSsS3jysvLW5z/3nvvqa6urtXr9Ma9nOiTT/5bMHfTTTe1OW7WrFnu7fOOP+dEERERuuSSS9rsv/HGG1u9tnRsWz7pWDFXe/8QDQ8PV2pqqqSu3SsAAAAAAAAAwHtZLBZNmjRJ0dHRLfoOHz6sjIyMbu82AQBAa0aNGqW0tDQKmNAlFDEB6LQtW7a4j2fOnCnDMNr8dfxygAUFBW3OOXbs2Db7hgwZ4j4+8dMh0n8LkxoaGvT222+36G/eSi4+Pl7nnHNOp+/Fz89P8fHxio+Pl5+fX6fv5UQ7d+6UdOwfh2lpae2OPe200yRJWVlZamxsfUWvyZMny8+v7QX00tLSZLFYJEk7duxwtx84cEDFxcWSpAceeKDdPzfDMNy/N125VwAAAAAAAACAd/P19dW4ceM0YsSIFn2BgYGsxAQA6JLGxkb3e5CtMQxDvr6+fZgIAwFFTAA6raioqFvn1dbWttkXFBTUZp+Pz3+/RDkcjhb9s2bNUkJCgiQpPT3do6+oqMi9GtH8+fM95mru74727uVER48elXSsGKu94iNJ7i3iXC6XysrKWh0TExPT7hx+fn7uwq/ma0t9c68AAAAAAAAAAO9nGIaSkpJ0yimnuIuWoqKilJSUZHIyAEB/UlNTo61btyojI0OlpaVmx8EA0v676sAA9M3Pz+v2ucEBbf+V+eSns7u91KrV0nYF6lu3zpTD6R1LuB5fSLRmzRolJiZ26ryOim+6yzAMXXvttXr00Uf16aef6siRIxo2bJgk6c0335TdbpfU+pZ17d2Lw+HwKEA6vkK4O/fSU59e6e48x9/rQw895N6GryPBwcHduh4AAAAAAAAAwLvFxsYqICBAhw4d0tixY1mFCQDQaWVlZdq1a5f7PcjMzEylpaV57G4DdBdFTBh0IkN6Z8/NIcGWXpk3PKh35u2OyMhI93F4eLgmTpxoYppjFixYoEcffVROp1Ovv/667r33Xkn/3Upu7NixmjJlSovz2rsXh8PhXr0oJiam28scNq+KVFpaKrvd3u5qTM1btxmGoYiIiFbHFBYWtns9u93uUXzV7Ph79ff394o/NwAAAAAAAACAuSIiItr8/2gAAFqTn5+vvXv3erQ5HA5lZWUpLS2NolicNLaTA9BpkydPdh9v3LjRxCT/NWHCBE2aNEnSfwuX9u/fr02bNklqfRUmqW/upblYqLGxUdu2bWt37Ndffy1JSklJkcXSeuHatm3b3KtLtWb79u1qbGz0uLYkJSUlyWazSfKePzcAAAAAAAAAgHerrq7Wvn37ur0LBQBg4HC5XMrJyWlRwCRJoaGhmjBhAgVM6BEUMQHotClTpmj48OGSpJUrV6q+vt7kRMc0Fypt3bpVmZmZ7mImSbr22mtbPacv7uW88/67deFf/vKXNsdt2rRJGRkZLc450dGjR7VmzZo2+4+/xvHz+Pr6au7cuZKktWvXKjMzs+PwAAAAAAAAAIBBq7GxUTt37tShQ4e0c+dO95ZBAIDBx+FwKCMjQ4cPH27RFxUVpUmTJrW5SAPQVRQxAeg0Hx8f/exnP5Mk7du3T9ddd50aGhraHF9ZWalnn32213Ndc8017sre9PR0vf7665KkmTNnKikpqdVz+uJeZsyYoWnTpkmSXnjhBf373/9uMaaiokJLlixxZ7rtttvanfOnP/1pq9vKbdiwQStXrpQkTZ06VdOnT/fof+CBB+Tr6yun06krrrii1R8ymjkcDqWnp7c7BgAAAAAAAAAwMDkcDu3cudP9f+ZHjx7Vtm3b2v0/dADAwNTQ0KDt27erpKSkRd+IESM0fvx4+fr6mpAMA5Wf2QEA9C+33nqrPv74Y7333nt666239O2332rJkiWaMWOGbDabKisrtXv3bq1fv14ffPCBAgMDdfvtt/dqpuHDh2v27Nlav369nnvuOZWXl0tqeyu5ju5l6tSpcjgcqq6uVmFhoT799NNu38sLL7yg0047TY2NjZo7d67uuOMOzZs3T8HBwdq6dasee+wx7du3T5J07733emwDd6JJkyYpIyNDU6dO1QMPPKAZM2aooaFBH330kZ588knZ7Xb5+fnpueeea3FuamqqnnjiCd19993KyMjQxIkTdcstt+jcc8/V0KFDVV9fr9zcXG3atElvv/228vPztWPHDvdqVQAAAAAAAACAwaGqqkrV1dUebdXV1fr22281ceJEhYaGmpQMANCXqqurPYpamxmGoZSUFMXFxZmUDAMZRUwAusQwDL3xxhu666679Oc//1k5OTlatmxZm+NjYmL6JNeCBQu0fv16dwGTn5+frrrqqnbP6Yt7SUtL05o1a3TllVeqsrJSv//97/X73/++xbif/OQnevTRRzuc6/bbb9dtt93WajGVxWLRyy+/rNNOO63V85cuXarg4GAtXbpUFRUVWr58uZYvX97qWIvFosDAwE7cIQAAAAAAAABgIAkPD9epp56qXbt2yW63u9sbGxu1bds2jRs3TlFRUSYmBAD0tqNHjyojI6PFdqJ+fn4aP368IiIiTEqGgY7t5AB0mb+/v55//nlt375dd9xxh1JTU2Wz2eTr6yubzaa0tDTddNNNevvtt5WZmdknma644goFBAS4X59//vmKjo7u8Lz27iUsLKxH7uX8889Xdna2fvaznyktLU1hYWEKCAjQyJEjtWDBAn322Wd69tln5ePT8Zfkm2++WZ999pmuuuoqxcfHy2KxaNiwYbruuuu0detWzZ8/v93zFy9erH379ukXv/iFZs2apaioKPn5+Sk4OFhjxozR5Zdfrj//+c86cuSIkpOTu3W/AAAAAAAAAID+LTw8XFOmTJHVavVodzqd2rVrlw4fPiyXy2VSOgBAbzpy5Ih27NjRooApMDBQkydPpoAJvYqVmAB0W2pqqp5++ukun/fII4/okUce6XDcnDlzOv2PoPDwcNXX13c5S7Pj78XhcKioqEjSsdWX2tvHddGiRVq0aFGH80dHR+s3v/mNfvOb33Q7Y7PTTz9db7zxRrfPHzp0qB566CE99NBDJ53lRF35MwMAAAAAAAAAeC+r1arJkydr165dqqio8OjLyclRbW2tUlJSZBiGSQkBAD2turpa2dnZLdrDwsI0YcIEWSwWE1JhMGElJgAAAAAAAAAAAAAt+Pv769RTT9XQoUNb9OXn52vHjh0eW84BAPq3kJAQjRo1yqMtOjpakyZNooAJfYIiJgAAAAAAAAAAAACt8vHx0SmnnKLExMQWfWVlZdq2bdtJ7ZQAAPAuI0aMUGxsrCQpISFB48aNk48PpSXoGzxpAAAAAAAAAAAAANpkGIb7jewTt4+rqanRt99+q8rKSpPSAQB6kmEYSklJUWpqqhITE9k2FH2KIiYAAAAAAAAAAAAAHYqJidGkSZPk7+/v0d7U1KSCggKTUgEAuqOxsbHNPh8fHw0ZMqQP0wDHUMQEAAAAAAAAAAAAoFNsNpsmT56soKAgj7bk5GQTUwEAOsvlcunw4cP66quvVFFRYXYcwIOf2QEAAO3Lzc01OwIAAAAAAAAAAG5Wq1WTJ0/Wrl271NDQoAkTJsjHh7UTAMDbuVwuZWdnKy8vT5K0a9cuTZ48WVar1eRkwDEUMQEAAAAAAAAAAADoEj8/P6WmpqqpqanF9nIAAO9jt9uVmZmpo0ePutuampq0c+dOTZkyRb6+viamA46hiAkAAAAAAAAAAABAl/n4+CggIKDN/vr6erlcLlb4AACT1dfXa+fOnaqpqWnRFxMTw2p68BoUMQEAAAAAAAAAAADoUXa7XTt27FBTU5MmTJggm81mdiQAGJQqKyu1c+dONTU1ebQbhqGxY8cqJibGpGRAS5TTAQAAAAAAAAAAAOgxTqdTGRkZqq2tVVNTk7Zv366ioiKzYwHAoFNcXKzt27e3KGDy9/fXpEmTKGCC12ElJgAAAAAAAAAAAAA95tChQyorK3O/drlcyszMVE1NjRISEti2CAB6mdPp1KFDh5Sbm9uiLygoSBMnTmSrT3glipgAAAAAAAAAAAAA9Jhhw4apoqLCo5BJkg4ePKiSkhKlpKQoPDzcnHAAMMBVVFQoKytLNTU1LfrCw8M1fvx4+fv7m5AM6BhlzgAAAAAAAAAAAAB6jJ+fn1JTUxUfH9+ir7a2Vtu3b9fu3bvV2NhoQjoAGJiampq0Z88ebdu2rdUCptjYWKWmplLABK/GSkwAAAAAAAAAAAAAepRhGEpOTpbValVOTk6L/sLCQpWWlmrUqFGKi4uTYRgmpASAgcPlcqm4uLjVvlGjRmnEiBF8rYXXYyUmAAAAAAAAAAAAAD3OMAwNHz5cU6ZMUUhISIt+u92urKwsbd26VVVVVSYkBICBw2KxaNSoUR5twcHBSktL08iRIylgQr9AERMAAAAAAAAAAACAXhMaGqopU6YoOTlZvr6+Lfqrqqr07bffKjs7W3a73YSEADAwxMfHKyQkRL6+vho9erSmTp0qm81mdiyg09hODgAAAAAAAAAAAECvMgxDw4YNU3R0tHJyclRUVNRiTH5+voYPHy4/P97CBIDWuFwulZaWymazyd/fv0W/YRgaO3as/Pz8FBAQYEJC4OSwEhMAAAAAAAAAAACAPmGxWDRu3DideuqpslqtHn0JCQkKDAw0KRkAeLe6ujrt3LlTu3bt0v79+9scFxwcTAET+i2KmAAAAAAAAAAAAAD0qYiICE2bNk2JiYny8fFRUFCQhg8fbnYsAPA6TqdTBw4c0JYtW3T06FFJx1auq6ioMDkZ0PMoYgKAk7Bq1SoZhiHDMJSbm2t2HAAAAAAAAAAA+g0fHx8lJCRo2rRpGjt2rHx8Wn/r0m63u9+4B4DBpKysTFu2bFFubq6cTqdHX1ZWllwul0nJgN7BhrIAAAAAAAAAAAAATHPitnInOnDggA4fPqyoqCglJyezTRKAAa+xsVE5OTkqKipqtd9isWjkyJF9nArofRQxAQAAAAAAAAAAAPBK1dXVOnz4sCSppKREZWVlSkxM1LBhw2QYhsnpAKBnuVwu5eXlaf/+/XI4HK2OGTZsmBITE+XnR7kHBh6eagAAAAAAAAAAAABex+VyKSsry6PN4XAoJydHBQUFSklJkc1mMykdAPSsqqoq7d27V9XV1a32h4aGKiUlRaGhoX2cDOg7FDEBAAAAAAAAAAAA8EqxsbGqra2V3W73aK+pqdG2bdsUGxurpKQk+fv7m5QQAE6O3W7X/v37lZeX12q/n5+fRo0apbi4OFagw4BHERMAAAAAAAAAAAAAr2MYhuLi4hQVFaV9+/apoKCgxZiCggKVlpYqKSlJVqvVhJQA0H12u12bN29WY2Njq/1Dhw5VUlKSLBZLHycDzOFjdgAA/de6det0/fXXKykpSUFBQQoLC1Nqaqruu+++NiuFJemRRx6RYRjuSuH6+notX75cU6ZMUWhoqEJDQzVjxgw9++yzLT5ZIUmrV692n//xxx93mHPJkiUyDEMBAQEqKyvr8F5CQ0M1ZswYnXvuuVq2bFm799JZxcXF+vnPf67JkycrPDxcgYGBSkxM1MKFC/X555+3e25iYqIMw9CiRYskSZs3b9Y111yjESNGKDAwUCNGjNANN9yg3bt3dypLdna27r77bqWmpspms8lqtSopKUmLFi3Sli1bTvZWJUl1dXX67W9/q0mTJik4OFiRkZGaNWuWXnjhBTmdTq1fv979Z7h+/foeuSYAAAAAAAAAYGDy9/fXKaecorS0NAUHB7fob2pq0p49e5SVlUUhE4B+xc/PT1FRUS3ag4KCNGnSJI0dO5YCJgwqrMQEoMvq6+t1ww036G9/+1uLvp07d2rnzp3605/+pNdff13z5s1rd67CwkJdeOGF2rZtm0f75s2btXnzZq1du1bvv/++fHz+W3N56aWX6tZbb1VdXZ1ee+01ff/7329z/qamJr399tuSpLlz5yoiIqLT97J7927t3r1bK1as6NS9tGXt2rW68sorVVlZ6dF+4MABHThwQK+++qp+8pOf6Omnn/a4z9b85S9/0ZIlSzyKuw4fPqxVq1bp9ddf1yuvvKIrr7yyzfOfeOIJ/exnP1NTU5NH+/79+7V//36tXr1aP//5z/XLX/6yG3d6TEFBgc4991xlZma622pra/XFF1/oiy++0DvvvKOf/vSn3Z4fAAAAAAAAADA42Ww2TZkyRUeOHFFubq6cTqdHf01NjVJTU1VQUCCHw2FSSgDomlGjRqm4uFhNTU3y8fFRQkKChg8f3uH7hsBAxFMPoEtcLpeuuOIKd9HPvHnz9Morr2jjxo3atGmTnnrqKY0cOVI1NTW64oorOlzZ57LLLlNGRobuvPNOffzxx/rmm2/02muvady4cZKkNWvW6IUXXvA4JzQ0VD/4wQ8kSe+++67q6+vbnP8f//iHjh49KklasGBBp+7l008/1Zo1a/TLX/6yS/fSmm3btmnevHmqrKyUv7+/7r77bq1bt05ff/21VqxYoVGjRkmSnnvuOT3wwAMdznXrrbcqJiZGzzzzjL766itt2LBB999/vwICAtTQ0KAFCxa0mXP58uW677771NTUpFNPPVV/+tOf9Mknn2jLli1KT0/XzJkz5XK59Ktf/UpPP/10l+9VOrbk5cUXX+wuYDr//PP13nvvacuWLXr33Xd13nnn6V//+pd+/vOfd2t+AAAAAAAAAMDg5uPjoxEjRmj69Omtrl7i4+Oj+Ph4ZWZmtrrbAwCYxeVytdru5+en0aNHKzIyUtOnT9fIkSMpYMKgxUpMGHxqSrp/riVY8m9jGdKaUkmtf+PpkL/12NytqT0quZyt950ouOUP6z3txRdf1Icffih/f3998MEHuvDCCz36Tz/9dC1cuFBnnXWWdu3apaVLl7a7XVrzaktz5sxxt02ZMkUXXHCBxo8fr8LCQj3//PNasmSJx3kLFizQG2+8ocrKSv3973/XFVdc0er8r732miQpLCxMF198cafuxeFwqKioSFOnTtVtt92mOXPmdOpeWnPLLbeosbFRvr6++vvf/67zzz/f3Td9+nRdeeWVOvPMM5WRkaEnnnhC1113nSZMmNDqXNu3b1dCQoK+/PJLxcbGutvPPvtsXXDBBTr//PPV1NSkH//4x/r66689zs3IyNCDDz4oSXr44Yf18MMPu7fzk6SpU6dq/vz5uv766/Xqq6/qwQcf1MKFC1usXNWRFStW6JtvvnHf+4oVKzyucemll+qmm27SX/7yly7NCwAAAAAAAADA8QIDAzVhwgSVlpYqOzu7xQeeQ0JC5OfHW6EAzFdfX6+cnByFhYXJZrO1OiYmJkZDhw7t42SA9+E7Nwaf5aO7f+7cJ6QZi1vve266VFvavXln/690Thur8Pz1f6Ti3Z2b55GK7l2/k1wul373u99Jku68884WBUzNIiIitHz5cs2dO1cbN25UVlaWUlJSWh17xx13eBQwNRsyZIhuuOEGPfbYY9qxY4cqKio8vqlfeOGFioyMVGlpqdLT01stYqqurtYHH3wgSbr88ssVGBjYq/dyoq+//lqbN2+WJC1evNijgOn4+VeuXKkzzzxTTqdTzz//vJ577rk25/z973/vUcDU7JxzztHixYv1pz/9SZs3b9aWLVs0bdo0j/Oampo0bdq0FgVMzXx8fPTMM8/orbfeUnV1td5++20tXtzG896G559/XpI0dOhQPfnkk62Oeeqpp7RmzRoVFxd3aW4AAAAAAAAAAE4UGRmp8PBwHTx4UIcOHZLL5ZLdbtewYcPMjgZgkHM6nR7bX5aVlWns2LGtjm3tvTtgMGINMgCdlpGRoZycHElqc+WjZmeffbb7eNOmTW2OO3GLt+NNnTpV0rGCo/3793v0+fv768orr5R0bMu48vLyFue/9957qqura/U6vXEvJ/rkk0/cxzfddFOb42bNmuXePu/4c04UERGhSy65pM3+G2+8sdVrS8e25ZOOFXO190NQeHi4UlNTJXXtXiUpPz9fGRkZkqSrrrpKQUFBrY4LCQnRVVdd1aW5AQAAAAAAAABoi6+vr0aNGqWxY8eqoqJCBw8elL+/v9mxAAxiFRUV+vbbb7Vv3z45ncd23XE4HDpy5IjJyQDvRhETgE7bsmWL+3jmzJkyDKPNXyEhIe6xBQUFbc7ZVrWxdGw1pmZVVVUt+psLkxoaGvT222+36G/eSi4+Pl7nnHNOp+/Fz89P8fHxio+Pl5+fX6fv5UQ7d+6UJFksFqWlpbU79rTTTpMkZWVlqbGxsdUxkydPbnfp27S0NFksFknSjh073O0HDhxwr3r0wAMPtPvnZhiG+/emK/d64jWnT5/e7tgZM2Z0aW4AAAAAAAAAADoSGBiozMxMFRUVtTkmPz9fmZmZbf5fPACcjKamJu3Zs0fbtm1TTU1Ni/7q6mqKLIF2UMQEoNPa+6G/PbW1tW32tbVaj3Rse7NmDoejRf+sWbOUkJAgSUpPT/foKyoqcq9GNH/+fI+5mvu7o717OdHRo0clHSvG6mjf7eYt4lwul8rKylodExMT0+4cfn5+7sKv5mtLfXOvJ16zo6zs6QsAAAAAAAAA6GuNjY3at2+fioqKtHnzZuXl5cnlcpkdC8AA4HK5lJ+fr6+//rrNhQLi4uI0btw4NTU19XE6oP9o/111YCC6L6f751qC2+77yWZJ3fxB19/adt8N/5Bczu7N28OOLyRas2aNEhMTO3VeRwUt3WUYhq699lo9+uij+vTTT3XkyBH3Htdvvvmm7Ha7pNa3rGvvXhwOh0cBkq+vr7uvO/fSU3vYdnee4+/1oYcecm/D15Hg4Hae9w6wby8AAAAAAAAAwNvs27fP/d6B3W5XVlaWCgoKlJKSotDQUJPTAeivqqurlZWVpcrKylb7Q0JClJKSorCwsDbHADiGIiYMPsFRvTRvZO/MGzSk4zF9JDLyv/cYHh6uiRMnmpjmmAULFujRRx+V0+nU66+/rnvvvVfSf7eSGzt2rKZMmdLivPbuxeFwuFcviomJ8Shi6ormVZFKS0tlt9vbXY2puSLbMAxFRES0OqawsLDd69ntdo/iq2bH36u/v3+v/bkdn7ujrB31AwAAAAAAAADQkxobG1VaWtqivaqqSt9++63i4+M1atSoDndWAIBmdrtdBw4c0OHDh1vt9/X1VWJiooYNG8YCAEAnsZ0cgE6bPHmy+3jjxo0mJvmvCRMmaNKkSZL+W7i0f/9+bdq0SVLrqzBJfXMvzcVCjY2N2rZtW7tjv/76a0lSSkqKLBZLq2O2bdvm/oRIa7Zv3+7ew/v4QqWkpCTZbDZJvfvnlpqa6j7evHlzu2M76gcAAAAAAAAAoCdZLBZNnz69zR0X8vLytGnTJu3du1fV1dV9nA5Af5Obm6svv/yyzQKm6OhoTZ8+XcOHD6eACegCipgAdNqUKVM0fPhwSdLKlStVX19vcqJjmguVtm7dqszMTHcxkyRde+21rZ7TF/dy3nnnuY//8pe/tDlu06ZNysjIaHHOiY4ePao1a9a02X/8NY6fx9fXV3PnzpUkrV27VpmZmR2H74b4+HiNGzdOkvTWW2+prq6u1XE1NTV68803eyUDAAAAAAAAAABtsVgsGjdunE499VRZrdYW/U6nU/n5+frmm2+0detWFRUVyel0mpAUgLdzuVxyOBwt2q1Wq1JTUzV+/HgFBASYkAzo3yhiAtBpPj4++tnPfibp2L7R1113nRoaGtocX1lZqWeffbbXc11zzTXuCub09HS9/vrrkqSZM2cqKSmp1XP64l5mzJihadOmSZJeeOEF/fvf/24xpqKiQkuWLHFnuu2229qd86c//WmrW7Ft2LBBK1eulCRNnTpV06dP9+h/4IEH5OvrK6fTqSuuuKLNqnDp2HZ66enp7Y5pS3P+goIC3XPPPa2Oufvuu93b9QEAAAAAAAAA0NciIiI0bdo0JSYmysen9bdLKysrlZmZqS+//FL79+9XU1NTH6cE4M3i4+M9XhuGoYSEBE2bNk1DhgwxKRXQ/7GpK4AuufXWW/Xxxx/rvffe01tvvaVvv/1WS5Ys0YwZM2Sz2VRZWandu3dr/fr1+uCDDxQYGKjbb7+9VzMNHz5cs2fP1vr16/Xcc8+pvLxcUttbyXV0L1OnTpXD4VB1dbUKCwv16aefdvteXnjhBZ122mlqbGzU3Llzdccdd2jevHkKDg7W1q1b9dhjj2nfvn2SpHvvvddjG7gTTZo0SRkZGZo6daoeeOABzZgxQw0NDfroo4/05JNPym63y8/PT88991yLc1NTU/XEE0/o7rvvVkZGhiZOnKhbbrlF5557roYOHar6+nrl5uZq06ZNevvtt5Wfn68dO3a4V6vqrNtuu01//etftXXrVv3pT3/S/v37deutt2rEiBE6dOiQnn/+ea1du1bTpk3Tli1bujQ3AAAAAAAAAAA9xcfHRwkJCYqJidH+/ftVXFzc6rimpiYdOnSoy/9fDqD/crlcKi8vV15enkaPHq3AwMAWYwICAhQVFaWSkhJFRUVp1KhRCgoKMiEtMLBQxASgSwzD0BtvvKG77rpLf/7zn5WTk6Nly5a1Ob6tvaV72oIFC7R+/Xp3AZOfn5+uuuqqds/pi3tJS0vTmjVrdOWVV6qyslK///3v9fvf/77FuJ/85Cd69NFHO5zr9ttv12233dZqMZXFYtHLL7+s0047rdXzly5dquDgYC1dulQVFRVavny5li9f3upYi8XS6g9kHfHz89Pf//53nXvuudqzZ4/++c9/6p///KfHmPPPP1/33HOPLrjggi7PDwAAAAAAAABAT7JarRo/frwaGhqUn5+v/Px8NTY2eoyJiYmRv7+/SQkB9BW73a6CggLl5eWprq5OkhQUFKRRo0a1On7UqFFtFjkB6B62kwPQZf7+/nr++ee1fft23XHHHUpNTZXNZpOvr69sNpvS0tJ000036e2331ZmZmafZLriiis89pU9//zzFR0d3eF57d1LWFhYj9zL+eefr+zsbP3sZz9TWlqawsLCFBAQoJEjR2rBggX67LPP9Oyzz7a5ZO3xbr75Zn322We66qqrFB8fL4vFomHDhum6667T1q1bNX/+/HbPX7x4sfbt26df/OIXmjVrlqKiouTn56fg4GCNGTNGl19+uf785z/ryJEjSk5O7tb9xsfHa+vWrfr1r3+tiRMnymq1Kjw8XKeffrqef/55/eMf/5DFYunW3AAAAAAAAAAA9IaAgAAlJibqtNNO07hx42Sz2dx9J24bdbzCwkJVVVX1RUQAvaSqqkp79uzRpk2blJOT4y5gkqT8/Hw5nc5WzwsKCqKACehhrMQEoNtSU1P19NNPd/m8Rx55RI888kiH4+bMmSOXy9WpOcPDw1VfX9/lLM2OvxeHw6GioiJJxz5d4evr2+Z5ixYt0qJFizqcPzo6Wr/5zW/0m9/8ptsZm51++ul64403un3+0KFD9dBDD+mhhx466SxtsVqtevDBB/Xggw/22jUAAAAAAAAAAOhpPj4+iomJUUxMjGpqalRaWqrQ0NBWxzocDmVlZcnhcCg0NFTx8fGKjo5u930FAN7B6XSquLhYR44cabcQsampScXFxRo6dGgfpgMGL4qYAAAAAAAAAAAAAOAEwcHBCg4ObrO/sLBQDodD0n9XcsnJyVFsbKzi4+NltVr7KiqATqqrq3NvHWm329sdGxQUpPj4eEVGRvZROgAUMQEAAAAAAAAAAABAF7hcLuXl5bVot9vtOnz4sA4fPqyIiAh3AYRhGCakBCAd+/t69OhR5eXl6ejRo+2ONQxDUVFRio+Pl81m4+8u0McoYgIAAAAAAAAAAACALnC5XIqOjpbdbldDQ0OrY8rKylRWVqaAgADFxcUpLi5OFoulj5MCaGho0M6dO9sdY7FY3H9PAwIC+igZgBNRxAQAAAAAAAAAAAAAXeDj46OEhASNHDlSpaWlysvLU1lZWatjGxoalJubqwMHDig6Olrx8fEKCwtjhRegjwQGBioyMlKlpaUt+sLDw90rpvn4+JiQDsDxKGICAAAAAAAAAAAAgG5o3noqKipKtbW1ys/PV0FBgex2e4uxLpdLRUVFKioq0ogRI5SUlGRCYmBgcjgcqq2tVWhoaKv98fHx7iImX19fxcbGKj4+XkFBQX0ZE0AHKGICAC+Xm5trdoQeN2fOHLlcLrNjAAAAAAAAAADQY4KCgjR69GglJiaquLhYR44cUXV1datjo6Ki+jgdMDDV1tYqLy9PBQUF8vHx0emnn97qikoRERGKiorSkCFDFBMTI19fXxPSAugIRUwAAAAAAAAAAAAA0EOaV3mJjY1VZWWl8vLyVFxcLKfTKUkKCQlpc7WY5jFsawW0zeVyqaSkRHl5eSovL3e3OxwOlZSUKCYmpsU5hmFowoQJfZgSQHdQxAQAAAAAAAAAAAAAvSAsLExhYWEaPXq0CgoKlJeXp/j4eBmG0er4goICHThwwL3VVUBAQB8nBrxXQ0OD8vPzlZ+fr8bGxlbH5OXltVrEBKB/oIS3F9XW1urxxx/X9OnTNWTIEAUHB2vs2LG65557dODAgZOePzExUYZhdOlXa9tSPfLII50+f/369SedGwAAAAAAAAAAABhM/P39NWLECM2YMUNDhw5tdYzL5VJeXp4aGxt18OBBffnll9q1a5fKysrkcrn6ODHgHVwul8rLy5WRkaGvvvpKBw4caLOASTq2ElrzimYA+h9WYuol2dnZmjt3rrKysjza9+zZoz179ujFF19Uenq6Lr744j7LZLPZFBsb22fXAwAAAAAAAAAAAPBfzQsHtKayslI1NTUebSUlJSopKZHValV8fLxiY2Pl58dbvBj47Ha7CgsLlZeXp9ra2nbH+vn5KS4uTnFxcbJarX2UEEBv4DtcL6iqqtJFF13kLmBavHix5s+fL6vVqnXr1unRRx9VZWWlrr76am3cuFFpaWndus7atWvbrTKVpE8++UR33323JOmqq65SYGBgu+N37NjRbv+oUaO6FhIAAAAAAAAAAABAh8rKytrsq6urU05Ojvbv36+YmBjFxsYqNDRUPj5svIOBJy8vTzk5OR2uqBQWFqb4+HhFR0fzdwEYIChi6gXLly/X3r17JUmPP/647rvvPnffzJkzNWfOHM2ePVu1tbVaunRpt7doGzNmTIdjfvWrX7mPr7vuug7HT5w4sVtZAAAAAAAAAAAAAHRfYmKioqKilJeXp8LCwlYLOJxOpwoKClRQUCAfHx+FhobKZrMpPDxc4eHhba7yBPQngYGBbRYw+fj4aOjQoYqLi1NoaGgfJwPQ2yhH7GFNTU16+umnJUnjxo3TPffc02LMGWecoZtuukmStGHDBm3evLlXslRUVOiDDz6QJCUlJenMM8/slesAAAAAAAAAAAAAOHkhISEaM2aMZs6cqeTkZAUFBbU51ul0qqKiQgcPHlRmZmYfpgS6p6mpSaWlpcrJydG3336ro0ePtjouIiKixbZwVqtVo0eP1syZMzVmzBgKmIABipWYeti6detUUVEhSbr++uvbXLZu0aJFWrFihSTpvffe0/Tp03s8y5tvvqn6+npJnVuFCQAAAAAAAAAAAID5/Pz8NGzYMMXHx6uiokJ5eXkqKSmRy+VqdbzNZmtzFaajR4/KbrfLZrMpICCgN2MDHhoaGlRRUeH+VVNT49FfUVGhIUOGtDjPMAzFxcVp3759ioqKUnx8PCuNAYMERUw97PPPP3cfz549u81x06ZNU1BQkGpra7Vx48ZeybJ69WpJx77IL1y4sFeuAQAAAAAAAAAAAKB3GIbh3iquoaFBBQUFKi4ublEMYrPZ2pzj8OHDKisrk3Rsmy6bzeb+ZbVaKQxBj3C5XKqvr3cXLJWXl7sX3GhLeXl5m31xcXGKiYmh8A4YZChi6mEZGRnu47Fjx7Y5zs/PT8nJyfruu+96ZXnH/fv3u4ujzjzzTCUlJXXqvPPPP1/btm1TeXm5wsPDNX78eF144YVasmSJIiIiup3n8OHD7fbn5+e7j2tqalRZWdnpue12u5xOp1wulxwOR7czAs2Of454pgYXl8slp9Mpu93epa9Dva26urrVY8AMPI/wJjyP8DY8k/AmPI/wNjyT8CYnvukLAEB/ERAQoISEBCUkJKipqUmVlZUqLy9XRUWFwsPDWz3H5XJ5/H93fX296uvrVVhYKEny9/eXzWZTeHi4bDabgoODKWpClxQVFamkpEQVFRVqbGzs0rlVVVVyOp2t7m7k5+cnPz/KGYDBhr/1Pay5WCc4OLjNHxaajRgxQt99952Ki4vV0NDQo1Wkq1evdi8n2ZWt5D7++GP3cXFxsTZs2KANGzbod7/7nVatWqVLLrmkW3lGjBjR6bHvvvtuu9XiJ0pLS5PNZlNISIiKioq6Ew9oU2lpqdkR0IcaGxtVXV2tiooKffDBB2bHadUrr7xidgTAjecR3oTnEd6GZxLehOcR3oZnEmarqKgwOwIAACfN399fkZGRioyMbHdcdXV1ux/YbmpqUklJiUpKSiRJvr6+His1hYaGtlpgAjQrKytTcXFxp8f7+PgoNDTU/YwBwPEoYuphVVVVkqSQkJAOxwYHB7uPq6ure7SIqfk/g6xWq6666qoOx6empuqHP/yhZsyYofj4eDU1NWnPnj1KT0/X2rVrVV5erssvv1xr1qzR//zP//RYTgAAAAAAAAAAAAC9Z8iQIaqsrJTdbu9wrMPh0NGjR3X06FFJUnJysoYNG9bbEeGFHA6HKisrVVFRIbvdruTk5FbH2Ww2FRQUtDkPhXEAuoIiph7WvK+nxWLpcOzxRUt1dXU9luGLL75QTk6OJOmSSy5RWFhYu+OXLl2qRx55pEX7aaedpuuuu04rVqzQrbfeKofDoZtvvlk5OTkKDAzsUqZDhw6125+fn68ZM2ZIki677DKNGTOm03MfOXJETqdT/v7+iomJ6VIuoDUOh8O9AlNkZKR8fX1NToS+UlVV5a7+nzlzptlx3Kqrq93FqQsXLuxUoSzQW3ge4U14HuFteCbhTXge4W14JuFN9u7dq0cffdTsGPBy1dXV+vbbb/X111/r66+/1ubNm5WbmytJSkhIcB/3pC+++ELPP/+8PvvsMxUWFio8PFyTJk3SokWLdM011/T49QAMDqGhoUpNTZXL5VJNTY0qKircvzqz9VdbK+W4XC6VlpbKZrPJ39+/p2PDBCduUVhdXe3e+ccwDI0aNarV98xOfEaatyhs3qaQLQoBdMWgLWLqiS+Uf/3rX7Vo0SKPtubins58029oaHAfW63Wk87TbPXq1e7j66+/vsPxHW17t2TJEm3evFkvvfSS8vLy9M4772jBggVdyjR8+PBOjw0ODu6w8Op4hYWFstvtMgyDYhN026pVq3TDDTdIkrKzsxUUFCTpWHV4Tz1Xubm5GjVqlKTWv34MZI888oh+8YtfSJL7B96uav66/fDDD7daeNkTDMOQj4+P/Pz8uvR1qC+FhIR4bTYMPjyP8CY8j/A2PJPwJjyP8DY8kzDb8SvkA22ZN2+e1q9f32fXe+SRR/SrX/1KTqfT3VZYWKi1a9dq7dq1Sk9P19tvv93lDxgDQDPDMBQSEqKQkBANGzZMLpdL9fX17oKm8vJy92INzfz8/Nr8vllVVaVdu3ZJOva99fiVdnpy9xn0noaGBo+itpqamjbHulwuVVVVtfq+cmBgoOLj4xUSEiKbzSar1UrREoBuG7RFTL0lNDRU0rFPaXTk+G8EPfXps4aGBr355puSpLi4OH3/+9/vkXmXLFmil156SZK0YcOGLhcxAQAAAAAAAADQXxz/QbwhQ4Zo2rRp+uKLLzr1f/9dtWLFCvcHAEePHq2f/exnSk1NVV5enp566imtW7dOH374oW688Ua99tprPX59AIOTYRiyWq2yWq2KjY2V1LKoJTAwsM1ilIqKCvdxTU2NampqlJeXJ+lYUcvxRU0UtXgHu92ukpIS959vV3cKKi8vb7WIyTAMpaSk9FBKAIPdoC1iyszMPOk54uLiWrQNHz5cX331lWpqatr8Qt6seYu16OjoHqtIXrNmjcrKyiRJ1157bY+tIDN+/Hj38ZEjR3pkTgA97/gVpfbv36/ExERzAwEAAAAAAAD90LXXXqslS5Zo+vTpSk5OliQlJib2eBHT0aNHdf/990uSRo4cqS+//FJRUVHu/osvvliXXnqp1qxZo9dff1233HKL5syZ06MZAKBZQECAYmJiFBMTI6n9nRWOL2I6UX19verr61VYWCjp2PZi4f9/e/cdHlWV/3H8M+mFhBA6AqFLVZCAgiBBIihVEARZlaCIBdeVZVUsSJC1UNa1ICqCxEJRBOkgLUGaQihKFUIJnVACSQikzu8PfrmbkJlJm8kk5P16njxc5px77vfOnDm5mfudcwIC5O/vL09PT3l5eRkTQ8B+MjMzjdVrLC3xl56err/++qvA7fr5+al8+fKqUKGCPcIEAJvKbBJT48aNHdJu06ZNNX/+fEnSgQMHdM8991isl56ersOHD0uSmjRpYrfjF3QpufwiOxqAsxV2GToAAAAAAACgoIYPH14sx5k+fbqRCDBhwoQcCUyS5OrqqqlTp2r58uXKyMjQpEmTSGICUGxs3R80mUxycXHJsQymNWlpaTp//rzOnz8vSapYsaKaN29use7JkyeVlJQkd3d3qz9ubm63/L1Ls9ms9PR0paWl5fmTnp6u1NRUZWRkSJJq1aqlevXq5WrT09NTnp6eSklJsXpcFxcXI2kpK/HMXpNmAEB+lNkkJkfp0KGDsb1+/XqrSUzR0dHGcnL33nuvXY59/vx5rVy5UpLUsmVLtWjRwi7tStK+ffuM7Ro1atitXQAAAAAAAAAAyqqFCxdKkvz9/dWvXz+LdWrWrKnQ0FD98ssvWrt2rRITE5nBBIDTNWvWTJmZmUpMTMyxBF1WIo0tlmYJyhIfH69Lly7lq42bf/z8/CyupONsZrNZmZmZuZKPfHx8rI7n27ZtK/Byb1nS0tIsPm4ymVS+fHnFxcUZj7m6uuZY+s/Pz08uLi6FOi4A2ANJTHYWEhKi8uXL68qVK/rmm2/06quvWswEjoiIMLb79u1rl2PPmTPH+KVkz1mYpBtrcmfp1KmTXdsGAAAAAAAAAKCsSU1N1datWyVJ7dq1k4eHh9W6nTp10i+//KKUlBRFR0erc+fOxRUmAFjl4uJiJL9IN5J1rl69miOpKTU1Ndd+tpKYrCXgWKp3c920tDSrSUx//fWXLl26ZHOGp5t/8pPMc/nyZaWmpuY5W5Kl1SZq1aplNYnJza3wt/FtPYeBgYHKzMw0Xrdy5crd8rNaAShdSGKyMw8PD7300ksaP3689u/fr8mTJ+uVV17JUWfLli2aMWOGpBt/eLRp08ZiW1m/MIKCgnTs2LE8j521lJybm5sGDx6cr3h3794tb29vY01vS6ZNm6bp06dLkqpVq2a3pCuUTuHh4Ro3bpykGxejCQkJ+vDDDzV//nwdPXpUPj4+Cg4O1ltvvaX27dsb+8XFxemTTz7Rzz//rGPHjsnLy0sdOnRQeHi4WrVqZfOYmZmZmj17tmbPnq0dO3bo0qVLKl++vJo3b64BAwZo2LBhNv/Al25k7k+YMEELFy5UbGys/Pz8dMcdd+jZZ5/VgAED8jzvrPfj2LFjFR4ebrVeSEiI1q9fr06dOikqKirPdm+2Z88eLVy4UBs2bNDevXt1/vx5ubu7q3r16mrfvr2ef/55izO8RUVF5frgom7durnqRUZGWpxueuHChZo1a5Z+//13xcXFycvLSw0aNFCvXr300ksv5bnO8cmTJ/X+++9rxYoVOn36tAIDAxUcHKyXXnpJoaGhBXsSrMjvawAAAAAAAACUBgcPHjRmLGncuLHNutnL9+/fX6AkppMnT9osP3PmjLGdmJiohISEfLddFElJSRa3gaKgX5UMfn5+8vPz02233abU1FQlJSUpKSlJKSkpSk9PN+4vWWJrqbO82Gr36tWrSk1NtZhUZY2Li4tcXFxUt25dHT161GKfOnDgQKFjvnr1qtV4i5JYdP36davtent7q1atWpJuPF+JiYmFPg4Kh3EKjuCsfuWIMYQkJgd45ZVX9MMPP+jgwYN69dVXFRMTo0GDBsnb21uRkZF67733lJ6eLm9vb3300Ud2Oea+ffu0fft2SdKDDz6oKlWq5Gu/7du3a9iwYercubMeeughtWjRQhUrVlR6eroOHDigWbNmadWqVZJuTCc4bdo0+fr62iVmlH4nTpxQaGioDh48aDx29epVrVixQqtWrdKcOXM0YMAA/fnnn+revbtOnTpl1EtOTtbixYv1yy+/aMWKFVb/6L506ZJ69+6tTZs25Xj8woULioqKUlRUlKZMmaIVK1YoKCjIYhv79+9XaGioTp8+bTx2/fp1rV27VmvXrtXQoUN13333FeWpsAtLiUjSjW9kxcTEKCYmRt9++61Gjx6t999/3y7HjI+PV//+/bVu3bocj6ekpGj79u3avn27pk6dqkWLFlldHnPDhg3q2bNnjgviM2fOaMmSJVqyZAkJRwAAAAAAAIAF2ZOLatasabNu1g1n6cbnsgWRfd+8fPfdd8aMKsXpu+++K/Zj4tZHvyqdqlWrJk9PT7m5ucnd3V1ubm7Gtqurq819//zzTy1btsxiWfPmzVWuXLkCxZKZmanMzExjViRLfapZs2aFXuIzJiZGy5cvt1hWv359Va5cWZKUkZGh9PR0paWl2fw3+/batWsLFROKF+MUHKE4+9WVK1fs3iZJTA7g5+enZcuWqXv37jp06JCmTZumadOm5ajj7++vWbNmqWXLlnY5ZtYsTJL05JNPFmjfjIwMrVmzRmvWrLFap2LFipoxY4Z69epV6Bhx6xkwYIBOnjyp119/XQ8++KB8fHy0ceNGjR07VgkJCXr66acVHBysnj176tq1a3r33XfVqVMnubu7a+XKlXr33XeVkpKisLAwHTp0KNdsShkZGerZs6e2bNki6cbMZS+++KLq1q2r06dP6+uvv9bChQu1f/9+denSRbt27cp1AZqQkKBu3boZCUwDBw7UkCFDVKVKFR08eFAffvihZs6cqT179hTPk2ZDenq6fH191aNHD91///1q3Lix/P39FRcXp7179+qTTz5RbGysPvjgAzVq1EhDhw419m3Tpo12796tRYsW6a233pIk/fLLL6pRo0aOY2SfnSklJUWhoaHasWOHXF1dNXjwYHXv3l1169ZVWlqafv31V3344YeKi4tT9+7dtXPnzlyJYsePHzcSmFxcXDR8+HD1799f5cuX159//qkPPvhA4eHhCg4OduAzBwAAAAAAAJQ+2b+5nteN9exfLmbWBgC3srNnz1otM5lMuRKbsv9ra0aQoizPlp6ebrUsv8vfZcnMzDSSjWzN4HT8+HGdOHHC6lJ0AHCrIonJQRo0aKCdO3fqs88+07x58xQTE6PU1FTVqlVL3bt31z/+8Q+rs8YUVGZmpmbNmiVJCggIUO/evfO9b/fu3TVjxgxt2bJFO3fu1Llz53Tx4kWZzWYFBgbqzjvv1IMPPqiwsDD5+/vbJV5nyMw0Kz45/9NDlnYVfDzk4uL49Wt37dql9evX6+677zYeCw4OVsOGDdWzZ08lJibq7rvvltls1tatW1W/fn2jXtu2bVWpUiWNGDFCx48f17Jly3ItVfjFF18YCUxPPvmkIiIijOkzW7durV69eunNN9/Ue++9p8OHD2v8+PGaMGFCjjbGjx9vfDPpvffe0+uvv26UtW7dWv3791fPnj2NGcecqWXLljp58qQCAgJylXXr1k0vvviievbsqdWrV2vcuHF68sknjW8d+Pr6qnnz5oqOjjb2adSokerUqWP1eO+884527NihgIAArVmzRq1bt85R3qFDB/3tb39Tu3btdObMGb3xxhvGWJNl1KhRxgxM33//vR577DGjLDg4WAMGDFDHjh1zxAUAAAAAAADgxmzxWW7+gufNPD09je1r164V6Dh5zdx05swZtW3bVpL0xBNP6LbbbitQ+4WVlJRkzBTwxBNPFHiGFMAS+hWsSU5OVlpamjGrkaWfrLKbZSUqWepTJ0+eVEJCgpFYlfXj6uqa6zE3Nze5uLgUaak4lH6MU3AEZ/WrU6dO2W0FoSwkMTmQr6+vXn31Vb366quF2j+/WbUuLi4Fnj42S5UqVfTUU0/pqaeeKtT+pUV8cqpa/9v6TFO3mu1vhapiOc+8KxbRyy+/nCOBKUuPHj0UFBSk2NhYnT9/Xp9//nmOBKYsQ4cO1ahRo3T9+nVt2LAhVxLTZ599JkmqXLmypkyZYvGibty4cVqwYIEOHDigr776Su+8847xB31qaqpmzJghSbrjjjs0evToXPu7u7trxowZqlevXoGz5e2tUqVKNss9PDw0adIktWzZUrGxsdq1a1euxKP8SkpKMp7f8ePHW20nKChIY8aM0QsvvKB58+blWFLy7Nmz+vnnnyVJPXv2zJHAlMXPz0/Tpk2z2E8AAAAAAACAorDHTeCZM2cqLCys6MEUgpeXl7Gdmmr7S7jZZ+vw9vYu0HHyWqouOz8/P6d8oblcuXKl+ovUKJnoV8guv33BbDYbMyWlpaXpypUr+uOPPyRZ7lNNmza1e6woOxin4AjF2a+yJruwJxe7twigzBg0aJDVsjvuuEPSjQ8SBg4caLGOt7e3GjZsKEk6cuRIjrLTp09r//79kqRHH33U6nrCbm5uxrJq8fHx2rFjh1G2fft2xcfHS5KGDBli9UONmjVrqmvXrlbPxVlSUlJ0/Phx7du3T3v27NGePXtyJDdmXTQXxvr16401Svv372+z7n333SfpxjcNtm/fbjweGRmpjIwMScqxtN3N2rZtq2bNmhU6VgAAAAAAAOBWlP0zz7yWiLt69aqxzYwNAOA4WUvW+fj4qHz58goICCjwDHgAgMJjJiYAhdaoUSOrZVlLolWqVEkVKlTIs97N6xTv2bPH2M5rFp/s5Xv27FG7du0kSbt37zYeb9Omjc022rZtq2XLltmsUxyuXr2qTz75RHPnztXevXuNJCFLLly4UOjjZF/erXr16vneL/ta1AV9fvfu3VuACAEAAAAAAADbsr4EWRQF+WzM3rLPkHTy5EmbdbOvxlCrVi2HxQQAAAA4E0lMAArNx8fHapmLi0uedbLXuzlZ59KlS8Z2lSpVbLZRrVo1i/sVpI2qVavaLC8Ox44d0/3336+jR4/mq35RMv/j4uIKtV9ycrKxXdqeXwAAAAAAANxaGjdu7OwQiqRRo0ZydXVVRkaGDhw4YLNu9vImTZo4OjQAAADAKUhiQplQwcdD298KdXYYxaaCj4ezQ7Are6xtb482HO2JJ57Q0aNHZTKZNHToUA0aNEhNmjRR5cqV5eHhIZPJpMzMTLm6ukpSjqXlCip70tiOHTvk7u6er/2yfzssu9Lw/AIAAAAAAAAliYeHh9q2bastW7Zoy5YtSk1NlYeH5c92169fL0ny9PRUcHBwcYYJAAAAFBuSmFAmuLiYVLGcp7PDQAEEBgYa2+fOnbNZN/sSZ9n3y76M3blz52wuf5fXMUwmk8xmszIzM23Wy742fUEcOHBAGzdulCS98cYb+ve//22xXvbZj4qiYsWKxnblypWtJifZcvPza2sa67yeXwAAAAAAAKAsevjhh7VlyxYlJCRowYIFGjRoUK46J0+e1Jo1ayRJXbp0kZ+fX3GHCQAAABQLF2cHAACWNG/e3Nj+/fffbdbdunWrxf1atGhhbG/bts1mG3mVZ30wEB8fb7WO2WxWTEyMzXas2bt3r7E9cOBAq/Wio6NttpPfGZFatWplbG/atClf+9zMns8vAAAAAAAAcKs5duyYTCaTTCaTQkJCLNYZNmyYypcvL0kaPXq0Ll68mKM8IyNDL7zwgjGz+iuvvOLQmAEAAABnIokJQIlUo0YNY233H3/8UUlJSRbrZWRkKCIiQtKNmYHuuusuo6x169bGbEHfffed1eXXTp06pVWrVtmMp27dupJsJxGtWLFCly9fttmONenp6ca2rdmcvvjiC5vteHl5GdspKSlW64WGhsrHx0eS9MknnxRqabrOnTsbS9t98803Vutt27ZNe/bsKXD7AAAAAAAAgLPExMQoIiIix0/WZ5RJSUm5yrLPFl8QgYGBmjBhgiQpNjZWd999t2bOnKno6GgtXrxYDzzwgJYsWSJJeuyxx6wmQwEAAAC3ApKYAJRYI0aMkCSdP39eL730ksU648aN0759+yRJzzzzjDw9/7dsoKenp4YOHSpJ2rVrlyZNmpRr//T0dD3zzDNKTU21GUunTp0k3ZgVytLMRWfPntXf//73fJyVZQ0bNjS2s5Kybvb5559r0aJFNtupXr26sX348GGr9QICAvTiiy9KkjZv3qyRI0faXCrv3Llzmj59eq5j9enTR5K0ePFi/fjjj7n2S0pK0rPPPmszZgAAAAAAAKCk2bhxo4YOHZrjJ2uWpIsXL+YqO3DgQKGP9eyzz+rtt9+WyWTS4cOH9dRTT6lNmzbq06ePIiMjJUndu3fX119/bZdzAwAAAEoqkpgAlFjPPfec2rVrJ0maOXOmunTpovnz52vHjh1atmyZHnnkEY0fP16SVL9+fY0ZMyZXG2+//bZq1qwpSXrttdc0ePBgrVy5Ujt27NDcuXPVvn17rVixQsHBwTZjGT58uNzc3GQ2m9WrVy999NFHio6O1ubNmzVp0iS1atVKV65cyZGMVBCtWrUylsL78ssvNXDgQC1dulTbt2/XokWLNGDAAL3wwgu6995782wnazamMWPGaPXq1Tp48KBiYmIUExOja9euGXXfeecd3X333ZKkjz/+WHfddZc+++wzbdq0Sbt27VJkZKSmTJmihx9+WLVr17Y4C9R//vMfY6m9wYMHa8SIEYqMjNT27ds1c+ZMtW7dWjt37szz+QUAAAAAAADKsnHjxmnjxo0aPHiwatWqJQ8PD1WpUkUPPPCAZs+erWXLluWYhR0AAAC4Fbk5OwAAsMbV1VVLly5V7969tWnTJq1bt07r1q3LVa9JkyZasWKFypUrl6usfPnyWrlypUJDQ3X27FnNmTNHc+bMyVEnLCxMnTp1MmZtsqRZs2aaOHGi/vnPfyo+Pl4jR47MUR4YGKiFCxdqzJgxOnToUIHP1WQy6bvvvtP999+v+Ph4/fjjj7lmNmrRooXmzZunGjVqWG3Hz89PL730kiZOnKgdO3aoa9euOcojIyONKac9PT21evVqhYWFacGCBfrjjz+M2Zks8ff3z/VYnTp1tHjxYvXu3VuJiYmaOnWqpk6dmqNO1rfIbC3FBwAAAAAAAJQkYWFhCgsLK1IbderUkdlsznf99u3bq3379kU6JgAAAFCaMRMTgBItMDBQv/76q7799ls9+OCDqlq1qtzd3VWxYkWFhIRoypQp2rVrl4KCgqy20axZM+3du1evvvqqGjZsKE9PT1WqVEmdO3fW7NmzNXPmzHzFMnLkSK1cuVLdunVThQoV5Onpqbp162rEiBHauXOnOnbsWKRzbdmypXbt2qXnnntOQUFBcnd3V2BgoNq2bavJkydr69atOZaLs+aDDz7QV199pY4dOyowMFCurq5W6/r5+Wn+/PnasGGDhg0bpttvv11+fn5yc3NTYGCg2rRpoxEjRmj58uVavXq1xTZCQkK0d+9ePf/88woKCpKHh4eqVq2qHj16aOXKlRo3blyhnxMAAAAAAAAAAAAAQNnATEwACiQ8PFzh4eF51ouIiFBERESe9aKiovKs4+LioieeeEJPPPFE3gFaERgYqAkTJmjChAkWy7N/syojI0NxcXEW63Xr1k3dunWzehxb55Ofb17Vrl1bn3/+uc06ebVhMpk0bNgwDRs2zGa97Dp06KAOHTrku/7NatWqlWsGpuzy229sKci31gAAAAAAAAAAAAAApQszMQEAAAAAAAAAAAAAAABwKpKYAAAAAAAAAAAAAAAAADgVSUwAAAAAAAAAAAAAAAAAnIokJgAAAAAAAAAAAAAAAABORRITAAAAAAAAAAAAAAAAAKciiQkAAAAAAAAAAAAAAACAU5HEBAAAAAAAAAAAAAAAAMCpSGICAAAAAAAAAAAAAAAA4FQkMQEAAAAAAAAAAAAAAABwKpKYAAAAAAAAAAAAAAAAADgVSUwAAAAAAAAAAAAAAAAAnIokJgAAAAAAAAAAAAAAAABORRITAAAAAAAAAAAAAAAAAKciiQkAAAAAAAAAAAAAAACAU5HEBAAAAAAAAAAAAAAAAMCpSGICAAAAAAAAAAAAAAAA4FQkMQEAAAAAAAAAAAAAAABwKpKYAAAAAAAAAAAAAAAAADgVSUwAAAAAAAAAAAAAAAAAnIokJgCQFBERIZPJJJPJpGPHjjnkGMeOHTOOERER4ZBjlFTh4eHGuQMAAAAAAAAAAAAAcDOSmAAAAAAAAAAAAAAAAAA4FUlMAHALKY4ZpQAAAAAAAAAAAAAAsDeSmAAAAAAAAAAAAAAAAAA4FUlMAAAAAAAAAAAAAAAAAJyKJCYAAAAAAAAAAAAAAAAATkUSE4ACCQ8Pl8lkkslkkiQlJCQoPDxcLVq0ULly5VSlShV1795dmzdvzrFfXFyc3nrrLTVr1ky+vr6qWLGi+vTpo507d+Z5zMzMTH3//ffq3r27qlWrJg8PD1WuXFmdO3fW1KlTlZqammcb8fHxGj16tBo3bixvb29VqVJFoaGhmjdvXr7OO+ucw8PDbdYLCQmRyWRSSEhIvtq92Z49e/Tvf/9b3bp1U82aNeXp6aly5cqpYcOGGjJkiH777TeL+0VFRclkMmno0KHGY3Xr1jXizvqJioqyuP/ChQs1YMAA1a5dW15eXgoICFBwcLDGjRun+Pj4POM+efKkRowYoXr16snLy0s1atRQ7969tWbNmkI9D7bMnj1bISEhqlChgsqVK6fmzZtr7Nixunz5sqT8v1YAAAAAAAAAAAAAgJLDzdkBACi9Tpw4odDQUB08eNB47OrVq1qxYoVWrVqlOXPmaMCAAfrzzz/VvXt3nTp1yqiXnJysxYsX65dfftGKFSvUuXNni8e4dOmSevfurU2bNuV4/MKFC4qKilJUVJSmTJmiFStWKCgoyGIb+/fvV2hoqE6fPm08dv36da1du1Zr167V0KFDdd999xXlqbCLqKgoi89DamqqYmJiFBMTo2+//VajR4/W+++/b5djxsfHq3///lq3bl2Ox1NSUrR9+3Zt375dU6dO1aJFi3TPPfdYbGPDhg3q2bOnEhISjMfOnDmjJUuWaMmSJXZLJkpPT9fgwYNzJZ7t3btXe/fu1ffff++QpCkAAAAAAAAAAAAAgOORxASg0AYMGKCTJ0/q9ddf14MPPigfHx9t3LhRY8eOVUJCgp5++mkFBwerZ8+eunbtmt5991116tRJ7u7uWrlypd59912lpKQoLCxMhw4dkoeHR472MzIy1LNnT23ZskWS1KlTJ7344ouqW7euTp8+ra+//loLFy7U/v371aVLF+3atUvlypXL0UZCQoK6detmJDANHDhQQ4YMUZUqVXTw4EF9+OGHmjlzpvbs2VM8T5oN6enp8vX1VY8ePXT//fercePG8vf3V1xcnPbu3atPPvlEsbGx+uCDD9SoUaMcsy61adNGu3fv1qJFi/TWW29Jkn755RfVqFEjxzHq1q1rbKekpCg0NFQ7duyQq6urBg8erO7du6tu3bpKS0vTr7/+qg8//FBxcXHq3r27du7cmStR7Pjx40YCk4uLi4YPH67+/furfPny+vPPP/XBBx8oPDxcwcHBRX5+/vWvfxkJTLfffrteffVV3XHHHbpy5YrmzZunr776SgMHDizycQAAAAAAAAAAAAAAxY8kJpQNmZnStUvOjqL4eAdKLo5fLXLXrl1av3697r77buOx4OBgNWzYUD179lRiYqLuvvtumc1mbd26VfXr1zfqtW3bVpUqVdKIESN0/PhxLVu2TH379s3R/hdffGEkMD355JOKiIgwlrFr3bq1evXqpTfffFPvvfeeDh8+rPHjx2vChAk52hg/frxOnDghSXrvvff0+uuvG2WtW7dW//791bNnT61atcq+T04htGzZUidPnlRAQECusm7duunFF19Uz549tXr1ao0bN05PPvmkXF1dJUm+vr5q3ry5oqOjjX0aNWqkOnXqWD3eO++8ox07diggIEBr1qxR69atc5R36NBBf/vb39SuXTudOXNGb7zxhmbNmpWjzqhRo4wZmL7//ns99thjRllwcLAGDBigjh075oirMHbv3q1PP/1UknTXXXdp/fr1ORLWunTpovbt22vIkCFFOg4AAAAAAAAAAAAAwDlIYkLZcO2SNKl+3vVuFa8clnwrOfwwL7/8co4Epiw9evRQUFCQYmNjdf78eX3++ec5EpiyDB06VKNGjdL169e1YcOGXElMn332mSSpcuXKmjJlipHAlN24ceO0YMECHThwQF999ZXeeecdeXp6SrqxDNuMGTMkSXfccYdGjx6da393d3fNmDFD9erVU1paWsGfBDuqVMn2a+bh4aFJkyapZcuWio2N1a5du3IlHuVXUlKS8fyOHz/eajtBQUEaM2aMXnjhBc2bN0/Tpk2Tr6+vJOns2bP6+eefJUk9e/bMkcCUxc/PT9OmTbPYTwriiy++UGZmpiRp2rRpuWbckm4kus2dO1crVqwo0rEAAAAAAAAAAAAAAMWPJCaUOOnp6UpNTc13/czMTJnN5jzrOH5eopLPbDbn+VxZYzKZciURDRo0yGq7LVq0UGxsrEwmkwYMGGAkoGTn6emphg0bavfu3Tpy5EiOstOnT2v//v2Sbixb5+vra7ENFxcXhYWFafTo0YqPj1d0dLTatWsnSdq+fbvi4+MlSUOGDDHivzneGjVq6IEHHtDy5cuN8ux1sx/X1vN3c9nN8Wb/f2ZmZq7ym5/jlJQUnTt3TomJicrIyJAk419J2rlzp1q1apXnMSy9duvXr9eVK1ckSf369bP43Gbp0KGDJCktLU3btm3TfffdJ0lat26dEU/2pe1ufn6Dg4PVrFkz7d271+LzcjNL8a5Zs0bSjX7VqlUrq22EhYUZSUw3v3aW2s1y82ucmZmZ73HI1dXVmBHrZmlpaYV+z7m4uMjNzfKv6fT09Dyfx1ulXZPJJHd3d4tlGRkZOd4TJaFdSbmWxsySmZmp9PT0Qrfr7u5usQ87ql2z2WwxuTMtLc14rdPS0qy+V9zc3ORiYVZAa+3ml7V2JRXo+uFmjnovM0Y4tl1bfZ8xwrHtOuq9XNrHiPyOkQVtt6BK23uZ64j/secYkb0/WutLjBH/w3XEDY58Lxd0jHR0vGV9jMjOWdcR1s4HAAAAAFB2kcSEEufAgQO6dCn/S795eXnJw8PD6gd7kpR87Zpyz9tS9ly/fr3QHz65urrKx8cnx2ONGjWSdCPZ5uYPkrNmyqlYsaI8PDx09epVi+36+flJkhITE3M8vmfPHmP7zjvvtLq/dGOWpSw7duzQHXfcIZPJpN27dxuPt2nTxthOS0tTSkpKjjZatmxpJDFdv35dVatWlSRdu3YtRz1bH7Kmp6fnSDa6Oebk5OQc7dxc7uvrq+TkZH3yySeaO3eu9u7da/PDzTNnzuRqI3t8ycnJunr1qnx8fHK9P7Iv73bbbbdZPcbNYmNjjWP++eefxuPZn1+z2ZwrrlatWhlJTLZeS+nGezr7B74pKSk6dOiQpBuvk639mzdvbmzf/Bx7enpa/YA0OTlZZrNZ6enpSklJUWpqqrGUYV6CgoKsLtu3a9euHK97QdSoUUMNGza0WLZnzx4jCa2gKlWqpGbNmlks++uvv3ThwoVCtVu+fHm1bNnSYtnRo0d1+vTpQrXr4+OTo39ld+LECcXGxhaqXXd3d7Vv395i2dmzZxUTE1OodiWpU6dOFh+/ePGi9u3bV+h227VrZ7EPJyQk6I8//ih0u8HBwcYMa9klJydbXQoyODhYUs6x+mZ33nmnxeUx09LS8v3+sqRp06aqXLmyxbKitNugQQOr4+G2bdsKfcOUMeIGR40RXl5eVssYI25wxhiRH7fyGJGfMTILY8QNXEf8j73HiKz+aO3vQMaI/+E64gZHjxEFGSOzMEb8z612HWHtfAAAAAAAZRdJTAAK7eakpuyyvt1qq072ejcn62RPZLP2IXOWrIQjScbMSze3UaVKFZtt5FVeHI4dO6bQ0FAdPXo0X/VvTrAqiLi4uELtl/2YxfX8xsfHG98wzqsvlITXEQAAAAAAAAAAAABQcCQxoWzwrqCk5wv3zTF3D3d5enhaLLuanCxzIactd3N3k5en5dkDkq8lKzOjcO26urnK2zuwUPuWVNaWACvuNhxtyJAhOnr0qEwmk4YOHapBgwapSZMmqlChgjIyMmQymZSZmWl8I7mwSwdIOZPGNmzYYHWq+5vVqFHD4uPF9fyWhtcRAAAAAAAAAAAAAFBwJDGhbDC5yOxTsXD7enhInpaTmKSrhU5ikru7ZG0JFFOyzDaWEbPJzU36/9mNSrPAwP8lYuU1a9C5c+eM7QoVKljcPnfunLH8nSV5HcNkMslsNiszj9c7r6XSrDl48KA2btwoSXrjjTf073//2yhLT083ZkDKPtNUUVSs+L/3Q6VKlQq0pFyWm5/fWrVqWa1b2JmfJOVYRiKvdopyHAAAAAAAAAAAAACA85DEhBKncePGuv322/Nd/+jRo8rIyDCWJbMkryXNbLE184u3t7fD2i3sLDu22vXy8nJIu56envLw8MjxmJubm7Gfr6+v1X1dXV0tPt68eXNj+48//tCwYcOstrF7925j+6677jKO16JFC+Pxbdu2qWPHjpIkd3d3I77sx8ji5eVlJCNVqlRJLi4u8vPzU0JCgs0kJVdXV2MpOFdX11znnb0fenh45Cg/cuSIsT1w4MBc7WbV3bBhg9U2pBuvRfbj+fr6WnztWrVqZWzv3LnTZoKXNXfccYexvW3bNiOJydJrvmvXLmPbVn/I2j87Ly8vNWzYUIcOHdKuXbts7r93715j++bnx1Yfznpt3Nzc5OnpKR8fH9WtW9dmnFms9WFJatmyZaHfc7bGtObNm+eZUFeYdm+//XY1bNjQ7u3WrVtXQUFBhWrX1utWq1Ytq7ODFaXdatWq5bl0YWFUrFhR7dq1K/T+1mZM8/f3d0i7Pj4+FttNTExURESEJCksLEx+fn4W9795nM1+vKLEa61dSUVq19Z7uU2bNoV+LzNG5N1uUcaIpKQkRUVFWSxjjLihuMeI/LpVx4j8jpH5aZcx4gauI24ozBiRvT+2bNnSYh3GiP/hOuIGR44R1apVK9AYmZ92GSNuKGvXEQAAAACAWxdJTChx3NzcciXE2OLi4pLnB2y2PvAqCke1azKZHLJsVnG2m/3/hXmeatSooSZNmmj//v2aN2+eJkyYoHLlyuWql5GRoW+++UbSjZmBgoODjeO1bt1aFSpUUHx8vL777juNHDnSiDV7fKdOndLq1atzxJ71YbDJZJKLi4vq1q2rP/74Q9u3b7ca88qVK3X58mWr5539/y4uLjn+n70P35wolT3eadOm5Xj85mNkT5RKS0uz+tyHhobKx8dHycnJmjJligYNGlTgvnH//ffL1dXVeA369euXK17pRoLTnj17jP8Xpj+Ehobq0KFD2r17t/74448cSVjZZX0gnhVHfo+VvV7WfgUZh6zJ7zJ9BWXr5ktZatfV1dXmjZ2S1q69+lVxtWsymSy26+7urvT0dGO7oMe21q49OKpdR72XGSOK3q6tfRkjHNuuo97LpX2MKOoYaa1deyqJ72VntFsWxojs/dHatT5jxP9wHXGDI9/L9hwjs7frCGVhjHBmu458LwMAAAAASrfSv+YUgFvWiBEjJEnnz5/XSy+9ZLHOuHHjtG/fPknSM888k2MmIk9PTw0dOlTSjZmAJk2alGv/9PR0PfPMM0pNTbUZS6dOnSRJv//+uzZt2pSr/OzZs/r73/+ej7OyLPu31rMn4mT3+eefa9GiRTbbqV69urF9+PBhq/UCAgL04osvSpI2b96skSNH2kwGPHfunKZPn57rWH369JEkLV68WD/++GOu/ZKSkvTss8/ajDk/nn32WePGy/Dhwy3OiDVr1iwtX768yMcCAAAAAAAAAAAAABQ/kpgAlFjPPfecMb34zJkz1aVLF82fP187duzQsmXL9Mgjj2j8+PGSpPr162vMmDG52nj77bdVs2ZNSdJrr72mwYMHa+XKldqxY4fmzp2r9u3ba8WKFQoODrYZy/Dhw+Xm5iaz2axevXrpo48+UnR0tDZv3qxJkyapVatWunLlSqGX0GjVqpWxhN6XX36pgQMHaunSpdq+fbsWLVqkAQMG6IUXXtC9996bZzteXl6SpDFjxmj16tU6ePCgYmJiFBMTo2vXrhl133nnHd19992SpI8//lh33XWXPvvsM23atEm7du1SZGSkpkyZoocffli1a9fWF198ket4//nPf4wlAAYPHqwRI0YoMjJS27dv18yZM9W6dWvt3Lkzz+c3L3feeaeR1BYdHa3g4GBFRERo+/btWrdunZ5//nk9+eSTRT4OAAAAAAAAAAAAAMA5WE4OQInl6uqqpUuXqnfv3tq0aZPWrVundevW5arXpEkTrVixwuJyc+XLl9fKlSsVGhqqs2fPas6cOZozZ06OOmFhYerUqZMxa5MlzZo108SJE/XPf/5T8fHxGjlyZI7ywMBALVy4UGPGjNGhQ4cKfK4mk0nfffed7r//fsXHx+vHH3/MNbNRixYtNG/ePNWoUcNqO35+fnrppZc0ceJE7dixQ127ds1RHhkZqZCQEEk3ZqpavXq1wsLCtGDBAv3xxx/G7EyW+Pv753qsTp06Wrx4sXr37q3ExERNnTpVU6dOzVHn7bfflslkUnR0dF5Pg00ffvihTp8+rQULFujAgQO5Xq+6devqhx9+UP369Yt0HAAAAAAAAAAAAABA8WMmJgAlWmBgoH799Vd9++23evDBB1W1alW5u7urYsWKCgkJ0ZQpU7Rr1y4FBQVZbaNZs2bau3evXn31VTVs2FCenp6qVKmSOnfurNmzZ2vmzJn5imXkyJFauXKlunXrpgoVKsjT01N169bViBEjtHPnTnXs2LFI59qyZUvt2rVLzz33nIKCguTu7q7AwEC1bdtWkydP1tatW3MsF2fNBx98oK+++kodO3ZUYGCgXF1drdb18/PT/PnztWHDBg0bNky33367/Pz85ObmpsDAQLVp00YjRozQ8uXLtXr1aotthISEaO/evXr++ecVFBQkDw8PVa1aVT169NDKlSs1bty4Qj8n2bm7u2v+/Pn67rvv1LFjR5UvX14+Pj5q0qSJ3njjDW3fvl316tWzy7EAAAAAAAAAAAAAAMWLmZgAFEh4eLjCw8PzrBcREaGIiIg860VFReVZx8XFRU888YSeeOKJvAO0IjAwUBMmTNCECRMsloeFhSksLEySlJGRobi4OIv1unXrpm7dulk9jq3zqVOnjsxms804a9eurc8//9xmnbzaMJlMGjZsmIYNG2azXnYdOnRQhw4d8l3/ZrVq1co1A1N2+e03+fH444/r8ccft0tbAAAAAAAAAAAAAICSgZmYAAAAAAAAAAAAAAAAADgVSUwAAAAAAAAAAAAAAAAAnIokJgAAAAAAAAAAAAAAAABORRITAAAAAAAAAAAAAAAAAKciiQkAAAAAAAAAAAAAAACAU7k5OwAAAOzJbDY7OwQAAAAAAAAAAAAAQAExExMAAAAAAAAAAAAAAAAApyKJCQAAAAAAAAAAAAAAAIBTkcQEAAAAAAAAAAAAAAAAwKlIYgIAAAAAAAAAAAAAAADgVCQxAQAAAAAAAAAAAAAAAHAqkphQ6rm43OjGGRkZMpvNTo4GQGllNpuVkZEhSXJ1dXVyNAAAAAAAAAAAAABQtpDEhFLPw8ND0o0EhJSUFCdHA6C0Sk5ONhIhs8YVAAAAAAAAAAAAAEDxIIkJpZ6vr6+xnZCQ4MRIAJRWZrNZly5dMv7v7+/vxGgAAAAAAAAAAAAAoOwhiQmlXrly5Yztixcv6uLFi8aSUABgi9ls1tWrV3Xy5EklJSVJkkwmU45xBQAAAAAAAAAAAADgeG7ODgAoKg8PD1WuXFnnz5+XJMXFxSkuLk6urq4ymUxOjg6lkdlsVmpqqiQpMTGRfnQLy8jIMJaQk24kMN12221ycSHHFwAAAAAAAAAAAACKE0lMuCVUrFhRqampunLlivEYszGhsDIzM41Zefz8/EhoKSOyEpj8/PycHQoAAAAAAAAAAAAAlDkkMeGWYDKZVKNGDQUGBury5ctKTk4miQmFlp6ebiTElS9fXm5uDJW3KldXV3l4eMjf31/lypUjYQ0AAAAAAAAAAAAAnIQ787ileHl5qVq1as4OA6VcQkKCFi9eLElq166d/P39nRwRAAAAAAAAAAAAAAC3NqacAAAAAAAAAAAAAAAAAOBUJDE5QFJSkn799VdNnjxZjz76qOrWrSuTySSTyaQ6deo45JibN2/W448/rqCgIGM2om7dumnOnDkFamfOnDnq2rWrqlWrJi8vLwUFBenxxx/Xli1bHBI3AAAAAAAAAAAAAAAAwHJyDtCrVy9FRUUV2/HCw8M1fvx4ZWZmGo+dO3dOq1at0qpVqzRr1iz99NNP8vLystrGtWvX1L9/fy1fvjzH48ePH9esWbM0Z84cvf322xo7dqzDzgMAAAAAAAAAAAAAAABlEzMxOYDZbDa2AwMD1bVrV5UrV84hx/ryyy81btw4ZWZmqn79+poxY4a2bt2qhQsXqnPnzpKkZcuW6amnnrLZzlNPPWUkMHXu3FkLFy7U1q1bNWPGDNWvX1+ZmZkKDw/XtGnTHHIeAAAAAAAAAAAAAAAAKLuYickBBg8erGeffVZt2rRRgwYNJEl16tRRUlKSXY9z6dIlvfbaa5Kk2rVr67ffflOlSpWM8p49e6pv375asmSJ5syZo+HDhyskJCRXO+vWrdPcuXMl3ZhF6ueff5arq6skqU2bNurdu7dat26t48eP67XXXtOAAQNUoUIFu54LAAAAAAAAAAAAAAAAyi5mYnKA4cOH67HHHjMSmBxl+vTpunLliiRpwoQJORKYJMnV1VVTp041EpImTZpksZ3JkydLktzc3HLUz1KpUiVNmDBBknT58mVNnz7drucBAAAAAAAAAAAAAACAso0kplJs4cKFkiR/f3/169fPYp2aNWsqNDRUkrR27VolJibmKE9MTNTatWslSaGhoapZs6bFdvr16yd/f39J0s8//2yP8AEAAAAAAAAAAAAAAABJJDGVWqmpqdq6daskqV27dvLw8LBat1OnTpKklJQURUdH5yjbtm2bUlNTc9SzxMPDQ/fcc4+xT1paWpHiBwAAAAAAAAAAAAAAALK4OTsAFM7BgweVkZEhSWrcuLHNutnL9+/fr86dOxv/37dvn8V61tpZtWqV0tPTdejQITVt2jTf8Z48edJm+YkTJ4ztI0eO5LtdwBGuXr1qLNV48OBB+fr6OjkilHX0SZQk9EeUJPRHlDT0SZQk9EeUNPRJlCTZP39MT093YiRAyZD9fXDmzJliO25iYqLxu+HUqVNKSEgotmPj1kW/gr3Rp2Bv9Ck4grP6VfZrR3v9bWUym81mu7QEm+rUqaPY2FgFBQXp2LFjRW5v5cqVeuihhyRJkyZN0r/+9S+rdaOjo9WmTRtJ0ujRo/X+++8bZaNHj9aECRMk3ZhhKTg42Go7kydP1iuvvGIcv1u3bvmO12Qy5bsuAAAAAAAAABSHrVu3Gp+dAmXVtm3b1LZtW2eHAQAAgFLMXn9bsZxcKZWYmGhslytXzmbd7N9sS0pKckg7AAAAAAAAAFDanDt3ztkhAAAAAAD+H8vJlVLXr183tj08PGzW9fT0NLavXbvmkHbykn25OEuOHj2q++67T5K0efNm1apVq0DtA/Z05swZ45tHW7duVfXq1Z0cEco6+iRKEvojShL6I0oa+iRKEvojShr6JEqSEydOqH379pKkxo0bOzkawPlatGihrVu3SpIqV64sN7fiuXXE7wY4Av0K9kafgr3Rp+AIzupX6enpOn/+vKQb15T2UGaTmOyxvNnMmTMVFhZW9GAKwcvLy9hOTU21WTclJcXY9vb2dkg7ealZs2a+69aqVatA9QFHql69Ov0RJQp9EiUJ/RElCf0RJQ19EiUJ/RElDX0SJUn2z0eBssrLy8vpyyryuwGOQL+CvdGnYG/0KThCcferOnXq2LU9lpMrpfz8/IztvJZ2u3r1qrF985Jx9moHAAAAAAAAAAAAAAAAKKwyOxPT/v37i9yGM6d2y545d/LkSZt1sy/ldvMybTe3ExwcXKh2AAAAAAAAAAAAAAAAgMIqs0lMpX2t80aNGsnV1VUZGRk6cOCAzbrZy5s0aZKjrGnTphbr2WrHzc1NDRs2LGjIAAAAAAAAAAAAAAAAgEUsJ1dKeXh4qG3btpKkLVu2KDU11Wrd9evXS5I8PT1zzbTUpk0beXh45KhnSWpqqn777TdjH3d39yLFDwAAAAAAAAAAAAAAAGQhiakUe/jhhyVJCQkJWrBggcU6J0+e1Jo1ayRJXbp0kZ+fX45yPz8/denSRZK0Zs0aq0vTLViwQAkJCZKkvn372iN8AAAAAAAAAAAAAAAAQBJJTCXWsWPHZDKZZDKZFBISYrHOsGHDVL58eUnS6NGjdfHixRzlGRkZeuGFF5SRkSFJeuWVVyy2869//UuSlJ6erhEjRhj1s1y4cEGvvfaaJCkgIEDDhg0r9HkBAAAAAAAAAAAAAAAAN3NzdgC3opiYGG3cuDHHY0lJSca/EREROcoefPBBVatWrcDHCQwM1IQJE/Tcc88pNjZWd999t9588021aNFCp0+f1kcffaTIyEhJ0mOPPWY1Ger+++/XoEGDNHfuXC1evFgPPPCAXn75ZdWoUUO7d+/Wu+++q+PHj0uSJkyYoAoVKhQ4VgAAAAAAAAAAAAAAAMAak9lsNjs7iFtNRESEhg4dmu/6kZGRuRKMjh07prp160qSOnXqpKioKKv7jx07VuPHj5e1l7J79+6aP3++vLy8rLZx7do19e/fX8uXL7dY7uLiojFjxig8PNzmuQAAAAAAAAAAAAAAAAAFxXJyt4Bx48Zp48aNGjx4sGrVqiUPDw9VqVJFDzzwgGbPnq1ly5bZTGCSJG9vby1btkyzZs3SAw88oCpVqsjDw0O1atXS4MGDtXHjRhKYAAAAAAAAAAAAAAAA4BDMxAQAAAAAAAAAAAAAAADAqZiJCQAAAAAAAAAAAAAAAIBTkcQEAAAAAAAAAAAAAAAAwKlIYgIAAAAAAAAAAAAAAADgVCQxAQAAAAAAAAAAAAAAAHAqkpgAAAAAAAAAAAAAAAAAOBVJTAAAAAAAAAAAAAAAAACciiQmAAAAAAAAAAAAAAAAAE5FEhMAAAAAAAAAAAAAAAAApyKJCU4XGxurUaNGqXHjxvL19VVgYKDatGmjSZMmKTk52dnhoYwwmUz5+gkJCXF2qCjl4uLitHTpUr399tt66KGHVKlSJaN/hYWFFbi9FStWqG/fvqpZs6Y8PT1Vs2ZN9e3bVytWrLB/8Ljl2KM/RkRE5HsMjYiIcOj5oPSLjo7WO++8o65duxrjWrly5dSoUSMNHTpUGzduLFB7jJEoCnv0R8ZI2EtCQoLmzp2rUaNGqVOnTmrQoIHKly8vDw8PValSRSEhIZo4caIuXryYr/Y2b96sxx9/XEFBQfLy8lK1atXUrVs3zZkzx8FngluBPfpjVFRUvsfH8PDw4js53HJee+21HP0pKioqz324hgTsLykpSb/++qsmT56sRx99VHXr1jXel3Xq1HHIMbneKTuSk5M1ceJEtWnTRoGBgfL19VXjxo01atQoxcbGFrn9Y8eO5fu6pTCf76L4FNf9SK4lyg5H9ik+Uypb7H3vMD/mzJmjrl27qlq1avLy8lJQUJAef/xxbdmyxSHHKxAz4ESLFy82+/v7myVZ/GnUqJH50KFDzg4TZYC1PnjzT6dOnZwdKko5W/1ryJAh+W4nIyPD/PTTT9tsb9iwYeaMjAzHnQxKPXv0x5kzZ+Z7DJ05c6ZDzwelW8eOHfPVj5588klzSkqKzbYYI1FU9uqPjJGwl9WrV+erH1WqVMm8cuVKm22NHTvW7OLiYrWNHj16mK9du1ZMZ4bSyB79MTIyMt/j49ixY4v3BHHL2Llzp9nNzS1Hf4qMjLRan2tIwHFCQkKsvq+CgoLsfjyud8qOQ4cOmRs2bGj1tfb39zcvWbKkSMc4evRovq9bCvL5LopXcdyP5FqibHF0n+IzpbKlOH+3JCcnm7t37271eC4uLubw8HC7HrOg3AQ4yc6dOzVw4EBdu3ZN5cqV0+uvv67OnTvr2rVrmjt3rr766isdPHhQPXr0UHR0tPz8/JwdMsqA559/Xi+88ILVcl9f32KMBre62rVrq3Hjxlq1alWB933zzTc1Y8YMSVKrVq306quvqn79+jp8+LAmTpyonTt3avr06apcubLee+89e4eOW1BR+mOWX375RTVq1LBaXrNmzUK3jVvf6dOnJUk1atTQgAED1LFjR9WuXVsZGRnasmWL/vOf/+jUqVP69ttvlZaWptmzZ1ttizESRWXP/piFMRJFVatWLXXu3FmtW7dWrVq1VL16dWVmZurkyZP66aeftGDBAl24cEG9e/fW1q1bdeedd+Zq48svv9S4ceMkSfXr19cbb7yhFi1a6PTp0/r4448VGRmpZcuW6amnnspXv0bZZY/+mOXrr79WmzZtrJZXqVLFEaeAW1xmZqaGDx+u9PR0ValSRXFxcXnuwzUk4Dhms9nYDgwMVHBwsDZv3qykpCS7H4vrnbIjMTFRPXr00KFDhyRJzzzzjAYNGiRvb29FRkbq/fffV0JCggYOHKhNmzapZcuWRT7mv//9b/Xp08dqeYUKFYp8DNhfcd2P5Fqi7Cjue9x8plS22ONejS1PPfWUli9fLknq3Lmz/vGPf6hGjRravXu33nvvPR0+fFjh4eGqXr26hg8f7pAY8uTUFCqUaVnfbnZzczNv3rw5V/nEiRP51h2KDX0NxeXtt982L1myxHz27Fmz2Zzzmzz5zab+66+/jG+TBgcHm5OTk3OUX7161RwcHGyMscxoB2vs0R+zfyPk6NGjjgsWt7wePXqYf/jhB3N6errF8vPnz5sbNWpk9Lf169dbrMcYCXuwV39kjIS9WOuL2f38889Gf+vbt2+u8osXL5rLly9vlmSuXbu2+fz587mO0atXr3zNVoKyzR79MftMTPQ1OMJ///tfsyRz48aNza+//nqe/Y1rSMCxvvzyS/Ps2bNzvHeCgoLsPhMT1ztly5gxY4zXcuLEibnKN23aZIztRVlhIfvnZcx2UjoVx/1IriXKluLoU3ymVLbY415Nfqxdu9Zot1evXrn+vj9//ry5du3aZknmgIAA86VLl+x27IJwsVMuFFAgW7du1YYNGyRJTz/9tNq1a5erzqhRo9SkSRNJ0scff6y0tLRijREAHGHcuHHq2bOnqlatWug2PvroI6Wnp0uSPv30U3l7e+co9/Hx0aeffipJSk9P13//+9/CB4xbmj36I2AvS5cu1aOPPipXV1eL5ZUqVdJ//vMf4/8//fSTxXqMkbAHe/VHwF6s9cXsHn74Yd1+++2SZPy9nd306dN15coVSdKECRNUqVKlXMeYOnWqcaxJkyYVNWzcouzRHwFHOn78uMaMGSNJ+uKLL+Th4ZHnPlxDAo41fPhwPfbYY2rQoIFDj8P1TtmRlpamTz75RJLUpEkTjRo1Kled9u3b6+mnn5YkrV+/Xtu2bSvWGFEyFNf9SK4lyg7uccMRiutezeTJkyVJbm5uOa6JslSqVEkTJkyQJF2+fFnTp093aDzWkMQEp1i4cKGxPXToUIt1XFxc9OSTT0q68SaJjIwsjtAAoEQzm81atGiRJKlx48a65557LNa75557jJsGixYtyjFtNwCUVp07dza2Dx8+nKucMRLFKa/+CDhD1hT1169fz1WW9Xe4v7+/+vXrZ3H/mjVrKjQ0VJK0du1aJSYmOiZQlAm2+iPgSCNGjFBSUpKGDBmiTp065Vmfa0jg1sH1TtkRGRlpJKwNGTJELi6Wb3eGhYUZ2z///HNxhIYSpjjuR3ItUbZwjxulVWJiotauXStJCg0NtboMYb9+/eTv7y/Jeb87SWKCU2zcuFGS5Ovrq9atW1utl/2Dhk2bNjk8LgAo6Y4eParTp09LUp4fxmaVnzp1SseOHXN0aADgcCkpKca2pVkgGCNRnPLqj0Bx++uvv7Rr1y5JNz44zy41NVVbt26VJLVr187mrCRZ42NKSoqio6MdEyxuebb6I+BIP/74o5YuXarAwEDjW8Z54RoSuDVwvVO2ZN1jkmyP3cHBwfLx8ZHEPaayqjjuR3ItUbZwjxul1bZt25SamirJ9ljl4eFhJGNu27bNKTOJkcQEp9i/f78kqUGDBnJzc7NaL/sHXVn7AI40b948NW3aVD4+PvLz81PDhg01ZMgQsqRRYuzbt8/YzutmAGMoitvQoUNVo0YNeXh4qFKlSrrnnnv01ltv6dSpU84ODbeI9evXG9tZUzJnxxiJ4pRXf7wZYyQcITk5WYcOHdKHH36oTp06GcsXvPzyyznqHTx4UBkZGZIYH+E4+e2PN3vzzTcVFBQkT09PVahQQa1atdLIkSN18ODBYogat5LLly/rH//4hyTLy0hZwzUkcGvgeqdsye/Y7ebmZixjaI/X+tNPP1WDBg3k5eWl8uXLq1mzZnruuee0Y8eOIrcNxyiO+5FcS5QtzrjHzWdKsIfCjFXp6ek6dOiQQ+OyhCQmFLvr16/rwoULkmR1mrIsFSpUkK+vryTpxIkTDo8N2Ldvn/bv369r164pKSlJMTEx+vbbb3X//ferb9++xhS1gLOcPHnS2M5rDK1Vq5axzRiK4hAVFaUzZ84oLS1NFy9e1O+//653331XDRo00Jdffuns8FDKZWZm6oMPPjD+/+ijj+aqwxiJ4pKf/ngzxkjYS0REhEwmk0wmk3x9fdWoUSONGjVK586dkySNHj1agwcPzrEP4yMcpTD98WabN2/W8ePHlZqaqsuXL2vXrl366KOP1KRJE4WHh7PMBvLt1Vdf1dmzZ3Xvvffq6aefzvd+jJHArYH3ctmS9Xr7+voqICDAZt2s1/v8+fM5ZtQtjB07dujw4cNKSUlRQkKC9u3bpy+//FKtW7fWc889V+T2YV/FdT+S8afscNY9bj5Tgj2UprHKenog4CDZ15guV65cnvV9fX119epVJSUlOTIslHE+Pj7q3bu3unTposaNG6tcuXI6f/681q9fry+++EIXL17UwoUL1adPH61evVru7u7ODhllVEHG0KwLZEmMoXCoevXqqV+/fmrXrp1xcXvkyBHNnz9fP/30k65fv67nnntOJpNJw4cPd3K0KK3++9//GksD9OvXz+J0zYyRKC756Y9ZGCNRXFq2bKlp06apTZs2ucoYH1HcbPXHLNWrV1e/fv3UoUMH1atXT25ubjp+/LiWLl2qb7/9VmlpaRo3bpxSU1P13nvvFWP0KI02bNig6dOny83NTV988YVMJlO+92WMBG4NvJfLlqzXO7/3mLIkJSXJ09OzwMcLCAhQ3759FRISooYNG8rLy0tnzpzRqlWrNGPGDCUlJenLL79UYmKiZs2aVeD24RjFdT+S8afsKO573HymBHsqTWMVSUwodtevXze2ba1LnSXrgvLatWsOiwk4deqUxW9sPPDAA/r73/+uhx56SDt37tT69ev1+eef66WXXir+IAEVbAzN/gc5YygcpW/fvhoyZEiumwRt2rTRwIEDtXTpUvXr109paWkaOXKkevfurWrVqjkpWpRW69ev1+jRoyVJVapU0eeff26xHmMkikN++6PEGAnHePjhhxUcHCzpxvh1+PBh/fjjj/r555/12GOP6aOPPlLPnj1z7MP4CEcpTH+UboyDsbGxub4gdNddd+nhhx/W8OHD1bVrV125ckUffPCBBg4cqDvvvLNYzgmlT2pqqoYPHy6z2ayRI0eqefPmBdqfMRK4NfBeLluyXu+C3GOSCvd616hRQ6dOnZKPj0+Ox1u1aqXu3btrxIgRCg0N1fHjxzV79mwNHDhQvXv3LvBxYH/FdT+S8afsKM573HymBHsrTWMVy8mh2Hl5eRnbqampedbPmn7T29vbYTEBtqacrVq1qn766Sfjw9VPP/20mKICcivIGJp9+mLGUDhK+fLlbX7LuWfPnnr77bclScnJyZoxY0ZxhYZbxN69e9W3b1+lp6fLy8tL8+bNU5UqVSzWZYyEoxWkP0qMkXCMgIAANW/eXM2bN1ebNm00aNAgLViwQN9++62OHDmiPn36KCIiIsc+jI9wlML0R+nGtzptzXDctm1bTZkyRZJkNpuNbcCS9957TwcOHFDt2rU1duzYAu/PGAnckLU8aFF+LI35xYX3csnkqH6V9XoX5B6TVLjX28PDI1cCU3YNGzbU999/b/yf+wclR3Hdj2T8KTuK8x43nynB3krTWEUSE4qdn5+fsZ2f6ceuXr0qKX/T8gGOUq9ePT3wwAOSpJiYGJ0+fdrJEaGsKsgYmjV+SoyhcK7hw4cbf3CtX7/eydGgNDl69Ki6du2q+Ph4ubq6au7cubrvvvus1meMhCMVtD/mF2Mk7OWJJ57QgAEDlJmZqRdffFGXLl0yyhgfUdxs9cf8GjRokPz9/SUxPsK6AwcO6P3335d046Zx9mUP8osxErg18F4uW7Je74LcY5Ic93p37NhRTZs2lSRt3LhRmZmZDjkOCqa47kcy/pQdJe0eN58poSBK01jFcnIodl5eXqpYsaIuXryokydP2qwbHx9vvEmy1voEnKVp06Zavny5pBvLz9WoUcPJEaEsqlmzprGd1xh64sQJY5sxFM5UpUoVVaxYURcuXNCpU6ecHQ5KidOnTys0NFSnT5+WyWTS119/rT59+tjchzESjlKY/phfjJGwpz59+ujHH3/U1atXtXLlSg0ePFgS4yOcw1p/zC83Nzc1atRI0dHRjI+w6r///a9SU1NVr149JScna+7cubnq7Nmzx9het26dzp49K0nq1auXfH19GSOB/7d///4it1G9enU7RFI4vJdLJkf1q5o1a+r333/X1atXdfnyZZsrLWS93pUrV86xPI69NW3aVPv27dP169d18eJFVa5c2WHHQv4U1/1Ixp+yo6Td4+YzJRTEzWNV1tLwljh7rCKJCU7RtGlTbdiwQTExMUpPT5ebm+WueODAAWO7SZMmxRUeYJGtaRuB4pL1jR4p5xhpCWMoShLGUBTEhQsX9MADD+jIkSOSbnyr/sknn8xzP8ZIOEJh+2NBMEbCXrLfKImNjTW2GzVqJFdXV2VkZDA+othY648FwfiIvGQtc3DkyBE99thjedYfP368sX306FH5+vpyDQn8v8aNGzs7hCLheqdkclS/atq0qebPny/pxut5zz33WKyXnp6uw4cPS3L8a811S8lUHPcjuZYoW0raPW7GHuRXYcYqNzc3NWzY0KFxWcJycnCKDh06SLoxFdn27dut1ss+9d29997r8LgAW/bt22dsMwsTnKVu3bpG/8tretBff/1VknTbbbepTp06jg4NsOr8+fO6cOGCJMZP5O3KlSvq1q2b8Xv3gw8+0IgRI/K1L2Mk7K0o/TG/GCNhT9m/eZl9um8PDw+1bdtWkrRlyxalpqZabSNr/PT09LT5rTwgL9b6Y36lp6fr4MGDkhgf4VhcQwK3Bq53ypase0yS7bE7OjramAnF0feYsv5u9PT0VMWKFR16LORfcdyP5FqibClJ97j5TAkF0aZNG3l4eEiyPValpqbqt99+M/Zxd3cvlviyI4kJTvHwww8b2zNnzrRYJzMzU99++60kKSAgQJ07dy6O0ACLjh49qtWrV0uS6tevr9tuu83JEaGsMplMxvI1Bw4cMC4kbvbbb78ZmdJ9+vQhGx9ONW3aNJnNZklSp06dnBwNSrLk5GT16NFDO3bskCS9+eabeu211/K9P2Mk7Kmo/TG/GCNhT/PmzTO2W7RokaMs6+/whIQELViwwOL+J0+e1Jo1ayRJXbp0kZ+fn2MCRZlgqz/mxw8//KArV65IYnyEdRERETKbzTZ/xo4da9SPjIw0Hs+6ccg1JHDr4Hqn7AgJCVH58uUlSd98843xN9XNIiIijO2+ffs6LJ5NmzZp7969km4kOLi4cPu1pCiO+5FcS5QtJekeN58poSD8/PzUpUsXSdKaNWusLom4YMECJSQkSHLs706bzICTdOzY0SzJ7ObmZt68eXOu8okTJ5olmSWZx44dW/wBosxYvHixOS0tzWr52bNnza1atTL643/+859ijA63uqNHjxp9a8iQIfna56+//jK7urqaJZmDg4PNycnJOcqTk5PNwcHBxhh78OBBB0SOW1FB++PRo0fNO3bssFlnyZIlZg8PD7Mks7e3t/nkyZN2iha3mpSUFHPXrl2NPviPf/yjUO0wRsIe7NEfGSNhTzNnzjRfu3bNZp0PP/zQ6LN169Y1p6en5yi/ePGiuXz58mZJ5qCgIPOFCxdylKenp5t79epltBEZGWnv08Atoqj98dKlS3n2r99//90cEBBglmQ2mUzm6Ohoe4SOMmrs2LF5jm1cQwLFLygoyLguyY/sn1l06tTJYh2ud8qWMWPGGK/lxIkTc5Vv3rzZ7ObmZrPPmM1mow1rffHnn382Z2ZmWt3/0KFD5tq1axvtzJ8/v6CnAgcr6v3IyMjIPD8z5VqibHF0n+IzJRTm3uHMmTPzzK1Yu3atUad37965Pjs6f/688TstICDAfOnSpSKeSeFYXqQRKAYff/yx7r33Xl27dk1du3bVG2+8oc6dO+vatWuaO3eupk2bJunGWtajRo1ycrS4lf39739XWlqaHnnkEbVr10516tSRt7e3Lly4oKioKH355ZfGdIwdOnSw+xIiKFs2btyomJgY4/9ZfUuSYmJicnw7SJLCwsJytdGoUSO98sor+uCDDxQdHa17771Xr732murXr6/Dhw9rwoQJ2rlzpyTplVdeccp6tSgditofjx07ps6dO6tdu3bq1auX7rzzTlWpUkWSdOTIEf3000/66aefjG+DTJ48mZnsYNVjjz2mVatWSZLuv/9+Pf3009qzZ4/V+h4eHmrUqFGuxxkjYQ/26I+MkbCn8PBwjRo1So888og6dOig+vXrq1y5ckpMTNTu3bs1a9Ysbdq0SdKN/jht2jS5urrmaCMwMFATJkzQc889p9jYWN19991688031aJFC50+fVofffSRIiMjJd14D4SEhBT3aaKUKGp/vHLlijp37qw77rhDDz/8sFq3bq3q1avL1dVVx48f19KlS/Xdd98ZywD961//UuvWrZ1yrig7uIYEHCsmJkYbN27M8VhSUpLx782fPzz44IOqVq1agY/D9U7Z8sorr+iHH37QwYMH9eqrryomJkaDBg2St7e3IiMj9d577yk9PV3e3t766KOPCn2cvn37qkGDBurXr5/atm2rmjVrytPTU2fOnNEvv/yiGTNmGP350UcfVb9+/ex0hrCX4rgfybVE2eLoPsVnSmWPPe4d5sf999+vQYMGae7cuVq8eLEeeOABvfzyy6pRo4Z2796td999V8ePH5ckTZgwQRUqVCjUcYrMKalTwP9bvHix2d/f38j4u/mnUaNG5kOHDjk7TNzisr71k9fPI488Yo6Pj3d2uCjlhgwZkq/+lvVjTUZGhvmpp56yue/TTz9tzsjIKMazQ2lT1P6Y/Rsjtn58fHzMX375pRPOEKVJQfqi8vi2LmMkisoe/ZExEvaU379ZatasaV61apXNtt5++22zyWSy2kb37t3znGUHZVtR+2P2b5Ta+nF1dTWHh4fbnPkAyI/8zMRkNnMNCThS9pkB8vNj6b2an5mYsnC9U3YcOnTI3LBhQ6uvtb+/v3nJkiU228jrc4b89tvnn3/efP36dQecJeyhKPcj8zMTk9nMtURZ48g+xWdKZY897h3mZyYms/nGzHDdu3e32raLi4vTV8liJiY4Va9evfTnn3/q448/1rJly3Ty5El5eHioQYMGGjBggF588UX5+Pg4O0zc4r755hutX79eW7Zs0ZEjR3ThwgUlJCSoXLlyqlWrltq3b68hQ4aoXbt2zg4VMLi4uGjGjBl65JFHNG3aNG3btk0XLlxQpUqV1KZNGz377LN66KGHnB0mbnGtW7fW999/ry1btig6OlpnzpzRhQsXlJ6ergoVKqhZs2bq0qWLhg0bZnxTBCgOjJEoCRgjYU+//PKLli1bpk2bNikmJkbnzp3TxYsX5e3trSpVqqhly5bq2bOnHn300Tz/hh43bpy6deumzz77TBs2bNC5c+cUEBCgO++8U0OHDtVjjz1WTGeF0qqo/bFGjRqaN2+etmzZoq1bt+rUqVO6cOGCrl+/rvLly+v2229XSEiIhg0bpjp16hT/CaLM4hoSuHVwvVN2NGjQQDt37tRnn32mefPmKSYmRqmpqapVq5a6d++uf/zjHwoKCirSMRYvXqwtW7bo999/V2xsrC5cuKCrV6/K399f9erVU8eOHfXUU0+pefPmdjorOEJx3I/kWqJscWSf4jMlOJK3t7eWLVum2bNnKyIiQn/88YcuX76sqlWrqmPHjnrxxRedfk/cZDb//zxjAAAAAAAAAAAAAAAAAOAELs4OAAAAAAAAAAAAAAAAAEDZRhITAAAAAAAAAAAAAAAAAKciiQkAAAAAAAAAAAAAAACAU5HEBAAAAAAAAAAAAAAAAMCpSGICAAAAAAAAAAAAAAAA4FQkMQEAAAAAAAAAAAAAAABwKpKYAAAAAAAAAAAAAAAAADgVSUwAAAAAAAAAAAAAAAAAnIokJgAAAAAAAAAAAAAAAABORRITAAAAAAAAAAAAAAAAAKciiQkAAAAAAAAAAAAAAACAU5HEBAAAAAAAAAAAAAAAAMCpSGICAAAAAAAAAAAAAAAA4FQkMQEAAAAAAAAAAAAAAABwKpKYAAAAAAAAAAAAAAAAADgVSUwAAAAAAAAAAAAAAAAAnIokJgAAAAAAAAAAAAAAAABORRITAAAAAEVERMhkMslkMunYsWPODqdY1KlTxzjnrJ86deo4OyyLwsPDc8VqMpkUFRXl7NAAAAAAAAAAALALkpgAAACAUuzYsWMWk1sK+gMAAAAAAAAAAOBMJDEBAAAAKNP69Omj3bt3a/fu3Vq1apWzw7HohRdeMGL8+uuvnR0OAAAAAAAAAAB25+bsAAAAAAAU3m233abdu3dbLW/RooUkKTg4WDNnzrRar3nz5goLC7N3eKVCQECAmjdv7uwwbKpSpYqqVKkiSbpw4YKTowEAAAAAAAAAwP5IYgIAAABKMXd393wl4Pj6+pb4RB0AAAAAAAAAAFB2sZwcAAAAAAAAAAAAAAAAAKciiQkAAACAIiIiZDKZZDKZdOzYsVzlISEhMplMCgkJkSTFxMToueeeU7169eTt7a06dero6aefVmxsbI799uzZo6FDh6pevXry8vJSrVq19PzzzysuLi5fcS1cuFADBgxQ7dq15eXlpYCAAAUHB2vcuHGKj48v6mnnW506dWQymYwl9/766y8988wzqlOnjjw9PVW1alX17dtXv/32m812rl+/rk8++UQhISGqXLmy3N3dFRgYqNtvv10PPfSQPvzwQ4vPPwAAAAAAAAAAtzqWkwMAAABQIGvWrFG/fv2UmJhoPBYbG6uvv/5aS5cu1fr169W4cWPNmTNHYWFhSk1NNeqdPHlSX3zxhVasWKHNmzerRo0aFo8RHx+v/v37a926dTkeT0lJ0fbt27V9+3ZNnTpVixYt0j333OOYE7Xi559/1uOPP67k5GTjsbi4OC1cuFBLlizRrFmzNHDgwFz7nTlzRqGhodq3b1+Ox+Pj4xUfH6+DBw9q5cqVOn36tCZPnuzw8wAAAAAAAAAAoCRhJiYAAAAA+Xb69Gk9+uijCggI0Keffqrff/9dGzZs0MsvvyyTyaS4uDgNGzZM27Zt05NPPqn69etr+vTp2rp1qyIjI/XEE09IupH09M9//tPiMVJSUhQaGqp169bJ1dVVTzzxhObMmaPffvtNGzZs0LvvvquKFSsqLi5O3bt3zzX7kyPt3r1bgwcPVtWqVTVlyhT99ttv2rJli8LDw+Xl5aWMjAwNHz5c58+fz7Xv3//+dyOB6fHHH9eCBQv022+/adu2bVq8eLHefvtt3XnnncV2LgAAAAAAAAAAlCTMxAQAAAAg3w4dOqSGDRtq06ZNqly5svF4hw4d5ObmpsmTJ2vTpk3q0aOH2rZtq9WrV8vHx8eoFxISouvXr2vevHmaP3++zp8/n6MdSXrnnXe0Y8cOBQQEaM2aNWrdunWO8g4dOuhvf/ub2rVrpzNnzuiNN97QrFmzHHvi/2/Hjh1q3bq11q1bJ39/f+Pxe+65Rw0aNNDjjz+uhIQEff/99xo5cqRRfv36dS1evFiSNGrUKIszLfXq1Uvjxo3TpUuXHH8iAAAAAAAAAACUMMzEBAAAAKBAPvnkk1yJR5L0wgsvGNsXLlzQ9OnTcyQwZXn++eclSenp6dqyZUuOsqSkJH322WeSpPHjx+dKYMoSFBSkMWPGSJLmzZunq1evFu5kCuHrr7/OkcCUZfDgwcbyeBs2bMhRdunSJaWlpUmS7rvvPpvtBwYG2ilSAAAAAAAAAABKD5KYAAAAAORbQECAunXrZrGsbt268vPzkyTdcccdatKkicV62ZdMO3LkSI6y9evX68qVK5Kk/v3724wlKxkoLS1N27dvz98JFFGLFi10xx13WCwzmUxq1aqVpNznVbFiRXl4eEiSvvvuO6Wnpzs2UAAAAAAAAAAAShmSmAAAAADkW8OGDWUymayWBwQESJIaNWqUZx1JSkxMzFEWHR1tbFevXl0mk8nqT/PmzY26Z8+eLeCZFE7jxo1tlmfNonTzeXl6emrgwIGSpJ9++kkNGjTQq6++quXLl+vy5csOiRUAAAAAAAAAgNKEJCYAAAAA+WZpebjsXFxc8qyXVUeSMjIycpTFxcUVKq7k5ORC7VdQ+T3/m89LkqZMmaJevXpJkmJjYzVp0iT16NFDFStWVJs2bTRp0iRjFioAAAAAAAAAAMoaN2cHAAAAAABZsif/7NixQ+7u7vnar2bNmo4KyW78/f21ePFibd26VT/++KOioqK0a9cuZWRkKDo6WtHR0Zo8ebIWLlyodu3aOTtcAAAAAAAAAACKFUlMAAAAAEqMihUrGtuVK1cuFclJBdW2bVu1bdtW0o1l56KiohQREaEFCxYoLi5OjzzyiA4fPixvb28nRwoAAAAAAAAAQPFhOTkAAAAAJUarVq2M7U2bNjkxkuLh5+enXr16af78+XrppZckSWfOnNHGjRudHBkAAAAAAAAAAMWLJCYAAAAAJUZoaKh8fHwkSZ988onMZrOTIyo+Xbp0MbYvXLjgxEgAAAAAAAAAACh+JDEBAAAAKDECAgL04osvSpI2b96skSNHKjMz02r9c+fOafr06cUVXqEdOXJE69evt1ln1apVxnbdunUdHRIAAAAAAAAAACWKm7MDAAAAAIDs3nnnHa1fv16///67Pv74Y0VFRemZZ55Ry5Yt5evrq/j4eO3du1dr1qzRihUr1KJFCw0bNszZYdt0/Phxde7cWU2bNlXfvn0VHBys2267TZJ04sQJ/fDDD/rxxx8lSS1bttTdd9/tzHABAAAAAAAAACh2JDEBAAAAKFE8PT21evVqhYWFacGCBfrjjz+M2Zks8ff3L8boimbfvn3at2+f1fLGjRtrwYIFMplMxRgVAAAAAAAAAADORxITAAAAgBLHz89P8+fP18aNG/XNN99ow4YNOn36tK5duyZ/f3/Vr19fbdu2VY8ePdS1a1dnh5unjh07KioqSr/88ot+++03nThxQufOndP169cVGBioO++8U/369VNYWJg8PT2dHS4AAAAAAAAAAMXOZDabzc4OAgAAAACKW506dRQbG6shQ4YoIiLC2eHkW1RUlDp37ixJioyMVEhIiHMDAgAAAAAAAADADpiJCQAAAECZdvnyZe3Zs0eS5OHhoUaNGjk5otzi4uIUFxcnSTp69KiTowEAAAAAAAAAwP5IYgIAAABQpi1atEiLFi2SJAUFBenYsWPODciCqVOnaty4cc4OAwAAAAAAAAAAh3FxdgAAAAAAAAAAAAAAAAAAyjaT2Ww2OzsIAAAAAAAAAAAAAAAAAGUXMzEBAAAAAAAAAAAAAAAAcCqSmAAAAAAAAAAAAAAAAAA4FUlMAAAAAAAAAAAAAAAAAJyKJCYAAAAAAAAAAAAAAAAATkUSEwAAAAAAAAAAAAAAAACnIokJAAAAAAAAAAAAAAAAgFORxAQAAAAAAAAAAAAAAADAqUhiAgAAAAAAAAAAAAAAAOBUJDEBAAAAAAAAAAAAAAAAcCqSmAAAAAAAAAAAAAAAAAA4FUlMAAAAAAAAAAAAAAAAAJyKJCYAAAAAAAAAAAAAAAAATkUSEwAAAAAAAAAAAAAAAACnIokJAAAAAAAAAAAAAAAAgFORxAQAAAAAAAAAAAAAAADAqUhiAgAAAAAAAAAAAAAAAOBUJDEBAAAAAAAAAAAAAAAAcCqSmAAAAAAAAAAAAAAAAAA4FUlMAAAAAAAAAAAAAAAAAJyKJCYAAAAAAAAAAAAAAAAATvV/p833QtN9ESoAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p6.plot()\n", - "p7.plot()\n", - "p8.plot()\n", - "p9.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Attributes" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Pulse implements these attributes:\n", - "- `start`\n", - "- `duration`\n", - "- `finish` (read only)\n", - "- `amplitude`\n", - "- `frequency`\n", - "- `relative_phase`\n", - "- `phase` (read only) returns the total phase of the pulse (global, based on its start + relative)\n", - "- `shape` a `PulseShape` object\n", - "- `channel`\n", - "- `type`\n", - "- `qubit`\n", - "- `serial` a str representation of the object\n", - "- `envelope_waveform_i` a Waveform object\n", - "- `envelope_waveform_q` a Waveform object\n", - "- `envelope_waveforms` a tuple of (Waveform, Waveform)\n", - "- `modulated_waveform_i` a Waveform object\n", - "- `modulated_waveform_q` a Waveform object\n", - "- `modulated_waveforms` a tuple of (Waveform, Waveform)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Methods" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Pulse implements the following methods:\n", - "- `copy()` returns a deep copy of the object. The later changes to the original do not impact the replica.\n", - "- `shallow_copy()` returns a shallow copy of the object. The replica references to the same `start`, `duration` and `shape` objects.\n", - "The difference in the behaviour of these two methods can be appreciated in the below example:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "p1 = Pulse(0, 40, 0.9, 100e6, 0, Drag(5,1), 0, PulseType.DRIVE)\n", - "p2 = p1.shallow_copy()\n", - "p3 = p1.copy()\n", - "assert p1 == p2\n", - "assert p1 == p3" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Operators" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Pulse now supports a small set of operators (`==`, `!=`, `+`, `*`).\n", - "Pulse is hashable, but not unmutable (its hash depends on the current value of its parameters), so one can use the following operators to compare pulses:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "p0 = Pulse(0, 40, 1, 100e6, 0, Rectangular(), 0, PulseType.DRIVE, 0)\n", - "p1 = Pulse(100, 40, 1, 100e6, 0, Rectangular(), 0, PulseType.DRIVE, 0)\n", - "p2 = Pulse(0, 40, 1, 100e6, 0, Rectangular(), 0, PulseType.DRIVE, 0)\n", - "\n", - "assert p0 != p1\n", - "assert p0 == p2\n", - "\n", - "# If we change p1 start to 0 it become the same as p0\n", - "p1.start = 0\n", - "assert p0 == p1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Since it is hashable, it can also be used as keys of a dictionary:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "rp = Pulse(0, 40, 0.9, 100e6, 0, Rectangular(), 0, PulseType.DRIVE)\n", - "dp = Pulse(0, 40, 0.9, 100e6, 0, Drag(5,1), 0, PulseType.DRIVE)\n", - "hash(rp)\n", - "my_dict = {rp: 1, dp: 2}\n", - "assert list(my_dict.keys())[0] == rp\n", - "assert list(my_dict.keys())[1] == dp" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Adding two Pulses returns a PulseSequence. Multiplying a Pulse by an integer n returns a PulseSequence with n deep copies of the original pulse." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pA = Pulse(0, 40, 1, 100e6, 0, Rectangular(), 'A', PulseType.DRIVE, 0)\n", - "pB = Pulse(0, 40, 1, 100e6, 0, Rectangular(), 'B', PulseType.DRIVE, 0)\n", - "ps = pA + pB\n", - "assert type(ps) == PulseSequence\n", - "ps.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As we have already seen, Pulse also implements a `plot()` method that represents the pulse waveforms:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "drag_pulse = Pulse(0, 40, 0.9, 50e6, 0, Drag(5,2), 0, PulseType.DRIVE, 200)\n", - "drag_pulse.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Pulse `serial` is a string representation of the pulse. It can be used as is to generate a copy of the pulse: " - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "p1 = Pulse(0, 40, 0.9, 50_000_000, 0, Gaussian(5), 0, PulseType.DRIVE)\n", - "assert p1.serial == 'Pulse(0, 40, 0.9, 50_000_000, 0, Gaussian(5), 0, PulseType.DRIVE, 0)'\n", - "p2 = eval(p1.serial)\n", - "assert p1 == p2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### ReadoutPulse, DrivePulse & FluxPulse Aliases" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "These objects are subclasses of the Pulse object. They have a different representation, and in their instantiation one does not require to specify the type." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "rop = ReadoutPulse(start = 0,\n", - " duration = 50, \n", - " amplitude = 0.9, \n", - " frequency = 20_000_000, \n", - " relative_phase = 0.0, \n", - " shape = Rectangular(), \n", - " channel = 0, \n", - " qubit = 0)\n", - "assert repr(rop) == 'ReadoutPulse(0, 50, 0.9, 20_000_000, 0, Rectangular(), 0, 0)'\n", - "assert isinstance(rop, Pulse)\n", - "\n", - "dp = DrivePulse(start = 0,\n", - " duration = 2000, \n", - " amplitude = 0.9, \n", - " frequency = 200_000_000, \n", - " relative_phase = 0.0, \n", - " shape = Gaussian(5), \n", - " channel = 0, \n", - " qubit = 0)\n", - "assert repr(dp) == 'DrivePulse(0, 2000, 0.9, 200_000_000, 0, Gaussian(5), 0, 0)'\n", - "assert isinstance(rop, Pulse)\n", - "\n", - "fp = FluxPulse(start = 0,\n", - " duration = 300, \n", - " amplitude = 0.9, \n", - " shape = Rectangular(), \n", - " channel = 0, \n", - " qubit = 0)\n", - "\n", - "assert repr(fp) == 'FluxPulse(0, 300, 0.9, Rectangular(), 0, 0)'\n", - "assert isinstance(rop, Pulse)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### PulseShape" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Overview" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`PulseShape` objects are used to represent the different shapes a pulse can take. These objects are responsible for generating the waveforms based on the parameters of the pulse and the sampling rate set in the `PulseShape` class attribute `SAMPLING_RATE`.\n", - "All `PulseShape` objects support the generation of waveforms with an arbitrary sampling rate. This will be useful for whenever we use instruments that use a sampling rate different than 1e9 Hz.\n", - "The types of pulse shapes currently supported are `Rectangular()`, `Gaussian`, `Drag`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Sampling Rate" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "p14 = Pulse(0, 40, 0.9, 100e6, 0, Drag(5,1), 0, PulseType.DRIVE)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACTEAAAPkCAYAAAB7yuiYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd3gU5drH8d+mE0ISaugdpEvvSC8ieAQBQaQLiILlKCoWQLEeUI8FkSJSBFQ84qGpSFWQqoCUoPQOIUAapGfeP/Jmzi7ZTTZlswl8P9eVK7M7zzxzT9mdmZ17nsdiGIYhAAAAAAAAAAAAAAAAAHATD3cHAAAAAAAAAAAAAAAAAODORhITAAAAAAAAAAAAAAAAALciiQkAAAAAAAAAAAAAAACAW5HEBAAAAAAAAAAAAAAAAMCtSGICAAAAAAAAAAAAAAAA4FYkMQEAAAAAAAAAAAAAAABwK5KYAAAAAAAAAAAAAAAAALgVSUwAAAAAAAAAAAAAAAAA3IokJgAAAAAAAAAAAAAAAABuRRITAAAAAAAAAAAAAAAAALciiQkAAAAAAAAAAAAAAACAW5HEBAAAAAAAAAAAAAAAAMCtSGICAAAAAAAAAAAAAAAA4FYkMQEAAAAAAAAAAAAAAABwK5KYAAAAAAAAAAAAAAAAALgVSUwAAAAAAAAAAAAAAAAA3IokJgAAAAAAAAAAAAAAAABuRRITAAAAAAAAAAAAAAAAALciiQkAAAAAAAAAAAAAAACAW5HEBAAAgDy1efNmWSwWWSwWdejQwd3h5EhKSoqaNGkii8Wihg0bKiUlxd0hAQAAFCi///67PD09ZbFY9P7777s7nHwnPj5elStXlsViUdeuXd0dDnLJggULzGui4cOHuzscALeRVq1ayWKxqE6dOkpMTHR3OAAAAFlGEhMAAMBtpkOHDuYP4vb+ihQposqVK+sf//iHPv74Y0VGRro75AJrzpw5+uOPPyRJ7777rjw8Mj+9Dg8P14wZM9S6dWuVKVNGfn5+qlSpknr27KnFixfn6x8ZV65cmW5/OnXqVJbqCA0N1cSJE9WgQQMVK1ZMhQsXVs2aNTVs2DBt2LDBNYFnQ0JCghYvXqyePXuqUqVK8vPzU5kyZdS6dWvNmDFD4eHhLp3/li1bNHr0aNWqVUtBQUEqVKiQqlatqgceeEDLli1TUlKSS+fvjPDwcP3444+aNm2a7r//fpUtW9Zm39i8eXOO6s7tz4m7t6kjhmFoxYoV6tevn6pVq6ZChQqpZMmSatq0qV577TWdOXMmW/Xu3r1bjz/+uOrUqaPAwEAFBgaqTp06evzxx7V79+5s1XnmzBlNnTpVTZo0UcmSJVWoUCFVq1ZN/fr104oVK2QYRrbqzamCtL9s2LBBQ4cOVc2aNVW4cGEVK1ZMDRo00MSJE3XkyJFs1VmQ5u+s/HysnDp1qsNzLC8vLxUvXlxVq1ZVkyZNNHz4cH3yySfau3ev2+LN7wzD0Pjx45WSkqJKlSrpiSeecFg2o/NbR9vDXRISErR7927NmjVLI0eOVP369eXl5ZWtpBVfX1+99tprkqT169fru+++c1HUWeeKY01uSUv8svfn4eGhoKAgVa9eXQMGDNAXX3yh2NhYt8ab32X03Zfdv6xeR9wpMrqe9/PzU0hIiGrUqKG2bdtqwoQJWrBgQbbOFzPaNp6engoODlaNGjXUv39/zZs3TzExMdlahqlTp9qMa9q0qTlu6NChWY47zZo1a2w+0ydPnjTHnTp1Kkf7Zk6uY3Iit84/33nnHUmp194ff/yxK0MGAABwDQMAAAC3lfbt2xuSnP4LDAw0Fi5cmGfxbdq0yZx3+/bt82y+uS06OtooWbKkIclo2bKlU9OsWrXKnMbRX+PGjY2//vrLxdFnXWRkpFGuXLl08Z48edLpOt544w3D29s7w+UfNGiQERUV5boFcUJoaKjRsGHDDOMsVaqUsWbNmlyfd3h4uHHvvfdm+rlt0qSJERoamuvzd1arVq0yjXHTpk3ZqtsVnxN3btOMnD9/3ujUqVOGcQUEBBhffPGF03XGx8cbTz75pGGxWBzWabFYjKefftpISEhwut558+YZhQsXzjDWLl26GBcvXszGmsi+grK/REZGGg899FCGdXp7extvvfVWdlZDvp9/VuT3Y+WUKVOydJ6V9tewYUPjs88+M5KSktwSd3719ddfm+vos88+y7BsVte5p6dnHi2FrY8//tjw8fHJMLZhw4Zlqc6kpCSjatWqhiSjevXqRmJiomuCd5KrjjW5qVKlSlnaX0qXLm388MMPeRbfF198ke39wR2y+92X0V9WriPuJFm9npdkeHh4GD179jR+/PFHp+eT1XmUKFHC+O6777K8DFOmTLEZ99FHH5njChcubMTExGRl9Zj69+9v1nPr7wonT57M0b6Z3euYnMjt88977rnHkGQEBwcb169fd23wAAAAucx9jyQBAADA5Zo1a6bmzZubrw3DUEREhHbv3q2jR49KkqKiojRs2DDFxcVpzJgx7gq1wPnwww915coVSdKLL76Yafl169apT58+Zgs6/v7+6ty5s0qWLKnjx4/rl19+kWEY+uOPP9S5c2ft3LlTZcuWdekyZMXzzz+v8+fPZ3v6yZMna9q0aebrMmXKqF27dvLz89Pvv/+uQ4cOSZKWLVumq1evas2aNW5pQeHcuXPq3LmzLly4ICn1CeV77rlH1apV05UrV7R+/XrFxsYqLCxMDzzwgH788Ud16tQpV+Z9/fp1tW7dWn///bf5XtWqVdWqVSv5+fnp+PHj2rZtmxITE/X777+rQ4cO2rFjhypXrpwr88+KtPWT21zxOXHnNs1IVFSUunfvroMHD5rvNW/eXHXr1lVkZKQ2btyoiIgIxcTEaMSIEfLw8HDqafXRo0dr0aJF5uuqVauqZcuWkqQdO3boxIkTMgxD//73vxUVFaXPP/880zrnz5+vRx991HwdHBysTp06KSgoSAcPHjRb21i/fr26d++ubdu2KSAgwOl1kV0FZX9JTExUnz59tHHjRvO9evXqqXHjxoqLi9Ovv/6qixcvKjExUS+99JISExM1efLkHK6d/DP/rChox8qyZcuqT58+Nu9FR0crIiJCp06d0sGDB82uZvft26fHHntMCxYs0OLFi1W9enV3hJyvJCcna8qUKZKkkJCQLLVOlFGLTWk8PT2zG1qOhIeHKyEhIVfr9PT01HPPPafHH39cx44d04IFC2y+l/OaK441rtS5c2fVqlXLfJ2SkqKrV6/qt99+07lz5yRJly5dUq9evbRy5Ur17NnTXaHmW82bN8/0c7do0SJFR0dLSr/O7QkMDMy1+G5Xt17Pp6SkKDIyUhERETp06JBOnz5tvr927VqtXbtWw4cP10cffaQiRYo4PZ8HHnhA5cqVs5lPeHi4tm/fbn5GwsPD1a9fP3377bfpjn1ZMWjQID377LNKTEzUjRs39J///CfLLTJFRERo1apV5uthw4ZlWH7o0KFZWh/W6yIvuOL888UXX9Qvv/yiiIgIzZgxQ2+88UZeLAoAAEDucGMCFQAAAFwgo6cerX333XdGUFCQWdbX19c4e/asy+O7HVpiio2NNVuJqFixopGcnJxh+fDwcCM4ONhc7s6dOxtXrlyxKbNv3z6jYsWKZplOnTq5chGy5JdffjGftH/44Yez/AT1+vXrbaaZOHGiER8fb1Nm6dKlhp+fn1nmtddec9HSZKxdu3ZmDJUqVTL27dtnM/7KlStG586dzTLFihXLtSdb+/TpY9br5+dnLFq0KF2ZY8eOGc2aNTPLNW7c2EhJScmV+WdFpUqVDG9vb6NRo0bGmDFjjLlz5xr79u3L0RPMrvqcuHObZmTIkCE289ywYYPN+JiYGGPw4MFmGR8fH+Po0aMZ1vn555/bPJH/wQcf2Hw/JScnGx988IHh4eFhlsusJb4jR47YtKA2ePDgdE/Mb9iwwShatKhZZsSIEVlcG1lXkPaXV1991eazvWzZMpvx8fHxxsSJE80yFovF2Lx5s3Mrwgnunr+zCsqx0ro1kszOY6KiooylS5caTZs2tfl+LFq0aL5sdTGvffvtt+Y6efnllzMtb70O87O0faRChQpG3759jbffftvYsGGD0a9fPzP+7LS8Ex0dbQQEBBiSjJo1a7rl+G8YrjnWuIJ1S0yOWjRMTk42Zs+ebfj6+tq0dJLdlmGyoqC1xOQMZ9Y5Mufs9bxhGMbFixeNf/3rX0b58uVtviObNWtm3Lx5M8NpnTlvT05ONubPn2/zGQkJCTFu3LiRo2V44IEHzPFdunTJsC57Zs+ebU7v7++friXfW1tiyu+tfrni/DMlJcWoUqWK2RpTXnyvAQAA5Jb8fdUPAACALMvKj56rV6+2+XFv0qRJLo/vdkhimjdvntPr2DAMm5vD1apVc/ij7/79+22SBX766adcjjzrYmNjjZo1axpSavcloaGhWf5B2DrpZuDAgQ7LzZo1yyxXpEiRdDevXW3NmjU2CSN//vmn3XIxMTFmly659bnZs2ePzXpdunSpw7LXr1+3uYn/5Zdf5nj+WbV//34jNjY23fs5SWJyxefEnds0IwcOHLC5ueuo64/k5GSjdevWZrlBgwY5rDMuLs6oUKGCWfbFF190WPaFF16wuVFya1KhNeuuOtq0aeMwaXPt2rVmOU9PT+Pw4cMO68wNBWV/uXz5sk03fBl1l2Xd3VurVq0clssKd88/KwrKsTIrSUxpUlJSjLfeesvw9PQ0p61Ro4YRERHh2mDzubZt25rr48SJE5mWLyhJTKdOnTIuXbqU7v1hw4blOGll1KhRZh2rV6/OYaRZ56pjjStkJaHmk08+sdm/Zs+e7fL4SGKCI1m5nk8THR1tc84myRgwYECG02TlvP3DDz+0Kb9kyZIcLcOKFSvM8R4eHsa5c+cyW0Qbbdq0Mad/5JFH0o0vSElMrrxemTZtmln+k08+ye3QAQAAXMZDAAAAuGPdd999uvvuu83X69evd2M0BYd1lxgPPfRQhmUTExM1d+5c8/Xrr78uf39/u2UbNGhg0xT+zJkzcxhpzr3++utm92azZs2Sn59flqbfvXu32dWUh4eH/vWvfzksO3bsWNWoUUNSanc8ixcvzmbU2WO9vocNG6b69evbLVe4cGG9/vrr5uvZs2ebXR9l1/Lly83hBg0aaNCgQQ7LBgcH66WXXjJff/jhhzmad3Y0aNAgy/tCRlz1OXHnNs3IrFmzzC6munbtqu7du9std+tn5ptvvlF4eLjdsitXrtTZs2clSUFBQXr11Vcdzn/y5MlmFy6nT5/WmjVr7Ja7fPmy/vOf/5iv//Wvf8nDw/7PCPfee6+6dOkiKbWLqM8++8zh/HOqIO0vCxcu1I0bNyRJNWvWzLDbVuv1u337du3du9dhWWe5e/7OKujHysxYLBZNmjRJb7/9tvne0aNH3fL9nV/8/fff2rp1q6TUbqqqVKni5ohyT6VKlRQSEuKSugcMGGAOz58/3yXzyIgrjjX5wdixY1WiRAnzNddEKGgCAgL09ddf67777jPf++abb/TLL7/kSv1jx461OffPab333Xef+ZlLSUnRl19+6fS0J06c0LZt28zXmXUll9+58nrF3ccMAACA7CKJCQAA4A7XunVrc/jEiRM244YPHy6LxSKLxaIFCxZkWteCBQvM8sOHD89xbEeOHNHzzz+vli1bqkSJEvLx8ZGfn59KlSqlJk2aaMSIEVq4cKGuX7+eaV2JiYlavHixBgwYoKpVq6pIkSIqXLiwqlSpokGDBmnFihUyDCPTek6cOKHt27dLSr0hXLt27QzLb968WREREZKkIkWK6MEHH8ywvPV6W7dunXnz2R3279+v6dOnS5IeeeQRM0EhK77//ntzuEuXLqpQoYLDshaLxeZH6BUrVmR5ftkVExOjDRs2mK9HjBiRYfkHH3xQAQEBkqRr167l+If8nTt3msM9e/bMtLz1DYrdu3frzJkzOZq/u7nic+LubeqIYRhauXKl03G1adNG1atXl5SaHGQ9rTXrz9pDDz3kMAFEkvz9/W1uajj6rK1cudJMtqpZs6bN8cIe6+1iHU9uK0j7i/V6SDumOlKxYkV16tTJfJ0b34Hunr+zCvKxMiuee+45tWnTxnz94YcfKiYmxm7ZtPMp6222f/9+PfXUU6pXr56KFSsmi8WiBx54IN20v//+u95++2316tVLVatWVUBAgHx8fBQSEqLWrVvr5ZdfztZxY/ny5erdu7fKlSsnX19flS9fXl27dtXChQvNG6nOnjsuWbLEHLa3DLCvU6dOCgoKkiStXr3a/NzkFVcca/IDLy8vNWvWzHx96zVRhw4dzP168+bNmdY3depUs/zUqVNzHN/u3bs1fvx4NW7cWEWLFpWXl5cKFSqkMmXKqGXLlho3bpy++eYbp74Lb9y4oVmzZql3796qVKmS/P39VaRIEdWoUUMjR47Uxo0bcxyvPWFhYfLx8ZHFYpGnp6fOnz/v1HSGYahKlSrm+rz1PMjeur5x44Zmzpypdu3aqXTp0vLz81OlSpU0ePBgbdmyJcuxh4aG6qWXXlLz5s0VEhIiHx8flSxZUi1atNDkyZN14cKFLNfpChaLRYsWLVKRIkXM9958881cqdvX19fmujeny+zt7W3z0EZWHl5ZtGiROVy+fHmbc5eCxtXXKzVr1lSdOnUkSX/88YdCQ0NzGDEAAEDeIIkJAADgDle0aFFzOCoqyo2R2Jo6darq1aun6dOna+fOnbp69aoSExMVHx+vK1eu6I8//tCCBQs0fPhwTZgwIcO6Nm/erNq1a2vo0KFavny5Tp48qZiYGN28eVOnTp3SV199pb59+6p169aZ/qC+evVqc9iZH0w3bdpkDrdq1Uq+vr4Zlm/evLl5QyguLs5MmMprycnJevTRR5WUlKRixYrp/fffz1Y91svfoUOHTMt37NjRHP7tt98UHx+frflmlfW8ChcubHMjyx4/Pz+1atXKfJ3TGz6XL182hytVqpRp+XLlysnT0zPX5u9urvicuHubOnL06FGdO3fOfJ3Vz4WjuHLyWXNFnWfOnNGxY8cynSY7Csr+EhcXpx07dpivc2u7OMvd88+KgnqszCqLxaJ//vOf5utr167p559/dmraqVOnqkmTJvroo4906NAhhwnczZs3V9OmTfXSSy9pzZo1OnnypG7cuKHExESFhYVp+/bteuutt1S9evUMW0e0FhkZqW7dumnAgAFavXq1Lly4oISEBJ0/f17r16/X8OHD1aFDB126dMmp+iRp1apV5nBBvgGd17y8vNSuXTtJUkJCgtP7T25xxbEmv8iP10RJSUkaO3asmjdvrpkzZ2rv3r2KiIhQcnKy4uLidOnSJe3cuVOfffaZHnroIZvW3uxZvny5qlevrscff1yrV6/WmTNnFBsbq5iYGB07dkxffPGFOnfurN69eysyMjJXl6VUqVK6//77JaW2vOPMAzKStGHDBp06dUqSVKZMGZtEfnv++usvNWvWTOPHj9fWrVt1+fJlxcfH68yZM1q6dKk6dOigMWPGKDk5OdN5x8fH67HHHlP9+vX19ttva/fu3QoLC1NiYqLCw8O1a9cuTZs2TdWrV9cnn3zi1PK4WrFixWwSfX/++Wddu3YtV+ouVKiQORwXF5fj+qwfXjl06JD++OMPp6azTngaMmSIw1ZCC4K8uF6xPsZa/5YBAACQnxXcMzwAAADkCuubYGlPdrvbhx9+qNdee838cblEiRLq1auXRo8erTFjxqhfv36qV6+eTRKHI8uXL1e3bt10/PhxSak/vnbs2FEjRozQqFGj1K5dO3l5eUmSduzYoVatWtkklNzK+mZR2k2kjFg/7di4ceNMy3t7e9s0Ie+upyU/+OAD7dmzR5I0ffp0lSxZMlv1ZHX5GzVqZA4nJyebXdm5mnWc9evXN/eJjFgvT063kzOtgFm7tXWOQ4cO5Wj+7uaKz4m7t6kj1vWWLl1aZcqUyXFckZGRunjxot3yztR5/vx5uzdss7pdypYta9OFUl6sw/y8v/z1119mS1YWi8Xm+y27dWaFu+efFQX1WJkdvXv3tumS59dff810munTp5vnRdWqVdOgQYM0atQode7cWd7e3jZl01pY8vX1VePGjTVgwACNHj1ajz76qE33PYmJiXrhhRcyTWSKj49Xjx49bM5/ypYtq4ceekijRo1Shw4d5OXlpW3btqlv375OdcUZHh6uffv2SUo9L2vSpEmm09zql19+0YwZMzRx4kS9+OKLmjFjhn7++ecC0ypXTliff+ZlEpOrjjX5RX68Jpo4caLmzJljvi5Xrpz69OmjMWPG6NFHH1WfPn101113OVXXBx98oIceeshMNgwMDFT37t01atQoDR8+XM2aNTPPLVevXq0OHTro5s2bubo81l2azp8/36nzX+tuvIcPH57h9V9kZKTuvfdehYaGytfXV927dzfXU3BwsFlu7ty5mbZ4c+PGDXXu3FmzZ882r0mrVaumAQMGaOzYserfv7/Kli0rSYqNjdWECRP01ltvZbo8eaF///7msGEYZtedOWXd+lJudJnZpEkT1a1b13xt3cKSI1u3brVpKa2gdyWXF9cr7jpmAAAA5ETmZ0UAAAC4rW3bts0crlKlihsjSZWUlKQ33njDfP3222/r2WefTXeTTkptweC///2vrly5YreuQ4cOadiwYUpMTJTFYtGzzz6rl19+2eZHbCm1y4hhw4Zp69atOnv2rEaMGKG1a9farXPXrl3mcIMGDTJdnr/++sscdqaFHSm1S5+07sWOHDni1DS56cSJE5oyZYok6Z577sn0R35HwsLCbLo5cWb5CxUqpJIlS5rb9MiRIzY3ql0lu9spTU63U8mSJc06nOni5/z58zY3igvSDXx7XPE5cfc2dcQVcVnXeWt5Z+pMq+PWp7+zG2taIuiRI0fUu3dvp6bLioKyv1jXWapUKZvEFWfqvHbtmq5cuZLtJFJ3zz8rCuKxMru8vb3VqFEjs/Uo69ayHHnppZcUFBSkBQsWpOt67dYWC/v27atevXqpY8eONq1mpElOTtbixYs1fvx43bhxQ6+88or69+/v8BzwjTfeMGP08PDQv/71Lz3zzDM2LV+cOHFCgwYN0vbt251qSWPXrl1m8kKdOnWcuml7q/bt29t939/fXyNHjtSrr76qUqVKZbnegqBhw4bmsPV5qau56liTHyQmJtqsy/xwTXT16lWzdR9PT099/vnnGjp0qN1uQS9evKhvv/3WYfd+GzZs0HPPPSfDMOTj46PXX39dEyZMSFd+3759Gjx4sA4fPqx9+/bpueee06effppry9S1a1dVqVJFJ0+e1IkTJ7R582ab1rpude3aNbMbQovFolGjRmVY/6effqqEhAR17dpVixYtUunSpc1xsbGxNsuzePFi3XvvvTZdmll7/PHHzevkmjVravbs2elaH0tOTtacOXP0zDPPKD4+XpMnT1bHjh1tWspxhyZNmsjT09NMvtqxY4fZClZ2/f3332aLWJLUsmXLHNWXZtiwYXr++eclScuWLdOMGTMyPCZYJzq1aNHC6SS+/Covrlesjxm7d++WYRgZdi8MAACQH9ASEwAAwB1szZo1+vPPP83XnTt3dmM0qY4cOaLw8HBJUps2bfTiiy/aTWCSUpvLHzFihPnD562efPJJxcbGSpLee+89TZ8+PV0CkyRVrVpVP/74o+rUqSNJ+uGHH8wbo9YuXbqksLAwSak/pNesWTPT5bl69ao57OwTq9Y/uOdW8/9ZMWbMGN28eVM+Pj6aPXt2tn/ktF52KX8vv7u3k3UrFD/++GOm5W9NsnPHfpKbXLH+3b1NHclpXDdv3kyXtGBdZ2BgoN3EhVv5+/urSJEi5utblzc2Ntb8/sxurPl1HebV/pLTOh3V6yx3zz8r8uvn1VWsb7pm1PpjmpSUFK1cuTJdApOkdF3vffrpp+rZs6fD7wFPT08NHz7cbN0kMTFRn332md2y169f14wZM8zXb775pp599tl0XfdUrVpVP/30kypVquRUN7DW5561atXKtHxW3Lx5U5988okaNmzoVIJYQVS7dm1z+NChQ061fpUbXHGsyS/mzJljs3z54Zpo+/bt5rYdOHCghg0b5vCcvEyZMpowYYLdJJ+UlBSNGzfObJnvq6++0gsvvGA34alhw4basGGD+T08b948my5wc8pisejRRx81X1u3smTPkiVLzO+UDh06qFq1ahmWT0hIUMOGDbVy5cp0x7NChQpp5syZeuSRR8z3XnrpJXO9WPv111/NZJlq1app27ZtdrtP9PT01Lhx48zv0OTkZL3++usZxpgX/P39VaFCBfO1M8eZjCQlJempp54yXwcGBmrgwIE5qjPNI488YrauFRYWpp9++slh2bi4OC1fvtx8nZVWmKZMmaLx48c79ffhhx9mf4GyKC/Of6pXr24mhkVERDj1wAwAAIC7kcQEAABwh/r+++9tfsT19fXV448/7saIUll3M5GT1h/279+vjRs3Skrtouzpp5/OsHzhwoX16quvmq+XLFmSrszJkyfN4VKlSsnHxyfTOGJiYsxhZ2723FrOevq8MH/+fG3YsEGS9OKLL+bo5uKtsefn5Xf3dvrHP/5hDu/du1fffvutw7LR0dF655130r1XkLli/bt7mzqS07hurSO7dd5aNqM6s1JvQViHebW/uGJbZ4W7558V+fXz6irWXVVZd2HlSL9+/XTPPffkagz9+vVTQECAJGn9+vV2yyxdulRxcXGSUluIeO655xzWFxwc7PTNe+vzqfLlyzsbsnx9fTVgwAAtWLBABw8eVFRUlBISEnTp0iWtXr1a/fr1M5M8Ll68qPvuuy/PuqXNS2XKlDETyZKSknT+/Pk8ma8rjjXulpKSorlz5+rZZ5813ytZsqQGDx7sxqhS5dY10apVq3T06FFJ0gMPPKA+ffpkWL506dLmdVNiYqK++eabbM/bnhEjRpgJFf/5z39sWm29lXWSk3XyU0bee++9DFsefP/9983kz1OnTtntXuv999+3qS+tG05Hhg8fbl4z/fTTT+ke5HCHrB5nbpWSkqKwsDCtWLFCbdq0MR+y8PLy0vz581W8ePFcibNMmTLq2rWr+TqjLuVWrlxp7i++vr5ZSqRatGiRZs6c6dRfWutfeSEvzn88PDxsuq+2blELAAAgv6I7OQAAgNvY2rVrzVaN0kRERGjXrl3mj9lp3n//fZsnNt3FOoZNmzbp77//dqrFo1tZt1QzaNAgp1oT6tSpkzm8devWdOOtn2J19ofbtJt/kpxKepJsW1WwbgnF1S5fvmzeoKxZs6ZeeumlHNVnvexS/l5+d2+nDh06qE2bNma3FcOHD1dSUlK6H+dPnTqlwYMH68SJEzbv5+V+4gquWP/u3qaO5DQuKX1s2anz1nozqjMr9RaEdZhX+4srtnVWuHv+WZFfP6+ukpY8JDmXhJrdFi/+/PNP7d27V6dOnVJUVFS6VpLSzo0OHDiglJSUdC0sbd682Rx+6KGHMu32rV+/fho7dmy6749bZed8SkrtStVe+ZCQEN1333267777tHr1avXv319xcXG6du2aHn/8cYdJWgWVl5eXgoKCzMSES5cuOd0NUU644liTV7788kvt2bPHfG0Yhq5evarffvtNZ8+eNd/38PDQ559/bvMZdRfra6LvvvtOkyZNylYXidbXRA8//LBT09x6TfTPf/4zy/N1pEyZMurVq5e+//57xcXFaenSpXYfpPn999+1f/9+SVLRokXVt2/fTOsuX758ht3TSakJYT179jQTVTZt2qTu3bub45OSkszEpsDAQPXq1cup5erYsaOOHDkiwzC0bdu2HHffllNZPc5ktt6k1FYE33vvPd133305iu1Ww4YNM5OkVq5cqcjISJskrDTWCU69e/dW0aJFczUOd8ir858SJUqY33WXLl3KQoQAAADuQRITAADAbWz37t3avXt3hmWKFCmiDz/8UCNGjMijqDJWoUIFtWzZUjt27FBkZKSaNGmiIUOGqE+fPmrTpo3drg/s2b59uzm8adMmnT59OtNpDMMwh61vaKS5ceOGOexsHH5+frp586ak1C4OnGF9kzErT7rn1Pjx480bYrNnz053Mzurbn0KOiEhIcMno9O4Y/mt43LXdvryyy/VrFkzhYeH68aNGxo0aJBeffVVtWzZUn5+fjp+/Li2bt2qxMRE+fv7q127dmaXC9ZdtRRErvic5Idtak9O45LSx5adOm+tN6M6s1JvXq3DgrC/uGJbZ4W7558VBelYmRusbygHBgZmWt66y1FnLFy4UG+99ZbTrRAlJiYqMjIy3Q3hffv2mcMtWrTItB5/f3/Vq1fPJlnEnuycT0nOJTz16tVLH330kcaMGSNJ2rBhg37//fcsr8P8zt/f3zxns16fruSKY01e2bBhg9nSqCMhISH6/PPPcz1BI7tatmypChUq6OzZszpz5ozq1q2rESNGqHfv3mrRooXTCQ/W10T/+c9/tGXLlkyniYyMNIftXRPl1JgxY/T9999LSm1tyV4Sk3UrTI888ohT1xAtW7Z06sGVVq1amUlMe/futRn3559/mp8pb29vm27UMmJ9ze2KdZZVWT3OZCYkJESLFi1S8+bNc1zXrR544AEFBQUpMjLS7DLu1pa3bu1qLitdyUmpLQBWrlw5N8LNVXl1vWJ9rM2rYwYAAEBOkMQEAABwhwkICFDx4sXVoEEDdenSRUOHDlVwcLC7w7Lx+eefq1OnTrp8+bJiYmI0a9YszZo1S15eXmrYsKHuuecede/eXZ07d5anp6fdOi5cuGAO//DDD1mOIbNm960TnjISEBBg3ph19klJ63J59ST4f//7X7MLs+HDh6tDhw45rvPW2GNjY526AeGO5beej7u2U+XKlfXbb7/pwQcf1IEDByRJx44d07Fjx2zKhYSEaMmSJfrvf/9r/pif3z7DWeWKz0l+2Kb25DSuW+vIbp23ls2ozqzUm1frsCDsL67Y1lnh7vlnRUE5VuYW6wSBYsWKZVre2a6kDMPQqFGj9MUXX2Q5pujo6HRJTFeuXDGHnW2ts3z58pkmMVlz9nwqK0aNGqU33nhDZ86ckZR6Hni7JTG5Yr1lxhXHGnexWCwqUqSISpYsqUaNGunee+/VoEGD8lVCpLe3txYvXqxevXopJiZG4eHhmj59uqZPny4/Pz81bdpU99xzj3r27KnWrVs7TN6xvib6+uuvsxxHdroiy0z37t1VqVIlnT59Wn/88Yf27dunhg0bmuNjY2O1dOlS87WzXclVrFgxy+Wsv+ck2/V19epVzZw506k6rblinWVVVo8zDzzwgMqVK2e+vnr1qo4fP24mZ12+fFnt2rXTf/7zH6dbp3KWn5+fBgwYoLlz50pKbXHp1m2+ZMkSJSUlSUrt1r1Hjx65GoO75NX1ijuOGQAAADnhkXkRAAAAFFRTpkyRYRg2f9HR0Tp16pRWrlypJ598Ml8mP9SpU0f79+/XhAkTbJqST0pK0p49e/T++++bP37PmzfPbh3WP9xmR3Jycrr3ChcubA47+yOjdasB1t2nZMS6iXdnfnTOqZs3b5pPQJcoUUIzZszIlXpvbTEhvy6/lH+2U40aNbRv3z4tW7ZMDz74oCpUqCA/Pz8FBQWpUaNGmjZtmg4ePKjOnTvbdBWZH7qCzAlXrP/8sk1vldO4/P3907WSZl1nVFRUpl05Samfe+un9G9d3kKFCtnczL2d1mFe7S85rdNRvc5y9/yzIr9+Xl3lyJEj5nDp0qUzLe9sYsXcuXNtEph69OihhQsX6sCBA7p+/bri4+NtzgmtuyBLSUlJV19MTIw57GyLSc7cUM3O+VRWeHh42HSHFRoamuvzcDfr9Wa9Pl3JFceavPLFF1/Y7PspKSmKjIzUsWPHtHz5co0cOTJfJTClad++vfbv36+hQ4faxBcXF6etW7fqrbfeUtu2bVWrVi2zZaNb5fSaKC1xJDd5eHho1KhR5mvrVpek1Baj0uJu1qyZGjRo4FS9zn5PWX9mbu1qLafrS3LNOsuKGzdu6Ny5c+ZrZ44zTz31lD755BPzb9myZdq1a5f279+vu+++W1JqS0GDBg3S8ePHcz1m65aVtm7dqpMnT9qMt+5KbvDgwZl2b1pQ5NX5jzuOGQAAADlBEhMAAAByjb0bYNkVEhKijz76SJcvX9bmzZs1bdo03XvvvTbN4Z8/f16jR4/Wk08+mW566x/nvvvuu3TJXM783cr6B2DrBJKM3HXXXeawM13aSTJbDpCkWrVqOTVNToSFhZlPHVssFt13331q2bKl3b8+ffrYTNunTx9z3LRp02zGlSpVyiZJzpnlj4uLs3kiOi+WX8pf28nDw0MDBw7Ut99+qzNnzig2NlYRERH6448/9Morr6hEiRKSpEOHDpnTNGvWLNfm7w6uWP/5aZtac/WyOluvdZ326rj1vTtpHbqizrCwMKdu+FvXWaxYMadb4LHH3fPPivy6r7lCQkKCTTdtLVu2zLW6rZOQX3vtNf3www8aOnSo6tWrp+Dg4HTdT9168/5W1glJaS1lZcaZbmqycz6VVWXKlHH5PNwlMTFRERER5mtnEhRyg6uONbej3Lwmqlq1qhYuXKgrV67oxx9/1CuvvKKOHTvaJDX9/fff6tOnj95///1001tfE/3xxx9Zvh46depUri2LtZEjR5ot6i5ZssTmGGWd1ORsK0xS9r6nbu2S2Xp9NWjQIFvXkFOnTnU6ZlfYs2ePzQM5OTnONGjQQOvWrTNbaYqJicnSNnFWmzZtVL16dUmprQZ9+eWX5riDBw/aHDez2pVcfpZX5z/W19d5dcwAAADICZKYAAAA4JC3t7c57MwTpbnx5OqtfH191b59e73yyitau3atwsPD9cMPP6ht27ZmmY8//ths6j5NSEiIOXxryxLZVaVKFXP4ypUrSkhIyHSa2rVrm8N79+7NtHxSUpLZldit0+eFK1euaOfOnQ7/rH9AlqR9+/aZ4+w9lZvV5f/jjz/MYU9PT9WsWTP7C5MF1nEeOHDAqf3dOta83k4RERE2LUu0bt06T+ef21zxOcmv29S63kuXLjn1/ZRZXEFBQTY37LP6WStXrpxNgqi9eTlT54ULF2yeIs+LdZif95e77rpLHh6pP7sYhpHu+zM7dWaFu+efFQXtWJkTK1euVHx8vPn6nnvuyZV6z549q6NHj0pK7WJ00qRJGZaPiorKtMujtKRZSTatemTEmXLW51PO1ptV1kkKt1urExcvXjST7b28vGy6gHIlVx1rCoL8cE1UuHBhde/eXdOmTdPGjRt19epVLV++XPXr1zfLTJo0SefPn7eZzhXXRLmhXLly6tmzp6TU7tdWrFghSTp+/Li2bNkiKXWZBw0a5HSdtybNOXL27Flz2Pp7Tsq/6ysrli9fbg57eHjYXDdnR6lSpfTxxx+brzdv3qw1a9bkqE57hg4dag4vXrzYHF64cKE5fPfdd5stQ90O8uJ6JSUlxWZfrly5ctaCBAAAcAOSmAAAAOCQ9Y2Gq1evZlre+oaiq3h7e6tHjx5av3696tWrZ76/atUqm3ItWrQwh7dt25Yr8w4JCVGpUqUkpd4Q/vvvvzOdpmPHjubw9u3bM0182r17t/kUsZ+fn1q1apWDiN3Pevk3b96cafm0mxZSamLOrd1muYr1vG7cuKE9e/ZkWD4+Pl47duwwX1t3W5MXvvvuOyUmJkpK7X6xSZMmeTr/3OaKz0l+3aY1atRQ+fLlzddZ/Vw4iisnnzVX1FmxYkXzifrcVlD2Fz8/P5vWD3JruzjL3fPPijvlWGkYhj744APzdcmSJdW5c+dcqTutRUUptWUG66QLe7Zu3Wq31UlrDRs2NId37tyZaQyxsbE6ePBgpuWsu4b666+/Mi2fHdYJNmXLlnXJPNzFOom5bt26edqtkiuONQVBfrwmKlSokPr166fNmzebiTcJCQn66aefbMq54poot4wZM8YcTmt9af78+eZ3U//+/dO1lJQRZ76npNTjTJrGjRvbjGvYsKF5PhAWFqZjx445Pf/84OrVqzZJPz169LDpnj27+vTpozZt2pivX3nllRzXeashQ4bIYrFIko4ePart27crOTlZS5cuNcvcTq0wSXlzvXL06FEzOSo4ONimK1kAAID8iiQmAAAAOGT9lF5mLTjExcWlSyRyJV9fX3Xr1s18bd36hyT16tXLHP7uu+/Sjc+u5s2bm8P79+/PtHyHDh3MH46joqL03XffZVh+wYIF5nDXrl3zpPWAypUrO909wsmTJ22mPXnypDnOOvY0DzzwgDm8fv36TFtcsK7DelpXCwgIsLmRbG9ZrH333XdmNzzFihXLtZY0nBEfH68333zTfP3YY4/l2bxdxRWfk/y6TS0Wi+6//36n49q+fbuZMOnp6anevXvbLWf9efn6668VGxvrsM7Y2Fh98803dqe1dv/995st+fz11182N03ssV6Wf/zjHxmWzYmCtL9Yr9vM6jx79qw2bNhgd9rscvf8nVUQjpW5YcaMGfrtt9/M188884z8/f1zpe60z6rkXJdKs2bNyrRMhw4dzOFvvvkm0xYi/vOf/2T43ZOmWbNm5o3qw4cPO9XyRFYcOXLEZj1bL8ftwPr80/q8NC+44lhTEGTlmujChQvaunWrawOyUqxYMZvkkoyuiebPn+9U16J55d5771WFChUkSRs3btSxY8dsvt+z2m3Z2bNnM02uCw8P19q1a83X1ol5UmpymHViyKeffpqlGNzJMAwNGzZMMTEx5nu5mWxk3U3evn37tHLlylyrW0r9nLVv3958vXjxYq1fv95M0vXy8tLgwYNzdZ7ulhfXK9bHjILeBTkAALhzkMQEAAAAh6yf3F29erXCw8Mdlp08eXKG4511/fp1paSkOFXWuiuAtBaS0jRv3ty8aRUbG6shQ4Y41f2blPoUs6MuVrp27WoOO3ODwtvbW6NHjzZfT5482eENn4MHD9r8cPnEE084FW9+1qxZM/PH0uTkZL344osOy86ZM8dM1ihSpIhNlwJ54fHHHzeHFyxYoEOHDtktd/PmTU2ePNl8PWbMmDxrBcEwDI0bN04nTpyQJNWrV++2SGJy1eckv27Txx57zEw4+Omnn/Tzzz/bLZeSkqLnn3/efN2/f3+VLFnSbtn777/fbOEpIiLCJtHtVtOmTVNERIQkqVKlSjY3OK2FhISob9++5uvnn3/eYcst69at07p16ySlJlu5cr8sSPvLsGHDzASbv/76S/PmzXM4/xdeeEHJycmSpFatWqVrHSI73D1/Z93ux0rDMPTOO+/YdPFWu3ZtTZgwIdfmUaVKFTMx6ODBg+Zxwp6vv/5aq1evzrTOhx9+WH5+fpJSk5atW5G6VWRkpF599VWnYi1RooTZylNsbKx+//33TKexvimfkZs3b2r48OHmvlyiRAn16NHDqWkLil9//dUctj4vzQuuONYUBNbXRMuWLbPpEvJWzzzzjNlaZk440+JTmoyuiR588EGzZcSLFy/q8ccfz7QVtjQxMTE2XTPmNk9PT40cOVJS6vfkI488Yias1K5d2yY5y1nPPfdchtvnueeeMxO5KlWqZPcz9MILL5jDH3/8sdavX+/0/N3VBV1MTIwGDhxo083bkCFDcrWlwi5duth0Yf3GG2/kWt1prFta+vrrr23OW3r06JFu/74duPp6xZ3HDAAAgGwzAAAAcFtp3769IcmQZEyZMiVHdaWkpBjVqlUz6+vSpYtx7do1mzI3btwwnnvuOUOS4evra5YdNmyY3To3bdpklmnfvn268V988YVRrVo1Y/r06cbJkyft1hEXF2d8/PHHhsViMevatm1bunIHDhwwAgICzDItWrQwduzY4XB5//rrL+P11183ypQpY6xatcpumePHj5v11axZ02Fd1sLDw43g4GBzuq5duxrh4eE2Zfbv329UrlzZLNOxY8cM6zx58qRZVpLxxRdfOBVLTt06X0fbyNr69ettpnnhhReMhIQEmzJff/21UahQIbPMa6+9lmGdX3zxRZbjcEa7du3MOitXrmzs37/fZnx4eLjRtWtXs0yxYsWM69evO6wvK9vpp59+MiZPnmwcP37c7vhjx44Z9913n1lXoUKFjF27dmW6TJUqVcr0c5lbrJd106ZNWZrWFZ8Tw8j9bZpbhgwZYs6zePHi6dZXTEyMTRkfHx/j6NGjGdb5+eefm+U9PDyMDz/80EhOTjbHJycnGx9++KHh4eFhllu4cGGGdYaGhhre3t5m+SFDhhgxMTE2ZTZu3GgUL17cLDNixIisrYxsKEj7y6uvvmrzuf36669txickJBgvvPCCzedn8+bNGdaZlc+1K+Y/bNgws2ylSpUyLOusgnKsnDJlSobnMdaio6ONZcuWGc2aNbOJo0SJEg6/69NYl3dWq1atzGkaNWpkHDlyxGZ8cnKy8cknnxje3t6Gp6en4efnl+lx9KWXXrL5Xvnggw9svlcMI3U9t2zZMt25YEbre/LkyWa5t956K9NlK168uPHqq68aoaGhDsts3brVaNCggc26mzVrVob1Wm9PV/9Mav25ye7xODEx0QgKCjKPC5l9/1gvW06vC9K44ljjiu1g/T2Z08/+jRs3jCJFipj1PfLII8bNmzdtyly9etU8blt/Dhytd+tzWXv7w5QpU4y7777b+PTTT42LFy/arSM6OtrmM+rp6WmcOXMmXbmff/7Z8PT0NMvde++9xuHDhx0u7969e43nn3/eCA4ONg4cOOB4xdwiO+v8zJkzNvtK2t+MGTOcmt563/Hx8TEkGT169DAuXbpkUy42NtaYMGGCzTy+/PJLh/Vaf159fHyMt956y4iOjrZbNjY21lixYoVx//33G82aNbNbJivHo6xcz1+8eNGYPn26UaFCBZv6W7dubcTFxWU4bXbO23/88Ueb6X744YccL4O16Ohoo3Dhwun2B0nG8uXLna4nO9eszigo16DW6tSpY06X0eceAAAgP8m7TtMBAABQ4FgsFr399tsaMGCApNTuwKpUqaLOnTurRIkSunTpkn755RdFRESobNmyeuKJJ/Tyyy/neL7Hjx/XxIkTNXHiRFWsWFENGjQwn7q8dOmSduzYoWvXrpnlBw8ebPNUaJp69epp2bJleuihh3Tz5k3t3LlTLVu2VLVq1dS4cWMVK1ZMcXFxCgsL059//qnz589nGlvVqlXVqlUrs4un0NBQ1a5dO8Npihcvrq+++kq9evVSUlKSfv75Z1WsWFFdunRRyZIldfz4cW3ZssV8KrpcuXL68ssvs7LK8rXOnTvrlVdeMZ/Wfffdd7V48WK1a9dOfn5++v3333Xw4EGzfNeuXfXSSy+5JdalS5eqefPmunjxok6dOqWGDRuqffv2qlatmq5cuaL169eb3fR4eXnpm2++UXBwcK7M+9q1a3r99df1+uuvq2bNmqpfv76KFy+u6Oho/fXXX/rjjz/Msn5+fvrvf//rti4BVq5cafMksD2PPvqoAgICbN67//779frrr9st76rPiTu3aUY++eQT/fHHHzp06JCuXr2qjh07qkWLFqpTp46ioqK0ceNGmxbh5syZY7ak4MjIkSO1efNmLV68WCkpKXrqqaf00UcfqWXLlpKkHTt26Pjx42b5ESNGZNriWa1atTRr1iyzS5fFixdr9erV6tSpkwIDA3X48GHt3LnTLN+gQQN9+OGHWV4fWVWQ9pdXX31V27Zt08aNGxUbG6uHHnpIb7zxhho3bqy4uDj98ssvunjxoln+tddes+lOJafcPX9nFcRj5dGjRzV+/Hib92JiYhQREaFTp07p4MGDZotAadq0aaPFixerSpUquR7PtGnT1K1bN6WkpGjv3r2qX7++2rRpo6pVqyomJka//vqrua3ffPNNzZkzR6dPn86wzsmTJ2v9+vXatWuXUlJS9Mwzz2jGjBlq166dAgICdOLECf3yyy9KSkpSq1atVLVqVS1ZskSSbRd3txo8eLB5PPj+++9tWqmy5+rVq5o2bZqmTZumsmXLqkGDBgoJCZGfn5+uXbum33//PV3rU0888YTbWitMa2nK2pkzZ8zhlStX2i2TWVdlGzduVGRkpCTpvvvuy5Pj1a1ccazJ7/z9/fXqq6+arSN++eWXWrdunTp27KjAwECdPXtWv/zyi27evKl69eqpe/fueu+993I83/379+vxxx/XE088oWrVqqlevXoqUaKEEhMTdfHiRf322282rZS9+OKLZvds1rp06aJZs2Zp3LhxSk5O1g8//KAff/xRderUUYMGDRQYGKibN2/q4sWL2r9/v65cuZLj2J1VoUIF9ejRw6aLNx8fn2ztM+PGjdN///tf/fjjj6pcubI6dOigChUq6OrVq9q0aZPNedXDDz+cYddks2fP1sWLF7Vu3TolJCTopZde0htvvKEWLVqoYsWK8vX1VUREhI4fP66DBw+arT81adIky3FnZO3atTatHaekpCgqKkoRERE6fPhwuq6+JWn06NH64IMP5Ovrm6uxSFL37t3VokUL89xv2rRpudraXUBAgPr27avFixfbvF+0aFGHXSo7Y8qUKSpSpIjT5Tt27KgHH3ww2/PLKlddrxw9elSHDx+WJDVq1CjT3y0AAADyDffmUAEAACC35WZLTGlee+01u09Dpv3dddddxsGDBzN9otgwMm+Jafny5TYtLGX05+HhYTz++OPpWvW51b59+4wmTZo4Vaf+/+nHvXv3Oqxv3rx52VrHK1euNEqUKJHhvO21nGDPiRMnbKZbtGiR03HkRHafak1JSTGmTZtm06KLvb+BAwcakZGRmdY3f/58m+nsPXWeXaGhoUbDhg0zjLNkyZLG6tWrM60rK09dL1u2zKn9s2nTpsbvv//u9PJUrFjRnHbkyJFOT5eRW59CdvbPmZYncvNzkiY3t2luOn/+vNGpU6cM4woICDDmz5/vdJ3x8fHG+PHjM/wetVgsxpNPPpnpd6e1uXPnOnwyPu2vc+fOxoULF7KzKrKtoOwvERERxoABAzKs09vb23jzzTedqi+rLazl9vyHDh1qTle1alWnpnFWfj9W3tpijLN/jRs3NubOnZuuFSNHrKfNilmzZhleXl4O4/Dw8DAmT55spKSk2OxHGR3Pr1+/nul3VevWrY2LFy8aDz/8sPneihUrMoy1bdu25nfSiRMnnF4fmf0VLVrUmDt3rlPry7pFKA8PD6emcUZ29hFntvWjjz5qlnXUamialJQUm7pff/313Fq8XD/WuGI75GZLTIaR2sKU9fq399eyZUvj3LlzNt8T2W2JacaMGU7vNz4+Ppm2YmoYqS0n1qhRw+l669ata5w/f97pdZTddf7999/bzLdfv35OT3vrug4NDTXuuuuuDJdr5MiRRmJiYqZ1JyUlGa+++qrh7+/v1Pry9vY2nnjiCbt1ZbclJmf/PD09jV69ehnr1693et1ZT5+VFlTXrFljM629eebkN4lbW/GVZIwbNy5Lddy6vrP699RTT9mtt6Bcg6Z54403zGk//vjjXIsVAADA1WiJCQAAAJmaPHmyunbtqo8//li//vqrwsLCFBgYqOrVq2vgwIEaNWqUAgICtHv37hzPq1+/fuZTr9u2bdP+/ft14sQJRURESJKCgoJUs2ZNtW3bVkOHDlWdOnUyrfPuu+/Wnj17tG7dOn3//ffatm2bLly4oIiICPn6+qpkyZK666671KJFC3Xv3l2tWrWSxWJxWN/gwYM1adIkXblyRfPnz9fkyZMzbG0gTe/evXX48GF98cUXWrFihblcISEhqlu3rgYNGqRBgwbJ29s707r+/PNPczgoKEi9evXKdBp3slgseuWVV/Tggw9q3rx5Wrdunc6ePavExESVKVNGrVq10rBhw9SlSxen6rNe/nvuucfuU+fZVatWLe3cuVNfffWVli1bpkOHDuny5csKDg5W1apV1bdvX40YMUIlSpTItXlKUq9evbRixQpt2LBBO3fu1MWLF3XlyhUVKlRIZcqUUfPmzdW/f3/de++9Tu1vknT9+nWdO3fOfP3II4/kasyukJufkzTu2qaZKVu2rNavX68VK1ZoyZIl+uOPP3Tx4kUFBASoYsWK6t27t0aNGqWKFSs6XaePj48+/vhjDRkyRPPnz9fmzZvNVubKlSunDh06aNSoUVluxevRRx9Vt27d9Pnnn2vVqlU6c+aMYmJiVKZMGTVu3FiPPPKIHnjggQy/O12hoOwvQUFB+vrrrzV69GgtXLhQ27dv18WLF+Xt7a0KFSqoe/fuGjVqlMuekM/t+Vt/B+f290pBPlZ6enoqMDBQgYGBKl68uOrXr68mTZronnvu0d133+3Sead57LHH1KZNG33wwQfatGmTLly4oEKFCqlcuXLq1KmTRo4cqUaNGmWpzuDgYG3YsEHffPONFi1apN9//13Xrl1TiRIlVLt2bQ0ZMkQPP/ywvL29bVrKzKyViKefflpbt26VYRiaN2+e3nzzTYdl//77b23fvl3bt283W4oJDw9XTEyMAgICVKpUKTVp0kRdunTRwIED5e/v79SyuXJfzm0xMTH66quvJEk1atTQfffdl2F562Xz8vLSwIEDcy2W3D7WFITt4OHhoblz56pPnz6aM2eOdu7cqatXr6p48eKqXbu2HnnkEQ0ZMiRLx5uMPPvss3rwwQf1888/67ffftOBAwd06tQpRUVFycPDQ8HBwapdu7Y6deqkoUOHqlKlSpnW2bFjR4WGhur777/XmjVrtGPHDl26dElRUVHy9/dXSEiIatWqpdatW+vee++121qYK/Ts2VO+vr5ma0ZprT9mR61atbR7927Nnz9f33zzjY4dO2YeQ9q0aaMxY8aoY8eOTtXl6emp119/XRMmTNCiRYu0fv16HT58WOHh4UpMTFRgYKAqVaqk+vXrq2PHjurZs6dKliyZ7did4ePjo8DAQAUFBal06dJq1KiR+d1Xvnx5l847Tc+ePdW0aVPt2bNHkvT666+rc+fOuVZ/x44dVaFCBZ09e9Z8b9iwYblWf04UpGtQwzA0f/58SannQMOHD8+1WAEAAFzNYhj/3w43AAAAAKe99dZbZtd5K1as0AMPPJCn80/rukNKbcb/lVdeydP5u9vdd99t/oj866+/qm3btm6OKH9asWKF+vbtKym1W7/169e7OSIABV1a8ophGCpWrJhOnjypwMBAd4dl151+rHSHcuXK6cKFC5JSuwAOCQlxWDYlJUV169bVkSNHFBISolOnTsnPzy+vQlVKSopKlCih69evy9vbW3/99ZdLuvnLLbNmzdLjjz8uKbWL0dGjR2dY/oMPPtA///lPSdKoUaM0b948l8eYHQVtOyD3bdmyRR06dJAkVapUSSdOnHA6YX/q1Kl67bXXJKV2GTZ16lQXRQkUrGvQH374QT179pQkvfTSSxkmCgMAAOQ3zl0NAAAAALDx5JNPmk/avvvuu3k+/40bN0qSSpUqpaeffjrP5+9O4eHhOnDggCTp3nvvzdc/Hrtb2n4ipSbeAUBObdq0SWnPw73wwgv5NoFJurOPle6wdetWM4GpQoUKGSYwSakt26QlH1y+fFkLFixwdYg29u7dq+vXr0tKbfklPyfOJCcna8aMGZKkatWqacSIEZlOk7b/+/r6asqUKS6NLycK0naAa3z++efm8MiRI51OYALyUkG7Bk37jSI4OFgTJ050czQAAABZwxUBAAAAkA0BAQF6/fXXJUk7duzQTz/9lGfzDgsL06FDhyRJkyZNUkBAQJ7NOz9Iu4FusVh4ojQTaTcw//GPf6h58+ZujgbA7SDte6VMmTKaMGGCm6Nx7E4/Vua1hIQEPfPMM+brhx9+2Knp+vfvr5YtW0qS3nnnHbM7qbyQti8XKlRIr776ap7NNzuWLFmiEydOSEq9Me3l5ZVh+eTkZP3yyy+SUrsYzM0uj3JbQdoOyH2XLl3S8uXLJaV2e5iTruQAVypI16C//PKLtmzZIkl65ZVXMu3eFQAAIL8hiQkAAADIpjFjxqhx48aSUlujSElJyZP5pv2AWqFCBY0bNy5P5pmfpN3s6tevnxo1auTmaPKvy5cv6/Dhw/Lw8NAbb7zh7nAA3CbSvoNfeeUVFSpUyM3ROHanHytz07hx4zR//nxFR0fbHX/w4EF16tRJe/bskZSa6J3W7VlmLBaLPvnkE3l4eOj06dOaOXNmrsWdmbR9efz48SpTpkyezTer4uPjNXnyZElSly5d9OCDD2Y6zZ49exQVFaXChQvrpZdecnWIOVJQtgNyX3Jysp566inFxcVJkgYMGKCyZcu6OSrAvoJ0Dfriiy9KkmrXrq0nn3zSzdEAAABkncVIawMcAAAAAAAAAKx06NBBW7Zska+vrxo2bKgaNWooICBAUVFR+vPPP3Xo0CGzi0GLxaLPP//cqe7OANx5li5dql27dikmJka//vqr/v77b0mp3R4eOHBANWrUyFJ9U6dONbulnDJliqZOnZrbIQMAAADIYxm3PQwAAAAAwB1u/PjxOa5jyJAhatGiRS5EU/Ds3LlTixcvznE9n3zySS5EAyC74uPjtXPnTu3cudPu+ODgYM2cOdPpruQA3HnWrVunhQsXpnv//fffz3ICEwAAAIDbE0lMAAAAAABkIDe6N2ratOkdm8QUGhqaK+uQJCbAPb766iutWLFCW7Zs0V9//aXw8HBdvXpVklS8eHHVq1dPXbt21ciRIxUcHOzeYAEUGEWKFFGTJk307LPPqlevXu4OBwAAAEA+QXdyAAAAAABkwGKx5LiOL774QsOHD895MAXQggULcqVrKX6+AAAAAAAAAG5vJDEBAAAAAAAAAAAAAAAAcCsPdwcAAAAAAAAAAAAAAAAA4M5GEhMAAAAAAAAAAAAAAAAAtyKJCQAAAAAAAAAAAAAAAIBbkcQEAAAAAAAAAAAAAAAAwK1IYgIAAAAAAAAAAAAAAADgViQxAQAAAAAAAAAAAAAAAHArkpgAAAAAAAAAAAAAAAAAuBVJTAAAAAAAAAAAAAAAAADciiQmAAAAAAAAAAAAAAAAAG5FEhMAAAAAAAAAAAAAAAAAtyKJCQAAAAAAAAAAAAAAAIBbkcQEAAAAAAAAAAAAAAAAwK1IYgIAAAAAAAAAAAAAAADgViQxAQAAAAAAAAAAAAAAAHArkpgAAAAAAAAAAAAAAAAAuBVJTAAAAAAAAAAAAAAAAADciiQmAAAAAAAAAAAAAAAAAG5FEhMAAAAAAAAAAAAAAAAAtyKJCQAAAAAAAAAAAAAAAIBbkcQEAAAAAAAAAAAAAAAAwK1IYgIAAAAAAAAAAAAAAADgViQxAQAAAAAAAAAAAAAAAHArkpgAAAAAAAAAAAAAAAAAuBVJTAAAAAAAAAAAAAAAAADciiQmAAAAAAAAAAAAAAAAAG5FEhMAAAAAAAAAAAAAAAAAtyKJCQAAAAAAAAAAAAAAAIBbkcQEAAAAAAAAAAAAAAAAwK1IYgIAAAAAAAAAAAAAAADgViQxAQAAAAAAAAAAAAAAAHArkpgAAAAAAAAAAAAAAAAAuBVJTAAAAAAAAAAAAAAAAADciiQmAAAAAAAAAAAAAAAAAG5FEhMAAAAAAAAAAAAAAAAAtyKJCQAAAAAAAAAAAAAAAIBbkcQEAAAAAAAAAAAAAAAAwK1IYgIAAAAAAAAAAAAAAADgViQxAQAAAAAAAAAAAAAAAHArkpgAAAAAAAAAAAAAAAAAuBVJTAAAAAAAAAAAAAAAAADciiQmAAAAAAAAAAAAAAAAAG5FEhMAAAAAAAAAAAAAAAAAtyKJCQAAAAAAAAAAAAAAAIBbkcQEAAAAAAAAAAAAAAAAwK1IYgIAAAAAAAAAAAAAAADgViQxAQAAAAAAAAAAAAAAAHArkpgAAAAAAAAAAAAAAAAAuBVJTAAAAAAAAAAAAAAAAADciiQmAAAAAAAAAAAAAAAAAG5FEhMAAAAAAAAAAAAAAAAAtyKJCQAAAAAAAAAAAAAAAIBbkcQEAAAAAAAAAAAAAAAAwK1IYgIAAAAAAAAAAAAAAADgViQxAQAAAAAAAAAAAAAAAHArkpgAAAAAAAAAAAAAAAAAuBVJTC4QFham1atXa/Lkybr33ntVokQJWSwWWSwWDR8+3CXzXLZsmbp166bSpUvLz89PlSpV0iOPPKLt27c7XcfNmzf1r3/9S82aNVOxYsVUuHBh1apVS88++6xOnz7tkrgBAAAAAAAAAAAAAAAAi2EYhruDuN1YLBaH44YNG6YFCxbk2rxiY2PVr18/rV271u54Dw8PTZ48WVOmTMmwnmPHjqlnz546evSo3fGBgYFasmSJevXqleOYAQAAAAAAAAAAAAAAAGu0xORiFStWVLdu3VxW/8iRI80Epo4dO+r777/Xrl279Pnnn6tatWpKSUnR1KlTNWfOHId1REdH67777jMTmEaPHq0NGzbot99+05tvvqmAgABFRUXpoYce0r59+1y2LAAAAAAAAAAAAAAAALgz0RKTC0yZMkXNmjVTs2bNFBISolOnTqlKlSqScrclpo0bN6pz586SpN69e2vFihXy9PQ0x4eHh6tJkyY6c+aMgoODdeLECRUtWjRdPZMnT9a0adMkSf/61780ceJEm/G//fab2rdvr6SkJLVv316bN2/OlfgBAAAAAAAAAAAAAAAAiZaYXOK1115Tr169FBIS4tL5zJgxQ5Lk5eWlTz/91CaBSZJKlCihd999V5IUERGhefPmpasjMTFRH330kSSpdu3aevbZZ9OVad26tUaNGiVJ2rJli3bv3p2rywEAAAAAAAAAAAAAAIA7G0lMBVR0dLQ2bNggSerSpYvKly9vt1zfvn0VGBgoSVqxYkW68Zs2bVJkZKSk1FaiPDzs7xLDhw83h+3VAwAAAAAAAAAAAAAAAGQXSUwF1O7du5WQkCBJat++vcNyPj4+atmypTlNYmKizfitW7eawxnV07RpU/n7+0uStm3blu24AQAAAAAAAAAAAAAAgFt5uTsAZM/hw4fN4Vq1amVYtlatWlq3bp2SkpJ09OhR1alTJ8v1eHl5qXr16vrzzz8VGhqa5XjPnTuX4fi4uDgdOXJEISEhKlmypLy82DUBAAAAAAAA5L6kpCRduXJFklS/fn35+fm5OSLAveLi4nTgwAFJ4vd5AAAAOM0V11aciRZQ1klBjrqSS1OhQgVz+OzZszZJTGn1FC5cWMHBwZnW8+eff+rKlSuKj4+Xr6+v0/FaxwAAAAAAAAAA+cGuXbvUrFkzd4cBuNWBAwfUvHlzd4cBAACAAiy3rq3oTq6Aio6ONocDAgIyLFu4cGFzOCYmxm49mdWRWT0AAAAAAAAAAAAAAABAdtESUwEVFxdnDvv4+GRY1rrFpNjYWLv1ZFZHZvVk5uzZs5mOb926tSRp9erVqlq1apbqB3LTjRs39N1330mS+vbta5PAB7gD+yTyE/ZH5Cfsj8hv2CeRn7A/Ir9hn0R+cuLECfXq1UtSatdZwJ3O+nOwa9culSlTJk/mGx0drcWLF0uShgwZoiJFiuTJfHF7Y79CbmOfQm5jn4IruGu/unjxotmiZ25dW5HEVEBZ9yWYkJCQYdn4+HhzuFChQnbryayOzOrJTGZd3lmrWrWqateunaX6gdwUFRWloKAgSVLNmjUVGBjo5ohwp2OfRH7C/oj8hP0R+Q37JPIT9kfkN+yTyK+8vPiJHLD+HJQpUyZLv+fnhPWxoVy5chwbkCvYr5Db2KeQ29in4Ar5Yb/KrWsrupMroKwz5zLr2u3GjRvm8K3dxqXV40z3cBnVAwAAAAAAAAAAAAAAAGQXSUwFlPWTEOfOncuwrHVXbhUqVLBbz40bNxQREeFUPSVLlrTpWg4AAAAAAAAAAAAAAADICZKYCqg6deqYw0eOHMmwbNp4Ly8v1ahRI1v1JCUl6fjx45JEV28AAAAAAAAAAAAAAADIVSQxFVDNmjWTj4+PJGnLli0OyyUkJGjHjh3mNN7e3jbj27Ztaw5nVM+ePXvM7uTatGmT7bgBAAAAAAAAAAAAAACAW5HEVEAVKVJEnTt3liStX7/eYZdy3333naKioiRJffr0STe+Q4cOCgoKkiQtXLhQhmHYrWfBggXmsL16AAAAAAAAAAAAAAAAgOwiiSmfWrBggSwWiywWi6ZOnWq3zHPPPScptau3J554QsnJyTbjw8PD9cILL0iSgoOD9eijj6arw8fHR08++aQkKTQ0VDNmzEhXZvv27fr8888lSe3bt1ezZs2yvVwAAAAAAAAAAAAAAADArbzcHcDtaOvWrTp27Jj5Ojw83Bw+duyYTatGkjR8+PBszadTp04aOHCgvvrqK61cuVJdu3bV008/rbJly+rAgQN68803debMGUnSu+++q6JFi9qtZ+LEifr666/1999/6/nnn9exY8c0cOBAFSpUSJs2bdJbb72lpKQkFSpUSP/+97+zFSsAAAAAAAAAAAAAAADgCElMLjBv3jwtXLjQ7rht27Zp27ZtNu9lN4lJkubPn6+oqCitXbtWmzZt0qZNm2zGe3h46NVXX9WYMWMc1lGkSBGtWbNGPXv21NGjRzVnzhzNmTPHpkxgYKCWLFmihg0bZjtWAAAAAAAAAAAAAAAAwB66kyvgChUqpDVr1mjJkiXq2rWrSpUqJR8fH1WoUEEPP/ywtm7d6rA7OmvVq1fX3r179e6776pp06YKDg6Wv7+/7rrrLj3zzDP6888/1atXL9cvEAAAAAAAAAAAAAAAAO44tMTkAgsWLEjXZVxWDR8+PEstND388MN6+OGHczTPwoUL6/nnn9fzzz+fo3oAAAAAAAAAAAAAAACArCCJCQAAAAAAAG6TkpKimJgYRUVFKSEhQcnJye4OCS6QlJSkhg0bSpLOnz+vy5cvuzcgFGienp7y9/dXcHCw/Pz83B0OAAAAACCXkMQEAAAAAAAAt4iOjtb58+dlGIa7Q4GLpaSkKCgoyBxOSkpyc0QoyJKSkhQfH6/r168rKChIZcqUkcVicXdYAAAAAIAcIokJAAAAAAAAec5eApPFYpGnp6cbo4KrGIahgIAASZK3tzcJJ8gR6yS4yMhI+fj4qESJEm6MCAAAAACQG0hiAgAAAAAAQJ5KSUmxSWAKCAhQsWLF5O/vT3LLbSo5OVlhYWGSpFKlSpGshhxJTk5WRESEuU9duXJFgYGB8vHxcXNkAAAAAICc8HB3AAAAAAAAALizxMTE2CQwlS9fXoULFyaBCYBTPD09Vbx4cRUvXtx8LyYmxo0RAQAAAAByA0lMAAAAAAAAyFNRUVHmcLFixUheApAtgYGB5vCNGzfcGAkAAAAAIDeQxAQAAAAAAIA8lZCQIEmyWCzy9/d3czQACipfX18zCTLtewUAAAAAUHCRxAQAAAAAAIA8lZycLCm1SyhaYQKQXRaLRZ6enpKklJQUN0cDAAAAAMgpkpgAAAAAAAAAAAAAAAAAuBVJTAAAAAAAAAAAAAAAAADciiQmAAAAAAAAAAAAAAAAAG5FEhMAAAAAAAAAAAAAAAAAtyKJCQAAAAAAAAAAAAAAAIBbkcQEAAAAAAAA4I6xYMECWSwWWSwWnTp1yt3huN3mzZvN9bF582Z3hwMAAAAAuIORxAQAAAAAAAAAAAAAAADArUhiAgAAAAAAAAAAAAAAAOBWXu4OAAAAAAAAAADgHh06dJBhGO4OAwAAAAAAWmICAAAAAAAAAAAAAAAA4F4kMQEAAAAAAAAAAAAAAABwK5KYAAAAAAAAgDvEpk2bNGzYMFWtWlX+/v4KDAxU/fr1NXHiRF24cMHhdFOnTpXFYpHFYpEkxcXFafr06WrcuLGKFCmiIkWKqHnz5vrkk0+UlJSUbvrFixerbNmyKlu2rH7++edM4xw7dqwsFot8fX11/fr1XF0WZ125ckWvvPKKGjVqpODgYPn5+aly5coaMmSItm7dmuG0lStXlsVi0fDhwyVJu3fv1qBBg1ShQgX5+fmpQoUKGjFihI4cOeJULMeOHdMzzzyj+vXrKygoSIUKFVLVqlU1fPhw7dmzJ0fLuXnzZnPbbt68OUd1AQAAAACQEyQxAQAAAAAAALe5uLg4DRo0SJ06ddKiRYt08uRJxcbGKjo6WgcPHtSMGTNUs2ZNrVq1KtO6Ll++rFatWun555/X3r17FRMTo5iYGO3evVsTJkxQ3759lZKSYjPNAw88ID8/P0nSV199lWH9iYmJ+vbbbyVJPXv2VNGiRV22LI6sW7dO1atX15tvvql9+/YpMjJS8fHxOn36tL788ku1a9dO48ePT7ec9syfP1+tW7fWV199pXPnzik+Pl7nzp3TggUL1LBhQy1fvjzD6WfMmKE6dero3//+tw4ePKioqCjFxcXp5MmTWrhwoZo3b67Jkydne1kBAAAAAMgvSGICAAAAAAAAbmOGYahfv35m8lDv3r21ePFibdu2Tdu3b9eHH36oihUr6saNG+rXr1+mLfv07dtXhw8f1pNPPqmff/5Zv//+u5YuXaratWtLklatWqW5c+faTFOkSBF169ZNkrRixQrFxcU5rP+HH37QtWvXJEmDBw926bLYs2/fPvXu3VtRUVHy9vbWM888o02bNmnXrl2aPXu2qlSpIkmaOXOmJk2alGldjz32mEqVKqWPP/5YO3fu1JYtW/TCCy/I19dX8fHxGjx4sMM4p0+frokTJyoxMVENGjTQrFmztH79eu3Zs0dLlixRq1atZBiGpk2bpo8++ijLywoAAAAAQH7i5e4AAAAAAAAAgIxcjYnP9rSFfb3k5+1pd9y1GwkyDCNb9Rby8ZS/j/2f1iJuJig5xfl6iwf4ZisGZ82bN09r1qyRt7e3Vq5cqR49etiMb9mypYYMGaJ27drp0KFDevrppzPsLm337t1at26dOnToYL7XuHFjde/eXXXq1NHly5f16aefauzYsTbT9e3bVytXrlRUVJRWr16tfv362a1/6dKlkqTAwED16tXLpctiz5gxY5SQkCBPT0+tXr3aTL6SpGbNmql///5q27atDh8+rBkzZmjo0KGqW7eu3br279+vSpUqaceOHSpdurT5/j333KPu3burW7duSkxM1OOPP65du3bZTHv48GG9/PLLkqQpU6ZoypQpZnd+ktSkSRMNHDhQw4YN05dffqmXX35ZQ4YMSddyFQAAAAAABQVJTAAAAAAAAMjXmryxPtvTvv6PuhraqrLdcV3e36JrNxKyVe9TnWvoma417Y7r/9l2HQ2LcbquU+/cl60YnGEYht59911J0pNPPpku6SdN0aJFNX36dPXs2VPbtm3T0aNHVaNGDbtlJ0yYYJPAlKZYsWIaMWKE3nnnHR04cECRkZEKCgoyx3fs2FFFixbV9evXtWTJErtJTDExMVq5cqUk6cEHHzS7oHPVstxq165d2r17tyRp9OjRNglM1vXPmTNHbdu2VUpKij799FPNnDnTYZ3vvfeeTQJTmo4dO2r06NGaNWuWdu/erT179qhp06Y20yUmJqpp06bpEpjSeHh46OOPP9by5csVExOjb7/9VqNHj3ZqWQEAAAAAyG9IYgIAAACQJQlJKTp19YaOXo7R+YibctTQxKi2VeTtmb4H69NXb+iHg5eyPf+HW1RUoJ+33XEpKYY8PNLf4AMA4E51+PBhHT9+XJIctnyU5p577jGHt2/f7jDx59Yu3qw1adJEUmrC0cmTJ9WwYUNznLe3t3r37q1Fixbphx9+UEREhIKDg22mX7FihWJjY+3OxxXLcqv16/+XMDdq1CiH5dq0aaPatWsrNDTUZppbFS1aVP/4xz8cjh85cqRmzZplzts6iWnVqlWSUpO57CUwpQkODlb9+vW1Z88ebd++nSQmAAAAAECBRRITAAAAALviEpN1/EqMjoXF6OjlGB0Ni9axsBidunrTqS5yhrWqLHu99xy/EqN3fjiS7bjuq1/GbhJTYnKKGr62ThWK+at6qQDVKFUk9X9IgCoXLywfr/QJVQAA3O727NljDrdq1crp6S5dcpxwXKtWLYfjihUrZg5HR0enG9+nTx8tWrRI8fHx+vbbb/Xoo4/ajE/rSq5s2bLq2LGjzThXLMutDh48KEny8fGxScCyp0WLFgoNDdXRo0eVkJAgHx+fdGUaNWokLy/HP8E2bNhQPj4+SkhI0IEDB8z3T58+rStXrkiSJk2apEmTJjkVf1aWFQAAAACA/IYkJgAAAAB2fbLxmD7ZdMzdYTjt9NUbupGQrCOXonXkUrSki+Y4Tw+LKhf/X3JTjZAAVSuZ+lfIx06mFQAAt4mwsLBsTXfz5k2H4/z9/R2O8/D4X9JwcnJyuvHNmzdXpUqVdPr0aS1ZssQmiSksLMxs1WjgwIE2daWNz46MluVW165dk5SajJVR8pEks4s4wzB0/fp1hYSEpCtTqlSpDOvw8vJSsWLFdOnSJXPeUt4sKwAAAAAA+Q1JTAAAAMAdIuJmQmqrSv/fstKxKzGKvJmg/45va7d8jZCAPI4wZ45ejnE4LjnF0PErN3T8yg39dOiy+b7FIlUo6q8apQI0qWdtVS9VsJYZAO4Uv7/SJdvTFvZ1/PPX+n+2l2Fk3rqgPRklwS5/rJVTrRbmBetEolWrVqly5cpOTZdZ8k12WSwWDRw4UO+++65++eUXnT9/XuXKlZMkffPNN0pKSpJkv8u6vFyWjLpvy4t6rJd18uTJ6t+/v1PTFS5cOFvzAwAAAAAgPyCJCQAAALiNGIah8JgEs+u3/3UFF6PwmHi700TFJdrtni2zhJ6QQF9VLeG4JSNH9+yKF/ZVp1rZvzHqZ6+POknHwhwnMTliGNKZazd15tpNTeld126Z6zcS9OOhS6pRKkDVSwUo2D99VzEAANcqHuDrknqLFXbNd3p+OlYUL17cHA4ODla9evXcGE2qhx9+WO+++65SUlK0bNkyPffcc5L+15VcrVq11Lhx43TT5cWypHWHd/XqVSUlJWXYGlNa120Wi0VFixa1W+by5ct230+TlJRk0/pTGutl9fb2zhfbDQAAAAAAVyOJCQAAACjgjlyK0sLfTpmtK0XcTMzS9MfCYtS4Yvobb9VKBsjTw6IyQX5mAk+NUkVUPSR12F7ikzPurhCs+cObZWvajAxtVVktqhbX0bDo1HURFqOjYdG6HGU/ecuar5eHyhUtZHfcgfORmvTdAfN1iQDf/62P/18XNUOKqISLbrADAJATjRo1Moe3bdumtm3tt8CYl+rWrau7775b+/fv19KlS/Xcc8/p5MmT2r59uyT7rTBJebMsaclCCQkJ2rdvn5o2beqw7K5duyRJNWrUkI+P/cS1ffv2ZZgMtX//fiUkJNjMW5KqVq2qoKAgRUZGatu2bdlaFgAAAAAAChqSmAAAAIACLio2Sct2nc329Mcu209i8vP21KHXujts+Si/CfL3VvMqxdS8SjGb96PiElNbpfr/JK+jl6N1NCxG567HmmXSErbsOXpLC0/hMfEKj4nX9hNXbd6vXSZQPeqWVvd6IborpEiudUMDAEBONG7cWOXLl9e5c+c0Z84cPfXUU/Lz83N3WBo8eLD279+vvXv3KjQ0VN9995057uGHH7Y7TV4sS5cuXfTyyy9LkubPn+8wiWn79u06fPiwOY0j165d06pVq9SnTx+74+fPn28z7zSenp7q2bOnli1bpnXr1ik0NFS1a9fO8vIAAAAAAFCQeLg7AAAAAACOJSWn6Lfj4XpzzWElJafYLVMjk27frHl7WlQzJEA965fWk51r6ONBjdSuZgmH5QtKAlNGAv281bhiUQ1oVkEv9aytL0Y019YXOunw6921ekJbffDQ3XqsQzWH0x8Li3ZqPqEXo/TB+r/V49+/quOMzXr7h1D9cea6UlKM3FoUAACyzMPDQy+99JIk6cSJExo6dKji4x23UhgVFaVPPvnE5XENGjTITPhdsmSJli1bJklq1aqVqlataneavFiW5s2bm4lLc+fO1YYNG9KViYyM1NixY82Yxo0bl2Gd//znP+12K7dlyxbNmTNHktSkSRM1a2bbUuWkSZPk6emplJQU9evXT+fOnXM4j+TkZC1ZsiTDMgAAAAAA5He0xAQAAADkM3GJydp6NFw/Hbqk9aGXdf3/u4freFcpta6ePuGoaGEflQjwUXhMgvmer5eHqpVM7e4steuzIqpeKkCVivvL25NnGSTJ38dL9coFqV65oAzLlSzip7tCiuhEeIwSk51LSDp19aZmbzmhL7ad0h+vdlWAL5deAAD3eeyxx/Tzzz9rxYoVWr58uf744w+NHTtWzZs3V1BQkKKionTkyBFt3rxZK1eulJ+fn8aPH+/SmMqXL6/27dtr8+bNmjlzpiIiIiQ57kouL5dl7ty5atGihRISEtSzZ09NmDBBvXv3VuHChbV371698847OnHihCTpueees+kG7lZ33323Dh8+rCZNmmjSpElq3ry54uPjtXbtWn3wwQdmV3MzZ85MN239+vU1Y8YMPfPMMzp8+LDq1aunMWPGqFOnTgoJCVFcXJxOnTql7du369tvv9XFixd14MABlS9fPkvLCwAAAABAfsEv6QAAAEA+EB2XqE1/XdFPhy5p85Ew3UhITlfmx0OX7CYxSdLItlXkYbGoRqkA1ShVROWKFnLYPRqy5p9da+qfXWsqKTlFp6/dTO2aLux/3dIdvxKjuET7rWS1q16CBCYAgNtZLBZ9/fXXeuqpp/TZZ5/p+PHjev755x2WL1WqVJ7ENXjwYG3evNlMYPLy8tKAAQMynCYvlqVhw4ZatWqV+vfvr6ioKL333nt677330pV74okn9Pbbb2da1/jx4zVu3Di7yVQ+Pj5auHChWrRoYXf6p59+WoULF9bTTz+tyMhITZ8+XdOnT7db1sfHJ190FQgAAAAAQHbxazoAAADgJldj4rU+9LJ+PHhJ245dVYKD7uLSrDt0WVN715WHneSkxztUd1WY+H9enqmtW1UrGaDudf/3fnKKoT2nrunHQ5e07tBlnY+INcd1r1faYX2T/3tQV6Lj1aNeaXWsVUqBft6uDB8AcIfz9vbWp59+qnHjxmnu3LnavHmzzpw5o5iYGAUEBKhKlSpq0qSJ7r33XvXq1StPYurXr5/Gjx9vdgnXrVs3lSxZMtPp8mJZunXrpmPHjunf//631q5dqxMnTig+Pl4hISFq166dHnvsMbVt29apuh599FHVq1dPH3zwgbZu3arw8HCVLFlSnTt31gsvvKA6depkOP3o0aN1//33a/bs2Vq3bp3++usvRUREyNfXV+XKlVP9+vXVtWtXPfjggypRwnE3wQAAAAAA5HckMQEAAAB56HxErNYduqQfD17S7lPXlOJc72SqVy5QPeqWVkJyivw8PF0bJLLE08OiFlWLq0XV4prcq44Ono/Sj4cuav3hMHWpHWJ3msTkFK3cf0ERNxP1w8FL8va0qHW1EupRr7S61A5RySK+ebwUAIA7Rf369fXRRx9lebqpU6dq6tSpmZbr0KGDDMO5E5zg4GDFxcVlOZY02V2W4cOHa/jw4ZmWK1mypN588029+eab2YjOVsuWLfX1119ne/qQkBBNnjxZkydPznEst8rKNgMAAAAAwJVIYgIAAADy0Ls/HNHK/RcyLWexSM0qF1P3uqXVrU6IKhTzz4PokFMWi0X1ywepfvkgTexey2G5XSevKeJmovk6MdnQlr+vaMvfV/SS5YCaVSqmbnVD1L1uabY9AAAAAAAAAOCOQBITAAAAkIe61y3tMInJ29OiNtVLqEfd0upSJ0QlAmiN53b106FLDscZhrTr1DXtOnVNb6wJVb1ygepep7R61Cut6qUCZLGk704QAAAAAAAAAICCjiQmAAAAIBckpxjafeqafjx4Sb8evaLVE9qpkE/6bt863FVSPl4eSkhKkST5+3iqw10l1b1uaXWsVUqBft55HTrc4KnONVS3bKB+OnRZW4+GKyE5xWHZg+ejdPB8lN77+W9VLVFY3euV1rgO1dhXAAAAAAAAAAC3FZKYAAAAgGyKT0rWtmPh+ungZf0celnXbiSY4345ekXd65ZON01hXy/1blBWFktqq0ztapSQn3f6ZCfc3ooH+OqhZhX1ULOKio5L1Oa/rujHQ5e0+UiYbiQkO5zuRPgNfbn9tJ7pUjMPowUAAAAAAAAAwPVIYgIAAACywDAMbT0Wrm/2nNOmI2GKiU+yW+6nQ5fsJjFJ0nsD7nZliChgivh5q/fdZdX77rKKS0xNjPvx4CWtD72s6zcT05XvVLuUfLw87NaVnGLI04Pu5gAAAAAAAAAABQ9JTAAAAIATkpJTtObARc3eckKHL0ZlWn794ctKTE6Rt6f9ZBPAHj9vT3WuHaLOtUOUlJyiXaeuad2hy/rp0CVdjIyTJPVwkBwnSR9uOKodJ67qsfZV1aFmKXmQ0AQAgFucOnXK3SEAAAAAAFDgkMQEAAAAZOBmQpK+3n1Wn289qXPXYzMtX6dMoHrUK63udUvLiwQS5ICXp4daVyuh1tVKaErvOvrzXKR+OnRJ7e8qabf8zYQkLd5+StdvJmrXyWuqGRKg0e2q6h8NyzlsuQkAAAAAAAAAgPyCJCYAAADAgaU7z+hfPx1RhJ0uvdJYLFLTSkXVvW5q4lKFYv55GCHuFBaLRXdXCNbdFYIdllm+55xN93N/X47RxG//1Hvr/tbItpU1qHlFFfHzzoNoAQAAAAAAAADIOpKYAAAAAAf8vD0cJjBVKVFYw1tX1r31S6tUEb88jgxIb/WfF+y+fykqTm+tPaKPNxzTwy0ramSbKgoJZJ8FAAAAAAAAAOQv9CkAAAAAOND77rIqG2Sb7NGwQrA+e6Sx1v+zvYa1rkwCE/KNJY+21PR+DVSjVIDd8dHxSZq95YTavrtRE5fv19HL0XkcIQAAAAAAAAAAjtESEwAAAO5YKSmGNv8dptKBhVSnbGC68d6eHhrZtoreWBOqzrVKaWz7ampWuagsFosbogUy5uPlof5NK+jBxuW1+e8wfbblhHadvJauXGKyoeW/n9Py38+xXwMAAAAAAAAA8g2SmAAAAHDHSUhK0X/3ndfcX0/o78sx6l43RLOHNLVbdmDzimpfs6RqhBTJ4yiB7PHwsKhTrRB1qhWivWeua84vJ/TjoUsyjPRlNxwJ04YjYXq0bRW90qtO3gcLAAAAAAAAAMD/I4kJAAAAd4zouEQt23VG87ee0qWoOPP9dYcv6/iVGFUrmb4brgBfLxKYUGA1qlhUsx5popPhNzTv1xNa/vs5JSSlpCvXuXaIG6IDAAAAAAAAAOB/PNwdAAAAAOBql6Pi9PYPoWr99ka9tfaITQKTJBmGNO/XE26KDnC9KiUK680+9bXthU6a0Km6ggp5m+PuLh+kllWLuTE6AAAAAAAAAABoiQkAAAC3saOXozXnlxP6ft95JSbb6Uvr/9UoFaDmVUjiwO2vZBFfPdvtLj3Wvpq+2XNW8349qTH3VJPFYrFbft2hS9px4ppGtauicsGF8jhaAAAAAAAAAMCdhCQmAAAA3FYMw9Ce09c1e8txrQ8Ny7Bs88rFNLZ9VXW8q5Q8POwncQC3o8K+XhrRpoqGtKzkMIHJMAx9vPGYDpyP1MLtp9S7QRmNuaea6pQNzONoAQAAAAAAAAB3ApKYAAAAcNvYdCRMH208qr1nIhyWsVik7nVKa0z7qmpcsWjeBQfkQ16ejnsY337iqg6cj5QkJacY+n7fBX2/74La1Sihx9pXU+tqxR0mQAEAAAAAAAAAkFUkMQEAAOC2sfPkNYcJTD5eHurXpLwebVtFVUsG5G1gQAE079eTdt//9Wi4fj0arnrlAjXmnmrqWa90hslQAAAAAAAAAAA4gyQmAAAA3DZGtKms+VtPKiE5xXwvqJC3hrSspGGtK6tkEV83RgcULK/dX1cVi/nr691nFZuYnG78wfNRenLZXv2raCGNbldV/ZuWl78Pl5gAAAAAAAAAgOzhcVkAAAAUKJej4nT9RoLdcSGBfurTqJwkqVxwIU3uVUe/vdhJz3W/iwQmIIsqFPPX1Pvr6rcXO+nZrjVVvLCP3XLnrsdqyspDav3ORr3/89+KvJmYx5ECAJA1CxYskMVikcVi0alTp9wdDgAAAAAA+H88JgsAAIACIS4xWZ9vPamZm45pVNsqerbbXXbLjW1fVa2rF1fP+mXkTRdXQI4VLeyjCZ1raPQ9VfXt7+c079cTOnX1ZrpyETcT9dGGo/pyx2m90OMuPdSsohuiBQAAAAAAAAAUVCQxAQAAIF8zDEPrDl/Wm2tCdeZaauLEou2n9Vj7airsm/50tmrJAFUtGZDXYQK3PT9vTz3SspIGNa+odYcu6bNfTmj/2Yh05a7dSNCxsJi8DxAAAAAAAAAAUKCRxAQAAIB86+/L0Xp91WFtPRZu835kbKK+3n1WI9tWcVNkwJ3L08Oie+uXUY96pbXr5DXN+eWENhwJM8eXCEhtuQkAAAAAAAAAgKwgiQkAAAD5TuTNRH2w/m8t3nFaySlGuvEWS2prLwDcx2KxqEXV4mpRtbj+vhyt99f9rR8PXdLE7ncp0M/b3eEBAAAAAAAAAAoYkpgAAACQbyQlp2jZ7rN6f91fun4z0W6ZppWKaur9dVWvXFAeRwfAkZohRfTZkCbac+qaGlUs6rDc4u2nFOTvo94NyshiseRhhAAAAAAAAACA/M7D3QEAAAAAkrT9+FX1+nirXv3+oN0EpjJBfvpwYEMtf6wVCUxAPtW0cjF5ethPTroQEas314bqyWV79dDsHTp4PjKPowMASNKmTZs0bNgwVa1aVf7+/goMDFT9+vU1ceJEXbhwweF0U6dOlcViMZNQ4+LiNH36dDVu3FhFihRRkSJF1Lx5c33yySdKSkpKN/3ixYtVtmxZlS1bVj///HOmcY4dO1YWi0W+vr66fv16ri6Ls65cuaJXXnlFjRo1UnBwsPz8/FS5cmUNGTJEW7duzXDaypUry2KxaPjw4ZKk3bt3a9CgQapQoYL8/PxUoUIFjRgxQkeOHHEqlmPHjumZZ55R/fr1FRQUpEKFCqlq1aoaPny49uzZk9NFlSTFxsbqrbfe0t13363ChQurePHiatOmjebOnauUlBRt3rzZ3Ac2b96cK/MEAAAAAMAaLTEBAADArc5eu6m3fwjV2gOX7I739fLQ2Huq6rEO1eTvw+krUFC988MRxSWmSJJ2nbqm3p9s1cBmFfRct7tUPMDXzdEBwO0vLi5OI0aM0FdffZVu3MGDB3Xw4EHNmjVLy5YtU+/evTOs6/Lly+rRo4f27dtn8/7u3bu1e/durVu3Tt9//708PP73/OQDDzygcePGKS4uTl999ZV69OjhsP7ExER9++23kqSePXuqaFHbVv5yc1kcWbdunfr376+oqCib90+fPq3Tp0/ryy+/1BNPPKGPPvrIZjntmT9/vsaOHWuT3HXu3DktWLBAy5Yt0+LFi9W/f3+H08+YMUMvvfSSEhNtE/1PnjypkydPatGiRXrllVf0+uuvZ2NJU126dEmdOnVSaGio+d7Nmzf122+/6bffftN//vMf/fOf/8x2/QAAAAAAOIOWmAAAAOA2hy5Eqsv7WxwmMPWsX1rr/9le/+x2FwlMQAF2+EKUVu63bRHDMKRlu86qw4zNmvfrCSUmp7gpOgC4/RmGoX79+plJP71799bixYu1bds2bd++XR9++KEqVqyoGzduqF+/fpm27NO3b18dPnxYTz75pH7++Wf9/vvvWrp0qWrXri1JWrVqlebOnWszTZEiRdStWzdJ0ooVKxQXF+ew/h9++EHXrl2TJA0ePNily2LPvn371Lt3b0VFRcnb21vPPPOMNm3apF27dmn27NmqUqWKJGnmzJmaNGlSpnU99thjKlWqlD7++GPt3LlTW7Zs0QsvvCBfX1/Fx8dr8ODBDuOcPn26Jk6cqMTERDVo0ECzZs3S+vXrtWfPHi1ZskStWrWSYRiaNm2aPvrooywvqyQlJSWpV69eZgJTt27dtGLFCu3Zs0ffffedunTpop9++kmvvPJKtuoHAAAAAMBZ3AkCAACA29QuHahapYto/znbbqVqlS6iyb3rqHW1Em6KDEBuql2miD57pLHeWBOqc9djbcZFxyXpjTWhWrbrjF7tVUcd7irlpigB5Gs3wrM/rU9hybuQg3qvSjKyV693odS67bl5TTKykJxZ2LXnPPPmzdOaNWvk7e2tlStXpmsFqWXLlhoyZIjatWunQ4cO6emnn86wu7S01pY6dOhgvte4cWN1795dderU0eXLl/Xpp59q7NixNtP17dtXK1euVFRUlFavXq1+/frZrX/p0qWSpMDAQPXq1culy2LPmDFjlJCQIE9PT61evdpMvpKkZs2aqX///mrbtq0OHz6sGTNmaOjQoapbt67duvbv369KlSppx44dKl26tPn+Pffco+7du6tbt25KTEzU448/rl27dtlMe/jwYb388suSpClTpmjKlClmd36S1KRJEw0cOFDDhg3Tl19+qZdffllDhgxJ13JVZmbPnq3ff//dXPbZs2fbzKNPnz4aNWqU5s+fn6V6gdtBWFiYdu3apV27dpmtzV29elWSNGzYMC1YsCDX57ls2TJ98cUX+vPPPxUREaGQkBC1a9dOTzzxhFq1apXr8wMAAADyE5KYAAAA4DYeHhZNub+u+n76myQp2N9bz3a7S4OaVZCXJ42GArcLi8WiHvXKqMNdpTTv1xOauem4YhOTbcocv3JDw7/Yrc61SumVXnVUpYSDxAAAd6bp1bI/bc8ZUvPR9sfNbCbdvJq9etu/KHV00ArPF/dKV444X9fUyMzLZJNhGHr33XclSU8++aTDbtyKFi2q6dOnq2fPntq2bZuOHj2qGjVq2C07YcIEmwSmNMWKFdOIESP0zjvv6MCBA4qMjFRQUJA5vmPHjipatKiuX7+uJUuW2E1iiomJ0cqVKyVJDz74oPz8/Fy6LLdKS1SQpNGjR9skMFnXP2fOHLVt21YpKSn69NNPNXPmTId1vvfeezYJTGk6duyo0aNHa9asWdq9e7f27Nmjpk2b2kyXmJiopk2bpktgSuPh4aGPP/5Yy5cvV0xMjL799luNHu1gf3fg008/lSSFhITogw8+sFvmww8/1KpVq3TlypUs1Q0UdCEhIXk2r9jYWPXr109r1661ef/MmTNasmSJli1bpsmTJ2vKlCl5FhMAAACQ17gzBAAAAJeLjkt0OK5xxaLq36S8hreurM3PddCQlpVIYAJuU37enhrfqYY2PddBDzQsa7fMhiNh6vbBFr29NjTD7w4AgHMOHz6s48ePS5LDlo/S3HPPPebw9u3bHZa7tYs3a02aNJGUmnB08uRJm3He3t7q3bu3pNQu4yIiItJNv2LFCsXGxtqdjyuW5Vbr1683h0eNGuWwXJs2bczu86ynuVXRokX1j3/8w+H4kSNH2p23lNotn5SazGUvgSlNcHCw6tevLylryypJFy9e1OHDhyVJAwYMkL+/v91yAQEBGjBgQJbqBm43FStWtJvYmFtGjhxpJjB17NhR33//vXbt2qXPP/9c1apVU0pKiqZOnao5c+a4LAYAAADA3bg7BAAAAJdJSErR3F9OqPXbG7XjhONWDv7Vr4Gm3l9Xwf4+eRgdAHcpHeSnfw9spP+Ma6UG5YPSjU9MNjT7lxPqOGOLvtlzVoaRza6eAADas2ePOdyqVStZLBaHfwEBAWbZS5cuOayzVq1aDscVK1bMHI6Ojk43vk+fPpKk+Ph4ffvtt+nGp3UlV7ZsWXXs2NHly3KrgwcPSpJ8fHzUsGHDDMu2aNFCknT06FElJCTYLdOoUSN5eTluDL9hw4by8Uk9Bz5w4ID5/unTp81WjyZNmpThslosFnPdZGVZb51ns2bNMizbvHnzLNUN3A4mT56sVatW6dKlSzp9+rRNd4u5aePGjfrqq68kSb1799bPP/+sf/zjH2rWrJlGjhypHTt2qGLFipKkF154QdevX3dJHAAAAIC7kcQEAAAAl9j0V5h6fPiL3lwbquj4JL226rCSU+wnImT0ZDmA21eTSsX0/eNt9K9+DVQiwDfd+PCYeK07dInvCADIgbCwsGxNd/PmTYfjHLXWI6V2b5YmOTk53fjmzZurUqVKkqQlS5bYjAsLCzNbIxo4cKBNXWnjsyOjZbnVtWvXJKUmY2WUfCTJ7CLOMAyHCQWlSpXKsA4vLy8z8Stt3lLeLOut88ws1rzsVgvIL1577TX16tXL5fv/jBkzJKV+J3z66afy9PS0GV+iRAmzO82IiAjNmzfPpfEAAAAA7pLxlTgAAACQRSeuxGja6sPa9NcVm/dDL0bpq91nNLhFJTdFBiA/8vCwaEDTCrq3Xml9vPGYvth2UonJqQmP3p4WvXxfHTdHCCBfmHg8+9P6FHY87ondkrLZ2pt3IcfjRvwgGSnZqzeXWScSrVq1SpUrV3ZquswSWrLLYrFo4MCBevfdd/XLL7/o/PnzKleunCTpm2++UVJSkiT7Xdbl5bLkVgJtduuxXtbJkyerf//+Tk1XuHAG+3smSBoG3CM6OlobNmyQJHXp0kXly5e3W65v374KDAxUVFSUVqxYoYkTJ+ZlmAAAAECeIIkJAAAAuSIqLlEfbziqBb+dMhMQbnUsLCaPowJQUBTx89ZLPWtrYLMKemNNqDYeCdPItlVUpUT2b8YCuI0ULuGieou7pl7/YpmXySPFi/9vGYODg1WvXj03RpPq4Ycf1rvvvquUlBQtW7ZMzz33nKT/dSVXq1YtNW7cON10ebEsaa0iXb16VUlJSRm2xpTWdZvFYlHRokXtlrl8+XKG80tKSrJp/SmN9bJ6e3u7bLtZx51ZrJmNB5A9u3fvNrukbN++vcNyPj4+atmypdatW6fdu3crMTFR3t7eeRUmAAAAkCfoTg4AAAA5kpJi6OvdZ9RpxmbN/fWk3QSmu8sH6T/jWmtK77puiBBAQVK1ZIDmD2+mBSOaaXzH6g7LbTxyWT8evCTDyGYLKgBwh2jUqJE5vG3bNjdG8j9169bV3XffLel/iUsnT57U9u3bJdlvhUnKm2VJSxZKSEjQvn37Miy7a9cuSVKNGjXk4+Njt8y+ffvM1qXs2b9/v5m8YJ2oVLVqVQUFBUly7XarX7++Obx79+4My2Y2HkD2HD582ByuVatWhmXTxiclJeno0aMujQsA7kQpKSmKi4tTdHS0rl27prCwMF25ckXly5dX+fLlFRYWpsuXL+vatWuKjo7O8DwPAJA9tMQEAACAbNtz6ppeW3VYB85H2h1fIsBXL/S4Sw82Li8PD7qnAOC8Dnc57vonNiFZr6w4qAuRcWpTvbgm96qru0oXycPoAKDgaNy4scqXL69z585pzpw5euqpp+Tn5+fusDR48GDt379fe/fuVWhoqL777jtz3MMPP2x3mrxYli5duujll1+WJM2fP19Nmza1W2779u1m4kGXLl0c1nft2jWtWrVKffr0sTt+/vz5NvNO4+npqZ49e2rZsmVat26dQkNDVbt27SwvT2bKli2r2rVrKzQ0VMuXL9e7776rQoXSd5V448YNffPNN7k+fwDSuXPnzGFHXcmlqVChgjl89uxZ1anjXNfL1vOw5+LFi+ZwdHS0oqKinKo3p2JiYuwOAznBfoU0hmEoKSlJSUlJ8vX1lYdH+rY9YmNjdfr0aSUnJyspKUkpKfa7hE77fj5//rzN+xUqVFCJEvZbjb1w4YI8PDzk5eUlT09PeXl52fzRle+di+8puIK79qvo6Ohcr5MkJgAAAGRZTIqXXvzvEa09dMXueB9PD41sW0VPdKymIn40bw8gd3225bguRMZJkrYdu6qeH/2qR1pU1DNdayrY335LGABwp/Lw8NBLL72kxx9/XCdOnNDQoUO1ePFi+fr62i0fFRWlRYsWafz48S6Na9CgQXrhhRdkGIaWLFmi77//XpLUqlUrVa1a1e40ebEszZs3V9OmTbVnzx7NnTtXDz74oDp37mxTJjIyUmPHjjVjGjduXIZ1/vOf/1Tr1q0VEhJi8/6WLVs0Z84cSVKTJk3UrFkzm/GTJk3SN998o+TkZPXr108//fSTwwSH5ORkffXVV2rfvn2mSRC3GjdunJ588kldunRJzz77rD799NN0ZZ555hmFhYVlqV4AzrG+8RMQEJBh2cKF/9fVclZuTlknP2Vm8eLFZktweWnx4sV5Pk/c/tivbi+enp7y9vY2k4DShjN6L82+ffsUFxeXrk4/Pz81bNgw2zGtX79e169ftzuuRYsWGSYqJSUlKTEx0eZ/2nBkZKRu3ryZ7bhQcPA9BVfIy/0qMtL+A+45QRKTi50+fVofffSR1qxZo7Nnz8rX11fVqlXTgAED9MQTT8jf3z9b9Z46dUpVqlTJ0jSVKlXSqVOn0r3foUMHbdmyxak66KoBAACcTyystTGVlBRpP4GpS+0QvXJfbVUuUdjueADIictRcfpsy3Gb95JTDC3cflr/3X9Bz3atqYdbVJInrb8BgOmxxx7Tzz//rBUrVmj58uX6448/NHbsWDVv3lxBQUGKiorSkSNHtHnzZq1cuVJ+fn4uT2IqX7682rdvr82bN2vmzJmKiIiQ5Lgrubxclrlz56pFixZKSEhQz549NWHCBPXu3VuFCxfW3r179c477+jEiROSpOeee86mG7hb3X333Tp8+LCaNGmiSZMmqXnz5oqPj9fatWv1wQcfKCkpSV5eXpo5c2a6aevXr68ZM2bomWee0eHDh1WvXj2NGTNGnTp1UkhIiOLi4nTq1Clt375d3377rS5evKgDBw5kK4npiy++0N69ezVr1iydPHlSjz32mCpUqKCzZ8/q008/1bp168zkLgC5y/qmuqOuKdNYJ23Gxsa6LCYAcLW0FopuTToKCwuz2xpSQEBAhudcmbFOaLKW0+7gHE3vTEtLaYlX9hw/ftxhElPdunVlGIbDBCjrYUctSwFAfkYSkwutWrVKjzzyiE3Tqzdv3tSePXu0Z88ezZs3T2vWrFH16tXzJJ677rorT+YDAABub6W8YuVrSVaSYdsEc/VSAXq1Vx21r1nSTZEBuBOUKuKrGf3v1ttrQ83WmNJE3EzUq/89pO/2ntd7/e9W1ZIZP8kOAHcKi8Wir7/+Wk899ZQ+++wzHT9+XM8//7zD8qVKOe7SMzcNHjxYmzdvNhOYvLy8NGDAgAynyYtladiwoVatWqX+/fsrKipK7733nt5777105Z544gm9/fbbmdY1fvx4jRs3zm4ylY+PjxYuXKgWLVrYnf7pp59W4cKF9fTTTysyMlLTp0/X9OnT7Zb18fHJVvd6Xl5eWr16tTp16qS//vpLP/74o3788UebMt26ddOzzz6r7t27Z7l+ABmz/twmJCRkWDY+Pt4cttf1oyNnz57NcPzFixfVvHlzSdKQIUNUrlw5p+vOiZiYGLOlgCFDhmTaEhXgDPar/CUlJUU3btxQTEyMYmJiFB8fr6SkJIeNJtx77712z2fi4uIUGhqa7Th69+6t4ODgdO8bhqF9+/bZnca627e0bjnLly9v001dv379XBJvly5dshyvPRaLRV5eXvL19VVAQIACAwNtWvWDe/A9BVdw1351/vz5TK+Ls4okJhfZu3evHnroIcXGxiogIECTJk1Sx44dFRsbq6+++kpz587V33//rfvuu0979uxRkSJFslR/uXLldODAgUzLvf3221q6dKkkadiwYRmWbdq0qb744ossxQEAAO483paU/2PvvuObqtc/gH+yk+696KSbttCWvaeAiLhAFEXhihNcV0Xlp17U63WgqKioOEBBxYUCIqgoe9MBdFG6994jbdbvDyQSkrQF2qbj8369eL3S8/2ec56kh6Q55znPg1GKEvzZdL4cva1cjMenhWDhaD9IRMa95YmIOpNAIMD1Q7wwLdwdH+7LxMf7MtGiNryzMCGvBte+ewBPzwzDojH+ELIqExERJBIJ1q5diwcffBCffPIJ9u7di7y8PDQ0NMDGxgYBAQEYOnQorr32WsyePbtbYpo7dy6WLVumvyg/ffp0uLq2nxDfHc9l+vTpyMjIwDvvvINff/0VWVlZaGlpgbu7O8aPH48HHngA48aN69C2lixZgsjISLz99ts4ePAgKioq4OrqiqlTp+Lpp5/GoEGD2lz/3nvvxZw5c/Dxxx/j999/x9mzZ1FTUwOZTIYBAwYgKioK11xzDW655Ra4uLhc0fP18vJCQkICVq9ejc2bNyMzMxMymQxhYWG46667cP/992P//v1XtG0iatvF1wbaaxHX2Niof3w5F6Yup0Kbra0t7OzsOjy/s1y4uE7UmXhcdT+1Wo3a2lrU1taipqYGDQ0Nl9XlRSqVmvydXU7i5uVsFwDCwsL0reou/Lu4klJdXR327NkD4Hxy0YXtXHhepiouSSQSeHh4QKVSGfzraOUne3t7k/G2l+x6qQsVm1QqFRoaGiASieDp6XlZ26Cuxfcp6grdeVxdXNCnszCJqYs8+uijaG5uhlgsxu+//47Ro0frx6ZMmYLg4GAsX74c6enpeOutt7By5crL2r5EImm3bKJGo8HevXsBnP/icdNNN7U539ra+qpKMRIREVH/ESytRZVTBMIHOOCJa0LgbCNrfyUiok6kkIrw72tCcOswb7y6Mw07ThcbjLeotXjplxT8llyCVXOHwNf5ylp5ExH1NVFRUVizZs1lr7dy5coOnb+aNGlShy9UOTg4GLRRulxX+lwWLVqERYsWtTvP1dUVr7zyCl555ZUriM7QqFGj8O23317x+u7u7njhhRfwwgsvXHUs5igUCvzf//0f/u///q/L9kFExi5OMCooKMCwYcPMzr24opKPj0+XxkVEdCVqa2uRlJR0xeu31Z7tAqFQaJBw1N4/sVgModD8jZfu7u5XFGtb7eIUCoXJDjkXJxW19e/i9qEXU6lUVxTrBfb29mbHcnNzoVAoYG9vb3b/RETdgUlMXeD48eM4cOAAAOCee+4xSGC64IknnsD69euRmpqKd999F//3f/8HiUTSqXHs3r0bRUVFAM7f2Xa1WcpERETUf6g0Wqw/lI1bh/nAwUpqNC4QAJ/eEQVnR4fuD46I6CLejlb4YEEs7hxZiWe3nEZOZZPB+LHsKsx8dz9WzArHHSN92zzJSERERETU3S6uxpaWltbm3AvjYrEYwcHBXRoXEdGldDodlEolamtr4ezsbPK6ZltJMqYIBAKDZCORSGR23qhRo9qc0xsIBAJIpVJIpcbnWztCKpUiPDy83SQoczcVmPv9qFQq5OTk6H+Wy+Wwt7fX/1MoFDyfQkTdhklMXeDnn3/WP168eLHJOUKhEHfddReeffZZ1NTUYM+ePZg+fXqnxvHll1/qH7fXSo6IiIjogvTSejzx3SmcKaxFSlEd3rktxuQ8to4jop5kdKAzdj46Aa/vSsOGwzkGY02tGjz3cxJO5lSZfU8jIiIiIrKE4cOHQyqVorW1Ffv27cMzzzxjcl5rayuOHj2qX6ezb4omIrqUTqdDY2Ojvj1cbW2tvp3ZoEGDTLYBFovFsLa2Nmh/CZzvGHOhRZpMJtMnLolEog4nx7A60PlOPW5ubm3O0el00Gg0+oSm1tZW1NbWoqWlxWzyVG1trcHPSqUSSqUSpaWlAM4nT12c1GRtbc2kJiLqMkxi6gIHDx4EcL4929ChQ83Omzhxov7xoUOHOjWJqb6+Xp9M5e/vjwkTJnTatomIiKhv0mh1+PRAFt76PR2tGi0A4OfEIsyM9MTMSA8LR0dE1D6FVISVcyIwI8IDT/1wCgXVzQbjfC8jIiIiop7G1tYWU6dOxc6dO7F7924UFBQYtJi7YMuWLairqwMA3HTTTd0dJhH1A1qtFg0NDQZJS+bau9XU1JhMYgIAR0dHiMVig6SX3lw9qbcRCAQQi8UQi8X6Lj0uLi5trnNpEtOlWltbUV5ejvLycgDnk9Xs7Oz0v187OzsmNRFRp+Ht810gNTUVABAUFGTQo/VSYWFhRut0lh9++AFNTefbKCxcuLBDHxxpaWkYOXIkHBwcIJfL4e3tjRtuuAFffvnlVfdYJSIiop4tu6IRt358BK/uTNMnMF3wwtYkKFUaC0VGRHT5Rgc6Y9djE3D7CF/9shuivTAz0tOCURERERFRf7RhwwYIBAIIBAKsXLnS5Jwnn3wSAKBWq7F06VJoNIbfwSsqKvD0008DABwcHLBkyZIujZmI+geNRoPq6mrk5OTg1KlTOHToEBISEpCVlYXKykqzCUxA20kvgYGBiI6ORkBAAJycnJjA1AvY2Nhc1u9KrVajqqoK2dnZSExMbPNYISK6XKzE1MmUSiUqKioAwOTdEhdzdHTUl1TMz8/v1DgubiV31113dWid0tJSfVlAACgsLERhYSG2bduG119/HT/88APCw8OvKJ6CgoI2x4uLi/WPGxsb9XeUEFlCQ0ODycdElsJjkrqSVqfDNyeL8O6eHCjVWqPxgc4K/Pf6ULQ2N6K1mccj9Sw8Hqk9z07zw4SBdvhgfy6enOzb5d8zeExST9LTj0e1Wg2tVqtvdUB938W/5/70O+9Lx/ilv8Oe8rx0Oh20Wi3UanWHP+svbXFDZM7BgweRkZGh//nCuX8AyMjIwIYNGwzmL1q06Ir2M2XKFNx2223YvHkztm3bhmuuuQaPPfYYvLy8cObMGbzyyivIy8sDALz++utwdHS8ov0QEV3s1KlTqK+vv+z1JBIJrKysoNPpWH2nj3B3d4e7u7tRC8Gampp2C11YWVmZbXHa0NAApVIJe3t7tkElog5jElMnu/jD3sbGpt35F5KYOvOEYl5eHvbt2wcAGDNmDIKCgtqcLxQKMXXqVMyaNQtDhgyBs7Mz6uvrER8fj48//hipqalISUnB5MmTcfz4cfj6+ra5PVN8fHw6PHfLli2wt7e/7H0QdYWNGzdaOgQiAzwmqTPVaSTY0+SNIrW1iVEdhsgqMEJThgNbT+CAiRk8Hqkn4fFIbRmnA77ecMTs+CmlM0KkNVAIO+9iLI9J6kl64vEYHR0Ne3t72NjYoKyszNLhUDerrKy0dAhd7siRfz53+soxPmjQIBQVFel/7inPq7W1Vd/6Ztu2bR1ap72WKUQXfPrpp/jiiy9Mjh06dAiHDh0yWHalSUwA8Pnnn6Ourg6//vor9uzZgz179hiMC4VCPP/887jvvvuueB9E1L+0tLSgtbUVtra2Jsft7Ow6lMQkl8sNWsMpFAomL/VRAoEANjY2sLGxwYABA6DT6dDc3GzQYlCpVBqs09Y13ZKSEhQWFgI4f0384uNIJpN16XMhot6LSUyd7OI3bqlU2u78C2/Qzc3NnRbDpk2boNPpAHSsCtOWLVvg4OBgtHz8+PF46KGHcO+99+KLL75AaWkpHnvsMWzZsqXTYiUiIqLup9MBKa2OONzkATWMSwTbC1sw2boQnuImC0RHRNT52jq3mtFqh8PNnohXumKiVREGSlkVloiIiIi6n0KhwI4dO/D1119jw4YNOHXqFGpqauDu7o7x48dj2bJlGD16tKXDJKIeSqfTQalUGiSbNDc3w9raGsOGDTO5jr29vT7B5GJWVlYGySZyubyrw6ceSiAQwMrKClZWVvD09ARwPjnu4uPM1DXmCy6uktnY2IjGxkZ9UvzFyXEODg6Qy+VMjiMiAExi6nQXf5C3tra2O7+lpQXA+S8oneXCHZYymQzz589vd35bHy4SiQSffvopjh49irNnz+Knn35CYWEhBgwYcFkxtdcur7i4GCNGjAAA3HzzzQgJCbms7RN1poaGBv3/o4ULF3aoqhpRV+IxSZ2ppK4FK3ek43B2jcnx24d64tHJAbCSmu5/zuORehIej3S1KhpacdMncQDUUOrE+K3RF7P8XfHs9EDYKy6/zDmPSepJevrxWFhYCK1WC4lEAjc3N0uHQ91Ao9HoKzA5OztDJDL99ybR5aqvr4etrS3s7e07nOCRnp6OV199tYsjo75gw4YNRi3jLteiRYsuq0LTggULsGDBgqvaJxH1fZe2/aqtrTV5XbKxsREqlcpkK68LFXQufI5e+Me2X9QWmUwGNze3dr/HqdXqNit9KZVKKJVKlJaWAjhfHOTi49Da2ppJTUT9FJOYOtnFJRk70iLuQv/1zjqZePz4caSlpQEA5syZ02aCUkeJxWLcc889WL58OQBg3759l/0lytvbu8Nzra2tYWdnd1nbJ+oqNjY2PB6pR+ExSVfjh7gCvLgtGfUtaqOxAQ4KrJo7GGOCXDq8PR6P1JPweKQrsXJXImqbDd8Tf00ux8m8Orx2SxSmhLlf8bZ5TFJP0hOPx9LSUqjVaggEAiaz9EMikYi/d+o0AoEAQqEQYrG4w+911tamWmoTERH1fPX19SgqKkJFRQXUauNzfKbU1tbCxcX4nJ9UKsW4ceP4dxl1CZVKBQcHB9TV1UGr1bY7v7W1FeXl5SgvLwcADBgwAEFBQV0dJhH1QExi6mRyuRzOzs6orKxEQUFBm3Orq6v1SUw+Pj6dsv8vv/xS/7gjreQ6atCgQfrHpkpLEhERUc+XXFRrMoHp9hE+WDErHLZy3mVFRP3Ls9eGo7FFjd+SSw2Wl9W34F8bTmLeUG88f/0g2PH9kYiIiIiIiCxEq9WivLwchYWFbVa2MUUkEkGlUrU5TtQVFAoFhgwZAq1Wi/r6eoOqYRqNpt31e9qNOETUfZjE1AUGDRqEAwcOICMjA2q1GmKx6Zf5QsUkAAgPD7/q/apUKmzevBkA4ObmhpkzZ171Ni9guT4iIqLeb/mMMOw9W47sivNJ1B52crx2SxQmhbKFCxH1T662Mnx051BsTSzCC1uTUKc0TPT8Pq4AhzIq8PrcwRgf7GqhKImIiIiIiKg/q6mpMbim2BaJRGLQksvGxobX+MiihEKh/ngEjFsh1tTUmEy0uzDflJaWFshksi6LmYgsi0lMXWDcuHE4cOAAGhsbERcXh5EjR5qct2/fPv3jsWPHXvV+d+zYgcrKSgDn+2abS566EikpKfrHXl5enbZdIiIi6j4KqQhvzhuCeR8dxo0xA/Cf2RGwt2J1ESLq3wQCAW6MGYBRA53xzJbT2Hu23GC8qFaJhZ8dx52jfPHsteGwlvFrNBEREREREXUfR0dHKBQKNDc3G43JZDI4ODjok0QUCgWTlqhHEwgEsLGxgY2NDQYMGACdTofm5maDSk0AzCYpNTY24uTJk3B0dISXlxecnZ15zBP1MTz72gVuvPFGvPrqqwCA9evXm0xi0mq1+tZvDg4OmDx58lXv9+JWcnffffdVb+8CtVqNzz//XP/zhAkTOm3bRERE1Pnyq5rg42RlcmyonyN+f3wCgtxsuzkqIqKezcNejvWLhuO7k/l4+ZdUNFzSfnPT0TzsT6/AqrmDMXKgs4WiJCIiIiIior5IpVKhtbUV1tbWRmMCgQBeXl7IzMwEAEilUnh6esLDwwNyuby7QyXqVAKBAFZWVrCysoKnpyeA89emzSkqKgIAVFdXo7q6GjKZDJ6envD09IRUKu2WmImoawktHUBfNGLECIwfPx4A8Nlnn+HIkSNGc9566y2kpqYCAB599FFIJIZVEPbu3QuBQACBQIBFixa1u8+qqirs2LEDABAVFYXo6OgOxbpnzx7U1NSYHVepVFiyZIk+1uuvvx4+Pj4d2jYRERF1r5qmVjy6OQHT396PnL9bxpnCBCYiItMEAgHmD/fFrsfGY2yQcaJSXlUTbvvkKF7angKlSmOBCImIiIiIiKiv0Ol0qKurQ1paGo4cOYJz586Znevu7g4nJycMGjQII0eOhL+/PxOYqM8y121IrVajtLTUYFlLSwtycnJw9OhRpKamora2FjqdrjvCJKIuwkpMXeTdd9/F2LFj0dzcjOnTp2PFihWYPHkympubsXnzZqxbtw4AEBISgieeeOKq97d582a0trYCuLwqTF988QXmzJmDOXPmYNKkSQgNDYWdnR0aGhoQFxeHdevW6VvJubm54d13373qWImIiKjz/ZVWimd+PIOy+hYAwJPfn8K394+GSMhSukREl8vb0Qob/zUSXx3Lxf9+TUPzRQlLOh1w4Fw5ls8MtWCERERERERE1FtpNBqUlZWhqKgIDQ0N+uW1tbVoaGiAjY2N0ToSiQRRUVHdGSZRj9PY2Gi2dZxOp0NZWRnKyspgbW0NLy8vuLm5mU2IIqKei/9ru0hMTAy+/fZb3Hnnnairq8OKFSuM5oSEhGDHjh2wtb36aggXWsmJRCLccccdl7VuQ0MDvv76a3z99ddm50RFRWHz5s0ICAi4qjiJiIioc9UpVfjvLyn47mSBwfKTudX4/GA27p0w0EKRERH1bkKhAAtH+2N8sCue+uEUTuRUAwBEQgHeunUI5BKRhSMkIiIiIiKi3qSpqQlFRUUoKSmBRmO6um9xcTGCg4O7OTKi3sHe3h6jRo1CeXk5CgsLDZIAL9bY2Ihz584hKysL7u7u8PLyMtmqkYh6JiYxdaHrr78ep0+fxrvvvosdO3agoKAAUqkUQUFBmDdvHpYtWwYrK6ur3s+5c+dw7NgxAMA111wDDw+PDq/79NNPIzo6GkeOHEFKSgrKy8tRVVUFmUwGd3d3DBs2DHPnzsVNN90EkYgn6YmIiHqSg+cqsPyHUyiqVRqN2crFcLOTWSAqIqK+xd/FGpvvG431h7Lxxm9ncf+EgRjs7WDpsIiIiIiIiKgX0Ol0qKioQFFREWpqatqca67CDBH9QyQSwcPDAx4eHqirq0NRURHKy8uh1WqN5mo0GhQVFaGoqAj29vYICQnplGvzRNS1mMTUxfz8/LB69WqsXr36stabNGlSh/t1BgcHX3Fvz/DwcISHh+Oxxx67ovWJiIio+zW2qPHqzlRsOppncnxiiCtev2UwPOzl3RwZEVHfJBIKsGT8QEwJc4O3o/mTXeUNrdDoBBAJruz7GREREREREfUNLS0tKC4uRnFxMVpbW9ucK5fL4enpCQ8PD0il0m6KkKj3s7Ozg52dHQIDA1FSUoKioiIolcY3/AJAfX09JBJJN0dIRFeCSUxEREREvcixrEo89cNp5FU1GY1ZS0V4bvYg3Dbch3duERF1gYGuNmbH1BotHv0hBSX1AzHFusDsPCIiIiIiIurbMjMzUVhY2G4BAicnJ3h5ecHJyYnn8oiugkQigY+PD7y9vVFdXY2ioiJUVlYazHF1dWUSE1EvIbR0AERERETUPpVGi9d3peG2T46aTGAaPdAZux6bgNtH+PKkBxGRBXy8PwtJRfWo0CjwQ10gNh5v/4Q1ERFdnQ0bNkAgEEAgECAnJ6dL9pGTk6Pfx4YNG7pkHz3VypUr9c/9Sl1Yf+XKlZ0XGBERUQ8nk8nMfh8Ui8Xw8fHBiBEjEBUVBWdnZ57LI+okAoEATk5OiIyMxMiRI+Hr66tPXPLy8jK7Xl5eHgoKCqBWq7srVCJqAysxEREREfVwRTXNePibBMTlVhuNKSQiPDsrDHeO9INQyBMeRESWkFZSh3d2p+t/1kKIVbuzkFDYiDfnDYaDFdsBEBERERER9Rfu7u7Izs6GVqvVL7O1tcWAAQPg6uoKoZA1Joi6mlwuR0BAAPz8/FBdXQ07OzuT89RqNfLy8qDRaJCdnQ03Nzd4eXnB1ta2myMmogv4KUlERETUgzW0qDHn/YMmE5iG+Tli56PjcddofyYwERFZkE4HBLhYGy3fnVqKWe8eQFxulQWiIiKi3qI7KkoRERFR59BqtSgtLUVCQgIaGxtNzpFIJHBzc4NQKISHhwdiY2MRGxsLd3d3JjARdTOhUAhnZ2ez42VlZdBoNADO//8uKSlBfHw84uPjUVpaapCMSETdg5WYiIiIiHowG5kYi8cGYNVvZ/XLJCIBnpoRinvGDYSIyUtERBYX7mmH7Q+Pw2u/JGH90QKDsaJaJW79+CiemhGK+8YPZNIpERH1K2ytSkREfYVSqURxcTGKi4uhUqkAAEVFRQgODjY539/fH4GBgRCLeSmWqKfS6XQoKioyOVZfX4+0tDRkZGTA09MTnp6eUCgU3RwhUf/EdF8iIiKiHu7BiYGYEOIKAPBxUuCHB8bgvgmBTGAiIupBZGIRHp8SgOtsciAXqA3GNFodXtuZhn99cQKVDS0WipCIiIiIiIguh06nQ1VVFZKSknDs2DHk5eXpE5gAoLS0FGq12uS6MpmMCUxEvUBQUBBcXV0hEJg+165Wq5Gfn4/jx4/jzJkzqKysZKI+URfjpycRERFRDycUCrD61iFY/Uc6np4ZBnuFxNIhERGRGb6SBtxql4FU+5E4kVdrMLb3bDlmrTmANbfFYORA86XMiYiIiIiIyHJUKhVKSkpQVFQEpVJpdp5Go0F5eTk8PT27MToi6iwCgQAODg5wcHBAS0uL/v99a2uryflVVVWoqqqCXC6Hp6cnPDw8IJVKuzlqor6PlZiIiIiIeoAWtQaHMirMjrvYyPC/m6KYwERE1AtYC9VYtyAKj0wNxqU38pXWteD2T47ivT/PQaPlnXtE1D1WrlwJgUCgv7u4rq4OK1euRFRUFGxsbODm5oZZs2bh8OHDBuuVlZXhueeeQ0REBKytreHs7IwbbrgBCQkJ7e5Tq9Vi06ZNmDVrFjw8PKBQKBAZGYm5c+fiww8/NHth4GLV1dV45plnEBYWBoVCATc3N0ybNg3ff/99h573hee8cuXKNudNmjQJAoEAkyZN6tB2L5WUlIT//ve/mDFjBry9vSGTyWBjY4Pg4GDcfffdOHr0qMn19u7dC4FAgMWLF+uXBQQE6OO+8G/v3r0m1//5558xb948+Pr6Qi6Xw8HBAcOGDcOLL76I6urqduMuKCjA0qVLMXDgQMjlcnh5eWHOnDnYvXv3Fb0OpnT0d0BERNQT1NXVIS0tDUePHkVWVlabCUz29vYYNGgQ3N3duzFCIuoqMpkMfn5+GDVqFAYNGgQHBwezc5VKJbKzs5GVldV9ARL1I6zERERERGRhORWNWPZNPNKK6/HdA6MR6+to6ZCIiOgqiYQC/PuaEIwKcMIjmxNRcVEbOa0OeOuPdBzLrsIHd8QyQZWIulV+fj6mTZuG9PR0/bLGxkbs3LkTv//+O7755hvMmzcPp0+fxqxZs1BYWKif19TUhG3btuG3337Dzp07MXnyZJP7qKqqwpw5c3Do0CGj5YcPH8bhw4exdu1a7Ny5E35+fia3kZqaimnTpqGoqEi/TKlU4s8//8Sff/6JxYsXY8KECVfzUnSKvXv3mnwdWltbkZGRgYyMDHz55Zd45pln8Oqrr3bKPqurqzF37lz89ddfBstbWloQFxeHuLg4rF27Flu3bsWoUaNMbuPAgQOYPXs26urq9MuKi4uxfft2bN++nUlHRETUr9TV1SEjIwP19fVtzhOJRHB3d4eXlxesra27KToi6k4CgQCurq5wdXVFU1MTioqKUFJSAo1GYzTXy8vLAhES9X1MYiIiIiKyoO2nivDsljNoaFEDAB7+OgG/PjIe9la8oE1E1BeMCXLBzkfH4/FvE3Hwkop7SpUG1lKRhSIjov5q3rx5KCgowLPPPouZM2fCysoKBw8exH/+8x/U1dXhnnvuwbBhwzB79mw0NzfjlVdewcSJEyGRSLBr1y688soraGlpwaJFi3Du3Dmj9gkajQazZ8/GkSNHAAATJ07EsmXL4Ovri9TUVGzevBm7du1Camoqpk6disTERNjY2Bhso66uDjNmzNAnMM2fPx9333033NzckJ6ejtWrV2P9+vVISkrqnhetDWq1GtbW1rjuuuswZcoUhIWFwc7ODmVlZUhOTsaaNWuQm5uL1157DSEhIQZVl4YPH44zZ85g69ateO655wAAv/32m9HFkICAAP3jlpYWTJs2DfHx8RCJRFiwYAFmzZqFgIAAqFQq7N+/H6tXr0ZZWRlmzZqFhIQEo0SxvLw8fQKTUCjEfffdh7lz58Le3h6nT5/Ga6+9hpUrV2LYsGFd+MoRERH1DPX19e1WmbS2toaXlxfc3d0hEvE7HFF/YWVlhaCgIAQEBKCsrAxFRUVoaGgAANjY2MDW1tbCERL1TUxiIiIiIrIApUqDl35JwdfH8gyWF9Y04/9+PoP3F8RaKDIiIupsrrYyfPGvEfhwbwZW/5EOrQ5wsJJgze0xEIvY5Z3IHK1Wh+qm9luO9SWOVlIIhYL2J16FxMRE7Nu3DyNHjtQvGzZsGIKDgzF79mzU19dj5MiR0Ol0OH78OAIDA/XzRowYARcXFyxduhR5eXnYsWMHbrrpJoPtf/TRR/oEprvuugsbNmyAQCCARqOBj48Ppk+fjjVr1uC1115DZmYmXn75Zbz++usG23j55ZeRn58PAPjf//6HZ599Vj82dOhQzJ07F7Nnz8bvv//e6a/P5YqOjkZBQYHJdhMzZszAsmXLMHv2bPzxxx948cUXcdddd+kvflpbWyMyMhInT57UrxMSEgJ/f3+z+3vppZcQHx8PBwcH7N69G0OHDjUYHzduHO644w6MHj0axcXFWLFiBb766iuDOU888YS+AtOmTZtw++2368eGDRuGefPmYfz48QZxERER9VU2NjZwdHQ0asV6oRqLl5cX7Ozs9G15iaj/EYlE8PT0hIeHB+rr61FUVARHR0ez7wuNjY2oq6uDh4cH3zuIrgCTmIiIiIi6WWZ5A5Z+FY+0EuMS1YGu1lg2JcgCURERUVcSCQVYNiUYw/2d8OjmRLxyUyS8HBSWDouoR6tuasXQ/+62dBjdKu65aXC2kXXpPh577DGDBKYLrrvuOvj5+SE3Nxfl5eX48MMPDRKYLli8eDGeeOIJKJVKHDhwwCiJ6YMPPgAAuLq64v333zd50n7lypX4+eefkZaWhk8++QQvvfQSZLLzz7u1tRWfffYZAGDw4MF45plnjNaXSCT47LPPMHDgQKhUqst/ETqRi4tLm+NSqRSrVq1CdHQ0cnNzkZiYaJR41FENDQ361/fll182ux0/Pz88//zzeOihh/D9999j3bp1+pY3JSUl+OmnnwAAs2fPNkhgusDW1hbr1q0zeZwQERH1NQKBAMHBwThx4gR0Oh1kMhm8vLzg4eFhVHGSiPo3gUAAOzs72NnZmZ2j0+lw7tw51NbWoqSkBMHBwUaVZ4mobbzlk4iIiKgb/ZRQgOvfO2gygemWWG9sf3gcwjzMfwkiIqLebeRAZ+x9ahKmhrubnaNUaboxIiLqb2677TazY4MHDwZw/uT8/PnzTc5RKBQIDg4GAGRlZRmMFRUVITU1FQBw6623mm2vIBaL9W3VqqurER8frx+Li4vTV0K4++67zd657O3tjenTp5t9LpbS0tKCvLw8pKSkICkpCUlJSdDpdPrxU6dOXfG29+3bh9raWgDA3Llz25w7YcIEAIBKpUJcXJx++Z49e6DRnP+cubi13aVGjBiBiIiIK46ViIiop9FqtWbHFAoFAgICMHDgQIwYMQK+vr5MYCKiK1JaWqr/m72urg5xcXHIzMyEWq22cGREvQcrMRERERF1g+ZWDf6zLQnfnSwwGlNIRHj5xkjMHeptgciIiKi7ySUis2ONLWrc8MEhXDPIHU9cE8J2c0TU6UJCQsyOXWiJ5uLiAkdHx3bn1dcbJuYnJSXpH7dXxefi8aSkJIwePRoAcObMGf3y4cOHt7mNESNGYMeOHW3O6Q6NjY1Ys2YNNm/ejOTkZH2SkCkVFRVXvJ+L27t5enp2eL2SkhL948t9fZOTky8jQiIiop6poqICGRkZCAoKMltF0cfHp5ujIqK+RqPRGN3oAQAFBQUoKytr8z2IiP7BJCYiIiKiLpZeWo+lX8XjXFmD0Viouy0+uCMGQW6m71InIqL+Q6fT4fmfk5BR1oCMsgacyK7Cmttj2HaOiDqVlZWV2TGhUNjunIvnXZqsU1VVpX/s5ubW5jY8PDxMrnc523B3N1/Vrrvk5ORgypQpyM7O7tD85ubmK95XWVnZFa3X1NSkf9zbXl8iIqKr0dLSgqSkJFRWVgIAMjIy4OjoCJHI/I0lRERXSiQSISwsDOfOnYNSqTQYa21tRUpKCpycnAy+CxGRMSYxEREREXURnU6H7+MK8MLWJChVxiWrbxvug/9cHwGFlCdOiIgI+CGuAFsSCvU/n8ytxqw1B/DWvCFttp8j6qscraSIe26apcPoVo5Wfadtibk2cN29ja62cOFCZGdnQyAQYPHixbjtttsQHh4OV1dXSKVSCAQCaLVa/cXSi1vLXa6Lk8bi4+MhkUg6tJ63t+mKr73h9SUiIroSAoEAnp6eSE1NNfjsbWlpQW5uLgYOHGjB6IioL3NycsKwYcOQn5+PvLw8o7//q6qqUF1djQEDBqCoqMhCURL1bExiIiIiIuoiK7cl44sjuUbLraUi/O/mKNwQPcACURERUU+lVGkgEQmg0vxzgqumSYV7vjiJJeMCsHxmGKRitpej/kMoFMDZRmbpMOgyODk56R+Xlpa2OffiFmcXr3dxG7vS0tI229+1tw+BQACdTget1viGgos1Nja2OW5OWloaDh48CABYsWIF/vvf/5qcd3H1o6vh7Oysf+zq6mo2Oaktl76+bbXOae/1JSIi6onq6+sRFRUFKysrk8nDDQ0N0Ol0TOYloi4jEong7+8PNzc3ZGRkoLq62mBcp9PBx8cHLi4uqK+vh52dnYUiJeqZePaTiIiIqIuMGuhstGyQpx22PzyOCUxERGRk4Wh//PDAGPg4GbeP+/RgNuZ9fAT5VU0m1iQi6hkiIyP1j48dO9bm3OPHj5tcLyoqSv/4xIkTbW6jvXFb2/Mtmy+9aHAxnU6HjIyMNrdjTnJysv7x/Pnzzc47efJkm9vp6EXUmJgY/eNDhw51aJ1LdebrS0RE1JO0trYiLS0NGRkZJlvjSiQShIWFISoqiglMRNQtrKysEBUVhfDwcEilxlV3FQoFMjIykJqaitbWVgtESNQzMYmJiIiIqItcG+WJu0b76X9eOMoPWx4ag4GuNhaMioiIerIhPg745eHxuDbSw2jsVH4NZq05gF1JJSbWJCKyPC8vL4SHhwMAvvvuOzQ0NJicp9FosGHDBgDnKwPFxsbqx4YOHaqvFrRx40az7dcKCwvx+++/txlPQEAAgLaTiHbu3Imampo2t2OOWq3WP26rmtNHH33U5nbkcrn+cUtLi9l506ZN01+UXbNmzRW1pps8ebK+td0XX3xhdt6JEyeQlJR02dsnIiLqbjqdDkVFRThx4oTZKoJeXl4YPnw43N3dmcBERN1KIBDAzc0Nw4cPx4ABpm9sLisrQ3x8fLsVZIn6CyYxEREREXWhFbPCMWqgEz5YEIuXb4yEXCKydEhERNTD2SskWHtHLF6+IQJSkeHX9nqlGg9sisPKbcloUWssFCERkXlLly4FAJSXl+ORRx4xOeell15CSkoKAODee++FTPZP20CZTIbFixcDABITE7Fq1Sqj9dVqNe69995271aeOHEigPNVoUxVLiopKcHDDz/cgWdlWnBwsP7xhaSsS3344YfYunVrm9vx9PTUP87MzDQ7z8HBAcuWLQMAHD58GI8//nibFzpKS0vx6aefGu3rhhtuAABs27YN3333ndF6DQ0NuP/++9uMmYiIqCeor69HQkICzp07Z5BcfIFCoUBMTAyCg4MhkUgsECER0XlisRhBQUGIjY01WS3O29sbQiFTN4gAJjERERERXbXCmmazY3KJCN/cOwrXDfY0O4eIiOhSAoEAC0f7Y8tDY+DvbHxya8PhHNzy4WHkVJiv/EFEZAkPPPAARo8eDQBYv349pk6dih9//BHx8fHYvXs3lixZgldeeQUAEBgYiOeff95oGy+88AK8vb0BAE8//TQWLFiAXbt2IT4+Hps3b8aYMWOwc+dODBs2rM1Y7rvvPojFYuh0Olx//fV45513cPLkSRw+fBirVq1CTEwMamtrDZKRLkdMTIy+Fd7HH3+M+fPn45dffkFcXBy2bt2KefPm4aGHHsLYsWPb3c6FakzPP/88/vjjD6SnpyMjIwMZGRlobv7n+8ZLL72EkSNHAgDeffddxMbG4oMPPsChQ4eQmJiIPXv24P3338eNN94IX19fk1Wg3nrrLX2rvQULFmDp0qXYs2cP4uLisH79egwdOhQJCQntvr5ERESWotFokJGRgfj4eNTX1xuNq9VqZGdnIzQ0FHZ2dhaIkIjINFtbW4SEhCArK0uffGljY2O2ShNRfyS2dABEREREvZVOp8OXR3Lxyo5UrJo3GDdEm/6iwTLVRER0pSIH2GP7w+Ow4qckbD9VZDCWVFiH2e8dxGu3RGH2YC8LRUhEZEgkEuGXX37BnDlzcOjQIfz111/466+/jOaFh4dj586dsLExbrVsb2+PXbt2Ydq0aSgpKcE333yDb775xmDOokWLMHHiRH3VJlMiIiLwxhtv4N///jeqq6vx+OOPG4w7OTnh559/xvPPP49z585d9nMVCATYuHEjpkyZgurqanz33XdGlY2ioqLw/fffw8vL/Pu0ra0tHnnkEbzxxhuIj4/H9OnTDcb37NmDSZMmAThfqeqPP/7AokWLsGXLFpw6dUpfnckUUxdu/f39sW3bNsyZMwf19fVYu3Yt1q5dazDnhRdegEAgaLMVHxERkaUIBAJUVVWZHHN0dMTu3buhUql4To6IeiSBQICysjJUVVVh+vTp8PPzM/t+pdVqIRAI+H5G/QorMRERERFdgdpmFR7cFI//bEtGq0aLFVvOIJvVMIiIqAvYyiVYc1s0Xr05CjKx4df4hhY1/kwts1BkRESmOTk5Yf/+/fjyyy8xc+ZMuLu7QyKRwNHREWPGjMGaNWuQmJgIPz8/s9uIiIhAcnIyli9fjuDgYMhkMri4uGDy5Mn4+uuvsX79+g7F8vjjj2PXrl2YMWMGHB0dIZPJEBAQgKVLlyIhIQHjx4+/qucaHR2NxMREPPDAA/Dz84NEIoGTkxNGjBiBN998E8ePHzdoF2fOa6+9hk8++QTjx4+Hk5MTRCLzbahtbW3x448/4sCBA1iyZAlCQ0Nha2sLsVgMJycnDB8+HEuXLsWvv/6KP/74w+Q2Jk2ahOTkZDz44IPw8/ODVCqFu7s7rrvuOuzatQsvvvjiFb8mREREXU0oFCIoKMhgmUKhwODBg+Hv7w+VSmWhyIiIOk6tVsPPz6/NinEZGRk4deoUGht57YH6D1ZiIiIiIrpMifk1WPZ1PAqq/2nr0NiqwdKv4rHloTGQS8xfcCAiIroSAoEAt4/wRYyvA5Z+FY/M8vMnrwa6WOO/N0ZaODoi6ulWrlyJlStXtjtvw4YN2LBhQ7vz9u7d2+4coVCIhQsXYuHChQDOt30pKzufdOnm5tZmks4FTk5OeP311/H666+bHF+0aBEWLVrU7nZmzJiBGTNmmB1v6/n4+/tDp9O1uX1fX198+OGHbc5pbxsCgQBLlizBkiVL2px3sXHjxmHcuHEdnn8pHx8fowpMF+vocdOW9p43ERHRlXJycoKrqysqKyvh6+sLHx8fCIVC1NXVWTo0IqJOUVdXh+LiYgBAXFwcvL294efn16HvUkS9GSsxEREREXWQTqfDpweyMPfDwwYJTBeMD3GBSMiyrkRE1HXCPOywbdk43Bw7AFKxEO8viIW1jPcnERERERFR31NVVdVm9ZGgoCAMGzYMfn5+EAp5yZOI+g6dTmfQ8lqn0yE/Px8nT55EZWWlBSMj6no800lERETUATVNrXjy+1PYbaJlj6OVBKtvjcbkMDcLREZERP2NtUyM1bdG4+EpwQhwsbZ0OERERERERJ2qpaUFmZmZKC8vh729PYYMGQKBwPjGQalUaoHoiIi6nlKpNNkaU6lUIikpCc7OzggKCoJcLrdAdERdi2nJRERERO1IKqzF9e8fNJnANNzfEb8+Op4JTERE1O3aSmAqq1fiXxtOIL+qqRsjIiIiIiIiunI6nQ4FBQU4ceIEysvLAQC1tbUoLS21cGRERN1LoVBg+PDh8PHxMZnEWVlZiRMnTiA/Px9ardYCERJ1HVZiIiIiImrDj3EFWPHTGbSoDb8ICATA0klBeGxaMMQi5oUTEVHPodJosezrBBzPrkJcbjXevS0ak0KZbEtERERERD1XXV0d0tPTTbaPy8rKgouLC8RiXtYkov5DJBJh4MCBcHd3x7lz51BbW2swrtVqkZWVhdLSUgQHB8Pe3t5CkRJ1Ll5xIyIiIjKhVa3F8z8n4YnvTxklMDlbS/Hlv0bgyRmhTGAiIqIe57WdaTieXQUAqG1WYfGGE1jz5zlotToLR0ZERERERGRIpVIhPT0dCQkJJhOYxGIxAgICIBKJLBAdEZHlWVtbY8iQIQgNDYVEIjEab2xsRGJiIs6ePWuyBR1Rb8OUZSIiIqJLlNQq8eBXcUjIqzEai/V1wNo7hsLDnr2mqX/T6XSoaVKhoqEFlsqLaGhoRKVGBiGAOqUatrY6k+WVifqTplY19qWXGyzT6YDVf6TjdEEN3ro1GvYK4xNeRERERERE3Umn06G0tBRZWVlmL7p7eHhg4MCBJi/aExH1JwKBAB4eHnB2dkZ2djaKi4uN5pSUlKCiogIDBw6Ep6enBaIk6hxMYiIiIiK6RF5VE04X1Botv2u0H567bhCkYlZfor6vuVWDotpmFNcoUVTTjMKaZhTXNqOoRomi2mYU1TRDqeoJ/daDAQCbVx+BjUwMT3s5vBwU8HKQw8teAc+/Hw9wUMDDXg6ZmHduUt9mJRXj56Vj8dT3p7AzqcRgbHdqGW54/yA+WjgUYR52FoqQiIiIiIj6u8bGRpOtkS6wtrZmayQiIhMkEglCQkLg4eGBc+fOoaGhwWBcrVajvr6eSUzUqzGJiYiIiOgSIwKcsGJWOF7+JQUAIBML8erNUbg51tvCkRF1DrVGi7L6FhTVNKOo9nySUnFNMwprlH8nKjWjuqn3lR5uaFHjXFkDzpU1mJ3jYiO7KMHpfHKTp/3fSU8OCrjayCAUspoT9W42MjHW3hGLdfuz8PquNINqaTmVTbjxg0N4/ZbBuCF6gOWCJCIiIiKifkej0SA3NxcFBQXQ6YzLOguFQvj7+2PAgAEQCnkTIRGROXZ2doiNjUVhYSFycnKg0WgAnE9yCggIsHB0RFeHSUxEREREJvxrrD8S82twKr8GH94Ziwgv3vlFvcOFNm/nKycp/05U+ruC0t/JSqX1LdBYqgechVU0tKCiocVktTUAkIgEcLf7u5qTvqrTP0lOnvYK2MnFbFtHPZ5AIMD9EwMRNcAeD3+TgMrGVv2YUqXFo5sTkZBXg/+7LhwSES8OEBERERFR19LpdEhISEBjY6PJcRcXFwQGBkIul3dzZEREvZNAIIC3tzdcXV2RmZmJ8vJyBAYGsgUn9XpMYiIiIiIyQSAQ4PVbotCq1sLBSmrpcIgMaLQ6nC2pR1JRLQqrLd/mzWL5PDpABx2AzgtApdGhoLoZBdXNZueYalvn7aRA1AB7DHSxYSUn6lHGBLlg+8Pj8OBX8TiVX2MwtuFwDpKLavHBgli42fFCARERERERdR2BQABPT09kZGQYLJfL5QgKCoKzs7OFIiMi6t1kMhkGDRqE2tpa2NnZmZ3X2toKiUTCmzOpx2MSExEREfVbvyeXoLROiYWj/U2OW0nFYP4S9QS1TSrE51cjIbcacXnVSMyrQWOrplv2ba+QwMtBgQEO8r/brl1clUgOdzu5xaq41NXV4cMPP4RGJ8CNt9+NWrVY3w7vQpu88/+UaGhRd9p+22pbZ6+QINbXAUP9HBHr64ghPg6wlvFrF1mWl4MC390/Ci9uT8HXx/IMxk7kVGP2ewex9o5YDPN3slCERERERETUH3h5eaGkpAQNDQ0QCATw8fGBr68vRCKRpUMjIur17O3Nd5NQq9U4ffo0ZDIZwsPDIRbzfCX1XDw6iYiIqN/RaHVY/cdZfLAnEyKhAEFuthgdyLu9qGfQanXIqmhAfG4N4nKrEZ9XbTJZpjPIxEJ9UpI+QemiCkOe9opekYAjEujg7ajAoDbuNKpTqlBcc3F7vWYU1yj1bfeKa5uh0lx9i73aZhX2nC3HnrPlAAChAAj3tEOsr6M+scnHScE7nqjbycQi/O+mKET7OOC5n5PQqv6nYltZfQtuW3cUX987CiMCmMhERERERERdQyAQIDg4GNnZ2QgODoaVlZWlQyIi6vN0Oh1SUlLQ2NiIxsZGJCYmIjIyku07qcfq+VckiIiIiDpRdWMrHtmcgAPnKgCcT2h6+Jt4bH94HDztFRaOjvqjxhY1TuXXID6v+u+kpRrUNquuertCAeBuJ7+o7dn5BCVPBwUG/F1Fycla2m+SaezkEth5SBDqYWtyXKvVoaKxBUU1ShTXNOuTm/TVnGqVKK9vuez9anVAclEdkovqsPFoLgDAxUaGoX7/VGuKHGAPuYR3nVL3uHWYD8I97PDApjgU1vzTNjHWzxExvg6WC4yIiIiIiPoMrVYLodB01WY7OzsMGTKkmyMiIuq/MjMzUV1drf+5sbERCQkJiIyMhK2t6XOlRJbEJCYiIiLqN84U1BpdtAWAioZW/BhXgGVTgi0UGfUXOp0O+VXNFyUsVSO1uA7aKywA5OtkhRB3mx7X5q03EgoFcLOVw81WjmgfB5NzWtQalNa2/J3gZNi2Lq24HiV1yg7tq6KhBb8ll+K35FIAgEQkQOQAe4NqTR72vBOKuk6Utz22PzwOj/6d1OtuJ8MHC2L5nkFERERERFetsrIS586dw+DBg1lpiYioB3B1dUVZWRlUqn9unG1tbUViYiLCw8Ph4uJiweiIjDGJiYiIiPqF707k47mthu1zAEAsFOD52YNw12g/C0VGfZlSpUFSYa0+aSkutwYVDZdfzQcApGIhhnifT3SJ/TvRxdVW1skRU1tkYhF8na3g62z6JGxRTfPfv+dqJORVI7moDuoOZKipNDok5NUgIa8Gnx3MBgAMcFAg1s8RQ30dEOvniHBPOyaYUKdyspZiw+IRePuPdEwOc+P7CRERERERXbWCggJkZmYCAJKSkhATEwOJRGLhqIiI+jd7e3vExMQgKSkJTU1N+uVarRbJyckYOHAgvL29+03Ffur5mMREREREfVqLWoOV21LwzfE8ozE3WxnW3hGLYf5OFoiM+qKSWqVBlaWkwlqoNFdWZsndToZhfk6I8T3fdizCyx5SMZNYerILbfuuH+IFAGhu1eB0QQ3i8qoRn3u+ZWBVY2uHtlX4d0u77aeKAAByiRCDvc8fC0P/TmRzspZ22XOh/kEkFODJGaFtzimrV8LFWgahkCeyiIiIiIjINJ1Oh4yMDBQVFemXNTc3Izk5GYMHDzbbWo6IiLqHQqFAdHQ0UlJSUFNTYzCWlZWF5uZmBAUF8f2aegQmMREREVGfVVTTjAe/isep/BqjseH+jvhgQSzc7Niyia6MSqNFanEd4nOrEZdXg/jcaqNWhR0lFgowyMvun3Zifo7wspfz7pdeTiEVYeRAZ4wc6Azg/EndnMqmv4+ZasTnVuNsaT10HchzU6q0OJ5dhePZVfplAS7Wf1fmOp/cFOxmCxETTagT1SlVuO3jo/BztsLb86PhYMXEOSIiIiIiMqRWq5GamoqqqiqjMZmMFV+JiHoKiUSCqKgonDt3DiUlJQZjxcXFUCqVGDRoEMRippCQZfEIJCIioj7pcGYFHv46AZUmqp4sHuuPFbPC2ZqJLludUoU/U0ux80wJDpyrQLNKc0XbcbKW/pN84uuIwd4OUEhFnRwt9TQCgQABLtYIcLHGLUO9AZw/pk7l1/xdvasGCbnVqG9Rd2h72RWNyK5oxI/xBQAAW7kYU8LccG2kByaGuPGYoqui1erw5HenkFXRiKyKRlz//kF8dOdQRHjZWzo0IiIiIiLqIZRKJZKSktDY2Gg05ufnBz8/P96gRUTUgwiFQoSEhEChUCA7O9tgrLq6GgkJCYiKioJczpu/yXKYxERERER9ik6nw7r9WXh9Vxq0l1Q3kUuEeP2WwbgheoBlgqNeqbqxFX+klGJnUjEOZlRcdns4gQAIdbdFrJ+jvtKSv7MVT+IRAMBOLsH4YFeMD3YFcD5x5FxZg74lYXxuNbIqjE8Gm1KvVGNrYhG2JhZBIRFhcpgrZkZ6YkqYG2xk/OpHl+ej/Zn4PaVU/3N+VTNuXnsYr94chZtjvS0YGRERERER9QT19fVISkpCa6vhDYQCgQChoaFwd3e3UGRERNQWgUAAX19fKBQKpKWlQavV6seampoQHx+PyMhI2NnZWTBK6s94JpuIiIj6lKd/PI3vThYYLfdztsJHdw5FuCf/8Kb2ldUr8VtyKXYlFeNoVhU0l2bEtcFWJka07/n2XkP9HDHExwF2ckkXRkt9iVAoQKiHLUI9bLFgpC8AoKqxFQl51YjLPf/vVEENlCptm9tpVmnw65kS/HqmBFKxEBOCXXBtpCemhbvD3orHI7Uv1tcRLjZSVDT8c0GiRa3Fv787hcT8Gjx33SBIxaxoSESWtWHDBixevBgAkJ2dDX9//07fR05ODgICAgAA69evx6JFizp9Hz3VypUr8eKLLwI4f7MIERHRBRUVFUhNTTW48A0AYrEYkZGRsLdnBVciop7O1dUVMpkMSUlJUKlU+uUqlQqnTp1CVFQUHBwcLBcg9VtMYiIiIqI+ZWq4u1ES09QwN6yeHw17BS/ck3lFNc3YlVSCXUklOJFbhY5epxnoYm1QZSnIzQYiIassUedxspZiarg7poafv4tVpdEirbgecblViM8734qusKbZ7Pqtai12p5Zhd2oZxEIBxgS54NpID0wf5A5nG1l3PQ3qZUYNdMYvD4/Hg1/FISGvxmDsyyO5SC6qw9o7YuFux/LiRERERET9hU6nQ0FBAbKysozGFAoFoqKioFAoLBAZERFdCTs7O8TGxuLMmTNoamrSL1coFLCxsbFgZNSfMYmJiIiI+pQZER54aFIg1u7NhEAAPDY1BA9PCYKQSSVkQl5lE3YmFWNnUgkS82s6tI5UJMS4YBfMjPTAlDA3uDAJhLqZRCRElLc9orztsWjs+WVFNc3YnVqKnWdKcCy70qid5gVqrQ7708uxP70c//fTGYwMcMa1UR6YEeHBZBQy4mEvx7f3jcbLv6Rg49Fcg7G43Gpct+YgPlgQg5EDnS0UIRFR39AdFaWIiIiullarRUZGBoqLi43GHBwcMGjQIEgkvIGQiKi3kcvliImJQUpKCqqrqyGVShEZGQmxmKkkZBk88oiIiKjPeWJ6KPKqmnDLUG9MDnWzdDjUw2SU1WPnmRLsTCpBSnFdh9aRS4SYGOKKayM9MSXcje3hqMfxclDgrtH+uGu0PyobWvB7Sil2JpXgcEYF1GYymrQ64EhWJY5kVeI/25IR6+uIayM9MDPSA96OVt38DKinkoqFePnGSET7OGDFT2fQov6nXURFQwsWfHoMK2aF419j/SEQMGGYiIiIiKgv0mg0SE5ORnV1tdGYh4cHgoODIRSy3TQRUW8lFosRFRWFzMxMuLu7Qy7nzY5kOUxiIiIiol6pqVUNK6npP2VEQgHeXxDbzRFRT6XT6ZBaXI9df1dcOlfW0KH1rKUiTAl3x7WRHpgU6mr2eCPqaZxtZLh9hC9uH+GL2ibV+QpNSSXYf64crRcloFxMpztfWScutxr/3ZGKwd72mBnpgWsjPRHgYt3Nz4B6oluGeiPUwxYPbIpDQfU/7Qs1Wh1e/iUFifk1eP2WKL5XEhERERH1QUKh0GRFjoCAAPj4+PCGBiKiPkAgECAoKMjSYRAxiYmIiIh6n1P5NXjoq3g8OSMEN8V4Wzoc6oF0Oh1OF9RiZ1IJdiUVI6eyqf2VANjJxZg2yB3XRnpifLAL5BJRF0dK1LXsrSS4Zag3bhnqjYYWNf5KK8OupGLsSStHs0pjdr3TBbU4XVCLN3adRZiHLa6N9MS1UR4IdrPhyel+LHKAPX55eBwe3ZyIfenlBmPbTxUhvaQeHy0cysQ3IiIiIqI+RiAQIDQ0FEqlEvX19RAKhQgLC4Orq6ulQyMiom6i1WqRkpICHx8f2NvbWzoc6sNY25GIiIh6lc3H8zDvoyMorGnGs1vOIKWoY+3AqO/TanU4kVOFl7anYNzre3DDB4fw0b7MdhOYnKyluH2ED7741wicfO4arL41GtcMcmcCE/U5NjIx5gzxwto7hiL++Wvw0Z1DcWO0F2xlbd/bklZSj7d3p2P62/sxdfU+rPotDUmFtdDpTLepo77NwUqKzxcNxyNTjO/MO1taj08OZFkgKiJqz8qVKyEQCPSJqHV1dVi5ciWioqJgY2MDNzc3zJo1C4cPHzZYr6ysDM899xwiIiJgbW0NZ2dn3HDDDUhISGh3n1qtFps2bcKsWbPg4eEBhUKByMhIzJ07Fx9++CFaW1vb3UZ1dTWeeeYZhIWFQaFQwM3NDdOmTcP333/foed94TmvXLmyzXmTJk2CQCDApEmTOrTdSyUlJeG///0vZsyYAW9vb8hkMtjY2CA4OBh33303jh49anK9vXv3QiAQYPHixfplAQEB+rgv/Nu7d6/J9X/++WfMmzcPvr6+kMvlcHBwwLBhw/Diiy+abPdzqYKCAixduhQDBw6EXC6Hl5cX5syZg927d1/R69CWr7/+GpMmTYKjoyNsbGwQGRmJ//znP6ipqQHQ8d8VERFZjkgkQmRkJGxtbTFkyBAmMBER9SM6nQ5nz55FZWUlTp06hdLSUkuHRH0YKzERERFRr6BUabByWzI2n8i/aJkWD2yKw/Zl42BvJbFgdGQpao0Wx7OrsDOpBL8ll6CsvqVD67nZyjAz0gMzIz0wwt8JYhFz+6l/UUhF+v8DLWoNDmVUYOeZEvyRWoqaJpXZ9bLKG/HBnkx8sCcTPk4KXBvpiZmRHoj2doBQyApN/YVIKMC/p4disLcDHv8uEfVKNQAg3NMOz183yMLREVF78vPzMW3aNKSnp+uXNTY2YufOnfj999/xzTffYN68eTh9+jRmzZqFwsJC/bympiZs27YNv/32G3bu3InJkyeb3EdVVRXmzJmDQ4cOGS0/fPgwDh8+jLVr12Lnzp3w8/MzuY3U1FRMmzYNRUVF+mVKpRJ//vkn/vzzTyxevBgTJky4mpeiU+zdu9fk69Da2oqMjAxkZGTgyy+/xDPPPINXX321U/ZZXV2NuXPn4q+//jJY3tLSgri4OMTFxWHt2rXYunUrRo0aZXIbBw4cwOzZs1FX989NIcXFxdi+fTu2b9/eaclEarUaCxYsMEo8S05ORnJyMjZt2tQlSVNERNQ1pFIpYmJiWKGXiKifyc3NRVlZGYDzCU1paWlobm6Gn58fPxOo0zGJiYiIiHq8oppmPLgpDqcKao3GPOzlUGm1FoiKLEWt0eJgRgV2JZXg95RSVDW2fxc/AAxwUGBmpAdmRXkgxseRCRdEf5OJRZgS5o4pYe5QabQ4llWFnUnF+C25FBUN5hMD86uasW5/Ftbtz4KHnRwzIz1wbaQHRgQ48eRFPzFtkDu2LRuHBzbGobi2GR/dGQuFlFXsqBNptUBzlaWj6F4KJ0DYtcnV8+bNQ0FBAZ599lnMnDkTVlZWOHjwIP7zn/+grq4O99xzD4YNG4bZs2ejubkZr7zyCiZOnAiJRIJdu3bhlVdeQUtLCxYtWoRz585BKpUabF+j0WD27Nk4cuQIAGDixIlYtmwZfH19kZqais2bN2PXrl1ITU3F1KlTkZiYCBsbG4Nt1NXVYcaMGfoEpvnz5+Puu++Gm5sb0tPTsXr1aqxfvx5JSUld+lp1hFqthrW1Na677jpMmTIFYWFhsLOzQ1lZGZKTk7FmzRrk5ubitddeQ0hIiEHVpeHDh+PMmTPYunUrnnvuOQDAb7/9Bi8vL4N9BAQE6B+3tLRg2rRpiI+Ph0gkwoIFCzBr1iwEBARApVJh//79WL16NcrKyjBr1iwkJCQYJYrl5eXpE5iEQiHuu+8+zJ07F/b29jh9+jRee+01rFy5EsOGDbvq1+fJJ5/UJzCFhoZi+fLlGDx4MGpra/H999/jk08+wfz58696P0RE1Dm0Wi2ys7P1lQVN4fc9IqL+RafTob6+3mh5bm4umpubERoaCmEXf4+l/oVJTERERNSjHcmsxLKv41FpIlHlnnEBeObaMEhYRadfKK1TYvPxfGw+kYfiWmWH1glwsdYnVkQNsOeJNqJ2SERCjAt2wbhgF7x0QyRO5vxT6ayt/3cldUpsOJyDDYdzMNDFGgtG+mLuUG84WEnNrkN9Q4CLNX5aOgYZZQ3wc7a2dDjU1zRXAasCLR1F93oqE7B26dJdJCYmYt++fRg5cqR+2bBhwxAcHIzZs2ejvr4eI0eOhE6nw/HjxxEY+M/vYMSIEXBxccHSpUuRl5eHHTt24KabbjLY/kcffaRPYLrrrruwYcMGCAQCaDQa+Pj4YPr06VizZg1ee+01ZGZm4uWXX8brr79usI2XX34Z+fnnK7D+73//w7PPPqsfGzp0KObOnYvZs2fj999/7/TX53JFR0ejoKAADg4ORmMzZszAsmXLMHv2bPzxxx948cUXcdddd0EkOp/waW1tjcjISJw8eVK/TkhICPz9/c3u76WXXkJ8fDwcHBywe/duDB061GB83LhxuOOOOzB69GgUFxdjxYoV+OqrrwzmPPHEE/oKTJs2bcLtt9+uHxs2bBjmzZuH8ePHG8R1Jc6cOYP33nsPABAbG4t9+/YZJKxNnToVY8aMwd13331V+yEios6hUqmQkpKCmpoa1NTUIDo6Wv+ZRURE/ZdAIEBkZCQyMjIMKuUC51uQK5VKREZGQiJhtwzqHLziR0RERD2STqfD5wezcednx4wSmBQSEdbcHoPnZw9iAlMfp9PpcCijAg9uisOY1/7C27vT201gCnG3wSNTg7HrsfH464mJeHpmGAZ7OzCBiegyiYQCjBzojJVzInDo6Sn46aExuH/CQPg6WbW5XlZFI/67IxUj//cnnvz+FBLza6DT6boparIEK6kYg70dzI4X1zbj1zPF3RcQEbXpscceM0hguuC6667TV+wpLy/Hyy+/bJDAdMHixYshl8sBnG9JdqkPPvgAAODq6or333/f5N9gK1euRFhYGADgk08+QUvLP5X/Wltb8dlnnwEABg8ejGeeecZofYlEgs8++6xHnCR3cXExmcB0gVQqxapVqwCcv1M5MTHxivfV0NCgf31ffvllowSmC/z8/PD8888DAL7//ns0Njbqx0pKSvDTTz8BAGbPnm2QwHSBra0t1q1bd8VxXvDRRx9B+3fV3HXr1hlV3ALOJ7pde+21V70vIiK6Os3NzUhISEBNTQ2A8585qamp/C5HREQAzicyBQcHIygoyGisrq4O8fHxaGpqskBk1BexEhMRERH1OEqVBiu2nMGWhEKjMX9nK3y8cBhCPWwtEBl1l9omFb6Py8fXx/KQVdHY7vzIAXa4NtITMyM9EOhqfHGEiK6OUChAjK8jYnwd8cy1YUguqsOupBLsTCpGZrnp/6Mtai1+iCvAD3EFiBxghztH+mFOtBespPwa2p+0qDV4YFM8TuXX4P4JA/HUjFCImYBMZFG33Xab2bHBgwcjNzcXAoHAbIsvhUKB4OBgnDlzBllZWQZjRUVFSE1NBQDceuutsLU1/Te7WCzG4sWL8fTTT6O6uhrx8fEYPXo0ACAuLg7V1dUAgLvvvttsIrq3tzemT5+OHTt2tP2Eu1lLSwtKS0vR0NCgT+C5+ALwqVOnzCYftWffvn2orT3fYnvu3Lltzp0wYQKA81U14uLi9D/v2bMHGo0GAAxa211qxIgRiIiIQHJy8hXFCgC7d+8GAERFRbX5nP/1r39h586dV7wfIiK6OrW1tUhOToZKpTJYXl1djcbGRpNJqERE1D8NGDAAcrkcqamp+u8VAKBUKpGQkICIiIg2b/Ig6giePSYiIqIepaC6CfdvjENyUZ3R2JQwN7w9Pxr2CsvfcU2dT6fT4VRBLTYdzcX2U0VoUWvbnD/Y2x6zB3vi2khP+LRTGYaIOo9AIEDkAHtEDrDHkzNCca60HjuTSrDtVBEyyhpMrpNUWIdntpzBK7+m4pZYb9wx0hfB7kxG7et0Oh1e+DkZp/JrAAAf789CclEd3rs9Bo7WbDVIZCkhISFmxy6cbHZxcYGjo2O78+rr6w2WJyUl6R+bqvZ0sYvHk5KS9ElMZ86c0S8fPnx4m9sYMWJEj0hiamxsxJo1a7B582YkJycbnMy/VEVFxRXv5+L2bp6enh1er6SkRP/4cl/fK01iamlpwblz5zq8HyIisoyysjKkpaUZVVySSqWIjIxkAhMRERlxdnZGdHQ0kpKSDKrqqtVqnD59GiEhIfDw8LBghNTbMYmJiIiIeozDGRVY+nU8qptURmOPTAnCY9NCIBSyJVhf09SqxrbEImw6loukQuPktYspJCLcEO2FO0f5IXKAfTdFSERtCXa3RbC7LR6eEoTj2VXYdCwPu5KKodIYtx2oV6qx4XAONhzOwcgAJ9w5yg8zIjwgFbMyT190LLsK357MN1h2MKMC179/EB8vHIoIL76PUzsUTsBTmZaOonspnLp8F1ZW5pO/hUJhu3Munndpsk5VVZX+sZubW5vbuPik9sXrXc423N3d2xzvDjk5OZgyZQqys7M7NL+5ufmK91VWVnZF613c1qG7Xt/q6mr9BfHe8HskIupvdDod8vLykJOTYzRmbW2NyMhIfftYIiKiS9nY2CAmJgZJSUloaPjnpkadToezZ8+iubkZ/v7+ZivrErWFSUxERETUI1Q2tOCeL06iWWV4IcRGJsZbtw7BjAhm7vc1GWX12HQ0Dz/GF6BeqW5zbpCbDe4c6YubYr1ZiYuohxIIBBg50BkjBzqjvH4Qvjt5viVkYY3pi7XHsqtwLLsKLjYyzB/ujdtH+MLbkVXV+pJRA53xv5ui8J9tSQZJbQXVzbjlw8N4/ZbBuCF6gAUjpB5PKASsXSwdBV2hzjhZ3RtOeC9cuBDZ2dkQCARYvHgxbrvtNoSHh8PV1RVSqRQCgQBarRYikQgAjCpdXI6Lk8bi4+MhkXTs72Jvb2+Ty7vr9e0Nv0ciov5Eq9UiPT0dpaWlRmNOTk4IDw+HWMzLh0RE1DaZTIbo6GikpqaisrLSYCwvLw/Nzc0IDQ3Vfxci6ij+FUJEREQ9grONDC9cPwjPbvmnvcFAV2usWzgUQW5sOdRXtKq1+D2lBBuP5OJYdlWbcyUiAWZEeODOUX4YGeDEix9EvYirrQxLJwfhgYmB2Jdeho1HcrE3vRymrttWNLTggz2Z+HBvJiaHuuHOUX6YEOIKESvv9QkLRvoi1MMWD26KQ1n9PyXGlSotHt2ciDMFtXjm2jCIRazGRdQXODn9U0nK1IXRi13c4uzi9S5uY1daWtpm+7v29iEQCKDT6aDVtt2muLGxsc1xc9LS0nDw4EEAwIoVK/Df//7X5LyLqx9dDWdnZ/1jV1dXs8lJbbn09fXx8TE7t73Xty0XWg52ZDtXsx8iIro8KpUKycnJqK2tNRrz8vJCUFAQz78QEVGHiUQiREREICsrCwUFBQZj9fX10Gg0TGKiy8azhERERNRj3D7CF7eP8AUATAt3x89LxzKBqY8orGnGm7+dxZjX/sKyrxPaTGAa4KDAUzNCcfiZqXh/QSxGDXTmCTSiXkokFGBKmDvWLx6B/U9NxoOTAuFsLTU5V6sD/kwrw+INJzBx1R6s3ZuBioYWk3Opdxnq54jtD49DrK+D0dinB7Nx1+fHUdXY2v2BEVGni4yM1D8+duxYm3OPHz9ucr2oqCj94xMnTrS5jfbGbW3Pf5eorq42O0en0yEjI6PN7ZiTnJysfzx//nyz806ePNnmdjr6t25MTIz+8aFDhzq0zqU68/Vti1wuR3BwcJfvh4iIOq6pqQkJCQkmE5gCAwMRHBzM8y9ERHTZBAKB/nPkApFIhMjISEilps8DErWFSUxERETUo6ycMwiv3hyFdQuHwk7OtmG9mVarw56zZVjyxQmMf/0vvL/HfEKCQABMDnXFZ3cPw/7lk7F0chBcbWXdHDERdSUfJys8PTMMh5+dgndvi8YIfyezcwuqm/HGrrMY8+pfeHRzAk7kVF1V+x2yPHc7OTbfNxp3jPQ1GjucWYnr3zuIpELjiylE1Lt4eXkhPDwcAPDdd9+hoaHB5DyNRoMNGzYAOF8ZKDY2Vj82dOhQfbWgjRs3mn3/LywsxO+//95mPAEBAQDaTiLauXMnampq2tyOOWr1Py2R26rm9NFHH7W5Hblcrn/c0mI+gXfatGmwsjrfenXNmjVX9Nk4efJk/Z3QX3zxhdl5J06cQFJS0mVv/2LTpk0DAJw5cwYJCQlm533++edXtR8iImpfTU0NEhIS0Nxs2O5bKBQiMjLyiqr7ERERXczLywtRUVEQi8WIiIiAtbW1pUOiXopJTERERNStdDodEvNrzI7LxCLcPsIXQrYR6rUqG1rw4d5MTHxzDxavP4HdqWXQmrm+4mwtxYOTArH/qclYv3gEpoa7s4UUUR8nE4twQ/QAfPfAaPz22ATcNdoPNjLTnc5bNVpsTSzCvI+OYOY7B7DxSA7qlapujpg6i1QsxCs3ReG1m6MgvaR9XGFNM2758DB+SigwszYR9RZLly4FAJSXl+ORRx4xOeell15CSkoKAODee++FTPZP8rpMJsPixYsBAImJiVi1apXR+mq1Gvfeey9aW9uu4jZx4kQA56tCmapcVFJSgocffrgDz8q0i+80vpCUdakPP/wQW7dubXM7np6e+seZmZlm5zk4OGDZsmUAgMOHD+Pxxx9vs1VeaWkpPv30U6N93XDDDQCAbdu24bvvvjNar6GhAffff3+bMXfE/fffr6/ocd9995lM9Prqq6/w66+/XvW+iIiobfn5+QbJtwAglUoRExNj0K6UiIjoajg5OWHkyJEGbayJLheTmIiIiKjbNLWq8cjmRNy09hD2ni2zdDjUiXQ6HU7kVOHRzQkY/epfeH1XGvKrms3OH+HvhHdvi8bhZ6fg6Zlh8HGy6sZoiainCPWwxUs3ROLYiqn4301RGORpZ3bu2dJ6PL81GSP/9ydW/HQGKUV13RgpdabbRvhi8/2j4G5nWHGvRa3F49+ewkvbU6DWmL8oT0Q92wMPPIDRo0cDANavX4+pU6fixx9/RHx8PHbv3o0lS5bglVdeAXC+dc3zzz9vtI0XXnhBXxHi6aefxoIFC7Br1y7Ex8dj8+bNGDNmDHbu3Ilhw4a1Gct9990HsVgMnU6H66+/Hu+88w5OnjyJw4cPY9WqVYiJiUFtba1BMtLliImJ0bfC+/jjjzF//nz88ssviIuLw9atWzFv3jw89NBDGDt2bLvbuVCN6fnnn8cff/yB9PR0ZGRkICMjw6BqxksvvYSRI0cCAN59913Exsbigw8+wKFDh5CYmIg9e/bg/fffx4033ghfX1+TVaDeeustfau9BQsWYOnSpdizZw/i4uKwfv16DB06FAkJCe2+vu0ZMmSIPqnt5MmTGDZsGDZs2IC4uDj89ddfePDBB3HXXXdd9X6IiKh94eHh+mp+AGBjY4PY2FjY2NhYMCoiIuqLxGLTNysC568jlJSUsOI6tcn8EURERETUifIqm3DfxpNIK6kHADzyTQK2PzwOfs4sKdqb1StV+DmhEJuO5uFsaX2bc21kYtwUMwB3jvJDqIdtN0VIRL2BtUyMBSN9cfsIHyTk12DT0Vz8croYrWrjRJamVg2+PpaHr4/lIdbXAXeO8sOsKE/IJSILRE5XKtbXEdsfHoeHNsXjZG61wdi5snp95Q4i6n1EIhF++eUXzJkzB4cOHcJff/2Fv/76y2heeHg4du7cafLiqb29PXbt2oVp06ahpKQE33zzDb755huDOYsWLcLEiRP1VZtMiYiIwBtvvIF///vfqK6uxuOPP24w7uTkhJ9//hnPP/88zp07d9nPVSAQYOPGjZgyZQqqq6vx3XffGVU2ioqKwvfffw8vLy+z27G1tcUjjzyCN954A/Hx8Zg+fbrB+J49ezBp0iQA5ytV/fHHH1i0aBG2bNmCU6dO6aszmWJnZ5wg7O/vj23btmHOnDmor6/H2rVrsXbtWoM5L7zwAgQCQZut+Dpi9erVKCoqwpYtW5CWlmb0+woICMC3336LwMDAq9oPERG1TSwWIzIyEgkJCbCzs0N4eLi+vSgREVF3yczMRGFhISorKxEeHg6hkDV3yBiPCiIiIupy+9PLcf37B/UJTABQp1Tj/o1x0JjrM0Y9WoVajpd3nsOo//2J57cmt5nAFO5ph1duOl9p5eUbI5nARERmCQQCxPo6YvWt0Tj27FT836xw+Dubr9QWn1eDf393CqNf/RP/+zUVORXGbWqo53KzlePre0dh4Sg//TIfJwXeuz2GrUWJejknJyfs378fX375JWbOnAl3d3dIJBI4OjpizJgxWLNmDRITE+Hn52d2GxEREUhOTsby5csRHBwMmUwGFxcXTJ48GV9//TXWr1/foVgef/xx7Nq1CzNmzICjoyNkMhkCAgKwdOlSJCQkYPz48Vf1XKOjo5GYmIgHHngAfn5+kEgkcHJywogRI/Dmm2/i+PHjBu3izHnttdfwySefYPz48XBycmrzwrKtrS1+/PFHHDhwAEuWLEFoaChsbW0hFovh5OSE4cOHY+nSpfj111/xxx9/mNzGpEmTkJycjAcffBB+fn6QSqVwd3fHddddh127duHFF1+84tfkYhKJBD/++CM2btyI8ePHw97eHlZWVggPD8eKFSsQFxeHgQMHdsq+iIiobQqFAjExMYiIiGACExERdbvCwkIUFhYCACoqKnDu3DlWZCKTWImJiIiIuoxOp8NH+7Kw6rc0XJqrZCsXY/nMUF6k7EW0Wh3+PFuBn+oCUKKxBhJKzM6VioWYHeWJO0b5IdbXgRU1iOiyOVpLce+EgbhnXAAOZVZg09Fc7E4tM5n8Wt2kwrr9WVi3PwsTQlxx/4SBGBPozPeeXkAqFuLlGyMRNcAer/yaio/vHAYHK6mlwyLqc1auXImVK1e2O2/Dhg3YsGFDu/P27t3b7hyhUIiFCxdi4cKFAACNRoOysvMtpd3c3Dp08dTJyQmvv/46Xn/9dZPjixYtwqJFi9rdzowZMzBjxgyz4209H39//3ZPrPv6+uLDDz9sc0572xAIBFiyZAmWLFnS5ryLjRs3DuPGjevw/Ev5+PgYVWC6WEePm4648847ceedd3bKtoiI6MopFApLh0BERP1QS0sLsrKyDJaVlJTAysoKPj4+FoqKeiomMREREVGXaGxRY/kPp7HjTLHRWLCbDdbdNQwBLmwl1xuoNFpsP1WEtXszkVHWAMD8783P2Qp3jPTFvKE+cLTmRWgiunpCoQDjg10xPtgVJbVKfHM8D5tP5KG0rsXk/P3p5difXo5oHwcsnRyEqWFuEDJhtse7dbgPro3ygK1cYulQiIiIiIh6rcrKStTX18PPz483dRARUY8hk8kQGRmJpKQkaLVa/fKsrCzI5XK4urpaMDrqaZjERERERJ0ut7IR92+MM2gfd8G1kR5YNW8IbGT8M6SnU6o0+CGuAB/ty0RBdbPZeUIBMC3cHXeO8sO4IBcmCxBRl/Gwl+Pxa0KwbEoQ/kwtxaajeTiYUWFybmJ+De798iRC3W3x0ORAXBflCbGIHdV7srYSmGqaWvHS9hQ8OyscrrayboyKiIiIiKh3aGhoQEpKCrRaLZqbmxEaGgqhkN+BiIioZ3B0dERYWBhSUlIMlqelpUEmk8HOzs5CkVFPw6uHRERE1Kn2ni3DI98koE6pNlguEABPTg/FQ5MCeSdYD9fYosbXx/LwyYEslNWbrnQCAK42Utw+0g+3j/CBpz3LkRNR95GIhJgZ6YmZkZ7IKm/A18fy8H1cAWqbVUZzz5bW49HNiVj9RzoenBiIm2IHQCZuv4UR9RwarQ6PbE7E/vRyHMmqxEd3DsUQHwdLh0VERERE1GO0tLQYVLcoKyuDUqnE4MGDO9TClYiIqDu4uroiICAA2dnZ+mVarRZJSUmIjY2FXC63YHTUUzAFm4iIiDqFTqfDB3sysHjDCaMEJju5GJ8vGo6lk4OYwNSD1TS14p3d6Rj7+l945ddUswlMTiIlplnnY9fS4fj3NSFMYCIiixroaoPnZg/CsRVT8cpNkfBxMv2elFvZhGe2nMHEN/bis4PZaGpVm5xHPc9bv5/F/vRyAEBxrRLzPj6C707mWzgqIiIiIqKeQaPRICkpCS0thudx5HI5KzEREVGP4+PjAw8PD4NlKpUKSUlJUKt5vo5YiYmIiIg6QUOLGk99fwo7k0qMxkLdbfHxwqHwd7G2QGTUEWX1Snx2IBubjuaisVVjdl60jwP+NcoLKX98B4HgfCUUIqKeQi4R4Y6Rfpg/zAfbTxdh7Z5MnCtrMJpXUqfEy7+k4IM9GfjXWH8sHO0Pe4X5NmZkWfVKFbYmFhksa1VrsfyH0zhTUIvnZw+CVMzPIyIiIiLqn3Q6HVJTU9HQYPjdx87ODqGhobyZkIiIehyBQIDg4GAolUrU1NTolzc2NiIlJQVRUVH8/OrnmMREREREV+10fg12JRsnMF0X5Yk35g6GtYx/cvREBdVN+HhfFr49mY9WtdbsvLFBzlg6KQijA51RX1+P1N3dGCQR0WUSi4S4KcYbNwwZgD9SS/HBngycLqg1mlfV2Io3f0/Hx/uysHC0H/41LgAuNjILRExtsZVLsHXZWCz9Kh7HsqsMxjYezUVaSR0+uCMWbrYsN05E1JvpdDpLh0BE1CtlZWWhsrLSYJlcLkdkZCSrMBERUY8lFAoRERGBhIQENDU16ZdXV1cjIyMDQUHs6tGf8S8YIiIiumpjglzw5PRQ/c9CAfDMtWF4f0EME5h6oIyyBjzx3SlMWrUXG4/mmk1gmhbujp8eGoOvlozCmCAXfmkgol5FKBRgRoQHti4di433jMDIACeT8+pb1Fi7NxPjXv8LK7clo6imuZsjpfa42MiwaclI/GtsgNHYiZxqXP/eQSTkVVsgMiIiIiIiyykqKkJBQYHBMrFYjKioKEgkrDZLREQ9m1gsRmRkpNFnVlFREQoLCy0UFfUEvKpIREREneKhSYE4U1CLI1mVeO/2GEwIcbV0SHSJpMJarN2bgZ1JJTB3o7NQAMwe7IWHJgcizMOuewMkIuoCAoEA44NdMT7YFSdzqvDBngzsOVtuNE+p0mLD4Rx8dSwXN8d444FJgQhgK9QeQyIS4oXrByFygB2e3XIGLRcl4JbWtWD+x0fx8o0RmD/c14JREhERERF1j6qqKpw7d85gmUAgQEREBKysrCwUFRER0eVRKBSIiIjAqVOnDKqzZmZmQi6Xw8XFxYLRkaUwiYmIiIg6hUAgwJu3DkFVQyt8nXmypCc5kVOF9//KwL5044v2F0hEAswd6o37JwTCnxftiaiPGubvhPWLRyC5qBZr92bi1zPFRkmdKo0O357Mx/dx+ZgV5Ymlk4MQ7smkzp7i5lhvhLjb4v6NcSi8qGpWq0aLp388g9MFtfjP9RGQill4moiIiIj6psbGRqSkpBgtDwkJgYODQ/cHREREdBXs7e0RFhaG1NRUg+Wtra0WiogsjWf1ulhubi6eeOIJhIWFwdraGk5OThg+fDhWrVpl0N/xSmzYsAECgaBD/zZs2NDu9pqamvDGG29g+PDhcHJygrW1NcLCwvDEE08gNzf3qmIlIqK+Iau8Ab+eKTY7biMTM4Gph9DpdNiXXo5bPzqCeR8dMZvAJJcI8a+xAdi/fDJevXkwE5iIqF+I8LLHBwtisfvfEzFvqDfEQuN2mVod8MvpYlz77gHcs+EE4nLZrqyniBxgj23LxmJMoLPR2FfH8nD7J0dRVqe0QGRERERERF2rtbUVZ86cgUajMVju6+sLDw8PC0VFRER0ddzc3ODv7w8AEAqFiIyMhJeXl2WDIothJaYutH37dtx5552oq6vTL2tqasLJkydx8uRJfPrpp9ixYweCgoIsGOV5GRkZmDVrllH50bNnz+Ls2bP49NNP8dVXX2H27NkWipCIiCxtd0opHv82ES1qLTzt5YjxdbR0SGSCVqvDb8kl+GBvBpIK68zOs5WLcfdofywe6w9nG1k3RkhE1HMEutpg1bwheOyaEKzbl4nNJ/IN2pRd8GdaGf5MK8Pogc5YOjkIY4OcIRAYJz5R93G2keHLf43AqzvT8NnBbIOxuNxqzH7vIL6+dxSC3GwsFCERERERUefSaDRISkpCS0uLwXJXV1f9hV8iIqLeytfXF2q1Gu7u7rCx4fmc/oxJTF0kISEB8+fPR3NzM2xsbPDss89i8uTJaG5uxubNm/HJJ58gPT0d1113HU6ePAlbW9ur2t9vv/3WZjait7e32bH6+npcd911+gSme++9F7fddhsUCgX27NmDV199FXV1dZg/fz4OHTqE6Ojoq4qViIh6F61Wh/f+ysDbu9P1yx7cFI9tD4+Fm63cgpHRxVQaLbYlFuHDfZnIKGswO8/ZWop/jQvAwtF+sJNLujFCIqKea4CDAi/eEIllU4Lx2cFsbDqai4YWtdG8I1mVOJJViSE+Dlg6KRDTwt0hNFHFibqHWCTE87MHIWqAPZ7ZchpK1T8JaJ4OCng7KiwYHbVHJBJBrVZDrVZDo9FAJBJZOiQi6oW0Wq2+GgnfR4iorzt79izq6+sNltnZ2SEsLIw3WRARUa8nEAgQGBho6TCoB2ASUxd59NFH0dzcDLFYjN9//x2jR4/Wj02ZMgXBwcFYvnw50tPT8dZbb2HlypVXtb+QkJArzrRftWoV0tPPX5h+44038NRTT+nHRo8ejUmTJmHixIloamrCY489hr17915VrERE1HvUNqvw728T8WdamcHykjol3v7jHF69OcpCkdEFSpUG38cV4ON9mSiobjY7z9NejvsnDMT84b5QSHlyn4jIFFdbGZ65NgwPTgzEl0dy8PmhbFQ3qYzmncqvwX0b4xDqbouHJgfiuihPiEXs1m4pN8YMQJCbDe7fGIfCmma42Ejx0Z2xkEv4edeTWVlZ6asI1NTUwNnZuD0gEVF7GhoaoNPpAAAKBZNXiahv8/T0RFVVlT55Uy6XIyIiAkIhv4sQERFR38G/bLrA8ePHceDAAQDAPffcY5DAdMETTzyB8PBwAMC7774Llcr4xHh3UKlUWLNmDQAgPDwcTzzxhNGcMWPG4J577gEA7Nu3DydOnOjWGImIyDLSSupww/sHjRKYAGDOEC+8MHuQBaKiCxpa1Fi3PxPj39iD539OMpvAFOBijTduGYx9T03GorEBTGAiIuoAeysJHp4ajINPT8Fz14XD3c50282zpfV4dHMipq7eh2+O56HVRCs66h6RA+yx/eFxmBTqig8WxMLTnheyezoHBwf947KyMpSVlUGpVOqTEYiI2qLValFXV4eSkhL9squtdE9E1NM5OjoiJiYGcrkcIpEIkZGRkEqllg6LiIioW9TU1KC4uNjSYVA3YCWmLvDzzz/rHy9evNjkHKFQiLvuugvPPvssampqsGfPHkyfPr2bIvzHnj17UFtbCwC4++67zWbsL1q0CB9//DEA4KeffsLw4cO7LUYiIup+WxML8cyPZ9Cs0hgsFwqAFbPCcc+4AJaptpCaplasP5SDDYdzUNtsPgk6zMMWSycHYVaUJ0RsdUREdEWsZWIsGT8QC0f74ce4Qny0LxN5VU1G83Irm/DsljN420aKII0zBsmqLBAtOVlLsWHxiDbnqDRaSFg1q0eQy+Wwt7fXn5OorKxEZWUlBAIBW0L1UTqdDq2trQCA+vp6fp+gq6LRaAySHhUKBaytrS0YERFR97C2tkZMTAyam5v5vkdERP1GSUkJ0tPTodPpIJVKWc25j2MSUxc4ePAggPN/TA4dOtTsvIkTJ+ofHzp0yCJJTBdivTSeSw0bNgxWVlZoamrCoUOHuiM0IiKyAJVGi1d/TcPnh7KNxpytpXhvQQzGBLpYIDKqU6rw6f4sfHYwG42tGrPzYnwdsGxyEKaEufHCEBFRJ5GJRVgw0he3DvPGL6eLsXZvBtJLG4zmlTW0ogyeiFe6wuFYAZZMCmVLsx6kqVWNuR8ewewhnnhwYiA/J3sAT09PSKVSlJeX65fpdDqo1WoLRkVdRavVoqHh/Hunra0tW99Qp1EoFPD19eX7OhH1G1KplBWYiIio38jOzkZeXp7+59TUVERHR8PGxsaCUVFXYhJTF0hNTQUABAUFQSw2/xKHhYUZrXOlFi9ejLNnz6KiogJ2dnYICgrCtGnT8OCDD2LAgAFm10tJSTEZz6XEYjGCgoJw+vTpK4q1oKCgzfGLS781Njairq7usvdB1FkunFS99DGRpXTXMVnR0IqnfkpFXL7xe3Ckly1W3xwODzsp36O7mVKlwTdxxfj8SD5qm81f0Bvl74AlY3ww3M8eAoEA9fX1XRIP3yOpJ+HxSJYwJdAWkwZGY9+5KnxyKA9JxcbHnlInxpt/ZmPj8ULcP84XNw7xgJhV8SxKp9Phma1nkVJch5TiOsRlV+Dl2SGwkfXd0yK95T1SKpXCzc0NSqUSSqUSarUaWi1bM/ZFOp1OX3mLJ5vpagmFQkilUlhZWUEul1/2+1xjY2MXRUZE1Dl0Oh2TM4mIiACjz0ONRoOkpCTExMRAJpNZKCrqSn33bJ2FKJVKVFRUAAC8vb3bnOvo6Ahra2s0NjYiPz//qva7d+9e/eMLJdiPHTuGt956C++88w7uv/9+k+tdSC6ytraGg4NDm/vw8fHB6dOnUV5ejpaWlst6U/Dx8enw3C1btsDe3r7D84m60saNGy0dApGBrjomS9QK/N7gi0adxGhskLQKY5qS8dNXR7pk32SaRgektToirtnN5O/lAn9JHWLl5XCvbUbcTiCuG2PkeyT1JDweyRLG6YAAG2vEKV1RpDa+IF9a34qXdmbg3d+SMUJRikBJHXgdwjJOK51xqNlT//OfZysRd24PZtrkw1HUYsHIugffI6mnSUxMtHQI1M9dSKgjIuqJtFotTp8+DVdX1zZvUiciIuoP/Pz80NzcjLKyMv2ylpYWJCcnY8iQIWxJ3wcxiamTXVz1oCN3lV1IYrrSuyIHDhyIm2++GaNHj9YnCmVlZeHHH3/EDz/8AKVSiQceeAACgQD33Xef2Xg7GusFDQ0NzGwkIuojUloccaDJE1oYtnMQQYvxVsUIl1VbKLL+SacDzqnscaLZDXVa05+1AugQJK1FjLwczv3gwisRUU8lEADekkZ4SxpRolYgXumKXJWd0bxarQx/NPoiQdSMEYpS+IobmMzUzTQQANAB+OeFr9HK8WPdQEy2LkSglJUmiYiIiMjydDod0tLSUFtbi9raWjQ3NyMwkK2QiYio/xIIBAgNDYVSqTToFFJfX4+0tDQMGjSIn5N9DJOYOplSqdQ/7khP4guJQM3NzZe9r5tuugl333230X/K4cOHY/78+fjll19w8803Q6VS4fHHH8ecOXPg4eFhMt7LifVK4m2v0lRxcTFGjBgBALj55psREhJyWdsn6kwNDQ36O5UXLlzIMvdkcV19TO5MLsO+rWcNlnnaybD6lnBEeNp26r7IPJ1Oh/0ZVXhvXy7Sa8y3Npga6oxlE/wQ6Gptdk5X4nsk9SQ8HqmnaWhowJvrf8CxZncUmqjMVKFR4NcGf8R42+HRyf6I9WEF2u50KKsaz2xNM2jPqoIIvzf6YnGUNx6e5N+n2v7xPZJ6Gh6T1JOkp6fj1VdftXQYRERGcnJyUF5erv+5sLAQWq2W10yIiKhfEwqFiIiIQEJCgkE+RkVFBbKyshAYGGjB6KizMYmpk8nlcv3j1tbWdue3tJyvnqBQKC57X+21XJs9ezZeeOEFPP/882hqasJnn32G//u//zMZ7+XEeiXxttda72LW1tawszO+e5nIEmxsbHg8Uo/SFcfk/NF2OFvRis8PZQMAxgY5473bY+Fk3X6CK3WOo1mVWPXbWcTlmq96NT7YBU9OD8UQH4fuC6wdfI+knoTHI/UU7uJmzLHNQczM2/DBgXycKjBuV5NQUIdFG09jcqgrnpwRiggvJjN1h2uj7RDp64oHNsUhuciw8tL6owU4W96M926PgbNN36s6zPdI6ml4TJKlXVxxnoiopygpKUFeXp7BMpFIBC8vLwtFRERE1HNIpVJERUUhISEBavU/N6gVFBTAysoKnp6eFoyOOpOw/Sl0OWxt/6lY0ZEWcY2N5ystdNXdZ/fdd5++UtO+ffuMxi/EezmxAl0XLxERWcazs8IwMsAJD0wMxBeLRzCBqZskFdbirs+P47Z1R80mMEX7OODre0di4z0je1QCExERtW1UgCN+XjoWH905FMFupr8/7TlbjuvWHMTD3yQgu8J8FT7qPD5OVvjxwTG4Jdb4RpvDmZW4/r2DOJVf0/2BEREREVG/VlNTg/T0dKPlgwYN4vUYIiKiv1lZWZlsH5eeno7qavM3iVPvwiSmTiaXy+Hs7AzgfNZfW6qrq/WJQT4+Pl0Sj5ubmz6ewsJCo/ELFZIaGxtRU1PT5rYutIRzdXU1aC1HRES9g06nMzsmEQmxaclIPHNtGMQi/nnQ1TLKGvDQV3GY/d5B7E8vNzkn1N0Wn9w1DD89NAZjAl26OUIiIuoMAoEAMyM9sOuxCXhz3hAMcDBd0Xb7qSJMW70Pz245jeLay281TpdHLhHhzXmD8fKNkZCIDE96FdUqMe+jI9h8PM/M2kREREREnaupqQnJyclG5+6CgoLg5ORkoaiIiIh6JkdHR5NtVpOTkw2KslDvxauUXWDQoEEAgIyMDINSZpdKS0vTPw4PD++yeC7NRLzYhVgvjedSarUamZmZALo2ViIi6hp1ShXu/TIOO88Um50jYfJSlyusacbyH05h+tv78OuZEpNzfJwUeHv+EPz66HhcM8i9zc9xIiLqHURCAeYO9cZfT07Ei3Mi4GKiXZlGq8M3x/MxcdVe/PeXFFQ1tt/ym66cQCDAwlF+2HzfaLjbGf4+WjVaPLPlDJ7dchotao2FIiQiIiKi/kClUiEpKcnoWtKAAQMwYMAAC0VFRETUs3l4eBgVidFoNEhKSkJrK8+p9Xa8WtkFxo0bB+B8daO4uDiz8y5u7zZ27NguiaW8vBwVFRUAYLJv8oVYL43nUidPntRnLnZVrERE1DXOltTjhvcPYXdqKZ78/hQyyuotHVK/U9nQgpe2p2Dyqr347mQBtCaKYrnayvDyDRH489+TcFOMN0RCJi8REfU1MrEId4/xx/7lk/DUjFDYysVGc1rVWnx6MBsT3tiDd3ano6HF/I0xdPWG+jli+8PjMCLA+A73b47nY82f5ywQFRERERH1B1qtFsnJyWhuNqzG6uzsjMDAQAtFRURE1DsEBATAxcWwi4VSqURSUhK0Wq2FoqLOwCSmLnDjjTfqH69fv97kHK1Wiy+//BIA4ODggMmTJ3dJLOvWrdOXIJ04caLR+KRJk2Bvbw8A+OKLL8y2GtqwYYP+8U033dT5gRIRUZfYfqoIN35wCNkV5xNRG1s1uG9jHOqVKgtH1j/UKVVY/ftZTHhjDz4/lI1WjfEfznZyMZ6eGYZ9T03CwtH+kIr55xkRUV9nJRVj6eQgHFg+GQ9OCoRcYvze39Cixju7z2HCG3vw6YEsKFWsCNRV3Gzl+GrJSNwzLsBgeaCrNR6cFGShqIiIiIioL9PpdEhPT0dtba3BchsbG4SHh7MyNxERUTsEAgHCwsJga2trsNzR0ZGfo70cr5J1gREjRmD8+PEAgM8++wxHjhwxmvPWW28hNTUVAPDoo49CIpEYjO/duxcCgQACgQCLFi0yWj8nJwcJCQltxvHLL7/gpZdeAgAoFAosXrzYaI5UKsUjjzwCAEhNTcWbb75pNOfIkSP47LPPAJxPhBo+fHib+yUiIstTabR4+ZcUPPxNApovuehZ06RCbmWThSLrH5QqDdbtz8SEN/ZgzV8ZaGw1vvCskIiwdHIgDjw9BQ9OCoSV1LgaBxER9W0OVlI8PTMM+5+ajIWj/CA2UYWvqrEV/92Rislv7sXm43lQm0iIpasnEQnx/OxBePe2aCgkIlhLRfh44TDYyPj5TERERESdLy8vD6WlpQbLpFIpIiMjIRKJLBQVERFR7yISiRAZGQmZTAaBQIDQ0FAEBAQwiamX49m4LvLuu+9i7NixaG5uxvTp07FixQpMnjwZzc3N2Lx5M9atWwcACAkJwRNPPHHZ28/JycHkyZMxevRoXH/99RgyZAjc3NwAAFlZWfjhhx/www8/6Csrvfnmm2b7Jz/11FP49ttvkZ6ejuXLlyMjIwO33XYbFAoF9uzZg//9739Qq9VQKBR45513ruwFISKiblNe34JlX8fjWHaV0dhgb3t8eOdQDHBQWCCyvk+l0eK7k+dbz5TWtZicIxEJcMdIPzw0ORButvJujpCIiHoiNzs5Xr4xEveOH4i3d6fj58RCXFokt7hWiWe2nMG6/Vn49/QQzIr0hJCtRzvdDdEDEOphi+IaJYLcbCwdDhERERH1QWVlZcjJyTFYJhQK9RdhiYiIqOOkUimioqKgUqng4OBg6XCoEzCJqYvExMTg22+/xZ133om6ujqsWLHCaE5ISAh27NhhVOLschw5csRkpacLrKys8Pbbb+O+++4zO8fW1hY7duzArFmzcO7cOaxbt06fZHWBnZ0dvvrqK0RHR19xrERE1PXi86rx4KY4kwk0tw33wco5EZBLeDdXZ9Nqddh+ughv/5GOHDNVroQC4KYYbzw2LRg+TlbdHCEREfUGvs5WeHt+NO6fOBBv/Z6OP1JKjeZkVTRi2dcJiPDKxJMzQjEpxJV3l3WyMA87hHnYmR0vq1eirlnNJCciIiIiumwtLS04e/as0fLw8PCrulZERETUn1lbW1s6BOpETGLqQtdffz1Onz6Nd999Fzt27EBBQQGkUimCgoIwb948LFu2DFZWV3YRc+jQodi0aROOHDmCkydPori4GBUVFVCr1XB0dERERASmTp2KJUuW6Cs0tSUoKAgJCQn44IMP8P333yMjIwOtra3w8fHBrFmz8Oijj8LPz++KYiUioq6n0+mw6VgeXtqeDJXGsHSDVCTEizdE4PYRvhaKru/S6XTYc7YMq35LR2pxndl5MyLc8eT0UAS782QUERG1L8zDDp/cNQzxedVYtessjmRVGs1JLqrD4vUnMMLfCctnhmKYv5MFIu1/VBotln2VgJTiOrw5bwhmRnpYOiQiIiIi6kVkMhnCwsKQlpYGrfZ8q+jAwEC4uLhYODIiIiKinoFJTF3Mz88Pq1evxurVqy9rvUmTJulbwZlia2uLO+64A3fcccfVhqhnbW2N5cuXY/ny5Z22TSIi6npKlQbP/ZyEH+IKjMa87OVYe+dQRPs4dH9gfdyxrEqs+u0sTuZWm50zLsgFT84I5etPRERXJNbXEV/fOxKHMirxxm9pOF1QazTneE4V5n50BFPC3PDk9FAM8jJfQYiu3v9+TcXxnPMtex/YFIcHJwXiyemhELG13N+nIQABAABJREFUHxERERF1kKurK2QyGZKSkuDq6ooBAwZYOiQiIqI+q6GhARkZGYiIiIBEIrF0ONQBTGIiIiLqxfKrmvDgV3FIKjSuAjQm0Bnv3R4DZxuZBSLru5IKa7Hqt7PYl15uds4QHwc8PSMUY4J4Fx0REV0dgUCAccEuGBs0Fr8ll+DN39ORUdZgNO+vtDL8lVaG64d44d/XhCDAhWW0O9vulFKsP5RjsOzDvZk4U1CLNbfHwMlaapnAiIiIiKjXsbOzw9ChQyGVStkemoiIqItUVlYiJSUFWq0WSUlJGDJkCIRCoaXDonYwiYmIiKiXamxR46a1h1HR0GI0dv/EgXhqeijEIv4x1llyKxvxxm9nseN0sdk5Ie42eGJ6KKYPcucJKCIi6lQCgQAzIz1xzSAPbIkvwDu7z6Gwptlo3vZTRfj1TDFuHeaDx68Jhput3ALR9k1jg1xwc+wAbIkvNFh+MKMC1793EB/eGYvB3g6WCY6IiIiIeh2ZjDceEhERdZWysjKkpqbqf66rq8PZs2cRFhbG6zc9HK9sEhER9VLWMjGWTg40XCYVYe0dsXj22nAmMHWSmqZWvLQ9BdNW7zObwOTtqMDqW4dg56MTMCPCg38AExFRlxEJBZg3zAd/PTkRK68fBBcb4+o/Gq0O3xzPw6RVe/Hu7nNoalVbINK+RyEV4a15Q/DyDRGQiAw/6wtrmjH3oyP47kS+haIjIiIiIiIiIqIL7O3tjRKGy8rKkJ/Pczc9Ha9uEhER9WKLxvjjhmgvAMBAV2tsXTYWs6I8LRxV39Ci1uCT/VmY8MYefH4oGyqNzmiOi40ML90Qgb+emISbY70hEjJ5iYiIuodMLMKisQHY99RkPDk9BLZy40LLTa0avL07HZPf3IvvTuRDozX+LKPLIxAIsHC0PzbfNwputoYnwlrVWiz/8TSe3XIGLWqNhSIkIiIiop5CqVQiISEBtbW1lg6FiIio35HJZIiMjIRIJDJYnpOTg6amJgtFRR3BJCYiIqJeTCAQ4LWbB+O+CQOxdelYBLnZWjqkXk+n02H7qSJMW70Pr/yaijqlcfUKO7kYT80Ixf7lk3DXaH9IxfyTioiILMNaJsayKcE4sHwyHpgYCLnE+DOptK4Fy388jevWHMCBc+UWiLLvGernhF8eGYcR/k5GY98cz8OtHx9FkYl2f0RERETUP+h0Opw7dw51dXVITExEeno6VCqVpcMiIiLqV2xsbBAeHm6w7MJntE7Hm/16Kl5xIyIi6gVqNMatYi5QSEVYMSsctnJJN0bUN53MqcJNaw/j4W8SkF9lfOFRKhLivgkDcWD5FCydHAQrqXHVCyIiIktwsJLimWvDsO+pyZg/zAemOpumldRj4WfHcffnx3G2pL77g+xj3Gzl+OrekfjX2ACjsVP5Nbj+vYM4nFlhgciIiIiIyNIqKytRVVWl/7m4uBh5eXkWjIiIiKh/cnZ2hre3t8GympoalJfzRr+eiklMREREPZhKo8Wbf2Zhc10wClXWlg6nz8qpaMSDm+Iw96MjSMyvMTnn+iFe+POJiVgxKxz2VkwYIyKinsndTo7X5w7Gr4+Mx4QQV5Nz9qWX49p39+OZH0+jrE7ZzRH2LRKREC9cPwjv3hYNhcSwPHllYyvu/PQYPt6Xybv7iIiIiPoRjUaDjIwMg2USiQR+fn4WioiIiKh/8/f3h0wmM1iWmZkJtdq4EwdZHpOYiIiIeqiimmbctu4ovjxWCB0E+L3RByV1LZYOq0+pbmzFi9uTMW31PuxMKjE5Z7i/I356aAzeuz0GPk5W3RwhERHRlQn3tMOX/xqBL/41AmEexu1mtTpg84l8TFy1F+/sTkdTK0/aXI0bogfgp6Vj4Ods+LeCVgccyqwEc5iIiIiI+o/c3Fy0tBiewwsMDIRYzIreREREliASiRAYGGiwrLW1FTk5OZYJiNrEJCYiIqIeaM/ZMly35gDicqv1y5Q6Mf69JRUqjdaCkfUNSpUG6/ZnYsKqPVh/KAdqrfGVRX9nK3x051B8d/9oxPg6WiBKIiKiqzcxxBU7HhmPN24ZDDdbmdF4s0qDd3afw6RVe/HtiTxoTHwmUseEedhh27JxmBrmpl/mYSfHO/OjIRSa6O9HRERERH1OY2MjCgoKDJY5ODjAzc3NzBpERETUHVxcXODk5GSwrLCwEPX19RaKiMxhEhMREVEPotZo8fquNCxefwLVTSqDMSG0uHmIO8S8CHbFdDodtp0qwrTV+/C/X9NQrzSuOuFgJcF/rh+E3x+fiJmRHhAI+HoTEVHvJhIKcOtwH+x9ahIenxYCK6nIaE5ZfQue/vEMrltzAPvSyy0QZd9gr5Dgk7uG4fFpIZCIBHhvQQycrKWWDouIiIiIuoFOp8O5c+cMWgkLBAIEBwfz/BIREZGFCQQCBAUFQSg0TJG59LObLI+1K4mIiHqIklolHvkmAcdzqozGbIWtmGGdh7kxE3nS4wodz67CK7+m4lR+jclxqUiIxWP98dDkINgrJN0bHBERUTewkorx6LRg3D7CB6v/SMd3J/NxaeGltJJ63P35cYwPdsGKWeEI97SzTLC9mFAowKPTgjF3mDcGOCgsHQ4RERERdZPS0lLU1tYaLPPx8YGVlZWZNYiIiKg7KRQK+Pr6GrSRq6+vR3FxMby8vCwXGBlgJSYiIqIeYF96OWatOWAygWlqiDPm2WbAVay0QGS9X1Z5A+7feBK3fnzEbALTnCFe+POJiXh2VjgTmIiIqM9zs5PjtVsG49dHx2NiiKvJOQfOVWDWmgNY/sMplNbxb5Ar0VYCU01TK25bdwSnC2q6LyAiIiIi6jIqlQpZWVkGy+RyOXx9fS0UEREREZni4+MDhcLwnE12djZaW1stFBFdiklMREREFqTWaPHmb2exaP1xVDUa/oEkEQnwwuxBWH1LOGRCrYUi7L2qGlux8v/Zu+/wqMq0DeD3tPReJr0XkkCA0DsJIL2IIihIW+ygWD4b6q6661rBBRUVRbBhQ0QQkB4InQABAum9955MMu37IzIyzCQESGZS7t91eV2Tc94z82R2lpw5536fd8cVTPzwKPZeKdI7ZoivA7YvH4l1D0TAy4Gz4oiIqGcJcbXB1/8Ygm/+MQQhrtY6+9Vq4OfYXES+H40P9yejrlF3GVa6dSqVGs/9fBGn0stx76cnsPl4BtuWExEREXVxGRkZkMvlWtsCAwMhEuku5UxERETGIxQKERQUpPlZIBDAw8ODf7M7ES4nR0REZCTF1TI8+cMFnM7Q7b7kYWeOTxYMQH8vO1RXVxuhuq5LJlfi6xOZ+PhwKmpk+m+2+jlZ4qUpIZgY5sLl+YiIqMcbE+yMkYFO+PV8LlbvS0JRdaPW/ga5EmsPpmDLmWw8d1cw7hvkBZGQfz9v1xcx6TiYWAwAkCvVeH3nVZzJLMc79/aFjRk7QhIRERF1NdXV1SgoKNDa5uTkBEdHRyNVRERERK2xt7eHVCpFU1MTgoKCuPRrJ8MQExERkRGcSCvFUz9cQGmtbnvKu8Jc8MGcfrC14E2sW6FSqbHzUj7e+zMJeZUNesfYW0jw9IRgzB/qDYmIDSmJiIiuEQkFmDvIC9P7uuHLmAx8diQN9U1KrTElNY14adtlbDqeiZenhmBssDPDwLdIpVLjcFKxzvbdlwtxJb8an8wfgD4etkaojIiIiIhuh1qtRnJystY2oVCIgIAAI1VEREREbREcHAyhUMhrW50Q794REREZgUKpRtkNy8eJhQK8Oi0UGxYOZIDpFp1OL8Ps9cex8sc4vQEmE7EQj40NwJEXorB4hC8DTERERC2wMBHjqfFBiH4+Eg8M8Ya+hktJRTVYsuksFn11Blfz2THyVgiFAny7bCgeHeuvsy+rrB73rD+Bb09mcnk5IiIioi4iLy8PdXV1Wtt8fX1hZmZmpIqIiIioLUQiEQNMnRTv4BERERnBmGBnrIgK1PzsbmuGnx4djodG+/Ok6Rakl9TikW9iMW/DKVzMrdI7ZlZ/dxx6bixemhLCJVqIiIjaSGpthrfvCceelWMQ2ctZ75iYlFJM+ygGz/9yEYVVMgNX2HVJREK8PCUUGxcPgt0NwfUmpQqv/X4FT/5wATUyuZEqJCIiIqK2MjU1hUTy9zmdpaUlPDw8jFgRERERUdfG5eSIiIiM5OkJwTibWQ4LEzFW39cP9pYmxi6pyyirbcS6gyn4/nQ2FCr9nQqG+Dnglamh6OdlZ9jiiIiIupFertbYvHQIYlJK8N/diUgo0O68pFYDv5zLxc5L+XhktD8eGRsAK1NeamiL8aEu2PXUaKzYch4Xsiu19v1xqQBX8qvx8fwI9Hbn8nJEREREnZWzszPs7e2RkZGB/Px8BAUFQShk/wAiIqKuTCaTsauiEfHKIhERUQdSqdQQCKC3u5JIKMAXiwbB0kQMob61WkiHTK7EpuOZWH84FTWNCr1j/J0s8dKUENwV5sKuVkRERO1kdJAz/njSCdvO5+KDfUkoqm7U2i+Tq7DuUCq2nMnBs3cFY+4gT4i5fOtNediZ46dHhuO9PxPx5bEMrX0ZpXWYvf4EXp/RGw8M8eJ5DREREVEnJRaLERQUBC8vL97wJCIi6sKUSiWys7ORk5ODsLAwODk5GbukHolXFImIiDpIaW0jFn11Bt+dzm5xjLWZhAGmNlCp1Pg9Lg/jVx/Bu38m6g0wOVia4M1ZvbH3mTGY2NuVN/qIiIjamUgowH2DvBD9f1F47q5gWJiIdMaU1jZi1W+XMWVtDA4nFkOt1t8xkf5mIhbi1elh2LBwIGzMtOeaNSlUWPXbZTz9UxzqWghwExEREVHnwAATERFR11VeXo7Y2FhkZ2dDrVYjNTUVSqXS2GX1SAwxERERdYBT6WWYujYGx1JL8e+dVxGfV2Xskrqs2MxyzP70BFb+GIe8ygad/SZiIR6PDED085FYNNwXEnZ9ICIi6lDmJiI8OT4I0c9HYv5Qb+jLY6cU12Lp5rNY9NUZJBXWGL7ILmhib1fsemq03qVwf4/Lx5cxGboHERERERERERHRHZPL5ZDJZJqfGxsbkZWVZcSKei7e5SMiImpHKpUanxxOxfwvTqG4pnmZlSalCsu3nEe1TG7k6rqWnPJ6LP/+POZ8dhIXcyr1jpkd4YFDz43Fi5NDYGMmMWyBREREPZzU2gz/nR2OP58eg3EhUr1jYlJKMWXtUaz67TJKahr1jqG/eTlY4JdHh2PpSF+t7eEetngs0t84RRERERGysrLw3HPPISQkBJaWlnBwcMDgwYPx/vvvo76+/o6ee/PmzRAIBG36b/Pmze3zC9FtY0cGIiKi7kkqlcLOzk5rW25uLurq6oxTUA8mvvkQIiIiaouy2kY88/NFHE0u0dnX0KREXkUDbNwYtLmZapkcnxxOxaZjmWhSqvSOGerngFemhaKvp51hiyMiIiIdwS7W+GrJYBxPLcVbuxJwtaBaa79KDWw5nY0dcfl4IioA/xjpBzOJ7lJ01MxELMS/ZvTGUD9HPL/1IqAGPpk/AKZivmdERETGsHPnTjz44IOorv77HKe+vh6xsbGIjY3Fl19+iV27diEwMNCIVZIhqNVqxMfHQywWIzAwEKampsYuiYiIiNqJQCBAUFAQYmNjoVarATT/7U9JSUG/fv0gEOhpRU4dgiEmIiKidnA2sxxPbrmAwmqZzr7RQU74cF5/OFnxwkZrFEoVfjybgw/3J6OsrknvGD8nS6yaGooJoVKeMBIREXUyIwOd8MeTo7DtQh7e35uIomrtzku1jQq892cStpzOxktTQjAt3I1/z1sxuY8rwtxskF1eD29HC2OXQ0RE1CNduHAB8+bNQ0NDA6ysrPDyyy8jKioKDQ0N+PHHH/HFF18gOTkZ06ZNQ2xsLKytre/o9fbu3Qt3d/cW93t6et7R89OdKSkpQWVlJQCgoqICPj4+8PT05DktERFRN2FhYQEvLy9kZ2drtlVVVaGoqAiurq5GrKxnYYiJiIjoDqhUanx+NB0f7EuCUqXW2icUAM9MCMbyqEAIhbyY0ZojySV4a9dVJBfV6t1vay7B0xOCsGCoD0zEXA2XiIiosxIKBZgz0BNTw13x+ZF0fH40DTK5dmfF3IoGrNhyAV95Z+C16WGI8LY3UrWdn7ejRasBpozSOpzPqsC9A3lDk4iIqCOsXLkSDQ0NEIvF2LdvH4YPH67ZN27cOAQFBeGFF15AcnIyVq9ejddff/2OXi84OBi+vr53VjR1CIVCgbS0NM3PSqUSubm5cHNzg1jMW21ERETdhbe3N4qLiyGT/d20ID09HY6OjpBIuNqKIfAuIBER0W2qqGvCsq/P4t0/E3UCTM7WpvjuoaF4cnwQA0ytSCmqweKvzmDxV2f0BpjEQgH+MdIPR56PxNKRfgwwERERdREWJmI8c1cwov8vCvcO0B+wOZ9didnrT2DljxeQV9lg4Aq7PplciSe+P4/nfrmI53+5iIYmpbFLIiIi6lbOnDmDmJgYAMCyZcu0AkzXPPfccwgNDQUArF27FnK53KA1kuFkZmaiqUm7c3hgYCADTERERN2MSCTSWSZYLpcjIyPDSBX1PLwTSEREdBvOZZVj6roYHE4q0dk3MtARu58ajREBTkaorGsoq23Eq9svY/LaGBxJ1n0PAeCuMBfse2YM/jkjDHYWJgaukIiIiNqDq60ZVs/th50rRmGIr4PeMb/H5WPcB9H4YG8SahsVBq6w63pj51UkFFQDAH45l4tZnxxDanGNkasiIiLqPrZv3655vHTpUr1jhEIhFi1aBACorKzE4cOHDVEaGVhNTQ3y8vK0tjk4OMDJidf+iIiIuiNHR0edv/MFBQWorq42UkU9C0NMREREt0CtVmPD0TTM+/wUCqpkWvsEAuDpCUH45h9D4WxtaqQKO7dGhRKfH0lD5PvR+O5Utk4HKwAIc7PBloeG4otFg+DvbGWEKomIiKi9hXva4qdHh+GzBwfA20F3ebRGhQofH05F1AfR+Oms/nME+tvFnEr8cCZba1tyUS1mfnwcv13INVJVRERE3cuxY8cAAJaWlhg4cGCL48aOHat5fPz48Q6viwxLrVYjJSVFa5tQKERgYCAEAnZfJyIi6q4CAgIgFGrHaZKTk6FW85pVR2OfSyIioluQW9GAD/enQHHDjTUnKxOsvT8CIwM5A0sftVqNPfGFeHtPAnLK9S8X42xtiucn9cK9Azwh4hJ8RERE3Y5AIMDkPm6ICpHimxNZWHcoBTUy7c5LJTWNePHXy9h8IguvTQvFCJ5b6dXPyw7rHojAy79eQt11y8jVNynxzE8XcTq9HM9GehmxQiIioq4vISEBwM2XDAsJCdE55nYtXboUSUlJKC0thY2NDQIDAzFhwgQ8/vjj8PDwuO3nzc1tPeRcUFCgeVxTU2OwLgO1tbV6H3cmpaWlqKnR7nbp4uICuVzO5QM7qa7wuaKuhZ8pam/8THUdrq6uyM/P1/xcV1eHtLQ0SKVSI1aln7E+VzeeJ7UHhpiIiIhugZeDBf5zdx8898tFzbZh/g5Yd38EpDZmRqys87qYU4n/7LqKs5kVevebioV4dIw/Hh0bAEtTnpoQERF1d6ZiER4e4497B3pi7YFkfHdat/NSQkE15n95GhNCpXh5aigC2J1Rx8x+7ujtboPl359HYqH2BaMfz+bgXGYZBipNYC9qMlKFREREXZdMJkNpaSkAwNPTs9Wx9vb2sLS0RF1dHXJycu7odaOjozWPy8rKUFZWhtOnT2P16tX43//+h0cfffS2ntfLq+3h5m+//Ra2tra39Tp34ttvvzX4a96MRCJBv379tEJsDQ0N2L59O7swdBGd8XNFXRs/U9Te+Jnq3AQCAcLDw2Fh8XdX8ezsbOzYsaNTh5kN+bmqqqpq9+fknUIiIqJbdO9AT5zOKMMv53LxZFQgVk4IZucgPQqqGvD+n0nYdiGvxTGzIzzw/KRecLczN2BlRERE1Bk4WJrgjVl9sHC4D97alYDDSSU6Yw4kFCM6qQQPDvPB0xOCYGdhYoRKO68AZytsXz4Sb+y8gh/OaN80TSmpRyYCMNYyv4WjiYiIqCXXzyi3srp5mPpaiOl2Z737+/vjnnvuwfDhwzWBo/T0dPz666/YunUrZDIZHnvsMQgEAjzyyCO39Rp067y9vXW6cGVkZDDARERE1EOo1Wqkp6ejT58+mm0ikQje3t5IS0szYmXdG0NMREREt+GNmX1wzwBPDPN3NHYpnU5dowKfH03HhqNpkMlVescM8rHHq9PD0N/LzrDFERERUacTKLXGpqVDcDS5BG/tSkBSkXZXIYVKjc0nMvHbhTw8NT4IC4f5wEQsNFK1nY+ZRIS37+mLoX6OWPXbZdRft7ycHCIcqPPCG7tT8O97+sHChJeBiIiI2kImk2kem5jcPERtamoKoLlLz62aPXs2Fi9eDIFAe4Lc4MGDMW/ePPzxxx+45557IJfL8cwzz2DmzJlwdXW9pde4WYeogoICDBkyBACwcOHCO1q67lbU1tZqOgUsXLiwTYExQ6mpqUFqaqrWNnt7eyxYsMBIFVFbdebPFXVN/ExRe+NnquvJyspCeXk5AMDOzg69e/fGxIkTjVyVNmN9rvLy8vD222+363Py6hUREZEe0UnFOJlWhpenhurdb24iYoDpBiqVGlvP5+KDvUkormnUO8bT3hwvTwnF1HBXnYtzRERE1LONCXbGiABH/BybizX7k1Baq70MWlWDHP/+4yq+O5WFl6eE4K4wF55PXOfuCA/08bDF8u/P6wTBfo0rxPncGnw4rz9D5ERERG1gZmamedzUdPOlWRsbm6+DmJvfeqfpmy3dNn36dPzzn//Ea6+9hvr6emzcuBGvvPLKLb3GzZbEu561tTVsbGxu6fnbg5WVlVFeVx+VSoWkpCStbSKRCCEhIW0KtVHn0Zk+V9Q98DNF7Y2fqa4hJCQEly9fhq+vLxwcHIxdzk0Z8nNVXV3d7s/JqYtERETXkcmV+Nfv8Viy6Sw+P5qOPZcLjF1Sl3AyrQwzPj6GF7Ze0htgsjYV46UpITjw7FhM6+vGG45ERESkl1gkxPyh3jj8f5F4IjJAb8eljNI6PPLtOcz/4jSu5FcZocrOK1DavLzc3EG6NyozSutw76cnkHJDwImIiIh0WVtbax63ZYm4uro6AG1beu52PPLII5prKUeOHOmQ16C/5ebmor6+Xmubn58fA0xEREQ9lEQiQURERJcIMHUHDDERERH9JT6vCtM/OoavT2Zptr3822UUVslaOapnyyitwyPfxOKBL07hSr5u2looAB4c5o3Dz0fisbEBMJOIjFAlERERdTXWZhK8MDkEB58di+l93fSOOZlehukfHcMLWy+iuJrna9eYm4jw3px++M+MYIih1No3o68bglysWziSiIiIrjEzM4OjY3MH7tzc3FbHVlRUaEJMXl5eHVKPVCrV1JOXl9chr0HNZDIZsrKytLZZW1vD3d3dSBURERFRZ8DJ+YbDEBMREfV4SpUan0anYfb640gt1p5dV1kvxw9nso1UWedVVd+8nMvED49g39UivWPGBDvjz6fH4D93h8PJytTAFRIREVF34OVggY/nD8Cvj4/QuwyaWg38HJuLyA+ise5gChqalLpP0kPNDHfBXJs0SEXNXQQ87Mzxxqw+Rq6KiIio6wgLCwMApKamQqFQtDguMTFR8zg0NLTD6uGNM8OQSCTw9PTUer+DgoL4/hMREREZiNjYBRARERlTbkU9nv35Is5klOvsM5MI8cq0MDw41NsIlXVOcqUK35/Kwv8OpqCyXq53TJDUCq9MC0VkL6mBqyMiIqLuaqCPPX57YgR2XMzHe38mIa+yQWt/fZMSa/Yn44cz2Xhhci/M6ucBoZA3mmxFTZhtnQ5h+FSMDXWHrbnE2CURERF1GaNGjUJMTAzq6upw7tw5DB06VO+465d3GzlyZIfUUlJSgtLSUgBgR6AOJhKJ4OfnBxcXF6SkpMDCwkJreUEiIiKi68nlcjQ0NMDGxsbYpXQbDDEREVGPtf1CHl7bHo+aRt3ZdH08bPC/eREIlFoZobLOR61W41BiMd7anYD0kjq9YxwsTfDMXcF4YLAXxCI2eyQiIqL2JRAIMKu/Byb1dsXGYxlYfzgVdTd0XiqokuGZny5i8/FMvDo9DIN9HYxUbechFACPj/Zp9WLaocQiiIVCjAl2NmBlREREndvdd9+Nt99+GwCwadMmvSEmlUqFb775BgBgZ2eHqKioDqllw4YNUKvVAICxY8d2yGuQNgsLC/Tt21fzvhMRERFdT61Wo7i4GGlpaRAIBBg8eDDEYsZv2gPvMBIRUY9TVS/HUz9cwNM/xekEmAQCYHlUALY9PpIBpr9cya/CgxtPY9nXsXoDTCYiIR4d44/o5yOxcJgPA0xERETUocwkIiyPCsTh5yNx/2Av6FvZ42JuFe777CSe+P4cssr0B7CpWVG1DM/+fBGLvjqDN3ZegUzOJfmIiIgAYMiQIRg9ejQAYOPGjTh58qTOmNWrVyMhIQEAsHLlSkgk2l0Po6OjIRAIIBAIsGTJEp3jMzMzceHChVbr+OOPP/Dmm28CAMzNzbF06dLb+XXoNggEAgiFvM5FRERE2hQKBS5evIjExETI5XI0NTUhMzPT2GV1G4yCERFRj3IirRT/9/NF5FfJdPZ52Jnjw3n9McSPM/YBoLBKhg/2JeHX87loadLZ1HBXvDQ5FN6OFoYtjoiIiHo8qbUZ3rm3LxYN98Vbu6/ieGqZzpjdlwux/2oRFg33xZPjAmFnYWKESjsvlUqN//vlomaZ4E3HM3E8tRT/mxeBMHe2QSciIlq7di1GjhyJhoYGTJw4EatWrUJUVBQaGhrw448/YsOGDQCA4OBgPPfcc7f8/JmZmYiKisLw4cMxY8YM9OvXD1KpFACQnp6OrVu3YuvWrZpuQB988AE8PDza7xckIiIiolsmEokgEom0tuXl5cHFxYXL0LYDhpiIiKhHaFQosWZfMjbEpOsN5NwT4YHXZ/WGjZlEd2cPU9uowIYjadgQkw6ZXKV3TF9PW7zGJVqIiIioEwhzt8F3y4a2uPStXKnGxmMZ2HouF0+OC8TC4T4wFYtaeLaeZd/VIsSklGptSy6qxd2fHMf/TQrGQ6P8IRTqaXVFRETUQ0REROCnn37Cgw8+iOrqaqxatUpnTHBwMHbt2nVHN6xOnjypt9PTNRYWFvjwww/xyCOP3PZrkH5qtRoymQzm5ubGLoWIiIi6CIFAgMDAQMTGxkKl+vs+WkpKCiIiIiDQ1zac2owhJiIi6hEUSjX2XinUCTDZmInx1uxwzOjnbpzCOhGFUoWfY3OxZn8ySmsb9Y5xszXDC5N7YVY/D97QIiIiok5DIBBgfKgLxgQ74/tTWfjfwRRNd6Frqhrk+M+uBHxzMgsvTQnBlD6uPf6i0qTeLnhzVm+8tSsBjYq/L7o1KVX47+5EHEosxpq5/eFux5t6RETUc82YMQOXLl3C2rVrsWvXLuTm5sLExASBgYG47777sGLFClhY3F6H6oEDB+K7777DyZMnERsbi4KCApSWlkKhUMDe3h69e/fG+PHj8dBDD2k6NFH7KioqQnJyMry8vODt7a3TVYGIiIhIH3Nzc3h7e2stI1dTU4OCggK4u/Oe451giImIiHoES1MxPpzXH3M+OwmlqjnJNCLAEavn9oObbc++KaNWqxGdXIK3dycguahW7xhLExEejwzAslH+MDfhxRwiIiLqnCQiIZaM9MPsCE98Ep2Kzccz0aTU7iyZXV6PJ74/jwHednhlWhgG+tgbqVrjEwgEWDTcFyMCHLHyxzhcya/W2n8qvRyT/ncUb80Ox0yG/omIqAfz8fHBmjVrsGbNmls6LjIyUrMUnD7W1tZYsGABFixYcKcl0m1QKBRIT0+HWq1GdnY2iouLERwcDHv7nnt+SERERG3n5eWFoqIiNDQ0aLZlZGTAyckJJiYmRqysaxMauwAiIiJDifC2x1PjgmAiEuLVaaH4btnQHh9guppfjYUbz2DpprN6A0xCAbBgqDein4/CinFBDDARERFRl2BrIcGqqaE48OxYTO/rpnfM+exK3PvpCSzfch7ZZfUGrrBzCZRa47cnRuLxyADc2JyqRqbAUz9cwNM/XkBVg1z/ExARERF1QQUFBZDL/z6/kclkWkvCEBEREbVGKBQiKChIa5tCoUBBQYGRKuoe2ImJiIi6HZlcCTOJ/rDN8qgATOvrikCptYGr6lwKq2RYvS8JW8/n6iyxd824EClenhKCIJee/V4RERFR1+XtaIGP5w/AP0ZV4K1dCTiXVaEzZtelAuy7UojFw33x5Lgg2FpIjFCp8ZmIhXhxcggig53x7M8XkVfZoLV/e1w+zmZWYPXcfhjm72ikKomIiIjah1qtRn5+vtY2R0dHODryPIeIiIjazt7eHs7OzigpKdFsy8/Ph7e3NwQ3zhSjNmEnJiIi6jZqGxV4/peLWPTVGc2ScTcSi4Q9OsBU16jAmv3JiPogGr+c0x9gCnOzwfcPDcVXSwYzwERERETdwgBve2x9bDg+XTAAPo4WOvvlSjW+PJaBMe8fxsZjGWhS9NwZ+EP9HbHn6dGYHeGhsy+vsgEPfHEK7+xJ7NHvEREREXV95eXlkMlkWtu8vLyMVA0RERF1ZTeeQzQ1NaGsrMxI1XR9DDEREVG3cC6rHFPXxuCXc7k4k1GOz4+mGbukTkWpUuOHM9kY+3401h1MQYNcqTPG1cYMH9zXD388OQojA52MUCURERFRxxEIBJgS7ob9z4zFa9PDYGuu23GpqkGOf/9xFXd9eAS7LxdA3VLLym7OxkyCD+f1x7oHImBjpt3EW60GvohJR1JhjZGqIyIiIrpzN3ZhsrKygo2NjZGqISIioq7M2toa1tbaTQHy8vKMVE3XxxATERF1aXKlCmv2JeG+z04iu7xes33NvmTE51UZsbLOQa1WIzqpGFPXxuDlbZdRWtuoM8bSRIT/mxiMw/8XiTkDPSEUsr0lERERdV8mYiGWjfLD0eej8NAoP0hEuuc+WWX1eOL785jz2Umcz9Zdgq6nmNnPHX8+PQbDb1g+bkVUIMI9bY1UFREREdGdkclkKC8v19rm7u7OJV+IiIjotnl4aHe0rqysRH19fQujqTUMMRERUZeVXlKLOZ+ewLpDqbhx9TgziQh5lQ3GKayTuJpfjUVfncGSTWeRVKQ7U14oAOYP9cbh5yOxYlwQzE1ERqiSiIiIyDhsLSR4dXoYDj4biWl93fSOOZdVgXvWn8DyLeeRU94zLzy525nj+4eGYtXUEEhEAvT3ssOT4wKNXRYRERHRbbuxC5NIJIJUKjVSNURERNQdODs7QyzW7mZ94zkHtY345kOIiIg6F7VajR/O5ODff1zVuyzaIB97fDivP7wcLIxQnfEVVcuwel8SfjmXi5ZWQInq5YyXp4Yi2MVa/wAiIiKiHsLb0QKfzB+Af4yswFu7ruJ8dqXOmF2XCrD/ShEWj/DBiqgg2FroLkXXnQmFAjwyJgCjAp1haSqCWKR/TpxarWYHAyIiIurUVCoVCgsLtba5urpCJOLkPiIiIrp9QqEQbm5uyMnJ0WwrLCyEn58fzzNuEUNMRETUpZTVNuLFXy/jQEKRzj6xUICnJwThsbEBLd5Y6c7qGhX4/Gg6vjiarjfcBQChbjZ4ZWooRgU5Gbg6IiIios5toI89fn18BPbEF+KdPYlaSxUDQJNShS9iMvDLuVw8NS4IDw7zgYm4Z51zhrnbtLr/86PpyCipwz9nhMHSlJeciIiIqPMpKSmBXC7X2ubu7m6kaoiIiKg7uTHEJBKJUF9fD2trNhS4FbyiREREXcbhxGI8v/USSmsbdfb5O1niw3n90c/LzvCFGZlSpcYvsTlYvT8ZJTW67w0AuNiY4v8m9sI9AzwhEnJ2PBEREZE+AoEAU8PdMD5Uim9PZuGjQ6moatC+yVVZL8ebf1zF1ycz8dLkEEzu48ruQwDi86qwel8S5Eo1TmWU4cN5/THA297YZRERERFpuXFZFzs7O1hY9Mxu7kRERNS+zM3N4eDgAJVKBXd3dzg5OfGa0W1giImIiDq9hiYl/rs7Ad+eytK7f8FQb7wyLRQWJj3vz9qR5BL8d1cCkopq9O63MBHhsbEBeGi0X498f4iIiIhuh6lYhIdG+2POQE98dCgV35zMhFypvU5vVlk9Hv/+PAb52OOVaaGI6MGBHZlciad/itO8R1ll9bjvs5NYERWIJ8cF9sguqURERNT51NbWorq6WmsbuzARERFRe+rduzeEQl4HuRO8m0lERJ1aUbUMD3xxCukldTr7HC1N8N6cvhgf6mKEyowroaAa/92dgJiUUr37hQJg3mBvPHNXEKTWZgaujoiIiKh7sLMwwWvTw7BouA/e+zMJuy4X6IyJzarA7PUnML2vG16cHAIvh543k/9KfjUKKhu0tilVaqw9mIIjySX4cF5/+DlZGqk6IiIiomY3dmEyMTGBo6OjkaohIiKi7ogBpjvHd5CIiDo1JytTSK1NdbaPD5Hiz6fH9LgAU3FNI17YehFT18W0GGCK7OWMPSvH4O17whlgIiIiImoHPo6W+GTBAPz6+HBEeNvpHfPHpQKMX30E/92dgKp6ud4x3dVAH3vsWTkGA310u1HF5VRi2roYfHsqCyqVWs/RRERERB1PoVCgqKhIa5ubmxtvNBIRERF1Mjw7IyKiTk0kFGD13P6wNmtuHmgmEeKt2X3w5eJBcNYTbuqu5GoBzjZIMf2zWPwcmwu1nvs/Ia7W+HbZEGxeOgS9XK0NXyQRERFRNzfQxwHbHh+BT+YPgJeDuc7+JqUKG46mY+wHh7HpeAaaFCojVGkc3o4W+OmRYXjurmCIhAKtffVNSry2PR7zNpxEanGtkSokIiKinkwoFCIkJAR2dnaabW5ubsYriIiIiIj04nJyRETU6XnYmeM/d/fBxmMZ+HBefwQ4Wxm7JINRKFX4Na4QW6qCUa+WANC9EeZiY4rnJvbCvQM8dW4YEREREVH7EggEmNbXDRPCpPj2ZBbWHUxBtUyhNaayXo43dl7F1ycy8cLkEEzp4wqBoPufp4lFQjw5Pgijg53xzE9xyCjVXhL6bGYFpq6NwZPjAvHo2ACYiDm3joiIiAxDKBTC2dkZzs7OqKurQ3V1NUxNe84ESSIiIjKuhoYGmJmZ9YjrQ3eKISYiIuoUopOKIRAIMDbYWe/+Wf09MC3cDWJRz7jRoVar8Wd8Id7fl4T0kjoAEp0xFiYiPDomAA+P8YOFCf+kExERERmSqViEh0b7Y85AT6w7mIpvT2VCrtRul5lZVo8nvj+Pfp62eHFyCEYEOhmpWsPq72WHXU+Nwr//SMAPZ7K19jUpVVi9Pxl/XCrAO/eGI8Jbdwk6IiIioo5kaWkJS0tLY5dBRERE3ZxarUZ5eTny8/NRXl6OPn36wNHR0dhldXo9404wERF1WuV1TXjmpzgs2XQWL2y9iGqZvMWxPSXAdCK1FHd/chyPf3/+rwCTNqEAeGCIF6L/LxIrJwQxwERERERkRHYWJvjnjDDsf2Yspoa76h1zMbcK8788jYUbT+NybpWBKzQOCxMx3r4nHN8tGwpvBwud/UlFNbjn0xPYfiHPCNUREREREREREXWsK1euID4+HuXl5QCA/Px8I1fUNfSMu8FERNTpqNVq/B6XhwlrjuC3v25cFFU34t09iUauzHgu51Zh4cbTmP/laVxs4ebWSH977Fk5Bm/f0xdSGzMDV0hERERELfF1ssT6BQOx9bHh6O9lp3dMTEopZnx8DMu3nEd6Sa1hCzSSUUFO2Pv0GDwyxh83rnxsZy7B6KCe0Z2KiIiIiIiIiHqWG7sulZeXo6GhwUjVdB0MMRERkcHlVtRj6eazWPljHMrrmrT2fX86G/F5PWN2+jXpJbVYvuU8Znx8DDEppXrHOIkaMN0qA5/e3we9XK0NXCERERERtdUgXwf89sQIfDJ/APyc9C9TsutSAe768Che3nYZRdUyA1doeOYmIqyaGorfl49CqJuNZvs/Z4TB0crUiJUREREREREREXUMqVQKkUikta2goMBI1XQdXH+GiIgMRqlS45uTmXh/bxLqm5Q6+63NxHhlaijCrrux0Z0VVcuw9mAKfjqbA6VKrXeMn5Mllo/2QurhrRAI9A4hIiIiok5GIBBgWl83TOztgl9ic7H2YDKKqhu1xihVavxwJhu/XcjFkhF+eHxsAGwtJEaq2DDCPW2xY8VIfBGTjrjsStzd38PYJREREVE3plKpkJycDGdnZzg4OEDAi2tERERkQCKRCK6ursjLy9NsKywshK+vL4RC9htqCUNMRERkEEmFNXjx10uIy6nUu39KH1e8MbN3j1girapejk+PpGHziQzI5Cq9Y1xsTLFyfDDuG+SJhrpapEUbtkYiIiIiunMSkRDzh3pjdoQHvj6ZifWHU1EtU2iNkclV+OxIGraczsLjkYFYMsIX5iaiFp6x65OIhHgiMhBqtbrFG4mltY14Y+dVvDi5FzztLQxcIREREXUXZWVlKCoqQlFREczMzODu7g5PT0+GmYiIiMhg3N3dtUJMcrkcJSUlcHFxMWJVnRtDTERE1KEaFUp8cigVnx5Jg1yp221Iam2KN2f1weQ+rkaozrAampTYfCITn0br3ry6xsZMrHPziqvjEhEREXVt5iYiPDY2AA8M9sZnR9Ow6bhumL1apsC7fyZi0/EMrJwQhLmDvCARdd9Zea3dPHxz51XsvJiPgwlFeH5SLywa7guRkDcbiYiI6Nbk5+drHstkMpSWlsLLy8uIFREREVFPY2FhATs7O1RWVmq25efnM8TUCoaYiIiow8RmluPFXy8hraRO7/4HhnjjpSkhsDXv3stmyJWqFpcRucZMIsTSkX54bEz3X0aEiIiIqKeytZDgxckhWDLCt8VlhYtrGvHKb/H4MiYDz00MxtQ+bhD2oADP4cRi7LjYfMOxvkmJN3Zexe9x+Xj33r7o5Wpt5OqIiIioq6irq9O6WQg0d0IgIiIiMjR3d3et85Lq6mrU1NTA2prXOfRhiImIiDrE+uhUvPdnkt59fk6WePuecAzzdzRwVYalUqmxO74Aq/clI6NUf5BLJBRg3mAvrBwfBJcesJQeEREREQEuNmb47+xwPDzaH6v3JeGPSwU6YzJK67BiywWEe6Tjhcm9MCrQqdsvfaJWq7HuUIrO9ricSkz/KAaPjw3A8nGBMBV33+X2iIiIqH0UFGifX0kkEjg7OxupGiIiIurJHB0dYWJigqamJs22goIChpha0H37khMRkVEN9LbX2SYWCrA8KgB7Vo7u9gGmmJQSzPrkOFZsudBigGl6XzcceHYs/js7nAEmIiIioh7Iz8kSH88fgJ0rRmF0kJPeMZfzqrBw4xks+PI0LuZUGrZAAxMIBNi8dAjmD/XW2SdXqrHuUCqmro3B2cxyI1RHREREXYVSqURhYaHWNldXVwiFvCVGREREhicUCuHm5qa1raioCAqFwkgVdW48YyMiog4x1N9R6+ZDX09b7FgxCs9PCoGZpPvOnL6YU4kFX57Cwo1ncDmvSu+Y0UFO2LliFD6ePwB+TpYGrpCIiIiIOptwT1t8u2wotjw0FP287PSOOZFWhlmfHMfj351DanGtYQs0IFtzCf47Oxw/PjJM77lyWkkd7vvsJF7bHo8amdwIFRIREVFnV1RUBKVSqbWNS8kRERGRMd0YYlKpVDqha2rG5eSIiKjDvDQlBCfTyrBgqDeWjvSDSNh9l79ILa7F6n1J2BPf8glHP09bvDg5BCMC9c+yJyIiIqKebUSgE7YHOGLvlUK8tzcJ6SW6HT33xBdi75VC3DfQC0/fFQQ3W3MjVNrxhvk7Ys/K0fjoUAo+P5IOhUqttf/bU1nYf7UI/767D+4KczFSlURERNTZqNVq5Ofna21zdHSEmRm7oBMREZHxmJqawsnJCaWlpZpt+fn58PDwgEDQfe+f3g6GmIiI6LZlldXhu1NZeHlKKIR6Ako2ZhLse2YMJKLu2/ivoKoBaw+k4OfYHNxwX0XD39kSL0zqhUm9XXkiQkREREStEggEmNzHDRNCXfDr+Vz870AKCqpkWmNUauCn2Bz8FpeHJSN88URkAOwsTIxUcccxk4jw/KQQTAt3x0vbLuFSrnan08JqGR7+JhbT+rrh9Rm94WxtaqRKiYiIqLOorq5GXZ12EJxdmIiIiKgzcHd31woxNTQ0oLKyEvb29kasqvNhiImIiG6ZQqnCV8czsGZ/MmRyFbwdLbFwmI/esd01wFRZ34RPo9Ow+UQmGhUqvWPcbM3w9IQg3DvAE+Ju+j4QERERUccQi4SYN9gbs/p74NuTWfgkOhWV9drLpzUpVNhwNB0/nMnGY2MDsHSkLyxMut+lnjB3G/z2xEhsOp6B1fuS0SDXXh5m16UCnEorQ/TzkbA2kxipSiIiIuoMbuzCZGZmxhuDRERE1CnY2dnBwsIC9fX1mm35+fk8V7lB97uyRUREHSo+rwovbbuE+LxqzbZ39yRiQqi02y5lcb36JgU2Hc/EZ0fSUCNT6B1jay7B8qgALBruCzOJyMAVEhEREVF3YiYR4eEx/pg3xAsbjqRj47EMnRBPjUyB9/cmYfOJTDw1Pgj3D/YyUrUdRyQU4KHR/pjU2xWrfruMmJRSrf1zBnoywERERNTDNTU1oaSkRGubu7s7O6MTERFRpyAQCODu7o7U1FSYmJjAzc0Nbm5uxi6r02GIiYiI2kQmV+J/B1LwRUw6lDesm1bbqMD/9qfg3Tl9jVRdx5MrVfjxbA7WHUxBSU2j3jHmEhGWjfLDw2P8YWvOGyhERERE1H5szCT4v0m9sGiEDz46mIofzmRDccN5eUlNI17bHo8vY9Lx+CgvqNVAd7tn5+VggW/+MQTbzufh37uuorJeDh9HCzw9IdjYpREREZGRFRYWQq3++/xIIBDA1dXViBURERERaXNxcYGJiQkcHR0hFHIVF30YYiIiops6kVaKVdsuI7OsXmefQAAsGuaD5yeHGKGyjqdSqfHH5QKs3peELD2/PwCIhQI8MMQbT44PhNTazMAVEhEREVFPIrU2w7/v7oOHRvthzf5k/B6XrzMmq6weL/2eBCdRAIaaF2ndzOsOBAIB7h3oibG9nPHmzquYN9gL5ibsgEpERNSTqdVqnaXkpFIpJBJONCQiIqLOQywWw9nZ2dhldGoMMXWwrKwsrFu3Drt27UJOTg5MTU0REBCAuXPnYvny5bCwsLjt566vr8eff/6J/fv3IzY2FqmpqaitrYWNjQ2Cg4MxadIkPPbYYzedaRAZGYkjR4606TW724VPImpdVb0cb+9JwI9nc/TuD5Ja4Z17+2KgT/dbq1WlUmPvlUKsPZiCxMKaFsfN6u+OZ+8Kho+jpQGrIyIiIqKezsfREmvvj8AjY/zx/t4kRCeV6IwpVZpjV60v8r+9hOcmhWJkoGO3Wk7FycoU6x6IaHXMF0fTUVbXhKcnBHGpZyIiom6svLwcjY3a3dPd3d2NVA0RERER3S6GmDrQzp078eCDD6K6ulqzrb6+HrGxsYiNjcWXX36JXbt2ITAw8Jaf+9KlSxg5ciRqa2t19pWXl+PUqVM4deoUPvzwQ2zYsAHz5s27o9+FiHoWtVqNHRfz8Z9dCXqXTpOIBFgeFYjHIwNgKu5eNwJUKjX2xBdi3cEUJBW1HF6K7OWM5yf1Qm93WwNWR0RERESkrbe7LTYvHYJT6WV4989EXMiu1BlzIbcaD248jYE+9nh6QhBGBTp1qzBTSzJK6/DBviQ0KlT4M74A/5rZG1G9pMYui4iIiDqAQqGAiYkJmpqaAABWVlawtrY2clVEREREdKsYYuogFy5cwLx589DQ0AArKyu8/PLLiIqKQkNDA3788Ud88cUXSE5OxrRp0xAbG3vLJ9PV1dWaANPIkSMxffp0DBo0CI6OjigpKcG2bdvwxRdfoLq6GgsWLICNjQ2mTJnS6nMOGjQImzZtuu3fmYi6h7icSry58wrO67n5AQADvO3w7r19EeTSvS4CqFRq7I4vwLqDKUgu0g2IXhPhbYcXJ4dgmL+jAasjIiIiImrdMH9HbHt8BPZfLcL7e5OQUqx7TnsuqwILN57BAG87rJwQjDFB3TfMpFar8fK2S2hUqAAAmWX1WLrpLCJ7OePVaaEIlHav7zNEREQ9nYuLC5ydnVFWVoa8vDy4uLh02/McIiIiou6MIaYOsnLlSjQ0NEAsFmPfvn0YPny4Zt+4ceMQFBSEF154AcnJyVi9ejVef/31W3p+oVCIuXPn4l//+hfCwsJ09k+cOBFTpkzB7NmzoVQq8eSTTyIlJaXVk3ZLS0v06dPnluogou4lPq8Kd39yXO8+SxMRXpwSggeH+kAo7D4XAJQqNXZdLsBHB1P03ui5JtjFCv83sRfuCuMFECIiIiLqnAQCASb2dsX4UBdsOZGK93bHo0ZlojPufHYlFn91Bv297PD0hCCMDXbudue4V/KrcS6rQmd7dFIJYlJKsXCYD56eEAQ7C933h4iIiLomoVAIZ2dnODs7Q61WG7scIiIiojZpaGhAQUEBBAIB/Pz8jF2O0QmNXUB3dObMGcTExAAAli1bphVguua5555DaGgoAGDt2rWQy+W39BojRozATz/9pDfAdM2sWbNwzz33AADS0tJw4cKFW3oNIup5ervbYHSQk872cSFS7H92LBYN9+02ASalSo3f4/Iw6X9H8dQPF1oMMAW7WOGT+QPw58oxmNjbtdvd3CEiIiKi7kckFGBWXxc8YJOCsRZ5cLc11TsuLqcSSzadxd3rT+BwUnG3utnXx8MWu58ajQHedjr7lCo1Np/IxNj3o7H5eAbkSpXhCyQiIqIOxWt4RERE1NnV1dXh8uXLOHPmDHJycpCXlwelUmnssoyOIaYOsH37ds3jpUuX6h0jFAqxaNEiAEBlZSUOHz7cIbVERUVpHqelpXXIaxBR9yEQCPDqtDBcyyn5Olrgi0WDsHHxILjbmRu3uHZyLbw08cMjWPljHFJbCC+FuFpj/YLm8NK0vm7dJrxFRERERD2HSKBGmGkFdj42CO/eGw5Pe/3n9BdzKrF001nc/clxHEos6jZhpiAXa2x9bAQ+uK8fpNa6Qa6qBjle33kVk/93FIeTio1QIRERERERERH1VCKRCOXl5ZqflUolioqKjFhR58Dl5DrAsWPHADQvzzZw4MAWx40dO1bz+Pjx45g4cWK719LY2Kh5LBKJ2v35iahrSi6qQZDUSu+MpF6u1nh0bAAcLEyweIQvTMTdI++qUKqw81I+PjqUivSSuhbHhbha4+kJQZgY5srgEhERERF1CxKREPMGe+OeAZ747XwePj6ciuzyep1xF3Or8I/NsejraYuV44MwLkTa5bsYCIUCzBnoiSl9XPFpdBo2xKSjSaHdeSmtpA5LN51FZC9nvDotFIFSayNVS0REREREREQ9hZmZGRwdHVFWVqbZlp+fDzc3ty5/PeZOMMTUARISEgAAgYGBEItbfotDQkJ0jmlvR44c0Ty+tnxdSxITEzF06FAkJSVBJpPByckJAwcOxL333osHHngAEonktuvIzc1tdX9BQYHmcV1dHaqrq2/7tYjuVG1trd7H3UFRTSPWHs7EH/HFWDsnDFHBjnrHPT7CHQAgq6+FzJAFdgCFSo09V4qx4XgOssobWhzXS2qJx0Z7IyrYEUKBALW1NQassnXd+TNJXQ8/j9SZ8PNInQ0/k9SZtPR5nNzLFuMDI7ArvhhfnMhBToXuGf+l3Cos+zoWYa5WeHSUNyKDHLrFxbNHhrthWqg9/nc4A3sTSnX2RyeVICa5BPcPcscLE/y7xe/cmfDfSOpM6upantxERF2HTNZ8HmNmZmbkSoiIiIhuj7u7u1aI6VpWwtbW1ohVGRdDTO1MJpOhtLT5Qpinp2erY+3t7WFpaYm6ujrk5OS0ey0XL17Erl27AADh4eE3DTEVFRVptSfLy8tDXl4eduzYgXfffRdbt2696XO0xMvLq81jt23b1qP/T0mdy7fffmvsEtqFXC3ARZkTLsicofhrJdHXtl3A/TapEAm6x1IRN1KpgeQmO5yXOaNKpbt0xDVOogYMMiuGb1MNkg+dRvIhAxZ5G7rLZ5K6B34eqTPh55E6G34mqTNp6fM4VQ0kW9jhnMwZ1XrOma8W1mLl1qt/nzNLatAdcj3+AO62tsDxejeUKLWX2FOqgdiLV/BZ6j7jFNdD8N9IMraqqipjl0BE7SArKwuFhYVwdHSEu7s77O3tGUImIiKiLsXe3h5mZmaacDbQ3I2pJ+clGGJqZzU1f3fusLKyuun4ayGm9p6B1tjYiIceeghKpRIA8NZbb7U4VigUYvz48Zg6dSr69esHR0dH1NTU4Pz58/j888+RkJCAq1evIioqCmfOnIG3t3e71kpEHUetBlLltjhV74JatYnWvmqVKS43OqC/WVkLR3dN18JLLd2Iuaa73YghIiIiIrpVQgEQYlqJYJNKpPx1Dq1vAkCp0hx/1vnASdSAgWbF8OsG59Bu4nrca52GpCY7nG5wQb26ufu0GEoMNS+6ydFERERkbHK5HMXFxQCAsrIylJWVISAg4KaTy4mIiIg6E4FAAHd3d6Snp2u2lZSUICAgACYmJq0c2X0xxNTOrk/IteVDZWrafHGwoaHlJY5ux4oVKxAbGwsAWLx4MWbMmNHi2G3btsHOzk5n++jRo/HEE0/g4Ycfxtdff42ioiI8/fTT2LZt2y3Xc7NOUwUFBRgyZAgA4J577kFwcPAtvwZRe6mtrdXMCl24cGGbAomd0eX8Gry3Pw0X8/Qvi2ZlKsK4MaMwb6C7gSvrGHKlCrvim5eNy61veRG8UFcrPD7aG2MDu86SGN3lM0ndAz+P1Jnw80idDT+T1JnczufxZksxlyrNsbfOB72klnh0lDfG9Wpeirmrq29SYuOJHHx9OhePjPLHIyMjjV1St8R/I6kzSU5Oxttvv23sMojoDhQVFUGlUml+FggEkEqlRqyIiIiI6Pa4uroiIyMDanXz6jlqtRqFhYU9trkMQ0zt7Pq1l5uamm46vrGxEQBgbm5+k5Ft9/bbb+PLL78EAAwePBiffPJJq+P1BZiukUgk+PLLL3Hq1CkkJSXht99+Q15eHjw8PG6ppluZ/WBpaQkbG5tben6ijmJlZdXlPo+FVTK892citl3I07tfKADuH+KNZ+8KhpNVy52Kugq5UoVt53Px8eFU5Oi50XJNX09brBwfhHEh0i4TXtKnK34mqfvi55E6E34eqbPhZ5I6k1v5PC4YaYv7hwdi58V8rDuUgvSSOp0xScV1eHZbAkJcrbFyfBAm9XaFUNh1z7FtALwy0x6LRgXC2doUZhKR3nE/nMlGUmENnp4QBDuLnjkbsr3w30gyNktLS2OXQER3QK1WIz8/X2ubk5NTj+1WQERERF2bRCKBVCpFUdHfnaHz8/Ph5eXVpe9p3i6GmNqZtbW15nFbloirq2u+GNhes88+//xzrFq1CgAQEhKC3bt33/GXcrFYjGXLluGFF14AABw5cgTz58+/41qJqH01NCmx4Wg6PjuShga5Uu+YEQGOeG16GELduv7F4ibF3+Gl3IqWw0v9PG3x9IRgRPZy7pF/6ImIiIiIbpVIKMDdER6Y0c8df1zKx7qDKUjTE2ZKLKzB49+fRy8Xazw1PghT+nTtMJOXg0WL+6rq5Xjvz0RU1Mvx24U8PDMhCAuG+UAiEhqwQiIiIgKAqqoqndUt3N27R7d5IiIi6pnc3d21QkyNjY2oqKiAg4ODEasyDoaY2pmZmRkcHR1RVlaG3NzcVsdWVFRoQkxeXl53/No//PADnnjiCQCAj48P9u/fDycnpzt+XgAICwvTPM7L09/dhYiMQ61WY8fFfLy7JxH5VfqXUfNxtMArU0NxV5hLlw/yNClU2HouF58cTkVeZSvhJS87PD0hCJHBDC8REREREd0OkVCAWf09ML1vc5jpo0OpSC3WnbCVVFSD5VvOI9jFCk+ND8LUPm5dOsykz7pDKaiolwMAqhrkeH3nVXx3OhuvTgtFZC8uXUNERGRIlZWVWj9bWFjA1tbWOMUQERERtQNra2tYWVlpNcqprKxkiInaR1hYGGJiYpCamgqFQgGxWP/bnJiYqHkcGhp6R6+5Y8cOLFq0CCqVCm5ubjh48OAtLeF2MwwAEHVev13Iw7M/X9S7z9pUjKfGB2HRCB+YivUvidBVNClU+OVcDtYfTms1vBThbYeV44MwluElIiIiIqJ2cX2YafflAqw7mIIUPWGm5KJarNhyAUHSFDw5PgjTwt0g6gZhpqoGOX46m6OzPbW4Fks2nUVkL2e8Oi0MgdL26bJNRERErauqqtL62cHBgdcBiYiIqEsTCARwcHDQCjHdeM7TU7DndQcYNWoUgOal4s6dO9fiuCNHjmgejxw58rZf7+DBg5g7dy4UCgUcHR2xf/9+BAQE3Pbz6XP16lXNY7ZlJepcpvd1h5+T9rKRQgEwf6g3Dj8fiYfH+HfpAFOjQonvTmUh8v3DeOW3+BYDTAO87fDNP4Zg2+MjENlLygsXRERERETtTCQUYEY/d+x9egw+nh+BYBf9oZ2U4lo89cMFTPrfUfwelwelSm3gStuXrbkEe1aOxrS+bnr3RyeVYNL/juL1HVdQWd9k4OqIiIh6FpVKherqaq1t7MJERERE3cGN5zQ1NTVQKpVGqsZ4GGLqAHfffbfm8aZNm/SOUalU+OabbwAAdnZ2iIqKuq3XOnHiBGbNmoXGxkbY2tpi79696N279209V0sUCgW++uorzc9jxoxp1+cnojtjIhbilal/d3Mb7u+IXU+Nxn9nh8PJytSIld2ZukYFvjqWgcj3o/Hq9vgWl8ob6GOPb5cNwa+Pj8AYdl8iIiIiIupwQqEA0/u648+VY/DJ/AHo5WKtd1xqcS1W/hiHiR8ewc+xOWhUdN0Lb14OFvhk/gD8/Ohw9PGw0dmvVKmx+UQmxr4fjc3HMyBXqoxQJRERUfdXW1sLlUr77yxDTERERNQd2NhoX29Qq9WoqakxUjXGw+XkOsCQIUMwevRoxMTEYOPGjVi8eDGGDx+uNWb16tVISEgAAKxcuRISiURrf3R0tCbYtHjxYmzevFnndeLi4jBt2jTU1dXB0tISu3btwsCBA2+p1sOHDyMiIgJ2dnZ698vlcjz88MOaWmfMmAEvL69beg0iunNqtRqXcqvQz8tO7/7xoVI8MMQLUb2kuCvMpUsHeYqrZdh8IhPfncpCtUzR4rjBvvZYOT4YIwMdu/TvS0RERETUVQmFAkzr64YpfVyx90oh1h5MQWKh7sW1tJI6vLD1Ej7Ym4QlI32xYIgPbC0kep6x8xvi54Ady0dh6/lcvL83CSU1jVr7qxrkeH3nVXx3OhuvTgtFZC+pkSolIiIyvKamJtTW1qKurg5NTU06YaMbKRQK9O/fHwCQl5eHoqKim76GTCaDmZmZ5meRSITMzMw7KZu6mdv5XJE2oVAIExMTWFpawsrKCiYmJsYuiYioRxCLxbCystJaUq66urrFLEd3xRBTB1m7di1GjhyJhoYGTJw4EatWrUJUVBQaGhrw448/YsOGDQCA4OBgPPfcc7f8/GlpaZg0aRIqKysBAP/5z39ga2uL+Pj4Fo+RSqWQSrUvnn399deYOXMmZs6cicjISPTq1Qs2Njaora3FuXPnsGHDBs1SclKpFGvXrr3lWonozsTlVOLNnVcQl1OJ3StHI8RVd9avQCDA2/f0NUJ17Se5qAZfHE3H9rg8yJUtLzcxxNcBT08IwvAAhpeIiIiIiDoDoVCAKeFumNTbFfuuFuJ/B/SHmYprGvHen0n4+FAq5g32wj9G+sHLwcIIFd8ZoVCAuYO8MDXcDZ9Gp+KLmAw0KbRv0qYW12LJprOI7OWMdQ9EwMasa4a2iIiI2kKtVqO0tBSlpaW3dJxKpdJ0UVKpVFAoWp7QeP0x1wcqRCJRm46jnuN2Plek61oosaioCM7OznB05PV4IiJDcHJygrm5OWxtbWFrawtLS0tjl2RwDDF1kIiICPz000948MEHUV1djVWrVumMCQ4Oxq5du2Btrb/temtiYmJQXFys+fmZZ5656TH/+te/8Prrr+tsr62txZYtW7Bly5YWjw0PD8ePP/4IPz+/W66ViG5PYZUM7/2ZiG0X8jTb/v3HVXy3bGi3+bKgVqtxMq0MG2LSEZ1U0urYIX5/hZf8+WWJiIiIiKgzEgoFmNzHDRPDXLHvahHWHUzB1YJqnXH1TUpsOp6Jr09kYmq4Gx4Z44++nnaGL/gOWZmK8fykENw/2Bvv7EnErssFOmOqG+SwNuXlNyIi6t4KCgpQVVWltU0gEEAkErV6nFqthpWVFQBAIpG06ZqfQCCAWv33BEiRSMRrhaTldj5XpE2pVGr9/6ykpARNTU1wd3c3YlVERD2Dj4+PsUswOl5F6UAzZszApUuXsHbtWuzatQu5ubkwMTFBYGAg7rvvPqxYsQIWFsadcfjiiy+if//+OHnyJK5evYqSkhKUl5fD1NQULi4uGDRoEObMmYPZs2ff9AsHEbWPstpGbIhJxzcnstAgV2rtO55ahgMJxbgrzMVI1bUPuVKF3ZcLsOFoOq7k697UuN6EUBc8MsYfQ/wcDFQdERERERHdieYwkysm9XbBocRifBGTjlPp5TrjVGrgj0sF+ONSAYb6OeCRMf6I6iWFUNi1bjR5OVjgkwUDsDijHG/+cQXxeX9/x/nnjN68cUZERN2aTCbTCjA5OjrCxsYGpqamN/0bqFQqNZO1pVLpTe9BKJVK1NfXa22ztLSEUCi8zeqpO7rVzxXpUqvVaGxsRHV1NcrKygAAVVVVcHR0hKmpqZGrIyKi7o4hpg7m4+ODNWvWYM2aNbd0XGRkpFbK+UZLlizBkiVL7rA6IDQ0FKGhoXj66afv+LmI6M60Fl66xsfRAmaSrvulvLZRgR/PZOOrYxnIr5K1OM5ELMS9AzyxbJQfAqVWBqyQiIiIiIjai0AgwPhQF4wPdcGl3Ep8EZOB3ZcLoFTpXu84nVGO0xnlCHC2xMOj/XF3hAfMJF3rhtMQPwfsWD4KW8/n4v29SRgd6IT+XnZ6xypVatQ3KWDNZeaIiKiLq6ys1DyWSqVwdHTssNdSKrWvmQoEAgaYiDqAQCCAmZkZzMzMIBKJNKGwiooKuLq6Grk6IiLq7hhiIiIystLaRnxxNB3fnGw5vGRtKsaT4wOxeIQvTMVd60I+0Lw03qYTGdhyOhs1spbXILe3kGDhcF8sGu4DJyvO6CAiIiIi6i76etrhowci8MKkXth0PBM/ns1GfZPu95+0kjq8tO0yPtiXjCUjfLBgqA/sLU2MUPHtEQoFmDvIC1PD3dCkULU4bufFfPxrxxU8PNoPi0f4MsxERERd1vWdkezs7Dr89a5fTo4ddog6np2dnSbEdGMnNCIioo7AEBMRkZGU1jZiw9F0fNtKeEkoAOYN9sZzE4O7ZKgnoaAaX8SkY0dcPhR6Zltf4+NogYdG+2POAE+Ym/DiAxERERFRd+XlYIF/zgjDyvFB2HImG5uOZ6C4plFnXGltIz7Yl4xPDqdh7iBP/GOUH3wcLY1Q8e2xMhUDLXyFU6rUWHcoBVUNcnywLxlfxGTgoVF+WDKSYSYiIup6rnVHEovFHR4qMjExgUQigUqlglKpZBcmIgMQiUQQiURQKpU63dCIiIg6AkNMRERGsPZACj47ktZieEkkFODu/h5YMS4Qfk5d50I90Lxe9rHUUmw4mo6YlNJWxw7wtsMjY/xxV5grREKBgSokIiIiIiJjs7WQ4PHIAPxjlC92xOXji5h0JBfV6oxrkCvx9cksfHsqC5P7uOLh0f6I8LY3QsXt549L+UgvqdP8XNUgx+r9yfjyWHOYafFIX9gwzERERKSXQCDQhCqIyDAEAl67JyIyBpVKhdraWlRVVcHJyQnm5ubGLskgGGIiIjIClVqtN8AkEgowO8IDK6IC4dvFwktNChX+uJSPDUfTkVhY0+I4gQCYFOaKh8f4YaCPgwErJCIiIiKizsZULMJ9g7wwZ6AnjiSX4IuYdBxPLdMZp1IDuy8XYvflQgz2tcfDo/0xIdQFwi44GeJybpXe7dfCTF/EpOOh0f5YwjATERERERERUY+UmJiIkpISqFTNS9WLRCKGmIiIqOP8Y5QfvjqegRqZAkDXDi9Vy+T44XQ2Nh3PRGG1rMVxZhIh7hvohX+M8uty3aWIiIiIiKhjCQQCRPaSIrKXFPF5VfgyJh07LxVAqWdZ6rOZFTibeQ7+TpZYNtoP9w7whJmk63RjeHV6GGYP8MC6gynYe6VIZ3+1TIE1+5PxZUw6lo3yx9JRDDMRERERERER9SRqtVoTYAKAqqoquLu7G7Eiw2GIiYiogxTXyCARCmFvaaKzz9ZcgqUj/fDJ4VTcE9G8bJyPY9cK9uRVNmDTsQz8eDYHtY2KFsc5Wppg0XBfLBzuAwc97wUREREREdH1+njY4n/3R+CFySHYdDwDP5zR/50jvbQOr/wWjzX7krvcd47e7rb4fOEgXM2vxrqDKfjzSqHOmGqZAh8eSMbGY+n4xyg/LB3pB1tzhpmIiIiIiIiIujtbW1sUFxdrfq6srIRare4RS3wyxERE1M6Ka2T4/Eg6vjuVhcUjfLFqaqjecctG+eHeAR5dLrx0s1nR1/g7WeKh0f64Z4BHl5oVTUREREREnYO7nTlemRaGJ8cH4ccz2fjqmP7ur2V1TfjwQDLWR6fivkGeWDbKv8t0fw1zt8FnCwfeNMz0vwMp2HgsAy9MDsHCYT5GqJSIiIiIiIiIDMXOzk7r56amJshksh6xpJzQ2AUQEXUXxdUyvLnzKka/exgbj2WgUaHCNyczUVrbqHe8rbmkywSY1Go1opOKseDLU5j+0TFsj8tvMcA0xNcBXywahAPPjsX8od4MMBERERER0R2xMZPgkTEBOPpCFD6c1w+hbjZ6xzUqVPjuVDbGrY7Go9/G4lxWuYErvX3Xwkx7Vo7GlD6uesfUyBQwFfFSHhER9TxyuRwNDQ1oamqCUqmEWt3yxErqmjZv3gyBQACBQIDMzMwOeY3MzEzNa2zevLlDXqOzev311zW/OxERdQ3m5uaQSLS7MVdVVRmpGsNiJyYiojtUXC3Dp0fSsOV0NhoVKq19MrkKG46mt9iNqbNrVCixIy4fX8ZkIKmopsVxQgEwpY8bHhrthwhvewNWSEREREREPYWJWIjZEZ64u78HjqeWYUNMOo4ml+iMU6uBvVeKsPdKEQZ42+GRMf64K8wVImHnv2kT6maDTx8ciISCanx0KAW7L//dmcnLwRyzB3gYsToiIiLjUCqVUCgUUCial5cVi8U9ogsBERER9VwCgQC2trYoLS3VbKuqqoKrq/6JT90JQ0xERLepqFqGT6PT8MMZ3fDSNWKhAHKl/n2dWUFVA348k4MfzmSjuEZ/JykAMJeIMG+wF/4x0g/ejhYGrJCIiIiIiHoqgUCAUUFOGBXkhISCanwZk4EdF/MgV+p2ZTifXYnHvjsPH0cLLBjqjTkDveBgaWKEqm9NqJsN1i8YiMTC5mXmdl8uxIqoQEha6MRUWCWDuUQEWwuJ3v1ERERdmVKp1PpZKGRnQuqcNm/ejKVLlwIAMjIy4Ovra9yCiIioS9MXYuoJGGIiIrpF18JLW85ko6mV8NJ9gzzxRGQgvBy6RrhHqVLjaHIJvj+djUOJRWhhtTgAgJOVKZaO9MWCod6ws+j8NwCIiIiIiKh7CnWzweq5/fD8pF7YfCIT35/OQo1MoTMuq6we/92diA/2JmNKuCsWDPXBYF/7Tr+kRohrc5gpqbAG/s4tL0f+711XcTSpBEtH+mLZKH+GmYiIqNtQqVRQqbSvwYpEIiNVQ0RERGQ4tra2Wj9fW17XxKR735tliImIqI0Kq2T47EhbwkteeCIyoMuEl4qrZfg5Ngc/nMlBXmVDq2MDpVZ4ZLQ/ZvZ3h5mEFwuIiIiIiKhzcLU1w0tTQrBiXCB+OpuDr45l6P1+06RU4fe4fPwel49AqRUWDPXGPRGenT7008vVusV9SYU12H25AGo1sO5QKjYdz8SSkb5YNsqPk06IiKjLuzHABDDERERERD2DlZUVRCKRVlfKqqoqODs7G7GqjscQExFRG/x0Nhuv/X6lxfCSRPR3eMnTvvOHl1QqNY6nlWLL6Wzsv1oERWttlwAM93fEI2P8MTbYGUJh556pTEREREREPZeVqRjLRvlh8XAf7I4vxIajaYjPq9Y7NrW4Fm/svIp39iRiel93LBjmjQgvu07fnelG6w6lQH3dV7qaRgU++ivMtJRhJiIi6uIUCu0OiyKRqMv9rSYiIiK6HQKBADY2NqioqNBs6wkhJi4cTETUBr3dbfUGmCQiARYM9Ub081H47+zwTh9gKqttxGdH0hC1OhoLN57BnvjCFgNMliYiLBjqjV1PjcIPjwxDVIiUASYiIiIiIuoSxCIhZvZzx84Vo/DLY8MxO8IDJmL9l8EaFSr8ej4X96w/gSlrY/DtqSzUyOQGrvj2KFVqiIUC6LuXW/tXmGnUu4fxwd4kVNQ1Gb5AIiKiO3R95wGAXZgA4PXXX4dAINCEuaqrq/H6668jPDwcVlZWkEqlmDp1Kk6cOKF1XHFxMV599VX07t0blpaWcHR0xKxZs3DhwoVWX0+lUuG7777D1KlT4erqChMTEzg7OyMqKgrr169HU9PNzzEqKirw0ksvISQkBObm5pBKpZgwYQJ++eWXNv3O137f119/vdVxkZGREIvFuPfee9v0vDeKj4/Hf/7zH0yaNAmenp4wNTWFlZUVgoKCsHjxYpw6dUrvcdHR0RAIBFi6dKlmm5+fn6bua/9FR0frPX779u2477774O3tDTMzM9jZ2WHQoEF44403tG5ctyQ3NxfLly+Hv78/zMzM4O7ujpkzZ+LAgQO39T4QEVHnceOScpWVlcYpxIDYiYmIqA36eNhiQqgUBxKKATSHl+YO8sITUYHwsDM3cnWtU6vVOJ1Rju9PZ2NvfCGalPq7SV3T290GC4b6YGZ/d1iZ8s8EERERERF1XQKBAIN9HTDY1wH/nB6GX8/nYsvpbKSX1ukdn1hYg9e2x+Pt3QmY1d8d84f4INzTVu/YzkAkFGDt/RFYERWIjw6lYuelfK2uTEBzmOnjw6nYdDwDi0b4YtFwH7jZdu7vsUREREDzdc0bl5NjiElbTk4OJkyYgOTkZM22uro67NmzB/v27cMPP/yA++67D5cuXcLUqVORl5enGVdfX48dO3Zg79692LNnD6KionSev7y8HDNnzsTx48e1tpeWliI6OhrR0dH4+OOPsWfPHvj4+OitMSEhARMmTEB+fr5mm0wmw8GDB3Hw4EEsXboUY8aMudO34o5FR0frfQ+ampqQmpqK1NRUfPPNN3jppZfw9ttvt8trVlRUYM6cOTh06JDW9sbGRpw7dw7nzp3D+vXr8fvvv2PYsGF6nyMmJgbTp09HdfXf3UcLCgqwc+dO7Ny586bBLyIi6tzs7Oy0fq6rq4NCoYBY3H3v4Xbf34yI6BaoVGocSS5BbaMCY/2s9I5ZOT4YR5NLMXewJx6P7Pzhpcr6Jvx6Pg9bTmchrUT/BfprzCUizOznjvlDvdHX05YtmYmIiIiIqNuxtzTBQ6P9sWyUH06ml+H709nYd6UQcqVud9r6JiV+OJODH87koK+nLeYP8cbM/u6wMOmcl9KCXKyx7oEIPDU+EOsO6g8z1TUp8Wl0GjYcTcfk3q5YPMIXg33t+f2PiIg6rRu7MAEMMd3ovvvuQ25uLl5++WVMnjwZFhYWOHbsGP71r3+huroay5Ytw6BBgzB9+nQ0NDTgrbfewtixYyGRSPDnn3/irbfeQmNjI5YsWYKUlBSYmPy9BK1SqcT06dNx8uRJAMDYsWOxYsUK+Pn5IT8/H1999RW2b9+OhIQEjB8/HnFxcbCy0r62Xl1djUmTJmkCTPPmzcPixYshlUqRnJyMNWvWYNOmTYiPjzfcm9YChUIBS0tLTJs2DePGjUNISAhsbGxQXFyMK1euYN26dcjKysI777yD4OBgra5LgwcPxuXLl/H777/j1VdfBQDs3bsX7u7uWq/h5+enedzY2IgJEybg/PnzEIlEmD9/PqZOnQo/Pz/I5XIcPXoUa9asQXFxMaZOnYoLFy7oBMWys7M1ASahUIhHHnkEc+bMga2tLS5duoR33nkHr7/+OgYNGtSB7xwREXUka2trCAQCqK/7kl9VVQVHR0cjVtWxDH7lJSUlBd988w1OnjyJwsJCNDQ0YO/evQgMDNSMiY+PR3Z2NiwtLTF27FhDl0hEPUi1TI5fYnPx7clMZJbVw8XGFCMe139CH+5pi1OrxsPB0kTv/s5ArVbjfHYFvj+djV2XCtCoZwm86/VyscaCYd64O8IDNmYSA1VJRERERERkPAKBACMCnDAiwAmltY34JTYXW85kIae8Qe/4S7lVuJR7GW/tSsDdER6YP9QboW42Bq66bQKlf4eZPjqUih0XdcNMSpUauy4XYNflArw3py/mDvIyTrFERNRjqFUqKPUsfaJUKqH6a7tCLIb6hoBSU2MjlPK/l3gVCoVaP3dmIjs7CIT6l7JtT3FxcThy5AiGDh2q2TZo0CAEBQVh+vTpqKmpwdChQ6FWq3HmzBkEBARoxg0ZMgROTk5Yvnw5srOzsWvXLsyePVuz/7PPPtMEmBYtWoTNmzdrws8DBw7EjBkz8Morr+C///0v0tLS8O9//xvvvvuuVn3//ve/kZOTAwD473//i5dfflmzb+DAgZgzZw6mT5+Offv2tf+bc4v69++P3NxcnY4XADBp0iSsWLEC06dPx/79+/HGG29g0aJFmlCdpaUl+vTpg9jYWM0xwcHB8PX1bfH13nzzTZw/fx52dnY4cOAABg4cqLV/1KhRWLBgAYYPH46CggKsWrUK33//vdaY5557TtOB6bvvvsMDDzyg2Tdo0CDcd999GD16tFZdRETUtQiFQtjY2KCqqkqzjSGmdqJSqfDCCy9g7dq1UKlUmqSYQCDQWS/3WnJYLBYjIyMDHh4ehiqTiHqIlKIafH0yE9vO56G+6e8ZPUXVjTiYVNbicZ01wFQtk2P7hTxsOZ2NxMKaVseaiIWYHu6GBcO8McCbs26JiIiIiKjncrIyxeORAXh0jD9iUkux5XQWDiQUQ6nS7c5U06jAt6ey8O2pLAzwtsOCoT6Y1tcNZpLO1xEiUGqNtfdH4MlxLYeZzCUiTOrtapwCiYioR1FWViJlxMhWx1S3urfrCTpxHGIHhw5/naefflorwHTNtGnT4OPjg6ysLJSUlODTTz/VCjBds3TpUjz33HOQyWSIiYnRCjF98sknAABnZ2d8/PHHeq8jv/HGG9i2bRsSExPxxRdf4M0334SpqSmA5mXYNm7cCADo27cvXnrpJZ3jJRIJNm7cCH9/f8iNHFBzcnJqdb+JiQnef/999O/fH1lZWYiLi9MJHrVVbW2t5v3997//3eLz+Pj44LXXXsMTTzyBX375BRs2bIClpSUAoLCwEL/99hsAYPr06VoBpmusra2xYcMGvZ8RIiLqOmxtbVFVVQWxWAxbW1udzofdjcFCTI8++ii++uorqNVqeHh4YPjw4di6davesdfaJWZmZmLr1q1YuXKlocokom5MqVLjYEIRvj6ZieOpLQeVfojNh/7VpTufS7mV+P5UNnZczEeDXLe98vX8nS0xf4g35gz0hJ1F5wxjERERERERGYNQKMDYYGeMDXZGUbUMP53NwY9nspFfJdM7/nx2Jc5nV+LNP67i3gGemD/UG4HSzncR8e8wUxA2Hc/AtvN5mu+Oswd4wNZcf0fehiYlzCRCTnohIiLq5O6///4W9/Xt2xdZWVkQCASYN2+e3jHm5uYICgrC5cuXkZ6ertmen5+PhIQEAMDcuXNhbW2t93ixWIylS5fixRdfREVFBc6fP4/hw4cDAM6dO4eKigoAwOLFi1s8r/D09MTEiROxa9eum//CBtTY2IiioiLU1tZCpWpe8eD6pXwuXrx42yGmI0eOaDpqzJkzp9WxY8aMAQDI5XKcO3dO8/Phw4c1Sy5ev7TdjYYMGYLevXvjypUrt1UrEREZn5ubG6RSKSwsLHrE93SDhJgOHjyIjRs3QiAQYNWqVXjjjTcgEokgbKWV5n333Yf33nsPhw4dYoiJiO5IZX0Tfjqbg29PZSG3Qv/yANeEuFpjRrgUxSeBzvo3oK5Rgd/j8rHlTBbi81qfoyQRCTC5jxvmD/HGMH+HHvGHjYiIiIiI6E642JjhqfFBWB4ViOikYmw5nY1DScU6nYwAoKpBjq+OZ+Cr4xkY4ueABUO9MbmPK0zFnas7U6DUCm/NDscLk0PwS2zz9+PFw31bHP+fXVcRm1mBRSN8MDvCAxYmBpsHSURERLcgODi4xX3XlkVzcnKCvb39TcfV1Pzd4T8+Pl7z+GZdfK7fHx8frwkxXb58WbN98ODBrT7HkCFDOkWIqa6uDuvWrcOPP/6IK1euaEJC+pSWlt7261y/vJubm1ubjyssLNQ8vtX3lyEmIqKuy8zMzNglGJRBrkBs2LABQHOHpf/85z9tOmbIkCEAwD+qRHTbEgqq8fWJTGyPy4NMrmpxnEgowMQwFywe4Yuhfg6oqanBp6cMWGgbXc2vxvens/B7XD5qGxWtjvVxtMADf3VdcrIyNVCFRERERERE3YdIKMD4UBeMD3VBXmUDfjqTjR/P5qC4plHv+DMZ5TiTUQ4HSxPcN9ATDwzxhq+TpYGrbp2tuQQPjfbHslF+LU5yqWqQazo2vfJbPN7dk4i5g7ywaLgvvB0tDFwxERERtcbCouW/zdcaCbQ25vpx1wd2ysvLNY+lUmmrx7u6/r087fXH3cpzuLi4tLrfEDIzMzFu3DhkZGS0aXxDQ+sTpltTXFx8W8fV19drHne195eIiKitDBJiOnnyJAQCAZYtW9bmYzw9PQFop4qJiNrqnT2J+OxIWqtjHCxNcP9gLzw4zAfuduYGquzWNDQpsfNSPraczkZcTmWrY6+FseYP9cbIACcIhey6RERERERE1B487Mzx7MReeHJ8EA4mFOP701mISdE/+768rgmfH03H50fTMSrQCfOHeuOuMBdIRC13JDe01rr0/hKbo7VcebVMgS+PZWDj8QyM6yXF4hG+GB3kxE6/RETUZiI7OwSdOK6zXalUarrZODk5QST6u5NhQ0ODVqhGIhbDtAt1IRD91d2oO2iPv/ld4bxh4cKFyMjIgEAgwNKlS3H//fcjNDQUzs7OMDExgUAggEql0nxO1fradLbR9Z/t8+fPQyLRv8Tvja7dO71RV3h/iYiI2sogIaZriWJfX982H3PtD7ZC0Xq3ESIifYb6ObQYYurjYYPFw30xo587zCSdq8U/0Pzl51JuFX67kIdfz+eiRtb6v4MeduZ4YIgX5g7ygtSm63yRJyIiIiIi6mokIiEm93HF5D6uyCqrww9ncvBLbA7K6pr0jj+WWopjqaVwsjLFfYM8cU+EB4JcrA1c9a05lqo/nKVWAwcTi3EwsRj+zpZYPNwX9w70hJUpl5ojIqLWCYRCiB0cdLcrlRD+dQ9I7OCgFWKyUCqhvO4/E1NTiNsY9KA753Dd/15FRUWtjr2+GcH1x12/hF1RUVGrS9/d7DUEAgHUajVUqpZXXACal4O7HYmJiTh27BgAYNWqVS2uKnN996M74ejoqHns7OzcYjipNTe+v15eXi2Ovdn7S0RE1JkY5CqDpaUlKisrUVJS0uZjcnNzAWif8BAR3UitVuudZTA22Bm+jhbILGturyoWCjAl3A1LRvhigLddp5yZkFZSi9/j8rEjLk9Td0uEAmBciBTzh3pjbLAUInZdIiIiIiIiMigfR0u8NCUEz94VjL1XCrHldDZOppfpHVta24hPo9PwaXQaQt1sMKu/O2b2c++UXYG/WjwYMaml+PpEJg4nFUNfk4H0kjr8a8cVvL83CXMGemLRcB/4O1sZvlgiIuq2RCJRu3S8odvTp08fzePTp09j4cKFLY49c+aM3uPCw8M1j8+ePYvRo0e3+Bxnz55ttR5ra2tUV1ejoqKixTFqtRqpqamtPk9Lrly5onk8b968FsfFxsa2+jxtve8QERGheXz8+PFWX7MlN76/rYWYbvb+EhFR16NWq6FWqzXLwnYnBvmN/P39AQBXr15t8zF79uwBAPTu3btDaiKirkuuVGHHxXzc++kJ7L2if8lJoVCARcN94WRliqfGB+H4S+Pw0QMRGOhj36kCTIVVMnwZk44ZHx3D+NVHsO5gSqsBJheb5t/n2Ivj8OXiwRgX4sIAExERERERkRGZiIWY0c8dPzwyDAefG4uHRvnBzqLlThEJBdV4Z08iRrxzCHM/P4nvT2ehooVOTsYgFAowNtgZXy0ZjOj/i8SyUX6wNtM/D7K2UYHNJzIxbvURLPrqDI4kt30CIxERUVsJBIJOdU23J3B3d0doaCgA4Oeff0Ztba3ecUqlEps3bwbQ3BlowIABmn0DBw7UdAv69ttvWwyj5eXlYd++fa3W4+fnB6D1ENGePXtQWVnZ6vO05PpVYVrr5vTZZ5+1+jxm1y152NjY2OK4CRMmwMLCAgCwbt262wrqRUVFaYJ+X3/9dYvjzp49i/j4+Ft+fiIi6nxqa2uRnZ2Ny5cv48SJE8jLyzN2SR3CICGmiRMnQq1W45NPPrlpq0egOey0efNmCAQCTJ061QAVElFXUFLTiLUHUjDynUN46ocLOJdVgc0nMlscP3+oN068NA7P3hUMl060zFpVgxw/nc3G/C9OYfg7B/GfXQm4nFfV4niBoLmz1OcLB+L4i82/T2ecrUtERERERNTTBThb4dXpYTj18nh8OK8fBvvatzr+TEY5XvktHkP+ewAPfX0WOy7mo76p9SXFDcnH0RKv/fX7/OfuPgiSttxt6WhyCf64mG/A6oiIiKgjLV++HABQUlKCp556Su+YN954Q9PA4OGHH4apqalmn6mpKZYuXQoAiIuLw/vvv69zvEKhwMMPP4ymptYD3WPHjgXQ3BXq+PHjOvsLCwvx5JNPtuG30i8oKEjz+Foo60affvopfv/991afx83NTfM4LS2txXF2dnZYsWIFAODEiRN45plnWr1/WlRUhC+//FLntWbNmgUA2LFjB37++Wed42pra/Hoo4+2WjMREXUd+fn5yMjIQHl5ORQKBaqqWr6/3JUZZDm5p556CuvWrUNaWhoee+wxrF+/HmKx/pfev38/li5dCplMBkdHRzz88MOGKJGIOrEL2RX4+kQmdl0ugFypPSPhVHo5EgurEeJqo3OcmUSks81YZHIlDiUW4/e4PBxOLEGT8uaBTh9HC8zq5477BnnBy8HCAFUSERERERFRezCTiDA7whOzIzyRVFiDX2JzsPNSPoqq9c/IlyvVOJBQjAMJxbAwEWFimAtmRXhgVKATJCLjt4a3NBXjwWE+WDDUGyfTyrD5RCYOJBRBdUPTgMUjfI1SHxEREbW/xx57DN9//z1OnjyJTZs2ISsrC0888QT8/PxQUFCAr776Ctu2bQMABAQE4LXXXtN5jn/+85/4+eefkZubixdffBFxcXFYtGgRpFIpkpOTsWbNGpw9exaDBg1qtcvSI488gvXr10OhUGDGjBn45z//iVGjRqGpqQnHjx/HmjVrIJfLERQUhJSUlFv+XSMiItCnTx/Ex8fj888/R0VFBRYuXAg3Nzfk5ubiu+++w9atWzFy5Ei9Iarrn8fMzAwymQyvvfYaJBIJfHx8NEv9eHh4wNy8eYLym2++iSNHjuD06dNYu3YtoqOj8fDDD6N///6wtLRERUUFrly5ggMHDmDPnj0IDw/HQw89pPV6q1evxv79+1FTU4P58+fjyJEjmDNnDmxsbHDp0iW88847SE5Ovun7S0REXYOtrS0KCgo0P1dVVUGtVne7jpUGCTG5uLjgs88+w6JFi7Bx40bs3bsX06ZN0+xfu3Yt1Go1jh8/jsTERM3afZs3b4aVVcszvIio+2pUKLHrUgG+PpGJi7mtp0i3xubi1elhBqqs7RRKFU6kleH3uHzsvVKI2sabz6Z1sjLF9L5umNXfHf297LrdHx0iIiIiIqKepperNV6dHoaXp4bidEYZdsTlY/flAlTL9H9HrG9SYntcPrbH5cPB0gTTwpu/Iw7wtofQyMuJCwQCjAh0wohAJ+SU1+O701n46WwOKuvlGORjjz4etnqPq21U4HByGVRqgCuiExERdQ0ikQh//PEHZs6ciePHj+PQoUM4dOiQzrjQ0FDs2bNH7/08W1tb/Pnnn5gwYQIKCwvxww8/4IcfftAas2TJEowdO1bTtUmf3r1747333sOzzz6LiooKPPPMM1r7HRwcsH37drz22mu3FWISCAT49ttvMW7cOFRUVODnn3/W6WwUHh6OX375Be7u7i0+j7W1NZ566im89957OH/+PCZOnKi1//Dhw4iMjATQ3Klq//79WLJkCbZt24aLFy9qujPpY2OjO5Hb19cXO3bswMyZM1FTU4P169dj/fr1WmP++c9/QiAQMMRERNQN2Npqf+dWKBSor6+HpaWlkSrqGAYJMQHAggULIJFI8OijjyInJweff/655ub8tRaI19Z8tbKywtdff60VdCKiniG1uBa/XcjFT2dzUFrbegvZwb72WDzCF5N6uxqouptTq9WIy6nE73H5+ONSAUprW173+horUzEm93HFrP7uGO7vCHEnmGVLRERERERE7UskFGBEgBNGBDjhjVm9EZ1Ugh1x+TiQUIRGhf5uveV1Tfj2VBa+PZUFDztzzOrvjln9PdDL1drA1evycrDAy1NC8fT4YOy4mNfqsufbzufin79fhbUwGGEm5Siokum9EUdERKRUKgEAQqGQEzw7AQcHBxw9ehTff/89tmzZggsXLqC8vBw2NjYIDw/HnDlz8PDDD8PExKTF5+jduzeuXLmCd999F7/99huys7NhbW2N8PBwPPzww3jggQdaXMLtes888wzCwsLw4Ycf4syZM6ivr4e7uzumTp2KF154Ad7e3nf0u/bv3x9xcXF4++23sWfPHuTn58Pa2hqBgYGYO3culi9fDjMzs5s+zzvvvIOgoCB88803uHLlCqqqqjSf6xtZW1vj119/xbFjx/D1118jJiYG+fn5aGhogI2NDQICAjBkyBBMmzZNJxB1TWRkJK5cuYK3334bu3fvRkFBAezt7TFo0CA8+eSTmDRpEl5//fU7eWuIiKiTMDMzg6mpKRob/77/XFVVxRDTnZg7dy7Gjx+P9evXY+fOnYiLi4NC8fess969e2PmzJlYuXIlpFKpIUsjIiNSqdT46ngGtsflIT6vutWxpmIhZvV3x6Lhvi3O8DSG1OJa7IjLw+8X85FVVn/T8SYiIaJCnDGrvwfGhUg71dJ3RERERERE1LFMxSJM6u2KSb1dUSOTY9+VImyPy8Px1FKdJdquyatswProNKyPTkOIqzVm9ffAjH5u8LQ37vLj5iYizBvc8k1DtVqNr09kAgBqVCY4LXPFpE/OYoivA+6O8MDUcFfYWbR845OIiHqWpqYmzX0jkUgEiUQCiURi5Ko6l9dff71NoZTNmze3KRwUHR3d6n6hUIiFCxdi4cKFbStQDwcHB7z77rt499139e5fsmQJlixZctPnmTRpEiZNmtTi/ujoaCiVShQXF+vs8/X11TRTaIm3tzc+/fTTVsfc7DkEAgEeeughnaXfWjNq1CiMGjWqzeNv5OXlpdOB6Xpt/cwQEVHnZ2trq/V3rrKystUugV2RQUNMAODo6IjXXnsNr732GlQqFcrLy6FUKuHg4MATUaIeSigUYMfF/FYDTB525nhwmA/uH+wFe8vOcXGzoKoBOy/m4/e4fFzJbz18BQACATDc3xGz+rtjch832Jrz3zwiIiIiIqKeztpMgnsHeuLegZ4oqWnErkvNS8nF5VS2eExiYQ0S/0zEu38mYrCvPWb298C0cDc4dJLvy9c7llqKtJI6ne1nMstxJrMc/9oRj8heUsyO4CQfIiKCVscapVIJsdjgt7GIiIiIOi07OzutEFNVVdVNA7ZdjVHP/oRCIZycnIxZAhF1Enf398Cl3Cqd7cP8HbBkhB8mhEo7xTJrlfVN2BNfiN/j8nA6oxxt+ZvQ19MWM/u5Y0Y/d7jY3LzdLBEREREREfVMztamWDLSD0tG+iGrrA474vKxPS5PbwjomrOZFTibWYE3dlzBmGBnzOrvjgmhLrA07Rw3fUUCAcI9bHE5T/c7PwDIlWrsv1qE/VeLYP3XcuuzIzww1N8RIiGXESIi6klUKpXOTTiRiOFWIiIiomtsbbVXKmpqaoJMJjNSNR2jc1zNIKJuS61W41xWBbbH5SGhoAZbHxuudy3z6f3c8J9dV6FSN1+0ndHXHXMHeyLE1cYIVWtraFLiYGIRtl/Ix5HkYsiVN08u+TpaYFZ/D8zs744AZysDVElERERERETdiY+jJZ4cH4QV4wJxtaAav8flY0dcPgqr9V+cVKjUOJRYjEOJxTCXiHBXmAvujnDH6CBnSIw4KWhEoBN2rBiJYwl5ePvHw0iV26JJrf+GdE2jAr+cy8Uv53LhYmOKmf3c8dBof04IIiLqIa7vwnSNUGj8ia1EREREnYW5uTkkEgnkcrlmW1VVFSwsjLvUfHtiiImIOkRqcQ22X2ieMZpb0aDZfjmvCn097XTGS63N8OLkEIS522C4v6PRuy6p1ECuwgqrdiThcHIZ6pp0v0Df6Fr4alZ/d/T1tNUb1iIiIiIiIiK6FQKBAL3dbdHb3RYvTQ7Bmcxy/B6Xj92XC1DVINd7TINciR0X87HjYj7sLSSYGu6GWf09MMjHHkIjdDcSCATo52mDsZb5GKUuQNj4OdibVIGDicVoUqj0HlNU3Ygvj2XgH6P8DFwtEREZy40hJpFIxGusRERERNcRCASwtbVFaWmpZhtDTK3w9/dvz6cD0Pw/QlpaWrs/LxG1v6JqGXZezMdvF/JwJb9a75jtF/L1hpgA4NGxAR1Y3c3VyOSISSnFnku52F8VAplaDMQXt3qMtakYU8JdMau/B4ax1T0RERERERF1IKFQgGH+jhjm74jXZ4bhaHIpfo/Lw4GEIsjk+sNAFfVyfH86G9+fzoarjRnGhUoxIVSKEQFOMJMYfokekUCNcb2ccPdgf1Q1yLE3vhC/XcjDqYwynSXbh/o5wM3W3OA1EhGRcegLMRERERGRNn0hJjc3NyNW1L7aNcSUmZnZpnHXkvM3rm2sbztT9kSdW41Mjj/jC7E9Lg8n0nQvON7oj0v5eHVaqFFmfuqTU16PgwlFOJhYjFPpZdctFdfyP48mYiHGh0gxq787IntJjXLRl4iIiIiIiHo2U3HzknF3hbmgtlGB/VcLsf1CPo6llkKp0v/lvLBahi2ns7HldDbMJSKMDHTCXWFSRIVIIbU2/JJttuYSzB3shbmDvVBQ1fDXxKh8JBQ0T4y6u79Hi8eu2ZeEqwU1mB3hgfGh/G5ORNTVqdVqqFTagVyGmIiIiIh02draav3c0NCgtbxcV9euIabFixe3uj8uLg4XL16EWq2GnZ0dIiIi4OLiAgAoKipCXFwcKioqmltM9+uHfv36tWd5RNROmhQqRCcV4/e4fBxIKEJjC63frxfgbIm7+3tgVn8PowaYVCo14nIrm4NLCcVILKxp03FCATAiwAkz+7tjch9X2JhJOrhSIiIiIiIioraxMhVjdoQnZkd4orS2EbsvF+D3uHycy6po8ZgGuRIHEopwIKEIANDPyw4TQqQYH+qCUDdrg08sdLM1xyNjAvDImAAkF9Vg+4U8TAnXP5NUpVLjl3O5KKiS4UBCEaxNxZjcxxV3R7BLMhFRV3VjgAlgiImIiIhIHysrK4hEIq0ulvX19UasqH21a4hp06ZNLe776quvsGXLFnh6emL16tWYPXs2xGLtl1cqldi2bRuef/55XL16FcuXL8eyZcvas0QiagdPfH9ec5GzNc7WppjZzx2zIzzQ293GaJ3V6hoViEkpxcGEIhxOKkZpbVObj+3jZoV7Bnpjel83SG0MPyuViIiIiIiI6FY4WZli0XBfLBrui5zyeuy4mI/tF/KQUlzb6nEXcypxMacSq/cnw8POHONCpJgQ5oJh/g4wFRv2JnKwizVemBzS4v7TGeUoqJJpfq5pVOCXc7n45VwuXGxMMaOvO+428rUIIiK6NTeu3CEUCvlvOBEREZEeAoEAFhYWqKn5u1mHQqEwYkXtq11DTC2JjY3FY489BmdnZ5w6dQru7u56x4lEItx3330YNWoUBg4ciCeeeAL9+vXDoEGDDFEmEbXRXWHSFkNMVqZiTOrtitkRHhgeYLzZj/mVDTiYWIwDV4twMr0MTW3oFgUAEpEAg7xtISq8Ch9JDV5c+hBsbGw6uFoiIiIiIiKi9uflYIHlUYF4IjIAaSW1OJBQjIMJRTiXVYEWVpwDAORVNuDbU1n49lQWLE1EGB3kjPGhUowLkcLRytRwv0ALdlzMb3FfUXUjvjyWgS+PZSBQaoW7+7tjVn8PeDlYGLBCIiK6VTeGmBhgIiIiImqZRKK9ahBDTLfoww8/hFKpxKpVq1oMMF3Pzc0Nq1atwlNPPYU1a9Zgy5YtBqiSiK4prJJh75VCLBzmo3fpt8l93PDa71c0wSCxUIDIXs64O8IDE0JdYCYxfJtflUqNy3lVOJhQhAMJxbhaUN3mY+0tJIgKkWJCqAtGBzlB3dSATz891oHVEhERERERERmOQCBAoNQagVJrPDY2AOV1TYhOKsbBhGIcSS5BbWPLFzvrmpT480oh/rxSCIEAiPCyw/hQF0wIdUGwi5VRbjK/PDUEEd52+D0uDyfSyqBuIZCVWlyLD/Yl44N9yRjkY49ZER6YHu4Ge0sTwxZMREQ3xRATERERUdtJpVLY2NhAIpHoBJq6OoOEmGJiYgAAQ4cObfMxw4YNAwAcO8YgAVFHU6vVSC6qxaHEYhxOLMbZrHKo1c3t24cHOOqMtzWXYEKoFMXVjbg7wgPTjHQBsKFJiWOpzcvEHUwsRklNY5uPDZRaYXxoc3BpgLe9Vseo6qaGjiiXiIiIiIiIqFNwsDTBPQM8cc8ATzQpVDidUYaDCcU4kFCE3IqWvxOr1cD57Eqcz67E+3uT4OVgjvEhzYGmIX4OMBELDVK/jZkEcwd5Ye4gLxRWybDzYj5+u5DX6oSm2KwKxGZVYO2BZJxZNUHvpC0iIuo8GGIiIiIiapmLi4vWz9XVbW/w0dkZJMRUUlICAGhsbHvA4NrYa8cSUfuSyZU4kVb6V3CpBHmVuhcpt1/I0xtiAoC190dAIjLMxcnrFVXLNBdWj6eWorGNy8SJhQIM8XP4a7aoFD6Olh1cKREREREREVHnZyIWYnSQM0YHOeNfM8KQXFSLAwlFOJhQhAs5lS12OQKAnPIGbD6Ric0nMmFtKsaY4OZl56J6SQ022cnV1gwPj/HHw2P8kVJUg+1xedh+IV/vdQ4AGObvyAATEVEnxE5MRERERAQYKMTk7OyMvLw87NmzByNHjmzTMbt37wYAODk5dWRpRD1KbkU9DicW41BiMU6kld00ALQ7vgBvzOqtd3k4QwWY1Go1ruRX/3UBtRiX86rafKytuQRRvZwxPtQFY4KdYWvevVrpEREREREREbUngUCAXq7W6OVqjeVRgSitbcShxGIcTChCTEop6puULR5b06jArssF2HW5AEIBMNDHXjORKMDZyiD1B7lY4/lJIXjurl44l12B7RfysOtyASrr5Zox40KkLR7/9I8X0KhQISqkOYjlbG1qiLKJiAgMMRERERFRM4OEmMaNG4dvvvkGa9aswZQpU24aZDpx4gQ+/PBDCAQCjB8/3hAlEnVbF3MqsSe+EIcTi5FUVNPm46xMxZjc2xW1jQq9IaaOdK1L1IGEYhxKKEZhtazNx/o7WWJ8qBTjQ10wyMceYiN0iyIiIiIiIiLqDpysTDXLtsnkSpxKb1527mBCEfKrWv6urlIDZzMrcDazAu/sSYSPowVG+9uhSm4JN3Fdh9ctFAow2NcBg30d8K8ZvXEkuQTb4/JwKKEYY4Od9R4jkyvx55VCyOQq7IkvBAD09bRFVC8pxoVIEe5hyw5OREQdiCEmIiIiIgIMFGJ66aWX8NNPP6GxsRHjx4/HY489hiVLlqBfv36aE1G1Wo2LFy/i66+/xqeffoqmpiaYmpripZdeMkSJRN3W1nO5+PZUVpvGutuaISqk+eLcyEAng4WXGhVKXMiuxMm0MpxKL8OFnEo0tXGZOJFQgEE+9pgQ6oLxoVL4G2h2JxEREREREVFPYiYRIbKXFJG9pHhzVm8kFNTgYEIRDiQU4WJu612Ts8rqkVVWD8APYigR/2M8RgVLMdzfEeEeth06AclELMRdYS64K8wFDU1KmJvov9ZxMr0MMrn2tYhLuVW4lFuFtQdT4GRlishezhgXIsXoICdYm7HbMxFRezI1NYVQKIRarYZarYZIZNiJtURERETUORgkxBQSEoKvv/4aDz74IJqamvDRRx/ho48+gomJCRwcHCAQCFBWVoampiYAzYEmsViMTZs2ISQkxBAlEnVZarUaGaV1LYZ3xoVIWwwxXWvvfi241MvF2iAzXJoUKsTlVOJUehlOppXhfHbFTZe2u561mRhjg50xIdQFkb2cYWdh0oHVEhEREREREdH1BAIBwtxtEOZugyfHB6G4WoZDicU4kFCMY6klOmGg6ykgwon0CpxIrwAAWJqIMNjPAcP9HTHM3xG93W06LNTUUoAJAA4nFrd6bGltI7aey8XWc7kQ/9XpaVyIFFEhUgQ4W7JjCBHRHRIKhQwuEREREd0GtVoNpbLl5d+7GoOEmABg7ty58PPzwxNPPIFz584BABobG1FQUKAzdsCAAVi/fj2GDBliqPKIupS6RgWOp5bicFIxDieWoLhGhnOv3gV7S90wz/AAR5hJhJoLiPYWEowNdkZUiBRjgw0TAGpSqHA571qnpXLEZpW3ekFTHx9HC4wPccGEUCkG+zlAwmXiiIiIiIiIiDoFqY0Z7h/ijfuHeGstEX8woQhF1Y2tHlvXpER0Ugmik0oAANamYk2oaXiAI0LdbCAywDJuK8YFoo+7LQ4lFiMmpQR1TS1fAFao1DiZXoaT6WV4a3cCvB0s8POjw+Fqa9bhdRIREREREREpFApcuHABcrkcCoUCarUaEokEcrnc2KXdMYOFmABg8ODBOHv2LGJjY3HgwAFcvnwZ5eXlAAB7e3uEh4djwoQJGDx4sCHLIuoSssrqcCixGIcSi3E6vRxNSu0Q0JHkEtwd4aFznJlEhAVDfWAmEWJciBT9vew7/OKfXKnC5bwqTael2MwKNMhvLf0pFAADvO0xIaw5uBTgbMVZjURERERERESdnJlEhHEhLhgX4gL13X0Qn1eNAwlF2HelAAmFtTc9vqZRobn+AQA2ZmIM8XPEMH+H5lCTqw2EHXBdQ2pthrmDvTB3sBeaFCqczSzHocRiHE4sRnppXavHNsiVkFqbtntNRERERERERPqIRCLU19drbROLxQwx3a5BgwZh0KBBxnhpoi6jSaFC7F8XzA4lFSO9pPULZocSi/WGmADgtelhHVGihkKpwpX86uZZiGlliM0sb3XGoj4CARDmZqOZaTnI1wG25pIOqpiIiIiIiIiIOppAIEC4py3CPW2xbKgrVn+yAQUKS9j3GorzuTVIKb55qKlapsCBhCIcSCgCANiaSzDUrznQNMzfEb1crNs91GQiFmJkoBNGBjrhtelhyCxtnlh2OEn/xLKoXs4t1rDjYj6SC2sQFSJFfy87g3SVIiIiIiIiou5NIBBALBZDoVBotkkkEjQ0NBixqvZhlBATEemXV9nQvExcYjFiUkpR26i4+UF/ySyrg1qtNki3IqVKjav51TiZXopT6eU4m1GOmluo9ZrQv0JLw/wdMNTPEbYWDC0RERERERERdVcWQiUCTKrx+ORA2NjYoKSmEafSy5o7OaeX3XQCFwBUNcix72oR9l1tDjXZW0gw1K95QtTwAEcESdu/k7OvkyX+McoP/xjlh7pGBY6lliI6qblbVFF1I8aFSFs89qez2TieWoaPD6fCwdIEY4OdERUixXB/RzizexMREdEd2bx5M5YuXQoAyMjIgK+vr3ELIiIiMiCJRKIVYhKLu0f8p3v8FkTdxLM/xeF0RnmbxoqFAgz2dcC4ECmiQqQIcLbssACTSqXG1YJqzYXF0xnlqJHdemgpxNUaw/ybZ0oO9XOAvaVJB1RLRERERERERF2Bs7UpZvRzx4x+7gCA4moZTqaX4VR6OU6llyHjJsu4AUBFvRx/XinEn1cKAQCOliZ/XXto7tbU3svTW5qKMam3Kyb1doVa3Xy9xM/JUu/Y2kYFzlx3nae8rgm/XcjDbxfyAAB+TpYY5GOPwX4OGOzrAF9HC4NMTiMi6mwEAgFUKhUEAoHmPyIiIiJq3Y2dlySS7tEwxCAhpqNHj97R8WPGjGmnSoiMp1GhRHxeFSrr5Rgf6qJ3zBA/h1ZDTE5WJojsJcW4EClGBTnBxqxj/iFSqdRIKqrBybTmmZBnMspR1XDr62cGSa007d2H+jnA0YozDImIiIiIiIhIP6mNGWb198Cs/h4AgMIqWXOXprQynMooQ1ZZ/U2fo6yuCbsuF2DX5QIAgJOVqSbQNMzfEf5O7TcJTCAQoLe7bYv7j6WUQK5Ut7g/o7QOGaV1+OVcrqbWwb72GOzbHGoKdbOGWCRsl1qJiDozsVgMmUym9bO5ubkRKyIiIiLq/G4MLbET0y2IjIy87YsDAoFAqwUWUVdRLZPjfFYFzmaW42xmBS7mVKJRoYKHnXmLIaZBvg462/p62iLqr+BSuIcthML2n4VSXteEi7mVuJRThUu5lTifXYGK+lsPLQU4W14XWmJbdCIiIiIiIiK6fa62Zrg7wgN3RzSHmvIrGzShppPpZcitaLjJMwCltY3441IB/rjUHGqSWptigLc9+nrZor+nHfp42nbYJLFAqTUeGxuAQ4lFSC6qbVOte+ILsSe+uavU2vv7awJdRETdGTsvEREREd06hpjukFrd8qwjou6gqFrWHFjKaA4tJRZWQ6XnY59X2YD8yga42+nOJBngbQdHSxPNMnGRvZwhtTFr1zprGxWIz2sOK13MrcLFnMo2XfTTx9/JEkP9Hf8KLjlAat2+tRIRERERERERXeNuZ457BnjingGeAICc8nqcum75ubzKm1/fKK5p1Fp+DgD8nS3Rz9MOfT1t0dfTDr3dbWAmEd1xvYFSK7z0/+zdeZxbZd338c/JPlkmmX3rMt1bKFDowlJaQBAQQWSHG9lFrCLgBg/io3irN9wPIIogCAi1gICooFg2QQplkxZaKHTf21k7k5nJMtlznj9Okklmktn3/t6v13mdk7NcuVJCJjnne37Xl2bzf740m33udlZtaeTfmxv5cJcbfzjW4/ELs9zsBuAPRXl3exMLqgsptJkG3E8hhBhpnUNMEmoSQgghhOhZ5xCTDCfXB2+++WaP+/j9frZu3cozzzzDhx9+yOLFi/nZz36GXj/wEwZCDDZVVdlxwM/a3W4+3O1m7e4W9rp7LmmetGa3O+uddA6LkbU/PmXQfqSFojE21Xm1wFKiytL2Az76mymcXGTl2ERo6egpRZQ7JbQkhBBCCCGEEEKIkTGx0MrEQisXLJiIqqrscycqNSWqNdV7gj03Auw84GfnAT/Pr6sBwKBTmFnm4IiJWqjp8AlOZpY5MA5gaLeJhVYuO7aay46tJhqLs7ney4e73Kzd4+bDXS00+UIZ+1e58rLeAAfw0Z4WvvHER4AWlFpYXcCCyYUsmlLIhII8ufgvhBhzJMQkhBBCCNF3UolpAE444YRe7XfGGWdw0003cdddd3HLLbfw2GOP8eSTTw5x74Tou/d3NvNfj/ynz8cpCswqc3T7I6y/P9BicZVtjV4+3demDQ23v43N9R4isf5XQZtYmMexU7Xh4Y6ZWpTz5JkQYhgFWyHeCrEIxMKJKX05mmN9BPJccPiF2dv9/AXY+kracVnaj+cYZtLigiv/mX3bZ3+Dd37V/9d73Wrtw7Oz/Wvh378Agxn0po55rmWDGfRG0Ju15VlngNnetd1IADy1acebOo7RSbBaCCGEEEKI0UpRFCYVWZlUZOXChVqoaU9ze0aoqdEb6rkhIBpX2VjnYWOdh6c/3AeA2aDj0Mp8Dp/g4oiJTo6Y4KK6yIZO1/fzOAa9jrlVTuZWObn6+Cmpvq7Z7WZN4ma5wyc4cx6/Zrc7tby90cf2Rl+qn2X5ZhZWF6amWeUO9P3ooxBCDCcJMfXfm2++yfLly1m9ejX19fUYDAYmT57M6aefzne/+10qKyu7HHP77bfzs5/9DNBu2A4Gg/z2t7/l6aefZtu2bQDMmTOHyy+/nG9+85tdLoiuWLGCK664AoDXXnuNL37xi9328brrruPhhx/GZDJRX19PQUHBoLyOvjhw4AC/+c1vWLlyJbt27SIYDFJeXs6SJUu47rrrOP7443MeW11dzZ49e7jiiitYvnw5a9as4Ve/+hXvvPMOBw4coKSkhFNOOYVbbrmF2bNn99iX7du388ADD/D666+zd+9ewuEwFRUVLF26lOuvv54FCxYM6LUKIYQ4eEglpmH0wx/+kP/85z88/fTTnHnmmVx88cUj3SVxkPGHony8t4VDKvIpspu7bJ830YVepxDLNl5cGpNex+ETnCyoLmTRlALmTyrEaR34h0fy5FYyrPTp/lY+q/EQiPRcijwXi1HHoZVODp+gnYhbUF3AhALrgPsqxEGraRt46yHSDmG/Fo5JLedYFwloyxMWwJfvydqs5e3/gc+e7l+fyg7LHWKq/xQ+6We7edmHOACgvRnqN/Sv3e5462Fnz5Uec/ru59lDTPWfwR9OyX6MotfCTAYzmB1gzgeTPbGcmBbfCEXTuh4bi0DzDu05zQ7tOAlFCSGEEEIIMWQURaG62EZ1sY2LF01CVVV2Nvn5aE8LnybOp2yq6/3NX6FonI/3tvLx3tbUOofFkBqC7ojEvMJp6fPF9/S+XrBgIgCRWDzn/ukhps4aPCH++Wkd//y0LtXH+ZMLUqGmwyc4B2WoPCGEGEwSYuq7YDDIVVddxTPPPNNl22effcZnn33Ggw8+yNNPP81ZZ52Vs52GhgZOP/101q9fn7F+zZo1rFmzhtdee40XXngBna6jGuE555zDN7/5TQKBAH/605+6DTFFIhH+8pe/AFohg84BpsF6Hd157bXXuOCCC/B4PBnr9+zZw549e3jyySf59re/zX333ZfxOrN57LHHuO6664hGo6l1+/fvZ/ny5Tz99NM88cQTXHDBBTmPv/vuu/nRj35EJJJ5s+iuXbvYtWsXK1as4Mc//jH//d//3Y9XKoQQ4mAjlZiG2eWXX87f/vY3Hn74YQkxiSEVicXZccDHxloPG2raWLu7hY11HmJxlXsuOILz5k/ocozVZGBuZT6f7G/LWO8wG5hfPfgnhho8QT7Zp51gSwaX2gI5KqL0gkGnMKvckXGSbWaZHcMAyqILMWa17gV/E4S8EPJo86AnsexJLHvTgkbtEG6HiB9mng5n3JW93df+L2x9uX99suS+4xb9AIKQsXA37Zr63+5IiPXuDuqccr3e7tpVYx3vgUBL9n3mX5l9vbcOfnd05rrOAajUlCUcNfM0cHb9eySEEEIIIYToHUVRmFZiZ1qJnQsTQaFQNMbmOi+f7m/lk8RNYtsafai9LGrtDUZ5d3sz725vTq0rtptT51oOT1RsKrT1/fdWrqHrVFXFbjaQZ9T36mY2bzDKqi0HWLXlAKANP/f693pXNV8IIYaLhJj6RlVVzj//fFauXAnAWWedxYUXXsjUqVPR6XR8+OGH3HPPPezdu5fzzz+fd999N2d1n3PPPZeNGzdyww03cNZZZ1FYWMiWLVv4+c9/zqZNm3jxxRd55JFHuO6661LHOBwOvvKVr/Dss8/yt7/9jQcffBCLxZK1/Zdffhm3WwvfXnrppUP2OnJZv349Z511FuFwGKPRyPXXX89XvvIVbDYb69at484772TXrl088MAD2Gw2/vd//7fbtv70pz9RWlrKrbfeyqJFiwgGg7z00kv8+te/JhQKcemllzJlypSs/bzrrru4+eabATj88MNZtmwZM2bMwOVysWXLFu6//37ef/99fv7zn1NcXMwNN9zQp9cqhBDi4COVmIbZpEmTANiwYQiqN4iDlicYYXOdl421bamy4FvrfYRz3N22do87a4gJYGF1IQ2eEAunFLIwEVyaWTbwEt2t7eFUdaXkCbQGz8Au1k8rsXHEBJd2d+BEF4dU5Mtdd2LsikUh7O0IF2ULHoU6bZ9+Miz8evb2nrsKatb2ry/eutzbjAMYfjHSnnOTqhuqENMY+2IT7ea19EauEFN0gOEoc3729SFv13VhnzZ19z5KKnwhe4gpFoH7jgJrIdiKwVqszdOXrcVgK9LmZkf24fmEEEIIIYQ4CJkNeo6Y6OKIiS4uS6zzh6J8VtOWupHsk/2t7HMHet1mky/EG5sbeWNzY2rdhIK8jvMyE1wcNsGJ3dy/07KKovDoFQuJxOJsrPVkDEHX7O/5d9K8ia6c255bu49QNM4hlfnMLndgNY3aU8dCiDEmrsZpDbV2WR+LxWgNtxIxZt6wG9QF0UfH9vlrl9mFThmam4YfffRRVq5cidFo5B//+Aenn356xvZjjjmGyy67jCVLlvD5559z00038c4772RtK1lt6cQTT0ytO+qoozjttNM45JBDaGho4He/+11GiAm0QNKzzz6Lx+Phn//8J+eff37W9v/0pz8BkJ+fz5lnnjlkryOXb37zm4TDYfR6Pf/85z859dRTU9sWLlzIBRdcwPHHH8/GjRu5++67ufzyyzn00EOztvXJJ58wefJkPvjgA8rLy1Prly5dymmnncapp55KJBLhW9/6Fh9++GHGsRs3buS2224D4Kc//Sk//elPM8J68+fP5+KLL+aKK67gySef5LbbbuOyyy7LOvSeEEIIkdQ5tKTT6XqsKjgWjNpfog0NDQD4/f4R7okY6/743m7e29HExjpPn046AXy4K3d57h+ePovbvjyn33eFeIMRtjX62NbgZVuDj62J5bq2YL/aS6py5XWUMp/o5LAqJw7LGAsniPFNVbWqRsFWCLRmzkvnQNX87Mc9fgbUrtcqIPWVrTj3NkuO0ElvhHOHjTANYDjG7trtHDbSGbRAjt6YmHdaTm03QX5F7nYnLITjbkhrw9C1PZ0ByPKZZ+jmruKpJ8I5D3f3avun8kg49Zda5aRYRAsfxcId81zL0cT+hux3hxHrf5U7QAsJZZMtxNSndnO8T9uboW2vNvWG3pQZalr6Q6henH3fQKtWFUxCT0IIIYQQ4iBiMxs4emoRR08tSq1z+8OpIeiSN50d8Pb+Boj9LQH2twRYuUG7gUFRtGDTzFIHM8oczCi1M7PMwfRSO3mm3l20N+p1qQDW15dMTQ2Xt2aXmzW7W1iz281ed9fflgurc18M/cM7u9hc7031cUqxjUMq8jmkMp85FfkcWpFPicMsFVKEEH3WGmrlhGcPripwb130FoWWwkFvV1XVVLWgG264oUvwJ6mgoIC77rqLM844g3fffZdt27YxY8aMLvt95zvfyQgwJRUWFnLVVVdx5513smHDBtra2nA6O6rHn3766RQVFdHc3MxTTz2VNcTk8/n4xz/+AcB5552XUa1psF9HNuvWrWPtWu3m1WuvvTYjwJTe/sMPP8zxxx9PPB7nd7/7HQ888EDONu+5556MAFPSSSedxLXXXsuDDz7ImjVrWLt2bUY1pnvuuYdIJMKCBQu6BJiSdDodv/3tb3nuuefw+Xz85S9/4dprr+3VaxVCCHFwylZ5aTwMKTdqX0HyS0KyIpMQuYSjcdoCEUoc5qzb3956IOPut94y6BTy84yEojHMhq4nkLKty8YbjLC90acFlRq8bG30sb3BS+0Aw0oARTZTRmDp8Akuiu3Z/x2EGDZr/gCe2uwhpeQ8Hs1+7OKbcoeYosH+BZig+wBJrnBIb3RTMQmLC/IKwGjTAk1GK5hs2tyY17FssmbuY7SCvTT3Szn2e5i/+H+1YJHOCIOVqJ6yVJsGW/EMbRpspbO1abDNPA1+fEALR0XDiZBUuGM5GoZoAEK+zEpgySnXUIBh38D6lSsc5W/qWzuxMHhrtQngmGXZ94uG4H8na8E1a1FG8MlizOe4yE78ig3Dzn9D+XTIr9Te73IxQwghhBBCjEOFNhMnzirlxFnabzVVVan3BPlkX1tGuMkTzPFbtxNVhX3uAPvcgYxzVooCEwuszCi1M6PMwcwyLdw0raTncFP6cHkXL9LOpzZ4gqxNBJrW7Hazqc7DgursF9TD0Tg7DnT8blFV2HnAz84Dfv75aUf12GK7iTmJYNMhFdo0pdiGIcfwd0IIIQbXxo0b2bFjB0DO6kdJS5d2nOt7//33s4Z/Og/xlm7+fO08raqq7Nq1i3nz5qW2GY1GLrjgAh566CFefvllWltbcblcGcc///zzBAKBrM8z2K8jm9WrV6eWr7nmmpz7LV68mDlz5rBp0yZef/31nPsVFBRw9tln59x+9dVX8+CDDwLw+uuvZ4SYXnzxRUALc3UXBna5XBx22GGsXbuW999/X0JMQgghuqXX61EUBTVtTPTxMKTcqAoxtbS0sHbtWu69915eeeUVFEXh3HPPHeluiVGktT2sDQNXqw0Ft6nOy/ZGL8dPL+bxqxZlPeaQyvxehZiqXHnMqcjn8AlOFlYXMm+iq9d3vwH4QtGOqkoN3lSVpcEIKwHYzQYOq3Jy+ERnqgR5lStP7n4TAxOLQrANAi0QcGvzdnfm40BLYp/WjiDS8TfBcd/J3ub794N7Z//6E2zNvW0gYaOgp5t2HVp1GnO+tmzJTyynP3YkQkedw0Zluds97ZfaNNiMeWC2D367QqMoWmUpgwkGMxM6/RT4iTsz8BT2dQ1Bpab09T4tIJRNex9DTJ3lqlLW3qzN41HwNWhTgglYknzwwssdxxjytDBTfiUs+R5M+8LA+iaEEEIIIcQopSgKFc48Kpx5nD5Xq8YQj6vscbdrlZoS4abPatsIRuK9bldVYa+7nb3u9qzhppll9ozKTT2Fm8ryLXz58Aq+fLhWldcTjODIMYzdtkYvkZiadVu6Jl+Y1duaWL2t47eI2aDjp2cdyn8dLTejCiHEUEtWFgI49thje31cfX191vWzZ+e+SbCwsCP46vV2vUn00ksv5aGHHiIUCvGXv/yFr3/96xnbk0PJVVZWctJJJ2VsG+zXkc3mzZsBMJlMGQGsbI4++mg2bdrEtm3bCIfDmExdK88feeSR3Va3mDdvHiaTiXA4zIYNG1Lr9+zZw4EDBwC49dZbufXWW3vV/768ViHE0InGo/gjfnwRH76wD1/Ehz/ixxv2EowGCcfDhGPaFIqFujyOxCJd1gciAeqL6okpMV575TUi8QjheJi42vvfDr2hoGDWmzHpTVgMFm2ut2DWmzMng7nLOouh634WgwWn2YnT5MRpceIwOuQ69QhTFIWJEyei0+mIxWK88cYbBIODk00YScMSYtLr+zd28YwZM7jlllsGuTdiLFBVlX3uABvr2hKBJS+b6jzUtGYfDm5jXe6AwpyKzOCDQacwo8yRKod9SEU+cyocuKzdDIeUJhVWSoSUtjYMblgJwGTQcWhlfiqsdPgEF1OLbeh08odA5BCPJwJGLVrIKBlAKj9MG6Itm18fDq17+vd83VV/sbj61yZofc/ZbrYQk9I1bNTlsROKp+du96zfwNn397/P44WqQjymhVbikcQ8+TiqDbM2yF+g+01v1CoE6YzasHe6xGO9EXT9+84xLHR6yHNp02ApOwwufloLM/kTU3v6vFmbR3P8jbLmCDH1tcITaBWq3Du0KVeFp3gM7l+gBQAdFYnQU1Xm3F6m/XcVQgghhBBiDNHpFKYU25hSbOPseVUARGNxtjb4UkPQfbq/lS31XqLxnsNC6dLDTa9vygw3TSrMrNw0o1Qbls5i7PrbKN+S+45cg07HV46oZGOdh50HfPSli6FoPGeFdFVVefjtnUwvtXNIZT7l+Ra50CGEEAPQ2Nj3UScA2tuzV5S3Wq05j9GlVYCPxWJdti9evJjJkyezZ88ennrqqYwQU2NjY6qq0cUXX5zRVnJ7f+R6Hdm0trYCWhirp6F1kkPEqapKS0sLZWVdb14tLc1dPR+04XsKCwupr6/H7Xan1g/HaxVC5NYeaac11EpLsIWWUAu+sA9vxIs/nAgmJcJJ/oi/y3p/xE8gmv3a9IAlvpr7AgMcxaEH7dGh+yzRK3ryTfk4zU5cZhcus4t8c35q2Wl2pralzy16+U0wmKZMmQKAx+PJ+Pszlg3LFaL08lW9YTAYuOCCC7j33nszxtgVB4fv/XUj+yN78YZ6V4IboMEToskXyjqU2hETXVy1uDoVWppeau/VUHC+UJTtjYmqSqnQki9nkKo/9DqFyUVWZpZqJ5qmJ044TSuxY5Qy3CJpw1+6VkdqT6uSFHAnwj9ZPmtP+VnuEJMygPdYdxWT+hTQULTht/JcWvipYHLuXU+8FY79TmZAyWgb+HBqQxV6ice0IbmiQW0eC6U9DmvzbOsy9tW2Wdq9nB7+BB0xLC9tAr2SFjKKdASNkqGjWJYQUtYp1rGv2vVExNikZA85JQNOqWVDWvApuV+2Yzrtp9NrlbuSwwIa89KWrWC0ZN9myNPaGOwv5rYimH1G9/uoKoT9maEmfxP4D+QeunCgFZ7yK7Ov9x/QKrV1V61N0WlBpmRVp/SQ0+TFkF8xsL4JIYQQQggxTAx6nXYDXWU+FycKiAcjsY7zTWk3yO1raaePp1BRVdjT3M6e5lzhJgczyuw9hpsAZpU7uO+SIwEIhGNsadBuKOyohu6hPZz7d+OciuxDYB/whrjj5c2pxwVWI4dU5jOnPJ/z5k/ocvOhEGJ8cpldvHXRW13Wx2Ix2lrbMJk7bjDW6XTdBmvGCpfZNSTtpoeJXnzxRaqrq3t1XE8BnP5QFIX/+q//4o477uDtt9+mpqaGqiotyPvnP/+ZaFS7xpNtyLrhfB2DdaG8v+2kv9af/OQnXHDBBb06zmaz9ev5hBjP4mocT8hDS6hFCyUlgkktwRbcQXcqrJS+HIyN/ao0o1VMjWn//qGWPh1n0plwWVyU28qptFVSaa+k0lZJhb0i9dhqHPvfBUT/DUuI6ac//WmP++h0OhwOB1OmTOG4446jpKRkGHomRqMNtT4M+ZY+H7e90Zc1xFTlyuOnZx2a9ZhwNE5tayB1N9ueZv+Qh5VmlHXcHTel2NarQJUYoyJBLWDU7u4UPkout3RsP/ZbcEiO8bRXfr/70FB3At18cbAWQsuufrbbmnvb5MVaNaRkMCnPpQ2FlVxOn5vzex9CyhXG6q1YBCLtEG7X5pFAYvIn5sltgbTt/o79kgGj1DxHMCm5Pt77IGZPTMARyQebN3SzpwAVYmFtGm0UfY7wU172QJQhRyDKmKcNb5isPGZxavNc1YsURRuC0GyHgure9bV6Cdz0Wafg0wHwNxFurWPPpo+xqz7KrDF0/ix3k+VXZW/XU9Pzc6tx8NZpU81HmdsueSZ7iElV4eMV4JqovUbnRC00JoQQQgghxChjMeqZW+VkblXmjZuBcIwdB7RwU7Lq97bGwQg3dQwN3TncNLnQyqRCKxMLrVQ4LRgSN9TlmfTMm+hi3kRX6tjkcHnpwaaNtR7qPUHyLQaqXHlZ+/J5p+rpLe0R3t3ezLvbmzl2WpGEmIQ4SOgUHYWWwi7rY7EYOosuY+guvV6P1SIXLnMpKipKLbtcLubOnTuCvdECSnfccQfxeJynn36aH/zgB0DHUHKzZ8/mqKOO6nLccLwOl8sFQHNzM9FotNtqTMmh2xRFoaCgIOs+DQ0NWdcnRaPRVAWM9KH40l+r0Wgc8f9mQoxGsXiM5mAzje2NWacDgQO4g27aQm3Exs0N2QevcDyc+m/76YFPs+7jMruosFVoAacsIad8U75UcxrHRk2ISYjeMul1zCy3a5WVKvKZU5HP7Ip8nHldL1aqqkqzP8xedzv7ElMysLTPHaCuLdCn8tg9SYaVZpTamVnmYEaZgxmldqaWSFhpTItFIdimBY6sRVr4pzNVhSfO0aqbJINJfSkxOev03NushQMIMXVTNjCv048xo1Vbl3VyZYaPnBNzt7v0B/3rayyqhYbCycmnzUO+RKioU8Ao7M8eRIoEOgWVEsuDGCoSol/UGIS92jQUjNZEqCk/x9yZ+ThV1SxtmyFx0lBv1AJBrq7/rwc9Hv6280EAll23jHyrBXz14KnVQkqe2tzD1HlqB/Yac1V4anfDizd0PFZ0kD9Bq+5WUJ2YT9GWXZPBVjz4VbGEEEIIIYQYgDxT9nBTezjKjkY/2xo7wk1bG73sc/f95rtc4SYAg06h0pWXCjVpc+3xpEIrzjxjari8Mw7ruLHA7Q9T0xLIeQFhY60n63qAQyolwCSE6FrdRi5Idu/II49MLb/77rscf/zxI9gbOPTQQzniiCP45JNP+NOf/sQPfvADdu3axfvvvw9kr8IEw/M6Zs+eDUA4HGb9+vUsWLAg574ffvghADNmzMgI1aVbv359t2GoTz75hHBYu7EyPag0depUnE4nbW1tvPvuu/16LUKMZe2Rdur8dTS0N2iBpPYDNLQ3cKD9QCrI0hRsIq7GR7qrPVJQsBvt2E12bEYbeYY8THoTZr0Zk86ESW9KPTbqjNp6fdf18XCct/79FnpVz1lnnEWBowCT3oReGdxryTE1RjgWJhgLZs6jQUKxUOYUDWXsF4qGuuzTHmmnLdxGdBiut7WGWmkNtbLJvSnrdpvRRoWtginOKcwunM3swtnMKphFqbVUvkuMA8MSYhKiv5IlppNDwR1S4WRqiS1jqLVgJMb+lnY+2uNmb3M7e90B9rV0BJa6K3XdXzoFqotsiZLcWjnumWUOCSuNBaqqDWOUMRxb2jBtgRas3gNcFtxCHkEcDzwAobaO48+6D+Zf0bVdRYG6T7oPDXWnvQ9ho57ozVrwKa9AG5Ipl9PugC/+vCOkZMx+12RW0bDW53CW0FHW5e62JZajUtJTiAFJBvZ89f1vw2DpJgjlBEs+JkwcFv2EoGJBv/8/UDJJC3hWLYBJx3Tf/oRFcNGTmYGn9OWeKmjlqvDUsjvzsRqHtr3atHt11/2NtrRwUzUs/DoUTev+uYUQQgghhBgBVpOBwyY4OWxC9nDT1kSoaXuDr9/hJoBoXE3d+JeNw2LQgk0FViYVdQSdJhVamVWefSg5gFKHmUVTCtlU68Eb6rjYUWA1Ut6PSuxCiPEnHA4TjUZxuVwoiiIXHntw1FFHMWHCBPbv38/DDz/MjTfeiMUysp+nl156KZ988gnr1q1j06ZN/O1vf0tt+6//+q+sxwzH61iyZAl33nknAI899ljOENP777/Pxo0bATjllFNytud2u3nxxRc555xzsm5/7LHHUsvp7ej1es444wyefvppXnvtNTZt2sScOQMcdUCIUaQ90k6tr5Zafy01vhpqfdo8udwaah3pLgJg0BkoMBeQb8rHZrRlhJGSy3ajPXM5MbcZbThMDvIMeYPyd8rj8bAnuAeAY8uPJT9/7IT7VVUlEA3QGmqlLdSWmieXW0OteMKejuWQJ7VuMINq/oif7a3b2d66nX/t+VdqfYG5gFmFs7RQU+EsZhfMptpZjUEnsZixZFj+a/33f/83AN/61rcoLs5xZ34nLS0t/Pa3vwW0MWLFwePKY6v4wsLDOKTCSVm+GVWFA74Qe93tfFbTxksb6lIBpX0t7TR4QkPWl/SwUrLU9swyB1OKbViMElYaMfFYojJSS9oQbZ0CSYdfBBOy/ChRVbh/gXaBOwcDkKr10fnt1VNlo/6GmLob9q1inhZMyisAa7IyUiKklAwrpa8zZSm3HA1pFY3C3sTc1/vH6UGlUOJxPNK/1ylAZ9CCIgaz9t/VkD5ZQG/q2J5YF44rfPr5FmKKjnlHLsCcZwWdEXR6rb3UpNcq6HRepzMk9jd0PUZv6MP+emCETySpca2qVjyiVe+KR7THsU7z1HJyffKYbNtjHcuxxONc+8ai2nCBkaAWGIoGOw1PmFYBbCyKBrUp2xBxCRbgjOSDP/+100ZXR8U6a1HHcl764yIonqnNLa6OYfBUVfs8T4WbOoWc/Ae0Y7Jp3d231xnxQ+Pn2gQw9/zs+wU98P79icBTtVbFyVHR+2EwhRBCCCGEGCK9DTdta/CxbQDhpiRvMMrntR4+z1JZSVGgIt+SEWyamJhOnFXK+fMnALC/JcDniaHoUFUJKgghAO1iaCwWQ6/Xo9fLOfee6HQ6fvSjH/Gtb32LnTt3cvnll/PEE09gNpuz7u/xeFixYgXXX3/9kPXpkksu4ZZbbkFVVZ566ileeOEFAI499limTp2a9ZjheB1HHnkkCxYsYO3atTzyyCOcd955nHzyyRn7tLW1cd1116X6tGzZsm7b/N73vsdxxx1HWVnmzcNvvfUWDz/8MADz589n4cKFGdtvvfVW/vznPxOLxTj//PN59dVXmTBhQtbniMViPPPMM5xwwgk59xFiOEXjUWp9tezx7OkSUKr11+IO9vO62ADlRXXkh3TkB3XkByC/HRx+FYc/hsMTJd+vkh9QyW/XtuWFoijUAXU9N240ojOZUCwW4mYzPrMZv8WCzmxGMZtRLGZ0JjOKxYLOYkYxaev0Dgd6lwu906nN05aVvMEJQI00RVGwGq1YjVYq7TlGTsgirsbxhr2psFNzoJk6f13qfVTnqxuU91NLqIUP6j7gg7oPUuvMejPTXdM7gk2Fs5lZMBOb0Tag5xqtdOPg+sWwhJhuv/12FEXh/PPP73WIye12p46TENPBxWLQ89aWAzzx/p5EUClAODq0JQSdecZUmeypxfZUaGlqiYSVhlQkAIq+Y/iidNEwvHZb9qBSsA3oYRzA0kOyh5h0Oi3o097cvz53VzHJWgjuHVk2KNpQTckL+anwUdpyWadxsOOxRGDIB4u+kQgVedPCRT7t36JtX1roqNP29FCShI6yUMBk0ypQGfO0obhSU54WBksuG61dgkVdw0bJ9T0Ek3R9/0wJejy8sU0bvmvOkmWYx1Aq/6ClqomAUyB7wCkS0IaczLWtu+MigcT/455uA5kjItiqTVk/C3PoLvjkmgSVR3Zsa2/ODD4l6YxQfrhWkSmUe7iKnAqqs69374C3/jdznd6s9StZyalwKhRN1ybX5K59E0IIIYQQYhh1F27a3uhjW6Ji0+4mv1bN3N2OLzSw4SBUFWrbgtS2BfnPrq7nTfKM+tR5t/Sg07YGLxMKrOSZ5NybEEL0xTe/+U3+9a9/8fzzz/Pcc8/x8ccfc91117Fo0SKcTicej4fNmzezatUq/vGPf2CxWIY0xDRhwgROOOEEVq1axQMPPEBrayuQeyi54XwdDz30EMcddxzhcJgzzjiD73znO5x11lnYbDbWrVvHnXfeyc6dOwH4wQ9+kDEMXGdHHHEEGzduZP78+dx6660sWrSIUCjESy+9xL333psaau6BBx7ocuxhhx3G3XffzXe/+102btzI3Llz+cY3vsEXvvAFysrKCAaD7N69m/fff5+//OUv1NXVsWHDBgkxiWETV+M0tjeyx7Ony7Tfu5+oOvTDhwHoYyoFPijwQaFXTc0LfeDygSMRSnK0g2nwB+LpEIkQj0TA72ewnkYxmVKhJtXhYEFzMxGziTZVJVZdjbGqCmNlJcbKSnR5fRg5ZYzQKTqcZidOs5NJTMq5XyAaoM5flwo11fnqqPHVpAJPje2NqD1dI+4kFAvxefPnfN78eWqdgsLswtksmbCEJVVLOKz4MPT9uH43Grjdbnbs2EE4HOboo48mEBjYDSyjgVxlEaPOQ6v3Ysgf3AoWRr1ClSvzREnqrrACK06rcVCf76ASj4OvQbtoHWjtNG/Jsi5tHgvB+Y/B3PO6tqs3wpo/gNrPrwc9VUzqb4gp5M297Zjrof1AIsRi0irXKHrtNUTa08JFHm25vQladmnL657Q5skg0lit4jKY9KZEyMimzTNCRXna+mTAyJQWNsrYlpcWVLJmhpUMZu12USGGgqJ0vAeHiqomKqR5tIpBqXlbp8feTvu0ZT4ehvGruzWQ4JOtGOyl2tCZc84CW6n2eRCPap+jgRZoq9HCTS27teBn59drsmshqWxa9nRdFwtB8zZt6kxngIIpUDxDG57umG9DfkXvX5cQQgghhBBDxGoycPgEF4dPcGWsV1WVlvaIdiNhsvJ5Yr7X3U5ta4B4364RdBGIxNjS4GVLQ/ZzKr+95EjOOqL3d3ELIcTBTlEUnn32WW688UYeeughduzYwc0335xz/9LS0iHv06WXXsqqVatSASaDwcCFF17Y7THD8TrmzZvHiy++yAUXXIDH4+Gee+7hnnvu6bLft7/9be64444e27r++utZtmxZ1jCVyWTij3/8I0cffXTW42+66SZsNhs33XQTbW1t3HXXXdx1111Z9zWZTCM+TKAYn9oj7exq28WOth3sbtvNbs9u9nj2sM+7j0B0aIMPjnaVQi8U+lQKvFDYKahU4NUqJo39GjLZqeEw0cZGoo3aKAjJb7++rdvwddpXX1iYCjQZKyu1gFNVx7LekXs457Euz5DHVOdUpjqzV/KLxCM0+Buo9dWyz7uPrS1b2ezezJaWLfgj/l4/j4rKJvcmNrk38fCnD5Nvymdx5WKOn3A8x1UeR3Fe7wrzjBbt7dp1ZUVRMBjGfgRo1L6CSESrGmI0SrhE9E6x3ZQKJaWHlCYVWSnPt6DXSVghq3i8I1gTTFz4DrZ1DSEddTmUHdr1+Eg7/Gp2/58/0Jp9vaIkwkZN/Wy3m+HZ8grAkKddBLc4tcmUCMIYLITjOjZu2YaKwiGHHorZaNKCSPGo9m/x5PkdlY/Sqx/Fhm5ow1HPkAgLmWxaICC5bLZnPs653Omx0Za9QpcQooOiaP+Pme2Q388T/qqqVXZKDzV1CUVlBqCi/hYO7N9BHkGcxhhKuJtw51DpS/DJ4tJCTs4JUHkUmPK0gGk8plXDMpg7hqrrfKdFy+6+9SsezQw4HZ2jBLnvAOxcBcXToXAaWKS6mhBCCCGEGBmKolBoM1FoMzFvoqvL9kgsTl1rMBVqSoac9rVoy63tA6/8XOGUi7RCCNFXRqOR3/3udyxbtoxHHnmEVatWsXfvXnw+H3a7nSlTpjB//ny+9KUvceaZZw55f84//3yuv/56QiHtHPmpp55KSUlJj8cNx+s49dRT2b59O7/+9a956aWX2LlzJ6FQiLKyMpYsWcI3v/lNjj/++F619fWvf525c+dy77338s4779DU1ERJSQknn3wyt9xyC4cccki3x1977bV85Stf4fe//z2vvfYaW7ZsobW1FbPZTFVVFYcddhhf/OIXOe+883o9so0Q2QSiAS2s1LqD7a3bU/NaX22fq9j0ltOnUtoGJW0qpa3avKQNSttUituGuHLSOBNzu4m53QQ/+yzrdkN5OZbZszHPmY1l9hwsc2ZjnDABZRwMI9YTo87IBMcEJjgmsKhiUWp9XI1T46thi3uLFmpyb2Fzy2bq/fW9atcT9vDy7pd5effLABxSdAhLqpZwfNXxo75KU+c8jdFoRFWH5v/z4TJqQ0zr168H6NWXHHFwMBt0GZWUJhTkactFWnDJZh61b+ehFQ11BI9CbdrF0DxX1/0CrfDCssygUqhNC+H0ZjiiiYuyh5hMNq3yRH8reQRbc2/rTYhJb9LCL6nhvkxaFaembfDiTZnDq6UPsaYzgK8efF3HvjUB85IPPl3Xr5c1uinav1kyYJSaO7Qptc6RmCcDRt0EkEbxH28hRDcUpSPE6Sjv1SHtHg8rHtSGN1y2bBn5VotW/a7drVW5a29OPG5OW5e+raV/Q771VzLw1LQl9z7r/wSKDqzFWuApWd0p2ALFs7S/lf4DfRua02gFR44qTDVr4W9f73hsL+sYki59KqiWQKcQQgghhBhRRr2OSUXa+bds2gIRLdSUFmxKDlO3v6WdSKznk+eTCrO3LYQQomeHHXYY9913X5+Ouf3227n99tt73O/EE0/s9UVQl8tFMBjsUz/S9ed1AFx55ZVceeWVPe5XUlLCL3/5S375y1/2o3eZjjnmGJ599tl+H19WVsZPfvITfvKTnwy4L0LE1Tj7vPtSoY1tLdvY3rqdGl/NoIeVbAGV8lYoadVCSqWJkFIyrGQeQMF/nc2GzuFAZ7ehtzvQ2e3o7Hb0DjtKXh46sxnFaEIxm1FMJhSzCZ0p8dioPVZMJm2/5Hq9vn+jccTjxMNh1FAYNRQkHgx2LIdCqMEQ8VCWdcEAcY+XWGsrsba21Jx4L67B9lG0vh5ffT2+VatS63Q2G+bZs7HMno1lzmzMs+dgnjkDnengOL+sU3RMdExkomMip0w+JbW+NdjK5pbNqXDTZvdmdrXtItbDSEAbmzeysXkjv//09zjNTo6rPI7zZpzHovJFKKNslJfOISZFUYjFxnZqcEhSHytWrMi6/u9//ztr167t9thQKMSOHTt47LHHUBSFhQsXDkUXxSg2t8LOIbOqugz7VmI3ozsYqimFfLD5n5lBo4zgUaeKSZ2r/1z6V5hxStd29UbY8lL/+9VdxSSLq/8Vk7b/G6LhRMjInzZ5IeKHvEItIBWLaK+1c+AqFtYulncePq7uk/71Z7QyWLqGi7IGjnrx2GiFgyCNLYQYJgaTFoDqZQgK0D73OwefUuGnEQo+qXHwN2pTQw/76gzaZ6neqFV0igS6/j0uqM79Wdu8PfOxr0Gb9rybuV7RQ8HkruGmyYtBf5CGt4UQQgghxKjizDPirHIyt8rZZVssrlLvCWYdpm6fO0CTL4TZoKPEYR6BngshRgNVVdElfjuP9YoBQoiDW6y+nvBHHxGrr0cNh1FMJvTl5Zjmz0df3ofzpt0IRANsb9meCmRo02YCsf4HCDszh1Uq3FDeolLphgq3SkWLts7R02hzBgP6AhcGVwH6wkL0hQUYCgrQF2jLepcLfX4+OpsWTtLZ7VpwyWodtxWE1HicuM+nBZqSU1sb/vp6PnzjDUzBEHMqyqHxAJHaWmIt3Ywy04O430/go48IfPRRap1iNmNdtAj70qXYly7BNHnyYLysMcVlcXFMxTEcU3FMal0oFuLTA5+yumY1q/evZnvr9m5agLZQGy/vepmXd73M3KK5XHPYNXxh0hfQKaPjfZttZDMJMWVx5ZVXdkmgqarKj3/84163kfzyeuONNw5298Qod+/5hzBnzpyR7kbPIkFtuJiQVwsehTyZQ4x1WZc+/JgX/uvPWnWjzkIeeP66/vcrV2Ujo3VgFZO2/yvR92TIqFPoCABdItWsakMU9SblvecdbRp3Olc7cuQOIJnzO+2b3zWAJBerhRDjyYCCT8mAUxP4mzoCQL4DiXmjNu9L1aS+ikd7DlU1boT/qdKqMeVXgKOyY7799d49jxoD905t2vaatk5nhNtylMAN+7WKUsa83r8WIYQQQgghhohep1DlyqPKlccxU4u6bPeHojR4gqPuTmYhxPBRVRWrVavGFghoV8ftdrt8LgghxoxoTQ3BV18ltm9fl22x/fsJr12LfuJELKedhqGqqtfthmIhtri38FnTZ3zW9BmfN3zCbv8+4oNQXUlRtUpKVU1aUKnSrYWUKtwqBT7o/AmsLyjAMLkMQ1kpxtJSDKVlGEpLMZQUo3cVYCgsQF9QgC4/Xz6/O1F0OvT5+ejz82HSpI71Hg9b3FpxhuOXLSM/Px+AeHs7kbo6IjU1RGpridTUavPaWiI1NUQPHEhcf+0dNRTCv3o1/tWrafglmCZPxpYINFkXLkRnOTiHdTbrzSwsX8jC8oV8b/73qPfX807NO6zev5oP6j6gPdqe89jPmj/ju6u+S3V+NVfPvZozp56JUd81RDSc9Ho9Op2OeFrVr2h0AKXRRoEhuyqeLTXf2yS9yWRi4cKF3HrrrZxwwgmD3bVhtWfPHu677z5WrlzJvn37MJvNTJs2jQsvvJBvf/vbqS/oA/Xyyy/z8MMPs2bNGg4cOEBJSQkLFy7kG9/4Bl/60pd61UY0GuXRRx/lqaeeYvPmzfh8PiorKznllFO44YYbOPTQLEOJjQWxqHbRM+yDcHtHACeStpy+vnPo6Oz7oWha13Zb98JDvRsnOatgW/b1lq53rvXJxr9D8w6tilG4veN1RnJ/4PbKlpe1qVvxXuWWRi2dEcx24kYbzd4QYcVE2cRpGKyursEis6NTtaNOQ7EZbVLtSAghBlNfgk+qqlVv8iUqKyWDTekhp2ToyX+AIfvjFfZpgefmbYPXZuGU3MHWT56Bld8H1yQomQXFM6FkdsdytuFmhRBCCCGEGCE2s4GpJfaR7oYQvTKWzvOPJZ2vGSmKIhfAhRBjRmTrVtqfew56CAvE9u3Dv3w51gsuwDhzZpftcTXOztadfHLgEz6rX8+GunVsD+4jxsCGIUuGlSY0qUw8oM0nNKlUNXcM/aYvLMRYVYXxkCqMlZUYy0oxlCVCSqVlGEpLDprhyEYDndWKedo0zNOyXJcG1HCY8J49BDdvIbh5E6FNmwlu3kzM7c66f2fhPXsIP/EELU88gWKxYDv6aFwXnI/9C18Yt9WweqPcVs75M8/n/JnnE4lFWNe4jtU1q3mn5p2cVZp2e3bzk/d+wv3r7+fyQy7n/JnnYzPahrnnHYxGI6FQx2gREmLKYteuXallVVWZOnUqiqLw6quvMmPGjJzHKYqCxWKhqKgIvV4/FF0bVi+++CJf+9rX8Hg67tRvb29n7dq1rF27lkcffZSVK1cyffr0fj9HPB7nG9/4Bn/4wx8y1tfU1FBTU8MLL7zA17/+dX7/+9+nyrJm09TUxBlnnMGaNWsy1u/cuZOHH36YP/7xj9x///18/etf73dfe0vx7If6WCJ8k6z2k7aca/05D2W/sFn/CTzyhf53qL05e4jJPMCTLGv+AFtfhWhAG4YmfRqITf/QpoOBos8xdFqn5VzDq5lsmdsMWvlyn8fDYw8+CMCy8zoS0EIIIcYIRQFroTYxu/t9Y1Htb30y4ORv7BR2SgtA5QogD6f2Znj+m4kKT5Vp0wQ4sAVQoXWPNiWrNyXZyxLBpllQPAtKZmpzR3n/xocXQgghhBBCiIPAWDrPP9ZkCzEJIcRYEK2p6VWAqeOAKO3PPYftyisJljj5tOlT1u39D+v2vs9n7TvwK+EB9cfpV6luUJncAJOSYaUmyMtzYJo4EeOECRiPnoCxqhJjVRWmqiqMVVXoBimEK4aHYjJhnjED84wZOM86E9D+lkYbDxDavIlgItQU2rSJ8N693VZtUoNBfG+9he+ttzBNnUrR17+O88wvoxzkoTWj3siiikUsqljE9xd8nzpfHf/e92+e3Pgk+337u+zf2N7I3Wvv5uFPH2bZEcu4dM6lI/J9RkJMvTA5x3iKlZWVObeNN+vWreOiiy4iEAhgt9u59dZbOemkkwgEAjzzzDM88sgjbN26lS9/+cusXbsWh8PRr+e57bbbUj9sjjzySG6++WamTZvGjh07+H//7/+xbt06Hn30UUpKSvif//mfrG3EYjHOOeecVIDp3HPP5dprr6WwsJD//Oc//OIXv6CxsZHrrruOqqqqIb/jw/7suZDfjx9igRawlUI0mJhCWkDI2zCwDr18sxZ8ibR3ChsNsLLR1p6qGo1DRqsWHDLZOkJEqcnedTm9ylEqfGRLCx1Z5KKrEEKIgdEbwFGmTT2JBLXKTalgUz1468FTC9468NSBt1b7TjJU2pvhk6ezb+tpDO5kGGv36sz1ZidMWQIXPzU4fRRCCCGEEEKIcWIsnecfiyTEJIQYq4Kvvtr7AFNSNMq6J+7h6+X/Ip7+cdeHjz5F1YZ+q27QQkvVjVDdaqKspBpTdTWmmZMxnZpYrp6MvqBAPlvHOUVRMJaVYiwrxZ42wlWsrQ3/e+/he3s1vtWriTU15WwjvHMndT/6EQfuu4+iq67Edf756GwjV1VoNKmwV3DpnEu5aNZF/GvPv/jDhj+wpWVLl/08YQ//u+Z/aWhv4Hvzvzfs/98ZjZlD2kmIqRfSx987WNx4440EAgEMBgOvvfYaxx57bGrbF77wBWbMmMHNN9/M1q1bueeee7j99tv7/Bxbt27l7rvvBmDBggW8/fbb5OXlAbBw4UK+8pWvcMIJJ7B27Vruuusurr766qx3g/zxj3/knXfeAeBb3/oWDzzwQGrbokWL+NKXvsT8+fPxeDzccMMNbNq0CYNhWN46ffPQEohHBr/d2nWD3+ZYkBEq6hw66rwt7bE5x35GK+jGfoU1IYQQBzGjBVwTtak7kUBaqKkuLeRUm7l+sL+3qP38zh1qg9Z9cGArOKu0v9vpPvsrNG3rqOJUND1VvVAIIYQQQgghxrOxdJ5/PJAL7WI02r1790h3QYwysfp6Yvv29evYmSEnUyNOtpt6rviuqCqVzTCtTmVancr0tjxmOqfjnDoT8yHTMZ01HfO0qRjKyg7qocBEdnqnk/wvfYn8L30JNR4nuGkT/rffxvf2agKffAJZ8hvR+noa7riTpgcfouJ/fonjCwMY6WicMegMfGnKlzi9+nTerX2XP2z4A2sb1nbZb/nny4nGo9y88OZh/V4jISbRow8//JDVq7U73K+55pqMHzZJ3//+93n88cfZtGkTv/nNb7jtttu6vLl68utf/zr1Bvztb3+b+mGTZLVa+e1vf8uxxx5LNBrl3nvvzQgoJSV/IBUWFnLXXXd12T59+nRuvfVWbr31VrZv387zzz/PBRdc0Ke+DouhCDCNZjoDGG1gsiYqHFkzH2dblwwTZazPst2YJxWOhBBCiP4y5kHhVG3KJR7Xqip5azsqOKXmacvDNYRd/SfwwEJt2eIC5wTIr9JCTXvegwOb03ZWtNdWMqsj2JQcom6gw+0KIYQQQgghxCgx1s7zj0VSiUkIMRaFP/qoy7rm+no2rV1Lc309kXAYo8lEUXk5cxYsoKi8PGPfr3in8Kui9V3aKG5TmV6rMr1Bx2xdJYeUzqVwxlzMi2ZgnjFdCyvJ56ToB0WnI+/QQ8k79FCKly0j1tqK981VuB9/nNDWrV32j7W2sv87N1B1913kD/EITWONoigcX3U8x1cdz/rG9Tz22WO8ue/NjH2e3PQkMTXGrYtuHbb/ZyXEJHr0wgsvpJavuuqqrPvodDouv/xybr31VlpbW3nzzTc59dRTe/0cqqry97//HYDZs2dzzDHHZN3vmGOOYdasWWzZsoW///3v3H///Rn/s2zdupVNmzYBcOGFF2LNMfbplVdeya233gowekNMo4nepF3ANFq1Ic+SwaDklG2dMQ8MeVqVh+4CRsn1hoN7TFIhhBBiTNPpwF6iTRVH5N4v3J6jmlOnqk5qbPD6FmzVpobPcuyggnuHNm15KXOTrQxKZkL54VA6B6qOgrJDB69vQgghhBBCCDFMxtJ5/rFKQkxCiLEoVl+fWj5QU8P7r7xCQ5bKTI3797Np7VrKJk7k2NNPp6SqCoDpYRf6mMrUephZr+Mw/USOKJ3HhJnzsZwyG9P06ehMcg1QDB29y4XrnK/i/OrZ+N56i+ZHHiXQOZwXi1Hz/R+gRmM4zzpzZDo6ys0rncd9X7iPF3e8yI/f/THxtJESnt78NHE1zm1H3zYs3286h5hisUG8XjACBjXEdPXVVwPaF83k+M3p6/ujc1tjQXJoNpvNxvz583Pud0LauJTvvvtun37c7Nq1i9ra2i7t5HqeLVu2UFNTw+7du5kyZUqXvvbUTnl5OTNnzmTr1q28++67ve7nqKE3a8Ehg1kLCSWXDZa0KfHYmBYwMuR1hJEy1luyrEsLI8mwaUIIIYQYDCYrFE3TplxiUfA1gKcG2vYn5jXQtq9j2d84PP31N2jTbu1uZWylMO0krbKTcwI4JyYqPE1IhL4tw9MvIYQQQgghhOijsXSef6ySEJMQYixSw2EA9m7dyut//jOxHiqeNOzbx4uPP84pF17IpJkzmRZ28Wr+j3EuPhLztGkoBqk5IkaGoig4TjwRx4kn0v7RRzQ9+BD+tOwA8Ti1t9yCYjGT/8UvjlxHR7mzpp2FQWfg1tW3Eku72fjZLc8yv2w+X5oy9NWspBJTN5YvX576kpkePEpf3xeqqo7JEFOystH06dMxdPOHZ/bs2V2O6a2NGzdmbac3z5P+46av7WzdupV9+/bh9/ux2Wy97u/+/fu73V5XV5daDlSfQriiBAxm1ESwSNWbtcd6LXCkGsyJYJIZNRFAUtMf680Z+6AMw1iwcSAUh5B/6J9LDCmfz5d1WYiRIu9JMZrI+3GUUhzgnK1N2URDKL56dN5adN46FF8tOm8tirdOW+epQQkNwdB1/kb49Nmsm1RFByio5nxUWylx12RiRbOIl88jVjIH1V4O+u6HYZD3oxht5D0pRhN5P4rRRt6TYjTx++X8nejZWDrP35O+nJ/3er14PJ5etx2NRonH46iq2ue7/juHmPrThhCdpb+H5P00OFRVJR6PE41G+/T5MF50/h5r0+s5UFPTqwBTUiwa5fU//5mzrrqKkgULUE49gzAQbm8fol6L0WxU/jaaMQPnPXfD3ffgf+65jvXxOPX/7y44+uiR69sYsLhoMbcvvJ3b19yeEWT6z/7/sLho8ZA/fyQSyXgcDoeH7fPa6/UOepuDGmKaNGlS1rBSrvXjUTAYpKmpCYAJEyZ0u29BQQE2mw2/38++LGUGu5P+o6On55k4cWJqufPz9KcdVVXZv38/s2bN6nV/0/vQk8fr5+AMOLNsUYFAYhJieDzxxBMj3QUhMsh7Uowm8n4cy/TAxMQE6MBoCeNQPeSr3sTckzF3qF7MhAetB0qivK4SbIFgC/rmLRh3vJbargIRjLQrVjyKkyalGLdSiEfnxKM48Sj5BMiDxO8MeT+K0Ubek2I0kfejGG3kPSlGWlvbEAT4xbgy1s7z96Qv5+efeOIJnM5s5+ezmzdvHk6nE7vdTmNj36oA22y2jGtHHo9nzFcOEKNLc3PzSHdhXAiHw/h8Ptra2vjHP/4x0t0ZUU888QRLIhF2vPJKrwNMSbFolPdfeYWpkybxzoMPDlEPxVgz6n4b2azMnTOHqWnB7FBdHQ/Ke7ZXqvOr2WHdkXq84bMNPPje0P/b5efnc8ghh6QeBwKBYftvNhS/rQY1xLR79+4+rR+P0pNmdru9x/2TP276mrLsy/OkV0zq/DyD1Y4QQgghhBjbIooJt1KMm+LsO6gqZkJdwk35qod8tQ1XvBU7PnSo2Y/vIwUwEcGktuFS25jE3q59xoBHycer5GeZO/Aq+YQV86D0RwghhBBCCHHwGGvn+ceLzpWZhBBiNPq0oQFfH8OkSQ379tHe2AhVVYPcKyEGiaJQM3VKRohJ9J5e1Y/I8waDQerq6ohEIkSj0S6VmcYaGWRzkAWDwdSyyWTqcX+zWbuoEgj0rbpQX54n+RzZnmew2ulJT3eG1NXVsWjRIgDOPfdcZs6c2af2hRhMPp8vlXy+7LLLenWiQoihJO9JMZrI+1F0x6fGUfwHULy1iaHralA8acveWnTtTYP2fEaiFKluilR3zn1Ucz5xewVxRyWqo5K4oyIx73iMwTJofRIHN/mMFKOJvB/FaCPvSTGabN26lTvuuGOkuyFGsbF2nr8nfTk/f9lll1HVh4vrNTU1xONxjEYjpaWlfepXIBDICC65XC70+pG5+CfGj1gslqrAVFRUJO+pQeD1enE4HDidTo499tiR7s6w6/w9dv1PfsLGHo7pzsRAgEuWLRuczokxaTT/NlKjUVp+8tOMcZGMJhPL5D3bK41rG9m6b2vq8aGHHsqyecPzbzdS76uamppB/20lIaZBZrF0XAAJh3sebiMUCgGQl5c3ZM+TfI5sz9O5nfTHfWmnJz2Vwk1ns9nIz8/vU/tCDBW73S7vRzGqyHtSjCbyfhRZOV3AjNzbI0Fo3Qs1a6F2HRzYDK37wH8Awn4YpEpOSUrIgz7kQd+8JfdO1iJwToD8CeCsgvyqxOMq7bGjAvTGQe2XGP/kM1KMJvJ+FKONvCdHOVWFWASiQYiGIBpIzBOPI+mP06fO23o6NrH96lfBUT6sLzG9oo0Q2Yy18/w96cv5eYfD0afP6IaGBqLRKIqi9DksoihKRoipP20I0R29Xi/vqUGgKAo6nQ6DwXDQf4ez2+20bhxIhAlaN2486P8dRYfR9NtIjUSo+f4PCLz+esZ608SJo6aPo9mTG5/ktX2vZayzWqwj8m83nO8rj8cz6G1KiGmQORyO1HJvSrr6/X6gdyVp+/s8yefI9jyd2+kuxNRdO0IIIYQQQvSK0QIlM7Vp3n9lbovHwL0Laj7WQk4NG6FlJ/gaIB7t2E/RgRofvD61N2tT3Sc5dlC0C2vJUFO2sJO9DHS6weuTEEIIIUS6WBQi7Vr4J9KuhYGSUzSQ+ThjXbsWIs+2LlfQKBoc3O9aPYm0D99zCdFLY+08/3ghw8kJIcaCcNpQoP3RsO0zNtx/B5MPPQbr4YdjKCoapJ4J0T9qNIrn1VdpfvgRQlsybwRVzGbKbvvRCPVs7Pjj53/k7rV3d1l/XOVxI9CbsU9CTIPMYrFQVFREc3Mz+/fv73bflpaW1A+PiRMn9ul50u+c6Ol50kvFdn6ezu0UFxf32I6iKH26c0MIIYQQQohe0emheLo2HXFhx/p4HNr2wYEt4KmBIy8Dbx3+ui288bcV5Ksejjt0Eqb6j6DhsyHomAreOm2qWZuj7wawl0N+hVa5Kb9SmxyVmeuMfbtjWgghhBBjQCwKET+E27VATtjfad6eub1zCCkVTsq1rj0z0D3eREM97yPEMBtr5/nHKkVRMh5LiEkIMRaY0gKo/VHnjPJfjj9R8PlTzHxNZY7XweH2mRwycQH5c+ZimT0bQ0VFl89IIQZbPBSi7fnnaf7DY0SyDD2rWCxMfPB32BJDzoquVFXlsc8e49cf/7rLtuvnXc/SCUuHv1PjwKCGmKZOnTqYzQHal9gdO3YMertD6ZBDDmH16tVs376daDSKwZD9n3nz5s2p5Tlz5vT5ObK109fn6dzOvHnzemxn4sSJUnJZCCGEEEIMH50OCiZrU5JrIjGdk02GjwA46uRlmPa9Af95GJq2aJWVhlM8Cp792tQdiysRbqpIhJsqu86tRVLVSQghhBhssQiEfVqwKDnlChh1Xpdr3+T6WM9DTYluRIMj3QMhshpL5/nHKoPBkAqAOZ3OnP/GQggxmpTMm0ft++/3+3j3JG1UnBaHwn9mK/wHP7AOQ/RjpnwA055Xmd5m4VDbdKZNOgLL9BmYp0/HPH06+gEGqIRQVZXQtm14X3+dlj89TaypKet+Sl4eEx96CNvREmDKJhaP8fre1/nDhj+wyb2py/Ybj7qRrx/29RHo2fgwqN8Id+/ePZjNAV2T+GPB8ccfz+rVq/H7/Xz00UccffTRWfd76623UsuLFy/u03NMmTKFyspKamtrM9rJ5u233wagqqqK6urqLn1N78/FF1+ctY36+nq2bt3ar74KIYQQQggxLA49R5sA/M1amOnAFmja2jFv63pXEQBmBxy9TKv01LY/Ma/RhlcZTMFWbWrcmHsfnTEt5FSRFnrqFH4y5h4KWgghhBizVFWrzBP2dwoddbeca1vaYwkaDa3CqeCaDAYLGMxa9UmDWXv80fLsQaUv36N9tymoHu7eCtErY+k8/1il1+uJRqOpZZ3czCGEGAOO+MY3+OTBB/t9/NYTC7KujxoUtlXBtioFCAMbyQt9ztRNKtP+DVPrVKbHiphcOpO86TMwz5iOaeo0TFOq0btcY/KauhgeMZ+f9g/ex/f2anyrVxOtq+t2f9OUKVTe8T/kdVP85GAVjoX5x45/8Phnj7PXuzfrPt+f/32unHvl8HZsnBnUENMVV1wxmM2NWV/96le54447AHj88cez/riJx+OsWLECAJfLxUknndSn51AUhbPPPpsHH3yQzZs388EHH3DMMcd02e+DDz5I3aFx9tlnd/kDNnPmTObMmcOmTZv485//zD333IPVau3SzvLly1PL55xzTp/6KoQQQgghxLCzFYHtOJjcadzxkA+at8GBrR0hpwNbwDURvnBb5r6qCoEWeP2n8PGK4et7PAJte7WpO3kFXYers5eCvSwxlYKtFExdv98LIYQQgyYe7wgShXwQ9ibmmY/N3ma+EH4fExHyVn4GajgzZBTydTxWYyP9qsavQ8+BCQu1cFF60EhvhqcuAOL9a3f+VbD4huzbNr/U9XuN3gxTT4Kiaf17PiGGwVg6zy+EEGL4lM6bR+Vxx1H73nt9PjY4s5joBCdaSKlnAbPC55MVPk8VJ2/FHP4P1Y3/YfLbKtXPqVQ3qkwOOXBMmIKpejKm6mpMk5PzavR2GV3nYKPGYoS278D/zjv4Vq+m/aOPIBLp8TjL3LkUfeNaHCefjKLXD0NPxw5f2MdzW5/jiY1PcCBwIOd+Ny+8mcsOuWwYezY+DWqI6fHHHx/M5sasRYsWsWTJElavXs0f/vAHrrjiCo499tiMfe655x42bdJKi914440YjcaM7atWrUr94LniiisyQkRJN910Ew8//DCxWIzvfOc7vP322+Tl5aW2BwIBvvOd7wBaWdabbropa39/8IMfcM011+B2u7n55pu5//77M7bv2LEj9WNt+vTpEmISQgghhBBjl9kOlUdqUzpV7bqvooC1EAKt/X8+RQdGm3YBd7AFWrSp8fPu9zM50sJNyXlJZtjJXga2EtAbu29LCCHE2KeqHWGhZMgoFSLyQcibtq2bx8ljIv5ePa0ZWJh8sGX9EL24UULRacGgSHv/2zjhFph0DBitibBRnjZXVfjNYf1vd8oJsOCq7NvMDgi1Za7Tm8Fky5yMVjDZtaC0yaYtVxyR+zkvfQ50hsS+Vu27kV6GjBKj31g7zy+EEGL4nPTrX/Ps0qVEg70fFteQl8c1T77EbQsWsMezh/UNH/PRjtV80vQpu2ONqL3Mp4ZMClsmwJYJHQco8XYq3Z8zufEzJq1VmfAyTGhWKW8BY2ERxqoqTBOqMFalTxMwVlags0il77Es3t5OaOtWgps3E9y0meDmTYS2bEXtw3vTdtxxFH3jWqxHHy1B6TTReJQNTRt4c++b/GXrX/BGcp/fneSYxI1H3cip1acOYw/HL/m1OER+85vfsHjxYgKBAKeeeio/+tGPOOmkkwgEAjzzzDM8/PDDgFYJ6fvf/36/nmPmzJn88Ic/5M4772Tt2rUsXryYW265hWnTprFjxw7+93//l3Xr1gHwwx/+kBkzZmRt54orruCxxx7j3Xff5YEHHqC+vp5rr72WgoICPvzwQ37+85/j8XjQ6XTcd999Mi61EEIIIYQYf7r7gX76HXDkZV2Hpwu29txu5ZFw7b+1C76eOvDWdsw3vwQ1awftJeQU9oLbC+4dPe+bV9gp7JQ+T6vylFcIMtSDEEIMn1i0a4WjkKdTuMiTGTRKr4rUOYhElvDuwUZv1gI1Oj34m/rfztkPwIRFiXBOYjKYwVsPv5rd/3ZLZsG0L3Rdr6paSErNUTHJaNXCSCa7Nk+fTHYonpn7Oa9+uePfxWQbvLBR6QD+HYQYYWPpPL8QQojhU7FwIWf95S+8eP75vQoyGfLyOOu556hYqMX6q53VVDur+erMcwHwhD18duAzNjRt4POaj/nM/TkHYm3dNZlB1SnUFENNsUJ6fShjVKWyuZWJTS1MOLCBidtgYpNKaSvoEj8J9CXFmCqrMFZVYigtw1BWhqG0BGNZGYbSUgylpRJ0GgXUSIRIfT3h3bsJbtpMaPMmgps2E969O/vNmT0wVFZgX7oU1/kXkDf30MHv8BjVFGji3Zp3eafmHd6rfQ9P2NPt/nMK53DNYddwyqRT0OuketVgkTTKEDnyyCN59tln+drXvobH4+FHP/pRl31mzpzJypUrcTgc/X6eX/7ylzQ2NvLYY4+xbt06Lr744i77XHPNNfziF7/I2YZer+eFF17gjDPOYM2aNfz1r3/lr3/9a8Y+ZrOZ+++/ny996Uv97qsQQgghhBBjknOCNs1Mu5NGVcHX2BFsat7eMbXu7biwWDRdm5sdUOKAkrQLh03b+xZiUhKhoVwXLQdDwK1NBzb10Bd9Yri6ThWdbCVgLUpMhYmpSLtoKndyCSEOJqoK0VDXSkYhb5ZgkbdT8Ci5nHZcNDDSr2hkGW2gN2n/dmq8f38LL/0LlM3tWgmocTP8rusQUb1mL8/8+55kcfa+DYMlLXRkB3N+7uMVBS58QqvK1DmgZLIPLHRUJhcvhOhsLJ3nF6In1dXV7NmzJ2dVsJF0++2387Of/QwAtR8X44UYCdO+/GUuevttVn33u9S8+27O/aoWL+bEe+9NBZiyyTflc1zVcRxXdRwkClweaD/AZ02f8VnzZ3zWuIHNzRtxR3ofbAKIGBT2lMGessxzMsaISlUzVLhVKlrcVLibqVj/CZVusGfJZOmcToyJQJOhrAxDWSmGomL0BS4MhYXoCwvRuwowFLhQTKY+9VFo4sEgkdo6IjU1RGprtSltOdrYqA3l3V9GI9b587EvWYL9hKWYpk2TqktALB5jQ9MG3ql5h9U1q9nYvLFXxx1dfjRXH3Y1x1YcK/+OQ2DEQkyqqrJz507cbjcAhYWFTJ06dVz9Rz7rrLP49NNP+c1vfsPKlSvZv38/JpOJ6dOnc8EFF3D99ddjtVoH9Bw6nY4//OEPnHfeeTz88MOsWbOGpqYmiouLWbhwIdddd12vgkfFxcW89957PPLII/zpT39i06ZN+P1+KisrOfnkk7nxxhs59FA5kSGEEEIIIQSgXUB0lGnTlKWZ26IhcO/SAk22ktxtNG/v23OmX7AtmgFn/L/M6k6+Bm1q3QeBZoj1PNZ9v6kx8NZpU2/oTVqYKS8t2JSaF2XZVqRVgBhHvw+FEGNAtmpHfX6cFkqKR0f6FY0MvSkxGbUqR4kQbjweJ9juR0cMs15BiYWyH3/ZC+CalAjlJIYu0+lgz/vw+On975fFCfkVWdbn979N6Dr8WpIxDxbfmAgZObXntyTCSWaHFlRKho8MfbzQM+fMgfVZCNEnY+k8/1ilKAqqqhKLxdDpdOPqOpEQYnyrWLiQS955h8ZPPuHThx+mcf16wl4vJoeD0nnzOPwb36D0iG6G3e1GibWEkyadxEmTTkqtawo0sdm9mc3uzWxxb2GzezN7PHtQ+1hpNWJU2F0Ou8u7ft7aAyoV7kTAyZ1YbmmjYncblm3bemxb53CgLyzA4CrQwk2FBRgKCtAXFKJz2NHb7egcDnQ2Ozq7Db3Dgc5uR2ezoYyjqt/xYJBYWxux1lZiLa0dy62tBA40Mu8//8EYDNH4nw+pb2gg1tw86H0wVFZgP14LLVmPPga93TbozzHWqKpKrb+Wjxs+ZnXNat6rfY+2XL/pOlFQOHnSyVw992oOKxnAEN+iR8MeYnrllVf43e9+x6pVq/D7/RnbrFYrJ554It/61rfGzRfyyZMn86tf/Ypf/epXfTruxBNP7FPa/IwzzuCMM87oa/cyGAwGli1bxrJlywbUjhBCCCGEEAc1g1kbNqWnoVPmnKVVeGreDs07IOLvfv90ZYdmH2IG4IVvw/onOx6b7FooyOwAo0WrohSLQKRdGxLPd0ALJQ2lWLhvoSfoCD4lA095hZ2qPKXNk9sk+CTEwUNVIRqEsF8LDIX92ZdDvrTlTkOqdQ4hRXseBmJc0hm16j8mu1YRyGBJBJAMWgBJQfv3jse0vx+xEESCcMZdkOdKVBCyd1QC2v46PHNJ16cBUpf4u/uzk18FRdO6rs9zDex1Blqzr7c4wTmpU8goP/Nxl3WuxON87e9+NooCX/zvgfVZCDFqjKXz/GOJqqrYbDYURSEQ0KoOWq1W9PqBDccSq68n/NFHxOrrUcNhFJMJfXk5pvnz0ZeXD0bXhRAiQ+kRR3DKAw8M+fMU5xVzfNXxHF91fGpde6Sdba3b2Ny8mW2t29jRuoOdbTtxB939eg5fnsK2KthW1fX8itOnUtoGJW3akHQlbSolbVDaplLcBqYYxL1e4l4vkT17+/zcOptNCzTZE2Enux2dNQ/FZEYxmVDMJhSTCZ3ZjGI0oZg71utMicfGxH4GY//OEakqajhEPBhEDYVRQ0HiwRBqKEQ8FETtvBwOaduDQWIeTyqspPYwzOCkxHxQbkHU6TBNmYJl9mwsc2Zjnj0Hy+xZGIqLB6P1MSsSi7CjbUdG6G+LewveiLdP7cwomMGSqiWcPf1spjqnDlFvRbphCzG1t7dz2WWX8cILLwDZy0H6/X5eeuklXnrpJb7yla/w5JNPYrNJIlAIIYQQQggxDi2+oWNZVcFbD83bOkJNzduhaRu07O4aMkoOU5dN657Mx+HExflsFB04KsFZpVWNKqiG8sM7qjr5DySWG7V5++DfFZZTv4JPZu0id/LCcsY8rfJF1m09XIwWQvSfqmrByfSQUXq4KFcAKbXs7/gsS388lMNrjnZGW0dwKH04seQ6nVGrXqTooPSQxHpH2jF2qFkH79wDwTYt4NO2r299qDwS7FkqDuYVDOy1BVuzr8/Vrs6offZbXNnneQXactkh2Y832eC7GwbUZSGEEP2TreLSQIYSi9bUEHz1VWL7uv5Ni+3fT3jtWvQTJ2I57TQMVVX9fh4hhBhNrEYrR5QcwRElmRWf3EE3O1p3sL11Oztad6SmllBLv5+rza7QZs8ecAIo8HaEmkpaE2GnROip0AvmHorVxv1+4n4/NDT0u4/jnc5mwzxjBuY5s7HMnqOFlmbMQJeXN9JdG1FtoTa2tmzNqFS2o20H0X5USLYZbRxTcQxLqpawuGox5TYJQA+3YQkxxeNxzjjjDFavXo2qqhiNRk499VQWLVpEWVkZAA0NDaxZs4bXXnuNcDjMP/7xD8444wxWrVolpUOFEEIIIYQQ45uiaEPc5Fd0HZ4uFoGWPYlw03Yt6DT5uNxttezu/fOqcfDs1yaAOV+B036Zfd/P/gqeeu1isCkPFEOiklOnkFO7OzFvhvgQDmmXTSzUEcDqL725I9xkdmQPOnWZa5U5lIiCQY0QHbmR24XoO1XVQoNhP0QCiSm53K7Nw+0dy5H0/do7beu0HE5b7uPwBuOOousUIuq8nBZCMudnBpJQtM/baChRBSmghY4Cbgi0aJ+7ATe07dceB9vI+Pf+v01aZaXOGjdB/QDCO4GW7CEma2Hf29IZOkJHuS5eW4vgoqfSAkoF2rLRKlX4hBBiDFNVNeMaUH9DTJGtW2l/7jmIdn+xMrZvH/7ly7FecAHGmTP79VyjQW1tLffddx+vvfYaO3bsoL29ncLCQkpLS5k7dy6nnXYa5557Lvn5+Zx44om89dZbqWP/+Mc/8sc//jGjvRNOOIFVq1alHre0tPDCCy/wxhtv8PHHH7N3717C4TCFhYUcccQRnHfeeVx55ZWYTNmHRN29ezdTpkwB4PHHH+fKK6/kb3/7G48++ijr16+nsbGR448/niuvvJKrrroq49hs1wR37dpFdXV1P/+1hDg4FVoKKSwvZGH5woz1zYFmdrTuYLdnN3s8e1LTfu9+ourAhsRucSi0OGDrhOzfz20BlUIfFPi0UFOht2M5OXf5QXcQ/3zUO50Yq6owVlVirExMVVWpZZ3TedBmJyLxCI3tjdT6aqn11bLft58t7i1scW+h1l87oLanu6azpGoJx1cdz5GlR2LM9htaDJthObP6+9//nrfffhtFUTjttNN49NFHqcqRcq+pqeHaa6/llVde4Z133uGhhx6S4c2EEEIIIYQQBy+9EYqna1NPVBUKpwKKFkzqa5WSgurc2z5aDrvezlxnLwPXZO244pngmgT5ldpQQI4K7aJywJ0WbkoLOLU3J7a5M8NPwx186iwW0ipQ+Q/0+VAH8H0gjoLy299oF9aNVjDmJSarNqRfl3V5YMjruq7L/mnHGfK0qlEH6YmrcSke195/0aAWVklNQS1klLE+27rkem3ZEvDx5fCnGNQoec9/AGokLajUKWx0MFc06o7Rmhkm6lztqDePk+sUnRb6CbR0fPalh5DCfjjlp9n7sf5P8MIAzo0FWsBe2nX9QCsmBXIMT2EtgvLDEiGjAm3Iz7wCgro8/v3+eoKKhdPOvghbUVVHIKk3w4HqjTDnzIH1WQghxKjTObTUnxBTtKamVwGmjgOitD/3HLYrrxyTFZlWr17NmWeeicfjyVjf2NhIY2Mjn332Gc888wzFxcWceWb//nYeeeSR7Nmzp8v6hoYGXnvtNV577TUeeughXnrpJcp7GKJPVVUuv/xynnjiiX71RQgxuIryiijKK2JRxaKM9dF4lFpfbSrUtNuzm72evezx7KHOX4c6CDem+PMU/HmwryT3d38lruLyZwacCn0qLh84ApDfrpLfri3bgtro16OaoqDLz0fvcqJ3udA7ncRtNj7bs4eI2czRXzwVx9QpmBJBJd1BPEpVKBaizlenhZT8WlCpzt/xuLG9kfggnb9wmp0cVXoUSyYs4fjK46mwVwxKu2JwDEuIKZnoXrhwIStXrkSn0+Xct6qqihdffJHFixfz4Ycf8sc//lFCTAeZmpoanE4nNpsNu90+4PGvhRBCCCGEOGgoClzxD205GtaGBmrZrQ0x17I7bdqTfbiegsm5227pegI7VfVo/4fZjzE5tFDTERfDku/13H9VhZA3d8ApFX5qSXvsHvngUyc61I6QyJBSsgScEqEnvTExnJQhsWxIW6fvWNYnHqeW0/bXGUFv6EM7hsz9RjpgpapaOCce1SqaxaMQjyXmuaZYp/07HxPJ0kYs9/6xcPawUSwtdBRNbB/k97EJmJt8sGvzoLY9apnsWhgmNdk7LecIHJkdXYdaM9m193hnsaj2/0U2ez+AT57pCCcFWqA9MY/4e+7/6XeCIUs1g7x+VDZK1+7OEWLqpl2TvaPSUSKElJqsiccFU7IfayuGb77TZXXY42HDmgcBOGXisZCf348XI8aqaDSKz+dLTYqiMGvWrJHulhBiFBiMEFPw1Vd7H2BKikYJvvoq9quv7vPzjaRQKMTFF1+Mx+PB4XCwbNkyTjrpJEpLSwmHw+zatYv33nuP559/PnXM448/jt/v57TTTqO2tpazzz6bX/ziFxnt2jpdNI/FYhx99NGceeaZHHnkkZSVlaXaf/LJJ3nllVdYt24dF198cUYFp2x+/etf8+mnn7JkyRKWLVvGzJkzaW1tZffu3Xz1q19lwYIF/O53v+PBB7XvCRs2dK0UmaswghBi8Bh0BiblT2JS/iSWsCRjWygWYp9nHzW+Gmp8NalQyX7vfmr9tbSF2gatH6pOq+bU4oCeIkr6uEJ+xEB+WE9+SEd+UCE/oJDvj2tBp5AOZ1Bb70jMDWrP5yoUsxmd2YRitiSWzSgWC4rZhC65zmJGMZlRLIntZgs6hz0VVNK7XNqUn4/S6Vq3x+Ph88Rn3snnn4djnP82CkQDtIXaaAu10RpqpTXUijvops5XR42vJhVUag42D8nzT7BPYHbhbGYVzmJ24WxmF86mzFp20Fa0GguGJcS0adMmFEXhu9/9brcBpiS9Xs/3vvc9Lr74YjZt2jQMPRSjSUtLC9u2bUs9zsvLw263p0JNdrsdk8kkHyxCCCGEEEJ0x2CComnalE2gRQsmpYecKo/Kvm8sog1T1FdhLzRtSQxtlMOKs7V+5FclqjhVpi1XaNU8bCXZwwSQGXxqd2vhrJAHgp7s82zrYuG+v7ZRQU0M7dWLcIQQo0lyaLWcgaMsASRz50BSp2VDHvTinFNKLKp9XrQnAkf+A9rnVWp4tpZOw7W1dlQe+lFN9jbdu+Cjx/v/7xJoAUdZ1/UDqZhktGlVnrLJr4SzH8iolpSasoWphOiH/fv3U1NTQzAYzFiv1+uZOXOmnN8T4iChqipqe9eAvxqLoba3oxo6LlXFIxHifQgkxRobie3b169+xfbtI7JrF/rSLGHfAVKs1iH5jHv33XeprdWGzPnTn/7UpdLSMcccwyWXXMK9995Le+LfPDmsm9GoDY3jcrmYO3cu3fn3v//NjBkzuqw/7rjjuPTSS3n88ce5+uqreeutt3jjjTc4+eSTc7b16aefcvnll7N8+fKs/yYul4vStP8GPfVNCDH8zHoz0wumM70ge5VwX9hHrb+WGm+NNk8EnZKhJ2/YOyT9iulUWswRWswRrTx2L1gNVuxGOzaTDYfRgc1ow26ya+uMNhymxDqjPed6q9GKTunD789xIhKP0BZqwxPypMJIncNJnnDXbaFYaFj6Z9QZme6anhFYmlkwE4epl28OMWoMS4gp+aVkZh/GF05+OZIfsiIQCBAIBDhwoGM4B6PR2CXYZB2iHwVCCCGEEEKMS8kL1ZXzet430g5zz+uo5ORv7Ntz5Xdz12zzTmjbCy27cu+jM2jD0yVDTo7EfNIxMGEBWPK1qTBHVZCeRIJpoaa2tMCTt1PgqS13OCoa7Pl5hBgrFL0WDOpc6cuUPkSirWN4Q5Mtbb/OxyS2JSshmWyDNxRiRvW2Vi2UlJzHwrDw69mP+/AReOkH/X/eaEh7DZ1ZB1gxKeDOHmKyFmqfg8mwkbUwMS/Isq4wM5RktOR+PrMdjvzawPosDmrxeBy/3084HKaoqCjrPqqqdgkwgVbhIxgMkpeXN9TdFEKMAmp7O9677866TQ8ZAxSFE9NwaV+xYkjadfzgByhDMCRQfX19annp0qU59zMYDOQPoLJHtgBTuquuuor77ruP9evX88ILL3QbYnK5XNx///1y/UaIccxusjPTNJOZBdmzAL6wj8ZAIwfaD9DY3khDe0NquTHQSGN7I03tTUTVPlbV64f2aDvt0XYI9L8NBQWb0UaeIQ+T3oRJb8KsN2PSmVKPTXoTJl1ifdpjk94EUfjc+jl69Px9199x2p2YdCb0uW7g66eYGiMcCxOMBrV5rGMeioYIxTpNaetS+6YdGxklldDzDHlU2iqpsFcwxTmFOYVzmFU4iynOKRh1xpHunhgEwxJimjZtGuvXr6exsfcnupP7TpuW465hcVCLRCK0tLTQ0tKSWnfEEUfgcrlGrlNCCCGEEEKMVxYnnPdIx+OwH1r3dhqibje01YCnpqNaSVJ+ZfZ243Hw1vb8/PGoNjReW6c7rI//rhZiyub1n2khBmuRNrSRtTgxTzw253eEKIwWbco23FJvRcN4m2v502MPYSTCReechc2sg0ggMbRc+jyYZV27FoTKun9iWY33v39i7FL0YLBooZnkpE8up6+3gN6UWGciFNexbsNGYuiZf8xSLI7CHKGjTuEjk00bEnC4qGruQNO+D2HrK10DSulzNZb9WENe7hCTeYB3YQZaB1YxyeLsGj7KK9BCXtkUTYf/2zTyQzSKg1okEkkNBef3+/H5fLS3t6OqKnq9nsWLF2e9OG2353hfA36/X0JMQgjRRxUVFanlxx9/nBtvvHHIn1NVVRoaGvB4PITDHRGzqqoq1q9fzyeffNLt8WeddRYOh1TBEOJgZjdpVY2mOqfm3CeuxnEH3ZlBp0Ai6NTeSEuwRZtCLQSiA0ggDQIVFV/Ehy/i638jiZzp2vVrB6dT40i+KZ9KeyWVtkoq7ZVU2Cq0ub2CKlsVTrNTgrHj3LCEmC655BLWrVvHihUrOO2003p1zIoVK1AUhYsuumiIeydGG5fLhdVqTZU67a1cJ0UCgQA7d+7MqNxkNpvlw00IIYQQQoj+MtmgdI42ZRMJgLcOPLXaVDU/+37tTVpAqb+6q/C0/inwNeTerjdpgSZrMdiKtCHrksvVS2HS0X3ri8GEmldIq04LMcQqj4IB3Pnchapqw/p1DjhFcwSiYlGIR7Rj4lFtikUS6xLb4tFO+0UgHsuxXySzje72y7iXfpTQGRKTURuaMPXYoD3WGzMfZ2zvPCW2p47pYf9U2MjUETrSdw4g5Qgm6c2g79+pm5DHw1ubHwTgsEXLsAzm+7GzcLsWXgwmKpiFPNowkunL2QJIgRYtPPW9z7O3W7sOVt/Tvz5FA7krJg1keDbIXTHJOREWXKO137kiUnKdxdX3/6Zy/kIMo2TlpGRgKRlaCoVyDwHRXVUlW1oVEkVRsNlsqfNztiGoUCKEEOPd8ccfz9SpU9m5cyc33XQTTz31FOeccw5Lly5l4cKFmEyDNyTsypUrefDBB3n77bfxenMPBdXU1NRtO4cffvig9UkIMX7pFB3FecUU5xUzpyjH+aaEQDRAa7AVd8jdEW5KBJy6LIdaaAu1DdOrEN3RKTryTfk4zU5cZhfltvJURaUqe1UqrGQzyu+Eg92whJhuuOEGnnnmGZ555hmOOOIIbr755m73v+uuu3j66ac56qijuOmmm4aji2IUmTBhAnPmzCEWi9He3t7lpEks1vUuS4vFgsGQ/e3s9XppamrK+CJtMBiyDken0x1845cKIYQQQggx6Ix5UDhVm7pjccLVr2nVm5KBJ29t2nJd9yGn7io8+bs/kU4srLXvreu67aQf5w4xPXOpFsiwlaRVeNLCUHryKIofIKjkaWEi1TF44QNFSYRgTJDnGpw2h0oy4DQa6I2g6CQEko2qau/TZNAofXjE1FCKaduMVvjS/2Zv64Pfwb9/3r9+RLq5gcni6l+bSTkrJnUa9s1oS4SMCjKDR52DSMnHBdXZny+/As781cD6LMQI8Xq9bN++Pee5t574fL6sISaTycScOXOwWq1y7k0IIQaB0WjkxRdf5Pzzz2fTpk2sWbOGNWvWAJCXl8fSpUu5/PLLueiii9Dr+zcskaqqXHvttfzhD3/o1f6BQPcVUQoKBhggF0KITvIMeeTZ86iwV/S8MxCNR2kNtdIabE1VUPKFtbk/4scb9uKP+LtdP9LVn0Ybm9GGy+wi35SPy+zSls0dy06zMxVWSj52mBzoFPk9IHo2LCGm+vp6Hn30Ua677jpuvfVWnn76aa644goWLlxIaWkpiqLQ0NDAmjVreOKJJ1i/fj0LFy7k4Ycfzhjft7NJkyYNR/fFCNHr9Tgcjowyo53vBkuWr+7uzi2fr2spv2g0SmtrK62tral1ybvBHA4H+fn5OJ1OLBaLVGwSQgghhBBiqBjM3Vc8isfAfyAt5FSXGXgqmJL9uGBr7iGmesNWlHvbvv9ofcp2GJAavOq392nhGbNDG7rO7ICjr4P5V2Zvd+M/tD6n72+yJx47tGo/Y4VOP7b6OxbE41ploXA7RPyJeSBtOTlv18JGR12WvZ33fwf/eagjqNSXSmi20twhJouz768pKRrUhlg0Wrpu61NgT0kbps2lBaByfQ6UHQrf+qCjQlK2ak1CjDOqqtLe3o7Vas16rkun0+HxePrVtsViIR7PPeRpaekAhmsVQowLitWK4wc/6LI+HovhbmnBYsn8HtDdUJSdBf/1LyI9DGfWHeO8eVhOOaXfx+eiWK2D3mbSIYccwoYNG3jxxRd58cUXefvtt9m+fTuBQIBXX32VV199lV/96le89NJL/foMfuyxx1IBpnnz5nHTTTdx9NFHU1VVhdVqTYWjLr/8cp544glUtftKrP0NUwkhxGAx6AypKk/9FY1H8Uf8qXCTL+IjFA0RjocJxUKEY2FtiodTy6FYqMvjSCyCP+Rn++7txIhRWlFKlCjhWJg4ub9T94eCgllv1iaDObVs0Vsw6U1YDIm53tKr/fL0eeSb83GanBiHcxh6cdAZlhBTdXV1xo/jTz/9lO9///vdHrN27VqOOuqonNsVRSEaHcCwA2JMUhSFvLw88vLyKCkpSa3v7kRJthBTNqqqpsJRdXXa3dhms5lFixbJXWJCCCGEEEKMBJ0eHOXalGtIumwUBY69XqvG1N6UmDdr897cOWfNcVIrHtfa6S01rlVtCibKlge7uTj82m3Qujf3dqOtI9CUMeXDzNPg0K9mP27fGq3qlMGsDaGnT1RzSg5dpjcmhiwzgfzu6btIQJti4cQUSZtH0ob7a+8aQLIVw8Jrsrf79t3w0R+1/ZNDBPZWwZTcIaaIH1r39P11ghZ6ysXsyL2tN4KtYCzvut41GQ49RwskJYNJuebm/N6/h03W3MNhCjFOxONxfD4fbW1tqSkajTJ//vys4YBkuKm7C9HJGwCTVc2TVc5zVUcXQogkRVFQstyIrMZiqIFAl8CPkiNwmY35mGMGFGIyH300ujE4vKVer+erX/0qX/3qVwGoq6vjlVde4YEHHuCjjz7io48+4rrrruP555/vc9uPPPIIANOnT+e9997LWmkPwO1297v/Qggx1hh0hlR1oYHyeDw8uE4b/n3ZxcvIH8rh34UYg4btF2ZPSWwhBqK7kFFFRQVWqzUVUOpLSWyDwZCz7Ugkgl6vl4CTEEIIIYQQo01eAZz2y+zbwv60cFNzYn4gM+iUa6ioQIsWTOqv7oIe3QVEIBFm8YMvS7Xi/MrcIaYXvgnN23vXP50xM+Q0/wo46UfZ933jv8G9My0YZU6EoYwd4ahcJcLLDoOZp2bftuEv/Q/ZFE7L/e+w7imo/7RTyChb8ChtXTzxuGoBnJ9jKI2Xb4GP/9i//lYckTvEFPJCWzehtu50F3gayMnWaED7d8l2t6U57YSryQGW/MyqYhZn9yGkzsO7JZXOhguW97/PQhxEotEoHo+HtrY2PB4PHo8n601/bW1tWUNMiqJgt9vxerW/R0ajsUtgKVcVJyGEGIhs145UVe31542+vBz9xInE9u3r83PrJ05EX54lSD0GVVRUcNVVV/G1r32NY445ho8//ph//vOfBAKBVAipt/+mn3/+OQBf+cpXcgaYVFXl448/HpzO96FvQgghhBj/hiXE9Pjjjw/H0wiRVUlJSapqk6qqhEKhVKApOSRdMBjMeqzTmfsE7+7du6mrq8PhcOB0OnE6neTn52M0Svk8IYQQQgghRi2TTZsKJvf9WKMFznlYCz11rvDU3oTqb0IJdVNtKVeISVV7DjF1p7twVDTc+3biieBOxK89Dvtz77tzFdR81Pu20x15We4Q0/qnYMe/+9furDNyh5i2vQob/96/dvOrcm/Tm/rXJmgVmXIxDaAaQHftdvde0ZsT4aNk8Ci5nPY4HsseYpp+MvyfvVqASW70EWJYhMPhjCpLva1E7vF4qKrK/rk2ebL2t9Fut2MymeSCshBiWOQKMfWF5bTT8C9fDn0ZvcNgwHLaaX16nrHAaDRywgkn8PHHHxONRmltbU0FkZLD9oVCoW7bSI6C4vfn/j3w97//PTWixWBIH1IwFAphNstwv0IIIcTBalhCTFdcccVwPI0QPVIUBYvFgsViobi4Y4iIaDSKz+fD6/Wm7lqLRCLdhpja2tpQVTV1d9u+xJ0eNpstFWhyOp1dxvMWQgghhBBCjFEmGxxxUc7NXo+H3//ufsyEuOq/zsdhVCHs0wJKIS9MXJT9wFhEq8qT3C/k1Y7rre6CKbHuL1B0q7uATl/CUaPBQMJGsW5e60Da7a5iktGae1uSIU8bFs1oA2Pacnfvh+rj4eI/ZQkqObQKWv1lMA/seCFEryUrX/Q2tNRZIJB7WNWioqL+dksIIQakc+WlvoaYDFVVWC+4gPbnnutdkMlgwHrBBRhyhDpHs9WrV1NRUcH06dOzbg+Hw7z11luAFkpN3uANWrWmzZs3s2PHjm6fY8aMGWzYsIEXX3yR//mf/6GwMLNq5o4dO/j2t789wFeSqaKiIqP9Qw45ZFDbF0IIIcTYIQOWC4E2bJzL5cLlcgHaj6RAIIDJlP2EdDQazXkXgt/vx+/3U1tbC4DZbE5VanI6nVJ6WwghhBBCiHEsrugJYEV1TYb8/J4PAG34tms7VR+Kx9ICUMm5JzPolFxXcUTuti0uiIYSQ6WFIN6Xu9O7CaV0F+wZjYYsxJSjEq/OkBhqz6gFi0xWLZhksiXmVrCVZD8WYPYZUDS947jkMcm2DHn9q3jkmqhNQohRTVVVotFo1mrfiqL0qQq41WrNOC8llS2EEKNROBzG4XCg1+tRFAVdP77nGGfOxHbllQRffbXboeX0EydiOe20MRlgAnjjjTf4+c9/zpIlS/jyl7/M4YcfTklJCYFAgK1bt/LQQw+lhnm75pprMBg6LgMed9xxvPnmm6xZs4Y777yTL33pS9hsWgXQvLy8VKW+yy+/nB/+8IfU1tZy7LHHcssttzB37lyCwSD//ve/+fWvf00oFOKoo44atCHljjvuuNTyd7/7XW677TYqKipS11Kqq6szXosQQgghxi/5iy9EFoqiYLXmvvO1L3e7hUIhGhsbaWxsBLTA1NSpUzPuLBBCCCGEEEKIDDo9WJzaNBDXf5j5OB7XwkyxsFZNKRbKDDkl18XC4OpmyL1F14KvsesxqeWINkxeNuWH5W53wkJtWLP+qDwq97bJi9OCRYlwUWpuzLI+bTmvIHe7x38XjvlWZjs648CHVCucqk1CiINCLBZLVfpua2vD4/FQUFDAoYcemnV/p9NJS0tLl/WKomC32zNCS30JPAkhxEiJRCIYDAb0ev2A2jFUVWG/+mpi9fWEP/qIWEMDaiiEYjajLyvDNH8++vLyQer1yInH47z11lupikvZnH322dxxxx0Z65YtW8aDDz6I2+3m1ltv5dZbb01tO+GEE1i1ahUAN954I//617947bXX2Lp1K9dcc01GO3l5eaxYsYKVK1cOWohp+vTpXHjhhfz5z3/mtdde47XXXsvYvmvXLqqrqwfluYQQQggxukmISYh+cLlcLF68OHVyqa2tDa/XSzwe7/HYaDTa7R0DsVhswD/WhBBCCCGEECIrnQ50edrwYwOx6NrB6U9nJ/1oaNo98lJtGmx5rsFvUwgx7kUikdT5pLa2Nnw+X5ehkzweT5fhlZKcTi3gqtfryc/PTwWWklVMhBDiYKcvLyfvy18e6W4MiR/84AccfvjhvP7666xbt47a2trUDdTl5eUsWrSIyy+/nC9nef1VVVV8+OGH3HHHHbz11lvs37+fYDDYZT+j0cjKlSt58MEHWbFiBRs3bkRVVaqqqjjllFO48cYbmT17NitXrhzU1/bkk0+yYMEC/vKXv7Bly5ZeX3MRQgghxPgyrCGmaDTKypUrWb16NTt37sTr9RKLxbo9RlEU3njjjWHqoRC9ZzAYKCwsTI0HHY/H8TgcSFQAANpbSURBVHq9qTvm2traiOYYfzt5sqmzSCTCe++9h8PhoLCwkKKiIux2uww/J4QQQgghhBBCCDFGqaqKx+OhubkZt9uN3+/v8ZhwOEwwGCQvr2voND8/n6OOOkrOGQkhxEHIbrdz7rnncu655/br+GnTpvHoo4/2uJ/BYOA73/kO3/nOd3Lus3z5cpYvX551W3V1dZeAbk+MRiM//OEP+eEPf9in44QQQggxvgxbiOmtt97iyiuvZO/eval13X2BURQl591GQoxGOp0udecbaO/v9vb2jDvrQqEQeXl5mEymrG20tbUB4PV68Xq97NmzB5PJlApLFRQUyLjPQgghhBBCCCGEEGOAx+OhpqYGt9ud80a37ni93qwhJp1Oh8PhGIwuCiGEEEIIIYQQo8qwpCHWr1/P6aefTjgcRlVVLBYLM2bMwOVyodPphqMLQgw7RVGw2WzYbDYqKysBCAaDhMPhnMckQ0zpwuEw9fX11NfXoygKTqczVaUpLy9Pgn5CCCGEEEIIIYQQo1AkEkkN8dMbDocjY3i4XDfBCSGEEEIIIYQQ49WwhJhuv/12QqEQZrOZX/3qV1x11VVYLJbheGohRhWLxdLte9/r9XZ7vKqqtLa20trays6dO7FYLBQVFVFYWCihQCGEEEIIIYQQQohhFIvFaGlpwel0YjQau2xPnquJx+Ndtul0uozAUn5+Pnq9fji6LYQQo5aqqqlJPhOFEEIIIQ5OwxJieuedd1AUhdtuu41ly5YNx1MKMSYdfvjhtLW10dzcjNvtJhAIdLt/MBikpqaGmpoa8vLyWLhwoVRmEkIIIYQQQgghhBgigUAAt9tNc3Mzra2tqKrK7NmzKSsr67KvXq/H5XLhdrsBsNlsqeraDodDbkYTQogEvV5Pe3t76rGiKNjt9hHskRBCCCGEGCnDEmIKBoMAnH766cPxdEKMWTqdjoKCAgoKCgBob29PnRhra2tDVdWcxzqdTgkwCSGEEEIIIYQQQgyieDxOW1sbbrcbt9udcZE9ye12Zw0xAVRVVaWqaEtleiGE6J1kNSY53y2EEEIIcfAZlhBTdXU1mzZtIhKJDMfTCTFuWK1WrFYrEyZMIBqN0tramqrSFA6HM/YtLCzM2c7GjRtRFCV10sxgGJb/9YUQQgghhBBCCCHGnHA4nLqprKWlhVgs1u3+brc758X27s7XCCGE0HR3864QQgghhDi4DEuS4atf/SqbNm3i7bff5thjjx2OpxRi3DEYDBQXF1NcXIyqqvh8vtQJNZ/Pl6re1Fk0GqWpqQlVVWlsbAS0qk3J8uVWq1XuaBFCCCGEEEIIIcRBzefz0dTUhNvtxuv19ulYm81GOBzGbDYPUe+EEGJ8yxZikkpMQgghhBAHp2EJMd14440sX76cu+++m4suuojq6urheFohxi1FUXA4HDgcDiZPnkw0Gs1ZXamlpaXLj8C2tjba2trYtWsXZrM5VaHJ5XKh1+uH4yUIIYQQQgghhBBCjBoNDQ3s37+/V/sajUYKCwtTk1S8FkKIgckVYhJCCCGEEAefYfmFXVJSwksvvcSZZ57J0UcfzS9+8QsuvPBCnE7ncDy9EONedyfL3G53t8eGQiFqa2upra1Fp9PhcrkoKiqiqKhI7iAUQgghhBBCCCHEuBEKhXKe6ygsLOw2xGS321NVrR0Oh1QHEUKIQaYoSkZwSUJMQgghhBAHp2G7Tejwww/n7bff5uijj+ab3/wmy5Yto7i4GKvV2u1xiqKwY8eOYeqlEOPP5MmTsdvtuN3urFWZ0sXjcdxuN263m23btuFyuZg9e7aEmYQQQgghhBBCCDEmhcNhDhw4QENDA16vl2OOOSbreQ6n04lerycWiwGg1+spKChIVVuScyNCCDG8JMQkhBBCCHFwGrYQ01//+leuueYavF4vqqqiqiqNjY09Hid3NQkxMBaLhaqqKqqqqojFYrS0tKSCSqFQqNtj/X4/JpNpmHoqhBBCCCGEEEIIMXCxWIzm5mYaGhq63NDldrupqKjocoxOp6OiogJVVSkqKsLpdKLT6Yaz20IIcVCTSkxCCCGEEAKGKcT0/vvvc/HFF6fuZJo8eTKHH344LpdLTgYIMYz0ej3FxcUUFxejqip+vx+3201zczMej6fL/qWlpTmDhJFIBIPBIEFDIYQQQgghhBBCjDhVVWlpaaGhoYGmpibi8XjW/Zqbm7OGmACmTZs2lF0UQgjRjc7nmSXEJIQQQghxcBqWENMvfvELYrEYTqeTp556ijPOOGM4nlYI0Q1FUbDb7djtdiZNmkQkEklVaGpubiYWi1FaWprz+M2bN+P3+ykrK6O0tBSbzTaMvRdCCCGEEEIIIcTBTlVVvF4vjY2NNDY2EolEejzG7/ejqqrclCWEEKOMhJiEEEIIIQQMU4hp7dq1KIrCz372MwkwCTFKGY1GysrKKCsrSw0753A4su4bDodxu90A7N27l71792K32yktLaW0tBSz2TycXRdCCCGEEEIIIcRBJBAI0NDQQGNjI4FAoMf9dTodRUVFlJWVUVBQIAEmIYQYhSTEJIQQQgghYJhCTO3t7QAcf/zxw/F0QogBSg47l8uBAwe6rPP5fPh8Pnbu3InL5aKsrIzi4mIMhmH5mBFCCCGEEEIIIcRBoqamhpqamh73KygooLS0VM5PCCHEGCQhJiGEEEKIg9Ow/HqfMmUKn3/+eSrMJIQY2zweT7fbW1tbaW1tZevWrak7HQsLC9HpdMPUQyGEEEIIIYQQQoxXpaWlOUNMDocjVSnaZDINc8+EEEL0l1RiEkIIIYQQMEwhpnPPPZfPPvuMV199VaoxCTEOzJ49m4kTJ6ZKt4fD4az7qapKU1MTTU1NGAwGSkpKKC0txel0Sul2IYQQQgghhBBCdKGqKi0tLTQ0NDBt2rSsQSSHw0FeXl5qKDmLxUJZWRmlpaVYrdbh7rIQQohB0Pl8cTweR1VVOY8shBBCCHGQGZYQ0/e//32efvppfv3rX3P22WezYMGC4XhaIcQQURQFu92O3W5n6tSptLa20tjYyIEDB4jFYlmPiUaj1NXV0dLSwqJFi4a5x0IIIYQQQgghhBitVFXF6/XS2NhIY2MjkUgE0MJKEyZM6LK/oihUVlYSCAQoKyvD4XDIRW4hhBjjslXxj8fj6PX6EeiNEEIIIYQYKcMSYnI4HLzxxhtccMEFLF26lO9+97tcdNFFzJw5E4vFMhxdEEIMEUVRKCgooKCggOnTp+N2u2loaMDtdmct+VtaWionFoUQQgghhBBCCEF7e3squJSsqpSusbExa4gJyLleCCHE2KQoCkajEUVR0Ov16PV6OY8shBBCCJGF1+tFURRsNtu4/L7UNdo+BPR6PZMnT+bDDz8kGAxy5513cuSRR2Kz2VJfRnNNBsOw5KyEEINAr9dTUlLC3LlzOfbYY5kxYwZOpzNjn9LS0pzHb9++nbq6OqLR6FB3VQghhBBCCCGEECPAaDTS2NjIxx9/zJo1a9izZ0/WABNoJ2bb29uHuYdCCCFGisViwWw2YzAYxuUFucG2d+9errvuOqZNm4bFYkFRFBRF4YUXXuDKK69EURSqq6uH7PlXrVqVes5Vq1YNWru7d+9Otbt8+fJBa1cIIYQYL3bv3s1HH33Eu+++y4YNG3C73SPdpUE1LAmhztVYslVnEUKML0ajkcrKSiorKwkGgzQ2NuLz+bDZbFn3DwaD1NTUALBt2zaKioooLy+nsLBQfrAKIYQQQgghhBBjWDwep6WlhdmzZ+N0OlO//7vjcDgoLS3FaDQOQw+FEEKIsWXv3r3Mnz+fpqamke6KEEIIIYaRqqp4PB4AYrEYbrebsrKycVUcaFheyU9/+tPheBohxChlsViYNGlSt/s0NDSkllVVpampiaamJvLy8qisrKS8vHxcffgKIYQQQgghhBAHg6amJrZt20Y4HMblcnW7b15eHqWlpZSWlmK1Woeng0IIIcQY9Itf/IKmpiYMBgO//OUvWbp0KXa7HYDJkyfzwgsvjGwHhRBCCDEk/H5/l1GNnE4noVBohHo0+CTEJIQYcaqq0tjYmHVbIBBgx44d7Nq1i/LyciorK3NWcxJCCCGEEEIIIcToYjQaCYfD3W5PBpccDodUYxZCCCF64fXXXwfgq1/9KjfffHOX7cuXLx/yodhOPPFEGXlFCCGEGGZtbW0Zj5PD8UqIaZisW7eOFStWcO+99450V4QQQ6y6upqGhgbcbnfWHz7xeJza2lpqa2txuVxUVVVRVFQkJzeFEEIIIYQQQohRLD8/H7vdjs/nS63T6XQUFxdTVlZGQUGB/LYXQggxqBo/+YRPfv97DqxfT9jrxeRwUDJvHkdcdx2lRxwx0t0bFMmhWWfOnDnCPRFCCCHEcOocYnI6nSPUk6Ez6kJMdXV1PPnkkzzxxBN8/vnnABJiEmKcUxSFkpISSkpKiEQiHDhwgNraWvx+f9b9W1tbaW1txWKxpIaaMxqNw9xrIYQQQgghhBBChEIh6urqsFqtlJaWdtmuKApVVVVs2bIFr9dLQ0MD5557LgUFBSPQWyGEEGOBqqrE43FisRjxeByz2dyrwGvdmjW8edNN1L73Xpdtte+/zycPPkjV4sWceO+9VCxcOBRdHzbJKodyXlwIIYQ4eKiqelCEmHQj3QHQhot66qmnOO2005g0aRL/5//8Hz7//HMpQynEQchoNFJZWcn8+fM54ogjKC4uzrlvMBhk586d7N27dxh7KIQQQgghhBBCHNySJ043btzIf/7zH/bs2cPevXtznssrLS1l1qxZfP755zQ1NaHX64e5x0IIIcaKeDyO3++nvb2dUChEJBIhHo/3eNyOlSt5dunSrAGmdDXvvsuzS5eyY+XKwerysFm+fDmKomQEun72s5+l1imKwpVXXgnAlVdeiaIoVFdXZ20ruf/tt98OwJo1a7jkkkuYMGECZrOZqqoqLrvsMjZt2pSzP6tWrUq1s2rVqqz7bN26le985zvMnTsXh8OByWSisrKSefPmcfXVV/Pss8/2avibf/3rX5x11lmUl5djNpuZMmUKy5YtY//+/T0eK4QQQowXwWCwy3Dt4zHENKKVmN58801WrFjB3/72t1RJ6eTJjoqKCs455xzOO++8keyiEGKEKIqCy+XC5XIRDAapra2lrq6OaDTaZd/KysoR6KEQQgghhBBCCHFwicfjNDY2UlNTkzE8HIDf76etrQ2Xy9XlOJ1Oh9VqHaZeCiGEGMt0uq733sdisW4DsHVr1vDi+ecTDQZ79RzRYJAXzz+fi95+e8xXZBoMv/vd77jxxhszzr3X1tby5JNP8re//Y2XX36ZpUuX9rnd5557jq997WtdLrbW1dVRV1fHJ598wuOPP86GDRuYO3duznZuvfVW7rzzzox1u3fv5qGHHuKvf/0rb731FnPmzOlz/4QQQoixprW1NeOx0WgkLy9vZDozhIY9xLR582ZWrFjBU089lUpIJ4NLEyZM4LzzzuP888/nuOOO61V5UCHE+GexWJg6dSrV1dVdTpYWFhbm/HCORqOoqioldYUQQgghhBBCiAFI3lxUX19PJBLJuV9tbW3WEJMQQgjRF3q9PiNQE4vFut3/zZtu6nWAKSkaDLLqu9/lknfe6VcfR8JXv/pVFixYAMBhhx0GwLJly/jWt76V2qevw7W++uqrfPjhhxx22GHceOONHHbYYQQCAZ5//nl+85vf0N7ezmWXXca2bdswmUy9brehoYGrrrqKcDhMaWkp119/PccccwzFxcUEAgG2b9/OW2+9xQsvvNBtO4888gjvvfceJ5xwAtdddx0zZ86ktbWVFStWsGLFCg4cOMDVV1/N+++/36fXLYQQQoxFnYeSc7lc4zJTMywhpubmZp5++mlWrFjBRx99BHQEl1wuF62trSiKwt13382FF144HF0SQoxBOp2O8vJyysrK8Hg81NTUUFFRkXP/mpoa9uzZQ2lpKVVVVTgcjmHsrRBCCCGEEEIIMXYlh4yrqamhqamp2311Ol3qt7cQQgjRmRqPE2hu7rI+FosRTKxvV5RUtaVwOJxRvUcB4jZb1ot0TRs29DiEXC41777L3jffpLibKkD9lVdUhJKlqtRAJEcuSFdaWtptFaOefPDBB5xxxhk8//zzGSGlJUuWUFRUxI9//GP27t3LypUrOeecc3rd7sqVK/H7/QC88cYbXfp43HHHcfnll3P//fd32857773Htddey+9///uM//4nn3wyJpOJRx99lA8++IB169Zx5JFH9rp/QgghxFjUOcQ0HoeSgyEMMUUiEV588UVWrFjBK6+8QiQSSQWXTCYTZ5xxBl/72tf48pe/PC5LXAkhho6iKDidzm4/mOPxOLW1taiqSkNDAw0NDeTn51NVVUVxcXHWssRCCCGEEEIIIcTBLhaLpaogJy8+5mKxWKisrKS8vFyqIAshhMgp0NzM70pLR7obWf35C18Ykna/1diItaRkSNoeTBaLhccffzxrlaUbbriB//7v/yYcDrN69eo+hZjq6+sBrTJUdyGrnq4PVlRU8Nvf/jZrgO0HP/gBjz76KACrV6+WEJMQQohxLRQKEexUeVJCTL30wQcfsGLFCv785z/T0tICaHduKYrC4sWL+drXvsaFF17Y55KWQgjRF01NTV3G2vZ4PHg8HkwmE5WVlVRUVPSpBK4QQgghhBBCCDHebdiwocvdnZ25XC6qqqooKioal6XrhRBCiIPFF7/4RUpzBMwcDgczZszg888/Z+fOnX1qNzmCQktLC3//+985++yz+9W/888/H7PZnHXbrFmzsNvt+Hy+PvdPCCGEGGs6/07X6/XYbLYR6s3QGvQQ03HHHYeiKKmqS7NmzeJrX/sal156KdXV1YP9dEIIkVUwGMz4LEoXDofZvXs3e/bsoaSkhKqqKvLz80egl0IIIYQQQgghxOhSVlaWNcSUHOK9srJy3J4oFUIIIQ42s2fP7nZ7YWEhAF6vt0/tfuUrX8HlctHa2so555zDiSeeyFlnncXSpUuZN29eaujAgfavoKAAn8/X5/4JIYQQY022oeTG601FQzacnMPh4L777uOKK64YqqcQQoicJk2aRHl5OXV1ddTW1napygRalbjGxkYaGxtxOBxUVVVRMgZK/AohhBBCCCGEEAMRi8VyXjwsLS1l586dRKNRQBtmpqqqivLycgyGITuVKIQQQogRYLVau92u0+kA7btDXxQVFfGPf/yDSy65hJqaGt58803efPNNAPLz8zn55JO5+uqrOfPMM0ekf0IIIcRYky3ENF4NyZkHVVXx+XxcffXV/OY3v+FrX/sal1xySap8pBBCDAeTycTkyZOZOHEiTU1N1NTU4PF4su7r9XrZvHkzO3bsoKioaJh7KoQQQgghhBBCDL1AIEBNTQ319fUcfvjhWasS6/V6ysvL8fv9VFVVUVhYOG7v7hRCCDE88oqK+FZjY5f1sViMpqYmAIqLizMCtrFYjEAgkLG/1WpNhVaS3rr5Zj5fvrzffZt71VUs/d//7ffxueTJOWaWLFnC9u3b+etf/8pLL73E22+/zf79+/F4PDz//PM8//zznHbaafztb3/rMawkhBBCHMxUVcVsNhMMBlPBXQkx9cGqVatYvnw5f/3rX/F6vaxfv55PPvmEW265hRNPPJHLLruMc889F7vdPthPLYQQWel0OkpLSyktLcXr9VJbW0tDQ0PWoeYikQh+v38EeimEEEIIIYQQQgw+VVVpbW1l//79uN3u1PqampqcQ6tPnTpVgktCCCEGjaLTYc1SAT8Wi2FJnKO1lpRkhJhUVQWfL2N/s8WC0WjMWDf/xhsHFGI66sYbs/ZNDA6LxcKll17KpZdeCsCuXbtYuXIlv/3tb9m6dSuvvvoqt912G/fee+8I91QIIYQYvRRF4bDDDksVE2pra8PhcIx0t4aMrudd+mbp0qU89thjNDQ08NRTT3Haaaeh0+mIxWL8+9//5qqrrqK8vJxLLrmEl156SUo8CiGGlcPhYNasWRx77LFMmTIFs9ncZR8ZUk4IIYQQ/5+9Ow+O/K7v/P/6drf6kNRq3fd9jY65D4OxiU0CJLFjiJ1acMwSXFwmIQXeJZiqrdoNqc0PB0OFK6HWLryYEEOA5SgIbDCQsTcYYzyjOXXf93227j6+vz8m6kxPS5pL0rclPR9VU9X9+Xz1/b7G/o5a+n7f3/cHAIDdzjRNTU9P68KFC7p48WJUAZMkjY+Pr7v0uiQKmAAAljMMI2bp0/XuJ2UfPar8N7zhlo5RcNddyj5y5Ja+FremrKxMf/7nf67XXntNhYWFkqRvf/vbFqcCAGB3MAxDXq9XhYWFMd0p95Jt+5u53W798R//sf7v//2/6u/v11NPPRWpDltcXNS3v/1tPfDAAywxB8ASCQkJKi4u1ute9zrV1dVFWu653e4Nn0SVRJcmAAAAAEBcu7Z4aXZ2dtPtAACIVzdSxCRJb/r85+Vwu29q3w6PR/fS/ccyKSkpOnXqlCRFlhQEAACQtrGI6Wq5ubn6i7/4C50/f17nzp3T448/ruzsbJmmqYmJicjTXf/1v/5XffSjH9W//du/7UQsAJBhGMrKytLRo0d14sQJVVdXb/jE6czMjM6cOaNLly5pbm5uh5MCAAAAALCxtaKk8+fPb1q8ZLfbVVhYqDvuuEM5OTk7nBIAgBt3bRFTOBy+sszcNfJOndID/+f/3HAhk8Pj0QPf+Y7y/r2IBlvvpz/9qYaHhzecn52d1W9+8xtJV7ozAQAArNnxHlNHjhzR3/7t32pgYED//M//rHe84x1yuVwyTVNDQ0P6u7/7O917773Ky8vTn/3Zn+kXv/jFTkcEsE8lJycrLS1tw/menh5J0tTUlM6dO0cxEwAAAADActcWL230e6rL5VJlZaXuvPNOVVRUyOPx7HBSAABuzrVFTNLG3Zgq7r9f7/x//08Fd9216T4L7rpL73zpJVXcf/+WZMT6vvnNb6qkpET333+/vvCFL+gXv/iFzp07p//3//6fvvzlL+vOO+/U4OCgJOlDH/qQxWkBAEA8cVh1YLvdrvvuu0/33Xef5ubm9K1vfUtf//rX9fLLL8s0TY2Ojurpp5/WM888o2AwaFVMAJB0pQvTtU+xTk1NaWpqSunp6SopKdl0GToAAAAAALaaaZq6cOHChl2XpCvFS8XFxcrNzZXNtuPPMwIAcMsMw5DdblcoFJLdbpfdbt+wi750pSPTH//ylxq7cEEXn3lGY+fPa9Xvl9PrVfbRozr8wQ8q+8iRHfwb7G+BQEA/+clP9JOf/GTDbT70oQ/pIx/5yA6mAgAA8c6yIqarpaSk6AMf+IA+8IEPqKenR1/72tf0j//4j+rs7LQ6GgBIklZXV5WQkKBAIBAzRzETAAAAAMAKhmHI4/GsW8RE8RIAYC9wu90yDGPT4qVrZR85ojf//d9vYypcz+c+9zm95S1v0b/+67/q4sWLGh4e1vj4uOx2u4qKinTnnXfq/e9/v+6++26rowIAENeamppkmqZ8Pp98Pp+Sk5Nv6uei3SguipiuVlpaqr/8y7/UX/7lX+rll1/W17/+dasjAYCys7OVkZGhoaEh9ff3b1rMlJaWptLSUoqZAAAAAADbrri4WKOjozJNUxLFSwCAvYXPsvWtfe5v5LnnntNzzz13y1+/5sUXX9xw7t57791wP2lpaXrXu96ld73rXTd0nKuVlpbecL6enp6b3j8AALtFOBzW5OSkwuGwJiYmJEn19fXKzMy0ONn2irsipqvddddduus66xcDwE5Ze0okPz9/02Km6elpTU9PKy0tTSUlJfL5fBakBQAAAADsBaZpanp6Wj6fT3a7PWbe4/EoJydH09PTKikpUU5ODjd8AQAAAADY5fx+v8LhcNTYfrjvHNdFTAAQj262mCkrK0t1dXUWJAUAAAAA7FZrxUs9PT3y+/2qqKhQYWHhuttWVFTIZrNRvAQAAAAAwB5x7dLxSUlJSkhIsCjNzqGICQBu0Y0WMyUlJVmQDgAAAACwG11bvLSmr69PeXl563Zjcji4xAcAAAAAwF5ybRHTfujCJFHEBAC3bbNiJofDoYKCAosTAgAAAADinWmampqaUm9vb1Tx0ppAIKDh4eENuzEBALAfmKYp0zRlGIYMw7A6DgAAwLYwTZMiJgDA7bm6mGl4eFh9fX0qKCjY8InY1dVVLS0t7ZsPHAAAAABArOsVL61xu91yOp07mAwAgPhgmqYCgYBCoZBCoZBM01RiYuK63QkBAAD2goWFBYVCoaix/XJPmSImANhidrtdhYWFysvL23S7vr4+DQ4OKjU1VaWlpfvmgwcAAAAAcHPFSyUlJcrOzpbNZtvBhAAAxAfDMBQIBBQOhyNjoVCIIiYAALBnXduFye12y+VyWZRmZ1HEBADbZLNfoldWVjQ8PCxJmpmZ0fnz55WamqqSkhKlpqbuUEIAAAAAwE6jeAkAgJtnt9tjipgAAAD2qv26lJxEERMAWKK/vz/ql27pSjHTzMwMxUwAAAAAsIe1tbVpZGRkw/m14qWcnBwZhrGDyQAAiF92u12BQCDyfm1ZOT4rAQDAXmOapmZmZqLGKGICAGyrxMREOZ1Ora6uxsxRzAQAAAAAe1dmZua6RUwej0fFxcUULwEAsI5ru96bpqlwOMyScgAAYM9ZWlqKKt6WKGICAGyz/Px85ebmanh4WH19fZsWM6WlpamiokJJSUkWJAUAAAAAbKX09HQlJydrfn5eEsVLAADcCJvNJsMwZJpmZCwUClHEBAAA9pxrl5JzOp3yeDwWpdl5FDEBgEVsNpsKCgqUl5e3aTHT9PS0zpw5o4KCApWUlCghIcGCtAAAAACAG7WysiLTNOV2u2PmDMNQaWmpOjs7VVJSouzsbIqXAAC4AXa7XcFgMPI+FApZmAbYP64uHgQAbL9ri5h8Pt++um5AERMAWOxGi5kGBwc1Ojqq6upqZWVlWZAUAAAAALCZUCik/v5+9ff3Ky0tTQcPHlx3u/T0dKWnp++ri5AAgL1prbAoGAxue2ek9YqYTNPk8xTYRqFQKFIwSOczANgZ6xUx7ScUMQFAnLiRYqZgMEgnJgAAAACIM6ZpamxsTN3d3VpZWZEkTU5OampqSunp6THbc7MVALBXJCYmRj77ZmZmlJGRsW3HuraAwjRNipiAbTYzMxN5nZiYaF0QANgnVlZWtLy8HDVGERMAwFJrxUy5ubnq6+tTf39/pF1rZmamUlNTrQ0IAAAAAIiYm5tTR0eH/H5/zFxXV5fS0tK4uQoA2LNSU1M1PT0tSRobG1MoFFJKSopcLteWf/7ZbDYZhhG1tFUoFJLNZtvS4wD7nWmaWllZ0dzcnCYnJyPjaWlpFqYCgP0hISFBR48e1ezsrGZnZ7W4uKikpCSrY+0oipi20eLiov7u7/5O3/nOd9TZ2amVlRUVFRXp/vvv10c+8hGVlJTc1v7D4bB++ctf6l/+5V/0q1/9Si0tLZqampLb7VZxcbF+67d+Sx/60Id0+PDhTffzyU9+Un/1V391Q8c8ffq07r333tvKDeDG2O12lZWVKS8vT11dXZqYmFB5ebnVsQAAAAAAuvJ0ZFdXl8bGxjbcJiUlReFwmKU3AAB7ltvtls/niyx7Mjk5qcnJSRmGcd3PP9M0I53o/X7/DRU9hcNhhcPhyHubzUYRE6LcynmFaGtLNV7N5/PJ5XJZlAgA9g+bzSafzxfpvrQfu05SxLRNOjo6dN9996m9vT1qvLW1Va2trfrKV76i559/Xn/wB39wy8coLS1Vf39/zHggEFBjY6MaGxv19NNP6y/+4i/0N3/zN/vu5Ab2Crfbrbq6Oi0vL8vtdq+7jWmaunTpkjIyMpSXl8cv7gAAAACwTUKhkPr7+9Xf3x91E/VqqampqqioUHJy8g6nAwBg5+Xl5cnpdGp8fDwyZpqmgsHgpl8XDoc1Pz8vSfJ6vTd0TTMYDEbt1zAMCisQ5VbOK2wuKytrW5eKBABsbD/WeFDEtA38fr/uv//+SAHTBz7wAT388MPyeDw6ffq0nnzySc3Nzemd73ynXn75ZR09evSWjjM0NCRJqqys1B/90R/prrvuUn5+vpaWlnT69Gl97nOf0/T0tJ566inZ7XZ96lOfuu4+L126tOl8WVnZLWUFcPs2KmCSrrRqnp6e1vT0tIaGhlRRUaH09PQdTAcAAAAAe5tpmhobG1N3d7dWVlbW3cbtdquiokIZGRn78kIjAGB/MgxDmZmZSklJ0fz8vBYWFrS6urphse+aYDAY6eDk8/nkcNzYLavFxcWo9x6Ph0IVRNzqeYX/YLPZ5HQ6lZSUpOTkZDmdTqsjAQD2ET65t8FnPvMZtbW1SZKeeuopffzjH4/M3Xnnnbr33nt1zz33aHFxUY8//rhefPHFWzrOHXfcob/8y7/UW9/61pgLY3fffbceeeQR3XnnnRofH9dnPvMZvf/977/uUlQHDx68pSwArBMKhdTV1RV5v7i4qEuXLik9PV0VFRVKTEy0MB0AAAAA7H5zc3Pq6OiQ3+9fd95ut6ukpEQFBQXcRAUA7FtOp1Pp6ek3/HDl3NycfvjDH0q6cu8kJSXlul9jmqZefvllhUKhyFhaWpqys7NvLTT2nFs5rwAAQPzgqsoWCwQC+uIXvyhJqq2t1cc+9rGYbd7whjfofe97nyTppZde0muvvXZLx/rVr36l3/3d393wyb6Kigr9j//xPyRdqTz/wQ9+cEvHARDfJicnI2t8X21qakpnzpxRR0eHAoGABckAAAAAYPcLBoO6cOHChgVMeXl5uuOOO1RUVEQBEwAA28wwDPl8vqj3G3VIBAAAwO7DlZUtdvr06Uibyve85z0bXrx69NFHI6+///3vb1ueN73pTZHXnZ2d23YcANbJzs7WkSNHlJycHDNnmqYGBwf1m9/8RoODgzJN04KEAAAAALB7ORwOFRUVxYynpqbqxIkTqq6uZokNAAB2UE5OjkpLS3XkyBHddddd635OAwAA7CamaaqtrU2Tk5P7/n4uy8ltsV/+8peR1/fcc8+G2508eVKJiYlaXFzUyy+/vG15rn4CwW63b9txAFgrNTVVx48f1+joqLq7u2M6MwWDQXV0dGhoaEgVFRU33NIZAAAAACAVFRVpZGREKysrcrvdqqioUEZGxobdsQEAwPZh6TgAALDXzMzMaHh4WMPDw3K73crPz9+3S9bvv7/xNmtqaoq8rqmp2XA7h8OhyspKSVJzc/O25XnppZcir2tra6+7/Vvf+lZlZ2fL6XQqOztb9957r/7mb/5G09PT25YRwNYwDEO5ubk6deqUiouL172Yvri4qEuXLunSpUtaXFy0ICUAAAAAxKe5uTkFg8F15+x2uyoqKlReXq5Tp04pMzOTAiYAAAAAALAlhoaGIq+Xl5c1MjKyb6870Ilpiw0MDEiSkpKSlJqauum2RUVFunjxosbHx7WysiKXy7WlWRYXF/X5z39ekuRyufT2t7/9ul/zs5/9LPJ6fHxcL730kl566SV9+tOf1nPPPXdD+1jP2n+XjQwPD0deLywsaG5u7paOA2yF+fn5dV/vJhkZGUpOTtbQ0JBmZmZi5qempjQ1NaXc3Fzl5eXtfEDclL1wTmLv4HxEPOF8RLzhnEQ84Xy8caurqxoaGtL09LSys7NVUFCw7nYul0sul4v/nreIcxLxZGFhweoIAAAAACDpyupaExMTUWP5+fkUMWFr+P1+SVJycvJ1t01KSoq8np+f3/Iipk984hPq6+uTJH34wx9Wfn7+htseOnRIf/iHf6g77rhD+fn5CgQCam1t1fPPP68XXnhBMzMz+qM/+iP96Ec/0u///u/fdJabWZP6e9/7nnw+300fA9gOX//6162OcNu8Xq9KSkrW/b708ssva3x83IJUuFV74ZzE3sH5iHjC+Yh4wzmJeML5uD6bzaa8vDzl5+fLbrdLkkZGRvTCCy9oeXnZ4nR7G+ckrDY7O2t1BAAAAACQFN3wRbpyvSInJ8eiNNajiGmLrV3kcjqd19326qKlpaWlLc3x/PPP6+/+7u8kXVlG7q//+q833Pbxxx/XJz/5yZjx173udfqTP/kTPf300/rQhz6kUCik97///ers7JTb7d7SvAC2j9/v1+XLl5WVlaWioqLI96eFhQUKmAAAAADsSxkZGSouLo55oMxms6m4uFhtbW0WJQMAALdqfn5eiYmJstlsVkcBAAC4IeFwOKaIKScnRw7H/i3l2bd/861ovfXVr35Vjz76aNTYWnHP6urqdb9+ZWUl8trj8dx2njUvvvii3ve+90mS0tPT9d3vfnfT/V9v2bvHHntMr732mp599lkNDQ3pu9/9rt71rnfdVKb+/v5N54eHh3XHHXdIkh566CFVV1ff1P6BrTQ/Px95KvTd7373DXVW2y1CoZBGR0c1NjamI0eO6O677153O9M0922Lwni0l89J7D6cj4gnnI+IN5yTiCecj+tbWFjQ4ODghktJ2Ww2HTx4UL/927/N70RbjHMS8aStrU1PPvmk1TEAbIFwOKzx8XENDQ1pbm5ONTU1+7pzAQAA2F0mJydjaks2W2FrP9i3RUzbxev1SrpyYeZ6rr5gtlUXbs6cOaO3ve1tWllZUXJysn7yk5+otrb2tvf72GOP6dlnn5UkvfTSSzddxFRYWHjD2yYlJSklJeWm9g9sl+Tk5D13Pqalpam8vHzTjnEtLS1yOBwqKSlRQkLCDqbD9ezFcxK7F+cj4gnnI+IN5yTiCefjlQfJuru7NTo6uuE2eXl5Ki0tvaHu2rg9nJOwWlJSktURAGyR5uZmTUxMRN4PDQ1RxAQAAHaNoaGhqPcpKSn7/qGffVvE1NzcfNv7yMvLixkrLCzUq6++qoWFBc3MzGza5WitO1FWVlZM+/Jb0djYqN/7vd+T3++Xy+XSD37wA73uda+77f1KUl1dXeT14ODgluwTgHU2uyg/OzsbubA/Ojqq0tJS5efn8xQyAAAAgF0nFAppYGBAfX19CofD626TmpqqioqKfX+REACA3Sg7OzuqiGlubk5+vz/ywDkAAEC8Wqspudp+78Ik7eMippqamm3Zb11dnb773e9KutLJ5PWvf/262wWDQXV2dkrSlnRK6uzs1Fve8hZNTk7K4XDoW9/6ln7nd37ntve7huIFYH8wTTPyvUm68r2qo6NDIyMjqq6u5pd/AAAAALvG9PS02tratLy8vO682+1WRUWFMjIyuO4BAMAulZmZKafTGbUMy/DwMNcxAQBA3BseHo56n5CQoKysLIvSxA+b1QH2mrvvvjvy+qWXXtpwuzNnzkSWk7vrrrtu65gDAwN685vfrOHhYdlsNn3ta1/T29/+9tva57Wampoir6n+A/auhYWFdZfDnJ+fV0NDg7q6uhQKhSxIBgAAAAA3zu/36+LFi+sWMNntdpWXl+vUqVPKzMykgAkAgF3MMIyYVTNGR0cVDAYtSgQAAHB9oVBIIyMjUWO5ubmy2Sjh4b/AFrv33nvl8/kkSV/72tdkmua62z333HOR1w8++OAtH29sbExvfvOb1dPTI0n6X//rf+mRRx655f1t5Omnn468vueee7Z8/wDiQ3Jysk6dOrVhlW9/f7/OnDmj6enpHU4GAAAAADfO6/UqMzMzZjwvL0933HGHioqKuDAIAMAekZeXF1WUHA6HY24KAgAAxJPR0dGYxhE0k7mCqzVbzOl06iMf+Ygkqbm5WZ/97GdjtnnllVf07LPPSrpSEHTq1Kl192UYhgzDUGlp6brzMzMz+t3f/V21trZKkj73uc/pAx/4wE3lvXTpkjo6Ojbd5plnntFXvvIVSVeq/26n6ApA/PN4PKqrq9ORI0eUmJgYM7+8vKyLFy+qtbVVgUDAgoQAAAAAcH2VlZWy2+2SpJSUFJ04cULV1dVyOp0WJwMAAFvJ5XLFFC8PDQ1t+JA5AACAlUzT1NDQUNRYenq63G63RYnii8PqAHvRxz/+cX3rW99SW1ubnnjiCXV0dOjhhx+Wx+PR6dOn9alPfUrBYFAej0ef//znb+kYKysruv/++3X+/HlJ0rve9S69+c1v1uXLlzf8mqSkJJWVlUWNnT17Vu9///v1pje9Sb//+7+vQ4cOKSMjQ8FgUC0tLXr++ef1wgsvSLrSbv2ZZ55RUlLSLWUGsLukpqbqxIkT6uvrU19fX8wv/SMjI5qcnFRVVRVLMAAAAACwxNrvKev9PuJyuVRZWalQKKT8/Hx+ZwEAYA/Lz8/X+Ph45P3S0pJmZmaUlpZmYSoAAIBYc3NzWlhYiBqjC9N/oIhpG3i9Xv34xz/Wfffdp/b2dj3zzDN65plnorZJSUnR888/r6NHj97SMYaHh/WrX/0q8v7555/X888/v+nX3HPPPXrxxRdjxkOhkH7+85/r5z//+YZfm5GRoWeffVYPPPDALeUFsDvZbDaVlpYqKytLbW1tmpubi5oPBAJqampSRkaGqqqq5HK5LEoKAAAAYL9ZXFxUa2urCgsLN1wSOzc3d4dTAQAAK/h8PiUmJmpxcTEyNjQ0RBETAACIO6urq3I6nVpdXZUkud1upaenW5wqflDEtE0qKyt17tw5/f3f/72+853vqKOjQ6urqyoqKtJ9992nj370oyopKbE6pu677z49++yzeuWVV3Tu3DmNjo5qcnJSpmkqPT1dR44c0e/93u/p0UcfVUpKitVxAVgkKSlJR48e1dDQkLq7u2PWaJ2cnJTT6VR1dbVFCQEAAADsF+FwWP39/ert7ZVpmmpvb1dqaqoSEhKsjgYAACxiGIby8/PV0dERGZuYmNDKygoPXgIAgLiSlZWljIwMTU5OamhoSOnp6XSPvgpFTNsoKSlJTzzxhJ544olb+vrN1msuLS3dkvWcs7Oz9d73vlfvfe97b3tfAPY2wzBUUFCgjIwMtbe3a2pqKjKXkJAQs1wlAAAAAGy1ubk5tbW1RbVdDwQC6urq0oEDByxMBgAArJaTk6Ouri6Fw+HI2PDwsEpLS60LBQAAsA6bzaasrCxlZWVtSd3HXmKzOgAAYHdxu906ePCgamtrI086V1ZW8tQzAAAAgG0TCoXU0dGhc+fORRUwrZmZmVEwGLQgGQAAiBcOh0M5OTlRY8PDw1FFTQAAAPGGLkzR6MQEALhphmEoOztbaWlpGh0dVVZW1obbBoNBORx83AAAAAC4NVNTU2pra9PKysq684WFhSotLZXdbt/hZAAAIN7k5+dreHg48n51dVWTk5ObXr8EAABA/OCuMgDgliUkJKiwsHDD+dXVVb322mvKyclRWVkZNxUAAAAA3LBAIKDOzk6Njo6uO5+UlKQDBw7I6/XucDIAABCvkpOTlZKSorm5ucjY8PAwRUwAAAC7BEVMAIBt09HRoWAwqMHBQU1OTqqqqkrp6elWxwIAAAAQx0zT1NjYmDo7OxUIBGLmDcNQaWmpCgsLZbPZLEgIAADiWX5+vubm5uTxeJSfn6/c3FyrIwEAgH1udXVV4XBYbrfb6ihxjyImAMC2mJiY0Pj4eOT98vKyLl26pJycHFVUVCghIcHCdAAAAADi0fLystrb2zU1NbXuvM/nU3V1tRITE3c4GQAA2C2ysrLkdDqVmpoqwzCsjgMAAKD+/n4NDAwoPT1d+fn5Sk9P5+eUDVDEBADYFqurqzIMQ6ZpRo2Pjo5qampKFRUVys7O5gMaAAAAgKQrHZiamprk9/tj5ux2uyoqKpSbm8vvEAAAYFM2m01paWlWxwAAAJAkhUIhjYyMSJKmpqY0NTWlkpISlZaWWhssTtFzGwCwLfLz83Xy5En5fL6YuUAgoJaWFl2+fFnLy8sWpAMAAAAQbwzDUEVFRcx4ZmamTp06pby8PAqYAAAAAADArjI+Pq5gMBg1lp2dbVGa+EcREwBg2yQmJurIkSOqrq6W3W6PmZ+amtJrr72mwcHBmI5NAAAAAPYfn8+n/Px8SZLT6VRdXZ3q6+vlcrksTgYAAAAAAHDzhoaGot6npaUpMTHRojTxj+XkAADbyjAM5eXlKT09XR0dHZqYmIiaD4fD6ujo0OjoqA4cOKCkpCSLkgIAAADYKeFwWDbb+s/WlZWVyWazqaSkRA4Hl64AAAAAAMDu5Pf75ff7o8bWHt7C+ujEBADYES6XS/X19aqrq5PT6YyZ9/v9Onv2rHp6ehQOhy1ICAAAAGC7BYNBtbe368KFCxt2Y3U4HKqoqKCACQAAbJn5+Xm1tbWpra3N6igAAGAfubYLk8vlUkZGhkVpdgeuBgEAdlRWVpbS0tLU1dWl4eHhqDnTNNXX16fMzEwlJydblBAAAADAdpicnFR7e7tWVlYkSYODgyosLLQ4FQAA2MsWFhbU1tamubk5SVe6xpeWlq77kCUAAMBWCgQCGhsbixrLy8uTYRgWJdod6MQEANhxDodD1dXVOnLkiDweT9RcUVERBUwAAADAHrK6uqqmpiZdvnw5UsAkSd3d3VpeXrYwGQAA2OucTmfUEi6maWpkZMTCRAAAYL8YHR2NWn3GMAzl5eVZmGh3oIgJAGCZ1NRUnThxQkVFRZIkj8ejkpISi1MBAAAA2AprNwlfe+01jY+Pr7vN/Pz8DqcCAAD7SUJCgrKzs6PGhoaGNlzWFgAAYCuYphmzlFxmZibdIG8Ay8kBACxlt9tVXl6u7OxshcNh2Wzr19eapqlwOCy73b7DCQEAAADcrNXVVbW2tmpqamrd+bS0NFVVVcV0ZgUAANhq+fn5Gh0djbxfWVnR5OSkMjMzLUwFAAD2sunpaS0tLUWN5efnW5Rmd6GICQAQF663hNzQ0JAGBgZUU1Mjn8+3Q6kAAAAA3KyJiQm1tbUpEAjEzDkcDlVUVCgnJ0eGYViQDgAA7Dder1fJyclRHSCHhoYoYgIAANvm2i5MiYmJ3N+8QSwnBwCIewsLC+rq6tLy8rLOnz+v7u7uqDVkAQAAAFgvFAqpra1NjY2N6xYwZWVl6dSpU8rNzaWACQAA7BjDMGI6H6zXHQEAAGArLC8va3JyMmosPz+fayE3iCImAEBcC4fDamlpiSpa6uvr0/nz57W4uGhhMgAAAABr5ubmdPbsWQ0PD8fMOZ1OHTx4UHV1dXI6nRakAwAA+112drYcjujFSa7tkAAAALAVrr02YrfblZOTY1Ga3YciJgBAXAsGg7Lb7THjfr9fZ8+e1dDQkEzTtCAZAAAAAEmamZnRuXPn1u1mkJGRoZMnTyojI8OCZAAAAFesd/NwZGREoVDIokQAAGAvMk1TIyMjUWM5OTkxxdTYGEVMAIC45nQ6deTIEZWVlcW0WQyHw2pvb9fly5e1urpqUUIAAABgf/P5fPJ6vVFjNptN1dXVqq+vV0JCgkXJAAAA/sO1S8oFg0GNj49blAYAAOxFhmHo+PHjKikpiXSjvvZnEGyOIiYAQNwzDEPFxcU6duyYEhMTY+anpqZ05swZTUxMWJAOAAAA2N8Mw1Btba1stiuXmbxer06ePKm8vLyYBxEAAACskpiYqLS0tKgxlpQDAABbzeVyqbS0VK973et0+PBhJSUlWR1pV6GICQCwa3i9Xh0/fnzdiuVAIKDGxka1tbXRBhoAAADYYR6PR1VVVSopKdGxY8fk8XisjgQAABDj2uuKfr9ffr/fojQAAGAvs9lsMQXUuD6KmAAAu4rdbldVVZUOHjy47rIUw8PDOnv2rObm5ixIBwAAAOxdU1NTm97ky83NVWlpKd2XAABA3MrIyJDL5YoaoxsTAABA/KCICQCwK2VkZOjkyZPKyMiImVtaWtL58+c1MjJiQTIAAABgbwmFQuro6NClS5fU0tJC51MAALBrGYahvLy8qLGxsTEFAgGLEgEAAOBqFDEBAHYtp9Op+vp6VVdXy2aL/kgzDEMpKSkWJQMAAAD2hvn5eTU0NGhwcFCStLi4qK6uLotTAQAA3Lq8vLxI50ibzabs7GyFw2GLUwEAAECSHFYHAADgdqw9PeXz+dTS0hJZ3qKyslKJiYkWpwMAAAB2J9M0NTAwoO7ubpmmGTU3NDSknJwcHhoAAAC7ktPpVGFhoZxOp3Jzc+VwcKsMAADcOtM0dfHiRXm9XuXn58vtdlsdaVfjJzMAwJ6QmJioo0ePqq+vTwsLC8rNzbU6EgAAALArLS8vq6WlRbOzszFzNptN5eXl8nq9FiQDAADYGuXl5VZHAAAAe8Ts7KxmZmY0MzOj/v5+ZWRk6MCBA0pISLA62q5EERMAYM+w2WwqLS2VaZqRltDXCoVC8vv9Sk1N3dlwAAAAwC4wNjamtrY2hUKhmLnk5GTV1NQoKSnJgmQAAAAAAADxxTRN9fX1RY0tLi7S6fE28F8OALDnbFTAJEnd3d0aHBxUQUGBysvLZbPZdjAZAAAAEJ+CwaDa29s1Nja27nxRUZFKS0v5+RkAAAAAAODfTUxMaHp6OmosLy9v03uV2BxFTACAfWNqakqDg4OSpMHBQU1PT6u2tlbJyckWJwMAAACsMzMzo5aWFq2srMTMuVwu1dTU0MkUAADsG5t1eQcAAFgTDAbV0dERNeZ0OpWXl2dRor2BIiYAwL4QCATU2toaNba4uKiGhgaVlZWpsLCQixMAAADYV8LhsHp6etTf37/ufHZ2tqqqqmiBDgAA9oXl5WV1dHTI5XKpqqrK6jgAACDO9fT0aHV1NWqsoqKC6yi3if96AIB9weFwqLi4WF1dXQqHw5Fx0zTV1dWlqakpHThwQG6328KUAAAAwM6Zmppat4DJ4XCoqqpK2dnZFqQCAADYWeFwWIODg+rp6YlcN8zJyVFKSorFyQAAQLyan5+PrP6yJi0tTVlZWRYl2jtsVgcAAGAnGIahgoICHT9+fN3l42ZmZnT27FmNjY1ZkA4AAADYeZmZmTGFSqmpqTpx4gQFTAAA/LvFxUU99dRTOnXqlNLT05WUlKSamhp97GMfU29v723vv6enR4Zh3NCfRx999Pb/QoixuroaVcAkSe3t7TJN08JUAAAgXpmmqfb29qgxwzBUVVXFqi9bgCImAMC+kpSUpGPHjqmoqChmLhgMqrm5Wc3NzQoGgxakAwAAAHZWVVWVXC6XDMNQeXm5Dh8+THdSAAD+XUdHh44ePapPfOITOnPmjKanp7W4uKjW1lb97d/+rQ4fPqx//ud/tjombpPb7VZJSUnU2Pz8vIaGhixKBAAA4tnIyIjm5uaixoqLi+XxeCxKtLewnBwAYN+x2WwqLy9Xenq6WlpatLKyEjU/Njam2dlZ1dTUKDU11ZqQAAAAwA5wOByqra2V3W5ft2MpAAD7ld/v1/333x95yv4DH/iAHn74YXk8Hp0+fVpPPvmk5ubm9M53vlMvv/yyjh49etvH/Ou//mu9/e1v33A+LS3tto+B9RUWFmp0dFSLi4uRse7ubmVmZsrlclmYDAAAxJPV1VV1dXVFjXk8HhUXF1uUaO+hiAkAsG+lpqbq5MmTam9vj1lGbmVlRRcuXFBRUZFKS0tls9G8EAAAALuPzWZTX1+fcnJylJWVte42Pp9vh1MBABD/PvOZz6itrU2S9NRTT+njH/94ZO7OO+/Uvffeq3vuuUeLi4t6/PHH9eKLL972MQsKCnTw4MHb3g9uns1mU1VVlS5cuBAZC4VC6urqUm1trYXJAABAPOnu7o5ZzaWyspL7iFuI/5IAgH1t7cnzmpoa2e32mPn+/n719vZakAwAAAC4PcnJyTp8+LAmJyfV1tYW04EUAACsLxAI6Itf/KIkqba2Vh/72MditnnDG96g973vfZKkl156Sa+99tqOZsTWS01NVU5OTtTY2NiYpqenLUoEAADiyezsrEZGRqLGsrKylJ6eblGivYkiJgAAJOXk5OjkyZMxT6G7XC4VFhZalAoAAAC4eaZpamRkRPX19XK73ZKkYDCo1tZWmaZpcToAAOLf6dOnNTs7K0l6z3ves+GT9Y8++mjk9fe///2diIZtVl5eLocjehGT9vZ2hcNhixIBAIB4EA6HI8sMr7Hb7aqoqLAo0d5FERMAAP/O7XbryJEjKisrk2EYkqQDBw4oISHB4mQAAADAjVldXdWlS5c0PDwc+Zl2zdzcnBYXFy1KBgDA7vHLX/4y8vqee+7ZcLuTJ08qMTFRkvTyyy9vey5sP6fTqbKysqixpaUl9ff3W5QIAADEi+zs7Kji9tLSUrlcLgsT7U0UMQEAcBXDMFRcXKxjx46poqJCaWlpVkcCAAAAbsjMzIzOnj277pInKSkpOnHihJKSkixIBgDA7tLU1BR5XVNTs+F2DodDlZWVkqTm5ubbPu6XvvQlVVZWyu12y+fzqb6+Xh/60IfU0NBw2/vGjcvLy5PX640a6+3t1dLSkkWJAACA1Ww2m4qLi3Xq1CllZGQoOTlZBQUFVsfakxzX3wQAgP3H6/XGXKy4WiAQ0PT0tLKzs3cwFQAAABDLNE319/eru7t73bn8/HxVVVXFdGYCAADrGxgYkCQlJSUpNTV1022Liop08eJFjY+Pa2Vl5baexr+6WGllZUVNTU1qamrS008/rccee0xf+MIXbmn/a3+fjQwPD0de+/1+zc3N3fQxbsX8/Py6r+NBfn6+WltbI+9N01Rzc7MqKir4mSrOxfN5hd2JcwpbjXNq9ysuLlYoFJLf77c6SoRV59V2/DegiAkAgJtkmqZaW1s1OTmpqakpVVVVyW63Wx0LAAAA+1AgEFBLS4umpqZi5lZXV9Xe3q7jx49zsw0AgJuwdjMmOTn5utte3eVwfn7+loqMUlNT9eCDD+ree+9VVVWV3G63hoeH9cILL+jZZ5/V/Py8nn76afn9fj3//PM3vf+ioqIb3vbrX/+6fD7fTR/jdn3961/f8WNeT0lJifLy8iLv/X6/vv3tb6/7cxfiUzyeV9jdOKew1TinsB128ryanZ3d8n1SxAQAwE0aGBjQ5OSkJGl0dFR+v191dXUszQEAAIAdNTs7q+bmZq2srMTMeb1evfjiiwoEAhYkAwBgd1teXpYkOZ3O6257ddHSrSw3lp+fr8HBQSUmJkaNHzt2TPfdd58+/OEP681vfrP6+vr0jW98Q+985zv1tre97aaPg5s3MDCgjIyMqPOgpKREMzMzCofDFiYDAADYuyhiAgDgJiwtLcUs07G4uKiGhgZVV1crJyfHomQAAADYL0zT1MDAgLq6utadLykpUVpamn72s5/tcDIAAHbWVnQa/OpXv6pHH300asztdku60tXweq4uJvZ4PDd9fKfTuWmxVFVVlf7xH/9Rv/VbvyVJ+tKXvnTTRUz9/f2bzg8PD+uOO+6QJL373e9WQUHBTe3/Vs3Pz0c6Bbz73e++oc5XO216elo9PT2SrpxvJSUluuOOO2Sz2awNhg3thvMKuwvnFLYa59TuEQgElJCQYHWMG2LVeTU4OKgnn3xyS/dJERMAADfB4/GopqZGbW1tCoVCkfFwOKyWlhbNzMyosrKS5eUAAACwbebn59ctYEpISFBtba3S0tI0NzdnQTIAAPYGr9cr6cpn7vUsLCxEXm/XzaI3vvGNqqurU1NTk375y18qHA7fVBFNYWHhDW/r9XqVkpJyKzFvS3JysiXHvR6v1xtZJqWysjKmYxbiW7yeV9i9OKew1Tin4tfCwoIuXLigvLw8lZaWyuHYPaU1O3lebcf1p93zXxoAgDiRnZ2t5ORkNTU1RV2okqSRkZHI8nJc1AAAAMB28Hq9Ki4uVl9fX2QsNTVVtbW1N7TsDQAAe0Vzc/Nt7yMvLy9mrLCwUK+++qoWFhY0MzOj1NTUDb9+rctRVlZW1NJyW22tiGl5eVmTk5PKysratmPhPxiGobq6Otnt9i3p/AUAAOKfaZpqb29XOBzW4OCgxsfHVVlZyc9fO4QiJgAAbkFiYqKOHTumzs5ODQ8PR80tLCzo7NmzLC8HAACAbVNaWqrZ2VnNzs6qpKREJSUl3FgDAOw7NTU127Lfuro6ffe735UktbS06PWvf/262wWDQXV2dkqSamtrtyXLGj7nrbObOi8AAIDbNzY2FunEKF1ZYtjv91PEtENYtBcAgFtkt9tVXV2tmpqamBbea8vLXbvsHAAAALAVDMNQbW2tDh8+rNLSUm5sAgCwhe6+++7I65deemnD7c6cORPp0n3XXXdta6ampiZJksvlUkZGxrYeCwAAYL8KBAKRIvU1LpdLJSUlFiXafyhiAgDgNuXk5OjEiRNKSkqKmRseHta5c+e0uLhoQTIAAADsZnNzcxobG9tw3uVyKS0tbQcTAQCwP9x7773y+XySpK997WsyTXPd7Z577rnI6wcffHDb8rz88stqbGyUdKXA6tqH6WCd1dVVqyMAAIAt1NPTo0AgEDVWWVkpu91uUaL9h590AQDYAmvLy+Xm5sbMLSwsqKGhQXNzcxYkAwAAwG5jmqYGBgZ0/vx5tbS0yO/3Wx0JAIB9xel06iMf+Ygkqbm5WZ/97GdjtnnllVf07LPPSpLuuecenTp1at19GYYhwzBUWlq67vwPfvCDDYukJKmjo0OPPPJI5P2f/dmf3ehfA9soFAqpq6tLv/71r6OWmwEAALvX3NychoaGosYyMjKUmZlpUaL9iYV8AQDYIna7XQcOHFBqaqra2toUDocjcx6PR8nJyRamAwAAwG4QDAbV2tqqiYmJyFhzc7OOHz8uh4PLOAAA7JSPf/zj+ta3vqW2tjY98cQT6ujo0MMPPyyPx6PTp0/rU5/6lILBoDwejz7/+c/f8nEefPBBVVZW6qGHHtIdd9yhwsJCuVwuDQ8P66c//ameffZZzc/PS5Le8Y536KGHHtqivyFu1dTUlNrb27W8vCxJam9v1/Hjx+mQBQDALmaaptrb26PGbDabKisrLUq0f3H1CwCALZaTk6Pk5GQ1NTVpcXFRdrtddXV1XMgAAADApvx+v5qamiI3xNYsLS1pYGBgww4OAABg63m9Xv34xz/Wfffdp/b2dj3zzDN65plnorZJSUnR888/r6NHj97WsTo6OvTUU09tus2f/umf6nOf+9xtHQdbY3FxMerntYWFBQ0ODqqoqMjCVAAA4HYMDQ1FCsfXlJSUyO12W5Ro/6KICQCAbZCUlKTjx4+rvb1dGRkZ8ng8VkcCAABAnDJNU0NDQ+rs7Fx3OZmioiIVFxdbkAwAgP2tsrJS586d09///d/rO9/5jjo6OrS6uqqioiLdd999+uhHP6qSkpLbOsYPf/hDvfLKK3r11VfV29uriYkJLSwsKCUlReXl5XrjG9+o9773vTp48OAW/a1wuwoKCjQ6Ohp1o7Onp0dZWVnc6AQAYBdaWVlRd3d31FhiYqIKCwstSrS/UcQEAMA2sdvtqqmp2XSblZUVJSQk0KUJAABgnwoGg2pra9P4+HjMnMPhUE1NjTIyMixIBgAApCsPqj3xxBN64oknbunr1ytQvtoDDzygBx544Jb2DWsYhqGqqiqdO3cuMhYOh9XZ2an6+noLkwEAgFvR1dWlUCgUNVZVVcW9O4tQxAQAgEXC4bAuX74swzBUW1tLtyYAAIB9ZqPl46Qry9PU1tbyND8AAEAcSklJUV5enoaHhyNjExMTmpycpAAdAIBdZHp6WmNjY1FjOTk5Sk1NtSYQROkYAAAW6ejo0Pz8vPx+v86ePauJiQmrIwEAAGAHrC0fd+7cuXULmAoLC3XkyBEKmAAAAOJYWVmZEhISosY6OjpiOjkAAID4FA6H1d7eHjXmcDhUXl5uUSJIFDEBAGCJsbGxqCe1QqGQGhsb1dHRoXA4bGEyAAAAbKdgMKjm5ma1t7fHLC/jcDhUX1+viooKWpYDAADEuYSEhJibnMvLy+rr67MoEQAAuBkDAwNaWlqKGisrK5PT6bQoESSKmAAAsERiYuK6y8cNDg7q/Pnz6z6RDwAAgN3NNE1duHBB4+PjMXNer1cnTpxQZmamBckAAABwK3JycuTz+aLG+vv7tbCwYFEiAABwo3Jzc5WTkxN57/V6lZeXZ2EiSBQxAQBgieTkZB0/flzZ2dkxcywvBwAAsDcZhqGCgoKY8YKCAh09epTl4wAAAHYZwzBUVVUlwzAiY6ZpqqOjI6brJgAAiC9Op1M1NTU6cuSIkpKSYj7TYQ2KmAAAsIjD4VBNTc26PxQFg0E1Njaqs7OTCx4AAAB7SG5urnJzcyVJdrtd9fX1qqysZPk4AACAXSopKUmFhYVRYzMzMxobG7MoEQAAuBmpqak6ceKEvF6v1VEgyWF1AAAA9jPDMJSfn6+UlBQ1NTXFrL07MDCgqakpOZ1Ora6uWpQSAAAAW6myslKmaaqkpGTdJYYBAACwu5SUlGhsbEwrKyuRsc7OTmVkZMjh4FYcAADxjg5M8YPH/AAAiANry8tlZWXFzC0uLurQoUNKTU3d+WAAAAC4JX6/f8M5u92umpoaCpgAAAD2CLvdrsrKyqixQCCgnp4eawIBAADsUhQxAQAQJxwOh2pra9ddXi4hIUE1NTUaGhpieTkAAIA4Fg6H1draqoaGBk1MTFgdBwAAADskMzNTGRkZkfdZWVkqKiqyMBEAALja0tISq57sAvSwBAAgjqwtL+f1etXU1KTl5eWo+cXFRYuSAQAA4HqWl5fV1NQU6cLU2tqq5ORkud1ui5MBAABgJ1RWVmp5eVnl5eVKT0+3Og4AAPh3pmmqpaVFi4uLKisrU15eHkvIxSk6MQEAEIe8Xq9OnDihzMzMyNjy8rJKS0v5oQoAACAOTU9Pq6GhIWoZuWAwqKamJjppAgAA7BNut1snTpyggAkAgDgzMjKiubk5BYNBtbe369y5czGNBBAfKGICACBOORwO1dXVqaCgQMFgUG1tbXI4aKIIAAAQT0zTVF9fny5evKhAIBA1Z7PZVFhYSBE6AADAPsLPfgAAxJdAIKCurq6YMafTaVEibIY7oQAAxDHDMJSdna0f/OAHCoVCVscBAADAVYLBoFpbWzUxMREz5/F4VF9fr6SkJAuSAQAAAAAAQJK6uroUDAajxqqqqmSz0fMnHvF/BQCAXWCzAqZAIKCmpiatrKzsYCIAAID9bXFxUefOnVu3gCkjI0PHjx+ngAkAAAARs7OzGhkZsToGAAD7ysjISMznb1ZWFku/xjE6MQEAsIuZpqnm5mZNT09rZmZGdXV1Sk1NtToWAADAnjY+Pq7W1tZ1C81LS0tVXFzMMiIAAACIGB0dVWtrq0zTlNPp5MYpAAA7YGZmRm1tbVFjdrtdFRUVFiXCjaATEwAAu1hPT4+mp6clXenIdOHCBQ0MDMg0TYuTAQAA7D2maaqrq0tNTU0xBUwOh0OHDh1SSUkJBUwAAACI6OnpUUtLS+R6XVNTkxYWFixOBQDA3ra4uKjGxsaY+2UVFRVyuVwWpcKNoIgJAIBdKhQKaWxsLGa8s7NTLS0tmy5BBwAAgJsTCAR08eJF9ff3x8wlJyfr+PHjPFEPAACAGNfePA2FQrp06ZJWV1ctSgQAwN4WCAR06dIlBYPBqPHCwkLl5eVZlAo3iiImAAB2KbvdruPHjystLS1mbmxsTOfOndPS0pIFyQAAAPae+fl5zczMxIzn5OTo6NGj8ng8Ox8KAAAAca+0tFRZWVlRYysrK7p8+TIPIQIAsMXC4bAuX76s5eXlqPGMjAyVl5dblAo3gyImAAB2sYSEBB06dEjFxcUxcwsLCzp79qwmJyctSAYAALC3pKWlqbS0NPLeMAxVVlbqwIEDstvt1gUDAABAXDMMQwcOHJDX640a9/v9UcvMAQCA22OaplpbWzU3Nxc1npycrNraWhmGYVEy3AyKmAAA2OUMw1BZWZnq6+tjbqCFQiFdvnxZPT09XBABAAC4TcXFxcrIyJDT6dSRI0dUUFDABTAAAABcl91u18GDB+V2u6PGJyYm1N3dbVEqAAD2lt7eXo2NjUWNuVwuHTx4kAfQdhGKmAAA2CMyMzN1/PhxJSUlxcz19vbq8uXLCgQCFiQDAADYGwzDUE1NjU6cOCGfz2d1HAAAAOwiTqdz3Zuo/f39Gh4etigVAAB7w9LSkvr6+qLG1oqIXS6XRalwKyhi2kaLi4t66qmndOrUKaWnpyspKUk1NTX62Mc+pt7e3tvef09PjwzDuKE/jz766A3t85vf/Kbe+ta3Kjc3V263WyUlJfrP//k/65VXXrntvACA7ZeYmKhjx44pKysrZm5qakoNDQ2an5+3IBkAAMDuMD09rZGRkQ3nHQ6HnE7nDiYCAADAXpGUlKT6+vqYbp7t7e2anp62KBUAALufx+PRoUOH5HA4ImO1tbVKTk62MBVuBUVM26Sjo0NHjx7VJz7xCZ05c0bT09NaXFxUa2ur/vZv/1aHDx/WP//zP1sdM2JpaUn333+/HnnkEf3sZz/T6OioVlZW1NfXp+eff1533323/uqv/srqmACAG2C321VbW6uKioqYueXlZZ07d06zs7MWJAMAAIhfpmmqv79fFy9eVFtbm+bm5qyOBAAAgD0oLS1NVVVVUWOmaaqxsVELCwsWpQIAYPdLS0vTsWPH5Ha7VVlZqYyMDKsj4RY4rr8Jbpbf79f999+v9vZ2SdIHPvABPfzww/J4PDp9+rSefPJJzc3N6Z3vfKdefvllHT169LaP+dd//dd6+9vfvuF8Wlrapl//3ve+Vz/5yU8kSW9605v00Y9+VPn5+bp06ZI+9alPqbOzU5/85CeVl5enD37wg7edFwCwvQzDUGFhoZKTk9XU1BS1jFxSUpK8Xq+F6QAAAOJLMBhUW1ubxsfHJf3HTaQTJ07QdQkAAABbLi8vT4uLixoYGIiMhUIhXb58WceOHeNnUAAAblFiYqJOnjwZs3wrdg+KmLbBZz7zGbW1tUmSnnrqKX384x+PzN1555269957dc8992hxcVGPP/64Xnzxxds+ZkFBgQ4ePHhLX/uv//qv+qd/+idJ0gMPPKDvf//7kX/Up06d0tve9jadOHFCfX19+sQnPqH/9J/+03WLogAA8SE1NVUnTpxQY2Oj/H6/EhISVF9fL5uNZowAAADSlaXgGxsbtbi4GDW+urqqoaEhlZaWWhMMAAAAe1p5ebmWl5c1MTERGVteXlZjY6OOHDnC9TsAAG4RBUy7Gz8BbbFAIKAvfvGLkq6ssfixj30sZps3vOENet/73idJeumll/Taa6/taMZrffazn5UkORwOffnLX475R52ZmalPf/rTkqSZmRl95Stf2fGMAIBb53K5dPToUeXn56uurk4ul8vqSAAAAHFhYmJCDQ0NMQVMklRaWqqSkhILUgEAAGA/MAxDNTU1MR3TfT6fDMOwKBUAAPHPNE3Nz89bHQPbhCKmLXb69GnNzs5Kkt7znvdsWCn/6KOPRl5///vf34lo6/L7/frFL34hSXrzm9+swsLCdbd76KGHlJKSIsnavACAW2Oz2VRVVaXU1NQNtwkGgzJNc+dCAQAAWMQ0TXV1damxsVGhUChqzuFw6ODBgyopKeHmEQAAALaV3W5XfX29XC6XDMNQdXW1ysvL+TkUAIBN9Pf36+zZsxocHLQ6CrYBRUxb7Je//GXk9T333LPhdidPnlRiYqIk6eWXX972XBt57bXXtLq6KmnzvE6nU69//esjXxMIBHYkHwBgZ4RCIZ0/f14tLS0xN/IAAAD2kkAgoEuXLqm/vz9mLikpScePH1dGRoYFyQAAALAfuVwuHTx4UIcOHVJeXp7VcQAAiGtjY2Pq7u6WJHV0dKijo4MH9PcYipi2WFNTU+R1TU3Nhts5HA5VVlZKkpqbm2/7uF/60pdUWVkpt9stn8+n+vp6fehDH1JDQ8OW5L16PhgMqr29/bYzAwDig2maamtr08LCgsbGxnTu3DktLS1ZHQsAAGDL+f1+nT17VtPT0zFzOTk5OnbsmDwejwXJAAAAsJ8lJycrLS3N6hgAAMS1ubk5tbS0RI0NDg5qbm7OokTYDg6rA+w1AwMDkq48vbnZkj2SVFRUpIsXL2p8fFwrKytyuVy3fNyri5VWVlbU1NSkpqYmPf3003rsscf0hS98Yd39r+WVtOFSclfnXdPf36+6urobznf1cdYzPDwceb2wsMA3Gljq6jVUWU8V8WC7z8mxsTGNjY1F3i8sLOjs2bMqKSmRz+fb8uNhd+N7JOIJ5yPiDedkfJucnFR/f/+6T+cVFhYqMzNTCwsLFiTbHpyPiDeck4gne+n7PQAAALAfLC0t6fLlyzHXdcrLy7mXtcdQxLTF/H6/pCtV89eTlJQUeT0/P39LRUypqal68MEHde+996qqqkput1vDw8N64YUX9Oyzz2p+fl5PP/20/H6/nn/++Q3z3kjma/PejKsLoK7ne9/7Ht9oEDe+/vWvWx0BiLId52RaWpoqKirkcPzHjwWhUEhdXV3q7+9nTWFsiO+RiCecj4g3nJPxpaSkZN2lOVZXV9XW1qZf//rXFqTaOZyPiDeck7Da7Oys1REA4IbNz8+rs7NTdXV1SkhIsDoOAAA7LhgM6vLlywoEAlHjeXl5123Ugt2HIqYttry8LElyOp3X3fbqoqVbWbYnPz9fg4ODSkxMjBo/duyY7rvvPn34wx/Wm9/8ZvX19ekb3/iG3vnOd+ptb3vbunlvJPPt5gUAxKfp6WldvnxZ1dXVMZ8pRUVFSk5OVkdHh0KhkEUJAQAAbs96D+LMzc2pvb095gIYAAAAEC+mpqbU1NSkUCikxsZGHT58WDabzepYAADsmHA4rKamJi0uLkaNp6WlqaqqSoZhWJQM22XfFjFtxcn81a9+VY8++mjUmNvtlnTlac7rWVlZibz2eDw3fXyn07lp4VFVVZX+8R//Ub/1W78lSfrSl74UU8S0lle6fubbydvf37/p/PDwsO644w5J0kMPPaTq6uqb2j+wlebn5yNPhb773e++oc5qwHbaqXMyFAqpr69PMzMzUeNpaWm66667VF5efkufV9hb+B6JeML5iHjDORnfBgYGND4+LknKysrS0aNHdc8991icavtwPiLecE4inrS1tenJJ5+0OgYAbGpsbEzNzc2R97Ozs2pra9OBAwe4YQsA2BdM01RHR4emp6ejxhMTE1VXV8fn4R61b4uYtovX65V0Y8utXb32+nZduHnjG9+ouro6NTU16Ze//KXC4XBUlf5aXun6mW8n7820cUtKSlJKSspN7R/YLsnJyZyPiCvbfU6mpqZqcHBQnZ2dUeNrS61UV1crJydn246P3YXvkYgnnI+IN5yT8aempkbBYFA5OTn77ucZzkfEG85JWC0pKcnqCABwXT6fT06nM+oB9NHRUXk8HpWUlFiYDACAnTEwMKDh4eGosYSEBB06dEgOB6Uue9W+/T97dfX6rcrLy4sZKyws1KuvvqqFhQXNzMwoNTV1w69f606UlZUVtVTbVlsrYlpeXtbk5KSysrKi8q4ZGBjQyZMnr5tXurK8EABg7zEMQ4WFhUpOTlZTU1PU8irhcFgtLS3y+/0qLy+ndTUAAIg7pmlu+BSezWbToUOHeEoPAAAAu4LL5dLBgwd1/vx5hcPhyHhPT488Ho+ys7MtTAcAwPaamJhQV1dX1JjNZtPBgwejVpvC3rNvi5hqamq2Zb91dXX67ne/K0lqaWnR61//+nW3CwaDkS4XtbW125JlzWYXaOvq6iKvW1paNt3P2rzD4VBVVdXWhAMAxKXU1FSdOHFCjY2N8vv9UXODg4Oan59XXV3dpsuaAgAA7KSlpSU1NjaqtLRUmZmZ625DARMAAAB2E6/Xq9raWjU2NkaNt7S0yOVyyefzWZQMAIDt4/f7121KU1NTQ1fffYAWClvs7rvvjrx+6aWXNtzuzJkzkeXZ7rrrrm3N1NTUJOlK1X5GRkbU3KlTpyI3oDfLu7q6ql//+teRr0lISNimtACAeOFyuXT06NF1Ow/Ozs6qp6dn50MBAACsY2pqSg0NDVpYWFBLS0vUcugAAADAbpaZmamKioqoMdM01djYqKWlJYtSAQCwPZaXl3X58uWoLoSSVFZWFrXiFPYuipi22L333hupfP/a174m0zTX3e65556LvH7wwQe3Lc/LL78cqdC/++67Y5b+8Xq9+p3f+R1J0s9//nMNDAysu5/vfe97mpub2/a8AID4YrPZVF1drQMHDkR1LvB4PCovL7cwGQAAwJWbN319fbp06ZKCwaAkKRQKqbGxMfIeAAAA2O0KCgqUn58fNRYIBHT58mV+7gUA7CkzMzNaXV2NGsvNzVVRUZFFibDTKGLaYk6nUx/5yEckSc3NzfrsZz8bs80rr7yiZ599VpJ0zz336NSpU+vuyzAMGYah0tLSded/8IMfbFgkJUkdHR165JFHIu//7M/+bN3t/uIv/kLSlSXuPvzhDysUCkXNT0xM6BOf+ISkK8sLvf/979/wmACAvSk3N1dHjx6V0+mU3W7XwYMH5XDs21VpAQBAHAiFQmpublZ3d3fMnGEY3MwBAADAnmEYhiorK5WWlhY1vri4qMbGxphuFQAA7Fa5ubmqq6uLNGdJTU1VVVVV1IP22Nu4+7gNPv7xj+tb3/qW2tra9MQTT6ijo0MPP/ywPB6PTp8+rU996lMKBoPyeDz6/Oc/f8vHefDBB1VZWamHHnpId9xxhwoLC+VyuTQ8PKyf/vSnevbZZzU/Py9Jesc73qGHHnpo3f389m//th5++GH90z/9k374wx/qLW95ix5//HHl5+fr0qVL+v/+v/9PfX19kqRPf/rTMT8kAwD2h5SUFJ04cUKLi4tKTEy0Og4AANjHlpaW1NjYuO6ycZmZmTpw4AAF1wAAANhTDMNQXV2dzp8/H/Vz8MzMjNrb21VdXc0NXgDAnpCVlSWXy6Wurq6ogibsD1zR2wZer1c//vGPdd9996m9vV3PPPOMnnnmmahtUlJS9Pzzz+vo0aO3dayOjg499dRTm27zp3/6p/rc5z636Tb/+3//b83NzeknP/mJTp8+rdOnT0fN22w2/ff//t/1wQ9+8LbyAgB2N6fTKafTueH86uqqlpeXlZKSsoOpAADAfjI1NaXm5uZ1Oy2VlpaquLiYmzcAAADYkxwOhw4ePKiGhgYFAoHI+MjIiDwej4qLiy1MBwDA1klJSdGRI0e4xrMPUcS0TSorK3Xu3Dn9/d//vb7zne+oo6NDq6urKioq0n333aePfvSjKikpua1j/PCHP9Qrr7yiV199Vb29vZqYmNDCwoJSUlJUXl6uN77xjXrve9+rgwcPXndfHo9HP/7xj/WNb3xDzz33nC5cuKCZmRnl5OTojW98o/78z/9cd955523lBQDsbeFwWE1NTZqbm1N1dbVyc3OtjgQAAPYQ0zTV39+/7vJxDodDNTU1ysjIsCAZAAAAsHPcbrcOHjyoCxcuRC0j193dLa/Xy2oaAIA9gwKm/Ykipm2UlJSkJ554Qk888cQtfb1pmpvOP/DAA3rggQduad8beeSRR/TII49s6T4BAPtDV1eXZmdnJUmtra3y+/2qqKigzScAALhtwWBQra2tmpiYiJlLTEzUwYMH5fF4LEgGAAAA7LyUlBTV1NSoqakpMpabmyufz2dhKgAAbs78/LxCoRCfX4hCERMAALhtk5OTGhwcjBobGhrS/Py86uvrN12CDgAAYDOLi4tqbGzU4uJizFxmZqZqampkt9stSAYAAABYJysrS+Xl5erq6lJZWZmKioroWAEA2DVWVlZ06dIlBQIB1dTUKDs72+pIiBO0RgAAALctLS1NBQUFMeNzc3M6e/as5ubmLEgFAAB2u2AwqPPnz69bwFRWVqa6ujoKmAAAALBvFRYW6tixYyouLqaACQCwa4RCIV2+fFmrq6syTVPNzc3q7e297kpV2B8oYgIAALfNZrOpsrJSNTU1McvHra6u6vz58xoeHrYoHQAA2K0cDoeKi4tjxg4dOsSNGgAAAOx7hmEoJSXF6hgAANywtaKl+fn5qPHp6WmKmCCJIiYAALCFcnJydPToUblcrqhx0zTV1tamtrY2hcNhi9IBAIDdqKCgINJSPCkpScePH1d6errFqQAAAID4FwqFuCEMAIgrnZ2dmpycjBrzeDyqr6+PeUge+xNnAQAA2FJer1cnTpxQampqzNzw8LAuXLiglZWVnQ8GAAB2JcMwVF1dreLiYh07dkwej8fqSAAAAEDcW15eVkNDgwYHB62OAgCAJGloaCjmc8nhcOjgwYNKSEiwKBXiDUVMAABgyyUkJOjw4cMqLCyMmZubm1NDQ4NmZ2ctSAYAAOLV8vLyhnN2u11lZWWy2+07mAgAAADYndauvy0uLqqzs1MjIyNWRwIA7HOjo6Nqb2+PGjMMQ/X19UpMTLQoFeIRRUwAAGBbGIahiooK1dTUxLQAXV1d1YULFzQ0NGRROgAAEC9M01RPT49+85vfaGZmxuo4AAAAwK62srKiCxcuKBAIRMZaW1vV3d3N0nIAgB23dt2npaUlZq66unrdVT2wv1HEBAAAtlVOTo6OHTsmt9sdNW6apsbGxrh4AgDAPhYMBtXY2Kje3l6ZpqmmpqZNOzIBAAAA2JzL5VJxcXHMeF9fn5qbmxUKhSxIBQDYj8LhsFpaWtTb2xszV1xcrNzcXAtSId5RxAQAALZdcnKyjh8/HlVR73Q6VVdXJ8MwrAsGAAAss7i4qIaGBk1OTkbGAoGAmpqaFA6HLUwGAAAA7G7FxcUqKiqKGR8fH9eFCxe0urpqQSoAwH4SCAR08eJFjY2NxcwVFBSotLR050NhV6CICQAA7IiEhAQdPnxYhYWFkXWOnU6n1bEAAIAFJiYm1NDQoKWlpZi5rKwsipwBAACA22AYhsrLy1VVVRUz5/f7de7cOS0sLFiQDACwHywuLurcuXOanZ2NmausrFRlZSXXfrAhh9UBAADA/mEYhioqKlRQUBCzvBwAANj7TNNUb2/vum3EHQ6H6urqlJaWZkEyAAAAYO/Jz8+X2+1WU1NT1DJyy8vLOnfunOrq6pSenm5hQgDAXrSysqLl5eWoMbvdrtraWmVkZFiUCrsFnZgAAMCO26yAKRgMqru7m2VkAADYY4LBoC5fvrxuAVNycrJOnDhBARMAAACwxdLT03Xs2DG5XK6o8VAopEuXLml4eNiiZACAvSotLU3V1dWR9y6XS0ePHqWACTeETkwAACBumKaplpYWTU5Oanp6WvX19TEXWAAAwO6zsLCgxsbGdZePy87OVnV1tex2uwXJAAAAgL0vKSlJx48f1+XLl+X3+6Pm2tratLi4qPLycpb2AQBsmdzcXC0uLmp6eloHDx7kXg9uGJ2YAABA3Ojr69Pk5KQkye/36+zZs5qZmbE2FAAAuC0TExM6d+7cugVMFRUVqqmpoYAJAAAA2GZOp1NHjhxRVlZWzNzAwICamppkmqYFyQAAe1VZWZmOHj1KARNuCkVMAAAgLqyurqq/vz9qLBAI6OLFixocHOQiCgAAu4xpmuru7lZjY6NCoVDUXEJCgo4cOaLCwkKe9gYAAAB2iN1uV21trYqKimLm3G43P5sDAG7K6uqqxsfHN5w3DIMH13DTKGICAABxwel06tixY3K73VHjpmmqo6NDra2tCofDFqUDAAA3a3Z2Vn19fTHjycnJOn78uFJTU3c+FAAAALDPGYah8vJyHThwIFK0lJmZqfLycouTAQB2k4WFBZ07d05NTU2RFTaArUAREwAAiBtJSUk6fvy40tLSYuZGR0d1/vx5LS8vW5AMAADcrNTUVBUXF0eN5eTk6OjRozFFywAAAAB2Vm5urg4dOqS0tDTV1NTQhQkAcMOmp6d17ty5yP2a5uZmzc/PW5wKewVFTAAAIK4kJCTo0KFDMTc9Jcnv96uhoUHT09MWJAMAADertLRU6enpMgxDlZWVOnDgAG3EAQAAgDiRlpamw4cP8zM6AOCGDQ8P6+LFiwqFQpGxUCik9vZ2maZpYTLsFRQxAQCAuGMYhsrKylRXVyebLfrHlUAgoIsXL6q/v58fiAEAiHOGYaimpkZHjhxRQUEBT3cDAAAAu8j8/Ly6urq4BgcAkGma6uzsVFtbW8yc1+tVfX09132wJRxWBwAAANhIVlaWEhMT1djYqKWlpai5rq4u+f1+VVdXy+HgRxoAAKyyuroqv9+vjIyMdecTEhLk8/l2OBUAAACA27G6uqrLly9rZWVFCwsLqquro2MTAOxToVBILS0tmpiYiJnLzMxUTU0NnxHYMnRiAgAAcS0pKUnHjx9Xenp6zNz4+HjUussAAGBnzc3N6ezZs2pqapLf77c6DgAAAIAtEAqFIgVMkjQ1NaXz589H3gMA9o+VlRVduHBh3QKmoqIiilyx5ShiAgAAcc/hcOjgwYMqKSmJmbPZbEpISLAgFQAA+5dpmhoaGtL58+e1urqqcDispqYmBQIBq6MBAAAAuE1+v1/z8/NRY/Pz82poaODhBQDYR+bn53Xu3LmY7/2GYai6ulrl5eUsIYctRxETAADYFQzDUGlpqQ4ePBhZPs7hcFDlDwDADguFQmptbVV7e7tM04yMLy8vq7Oz08JkAAAAALZCamqqDh8+HLkGt2Z1dVXnz59ftxsHAGBv2agLn8Ph0KFDh5SXl2dRMux1FDEBAIBdJSMjQ8ePH1dycrJqamrk8XisjgQAwL6xtLSk8+fPa3R0NGYuNTVV5eXlFqQCAAAAsNVSU1N1/PjxmGtv4XBYjY2NGhgYiHqoAQCwdwwODurSpUsKhUJR4263W8eOHVNaWppFybAfOK6/CQAAQHzxeDw6fvz4pm1KTdOkjSkAAFtoampKzc3NCgaDMXNFRUUqKyvjsxcAAADYQzwej44dO6bGxkbNzs5GzXV2dmpxcVFVVVX8HgAAe8j8/Lw6OjpixlNSUlRfXy+n02lBKuwndGICAAC70mYXR8LhsM6fP6/h4eEdTAQAwN5kmqZ6e3t16dKlmAImu92uuro6lZeXc+MCAAAA2IMSEhJ0+PBh5eTkxMwNDw+v+3sCAGD3Sk5OVllZWdRYVlaWjhw5QgETdgRFTAAAYM9pb2/X3Nyc2tra1NraqnA4bHUkAAB2pWAwqMbGRvX09MTMJSYm6tixY8rKytr5YAAAAAB2jM1m04EDB1RaWhozNz09rfPnz2t5eXnngwEAtkVRUZFyc3MlSSUlJaqtrZXNRmkJdgbLyQEAgD1leHhYIyMjkfcjIyNaWFhQXV2d3G63hckAANhdFhYW1NjYqKWlpZi5zMxMHThwQA4HlxUAAACA/cAwDJWUlMjj8ailpUWmaUbmFhYW1NDQoIMHDyolJcXClACArWAYhqqqqpSVlaX09HSr42CfoVwOAADsKevdaPX7/WpoaND09LQFiQAA2H3GxsbU0NCw7udqWVmZ6urqKGACAAAA9qHs7GwdOXJECQkJUeOBQCDqwUIAQPxbXV3dcM5ms1HABEtQxAQAAPaU8vLydVubBgIBXbx4UX19fVFPigEAgFihUChmOdaEhAQdPnxYxcXFMgzDomQAAAAArObz+XTs2DElJiZGjVVWVlqYCgBwo0zT1MDAgF599VXNzs5aHQeIQhETAADYc7Kzs3X8+HF5PJ6Yue7ubjU1NSkYDFqQDACA3SEvL095eXmR916vV8ePH1daWpqFqQAAAADEC4/Ho2PHjik1NVUej0f19fUxDxUCAOKPaZrq6OhQZ2enwuGwGhsb1+3EDViFnyYAAMCelJSUpOPHjysjIyNmbmJiQg0NDVpYWLAgGQAAu0NlZaW8Xq/y8vJ09OhRud1uqyMBAAAAiCMOh0OHDh1ad3k5AED8CQaDunz5soaGhiJjgUBAly9fVigUsjAZ8B8oYgIAAHuWw+FQfX29SktLY+aWlpZ07tw5jY+P73wwAAB2AZvNpiNHjqi6uponqgEAAACsy2azyeVybTi/vLxMhw8AiAPLy8s6f/68pqamYuays7O59oO4wZkIAAD2NMMwVFJSokOHDsnhcETNhUIhNTU1qbOzU6ZpWpQQAABrhEIhtbS0aHJycsNt7Hb7DiYCAAAAsJcEg0FdunRJ586d0+zsrNVxAGDfmpubW3d1CsMwVFtbq5KSEhmGYVE6IBpFTAAAYF9IT0/XiRMnlJycHDM3MDCgnp6enQ8FAIBF1joSjo6OqqWlhSejAQAAAGypcDispqYmLS4uKhAI6MKFCxobG7M6FgDsO+Pj47pw4YICgUDUeEJCgo4cOaLs7GyLkgHro4gJAADsG263W0ePHlVOTk7MeGFhoUWpAADYWZOTk1FP3wWDQTU2NioUClmcDAAAAMBe0d/fr+np6ch70zTV3Nys7u5uhcNhC5MBwP4QDofV29urpqammO+7iYmJOnbsmHw+n0XpgI05rr8JAADA3mG323XgwAGlpKSoo6NDhmGovr5eCQkJVkcDAGBbmaap3t5e9fb2xswtLy9rYWFBKSkpFiQDAAAAsNcUFBRodnY2qpBJkvr6+jQxMaGqqiqlpqZaEw4A9rjZ2Vm1t7fHLB8nSampqaqrq+OeCOIWRUwAAGDfMQxD+fn5Sk5O1srKyrpLzAEAsJcEAgG1tLRoamoqZi4xMVH19fVKTEy0IBkAAACAvcjhcOjQoUPq6OjQ0NBQ1Nzi4qIuXLignJwclZeXy+l0WpQSAPaWQCCgrq4ujYyMrDufm5urqqoq2Wws2IX4RRETAADYt67XbSIQCCgUCsntdu9QIgAAtt78/LwaGxu1vLwcM5eVlaUDBw7IbrdbkAwAAADAXmYYhiorK+XxeNTZ2RkzPzo6qsnJSZWVlSkvL0+GYViQEgD2DtM0NT4+vu5cWVmZioqK+F6LuEcREwAAwDpM01RTU5Pm5+dVW1ur9PR0qyMBAHDTRkdH1dbWpnA4HDNXXl6uwsJCLl4BAAAA2DaGYaiwsFA+n09tbW2an5+Pmg8Gg2pvb9fIyIiqqqrk9XotSgoAu5/T6VRZWZk6OjoiY0lJSaqqqpLP57MwGXDj6BMGAACwju7ubs3MzCgYDOrSpUvq7e2VaZpWxwIA4IaEw2F1dHSopaUlpoApISFBhw8f5uk7AAAAADvG6/Xq+PHjqqysXLcTrN/vV0NDgzo6OhQMBi1ICAB7Q35+vpKTk2W321VRUaETJ05QwIRdhU5MAAAA15icnFR/f3/UWE9Pj/x+v2pqauRw8CMUACB+raysqKmpSXNzczFzXq9X9fX1crlcFiQDAAAAsJ8ZhqGCggJlZWWps7NTY2NjMdsMDw+rsLCQ628AsAHTNDU5OSmfz6eEhISYecMwIvcxuP6D3YhOTAAAANfw+XzKzMyMGZ+cnFRDQ4MWFhYsSAUAwPWFQiGdO3du3QKmvLw8HT16lAtYAAAAACzldDpVW1urw4cPy+PxRM2VlJTI7XZblAwA4tvS0pIuX76sxsZGdXd3b7hdUlIS13+wa1HEBAAAcA2Hw6G6ujqVlZXFzC0tLamhoUEjIyMsLwcAiDt2u135+flRY4Zh6MCBA6qurpbNxmUAAAAAAPEhLS1NJ0+eVGlpqWw2mxITE1VYWGh1LACIO+FwWL29vTpz5oympqYkXelcNzs7a3EyYOvRixEAAGAdhmGouLhYXq9XTU1NCgaDkblwOKzW1lbNzMyoqqpKdrvdwqQAAEQrKiqS3+/XxMSEXC6X6uvr5fV6rY4FAAAAADFsNptKSkqUnZ2tYDC44YMXwWBQc3NzSk9P3+GEAGCt6elptbe3a2lpKWauvb1dJ06ckGEYFiQDtgdFTAAAAJtIS0vTiRMn1NjYqPn5+ai50dFRzc3Nqa6uTsnJyRYlBAAg2lrnpYSEBJWVlSkhIcHqSAAAAACwqWuXlbtWb2+vBgYGlJmZqcrKSpZJArDnra6uqrOzU2NjY+vOO51OFRcX73AqYPtRxAQAAHAdbrdbx44dU2dnp4aGhqLm1paXq6ysVF5eHk88AAB2hGmampubk8/nW3fe4XCourp6h1MBAAAAwNabn5/XwMCAJGliYkLT09MqLS1VQUEB1+IA7DmmaWpoaEjd3d0KhULrblNQUKDS0lI5HJR7YO/hrAYAALgBNptNVVVV8vl8amtri/rlwTRNtbe3a2ZmRgcOHGB5OQDAtlpdXVVzc7NmZmZ05MgRpaamWh0JAAAAALbF2nW3q4VCIXV2dmpkZCRyvQ4A9gK/36+2traYVSHWeL1eVVVVyev17nAyYOdQxAQAAHATsrOz5fV61dTUFPOLRCAQkM1msygZAGA/mJ6eVnNzswKBgCSpublZJ06ckNPptDgZAAAAAGyP3NxcLS4uKhgMRo0vLCzo/Pnzys3NVXl5OUtpA9i1gsGguru7Y1aCWONwOFRWVsZqENgXKGICAAC4SR6PR8eOHVNXV5cGBwclSQkJCaqpqeEXCADAtjBNU729vert7Y0aX11dVWtrqw4dOmRRMgAAAADYPoZhKC8vT5mZmerq6tLIyEjMNiMjI5qcnFR5ebk8Ho8FKQHg1gWDQb322mtaXV1ddz4nJ0fl5eU8wIZ9gyImAACAW2Cz2VRZWanU1FS1traqpqZGLpfL6lgAgD1oZWVFzc3Nmp2djZlzOp0qKiqyIBUAAAAA7JyEhAQdOHBAubm5am9v18LCQtR8IBBQa2urkpKS5PF4tLS0ZFFSALg5DodDmZmZMV2YEhMTVVVVpdTUVGuCARahiAkAAOA2ZGZmKjU1VQ7Hxj9WhcNhlpkDANySqakptbS0RJaPu1p6erpqampYMgEAAADAvuHz+XT8+HENDg6qp6dH4XA4an5hYUGHDh3SyMiIQqGQRSkB4OaUlZVpfHxcgUBANptNJSUlKiws5L4C9iWKmAAAAG7TZgVMwWBQ586dU25urgoLC1luDgBwQ8LhsHp6etTf3x8zZxiGysrK+FwBAAAAsC/ZbDYVFRUpKytLnZ2dmpiYiJnPz89Xc3Oz7rjjjk2v3QHATjJNc91xh8OhiooKjY+Pq7KyUm63e4eTAfGDT20AAIBtYpqm2tratLi4qK6uLs3OzurAgQN0zAAAbGp5eVnNzc2am5uLmXO5XKqtrZXP57MgGQAAAADED7fbrfr6ek1OTqqjo0PLy8tR88nJyRQwAYgLy8vL6uzsVEpKyobXdLKzs5WTk7PDyYD4wyc3AADANhkeHtb4+Hjk/eTkpM6ePcvNZwDAhiYmJtTa2qpgMBgzl5GRQTEsAAAAAFwjIyNDqamp6uvrU39/v0zTVDAYVEFBgdXRAOxz4XA4avnL6elp1dTUrLst3baBK1hEEQAAYJusrq7GjK2srOj8+fPq6+vbsHUsAGB/6unpUWNjY0wBk2EYqqioUH19PQVMAAAAALAOu92usrIy1dTUaHZ2Vn19ffz+BMBSs7OzamhoUFdXl8LhsCQpFAppcHDQ4mRAfKMTEwAAwDYpLS1VSkqKWlpaFAgEoua6u7sjy8s5nU6LEgIA4klycnLMmNvtVl1dnbxerwWJAAAAAGB3cbvdam5u3nSb4eFhzczMqKKigutyALZcIBBQV1eXRkZG1p2fn59XQkJCzD0DAFfQiQkAAGAbpaen68SJE+suHzc1NaWzZ89qZmZm54MBAOJOZmamCgsLo96fOHGCAiYAAAAA2CKrq6vq6urS2NiYXnvtNQ0NDdEtHcCWME1Tw8PD+s1vfrNhAVNeXp5qa2spYAI2QScmAACAbeZyuXTkyBH19vaqt7c3am51dVUXLlxQaWmpiouLWfcaAPa5srIy+f1+ZWdnKy8vj88FAAAAANhCXV1dkSW8g8Gg2tvbNTIyoqqqKh4gAXDL5ufn1d7errm5uXXnk5OTVVVVpZSUlA23AXAFRUwAAAA7wDAMlZaWyufzqaWlRaurq1HzPT09mpmZUW1tLW2sAWCPW11d3fB7vc1m05EjRyheAgAAAIAttrq6qsnJyZhxv9+vhoYG5efnq6ysTA4Ht08B3JhgMKje3l4NDAysO2+321VaWqqCggKu9QA3iOXkAAAAdlBaWppOnDih1NTUmLmZmRmdOXNG09PTOx8MALAjxsbGNm0rLomLWgAAAACwDZxOp06dOqXs7Ox154eGhvTKK6+ora1N8/PzO5wOwG7T09OjX//61xsWMGVlZenUqVMqLCzkWg9wEyglBgAA2GFOp1OHDx9WX1+fenp6ouYCgYDGx8eVlpZmTTgAwLYIhULq7OzU8PCwJKm9vV1er1dJSUkWJwMAAACA/cPpdKq2tla5ublqb2/X0tJS1Hw4HNbw8LCGh4eVkpKigoICZWZmymajLwSAaKZpKhQKxYx7PB5VVlYqPT3dglTA7kcREwAAgAUMw1BJSYl8Pp+am5sjy8slJSWpoqLC4nQAgK20uLiopqYmLSwsRMbC4bCampp0/Phx2e12C9MBAAAAwP6TlpamkydPqr+/X319fQqHwzHbzM3NaW5uTgkJCcrLy1NhYaESEhIsSAsgHuXn56uvry/y3jAMFRcXq7i4mMJH4DbwrwcAAMBCqampOnnypNLT02Wz2VRbW8vNbADYQ0ZHR3X27NmoAqY1Xq/XgkQAAAAAAEmy2WwqKSnRyZMnlZWVteF2gUBA/f39O5gMgNVM09T09LQaGxu1vLy87jYul0uZmZmSpMzMTJ08eVKlpaUUMAG3iU5MAAAAFktISNDBgwe1uLjIskIAsEeEQiG1trZqZGQkZs5ms6mqqkq5ubkWJAMAAAAAXM3j8aiurk4rKyuRpeTWuqavyc7OpgsTsA8Eg0GNjIxoaGgostxkYmKiysrK1t2+rKxMFRUVcrvdOxkT2NMoYgIAAIgDhmFsWsC0tLSkjo4OVVVV8QsRAMQ5j8ejtra2dZ/US0pKUl1dnRITEy1IBgAAAADYiMvlUmlpqYqLizUxMaGhoSHNzs5KurJs1EZGR0eVmJhIt11gF/P7/RoaGtLY2FjM8pLDw8MqKSlZt8MS13eArUcREwAAQJwLh8Nqbm6W3+/X2bNndeDAgUibWgBA/DBNU1lZWSotLV23gCkvL08VFRUsGwoAAAAAccxmsyk7O1vZ2dlaWFjQ5OTkhgVKoVBI7e3tCoVC8nq9ys/PV1ZWFr/3AbtAOBzW+Pi4BgcH5ff7N9wuEAhofHxcOTk5O5gO2L8oYgIAAIhzXV1dkV+igsGgGhsbVVBQoLKyMi6IAECcCAQC6u3tVUVFRcyc3W5XdXW1srOzLUgGAAAAALhVSUlJm3ZPHx0dVSgUknSlk0tra6s6OzuVm5ur/Px8eTyenYoK4AYtLS1Flo4MBoObbpuYmKj8/HxlZGTsUDoAFDEBAADEsWAwqMnJyZjxwcFBTU1N6cCBA/L5fBYkAwCsmZ2dVVNTk1ZXV2PmkpOTVVtbS3txAAAAANhjTNPU0NBQzHgwGNTAwIAGBgaUlpYWKYAwDMOClACkK/9ep6amNDQ0pKmpqU23NQxDmZmZys/Pl8/n498usMMoYgIAAIhjDodDJ06cUGtrqyYmJqLmlpaWdP78eRUVFam0tHTdNbkBANvP5XJFnry9Wn5+vioqKvj+DAAAAAB70NqS4sFgUCsrK+tuMz09renpablcLuXl5SkvL09Op3OHkwJYWVnR5cuXN93G6XRG/p26XK4dSgbgWhQxAQAAxDmHw6G6ujoNDQ2pq6tL4XA4ar6/v1+Tk5OqqamR1+u1KCUA7F9ut1vl5eVqb2+XdOWp28rKSpWUlFicDAAAAACwXWw2m0pKSlRcXKzJyUkNDQ1penp63W1XVlbU09Oj3t5eZWVlKT8/XykpKXR4AXaI2+1WRkbGuqsepKamRjqm8SAaYD2KmAAAAHYBwzBUUFCgtLQ0tbS0yO/3R80vLi6qoaEhcuGEX7YAYGfl5eVpZGREfX196urq0qlTp6yOBAAAAADYAWtLT2VmZmpxcVHDw8MaGRlRMBiM2dY0TY2NjWlsbExFRUUqLy+3IDGwN4VCIS0uLm74oG9+fn6kiMlutys3N1f5+flKTEzcyZgAroMiJgAAgF0kMTFRx44dU39/v3p6emSaZtR8b2+vJicndeDAASUnJ1uUEgD2ptnZWSUnJ8tut8fMGYahsrIy/exnP7MgGQAAAAAgHiQmJqqiokKlpaUaHx/X4OCg5ufn1902MzNzh9MBe9Pi4qKGhoY0MjIim82m17/+9es+5JuWlqbMzEylp6crOzt73es7AKxHERMAAMAuYxiGiouLlZ6ertbW1pgLIfPz82poaFB5ebkKCwstSgkAe0coFFJ3d7cGBweVn5+vqqqqdbfj4hcAAAAAQPqPLi+5ubmam5vT0NCQxsfHFQ6HJUnJyckbdotZ24ZO68DGTNPUxMSEhoaGNDMzExkPhUKamJhQdnZ2zNcYhqH6+vodTAngVlDEBAAAsEslJyfr2LFj6uvrU19fX1RXJtM05XDwox4A3K65uTm1tLRoaWlJkjQ0NKTMzEylpaVZnAwAAAAAsBukpKQoJSVFFRUVGhkZ0dDQkPLz82UYxrrbj4yMqLe3N7LUlcvl2uHEQPxaWVnR8PCwhoeHtbq6uu42Q0ND6xYxAdgdKOHdRouLi3rqqad06tQppaenKykpSTU1NfrYxz6m3t7e295/aWmpDMO4qT89PT0x+/nkJz95w1//4osv3nZuAACwdWw2m0pLS3Xs2LGotbszMjKUk5NjYTIA2N3C4bC6urp07ty5SAHTmtbWVgWDQYuSAQAAAAB2o4SEBBUVFemOO+7Y8LqdaZoaGhrS6uqq+vr69Otf/1qNjY2anp6OeoAR2E9M09TMzIyampr06quvqre3d8MCJulKJ7S1jmYAdh8ez98mHR0duu+++9Te3h413traqtbWVn3lK1/R888/rz/4gz/YsUw+n0+5ubk7djwAALBzvF6vTpw4oZ6eHo2MjKi6unrDp7kAAJvz+/1qaWnR4uJizJzNZlNhYSFLxwEAAAAAbsla44D1zM3NaWFhIWpsYmJCExMT8ng8ys/PV25uLh3YsS8Eg0GNjo5qaGho3Ws0V3M4HMrLy1NeXp48Hs8OJQSwHfiE2wZ+v1/3339/pIDpAx/4gB5++GF5PB6dPn1aTz75pObm5vTOd75TL7/8so4ePXpLx3nhhRc2rTKVpJ///Of6L//lv0iS3vGOd8jtdm+6/aVLlzadLysru7mQAABgx9hsNpWXl6u4uHjTCxnT09NKTU2lyAkArhEOh9XX17dh51yv16uampqozncAAAAAAGyV6enpDeeWlpbU2dmp7u5uZWdnKzc3V16vVzYbC+9g7xkaGlJnZ+d1OyqlpKQoPz9fWVlZ/FsA9giKmLbBZz7zGbW1tUmSnnrqKX384x+PzN1555269957dc8992hxcVGPP/74LS/RVl1dfd1t/uf//J+R13/yJ39y3e0PHjx4S1kAAED82KyAaXJyUpcvX1ZqaqoOHDhw3QJnANgv5ufn1draqvn5+Zg5wzBUWlqqoqIiCkABAAAAANumtLRUmZmZGhoa0ujo6LoFHOFwWCMjIxoZGZHNZpPX65XP51NqaioPLmLPcLvdGxYw2Ww25eTkKC8vT16vd4eTAdhulCNusUAgoC9+8YuSpNraWn3sYx+L2eYNb3iD3ve+90mSXnrpJb322mvbkmV2dlY//OEPJUnl5eW6++67t+U4AABgdwgEApFC65mZGZ05c0bDw8MyTdPiZABgHdM01dfXp4aGhnULmJKTk3X8+HEVFxdzIRgAAAAAsO2Sk5NVXV2tO++8U5WVlZt2Aw6Hw5qdnVVfX5+am5t3MCVwawKBgCYnJ9XZ2amGhgZNTU2tu11aWlrMsnAej0cVFRW68847VV1dTQETsEfRiWmLnT59WrOzs5Kk97znPRu2rXv00Uf19NNPS5K+//3v69SpU1ue5dvf/raWl5cl3VgXJgAAsLd1dHRELUUbCoXU1tamiYkJVVdXy+VyWZgOAHbe4uKiWlpa5Pf7Y+YMw1BxcbGKi4tpRw4AAAAA2HEOh0MFBQXKz8/X7OyshoaGNDExseEDiT6fb8OHb6amphQMBuXz+bgGiB21srKi2dnZyJ+FhYWo+dnZWaWnp8d8nWEYysvLU1dXlzIzM5Wfn0+nMWCfoIhpi/3yl7+MvL7nnns23O7kyZNKTEzU4uKiXn755W3J8g//8A+SrnyTf/e7370txwAAALtHbm6uZmdntbKyEjU+NTWlM2fOqLKyUtnZ2fwiCGDfGBgYWLeAKTExUTU1NTzRBwAAAACwnGEYkaXiVlZWNDIyovHx8ZhiEJ/Pt+E+BgYGND09LenKMl0+ny/yx+PxcD0QW8I0TS0vL0cKlmZmZiINNzYyMzOz4VxeXp6ys7MpvAP2GYqYtlhTU1PkdU1NzYbbORwOVVZW6uLFi9vS3rG7uztSHHX33XervLz8hr7urW99q86fP6+ZmRmlpqaqrq5Ov/d7v6fHHntMaWlpt5xnYGBg0/nh4eHI64WFBc3Nzd3ysYDbdfUyIustKQLsNM5JbBW73a4DBw5oYGAgpk1vMBhUS0uLhoeHVVRUpISEhHX3wfmIeML5iNuVlZWliYkJBQKByFh2drby8vJkmuZN/17COYl4wvmIeMM5iXhy7U1fAAB2C5fLpZKSEpWUlCgQCGhubk4zMzOanZ1Vamrqul9z7e+3y8vLWl5e1ujoqCQpISFBPp9Pqamp8vl8SkpKoqgJN2VsbEwTExOanZ2NWgngRvj9foXD4XW7YDscDjkclDMA+w3/6rfYWrFOUlLShj8srCkqKtLFixc1Pj6ulZWVLa0i/Yd/+IdIO8mbWUruZz/7WeT1+Pi4XnrpJb300kv69Kc/reeee05vf/vbbylPUVHRDW/7ve99b9NqcWAnff3rX7c6AhCFcxJbJTU1VeXl5XI6nVHjs7OzmpiYUHd394brka/hfEQ84XzErfL5fKqtrdXS0pI6Ozu37MY65yTiCecj4g3nJKw2OztrdQQAAG5bQkKCMjIylJGRsel28/PzCoVCG84HAgFNTExoYmJC0pUHIa/u1OT1ellmHZuanp7W+Pj4DW9vs9nk9Xoj5xgAXI0ipi22thRBcnLydbdNSkqKvJ6fn9/SIqa1i0Eej0fveMc7rrv9oUOH9Id/+Ie64447lJ+fr0AgoNbWVj3//PN64YUXNDMzoz/6oz/Sj370I/3+7//+luUEAADWmJmZ0YULF1RaWqqsrKyouYSEBFVXV2tyclLd3d0KBoMWpQSArWEYRuQhj2vNzs6qra1NMzMzCofDO5wMAAAAAIDtl56errm5uRu6zhcKhTQ1NRV5wLGyslIFBQXbHRFxKBQKaW5uTrOzswoGg6qsrFx3O5/Pp5GRkQ33Q2EcgJtBEdMWW1vX89quBuu5umhpaWlpyzL86le/UmdnpyTp7W9/u1JSUjbd/vHHH9cnP/nJmPHXve51+pM/+RM9/fTT+tCHPqRQKKT3v//96uzslNvtvqlM/f39m84PDw/rjjvukCQ99NBDqq6uvqn9A1tpfn4+Ugj47ne/+4aKEoHtxDmJ7TYzM6P+/v6YixgZGRnKyclRUVFRpMMk5yPiCecjrsc0TU1OTmpkZETV1dU39Hva7eCcRDzhfES84ZxEPGlra9OTTz5pdQzEufn5eTU0NOg3v/mNfvOb3+i1115TT0+PJKmkpCTyeiv96le/0pe//GX927/9m0ZHR5WamqojR47o0Ucf1R//8R9v+fEA7A9er1eHDh2SaZpaWFjQ7Oxs5M+NLP21Uaectd+5fT6fEhIStjo2LHDtEoXz8/ORh8IMw1BZWZnsdnvM1117jqwtUbi2TCFLFAK4Gfu2iGkrvlF+9atf1aOPPho1tlbccyMf+isrK5HXHo/ntvOs+Yd/+IfI6/e85z3X3f56y9499thjeu211/Tss89qaGhI3/3ud/Wud73rpjIVFhbe8LZJSUnXLbwCdkpycjLnI+IK5yS2Q0pKinJzc9Xe3h5pG70mGAxqeHhYhYWFMU/HcD4innA+4lorKytqa2uLPDk6NDSkQ4cO7dhFM85JxBPOR8QbzklY7eoO+cBGHnjgAb344os7drxPfvKT+p//839GdQcdHR3VCy+8oBdeeEHPP/+8/s//+T83/YAxAKwxDEPJyclKTk5WQUGBTNPU8vJypKBpZmYm0qxhjcPh2PBz0+/3q7GxUdKVz9arO+1s5eoz2D4rKytRRW0LCwsbbmuapvx+/7r3ld1ut/Lz85WcnCyfzyePx0PREoBbtm+LmLaL1+uVdOUpjeu5+oNgq54+W1lZ0be//W1JUl5ent7ylrdsyX4fe+wxPfvss5Kkl1566aaLmAAAQHxzOp2qq6vT+Pi42tvbo7oyHThwgPa+AHYN0zQ1Njamjo6OqO9l09PTGhkZUV5enoXpAAAAsFtcvRxxenq6Tp48qV/96lc3dO3/Zj399NP6q7/6K0lSRUWF/tt/+286dOiQhoaG9IUvfEGnT5/Wj3/8Y733ve/VN77xjS0/PoD9yTAMeTweeTwe5ebmSootanG73RsWo8zOzkZeLywsaGFhQUNDQ5KuFLVcXdREUUt8CAaDmpiYiPz/vdmVgmZmZtYtYjIMQ1VVVVuUEsB+t2+LmJqbm297H+td/C4sLNSrr76qhYWFDb+Rr1lbYi0rK2vLKpJ/9KMfaXp6WpL0yCOPrNvS71bU1dVFXg8ODm7JPgEAQHwxDEPZ2dny+Xxqb2/X5OSkCgoKrtu1EQDixerqqtra2jQ5Obnu/GZPFAIAAABXe+SRR/TYY4/p1KlTqqyslCSVlpZueRHT1NSUPvGJT0iSiouL9etf/1qZmZmR+T/4gz/Qgw8+qB/96Ef65je/qQ9+8IO69957tzQDAKxxuVzKzs5Wdna2pOiCzmtdXcR0reXlZS0vL2t0dFTSleXFUlNTlZKSIpfLJbfbHWkMga0TDocVDAZlGMa6S/wFg0G1trbe9H69Xq98Pp/S0tK2IiYAbGrfFjHV1NRsy37r6ur03e9+V5LU0tKi17/+9etuFwwG1dnZKUmqra3dsuPf7FJyN4rqaAAA9g+Xy6X6+nqNj48rIyNjw+2u7nACAFbaqPvSGqfTqerq6k2/pwEAAABX++AHP7gjx/nKV74SKQT49Kc/HVXAJEl2u11f/vKX9ZOf/EShUEif+cxnKGICsGM2uz9oGIZsNlvUMpgbCQQCGh8f1/j4uCQpIyNDBw8eXHfbgYEBzc/PKyEhYcM/Dodjz9+7NE1TwWBQgUDgun+CwaBWV1cVCoUkSUVFRSovL4/Zp8vlksvl0srKyobHtdlskaKltcKzrWqaAQA3Yt8WMW2Xu+++O/L6pZde2rCI6cyZM5GngO+6664tOfb4+Lj+5V/+RZJ09OhRHTp0aEv2K0lNTU2R1/n5+Vu2XwAAEJ/WujJtpr29XYmJiaqoqFBiYuIOJQOAaHNzc+rs7NTc3Ny689nZ2aqsrFz3CUQAAADAaj/4wQ8kSSkpKXrooYfW3aawsFBvfvOb9dOf/lS/+MUv5Pf76WACwHL19fUKh8Py+/1RS9CtFdJsZrPf0aenpzU1NXVD+7j2j9frjctl5E3TVDgcjik+SkxM3PD7+WuvvXbTy72tCQQC644bhiGfz6exsbHImN1uj1r6z+v1ymaz3dJxAWArUMS0xe699175fD7Nzs7qa1/7mp544ol1K4Gfe+65yOsHH3xwS479zW9+M/KhtJVdmKQra3Kvueeee7Z03wAAYPfJycmJtIWenp5WQUGBSkpK5HDw4yWAnbG6uqqurq5Ia/prJSQkqKqqSllZWTucDAAAALgxq6ur+s1vfiNJuvPOO+V0Ojfc9p577tFPf/pTrays6MyZM3rTm960UzEBYEM2my1S/CJdKdZZWFiIKmpaXV2N+brNipg2KsBZb7trtw0E/v/27jw+iirf//+7s3T2hWyQkCYBQkQGBr0siqMjKKKCqODOVUFkGLcZ9TIuM35VGK8Lyozb6AgXlNHBXVQUF0QDI5uAooMiQgKELCzZIPvSSf3+YNK/xHRn7e5K0q/n49EPKn1OVX2KPjmprvrUOXUuk5h++uknFRcXtzrC089f7UnmOXbsmGpra9scLcnZ1Hw2m81lElNXrrO29n8YExOjhoYGx+cWHh7e60e1AtCzcJfJzaxWq37/+9/roYce0o8//qhFixbprrvualZn8+bNWrZsmaQTXzzGjBnjdFuNfzBSUlJ04MCBNvfdOJVcQECAZsyY0a54d+7cqZCQEMec3s4sWbJES5culST169fPbUlXAACgZwoICJDNZnP8bBiGcnNzdeTIEQ0cOFD9+vXjiy8Aj2loaFBeXp6ys7NdPt0ZFxenIUOGtHoTCAAAADDbnj17HOe0Q4cObbVu0/Iff/yxQ0lMubm5rZYfOnTIsVxWVuZylFN3Ky8vd7oMdAXtqnuIiIhQRESE+vfvr9raWpWXl6u8vFw1NTWy2+0yDMNlX9PaVGdtaW27FRUVqq2tdZpU5Yqfn5/8/Pw0cOBA7d+/32mb2r17d6djrqiocBlvV66vVldXu9xuSEiI49quYRgqKyvr9H7QOfRT8ASz2pUn+hCSmDzgrrvu0htvvKE9e/bo7rvvVmZmpq6++mqFhIQoIyNDjzzyiOx2u0JCQvTUU0+5ZZ+7du3S119/LUm64IIL2pz+pdHXX3+tOXPmaMKECbrwwgs1YsQIxcbGym63a/fu3VqxYoXWrFkj6cRwgkuWLFFYWJhbYgYAAD1TcHCw07nu6+rqtGfPHuXn5ystLc3xBBYAuJPdbtfBgwedJjCFhIRo0KBBio2NJZkSAAAA3V7T5KLk5ORW6zZ9mCgnJ6dD+2m6blteeeUVU77Pv/LKK17fJ3o/2lXP1K9fPwUFBSkgIECBgYEKCAhwLPv7+7e67r///W+tXr3aadnw4cMVHh7eoVgaGhrU0NDgGBXJWZv6xS9+0ekpPjMzM/XRRx85LRs8eLBjdOn6+nrZ7XbV1dW1+m/T5c8//7xTMcG76KfgCd5sV8ePH3f7Nkli8oCIiAitXr1akydP1t69e7VkyRItWbKkWZ3IyEitWLFCp5xyilv22TgKkyRdf/31HVq3vr5ea9eu1dq1a13WiY2N1bJlyzR16tROxwgAAHqH8vJyffvtt7roootUUFDQYijkxvKEhAQNGjRIQUFBJkUKoDeyWq1KSUlRVlaW4z1/f38NGDBAycnJ7RrqHQAAAOgOmj653taN9aYPFzNqA4De7PDhwy7LLBZLi8Smpv+2NiJIV6Zns9vtLsvaO/1do4aGBkeyUWsjOB08eFA5OTkup6IDgN6KJCYPSUtL044dO/Tcc8/prbfeUmZmpmpra2Wz2TR58mTdfvvtSklJccu+GhoatGLFCklSdHS0Lr744navO3nyZC1btkybN2/Wjh07dOTIERUVFckwDMXExGjkyJG64IILNGvWLEVGRrolXgAA0PM1NDSof//+Sk1NVVZWloqKilrUOXr0qAoLCx2JBW09KQUA7ZWUlKRDhw6psrJSffv21aBBg5g6DgAAAD1OdXW1Y7mt89mmDwhVVVV1aD9tjdx06NAhjR07VpJ03XXXqX///h3afmeVl5c7Rgq47rrrOjxCCuAM7QquVFZWqq6uzjGqkbNXY9nPNSYqOWtTubm5Ki0tdSRWNb78/f1bvBcQECA/Pz9Gj/Zx9FPwBLPaVV5enh599FG3bpMkJg8KCwvT3XffrbvvvrtT67c3q9bPz6/Dw8c2SkhI0OzZszV79uxOrQ8AAHxbSEiIhg8fruLiYmVlZamysrJZeUNDgw4cOKBDhw5p8ODBiouL40s6gDYZhqHDhw8rNjbW6c0cPz8/paeny2Kx8LAFAACAD3PH98uXXnpJs2bN6nownRAcHOxYrq2tbbVu09E6QkJCOrSftqaqayoiIsKUc+zw8HDO7eF2tCs01d62YBiGY6Skuro6HT9+XN99950k521q2LBhbo8VvoN+Cp7gzXZVWlrq9m2SxAQAAIAui4mJUXR0tPLz85Wdnd3iiaWamhrt2rVLffv21dChQ02KEkBPcOzYMWVlZam8vFyJiYlKT093Wi8qKsrLkQEAAADuFRER4Vhua4q4iooKxzIjNgCA5zROWRcYGOj4uaMj4AEAOo8kJgAAALiFn5+fkpOTlZCQ4Bh96ediYmJMiAxAT1BdXa19+/apoKDA8d6hQ4eUmJjY7OYOAAAA0OjHH3/s8jYSExPdEEnnNB0hKTc3t9W6TWdjsNlsHosJAAAAMBNJTAAAAHArq9Wq9PR0JSUlKTMzU8ePH5d0YtSU+Ph4k6MD0N3U19crJydHOTk5amhoaFGelZWlkSNHMhUlAAAAWujpI/2mp6fL399f9fX12r17d6t1m5affPLJng4NAAAAMIWf2QEAAACgdwoPD9fIkSM1bNgwBQcHKy0tzWUSgrPEBQC9m2EYKigo0LZt25Sdne20HwgNDVVKSgoJTAAAAOiVrFarxo4dK0navHmzamtrXdZdv369JCkoKEijR4/2SnwAAACAt5HEBAAAAI+xWCyKj4/X2LFjFR4e7rLerl279P333zO/POAjysvL9d1332nXrl2qqalpUR4QEKC0tDSNHj1affr0MSFCAAAAwDsuvfRSSVJpaalWrlzptE5ubq7Wrl0rSTr33HOZbhkAAAC9FklMAAAA8LjWRlEpLi5WUVGRioqKtG3bNu3bt092u92L0QHwlrq6Ou3Zs0dff/21Y6rJn0tKStLYsWPVv39/RmACAABAj3bgwAFZLBZZLBaNHz/eaZ05c+YoKipKknTvvfeqqKioWXl9fb1uueUW1dfXS5Luuusuj8YMAAAAmCnA7AAAAADguxoaGpSVleX42TAM5eTk6MiRIxo4cKD69u1LEgPQCzQ0NCg/P1/Z2dkukxSjoqKUlpbW6qhtAAAAgLdkZmZqw4YNzd4rLy93/Lt8+fJmZRdccIH69evX4f3ExMRo4cKFuummm5Sdna3TTjtN9913n0aMGKH8/Hw99dRTysjIkCRdc801LpOhAAAAgN6AJCYAAACYprKyUnV1dS3er62t1U8//aT8/HylpaUpMjLShOgAuEtVVVWzhMWmgoKCNHjwYMXFxZG0CAAAgG5jw4YNuuGGG5yWFRUVtSjLyMjoVBKTJP32t79Vfn6+HnroIWVlZWn27Nkt6kyePFkvvvhip7YPAAAA9BRMJwcAAADThIeHtzptVFlZmXbs2KHdu3erpqbGhAgBuENYWJiSkpKavefn56fU1FSNGTNG8fHxJDABAADApy1YsEAbNmzQjBkzZLPZZLValZCQoPPOO0+vvvqqVq9ereDgYLPDBAAAADyKkZgAAABgqoCAAKWlpSkxMVFZWVkqKSlpUefIkSMqLCzUgAEDlJycLD8/cvGBniY1NVVHjx6V3W5XQkKCBg0apKCgILPDAgAAAJyaNWuWZs2a1aVtpKamyjCMdtc/44wzdMYZZ3RpnwAAAEBPRhITAAAAuoWwsDCNGDFCxcXFysrKUlVVVbPy+vp67d+/X4cPH9agQYMUGxvLyC1AN2IYhgoKChQXF+c00TAwMFDp6emyWq2KiooyIUIAAAAAAAAAQHdGEhMAAAC6DYvFotjYWPXp00d5eXnKzs5WfX19szpVVVX64YcflJiYqPT0dJMiBdDIMAyVlJTowIEDKisr06BBg2Sz2ZzWjY+P93J0AAAAAAAAAICegiQmAAAAdDt+fn6y2Wzq27evY/Sln4uMjDQhMgCNGhoaVFBQoJycHFVUVDjez87OVt++fWW1Wk2MDgAAAAAAAADQ05DEBAAAgG7LarXqpJNOUmJiorKyslRaWup4PyEhweToAN9kt9t1+PBh5ebmqqampkV549SPJ510kgnRAQAAAAAAAAB6KpKYAAAA0O1FRkbqlFNO0dGjR7Vv3z71799ffn5+TuuWlZWppKRESUlJCgjgdBdwl9raWuXl5Sk/P192u91lvZCQEMXFxXkxMgAAAAAAAABAb8BdHQAAAPQIFotFffv2bTM5IicnRwUFBTp48KASExOVnJysoKAgL0UJ9D6VlZXKzc3V4cOHZRiGy3ohISGOaSBdJRkCAAAAAAAAAOAKSUwAAADoUfz9/V2WVVVVqaCgQNKJKa1yc3OVl5enhIQE2Ww2hYWFeStMoMc7fvy4cnJyVFRU1Gq9yMhI2Ww2xcbGymKxeCk6AAAAAAAAAEBvQxITAAAAeo3c3NwW7xmGoSNHjujIkSOKiYmRzWZTVFQUyRZAG/Ly8lpNYIqNjXX8PgEAAAAAAAAA0FUkMQEAAKDX6Nevn+rq6hyjMf1ccXGxiouLFRERIZvNpri4OJKZABdsNluL36XGaR1tNptCQ0NNigwAAAAAAAAA0BuRxAQAAIBeIyIiQsOGDVNVVZVyc3N1+PBhNTQ0tKhXVlamXbt2KTg4WDabTX379m11mjqgt7Lb7fLz85Ofn1+LsoiICEVHR+vYsWPy9/dXUlKS+vfvr6CgIBMiBQAAAAAAAAD0diQxAQAAoNcJCQnRkCFDlJKSovz8fOXl5clut7eoV11drb179+rAgQOy2Wyy2WwmRAt4X01NjXJzc3Xo0CENHjxYiYmJTuulpKQoJiZGiYmJCgjg6yMAAAAAAAAAwHO4Cg0AAIBey2q1KjU1VTabTYcPH1Zubq6qq6tb1Kurq1Ntba0JEQLeVVFRoZycHB09elSGYUiScnNz1a9fP6dTK0ZHRys6OtrLUQIAAAAAAAAAfBFJTAAAAOj1/P391b9/fyUlJamgoEA5OTkqLy93lFssFvXv39/ECAHPMQxDx48fV05OjoqLi1uUV1ZWqqioSHFxcSZEBwAAAAAAAADACSQxAQAAwGdYLBYlJCQoPj5ex44dU05OjkpKSpSQkKDg4GCn69TV1amsrEx9+vRxOlIN0F0ZhqHCwkLl5OSorKys1brl5eUkMQEAAAAAAAAATEUSEwAAAHyOxWJRnz591KdPH5WXl8vf399l3by8PGVnZyssLEw2m03x8fHy8/PzYrRAx9TX1+vIkSPKyclxOn1iIz8/P/Xr10/JyckKCQnxYoQAAAAAAAAAALREEhMAAAB8Wnh4uMuy+vp65efnS5IqKiq0e/du7d+/X8nJyUpMTGw1+Qnwtrq6OuXl5Sk/P191dXUu6wUEBDimV7RarV6MEAAAAAAAAAAA10hiAgAAAFw4fPhwi2SQmpoaZWVlKTs7W4mJiYqPj1d4eDhTzcF0O3fubHXauODgYCUnJ6tfv34k4AEAAAAAAAAAuh2SmAAAAAAXrFarQkJCVFVV1aLMbrcrJydHOTk5CgoKUlxcnOLi4hQVFUVCE0yRlJSkn376qcX74eHhjqkQaZsAAAAAAAAAgO6KJCYAAADAhfj4eMXFxamoqEg5OTkqLS11Wq+mpkZ5eXnKy8tTYGCgYmNjFRcXp5iYGJJG4Bb19fUqLi5WYWGh0tLSFBgY2KJOQkKC9u/fr9raWklSnz59ZLPZFB0dTTsEAAAAAAAAAHR7JDEBAAAArbBYLI5Rlo4fP66cnBwVFRW5rF9XV6fDhw+rqKhI48aN82Kk6G3q6upUVFSkwsJClZSUqKGhQZIUExOjvn37tqjv5+cnm82msrIy2Ww2hYeHeztkAAAAAAAAAAA6jSQmAAAAoJ2ioqIUFRWliooKHT58WIWFhaqurnZaNy4uzuXoN4ZhMDIOnKqpqVFhYaEKCwt17Ngxp3UKCwudJjFJUnJysgejAwAAAAAAAADAc0hiAgAAADooLCxMgwcP1qBBg1RRUeFIOqmoqHDUiYuLc7n+999/r4aGBscIT0FBQd4IG91UVVWVCgsLVVBQoLKysjbrFxcXq76+Xv7+/l6IDgAAAAAAAAAA7yCJCQAAAOgki8Wi8PBwhYeHKzU11ZGMUlJSoujoaKfr1NXVqaSkRIZh6NixY8rMzFRERIQjoSk0NNS7BwFTVFRUqKCgoEXyW1uio6NbTZADAAAAAAAAAKCnIokJAAAAcJOQkBDZbDbZbDaXdYqKimQYRrP3ysrKVFZWpv379yssLMyR0BQWFsa0c73U4cOHlZub22Y9Pz8/9enTR3FxcYqNjVVgYKAXogMAAAAAAAAAwPtIYgIAAAC8qKioqNXyiooKVVRUKDs7W8HBwY6EpsjISBKaehjDMFx+ZnFxcS6TmPz9/RUbG6u4uDjFxMQwbRwAAAAAAAAAwCeQxAQAAAB40dChQ1VcXKzCwkIVFRWpvr7eZd3q6mrl5uYqNzdXgYGBiouL0+DBg0lq6cbq6+tVUlLi+HxHjx6toKCgFvUiIyNltVpVW1srSY7PNy4uTtHR0fLz8/N26AAAAAAAAAAAmIokJgAAAMCL/P39FR8fr/j4eDU0NOjYsWMqLCxUYWGh6urqXK5XV1enkpISklu6odraWkfiUnFxsRoaGhxlhYWF6t+/f4t1LBaLEhMTZbfbFRcXp6ioKEbaAgAAAAAAAAD4NJKYAAAAAJP4+fkpJiZGMTExGjJkiEpLSx0JTdXV1S3qx8XFuUx0yczMlGEYCgsLU2hoqEJDQ2W1Wj19CD7DMAzV1taqoqJClZWVjldFRYXsdrvL9VwlMUlSamqqh6IFAAAAAAAAAKDnIYkJAAAA6AYsFouioqIUFRWlQYMGqaKiwpHQVFFRIelEEpMzhmHoyJEjLZJpAgICmiU1hYaGKiwsTFarlVF/OmDv3r06cuRIq1P/uXL8+HHZ7XYFBPDVCwAAAAAAAACA1nAlHQAAAOhmLBaLwsPDFR4ertTUVFVWVqq4uFiRkZFO69fV1TkdDchut+v48eM6fvx4s/f9/f0dCU2hoaGKiYlRWFiYR46luzIMQ1VVVY4Rlfz9/V2OmCSpwwlM0dHRiouLU1xcHAlMAAAAAAAAAAC0A1fTAQAAgG6ucRQlVxpHamqv+vp6lZWVqaysTJIUGBjoMompqqpKwcHBPXbkpoaGBkey0s+ngjMMw1EvNDTUZRJTa//3jfz8/NSnTx/FxcUpNjZWgYGBbjsGAAAAAAAAAAB8AUlMAAAAQA8XHBzsGLGpoqJCVVVVamhoaPf6rhKY7Ha7tm7dKovF0mxKusZRnEJCQuTn5+euw+iyqqoqlZaWOpKUGv8v2ruuYRhOk7WaJjH5+fk5naKvJyd6AQAAAAAAAADQHZDEBAAAAPRwISEhSklJcfxsGIaqq6tbjDxUUVHhNLnJ1UhDlZWVju1VVFQ4HfGptUSmU089Vf7+/i3eP3bsmDIzM9t1bM6MGDFCQUFBLd4vKCjQ/v37O7XNxunlnP1fREREaMSIEQoNDVVQUBDJSgAAAAAAAAAAeABJTAAAAEAvY7FYFBISopCQkGbvG4ahmpqaZlOr2e12p4lG0v+fxNSa9o501FR9fX2Hp8Brquk0cE21Z9q3nwsMDHSMpuQqOSkgIEAxMTEd3jYAAAAAAAAAAGg/kpgAAAAAH2GxWBQcHKzg4OB2JeVUV1d7ISr3cTUtniRZrVan08AFBgZ6MUIAAAAAAAAAAOAKSUwAAAAAnEpNTVX//v2bjdzU+KqpqTE7vBaCg4MdI1A1Jik1JiwFBPDVBwAAAAAAAACA7owr+QAAAABcCgwMVFRUlKKiopq9b7fbVVlZqerqapfTu/n5+Tl9Pzw8XEOHDu1STM5YLBaNHTu209sFAAAAAAAAAADmIYkJAAAAQIcFBAQoMjJSkZGRHV43KChIffv29UBUAAAAAAAAAACgp3L+aDQAAAAAAAAAAAAAAAAAeAlJTAAAAAAAAAAAAAAAAABMRRITAAAAAAAAAAAAAAAAAFORxAQAAAAAAAAAAAAAAADAVCQxAQAAAAAAAAAAAAAAADAVSUwAAAAAAAAAAAAAAAAATEUSEwAAAAAAAAAAAAAAAABTkcQEAAAAAAAAAAAAAAAAwFQkMQEAAAAAAAAAAAAAAAAwFUlMAAAAAAAAAAAAAAAAAExFEhMAAAAAAAAAAAAAAAAAU5HEBAAAAAAAAAAAAAAAAMBUJDEBAAAAAAAAAAAAAAAAMBVJTAAAAAAAAAAAAAAAAABMRRITAAAAAAAAAAAAAAAAAFORxAQAAAAAAAAAAAAAAADAVCQxAQAAAAAAAAAAAAAAADAVSUwAAAAAAAAAAAAAAAAATEUSEwAAAAAAAAAAAAAAAABTkcQEAAAAAAAAAAAAAAAAwFQkMQEAAAAAAAAAAAAAAAAwFUlMAAAAAAAAAAAAAAAAAExFEhMAAAAAAAAAAAAAAAAAU5HEBAAAAAAAAAAAAAAAAMBUJDEBAAAAAAAAAAAAAAAAMBVJTAAAAAAAAAAAAAAAAABMRRKTB5SXl+tf//qXFi1apCuvvFIDBw6UxWKRxWJRamqqR/a5adMmXXvttUpJSVFwcLD69eun888/X6+99lqHtvPaa69p0qRJ6tevn4KDg5WSkqJrr71Wmzdv9kjcAAAAAAAAAAAAAAAAQIDZAfRGU6dO1bp167y2v/nz5+uhhx5SQ0OD470jR45ozZo1WrNmjVasWKG3335bwcHBLrdRVVWlyy+/XB999FGz9w8ePKgVK1botdde0wMPPKAHH3zQY8cBAAAAAAAAAAAAAAAA38RITB5gGIZjOSYmRpMmTVJ4eLhH9rV48WItWLBADQ0NGjx4sJYtW6atW7fqvffe04QJEyRJq1ev1uzZs1vdzuzZsx0JTBMmTNB7772nrVu3atmyZRo8eLAaGho0f/58LVmyxCPHAQAAAAAAAAAAAAAAAN/FSEweMGPGDP32t7/VmDFjlJaWJklKTU1VeXm5W/dTXFyse+65R5I0YMAAbdmyRXFxcY7yiy66SNOmTdMHH3yg1157TXPnztX48eNbbOeLL77Q66+/LunEKFLvvvuu/P39JUljxozRxRdfrFGjRungwYO65557dMUVV6hPnz5uPRYAAAAAAAAAAAAAAAD4LkZi8oC5c+fqmmuucSQwecrSpUt1/PhxSdLChQubJTBJkr+/v55//nlHQtITTzzhdDuLFi2SJAUEBDSr3yguLk4LFy6UJB07dkxLly5163EAAAAAAAAAAAAAAADAt5HE1IO99957kqTIyEhNnz7daZ3k5GRNnDhRkvT555+rrKysWXlZWZk+//xzSdLEiROVnJzsdDvTp09XZGSkJOndd991R/gAAAAAAAAAAAAAAACAJJKYeqza2lpt3bpVkjRu3DhZrVaXdc8++2xJUk1NjbZv396sbNu2baqtrW1Wzxmr1arTTz/dsU5dXV2X4gcAAAAAAAAAAAAAAAAaBZgdADpnz549qq+vlyQNHTq01bpNy3/88UdNmDDB8fOuXbuc1nO1nTVr1shut2vv3r0aNmxYu+PNzc1ttTwnJ8exvG/fvnZvF/CEiooKx1SNe/bsUVhYmMkRwdfRJtGd0B7RndAe0d3QJtGd0B7R3dAm0Z00vf5ot9tNjAToHpr+Hhw6dMhr+y0rK3P8bcjLy1NpaanX9o3ei3YFd6NNwd1oU/AEs9pV03NHd323shiGYbhlS2hVamqqsrOzlZKSogMHDnR5e5988okuvPBCSdITTzyhP/zhDy7rbt++XWPGjJEk3XvvvXr00UcdZffee68WLlwo6cQIS6NHj3a5nUWLFumuu+5y7P/8889vd7wWi6XddQEAAAAAAADAG7Zu3eq4dgr4qm3btmns2LFmhwEAAIAezF3frZhOrocqKytzLIeHh7dat+mTbeXl5R7ZDgAAAAAAAAD0NEeOHDE7BAAAAADAfzCdXA9VXV3tWLZara3WDQoKcixXVVV5ZDttaTpdnDP79+/Xr3/9a0nSpk2bZLPZOrR9wJ0OHTrkePJo69atSkxMNDki+DraJLoT2iO6E9ojuhvaJLoT2iO6G9okupOcnBydccYZkqShQ4eaHA1gvhEjRmjr1q2SpPj4eAUEeOfWEX8b4Am0K7gbbQruRpuCJ5jVrux2uwoKCiSdOKd0B59NYnLH9GYvvfSSZs2a1fVgOiE4ONixXFtb22rdmpoax3JISIhHttOW5OTkdte12Wwdqg94UmJiIu0R3QptEt0J7RHdCe0R3Q1tEt0J7RHdDW0S3UnT66OArwoODjZ9WkX+NsATaFdwN9oU3I02BU/wdrtKTU116/aYTq6HioiIcCy3NbVbRUWFY/nnU8a5azsAAAAAAAAAAAAAAABAZ/nsSEw//vhjl7dh5tBuTTPncnNzW63bdCq3n0/T9vPtjB49ulPbAQAAAAAAAAAAAAAAADrLZ5OYevpc5+np6fL391d9fb12797dat2m5SeffHKzsmHDhjmt19p2AgICNGTIkI6GDAAAAAAAAAAAAAAAADjFdHI9lNVq1dixYyVJmzdvVm1trcu669evlyQFBQW1GGlpzJgxslqtzeo5U1tbqy1btjjWCQwM7FL8AAAAAAAAAAAAAAAAQCOSmHqwSy+9VJJUWlqqlStXOq2Tm5urtWvXSpLOPfdcRURENCuPiIjQueeeK0lau3aty6npVq5cqdLSUknStGnT3BE+AAAAAAAAAAAAAAAAIIkkpm7rwIEDslgsslgsGj9+vNM6c+bMUVRUlCTp3nvvVVFRUbPy+vp63XLLLaqvr5ck3XXXXU6384c//EGSZLfbdeuttzrqNyosLNQ999wjSYqOjtacOXM6fVwAAAAAAAAAAAAAAADAzwWYHUBvlJmZqQ0bNjR7r7y83PHv8uXLm5VdcMEF6tevX4f3ExMTo4ULF+qmm25Sdna2TjvtNN13330aMWKE8vPz9dRTTykjI0OSdM0117hMhjrnnHN09dVX6/XXX9eqVat03nnn6Y477lBSUpJ27typhx9+WAcPHpQkLVy4UH369OlwrAAAAAAAAAAAAAAAAIArFsMwDLOD6G2WL1+uG264od31MzIyWiQYHThwQAMHDpQknX322Vq3bp3L9R988EE99NBDcvVRTp48We+8846Cg4NdbqOqqkqXX365PvroI6flfn5+uv/++zV//vxWjwUAAAAAAAAAAAAAAADoKKaT6wUWLFigDRs2aMaMGbLZbLJarUpISNB5552nV199VatXr241gUmSQkJCtHr1aq1YsULnnXeeEhISZLVaZbPZNGPGDG3YsIEEJgAAAAAAAAAAAAAAAHgEIzEBAAAAAAAAAAAAAAAAMBUjMQEAAAAAAAAAAAAAAAAwFUlMAAAAAAAAAAAAAAAAAExFEhMAAAAAAAAAAAAAAAAAU5HEBAAAAAAAAAAAAAAAAMBUJDEBAAAAAAAAAAAAAAAAMBVJTAAAAAAAAAAAAAAAAABMRRITAAAAAAAAAAAAAAAAAFORxAQAAAAAAAAAAAAAAADAVCQxwXTZ2dmaN2+ehg4dqrCwMMXExGjMmDF64oknVFlZaXZ48BEWi6Vdr/Hjx5sdKnq4o0eP6sMPP9QDDzygCy+8UHFxcY72NWvWrA5v7+OPP9a0adOUnJysoKAgJScna9q0afr444/dHzx6HXe0x+XLl7e7D12+fLlHjwc93/bt2/XnP/9ZkyZNcvRr4eHhSk9P1w033KANGzZ0aHv0kegKd7RH+ki4S2lpqV5//XXNmzdPZ599ttLS0hQVFSWr1aqEhASNHz9ejz/+uIqKitq1vU2bNunaa69VSkqKgoOD1a9fP51//vl67bXXPHwk6A3c0R7XrVvX7v5x/vz53js49Dr33HNPs/a0bt26NtfhHBJwv/Lycv3rX//SokWLdOWVV2rgwIGO38vU1FSP7JPzHd9RWVmpxx9/XGPGjFFMTIzCwsI0dOhQzZs3T9nZ2V3e/oEDB9p93tKZ67vwHm/dj+Rcwnd4sk1xTcm3uPveYXu89tprmjRpkvr166fg4GClpKTo2muv1ebNmz2yvw4xABOtWrXKiIyMNCQ5faWnpxt79+41O0z4AFdt8Oevs88+2+xQ0cO11r5mzpzZ7u3U19cbN954Y6vbmzNnjlFfX++5g0GP5472+NJLL7W7D33ppZc8ejzo2c4666x2taPrr7/eqKmpaXVb9JHoKne1R/pIuMtnn33WrnYUFxdnfPLJJ61u68EHHzT8/PxcbmPKlClGVVWVl44MPZE72mNGRka7+8cHH3zQuweIXmPHjh1GQEBAs/aUkZHhsj7nkIDnjB8/3uXvVUpKitv3x/mO79i7d68xZMgQl591ZGSk8cEHH3RpH/v372/3eUtHru/Cu7xxP5JzCd/i6TbFNSXf4s2/LZWVlcbkyZNd7s/Pz8+YP3++W/fZUQECTLJjxw5dddVVqqqqUnh4uP74xz9qwoQJqqqq0uuvv67/+7//0549ezRlyhRt375dERERZocMH3DzzTfrlltucVkeFhbmxWjQ2w0YMEBDhw7VmjVrOrzufffdp2XLlkmSTj31VN19990aPHiwsrKy9Pjjj2vHjh1aunSp4uPj9cgjj7g7dPRCXWmPjT799FMlJSW5LE9OTu70ttH75efnS5KSkpJ0xRVX6KyzztKAAQNUX1+vzZs36y9/+Yvy8vL08ssvq66uTq+++qrLbdFHoqvc2R4b0Ueiq2w2myZMmKBRo0bJZrMpMTFRDQ0Nys3N1dtvv62VK1eqsLBQF198sbZu3aqRI0e22MbixYu1YMECSdLgwYP1pz/9SSNGjFB+fr6efvppZWRkaPXq1Zo9e3a72jV8lzvaY6MXX3xRY8aMcVmekJDgiUNAL9fQ0KC5c+fKbrcrISFBR48ebXMdziEBzzEMw7EcExOj0aNHa9OmTSovL3f7vjjf8R1lZWWaMmWK9u7dK0n6zW9+o6uvvlohISHKyMjQo48+qtLSUl111VXauHGjTjnllC7v83//9391ySWXuCzv06dPl/cB9/PW/UjOJXyHt+9xc03Jt7jjXk1rZs+erY8++kiSNGHCBN1+++1KSkrSzp079cgjjygrK0vz589XYmKi5s6d65EY2mRqChV8WuPTzQEBAcamTZtalD/++OM8dQevoa3BWx544AHjgw8+MA4fPmwYRvMnedqbTf3TTz85niYdPXq0UVlZ2ay8oqLCGD16tKOPZUQ7uOKO9tj0iZD9+/d7Llj0elOmTDHeeOMNw263Oy0vKCgw0tPTHe1t/fr1TuvRR8Id3NUe6SPhLq7aYlPvvvuuo71NmzatRXlRUZERFRVlSDIGDBhgFBQUtNjH1KlT2zVaCXybO9pj05GYaGvwhCeffNKQZAwdOtT44x//2GZ74xwS8KzFixcbr776arPfnZSUFLePxMT5jm+5//77HZ/l448/3qJ848aNjr69KzMsNL1exmgnPZM37kdyLuFbvNGmuKbkW9xxr6Y9Pv/8c8d2p06d2uL7fUFBgTFgwABDkhEdHW0UFxe7bd8d4eemXCigQ7Zu3aovv/xSknTjjTdq3LhxLerMmzdPJ598siTp6aefVl1dnVdjBABPWLBggS666CL17du309t46qmnZLfbJUnPPvusQkJCmpWHhobq2WeflSTZ7XY9+eSTnQ8YvZo72iPgLh9++KGuvPJK+fv7Oy2Pi4vTX/7yF8fPb7/9ttN69JFwB3e1R8BdXLXFpi699FKddNJJkuT4vt3U0qVLdfz4cUnSwoULFRcX12Ifzz//vGNfTzzxRFfDRi/ljvYIeNLBgwd1//33S5JeeOEFWa3WNtfhHBLwrLlz5+qaa65RWlqaR/fD+Y7vqKur0zPPPCNJOvnkkzVv3rwWdc444wzdeOONkqT169dr27ZtXo0R3YO37kdyLuE7uMcNT/DWvZpFixZJkgICApqdEzWKi4vTwoULJUnHjh3T0qVLPRqPKyQxwRTvvfeeY/mGG25wWsfPz0/XX3+9pBO/JBkZGd4IDQC6NcMw9P7770uShg4dqtNPP91pvdNPP91x0+D9999vNmw3APRUEyZMcCxnZWW1KKePhDe11R4BMzQOUV9dXd2irPF7eGRkpKZPn+50/eTkZE2cOFGS9Pnnn6usrMwzgcIntNYeAU+69dZbVV5erpkzZ+rss89usz7nkEDvwfmO78jIyHAkrM2cOVN+fs5vd86aNcux/O6773ojNHQz3rgfybmEb+EeN3qqsrIyff7555KkiRMnupyGcPr06YqMjJRk3t9Okphgig0bNkiSwsLCNGrUKJf1ml5o2Lhxo8fjAoDubv/+/crPz5ekNi/GNpbn5eXpwIEDng4NADyupqbGsexsFAj6SHhTW+0R8LaffvpJ3377raQTF86bqq2t1datWyVJ48aNa3VUksb+saamRtu3b/dMsOj1WmuPgCe9+eab+vDDDxUTE+N4yrgtnEMCvQPnO76l8R6T1HrfPXr0aIWGhkriHpOv8sb9SM4lfAv3uNFTbdu2TbW1tZJa76usVqsjGXPbtm2mjCRGEhNM8eOPP0qS0tLSFBAQ4LJe0wtdjesAnvTWW29p2LBhCg0NVUREhIYMGaKZM2eSJY1uY9euXY7ltm4G0IfC22644QYlJSXJarUqLi5Op59+uv7f//t/ysvLMzs09BLr1693LDcOydwUfSS8qa32+HP0kfCEyspK7d27V3/961919tlnO6YvuOOOO5rV27Nnj+rr6yXRP8Jz2tsef+6+++5TSkqKgoKC1KdPH5166qm68847tWfPHi9Ejd7k2LFjuv322yU5n0bKFc4hgd6B8x3f0t6+OyAgwDGNoTs+62effVZpaWkKDg5WVFSUfvGLX+imm27SN9980+VtwzO8cT+ScwnfYsY9bq4pwR0601fZ7Xbt3bvXo3E5QxITvK66ulqFhYWS5HKYskZ9+vRRWFiYJCknJ8fjsQG7du3Sjz/+qKqqKpWXlyszM1Mvv/yyzjnnHE2bNs0xRC1gltzcXMdyW32ozWZzLNOHwhvWrVunQ4cOqa6uTkVFRfrqq6/08MMPKy0tTYsXLzY7PPRwDQ0Neuyxxxw/X3nllS3q0EfCW9rTHn+OPhLusnz5clksFlksFoWFhSk9PV3z5s3TkSNHJEn33nuvZsyY0Wwd+kd4Smfa489t2rRJBw8eVG1trY4dO6Zvv/1WTz31lE4++WTNnz+faTbQbnfffbcOHz6sX/3qV7rxxhvbvR59JNA78LvsWxo/77CwMEVHR7dat/HzLigoaDaibmd88803ysrKUk1NjUpLS7Vr1y4tXrxYo0aN0k033dTl7cO9vHU/kv7Hd5h1j5trSnCHntRXuU4PBDyk6RzT4eHhbdYPCwtTRUWFysvLPRkWfFxoaKguvvhinXvuuRo6dKjCw8NVUFCg9evX64UXXlBRUZHee+89XXLJJfrss88UGBhodsjwUR3pQxtPkCXRh8KjBg0apOnTp2vcuHGOk9t9+/bpnXfe0dtvv63q6mrddNNNslgsmjt3rsnRoqd68sknHVMDTJ8+3elwzfSR8Jb2tMdG9JHwllNOOUVLlizRmDFjWpTRP8LbWmuPjRITEzV9+nSdeeaZGjRokAICAnTw4EF9+OGHevnll1VXV6cFCxaotrZWjzzyiBejR0/05ZdfaunSpQoICNALL7wgi8XS7nXpI4Hegd9l39L4ebf3HlOj8vJyBQUFdXh/0dHRmjZtmsaPH68hQ4YoODhYhw4d0po1a7Rs2TKVl5dr8eLFKisr04oVKzq8fXiGt+5H0v/4Dm/f4+aaEtypJ/VVJDHB66qrqx3Lrc1L3ajxhLKqqspjMQF5eXlOn9g477zz9Lvf/U4XXnihduzYofXr1+vvf/+7fv/733s/SEAd60ObfiGnD4WnTJs2TTNnzmxxk2DMmDG66qqr9OGHH2r69Omqq6vTnXfeqYsvvlj9+vUzKVr0VOvXr9e9994rSUpISNDf//53p/XoI+EN7W2PEn0kPOPSSy/V6NGjJZ3ov7KysvTmm2/q3Xff1TXXXKOnnnpKF110UbN16B/hKZ1pj9KJfjA7O7vFA0L/9V//pUsvvVRz587VpEmTdPz4cT322GO66qqrNHLkSK8cE3qe2tpazZ07V4Zh6M4779Tw4cM7tD59JNA78LvsWxo/747cY5I693knJSUpLy9PoaGhzd4/9dRTNXnyZN16662aOHGiDh48qFdffVVXXXWVLr744g7vB+7nrfuR9D++w5v3uLmmBHfrSX0V08nB64KDgx3LtbW1bdZvHH4zJCTEYzEBrQ0527dvX7399tuOi6vPPvusl6ICWupIH9p0+GL6UHhKVFRUq085X3TRRXrggQckSZWVlVq2bJm3QkMv8cMPP2jatGmy2+0KDg7WW2+9pYSEBKd16SPhaR1pjxJ9JDwjOjpaw4cP1/DhwzVmzBhdffXVWrlypV5++WXt27dPl1xyiZYvX95sHfpHeEpn2qN04qnO1kY4Hjt2rP72t79JkgzDcCwDzjzyyCPavXu3BgwYoAcffLDD69NHAic0Tg/alZezPt9b+F3unjzVrho/747cY5I693lbrdYWCUxNDRkyRP/85z8dP3P/oPvw1v1I+h/f4c173FxTgrv1pL6KJCZ4XUREhGO5PcOPVVRUSGrfsHyApwwaNEjnnXeeJCkzM1P5+fkmRwRf1ZE+tLH/lOhDYa65c+c6vnCtX7/e5GjQk+zfv1+TJk1SSUmJ/P399frrr+vXv/61y/r0kfCkjrbH9qKPhLtcd911uuKKK9TQ0KDbbrtNxcXFjjL6R3hba+2xva6++mpFRkZKon+Ea7t379ajjz4q6cRN46bTHrQXfSTQO/C77FsaP++O3GOSPPd5n3XWWRo2bJgkacOGDWpoaPDIftAx3rofSf/jO7rbPW6uKaEjelJfxXRy8Lrg4GDFxsaqqKhIubm5rdYtKSlx/JI0zvUJmGXYsGH66KOPJJ2Yfi4pKcnkiOCLkpOTHctt9aE5OTmOZfpQmCkhIUGxsbEqLCxUXl6e2eGgh8jPz9fEiROVn58vi8WiF198UZdcckmr69BHwlM60x7biz4S7nTJJZfozTffVEVFhT755BPNmDFDEv0jzOGqPbZXQECA0tPTtX37dvpHuPTkk0+qtrZWgwYNUmVlpV5//fUWdb7//nvH8hdffKHDhw9LkqZOnaqwsDD6SOA/fvzxxy5vIzEx0Q2RdA6/y92Tp9pVcnKyvvrqK1VUVOjYsWOtzrTQ+HnHx8c3mx7H3YYNG6Zdu3apurpaRUVFio+P99i+0D7euh9J/+M7uts9bq4poSN+3lc1Tg3vjNl9FUlMMMWwYcP05ZdfKjMzU3a7XQEBzpvi7t27Hcsnn3yyt8IDnGpt2EbAWxqf6JGa95HO0IeiO6EPRUcUFhbqvPPO0759+ySdeKr++uuvb3M9+kh4QmfbY0fQR8Jdmt4oyc7Odiynp6fL399f9fX19I/wGlftsSPoH9GWxmkO9u3bp2uuuabN+g899JBjef/+/QoLC+McEviPoUOHmh1Cl3C+0z15ql0NGzZM77zzjqQTn+fpp5/utJ7dbldWVpYkz3/WnLd0T964H8m5hG/pbve46XvQXp3pqwICAjRkyBCPxuUM08nBFGeeeaakE0ORff311y7rNR367le/+pXH4wJas2vXLscyozDBLAMHDnS0v7aGB/3Xv/4lSerfv79SU1M9HRrgUkFBgQoLCyXRf6Jtx48f1/nnn+/4u/vYY4/p1ltvbde69JFwt660x/aij4Q7NX3ysulw31arVWPHjpUkbd68WbW1tS630dh/BgUFtfpUHtAWV+2xvex2u/bs2SOJ/hGexTkk0DtwvuNbGu8xSa333du3b3eMhOLpe0yN3xuDgoIUGxvr0X2h/bxxP5JzCd/Sne5xc00JHTFmzBhZrVZJrfdVtbW12rJli2OdwMBAr8TXFElMMMWll17qWH7ppZec1mloaNDLL78sSYqOjtaECRO8ERrg1P79+/XZZ59JkgYPHqz+/fubHBF8lcVicUxfs3v3bseJxM9t2bLFkSl9ySWXkI0PUy1ZskSGYUiSzj77bJOjQXdWWVmpKVOm6JtvvpEk3XfffbrnnnvavT59JNypq+2xvegj4U5vvfWWY3nEiBHNyhq/h5eWlmrlypVO18/NzdXatWslSeeee64iIiI8Eyh8QmvtsT3eeOMNHT9+XBL9I1xbvny5DMNo9fXggw866mdkZDjeb7xxyDkk0HtwvuM7xo8fr6ioKEnSP/7xD8d3qp9bvny5Y3natGkei2fjxo364YcfJJ1IcPDz4/Zrd+GN+5GcS/iW7nSPm2tK6IiIiAide+65kqS1a9e6nBJx5cqVKi0tleTZv52tMgCTnHXWWYYkIyAgwNi0aVOL8scff9yQZEgyHnzwQe8HCJ+xatUqo66uzmX54cOHjVNPPdXRHv/yl794MTr0dvv373e0rZkzZ7ZrnZ9++snw9/c3JBmjR482Kisrm5VXVlYao0ePdvSxe/bs8UDk6I062h73799vfPPNN63W+eCDDwyr1WpIMkJCQozc3Fw3RYvepqamxpg0aZKjDd5+++2d2g59JNzBHe2RPhLu9NJLLxlVVVWt1vnrX//qaLMDBw407HZ7s/KioiIjKirKkGSkpKQYhYWFzcrtdrsxdepUxzYyMjLcfRjoJbraHouLi9tsX1999ZURHR1tSDIsFouxfft2d4QOH/Xggw+22bdxDgl4X0pKiuO8pD2aXrM4++yzndbhfMe33H///Y7P8vHHH29RvmnTJiMgIKDVNmMYhmMbrtriu+++azQ0NLhcf+/evcaAAQMc23nnnXc6eijwsK7ej8zIyGjzminnEr7F022Ka0rozL3Dl156qc3cis8//9xR5+KLL25x7aigoMDxNy06OtooLi7u4pF0jvNJGgEvePrpp/WrX/1KVVVVmjRpkv70pz9pwoQJqqqq0uuvv64lS5ZIOjGX9bx580yOFr3Z7373O9XV1emyyy7TuHHjlJqaqpCQEBUWFmrdunVavHixYzjGM8880+1TiMC3bNiwQZmZmY6fG9uWJGVmZjZ7OkiSZs2a1WIb6enpuuuuu/TYY49p+/bt+tWvfqV77rlHgwcPVlZWlhYuXKgdO3ZIku666y5T5qtFz9DV9njgwAFNmDBB48aN09SpUzVy5EglJCRIkvbt26e3335bb7/9tuNpkEWLFjGSHVy65pprtGbNGknSOeecoxtvvFHff/+9y/pWq1Xp6ekt3qePhDu4oz3SR8Kd5s+fr3nz5umyyy7TmWeeqcGDBys8PFxlZWXauXOnVqxYoY0bN0o60R6XLFkif3//ZtuIiYnRwoULddNNNyk7O1unnXaa7rvvPo0YMUL5+fl66qmnlJGRIenE78D48eO9fZjoIbraHo8fP64JEybol7/8pS699FKNGjVKiYmJ8vf318GDB/Xhhx/qlVdecUwD9Ic//EGjRo0y5VjhOziHBDwrMzNTGzZsaPZeeXm549+fX3+44IIL1K9fvw7vh/Md33LXXXfpjTfe0J49e3T33XcrMzNTV199tUJCQpSRkaFHHnlEdrtdISEheuqppzq9n2nTpiktLU3Tp0/X2LFjlZycrKCgIB06dEiffvqpli1b5mjPV155paZPn+6mI4S7eON+JOcSvsXTbYprSr7HHfcO2+Occ87R1Vdfrddff12rVq3SeeedpzvuuENJSUnauXOnHn74YR08eFCStHDhQvXp06dT++kyU1KngP9YtWqVERkZ6cj4+/krPT3d2Lt3r9lhopdrfOqnrddll11mlJSUmB0ueriZM2e2q701vlypr683Zs+e3eq6N954o1FfX+/Fo0NP09X22PSJkdZeoaGhxuLFi004QvQkHWmLauNpXfpIdJU72iN9JNypvd9ZkpOTjTVr1rS6rQceeMCwWCwutzF58uQ2R9mBb+tqe2z6RGlrL39/f2P+/PmtjnwAtEd7RmIyDM4hAU9qOjJAe17OflfbMxJTI853fMfevXuNIUOGuPysIyMjjQ8++KDVbbR1naG97fbmm282qqurPXCUcIeu3I9sz0hMhsG5hK/xZJvimpLvcce9w/aMxGQYJ0aGmzx5sstt+/n5mT5LFiMxwVRTp07Vv//9bz399NNavXq1cnNzZbValZaWpiuuuEK33XabQkNDzQ4Tvdw//vEPrV+/Xps3b9a+fftUWFio0tJShYeHy2az6YwzztDMmTM1btw4s0MFHPz8/LRs2TJddtllWrJkibZt26bCwkLFxcVpzJgx+u1vf6sLL7zQ7DDRy40aNUr//Oc/tXnzZm3fvl2HDh1SYWGh7Ha7+vTpo1/84hc699xzNWfOHMeTIoA30EeiO6CPhDt9+umnWr16tTZu3KjMzEwdOXJERUVFCgkJUUJCgk455RRddNFFuvLKK9v8Dr1gwQKdf/75eu655/Tll1/qyJEjio6O1siRI3XDDTfommuu8dJRoafqantMSkrSW2+9pc2bN2vr1q3Ky8tTYWGhqqurFRUVpZNOOknjx4/XnDlzlJqa6v0DhM/iHBLoPTjf8R1paWnasWOHnnvuOb311lvKzMxUbW2tbDabJk+erNtvv10pKSld2seqVau0efNmffXVV8rOzlZhYaEqKioUGRmpQYMG6ayzztLs2bM1fPhwNx0VPMEb9yM5l/AtnmxTXFOCJ4WEhGj16tV69dVXtXz5cn333Xc6duyY+vbtq7POOku33Xab6ffELYbxn3HGAAAAAAAAAAAAAAAAAMAEfmYHAAAAAAAAAAAAAAAAAMC3kcQEAAAAAAAAAAAAAAAAwFQkMQEAAAAAAAAAAAAAAAAwFUlMAAAAAAAAAAAAAAAAAExFEhMAAAAAAAAAAAAAAAAAU5HEBAAAAAAAAAAAAAAAAMBUJDEBAAAAAAAAAAAAAAAAMBVJTAAAAAAAAAAAAAAAAABMRRITAAAAAAAAAAAAAAAAAFORxAQAAAAAAAAAAAAAAADAVCQxAQAAAAAAAAAAAAAAADAVSUwAAAAAAAAAAAAAAAAATEUSEwAAAAAAAAAAAAAAAABTkcQEAAAAAAAAAAAAAAAAwFQkMQEAAAAAAAAAAAAAAAAwFUlMAAAAAAAAAAAAAAAAAExFEhMAAAAAAAAAAAAAAAAAU5HEBAAAAEDLly+XxWKRxWLRgQMHzA7HK1JTUx3H3PhKTU01Oyyn5s+f3yJWi8WidevWmR0aAAAAAAAAAABuQRITAAAA0IMdOHDAaXJLR18AAAAAAAAAAABmIokJAAAAgE+75JJLtHPnTu3cuVNr1qwxOxynbrnlFkeML774otnhAAAAAAAAAADgdgFmBwAAAACg8/r376+dO3e6LB8xYoQkafTo0XrppZdc1hs+fLhmzZrl7vB6hOjoaA0fPtzsMFqVkJCghIQESVJhYaHJ0QAAAAAAAAAA4H4kMQEAAAA9WGBgYLsScMLCwrp9og4AAAAAAAAAAPBdTCcHAAAAAAAAAAAAAAAAwFQkMQEAAADQ8uXLZbFYZLFYdODAgRbl48ePl8Vi0fjx4yVJmZmZuummmzRo0CCFhIQoNTVVN954o7Kzs5ut9/333+uGG27QoEGDFBwcLJvNpptvvllHjx5tV1zvvfeerrjiCg0YMEDBwcGKjo7W6NGjtWDBApWUlHT1sNstNTVVFovFMeXeTz/9pN/85jdKTU1VUFCQ+vbtq2nTpmnLli2tbqe6ulrPPPOMxo8fr/j4eAUGBiomJkYnnXSSLrzwQv31r391+v8PAAAAAAAAAEBvx3RyAAAAADpk7dq1mj59usrKyhzvZWdn68UXX9SHH36o9evXa+jQoXrttdc0a9Ys1dbWOurl5ubqhRde0Mcff6xNmzYpKSnJ6T5KSkp0+eWX64svvmj2fk1Njb7++mt9/fXXev755/X+++/r9NNP98yBuvDuu+/q2muvVWVlpeO9o0eP6r333tMHH3ygFStW6Kqrrmqx3qFDhzRx4kTt2rWr2fslJSUqKSnRnj179Mknnyg/P1+LFi3y+HEAAAAAAAAAANCdMBITAAAAgHbLz8/XlVdeqejoaD377LP66quv9OWXX+qOO+6QxWLR0aNHNWfOHG3btk3XX3+9Bg8erKVLl2rr1q3KyMjQddddJ+lE0tP//M//ON1HTU2NJk6cqC+++EL+/v667rrr9Nprr2nLli368ssv9fDDDys2NlZHjx7V5MmTW4z+5Ek7d+7UjBkz1LdvX/3tb3/Tli1btHnzZs2fP1/BwcGqr6/X3LlzVVBQ0GLd3/3ud44EpmuvvVYrV67Uli1btG3bNq1atUoPPPCARo4c6bVjAQAAAAAAAACgO2EkJgAAAADttnfvXg0ZMkQbN25UfHy84/0zzzxTAQEBWrRokTZu3KgpU6Zo7Nix+uyzzxQaGuqoN378eFVXV+utt97SO++8o4KCgmbbkaQ///nP+uabbxQdHa21a9dq1KhRzcrPPPNM/fd//7fGjRunQ4cO6U9/+pNWrFjh2QP/j2+++UajRo3SF198ocjISMf7p59+utLS0nTttdeqtLRU//znP3XnnXc6yqurq7Vq1SpJ0rx585yOtDR16lQtWLBAxcXFnj8QAAAAAAAAAAC6GUZiAgAAANAhzzzzTIvEI0m65ZZbHMuFhYVaunRpswSmRjfffLMkyW63a/Pmzc3KysvL9dxzz0mSHnrooRYJTI1SUlJ0//33S5LeeustVVRUdO5gOuHFF19slsDUaMaMGY7p8b788stmZcXFxaqrq5Mk/frXv251+zExMW6KFAAAAAAAAACAnoMkJgAAAADtFh0drfPPP99p2cCBAxURESFJ+uUvf6mTTz7Zab2mU6bt27evWdn69et1/PhxSdLll1/eaiyNyUB1dXX6+uuv23cAXTRixAj98pe/dFpmsVh06qmnSmp5XLGxsbJarZKkV155RXa73bOBAgAAAAAAAADQw5DEBAAAAKDdhgwZIovF4rI8OjpakpSent5mHUkqKytrVrZ9+3bHcmJioiwWi8vX8OHDHXUPHz7cwSPpnKFDh7Za3jiK0s+PKygoSFdddZUk6e2331ZaWpruvvtuffTRRzp27JhHYgUAAAAAAAAAoCchiQkAAABAuzmbHq4pPz+/Nus11pGk+vr6ZmVHjx7tVFyVlZWdWq+j2nv8Pz8uSfrb3/6mqVOnSpKys7P1xBNPaMqUKYqNjdWYMWP0xBNPOEahAgAAAAAAAADA1wSYHQAAAAAANGqa/PPNN98oMDCwXeslJyd7KiS3iYyM1KpVq7R161a9+eabWrdunb799lvV19dr+/bt2r59uxYtWqT33ntP48aNMztcAAAAAAAAAAC8iiQmAAAAAN1GbGysYzk+Pr5HJCd11NixYzV27FhJJ6adW7dunZYvX66VK1fq6NGjuuyyy5SVlaWQkBCTIwUAAAAAAAAAwHuYTg4AAABAt3Hqqac6ljdu3GhiJN4RERGhqVOn6p133tHvf/97SdKhQ4e0YcMGkyMDAAAAAAAAAMC7SGICAAAA0G1MnDhRoaGhkqRnnnlGhmGYHJH3nHvuuY7lwsJCEyMBAAAAAAAAAMD7SGICAAAA0G1ER0frtttukyRt2rRJd955pxoaGlzWP3LkiJYuXeqt8Dpt3759Wr9+fat11qxZ41geOHCgp0MCAAAAAAAAAKBbCTA7AAAAAABo6s9//rPWr1+vr776Sk8//bTWrVun3/zmNzrllFMUFhamkpIS/fDDD1q7dq0+/vhjjRgxQnPmzDE77FYdPHhQEyZM0LBhwzRt2jSNHj1a/fv3lyTl5OTojTfe0JtvvilJOuWUU3TaaaeZGS4AAAAAAAAAAF5HEhMAAACAbiUoKEifffaZZs2apZUrV+q7775zjM7kTGRkpBej65pdu3Zp165dLsuHDh2qlStXymKxeDEqAAAAAAAAAADMRxITAAAAgG4nIiJC77zzjjZs2KB//OMf+vLLL5Wfn6+qqipFRkZq8ODBGjt2rKZMmaJJkyaZHW6bzjrrLK1bt06ffvqptmzZopycHB05ckTV1dWKiYnRyJEjNX36dM2aNUtBQUFmhwsAAAAAAAAAgNdZDMMwzA4CAAAAALwtNTVV2dnZmjlzppYvX252OO22bt06TZgwQZKUkZGh8ePHmxsQAAAAAAAAAABuwEhMAAAAAHzasWPH9P3330uSrFar0tPTTY6opaNHj+ro0aOSpP3795scDQAAAAAAAAAA7kcSEwAAAACf9v777+v999+XJKWkpOjAgQPmBuTE888/rwULFpgdBgAAAAAAAAAAHuNndgAAAAAAAAAAAAAAAAAAfJvFMAzD7CAAAAAAAAAAAAAAAAAA+C5GYgIAAAAAAAAAAAAAAABgKpKYAAAAAAAAAAAAAAAAAJiKJCYAAAAAAAAAAAAAAAAApiKJCQAAAAAAAAAAAAAAAICpSGICAAAAAAAAAAAAAAAAYCqSmAAAAAAAAAAAAAAAAACYiiQmAAAAAAAAAAAAAAAAAKYiiQkAAAAAAAAAAAAAAACAqUhiAgAAAAAAAAAAAAAAAGAqkpgAAAAAAAAAAAAAAAAAmIokJgAAAAAAAAAAAAAAAACmIokJAAAAAAAAAAAAAAAAgKlIYgIAAAAAAAAAAAAAAABgKpKYAAAAAAAAAAAAAAAAAJiKJCYAAAAAAAAAAAAAAAAApiKJCQAAAAAAAAAAAAAAAICpSGICAAAAAAAAAAAAAAAAYCqSmAAAAAAAAAAAAAAAAACYiiQmAAAAAAAAAAAAAAAAAKYiiQkAAAAAAAAAAAAAAACAqf4/92zrouLDywwAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p14.plot(sampling_rate=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p14.plot(sampling_rate=100)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Drag Shape" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This version of the driver includes a fix to the formula that generates the DRAG pulse." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACTEAAAPkCAYAAAB7yuiYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd3wUdf7H8fdueu8JAUIJvSldQOlg74ddKaKep57lZ29YsJyed556np4V5GynJ54FFemCNKX3GmpII70nO78/YuZ2yW6yKZtN4PV8sA+mfOc7353M7szsfObztRiGYQgAAAAAAAAAAAAAAAAAvMTq7QYAAAAAAAAAAAAAAAAAOLURxAQAAAAAAAAAAAAAAADAqwhiAgAAAAAAAAAAAAAAAOBVBDEBAAAAAAAAAAAAAAAA8CqCmAAAAAAAAAAAAAAAAAB4FUFMAAAAAAAAAAAAAAAAALyKICYAAAAAAAAAAAAAAAAAXkUQEwAAAAAAAAAAAAAAAACvIogJAAAAAAAAAAAAAAAAgFcRxAQAAAAAAAAAAAAAAADAqwhiAgAAAAAAAAAAAAAAAOBVBDEBAAAAAAAAAAAAAAAA8CqCmAAAAAAAAAAAAAAAAAB4FUFMAAAAAAAAAAAAAAAAALyKICYAAAAAAAAAAAAAAAAAXkUQEwAAAAAAAAAAAAAAAACvIogJAAAAAAAAAAAAAAAAgFcRxAQAAAAAAAAAAAAAAADAqwhiAgAAAAAAAAAAAAAAAOBVBDEBAACgxViyZIksFossFovGjBnj7eY0is1m06BBg2SxWNS/f3/ZbDZvNwkAAKDZ/frrr/Lx8ZHFYtFf//pXbzenRRo+fLgsFot69+6t8vJybzcHTeBkuq4B0LJcffXVslgsio+PV05OjrebAwAA0OQIYgIAADiFjBkzxvwx3dkrLCxMnTp10iWXXKLXXntNubm53m5yq/XWW29p3bp1kqQXXnhBVmvdp96ZmZl66aWXNGLECCUmJiowMFAdO3bU+eefrzlz5nj9plZ2drY+++wz3XbbbRoxYoTi4+Pl7++v8PBwdenSRVdffbU+/PBDr7dTksrKyrR27Vq98cYbuvHGG9WvXz/5+vqa+/rUqVO93cQ6rVu3zqHNFotFS5YsafZ2bN++Xffff79OO+00RUdHKyQkRN27d9eUKVO0cOHCBtXpiX29rKxMc+bM0fnnn6+OHTsqMDBQiYmJGjFihF566SVlZmY2qK2NZRiG5s6dq0mTJqlLly4KCgpSXFycBg8erKeeekoHDx5sUL1r167Vbbfdpt69eys8PFzh4eHq3bu3brvtNq1du7ZBdR48eFBPPvmkBg0apLi4OAUFBalLly6aNGmS5s6dK8MwGlRvY7Wm/WXhwoWaPHmyunfvrpCQEEVHR+u0007T/fffrx07djSozta0fne15OPdk08+6fI8ydfXVzExMUpOTtagQYM0depU/f3vf9f69eu91t6WzjAM3XHHHbLZbOrYsaNuv/12l2ULCwv1zTff6J577tHo0aOVmJiogIAAhYSEqGPHjrr00kv1z3/+U4WFhc34DpyrrKzUpk2b9O677+oPf/iDBg8eLH9//wYHrfzpT3+SVHXMfe211zzQ4obxxDlAU+G6pmnNmjWr1u3ZkJc3zltbg6lTp7rcZv7+/oqLi1PXrl01bNgw/f73v9dbb72lnTt31ns9nTp1crkeq9WqiIgIde7cWZdccoleeeUVZWVlNeg9nHhdNWnSJHPeqFGj6t3ualu3bq11f2rMvjlr1qwGt6sxmuq64JlnnpGvr68yMjI0Y8YMD7caAADACwwAAACcMkaPHm1IcvsVHh5uzJ49u9nat3jxYnPdo0ePbrb1NrX8/HwjLi7OkGQMGzbMrWW+/vprcxlXr4EDBxo7d+70cOtrys/PNy688ELD39/frf2mU6dOxtKlS5u9ndVee+21Ots6ZcoUr7XPHeXl5caAAQNqtHvx4sXN2o5nnnnG8PPzq3VbXnPNNUZeXp7bdXpiX9++fbvRv3//WuuMj483vv3224ZshgY7cuSIMW7cuFrbFRoaarz//vtu11laWmrceeedhsVicVmnxWIx7r77bqOsrMztet955x0jJCSk1rZOmDDBSE1NbcCWaLjWsr/k5uYaV111Va11+vn5Gc8991xDNkOLX399tOTjnWEYxhNPPFGvc6XqV//+/Y0333zTqKio8Eq7W6pPP/3U3EZvvvmmy3LXXXedERwc7Na2jo2NNf7zn/8047twNHfu3Drb2pDz2FGjRhmSjMjISCM7O7vJ211fnjgHaEpc1zSt999/v0HffbW9mvu8tbWYMmVKg7bnyJEjjU8++cTt9XTs2LFe9YeEhNT6Pe3qPZx4XfXVV1+Z8ywWi7Fv3776bB7T/fffb9bTqVMnw2azOcxvzL5Zn3PvptLU1wWTJ082JBm+vr7Gnj17PNt4AACAZuYrAAAAnJKGDBmioUOHmuOGYSgnJ0dr167V7t27JUl5eXmaMmWKSkpKdMstt3irqa3OK6+8ooyMDEnSQw89VGf5+fPn67LLLlNFRYUkKTg4WOPHj1dcXJz27t2rZcuWyTAMrVu3TuPHj9fq1avVtm1bj74HewUFBfrmm28cpiUkJGjw4MFq06aNysvLtWHDBm3atEmSlJKSovHjx2vu3Lm68MILm62d1TIzM1VWVtbs621KL730ktcze8yYMUMzZ840xxMTEzVy5EgFBgbq119/1datWyVJH3/8sbKysvTtt9/K17f2S0xP7OuHDx/W+PHjdfToUUkyn/ru0qWLMjIytGDBAhUXFys9PV2XXnqpvv/+e40bN64xm8YteXl5Ouecc7RlyxZz2tChQ9WnTx/l5uZq0aJFysnJUUFBgaZNmyar1arJkyfXWe/NN9+sDz74wBxPTk7WsGHDJEmrVq3Svn37ZBiG/va3vykvL0/vvvtunXW+9957uummm8zxyMhIjRs3ThEREdqyZYuZ2WnBggU655xztGLFCoWGhrq9LRqqtewv5eXluuyyy7Ro0SJzWt++fTVw4ECVlJTop59+UmpqqsrLy/XII4+ovLy8SZ+a9/b666OlH+9O1LZtW1122WUO0/Lz85WTk6OUlBRt2bLF7C52w4YNuvXWWzVr1izNmTNHXbt29UaTW5TKyko98cQTkqrOG2rLgvj555+rtLTUHI+KitLQoUPVtm1bGYah7du3a82aNTIMQ5mZmfrd736nN954Q7feequn30YNOTk5KioqavJ6H3roIS1btkw5OTl66aWX9MwzzzT5OtzliXMAT+K6pvF69epVa6Y0SZo7d655/DxxmzvTrl27Jmvfyapnz54aP368OW4YhvLy8pSTk6Ndu3Zp9+7dZibMn376ST/99JM++OADvffee0pISHB7PePHj1fPnj0d1pOdna21a9dqz549kqqy4d16660qLS3VnXfe2eD3dN555yk+Pl7p6ekyDENz5syp93mHzWbThx9+aI5PnjxZFovFZflLL720Xvtbr1696tWexvLEdcGDDz6oDz74QBUVFXriiSf0r3/9y9NvAwAAoPl4JXQKAAAAXmH/xPITTzzhstwXX3xhREREmGUDAgKMQ4cOebx9re2JZWeKi4vNDBMdOnQwKisray2fmZlpREZGmu97/PjxRkZGhkOZDRs2GB06dDDLjBs3zpNvoYbU1FRDkhEVFWXcddddxoYNG5yW++mnn4zOnTs7PPF+7NixZm2rYfwvi0ZSUpJx+eWXG88//7yxcOFCY9KkSS6fGG5Jdu3aZQQGBhqSjGuvvdYrT7QvWLDAYb3333+/UVpa6lDmo48+MtspyXjqqadqrdNT+/rIkSPN8h07dqyxf2ZkZBjjx483y0RHRzdLhosbbrjBYZ0LFy50mF9QUGBcd911Zhl/f39j9+7dtdb57rvvmuWtVqvx8ssvO3zHVFZWGi+//LJhtVrNcnVlndixY4dDpo3rrrvOKCgocCizcOFCIyoqyiwzbdq0em6N+mtN+8vjjz9ulg8MDDQ+/vhjh/mlpaUO2QQsFouxZMkS9zaEG7y9fne1huOdYThmYqrrXCQvL8/46KOPjMGDBzt8Z0ZFRXktk1RL8vnnn5vb5NFHH621bEBAgBEcHGxMnz7dWLFihdPzpy1btjhkUfPx8TE2bdrkqea7VJ2xJiEhwbjwwguNp556ypg3b55x1113Neo81mazmedRkZGRNb6Lm4snzgE8geua5ufuNkftastidKKsrCzjzTffNHr06OHwuezUqZORnp5e67L2mZhqy+7z1VdfOZznBQYGGocPH27Ue7j77rvN+d26dau1Lmd++OEHh/frLNOQN66RGsoT1wWG8b/PpI+Pj5GSkuKp5gMAADQ7gpgAAABOIfX54fmbb75x+GHw4Ycf9nj7ToYf+9955516/bhvf2O5S5cuRmFhodNyGzdudAg0+OGHH5q45a5lZWUZM2bMMHJzc+ssu3//fiM8PNxs50MPPdQMLXSUkpLiNHiqPjcMvMVms5mf06ioKCMtLc0rP9APGTLEXOfVV1/tstwbb7xhlgsLC6sRkGDPE/v6t99+6/Bjv6ub2QUFBUZycnKzfZ9t3rzZIZDo+++/d1qusrLSGDFihFnummuucVlnSUmJkZSU5NZn68EHH3QI1Dnx5rO9K664wix75plnugy8nDdvnkPgwLZt21zW2RRay/6Slpbm0A1fbd2w2Hf3Nnz4cJfl6sPb66+P1nC8M4z6BTFVs9lsxnPPPWf4+Pg43LTNycnxbGNbuLPOOsvcHnV1J3Tfffe5Ffh8/PhxhxvztR2jPCU1NdU4cOBAjekN2XdONHPmTLOOv//9741sacN44hzAE7iuaX4EMTWNhlyTlJWVGX/84x8d9uMzzzzTKC8vd7mMu0FMhmEY//3vfx3qfvbZZxv1HtavX+9Q388//+zO2zTZB/ScddZZTsu0liAmT1wXVJszZ45Z/r777mvqpgMAAHiNVQAAAIATF1xwgU4//XRzfMGCBV5sTeth33XTVVddVWvZ8vJyvf322+b4008/reDgYKdlTzvtNE2ZMsUcf/311xvZUvdFR0frqaeeUnh4eJ1lO3Xq5NC1y7fffuvJpjnVsWPHenWv0JK8/fbbWrp0qSTpxRdfVHx8fLO3Ye3atWb3YVarVS+++KLLsr///e/VrVs3SVVdLM2ZM8dpOU/t6/bzpkyZon79+jktFxISoqefftoc/+c//2l2Z+UJb7zxhtnF1MSJE3XOOec4LXfi9v33v/+tzMxMp2W/+uorHTp0SJIUERGhxx9/3OX6Z8yYYX5eDxw44PJzmJaWpv/85z/m+Isvviir1fnPBOedd54mTJggqaqLqDfffNPl+hurNe0vs2fPVmFhoSSpe/futXZRZL99V65c2SRdRnp7/e5qLce7hrJYLHr44Yf1/PPPm9N2796tV155xYut8q5du3Zp+fLlkqq6zOncuXOt5f/85z+7deyOiorSgw8+aI7PmzevcQ1tgDZt2qhDhw4eqfvKK680h9977z2PrKM2njgHaAm4rkFr5+fnp1dffVW33XabOW3FihX66KOPmqT+iy++2OF7etmyZY2qr3///jrttNPMcfuukOtSUFCguXPnmuP25wStkSeuC6pdcsklCggIkCSzazkAAICTAUFMAAAAcGnEiBHm8L59+xzmTZ06VRaLRRaLRbNmzaqzrlmzZpnlp06d2ui27dixQw888ICGDRum2NhY+fv7KzAwUPHx8Ro0aJCmTZum2bNnKzs7u866ysvLNWfOHF155ZVKTk5WWFiYQkJC1LlzZ11zzTWaO3euDMOos559+/Zp5cqVkqpuJvfq1avW8kuWLFFOTo4kKSwsTL/73e9qLW+/3ebPn2/euG5pzjzzTHM4JSXFew1pZY4ePaoHHnhAkjRy5EhNnz7dK+348ssvzeEJEyYoKSnJZVmLxeJwY8H+hoM9T+zrBQUFWrhwoTk+bdq0Wuv83e9+p9DQUEnS8ePHG31zxhXDMPTVV1+53a4zzzxTXbt2lVQVHGS/rD37v8tVV13lMgBEkoKDgx1uhLv6u3z11VfmTZXu3bs7fOc7Y/93sW9PU2tN+4v9dqg+LrrSoUMHjRs3zhx39XepD2+v310n6/HuRPfdd5/DMfCVV15RQUGB07LV50T2f7ONGzfqrrvuUt++fRUdHS2LxaJLL720xrK//vqrnn/+eV144YVKTk5WaGio/P39lZCQoBEjRujRRx/VwYMH693+zz77TBdddJHatWungIAAtW/fXhMnTtTs2bPNG6Punv99+OGH5rCz99AY9ts4Ly9Px48fb9L6val79+7q3bu3JGndunXavn17s67fE+cALQXXNfW7rqmvsrIyxcXFmdul+prIHaNHjzaXe/XVVx3mOdvW5eXlmj17tiZOnKj27dub31eXXnqp/vvf/9a77YcOHdLMmTM1cuRItW3bVgEBAYqOjtaAAQN03333adeuXfWu01P++te/OgQbPf/88+a5XGP179/fHD569Gij67P/fvj3v/+tsrIyt5b7/PPPVVRUJEkKCgpyOKdtbTx1XVAtLCxM48ePlySlp6frxx9/bGSLAQAAWgaCmAAAAOBSVFSUOZyXl+fFljh68skn1bdvX/35z3/W6tWrlZWVpfLycpWWliojI0Pr1q3TrFmzNHXqVP3xj3+sta4lS5aoV69emjx5sj777DPt379fBQUFKioqUkpKij755BNdfvnlGjFihI4cOVJrXd988405bH+j2JXFixebw8OHDzefonRl6NChZuBCSUlJvW4ONCf7G7KVlZVebEnrcvvttys3N1f+/v765z//WWswgifZ75djxoyps/zYsWPN4Z9//lmlpaW11tlU+7r9ukJCQjRkyJBa6wwMDNTw4cPN8UWLFtVavqF2796tw4cPm+P13Yau2tWYv4sn6jx48KD27NlT5zIN0Vr2l5KSEq1atcocb6q/i7u8vf76OFmPdyeyWCz6v//7P3P8+PHjbt9QfPLJJzVo0CC9+uqr2rp1q8tghaFDh2rw4MF65JFH9O2332r//v0qLCxUeXm50tPTtXLlSj333HPq2rVrrVl07OXm5urss8/WlVdeqW+++UZHjx5VWVmZjhw5ogULFmjq1KkaM2aMjh075lZ9kvT111+bw+6cE9XHicfHk+1cw3572Z9bNgdPnAO0FFzX1O+6pr78/f0dglbczSS2e/duM1A4ICBA119/fa3lU1NTNWbMGE2dOlULFizQkSNHzO+r//73v7r00kt18cUXuxX8arPZNGPGDHXv3l0zZszQ8uXLlZqaqrKyMmVnZ2vDhg36y1/+oj59+ujRRx/1SPBXfQUEBOiOO+4wx3fs2KGNGzc2Sd1BQUHmcElJSaPru+666+Tr6yup6njo7veZfdamSy+91K1swC2Vp64L7HnzmAEAAOApBDEBAADAJfsbaBEREV5syf+88soreuqpp8wbVrGxsbrwwgt1880365ZbbtGkSZPUt29f+fj41FnXZ599prPPPlt79+6VVPXD7dixYzVt2jRNnz5dI0eONH94XbVqlYYPH660tDSX9dnfqBw5cmSd67d/un7gwIF1lvfz83Po/qi5n8531+bNm83h2p7gx/98/vnnZvaDBx98sM4sXp5U3/1ywIAB5nBlZaXTp9U9sa/bT+vXr5/5Wa2N/bo99fmxr7dNmzZKTExsdLtyc3OVmprqtLw7dR45csTpDdv6/l3atm3r0N1Tc2zDlry/7Ny508x+YLFYHD4LDa2zPry9/vo4WY93zlx00UUKDAw0x3/66ac6l/nzn/9sntt06dJF11xzjaZPn67x48fLz8/PoWx1hqWAgAANHDhQV155pW6++WbddNNNuuCCCxQbGyupKlPJgw8+WGcgU2lpqc4991yHc5i2bdvqqquu0vTp0zVmzBj5+vpqxYoVuvzyy93qqiYzM1MbNmyQVHVuNWjQoDqXqQ/784ygoCDzPZ8s7M8hmzurhifOAVoKrmvqd13TEPZdmn766aduBRLZBztdfvnlio6Odlm2vLxcl112mX7++Wf5+PhozJgxmj59uq688kqH85Ovv/5aF110Ua3fV5WVlbryyis1c+ZMM2CnXbt2uuyyy3TLLbfo2muvVZcuXSRJFRUVeu655/T73/++zvfTHK644gqHcXeOM+6wz77UFF1zJyQkOHSd5k6XcocOHdKSJUvM8dbelZwnrgtO5M1jBgAAgKfU/asdAAAATlkrVqwwh+3T1ntLRUWFnnnmGXP8+eef17333lvjBp9U9bTnf//7X2VkZDita+vWrZoyZYrKy8tlsVh077336tFHH1VkZKRDuX379mnKlClavny5Dh06pGnTpmnevHlO61yzZo05fNppp9X5fnbu3GkOd+zYsc7yUlV3QKtXr5ZU9eRtS2Oz2TRnzhxzfMKECV5sTeuQk5NjPlnfrVs3Pfroo15rS3p6utnlk+TefhkUFKS4uDjzs7Zjxw6H4APJM/t6Q+us5qnPjyfaZV/nieXdqbO6jhOzDzW0rdU3PXfs2KGLLrrIreXqo7XsL/Z1xsfHOwSuuFPn8ePHlZGRobi4OLfa09LWXx8n4/HOFT8/Pw0YMMDMHmWfLcuVRx55RBEREZo1a1aNrtdOzGxz+eWX68ILL9TYsWMdsmZUq6ys1Jw5c3THHXeosLBQjz32mK644gqX53HPPPOM2Uar1aoXX3xR99xzj6zW/z33uG/fPl1zzTVauXKl1q1bV+f7WbNmjZmxpHfv3m4FDdaHfXdf48aN81rmQk+x79Jp7dq1MgyjWd6jp84BWgqua+p3XdMQ3bt31+jRo7V06VLl5+fr3//+d63dZ1VWVmr27Nnm+E033VRr/Z9//rnKyso0cOBAffLJJ+rWrZtDXc8//7wef/xxSVVZxf785z/r4YcfdlrXU089pf/85z+SqoJLXn/9dV122WU1PmufffaZbr75ZuXm5urtt9/WhAkTvN69WVJSkhITE80A91WrVunOO+9sVJ05OTkO17LDhg1rVH3VpkyZom+//VaSNG/ePGVlZSkmJsZl+Tlz5pjHj7Zt27b6a8nmuF7p16+ffHx8VFlZqd27dys7O9sh8xwAAEBrRBATAAAAnPr222+1adMmc3z8+PFebE2VHTt2KDMzU5J05pln6qGHHnJZNjo6utYfze+8804VFxdLkv7yl7/onnvucVouOTlZ33//vYYOHapt27bpu+++0+rVq3XGGWc4lDt27JjS09MlVWXE6N69e53vJysryxx292nXNm3amMPHjx93a5nm9I9//MP8sdVqteoPf/iDl1vU8t17771mFz1vvvlmnd0seZL9PinVb7+svrHmbL/0xL7eUj8/jW1XUVGRSktLHfYD+zrDw8OdBi6cKDg4WGFhYcrPz5dU8/0WFxeb34ENbWtL3YatZR+srrehQUTeXn99tNTPq6f06NHDDGJyJ9OJzWbTV199pVGjRtWYd+Ix4R//+Eetdfn4+Gjq1KkKCgrS1VdfrfLycr355pt64YUXapTNzs7WSy+9ZI4/++yzuvfee2uUS05O1g8//KD+/fvrwIEDdb4f+/PHnj171lm+Pr755huHTBO33357k9bfEnTt2lW+vr6qqKhQTk6ODh486PbN78bw1DlAS8B1TRV3r2sa45ZbbtHSpUslSe+++26t7Z43b54ZiNOlSxeHbrScKSsrU7t27TR//vwagTA+Pj567LHHVFpaagaHPfvss7r99ttrdEeWkpKi5557TlLVtl2+fLmZdelEV1xxhWJjY80uu5588kldccUVXg+e7NGjh7ntmiKj1v3336+ioiJJVdvyxhtvbHSdknTxxRcrKipK2dnZKi8v1yeffFLr97b9wzDXX3+9W1nIpKqsZp9//rlbZWNiYvTUU0+5VbaxPHFdcKKgoCB17NhR+/btk1R1DB49enQDWwwAANAy0J0cAAAAavjyyy91/fXXm+MBAQG67bbbvNiiKvbdITXmpuvGjRu1aNEiSVXdYNx99921lg8JCTGf6pWkDz/8sEaZ/fv3m8Px8fHy9/evsx0FBQXmsDtBCSeWs1++Jdi6davD087Tp09Xnz59vNiilm/RokVmNxqTJ082b5B4y4n7VFPtl57Y11vq56ex7TqxjobWeWLZ2uqsT72tYRu2ln3QVb3u8vb666Olfl49xb6rKvsurFyZNGmS0wCmxpg0aZJCQ0MlSQsWLHBa5qOPPjK7UerYsaPuu+8+l/VFRkbq6aefdmvd9udE7du3d7fJdUpNTXXormrixIk677zzmqz+lsJqtTp0OZSSktIs623Jx4XG4LrGkTvXNY3xu9/9zuwSbsWKFTWySdp79913zeEbb7zRrcCgp59+utZMPo899pj5+SksLNTHH39co8wrr7xiduE3Y8YMlwFM1caOHWt2i7Z9+3atX7++znZ6Wn2PMycyDEPHjx/X/Pnzde655+qdd94x5/3lL39psq6tAwICdNVVV5njtXUpt2bNGofMQ/XpSu7LL7/U66+/7tbLPvuXpzXXuVq7du3M4eY6ZgAAAHgSmZgAAABOUfPmzTOf/q1WnUZ+9+7dDtP/+te/KikpqTmb55R9GxYvXqxdu3a5lfHoRPbdJlxzzTVu/WBuH1yyfPnyGvPtn4Ct7Yd1e9U3DiW5FfQkOWZksM+i4m05OTm69NJLzR9Zu3Xrpr/+9a9eblXLVlxcbN6MjYmJ0V/+8hcvt8hxn5Sabr/0xL7eUj8/jW2XVLNtDanzxHprq7M+9baGbdha9kFX9brL2+uvj5b6efWU6uAhSWY2tNpcffXVDVrPpk2btH79eqWkpCgvL69G13PV5zebN2+WzWZz6CJOkpYsWWIOX3XVVXV2+zZp0iT9/ve/r/H9caKGnBPVpaysTJMmTTIzj8TExDh0K3eyiY2N1aFDhyTJzNboaS35uFAXrmuqNNV1TWMEBARo8uTJ+tvf/iapKlDpxRdfrFEuLS3N7GasOoOcO3XX1ZVbQECArr76ar388suSqrbt73//e4cy9tvs2muvrXO9UtU2++GHHyRVbbOBAwe6tZyn1Pc4M23atFqzYklVQaczZ850629RH1OmTNGbb74pqSpQaefOnerRo0eNcvYBToMHD1bv3r2btB3e0FznarGxseZwcx0zAAAAPIkgJgAAgFPU2rVrtXbt2lrLhIWF6ZVXXqnzB8/mkpSUpGHDhmnVqlXKzc3VoEGDdMMNN+iyyy7TmWeeqeDgYLfqqe7iRar6YdudrlEMwzCHq28q2SssLDSH3W1HYGCgmba/rKzMrWXsb1DWJyOLJ5WUlOiSSy7Rnj17JFV1d/X55587/LiOmmbMmKG9e/dKkl566SWHH5+9JTAw0GG8rKysxjRn6tovPbGv27erJX1+GtsuqWbbGlLnifXWVmd96m2ubdga9hdP/K3rw9vrr4+T5XjnLvsbyid2Y+TMoEGD6lX/7Nmz9dxzz2nXrl1ulS8vL1dubq6ioqIcpm/YsMEcdqc7qeDgYPXt21e//PJLreUack5UG8MwNGXKFP3888+SJD8/P3388cdq27Zto+tuqey3m/329CRPnQM0B65rqjTVdU1j3XLLLWYQ0wcffKDnnnuuRpDk7NmzVVFRIUk6//zz3fo89+vXz63ri+HDh5tBTCdmTcrKyjK/O/39/d3uVmzbtm3msCe2WX3V9zhTl5CQEL355pu64IILGl3XiYYNG6bu3bub233OnDlml3/VysrK9Mknn5jj9cnCJFXt+2PGjGl0W5tac52reeOYAQAA4EkEMQEAAMAUGhqqmJgYnXbaaZowYYImT56syMhIbzfLwbvvvqtx48YpLS1NBQUFeuONN/TGG2/I19dX/fv316hRo3TOOedo/Pjx8vHxcVrH0aNHzeHvvvuu3m2oK2W//Y2B2oSGhpo3dd19ct2+XEsIEqqoqNBVV12lZcuWSar6ofarr77Saaed5uWWtWy//vqreXNl7NixTf7Ec0OduE8VFxe7dQOzrv3SE/u6/bSW9PlpbLtOrKOhdZ5YtrY661Nvc23D1rC/eOJvXR/eXn99nAzHu/rIzc01h6u7VaqNu11JGYah6dOn6/333693m/Lz82sEMWVkZJjD7mamad++fZ1BTPbcPSeqzR133GHe3LZarZo9e7YmTpzY6HpbsqbYbvXlqXMAb+G6xj0N6YqsLr169dJZZ52l5cuXKy0tTd98840uvfRShzLV3SlL0k033eRWvR06dKh3OfvvOUlmNjepKqjk9ddfd6tOe57YZvVV3+PM+PHj1bNnT4flU1JS9PPPP8tms6mwsFAXXXSR3njjjRqZq5rClClT9Oijj0qS/vWvf2nmzJkOWcO+/fZbZWVlSaoKLrvmmmuavA3e0Fznat44ZgAAAHiSte4iAAAAOBk98cQTMgzD4ZWfn6+UlBR99dVXuvPOO1vcD/2S1Lt3b23cuFF//OMfFRERYU6vqKjQL7/8or/+9a8655xz1LFjR73zzjtO67D/0bchKisra0wLCQkxh939gdK+ixX7rldqY58e3p0frD3JZrNp6tSp+uqrryRJvr6++uyzzzR69Givtqs1uOmmm1RZWamAgACze4WW4MRuf5pqv/TEvt5SPz+NbVdwcHCNbiTs68zLy6uzKydJKioqcnhK/8T3GxQU5PBk98m0DVvLPuiqXnd5e/310VI/r56yY8cOc7hNmzZ1lnc3e83bb7/tEMB07rnnavbs2dq8ebOys7NVWlrqcF7XsWNHs6zNZqtRX3UXsJL7GZPcuZnakHMiVx5++GH94x//MMdff/31k+bmdm3st5v99vQkT50DNAeuaxrO2XVNU6juMlmqCtayt3z5cu3cuVOSlJiY6Hb2H3e/p+w/Myd2tdbY7SXJzCDlTfU9zlx//fX6+9//br7mzJmjn376Sbt379aECRMkVQXC3H777WbWu6Z0ww03mF2aHjhwQEuXLnWYb9+V3AUXXNBkXZF6myeuC5zxxjEDAADAkwhiAgAAQLNwdvOsoRISEvTqq68qLS1NS5Ys0cyZM3Xeeec5pNI/cuSIbr75Zt155501lrf/Ye+LL76ocdPDndeJ7H88zszMdOt99OjRwxx2p+sHSTp48KA5bP80rTfceuut+vDDDyVVZUb44IMPdOGFF3q1Ta1FdRc+AQEBmjx5soYNG+byZe+2224zp992221N3q74+HiHm3zu7JclJSUOT7k72y89sa+31M+Pp9+ru/Xa1+msjhOnnUrb0BN1pqenuxVcZl9ndHS02xl4nPH2+uujpe5rnlBWVubQTduJ3+ON8dJLL5nDTz31lL777jtNnjxZffv2VWRkpPz9/R3Kn3jz/kT2AUnVmbLq4k43NQ05J3Lm2Wef1Z/+9Cdz/IUXXtCtt97a4PpaE/vjqjsBCk3BU+cAJ6OT/bqmKUyaNMnM/vbdd985ZIyyD2qaOnWqyyxTJ2rI91RYWJjDPPvtFR4e3qDtNWvWLLfa4SkHDhxwCIhpzHEmOTlZ//3vf80supWVlZo6darKy8sb3U57SUlJGjt2rDk+Z84cczgrK0vz5s0zx+vblVxL1lznP944ZgAAAHgSQUwAAABoED8/P3PYnadRm+Kp1xMFBARo9OjReuyxxzRv3jxlZmbqu+++01lnnWWWee2117R27VqH5RISEszhE7NSNFTnzp3N4YyMDJWVldW5TK9evczh9evX11m+oqJCmzdvdrp8c7vnnnv09ttvm+P//Oc/T4nMCE0tLy9Pq1evrvVlb/v27eb0bdu2eaRN9d0v161bZw77+Pioe/fuja7TnX3dftrmzZvd+h6yb6unPj/29R47dsyt75i62hUREaHExERzvL5/l3bt2jncDHW2LnfqPHr0qMNNs+bYhi15f+nRo4eZVcAwDIfAlYbWWR/eXn99tObjXX199dVXKi0tNcdHjRrVJPUeOnRIu3fvliRFRkbq4YcfrrV8Xl5enV0excbGmsOHDx92qx3ulLM/J3K33hP97W9/02OPPWaOP/bYY3rggQcaVFdrY7PZHI4dnTp1arZ1e+IcoDXguqbpBQUF6frrr5dUFRgze/ZsSVXBlZ999pkkyWKxaPr06W7XeWKAtiuHDh0yh+2/5yTH7ZWXl+d2YFRLUr39qjX2OBMcHKz33nvP7N5t9+7deuuttxpVpzP2wUmff/65mT3ok08+Ma+dY2Njdf755zf5ur3FE9cFzhw5csQcbs5jBgAAgKcQxAQAAIAGsb8hnpWVVWd5+5uRnuLn56dzzz1XCxYsUN++fc3pX3/9tUO5M844wxxesWJFk6w7ISFB8fHxkqpuJu/atavOZeyfRl25cmWdgU9r1641f2gPDAzU8OHDG9Hihnv00Uf1t7/9zRx/+eWXddNNN3mlLWh69vvlkiVL6ixv3x3EiBEjnHZ54Il93X5dhYWF+uWXX2qts7S0VKtWrTLHx40bV2v5hurWrZvat29vjtd3G7pqV2P+Lp6os0OHDuratWudyzREa9lfAgMDHbIfNNXfxV3eXn99tNbjXX0ZhqGXX37ZHI+Li9P48eObpG77LCY9e/Z0CLpwZvny5XVmWOnfv785fGLQrDPFxcXasmVLneWqM3pIMruMqo+33npL99xzjzl+1113aebMmfWup7XavXu3GUgTGRnp0C2gp3niHKA14LrGM+y7lHvvvfckVQWsVGdKGj16tLp06eJ2fVu2bHErG9zKlSvN4YEDBzrMS0xMVFJSkjnuia7TPKm0tFSvv/66Od63b1+H/aOhBg0apGuvvdYcf+aZZ9zK8Fgfl19+uZkBMC8vT19++aUkx67krr322jqPb62Jp64L7BUVFTlkeTr99NPr10gAAIAWiCAmAAAANIj9E351ZX8oKSmp8YO7JwUEBOjss882x+0zh0hy6PLsiy++qDG/oYYOHWoOb9y4sc7yY8aMUUREhKSqH3K/+OKLWsvbd10wceJEh+4Qmsuzzz6r5557zhx/+umndffddzd7O1q7hnbxsXjxYnO6Oz+CN8Sll15qDi9YsKDOLBr2+6X9svY8sa+HhoY6BAfU1bXHF198YXatFB0d3WTZUU5ksVh08cUXu92ulStXmkGPPj4+uuiii5yWs9+2n376qfn0ujPFxcX697//7XRZexdffLGZyWfnzp0OQTvO2L+XSy65pNayjdGa9hf7bVtXnYcOHdLChQudLttQ3l6/u1rj8a4hXnrpJYcb4vfcc4+Cg4ObpO7qz6rkXpdKb7zxRp1lxowZYw7/+9//rjMDzX/+859av3uqDRkyxMzosW3bNrcy21T717/+5dBl3PTp0x0Cw04F9ueQQ4YMadZ1e+IcoDXgusYz+vbtawah7tmzR0uXLnXoSq6+D0GUlJTUyEJ0orKyMn366afmuH1gXjX7bfaPf/yjXm3wtv/7v/9TSkqKOf7II4+Y37eN9fjjj5vHmmPHjjV5NqaQkBBNmjTJHJ8zZ4527typNWvWmNNOpq7kJM9dF9jbsmWL2cVlt27dHLoFBQAAaK0IYgIAAECD2D/1+8033ygzM9Nl2RkzZtQ6313Z2dnmD3R1se9GoDpDUrWhQ4eaN+6Ki4t1ww03uNX9m1T1w7ir7lkmTpxoDi9fvrzOuvz8/HTzzTeb4zNmzHB5c3DLli0OP3refvvtbrW3Kb3yyisOXbs88MADevzxx5u9HfCsIUOGmDdNKysr9dBDD7ks+9Zbb5k/tIeFhWny5MlOy3lqX7/tttvM4VmzZmnr1q1OyxUVFWnGjBnm+C233CJfX1+X9TbWrbfeat4E+uGHH/Tjjz86LWez2Ry6R7riiisUFxfntOzFF19sPsmdk5OjZ5991uX6Z86cqZycHElSx44dHW7W2UtISNDll19ujj/wwAMuM7fMnz9f8+fPl1R1U8U+yKCptab9ZcqUKWaAzc6dO/XOO++4XP+DDz6oyspKSdLw4cNrZIdoCG+v312t7XhXX4Zh6E9/+pNDF2+9evXSH//4xyZbR+fOnc0b1Vu2bNG+fftclv3000/1zTff1Fnntddeq8DAQEnS/v37aw0Wys3NdfuYHxsba2Z5Ki4u1q+//urWcl988YWmTp1qfg9dc801euutt5rsBn1r8dNPP5nD9ueWzcET5wCtAdc1nmOfjenBBx80s75FRUXpd7/7Xb3rmzFjRq1tfu6558yutUJCQpx2d33vvffKx8dHkjR37tw6A0vseavLvvLyct19990OQVdjxozRlVde2WTr6NGjh66++mpz/MUXX3ToHrUp2AcpzZ8/X3/+85/N8b59+zbruUlz8cR1gT1vHjMAAAA8xgAAAMApY/To0YYkQ5LxxBNPNKoum81mdOnSxaxvwoQJxvHjxx3KFBYWGvfdd58hyQgICDDLTpkyxWmdixcvNsuMHj26xvz333/f6NKli/HnP//Z2L9/v9M6SkpKjNdee82wWCxmXStWrKhRbvPmzUZoaKhZ5owzzjBWrVrl8v3u3LnTePrpp43ExETj66+/dlpm7969Zn3du3d3WZe9zMxMIzIy0lxu4sSJRmZmpkOZjRs3Gp06dTLLjB07ttY69+/fb5aVZLz//vtutaU27777rsM2vf322xtdp2EYxhNPPOHQVk+aMmVKnftgbezb2djPT0PXu3jx4mZZ54IFCxzW++CDDxplZWUOZT799FMjKCjILPPUU0/VWqcn9nXDMIyRI0ea5Tt16mRs3LixxnonTpxolomOjjays7Pd2xCNcMMNN5jrjImJqfG3KygocCjj7+9v7N69u9Y63333XbO81Wo1XnnlFaOystKcX1lZabzyyiuG1Wo1y82ePbvWOrdv3274+fmZ5W+44QajoKDAocyiRYuMmJgYs8y0adPqtzEaoDXtL48//rhZPigoyPj0008d5peVlRkPPvigw2dqyZIltdbZsWNHt7+vPLF+++/Ljh071lrWXa3leGd/XHJ2LmIvPz/f+Pjjj40hQ4Y4tCM2NtbYu3dvrcs25Ng3fPhwc5kBAwYYO3bscJhfWVlp/P3vfzf8/PwMHx8fIzAw0Czv6rzpkUcecfheefnllx2+VwyjajsPGzasxvlcbdt7xowZZrnnnnuuzvf23XffGf7+/uYyl1xyiVFeXl7ncnV5//33Hba1q+3QFOqz79Smd+/eZj3btm2rtWx9vivc5YlzAE/8Hbiu+R9PXNc405BtXlhYaERERDj8/SUZd9xxh1vL2+871d8RgwcPNvbs2eNQrqKiwnjuueccttUzzzzjsl77z6vFYjHuvfdeIyMjw2nZ8vJy44cffjCuv/56o02bNi7rdPdaoT7XJFlZWcY///lPo2fPng71d+vWzcjKyqp1WfvvB3ePj9u2bXM4j3zjjTca/R7s2Ww2h3bZv/785z+7XY9heOYayf5z25T1euK6oNr5559vLjdv3rwmaS8AAIC3ee7RUwAAAJzULBaLnn/+efPpzwULFqhz584aP368YmNjdezYMS1btkw5OTlq27atbr/9dj366KONXu/evXt1//336/7771eHDh102mmnmU8kHzt2TKtWrdLx48fN8tddd51GjBhRo56+ffvq448/1lVXXaWioiKtXr1aw4YNU5cuXTRw4EBFR0erpKRE6enp2rRpk/lEb22Sk5M1fPhwMw389u3b1atXr1qXiYmJ0SeffKILL7xQFRUV+vHHH9WhQwdNmDBBcXFx2rt3r5YuXWpmJWjXrp3+9a9/1WeTNdrmzZt18803m20ICQmRYRi644473Fr+rrvuUrdu3TzZxBqqM0DYO3jwoDn81VdfOS1TVxcip4rx48frscce0zPPPCNJeuGFFzRnzhyNHDlSgYGB+vXXX7Vlyxaz/MSJE/XII4/UWqen9vWPPvpIQ4cOVWpqqlJSUtS/f3+NHj1aXbp0UUZGhhYsWGB2veTr66t///vfzdLNwt///netW7dOW7duVVZWlsaOHaszzjhDvXv3Vl5enhYtWuSQSeCtt95S165da63zxhtv1JIlSzRnzhzZbDbdddddevXVVzVs2DBJ0qpVq7R3716z/LRp0+rMjNGzZ0+98cYbZpcuc+bM0TfffKNx48YpPDxc27ZtM7MmSNJpp52mV155pd7bo75a0/7y+OOPa8WKFVq0aJGKi4t11VVX6ZlnntHAgQNVUlKiZcuWKTU11Sz/1FNPafTo0Q3fOC1s/e5qDce7E+3evbvGsa6goEA5OTlKSUnRli1bzOxW1c4880zNmTNHnTt3bvL2zJw5U2effbZsNpvWr1+vfv366cwzz1RycrIKCgr0008/mX/rZ599Vm+99ZYOHDhQa50zZszQggULtGbNGtlsNt1zzz166aWXNHLkSIWGhmrfvn1atmyZKioqNHz4cCUnJ+vDDz+U5NjF3Ymuu+46Pf3005KkL7/80iFL1YkyMzN1+eWXm9ljfHx8FBcX53Z3tTfccINDJp3mcP755+vo0aMO0+wztPzyyy9OzzPmzZuntm3buqx39+7d2rZtmyRpwIABdZ5HeoInzgFaOq5rPCc4OFjXXXddjW7b6tuVnCRNmjRJe/bs0Zo1a9SzZ0+NHDlSXbp0UX5+fo1j3ahRo/Tggw+6rOuJJ55QSkqKZs+eLcMw9Je//EWvvfaaBg8erC5duig4OFh5eXlKSUnRpk2bVFhYKKnqWNaUVq9e7XCcMQxD+fn5ysnJ0e7du7Vz584aWTIvueQSvf3224qOjm7StkhVWQSvuOIKs0u+P/3pT5o+fbr8/PyapH6LxaLJkydr5syZDtN9fHx03XXXNbjeV155RZ9//rnb5U8//XSHDJGe5onrAknKz883uwqOj48nExMAADh5eC18CgAAAM2uKZ9YrvbUU085fZKy+tWjRw9jy5YtDk/RNvSJ5c8++8zh6draXlar1bjttttqPDl+og0bNhiDBg1yq06pKnPH+vXrXdb3zjvvNGgbf/XVV0ZsbGyt63aWdcGZffv2OSz3wQcfuN0OZ058IrW+r9qeYLXP1GC1WhvVTnsNbasrNpvNodzTTz/dZG2tz3tprkxMhlH1nmfOnOmQpcfZ6+qrrzZyc3Pdrrcp9/Vq27dvN/r3719rnXFxccY333zTkE3RYEeOHDHGjRtXa7tCQ0ON9957z+06S0tLjTvuuKPW70KLxWLceeeddX7/2Xv77beNkJCQWts6fvx44+jRow3ZFA3WWvaXnJwc48orr6y1Tj8/P+PZZ591q776Zldp6vVPnjzZXC45OdmtZdzVko93hlEzQ6C7r4EDBxpvv/12jSxGrrhz7HHmjTfeMHx9fV22w2q1GjNmzKiR7aK2zDfZ2dl1fleNGDHCSE1NNa699lpz2ty5c2tt61lnnWV+J+3bt89luRMzatX3VVuGkffee8+h7MGDB+vYwu5xlUmkrlddGYieeeYZs+xrr71WZzs6dOhglr/xxhub5L0ZRtOfA3ji78B1TU1NfV1zooZu8w0bNjisd/DgwW4ve+K2PnLkiJkZztXrggsuMPLz892q/9VXXzWioqLc2l4Wi8W4+OKLXdZlX9bdTEz1eY0ePdr47LPP3N52DcnEZBiGsWXLFod985133qn1PdQ3C9zu3btrvLfzzjuvXnUYRsOv96SqbH/OLFq0yKHcsmXL6t0uVzxxXfCvf/3LXPbee+9tsrYCAAB4G5mYAAAA0CgzZszQxIkT9dprr+mnn35Senq6wsPD1bVrV1199dWaPn26QkNDtXbt2kava9KkSUpNTdX8+fO1YsUKbdy4Ufv27VNOTo4kKSIiQt27d9dZZ52lyZMnq3fv3nXWefrpp+uXX37R/Pnz9eWXX2rFihU6evSocnJyFBAQoLi4OPXo0UNnnHGGzjnnHA0fPlwWi8Vlfdddd50efvhhZWRk6L333tOMGTNqzVRQ7aKLLtK2bdv0/vvva+7cueb7SkhIUJ8+fXTNNdfommuucesp2E2bNpnDERERuvDCC+tcxlvs23r99dd7sSW1s2+nr6+vrr76ai+2pnlYLBY99thj+t3vfqd33nlH8+fP16FDh1ReXq7ExEQNHz5cU6ZM0YQJE+pVb1Pu69V69uyp1atX65NPPtHHH3+srVu3Ki0tTZGRkUpOTtbll1+uadOmKTY2tr6boVHatm2rBQsWaO7cufrwww+1bt06paamKjQ0VB06dNBFF12k6dOnq0OHDm7X6e/vr9dee0033HCD3nvvPS1ZssTMqNCuXTuNGTNG06dP15AhQ+rV1ptuuklnn3223n33XX399dc6ePCgCgoKlJiYqIEDB+r666/XpZdeWuv3nye0lv0lIiJCn376qW6++WbNnj1bK1euVGpqqvz8/JSUlKRzzjlH06dP91hWlaZevye/m1vz8c7Hx0fh4eEKDw9XTEyM+vXrp0GDBmnUqFE6/fTTPbruarfeeqvOPPNMvfzyy1q8eLGOHj2qoKAgtWvXTuPGjdONN96oAQMG1KvOyMhILVy4UP/+97/1wQcf6Ndff9Xx48cVGxurXr166YYbbtC1114rPz8/h6wwdWUpu/vuu7V8+XIZhqF33nlHzz77bEPecqPY7yOjRo1SUlJSs7fBXYZh6L333pNUtT9PnTq11vLZ2dk6fPiwOd6Un9WmPgdoLX8Hrms84/TTT1dycrL27dsnqWFZmKq1bdtWS5cu1b/+9S99+OGH2rFjhzIzMxUTE6MhQ4Zo2rRpuvTSS92u749//KOmTp2qOXPm6Mcff9TGjRuVkZGhkpIShYWFqX379urTp4/GjBmj888/3+P7rp+fn8LCwhQREaG4uDidfvrpGjx4sMaOHdtsmW379Omj3/3ud2Zmo+eff15TpkyRr2/T3Erq2rWrzjzzTK1YscKcNmXKlCapu7Hsv6u6dOmi4cOHN1ndnrgueOeddyRVnZ+4myUZAACgNbAYxgn5SAEAAAA0ynPPPWd2MTF37tx6/ZDeFKq7mJKqup557LHHmnX97rLZbIqNjVV2drb8/Py0c+dOj3S/0xRefvll/d///Z8kafr06eYPxgBwsqkOXjEMQ9HR0dq/f7/Cw8O93SynWsvx7mTSrl07sxu1Y8eOKSEhwWVZm82mPn36aMeOHUpISFBKSooCAwObq6mSqoInqm9K//TTTzrrrLOadf318d133+n888+XJD3yyCN1Bn3NnTtXl19+uaSqLuAWLFjg8TY2VGv6O6DppaSkKDk5WYZhKCQkREePHnX7uDJr1ixNmzZNUlWgy6xZszzYUpzqLrnkEn311VeSqrpYbskP2Wzbtk19+/aVYRi69tprza5eAQAATgZ1PxIOAAAAoF7uvPNOxcXFSZJeeOGFZl//okWLJEnx8fG6++67m3397lq/fr2ys7MlVT2R3VIDmKT/bdOAgAA98cQTXm4NAHjO4sWLVf2824MPPthiA5ik1nO8O1ksX77cDGBKSkqqNYBJkqxWq5566ilJUlpaWrMHH2RmZmrz5s2SpPPOO6/FB85UnzNGRkbq/vvvr7N89f4vVQXQt1St7e+Apvfee++Zx5Urr7yyRR9XcOqqrKzUsmXLJEl9+/bVtdde6+UW1e7FF1+UYRjy9fU1j7UAAAAnC4KYAAAAgCYWGhqqp59+WpK0atUq/fDDD8227vT0dG3dulWS9PDDDys0NLTZ1l1f1TffgoKC9Pjjj3u5Na7Z/6B96623ttguUACgKVR/NycmJuqPf/yjl1vjWms63p0MysrKdM8995jj7t7cveKKKzRs2DBJ0p/+9CeVlpZ6pH3OVAfkWSwWr3RlVx/Lli3T0qVLJUmPPfZYnV31Sf/7rF5yySUaOnSoJ5vXKK3p74CmV1JSorffftscv/XWW73YGsC1devWmd05zpw5060u4b1l7969+uijjyRVfaa6du3q5RYBAAA0rZZ7JgYAAAC0YrfccosGDhwoqSqThc1ma5b1Vt8oSkpK0h/+8IdmWWdDVd98u+OOO5SYmOjl1rj2yy+/KC8vTyEhIXrkkUe83RwA8Kjq7+bHHntMQUFBXm6Na63peNfS/eEPf9B7772n/Px8p/O3bNmicePG6ZdffpFUFax92223uVW3xWLR3//+d1mtVh04cECvv/56k7W7LtX78qRJkzRgwIBmW29DPPTQQ5KkXr166c4776yzfFpamrZt2yar1apnnnnG081rlNb0d0DTe+yxx3Ts2DFJ0ogRI1p0wB1ObdXfVUOGDGn27uDr67HHHlN5ebni4uI0c+ZMbzcHAACgyVmM6lyuAAAAAAAAAE4pY8aM0dKlSxUQEKD+/furW7duCg0NVV5enjZt2qStW7eaXUFZLBa9++67mjZtmpdbDaAl+v777/X999+ruLhYa9as0YYNGyRVfXcsWbJEo0aNqld9s2bNMr9vpkyZ0uzdUgIAAABofr7ebgAAAAAAoOH+9a9/adWqVY2qo1u3brrrrruaqEWtzx133NHoOm644QadccYZTdCa1mf16tWaM2dOo+v5+9//3gStAdBQpaWlWr16tVavXu10fmRkpF5//XW3u5IDcOpZtWqVXnnllRrT77vvvnoHMAEAAAA4NRHEBAAAAACt2IIFCzR79uxG1TF69OhTOoipKbo3Gjx48CkbxLR9+/Ym2YYEMQHe8cknn2ju3LlaunSpdu7cqczMTGVlZUmSYmJi1LdvX02cOFE33nijIiMjvdtYAK1GcHCw+vXrp9tuu02TJ0/2dnMAAAAAtBIEMQEAAAAAAACnqDZt2ugPf/iD/vCHP3i7KQBauSeffFJPPvlkk9U3depUTZ06tcnqAwAAANDyWYzqTu0BAAAAAAAAAAAAAAAAwAus3m4AAAAAAAAAAAAAAAAAgFMbQUwAAAAAAAAAAAAAAAAAvIogJgAAAAAAAAAAAAAAAABeRRATAAAAAAAAAAAAAAAAAK8iiAkAAAAAAAAAAAAAAACAVxHEBAAAAAAAAAAAAAAAAMCrCGICAAAAAAAAAAAAAAAA4FUEMQEAAAAAAAAAAAAAAADwKoKYAAAAAAAAAAAAAAAAAHgVQUwAAAAAAAAAAAAAAAAAvIogJgAAAAAAAAAAAAAAAABeRRATAAAAAAAAAAAAAAAAAK8iiAkAAAAAAAAAAAAAAACAVxHEBAAAAAAAAAAAAAAAAMCrCGICAAAAAAAAAAAAAAAA4FUEMQEAAAAAAAAAAAAAAADwKoKYAAAAAAAAAAAAAAAAAHgVQUwAAAAAAAAAAAAAAAAAvIogJgAAAAAAAAAAAAAAAABeRRATAAAAAAAAAAAAAAAAAK8iiAkAAAAAAAAAAAAAAACAVxHEBAAAAAAAAAAAAAAAAMCrCGICAAAAAAAAAAAAAAAA4FUEMQEAAAAAAAAAAAAAAADwKoKYAAAAAAAAAAAAAAAAAHgVQUwAAAAAAAAAAAAAAAAAvIogJgAAAAAAAAAAAAAAAABeRRATAAAAAAAAAAAAAAAAAK8iiAkAAAAAAAAAAAAAAACAVxHEBAAAAAAAAAAAAAAAAMCrCGICAAAAAAAAAAAAAAAA4FUEMQEAAAAAAAAAAAAAAADwKoKYAAAAAAAAAAAAAAAAAHgVQUwAAAAAAAAAAAAAAAAAvIogJgAAAAAAAAAAAAAAAABeRRATAAAAAAAAAAAAAAAAAK8iiAkAAAAAAAAAAAAAAACAVxHEBAAAAAAAAAAAAAAAAMCrCGICAAAAAAAAAAAAAAAA4FUEMQEAAAAAAAAAAAAAAADwKoKYAAAAAAAAAAAAAAAAAHgVQUwAAAAAAAAAAAAAAAAAvIogJgAAAAAAAAAAAAAAAABeRRATAAAAAAAAAAAAAAAAAK8iiAkAAAAAAAAAAAAAAACAVxHEBAAAAAAAAAAAAAAAAMCrCGICAAAAAAAAAAAAAAAA4FUEMQEAAAAAAAAAAAAAAADwKoKYAAAAAAAAAAAAAAAAAHgVQUwAAAAAAAAAAAAAAAAAvIogJgAAAAAAAAAAAAAAAABeRRATAAAAAAAAAAAAAAAAAK8iiAkAAAAAAAAAAAAAAACAVxHEBAAAAAAAAAAAAAAAAMCrCGICAAAAAAAAAAAAAAAA4FUEMXlAenq6vvnmG82YMUPnnXeeYmNjZbFYZLFYNHXqVI+s8+OPP9bZZ5+tNm3aKDAwUB07dtT111+vlStXul1HUVGRXnzxRQ0ZMkTR0dEKCQlRz549de+99+rAgQMeaTcAAAAAAAAAAAAAAABgMQzD8HYjTjYWi8XlvClTpmjWrFlNtq7i4mJNmjRJ8+bNczrfarVqxowZeuKJJ2qtZ8+ePTr//PO1e/dup/PDw8P14Ycf6sILL2x0mwEAAAAAAAAAAAAAAAB7ZGLysA4dOujss8/2WP033nijGcA0duxYffnll1qzZo3effdddenSRTabTU8++aTeeustl3Xk5+frggsuMAOYbr75Zi1cuFA///yznn32WYWGhiovL09XXXWVNmzY4LH3AgAAAAAAAAAAAAAAgFMTmZg84IknntCQIUM0ZMgQJSQkKCUlRZ07d5bUtJmYFi1apPHjx0uSLrroIs2dO1c+Pj7m/MzMTA0aNEgHDx5UZGSk9u3bp6ioqBr1zJgxQzNnzpQkvfjii7r//vsd5v/8888aPXq0KioqNHr0aC1ZsqRJ2g8AAAAAAAAAAAAAAABIZGLyiKeeekoXXnihEhISPLqel156SZLk6+urf/zjHw4BTJIUGxurF154QZKUk5Ojd955p0Yd5eXlevXVVyVJvXr10r333lujzIgRIzR9+nRJ0tKlS7V27domfR8AAAAAAAAAAAAAAAA4tRHE1Erl5+dr4cKFkqQJEyaoffv2TstdfvnlCg8PlyTNnTu3xvzFixcrNzdXUlWWKKvV+S4xdepUc9hZPQAAAAAAAAAAAAAAAEBDEcTUSq1du1ZlZWWSpNGjR7ss5+/vr2HDhpnLlJeXO8xfvny5OVxbPYMHD1ZwcLAkacWKFQ1uNwAAAAAAAAAAAAAAAHAiX283AA2zbds2c7hnz561lu3Zs6fmz5+viooK7d69W7179653Pb6+vuratas2bdqk7du317u9hw8frnV+SUmJduzYoYSEBMXFxcnXl10TAAAAAAAAQNOrqKhQRkaGJKlfv34KDAz0cosA7yopKdHmzZslid/nAQAA4DZPXFtxJtpK2QcFuepKrlpSUpI5fOjQIYcgpup6QkJCFBkZWWc9mzZtUkZGhkpLSxUQEOB2e+3bAAAAAAAAAAAtwZo1azRkyBBvNwPwqs2bN2vo0KHebgYAAABasaa6tqI7uVYqPz/fHA4NDa21bEhIiDlcUFDgtJ666qirHgAAAAAAAAAAAAAAAKChyMTUSpWUlJjD/v7+tZa1z5hUXFzstJ666qirnrocOnSozvkjRoyQJH3zzTdKTk6uV/1AUyosLNQXX3whSbr88ssdAvgAb2CfREvC/lg7m2GosLRSucXlyimuUF5JhUL9fXRa+3Cn5V9ZvF8/7sxSabmt3uvqFh+sf1zV1+m8d1ce1ie/HK13nZIUGeSrz24a6HTefzel6e9LDzSoXkmaf8cQWSyWGtMX7srUn37Y1+B6r47Ypat/d1mN/XHtgRw98tWuBtf7r6mnKyGsZvbR7ccKdOdn25ws4Z6/X9lbPRJqPkSQll+q62dtbHC9j5/XRaO6xtSYbhiGzv/HL5Kk0AAfhQf6KjzQV2En/F817KPwQD+FBfooItBPkUG+8vXh2Rd38R2JloT9ES0N+yRakn379unCCy+UVNV1FnCqs/8crFmzRomJic2y3vz8fM2ZM0eSdMMNNygsLKxZ1ouTG/sVmhr7FJoa+xQ8wVv7VWpqqpnRs6murQhiaqXs+xIsKyurtWxpaak5HBQU5LSeuuqoq5661NXlnb3k5GT16tWrXvUDTSkvL08RERGSpO7duys83PmNZ6C5sE+iJTlV98ejOcU6mlOsjPxSZRSUKvO3/48Xlim7sFzHi8qUXVim7KIy2QzHZcf0iNNVE52f20TvqFDlQUO+9Tu1kiQZIcEuz5mS0/zku6vu8ztnLAG+LuvdmB8i3/WFkiRfq0UBvlb5+1rl51P9ssjXxypfq8Vh3M/HIl+rVT169pKPtWYQU2lojq6viJDVapHVIlktFruXZLVaZLFIFllkyNBv/1RSWqqNGzYqKijC6f7oG52vG0vDVGkzVGkzVPHb//8bt9WYV2EzVFFpU1mlTaf16a3okJrB/vmBx+Ubnt6g7StJvXr2VI82NS8ircfy5Rt+pMH19u7ZQ7261bxQLCitkEL3Vw1LKqiUjhZKKqwuUfHby7lnLu2r64d1dDrvh63HFOLvq5hQf8WE+Cs6xP+UDno6Vb8j0TKxP6KlYZ9ES+Xry0/kgP3nIDExsV6/5zeG/bGhXbt2HBvQJNiv0NTYp9DU2KfgCS1hv2qqayuu0Fop+8i5urp2Kyw0707U6Dauuh53uoerrR4AAIDWpKS8UpkFpVVBSfmlyiwoU3xYgCb0TnBafsZ/t2jB9oYFrWQXug4migjya1Cd0m+BKS5EB/srNjRAIQE+CvLzUbC/j4L9fRXk76MQfx8F+fv+Ns1HQf4+CvbzUXCAr1nWlcsGttNFp7dVgK+1SQNV+idFqn9SZL2Xy8vL0xu7fnA5v1tCmJ6+xHm2qsYY2jlae587X2UVVcFOZRU2lVZUqqTcppLyShWXV1b9X1Y1XFpuU/Fv04vLKhXvJLuTVJXJq0N0sApLK1RYVqGSemboCg90vj/lFDUsoM2s18V+ahiG/vjxepVV/K+dFosUE+KvuLBAxYcFVL3CA5QQXjVuTg8PUICv630NAAAAAAAAAHDqIYiplbJ/EuLw4cMaPHiwy7L2XbklJSXVqGf16tUqLCxUTk6OIiMj66wnLi7OoWs5AACAlsJmM5RZWKpjuSVVr7wSpf42nJpbrPTfgpbyS2oGAI3rGe8yiCnORdCJO47XEkDiLIgp2N9HEUF+igjyU3j1/4F+Cvut26+wQF+FBvgpMth1ANTVQzvo6qEdGtxmVwJ8fRTAFYQkycdqUZC/j4LUdIE4vRLDteyBseZ4RaVNhWWVKiqrUGFphQpKK1VYWqH8knLlFVcor6RceSUVyisuV15JuRLCA53Wm1NU3qh2xTjJRiVJhWWVDgFMkmQYUmZBmTILyrQ9tfZ6n7q4j6aM6OR03oZDOYoI8lNiRKAC/Qh2AgAAAAAAAIBTAbcgWqnevXubwzt27Ki1bPV8X19fdevWrUY9//nPf8xyw4YNc1pHRUWF9u7dK0l09QYAALyiotKmjIJSVVQaSooOdlpm+uy1Wrwzo0H1Z+SXupwXF1r/IKYQfx9FhfirbYTrvuIuPr2thnaO/l/QUqCf/H1P3a644MjXx6qIIGujMnZJUo82YfrpgbHKKSpXdlGZcorLlVNU1RViTnHZ/6YXVU3PKS5XbnG5jN+6RowJdR7EdLygcRmeXAXiGYaha95apeLySklSVLCf2kYGKTEiSG0jA38bDlS7yCAlRgYpISzglO7CDgAAAAAAAABOFgQxtVJDhgyRv7+/ysrKtHTpUj300ENOy5WVlWnVqlXmMn5+jjcKzjrrLHN46dKlLoOYfvnlF7M7uTPPPLMp3gIAAICDgtIKHc4u0qHjxTqcXaTD2cU6mlNsZlJKzy+RzZAm9ErQO1OcZ6F0lYnGHbUGMYUFKMjPR3FhAVWv0ADFhvkrJiRA0SH+igrxV3Swv6JDql6RwX5uZY9pGxmktpGug5yApuDnY1VSdLCSot1fptJmKKeoTMcLy9QhxnnQYGlFpbrGh+p4YZmyi8rMoCd3xYc5/7zml1aYAUySlF1Uruyicm09mue0vNVS9dlPjKgKcLr2jA4a0SW2fo0BAAAAAAAAAHgdQUytVFhYmMaPH6/vvvtOCxYs0OHDhx26mKv2xRdfKC+v6sf+yy67rMb8MWPGKCIiQrm5uZo9e7YeeOABWSyWGuVmzZplDjurBwAAoD5+2HpMv6Qc1+HsYh36LWDJ3S6vjuUVu5zXJqJ+QUz+vtbfApIC1LaWZa87o6NuGN6pXnUDrZmP1aKY0ADF1JKFrFtCmBb832hJVZnSsovKlZFfqvT8ErPrxvS8quH06ul5pSr9rQu6+HDndafnuQ4odMZmSKm5VV1HrjuYowm9nHcLKUm3f7hO4UF+6hAdrKTooKr/o4IVGezn9DoIAAAAAAAAANB8CGJqoWbNmqVp06ZJkp544gk9+eSTNcrcd999+u6771RRUaHbb79dX3zxhXx8/vfEf2Zmph588EFJUmRkpG666aYadfj7++vOO+/UzJkztX37dr300ku6//77HcqsXLlS7777riRp9OjRGjJkSFO9TQAAcBIpKa/UoeNVAUmHs4sUGuirywbUDLKWpAXb0vTZr4cbtJ5juSUu5yX+FojkY7UoISxAbSIClRgR9Nv/gYoPD1R8WIBiQ6syKoUH+roVuGC1EtwA1MbXx2pmKuutcJflDMNQXkmFMvJLlBTlPMNTXkm5Qvx9VFhW6XR+XRJdBCQWlVXo282pTueFBfj+lq3qt8Cm6ldUsNpHBbmVWQ0AAAAAAAAA0DgEMXnA8uXLtWfPHnM8MzPTHN6zZ49DViNJmjp1aoPWM27cOF199dX65JNP9NVXX2nixIm6++671bZtW23evFnPPvusDh48KEl64YUXFBUV5bSe+++/X59++ql27dqlBx54QHv27NHVV1+toKAgLV68WM8995wqKioUFBSkv/3tbw1qKwAAODkUl1cqqzJAuZX+em/lIaUVViols0gpWYVKPSG46PT2ES6DmNq7CF5wR15JhcoqbPL3tdaYd16/RI3pEa/Y0AD5EHgEtDgWi0URQX6KCPJzWWZghyhtffpcFZZWKDW3WEdzSpSaW6wjOSVK/a2LyaM5xTqaW6yScluN5V110Xg423UWt/zSCm1LzdO2VOdd1rUJD9Szl/XV+FqyPAEAAAAAAAAAGocgJg945513NHv2bKfzVqxYoRUrVjhMa2gQkyS99957ysvL07x587R48WItXrzYYb7VatXjjz+uW265xWUdYWFh+vbbb3X++edr9+7deuutt/TWW285lAkPD9eHH36o/v37N7itAACg9flxW5oWbk/T/sxCHcgq0rG8EkndJEk/LE6pddnaAgbaRzkPMpCk+LAAtY8KUvuoYLWLClLbyCAlhgea2ZSiQ/xdZk8KD/RTeKDr4AgArUdIgK+6xoepa3yY0/mGYSi7qFxHTwhsSgh3nonpYFZRg9tyLK9Ewf7OL5/LK22a9OZKdYwOVtswX+0ujVCkT5nySioU7jopFQAAAAAAAADgBAQxtXJBQUH69ttv9dFHH2nWrFnauHGjcnJylJCQoJEjR+qOO+7Q8OHD66yna9euWr9+vV5//XV99tln2rNnj8rKypSUlKTzzz9fd911lzp27NgM7wgAADSH0oqqDEp7MwpUUl6pywc6z5i08VCOPll7qEHryCosU1FZhdMb/z0Tw3TR6W1/C1YKMrtsahtJt00A3GOxWBQd4q/oEH/1bRdRZ/nOcSG6/5weOnS8SAePF+lQdpGO5pSo0ma4tb4OMc4zyB06XqSNh3K08VDOb1OSJEn/+etKxYT4q3NsSNUrLkSdY6r+7xQTwncdAAAAAAAAAJyAICYPmDVrVo0u4+pr6tSp9crQdO211+raa69t1DpDQkL0wAMP6IEHHmhUPQAAoOXIKSrT3owC7Ukv0N6MQu1NL9CejAIdOl6k6vv2CeEBLoOYOsWG1HudsaH+avdbUFJxWaXTIKY+bSP02jUD6l03ADRUl7hQ3T62q8O08kqbjuWW6GB1YJPd/4eyi3W8sEyS5OdjURsXGZ72Zxa6XGdWYZmyCsv0y4HsGvPaRgSqc1yInrioj7onOM82BQAAAAAAAACnEoKYAAAATgJZBaXafCT3f8FKGQXam16grN9uwNcmLa/UZcakTi4yj4RYytUrKVZd4sPVMTZYnWNC1DEmRB1jghUSwCkmgNbBz8eqpOhgJUUH60wn8wtKK3ToeJHS80vlY3XejWVtQUy1OZpboqO5JfL3sTqdn11Ypo/WHFTX+FB1iw9Vh+hg+booCwAAAAAAAAAnA+4wAQAAtBKVNsPlTfR5m1P1+H+3NrjuA1lF6pUYXmN6clyorhmapI4xIeoUE6zYQOn7z+fIz2LoD9ePU3h4zWUA4GQRGuCrXonh6pXouszo7nHy97VqX0ahdh/L1eaUY8q3+cuQ8+9re75Wi9pHBTmdt/1Ynv78w05z3N/Hqs6xIeqaEKqucaHqlhCqbvFh6hQbrABfuqYDAAAAAAAA0PoRxAQAANDC2GyGDmUXaeexfO1Ky9eO3/5PzSnRhifOdhrI1CU+tEHrahMeqM6xIaqs7lvuBNEh/nr+8tPM8by8PC20OC8LAKeibglh6vZbd3B5eXl6442fVGlYdMGVk5VRYtH+zELtyyxUSmah9mcW6lheiblsbdmV9qQXOIyXVdq0My1fO9PyHab7WC3qGB2sLr9lbOqWEKqucWHqmRgmPzI3AQAAAAAAAGhFCGICAADwEsMwlJ5fagYr7TxWdXN6d1qBissrnS5z8HiROseG1JjeNc51EJOv1aJOsSHqGheqLvEh6hIXqq7xoUqOC1UoXb8BQJPzsRjqHBus051kqysqq1BKZpH2ZxbKZrgOCj0xiMmVSpuhfb8FSv24Lc2cvnHG2YoIJogJAAAAAAAAQOvBXSsAAIBmdDCrSG//tE8706oCl3KKyuu1/M5j+U6DmOLCAtQuMkhxYQHqGh+qLnGh6hIXoq7xoUqKDiYbBwC0EMH+vurdNly929beHWenmBCd0TlaezMKlFlQVq91JEYEKiLYz+m877cc05tL96pXYph6tglXjzZh6tkmTJHB/vVaBwAAAAAAAAA0NYKYAAAAmpDNZujA8SIlRgQq0M+nxvyySpvmrDrQ4Pp3HsvXuX3b1JhusVi04qFxDa4XANCy3HhWZ914VmdJ0vHCMu1JL9Ce9ALtTs83h1NzS5wu27NNmMt6Nx3O0YZDVS97bcID1fO3wKaebaq6o0uODZW/L0GwAAAAAAAAAJoHQUwAAAANVFJeqZ3H8rUtNU/bjuZpW2qetqfmqaisUp/dOlxDOkXXWKZTTLD8fa0qq7DVWX9UsJ96tAlTj4Qwdf/t/x613JgGAJycokP8NbRztIZ2djyu5JeUmwFNVQFOVf/XluVp57F8p9OP5ZXoWF6JluzMMKf5+VjUJS5UPdqEqU/bcJ3WPlLDkmOa5k0BAAAAAAAAwAkIYgIAAHDD8cKy3wKVcs2Apb0Zhaq0GU7Lbzua5zSIydfHqq5xodqWmmdOC/b3UbeEMPW0C1bq3iZUcaEBslgsHntPAIDWLSzQTwM6RGlAhyiH6Ybh/NgkSTtcBDE5U15paMexfO04lq//bjiqvu3C9c0fRza4vQAAAAAAAABQG4KYAAAAnKi0Gfrbgl3aerQqy9KxPOdd9riy7Wiey3nXDE1SXkmFmVmpXWSQrFaClQAATaO2ANjnL++nHcfytCO1KjhpT3qByirrzg4oSX0SI1zX+912bTuap77tItSnbbj6tI1Qx+hgjm8AAAAAAAAA3EYQEwAAOGUZhqGySpsCfH1qzPOxWvTZL4frHbxU7UhOsct5Nwzv1KA6AQBorFHd4zSqe5w5Xl5pU0pmobYfy9dOu+AmZ8exPu1cd1P3854sbT6Sq592Z5rTQgN81TsxXL3bhpvBTV3jQ+XnY23aNwUAAAAAAADgpEAQEwAAOCUYhqGjuSXafDhHmw7navORqtfUEZ1094TuTpfp3Ta8ziAmi0XqHBOiXm3DzRu1fRLDFRcW4Im3AQBAk/LzsapbQpi6JYRJp7c1p+eVlGvXsXxtP5Zf1Y3q0Vyd1j7SaR3llTbtdNJNXUFphdakHNealOPmNH9fq3q2CVO/dhE6vX2kTkuKULf4MPmQsQkAAAAAAAA45RHEBAAATjqGYehYXok2/xasVB20dLywrEbZzYdzXdbTOzFci3akm+MBvlb1TPxfsFLvxHD1bBOmkABOqQAAJ5fwQD8N7hStwZ2i6yxbny7pyips2nS46tj84eqDkqTfj07Ww+f1alR7AQAAAAAAALR+3HEDAACtXkZ+qTbZZVjadDhXmQWlbi276UiuDMOQxVIzA8So7nEqr7RVZVdqG65OMSHypQscAAActI0M0uvXDtTWo7naejRPW4/mKrOgZuCwK/3aRbic98+le9UpNkSnt49Um4jApmguAAAAAAAAgBaKICYAANDqzfxmm77aeLRBy2bklyotr9TpjdGhnaM1tHPdGSgAADiVRQT56YLTEnXBaYmSqjIipueXauvRXG05kmcGNx3OLna6/OkuuqnLLSrX89/tMMfjwwJ0WvtInd4+QqclVf0fGezf5O8HAAAAAAAAgHcQxAQAAFosm83Q/qxCbTiYo+yiMt00Mtlpuf5JkW4HMUUE+em09hHq1+63V/sIJYQHNGWzAQA4pVksFiWEByohPFDjeiaY03OKyrT1aJ42H8nVxkNVGRSLyyvVPirIaT2bjuQ4jKfnl2rB9jQt2J5mTusQHazTkyI1sEOkBnSIUu/EcPn7kjURAAAAAAAAaI0IYgIAAC1GdmGZNhzK0fpDOdpwKEcbDmYrr6RCkhTs76NpZ3aWj7Vmt2/9O0Q6rS8s0NcMVOrXLkKntYtUUnSQ067jAACAZ0UG++vMrrE6s2usOS2/pNzlcXnT4dw66zx4vEgHjxfp69+Cmf19rerXLkIDO0Tq5lHJig+jCzoAAAAAAACgtSCICQAAeEVZhU3bU/OqgpYOZmvDoRylZBW5LF9UVqldafnqlRheY16ftuGKCvZT94SwqixL7SPVr12EOkYHy+ok6AkAALQMYYF+LuclRgRqeHKMthzJVX5phVv1lVXY9OuBbP16IFt/GNO1qZoJAAAAAAAAoBkQxAQAAJrNoeNFmrPqgH49kK3NR3JVVmGr1/LrD+Y4DWIK8PXRuscnkmEJAICTyOUD2+vyge1lsxnal1mozUdytPFQrjYdztHWo3kqreU8olNMsKJD/J3OW7AtTa8t3mN2QTewQ6TaRZKpEQAAAAAAAPA2gpgAAECzKSit0FvL9tV7ufiwAPVPilRipOsuYbjxCADAyclqtahrfKi6xofqsgHtJUnllTbtSsvXxkO5Wn8wW+sP5WhPeoG5zMAOUS7rW5tyXBsP5WjjoRy9vyJFUtW5xoAOkRrYIUqDOkapX/sIBfj6ePR9AQAAAAAAAHBEEBMAAGi04rJKbTycY3bf8n8Tu6tvu4ga5bonhCkswLfWLmEC/azq1y5C/ZMi1T8pSgM6RCoxIpAgJQAAYPLzsapP2wj1aRuha8/oIEnKLSrXhsM5WncgW6e1r3keUm3dwewa09LzS/XD1jT9sDVNkuTva9Xp7SM0qGO0hnSqCmyKDHae2QkAAAAAAABA0yCICQAA1Ft6Xol+OZCtX1Ky9euB49p6NE8VNsOcP6JLjNMgJh+rRQM6RmnZrgxzWnJciAYkRal/h0gNSIpUjzZh8vOxNsv7AAAAJ4+IYD+N7h6n0d3jXJYpr7Rp0+HcOusqq7BpbUq21qZk682lVdO6J4TqotPa6o/juzVVkwEAAAAAAADYIYgJAADUymYztDu9QGtSjuvXlOP69WC2Dh0vrnWZXw9k66aRzuddPqCd+reP0KBO0erfPlIRwX4eaDUAAEBNFknvThmi9Qezte63buhyisrdWnZXWoGO5pZ4toEAAAAAAADAKYwgJgAA4NRHqw9q8c50rU057vbNvWq/HMiWYRhOu4C7dEC7pmoiAABAvfj6WHVWt1id1S1WkmQYhvZnFmr9wRytO1jVLe7OtHwZhvPlB3eMcln3de+sktVi0eDfuqDr3yFSwf787AIAAAAAAAC4i1/TAACAUwu3p2nhjnS3y1stUu+24RrUIUqDOkXLZkg+NWOYAAAAWgyLxaLkuFAlx4Xqd4PaS5Jyi8u1/mBVt7lrU45rw6EclVbYJElDOkU7raeorEKr9h1Xpc3QT7szJVV1o9u3bbiGdo7WGZ1jNKRztCKCyEAJAAAAAAAAuEIQEwAAp5iisgqtO5CjNfuzJEn/d3YPp+WGdo6uNYgpLMBXAzpGaVCHKA3uFKX+SZEKCeDUAgAAtG4RQX4a0yNeY3rES5LKKmzaejRXGw/lKCk6yOkyGw7mqNLmmL6p0mZo4+FcbTycq7d/2i+LRerVJlxnJFcFNZ3ROVpRIf4efz8AAAAAAABAa8GdRgAATnK5ReX65cBxrdl/XKv3H9eWI7mq+O0mW1Swn+6e0F1Wa82USUM7O2YaaBcZpCGdqrIsDe4Ype4JYfJxshwAAMDJxN/XqgEdojSgg+uu5NamZNdZj2FI21LztC01T++vSJEk9UgI0xnJ0bplVLLaRwU3VZMBAAAAAACAVokgJgAATjLZhWVavT9Lq/ZVBS3tOJYnw3BRtqhcezIK1D0hrMa8vu0idN0ZHTSkU7SGdI5Wu0jnmQcAAABOddcN66DuCaH65UC2fkk5ri1H82pkZnJmZ1q+dqbl65ZRyc3QSgAAAAAAAKBlI4gJAIBWrrC0Qj/vzdLKvVlauS+r1qAlZ1bvP+40iMnPx6pnL+vXhC0FAAA4OcWGBui8fok6r1+ipKruezcczNHq/ce1en+W1h3MUVmFzemy7SKDXGZhWncwW/9ee8jsgq4tQeUAAAAAAAA4iRHEBABAK7c9NU83f/BLvZbxtVrUt12Ezugcrf7tIz3TMAAAgFNUsL+vRnSN1YiusZKk0opKbTyUq9X7srRqf5Z+PZCtkvKqoKYzkqNd1rNkZ4Y+WXtIn6w9JEnqEB2sEV1iNPy3V3xYoOffDAAAAAAAANBMCGICAKCFKy6v1KHyEMX4lDqdf1r7SAX5+ai4vNJlHf6+Vg1IitQZnaM1tHOMBnSIVEgApwEAAADNIcDXR0M7R2to52j9Ud1UVmHT5iM5WrXvuPq1i3C53Kp9WQ7jB48X6eDxIjOoqVt86G9BTbEalhytyGB/j74PAAAAAAAAwJO4ewkAQAtTUl6p9QdztHJfllbtzdK6g9mqsHXWqOAjTsv7+1o1uFOUftqdaU4L9LNqSKdondE5Wmckx+i09hEK8PVprrcAAACAWvj7WjWoY7QGdXSdhamkvFIbDuXUWs/u9ALtTi/Q7JUHZLFIfdtGmJmaesb4NXGrAQAAAAAAAM8iiAkAAC+rqLRp05FcrdidqZ9/C1oqrbDVKHe0PMRlHWN6xKu80qbhybEa0TVGp7ePlL+v1ZPNBgAAgAdV2gw9cE4Prd5/XGv2H1ducXmt5Q1D2nwkV5uP5Oqfy/bpvN5x6tQ8TQUAAAAAAACaBEFMAAA0M8MwtDejUCv2ZGr5nkyt2pul/NKKOpc7UhEiwzCczpt+VmdNP6tzUzcVAAAAXhIS4KubRibrppHJstkM7TiWr5X7svTznkyt3n9cBXWcPw7tFKn0VOfz9qQXqFNMsHx9CHoHAAAAAABAy0EQEwAAzegfS/ZozsoDSs0tqddyFhkKs5Yrt7hCEREeahwAAABaJKvVot5tw9W7bbimn9VZFZU2bT6Sq5/3Zmnl3iytTTleI5PnGR0j9PXKmnWVVdh00WvL5WO1aFhytM7sGquR3WLVJS5UFoulmd4RAAAAAAAAUBNBTAAANKPScptbAUwWi9S3bYSGd4nR6W2CtG7+Z/K32BQZfE4ztBIAAAAtma+PVQM6RGlAhyjdPrarSisqtf5gjn7eU9U9cWZBqdpFBjpddsOhHBWXV0qSFmxP14Lt6ZKkxIhAM6DpzK6xig0NaLb3AwAAAAAAAEgEMQEA0CTKK23aeChHy/dkandagV6/bqDTcmd1i9UrC3c7ndcjIUwjusZoeHKMzugco4hgP0lSXl6etvxoc7oMAAAAEODro2HJMRqWHKP/k1RRaVNRYYHTsj/vzXQ6PTW3RJ//elif/3pYktQrMVwju8XqrK6xGto5WoF+Pp5qPgAAAAAAACCJICYAABrEMAztSS/QT7sztWJPplbty1JhWaU5/8GsInWICa6xXP+kSIX4+6iwrFIJ4QE6q2uczuoWozO7xCo+3PnT8gAAAEB9+PpYXc47eLzIrTq2p+Zpe2qe3lq2T/6+Vg3pFKWzusZp2pmdCGgCAAAAAACARxDEBACAm3KKyrR8T6aW7crQT7sza+0WbvmeTF0b06HGdD8fq/529QB1jg1Rl7gQWSwWTzYZAAAAcPDXK/vrofN6auXeLP20O1PLd2fqWF7t3R2XVdi0Yk+Wtqfm6/ejkpuppQAAAAAAADjVEMQEAIALFZU2bTyco6W7qgKXNh3Okc1wb9kVezJ17Rk1g5gkaWLvhCZsJQAAAFA/8WGBuqR/O13Sv50Mw9DejAIzoOnEDKP2zuwaK6vVeRD+z3szVVxWqWHJMQoJ4OcmAAAAAAAA1B+/KgEA4ERpRaWGP79IxwvL6rVczzZhOqtrrMb1jPdQywAAAICmY7FY1DU+TF3jwzTtzM4qr7Rp/cEcLd+doZ/2ZGrjof8F8o/sGuuynn8u3aeluzLk52PRkE7RGt09TqN7xKlHQhjZRwEAAAAAAOAWgpgAAHAiwNdHybEhdQYxJUYEamS3WJ3ZNVYjusQqLiygmVoIAAAAND0/H6uGdo7W0M7R+r+zeyi3uFwr92Zp+Z4MjezuPIiptKJSq/dnSZLKKw39vDdLP+/N0vPf7VBCeIBGdasKaDqra6wig/2b8+0AAAAAAACgFSGICQBwSjEMQ9tT87Vsd4aW7cpQ94QwPXlxH6dlR3WP0y8Hsh2mBfpZdUbnGI3qHqfR3WPVJS6UJ8sBAABw0ooI8tO5fdvo3L5tXJb59UC2SsptTuel5ZXqs18P67NfD8tqkU5PitTo7nEa1T1Op7ePlI+L7ukAAAAAAABw6iGICQBw0sstKtdPezK0ZGeGlu7KUEZ+qTnvQFaRnriot9NApFHd4/TXH3epZ5swjeoep5HdYjWkU7QC/Xyas/kAAABAi2aRRcOSo/VLSrYqqvuec8JmSOsP5mj9wRz9bcFuRQb76ayusbp9bFf1SgxvxhYDAAAAAACgJSKICQBw0jEMQ9tS87RkZ4aW7EzXuoM5qnRxM+VITrH2ZRaqS1xojXn92kVo9SPjlRAe6OkmAwAAAK3W8C4xGt5luApKK/Tznkwt2131AMHh7OJal8spKtc3m1J16+guzdRSAAAAAAAAtGQEMQEATgp5JeVasTtTi3ema8nODKXbZVuqy7JdGU6DmHysFgKYAAAAADeFBvjq7D5tdHafNjIMQ/szC7V0V1U21FX7spx2ORcbGqDeLrIwHc4u0k+7MzWmR5wSI4I83XwAAAAAAAB4GUFMAIBWb83+47r27VW1dl1xoqToII3qFqdR3eM0okuMB1sHAAAAnHosFouS40KVHBeqaWd2Vkl5pdamHNfS37p43p1eIEka1T1WVmvNrp0l6YetaZr5zTZJUq/EcI3tEaexPeM1IClSvj7WZnsvAAAAAAAAaB4EMQEAWr3ebcNlcX7fwxTga9XwLjEa0z1Oo3vEq1NMsCx1LQQAAACgSQT6+WhktziN7BanxyQdzSnWsl0ZSnaSEbXa4h3p5vD21DxtT83TP5bsVUSQn0Z1j9PYHnEa3T1OMaEBzfAOAAAAAAAA4GkEMQEAWizDMLQrrUBLdqZr8c50TR3RWef2bVOjXGiAr4Z2jtaKPVkO0ztEB2tsjziN6Rmv4ckxCvTzaa6mAwAAAKhF28ggXT20g8v5haUVWr0/y+m83OJyfb3xqL7eeFQWi3R6+0iN7RGvsT3j1LdthMvMTgAAAAAAAGjZCGICALQoJeWVWrkvS4u2p2vRjnQdySk25yVFBTsNYpKkMd3jtTYlW2d0jtbYHvEa0yNOnWNDyLYEAAAAtEJ5JeU6t2+ilu5MV15JhctyhiFtOJSjDYdy9PKCXYoNDdCYHnGaNKi9hiXTbTQAAAAAAEBrQhATAMDr0vJKtGhHuhZuT9eKPZkqLq90Wm7JrgwZhuE0MOnqoUm6blgHBftzaAMAAABau8SIIL12zQBVVNq0/lCOFu9I1+KdGdqemlfrcpkFpfr818PqnhBKEBMAAAAAAEArw51eAECzs9kMbT6Sq4U70rVoR5q2HKn9RkS1jPxSbT2ap77tImrMCwv0a+pmAgAAAPAyXx+rhnSK1pBO0Xrg3J5KzS3Wkp0ZWrwjXcv3ZKqozPkDEGN7xDudbhiGft6bpcGdohTgS3fTAAAAAAAALQlBTACAZvXl+iN65tvtyiwodXuZdpFBGt0jTmN7xKtLXKgHWwcAAACgJUuMCNI1QzvomqEdVFpRqbX7s7V4Z7oW70zXvoxCSVL7qCB1jXd+3bAzLV/XvbNaIf4+GtktTuN7xWtsz3jFhgY059sAAAAAAACAEwQxAQCaVUSwX50BTFaLNLBDlMb1itf4ngnqnhDqtAs5AAAAAKeuAF8fndUtVmd1i9XjF/ZWSmahluxMl4/V4vL6YeH2dElSYVmlvt96TN9vPSaLReqfFKkJvRI0rme8erYJ4/oDAAAAAADACwhiAgA0mYpKm349kK1FO9L1+9FdFB3iX6PM8OQYBfn5qLjcsduHsEBfje5e9ST06O7xTpcFAAAAAFc6xYZoamznWsss2J5WY5phSOsP5mj9wRz9+YedahcZpPG94jW+V4KGJUfT7RwAAAAAAEAzIYgJANAohaUVWrYrQz9uT9PiHenKLiqXJPVMDNNlA9rXKB/o56Mzu8ZqwfY0JceFaHzPeI3rmaDBnaLk52Nt7uYDAAAAOEWUV9pktVhksVQFLrlyJKdYH6w8oA9WHlCwv49GdovV+F4JGtsjXnFhdDsHAAAAAADgKQQxAQDqLS2vRAu2p+nHbWn6eU+WyiptNcos2pHhNIhJku47p7sevaCXOseGeLqpAAAAACBJ8vOx6j9/GKHMglIt3pGuhdvT9dPuDBWWVbpcpqisUj9sTdMPW9M0slus5kw/oxlbDAAAAAAAcGohiAkAUCfDMLQzLV8/bk3Tgu1p2ng4t85llu5MV3mlzWl2pZ5twj3RTAAAAACoU2xogK4YnKQrBieptKJSq/cd18LtaVqwPV1HcopdLjehV4LLeYZhyGKxeKK5AAAAAAAApwyCmAAALq07mK2vNx7Vgu1pOnTc9Y/5J+qVGK4JveJVWuE8iAkAAAAAWoIAXx+N6h6nUd3j9OTFhnalFWjB9jQt2pGudQezHbqdG9cz3mkdNpuhc19Zpr5tIzSxd4JGdY9TSAA/uQEAAAAAANQXv6gAAFyatylV769IqbOcr9WiYckxmtg7QeN7xat9VLDnGwcAAAAATchisahHmzD1aBOm28d2VVZBqRbvzNCiHWlKyytVUrTz65wNh3O0K61Au9IK9MX6I/L3terMLjE6u08bje8Vr/iwwGZ+JwAAAAAAAK0TQUwAcIrLyC9VXFiA03kTeyfoneX7nc4LC/TV2B7xmtA7QWN6xCk80M+TzQQAAACAZhUTGqBJg9pr0qD2MuxTMp3gx21pDuNlFTYt3pmhxTszZLFI/ZMiNbF3gs7unaAucaF0OwcAAAAAAOACQUwAcIoxDENbj+bpx21pWrA9TdtS87Tq4fFKCK/5dPCgjlGKDPZTTlG5JKldZJAm9k7QxN4JGtIpWv6+dBUHAAAA4ORXW+DRghOCmOwZhrT+YI7WH8zRi9/vVOfYEDOgaUCHKPlYCWgCAAAAAACoRhATAJwCyipsWrUvSwu2p2nBtjQdzS1xmL9we7quPaNDjeV8fayaNqKzLBZpQq8E9UoM46lhAAAAALAz68ahWrAtTT9uS9OqfVmqsLnO2rQ/s1BvLdunt5btU0yIvy48LVFPXdK3GVsLAAAAAADQchHEBAAnqaKyCi3dmaEfth7Twh3pyi+pcFn2x23HnAYxSdJdE7p5qokAAAAA0Oq1iwzSlBGdNGVEJ+UWl2vJznTN35ampTszVFDq+josq7CsxgMmAAAAAAAApzKCmADgJJJTVKYF29P1w9ZjWrYrQ6UVNreW23o0TxWVNvn60D0cAAAAADRURJCfLunfTpf0b6fSikqt2ndcP247pgXb0nUsr2bA0tm9E1zWtWhHmrrEhapjTIgnmwwAAAAAANBiEMQEACeJR+Zu1qdrD6mylq4L7CVFB2lirzaa2DtBQzpFEcAEAAAAAE0owNdHo7vHaXT3OD19saHNR3L142/dzu1My5fVIo3v5TyIqbzSprs+2aD8kgr1bBOmc/u20Tl92qhnG7r4BoDmlJ6erjVr1mjNmjVau3at1q5dq6ysLEnSlClTNGvWrCZf58cff6z3339fmzZtUk5OjhISEjRy5EjdfvvtGj58eJOvDwAAAGhJCGICgJNETIh/nQFMp7eP0Nl92mhCrwR1Twjlx28AAAAAaAZWq0WnJ0Xq9KRI3XdODx3IKtTGw7mKDvF3Wn71vuNml+A7juVrx7F8/W3BbnWMCda5fdronL5t1L99pKxWrukAwJMSElxnzGtqxcXFmjRpkubNm+cw/eDBg/rwww/18ccfa8aMGXriiSearU0AAABAcyOICQBaAcMwtOVIntamHNeNZ3V2WuacPm302qI9DtN8rBYNS47WOX2qMi4lRgQ1R3MBAAAAALXoGBNSazdxP2475nT6gawi/XPZPv1z2T4lhAfonD5tdG6fNhraOZrsugDgYR06dFDPnj01f/58j9R/4403mgFMY8eO1V133aW2bdtq8+bNeu6557R37149+eSTSkxM1C233OKRNgAAAADeRhATALRQFZU2rU3J1g9bj+nHbWk6klMsSZrQK0EdYoJrlO/TNlztIoOUWVCqUd3jdE6fNhrfM15RLp7sBQAAAAC0TGGBfooJ8VdWYZnLMml5pfpg5QF9sPKAIoP9NKFXgs7t00ZndYtVoJ9PM7YWAE5eM2bM0JAhQzRkyBAlJCQoJSVFnTs7f8CwMRYtWqRPPvlEknTRRRdp7ty58vGp+i4fMmSILr74Yg0aNEgHDx7Ugw8+qCuuuEJRUVFN3g4AAADA2whiAoAWpKS8Uiv2ZOqHrce0YHu6jjv5wfqHrcd086jkGtMtFovemTJYHWOCFezP1zsAAAAAtFb3ndND90zsrl8PZOv7Lcf0w9Zj5oMtzuQUlevzXw/r818Pq014oH5+aBxdzQFAE3jqqaeaZT0vvfSSJMnX11f/+Mc/zACmarGxsXrhhRd0zTXXKCcnR++8847uv//+ZmkbAAAA0Jy4yw0AXpZXUq7FO9I1f2ualuxMV2FZZa3lXQUxSVKvxHBPNBEAAAAA0Mx8rBYN7RytoZ2j9fiFvbTlSJ6+35qqH7amaU96gcvlhiVHE8AEAK1Ifn6+Fi5cKEmaMGGC2rdv77Tc5ZdfrvDwcOXl5Wnu3LkEMQEAAOCkRBATAHhBdmGZftyWpu+2pGr5nkyVVxpuLdcpJliDO0XLMAxZLPwoDQAAAACnAovFon7tI9SvfYTuP6en9qTn64etafp+yzFtPpLrUPbcvm1c1vPyj7sUFeyns/u0UdvIIE83GwDghrVr16qsrCob++jRo12W8/f317BhwzR//nytXbtW5eXl8vPza65mAgAAAM2CICYA8IIbZ6/V+oM5bpXtnRiuc/q00bl926h7QijBSwAAAABwiusaH6au8WG6fWxXHc4u0vytafp+6zFtPZKrUd3jnC5TVFahfy7bq5Jym578eptObx+hc/q20bl92ig5LrSZ3wEAoNq2bdvM4Z49e9ZatmfPnpo/f74qKiq0e/du9e7d29PNA4BWzzAMGYYhq9XqdH5WVpZKS0vNcie+SkpKlJSUJIvFoqNHj+r48eOyWCyyWCwKCAhQQkKC03pLSkpUXl4uHx8fhxf3eACgdgQxAYAXnN27jcsgJotFGtwxSuf0aaNz+rRRUnRw8zYOAAAAANBqtI8K1o1nddaNZ3VWQWmFgv2d/9y3bFeGSspt5vjGw7naeDhXL36/U90TQnVu30Sd36+NeiSEcWMFAJrR4cOHzWFXXclVS0pKMocPHTrkdhCT/TqcSU1NNYfz8/OVl5fnVr2NVVBQ4HQYaAz2q5ObYRiqrKxUWVmZKioqVFFRocrKSnPY/lU93TAMxcTEqEOHDk7rPHDggPLz82tdb7t27SRJaWlpDtNDQkIUFOQ8w+nRo0drlJeqsqz6+PjI19fX6cvHx0d+fn4KCwtzZ5OgFeJ7Cp7grf2qru/PhiCICQCa2OHsIn2/5Zg2HMrRa9cMcPrj73l92+iF73eY434+Fp3ZNVbn9GmjCb0SFBcW0JxNBgAAAACcBEIDXP/U9/2WYy7n7Uor0K603Xp14W4lx4bovH5tdF7fRPVpG05AEwB4mP2Nn9DQ2jPjhYSEmMP1uTllH/xUlzlz5igiIsLt8k1lzpw5zb5OnPzYr04uvXr1UmhoqHx8fOq97M6dO/Xtt986ndetWzfFxMQ0qE2pqalauHCh03kdO3ZUYmJijemGYZiBVq6UlZVp3bp1TucFBwcrLCxMZWVlKi0tVWlpqSorKxvUfngf31PwhObcr3Jzc+suVE8EMXnYgQMH9Oqrr+rbb7/VoUOHFBAQoC5duujKK6/U7bffruDghmVYSUlJUefOneu1TMeOHZWSklJj+pgxY7R06VK36jAMo17rBE4VKZmFmrclVd9vOaZNh//3ZX3HuK7q2Sa8RvlOsSEa1DFKsaH+Or9fosb2jFd4IH3YAwAAAAA849IB7WS1WrRgW5rySlzfMNmXWajXF+/V64v3qmNMsM77LUNTv3YRBDQBgAeUlJSYw/7+/rWWDQj434OPxcXFHmsTAHiSj4+PAgMDa7wCAgJ07NgxHT161OlyVqu1QQFM1et0xWazuZxXl9rumza0rZJqDXCKiIhQx44dHaaVl5erpKTE6YsAJwCtDUFMHvT111/r+uuvd0i9WlRUpF9++UW//PKL3nnnHX377bfq2rVrs7SnR48ezbIe4FSxJz1f8zYf03dbjml7qvMUy/M2H3MaxCRJn986nB+AAQAAAADNYkyPeI3pEa/ySptW7cvSD1uP6YetacrIL3W5zIGsIr25dK8+++WQ1jw6QT5cwgJAkwsMDDSHy8rKai1bWvq/72xX3Rc5c+jQoVrnp6amaujQoZKkG264wew2ydMKCgrMTAE33HBDnZmoAHewX7UcFRUVKikpUXFxsfl/aWlprQE6/fv31yWXXOJ03v79+5WTk9OgtiQlJWncuHFO56WlpSk3N1cWi8W8Z1M9bLFYVFFRof3790uSOnfuLF9fXxmGIcMwlJCQoDFjxjit98CBA8rOzm5Qgoj4+Hj94Q9/cDrv8OHDysjIcJjm5+fnsgu66qCxoKAgBQYGKjY2lntTXsb3FDzBW/vVkSNH9PzzzzdpnQQxecj69et11VVXqbi4WKGhoXr44Yc1duxYFRcX65NPPtHbb7+tXbt26YILLtAvv/xS735N27Vrp82bN9dZ7vnnn9dHH30kSZoyZUqtZQcPHqz333+/Xu0ATiWGYWjHsXx9tzlV87Yc0570ulM2f78lVf83sbvTeZwkAgAAAACam5+PVSO7xWlktzg9fXFfrTuYre+2HNN3m1N1NLfE6TLn9G0jHyvXsADgCfb3BurqIq6wsNAcrs+Nqfbt29erPeHhzh/K9KTQ0FCvrBcnN/Yr79i5c6eys7MdAi/dVVFR4fJvFhoa6hDEVB24U9vL19dXPj4+8vPzc5ntrq59JC8vTwsWLJAknX322W7vU/369ZNUlempsrLS4VVRUaHy8nKXr9r23foGRVVWVqqwsFCFhYXy9/dXly5dXJazWCyyWq31qh+Nw/cUPKE59yv7hD5NhSAmD7nrrrtUXFwsX19fzZ8/X8OHDzfnjRs3Tt26ddMDDzygXbt26S9/+YuefPLJetXv5+envn371lqmsrJSS5YskVR14XHZZZfVWj4kJKTOOoFT0ZYjufp2c6q+25yqlKwit5aJDPbTxF4JOr9fogzDIGAJAAAAANDiWK0WDe4UrcGdovXYBb208XDubw/upOrQ8f91U3R+30SXddz7740KCfDReX0TNbRzNMFOAFBP9gFGhw8f1uDBg12Wtc+olJSU5NF2AYAzhmGouLhYhmEoJCTEaZny8vIGBTBJjl1snigxMVGxsbEKCAiQv79/qwm2sVqtslqt8vPza5L6goKCFBYWprKysnpvZ1d/M6kqm8qBAwcUEhKi8PBwhYWFKSwsTEFBQdzjAtCsCGLygDVr1uinn36SJE2fPt0hgKnavffeq/fff1/bt2/XK6+8okcffbTJDl7VFixYYPYbO2nSpHqllwXwP8/N266f92bVWS421F9n92mj8/q20bDkGPn5tI4TaAAAAAAALBaL+idFqn9SpB46r6e2Hs3TvM2pWrkvS8OSo50uk1NUpv9uOKIKm6EPVh5QbKi/zunTRuf3S9QZnaPly3UxANSpd+/e5vCOHTtqLVs939fXV926dfNouwBAqurmMi8vT3l5ecrPz1d+fr4qKysVGxurPn36OF0mJCREWVl131Op7uKs+hUYGKjg4GCX5WubdypJTk42h202m9lV34kvZwFhtW3D/Px82Ww28+9czcfHxwxoqs7WFxAQ0LRvCgDsEMTkAV9++aU5PG3aNKdlrFarJk+erIcfflg5OTlavHixzj777CZtxwcffGAO19WVHADXzuuX6DKIKSE8QOf2aaPz+iVqSCeeOAUAAAAAtH4Wi0V920Wob7uIWsv9uC1NFbb/dWeRWVCmD1cf1IerDyoq2E/n/Ha9PKJLjKebDACt1pAhQ+Tv76+ysjItXbpUDz30kNNyZWVlWrVqlblMUz8UDQCGYai0tFQ5OTnKzc1Vbm6uiouLnZa1D3I5kX22H4vFouDgYIWEhCgkJETBwcEKDg5WYGBgq8mk1JJZrVZzm57IPsCpuju5yMhIl3W5+ptWVlYqJyfHoSu/oKAgRUREmK/AwECyNQFoMgQxecDy5cslVR2kBw0a5LLc6NGjzeEVK1Y0aRBTfn6+GUzVqVMnjRo1qsnqBk4WhmH8P3v3HR5XXt+L/33O9BlNlTSSRl1WsSzZlsu6bGEbu8B26hJgWQglkBAglwu5gZuEJPeG5CaQbH4QEkJZahbCLmwxy9K2x2uvmyTbsmT1MurTezu/P85oZFmjanW9X89znhmd8z1nvvIz1syceZ/PB2cHPDjWMowz/W48/rHrIWYJIb2poQB/8eR5TLUZLrbo8JbGQrxldyH2lVqz7kNERERERES01T17fmTObe5QHI+9PoDHXh+AWafCLTU2xOM5KFEG13CGREQbn9FoxO23345nn30Wv/nNbzA4ODijxdyUJ554Aj6fDwDw1re+da2nSURbkCRJCIVCmcCS1+tddHuyaDSKWCwGtVo9a5vZbEZ9fT0MBgN0Oh3DSuvkyoBTbu78FxUstQXgVLWnkRH584Ddbkd9ff01zZeIaApDTKugra0NAFBdXQ2lcu5/4p07d87aZ6X89Kc/RSgUAgA89NBDi0q/Xrp0CYcPH0Z7ezsikQjy8vJw4MABvP3tb8fv/d7v8coO2hKmgku/aBnGL1qH4fROl9M80+/GwYrZJfLtRi3e2lQMu0mLu3YXYnexmYlyIiIiIiIi2va+cHc99pdZ8IvWEVwc9s05zhuO48mWUQAVUAtJjDzdjrceKMfNtfm8MIiItrxHH30007HhL//yL/HFL35x1pj/+T//J5599lkkEgn80R/9EZ544gkoFIrM9omJCfzpn/4pAMBiseDDH/7wmsydiLa23t5e9Pf3L2tftVqNSCSSNcSk0Whgt9uvdXq0hlQqFa6//vpMK7mpJRaLLWr/+drUJZPJGa9pREQLYYhphUUiEUxMTABA1qslrmS1WmEwGBAMBjEwMLCi87iyldz73//+Re0zOjqK0dHRzM9DQ0MYGhrCU089hb//+7/HT3/602WnaAcHB+fdPjw8nLkfDAYzV5QQrQRJktDq9ONXlybw67YJDPuyp8l/droPtTYlAoFAZt3U/S++ZbrH8HxlUolWQ7bnJNF64fORNhI+H2mj4XOSNhI+H2kt5GuA9x8swPsPFqDfFcZv2ifw60sTuDA893MuJinwVOsYTvV78ewfXseLhGhdBIOsCEaL88orr6CzszPz89S5fwDo7OzEo48+OmP8Bz7wgWU9zm233YZ3v/vdeOyxx/DUU0/hjjvuwKc//Wk4HA60trbi//7f/5sJGvz93/89rFbrsh6HiLafVCo1ZyUks3n+1sFTFAoFjEYjjEYjTCYTjEYj1Go138dtMSqVCjabDTbb9MX+0Wh0RqjJ5/MhmUzO2neuNnWSJOHUqVNQKBSwWq2wWq0wm80MNRHRvBhiWmFXhhtycnIWHD8VYlrJE4r9/f148cUXAQDXX389qqur5x0viiJuv/123HXXXdi7dy9yc3Ph9/tx5swZ/Pu//zva2tpw8eJF3HrrrTh58iTKysqWPKfS0tJFj33iiScW/caJaC6SBIwldeiKmdEdN8Gfmn01wNV+fqoPxsu/wpXvu7///e+v4iyJlo7PSdpI+HykjYTPR9po+JykjYTPR1pLbwDQZFKhO25Cd8yM0WT2q7LtkUH827+dXtvJEaV5vd71ngJtEt/85jfx3e9+N+u2V199Fa+++uqMdcsNMQHAt7/9bfh8PvziF7/A888/j+eff37GdlEU8ed//uf46Ec/uuzHIKLtIRKJYHJyEpOTk/B6vTh8+PCcbd8EQYAkSTPWq1QqmM3mzJKTk8PA0jal0Wig0WiQl5cHQA4lBQKBGS0IE4kEjEZj1v0jkQgiEbkjSjAYxODgIERRhNlshs1mQ15eHrRa7Zr9PkS0OTDEtMKm/hADyPqG4GoajQaA3Dt0pfzgBz/IvOFYTBWmJ554ImtC9qabbsIf/uEf4iMf+Qi++93vYnR0FJ/+9KfxxBNPrNhciVbaeEKLyzEzuuPmRQWXAMAiRrFD7cUONU9gEREREREREV0rkyKOJsUkmrSTCKRU6I6Z0BUzYSRpyIyZ7zP4LwNl0AkJ7FB74VAGwY5zRLQd6HQ6HDt2DD/60Y/w6KOPorm5GR6PBwUFBbjpppvwiU98AkePHl3vaRLRBjQVLJkKLl1dOMHtdqOgoGDWfgqFAmazGeFweEZoSa/XM7REWQmCkKnKVVJSAkmSEI1G56z25XK5Zq1LpVJwu91wu93o6uqCwWBAbm4u8vLyGJgjIgAMMa24K9Oii+kTGo3Kba10Ot2KzWHqCkuNRoMHH3xwwfFzlfgD5LT1N7/5Tbz22mtob2/Hz372MwwNDaG4uHhJc1qoXd7w8DAOHToEAHjb296G2traJR2faMon/+sCmi/PflN0tXKbDm+qz8Od9fmoyZ/5hjwQCGT+Hz300EOLqqpGtJr4nKSNhM9H2kj4fKSNhs9J2kj4fKSNJhAI4Ovf/U90x8zQFNfjL975gaxfUIz4ovj6V08CAC7GbLDpVbhjZx7eVJ+HfaVmKJhoohXQ0dGBL33pS+s9DdoEHn300Vkt45bqAx/4wJIqNL3nPe/Be97znmt6TCLa+lKpFDweTya4NPV9YzZzhZgAoKGhAQqFgsERWhZBEOatpLSY6pfBYBDBYBD9/f1Qq9XIy8tDbm4uLBbLnOEoItraGGJaYVeWy1tMi7ip/usrdTLx5MmTuHTpEgDgvvvumzegtFhKpRIf+tCH8LnPfQ4A8OKLLy75Q1RJScmixxoMBphMpiUdn2jKA/vL8MIcIabKPAPu3l2Eu/cUYWehcVFvynNycvh8pA2Fz0naSPh8pI2Ez0faaPicpI2Ez0faKHLEBPZoJ/Hxd+2e8zn5Xy09M352heL48Zlh/PjMMPKNGtzVWIi79zhwsNwKkYEmWiaDwbDwICIiog1mqoLN+Pg4JiYmkEwmF7Wf2+2GJElZvxNRKvlVMa2enTt3ori4GG63Gy6XC36/f97xsVgMTqcTTqcTCoUChw4dWlTnIyLaWvjKtMK0Wi1yc3MxOTmJwcHBece63e5MiKm0tHRFHv973/te5v5iWskt1q5duzL3h4aGVuy4RIslSRIuOH14usWJVzsn8MTHb4BaOTuBfXu9HWqliFgiBWA6uHTX7iLUFy0uuERERERERERE6+NYi3PObeP+KL57vA/fPd6HApMGd+0uwj17irCvlIEmIiIi2tq6u7sxPDyMRCKxqPFKpRK5ubmw2WywWq38boTWhSiKmTaFFRUViMfjmQpiLpcL8Xh8zn11Oh0DTETbFENMq2DXrl14+eWX0dnZiUQiMWeKeapiEgDU19df8+PG43E89thjAAC73Y43v/nN13zMKXxzQ+ulfcSPZ1qceLrZid7JUGb9q10TuLXOPmu8UavCew6VwaBR4K7dRdhVZOLzl4iIiIiIiGiT+OcH9+GZVieOtQzjgtM357hRXxTfebUX33m1Fw6zFnelKy83lVp4HoCIiIi2nGQyuWCAaarQQl5eHsxmM98T0YajUqmQn5+P/Px8SJIEr9ebaYkYDodnjLXbZ38HOGVychIKhYLPc6ItiiGmVXDjjTfi5ZdfRjAYxOnTp3H48OGs41588cXM/RtuuOGaH/fYsWOYnJwEIPfNXskSkBcvXszcdzgcK3Zcomy6xwN4pmUYz7Q40TGavS3jL1qGs4aYAOCL9zWs5vSIiIiIiIiIaJWU5erxh7dU4w9vqUbPRBC/aB3GMy3DaBueO9Dk9EbwzVd68PLlCTz3J29Yw9kSERERrZxYLDZn5Zn8/Hw4nbMrVhqNxkxwSa/XM9BBm4YgCLBYLLBYLKiqqkIoFMoEmnw+H/Lz87PuJ0kSurq6EA6HoVarYbfbUVhYyHbBRFsIQ0yr4IEHHsCXvvQlAMB3vvOdrCGmVCqVaf1msVhw6623XvPjXtlK7uGHH77m401JJBL49re/nfn5DW/gySBaeQOuUCa4NN+VllOeuzCC//vW3VlbyhERERERERHR5leZZ8Af3VqNP7q1Gp1jAfyidRjHWobRPurPOv6ePUVrPEMiIiKia5NIJDA2NoaRkREEg0EcPXo0a5ECs9kMtVqNWCwGk8mUqWaj0WjWYdZEK0sQBBgMBhgMBpSVlSEej0OlUmUdGwwGM1WbYrEYBgcHMTg4CKPRiIKCAtjt9jn3JaLNgSGmVXDo0CHcdNNNePnll/Gtb30LDz/8MI4ePTpjzJe//GW0tbUBAD71qU/N+mP6wgsvZIJNDz/8MB599NF5H9PlcuHYsWMAgN27d6OpqWlRc33++eexb98+WCyWrNvj8Tg+8pGPZOZ67733orS0dFHHJlrIiDeCY63DeLrZiXMDnkXtU2LV4Z49DtyzpwgqBa8oICIiIiIiItoOqu05+OTtNfjk7TW4POrPXAjVNR7MjLlrnhDTR793CjUFObh7twP1RUZWKSAiIqJ1I0kS3G43RkdHMTExgVQqldk2Pj6OoqLZ72kEQcDOnTuh0+mg1WrXcrpEa26+ENLY2FjW9X6/H36/H11dXcjLy0NhYSGsVivf9xNtQgwxrZJHHnkEN9xwA8LhMO688058/vOfx6233opwOIzHHnsM3/jGNwAAtbW1+MxnPnPNj/fYY48hFosBWFoVpu9+97u47777cN999+GWW25BXV0dTCYTAoEATp8+jW984xuZVnJ2ux2PPPLINc+VaMqXnm3Dk+dmlz+9WqFJi3v2FOGevQ7sLWF/WyIiIiIiIqLtrKbAiD+5w4hPv7EGHaMBHEu3o9+Rn5N1fOdYAL+6OIpfXRzF157vQlW+AffuceDevQ5U27PvQ0RERLTSIpEIhoeHMTo6img0mnXMyMhI1hATAFit1tWcHtGmoNPpYDAYEAwGs26XJAnj4+MYHx+HWq1GQUEBioqKoNPp1nimRLRcDDGtkn379uHHP/4x3ve+98Hn8+Hzn//8rDG1tbU4duwYjEbjNT/eVCs5hUKB9773vUvaNxAI4Ec/+hF+9KMfzTlm9+7deOyxx1BZWXlN8yS60j17HHOGmPJy1LhrdxHu3evAgTIrRJHBJSIiIiIiIiKaJggC6gqNqCusm3fcsZbhGT93jwfxyG8v45HfXkZ9kQn37i3CvXscKLXpV3O6REREtA1NVV1yOp2YnJxccHw4HJ63lRbRdldUVISioiIEg0GMjo5idHQ0U+jjarFYDAMDAxgYGIDNZoPD4YDNZmOxBKINjiGmVXTvvfeipaUFjzzyCI4dO4bBwUGo1WpUV1fjne98Jz7xiU9Ar7/2kyOXL1/GiRMnAAB33HEHCgsLF73vn/7pn6KpqQnHjx/HxYsXMT4+DpfLBY1Gg4KCAhw8eBDveMc78Na3vhUKheKa50rbhz8Sx68vjuK5CyP4pweboFfP/nPzhto8GLVK+CMJAIBFr8JbGgtx7x4HDlflQsHgEhERERERERFdo2Otc1eBbhv2oW3Yh//3y3bsK7Pg3j0O3L2nCAUmtmkhIiKi5YvH4xgZGYHT6UQkEpl3rCAIyM3NRUFBAWw2G0RRXKNZEm1eBoMBVVVVqKyshMvlyrRnlCQp63iXy4VoNAqbzbbGMyWipWKIaZWVl5fjK1/5Cr7yla8sab9bbrllzj+yV6upqVn02KvV19ejvr4en/70p5e1P9GVQrEEfts2hmdanHi+fRyxhNzH+XeXxnDPHses8RqlAm/fXwJ/JIF79hbhxuo8qBR8c05EREREREREK0OSJPzjO/fiWMswnmkZxpAnPOfYs/0enO334G+OXcThShvu3evAWxqLYDOo13DGREREtNk5nU50dXUhlUrNO85gMKCwsBB2ux1qNd9vEC3HVAgwNzcX8XgcY2NjGBkZQSAQmDXW4XCwChPRJsAQExFdk0g8iRc7xvF0sxO/bRtDOJ6cNeaZ5uGsISYA+OJ9Das9RSIiIiIiIiLapgRBwJ4SC/aUWPC/3rITZwc8eLrZiWMtwxjzR7PuI0nAa90uvNbtwhNnhvD4x69f41kTERHRZmYwGOYMMCkUChQUFKCwsBBGo3GNZ0a0talUKhQXF6O4uBiBQAAjIyMYGRlBMpmEQqGA3W6fc1+32w2z2cxKaEQbAENMRLRksUQKr3ZO4OlmJ359cRT+aGLe8b9rH4M/EodRyx7ORERERERERLQ+BEHA/jIr9pdZ8b/v3oWTPS481ezEs+eH4QnFs+5z9+6iNZ4lERERbXYmkwkGgwHBYDCzzmAwwOFwwG63Q6nk17NEqy0nJwfV1dWorKzE2NgYEonEnP/3gsEgWlpaoNFoUFxcjKKiIv4/JVpH/N9HRIuSTEk43jWJZ1qcePb8CLzh7Cf3rqRSCHhDTT7u3etgmzgiIqJ1JEkSookUovEUwvEkYokUYskU4skUYon0bea+lFl/9Zh4Uj5OPJlC/IrtyZSEZApIplJISkAqJcnrpPRtSkLqqvuJlCSPk+R9UykJiVQKS2mSnEqm4PHWAACe/bdTELO83xAAKEQBoiBAIQpQigJEUYBCmL5ViNOLPA7pn0UoBGTGKRUClKIItVKESiFCrRAy91UKeb1aIUKlFKBWKKBSCFApRWgUIlSZfUSolUJmvFapgE6tgEYpspw1ERHRGlKIAo7uyMXRHbn46/sb8Er6Yq1fXRhFIH2xliAAd+/JHmKSJAl/9fRF3FCdhzfU5kGjVKzl9ImIiGgdRaNRDA0NwWw2Izc3d9Z2QRDgcDjQ2dmJ/Px8OBwOmEwmfu4nWgcKhQJFRfNfmDA4OAhA/r/d3d2Nvr4+FBUVobi4GFqtdi2mSURXYIiJiBbl/xy7iO+82rvgOIUo4Podubh3rwNv2lUIs57Vl4iIiBaSTEkIxhIIRqeWpHwbk29DsSQi8STC8SSi6dtwPIlIOpQUvfLnWBKRRBKRWBKRxPTP0lLSQZuKBgDgcYXXeR7XTqsSoVUpoFMpoM0sYuZnnUoBzVU/T+2jVSmgVyugVyuRo1FCr1EgR6OEQaOEQa2AQaNkqJyIiGgOKoWIW+vsuLXOjkg8iRfax/F0ixPhWBIFpuxfWrQMevHof/fi0f/uhUmrxJsbC3HvXgeOVuVCyddcIiKiLSkQCGBwcBBjY2OQJAkejwc2my1rOKmgoAB5eXlQq9XrMFMiWqxoNIrR0dEZ65LJJAYHBzE4OAi73Y6SkhK2fyRaQwwxEdGi3LGrYM4QkyAAhyttuGePA29pLERujmZtJ0dERLQOUungkS+SgC8chz9964vEEYgmEJgVSJodTppaH4mn1vvXoQ0gEk8hEk/Bg4UrXi6HWiHCoFGkg03Kq+5P/5yjUUKvVsCoVcGoVcKkVcGkS99qVcjRKqEQefUoERFtTVqVAm9uLMSbGwshzZMCf7rZmbnviyTwk1OD+MmpQeQa1LhrdxHu3evAwXIrRL5mEhERbXperxd9fX1wu90z1vv9fvh8PpjN5ln7KBQKKBSs1Ei00SUSCRiNRvh8vqzbx8bGMDY2BovFgvLyclgslrWdINE2xBATEQEA+idDeLrFifcdLs9aPelwZS7sRg3G/NHMugPlVtyzpwh37S6a88pEIiKijUqSJARjSbiDMXjD8UwAyZcJI10RTorEZ90PRBNIbdnqRrQVxZIpxEIpuEPXHpLK0Shh0iph0l0ZdFLBpFXCeEXo6cr7Zp0KVr0aRq2SX+gSEdGmMFfLl1RKwjMtw1m3TQZj+P5rffj+a30oNGlxz54i3NfkwO5iM1vIEBERbTIejwd9fX3weDxzjhkcHMwaYiKizcFgMGDfvn3w+XwYGBjAxMRE1nEejwcejwdmszkTZuL7e6LVwRAT0TY25ovgmZZhPNXsxLkBDwAgL0eNB68rmzVWIQq4Z48DJ3sncd9eB+7e40CxRbfGMyYiIsoulkjBE4rBHYrDHYrBE4pnfpZvp9bJ292hOLzhGOLJ7Z1CEgVArRShUohQK8TMfZVCgFqpgFohyNsy60VolPL2K9crRAEKUYAoCFCKAkRRgEIQoBBxxX1hxjhFer0oyuMUoij/vITP/qFwGM899xwA4E1vehP0utnvTVISkJQkpFISkikpcz+RkpCS0usy94GUJCGRnB535b6JlIREKoV4QpIDQckU4on0bTKFWCKFWFKasW7qfiyRQjwp75fcAum3qWpjTm9kyfuKAmDRq2HRq2BJB5ssejWsehWsBnUm7GTVq+T1BhUsOjV0al7BSkREG0MiJeGPbt2Bp5qdeL3XPee4EV8E33ylB998pQfluXrcu8eBe/c6UFfIVhREREQb1VSbuL6+Pni93jnHiaKIwsJCFBcXr+HsiGi1mEwmNDQ0IBwOY2hoCMPDw0ilZlfP93q9aGlpgclkQnl5OaxWK8NMRCuMISaibcYbiuPZ83Jw6bXuyVkVJJ5qdmYNMQHA5+/aCaVCXINZEhHRdiZJEkKxJCYDMUwEo3AFYpgMRjERiGEyEIMrGMVkMAZXcDqsFIwl13vaK0qjFOWWXhoFDGq5tZdOrYBOpYBGJd9qVWL6dnrJvl6ETq2AVqnI3GpU0+Gjzczn86HzebnU8x0782AymdZ5RouTTEmIJ1OIJlKIxpOIxFMIx5OIxJOZ20jW9anMtnAsiUgihXAsiWhC/jkUSyIUSyAQlW9DG/T/RUoCXOn/w0uhUYrpwJMccrLlqJFnUCM3R4PcHDVyDVO38jqTVsmTSEREtCrUShEPHa3AQ0cr4PSEcaxlGE+3ONEyOPcXnX2TIXz1+U589flO/N6hUnzpbXvWcMZERES0EEmS4HK50NfXB7/fP+c4lUqF4uJiOBwOqFSzu1oQ0eam0+lQXV2N8vJyOJ1OOJ1OxGKzz2H5fD6cP38ehw8fhkajWYeZEm1dDDERbQOhWAK/aRvDU+eG8GLH+LxVJ453TWLMH4HdOLs9HANMRES0XNFEMh1AimEiEMVkOpg0GZSDSZOBK+4Ho4jEZ1/lspEJwlR7LbmlllGjRI5WDh/laJQwaJQwqBUwaJTQa5TISYeTDOltORoF9OrpcXzN3drkilRyyAy61TvhmUxJmTBTIJpAMJpAMJqUb2NX358OPwXTVZYC0QR84ekWiutdQCqaSGHEF8GIb3HVn1QKATbDdLgpL0cj/5yjRt5U4ClHg1yDvI2VnoiIaDkcFh0+8oYqfOQNVeidCOKZFieeanaiYzQw5z77yqxrOEMiIiJaiNvtRk9Pz7zhJbVajdLSUhQVFUGh4OdHoq1OpVKhvLwcJSUlGBkZwcDAAKLR6IwxBQUFDDARrQKGmIi2qFgihZc6xvFUsxO/vjiKcHzhK/FtBjXu2l2IxDZvrUNERIsjSRJ8kTjG/VGM+aIY80cw7o/KP/unfx7zR+EJxdd7uvNSiAJMWiVMOlU6iKSEUSPfZoJJ2mz35X1y1EqIm7yqEW09ClGAUauCUatCwTUea6pCmhxokoNN/ivu+8Jx+COJGdt9kQT84XhmXSy5tuHEeFLCqC+KUV904cGQg4h2owb5Rg3sJi3yczSwmzTT64xa2I0aWPQqVngiIqKsKvIM+MRtNfjEbTVoH/Hj6WYnnm5xom8ylBmjUgh4U0Nh1v2TKQlPnhvC7fUFMK9i0JmIiIhm8ng8cwaYNBpNJrwkirzojGi7USgUKC4uRlFREUZGRtDf358JM5WVZe9sQ0TXhiEmoi3oWMswPv+zVnjDC39hbFAr8KaGQtzX5MAN1XlQsfIDEdG2J0kSXMEYRnwRjPmjGPdFMR6IYswXwZArgPO+SoQkFb7zD/+NSGLjVUwyapWZdlMWvRrW9H2zTiXfN8jrLbr0GINcOYmhBKK5CYKQqRxWZF76/lMhKE84Dne6FaQ7FIMnHIcnGIM73Roysy693RuOQ1qjfP1U9anuieC841QKAfk5GuSbtFcEnOSQk0GRxFhCB70YR3K9S1cREdG6qis0oq6wDp+5sxatQ1483ezEMy3DaHCY5wwoneiZxP/4STPUChG37szH/U3FuG2nXa7eSERERKumtLQUTqcTiUQis06r1aKsrAwFBQUMLxERRFGEw+FAYWEhxsbGEA6HodPpso5NpVK4fPkyiouLkZOTs8YzJdr8GGIi2oJKbbp5A0xqpYjb6uy4r8nBk2FERNtMIpnCmD+KYW8Eo74Ihr0RjHjDGPFF07cRjHqjC1RMMcg3qdUPMKmVIvIM6ZZPOWrY0m2fcg1qWA3qdFBJDidZ0kElBnKJNp4rQ1DFluwneLJJpiT4wnE5/BSKyUGnoHxfbkEZTbeplFtRugIxBGMLVyC9FvGkBKc3Aqd3rrZ2OwAAP/r7V2A3aVFg0qLIPH1baNai0KRFkVkHu0nD9+JERFucIAjYU2LBnhIL/uwt9fOer3nqnBMAEEum8NyFUTx3YRQ5GiXubCjA/U3FuGFHLtsOExERrQKlUonS0lL09PRAp9OhrKwMdrud4SUimkUURRQWZq+sOmV4eBgjIyMYGRmB3W5HRUXFnIEnIpqNISaiTapj1I/8HA2sBvWsbbuLzajI1aP3inLlClHA9TtycX9TMe5sKIBJy7LkRERbTTiWxIgvghFvBCO+sBxU8kZmBJbGA9E1q2qSjUIUkGu4Iox0VTApN0eT/lm+b1ArWCGJaBtTiIIcWDSoUTkVoFxAOJbEZDCKyUAsHXCKZgJP8u104GkiGENslSrKJSVgOP03+NzA3ONsBjUKTelwUzrgVGhOB57S9418705EtCWI6de1bKKJJJ49PzJrfSCawBNnhvDEmSHkGtS4e08R7m9yYH+Zle+TiYiIFikWi6G/vx9KpRIVFRVZxxQXF0OtVqOgoICvsUS0bMlkEn19fZmfx8bGMD4+jqKiIpSXl0Otzv55gIimMcREtIkMuEJ4usWJp845cWnEj/99dz0+fFPVrHGCIOC+vQ78y+86cbDcivuaHLhrdxHycjTrMGsiIloJkiRhMhjDkDsMpyeMofTi9ITh9EQw5AnDFYyt2/yMWuUVbZXkFkt208yf83I0MOtUEEWeCCKi1aNTK1Ci1qPEql9wrCRJ8EcTmPBHMe6PYiyzRDA+tS7dUnO1/sa6gnLY6uKwb84xRq1cwcph0WVuHRYtSqzyfbtRCwX/thIRbWreUByHK214oX18zqqok8EYvne8D9873odiiw73NTlw314HdhYa+WUrERFRFqlUCgMDA+jr60MymYQoiigqKoJGM/u7EoVCsWB1FSKihTidTsTjM6uvSpIEp9OJ0dFRlJWVwWQyrdPsiDYHhpiINrhxfxTHWpx4qtmJM/2eGduebnZmDTEBwENHK/Cu60oX9eUNERGtv2giiRFvBEPuqXBSBEOeUCag5PSEEV2laiFzEQUgN0eD/Bw5kGQ3amBWC2g7ewJ6MYH3vf1eVBbakJejgU7NdkhEtPkIggCTVgWTVoWq/Jx5x8YSKUwE5JDTeDroNBVwGvNFMe6X23OO+6NIYWW/SPZHErg04selEX/W7UpRQKFZC4dFh5KpsJN1KvQkr9er+fGfiGgjs5u0+Mb7D8IbiuOXF4bxVLMT/901OWcV1SFPGF9/oQtff6ELtQU5+JM31uItu4vWdtJEREQbmNVqxaVLlxCNRjPrUqkU+vv7UVNTs44zI6KtzOFwZAKUyWRyxrZkMomenh6o1WrYbDa4XK51miXRxsazmEQbkDccx3MXRvB0sxOvdk4gNccJq+ZBL3ongqjIm91aI9/IqktERBtJLJHCkCeMAVcIA+4QBlxhDLhDmcpKY/7owgdZQWqFOKN1UZFZi4L07dT6/BwNlApxxn4+nw9fb3sWANBUYoLJxLAsEW0PaqWYroCkm3OMz+fDv/7r1xGWFHjL298Df0KRbvMZntHac8QbQSiWnPM4S5VISRh0hzHoDuPkHGOselWmklOpTY9Sa/rWpkepVc8wKhHRBmHWq/DgdWV48LoyjPoieKZFDjQ1D3jm3KdjNDDnuSMiIqLtJhwOo76+HmazeUaAacrIyAgqKyuhVPIrUiJaeQqFAuXl5XA4HOjv78fQ0BCkq65MiMViqK2thc/nQygUYmUmoqvwFZpog4jEk/ht2xiePDc0b+nwKxWatBhwh7KGmIiIaG2lUhJG/RE5nHRlUCl9f8QXmfMq6pVm1ChnBJSm7k8HlXSw6lVsOUFEtAoEAdALSewqzJnzJNRUG7uRdKBpxBvBSCbgFMaIL4oRbxjuUDzr/svhDsXhDsVxwZm9bV1ejholVj3KbHqU2nQotU4HnIosWqiuCrUSEdHqKzBp8aEbK/GhGyvROxHEU81OPHluCF3jwRnjDGoFbq+3Zz1GLJFCJJGESataiykTERGtm1gsht7eXgwPD8NsNmcdY7fbGWAiojWhUqmwY8cOlJSUoKenB6Ojo7PGmEwmtLe3w+v1orKyEmq1eh1mSrTx8FWaaJ31TATx1d914rkLIwhEEwuOt+hVuGt3Ee7b68ChChtEkV9AExGtFW8ojj5XMFNFacAVQr8rhEF3GEPu8KICqNdKIQooNGlRbJWraTgsWhRb9OlbHYosOuRo+BaPiGgju7KNXW2Bcc5xkbjcatTpCWMw3VrU6bmy7WgYsRVqNToRiGEiEMO5LJU+pl57psJNZVMVnGxyNaf8HA2DsUREq6wiz4BP3l6DP76tGheHfXjqnBNPNzvh9EbwpsZCaFXZK+q90D6GT/znWdxWZ8d9TQ7cttM+51giIqLNSJIkDA0Nobe3d1brpilGoxHV1dWsdkJEa06j0WDnzp0oLi5GZ2cnfL7ZF5eNjIxgfHwclZWVKC4uXodZEm0s/IaLaJ0lUxIePzM47xi9WoE7dxXgviYHbqzOh1rJq6CJiFaDJEmYCMTQNxlE72QIfZNB9KVveydD8IZXriLGXHI0yulwklWXaf1TnG5hVGDSQsEAKxHRtqBVKVCRZ5iz8moqJWEyGLsi2CS3lHN6wnB65YDtSlRzSqYkDKUf4zW4Zm3XqxUos+lRkWtAeV761qZHeZ4BRSYtL7wgIlpBgiCgwWFGg8OMP33zTpzqc8Okm/sU75PNTsQSKfzywgh+eWEEORol7mwowP1NxbhhR+6s9tFERESbidfrxeXLlxEMBrNun6qEYrfbeeEFEa0ro9GIpqYmjI+Po6urC7FYbMb2ZDLJv1NEaQwxEa2RZErK+qVztT0HjcUmnB+ambxVK0TcUpeP+5ocuH1nAXRqXiVHRLQSUikJI74IejMBpemQUv9kEMFY9iu2VopJq8y05ym16VBi1cshpXRgyaxjmwciIlocURSQb9Qg36jB3lJL1jGhWCIdcopgyB3GkEdudypXEgxhIhDLut9ShGJJXBrx49KIf9Y2tVJEmU0vh5pyDajIk2/LbXoUW3VsU0dEdA1EUcChStuc2wPRBH7bNjpr3RNnhvDEmSHkGtS4e08R7m9yYH+ZlV+aEBHRppFMJtHV1YXh4eE5tzudTtxzzz2wWCxrOzkiojkIggC73Q61Wo2nn34axcXFUCjk73+NRiOKiorWeYZEGwNDTESraNQXwdPNTjx5zok7dxXgj2+vyTrugaZinB/yQRCA63fk4v69xXhTYyG/yCYiWqZUSsKwL4Lu8QB6J6arKvVOyu3fVqr1TjYapZgOKelmhZVKbXr+bSciojWlVytRbTei2p69bV0olsCgO4wBl9wmdWDqvjuMQVcI/kW0vJ5PLJFC51gAnWOBWdsUooASqy4TairP1aMyz4DKPANKbXoGnIiIrlHLoAfJlDTn9slgDN873ofvHe9DiVWHe/c6cH+TAzsL2WqHiIg2NlEUEQqFsm6zWq347W9/i1gsBlHkZwoi2nhEUYTT6cT4+DjuuOMOuN1u1NbW8qICojSGmIhWmC8Sxy9bR/Bk8xD+u2sSUvpcUSiWwCduq876AnTvXgcA4L69DthN2rWcLhHRpuYJxdA9EUT3eBA9EwH0ZO4HEV2loJJCFFBk1mbCSaXpcNLU/Xyjhh82iIho09CrlagtMKK2YHbISZIkeMNx9Lvk6k0D7tCMgNOgO4xYcvmvt8mUlKmKeDWlKKDMpkdVviEdbMpBVb4BVXkGvtYSES3S9TvycOoLd+DZ88N4qtmJ493T56muNugO4+svdOHrL3ShtiAH9zcV4x0HSlDA81RERLQBCYKAmpoanD59GlL6xc1gMKCmpgaCIMxq00REtBHF43GUl5ejtrYWGo1mznH9/f2w2WzIyclZw9kRrR+GmIhWQCSexAvtY/j5WSd+1z6WtcJH13gQF5w+NBabZ20rMGnx4Zuq1mKqRESbTiSeRN9kCD0TAXSlA0pyWCkAdyi+Ko+pVogotelQkWtg6xsiItq2BEGARa+GRa/GnhLLrO3ztWjtmwwidA0tWhMpSQ4qTwRnbcvRKDMVmyrzDOlwUw4q8vQwalnxkIjoSma9Cu8+VIZ3HyrDqC+CZ1qG8dS5ITQPeufcp2M0gH94rh0NDhNDTEREtGEZDAaUlJRgaGgIFRUVKC4uhiiK8Pl86z01IqIlmS/A5PF40NPTg56eHpSUlKCioiLTgo5oq2KIiWiZkikJr3VP4slzQ3j2/Aj8kYXbLPzy/EjWEBMR0XYnSRJGfVF0jgXQNR5A93gA3emw0pAnPOfVwtdCp1KgPFcvB5Xy9Ci3GVCRq0d5ngGFJi0UIis8EBERzUcUBTgsOjgsOly/Y+Y2SZIwHoiifzI0s63rpPz67lvE56e5BKIJtA550To0+wt4u1EzI9hUlW9AtT0HJVY9X9uJaNsrMGnxoRsr8aEbK9EzEcTTzU78/NwQusdnB0ZzDWrcWJ23DrMkIiKa5vV6IYoijMbs7bHLy8vhcDig1TJ0S0RbTyqVwuXLlzM/Dw4OYnJyErW1tbBYLOs3MaJVxhAT0RJIkoTzQz48eW4IT7c4MeqLLrhPjkaJNzUU4v4mB67fkbsGsyQi2rgSyRT6XKFMWKlzLICuMbnCUiC6/C8z52JQK1CZb0BFriFdVUmPijz5Nj+HrWiIiIhWiyAIsBu1sBu1OFhhm7XdE4plwk19kyH0TgbROyEHnVzB5bd+GPNHMeaP4kSPa8Z6jVJEZZ4BO+w5qM7PQbVdXirzDNCqeAUjEW0/lXkGfPL2GvzxbdW44PTh6WYnnmp2YtgbAQDcs6cIyjkq0D7bOoxfXRzF/U0O3FidN+c4IiKi5Uomk+jp6cHQ0BD0ej0OHDgAUZz9eqNQKFiRhIi2rOHhYYRCoRnrwuEwmpub4XA4UFVVxb+BtCUxxES0BGP+KO772isLVgRRKQTcUmfHA03FuL3ezpPiRLTthGIJdI0FM0GlzrEAOscD6JsMIp5c2bJKSlFAWa4eVZmWMvIXklV5BuQbGVQiIiLaiCx6NZr0ajSVWmZt84RickXG8SC6JwLpNrJyBadoltbdixFNpHBpxI9LI/4Z6wUBKLXqUW3PwY501aZqew6q840w69majoi2PkEQ0FhsRmOxGX/65p14vdeFn59z4u0HSubc58enBvBC+zh+dnYIuQY17tlThPv3FWNfqYWfv4iI6Jp5PB60t7cjEpGDtaFQCP39/aioqFjfiRERrbGioiLE43H09/dDuurLaafTicnJSdTV1cFqta7TDIlWB0NMREtQYNLicKUNr3W7sm4/XGnDA/uKcVdjEU94E9G24A7G0DHqR+dUVaXxILrGAhjyhFf8sQpNWlTmGVCZLweUqvINqMzLQYlVBxWv/CUiItoyLHo19pepsb9s5km4VErCsC+CnvEgeibk9x096fazg+4QUsvISUsS0O8Kod8Vwu8uzdyWl6PGjnTVpqnb2gIjCkwMSRPR1iSKAg5X5eJw1dyVxCcDUbx8eWL652AM3z3eh+8e70OZTY/7mxy4v6kY1factZgyERFtIYlEAj09PXA6nbO29ff3Iz8/HwaDYR1mRkS0PkRRREVFBfLz89He3g6/f+aFWdFoFC0tLSgsLMSOHTugVDL6QVsDn8lEV/BH4vjVhVEkJQnvOliadcz9TcUzQky7iky4v8mBe/c64LDo1mqqRERryhuO4/KoHx2jAXSM+tNLABOBhdtqLoVercCO/BxU5RtQlZeTDirJi0HDty1ERETbmSgKKLboUGzR4caavBnbookk+idD6M5UbUqHq8cD8ITiy3q8iUAMEwHXrNZ0Jq0SNQVG1BYYUVsgB5tqCnLYqpaItoVjrcNIzpEa7XeF8P/9rhP/3+860eAw4YGmYty714FCs3aNZ0lERJuN2+1Ge3s7otHZ5xoFQUBFRQX0ev06zIyIaP0ZDAbs27cPQ0ND6OnpQSo1s0r1yMgIXC4X6urqYLPZ1mmWRCuH3wbSthdLpPBC+xiebHbiNxdHEU2kUGTW4h37SyCKs09A39VYhP94uRtvaSzEA03FqCkwrsOsiYhWhz8SR8doIBNYujwmB5ZGfSsbVpqqbLDDnoPqdGWDansOCk3arH97iYiIiOajUSpQU2Cc9flMkiRMBmOZ9rZTrW67xgJweiPLeixfJIHTfW6c7nPPWG/Rq1BrlwNNU8Gm2gIj8nI0y/69iIg2mrc0FiGZkvDzc040D3jmHHfB6cMFpw9/+2wbjlTm4oF9Dry5sQhmHSuXExHRtFQqhe7ubgwNDWXdbjKZUFdXxwATEW17giCgpKQEubm5aG9vh9frnbE9FouhtbUVDocDVVVVUCgU6zRTomvHEBNtS6mUhJO9Ljx5bgi/aB2BNzzzytxhbwQne104kqV8tlmvwu8+c8sazZSIaHUEowlcHpOrKl0e9aM9HVwaXuaXedkIAlBi1c0IKU21YrHo1Sv2OERERERzEQQBeTka5OVoZn2+C0YT6B4PonPcnw42BdE5HkDvRBCJZfSm84TiONnrwsnemZWbbAb1FRWbjKhNt6WzGvh+iIg2n3yjBh+8oRIfvKESPRNBPHXOiSfPDaF7Iph1vCQBx7sncbx7En/+8wv4xaduYqs5IiICAAQCAVy6dAnB4OzXEFEUUVlZieLiYlY7JSK6gk6nw969ezE8PIzu7m4kk8kZ251OJzweD3bt2sUWnLRpMcRE24YkSbg47MNT55x4qtm54Bf1T55zZg0xERFtJolkCr2TIbSP+HFpxIe2YT/aR30YcIVX7DHUChGVeQZUF0yHlKrTLeG0Kqb9iYiIaGMyaJTYXWLG7hLzjPXxZAp9k6EZVZs60/dDseQcR5ubKxjDa92uGW3JATkIsLPQmF5M2FlkRLU9Bxol3z8R0eZQmWfAp95Yg0/eXo3WIS9+ftaJp1ucGPdnr+RrN2mwI59fpBARbXeSJGFwcBA9PT2QpNkXD1gsFtTW1kKn063D7IiINj5BEOBwOGCz2dDR0QG3e2al6FgsBqWSMRDavPjspS1vwBXCk+eG8OQ5Jy6PBRYcrxQF3Fybj1vq8tdgdkREK2ciEEX7iB9twz5cGvGjfURuBRdNpBbeeRGUooCqfEO6goARtQU5qCkwoiJXD6VCXJHHICIiIlpvKoWYqSL5pobp9amUhCFPON1uV65o2TEqV3GKxJf+fmvcH8W4P4qXL09k1ilEAVV5BuwsMk0HnIpMcJi1vAKdiDYsQRCwp8SCPSUWfOHuehzvmsTPzw3hl+dHEIgmMuPu2+uY82/Z6T4X1AoFGotN/HtHRLSFRaNRXLp0CR6PZ9Y2QRBQVVXF6ktERIuk1Wqxe/duDA8Po6urC6mUfG6itrYWGg1b29PmxRATbVnJlIT3/MdrONHjWngwgOsqrLi/qRh37S6CjWX9iWgDi8ST6BwLpINKcmCpbdiPiUD2q12XSiEKqMjVT7c8Sbc/qcg1QK1kWImIiIi2J1EUUGrTo9Smx207CzLrUykJA+5QJth0eVQOOXWOBxBbYpg8mZJweSyAy2MBPN08vd6oVc6o2LSz0IS6QiNyNDytQ0Qbi0IUcGNNHm6sycP/eaARv7s0hp+fHcIL7eN4YF/xnPv93bOX8HqvG1X5Bty/txj3NzlQkceqTUREW43L5coaYDIYDKivr2frIyKiJZqqymSxWNDW1oacnBzk57NQB21uPNtFW5ZCFGDUzv8Urysw4v59Dty314ESq36NZkZEtDiSJF/tf6Z7EqfD+XAlNXju30+hzx1BMjW71PJSiQJQkWtATTqkNBVYqswzsI0JERER0SKJooDyXAPKcw24Y9d0uCmZktDvCs0INnWM+tE9HkQsubRwkz+SwOu9brzeO7NEfKlNJwebrgg4VeQaoBB55ToRrT+tSoG7dhfhrt1F8EXiMGlVWccNukOZv2/d40H802868E+/6cDeUgseaHLgnj0O5Bt5JTkR0VZQWFiIyclJTE5OZtaVlJSgsrISosiLJ4mIlkuv12Pfvn1Z23ROSSaTAACFgt//0MbGEBNtavFkCt3jQdQVGrNuv6+pGL9pG5uxrtiiw717HXhgnwM7C01rMU0iogUFowlcGvGhbdiPSyM+tI/4cWnYD3+m9H76C7HJ8LKObzdqUFdoRH26NUldoRE78nOgVfHNKhEREdFqUIgCKvMMqMwz4E0NhZn1iWQKvZMh+f1euqrmpREfBlxLf5834ApjwBXGry+OZtZplCJqC4zYkavFWCQXuYoIPKE4TPz4S0TraK4AEwA81ezMur55wIPmAQ/+z7E23FCdh/v3OvCmxkJWoSMi2sQEQUBtbS1OnToFURRRV1cHq9W63tMiItoSFgqDdnV1wev1YteuXax8RxsaP/HRppNKSTjd78bPzw7hF63DkACc/Pwbs7Y4uqO+AAa1AiqliLt3F+H+pmIcLLdC5FWpRLSOxv1RXHB6cXHYhwtOH9qcPvRMBjFPQH7RNEoRdYXG6avx04Gl3BxetUpERES0ESgVIqrtOai25+DuPUWZ9YFoYjrYNOxH+4gfbSM++COJeY42WzSRQuuQF61DXgDy8Z/+59fgMGuxy2HCLocZu4pMaHCYUGLVQRD4+ZiI1pdJq0KZTY9+Vyjr9mRKwksd43ipYxxf+Hkr3lhfgAeaivGG2ny2PCci2oTUajV2794NrVYLlWrukCsREa2c0dFRDA8PAwDOnDmDmpoaFBYWLrAX0fpgiIk2jfYRP35+bghPnXNiyDPzCtWXL4/j9vqCWfvo1Ar8+A+OorbAyJMaRLTmUikJfa4QLjp9M0JL4/7oihy/zKZPh5WM2JmusFTO9iFEREREm1KORokD5VYcKJ++El2SJDi9EVwanqrY5MelYR+6J4JLbi/s9Ebg9EZmVCs2aZVysKnIjAaHCbscJlTbc6BS8PMzEa2d9x0px3sPl+FMvwdPnRvCMy3DmAzGso6NxFN4pmUYz7QMw6JX4a7dRfiLe3axyjAR0QaSTCbR1dWFgoICmM3mrGOMxuzdNYiIaOWFQiF0dHRkfk6lUmhvb4fH40FNTQ3by9GGwxATbWhDnjCeOufEk+eGcGnEP+e4J885s4aYAKCxOPubZCKilRRNJNExEsDFYW86tORD27APwVjymo9t1CqRk/AiVxHB2247jKZKO2oLjCyhT0RERLTFCYKAYosOxRbdjM+80UQSnWMBuWLTqB9t6ZDTUsPyvkgCr3W78Fq3K7NOrRBRW5iDhiIzdjnkik07i0x870lEq0oQhEyQ83/fswuvdE7gqXNOPHdhBKE5Pld7QnGc7nUzwEREtIGEQiFcvHgRwWAQLpcLBw4cYLUlIqJ1JggC9Ho9AoHAjPWjo6Pw+/1sL0cbDs9A0YbjCyfwg9f68NQ5J072uhbeAcBkMApJklgGn4jWhDcUT1dVkqsrXXT60DkWQGKJV8NfTSEKqMozoL7IhJ1F0y3hDEIM//Zv/wYAeMe+IphMppX4NYiIiIhok9IoFWhwmNHgmHnRzmQgmm5D50dr/yRevdALV1KDJBZfWSmWTOH8kA/nh3yZdYIAVOQasKvIlG5JZ0JDkQl2k3bFficioikqhYhb6+y4tc6OUCyBX18cxZPnnHipY3zW5+77mhxzHicSTzLgRES0hsbGxtDe3o5UKgUAiEajuHTpEhobG/ndDRHROtLpdNi3bx+6urrgdDpnbAuFQmwvRxsOQ0y04Tz47bNATu6C46rtOXigyYH79hajLFe/BjMjou1GkiSM+qJoHfLOaAk36A4vvPMCdCoF6ouM6avbzdhVZEJdoTHrCVafL37Nj0dEREREW19ujgbXV2twfXUefL5cfH3gt0hJwJ3veD/6/UlcGPJlWhx7w4t/jylJQM9EED0TQRxrHc6sz8vRZKo17SoyobHYjHKbHiLbGxPRCtGrlbi/qRj3NxXDFYzhWOswnjw7hFN9bgDA/fOEmN72r/8NvVqB+/cV4z2Hyth6nYholUiShO7ubgwODs7a5vF4EAqFWOGDiGidiaKImpoamM1mdHR0IJmcrnY61V7O7/djx44dEEW2mKf1xRATbTh2aQwqpJCEiCRESBCRhIAkROQZ9XjLHgfu3luCeocFgqgEBP4hJaJrJ0kSRnwRtA56cX7Ii9YhL1qHfJgILK0lRzZ5OWrsSgeVGtJXrlfkGngClYiIiIhWnSgANXYDDlSb8NZ98jpJkuD0RnBhaLqy6AWnD0OepYX1JwJRvNQxjpc6xjPrjFolGhwm7C42o7HYjD0lFgabiGhF2AxqPHSkHA8dKceAK4QTPS6UWLNf2Ngx6sfFYbminC8Sx/sOl63lVImIto14PI6LFy/C4/HM2mYwGFBfX88AExHRBmK322E0GnHx4sVZ7eWcTieCwSB27doFtVq9TjMkYoiJNqAnNH+FEu0cwaQ4gNPpJUMAFGrgfY8DlTfN3ifiBX74TnmMQg0oNfKi0gMqXfr2ivvqK9frAHsDkJO/8r8oEa0bSZIw7I2gdWg6sHR+yIuJQOyaj12Rq59RXanBYUK+UcOSyURERES0YQiCgGKLDsUWHe5smC4X7w3FcWFYrkJ60SlXbbo8FkByCW2T/ZEEXut24bXu6fbwRo0SDcXTwabdxWZU5BoYbCKiZSu16VFqm7sy+5PnhjL3728q5mdyIqJVEAgEcOHCBUQikVnbCgsLUV1dDYWCbT2JiDaaqfZynZ2dGB4enrHN6/XizJkzaGhogNFoXKcZ0nbHEBNtARKQjALiHE/neBgYOLH8w7/9W8Dud2Tf9rUjgEIFaEyAxphlMQE66xWLRb7VmgGRb96J1sJUYKllcGZgaTJ4bYEllUJAbYEx0zqjodiMnYVGGLWqFZo5EREREdHaMutVuH5HHq7fkZdZF4kncXk0kGmtfMHpQ9uwD6FYcp4jzeSPZg827UpXbNpdIoebKhlsIqIV8uIVFeLu2zt3yzkiIlqesbExtLe3I5VKzVgvCAJqampQVFS0TjMjIqLFEEURtbW1MJlM6OjogCRNX7wUjUZx9uxZ1NbWorCwcJ6jEK0Ohpho61DMUdYucY2toFRzXNWVjAPjbcs8qAC8+e+AIx/Lvrn5x4BCCRjypxedlcEnogVMtcVoXeHAklGjRL1Drqo0VWGp2p4DtZLtLImIiIhoa9OqFNhdIgeNpqRSEnongzNa0V1wLq2yqT+awIkeF070TAebcq4MNqXDTQw2EdFyPP7x6/FSxwRaBz3zVmwiIqKlkSQJ3d3dGBwcnLVNrVZj165dMJvNWfYkIqKNqLCwEAaDARcuXEA0Ov2duiRJ6OnpQV5eHpRKRkpobfEZR1uHco4QUzJ+bcdV6bKvj/qv4aASoJ6nD/RzfwaEJmeuE0RAn5sONeVdEXDKA/R5gLFQXqwVcuCJaIuTJAlDnnAmrNQ65MP5IS9c1xpY0irR6Ji+Gnx3sRnlNj2/OCEiIiIiShNFAVX5OajKz8E9e+QKJ5IkYcQ384KC1iEfJgKLv7AoEE3gZI8LJ+cJNjUWm1GVx2ATEc1Po1Tgjl0FuGNXwXpPhYhoy4jH42hra4Pb7Z61zWQyYdeuXdBoNOswMyIiuhZGoxH79+/HxYsX4fV6AciV9RoaGhhgonXBZx1tOP4PvgTUVgNSCkgl5dvM/eTsdak4kIwBth3ZD2jIBe75JznMlIjKYxMRuc1cPCTfxoLpn6fWhaa3aUzZj3tNISbMHTRKJoCQa/Z6KQUEx+VlPrd+Abj5c9m3XXwKUGrTgaciORQlspIMbQ6TgShaBr04N+BBy6AHLYMrUGHpqsDSnmIzyhhYIiIiIiJaMkEQUGTWocisw50Ncrl5SZIw6oumA03T4aZx/7UHmxqLTdhbasHeEgv2lJhRbNFBEPg+noiIiGg1xONxnDt3DqFQaNa2oqIiVFdXQ+R3DUREm5ZarcaePXvQ3d2NoaEh1NTUwGSa4ztyolXGEBNtPEotoDGu3PF0VuDg76/c8aboc4EHfyiHmaJ+IOq74n7654gPiHiAsFsOJiWvOFE7V4gp7AIgZd+2GDnzXGF27H/MDEEp1ICpGDCXAObS9G3JFT8Xz18ximiVBKIJnB/yonlADis1D3ow6A5f0zFNWmWmstLULQNLRERERESrRxAEFJq1KDRrZ1RDGfVF0DJ4bcGm17pdeK17OtiUl6PGnnSgaSrcZDPMUbGZiIiIiJZEqVQiJydnRohJEARUV1fD4XCs48yIiGiliKKI6upq2O12BphoXTHERLRcmhyg/p6l7RMPy4GmsBuwlGcfk4gCZddPV12KeJb2GMai7OuT8dlVnJIxwN0jL3PR2eRQ0/V/DOx519LmQrQI0UQSl4b9aBn0oHlQDi51jgcgXUOWz6RVzmgHNxVY4pXZRERERETrr8CkxR27ZgebWq8KNo0tIdg0EYjhd5fG8LtLY5l1pTYd9pRYsLfEjL0lFjQWm2HQ8FQYERER0VIJgoC6ujpEo1F4vV6oVCo0NDTAbDav99SIiGiFzRdgkiQJPp+Pf/9pVfHMDdFaUunkxTTPlQmWUuD3n53+OREDQpNAaCIdbJqYDjhN/RwYAwKjgH9EbhWXTWB0eXMOu+QlPrtMbMZj7wWUGsBaAVgr07cV8u8pKpb3uLQlpVISusYDaB70yqGlAQ/ahv2IJVPLPqZZp0JjsQm7iy2ZwFKpja0kiIiIiIg2kwKTFgW7tHjjFcGmMV9kViu6Ud/ig00DrjAGXGEcaxkGAIgCUG3PkVvQlVrQVGJBXaERaiVbnxAREREtRBRFNDQ0oKOjAzt27IBWq13vKRER0RobHBxEd3c3ysrKUFFRwe/iaFUwxES00SnVgKlIXhaSSgKY48UiHgGK9spBp8AYltyyzlySfX0yDrQ/C0jJ2dtEFWApkwNNudXpZQeQVwOYSgD2yN7SJEnCkCecaQfXPODB+SEfAtHEso+pUymwu9iMPSVm7CmVr6hmhSUiIiIioq3JbtLidpMWt9fPDDZlLopIV3L1huOLOl5KAjpGA+gYDeC/Tg8CANQKEfUOE5pKzHLVplILqvIMbDtNRERElMVUBSYiItp+JiYm0N3dDQDo7+9HOBzGzp07IfL7XlphDDERbSXzVT3Kqwb+4CX5fjIhV2byOQHvAOAdvGJJ/xx2zdzfXJr9uN7B7AEmAEjFAVeXvHT9duY2pRawVQG3/W9g592L+/1oQ/OG4jg36MG5fg+aBz1oGfRgIhBb9vGUooCdRUbsKZGvkN5TakZ1fg6UCr4ZIiIiIiLaruxXtaKTJAn9rhDODXjQkg43tQ55EYkvrtprLJlC84B80QXQBwAwapRoLDZjb6kFTaUW7C+zwG5ipQEiIiLa+uLxOC5fvoyqqipWWiIiooxoNIq2trYZ68bHxxGNRtHY2AiVSrVOM6OtiCEmou1IoQTMxfJSel32MbEg4B2aDjVZyrKPc/cubw6JCDB2EXNWjpIk4NhnAGs5kF8P5NfJQSqmeTeERDKFSyN+nB2QQ0tnB9zoHg9e0zGr8g3YWyJXV9pTasGuIhO0KrYjJCIiIiKiuQmCgPJcA8pzDbi/qRiA/Hnl8lhADielg02XRvxIphZXkdgfTeB49ySOd09m1jnMWuwrs6Kp1IJ9ZRY0Fpv5eYWIiIi2lGg0ipaWFoRCIYRCITQ1NUGp5NeIREQEaDQa7NixA5cvX56x3ufz4ezZs9izZw/Dr7Ri+O6DiLJTG4D8WnmZT241cNc/ymGmqcXVA8QXGWjJq8m+PjAGnPrWzHWqqTntlENN+TvlxVLOcNMqG/FGcLbfjXMDHpzt96BlyLPoK5uzKTJrsadEvrJ5b4n8BYBZx5Q2ERERERFdO6VCRH2RCfVFJrz7kLwuEk/igtOH5gG5amzLoBfdE4u/EMPpjcDZOoxjrcPyY4gC6otMmVBTU6kFlXkGtromIiKiTSkUCqGlpQXRaBQAEAwG0dbWhsbGRr6/ISIiAIDD4YBWq8XFixeRTE536QmHw5kgk8FgWMcZ0lbBEBMRXRtLKXDoIzPXSRIQnEiHmnrkUNPkZWCyE5joBGJ+eZygkANI2Yxfmr0uHgScZ+XlSkqdHIbK3wkUNAAFjUDpIUBruuZfbzsKx5JoHfLOCC2N+CLLPp5Zp8KeEjOaSi3Yk660xFYMRERERES0lrQqBQ6UW3Gg3JpZ5w3H0TroRfOgJx1u8i76s08iJaF1yIvWIS++/5rchs6iV2FviRxq2ldmRVOJBWY9L9YgIiKijc3n86G1tRWJRGLG+kAggGg0ysoaRESUYbPZsG/fPrS2tmaCrwAQi8Vw7tw5NDY2wmw2r+MMaStgiImIVp4gADn58nJ1uzpJAoLjwMRlwD8MKNXZjzHevvjHS4SBkRZ5aU2v+/1fAWWHlzX97SSVktA9EUyHleTQ0lLaLFxNrRTR6DChqdSKvaVycKnMpufVOkREREREtOGYdSrcWJOHG2vyMutGfZF0GzoPmge8aB7wwB9NzHOUaZ5QHC92jOPFjvHMuqp8Q7pakxX7Si2oKzRCpWAlYSIiItoYXC4XLly4gFRqZtV9nU7H1kBERJSVwWDIBJmCwekKx4lEAi0tLaivr0deXt48RyCaH0NMRLS2BAHIscvLfPJrgf3vl8NMY5eAqHdpj1OwK/v60QvAT39frtZU0AAU7pYXY+HSjr9JuYMxObCUDi01D3jgiyzuhHw2Fbn66RPyZRbsLDRBreQJeSIiIiIi2pwKTFrc2VCIOxvkz4iplISu8QDO9k9/juoY9WOx1310jwfRPR7EE2eGAABalYjdxWa5UlO6FV2RWbdavw4RERHRnEZHR9He3g5JmvnGxmg0Yvfu3VCpWFGSiIiy02g02Lt3L86fPw+fz5dZn0qlcOHCBdTV1aGwcHt890orjyEmItqYqm6RF0Cu3uQfkVvMjbcD423pcFMbEPHM3tdaAWiM2Y870po+ziXg/E+n1+cUAEVNgKMJSnMNjJIPfsxxjE0imZLQPuLHmX43zvS5cabfjd7J0LKPZ9Qq5ZPs6dDS3lILbIY5KmkRERERERFtAaIooKbAiJoCI951XSkAIBhNoGXQm6loe3bAg3F/dIEjySLxFF7vdeP1XndmXYFJg/1lVnkpt6DBYYZWpViV34eIiIgIAAYHB9HV1TVrvdVqRUNDAxQKvhchIqL5qVQq7NmzB21tbZicnJyxrb29HbFYDKWlpezWQkvGEBMRbXyCAJiK5GXHrdPrp1rTjV+SqzWNXZQrLdkq5z7WSGv29YFR4PJzwOXnoAfwhwCC0EPzxHGg9IAccCraC1jK5PlsQJ5QDGf7PXJoqd+Nc/0eBGPJZR1LIQqoKzBiX5klU2mpKs8AUdyYvzsREREREdFaMWiUOLojF0d35AIAJEmC0xvBuf7pNt2tQ15EE6kFjiQb9UXx7PkRPHt+BACgVohoKDbhQJkV+8vlcFOhma1ciIiI6NpJkoS+vj709fXN2ma321FXVwdRZKV9IiJaHIVCgYaGBnR0dGBkZGTGtp6eHiQSCVRVVa3T7GizYoiJiDavK1vTVb5hcfuMXlj04Q0IAb0vyAsAqPTAnw0CwvpfhZJKSegcD2QqLJ3uc6NrPLjwjnMoNGkzrQyaSi3YXWKGXs2XCCIiIiIiooUIgoBiiw7FFh3u3lMEAIgnU7g07MfZAfkCk7MDHvRMLO4zWyyZktvX9XuAV3oAAMUWHfaVWXAgHWra5TBBpeAXjERERLR4kiShp6cHAwMDs7YVFxdjx44drJZBRERLJggCamtroVKpZr3G6HRsn05Lx2+oiWh7uf0vgPp75TDT6Hn5NhZY3L6FuwFxjgBT52/lKk8lB+WqTZqcFZsyAPgjcZwb8OB0nxtn0lf3+iOJZR1LqxKxp3g6sNRUZkGRmW8iiIiIiIiIVopKIWJ3iRm7S8x4/1F5nTsYw7lBTybUdK7fDd8iP9cNecIY8oTxTMswAECjFLG3xIJ95ZZMK7p8o2a1fh0iIiLa5CRJQldXF4aGhmZtq6ysZLsfIiK6JoIgoKqqCmq1OtOutLq6GkVFRes8M9qMGGIiou2leL+8TEmlAFcXMNwMOM8Cw82QhpshRH2z9y3aO/dxzz8OnPuhfF8Qgfx6oOQAUHwQKD4A2OvnDkBdRZIk9EwEZwSW2kf9kKQl/J5XKLPp01frym3h6gqNvGKXiIiIiIhojVkNatxaZ8etdXYAcoXdnskgzvbLF6ws5bNfNJHCyV4XTva6MuvKbHrsT1dr2ldmxc5CI5T87EdEREQABgYGsgaYampq4HA41mFGRES0FZWUlECpVCKRSKC4uHi9p0ObFENMRLS9iSKQVyMvu98BAPB7PfjPf/07FKaG8eYmBzSTFwHnObnC0lyGTk/fl1LA2AV5OfM9eZ3KIIenSg8BpUeA0usAnRUAEIwm0DwotwqYag/nDsWX9evwalwiIiIiIqLNQRQF7MjPwY78HLzjQAkAwBeJo3nAgzN9Hpzudy+pCm+/K4R+Vwg/P+cEAOjVCuwtsWB/eTrYVGqF1aBetd+HiIiINq7CwkKMjo4iFApl1tXV1aGwsHAdZ0VERFsRX1voWjHERER0NUGER7TCI1px600fh8ZkAiQJSCWzj4/4gPH2+Y8ZDwK9LwO9L2NEsuJUqhanNEdwStqJtpAZyWVWWSq26LCvTA4sHSi3or7IBLWSV9oSERERERFtRiatCjfV5OOmmnwAcrWmzvFA5oKX031udI0HF3WsUCyJ492TON49mVlXlW/AwXIrDlbYcLDciso8A1vHEBERbQNqtRp79uxBc3MzwuEwdu7ciYKCgvWeFhERbUOBQAB6vR6iyO8zKTuGmIiIFkMQAMUcfzLjYeDgB4HBU8DoBUCaDjslJQEdUglOperSSy2GkJ/eb2lTUCtENBSbMoGl/WVWFJq1y/yFiIiIiIiIaKMTRQG1BUbUFhjx7kNlAABPKCZX8u2Xg03n+j0Ixua46OYq3eNBdI8H8ZNTgwCAXIMa+8utuK7CigPlNjQWm6BRLq4VOhEREW0uGo0Ge/bsQSAQQF5e3npPh4iItiGv14uWlhZYrVbs2rWLQSbKiiEmIqJrZSwA7vknAEAo4Me51nM43d6HU84ozvgt8EvLCxrZjRrsV3ThQL6E/Tt3oGHvYWhzTCs5cyIiIiIiItpkLHo1bt1px6077QCAZEpC+4hfbj+XrtjUOxla4CiyyWAMv744il9fHAUAqJUimkosOFBhxcFy+QIai54t6IiIiLYKrVYLrZYXxhIR0drz+XxobW1FKpXC5OQkLl68yCATZcUQExHRNRjzRXCqz41TvW6c7nPhgtOHREoCYF3ScRSigF1FJhwot2JfmQUHyq0oVnghfOXtwADk5bdKoKgJqLgBKL8RKDsCaBlqIiIiIiIi2s4UooBdDhN2OUx46Eg5AGAiEMXZfg9Op0NNLYMeROKpBY8VS6RwsteFk72uzLoaew4Opis1XVdhRZlNzxZ0REREG5QkSRgbG4PdbufrNRERbRipVAoXL15EMjldRXhychKXLl1CfX09X7NoBoaYiIgWKZWS0DkewOu9LpzudeNUnxv9rsVd3Xo1o1rAAUsQB/UjOHDHe9BUaoFOfVXJ/gu/umoCCWDolLy8+gggiEDhHqD8BjnYVHYU0NuW+dsRERERERHRVpGXo8Eduwpwx64CAEA8mcJFpw+n+uQLcE71ujHmjy7qWJfHArg8FsB/nhzIHPtguRUHK6w4WGFDg8MElYJXzhIREa03SZJw+fJlDA8Pw+PxoLa2ll8KExHRhiCKIurr69Ha2jojyDQ+Pg5RFFFXV8fXLMpgiImIaA4JScCpfi/axsdwqteFM/0eeMPxZR2r1KbDwXIbDpRbcV2FDTX2HIjiAi/GAyfm3y6lgOFz8vLa1wAIQEGDHGqqfANQfTug0i1rvkRERERERLR1qBQi9pZasLfUgg/dWAlJkjDoDuP1XpccbOp1o33Uv6hjTQSi+OWFEfzywggAQKsSsbfEgusqbDhQYcX+MivMOtVq/jpERER0FUmS0NXVheHhYQDAyMgIUqkUdu7cyS+FiYhoQzCbzWhsbMy0lJsyOjoKQRAYvqUMhpiIiNImAlGc6nXjvy+P4Je+KkwktfiPH7Qs+TgKUUCDQ24Nd7DchoMVVhSYltFnfNcDgEIN9L0KOM/KlZjmJQGj5+Xl5L8Dn+1iiImIiIiIiIhmEQQBpTY9Sm16vG1/CQDAG4rjTL8bp9KVms4NeBBNLNyCLhJP4USPCyd6XOljA7V2Y7pSk/y5uMTKz6ZERESrRZIkdHd3Y2hoaMb68fFxFBcXw2QyrdPMiIiIZrJYLJkgkyRJmfUjIyMQRRHV1dUMMhFDTES0PUmShO6JIF7vSV912udGz0TwihH6RR8rR6PE/nKrXE6/3Iq9pRYYNCvw57XssLwAQCwIDJyUA029r8ot5ZKxufctaAQMedm3TXQCEQ9Q1AQo+DJAREREREREgFmvwq077bh1px0AEEukcMHpxek+t9xWvc+NicA8n0PTJAloH/WjfdSPH57oBwAUmDTY6zAiGMlFkTKIREpa4ChERES0WL29vRgcHJy1fteuXQwwERHRhmO1WtHQ0IALFy7MCDI5nU6IooiqqioGmbY5fntNRNtCIpnCxWEfTva45HL5vW5MBhc++ZpNsUWXbgtnxYFyG+oKjVAs1BruWqkNwI5b5QUA4mFg8FQ61PQKMPg6kIhMj6+8ee5jnfoW8Nq/AhoTUHGjPLbqZiB/p3zJLBEREREREW17aqWIfWVW7Cuz4sM3VUGSJPRNhnCqz41T6TZ0nWOBRR1r1BfFr3xRAEUAgGe/chz7y604VGHDdZU2NJVaoFUpVvG3ISIi2pr6+/vR398/a319fT3y8ua4yJWIiGid5ebmYteuXbhw4cKM9YODg1AoFKioqFifidGGwBATEW1JkXgSZ/s9eL1XDi2d6XMjGEsu+TiiANQXmeQqSxVya7gi8wYog6/SAZU3yQsAJKJyy7nel4Gel4Dq2+fet/tF+TbqA9p/IS8AYCwCdtw2vehtq/s7EBERERER0aYhCAIq8gyoyDPgHQfkFnTuYAxn+t14vdeN030uNA96EVtEC7pgLImXL0/g5csTAAC1QsTuEjOuq7DhUKV8wZBZp1rV34eIiGizGx4eRk9Pz6z1O3fuhN1uX4cZERERLV5eXh7q6+vR1tY2Y31fXx9UKhWKi4vXaWa03hhiIqItwRuK41SfCyd7XXi9x4XWIS/iyaWXpzeoFdjtMCIx0oEiZRCf/4P3oCh/E4R5lBqg7Ii8vOGzc48LjANjF7Jv8w8D534oLxAAxz45DLXjdqDkOraeIyIiIiIiohmsBjVury/A7fUFAIBoIonzQ16c6nVnWre7FlEFOZZM4XR6/L+9KBcJrisw4lClLR1ssqHApF3tX4eIiGjTmJiYQEdHx6z1tbW1KCgoWIcZERERLZ3dbockSbh06dKM9Z2dnVCpVAzlblP8RpqINqURbyQTWHq914X2UT+kpWeWUGDS4GCFDdelKy3tLDQiFAzg619/BQBg0GyxP5O+Iblt3PilBQZKgPOMvLz0D3Lruco3AIf/QL4lIiIiIiIiuopGqcCBchsOlNvwBwAkSUL3RBCne9043jmK37X2w5vSLHgcSQIujfhxacSP7x3vAwCU2fSZSk3XVdhQmWeAwJboRES0DXk8nllVKwBgx44dKCoqWocZERERLV9BQQGSySQuX748Y/2lS5eg1WphMpnWaWa0XrbYt/NEtBVNnfR8vSddaanXhQFXeFnHqso34FCFDQcrbDhUYUOpTbe9Tno6moA/OgH4R+S2c90vAj0vAt6B+feL+oBLzwC7HliLWRIREREREdEWIAgCduTnYEd+Dt5cZ0Zh/28RSimw5/a34fxoGK/3unDR6UNqERcl9btC6HeF8PiZQQBAXo4a11XYMkt9kRFKhbjKvxEREdH6CgQCOH/+PFKpme1bS0tLUVJSsk6zIiIiujYOhwOxWAx9fX2Zdbm5ucjJyVnHWdF6YYhplfX19eFf/uVfcOzYMQwMDECj0WDHjh1417vehT/6oz+CXq9f9rEfffRRfPCDH1zU2O985zv4wAc+MO+YUCiEr371q/iv//ovdHV1IRqNorS0FHfffTc++clPory8fNlzJVqKRDKFtmF/ptLSqT4XJgILl5+/migADQ5z5krNgxU25OUsfMXntmAsBPa8S14kCZjsBDp/C3T9Fuh9BYiHsuwkADtuzX68RBQ49yOg5k7AzB61RERERERElJ1eTOKOnXl4+yH5alp/JI4z/Z7MhUvnBjyIJVILHAWYCMTw7PkRPHt+BACQo1FiX5kFhypsuK7ShqZSC7Qqxar+LkRERGspHA6jtbUVyWRyxvrCwkJUVlau06yIiIhWRnl5OeLxOJxOJxwOB6qrq7dXIQrKYIhpFT399NN43/veB5/Pl1kXCoVw6tQpnDp1Ct/85jdx7NgxVFdXr+MsZZ2dnbjrrrtmlWlrb29He3s7vvnNb+KHP/wh7rnnnnWaIW1lkXgSZ/s9eD1dZelMnxvBWHLhHa+iUYpoKrXgUKV8Feb+citytlo7uNUgCEBejbwc+ZgcSOo/DnT+Buj8HTB2QR7naAIMedmP0fsK8Myn5fsFjXKYqfbNQMlBQORJYyIiIiIiIsrOqFXh5tp83FybDwCIJpJoHfRecWGTG/5IYsHjBKIJvHx5Ai9fngAAqBUidpdMX9h0oNwGs061qr8LERHRapEkCefPn0csNvNi39zcXNTW1vJLXiIi2vQEQUB1dTUsFgvy8vL42raN8dv9VXL27Fk8+OCDCIfDyMnJwZ/92Z/h1ltvRTgcxmOPPYb/+I//QEdHB+6++26cOnUKRqPxmh7vueeeg8PhmHP7fGVE/X4/7r777kyA6SMf+Qje/e53Q6fT4fnnn8eXvvQl+Hw+PPjgg3j11VfR1NR0TXMl8kXiON3rxms9k3i9x4XWIS/iyUXUjr+KSavEwXTZ+EOVVjQWm6FRMjBzzZQaoOoWebkTgG8Y6PodoNLNvc/lX03fHz0vL698BdDZgOo3ArVvAnbcBuhtqzx5IiIiIiIi2sw0SgUOptvA4xYgmZLQPuLH672uTLBpzB9d8DixZAqn+9w43efGv70oX79TV2DEoUpbZrEbtav/CxEREa0AQRCwY8cOXLhwIdNKzmw2o76+nl/yEhHRliEIAvLz89d7GrTOGGJaJZ/61KcQDoehVCrxq1/9CkePHs1su+2221BTU4PPfe5z6OjowJe//GV88YtfvKbHq62tRUVFxbL2/Yd/+Ad0dHQAAP7f//t/+OxnP5vZdvToUdxyyy24+eabEQqF8OlPfxovvPDCNc2Vth93MIaTvS6c6HbhZO8kLjp9SC09s4QCkyYdWJKDS3UFRogiP6CtOlMRsO+9c2+XJKDjl9m3hV1A60/kRRCB0sNyoKnubiC/dnXmS0RERERERFuGQhSwy2HCLocJD19fAUmS0O8K4WSPK13R2Y2eieCCx5Ek4NKIH5dG/Pje8T4AQFWeAYcqbThcZcOhylwUW+a5eIeIiGid2Ww2NDU1obW1FWq1Go2NjVAoeFEvERFtH6lUCoIgMMC7xTHEtApOnjyJl19+GQDwoQ99aEaAacpnPvMZfOc730FbWxseeeQRfOELX4BKtfYlrePxOP7lX/4FAFBfX4/PfOYzs8Zcf/31+NCHPoR///d/x4svvojXX38d11133VpPlTaRMX8EJ3vSoaUeF9pH/cs6TlWeAddV2HBdpQ2HKmwoten4orQRxcNA8UEg7AEinrnHSSm5TV3/ceA3XwRyq4G6u4BdDwAlB9ZmrkRERERERLSpCYKA8lwDynMNeOfBUgDyeYhTve5MsKlteHEXT3VPBNE9EcRjrw8AAEqsOhyqtOFIZS4OVdpQnqvneQgiItpQjEYjmpqaoFAooFTyKz4iIto+YrEYLly4gJycHFRXV/Oz2hbGdzir4Oc//3nm/gc/+MGsY0RRxPvf/3782Z/9GTweD55//nnceeedazTDac8//zy8Xi8A4OGHH4YoilnHfeADH8C///u/AwB+9rOfMcREMwx5wjjZM5kJLXUv4grIq4kCsMthkistpcvG5xs1qzBbWnFqPfCObwHJBDD4ulyV6fKvgLGL8+832Qn8978A/mGg5JtrM1ciIiIiIiLacuxGLe7aXYS7dhcBAPyROE73ueVKTT1unBv0IJZILXicQXcYg+4hPHFmCIBcEfpQOtB0pNKGansOT5QTEdG60+v16z0FIiKiNRUMBnH+/HlEIhH4fD7odDqUlJSs97RolTDEtApeeeUVAIDBYMCBA3NXF7n55psz91999dV1CTFNzfXq+Vzt4MGD0Ov1CIVCePXVV9diarRBTZVtP9Htwms9kzjZ48KgO7zk46gVIppKLXJruEob9pdZYNSufTUyWkEKJVB+VF7u+CvA0y+HmTp+BfS8CCQi2feru2vuY8aCgNqwOvMlIiIiIiKiLcmoVeGWOjtuqbMDAKKJJFoHvTjZK198darXjUA0seBxRn1RPN3sxNPNTgCAzaDGdRVWHE4Hm+qLTFCwzT0REa2CZDLJVnFERESQXxObm5sRj8cz67q6uqDVapGXl7eOM6PVwhDTKmhrawMAVFdXz1vOc+fOnbP2Wa4PfvCDaG9vx8TEBEwmE6qrq/HGN74RH//4x1FcXDznfhcvTldKuXI+V1MqlaiurkZLS8uy5jo4ODjv9uHh4cz9YDAIn8+35Meg1SFJEnomwzjV78Xp9DIWiC35OFqliL0lJhwsM+NAqQm7i03QKKcrf0mxMHyxpYehVkMgEMh6n5ZItAB175KXeBjKgeNQdv8ayq5fQwyOAgAkUQV/wWEg2//5eAjGf9uPpL0Rieo3IV7zFkim7Zmq5nOSNhI+H2kj4fORNho+J2kj4fORNpr1fk7W2pSotdnxvv12JFISOkYDOD3gw6l+L84MeOENLxxqcgVjeO7CKJ67IH+mNWoU2FdqxoH0uY76whyoFNmrnNPGEgwuvYo4EdFaCQaDaG5uxo4dO1BQULDe0yEiIlpXCoUC1dXVszIKbW1taGpqgtFoXKeZ0WphiGmFRSIRTExMAMCCJcysVisMBgOCwSAGBgau6XFfeOGFzP3JyUlMTk7ixIkT+PKXv4x//ud/xh/8wR9k3W8qXGQwGGCxWOZ9jNLSUrS0tGB8fBzRaBQazeJbfZWWli567BNPPAGz2bzo8bSyJAmYTGrhTOgxnDDAmTAgIi39T4UKSRQpQ3CogihSBpGviEDhlZBqBV5vBV5fhbmvhu9///vrPYUtpgyQfh+FmmHUJDugkaL4zbd/kHVkTbIdb4sHoRw6AeXQCWhf/GsMC4VoV+xEh2In3KJtjee+MfA5SRsJn4+0kfD5SBsNn5O0kfD5SBvNRnpO7gRQpwFcKg2G4/J5EGdCj7C0cLVofzSJlzpdeKnTBQBQIolCZRgOpXwuxK4MQylIq/wb0HJ4vd71ngIRUVaxWAytra2Ix+O4dOkSwuEwysvL2c6UiIi2NbvdjnA4jN7e3sy6VCqF8+fPY//+/UvKLdDGxxDTCvP7/Zn7OTk5C46fCjEt9wq0qqoqvO1tb8PRo0czQaHu7m48/vjj+OlPf4pIJIKPfexjEAQBH/3oR+ec72LnOiUQCPCPwRaRkoCJpA7OhB7OhAHDCQNi0tLL1GqEhBxaUgbhUAaRq4iAFdUpK0HAiODAiOiYd1hN8vKsdUXSCIoSI7gl8QLGhHx0KHaiXVGHCSEf4Ad5IiIiIiIiWgZBAHIVUeQqomiEC5IEeFPqzHkSZ1yPgKRe8DgJKDCYyMFgQj7PpkAKBcowitLnSgqUIagYaiIiojkkk0mcP38e0Wg0s66vrw8qlWrejhtERETbQVlZGcLhMEZHRzPrYrEYzp8/j6amJrZh3UIYYlphkUgkc1+tXvjkxlQQKBxeehutt771rXj44YdnJfCvu+46PPjgg3jmmWfwtre9DfF4HH/yJ3+C++67D4WFhVnnu5S5Lme+C1WaGh4exqFDhwAAb3vb21BbW7uk49PixRIpXBj2y+3hBnw4N+hDKJZc8nFyDSocKDXjYJkZ+8vMqM7XQ9wiIZJAIJC5KvShhx5aVMiPVpgkIedb3wPm6Sxpl8ZhT4zjxsTLSFqrkKh5C+I1dyFl373lAk18TtJGwucjbSR8PtJGw+ckbSR8PtJGs9mfk0OeCE4PeHG6X1763ZEF90lCTFd2MuA0AKUooKEoJ91+zoymEhOMWp6eXQ8dHR340pe+tN7TICLKkCQJly9fnnGhPAAYjcZZ3+sQERFtR4IgoLa2FpFIZEZl1UAggPb2dtTX17Ny4RbBT8krTKvVZu7HYrEFx08l6nU63ZIfa6GWa/fccw/+4i/+An/+53+OUCiEb33rW/jCF76Qdb5Lmety5rtQa70rGQwGmEymJR2f5haJJ3Gm340T3S6c7HHhTL8b0URqyccpMmtxuNKGw1W5OFRpQ1WeYVu8EOTk5PD5uF7++BTQ/QLQ9gzQfgwIu+ccqnB3Q3Hya9Cc/BpgKQP2vR+4+bNrN9c1xOckbSR8PtJGwucjbTR8TtJGwucjbTSb8TlpMplQX2bH+26Qfx7xRnCy14WTPZM40e3C5bGFq6wnUhKah/xoHvLj28cHIQrALocJhyvlcy2HKmywGha+0JCu3ZUV54mINoKhoaEZlSUA+fubxsZGVpYgIiJKE0URDQ0NOHv27IyiK+Pj4zAajZnOVbS5McS0woxGY+b+YlrEBYNBAItr57YcH/3oR/EXf/EXkCQJL7744qwQ09R8lzJXYPXmS9cuEE3gdJ87cxKtedCDeHLppcrLbHocrrThUKUNR6pyUWLVbYvQEm0gKh1Q9xZ5ST4C9L0CXHxSDjUFx+bez9MPePrWbp5ERERERES07RSatbhvrwP37ZVbpU8Goni914UTPfJFZBeHfZAWOB2TkoDzQz6cH/LhW6/0AADqCow4UiVfRHa40obcHM38ByEiok3P4/Ggq6trxjqFQoHGxsZFddEgIiLaTlQqFRobG3HmzBkkk9Pdhrq7u2EwGGCz2dZxdrQSGGJaYVqtFrm5uZicnMTg4OC8Y91udyYYtFqpQLvdjtzcXExMTGBoaGjW9pKSEpw4cQLBYBAejwcWi2XOY021hMvPz5/RWo7Wlzccx+s9LpzsdeFE9yTOO31IppYeWqq25+BQpS0TXCoyL706GNGqUSiBqlvk5a5/BAZOABefAtqeBnxZ/tbuun/uY7n75GpNDOURERERERHRCsnN0eDNjUV4c2MRAPl8zek+F050y8Gm1iHvos7XtI/60T7qx3ePyxfn1Bbk4HBlLo5U5eJwlQ15DDUREW0pkUgEFy9enLV+586drBpHREQ0B71ej/r6epw/f37G+ra2Nuzfv39ZXbBo42CIaRXs2rULL7/8Mjo7O5FIJKBUZv9nvnTpUuZ+fX39qs1nvuo5u3btwuOPP56Zz5EjR7KOSyQSmSsBVnOutLCp0NJr3ZN4rWcSF5wLX9l3NUGYurIvXa68kifBaBMRFUD59fLy5i8BQ2eAtiflUJO7B9CYgcqbs+8b9QNfOwSYioHGtwENbwMKdq3t/ImIiIiIiGjLM+tUuG1nAW7bWQAACEYTONPvxskeOdh0bsCDWDK14HE6RgPoGA3g+6/JoaZqew6OVMlVsw9X5iLfyPM5RESbVTKZxIULFxCPx2esLysrQ15e3jrNioiIaHPIzc1FRUUFent7M+sSiQQuXLiAffv2sR3rJsYQ0yq48cYb8fLLLyMYDOL06dM4fPhw1nEvvvhi5v4NN9ywKnMZHx/HxMQEAMDhcGSd65XzmSvEdOrUqUzVqNWaK2W3EqElUQAai83pKku5uK7CCoueZWhpCxAEoOSAvLzxr4DR88BkF6Cc4/nd/iyQiACuLuClf5CX/J1ymKnxbUBezdrOn4iIiIiIiLYFg0aJm2rycVNNPgAgEk/i3IAHJ9Pt5073uRGOJxc4CtA5FkDnWAA/eK0fALAj34DDVXKlpiOVNthN2lX9PYiIaGVIkoTLly8jEAjMWG+z2VBRUbE+kyIiItpkysrKEAgEMnkIAAgGg+ju7kZNDb/z26wYYloFDzzwAL70pS8BAL7zne9kDTGlUil873vfAwBYLBbceuutqzKXb3zjG5DSiZebb55dmeSWW26B2WyG1+vFd7/7XXzuc5/LWrnp0Ucfzdx/61vfuipzJZk3FMfJ3nRoqXsSF4eXHlpSKQTsKbFkWsMdKLfCqFWtzoSJNgpBAAp3y8tczj8xe934JeCFv5WXgt3A7rcDu98JmEtWb65ERERERES0rWlVCjl4VJULAIglUmgd8uJEzyRe63bhVK8LodjCoaau8SC6xoP40Qk51FSVNxVqkqs1FTDURES0IQ0NDWF0dHTGOp1Oh/r6+nm7axAREdE0QRBQV1eHUCiEUCgEADCZTCgrK1vnmdG1YIhpFRw6dAg33XQTXn75ZXzrW9/Cww8/jKNHj84Y8+UvfxltbW0AgE996lNQqWYGTF544YVMsOnhhx+eESICgN7eXrjdbuzbt2/OeTzzzDP467/+awDym98PfvCDs8ao1Wp88pOfxN/8zd+gra0N//iP/4jPfvazM8YcP34c3/rWtwDIQajrrrtuEf8KtFgrEVpSK0XsL7PgcGUuDlfasK/MCp2aJfKIZkgmgMnO+ceMtsrLb74IlN8gh5l23Q/obWsyRSIiIiIiItqe1EoRB8qtOFBuxR/eAsSTKZwf8uJEujr36z0uBBcRauqeCKJ7Ioj/PCmHmirzDDhcmW4/V2VDkVm3yr8JEREtxOv1oqura8Y6hUKBhoYGKJX82o6IiFafJElbJjSrVCrR0NCAM2fOwG63o7q6GqIorve06Brw3dAqeeSRR3DDDTcgHA7jzjvvxOc//3nceuutCIfDeOyxx/CNb3wDAFBbW4vPfOYzSz5+b28vbr31Vhw9ehT33nsv9u7dC7vdDgDo7u7GT3/6U/z0pz/NVGH6x3/8RxQXF2c91mc/+1n8+Mc/RkdHBz73uc+hs7MT7373u6HT6fD888/jb//2b5FIJKDT6fDP//zPy/sHoYyVCi0dKLOmr9izYW+pBVoVQ0tE81IogU+8DgydAc4/Dlz4GeB3zj2+71V5+cVngZo7gf3vB+revHbzJSIiIiIiom1LpRCxr8yKfWVWfOzmHUgkU7jg9GXOJ73e60YgmljwOD0TQfRMBPHY6wMAgPJcPY5U5uLIDhsOV+bCYWGoiYhoLSUSicwF7lfauXMnDAbDOsyIiIi2owefeRC9vl5oFVpolfKiU+qgVci3Fq0Fedo85OnykKfPQ0lOCUqMJcjV5m7I8JNer8fBgweh1bIS7VbAENMq2bdvH3784x/jfe97H3w+Hz7/+c/PGlNbW4tjx47BaDQu+3GOHz+O48ePz7ldr9fjn/7pn/DRj350zjFGoxHHjh3DXXfdhcuXL+Mb3/hGJmQ1xWQy4Yc//CGampqWPdftyhuKZ0qBv9Y9ibaRpYeWNEoR+xlaIrp2ggCUHJCXO/8PMHACuPAEcOHnQHAs+z6pONB+DDAWMsRERERERERE60KpELG31IK9pRb8QTrUdHFYDjWd6HbhZI8L/kWEmvomQ+ibDOHHp+RQU5lNn6nUdGRHLooZaiIiWlUKhQLFxcXo7u7OrCsrK0NeXt46zoqIiLabcCKcWRBd/H46pQ5lxjLUWmtRY61BrbUWu3J3waq1rt5kF4kBpq2DIaZVdO+996KlpQWPPPIIjh07hsHBQajValRXV+Od73wnPvGJT0Cv1y/r2AcOHMAPfvADHD9+HKdOncLw8DAmJiaQSCRgtVrR0NCA22+/HR/+8IczFZrmU11djbNnz+JrX/sa/uu//gudnZ2IxWIoLS3FXXfdhU996lMoLy9f1ly3G08ohpM9rmsOLR0onwot5WJvqRkaJUNLRCtKFIHyo/Ly5r8Del8BWv8LuPgUEPXOHr/nXWs/RyIiIiIiIqIslAoRe0os2FNiwUffsAPJlISLTl/6QrpJnOhxwR9ZONTU7wqh3xXCf50eBACUWHWZ81GHK20otS3v3CUREWUnCAJKS0thMpnQ1tYGrVaLioqK9Z4WERFtM+FEeNn7tbvb0e5un7G+3FSOvfl7sTd/L44UHUGpsXRDVmyizYEhplVWXl6Or3zlK/jKV76ypP1uueWWTCu4bIxGI9773vfive9977VOMcNgMOBzn/scPve5z63YMbcDhpaItgBRAVTdLC93/SNw+VdA60+AjueAZAwwlwElh7LvG/YA370HaHgrsOdBwFyyplMnIiIiIiIiUogCdpeYsbvEjA/fVIVkSkLb8FT7ORdO9kzCt4hQ06A7jJ+eHsRP06GmYoscajpcZcPRqlyUWHX8MoKIaAWYzWYcOHAAkiTx7yoREa25SDKyosfr8/Whz9eHp7qeAgAU5xTjSNER3Fh8I653XA+9av0ujkgmk+jq6kJ+fj6s1vWvGEULY4iJaIkYWiLa4lRaYNd98hL2AG1Py23oRDH7+As/A0Za5eW3fwNUvgFoeg9Qfy+gZh97IiIiIiIiWnsKUUBjsRmNxdOhpksjPrzW7cKJdKUmbzi+4HGGPGE8fmYQj5+ZDjVl2s9V5aLUxlATEdFyqVSq9Z4CERFtU4++6VGEEiFEEhFEkpHp+4kIgvEg3BE3JiITmAxPYiQ4gqHAEOKphT8/TBkKDOHxy4/j8cuPQ6PQ4GjRUdxWdhtuK7sNZo15FX+zmUKhEC5evIhgMIjJyUkcOHAAarV6zR6flochJqIFeEIxnOhxZa5cu7TM0NLBCiuOVObiyI5c7ClhaIloU9BZgP0PzT+m+T+v+EECel6Ul2f+B7DrfqDp94DyG+cOQRERERERERGtMoUooMFhRoPDjA/dWIlUSsKlEf+M9nOe0OJCTU+cHcITZ4cAAEVmbab13JGqXJTn6hlqIiIiIiLa4Kqt1Usan0wlMR4eR7+vH5c9l3HZLS8d7o4FqzpFk1G8MPgCXhh8AX/z2t/gltJbcE/VPbip+CaoFKsX6A0Ggzhz5gxSqRQAIBaLoa2tDXv27OFnlg2OISaiqzC0RESL5uoGBk5k3xYPAs0/khdzqdxqbu/vAXlLe2NIREREREREtNJEUcAuhwm7HCZ88AY51NQx5sdrXXKg6USPC65gbMHjDHsj+NnZIfwsHWoqNGlxuGq6UlMFQ01EtM0NDw9Dr9fDbF67qhNEREQrTSEqUGgoRKGhEIeKDmXWx1NxdLg70DzWjHPj53By+CQmI5NzHieeiuPXfb/Gr/t+DZvWhgeqH8A7a9+JEmPJis956vXX7XZn1nk8HvT396O8vHzFH49WDkNMtO2tRGhJq0q3h2NoiWh7sVYCv/8ccO5Hclu5qC/7OO8A8PI/ykvJdcDedwONbwd07L1LRERERERE608UBewsNGFnoQkfSIeaLo8FMpWaXuteXKhpxBfBk+ecePKcEwBgN2oygaYjVTZU5hkYaiKibcPv9+Py5cuQJAlVVVUoKSnh30AiItpSVKIKDbkNaMhtwHvq3wNJknDZcxmvOV/DS0Mv4fTIaSSkRNZ9XREXvn3+2/jO+e/gppKb8N769+Jo0dEVe60UBAE7d+7E6dOnEYtNf5bp7e2F1WqFyWRakcehlccQE2077uCVoaVJXBrxL/kYDC0REQBAEICyI/Lylr8H2n8BnPtPoOu3gJTKvs/g6/Lyy88Dd3954XZ1RERERERERGtMFAXUFRpRV2jE+49WQJIkdI4FMoGmEz2TmAgsHGoa80fxVLMTTzXLoaYC05WhJlZqIqKtK5lM4tKlS5DSV0x3d3fD6/WioaGBf/eIiGjLEgQBtdZa1Fpr8f6G98Mb9eKlwZfwm77f4OWhlxFPzW5hLUHCS4Mv4aXBl1Bvq8cHGz+IO8rvgFK89iiLWq3Grl27cO7cuRnrL126hAMHDkCh4Pf7GxFDTLTlrVRo6WC5DUfS5bD3lFigVoqrMFsi2rRUOrm6UuPbAf8o0PoTOdA0diH7+GQUKGhY2zkSERERERERLYMgCKgpMKKmwIiH0qGmrvEAjne7cCIdbJoIRBc8zqgvOqNSU6FJmznfdqQqF+UMNRHRFtHT04NQKDRjnV7Pv3FERLS9mDVm3LvjXty74154o1481/scnul+BmfHzmYd3+Zqw+de+hxKckrw8aaP4+7Ku6EQry1oZDabUV5ejr6+vsy6cDiMrq4u1NbWXtOxaXUwxERbDkNLRLTujAXA9X8MHP0EMNIKNP8n0PITIDQxPcbeADj2Zd8/FgIEEVBp12a+REREREREREsgCAKq7UZU24146Eh5OtQUTLefk8/LjfsXDjWN+CL4+Tknfp4ONRWZtZnWc0eqclFm4xf+RLT5uFwuDA0NzViXk5ODioqK9ZkQERHRBmDWmPGuunfhXXXvQrenGz/p+Ame6nwK/vjs7/IHA4P4witfwDdbv4k/bPpD3Fl+J0Rh+d/Vl5eXw+Vywe+ffqzh4WHYbDbk5eUt+7i0Ohhiok3PFYzh5BUnSBhaIqINQxCAoj3ycsdfA52/BZp/BFz6hdxGbq4TsWd/ADz/f4Dd75LHGSrXdt5ERERERERESyCHmnJQbc/Bew/LoabuiSBOpM/XHV9kqGnYG8HPzg7hZ2flL/+nQk1H05WaSm06hpqIaEOLx+Nob2+fsU4URdTX10MU+Z0DERERAFRZqvC/Dv0vfHLfJ/FM9zP43sXvoc/XN2tcj7cHn33xs3g091H86aE/xT77HMUBFiAIAurr63Hq1CmkUqnM+o6ODphMJqjV6mX/LrTyGGKiTWclQks6lQIHK6yZK7t2FzO0RESrTKEC6t4sL8FJ+ee5nP0eEPECr/8H8Pp/wJDfgP0JBy4qGtduvkRERERERETLJAgCduTnYEd+Dt5zuCwTanqte2mVmq4ONTkylZpycXRHLkqsDDUR0cYhSRI6OjoQi8VmrK+qqoJer1+nWREREW1cepUe76p7F95e83b8buB3+Hbrt3F+8vyscRcmL+D9z74fb6p4E/7kwJ+gOKd4yY+l0+lQXV2Njo6OzLqp8HFjYyM/V2wgDDHRhsfQEhFtOYbcubc5z8kt6K6gGL+AO3ABt8Z/h9QveoEjHwHKr5+7khMRERERERHRBnJlqGmqUlPX+FSoST7vNxFYONTk9EbwxNkhPJEONRVbdDicrqx+tCoXpTaGBIho/YyOjmJiYmLGOpvNBofDsU4zIiIi2hwUogJ3lN+BN5a9ES8PvYyvnv0q2lxts8Y91/scXhh4AR/b+zE83PAwVOI8BQOyKCwshMvlmvF67XK5MDw8zNfrDYQhJtpwvOEEfnl+mKElItqe+o/PuUmJJHDpZ/KSWwMceBjY+575Q1FEREREREREG8yV7efed2Q61HQ8HWo60T2JiUBsweMMecJ44swQnjgzHWqaOh94hKEmIlpDkUgEnZ2dM9apVCrU1dWxsgMREdEiCYKAN5S8ATcV34Tf9v8Wj5x5BL2+3hljoskoHjnzCI51H8NfHv1LNNmblnT82tpa+Hy+GZUTu7q6YLFYWDlxg2CIiTacd3zzDJSmvCXtw9ASEW0ZRz4O1L0FOPcj4OwPAd9g9nGTl4Ff/W/gt38N1N8LHPgAUHETqzMRERERERHRpnNlqOmhTKgpgONd09XZJ4OLCzU9fmYQj5+RP0uXWHWZ9nNHqmwosfJLCSJaeVNt5JLJ5Iz1tbW1UKvV6zQrIiKizUsQBLyx/I24ufRm/KT9J/jXc/8KX8w3Y0ynpxMPPfsQ3lf/Pnxq/6egVWoXdeypkHFr63RXlFQqhe7ubjQ2Nq7o70HLwxATbThfVT2CXJUOEgQkISIJEVL6NgUBKYiAoIA1R4Ncow55Rh2sOTooFAogKALnFcAFERAVgEIFKDSAQg0o1en7KkCZXqdQp+9fPS49NnM/PU6pA0SGo4holVkrgFs/D9z8p0DPi4if/DaE9l/IlZiulowB5x+XF9sO4MO/AfS2NZ8yERERERER0UqRQ01GVNuNeOhoBSRJQudYAK91T6arNbngWkSoadAdxk9PD+Knpwexr8yCn/3hDWsweyLabkZGRuB2u2esKywsRF7e0i7WJiIioplUlnsHDgABAABJREFUogrvrX8v7qm6B1879zU8dukxSJBmjPlB2w/wytAr+Nsb/xa783cv6rhT7V6dTicAIDc3FzU1NSs+f1oehphowzmouIwSxSKCQqH0MrraM7qKUgeo9YDKAKgWe98AqPTpdelFbQC0ZkBjArQmOSRFRHQlUQHsuA3h/IN4tO/LaEy04mZjLxTuruzjNUYGmIiIiIiIiGjLEQQBNQVG1BRMh5ouT4WauiZxomfhUNORKrZiJ6KVF41G0dU181ydRqPBjh071mlGREREW49ZY8bnD38e9+24D391/K9wyXVpxvZeXy8eevYhfHTPR/EHe/4AClGx4DGrqqrg9/tRUlKC/Px8tn/dQBhiIlqqRFheMLmyx1WopwNNV95mW6c1yWEFjXl6nc4iB6aIaEsKC3q8rjqMgx/4Dkzu88DpR4GLTwLJ6PSgAx+Y+wCpFCvJERERERER0ZYgCAJqC4yoLTDi/UcrkEpNh5qmFncoPmMfhpiIaKXN1UaupqYGSiW/fiMiIlppjXmN+M+7/xM/uPgDfPXcVxG94juypJTE15u/jlOjp/B3N/0d7Hr7vMdSKBTYt28fw0sbEN9FEW0UyRgQmpCX5VLpAZ0N0FvTt7Z5bq3yrcbMYAPRZiIIQMUN8vKWvwdafgyc+g7gHQR2vyP7PpIEfOfNgK0KOPghoOSgfBwiIiIiIiKiLUAUBdQVGlFXaMTD18uhpo4xP17rklvPne5342C5db2nSURbUG5uLrxebybIVFBQgNxchiaJiIhWi1JU4gONH8AbSt+AL7z8BZyfPD9j++sjr+OdT78Tf3vj3+KG4vnbSTPAtDExxEQbTuToZ4ASOyAlgVQSkFLyfUlK/5xel7kvzRyXumJ7Kg4kokAyLlcrufJ+cmpbbHpJxNLb5i8/vWHFQ/LiG1z8PoJiOtA0FXDS2wBDPmCwAznpZeq+zsrwA9FGobcBRz4OHP4Y4O6RK7RlM3QaGDghL83/CRTuAa77ELD7nXJrSyIiIiIiIqItRBQF7Cw0YWehCR+4oRKSJPELCiJacYIgwOFwwGazoaOjA4FAgG3kiIiI1kiVuQrfv+v7+GbrN/Fvzf+GpDRdGdEVceHjv/k4/njfH+PDuz/MzwKbDENMtOHEGx8E6uvXdxKSlA47XRFwiofTSzooFAsB8aC8bup+LHTV9nnGRgNyyGq9ScmlVYASVelQU/5VAacCICd/5n2thYEnorUgCHKVpbm8/s2ZP4+0AE9/CvjVnwN7f08ONOXXre4ciYiIiIiIiNYJv7QgotWk1Wqxe/duRKNRqFSq9Z4OERHRtqEUlfjY3o/hSNER/P/s3Xd4FNXbxvHvpvdOCyX0Ir0qAlLkBUWwIEVFmooFEAtiwYa9ICpKUSyAKKhg+aGIFKUXIUCQ3lsCJEBCet99/xizsKQAIdlNuT/XdS52zpyZeWZZwmTnmeeMWz2O08mnressWPhk2yfsid3Dmx3exMvV64r3m5mZSXR0NFWrVtXvEg6gJCaRvJhM4OJmtOJisUBWGqQlQPp/LS2vPxMhPT6Pvv9eZ6UWX4x5MWdCQpTRLsfZ7UIFJ98q4Fflvz9Dbf/08Cv+uEXKq8xU2Lso73XpCbDpc6PV7ARtHoCGvYv3Z5+IiIiIiIiIiEgZYzKZ8PDwcHQYIiIi5VKLii1Y0GcBL617iZUnVtqsW3ZsGUcTjjKl2xRCfUIvu6+zZ89y4MABMjIycHNzo2LFisUTtORLSUwijmIygaun0XwrFX4/WRlGIkJqHKTEQmpsPn9esj47vejOJT/ZGcbUdpeb3s7N56Ikp9ALf/pXu9A0jZ1I4bh6wuNbYdsc2DITzh/Pe9zRNUbzqQSthhgJTX6Xv5gTERERERERERERERERcSR/d38+6foJM3fN5OMtH2PBYl13IO4Ag/4YxNSbp3Jd8HX57uPgwYNERV0o5HHo0CGCgoJwcVFajT3p3RYp7VzcwCUEvEOufBuLxZjmLr9kp+SzkBwDSWf++zMa0uKL7xwykuDcAaPlx9Ub/KtelNhU3TbJya8quLgXX4wipZlPBej0NHR4Ag7+ZUwvd2ApXHQBZ5UUDasnwpoPoVEf6DAGqra2e8giIiIiIiIiIiIlTU5VBhERESl5TCYTDzR5gPqB9Xl29bMkZiRa151NPcuwP4fxQecPuKnaTXlu7+/vb5PElJGRwdGjR6lbt26xxy4XKIlJpDwymcDN22gB1a9sm6x0SD5jJDhcnNyU9F9f8hlIijFaejEkPGUmw9n9RsuPTyUjuSkwDALCLvwZUMPo1xRZUt45OUP9HkaLOwpbZsHWOZByNvdYSzbs/hVqdlQSk4iIiIiIiIiUa8eOHeOTTz5h0aJFnDhxAnd3d+rUqcOAAQMYNWoUXl5ehd73rFmzGD58+BWNnTlzJsOGDSv0seTaJCUlsXXrVkJDQ6lZs6aqMoiIiJRQHat25Pvbvufxvx/ncPxha39qViqP//04r7Z/lb71+ubaLiQkhKCgIGJjY619UVFRVKpUCV9fX7vELkpiEpEr5eJ+oerR5WSmXUhqSo6BxNOQeAoSTv735ylIPGlUfSpKSdFGiwrPvc7kZExRd3FiU87roFrgUxmcnIo2HpGSLLAmdJ8AXV6A3Qsh/Cs4vsF2jJsvNL/HEdGJiIiIiIiIiJQIv/32G/fffz8JCQnWvpSUFMLDwwkPD+fLL79k0aJFekK/jLNYLBw4cACLxUJUVBRnzpyhbt26VKhQwdGhiYiISB5q+NVgTq85PLXiKTad3mTtN1vMvLr+VRIzEhnaeKjNNiaTibp16xIeHo7ZbLb2HzhwgJYtW2IymewWf3mmJCYRKXquHkaFp8tVecpMvSip6eIkp5OQEAXxUcZyXlNeXS2LGRIijXZsXe71Lp5GUkdQbdx9qtIi6zjnTYGY4o+Dd0Nw1o9LKaNc3KFZf6NF7zKmmtv+vTHlZMtB4J5PZvnZA8a/01qdjepuIiIiIiIiIiJlzLZt2xg4cCCpqan4+Pjwwgsv0LVrV1JTU/n+++/54osv2L9/P7fddhvh4eHX/IT+kiVLCA0NzXd9tWpX8ICpFIvo6GibRLaMjAySkpKUxCQiIlKC+bn58Vn3z3hl/Sv8fvh3m3UfhH9AUmYSI5uPtElO8vT0pEaNGhw9etTal5iYyKlTpwq8TpOio7vyIuI4rp4QVNto+cnONJKa4iONlhB54XV8JJw/ARfNZ1poWalwZg+c2YM70DOn/6t54ORqVG0KrHUh3uA6RgsIM6boEikLKjWG3h/Bza9CxHdQ/5b8x679GCK+hQoNod0IaHYPuPvYLVQRERERERERkeL2xBNPkJqaiouLC0uXLqV9+/bWdd26daNevXo8++yz7N+/n0mTJjFhwoRrOl79+vWpWbPmtQUtRS4zM5NDhw7Z9Hl4eFCjRg0HRSQiIiJXytXZlbc7vk1l78p8ueNLm3Wfbf+MlMwUnmnzjE0iU/Xq1YmOjiY1NdXad/jwYUJCQnBzc7Nb7OWVkphEpGRzzkkgCst/TFr8hYSm88cg7pjtn+kJ+W97JcyZcO6g0XLF5/ZfUlPdCy2kHgTXA68gVaiR0skzANqPyn998jnYMd94fWYvLBoLy1+DVkOMhKbAmvaIUkRERERERESk2GzatIk1a9YA8OCDD9okMOUYO3YsM2fOZM+ePUyePJkXX3wRV1dXe4cqxezw4cNkZWXZ9NWtWxdnZz3cKiIiUhqYTCaeaPUEvm6+fLTlI5t13+z+BieTE0+3ftqayOTk5ES9evX4999/reOys7M5dOgQjRo1smvs5ZGSmESk9PPwN1qlxnmvT427JLHpuG2SU1Za4Y+dnWEkcZzZm0dcARcSmoLrQEh9o2pNUC0jOUuktNo6G7LTbfvSE2DDFNg4DRreBjeMhBrtlcgnIiIiIiIiIqXSr7/+an09fPjwPMc4OTkxZMgQXnjhBc6fP8+KFSvo0aOHnSIUe0hISOD06dM2fSEhIQQHBzsoIhERESmsB5o8gI+rD29ufBMLFmv/rF2zcDI58WSrJ62JTIGBgVSsWJGYmBjruJiYGKpUqUJAQIC9Qy9XlMQkImWfZ6DRQlvkXmc2Q9JpiD0MsUcg9jCZMfs5d2AzgZY43Mko/HHTzkPkZqNdzMnVSG6q0MBIasppQbXBRSUIpRTwr24k5Z3dn3udxQx7fjNalRZGMlPju/TZFhEREREREZFSZe3atQB4e3vTunXrfMd17tzZ+nrdunVKYipDLBYLBw/aVud3dnambt26DopIRERErtWABgPwdPHkpXUvYbaYrf1f7/waVydXRrccbe2rU6cO586dIzs729p36NAhWrVqZTP9nBQtJTGJSPnm5AR+oUar2RGA1IQEZk+fDhYLI4cNxDfzjDXBydrOHTCmsSsMcybE7DaaTSwuxnR0lyY3BdcBF/drPFGRItSsPzTtB4dXwKYvYN9iuChj3epUBPzyMCx7GdqOgDbDwTvE3tGKiIiIiIiIiFy1PXv2AMa0YS4u+d9KadiwYa5tCmv48OHs27ePs2fP4ufnR926denevTuPPfYYVatWLfR+IyMjC1x/6tQp6+vExEQSEhIKfayrkZSUlOfrkiI2NpbExESbvkqVKpGenk56eno+W4mjlfTPlZQ++kxJUdNnyvE6V+jMi61e5M0tthWZPv/3c9wt7gysO9DaV6VKFZtrqaSkJI4ePVriqjI66nN16bVSUVASk4hIfkwmLF7B4FcLqrezXWexQMo5OHsAzh00kprOHjRexx42EpWuljnroqnp/ndRHM5GlaaKDW2Tm0LqKblJHMdkgjrdjBZ7BDbNgK1zICOPi5WkaFjxJqz5AFoNhV7v2z9eEREREREREZErlJaWxtmzZwGoVq1agWMDAwPx9vYmOTmZEydOXNNxV65caX197tw5zp07xz///MOkSZP4+OOPeeSRRwq13+rVq1/x2Dlz5uDv71+o41yLOXPm2P2YBXFycqJ58+a4u1/4/jU1NZVffvkFiyWPh/mkRCppnysp/fSZkqKmz5Rj3eB5Axv8NsBFRZU+2fEJ4WvCqZ1W29rXrFkzvLy8rMsHDx5kwYIFmM1mSiJ7fq7i4wtZ9KMASmISESkMk8moKOMdAmHtbddlZ0H88f+Smv5Lcjp7AM7sg+SYvPdXEEv2f/s5YEzRlcPJxZjSq1JjqNQEKjcx/vSpZMQnYi9BteCWd6DLC7DtW/jnMzh/LPe4rDTI1lNqIiIiIiIiIlKyXfxEuY+Pz2XH5yQxFfap99q1a9O3b1/at29vTTg6fPgwP/30EwsWLCAtLY1HH30Uk8nEww8/XKhjyNWpUqWKTQITwPHjx5XAJCIiUobUSa2DGTP/+P9j07/BfwNuFjeqpRvJ7MeOHaNRo0bW9W5ubgQFBVmT3qVoKYlJRKSoObsYlZOCagM9bNelxBrJTGf2/PfnXojZC0mnr/445qwL09LtmH+h3yvkQkJTTnJTSANwcbum0xK5LA8/aD8Srn/EmGJu43Q4ttZ2zPWPOSY2EREREREREZErlJaWZn3t5nb579Rykl1SU1Ov+lh33XUXQ4cOxXTJQ4lt27Zl4MCB/P777/Tt25fMzEyeeuopbr/9dipXrnxVx7hchahTp07Rrp1RiX7w4MHXNHXd1UhKSrJWChg8ePAVJYzZQ0ZGBnv27LGpruDj48PAgQNz/T1JyVNSP1dSeukzJUVNn6mSZ86+OXy2+zPrssVkYWPIRqbdNI0GAQ0AOHToEAkJCXh4eFC1alVatmzpqHDz5KjPVVRUFO+8806R7lNJTCIi9uQVZFRuurR6U2ocnNl/YTq5M3uNJKeEqKs/RspZOLzSaDmcXIxEpspNLqrc1BR8Kl7L2YjkzckZGvU22skIozLTjgVQ6yZjWsS8pCfBps+h9XDj34mIiIiIiIiIiIN4eHhYX2dkZFx2fHq6UXna09Pzqo91uanbevfuzSuvvMLLL79MSkoKX331FS+++OJVHeNyU+JdzNfXFz8/v6vaf1Hw8fFxyHHzsnfv3lzTwzRo0EA3mUuhkvS5krJBnykpavpMlQwj24wklVRm755t7UvLTuO5jc8x97a5VPauTP369YmPj6dKlSolPqnZnp+rhISEIt+nkphEREoCz0Cocb3RLpYWn3dyU3zBT0/lYs6CmF1Gu5h3hf8qNjWGKi0gtAUE1QEnp2s5G5ELQlvAXZ9B99cgvYALmW3fwl+vw6qJ0PJ+o6JTUO38x4uIiIiIiIiIFBNfX1/r6yuZIi45ORm4sqnnCuPhhx/mlVdewWKxsGrVqqtOYpIrl5iYSHR0tE1flSpVlMAkIiJShplMJsa2GUtcehwLDy209p9JPcOov0bxza3f4O3tjbe3twOjLD+UxCQiUpJ5+EP1tka7WFqCMY3c6R0QvQuid0L0bshMvrr9J5+BwyuMlsPNF6o0u5DUVKUFBNdVYpNcG99KRstLdhZsnGq8zkqFzV9A+FfQqA/cOAaqtbFfnCIiIiIiIiJS7nl4eBAcHMy5c+eIjIwscGxcXJw1ial69erFEk/FihUJDg7m7NmzREUVonK7XDE3NzcqVqxITEwMAM7OztSsWdOxQYmIiEixM5lMTGg/gVPJp9h8erO1f3/cfp5b/RyfdPsEJ5PuldqDkphEREojDz+ocYPRcpjNEHfESGg6vfO/5KYdcP741e07IxGOrTNaDjcfqNzsQlJTaIv/Epuci+BkpNzb87/cn1OLGXb/z2g12sONj0P9W5VMJyIiIiIiIiJ2cd1117FmzRoOHjxIVlYWLi55307Zu3ev9XWjRo2KLZ6SPm1JWeHu7k6jRo2oWrUqBw8epEKFCri5uTk6LBEREbEDV2dXPuryEff/cT9HE45a+1dFrmL69umMajHKccGVI0piEhEpK5ycILiO0a6740J/WrxRpSl654XKTTG7ITPlyvedkQTH1xsth5sPVG76X1JTSyU2SeFVbAzNBsLOn4ypDy91fIPRgutC+9HQ/B5w9bR/nCIiIiIiIiJSbnTs2JE1a9aQnJzMli1buP766/Mct2rVKuvrDh06FEssZ86c4ezZswCEhoYWyzHElp+fHy1btnR0GCIiImJn/u7+TLt5GoP+GERcepy1/7Ptn9EwsCE3h91sM95isXD+/HkCAgKUdF5ElMQkIlLWefhDWHuj5TBnQ+x/VZuid8Kpf+FUBCRF57ubXDKSLiSX5HD1vjAVXbU2ULU1BNYE/actBanYEPrOgJtfgY3TYctsoyLYpc4dhN+fhL/fhHYPQ9uHwDvY7uGKiIiIiIiISNl355138s477wAwc+bMPJOYzGYz33zzDQABAQF07dq1WGKZMWMGFosFgM6dOxfLMSQ33YgUEREpn6r7VWdSl0mMWDqCbEu2tX/82vHM9Z9LnYA6AMTHx3PkyBHi4+OpX78+VapUcVTIZYrmZBERKY+cnCGkLjS+E7q9BIN+hGf2w9N74d7vofPzUP8W8Kl8dfvNTDaSmv6ZDj89CJ+0gIl1Ye5AWDURDv1tVIYSyYt/Nej5Fjy9C/7vDfDN58nClLOw8m34qDH8/jRkpds3ThEREREREREp89q1a0enTp0A+Oqrr9iwYUOuMZMmTWLPnj0APPHEE7i6utqsX7lyJSaTCZPJxLBhw3Jtf/ToUbZt21ZgHL///juvv/46AJ6engwfPrwwpyMiIiIiV6Ft5baMazvOpi8lK4WnVz5NSmYKhw8fJiIigvh4477nsWPHMJvNjgi1zFElJhERucCvitEa3HqhL/E0nIwwKjXl/Jl46sr3mXIW9v9ptBwhDS5UaqrWxphOzFn/Jcl/PPyhwxi4/lHY9TOs/9SoGHaprFQ4/S84u9k/RhEREREREREp8yZPnkyHDh1ITU2lR48ejB8/nq5du5Kamsr333/PjBkzAKhfvz5jx4696v0fPXqUrl270r59e/r06UPz5s2pWLEiAIcPH2bBggUsWLDAWoXpgw8+oGrVqkV3giIiIiKSr/sa3sfuc7tZeGihte9w/GHe+uctxl43lhMnTlj709PTiYqKonr16o4ItUzRHWMRESmYb2VocIvRciRG2yY1nYyAxJNXvs+z+4wW8Z2x7Or13xR0raFqG6jWFvz1hUy55+IGze+BZgPh8AojmenQ37Zjbnxc0xWKiIiIiIiISLFo2bIlP/zwA/fffz8JCQmMHz8+15j69euzaNEifH19C32cDRs25FnpKYeXlxcfffQRDz/8cKGPIXnLzs5m+/bthIaGUqlSJU0hJyIiIlYmk4mXb3iZ/XH72Ru719q/8NBC2lZqS62AWpw/f97af/z4capUqYKLi9JwroXePRERuXq+lcC3J9TveaEvKeZCUlPUFogMN6owXYnMFDi+3mjWY1S5UKmpWjuo2gpcPYvyLKS0MJmgTjejnd4B66fAzgXG9HMNe+e9jcUCB/+COl2N6RNFRERERERERAqhT58+/Pvvv0yePJlFixYRGRmJm5sbdevWpX///owePRovL69C7bt169Z8++23bNiwgfDwcE6dOsXZs2fJysoiMDCQxo0bc/PNN/PQQw9ZKzRJ0YqKiiIxMZF9+/Zx4sQJatWqRXBwsJKZREREBAAPFw8+6PwBA38fSHJmsrX/rX/e4puu38D5C2OzsrKIjIykZs2ado+zLFESk4iIFA2filC/h9HASCKJO3ohoSkqHE5th+yMK9tf4inY+7vRAJxcIbQFVL8eatwA1W8AnwrFcSZSklVuCn0/h5tfgfgT+ScoHVsH390NgbWgwxPQ4j5wcbdvrCIiIiIiIiJSJoSFhfHhhx/y4YcfXtV2Xbp0sU4FlxdfX18GDRrEoEGDrjVEKYTMzEyOHz9uXU5JSeHkyZOEhIQ4MCoREREpacL8wpjQfgLjVo+z9qVlp/Hq1ld5uebLxMbGWvtPnDhBaGgobm5ujgi1TFASk4iIFA+TCYJqGa1pP6MvKx1O7zQSmnISm2IPX9n+zJkQudloG6YYfUF1oEZ7qHG9kdQUUk9Ti5UX/lULnnJwzX9fKsYdgd+fhJXvQvtR0GY4uBe+vLuIiIiIiIiIiJQNUVFRZGdn2/TVqlXLQdGIiEhJlH36NBlbtpB9+jSWjAxMbm44V66MW+vWOFeu7OjwxI5uqXULm09v5sf9P1r79sTuYX3l9TSkobXPbDYTGRlJ7dq1HRFmmaAkJhERsR8Xd6jW2mjXP2L0JZ8zqjVdnNiUFn9l+4s9ZLSIb41lr2DbSk2hLVR9pzw6GQGH/rLtSzoNy16GNZOg3cPG589bT9WJiIiIiIiIiJRHOdO9XKxChQr4+urhNxERgayoKNKWLCH7xIlc67IjI8kID8e5enU8evbEpWoBD1xLmTKu7Ti2RG/hUPwha9/U3VOZ3mw6WQlZ1r6oqCiqV6+Oq6urI8Is9ZTEJCIijuUdbDsNndlsJCblJDSd2ATRO8Fivvy+Us7Bvj+MBuDsDlVb/ZfY1B6qtwOvoOI7FykZsjOgSnNj+sJLpZ2H1e/D+k+h9VBoPxoCqts9RBERERERERERcZy8qjCFhYU5KBoRESlJMvfvJ2X+fMjKKnBc9okTJM+ahVf//rjWr2+n6MSRPFw8eKfTO9z3x31kmY3PhwULU45O4dGgR63jcqoxqcJj4SiJSUREShYnJ2NauJB60OJeoy890UhqOvEPHN9gvM5Iuvy+stON8cc3wLqPjb6QBhB2I9TsCGEdwK9KsZ2KOEj1dvDwKji8wphW7uia3GOyUuGfz2Dzl9BsIHR4Aio0sH+sIiIiIiIiIiJiV3lVYQoJCcHb29tBEYmISEmRFRV1RQlMFzbIImX+fLyHDVNFpnKiUXAjRrcYzcdbP7b27UzYyZkKZ6iQXcHaFxUVRbVq1VSNqRCUxCQiIiWfuy/U6Wo0gOwsozpTTlLT8Y2QeOrK9nV2n9G2zDSWg+oYCU05zS+0eM5B7MtkgjrdjBYZbiQz7VuUe5w5CyK+g4i50PA26PQ0VG1t/3hFRERERERERMQuTp48SdYlN6dVhUlERADSliy58gSmHFlZpC1Zgs8DDxRPUFLiDGs8jNWRq9kas9Xa9/nxz3mp6kvW5ezsbKKioqhZs6YDIizdlMQkIiKlj7MLhLYw2vWPgMUC54//l9S00WgxuwHL5fcVe8hoW2cby0G1jQpNNTtBzQ7gX60YT0TsolobuHcuxOw1KnL9+yNYsi8ZZIG9v8OxdfD0HnD1dESkIiIiIiIiIiJSjLKzs3NVYQoODsbHx8dBEYmISEmRffo02SdOFG7bEyfIPn0a58qVizgqKYmcnZx5vcPr3L3wbtKz0wE4nXmafRn7aOB2YdaPnGpMLi5Ky7kaTo4OQERE5JqZTBAYBs0GQO8PYeR6eO4oDFoAnZ6BsI7gcoVJKbGHYdsc+OVh+KgxTG4Ov46CiHlGopSUXhUbwl2fwRMR0O5hcPHIPabdI0pgEhEREREREREpo06ePElmZqZNn6owiYgIQMaWLde0ferKlViyL32AWsqqML8wRrYYadP305mfbJazsrI4efKkPcMqE5TyJSIiZZNnANT7P6MBZGXA6X/h2Hqj2s6x9ZCecPn9xB01WsS3xnJADSMpqmZHo1JTQJiRRCWlR0AN6DURbnoW/vkMNn0B6fHg6m1U9hIRERERERERkTInrypMQUFB+Pr6OigiEREpSbJPn76m7VPXriXy7Xdwq1UL93r18GzWDM/WrfBo0ACTKvGUSUOuG8KfR/5kT+weAE5mnmR7ynaaezUHwNnZGZPuIV41/WsREZHywcXNmFasWhvoMAbM2XB6Bxxda7Tj6yEt/vL7OX8czs+F7XONZf/qUOsmqN0FanUG30rFehpShHwqwM0vQ4cnIPxrMGeCV1DeYxOjYd5AaD8aGt8FTs72jVVERERERERERK7J6dOnycjIsOmrUaOGg6IREZGSxnLJ/xFXy+TqiiUjg/R9+0jft4+E338HwMnLC88WLfC+qRO+3bpBQEARRCslgYuTC693eJ17fr+HbItRhWvx+cU08GxA/Zr1qV6tuqaSKwS9YyIiUj45OUNoC6PdONpIaoreCUfXGUlNx9ZB2vnL7yf+BER8ZzSACo2gdmcjqSmsA3j4Fd85SNHw8IOOTxY8ZsOncHIb/PQgrHwHOo2Fpv3B2dUuIYqIiIiIiIiISOFZLJZcVZgCAgLw9/d3UEQiIlLSmNzcrml7yyXTleYwp6SQvH49yevXE/Pue7jUqkkjH19O1K1zTceTkqFhUEOGNR7GVzu/AiAyI5IXjr/AK9VeoZZLLQdHVzopiUlERASMpKYqzY3WfiSYzRCz67+kpjVGUlNq3OX3c2aP0f75DEzOULW1kdBUuzNUawsu7sV+KlLEks/B5q8vLJ87CL8+BivfhU5PQ/P7jEpfIiIiIiIiIiJSIp07d460tDSbPlVhEhGRizlXrkz2JQmvVyMz7vwVjcs6cpR6QL0dO4jZf4Dsfnfj16sXzkqsLbUebf4oy48v51jCMQAyLZl8vOVjutfojo+bj4OjK32UxCQiIpIXJyeo3NRoNzxqJDWd2XNh+rlj6yDlXMH7sGRD5CajrX4fXL2gRvv/kpq6QKUmxnGkZNs+DzKTc/efPwa/PQGrJhqVnFoOBlcPu4cnIiIiIiIiIiIFCwwMpG7dukRGRpKWloaPjw8Bms5HREQu4ta6NRnh4YXePviVl/GPjyf94EHSdu4idcsWMo4dK3CbzF27OL1rF9HvvU9A37sIGjoUt7CwQscgjuHh4sFzbZ9j5F8jrX3n0s7x+b+fM7bNWAdGVjopiUlERORKODlBpcZGu/6R/5Ka9sKR1XBkFRxZAxmJBe8jMwUO/WU0AK9gqHUT1Ppv+rkglZUskW4YCYFhsOp9OP1v7vUJkfDHM7D6A+jwBLQeBm5edg9TRERERERERETy5uzsTNWqVQkNDeXs2bM4OztjMpkcHZaIiJQgzpUr41y9OtknTlz9ttWr496gAe6Ad7t21v6ss2dJ2bKVpNWrSFq5iuxzeT8cb0lLI27uPOLmfY/Pzd0IGTECz+bNC3sq4gCdqnWic7XOrIpcZe37ds+33F3vbmr613RcYKWQyj+IiIgUhpMTVLrOqNJ07zx47ig8uBy6vgQ1O4HzFUwvlnIOdv0Cvz8Jn7SAj5vBwjGw61dIPV+s4ctVcHKCRn3gkdVw349QtU3e45JOw5IXYHIzWPsxpF8mqU1EREREREREROzKZDJRoUIFgoKCHB2KiIiUQB49e4LLVdaBcXExtstrVUgIfj17EPrWW9Rbs5qa38/D5/5BpHl65r0vi4Wk5X9xdOA9nBg9mvQDB67yDMSRxrUdh4vThc9PljmL9ze/D0BmZiYxMTGOCq1UUSUmERGRouDsAtXbGq3zOMhIgeMb4PBKo53eAVgK3sf5Y7B1ttFMzlCtDdTtjlPl6zFZzFhMyj12KJMJ6veEej3g8ApjGrnj63OPSz4Dy1+FdR9D+1HQ6RljWxERERERERERERERKbFcqlbFq39/UubPh6ysK9jABa/+/XGpWvWyQ01OTni2aIF/7drMc3amQtRJupjNpK1eneexkpb/RdJff+N/++1UeOpJXCtXLswpiR2F+YUx+LrBzNw509q3O3o3qyJW4ZTohNlsxtvbG29vbwdGWfIpiUlERKQ4uHlB3ZuNBpB8Do6uhsOrjKSmuCMFb2/JhhP/wIl/8AEex5MjzrVw3RUMTXqDry5WHcZkgjrdjHZ0Lax6z5hW8FKpcRC1TQlMIiIiIiIiIiIiIiKlhGv9+ngPG0bakiUFTi3nXL06Hj17XlEC06UsTk7EVK9G8GOP4ZmSQuycOZz/4UfMSUmXDLQQ/7//kbhsGSGPP07Q4PsxXW2lKLGrR5o9wm+HfuNs6lmccOKZKs9APJgxAxAZGUmDBg0cHGXJpk+4iIiIPXgHQ+O7jAYQdwyOrDKSmo6sMqr3FMCTVK7L3g1LxhqtUhMjQarOzVDjBnBxt8NJSC41Oxrt+D+w+n04uNx2fedxjolLREREREREREREREQKxaVqVXweeIDs06fJ2LKF7OhoLOnpmNzdca5UCbfWrXEuospIrpUrU2ncOEIeG8n5H37g3BdfkH3+vM0Yc0oKMe+9R/yvv1J5wqt4tWxZJMeWouft6s1TrZ/ixbUvYsbMusR13BJwi3V9dHQ0tWrVws3NzYFRlmxKYhIREXGEwDAIHAKthoDFAjG74dAKOPQ3HFsHWWkFbx+902jrJoOrN9TqZCQ01b0ZguvY5xzkghrXw/0/QdQWWP0B7PsD6v4fhObzi4Q5G9ITwTPArmGKiIiIiIiIiJQXUVFRpKSkEBoaqmlbRESkUJwrV8bzttvscywfb4IffICAgQOI/XomsbNmYU5JsRmTvm8fx+4bRPCDDxAyZgxOSoQpkXrX7s2c3XPYG7uXVYmruNn/ZlxNrgBYLBZOnTpFWFiYg6MsuZwcHYCIiEi5ZzJBpcZw42gY/DM8d9RIiLlhJIRcQUnJzGTY/ycsHgeftoLJzWHRWNj7h5EoI/ZTtTXcOw8eWQM93sh/3K5f4ONmsPJdSIu3X3wiIiIiIiIiIuWAxWIhMjKSkydPEh4eTkREBAkJCY4OS0RE5LKcfXyoMOZx6ixbin+/u3MPsFg49+VXHB0wkPQDB+wfoFyWk8mJMS3HAJCYncjmpM0260+ePInFYnFEaKWCkphERERKGldPqNsdbnkHRm8i8aGN/Ol6K/ucGmBx97v89nFHYfOX8P298F4t+OYO2DANzh0q9tDlP1WaQcVGea8zZ8Oq9yA9Hla+Ax83hVXvQ5q+SBMRERERERERKQqxsbGkpV2odB4fH6+bhSIiUqq4BAcT+uabhM39Dvf69XOtT9+7lyN39yN27lz9H1cCdazakVYVWwGwOnG1zbqMjAzOnTvniLBKBSUxiYiIlHAWv6psd2nJr+53k/jYdnhgCdw0DkJbAaaCNzZnwuGVsOQFo0rTJ63gz/FGX1aGHaKXXHb+DGf3X1hOi4cVb8HkZsZUdKqeJSIiIiIiIiJyTU6ePGmz7O3tjZ/fFTwcKCIiUsJ4tWpFrZ9/ouIzYzG5utqss2RkEP36G5x6YTzmi5J3xfFMJhNPtn4SgMiMSI6kH7FZHxUV5YCoSgclMYmIiJQmTi5Q4wbo9hI8vALGHYK7v4Lm94FPpctvH3sINk41qjO9Xxt+uB+2zoHE6OKPXQzRO/LuT42Dv98wpplb8yGkJ9k3LhERERERERGRMiAtLY3Y2FibvtDQUEymyzwMKCIiUkKZXFwIfughai6Yj3u9ernWx//6K8fuG0SmEmNKlJYVW3JTtZsAWJOwxmbd+fPnSUlJcURYJZ6SmEREREoz72Bo2g/umg5j98Gja6H7BKjZCZxcC942IxH2/AYLR8Ok+vB5Z1jxNkRtAbPZLuGXS//3Ojy2Hhrdnvf61Fj46zWjMtPajyEj2a7hiYiIiIiIiIiUZpdWYXJ2dqZSpSt4+E9ERKSE82jQgJoL5hM0bFiudWm7d3Pk7n6kbNtm/8AkX2NajgFga8pWkrNt7/dces0iBiUxiYiIlBUmE1RuCh2fgmG/w3NHYMAcaHn/lVVpOhUBq96DL7rBpAbw60jY9SukJRR35OVPpcYwcI6RdNawd95jUs7B8ldhcnNY/ylkKCNfRERERERERKQgZrOZ06dP2/RVrlwZZ2dnB0UkIiJStJzc3an0/HNU/WQyTl5eNuuyz5/n+LDhJP71l4Oik0s1CGrArTVvJcuSxfqk9TbrTp8+TXZ2toMiK7mUxCQiIlJWufvCdbfDHVPh6b3w8Ero8gKEtrr8tskxEPEdzB8K79eCWb2NRJqzB4s97HKlclO45zt4ZDU06JX3mOQzsPQlI5kpYq594xMRERERERERKUXOnDlDZmamTV+VKlUcFI2IiEjx8evRg5rzf8StVi2bfkt6OpGPjyHu++8dFJlc6qFmDwGwLnEdZsuFmVCys7OJiYlxVFgllpKYREREygMnJwhtCV2eh4dXwDMH4I5pcN0d4OZb8LbmLDi6xkikmdIaprSFZa/CiU2adq6oVGkO984zEs3q35L3mOQYyEq3a1giIiIiIiIiIqXJpdOyBAQE4O3t7aBoREREipd7nTrUnP8j3jd1sl1hNnN6wmucnT7dMYGJjfqB9elSrQtns86yJ3WPzTpNKZebkphERETKI5+K0HIQDPgGnj0MQxZC+9EQXO/y257dD+s+hq/+DybVh/+Nhn2LITO12MMu80Jbwn0/wIi/oV4P23UBNaDFIMfEJSIiIiIiIiJSwiUnJ5OQkGDTFxoa6qBoRERE7MPZx4fqU6fif3ffXOvOTP6EM1OmOiAquVRONaY1iWts+pOSkkhKSnJESCWWi6MDEBEREQdzcYPanY3W8y2IPQz7l8L+P+HYOsjOyH/b5DOwbY7RXDyhTjdo2MuoJuQdYr9zKGuqtoZB8yEyHFa+AweXw03jjL+rvKTFg5sPODnbN04RERERERERkRIiOjraZtnV1ZXg4GAHRSMiImI/JldXqrz5Jq6VKnN22jSbdWenTAGzmZDHR2MymRwUoTSv0Jx2ldux+fRmYrNiCXIJsq47e/YsPj4+DoyuZFESk4iIiNgKqg03PGq09CQ4vBIOLIH9SyApOv/tslJh3yKjmZyg+vXQ4FZocBuE1LVb+GVKtTZw/09GMlOV5vmP+2McnIyAruOh0e3G9IEiIiIiIiIiIuWExWLJlcRUqVIlnPQdiYiIlBMmk4kKYx7HOSSY6NffsFl3dto0cHKiwuhRDopOAB5q+hCbTm9iU9Imuvh1YWvyVlrUaUFYWJijQytRlMQkIiIi+XP3gUa9jWY2w8mtsHcR7PsDzuzNfzuLGY5vMNqyVyCkPjToBQ1vg6ptlGRztaq1yX9dzB7490fAAvOHQuVm0O1lqPd/oKcqRERERERERKQciI2NJSPDtpp45cqVHRSNiIiI4wTddx8mJydOT3jNpv/slCk4BwYQNGiQgyKTG6rcQJPgJvwV9xdL45eSYckggghuaXiLo0MrUXQHUURERK6Mk5ORTNP9VRj1Dzy+FXq8BWEdjMpLBTm7H9Z9DF/9H0yqD/8bDfsWQ2aqXUIv01a8BVguLJ/+F+b2h697wpHVDgtLRERERERERMReLq3C5Ovri7e3t4OiERERcazAe+6h8muv5eqPfvMtEv780wERCRjVsh5s+iCp5lQyLEby9e5zu9l+ZruDIytZlMRUzI4dO8bYsWNp2LAh3t7eBAUF0bZtWyZOnEhKSso17TslJYWff/6Zxx57jLZt2xIYGGid47l9+/ZMmDCB06dPX3Y/Xbp0wWQyXVETERGxCq4DN46G4X/AMwfhzunQqA+4XuYLouQzsG0OzLsH3q8DPw6FnT9BeqJ94i5LMlIg7lje6078A7P7wOzb4cRm+8YlIiIiIiIiImInFosl1z2MSpUqOTAiERERxwscOIDKE1617bRYODnuWZI3/uOYoIQu1bsQ6h1q0zd3z1wHRVMyaTq5YvTbb79x//33k5CQYO1LSUkhPDyc8PBwvvzySxYtWkTdunWvet///vsvHTp0ICkpKde62NhYNm7cyMaNG/noo4+YMWMGAwcOvKZzERERKZB3MLS4z2iZaXBklTHt3P4/ISk6/+0yk2H3r0ZzdoM63YxEqAa9wCvIXtGXXm5e8PAq2PM/WPG2UfHqUkdWwVeroP4t0PVFqNLM/nGKiIiIiIiIiBQTk8lEo0aNqFOnDjExMcTExFCxYkVHhyUiIuJwgffcQ9a5c5z9dIq1z5KZSeTo0dT88Qfca9d2YHTlk4uTCwMbDuSjLR9Z+5YdW0ZMSgwVvXT9AkpiKjbbtm1j4MCBpKam4uPjwwsvvEDXrl1JTU3l+++/54svvmD//v3cdttthIeH4+vre1X7T0hIsCYwdejQgd69e9OmTRuCg4M5c+YMP//8M1988QUJCQkMGjQIPz8/br311gL32aZNG2bOnFnocxYREQHA1QPq9zSa2QwntxoJTfv+gDN7898uO8NIetr/J5icoWYHaHQ7NOwNflXsF39p4+QEje+Chn1gx4+w8h04fzz3uJz3tvFd0GU8VKhv/1hFRERERERERIqJm5sb1apVo1q1ao4ORUREpMQIGTmSrLNnOT/ve2ufOSmJyJGjqPnjDzj7+TkwuvLp7np3Mz1iOmnZaQBkWbL4cd+PjG452sGRlQxKYiomTzzxBKmpqbi4uLB06VLat29vXdetWzfq1avHs88+y/79+5k0aRITJky4qv07OTkxYMAAXn31Va677rpc63v06MGtt97KXXfdRXZ2No8//jgHDhwocEo4b29vmjRpclVxiIiIFMjJCaq1MVr3V+HcIdi32EhqOr4BsOS9nSUbjqw22h/PQLV2RoWmRn0gqJZdT6HUcHYxKmE16WdM17d6IiSeyj1u1y+w+3/Q/F7o9hL4heYeIyIiIiIiIiIiIiIipZ7JZKLySy+RfS6WxKVLrf0ZR48SNfYZqn82HZOzswMjLH/83f25rfZt/HTgJwA8TB4cPnGYLZYt1KtbD79ynljm5OgAyqJNmzaxZs0aAB588EGbBKYcY8eOpVGjRgBMnjyZzMzMqzrGjTfeyA8//JBnAlOOO+64g759+wJw6NAhtm3bdlXHEBERKXLBdeDG0fDAYnhmP/SZDHW7g5NrwdtFboJlL8MnLeCzjrDqfYjZA5Z8kqDKMxc3aPsgjNkGPd4Cr+DcYyxm+PdHyL666w8RERERERERERERESldTM7OhL73Lh6X5BYkr1lDzIcfOiiq8u2+RvcBcHvg7bxd/W3u8L+DpMQkzpw54+DIHE9JTMXg119/tb4ePnx4nmOcnJwYMmQIAOfPn2fFihXFEkvXrl2trw8dOlQsxxARESkUn4rQehjc/xOMOwh9vzCmjnPxLHi70ztgxVsw7QaY0gaWT4CoLUpoupSrp5Ew9sR26PoSuPvbrm89FALDHBObiIiIiIiIiIiIiIjYjZOnJ9WmTsE52PbB59ivvibxr78cFFX5VT+wPm0rtyXbko2bk5u1PyYmBks5v9+lJKZisHbtWsCYnq1169b5juvcubP19bp164ollvT0dOtrZ5WBExGRksozAJoNgHu+g2cPwYA50HQAuF+mZOa5g7D2I/iiG3zUBP4cDyc2K6HpYu6+0HkcPLkdOo0FV29w8YBOz+S/jd4/ERERERERESnhsrKyyv1NPhERkavhWqUK1T79BFxtZ8c4Of5FMk+edFBU5dd9De9ja/JWm76MjAwSEhIcFFHJ4OLoAMqiPXv2AFC3bl1cXPJ/ixs2bJhrm6K2atUq6+uc6evys3fvXq6//nr27dtHWloaISEhtG7dmrvvvpt7770XV9fLTPVTgMjIyALXnzp1yvo6OTm53P/DFMdKSkrK87WIo5TLz2S1Lkbr9g4ux9fhcmAxLoeW4JQam/82CZGwcSpsnIrZN5TM+reRVa832VVagslkr8hLMGdo+ySmxvfjfGorWXhDXv/fZqbi/WM/MpoMJLPJveBs+/9/ufw8Somlz6OUNPpMSkmiz6OUNPpMSkmSnJzs6BBEpAgcO3aMmJgYKlSoQIUKFfDz88Ok74BEREQK5NWqFZVffJHTEyZY+8zx8UQ9M46wb2ZjKiC/QYpW5+qdecP5DU5mnCTULdTaHxMTg7+/fwFblm36BBaxtLQ0zp49C0C1atUKHBsYGIi3tzfJycmcOHGiyGPZvn07ixYtAqBp06aXTWKKjo4mOjrauhwVFUVUVBQLFy7kvffeY8GCBZfdR36qV69+xWN//vnncv2PUkqWOXPmODoEERvl9zNZC5PlYaq5naB+9j7qm/fhZ0nMd7RT4knct3yB+5YviDf5sc+5IfucG3HSFKqEJqvpefa2y9xI16x/8Yz+l7S/P2CNy03scb4uz/et/H4epSTS51FKGn0mpSTR51FKGn0mxdHi4+MdHYKIXCOLxcKZM2fIyMiw3suoWbMmYWFhjg5NRESkxAsYOIDkfzaSuPhPa1/q1q2c+XQKFZ960nGBlTOuTq7cXud2tkRusUliOnPmDHXr1i23ydmaTq6IJSZeuKHq4+Nz2fHe3t5A0T+Blp6ezkMPPUR2djYAb731Vr5jnZycuPnmm5k0aRLLly9n27ZtrF69mo8//tiatLR79266du3K8ePHizROERGRK2UxOXHCOYy/3How3X0037gPY6NLe2JNgQVu529JoF3WJganz+bR9Kl0zVxOFXOUpkzLg7sljRuy1luXAy1x3J75P4alf02t7EN6z0RERERERESkREhISCA9Pd2mLzg42EHRiIiIlC4mk4kqr7+O6yVFWc7NmEHK1m0Oiqp8uqvuXbmmlMvMzOT8+fOOCagEUCWmIpaWlmZ97ebmdtnx7u7uAKSmphZpHKNHjyY8PByAoUOH0qdPn3zH/vzzzwQEBOTq79SpEyNHjmTEiBHMnj2b6OhonnzySX7++eerjudylaZOnTpFu3btAOjbty/169e/6mOIFJWkpCTrU6GDBw++ooREkeKkz+RlWCwknd2L6/5FuOz/Hee4Q/kOzUloape1CbNvVTLr9yKrfh+yK7dQhSbAdef3eC5Ny9VfyRLNgIwfyKp2A3Gtn+DrpTsAfR7F8fTzUUoafSalJNHnUUoafSalJNm/fz/vvPOOo8MQkWsQExNjs+zl5WV9aFxEREQuz9nXl6ofTuLofYMgK8votFg4NX48tX79BScPD8cGWE7UDqhNaGAox9OPU8O9hrU/JiaGwMCCH+Ivq5TEVMQ8LvrHnJGRcdnxOU8KeHp6FlkM77zzDl9++SUAbdu2ZerUqQWOzyuBKYerqytffvklGzduZN++ffzyyy9ERUVRtWrVq4rpclPrXczb2xs/P7+r2r9IcfHx8dHnUUoUfSbz4X891LkebnkNYnbDrl9g169w7kC+mzglRlmnnMO/Olx3BzS+C6q2Lr8JTTc+DFUawfIJEBWea7VL5EYqRG7kLqf6rHbtrM+jlCj6PEpJo8+klCT6PEpJo8+kOJoSHURKt5yp5C5WoUKFcjvlioiISGF5NmtGhSfGcGbSh9a+jKNHOfPxZCo9/5wDIytf+tbry+qdq22TmM7EUK9ePZycyt/kauXvjIuZr6+v9fWVTBGXnJwMXNnUc1fi888/Z/z48QA0bNiQP/7445p/KXdxceHBBx+0Lq9ateqa9iciIlJsTCao1Bi6vQSjN8Oj6+CmcRBcr+Dt4k/Ahinw5c3wcTNY8iJEbimf06fV6gQPLYeB30FIgzyH1Dfv54H0L/FY8jScL7jaooiIiIiIiIhIUTp//jyZmZk2fRUrVnRQNCIiIqVb8PDheDRrZtMXO3u2ppWzo541e7I7fbdNnznbTFxcnIMiciwlMRUxDw8P67zLkZGRBY6Ni4uzJjFVr179mo89b948Ro4cCUBYWBjLli0jJCTkmvcLcN1111lfR0VFFck+RUREipXJBJWb5JHQVLfg7eKP/5fQ1A0+aQF/vQ7Ru+wScolhMkGj3jByA9wxDfxyV1R0woLbrvnwaSv4czwkn3NAoCIiIiIiIiJS3pw7Z/sdhI+PD15eXg6KRkREpHQzubgQ+s7bmNzcLnRaLJx66SUsVzDzlFw7b1dvrq9+PUfSjtj0X3rNU14oiakY5CT8HDx4kKyc+SPzsHfvXuvrRo0aXdMxFy5cyJAhQzCbzVSpUoW//vrrqqZwuxyVYRURkVLNJqEp/MoTmuKOwppJMP1GmHoDrJoI5w7ZJeQSwckZWg6Cx7dAz3fAMyj3mOwM2DgVfhxs//hEREREREREpFyxWCy5bujlPFguIiIiheNepw4hj4+26cs4fJhzs2c7KKLyp0/tPmxP2W7TF30mGks5nDFESUzFoGPHjoAxVdyWLVvyHXfxtGwdOnQo9PH++usvBgwYQFZWFsHBwSxbtow6deoUen952b37Qvmy0NDQIt23iIiIXRU2oenMHljxplF5aEYXWD8F4stJdUJXD2g/Ep7YTvoNT5KBa+4xHZ+2f1wiIiIiIiIiUq4kJyeTlpZm01dUM1KIiIiUZ8HDh+PRpIlN39lp08k8dcpBEZUvrSu15oT5hE2fOctMYmKigyJyHCUxFYM777zT+nrmzJl5jjGbzXzzzTcABAQE0LVr10Ida/369dxxxx2kp6fj7+/PkiVLaNy4caH2lZ+srCy+/vpr6/JNN91UpPsXERFxmLwSmjo9A0G1C97u5DZY+iJ81Bhm9oLNX0LyWfvE7EgefqTfOJbPPUYS7twGi9N/yUw1O0Hdmx0bm4iIiIiIiIiUeZdWYXJ3d8fb29tB0YiIiJQdJhcXKr/6inHf5D+W1FSi33nXgVGVH85OzrSp3obTmadt+s+eLQf3ni7h4ugAyqJ27drRqVMn1qxZw1dffcXQoUNp3769zZhJkyaxZ88eAJ544glcXW0rGqxcudKa2DR06FBmzZqV6zgRERHcdtttJCcn4+3tzaJFi2jduvVVxbpixQpatmxJQEBAnuszMzMZMWKENdY+ffpQvXr1qzqGiIhIqZCT0JST1HQqAnb+BDt/hoT8Ki5Z4Ng6o/3xLNTuAk37QcPbwMPfjsHbV4rJm7/cetDgvk/wDf8U2jxo84uNjVPbIfU81O5s1xhFRESk9MjIyCApKYnk5GQyMjIwm82ODkmKQVZWFi1atAAgKiqK6OhoxwYkpZqzszMeHh74+fnh7e2NKb/fR0SkzLk0iSkkJEQ/A8ShdC1b9uk6tnxwcnLCzc0Nb29vfHx8cHNzc3RIDuHZtCkBAwZw/ocfrH2JS5eStHYdPh0LP7OUXJlbat7Cgo0LqOxf2doXHRtN7dqXefC+jFESUzGZPHkyHTp0IDU1lR49ejB+/Hi6du1Kamoq33//PTNmzACgfv36jB079qr3f+jQIXr27Mn58+cBePPNN/H392fnzp35blOxYkUqVqxo0zd79mxuv/12br/9drp06UKDBg3w8/MjKSmJLVu2MGPGDOtUchUrVmTy5MlXHauIiEipYzJBaEujdX8dTvwDOxfArl8hJZ+sd0s2HPrLaM7uUO//oMndUP8WcPOya/j2YvGvDnd9VsAACyx+Ho6vh7r/B90nGEliIiIiIoDFYuHs2bPl8qnC8shsNuPv7299nZWV5eCIpDTLysoiPT2d+Ph4PD09qVGjBk5OmnRApKxLT0/PNaVKcHCwg6KR8k7XsuWHrmPLj5ykxOjoaCpUqEBwcHC5TJSt+NSTJC5ZQvZ/eQgAMe+9h3f7XzA5OzsusHKgeYXmfGr+lFMZp9iRsoN/U/+le73utKf95TcuQ5TEVExatmzJDz/8wP33309CQgLjx4/PNaZ+/fosWrQIX1/fq97/mjVriImJsS4/9dRTl93m1VdfZcKECbn6k5KSmDt3LnPnzs1326ZNm/L9999Tq1atq45VRESkVHNygrD2RrvlPTiyyqjOtOc3SI/Pe5vsdNj7u9FcvaFhL2jaH+p0A2fXvLcpi/YtNhKYAA4ug4PLofm90O1F8K/m2NhERETE4U6dOkV8vO31lMlkwllfipZJFosFHx8fAFxdXcvlzQApOtnZ2VgsFgBSU1M5fvw4YWFh+lyJlHGXVmFycXGxJhaI2JuuZcsPXceWDxdfXwKcOXOGjIwMQkNDHRiVYzgHBFDxmbGceulla1/6gQPE/28hAX3vcmBkZZ/JZKJx1ca8tfsta9/io4sZ02pMufrZoySmYtSnTx/+/fdfJk+ezKJFi4iMjMTNzY26devSv39/Ro8ejZeXYyszPPfcc7Ro0YINGzawe/duzpw5Q2xsLO7u7lSqVIk2bdrQr18/7rrrLl14iYiIOLtA3ZuN1vtDIyln509Gsk5mSt7bZCbDjvlG8wqGxndB0wFQvV3+U7CVBdlZsHzCJZ0W2D7XeM9ueBQ6PgWegY6ITkRERBwsLS3N5qZPcHAwfn5+uLu7l6sv5sqT7Oxs6wN5FStW1PdMck3MZjNJSUmcPn2a7OxsUlNTSU5Ott5gFJGy6dKKN0FBQarCJg6ha9nyRdex5YPFYiE9PZ2EhARr0mx8fDzBwcG4u7s7ODr787/rLmLnfEv6vn3WvjOffIJfr1tx8vBwYGRl3y21b2Hm7pnW5aikKHaf203jkMYOjMq+lMRUzMLCwvjwww/58MMPr2q7Ll262GR7XmrYsGEMGzbsGqODRo0a0ahRI5588slr3peIiEi54uIODW8zWkaykci08yc4sAzMmXlvk3IONn9ptMCaRnWmpgOgQn27hm43NzwKK9+FpEvmic9Oh3WTYctsuOkZaDsCXPWLj4iISHly/qKy9BUrVtRUMCJyVZycnPDz8wMgKioKgMTERCUxiZRhFosl1z0TXT+Io+haVqTsMZlMeHh44OHhgbOzszVxLS4ujsqVKzs4OvszOTtT8ZmxnBjxsLUv6/RpYufMIWTECAdGVvY1CmpEmF8YxxKOWftWnFhRrpKYlKIuIiIicq3cvKFpP7h3How7AHdMhdpdwVTApVbcUVg9Eaa2hc9vgvVTIPG03UIuds4u0OYBeHwrdH0R3PK4mZB2Hpa+BFPawPYfwGy2e5giIiLiGCkpF6pYBgQEOC4QESnVfHx8rBUvUlNTHRyNiBQnk8lE8+bN6dChA40bNyY0NJSgoCBHhyXllK5lRcq2i/9dX/zvvbzx7tgRr/Y32PSd+3wG2ZdMpSlFy2Qy0bV6V5u+lSdWOiQWR1ESk4iIiEhR8gyElvfDkF9h7D7o9QFUa1fwNqe2w9IX4cNG8M0dsO07SEuwS7jFzt0HOj8LYyKMiktOeRQCjT8BvzwMM26Cg3/ZPUQRERGxv+zsbABcXFw0HYOIFJqTk5P1Z0jOzxURKdtcXFwICQmhXr16uLhoshFxDF3LipRtzs7OusbESKap+MwzNn3mpCRiv5njoIjKjy7Vu9gs74vbx8mkk44JxgGUxCQiIiJSXHwqQrsR8NAyI4mn60sQXC//8RYzHF4J/xsJH9SD+cNg7x+QlWGngIuRTwW47QMYtQmuuyPvMad3wLd9jUSu88ftG5+IiIiIiIiIiIiICFirfZZ3no0b49frVpu+2G++ITsx0UERlQ/NKzQnwD0AgCCXIDr4dCBiV0SuqXXLKqWpi4iIiNhDUC3oPA5uegZORcC/82HnAkiKznt8Vhrs+sVonoHQ+C5oOgCqXw9OpTgPPbgODPgGIsNh2StwbF3uMae2g7uf/WMTERERERERERERERGrkMceI+GPxdZlc2Iicd9+S8hjjzkwqrLNxcmFm0NvpnFGYyq6VjQ604wptL28vBwbnB2U4jtgIiIiIqWQyQShLeGWt+HpPTD4F2h+H7j55L9NahyEfw0zb4HJzWH5a3Bmn/1iLg7V2sCwRXDvD1Choe26m8aBZ4BDwhIREREREREREREREYN7vXr49uxp03du1myyk5IcFFH5cGP1G3E3udv0nT5z2kHR2JeSmEREREQcxckZ6nSDu6bDMweg39dQ/1ZwKqBYZvxxWPshTG0HM7rCPzMg+Zz9Yi5KJhM0uAUeXQe3fwq+VSCgBrR9KP9tykm5VBERERERERERERGRkiBkpG3VJXN8PHHz5jkomvKhQ7UO7EuzfZj9aPRRxwRjZ0piEhERESkJ3Lygyd1w3/cwdj/cNgmq31DwNie3wuJxMKk+zLsPdi+ErHT7xFuUnF2g1RB4fKtRmcnFPe9xidHwWSfY9auSmURERERERETKAYvFwpYtW9i/fz9nzpwhMzPT0SGJiIiUOx4NGuD7f91t+uK+/Q6L/l8uNt6u3mR5ZNn0WVItmM1mB0VkP0piEhERESlpvIONakQPLoEntkO3lyCkQf7jzVmwbxH8OBg+qA+/PwUnNpW+RB83L6h0Xf7rV74N0Ttg/lD4qodxjiIiIiIiV2nWrFmYTCZMJhNHjx51dDgOt3LlSuv7sXLlSkeHIyJiIzExkaSkJE6dOsXu3btZv349GRkZjg5LROSa2eOa9OjRo9ZjzJo1q1iOUVJNmDDBeu5SNIIffthmOSs6moQ/lzgomvKhVuVaNssuuBAfH++gaOxHSUwiIiIiJVlgTbhpHIz6Bx5ZDe1Hg0+l/MennYfwr+Gr/4NPW8Gq9yHumL2iLT4xe2DrNxeWIzcZ5/jjUIg94ri4RERERERERKTYxMXF2Sx7eXnh5ubmoGhERETKL8+mTfFs3dqmL3bmTCyl7WHqUuSGajdwIv2ETd+R02X/foiSmERERERKA5MJqjSHnm/BU7th0E/QpB+4eOS/TexhWPEWTG4GM3sZSUBppTRLP2IuWPIok7r7V5jSFpa8CCmxdg9LRERERERERIrPpdUGAgMDHRSJiIjkRVVOy5egYUNtltN27yY1PNxB0ZR9YX5hnMi2TWI6G3fWQdHYj5KYREREREobZxeo1x36fQXPHIDbp0BYx4K3ObYOFj5uTDe34AE4sAyyswrepiT5v9eh/2yjMtWlzJmwYQp80hI2TIWsdLuHJyIiIiJSWnXp0gWLxYLFYqFLly6ODkdExMpiseRKYgoICHBMMCIiIoJvt264Vq9u03du9mwHRVP2mUwmvHy8bPpcMlwwm/N44LsMURKTiIiISGnm4QetBsPwRfDEv9D1JQiqk//4rDTY+RN81w8+bGRUMDq9w37xFpbJBI3vhFGboOfb4BGQe0zaeVgyHqa2g12/gsrYioiIiIiIiJRaiYmJuW7S+fn5OSgaERERMTk7EzR4sE1f0oqVZEbHOCiisq9elXqYL5qlwtnkTFx8XAFblH5KYhIREREpKwLDoPM4eHwLPPQXtH0o72SfHMkxRgWjzzoabeNnkHzObuEWios7tB8FY7ZB+9Hg5Jp7TNxRmD8UvuoBJzbZPUQRERERERERuXaXVmHy8vLCzc3NQdGIiIgIgH/fuzB5XVQdKDub+F9+dlxAZVy7qu2Iyoiy6Ttw6oCDorEPJTGJiIiIlDUmE1RrA7dNgmf2w8BvoWHvvBN+cpzeAX8+B5MawA/3w74/S/Z0c15B0PMtGL0Jrrsz7zGRm+Cr/4N1k+0amoiIiEhJtmLFCoYOHUrt2rXx8vLCz8+Ppk2bMm7cOE6ePJnvdhMmTMBkMmEymQBIS0tj4sSJtGrVCl9fX3x9fWnXrh1TpkwhKyv3deScOXMIDQ0lNDSUZcuWXTbORx55BJPJhLu7O3FxeT9lWthzuVJnzpzhpZdeomXLlgQEBODh4UHNmjUZPHgwa9euLXDbmjVrYjKZGDZsGACbN2/m3nvvpXr16nh4eFC9enWGDx/O3r17ryiWgwcP8tRTT9G0aVP8/f3x9PSkdu3aDBs2jPDw8Gs6z5UrV1r/bleuXHlN+xIRKUqXJjH5+/s7KBIRcbRLr0UTEhKYMGECTZs2xcfHh4oVK9KrVy/Wr19vs11MTAwvvfQSjRs3xtvbm+DgYO644w62bdtW4PHMZjPffvstvXr1omrVqoSFhdGkSRNuvvlmpk2bRkZGxmVjjouL4/nnn6dhw4Z4enpSsWJFunfvzvz586/onHPOd8KECQWO69KlCyaTqdDTAu/cuZM333yTnj17Uq1aNdzd3fHx8aFevXoMHTqUjRs35rldzjXk8OHDrX21atWyxn2568tff/2V/v37U6NGDTw8PAgICKBNmza89tpr+V7/XywyMpJRo0ZRu3ZtPDw8CA0N5fbbb2f58uWFeh/kyjn7+OB/Wy+bvvM/zsdSxqc4c5QQzxDOYfvw+dm4sw6Kxj5cHB2AiIiIiBQjF3do1Mdoyedg18+wfR5Ebcl7vDkT9vxmNO+K0HwgtLgfKja0b9xXKqg2DJgNx/+BpS8ZiUsXMzlBvZ6OiU1ERESkBElLS2P48OF8//33udbt3LmTnTt3Mn36dObNm0efPn0K3Fd0dDS33HILERERNv2bN29m8+bNLF26lF9//RUnpwvPT95555089thjpKWl8f3333PLLbfku//MzEwWLFgAQK9evQgMDCy2c8nP0qVL6d+/PwkJCTb9x44d49ixY3z77beMGjWKTz75xOY88/L111/zyCOP2CR3RUZGMmvWLObNm8ecOXPo379/vtt/8MEHjB8/nszMTJv+I0eOcOTIEb755hteeuklXn/99UKcqYhIyWSxWJTEJCJ5OnHiBN27d2f//v3WvuTkZBYvXszSpUuZN28e/fv3599//6VXr15ERV2oYJKSksLChQtZsmQJixcvpmvXrrn2Hxsby+233866dety9a9atYpVq1YxZcoUFi9eTFhYWJ4x7tmzh+7du9sk1qelpfHXX3/x119/MXz4cG666aZrfSuu2cqVK/N8DzIyMjh48CAHDx7km2++4fnnn+edd94pkmPGxcXRr18//v77b5v+9PR0tmzZwpYtW5g2bRr/+9//uOGGG/Lcx5o1a+jdu7fNtfqpU6f47bff+O233y6b+CXXLmDAAM7PX2Bdzjx5kuR16/Hp1NGBUZVdPr4+cFHupHumOxaLxZrYWdaoEpOIiIhIeeEdDO1GwIi/YXQ4dHoG/KrlPz45BtZ/CtOuhxldYfOXkHbebuFelRrXw4NLof8sCKx5ob/V0JKbgCUiIiJiJxaLhX79+lmTfvr06cOcOXNYt24dGzZsYPLkydSoUYPk5GT69et32co+ffv2Zffu3YwZM4Zly5axZcsW5s6dS6NGjQD47bff+OKLL2y28fX1pUePHgD88ssvpKWl5bv/xYsXExsbC8CgQYOK9VzyEhERQZ8+fUhISMDV1ZWnnnqKFStWsGnTJj7//HNq1aoFwNSpU3nhhRcuu69HH32UihUr8umnn/LPP/+watUqnnvuOdzd3UlPT2fQoEH5xjlx4kTGjRtHZmYmzZo1Y/r06Sxfvpzw8HC+++472rdvj8Vi4Y033uCTTz656nMVESmpUlJSclX2UxKTiAD079+fyMhIXnjhBVatWsXmzZv56KOP8PPzIzs7mwcffJAjR47Qu3dvUlNTeeutt1i7di3//PMPr732Gm5ubqSnpzNs2LBcFZWys7Pp3bu3NYGpc+fO/PDDD/z555/MmjWLO+64AzCSlG6++WaSkpJyxZeQkEDPnj2tCUwDBw7kjz/+IDw8nLlz59KmTRtmzpzJtGnTivmdurysrCy8vb0ZMGAAn332GStXrmTr1q38+eefTJo0yZqk9e677zJz5kybbdu2bcuOHTt48803rX1Llixhx44dNq1t27bW9enp6XTv3p2///4bZ2dnBg8ezLx589i4cSNr1qzhrbfeIjg4mJiYGHr16sWxY8dyxXz8+HFrApOTkxOPPvooy5cvZ/PmzXz11VfUq1ePCRMmsGjRomJ61wTAo0kT3P/7/S/H+R9/cFA0ZV+9KvVslt1MbsQmxDoomuJn90pMBw4c4JtvvmHDhg2cPn2a1NRUlixZQt26da1jdu7cyfHjx/H29qZz5872DlFERESk7AupBze/DF3Hw5FVEDHXqL6Ulc/NpJNb4eRWfJ3duZ3a7HBuDuZs+8Z8OSYTNL4LGvQyEq42TjfOLz8JJ8G3irGdiIiIlGjnktILva23uwsers55rotNzsBisRRqv55uzni55f3V2vmUDLLNV77fYB/3QsVwpb788ksWLVqEq6srCxcuzFUF6YYbbmDw4MF06tSJXbt28eSTTxY4XVpOtaWLp6xo1aoVPXv25LrrriM6Oppp06bxyCOP2GzXt29fFi5cSEJCAr///jv9+vXLc/9z584FwM/Pj969exfrueTl4YcfJiMjA2dnZ37//Xdr8hUYN2v69+9Px44d2b17Nx988AFDhgyhcePGee5r+/bthIWFsXHjRipXrmztv+mmm+jZsyc9evQgMzOTkSNHsmmTbVXR3bt38+KLLwLw6quv8uqrr9o8adu6dWvuuecehg4dyrfffsuLL77I4MGDc1WuEhEpjS6twuTu7o6Hh4eDohG5ehazmezz5x0dhl05BwRgukyFyqIQERHBqlWruP766619bdq0oV69evTu3ZvExESuv/56LBYLmzZtok6dOtZx7dq1IyQkhFGjRnH8+HEWLVrEXXfdZV3/2WefsWHDBgCGDBnCrFmzMJvNxMTE0KxZM+6//35eeeUV3n77bQ4dOsQbb7zBe++9ZxPfG2+8wYkTJwB4++23bZLeW7duTb9+/ejduzdLly4tlvfnarRo0YLIyEgCAgJyrevZsyejR4+md+/eLFu2jNdee40hQ4bg7Gz8buXt7U2TJk1skvHr169PzZo18z3e66+/ztatWwkICGD58uW0bt3aZn3Hjh0ZNGgQ7du359SpU4wfP57vvvvOZszYsWOtFZi+/fZb7r33Xuu6Nm3a0L9/fzp16nTNUy5LwUwmE4ED+nP6tQvVYBNXriL7/Hmc8/g8ybVpGdqSxQcXU8m1krXvwMkDBPsHOzCq4mO3JCaz2cyzzz7L5MmTMZvN1i+ITCZTrizXnAxKFxcXjhw5QtWqVe0VpoiIiEj54uQMdboZLfW8Md1cxFyI3JzncFN2Oo3YQ6PsPZi/XAkt7oMWgyCkbp7jHcLFHdqPgnaPgHM+l7tZ6fB1TyOJqcdbUL1t3uNERESkRGj95vJCb/v6HY0Z0r5mnuu6f7iK2OSMPNddzhM31+Op/6uf57r+n23gQEzup7Lzc/Td2woVw5WwWCzWGytjxozJdxq3wMBAJk6cSK9evVi3bh0HDhygXr16eY59/PHHbRKYcgQFBTF8+HDeffddduzYQXx8vE3VjK5duxIYGEhcXBzfffddnklMSUlJLFy4EIC7777b5oZ1cZzLpTZt2sTmzca18IgRI2wSmC7e/4wZM+jYsSNms5lp06YxderUfPc5adIkmwSmHF27dmXEiBFMnz6dzZs3Ex4eTps2bWy2y8zMpE2bNrkSmHI4OTnx6aefMn/+fJKSkliwYAEjRoy4onMVESnJNJWclHbZ589z4MYOjg7DruqtX4dLUFCxH+fJJ5+0SWDKcdtttxEWFsaxY8c4c+YM06dPt0lgyjF8+HDGjh1LWloaa9assUliyrmmq1ChAlOmTMnz+uu1117j559/Zu/evXzxxRe8/vrruLsbDyVkZGTw1VdfAdCsWTOef/75XNu7urry1VdfUbt27VzTBdtbSEhIgevd3NyYOHEiLVq04NixY0RERORKPLpSSUlJ1vf3jTfeyHc/YWFhvPzyy4wcOZL58+czY8YMvL29ATh9+jS//PILAL1797ZJYMrh6+vLjBkz8vyMSNHy692b6HfexZKT65GZScKfSwi8Z6BjAyuDfN18OWM5Q5AliGPpxziUdojr/K7jBvKecrG0s9t0co888ggfffQR2dnZhIaG5vukFRhz3deqVYvs7GwWLFiQ7zgRERERKUKeAdDmAXhoOYzaBB2eAJ/cN1tyOCWdhrUfwpTW8FVP2DIb0hLyHW93+SUwAWyaAeePw4l/4KvuMH8YxB6xW2giIiIi9rJ7924OHToEUOD3cWBUB8qR8wR6Xi6d4u1iOTcjLBYLR47YXl+5urrSp08fwJgy7nwe1Ql++eUXUlNT8zxOcZzLpZYvv5Aw9+CDD+Y7rkOHDtbp8y7e5lKBgYHWaUfy8sADD+R5bDCm5QMjmSuvG2g5AgICaNq0KXB15yoiUpLlVNnIoSQmEclxzz335LuuWbNmgFFEY+DAvBMpPD09rQnuhw8ftvafPHmSPXv2ADBgwAB8fX3z3N7FxYXhw4cDEBcXx9atW63rtmzZQlxcHABDhw7N9xquWrVqeSbLO1p6ejrHjx9n9+7d7Ny5k507d9pUrt2+fXuh971q1SprguqVXstnZmayZcsWa/+KFSvIzjZmB8j5O8hLu3bt8q2UKkXH2dcXn65dbfrif//NQdGUfUk+SYw7Po6PT3/Mb+d/45/YfxwdUrGxSxLTX3/9Zc06HT9+PEePHuXHH38scJv+/ftjsVj4+++/7RGiiIiIiFysQgP4v9fhqV1w33y47k5wdst//ImN8NsY+KA+/PwIHF4FZrPdwr0qKbGweqJt365fYGo7WPoypMXnvZ2IiIhIKXTxNArt27fHZDLl23x8fKxjT58+ne8+GzZsmO+6oIuevk9MTMy1PudJ9/T09DwfXsyZSi40NJSul3whXhzncqmdO3cCxlPnLVq0KHBsztPdBw4cyFVpPkfLli1xcck/ub5Fixa4uRnX2Tt27LD251QQAHjhhRcKPFeTyWR9b67mXEVESqrMzEzS0mynu/fz83NQNCJS0tSvn3c1VMA6LVpISEiBU+zmjLv4ejXnOhC4bBWfi9dfvN3F13Nt2xZc+b1du3YFrreX5ORk3nnnHZo3b463tzdhYWE0btyYpk2b0rRpU1q2bGkde/bs2UIf5+Jr+SpVqhR4bdukSRPr2Iuvb0vj+1vW+fexnf47NXwLmVFRDoqmbGtSqQlZlizrcsSZCJskw7LELklMM2bMAIwKS2+++aZ1rsyC5Pxg2bVrV7HGJiIiIiIFcHaB+j1gwGwYu4/Urm9wypR/dSayUuHf7+Gb2+GT5rDiHYg7ardwr8j54+ARkLs/OwPWfwKftILwryE7K/cYERERkVImJiamUNulpKTku87LyyvfdU5OF75uzHlK+mLt2rUjLCwMgO+++85mXUxMjLUa0T333GOzr5z1hVHQuVwqNjYWMJKxCko+AqxTxFksFusT95eqWLFigftwcXGxJn7lHBvsc64iIiXVpUmwTk5O1qmERESu5Fq0oDEXj7v4evXia7HLXcNdPFXwxdtdzT4qVapU4Hp7OHr0KE2bNmX8+PH8+++/eV6/XyynYmphFMX1bWl7f8sD75tuwumSaonxvy9yUDRlW8uKLW2Wz6ef50hC2ZxdouDfxIvIhg0bMJlMBZZgvlS1atUAPT0kIiIiUmJ4BZHZchjfbEylgjmGQY3Bfe+vkJLPEzjnj8Oqd41WsxO0uA+uuwPcHPzFY2gLGL0ZNn8Jq96HtPO261POwu9PwaYvoOdbUKebI6IUERGRi2x5qXuht/V2z//rr+VPdy70k4uebvk/pDf/0fZkm0vGE5EX34j47bffqFmz5hVtd7mbAoVlMpm45557eO+991i9ejVRUVFUrVoVgB9//JGsLCORPK8p6+x5LgVN32aP/Vx8rq+88gr9+/e/ou10k19EygIfHx8aNmxIYmIiiYmJODk5FdnPZRF7cQ4IoN76dY4Ow66c/6tuVBYUxc+c0vBza/DgwRw5cgSTycTw4cO55557aNSoERUqVMDNzQ2TyYTZbLYWKLmWqi8XX99u3boVV1fXK9ouJ2fgUqXh/S0PnNzc8OvZk/MXzcKVsGgRIY887MCoyqYq3lWo6FWRmJQLCYHbordR27+2A6MqHnZJYsrJrLzSLxYA6w+unC8uRERERKTkOONUkfQuj+F+27twYCls+w4OLAFzPtduR9cY7Y9noend0HIIVG0Fjvpl08Ud2o+C5vfC6g9g0wwwZ9qOidkNc+6Cej2hx5tQIf9S1SIiIlK8gn3ci2W/Qd4FTJd7DQK8ime/hREcHGx9HRAQYDM1g6Pcd999vPfee5jNZubNm8czzzwDXJhKrmHDhrRq1SrXdvY4l5yqSOfOnSMrK6vAakw5D1+aTKZ8pyuJjo4u8HhZWVk21Z9yXHyurq6uJeLvTUTEXtzc3KhUqZK1ikZZnSpFyjaTkxMuF/3fLiXfxddil7uGu7gIx8XbXXxNGB0dXeDUd5c7hslkwmKxYDabCxyXnJxc4Pr87N27l7Vr1wIwfvx43nzzzTzHXVz96FpcfH1boUKFfJOTCnLp+1u9evV8x17u/ZWi49+nt00SU/r+/WQcP45bjRoOjKrsMZlMtKzYkiVHl1j7tsVs4+76dzswquJhl+nkcp4AypnH/UpERkYCtj/4RURERKSEcXaFhrfBvXPh6b3Q822o2Dj/8RmJsGUWfNkNpneAjdMhpWh+ES4UryC45W0Y9Q80uC3vMQeWwPT2sPg5x8YqIiIiUggtW14oOb9uXcmoBtC4cWOaN28OXEhcOnLkCBs2bADyrsIE9jmXnGShjIwMIiIiChy7adMmAOrVq4ebW96JaxEREQU+pLl9+3YyMjJsjg1Qu3Zt/P+blqGk/L2JiDiKqm2IiD1cfC32zz//FDg25zrw0u2aNm1qfb158+YC93G59b6+vgD5TlsMRpLnwYMHC9xPfnbt2mV9PXDgwHzHhYeHF7ifK/0ZXRTX8kX5/krR8WzVCudLcjoSly13UDRl26VTyu0/t79MJnvbJYmpdm2jhNXu3buveJvFixcDxpcaIiIiIlIK+FQwqhs9tg4eXgXtHgbPvJ9IByBmF/z5PExqAPOHw6EVcJkni4pNcB0jEWvIQqjUNPd6cxb88xl8d2XTeIiIiIiUFK1atbI+5TxjxgzS0tIcHJEhJ1Fp27Zt7Nmzx5rMBEalprzY41y6d78wdeHXX3+d77gNGzZYv+u8eJtLxcbG8ttvv+W7/uJjXLwfZ2dnevXqBcDSpUvZs2fP5YMXERERkUILDQ2lUaNGgDHNcVJSUp7jsrOzmTVrFmBUBrq4gmjr1q2t1YLmzJmTb3JBVFQUS5cuLTCeWrVqAQUnES1evJjz588XuJ/8XJxoX1A1p88++6zA/Xh4eFhfp6en5zuue/fueHl5AfDJJ58UKvGia9eu1qntZs+ene+4zZs3s3PnzqvevxSOydkZ35u72fQlLlcSU3FoEtyErn5dGRYyjFeqvsKogFHEJeaf6Fha2SWJqUePHlgsFqZOnXrZkndgJDvNmjULk8lk/WVdREREREoJkwlCW0CviTB2H/SfDXX/D0z5XHpmZ8Cun2HOnfBJc1j5HsRH2jPiC2p3hkdWwe2fgnfF3Os7jbV/TCIiIiLXwMnJifHjxwNw+PBhhgwZUuDNhYSEBKZMmVLscd17773Wp7a/++475s2bB0D79u2tD0Reyh7n0q5dO9q0aQPAF198wV9//ZVrTHx8PI888og1pscee6zAfT799NN5TmexatUqZsyYARg3vNq2bWuz/oUXXsDZ2Rmz2Uy/fv2slevzkp2dzXfffVfgGBEREREp2KhRowBjdqExY8bkOea1116zJrOPGDECd/cLU1+7u7szfPhwwKjIOXHixFzbZ2VlMWLECGs1zvx07twZMKpC5VW56PTp0zz++ONXcFZ5q1evnvV1TlLWpaZPn87//ve/AvdTpUoV6+tDhw7lOy4gIIDRo0cDsH79ep566qkC8waio6P58ssvcx3rjjvuAGDhwoX8eNEUZjmSkpKs1+piP76XPNiRGhFB1lXM0iVXpn5gfXr496CNTxsquhr3Lw5GF64aW0lmlySmMWPG4O3tzaFDh3j00UcLLKG8bNkyevToQVpaGkFBQYwYMcIeIYqIiIhIcXBxh8Z3wv0L4Mmd0PUlCChgLuzzx2Hl2/BRE/j2btj1K2QV/At9kXNyhlZDYMxW6Pg0OP/3RUStm6DBrfaNRURERKQIPProo9x1110AzJ8/n8aNGzNx4kRWrVpFREQEq1evZsaMGdx3332EhoYyYcKEYo+pWrVq1hszU6dOtU5nkd9UcjnscS5ffPEFbm5uZGVl0atXL5555hlWrVpFeHg4X3zxBa1atWLHjh0APPPMMzZTiFyqefPmREVF0bp1a6ZOncrmzZtZu3Yt48eP55ZbbiErKwsXFxemTp2aa9umTZvywQcfAMZDn02aNOHZZ5/lzz//ZNu2bWzYsIF58+YxZswYqlevzv3331/oJ/FFRERExLjWbN++PQAzZ87k5ptv5ueff+bff/9l+fLl9O/fnzfeeAOAOnXq8PLLL+faxyuvvGKtHvrcc89x33338eeff7J161a+//57brzxRhYvXmxNnM/Pww8/jIuLCxaLhT59+vDxxx8THh7O+vXrmThxIi1btiQ+Pt4mGelqtGzZ0nod+/nnnzNw4EB+//13tmzZwv/+9z/69+/PyJEj6dChw2X3k1ON6eWXX2bZsmXs37+fgwcPcvDgQVJTU61jX3/9da6//noAJk+eTKtWrZg6dSrr1q0jIiKCFStWMGXKFO68805q1KiRZxWoSZMmWafau++++xg1ahQrVqxgy5YtzJw5k9atW7Nt27bLvr9StLzat8fJ2/tCh8VC4l9/Oy6gMsrT1ZOz5rM2fTFxMQ6Kpvi42OMglSpV4rPPPmPIkCF89dVXLFmyhNtuu826fvLkyVgsFtatW8fevXuxWCw4OTkxa9YsfHx87BGiiIiIiBQ3/6rQeZxRzejoatg6B/YsNCox5WKBg8uN5hUCze+BloOhYkP7xevuC91fhdbD4K/XoONTRpWpvMQdBVcv8MmjepOIiIiIg5lMJn744QeeeOIJPvvsMw4dOsSzzz6b7/iKFe1zTTNo0CBWrlxpTbxxcXFhwIABBW5jj3Np0aIFv/32G/379ychIYFJkyYxadKkXONGjRrFO++8c9l9jR49mscee8z65PnF3NzcmD17tvVmzqWefPJJvL29efLJJ4mPj2fixIl5PtGfs6+Lp/MQESmNUlNTcXNzs04XJCJiT87Ozvz+++/cfvvtrFu3jr///pu//86diNGoUSMWL16c531sf39//vzzT7p3787p06eZN2+etepojmHDhtG5c2dr1aa8NG7cmPfff5+nn36auLg4nnrqKZv1QUFB/Prrr7z88sscOHDgqs/VZDIxZ84cunXrRlxcHD/++GOuykZNmzZl/vz5hIaG5rsfX19fxowZw/vvv8/WrVvp0aOHzfoVK1bQpUsXwKhUtWzZMoYNG8bPP//M9u3b87xGzuHn55err2bNmixcuJDbb7+dxMREpk2bxrRp02zGvPLKK5hMpgKn4pOi5eTmhk/nm0j4Y7G1L2nVKgLvGejAqMqmbLdsuGg2xszUTMcFU0zsUokJjC8l5s2bh5+fHydOnODzzz+3loz+8ssv+eqrr9izZw8WiwUfHx/mz59vk+gkIiIiImWEkxPU7gL9vjKmm7v1faiU/9PrpJyFDVNg2vXw5f/B1m8gPe856YtFYBj0+xoqN817vcUCC8fAJ61g7UeQmWa/2ERERESukKurK9OmTWP79u08/vjjNG3aFH9/f5ydnfH396dFixY8+OCDLFiwgD179tglpn79+tlMv9GjRw8qVKhw2e3scS49evTg4MGDjB8/nhYtWuDn54e7uzs1atRg0KBBrFmzhilTpuDkdPmvVx966CHWrFnDgAEDCA0Nxc3NjapVqzJkyBC2bdvGPffcU+D2I0aM4PDhw7z22mt06NCBkJAQXFxc8Pb2pn79+tx999189tlnREVFUbdu3UKdr4hISREREcHatWvZtGkTu3btIjk52dEhiUg5ExQUxOrVq/nmm2+45ZZbqFSpEq6urgQGBtK5c2emTJlCREQEYWFh+e6jcePG7Nq1i2effZZ69erh7u5OSEgIXbt2Ze7cucycOfOKYnnqqaf4888/6dmzJ4GBgbi7u1OrVi1GjRrFtm3b6NSp0zWda4sWLYiIiODRRx8lLCwMV1dXgoKCaNeuHR988AGbNm2ymS4uP++++y5ffPEFnTp1IigoqMBEVF9fX3766SfWrFnDQw89RIMGDfD19cXFxYWgoCDatm3LqFGj+OOPP1i2bFme++jSpQu7du3iscceIywsDDc3NypVqsRtt93Gn3/+yWuvvVbo90QKz6drN5vl5H/+wXKZaRPl6gX4Bdgse5o9sVgseQ8upUwWO5/RuXPnmDZtGr/99hsRERE2U8s1btyY22+/nSeeeMJuT3xJyRAZGUn16tUBozx2o0aNHByRlGcJCQlMnz4dgMceeyzPTG8Re9JnUkqSYvs8WixwcpuRoLTzJ0hPKHi8mw80vgtaDYVqbfKvkGQP+xbDvItuPAXUgP97Ha6707FxlQP6+SgljT6TUpKU9M/jgQMHrNNoFXb6AyldsrOziYkxytxXrFixzFfYqFmzJseOHWPo0KHMmjXL0eGUaYX5ebJnzx6uu+46AE6cOGGd8kWkvLr4+3l7/pu49HrF09OT9evX24xp06YN3hdPTyNyGfa4Dta1bPlS3q5jxVCc/85L+u/rhZUVG8uBDh2N7/r/U2PWLLxvyLvqrBTOlsgtJB2yfci7ZduWkIVDPlfFcR1pt0pMOYKDg3n55ZfZtGkTaWlpxMTEcOrUKdLT09mxYwdvvfWWEphEREREyhuTCaq2gj4fG9WZ7vwMatyY//iMJNg2B77qDtNugPVTIPls/uOLS1YGLH3Jtu/8cZg/DGbeClFb7R+TiIiIiIiISCl0adUlk8mEp6eng6IRERGRq+ESFITHfw8K5Ehet9ZB0ZRdDSs2JN2cbtN3IPrqp5QsyeyexGRzcCcnQkJCrGX4RERERERw84IW98IDi2F0OHR4ArwLSHI/sxeWvgiTGsKPQ+DAcjBn2yfWrFSo1i7vdcc3wBdd4ZdHIeGkfeIRERERERERKaUuTWLy8vK6omk7RUREpGTw7tTRZjlp7ToHRVJ2ebt5E2eOs+k7GVu27j/o6k9ERERESq6QesbUbE/vhnvmQv1bwJTPJaw5E3b/D767GyY3h5XvQXxU8cbn4Q93TYcRK6BG+7zHbJ8Hn7Y24slIKd54REREREREREqplBTb35k1jZyIiEjp4tPRNokpfc8ess6ccVA0ZVemS6bNcmpKqoMiKR5KYhIRERGRks/ZFRreBvf9AE/tgm4vQ2Ct/MfHn4CVb8PHTWDuPbBvMWRnFV98VVvB8MXQfzYEhOVen5lixDOlDWz/Aczm4otFREREREREpBRKSkqyWVYSk4iISOni2bw5Tj4+Nn0p4eEOiqbscvd0t1l2znJ2UCTFw6Uod1a7du2i3B1gzHl86NChIt+viIiIiJRSfqFw0zPQ8Wk4tha2zoE9CyErLfdYixn2Lzaabyi0GgwtB0NA9aKPy2SCxnca1aL++QxWfwAZibZjEqLgl4dh0wy45V2o3rbo4xAREREREREpZSwWS67p5JTEJCIiUrqYXF3xbN2K5FWrrX0pmzfjd+utDoyq7An2C4aLii/5mfywWCyOC6iIFWkS09GjR69onMlkAsj1RubVn9MnIiIiImLDyQlq3WS01PdhxwLYOhtO78h7fOJJWPUerHof6naH1sOgfk+jylNRcvWAjk9Ci/tgxVuw9RsjmepiUeHwbV+jqpSHX9EeX0REREQc7kq/JxUREUNmZibZ2dk2fUpiEhERKX282rS5JIlJlZiKWo2QGkRFR1mX3UxunEs658CIilaRJjENHTq0wPURERFs374di8VCQEAALVu2pFKlSgBER0cTERFBXFwcJpOJ5s2b07x586IMT0RERETKKs9AaDfCaCe3wZZZRlJTRlIegy1wcJnRfCpDy0HQaggE1izamHwqQp/J0O5hWDIeDq+0Xd9prBKYRERERERERIC0NNvqys7Ozri7u+czWkREREoqrzZtbJbTDxwgKy4Ol8BAB0VU9tQMqsne7L34Ovta+yLjIh0YUdEq0iSmmTNn5rvu66+/Zu7cuVSrVo1JkyZx11134eJie/js7Gx+/vlnxo0bx+7duxk1ahQPPvhgUYYoIiIiImVdaEuj9XgLdv5kJDSd3Jr32KTTsGYSrPkQ6nSFVkOhQS9wcSu6eCo1hsG/wv4lRjJT7CEIrAU3PFZ0xxAREREREREpxdLT022Wvby8NFOHiIhIKeTZuDEmDw8sFyUop27diu/NNzswqrLFxcmFeEs8vlxIYopNjnVgREXLyR4HCQ8P59FHHyUkJISNGzfSv3//XAlMYGTW9+/fnw0bNhAUFMTIkSMJD1d5MREREREpBHcfaD0UHl4Bj6yBtg+Be36Vjyxw6G+YPxQ+ug6WvQrnDhVdLCYTNLgFRm40kqtufR9c8nmiNCUWTv1bdMcWERERERERKeEuTWLy9PR0UCQiIiJyLUxubni2aGHTpynlip7ZxWyznJqe6qBIip5dkpg++ugjsrOzGT9+PKGhoZcdX6VKFcaPH09mZiYffvihHSIUERERkTKtSjO4bRKM3Qt3TIVq7fIfm3wG1n0Mn7aC2X2Mak5Z6fmPvxoubnDjaKjfI/8xK9+Bz2+C356ApDNFc1wRERERERGREkxJTCIiImWHV+vWNsup/+qh3aLm5OnEusR1/BL7CzNiZrAxZaOjQyoyRTqdXH7WrFkDwPXXX3/F29xwww0ArF27tlhiEhEREZFyyM0bWt5vtOhdsGU2/Ps9pMXnPf7IaqN5BUPze6H1MAipV3zxxeyBzV8BFmMavJ0/Q+fnoN3DRTvFnYiIiIiIiEgJoiQmERGRssOzeTOb5bTdu7FkZWHKY7YuKZyQiiG8u+dd63IlSyVCuXxBodLALpWYzpwxniC/9CK0IDljc7YVERERESlSlRpDr/dh7D6463Oo0T7/sSnnYMMUmNIGZt4G//4ImWn5jy8MiwX+fAEs2Rf60hNg6YswvT3sX2KMERERERERESljlMQkIiJSdng0bWqzbElLI/3gQQdFUzaF+YXZLMekxpBNdj6jSxe7JDFVqFABgMWLF1/xNn/88QcAISEhxRKTiIiIiAgArp7Q/B544E8Y+Q/cMAo8A/Mff2wt/DwCPmxoJB2d2Vc0cVjMULMDuHrlXnfuIMwdAN/1K7rjiYiIiIiIiJQA7u7uufqUxCQiIlJ6uQQG4lq1qk1f6o4dDoqmbKrqY/v+WrCQ7JzsoGiKll2SmLp164bFYuHDDz9k3bp1lx2/fv16PvroI0wmEzfffLMdIhQRERERASo2hFvehqf3wt1fQc1O+Y9NjYON02BqO6M6044FkHXllUdzcXKGm8bB41ug2cC8xxxcDtPaw+LnjeOLiIiIiIiIlHLp6ek0atSIJk2aUKdOHapVq4aLppsREREp1Tya2VZjStux00GRlE2+br74u/vb9CU5JzkomqJllySm559/Hnd3d9LT07n55pt58skniYiIwHLRdBgWi4WIiAieeuopunXrRlpaGm5ubjz//PP2CFFERERE5AJXD2jaD4b9DqPD4cbHwSs4//HH1sJPD8KHjWDZKxB7uPDH9guFvjPgweVQtXXu9ZZs+Gc6fNIKNn8J2VmFP5aIiIiIiIhICeDh4UFwcDDVqlWjTp06mEwmR4ckIiIi18CziW0SkyoxFb1qPtVslpXEdBUaNmzI7NmzcXZ2JiMjg08//ZTWrVvj5eVF1apVqVatGl5eXrRu3ZpPPvmEjIwMXFxcmDlzJg0bNrRHiCIiIiIieQupBz3ehKf3QL+ZULtL/mNTzsG6yfBJS/jmTti9ELIzC3fc6m2NRKY7PwOfyrnXp8bCorHw+U1weFXhjiEiIiIiIiIiIiIiUsQ8mjSxWc44eBBLZiG/K5c8VfO9kMTk6eRJtke2A6MpOnarxzlgwABq1arFyJEj2bJlC2CUCD116lSusa1atWLatGm0a9fOXuGJiIiIiBTMxR2a9DVa7GHYMhu2fQspZ/Mef3iF0XwqQ6vB0GooBFS/umM6OUGLe6FRH1j7IayfAtmXTFkXswu+uQPGbIWg2oU7NxERERERERERERGRIuJev57NsiUzk4zjx3GvU8dBEZU9Td2b0rZqWwKdA3F3cudQ0iHOxJ1xdFjXzK6TCrdt25bNmzcTHh7O8uXL2bFjB7GxsQAEBgbStGlTunfvTtu2be0ZloiIiIjI1QmqDf/3GnQdD3t/h/CZcHRN3mOTTsPqibBmEtTrAa2HQ73/AyfnKz+euw/c/Aq0GgJLX4Y9C23Xt7xfCUwiIiIiIiIiIiIiUiK4BAbiUqECWWcuJNWk79+vJKYiFOQRhF+6n3XZ29WbMyiJqVDatGlDmzZtHHFoEREREZGi4+IOTe422pn9sGUWRHwHaedzj7WYYf+fRvOvblRmajUYfPOYKi4/gTVh4Bw4sgb+fB6id4Kbr5HgJCIiIiIiIiIiIiJSQrjXr2+TxJS2fz9+t97qwIjKliCfILLis6zLfi5+WLA4MKKi4eToAEREREREyoQK9eGWt2HsXrjzM6h+ff5j40/Aijfhw+vgh/vh0N9gNl/5sWp1gkdWQ++PjYpQPhXzHpedCZFbruo0RERERMq6WbNmYTKZMJlMHD161NHhiIiUez4+PmRkZGCxlP6bbiIixU3XslKauNevb7Ocvv+AgyIpmyr72T4g7eXsRbZztoOiKToOqcQkIiIiIlJmuXpCi3uNdnonbJkJ23+AjMTcYy3ZsOc3owXWgtbDjKnhvEMufxwnZ2gzvOAxm7+CP5+Dpv2h+2vgX7VQpyQiIiIiIiJSHNzc3GjSpAm7du0CwN3dnTZt2uDiottXIiIipV3uJKb9DoqkbKrsX5lIIm36LB6lPyncLleBq1evvqbtb7rppiKKRERERETEjio3gdsmGQlEO3+C8K/hVETeY+OOwPJX4e834brboc0DENYBTKbCHTv5HKx823i9Yz7sXQQdnoQbHwc3r8LtU0RERERERKQIubm52SxnZmbi7OzsoGhERESkKLnXrWuznBkVhTkjA6dL/v+XwvF29ybFnIKX04Xv+00ehbyfUILYJYmpS5cumAp588VkMpGVlXX5gSIiIiIiJZW7D7QearSorUZ1ph0LIDMl91hzppHwtPMnCKkPrYdD83vAK+jqjrnybUiLv7CcmWL0bZtjTEHXuG/hE6REREREREREioC7u3uu5cLeTxIREZGSxa1mmG2H2UxmZCTutWs7JqAyKNmSjBcXkpic3Ut/MriTvQ5ksVgK3UREREREyoyqreD2T2HsXuj1AVS8Lv+xZ/fDkhfgw0bwy2NwYhNc6fVxSH1w98/dH38CFjwAs26DU/8W7hxEREREREREisCllZguTWoSERGR0svZ1xfnINuHczOOHXNQNGVTBhk2y5deW5VGdqnEtGLFisuOSU5OZv/+/Xz//fds2rSJDh068Nprr6lsqIiIiIiUTR7+0G4EtH3ISE4K/xp2/QLZ6bnHZqXB9rlGq9QE2gyHpgPAwy///V//CDS525iebutssJht1x9bBzM6Q+th0PUl8A4u0tMTERERERERuRwlMYmIiJRtbmFhpMbGWpeVxFS0zC5muOi5Z3e30n8tZZdKTJ07d75s69WrF08++SQbN27kvffeY926dXz99dd07tzZHiGKiIiIiDiGyQQ1roe+nxvVmXq+DcF18x8fvRMWjYVJDWHhGDgZkf9Y7xDo8zE8shpqdsq93mI2kqc+bQX/zIBsTeMsIiJS1q1YsYKhQ4dSu3ZtvLy88PPzo2nTpowbN46TJ0/mu92ECRMwmUzWKX7S0tKYOHEirVq1wtfXF19fX9q1a8eUKVPIysp9TTFnzhxCQ0MJDQ1l2bJll43zkUcewWQy4e7uTlxcXJGey5U6c+YML730Ei1btiQgIAAPDw9q1qzJ4MGDWbt2bYHb1qxZE5PJxLBhwwDYvHkz9957L9WrV8fDw4Pq1aszfPhw9u7de0WxHDx4kKeeeoqmTZvi7++Pp6cntWvXZtiwYYSHh1/rqQKQmprK22+/TfPmzfH29iY4OJgOHTrwxRdfYDabWblypfUzsHLlyiI5pojIpUlMZaF6gIgUr8JcA17rtez8+fMJDQ3FxcVF17Il9FpWSi63GjVsljOPH3dQJGWTi6tt3SIPVw8HRVJ07Dad3NUYN24cffv2Zd68eXz//feODkdERERExD68gqD9KBgdDkN/h8Z9wck177GZyUaFpRmd4YtuEDEXMlPzHlu5KQz9DQbMgYAaudennYfF4+DzTnB4VZGdjoiIiJQcaWlp3HvvvXTr1o1vvvmGI0eOkJqaSmJiIjt37uSDDz6gfv36/Pbbb5fdV3R0NO3bt+fZZ59l27ZtJCUlkZSUxObNm3n88cfp27cvZrNtFcg777wTDw/jy9TLfd+XmZnJggULAOjVqxeBgYHFdi75Wbp0KXXr1uWtt94iIiKC+Ph40tPTOXbsGN9++y2dOnVi9OjRuc4zL19//TU33ngj33//PZGRkaSnpxMZGcmsWbNo0aIF8+fPL3D7Dz74gOuuu46PP/6YnTt3kpCQQFpaGkeOHGH27Nm0a9eOV155pdDnCnD69Glat27Niy++yL///ktKSgqxsbGsX7+ehx9+mF69epGRkXH5HYmIXCUXF9sbb0piEpH8FNU1YGGuZW+99VbrtezcuXML3L+uZW3Z41pWSja3mmE2yxlHVYmpKHm6edosu7mU/mupEpnEBDBkyBAsFgszZsxwdCgiIiIiIvZlMkGtTtB/Jjy9G25+FQLC8h8ftQV+fcyozrTkRTh3KO99Xnc7jNoEXV8EF8/cY2J2wze3w9F1RXcuIiIi4nAWi4V+/fpZk4f69OnDnDlzWLduHRs2bGDy5MnUqFGD5ORk+vXrd9mnofv27cvu3bsZM2YMy5YtY8uWLcydO5dGjRoB8Ntvv/HFF1/YbOPr60uPHj0A+OWXX0hLS8t3/4sXLyb2v+kGBg0aVKznkpeIiAj69OlDQkICrq6uPPXUU6xYsYJNmzbx+eefU6tWLQCmTp3KCy+8cNl9Pfroo1SsWJFPP/2Uf/75h1WrVvHcc8/h7u5Oeno6gwYNyjfOiRMnMm7cODIzM2nWrBnTp09n+fLlhIeH891339G+fXssFgtvvPEGn3zyyVWfK0BWVha9e/dmz549APTo0YNffvmF8PBwfv75Z7p3786SJUt46aWXCrV/EZGCXJrE5Oqaz4M8IlKuFeU1YGGuZX18fKzXsj///LOuZUvQtayUfK7VL6nEFBXloEjKJh9PH5tlT+c8vvcvZVwuP8QxavxXVmzHjh0OjkRERERExIF8KkKnp6HDk3D4bwifCfsWgyU799i087BhitFqd4W2D0L9W8H5ost+V0/o/Cy0uA+WvQI7f7LdR432EHZjcZ6RiIjI1Us+W/ht3byN///y3O85wFK4/bp6GvvOS0qsMW3rlfIOKVwMV+jLL79k0aJFuLq6snDhQm655Rab9TfccAODBw+mU6dO7Nq1iyeffLLAKSY2b97M0qVL6dKli7WvVatW9OzZk+uuu47o6GimTZvGI488YrNd3759WbhwIQkJCfz+++/069cvz/3nPN3u5+dH7969i/Vc8vLwww+TkZGBs7Mzv//+u/WGFUDbtm3p378/HTt2ZPfu3XzwwQcMGTKExo0b57mv7du3ExYWxsaNG6lcubK1/6abbqJnz5706NGDzMxMRo4cyaZNm2y23b17Ny+++CIAr776Kq+++qp1ChSA1q1bc8899zB06FC+/fZbXnzxRQYPHpzraf/L+fzzz9myZYv13D///HObY9x11108+OCDfP3111e1XxGRK3Fp0pKSmKSsMFvMnE8/7+gw7CrAPQAnU/HUzyjKa0Bdy5ata1kp+VxDq9gsZ0ZHY7FYbD4PUnh+nn6kkGJd9nL2cmA0RaPEJjFFR0cDkJyc7OBIRERERERKACcnqNvdaAknYes3sGU2JJ7Me/zhFUbzDYXWw6DVEPC76BdG/2rQ72to8yAsfg6idwAmuPU9o2qTiIhISTKxTuG37fUBtBuR97qpbSHlXOH22/l56JrPk8szb4Uze698XxPiCxfDFbBYLLz33nsAjBkzJteNkhyBgYFMnDiRXr16sW7dOg4cOEC9evXyHPv444/b3PTJERQUxPDhw3n33XfZsWMH8fHx+Pv7W9d37dqVwMBA4uLi+O677/K88ZOUlMTChQsBuPvuu63TdhTXuVxq06ZNbN68GYARI0bY3PS5eP8zZsygY8eOmM1mpk2bxtSpU/Pd56RJk2xu+uTo2rUrI0aMYPr06WzevJnw8HDatGljs11mZiZt2rTJddMnh5OTE59++inz588nKSmJBQsWMGJEPp/3fEybNu3/2bvv8Ciqto/j302vJAQIvffeOwgiL2hAbHSUIiAiqCD2CpZHFAVFBASRJqIiSJEuvSktoQYp0ntJSEgv+/6xsmSTTSXZTfl9rmuuZ2fmzJl7133C2Zl77gNA8eLFmTRpktU2X3/9NStWrOD69euZ6ltEJC1Go1GVmCTfCo0Jpd0v7ewdhk1t6bUFPze/bO83u8eA9zOWLVKkCDdv3tRYltwzlpXcz7l4cYt1Y3Q0CaGhOClhLVt4u3tbJDF5OnoSm5C3pwLPtdPJ3f1jebcik4iIiIiI/KdQKWj/Jow6BL0WmKoupSb8Emz+H3xVB37tD/9uAWOSihMVWsOwLdBlIrQZBSXrp95XyJnsegciIiJiI0ePHuXUKdNUs6k9LX7XAw88YH69a9euVNslnxYjqcaNGwOmmzSnT5+22Ofs7Myjjz4KmKbZCA0NTXH877//TlRUlNXz5MR7Se7PP/80vx48eHCq7Vq3bm2eciTpMckVLlyYxx57LNX9zz77rNVzg2kqEzDdAEvrKWVfX1/q1q0LZO69Aly+fJmjR48C0LNnTzw8rD+16+XlRc+ePTPVt4hIehITE3FwsLxNpSQmEUkuu8eA9zOWvXt+jWVN7D2WlbzByd8/xUOz8f8VtJH75+vum2Lb7aice1DKFnJVElNISAjr168nICCAP/74A4PBwJNPPmnvsEREREREcidHJ6jZFfovhRf3Q8uR4OZrvW1iPBxdBvO6wZSm8Nc0iAo17XNwNE0913Fs6uc6uQEmN4Q/XjFNkSMiIiJ5wt69e82vW7ZsicFgSHXx8vIyt71y5UqqfdaoUSPVfX5+956+Dw8PT7H/iSeeACAmJobffvstxf6702+UKlWKBx+0TNTOifeS3OHDhwFwcXGhQYMGabZt3rw5ACdOnCA21vqTrg0bNkxRZSSpBg0a4OLiAsChQ4fM28+ePWuuevTWW2+l+V4NBoP5s8nMe01+zqZNm6bZtlmzZpnqW0QkPfHx8Sm2KYlJRJLL7jHg/Yxl+/TpA2gse5e9x7KSNxicnXEqajmFetzly3aKJv8p7FmYVaGrWHRzEbOvz2bKlSncib9j77Dui02SmBwdHTO0FC1alIcffpi1a9cCULVqVd544w1bhCgiIiIikrcVqQydP4Exx+DxaVC6Septb56ANW/ClzVg2Qi4FJh23wlxsOYtMCbC3lmmZKbdMyEh5QVnERERyV2uXbuWpeMiIyNT3ZdatR7AoqJGQkJCiv3NmjWjfPnyACxYsMBi37Vr18xPcPfu3TtFdY6ceC/J3bplStb28/NL84YNYJ5Ww2g0EhISYrWNv79/mn04OTmZb5bdPTfY5r0mP2d6sRZPNg2EiMj9Sp7EZDAYUvztFxHJ7nHR/YxlW7durbFsEvYey0re4ZRsSkJVYso+rk6ubInYwpbwLeyL2Mex6GOEJ6RMwsxL0v7rlU2MSaeryAAnJyd69OjBpEmTLOYaFRERERGRdDi7Q4O+puVSkCnp6NBvEGflIkB8FAT+aFpKNTJVY6r9JLgku5izeybc+OfeenQorHoV9s6GRz6Dim1z8h2JiIjAa6eyfqyLZ+r7RuwBMnfdyszZPfV9g1abkn9zgaQ3X1asWEGFChUydFx6NyyyymAw0Lt3bz777DO2bt3KxYsXKV26NAC//vqr+Ya2tWk+bPle0prywhb9JH2v77//Pj169MjQcZ6eaXzf05Fd71lEJKOSJzE5Ozvrb5HkG76uvmzptcXeYdiUr6tvjvSbm8azBoOBvn378umnn2osmwZ7jGUld3MuUZzoJNW64pTElK18XHyIiIswr4fFhtkxmvtnkySmDz74IN02Dg4OeHt7U7FiRVq1akWxYsVsEJmIiIiISD5WqgF0+wb+7yM48LMpoenGcettL+2HZfth7TvQoB80eRaKVjHtMyaCk7sp6Smpa0dgbleo9Rh0+hh8y+Xo2xERkQLMs2j6bbLUb5Gc6dfDL/02NlKkyL336OvrS506dewYjUnfvn357LPPSExMZOHChbz66qvAvek3atSoQaNGjVIcZ4v3cvdJ8ps3bxIfH5/mE+x3p7swGAwULlzYapur6Vycj4+Pt3hi/q6k79XZ2TnH/rsljTu9WNPbLyKSWdaSmETyCweDA35uuWdMmJfltvFsv379+PTTTzWWxf5jWck7HItY/vZOSKX6l2SNj6sPlyIumdeVxJQBGUliEhERERGRHOLuCy2eh+bD4Mx22PM9HPsDEq1MBxcdCn99a1oqtYcmg6H586ZEpfXvw5ElKY85ugyOr4XWo6D1yykrOYmIiIjdNGzY0Px6x44dtGnTxo7RmNSuXZv69etz4MABfvrpJ1599VVOnz7Nrl27AOtProNt3svdGyyxsbEEBQXRpEnqU/Tu3r0bgKpVq+Li4mK1TVBQUJo3kA4cOEBsbKzFuQEqVaqEj48Pt2/fZseOHVl6LxlRt25d8+s9e/bwzDPPpNp2z549ORaHiBRMhQoV4ujRozg4ONC5c2e8vLzsHZKI5EK5bTyrsew99h7LSt7hmCxRLuGWkpiyUyHXQhbrYXF5O4lJkwuLiIiIiBQUBoNp6reec2H0EXjwHShUOvX2/26GX5+Br+pA0ALo/D8YuBKKW3l6Kj4atoyHb5vBkd8hk1NKi4iISM5o1KgRZcqUAWDGjBlER0fbOSKTuzd3AgMDCQ4ONj+5DqZKTdbY4r107NjR/PqHH35Itd2uXbs4evRoimOSu3XrFitWrEh1f9JzJO3H0dGRgIAAANatW0dwcHD6wWdBqVKlqFmzJgCLFi0iKirKaruIiAh+/fXXHIlBRAouZ2dnwsLCCA0Nxc/Pj6JFc6jyoojkablxPKuxbMpz2GMsK3mHU2HLynQJ/1Xwkuzh4+JjsZ7XKzHZJInpww8/5MMPP+TGjRsZPiYkJMR8nIiIiIiIZDPvEtDudXj5IPT+CSo/lHrb8Muw+VOYVBv+/g7+70MI+ALcrZSavn0eFg2EuY/C1SM5Fr6IiIhkjIODA2+//TYA//77L/379ycmJibV9mFhYUyZMiXH4+rTpw8GgwGABQsWsHDhQgBatmxJpUqVrB5ji/fSrFkz8xPrM2fOZMOGDSna3L59m2HDhpljGj58eJp9vvLKK1an4tiyZQszZswAoHHjxjRt2tRi/1tvvYWjoyOJiYl0796dCxcupHqOhIQEFixYkGab1NyN/8qVK4wZM8Zqm9GjR3Pt2rVM9y0iIiJyv3LjeFZj2dwzlpW8IXklpvhQVWLKTt4u3ubXDjgQFWf94ZS8wibTyY0dOxaDwUD37t0znEl/69Yt83Hvv/9+DkcoIiIiIlJAOTpBjS6m5eYp2DcbAn+EKCs/JI0JELzctBSpAi1HQshZCPoRjImWbc9sg+ltoM8vUK2Tbd6LiIiIWPX888+zfv16fv/9dxYtWsT+/fsZNmwYzZo1w8fHh7CwMI4dO8bmzZtZvnw5bm5ujBw5MkdjKlOmDO3atWPz5s18++23hIaGAqlPv2HL9zJz5kyaN29ObGwsAQEBvPjiizz66KN4enoSGBjI+PHj+ffffwF49dVXLabOSK5+/focPXqUxo0b89Zbb9GsWTNiYmJYtWoVkyZNMk/P8e2336Y4tm7dunzxxReMHj2ao0ePUqdOHZ577jk6dOhA8eLFiY6O5syZM+zatYvffvuNy5cvc+jQIfMT/hk1fPhwZs+eTWBgINOmTeP06dM8//zzlC1blvPnzzN16lTWrVtHkyZN2Lt3b6b6FhEREckOuW08q7Fs7hnLSt7g6Kfp5HJSVWNVxpcdj6uDK84GZ84lnLN3SPfFJklMIiIiIiKSBxSpDJ0+Nk0zd2Qp7J0FF/ZYb3vzJGz8CJzcodojEHYRLgdZtilUxjR9nYiIiNiVwWDgl19+4eWXX2b69OmcOnWK119/PdX2/v7+NomrX79+bN682XzTx8nJiZ49e6Z5jC3eS4MGDVixYgU9evQgLCyML7/8ki+//DJFuxEjRvDpp5+m29fIkSMZPny41RtQLi4uzJ07l+bNm1s9ftSoUXh6ejJq1Chu377NhAkTmDBhgtW2Li4uuLm5ZeAdWnJycuKPP/6gQ4cO/PPPP6xZs4Y1a9ZYtOnUqRNjxoyhc+fOme5fRERE5H7lxvGsxrK5YywreYOTX7Lp5EJDMSYmYnCwycRh+Z6zgzNejl7mdYPRYMdo7l+u/VbExcUBpjmRRURERETEhpzdoUEfGPInDNsKjQaAs4f1tvFR8M9KUwJT4YqWU8x1+sjUl4iIiNids7MzU6dO5cCBA7z44ovUrVsXHx8fHB0d8fHxoUGDBgwePJjffvuN4OBgm8TUvXt3XF1dzeudOnWiWLFi6R5ni/fSqVMnTp48ydtvv02DBg0oVKgQrq6ulCtXjn79+rFt2zamTJmCQwYuug8ZMoRt27bRs2dPSpUqhYuLC6VLl6Z///4EBgbSu3fvNI8fOnQo//77L+PGjaN169YULVoUJycnPD09qVatGk899RTTp0/n4sWLVKlSJUvvt1SpUgQGBvLxxx9Tp04d3N3d8fX1pUWLFkydOpXVq1fj4uKSpb5FREREskNuG89qLJt7xrKS+zl4e1tuSEzEGJW3pzzLTZL/fzmvJzHl2kpMQUFBABn6Yy8iIiIiIjmkZH3oNtmUkHTgF9jzPdz4x3rbkNOm/3VyA6/i4F8r9X5j7oCrV+r7RUREJEfUrVuXyZMnZ/q4sWPHMnbs2HTbtW/fHqPRmKE+fX19iY6OznQsd2X1vQwcOJCBAwem265YsWJ88sknfPLJJ1mIzlKLFi345Zdfsnx88eLFef/993n//ffvO5bUuLu788477/DOO+/k2DlERJKKi4vDycmJhIQEe4ciInlIVsaAGsven7wwlpXczcHTM8W2hIgIq9sl8xwdHS3WHXJvLaMMyZEkpnnz5lndvmzZsnTnTY+JieHUqVP88MMPGAwGmjZtmhMhioiIiIhIZrj5QPPnoNlQOLvDlMwUvAIS41O2jY+G0LPwbVOo2A6aDobqAeD4X5XVGydhZgdoOQJav6RqTSIiIiIiIgXQmTNnaNKkCWB6sL1KlSqUKlXKzlGJiIhIdrOWrJQYEWGHSPInJ0fLtB9Ho2MqLfOGHEliGjhwIAaDZYkqo9HIu+++m+E+jEYjDg4OvPzyy9kdnoiIiIiIZJXBABXamJbwqxA4D/bOgbAL1tuf3mJavEpA44HQeACsfQtibsPm/0Hgj6YqT7UeM/UtIiIiIiIiBULSCkx37wmJiIhI/uPg4gLOzhAXZ96WGBFpx4jyFycny7QfJ0OunZAtQ3JsRGg0Gs2LtW1pLc7OzrRu3Zrly5fTrl27nArRJs6ePcuYMWOoUaMGnp6e+Pn50bRpUyZMmEBkZPb9H3P16tU88cQTlClTBldXV8qUKcMTTzzB6tWrM9xHfHw806dPp23bthQrVgx3d3cqV67MsGHDOHLkSLbFKiIiIiL5hHdxeOA1GHUQei+EKh2BVBKR7lyBLeNhUm04se7e9tvnYNEAmPsoXNWYU0REREREcp+8dJ0/L0k+ZZOSmERERPIvRw8Pi3VVYso+zk7OFuuaTs6K06dPm18bjUYqVaqEwWBg7dq1VK1aNdXjDAYDbm5uFClSJMW8fXnRihUrePrppwkLCzNvi4yMZO/evezdu5fvv/+elStXUqVKlSyfIzExkeeee45Zs2ZZbL948SIXL15k6dKlDBkyhO+++y7NHwA3btwgICCAPXv2WGz/999/mTFjBnPnzmXKlCkMGTIky7GKiIiISD7l4Ag1AkzLrX9h72xThaWoWynbGhOt93FmG0xvA02HQPu3wMMvZ2MWERERERHJgLx0nT+vSZ7ElHyGDxEREck/HDw9Sbh927yuJKbs4+LggpF74ypDag8a5xE5MtotX768ealQoYJ5e6lSpSz2JV/KlSuHv79/vkhgCgwMpFevXoSFheHl5cUnn3zCzp072bBhA0OHDgXg+PHjdOnShfDw8Cyf55133jH/sGnYsCELFy5k9+7dLFy4kIYNGwLw/fffpzmVX0JCAk888YQ5genJJ59k9erV/P3330yePBl/f39iYmIYNmxYvn3iQ0RERESyiV8l0/RwrwTDEzOgTLOMH2tMhN0z4JvGsGcWJCakf4yIiIiIiEgOyUvX+fMiJTGJiIgUHAZ3d4t1Y0y0nSLJf5wcLWsX5fUkJptMhpeYmMrT1vnYyy+/TFRUFE5OTqxbt46WLVua93Xo0IGqVavy+uuvc/z4cb788kvGjh2b6XMcP36cL774AoAmTZqwdetW3P/7P3/Tpk3p1q0b7dq1Y+/evUyYMIFnn33W6tMgc+fOZfv27QC88MILfPvtt+Z9zZo145FHHqFx48aEhYXx0ksvERwcnGJeRRERERERC85uUL+Xabl8EPbOgoOLIC4DT9hE3YKVr5gqOj3yGVRonfPxioiIiGSjM2fO2DuEbNe+ffsUCQci+V1eus6fHyiJSUQkd8iPY1mxP0Oy/AJjfLydIsl/HAyWtYvy+nRyeTv6XGr37t1s27YNgMGDB1v8sLlrzJgx1KxZE4Cvv/6auLi4TJ/nq6++Iv6//3N/88035h82d3l4ePDNN98AEB8fz6RJk6z2c/cHkp+fHxMmTEixv0qVKrz11lsAnDx5kt9//z3TsYqIiIhIAVayHjz6NYwJhoAvoFjNjB139RDMCYBFg+D2hZyNUUREREREJIm8dp0/L1IlJhERkYIjRRJTnJKYskvy6YaVxCQpLF261Px60KBBVts4ODjQv39/AEJDQ9m0aVOmzmE0Glm2bBkANWrUoEWLFlbbtWjRgurVqwOwbNmyFD8Kjh8/TnBwMAA9e/bEw8PDaj8DBw40v1YSk4iIiIhkiZsPNBsKL+yCgaug9pPgkIEKn0eWwNcN4ciynI9RRERERESEvHWdP69SEpOIiEjBkbISU+aTv8W65GOo5JWZ8ppsnRPs2WefBUwf0t35m5Nuz4rkfeUFd6dm8/T0pHHjxqm2a9eunfn1jh076NSpU4bPcfr0aS5dupSin9TO888//3Dx4kXOnDlDxYoVU8SaXj8lSpSgWrVqHD9+nB07dmQ4ThERERGRFAwG0xRxFVpD+FUInAd750BYGtWWEmNh9Wtw/Rg0HgDeJWwWroiIiIiIFDx56Tp/XqUkJhERkQLEWdPJ5ZT8Np1ctiYxzZkzxzzITJp4lHR7ZhiNxjyZxHS3slGVKlVwckr9I65Ro0aKYzLq6NGjVvvJyHmS/rjJbD/Hjx/n/PnzRERE4OnpmeF4L1xIe/qPy5cvm19HREQQFhaW4b5FstudO3esvhaxF30nJTfR91Gynzs0GAb1BuN0eiMuQfNwOrvFetM7V2Hz/zBu/Zz4yp2Jrd4DjEYwGPR9lFxBfyMlN8nt38f4+HgSExMxGo0kJCTYOxyxgaT/nfXfXLKT0WgkMTGR+Pj4DF9TjIiIyOGoJD/IS9f505OZ6/Ph4eE2uz6fPIkpMjIyxXQoIplli3GwxrIFi8axBVNWxpgZldt/r+eURCzzRaLv3FFOQDaJiY6xWHcwONjssw0PD8/2PrM1ialcuXJWk5VS254fRUdHc+PGDQDKlCmTZtvChQvj6elJREQE58+fz9R5kv7oSO88ZcuWNb9Ofp6s9GM0Grlw4YK5fG1GJI0hPUuWLMHHxyfD7UVy0vz58+0dgogFfSclN9H3UXJGa3xda9IgIZB68QdwJzpFC0NiPM4nVlL0xEqGGIoQ6NiQX+dFE2Nws0O8Itbpb6TkJrnx+9igQQN8fHzw8vLi2rVr9g5HbOzmzZv2DkHykdjYWO7cucPt27dZvnx5ho65fft2DkcleV1eu86fnsxcn58/f77Nrs83bdoUR0dH8/rvv/9eoG7mSs7LqXGwxrIFl8axBUdWxphZkRt/r+eUFpcu4Z9kfee2bZwKCbFbPPlJrHcsD9R+wLzugAPTpk2zyblz4rdVtiYxnTlzJlPb86OkmWZeXl7ptr/74yazA/PMnCdpxaTk58mufkREREREskuogx+bHR5iu9MDVE84RqP4vZQyXrbatojxJh3j/6R9/CaOONZhv1NjrjloqjkREREREcm6vHadP69K/vB78spMIiIikn8YsPx33lhAiuDYQmxcLEtvLSWRRBKNpqUc5ewdVpZlaxKTmJ7QuMvFxSXd9q6urgBERUXl2HnunsPaebKrn/Sk92TI5cuXadasGQBPPvkk1apVy1T/Itnpzp075sznZ555JkMXKkRykr6Tkpvo+yj2cufqIVwOzMf52O8Y4lNWZ3IigfoJB6ifcID4ko2Iq/8McdW6gpOqM4nt6G+k5Ca5/ft48eJFEhMTcXZ2xt/fP/0DJM9LSEgwP7lepEgRi8obIvcjPDwcb29vfHx8aNmyZYaOOX78OJ9++mkORyZ5WV67zp+ezFyff+aZZyhdunSm+s+qoKAgi8Slp556yiJZSyQrbDEO1li2YNE4tmDKyhgzo3L77/WccuPQYWIu3XtQtXXbtnTu1cuOEeUfJ2+fZMDGAeZ1Awa2D99uk3NfvHgx239bKYkpm7m53btJEhsbm277mBjT/ITu7u45dp6757B2nuT9JF3PTD/pSa8UblKenp4UKlQoU/2L5BQvLy99HyVX0XdSchN9H8WmCrWGqq0hajwc+Bn2fA83T1ht6nR5P06X9+O+5SNo2A+aPAt+lWwcsBR0+hspuUlu/D5evXqV+Ph4DAaDbgIUQI6OjvrvLtnGYDDg4OCAk5NThv/WKUlC0pPXrvOnJzPX5729vW02bnBwcCAhIcG87uHhkevGLJK35dQ4WGPZgkvj2IIjK2PMrMiNv9dzSkiyyktu7vp3P7t4xHtYrDsYHGz22YaFhWV7nw7Z3mMB5+3tbX6dkZKuERERQMZK0mb1PHfPYe082dWPiIiIiIhNuPtCi+dh5B5i6/ROu23ULdj5DUxuCD8+BcdWQWJC2seIiIiIiEiBl9eu8+dVmk5ORESk4DAaEy3WDY5KVcku8YnxFuuOhrydbKlvRjZzc3OjSJEiAFy4cCHNtiEhIeYfHmXLls3UeZI+OZHeeZKWik1+nqz0YzAYMvXkhoiIiIhItjMYiO40gYUufbmJX/rtT/4JP/eBr+vD1i/gzrWcj1FERERERPKkvHadP68qVaoUp06d4tSpU5QvXx4PD4/0DxIREZG8KcEyiQmHvJ1ok5skT2JycsjbE7Jla/SVKmX/FA0Gg4FTp05le785qVatWmzbto2TJ08SHx+Pk5P1j/nYsWPm1zVr1sz0Oaz1k9nzJO+nQYMG6fZTtmxZlVwWERERkVzhnGMFZrk9x4stPXHf+QXE3E77gNvnYeNHsHk81OoGTQZD+VaQ7AlgEREREREp2PLSdf68qkiRIly/fh0APz8/XFxc7ByRiIiI5BRj8gr5Droem13iEuMs1p0MSmIyO3PmTHZ2B6QsJ5oXtGnThm3bthEREcG+ffto3ry51XZbtmwxv27dunWmzlGxYkVKlSrFpUuXLPqxZuvWrQCULl2aChUqpIg1aTy9e1ufkuPKlSscP348S7GKiIiIiOQko8GBuIYDcW/SDzZ9AvtmQ7LyxCkkxsHhxaalWE1oOhjq9QI3zcMuIiIiIiJ56zq/iIiISG5njIm1WHdwc7NTJPmPKjGlYcCAAdnZXZ71+OOP8+mnnwIwe/Zsqz9uEhMTmTdvHgC+vr48+OCDmTqHwWDgscceY9q0aRw7doy//vqLFi1apGj3119/mZ/QeOyxx1IkhVWrVo2aNWsSHBzMr7/+ypdffmm1ZOucOXPMr5944olMxSoiIiIiYhOeRaDrRGg8ENa8CWd3ZOy468Gw6lVY/wHU72WqzlSiTo6GKiIiIiIiuVteus4vIiIiktslRkVarBuUxJRtlMSUhtmzZ2dnd3lWs2bNaNu2Ldu2bWPWrFkMGDCAli1bWrT58ssvCQ4OBuDll1/G2dnZYv/mzZvNP3gGDBhgkUR016hRo5gxYwYJCQm8+OKLbN26FXd3d/P+qKgoXnzxRQCcnJwYNWqU1XhfffVVBg8ezK1bt3j99deZMmWKxf5Tp06Zf6xVqVJFSUwiIiIikruVrAcDV8KRJbDufQi7kLHj4iJg7w+mpWwLU3WmWo+Bk2vOxisiIiJZMmfOHAYNGgTA6dOnc6QyyZkzZ6hYsSJguvY5cODAbD9HbjV27FjGjRsHgNFozFIfdxMtPvjgA8aOHZtdoYnYRF67zi8iIiKSmxmjoi3WHdzcU2kpmZUiiSmPTyfnYO8A8quvv/4ad3d34uPj6dSpE59++il//fUXmzZtYtiwYbz++uuAqRLSmDFjsnSOatWq8dprrwGwd+9eWrduzS+//MLevXv55ZdfaN26NXv37gXgtddeo2rVqlb7GTBggLnM7bfffkv37t1Zu3Ytu3fvZsqUKbRq1YqwsDAcHByYPHlyqnN/i4iIiIjkGgYD1HkKRu6Bdm+AU5Ine2o/CZ3/B36VUz/+/F+wZChMrAV/joWQszkesoiIiIiI5C556Tq/iIiISG6WGJ0sicldlZiyS3x8PJVcK1HauTRFnYri7eht75Dui7JRckjDhg355ZdfePrppwkLC+Ptt99O0aZatWqsXLkSb++sf4k++eQTrl27xg8//EBgYCC9e/dO0Wbw4MF8/PHHqfbh6OjI0qVLCQgIYM+ePSxevJjFixdbtHF1dWXKlCk88sgjWY5VRERERMTmXDzgwbehQT9Y9y6c2gQPfwreJaD5cDi9GfbMgn9WgTEx5fGRN2D7JNj+FVTtZKrOVKUjODja+p2IiIhIPmWLilIikjV56Tp/Xmc0GklMTMTBQc/ei0j2qVChAmfPnk21Gp49ZUfVS5G8JDEqymLdoEpM2cYYaeSVkq+Y16/HX7djNPfPbklMRqORf//9l1u3bgHg5+dHpUqV8tVczo8++igHDx7k66+/ZuXKlVy4cAEXFxeqVKlCjx49GDlyJB4eHvd1DgcHB2bNmsVTTz3FjBkz2LNnDzdu3KBo0aI0bdqUYcOGZSjxqGjRouzcuZOZM2fy008/ERwcTEREBKVKleKhhx7i5Zdfpnbt2vcVq4iIiIiI3RQuD73mQ9glUwITgIMDVO5gWm5fhH2zYcdkSIix0oERTqw1Lb7loMmz0PAZ8Cxq07chIiIikpfohpzkB3npOn9ec+bMGRo3boyjoyNBQUFUrlyZMmXK2DssERERyWbG+HiIi7PY5uChJKbsEhcfhyuu5vV44tNonfvZPIlpzZo1TJ06lc2bNxMREWGxz8PDg/bt2/PCCy/kmwF5+fLlmThxIhMnTszUce3bt8/Uj/yAgAACAgIyG54FJycnhg8fzvDhw++rHxERERGRXKtQKevbfUqDd8l7CUxuvhAdar1t6DnTFHOb/ge1HoemQ6BsM9MUdiIiIiIiku/kpev8eUlCQgLOzs4W6yKSNQlXrhC7bx8JV65gjI3F4OKCY4kSuDRujGOJEvYOT0QKuITw8BTbHO4zCVzuiYu3TBBLNFiZcSAPsVkSU2RkJM888wxLly4FrD+FExERwapVq1i1ahXdunXjxx9/xNPT01YhioiIiIhIQRV5CzZ+dG89OhRwgOK1IOQsxKb8oU1CLBz61bQUr2Oaaq5uT3D1slXUIiIiIiIieZajo+U03UpiEsm8+IsXiV67loTz51PsS7hwgdi9e3EsWxa3zp1xKl3aDhGKiEDi7dsptjn6+to+kHwqPsGy8pKRvF0R1yaTCycmJhIQEMDSpUsxGo04OTnRpUsXxo0bx/Tp05k+fTrjxo2ja9euODs7YzQaWb58OQEBASo5LCIiIiIiOe/AQogKSbYxEa4eBkdnqNcLStRL/firh+GP0fBlDVj5KlwLztFwRUREMmPs2LEYDAYM/1UNDAsLY+zYsdStWxcvLy/8/f0JCAhg586dFsddu3aNd999l9q1a+Pp6UmRIkV47LHHCAwMTPeciYmJ/PjjjwQEBFCiRAnc3d2pU6cO3bt3Z9q0acTGxqbbR0hICG+++SY1atTA3d0df39/OnbsyKJFizL0vu++57Fjx6bZrn379hgMBtq3b5+hfpM7fPgwH3/8MZ07d6ZMmTK4urri5eVF1apVGTBgAH/99ZfV4zZv3ozBYGDQoEHmbRUrVjTHfXfZvHmz1eOXLl1Kjx49KFeuHG5ubvj6+tKkSRPGjRtHSEjycU1KFy5cYMSIEVSqVAk3NzdKlSpFt27d+PPPP7P0OViT0f8GIlIwOThY3qJKTMzbVQNEbC3u+HEi5syxmsCUVML580TMmUPc8eM2iixnXLp0iTfffJNGjRrh4+ODs7MzxYsXp27duvTp04c5c+YQFhYG3BvfnT17FoC5c+emGGMlH/uFhIQwe/Zsnn76aWrVqoWXlxcuLi6ULl2aPn368OOPP6Y5hj1z5oy57zlz5gCwZMkSAgICKFWqFE5OTrRv3545c+ZgMBgYN26c+djksRkMBs6cOZOtn5+IPSUkS2IyuLri4OZmp2jyn+SJ4EZD3s6xsUklpu+++46tW7diMBjo3Lkz33//PaVTyfa9ePEiQ4cOZc2aNWzfvp3p06drejMREREREclZLV4A7xKw7j0Iu2i5L+oWHPwFiteFrl/B+b/h8JJ7U88lFRsOe2aalvKtTdWZajwKTi42eRsiIiLpOX/+PB07duR4kptYERERrF69mnXr1rFw4UJ69OjBwYMHCQgI4OLFe/8uRkZGsnz5ctauXcvq1at58MEHrZ7j1q1bdOvWjR07dqTYvnPnTnbu3MnUqVNZvXo15cuXt9pHcHAwHTt25NKlS+Zt0dHRbNiwgQ0bNjBo0CAeeOCB+/kossXmzZutfg6xsbGcPHmSkydPMm/ePN58800+/fTTbDlnSEgI3bt3Z+PGjRbbY2Ji2LdvH/v27WPq1KksW7aMFi1aWO1j27ZtdO3a1XyjD+Dy5cusWLGCFStWKOlIRGwieRKTKjGJZFz8xYtELloE8fHpNwaIjydy0SI8Bw7MkxWZrI1dwJR0f+3aNQ4fPszPP/9M0aJF6dq1a5bO0bBhQ3PSU1JXr17l6tWrbNmyhYULF7Jq1SpKpDNFn9FopH///syfPz9LsYjkN8mTmBx9fOwUSf6UmJAsEdwmpYxyjk2SmObOnQtA06ZNWblyZYqBaVKlS5dmxYoVtG7dmt27dzN37lwlMYmIiIiISM4yGKDOU1DtYdj+Fez4OmWS0tVD8McoqNMdhm6EUxth7ywIOWO9z7M7TIunPzTqD40Hgm/ZnH0fIiIi6ejRowcXLlzgrbfe4uGHH8bDw4Pt27fzwQcfEBYWxuDBg2nSpAldu3YlKiqKTz75hHbt2uHs7MyaNWv45JNPiImJYeDAgZw4cQIXF8tE3YSEBLp27cquXbsAaNeuHSNHjqRcuXIEBwfz888/s2bNGoKDg3nooYcICgrCy8tyKtawsDA6d+5sTmDq1asXAwYMwN/fn+PHjzNx4kRmz57N4cOHbfOhpSE+Ph5PT0+6dOlChw4dqFGjBoUKFeLatWscOXKEyZMnc/bsWcaPH0+1atUsqi41bdqUQ4cOsWzZMt59910A1q5dS6lSpSzOUbFiRfPrmJgYOnbsyP79+3F0dKRv374EBARQsWJF4uLi2Lp1KxMnTuTatWsEBAQQGBiYIlHs3Llz5puADg4OPPfcc3Tv3h0fHx8OHjzI+PHjGTt2LE2aNMnBT05ERNPJidyP6LVrM57AdFd8PNFr1+L17LM5E1QOiYmJoXfv3oSFheHt7c3w4cN58MEH8ff3JzY2ltOnT7Nz505+//138zGzZ88mIiLCPKZ87LHH+Pjjjy369fT0tFhPSEigefPmdO3alYYNG1K8eHFiY2M5deoUs2fPZtOmTQQGBtK7d+9UK2Xe9dVXX3Hw4EHatm3L8OHDqVatGqGhoZw5c4bHH3+cJk2aMHXqVKZNmwbAoUOHUvSRWkEQkbxISUw5y5hoWXkprXycvMAmSUzBwcEYDAZGjx6doQ/M0dGRV155hd69exMcrGkYRERERETERlw8ocM70PBpWPcuBC9P2ebwb/DPKmj7CgzfBed2wp5ZcHwNGK1MfxBxDbZ9AdsnmpKkmg6GSh0gj/+YFBHJaYmJRkIi059yLD8p7OGCg4MhR88RFBTEli1baN68uXlbkyZNqFq1Kl27diU8PJzmzZtjNBrZvXs3lStXNrdr1qwZRYsWZcSIEZw7d46VK1fyxBNPWPQ/ffp0cwJT//79zdNlJCQkULZsWTp16sTkyZMZP348p06d4qOPPuKzzz6z6OOjjz7i/H/Tovzvf//jrbfeMu9r3Lgx3bt3p2vXrqxbty7bP5/MatCgARcuXMDX1zfFvs6dOzNy5Ei6du3K+vXrGTduHP379zfftPf09KROnTrs3bvXfEy1atWoUKFCquf78MMP2b9/P76+vvz55580btzYYn+bNm3o168fLVu25PLly7z99tssWLDAos2YMWPMVQx+/PFH+vTpY97XpEkTevToQdu2bS3iEhHJCarEJPmZ0WjEGBmZI30nXLuW7hRyqR57/jxxp0/j6O+fzVGBwcPDPH1xdtqxY4c5uf2nn35KUWmpRYsW9OnTh0mTJhH532d+Nwnc2dkZAF9fX+rUqZPmeTZu3EjVqlVTbG/evDkdO3bk559/5pVXXmHLli1s2LCBhx56KNW+Dh48aDEWTs7X1xf/JP8N0otNJK9LCFUSU44yAkn+1CiJKQPu/nGuVq1aho+5+49ETvxjJyIiIiIikqbC5aHXfPh3C6x+A64ne7giLhI2fgz750OXL6HPQgg9D/vmwP65EHE9ZZ/GRFPy0z+roHBFaPKsKVnKw88mb0lEJK8JiYyl8cd/2jsMm9r3bkeKeLnm6DlGjRplkcB0V5cuXShfvjxnz57l+vXrTJs2zSKB6a5BgwYxZswYoqOj2bZtW4okpm+//RaAYsWKMWXKFKvX9saOHcvSpUs5duwYM2fO5MMPP8TV1fS+Y2NjmTVrFgD16tXjzTffTHG8s7Mzs2bNolKlSsTFxWX+Q8hGRYsWTXO/i4sLEyZMoEGDBpw9e5agoKAUiUcZdefOHfPn+9FHH6XaT/ny5Xnvvfd44YUXWLRoETNmzDBXGrhy5Yq5SkHXrl0tEpju8vb2ZsaMGVa/JyIi2Sn5Dbb4zFaVEcnFjJGRhH/xhb3DsCpy3rwc6df71VcxJKtulB2uXLlifp3WdMJOTk4UKlQoy+exlsCUVO/evZk3bx5BQUEsXbo0zSQmX1/fVMfCIgVRQkiIxbqDr5KYspNDogMkKXCZvNplXmOTFKy7FzyuXbuW4WPutrV2sURERERERMQmKrWD57fDIxPAzcqP69CzEHnL9Nq3LDz0How+Ck/NgvKtU+835DSsfw++rAG/Pw/n94DRmHp7ERGRbNK7d+9U99WrVw8wPVTYq1cvq23c3d3NN3j+/fdfi32XLl0yV1Xv2bMn3t7eVvtwcnIyT6sWEhLC/v37zfv27dtHyH8XuAcMGJDqjZ8yZcrQqVOnVN+LvcTExHDu3DmOHj3K4cOHOXz4MMYk/8YfOHAgy31v2bKF2/9Nw9C9e/c02969wRcXF8e+ffvM2zdt2mSudJJ0arvkmjVrRu3atbMcq4hIRmg6ORHJiJIlS5pfz5492ybnNBqNXLlyhePHj3P48GGOHTvGsWPHzNP+pjeme/TRR1MdC4sURPHXLfNEnHOgGlxB5ojlmMrZ0dlOkWQPmyQx9enTB6PRyLxMZPbOmzcvzQsmIiIiIiIiNuHoBM2fgxcDTdWTktbmLdMM6vW0bO/kAnW7w6BVpunmmg4Fl1QuXCXEwIGFMKsjfPcA7JsLsRE59lZERETSqpR+d0q0okWLUrhw4XTbhYeHW2w/fPiw+XV6VXyS7k963KFDh8yvmzZtmmYfzZo1S3O/rURERPDpp59Sv359PD09KV++PLVr16Zu3brUrVuXhg0bmtveuHEjy+dJOr1byZIlMRgMqS5JpyRJWr0gL36+IpJ/OTlZThZi7+p6IpI7tWnThkqVKgGmqqLNmjXj008/ZceOHcTGZu/00ytXrqRr1674+PhQsmRJqlevToMGDejQoQMdOnRg1apVQPpjursPB4iISVyyYjdOxYrZKZL8yQUXy3Vnl1Ra5g02SWJ66aWXaNSoET///DOff/55uu0nTJjAwoULadiwIaNGjcr5AEVERERERNLjWQS6ToJhW6FcK8AAj3wGaZUGL14LunwBY4Khy0QoXif1tlcOwoqX4Mua/01hdzzb34KIiIiHh0eq++5O65NWm6TtklfMuHXrlvm1fzpP1pYoUcLqcZnpo3jx4mnut4UzZ85Qt25d3n77bQ4ePJhuFZGoqKgsnyszVe6TioyMNL/Oa5+viORv1pKYjKpQKyLJODs7s2LFCmrWrAnAnj17ePvtt2nTpg2+vr48/PDD/PTTT/dVzc1oNDJkyBC6du3KypUrUyTrJ5femC6tBwJECqL4a9ct1p1UiSlbuRncLNY9XbN/ak9bckq/yf27cuUK33//PcOGDeOtt95i4cKFDBgwgKZNm+Lv74/BYODq1avs2bOH+fPnExQURNOmTZkxY4bFk0LJlStXzhbhi4iIiIiI3FOynqnK0sX9ULpR6u02fAhV/g/KtwRXb2g62FTJ6fzfsGcWHF0KCVaeGIy5DX9PNy0V2kLTIVCjC+TxMsAiIplV2MOFfe92tHcYNlXYI28/LZlUatPA2bqPnPbMM89w+vRpDAYDgwYNonfv3tSsWZNixYrh4uKCwWAgMTHRPGXS/dycT3pjbv/+/Tg7Z2xsUKZMGavb88LnKyL5W/Lp5IxGIwkJCSmSm0TyIoOHB96vvpojfUevX0/cfUxR69ygAW4ds3+cbUgnEf5+1KpVi0OHDrFixQpWrFjB1q1bOXnyJFFRUaxdu5a1a9cyceJEVq1alW6itjU//PADs2bNAqBBgwaMGjWK5s2bU7p0aVxdXbl58yYAr7/+Oj/++GO6Y7rkf99ECrr45JWYlMSUbaLjonFzsExiKuRayE7RZA+bjAQrVKhg8aP44MGDjBkzJs1j9u7dS6NGqd8QMBgMxMfHZ1uMIiIiIiIiGWYwQJnGqe//dwts+9K01OkO//ch+JQ2HVeuhWl5+FMInA97f4DQc9b7ObPNtHiVgMYDoNEAUz8iIgWAg4OBIl6u9g5DMsHPz8/8+urVq2m2TfrgYtLjkj61fvXq1TSnv0vvHAaDAaPRSGJiYprtIiKyNpXrsWPH2L59OwBvv/02H3/8sdV2Sasf3Y8iRYqYXxcrVizV5KS0JP98y5Ytm2rb9D5fEZH7ZS1ZKS4uTklMki8YDAYMnjlTCcO1RYv7SmJybd4chxyKLSc5Ojry+OOP8/jjjwNw+fJl1qxZw7fffsu+ffvYt28fw4YN4/fff8903zNnzgSgSpUq7Ny5E3d3d/O+pInk2TWuEylIjHFxJPyXCHiXkpiyz+3Y23x95Wu8HLzwcvTC08GTEdVH2Dus+2KT6eTAlEGf3YuIiIiIiEiukxBvmg7ursO/wZQmsHUCxEXf2+5ZFNqMhpeCoO+vULUzkEpFhDtXYMtn8FVd+LkfnNwA6dyQFRERsbU6de5Nm/r333+n2Xb37t1Wj6tbt6759Z49e9LsI7393t7eAISEhKTaxmg0cvLkyTT7Sc2RI0fMr3v16pVqu71796bZT0YrIjVs2ND8eseOHRk6Jrns/HxFRO6Xg4NDikTTuLg4O0Ujknc4liiBYxqJyGkeW7Ysjkmm9c3LSpYsyaBBg9i1a5e5MMYff/xhMdVbRsdZd8d13bp1s0hgSspoNBIYGHifUd+jqphSUMRfv55im1OxYnaIJH8KjQnlRPQJAiMD2Ra+jTWha/Bx97F3WPfFJunss2fPtsVpRERERERE7O/gL3A92HJbXCRs/Bj2z4fOn0CNrqaqTAAOjlCts2kJOQP75sD+eRB5M3nPYEyAY3+YlsIVoPFAaPA0eOmHv4iI2F+pUqWoWbMmwcHB/Prrr4wfPx4vL68U7RISEpgzZw5gqgyUtBp748aNKVy4MCEhIcyfP5/Ro0dbvcFz8eJF1q1bl2Y8FStW5MCBA2kmEa1evZrQ0NCMvcFkklaJT6ua0/Tp09Psx83tXun/mJiYVNt17NgRDw8PIiMjmTx5Mj179sz0za8HH3wQR0dHEhISmDt3Lk8++aTVdnv27OHw4cOZ6ltEJLMMBgNxcXG4ut6rvKgkJpGMcevcmYg5cyAzs9Y4OeHWuXOOxWQvzs7OtGvXjv379xMfH09oaKg5EenuOCutMRbcG9elNaZbs2YNly9fzqaoU44Bk/4tFMlPYs9fsFg3uLvjmKRCrNyfW9GWFeJcja44GvL2lJY2SWIaMGCALU4jIiIiIiJif/V6Qewd2PQJRN+23Bd6Fn55Giq1h4c/A/8alvsLV4COY6H9W3B0Oez5Hs7/Zf08IWfgz7Gw8ROo+Sg0eRYqtLmXHCUiImIHI0aMYOTIkVy/fp2XXnqJH374IUWbDz/8kKNHjwIwdOhQixs2rq6uDBo0iIkTJxIUFMSECRN4/fXXLY6Pj49n6NChxMbGphlLu3btOHDgAH///Tc7duygdevWFvuvXLnCiy++mNW3StWqVc2v58yZQ4sWLVK0mTZtGsuWLUuzn5IlS5pfnzp1iurVq1tt5+vry8iRI/n888/ZuXMno0ePZuLEiTg4WC+2f/XqVVasWMGQIUMszvXYY4+xZMkSli9fzq+//krPnj0tjrtz5w7Dhg1LM2YRkexy9epVDAYDLVu2xNvb22ryq4ik5FS6NB49ehC5aFHGEpmcnPDo0QOn0nlvivpt27ZRsmRJqlSpYnV/bGwsW7ZsAcDLy4tiSSq8lCxZkmPHjnHq1Kk0z1G1alUOHTrEihUr+N///mcx3THAmTNneOedd+7znVhKPgasVatWtvYvklvEXbBMYnIpU0aVyLJRaEyoxbpbopv1hnmIzaaTExERERERKRAcnaD5MHgxEBoPwuoUcf9uhmmtYPWbEBWacr+TK9TrAYPXwvM7TAlKzp7Wz5cYB0eWwNyuMKUp7JoKkbestxUREclhzz//PC1btgRM1dkfeughFi9ezP79+/nzzz8ZMmQIn3zyCQCVK1fmvffeS9HH+++/T5kyZQB444036Nu3L2vWrGH//v38/PPPtGrVitWrV9OkSZM0Y3nuuedwcnLCaDTy6KOP8tVXX7F371527tzJhAkTaNiwIbdv37ZIRsqMhg0bmqfC++677+jVqxd//PEH+/btY9myZfTo0YMXXnghRfKUtX7uPon/3nvvsX79eo4fP87Jkyc5efKkxZQoH374Ic2bNwfg66+/plGjRnz77bfs2LGDoKAgNm3axJQpU3j88ccpV66c1SpQX375pXmqvb59+zJixAg2bdrEvn37mD17No0bNyYwMDDdz1dEJDtcunSJixcvUqxYMfz9/VWJRCQTnKtVw3PgwHSnlnMsWxbPgQNxrlbNRpFlrw0bNlC9enXat2/PhAkTWLt2Lfv372fHjh3Mnj2btm3bsn//fgAGDx6Mk9O9Gh6tWrUCTFUmx48fz4EDB8xjrIsXL5rb9e/fHzD9TWrZsiU//PADu3fvZuvWrYwbN46HH36Y0NBQiwqi9+tubACjR49m69atnDhxwhxffGaqbInkYrEXzlusO2dxOkyxLkUlpsS8P5aySSUmERERERGRAsezCDz6FTQZBKvfgHO7LPcbE+DvaXDoV+jwHjTqb5paLrkSdaDrJOg4ztR2zw9w7Yj1c948AWvfgg3joPYTpuSnMk1VnUlERGzG0dGRP/74g27durFjxw42btzIxo0bU7SrWbMmq1evtlpxw8fHhzVr1tCxY0euXLnCwoULWbhwoUWbgQMH0q5dOwYNGpRqLLVr1+bzzz/nlVdeISQkhNGjR1vs9/PzY+nSpbz33nucOHEi0+/VYDAwf/58OnToQEhICL/++iu//vqrRZu6deuyaNEiSpUqlWo/3t7evPTSS3z++efs37+fTp06WezftGkT7du3B0yVqtavX8/AgQNZsmQJBw4cYOTIkan2XahQoRTbKlSowPLly+nWrRvh4eFMnTqVqVOnWrR5//33MRgMaU7FJyIiIvbnVLo0Xs8+S8KVK8Tu20fC1asYY2IwuLriWLw4Lo0b41iihL3DvG+JiYls2bLFXHHJmscee4xPP/3UYtvw4cOZNm0at27d4q233uKtt94y72vXrh2bN28G4OWXX2b9+vWsW7eO48ePM3jwYIt+3Nzc+Prrr9mxY4c5Yep+ValShZ49e/Lrr7+ybt26FFMlnz59mgoVKmTLuUTsKS7ZdHLOZfJeRbjcLCQ6xGI9PyQxqRKTiIiIiIhITipZHwathqdmQSErP9Ijb8Ifo2BGeziXytRxAG6FoOkQGL4DBq+H+n3BKZXywPHRcGAhzPo/mNYads+E6LDseDciIiLp8vPzY+vWrcybN4+HH36Y4sWL4+zsTOHChWnVqhWTJ08mKCiI8uXLp9pH7dq1OXLkCK+//jpVq1bF1dWVokWL8uCDD/LTTz8xe/bsDMUyevRo1qxZQ+fOnSlcuDCurq5UrFiRESNGEBgYSNu2be/rvTZo0ICgoCCef/55ypcvj7OzM35+fjRr1owvvviC3bt3W0wVkprx48czc+ZM2rZti5+fH46OVhKb/+Pt7c3ixYvZtm0bQ4YMoXr16nh7e+Pk5ISfnx9NmzZlxIgRrFq1ivXr11vto3379hw5coThw4dTvnx5XFxcKF68OF26dGHNmjWMGzcuy5+JiIiI2J5jiRK4d+mC17PP4j18OF7PPot7ly75IoHp1VdfZfHixQwfPpwWLVpQrlw53NzccHNzo0KFCvTs2ZM//viDpUuX4u7ubnFs6dKl2b17N4MHD6ZKlSrm6pfJOTs7s3LlSiZPnkyTJk3w8PDA3d2dKlWqMGzYMNauXcujjz6a7e/txx9/5PPPP6dZs2b4+PikOk2wSF4Wd96yEpNLGVViyk6hEaF4OXhh+G82APcE93SOyP0MRqPRaKuTxcfHs3LlSrZt28a///5LeHg4CQkJaR5jMBjYsGGDjSIUe7lw4QJl/ysdd/ToUWrWrGnniKQgCwsLY9q0aYApS9/aU4sitqTvpOQm+j5KbpInv4+xEbB9EuyYDAkxKfc/8Dp0eCfj/UXeggM/w94fTFWY0uLsCXWfMlVnKtUwc3FLhuTJ76TkW7n9+3jixAni4+NxcnLK8lRekrckJCRw7do1APz9/dNM0hHJjKz8PQkODqZWrVoAnD9/3jx9oUhBlfT6vC3/P5HbxyuSN9nie6WxbMGicWzBlJP/Py9o//4db9WahFv3pjwrM20q3g8+aMeI8peFmxZSyqEUccY4bsff5vCVw4zuNtpm36ucGEfabDq5LVu2MHDgQM6dO2fellb+lMFgwGg0YtC0ByIiIiIikl+4eEKHd6Hh07D2HTj2x719hUpDm1GZ68/DD1q+AC2Gw9kdpmSmo8shMS5l27gI2D/PtJRqaEpmqvOUKSYRERERERERERGRbBQfEmKRwATgkkZFXsk8F6MLAM4GZ4o6F80X08nZJIkpKCiIhx9+mNjYWIxGI25ublStWhVfX1+VxRMRERERkYKncAXovQBObYI1b8L1Y9Dpo6wnFBkMUKGNablzHYIWwL7ZEHLGevtLgbD8RVMiVb1e0GQQFK+d1XcjIiIiIiJy34xGI7Gxsbi4uOgBdxERkXwg9tQpyw3OzriUK2efYPIho9GIp8HyenJCdNozoeUFNkliGjt2LDExMbi6ujJx4kQGDRqU6pyjIiIiIiIiBUblB+H57RC8HGo/mXq7fXOgZAMo1SD9Pr2KmSo6tXoJ/t1kSmY6tgqMVn7AxoTBnpmmpWxzU3WmWo+Bc96fO11ERERERHI/R0dHatSoweHDh4mLM1WUbdmyJS4uLnaOTERERO5XzEnLJCbXChUwONlssrB8LzQqFHeHZNdxY+wTS3ayyTdk+/btGAwG3nnnHYYPH26LU4qIiIiIiOQNjs6mad1Sc/MUrHwVEuOhYT/o8D54F0+/XwcHqPKQaQm7DIHzYd9cCLtgvf35v03Lmjehfl9TdaaiVbP2nkRERERERDIgISEBLy8vcwITQExMjJKYRERE8oGYZJWYXKpUtlMk+dPl25dTbHOIyvszodnkHURHRwPw8MMP2+J0IiIiIiIi+ce69yAxDjBC4I/wTWPYPgniM/FYTaGS0O51GHUQ+vwCVTsDqUzPEBUCf30LU5rAnK5weDHEx2bHOxEREREREUkhNtby90ZMTD4oISAiIiLEnjppse5auYqdIsmfboTfsFi/k3AHB6OSmDKkQoUKABaZ9CIiIiIiIpKO01vhn5WW22LD4c+x8G0zCP4DjMaM9+fgCNUfhn6/mhKaHngNvNKo6nRmG/z2LEyqBes/gFuns/Q2REREREREUqMkJhERkfwp5kSyJCZVYspWYZFhFuvhceF2iiR72SSJ6fHHHwdg69attjidiIiIiIhI/lCmGTz0Pjh7ptwXcgZ+6QfzusHVI5nv27ccdHgXRh+BnvOh0oOpt424Dju+gskNYP6TELwCEvSQioiIiIiI3D8lMYmIiOQ/8devE3/9usU216pV7RRN/hQRFWG5Hh+RSsu8xSZJTC+//DIlS5bkiy++4MyZM7Y4pYiIiIiISN7n7AZtx8CL+6B+X+ttTm+F6W3gj1cg4mbmz+HoDLW6Qf+l8OJ+aP0yeBRJvf2pDfDL0zCpNmz40JRMJSIiIiIikkXJk5aio6PtFImIiIhkl+ijRy3WDR4euPw3g5dkj/jYeIv1yJhIO0WSvWySxFSsWDFWrVqFu7s7zZs3Z+bMmdy+fdsWpxYREREREcn7CpWEJ6bB0I1QtnnK/cZE2DsLvmkIu6ZmvUpSkcrwfx/CK8Hw1Cwo3yb1tneuwrYv4ev6MO9xOLIU4mNTby8iIiIiImJF8qSlqKgoO0UiIiIi2SV5EpNbzZoYHB3tFE3+5Bhv+Xnml0RwJ1udqF69emzdupXmzZvz/PPPM3z4cIoWLYqHh0eaxxkMBk6dOmWjKEVERERERHKx0o3h2bVweDGsfx/CLlruj74Na9+CvT9A5/9BtU5ZO4+TK9Ttblqu/wN7Z8OBn0z9W/PvJtPiURQa9oNGA0wJUSIiIiIiIumwlsRkNBoxGAx2ikhERETuV9SRIxbrbrVq2SmS/MloNOJt8LbYFh8Vj4Nt6hjlKJslMS1evJjBgwcTHh6O0WjEaDRy7dq1dI/TIFVERERERCQJg8GUXFQ9AHZOhu1fQXyyJ5VvnoBDv2Y9iSmpYtXhkfHw0Ptw5HfYPxfO/229beQN2PG1aanQFhoPhJqPmpKiRERERERErEiexJSQkEBcXBwuLi52ikhERETuV/SRZJWYaiuJKTtdv3MdL0cvy435YzY52yQx7dq1i969e5OQkABA+fLlqVevHr6+vjg45P1MMBEREREREZtz8YD2b0LDp2H9B3D4t3v7nNyh49jsP1/Dfqbl6lFTMtOBhalXZzqzzbS4+0GDvqbqTMWqZW9MIiIiIiKS58XGxmIwGDAajeZtUVFRSmISERHJo+Jv3iT+8mWLbarElL3O3TpnsZ5oTMQQlT8KBNkkienjjz8mISEBHx8fFixYQEBAgC1OKyIiIiIikv/5lIHus6DZc7DmDbgUCK1fNm3PKcVrwSOfmRKlji6HfXPg3E7rbaNuwa4ppqV8a1MyU61u4Oyec/GJiIiIiEie4urqalGRKSoqCh8fHztGJCIiIlkVFRhosW7w8MC1UiU7RZM/Xbt9DU88zethiWEYjEpiyrC9e/diMBgYN26cEphERERERERyQrnmMGSjqSJTja6ptwteAS5eUPnB+z+nszvU72Varv8D++dB0E+mxCVrzu4wLatfh/p9oPEA8K95/3GIiIiIiEieZi2JSURERPKmyP2WSUzu9ethcLJJakqBERYRZpHEFEX+GTvZ5JsSGWmafK9Nmza2OJ2IiIiIiEjB5OAA9Xqmvj/6NqwYBZE3oHoAdPoYilTOnnMXqw6dP4EO78GxP0zVmc5sSyWOUPh7mmkp2xwaD4Raj5umrBMRERERkQIn+dRxSmISERHJu6L277dY92jYyE6R5F+BsYHMujiLYk7F8Hf2p2aR/POgqIMtTlKxYkXgXjKTiIiIiIiI2MHWCaYEJoB/VsG3zWHdu6bkpuzi7AZ1u8PAP2DkPmj1EngUTb39+b9h6XD4sgasfBWuHMq+WEREREREJE9wc3OzWFcSk4iISN6UGBND9JEjFtvcGymJKbuduH2CK3FXOBR1iA1hG3Ar5Jb+QXmETZKYnnzySYxGI2vXrrXF6URERERERCS5W6fhr+mW2xLjYOc38E1jU+WkxITsPWfRKtDpI3glGHrMgUrtU28bcxv2zITpbWBmB9PUdDF3sjceERERERHJlVxdXS3WIyMjMRqNdopGREREsir68GGMcXH3Njg44N6gvv0CyofiEuM4ffu0xbaKhSraKZrsZ5MkpjFjxlC1alW++uor9u7da4tTioiIiIiISFK+5aDLF9arIkVchxUvw4x2cGZ79p/byQVqPwH9l8FLgdDmFfD0T739xX2w/EVTdablL8GFfaAbGCIiIiIi+ZabmxslS5akSpUq1KtXj+bNm2MwGOwdloiIiGRS5N59Fuuu1arh6OVlp2jypzO3zxCfGG+xrVKhSnaKJvvZJInJ29ubDRs2UKdOHR544AHeeecdDh48SHR0tC1OLyIiIiIiIg6O0HggvLQfWr0IDs4p21w5BHO6wK/9IeRMzsThVwk6fgCvHIWe86FKRyCVmxOx4bB/LnzfAaa1gl1TIeJmzsQlIiIiIiJ24+zsTLVq1ShdujSFCxfGxcXF3iGJiIhIFkTs3Gmx7tG4sZ0iyb9OhJywWC/uUZxCLoXsFE32s0kSk6OjI+XLl2f37t1ER0czfvx4GjZsiKenJ46OjmkuTk5OtghRRERERESkYHDzgU4fw4i/oXqA9TZHl8GUZvDnWIgOy5k4HJ2hVjd4ejG8fAAeeA28S6be/tpRWPsWTKwBiwbCyQ2QmJgzsYmISJ4wZ84cDAYDBoOBM2fO5Mg5zpw5Yz7HnDlzcuQcudXYsWPN711EREQkNzh37hzDhg2jcuXKuLm5mccqS5cuZeDAgRgMBipUqJBj59+8ebP5nJs3b862fgvymFPyl8SoKKL277fY5tm6lZ2iyb9OhFomMVUpXMVOkeQMm2QIJZ+3WPMYi4iIiIiI2FmRytBnIZzaCGvehuvBlvsTYmD7JAj8ETq8Cw37g0MOPQdTuLzpHO3ehBPrYN8cOLkejFaSlBJi4cjvpsWnHDTsBw36gW/ZnIlNREREREREROzu3LlzNG7cmBs3btg7FBFJReS+/Rjj4u5tcHTEo2lT+wWUT90JvUNNt5pcirvE7YTbVPOtZu+QspVNkpg++OADW5xGREREREREMqtyB3h+O+ybDZs+gagQy/0R12H/fGg0IOdjcXSCGgGm5fZFCPoJAudD6Fnr7W+fg82fwubxpvfRqL+pupSTpp4QEZG8Y86cOQwaNAiA06dP52j1ABEREZG86uOPP+bGjRs4OTnxySef8MADD+Dl5QVA+fLlWbp0qX0DFJEUU8m5162Lo7e3naLJv6oYq9CmRBsAIhIiMLjmr+q5SmISEREREREp6BydoNlQqPMUbPkM9nwPifH39j/8Kdh6Khmf0tDuNWg7Bs5sNSVSBa8wVYhKwQinNpgWjyJQrzc0egb8a9o2ZhERERERERHJEX/++ScAjz/+OK+//nqK/XPmzMnxqdjat2+vGYdE0hCxa5fFumcrTSWX3e7E3qGIYxHzuqejJ4V9CtsxouyXQ3MBZI/AwEBGjx5t7zBEREREREQKBg8/eOQzGL4Lqj1s2lbnKSjbzH4xOThApfbQfRaMOQaPfA7F66bePvIm/PUtTG0B33eE/fMgJtxm4YqIiIiIyP0xGo1ERkZy/fp1YmKsPcQgIsldO3CA9S+8wE+tWjGnbl1+atWK9S+8wLUDB+wdWra5ePEiANWq5a9pk0Tyi7ir14gJDrbY5tmqpZ2iyb/+ufoPzgZni22V/SvbKZqcYZNKTJlx+fJlfvzxR+bPn8+RI0cAmDRpkp2jEhERERERKUCKVYO+v8CpTVAkjR/BZ7bD5QPQdKhtpnDz8IPmw6DZc3A5yJSgdOg3iAmz3v7CHtOy+k2o84RpSrwyTW1fVUpERERERDLk8OHD3Lp1y1zppEaNGhQvXtzOUYnkXpf37GHTqFFcSjaFE8ClXbs4MG0apVu3pv2kSZRs2tQOEWaf2NhYAJydndNpKSL2cGfzZot1B29v3OvVs08w+diZG2coSlHzekRiBJ5unoTFpnJ9NA/KFZWYoqKiWLBgAZ07d6ZcuXK8+eabHDlyROX4RERERERE7Knyg+Bbzvq+xARTctDat2Fqcwj+A2z1G85ggFINoeskGPMPPPEdlG+devu4CAj8EWb9H3zbHHZOgYgbtolVRCQXGDt2LAaDAcN/SZxhYWGMHTuWunXr4uXlhb+/PwEBAexMdvPr2rVrvPvuu9SuXRtPT0+KFCnCY489RmBgYLrnTExM5McffyQgIIASJUrg7u5OnTp16N69O9OmTTPfhEpLSEgIb775JjVq1MDd3R1/f386duzIokWLMvS+777nsWPHptmuffv2GAwG2rdvn6F+kzt8+DAff/wxnTt3pkyZMri6uuLl5UXVqlUZMGAAf/31l9XjNm/ejMFgYNCgQeZtFStWNMd9d9mc7GbAXUuXLqVHjx6UK1cONzc3fH19adKkCePGjSMkJCTduC9cuMCIESOoVKkSbm5ulCpVim7dupmnaslOP/30E+3bt6dw4cJ4eXlRp04dPvjgA0JDQ4GM/7cSkYIh6b2hO3fu2DESkdzt1MqV/PLAA1YTmJK6uGMHvzzwAKdWrrRRZNlnzpw5FuNYgHHjxlmMlQYOHAjAwIEDMRgMVKhQwWpfyccbe/bsoU+fPubxW+nSpXnmmWcITlZJJqm747e0xmjHjx/nxRdfpE6dOnh7e+Pi4kKpUqVo0KABzz77LL/88kuGqsytX7+eRx99lBIlSuDq6krFihUZPnw4Fy5cSPdYEXu4s3GjxbpX27YYXGzw0GMBExoWarEe7Rhtn0BykF0rMW3atIl58+axZMkS80D07uC0ZMmSPPHEEzz11FP2DFFERERERESsCVoAVw+ZXt/6F37pBxXaQudPoGR928Xh4gH1e5uWGychcD4cWAh3rlpvf+MfWPcO/DkWqj9iqs5U+UFwcLRdzCIidnT+/Hk6duzI8ePHzdsiIiJYvXo169atY+HChfTo0YODBw8SEBBgnrYDIDIykuXLl7N27VpWr17Ngw8+aPUct27dolu3buzYsSPF9p07d7Jz506mTp3K6tWrKV++vNU+goOD6dixI5cuXTJvi46OZsOGDWzYsIFBgwbxwAMP3M9HkS02b95s9XOIjY3l5MmTnDx5knnz5vHmm2/y6aefZss5Q0JC6N69OxuT3SSIiYlh37597Nu3j6lTp7Js2TJatGhhtY9t27bRtWtXwsLuPa17+fJlVqxYwYoVK7ItmSg+Pp6+ffumSDw7cuQIR44c4ccff8yRpCkRybu8vLy4efOmeT08XFNDi1hzec8eVnTvTnx0xm5ex0dHs6J7d3pt3ZrnKzJlh6lTp/Lyyy8THx9v3nbp0iV+/PFHlixZwurVq7M01ly0aBFPP/10ioT9y5cvc/nyZQ4cOMDs2bM5dOgQderUSbWft956i/Hjx1tsO3PmDNOnT2fx4sVs2bKFmjVrZjo+kZySGBlJxK5dFtu8Uvm9KPfHKc4JkhSkc3V3tV8wOcTmSUzHjh1j3rx5LFiwwJwpejdxqUyZMjz11FN0796dVq1aWWTVioiIiIiISC4RHwMbP0m5/cw2+K4dNOgLHd6DQiVtG1fRKvB/46DDu3BiHeyfb/pfY0LKtolxELzctBQqAw36QP0+aU+fJyKSD/To0YMLFy7w1ltv8fDDD+Ph4cH27dv54IMPCAsLY/DgwTRp0oSuXbsSFRXFJ598Qrt27XB2dmbNmjV88sknxMTEMHDgQE6cOIFLsidrExIS6Nq1K7v+u4Ddrl07Ro4cSbly5QgODubnn39mzZo1BAcH89BDDxEUFISXl5dFH2FhYXTu3NmcwNSrVy8GDBiAv78/x48fZ+LEicyePZvDhw/b5kNLQ3x8PJ6ennTp0oUOHTpQo0YNChUqxLVr1zhy5AiTJ0/m7NmzjB8/nmrVqllUXWratCmHDh1i2bJlvPvuuwCsXbuWUqVKWZyjYsWK5tcxMTF07NiR/fv34+joSN++fQkICKBixYrExcWxdetWJk6cyLVr1wgICCAwMDBFoti5c+fMCUwODg4899xzdO/eHR8fHw4ePMj48eMZO3YsTZo0ue/P59VXXzUnMFWvXp3XX3+devXqcfv2bRYtWsTMmTPp1avXfZ9HRPIPb29vi/Xw8HCMRqPuF4kks2nUqAwnMN0VHx3N5tGj6bN9ew5Flf0ef/xx85ikbt26AAwfPpwXXnjB3KZw4cKZ6nPt2rXs3r2bunXr8vLLL1O3bl2ioqL4/fff+frrr4mMjOSZZ56xOtZNy9WrVxk0aBCxsbH4+/szcuRIWrRoQdGiRYmKiuLkyZNs2bKFpUuXptnPzJkz2blzJ+3atWPYsGFUq1aN0NBQ5s2bx7x587h+/TrPPvusebwtkhtE7NyJMWnynqMjXg+0tV9A+dTtmNsUcyhmsa1kERtff7UBmyQx3bx5k4ULFzJv3jz27dsH3Etc8vX1JTQ0FIPBwBdffEHPnj1tEZKIiIiIiIhklZMr9PrRNJXchd3JdhpNVZqO/A6tR0GrF03VkmzJ0RlqdDEtYZfhwE+mhKaQ09bbh12ArRNMS7lW0LAf1HoMXL2ttxcR20hMhKhb9o7Cttz9wMEhR08RFBTEli1baN68uXlbkyZNqFq1Kl27diU8PJzmzZtjNBrZvXs3lSvfS+5s1qwZRYsWZcSIEZw7d46VK1fyxBNPWPQ/ffp08w2V/v37m6cASUhIoGzZsnTq1InJkyczfvx4Tp06xUcffcRnn31m0cdHH33E+fPnAfjf//7HW2+9Zd7XuHFjunfvTteuXVm3bl22fz6Z1aBBAy5cuICvr2+KfZ07d2bkyJF07dqV9evXM27cOPr374+jo6n6n6enJ3Xq1GHv3r3mY6pVq5bqFCgAH374Ifv378fX15c///yTxo0bW+xv06YN/fr1o2XLlly+fJm3336bBQsWWLQZM2aMuQLTjz/+SJ8+fcz7mjRpQo8ePWjbtq1FXFlx6NAhvvnmGwAaNWrEli1bLBLWHnroIVq1asWAAQPu6zwikr8kT2JKTEwkMjIST09PO0UkkjXGxESiklQVy043Dh1Kdwq51FzcsYNzmzZRNI0qQFnlXqQIhmwey/r6+qYYZ/n7+6dZxSg9f/31FwEBAfz+++8WSUpt27alSJEivPvuu6mOddOycuVKIiIiANiwYUOKGFu1akX//v2ZMmVKmv3s3LmToUOH8t1331kkcD700EO4uLjw/fff89dffxEYGEjDhg0zHJ9ITgrfYFkl1qNJExx9fOwUTf515PIRPB0tx0TVilezUzQ5J8eSmOLi4lixYgXz5s1jzZo1xMXFmROXXFxcCAgI4Omnn6ZLly64u7vnVBgiIiIiIiKSE8o2hcHr4MgSWD8Wbp+z3B8XCZv/B/vmQMcPoG7PHL8xb1WhktB2DLR5Bc7ugP3z4OgyiE/lidVzO03LqtdNiUwN+kL51vaJXaSgi7oFEwpYdbTXToFn0Rw9xahRoywSmO7q0qUL5cuX5+zZs1y/fp1p06ZZJDDdNWjQIMaMGUN0dDTbtm1LcWPn22+/BaBYsWJMmTLFauWMsWPHsnTpUo4dO8bMmTP58MMPcXU1lcCPjY1l1qxZANSrV48333wzxfHOzs7MmjWLSpUqERcXl/kPIRsVLZr2fy8XFxcmTJhAgwYNOHv2LEFBQSkSjzLqzp075s/3o48+SrWf8uXL89577/HCCy+waNEiZsyYYb75f+XKFX7//XcAunbtapHAdJe3tzczZsyw+j3JjOnTp5OYmAjAjBkzUlTcAlOi288//8zq1avv61wikn+4uLjg6upKTEyMeVt4eLiSmCTPibp5k6n+/vYOw6pfO3TIkX5fuHYNj2LF0m9oZ25ubsyePdtqlaWXXnqJDz/8kNjYWKtj3bRcuXIFMFWGSivJKr374iVLluSbb76xOo5+9dVX+f777wHT9MBKYpLcIDE2lvBkU0R7PdjeLrHkd+dunKMk9yovRSZG4umR/8ZI2X4V9q+//uKFF16gZMmS9OjRgxUrVpjn/WzdujXTpk3j8uXLLFmyhCeffNJ8gUJERERERETyGIMB6jwFI3fDQ++DS8qbk4Rfgt+Hwfcd4KwdS50bDFChDTw5A8b8AwFfQMn6qbePizBVcJrbFSY3gM2fQchZm4UrIpJTevfuneq+evXqAWAwGFKd4svd3Z2qVasC8O+//1rsu3TpEsHBwQD07NkzRTWNu5ycnMzTqoWEhLB//37zvn379hESEgLAgAEDUp0+qEyZMnTq1CnV92IvMTExnDt3jqNHj3L48GEOHz5sfrAT4MCBA1nue8uWLdy+fRuA7t27p9n2gQceAEwPmt6tjA+wadMmEhJM06wmndouuWbNmlG7du0sxwrw5383MurWrZtm4tazzz57X+cRkfzH2pRyIiLZ5f/+7//wTyXBzNvbO9WxbnpKljQlFoSEhLBs2bIsx9e9e/dU759Xr17dnBie2fhEckrE9h0kJvu3ulDnznaKJn+7E37HYj3aKTpfTrmb7ZWYWrVqhcFgMP84r169Ok8//TT9+vVLsxSyiIiIiIiI5FHO7qZqRw2fgY0fQ+B8MCZatrkUCLMfNlU3CvgSvOz4dKa7LzQbalouH4Sgn+DgL6lPWxV61lRVavP/oOID0OBpqPmo7afJExHJBtWqpV5q/u5UHUWLFqVw4cLptkt+U/nw4cPm1+lV8Um6//Dhw7Rs2RIwTUF2V9OmTdPso1mzZqxcuTLNNrYQERHB5MmT+fnnnzly5Ig5SciaGzduZPk8Sad3u3uTLCPuVgWAzH++R44cyUSE98TExHDixIkMn0dEJClvb2+Lv5dKYhKR7FSjRo009/v5+QGZ/9vTrVs3fH19CQ0N5YknnqB9+/Y8+uijPPDAAzRo0MA8pfD9xle4cGHu3Lmjv42Sa4StWmWx7t6oEc6Z+L0iGeca7wpJisi5e+bPGc9ybDo5b29vJk+erDnNRURERERECgovf+g2GZo9B+vegX83p2xzfnfuSv4pWc+0/N+HcHyNKaHpxDowpnID+vRW07LSG+o8YUpoKtvMVOlJRCQP8PBI/W+ww39TZ6bVJmm75Mk6t27dSwZN7en2u0qUKGH1uMz0Ubx48TT328KZM2fo0KEDp0+fzlD7qKioLJ/r2rVrWTouMjLS/NpWn29ISIj5Ide88N9RRHKX5JWY7ty5Q2JiovnfHxGR+5HVsW56ihQpwvLly+nTpw8XL15k06ZNbNq0CYBChQrx0EMP8eyzz9K1a1e7xCeSExKjogjfuNFiW6GAADtFk79dDL9IcSfL305lipaxUzQ5K0eSmIxGI3fu3OHZZ5/l66+/5umnn6ZPnz6ZekJIRERERERE8qgSdeCZpXB8Lax7F26euLfvoQ/AJRfO1e7kArW6mZbwq6bKTEEL4Pox6+1jw2H/PNNSpAo06IuhUtoXIkUkk9z94LVT9o7Cttz97B1BtsmOkvZ5oSz+M888w+nTpzEYDAwaNIjevXtTs2ZNihUrhouLCwaDgcTERPOT90mnlsuspDeq9u/fj7Ozc4aOK1PG+oVtW32+eeG/o4jkLsmTmO7ecypUqJCdIhLJPPciRXghiwnI6dny+uscmTMny8fXGTSIBz77LPsC+o97kSLZ3mde07ZtW06ePMnixYtZtWoVW7du5cKFC4SFhfH777/z+++/07lzZ5YsWZJuspJIXnBnyxaMSR6awMGBQp1z37Tf+UHQxSC8HLwstlUpXsVO0eSsbE9i2rx5M3PmzGHx4sWEh4cTFBTEgQMHeOONN2jfvj3PPPMMTz75pHm+ThEREREREcmHDAao/jBUeQj2/gCbPwXfclCvl70jS593cWj9ErR6ES7th8AFcPg3iL5tvf3Nk7DhQ7w2fkwPQwUOOdaD+GhAN1lE7ouDA3gWtXcUkgl3p94AuHr1apptk05xlvS4pNPYXb16Nc3p79I7h8FgwGg0kpiYmGa7iIiINPen5tixY2zfvh2At99+m48//thqu6TVj+5HkSQ3BosVK5ZqclJakn++ZcuWTbVtep9vWu5OOZiRfu7nPCKSPzk5OeHu7m5RvS48PFxJTJKnGBwc8CiWM9OoN3755ftKYmr08ss5FpuAm5sb/fr1o1+/fgCcPn2alStX8s0333D8+HHWrl3LO++8w6RJk+wcqcj9u710mcW6R/NmOOnvS464cOMCNbg33WSEMQI3Vzc7RpRzsr325gMPPMAPP/zA1atXWbBgAZ07d8bBwYGEhAQ2btzIoEGDKFGiBH369GHVqlUqdSciIiIiIpKfOTpD82HwUiA8NcuUlGDNzVMw/wm4FGTT8NJkMEDpxtB1Iow5Dt1/gMoPAdYrShiMiVRK/JfH4pbi/V0T+OMVuLgP7qPqhohIXlKnTh3z67///jvNtrt377Z6XN26dc2v9+zZk2Yf6e2/W8kjJCQk1TZGo5GTJ0+m2U9qjhw5Yn7dq1fqSbp79+5Ns5+MVipq2LCh+fWOHTsydExy2fn5psXNzY2qVavm+HlEJP9KnrB0+3YqDxSIFED+DRpQqlWrLB1bunVr/OvXz+aIJC0VK1Zk5MiR7Nmzx5yE/uuvv9o5KpH7F3f1Gne2brXY5pPOdImSdSdun+BMzBkSjP/l1+TP/CUgB5KY7nJzc6NPnz6sXr2a8+fP8/nnn1O3bl2MRiORkZH8+uuvPProo5piTkREREREpCBwLwxFq6a+/88P4NRGmNEOlgyD2xdsF1tGOLtBnafgmSUw+gg89D74VU61uSHmNuydBTM7wNSWsGOyaZo6EZF8rFSpUtSsWRMw3Zi5c+eO1XYJCQnM+a96QOHChWnUqJF5X+PGjc3VgubPn5/q9GsXL15k3bp1acZTsWJFIO0kotWrVxMaGppmP6mJj483v06rmtP06dPT7MfN7d7V55iYmFTbdezY0TztyOTJk7M0Nd2DDz5ontpu7ty5qbbbs2cPhw8fznT/SXXs2BGAQ4cOERgYmGq7H3744b7OIyL5k4+Pj8V6aGjofU3JKZLfPPjVVzi5Ze4OtpO7O+1V/cduChUqRNOmTQG4ceOGnaMRuX+3ly2DJFVvDR4eeHd+2I4R5V/XI6+z9sZavrj8Ba+de41vrnxD6dKl7R1WjsmxJKakSpQowauvvkpQUBCBgYGMGjUKf39/jEYjN27cMD9t9Morr/Dyyy+zbds2W4QlIiIiIiIiucG5vyB4xb31gz/DN43hz3EQHWa/uFLjUxrajoEX98Gz66BRf3DxTr399WBY/x5MrAkLesLhJRAXbbt4RURsaMSIEQBcv36dl156yWqbDz/8kKNHjwIwdOhQXF1dzftcXV0ZNGgQAEFBQUyYMCHF8fHx8QwdOpTY2Ng0Y2nXrh1gqgplrXLRlStXePHFFzPwrqy7W2kIMCdlJTdt2jSWLVtmdd9dSR/yPHXqVKrtfH19GTlyJAA7d+5k9OjRaU6Vd/XqVb7//vsU53rssccAWL58udUqAHfu3GHYsGFpxpwRw4YNM1/3fe6556wmei1YsIBVq1bd97lEJP9JnsQUFxdnMb2cSEFXsmlTHv3ttwwnMjm5u/PookWU/C+JRrLf2rVruXz5cqr7b9++ba5GejfZXiSvMhqN3F682GJboUcextHL004R5W/7ru0zv441xnIx4SJ1StdJ44i8zSZJTEnVr1+fiRMncuHCBf744w969uyJq6srRqORS5cuMWXKFNq3b0/JkiV54YUX2LBhg61DFBEREREREVvaNSXltvho2D4RJjeE3TMhIc72caXHYIByzaHbN/DqP0Q9/DVnHMqn3t6YACfWwm+D4ItqsPwlOLtL082JSL7y/PPP07JlSwBmz57NQw89xOLFi9m/fz9//vknQ4YM4ZNPPgGgcuXKvPfeeyn6eP/9981Tbbzxxhv07duXNWvWsH//fn7++WdatWrF6tWradKkSZqxPPfcczg5OWE0Gnn00Uf56quv2Lt3Lzt37mTChAk0bNiQ27dvWyQjZUbDhg3NU+F999139OrViz/++IN9+/axbNkyevTowQsvvEDr1q3T7eduNab33nuP9evXc/z4cU6ePMnJkyctbtp/+OGHNG/eHICvv/6aRo0a8e2337Jjxw6CgoLYtGkTU6ZM4fHHH6dcuXJWq0B9+eWX5qn2+vbty4gRI9i0aRP79u1j9uzZNG7cmMDAwHQ/3/TUr1/fnNS2d+9emjRpwpw5c9i3bx8bN25k+PDh9O/f/77PIyL5k7u7Oy4uLgA4Ojri5+eXZuKmSEFUuUsXem3dSul0xhqlW7em15YtVO7SxUaRFUwLFy6kfPnydOnSha+//poNGzYQGBjI1q1bmTp1Ki1btuTixYuAacwskpdF7dtH7NmzFtt8n3rKTtHkf/uu7LNYb+jfEEcHRztFk/Oc7HViR0dHAgICCAgIICwsjF9++YX58+ezY8cOjEYjV69e5bvvvmPGjBkWpZlFREREREQkn3lyJvw1DbZNhNhwy32RN2DVq/D3dPi/D6F6gCl5KLdx8SSu1pP8suUqhRJDGdTIHbfg3yD0rPX2Mbdh/1zTUrgC1OsN9XuBXyWbhi0ikt0cHR35448/6NatGzt27GDjxo1s3LgxRbuaNWuyevVqvLy8Uuzz8fFhzZo1dOzYkStXrrBw4UIWLlxo0WbgwIG0a9fOXLXJmtq1a/P555/zyiuvEBISwujRoy32+/n5sXTpUt577z1OnDiR6fdqMBiYP38+HTp0ICQkhF9//TVFZaO6deuyaNEiSpUqlWo/3t7evPTSS3z++efs37+fTp06WezftGkT7du3B0yVqtavX8/AgQNZsmQJBw4cMFdnsqZQoUIptlWoUIHly5fTrVs3wsPDmTp1KlOnTrVo8/7772MwGNKcii8jJk6cyKVLl1iyZAnHjh1L8d+rYsWK/PLLL1SunPoUrSJSMBkMBqpVq4aLiwteXl7mym4iYqlk06b02b6dawcOcHDGDK4FBREbHo6Ltzf+DRpQ77nn8K9f395hFhhxcXGsWrUqzUqTzz//fKoVS0XyipBfLH/3uFSsiHvDhnaKJv9LWokJoHHxxnaKxDZsXonJmkKFCjF06FC2bt3KqVOn+OCDD6hcuTJGo1FzHIuIiIiIiOR3zu7Q9hV4KRCaDgWDlSeJbp6En/vCnC5wcV/K/blImIMvsS1HwUtBMOAPqN8XnD1SPyDkDGwZb6o6Nasz7P0BokJsFK2ISPbz8/Nj69atzJs3j4cffpjixYvj7OxM4cKFadWqFZMnTyYoKIjy5VOvXle7dm2OHDnC66+/TtWqVXF1daVo0aI8+OCD/PTTT8yePTtDsYwePZo1a9bQuXNnChcujKurKxUrVmTEiBEEBgbStm3b+3qvDRo0ICgoiOeff57y5cvj7OyMn58fzZo144svvmD37t0W08WlZvz48cycOZO2bdvi5+eHo2PqT9V6e3uzePFitm3bxpAhQ6hevTre3t44OTnh5+dH06ZNGTFiBKtWrWL9+vVW+2jfvj1Hjhxh+PDhlC9fHhcXF4oXL06XLl1Ys2YN48aNy/JnkpSzszOLFy9m/vz5tG3bFh8fHzw8PKhZsyZvv/02+/bto1IlJfCKiHVFihTB29tbCUwiGeBfvz4dv/2Wvjt2MPDgQfru2EHHb79VApMNTZo0iR9//JFnn32WJk2aULp0aVxcXHB3d6datWoMGDCAbdu2MW3aNBwccsUtepEsib9+nbA1ayy2+T71pP69ziE3om5wIsTyoZv8nsRkt0pMqalQoQIffPABH3zwATt27GD+/Pn2DklERERERERswasYdPkCmg+D9R/APytTtjm7A2Z2gLo9oMN7UDiN6dvszcEBKrY1LQGfQ/AKOLAQTm8DUnlg5/xfpmX1G1D9EajfB6p0BEdnm4YuIvnL2LFjGTt2bLrt5syZw5w5c9Jtt3nz5nTbODg48Mwzz/DMM88AkJCQwLVr1wDw9/dPM0nnLj8/Pz777DM+++wzq/sHDhzIwIED0+2nc+fOdO7cOdX9ab2fChUqpPuQZbly5Zg2bVqabdLrw2AwMGTIEIYMGZJmu6TatGlDmzZtMtw+ubJly6aowJRURr83GfH000/z9NNPZ0tfIiIiUjClN55Kbyyb0cIZaY0N27dvn2o/hQsXpl+/fvTr1y9D50kqI2POu86cOZPp/kWyU8gvv0JcnHnd4OqKj6aSyzG7Lu6yWPd09qR20dp2isY2cl0SU1KtW7dOd854ERERERERyWeKVoU+P8GZHbDuHbgUmLLNoUVwdDk8+R3UfsL2MWaWqzc06GtaQs/DoV/hwM9w47j19gmxcHSZafEoCnW7Q/3eULJB7pxOT0RERERERERE8jVjbCwhv/xssa1Q1y44FS5sp4jyvxOXTvBuqXc5FXOKk9En8ffzx9khfz/smKuTmERERERERKQAq9AahmyEI0vgz3Fw+5zlfoMByjSzT2z3w7cstB0DbV4xJWgd+NmUlBV1y3r7yBvw93TTUqyGKZmpbk/wKW3buEVEREREREREpMAKW7uOhOs3LLb5qeJqjkk0JhJzJ4YSniUo4VKC1t6tiXGJsXdYOU4TboqIiIiIiEju5eBgqkI0cg/834fg6nNvX8sReTuRx2CA0o1MU82N+Qd6L4Sa3cDRJfVjrh+DP8fCpNowtxsE/QTRYTYLWURERETEnhITE+0dgoiISIFkNBq5lWzKRo8mTXCrWdM+ARUAwbeCqehc0WJbiSIl7BSN7agSk4iIiIiIiOR+zm7Q+mVo8DRs/dw0lVzrUam3j7gBnkVtFt59c3KBGgGmJfIWHPndVKHpwu5UDjDC6S2mxWk0VH/EVJ2pSkdTXyIiIiIi+YDRaCQqKoqQkBBCQkIIDQ2lcePGuLu72zs0ERGRAiVix06ijxyx2FZYVZhy1N/n/6ayS2WLbRVKVLBPMDakJCYRERERERHJOzyLwCOfQcex4JzKjYuoUJjSFMq3goc+gGLVbBnh/fPwg6aDTcvNU3DwFziwEELPWW8fH21KejryO7gXhtpPmBKayjY3VbISEREREcnDDhw4QGxsrHk9JCRESUwiIiI2dvO77yzWncuXw/v/OtopmoLh0rVLVHa9l8QURxze3t52jMg2lMQkIiIiIiIieU9qCUwAO76CqFtw7A/4ZzU0egbavwXeebDccpHK8ODb0O5NOP+XKZnpyFKISWUKuagQ2PuDafEtB3V7mBKa/GvYNGwREZHMMBqN9g5BRHIpg8FA4cKFuXr1qnnbrVu3KFWqlB2jEhERKVgi9wcSuWePxbYiQ4ZgcHS0U0T5353YO3jGe4LrvW3Ons4YDAb7BWUjeiRTRERERERE8o/bF+GvaffWjQmwbw5MbggbP4boVJJ/cjsHB1NlqW7fwKvHofsPUO0RcEjj2aTQc7DtS5jaHKa3gZ3fQNgl28UsIiIiIpINChcubLEeGhpKYmKinaIREREpeG7OmGGx7lS8OD6PPWanaAqG7Re3U92tusW2gjCVHCiJSURERERERPKTmyfAxTPl9rhI2DrBlMz093cQH5uyTV7h7A51noK+P8OY49DlSyjbIu1jrhyCde/CxFow91HYPx+ib9smXhERERGR+5A8iSkhIYHw8HA7RSMiIlKwRB08yJ3Nmy22FXl2EA4uLvYJqIDYd24fno6W1ziLFy1up2hsS0lMIiIiIiIikn9Uag8vBUHbV8HJypRzkTdg9evwbTM4vATy+vQ1nkWg6RAYvBZePgAd3oWi1dM4wAint8LykTChKvzaH4L/gPgYm4UsIiIiIpIZLi4ueHpa3sS7deuWnaIREREpWK5NmmSx7li4ML49etgpmoIhNiGWO7fvWGyLd4zHzc3NThHZlpKYREREREREJH9xKwQPvQcvBUKjAWCw8tM35DT8NghmdoDT22wfY04oXAEeeA1G/A3DtkLLkeBVIvX2CTFwdBn80g++qAbLXzIlOCUm2CxkEREREZGMSF6NKSQkxE6RiIiIFBwRu3YRuesvi21Fhg7FwcPDThEVDH9f/pvKrpUttvkX8bdTNLanJCYRERERERHJnwqVhG6TYfguqB5gvc2l/TC3KyzoAVeP2Da+nGIwQMn60PkTeOUo9F8GDfqBi3fqx0SHwv65pqnmJtaC1W/Chb15v1KViIiIiOQLfn5+Fuvh4eHExcXZKRoREcnvjLoegtFo5Nqkryy2ORUvTuG+fewTUAGy+exmKrpWtNhWyr+UnaKxPSUxiYiIiIiISP7mXwP6LIRBq6FMU+ttTqyDVa/bNi5bcHA0TbH3+FR47QT0mAPVu4CDc+rH3LkCf0+D7x+Cr+vDn+PgymElNEm2cnR0BCA+Pp6EBFX/EpGsSUxMNP8Nuft3RUTyJx8fHxwcLG9p3bx5007RSEGnsaxI/paQkKAxJhC+fj3RBw9abCv6wgs4FJApzewlITGBKzeu4GRwMm8zYsTX19d+QdmYkphERERERESkYCjfCgavh57zwK9yyv0dP7B9TLbk7A61n4A+P8Grx6HrJCjXKu1jQs/C9okwvTVMbQFbPoebp2wTr+RrHklKz4eGhtovEBHJ0+7cuWN+St7d3d3O0YhITnJwcEhRjUlJTGIvGsuK5G9J/3/tUUCnTUuMieHa5xMstjmXL4fvk0/YKaKC48D1A1RyqmSxzaOQR4FKqFMSk4iIiIiIiBQcBgPUegxG/A1dvgTP/+aTr/kolG1m39hsycMPmjwLz66Glw/CQx9A8bppH3P9GGz6BL5pBN+1g53fwO0LtolX8p2kTxBeu3aNa9euER0drZL9IpIhiYmJhIWFceXKFfM2b+80pk0VkXyhSJEiFuu3bt0iMTHRTtFIQaaxrEj+YzQaiY6ONv9/+q7ChQvbMSr7uTV7DnEXLK/5+L/8MgbnNCp7S7bYcHYDtTxqWWwrU7yMnaKxD6f0m0hWRUZGMmXKFBYtWsSpU6eIiYmhbNmydOnShZdeeony5cvfV/+JiYls376dNWvWsHPnTo4dO8atW7dwc3OjXLlyPPDAAzz//PPUq1cvzX7Gjh3LuHHjMnTOTZs20b59+/uKW0RERERExO4cnaHpEKjXG3ZNgTpPpd721CYIuwj1+5imZ8tvCpeHtq+YlmvH4MgSOPQb3Eqj4tLlINOy7l1TNac6T5qqPHkWtVXUkse5ubnh4+PD7du3AVMlhZs3b2IwGArU04UFidFoJDY2FoDw8HAMBoOdI5K8LCEhweJGsbu7O56ennaMSERsIXkSU2JiIiEhISm2i+Q0jWULFo1jC4bk40swTWXq6upqp4jsJ+7KFW58953FNvdGjfB+5BE7RVRwJCQmsO/CPuoWtnzQsKCNdZTElENOnjxJQEAAJ06csNj+zz//8M8///D999+zYMECunbtmuVzVKhQgfPnz6fYHhcXx5EjRzhy5Ajfffcdr776KuPHj9c/qiIiIiIiIsm5ekH7N1Pfn5gAa96C68GmykMd3oMaXUwVnfIj/xrg/za0fwsuH4DDv8Hh3yEsjYpL53aaltVvQKV2UKe76TNy97VZ2JI3lSxZEhcXF65fv27eZjQaiY+Pt2NUklMSExO5c+cOYKqY4+CgAvGSPdzd3SlXrpyufYoUAM7OzhaJI2BKHiloN/Ykd9BYtuDQOLZgKlasWIH99+XaF19ijIq6t8FgoMS772i8bQP7ru7jSPgR3gx/k6puVannUY9OZToVuGQ6JTHlgPDwcLp06WJOYBo6dCi9e/fG3d2dTZs28emnnxIWFkavXr3YsWMHDRo0yNJ5Ll26BECVKlV46qmnaN26NaVKlSIqKopNmzYxadIkQkJC+Pzzz3F0dOR///tfun0eOnQozf0VK1bMUqwiIiIiIiJ50sFfTQlMYJpO7Zd+UKYpdBwLFdrYNbQcZTBAqQampeOHcGG3qTrT0aUQcd36McYEOLXRtPzhAlX+D2o/DtUeBrdCtotd8gyDwUDRokUpVKgQd+7cISIigtjYWE0Lk0/Fx8ebbzr7+Pjg5KTLkpJ1jo6OuLu74+3tjaenp26oiBQgRYoUSZHEZDQa9XdAbE5j2YJD49iCwcHBARcXFzw9PfHy8sLFxcXeIdlFxK5dhP3xh8U23+7dcatVK5UjJDutPL0SgAQSOBZ9jET3RN5r+J6do7I9/ZXNARMmTOD48eMAfP7557z22mvmfS1btqR9+/a0a9eOyMhIRo0axebNm7N0nmbNmvHBBx/QqVOnFAP0Nm3a0LdvX1q2bMn169eZMGECQ4YMoVKlSmn2WadOnSzFIiIiIiIiku/Ex8ImKw+DXNgDc7pAlY7w0PtQsr7tY7MlBwco18K0PDwezmyFQ4sheAXE3LZ+TEIs/LPStDi6mj4rJTRJKlxcXPDz88PPz8/eoUgOCgsLY/ny5YDp+lihQvpbICIimVekSBH+/fdf87rBYCAmJgY3Nzc7RiUFmcay+Z/GsVJQJEZFcfn9Dyy2OXh7U2z0KPsEVMDEJMSw/sx6i21dKnWxUzT2pXp32SwuLo7JkycDULNmTcaMGZOiTatWrRg8eDAAW7ZsYc+ePVk6186dO+ncuXOqTxhUrlyZ999/HzBlCS9dujRL5xERERERESmQHJ2h6yQoUdf6/pN/wncPwG/Pws1Tto3NXhydoHIHePxbeO0E9F4IdZ4CZ4/Uj0mIMSUzLRkKE6rAwr5wcBHEhNsubhERERHJFzw8PChWrBjly5encePGNG/eXAlMIiIi2eD65G+IO3/eYluxUS/jpCRNm9h6YSvhcfeulRkwEFAxwI4R2Y8qMWWzTZs2mUsKDhgwINV5UQcOHMh3330HwO+//07Tpk1zJJ4HH3zQ/PrUqQJyUV1ERERERCQ7GAxQtaMpaefIEtj4MYScTtnu8GI4ugy3Or3xNPoRYfCyfaz24OQKNQJMS2wE/LMaDi+Bk+tNlZisuZvQdLdCU9X/g1qPQ/WHwdXbpuGLiIiISN5US1PaiIiIZKuoQ4e5NXeuxTb3Ro0o3KePnSIqeFb+u9JivUmJJpTwLGGnaOxLSUzZbPv27ebX7dq1S7VdkyZN8PDwIDIykh07duRYPDExMebXjo6OOXYeERERERGRfMvBAep2h1qPwf55sOUzuHPVsk1iPC4Hf2QYTux1agbRfaEglZh38TR9RnW7Q1Qo/LMKjvwOpzZBYpz1YxJi4NgfpkUJTSIiIiIiIiIiNpcYE8Plt9+GxETzNoOzMyU//ghDKgVbJHvdjrnN1gtbLbZ1qVgwp5IDTSeX7Y4ePWp+XaNGjVTbOTk5UaVKFQCCg4NzLJ4tW7aYX9esWTPd9p06dcLf3x8XFxf8/f1p374948ePJyQkJMdiFBERERERyRMcnaHpYHgpEB56H1x9UjRxJp6W8TvxntUaLu63Q5C5gLsvNOgL/RaZppx7bCpU7QQOzqkfczehackQ+Lwy/NxPU86JiIiIiIiIiOSwa19+ScyJExbbir4wHNdKlewUUcGz7uw6Onh34IXiL9Dcqznejt78X4X/s3dYdqNKTNnswoULAHh6euLr65tm27Jly3Lw4EGuX79OTEwMrq6u2RpLZGQkX331FQCurq489thj6R6zfv168+vr16+zZcsWtmzZwmeffcacOXMy1Ic1dz+X1Fy+fNn8OiIigrCwsCydRyQ73Llzx+prEXvRd1JyE30fJTfR91Hsqv5QqNYd1z3TcAn8AUNCjMXuBGcPIt3LQIH/beMIlR81LdGhOJ9ah9PxlTid3YohMd76IUkqNBkdXYmv0J64al2Ir9RRFZoyQX8jJbfRd1Jyk4iICHuHICIiIiJid3e2bSNk3nyLba41alBk8GA7RVQwLT6+mCc8n6CESwlqudciwZhAxM0ICpUsQFXek1ASUzYLDzc9Jerl5ZVuW09PT/PrO3fuZHsS0xtvvMG5c+cAGDFiBKVKlUq1bd26dXn88cdp1qwZpUqVIi4ujn/++YcFCxawbt06QkNDeakk9IsAAOgJSURBVOqpp1ixYgWPPPJIpmMpW7ZshtsuWbIEH5+UTzSL2MP8+fPTbyRiQ/pOSm6i76PkJvo+iv0Uxsv5OVqzjXoJB3DACMDamMYcnjnbzrHlVi1wdalP1YQT1EgIpkLiaRxJtNrSkBCD86m1OJ9aSzyOnHGoyHHH6pxwrEq0wcPGcedd+hspuY2+k2Jvt2/ftncIIpIDjEYjBoPB3mGIiIjkCfE3b3LprbctthlcXSk94XMMLi52iqrgOXrzKKFhoZQoXcK8zdHgiIdHwb3upSSmbBYdHQ2ASwb+j500aSkqKipb41iwYAFTpkwBTNPIffzxx6m2HTVqFGPHjk2xvXnz5vTv35/vvvuO559/noSEBIYMGcKpU6dwc3PL1nhFRERERETyqjsGb9a6BLA7sTlt47dSNPE6RxzrpNq+WOI1rhuKQQG+wRJjcOewUz0OO9XD1RiVoYQmJxKokniSKoknSYwzcM6h3H8JTdW5Y1CFJhEREZGCKDo6mmvXrnH9+nV8fHyoUqWKvUMSERHJ9YwJCVx6400Sbtyw2O7/+mu4Vq1qp6gKpt+O/0Yjz0YW21xdXSlUqGBWYYICnMSUHdn4s2fPZuDAgRbb7ib3xMbGpnt8TMy96Qbc3d3vO567Nm/ezOD/Srz5+fmxePHiNPtPb9q7YcOGsWfPHmbNmsWlS5dYvHgx/fr1y1RM58+fT3P/5cuXadasGQBPPvkk1apVy1T/Itnpzp075qdCn3nmmQxVVhPJSfpOSm6i76PkJvo+Sm5j+k4WwdkYy9P9B1j9TjrcPI7n3I4klGpCTOvXSCjb0g6R5l4RUSH3ppw7ty3VKeccMFIh8SwVEs/SKW4d8SUbE1/1YeKqPIzRt4Jtg86l9DdScht9JyU3OX78OJ9++qm9wxCR+3Tp0iVOnDhhXo+NjaVy5cqqxiQiIpKO6998Q8T27RbbvNq1o3DfvnaKqGCKjItk5b8reb346xbbixUrVqDHMwU2iSmneHubnv68c+dOum2Tzr2eXRdu9u7dS7du3YiJicHLy4tVq1ZRs2bN++532LBhzJo1C4AtW7ZkOompTJkyGW7r6elZoDMLJXfx8vLS91FyFX0nJTfR91FyE30fJTeJM7ik/p1c/TVgxOnSHpwW9YRK7aHD+1Cmsa3DzJ0KFYLiQ6HVUIi8Bf+sgiNL4d/NkBiX6mFOl/fhdHkfbls/geJ1oeajpsW/ZoGueHWX/kZKbqPvpNibp6envUMQkWzg4+NjsR4bG8vt27fTfXBbRESkIAv/809uTv/OYptj0aKU/N8nBTpxxh5Wn15NUYeiFHUuarHd39/fThHlDgU2iSk4OPi++yhZsmSKbWXKlOHvv/8mIiKC0NDQNAfLd6sTFStWzGJquaw6cuQIDz/8MOHh4bi6urJ06VKaN29+3/0C1KpVy/z64sWL2dKniIiIiIhIgXIpCIKXW277d7NpqR4AD74DJVKfhq7A8fCDhk+blqhQOLHO9Pmd+BPi05iS/eoh07L5f+BX2ZTMVKsblGqkhCYRERGRfMTT0xNPT0+LB8avX7+uJCYREZFUxPx7mktvvGm50cmJMl9NwqlIEfsEVYD9dvw3GntaPtjo7u5e4CsXF9gkpho1auRIv7Vq1WLx4sUAHDt2jBYtWlhtFx8fz6lTpwCypVLSqVOn+L//+z9u3ryJk5MTv/zyCw899NB993uXsi5FRERERETuU1QI+JaD0HMp9/2zCv5ZDXWehPZvQ9Eqto8vN3P3hXo9TUtsJJzaAMEr4J81EHM79eNunYIdX5mWQmWgZldTUlO5luDgaKPgRURERCSnFCtWzCKJ6dq1a1SuXBkHBwc7RiUiIpL7xIeEcH748yQm+XcToPgbb+DRpImdoiq4gm8Gc/TmUfqU6WOxvaBPJQegUVw2a9Omjfn1li1bUm23d+9e88C6devW93XOCxcu0LFjRy5fvoyDgwNz587lscceu68+kzt69Kj5dalSpbK1bxERERERkQKh8oMwch90+RK8SlhpYITDi+HbZrBshPVkJwEXD1Mi0pMz4LWT0G8xNBoAHkXTPi7sAvw9HeZ0gS+qwdIRcGylKSlKRERERPKk5NOtxMfHc/PmTTtFIyIikjslRkdzYfgLxJ21vNZUqNujFH66n52iKtgWBC+ghnsNfJwsp8ct6FPJgZKYsl379u3N8zDPnTsXo9Fotd2cOXPMr5944oksn+/atWt07NiRM2fOADB9+nT69u2b5f5S89139+bFbNeuXbb3LyIiIiIiUiA4uUDTIfByEHT6GDyslOo2JkDgjzC5Eax8FcKv2DzMPMPJBap2hG6T4dXjMHAVNH8eCpVO+7jIGxD0I/zcFz6vBAv7wP55cOe6beIWERERkWzh7u5uvidz15UrGj+LiIjcZUxM5NLrbxAVFGSx3bVWTUqOG1fgq/7Yw/XI66w8vZIWXpazenl7e+Pp6WmnqHIPJTFlMxcXF1566SUAgoOD+eKLL1K02bVrF7NmzQJMCUFNmza12pfBYMBgMFChQgWr+0NDQ+ncuTP//PMPAJMmTWLo0KGZivfQoUOcPHkyzTYzZszg+++/B6BEiRL3lXQlIiIiIiIigLM7tHoRXj4AD74Lrj4p2yTGwZ6Z8HUD2PCRzUPMcxwcoUJreOQzGH0Ehm6ENqPBr3Lax8VHmabzW/4ifFEVZnWC7V/B9eM2CVtERERE7k+JEpZVTm/dukVsbKydohEREck9jEYjV//3KeHr1llsdypZkrLTpuPg7m6nyAq2n//5GVdcqetR12J78eLF7RRR7uJk7wDyo/9n787j27rq/P+/ryTLluXdlrxviZ29WdqkbdqmKVCWSSlM+wVaCkw7ZRso05aBlu/MMAPzhaFfSudboCzTDh0KJWwFOj+gMHRa0tKdtGn2xXYSx7sleZW8avv9cRMlqiVnsy0vr+fjcR6Wzjn36qPkxnakt86566679LOf/UwNDQ26++671dTUpBtvvFEOh0Pbtm3TV77yFYVCITkcDn39618/p8cYGxvTNddco53HE5Mf+MAHdPXVV2vv3r1Jj3E6naqtrY3re+211/SRj3xEb3rTm/QXf/EXuuCCC1RYWKhQKKSDBw9q69atevL4NzWr1aqHHnqI9B8AAAAATJX0bGnzXdKGD0svPmBudxZ8w/ZmoRFppC819c1VhiGVX2S2t3xB8hyQDvzGbN17JjkwKrW+YranviAV1klLt0jLrpEqNphBKQAAAMwqRUVFamxsVCQSifV1d3ersrIyhVUBAJBa0WhU3n/7N/X96Edx/ZasLFU++O9KK2bbslQYDY3q54d+roucFynNSIv1G4bBVnLHEWKaBtnZ2XriiSe0ZcsWNTY26qGHHtJDDz0UNycnJ0dbt27V2rVrz+kxOjs79eKLL8bub926VVu3bp30mM2bN+uZZ56Z0B8Oh/XUU0/pqaeeSnpsYWGhHn74YV177bXnVC8AAAAAYBKZBdLVX5Au/YT0/P3S9oel8Jg5ZsuQrrwrtfXNZYYhFa8w21Wfk3qPSod+b66+dOxFc/u+ZHqapBe/abbMImnJO6RlW6RFb5LsmTP3HAAAAJCUzWaTy+VSd3d3rK+rq0sVFRVskQMAWLB8Dzygnu89HN+ZlqaKbz2gjCVLUlMU9Jsjv1H/WL8uLYjfSq6oqEhpaWlJjlpYCDFNk7q6Or3++uv69re/rccee0xNTU0aHx9XZWWltmzZojvuuEPV1dWpLlNbtmzRww8/rJdeekmvv/66uru71dPTo2g0qoKCAq1Zs0bveMc7dMsttygnJyfV5QIAAADA/Jbllt5xj7TxNulPX5Ne/5G04SNSTmni+ePDZkgnjeW/z1hBrbTxk2Yb7pUan5QOPiE1PS0Fh5IfN+yTdv7IbDaHtPhN5ipNS94hZblmrn4AAABMUFJSEhdiGh4elt/v530NAMCCE41G5fvud+X7znfjBywWlf3fe+S89NLEB2LaRaIRPbr/UZWllakqvSpu7I3b4y5khJimkdPp1N1336277777nI6PRqNJx2pqaiYdP1Nut1u33nqrbr311vM+FwAAAABgiuRWSNd+Q7r8DikjL/m8l78t/fl70qa/ky68WUrLmLES54XMAmnNjWYLjkrNz5mBpkO/lwJdyY8LjZgrOR36nSTD3Gpuyduk+rdLJReYwTIAAADMmNzcXGVkZGh0dDTW19XVRYgJALCgRKNRee79mnq///34AcNQ6b/+q3KvuSY1hUGS9Hz78zo6cFT1GfXqHO9Uqd380KLdbld+fn6Kq5s9LKkuAAAAAAAAJFGwyAzaJDI6IL34LTNs8/u7pW+uk/78H1JobGZrnC/SMqT6t0rXfl36uwPSR/8obfqs5F5xmgOjUtufpT9+WXpwk3T/Suk3d0gHfyeNT7KyEwAAAKaMYRgqLi6O6/N4PAqHJ9k6GACAeSQaCqnzH/5xYoBJUskXv6i86/5y5otCTDQa1X/s/g9JUuNoo/6141/1E/9PVFpaqvLycrbAPQUrMQEAAAAAMBe98qA02n/yvr9D+t1npefvN1dmWvchyZaesvLmNItFKr/IbG/5J6n3qLk606HfScdelKKTvBk22C699ojZrOlSzRXSkrdL9W8zt7IDAADAtCgpKdGxY8di98PhsLxeL9uzAADmvcjwsNo/e5cCf/zjhLHiz39e+Te8LwVV4VSvdL2ind6dcX1vX/p2LalfkpqCZjFCTAAAAAAAzEXd+xL3D7ZLT3xGeu5+6crPSGs/KNnsM1vbfFNQK238pNmGe6XG/5EOPSE1PS2NB5IfFx6TDj9ttt/fLRUtOR5oertUdalkTZu55wAAADDPZWRkKD8/X319fZKk/Px8ZWSw3TIAYH4LdnSo9bZPaezAgfgBq1Wl//pl5f3lX6akLsT7913/Hne/zFmmdy5+Z4qqmd0IMQEAAAAAMBe97wfmqkDP3CMd/dPE8cE26befPiXM9AFCM1Mhs0Bac4PZQmNS83NSw5NSw39L/ccmP9bXYLYXH5DSc6XFbzJDTXVvlbJcM1M/AADAPFZRUSGn06mysjI5HI5UlwMAwLQa3rFDbZ/6W4V7e+P6jfR0ld9/v7Lf/KYUVYZTbe/arte6X4vr+8jqjyjNwut0iRBiAgAAAABgrqq+TLr5N1Lz89K2e6Rjz0+cM9Ai/eYO6bl/k668S1rzfsJMU8WWLtVdbba/+KoZUGr4g9T4pNTykhQJJT92bEDa/19mkyGVX2iu0LTkbVLJGnNLOwAAAJyVgoICFRQUpLoMAACmVTQaVd+Pf6zu//tVKRiMG7NkZ6vyO99W5oYNKaoOb/Tgrgfj7pc4S/Tuxe9OUTWzHyEmAAAAAADmuporpL9+wlyRads9UsuLE+f0t0i//lszzLTlPqn+rTNf53xmGJJrqdkuv10aHZAO//F4qOl/pGHfJAdHpfbXzPbMVySnW1r8ZjMctfhNkrNoxp4GAAAAAACYvUJ9fer8/D8p8PTTE8bstbWq+M63lV5bm4LKkMiO7h16pesVpRvpKreX68jYEX141Ydlt9pTXdqsRYgJAAAAAID5ovZKqWaTdPRZM8zU+vLEOX3NEi+UTL+MXGnldWaLRKSOHccDTX+QOndNfuyQR9r9U7PJkMrWSovfYoaaKtazkhYAAAAAAAvQ0Ct/VsfddyvU3T1hzLlpk8r/7T5Zc3JSUBmS+e6u70qSLs66WDcU3qCuYJc2Zm1UKBSSzUZcJxH+VAAAAAAAmE8MQ1p0lVS72VwJ6Jl7pLbtJ8erLzfDTpg5FosZPqpYL735H6XBTnPLucYnpcPbpODQJAdHpY7XzfbcfVJ6jvn3V3e1VPcWKa9qxp4GAAAAAACYeWG/X577/k39P/tZwvGCW2+V+zN/J8NqneHKMJkX21/Uy53mBww3ZW+SJJWklejo4aMKDAa0YsWKVJY3axFiAgAAAABgPjIMM+Sy+M1S09PmNmXtr0lX/b05lshAm5RVIll5uWBa5ZRKF91sttCYdOwFqeFJqeG/pb6jkx87Nigd/K3ZJKloyfFVmt5iBtTsmdNfPwAAwBwSjUbV09Mju92uHFanAADMMf6nnlLX//mSQh7PhDFrQYHK7vmKsjZvTkFlmEwkGtH9O+6XJC1OX6wye1nceElJSSrKmhN4VRIAAAAAgPnMMKT646v2tL4iVV2aeF40Kv3k/dKYX9r0GWnNjWxbNhNs6WbQbPGbpb/4v1LPYTN0dvhp6ehzp1mlSZKvwWyvfFeypkvVl0l1V8tScon5d5ossAYAADDPjY+Pq7OzU52dnRobG1NhYaFWrVqV6rIAADgjo4ca5Pna1zT0/PMJxzM3Xqqyr35VaW73DFeGM/HEkSd0sPegJGlzTnzIzOFwKD8/PxVlzQmEmAAAAAAAWAgMI3mASZIa/iB17TZv//pT0rP3SlfcKa37oBm0wcwoXGy2Sz5mrtLU8rIZaGp6WureO/mx4THpyDbpyDZlSfqEka2jlkWyHSyTVrxDynLNyFMAAACYDXw+n5qbm2P3e3p6NDw8rMxMVq4EAMxewW6PvA98UwO/elyKRCaMG5mZct9xu/I/9CEZFksKKsTpjIXH9MDrD0iSCm2FWpu5Nm68tLRUBh86S4oQEwAAAAAAC100Kv3p3vi+gRbpib+T/nSfdPkd5tZnaY7U1LdQ2dKlRZvN9tb/I/m7pMN/lJqekg5vk0Z6Jz08J+rXmvAu6Xefkn4nqfiC4+e7SqraKKVnzcjTAAAASIXi4mIdPXpUoVAo1tfW1qYlS5aksCoAABIbb2tTz8MPa+CXv1J0fDzhHOemTSr5whdkryif4epwNn5y4CfqHOqUJF2Vc5UsxsmwmdVqVWlpaapKmxMIMQEAAAAAsNCN9JlBpkT8HdJ/f0567t+ky2+X1t8q2Z0zWx9M2SXS2pvMFglLHTuPr9L0lNS2XYpO/IRmnO49ZnvpW5LFJlVcfDLUVH4R2wcCAIB55cSbhK2trbG+7u5u1dTUyG63p7AyAMBc4dm1S7sefFDenTs17vfLnp0t19q1WvPxj8u9Zs2UPMbI3n3qe/SHGvjtE1I4nHCOze2W+67PKued72QFn1luYGxAD+15SJLksDh0WdZlceMlJSWy2YjpTIY/HQAAAAAAFrrMAumjfzQDMc9+TWp9eeKcIY/05Oel5++XNt4mbfiolJEz87XCZLFKFReZbfPd0ki/dPRZM9DU9EdpsG3y4yMhqeVFsz1zj2TPkqovNwNNizZL7hXmFoQAAABzWHl5udra2hQ9HtiPRCLq6OhQTU1NagsDAMxqndu3a9udd6rjxRcnjHW89JJ2ffe7Kr/8cl11//0q3bDhrM9vDQZVcfiIPH/1VwoePJR0npGZqcIP36rCv/5rWdgOdU74zs7vyD/ulyRdkX2F0i3pceMVFRWpKGtOIcQEAAAAAADMwErd1dLit0jNz0nP3mt+faPhHunp/yO98E3p0k9Il3xccuTPfL2I58iTVrzbbNGoAs2v6ZUf36Oa8FEtsnbKCA5Pfvx4QGr8g9kkyemWaq88GWrKq5ruZwAAADDl0tPT5Xa71d3dHevr6OhQZWWlrFZrCisDAMxWh594Qr95z3sUGh2ddF77Cy/oZ1deqWt/8Qstvuaa0543HAgo8Myz6v3dE3r7s3+SLRxWMNnktDTlXX+9im77pNLc7rN/EkiJg70H9dNDP5UkWWXVVdlXxY27XC5lZGSkoLK5hRATAAAAAAA4yTDM8ErtldKxl6Q/3Ssd/uPEeaP95go+L31b+uCvpMqz/+QhpolhKFK4RK/aLtartov1iY99WDmDjdKRZ8zVmtq2mysxTWbII+39hdkkqWCRGWiq3Wyu2JTlmu5nAQAAMCUqKiriQkzBYFDd3d0qKytLYVUAgNmoc/v2MwownRAaHdVv3vMe3fCnP01YkSkaDmt0/wEN//kVDb30sob//GdFx8clJQ9pGA6H8m+4QQV/fYvSiovP56lghkWiEX355S8rEo1IktY71yvXlhs3p7KyMhWlzTmEmAAAAAAAQGLVG6UPPS61vWaGmRr+e+IcW4ZUsmrma8OZs9rNv8vqjdKb/l4a85sBtROhpu69pz9H7xGzvfqf5n3XMjPMVHOF2bL4ZCgAAJidsrKylJ+fr76+vlhfW1ubSktLZbB9LgDgFNvuvPOMA0wnhEZHte2OO3T9I49o7NAhjR44qLGDBzSyd58ig4NndA5bWany3vMe5b///bLls9r1XPT/Nf1/2uXdFbv/lty3xI3n5uYqOzt7psuakwgxAQAAAACAyVVcJN30M6lzl/Snr0kHfnNy7PI7pDRH6mrD2UvPlpa8zWySFPCaYaYjz0hHnpUGWk5/Du9Bs736sHm/aEl8qCm7ZNrKBwAAOFsVFRVxIaaRkRH19PSoqKgohVUBAGYTz86d6njxxXM6tuOll7TrbW9XzllsFRYxDGVu2iTXB26S84orZLDN6Zw1MDag+1+7P3Z/ecZyldnjV3ysqKiY6bLmLEJMAAAAAADgzJSukW74kdS9T/rTfVLz89L6v04+/7VHpJpNUuHiGSsR5yDLJV3wHrNFo1LfUTPMdOQZ6eifpJHe05/D12C2175v3i+sOx5q2iTVXC7lsF0LAABInfz8fDmdTg0NDcX6WlpaVFhYyGpMAABJ0q6HHjqv41sG+rUq4zQf6ElLU/qG9XrFMNRVVaUPf/rTysrJOa/HReo98PoD6hs7GZZ+W97b4sYdDocKCwtnuqw5ixATAAAAAAA4O8Urpfd+39yWzO5MPKfnsPTbT5u3V7xbuuLTZggKs5thSAWLzLb+r6VIROreczLU1PqKNB44/Xl6msy24wfm/YJF5gpN1VeYoaZcPoEIAABmjmEYqqys1MGDB2N9fr9ffX19KigoSGFlAIDZwrtz53kdPzg6lrDfXlurzEsvkfOSS+TcuFFDhqGW7373vB4Ls8cu7y79/NDPY/edFqdK00vj5lRUVBCaPguEmAAAAAAAwLlJz04+9sI3pGjEvL3vcbPVXW2GmaovN8MymP0sFjN8VrpGuvx2KRw0txVsft5sLS9L4/7Tn6f3iNl2/NC8n19jhpqqLpOqLjVDTlwTAABgGrlcLjU3N2t0dDTWd+zYMeXn5/PGIgBA4/4z+L/tJEKRiGwlJcpYvlwZy5cpfflyOVavVlpxcfzEwcHzehzMHqOhUX3++c8rqmisL2yEte6idbIMWdTS0qJIJKKSktOs0IU4hJgAAAAAAMDUGuyUdv1kYn/TU2aruFja9HdS/dvNkAzmDmuaVLHebFfcKYVDUtcuqfmF46Gml6SxM3hBtq/ZbK//yLzvdEtVl0iVl0pVG6XS1eZjAQAATBGLxaKqqio1NDTE+gYHB9Xf36/8/PwUVgYAmA3s2ZN8UOsMZF+4TvXPbJuiajAXfGfnd9Q82BzX9zdr/kZl2WVStlRcXKzR0VFZeO3rrBBiAgAAAAAAU8uWLl36SWn7w4lX6Wn7s/STGyX3CnNlppXXS1ZeopiTrDap/CKzXX67FAlLXbuPr9T0gnTsRWls4PTnGfJIB35jNkmyOcygVOUlZqipcoOUkTu9zwUAAMx7xcXFOnbsmMbGzC1/nE4nqzABACRJrrVr1fHSS+d8vPvCC6ewGsx2u7y79IP9P4jrW1W4SjevvDl23zAMORyOmS5tzuMVQgAAAAAAMLUyC6S3/osZUNr+Penl70rDvonzPPulX31U+uOXpMtul9Z9UErjxZ05zWKVytaZ7bK/PR5q2iMdO75S07EXpNEzCDWFRqTm58wmSTKk4pUnQ01Vl0i5lWxBBwAAzsqJ1Zg6OztVXV2twsJCQkwAAEnSmo99TLu++91zPn71xz42hdVgNjuxjVwkGon1pVnS9OUrviybhQjO+eJPEAAAAAAATA9HnnTlZ81VmXZulV74pjTQMnFef4v0u89Kz35VuvQT0oaPShk5M14upoHFKpWtNdvG28xQU/e+k6Gm1lekIe8ZnCgqde8126sPm13ZZVLVpSebeyUregEAgNMqLS1VaWkp4SUAQBz32rUqu+wydbz44lkfW3755XKvWTMNVWE2+vbOb0/YRu6Taz+pxXmLU1PQPMMrOwAAAAAAYHrZM6WLPypddIu095fS8/dL3oMT5w15pW1fkS54HyGm+cpilUpXm+3ST0jRqNR7RGp5WWp9WWp5RfIdOrNz+Tukfb8ymyTZs6TyC6Xy9eZWdOXrpezi6XsuAABgTiK8BABI5k1f/7p+duWVCo2OnvExNodDV91//zRWhdlke9d2/WBf/DZylxddrvfWvDdFFc0/hJgAAAAAAMDMsKZJa240Q0oNv5ee+39S+6vxc1bfIOVVpqY+zDzDkAoXm23dB8y+4V5zhaaWl8xQU8cOKTx++nONB6SjfzLbCblVUsVFJ4NNpWvYshAAAAAAkFDphg269he/0G/e854zCjLZHA5d+9hjKt2wYQaqQ6r1jvbqc3/6nKKKxvrSLGn667K/1s4dO1VUVKSqqiplZ2ensMq5jxATAAAAAACYWRaLtOwaaekWc0ux5/+fdPiPkgzp8juTHxfwSlmumaoSqZJZIC39C7NJUnBU6tx5MtTU+rI00ndm5xpoMdu+x837FptUvOrkSk0VG8wAFSsyAAAAAAAkLb7mGt3wpz/pmU9/Wu0vvJB0Xvnll+uq++8nwLRARKIR/ePz/yjviDeu/zOrPqPRQTPw5vP55PP5tHz5crnd7lSUOS8QYgIAAAAAAKlhGFLtJrN17DQDTa4lieeOBaRvXWSupHPZ7VLd1QRPFoq0DKnqUrNJUiQi9TSaW9Cd2Iau98iZnSsSMgNRnTul7d8z+zLypPKLTgk2rTeDVAAAYEHp6+uT1+tVfX09W84BwAJXumGD3v/88/Ls2qXdDz0kz86dGvf7Zc/OlnvtWq3+2MfkXrMm1WViBj26/1E93/58XN9lZZdppbFSAxqI9dlsNhUU8JrC+SDEBAAAAAAAUq9srdmSef1H0ujAye3CXMuly/5WuuA9ki19pqrEbGCxSK6lZrvoZrMv4JHath9vr0odr5vby52J0X7p8NNmO6FgkRloKlsrla6VSldL6SwHDwDAfDQ4OKijR4+qv79fklRQUKCioqLUFgUAmBXca9bo6m9/O9VlIMX2ePfo6699Pa6vMKNQf3/B3+vYoWNx/VVVVbLZiOGcD/70AAAAAADA7BYOSS+/4UVD7wHp//uk9PT/kS75uLT+ryVHfmrqQ+pluc0tCpddY96PhCXvQTPQ1P6q1Paa5NkvKXpm5+s9YrY9Pz/eYUiFdSdDTWVrpZLVUkbOlD8VAAAwc6LRqA4cOKDR0dFYX3NzswoLC1mNCQAAaGBsQHf96S6FoqFYnyFDX7niK+pp74mbm56ervLy8pkucd4hxAQAAAAAAGa33iNScDTxWKBLevpfpD/dJ134V9Kln5Dyq2e2Psw+FqtUvNJsJ1ZrGvObKzS1vSq1v2au2hToPsMTRs0t7HoapT2PnewurDsZajqxYlNG7tQ+FwBASg0PD+tb3/qWHnvsMR0+fFhjY2OqrKzUNddco9tvv13V1ef3e0dzc7Nqa2vPaO7NN9+sRx555LweD/EMw1BNTY0OHjwY6xsaGpLH41FxcXEKKwMAAKkWjoT1uec+p/ZAe1z/Ry74iOrt9dof2B/XX11dLYvFMpMlzkuEmAAAAAAAwOzmWiLducdcFefFb0m+QxPnBIekV74r/fkhaeVfmlvNla2b8VIxi6VnS7VXmk2SolFpoO34Sk3HW+dOKZQkMJdIT5PZ9v7iZF/B4vgVm0rXEGwCgDmqqalJW7ZsUWNjY1z/oUOHdOjQIX3ve9/T1q1b9c53vjNFFWIquN1utba2amhoKNbX3Nwsl8vFG5EAACxg39r5Lb3Q/kJc3zr3On1izSf0+muvx/U7HA6VlJTMZHnzFiEmAAAAAAAw+6VlmCstrf2g1PQ/0osPSM3PTZwXDUt7f2m2mk1mmKnurRJvQOGNDEPKqzTbyuvMvnBQ6t5nBps6Xpc6dplbF0ZCk5/rVL2Hzbb3lyf7ChaZ28+VrJKKLzBXiMqtMGsAAMxKfr9f11xzTSzA9NGPflQ33nijHA6Htm3bpnvuuUeDg4O64YYb9MILL2jt2rXn/Zhf/vKX9e53vzvpeH4+W+dOB8MwVFtbq71798b6RkdH1dnZyZYwAAAsUE82P6nv7fleXF9BRoHuvfJe+Tw+jYyMxI3V1tayFe0UIcQEAAAAAADmDotFWvJ2s7XvMMNM+/9LikYmzm1+zmwfeVqqWD/jpWIOsqaZqyeVrT3ZFxw1g02dr0sdO83VmjxnG2w6Yrb9/3WyLyNPKl5lBppKVpm33culNMdUPBMAwHn62te+poaGBknSvffeq7vuuis2tnHjRl111VXavHmzhoeHdeedd+qZZ54578csLy/XqlWrzvs8OHsFBQXKycnR4OBgrO/YsWMqLi6WzcZbaQAALCT7e/br8y98Pq7PZtj0/676f3JluLR9z/a4saysLBUVFc1kifMav3kBAAAAAIC5qfxC6b3fl/q+IL3879KOH5rbyp2qYoNUflFq6sP8kJYhVVxkthOCo5Jn38lQU8fO48Gm4Jmfd7RfOva82U4wLFJh3SnhpgvM2zllrNoEADMoGAzqm9/8piRp+fLl+sxnPjNhzmWXXaYPf/jDevDBB/Xss89q+/bt2rBhw0yXiilyYjWmXbt2xfqCwaBaWlq0aNGiFFYGAABmUtdQlz719Kc0EopfaelzF39OFxVfpObmZo2NjcWNsQrT1CLEBAAAAAAA5rb8Gukv/q+0+W7pte9LrzwoBbrNscv+Nnn4IzjCqjc4N2kZZjju1IBcaOz4ik07T4abuvefXbApGpF8DWbb96uT/Y7848GmU1ZuKloq2TOn6AkBAE61bds2DQwMSJJuvvlmWZJsS3vLLbfowQcflCQ9/vjjhJjmuLy8PBUUFKi3tzfW19bWptLSUjkc/M4IAMB8NxQc0m1P3ybviDeu//r663XD0hs0Njam1tbWuLG8vDy2/J1ihJgAAAAAAMD8kFkgbfqMtPFT0p7HpP2/lpa9M/HcaFT6j7dIeZXSpZ+Qajez0g3Ojy3dXB2s/MKTfaExc4Wmzp1S114z5NS9VxobTHqahEb6Tm6PGGOYAT7XMsm11PzqXiYVLZHszil4QgCwcD3//MlV8jZv3px03vr165WZmanh4WG98MILM1EaptnixYvV19enaDQqSYpGozp69KhWrFiR4soAAMB0CoaD+syzn1FDX0Nc/4aSDfr8JZ+XYRg6evSoIpFI3PjixYtZhWmKEWICAAAAAADziy1dWvdBsyVz5BlzOzDPPqnhvyX3SjPMdMF7zVV2gKlgS5fK1prthGhU6m85GWjq3msGnHqPSIqexcmjUt9RszX8Pn4or0pyLT8ZbjoRdErPOv/nBAALwP79+2O3ly1blnSezWZTXV2ddu/erQMHDpz34z7wwAP68pe/rLa2NqWnp6uiokKbNm3Sxz72MV144YWnPwHOW2ZmpsrKytTe3h7r83q96u/vV15eXuoKAwAA0yYSjegfX/hHvdAeH0qvyanR/VfdrzRrmvx+v7q7u+PGS0tLlZXF/7OnGiEmAAAAAACw8Lz83fj7nn3Srz8lPfVFaf2t0oYPS9klKSkN85xhSPnVZlu25WT/WEDyHpS69hwPN+0z29mu2iSZIan+FqnxD/H9uZVvCDYtk1xLpIzc83tOADDPtLW1SZKcTudpgyuVlZXavXu3vF6vxsbGlJ6efs6Pu2PHjtjtsbEx7d+/X/v379eDDz6oj3/84/rGN75xTuc/8XyS6ezsjN32+/0aHDyHnz3nIBAIJLydagUFBerq6lI4HI71NTQ0aOnSpay0MAfM1usKcxfXFKYa19TsEo1Gdf/u+/X7o/EfDsqz5+mrl3xVxpihwbFBRSIRlZaWqru7W5FIRBaLRYWFhTP2e9PppOq68vv9U35OQkwAAAAAAGBhGemX2v6ceGzYJ/3pXun5+6VV/8tcnenUVXSA6ZKeJVWsN9sJ0ajUf8wMM3Xtlbr3mLd7j5zbYwy0mq3pqfj+7DKpqF4qrDv+tV4qXGyu6GSxnvtzAoA56sSbMWfyyXqn8+QWnoFA4JxCRnl5ebruuut01VVXqb6+XhkZGers7NSTTz6phx9+WIFAQA8++KD8fr+2bt161uevrKw847mPPvqocnNnPtz66KOPzvhjTqa4uFi1tbWx+yMjI/rlL38pr9ebwqpwtmbbdYW5j2sKU41rKvV2O3drd/buuD5rxKpLOi/Rbx79zYT5aWlpqqys1MjIiF588cWZKvOszOR1NTAwMOXnJMQEAAAAAAAWFkee9Ol90s4fS6/8u9TTNHFOJCjt/qnZqi4zw0zLriHQgZllGFJ+jdmWXXOyf3xI8jVI3kPm6k2eg+bXvmad3ZZ0x/k7zHb02fh+a7pUsEgqqjMDToX1J8NOmQXn/rwAYJYbHR2VJNnt9tPOPTW0NDIyctaPdWLrsszMzLj+devWacuWLbrtttt09dVXq6WlRT/+8Y91ww036F3vetdZPw7OjsfjUXFxcdzfi8vlIsQEAMA8ste5d0KAyRK1aHP/ZrmCroTHBINBHTlyjh8swhkhxAQAAAAAABYeu1O6+KPS+g+bq9K8/B3pyLbEc1teNFtupbnN3IU3E+BAatmdUtk6s50qOJIk3HRUikbO/nHCY5L3gNneyFFgrtaUX2sGnWKtVsosNANYADDNpmJrr+9///u65ZZb4voyMjIkSePj46c9fmxsLHbb4XCc9ePb7fZJw1L19fX60Y9+pCuvvFKS9MADD5x1iKm1tXXS8c7OTl188cWSpA996EMqLy8/q/Ofq0AgEFsp4EMf+tAZrXw1kwYHB3X48GFZLBaVlJRozZo12rx5c6rLwmnM9usKcw/XFKYa19Ts8KOGH2nnvp1xfYYMfeHiL+jqiqtTU9R5SNV11d7ernvuuWdKz0mICQAAAAAALFwWi7TkbWbr3i+98l1p18/M8MYbDbRKT33R3HprzQ0zXipwWmkOqXSN2U4VHJV6Gk8JNx0wb/cekaLhc3uskV6prVdq2z5xLD3HDDOdEnCyZhQrK+pXQLxAD2D2y87OlmS+GXQ6Q0NDsdvT9WbRpk2btGLFCu3fv1/PP/+8IpGILBbLGR9fUVFxxnOzs7OVk5NzLmWel6ysrJQ87mRO1ON2u89oVS7MPrPxusLcxjWFqcY1lRr/ufc/9d19353Q//lLP6/rl16fgoqm1kxeV4ODg1N+TkJMAAAAAAAAklS8QnrXA9JbviC99n3pz9+TAl3xc5wuaeVfpqQ84JylZUglF5jtVKExcztFX8Pxr01m2MnXJI0NnPvjjQ1KnbvMdpxT0m2SQrLK+P7PpYIaKb9ayqs+5WuN5MhnFScAZ+zAgQQrxZ2l0tLSCX0VFRV65ZVXNDQ0pP7+fuXl5SU9/sQqRy6XK25rual2IsQ0Ojqqnp4euVyJtzjB1DqbABgAAJjdotGovrXzW3po90MTxv7hkn/Q+5a+L27uyMjIhC1/Mf0IMQEAAAAAAJzKWSRdeZd02R3S/v+SXvq21LnTHLvoryVbkjcoe4+a23xluWeqUuD82NKl4pVmO1U0Kg35zGBTT6Pka5R6Dpu3e49KkeC5P6TCUt9hsyViz5byquIDTrmVUm6F+TWzgJATgJhly5ZNy3lXrFihX/7yl5KkgwcP6tJLL004LxQK6fBh8/vZ8uXLp6WWE6Zi6zwAAICFKhKN6Kt//qp+fPDHE8b+98X/W+9f9v64Pp/Pp/3796usrEy1tbWy2YjWzBT+pAEAAAAAABKx2aXV75MueK/U9qr054ek9bcmn/8//yQ1/EFaeb10ycek8otmrlZgKhmGlOUyW/XG+LFwSOo/Zoaa+o6aW9KdaH3HzivgJEka90uefWZLxOY4HmhK1CqlnHJz5SkAOA9XXHFF7Pazzz6bNMT06quvxraTu/zyy6e1pv3790uS0tPTVVhYOK2PBQAAMJ8EI0F98cUv6teHfz1h7O4Nd+sDyz8Q1xcKhdTU1CRJ6ujokNfr1ZIlS1RUVDQj9S50hJgAAAAAAAAmYxhS5QazJdPfKh18QopGpN0/NVv5eunij0or/pJQBeYPq00qXGy2N4qEpYG2U0JNR82Vm3qPKNp7REZo9PwfPzRirgjV05h8jtMl5ZRJ2aWntBLza87x+44CyWI5/3oAzEtXXXWVcnNzNTAwoB/84Ae6++67E66E9Mgjj8RuX3fdddNWzwsvvKB9+8xw5xVXXCEL379Szu/3a2BggO3mAACY5fzjfv3dM3+nlztfjus3ZOifN/6z3rPkPROOOXbsmMbHx2P3g8GgIpHItNcKEyEmAAAAAACA8/Xqw2aA6VTtr0qPvyr9999L6z4orf9rqWBRauoDZoLFam7/ll8tLX5T3JB/YECPfvdryo3063+9eb0cY16pv9lcvan/mDTQLkXDU1PHkNdsnbsmqTXtZLDp1K85ZfH303PYvg5YgOx2u26//XZ96Utf0oEDB3Tffffprrvuipvz0ksv6eGHH5Ykbd68WRs2JA47nwg/VVdXq7m5ecL4f/3Xf+nd73530u3impqadNNNN8Xuf/KTnzyXp4QpEgqF1NzcrPb2dklSbm6usrOzU1wVAABIpGuoS5946hNq6m+K67cZNt2z6R69o/YdE44JBAJqa2uL68vLy5PL5ZrWWnESISYAAAAAAIDzFQ5K1nQpPDZxbKRXevGb0osPSHVvkTZ8RKp/mxn4ABYKw1DAyFbAmq3giuvlyMmJHw+HpMF2M9B0ItjU32LeHmiT/B0Tg4LnIxKUBlrNNpk0pxlmynJLziJzladYe8P9jDxWdwLmkbvuuks/+9nP1NDQoLvvvltNTU268cYb5XA4tG3bNn3lK19RKBSSw+HQ17/+9XN+nOuuu051dXW6/vrrdfHFF6uiokLp6enq7OzUH/7wBz388MMKBAKSpPe97326/vrrp+gZ4mxFIhG99tprGh09ubJgQ0ODLrzwwqQhNAAAkBq7vLv06W2flnfEG9fvsDl03+b7dGXFlROOiUajamyMX/XXMAzV19fzs34GEWICAAAAAAA4X2//V+mKT0s7fiBtf9gMY0wQlZqeMltupXTRzdKFN5vhCGChs9pOruJUm2A8HJICXWagaaDteACpLf7+6MDU1xUcknoPm+10DKuUWZgg4PTG8FOh5MiX0nMJPQGzWHZ2tp544glt2bJFjY2Neuihh/TQQw/FzcnJydHWrVu1du3a83qspqYm3XvvvZPO+cQnPqH777//vB4H58disai0tFRHjx6N9QUCAXV0dKi8vDyFlQEAgFM93vi4vvTylxSMBOP6CzIK9J23fEcri1YmPK6rq0uDg4NxfVVVVcrMzJy2WjERISYAAAAAAICp4CySNn1GuuwO6dATZpjp6LOJ5w60Sn/8svTMV6X1t0pbJn/jEljwrDYpt8JsyYwOmgHCgTbJ3yn5u6TBDvOrv9NsAY+k6PTUGA1LQx6znRFDcuSZKzg58o+3U25P1p+WMT3PAUCcuro6vf766/r2t7+txx57TE1NTRofH1dlZaW2bNmiO+64Q9XV1ef1GL/+9a/10ksv6ZVXXtGxY8fk8/k0NDSknJwcLVq0SJs2bdKtt96qVatWTdGzwvmoqKhQd3e3hoeHY31HjhxRYWGhMjL43gwAQCoFw0F97dWv6ScHfzJhrDa3Vt95y3dUkZ34/5RjY2M6fDj+wysZGRmqqqqallqRHCEmAAAAAACAqWS1SSvebTZfo/Tqf0o7tyZeJSYSlDJyJvYDOHsZOWZzL08+JxwyQ0b+Tmmw82TYyd9lbll3IvA00jcDBUfNxxnpk/qOnn76qWyOk+GmjDwpPUuyZ0np2SebPcvsT8+W7Cf6T8zLMW/b0qfjiQHzitPp1N1336277777nI6PRicPTl577bW69tprz+ncmHkWi0X19fXatWtXrC8SiejQoUNavXo1W80AAJAibf423f2nu7XHt2fC2CUll+jfrvo35abnJjw2Go2qoaFB4XA4rr++vl4WVs+dcYSYAAAAAAAApktRvfSOe6Q3/5O095fSqw9LHa+fHDcs0kW3pKw8YMGx2qScMrNNtvNPcOSUcFOnNOSThrxmG/bF35+ObexOJzQi+UfM4NX5sNpPCTvlmLftmWZIKs1hrvhkO/41LVOyZRzvdyTujxs/fttqlyzWqXneADAL5OXlqbS0VJ2dnbG+/v5+dXV1qbS0NIWVAQCwMD117Cn98wv/LH/QP2Hsr1b8lT590adlsySPxng8HvX29sb1FRcXq6CgYMprxekRYgIAAAAAAJhu9kzpwg+Zrf01aft/Snt/IS1+c/LtsfqapZ99ULrwZumC95orrgCYGWkOqaDWbKcTGpOGe06Gmk4NOA29sd8jhUanv/4zFR6XRnrNNq0MyZp2PNBkM29b0o73nbhtOz5+os+W+BjDIhnG8a/JWoLxxW+Saq6Y5ucJYKFYtGiRent7NTY2Fus7fPiwCgoKlJ7OKncAAMyEoeCQ7nv1Pv2i4RcTxuwWu7542Rd17eLJV7wcHx9XU1NTXF9aWpoWL148pbXizBFiAgAAAAAAmEnlF5ntbV+SxgaTz9vxQ6lrj/S7z0pP/pO06npz1aaKDeYb9ABmB1v6ydWdTicalYLD0kj/ya3kRk+5nbR/QBpLwYpPUyZqBqbC46krwZ5JiAnAlLHZbKqvr9fevXtjfeFwWA0NDVq1ahXbygEAMM1e7XpVn3/h82oPtE8Yq86p1n2b79OygmWnPU9jY6NCoVBc35IlS5SWljZlteLsEGICAAAAAABIhcwCsyUSDkqvbz15PzQi7dxqNtdyM8y05gbJkT8jpQKYIoYh2Z1my51sP7sEwiFz67q4cFOf2TcekMYC0pj/+O3BN9z3H78/KCk6Hc9s9jMsqa4AwDxTWFio4uJidXd3x/p6e3vl8XhUXFycwsoAAJi/hoJD+tbr39LWA1sVTfB/my21W/TPG/9ZzjTnac/l9Xrl8/ni+lwul4qKiqasXpw9QkwAAAAAAACzTdPTUqAr8Zj3gPTfn5Oe+oK04i/NQFPVpazOBMx3VpvkLDTbuTqxEtSJUNO4/5SAk9+8Hxw52UKjp9wekYKj5vGhUfN2KMHc2RqSIsQEYBosXrxYfX19Gh8/udJcU1OT8vPzZbfbU1gZAADzzx9b/qivvPIVdQ93Txhz2Bz63xf/b11Xd90ZrYgYjUbV2toa15eWlqa6uropqxfnhhATAAAAAADAbFP/NulDj0uvPSIdfEKKhCbOCY1Ku39qtqIl0roPSqtvlLL55D+AJE5dCSp7Gs4fjUqhsZOBp9CIuYJUeFyKBM3bkeDxreVOvR00v8+Fj98/cTsSPN53ym1JikZO06IT+4qWTMMTBrDQpaWlqb6+Xvv27Yv1hUIhNTQ0aOXKlWwrBwDAFGgdbNW9r96rZ1qfSTh+oftCffmKL6syu/KMz2kYhlavXq2jR4+qo6NDklRXV0cIeRYgxAQAAAAAADDbWCzS4jebLeAxt5F77QdS39HE830N0v/8s/TUv0hL3iHLZZ+b2XoBQDJDUmkZZnOkuhgAmBlFRUVyuVzyer2xvp6eHnV1dam0tDSFlQEAMLf5x/16aPdD+tGBHymU4MNddotdt194uz64/IOyWqxnfX6bzab6+nq5XC75fD65XK6pKBvniRATAAAAAADAbJbllq74tHTZHVLzc+bqTAd+Y65K8kbRsNT4B0Wv+tKMlwkAALBQ1dXVqb+/X8Gg+ftZenq6HA7SnAAAnIux8JgeO/SY/mPPf6h3tDfhnI2lG/X5Sz+vqpyq8368vLw85eXlnfd5MDUIMQEAAAAAAMwFFou0aLPZhnzSzh9LO34g9TTFz1vyDkWdfHoQAABgptjtdi1ZskT79u2Ty+VSfX290tLSUl0WAABzSjAc1ONNj+vB3Q/KM+xJOKcgo0B3b7hbW2q3sG3rPEWICQAAAAAAYK5xFkmX3y5d9rdSy0vSjkel/f8lBYeldR9MftzTX5L8XeacqkvNrZ8AAABw3oqKirRu3Trl5OSkuhQAAOaU4eCwftHwCz164FF1DXUlnGOz2PSBZR/Qx9Z8TDn2c/tZG41GCT7NAYSYAAAAAAAA5irDkKovM9tffFU68Gup7q3S0PDEuaFx6dX/lEZ6pZ0/kgoWS2vfL62+Qco7/+XXAQAAFjoCTAAAnLmuoS79/NDP9bNDP9Pg+GDSeW+qfJM+u/6z57V1nN/v1+HDh7V06VK2fJ3lCDEBAAAAAADMBxk5k6/C1PB7M8B0Qu9h6Y9fNlvNJmntTdLyd0npWdNfKwAAAAAAWHAi0Yhe7nxZPzv4Mz3b9qzC0XDSuZeUXKJPrfuU1rrXntdjhsNhHTx4UMPDw3r11VdVV1enkpISVmWapQgxAQAAAAAALASvb00+1vyc2Z74jBlkWvt+M9hksc5cfQAAAPNUNBpVf3+/8vPzU10KAAApcWTgiH57+Ld64sgT6hjqmHTuOvc63bb2Nl1SesnUPPaRIxoeNlesjkQiamhokMViUXFx8ZScH1OLEBMAAAAAAMBCcO03pN0/lV7/kdTTlHhOcNics/unUk65udXc2pukovqZrRUAAGCeGBsb06FDh9TX16fly5fL7XanuiQAAKZdNBrV0YGjerrlaT3V8pT29+w/7TFXVV6lW1fdqnXudVNWh8/nU0dHfGgqKytLLpdryh4DU4sQEwAAAAAAwEKQUypd8Wnp8jultu3Szh9L+34ljQ4knj/YLj3//8xWs0m6+TcSS60DAACcMZ/Pp0OHDikUCkmSGhoalJWVpczMzBRXBgDA1BsODuvV7lf1UsdLer79eTUPNp/2GIfNoWsXXaublt+kxXmLp7Se0dFRHTp0KK7PYrFo+fLlslgsU/pYmDqEmAAAAAAAABYSw5AqLzbbO/6v1PB7aedPpKanpGg48THZpQSYAAAAzlIoFIoFmCQpHA7rwIEDWrduHW+eAgDmPN+IT7u8u8zm2aXdvt0KRUKnP1BSXV6dblh6g9656J3KsmdNeW2RSET79++P+zksSYsXLyZMPMsRYgIAAAAAAFio0jKkldeZLeCR9jwm7fqJ1LUnft7a9yc/R9deybVMsvIyEwAAwKlKSkrU39+v7u7uWF8gENDhw4dVX892vQCA2S8ajapntEdt/ja1+FvU1Nekhv4GNfY2yjPiOatzFWYUasuiLbp20bVaVrBMxjR+WOrIkSPy+/1xfS6XS6WlpdP2mJgavLoEAAAAAAAAKcstbbzNbF17zTDT7p9LFptUuznxMWN+6XtvkdJzpFX/S1r9XqnsQlZtAgAAOK6+vl5+v1/Dw8Oxvo6ODuXm5srtdqewMgDAQvVi+4sKBAMaDY9qJDii0fCohkPDGg2Najg4rN7RXvlGfOod7VX3cLdGQiPn/FjuTLfeXPlmvbnqzdpQskE2y/RHVHw+n9rb2+P6HA6HlixZMq3BKUwNQkwAAAAAAACIV7JKKvlX6ep/kfqaJYs18bwDv5VCo2Z75btmK1gsrX6fdMF7pcLFM1o2AADAbGO1WrVixQrt2LFDkUgk1t/Q0KCsrCy2tAEAzLjPPfc59Y/1T8u5bYZNq12rtbFsoy4vu1wri1bKYszcFqojIyM6dOhQXJ9hGFqxYoVsNuIxcwF/SwAAAAAAAEjMapOK6pKP7/n5xL7ew9Iz95it7EIz0LTyOim7ZPrqBAAAmMWcTqfq6+vj3lQNh8Pav3+/LrzwQlksM/fmLgAADptjykJMmbZMXeC6QGtca7TWtVYXFV+kzLTUBHQjkYgOHDigUCgU119XV6esrKyU1ISzR4gJAAAAAAAAZy8clEYHJ5/TscNs//33UvXl0qrrpOXvlrJcM1MjAADALFFSUqL+/n51d3fH+oaGhtTU1KQlS5aksDIAwEKTYcs462PSLGkqzypXTU6N6vPrtSR/ierz61WTUyNrstWbZ9iRI0fk9/vj+lwul0pLS1NUEc4FIaZpNDw8rG9961t67LHHdPjwYY2NjamyslLXXHONbr/9dlVXV5/X+Zubm1VbW3tGc2+++WY98sgjp533k5/8RN///ve1e/du9ff3q7i4WJs2bdJtt92mjRs3nle9AAAAAABgHrGmSR99WvI1Srt/Lu15TOo7mmRyVDr2vNl+d7dUu0m66BZzhSYAAIAFor6+Xn6/X8PDw7G+zs5OZWVlqaysLIWVAQAWkoqsCkWjUTlsDjlsDmXYMpRhzZAjzaEMa4byM/JV5ChSoaNQRRlFqsiukDvTPaPbwp2trq4utbe3x/U5HA4tWbJEhmGkqCqcC0JM06SpqUlbtmxRY2NjXP+hQ4d06NAhfe9739PWrVv1zne+M0UVxhsZGdF73vMe/e53v4vrb2lp0datW/WTn/xE//zP/6wvfOELKaoQAAAAAADMSkX10pv/UXrTP0jtr5mBpn2/koa8iedHw9KRZyT3SkJMAABgQbFarVqxYoV27NihSCQS629qapLT6VRubm4KqwMALBTfufo7qS5hyr1xBSbDMLRixQrZbERi5hr+xqaB3+/XNddcEwswffSjH9WNN94oh8Ohbdu26Z577tHg4KBuuOEGvfDCC1q7du15P+aXv/xlvfvd7046np+fP+nxt956ayzA9KY3vUl33HGHysrKtGfPHn3lK1/R4cOH9cUvflGlpaX62Mc+dt71AgAAAACAecYwpIr1Znv7V8yg0p7HpINPSOP+ifNXXZ/8XMFRKe3sl7cHAACY7ZxOp5YuXaoDBw7E+qLRqPbv368LL7xQ6enpKawOAIC5qa6uTk6nU01NTYpGo1qyZImysrJSXRbOASGmafC1r31NDQ0NkqR7771Xd911V2xs48aNuuqqq7R582YNDw/rzjvv1DPPPHPej1leXq5Vq1ad07F//OMf9dOf/lSSdO211+rxxx+X1WruW7lhwwa9613v0kUXXaSWlhZ97nOf03vf+97ThqIAAAAAAMACZrVJ9VebLTgqNT1lrs506PdScFjKrZLKL0p8rL9L+uaF0uI3ScvfJS19h5TBqgQAAGD+cLvd8vv9amtri/WNj4+rqalJK1euTGFlAADMTYZhqKysTE6nU319fSopKUl1SThHs3fTwjkqGAzqm9/8piRp+fLl+sxnPjNhzmWXXaYPf/jDkqRnn31W27dvn9Ea3+i+++6TJNlsNn3nO9+JBZhOKCoq0le/+lVJUn9/v773ve/NeI0AAAAAAGCOSsuQlr9Tes9/Snc1Se/5vvTmz5srNyWy//+TgkPSwd9Kj39Munex9KP3SDt+KA31zGztAAAA02TRokVxHxjPzc1VfX19CisCAGDuy83NVU1NTarLwHkgxDTFtm3bpoGBAUnSzTffLIsl8R/xLbfcErv9+OOPz0RpCfn9fj399NOSpKuvvloVFRUJ511//fXKycmRlNp6AQAAAADAHGZ3mtvIrbkh+Zy9v4q/HwlKTf8j/fpvpfvqpR9cK23/nuTvnt5aAQAAppFhGFq+fLkyMjJUXl6uNWvWyG63p7osAACAlCLENMWef/752O3Nmzcnnbd+/XplZmZKkl544YVpryuZ7du3a3x8XNLk9drtdl166aWxY4LB4IzUBwAAAAAAFpDhXqn9teTj0bB09E/SE5+R/m2p9J/vkF76jtTfOnM1AgAATJG0tDRddNFFqqurk5FslUoAABDH7/drZGQk1WVgmhBimmL79++P3V62bFnSeTabTXV1dZKkAwcOnPfjPvDAA6qrq1NGRoZyc3O1cuVK/c3f/I127NgxJfWeOh4KhdTY2HjeNQMAAAAAAMTJLJA+2yC9+ztS/dsl62SrEUSllpekP/y99PVV0kNvknb/fMZKBQAAmAo2my3VJQAAMGeMjo5q79692rFjh3p7e1NdDqYBvxlNsba2NkmS0+lUXl7epHMrKyu1e/dueb1ejY2NKT09/Zwf99Sw0tjYmPbv36/9+/frwQcf1Mc//nF94xvfSHj+E/VKSrqV3Kn1ntDa2qoVK1accX2nPk4inZ2dsdtDQ0MaHBw843MDUy0QCCS8DaQK1yRmE65HzCZcj5htuCYxm8zt69EmLb7WbGN+2Y48pbTG38vWvE1GaDT5YR07NOo5onFeU5iV5vY1iflmaGgo1SUAwBmJRCKKRCIEnQAAkLnYyt69e2M7Te3Zs0e1tbWqrKxkRcN5hN96ppjf75ckZWVlnXau0+mM3Q4EAucUYsrLy9N1112nq666SvX19crIyFBnZ6eefPJJPfzwwwoEAnrwwQfl9/u1devWpPWeSc1vrPdsnBqAOp1f/epXys3NPavzA9Pl0UcfTXUJQByuScwmXI+YTbgeMdtwTWI2mR/X4zql2Vaq1nJES8MHtTjcpHSNT5j16PYe9b723YmHR6NaFDmiFkuVQkbaDNSLycyPaxJz2cDAQKpLAIDTCgaDsd00LrjgAlksbK4CAFi4otGo9u/fP+EDCX19fWeVRcDsR4hpio2Omp8ItNsnW+7cdGpo6Vz2bCwrK1N7e7syMzPj+tetW6ctW7botttu09VXX62Wlhb9+Mc/1g033KB3vetdCes9k5rPt14AAAAAAIBzFTTsarAuU4N1mazRkGoiR7U0fEh14QY5NKoeo0C9lqKExxZFvXrv+M8UlE3Nllo1WpeoyVqnEcOZcD4AAEAqjYyMaO/evRoeHpYkNTY2asmSJawyAQBYkKLRqJqamtTX1xfXn5mZqRUrVvDzcZ5ZsCGmqbiQv//97+uWW26J68vIyJCk2BJmkxkbG4vddjgcZ/34drt90uBRfX29fvSjH+nKK6+UJD3wwAMTQkwn6pVOX/P51Nva2jrpeGdnpy6++GJJ0vXXX68lS5ac1fmBqRQIBGKfCv3Qhz50RiurAdOJaxKzCdcjZhOuR8w2XJOYTRbS9RgMBxVpfVGO0Ig+UfeOhHPsL39DelFKU0j1kUbVRxoVDRoKl61XaPFbFap9syKFSyRe+Jw2C+maxOzX0NCge+65J9VlAEBC0WhU+/btiwWYJKmrq0sOh0NVVVUprAwAgNRob29XR0dHXF9aWppWrVqltDRWW55vFmyIabpkZ2dLOrPt1k5d6my6XrjZtGmTVqxYof379+v5559XJBKJW3L0RL3S6Ws+n3orKirOeK7T6VROTs5ZnR+YLllZWVyPmFW4JjGbcD1iNuF6xGzDNYnZZEFcj/nXTj7e/PSELkNR2Tq2y9axXXruK1JulbTkbVL926XaTVLa2X/gDGdmQVyTmNWcTlZhAzB7GYahpUuXaufOnYpEIrH+o0ePyuFwyOVypbA6AABmls/n0+HDh+P6DMPQypUrz2mhGMx+CzbEdODAgfM+R2lp6YS+iooKvfLKKxoaGlJ/f7/y8vKSHn9idSKXyxW3VdtUOxFiGh0dVU9PT9wvuKeGi9ra2rR+/frT1iuJfSUBAAAAAMDcEBqT7FmSYZWi4eTzBlqk7d8zm80h1V4pLXm72XLP/MNZAAAA5ys7O1vLly/Xvn374voPHjyo9PR0wsAAgAXB7/cnzHUsW7ZMubm5KagIM2HBhpiWLVs2LeddsWKFfvnLX0oyf5m89NJLE84LhUKxxODy5cunpZYTJts6b8WKFbHbBw8enPQ8J8ZtNpvq6+unpjgAAAAAAIDpZEuXbvmtNNwrNT4pHfyt1PRHKTiU/JjQiNT4B7M1vF36wM9nrl4AAABJRUVFWrRokY4cORLri0Qi2rNnj9atW6fMzMwUVgcAwPQaGRnRnj174lYllKSamhq53e4UVYWZYDn9FJyNK664Inb72WefTTrv1VdfjW3Pdvnll09rTfv375ckpaenq7CwMG5sw4YNstvtkiavd3x8XC+//HLsGPaWBAAAAAAAc0pmgbTmRumGH0l3H5Fu+rl00V9LOeWTH7fk7cnHRgentkYAAIBTVFRUTNgVJBQKaffu3RobG0tRVQAATK/x8XHt3r1bwWAwrr+4uFhVVVUpqgozhRDTFLvqqqtiS5f94Ac/UDQaTTjvkUceid2+7rrrpq2eF154Ibbc6BVXXCGLJf6vPDs7W295y1skSU899ZTa2toSnudXv/qVBgcHp71eAAAAAACAaZeWYYaTrv269Ol90t+8IL3ln6XKSyXjDS+X1b8t8TnCQen+ldJ3L5ee/CfpyDPm1nUAAABTxDAM1dXVKT8/P65/bGws4Zu7AADMdaFQSHv27NHo6Ghcf25urpYsWTLpLlSYHwgxTTG73a7bb79dknTgwAHdd999E+a89NJLevjhhyVJmzdv1oYNGxKeyzAMGYahmpqahOP/9V//lTQkJUlNTU266aabYvc/+clPJpz32c9+VpL5DeG2225TOByOG/f5fPrc5z4nScrLy9NHPvKRpI8JAAAAAAAwpxiGVLJK2vQZ6cN/kO46LF3/H9Kq90jVV0h5lYmPa9sujQ1K3XulF78p/fDd0ldrpK3vlV7+d8nXJE3yug0AAMCZsFgsWrlypbKzs+P6h4eHtXfv3gnv6QAAMFdFIhHt3btXgUAgrt/pdGrVqlUTFmzB/GRLdQHz0V133aWf/exnamho0N13362mpibdeOONcjgc2rZtm77yla8oFArJ4XDo61//+jk/znXXXae6ujpdf/31uvjii1VRUaH09HR1dnbqD3/4gx5++OHYP/D3ve99uv766xOe581vfrNuvPFG/fSnP9Wvf/1rvfWtb9Wdd96psrIy7dmzR//6r/+qlpYWSdJXv/rVCYl/AAAAAACAeSOzQFr9PrNNpunpiX3BYanxSbNJUl6VtPgtUt1bpNorpYzcqa8XAADMe1arVatWrdLOnTs1MjIS6x8cHNT+/fu1cuVK3tgFAMx5hmHI6XRqYGAg1peRkaHVq1fLZiPaslDwNz0NsrOz9cQTT2jLli1qbGzUQw89pIceeihuTk5OjrZu3aq1a9ee12M1NTXp3nvvnXTOJz7xCd1///2TzvnP//xPDQ4O6ne/+522bdumbdu2xY1bLBb90z/9kz72sY+dV70AAAAAAADzQusrp5/T3yK99n2zGVapbJ20aLNUu1mq2STxZiMAADhDdrtdq1ev1uuvv67x8fFYf29vrxoaGrR06VK22AEAzGkntlG12+1qbm5WWlqaVq9eLbvdnurSMIMIMU2Turo6vf766/r2t7+txx57TE1NTRofH1dlZaW2bNmiO+64Q9XV1ef1GL/+9a/10ksv6ZVXXtGxY8fk8/k0NDSknJwcLVq0SJs2bdKtt96qVatWnfZcDodDTzzxhH784x/rkUce0a5du9Tf36/i4mJt2rRJn/rUp7Rx48bzqhcAAAAAAGDe+NDjUtur0uGnzVWZOl6XNMn2cdGw1P6q2V7/kfSZQzNWKgAAmB9OrEaxc+dOhUKhWP/g4KBCoZDS0tJSWB0AAOfPMAxVV1fLbrcrKytLDocj1SVhhhFimkZOp1N333237r777nM6Phqd5IUvSddee62uvfbaczp3MjfddJNuuummKT0nAAAAAADAvGNNk6o3mu3Nn5eGeqQj26TDfzRDTYGu5MfWXiklWymhY6dky5BcS5PPAQAAC5bT6dSqVau0e/duRSIRZWVl6YILLiDABACYV0pLS1NdAlKEEBMAAAAAAABwvpyF0gXvMVs0KnXvO7lKU8tLUvjkti+q3Zz8PE990QxDZZWYYaeay6XqK6TCxYSaAACAJCk3N1fLly9XR0eHVqxYIZuNt/sAAHNPKBTiZxgm4IoAAAAAAAAAppJhSCWrzHb5HdL4sNT6snTkWenos2Y4KZHQmNTysnk70CXt+bnZJDPUVH3ZyVATKzUBALCgFRUVqbCwUAa/DwAA5qCOjg4dO3ZMq1evltPpTHU5mEUIMQEAAAAAAADTyZ4pLX6z2SbT+mcpNJJ4LNAl7fuV2SQps+h4qOkKqfpyyb1Cslimtm4AADCrTRZgikajBJwAALNSV1eXGhsbJUm7du3S6tWrlZWVleKqMFvwygYAAAAAAAAwG4z0STnlZzZ32Ccd+LX0+7ulf79c+toiqemp6a0PAADMCZFIRAcOHFBXV1eqSwEAIE53d7cOHToUux8MBrVr1y6Nj49PchQWElZiAgAAAAAAAGaDFe+Sll8r9Rw2t5079oLU/IK5CtPpjPRJeTWJx0Lj0nhAyiyY0nIBAMDsE4lEtH//fvX09Mjr9cowDBUXF6e6LAAA5PV6dfDgwQn95eXlstvtKagIsxEhJgAAAAAAAGC2MAypqM5sGz4sRaNS7xGp+fmToabBtonHZRVLhYsTn7PlJemH75KKlkpVl0iVl0iVl5rz2WYGAIB5IxKJaO/everr64v1HTx4UIZhyO12p7AyAMBC5/P5dODAgQn9lZWVqq6uTkFFmK0IMQEAAAAAAACzlWGYYaPCxdJFN5uhpv5jZpjp2AtmuKn/mFR9efJAUusr5lffIbPt+KF5P7PIDDRVXSKVr5fK1kp254w8LQAAMPUMw1BWVlZciEmSDhw4oGg0yopMAICU8Hg8CQNM5eXlqq2tlcGHa3AKQkwAAAAAAADAXGEYUn6N2dZ9wOwbaJOCo8mPaXk5cf+wTzr0hNkkybBK7hVSxUVS+UVmsMm1VLJYp/IZAACAaWIYhmpraxWJRNTe3h43dvDgQUUiEZWWlqaoOgDAQtTV1aVDhw5N6C8rK9PixYsJMGECQkwAAAAAAADAXJZbkXwsGpW6957ZeaJhqXuP2V57xOwrWS39zXPnXSIAAJgZhmFo8WJzi9k3BpkaGhoUiURUXl6eitIAAAtMZ2enGhoaJvSXlpaqrq6OABMSIsQEAAAAAAAAzFeGId25V+raba7I1PqK2QLdZ3a8e0XysaanzK+l6yRn4fnXCgAApsSJIJNhGGpra4sba2pqUiQSUWVlZYqqAwAsBO3t7WpqaprQX15ezgpMmBQhJgAAAAAAAGA+s9mlivVm06fM1Zn6ms0wU8vLUturkmefFI1MPLb8ouTn3XaP1P6qeTunQipbK5WulUrXmLez3FP+VAAAwJkxDEOLFi2SxWJRS0tL3NiRI0cUiURUXV2douoAAPNZa2urjhw5MqG/oqJCixYtIsCESRFiAgAAAAAAABYSw5AKas225kazb3xI6txlBpraXzPbQKtUkSTEFA7Fb1M32Ga2g7892ZddGgs12fKWKCvqV0BZ0/a0AABAPMMwVFtbK4vFoubm5rix5uZmRSIR1dTU8GYyAGDK+Hy+hAGmqqoqfubgjBBiAgAAAAAAABY6u1OqvsxsJ/i7pcyCxPN9h6TQ6OTn9HeareH3ypR0m6QhZSr9F89Jmz4t1V89VdUDAIBJVFdXy2KxTHhTuaWlRaFQSHV1dbypDACYEgUFBSosLFRPT0+sr6amhtX/cMYsqS4AAAAAAAAAwCyUXSxZ0xKPBUekig2SzXFWp3RqWLaW56XgUPJJh/8oDXaY294BAIApUVlZqbq6ugn9HR0dCVfMAADgXFgsFq1YsUIFBeYHYhYtWkSACWeFlZgAAAAAAAAAnJ2K9dJHnjK3lfM1SJ07ze3oOnZKXXsmDylJUvGqxP0Br/TodeZtR4FUvFJyr5DcyyTX8ZZsdSgAADCp8vJyWSwWNTQ0xPrsdrvKy8tTWBUAYL6xWCxauXKlent7VVRUlOpyMMcQYgIAAAAAAABwbqw2qXiF2dbeZPZFwlJP08lQU+cuRTt3yhgPSJKiNoeM/NrE5+vee/L2SK/U/JzZTuV0S66lknu5+dW1THItl5yFU//8AACYZ0pLS2W1WnXw4EFZLBZdcMEFysjISHVZAIB5xmKxEGDCOSHEBAAAAAAAAGDqWKzHw0VLpdXvkyT5B/r1k+/cI3fUo3dcuUEOiyXxsd37Tn/+IY/Z3hhuyiySPvykVLj4PJ8AAADzm9vtVlpamgzDUFZWVqrLAQDMQaOjo2psbNSSJUuUnp6e6nIwjxBiAgAAAAAAADC9DIv6LQXqV4HesvqDciSbFxyW7FnS8VWbzspwj5Rdmnis43XpT/dJhXXxzVkkGcbZPxYAAHNcfn5+qksAAMxRQ0ND2rNnj8bGxrRnzx6tXbtWNhvRE0wNriQAAAAAAAAAs8Pmu6VNn5UGWqSuvebKTN6DkveQ1NMohceTH5tfLdkzE4917pYO/nZif0buyUBTwWIpv+Zky3ITcAIALEjRaFSHDx9WQUGBCgoKUl0OAGAW6e/v1759+xQKhSSZgaa9e/fqggsukNVqTXF1mA8IMQEAAAAAAACYPSyWk0Gi5e882R8OSX1Hj4eaDkqe4+EmX4MUHpNcy5Kfs6cpcf/ogNT+mtneKC1TyquWChZJN24l0AQAWDCam5vV3t6u9vZ21dfXq6ysLNUlAQBmga6uLjU0NCgajcb1B4NBhUIhQkyYEoSYAAAAAAAAAMx+VptUVG+25dee7I+Epb5mKRxMfmyyENNkgsOS94C5tV2yANP+X0sHfi3lVhxvlSdvZ+Se/WMCAJBi7e3tamlpid1vbGzUyMiIFi1aJINALwAsSNFoVM3NzXE/H07IycnRqlWrlJaWloLKMB8RYgIAAAAAAAAwd1msUuHiyeeseb8Zfuo5bAaaeo9MvjXdqfJrko+1bZf2PJZ4LD3nlHDTKSGnnHIpp1TKLpXSHGdWAwAAMyAajWpgYGBCf1tbm0ZGRrR8+XJW2QCABSYcDuvQoUPyer0TxgoLC/nZgClHiAkAAAAAAADA/LbiXWY7IRKWBlolX5MZauppNFdz6muW+o5JkVNWdcqvTn7egbbkY2ODkme/2RIprJf+9tXEY74maaRXyiqWskskW3ryxwEAYIoYhqHly5fL4XBMWG2jp6dHO3fu1KpVq5Sezs8lAFgIxsfHtXfvXvn9/gljFRUVrNKHaUGICQAAAAAAAMDCYrGaKyzl10j1V8ePRcKSv/NkqClvshBT67nXkFOafGz796RXvnvyvqNAynJLTpfkLDr+9Y23j99Pz0m+/R0AAKdhGIZqa2vlcDjU0NCgaDQaGwsEAnr99de1atUqZWVlpbBKAMB0Gxoa0t69ezU6OjphrL6+XmVlZSmoCgsBISYAAAAAAAAAOMFiPbn9W80Vk8+98Gap8hIzzDTQZrZA95k9TvYkISZ/Z/z9kV6zeQ+e/rxlF0of25Z4rPkFM5jlyJ/YbPYzqxsAsCCUlJQoIyND+/btUygUivWPjY1p586dWrp0qVwuVworBABMl56eHh04cEDhcDiu32q1asWKFSooKEhRZVgICDEBAAAAAAAAwLm48EMT+0Jj0mD7yVDTQFt8yGmgXQoOmdvEJXOmQahEHHnJx3b9RHr90cRjaU4zzJSRK6VnT2yFi6X1tyY+dnTAXMEqLdPc+o6VoABgXsjLy9O6deu0Z8+euJU4wuGw9u/fr6qqKtXU1LCVEADME9FoVC0tLWpubp4wlp6ergsuuEBOp3PmC8OCQogJAAAAAAAAAKaKLV0qWGS2ZMb8ZugnGYtNsmVIoYlbN5yW0518bKQv+VhwyGyDbYnHqzYmDzE99S/Sqw8fv2OYYSZ7ppTmMG+nOcyQVJrDbHan+edkTZfyqqTLPpX4vJ27JF/j8bl2yZomGRbJsJorZsVuW97QbzVXlprs7wAAcEYyMzN14YUXau/evRocHIwba2lpUSAQ0PLly2Wz8ZYjAMwHw8PDE/qys7O1atUq2e2s3orpx28UAAAAAAAAADCT0rMnH7/lt1I0Ko32S/5uc3u54R4p4JGGvMebL/52cMg81lmU/Lwj/dNTc3DklDvRk4GoM1F2YfIQ057HpBcfOOMS4+TXSnfsPLdjAQBx0tLStGbNGjU0NKi7O361wN7eXu3YsUOrVq1SZmZmiioEAEwFwzC0ZMkSDQ8PKxAISJJcLpeWLl0qq9Wa4uqwUBBiwqzj9XpVU1Mjh8OR6lIAAAAAAACA1DAMc3s3R77kXnb6+eNDZpjJlp58TlGdNO43V2Qa6ZfGBpPPfaP0nORjZxpYSsQ6yae5Q+PndMrxtBx5XVcqcOiQli5deo6FAQBOZbFYtHTpUmVlZenw4cNxY6FQiDe3AWCesFqtWrlypXbs2KHKykpVVFSwbShmFCEmzDrd3d3685//rOzsbBUXF8vlcrE0HQAAAAAAADAZu9Nsk7n2G/H3w0FpdOB4qKlPGu41t7obGzz+9ZRWsT75eeNWYjpLtkle9wufW4hp99ovaSirVurqUkVFhZzO0/y5AADOiGEYqqioUFZWlvbv369gMCjDMLRy5Uqlp08SogUAzCkZGRm6+OKL2SoUKcFVh1nL7/fL7/erqalJ+fn5Ki4uVmFhId8sAQAAAAAAgKlgTTO3n5tsC7oz8Z7vS+MBczWo4MjxNnxKG5HGT7kdHJZCo2ZIqbA++XmzSyT3Cik0ZgauwuNSNCJFw1IkfPx25PjtcOyry/O8GWKS5PF4VFtbe37PDwAQJy8vTxdeeKH27dun0tJS5ebmprokAMBZCAaDampqmnR3JN6TR6pw5WFO6OvrU19fnywWiwoLC+V2u1VQUCCLxZLq0gAAAAAAAICFLT3LbFPtqv9ttlNEo1ENDg6qv79f1dXVCQ9zDw+reft2SWaIqaamhi0wAGCKZWRkaN26dZN+f41Go3z/BYBZZnBwUPv379fY2JiGh4e1bt063nPHrEKICbPOZPsmRyIReb1eeb1e2Ww2uVwuud1u5ebm8oswAAAAAAAAME8NDQ2pu7tbHo9HY2NjkiSXy6XMzMwJcx2ZmcrLy5Pdbpfb7Z7pUgFgwZjsTe9oNKp9+/YpJydHlZWVvIcDACkWjUbV1tamo0ePKhqNSpICgYAOHz6s+vpJVkcFZhghJsw6y5YtU3FxsTwej3w+nyKRSMJ5oVBInZ2d6uzslNPp1EUXXcQvwQAAAAAAAMA8MTo6Ko/HI4/Ho6GhoQnj3d3dSbeKW716Na8VAkAKtba2qqenRz09Perv79eyZctkt9tTXRYALEjBYFCHDh1ST0/PhDGv16vq6mq+R2PWIMSEWccwDBUWFqqwsFDhcFg+n08ej0d9fX2xVOgbZWdn86IEAAAAAAAAMMcFg0F5vV55PB4NDAxMOneyreJ4rRAAUmdgYEBHjx6N3e/r69Nrr72mFStWKDc3N4WVAcDCc+r2cW+Um5ur5cuXE2DCrEKICbOa1WpVcXGxiouLYy9gdHd3a3BwMG7eZMtC9/b2Kjs7W2lpadNdLgAAAAAAAICzFA6H1dPTI4/Ho97e3qQfZDxVZmam3G63otEogSUAmGUCgcCEvvHxce3cuVO1tbVsLwcAMyDR9nGnqqqqSvqBACCVCDFhzkhLS1NZWZnKyspiS0l3d3crFAopLy8v4TGhUEh79+6VJOXn58vtdquoqEhWq3UGKwcAAAAAAACQyLFjx9Ta2qpwOHzauXa7XW63W8XFxXI6nbzhAgCzVHl5uTIzM3Xw4EGNj4/HjR09elS9vb1atmyZMjIyUlQhAMxvY2NjOnjwoPr7+yeMpaWladmyZSooKJj5woAzQIgJc1JGRoaqqqpUVVWl8fHxpC9YeL3eWLK0t7dXvb29slgsKioqktvtVn5+viwWy0yWDgAAAAAAAOA4q9U6aYDJZrPFXsvLy8sjuAQAc0R+fr4uuugiHThwYMKb6AMDA3r11VdVX18vt9vN93YAmEIej0eNjY0KhUITxk5sH5eenp6CyoAzQ4gJc95ke3R6PJ4JfZFIRB6PRx6PR2lpaXK5XHK73crJyeEXZQAAAAAAAGCKjYyMKCMjI+Frb263W4cPH47rMwxDhYWFKi4uVkFBAR9CBIA5ym63a/Xq1WppaVFzc3PcWDgc1sGDB9XT06P6+nqlpaWlpkgAmCdCoZAaGxsTvj8usX0c5g5CTJi3otGo7Ha7LBaLIpFIwjnBYFAdHR3q6OhQRkaG3G633G63nE7nDFcLAAAAAAAAzB9jY2Pyer3q7u5WIBDQunXrlJOTM2Ge3W5Xfn6++vr6lJeXp+LiYhUVFclm46VrAJgPDMNQdXW1cnNzdfDgQY2NjcWNe71eDQ4OaunSpcrPz09RlQAw9/X09CQMMKWnp/M9FnMK/xPEvGUYhpYvX65QKKSenh51d3err68v6fzR0VG1tLSopaVFTqdT5eXlKi0tncGKAQAAAAAAgLkrFArJ5/Opu7t7wtZBHo8nYYhJkhYvXiybzca2FgAwj+Xl5Wn9+vVqampSd3d33NjY2Jh2796tiooK1dbWsgIfAJwDt9stn88nn88X63O5XKx2hzmHEBPmPZvNpuLiYhUXF2t8fDz2CTC/35/0mKGhIQ0NDc1glQAAAAAAAMDcE4lE1Nvbq+7ubvX09CgajSac5/F4tHjx4oTbV7AqOgAsDDabTcuWLVNBQYEaGxsVCoXixgOBANscAcA5MgxDS5Ys0eDgoMLhsOrr61VcXJzqsoCzRogJC4rdbld5ebnKy8s1MjIij8cjj8ej4eHhCXPdbnfS80QiET4JAAAAAAAAgAUpGo2qv79fHo9HPp9vwpvQyYyMjCgzM3OaqwMAzHZutzu2vdyJlfusVquWLl1KiAkATiMSicgwjITfL9PS0rRy5UrZ7XZlZGSkoDrg/BFiwoLlcDhUXV2tqqoqBQKBWKBpfHxcDodD2dnZCY8bHx/X9u3bVVhYKLfbrfz8fH6pBgAAAAAAwLw3PDyszs7O2Gtop2O1WlVUVMRraACACdLT07V69Wq1t7fryJEjWrJkCW+4A8BpDAwMqKGhQdXV1UkX5Ei2hTMwVxBiwoJnGIays7OVnZ2tRYsWaWBgQKFQKOmLKh6PR6FQSN3d3eru7lZaWprcbrfcbreys7N5MQYAAAAAAADz0uDgoNra2iadYxiGCgoK5Ha7VVhYKKvVOkPVAQDmGsMwVFFRoaKiokkDTIFAQA6Hg58pABascDiso0ePqr29XZLU1NSkvLw82e32FFcGTD1CTMApDMNQXl7epHM8Hk/c/WAwqPb2drW3tysjI0Nut1vFxcUsjQ0AAAAAAIB5paioSA0NDYpGoxPGcnNz5Xa75XK5lJaWloLqAABz1WQBplAopD179shisWjJkiXKz8+fwcoAIPX6+/t16NAhjY6OxvqCwaCampq0YsWKFFYGTA9CTMBZGBsbk9/vTzo+OjqqlpYWtbS0KCsrK7ZCU3p6+gxWCQAAAAAAAJydcDgsn8+n7u5uVVVVJfygn81mU2FhoXw+nyTJ6XTGXv9iCyAAwHQ4fPhwbAvT3bt3q7i4WIsWLWL1EQDzXjAY1JEjR9TV1ZVwfHR0VKFQSDYbkQ/ML1zRwFlIT0/XpZdeKq/XK4/HM2mgKRAIKBAI6MiRI8rLy4t9Eo0fJAAAAAAAAJgNIpGIent75fF41NPTo0gkIsl8DSzZauWlpaVyOBwqLi6W0+mcwWoBAAtNb2/vhDfvu7u71dPTo9raWpWWlsowjBRVBwDTIxqNqqurS0eOHFEoFJowbhiGampqVFlZyfdAzEukKYCzlJ6eroqKClVUVGh4eFgej0cej0cjIyNJj+nv71d/f79GR0dVW1s7g9UCAAAAAAAAJ0WjUfX398vj8cjn8yV8Y8Tr9aq+vl4Wi2XCWEFBgQoKCmaiVADAAudwOJSbm6uBgYG4/lAopMbGRnV1dam+vl7Z2dkpqhAAplYgEFBjY6MGBwcTjufk5Gjp0qXKzMyc4cqAmUOICTgPmZmZqqmpUXV1tfx+fyzQFAwGE84vLi6e4QoBAAAAAACw0EWjUQUCAXV3d8vr9ca25UkmHA6rp6dHLpdrhioEAGAih8OhNWvWqLOzU0eOHFE4HI4b9/v92rFjh8rLy1VTU8NOGADmrHA4rObmZrW1tSUct1qtqqmpUXl5OasvYd7jpzkwBQzDUE5OjnJycrR48WL19fXFPs124pfqrKyspKnYkZERtbe3q7i4WFlZWfzwAQAAAAAAwHk701XET1VQUCC3281qSwCAWcEwDJWVlamwsFBHjhyRx+OZMKe9vV1er1eLFy9Wenp6CqoEgHMTjUbl8/nU1NSksbGxhHOKiopUV1fH9zcsGISYgClmGEZsWe1wOKze3l51d3crPz8/6TEej0ft7e1qb2+Xw+GQ2+2W2+1mKUAAAAAAAACck97eXu3Zs+eM5ubk5Ki4uFhFRUWy2+3TXBkAAGcvPT1dy5cvV0lJiRobGyeEc8fHx3XgwIHYB8qHh4dTVCkAnJ329vaEAaaMjAzV19fz4QIsOISYgGlktVrlcrkmXXo7Go3GfXJgZGREx44d07Fjx5SVlSW32y2Xy6WMjIyZKBkAAAAAAADzQF5enqxW64Std05wOp2xD9LxuhMAYK7Iz8/X+vXr1draqmPHjikajcaNBwIBXXDBBWpubk5NgQBwFgzD0OLFi/Xaa6/F9VVWVqqqqkpWqzWF1QGpQYgJSLFAIJD0EwGBQECBQEBHjhxRbm5uLNCUlpY2w1UCAAAAAABgNgmHw/L5fMrIyFBubu6EcYvFoqKiInV3d8f6MjIyYsElp9M5k+UCADBlLBaLqqur5Xa71djYqL6+vglzBgcHU1AZAJy9rKwslZWVqaOjQ3l5eaqvr2e3HixohJiAFLPb7aqqqpLH49Ho6GjSeQMDAxoYGFBjY6Py8/NVXFyswsJC2Wz8MwYAAAAAAFgIIpGIent75fF41NPTo0gkoqKiooQhJklyu93q7e2NBZeys7NlGMYMVw0AwPRwOBy64IIL5PP5dPjw4dh2TN3d3RO2mwOAVIlGo+rp6ZHValV+fn7COdXV1crNzZXL5eL3dSx4pB+AFEtPT1dtba1qamrk9/vl8Xjk8XgUDAaTHtPX16e+vj5ZLBYtX75cRUVFM1gxAAAAAAAAZko0GtXAwIA8Ho+8Xq9CoVDceE9Pj0KhUMIPuuXn52vjxo28EQIAmLcMw5DL5VJBQYHa2trU3t6utra2pPOT/cwEgOng9/t15MgR9ff3KyMjQxs2bEg4z263y+12z3B1wOzET2lgljAMQzk5OcrJydHixYvV398fe3EqHA4nPCYSiSg7O3uGKwUAAAAAAMB0ikajCgQCsQ+7jY+PTzrX5/OppKRkwhjhJQDAQmG1WmMrmTz33HMJ54TDYW3fvl05OTmqqalha1UA02Z4eFjNzc3yer2xvtHRUbW3tyddRRWAiRATMAsZhqH8/Hzl5+ervr5+wjLhJ+Tm5io9PT3hOUZGRjQ+Pq6cnBxesAIAAAAAAJgDhoeHY8GlM90GJz8/P+nrQwAALDQWiyXpWHt7u8bHx+Xz+WIB4OrqamVkZMxghQDms7GxMR07dkydnZ0Jx48dO6YVK1bMcFXA3EKICZjlLBaLioqKVFRUpFAopJ6eHnk8HvX19U26rGBHR4fa2tqUnp4ut9stt9stp9NJoAkAAAAAAGCWGRsb0969exUIBM5ofk5Ojtxut1wul+x2+zRXBwDA3BcKhdTa2hrX19XVpe7ubpWVlamqqoqfqQDOWTAYVEtLizo6OuIWpDhVenq6Fi1aJKvVOsPVAXMLISZgDrHZbCouLlZxcbGCwWDSTxREo9HY8oRjY2NqbW1Va2urMjMzY4Emh8Mxk6UDAAAAAAAgCbvdrrGxsUnnOJ3O2Os6rBgBAMDZGRoaStgfjUbV3t6urq4uVVRUqKKiQjYbb58CODPhcFhtbW1qbW1VOBxOOMdms6myslLl5eWyWq0aHByc4SqBuYWfwsAclZaWlnRsYGAg4QtfJ/ZfbW5uVnZ2duwTeyw5DgAAAAAAML3C4bDGx8cTfrDMMAy53W61t7fH9WdkZMStsA0AAM5Nbm6uLrnkErW2tqqtrW3CSinhcFjHjh1Te3u7ysvLCTMBmFQoFFJHR4daW1sVCoUSzrFYLCovL1dlZeWk7+sCiMdPX2AeCofDyszM1PDwcNI5fr9ffr9fhw8fVl5entxut4qKivghCgAAAAAAMEUikYh6e3vl8XjU09OjnJwcrVmzJuHcEyGmtLS0WHApOztbhmHMcNUAAMxPNptNtbW1Ki8vj237FI1G4+aEQiEdO3ZMbW1tsTAT75sAONXIyIh27NiRNLxkGIZKS0tVVVXFQhLAOSDEBMxDhYWFKigo0NDQkDwejzwez6RLkvf396u/v1+NjY3Kz89XXV0d280BAAAAAACcg0gkor6+Pnm9Xvl8vrhtJfr7+zU+Pi673T7huOzsbK1Zs0a5ubkElwAAmEZ2u111dXUqLy/XsWPH1N3dPWFOOBxWS0uL2tvbVVZWppqaGlkslhRUC2C2ycjIUEZGhgKBwIQxt9utmpoa3mcFzgMhJmCeMgxDWVlZysrKUm1trQYHB+XxeOT1ehUMBhMeE41G1dfXxxKpAAAAAAAAZyEajWpgYCD22kuyT2VLktfrVXl5+YR+wzCUl5c3jVUCAIBTORwOLVu2TJWVlWpubpbP55swJxwOa2BggIAxgBjDMFRdXa19+/bF+goKClRbW6usrKwUVgbMDyQVgAXAMAzl5uYqNzdXdXV16uvrk8fjmfBpQMn8IZtsadRQKCSr1cov6wAAAAAAYMGLRqPy+/2x4NL4+PhpjzEMY9LVsgEAwMxzOp1auXKlAoGAWlpa5PV648arq6t5XwRYYIaHh+XxeJL++y8sLJTT6ZTD4VBVVZWys7NTUCUwPxFiAhYYwzBUUFCggoICRSIR9fT0yOPxqLe3V5FIRG63O+mxR44cUU9Pj1wul1wul3JycvjFHQAAAAAALCiRSETNzc3yer0aHR09o2Py8vJir6ck+/AYAABIraysLK1YsUJDQ0NqaWmRx+NRdna28vPzE86PRqMaHBzkvRJgnjjxb7q1tVU9PT2SpJycHBUUFEyYaxiG1q1bJ6vVOtNlAvMeISZgAbNYLLEX0EKhkHw+nwoLCxPOjUQiseXQ29vb1d7ervT09Njx2dnZ/JIOAAAAAADmPcMw5PP5Thtgys7OltvtlsvlUnp6+gxVBwAAzpfT6dTy5ctVXV2tcDic9L0Pn8+n/fv3KysrS5WVlXK5XLxPAsxB0WhUPp9Pra2t8vv9cWNtbW0JQ0ySCDAB04QQEwBJks1mU0lJSdLxvr4+hUKhuL6xsTG1tbWpra1NGRkZcrlccrvdcjqd/KIOAAAAAADmtHA4nPCNCcMw5HK51NLSMmEsKysr9oEvh8MxE2UCAIBpkpmZmXQsGo2qtbVVkhQIBHTgwAEdOXJEFRUVKikpkc3GW7DAbBcOh9XV1aW2trakH1Do6+tTIBBQVlbWDFcHLFz8BAVwRgYGBiYdHx0dVWtrq1pbW5WZmRkLNE32Sz4AAAAAAMBsMjY2Jq/XK4/HI0m68MILE85zu92xEJPD4ZDb7eZ1EAAAFpDBwcEJK7aMjY3p8OHDOnr0qIqLi1VWVkbwAZiFhoaG1NHRoe7uboXD4aTzrFarysrKZLfbZ7A6AISYAJyRRYsWqaSkJPZC3vDwcNK5w8PDOnbsmI4dOyan0ym3262ysjI+eQAAAAAAAGadYDAor9crr9er/v7+uLGRkZGEKyo5nU4tWrRI+fn5rEgNAMACFAqFlJGRkXD1lkgkos7OTnV2dionJ0fl5eUqKiqSxWJJQaUAJPPfpc/nU0dHx2kXbkhPT2dVNSCF+FcH4IxlZmaqurpaVVVVGhoaigWaki2xKJlp5paWFpWXl89gpQAAAAAAAMmFQiH5fD55vV719fUpGo0mnOf1elVVVZVwrLKycjpLBAAAs1hhYaEKCgrk8/nU2to6YVWmEwYHBzU4OKi0tDSVlpaqtLRUGRkZM1wtsLANDw9r165dGh8fn3Redna2Kioq5HK5+JACkEKEmACcNcMwlJWVpaysLNXU1CgQCMjj8cjr9WpsbGzC/MLCQlmt1oTnikaj/CIAAAAAAACmXTgcVm9vrzwej3p6epIGl07V29ubNMQEAAAWNsMw5HK55HK5NDAwoLa2Nvl8voRzg8GgWlpa1NLSosLCQi1fvjzp+yYAppbD4Zj0vcjCwkJVVFQoNzeX9yyBWYAQE4DzYhiGsrOzlZ2drUWLFmlwcDC2BPuJRLPL5Up6/MGDBzU+Ph77RT8tLW2mSgcAAAAAAPNcNBpVT09PLLgUiUROe4zValVRUZFcLpfy8/NnoEoAADDX5ebmKjc3V2NjY+ro6FBXV1fSVV/GxsYIMAHTIBwOJ/y3ZRiGSktL1dzcHOtjdTRg9iLEBGDKGIYR+0V98eLFGhgYkM/nU0FBQcL54XBYPp9PkUhE/f39ampqUl5entxut4qKithnFgAAAAAAnBfDMNTS0pJ0i5cTLBaLCgsL5XK5VFBQwBuLAADgnKSnp6u2tlbV1dXy+Xzq6OjQwMBA3JySkpKkx7N7BXB2QqGQPB6Purq6ZBiG1q1bl3BeaWmpjh07puzsbJWXl6uoqEgWi2WGqwVwJkgIAJgWhmEoLy9PeXl5See88ROQ0WhUfX196uvrU0NDgwoKCuR2uyfdjg4AAAAAAGCyN/xcLlfCEJNhGCooKJDL5VJhYSEfpgIAAFPGYrHI7XbL7XZraGhIHR0d6u7uViQSkdvtTnhMNBrVjh075HA4VFxcrPz8fEIWQAIn3k/s7u6OLZZwwvDwsDIzMyccY7fbdfHFF7PqEjAH8D/zaTQ8PKxvfetbeuyxx3T48GGNjY2psrJS11xzjW6//XZVV1ef1/lramp07Nixszrm6NGjqqmpiev74he/qH/5l385o+O3bdumq6666qweE0gm2d7Q0snl3nt6evg0JAAAAAAAmCASiaivr09er1fDw8Nat25dwiCTy+XSkSNHYvdPXQWabe0BAMB0czqdqq+vV21trQYHB5P+/uH3+xUIBBQIBOT1emWz2eRyueRyuZSXl8cKTVjQotGoBgYG5PV65fV6FQwGE87r7u5WbW1twjECTMDcQIhpmjQ1NWnLli1qbGyM6z906JAOHTqk733ve9q6dave+c53zlhNubm5ky5RCcy0pUuXyuVyyev1TliV6VSRSCT2S4nVao0FmgoLC/mlHQAAAACABeTElvRer1c+n0+hUCg2NjQ0pKysrAnHZGRkqKysTE6nU0VFRbLb7TNZMgAAgCTJZrOpoKAg6Xh3d3fc/VAopM7OTnV2dsput8cCTTk5Obw3ggUhGo3K7/fL4/HI6/VqfHz8tMf09vYmDTEBmBsIMU0Dv9+va665JhZg+uhHP6obb7xRDodD27Zt0z333KPBwUHdcMMNeuGFF7R27dpzepwnn3zytN+sn3rqKX3605+WJL3vfe87bcJ0z549k47zTR9TyWq1xn7pDofD6unpkcfjUW9vr6LRaMJjwuGwPB6P+vr6tHHjxhmuGAAAAAAAzLRoNBoLLnm93rjg0qk8Hk/CEJMk1dfXT2eJAAAA5yUajU66e8X4+Lja29vV3t6u9PT02Hsr2dnZBJow7/j9/tjv/qOjo6edbxiGCgsLVVJSovz8/BmoEMB0IsQ0Db72ta+poaFBknTvvffqrrvuio1t3LhRV111lTZv3qzh4WHdeeedeuaZZ87pcZYsWXLaOV/60pdit//qr/7qtPNXrVp1TrUA58tqtcb2hw6FQvL5fPJ6verr60sYaHK5XPxiDgAAAADAPHVqcMnn8yXdLuJUPp9PtbW1vF4AAADmHMMwtH79enk8HnV3d8vv9yedOzY2pra2NrW1tclut8d2ryC8gfni6NGj6uvrO+28rKwsFRcXq7i4mG2igXmEENMUCwaD+uY3vylJWr58uT7zmc9MmHPZZZfpwx/+sB588EE9++yz2r59uzZs2DDltQwMDOjXv/61JGnRokW64oorpvwxgOlgs9lUUlKikpISBYNB+Xw+eTwe9ff3x+a4XK6kx+/bt08Wi0Uul0sFBQWyWCwzUDUAAAAAADhfp664dCbBJUnKycmJrUZAgAkAAMxVaWlpKi8vV3l5uUZGRmK/EwUCgaTHjI+Pq7OzU6FQiBAT5pRIJJL0/bvCwsKkISan0ymXyyW32y2HwzGdJQJIEUJMU2zbtm0aGBiQJN18881Jv/necsstevDBByVJjz/++LSEmH7+85/Hltg7k1WYgNkoLS1NpaWlKi0t1fj4eGx1ptzc3ITzT4SeJHMZeavVqqKiotinEAg0AQAAAAAwex07dizuQ0zJZGdnx4JLGRkZ018YAADADHI4HKqqqlJVVZWGh4fl8Xjk9Xo1PDyccH5RUVHSc42MjCgjI4OwN1IqGo1qeHhYfX196unp0fDwsC699NKE12VhYaGamppi9x0Oh9xut1wul5xO50yWDSAFCDFNseeffz52e/PmzUnnrV+/XpmZmRoeHtYLL7wwLbX88Ic/lGQuQfmhD31oWh4DmEl2uz32KYRk3rhndDgcVnd3t7q7uwk0AQAAAAAwy7lcrqQhphPBpaKiIj51DQAAFozMzEzV1NSourpaQ0NDsRWaRkZGJJnvAxYUFCQ8NhQKafv27UpLS1N+fn6s2e32mXwKWKDGx8fV39+v3t5e9fX1aXx8PG58cHAw4aIFGRkZsd/53W63nE4nITxgASHENMX2798fu71s2bKk82w2m+rq6rR7924dOHBgyus4evRoLBx1xRVXaNGiRWd03Nve9jbt3LlT/f39ysvL04oVK/SOd7xDH//4x89rGcq2trZJxzs7O2O3h4aGNDg4eM6PhYXt1Gvpjd4YaMrNzVVeXp6ys7PjAk2nLs062TKtwEzhmsRswvWI2YTrEbMN1yRmE65HzDZ+v19ZWVkqKCjQgQMHtGzZsoRvRKSnp8fddzgcysvLU35+fmwsGAye8VZzQCJDQ0OpLgEAgLNmGIaysrKUlZWl2tpaDQ8Py+fzaXx8XDZb4rd8+/v7FY1GNT4+Hnt/RJKysrJigabc3Fw+9I0pEYlENDg4GAstne7/oj09PUl3Xlm5cuV0lAhgDiDENMVOhHWcTqfy8vImnVtZWandu3fL6/VqbGxswos05+OHP/yhotGopLPbSu5//ud/Yre9Xq+effZZPfvss/rqV7+qRx55RO9+97vPqZ7KysoznvurX/0q6Q8s4HTS0tJUUFCgwsJCZWdnJ01mh8Nh9fb2qre3V6FQKHb7jZ/2fPTRR2egauDMcU1iNuF6xGzC9YjZhmsSswnXI1IpKytLhYWFKigo0KpVqyRJo6Oj2rp1q/x+f8JjampqND4+rt7eXo2Ojs5kuVggBgYGUl0CAADnLTMzU1VVVZPO6evrS9gfCAQUCATU2toqwzCUk5Oj3Nxc5ebmKicnJ2koCjhVNBpVX1+fBgYGNDAwIL/fr0gkcsbH9/b2nvFCHAAWDn4CTbETL75kZWWddu6pe3YGAoEpDTGdeIHS4XDofe9732nnX3DBBfrLv/xLXXzxxSorK1MwGNShQ4e0detWPfnkk+rv79f/+l//S7/5zW/0F3/xF1NWJzDVgsFg7NMEaWlpsRdKc3Jykh5js9nkdruVk5OjnTt3zlyxAAAAAADMQ9nZ2SooKFBBQUHS17sKCwuThpiam5unsToAAICFY3h4+LRzotFoLIRyQlZWlvLy8rRo0SK28UJShmGooaFBY2NjZ3xMenq68vPzY/9fAIA3IsQ0xU58OuxM9pI99UWcE/vWToUXX3xRhw8fliS9+93vnjS8IUl33nmnvvjFL07ov+SSS/RXf/VXevDBB/U3f/M3CofD+shHPqLDhw8rIyPjrGpqbW2ddLyzs1MXX3yxJOn666/XkiVLzur8wOmc2He3v78/6ZLh1dXV2rhxowKBQCwI+KEPfUhZWVmKRqP8oo6USXRNAqnC9YjZhOsRsw3XJGYTrkfMpGg0qkAgEPt/dygUOu0xFRUVesc73sH/tZESDQ0Nuueee1JdBma5QCCgHTt26M9//rP+/Oc/a/v27bGQZXV19bQELl988UV95zvf0XPPPafu7m7l5eVpzZo1uuWWW/T+979/yh8PwPy3evVqjYyMqK+vT319ferv71c4HD7tcYFAYNL3RXjPZP6LRCIKBALy+/2y2WwqLi5OOC83N1cejyfpeSwWi/Ly8lRQUKD8/Hw5HA6uHQCTWrAhpqn45vj9739ft9xyS1zfiXDP+Pj4aY8/NZXqcDjOu54TfvjDH8Zu33zzzaedf7pt7z7+8Y9r+/btevjhh9XR0aFf/vKX+sAHPnBWNVVUVJzxXKfTedrgFXAuioqKJJn/9rxer7xerwYHB2Pj5eXlys7OjjsmKytLOTk52rVrl+x2u1wul/Lz82W1Wme0duCEE9ckMBtwPWI24XrEbMM1idmE6xHTpb+/Xx6PRz6fT8Fg8IyOGRkZUW1trSoqKpSZmckbGEiJU1fIB5K59tpr9cwzz8zY433xi1/Ul770pbhteLq7u/Xkk0/qySef1NatW/WLX/zirD9gDGBhMwxDmZmZyszMVHl5uSKRiAYHB2OhpmQrY0pmOCWZxsZGDQ4OKjs7O9acTqcsFst0PA1Ms2g0qqGhIfn9/lgbGhpSNBqVZK60mizElJeXNyHElJ2drfz8fOXn5ysnJ4frAsBZWbAhpulyIgARCAROO/fU1WCm6hORY2Nj+vnPfy5JKi0t1Vvf+tYpOe/HP/5xPfzww5KkZ5999qxDTMBskp6eroqKClVUVMQCTYODg0n/HY6Ojqq/v1+S5PF4ZLFYVFhYqKKiIhUWFhJoAgAAAAAsSO3t7fL5fKedl5mZqZycHP3hD3/QyMiILrvsMkIkAGa9E2/cSlJBQYHWr1+vF1988Yxe+z9bDz74oP7lX/5FkrR48WL9wz/8gy644AJ1dHToG9/4hrZt26YnnnhCt956q3784x9P+eMDWDhOrIqTl5en2tpahUKh2FZyAwMD8vv9se9/k4WYBgcHNTQ0pKGhIXV1dUk6GZhyOp1xLT09neD6LBGNRjU+Ph77uzu1nfpz740CgYAikUjCMFJubq6ys7OVl5en3Nxc5eTkKC0tbTqfBoB5bsGGmA4cOHDe5ygtLZ3QV1FRoVdeeUVDQ0Pq7++fdJWjE1usuVyuuK3lzsdvfvMb9fX1SZJuuummKQtXrFixIna7vb19Ss4JzAYnAk2T8Xq9cfcjkUhsJSeLxaL8/Hy5XC4VFhbKZluw31YBAAAAAPPQZFuFuFyupCEmp9Mpl8uloqIiOZ1ODQ4OamRkZDpLBYApddNNN+njH/+4NmzYoLq6Okn6/9u78zgny3v//+8kM0lmSSazMDDsCCKoFK2AWkuBuqNoodatVXG3ao/29Kg97alLrVXU9tT26KnWBdviLlrcqYhUBETUn6WCsgjIMsDsmZlsk+T+/cE395lhksxClsnwej4e94N7cl/3dV9hrrly5b4+93Vp5MiRKQ9iqq+v1y233CJJGj58uFatWmXOKC9JZ555pmbPnq1XXnlFTz/9tK666ipNnz49pWUAcPDKy8tTeXm5ysvLJUmRSETNzc1JxzgjkUiHiRpiYrP57H8sLy9PhYWFKi4uVmFhoUpLS1VYWJjy94Lkdu/erc2bN3dr6ef9xX63+69mIu17YOHrX/96KooIAJIO4iCmcePGpSXfww8/XC+++KIk6fPPP9dxxx0XN104HNbmzZslSePHj0/Z9Xu6lFx3ESGNg1myp0qj0ajq6upUV1cni8Wi0tJSVVRUqKKigkhzAAAAAEBOikQiamhoUE1NjZqamjRlypS4T12XlZXJarWaSx8VFxebgUsMTAHIdVdddVVGrvPoo4+qqalJkjRv3rwOAUySZLPZ9NBDD+n1119XJBLRfffdRxATgLSx2WzmTE2JJFuCLp5wOCyv1yuv1ytJGjNmTMK+YmNjoxwOhxwOB0uQdcEwDAWDQfn9/g7bEUccEXdcNy8vr1cBTIWFhXK5XPw+AGTMQRvElC7f/OY3zf1ly5YlDGJas2aNGYl8wgknpOTaNTU1evPNNyVJRx11lCZMmJCSfCVp3bp15v7gwYNTli+QCw4//HDV1taqtrbWXFYuHsMwVF9fr/r6em3YsEEej0cDBgxQVVUVgYAAAAAAgD4tEomovr5eNTU1qqurMwOTpH2zhOw/qC7tGwgZMmSI8vLyNGDAABUUFGSyyADQL7z88suSJLfbrTlz5sRNM3ToUJ100kl66623tGTJEjU3N8edDQMAMsHlcmnixIlqbm42t0Ag0O3zE/UZDcPQP//5T3NZM7vdbgY0xdvsdnu/DayJRqMKhUIKBoMJt1AoFPfcYDAop9PZ6fXuLOfsdDrlcrnMrbi4mBVIAGQcrU6KTZ8+XSUlJWpqatKTTz6pm2++OW7wwvz588392bNnp+TaTz/9tNra2iSldhYmad+a3DHTpk1Lad5AX+dwODRkyBANGTJEoVBIdXV1qqmpUWNjY9I1ghsbGxWJRAj8AwAAAAD0SeFw2Axcqq+v7xC41F5tbW3cICZJOuSQQ9JZRADo10KhkFavXi1JOv7442W32xOmnTZtmt566y0Fg0GtWbNGM2bMyFQxAaCDeLM1tbW1mUvJtd8ikUin8xMFMQUCgQ5jLqFQSKFQKOnMTzabTfn5+crPz9eYMWPkdrs7pYlGo2pubpbNZuuwWa3WtD2AbhiGotGoIpFI3C0cDmvAgAFxA4Sam5v18ccf9/rafr8/bhCT0+k0Z1G12WzmEn9FRUXmPiuMAOgLCGJKMbvdrn/7t3/TnXfeqfXr1+v+++/XTTfd1CHNypUr9dhjj0na98Vj8uTJcfOKfXCOGDFCW7du7fLasaXk8vLydOGFF3arvGvXrlVBQYG5pnc8jzzyiB599FFJ0qBBg1IWdAXkIrvdrqqqKlVVVamtrc0MaGpoaIgb0JToJq+07ylXm82WzuICAAAAANBB7OGc2trahN9l91dXVyfDMJhlGABSbMOGDeYA/7hx45KmbX98/fr1PQpi2rFjR9Lj1dXV5n5zc7O55FO6tbS0xN0HDgT1KnusVqs5g4+0L5Cnra3NXOYsEAiYMwjFJmVorzdtTywoKBAIJPx9B4PBDivO7F/m2CbtG5uNbbGfy8vLzfTtrxEKhbR582YZhmH2qaPRqLl1xWKxxF1WL9EMS91VX1+fcOxp9OjRys/Pl91u79S3j/2ekH60U0iHbNWrni4x2h0EMaXBTTfdpGeffVYbNmzQzTffrE2bNun8889XQUGBli5dql//+tcKh8MqKCjQ7373u5Rcc926dfroo48kSaeddpoqKyu7dd5HH32kK664QjNmzNDpp5+uCRMmqLy8XOFwWJ9//rkWLFigxYsXS9oXzfzII490a7pB4GCQn5+vQYMGadCgQQqHw+ZN4PZPrw4YMCDuuYZh6KOPPlJeXp4qKipUUVGRcA1oAAAAAAAO1O7du7V79241NTV1+5ySkhINGDBAFRUVBDABQBq0Dy4aOnRo0rTDhg0z97dv396j67Q/tyt/+ctfVFJS0qP8U+Evf/lLxq+J/o961Te98847cV8vLy/XqFGjer182fPPPx93WbuCggJNnDgx7jndCTiKzZgndaxTDodDRx99dK/KKu1bTjRe39xqtWrKlCndziccDisYDCoQCCgQCGjt2rVqbW3tdbmQWbRTSIdM1que3GPoLoKY0sDlcum1117TzJkztXHjRj3yyCN65JFHOqRxu91asGCBjjrqqJRcMzYLkyRdfPHFPTo3Eono7bff1ttvv50wTXl5uR577DHNmjWr12UE+rO8vDwNHDhQAwcOVCQSUX19vbxeb8JpUX0+nxnR3tzcrC1btqiwsNAMaCouLuYGMQAAAAAgZbxeb7duLno8HjNwKdmyRgCAA9f+yfXi4uKkads/XMysDQD6o7q6OtXV1SkvL092u73D5nA4Ovwcb6aheLM7SUrbihjdmdE0mUTBWrFl6Gw2myKRiLmsXvstNqNVKBRSOBw+oHIAQF9DEFOajBkzRp988okefPBBPf/889q0aZNCoZCGDRummTNn6oYbbtCIESNScq1oNKoFCxZI2nej6ayzzur2uTNnztRjjz2mlStX6pNPPtGePXvMKcLLyso0ceJEnXbaaZo7d27cdWQBdGaz2TRgwICEszBJUk1NTafXfD6fvvrqK3311VdyOp0qLy9XRUWFSkpKCGgCAAAAACRlGIYCgUDCh2kqKio6LBcUY7FYOgQu5efnp7uoAID/p/2MIV0FjjocDnO/p8v9dDVzU3V1tTnrx0UXXaQhQ4b0KP/eamlpMWcKuOiii7oM5AK6g3rV/xmGoUgkonA43GE76qij4o6lNDc368svv+zWEm/xnH766Xr++ecldaxTbW1t+te//tXtfGLL1tlsNtlsNp1yyinyeDxx0waDQTMd40P9D+0U0iFb9Wrnzp26++67U5onQUxpVFRUpJtvvlk333xzr87vbgSv1Wrt8fSxMZWVlbrssst02WWX9ep8AL3T0NCQ9HggENDOnTu1c+dO5efnmwFNpaWl5trMAAAAAICDm2EY8nq9qq2tVW1trYLBoL7xjW/Efarb4/GYT3NbrVaVlZWpoqJC5eXlvV6yAwCyLRUDu0888YTmzp174IXpBafTae6HQqGkaYPBoLmfKGA1ka6WqmvP5XJl5YHm4uJiHqRGylGvIO1bHWfIkCEyDMOc5Wj/zTCMhFv7INL2dSoajWr8+PGyWCwdtljwUfvNarUSjIS4aKeQDpmsV16vN+V5cocCALJg4sSJampqUk1NjWpraxNOcyrti+bfvXu3du/eLZvNpvLyco0bN44OLwAAAAAchKLRqBobG1VbW6u6urpOg951dXUaOHBgp/OsVqsOOeQQ2e12lZaWpm1ZDQBA97lcLnO/qyXiWltbzX1mbACAnmsfYNQTiQborVarKisrU1E0AEA7BDEBQBZYrVaVlpaqtLRUhx56aIcnZ9tPI72/2PrHBDABAAAAwMEjEomooaHBDFwKh8MJ09bW1sYNYpKkwYMHp6uIAJAV69evP+A8qqqqUlCS3mk/Q9KOHTuSpm2/GsOwYcPSViYAAAAgmwhiAoAss1gsKikpUUlJiQ455BC1traaAU3tn7CKqaioSJhXQ0ODCgoKOkxFDQAAAADIPeFwWHV1daqtrVV9fb2i0Wi3zvP5fDIMg4dfABwUxo0bl+0iHJCxY8eaS31+/vnnSdO2Pz5+/Ph0Fw0AAADICoKYAKAPsVgsKi4uVnFxsUaOHCm/328GNMWmLE0UxGQYhtavX6+2tjYVFxeroqJCFRUVKiws5OY1AAAAAOSQDRs2aPfu3TIMo1vpi4qKVF5ergEDBqioqIjvgACQI+x2u6ZMmaKVK1dq5cqVCoVCstvtcdMuW7ZMkuRwODRp0qRMFhMAAADIGIKYAKAPKygo0LBhwzRs2DCFQiE1NTXJ4XDETev1etXW1iZJamlpUUtLi7Zu3aqCggIzoMnlcnEzGwAAAAD6OJvN1mUAk8vl6vDwCgAgN33nO9/RypUr5fV6tXDhQp1//vmd0uzYsUNvv/22JOnEE0+Uy+XKdDEBAACAjLBmuwAAgO6x2+0aMGBAwuO1tbVxX/f7/dq+fbs++eQTrVq1Shs2bFBdXV23lyIAAAAAAKSOYRhqbGzU9u3bE6ZJNAOvx+PRmDFjdNxxx+nrX/+6hg8fTgATAPRhW7dulcVikcVi0fTp0+OmueKKK1RSUiJJ+ulPf6q6uroOxyORiK699lpFIhFJ0k033ZTWMgMAAADZxExMANBPWK1W5eXlKRwOJ0wTCoVUXV2t6upq2Ww2lZaWqry8XOXl5crPz89gaQEAAADg4BGJRFRfX6+6ujrV1dWZ39sqKyvjzrbrdruVn5+vcDis0tJSc8YlvrcBQOZs2rRJy5cv7/BaS0uL+e/8+fM7HDvttNM0aNCgHl+nrKxM8+bN0zXXXKNt27bp2GOP1c9//nNNmDBBu3bt0u9+9zstXbpUknTBBRckDIYCAAAA+gOCmACgnxg1apRGjhypxsZG1dbWqq6uTsFgMGH6SCSi2tpa1dbWymaz6YQTTmCpOQAAAABIkVAopLq6OtXW1qqhoSHu8nB1dXUaPHhwp9ctFosmTJiggoIC5eVx+w4AsmH58uW69NJL4x6rq6vrdGzp0qW9CmKSpKuvvlq7du3SnXfeqc2bN+uyyy7rlGbmzJl6/PHHe5U/AAAAkCu4CwIA/YjFYlFpaalKS0s1ZswYNTc3m4FKfr8/4XmlpaUEMAEAAADAAfL5fOZDJV6vt8v0tbW1cYOYJMnlcqW6eACAPuyOO+7QqaeeqgcffFDvvfee9uzZI4/Ho4kTJ+rSSy/VBRdckO0iAgAAAGlHEBMA9FMWi0Vut1tut1uHHHJI0pvpFRUVCfPZuHGjDMNQeXm5PB6PbDZbuosOAAAAADmjqanJnHEp2cMj+ysuLpbH40lfwQAAB2Tu3LmaO3fuAeUxcuTIuDPxJfKNb3xD3/jGNw7omgAAAEAuI4gJAA4ShYWFGj58uIYPH24ua1BXV6fGxkaVlZXFPScajWrPnj2KRCKqrq6W1WpVaWmpKioqVFZWJrvdnuF3AQAAAAB9y6ZNm9TS0tJlOovFopKSElVUVKi8vFxOpzMDpQMAAAAAAMgdBDEBwEHIbrerqqpKVVVVikajslqtcdM1NjYqEomYP0ejUTP4SZLcbrd5A76wsDAjZQcAAACATItEIglnpS0vL08YxGSz2VRWVqby8nKVlZUpPz8/ncUEAAAAAADIaQQxAcBBLlEAkyQzWCkRr9crr9erL7/8UgUFBSovL1dFRYXcbrcsFkuqiwoAAAAAGWEYhlpbW82HOMLhsCZPnhz3e05FRYW2bdtm/my3283vRh6PJ+l3LgAAAAAAAPwfgpgAAAkNHTpUTqdTdXV1ampqSprW7/drx44d2rFjh/Lz81VWVqYxY8YoL4+PGgAAAAB9XyQSUWNjo+rq6lRfX69gMNjhuN/vjzsDbVFRkUpLS+VyuVReXi6Xy8VDHQAAAAAAAL3AyDIAIKGCggINGzZMw4YNU1tbm/kUcn19vaLRaMLz2traVF9fn3C5BQAAAADoC4LBoOrr61VXV6eGhoak33Pq6uriBjFZLBZ97WtfS2cxAQAAAAAADgoEMQEAuiU/P1+DBg3SoEGDFI1G1dDQYAY1hUKhTunLysoSPn3c1NSkaDSqkpISllYAAAAAkDGGYailpcV8OKO5ubnb5zY0NGjYsGFpLB0AAAAAAMDBjSAmAECPWa1WlZeXq7y8XIZhqLm52Qxoam1tlSSVl5cnPH/btm1qaGiQzWZTWVmZysvLVVZWpvz8/Ey9BQAAAAAHmWg0qg8//FCBQKDb5zidTvO7T0lJSRpLBwAAAAAAAIKYAAAHxGKxyO12y+12a9SoUfL7/aqvr1dpaWnc9OFwWI2NjZKkSCSimpoa1dTUSJLcbrcZ0FRUVJRwJicAAAAA6Cmr1Sqn09llEFPse0l5ebkKCwv5XgIAAAAAAJAhBDEBAFKqoKBAQ4YMSXi8sbFRhmHEPeb1euX1erVlyxY5HA4zoMnj8chms6WryAAAAAByXDQaldfrVV1dnWw2m0aOHBk3XXl5uflQRQwzxAIAAAAAAPQNBDEBADKuuLhYLS0tSdMEg0Ht2rVLu3btktVqlcfjUVlZmSorKxlUAAAAAKBQKKT6+nrV1dWpoaFBkUhEkmS32zVixIi4MyiVlZVp8+bNnZaJs1qtmS4+AAAAAAAA9kMQEwAgoyoqKlRRUaFgMNhhwCEajSY8JxqNqr6+3lymjiAmAAAA4OBjGIaam5tVV1en+vr6hA9GhEIhtbS0yOVydTpWWFioyZMnq6CggGXiAAAAAAAA+hiCmAAAWeFwOFRVVaWqqipFo1E1NjaagxGBQCDuOU6nUwUFBXGPhUIhRaNROZ3OdBYbAAAAQAa1tbWpoaHBfPihra2tW+fV19fHDWKS9gUyAQAAAAAAoO8hiAkAkHVWq1VlZWUqKyuTYRjy+XxmQFNTU5OZrqysLOHT0tXV1dq6dasKCwvNvFgWAgAAAMhNgUBA69evl9fr7dF5xcXFKisrU3l5eZpKBgAAAAAAgHQhiAkA0KdYLBYVFRWpqKhIw4cPN5+8rq+vV0VFRcLz6uvrJUk+n08+n087duyQ1WpVaWmpGdTELE0AAABAbrDb7QmXi2vPZrOptLRU5eXlKi0tlcPhyEDpAAAAAAAAkA4EMQEA+rT8/HxVVlaqsrIyYZq2tra4T2hHo1HV1dWprq5OkpilCQAAAOgDDMOQ1+tVfX293G533FmTrFarPB6P+bBCe7F+fXl5udxuN/16AAAAAACAfoIgJgBAzvP7/crPz1dbW1vSdPvP0uTxeFRaWqqKigpmaQIAAADSKBgMqr6+XvX19WpsbFQ4HJYkDRgwIOHSb+Xl5aqvrzf77uXl5cywCgAAAAAA0I8RxAQAyHlut1vHH3+8mpubzYGR5ubmpOdEo1EzrdVq1eDBgzNUWgAAAKD/i0ajampqMvvcPp8vbrqGhgYZhiGLxdLpWOxhg5KSEtlstnQXGQAAAAAAAFlGEBMAoF+wWCxyu91yu90aOXKkQqGQGhoazEGT2JPe8ZSVlcV9PRqNqqWlRS6XK+6gCgAAAIB9DMOQ3+83++CNjY2KRqNdnhcOh+X1elVSUtLpmN1uT9hXBwAAAAAAQP9DEBMAoF+y2+0aOHCgBg4cKMMw5PV6VV9fr4aGhg6zNBUUFCRcjsLr9erTTz9VXl6eSktLVVpaqrKyMjkcjky9DQAAAKDPq6ur06ZNmxQIBHp0XlFRkUpLS2W329NUMgAAAAAAAOQSgpgAAP2exWJRSUmJSkpKNGrUKLW1tZlPiBcUFCQ8r6GhQdK+p8NrampUU1MjSSosLFRZWZlKS0tZ2gIAAAAHvby8vG4FMMUeDoj1pXk4AAAAAAAAAO0RxAQAOOjk5+ersrJSlZWVSdPV19fHfd3n88nn82nHjh2yWq0qKSmRx+NRaWmpiouLWXoOAAAA/YJhGPL5fGpoaFBDQ4PGjBkT9yEAt9stm82mSCTS6ZjL5TKDltxuN31lAAAAAAAAJEQQEwAAcUSjUUWj0W6liw3qbNmyxXy6vKKiossgKQAAAKCvCYVCZv+2oaFBoVDIPFZfX68hQ4Z0Osdiscjj8aiurk52u73DbEv5+fmZLD4AAAAAAAByGEFMAADEYbVaNXnyZAUCgQ6DOOFwOOl5saXnLBYLQUwAAADo8yKRiJqamsz+bmtra8K0DQ0NcYOYJGnEiBEaOXKkioqKmG0JAAAAAAAAvUIQEwAASTidTlVVVamqqkqGYai5uVn19fVqaGiQ1+tNeF5paWnCY7t27ZLT6VRJSYlsNls6ig0AAADEZRiGWlpazKClpqYmGYbRrXMbGxtlGEbcICWXy5XqogIAAAAAAOAgQxATAADdZLFY5Ha75Xa7NXLkSLW1tXV4at3v95tpEwUxRSIRbdq0yRz8KSkpUWlpqTwej1wuF0+tAwAAIK0+++wz1dXV9egch8Oh0tJSlZaWJgxiAgAAAAAAAA4UQUwAAPRSfn6+KioqVFFRIUkKBAJqbGxUS0uLHA5H3HO8Xq/5pLthGGpsbFRjY6MkKS8vTx6Px9wKCwsZIAIAAECPGIahtra2hMfdbneXQUw2m00ej8cMXCooKKBfCgAAAAAAgLQjiAkAgBRxOp0aNGhQ0jQNDQ0Jj4XDYdXW1qq2tlbSviApj8cjp9Mpp9OpQCCQ0vICAACgfwgGg2psbFRDQ4O55Nvhhx8eN63H44n7utvtNoOWXC6XrFZrGksMAAAAAAAAdEYQEwAAGVRQUCCXy6Xm5uYu07a1tammpkaSdNRRRykUCikcDqe7iAAAAOjjQqGQuaxxY2Njh2WNYxIFwLtcLtlsNtntdjNoyePxKC+PW0QAAAAAAADILu5QAQCQQVVVVaqqqlI4HO7wtLzP5+vyXMMwZLPZEh5jiQ8AAID+KdZ3jG2tra1dntPS0hL3dYvFouOOO46gJQAAAAAAAPQ53LECACAL8vLyVFFRoYqKCkn7lgCJBTQ1NjYqGAx2Osfr9SYMVNq2bZv27Nkjj8djbg6HI63vAQAAAOkTDoe1detWNTU1JQxISiZZkDwBTAAAAAAAAOiLuGsFAEAf4HA4NGjQIA0aNEiGYSgQCJgBTfX19QqHw2pqakp4fmNjowKBgHbv3q3du3dL2rd0XSygqaSkhKAmAACAHGK1WlVdXa1oNNqt9Hl5eSopKTGXh2MZYgAAAAAAAOQagpgAAOhjLBaLCgoKVFBQoKqqKjU1NWn+/Plqa2uLmz4Sicjr9XZ63e/3y+/3q7q6WpLkdDpVUlJiBjU5nU6WoAMAAMiCUCikxsZGNTU1yePxaMCAAZ3SWK1WlZSUqKGhIW4eseOxoKXi4uIOfbt4/UMAAAAAAACgLyOICQCAPs5isSgQCCQ87vV6ZRhGl/kEAgEFAgHt2bNHkmS321VSUqKqqiqVlpamrLwAAADoKBgMmkFLjY2N8vv95rG2tra4QUySOgQxWSwWud1ueTwelZaWyuVyyWq1ZqT8AAAAAAAAQCYQxAQAQI7zeDw65phjzOXnGhsbFYlEujwvFAqppqaGACYAAIAUii0N3NTUZAYtJQtIb2pqkmEYcWfILC8vl2EY8ng8crvdBC0BAAAAAACgXyOICQCAHGexWFRcXKzi4mINHTpUhmGoubnZHDhrampSOBxOeL7H44n7ejQa1WeffaaSkhKVlJTwtD8AAEACPp9P9fX1Zt8r0TLA8YRCIfn9fhUWFnY6FuvjAQAAAAAAAAcDgpgAAOhnYkuNuN1uDRs2TIZhqLW1tcNsALGBNbvdLqfTGTcfr9er+vp61dfXS5KsVqtcLpfcbrdKSkrkdruVn5+fsfcFAADQV9XW1mrLli09Osdms5nB4nl53J4BAAAAAAAAuEsGAEA/136mpiFDhsgwDPn9fjU1NSkajcZdukTat7RJe9Fo1AyE2r59uySpsLCwQ1BTQUFBwvwAAAByUTAYlNfrldfr1SGHHBK3r1NSUtJlPnl5eWbQksfjUXFxMf0mAAAAAAAAoB2CmAAAOMhYLBYVFhbGXbKkvf2DmOLx+Xzy+XzavXu3JCk/P98Maho6dCgDcwAAIKcYhiGfzyev12sGbwcCAfP4oEGDVFRU1Ok8l8sli8UiwzDM1/Lz8zsELRUVFdE3AgAAAAAAAJIgiAkAAMQ1ePBgFRQUqKmpSa2trd06p62tTXV1dWppadGwYcPSXEIAAIADEw6H1dzcbM605PV6FQ6HE6b3er1xg5isVqsGDBggq9VqBi45nU6ClgAAAAAAAIAeIIgJAADEVVFRoYqKCkn7gpNiMxJ4vV41NzcrGo0mPDfZkio7d+5Uc3OzSkpK5HK5mJUAAABkTDQa1Z49e8zApe4Gasc0NTWpqqoq7rHx48enoogAAAAAAADAQYsgJgAA0KX8/HyVl5ervLxc0r4BwJaWlg6BTaFQyEzvdrsT5lVTU6Ompibt2bNHkmSz2eRyueRyueR2u+V2u2W329P7hgAAwEHJYrFo8+bNikQiPTrPZrOZ/RQAAAAAAAAA6UEQEwAA6DGr1WoO5A0dOlSGYSgQCJjLsHg8nrjnRaNRNTc3d3gtEomosbFRjY2N5msOh0Nut9sMbCouLpbNZkvjOwIAALnMMAz5fL4OfZGBAwd2SmexWORyuTr0O+JxOBwqKSmR2+1WSUkJM0cCAAAAAAAAGUAQEwAAOGAWi0UFBQUqKCiIO2AY09ramnQZuphgMKiamhrV1NSY+RcVFWnYsGGqrKxMWbkBAEBuCgaDam5uNpeFa25u7jC7UiQSSdgncbvdHYKYLBaLiouLzQBtt9stp9OZ7rcAAAAAAAAAYD8EMQEAgIxxOBwaM2aMuQRdMBjs1nmGYailpSVpAFQ4HFZeHl0bAAD6m7a2NjNgKba1X8Y2Hq/Xm/CYx+ORz+czA5ZcLpesVmuqiw0AAAAAAACghxjpAwAAGWO32zVkyBANGTJEkhQKhcxlX2KDku1nUdif2+2O+3okEtH7778vp9Mpl8ul4uJiuVwuuVwuApsAAMhRO3fu1M6dO+X3+3t8bjAYVDAYlMPh6HSstLRUpaWlqSgiAAAAAAAAgBRiVA8AAGSN3W5XRUWFKioqJO2bccnn85lBTV6vV62trZIkm82mgoKCuPk0NzdLkgKBgAKBgLkMnSQVFBR0CGoqLi4msAkAgD4gGo0qEAiosLAw4fGeBjA5HA5zhiVmVwIAAAAAAAByCyN4AACgz7BYLCoqKlJRUZGqqqok7ZtlKbZsjMViiXteLIgpHr/fL7/f3ymwqX1QEwOdAACkVzQalc/nU0tLizn7YktLi6xWq0444YS4n/EulytpnjabzQxULikpkcvlijvzEgAAAAAAAIDcQBATAADo02w2mzweT9I0yYKY4okFNu3du1eSdPzxx8tut/e2iAAAoJ1IJKLW1lYzYKmlpUWtra0yDCNuWr/fH3c2puLiYnPfYrF0mFnR5XKpsLAwYYAzAAAAAAAAgNxDEBMAAMh548aN0/Dhw82B0ti/8QZL9+dwOBIGMNXV1WnPnj0qLi42N4KdAADoKBQKac+ePWppaVFLS4t8Pl+Pzm9ubo4bxJSXl6fx48eroKBARUVFzJoIAAAAAAAA9HMEMQEAgJxntVrNIKOYaDTaYRaI5ubmuLNAJFuqpqmpSTU1NR2WorPb7SoqKuoQ2FRQUMBMEACAfs8wjLifd21tbfryyy97na/f7094rLKystf5AgAAAAAAAMgtBDEBAIB+yWq1msvNVFVVSdoX2BSbJSIW2OR2uxPm0dLS0um1UCikUCikhoaGDteKBTTFApyKiopks9lS/8YAAEizaDQqv99vBgO3traqublZhx9+eNwlXgsLC2W1WhWNRrvM2+l0dlgWrri4WPn5+Wl4FwAAAAAAAAByDUFMAADgoGG1WuV2u5MGLsUYhhE3iCmeaDQqr9crr9drvuZ2u3X00Uf3uqwAAKSbYRgKhUJqbW3tELDk8/niLsna0tISN4jJYrGouLi4w+egtC+4qf3MhQQsAQAAAAAAAEiGICYAAIAERo4caQ7qtrS0dGuGiZiioqKEx7Zu3apQKKSioiJzY1AXAJAJu3fvNj/XWltbFQ6Hu31usuDeioqKTkFLzEgIAAAAAAAAoCcIYgIAAIjDYrFo8ODB5s+GYcjv95sDv7HB31AoFPf84uLihHnX1NTI5/N1eM1ut6uoqEiFhYUdgpsYAAYA9IRhGIpGowk/P7Zt26ZAINCrvJMFMQ0bNqxXeQIAAAAAAABADEFMAAAA3WCxWFRYWKjCwkJVVlaar4dCoU6BTT6fL2EQUzQald/v7/R6KBRSKBRSQ0NDh9edTmeHoCa32y2n05naNwcAyDmxzxOfzyefz2d+/vh8Pg0ZMkSjR4+Oe15xcXG3g5gcDof5+RObXQkAAAAAAAAA0oUgJgAAgANgt9tVVlamsrIy87VIJCKr1Ro3vc/nk2EY3c4/EAgoEAiorq5OkjRq1CgNHz48btpIJMLMTQDQz0QiEfn9/g5BSj6fT36/P+HnSWtra8L8ioqKVFtb2+E1m81mLgXHUqcAAAAAAAAAsoUgJgAAgBRLFkiUn5+vUaNGqbW11RyQ7klQU1FRUdzXDcPQihUrlJeXZ84Y1X6z2+2yWCw9fi8AgOzYunWr9uzZ06ul35It++Z2u1VRUdEhYMnpdPIZAQAAAAAAACDrCGICAADIIIfD0WEmJcMwzBk22m/xlpyTEgcxBYNBRaNRc1m6xsbGDsdjs2wUFhaqoKBARUVFKigoUEFBQcJZowAAqRWNRhUIBMyZlCwWi4YOHRo3bTgc7lUAkyS1tbUpFArJbrd3Orb/7IEAAAAAAAAA0FcQxAQAAJBFFovFDC4aMGCA+XokEpHP5+sQ2BQIBORwOOLm4/P5kl4nEomoublZzc3Nna7vdDo1btw4ud3uA39DAADZ7XZ5vV41NzfL7/fL7/fL5/N1CkpyOp0Jg5gKCwu7fa3CwkIVFRV1moEPAAAAAAAAAHIJQUwAAAB9kM1mk8vlksvl6lb6roKYEonNBJVoCbxgMKgvvvjCnLXJMAw5nU4Fg8FeXQ8A+pumpibV1dXJ7/erpaVFU6ZMkdVq1ebNm7s8NxAIKBqNxp0Rb/+Z95xOZ6elQouKipSXx9d6AAAAAAAAAP0DdzsBAAD6gcGDB6u0tFQ+n6/TFo1Guzy/oKAg7ut+v18NDQ1qaGgwXzvqqKNkGIY+++yzDsvSxTan08kSdQByXiQSUSAQUCAQUFtbmwYNGhQ3XUtLi7Zv327+3NP2LxAIxJ11qaioSOPGjTMDlhIFmwIAAAAAAABAf0EQEwAAQD9gtVpVVFTUaeYOwzAUDAbNgCa/36/W1lb5/X6FQiFJksPhSDjo7vf7475usVgUCoUUCoU6BDjF2O12OZ1OHXHEESxpBKBPirWPsUAlv99v7gcCAbONjKmsrIzbViYKAk0mPz/fDPxMJC8vTwMHDuxx3gAAAAAAAACQqwhiAgAA6McsFoucTqecTqfKyso6HAuHw/L5fAqHwwnPTxTE1JVYgFOiZY6ampr05ZdfmmVrvyULqgKA3mpublZ1dXWHQCXDMLp9fjAYjBt0lCgQyWq1mrMotZ+trrCwkCXgAAAAAAAAACAO7pwCAAAcpPLy8uR2u5OmKSsrk9VqVSAQMGdyShb01J7dbk86w5PX65XX64173OFwyOFwmEFN+2/5+fmyWCzdKgeA/scwDIXDYQUCAQWDQXNGpWAwqHHjxsVte0KhkKqrq3t9zUAgEDdgyel0qqKiQgUFBbJYLHrjjTcUCAR0+eWXq6SkpNfXAwAAAAAAAICDDUFMadDS0qKPP/5Yq1ev1urVq/Xhhx9q69atkqQRI0aY+6m0YsUKPfTQQ3rvvfe0Z88eeTweTZw4UXPnztUFF1zQ7XyefvppPfHEE/rnP/+pxsZGDRw4UFOnTtV1112n448/PuXlBgAAfZvH45HH4zF/9nq9euSRR+R0OjVr1ixJ+wKSYltbW5uZ1ul0Jsw3EAgkvW4sKCFRkNPUqVPjBjGFQiEFAgE5HA7Z7XYCnYAcZBiGIpGI2Q7sH6QU26LRaNzzR40a1aMZk7qSn5+ftD2zWCw64ogjJO1rI5ubm83XAQAAAAAAAADdRxBTGsyaNUvvvvtuxq53++2368477+xwE3/Pnj1avHixFi9erAULFuiFF15IeuPd7/frnHPO0euvv97h9a+++koLFizQ008/rVtvvVW33XZb2t4HAADIDZFIRK2trSotLe00k1NsZpRAIJB0SbiugpiSSTbDU21trTZu3Gj+HAtmaj+Lk91uV35+vux2u7lPsAGQfoZhqK2tzVxusqSkRDabrVO6pqYmffrpp72+TrIZk+KxWq1yOp0qKCjosLRl7Od4ZQQAAAAAAAAApB5BTGlgGIa5X1ZWpkmTJmnFihVqaWlJ+bUefvhh3XHHHZKk0aNH62c/+5kmTJigXbt26YEHHtDSpUv12muv6bLLLtNTTz2VMJ/LLrvMDGCaMWOGbrjhBg0ePFhr167Vr3/9a23evFm33367qqqqdNVVV6X8fQAAgP4hLy9PxcXFKi4uTpquqqpKxcXFZsBTMBiU3+9XJBLp8hoOhyPhsWAw2OnnYDBozoySSCzQ6etf/3rc4+FwWIZhKC8vj4AnYD+RSERtbW0dApSCwaC5335r/11p0qRJKioq6pSf3W4/oPLs3w7EWK1WDRkyxJxZKRaoRCAjAAAAAAAAAPQNBDGlwYUXXqirr75akydP1pgxYyRJI0eOTHkQU319vW655RZJ0vDhw7Vq1SpVVFSYx88880zNnj1br7zyip5++mldddVVmj59eqd83nnnHT3zzDOS9s0i9dJLL5lPG0+ePFlnnXWWjjnmGH311Ve65ZZb9L3vfU+lpaUpfS8AAODgUlJSopKSkk6vt5/JKbbFAiJiW7IgplAo1KvyhEKhpEEMe/bs0aZNm2SxWDrM4BT7N7bl5eV1+pngCOQSwzAUjUbNoKS2traEMya1tLTok08+SbisW1dCoVDcIKZkf+Px2O12OZ1Oc7a1wsLChGlj388AAAAAAAAAAH0PQUxpkKmZih599FE1NTVJkubNm9chgEmSbDabHnroIb3++uuKRCK677774gYx3X///ZL2zZzw0EMPdRqgqKio0Lx583TBBReosbFRjz76qG666ab0vCkAAHBQ62omJ8Mwks7WFI1GZbFYOsz20l3JZn+JBUcZhmEGU3VXQUGBpkyZEvdYa2urfD6f8vLyOm0EPyFVIpGImpubFQ6HzcCk2P7+/7a1tXX6+znmmGPi/k3m5eX1OoBJShx0aLPZZLPZFIlElJeX1yFAyeFwdPg52fKSAAAAAAAAAIDcQhBTDnv55ZclSW63W3PmzImbZujQoTrppJP01ltvacmSJWpubpbL5TKPNzc3a8mSJZKkk046SUOHDo2bz5w5c+R2u+X1evXSSy8RxAQAALLCYrEoLy9xF3b8+PEaN26c2traOszeFNtCoZC55FVbW1uHc7sTxNQbyQKq6urqtGXLlrjH4gU22Ww289/8/PyEfbdYYAnBHbkpGo0qEokoEokoHA6b++1fi23tfz7ssMPkdDo75ef3+/Xpp5/2ujyJ6n9+fn6v88zPz0/6tzF58mSzrgMAAAAAAAAADg4EMeWoUCik1atXS5KOP/74pINu06ZN01tvvaVgMKg1a9ZoxowZ5rEPP/zQHJSYNm1awjzsdruOO+44LV68WB9++KHa2toOaNACAAAgXdov+dY+eHt/hmEoFAqZW7LgqAMJYkrWZwqHw0mPJTtut9sTBjFVV1eby9/FZrWxWq3m/v4/739s8ODBcfONBYBZrVbzHKvVKovFclDNHBWNRhUKhRSNRhWNRs0l2CKRiPlabH//f6PRqEaNGhW3/97c3KxPPvmkVzOJSfvqabwgpmR1uzv2D/iLif3+Y0FzFovFXGYxNkvS/pvD4VB+fn6XAXY9XVIOAAAAAAAAAJD7CGLKURs2bDCXUhk3blzStO2Pr1+/vkMQ07p16+KmS5TP4sWLFQ6HtXHjRh1++OHdLu+OHTuSHt++fbu5/+WXX3Y7XyAdWltbzaUaN2zYoKKioiyXCAc76iT6kv5eH3ft2hX3davVqtLSUrW1tSkSiZj/7j8TTmy/fRCK3+/X+vXr4+a7c+dONTQ09KqsDocjYb41NTXau3dvr/K12WwaP3583GP19fUJ/48kmcFMibbRo0fHDXZqaWlRbW2teax9mv1fa/9/Gw6HVVZWpi1btsStj36/3/x/MAzDPDe23z6veMfGjBkTNwCotbU14Qxa3eHz+eIGGwUCAe3Zs6fX+X7xxRdxl32LRqO9rg95eXn68ssvVV9fH/d4YWFhhwC49r+7SCQiv98vv9/fq2vnov7eRiK3UB/R11An0Ze0v/+Y7MEB4GDR/u+guro6Y9dtbm42Pxt27twpr9ebsWuj/6JeIdWoU0g16hTSIVv1qn3fMVXfrSxGbx/zRY+MHDlS27Zt04gRI7R169YDzu/NN9/U6aefLkm677779B//8R8J065Zs0aTJ0+WJP30pz/V3XffbR776U9/qnnz5knaNyvTpEmTEuZz//33m8vIvfnmmzr11FO7Xd6D6cl8AAAAAAAAALlh9erV5r1T4GD14YcfasqUKdkuBgAAAHJYqr5bJZ/DH31Wc3OzuR/vaev22j/Z1tLSkpZ8AAAAAAAAACDXHMhMmAAAAACA1GI5uRwVCATMfbvdnjStw+Ew9/dfyiFV+XSl/XJx8WzZskXf+ta3JEkrVqzQsGHDepQ/kErV1dXmk0erV69WVVVVlkuEgx11En0J9RF9CfURfQ11En0J9RF9DXUSfcn27dv1jW98Q5I0bty4LJcGyL4JEyZo9erVkqQBAwbEXVY7HfhsQDpQr5Bq1CmkGnUK6ZCtehUOh1VTUyNpX58yFQ7aIKZULG/2xBNPaO7cuQdemF5wOp3mfigUSpo2GAya+wUFBWnJpytDhw7tdtphw4b1KD2QTlVVVdRH9CnUSfQl1Ef0JdRH9DXUSfQl1Ef0NdRJ9CXt748CByun05n1ZRX5bEA6UK+QatQppBp1CumQ6Xo1cuTIlObHcnI5yuVymftdLe3W2tpq7u+/ZFyq8gEAAAAAAAAAAAAAAAB666CdiWn9+vUHnEc2p3ZrHzm3Y8eOpGnbL+W2/zJt++czadKkXuUDAAAAAAAAAAAAAAAA9NZBG8SU62udjx07VjabTZFIRJ9//nnStO2Pjx8/vsOxww8/PG66ZPnk5eXp0EMP7WmRAQAAAAAAAAAAAAAAgLhYTi5H2e12TZkyRZK0cuVKhUKhhGmXLVsmSXI4HJ1mWpo8ebLsdnuHdPGEQiGtWrXKPCc/P/+Ayg8AAAAAAAAAAAAAAADEEMSUw77zne9IkrxerxYuXBg3zY4dO/T2229Lkk488US5XK4Ox10ul0488URJ0ttvv51wabqFCxfK6/VKkmbPnp2K4gMAAAAAAAAAAAAAAACSCGLqs7Zu3SqLxSKLxaLp06fHTXPFFVeopKREkvTTn/5UdXV1HY5HIhFde+21ikQikqSbbropbj7/8R//IUkKh8O67rrrzPQxtbW1uuWWWyRJHo9HV1xxRa/fFwAAAAAAAAAAAAAAALC/vGwXoD/atGmTli9f3uG1lpYW89/58+d3OHbaaadp0KBBPb5OWVmZ5s2bp2uuuUbbtm3Tscceq5///OeaMGGCdu3apd/97ndaunSpJOmCCy5IGAz17W9/W+eff76eeeYZLVq0SCeffLJuvPFGDR48WGvXrtVdd92lr776SpI0b948lZaW9risAAAAAAAAAAAAAAAAQCIWwzCMbBeiv5k/f74uvfTSbqdfunRppwCjrVu3atSoUZKkadOm6d133014/m233aY777xTiX6VM2fO1Isvviin05kwD7/fr3POOUevv/563ONWq1W/+MUvdPvttyd9LwAAAAAAAAAAAAAAAEBPsZxcP3DHHXdo+fLluvDCCzVs2DDZ7XZVVlbq5JNP1lNPPaXXXnstaQCTJBUUFOi1117TggULdPLJJ6uyslJ2u13Dhg3ThRdeqOXLlxPABAAAAAAAAAAAAAAAgLRgJiYAAAAAAAAAAAAAAAAAWcVMTAAAAAAAAAAAAAAAAACyiiAmAAAAAAAAAAAAAAAAAFlFEBMAAAAAAAAAAAAAAACArCKICQAAAAAAAAAAAAAAAEBWEcQEAAAAAAAAAAAAAAAAIKsIYgIAAAAAAAAAAAAAAACQVQQxAQAAAAAAAAAAAAAAAMgqgpgAAAAAAAAAAAAAAAAAZBVBTOi2bdu26Sc/+YnGjRunoqIilZWVafLkybrvvvvk8/lSdp033nhDs2fP1tChQ+VwODR06FDNnj1bb7zxRrfzCIfD+uMf/6ipU6dqwIABKigo0OjRo3X11Vfrs88+S1lZkT3prI8+n08LFy7UD3/4Q02ePFmlpaXKz89XeXm5jj/+eN1+++3avXt3l/lMnz5dFoulWxtyWzrr4/z587tdj+bPn99lfj6fT/fee68mT56ssrIyFRUVady4cfrJT36ibdu2HVBZ0Xekq05u3bq12/Uxto0cOTJuXrSR/dvevXv16quv6tZbb9Xpp5+uiooK8/c5d+7ctFzz6aef1imnnKJBgwbJ6XRqxIgR+sEPfqCVK1d2Ow/ayP4rU3WyqalJCxYs0KWXXqqJEyeqpKRE+fn5GjBggGbMmKHf/OY3amxs7DKfkSNHHlAbi74tU/Xx9ttv7/Zn7bvvvttlfrW1tbr11lv1ta99TW63W263W1/72td06623qq6uLmXlRuZlok6+++67Pe5HTp8+PW5etJH925o1a/TLX/5Sp5xyinlvsLi4WGPHjtWll16q5cuXp/ya9COB9GtpadE//vEP3X///Tr33HM1atSotLfXK1as0A9+8AONGDFCTqdTgwYN0qmnnqqnn346LddD9qS7De7J/bB03fNAauTSOCdyQy6NDaFvy9X76WljAN2waNEiw+12G5LibmPHjjU2btx4QNeIRCLG5ZdfnvAakowrrrjCiEQiSfOpqakxJk+enDAPh8Nh/OlPfzqgsiK70lkfP/30U6O4uDhpPZRkuN1u45lnnkma17Rp07rMJ7Yhd6W7fXziiSe6XY+eeOKJpHlt3LjROPTQQ5PW61deeaXXZUXfkM46uWXLlm7Xx9h2yimnxM2LNrJ/S/b7vOSSS1J6LZ/PZ8ycOTPh9axWq3H77bd3mQ9tZP+WiTr5+uuvGw6Ho8s2bdCgQcY777yTNK8RI0Z0q30cMWJESsqOzMpUG3nbbbd1+7N26dKlSfNatWqVMWjQoITnV1VVGR988EHKyo7MykSdXLp0aY/7kVdddVXcvGgj+6+pU6d263d78cUXG8Fg8ICvRz8SyJzp06dntL2+7bbbDKvVmvCaZ5xxhuH3+1N+XWReJtrgntwPS/U9D6ROLo1zIjfk0tgQ+r5Mfrak6ntQOuUJ6MInn3yi8847T36/X8XFxfrP//xPzZgxQ36/X88884z+9Kc/acOGDTrjjDO0Zs0auVyuXl3n5z//uR577DFJ0tFHH62bb75Zo0eP1ubNm3Xvvffqk08+0aOPPqoBAwbo17/+ddw8IpGIZs+erQ8//FCSNGfOHF155ZUqKyvTBx98oF/96lfau3evrr76ag0ZMkSnn3567/5TkDXpro9er1ctLS2SpBNOOEFnnnmmJk2apPLyctXU1GjhwoX605/+JK/Xq+9///tyu91d1qNJkybpiSee6PV7Rt+VqfYx5q233tLgwYMTHh86dGjCY83NzTrjjDO0ceNGSdKVV16p888/XwUFBVq6dKnuvvtueb1enXfeeXr//fd11FFHHVBZkR3prpNDhgzR2rVru0x3991366mnnpIkXXLJJUnT0kb2f8OHD9e4ceO0ePHitOR/2WWX6fXXX5ckzZgxQzfccIMGDx6stWvX6te//rU2b96s22+/XVVVVbrqqqvi5kEbeXBJV52sq6tTMBiU1WrVySefrNNOO00TJ06Ux+PRjh07tGDBAj377LPavXu3zjzzzG7VpbPPPlu/+tWvEh632+0pfQ/IvHS3kTFdfX6PGjUq4bHt27dr1qxZqqmpUV5env793/9dZ555piTp1Vdf1W9/+1tVV1dr1qxZ+uijj5L2SdH3patOTp48uVv9yOuvv17Lli2T1HU/kjay/9m1a5ckafDgwfre976nqVOnavjw4YpEIlq5cqV+85vfaOfOnfrzn/+strY28ztHb9GPBDLHMAxzv6ysTJMmTdKKFSvM+7Cp9PDDD+uOO+6QJI0ePVo/+9nPNGHCBO3atUsPPPCAli5dqtdee02XXXbZAbcjyK5stMG/+tWvdPbZZyc8XlpaesDXQOrl0jgnckMujQ0h9+TC/fS0y2oIFXJC7CmovLw8Y8WKFZ2O33vvvWZk3m233dara3zxxRdGXl6eIcmYNGmS4fP5OhxvbW01Jk2aZJYjUeTqY489Zpbl2muv7XR848aNZlTsmDFjjLa2tl6VF9mT7vr4/vvvG+eee67x2WefJUzz8ssvGxaLxZBkjB492ohGo3HTxWYZmTZtWo/LgdyQifaxfbT9li1bel3WX/ziF2Y+9957b6fj77//vtkOU2dzVybqZFfC4bAxePBgQ5Lhcrk6fabH0Eb2b7feeqvxyiuvGLt37zYMo+NTi6l8cmTJkiVmvrNmzTLC4XCH4zU1Ncbw4cMNSYbH4zHq6+vj5kMb2f9lok4+88wzxtVXX21s27YtYZrf//735nVnzJiRMF1slhGe4u2fMtVGtp+J6UBcdNFFZj7PPfdcp+PPPvssT57nuEzVya40NDSYM9qNGTMmYTrayP7rjDPOMJ599tlOfbqYmpoaY+zYsWb9XLZsWa+vRT8SyKyHH37YeOqppzrc14+156mciamurs4oKSkxJBnDhw83ampqOhwPh8PGrFmzzL/brmajRN+WqTa4fd+I2U5yUy6NcyI35NLYEHJDrt1PTzeCmJDUBx98YFbkq6++Om6aSCRijB8/3qzMoVCox9f54Q9/aF5n5cqVcdOsXLkyaYCSYRhmOcrKyozW1ta4ae6+++6kN2DRd2WqPnbHd7/7XbMsH330Udw0DND3b5mqj6noqIZCIfMGzvjx4xNOV3v11Veb11q9enWvroXs6Stt5JtvvmmW49JLL02Yjjby4JKuL12nn366ecNg+/btcdM8/fTTSW9q0kYenLI1QG8YhnnT0mq1dhpUiWGA/uDSl4OYqqurzaVYTj311ITpTj31VLNeV1dX9/p66Buy1Ub+8Y9/NK97xx13JExHG3lwe+WVV8x68qMf/ajX+dCPBLIvHUFM8+bNM//enn766bhptm/fbthsNkOSMXPmzJRdG5mVyTaYIKbclmvjnOj7cmlsCLmrL99PzwSrgCRefvllc//SSy+Nm8Zqteriiy+WJDU2Nmrp0qU9uoZhGPrb3/4mSRo3bpyOO+64uOmOO+44HXbYYZKkv/3tbx2moJWkDRs2aP369ZKkc889V4WFhXHzmTt3rrn/0ksv9aisyK5M1MfumjFjhrm/efPmtFwDfVtfqo9dWbp0qZqamiTtW5LBao3/8U/7mNv6Sp3885//bO53tQQIcCCam5u1ZMkSSdJJJ52UcNrkOXPmyO12S4rfttFGItOmT58uSYpGo9qyZUt2CwN0YdGiRYpGo5IS9y+k/2sjo9GoFi1alImioR+K9SMtFovZZwX2l4r7MfQjgf4rdm/E7XZrzpw5cdMMHTpUJ510kiRpyZIlam5uzlTxkEK0weiuXBrnRG7oK/fhgZ5K1fegTCCICUktX75cklRUVKRjjjkmYbpp06aZ+++//36PrrFlyxZzzfv2+SS7zs6dO7V169a4Ze0qn0GDBmns2LG9KiuyKxP1sbuCwaC5b7PZ0nIN9G19qT52pbvt46RJk8wAUNrH3NMX6mRzc7P5JW7kyJH61re+ldL8gfY+/PBDhUIhScnbNrvdbt48+vDDD9XW1tbhOG0kMo1+JHJJd9vIvtDnRW7bvHmzVqxYIUmaOnWqRo4cmd0Coc9Kxeco/UigfwqFQlq9erUk6fjjj5fdbk+YNvY3GwwGtWbNmoyUD6lFG4zuyqVxTuSGvnAfHuiNVH0PygSCmJBUbGajMWPGKC8vL2G6cePGdTqnu9atWxc3n55epzf5bN++Xa2trd0uK7IrE/Wxu5YtW2bujx8/Pmnazz//XMcee6w8Ho+cTqeGDh2qs88+W3/+85+z0vAjNbJRHy+99FINHjxYdrtdFRUVOu644/Rf//Vf2rlzZ9Lzuts+5uXlacyYMSkpKzKvL7SRL7zwgnw+nyTpoosuksVi6fIc2kj0Vm/6fuFwWBs3buxVPrSRSJVYPzI/P9+sU4n84x//0FFHHSWXy6XCwkKNGjVK5513nl5++WWe2ESPnHLKKaqsrJTdbldlZaWmT5+ue+65Rw0NDUnPi7WRJSUlGjRoUMJ0VVVV5lN6tJHojd7M5kkbeXDqyf2YROhHAv3Thg0bFIlEJB3YOANyQ7ba4D/84Q8aM2aMnE6nSkpKdMQRR+iaa67Rxx9/fMB5Iz1yaZwTuSGXxoaA9lL1PSgTCGJCQoFAQLW1tZKUcDqxmNLSUhUVFUnaFxjUEzt27DD3u7rOsGHDzP39r9ObfAzD6HAe+q5M1cfu+PTTT/Xaa69JkiZMmNDlTbM9e/Zo9erVampqUjAY1M6dO7Vo0SJdcsklOuqoo+io5qBs1cd3331X1dXVamtrU11dnT744APdddddGjNmjB5++OGE58XauaKiInk8nqTXiLWPNTU1HZ5wRd/WV9rI9oNP3V0ChDYSvZXqPiRtJDLhtdde0z//+U9J0qmnnmoGfSSyZcsWffrpp2ppaZHf79fWrVv13HPPafbs2Zo6dSo3q9Btf//731VTU6O2tjbV1NRo2bJl+s///E8dcsgh5rIH8cTayK7aWen/2sh0fAdD/2YYhv76179KkgoKCvS9732vW+fRRh58otGo7rnnHvPnc889t1f50I8E+qdU/W0jN2SrDf7444+1efNmBYNBeb1erVu3Tg8//LCOOeYYXXPNNbTxfUyujXOi78u1sSGgvVxqqxKHB+Kg134t6OLi4i7TFxUVqbW1VS0tLWm7Tqyxl9TpOqnKB31TpupjV4LBoK644grzqZ677rorYVqr1aoTTzxRM2fO1MSJE1VeXq7m5mZ9/PHHevjhh7V+/XqtW7dOM2bM0OrVqzV8+PCUlhXpk+n6eMghh2jOnDk6/vjjzY7Dl19+qRdffFEvvPCCAoGArrnmGlksFl111VUJy9vdssa0tLTI4XD0qszIrL7QRn711VfmU9Hf+MY3upxdhDYSByrVfUjaSKRbfX29rrvuOkn7lr/55S9/mTCt3W7XWWedpVNOOUVHHnmkSkpK1NjYqJUrV+p///d/tX37dr3//vs6+eSTtXLlSpWUlGTqbSDHTJgwQd/5znc0ZcoUDR48WG1tbfriiy+0YMECLV68WI2Njfrud7+rV155Raeffnqn83vTRvIdGz21fPlyffnll5Kk2bNny+VyJU1PG3nw+u///m9zqag5c+YkXb4jGfqRQP/E+MDBJdNtsMfj0ezZszV9+nQdeuihcjqdqq6u1uLFi/XYY4+ppaVFDz/8sJqbm7VgwYIe54/0yLVxTvR9uTY2BLSXS20VQUxIKBAImPvJ1o+OiXX8/H5/2q7TvnO5/3VSlQ/6pkzVx65cf/315jrpl1xyiWbNmpUw7cKFC+M+BTJ16lRde+21uvLKK/Xkk09qz549uvHGG7Vw4cKUlhXpk8n6OHv2bF1yySWdluWaPHmyzjvvPL366quaM2eO2tra9OMf/1hnnXVWp6U+YuXtSVl7W15kR19oI//617+ay3Z0ZxYm2kgcqFT3IWkjkU6RSETf//73tW3bNknSf/3Xf+noo49OmH716tVx28jp06fr+uuv1znnnKPFixdr/fr1uuOOO/Tb3/42XUVHDrvxxht1++23d3r92GOP1cUXX6yHH35Y11xzjSKRiK644gpt3rxZTqezQ9retJG0j+ipv/zlL+Z+d/qRtJEHp2XLlumnP/2pJKmyslL/+7//2+u86EcC/RPjAweXTLbBgwcP1s6dO1VYWNjh9aOPPlozZ87Uddddp5NOOklfffWVnnrqKZ133nk666yzenwdpF6ujXOi78u1sSGgvVxqq1hODgm1v3kZCoW6TB+bJrOgoCBt12k/Fef+10lVPuibMlUfk7n77rv16KOPStrXSXjwwQeTpk82jW1+fr4effRRHXbYYZKkl156ianuc0gm62NJSUmnTmp7Z555pm699VZJks/n02OPPdYpTay8PSmrRPuYS/pCGxkbfHI4HDrvvPO6TE8biQOV6j4kbSTS6dprr9Wbb74pad9n9y9+8Yuk6ZO1kS6XS88995zKysokSY888ki36i8OPl0tq3H11Vfr8ssvlyTt2rVLL774Yqc0vWkjaR/RE4FAQM8//7ykfQOEJ510Upfn0EYefD777DPNnj1b4XBYTqdTzz//vCorK3udH/1IID6LxXLA2/z587NWfsYH+qZ01atMtsF2u71TAFN7hx56qLk0riT94Q9/6PE1kB65Ns6Jvi/XxoaA9nKprSKICQm1n767O9OEtba2Sure9Hm9vU7sGvGuk6p80Ddlqj4m8vDDD+tnP/uZJGncuHF6/fXXO0yl1xt5eXnmoIEkcxkm9H3Zro/7u+qqq8zObLx6FCtvT8oq0T7mkmzXydWrV+vzzz+XJJ111lldDpp2B20kupLqPiRtJNLlP//zP/XII49I2jfb3HPPPSebzXZAeZaUlOj888+XtK9exmYKBXrq6quvNvdT1Y+kfURPLFq0SI2NjZKk73//+wfcPkq0kf3Nli1bdMopp6ihoUE2m03PPPOMvvWtbx1QnvQjgf6J8YGDS19rg6dOnarDDz9c0r6lcqPRaFqug57JtXFO9H3Zvg+/v67GhoD2cqmtYjk5JOR0OlVeXq66ujrt2LEjadqGhgazMsfW5OyuoUOHmvtdXWf79u3m/v7X2T+fioqKLvOxWCwdzkPflan6GM/TTz+ta6+9VpI0YsQI/f3vf09av3oi9sVGErOM5JBs1sd4KisrVV5ertra2rj1aOjQofrggw/U2tqqxsbGpAEmsfZxwIABvVofHtmR7Tr55z//2dzvzhIg3UUbiWT27/tNmjQpYdqu+pC0kUiXefPm6Z577pEkff3rX9err76asqeXaCORCl3Vo6FDh2rPnj1d9i+k/2sj09XnRf9EPxLJ7Nq1SyeddJJ27doli8Wixx9/XGefffYB50s/Eohv/fr1B5xHVVVVCkrSO6kaZ0Bqpate9cU2+PDDD9e6desUCARUV1enAQMGpO1a6J5cG+dE35ft+/D762psCGgvVd+DMoEgJiR1+OGH67333tOmTZsUDoeVlxe/ysRmX5Ck8ePH9/ga8fLp6XX2z+eoo47qMp9hw4Yd8Gw6yJxM1Mf9LVq0SBdffLGi0aiqqqq0ZMmSlAa+JZsKEn1bNupjMsnq0uGHH24uD/L555/ruOOOi5suHA5r8+bNktJbVqRHtupkW1ubnnnmGUn7vjSddtppB5xnDG0kkulNHzIvL0+HHnpop3xoI5EODz30kH76059K2ldn3nrrLbnd7pTlTxuJVOiqHh1++OH66KOP1NTUpN27d2vQoEFx01VXV8vr9UqijUT37d27V2+99ZakfYGeRx55ZMrypo3MfbW1tTr55JP15ZdfStq3NE+qAt3oRwLxjRs3LttFOCBjx46VzWZTJBI5oHEGpFa66lVfbIPpf/RNuTTOidyQS2NDQHup+h6UCSwnh6S++c1vSto3ZdhHH32UMF37KepOOOGEHl1j1KhRGjx4cKd84vnHP/4hSRoyZIhGjhwZt6xd5bN7925t2LChV2VFdmWiPra3ZMkSnXvuuQqHwyovL9ff//53jR49utf5xbNu3TpzP/Z3gNyQ6fqYTE1NjWprayXFr0fdbR/XrFljPhlA+5h7slUnX3vtNdXV1UmSLrzwwoRf2nqDNhLJTJ48WXa7XVLyti0UCmnVqlXmOfn5+R2O00YiHf7yl7/o+uuvlyQdcsghevvtt1M2k2cMbSRSoat61N02MhN9XvQ/Tz31lMLhsKTUzsIk0UbmuqamJp166qnm7/Gee+7Rddddl7L86UcC/ZPdbteUKVMkSStXrlQoFEqYNvY363A4ks5CgL6rL7bBsc8th8Oh8vLytF4L3ZdL45zIDbk0NgS0l6rvQZlAEBOS+s53vmPuP/HEE3HTRKNRc/pvj8ejGTNm9OgaFovFnAr6888/N/8o9rdq1Soz6u/ss8/uFFk6duxYM5L1ueeek8/ni5vP/Pnzzf3Zs2f3qKzIrkzUx5gVK1bo7LPPVjAYVElJid566y0dccQRvcorkXA4rMcff9z8+Vvf+lZK80d6ZbI+duWRRx6RYRiSpGnTpnU6Pn36dJWUlEiSnnzySTPt/mgfc1u26mT7JUAuueSSA84vhjYSXXG5XDrxxBMlSW+//XbCKZwXLlxozg4Sr22jjUSqLVy4UJdeeqkMw9DQoUO1ZMmSlN9IampqMmfBKywsZOAFvfbwww+b+/H6kWeddZas1n23jhL1L6T/ayOtVqvOOuus1BYS/VasH5mfn68LL7wwZfnSRuY2n8+nM844Qx9//LEk6ec//7luueWWlF6DfiTQf8XujXi9Xi1cuDBumh07dujtt9+WJJ144olyuVyZKh5SqK+1we+//74+++wzSfsCHGJ9aGRfLo1zIjfk0tgQ0F6qvgdlhAF0YerUqYYkIy8vz1ixYkWn4/fee68hyZBk3HbbbZ2OL1261Dx+ySWXxL3GF198YdhsNkOSMWnSJMPn83U47vP5jEmTJpnl2LBhQ9x8HnvsMfNa1113XafjmzZtMtxutyHJGDNmjNHW1tb1fwD6lEzUx08++cTweDyGJKOoqMhYvnx5j8v5zjvvGA0NDQmPh0Ih45JLLjHLMmvWrB5fA9mX7vq4ZcsW4+OPP05ahldeecWw2+2GJKOgoMDYsWNH3HS/+MUvzGvde++9nY6vWLHCyMvLMyQZ06ZNS3pN9F2ZaCPbq6urM+vfhAkTul1O2siDz5YtW3pUtwzDMJ544omk9dUwDGPJkiVmmrPOOssIh8MdjtfU1BjDhw83JBkej8eor6+Pmw9t5MEnXXXyrbfeMtvFyspK4/PPP+9x2d54441O34faa25uNk455RSzLD/60Y96fA30Lemoj//85z+NjRs3Js3j4YcfNvMYNGiQ0dLSEjfdRRddZKZ7/vnnOx1/7rnnelx+9G3paiPb+9e//tWrvh5tZP8WDAY7/P5uuOGGXuVDPxLIDSNGjDAkGSNGjOhW+vafT4n+nurq6oySkhIz39ra2g7Hw+GwMWvWLDOfpUuXHtibQFalqg2O5ZGoLr700ktGNBpNeP7GjRvNzwxJxosvvtjTt4I0y6VxTuSGXBobQm7q6/fT0y11632g33rggQd0wgknyO/365RTTtHPfvYzzZgxQ36/X88884weeeQRSftmQvrJT37Sq2uMHTtWN910k+655x6tWbNGJ5xwgm655RaNHj1amzdv1rx58/TJJ59Ikm666aaEay9ecsklevzxx/X+++/rwQcf1O7du3XllVeqtLRUq1ev1p133imv1yur1arf//73KV3yBpmR7vq4efNmnXrqqWpsbJQk/epXv1JJSYn+9a9/JTynsrJSlZWVHV578sknddZZZ+mss87S9OnTddhhh8ntdqulpUUfffSRHnnkEXN62crKSj3wwAM9LiuyL931cevWrZoxY4aOP/54zZo1SxMnTjTr2pdffqkXXnhBL7zwghlpf//992vIkCFx87rpppv07LPPasOGDbr55pu1adMmnX/++SooKNDSpUv161//WuFwWAUFBfrd737Xu/8QZF0mPrPbe+aZZ8zp2XsyCxNtZP+3fPlybdq0yfw5Nq2xJG3atKnDk5CSNHfu3F5d59vf/rbOP/98PfPMM1q0aJFOPvlk3XjjjRo8eLDWrl2ru+66S1999ZUkad68eSotLY2bD21k/5eJOrlq1SrNnj1boVBI+fn5+u///m+1tbUl7UcOHTpUHo+nw2v33HOPvv/972vOnDn65je/qdGjR6u4uFhNTU1asWKF/vjHP5r1+rDDDtPtt9/e47IiuzJRHz/66CNdccUVmjFjhk4//XRNmDBB5eXlCofD+vzzz7VgwQItXrxYkmSz2fTII4+oqKgobl533XWX3nzzTdXU1OiCCy7QmjVrdOaZZ0qSXn31Vf3mN7+RJA0YMEC/+tWvelxWZF+mPrfbe/LJJ839nvQjaSP7twsuuMBsm7797W/r8ssvT/o5arfbNXbs2F5di34kkFmbNm3S8uXLO7zW0tJi/rv/Z81pp52mQYMG9fg6ZWVlmjdvnq655hpt27ZNxx57rH7+859rwoQJ2rVrl373u99p6dKlkva1OdOnT+/V+0HfkKk2ePbs2RozZozmzJmjKVOmaOjQoXI4HKqurtZbb72lxx57zKzP5557rubMmZOid4hUyaVxTuSGXBobQm7ItfvpaZeV0CnknEWLFpkzGMXbxo4dm/Apz+7O6hCJRIzLLrss4TUkGZdffrkRiUSSlrWmpsaYPHlywjwcDofxpz/96UD+O5Bl6ayP7aNUu7vFi2ZtP4NIsm3ChAnGZ599luL/IWRSOutj++PJtsLCQuPhhx/usqwbN240Dj300IT5uN1u45VXXjnQ/xJkWSY+s2OOPfZYQ5Jhs9mM6urqbpeRNrL/6+7vOLbF090ZHXw+nzFz5syEeVut1m7NCEEb2b9lok7edtttPe5HPvHEE53ymTZtWrfOnTZtGk/Z5ahM1Mfufq8pLy83Xn755S7LvGrVKmPQoEEJ8xk0aJCxatWqA/2vQZZk8nPbMPbd/xk8eLAhySgtLTWCwWC3y0ob2b/19HM00YwZ9COBvqen91zjzZDUnZmYYm699VbDYrEkzH/mzJmG3+9Pz5tFRqWiDe7qc6W79faHP/yhEQgE0vAukQq5NM6J3JBLY0Po+3Lxfno6MQ0NumXWrFn65z//qQceeECvvfaaduzYIbvdrjFjxuh73/uerr/+ehUWFh7QNaxWqx577DF997vf1SOPPKIPP/xQtbW1qqio0OTJk3X11Vfr9NNP7zKfiooKrVixQn/605/01FNPaf369WptbdXgwYN14okn6oYbbtARRxxxQGVFdmWiPh6oW265RUcddZRWrlypdevWqaamRvX19XI4HBo4cKAmTZqkc845R7Nnz5bNZstqWXFg0lkfjznmGP31r3/VypUrtWbNGlVXV6u2tlbhcFilpaU64ogjdOKJJ+qKK67oNBtYPGPGjNEnn3yiBx98UM8//7w2bdqkUCikYcOGaebMmbrhhhs0YsSIXpUVfUem2siNGzfqgw8+kCSdfPLJPXpCkjYSqVRQUKDXXntNTz31lObPn69PP/1UjY2NGjhwoKZOnarrr79exx9/fJf50Eair7j//vu1ZMkSrVy5Ul988YVqa2vV2NiowsJCDR48WMcee6wuuOACnXLKKbJYLNkuLvqomTNn6rHHHtPKlSv1ySefaM+ePaqrq5NhGCorK9PEiRN12mmnae7cuXK73V3md+yxx2rt2rV64IEH9PLLL2vr1q2SpFGjRunss8/WjTfeqPLy8jS/K/QXS5Ys0a5duyRJ5513nux2e7fPpY1EKtGPBPqvO+64Q6eeeqoefPBBvffee9qzZ488Ho8mTpyoSy+9VBdccEG2i4gUyUQbvGjRIq1cuVIffPCBtm3bptraWrW2tsrtduuQQw7R1KlTddlll+nII49M0btCOuTSOCdyQy6NDQHtpep7UDpZDOP/zTMGAAAAAAAAAAAAAAAAAFlgzXYBAAAAAAAAAAAAAAAAABzcCGICAAAAAAAAAAAAAAAAkFUEMQEAAAAAAAAAAAAAAADIKoKYAAAAAAAAAAAAAAAAAGQVQUwAAAAAAAAAAAAAAAAAsoogJgAAAAAAAAAAAAAAAABZRRATAAAAAAAAAAAAAAAAgKwiiAkAAAAAAAAAAAAAAABAVhHEBAAAAAAAAAAAAAAAACCrCGICAAAAAAAAAAAAAAAAkFUEMQEAAAAAAAAAAAAAAADIKoKYAAAAAAAAAAAAAAAAAGQVQUwAAAAAAAAAAAAAAAAAsoogJgAAAAAAAAAAAAAAAABZRRATAAAAAAAAAAAAAAAAgKwiiAkAAAAAAAAAAAAAAABAVhHEBAAAAAAAAAAAAAAAACCrCGICAAAAoPnz58tischisWjr1q3ZLk5GjBw50nzPsW3kyJHZLlZct99+e6eyWiwWvfvuu9kuGgAAAAAAAAAAKUEQEwAAAJDDtm7dGje4pacbAAAAAAAAAABANhHEBAAAAOCgdvbZZ2vt2rVau3atFi9enO3ixHXttdeaZXz88cezXRwAAAAAAAAAAFIuL9sFAAAAANB7Q4YM0dq1axMenzBhgiRp0qRJeuKJJxKmO/LIIzV37txUFy8neDweHXnkkdkuRlKVlZWqrKyUJNXW1ma5NAAAAAAAAAAApB5BTAAAAEAOy8/P71YATlFRUZ8P1AEAAAAAAAAAAAcvlpMDAAAAAAAAAAAAAAAAkFUEMQEAAADQ/PnzZbFYZLFYtHXr1k7Hp0+fLovFounTp0uSNm3apGuuuUaHHHKICgoKNHLkSF1++eXatm1bh/P+9a9/6dJLL9Uhhxwip9OpYcOG6Yc//KH27t3brXK9/PLL+t73vqfhw4fL6XTK4/Fo0qRJuuOOO9TQ0HCgb7vbRo4cKYvFYi6598UXX+jKK6/UyJEj5XA4NHDgQM2ePVurVq1Kmk8gENDvf/97TZ8+XQMGDFB+fr7Kysp02GGH6fTTT9dvf/vbuP//AAAAAAAAAAD0dywnBwAAAKBH3n77bc2ZM0fNzc3ma9u2bdPjjz+uV199VcuWLdO4ceP09NNPa+7cuQqFQma6HTt26I9//KPeeOMNrVixQoMHD457jYaGBp1zzjl65513OrweDAb10Ucf6aOPPtJDDz2kv/3tbzruuOPS80YTeOmll/SDH/xAPp/PfG3v3r16+eWX9corr2jBggU677zzOp1XXV2tk046SevWrevwekNDgxoaGrRhwwa9+eab2rVrl+6///60vw8AAAAAAAAAAPoSZmICAAAA0G27du3SueeeK4/Hoz/84Q/64IMP9N577+nGG2+UxWLR3r17dcUVV+jDDz/UxRdfrNGjR+vRRx/V6tWrtXTpUl100UWS9gU9/fu//3vcawSDQZ100kl65513ZLPZdNFFF+npp5/WqlWr9N577+muu+5SeXm59u7dq5kzZ3aa/Smd1q5dqwsvvFADBw7U//zP/2jVqlVauXKlbr/9djmdTkUiEV111VWqqanpdO6PfvQjM4DpBz/4gRYuXKhVq1bpww8/1KJFi3Trrbdq4sSJGXsvAAAAAAAAAAD0JczEBAAAAKDbNm7cqEMPPVTvv/++BgwYYL7+zW9+U3l5ebr//vv1/vvv64wzztCUKVP097//XYWFhWa66dOnKxAI6Pnnn9eLL76ompqaDvlI0i9/+Ut9/PHH8ng8evvtt3XMMcd0OP7Nb35T3//+93X88cerurpaP/vZz7RgwYL0vvH/5+OPP9Yxxxyjd955R26323z9uOOO05gxY/SDH/xAXq9Xf/3rX/XjH//YPB4IBLRo0SJJ0k9+8pO4My3NmjVLd9xxh+rr69P/RgAAAAAAAAAA6GOYiQkAAABAj/z+97/vFHgkSddee625X1tbq0cffbRDAFPMD3/4Q0lSOBzWypUrOxxraWnRgw8+KEm68847OwUwxYwYMUK/+MUvJEnPP/+8Wltbe/dmeuHxxx/vEMAUc+GFF5rL47333nsdjtXX16utrU2S9K1vfStp/mVlZSkqKQAAAAAAAAAAuYMgJgAAAADd5vF4dOqpp8Y9NmrUKLlcLknS1772NY0fPz5uuvZLpn355Zcdji1btkxNTU2SpHPOOSdpWWLBQG1tbfroo4+69wYO0IQJE/S1r30t7jGLxaKjjz5aUuf3VV5eLrvdLkn6y1/+onA4nN6CAgAAAAAAAACQYwhiAgAAANBthx56qCwWS8LjHo9HkjR27Ngu00hSc3Nzh2Nr1qwx96uqqmSxWBJuRx55pJl29+7dPXwnvTNu3Likx2OzKO3/vhwOh8477zxJ0gsvvKAxY8bo5ptv1uuvv67Gxsa0lBUAAAAAAAAAgFxCEBMAAACAbou3PFx7Vqu1y3SxNJIUiUQ6HNu7d2+vyuXz+Xp1Xk919/3v/74k6X/+5380a9YsSdK2bdt033336YwzzlB5ebkmT56s++67z5yFCgAAAAAAAACAg01etgsAAAAAADHtg38+/vhj5efnd+u8oUOHpqtIKeN2u7Vo0SKtXr1azz33nN599139f//f/6dIJKI1a9ZozZo1uv/++/Xyyy/r+OOPz3ZxAQAAAAAAAADIKIKYAAAAAPQZ5eXl5v6AAQNyIjipp6ZMmaIpU6ZI2rfs3Lvvvqv58+dr4cKF2rt3r7773e9q8+bNKigoyHJJAQAAAAAAAADIHJaTAwAAANBnHH300eb++++/n8WSZIbL5dKsWbP04osv6t/+7d8kSdXV1Vq+fHmWSwYAAAAAAAAAQGYRxAQAAACgzzjppJNUWFgoSfr9738vwzCyXKLMOfHEE8392traLJYEAAAAAAAAAIDMI4gJAAAAQJ/h8Xh0/fXXS5JWrFihH//4x4pGownT79mzR48++mimitdrX375pZYtW5Y0zeLFi839UaNGpbtIAAAAAAAAAAD0KXnZLgAAAAAAtPfLX/5Sy5Yt0wcffKAHHnhA7777rq688kodddRRKioqUkNDgz777DO9/fbbeuONNzRhwgRdccUV2S52Ul999ZVmzJihww8/XLNnz9akSZM0ZMgQSdL27dv17LPP6rnnnpMkHXXUUTr22GOzWVwAAAAAAAAAADKOICYAAAAAfYrD4dDf//53zZ07VwsXLtSnn35qzs4Uj9vtzmDpDsy6deu0bt26hMfHjRunhQsXymKxZLBUAAAAAAAAAABkH0FMAAAAAPocl8ulF198UcuXL9eTTz6p9957T7t27ZLf75fb7dbo0aM1ZcoUnXHGGTrllFOyXdwuTZ06Ve+++67eeustrVq1Stu3b9eePXsUCARUVlamiRMnas6cOZo7d64cDke2iwsAAAAAAAAAQMZZDMMwsl0IAAAAAMi0kSNHatu2bbrkkks0f/78bBen2959913NmDFDkrR06VJNnz49uwUCAAAAAAAAACAFmIkJAAAAwEGtsbFR//rXvyRJdrtdY8eOzXKJOtu7d6/27t0rSdqyZUuWSwMAAAAAAAAAQOoRxAQAAADgoPa3v/1Nf/vb3yRJI0aM0NatW7NboDgeeugh3XHHHdkuBgAAAAAAAAAAaWPNdgEAAAAAAAAAAAAAAAAAHNwshmEY2S4EAAAAAAAAAAAAAAAAgIMXMzEBAAAAAAAAAAAAAAAAyCqCmAAAAAAAAAAAAAAAAABkFUFMAAAAAAAAAAAAAAAAALKKICYAAAAAAAAAAAAAAAAAWUUQEwAAAAAAAAAAAAAAAICsIogJAAAAAAAAAAAAAAAAQFYRxAQAAAAAAAAAAAAAAAAgqwhiAgAAAAAAAAAAAAAAAJBVBDEBAAAAAAAAAAAAAAAAyCqCmAAAAAAAAAAAAAAAAABkFUFMAAAAAAAAAAAAAAAAALKKICYAAAAAAAAAAAAAAAAAWUUQEwAAAAAAAAAAAAAAAICsIogJAAAAAAAAAAAAAAAAQFYRxAQAAAAAAAAAAAAAAAAgqwhiAgAAAAAAAAAAAAAAAJBVBDEBAAAAAAAAAAAAAAAAyCqCmAAAAAAAAAAAAAAAAABkFUFMAAAAAAAAAAAAAAAAALKKICYAAAAAAAAAAAAAAAAAWfX/A6SHiJ84fHZ0AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "dp = Pulse(0, 2, 1, 4e9, 0, Drag(2,1), 0, PulseType.DRIVE)\n", - "dp.plot(sampling_rate=100)\n", - "# envelope i & envelope q should cross nearly at 0 and at 2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Sudden variant Net Zero" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "SNZ.__init__() got an unexpected keyword argument 't_half_flux_pulse'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m dp \u001b[38;5;241m=\u001b[39m FluxPulse(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m40\u001b[39m, \u001b[38;5;241m0.9\u001b[39m, \u001b[43mSNZ\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt_half_flux_pulse\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m17\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mb_amplitude\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.8\u001b[39;49m\u001b[43m)\u001b[49m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m200\u001b[39m)\n\u001b[1;32m 2\u001b[0m dp\u001b[38;5;241m.\u001b[39mplot()\n", - "\u001b[0;31mTypeError\u001b[0m: SNZ.__init__() got an unexpected keyword argument 't_half_flux_pulse'" - ] - } - ], - "source": [ - "dp = FluxPulse(0, 40, 0.9, SNZ(t_half_flux_pulse=17, b_amplitude=0.8), 0, 200)\n", - "dp.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Infinite Impulse Response (Filter) Shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "b = [1, 2, 1]\n", - "a = [1, -1.5432913909679857, 0.6297148520559599]\n", - "\n", - "# import numpy as np\n", - "# http://jaggedplanet.com/iir/iir-explorer.asp\n", - "# low pass\n", - "# b = np.array([1, 2, 1])\n", - "# a = np.flip(np.array([0.277023226134283,-0.7651127295946996,1]))\n", - "# high pass\n", - "# b = np.array([1, -2, 1])\n", - "# a = np.flip(np.array([0.7466573279103673,-1.7095165404698354,1]))\n", - "\n", - "dp = FluxPulse(0, 80, 0.9, IIR(\n", - " b=b, \n", - " a=a,\n", - " target=SNZ(t_half_flux_pulse=30, b_amplitude=1)), \n", - " 0, 200)\n", - "dp.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### eCap Pulse Shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dp = Pulse(0, 40, 0.9, 400e6, 0, eCap(alpha=2), 0, PulseType.DRIVE)\n", - "dp.plot(sampling_rate=100)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Waveform" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Overview" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `Waveform` object is used to hold the array of samples that make up a waveform. This simple class is hashable so that it allows the comparison of two `Waveforms`, which is later needed by the driver.\n", - "The class has a writable `serial` attribute that can be set externally." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "duration = 200 # ns\n", - "amplitude = 0.9 \n", - "num_samples = int(duration) # default sampling rate of 1GSps\n", - "waveform = Waveform(amplitude * np.ones(num_samples))\n", - "waveform.serial = f\"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(amplitude, '.6f').rstrip('0').rstrip('.')}, shape = Rectangular())\"\n", - "waveform.serial" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Pulse Sequence" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Overview" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "One of the key enhancements introduced in this new version of the driver are those related to the `PulseSequence`. Previously, `PulseSequence` wasn't more than an a list to contain the sequence of pulses and two attributes to store the time and phase of the sequence.\n", - "The new version of `PulseSequence` introduces many features. It is a sorted collection of pulses with many auxiliary methods." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Initialisation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Multiple pulses can be used to initialise a `PulseSequence` or can be added to it:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "p1 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5,1), 1, PulseType.DRIVE)\n", - "p2 = Pulse(500, 40, 0.9, 100e6, 0, Drag(5,1), 2, PulseType.DRIVE)\n", - "p3 = Pulse(400, 40, 0.9, 100e6, 0, Drag(5,1), 3, PulseType.DRIVE)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# initialise an empty PulseSequence\n", - "ps = PulseSequence()\n", - "assert type(ps) == PulseSequence" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# initialise a PulseSequence with multiple pulses at once\n", - "ps = PulseSequence(p1, p2, p3)\n", - "assert ps.count == 3 and len(ps) ==3\n", - "assert ps[0] == p1\n", - "assert ps[1] == p2\n", - "assert ps[2] == p3\n", - "# * please note that pulses are always sorted by channel first and then by their start time" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# initialise a PulseSequence with the sum of multiple pulses\n", - "other_ps = p1 + p2 + p3\n", - "assert other_ps.count == 3 and len(other_ps) ==3\n", - "assert other_ps[0] == p1\n", - "assert other_ps[1] == p2\n", - "assert other_ps[2] == p3\n", - "# * please note that pulses are always sorted by channel first and then by their start time\n", - "\n", - "plist = [p1, p2, p3]\n", - "n = 0\n", - "for pulse in ps:\n", - " assert plist[n] == pulse\n", - " n += 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "p4 = Pulse(300, 40, 0.9, 50e6, 0, Gaussian(5), 1, PulseType.DRIVE)\n", - "p5 = Pulse(200, 40, 0.9, 50e6, 0, Gaussian(5), 2, PulseType.DRIVE)\n", - "p6 = Pulse(100, 40, 0.9, 50e6, 0, Gaussian(5), 3, PulseType.DRIVE)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# multiple pulses can be added at once\n", - "yet_another_ps = PulseSequence()\n", - "yet_another_ps.add(p4)\n", - "yet_another_ps.add(p5, p6)\n", - "assert yet_another_ps[0] == p4\n", - "assert yet_another_ps[1] == p5\n", - "assert yet_another_ps[2] == p6" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Operators" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "PulseSequence support a number of operators(`==`, `!=`, `+`, `+=`, `*`, `*=`). Below are a few examples:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "ps += yet_another_ps\n", - "assert ps.count == 6\n", - "ps += ReadoutPulse(800, 200, 0.9, 20e6, 0, Rectangular(), 1)\n", - "ps = ps + ReadoutPulse(800, 200, 0.9, 20e6, 0, Rectangular(), 2)\n", - "ps = ReadoutPulse(800, 200, 0.9, 20e6, 0, Rectangular(), 3) + ps\n", - "assert ps.count == 9\n", - "print(ps)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "ps.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`PulseSequence` now implements `__contains__()` so one can check if a `Pulse` is included in the `PulseSequence` likw so: " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "assert p5 in ps" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Attributes & Methods" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`PulseSequence` includes the following (read only) attributes:\n", - "- `pulses` a list containing the pulses of the sequence\n", - "- `serial`\n", - "- `count`\n", - "- `is_empty`\n", - "- `start`\n", - "- `finish`\n", - "- `duration`\n", - "- `channels`\n", - "- `pulses_overlap`\n", - "- `channels`\n", - "- `ro_pulses`\n", - "- `qd_pulses`\n", - "- `qf_pulses`\n", - "\n", - "\n", - "`PulseSequence` implements the following methods:\n", - "- `add()`\n", - "- `pop()`\n", - "- `remove()`\n", - "- `clear()`\n", - "- `shallow_copy()`\n", - "- `deep_copy()`\n", - "- `get_channel_pulses()`\n", - "- `get_pulse_overlaps()` returns a dictionary of time intervals with the list of pulses in it\n", - "- `separate_overlapping_pulses()`\n", - "- `plot()`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "p1 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5,1), 1, PulseType.DRIVE)\n", - "ps = PulseSequence(p1)\n", - "assert ps.count == 1\n", - "ps *= 3\n", - "assert ps.count == 3\n", - "ps *= 3\n", - "assert ps.count == 9" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "p1 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5,1), 1, PulseType.DRIVE)\n", - "p2 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5,1), 2, PulseType.DRIVE)\n", - "ps = 2 * p2 + p1 * 3\n", - "assert ps.count == 5" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "ps.clear()\n", - "assert ps.count == 0\n", - "assert ps.is_empty" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "p1 = Pulse(20, 40, 0.9, 200e6, 0, Drag(5,1), 1, PulseType.DRIVE)\n", - "p2 = Pulse(60, 1000, 0.9, 20e6, 0, Rectangular(), 2, PulseType.READOUT)\n", - "ps = p1 + p2\n", - "assert ps.start == p1.start\n", - "assert ps.finish == p2.finish\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "p1 = DrivePulse(0, 400, 0.9, 20e6, 0, Gaussian(5), 10)\n", - "p2 = ReadoutPulse(100, 400, 0.9, 20e6, 0, Rectangular(), 30)\n", - "p3 = DrivePulse(300, 400, 0.9, 20e6, 0, Drag(5,50), 20)\n", - "p4 = DrivePulse(400, 400, 0.9, 20e6, 0, Drag(5,50), 30)\n", - "p5 = ReadoutPulse(500, 400, 0.9, 20e6, 0, Rectangular(), 20)\n", - "p6 = DrivePulse(600, 400, 0.9, 20e6, 0, Gaussian(5), 30)\n", - "\n", - "ps = PulseSequence(p1, p2, p3, p4, p5, p6)\n", - "assert ps.channels == [10, 20, 30]\n", - "assert ps.get_channel_pulses(10).count == 1 \n", - "assert ps.get_channel_pulses(20).count == 2 \n", - "assert ps.get_channel_pulses(30).count == 3 " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "ps.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "assert ps.pulses_overlap == True\n", - "assert ps.get_channel_pulses(10).pulses_overlap == False\n", - "assert ps.get_channel_pulses(20).pulses_overlap == True\n", - "assert ps.get_channel_pulses(30).pulses_overlap == True\n", - "\n", - "channel10_ps = ps.get_channel_pulses(10)\n", - "channel20_ps = ps.get_channel_pulses(20)\n", - "channel30_ps = ps.get_channel_pulses(30)\n", - "\n", - "split_pulses = PulseSequence()\n", - "overlaps = channel20_ps.get_pulse_overlaps()\n", - "n = 0\n", - "for section in overlaps.keys():\n", - " for pulse in overlaps[section]:\n", - " sp = SplitPulse(pulse, section[0], section[1])\n", - " sp.channel = n\n", - " split_pulses.add(sp)\n", - " n += 1\n", - "split_pulses.plot()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "n = 70\n", - "for segregated_ps in ps.separate_overlapping_pulses():\n", - " n +=1\n", - " for pulse in segregated_ps:\n", - " pulse.channel = n\n", - "ps.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "p1 = DrivePulse(t0, 400, 0.9, 20e6, 0, Gaussian(5), 10)\n", - "p2 = ReadoutPulse(p1.finish, 400, 0.9, 20e6, 0, Rectangular(), 30)\n", - "p3 = DrivePulse(p2.finish, 400, 0.9, 20e6, 0, Drag(5,50), 20)\n", - "ps1 = p1 + p2 + p3\n", - "ps2 = p3 + p1 + p2\n", - "assert ps1 == ps2" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "hash(ps1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "hash(ps2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "for pulse in ps1.pulses:\n", - " print(pulse.serial)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "for pulse in ps2.pulses:\n", - " print(pulse.serial)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Overlaps" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "overlaps" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "qibolab", - "language": "python", - "name": "qibolab" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - }, - "vscode": { - "interpreter": { - "hash": "df6c4956c0d01326f01905a7a43ac8f74636b2b92922eba33adb46287ed0dc33" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/qibolab_v017_1Q_emulator_test_QuTiP.ipynb b/examples/qibolab_v017_1Q_emulator_test_QuTiP.ipynb deleted file mode 100644 index fda85d07bb..0000000000 --- a/examples/qibolab_v017_1Q_emulator_test_QuTiP.ipynb +++ /dev/null @@ -1,964 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "1472864f-98c4-422a-99ec-d0fd67d4bf9e", - "metadata": {}, - "source": [ - "# Qibolab v0.1.7 1Q emulator demo for QuTiP engine" - ] - }, - { - "cell_type": "markdown", - "id": "e2fcc40a", - "metadata": {}, - "source": [ - "Results updated on: 18 June 2024" - ] - }, - { - "cell_type": "markdown", - "id": "c281a2bf-dc45-441a-8869-4a0a7d3c35bc", - "metadata": { - "tags": [] - }, - "source": [ - "## Setting up and using the emulator platform" - ] - }, - { - "cell_type": "markdown", - "id": "2720e9bb-ed10-46a9-bb46-cfc1f487ab77", - "metadata": {}, - "source": [ - "The emulator is instantiated like any other device platform in Qibolab, by first adding the path to the emulator runcard to the `QIBOLAB_PLATFORMS` environment variable and then using `qibolab.create_platform`. In this tutorial, we will be using the test emulator `default_q0` that can be found in ``/qibolab/tests/emulators/``:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "4406fccb-60aa-415b-b264-d27c8a5b4eb7", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.6|INFO|2024-06-18 02:01:41]: Loading platform default_q0\n", - "INFO:qibo.config:Loading platform default_q0\n" - ] - } - ], - "source": [ - "# add directory of emulator platform to QIBOLAB_PLATFORMS environment variable\n", - "import pathlib, os\n", - "emulator_path = pathlib.Path(os.path.abspath('')).parent/'tests/emulators/'\n", - "os.environ[\"QIBOLAB_PLATFORMS\"] = emulator_path.as_posix() \n", - "\n", - "# create emulator platform as per any other device platform\n", - "from qibolab import create_platform\n", - "emulator_platform = create_platform(\"default_q0\")" - ] - }, - { - "cell_type": "markdown", - "id": "7f1c6458-1276-4250-b67a-87a7ff0a7ac4", - "metadata": {}, - "source": [ - "Similarly, the emulator plays pulse sequences in the same way as any other device platforms. In this tutorial, we will play a simple RX pulse followed by a readout pulse as defined in the runcard on the 'default_q0' single-qubit emulator that we have just initialized:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "02588224-329c-4466-8486-29b8752faddc", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.6|INFO|2024-06-18 02:01:41]: Minimal execution time (sequence): 0.30500777777777777\n", - "INFO:qibo.config:Minimal execution time (sequence): 0.30500777777777777\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Total run time: 1.19s*] Elapsed 1.19s / Remaining 00:00:00:00[*********72%***** ] Elapsed 0.91s / Remaining 00:00:00:00\n" - ] - } - ], - "source": [ - "from qibolab.pulses import PulseSequence\n", - "\n", - "# Extract preset pulses from runcard\n", - "pulse_x0 = emulator_platform.create_RX_pulse(qubit=0, start=0)\n", - "pulse_r0 = emulator_platform.create_qubit_readout_pulse(qubit=0, start=int(pulse_x0.duration + 5))\n", - "\n", - "# Add pulses to PulseSequence\n", - "sequence = PulseSequence()\n", - "sequence.add(pulse_x0)\n", - "sequence.add(pulse_r0)\n", - "\n", - "from qibolab.execution_parameters import ExecutionParameters\n", - "\n", - "# Execute the pulse sequence and save the output\n", - "options = ExecutionParameters(nshots=1000)\n", - "results = emulator_platform.execute_pulse_sequence(sequence, options=options)" - ] - }, - { - "cell_type": "markdown", - "id": "dfdf69bd-fd58-4eb7-a99a-764c22d18334", - "metadata": { - "tags": [] - }, - "source": [ - "## Pulse simulator and simulation engine" - ] - }, - { - "cell_type": "markdown", - "id": "af73d5f8-a126-4791-826b-a537c2610618", - "metadata": {}, - "source": [ - "The only instrument used by the emulator is the :class:`qibolab.instruments.emulator.pulse_simulator.PulseSimulator`" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ef46ee8e-c1a2-4fc1-bd1f-c0d75cb6959f", - "metadata": {}, - "outputs": [], - "source": [ - "pulse_simulator = emulator_platform.instruments['pulse_simulator']" - ] - }, - { - "cell_type": "markdown", - "id": "9c1da6a3-2738-43c0-bf97-dd7664249ad9", - "metadata": {}, - "source": [ - "The information from the runcard used to initialized the `PulseSimulator` can be found under `'instruments'`, and is further grouped under `'model_params'` and `'simulations_config'`. " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "3b72c4ef-d03c-43ea-93b5-41846281b39e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'pulse_simulator': {'model_params': {'model_name': 'general_no_coupler_model',\n", - " 'topology': [],\n", - " 'nqubits': 1,\n", - " 'ncouplers': 0,\n", - " 'qubits_list': ['0'],\n", - " 'couplers_list': [],\n", - " 'nlevels_q': [3],\n", - " 'nlevels_c': [],\n", - " 'readout_error': {'0': [0.01, 0.02]},\n", - " 'drive_freq': {'0': 5.090167234445013},\n", - " 'T1': {'0': 88578.48970762537},\n", - " 'T2': {'0': 106797.94866226273},\n", - " 'lo_freq': {'0': 5.090167234445013},\n", - " 'rabi_freq': {'0': 0.333},\n", - " 'anharmonicity': {'0': -0.3361230051821652},\n", - " 'coupling_strength': {}},\n", - " 'simulation_config': {'simulation_engine_name': 'Qutip',\n", - " 'sampling_rate': 4.5,\n", - " 'sim_sampling_boost': 10,\n", - " 'runcard_duration_in_dt_units': False,\n", - " 'instant_measurement': True,\n", - " 'simulate_dissipation': True,\n", - " 'output_state_history': True},\n", - " 'sim_opts': None,\n", - " 'bounds': {'waveforms': 1, 'readout': 1, 'instructions': 1}}}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qibolab.serialize import load_runcard\n", - "\n", - "load_runcard(emulator_path/\"default_q0\")['instruments']" - ] - }, - { - "cell_type": "markdown", - "id": "290cc6ae-372a-4596-abb5-1d7313365385", - "metadata": {}, - "source": [ - "As indicated from 'model_params', this emulator simulates a single qubit as a 3-level quantum system with no couplers. All frequencies given are in units of GHz and all times in ns." - ] - }, - { - "cell_type": "markdown", - "id": "8e089478-44b0-4ad2-9ab2-2162414e94b0", - "metadata": {}, - "source": [ - "The PulseSimulator contains a `simulation_engine`, which in turn contains methods to simulate the dynamics of the pulse-device system, as well as process the results, using a specific quantum dynamics simulation library, which in this case is `QuTiP`:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f8b38586-d48f-4ca3-b76f-feac1f332904", - "metadata": {}, - "outputs": [], - "source": [ - "simulation_engine = pulse_simulator.simulation_engine" - ] - }, - { - "cell_type": "markdown", - "id": "a3692ac5-2e5c-4806-b674-ed2720a12ed3", - "metadata": {}, - "source": [ - "To help visualize the model, we can use the `print_hamiltonian` function from `qibolab_visualization.emulator`:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "d70d80ac-21de-40db-82aa-f669372e7c06", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dictionary\n" - ] - }, - { - "data": { - "text/latex": [ - "$O_i = b^{\\dagger}_i b_i$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/latex": [ - "$X_i = b^{\\dagger}_i + b_i$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "---------------------\n", - "One-body drift terms:\n", - "---------------------\n" - ] - }, - { - "data": { - "text/latex": [ - "$O_0$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/latex": [ - "$5.090167234445013~\\text{GHz}$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/latex": [ - "$O_0O_0-O_0$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/latex": [ - "$-0.1680615025910826~\\text{GHz}$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------\n", - "Two-body drift terms:\n", - "---------------------\n", - "None\n", - "---------------------\n", - "One-body drive terms:\n", - "---------------------\n" - ] - }, - { - "data": { - "text/latex": [ - "$X_0$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/latex": [ - "$0.333~\\text{GHz}$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------\n", - "Dissipative terms:\n", - "---------------------\n", - ">> t1 Linblad operators:\n" - ] - }, - { - "data": { - "text/latex": [ - "$\\sigma^+_0$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/latex": [ - "$0.0023758601136844794~\\sqrt{{ \\text{GHz} }}$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ">> t2 Linblad operators:\n" - ] - }, - { - "data": { - "text/latex": [ - "$\\sigma^Z_0$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/latex": [ - "$0.002163732391848669~\\sqrt{{ \\text{GHz} }}$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "---------------------\n" - ] - } - ], - "source": [ - "from qibolab_visualization.emulator import print_hamiltonian\n", - "print_hamiltonian(simulation_engine.model_config)" - ] - }, - { - "cell_type": "markdown", - "id": "e779a202-96bd-4a40-a9a6-64c110fd51dd", - "metadata": { - "tags": [] - }, - "source": [ - "## Simulation results" - ] - }, - { - "cell_type": "markdown", - "id": "08e1c8ee-8076-47ee-a05a-bcc068d681d0", - "metadata": {}, - "source": [ - "The simulation results generated by the simulation engine are returned together with the usual outputs of `execute_pulse_sequence` for device platforms and are grouped under 'simulation'. \n", - "\n", - "Let us retrieve the simulation results obtained previously:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "9e45c3b1-1313-4fba-8dda-5810293369a7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['sequence_duration', 'simulation_dt', 'simulation_time', 'output_states'])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "simulation_results = results['simulation']\n", - "simulation_results.keys()" - ] - }, - { - "cell_type": "markdown", - "id": "d1a09410-20f2-4797-9540-636f427a76cb", - "metadata": {}, - "source": [ - "The time taken to complete the simulation is:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "abfff213-828e-434c-b4c5-2de8c07d8ae5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.192088042" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "simulation_results['simulation_time']" - ] - }, - { - "cell_type": "markdown", - "id": "f499f704-f3da-4031-92c9-a9ef92d171ba", - "metadata": {}, - "source": [ - "In addition, one can generate the list of discretized times used in the simulation:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b6a08d7f-bd83-44b1-868f-9346e8cd21e2", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "sequence_duration = simulation_results['sequence_duration']\n", - "simulation_dt = simulation_results['simulation_dt']\n", - "sim_time_list = np.linspace(0,sequence_duration,num=int(sequence_duration/simulation_dt)+1)" - ] - }, - { - "cell_type": "markdown", - "id": "79574a8f-d831-48d5-a47c-848392773fda", - "metadata": {}, - "source": [ - "When 'output_state_history' in `'simulation_config'` is set to 'True', the corresponding device quantum states obtained from simulation at each of these times are stored in 'output_states' as objects native to the simulation engine library. In this case, these are :class:`qutip.Qobj`. As an example, we see that the initial state is indeed the density matrix for a 3 level system corresponding to $\\ket{0}$:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "757e3e62-86d4-46c5-8ff4-8d0b62d3ca85", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, isherm = True $ \\\\ \\left(\\begin{matrix}1.0 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.0\\\\0.0 & 0.0 & 0.0\\\\\\end{matrix}\\right)$" - ], - "text/plain": [ - "Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, isherm = True\n", - "Qobj data =\n", - "[[1. 0. 0.]\n", - " [0. 0. 0.]\n", - " [0. 0. 0.]]" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "simulated_states = simulation_results['output_states']\n", - "simulated_states[0]" - ] - }, - { - "cell_type": "markdown", - "id": "d8df8936-bd2c-4794-a392-2ff6816391c7", - "metadata": {}, - "source": [ - "One can call the `compute_overlaps` method in the simulation engine to compute the overlaps of the state with the different computational basis states for the entire simulation history. We can then visualize this with the plot_overlaps function from `qibolab_visualization.emulator`:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "d912711f-4618-421b-92c7-f5b61c4b853b", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Overlap of final state with basis states:\n", - "[0] 0.0016351326811553345\n", - "[1] 0.9982829949142029\n", - "[2] 8.187240463464329e-05\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "overlaps = simulation_engine.compute_overlaps(simulated_states)\n", - "\n", - "from qibolab_visualization.emulator import plot_overlaps\n", - "plot_overlaps(overlaps,sim_time_list,time_label='Time / ns');" - ] - }, - { - "cell_type": "markdown", - "id": "8e369387-8913-4e8d-8a21-b8970f358407", - "metadata": { - "tags": [] - }, - "source": [ - "## Sampling and applying readout noise" - ] - }, - { - "cell_type": "markdown", - "id": "5688f522-e408-4759-b951-74fa003b6be3", - "metadata": {}, - "source": [ - "By default, the 'readout_error' from the `'model_params'` dictionary is applied when generating the samples from simulation without noise:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "bce5d664-de80-45cc-9611-71a138b3fbbf", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 983)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "samples = results[0].samples\n", - "samples[:20].tolist(), np.sum(samples)" - ] - }, - { - "cell_type": "markdown", - "id": "24a8bb55-23ce-4c3d-a73c-bcced2ddaa6e", - "metadata": {}, - "source": [ - "Samples can be obtained from the final state of the simulation without applying readout error manually by the `get_samples` function:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "286e6c12-b87b-47cf-9d73-541194f5c185", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 999)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "final_state = simulated_states[-1]\n", - "\n", - "from qibolab.instruments.emulator.pulse_simulator import get_samples\n", - "ro_qubit_list = [pulse_r0.qubit]\n", - "ro_reduced_dm, rdm_qubit_list = pulse_simulator.simulation_engine.qobj_to_reduced_dm(final_state, ro_qubit_list)\n", - "noiseless_samples = get_samples(1000, ro_reduced_dm, rdm_qubit_list, pulse_simulator.simulation_engine.qid_nlevels_map)\n", - "\n", - "noiseless_samples[0][:20], np.sum(noiseless_samples[0])" - ] - }, - { - "cell_type": "markdown", - "id": "97b760c6-01d4-43a1-96af-37e810247fa2", - "metadata": {}, - "source": [ - "The `readout_error` can be applied subsequently as well with the `apply_readout_noise` function:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "4e6a91b6-3d27-4505-9f10-718b19fb6c0d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "([1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 905)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qibolab.instruments.emulator.pulse_simulator import apply_readout_noise\n", - "\n", - "readout_error = {0: [0.1, 0.1], 1: [0.1, 0.1]}\n", - "noisy_samples = apply_readout_noise(noiseless_samples, readout_error)\n", - "noisy_samples[0][:20], np.sum(noisy_samples[0])" - ] - }, - { - "cell_type": "markdown", - "id": "24a9f3fe-93e3-4daa-87f7-272a8a016119", - "metadata": {}, - "source": [ - "## Returning only the final state of simulations" - ] - }, - { - "cell_type": "markdown", - "id": "7a877c1f-e780-4289-9351-0821593997b5", - "metadata": {}, - "source": [ - "In some cases, the entire history of the simulated states is not needed. One can save memory by setting `'output_state_history' = 'False'`in `'simulations_config'`. This is useful for instance when running sweepers:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "e0690c99-11a0-45a0-87c2-f81ba39f3bf6", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "from qibolab.sweeper import Sweeper, Parameter\n", - "\n", - "parameter = Parameter.duration\n", - "parameter2 = Parameter.amplitude\n", - "parameter_range = np.linspace(pulse_x0.duration*.5, pulse_x0.duration*1.0, num=2)\n", - "parameter2_range = np.linspace(pulse_x0.amplitude*.95, pulse_x0.amplitude*1.05, num=3)\n", - "sweeper = Sweeper(parameter, parameter_range, [pulse_x0])\n", - "sweeper2 = Sweeper(parameter2, parameter2_range, [pulse_x0])" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "9012c9b0-74a2-420f-8c4c-2c1addb16803", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Qibo 0.2.6|INFO|2024-06-18 02:01:43]: Minimal execution time (sweep): 7.4958711466666665\n", - "INFO:qibo.config:Minimal execution time (sweep): 7.4958711466666665\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Total run time: 0.89s*] Elapsed 0.89s / Remaining 00:00:00:00[****** 26% ] Elapsed 0.28s / Remaining 00:00:00:00\n", - " Total run time: 0.99s*] Elapsed 0.99s / Remaining 00:00:00:00[* 6% ] Elapsed 0.11s / Remaining 00:00:00:01\n", - " [ 1% ] Elapsed 0.01s / Remaining 00:00:00:01" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "IOPub message rate exceeded.\n", - "The Jupyter server will temporarily stop sending output\n", - "to the client in order to avoid crashing it.\n", - "To change this limit, set the config variable\n", - "`--ServerApp.iopub_msg_rate_limit`.\n", - "\n", - "Current values:\n", - "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", - "ServerApp.rate_limit_window=3.0 (secs)\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Total run time: 1.10s*] Elapsed 1.10s / Remaining 00:00:00:00\n", - " Total run time: 1.14s*] Elapsed 1.14s / Remaining 00:00:00:00[**** 18% ] Elapsed 0.25s / Remaining 00:00:00:01[*********75%***** ] Elapsed 0.88s / Remaining 00:00:00:00[*********98%***********] Elapsed 1.08s / Remaining 00:00:00:00\n", - " [*********48% ] Elapsed 0.55s / Remaining 00:00:00:00[* 3% ] Elapsed 0.05s / Remaining 00:00:00:01[* 4% ] Elapsed 0.06s / Remaining 00:00:00:01" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "IOPub message rate exceeded.\n", - "The Jupyter server will temporarily stop sending output\n", - "to the client in order to avoid crashing it.\n", - "To change this limit, set the config variable\n", - "`--ServerApp.iopub_msg_rate_limit`.\n", - "\n", - "Current values:\n", - "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", - "ServerApp.rate_limit_window=3.0 (secs)\n", - "\n" - ] - } - ], - "source": [ - "# output only final state\n", - "emulator_platform.instruments['pulse_simulator'].output_state_history = False\n", - "sweep_results = emulator_platform.sweep(sequence, ExecutionParameters(), sweeper, sweeper2)" - ] - }, - { - "cell_type": "markdown", - "id": "a1fe5e3d-7619-480e-b3a8-e4b60e037092", - "metadata": {}, - "source": [ - "To help visualize the simulation results, we can once again look at its overlap with the basis states of the system. We use `make_array_index_list` function to generate a list of all possible index combinations of an array with arbitrary shape, in this case corresponding to all possible combinations of different sweeper parameters:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "37ac5613-2c25-4344-b5bf-4604ed2859d1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from qibolab.instruments.emulator.pulse_simulator import make_array_index_list\n", - "\n", - "final_states_array = sweep_results['simulation']['output_states']\n", - "shape = final_states_array.shape\n", - "index_list = make_array_index_list(shape)\n", - "overlaps = {}\n", - "for index in index_list:\n", - " pulse_simulator.merge_sweep_results(overlaps, simulation_engine.compute_overlaps(final_states_array[tuple(index)]))\n", - "\n", - "import matplotlib.pyplot as plt\n", - "for label in overlaps.keys():\n", - " plt.figure()\n", - " plt.pcolormesh(np.array(overlaps[label]).reshape(shape))\n", - " plt.colorbar()\n", - " plt.title(f'Final state overlap with {label}')\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "ed868b1f", - "metadata": {}, - "source": [ - "## --- Version information for major packages used in the current Qibolab emulator example ---" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "f78416d6-33a7-4350-86c1-c64fb3fe80ab", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext watermark" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "38340640-9e0b-40b3-9952-d4cabef2e277", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Python implementation: CPython\n", - "Python version : 3.9.18\n", - "IPython version : 8.15.0\n", - "\n", - "qibolab : 0.1.7\n", - "qibo : 0.2.6\n", - "qutip : 4.7.5\n", - "matplotlib: 3.8.0\n", - "numpy : 1.26.4\n", - "scipy : 1.12.0\n", - "\n" - ] - } - ], - "source": [ - "%watermark -v -p qibolab,qibo,qutip,matplotlib,numpy,scipy" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.18" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/extras/test819.py b/extras/test819.py deleted file mode 100644 index 6d0ce15ef1..0000000000 --- a/extras/test819.py +++ /dev/null @@ -1,91 +0,0 @@ -import numpy as np -from qibo.backends import GlobalBackend - -from qibolab import Platform -from qibolab.execution_parameters import ( - AcquisitionType, - AveragingMode, - ExecutionParameters, -) -from qibolab.instruments.qblox.controller import QbloxController -from qibolab.platform import NS_TO_SEC -from qibolab.pulses import PulseSequence -from qibolab.sweeper import Parameter, Sweeper, SweeperType - -GlobalBackend.set_backend("qibolab", "spinq10q") -platform: Platform = GlobalBackend().platform -controller: QbloxController = platform.instruments["qblox_controller"] - -sequence = PulseSequence() -ro_pulses = {} - -qid = 0 -qubit = platform.qubits[qid] -qubits = {qid: qubit} - -ro_pulse = platform.create_qubit_readout_pulse(qid, start=0) -ro_pulse.frequency = int(2e9) -sequence.add(ro_pulse) - -freq_width = 2e7 -freq_step = 2e5 -bias_width = 0.8 -bias_step = 0.01 -nshots = 1024 -relaxation_time = 5000 - -navgs = nshots -repetition_duration = sequence.finish + relaxation_time - -# define the parameters to sweep and their range: -delta_frequency_range = np.arange(-freq_width // 2, freq_width // 2, freq_step) -freq_sweeper = Sweeper( - Parameter.frequency, delta_frequency_range, [ro_pulse], type=SweeperType.OFFSET -) - -delta_bias_range = np.arange(-bias_width / 2, bias_width / 2, bias_step) -bias_sweeper = Sweeper( - Parameter.bias, delta_bias_range, qubits=[qubit], type=SweeperType.OFFSET -) - -options = ExecutionParameters( - nshots=nshots, - relaxation_time=relaxation_time, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, -) -time = (sequence.duration + relaxation_time) * nshots * NS_TO_SEC -sweepers = (bias_sweeper, freq_sweeper) -for sweep in sweepers: - time *= len(sweep.values) - -# mock -controller.is_connected = True - - -class Sequencers: - def __getitem__(self, index): - return self - - def set(self, *args): - pass - - -class Device: - sequencers = Sequencers() - - -for mod in controller.modules.values(): - mod.device = Device() - mod._device_num_sequencers = 0 -# end mock - -# for name, mod in controller.modules.items(): -# if "qcm_rf" in name: -# continue - -mod = controller.modules["qcm_bb0"] -channels = controller._set_module_channel_map(mod, qubits) -pulses = sequence.get_channel_pulses(*channels) -mod.process_pulse_sequence(qubits, pulses, navgs, nshots, repetition_duration, sweepers) -print(mod._sequencers["o1"][0].program) diff --git a/flake.lock b/flake.lock index 07ae0529b8..86505603c4 100644 --- a/flake.lock +++ b/flake.lock @@ -1,22 +1,86 @@ { "nodes": { + "cachix": { + "inputs": { + "devenv": "devenv_2", + "flake-compat": [ + "devenv", + "flake-compat" + ], + "nixpkgs": [ + "devenv", + "nixpkgs" + ], + "pre-commit-hooks": [ + "devenv", + "pre-commit-hooks" + ] + }, + "locked": { + "lastModified": 1712055811, + "narHash": "sha256-7FcfMm5A/f02yyzuavJe06zLa9hcMHsagE28ADcmQvk=", + "owner": "cachix", + "repo": "cachix", + "rev": "02e38da89851ec7fec3356a5c04bc8349cae0e30", + "type": "github" + }, + "original": { + "owner": "cachix", + "repo": "cachix", + "type": "github" + } + }, "devenv": { "inputs": { - "flake-compat": "flake-compat", + "cachix": "cachix", + "flake-compat": "flake-compat_2", + "nix": "nix_2", + "nixpkgs": [ + "nixpkgs" + ], + "pre-commit-hooks": "pre-commit-hooks" + }, + "locked": { + "lastModified": 1723898192, + "narHash": "sha256-MXIK60F11Tc7B+vRcLOWPx6IweAu3u54YpdByM/9OuA=", + "owner": "cachix", + "repo": "devenv", + "rev": "64bb347c3b0cee39da55ec6f52a5bef8d833c431", + "type": "github" + }, + "original": { + "owner": "cachix", + "repo": "devenv", + "type": "github" + } + }, + "devenv_2": { + "inputs": { + "flake-compat": [ + "devenv", + "cachix", + "flake-compat" + ], "nix": "nix", "nixpkgs": "nixpkgs", - "pre-commit-hooks": "pre-commit-hooks" + "poetry2nix": "poetry2nix", + "pre-commit-hooks": [ + "devenv", + "cachix", + "pre-commit-hooks" + ] }, "locked": { - "lastModified": 1701187605, - "narHash": "sha256-NctguPdUeDVLXFsv6vI1RlEiHLsXkeW3pgZe/mwn1BU=", + "lastModified": 1708704632, + "narHash": "sha256-w+dOIW60FKMaHI1q5714CSibk99JfYxm0CzTinYWr+Q=", "owner": "cachix", "repo": "devenv", - "rev": "a7c4dd8f4eb1f98a6b8f04bf08364954e1e73e4f", + "rev": "2ee4450b0f4b95a1b90f2eb5ffea98b90e48c196", "type": "github" }, "original": { "owner": "cachix", + "ref": "python-rewrite", "repo": "devenv", "type": "github" } @@ -29,11 +93,11 @@ "rust-analyzer-src": "rust-analyzer-src" }, "locked": { - "lastModified": 1705904706, - "narHash": "sha256-0aJfyNYWy6pS4GfOA+pmGOE+PgJZLG78T+sPh8zRJx8=", + "lastModified": 1724049063, + "narHash": "sha256-aTnh9Ar40OaT2MTULeJMR9EIrylKeKUYWP61QEZBu0Q=", "owner": "nix-community", "repo": "fenix", - "rev": "8e7851239acf6bfb06637f4d3e180302f53ec542", + "rev": "94c18bf5acb3966b07cc863bd00f4f959c0c5ec4", "type": "github" }, "original": { @@ -61,11 +125,27 @@ "flake-compat_2": { "flake": false, "locked": { - "lastModified": 1673956053, - "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=", + "lastModified": 1696426674, + "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=", + "owner": "edolstra", + "repo": "flake-compat", + "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33", + "type": "github" + }, + "original": { "owner": "edolstra", "repo": "flake-compat", - "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9", + "type": "github" + } + }, + "flake-compat_3": { + "flake": false, + "locked": { + "lastModified": 1696426674, + "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=", + "owner": "edolstra", + "repo": "flake-compat", + "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33", "type": "github" }, "original": { @@ -79,11 +159,11 @@ "systems": "systems" }, "locked": { - "lastModified": 1685518550, - "narHash": "sha256-o2d0KcvaXzTrPRIo0kOLV0/QXHhDQ5DTi+OxcjO8xqY=", + "lastModified": 1689068808, + "narHash": "sha256-6ixXo3wt24N/melDWjq70UuHQLxGV8jZvooRanIHXw0=", "owner": "numtide", "repo": "flake-utils", - "rev": "a1720a10a6cfe8234c0e93907ffe81be440f4cef", + "rev": "919d646de7be200f3bf08cb76ae1f09402b6f9b4", "type": "github" }, "original": { @@ -97,16 +177,17 @@ "systems": "systems_2" }, "locked": { - "lastModified": 1685518550, - "narHash": "sha256-o2d0KcvaXzTrPRIo0kOLV0/QXHhDQ5DTi+OxcjO8xqY=", + "lastModified": 1710146030, + "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=", "owner": "numtide", "repo": "flake-utils", - "rev": "a1720a10a6cfe8234c0e93907ffe81be440f4cef", + "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a", "type": "github" }, "original": { - "id": "flake-utils", - "type": "indirect" + "owner": "numtide", + "repo": "flake-utils", + "type": "github" } }, "gitignore": { @@ -118,11 +199,11 @@ ] }, "locked": { - "lastModified": 1660459072, - "narHash": "sha256-8DFJjXG8zqoONA1vXtgeKXy68KdJL5UaXR8NtVMUbx8=", + "lastModified": 1709087332, + "narHash": "sha256-HG2cCnktfHsKV0s4XW83gU3F57gaTljL9KNSuG6bnQs=", "owner": "hercules-ci", "repo": "gitignore.nix", - "rev": "a20de23b925fd8264fd7fad6454652e142fd7f73", + "rev": "637db329424fd7e46cf4185293b9cc8c88c95394", "type": "github" }, "original": { @@ -131,53 +212,90 @@ "type": "github" } }, - "lowdown-src": { - "flake": false, + "nix": { + "inputs": { + "flake-compat": "flake-compat", + "nixpkgs": [ + "devenv", + "cachix", + "devenv", + "nixpkgs" + ], + "nixpkgs-regression": "nixpkgs-regression" + }, "locked": { - "lastModified": 1633514407, - "narHash": "sha256-Dw32tiMjdK9t3ETl5fzGrutQTzh2rufgZV4A/BbxuD4=", - "owner": "kristapsdz", - "repo": "lowdown", - "rev": "d2c2b44ff6c27b936ec27358a2653caaef8f73b8", + "lastModified": 1712911606, + "narHash": "sha256-BGvBhepCufsjcUkXnEEXhEVjwdJAwPglCC2+bInc794=", + "owner": "domenkozar", + "repo": "nix", + "rev": "b24a9318ea3f3600c1e24b4a00691ee912d4de12", "type": "github" }, "original": { - "owner": "kristapsdz", - "repo": "lowdown", + "owner": "domenkozar", + "ref": "devenv-2.21", + "repo": "nix", "type": "github" } }, - "nix": { + "nix-github-actions": { "inputs": { - "lowdown-src": "lowdown-src", "nixpkgs": [ "devenv", + "cachix", + "devenv", + "poetry2nix", "nixpkgs" + ] + }, + "locked": { + "lastModified": 1688870561, + "narHash": "sha256-4UYkifnPEw1nAzqqPOTL2MvWtm3sNGw1UTYTalkTcGY=", + "owner": "nix-community", + "repo": "nix-github-actions", + "rev": "165b1650b753316aa7f1787f3005a8d2da0f5301", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "nix-github-actions", + "type": "github" + } + }, + "nix_2": { + "inputs": { + "flake-compat": [ + "devenv", + "flake-compat" ], - "nixpkgs-regression": "nixpkgs-regression" + "nixpkgs": [ + "devenv", + "nixpkgs" + ], + "nixpkgs-regression": "nixpkgs-regression_2" }, "locked": { - "lastModified": 1676545802, - "narHash": "sha256-EK4rZ+Hd5hsvXnzSzk2ikhStJnD63odF7SzsQ8CuSPU=", + "lastModified": 1712911606, + "narHash": "sha256-BGvBhepCufsjcUkXnEEXhEVjwdJAwPglCC2+bInc794=", "owner": "domenkozar", "repo": "nix", - "rev": "7c91803598ffbcfe4a55c44ac6d49b2cf07a527f", + "rev": "b24a9318ea3f3600c1e24b4a00691ee912d4de12", "type": "github" }, "original": { "owner": "domenkozar", - "ref": "relaxed-flakes", + "ref": "devenv-2.21", "repo": "nix", "type": "github" } }, "nixpkgs": { "locked": { - "lastModified": 1678875422, - "narHash": "sha256-T3o6NcQPwXjxJMn2shz86Chch4ljXgZn746c2caGxd8=", + "lastModified": 1692808169, + "narHash": "sha256-x9Opq06rIiwdwGeK2Ykj69dNc2IvUH1fY55Wm7atwrE=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "126f49a01de5b7e35a43fd43f891ecf6d3a51459", + "rev": "9201b5ff357e781bf014d0330d18555695df7ba8", "type": "github" }, "original": { @@ -189,18 +307,17 @@ }, "nixpkgs-python": { "inputs": { - "flake-compat": "flake-compat_2", - "flake-utils": "flake-utils_2", + "flake-compat": "flake-compat_3", "nixpkgs": [ "nixpkgs" ] }, "locked": { - "lastModified": 1702034373, - "narHash": "sha256-Apubv9die/XRBPI0eRFJyvuyGz/wD4YQUQJHRYCRenc=", + "lastModified": 1722978926, + "narHash": "sha256-sqOOEaKJJSUFBzag/cGeeXV491TrrVFY3DFBs1w20V8=", "owner": "cachix", "repo": "nixpkgs-python", - "rev": "1cae686aa92dbccafe74fd242f984c3ec27c0b20", + "rev": "7c550bca7e6cf95898e32eb2173efe7ebb447460", "type": "github" }, "original": { @@ -225,29 +342,45 @@ "type": "github" } }, + "nixpkgs-regression_2": { + "locked": { + "lastModified": 1643052045, + "narHash": "sha256-uGJ0VXIhWKGXxkeNnq4TvV3CIOkUJ3PAoLZ3HMzNVMw=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2", + "type": "github" + }, + "original": { + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2", + "type": "github" + } + }, "nixpkgs-stable": { "locked": { - "lastModified": 1685801374, - "narHash": "sha256-otaSUoFEMM+LjBI1XL/xGB5ao6IwnZOXc47qhIgJe8U=", + "lastModified": 1710695816, + "narHash": "sha256-3Eh7fhEID17pv9ZxrPwCLfqXnYP006RKzSs0JptsN84=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "c37ca420157f4abc31e26f436c1145f8951ff373", + "rev": "614b4613980a522ba49f0d194531beddbb7220d3", "type": "github" }, "original": { "owner": "NixOS", - "ref": "nixos-23.05", + "ref": "nixos-23.11", "repo": "nixpkgs", "type": "github" } }, "nixpkgs_2": { "locked": { - "lastModified": 1702312524, - "narHash": "sha256-gkZJRDBUCpTPBvQk25G0B7vfbpEYM5s5OZqghkjZsnE=", + "lastModified": 1723637854, + "narHash": "sha256-med8+5DSWa2UnOqtdICndjDAEjxr5D7zaIiK4pn0Q7c=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "a9bf124c46ef298113270b1f84a164865987a91c", + "rev": "c3aa7b8938b17aebd2deecf7be0636000d62a2b9", "type": "github" }, "original": { @@ -257,13 +390,38 @@ "type": "github" } }, + "poetry2nix": { + "inputs": { + "flake-utils": "flake-utils", + "nix-github-actions": "nix-github-actions", + "nixpkgs": [ + "devenv", + "cachix", + "devenv", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1692876271, + "narHash": "sha256-IXfZEkI0Mal5y1jr6IRWMqK8GW2/f28xJenZIPQqkY0=", + "owner": "nix-community", + "repo": "poetry2nix", + "rev": "d5006be9c2c2417dafb2e2e5034d83fabd207ee3", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "poetry2nix", + "type": "github" + } + }, "pre-commit-hooks": { "inputs": { "flake-compat": [ "devenv", "flake-compat" ], - "flake-utils": "flake-utils", + "flake-utils": "flake-utils_2", "gitignore": "gitignore", "nixpkgs": [ "devenv", @@ -272,11 +430,11 @@ "nixpkgs-stable": "nixpkgs-stable" }, "locked": { - "lastModified": 1688056373, - "narHash": "sha256-2+SDlNRTKsgo3LBRiMUcoEUb6sDViRNQhzJquZ4koOI=", + "lastModified": 1713775815, + "narHash": "sha256-Wu9cdYTnGQQwtT20QQMg7jzkANKQjwBD9iccfGKkfls=", "owner": "cachix", "repo": "pre-commit-hooks.nix", - "rev": "5843cf069272d92b60c3ed9e55b7a8989c01d4c7", + "rev": "2ac4dcbf55ed43f3be0bae15e181f08a57af24a4", "type": "github" }, "original": { @@ -297,11 +455,11 @@ "rust-analyzer-src": { "flake": false, "locked": { - "lastModified": 1705864945, - "narHash": "sha256-ZATChFWHToTZQFLlzrzDUX8fjEbMHHBIyPaZU1JGmjI=", + "lastModified": 1723915239, + "narHash": "sha256-x/RXN/ougJ1IEoBKrY0UijB530OfOfICK4KPa3Kj9Bk=", "owner": "rust-lang", "repo": "rust-analyzer", - "rev": "d410d4a2baf9e99b37b03dd42f06238b14374bf7", + "rev": "fa003262474185fd62168379500fe906b331824b", "type": "github" }, "original": { diff --git a/flake.nix b/flake.nix index a91b8b4328..e7ba41854c 100644 --- a/flake.nix +++ b/flake.nix @@ -2,15 +2,18 @@ inputs = { nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; systems.url = "github:nix-systems/default"; - devenv.url = "github:cachix/devenv"; - nixpkgs-python = { - url = "github:cachix/nixpkgs-python"; + devenv = { + url = "github:cachix/devenv"; inputs.nixpkgs.follows = "nixpkgs"; }; fenix = { url = "github:nix-community/fenix"; inputs.nixpkgs.follows = "nixpkgs"; }; + nixpkgs-python = { + url = "github:cachix/nixpkgs-python"; + inputs = {nixpkgs.follows = "nixpkgs";}; + }; }; outputs = { @@ -35,17 +38,22 @@ forEachSystem (system: let pkgs = nixpkgs.legacyPackages.${system}; - pwd = builtins.getEnv "PWD"; - platforms = builtins.toPath "${pwd}/../qibolab_platforms_qrc/"; in { default = devenv.lib.mkShell { inherit inputs pkgs; modules = [ - ({lib, ...}: { + ({ + lib, + pkgs, + config, + ... + }: { packages = with pkgs; [pre-commit poethepoet jupyter]; - env.QIBOLAB_PLATFORMS = platforms; + env = { + QIBOLAB_PLATFORMS = (dirOf config.env.DEVENV_ROOT) + "/qibolab_platforms_qrc"; + }; languages.c = { enable = true; @@ -57,11 +65,13 @@ languages.python = { enable = true; + libraries = with pkgs; [zlib]; + version = "3.11"; poetry = { enable = true; install = { enable = true; - groups = ["dev" "tests"]; + groups = ["dev" "analysis" "tests"]; extras = [ (lib.strings.concatStrings (lib.strings.intersperse " -E " @@ -69,7 +79,6 @@ ]; }; }; - version = "3.11"; }; languages.rust = { diff --git a/poetry.lock b/poetry.lock index 44aadec062..afb5b3a695 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand. +# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand. [[package]] name = "alabaster" @@ -11,37 +11,56 @@ files = [ {file = "alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65"}, ] +[[package]] +name = "alembic" +version = "1.13.2" +description = "A database migration tool for SQLAlchemy." +optional = false +python-versions = ">=3.8" +files = [ + {file = "alembic-1.13.2-py3-none-any.whl", hash = "sha256:6b8733129a6224a9a711e17c99b08462dbf7cc9670ba8f2e2ae9af860ceb1953"}, + {file = "alembic-1.13.2.tar.gz", hash = "sha256:1ff0ae32975f4fd96028c39ed9bb3c867fe3af956bd7bb37343b54c9fe7445ef"}, +] + +[package.dependencies] +Mako = "*" +SQLAlchemy = ">=1.3.0" +typing-extensions = ">=4" + +[package.extras] +tz = ["backports.zoneinfo"] + [[package]] name = "annotated-types" -version = "0.6.0" +version = "0.7.0" description = "Reusable constraint types to use with typing.Annotated" optional = false python-versions = ">=3.8" files = [ - {file = "annotated_types-0.6.0-py3-none-any.whl", hash = "sha256:0641064de18ba7a25dee8f96403ebc39113d0cb953a01429249d5c7564666a43"}, - {file = "annotated_types-0.6.0.tar.gz", hash = "sha256:563339e807e53ffd9c267e99fc6d9ea23eb8443c08f112651963e24e22f84a5d"}, + {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, + {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, ] [[package]] name = "antlr4-python3-runtime" -version = "4.11.1" -description = "ANTLR 4.11.1 runtime for Python 3" +version = "4.13.2" +description = "ANTLR 4.13.2 runtime for Python 3" optional = false python-versions = "*" files = [ - {file = "antlr4-python3-runtime-4.11.1.tar.gz", hash = "sha256:a53de701312f9bdacc5258a6872cd6c62b90d3a90ae25e494026f76267333b60"}, - {file = "antlr4_python3_runtime-4.11.1-py3-none-any.whl", hash = "sha256:ff1954eda1ca9072c02bf500387d0c86cb549bef4dbb3b64f39468b547ec5f6b"}, + {file = "antlr4_python3_runtime-4.13.2-py3-none-any.whl", hash = "sha256:fe3835eb8d33daece0e799090eda89719dbccee7aa39ef94eed3818cafa5a7e8"}, + {file = "antlr4_python3_runtime-4.13.2.tar.gz", hash = "sha256:909b647e1d2fc2b70180ac586df3933e38919c85f98ccc656a96cd3f25ef3916"}, ] [[package]] name = "anyio" -version = "4.3.0" +version = "4.5.0" description = "High level compatibility layer for multiple asynchronous event loop implementations" optional = false python-versions = ">=3.8" files = [ - {file = "anyio-4.3.0-py3-none-any.whl", hash = "sha256:048e05d0f6caeed70d731f3db756d35dcc1f35747c8c403364a8332c630441b8"}, - {file = "anyio-4.3.0.tar.gz", hash = "sha256:f75253795a87df48568485fd18cdd2a3fa5c4f7c5be8e5e36637733fce06fed6"}, + {file = "anyio-4.5.0-py3-none-any.whl", hash = "sha256:fdeb095b7cc5a5563175eedd926ec4ae55413bb4be5770c424af0ba46ccb4a78"}, + {file = "anyio-4.5.0.tar.gz", hash = "sha256:c5a275fe5ca0afd788001f58fca1e69e29ce706d746e317d660e21f70c530ef9"}, ] [package.dependencies] @@ -51,9 +70,9 @@ sniffio = ">=1.1" typing-extensions = {version = ">=4.1", markers = "python_version < \"3.11\""} [package.extras] -doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] -test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"] -trio = ["trio (>=0.23)"] +doc = ["Sphinx (>=7.4,<8.0)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] +test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.21.0b1)"] +trio = ["trio (>=0.26.1)"] [[package]] name = "astroid" @@ -103,32 +122,32 @@ test = ["pytest", "uvloop"] [[package]] name = "attrs" -version = "23.2.0" +version = "24.2.0" description = "Classes Without Boilerplate" optional = false python-versions = ">=3.7" files = [ - {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"}, - {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"}, + {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, + {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, ] [package.extras] -cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] -dev = ["attrs[tests]", "pre-commit"] -docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] -tests = ["attrs[tests-no-zope]", "zope-interface"] -tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"] -tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"] +benchmark = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +cov = ["cloudpickle", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +dev = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pre-commit", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier (<24.7)"] +tests = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +tests-mypy = ["mypy (>=1.11.1)", "pytest-mypy-plugins"] [[package]] name = "azure-core" -version = "1.30.1" +version = "1.31.0" description = "Microsoft Azure Core Library for Python" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "azure-core-1.30.1.tar.gz", hash = "sha256:26273a254131f84269e8ea4464f3560c731f29c0c1f69ac99010845f239c1a8f"}, - {file = "azure_core-1.30.1-py3-none-any.whl", hash = "sha256:7c5ee397e48f281ec4dd773d67a0a47a0962ed6fa833036057f9ea067f688e74"}, + {file = "azure_core-1.31.0-py3-none-any.whl", hash = "sha256:22954de3777e0250029360ef31d80448ef1be13b80a459bff80ba7073379e2cd"}, + {file = "azure_core-1.31.0.tar.gz", hash = "sha256:656a0dd61e1869b1506b7c6a3b31d62f15984b1a573d6326f6aa2f3e4123284b"}, ] [package.dependencies] @@ -141,30 +160,31 @@ aio = ["aiohttp (>=3.0)"] [[package]] name = "azure-identity" -version = "1.16.0" +version = "1.18.0" description = "Microsoft Azure Identity Library for Python" optional = false python-versions = ">=3.8" files = [ - {file = "azure-identity-1.16.0.tar.gz", hash = "sha256:6ff1d667cdcd81da1ceab42f80a0be63ca846629f518a922f7317a7e3c844e1b"}, - {file = "azure_identity-1.16.0-py3-none-any.whl", hash = "sha256:722fdb60b8fdd55fa44dc378b8072f4b419b56a5e54c0de391f644949f3a826f"}, + {file = "azure_identity-1.18.0-py3-none-any.whl", hash = "sha256:bccf6106245b49ff41d0c4cd7b72851c5a2ba3a32cef7589da246f5727f26f02"}, + {file = "azure_identity-1.18.0.tar.gz", hash = "sha256:f567579a65d8932fa913c76eddf3305101a15e5727a5e4aa5df649a0f553d4c3"}, ] [package.dependencies] -azure-core = ">=1.23.0" +azure-core = ">=1.31.0" cryptography = ">=2.5" -msal = ">=1.24.0" -msal-extensions = ">=0.3.0" +msal = ">=1.30.0" +msal-extensions = ">=1.2.0" +typing-extensions = ">=4.0.0" [[package]] name = "babel" -version = "2.15.0" +version = "2.16.0" description = "Internationalization utilities" optional = false python-versions = ">=3.8" files = [ - {file = "Babel-2.15.0-py3-none-any.whl", hash = "sha256:08706bdad8d0a3413266ab61bd6c34d0c28d6e1e7badf40a2cebe67644e2e1fb"}, - {file = "babel-2.15.0.tar.gz", hash = "sha256:8daf0e265d05768bc6c7a314cf1321e9a123afc328cc635c18622a2f30a04413"}, + {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, + {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, ] [package.extras] @@ -279,85 +299,100 @@ test = ["black (>=22.3.0)", "coverage[toml] (>=6.2)", "hypothesis (>=5.49.0)", " [[package]] name = "cachetools" -version = "5.3.3" +version = "5.5.0" description = "Extensible memoizing collections and decorators" optional = false python-versions = ">=3.7" files = [ - {file = "cachetools-5.3.3-py3-none-any.whl", hash = "sha256:0abad1021d3f8325b2fc1d2e9c8b9c9d57b04c3932657a72465447332c24d945"}, - {file = "cachetools-5.3.3.tar.gz", hash = "sha256:ba29e2dfa0b8b556606f097407ed1aa62080ee108ab0dc5ec9d6a723a007d105"}, + {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"}, + {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"}, ] [[package]] name = "certifi" -version = "2024.2.2" +version = "2024.8.30" description = "Python package for providing Mozilla's CA Bundle." optional = false python-versions = ">=3.6" files = [ - {file = "certifi-2024.2.2-py3-none-any.whl", hash = "sha256:dc383c07b76109f368f6106eee2b593b04a011ea4d55f652c6ca24a754d1cdd1"}, - {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"}, + {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, + {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, ] [[package]] name = "cffi" -version = "1.16.0" +version = "1.17.1" description = "Foreign Function Interface for Python calling C code." optional = false python-versions = ">=3.8" files = [ - {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, - {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, - {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, - {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, - {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, - {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, - {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, - {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, - {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, - {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, - {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, - {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, - {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, - {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, - {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, - {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, - {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, - {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, - {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, - {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, - {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, - {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, - {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, - {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, - {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, - {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, - {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, - {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, - {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, - {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, - {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, - {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, + {file = "cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14"}, + {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17"}, + {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8"}, + {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e"}, + {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be"}, + {file = "cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c"}, + {file = "cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15"}, + {file = "cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401"}, + {file = "cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d"}, + {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6"}, + {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f"}, + {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b"}, + {file = "cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655"}, + {file = "cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0"}, + {file = "cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4"}, + {file = "cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93"}, + {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3"}, + {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8"}, + {file = "cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65"}, + {file = "cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903"}, + {file = "cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e"}, + {file = "cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd"}, + {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed"}, + {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9"}, + {file = "cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d"}, + {file = "cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a"}, + {file = "cffi-1.17.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1"}, + {file = "cffi-1.17.1-cp38-cp38-win32.whl", hash = "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8"}, + {file = "cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1"}, + {file = "cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16"}, + {file = "cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3"}, + {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595"}, + {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a"}, + {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e"}, + {file = "cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7"}, + {file = "cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662"}, + {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, ] [package.dependencies] @@ -476,26 +511,15 @@ files = [ [package.dependencies] colorama = {version = "*", markers = "platform_system == \"Windows\""} -[[package]] -name = "cloudpickle" -version = "3.0.0" -description = "Pickler class to extend the standard pickle.Pickler functionality" -optional = false -python-versions = ">=3.8" -files = [ - {file = "cloudpickle-3.0.0-py3-none-any.whl", hash = "sha256:246ee7d0c295602a036e86369c77fecda4ab17b506496730f2f576d9016fd9c7"}, - {file = "cloudpickle-3.0.0.tar.gz", hash = "sha256:996d9a482c6fb4f33c1a35335cf8afd065d2a56e973270364840712d9131a882"}, -] - [[package]] name = "cma" -version = "3.3.0" +version = "3.4.0" description = "CMA-ES, Covariance Matrix Adaptation Evolution Strategy for non-linear numerical optimization in Python" optional = false python-versions = "*" files = [ - {file = "cma-3.3.0-py3-none-any.whl", hash = "sha256:5cc571b1e2068fcf1c538be36f8f3a870107456fed22ce81c1345a96329e61db"}, - {file = "cma-3.3.0.tar.gz", hash = "sha256:b748b8e03f4e7ae816157d7b9bb2fc6b1fb2fee1d5fd3399329b646bb75861ec"}, + {file = "cma-3.4.0-py3-none-any.whl", hash = "sha256:4140e490cc4e68cf8c7b1114e079c0561c9b78b1bf9ec69362c20865636ae5ca"}, + {file = "cma-3.4.0.tar.gz", hash = "sha256:a1ebd969b99871be3715d5a24b7bf54cf04ea94e80d6b8536d7147620dd10f6c"}, ] [package.dependencies] @@ -516,6 +540,23 @@ files = [ {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] +[[package]] +name = "colorlog" +version = "6.8.2" +description = "Add colours to the output of Python's logging module." +optional = false +python-versions = ">=3.6" +files = [ + {file = "colorlog-6.8.2-py3-none-any.whl", hash = "sha256:4dcbb62368e2800cb3c5abd348da7e53f6c362dda502ec27c560b2e58a66bd33"}, + {file = "colorlog-6.8.2.tar.gz", hash = "sha256:3e3e079a41feb5a1b64f978b5ea4f46040a94f11f0e8bbb8261e3dbbeca64d44"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} + +[package.extras] +development = ["black", "flake8", "mypy", "pytest", "types-colorama"] + [[package]] name = "comm" version = "0.2.2" @@ -549,126 +590,167 @@ test = ["flake8 (==3.7.8)", "hypothesis (==3.55.3)"] [[package]] name = "contourpy" -version = "1.2.1" +version = "1.3.0" description = "Python library for calculating contours of 2D quadrilateral grids" optional = false python-versions = ">=3.9" files = [ - {file = "contourpy-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd7c23df857d488f418439686d3b10ae2fbf9bc256cd045b37a8c16575ea1040"}, - {file = "contourpy-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5b9eb0ca724a241683c9685a484da9d35c872fd42756574a7cfbf58af26677fd"}, - {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c75507d0a55378240f781599c30e7776674dbaf883a46d1c90f37e563453480"}, - {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11959f0ce4a6f7b76ec578576a0b61a28bdc0696194b6347ba3f1c53827178b9"}, - {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb3315a8a236ee19b6df481fc5f997436e8ade24a9f03dfdc6bd490fea20c6da"}, - {file = "contourpy-1.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39f3ecaf76cd98e802f094e0d4fbc6dc9c45a8d0c4d185f0f6c2234e14e5f75b"}, - {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:94b34f32646ca0414237168d68a9157cb3889f06b096612afdd296003fdd32fd"}, - {file = "contourpy-1.2.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:457499c79fa84593f22454bbd27670227874cd2ff5d6c84e60575c8b50a69619"}, - {file = "contourpy-1.2.1-cp310-cp310-win32.whl", hash = "sha256:ac58bdee53cbeba2ecad824fa8159493f0bf3b8ea4e93feb06c9a465d6c87da8"}, - {file = "contourpy-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:9cffe0f850e89d7c0012a1fb8730f75edd4320a0a731ed0c183904fe6ecfc3a9"}, - {file = "contourpy-1.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6022cecf8f44e36af10bd9118ca71f371078b4c168b6e0fab43d4a889985dbb5"}, - {file = "contourpy-1.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ef5adb9a3b1d0c645ff694f9bca7702ec2c70f4d734f9922ea34de02294fdf72"}, - {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6150ffa5c767bc6332df27157d95442c379b7dce3a38dff89c0f39b63275696f"}, - {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c863140fafc615c14a4bf4efd0f4425c02230eb8ef02784c9a156461e62c965"}, - {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:00e5388f71c1a0610e6fe56b5c44ab7ba14165cdd6d695429c5cd94021e390b2"}, - {file = "contourpy-1.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4492d82b3bc7fbb7e3610747b159869468079fe149ec5c4d771fa1f614a14df"}, - {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:49e70d111fee47284d9dd867c9bb9a7058a3c617274900780c43e38d90fe1205"}, - {file = "contourpy-1.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b59c0ffceff8d4d3996a45f2bb6f4c207f94684a96bf3d9728dbb77428dd8cb8"}, - {file = "contourpy-1.2.1-cp311-cp311-win32.whl", hash = "sha256:7b4182299f251060996af5249c286bae9361fa8c6a9cda5efc29fe8bfd6062ec"}, - {file = "contourpy-1.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2855c8b0b55958265e8b5888d6a615ba02883b225f2227461aa9127c578a4922"}, - {file = "contourpy-1.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:62828cada4a2b850dbef89c81f5a33741898b305db244904de418cc957ff05dc"}, - {file = "contourpy-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:309be79c0a354afff9ff7da4aaed7c3257e77edf6c1b448a779329431ee79d7e"}, - {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e785e0f2ef0d567099b9ff92cbfb958d71c2d5b9259981cd9bee81bd194c9a4"}, - {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cac0a8f71a041aa587410424ad46dfa6a11f6149ceb219ce7dd48f6b02b87a7"}, - {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af3f4485884750dddd9c25cb7e3915d83c2db92488b38ccb77dd594eac84c4a0"}, - {file = "contourpy-1.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce6889abac9a42afd07a562c2d6d4b2b7134f83f18571d859b25624a331c90b"}, - {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a1eea9aecf761c661d096d39ed9026574de8adb2ae1c5bd7b33558af884fb2ce"}, - {file = "contourpy-1.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:187fa1d4c6acc06adb0fae5544c59898ad781409e61a926ac7e84b8f276dcef4"}, - {file = "contourpy-1.2.1-cp312-cp312-win32.whl", hash = "sha256:c2528d60e398c7c4c799d56f907664673a807635b857df18f7ae64d3e6ce2d9f"}, - {file = "contourpy-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:1a07fc092a4088ee952ddae19a2b2a85757b923217b7eed584fdf25f53a6e7ce"}, - {file = "contourpy-1.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bb6834cbd983b19f06908b45bfc2dad6ac9479ae04abe923a275b5f48f1a186b"}, - {file = "contourpy-1.2.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1d59e739ab0e3520e62a26c60707cc3ab0365d2f8fecea74bfe4de72dc56388f"}, - {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd3db01f59fdcbce5b22afad19e390260d6d0222f35a1023d9adc5690a889364"}, - {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a12a813949e5066148712a0626895c26b2578874e4cc63160bb007e6df3436fe"}, - {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe0ccca550bb8e5abc22f530ec0466136379c01321fd94f30a22231e8a48d985"}, - {file = "contourpy-1.2.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1d59258c3c67c865435d8fbeb35f8c59b8bef3d6f46c1f29f6123556af28445"}, - {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f32c38afb74bd98ce26de7cc74a67b40afb7b05aae7b42924ea990d51e4dac02"}, - {file = "contourpy-1.2.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d31a63bc6e6d87f77d71e1abbd7387ab817a66733734883d1fc0021ed9bfa083"}, - {file = "contourpy-1.2.1-cp39-cp39-win32.whl", hash = "sha256:ddcb8581510311e13421b1f544403c16e901c4e8f09083c881fab2be80ee31ba"}, - {file = "contourpy-1.2.1-cp39-cp39-win_amd64.whl", hash = "sha256:10a37ae557aabf2509c79715cd20b62e4c7c28b8cd62dd7d99e5ed3ce28c3fd9"}, - {file = "contourpy-1.2.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a31f94983fecbac95e58388210427d68cd30fe8a36927980fab9c20062645609"}, - {file = "contourpy-1.2.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef2b055471c0eb466033760a521efb9d8a32b99ab907fc8358481a1dd29e3bd3"}, - {file = "contourpy-1.2.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b33d2bc4f69caedcd0a275329eb2198f560b325605810895627be5d4b876bf7f"}, - {file = "contourpy-1.2.1.tar.gz", hash = "sha256:4d8908b3bee1c889e547867ca4cdc54e5ab6be6d3e078556814a22457f49423c"}, + {file = "contourpy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:880ea32e5c774634f9fcd46504bf9f080a41ad855f4fef54f5380f5133d343c7"}, + {file = "contourpy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:76c905ef940a4474a6289c71d53122a4f77766eef23c03cd57016ce19d0f7b42"}, + {file = "contourpy-1.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:92f8557cbb07415a4d6fa191f20fd9d2d9eb9c0b61d1b2f52a8926e43c6e9af7"}, + {file = "contourpy-1.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36f965570cff02b874773c49bfe85562b47030805d7d8360748f3eca570f4cab"}, + {file = "contourpy-1.3.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cacd81e2d4b6f89c9f8a5b69b86490152ff39afc58a95af002a398273e5ce589"}, + {file = "contourpy-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69375194457ad0fad3a839b9e29aa0b0ed53bb54db1bfb6c3ae43d111c31ce41"}, + {file = "contourpy-1.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a52040312b1a858b5e31ef28c2e865376a386c60c0e248370bbea2d3f3b760d"}, + {file = "contourpy-1.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3faeb2998e4fcb256542e8a926d08da08977f7f5e62cf733f3c211c2a5586223"}, + {file = "contourpy-1.3.0-cp310-cp310-win32.whl", hash = "sha256:36e0cff201bcb17a0a8ecc7f454fe078437fa6bda730e695a92f2d9932bd507f"}, + {file = "contourpy-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:87ddffef1dbe5e669b5c2440b643d3fdd8622a348fe1983fad7a0f0ccb1cd67b"}, + {file = "contourpy-1.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fa4c02abe6c446ba70d96ece336e621efa4aecae43eaa9b030ae5fb92b309ad"}, + {file = "contourpy-1.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:834e0cfe17ba12f79963861e0f908556b2cedd52e1f75e6578801febcc6a9f49"}, + {file = "contourpy-1.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dbc4c3217eee163fa3984fd1567632b48d6dfd29216da3ded3d7b844a8014a66"}, + {file = "contourpy-1.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4865cd1d419e0c7a7bf6de1777b185eebdc51470800a9f42b9e9decf17762081"}, + {file = "contourpy-1.3.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:303c252947ab4b14c08afeb52375b26781ccd6a5ccd81abcdfc1fafd14cf93c1"}, + {file = "contourpy-1.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637f674226be46f6ba372fd29d9523dd977a291f66ab2a74fbeb5530bb3f445d"}, + {file = "contourpy-1.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:76a896b2f195b57db25d6b44e7e03f221d32fe318d03ede41f8b4d9ba1bff53c"}, + {file = "contourpy-1.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e1fd23e9d01591bab45546c089ae89d926917a66dceb3abcf01f6105d927e2cb"}, + {file = "contourpy-1.3.0-cp311-cp311-win32.whl", hash = "sha256:d402880b84df3bec6eab53cd0cf802cae6a2ef9537e70cf75e91618a3801c20c"}, + {file = "contourpy-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:6cb6cc968059db9c62cb35fbf70248f40994dfcd7aa10444bbf8b3faeb7c2d67"}, + {file = "contourpy-1.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:570ef7cf892f0afbe5b2ee410c507ce12e15a5fa91017a0009f79f7d93a1268f"}, + {file = "contourpy-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:da84c537cb8b97d153e9fb208c221c45605f73147bd4cadd23bdae915042aad6"}, + {file = "contourpy-1.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0be4d8425bfa755e0fd76ee1e019636ccc7c29f77a7c86b4328a9eb6a26d0639"}, + {file = "contourpy-1.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9c0da700bf58f6e0b65312d0a5e695179a71d0163957fa381bb3c1f72972537c"}, + {file = "contourpy-1.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb8b141bb00fa977d9122636b16aa67d37fd40a3d8b52dd837e536d64b9a4d06"}, + {file = "contourpy-1.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3634b5385c6716c258d0419c46d05c8aa7dc8cb70326c9a4fb66b69ad2b52e09"}, + {file = "contourpy-1.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0dce35502151b6bd35027ac39ba6e5a44be13a68f55735c3612c568cac3805fd"}, + {file = "contourpy-1.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea348f053c645100612b333adc5983d87be69acdc6d77d3169c090d3b01dc35"}, + {file = "contourpy-1.3.0-cp312-cp312-win32.whl", hash = "sha256:90f73a5116ad1ba7174341ef3ea5c3150ddf20b024b98fb0c3b29034752c8aeb"}, + {file = "contourpy-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:b11b39aea6be6764f84360fce6c82211a9db32a7c7de8fa6dd5397cf1d079c3b"}, + {file = "contourpy-1.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3e1c7fa44aaae40a2247e2e8e0627f4bea3dd257014764aa644f319a5f8600e3"}, + {file = "contourpy-1.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:364174c2a76057feef647c802652f00953b575723062560498dc7930fc9b1cb7"}, + {file = "contourpy-1.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32b238b3b3b649e09ce9aaf51f0c261d38644bdfa35cbaf7b263457850957a84"}, + {file = "contourpy-1.3.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d51fca85f9f7ad0b65b4b9fe800406d0d77017d7270d31ec3fb1cc07358fdea0"}, + {file = "contourpy-1.3.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:732896af21716b29ab3e988d4ce14bc5133733b85956316fb0c56355f398099b"}, + {file = "contourpy-1.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d73f659398a0904e125280836ae6f88ba9b178b2fed6884f3b1f95b989d2c8da"}, + {file = "contourpy-1.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c6c7c2408b7048082932cf4e641fa3b8ca848259212f51c8c59c45aa7ac18f14"}, + {file = "contourpy-1.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f317576606de89da6b7e0861cf6061f6146ead3528acabff9236458a6ba467f8"}, + {file = "contourpy-1.3.0-cp313-cp313-win32.whl", hash = "sha256:31cd3a85dbdf1fc002280c65caa7e2b5f65e4a973fcdf70dd2fdcb9868069294"}, + {file = "contourpy-1.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:4553c421929ec95fb07b3aaca0fae668b2eb5a5203d1217ca7c34c063c53d087"}, + {file = "contourpy-1.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:345af746d7766821d05d72cb8f3845dfd08dd137101a2cb9b24de277d716def8"}, + {file = "contourpy-1.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3bb3808858a9dc68f6f03d319acd5f1b8a337e6cdda197f02f4b8ff67ad2057b"}, + {file = "contourpy-1.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:420d39daa61aab1221567b42eecb01112908b2cab7f1b4106a52caaec8d36973"}, + {file = "contourpy-1.3.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d63ee447261e963af02642ffcb864e5a2ee4cbfd78080657a9880b8b1868e18"}, + {file = "contourpy-1.3.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:167d6c890815e1dac9536dca00828b445d5d0df4d6a8c6adb4a7ec3166812fa8"}, + {file = "contourpy-1.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:710a26b3dc80c0e4febf04555de66f5fd17e9cf7170a7b08000601a10570bda6"}, + {file = "contourpy-1.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:75ee7cb1a14c617f34a51d11fa7524173e56551646828353c4af859c56b766e2"}, + {file = "contourpy-1.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:33c92cdae89ec5135d036e7218e69b0bb2851206077251f04a6c4e0e21f03927"}, + {file = "contourpy-1.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a11077e395f67ffc2c44ec2418cfebed032cd6da3022a94fc227b6faf8e2acb8"}, + {file = "contourpy-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e8134301d7e204c88ed7ab50028ba06c683000040ede1d617298611f9dc6240c"}, + {file = "contourpy-1.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e12968fdfd5bb45ffdf6192a590bd8ddd3ba9e58360b29683c6bb71a7b41edca"}, + {file = "contourpy-1.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fd2a0fc506eccaaa7595b7e1418951f213cf8255be2600f1ea1b61e46a60c55f"}, + {file = "contourpy-1.3.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4cfb5c62ce023dfc410d6059c936dcf96442ba40814aefbfa575425a3a7f19dc"}, + {file = "contourpy-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68a32389b06b82c2fdd68276148d7b9275b5f5cf13e5417e4252f6d1a34f72a2"}, + {file = "contourpy-1.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:94e848a6b83da10898cbf1311a815f770acc9b6a3f2d646f330d57eb4e87592e"}, + {file = "contourpy-1.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:d78ab28a03c854a873787a0a42254a0ccb3cb133c672f645c9f9c8f3ae9d0800"}, + {file = "contourpy-1.3.0-cp39-cp39-win32.whl", hash = "sha256:81cb5ed4952aae6014bc9d0421dec7c5835c9c8c31cdf51910b708f548cf58e5"}, + {file = "contourpy-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:14e262f67bd7e6eb6880bc564dcda30b15e351a594657e55b7eec94b6ef72843"}, + {file = "contourpy-1.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fe41b41505a5a33aeaed2a613dccaeaa74e0e3ead6dd6fd3a118fb471644fd6c"}, + {file = "contourpy-1.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eca7e17a65f72a5133bdbec9ecf22401c62bcf4821361ef7811faee695799779"}, + {file = "contourpy-1.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1ec4dc6bf570f5b22ed0d7efba0dfa9c5b9e0431aeea7581aa217542d9e809a4"}, + {file = "contourpy-1.3.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:00ccd0dbaad6d804ab259820fa7cb0b8036bda0686ef844d24125d8287178ce0"}, + {file = "contourpy-1.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ca947601224119117f7c19c9cdf6b3ab54c5726ef1d906aa4a69dfb6dd58102"}, + {file = "contourpy-1.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c6ec93afeb848a0845a18989da3beca3eec2c0f852322efe21af1931147d12cb"}, + {file = "contourpy-1.3.0.tar.gz", hash = "sha256:7ffa0db17717a8ffb127efd0c95a4362d996b892c2904db72428d5b52e1938a4"}, ] [package.dependencies] -numpy = ">=1.20" +numpy = ">=1.23" [package.extras] bokeh = ["bokeh", "selenium"] docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"] -mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.8.0)", "types-Pillow"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.11.1)", "types-Pillow"] test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] -test-no-images = ["pytest", "pytest-cov", "pytest-xdist", "wurlitzer"] +test-no-images = ["pytest", "pytest-cov", "pytest-rerunfailures", "pytest-xdist", "wurlitzer"] [[package]] name = "coverage" -version = "7.5.1" +version = "7.6.1" description = "Code coverage measurement for Python" optional = false python-versions = ">=3.8" files = [ - {file = "coverage-7.5.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c0884920835a033b78d1c73b6d3bbcda8161a900f38a488829a83982925f6c2e"}, - {file = "coverage-7.5.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:39afcd3d4339329c5f58de48a52f6e4e50f6578dd6099961cf22228feb25f38f"}, - {file = "coverage-7.5.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a7b0ceee8147444347da6a66be737c9d78f3353b0681715b668b72e79203e4a"}, - {file = "coverage-7.5.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a9ca3f2fae0088c3c71d743d85404cec8df9be818a005ea065495bedc33da35"}, - {file = "coverage-7.5.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fd215c0c7d7aab005221608a3c2b46f58c0285a819565887ee0b718c052aa4e"}, - {file = "coverage-7.5.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:4bf0655ab60d754491004a5efd7f9cccefcc1081a74c9ef2da4735d6ee4a6223"}, - {file = "coverage-7.5.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:61c4bf1ba021817de12b813338c9be9f0ad5b1e781b9b340a6d29fc13e7c1b5e"}, - {file = "coverage-7.5.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:db66fc317a046556a96b453a58eced5024af4582a8dbdc0c23ca4dbc0d5b3146"}, - {file = "coverage-7.5.1-cp310-cp310-win32.whl", hash = "sha256:b016ea6b959d3b9556cb401c55a37547135a587db0115635a443b2ce8f1c7228"}, - {file = "coverage-7.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:df4e745a81c110e7446b1cc8131bf986157770fa405fe90e15e850aaf7619bc8"}, - {file = "coverage-7.5.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:796a79f63eca8814ca3317a1ea443645c9ff0d18b188de470ed7ccd45ae79428"}, - {file = "coverage-7.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4fc84a37bfd98db31beae3c2748811a3fa72bf2007ff7902f68746d9757f3746"}, - {file = "coverage-7.5.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6175d1a0559986c6ee3f7fccfc4a90ecd12ba0a383dcc2da30c2b9918d67d8a3"}, - {file = "coverage-7.5.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fc81d5878cd6274ce971e0a3a18a8803c3fe25457165314271cf78e3aae3aa2"}, - {file = "coverage-7.5.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:556cf1a7cbc8028cb60e1ff0be806be2eded2daf8129b8811c63e2b9a6c43bca"}, - {file = "coverage-7.5.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:9981706d300c18d8b220995ad22627647be11a4276721c10911e0e9fa44c83e8"}, - {file = "coverage-7.5.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:d7fed867ee50edf1a0b4a11e8e5d0895150e572af1cd6d315d557758bfa9c057"}, - {file = "coverage-7.5.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ef48e2707fb320c8f139424a596f5b69955a85b178f15af261bab871873bb987"}, - {file = "coverage-7.5.1-cp311-cp311-win32.whl", hash = "sha256:9314d5678dcc665330df5b69c1e726a0e49b27df0461c08ca12674bcc19ef136"}, - {file = "coverage-7.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:5fa567e99765fe98f4e7d7394ce623e794d7cabb170f2ca2ac5a4174437e90dd"}, - {file = "coverage-7.5.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b6cf3764c030e5338e7f61f95bd21147963cf6aa16e09d2f74f1fa52013c1206"}, - {file = "coverage-7.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2ec92012fefebee89a6b9c79bc39051a6cb3891d562b9270ab10ecfdadbc0c34"}, - {file = "coverage-7.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:16db7f26000a07efcf6aea00316f6ac57e7d9a96501e990a36f40c965ec7a95d"}, - {file = "coverage-7.5.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:beccf7b8a10b09c4ae543582c1319c6df47d78fd732f854ac68d518ee1fb97fa"}, - {file = "coverage-7.5.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8748731ad392d736cc9ccac03c9845b13bb07d020a33423fa5b3a36521ac6e4e"}, - {file = "coverage-7.5.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7352b9161b33fd0b643ccd1f21f3a3908daaddf414f1c6cb9d3a2fd618bf2572"}, - {file = "coverage-7.5.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:7a588d39e0925f6a2bff87154752481273cdb1736270642aeb3635cb9b4cad07"}, - {file = "coverage-7.5.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:68f962d9b72ce69ea8621f57551b2fa9c70509af757ee3b8105d4f51b92b41a7"}, - {file = "coverage-7.5.1-cp312-cp312-win32.whl", hash = "sha256:f152cbf5b88aaeb836127d920dd0f5e7edff5a66f10c079157306c4343d86c19"}, - {file = "coverage-7.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:5a5740d1fb60ddf268a3811bcd353de34eb56dc24e8f52a7f05ee513b2d4f596"}, - {file = "coverage-7.5.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e2213def81a50519d7cc56ed643c9e93e0247f5bbe0d1247d15fa520814a7cd7"}, - {file = "coverage-7.5.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5037f8fcc2a95b1f0e80585bd9d1ec31068a9bcb157d9750a172836e98bc7a90"}, - {file = "coverage-7.5.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c3721c2c9e4c4953a41a26c14f4cef64330392a6d2d675c8b1db3b645e31f0e"}, - {file = "coverage-7.5.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ca498687ca46a62ae590253fba634a1fe9836bc56f626852fb2720f334c9e4e5"}, - {file = "coverage-7.5.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cdcbc320b14c3e5877ee79e649677cb7d89ef588852e9583e6b24c2e5072661"}, - {file = "coverage-7.5.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:57e0204b5b745594e5bc14b9b50006da722827f0b8c776949f1135677e88d0b8"}, - {file = "coverage-7.5.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8fe7502616b67b234482c3ce276ff26f39ffe88adca2acf0261df4b8454668b4"}, - {file = "coverage-7.5.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:9e78295f4144f9dacfed4f92935fbe1780021247c2fabf73a819b17f0ccfff8d"}, - {file = "coverage-7.5.1-cp38-cp38-win32.whl", hash = "sha256:1434e088b41594baa71188a17533083eabf5609e8e72f16ce8c186001e6b8c41"}, - {file = "coverage-7.5.1-cp38-cp38-win_amd64.whl", hash = "sha256:0646599e9b139988b63704d704af8e8df7fa4cbc4a1f33df69d97f36cb0a38de"}, - {file = "coverage-7.5.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4cc37def103a2725bc672f84bd939a6fe4522310503207aae4d56351644682f1"}, - {file = "coverage-7.5.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:fc0b4d8bfeabd25ea75e94632f5b6e047eef8adaed0c2161ada1e922e7f7cece"}, - {file = "coverage-7.5.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d0a0f5e06881ecedfe6f3dd2f56dcb057b6dbeb3327fd32d4b12854df36bf26"}, - {file = "coverage-7.5.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9735317685ba6ec7e3754798c8871c2f49aa5e687cc794a0b1d284b2389d1bd5"}, - {file = "coverage-7.5.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d21918e9ef11edf36764b93101e2ae8cc82aa5efdc7c5a4e9c6c35a48496d601"}, - {file = "coverage-7.5.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c3e757949f268364b96ca894b4c342b41dc6f8f8b66c37878aacef5930db61be"}, - {file = "coverage-7.5.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:79afb6197e2f7f60c4824dd4b2d4c2ec5801ceb6ba9ce5d2c3080e5660d51a4f"}, - {file = "coverage-7.5.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d1d0d98d95dd18fe29dc66808e1accf59f037d5716f86a501fc0256455219668"}, - {file = "coverage-7.5.1-cp39-cp39-win32.whl", hash = "sha256:1cc0fe9b0b3a8364093c53b0b4c0c2dd4bb23acbec4c9240b5f284095ccf7981"}, - {file = "coverage-7.5.1-cp39-cp39-win_amd64.whl", hash = "sha256:dde0070c40ea8bb3641e811c1cfbf18e265d024deff6de52c5950677a8fb1e0f"}, - {file = "coverage-7.5.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:6537e7c10cc47c595828b8a8be04c72144725c383c4702703ff4e42e44577312"}, - {file = "coverage-7.5.1.tar.gz", hash = "sha256:54de9ef3a9da981f7af93eafde4ede199e0846cd819eb27c88e2b712aae9708c"}, + {file = "coverage-7.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b06079abebbc0e89e6163b8e8f0e16270124c154dc6e4a47b413dd538859af16"}, + {file = "coverage-7.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cf4b19715bccd7ee27b6b120e7e9dd56037b9c0681dcc1adc9ba9db3d417fa36"}, + {file = "coverage-7.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61c0abb4c85b095a784ef23fdd4aede7a2628478e7baba7c5e3deba61070a02"}, + {file = "coverage-7.6.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fd21f6ae3f08b41004dfb433fa895d858f3f5979e7762d052b12aef444e29afc"}, + {file = "coverage-7.6.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f59d57baca39b32db42b83b2a7ba6f47ad9c394ec2076b084c3f029b7afca23"}, + {file = "coverage-7.6.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a1ac0ae2b8bd743b88ed0502544847c3053d7171a3cff9228af618a068ed9c34"}, + {file = "coverage-7.6.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e6a08c0be454c3b3beb105c0596ebdc2371fab6bb90c0c0297f4e58fd7e1012c"}, + {file = "coverage-7.6.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f5796e664fe802da4f57a168c85359a8fbf3eab5e55cd4e4569fbacecc903959"}, + {file = "coverage-7.6.1-cp310-cp310-win32.whl", hash = "sha256:7bb65125fcbef8d989fa1dd0e8a060999497629ca5b0efbca209588a73356232"}, + {file = "coverage-7.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:3115a95daa9bdba70aea750db7b96b37259a81a709223c8448fa97727d546fe0"}, + {file = "coverage-7.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7dea0889685db8550f839fa202744652e87c60015029ce3f60e006f8c4462c93"}, + {file = "coverage-7.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed37bd3c3b063412f7620464a9ac1314d33100329f39799255fb8d3027da50d3"}, + {file = "coverage-7.6.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d85f5e9a5f8b73e2350097c3756ef7e785f55bd71205defa0bfdaf96c31616ff"}, + {file = "coverage-7.6.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bc572be474cafb617672c43fe989d6e48d3c83af02ce8de73fff1c6bb3c198d"}, + {file = "coverage-7.6.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0420b573964c760df9e9e86d1a9a622d0d27f417e1a949a8a66dd7bcee7bc6"}, + {file = "coverage-7.6.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1f4aa8219db826ce6be7099d559f8ec311549bfc4046f7f9fe9b5cea5c581c56"}, + {file = "coverage-7.6.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:fc5a77d0c516700ebad189b587de289a20a78324bc54baee03dd486f0855d234"}, + {file = "coverage-7.6.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b48f312cca9621272ae49008c7f613337c53fadca647d6384cc129d2996d1133"}, + {file = "coverage-7.6.1-cp311-cp311-win32.whl", hash = "sha256:1125ca0e5fd475cbbba3bb67ae20bd2c23a98fac4e32412883f9bcbaa81c314c"}, + {file = "coverage-7.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:8ae539519c4c040c5ffd0632784e21b2f03fc1340752af711f33e5be83a9d6c6"}, + {file = "coverage-7.6.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:95cae0efeb032af8458fc27d191f85d1717b1d4e49f7cb226cf526ff28179778"}, + {file = "coverage-7.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5621a9175cf9d0b0c84c2ef2b12e9f5f5071357c4d2ea6ca1cf01814f45d2391"}, + {file = "coverage-7.6.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:260933720fdcd75340e7dbe9060655aff3af1f0c5d20f46b57f262ab6c86a5e8"}, + {file = "coverage-7.6.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07e2ca0ad381b91350c0ed49d52699b625aab2b44b65e1b4e02fa9df0e92ad2d"}, + {file = "coverage-7.6.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c44fee9975f04b33331cb8eb272827111efc8930cfd582e0320613263ca849ca"}, + {file = "coverage-7.6.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877abb17e6339d96bf08e7a622d05095e72b71f8afd8a9fefc82cf30ed944163"}, + {file = "coverage-7.6.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3e0cadcf6733c09154b461f1ca72d5416635e5e4ec4e536192180d34ec160f8a"}, + {file = "coverage-7.6.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c3c02d12f837d9683e5ab2f3d9844dc57655b92c74e286c262e0fc54213c216d"}, + {file = "coverage-7.6.1-cp312-cp312-win32.whl", hash = "sha256:e05882b70b87a18d937ca6768ff33cc3f72847cbc4de4491c8e73880766718e5"}, + {file = "coverage-7.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:b5d7b556859dd85f3a541db6a4e0167b86e7273e1cdc973e5b175166bb634fdb"}, + {file = "coverage-7.6.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a4acd025ecc06185ba2b801f2de85546e0b8ac787cf9d3b06e7e2a69f925b106"}, + {file = "coverage-7.6.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a6d3adcf24b624a7b778533480e32434a39ad8fa30c315208f6d3e5542aeb6e9"}, + {file = "coverage-7.6.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0c212c49b6c10e6951362f7c6df3329f04c2b1c28499563d4035d964ab8e08c"}, + {file = "coverage-7.6.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6e81d7a3e58882450ec4186ca59a3f20a5d4440f25b1cff6f0902ad890e6748a"}, + {file = "coverage-7.6.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78b260de9790fd81e69401c2dc8b17da47c8038176a79092a89cb2b7d945d060"}, + {file = "coverage-7.6.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a78d169acd38300060b28d600344a803628c3fd585c912cacc9ea8790fe96862"}, + {file = "coverage-7.6.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2c09f4ce52cb99dd7505cd0fc8e0e37c77b87f46bc9c1eb03fe3bc9991085388"}, + {file = "coverage-7.6.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6878ef48d4227aace338d88c48738a4258213cd7b74fd9a3d4d7582bb1d8a155"}, + {file = "coverage-7.6.1-cp313-cp313-win32.whl", hash = "sha256:44df346d5215a8c0e360307d46ffaabe0f5d3502c8a1cefd700b34baf31d411a"}, + {file = "coverage-7.6.1-cp313-cp313-win_amd64.whl", hash = "sha256:8284cf8c0dd272a247bc154eb6c95548722dce90d098c17a883ed36e67cdb129"}, + {file = "coverage-7.6.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d3296782ca4eab572a1a4eca686d8bfb00226300dcefdf43faa25b5242ab8a3e"}, + {file = "coverage-7.6.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:502753043567491d3ff6d08629270127e0c31d4184c4c8d98f92c26f65019962"}, + {file = "coverage-7.6.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a89ecca80709d4076b95f89f308544ec8f7b4727e8a547913a35f16717856cb"}, + {file = "coverage-7.6.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a318d68e92e80af8b00fa99609796fdbcdfef3629c77c6283566c6f02c6d6704"}, + {file = "coverage-7.6.1-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13b0a73a0896988f053e4fbb7de6d93388e6dd292b0d87ee51d106f2c11b465b"}, + {file = "coverage-7.6.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4421712dbfc5562150f7554f13dde997a2e932a6b5f352edcce948a815efee6f"}, + {file = "coverage-7.6.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:166811d20dfea725e2e4baa71fffd6c968a958577848d2131f39b60043400223"}, + {file = "coverage-7.6.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:225667980479a17db1048cb2bf8bfb39b8e5be8f164b8f6628b64f78a72cf9d3"}, + {file = "coverage-7.6.1-cp313-cp313t-win32.whl", hash = "sha256:170d444ab405852903b7d04ea9ae9b98f98ab6d7e63e1115e82620807519797f"}, + {file = "coverage-7.6.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b9f222de8cded79c49bf184bdbc06630d4c58eec9459b939b4a690c82ed05657"}, + {file = "coverage-7.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6db04803b6c7291985a761004e9060b2bca08da6d04f26a7f2294b8623a0c1a0"}, + {file = "coverage-7.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f1adfc8ac319e1a348af294106bc6a8458a0f1633cc62a1446aebc30c5fa186a"}, + {file = "coverage-7.6.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a95324a9de9650a729239daea117df21f4b9868ce32e63f8b650ebe6cef5595b"}, + {file = "coverage-7.6.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b43c03669dc4618ec25270b06ecd3ee4fa94c7f9b3c14bae6571ca00ef98b0d3"}, + {file = "coverage-7.6.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8929543a7192c13d177b770008bc4e8119f2e1f881d563fc6b6305d2d0ebe9de"}, + {file = "coverage-7.6.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:a09ece4a69cf399510c8ab25e0950d9cf2b42f7b3cb0374f95d2e2ff594478a6"}, + {file = "coverage-7.6.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:9054a0754de38d9dbd01a46621636689124d666bad1936d76c0341f7d71bf569"}, + {file = "coverage-7.6.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0dbde0f4aa9a16fa4d754356a8f2e36296ff4d83994b2c9d8398aa32f222f989"}, + {file = "coverage-7.6.1-cp38-cp38-win32.whl", hash = "sha256:da511e6ad4f7323ee5702e6633085fb76c2f893aaf8ce4c51a0ba4fc07580ea7"}, + {file = "coverage-7.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:3f1156e3e8f2872197af3840d8ad307a9dd18e615dc64d9ee41696f287c57ad8"}, + {file = "coverage-7.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:abd5fd0db5f4dc9289408aaf34908072f805ff7792632250dcb36dc591d24255"}, + {file = "coverage-7.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:547f45fa1a93154bd82050a7f3cddbc1a7a4dd2a9bf5cb7d06f4ae29fe94eaf8"}, + {file = "coverage-7.6.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:645786266c8f18a931b65bfcefdbf6952dd0dea98feee39bd188607a9d307ed2"}, + {file = "coverage-7.6.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9e0b2df163b8ed01d515807af24f63de04bebcecbd6c3bfeff88385789fdf75a"}, + {file = "coverage-7.6.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:609b06f178fe8e9f89ef676532760ec0b4deea15e9969bf754b37f7c40326dbc"}, + {file = "coverage-7.6.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:702855feff378050ae4f741045e19a32d57d19f3e0676d589df0575008ea5004"}, + {file = "coverage-7.6.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:2bdb062ea438f22d99cba0d7829c2ef0af1d768d1e4a4f528087224c90b132cb"}, + {file = "coverage-7.6.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:9c56863d44bd1c4fe2abb8a4d6f5371d197f1ac0ebdee542f07f35895fc07f36"}, + {file = "coverage-7.6.1-cp39-cp39-win32.whl", hash = "sha256:6e2cd258d7d927d09493c8df1ce9174ad01b381d4729a9d8d4e38670ca24774c"}, + {file = "coverage-7.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:06a737c882bd26d0d6ee7269b20b12f14a8704807a01056c80bb881a4b2ce6ca"}, + {file = "coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df"}, + {file = "coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d"}, ] [package.dependencies] @@ -679,43 +761,38 @@ toml = ["tomli"] [[package]] name = "cryptography" -version = "42.0.7" +version = "43.0.1" description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers." optional = false python-versions = ">=3.7" files = [ - {file = "cryptography-42.0.7-cp37-abi3-macosx_10_12_universal2.whl", hash = "sha256:a987f840718078212fdf4504d0fd4c6effe34a7e4740378e59d47696e8dfb477"}, - {file = "cryptography-42.0.7-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:bd13b5e9b543532453de08bcdc3cc7cebec6f9883e886fd20a92f26940fd3e7a"}, - {file = "cryptography-42.0.7-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a79165431551042cc9d1d90e6145d5d0d3ab0f2d66326c201d9b0e7f5bf43604"}, - {file = "cryptography-42.0.7-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a47787a5e3649008a1102d3df55424e86606c9bae6fb77ac59afe06d234605f8"}, - {file = "cryptography-42.0.7-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:02c0eee2d7133bdbbc5e24441258d5d2244beb31da5ed19fbb80315f4bbbff55"}, - {file = "cryptography-42.0.7-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:5e44507bf8d14b36b8389b226665d597bc0f18ea035d75b4e53c7b1ea84583cc"}, - {file = "cryptography-42.0.7-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:7f8b25fa616d8b846aef64b15c606bb0828dbc35faf90566eb139aa9cff67af2"}, - {file = "cryptography-42.0.7-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:93a3209f6bb2b33e725ed08ee0991b92976dfdcf4e8b38646540674fc7508e13"}, - {file = "cryptography-42.0.7-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:e6b8f1881dac458c34778d0a424ae5769de30544fc678eac51c1c8bb2183e9da"}, - {file = "cryptography-42.0.7-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3de9a45d3b2b7d8088c3fbf1ed4395dfeff79d07842217b38df14ef09ce1d8d7"}, - {file = "cryptography-42.0.7-cp37-abi3-win32.whl", hash = "sha256:789caea816c6704f63f6241a519bfa347f72fbd67ba28d04636b7c6b7da94b0b"}, - {file = "cryptography-42.0.7-cp37-abi3-win_amd64.whl", hash = "sha256:8cb8ce7c3347fcf9446f201dc30e2d5a3c898d009126010cbd1f443f28b52678"}, - {file = "cryptography-42.0.7-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:a3a5ac8b56fe37f3125e5b72b61dcde43283e5370827f5233893d461b7360cd4"}, - {file = "cryptography-42.0.7-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:779245e13b9a6638df14641d029add5dc17edbef6ec915688f3acb9e720a5858"}, - {file = "cryptography-42.0.7-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d563795db98b4cd57742a78a288cdbdc9daedac29f2239793071fe114f13785"}, - {file = "cryptography-42.0.7-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:31adb7d06fe4383226c3e963471f6837742889b3c4caa55aac20ad951bc8ffda"}, - {file = "cryptography-42.0.7-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:efd0bf5205240182e0f13bcaea41be4fdf5c22c5129fc7ced4a0282ac86998c9"}, - {file = "cryptography-42.0.7-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:a9bc127cdc4ecf87a5ea22a2556cab6c7eda2923f84e4f3cc588e8470ce4e42e"}, - {file = "cryptography-42.0.7-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:3577d029bc3f4827dd5bf8bf7710cac13527b470bbf1820a3f394adb38ed7d5f"}, - {file = "cryptography-42.0.7-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2e47577f9b18723fa294b0ea9a17d5e53a227867a0a4904a1a076d1646d45ca1"}, - {file = "cryptography-42.0.7-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1a58839984d9cb34c855197043eaae2c187d930ca6d644612843b4fe8513c886"}, - {file = "cryptography-42.0.7-cp39-abi3-win32.whl", hash = "sha256:e6b79d0adb01aae87e8a44c2b64bc3f3fe59515280e00fb6d57a7267a2583cda"}, - {file = "cryptography-42.0.7-cp39-abi3-win_amd64.whl", hash = "sha256:16268d46086bb8ad5bf0a2b5544d8a9ed87a0e33f5e77dd3c3301e63d941a83b"}, - {file = "cryptography-42.0.7-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2954fccea107026512b15afb4aa664a5640cd0af630e2ee3962f2602693f0c82"}, - {file = "cryptography-42.0.7-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:362e7197754c231797ec45ee081f3088a27a47c6c01eff2ac83f60f85a50fe60"}, - {file = "cryptography-42.0.7-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4f698edacf9c9e0371112792558d2f705b5645076cc0aaae02f816a0171770fd"}, - {file = "cryptography-42.0.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5482e789294854c28237bba77c4c83be698be740e31a3ae5e879ee5444166582"}, - {file = "cryptography-42.0.7-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e9b2a6309f14c0497f348d08a065d52f3020656f675819fc405fb63bbcd26562"}, - {file = "cryptography-42.0.7-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:d8e3098721b84392ee45af2dd554c947c32cc52f862b6a3ae982dbb90f577f14"}, - {file = "cryptography-42.0.7-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c65f96dad14f8528a447414125e1fc8feb2ad5a272b8f68477abbcc1ea7d94b9"}, - {file = "cryptography-42.0.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:36017400817987670037fbb0324d71489b6ead6231c9604f8fc1f7d008087c68"}, - {file = "cryptography-42.0.7.tar.gz", hash = "sha256:ecbfbc00bf55888edda9868a4cf927205de8499e7fabe6c050322298382953f2"}, + {file = "cryptography-43.0.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:8385d98f6a3bf8bb2d65a73e17ed87a3ba84f6991c155691c51112075f9ffc5d"}, + {file = "cryptography-43.0.1-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27e613d7077ac613e399270253259d9d53872aaf657471473ebfc9a52935c062"}, + {file = "cryptography-43.0.1-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68aaecc4178e90719e95298515979814bda0cbada1256a4485414860bd7ab962"}, + {file = "cryptography-43.0.1-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:de41fd81a41e53267cb020bb3a7212861da53a7d39f863585d13ea11049cf277"}, + {file = "cryptography-43.0.1-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f98bf604c82c416bc829e490c700ca1553eafdf2912a91e23a79d97d9801372a"}, + {file = "cryptography-43.0.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:61ec41068b7b74268fa86e3e9e12b9f0c21fcf65434571dbb13d954bceb08042"}, + {file = "cryptography-43.0.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:014f58110f53237ace6a408b5beb6c427b64e084eb451ef25a28308270086494"}, + {file = "cryptography-43.0.1-cp37-abi3-win32.whl", hash = "sha256:2bd51274dcd59f09dd952afb696bf9c61a7a49dfc764c04dd33ef7a6b502a1e2"}, + {file = "cryptography-43.0.1-cp37-abi3-win_amd64.whl", hash = "sha256:666ae11966643886c2987b3b721899d250855718d6d9ce41b521252a17985f4d"}, + {file = "cryptography-43.0.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:ac119bb76b9faa00f48128b7f5679e1d8d437365c5d26f1c2c3f0da4ce1b553d"}, + {file = "cryptography-43.0.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1bbcce1a551e262dfbafb6e6252f1ae36a248e615ca44ba302df077a846a8806"}, + {file = "cryptography-43.0.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58d4e9129985185a06d849aa6df265bdd5a74ca6e1b736a77959b498e0505b85"}, + {file = "cryptography-43.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d03a475165f3134f773d1388aeb19c2d25ba88b6a9733c5c590b9ff7bbfa2e0c"}, + {file = "cryptography-43.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:511f4273808ab590912a93ddb4e3914dfd8a388fed883361b02dea3791f292e1"}, + {file = "cryptography-43.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:80eda8b3e173f0f247f711eef62be51b599b5d425c429b5d4ca6a05e9e856baa"}, + {file = "cryptography-43.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38926c50cff6f533f8a2dae3d7f19541432610d114a70808f0926d5aaa7121e4"}, + {file = "cryptography-43.0.1-cp39-abi3-win32.whl", hash = "sha256:a575913fb06e05e6b4b814d7f7468c2c660e8bb16d8d5a1faf9b33ccc569dd47"}, + {file = "cryptography-43.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:d75601ad10b059ec832e78823b348bfa1a59f6b8d545db3a24fd44362a1564cb"}, + {file = "cryptography-43.0.1-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:ea25acb556320250756e53f9e20a4177515f012c9eaea17eb7587a8c4d8ae034"}, + {file = "cryptography-43.0.1-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c1332724be35d23a854994ff0b66530119500b6053d0bd3363265f7e5e77288d"}, + {file = "cryptography-43.0.1-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:fba1007b3ef89946dbbb515aeeb41e30203b004f0b4b00e5e16078b518563289"}, + {file = "cryptography-43.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5b43d1ea6b378b54a1dc99dd8a2b5be47658fe9a7ce0a58ff0b55f4b43ef2b84"}, + {file = "cryptography-43.0.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:88cce104c36870d70c49c7c8fd22885875d950d9ee6ab54df2745f83ba0dc365"}, + {file = "cryptography-43.0.1-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:9d3cdb25fa98afdd3d0892d132b8d7139e2c087da1712041f6b762e4f807cc96"}, + {file = "cryptography-43.0.1-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e710bf40870f4db63c3d7d929aa9e09e4e7ee219e703f949ec4073b4294f6172"}, + {file = "cryptography-43.0.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7c05650fe8023c5ed0d46793d4b7d7e6cd9c04e68eabe5b0aeea836e37bdcec2"}, + {file = "cryptography-43.0.1.tar.gz", hash = "sha256:203e92a75716d8cfb491dc47c79e17d0d9207ccffcbcb35f598fbe463ae3444d"}, ] [package.dependencies] @@ -728,7 +805,7 @@ nox = ["nox"] pep8test = ["check-sdist", "click", "mypy", "ruff"] sdist = ["build"] ssh = ["bcrypt (>=3.1.5)"] -test = ["certifi", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] +test = ["certifi", "cryptography-vectors (==43.0.1)", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] test-randomorder = ["pytest-randomly"] [[package]] @@ -748,13 +825,13 @@ tests = ["pytest", "pytest-cov", "pytest-xdist"] [[package]] name = "dash" -version = "2.17.0" +version = "2.18.1" description = "A Python framework for building reactive web-apps. Developed by Plotly." optional = false python-versions = ">=3.8" files = [ - {file = "dash-2.17.0-py3-none-any.whl", hash = "sha256:2421569023b2cd46ea2d4b2c14fe72c71b7436527a3102219b2265fa361e7c67"}, - {file = "dash-2.17.0.tar.gz", hash = "sha256:d065cd88771e45d0485993be0d27565e08918cb7edd18e31ee1c5b41252fc2fa"}, + {file = "dash-2.18.1-py3-none-any.whl", hash = "sha256:07c4513bb5f79a4b936847a0b49afc21dbd4b001ff77ea78d4d836043e211a07"}, + {file = "dash-2.18.1.tar.gz", hash = "sha256:ffdf89690d734f6851ef1cb344222826ffb11ad2214ab9172668bf8aadd75d12"}, ] [package.dependencies] @@ -773,11 +850,11 @@ Werkzeug = "<3.1" [package.extras] celery = ["celery[redis] (>=5.1.2)", "redis (>=3.5.3)"] -ci = ["black (==22.3.0)", "dash-dangerously-set-inner-html", "dash-flow-example (==0.0.5)", "flake8 (==7.0.0)", "flaky (==3.8.1)", "flask-talisman (==1.0.0)", "jupyterlab (<4.0.0)", "mimesis (<=11.1.0)", "mock (==4.0.3)", "numpy (<=1.26.3)", "openpyxl", "orjson (==3.9.12)", "pandas (>=1.4.0)", "pyarrow", "pylint (==3.0.3)", "pytest-mock", "pytest-rerunfailures", "pytest-sugar (==0.9.6)", "pyzmq (==25.1.2)", "xlrd (>=2.0.1)"] +ci = ["black (==22.3.0)", "dash-dangerously-set-inner-html", "dash-flow-example (==0.0.5)", "flake8 (==7.0.0)", "flaky (==3.8.1)", "flask-talisman (==1.0.0)", "jupyterlab (<4.0.0)", "mimesis (<=11.1.0)", "mock (==4.0.3)", "numpy (<=1.26.3)", "openpyxl", "orjson (==3.10.3)", "pandas (>=1.4.0)", "pyarrow", "pylint (==3.0.3)", "pytest-mock", "pytest-rerunfailures", "pytest-sugar (==0.9.6)", "pyzmq (==25.1.2)", "xlrd (>=2.0.1)"] compress = ["flask-compress"] dev = ["PyYAML (>=5.4.1)", "coloredlogs (>=15.0.1)", "fire (>=0.4.0)"] diskcache = ["diskcache (>=5.2.1)", "multiprocess (>=0.70.12)", "psutil (>=5.8.0)"] -testing = ["beautifulsoup4 (>=4.8.2)", "cryptography (<3.4)", "dash-testing-stub (>=0.0.2)", "lxml (>=4.6.2)", "multiprocess (>=0.70.12)", "percy (>=2.0.2)", "psutil (>=5.8.0)", "pytest (>=6.0.2)", "requests[security] (>=2.21.0)", "selenium (>=3.141.0,<=4.2.0)", "waitress (>=1.4.4)"] +testing = ["beautifulsoup4 (>=4.8.2)", "cryptography", "dash-testing-stub (>=0.0.2)", "lxml (>=4.6.2)", "multiprocess (>=0.70.12)", "percy (>=2.0.2)", "psutil (>=5.8.0)", "pytest (>=6.0.2)", "requests[security] (>=2.21.0)", "selenium (>=3.141.0,<=4.2.0)", "waitress (>=1.4.4)"] [[package]] name = "dash-bootstrap-components" @@ -855,13 +932,13 @@ files = [ [[package]] name = "datadog-api-client" -version = "2.24.1" +version = "2.28.0" description = "Collection of all Datadog Public endpoints" optional = false python-versions = ">=3.7" files = [ - {file = "datadog_api_client-2.24.1-py3-none-any.whl", hash = "sha256:bf404b29798689d3362c1568a24602a489a2c6f10c778bbcd15411687c93c289"}, - {file = "datadog_api_client-2.24.1.tar.gz", hash = "sha256:63f4fe3c5876da73d5162678567b941a56f3f42fac1477307c478662a06e1ea3"}, + {file = "datadog_api_client-2.28.0-py3-none-any.whl", hash = "sha256:104b97574cd4704274aba54dcf4d9628561602d83f2bea29d7591bb6b3acc2a9"}, + {file = "datadog_api_client-2.28.0.tar.gz", hash = "sha256:5748dc0beeff9f8d408bd87d62deb0f4c3019e46202dbbcd1b57e47495ded53f"}, ] [package.dependencies] @@ -900,81 +977,92 @@ files = [ [[package]] name = "dependency-injector" -version = "4.41.0" +version = "4.42.0" description = "Dependency injection framework for Python" optional = false python-versions = "*" files = [ - {file = "dependency-injector-4.41.0.tar.gz", hash = "sha256:939dfc657104bc3e66b67afd3fb2ebb0850c9a1e73d0d26066f2bbdd8735ff9c"}, - {file = "dependency_injector-4.41.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a2381a251b04244125148298212550750e6e1403e9b2850cc62e0e829d050ad3"}, - {file = "dependency_injector-4.41.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:75280dfa23f7c88e1bf56c3920d58a43516816de6f6ab2a6650bb8a0f27d5c2c"}, - {file = "dependency_injector-4.41.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63bfba21f8bff654a80e9b9d06dd6c43a442990b73bf89cd471314c11c541ec2"}, - {file = "dependency_injector-4.41.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3535d06416251715b45f8412482b58ec1c6196a4a3baa207f947f0b03a7c4b44"}, - {file = "dependency_injector-4.41.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d09c08c944a25dabfb454238c1a889acd85102b93ae497de523bf9ab7947b28a"}, - {file = "dependency_injector-4.41.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:586a0821720b15932addbefb00f7370fbcd5831d6ebbd6494d774b44ff96d23a"}, - {file = "dependency_injector-4.41.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7fa4970f12a3fc95d8796938b11c41276ad1ff4c447b0e589212eab3fc527a90"}, - {file = "dependency_injector-4.41.0-cp310-cp310-win32.whl", hash = "sha256:d557e40673de984f78dab13ebd68d27fbb2f16d7c4e3b663ea2fa2f9fae6765b"}, - {file = "dependency_injector-4.41.0-cp310-cp310-win_amd64.whl", hash = "sha256:3744c327d18408e74781bd6d8b7738745ee80ef89f2c8daecf9ebd098cb84972"}, - {file = "dependency_injector-4.41.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:89c67edffe7007cf33cee79ecbca38f48efcc2add5c280717af434db6c789377"}, - {file = "dependency_injector-4.41.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:786f7aac592e191c9caafc47732161d807bad65c62f260cd84cd73c7e2d67d6d"}, - {file = "dependency_injector-4.41.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8b61a15bc46a3aa7b29bd8a7384b650aa3a7ef943491e93c49a0540a0b3dda4"}, - {file = "dependency_injector-4.41.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a4f113e5d4c3070973ad76e5bda7317e500abae6083d78689f0b6e37cf403abf"}, - {file = "dependency_injector-4.41.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5fa3ed8f0700e47a0e7363f949b4525ffa8277aa1c5b10ca5b41fce4dea61bb9"}, - {file = "dependency_injector-4.41.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:05e15ea0f2b14c1127e8b0d1597fef13f98845679f63bf670ba12dbfc12a16ef"}, - {file = "dependency_injector-4.41.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3055b3fc47a0d6e5f27defb4166c0d37543a4967c279549b154afaf506ce6efc"}, - {file = "dependency_injector-4.41.0-cp311-cp311-win32.whl", hash = "sha256:37d5954026e3831663518d78bdf4be9c2dbfea691edcb73c813aa3093aa4363a"}, - {file = "dependency_injector-4.41.0-cp311-cp311-win_amd64.whl", hash = "sha256:f89a507e389b7e4d4892dd9a6f5f4da25849e24f73275478634ac594d621ab3f"}, - {file = "dependency_injector-4.41.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:ac79f3c05747f9724bd56c06985e78331fc6c85eb50f3e3f1a35e0c60f9977e9"}, - {file = "dependency_injector-4.41.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:75e7a733b372db3144a34020c4233f6b94db2c6342d6d16bc5245b1b941ee2bd"}, - {file = "dependency_injector-4.41.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40936d9384363331910abd59dd244158ec3572abf9d37322f15095315ac99893"}, - {file = "dependency_injector-4.41.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a31d9d60be4b585585081109480cfb2ef564d3b851cb32a139bf8408411a93a"}, - {file = "dependency_injector-4.41.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:953bfac819d32dc72b963767589e0ed372e5e9e78b03fb6b89419d0500d34bbe"}, - {file = "dependency_injector-4.41.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:8f0090ff14038f17a026ca408a3a0b0e7affb6aa7498b2b59d670f40ac970fbe"}, - {file = "dependency_injector-4.41.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:6b29abac56ce347d2eb58a560723e1663ee2125cf5cc38866ed92b84319927ec"}, - {file = "dependency_injector-4.41.0-cp36-cp36m-win32.whl", hash = "sha256:059fbb48333148143e8667a5323d162628dfe27c386bd0ed3deeecfc390338bf"}, - {file = "dependency_injector-4.41.0-cp36-cp36m-win_amd64.whl", hash = "sha256:16de2797dcfcc2263b8672bf0751166f7c7b369ca2ff9246ceb67b65f8e1d802"}, - {file = "dependency_injector-4.41.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c71d30b6708438050675f338edb9a25bea6c258478dbe5ec8405286756a2d347"}, - {file = "dependency_injector-4.41.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d283aee588a72072439e6721cb64aa6cba5bc18c576ef0ab28285a6ec7a9d655"}, - {file = "dependency_injector-4.41.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc852da612c7e347f2fcf921df2eca2718697a49f648a28a63db3ab504fd9510"}, - {file = "dependency_injector-4.41.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:02620454ee8101f77a317f3229935ce687480883d72a40858ff4b0c87c935cce"}, - {file = "dependency_injector-4.41.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7a92680bea1c260e5c0d2d6cd60b0c913cba76a456a147db5ac047ecfcfcc758"}, - {file = "dependency_injector-4.41.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:168334cba3f1cbf55299ef38f0f2e31879115cc767b780c859f7814a52d80abb"}, - {file = "dependency_injector-4.41.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:48b6886a87b4ceb9b9f78550f77b2a5c7d2ce33bc83efd886556ad468cc9c85a"}, - {file = "dependency_injector-4.41.0-cp37-cp37m-win32.whl", hash = "sha256:87be84084a1b922c4ba15e2e5aa900ee24b78a5467997cb7aec0a1d6cdb4a00b"}, - {file = "dependency_injector-4.41.0-cp37-cp37m-win_amd64.whl", hash = "sha256:8b8cf1c6c56f5c18bdbd9f5e93b52ca29cb4d99606d4056e91f0c761eef496dc"}, - {file = "dependency_injector-4.41.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a8686fa330c83251c75c8238697686f7a0e0f6d40658538089165dc72df9bcff"}, - {file = "dependency_injector-4.41.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8d670a844268dcd758195e58e9a5b39fc74bb8648aba99a13135a4a10ec9cfac"}, - {file = "dependency_injector-4.41.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e3b9d41e0eff4c8e16fea1e33de66ff0030fe51137ca530f3c52ce110447914"}, - {file = "dependency_injector-4.41.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:33a724e0a737baadb4378f5dc1b079867cc3a88552fcca719b3dba84716828b2"}, - {file = "dependency_injector-4.41.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:3588bd887b051d16b8bcabaae1127eb14059a0719a8fe34c8a75ba59321b352c"}, - {file = "dependency_injector-4.41.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:409441122f40e1b4b8582845fdd76deb9dc5c9d6eb74a057b85736ef9e9c671f"}, - {file = "dependency_injector-4.41.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:7dcba8665cafec825b7095d5dd80afb5cf14404450eca3fe8b66e1edbf4dbc10"}, - {file = "dependency_injector-4.41.0-cp38-cp38-win32.whl", hash = "sha256:8b51efeaebacaf79ef68edfc65e9687699ccffb3538c4a3ab30d0d77e2db7189"}, - {file = "dependency_injector-4.41.0-cp38-cp38-win_amd64.whl", hash = "sha256:1662e2ef60ac6e681b9e11b5d8b7c17a0f733688916cf695f9540f8f50a61b1e"}, - {file = "dependency_injector-4.41.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:51217cb384b468d7cc355544cec20774859f00812f9a1a71ed7fa701c957b2a7"}, - {file = "dependency_injector-4.41.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b3890a12423ae3a9eade035093beba487f8d092ee6c6cb8706f4e7080a56e819"}, - {file = "dependency_injector-4.41.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99ed73b1521bf249e2823a08a730c9f9413a58f4b4290da022e0ad4fb333ba3d"}, - {file = "dependency_injector-4.41.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:300838e9d4f3fbf539892a5a4072851728e23b37a1f467afcf393edd994d88f0"}, - {file = "dependency_injector-4.41.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:56d37b9d2f50a18f059d9abdbea7669a7518bd42b81603c21a27910a2b3f1657"}, - {file = "dependency_injector-4.41.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:4a44ca3ce5867513a70b31855b218be3d251f5068ce1c480cc3a4ad24ffd3280"}, - {file = "dependency_injector-4.41.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:67b369592c57549ccdcad0d5fef1ddb9d39af7fed8083d76e789ab0111fc6389"}, - {file = "dependency_injector-4.41.0-cp39-cp39-win32.whl", hash = "sha256:740a8e8106a04d3f44b52b25b80570fdac96a8a3934423de7c9202c5623e7936"}, - {file = "dependency_injector-4.41.0-cp39-cp39-win_amd64.whl", hash = "sha256:22b11dbf696e184f0b3d5ac4e5418aeac3c379ba4ea758c04a83869b7e5d1cbf"}, - {file = "dependency_injector-4.41.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:b365a8548e9a49049fa6acb24d3cd939f619eeb8e300ca3e156e44402dcc07ec"}, - {file = "dependency_injector-4.41.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5168dc59808317dc4cdd235aa5d7d556d33e5600156acaf224cead236b48a3e8"}, - {file = "dependency_injector-4.41.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e3229d83e99e255451605d5276604386e06ad948e3d60f31ddd796781c77f76f"}, - {file = "dependency_injector-4.41.0-pp37-pypy37_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1baee908f21190bdc46a65ce4c417a5175e9397ca62354928694fce218f84487"}, - {file = "dependency_injector-4.41.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:b37f36ecb0c1227f697e1d4a029644e3eda8dd0f0716aa63ad04d96dbb15bbbb"}, - {file = "dependency_injector-4.41.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:b0c9c966ff66c77364a2d43d08de9968aff7e3903938fe912ba49796b2133344"}, - {file = "dependency_injector-4.41.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:12e91ac0333e7e589421943ff6c6bf9cf0d9ac9703301cec37ccff3723406332"}, - {file = "dependency_injector-4.41.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2440b32474d4e747209528ca3ae48f42563b2fbe3d74dbfe949c11dfbfef7c4"}, - {file = "dependency_injector-4.41.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54032d62610cf2f4421c9d92cef52957215aaa0bca403cda580c58eb3f726eda"}, - {file = "dependency_injector-4.41.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:76b94c8310929e54136f3cb3de3adc86d1a657b3984299f40bf1cd2ba0bae548"}, - {file = "dependency_injector-4.41.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:6ee9810841c6e0599356cb884d16453bfca6ab739d0e4f0248724ed8f9ee0d79"}, - {file = "dependency_injector-4.41.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b98945edae88e777091bf0848f869fb94bd76dfa4066d7c870a5caa933391d0"}, - {file = "dependency_injector-4.41.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a2dee5d4abdd21f1a30a51d46645c095be9dcc404c7c6e9f81d0a01415a49e64"}, - {file = "dependency_injector-4.41.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d03f5fa0fa98a18bd0dfce846db80e2798607f0b861f1f99c97f441f7669d7a2"}, - {file = "dependency_injector-4.41.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:f2842e15bae664a9f69932e922b02afa055c91efec959cb1896f6c499bf68180"}, + {file = "dependency_injector-4.42.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0bb90f064970366acddc6e946626dd9b59505dc0f798459fe31fce458a8d0fc5"}, + {file = "dependency_injector-4.42.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf96588c58790768c9ebb2f61532dc847236bdf7317b07cfdf75a14d63c3114e"}, + {file = "dependency_injector-4.42.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54b3ef487584bf2f9945b3f2f97e0ada8933e773960e0a3c4b40d369e37003fb"}, + {file = "dependency_injector-4.42.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a0625b993dc3c58c35b613d9ccdf0eb8420f978f62d19d71820ea7630326972d"}, + {file = "dependency_injector-4.42.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4a4eb3356e26273f8065266fab4fd51c863afafe10e586d3bfc67340677e2674"}, + {file = "dependency_injector-4.42.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dffba9e2864b5d002f5b3bd89df4cde4f20dec4c2cd073ce0bd460229ed0afdb"}, + {file = "dependency_injector-4.42.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:19b50b48030dfa7cd3488253cbe7ee69c9b737275ac1aa184d9e995f44bb8317"}, + {file = "dependency_injector-4.42.0-cp310-cp310-win32.whl", hash = "sha256:68af4878040573a710202e171ecc1cec2c47910783f59d14c299f68439f8fe0b"}, + {file = "dependency_injector-4.42.0-cp310-cp310-win_amd64.whl", hash = "sha256:8eb65b102b36d171dfdf6c9b06766797d97d535b83a61859d1d91092b960c05a"}, + {file = "dependency_injector-4.42.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:952565b29186ce59f6972eb4cd37a927b3f3b61a2715345f0d6f4a7c01305ebb"}, + {file = "dependency_injector-4.42.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae4593738906f8b2ec3e61fda30e6b7dc24f34b83dad5d4ac0d8a07c4be6c3e8"}, + {file = "dependency_injector-4.42.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffddebe6d22394b0e8b3a41ef8d140d2bd829cbcc39fc48e5f560fe3db8ac3f5"}, + {file = "dependency_injector-4.42.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8271ffd0c95c598c9340b8f4c21478a7029c4dcba85d377fcbedf708f3f1564a"}, + {file = "dependency_injector-4.42.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8796683cce845204ebe6594b617ce2407742534fce4635db5c30e8dcf4a0e2f0"}, + {file = "dependency_injector-4.42.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8fc9aedb66a26b6fc0cd6065e52c45e9197cec6ab0b32b9e565421ad2be66a88"}, + {file = "dependency_injector-4.42.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:36f78f7e3fe5c95f11757928d7b93c0d4a5fd38be45172fa1a9eb1653d3261de"}, + {file = "dependency_injector-4.42.0-cp311-cp311-win32.whl", hash = "sha256:9eb1dcb897c00b853e3843ba15947cc2b25b6af947077ea65d7d5bef84d0d0d8"}, + {file = "dependency_injector-4.42.0-cp311-cp311-win_amd64.whl", hash = "sha256:cd794587a8b71cda35231b3351977765ffd3f09dd8b8be1f981726c76b44742f"}, + {file = "dependency_injector-4.42.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f283c0c67cd71723744b6016f6f55b6e2ee790059816b0cc1d6792ec236e62e9"}, + {file = "dependency_injector-4.42.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1e9016f864fb8f58a53a7ce13ddccb3b44d5333b205101301d42168dfbada5e"}, + {file = "dependency_injector-4.42.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c5a39274cd130f9adc6beb7b9488c7a2faf55f9d894124908f1209d9c84c3b7"}, + {file = "dependency_injector-4.42.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3b478f65b20844ed3f9fda5edb1f09e34575e006c439c387283fd833053e3bd1"}, + {file = "dependency_injector-4.42.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:524654f11c839b2e8ea0b217f49f762182daf244a5ecdf7339b664d9d77be7f1"}, + {file = "dependency_injector-4.42.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:386bc36d337c17e149a11f89d33e6383b9d05cff18c68d8e95a50f3483b03ff1"}, + {file = "dependency_injector-4.42.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c2d632b9ff85cc9158c4f815109faedbd4c384bab839aefc288c3249024a2a66"}, + {file = "dependency_injector-4.42.0-cp312-cp312-win32.whl", hash = "sha256:ecfca509e0108fbb85c2af3ebaa8eaa4a6dcacafc93d0ad8e0ca46b74c8d0df7"}, + {file = "dependency_injector-4.42.0-cp312-cp312-win_amd64.whl", hash = "sha256:34d506b31b150ed2f8191ec0b7f9f7e67f8d8ba90414d23c14c4e3515ac9d0c2"}, + {file = "dependency_injector-4.42.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bda68a7f6eef700c493de94daf532bd021aa65458209c11f8db6b0012aa1b32f"}, + {file = "dependency_injector-4.42.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:578707e06c45b46a8db7eb5ebcd7a566bd0602197322184cf4a4e8c23a513ce4"}, + {file = "dependency_injector-4.42.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:89fd5f7937977b2deb8454bf4c7f3ffa9c630d4e893d99b1ceac9ebb075a5527"}, + {file = "dependency_injector-4.42.0-cp36-cp36m-musllinux_1_2_aarch64.whl", hash = "sha256:5997868c51898951abd1e606dfd993ed87df49beafa04652dfc6482e64f79771"}, + {file = "dependency_injector-4.42.0-cp36-cp36m-musllinux_1_2_i686.whl", hash = "sha256:07d262d8438d79bc4d4fe500d6bbffaf24c7b3b5f2c87973de6dba7b33851f20"}, + {file = "dependency_injector-4.42.0-cp36-cp36m-musllinux_1_2_x86_64.whl", hash = "sha256:ac755e5aaf268edc00590bd4c8b6618f6e5dfdedbc417dd532ea8d61f6d372b3"}, + {file = "dependency_injector-4.42.0-cp36-cp36m-win32.whl", hash = "sha256:d2ff45f5ddcab3c833e685c8851f03b7bb7360911db39f1960bd8a8f7ef7e515"}, + {file = "dependency_injector-4.42.0-cp36-cp36m-win_amd64.whl", hash = "sha256:656d89135118b31ac8e49c4fae09ae31119f50a61ba6af0da121aea774210d70"}, + {file = "dependency_injector-4.42.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8797cfe97bd8cb3672286a9c759244032b46c25e4360d91f710b348c2d0605bc"}, + {file = "dependency_injector-4.42.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e071f40a9d911b16555171a5030e27c6c3b379d984fff2b4a78a10183108557"}, + {file = "dependency_injector-4.42.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6204e5da66e92e51df6df363dce98ad994c969631535909014df3e4e5c8a3b23"}, + {file = "dependency_injector-4.42.0-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:86814cba9a39658b3632b40ae93e5dc44a7de7214b9f23bf3311a216bdf59526"}, + {file = "dependency_injector-4.42.0-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:d7c26d3de4fb98594c23bc8813933ede4f624544ab7f5b4f13d75a672ed3f276"}, + {file = "dependency_injector-4.42.0-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:82cfa80b6c57463314e18aa3d01fba62131aa98f15bad55f185eef7e101a6f34"}, + {file = "dependency_injector-4.42.0-cp37-cp37m-win32.whl", hash = "sha256:690d3c0cafc2e7ada536255f093fe05aff8bac6d5b46c9ebe144ff004c509498"}, + {file = "dependency_injector-4.42.0-cp37-cp37m-win_amd64.whl", hash = "sha256:14b6e91997691b26b62b39dfd50b6246765274ce2768a9bb491bcd77b994700b"}, + {file = "dependency_injector-4.42.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5437faac11595c0d50275d520554dc85d9e9909d9d1c7eb8c56cf28b91869f1a"}, + {file = "dependency_injector-4.42.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:611cb623399aac15e356a68ad5d8ee9e01c02b47f19b81c061f510c6e624bed7"}, + {file = "dependency_injector-4.42.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8507e2c7c769ff6b74d5cbca58cc6d08c34d09c5972c890b2514fb653c930e8"}, + {file = "dependency_injector-4.42.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:51cccaf884d62953a688da483494b113e670598c4591e99701638db0baa8a5fe"}, + {file = "dependency_injector-4.42.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:96e10090424415d6762da4945ec06b3391ce03a7da43e01a64b09e44cd25563e"}, + {file = "dependency_injector-4.42.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:39c21064fc042a809dfc5f93cd149ecb893be9eaf8f839d147ea2d1d19507b19"}, + {file = "dependency_injector-4.42.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:9eebc5775de27eb33b994aa864f81061b39007b4370fbde3525749acf5fc2d68"}, + {file = "dependency_injector-4.42.0-cp38-cp38-win32.whl", hash = "sha256:1e65c16fe88ec4bdb80dff01874bc3447809f78942c7c77293d0ffdf15e2cddf"}, + {file = "dependency_injector-4.42.0-cp38-cp38-win_amd64.whl", hash = "sha256:8d198e25ecbfbef4c1c5f331d0630bfcb1252534dcf32600e0e72d0aab292213"}, + {file = "dependency_injector-4.42.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1b285f2399594bdb7770fe1e7d9dd3180cabfefcac93e64ed61cda0cf73be943"}, + {file = "dependency_injector-4.42.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6e52a74f4d06dcde0033e92f6a29fa5f91b4a81be5f99795315e5f945bdff8b"}, + {file = "dependency_injector-4.42.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28bb5b94adc35d997d1e34b829c03104ff3756024ded6da767198f7291c4e959"}, + {file = "dependency_injector-4.42.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f38c9ddfb9160aee62cbe424d7bf67099b7f21c7777cdbbad7c1106dc35f667f"}, + {file = "dependency_injector-4.42.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:a158bf48ebbd04ae97a69ffbf00e3a45c6f6879886b23583eeee655a544838a3"}, + {file = "dependency_injector-4.42.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:435bed281c68146e789970938ca6576ac999cd4e09f7f64ddc7674158bc62d42"}, + {file = "dependency_injector-4.42.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:43a70b098626eb2e72c77a819c31641de5e96b87573c37f459ec580035390868"}, + {file = "dependency_injector-4.42.0-cp39-cp39-win32.whl", hash = "sha256:6524d1403a589f3eebdf925aef95f350cf7b86f72e09c798ec0a1e6464435e1a"}, + {file = "dependency_injector-4.42.0-cp39-cp39-win_amd64.whl", hash = "sha256:932b0c6cccfb336cf7d0b8d8fce36f58983d543a3a4e81309d6190732160c3ad"}, + {file = "dependency_injector-4.42.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:e040496d6d22ed0bab2ab96a13734a22bd4f60b74b73a4a682688fc0e615841c"}, + {file = "dependency_injector-4.42.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2507d1de74314340479b57e31c103e0fcfa5135de03b07a774794cfb244f6098"}, + {file = "dependency_injector-4.42.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:67f52a45a00fd93e33b3d5c45181298ae2f09c56640e41524eec517ceccaf2fc"}, + {file = "dependency_injector-4.42.0-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b20c4d1be03eac0ab8e7ec91604f58a9fae705f6a4e228802c6302464cc1701"}, + {file = "dependency_injector-4.42.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0d11dcd7461747ae968e5e459eb5389652e6f49ab00eecfe05b19249f6d5aebd"}, + {file = "dependency_injector-4.42.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51f6fce317725cdc738ef45e5a56c28c51d15b060a346324ed8c547d9965035f"}, + {file = "dependency_injector-4.42.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f677d62b6de82a7e6c14db1f40831a80cd54324d20bb1c053f200860202b5ec1"}, + {file = "dependency_injector-4.42.0-pp37-pypy37_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45498d2bc1b801686f3123d753b47310876dab34642bcda283df774dcfd1a2de"}, + {file = "dependency_injector-4.42.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:f1b99e832919d784a7979bef3afa7ba10653c24e4ea55177578e87fb645bbf43"}, + {file = "dependency_injector-4.42.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a3fcdb443222b03770c6dbee0feb425e2d633099bde9ece758136cca4d73fc6"}, + {file = "dependency_injector-4.42.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0c1a121d37f9511604afbcbc8fc30c322fb3161e71178c240afaad521fa1916a"}, + {file = "dependency_injector-4.42.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d1464bc2c707a4657c31188bf8fda45b107cb67c324dde829b69db7f1d4a458f"}, + {file = "dependency_injector-4.42.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4d83f3a38be04d54c9abda8d95bf26ef6f4f913c54bcc0511e17c65d4a605954"}, + {file = "dependency_injector-4.42.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:c57016c155071b88d8f14c79e7c06557b5518ce4df2c57c7e7f214118b6cdeda"}, + {file = "dependency_injector-4.42.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b6ce807fec00c9ef93c318ce28f641f40a01e76df2d4505f2ba16b2dd3f8943"}, + {file = "dependency_injector-4.42.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ee595345d77a2375eaf3fb5c75d099c7593b6efd3088d7a44f5553241f66194"}, + {file = "dependency_injector-4.42.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:502c9dedda77f35154d0ff934d2368e90749aa03198a9356081b82b63c387fcd"}, + {file = "dependency_injector-4.42.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2048628b98c61ec96fe2c2022b175cd1f629516bae635f2e4a9bca33aa9fa85"}, + {file = "dependency_injector-4.42.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b29610964250ee1f532c079112e1a58e41f27670b02a5890433ed8ca1313a9ed"}, + {file = "dependency_injector-4.42.0.tar.gz", hash = "sha256:7057fc07b89aa09bc1c75e4190a8a6b86a3038d91a6d8302aea4f8094b184cd0"}, ] [package.dependencies] @@ -1038,13 +1126,13 @@ files = [ [[package]] name = "exceptiongroup" -version = "1.2.1" +version = "1.2.2" description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" files = [ - {file = "exceptiongroup-1.2.1-py3-none-any.whl", hash = "sha256:5258b9ed329c5bbdd31a309f53cbfb0b155341807f6ff7606a1e801a891b29ad"}, - {file = "exceptiongroup-1.2.1.tar.gz", hash = "sha256:a4785e48b045528f5bfe627b6ad554ff32def154f42372786903b7abcfe1aa16"}, + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, ] [package.extras] @@ -1052,13 +1140,13 @@ test = ["pytest (>=6)"] [[package]] name = "executing" -version = "2.0.1" +version = "2.1.0" description = "Get the currently executing AST node of a frame, and other information" optional = false -python-versions = ">=3.5" +python-versions = ">=3.8" files = [ - {file = "executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc"}, - {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"}, + {file = "executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf"}, + {file = "executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab"}, ] [package.extras] @@ -1081,13 +1169,13 @@ pyrepl = ">=0.8.2" [[package]] name = "fastjsonschema" -version = "2.19.1" +version = "2.20.0" description = "Fastest Python implementation of JSON schema" optional = false python-versions = "*" files = [ - {file = "fastjsonschema-2.19.1-py3-none-any.whl", hash = "sha256:3672b47bc94178c9f23dbb654bf47440155d4db9df5f7bc47643315f9c405cd0"}, - {file = "fastjsonschema-2.19.1.tar.gz", hash = "sha256:e3126a94bdc4623d3de4485f8d468a12f02a67921315ddc87836d6e456dc789d"}, + {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"}, + {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"}, ] [package.extras] @@ -1118,53 +1206,53 @@ dotenv = ["python-dotenv"] [[package]] name = "fonttools" -version = "4.51.0" +version = "4.53.1" description = "Tools to manipulate font files" optional = false python-versions = ">=3.8" files = [ - {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:84d7751f4468dd8cdd03ddada18b8b0857a5beec80bce9f435742abc9a851a74"}, - {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8b4850fa2ef2cfbc1d1f689bc159ef0f45d8d83298c1425838095bf53ef46308"}, - {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5b48a1121117047d82695d276c2af2ee3a24ffe0f502ed581acc2673ecf1037"}, - {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:180194c7fe60c989bb627d7ed5011f2bef1c4d36ecf3ec64daec8302f1ae0716"}, - {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:96a48e137c36be55e68845fc4284533bda2980f8d6f835e26bca79d7e2006438"}, - {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:806e7912c32a657fa39d2d6eb1d3012d35f841387c8fc6cf349ed70b7c340039"}, - {file = "fonttools-4.51.0-cp310-cp310-win32.whl", hash = "sha256:32b17504696f605e9e960647c5f64b35704782a502cc26a37b800b4d69ff3c77"}, - {file = "fonttools-4.51.0-cp310-cp310-win_amd64.whl", hash = "sha256:c7e91abdfae1b5c9e3a543f48ce96013f9a08c6c9668f1e6be0beabf0a569c1b"}, - {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a8feca65bab31479d795b0d16c9a9852902e3a3c0630678efb0b2b7941ea9c74"}, - {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ac27f436e8af7779f0bb4d5425aa3535270494d3bc5459ed27de3f03151e4c2"}, - {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e19bd9e9964a09cd2433a4b100ca7f34e34731e0758e13ba9a1ed6e5468cc0f"}, - {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2b92381f37b39ba2fc98c3a45a9d6383bfc9916a87d66ccb6553f7bdd129097"}, - {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5f6bc991d1610f5c3bbe997b0233cbc234b8e82fa99fc0b2932dc1ca5e5afec0"}, - {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9696fe9f3f0c32e9a321d5268208a7cc9205a52f99b89479d1b035ed54c923f1"}, - {file = "fonttools-4.51.0-cp311-cp311-win32.whl", hash = "sha256:3bee3f3bd9fa1d5ee616ccfd13b27ca605c2b4270e45715bd2883e9504735034"}, - {file = "fonttools-4.51.0-cp311-cp311-win_amd64.whl", hash = "sha256:0f08c901d3866a8905363619e3741c33f0a83a680d92a9f0e575985c2634fcc1"}, - {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4060acc2bfa2d8e98117828a238889f13b6f69d59f4f2d5857eece5277b829ba"}, - {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1250e818b5f8a679ad79660855528120a8f0288f8f30ec88b83db51515411fcc"}, - {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76f1777d8b3386479ffb4a282e74318e730014d86ce60f016908d9801af9ca2a"}, - {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b5ad456813d93b9c4b7ee55302208db2b45324315129d85275c01f5cb7e61a2"}, - {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:68b3fb7775a923be73e739f92f7e8a72725fd333eab24834041365d2278c3671"}, - {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8e2f1a4499e3b5ee82c19b5ee57f0294673125c65b0a1ff3764ea1f9db2f9ef5"}, - {file = "fonttools-4.51.0-cp312-cp312-win32.whl", hash = "sha256:278e50f6b003c6aed19bae2242b364e575bcb16304b53f2b64f6551b9c000e15"}, - {file = "fonttools-4.51.0-cp312-cp312-win_amd64.whl", hash = "sha256:b3c61423f22165541b9403ee39874dcae84cd57a9078b82e1dce8cb06b07fa2e"}, - {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:1621ee57da887c17312acc4b0e7ac30d3a4fb0fec6174b2e3754a74c26bbed1e"}, - {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e9d9298be7a05bb4801f558522adbe2feea1b0b103d5294ebf24a92dd49b78e5"}, - {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee1af4be1c5afe4c96ca23badd368d8dc75f611887fb0c0dac9f71ee5d6f110e"}, - {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c18b49adc721a7d0b8dfe7c3130c89b8704baf599fb396396d07d4aa69b824a1"}, - {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:de7c29bdbdd35811f14493ffd2534b88f0ce1b9065316433b22d63ca1cd21f14"}, - {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cadf4e12a608ef1d13e039864f484c8a968840afa0258b0b843a0556497ea9ed"}, - {file = "fonttools-4.51.0-cp38-cp38-win32.whl", hash = "sha256:aefa011207ed36cd280babfaa8510b8176f1a77261833e895a9d96e57e44802f"}, - {file = "fonttools-4.51.0-cp38-cp38-win_amd64.whl", hash = "sha256:865a58b6e60b0938874af0968cd0553bcd88e0b2cb6e588727117bd099eef836"}, - {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:60a3409c9112aec02d5fb546f557bca6efa773dcb32ac147c6baf5f742e6258b"}, - {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f7e89853d8bea103c8e3514b9f9dc86b5b4120afb4583b57eb10dfa5afbe0936"}, - {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56fc244f2585d6c00b9bcc59e6593e646cf095a96fe68d62cd4da53dd1287b55"}, - {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d145976194a5242fdd22df18a1b451481a88071feadf251221af110ca8f00ce"}, - {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c5b8cab0c137ca229433570151b5c1fc6af212680b58b15abd797dcdd9dd5051"}, - {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:54dcf21a2f2d06ded676e3c3f9f74b2bafded3a8ff12f0983160b13e9f2fb4a7"}, - {file = "fonttools-4.51.0-cp39-cp39-win32.whl", hash = "sha256:0118ef998a0699a96c7b28457f15546815015a2710a1b23a7bf6c1be60c01636"}, - {file = "fonttools-4.51.0-cp39-cp39-win_amd64.whl", hash = "sha256:599bdb75e220241cedc6faebfafedd7670335d2e29620d207dd0378a4e9ccc5a"}, - {file = "fonttools-4.51.0-py3-none-any.whl", hash = "sha256:15c94eeef6b095831067f72c825eb0e2d48bb4cea0647c1b05c981ecba2bf39f"}, - {file = "fonttools-4.51.0.tar.gz", hash = "sha256:dc0673361331566d7a663d7ce0f6fdcbfbdc1f59c6e3ed1165ad7202ca183c68"}, + {file = "fonttools-4.53.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0679a30b59d74b6242909945429dbddb08496935b82f91ea9bf6ad240ec23397"}, + {file = "fonttools-4.53.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e8bf06b94694251861ba7fdeea15c8ec0967f84c3d4143ae9daf42bbc7717fe3"}, + {file = "fonttools-4.53.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b96cd370a61f4d083c9c0053bf634279b094308d52fdc2dd9a22d8372fdd590d"}, + {file = "fonttools-4.53.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1c7c5aa18dd3b17995898b4a9b5929d69ef6ae2af5b96d585ff4005033d82f0"}, + {file = "fonttools-4.53.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e013aae589c1c12505da64a7d8d023e584987e51e62006e1bb30d72f26522c41"}, + {file = "fonttools-4.53.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9efd176f874cb6402e607e4cc9b4a9cd584d82fc34a4b0c811970b32ba62501f"}, + {file = "fonttools-4.53.1-cp310-cp310-win32.whl", hash = "sha256:c8696544c964500aa9439efb6761947393b70b17ef4e82d73277413f291260a4"}, + {file = "fonttools-4.53.1-cp310-cp310-win_amd64.whl", hash = "sha256:8959a59de5af6d2bec27489e98ef25a397cfa1774b375d5787509c06659b3671"}, + {file = "fonttools-4.53.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:da33440b1413bad53a8674393c5d29ce64d8c1a15ef8a77c642ffd900d07bfe1"}, + {file = "fonttools-4.53.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ff7e5e9bad94e3a70c5cd2fa27f20b9bb9385e10cddab567b85ce5d306ea923"}, + {file = "fonttools-4.53.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c6e7170d675d12eac12ad1a981d90f118c06cf680b42a2d74c6c931e54b50719"}, + {file = "fonttools-4.53.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bee32ea8765e859670c4447b0817514ca79054463b6b79784b08a8df3a4d78e3"}, + {file = "fonttools-4.53.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6e08f572625a1ee682115223eabebc4c6a2035a6917eac6f60350aba297ccadb"}, + {file = "fonttools-4.53.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b21952c092ffd827504de7e66b62aba26fdb5f9d1e435c52477e6486e9d128b2"}, + {file = "fonttools-4.53.1-cp311-cp311-win32.whl", hash = "sha256:9dfdae43b7996af46ff9da520998a32b105c7f098aeea06b2226b30e74fbba88"}, + {file = "fonttools-4.53.1-cp311-cp311-win_amd64.whl", hash = "sha256:d4d0096cb1ac7a77b3b41cd78c9b6bc4a400550e21dc7a92f2b5ab53ed74eb02"}, + {file = "fonttools-4.53.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d92d3c2a1b39631a6131c2fa25b5406855f97969b068e7e08413325bc0afba58"}, + {file = "fonttools-4.53.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3b3c8ebafbee8d9002bd8f1195d09ed2bd9ff134ddec37ee8f6a6375e6a4f0e8"}, + {file = "fonttools-4.53.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32f029c095ad66c425b0ee85553d0dc326d45d7059dbc227330fc29b43e8ba60"}, + {file = "fonttools-4.53.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10f5e6c3510b79ea27bb1ebfcc67048cde9ec67afa87c7dd7efa5c700491ac7f"}, + {file = "fonttools-4.53.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f677ce218976496a587ab17140da141557beb91d2a5c1a14212c994093f2eae2"}, + {file = "fonttools-4.53.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9e6ceba2a01b448e36754983d376064730690401da1dd104ddb543519470a15f"}, + {file = "fonttools-4.53.1-cp312-cp312-win32.whl", hash = "sha256:791b31ebbc05197d7aa096bbc7bd76d591f05905d2fd908bf103af4488e60670"}, + {file = "fonttools-4.53.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ed170b5e17da0264b9f6fae86073be3db15fa1bd74061c8331022bca6d09bab"}, + {file = "fonttools-4.53.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:c818c058404eb2bba05e728d38049438afd649e3c409796723dfc17cd3f08749"}, + {file = "fonttools-4.53.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:651390c3b26b0c7d1f4407cad281ee7a5a85a31a110cbac5269de72a51551ba2"}, + {file = "fonttools-4.53.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e54f1bba2f655924c1138bbc7fa91abd61f45c68bd65ab5ed985942712864bbb"}, + {file = "fonttools-4.53.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9cd19cf4fe0595ebdd1d4915882b9440c3a6d30b008f3cc7587c1da7b95be5f"}, + {file = "fonttools-4.53.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:2af40ae9cdcb204fc1d8f26b190aa16534fcd4f0df756268df674a270eab575d"}, + {file = "fonttools-4.53.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:35250099b0cfb32d799fb5d6c651220a642fe2e3c7d2560490e6f1d3f9ae9169"}, + {file = "fonttools-4.53.1-cp38-cp38-win32.whl", hash = "sha256:f08df60fbd8d289152079a65da4e66a447efc1d5d5a4d3f299cdd39e3b2e4a7d"}, + {file = "fonttools-4.53.1-cp38-cp38-win_amd64.whl", hash = "sha256:7b6b35e52ddc8fb0db562133894e6ef5b4e54e1283dff606fda3eed938c36fc8"}, + {file = "fonttools-4.53.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:75a157d8d26c06e64ace9df037ee93a4938a4606a38cb7ffaf6635e60e253b7a"}, + {file = "fonttools-4.53.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4824c198f714ab5559c5be10fd1adf876712aa7989882a4ec887bf1ef3e00e31"}, + {file = "fonttools-4.53.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:becc5d7cb89c7b7afa8321b6bb3dbee0eec2b57855c90b3e9bf5fb816671fa7c"}, + {file = "fonttools-4.53.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84ec3fb43befb54be490147b4a922b5314e16372a643004f182babee9f9c3407"}, + {file = "fonttools-4.53.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:73379d3ffdeecb376640cd8ed03e9d2d0e568c9d1a4e9b16504a834ebadc2dfb"}, + {file = "fonttools-4.53.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:02569e9a810f9d11f4ae82c391ebc6fb5730d95a0657d24d754ed7763fb2d122"}, + {file = "fonttools-4.53.1-cp39-cp39-win32.whl", hash = "sha256:aae7bd54187e8bf7fd69f8ab87b2885253d3575163ad4d669a262fe97f0136cb"}, + {file = "fonttools-4.53.1-cp39-cp39-win_amd64.whl", hash = "sha256:e5b708073ea3d684235648786f5f6153a48dc8762cdfe5563c57e80787c29fbb"}, + {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"}, + {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"}, ] [package.extras] @@ -1198,33 +1286,22 @@ pygments = ">=2.7" sphinx = ">=6.0,<8.0" sphinx-basic-ng = "*" -[[package]] -name = "future" -version = "1.0.0" -description = "Clean single-source support for Python 3 and 2" -optional = false -python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" -files = [ - {file = "future-1.0.0-py3-none-any.whl", hash = "sha256:929292d34f5872e70396626ef385ec22355a1fae8ad29e1a734c3e43f9fbc216"}, - {file = "future-1.0.0.tar.gz", hash = "sha256:bd2968309307861edae1458a4f8a4f3598c03be43b97521076aebf5d94c07b05"}, -] - [[package]] name = "google-api-core" -version = "2.19.0" +version = "2.20.0" description = "Google API client core library" optional = false python-versions = ">=3.7" files = [ - {file = "google-api-core-2.19.0.tar.gz", hash = "sha256:cf1b7c2694047886d2af1128a03ae99e391108a08804f87cfd35970e49c9cd10"}, - {file = "google_api_core-2.19.0-py3-none-any.whl", hash = "sha256:8661eec4078c35428fd3f69a2c7ee29e342896b70f01d1a1cbcb334372dd6251"}, + {file = "google_api_core-2.20.0-py3-none-any.whl", hash = "sha256:ef0591ef03c30bb83f79b3d0575c3f31219001fc9c5cf37024d08310aeffed8a"}, + {file = "google_api_core-2.20.0.tar.gz", hash = "sha256:f74dff1889ba291a4b76c5079df0711810e2d9da81abfdc99957bc961c1eb28f"}, ] [package.dependencies] google-auth = ">=2.14.1,<3.0.dev0" googleapis-common-protos = ">=1.56.2,<2.0.dev0" proto-plus = ">=1.22.3,<2.0.0dev" -protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<5.0.0.dev0" +protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.0 || >4.21.0,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<6.0.0.dev0" requests = ">=2.18.0,<3.0.0.dev0" [package.extras] @@ -1234,13 +1311,13 @@ grpcio-gcp = ["grpcio-gcp (>=0.2.2,<1.0.dev0)"] [[package]] name = "google-auth" -version = "2.29.0" +version = "2.35.0" description = "Google Authentication Library" optional = false python-versions = ">=3.7" files = [ - {file = "google-auth-2.29.0.tar.gz", hash = "sha256:672dff332d073227550ffc7457868ac4218d6c500b155fe6cc17d2b13602c360"}, - {file = "google_auth-2.29.0-py2.py3-none-any.whl", hash = "sha256:d452ad095688cd52bae0ad6fafe027f6a6d6f560e810fec20914e17a09526415"}, + {file = "google_auth-2.35.0-py2.py3-none-any.whl", hash = "sha256:25df55f327ef021de8be50bad0dfd4a916ad0de96da86cd05661c9297723ad3f"}, + {file = "google_auth-2.35.0.tar.gz", hash = "sha256:f4c64ed4e01e8e8b646ef34c018f8bf3338df0c8e37d8b3bba40e7f574a3278a"}, ] [package.dependencies] @@ -1250,85 +1327,164 @@ rsa = ">=3.1.4,<5" [package.extras] aiohttp = ["aiohttp (>=3.6.2,<4.0.0.dev0)", "requests (>=2.20.0,<3.0.0.dev0)"] -enterprise-cert = ["cryptography (==36.0.2)", "pyopenssl (==22.0.0)"] +enterprise-cert = ["cryptography", "pyopenssl"] pyopenssl = ["cryptography (>=38.0.3)", "pyopenssl (>=20.0.0)"] reauth = ["pyu2f (>=0.1.5)"] requests = ["requests (>=2.20.0,<3.0.0.dev0)"] [[package]] name = "googleapis-common-protos" -version = "1.63.0" +version = "1.65.0" description = "Common protobufs used in Google APIs" optional = false python-versions = ">=3.7" files = [ - {file = "googleapis-common-protos-1.63.0.tar.gz", hash = "sha256:17ad01b11d5f1d0171c06d3ba5c04c54474e883b66b949722b4938ee2694ef4e"}, - {file = "googleapis_common_protos-1.63.0-py2.py3-none-any.whl", hash = "sha256:ae45f75702f7c08b541f750854a678bd8f534a1a6bace6afe975f1d0a82d6632"}, + {file = "googleapis_common_protos-1.65.0-py2.py3-none-any.whl", hash = "sha256:2972e6c496f435b92590fd54045060867f3fe9be2c82ab148fc8885035479a63"}, + {file = "googleapis_common_protos-1.65.0.tar.gz", hash = "sha256:334a29d07cddc3aa01dee4988f9afd9b2916ee2ff49d6b757155dc0d197852c0"}, ] [package.dependencies] -protobuf = ">=3.19.5,<3.20.0 || >3.20.0,<3.20.1 || >3.20.1,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<5.0.0.dev0" +protobuf = ">=3.20.2,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<6.0.0.dev0" [package.extras] grpc = ["grpcio (>=1.44.0,<2.0.0.dev0)"] +[[package]] +name = "greenlet" +version = "3.1.0" +description = "Lightweight in-process concurrent programming" +optional = false +python-versions = ">=3.7" +files = [ + {file = "greenlet-3.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a814dc3100e8a046ff48faeaa909e80cdb358411a3d6dd5293158425c684eda8"}, + {file = "greenlet-3.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a771dc64fa44ebe58d65768d869fcfb9060169d203446c1d446e844b62bdfdca"}, + {file = "greenlet-3.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0e49a65d25d7350cca2da15aac31b6f67a43d867448babf997fe83c7505f57bc"}, + {file = "greenlet-3.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2cd8518eade968bc52262d8c46727cfc0826ff4d552cf0430b8d65aaf50bb91d"}, + {file = "greenlet-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76dc19e660baea5c38e949455c1181bc018893f25372d10ffe24b3ed7341fb25"}, + {file = "greenlet-3.1.0-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c0a5b1c22c82831f56f2f7ad9bbe4948879762fe0d59833a4a71f16e5fa0f682"}, + {file = "greenlet-3.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:2651dfb006f391bcb240635079a68a261b227a10a08af6349cba834a2141efa1"}, + {file = "greenlet-3.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:3e7e6ef1737a819819b1163116ad4b48d06cfdd40352d813bb14436024fcda99"}, + {file = "greenlet-3.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:ffb08f2a1e59d38c7b8b9ac8083c9c8b9875f0955b1e9b9b9a965607a51f8e54"}, + {file = "greenlet-3.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9730929375021ec90f6447bff4f7f5508faef1c02f399a1953870cdb78e0c345"}, + {file = "greenlet-3.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:713d450cf8e61854de9420fb7eea8ad228df4e27e7d4ed465de98c955d2b3fa6"}, + {file = "greenlet-3.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c3446937be153718250fe421da548f973124189f18fe4575a0510b5c928f0cc"}, + {file = "greenlet-3.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1ddc7bcedeb47187be74208bc652d63d6b20cb24f4e596bd356092d8000da6d6"}, + {file = "greenlet-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:44151d7b81b9391ed759a2f2865bbe623ef00d648fed59363be2bbbd5154656f"}, + {file = "greenlet-3.1.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cea1cca3be76c9483282dc7760ea1cc08a6ecec1f0b6ca0a94ea0d17432da19"}, + {file = "greenlet-3.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:619935a44f414274a2c08c9e74611965650b730eb4efe4b2270f91df5e4adf9a"}, + {file = "greenlet-3.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:221169d31cada333a0c7fd087b957c8f431c1dba202c3a58cf5a3583ed973e9b"}, + {file = "greenlet-3.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:01059afb9b178606b4b6e92c3e710ea1635597c3537e44da69f4531e111dd5e9"}, + {file = "greenlet-3.1.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:24fc216ec7c8be9becba8b64a98a78f9cd057fd2dc75ae952ca94ed8a893bf27"}, + {file = "greenlet-3.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d07c28b85b350564bdff9f51c1c5007dfb2f389385d1bc23288de51134ca303"}, + {file = "greenlet-3.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:243a223c96a4246f8a30ea470c440fe9db1f5e444941ee3c3cd79df119b8eebf"}, + {file = "greenlet-3.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26811df4dc81271033a7836bc20d12cd30938e6bd2e9437f56fa03da81b0f8fc"}, + {file = "greenlet-3.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9d86401550b09a55410f32ceb5fe7efcd998bd2dad9e82521713cb148a4a15f"}, + {file = "greenlet-3.1.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26d9c1c4f1748ccac0bae1dbb465fb1a795a75aba8af8ca871503019f4285e2a"}, + {file = "greenlet-3.1.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:cd468ec62257bb4544989402b19d795d2305eccb06cde5da0eb739b63dc04665"}, + {file = "greenlet-3.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a53dfe8f82b715319e9953330fa5c8708b610d48b5c59f1316337302af5c0811"}, + {file = "greenlet-3.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:28fe80a3eb673b2d5cc3b12eea468a5e5f4603c26aa34d88bf61bba82ceb2f9b"}, + {file = "greenlet-3.1.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:76b3e3976d2a452cba7aa9e453498ac72240d43030fdc6d538a72b87eaff52fd"}, + {file = "greenlet-3.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:655b21ffd37a96b1e78cc48bf254f5ea4b5b85efaf9e9e2a526b3c9309d660ca"}, + {file = "greenlet-3.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c6f4c2027689093775fd58ca2388d58789009116844432d920e9147f91acbe64"}, + {file = "greenlet-3.1.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:76e5064fd8e94c3f74d9fd69b02d99e3cdb8fc286ed49a1f10b256e59d0d3a0b"}, + {file = "greenlet-3.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a4bf607f690f7987ab3291406e012cd8591a4f77aa54f29b890f9c331e84989"}, + {file = "greenlet-3.1.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:037d9ac99540ace9424cb9ea89f0accfaff4316f149520b4ae293eebc5bded17"}, + {file = "greenlet-3.1.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:90b5bbf05fe3d3ef697103850c2ce3374558f6fe40fd57c9fac1bf14903f50a5"}, + {file = "greenlet-3.1.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:726377bd60081172685c0ff46afbc600d064f01053190e4450857483c4d44484"}, + {file = "greenlet-3.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:d46d5069e2eeda111d6f71970e341f4bd9aeeee92074e649ae263b834286ecc0"}, + {file = "greenlet-3.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81eeec4403a7d7684b5812a8aaa626fa23b7d0848edb3a28d2eb3220daddcbd0"}, + {file = "greenlet-3.1.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a3dae7492d16e85ea6045fd11cb8e782b63eac8c8d520c3a92c02ac4573b0a6"}, + {file = "greenlet-3.1.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4b5ea3664eed571779403858d7cd0a9b0ebf50d57d2cdeafc7748e09ef8cd81a"}, + {file = "greenlet-3.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a22f4e26400f7f48faef2d69c20dc055a1f3043d330923f9abe08ea0aecc44df"}, + {file = "greenlet-3.1.0-cp37-cp37m-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13ff8c8e54a10472ce3b2a2da007f915175192f18e6495bad50486e87c7f6637"}, + {file = "greenlet-3.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:f9671e7282d8c6fcabc32c0fb8d7c0ea8894ae85cee89c9aadc2d7129e1a9954"}, + {file = "greenlet-3.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:184258372ae9e1e9bddce6f187967f2e08ecd16906557c4320e3ba88a93438c3"}, + {file = "greenlet-3.1.0-cp37-cp37m-win32.whl", hash = "sha256:a0409bc18a9f85321399c29baf93545152d74a49d92f2f55302f122007cfda00"}, + {file = "greenlet-3.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:9eb4a1d7399b9f3c7ac68ae6baa6be5f9195d1d08c9ddc45ad559aa6b556bce6"}, + {file = "greenlet-3.1.0-cp38-cp38-macosx_11_0_universal2.whl", hash = "sha256:a8870983af660798dc1b529e1fd6f1cefd94e45135a32e58bd70edd694540f33"}, + {file = "greenlet-3.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cfcfb73aed40f550a57ea904629bdaf2e562c68fa1164fa4588e752af6efdc3f"}, + {file = "greenlet-3.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f9482c2ed414781c0af0b35d9d575226da6b728bd1a720668fa05837184965b7"}, + {file = "greenlet-3.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d58ec349e0c2c0bc6669bf2cd4982d2f93bf067860d23a0ea1fe677b0f0b1e09"}, + {file = "greenlet-3.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd65695a8df1233309b701dec2539cc4b11e97d4fcc0f4185b4a12ce54db0491"}, + {file = "greenlet-3.1.0-cp38-cp38-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:665b21e95bc0fce5cab03b2e1d90ba9c66c510f1bb5fdc864f3a377d0f553f6b"}, + {file = "greenlet-3.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:d3c59a06c2c28a81a026ff11fbf012081ea34fb9b7052f2ed0366e14896f0a1d"}, + {file = "greenlet-3.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5415b9494ff6240b09af06b91a375731febe0090218e2898d2b85f9b92abcda0"}, + {file = "greenlet-3.1.0-cp38-cp38-win32.whl", hash = "sha256:1544b8dd090b494c55e60c4ff46e238be44fdc472d2589e943c241e0169bcea2"}, + {file = "greenlet-3.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:7f346d24d74c00b6730440f5eb8ec3fe5774ca8d1c9574e8e57c8671bb51b910"}, + {file = "greenlet-3.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:db1b3ccb93488328c74e97ff888604a8b95ae4f35f4f56677ca57a4fc3a4220b"}, + {file = "greenlet-3.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:44cd313629ded43bb3b98737bba2f3e2c2c8679b55ea29ed73daea6b755fe8e7"}, + {file = "greenlet-3.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fad7a051e07f64e297e6e8399b4d6a3bdcad3d7297409e9a06ef8cbccff4f501"}, + {file = "greenlet-3.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3967dcc1cd2ea61b08b0b276659242cbce5caca39e7cbc02408222fb9e6ff39"}, + {file = "greenlet-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d45b75b0f3fd8d99f62eb7908cfa6d727b7ed190737dec7fe46d993da550b81a"}, + {file = "greenlet-3.1.0-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2d004db911ed7b6218ec5c5bfe4cf70ae8aa2223dffbb5b3c69e342bb253cb28"}, + {file = "greenlet-3.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b9505a0c8579899057cbefd4ec34d865ab99852baf1ff33a9481eb3924e2da0b"}, + {file = "greenlet-3.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fd6e94593f6f9714dbad1aaba734b5ec04593374fa6638df61592055868f8b8"}, + {file = "greenlet-3.1.0-cp39-cp39-win32.whl", hash = "sha256:d0dd943282231480aad5f50f89bdf26690c995e8ff555f26d8a5b9887b559bcc"}, + {file = "greenlet-3.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:ac0adfdb3a21dc2a24ed728b61e72440d297d0fd3a577389df566651fcd08f97"}, + {file = "greenlet-3.1.0.tar.gz", hash = "sha256:b395121e9bbe8d02a750886f108d540abe66075e61e22f7353d9acb0b81be0f0"}, +] + +[package.extras] +docs = ["Sphinx", "furo"] +test = ["objgraph", "psutil"] + [[package]] name = "grpcio" -version = "1.63.0" +version = "1.66.1" description = "HTTP/2-based RPC framework" optional = false python-versions = ">=3.8" files = [ - {file = "grpcio-1.63.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:2e93aca840c29d4ab5db93f94ed0a0ca899e241f2e8aec6334ab3575dc46125c"}, - {file = "grpcio-1.63.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:91b73d3f1340fefa1e1716c8c1ec9930c676d6b10a3513ab6c26004cb02d8b3f"}, - {file = "grpcio-1.63.0-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:b3afbd9d6827fa6f475a4f91db55e441113f6d3eb9b7ebb8fb806e5bb6d6bd0d"}, - {file = "grpcio-1.63.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8f3f6883ce54a7a5f47db43289a0a4c776487912de1a0e2cc83fdaec9685cc9f"}, - {file = "grpcio-1.63.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf8dae9cc0412cb86c8de5a8f3be395c5119a370f3ce2e69c8b7d46bb9872c8d"}, - {file = "grpcio-1.63.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:08e1559fd3b3b4468486b26b0af64a3904a8dbc78d8d936af9c1cf9636eb3e8b"}, - {file = "grpcio-1.63.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:5c039ef01516039fa39da8a8a43a95b64e288f79f42a17e6c2904a02a319b357"}, - {file = "grpcio-1.63.0-cp310-cp310-win32.whl", hash = "sha256:ad2ac8903b2eae071055a927ef74121ed52d69468e91d9bcbd028bd0e554be6d"}, - {file = "grpcio-1.63.0-cp310-cp310-win_amd64.whl", hash = "sha256:b2e44f59316716532a993ca2966636df6fbe7be4ab6f099de6815570ebe4383a"}, - {file = "grpcio-1.63.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:f28f8b2db7b86c77916829d64ab21ff49a9d8289ea1564a2b2a3a8ed9ffcccd3"}, - {file = "grpcio-1.63.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:65bf975639a1f93bee63ca60d2e4951f1b543f498d581869922910a476ead2f5"}, - {file = "grpcio-1.63.0-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:b5194775fec7dc3dbd6a935102bb156cd2c35efe1685b0a46c67b927c74f0cfb"}, - {file = "grpcio-1.63.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e4cbb2100ee46d024c45920d16e888ee5d3cf47c66e316210bc236d5bebc42b3"}, - {file = "grpcio-1.63.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ff737cf29b5b801619f10e59b581869e32f400159e8b12d7a97e7e3bdeee6a2"}, - {file = "grpcio-1.63.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:cd1e68776262dd44dedd7381b1a0ad09d9930ffb405f737d64f505eb7f77d6c7"}, - {file = "grpcio-1.63.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:93f45f27f516548e23e4ec3fbab21b060416007dbe768a111fc4611464cc773f"}, - {file = "grpcio-1.63.0-cp311-cp311-win32.whl", hash = "sha256:878b1d88d0137df60e6b09b74cdb73db123f9579232c8456f53e9abc4f62eb3c"}, - {file = "grpcio-1.63.0-cp311-cp311-win_amd64.whl", hash = "sha256:756fed02dacd24e8f488f295a913f250b56b98fb793f41d5b2de6c44fb762434"}, - {file = "grpcio-1.63.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:93a46794cc96c3a674cdfb59ef9ce84d46185fe9421baf2268ccb556f8f81f57"}, - {file = "grpcio-1.63.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:a7b19dfc74d0be7032ca1eda0ed545e582ee46cd65c162f9e9fc6b26ef827dc6"}, - {file = "grpcio-1.63.0-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:8064d986d3a64ba21e498b9a376cbc5d6ab2e8ab0e288d39f266f0fca169b90d"}, - {file = "grpcio-1.63.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:219bb1848cd2c90348c79ed0a6b0ea51866bc7e72fa6e205e459fedab5770172"}, - {file = "grpcio-1.63.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2d60cd1d58817bc5985fae6168d8b5655c4981d448d0f5b6194bbcc038090d2"}, - {file = "grpcio-1.63.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:9e350cb096e5c67832e9b6e018cf8a0d2a53b2a958f6251615173165269a91b0"}, - {file = "grpcio-1.63.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:56cdf96ff82e3cc90dbe8bac260352993f23e8e256e063c327b6cf9c88daf7a9"}, - {file = "grpcio-1.63.0-cp312-cp312-win32.whl", hash = "sha256:3a6d1f9ea965e750db7b4ee6f9fdef5fdf135abe8a249e75d84b0a3e0c668a1b"}, - {file = "grpcio-1.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:d2497769895bb03efe3187fb1888fc20e98a5f18b3d14b606167dacda5789434"}, - {file = "grpcio-1.63.0-cp38-cp38-linux_armv7l.whl", hash = "sha256:fdf348ae69c6ff484402cfdb14e18c1b0054ac2420079d575c53a60b9b2853ae"}, - {file = "grpcio-1.63.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a3abfe0b0f6798dedd2e9e92e881d9acd0fdb62ae27dcbbfa7654a57e24060c0"}, - {file = "grpcio-1.63.0-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:6ef0ad92873672a2a3767cb827b64741c363ebaa27e7f21659e4e31f4d750280"}, - {file = "grpcio-1.63.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b416252ac5588d9dfb8a30a191451adbf534e9ce5f56bb02cd193f12d8845b7f"}, - {file = "grpcio-1.63.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e3b77eaefc74d7eb861d3ffbdf91b50a1bb1639514ebe764c47773b833fa2d91"}, - {file = "grpcio-1.63.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:b005292369d9c1f80bf70c1db1c17c6c342da7576f1c689e8eee4fb0c256af85"}, - {file = "grpcio-1.63.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cdcda1156dcc41e042d1e899ba1f5c2e9f3cd7625b3d6ebfa619806a4c1aadda"}, - {file = "grpcio-1.63.0-cp38-cp38-win32.whl", hash = "sha256:01799e8649f9e94ba7db1aeb3452188048b0019dc37696b0f5ce212c87c560c3"}, - {file = "grpcio-1.63.0-cp38-cp38-win_amd64.whl", hash = "sha256:6a1a3642d76f887aa4009d92f71eb37809abceb3b7b5a1eec9c554a246f20e3a"}, - {file = "grpcio-1.63.0-cp39-cp39-linux_armv7l.whl", hash = "sha256:75f701ff645858a2b16bc8c9fc68af215a8bb2d5a9b647448129de6e85d52bce"}, - {file = "grpcio-1.63.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:cacdef0348a08e475a721967f48206a2254a1b26ee7637638d9e081761a5ba86"}, - {file = "grpcio-1.63.0-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:0697563d1d84d6985e40ec5ec596ff41b52abb3fd91ec240e8cb44a63b895094"}, - {file = "grpcio-1.63.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6426e1fb92d006e47476d42b8f240c1d916a6d4423c5258ccc5b105e43438f61"}, - {file = "grpcio-1.63.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e48cee31bc5f5a31fb2f3b573764bd563aaa5472342860edcc7039525b53e46a"}, - {file = "grpcio-1.63.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:50344663068041b34a992c19c600236e7abb42d6ec32567916b87b4c8b8833b3"}, - {file = "grpcio-1.63.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:259e11932230d70ef24a21b9fb5bb947eb4703f57865a404054400ee92f42f5d"}, - {file = "grpcio-1.63.0-cp39-cp39-win32.whl", hash = "sha256:a44624aad77bf8ca198c55af811fd28f2b3eaf0a50ec5b57b06c034416ef2d0a"}, - {file = "grpcio-1.63.0-cp39-cp39-win_amd64.whl", hash = "sha256:166e5c460e5d7d4656ff9e63b13e1f6029b122104c1633d5f37eaea348d7356d"}, - {file = "grpcio-1.63.0.tar.gz", hash = "sha256:f3023e14805c61bc439fb40ca545ac3d5740ce66120a678a3c6c2c55b70343d1"}, -] - -[package.extras] -protobuf = ["grpcio-tools (>=1.63.0)"] + {file = "grpcio-1.66.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:4877ba180591acdf127afe21ec1c7ff8a5ecf0fe2600f0d3c50e8c4a1cbc6492"}, + {file = "grpcio-1.66.1-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:3750c5a00bd644c75f4507f77a804d0189d97a107eb1481945a0cf3af3e7a5ac"}, + {file = "grpcio-1.66.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:a013c5fbb12bfb5f927444b477a26f1080755a931d5d362e6a9a720ca7dbae60"}, + {file = "grpcio-1.66.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b1b24c23d51a1e8790b25514157d43f0a4dce1ac12b3f0b8e9f66a5e2c4c132f"}, + {file = "grpcio-1.66.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7ffb8ea674d68de4cac6f57d2498fef477cef582f1fa849e9f844863af50083"}, + {file = "grpcio-1.66.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:307b1d538140f19ccbd3aed7a93d8f71103c5d525f3c96f8616111614b14bf2a"}, + {file = "grpcio-1.66.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1c17ebcec157cfb8dd445890a03e20caf6209a5bd4ac5b040ae9dbc59eef091d"}, + {file = "grpcio-1.66.1-cp310-cp310-win32.whl", hash = "sha256:ef82d361ed5849d34cf09105d00b94b6728d289d6b9235513cb2fcc79f7c432c"}, + {file = "grpcio-1.66.1-cp310-cp310-win_amd64.whl", hash = "sha256:292a846b92cdcd40ecca46e694997dd6b9be6c4c01a94a0dfb3fcb75d20da858"}, + {file = "grpcio-1.66.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:c30aeceeaff11cd5ddbc348f37c58bcb96da8d5aa93fed78ab329de5f37a0d7a"}, + {file = "grpcio-1.66.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8a1e224ce6f740dbb6b24c58f885422deebd7eb724aff0671a847f8951857c26"}, + {file = "grpcio-1.66.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:a66fe4dc35d2330c185cfbb42959f57ad36f257e0cc4557d11d9f0a3f14311df"}, + {file = "grpcio-1.66.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e3ba04659e4fce609de2658fe4dbf7d6ed21987a94460f5f92df7579fd5d0e22"}, + {file = "grpcio-1.66.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4573608e23f7e091acfbe3e84ac2045680b69751d8d67685ffa193a4429fedb1"}, + {file = "grpcio-1.66.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:7e06aa1f764ec8265b19d8f00140b8c4b6ca179a6dc67aa9413867c47e1fb04e"}, + {file = "grpcio-1.66.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3885f037eb11f1cacc41f207b705f38a44b69478086f40608959bf5ad85826dd"}, + {file = "grpcio-1.66.1-cp311-cp311-win32.whl", hash = "sha256:97ae7edd3f3f91480e48ede5d3e7d431ad6005bfdbd65c1b56913799ec79e791"}, + {file = "grpcio-1.66.1-cp311-cp311-win_amd64.whl", hash = "sha256:cfd349de4158d797db2bd82d2020554a121674e98fbe6b15328456b3bf2495bb"}, + {file = "grpcio-1.66.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:a92c4f58c01c77205df6ff999faa008540475c39b835277fb8883b11cada127a"}, + {file = "grpcio-1.66.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:fdb14bad0835914f325349ed34a51940bc2ad965142eb3090081593c6e347be9"}, + {file = "grpcio-1.66.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:f03a5884c56256e08fd9e262e11b5cfacf1af96e2ce78dc095d2c41ccae2c80d"}, + {file = "grpcio-1.66.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2ca2559692d8e7e245d456877a85ee41525f3ed425aa97eb7a70fc9a79df91a0"}, + {file = "grpcio-1.66.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84ca1be089fb4446490dd1135828bd42a7c7f8421e74fa581611f7afdf7ab761"}, + {file = "grpcio-1.66.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:d639c939ad7c440c7b2819a28d559179a4508783f7e5b991166f8d7a34b52815"}, + {file = "grpcio-1.66.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b9feb4e5ec8dc2d15709f4d5fc367794d69277f5d680baf1910fc9915c633524"}, + {file = "grpcio-1.66.1-cp312-cp312-win32.whl", hash = "sha256:7101db1bd4cd9b880294dec41a93fcdce465bdbb602cd8dc5bd2d6362b618759"}, + {file = "grpcio-1.66.1-cp312-cp312-win_amd64.whl", hash = "sha256:b0aa03d240b5539648d996cc60438f128c7f46050989e35b25f5c18286c86734"}, + {file = "grpcio-1.66.1-cp38-cp38-linux_armv7l.whl", hash = "sha256:ecfe735e7a59e5a98208447293ff8580e9db1e890e232b8b292dc8bd15afc0d2"}, + {file = "grpcio-1.66.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:4825a3aa5648010842e1c9d35a082187746aa0cdbf1b7a2a930595a94fb10fce"}, + {file = "grpcio-1.66.1-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:f517fd7259fe823ef3bd21e508b653d5492e706e9f0ef82c16ce3347a8a5620c"}, + {file = "grpcio-1.66.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f1fe60d0772831d96d263b53d83fb9a3d050a94b0e94b6d004a5ad111faa5b5b"}, + {file = "grpcio-1.66.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31a049daa428f928f21090403e5d18ea02670e3d5d172581670be006100db9ef"}, + {file = "grpcio-1.66.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:6f914386e52cbdeb5d2a7ce3bf1fdfacbe9d818dd81b6099a05b741aaf3848bb"}, + {file = "grpcio-1.66.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bff2096bdba686019fb32d2dde45b95981f0d1490e054400f70fc9a8af34b49d"}, + {file = "grpcio-1.66.1-cp38-cp38-win32.whl", hash = "sha256:aa8ba945c96e73de29d25331b26f3e416e0c0f621e984a3ebdb2d0d0b596a3b3"}, + {file = "grpcio-1.66.1-cp38-cp38-win_amd64.whl", hash = "sha256:161d5c535c2bdf61b95080e7f0f017a1dfcb812bf54093e71e5562b16225b4ce"}, + {file = "grpcio-1.66.1-cp39-cp39-linux_armv7l.whl", hash = "sha256:d0cd7050397b3609ea51727b1811e663ffda8bda39c6a5bb69525ef12414b503"}, + {file = "grpcio-1.66.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:0e6c9b42ded5d02b6b1fea3a25f036a2236eeb75d0579bfd43c0018c88bf0a3e"}, + {file = "grpcio-1.66.1-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:c9f80f9fad93a8cf71c7f161778ba47fd730d13a343a46258065c4deb4b550c0"}, + {file = "grpcio-1.66.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5dd67ed9da78e5121efc5c510f0122a972216808d6de70953a740560c572eb44"}, + {file = "grpcio-1.66.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48b0d92d45ce3be2084b92fb5bae2f64c208fea8ceed7fccf6a7b524d3c4942e"}, + {file = "grpcio-1.66.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:4d813316d1a752be6f5c4360c49f55b06d4fe212d7df03253dfdae90c8a402bb"}, + {file = "grpcio-1.66.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9c9bebc6627873ec27a70fc800f6083a13c70b23a5564788754b9ee52c5aef6c"}, + {file = "grpcio-1.66.1-cp39-cp39-win32.whl", hash = "sha256:30a1c2cf9390c894c90bbc70147f2372130ad189cffef161f0432d0157973f45"}, + {file = "grpcio-1.66.1-cp39-cp39-win_amd64.whl", hash = "sha256:17663598aadbedc3cacd7bbde432f541c8e07d2496564e22b214b22c7523dac8"}, + {file = "grpcio-1.66.1.tar.gz", hash = "sha256:35334f9c9745add3e357e3372756fd32d925bd52c41da97f4dfdafbde0bf0ee2"}, +] + +[package.extras] +protobuf = ["grpcio-tools (>=1.66.1)"] [[package]] name = "grpclib" @@ -1491,44 +1647,20 @@ files = [ {file = "hyperframe-6.0.1.tar.gz", hash = "sha256:ae510046231dc8e9ecb1a6586f63d2347bf4c8905914aa84ba585ae85f28a914"}, ] -[[package]] -name = "hyperopt" -version = "0.2.7" -description = "Distributed Asynchronous Hyperparameter Optimization" -optional = false -python-versions = "*" -files = [ - {file = "hyperopt-0.2.7-py2.py3-none-any.whl", hash = "sha256:f3046d91fe4167dbf104365016596856b2524a609d22f047a066fc1ac796427c"}, - {file = "hyperopt-0.2.7.tar.gz", hash = "sha256:1bf89ae58050bbd32c7307199046117feee245c2fd9ab6255c7308522b7ca149"}, -] - -[package.dependencies] -cloudpickle = "*" -future = "*" -networkx = ">=2.2" -numpy = "*" -py4j = "*" -scipy = "*" -six = "*" -tqdm = "*" - -[package.extras] -atpe = ["lightgbm", "scikit-learn"] -dev = ["black", "nose", "pre-commit", "pytest"] -mongotrials = ["pymongo"] -sparktrials = ["pyspark"] - [[package]] name = "idna" -version = "3.7" +version = "3.10" description = "Internationalized Domain Names in Applications (IDNA)" optional = false -python-versions = ">=3.5" +python-versions = ">=3.6" files = [ - {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"}, - {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"}, + {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"}, + {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"}, ] +[package.extras] +all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"] + [[package]] name = "ifaddr" version = "0.2.0" @@ -1553,40 +1685,48 @@ files = [ [[package]] name = "importlib-metadata" -version = "7.1.0" +version = "8.5.0" description = "Read metadata from Python packages" optional = false python-versions = ">=3.8" files = [ - {file = "importlib_metadata-7.1.0-py3-none-any.whl", hash = "sha256:30962b96c0c223483ed6cc7280e7f0199feb01a0e40cfae4d4450fc6fab1f570"}, - {file = "importlib_metadata-7.1.0.tar.gz", hash = "sha256:b78938b926ee8d5f020fc4772d487045805a55ddbad2ecf21c6d60938dc7fcd2"}, + {file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"}, + {file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"}, ] [package.dependencies] -zipp = ">=0.5" +zipp = ">=3.20" [package.extras] -docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"] +cover = ["pytest-cov"] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +enabler = ["pytest-enabler (>=2.2)"] perf = ["ipython"] -testing = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"] +test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"] +type = ["pytest-mypy"] [[package]] name = "importlib-resources" -version = "6.4.0" +version = "6.4.5" description = "Read resources from Python packages" optional = false python-versions = ">=3.8" files = [ - {file = "importlib_resources-6.4.0-py3-none-any.whl", hash = "sha256:50d10f043df931902d4194ea07ec57960f66a80449ff867bfe782b4c486ba78c"}, - {file = "importlib_resources-6.4.0.tar.gz", hash = "sha256:cdb2b453b8046ca4e3798eb1d84f3cce1446a0e8e7b5ef4efb600f19fc398145"}, + {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"}, + {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"}, ] [package.dependencies] zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""} [package.extras] -docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] -testing = ["jaraco.test (>=5.4)", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)", "zipp (>=3.17)"] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"] +cover = ["pytest-cov"] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +enabler = ["pytest-enabler (>=2.2)"] +test = ["jaraco.test (>=5.4)", "pytest (>=6,!=8.1.*)", "zipp (>=3.17)"] +type = ["pytest-mypy"] [[package]] name = "iniconfig" @@ -1651,21 +1791,21 @@ test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.22)", "pa [[package]] name = "ipywidgets" -version = "8.1.2" +version = "8.1.5" description = "Jupyter interactive widgets" optional = false python-versions = ">=3.7" files = [ - {file = "ipywidgets-8.1.2-py3-none-any.whl", hash = "sha256:bbe43850d79fb5e906b14801d6c01402857996864d1e5b6fa62dd2ee35559f60"}, - {file = "ipywidgets-8.1.2.tar.gz", hash = "sha256:d0b9b41e49bae926a866e613a39b0f0097745d2b9f1f3dd406641b4a57ec42c9"}, + {file = "ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245"}, + {file = "ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17"}, ] [package.dependencies] comm = ">=0.1.3" ipython = ">=6.1.0" -jupyterlab-widgets = ">=3.0.10,<3.1.0" +jupyterlab-widgets = ">=3.0.12,<3.1.0" traitlets = ">=4.3.1" -widgetsnbextension = ">=4.0.10,<4.1.0" +widgetsnbextension = ">=4.0.12,<4.1.0" [package.extras] test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] @@ -1755,13 +1895,13 @@ files = [ [[package]] name = "jsonschema" -version = "4.22.0" +version = "4.23.0" description = "An implementation of JSON Schema validation for Python" optional = false python-versions = ">=3.8" files = [ - {file = "jsonschema-4.22.0-py3-none-any.whl", hash = "sha256:ff4cfd6b1367a40e7bc6411caec72effadd3db0bbe5017de188f2d6108335802"}, - {file = "jsonschema-4.22.0.tar.gz", hash = "sha256:5b22d434a45935119af990552c862e5d6d564e8f6601206b305a61fdf661a2b7"}, + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, ] [package.dependencies] @@ -1772,7 +1912,7 @@ rpds-py = ">=0.7.1" [package.extras] format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] -format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] +format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=24.6.0)"] [[package]] name = "jsonschema-specifications" @@ -1790,13 +1930,13 @@ referencing = ">=0.31.0" [[package]] name = "jupyter-client" -version = "8.6.1" +version = "8.6.3" description = "Jupyter protocol implementation and client libraries" optional = false python-versions = ">=3.8" files = [ - {file = "jupyter_client-8.6.1-py3-none-any.whl", hash = "sha256:3b7bd22f058434e3b9a7ea4b1500ed47de2713872288c0d511d19926f99b459f"}, - {file = "jupyter_client-8.6.1.tar.gz", hash = "sha256:e842515e2bab8e19186d89fdfea7abd15e39dd581f94e399f00e2af5a1652d3f"}, + {file = "jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f"}, + {file = "jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419"}, ] [package.dependencies] @@ -1809,7 +1949,7 @@ traitlets = ">=5.3" [package.extras] docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] +test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest (<8.2.0)", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] [[package]] name = "jupyter-core" @@ -1844,126 +1984,136 @@ files = [ [[package]] name = "jupyterlab-widgets" -version = "3.0.10" +version = "3.0.13" description = "Jupyter interactive widgets for JupyterLab" optional = false python-versions = ">=3.7" files = [ - {file = "jupyterlab_widgets-3.0.10-py3-none-any.whl", hash = "sha256:dd61f3ae7a5a7f80299e14585ce6cf3d6925a96c9103c978eda293197730cb64"}, - {file = "jupyterlab_widgets-3.0.10.tar.gz", hash = "sha256:04f2ac04976727e4f9d0fa91cdc2f1ab860f965e504c29dbd6a65c882c9d04c0"}, + {file = "jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54"}, + {file = "jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed"}, ] [[package]] name = "kiwisolver" -version = "1.4.5" +version = "1.4.7" description = "A fast implementation of the Cassowary constraint solver" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"}, - {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"}, - {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"}, - {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"}, - {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"}, - {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"}, - {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"}, - {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"}, - {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"}, - {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"}, - {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"}, - {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"}, - {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"}, - {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"}, - {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"}, - {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"}, - {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"}, - {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"}, - {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"}, - {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"}, - {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"}, - {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"}, - {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"}, - {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"}, - {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"}, - {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"}, - {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"}, - {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"}, - {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"}, - {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"}, - {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"}, - {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"}, - {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"}, - {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"}, - {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"}, - {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"}, - {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"}, - {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"}, - {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"}, - {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"}, - {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"}, - {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"}, - {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"}, - {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"}, - {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"}, - {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"}, - {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"}, - {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"}, - {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"}, - {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"}, - {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"}, - {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"}, - {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"}, - {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"}, - {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"}, - {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"}, - {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"}, - {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"}, - {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"}, - {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"}, - {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"}, - {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"}, - {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"}, - {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"}, - {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"}, - {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"}, - {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"}, - {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"}, - {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"}, - {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"}, - {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"}, - {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"}, - {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"}, - {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"}, - {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"}, - {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"}, - {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"}, - {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"}, - {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"}, - {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"}, - {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"}, - {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"}, - {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"}, - {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"}, - {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"}, - {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"}, - {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"}, - {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"}, - {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"}, - {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"}, - {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"}, - {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, + {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6"}, + {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17"}, + {file = "kiwisolver-1.4.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa0abdf853e09aff551db11fce173e2177d00786c688203f52c87ad7fcd91ef9"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8d53103597a252fb3ab8b5845af04c7a26d5e7ea8122303dd7a021176a87e8b9"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:88f17c5ffa8e9462fb79f62746428dd57b46eb931698e42e990ad63103f35e6c"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88a9ca9c710d598fd75ee5de59d5bda2684d9db36a9f50b6125eaea3969c2599"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4d742cb7af1c28303a51b7a27aaee540e71bb8e24f68c736f6f2ffc82f2bf05"}, + {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e28c7fea2196bf4c2f8d46a0415c77a1c480cc0724722f23d7410ffe9842c407"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e968b84db54f9d42046cf154e02911e39c0435c9801681e3fc9ce8a3c4130278"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0c18ec74c0472de033e1bebb2911c3c310eef5649133dd0bedf2a169a1b269e5"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8f0ea6da6d393d8b2e187e6a5e3fb81f5862010a40c3945e2c6d12ae45cfb2ad"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:f106407dda69ae456dd1227966bf445b157ccc80ba0dff3802bb63f30b74e895"}, + {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:84ec80df401cfee1457063732d90022f93951944b5b58975d34ab56bb150dfb3"}, + {file = "kiwisolver-1.4.7-cp310-cp310-win32.whl", hash = "sha256:71bb308552200fb2c195e35ef05de12f0c878c07fc91c270eb3d6e41698c3bcc"}, + {file = "kiwisolver-1.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:44756f9fd339de0fb6ee4f8c1696cfd19b2422e0d70b4cefc1cc7f1f64045a8c"}, + {file = "kiwisolver-1.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:78a42513018c41c2ffd262eb676442315cbfe3c44eed82385c2ed043bc63210a"}, + {file = "kiwisolver-1.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d2b0e12a42fb4e72d509fc994713d099cbb15ebf1103545e8a45f14da2dfca54"}, + {file = "kiwisolver-1.4.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a8781ac3edc42ea4b90bc23e7d37b665d89423818e26eb6df90698aa2287c95"}, + {file = "kiwisolver-1.4.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46707a10836894b559e04b0fd143e343945c97fd170d69a2d26d640b4e297935"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef97b8df011141c9b0f6caf23b29379f87dd13183c978a30a3c546d2c47314cb"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab58c12a2cd0fc769089e6d38466c46d7f76aced0a1f54c77652446733d2d02"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:803b8e1459341c1bb56d1c5c010406d5edec8a0713a0945851290a7930679b51"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9a9e8a507420fe35992ee9ecb302dab68550dedc0da9e2880dd88071c5fb052"}, + {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18077b53dc3bb490e330669a99920c5e6a496889ae8c63b58fbc57c3d7f33a18"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6af936f79086a89b3680a280c47ea90b4df7047b5bdf3aa5c524bbedddb9e545"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3abc5b19d24af4b77d1598a585b8a719beb8569a71568b66f4ebe1fb0449460b"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:933d4de052939d90afbe6e9d5273ae05fb836cc86c15b686edd4b3560cc0ee36"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:65e720d2ab2b53f1f72fb5da5fb477455905ce2c88aaa671ff0a447c2c80e8e3"}, + {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3bf1ed55088f214ba6427484c59553123fdd9b218a42bbc8c6496d6754b1e523"}, + {file = "kiwisolver-1.4.7-cp311-cp311-win32.whl", hash = "sha256:4c00336b9dd5ad96d0a558fd18a8b6f711b7449acce4c157e7343ba92dd0cf3d"}, + {file = "kiwisolver-1.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:929e294c1ac1e9f615c62a4e4313ca1823ba37326c164ec720a803287c4c499b"}, + {file = "kiwisolver-1.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:e33e8fbd440c917106b237ef1a2f1449dfbb9b6f6e1ce17c94cd6a1e0d438376"}, + {file = "kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2"}, + {file = "kiwisolver-1.4.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942216596dc64ddb25adb215c3c783215b23626f8d84e8eff8d6d45c3f29f75a"}, + {file = "kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad42ba922c67c5f219097b28fae965e10045ddf145d2928bfac2eb2e17673640"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:612a10bdae23404a72941a0fc8fa2660c6ea1217c4ce0dbcab8a8f6543ea9e7f"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e838bba3a3bac0fe06d849d29772eb1afb9745a59710762e4ba3f4cb8424483"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22f499f6157236c19f4bbbd472fa55b063db77a16cd74d49afe28992dff8c258"}, + {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e77f2126c3e0b0d055f44513ed349038ac180371ed9b52fe96a32aa071a5107"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:657a05857bda581c3656bfc3b20e353c232e9193eb167766ad2dc58b56504948"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4bfa75a048c056a411f9705856abfc872558e33c055d80af6a380e3658766038"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:34ea1de54beef1c104422d210c47c7d2a4999bdecf42c7b5718fbe59a4cac383"}, + {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:90da3b5f694b85231cf93586dad5e90e2d71b9428f9aad96952c99055582f520"}, + {file = "kiwisolver-1.4.7-cp312-cp312-win32.whl", hash = "sha256:18e0cca3e008e17fe9b164b55735a325140a5a35faad8de92dd80265cd5eb80b"}, + {file = "kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb"}, + {file = "kiwisolver-1.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:f5a8b53bdc0b3961f8b6125e198617c40aeed638b387913bf1ce78afb1b0be2a"}, + {file = "kiwisolver-1.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2e6039dcbe79a8e0f044f1c39db1986a1b8071051efba3ee4d74f5b365f5226e"}, + {file = "kiwisolver-1.4.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a1ecf0ac1c518487d9d23b1cd7139a6a65bc460cd101ab01f1be82ecf09794b6"}, + {file = "kiwisolver-1.4.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ab9ccab2b5bd5702ab0803676a580fffa2aa178c2badc5557a84cc943fcf750"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f816dd2277f8d63d79f9c8473a79fe54047bc0467754962840782c575522224d"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf8bcc23ceb5a1b624572a1623b9f79d2c3b337c8c455405ef231933a10da379"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dea0bf229319828467d7fca8c7c189780aa9ff679c94539eed7532ebe33ed37c"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c06a4c7cf15ec739ce0e5971b26c93638730090add60e183530d70848ebdd34"}, + {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:913983ad2deb14e66d83c28b632fd35ba2b825031f2fa4ca29675e665dfecbe1"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5337ec7809bcd0f424c6b705ecf97941c46279cf5ed92311782c7c9c2026f07f"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4c26ed10c4f6fa6ddb329a5120ba3b6db349ca192ae211e882970bfc9d91420b"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c619b101e6de2222c1fcb0531e1b17bbffbe54294bfba43ea0d411d428618c27"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:073a36c8273647592ea332e816e75ef8da5c303236ec0167196793eb1e34657a"}, + {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ce6b2b0231bda412463e152fc18335ba32faf4e8c23a754ad50ffa70e4091ee"}, + {file = "kiwisolver-1.4.7-cp313-cp313-win32.whl", hash = "sha256:f4c9aee212bc89d4e13f58be11a56cc8036cabad119259d12ace14b34476fd07"}, + {file = "kiwisolver-1.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:8a3ec5aa8e38fc4c8af308917ce12c536f1c88452ce554027e55b22cbbfbff76"}, + {file = "kiwisolver-1.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:76c8094ac20ec259471ac53e774623eb62e6e1f56cd8690c67ce6ce4fcb05650"}, + {file = "kiwisolver-1.4.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5d5abf8f8ec1f4e22882273c423e16cae834c36856cac348cfbfa68e01c40f3a"}, + {file = "kiwisolver-1.4.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:aeb3531b196ef6f11776c21674dba836aeea9d5bd1cf630f869e3d90b16cfade"}, + {file = "kiwisolver-1.4.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b7d755065e4e866a8086c9bdada157133ff466476a2ad7861828e17b6026e22c"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08471d4d86cbaec61f86b217dd938a83d85e03785f51121e791a6e6689a3be95"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bbfcb7165ce3d54a3dfbe731e470f65739c4c1f85bb1018ee912bae139e263b"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d34eb8494bea691a1a450141ebb5385e4b69d38bb8403b5146ad279f4b30fa3"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9242795d174daa40105c1d86aba618e8eab7bf96ba8c3ee614da8302a9f95503"}, + {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a0f64a48bb81af7450e641e3fe0b0394d7381e342805479178b3d335d60ca7cf"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:8e045731a5416357638d1700927529e2b8ab304811671f665b225f8bf8d8f933"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:4322872d5772cae7369f8351da1edf255a604ea7087fe295411397d0cfd9655e"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:e1631290ee9271dffe3062d2634c3ecac02c83890ada077d225e081aca8aab89"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:edcfc407e4eb17e037bca59be0e85a2031a2ac87e4fed26d3e9df88b4165f92d"}, + {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:4d05d81ecb47d11e7f8932bd8b61b720bf0b41199358f3f5e36d38e28f0532c5"}, + {file = "kiwisolver-1.4.7-cp38-cp38-win32.whl", hash = "sha256:b38ac83d5f04b15e515fd86f312479d950d05ce2368d5413d46c088dda7de90a"}, + {file = "kiwisolver-1.4.7-cp38-cp38-win_amd64.whl", hash = "sha256:d83db7cde68459fc803052a55ace60bea2bae361fc3b7a6d5da07e11954e4b09"}, + {file = "kiwisolver-1.4.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9362ecfca44c863569d3d3c033dbe8ba452ff8eed6f6b5806382741a1334bd"}, + {file = "kiwisolver-1.4.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e8df2eb9b2bac43ef8b082e06f750350fbbaf2887534a5be97f6cf07b19d9583"}, + {file = "kiwisolver-1.4.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f32d6edbc638cde7652bd690c3e728b25332acbadd7cad670cc4a02558d9c417"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e2e6c39bd7b9372b0be21456caab138e8e69cc0fc1190a9dfa92bd45a1e6e904"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dda56c24d869b1193fcc763f1284b9126550eaf84b88bbc7256e15028f19188a"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79849239c39b5e1fd906556c474d9b0439ea6792b637511f3fe3a41158d89ca8"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5e3bc157fed2a4c02ec468de4ecd12a6e22818d4f09cde2c31ee3226ffbefab2"}, + {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3da53da805b71e41053dc670f9a820d1157aae77b6b944e08024d17bcd51ef88"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8705f17dfeb43139a692298cb6637ee2e59c0194538153e83e9ee0c75c2eddde"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:82a5c2f4b87c26bb1a0ef3d16b5c4753434633b83d365cc0ddf2770c93829e3c"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ce8be0466f4c0d585cdb6c1e2ed07232221df101a4c6f28821d2aa754ca2d9e2"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:409afdfe1e2e90e6ee7fc896f3df9a7fec8e793e58bfa0d052c8a82f99c37abb"}, + {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5b9c3f4ee0b9a439d2415012bd1b1cc2df59e4d6a9939f4d669241d30b414327"}, + {file = "kiwisolver-1.4.7-cp39-cp39-win32.whl", hash = "sha256:a79ae34384df2b615eefca647a2873842ac3b596418032bef9a7283675962644"}, + {file = "kiwisolver-1.4.7-cp39-cp39-win_amd64.whl", hash = "sha256:cf0438b42121a66a3a667de17e779330fc0f20b0d97d59d2f2121e182b0505e4"}, + {file = "kiwisolver-1.4.7-cp39-cp39-win_arm64.whl", hash = "sha256:764202cc7e70f767dab49e8df52c7455e8de0df5d858fa801a11aa0d882ccf3f"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:94252291e3fe68001b1dd747b4c0b3be12582839b95ad4d1b641924d68fd4643"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b7dfa3b546da08a9f622bb6becdb14b3e24aaa30adba66749d38f3cc7ea9706"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd3de6481f4ed8b734da5df134cd5a6a64fe32124fe83dde1e5b5f29fe30b1e6"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a91b5f9f1205845d488c928e8570dcb62b893372f63b8b6e98b863ebd2368ff2"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40fa14dbd66b8b8f470d5fc79c089a66185619d31645f9b0773b88b19f7223c4"}, + {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:eb542fe7933aa09d8d8f9d9097ef37532a7df6497819d16efe4359890a2f417a"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:bfa1acfa0c54932d5607e19a2c24646fb4c1ae2694437789129cf099789a3b00"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:eee3ea935c3d227d49b4eb85660ff631556841f6e567f0f7bda972df6c2c9935"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f3160309af4396e0ed04db259c3ccbfdc3621b5559b5453075e5de555e1f3a1b"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a17f6a29cf8935e587cc8a4dbfc8368c55edc645283db0ce9801016f83526c2d"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:10849fb2c1ecbfae45a693c070e0320a91b35dd4bcf58172c023b994283a124d"}, + {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:ac542bf38a8a4be2dc6b15248d36315ccc65f0743f7b1a76688ffb6b5129a5c2"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b01aac285f91ca889c800042c35ad3b239e704b150cfd3382adfc9dcc780e39"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:48be928f59a1f5c8207154f935334d374e79f2b5d212826307d072595ad76a2e"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f37cfe618a117e50d8c240555331160d73d0411422b59b5ee217843d7b693608"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:599b5c873c63a1f6ed7eead644a8a380cfbdf5db91dcb6f85707aaab213b1674"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:801fa7802e5cfabe3ab0c81a34c323a319b097dfb5004be950482d882f3d7225"}, + {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0c6c43471bc764fad4bc99c5c2d6d16a676b1abf844ca7c8702bdae92df01ee0"}, + {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"}, ] [[package]] @@ -2086,15 +2236,34 @@ dev = ["changelist (==0.5)"] lint = ["pre-commit (==3.7.0)"] test = ["pytest (>=7.4)", "pytest-cov (>=4.1)"] +[[package]] +name = "mako" +version = "1.3.5" +description = "A super-fast templating language that borrows the best ideas from the existing templating languages." +optional = false +python-versions = ">=3.8" +files = [ + {file = "Mako-1.3.5-py3-none-any.whl", hash = "sha256:260f1dbc3a519453a9c856dedfe4beb4e50bd5a26d96386cb6c80856556bb91a"}, + {file = "Mako-1.3.5.tar.gz", hash = "sha256:48dbc20568c1d276a2698b36d968fa76161bf127194907ea6fc594fa81f943bc"}, +] + +[package.dependencies] +MarkupSafe = ">=0.9.2" + +[package.extras] +babel = ["Babel"] +lingua = ["lingua"] +testing = ["pytest"] + [[package]] name = "markdown" -version = "3.6" +version = "3.7" description = "Python implementation of John Gruber's Markdown." optional = false python-versions = ">=3.8" files = [ - {file = "Markdown-3.6-py3-none-any.whl", hash = "sha256:48f276f4d8cfb8ce6527c8f79e2ee29708508bf4d40aa410fbc3b4ee832c850f"}, - {file = "Markdown-3.6.tar.gz", hash = "sha256:ed4f41f6daecbeeb96e576ce414c41d2d876daa9a16cb35fa8ed8c2ddfad0224"}, + {file = "Markdown-3.7-py3-none-any.whl", hash = "sha256:7eb6df5690b81a1d7942992c97fad2938e956e79df20cbc6186e9c3a77b1c803"}, + {file = "markdown-3.7.tar.gz", hash = "sha256:2ae2471477cfd02dbbf038d5d9bc226d40def84b4fe2986e49b59b6b472bbed2"}, ] [package.dependencies] @@ -2229,40 +2398,51 @@ marshmallow = ">=3.0.0b10" [[package]] name = "matplotlib" -version = "3.9.0" +version = "3.9.2" description = "Python plotting package" optional = false python-versions = ">=3.9" files = [ - {file = "matplotlib-3.9.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2bcee1dffaf60fe7656183ac2190bd630842ff87b3153afb3e384d966b57fe56"}, - {file = "matplotlib-3.9.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3f988bafb0fa39d1074ddd5bacd958c853e11def40800c5824556eb630f94d3b"}, - {file = "matplotlib-3.9.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe428e191ea016bb278758c8ee82a8129c51d81d8c4bc0846c09e7e8e9057241"}, - {file = "matplotlib-3.9.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaf3978060a106fab40c328778b148f590e27f6fa3cd15a19d6892575bce387d"}, - {file = "matplotlib-3.9.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:2e7f03e5cbbfacdd48c8ea394d365d91ee8f3cae7e6ec611409927b5ed997ee4"}, - {file = "matplotlib-3.9.0-cp310-cp310-win_amd64.whl", hash = "sha256:13beb4840317d45ffd4183a778685e215939be7b08616f431c7795276e067463"}, - {file = "matplotlib-3.9.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:063af8587fceeac13b0936c42a2b6c732c2ab1c98d38abc3337e430e1ff75e38"}, - {file = "matplotlib-3.9.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9a2fa6d899e17ddca6d6526cf6e7ba677738bf2a6a9590d702c277204a7c6152"}, - {file = "matplotlib-3.9.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:550cdda3adbd596078cca7d13ed50b77879104e2e46392dcd7c75259d8f00e85"}, - {file = "matplotlib-3.9.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76cce0f31b351e3551d1f3779420cf8f6ec0d4a8cf9c0237a3b549fd28eb4abb"}, - {file = "matplotlib-3.9.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c53aeb514ccbbcbab55a27f912d79ea30ab21ee0531ee2c09f13800efb272674"}, - {file = "matplotlib-3.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:a5be985db2596d761cdf0c2eaf52396f26e6a64ab46bd8cd810c48972349d1be"}, - {file = "matplotlib-3.9.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c79f3a585f1368da6049318bdf1f85568d8d04b2e89fc24b7e02cc9b62017382"}, - {file = "matplotlib-3.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bdd1ecbe268eb3e7653e04f451635f0fb0f77f07fd070242b44c076c9106da84"}, - {file = "matplotlib-3.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d38e85a1a6d732f645f1403ce5e6727fd9418cd4574521d5803d3d94911038e5"}, - {file = "matplotlib-3.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a490715b3b9984fa609116481b22178348c1a220a4499cda79132000a79b4db"}, - {file = "matplotlib-3.9.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8146ce83cbc5dc71c223a74a1996d446cd35cfb6a04b683e1446b7e6c73603b7"}, - {file = "matplotlib-3.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:d91a4ffc587bacf5c4ce4ecfe4bcd23a4b675e76315f2866e588686cc97fccdf"}, - {file = "matplotlib-3.9.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:616fabf4981a3b3c5a15cd95eba359c8489c4e20e03717aea42866d8d0465956"}, - {file = "matplotlib-3.9.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cd53c79fd02f1c1808d2cfc87dd3cf4dbc63c5244a58ee7944497107469c8d8a"}, - {file = "matplotlib-3.9.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:06a478f0d67636554fa78558cfbcd7b9dba85b51f5c3b5a0c9be49010cf5f321"}, - {file = "matplotlib-3.9.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:81c40af649d19c85f8073e25e5806926986806fa6d54be506fbf02aef47d5a89"}, - {file = "matplotlib-3.9.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:52146fc3bd7813cc784562cb93a15788be0b2875c4655e2cc6ea646bfa30344b"}, - {file = "matplotlib-3.9.0-cp39-cp39-win_amd64.whl", hash = "sha256:0fc51eaa5262553868461c083d9adadb11a6017315f3a757fc45ec6ec5f02888"}, - {file = "matplotlib-3.9.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:bd4f2831168afac55b881db82a7730992aa41c4f007f1913465fb182d6fb20c0"}, - {file = "matplotlib-3.9.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:290d304e59be2b33ef5c2d768d0237f5bd132986bdcc66f80bc9bcc300066a03"}, - {file = "matplotlib-3.9.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ff2e239c26be4f24bfa45860c20ffccd118d270c5b5d081fa4ea409b5469fcd"}, - {file = "matplotlib-3.9.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:af4001b7cae70f7eaacfb063db605280058246de590fa7874f00f62259f2df7e"}, - {file = "matplotlib-3.9.0.tar.gz", hash = "sha256:e6d29ea6c19e34b30fb7d88b7081f869a03014f66fe06d62cc77d5a6ea88ed7a"}, + {file = "matplotlib-3.9.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:9d78bbc0cbc891ad55b4f39a48c22182e9bdaea7fc0e5dbd364f49f729ca1bbb"}, + {file = "matplotlib-3.9.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c375cc72229614632c87355366bdf2570c2dac01ac66b8ad048d2dabadf2d0d4"}, + {file = "matplotlib-3.9.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d94ff717eb2bd0b58fe66380bd8b14ac35f48a98e7c6765117fe67fb7684e64"}, + {file = "matplotlib-3.9.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab68d50c06938ef28681073327795c5db99bb4666214d2d5f880ed11aeaded66"}, + {file = "matplotlib-3.9.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:65aacf95b62272d568044531e41de26285d54aec8cb859031f511f84bd8b495a"}, + {file = "matplotlib-3.9.2-cp310-cp310-win_amd64.whl", hash = "sha256:3fd595f34aa8a55b7fc8bf9ebea8aa665a84c82d275190a61118d33fbc82ccae"}, + {file = "matplotlib-3.9.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d8dd059447824eec055e829258ab092b56bb0579fc3164fa09c64f3acd478772"}, + {file = "matplotlib-3.9.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c797dac8bb9c7a3fd3382b16fe8f215b4cf0f22adccea36f1545a6d7be310b41"}, + {file = "matplotlib-3.9.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d719465db13267bcef19ea8954a971db03b9f48b4647e3860e4bc8e6ed86610f"}, + {file = "matplotlib-3.9.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8912ef7c2362f7193b5819d17dae8629b34a95c58603d781329712ada83f9447"}, + {file = "matplotlib-3.9.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7741f26a58a240f43bee74965c4882b6c93df3e7eb3de160126d8c8f53a6ae6e"}, + {file = "matplotlib-3.9.2-cp311-cp311-win_amd64.whl", hash = "sha256:ae82a14dab96fbfad7965403c643cafe6515e386de723e498cf3eeb1e0b70cc7"}, + {file = "matplotlib-3.9.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:ac43031375a65c3196bee99f6001e7fa5bdfb00ddf43379d3c0609bdca042df9"}, + {file = "matplotlib-3.9.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:be0fc24a5e4531ae4d8e858a1a548c1fe33b176bb13eff7f9d0d38ce5112a27d"}, + {file = "matplotlib-3.9.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf81de2926c2db243c9b2cbc3917619a0fc85796c6ba4e58f541df814bbf83c7"}, + {file = "matplotlib-3.9.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6ee45bc4245533111ced13f1f2cace1e7f89d1c793390392a80c139d6cf0e6c"}, + {file = "matplotlib-3.9.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:306c8dfc73239f0e72ac50e5a9cf19cc4e8e331dd0c54f5e69ca8758550f1e1e"}, + {file = "matplotlib-3.9.2-cp312-cp312-win_amd64.whl", hash = "sha256:5413401594cfaff0052f9d8b1aafc6d305b4bd7c4331dccd18f561ff7e1d3bd3"}, + {file = "matplotlib-3.9.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:18128cc08f0d3cfff10b76baa2f296fc28c4607368a8402de61bb3f2eb33c7d9"}, + {file = "matplotlib-3.9.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4876d7d40219e8ae8bb70f9263bcbe5714415acfdf781086601211335e24f8aa"}, + {file = "matplotlib-3.9.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d9f07a80deab4bb0b82858a9e9ad53d1382fd122be8cde11080f4e7dfedb38b"}, + {file = "matplotlib-3.9.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7c0410f181a531ec4e93bbc27692f2c71a15c2da16766f5ba9761e7ae518413"}, + {file = "matplotlib-3.9.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:909645cce2dc28b735674ce0931a4ac94e12f5b13f6bb0b5a5e65e7cea2c192b"}, + {file = "matplotlib-3.9.2-cp313-cp313-win_amd64.whl", hash = "sha256:f32c7410c7f246838a77d6d1eff0c0f87f3cb0e7c4247aebea71a6d5a68cab49"}, + {file = "matplotlib-3.9.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:37e51dd1c2db16ede9cfd7b5cabdfc818b2c6397c83f8b10e0e797501c963a03"}, + {file = "matplotlib-3.9.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b82c5045cebcecd8496a4d694d43f9cc84aeeb49fe2133e036b207abe73f4d30"}, + {file = "matplotlib-3.9.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f053c40f94bc51bc03832a41b4f153d83f2062d88c72b5e79997072594e97e51"}, + {file = "matplotlib-3.9.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dbe196377a8248972f5cede786d4c5508ed5f5ca4a1e09b44bda889958b33f8c"}, + {file = "matplotlib-3.9.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5816b1e1fe8c192cbc013f8f3e3368ac56fbecf02fb41b8f8559303f24c5015e"}, + {file = "matplotlib-3.9.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:cef2a73d06601437be399908cf13aee74e86932a5ccc6ccdf173408ebc5f6bb2"}, + {file = "matplotlib-3.9.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e0830e188029c14e891fadd99702fd90d317df294c3298aad682739c5533721a"}, + {file = "matplotlib-3.9.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03ba9c1299c920964e8d3857ba27173b4dbb51ca4bab47ffc2c2ba0eb5e2cbc5"}, + {file = "matplotlib-3.9.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1cd93b91ab47a3616b4d3c42b52f8363b88ca021e340804c6ab2536344fad9ca"}, + {file = "matplotlib-3.9.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6d1ce5ed2aefcdce11904fc5bbea7d9c21fff3d5f543841edf3dea84451a09ea"}, + {file = "matplotlib-3.9.2-cp39-cp39-win_amd64.whl", hash = "sha256:b2696efdc08648536efd4e1601b5fd491fd47f4db97a5fbfd175549a7365c1b2"}, + {file = "matplotlib-3.9.2-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d52a3b618cb1cbb769ce2ee1dcdb333c3ab6e823944e9a2d36e37253815f9556"}, + {file = "matplotlib-3.9.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:039082812cacd6c6bec8e17a9c1e6baca230d4116d522e81e1f63a74d01d2e21"}, + {file = "matplotlib-3.9.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6758baae2ed64f2331d4fd19be38b7b4eae3ecec210049a26b6a4f3ae1c85dcc"}, + {file = "matplotlib-3.9.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:050598c2b29e0b9832cde72bcf97627bf00262adbc4a54e2b856426bb2ef0697"}, + {file = "matplotlib-3.9.2.tar.gz", hash = "sha256:96ab43906269ca64a6366934106fa01534454a69e471b7bf3d79083981aaab92"}, ] [package.dependencies] @@ -2327,17 +2507,6 @@ files = [ {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, ] -[[package]] -name = "more-itertools" -version = "9.1.0" -description = "More routines for operating on iterables, beyond itertools" -optional = false -python-versions = ">=3.7" -files = [ - {file = "more-itertools-9.1.0.tar.gz", hash = "sha256:cabaa341ad0389ea83c17a94566a53ae4c9d07349861ecb14dc6d0345cf9ac5d"}, - {file = "more_itertools-9.1.0-py3-none-any.whl", hash = "sha256:d2bc7f02446e86a68911e58ded76d6561eea00cddfb2a91e7019bbb586c799f3"}, -] - [[package]] name = "mpmath" version = "1.3.0" @@ -2357,140 +2526,141 @@ tests = ["pytest (>=4.6)"] [[package]] name = "msal" -version = "1.28.0" +version = "1.31.0" description = "The Microsoft Authentication Library (MSAL) for Python library enables your app to access the Microsoft Cloud by supporting authentication of users with Microsoft Azure Active Directory accounts (AAD) and Microsoft Accounts (MSA) using industry standard OAuth2 and OpenID Connect." optional = false python-versions = ">=3.7" files = [ - {file = "msal-1.28.0-py3-none-any.whl", hash = "sha256:3064f80221a21cd535ad8c3fafbb3a3582cd9c7e9af0bb789ae14f726a0ca99b"}, - {file = "msal-1.28.0.tar.gz", hash = "sha256:80bbabe34567cb734efd2ec1869b2d98195c927455369d8077b3c542088c5c9d"}, + {file = "msal-1.31.0-py3-none-any.whl", hash = "sha256:96bc37cff82ebe4b160d5fc0f1196f6ca8b50e274ecd0ec5bf69c438514086e7"}, + {file = "msal-1.31.0.tar.gz", hash = "sha256:2c4f189cf9cc8f00c80045f66d39b7c0f3ed45873fd3d1f2af9f22db2e12ff4b"}, ] [package.dependencies] -cryptography = ">=0.6,<45" +cryptography = ">=2.5,<46" PyJWT = {version = ">=1.0.0,<3", extras = ["crypto"]} requests = ">=2.0.0,<3" [package.extras] -broker = ["pymsalruntime (>=0.13.2,<0.15)"] +broker = ["pymsalruntime (>=0.14,<0.18)", "pymsalruntime (>=0.17,<0.18)"] [[package]] name = "msal-extensions" -version = "1.1.0" +version = "1.2.0" description = "Microsoft Authentication Library extensions (MSAL EX) provides a persistence API that can save your data on disk, encrypted on Windows, macOS and Linux. Concurrent data access will be coordinated by a file lock mechanism." optional = false python-versions = ">=3.7" files = [ - {file = "msal-extensions-1.1.0.tar.gz", hash = "sha256:6ab357867062db7b253d0bd2df6d411c7891a0ee7308d54d1e4317c1d1c54252"}, - {file = "msal_extensions-1.1.0-py3-none-any.whl", hash = "sha256:01be9711b4c0b1a151450068eeb2c4f0997df3bba085ac299de3a66f585e382f"}, + {file = "msal_extensions-1.2.0-py3-none-any.whl", hash = "sha256:cf5ba83a2113fa6dc011a254a72f1c223c88d7dfad74cc30617c4679a417704d"}, + {file = "msal_extensions-1.2.0.tar.gz", hash = "sha256:6f41b320bfd2933d631a215c91ca0dd3e67d84bd1a2f50ce917d5874ec646bef"}, ] [package.dependencies] -msal = ">=0.4.1,<2.0.0" -packaging = "*" -portalocker = [ - {version = ">=1.0,<3", markers = "platform_system != \"Windows\""}, - {version = ">=1.6,<3", markers = "platform_system == \"Windows\""}, -] +msal = ">=1.29,<2" +portalocker = ">=1.4,<3" [[package]] name = "multidict" -version = "6.0.5" +version = "6.1.0" description = "multidict implementation" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:228b644ae063c10e7f324ab1ab6b548bdf6f8b47f3ec234fef1093bc2735e5f9"}, - {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:896ebdcf62683551312c30e20614305f53125750803b614e9e6ce74a96232604"}, - {file = "multidict-6.0.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:411bf8515f3be9813d06004cac41ccf7d1cd46dfe233705933dd163b60e37600"}, - {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d147090048129ce3c453f0292e7697d333db95e52616b3793922945804a433c"}, - {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:215ed703caf15f578dca76ee6f6b21b7603791ae090fbf1ef9d865571039ade5"}, - {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c6390cf87ff6234643428991b7359b5f59cc15155695deb4eda5c777d2b880f"}, - {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fd81c4ebdb4f214161be351eb5bcf385426bf023041da2fd9e60681f3cebae"}, - {file = "multidict-6.0.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3cc2ad10255f903656017363cd59436f2111443a76f996584d1077e43ee51182"}, - {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6939c95381e003f54cd4c5516740faba40cf5ad3eeff460c3ad1d3e0ea2549bf"}, - {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:220dd781e3f7af2c2c1053da9fa96d9cf3072ca58f057f4c5adaaa1cab8fc442"}, - {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:766c8f7511df26d9f11cd3a8be623e59cca73d44643abab3f8c8c07620524e4a"}, - {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:fe5d7785250541f7f5019ab9cba2c71169dc7d74d0f45253f8313f436458a4ef"}, - {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c1c1496e73051918fcd4f58ff2e0f2f3066d1c76a0c6aeffd9b45d53243702cc"}, - {file = "multidict-6.0.5-cp310-cp310-win32.whl", hash = "sha256:7afcdd1fc07befad18ec4523a782cde4e93e0a2bf71239894b8d61ee578c1319"}, - {file = "multidict-6.0.5-cp310-cp310-win_amd64.whl", hash = "sha256:99f60d34c048c5c2fabc766108c103612344c46e35d4ed9ae0673d33c8fb26e8"}, - {file = "multidict-6.0.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f285e862d2f153a70586579c15c44656f888806ed0e5b56b64489afe4a2dbfba"}, - {file = "multidict-6.0.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:53689bb4e102200a4fafa9de9c7c3c212ab40a7ab2c8e474491914d2305f187e"}, - {file = "multidict-6.0.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:612d1156111ae11d14afaf3a0669ebf6c170dbb735e510a7438ffe2369a847fd"}, - {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7be7047bd08accdb7487737631d25735c9a04327911de89ff1b26b81745bd4e3"}, - {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de170c7b4fe6859beb8926e84f7d7d6c693dfe8e27372ce3b76f01c46e489fcf"}, - {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04bde7a7b3de05732a4eb39c94574db1ec99abb56162d6c520ad26f83267de29"}, - {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85f67aed7bb647f93e7520633d8f51d3cbc6ab96957c71272b286b2f30dc70ed"}, - {file = "multidict-6.0.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:425bf820055005bfc8aa9a0b99ccb52cc2f4070153e34b701acc98d201693733"}, - {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d3eb1ceec286eba8220c26f3b0096cf189aea7057b6e7b7a2e60ed36b373b77f"}, - {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:7901c05ead4b3fb75113fb1dd33eb1253c6d3ee37ce93305acd9d38e0b5f21a4"}, - {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e0e79d91e71b9867c73323a3444724d496c037e578a0e1755ae159ba14f4f3d1"}, - {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:29bfeb0dff5cb5fdab2023a7a9947b3b4af63e9c47cae2a10ad58394b517fddc"}, - {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e030047e85cbcedbfc073f71836d62dd5dadfbe7531cae27789ff66bc551bd5e"}, - {file = "multidict-6.0.5-cp311-cp311-win32.whl", hash = "sha256:2f4848aa3baa109e6ab81fe2006c77ed4d3cd1e0ac2c1fbddb7b1277c168788c"}, - {file = "multidict-6.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:2faa5ae9376faba05f630d7e5e6be05be22913782b927b19d12b8145968a85ea"}, - {file = "multidict-6.0.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:51d035609b86722963404f711db441cf7134f1889107fb171a970c9701f92e1e"}, - {file = "multidict-6.0.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cbebcd5bcaf1eaf302617c114aa67569dd3f090dd0ce8ba9e35e9985b41ac35b"}, - {file = "multidict-6.0.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2ffc42c922dbfddb4a4c3b438eb056828719f07608af27d163191cb3e3aa6cc5"}, - {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ceb3b7e6a0135e092de86110c5a74e46bda4bd4fbfeeb3a3bcec79c0f861e450"}, - {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:79660376075cfd4b2c80f295528aa6beb2058fd289f4c9252f986751a4cd0496"}, - {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e4428b29611e989719874670fd152b6625500ad6c686d464e99f5aaeeaca175a"}, - {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d84a5c3a5f7ce6db1f999fb9438f686bc2e09d38143f2d93d8406ed2dd6b9226"}, - {file = "multidict-6.0.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:76c0de87358b192de7ea9649beb392f107dcad9ad27276324c24c91774ca5271"}, - {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:79a6d2ba910adb2cbafc95dad936f8b9386e77c84c35bc0add315b856d7c3abb"}, - {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:92d16a3e275e38293623ebf639c471d3e03bb20b8ebb845237e0d3664914caef"}, - {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:fb616be3538599e797a2017cccca78e354c767165e8858ab5116813146041a24"}, - {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:14c2976aa9038c2629efa2c148022ed5eb4cb939e15ec7aace7ca932f48f9ba6"}, - {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:435a0984199d81ca178b9ae2c26ec3d49692d20ee29bc4c11a2a8d4514c67eda"}, - {file = "multidict-6.0.5-cp312-cp312-win32.whl", hash = "sha256:9fe7b0653ba3d9d65cbe7698cca585bf0f8c83dbbcc710db9c90f478e175f2d5"}, - {file = "multidict-6.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:01265f5e40f5a17f8241d52656ed27192be03bfa8764d88e8220141d1e4b3556"}, - {file = "multidict-6.0.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:19fe01cea168585ba0f678cad6f58133db2aa14eccaf22f88e4a6dccadfad8b3"}, - {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bf7a982604375a8d49b6cc1b781c1747f243d91b81035a9b43a2126c04766f5"}, - {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:107c0cdefe028703fb5dafe640a409cb146d44a6ae201e55b35a4af8e95457dd"}, - {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:403c0911cd5d5791605808b942c88a8155c2592e05332d2bf78f18697a5fa15e"}, - {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aeaf541ddbad8311a87dd695ed9642401131ea39ad7bc8cf3ef3967fd093b626"}, - {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e4972624066095e52b569e02b5ca97dbd7a7ddd4294bf4e7247d52635630dd83"}, - {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d946b0a9eb8aaa590df1fe082cee553ceab173e6cb5b03239716338629c50c7a"}, - {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b55358304d7a73d7bdf5de62494aaf70bd33015831ffd98bc498b433dfe5b10c"}, - {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:a3145cb08d8625b2d3fee1b2d596a8766352979c9bffe5d7833e0503d0f0b5e5"}, - {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:d65f25da8e248202bd47445cec78e0025c0fe7582b23ec69c3b27a640dd7a8e3"}, - {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:c9bf56195c6bbd293340ea82eafd0071cb3d450c703d2c93afb89f93b8386ccc"}, - {file = "multidict-6.0.5-cp37-cp37m-win32.whl", hash = "sha256:69db76c09796b313331bb7048229e3bee7928eb62bab5e071e9f7fcc4879caee"}, - {file = "multidict-6.0.5-cp37-cp37m-win_amd64.whl", hash = "sha256:fce28b3c8a81b6b36dfac9feb1de115bab619b3c13905b419ec71d03a3fc1423"}, - {file = "multidict-6.0.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:76f067f5121dcecf0d63a67f29080b26c43c71a98b10c701b0677e4a065fbd54"}, - {file = "multidict-6.0.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b82cc8ace10ab5bd93235dfaab2021c70637005e1ac787031f4d1da63d493c1d"}, - {file = "multidict-6.0.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5cb241881eefd96b46f89b1a056187ea8e9ba14ab88ba632e68d7a2ecb7aadf7"}, - {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8e94e6912639a02ce173341ff62cc1201232ab86b8a8fcc05572741a5dc7d93"}, - {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:09a892e4a9fb47331da06948690ae38eaa2426de97b4ccbfafbdcbe5c8f37ff8"}, - {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55205d03e8a598cfc688c71ca8ea5f66447164efff8869517f175ea632c7cb7b"}, - {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:37b15024f864916b4951adb95d3a80c9431299080341ab9544ed148091b53f50"}, - {file = "multidict-6.0.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2a1dee728b52b33eebff5072817176c172050d44d67befd681609b4746e1c2e"}, - {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:edd08e6f2f1a390bf137080507e44ccc086353c8e98c657e666c017718561b89"}, - {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:60d698e8179a42ec85172d12f50b1668254628425a6bd611aba022257cac1386"}, - {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:3d25f19500588cbc47dc19081d78131c32637c25804df8414463ec908631e453"}, - {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:4cc0ef8b962ac7a5e62b9e826bd0cd5040e7d401bc45a6835910ed699037a461"}, - {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:eca2e9d0cc5a889850e9bbd68e98314ada174ff6ccd1129500103df7a94a7a44"}, - {file = "multidict-6.0.5-cp38-cp38-win32.whl", hash = "sha256:4a6a4f196f08c58c59e0b8ef8ec441d12aee4125a7d4f4fef000ccb22f8d7241"}, - {file = "multidict-6.0.5-cp38-cp38-win_amd64.whl", hash = "sha256:0275e35209c27a3f7951e1ce7aaf93ce0d163b28948444bec61dd7badc6d3f8c"}, - {file = "multidict-6.0.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e7be68734bd8c9a513f2b0cfd508802d6609da068f40dc57d4e3494cefc92929"}, - {file = "multidict-6.0.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1d9ea7a7e779d7a3561aade7d596649fbecfa5c08a7674b11b423783217933f9"}, - {file = "multidict-6.0.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ea1456df2a27c73ce51120fa2f519f1bea2f4a03a917f4a43c8707cf4cbbae1a"}, - {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf590b134eb70629e350691ecca88eac3e3b8b3c86992042fb82e3cb1830d5e1"}, - {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5c0631926c4f58e9a5ccce555ad7747d9a9f8b10619621f22f9635f069f6233e"}, - {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dce1c6912ab9ff5f179eaf6efe7365c1f425ed690b03341911bf4939ef2f3046"}, - {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0868d64af83169e4d4152ec612637a543f7a336e4a307b119e98042e852ad9c"}, - {file = "multidict-6.0.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:141b43360bfd3bdd75f15ed811850763555a251e38b2405967f8e25fb43f7d40"}, - {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7df704ca8cf4a073334e0427ae2345323613e4df18cc224f647f251e5e75a527"}, - {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:6214c5a5571802c33f80e6c84713b2c79e024995b9c5897f794b43e714daeec9"}, - {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:cd6c8fca38178e12c00418de737aef1261576bd1b6e8c6134d3e729a4e858b38"}, - {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:e02021f87a5b6932fa6ce916ca004c4d441509d33bbdbeca70d05dff5e9d2479"}, - {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ebd8d160f91a764652d3e51ce0d2956b38efe37c9231cd82cfc0bed2e40b581c"}, - {file = "multidict-6.0.5-cp39-cp39-win32.whl", hash = "sha256:04da1bb8c8dbadf2a18a452639771951c662c5ad03aefe4884775454be322c9b"}, - {file = "multidict-6.0.5-cp39-cp39-win_amd64.whl", hash = "sha256:d6f6d4f185481c9669b9447bf9d9cf3b95a0e9df9d169bbc17e363b7d5487755"}, - {file = "multidict-6.0.5-py3-none-any.whl", hash = "sha256:0d63c74e3d7ab26de115c49bffc92cc77ed23395303d496eae515d4204a625e7"}, - {file = "multidict-6.0.5.tar.gz", hash = "sha256:f7e301075edaf50500f0b341543c41194d8df3ae5caf4702f2095f3ca73dd8da"}, -] + {file = "multidict-6.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3380252550e372e8511d49481bd836264c009adb826b23fefcc5dd3c69692f60"}, + {file = "multidict-6.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:99f826cbf970077383d7de805c0681799491cb939c25450b9b5b3ced03ca99f1"}, + {file = "multidict-6.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a114d03b938376557927ab23f1e950827c3b893ccb94b62fd95d430fd0e5cf53"}, + {file = "multidict-6.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1c416351ee6271b2f49b56ad7f308072f6f44b37118d69c2cad94f3fa8a40d5"}, + {file = "multidict-6.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6b5d83030255983181005e6cfbac1617ce9746b219bc2aad52201ad121226581"}, + {file = "multidict-6.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3e97b5e938051226dc025ec80980c285b053ffb1e25a3db2a3aa3bc046bf7f56"}, + {file = "multidict-6.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d618649d4e70ac6efcbba75be98b26ef5078faad23592f9b51ca492953012429"}, + {file = "multidict-6.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10524ebd769727ac77ef2278390fb0068d83f3acb7773792a5080f2b0abf7748"}, + {file = "multidict-6.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ff3827aef427c89a25cc96ded1759271a93603aba9fb977a6d264648ebf989db"}, + {file = "multidict-6.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:06809f4f0f7ab7ea2cabf9caca7d79c22c0758b58a71f9d32943ae13c7ace056"}, + {file = "multidict-6.1.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:f179dee3b863ab1c59580ff60f9d99f632f34ccb38bf67a33ec6b3ecadd0fd76"}, + {file = "multidict-6.1.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:aaed8b0562be4a0876ee3b6946f6869b7bcdb571a5d1496683505944e268b160"}, + {file = "multidict-6.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3c8b88a2ccf5493b6c8da9076fb151ba106960a2df90c2633f342f120751a9e7"}, + {file = "multidict-6.1.0-cp310-cp310-win32.whl", hash = "sha256:4a9cb68166a34117d6646c0023c7b759bf197bee5ad4272f420a0141d7eb03a0"}, + {file = "multidict-6.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:20b9b5fbe0b88d0bdef2012ef7dee867f874b72528cf1d08f1d59b0e3850129d"}, + {file = "multidict-6.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3efe2c2cb5763f2f1b275ad2bf7a287d3f7ebbef35648a9726e3b69284a4f3d6"}, + {file = "multidict-6.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7053d3b0353a8b9de430a4f4b4268ac9a4fb3481af37dfe49825bf45ca24156"}, + {file = "multidict-6.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:27e5fc84ccef8dfaabb09d82b7d179c7cf1a3fbc8a966f8274fcb4ab2eb4cadb"}, + {file = "multidict-6.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e2b90b43e696f25c62656389d32236e049568b39320e2735d51f08fd362761b"}, + {file = "multidict-6.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d83a047959d38a7ff552ff94be767b7fd79b831ad1cd9920662db05fec24fe72"}, + {file = "multidict-6.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d1a9dd711d0877a1ece3d2e4fea11a8e75741ca21954c919406b44e7cf971304"}, + {file = "multidict-6.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec2abea24d98246b94913b76a125e855eb5c434f7c46546046372fe60f666351"}, + {file = "multidict-6.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4867cafcbc6585e4b678876c489b9273b13e9fff9f6d6d66add5e15d11d926cb"}, + {file = "multidict-6.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5b48204e8d955c47c55b72779802b219a39acc3ee3d0116d5080c388970b76e3"}, + {file = "multidict-6.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d8fff389528cad1618fb4b26b95550327495462cd745d879a8c7c2115248e399"}, + {file = "multidict-6.1.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a7a9541cd308eed5e30318430a9c74d2132e9a8cb46b901326272d780bf2d423"}, + {file = "multidict-6.1.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:da1758c76f50c39a2efd5e9859ce7d776317eb1dd34317c8152ac9251fc574a3"}, + {file = "multidict-6.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c943a53e9186688b45b323602298ab727d8865d8c9ee0b17f8d62d14b56f0753"}, + {file = "multidict-6.1.0-cp311-cp311-win32.whl", hash = "sha256:90f8717cb649eea3504091e640a1b8568faad18bd4b9fcd692853a04475a4b80"}, + {file = "multidict-6.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:82176036e65644a6cc5bd619f65f6f19781e8ec2e5330f51aa9ada7504cc1926"}, + {file = "multidict-6.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b04772ed465fa3cc947db808fa306d79b43e896beb677a56fb2347ca1a49c1fa"}, + {file = "multidict-6.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6180c0ae073bddeb5a97a38c03f30c233e0a4d39cd86166251617d1bbd0af436"}, + {file = "multidict-6.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:071120490b47aa997cca00666923a83f02c7fbb44f71cf7f136df753f7fa8761"}, + {file = "multidict-6.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50b3a2710631848991d0bf7de077502e8994c804bb805aeb2925a981de58ec2e"}, + {file = "multidict-6.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b58c621844d55e71c1b7f7c498ce5aa6985d743a1a59034c57a905b3f153c1ef"}, + {file = "multidict-6.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55b6d90641869892caa9ca42ff913f7ff1c5ece06474fbd32fb2cf6834726c95"}, + {file = "multidict-6.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b820514bfc0b98a30e3d85462084779900347e4d49267f747ff54060cc33925"}, + {file = "multidict-6.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10a9b09aba0c5b48c53761b7c720aaaf7cf236d5fe394cd399c7ba662d5f9966"}, + {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e16bf3e5fc9f44632affb159d30a437bfe286ce9e02754759be5536b169b305"}, + {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:76f364861c3bfc98cbbcbd402d83454ed9e01a5224bb3a28bf70002a230f73e2"}, + {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:820c661588bd01a0aa62a1283f20d2be4281b086f80dad9e955e690c75fb54a2"}, + {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0e5f362e895bc5b9e67fe6e4ded2492d8124bdf817827f33c5b46c2fe3ffaca6"}, + {file = "multidict-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ec660d19bbc671e3a6443325f07263be452c453ac9e512f5eb935e7d4ac28b3"}, + {file = "multidict-6.1.0-cp312-cp312-win32.whl", hash = "sha256:58130ecf8f7b8112cdb841486404f1282b9c86ccb30d3519faf301b2e5659133"}, + {file = "multidict-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:188215fc0aafb8e03341995e7c4797860181562380f81ed0a87ff455b70bf1f1"}, + {file = "multidict-6.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d569388c381b24671589335a3be6e1d45546c2988c2ebe30fdcada8457a31008"}, + {file = "multidict-6.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:052e10d2d37810b99cc170b785945421141bf7bb7d2f8799d431e7db229c385f"}, + {file = "multidict-6.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f90c822a402cb865e396a504f9fc8173ef34212a342d92e362ca498cad308e28"}, + {file = "multidict-6.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b225d95519a5bf73860323e633a664b0d85ad3d5bede6d30d95b35d4dfe8805b"}, + {file = "multidict-6.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:23bfd518810af7de1116313ebd9092cb9aa629beb12f6ed631ad53356ed6b86c"}, + {file = "multidict-6.1.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c09fcfdccdd0b57867577b719c69e347a436b86cd83747f179dbf0cc0d4c1f3"}, + {file = "multidict-6.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf6bea52ec97e95560af5ae576bdac3aa3aae0b6758c6efa115236d9e07dae44"}, + {file = "multidict-6.1.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57feec87371dbb3520da6192213c7d6fc892d5589a93db548331954de8248fd2"}, + {file = "multidict-6.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0c3f390dc53279cbc8ba976e5f8035eab997829066756d811616b652b00a23a3"}, + {file = "multidict-6.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:59bfeae4b25ec05b34f1956eaa1cb38032282cd4dfabc5056d0a1ec4d696d3aa"}, + {file = "multidict-6.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b2f59caeaf7632cc633b5cf6fc449372b83bbdf0da4ae04d5be36118e46cc0aa"}, + {file = "multidict-6.1.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:37bb93b2178e02b7b618893990941900fd25b6b9ac0fa49931a40aecdf083fe4"}, + {file = "multidict-6.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4e9f48f58c2c523d5a06faea47866cd35b32655c46b443f163d08c6d0ddb17d6"}, + {file = "multidict-6.1.0-cp313-cp313-win32.whl", hash = "sha256:3a37ffb35399029b45c6cc33640a92bef403c9fd388acce75cdc88f58bd19a81"}, + {file = "multidict-6.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:e9aa71e15d9d9beaad2c6b9319edcdc0a49a43ef5c0a4c8265ca9ee7d6c67774"}, + {file = "multidict-6.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:db7457bac39421addd0c8449933ac32d8042aae84a14911a757ae6ca3eef1392"}, + {file = "multidict-6.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d094ddec350a2fb899fec68d8353c78233debde9b7d8b4beeafa70825f1c281a"}, + {file = "multidict-6.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5845c1fd4866bb5dd3125d89b90e57ed3138241540897de748cdf19de8a2fca2"}, + {file = "multidict-6.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9079dfc6a70abe341f521f78405b8949f96db48da98aeb43f9907f342f627cdc"}, + {file = "multidict-6.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3914f5aaa0f36d5d60e8ece6a308ee1c9784cd75ec8151062614657a114c4478"}, + {file = "multidict-6.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c08be4f460903e5a9d0f76818db3250f12e9c344e79314d1d570fc69d7f4eae4"}, + {file = "multidict-6.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d093be959277cb7dee84b801eb1af388b6ad3ca6a6b6bf1ed7585895789d027d"}, + {file = "multidict-6.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3702ea6872c5a2a4eeefa6ffd36b042e9773f05b1f37ae3ef7264b1163c2dcf6"}, + {file = "multidict-6.1.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:2090f6a85cafc5b2db085124d752757c9d251548cedabe9bd31afe6363e0aff2"}, + {file = "multidict-6.1.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:f67f217af4b1ff66c68a87318012de788dd95fcfeb24cc889011f4e1c7454dfd"}, + {file = "multidict-6.1.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:189f652a87e876098bbc67b4da1049afb5f5dfbaa310dd67c594b01c10388db6"}, + {file = "multidict-6.1.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:6bb5992037f7a9eff7991ebe4273ea7f51f1c1c511e6a2ce511d0e7bdb754492"}, + {file = "multidict-6.1.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:ac10f4c2b9e770c4e393876e35a7046879d195cd123b4f116d299d442b335bcd"}, + {file = "multidict-6.1.0-cp38-cp38-win32.whl", hash = "sha256:e27bbb6d14416713a8bd7aaa1313c0fc8d44ee48d74497a0ff4c3a1b6ccb5167"}, + {file = "multidict-6.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:22f3105d4fb15c8f57ff3959a58fcab6ce36814486500cd7485651230ad4d4ef"}, + {file = "multidict-6.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:4e18b656c5e844539d506a0a06432274d7bd52a7487e6828c63a63d69185626c"}, + {file = "multidict-6.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a185f876e69897a6f3325c3f19f26a297fa058c5e456bfcff8015e9a27e83ae1"}, + {file = "multidict-6.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ab7c4ceb38d91570a650dba194e1ca87c2b543488fe9309b4212694174fd539c"}, + {file = "multidict-6.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e617fb6b0b6953fffd762669610c1c4ffd05632c138d61ac7e14ad187870669c"}, + {file = "multidict-6.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:16e5f4bf4e603eb1fdd5d8180f1a25f30056f22e55ce51fb3d6ad4ab29f7d96f"}, + {file = "multidict-6.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f4c035da3f544b1882bac24115f3e2e8760f10a0107614fc9839fd232200b875"}, + {file = "multidict-6.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:957cf8e4b6e123a9eea554fa7ebc85674674b713551de587eb318a2df3e00255"}, + {file = "multidict-6.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:483a6aea59cb89904e1ceabd2b47368b5600fb7de78a6e4a2c2987b2d256cf30"}, + {file = "multidict-6.1.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:87701f25a2352e5bf7454caa64757642734da9f6b11384c1f9d1a8e699758057"}, + {file = "multidict-6.1.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:682b987361e5fd7a139ed565e30d81fd81e9629acc7d925a205366877d8c8657"}, + {file = "multidict-6.1.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ce2186a7df133a9c895dea3331ddc5ddad42cdd0d1ea2f0a51e5d161e4762f28"}, + {file = "multidict-6.1.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:9f636b730f7e8cb19feb87094949ba54ee5357440b9658b2a32a5ce4bce53972"}, + {file = "multidict-6.1.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:73eae06aa53af2ea5270cc066dcaf02cc60d2994bbb2c4ef5764949257d10f43"}, + {file = "multidict-6.1.0-cp39-cp39-win32.whl", hash = "sha256:1ca0083e80e791cffc6efce7660ad24af66c8d4079d2a750b29001b53ff59ada"}, + {file = "multidict-6.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:aa466da5b15ccea564bdab9c89175c762bc12825f4659c11227f515cee76fa4a"}, + {file = "multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506"}, + {file = "multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.1.0", markers = "python_version < \"3.11\""} [[package]] name = "nbclient" @@ -2575,13 +2745,13 @@ test = ["pep440", "pre-commit", "pytest", "testpath"] [[package]] name = "nbsphinx" -version = "0.9.4" +version = "0.9.5" description = "Jupyter Notebook Tools for Sphinx" optional = false python-versions = ">=3.6" files = [ - {file = "nbsphinx-0.9.4-py3-none-any.whl", hash = "sha256:22cb1d974a8300e8118ca71aea1f649553743c0c5830a54129dcd446e6a8ba17"}, - {file = "nbsphinx-0.9.4.tar.gz", hash = "sha256:042a60806fc23d519bc5bef59d95570713913fe442fda759d53e3aaf62104794"}, + {file = "nbsphinx-0.9.5-py3-none-any.whl", hash = "sha256:d82f71084425db1f48e72515f15c25b4de8652ceaab513ee462ac05f1b8eae0a"}, + {file = "nbsphinx-0.9.5.tar.gz", hash = "sha256:736916e7b0dab28fc904f4a9ae3b53a9a50c29fccc6329c052fcc7485abcf2b7"}, ] [package.dependencies] @@ -2713,19 +2883,19 @@ requests = ">=2.19.0" [[package]] name = "openpulse" -version = "0.5.0" +version = "1.0.0" description = "Reference OpenPulse AST in Python" optional = false python-versions = "*" files = [ - {file = "openpulse-0.5.0-py3-none-any.whl", hash = "sha256:c91b69633366381f3fdbc0c9be8c37c114b2d8e469f667ff9b0f78632e00c395"}, - {file = "openpulse-0.5.0.tar.gz", hash = "sha256:d7b1d940c0e081975f5ebdad2b378d24e4a612b73fce1bc2e26948d907f5db1c"}, + {file = "openpulse-1.0.0-py3-none-any.whl", hash = "sha256:5abf56758cadd0ad39035511b280bb1ef916d2fc60ec914566559425eef832f8"}, + {file = "openpulse-1.0.0.tar.gz", hash = "sha256:f46021d953f5ee84a4ad62fb166a11bad73fa235531c4f10be486ed9f4eca33d"}, ] [package.dependencies] -antlr4-python3-runtime = ">=4.7,<4.12" +antlr4-python3-runtime = ">=4.7,<4.14" importlib-metadata = {version = "*", markers = "python_version < \"3.10\""} -openqasm3 = {version = ">=0.5.0", extras = ["parser"]} +openqasm3 = {version = ">=1.0.0,<2.0", extras = ["parser"]} [package.extras] all = ["pytest (>=6.0)", "pyyaml"] @@ -2733,13 +2903,13 @@ tests = ["pytest (>=6.0)", "pyyaml"] [[package]] name = "openqasm3" -version = "0.5.0" +version = "1.0.0" description = "Reference OpenQASM AST in Python" optional = false python-versions = "*" files = [ - {file = "openqasm3-0.5.0-py3-none-any.whl", hash = "sha256:40991ac057b9e3c208d1b34242b0aad8a3b9840df0335a652b1e4e4248937b1c"}, - {file = "openqasm3-0.5.0.tar.gz", hash = "sha256:bf8bf4ed098393447e552eaea18b0a34a2429d228477683d6b579348bc17bfc8"}, + {file = "openqasm3-1.0.0-py3-none-any.whl", hash = "sha256:d4371737b4a49b0d56248ed3d30766a94000bccfb43303ec9c7ead351a1b6cc3"}, + {file = "openqasm3-1.0.0.tar.gz", hash = "sha256:3f2bb1cca855cff114e046bac22d59adbf9b754cac6398961aa6d22588fb688e"}, ] [package.dependencies] @@ -2751,70 +2921,108 @@ all = ["antlr4-python3-runtime (>=4.7,<4.14)", "importlib-metadata", "pytest (>= parser = ["antlr4-python3-runtime (>=4.7,<4.14)", "importlib-metadata"] tests = ["pytest (>=6.0)", "pyyaml"] +[[package]] +name = "optuna" +version = "4.0.0" +description = "A hyperparameter optimization framework" +optional = false +python-versions = ">=3.7" +files = [ + {file = "optuna-4.0.0-py3-none-any.whl", hash = "sha256:a825c32d13f6085bcb2229b2724a5078f2e0f61a7533e800e580ce41a8c6c10d"}, + {file = "optuna-4.0.0.tar.gz", hash = "sha256:844949f09e2a7353ab414e9cfd783cf0a647a65fc32a7236212ed6a37fe08973"}, +] + +[package.dependencies] +alembic = ">=1.5.0" +colorlog = "*" +numpy = "*" +packaging = ">=20.0" +PyYAML = "*" +sqlalchemy = ">=1.3.0" +tqdm = "*" + +[package.extras] +benchmark = ["asv (>=0.5.0)", "botorch", "cma", "virtualenv"] +checking = ["black", "blackdoc", "flake8", "isort", "mypy", "mypy-boto3-s3", "types-PyYAML", "types-redis", "types-setuptools", "types-tqdm", "typing-extensions (>=3.10.0.0)"] +document = ["ase", "cmaes (>=0.10.0)", "fvcore", "kaleido", "lightgbm", "matplotlib (!=3.6.0)", "pandas", "pillow", "plotly (>=4.9.0)", "scikit-learn", "sphinx", "sphinx-copybutton", "sphinx-gallery", "sphinx-rtd-theme (>=1.2.0)", "torch", "torchvision"] +optional = ["boto3", "cmaes (>=0.10.0)", "google-cloud-storage", "matplotlib (!=3.6.0)", "pandas", "plotly (>=4.9.0)", "redis", "scikit-learn (>=0.24.2)", "scipy", "torch"] +test = ["coverage", "fakeredis[lua]", "kaleido", "moto", "pytest", "scipy (>=1.9.2)", "torch"] + [[package]] name = "orjson" -version = "3.10.3" +version = "3.10.7" description = "Fast, correct Python JSON library supporting dataclasses, datetimes, and numpy" optional = false python-versions = ">=3.8" files = [ - {file = "orjson-3.10.3-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9fb6c3f9f5490a3eb4ddd46fc1b6eadb0d6fc16fb3f07320149c3286a1409dd8"}, - {file = "orjson-3.10.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:252124b198662eee80428f1af8c63f7ff077c88723fe206a25df8dc57a57b1fa"}, - {file = "orjson-3.10.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9f3e87733823089a338ef9bbf363ef4de45e5c599a9bf50a7a9b82e86d0228da"}, - {file = "orjson-3.10.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c8334c0d87103bb9fbbe59b78129f1f40d1d1e8355bbed2ca71853af15fa4ed3"}, - {file = "orjson-3.10.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1952c03439e4dce23482ac846e7961f9d4ec62086eb98ae76d97bd41d72644d7"}, - {file = "orjson-3.10.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c0403ed9c706dcd2809f1600ed18f4aae50be263bd7112e54b50e2c2bc3ebd6d"}, - {file = "orjson-3.10.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:382e52aa4270a037d41f325e7d1dfa395b7de0c367800b6f337d8157367bf3a7"}, - {file = "orjson-3.10.3-cp310-none-win32.whl", hash = "sha256:be2aab54313752c04f2cbaab4515291ef5af8c2256ce22abc007f89f42f49109"}, - {file = "orjson-3.10.3-cp310-none-win_amd64.whl", hash = "sha256:416b195f78ae461601893f482287cee1e3059ec49b4f99479aedf22a20b1098b"}, - {file = "orjson-3.10.3-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:73100d9abbbe730331f2242c1fc0bcb46a3ea3b4ae3348847e5a141265479700"}, - {file = "orjson-3.10.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:544a12eee96e3ab828dbfcb4d5a0023aa971b27143a1d35dc214c176fdfb29b3"}, - {file = "orjson-3.10.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:520de5e2ef0b4ae546bea25129d6c7c74edb43fc6cf5213f511a927f2b28148b"}, - {file = "orjson-3.10.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ccaa0a401fc02e8828a5bedfd80f8cd389d24f65e5ca3954d72c6582495b4bcf"}, - {file = "orjson-3.10.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a7bc9e8bc11bac40f905640acd41cbeaa87209e7e1f57ade386da658092dc16"}, - {file = "orjson-3.10.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3582b34b70543a1ed6944aca75e219e1192661a63da4d039d088a09c67543b08"}, - {file = "orjson-3.10.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1c23dfa91481de880890d17aa7b91d586a4746a4c2aa9a145bebdbaf233768d5"}, - {file = "orjson-3.10.3-cp311-none-win32.whl", hash = "sha256:1770e2a0eae728b050705206d84eda8b074b65ee835e7f85c919f5705b006c9b"}, - {file = "orjson-3.10.3-cp311-none-win_amd64.whl", hash = "sha256:93433b3c1f852660eb5abdc1f4dd0ced2be031ba30900433223b28ee0140cde5"}, - {file = "orjson-3.10.3-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:a39aa73e53bec8d410875683bfa3a8edf61e5a1c7bb4014f65f81d36467ea098"}, - {file = "orjson-3.10.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0943a96b3fa09bee1afdfccc2cb236c9c64715afa375b2af296c73d91c23eab2"}, - {file = "orjson-3.10.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e852baafceff8da3c9defae29414cc8513a1586ad93e45f27b89a639c68e8176"}, - {file = "orjson-3.10.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18566beb5acd76f3769c1d1a7ec06cdb81edc4d55d2765fb677e3eaa10fa99e0"}, - {file = "orjson-3.10.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bd2218d5a3aa43060efe649ec564ebedec8ce6ae0a43654b81376216d5ebd42"}, - {file = "orjson-3.10.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cf20465e74c6e17a104ecf01bf8cd3b7b252565b4ccee4548f18b012ff2f8069"}, - {file = "orjson-3.10.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba7f67aa7f983c4345eeda16054a4677289011a478ca947cd69c0a86ea45e534"}, - {file = "orjson-3.10.3-cp312-none-win32.whl", hash = "sha256:17e0713fc159abc261eea0f4feda611d32eabc35708b74bef6ad44f6c78d5ea0"}, - {file = "orjson-3.10.3-cp312-none-win_amd64.whl", hash = "sha256:4c895383b1ec42b017dd2c75ae8a5b862fc489006afde06f14afbdd0309b2af0"}, - {file = "orjson-3.10.3-cp38-cp38-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:be2719e5041e9fb76c8c2c06b9600fe8e8584e6980061ff88dcbc2691a16d20d"}, - {file = "orjson-3.10.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb0175a5798bdc878956099f5c54b9837cb62cfbf5d0b86ba6d77e43861bcec2"}, - {file = "orjson-3.10.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:978be58a68ade24f1af7758626806e13cff7748a677faf95fbb298359aa1e20d"}, - {file = "orjson-3.10.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:16bda83b5c61586f6f788333d3cf3ed19015e3b9019188c56983b5a299210eb5"}, - {file = "orjson-3.10.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ad1f26bea425041e0a1adad34630c4825a9e3adec49079b1fb6ac8d36f8b754"}, - {file = "orjson-3.10.3-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:9e253498bee561fe85d6325ba55ff2ff08fb5e7184cd6a4d7754133bd19c9195"}, - {file = "orjson-3.10.3-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0a62f9968bab8a676a164263e485f30a0b748255ee2f4ae49a0224be95f4532b"}, - {file = "orjson-3.10.3-cp38-none-win32.whl", hash = "sha256:8d0b84403d287d4bfa9bf7d1dc298d5c1c5d9f444f3737929a66f2fe4fb8f134"}, - {file = "orjson-3.10.3-cp38-none-win_amd64.whl", hash = "sha256:8bc7a4df90da5d535e18157220d7915780d07198b54f4de0110eca6b6c11e290"}, - {file = "orjson-3.10.3-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9059d15c30e675a58fdcd6f95465c1522b8426e092de9fff20edebfdc15e1cb0"}, - {file = "orjson-3.10.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8d40c7f7938c9c2b934b297412c067936d0b54e4b8ab916fd1a9eb8f54c02294"}, - {file = "orjson-3.10.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d4a654ec1de8fdaae1d80d55cee65893cb06494e124681ab335218be6a0691e7"}, - {file = "orjson-3.10.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:831c6ef73f9aa53c5f40ae8f949ff7681b38eaddb6904aab89dca4d85099cb78"}, - {file = "orjson-3.10.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99b880d7e34542db89f48d14ddecbd26f06838b12427d5a25d71baceb5ba119d"}, - {file = "orjson-3.10.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2e5e176c994ce4bd434d7aafb9ecc893c15f347d3d2bbd8e7ce0b63071c52e25"}, - {file = "orjson-3.10.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b69a58a37dab856491bf2d3bbf259775fdce262b727f96aafbda359cb1d114d8"}, - {file = "orjson-3.10.3-cp39-none-win32.whl", hash = "sha256:b8d4d1a6868cde356f1402c8faeb50d62cee765a1f7ffcfd6de732ab0581e063"}, - {file = "orjson-3.10.3-cp39-none-win_amd64.whl", hash = "sha256:5102f50c5fc46d94f2033fe00d392588564378260d64377aec702f21a7a22912"}, - {file = "orjson-3.10.3.tar.gz", hash = "sha256:2b166507acae7ba2f7c315dcf185a9111ad5e992ac81f2d507aac39193c2c818"}, + {file = "orjson-3.10.7-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:74f4544f5a6405b90da8ea724d15ac9c36da4d72a738c64685003337401f5c12"}, + {file = "orjson-3.10.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:34a566f22c28222b08875b18b0dfbf8a947e69df21a9ed5c51a6bf91cfb944ac"}, + {file = "orjson-3.10.7-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bf6ba8ebc8ef5792e2337fb0419f8009729335bb400ece005606336b7fd7bab7"}, + {file = "orjson-3.10.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac7cf6222b29fbda9e3a472b41e6a5538b48f2c8f99261eecd60aafbdb60690c"}, + {file = "orjson-3.10.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:de817e2f5fc75a9e7dd350c4b0f54617b280e26d1631811a43e7e968fa71e3e9"}, + {file = "orjson-3.10.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:348bdd16b32556cf8d7257b17cf2bdb7ab7976af4af41ebe79f9796c218f7e91"}, + {file = "orjson-3.10.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:479fd0844ddc3ca77e0fd99644c7fe2de8e8be1efcd57705b5c92e5186e8a250"}, + {file = "orjson-3.10.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:fdf5197a21dd660cf19dfd2a3ce79574588f8f5e2dbf21bda9ee2d2b46924d84"}, + {file = "orjson-3.10.7-cp310-none-win32.whl", hash = "sha256:d374d36726746c81a49f3ff8daa2898dccab6596864ebe43d50733275c629175"}, + {file = "orjson-3.10.7-cp310-none-win_amd64.whl", hash = "sha256:cb61938aec8b0ffb6eef484d480188a1777e67b05d58e41b435c74b9d84e0b9c"}, + {file = "orjson-3.10.7-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:7db8539039698ddfb9a524b4dd19508256107568cdad24f3682d5773e60504a2"}, + {file = "orjson-3.10.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:480f455222cb7a1dea35c57a67578848537d2602b46c464472c995297117fa09"}, + {file = "orjson-3.10.7-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8a9c9b168b3a19e37fe2778c0003359f07822c90fdff8f98d9d2a91b3144d8e0"}, + {file = "orjson-3.10.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8de062de550f63185e4c1c54151bdddfc5625e37daf0aa1e75d2a1293e3b7d9a"}, + {file = "orjson-3.10.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b0dd04483499d1de9c8f6203f8975caf17a6000b9c0c54630cef02e44ee624e"}, + {file = "orjson-3.10.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b58d3795dafa334fc8fd46f7c5dc013e6ad06fd5b9a4cc98cb1456e7d3558bd6"}, + {file = "orjson-3.10.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:33cfb96c24034a878d83d1a9415799a73dc77480e6c40417e5dda0710d559ee6"}, + {file = "orjson-3.10.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e724cebe1fadc2b23c6f7415bad5ee6239e00a69f30ee423f319c6af70e2a5c0"}, + {file = "orjson-3.10.7-cp311-none-win32.whl", hash = "sha256:82763b46053727a7168d29c772ed5c870fdae2f61aa8a25994c7984a19b1021f"}, + {file = "orjson-3.10.7-cp311-none-win_amd64.whl", hash = "sha256:eb8d384a24778abf29afb8e41d68fdd9a156cf6e5390c04cc07bbc24b89e98b5"}, + {file = "orjson-3.10.7-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:44a96f2d4c3af51bfac6bc4ef7b182aa33f2f054fd7f34cc0ee9a320d051d41f"}, + {file = "orjson-3.10.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76ac14cd57df0572453543f8f2575e2d01ae9e790c21f57627803f5e79b0d3c3"}, + {file = "orjson-3.10.7-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bdbb61dcc365dd9be94e8f7df91975edc9364d6a78c8f7adb69c1cdff318ec93"}, + {file = "orjson-3.10.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b48b3db6bb6e0a08fa8c83b47bc169623f801e5cc4f24442ab2b6617da3b5313"}, + {file = "orjson-3.10.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:23820a1563a1d386414fef15c249040042b8e5d07b40ab3fe3efbfbbcbcb8864"}, + {file = "orjson-3.10.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0c6a008e91d10a2564edbb6ee5069a9e66df3fbe11c9a005cb411f441fd2c09"}, + {file = "orjson-3.10.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d352ee8ac1926d6193f602cbe36b1643bbd1bbcb25e3c1a657a4390f3000c9a5"}, + {file = "orjson-3.10.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d2d9f990623f15c0ae7ac608103c33dfe1486d2ed974ac3f40b693bad1a22a7b"}, + {file = "orjson-3.10.7-cp312-none-win32.whl", hash = "sha256:7c4c17f8157bd520cdb7195f75ddbd31671997cbe10aee559c2d613592e7d7eb"}, + {file = "orjson-3.10.7-cp312-none-win_amd64.whl", hash = "sha256:1d9c0e733e02ada3ed6098a10a8ee0052dd55774de3d9110d29868d24b17faa1"}, + {file = "orjson-3.10.7-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:77d325ed866876c0fa6492598ec01fe30e803272a6e8b10e992288b009cbe149"}, + {file = "orjson-3.10.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ea2c232deedcb605e853ae1db2cc94f7390ac776743b699b50b071b02bea6fe"}, + {file = "orjson-3.10.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3dcfbede6737fdbef3ce9c37af3fb6142e8e1ebc10336daa05872bfb1d87839c"}, + {file = "orjson-3.10.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:11748c135f281203f4ee695b7f80bb1358a82a63905f9f0b794769483ea854ad"}, + {file = "orjson-3.10.7-cp313-none-win32.whl", hash = "sha256:a7e19150d215c7a13f39eb787d84db274298d3f83d85463e61d277bbd7f401d2"}, + {file = "orjson-3.10.7-cp313-none-win_amd64.whl", hash = "sha256:eef44224729e9525d5261cc8d28d6b11cafc90e6bd0be2157bde69a52ec83024"}, + {file = "orjson-3.10.7-cp38-cp38-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:6ea2b2258eff652c82652d5e0f02bd5e0463a6a52abb78e49ac288827aaa1469"}, + {file = "orjson-3.10.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:430ee4d85841e1483d487e7b81401785a5dfd69db5de01314538f31f8fbf7ee1"}, + {file = "orjson-3.10.7-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4b6146e439af4c2472c56f8540d799a67a81226e11992008cb47e1267a9b3225"}, + {file = "orjson-3.10.7-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:084e537806b458911137f76097e53ce7bf5806dda33ddf6aaa66a028f8d43a23"}, + {file = "orjson-3.10.7-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4829cf2195838e3f93b70fd3b4292156fc5e097aac3739859ac0dcc722b27ac0"}, + {file = "orjson-3.10.7-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1193b2416cbad1a769f868b1749535d5da47626ac29445803dae7cc64b3f5c98"}, + {file = "orjson-3.10.7-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:4e6c3da13e5a57e4b3dca2de059f243ebec705857522f188f0180ae88badd354"}, + {file = "orjson-3.10.7-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:c31008598424dfbe52ce8c5b47e0752dca918a4fdc4a2a32004efd9fab41d866"}, + {file = "orjson-3.10.7-cp38-none-win32.whl", hash = "sha256:7122a99831f9e7fe977dc45784d3b2edc821c172d545e6420c375e5a935f5a1c"}, + {file = "orjson-3.10.7-cp38-none-win_amd64.whl", hash = "sha256:a763bc0e58504cc803739e7df040685816145a6f3c8a589787084b54ebc9f16e"}, + {file = "orjson-3.10.7-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:e76be12658a6fa376fcd331b1ea4e58f5a06fd0220653450f0d415b8fd0fbe20"}, + {file = "orjson-3.10.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed350d6978d28b92939bfeb1a0570c523f6170efc3f0a0ef1f1df287cd4f4960"}, + {file = "orjson-3.10.7-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:144888c76f8520e39bfa121b31fd637e18d4cc2f115727865fdf9fa325b10412"}, + {file = "orjson-3.10.7-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:09b2d92fd95ad2402188cf51573acde57eb269eddabaa60f69ea0d733e789fe9"}, + {file = "orjson-3.10.7-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5b24a579123fa884f3a3caadaed7b75eb5715ee2b17ab5c66ac97d29b18fe57f"}, + {file = "orjson-3.10.7-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e72591bcfe7512353bd609875ab38050efe3d55e18934e2f18950c108334b4ff"}, + {file = "orjson-3.10.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:f4db56635b58cd1a200b0a23744ff44206ee6aa428185e2b6c4a65b3197abdcd"}, + {file = "orjson-3.10.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:0fa5886854673222618638c6df7718ea7fe2f3f2384c452c9ccedc70b4a510a5"}, + {file = "orjson-3.10.7-cp39-none-win32.whl", hash = "sha256:8272527d08450ab16eb405f47e0f4ef0e5ff5981c3d82afe0efd25dcbef2bcd2"}, + {file = "orjson-3.10.7-cp39-none-win_amd64.whl", hash = "sha256:974683d4618c0c7dbf4f69c95a979734bf183d0658611760017f6e70a145af58"}, + {file = "orjson-3.10.7.tar.gz", hash = "sha256:75ef0640403f945f3a1f9f6400686560dbfb0fb5b16589ad62cd477043c4eee3"}, ] [[package]] name = "packaging" -version = "24.0" +version = "24.1" description = "Core utilities for Python packages" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"}, - {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, + {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"}, + {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"}, ] [[package]] @@ -2825,6 +3033,7 @@ optional = false python-versions = ">=3.9" files = [ {file = "pandas-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90c6fca2acf139569e74e8781709dccb6fe25940488755716d1d354d6bc58bce"}, + {file = "pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7adfc142dac335d8c1e0dcbd37eb8617eac386596eb9e1a1b77791cf2498238"}, {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4abfe0be0d7221be4f12552995e58723c7422c80a659da13ca382697de830c08"}, {file = "pandas-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8635c16bf3d99040fdf3ca3db669a7250ddf49c55dc4aa8fe0ae0fa8d6dcc1f0"}, {file = "pandas-2.2.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:40ae1dffb3967a52203105a077415a86044a2bea011b5f321c6aa64b379a3f51"}, @@ -2838,12 +3047,14 @@ files = [ {file = "pandas-2.2.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0cace394b6ea70c01ca1595f839cf193df35d1575986e484ad35c4aeae7266c1"}, {file = "pandas-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:873d13d177501a28b2756375d59816c365e42ed8417b41665f346289adc68d24"}, {file = "pandas-2.2.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9dfde2a0ddef507a631dc9dc4af6a9489d5e2e740e226ad426a05cabfbd7c8ef"}, + {file = "pandas-2.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e9b79011ff7a0f4b1d6da6a61aa1aa604fb312d6647de5bad20013682d1429ce"}, {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cb51fe389360f3b5a4d57dbd2848a5f033350336ca3b340d1c53a1fad33bcad"}, {file = "pandas-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eee3a87076c0756de40b05c5e9a6069c035ba43e8dd71c379e68cab2c20f16ad"}, {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3e374f59e440d4ab45ca2fffde54b81ac3834cf5ae2cdfa69c90bc03bde04d76"}, {file = "pandas-2.2.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:43498c0bdb43d55cb162cdc8c06fac328ccb5d2eabe3cadeb3529ae6f0517c32"}, {file = "pandas-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:d187d355ecec3629624fccb01d104da7d7f391db0311145817525281e2804d23"}, {file = "pandas-2.2.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0ca6377b8fca51815f382bd0b697a0814c8bda55115678cbc94c30aacbb6eff2"}, + {file = "pandas-2.2.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9057e6aa78a584bc93a13f0a9bf7e753a5e9770a30b4d758b8d5f2a62a9433cd"}, {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:001910ad31abc7bf06f49dcc903755d2f7f3a9186c0c040b827e522e9cef0863"}, {file = "pandas-2.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66b479b0bd07204e37583c191535505410daa8df638fd8e75ae1b383851fe921"}, {file = "pandas-2.2.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a77e9d1c386196879aa5eb712e77461aaee433e54c68cf253053a73b7e49c33a"}, @@ -2856,6 +3067,7 @@ files = [ numpy = [ {version = ">=1.22.4", markers = "python_version < \"3.11\""}, {version = ">=1.23.2", markers = "python_version == \"3.11\""}, + {version = ">=1.26.0", markers = "python_version >= \"3.12\""}, ] python-dateutil = ">=2.8.2" pytz = ">=2020.1" @@ -2948,84 +3160,95 @@ ptyprocess = ">=0.5" [[package]] name = "pillow" -version = "10.3.0" +version = "10.4.0" description = "Python Imaging Library (Fork)" optional = false python-versions = ">=3.8" files = [ - {file = "pillow-10.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45"}, - {file = "pillow-10.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf"}, - {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3"}, - {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5"}, - {file = "pillow-10.3.0-cp310-cp310-win32.whl", hash = "sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2"}, - {file = "pillow-10.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f"}, - {file = "pillow-10.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b"}, - {file = "pillow-10.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795"}, - {file = "pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd"}, - {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad"}, - {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c"}, - {file = "pillow-10.3.0-cp311-cp311-win32.whl", hash = "sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09"}, - {file = "pillow-10.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d"}, - {file = "pillow-10.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f"}, - {file = "pillow-10.3.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84"}, - {file = "pillow-10.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a"}, - {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef"}, - {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3"}, - {file = "pillow-10.3.0-cp312-cp312-win32.whl", hash = "sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d"}, - {file = "pillow-10.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b"}, - {file = "pillow-10.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a"}, - {file = "pillow-10.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b"}, - {file = "pillow-10.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd"}, - {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d"}, - {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3"}, - {file = "pillow-10.3.0-cp38-cp38-win32.whl", hash = "sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b"}, - {file = "pillow-10.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999"}, - {file = "pillow-10.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936"}, - {file = "pillow-10.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8"}, - {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9"}, - {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb"}, - {file = "pillow-10.3.0-cp39-cp39-win32.whl", hash = "sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572"}, - {file = "pillow-10.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb"}, - {file = "pillow-10.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591"}, - {file = "pillow-10.3.0.tar.gz", hash = "sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d"}, -] - -[package.extras] -docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] + {file = "pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e"}, + {file = "pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc"}, + {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e"}, + {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46"}, + {file = "pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984"}, + {file = "pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141"}, + {file = "pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1"}, + {file = "pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c"}, + {file = "pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319"}, + {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d"}, + {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696"}, + {file = "pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496"}, + {file = "pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91"}, + {file = "pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22"}, + {file = "pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94"}, + {file = "pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a"}, + {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b"}, + {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9"}, + {file = "pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42"}, + {file = "pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a"}, + {file = "pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9"}, + {file = "pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3"}, + {file = "pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc"}, + {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a"}, + {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309"}, + {file = "pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060"}, + {file = "pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea"}, + {file = "pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d"}, + {file = "pillow-10.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8d4d5063501b6dd4024b8ac2f04962d661222d120381272deea52e3fc52d3736"}, + {file = "pillow-10.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15e02e9bb4c21e39876698abf233c8c579127986f8207200bc8a8f6bb27acf2"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:43efea75eb06b95d1631cb784aa40156177bf9dd5b4b03ff38979e048258bc6b"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:950be4d8ba92aca4b2bb0741285a46bfae3ca699ef913ec8416c1b78eadd64cd"}, + {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d7480af14364494365e89d6fddc510a13e5a2c3584cb19ef65415ca57252fb84"}, + {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:73664fe514b34c8f02452ffb73b7a92c6774e39a647087f83d67f010eb9a0cf0"}, + {file = "pillow-10.4.0-cp38-cp38-win32.whl", hash = "sha256:e88d5e6ad0d026fba7bdab8c3f225a69f063f116462c49892b0149e21b6c0a0e"}, + {file = "pillow-10.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab"}, + {file = "pillow-10.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0ae24a547e8b711ccaaf99c9ae3cd975470e1a30caa80a6aaee9a2f19c05701d"}, + {file = "pillow-10.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134ace6dc392116566980ee7436477d844520a26a4b1bd4053f6f47d096997fd"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:c76e5786951e72ed3686e122d14c5d7012f16c8303a674d18cdcd6d89557fc5b"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b2724fdb354a868ddf9a880cb84d102da914e99119211ef7ecbdc613b8c96b3c"}, + {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dbc6ae66518ab3c5847659e9988c3b60dc94ffb48ef9168656e0019a93dbf8a1"}, + {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:06b2f7898047ae93fad74467ec3d28fe84f7831370e3c258afa533f81ef7f3df"}, + {file = "pillow-10.4.0-cp39-cp39-win32.whl", hash = "sha256:7970285ab628a3779aecc35823296a7869f889b8329c16ad5a71e4901a3dc4ef"}, + {file = "pillow-10.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5"}, + {file = "pillow-10.4.0-cp39-cp39-win_arm64.whl", hash = "sha256:32cda9e3d601a52baccb2856b8ea1fc213c90b340c542dcef77140dfa3278a9e"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a02364621fe369e06200d4a16558e056fe2805d3468350df3aef21e00d26214b"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b885f89040bb8c4a1573566bbb2f44f5c505ef6e74cec7ab9068c900047f04b"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:2db98790afc70118bd0255c2eeb465e9767ecf1f3c25f9a1abb8ffc8cfd1fe0a"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f7baece4ce06bade126fb84b8af1c33439a76d8a6fd818970215e0560ca28c27"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=7.3)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinxext-opengraph"] fpx = ["olefile"] mic = ["olefile"] tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] @@ -3034,29 +3257,29 @@ xmp = ["defusedxml"] [[package]] name = "platformdirs" -version = "4.2.2" +version = "4.3.6" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." optional = false python-versions = ">=3.8" files = [ - {file = "platformdirs-4.2.2-py3-none-any.whl", hash = "sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee"}, - {file = "platformdirs-4.2.2.tar.gz", hash = "sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3"}, + {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, + {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, ] [package.extras] -docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] -test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"] -type = ["mypy (>=1.8)"] +docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.2)", "pytest-cov (>=5)", "pytest-mock (>=3.14)"] +type = ["mypy (>=1.11.2)"] [[package]] name = "plotly" -version = "5.22.0" +version = "5.24.1" description = "An open-source, interactive data visualization library for Python" optional = false python-versions = ">=3.8" files = [ - {file = "plotly-5.22.0-py3-none-any.whl", hash = "sha256:68fc1901f098daeb233cc3dd44ec9dc31fb3ca4f4e53189344199c43496ed006"}, - {file = "plotly-5.22.0.tar.gz", hash = "sha256:859fdadbd86b5770ae2466e542b761b247d1c6b49daed765b95bb8c7063e7469"}, + {file = "plotly-5.24.1-py3-none-any.whl", hash = "sha256:f67073a1e637eb0dc3e46324d9d51e2fe76e9727c892dde64ddf1e1b51f29089"}, + {file = "plotly-5.24.1.tar.gz", hash = "sha256:dbc8ac8339d248a4bcc36e08a5659bacfe1b079390b8953533f4eb22169b4bae"}, ] [package.dependencies] @@ -3080,13 +3303,13 @@ testing = ["pytest", "pytest-benchmark"] [[package]] name = "portalocker" -version = "2.8.2" +version = "2.10.1" description = "Wraps the portalocker recipe for easy usage" optional = false python-versions = ">=3.8" files = [ - {file = "portalocker-2.8.2-py3-none-any.whl", hash = "sha256:cfb86acc09b9aa7c3b43594e19be1345b9d16af3feb08bf92f23d4dce513a28e"}, - {file = "portalocker-2.8.2.tar.gz", hash = "sha256:2b035aa7828e46c58e9b31390ee1f169b98e1066ab10b9a6a861fe7e25ee4f33"}, + {file = "portalocker-2.10.1-py3-none-any.whl", hash = "sha256:53a5984ebc86a025552264b459b46a2086e269b21823cb572f8f28ee759e45bf"}, + {file = "portalocker-2.10.1.tar.gz", hash = "sha256:ef1bf844e878ab08aee7e40184156e1151f228f103aa5c6bd0724cc330960f8f"}, ] [package.dependencies] @@ -3099,13 +3322,13 @@ tests = ["pytest (>=5.4.1)", "pytest-cov (>=2.8.1)", "pytest-mypy (>=0.8.0)", "p [[package]] name = "prompt-toolkit" -version = "3.0.43" +version = "3.0.47" description = "Library for building powerful interactive command lines in Python" optional = false python-versions = ">=3.7.0" files = [ - {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"}, - {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"}, + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, ] [package.dependencies] @@ -3113,20 +3336,20 @@ wcwidth = "*" [[package]] name = "proto-plus" -version = "1.23.0" +version = "1.24.0" description = "Beautiful, Pythonic protocol buffers." optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" files = [ - {file = "proto-plus-1.23.0.tar.gz", hash = "sha256:89075171ef11988b3fa157f5dbd8b9cf09d65fffee97e29ce403cd8defba19d2"}, - {file = "proto_plus-1.23.0-py3-none-any.whl", hash = "sha256:a829c79e619e1cf632de091013a4173deed13a55f326ef84f05af6f50ff4c82c"}, + {file = "proto-plus-1.24.0.tar.gz", hash = "sha256:30b72a5ecafe4406b0d339db35b56c4059064e69227b8c3bda7462397f966445"}, + {file = "proto_plus-1.24.0-py3-none-any.whl", hash = "sha256:402576830425e5f6ce4c2a6702400ac79897dab0b4343821aa5188b0fab81a12"}, ] [package.dependencies] -protobuf = ">=3.19.0,<5.0.0dev" +protobuf = ">=3.19.0,<6.0.0dev" [package.extras] -testing = ["google-api-core[grpc] (>=1.31.5)"] +testing = ["google-api-core (>=1.31.5)"] [[package]] name = "protobuf" @@ -3161,47 +3384,68 @@ files = [ [[package]] name = "protobuf" -version = "4.25.3" +version = "4.25.5" +description = "" +optional = false +python-versions = ">=3.8" +files = [ + {file = "protobuf-4.25.5-cp310-abi3-win32.whl", hash = "sha256:5e61fd921603f58d2f5acb2806a929b4675f8874ff5f330b7d6f7e2e784bbcd8"}, + {file = "protobuf-4.25.5-cp310-abi3-win_amd64.whl", hash = "sha256:4be0571adcbe712b282a330c6e89eae24281344429ae95c6d85e79e84780f5ea"}, + {file = "protobuf-4.25.5-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:b2fde3d805354df675ea4c7c6338c1aecd254dfc9925e88c6d31a2bcb97eb173"}, + {file = "protobuf-4.25.5-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:919ad92d9b0310070f8356c24b855c98df2b8bd207ebc1c0c6fcc9ab1e007f3d"}, + {file = "protobuf-4.25.5-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:fe14e16c22be926d3abfcb500e60cab068baf10b542b8c858fa27e098123e331"}, + {file = "protobuf-4.25.5-cp38-cp38-win32.whl", hash = "sha256:98d8d8aa50de6a2747efd9cceba361c9034050ecce3e09136f90de37ddba66e1"}, + {file = "protobuf-4.25.5-cp38-cp38-win_amd64.whl", hash = "sha256:b0234dd5a03049e4ddd94b93400b67803c823cfc405689688f59b34e0742381a"}, + {file = "protobuf-4.25.5-cp39-cp39-win32.whl", hash = "sha256:abe32aad8561aa7cc94fc7ba4fdef646e576983edb94a73381b03c53728a626f"}, + {file = "protobuf-4.25.5-cp39-cp39-win_amd64.whl", hash = "sha256:7a183f592dc80aa7c8da7ad9e55091c4ffc9497b3054452d629bb85fa27c2a45"}, + {file = "protobuf-4.25.5-py3-none-any.whl", hash = "sha256:0aebecb809cae990f8129ada5ca273d9d670b76d9bfc9b1809f0a9c02b7dbf41"}, + {file = "protobuf-4.25.5.tar.gz", hash = "sha256:7f8249476b4a9473645db7f8ab42b02fe1488cbe5fb72fddd445e0665afd8584"}, +] + +[[package]] +name = "protobuf" +version = "5.28.2" description = "" optional = false python-versions = ">=3.8" files = [ - {file = "protobuf-4.25.3-cp310-abi3-win32.whl", hash = "sha256:d4198877797a83cbfe9bffa3803602bbe1625dc30d8a097365dbc762e5790faa"}, - {file = "protobuf-4.25.3-cp310-abi3-win_amd64.whl", hash = "sha256:209ba4cc916bab46f64e56b85b090607a676f66b473e6b762e6f1d9d591eb2e8"}, - {file = "protobuf-4.25.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:f1279ab38ecbfae7e456a108c5c0681e4956d5b1090027c1de0f934dfdb4b35c"}, - {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:e7cb0ae90dd83727f0c0718634ed56837bfeeee29a5f82a7514c03ee1364c019"}, - {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:7c8daa26095f82482307bc717364e7c13f4f1c99659be82890dcfc215194554d"}, - {file = "protobuf-4.25.3-cp38-cp38-win32.whl", hash = "sha256:f4f118245c4a087776e0a8408be33cf09f6c547442c00395fbfb116fac2f8ac2"}, - {file = "protobuf-4.25.3-cp38-cp38-win_amd64.whl", hash = "sha256:c053062984e61144385022e53678fbded7aea14ebb3e0305ae3592fb219ccfa4"}, - {file = "protobuf-4.25.3-cp39-cp39-win32.whl", hash = "sha256:19b270aeaa0099f16d3ca02628546b8baefe2955bbe23224aaf856134eccf1e4"}, - {file = "protobuf-4.25.3-cp39-cp39-win_amd64.whl", hash = "sha256:e3c97a1555fd6388f857770ff8b9703083de6bf1f9274a002a332d65fbb56c8c"}, - {file = "protobuf-4.25.3-py3-none-any.whl", hash = "sha256:f0700d54bcf45424477e46a9f0944155b46fb0639d69728739c0e47bab83f2b9"}, - {file = "protobuf-4.25.3.tar.gz", hash = "sha256:25b5d0b42fd000320bd7830b349e3b696435f3b329810427a6bcce6a5492cc5c"}, + {file = "protobuf-5.28.2-cp310-abi3-win32.whl", hash = "sha256:eeea10f3dc0ac7e6b4933d32db20662902b4ab81bf28df12218aa389e9c2102d"}, + {file = "protobuf-5.28.2-cp310-abi3-win_amd64.whl", hash = "sha256:2c69461a7fcc8e24be697624c09a839976d82ae75062b11a0972e41fd2cd9132"}, + {file = "protobuf-5.28.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:a8b9403fc70764b08d2f593ce44f1d2920c5077bf7d311fefec999f8c40f78b7"}, + {file = "protobuf-5.28.2-cp38-abi3-manylinux2014_aarch64.whl", hash = "sha256:35cfcb15f213449af7ff6198d6eb5f739c37d7e4f1c09b5d0641babf2cc0c68f"}, + {file = "protobuf-5.28.2-cp38-abi3-manylinux2014_x86_64.whl", hash = "sha256:5e8a95246d581eef20471b5d5ba010d55f66740942b95ba9b872d918c459452f"}, + {file = "protobuf-5.28.2-cp38-cp38-win32.whl", hash = "sha256:87317e9bcda04a32f2ee82089a204d3a2f0d3c8aeed16568c7daf4756e4f1fe0"}, + {file = "protobuf-5.28.2-cp38-cp38-win_amd64.whl", hash = "sha256:c0ea0123dac3399a2eeb1a1443d82b7afc9ff40241433296769f7da42d142ec3"}, + {file = "protobuf-5.28.2-cp39-cp39-win32.whl", hash = "sha256:ca53faf29896c526863366a52a8f4d88e69cd04ec9571ed6082fa117fac3ab36"}, + {file = "protobuf-5.28.2-cp39-cp39-win_amd64.whl", hash = "sha256:8ddc60bf374785fb7cb12510b267f59067fa10087325b8e1855b898a0d81d276"}, + {file = "protobuf-5.28.2-py3-none-any.whl", hash = "sha256:52235802093bd8a2811abbe8bf0ab9c5f54cca0a751fdd3f6ac2a21438bffece"}, + {file = "protobuf-5.28.2.tar.gz", hash = "sha256:59379674ff119717404f7454647913787034f03fe7049cbef1d74a97bb4593f0"}, ] [[package]] name = "psutil" -version = "5.9.8" +version = "6.0.0" description = "Cross-platform lib for process and system monitoring in Python." optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" -files = [ - {file = "psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"}, - {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"}, - {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"}, - {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"}, - {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"}, - {file = "psutil-5.9.8-cp27-none-win32.whl", hash = "sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"}, - {file = "psutil-5.9.8-cp27-none-win_amd64.whl", hash = "sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"}, - {file = "psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"}, - {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"}, - {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"}, - {file = "psutil-5.9.8-cp36-cp36m-win32.whl", hash = "sha256:7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"}, - {file = "psutil-5.9.8-cp36-cp36m-win_amd64.whl", hash = "sha256:27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"}, - {file = "psutil-5.9.8-cp37-abi3-win32.whl", hash = "sha256:bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"}, - {file = "psutil-5.9.8-cp37-abi3-win_amd64.whl", hash = "sha256:8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"}, - {file = "psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"}, - {file = "psutil-5.9.8.tar.gz", hash = "sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"}, +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "psutil-6.0.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a021da3e881cd935e64a3d0a20983bda0bb4cf80e4f74fa9bfcb1bc5785360c6"}, + {file = "psutil-6.0.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:1287c2b95f1c0a364d23bc6f2ea2365a8d4d9b726a3be7294296ff7ba97c17f0"}, + {file = "psutil-6.0.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:a9a3dbfb4de4f18174528d87cc352d1f788b7496991cca33c6996f40c9e3c92c"}, + {file = "psutil-6.0.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:6ec7588fb3ddaec7344a825afe298db83fe01bfaaab39155fa84cf1c0d6b13c3"}, + {file = "psutil-6.0.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:1e7c870afcb7d91fdea2b37c24aeb08f98b6d67257a5cb0a8bc3ac68d0f1a68c"}, + {file = "psutil-6.0.0-cp27-none-win32.whl", hash = "sha256:02b69001f44cc73c1c5279d02b30a817e339ceb258ad75997325e0e6169d8b35"}, + {file = "psutil-6.0.0-cp27-none-win_amd64.whl", hash = "sha256:21f1fb635deccd510f69f485b87433460a603919b45e2a324ad65b0cc74f8fb1"}, + {file = "psutil-6.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c588a7e9b1173b6e866756dde596fd4cad94f9399daf99ad8c3258b3cb2b47a0"}, + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ed2440ada7ef7d0d608f20ad89a04ec47d2d3ab7190896cd62ca5fc4fe08bf0"}, + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fd9a97c8e94059b0ef54a7d4baf13b405011176c3b6ff257c247cae0d560ecd"}, + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e8d0054fc88153ca0544f5c4d554d42e33df2e009c4ff42284ac9ebdef4132"}, + {file = "psutil-6.0.0-cp36-cp36m-win32.whl", hash = "sha256:fc8c9510cde0146432bbdb433322861ee8c3efbf8589865c8bf8d21cb30c4d14"}, + {file = "psutil-6.0.0-cp36-cp36m-win_amd64.whl", hash = "sha256:34859b8d8f423b86e4385ff3665d3f4d94be3cdf48221fbe476e883514fdb71c"}, + {file = "psutil-6.0.0-cp37-abi3-win32.whl", hash = "sha256:a495580d6bae27291324fe60cea0b5a7c23fa36a7cd35035a16d93bdcf076b9d"}, + {file = "psutil-6.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:33ea5e1c975250a720b3a6609c490db40dae5d83a4eb315170c4fe0d8b1f34b3"}, + {file = "psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:ffe7fc9b6b36beadc8c322f84e1caff51e8703b88eee1da46d1e3a6ae11b4fd0"}, + {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"}, ] [package.extras] @@ -3220,49 +3464,38 @@ files = [ [[package]] name = "pure-eval" -version = "0.2.2" +version = "0.2.3" description = "Safely evaluate AST nodes without side effects" optional = false python-versions = "*" files = [ - {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, - {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, ] [package.extras] tests = ["pytest"] -[[package]] -name = "py4j" -version = "0.10.9.7" -description = "Enables Python programs to dynamically access arbitrary Java objects" -optional = false -python-versions = "*" -files = [ - {file = "py4j-0.10.9.7-py2.py3-none-any.whl", hash = "sha256:85defdfd2b2376eb3abf5ca6474b51ab7e0de341c75a02f46dc9b5976f5a5c1b"}, - {file = "py4j-0.10.9.7.tar.gz", hash = "sha256:0b6e5315bb3ada5cf62ac651d107bb2ebc02def3dee9d9548e3baac644ea8dbb"}, -] - [[package]] name = "pyasn1" -version = "0.6.0" +version = "0.6.1" description = "Pure-Python implementation of ASN.1 types and DER/BER/CER codecs (X.208)" optional = false python-versions = ">=3.8" files = [ - {file = "pyasn1-0.6.0-py2.py3-none-any.whl", hash = "sha256:cca4bb0f2df5504f02f6f8a775b6e416ff9b0b3b16f7ee80b5a3153d9b804473"}, - {file = "pyasn1-0.6.0.tar.gz", hash = "sha256:3a35ab2c4b5ef98e17dfdec8ab074046fbda76e281c5a706ccd82328cfc8f64c"}, + {file = "pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629"}, + {file = "pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034"}, ] [[package]] name = "pyasn1-modules" -version = "0.4.0" +version = "0.4.1" description = "A collection of ASN.1-based protocols modules" optional = false python-versions = ">=3.8" files = [ - {file = "pyasn1_modules-0.4.0-py3-none-any.whl", hash = "sha256:be04f15b66c206eed667e0bb5ab27e2b1855ea54a842e5037738099e8ca4ae0b"}, - {file = "pyasn1_modules-0.4.0.tar.gz", hash = "sha256:831dbcea1b177b28c9baddf4c6d1013c24c3accd14a1873fffaa6a2e905f17b6"}, + {file = "pyasn1_modules-0.4.1-py3-none-any.whl", hash = "sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd"}, + {file = "pyasn1_modules-0.4.1.tar.gz", hash = "sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c"}, ] [package.dependencies] @@ -3270,132 +3503,134 @@ pyasn1 = ">=0.4.6,<0.7.0" [[package]] name = "pybase64" -version = "1.3.2" +version = "1.4.0" description = "Fast Base64 encoding/decoding" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" files = [ - {file = "pybase64-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3f89501c77883568612d9133be6684e36d60c098f30f4d5d6844d3130757c961"}, - {file = "pybase64-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1da5c376605397e1ff862ec414151eac183af7bd4843527022739144b302b8a9"}, - {file = "pybase64-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc61af2d33b2103af8507c549932fecb41b25e6d5c2916e0da92532378e3d639"}, - {file = "pybase64-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2fecde2c7d2bec98f585b57d33a48a54deaeb7dfc01df11e67926d44ddbdb235"}, - {file = "pybase64-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c4436edcff0cad586fd265d469696d1058ae4ec6b56cc96b180e2a8bcb3eab44"}, - {file = "pybase64-1.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9c919d38e70b7047f92210de8571422d7ba9df7fb74e35ae43be6e08c6842c9"}, - {file = "pybase64-1.3.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9af3f1700b4bdac7a3dfd3242af14d30b87e21e5940d95430c7ad576c79be101"}, - {file = "pybase64-1.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:812f2f8264a7f5e6bbb7605e0df9a2f827cfe2af994b92353bd4183480338104"}, - {file = "pybase64-1.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:fdfbe910e666c6d8b05356668ee6fee8848bfa09fc5d326e58466c30ef8db6c1"}, - {file = "pybase64-1.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:c99ae0e46bd7bec2c66bd1b5a9115911f15935202c55f71d64cd58dede018c52"}, - {file = "pybase64-1.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:1e52cd080d22960491688b0512d11108da58e8a3e0a28756afef4d201399f932"}, - {file = "pybase64-1.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4ae3659c92447d229fd272a90d215b0b3defe88c16ce5be784c8ecff77b4e2b4"}, - {file = "pybase64-1.3.2-cp310-cp310-win32.whl", hash = "sha256:ca3278ea46f026400bad43bf2780bb69d851b4931c99996f6d3172d30e224694"}, - {file = "pybase64-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:06fc379c0bbb03ce12afbcb11c1dd89943dc297d2eb7f38f17da86567c1e2da9"}, - {file = "pybase64-1.3.2-cp310-cp310-win_arm64.whl", hash = "sha256:db8bdddb2aaa57a1dfbb7133d431bd2f5c2f67b3638f0fe28f6c63a5ce52a03d"}, - {file = "pybase64-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1aef411095a3e53ecb232da05cce23518230bbf40b3b4b633b11b98d0f0c5621"}, - {file = "pybase64-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:951a32cb5d280a0ffd50d9dfd74af2d66e9ba6a052200f7b42ab57efd3da4230"}, - {file = "pybase64-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21ddd131cf0bbf0ff18138089268fa9e658b205ac9b31cb9fabae6b16b31e2ff"}, - {file = "pybase64-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31b796e74d691ee75903e38cc6008bfa9163c80814c148b71efb43473ee406ed"}, - {file = "pybase64-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8bf72833e16eae9e44ae46409b9a32a030bb5e26bc5cf4413dc74241cf2e845a"}, - {file = "pybase64-1.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:227e1b6c31d5306ba2820680b61ba7739fbc92a46ba1c6335d4e9abeff2338da"}, - {file = "pybase64-1.3.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19f3a2ade62217ee42e36b43d781589b9e265556191c30b72cf05f3f64aa9f2f"}, - {file = "pybase64-1.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1d67fdb1ef66f154d2d116a1e74fb4f60a3812cc43fd0907dd9fc05526fae763"}, - {file = "pybase64-1.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:bbfa7795782ff5079ddf183ffed6a67ec149a543cb0edf4902f875c31857a8ee"}, - {file = "pybase64-1.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:9ca4bb2efce3de2179adf57dafe2a7f7cf5dcc5361d04f9a2e8c58e93cca6741"}, - {file = "pybase64-1.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:d5ee9f5e7dabc4921abd8b5408fc6f9f330e9383d62fe69b142c403f3632ecd1"}, - {file = "pybase64-1.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f0ab56e017acaa59de96aa0a8e5f3aab88d3831d873426e003e11d39a91e7a84"}, - {file = "pybase64-1.3.2-cp311-cp311-win32.whl", hash = "sha256:7b6358d0cc13f3d1764cccdce0af563ec6abc79835fa7f25d1b7aa45da6393e4"}, - {file = "pybase64-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:98b186d0f3cad2ac164970e3a68a6a46c6b9c5c3f3c4d925f6181883d2a62470"}, - {file = "pybase64-1.3.2-cp311-cp311-win_arm64.whl", hash = "sha256:26f3153652bf4da3f7e634f13d44c4bb48b780551a6abd8f98d54745d3a83404"}, - {file = "pybase64-1.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:dc7f4628dafb04aa338bf14535e9db3579796f49bdebb03f9250d0a12b1f36cc"}, - {file = "pybase64-1.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e47bc67434a7e76fac34170f8d6091086acc1807fdad8fdf2069b516d73e9e38"}, - {file = "pybase64-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:349c3b6705ab7fd1f94c042d03482c66ff819274d3642ee6f7ec6978553da7b3"}, - {file = "pybase64-1.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b9d45188090f5af2948baab32624f8da87d569fa27f769b05264554c54be1f49"}, - {file = "pybase64-1.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fb2d1526fa41631673aa92290195b38015e4dea8fb265a7f9a7bb4d17eb98a8f"}, - {file = "pybase64-1.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3f038d3da111399a4246bc3f9c588956bc666e48192281759b9d310c423fcbcb"}, - {file = "pybase64-1.3.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6f34260036cd94b83c450dadb0d9316cdd468dfddd0aadb20837cb7f3e4b3d4"}, - {file = "pybase64-1.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:8c1dabbcfbc09d2cd41b02f0c9caaa5afc9282855b4b32451cb03af3fc5ff6ff"}, - {file = "pybase64-1.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:2c07669c87f66a164aba142cd812f1efb84b8bbb616c2cc35a28bd5c66d6414b"}, - {file = "pybase64-1.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:609b5c1fe84251b519e5f7e5c73c25635f4b722243b36f9aefe98a27d8b96938"}, - {file = "pybase64-1.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:736b0163926b2eb4e592dee7b41f89a29c2d3d0bcf93cb34fa9b84cfff948258"}, - {file = "pybase64-1.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f6a6b9dbb8257de1aac18c7b25e0d8849f3016a067743124e18de436e930f00"}, - {file = "pybase64-1.3.2-cp312-cp312-win32.whl", hash = "sha256:fbacb2f79e4dabf3abe25c247bea8000360fd0babb5b87579427310d852c8325"}, - {file = "pybase64-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:e8aec2d73a622ddf3c532ea860de6aebfaab646a6a6bb6ffeca295de106235e9"}, - {file = "pybase64-1.3.2-cp312-cp312-win_arm64.whl", hash = "sha256:9cd58fc35b81ccf647ae2d570fc957182b3a3b3f9b48b1f1d6d97e8cebd4c8d6"}, - {file = "pybase64-1.3.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:7a919d5129a543033a40cce7c4d26760953bb0108c1550b99961d7497131c60f"}, - {file = "pybase64-1.3.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88ca827cc2fca05b22e61bfebbe5ba85e9fb5d4ce5c376ad630a52b30bf20456"}, - {file = "pybase64-1.3.2-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:28e3ec4f74042352a85efb3c19ed9b115ff968bd16cc916a7fd70e6ae99cf67d"}, - {file = "pybase64-1.3.2-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:76662aa43a7a3d8ae2d51779c5a223fbaa4fa07925dead4c234316fc938084c2"}, - {file = "pybase64-1.3.2-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b95141be248c37a055deac1730d41f2a1715d41355a330b44738b2e4d3de28b8"}, - {file = "pybase64-1.3.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48f778c3bf3080d4a6230cd65eb06f0c0d3e05bb587fa7910db60e99815958a4"}, - {file = "pybase64-1.3.2-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:fde83acf303fe3a73f6ef4841866211c4ec7b4dc94b7439e1079089896efe8e0"}, - {file = "pybase64-1.3.2-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:4f8c20fb576bc9b54b547da8b3ce26e43e2447983d67197e13bc21e6874ed8ef"}, - {file = "pybase64-1.3.2-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:c0c8be6e23c28f98ec5d8f35a638676f983129651a37dc08c676e8edd7f2cf20"}, - {file = "pybase64-1.3.2-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:e0f65f6d682d72316d877c86b677793abaa65b391a3692767a077faced4b7802"}, - {file = "pybase64-1.3.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:4876c26f59c1ed4e1d63f947cefd5536a3511f74bc3c85afeaf81f75bcd21ff3"}, - {file = "pybase64-1.3.2-cp36-cp36m-win32.whl", hash = "sha256:a52a28b1f7b1f8a28c960637ec5c6e7fd90dadd5958b6c52632db704b6fa01a3"}, - {file = "pybase64-1.3.2-cp36-cp36m-win_amd64.whl", hash = "sha256:9ef6f22fc4223c8fd92cce2bf2d5fb4e26940319dec28ed5ac0e525076df2068"}, - {file = "pybase64-1.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:e19c6fe8ce448402137e8906bb4b4ec193a3152bd492e9bb2889b2ac705e8a17"}, - {file = "pybase64-1.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f07fb1f4884acc86272d7fe93f0475c85632d38806e03c69a03188b4367edec"}, - {file = "pybase64-1.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bc6a436a0cb2e8e78c92d1a98b2cb37bccb05bdf62225c0a1cda482ffa33a71a"}, - {file = "pybase64-1.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bb7420858e1c0608b895910495c664ac586dadef22cec5a2194e71a8917ec92e"}, - {file = "pybase64-1.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:085f0d8b7e593f5374f32483e5dcf543715a9a9fc1ea310f8d2ed664dabf7cdb"}, - {file = "pybase64-1.3.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:894415376efe88f9a22d45b6bfc06d9d594daac76c2acab3655afe3225987d37"}, - {file = "pybase64-1.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:0784181bf9368842ae9ff12c68c452e9ed6aeadb459b8e675201f4e4ba2444ff"}, - {file = "pybase64-1.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:755377cf87e76d7b48d7ff8d5814e114e9f153f22ae2636b5a875189824cf4ff"}, - {file = "pybase64-1.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:1f65c78b257beda1579d01836b27a89bc2f526b047998d328f010ecd078b73ee"}, - {file = "pybase64-1.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:0a0dcd173c7d4d1e971c94e15a246a4445955b0686e1488e78d18c05d3b71d9a"}, - {file = "pybase64-1.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:059d326412e5dbd786065dc525dbc53fc24656b3327de7ab70af41d432561a2f"}, - {file = "pybase64-1.3.2-cp37-cp37m-win32.whl", hash = "sha256:0b5f570f0d52a4d21c1adc762552a4aa0f9e8bc92f9ecd6b6b69c833eedfe8b9"}, - {file = "pybase64-1.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:025b613650939d618a4aef5473137bacc3346a71ed82e947551816e2bb06987f"}, - {file = "pybase64-1.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1e427957de7428446820a227bf483a3bca0351473e9ff3bbd831fca95f814a35"}, - {file = "pybase64-1.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:28591a028683dec543b5e9573ecad97ff72aa74c94b0ec62d0ee9c82cda8fa38"}, - {file = "pybase64-1.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:06d919d1279825e757a53b80396306c54c2512cf3169567746c7768fb68b7cee"}, - {file = "pybase64-1.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:879a41a64713068bfad2d6bc7c522b8f697527446658df97d061e79e5bb3c45c"}, - {file = "pybase64-1.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c7f7b2f072c8c7ab63c61e7a35f0685fb460600df820b950f2b690b1d4647ee6"}, - {file = "pybase64-1.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5126e7f0d53ce17e004439e928b3a4212a11f31d91b03c56408d2b385570eada"}, - {file = "pybase64-1.3.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f906b295210d5f6bc8cfe87445e92bc1a290d2b89bff1a74069e3a412eb7602a"}, - {file = "pybase64-1.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:cdd036423e0cd121eee3b5b7ea9e52413409c64537bd5f94bdfa615583229ea3"}, - {file = "pybase64-1.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:af4688d8554b7b0f20e3cd4cb167eab62d2b8886683f26b634301ac259b6c1f4"}, - {file = "pybase64-1.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:7bc5fc155935fd0d204bed726507aa04f7ef49885a79b93c347037c437fa45a3"}, - {file = "pybase64-1.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:9bc5f4866a6b9940bd10a5a1f8be139bb46728b40c48c5af8dd590eb170e8fb1"}, - {file = "pybase64-1.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c1ec8154e6e867b2c2a6de9abbe50115d7c2d426d69e7791e1f4337270304497"}, - {file = "pybase64-1.3.2-cp38-cp38-win32.whl", hash = "sha256:651c4e07c507f7756179aa75de3b1b802346a195fa40991c75ced57da45ba761"}, - {file = "pybase64-1.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:11b4971af5aa3926115cdacc7e837d018c6cc9b6cfe0b93c839c29a0af5be2b2"}, - {file = "pybase64-1.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0bf75f63bc16b68152ac31b552a09313dc54c2dca171a7a8c27f4505a8e91104"}, - {file = "pybase64-1.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:81cd93debccda870834adadca7c7923bd5c276e1ef544cf62ee9a5d1c4045f68"}, - {file = "pybase64-1.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2758adcbebd18fefb325a2c2caa6698a9ede6dee3dd97439cc17e9354bceb8bb"}, - {file = "pybase64-1.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f9d3f645c7c74321273a5851504fab90fbee9e013b1069d066c8aec2613ce4f6"}, - {file = "pybase64-1.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cc0fe1a2a54958ff268d04582b0b942208c7ce020e81f581625b5a0281a0da29"}, - {file = "pybase64-1.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9622442f217bd2ec12d4188eb942a3210b0a5bdb9e295e252cca099a703001ce"}, - {file = "pybase64-1.3.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11114b6b3c7f4d6668b20b473fae88a92214389a86bda3c98914c8a2fa376556"}, - {file = "pybase64-1.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a19312ced969d8f7b712ed3201fcf803eefdf882891977037596391ab11da26b"}, - {file = "pybase64-1.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:e0a8518e6b01aa89a274b7a833cde079ace40c16cdd9573a7dfa6166f904a3fb"}, - {file = "pybase64-1.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:47afc5ae22fef448142db84f0cf631fe9f86160055f018f9002f816a3b63ef15"}, - {file = "pybase64-1.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:41a177b58e3b2dbb93fe03c6aa14798142e1cd16ae0257cb844c44e42cd25144"}, - {file = "pybase64-1.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6f3188bfa49e4bd27a7bf120d17da891ad4d190be44e45aca0abb95c4b7ab656"}, - {file = "pybase64-1.3.2-cp39-cp39-win32.whl", hash = "sha256:f0190a9b9e30aa448221fb6ca6c9a4359b28ffe769c4a8c08c1d2457e04093c8"}, - {file = "pybase64-1.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:9499f665dcc86713332e5759b1552d141b6d4770da4206094b869eb7c001337c"}, - {file = "pybase64-1.3.2-cp39-cp39-win_arm64.whl", hash = "sha256:15b844e29b6bb08949ffb07021383e3182e6651436708130d1d528e42aeacab5"}, - {file = "pybase64-1.3.2-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:b9f7e26e2c5c4c73755a6cd13979cba0fcfa8efcefa68d5baf6766cd86de200f"}, - {file = "pybase64-1.3.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2be5ec28edf2ba01fd12b1d04ff4c06208bf2a0eb81812db4966eef83bb2d68"}, - {file = "pybase64-1.3.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bbd9419835e8723691c536ca17c5b4f928837a709ca8abb8a25ab5667ae7f081"}, - {file = "pybase64-1.3.2-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d23b6ccbb5244bd853a33428dd9b1e37e187c51ccc98e5a54b202c8ecd9a0780"}, - {file = "pybase64-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7f5c52598f4cb2c45f15cba9c823f3af469408837dea2cb105b53a0cce862b0b"}, - {file = "pybase64-1.3.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:72d7044ea0137a9f8936b65f40817490fc2dab34fa7715f60034f8fca556748d"}, - {file = "pybase64-1.3.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fea73a50e8f236aa60cb87ccb5a85778e64db8bc7446c3f89226dd79ed23894f"}, - {file = "pybase64-1.3.2-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ba5ab04d84db9963610bcada4a46bf654b12ea7934795c2781667c1694ae60d"}, - {file = "pybase64-1.3.2-pp37-pypy37_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4f5974ada99be1f0222e0e17f5584df07a8ccd8b025b739ae66006127718bb1"}, - {file = "pybase64-1.3.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:48292d202b134ec320e6ec2212199f8a5ea3b58ae83cba2b30201040e7733904"}, - {file = "pybase64-1.3.2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:03b1d733116cf6f77ad7c3b286b793ed0fbb8363d2e4a031bd3d120dcbdbe9c7"}, - {file = "pybase64-1.3.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f109a6aba9c235406f994d80083f5680a81b52358102751c23b8f2e1da57b231"}, - {file = "pybase64-1.3.2-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:915c4eb35bc339f100749856eac74a145639ea7c2bb7b83e5a14d4ef70c6af7a"}, - {file = "pybase64-1.3.2-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71b65b78197ed6bc009cb84418a484ecc568dafc9329d4bac90b8eff21ca8cb4"}, - {file = "pybase64-1.3.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:33f11c42ce14fbb2eeb41b76b6f4f7acfdd970c16a609ae0a26fa283761f06f3"}, - {file = "pybase64-1.3.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:91da83c784f86254eb05c1aa134b91952f90c82e336bbbc54d59d15af8023f1f"}, - {file = "pybase64-1.3.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b54d33adca9e96408dc8ecabf7f880bb86ce15c7e2e00e3919e8b45e6e0ec07"}, - {file = "pybase64-1.3.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bac1442c9c4de1c4d977adaa67a2410838fa8c3150149f32b0596731e0b7babb"}, - {file = "pybase64-1.3.2-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:266466931e324706eee0c3a12d032ae8b80d1b3895e17686c41176755c7c3684"}, - {file = "pybase64-1.3.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:1b722174c06c204dff14852f3a968ee448698cf9af0c0c31a5d15343ccb19ef3"}, - {file = "pybase64-1.3.2.tar.gz", hash = "sha256:32ef993c55821dac9abd767ee4656a5013b2ed8bf1125cabbae7e84d2b991038"}, + {file = "pybase64-1.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:53588d4343c867329830a68c305da771f151e3e850962991b28e8e946ac359c7"}, + {file = "pybase64-1.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:68d3143f14cb91459f5ab942dc8ec717e84b45a20108832603815257b65319f2"}, + {file = "pybase64-1.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78b8eeddc5914cc407cf56aa70fb45142a4da60ce4c259b93a78f7ec28e4c086"}, + {file = "pybase64-1.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7236b6da20d1264e7afe80c04e168c2346b1d92b6c040dc200ae15c8c85780d3"}, + {file = "pybase64-1.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f8fb055b149cef84c238bfe83405d4e16a85717b5ee3b7196a90e75ce6d3e062"}, + {file = "pybase64-1.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cff5181ae5c01d4a00e5cd4d76c571f696bbc61c4dde448cc3ccf00e6efe0aba"}, + {file = "pybase64-1.4.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46e423377492ddedca1ea5a6c1790de194421be0635652b05b3e9dac14e6843f"}, + {file = "pybase64-1.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fd6ad3539c0c649856f7eeb92beb279087b25a1c1b67c1a6937eeac53035e972"}, + {file = "pybase64-1.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:6b1271d3c4952eb0668e1252e46457ed6b30d6e1c7e678b02fdb3dcee237559b"}, + {file = "pybase64-1.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:7343b9488c2a141bf139ac479aa39be895c75d1813e10062a9ba445d83d77fc1"}, + {file = "pybase64-1.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:4956588c464e267627b9260443834ffb10033e4ca28725595c58f0894847f327"}, + {file = "pybase64-1.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7e0d8d16f608e613fff5481200ce17ea159ef08519344cd6d3b4e9096124e44f"}, + {file = "pybase64-1.4.0-cp310-cp310-win32.whl", hash = "sha256:8683400369296f920f1546437be6ef46e3a9f446b199c6c372504a0e09e19e83"}, + {file = "pybase64-1.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ce3d5dd91ec1673cc92b36f4fe1c1476cfc7ac1305c8f3ac1b2327ae186093bb"}, + {file = "pybase64-1.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:6fb1932336d3f413ce0497a7ff73cfce8cc90991e3724811d83147c3199b85d5"}, + {file = "pybase64-1.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a0d09663dae7999b3efac87561cf469d1c394b683f59d8e233db587c3a2b4c35"}, + {file = "pybase64-1.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e7427a5d51d99791165c1f1b0113e9eb2699043fa4b0686ffd8465dc015c5eb2"}, + {file = "pybase64-1.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2590ecc24ff7325457f37c742b7e48aeb87444f23773dfd6a9c12e5d2e8f363f"}, + {file = "pybase64-1.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e581031d510431213168a6c9c735d74bf24f6dd0b92a2a82413aded8cb31cac4"}, + {file = "pybase64-1.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:618e1c7fce64223e8fdca9360d7f23d8da0d31d3ab8b6afed034c9c3ba566860"}, + {file = "pybase64-1.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:916591bcd8d1858f27be636d984e4c0713c7c1f0a651cf18529a8fc0cbc9c6d9"}, + {file = "pybase64-1.4.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:288a5d00500faf13ead83c6611dc265304cc04fd85013ed23eb730ccf9e54399"}, + {file = "pybase64-1.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:30df6f3f6f3b5485dcea9f0dfa4807a9ec41e186824e16f37a300a08e13ba836"}, + {file = "pybase64-1.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:853a00a9f43d1410c57399fc23e8bba0c705fb46abcba7604a0e59d0d6426161"}, + {file = "pybase64-1.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e2515dd6cfbd204cb5cdcc94f34bf70ca380dfecaf750867fd2b211620ba5b3e"}, + {file = "pybase64-1.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:8d5678655a84633a7044bab2b6cb09bfd0735862b9f1092539e7718a6bba782a"}, + {file = "pybase64-1.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cc9aa578ab7810b282c2426904db5b2cb86a3e36e51732118fe3340921ade360"}, + {file = "pybase64-1.4.0-cp311-cp311-win32.whl", hash = "sha256:b9beab673f09203201db6e03bf7dd285250e075b5f66d5b337f4a08c11a587c7"}, + {file = "pybase64-1.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:6d8366e268cb9743cf73b7351c31c2f03270c0e9cb397e5f00daa1824f453bb7"}, + {file = "pybase64-1.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:d8d8133ad82c1584be15e59b3c8c590da9160eb698298c59aa4e60983c9f73a8"}, + {file = "pybase64-1.4.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:51a3aa66a989affa85b311ad88c05bf16ef3803e60e84cd821f7231c83b22d7f"}, + {file = "pybase64-1.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2607bfdda2c582a870dc5b18fbc121434278712a78e41249caf7ea1a9f1266ce"}, + {file = "pybase64-1.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0eb2ddaa008e53944cf62b927f18e7800d629c7b71ab77f87d3293f937a40abb"}, + {file = "pybase64-1.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9b73d2b3cb9107f78a77ad98501f075c58823604f0de27f59216f19b68ed0fc"}, + {file = "pybase64-1.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c50cba5cea82c86ac0a3c7eb30e74a25ac24f42de18e48e1ff2fe60ca82bc2b3"}, + {file = "pybase64-1.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c56a3a43b9a6b9d8917724cab65bdd59f72ed7a66c73bf55abdb31fa0ee1ce7f"}, + {file = "pybase64-1.4.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:35c018a191be4f7ac2f4cf404843ed30832da11643251fe9536ef9067577325a"}, + {file = "pybase64-1.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:dab702ba6723dcbf82bdcac9c080bac949eaecba1591ba50e1925fd8f8cde159"}, + {file = "pybase64-1.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:030441e07c410c011431c97df4906fda79a333fd984c4170eec23cb6d6d89fc1"}, + {file = "pybase64-1.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:24a4e1bfb41dea3e88487dee9d46c634505e907ddf5429fa80692453d6ae3541"}, + {file = "pybase64-1.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:03d5aab98b6d529e0fa48eefd1db5c5bc0c931853eb3fb527beb3d0478ccd04e"}, + {file = "pybase64-1.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8612a3701fb5a33ce14128f2fbe7e3603e6347cbdeb256910d96b25e431b9323"}, + {file = "pybase64-1.4.0-cp312-cp312-win32.whl", hash = "sha256:6d9901f0b6f0c6873856ce59ffc0b53135b4078e04e0ceb0ecc050138c6ba71e"}, + {file = "pybase64-1.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f8bd2321724f386020b1b0a00f546a4b7c49b86c6a81cbb5afb601b44e5131"}, + {file = "pybase64-1.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:23ef9e0d02818f2d3ee5f84bba0dec591c67b7fde74c6c40c8eae4a3030a4d8a"}, + {file = "pybase64-1.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4c1631af25e24d1643f18454f68649c0e07e9ba880553ef0e7b144b62b7551f9"}, + {file = "pybase64-1.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ac9005d947c5680dde42b120b6ccc18461bd203cba52cfb32e2d20dbe3c149e0"}, + {file = "pybase64-1.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81767f59b639bb6b481bcef0add94fc9ff4434ab65b694f46224654874c8d888"}, + {file = "pybase64-1.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:158263489efbce7ef7b4d70771e8882650810440a2386e53e17af1753d70e1e5"}, + {file = "pybase64-1.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9946adae43bbffc3a62a943bc8dd467373ff27166cec59de113d2ce954343210"}, + {file = "pybase64-1.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:407aa690d5ed8d9ddd06e83ce61e9be9fb33f52575db28bc935eba42f65d3b0d"}, + {file = "pybase64-1.4.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7c173a645a28ddecaf991f0dda7a7f789a026ebbb56580aa3e761470b15fa8c"}, + {file = "pybase64-1.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5bbf14daab52a6340ed9b9473a74ff91564110466f5e295ab1ff85913eadcb7c"}, + {file = "pybase64-1.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cea8377c2f24808fd9ed254bbaede2a96cead3df331fbc533c9efb6b425f3d1c"}, + {file = "pybase64-1.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b206fb7a1190e69b05c1469f78948ba770009e608e4e4ded1934ea87143c3a7e"}, + {file = "pybase64-1.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:1f68a13383d9f9ef55e9d316c6491d60b47e14ca7407bc43be9e991f03c2a969"}, + {file = "pybase64-1.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7bf62a95a4ff55239a5094af69c528dfc926db27543bfc1676f620d9d90c21d5"}, + {file = "pybase64-1.4.0-cp313-cp313-win32.whl", hash = "sha256:d81a28738a28678eb637f1798e43e9e700b336ae69c46e397f84a3168c8dc8cc"}, + {file = "pybase64-1.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:4d711d8c840e8d684ac31b21c79db4722fb6fd7610f544827448f7a0c6695ea2"}, + {file = "pybase64-1.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb8b219b4eecd935f1f0c9deebee9b8b0b4b50cf4ab603b9e2eeaf9ed278d909"}, + {file = "pybase64-1.4.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:b88810395971b333c71920e3bd6387224a75aa6c3c2670cb1fd144a50426e84d"}, + {file = "pybase64-1.4.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6c7e1cf93dc692896481c0e60ccd44c2329e1bc14e7913fcaac0a671d011c7c4"}, + {file = "pybase64-1.4.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea61017577d5bbc39339f3af0ef0115d9c7c4317bf461d6e2cac4d0473e6afba"}, + {file = "pybase64-1.4.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7227c049aa1399fb61827d27fcc2ba089ecbbc5b1a60e16ba7620ca246a60d17"}, + {file = "pybase64-1.4.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed7d38b5d96eab31ea7e45cc3a5f586db023bfdf5df4b7ad096d63d6f70267dd"}, + {file = "pybase64-1.4.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cae19e57eb8155ef68e770d8e0283384fb2a04c568f729f2d12e6bd3ffbee3a6"}, + {file = "pybase64-1.4.0-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ced59a394de5d181bdf6493d72838b7603fb89898d12f2213a55f7175fc25ac"}, + {file = "pybase64-1.4.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:305798dff96d23621e10262a4c64dd641b39c5123289a119359941ab7c17dcfc"}, + {file = "pybase64-1.4.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:acdad56404a0a17a8a240a21a55272b2165bb98f898cf76b0b35d219db1237fe"}, + {file = "pybase64-1.4.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c7052eebefb4a543a2a70e2dab1a717a431656a8831149c1a99dec39677ce4ca"}, + {file = "pybase64-1.4.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:669a6e55a4dcc0069524bca84702ae99645bfb5d9f6745379b9c043b424530e3"}, + {file = "pybase64-1.4.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c8abce1e40a2c0b2a332995cd716c16d9449e3aaea29c94f632643e7a66a54cb"}, + {file = "pybase64-1.4.0-cp313-cp313t-win32.whl", hash = "sha256:62b19c962b0f205615766f49aaeab8e981173681a5762904794573a56d899ab7"}, + {file = "pybase64-1.4.0-cp313-cp313t-win_amd64.whl", hash = "sha256:af0349c823aa0e605dbf2cfaaf0b89212123158421a2968a3c3565dd6771e57f"}, + {file = "pybase64-1.4.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9dc05a62222395a3f4b7f3860792612f8b06e448e3bf483e316ce1361e6f338e"}, + {file = "pybase64-1.4.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:322a93f1dcbe4d4e0c9a7499c761b835969a84d5e5f30d2bce73b511bc3d660d"}, + {file = "pybase64-1.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a64823e3b83f3cd14a781e5ff1f49ca91cf48238df21241222a129e8d41d1368"}, + {file = "pybase64-1.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:470e7d5103b421a481ad5676013c2ddfd0c07d086ff86e3c8f4b0c71bbeb00f5"}, + {file = "pybase64-1.4.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66c865421e30a277ee4dcd1a9ec4628d0dc04bfe0f4c22802ad0db3b1e0247d4"}, + {file = "pybase64-1.4.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c1146c303f02e9f1996e1e926fde932090499473d143362265b1b771fec45418"}, + {file = "pybase64-1.4.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4d307fd11a16266375f9c9032445498faa101abe54ba65b422fb34bab83aa147"}, + {file = "pybase64-1.4.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89d7c5ac318d4c832f0d07c9cfb323fbdec60b3138d3cf94df622d56628aaffb"}, + {file = "pybase64-1.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:1ad8afea87817744fd5ea0d61cc3bb9ab0023e2a1f9741df578d347fc106cfd4"}, + {file = "pybase64-1.4.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:11f9c7edf1d221203938f8fb58be2b3e9b3ec87863bfeb215a783a228d305786"}, + {file = "pybase64-1.4.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:09b8bc436c0f16e675fddb963d7d2be0fce3d0f8a28a39081c127d4aa3ffb1bf"}, + {file = "pybase64-1.4.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:ddf2f84779a338ad52d37594442c03109ab559cc6c9b437daaa745d6253d0bf9"}, + {file = "pybase64-1.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:05f1f292a3926df58b8c5b38bdfc4cf4d5ad1499a07309df94a84e7111cf5075"}, + {file = "pybase64-1.4.0-cp38-cp38-win32.whl", hash = "sha256:b52cfeb6f2a4ec8281dafab9a304133c6b3c8c83d96af476d336b068597ecee2"}, + {file = "pybase64-1.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:ccc097310842d8054b91983481840cf52c85166b295d70348a59423b966cf965"}, + {file = "pybase64-1.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:420c5503b768b7aa0e454fd890915ffbc66bcf9653ee978486a90c4dd6c98a56"}, + {file = "pybase64-1.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:957befeb3b23566f2e54dba8e2c0a15ceeb06c18fce63a3b834308e6e5b0ac29"}, + {file = "pybase64-1.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50b13c62ba0ce3bf19d01b736b43b93f89bc1477b1f75e7d5882048d2e0fb1f0"}, + {file = "pybase64-1.4.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f855a2d52886fdf8c7edf3b0d6cfe00690337ae8cbf3f29ef40140b194c578c0"}, + {file = "pybase64-1.4.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:976bb75cffeb87ca5d865cb1a5c4b96de420d6a0d9a7f8ed334f65d5f2785e8c"}, + {file = "pybase64-1.4.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b1fbc82eed9c1f68277a8fd9b0f09b887b64bddacb1e2dd874c4ae1bf1aea6cf"}, + {file = "pybase64-1.4.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed6e3448ab5037d60e5568f5667a996704e889bdad0f460fbf521626cf81e6ee"}, + {file = "pybase64-1.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:59729edf77dc96d7c8cfe4db46688af3e685b0f627e91aec0be2e631e1ed5735"}, + {file = "pybase64-1.4.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:7187ec5b97e5f2034335e340d92a8e0bd65b467497b209ee37770a5e80f9ab87"}, + {file = "pybase64-1.4.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:cbb69a4bda3d2ccb044eab060e5a3312931e80c0b1a438310e0494b80a7c2f8c"}, + {file = "pybase64-1.4.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:971c897a6844c7ca061d9abe61979c6cc5b8801511b6ebf3f147d2bfa7059c13"}, + {file = "pybase64-1.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f18bccbe275ae65953d44aa27fbde14412fbbe65d526a5862f15c59f4920a563"}, + {file = "pybase64-1.4.0-cp39-cp39-win32.whl", hash = "sha256:3ca60f2b6745e12b838854dcfc2e65a6d1d3cea0725a78f278b4ea8090563a6e"}, + {file = "pybase64-1.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:46825067ae83fda34d983ba89632191370919f9fd17186eee808f8f8b49043a0"}, + {file = "pybase64-1.4.0-cp39-cp39-win_arm64.whl", hash = "sha256:de47017df163056f3124ec9bc4405db3df213e43b315204429d78fd3ce6a4299"}, + {file = "pybase64-1.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f867d6b667e1f3a9acf602c3cdf9a477f75ed88e7496cd792470bb74a7c275d"}, + {file = "pybase64-1.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:de01468a6626c5056038b51d28748d3cae1765e3913c956d47469cced5aba353"}, + {file = "pybase64-1.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc497c8c05fb00a3ee4b0946aba811c7c1e2153e11e26b91f31a65fb72820f71"}, + {file = "pybase64-1.4.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:974aab42844d33b5b3b98999e3a614705f5ad28f5cdcfd6bed2140e1d30bc187"}, + {file = "pybase64-1.4.0-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:528f23e78c5f9b116e828d7f3981bc35b102e9b4a46d14b1113973f217f7c03b"}, + {file = "pybase64-1.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a10dea4196cb44492137a31dcc5062b076f784eb7fd6160b329600942319e100"}, + {file = "pybase64-1.4.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:371835babfa0119a809e60b18cd48e506db05a12717c96086e16b74856fcc186"}, + {file = "pybase64-1.4.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:9d1dd06136a5a1f7c1ea0c9fb0faf23ee333346a8667d462a537ca557b321e8f"}, + {file = "pybase64-1.4.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7920615b0db6e8b59ea3b3a0f831962819db96bc63583e918a6e97e2327b0218"}, + {file = "pybase64-1.4.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2b3a789d61e39bb84f5e894332c6db108c39acf68b2710b6339162ff90d7a615"}, + {file = "pybase64-1.4.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a1357a4913b72b947877a13ef54cf0543978a1a5b55ae8983e5856bb8ff2e8e"}, + {file = "pybase64-1.4.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:06fb8f4706f0148484788b0036e8ee77717a103d50854ac060d51b894735451a"}, + {file = "pybase64-1.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ae9e00211374a3c0d16c557b157a6fbfaf76c976a55da5516ba952d3ff893422"}, + {file = "pybase64-1.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5bd98d7b4467953c6b904ae946cf78443dca0f42ec44facb3e9db1800272ff45"}, + {file = "pybase64-1.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:824d0d1c04cf0556b22a386b4a3dcefa22f288d15784dd04aa3240c0831efb51"}, + {file = "pybase64-1.4.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7d03e7373b1b398bb6137ee1fe39fa2c328f9d6a92a0ea5c8b9b37767b7ff52d"}, + {file = "pybase64-1.4.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e252a1a04fbbb7ed091150aed92ad1fbce378099e6ad385b0473e25f3a97a98e"}, + {file = "pybase64-1.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c689e9aa56c7056eb42bfd7dd383d98f67852e3fc78c57747a11e049e0e1ba12"}, + {file = "pybase64-1.4.0.tar.gz", hash = "sha256:714f021c3eaa287c1097ced68f2df4c5b2ecd2504551c2e71c843f54365aca03"}, ] [[package]] @@ -3525,109 +3760,120 @@ files = [ [[package]] name = "pydantic" -version = "2.7.1" +version = "2.9.2" description = "Data validation using Python type hints" optional = false python-versions = ">=3.8" files = [ - {file = "pydantic-2.7.1-py3-none-any.whl", hash = "sha256:e029badca45266732a9a79898a15ae2e8b14840b1eabbb25844be28f0b33f3d5"}, - {file = "pydantic-2.7.1.tar.gz", hash = "sha256:e9dbb5eada8abe4d9ae5f46b9939aead650cd2b68f249bb3a8139dbe125803cc"}, + {file = "pydantic-2.9.2-py3-none-any.whl", hash = "sha256:f048cec7b26778210e28a0459867920654d48e5e62db0958433636cde4254f12"}, + {file = "pydantic-2.9.2.tar.gz", hash = "sha256:d155cef71265d1e9807ed1c32b4c8deec042a44a50a4188b25ac67ecd81a9c0f"}, ] [package.dependencies] -annotated-types = ">=0.4.0" -pydantic-core = "2.18.2" -typing-extensions = ">=4.6.1" +annotated-types = ">=0.6.0" +pydantic-core = "2.23.4" +typing-extensions = {version = ">=4.6.1", markers = "python_version < \"3.13\""} [package.extras] email = ["email-validator (>=2.0.0)"] +timezone = ["tzdata"] [[package]] name = "pydantic-core" -version = "2.18.2" +version = "2.23.4" description = "Core functionality for Pydantic validation and serialization" optional = false python-versions = ">=3.8" files = [ - {file = "pydantic_core-2.18.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:9e08e867b306f525802df7cd16c44ff5ebbe747ff0ca6cf3fde7f36c05a59a81"}, - {file = "pydantic_core-2.18.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f0a21cbaa69900cbe1a2e7cad2aa74ac3cf21b10c3efb0fa0b80305274c0e8a2"}, - {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0680b1f1f11fda801397de52c36ce38ef1c1dc841a0927a94f226dea29c3ae3d"}, - {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:95b9d5e72481d3780ba3442eac863eae92ae43a5f3adb5b4d0a1de89d42bb250"}, - {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4fcf5cd9c4b655ad666ca332b9a081112cd7a58a8b5a6ca7a3104bc950f2038"}, - {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b5155ff768083cb1d62f3e143b49a8a3432e6789a3abee8acd005c3c7af1c74"}, - {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:553ef617b6836fc7e4df130bb851e32fe357ce36336d897fd6646d6058d980af"}, - {file = "pydantic_core-2.18.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b89ed9eb7d616ef5714e5590e6cf7f23b02d0d539767d33561e3675d6f9e3857"}, - {file = "pydantic_core-2.18.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:75f7e9488238e920ab6204399ded280dc4c307d034f3924cd7f90a38b1829563"}, - {file = "pydantic_core-2.18.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ef26c9e94a8c04a1b2924149a9cb081836913818e55681722d7f29af88fe7b38"}, - {file = "pydantic_core-2.18.2-cp310-none-win32.whl", hash = "sha256:182245ff6b0039e82b6bb585ed55a64d7c81c560715d1bad0cbad6dfa07b4027"}, - {file = "pydantic_core-2.18.2-cp310-none-win_amd64.whl", hash = "sha256:e23ec367a948b6d812301afc1b13f8094ab7b2c280af66ef450efc357d2ae543"}, - {file = "pydantic_core-2.18.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:219da3f096d50a157f33645a1cf31c0ad1fe829a92181dd1311022f986e5fbe3"}, - {file = "pydantic_core-2.18.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cc1cfd88a64e012b74e94cd00bbe0f9c6df57049c97f02bb07d39e9c852e19a4"}, - {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05b7133a6e6aeb8df37d6f413f7705a37ab4031597f64ab56384c94d98fa0e90"}, - {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:224c421235f6102e8737032483f43c1a8cfb1d2f45740c44166219599358c2cd"}, - {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b14d82cdb934e99dda6d9d60dc84a24379820176cc4a0d123f88df319ae9c150"}, - {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2728b01246a3bba6de144f9e3115b532ee44bd6cf39795194fb75491824a1413"}, - {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:470b94480bb5ee929f5acba6995251ada5e059a5ef3e0dfc63cca287283ebfa6"}, - {file = "pydantic_core-2.18.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:997abc4df705d1295a42f95b4eec4950a37ad8ae46d913caeee117b6b198811c"}, - {file = "pydantic_core-2.18.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:75250dbc5290e3f1a0f4618db35e51a165186f9034eff158f3d490b3fed9f8a0"}, - {file = "pydantic_core-2.18.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4456f2dca97c425231d7315737d45239b2b51a50dc2b6f0c2bb181fce6207664"}, - {file = "pydantic_core-2.18.2-cp311-none-win32.whl", hash = "sha256:269322dcc3d8bdb69f054681edff86276b2ff972447863cf34c8b860f5188e2e"}, - {file = "pydantic_core-2.18.2-cp311-none-win_amd64.whl", hash = "sha256:800d60565aec896f25bc3cfa56d2277d52d5182af08162f7954f938c06dc4ee3"}, - {file = "pydantic_core-2.18.2-cp311-none-win_arm64.whl", hash = "sha256:1404c69d6a676245199767ba4f633cce5f4ad4181f9d0ccb0577e1f66cf4c46d"}, - {file = "pydantic_core-2.18.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:fb2bd7be70c0fe4dfd32c951bc813d9fe6ebcbfdd15a07527796c8204bd36242"}, - {file = "pydantic_core-2.18.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6132dd3bd52838acddca05a72aafb6eab6536aa145e923bb50f45e78b7251043"}, - {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7d904828195733c183d20a54230c0df0eb46ec746ea1a666730787353e87182"}, - {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c9bd70772c720142be1020eac55f8143a34ec9f82d75a8e7a07852023e46617f"}, - {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2b8ed04b3582771764538f7ee7001b02e1170223cf9b75dff0bc698fadb00cf3"}, - {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e6dac87ddb34aaec85f873d737e9d06a3555a1cc1a8e0c44b7f8d5daeb89d86f"}, - {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ca4ae5a27ad7a4ee5170aebce1574b375de390bc01284f87b18d43a3984df72"}, - {file = "pydantic_core-2.18.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:886eec03591b7cf058467a70a87733b35f44707bd86cf64a615584fd72488b7c"}, - {file = "pydantic_core-2.18.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ca7b0c1f1c983e064caa85f3792dd2fe3526b3505378874afa84baf662e12241"}, - {file = "pydantic_core-2.18.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b4356d3538c3649337df4074e81b85f0616b79731fe22dd11b99499b2ebbdf3"}, - {file = "pydantic_core-2.18.2-cp312-none-win32.whl", hash = "sha256:8b172601454f2d7701121bbec3425dd71efcb787a027edf49724c9cefc14c038"}, - {file = "pydantic_core-2.18.2-cp312-none-win_amd64.whl", hash = "sha256:b1bd7e47b1558ea872bd16c8502c414f9e90dcf12f1395129d7bb42a09a95438"}, - {file = "pydantic_core-2.18.2-cp312-none-win_arm64.whl", hash = "sha256:98758d627ff397e752bc339272c14c98199c613f922d4a384ddc07526c86a2ec"}, - {file = "pydantic_core-2.18.2-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:9fdad8e35f278b2c3eb77cbdc5c0a49dada440657bf738d6905ce106dc1de439"}, - {file = "pydantic_core-2.18.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1d90c3265ae107f91a4f279f4d6f6f1d4907ac76c6868b27dc7fb33688cfb347"}, - {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:390193c770399861d8df9670fb0d1874f330c79caaca4642332df7c682bf6b91"}, - {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:82d5d4d78e4448683cb467897fe24e2b74bb7b973a541ea1dcfec1d3cbce39fb"}, - {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4774f3184d2ef3e14e8693194f661dea5a4d6ca4e3dc8e39786d33a94865cefd"}, - {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4d938ec0adf5167cb335acb25a4ee69a8107e4984f8fbd2e897021d9e4ca21b"}, - {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0e8b1be28239fc64a88a8189d1df7fad8be8c1ae47fcc33e43d4be15f99cc70"}, - {file = "pydantic_core-2.18.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:868649da93e5a3d5eacc2b5b3b9235c98ccdbfd443832f31e075f54419e1b96b"}, - {file = "pydantic_core-2.18.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:78363590ef93d5d226ba21a90a03ea89a20738ee5b7da83d771d283fd8a56761"}, - {file = "pydantic_core-2.18.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:852e966fbd035a6468fc0a3496589b45e2208ec7ca95c26470a54daed82a0788"}, - {file = "pydantic_core-2.18.2-cp38-none-win32.whl", hash = "sha256:6a46e22a707e7ad4484ac9ee9f290f9d501df45954184e23fc29408dfad61350"}, - {file = "pydantic_core-2.18.2-cp38-none-win_amd64.whl", hash = "sha256:d91cb5ea8b11607cc757675051f61b3d93f15eca3cefb3e6c704a5d6e8440f4e"}, - {file = "pydantic_core-2.18.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:ae0a8a797a5e56c053610fa7be147993fe50960fa43609ff2a9552b0e07013e8"}, - {file = "pydantic_core-2.18.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:042473b6280246b1dbf530559246f6842b56119c2926d1e52b631bdc46075f2a"}, - {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a388a77e629b9ec814c1b1e6b3b595fe521d2cdc625fcca26fbc2d44c816804"}, - {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25add29b8f3b233ae90ccef2d902d0ae0432eb0d45370fe315d1a5cf231004b"}, - {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f459a5ce8434614dfd39bbebf1041952ae01da6bed9855008cb33b875cb024c0"}, - {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eff2de745698eb46eeb51193a9f41d67d834d50e424aef27df2fcdee1b153845"}, - {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8309f67285bdfe65c372ea3722b7a5642680f3dba538566340a9d36e920b5f0"}, - {file = "pydantic_core-2.18.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f93a8a2e3938ff656a7c1bc57193b1319960ac015b6e87d76c76bf14fe0244b4"}, - {file = "pydantic_core-2.18.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:22057013c8c1e272eb8d0eebc796701167d8377441ec894a8fed1af64a0bf399"}, - {file = "pydantic_core-2.18.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:cfeecd1ac6cc1fb2692c3d5110781c965aabd4ec5d32799773ca7b1456ac636b"}, - {file = "pydantic_core-2.18.2-cp39-none-win32.whl", hash = "sha256:0d69b4c2f6bb3e130dba60d34c0845ba31b69babdd3f78f7c0c8fae5021a253e"}, - {file = "pydantic_core-2.18.2-cp39-none-win_amd64.whl", hash = "sha256:d9319e499827271b09b4e411905b24a426b8fb69464dfa1696258f53a3334641"}, - {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a1874c6dd4113308bd0eb568418e6114b252afe44319ead2b4081e9b9521fe75"}, - {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:ccdd111c03bfd3666bd2472b674c6899550e09e9f298954cfc896ab92b5b0e6d"}, - {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e18609ceaa6eed63753037fc06ebb16041d17d28199ae5aba0052c51449650a9"}, - {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e5c584d357c4e2baf0ff7baf44f4994be121e16a2c88918a5817331fc7599d7"}, - {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43f0f463cf89ace478de71a318b1b4f05ebc456a9b9300d027b4b57c1a2064fb"}, - {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:e1b395e58b10b73b07b7cf740d728dd4ff9365ac46c18751bf8b3d8cca8f625a"}, - {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0098300eebb1c837271d3d1a2cd2911e7c11b396eac9661655ee524a7f10587b"}, - {file = "pydantic_core-2.18.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:36789b70d613fbac0a25bb07ab3d9dba4d2e38af609c020cf4d888d165ee0bf3"}, - {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3f9a801e7c8f1ef8718da265bba008fa121243dfe37c1cea17840b0944dfd72c"}, - {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:3a6515ebc6e69d85502b4951d89131ca4e036078ea35533bb76327f8424531ce"}, - {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20aca1e2298c56ececfd8ed159ae4dde2df0781988c97ef77d5c16ff4bd5b400"}, - {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:223ee893d77a310a0391dca6df00f70bbc2f36a71a895cecd9a0e762dc37b349"}, - {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2334ce8c673ee93a1d6a65bd90327588387ba073c17e61bf19b4fd97d688d63c"}, - {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:cbca948f2d14b09d20268cda7b0367723d79063f26c4ffc523af9042cad95592"}, - {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b3ef08e20ec49e02d5c6717a91bb5af9b20f1805583cb0adfe9ba2c6b505b5ae"}, - {file = "pydantic_core-2.18.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c6fdc8627910eed0c01aed6a390a252fe3ea6d472ee70fdde56273f198938374"}, - {file = "pydantic_core-2.18.2.tar.gz", hash = "sha256:2e29d20810dfc3043ee13ac7d9e25105799817683348823f305ab3f349b9386e"}, + {file = "pydantic_core-2.23.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:b10bd51f823d891193d4717448fab065733958bdb6a6b351967bd349d48d5c9b"}, + {file = "pydantic_core-2.23.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4fc714bdbfb534f94034efaa6eadd74e5b93c8fa6315565a222f7b6f42ca1166"}, + {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63e46b3169866bd62849936de036f901a9356e36376079b05efa83caeaa02ceb"}, + {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed1a53de42fbe34853ba90513cea21673481cd81ed1be739f7f2efb931b24916"}, + {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cfdd16ab5e59fc31b5e906d1a3f666571abc367598e3e02c83403acabc092e07"}, + {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255a8ef062cbf6674450e668482456abac99a5583bbafb73f9ad469540a3a232"}, + {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a7cd62e831afe623fbb7aabbb4fe583212115b3ef38a9f6b71869ba644624a2"}, + {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f09e2ff1f17c2b51f2bc76d1cc33da96298f0a036a137f5440ab3ec5360b624f"}, + {file = "pydantic_core-2.23.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e38e63e6f3d1cec5a27e0afe90a085af8b6806ee208b33030e65b6516353f1a3"}, + {file = "pydantic_core-2.23.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0dbd8dbed2085ed23b5c04afa29d8fd2771674223135dc9bc937f3c09284d071"}, + {file = "pydantic_core-2.23.4-cp310-none-win32.whl", hash = "sha256:6531b7ca5f951d663c339002e91aaebda765ec7d61b7d1e3991051906ddde119"}, + {file = "pydantic_core-2.23.4-cp310-none-win_amd64.whl", hash = "sha256:7c9129eb40958b3d4500fa2467e6a83356b3b61bfff1b414c7361d9220f9ae8f"}, + {file = "pydantic_core-2.23.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:77733e3892bb0a7fa797826361ce8a9184d25c8dffaec60b7ffe928153680ba8"}, + {file = "pydantic_core-2.23.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b84d168f6c48fabd1f2027a3d1bdfe62f92cade1fb273a5d68e621da0e44e6d"}, + {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df49e7a0861a8c36d089c1ed57d308623d60416dab2647a4a17fe050ba85de0e"}, + {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ff02b6d461a6de369f07ec15e465a88895f3223eb75073ffea56b84d9331f607"}, + {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:996a38a83508c54c78a5f41456b0103c30508fed9abcad0a59b876d7398f25fd"}, + {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d97683ddee4723ae8c95d1eddac7c192e8c552da0c73a925a89fa8649bf13eea"}, + {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:216f9b2d7713eb98cb83c80b9c794de1f6b7e3145eef40400c62e86cee5f4e1e"}, + {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6f783e0ec4803c787bcea93e13e9932edab72068f68ecffdf86a99fd5918878b"}, + {file = "pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d0776dea117cf5272382634bd2a5c1b6eb16767c223c6a5317cd3e2a757c61a0"}, + {file = "pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d5f7a395a8cf1621939692dba2a6b6a830efa6b3cee787d82c7de1ad2930de64"}, + {file = "pydantic_core-2.23.4-cp311-none-win32.whl", hash = "sha256:74b9127ffea03643e998e0c5ad9bd3811d3dac8c676e47db17b0ee7c3c3bf35f"}, + {file = "pydantic_core-2.23.4-cp311-none-win_amd64.whl", hash = "sha256:98d134c954828488b153d88ba1f34e14259284f256180ce659e8d83e9c05eaa3"}, + {file = "pydantic_core-2.23.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f3e0da4ebaef65158d4dfd7d3678aad692f7666877df0002b8a522cdf088f231"}, + {file = "pydantic_core-2.23.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f69a8e0b033b747bb3e36a44e7732f0c99f7edd5cea723d45bc0d6e95377ffee"}, + {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:723314c1d51722ab28bfcd5240d858512ffd3116449c557a1336cbe3919beb87"}, + {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb2802e667b7051a1bebbfe93684841cc9351004e2badbd6411bf357ab8d5ac8"}, + {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d18ca8148bebe1b0a382a27a8ee60350091a6ddaf475fa05ef50dc35b5df6327"}, + {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33e3d65a85a2a4a0dc3b092b938a4062b1a05f3a9abde65ea93b233bca0e03f2"}, + {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:128585782e5bfa515c590ccee4b727fb76925dd04a98864182b22e89a4e6ed36"}, + {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:68665f4c17edcceecc112dfed5dbe6f92261fb9d6054b47d01bf6371a6196126"}, + {file = "pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:20152074317d9bed6b7a95ade3b7d6054845d70584216160860425f4fbd5ee9e"}, + {file = "pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9261d3ce84fa1d38ed649c3638feefeae23d32ba9182963e465d58d62203bd24"}, + {file = "pydantic_core-2.23.4-cp312-none-win32.whl", hash = "sha256:4ba762ed58e8d68657fc1281e9bb72e1c3e79cc5d464be146e260c541ec12d84"}, + {file = "pydantic_core-2.23.4-cp312-none-win_amd64.whl", hash = "sha256:97df63000f4fea395b2824da80e169731088656d1818a11b95f3b173747b6cd9"}, + {file = "pydantic_core-2.23.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7530e201d10d7d14abce4fb54cfe5b94a0aefc87da539d0346a484ead376c3cc"}, + {file = "pydantic_core-2.23.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:df933278128ea1cd77772673c73954e53a1c95a4fdf41eef97c2b779271bd0bd"}, + {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cb3da3fd1b6a5d0279a01877713dbda118a2a4fc6f0d821a57da2e464793f05"}, + {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:42c6dcb030aefb668a2b7009c85b27f90e51e6a3b4d5c9bc4c57631292015b0d"}, + {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:696dd8d674d6ce621ab9d45b205df149399e4bb9aa34102c970b721554828510"}, + {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2971bb5ffe72cc0f555c13e19b23c85b654dd2a8f7ab493c262071377bfce9f6"}, + {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8394d940e5d400d04cad4f75c0598665cbb81aecefaca82ca85bd28264af7f9b"}, + {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0dff76e0602ca7d4cdaacc1ac4c005e0ce0dcfe095d5b5259163a80d3a10d327"}, + {file = "pydantic_core-2.23.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7d32706badfe136888bdea71c0def994644e09fff0bfe47441deaed8e96fdbc6"}, + {file = "pydantic_core-2.23.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ed541d70698978a20eb63d8c5d72f2cc6d7079d9d90f6b50bad07826f1320f5f"}, + {file = "pydantic_core-2.23.4-cp313-none-win32.whl", hash = "sha256:3d5639516376dce1940ea36edf408c554475369f5da2abd45d44621cb616f769"}, + {file = "pydantic_core-2.23.4-cp313-none-win_amd64.whl", hash = "sha256:5a1504ad17ba4210df3a045132a7baeeba5a200e930f57512ee02909fc5c4cb5"}, + {file = "pydantic_core-2.23.4-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:d4488a93b071c04dc20f5cecc3631fc78b9789dd72483ba15d423b5b3689b555"}, + {file = "pydantic_core-2.23.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:81965a16b675b35e1d09dd14df53f190f9129c0202356ed44ab2728b1c905658"}, + {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ffa2ebd4c8530079140dd2d7f794a9d9a73cbb8e9d59ffe24c63436efa8f271"}, + {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:61817945f2fe7d166e75fbfb28004034b48e44878177fc54d81688e7b85a3665"}, + {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:29d2c342c4bc01b88402d60189f3df065fb0dda3654744d5a165a5288a657368"}, + {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5e11661ce0fd30a6790e8bcdf263b9ec5988e95e63cf901972107efc49218b13"}, + {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d18368b137c6295db49ce7218b1a9ba15c5bc254c96d7c9f9e924a9bc7825ad"}, + {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ec4e55f79b1c4ffb2eecd8a0cfba9955a2588497d96851f4c8f99aa4a1d39b12"}, + {file = "pydantic_core-2.23.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:374a5e5049eda9e0a44c696c7ade3ff355f06b1fe0bb945ea3cac2bc336478a2"}, + {file = "pydantic_core-2.23.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5c364564d17da23db1106787675fc7af45f2f7b58b4173bfdd105564e132e6fb"}, + {file = "pydantic_core-2.23.4-cp38-none-win32.whl", hash = "sha256:d7a80d21d613eec45e3d41eb22f8f94ddc758a6c4720842dc74c0581f54993d6"}, + {file = "pydantic_core-2.23.4-cp38-none-win_amd64.whl", hash = "sha256:5f5ff8d839f4566a474a969508fe1c5e59c31c80d9e140566f9a37bba7b8d556"}, + {file = "pydantic_core-2.23.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:a4fa4fc04dff799089689f4fd502ce7d59de529fc2f40a2c8836886c03e0175a"}, + {file = "pydantic_core-2.23.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0a7df63886be5e270da67e0966cf4afbae86069501d35c8c1b3b6c168f42cb36"}, + {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dcedcd19a557e182628afa1d553c3895a9f825b936415d0dbd3cd0bbcfd29b4b"}, + {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f54b118ce5de9ac21c363d9b3caa6c800341e8c47a508787e5868c6b79c9323"}, + {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86d2f57d3e1379a9525c5ab067b27dbb8a0642fb5d454e17a9ac434f9ce523e3"}, + {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:de6d1d1b9e5101508cb37ab0d972357cac5235f5c6533d1071964c47139257df"}, + {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1278e0d324f6908e872730c9102b0112477a7f7cf88b308e4fc36ce1bdb6d58c"}, + {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9a6b5099eeec78827553827f4c6b8615978bb4b6a88e5d9b93eddf8bb6790f55"}, + {file = "pydantic_core-2.23.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:e55541f756f9b3ee346b840103f32779c695a19826a4c442b7954550a0972040"}, + {file = "pydantic_core-2.23.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a5c7ba8ffb6d6f8f2ab08743be203654bb1aaa8c9dcb09f82ddd34eadb695605"}, + {file = "pydantic_core-2.23.4-cp39-none-win32.whl", hash = "sha256:37b0fe330e4a58d3c58b24d91d1eb102aeec675a3db4c292ec3928ecd892a9a6"}, + {file = "pydantic_core-2.23.4-cp39-none-win_amd64.whl", hash = "sha256:1498bec4c05c9c787bde9125cfdcc63a41004ff167f495063191b863399b1a29"}, + {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f455ee30a9d61d3e1a15abd5068827773d6e4dc513e795f380cdd59932c782d5"}, + {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1e90d2e3bd2c3863d48525d297cd143fe541be8bbf6f579504b9712cb6b643ec"}, + {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e203fdf807ac7e12ab59ca2bfcabb38c7cf0b33c41efeb00f8e5da1d86af480"}, + {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e08277a400de01bc72436a0ccd02bdf596631411f592ad985dcee21445bd0068"}, + {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f220b0eea5965dec25480b6333c788fb72ce5f9129e8759ef876a1d805d00801"}, + {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d06b0c8da4f16d1d1e352134427cb194a0a6e19ad5db9161bf32b2113409e728"}, + {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:ba1a0996f6c2773bd83e63f18914c1de3c9dd26d55f4ac302a7efe93fb8e7433"}, + {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:9a5bce9d23aac8f0cf0836ecfc033896aa8443b501c58d0602dbfd5bd5b37753"}, + {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:78ddaaa81421a29574a682b3179d4cf9e6d405a09b99d93ddcf7e5239c742e21"}, + {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:883a91b5dd7d26492ff2f04f40fbb652de40fcc0afe07e8129e8ae779c2110eb"}, + {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88ad334a15b32a791ea935af224b9de1bf99bcd62fabf745d5f3442199d86d59"}, + {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:233710f069d251feb12a56da21e14cca67994eab08362207785cf8c598e74577"}, + {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:19442362866a753485ba5e4be408964644dd6a09123d9416c54cd49171f50744"}, + {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:624e278a7d29b6445e4e813af92af37820fafb6dcc55c012c834f9e26f9aaaef"}, + {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f5ef8f42bec47f21d07668a043f077d507e5bf4e668d5c6dfe6aaba89de1a5b8"}, + {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:aea443fffa9fbe3af1a9ba721a87f926fe548d32cab71d188a6ede77d0ff244e"}, + {file = "pydantic_core-2.23.4.tar.gz", hash = "sha256:2584f7cf844ac4d970fba483a717dbe10c1c1c96a969bf65d61ffe94df1b2863"}, ] [package.dependencies] @@ -3660,13 +3906,13 @@ windows-terminal = ["colorama (>=0.4.6)"] [[package]] name = "pyjwt" -version = "2.8.0" +version = "2.9.0" description = "JSON Web Token implementation in Python" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "PyJWT-2.8.0-py3-none-any.whl", hash = "sha256:59127c392cc44c2da5bb3192169a91f429924e17aff6534d70fdc02ab3e04320"}, - {file = "PyJWT-2.8.0.tar.gz", hash = "sha256:57e28d156e3d5c10088e0c68abb90bfac3df82b40a71bd0daa20c65ccd5c23de"}, + {file = "PyJWT-2.9.0-py3-none-any.whl", hash = "sha256:3b02fb0f44517787776cf48f2ae25d8e14f300e6d7545a4315cee571a415e850"}, + {file = "pyjwt-2.9.0.tar.gz", hash = "sha256:7e1e5b56cc735432a7369cbfa0efe50fa113ebecdc04ae6922deba8b84582d0c"}, ] [package.dependencies] @@ -3674,8 +3920,8 @@ cryptography = {version = ">=3.4.0", optional = true, markers = "extra == \"cryp [package.extras] crypto = ["cryptography (>=3.4.0)"] -dev = ["coverage[toml] (==5.0.4)", "cryptography (>=3.4.0)", "pre-commit", "pytest (>=6.0.0,<7.0.0)", "sphinx (>=4.5.0,<5.0.0)", "sphinx-rtd-theme", "zope.interface"] -docs = ["sphinx (>=4.5.0,<5.0.0)", "sphinx-rtd-theme", "zope.interface"] +dev = ["coverage[toml] (==5.0.4)", "cryptography (>=3.4.0)", "pre-commit", "pytest (>=6.0.0,<7.0.0)", "sphinx", "sphinx-rtd-theme", "zope.interface"] +docs = ["sphinx", "sphinx-rtd-theme", "zope.interface"] tests = ["coverage[toml] (==5.0.4)", "pytest (>=6.0.0,<7.0.0)"] [[package]] @@ -3694,7 +3940,8 @@ astroid = ">=3.1.0,<=3.2.0-dev0" colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""} dill = [ {version = ">=0.2", markers = "python_version < \"3.11\""}, - {version = ">=0.3.6", markers = "python_version >= \"3.11\""}, + {version = ">=0.3.6", markers = "python_version >= \"3.11\" and python_version < \"3.12\""}, + {version = ">=0.3.7", markers = "python_version >= \"3.12\""}, ] isort = ">=4.2.5,<5.13.0 || >5.13.0,<6" mccabe = ">=0.6,<0.8" @@ -3759,13 +4006,13 @@ tqdm = "*" [[package]] name = "pyparsing" -version = "3.1.2" +version = "3.1.4" description = "pyparsing module - Classes and methods to define and execute parsing grammars" optional = false python-versions = ">=3.6.8" files = [ - {file = "pyparsing-3.1.2-py3-none-any.whl", hash = "sha256:f9db75911801ed778fe61bb643079ff86601aca99fcae6345aa67292038fb742"}, - {file = "pyparsing-3.1.2.tar.gz", hash = "sha256:a1bac0ce561155ecc3ed78ca94d3c9378656ad4c94c1270de543f621420f94ad"}, + {file = "pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c"}, + {file = "pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032"}, ] [package.extras] @@ -3807,13 +4054,13 @@ cp2110 = ["hidapi"] [[package]] name = "pytest" -version = "8.2.0" +version = "8.3.3" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.8" files = [ - {file = "pytest-8.2.0-py3-none-any.whl", hash = "sha256:1733f0620f6cda4095bbf0d9ff8022486e91892245bb9e7d5542c018f612f233"}, - {file = "pytest-8.2.0.tar.gz", hash = "sha256:d507d4482197eac0ba2bae2e9babf0672eb333017bcedaa5fb1a3d42c1174b3f"}, + {file = "pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2"}, + {file = "pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181"}, ] [package.dependencies] @@ -3821,7 +4068,7 @@ colorama = {version = "*", markers = "sys_platform == \"win32\""} exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} iniconfig = "*" packaging = "*" -pluggy = ">=1.5,<2.0" +pluggy = ">=1.5,<2" tomli = {version = ">=1", markers = "python_version < \"3.11\""} [package.extras] @@ -3847,21 +4094,21 @@ testing = ["fields", "hunter", "process-tests", "pytest-xdist", "six", "virtuale [[package]] name = "pytest-env" -version = "1.1.3" +version = "1.1.5" description = "pytest plugin that allows you to add environment variables." optional = false python-versions = ">=3.8" files = [ - {file = "pytest_env-1.1.3-py3-none-any.whl", hash = "sha256:aada77e6d09fcfb04540a6e462c58533c37df35fa853da78707b17ec04d17dfc"}, - {file = "pytest_env-1.1.3.tar.gz", hash = "sha256:fcd7dc23bb71efd3d35632bde1bbe5ee8c8dc4489d6617fb010674880d96216b"}, + {file = "pytest_env-1.1.5-py3-none-any.whl", hash = "sha256:ce90cf8772878515c24b31cd97c7fa1f4481cd68d588419fd45f10ecaee6bc30"}, + {file = "pytest_env-1.1.5.tar.gz", hash = "sha256:91209840aa0e43385073ac464a554ad2947cc2fd663a9debf88d03b01e0cc1cf"}, ] [package.dependencies] -pytest = ">=7.4.3" +pytest = ">=8.3.3" tomli = {version = ">=2.0.1", markers = "python_version < \"3.11\""} [package.extras] -test = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "pytest-mock (>=3.12)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "pytest-mock (>=3.14)"] [[package]] name = "pytest-mock" @@ -3882,25 +4129,28 @@ dev = ["pre-commit", "pytest-asyncio", "tox"] [[package]] name = "python-box" -version = "7.1.1" +version = "7.2.0" description = "Advanced Python dictionaries with dot notation access" optional = false python-versions = ">=3.8" files = [ - {file = "python-box-7.1.1.tar.gz", hash = "sha256:2a3df244a5a79ac8f8447b5d11b5be0f2747d7b141cb2866060081ae9b53cc50"}, - {file = "python_box-7.1.1-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:81ed1ec0f0ff2370227fc07277c5baca46d190a4747631bad7eb6ab1630fb7d9"}, - {file = "python_box-7.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8891735b4148e84d348c6eadd2f127152f751c9603e35d43a1f496183a291ac4"}, - {file = "python_box-7.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:0036fd47d388deaca8ebd65aea905f88ee6ef91d1d8ce34898b66f1824afbe80"}, - {file = "python_box-7.1.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:aabf8b9ae5dbc8ba431d8cbe0d4cfe737a25d52d68b0f5f2ff34915c21a2c1db"}, - {file = "python_box-7.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c046608337e723ae4de3206db5d1e1202ed166da2dfdc70c1f9361e72ace5633"}, - {file = "python_box-7.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9266795e9c233874fb5b34fa994054b4fb0371881678e6ec45aec17fc95feac"}, - {file = "python_box-7.1.1-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:f76b5b7f0cdc07bfdd4200dc24e6e33189bb2ae322137a2b7110fd41891a3157"}, - {file = "python_box-7.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ea13c98e05a3ec0ff26f254986a17290b69b5ade209fad081fd628f8fcfaa08"}, - {file = "python_box-7.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:1b3f346e332dba16df0b0543d319d9e7ce07d93e5ae152175302894352aa2d28"}, - {file = "python_box-7.1.1-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:24c4ec0ee0278f66321100aaa9c615413da27a14ff43d376a2a3b4665e1d9494"}, - {file = "python_box-7.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d95e5eec4fc8f3fc5c9cc7347fc2eb4f9187c853d34c90b1658d1eff96cd4eac"}, - {file = "python_box-7.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:a0f1333c42e81529b6f68c192050df9d4505b803be7ac47f114036b98707f7cf"}, - {file = "python_box-7.1.1-py3-none-any.whl", hash = "sha256:63b609555554d7a9d4b6e725f8e78ef1717c67e7d386200e03422ad612338df8"}, + {file = "python_box-7.2.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:6bdeec791e25258351388b3029a3ec5da302bb9ed3be175493c43cdc6c47f5e3"}, + {file = "python_box-7.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c449f7b3756a71479fa9c61a86e344ac00ed782a66d7662590f0afa294249d18"}, + {file = "python_box-7.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:6b0d61f182d394106d963232854e495b51edc178faa5316a797be1178212d7e0"}, + {file = "python_box-7.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e2d752de8c1204255bf7b0c814c59ef48293c187a7e9fdcd2fefa28024b72032"}, + {file = "python_box-7.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e8a6c35ea356a386077935958a5debcd5b229b9a1b3b26287a52dfe1a7e65d99"}, + {file = "python_box-7.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:32ed58ec4d9e5475efe69f9c7d773dfea90a6a01979e776da93fd2b0a5d04429"}, + {file = "python_box-7.2.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:2a2d664c6a27f7515469b6f1e461935a2038ee130b7d194b4b4db4e85d363618"}, + {file = "python_box-7.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e8a5a7365db1aaf600d3e8a2747fcf6833beb5d45439a54318548f02e302e3ec"}, + {file = "python_box-7.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:739f827056ea148cbea3122d4617c994e829b420b1331183d968b175304e3a4f"}, + {file = "python_box-7.2.0-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:2617ef3c3d199f55f63c908f540a4dc14ced9b18533a879e6171c94a6a436f23"}, + {file = "python_box-7.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffd866bed03087b1d8340014da8c3aaae19135767580641df1b4ae6fff6ac0aa"}, + {file = "python_box-7.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:9681f059e7e92bdf20782cd9ea6e533d4711fc7b8c57a462922a025d46add4d0"}, + {file = "python_box-7.2.0-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:6b59b1e2741c9ceecdf5a5bd9b90502c24650e609cd824d434fed3b6f302b7bb"}, + {file = "python_box-7.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e23fae825d809ae7520fdeac88bb52be55a3b63992120a00e381783669edf589"}, + {file = "python_box-7.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:573b1abdcb7bd745fa404444f060ee62fc35a74f067181e55dcb43cfe92f2827"}, + {file = "python_box-7.2.0-py3-none-any.whl", hash = "sha256:a3c90832dd772cb0197fdb5bc06123b6e1b846899a1b53d9c39450d27a584829"}, + {file = "python_box-7.2.0.tar.gz", hash = "sha256:551af20bdab3a60a2a21e3435120453c4ca32f7393787c3a5036e1d9fc6a0ede"}, ] [package.extras] @@ -3939,13 +4189,13 @@ files = [ [[package]] name = "pytz" -version = "2024.1" +version = "2024.2" description = "World timezone definitions, modern and historical" optional = false python-versions = "*" files = [ - {file = "pytz-2024.1-py2.py3-none-any.whl", hash = "sha256:328171f4e3623139da4983451950b28e95ac706e13f3f2630a879749e7a8b319"}, - {file = "pytz-2024.1.tar.gz", hash = "sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812"}, + {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, + {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, ] [[package]] @@ -4007,159 +4257,182 @@ files = [ [[package]] name = "pyyaml" -version = "6.0.1" +version = "6.0.2" description = "YAML parser and emitter for Python" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" files = [ - {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"}, - {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"}, - {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"}, - {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"}, - {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"}, - {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"}, - {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"}, - {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"}, - {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"}, - {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"}, - {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"}, - {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"}, - {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"}, - {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"}, - {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"}, - {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, - {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, - {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, - {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef"}, - {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, - {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, - {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, - {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"}, - {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"}, - {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"}, - {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"}, - {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"}, - {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"}, - {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"}, - {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"}, - {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"}, - {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"}, - {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"}, - {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"}, - {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"}, - {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"}, - {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"}, - {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"}, - {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"}, - {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"}, - {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"}, - {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"}, - {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"}, - {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"}, - {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"}, - {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"}, - {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"}, - {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"}, - {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"}, - {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"}, - {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, + {file = "PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086"}, + {file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"}, + {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237"}, + {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b"}, + {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed"}, + {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180"}, + {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68"}, + {file = "PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99"}, + {file = "PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e"}, + {file = "PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774"}, + {file = "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee"}, + {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c"}, + {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317"}, + {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85"}, + {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4"}, + {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e"}, + {file = "PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5"}, + {file = "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44"}, + {file = "PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab"}, + {file = "PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725"}, + {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5"}, + {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425"}, + {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476"}, + {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48"}, + {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b"}, + {file = "PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4"}, + {file = "PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"}, + {file = "PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba"}, + {file = "PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1"}, + {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133"}, + {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484"}, + {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5"}, + {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc"}, + {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652"}, + {file = "PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183"}, + {file = "PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563"}, + {file = "PyYAML-6.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a"}, + {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5"}, + {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d"}, + {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083"}, + {file = "PyYAML-6.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706"}, + {file = "PyYAML-6.0.2-cp38-cp38-win32.whl", hash = "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a"}, + {file = "PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff"}, + {file = "PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d"}, + {file = "PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f"}, + {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290"}, + {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12"}, + {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19"}, + {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e"}, + {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725"}, + {file = "PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631"}, + {file = "PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8"}, + {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, ] [[package]] name = "pyzmq" -version = "26.0.3" +version = "26.2.0" description = "Python bindings for 0MQ" optional = false python-versions = ">=3.7" files = [ - {file = "pyzmq-26.0.3-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:44dd6fc3034f1eaa72ece33588867df9e006a7303725a12d64c3dff92330f625"}, - {file = "pyzmq-26.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:acb704195a71ac5ea5ecf2811c9ee19ecdc62b91878528302dd0be1b9451cc90"}, - {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dbb9c997932473a27afa93954bb77a9f9b786b4ccf718d903f35da3232317de"}, - {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6bcb34f869d431799c3ee7d516554797f7760cb2198ecaa89c3f176f72d062be"}, - {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38ece17ec5f20d7d9b442e5174ae9f020365d01ba7c112205a4d59cf19dc38ee"}, - {file = "pyzmq-26.0.3-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:ba6e5e6588e49139a0979d03a7deb9c734bde647b9a8808f26acf9c547cab1bf"}, - {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:3bf8b000a4e2967e6dfdd8656cd0757d18c7e5ce3d16339e550bd462f4857e59"}, - {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:2136f64fbb86451dbbf70223635a468272dd20075f988a102bf8a3f194a411dc"}, - {file = "pyzmq-26.0.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e8918973fbd34e7814f59143c5f600ecd38b8038161239fd1a3d33d5817a38b8"}, - {file = "pyzmq-26.0.3-cp310-cp310-win32.whl", hash = "sha256:0aaf982e68a7ac284377d051c742610220fd06d330dcd4c4dbb4cdd77c22a537"}, - {file = "pyzmq-26.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:f1a9b7d00fdf60b4039f4455afd031fe85ee8305b019334b72dcf73c567edc47"}, - {file = "pyzmq-26.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:80b12f25d805a919d53efc0a5ad7c0c0326f13b4eae981a5d7b7cc343318ebb7"}, - {file = "pyzmq-26.0.3-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:a72a84570f84c374b4c287183debc776dc319d3e8ce6b6a0041ce2e400de3f32"}, - {file = "pyzmq-26.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7ca684ee649b55fd8f378127ac8462fb6c85f251c2fb027eb3c887e8ee347bcd"}, - {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e222562dc0f38571c8b1ffdae9d7adb866363134299264a1958d077800b193b7"}, - {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f17cde1db0754c35a91ac00b22b25c11da6eec5746431d6e5092f0cd31a3fea9"}, - {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b7c0c0b3244bb2275abe255d4a30c050d541c6cb18b870975553f1fb6f37527"}, - {file = "pyzmq-26.0.3-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:ac97a21de3712afe6a6c071abfad40a6224fd14fa6ff0ff8d0c6e6cd4e2f807a"}, - {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:88b88282e55fa39dd556d7fc04160bcf39dea015f78e0cecec8ff4f06c1fc2b5"}, - {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:72b67f966b57dbd18dcc7efbc1c7fc9f5f983e572db1877081f075004614fcdd"}, - {file = "pyzmq-26.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f4b6cecbbf3b7380f3b61de3a7b93cb721125dc125c854c14ddc91225ba52f83"}, - {file = "pyzmq-26.0.3-cp311-cp311-win32.whl", hash = "sha256:eed56b6a39216d31ff8cd2f1d048b5bf1700e4b32a01b14379c3b6dde9ce3aa3"}, - {file = "pyzmq-26.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:3191d312c73e3cfd0f0afdf51df8405aafeb0bad71e7ed8f68b24b63c4f36500"}, - {file = "pyzmq-26.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:b6907da3017ef55139cf0e417c5123a84c7332520e73a6902ff1f79046cd3b94"}, - {file = "pyzmq-26.0.3-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:068ca17214038ae986d68f4a7021f97e187ed278ab6dccb79f837d765a54d753"}, - {file = "pyzmq-26.0.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:7821d44fe07335bea256b9f1f41474a642ca55fa671dfd9f00af8d68a920c2d4"}, - {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eeb438a26d87c123bb318e5f2b3d86a36060b01f22fbdffd8cf247d52f7c9a2b"}, - {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:69ea9d6d9baa25a4dc9cef5e2b77b8537827b122214f210dd925132e34ae9b12"}, - {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7daa3e1369355766dea11f1d8ef829905c3b9da886ea3152788dc25ee6079e02"}, - {file = "pyzmq-26.0.3-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6ca7a9a06b52d0e38ccf6bca1aeff7be178917893f3883f37b75589d42c4ac20"}, - {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1b7d0e124948daa4d9686d421ef5087c0516bc6179fdcf8828b8444f8e461a77"}, - {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e746524418b70f38550f2190eeee834db8850088c834d4c8406fbb9bc1ae10b2"}, - {file = "pyzmq-26.0.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:6b3146f9ae6af82c47a5282ac8803523d381b3b21caeae0327ed2f7ecb718798"}, - {file = "pyzmq-26.0.3-cp312-cp312-win32.whl", hash = "sha256:2b291d1230845871c00c8462c50565a9cd6026fe1228e77ca934470bb7d70ea0"}, - {file = "pyzmq-26.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:926838a535c2c1ea21c903f909a9a54e675c2126728c21381a94ddf37c3cbddf"}, - {file = "pyzmq-26.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:5bf6c237f8c681dfb91b17f8435b2735951f0d1fad10cc5dfd96db110243370b"}, - {file = "pyzmq-26.0.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c0991f5a96a8e620f7691e61178cd8f457b49e17b7d9cfa2067e2a0a89fc1d5"}, - {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:dbf012d8fcb9f2cf0643b65df3b355fdd74fc0035d70bb5c845e9e30a3a4654b"}, - {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:01fbfbeb8249a68d257f601deb50c70c929dc2dfe683b754659569e502fbd3aa"}, - {file = "pyzmq-26.0.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c8eb19abe87029c18f226d42b8a2c9efdd139d08f8bf6e085dd9075446db450"}, - {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:5344b896e79800af86ad643408ca9aa303a017f6ebff8cee5a3163c1e9aec987"}, - {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:204e0f176fd1d067671157d049466869b3ae1fc51e354708b0dc41cf94e23a3a"}, - {file = "pyzmq-26.0.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:a42db008d58530efa3b881eeee4991146de0b790e095f7ae43ba5cc612decbc5"}, - {file = "pyzmq-26.0.3-cp37-cp37m-win32.whl", hash = "sha256:8d7a498671ca87e32b54cb47c82a92b40130a26c5197d392720a1bce1b3c77cf"}, - {file = "pyzmq-26.0.3-cp37-cp37m-win_amd64.whl", hash = "sha256:3b4032a96410bdc760061b14ed6a33613ffb7f702181ba999df5d16fb96ba16a"}, - {file = "pyzmq-26.0.3-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:2cc4e280098c1b192c42a849de8de2c8e0f3a84086a76ec5b07bfee29bda7d18"}, - {file = "pyzmq-26.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5bde86a2ed3ce587fa2b207424ce15b9a83a9fa14422dcc1c5356a13aed3df9d"}, - {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:34106f68e20e6ff253c9f596ea50397dbd8699828d55e8fa18bd4323d8d966e6"}, - {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ebbbd0e728af5db9b04e56389e2299a57ea8b9dd15c9759153ee2455b32be6ad"}, - {file = "pyzmq-26.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6b1d1c631e5940cac5a0b22c5379c86e8df6a4ec277c7a856b714021ab6cfad"}, - {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e891ce81edd463b3b4c3b885c5603c00141151dd9c6936d98a680c8c72fe5c67"}, - {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:9b273ecfbc590a1b98f014ae41e5cf723932f3b53ba9367cfb676f838038b32c"}, - {file = "pyzmq-26.0.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b32bff85fb02a75ea0b68f21e2412255b5731f3f389ed9aecc13a6752f58ac97"}, - {file = "pyzmq-26.0.3-cp38-cp38-win32.whl", hash = "sha256:f6c21c00478a7bea93caaaef9e7629145d4153b15a8653e8bb4609d4bc70dbfc"}, - {file = "pyzmq-26.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:3401613148d93ef0fd9aabdbddb212de3db7a4475367f49f590c837355343972"}, - {file = "pyzmq-26.0.3-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:2ed8357f4c6e0daa4f3baf31832df8a33334e0fe5b020a61bc8b345a3db7a606"}, - {file = "pyzmq-26.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c1c8f2a2ca45292084c75bb6d3a25545cff0ed931ed228d3a1810ae3758f975f"}, - {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b63731993cdddcc8e087c64e9cf003f909262b359110070183d7f3025d1c56b5"}, - {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b3cd31f859b662ac5d7f4226ec7d8bd60384fa037fc02aee6ff0b53ba29a3ba8"}, - {file = "pyzmq-26.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:115f8359402fa527cf47708d6f8a0f8234f0e9ca0cab7c18c9c189c194dbf620"}, - {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:715bdf952b9533ba13dfcf1f431a8f49e63cecc31d91d007bc1deb914f47d0e4"}, - {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:e1258c639e00bf5e8a522fec6c3eaa3e30cf1c23a2f21a586be7e04d50c9acab"}, - {file = "pyzmq-26.0.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:15c59e780be8f30a60816a9adab900c12a58d79c1ac742b4a8df044ab2a6d920"}, - {file = "pyzmq-26.0.3-cp39-cp39-win32.whl", hash = "sha256:d0cdde3c78d8ab5b46595054e5def32a755fc028685add5ddc7403e9f6de9879"}, - {file = "pyzmq-26.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:ce828058d482ef860746bf532822842e0ff484e27f540ef5c813d516dd8896d2"}, - {file = "pyzmq-26.0.3-cp39-cp39-win_arm64.whl", hash = "sha256:788f15721c64109cf720791714dc14afd0f449d63f3a5487724f024345067381"}, - {file = "pyzmq-26.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2c18645ef6294d99b256806e34653e86236eb266278c8ec8112622b61db255de"}, - {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7e6bc96ebe49604df3ec2c6389cc3876cabe475e6bfc84ced1bf4e630662cb35"}, - {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:971e8990c5cc4ddcff26e149398fc7b0f6a042306e82500f5e8db3b10ce69f84"}, - {file = "pyzmq-26.0.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8416c23161abd94cc7da80c734ad7c9f5dbebdadfdaa77dad78244457448223"}, - {file = "pyzmq-26.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:082a2988364b60bb5de809373098361cf1dbb239623e39e46cb18bc035ed9c0c"}, - {file = "pyzmq-26.0.3-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d57dfbf9737763b3a60d26e6800e02e04284926329aee8fb01049635e957fe81"}, - {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:77a85dca4c2430ac04dc2a2185c2deb3858a34fe7f403d0a946fa56970cf60a1"}, - {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4c82a6d952a1d555bf4be42b6532927d2a5686dd3c3e280e5f63225ab47ac1f5"}, - {file = "pyzmq-26.0.3-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4496b1282c70c442809fc1b151977c3d967bfb33e4e17cedbf226d97de18f709"}, - {file = "pyzmq-26.0.3-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:e4946d6bdb7ba972dfda282f9127e5756d4f299028b1566d1245fa0d438847e6"}, - {file = "pyzmq-26.0.3-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:03c0ae165e700364b266876d712acb1ac02693acd920afa67da2ebb91a0b3c09"}, - {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:3e3070e680f79887d60feeda051a58d0ac36622e1759f305a41059eff62c6da7"}, - {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6ca08b840fe95d1c2bd9ab92dac5685f949fc6f9ae820ec16193e5ddf603c3b2"}, - {file = "pyzmq-26.0.3-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e76654e9dbfb835b3518f9938e565c7806976c07b37c33526b574cc1a1050480"}, - {file = "pyzmq-26.0.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:871587bdadd1075b112e697173e946a07d722459d20716ceb3d1bd6c64bd08ce"}, - {file = "pyzmq-26.0.3-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d0a2d1bd63a4ad79483049b26514e70fa618ce6115220da9efdff63688808b17"}, - {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0270b49b6847f0d106d64b5086e9ad5dc8a902413b5dbbb15d12b60f9c1747a4"}, - {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:703c60b9910488d3d0954ca585c34f541e506a091a41930e663a098d3b794c67"}, - {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:74423631b6be371edfbf7eabb02ab995c2563fee60a80a30829176842e71722a"}, - {file = "pyzmq-26.0.3-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4adfbb5451196842a88fda3612e2c0414134874bffb1c2ce83ab4242ec9e027d"}, - {file = "pyzmq-26.0.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3516119f4f9b8671083a70b6afaa0a070f5683e431ab3dc26e9215620d7ca1ad"}, - {file = "pyzmq-26.0.3.tar.gz", hash = "sha256:dba7d9f2e047dfa2bca3b01f4f84aa5246725203d6284e3790f2ca15fba6b40a"}, + {file = "pyzmq-26.2.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:ddf33d97d2f52d89f6e6e7ae66ee35a4d9ca6f36eda89c24591b0c40205a3629"}, + {file = "pyzmq-26.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dacd995031a01d16eec825bf30802fceb2c3791ef24bcce48fa98ce40918c27b"}, + {file = "pyzmq-26.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89289a5ee32ef6c439086184529ae060c741334b8970a6855ec0b6ad3ff28764"}, + {file = "pyzmq-26.2.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5506f06d7dc6ecf1efacb4a013b1f05071bb24b76350832c96449f4a2d95091c"}, + {file = "pyzmq-26.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ea039387c10202ce304af74def5021e9adc6297067f3441d348d2b633e8166a"}, + {file = "pyzmq-26.2.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a2224fa4a4c2ee872886ed00a571f5e967c85e078e8e8c2530a2fb01b3309b88"}, + {file = "pyzmq-26.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:28ad5233e9c3b52d76196c696e362508959741e1a005fb8fa03b51aea156088f"}, + {file = "pyzmq-26.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:1c17211bc037c7d88e85ed8b7d8f7e52db6dc8eca5590d162717c654550f7282"}, + {file = "pyzmq-26.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b8f86dd868d41bea9a5f873ee13bf5551c94cf6bc51baebc6f85075971fe6eea"}, + {file = "pyzmq-26.2.0-cp310-cp310-win32.whl", hash = "sha256:46a446c212e58456b23af260f3d9fb785054f3e3653dbf7279d8f2b5546b21c2"}, + {file = "pyzmq-26.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:49d34ab71db5a9c292a7644ce74190b1dd5a3475612eefb1f8be1d6961441971"}, + {file = "pyzmq-26.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:bfa832bfa540e5b5c27dcf5de5d82ebc431b82c453a43d141afb1e5d2de025fa"}, + {file = "pyzmq-26.2.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:8f7e66c7113c684c2b3f1c83cdd3376103ee0ce4c49ff80a648643e57fb22218"}, + {file = "pyzmq-26.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3a495b30fc91db2db25120df5847d9833af237546fd59170701acd816ccc01c4"}, + {file = "pyzmq-26.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77eb0968da535cba0470a5165468b2cac7772cfb569977cff92e240f57e31bef"}, + {file = "pyzmq-26.2.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ace4f71f1900a548f48407fc9be59c6ba9d9aaf658c2eea6cf2779e72f9f317"}, + {file = "pyzmq-26.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:92a78853d7280bffb93df0a4a6a2498cba10ee793cc8076ef797ef2f74d107cf"}, + {file = "pyzmq-26.2.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:689c5d781014956a4a6de61d74ba97b23547e431e9e7d64f27d4922ba96e9d6e"}, + {file = "pyzmq-26.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0aca98bc423eb7d153214b2df397c6421ba6373d3397b26c057af3c904452e37"}, + {file = "pyzmq-26.2.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:1f3496d76b89d9429a656293744ceca4d2ac2a10ae59b84c1da9b5165f429ad3"}, + {file = "pyzmq-26.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5c2b3bfd4b9689919db068ac6c9911f3fcb231c39f7dd30e3138be94896d18e6"}, + {file = "pyzmq-26.2.0-cp311-cp311-win32.whl", hash = "sha256:eac5174677da084abf378739dbf4ad245661635f1600edd1221f150b165343f4"}, + {file = "pyzmq-26.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:5a509df7d0a83a4b178d0f937ef14286659225ef4e8812e05580776c70e155d5"}, + {file = "pyzmq-26.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:c0e6091b157d48cbe37bd67233318dbb53e1e6327d6fc3bb284afd585d141003"}, + {file = "pyzmq-26.2.0-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:ded0fc7d90fe93ae0b18059930086c51e640cdd3baebdc783a695c77f123dcd9"}, + {file = "pyzmq-26.2.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:17bf5a931c7f6618023cdacc7081f3f266aecb68ca692adac015c383a134ca52"}, + {file = "pyzmq-26.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55cf66647e49d4621a7e20c8d13511ef1fe1efbbccf670811864452487007e08"}, + {file = "pyzmq-26.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4661c88db4a9e0f958c8abc2b97472e23061f0bc737f6f6179d7a27024e1faa5"}, + {file = "pyzmq-26.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea7f69de383cb47522c9c208aec6dd17697db7875a4674c4af3f8cfdac0bdeae"}, + {file = "pyzmq-26.2.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:7f98f6dfa8b8ccaf39163ce872bddacca38f6a67289116c8937a02e30bbe9711"}, + {file = "pyzmq-26.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e3e0210287329272539eea617830a6a28161fbbd8a3271bf4150ae3e58c5d0e6"}, + {file = "pyzmq-26.2.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:6b274e0762c33c7471f1a7471d1a2085b1a35eba5cdc48d2ae319f28b6fc4de3"}, + {file = "pyzmq-26.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:29c6a4635eef69d68a00321e12a7d2559fe2dfccfa8efae3ffb8e91cd0b36a8b"}, + {file = "pyzmq-26.2.0-cp312-cp312-win32.whl", hash = "sha256:989d842dc06dc59feea09e58c74ca3e1678c812a4a8a2a419046d711031f69c7"}, + {file = "pyzmq-26.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:2a50625acdc7801bc6f74698c5c583a491c61d73c6b7ea4dee3901bb99adb27a"}, + {file = "pyzmq-26.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:4d29ab8592b6ad12ebbf92ac2ed2bedcfd1cec192d8e559e2e099f648570e19b"}, + {file = "pyzmq-26.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9dd8cd1aeb00775f527ec60022004d030ddc51d783d056e3e23e74e623e33726"}, + {file = "pyzmq-26.2.0-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:28c812d9757fe8acecc910c9ac9dafd2ce968c00f9e619db09e9f8f54c3a68a3"}, + {file = "pyzmq-26.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d80b1dd99c1942f74ed608ddb38b181b87476c6a966a88a950c7dee118fdf50"}, + {file = "pyzmq-26.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8c997098cc65e3208eca09303630e84d42718620e83b733d0fd69543a9cab9cb"}, + {file = "pyzmq-26.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ad1bc8d1b7a18497dda9600b12dc193c577beb391beae5cd2349184db40f187"}, + {file = "pyzmq-26.2.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:bea2acdd8ea4275e1278350ced63da0b166421928276c7c8e3f9729d7402a57b"}, + {file = "pyzmq-26.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:23f4aad749d13698f3f7b64aad34f5fc02d6f20f05999eebc96b89b01262fb18"}, + {file = "pyzmq-26.2.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:a4f96f0d88accc3dbe4a9025f785ba830f968e21e3e2c6321ccdfc9aef755115"}, + {file = "pyzmq-26.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ced65e5a985398827cc9276b93ef6dfabe0273c23de8c7931339d7e141c2818e"}, + {file = "pyzmq-26.2.0-cp313-cp313-win32.whl", hash = "sha256:31507f7b47cc1ead1f6e86927f8ebb196a0bab043f6345ce070f412a59bf87b5"}, + {file = "pyzmq-26.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:70fc7fcf0410d16ebdda9b26cbd8bf8d803d220a7f3522e060a69a9c87bf7bad"}, + {file = "pyzmq-26.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:c3789bd5768ab5618ebf09cef6ec2b35fed88709b104351748a63045f0ff9797"}, + {file = "pyzmq-26.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:034da5fc55d9f8da09015d368f519478a52675e558c989bfcb5cf6d4e16a7d2a"}, + {file = "pyzmq-26.2.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:c92d73464b886931308ccc45b2744e5968cbaade0b1d6aeb40d8ab537765f5bc"}, + {file = "pyzmq-26.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:794a4562dcb374f7dbbfb3f51d28fb40123b5a2abadee7b4091f93054909add5"}, + {file = "pyzmq-26.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aee22939bb6075e7afededabad1a56a905da0b3c4e3e0c45e75810ebe3a52672"}, + {file = "pyzmq-26.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ae90ff9dad33a1cfe947d2c40cb9cb5e600d759ac4f0fd22616ce6540f72797"}, + {file = "pyzmq-26.2.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:43a47408ac52647dfabbc66a25b05b6a61700b5165807e3fbd40063fcaf46386"}, + {file = "pyzmq-26.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:25bf2374a2a8433633c65ccb9553350d5e17e60c8eb4de4d92cc6bd60f01d306"}, + {file = "pyzmq-26.2.0-cp313-cp313t-musllinux_1_1_i686.whl", hash = "sha256:007137c9ac9ad5ea21e6ad97d3489af654381324d5d3ba614c323f60dab8fae6"}, + {file = "pyzmq-26.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:470d4a4f6d48fb34e92d768b4e8a5cc3780db0d69107abf1cd7ff734b9766eb0"}, + {file = "pyzmq-26.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3b55a4229ce5da9497dd0452b914556ae58e96a4381bb6f59f1305dfd7e53fc8"}, + {file = "pyzmq-26.2.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9cb3a6460cdea8fe8194a76de8895707e61ded10ad0be97188cc8463ffa7e3a8"}, + {file = "pyzmq-26.2.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8ab5cad923cc95c87bffee098a27856c859bd5d0af31bd346035aa816b081fe1"}, + {file = "pyzmq-26.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ed69074a610fad1c2fda66180e7b2edd4d31c53f2d1872bc2d1211563904cd9"}, + {file = "pyzmq-26.2.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:cccba051221b916a4f5e538997c45d7d136a5646442b1231b916d0164067ea27"}, + {file = "pyzmq-26.2.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:0eaa83fc4c1e271c24eaf8fb083cbccef8fde77ec8cd45f3c35a9a123e6da097"}, + {file = "pyzmq-26.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:9edda2df81daa129b25a39b86cb57dfdfe16f7ec15b42b19bfac503360d27a93"}, + {file = "pyzmq-26.2.0-cp37-cp37m-win32.whl", hash = "sha256:ea0eb6af8a17fa272f7b98d7bebfab7836a0d62738e16ba380f440fceca2d951"}, + {file = "pyzmq-26.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:4ff9dc6bc1664bb9eec25cd17506ef6672d506115095411e237d571e92a58231"}, + {file = "pyzmq-26.2.0-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:2eb7735ee73ca1b0d71e0e67c3739c689067f055c764f73aac4cc8ecf958ee3f"}, + {file = "pyzmq-26.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1a534f43bc738181aa7cbbaf48e3eca62c76453a40a746ab95d4b27b1111a7d2"}, + {file = "pyzmq-26.2.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:aedd5dd8692635813368e558a05266b995d3d020b23e49581ddd5bbe197a8ab6"}, + {file = "pyzmq-26.2.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8be4700cd8bb02cc454f630dcdf7cfa99de96788b80c51b60fe2fe1dac480289"}, + {file = "pyzmq-26.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fcc03fa4997c447dce58264e93b5aa2d57714fbe0f06c07b7785ae131512732"}, + {file = "pyzmq-26.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:402b190912935d3db15b03e8f7485812db350d271b284ded2b80d2e5704be780"}, + {file = "pyzmq-26.2.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8685fa9c25ff00f550c1fec650430c4b71e4e48e8d852f7ddcf2e48308038640"}, + {file = "pyzmq-26.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:76589c020680778f06b7e0b193f4b6dd66d470234a16e1df90329f5e14a171cd"}, + {file = "pyzmq-26.2.0-cp38-cp38-win32.whl", hash = "sha256:8423c1877d72c041f2c263b1ec6e34360448decfb323fa8b94e85883043ef988"}, + {file = "pyzmq-26.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:76589f2cd6b77b5bdea4fca5992dc1c23389d68b18ccc26a53680ba2dc80ff2f"}, + {file = "pyzmq-26.2.0-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:b1d464cb8d72bfc1a3adc53305a63a8e0cac6bc8c5a07e8ca190ab8d3faa43c2"}, + {file = "pyzmq-26.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4da04c48873a6abdd71811c5e163bd656ee1b957971db7f35140a2d573f6949c"}, + {file = "pyzmq-26.2.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:d049df610ac811dcffdc147153b414147428567fbbc8be43bb8885f04db39d98"}, + {file = "pyzmq-26.2.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:05590cdbc6b902101d0e65d6a4780af14dc22914cc6ab995d99b85af45362cc9"}, + {file = "pyzmq-26.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c811cfcd6a9bf680236c40c6f617187515269ab2912f3d7e8c0174898e2519db"}, + {file = "pyzmq-26.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:6835dd60355593de10350394242b5757fbbd88b25287314316f266e24c61d073"}, + {file = "pyzmq-26.2.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc6bee759a6bddea5db78d7dcd609397449cb2d2d6587f48f3ca613b19410cfc"}, + {file = "pyzmq-26.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c530e1eecd036ecc83c3407f77bb86feb79916d4a33d11394b8234f3bd35b940"}, + {file = "pyzmq-26.2.0-cp39-cp39-win32.whl", hash = "sha256:367b4f689786fca726ef7a6c5ba606958b145b9340a5e4808132cc65759abd44"}, + {file = "pyzmq-26.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:e6fa2e3e683f34aea77de8112f6483803c96a44fd726d7358b9888ae5bb394ec"}, + {file = "pyzmq-26.2.0-cp39-cp39-win_arm64.whl", hash = "sha256:7445be39143a8aa4faec43b076e06944b8f9d0701b669df4af200531b21e40bb"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:706e794564bec25819d21a41c31d4df2d48e1cc4b061e8d345d7fb4dd3e94072"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b435f2753621cd36e7c1762156815e21c985c72b19135dac43a7f4f31d28dd1"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:160c7e0a5eb178011e72892f99f918c04a131f36056d10d9c1afb223fc952c2d"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c4a71d5d6e7b28a47a394c0471b7e77a0661e2d651e7ae91e0cab0a587859ca"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:90412f2db8c02a3864cbfc67db0e3dcdbda336acf1c469526d3e869394fe001c"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2ea4ad4e6a12e454de05f2949d4beddb52460f3de7c8b9d5c46fbb7d7222e02c"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:fc4f7a173a5609631bb0c42c23d12c49df3966f89f496a51d3eb0ec81f4519d6"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:878206a45202247781472a2d99df12a176fef806ca175799e1c6ad263510d57c"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:17c412bad2eb9468e876f556eb4ee910e62d721d2c7a53c7fa31e643d35352e6"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:0d987a3ae5a71c6226b203cfd298720e0086c7fe7c74f35fa8edddfbd6597eed"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:39887ac397ff35b7b775db7201095fc6310a35fdbae85bac4523f7eb3b840e20"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:fdb5b3e311d4d4b0eb8b3e8b4d1b0a512713ad7e6a68791d0923d1aec433d919"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:226af7dcb51fdb0109f0016449b357e182ea0ceb6b47dfb5999d569e5db161d5"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bed0e799e6120b9c32756203fb9dfe8ca2fb8467fed830c34c877e25638c3fc"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:29c7947c594e105cb9e6c466bace8532dc1ca02d498684128b339799f5248277"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cdeabcff45d1c219636ee2e54d852262e5c2e085d6cb476d938aee8d921356b3"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35cffef589bcdc587d06f9149f8d5e9e8859920a071df5a2671de2213bef592a"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:18c8dc3b7468d8b4bdf60ce9d7141897da103c7a4690157b32b60acb45e333e6"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7133d0a1677aec369d67dd78520d3fa96dd7f3dcec99d66c1762870e5ea1a50a"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:6a96179a24b14fa6428cbfc08641c779a53f8fcec43644030328f44034c7f1f4"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:4f78c88905461a9203eac9faac157a2a0dbba84a0fd09fd29315db27be40af9f"}, + {file = "pyzmq-26.2.0.tar.gz", hash = "sha256:070672c258581c8e4f640b5159297580a9974b026043bd4ab0470be9ed324f1f"}, ] [package.dependencies] @@ -4253,43 +4526,44 @@ test = ["coverage[toml] (>=6.2)", "mypy (>=0.940)", "pytest (>=6.2.2)", "pytest- [[package]] name = "qibo" -version = "0.2.7" +version = "0.2.12" description = "A framework for quantum computing with hardware acceleration." optional = false -python-versions = "<3.12,>=3.9" +python-versions = "<3.13,>=3.9" files = [ - {file = "qibo-0.2.7-py3-none-any.whl", hash = "sha256:20e42ad27f7a9795f84565ab5645e3b24d4af62a0a8c6de5110b5ae6894b35a2"}, - {file = "qibo-0.2.7.tar.gz", hash = "sha256:a57e98a3eccfc3c43c4a697448a4618c9a158f72645d5c93b0b2bdd3ace882ef"}, + {file = "qibo-0.2.12-py3-none-any.whl", hash = "sha256:2e301747b31946d0737bfa621bf5b30b00c861926468ce36973cf61b2803f58a"}, + {file = "qibo-0.2.12.tar.gz", hash = "sha256:6849801eee77f928077a3e11b52cf549c34a9e9678a6d366d495686a6b21e788"}, ] [package.dependencies] cma = ">=3.3.0,<4.0.0" -hyperopt = ">=0.2.7,<0.3.0" joblib = ">=1.2.0,<2.0.0" networkx = ">=3.2.1,<4.0.0" numpy = ">=1.26.4,<2.0.0" openqasm3 = {version = ">=0.5.0", extras = ["parser"]} +optuna = ">=4.0.0,<5.0.0" scipy = ">=1.10.1,<2.0.0" sympy = ">=1.11.1,<2.0.0" tabulate = ">=0.9.0,<0.10.0" [package.extras] -qinfo = ["cvxpy (>=1.4.2,<2.0.0)"] -tensorflow = ["tensorflow (>=2.14.1,<2.16)"] -torch = ["torch (>=2.1.1,<3.0.0)"] +qulacs = ["qulacs (>=0.6.4,<0.7.0)"] +tensorflow = ["tensorflow (>=2.16.1,<3.0.0)"] +torch = ["torch (>=2.1.1,<2.4)"] [[package]] name = "qibosoq" -version = "0.1.2" +version = "0.1.3" description = "QIBO Server On Qick (qibosoq) is the server component of qibolab to be run on RFSoC boards" optional = false -python-versions = "<3.12,>=3.8" +python-versions = "<3.13,>=3.9" files = [ - {file = "qibosoq-0.1.2-py3-none-any.whl", hash = "sha256:c6eaebba2bdcc1c05359d9cbcdf35bf2a4f15fe8c67730ea5911ff4c04f3e2f3"}, - {file = "qibosoq-0.1.2.tar.gz", hash = "sha256:ccb4eb7d8f7557ea8ea72ffc88f00669e64dc02c871c856b5fb33c97c3c18863"}, + {file = "qibosoq-0.1.3-py3-none-any.whl", hash = "sha256:8b909a3a6ed9807b679b11e7c97a70f88dae74b8d72ebfd9225f51c89bd1817f"}, + {file = "qibosoq-0.1.3.tar.gz", hash = "sha256:8f5c2a2327156519d0fd9d26fc75b563506b1cb860a207fb8eea1749bb30ef3f"}, ] [package.dependencies] +numpy = ">=1.26,<2.0" qick = ">=0.2.211,<=0.2.249" [[package]] @@ -4410,46 +4684,38 @@ interplot = ["dill (>=0.3.4,<0.4.0)", "ipython (>=7.31.1,<8.0.0)", "pypiwin32 (> [[package]] name = "qutip" -version = "4.7.5" +version = "5.0.4" description = "QuTiP: The Quantum Toolbox in Python" optional = false -python-versions = "*" +python-versions = ">=3.9" files = [ - {file = "qutip-4.7.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b4ae6b823674328703f96ca1fec75260c773d3eea981f91eecaa71235c965ba3"}, - {file = "qutip-4.7.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7141cf931b6f92397cd6738d082c46e082b26c066deb494a4b6b8f1f841b0aa8"}, - {file = "qutip-4.7.5-cp310-cp310-win_amd64.whl", hash = "sha256:a0e513344872dfbd5728a5a1688671909fa4ebeb1d42f09bc896518ed880f82c"}, - {file = "qutip-4.7.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7a257fc52facddb25149c2fc03400fd219b893a9238fde46548d9e1430c16b2d"}, - {file = "qutip-4.7.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95587c1bd98084c6ca29c4d745048da39ed2431854dd1f12914c21aa47076e9c"}, - {file = "qutip-4.7.5-cp311-cp311-win_amd64.whl", hash = "sha256:8c4b7b9ad94b9edad32d290d0823af4e87daf123c5398925afd8f99f8c6a8fcb"}, - {file = "qutip-4.7.5-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:cd223ff0f31cef3b08de9d898d959c65a4cd3ef05eec3cf91ee25431285d284d"}, - {file = "qutip-4.7.5-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:4f08e5ffcffdae89e906fd579aa155e3b794d0eb7345ae4cfadb4b24a46a08d7"}, - {file = "qutip-4.7.5-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d0090d2543fcab58f966387b0553987971c75cc8b7fb269c354e68b023d87f18"}, - {file = "qutip-4.7.5-cp36-cp36m-win32.whl", hash = "sha256:193b96cd41a522f842bd9807c763e305d0e810fd6bedd5f486e8a5284d80ea26"}, - {file = "qutip-4.7.5-cp36-cp36m-win_amd64.whl", hash = "sha256:240c01a931fe22417fbc18864cb91b91c44fdf6e5b922386e3891752e2cf9740"}, - {file = "qutip-4.7.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:11b6b750e6d68d6b35a9f64576d00742fb0f7ea97f5e624bd01fe9fec0eb0c53"}, - {file = "qutip-4.7.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:349dff8b40a0fc97ff2722c76e73f6141f9a5ffd44c0bf16d830b780a41d0dca"}, - {file = "qutip-4.7.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:736a1b0f13bcf51fe9152478409d78a7608d9a7bb924238483df8a0df55c88fd"}, - {file = "qutip-4.7.5-cp37-cp37m-win32.whl", hash = "sha256:695183bee518aee1c0915e7a0974a4305d128f06afc59b6e18a2127ef353138b"}, - {file = "qutip-4.7.5-cp37-cp37m-win_amd64.whl", hash = "sha256:700b4d1df10ed7cac8acd0b15da4bfb4506073d7bcdb46f9cc896da5b13ed0f5"}, - {file = "qutip-4.7.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:be905e4b3a0afbf53d3144b642391b0de8274123ea7febbee19e1ec1339c2c70"}, - {file = "qutip-4.7.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4595d59c5cd22c88022897d3bdbdab191a9eb032ee2ae8fd88937b82d736435c"}, - {file = "qutip-4.7.5-cp38-cp38-win_amd64.whl", hash = "sha256:79b2667a7ded59d05722c78bfd71054e63a7c0ceb8a4ec7426ece69cd125668c"}, - {file = "qutip-4.7.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b9c16d9f5f7e61d8c0b904b498fa44d30ded6685d7fe28c3c19c57b9c0fc8fc9"}, - {file = "qutip-4.7.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acb9f827ea757faa193bf19e42269ed52da06efc38f966923ee6b793b28526f5"}, - {file = "qutip-4.7.5-cp39-cp39-win_amd64.whl", hash = "sha256:36502a7883b8c87d42381aa7b8fb0b3450b3bed26924dfdad9e7829d33a2ced3"}, - {file = "qutip-4.7.5.tar.gz", hash = "sha256:a0cc9883281ec89e38ac635adc4bb602d85ec49071628ee17d3bf2c14b5c11ac"}, -] - -[package.dependencies] -numpy = ">=1.16.6" + {file = "qutip-5.0.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e855d70e5b97e15e30372dec89ec0c6bb12842a1262472894e4bb444e1e31541"}, + {file = "qutip-5.0.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10a50997d68df3702781ebd6e79def2c54431daecf550e742dba95679ce3d578"}, + {file = "qutip-5.0.4-cp310-cp310-win_amd64.whl", hash = "sha256:85adc3c8ab91db1c22068599db9d39ea5d849f0ac646a176da221229560d25be"}, + {file = "qutip-5.0.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:288d2dcadc79b5a6918bef41adffb75d4a62039c095b02fc9901b2a7cd51787e"}, + {file = "qutip-5.0.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39da3510f0b508e698a1526b93826be6154f03add1cc090840d3d7b6a23f6298"}, + {file = "qutip-5.0.4-cp311-cp311-win_amd64.whl", hash = "sha256:6096c018a909177d0220db2e89608c1929fe2d6cb14b04cce68aadcc53b142a1"}, + {file = "qutip-5.0.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ca0a7b5bd16404c16156600afe24f656b5230a7236f2e3fde933fed6e4823df9"}, + {file = "qutip-5.0.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:683fa10b9273ff0357323c9f0993e5620bf6bd020e80f2ec34f1c4c8bc3cbc0e"}, + {file = "qutip-5.0.4-cp312-cp312-win_amd64.whl", hash = "sha256:6a5c85b0df421ab5ed1dde345491256ceb9bdc77e0f6853541e1fa0a45536730"}, + {file = "qutip-5.0.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d5f617912ad9262a4bd4ea04096c24868507ede4e20cffe80b704f4a77101f82"}, + {file = "qutip-5.0.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d322e8637747f8f618ee2239e0ffed37f687cca1e282294ab6e46b5a3f54f5ca"}, + {file = "qutip-5.0.4-cp39-cp39-win_amd64.whl", hash = "sha256:7f556165bf1cc73fe2b1ae062ef09ee11d80718426e197d359908c073b882fc6"}, + {file = "qutip-5.0.4.tar.gz", hash = "sha256:e5ee097cf0ef72e12baf21b32b293f2a7838bd439098286762ef786343549f1c"}, +] + +[package.dependencies] +numpy = ">=1.22" packaging = "*" -scipy = ">=1.0" +scipy = ">=1.9" [package.extras] -full = ["cvxopt", "cvxpy (>=1.0)", "cython (>=0.29.20,<3.0.0)", "ipython", "matplotlib (>=1.2.1)", "pytest (>=5.2)", "pytest-rerunfailures"] -graphics = ["matplotlib (>=1.2.1)"] +extras = ["loky", "tqdm"] +full = ["cvxopt", "cvxpy (>=1.0)", "cython (>=0.29.20)", "filelock", "ipython", "loky", "matplotlib (>=3.5)", "pytest (>=5.2)", "pytest-rerunfailures", "setuptools", "tqdm"] +graphics = ["matplotlib (>=3.5)"] ipython = ["ipython"] -runtime-compilation = ["cython (>=0.29.20,<3.0.0)"] +mpi = ["mpi4py"] +runtime-compilation = ["cython (>=0.29.20)", "filelock", "setuptools"] semidefinite = ["cvxopt", "cvxpy (>=1.0)"] tests = ["pytest (>=5.2)", "pytest-rerunfailures"] @@ -4486,13 +4752,13 @@ rpds-py = ">=0.7.0" [[package]] name = "requests" -version = "2.31.0" +version = "2.32.3" description = "Python HTTP for Humans." optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, - {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, ] [package.dependencies] @@ -4538,13 +4804,13 @@ idna2008 = ["idna"] [[package]] name = "rich" -version = "13.7.1" +version = "13.8.1" description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" optional = false python-versions = ">=3.7.0" files = [ - {file = "rich-13.7.1-py3-none-any.whl", hash = "sha256:4edbae314f59eb482f54e9e30bf00d33350aaa94f4bfcd4e9e3110e64d0d7222"}, - {file = "rich-13.7.1.tar.gz", hash = "sha256:9be308cb1fe2f1f57d67ce99e95af38a1e2bc71ad9813b0e247cf7ffbcc3a432"}, + {file = "rich-13.8.1-py3-none-any.whl", hash = "sha256:1760a3c0848469b97b558fc61c85233e3dafb69c7a071b4d60c38099d3cd4c06"}, + {file = "rich-13.8.1.tar.gz", hash = "sha256:8260cda28e3db6bf04d2d1ef4dbc03ba80a824c88b0e7668a0f23126a424844a"}, ] [package.dependencies] @@ -4556,110 +4822,114 @@ jupyter = ["ipywidgets (>=7.5.1,<9)"] [[package]] name = "rpds-py" -version = "0.18.1" +version = "0.20.0" description = "Python bindings to Rust's persistent data structures (rpds)" optional = false python-versions = ">=3.8" files = [ - {file = "rpds_py-0.18.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:d31dea506d718693b6b2cffc0648a8929bdc51c70a311b2770f09611caa10d53"}, - {file = "rpds_py-0.18.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:732672fbc449bab754e0b15356c077cc31566df874964d4801ab14f71951ea80"}, - {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a98a1f0552b5f227a3d6422dbd61bc6f30db170939bd87ed14f3c339aa6c7c9"}, - {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f1944ce16401aad1e3f7d312247b3d5de7981f634dc9dfe90da72b87d37887d"}, - {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:38e14fb4e370885c4ecd734f093a2225ee52dc384b86fa55fe3f74638b2cfb09"}, - {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08d74b184f9ab6289b87b19fe6a6d1a97fbfea84b8a3e745e87a5de3029bf944"}, - {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d70129cef4a8d979caa37e7fe957202e7eee8ea02c5e16455bc9808a59c6b2f0"}, - {file = "rpds_py-0.18.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce0bb20e3a11bd04461324a6a798af34d503f8d6f1aa3d2aa8901ceaf039176d"}, - {file = "rpds_py-0.18.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:81c5196a790032e0fc2464c0b4ab95f8610f96f1f2fa3d4deacce6a79852da60"}, - {file = "rpds_py-0.18.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:f3027be483868c99b4985fda802a57a67fdf30c5d9a50338d9db646d590198da"}, - {file = "rpds_py-0.18.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d44607f98caa2961bab4fa3c4309724b185b464cdc3ba6f3d7340bac3ec97cc1"}, - {file = "rpds_py-0.18.1-cp310-none-win32.whl", hash = "sha256:c273e795e7a0f1fddd46e1e3cb8be15634c29ae8ff31c196debb620e1edb9333"}, - {file = "rpds_py-0.18.1-cp310-none-win_amd64.whl", hash = "sha256:8352f48d511de5f973e4f2f9412736d7dea76c69faa6d36bcf885b50c758ab9a"}, - {file = "rpds_py-0.18.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6b5ff7e1d63a8281654b5e2896d7f08799378e594f09cf3674e832ecaf396ce8"}, - {file = "rpds_py-0.18.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8927638a4d4137a289e41d0fd631551e89fa346d6dbcfc31ad627557d03ceb6d"}, - {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:154bf5c93d79558b44e5b50cc354aa0459e518e83677791e6adb0b039b7aa6a7"}, - {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07f2139741e5deb2c5154a7b9629bc5aa48c766b643c1a6750d16f865a82c5fc"}, - {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8c7672e9fba7425f79019db9945b16e308ed8bc89348c23d955c8c0540da0a07"}, - {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:489bdfe1abd0406eba6b3bb4fdc87c7fa40f1031de073d0cfb744634cc8fa261"}, - {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c20f05e8e3d4fc76875fc9cb8cf24b90a63f5a1b4c5b9273f0e8225e169b100"}, - {file = "rpds_py-0.18.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:967342e045564cef76dfcf1edb700b1e20838d83b1aa02ab313e6a497cf923b8"}, - {file = "rpds_py-0.18.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2cc7c1a47f3a63282ab0f422d90ddac4aa3034e39fc66a559ab93041e6505da7"}, - {file = "rpds_py-0.18.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f7afbfee1157e0f9376c00bb232e80a60e59ed716e3211a80cb8506550671e6e"}, - {file = "rpds_py-0.18.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9e6934d70dc50f9f8ea47081ceafdec09245fd9f6032669c3b45705dea096b88"}, - {file = "rpds_py-0.18.1-cp311-none-win32.whl", hash = "sha256:c69882964516dc143083d3795cb508e806b09fc3800fd0d4cddc1df6c36e76bb"}, - {file = "rpds_py-0.18.1-cp311-none-win_amd64.whl", hash = "sha256:70a838f7754483bcdc830444952fd89645569e7452e3226de4a613a4c1793fb2"}, - {file = "rpds_py-0.18.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3dd3cd86e1db5aadd334e011eba4e29d37a104b403e8ca24dcd6703c68ca55b3"}, - {file = "rpds_py-0.18.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:05f3d615099bd9b13ecf2fc9cf2d839ad3f20239c678f461c753e93755d629ee"}, - {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35b2b771b13eee8729a5049c976197ff58a27a3829c018a04341bcf1ae409b2b"}, - {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ee17cd26b97d537af8f33635ef38be873073d516fd425e80559f4585a7b90c43"}, - {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b646bf655b135ccf4522ed43d6902af37d3f5dbcf0da66c769a2b3938b9d8184"}, - {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:19ba472b9606c36716062c023afa2484d1e4220548751bda14f725a7de17b4f6"}, - {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e30ac5e329098903262dc5bdd7e2086e0256aa762cc8b744f9e7bf2a427d3f8"}, - {file = "rpds_py-0.18.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d58ad6317d188c43750cb76e9deacf6051d0f884d87dc6518e0280438648a9ac"}, - {file = "rpds_py-0.18.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e1735502458621921cee039c47318cb90b51d532c2766593be6207eec53e5c4c"}, - {file = "rpds_py-0.18.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f5bab211605d91db0e2995a17b5c6ee5edec1270e46223e513eaa20da20076ac"}, - {file = "rpds_py-0.18.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2fc24a329a717f9e2448f8cd1f960f9dac4e45b6224d60734edeb67499bab03a"}, - {file = "rpds_py-0.18.1-cp312-none-win32.whl", hash = "sha256:1805d5901779662d599d0e2e4159d8a82c0b05faa86ef9222bf974572286b2b6"}, - {file = "rpds_py-0.18.1-cp312-none-win_amd64.whl", hash = "sha256:720edcb916df872d80f80a1cc5ea9058300b97721efda8651efcd938a9c70a72"}, - {file = "rpds_py-0.18.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:c827576e2fa017a081346dce87d532a5310241648eb3700af9a571a6e9fc7e74"}, - {file = "rpds_py-0.18.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:aa3679e751408d75a0b4d8d26d6647b6d9326f5e35c00a7ccd82b78ef64f65f8"}, - {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0abeee75434e2ee2d142d650d1e54ac1f8b01e6e6abdde8ffd6eeac6e9c38e20"}, - {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed402d6153c5d519a0faf1bb69898e97fb31613b49da27a84a13935ea9164dfc"}, - {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:338dee44b0cef8b70fd2ef54b4e09bb1b97fc6c3a58fea5db6cc083fd9fc2724"}, - {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7750569d9526199c5b97e5a9f8d96a13300950d910cf04a861d96f4273d5b104"}, - {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:607345bd5912aacc0c5a63d45a1f73fef29e697884f7e861094e443187c02be5"}, - {file = "rpds_py-0.18.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:207c82978115baa1fd8d706d720b4a4d2b0913df1c78c85ba73fe6c5804505f0"}, - {file = "rpds_py-0.18.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:6d1e42d2735d437e7e80bab4d78eb2e459af48c0a46e686ea35f690b93db792d"}, - {file = "rpds_py-0.18.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:5463c47c08630007dc0fe99fb480ea4f34a89712410592380425a9b4e1611d8e"}, - {file = "rpds_py-0.18.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:06d218939e1bf2ca50e6b0ec700ffe755e5216a8230ab3e87c059ebb4ea06afc"}, - {file = "rpds_py-0.18.1-cp38-none-win32.whl", hash = "sha256:312fe69b4fe1ffbe76520a7676b1e5ac06ddf7826d764cc10265c3b53f96dbe9"}, - {file = "rpds_py-0.18.1-cp38-none-win_amd64.whl", hash = "sha256:9437ca26784120a279f3137ee080b0e717012c42921eb07861b412340f85bae2"}, - {file = "rpds_py-0.18.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:19e515b78c3fc1039dd7da0a33c28c3154458f947f4dc198d3c72db2b6b5dc93"}, - {file = "rpds_py-0.18.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a7b28c5b066bca9a4eb4e2f2663012debe680f097979d880657f00e1c30875a0"}, - {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:673fdbbf668dd958eff750e500495ef3f611e2ecc209464f661bc82e9838991e"}, - {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d960de62227635d2e61068f42a6cb6aae91a7fe00fca0e3aeed17667c8a34611"}, - {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:352a88dc7892f1da66b6027af06a2e7e5d53fe05924cc2cfc56495b586a10b72"}, - {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e0ee01ad8260184db21468a6e1c37afa0529acc12c3a697ee498d3c2c4dcaf3"}, - {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4c39ad2f512b4041343ea3c7894339e4ca7839ac38ca83d68a832fc8b3748ab"}, - {file = "rpds_py-0.18.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:aaa71ee43a703c321906813bb252f69524f02aa05bf4eec85f0c41d5d62d0f4c"}, - {file = "rpds_py-0.18.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:6cd8098517c64a85e790657e7b1e509b9fe07487fd358e19431cb120f7d96338"}, - {file = "rpds_py-0.18.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:4adec039b8e2928983f885c53b7cc4cda8965b62b6596501a0308d2703f8af1b"}, - {file = "rpds_py-0.18.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:32b7daaa3e9389db3695964ce8e566e3413b0c43e3394c05e4b243a4cd7bef26"}, - {file = "rpds_py-0.18.1-cp39-none-win32.whl", hash = "sha256:2625f03b105328729f9450c8badda34d5243231eef6535f80064d57035738360"}, - {file = "rpds_py-0.18.1-cp39-none-win_amd64.whl", hash = "sha256:bf18932d0003c8c4d51a39f244231986ab23ee057d235a12b2684ea26a353590"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:cbfbea39ba64f5e53ae2915de36f130588bba71245b418060ec3330ebf85678e"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:a3d456ff2a6a4d2adcdf3c1c960a36f4fd2fec6e3b4902a42a384d17cf4e7a65"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7700936ef9d006b7ef605dc53aa364da2de5a3aa65516a1f3ce73bf82ecfc7ae"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:51584acc5916212e1bf45edd17f3a6b05fe0cbb40482d25e619f824dccb679de"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:942695a206a58d2575033ff1e42b12b2aece98d6003c6bc739fbf33d1773b12f"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b906b5f58892813e5ba5c6056d6a5ad08f358ba49f046d910ad992196ea61397"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6f8e3fecca256fefc91bb6765a693d96692459d7d4c644660a9fff32e517843"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7732770412bab81c5a9f6d20aeb60ae943a9b36dcd990d876a773526468e7163"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:bd1105b50ede37461c1d51b9698c4f4be6e13e69a908ab7751e3807985fc0346"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:618916f5535784960f3ecf8111581f4ad31d347c3de66d02e728de460a46303c"}, - {file = "rpds_py-0.18.1-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:17c6d2155e2423f7e79e3bb18151c686d40db42d8645e7977442170c360194d4"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6c4c4c3f878df21faf5fac86eda32671c27889e13570645a9eea0a1abdd50922"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:fab6ce90574645a0d6c58890e9bcaac8d94dff54fb51c69e5522a7358b80ab64"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:531796fb842b53f2695e94dc338929e9f9dbf473b64710c28af5a160b2a8927d"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:740884bc62a5e2bbb31e584f5d23b32320fd75d79f916f15a788d527a5e83644"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:998125738de0158f088aef3cb264a34251908dd2e5d9966774fdab7402edfab7"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e2be6e9dd4111d5b31ba3b74d17da54a8319d8168890fbaea4b9e5c3de630ae5"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0cee71bc618cd93716f3c1bf56653740d2d13ddbd47673efa8bf41435a60daa"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2c3caec4ec5cd1d18e5dd6ae5194d24ed12785212a90b37f5f7f06b8bedd7139"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:27bba383e8c5231cd559affe169ca0b96ec78d39909ffd817f28b166d7ddd4d8"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:a888e8bdb45916234b99da2d859566f1e8a1d2275a801bb8e4a9644e3c7e7909"}, - {file = "rpds_py-0.18.1-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:6031b25fb1b06327b43d841f33842b383beba399884f8228a6bb3df3088485ff"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:48c2faaa8adfacefcbfdb5f2e2e7bdad081e5ace8d182e5f4ade971f128e6bb3"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:d85164315bd68c0806768dc6bb0429c6f95c354f87485ee3593c4f6b14def2bd"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6afd80f6c79893cfc0574956f78a0add8c76e3696f2d6a15bca2c66c415cf2d4"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa242ac1ff583e4ec7771141606aafc92b361cd90a05c30d93e343a0c2d82a89"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d21be4770ff4e08698e1e8e0bce06edb6ea0626e7c8f560bc08222880aca6a6f"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c45a639e93a0c5d4b788b2613bd637468edd62f8f95ebc6fcc303d58ab3f0a8"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:910e71711d1055b2768181efa0a17537b2622afeb0424116619817007f8a2b10"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b9bb1f182a97880f6078283b3505a707057c42bf55d8fca604f70dedfdc0772a"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:1d54f74f40b1f7aaa595a02ff42ef38ca654b1469bef7d52867da474243cc633"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:8d2e182c9ee01135e11e9676e9a62dfad791a7a467738f06726872374a83db49"}, - {file = "rpds_py-0.18.1-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:636a15acc588f70fda1661234761f9ed9ad79ebed3f2125d44be0862708b666e"}, - {file = "rpds_py-0.18.1.tar.gz", hash = "sha256:dc48b479d540770c811fbd1eb9ba2bb66951863e448efec2e2c102625328e92f"}, + {file = "rpds_py-0.20.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:3ad0fda1635f8439cde85c700f964b23ed5fc2d28016b32b9ee5fe30da5c84e2"}, + {file = "rpds_py-0.20.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9bb4a0d90fdb03437c109a17eade42dfbf6190408f29b2744114d11586611d6f"}, + {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c6377e647bbfd0a0b159fe557f2c6c602c159fc752fa316572f012fc0bf67150"}, + {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb851b7df9dda52dc1415ebee12362047ce771fc36914586b2e9fcbd7d293b3e"}, + {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1e0f80b739e5a8f54837be5d5c924483996b603d5502bfff79bf33da06164ee2"}, + {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a8c94dad2e45324fc74dce25e1645d4d14df9a4e54a30fa0ae8bad9a63928e3"}, + {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8e604fe73ba048c06085beaf51147eaec7df856824bfe7b98657cf436623daf"}, + {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:df3de6b7726b52966edf29663e57306b23ef775faf0ac01a3e9f4012a24a4140"}, + {file = "rpds_py-0.20.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf258ede5bc22a45c8e726b29835b9303c285ab46fc7c3a4cc770736b5304c9f"}, + {file = "rpds_py-0.20.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:55fea87029cded5df854ca7e192ec7bdb7ecd1d9a3f63d5c4eb09148acf4a7ce"}, + {file = "rpds_py-0.20.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ae94bd0b2f02c28e199e9bc51485d0c5601f58780636185660f86bf80c89af94"}, + {file = "rpds_py-0.20.0-cp310-none-win32.whl", hash = "sha256:28527c685f237c05445efec62426d285e47a58fb05ba0090a4340b73ecda6dee"}, + {file = "rpds_py-0.20.0-cp310-none-win_amd64.whl", hash = "sha256:238a2d5b1cad28cdc6ed15faf93a998336eb041c4e440dd7f902528b8891b399"}, + {file = "rpds_py-0.20.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:ac2f4f7a98934c2ed6505aead07b979e6f999389f16b714448fb39bbaa86a489"}, + {file = "rpds_py-0.20.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:220002c1b846db9afd83371d08d239fdc865e8f8c5795bbaec20916a76db3318"}, + {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8d7919548df3f25374a1f5d01fbcd38dacab338ef5f33e044744b5c36729c8db"}, + {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:758406267907b3781beee0f0edfe4a179fbd97c0be2e9b1154d7f0a1279cf8e5"}, + {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3d61339e9f84a3f0767b1995adfb171a0d00a1185192718a17af6e124728e0f5"}, + {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1259c7b3705ac0a0bd38197565a5d603218591d3f6cee6e614e380b6ba61c6f6"}, + {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c1dc0f53856b9cc9a0ccca0a7cc61d3d20a7088201c0937f3f4048c1718a209"}, + {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7e60cb630f674a31f0368ed32b2a6b4331b8350d67de53c0359992444b116dd3"}, + {file = "rpds_py-0.20.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dbe982f38565bb50cb7fb061ebf762c2f254ca3d8c20d4006878766e84266272"}, + {file = "rpds_py-0.20.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:514b3293b64187172bc77c8fb0cdae26981618021053b30d8371c3a902d4d5ad"}, + {file = "rpds_py-0.20.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d0a26ffe9d4dd35e4dfdd1e71f46401cff0181c75ac174711ccff0459135fa58"}, + {file = "rpds_py-0.20.0-cp311-none-win32.whl", hash = "sha256:89c19a494bf3ad08c1da49445cc5d13d8fefc265f48ee7e7556839acdacf69d0"}, + {file = "rpds_py-0.20.0-cp311-none-win_amd64.whl", hash = "sha256:c638144ce971df84650d3ed0096e2ae7af8e62ecbbb7b201c8935c370df00a2c"}, + {file = "rpds_py-0.20.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a84ab91cbe7aab97f7446652d0ed37d35b68a465aeef8fc41932a9d7eee2c1a6"}, + {file = "rpds_py-0.20.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:56e27147a5a4c2c21633ff8475d185734c0e4befd1c989b5b95a5d0db699b21b"}, + {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2580b0c34583b85efec8c5c5ec9edf2dfe817330cc882ee972ae650e7b5ef739"}, + {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b80d4a7900cf6b66bb9cee5c352b2d708e29e5a37fe9bf784fa97fc11504bf6c"}, + {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50eccbf054e62a7b2209b28dc7a22d6254860209d6753e6b78cfaeb0075d7bee"}, + {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:49a8063ea4296b3a7e81a5dfb8f7b2d73f0b1c20c2af401fb0cdf22e14711a96"}, + {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea438162a9fcbee3ecf36c23e6c68237479f89f962f82dae83dc15feeceb37e4"}, + {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:18d7585c463087bddcfa74c2ba267339f14f2515158ac4db30b1f9cbdb62c8ef"}, + {file = "rpds_py-0.20.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d4c7d1a051eeb39f5c9547e82ea27cbcc28338482242e3e0b7768033cb083821"}, + {file = "rpds_py-0.20.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e4df1e3b3bec320790f699890d41c59d250f6beda159ea3c44c3f5bac1976940"}, + {file = "rpds_py-0.20.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2cf126d33a91ee6eedc7f3197b53e87a2acdac63602c0f03a02dd69e4b138174"}, + {file = "rpds_py-0.20.0-cp312-none-win32.whl", hash = "sha256:8bc7690f7caee50b04a79bf017a8d020c1f48c2a1077ffe172abec59870f1139"}, + {file = "rpds_py-0.20.0-cp312-none-win_amd64.whl", hash = "sha256:0e13e6952ef264c40587d510ad676a988df19adea20444c2b295e536457bc585"}, + {file = "rpds_py-0.20.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:aa9a0521aeca7d4941499a73ad7d4f8ffa3d1affc50b9ea11d992cd7eff18a29"}, + {file = "rpds_py-0.20.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4a1f1d51eccb7e6c32ae89243cb352389228ea62f89cd80823ea7dd1b98e0b91"}, + {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8a86a9b96070674fc88b6f9f71a97d2c1d3e5165574615d1f9168ecba4cecb24"}, + {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6c8ef2ebf76df43f5750b46851ed1cdf8f109d7787ca40035fe19fbdc1acc5a7"}, + {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b74b25f024b421d5859d156750ea9a65651793d51b76a2e9238c05c9d5f203a9"}, + {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:57eb94a8c16ab08fef6404301c38318e2c5a32216bf5de453e2714c964c125c8"}, + {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1940dae14e715e2e02dfd5b0f64a52e8374a517a1e531ad9412319dc3ac7879"}, + {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d20277fd62e1b992a50c43f13fbe13277a31f8c9f70d59759c88f644d66c619f"}, + {file = "rpds_py-0.20.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:06db23d43f26478303e954c34c75182356ca9aa7797d22c5345b16871ab9c45c"}, + {file = "rpds_py-0.20.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b2a5db5397d82fa847e4c624b0c98fe59d2d9b7cf0ce6de09e4d2e80f8f5b3f2"}, + {file = "rpds_py-0.20.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5a35df9f5548fd79cb2f52d27182108c3e6641a4feb0f39067911bf2adaa3e57"}, + {file = "rpds_py-0.20.0-cp313-none-win32.whl", hash = "sha256:fd2d84f40633bc475ef2d5490b9c19543fbf18596dcb1b291e3a12ea5d722f7a"}, + {file = "rpds_py-0.20.0-cp313-none-win_amd64.whl", hash = "sha256:9bc2d153989e3216b0559251b0c260cfd168ec78b1fac33dd485750a228db5a2"}, + {file = "rpds_py-0.20.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:f2fbf7db2012d4876fb0d66b5b9ba6591197b0f165db8d99371d976546472a24"}, + {file = "rpds_py-0.20.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1e5f3cd7397c8f86c8cc72d5a791071431c108edd79872cdd96e00abd8497d29"}, + {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce9845054c13696f7af7f2b353e6b4f676dab1b4b215d7fe5e05c6f8bb06f965"}, + {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c3e130fd0ec56cb76eb49ef52faead8ff09d13f4527e9b0c400307ff72b408e1"}, + {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4b16aa0107ecb512b568244ef461f27697164d9a68d8b35090e9b0c1c8b27752"}, + {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aa7f429242aae2947246587d2964fad750b79e8c233a2367f71b554e9447949c"}, + {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af0fc424a5842a11e28956e69395fbbeab2c97c42253169d87e90aac2886d751"}, + {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b8c00a3b1e70c1d3891f0db1b05292747f0dbcfb49c43f9244d04c70fbc40eb8"}, + {file = "rpds_py-0.20.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:40ce74fc86ee4645d0a225498d091d8bc61f39b709ebef8204cb8b5a464d3c0e"}, + {file = "rpds_py-0.20.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:4fe84294c7019456e56d93e8ababdad5a329cd25975be749c3f5f558abb48253"}, + {file = "rpds_py-0.20.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:338ca4539aad4ce70a656e5187a3a31c5204f261aef9f6ab50e50bcdffaf050a"}, + {file = "rpds_py-0.20.0-cp38-none-win32.whl", hash = "sha256:54b43a2b07db18314669092bb2de584524d1ef414588780261e31e85846c26a5"}, + {file = "rpds_py-0.20.0-cp38-none-win_amd64.whl", hash = "sha256:a1862d2d7ce1674cffa6d186d53ca95c6e17ed2b06b3f4c476173565c862d232"}, + {file = "rpds_py-0.20.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:3fde368e9140312b6e8b6c09fb9f8c8c2f00999d1823403ae90cc00480221b22"}, + {file = "rpds_py-0.20.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9824fb430c9cf9af743cf7aaf6707bf14323fb51ee74425c380f4c846ea70789"}, + {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:11ef6ce74616342888b69878d45e9f779b95d4bd48b382a229fe624a409b72c5"}, + {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c52d3f2f82b763a24ef52f5d24358553e8403ce05f893b5347098014f2d9eff2"}, + {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d35cef91e59ebbeaa45214861874bc6f19eb35de96db73e467a8358d701a96c"}, + {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d72278a30111e5b5525c1dd96120d9e958464316f55adb030433ea905866f4de"}, + {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4c29cbbba378759ac5786730d1c3cb4ec6f8ababf5c42a9ce303dc4b3d08cda"}, + {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6632f2d04f15d1bd6fe0eedd3b86d9061b836ddca4c03d5cf5c7e9e6b7c14580"}, + {file = "rpds_py-0.20.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:d0b67d87bb45ed1cd020e8fbf2307d449b68abc45402fe1a4ac9e46c3c8b192b"}, + {file = "rpds_py-0.20.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:ec31a99ca63bf3cd7f1a5ac9fe95c5e2d060d3c768a09bc1d16e235840861420"}, + {file = "rpds_py-0.20.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:22e6c9976e38f4d8c4a63bd8a8edac5307dffd3ee7e6026d97f3cc3a2dc02a0b"}, + {file = "rpds_py-0.20.0-cp39-none-win32.whl", hash = "sha256:569b3ea770c2717b730b61998b6c54996adee3cef69fc28d444f3e7920313cf7"}, + {file = "rpds_py-0.20.0-cp39-none-win_amd64.whl", hash = "sha256:e6900ecdd50ce0facf703f7a00df12374b74bbc8ad9fe0f6559947fb20f82364"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:617c7357272c67696fd052811e352ac54ed1d9b49ab370261a80d3b6ce385045"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9426133526f69fcaba6e42146b4e12d6bc6c839b8b555097020e2b78ce908dcc"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:deb62214c42a261cb3eb04d474f7155279c1a8a8c30ac89b7dcb1721d92c3c02"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fcaeb7b57f1a1e071ebd748984359fef83ecb026325b9d4ca847c95bc7311c92"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d454b8749b4bd70dd0a79f428731ee263fa6995f83ccb8bada706e8d1d3ff89d"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d807dc2051abe041b6649681dce568f8e10668e3c1c6543ebae58f2d7e617855"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3c20f0ddeb6e29126d45f89206b8291352b8c5b44384e78a6499d68b52ae511"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b7f19250ceef892adf27f0399b9e5afad019288e9be756d6919cb58892129f51"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:4f1ed4749a08379555cebf4650453f14452eaa9c43d0a95c49db50c18b7da075"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:dcedf0b42bcb4cfff4101d7771a10532415a6106062f005ab97d1d0ab5681c60"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:39ed0d010457a78f54090fafb5d108501b5aa5604cc22408fc1c0c77eac14344"}, + {file = "rpds_py-0.20.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:bb273176be34a746bdac0b0d7e4e2c467323d13640b736c4c477881a3220a989"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f918a1a130a6dfe1d7fe0f105064141342e7dd1611f2e6a21cd2f5c8cb1cfb3e"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:f60012a73aa396be721558caa3a6fd49b3dd0033d1675c6d59c4502e870fcf0c"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d2b1ad682a3dfda2a4e8ad8572f3100f95fad98cb99faf37ff0ddfe9cbf9d03"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:614fdafe9f5f19c63ea02817fa4861c606a59a604a77c8cdef5aa01d28b97921"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fa518bcd7600c584bf42e6617ee8132869e877db2f76bcdc281ec6a4113a53ab"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f0475242f447cc6cb8a9dd486d68b2ef7fbee84427124c232bff5f63b1fe11e5"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f90a4cd061914a60bd51c68bcb4357086991bd0bb93d8aa66a6da7701370708f"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:def7400461c3a3f26e49078302e1c1b38f6752342c77e3cf72ce91ca69fb1bc1"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:65794e4048ee837494aea3c21a28ad5fc080994dfba5b036cf84de37f7ad5074"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:faefcc78f53a88f3076b7f8be0a8f8d35133a3ecf7f3770895c25f8813460f08"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:5b4f105deeffa28bbcdff6c49b34e74903139afa690e35d2d9e3c2c2fba18cec"}, + {file = "rpds_py-0.20.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:fdfc3a892927458d98f3d55428ae46b921d1f7543b89382fdb483f5640daaec8"}, + {file = "rpds_py-0.20.0.tar.gz", hash = "sha256:d72a210824facfdaf8768cf2d7ca25a042c30320b3020de2fa04640920d4e121"}, ] [[package]] @@ -4766,103 +5036,110 @@ files = [ [[package]] name = "scikit-learn" -version = "1.4.2" +version = "1.5.2" description = "A set of python modules for machine learning and data mining" optional = false python-versions = ">=3.9" files = [ - {file = "scikit-learn-1.4.2.tar.gz", hash = "sha256:daa1c471d95bad080c6e44b4946c9390a4842adc3082572c20e4f8884e39e959"}, - {file = "scikit_learn-1.4.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8539a41b3d6d1af82eb629f9c57f37428ff1481c1e34dddb3b9d7af8ede67ac5"}, - {file = "scikit_learn-1.4.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:68b8404841f944a4a1459b07198fa2edd41a82f189b44f3e1d55c104dbc2e40c"}, - {file = "scikit_learn-1.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81bf5d8bbe87643103334032dd82f7419bc8c8d02a763643a6b9a5c7288c5054"}, - {file = "scikit_learn-1.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:36f0ea5d0f693cb247a073d21a4123bdf4172e470e6d163c12b74cbb1536cf38"}, - {file = "scikit_learn-1.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:87440e2e188c87db80ea4023440923dccbd56fbc2d557b18ced00fef79da0727"}, - {file = "scikit_learn-1.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:45dee87ac5309bb82e3ea633955030df9bbcb8d2cdb30383c6cd483691c546cc"}, - {file = "scikit_learn-1.4.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:1d0b25d9c651fd050555aadd57431b53d4cf664e749069da77f3d52c5ad14b3b"}, - {file = "scikit_learn-1.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0203c368058ab92efc6168a1507d388d41469c873e96ec220ca8e74079bf62e"}, - {file = "scikit_learn-1.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:44c62f2b124848a28fd695db5bc4da019287abf390bfce602ddc8aa1ec186aae"}, - {file = "scikit_learn-1.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:5cd7b524115499b18b63f0c96f4224eb885564937a0b3477531b2b63ce331904"}, - {file = "scikit_learn-1.4.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:90378e1747949f90c8f385898fff35d73193dfcaec3dd75d6b542f90c4e89755"}, - {file = "scikit_learn-1.4.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:ff4effe5a1d4e8fed260a83a163f7dbf4f6087b54528d8880bab1d1377bd78be"}, - {file = "scikit_learn-1.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:671e2f0c3f2c15409dae4f282a3a619601fa824d2c820e5b608d9d775f91780c"}, - {file = "scikit_learn-1.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d36d0bc983336bbc1be22f9b686b50c964f593c8a9a913a792442af9bf4f5e68"}, - {file = "scikit_learn-1.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:d762070980c17ba3e9a4a1e043ba0518ce4c55152032f1af0ca6f39b376b5928"}, - {file = "scikit_learn-1.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d9993d5e78a8148b1d0fdf5b15ed92452af5581734129998c26f481c46586d68"}, - {file = "scikit_learn-1.4.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:426d258fddac674fdf33f3cb2d54d26f49406e2599dbf9a32b4d1696091d4256"}, - {file = "scikit_learn-1.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5460a1a5b043ae5ae4596b3126a4ec33ccba1b51e7ca2c5d36dac2169f62ab1d"}, - {file = "scikit_learn-1.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49d64ef6cb8c093d883e5a36c4766548d974898d378e395ba41a806d0e824db8"}, - {file = "scikit_learn-1.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:c97a50b05c194be9146d61fe87dbf8eac62b203d9e87a3ccc6ae9aed2dfaf361"}, + {file = "scikit_learn-1.5.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:299406827fb9a4f862626d0fe6c122f5f87f8910b86fe5daa4c32dcd742139b6"}, + {file = "scikit_learn-1.5.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:2d4cad1119c77930b235579ad0dc25e65c917e756fe80cab96aa3b9428bd3fb0"}, + {file = "scikit_learn-1.5.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c412ccc2ad9bf3755915e3908e677b367ebc8d010acbb3f182814524f2e5540"}, + {file = "scikit_learn-1.5.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a686885a4b3818d9e62904d91b57fa757fc2bed3e465c8b177be652f4dd37c8"}, + {file = "scikit_learn-1.5.2-cp310-cp310-win_amd64.whl", hash = "sha256:c15b1ca23d7c5f33cc2cb0a0d6aaacf893792271cddff0edbd6a40e8319bc113"}, + {file = "scikit_learn-1.5.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:03b6158efa3faaf1feea3faa884c840ebd61b6484167c711548fce208ea09445"}, + {file = "scikit_learn-1.5.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:1ff45e26928d3b4eb767a8f14a9a6efbf1cbff7c05d1fb0f95f211a89fd4f5de"}, + {file = "scikit_learn-1.5.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f763897fe92d0e903aa4847b0aec0e68cadfff77e8a0687cabd946c89d17e675"}, + {file = "scikit_learn-1.5.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8b0ccd4a902836493e026c03256e8b206656f91fbcc4fde28c57a5b752561f1"}, + {file = "scikit_learn-1.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:6c16d84a0d45e4894832b3c4d0bf73050939e21b99b01b6fd59cbb0cf39163b6"}, + {file = "scikit_learn-1.5.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f932a02c3f4956dfb981391ab24bda1dbd90fe3d628e4b42caef3e041c67707a"}, + {file = "scikit_learn-1.5.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:3b923d119d65b7bd555c73be5423bf06c0105678ce7e1f558cb4b40b0a5502b1"}, + {file = "scikit_learn-1.5.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f60021ec1574e56632be2a36b946f8143bf4e5e6af4a06d85281adc22938e0dd"}, + {file = "scikit_learn-1.5.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:394397841449853c2290a32050382edaec3da89e35b3e03d6cc966aebc6a8ae6"}, + {file = "scikit_learn-1.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:57cc1786cfd6bd118220a92ede80270132aa353647684efa385a74244a41e3b1"}, + {file = "scikit_learn-1.5.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:757c7d514ddb00ae249832fe87100d9c73c6ea91423802872d9e74970a0e40b9"}, + {file = "scikit_learn-1.5.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:52788f48b5d8bca5c0736c175fa6bdaab2ef00a8f536cda698db61bd89c551c1"}, + {file = "scikit_learn-1.5.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:643964678f4b5fbdc95cbf8aec638acc7aa70f5f79ee2cdad1eec3df4ba6ead8"}, + {file = "scikit_learn-1.5.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca64b3089a6d9b9363cd3546f8978229dcbb737aceb2c12144ee3f70f95684b7"}, + {file = "scikit_learn-1.5.2-cp39-cp39-win_amd64.whl", hash = "sha256:3bed4909ba187aca80580fe2ef370d9180dcf18e621a27c4cf2ef10d279a7efe"}, + {file = "scikit_learn-1.5.2.tar.gz", hash = "sha256:b4237ed7b3fdd0a4882792e68ef2545d5baa50aca3bb45aa7df468138ad8f94d"}, ] [package.dependencies] joblib = ">=1.2.0" numpy = ">=1.19.5" scipy = ">=1.6.0" -threadpoolctl = ">=2.0.0" +threadpoolctl = ">=3.1.0" [package.extras] -benchmark = ["matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "pandas (>=1.1.5)"] -docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=6.0.0)", "sphinx-copybutton (>=0.5.2)", "sphinx-gallery (>=0.15.0)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"] +benchmark = ["matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "pandas (>=1.1.5)"] +build = ["cython (>=3.0.10)", "meson-python (>=0.16.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)"] +docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "polars (>=0.20.30)", "pooch (>=1.6.0)", "pydata-sphinx-theme (>=0.15.3)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=7.3.7)", "sphinx-copybutton (>=0.5.2)", "sphinx-design (>=0.5.0)", "sphinx-design (>=0.6.0)", "sphinx-gallery (>=0.16.0)", "sphinx-prompt (>=1.4.0)", "sphinx-remove-toctrees (>=1.0.0.post1)", "sphinxcontrib-sass (>=0.3.4)", "sphinxext-opengraph (>=0.9.1)"] examples = ["matplotlib (>=3.3.4)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)"] -tests = ["black (>=23.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.3)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.19.12)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.0.272)", "scikit-image (>=0.17.2)"] +install = ["joblib (>=1.2.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)", "threadpoolctl (>=3.1.0)"] +maintenance = ["conda-lock (==2.5.6)"] +tests = ["black (>=24.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.9)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.20.30)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.2.1)", "scikit-image (>=0.17.2)"] [[package]] name = "scipy" -version = "1.12.0" +version = "1.13.1" description = "Fundamental algorithms for scientific computing in Python" optional = false python-versions = ">=3.9" files = [ - {file = "scipy-1.12.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:78e4402e140879387187f7f25d91cc592b3501a2e51dfb320f48dfb73565f10b"}, - {file = "scipy-1.12.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:f5f00ebaf8de24d14b8449981a2842d404152774c1a1d880c901bf454cb8e2a1"}, - {file = "scipy-1.12.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e53958531a7c695ff66c2e7bb7b79560ffdc562e2051644c5576c39ff8efb563"}, - {file = "scipy-1.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e32847e08da8d895ce09d108a494d9eb78974cf6de23063f93306a3e419960c"}, - {file = "scipy-1.12.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4c1020cad92772bf44b8e4cdabc1df5d87376cb219742549ef69fc9fd86282dd"}, - {file = "scipy-1.12.0-cp310-cp310-win_amd64.whl", hash = "sha256:75ea2a144096b5e39402e2ff53a36fecfd3b960d786b7efd3c180e29c39e53f2"}, - {file = "scipy-1.12.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:408c68423f9de16cb9e602528be4ce0d6312b05001f3de61fe9ec8b1263cad08"}, - {file = "scipy-1.12.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5adfad5dbf0163397beb4aca679187d24aec085343755fcdbdeb32b3679f254c"}, - {file = "scipy-1.12.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3003652496f6e7c387b1cf63f4bb720951cfa18907e998ea551e6de51a04467"}, - {file = "scipy-1.12.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b8066bce124ee5531d12a74b617d9ac0ea59245246410e19bca549656d9a40a"}, - {file = "scipy-1.12.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8bee4993817e204d761dba10dbab0774ba5a8612e57e81319ea04d84945375ba"}, - {file = "scipy-1.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:a24024d45ce9a675c1fb8494e8e5244efea1c7a09c60beb1eeb80373d0fecc70"}, - {file = "scipy-1.12.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:e7e76cc48638228212c747ada851ef355c2bb5e7f939e10952bc504c11f4e372"}, - {file = "scipy-1.12.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:f7ce148dffcd64ade37b2df9315541f9adad6efcaa86866ee7dd5db0c8f041c3"}, - {file = "scipy-1.12.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c39f92041f490422924dfdb782527a4abddf4707616e07b021de33467f917bc"}, - {file = "scipy-1.12.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7ebda398f86e56178c2fa94cad15bf457a218a54a35c2a7b4490b9f9cb2676c"}, - {file = "scipy-1.12.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:95e5c750d55cf518c398a8240571b0e0782c2d5a703250872f36eaf737751338"}, - {file = "scipy-1.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:e646d8571804a304e1da01040d21577685ce8e2db08ac58e543eaca063453e1c"}, - {file = "scipy-1.12.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:913d6e7956c3a671de3b05ccb66b11bc293f56bfdef040583a7221d9e22a2e35"}, - {file = "scipy-1.12.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:bba1b0c7256ad75401c73e4b3cf09d1f176e9bd4248f0d3112170fb2ec4db067"}, - {file = "scipy-1.12.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:730badef9b827b368f351eacae2e82da414e13cf8bd5051b4bdfd720271a5371"}, - {file = "scipy-1.12.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6546dc2c11a9df6926afcbdd8a3edec28566e4e785b915e849348c6dd9f3f490"}, - {file = "scipy-1.12.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:196ebad3a4882081f62a5bf4aeb7326aa34b110e533aab23e4374fcccb0890dc"}, - {file = "scipy-1.12.0-cp39-cp39-win_amd64.whl", hash = "sha256:b360f1b6b2f742781299514e99ff560d1fe9bd1bff2712894b52abe528d1fd1e"}, - {file = "scipy-1.12.0.tar.gz", hash = "sha256:4bf5abab8a36d20193c698b0f1fc282c1d083c94723902c447e5d2f1780936a3"}, -] - -[package.dependencies] -numpy = ">=1.22.4,<1.29.0" - -[package.extras] -dev = ["click", "cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] -doc = ["jupytext", "matplotlib (>2)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (==0.9.0)", "sphinx (!=4.1.0)", "sphinx-design (>=0.2.0)"] -test = ["asv", "gmpy2", "hypothesis", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + {file = "scipy-1.13.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:20335853b85e9a49ff7572ab453794298bcf0354d8068c5f6775a0eabf350aca"}, + {file = "scipy-1.13.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d605e9c23906d1994f55ace80e0125c587f96c020037ea6aa98d01b4bd2e222f"}, + {file = "scipy-1.13.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cfa31f1def5c819b19ecc3a8b52d28ffdcc7ed52bb20c9a7589669dd3c250989"}, + {file = "scipy-1.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26264b282b9da0952a024ae34710c2aff7d27480ee91a2e82b7b7073c24722f"}, + {file = "scipy-1.13.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:eccfa1906eacc02de42d70ef4aecea45415f5be17e72b61bafcfd329bdc52e94"}, + {file = "scipy-1.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:2831f0dc9c5ea9edd6e51e6e769b655f08ec6db6e2e10f86ef39bd32eb11da54"}, + {file = "scipy-1.13.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:27e52b09c0d3a1d5b63e1105f24177e544a222b43611aaf5bc44d4a0979e32f9"}, + {file = "scipy-1.13.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:54f430b00f0133e2224c3ba42b805bfd0086fe488835effa33fa291561932326"}, + {file = "scipy-1.13.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e89369d27f9e7b0884ae559a3a956e77c02114cc60a6058b4e5011572eea9299"}, + {file = "scipy-1.13.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a78b4b3345f1b6f68a763c6e25c0c9a23a9fd0f39f5f3d200efe8feda560a5fa"}, + {file = "scipy-1.13.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:45484bee6d65633752c490404513b9ef02475b4284c4cfab0ef946def50b3f59"}, + {file = "scipy-1.13.1-cp311-cp311-win_amd64.whl", hash = "sha256:5713f62f781eebd8d597eb3f88b8bf9274e79eeabf63afb4a737abc6c84ad37b"}, + {file = "scipy-1.13.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5d72782f39716b2b3509cd7c33cdc08c96f2f4d2b06d51e52fb45a19ca0c86a1"}, + {file = "scipy-1.13.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:017367484ce5498445aade74b1d5ab377acdc65e27095155e448c88497755a5d"}, + {file = "scipy-1.13.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:949ae67db5fa78a86e8fa644b9a6b07252f449dcf74247108c50e1d20d2b4627"}, + {file = "scipy-1.13.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de3ade0e53bc1f21358aa74ff4830235d716211d7d077e340c7349bc3542e884"}, + {file = "scipy-1.13.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2ac65fb503dad64218c228e2dc2d0a0193f7904747db43014645ae139c8fad16"}, + {file = "scipy-1.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:cdd7dacfb95fea358916410ec61bbc20440f7860333aee6d882bb8046264e949"}, + {file = "scipy-1.13.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:436bbb42a94a8aeef855d755ce5a465479c721e9d684de76bf61a62e7c2b81d5"}, + {file = "scipy-1.13.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:8335549ebbca860c52bf3d02f80784e91a004b71b059e3eea9678ba994796a24"}, + {file = "scipy-1.13.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d533654b7d221a6a97304ab63c41c96473ff04459e404b83275b60aa8f4b7004"}, + {file = "scipy-1.13.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637e98dcf185ba7f8e663e122ebf908c4702420477ae52a04f9908707456ba4d"}, + {file = "scipy-1.13.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a014c2b3697bde71724244f63de2476925596c24285c7a637364761f8710891c"}, + {file = "scipy-1.13.1-cp39-cp39-win_amd64.whl", hash = "sha256:392e4ec766654852c25ebad4f64e4e584cf19820b980bc04960bca0b0cd6eaa2"}, + {file = "scipy-1.13.1.tar.gz", hash = "sha256:095a87a0312b08dfd6a6155cbbd310a8c51800fc931b8c0b84003014b874ed3c"}, +] + +[package.dependencies] +numpy = ">=1.22.4,<2.3" + +[package.extras] +dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] +doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.12.0)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] +test = ["array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] [[package]] name = "setuptools" -version = "69.5.1" +version = "75.1.0" description = "Easily download, build, install, upgrade, and uninstall Python packages" optional = false python-versions = ">=3.8" files = [ - {file = "setuptools-69.5.1-py3-none-any.whl", hash = "sha256:c636ac361bc47580504644275c9ad802c50415c7522212252c033bd15f301f32"}, - {file = "setuptools-69.5.1.tar.gz", hash = "sha256:6c1fccdac05a97e598fb0ae3bbed5904ccb317337a51139dcd51453611bbb987"}, + {file = "setuptools-75.1.0-py3-none-any.whl", hash = "sha256:35ab7fd3bcd95e6b7fd704e4a1539513edad446c097797f2985e0e4b960772f2"}, + {file = "setuptools-75.1.0.tar.gz", hash = "sha256:d59a21b17a275fb872a9c3dae73963160ae079f1049ed956880cd7c09b120538"}, ] [package.extras] -docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"] -testing = ["build[virtualenv]", "filelock (>=3.4.0)", "importlib-metadata", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "mypy (==1.9)", "packaging (>=23.2)", "pip (>=19.1)", "pytest (>=6,!=8.1.1)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist (>=3)", "tomli", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] -testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)", "ruff (>=0.5.2)"] +core = ["importlib-metadata (>=6)", "importlib-resources (>=5.10.2)", "jaraco.collections", "jaraco.functools", "jaraco.text (>=3.7)", "more-itertools", "more-itertools (>=8.8)", "packaging", "packaging (>=24)", "platformdirs (>=2.6.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"] +cover = ["pytest-cov"] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier", "towncrier (<24.7)"] +enabler = ["pytest-enabler (>=2.2)"] +test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "jaraco.test", "packaging (>=23.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"] +type = ["importlib-metadata (>=7.0.2)", "jaraco.develop (>=7.21)", "mypy (==1.11.*)", "pytest-mypy"] [[package]] name = "six" @@ -4924,13 +5201,13 @@ files = [ [[package]] name = "soupsieve" -version = "2.5" +version = "2.6" description = "A modern CSS selector implementation for Beautiful Soup." optional = false python-versions = ">=3.8" files = [ - {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"}, - {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"}, + {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, + {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, ] [[package]] @@ -5019,17 +5296,17 @@ markdown = ">=3.4" [[package]] name = "sphinxcontrib-applehelp" -version = "1.0.8" +version = "2.0.0" description = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" optional = false python-versions = ">=3.9" files = [ - {file = "sphinxcontrib_applehelp-1.0.8-py3-none-any.whl", hash = "sha256:cb61eb0ec1b61f349e5cc36b2028e9e7ca765be05e49641c97241274753067b4"}, - {file = "sphinxcontrib_applehelp-1.0.8.tar.gz", hash = "sha256:c40a4f96f3776c4393d933412053962fac2b84f4c99a7982ba42e09576a70619"}, + {file = "sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5"}, + {file = "sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1"}, ] [package.extras] -lint = ["docutils-stubs", "flake8", "mypy"] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] standalone = ["Sphinx (>=5)"] test = ["pytest"] @@ -5053,33 +5330,33 @@ Sphinx = ">=2.1" [[package]] name = "sphinxcontrib-devhelp" -version = "1.0.6" +version = "2.0.0" description = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents" optional = false python-versions = ">=3.9" files = [ - {file = "sphinxcontrib_devhelp-1.0.6-py3-none-any.whl", hash = "sha256:6485d09629944511c893fa11355bda18b742b83a2b181f9a009f7e500595c90f"}, - {file = "sphinxcontrib_devhelp-1.0.6.tar.gz", hash = "sha256:9893fd3f90506bc4b97bdb977ceb8fbd823989f4316b28c3841ec128544372d3"}, + {file = "sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2"}, + {file = "sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad"}, ] [package.extras] -lint = ["docutils-stubs", "flake8", "mypy"] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] standalone = ["Sphinx (>=5)"] test = ["pytest"] [[package]] name = "sphinxcontrib-htmlhelp" -version = "2.0.5" +version = "2.1.0" description = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" optional = false python-versions = ">=3.9" files = [ - {file = "sphinxcontrib_htmlhelp-2.0.5-py3-none-any.whl", hash = "sha256:393f04f112b4d2f53d93448d4bce35842f62b307ccdc549ec1585e950bc35e04"}, - {file = "sphinxcontrib_htmlhelp-2.0.5.tar.gz", hash = "sha256:0dc87637d5de53dd5eec3a6a01753b1ccf99494bd756aafecd74b4fa9e729015"}, + {file = "sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8"}, + {file = "sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9"}, ] [package.extras] -lint = ["docutils-stubs", "flake8", "mypy"] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] standalone = ["Sphinx (>=5)"] test = ["html5lib", "pytest"] @@ -5099,33 +5376,33 @@ test = ["flake8", "mypy", "pytest"] [[package]] name = "sphinxcontrib-qthelp" -version = "1.0.7" +version = "2.0.0" description = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents" optional = false python-versions = ">=3.9" files = [ - {file = "sphinxcontrib_qthelp-1.0.7-py3-none-any.whl", hash = "sha256:e2ae3b5c492d58fcbd73281fbd27e34b8393ec34a073c792642cd8e529288182"}, - {file = "sphinxcontrib_qthelp-1.0.7.tar.gz", hash = "sha256:053dedc38823a80a7209a80860b16b722e9e0209e32fea98c90e4e6624588ed6"}, + {file = "sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb"}, + {file = "sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab"}, ] [package.extras] -lint = ["docutils-stubs", "flake8", "mypy"] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] standalone = ["Sphinx (>=5)"] -test = ["pytest"] +test = ["defusedxml (>=0.7.1)", "pytest"] [[package]] name = "sphinxcontrib-serializinghtml" -version = "1.1.10" +version = "2.0.0" description = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)" optional = false python-versions = ">=3.9" files = [ - {file = "sphinxcontrib_serializinghtml-1.1.10-py3-none-any.whl", hash = "sha256:326369b8df80a7d2d8d7f99aa5ac577f51ea51556ed974e7716cfd4fca3f6cb7"}, - {file = "sphinxcontrib_serializinghtml-1.1.10.tar.gz", hash = "sha256:93f3f5dc458b91b192fe10c397e324f262cf163d79f3282c158e8436a2c4511f"}, + {file = "sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331"}, + {file = "sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d"}, ] [package.extras] -lint = ["docutils-stubs", "flake8", "mypy"] +lint = ["mypy", "ruff (==0.5.5)", "types-docutils"] standalone = ["Sphinx (>=5)"] test = ["pytest"] @@ -5144,6 +5421,93 @@ files = [ numpy = "*" pyserial = "*" +[[package]] +name = "sqlalchemy" +version = "2.0.35" +description = "Database Abstraction Library" +optional = false +python-versions = ">=3.7" +files = [ + {file = "SQLAlchemy-2.0.35-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:67219632be22f14750f0d1c70e62f204ba69d28f62fd6432ba05ab295853de9b"}, + {file = "SQLAlchemy-2.0.35-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4668bd8faf7e5b71c0319407b608f278f279668f358857dbfd10ef1954ac9f90"}, + {file = "SQLAlchemy-2.0.35-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb8bea573863762bbf45d1e13f87c2d2fd32cee2dbd50d050f83f87429c9e1ea"}, + {file = "SQLAlchemy-2.0.35-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f552023710d4b93d8fb29a91fadf97de89c5926c6bd758897875435f2a939f33"}, + {file = "SQLAlchemy-2.0.35-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:016b2e665f778f13d3c438651dd4de244214b527a275e0acf1d44c05bc6026a9"}, + {file = "SQLAlchemy-2.0.35-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7befc148de64b6060937231cbff8d01ccf0bfd75aa26383ffdf8d82b12ec04ff"}, + {file = "SQLAlchemy-2.0.35-cp310-cp310-win32.whl", hash = "sha256:22b83aed390e3099584b839b93f80a0f4a95ee7f48270c97c90acd40ee646f0b"}, + {file = "SQLAlchemy-2.0.35-cp310-cp310-win_amd64.whl", hash = "sha256:a29762cd3d116585278ffb2e5b8cc311fb095ea278b96feef28d0b423154858e"}, + {file = "SQLAlchemy-2.0.35-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e21f66748ab725ade40fa7af8ec8b5019c68ab00b929f6643e1b1af461eddb60"}, + {file = "SQLAlchemy-2.0.35-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8a6219108a15fc6d24de499d0d515c7235c617b2540d97116b663dade1a54d62"}, + {file = "SQLAlchemy-2.0.35-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:042622a5306c23b972192283f4e22372da3b8ddf5f7aac1cc5d9c9b222ab3ff6"}, + {file = "SQLAlchemy-2.0.35-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:627dee0c280eea91aed87b20a1f849e9ae2fe719d52cbf847c0e0ea34464b3f7"}, + {file = "SQLAlchemy-2.0.35-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4fdcd72a789c1c31ed242fd8c1bcd9ea186a98ee8e5408a50e610edfef980d71"}, + {file = "SQLAlchemy-2.0.35-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:89b64cd8898a3a6f642db4eb7b26d1b28a497d4022eccd7717ca066823e9fb01"}, + {file = "SQLAlchemy-2.0.35-cp311-cp311-win32.whl", hash = "sha256:6a93c5a0dfe8d34951e8a6f499a9479ffb9258123551fa007fc708ae2ac2bc5e"}, + {file = "SQLAlchemy-2.0.35-cp311-cp311-win_amd64.whl", hash = "sha256:c68fe3fcde03920c46697585620135b4ecfdfc1ed23e75cc2c2ae9f8502c10b8"}, + {file = "SQLAlchemy-2.0.35-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:eb60b026d8ad0c97917cb81d3662d0b39b8ff1335e3fabb24984c6acd0c900a2"}, + {file = "SQLAlchemy-2.0.35-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6921ee01caf375363be5e9ae70d08ce7ca9d7e0e8983183080211a062d299468"}, + {file = "SQLAlchemy-2.0.35-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8cdf1a0dbe5ced887a9b127da4ffd7354e9c1a3b9bb330dce84df6b70ccb3a8d"}, + {file = "SQLAlchemy-2.0.35-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93a71c8601e823236ac0e5d087e4f397874a421017b3318fd92c0b14acf2b6db"}, + {file = "SQLAlchemy-2.0.35-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e04b622bb8a88f10e439084486f2f6349bf4d50605ac3e445869c7ea5cf0fa8c"}, + {file = "SQLAlchemy-2.0.35-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1b56961e2d31389aaadf4906d453859f35302b4eb818d34a26fab72596076bb8"}, + {file = "SQLAlchemy-2.0.35-cp312-cp312-win32.whl", hash = "sha256:0f9f3f9a3763b9c4deb8c5d09c4cc52ffe49f9876af41cc1b2ad0138878453cf"}, + {file = "SQLAlchemy-2.0.35-cp312-cp312-win_amd64.whl", hash = "sha256:25b0f63e7fcc2a6290cb5f7f5b4fc4047843504983a28856ce9b35d8f7de03cc"}, + {file = "SQLAlchemy-2.0.35-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:f021d334f2ca692523aaf7bbf7592ceff70c8594fad853416a81d66b35e3abf9"}, + {file = "SQLAlchemy-2.0.35-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05c3f58cf91683102f2f0265c0db3bd3892e9eedabe059720492dbaa4f922da1"}, + {file = "SQLAlchemy-2.0.35-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:032d979ce77a6c2432653322ba4cbeabf5a6837f704d16fa38b5a05d8e21fa00"}, + {file = "SQLAlchemy-2.0.35-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:2e795c2f7d7249b75bb5f479b432a51b59041580d20599d4e112b5f2046437a3"}, + {file = "SQLAlchemy-2.0.35-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:cc32b2990fc34380ec2f6195f33a76b6cdaa9eecf09f0c9404b74fc120aef36f"}, + {file = "SQLAlchemy-2.0.35-cp37-cp37m-win32.whl", hash = "sha256:9509c4123491d0e63fb5e16199e09f8e262066e58903e84615c301dde8fa2e87"}, + {file = "SQLAlchemy-2.0.35-cp37-cp37m-win_amd64.whl", hash = "sha256:3655af10ebcc0f1e4e06c5900bb33e080d6a1fa4228f502121f28a3b1753cde5"}, + {file = "SQLAlchemy-2.0.35-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:4c31943b61ed8fdd63dfd12ccc919f2bf95eefca133767db6fbbd15da62078ec"}, + {file = "SQLAlchemy-2.0.35-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a62dd5d7cc8626a3634208df458c5fe4f21200d96a74d122c83bc2015b333bc1"}, + {file = "SQLAlchemy-2.0.35-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0630774b0977804fba4b6bbea6852ab56c14965a2b0c7fc7282c5f7d90a1ae72"}, + {file = "SQLAlchemy-2.0.35-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d625eddf7efeba2abfd9c014a22c0f6b3796e0ffb48f5d5ab106568ef01ff5a"}, + {file = "SQLAlchemy-2.0.35-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:ada603db10bb865bbe591939de854faf2c60f43c9b763e90f653224138f910d9"}, + {file = "SQLAlchemy-2.0.35-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:c41411e192f8d3ea39ea70e0fae48762cd11a2244e03751a98bd3c0ca9a4e936"}, + {file = "SQLAlchemy-2.0.35-cp38-cp38-win32.whl", hash = "sha256:d299797d75cd747e7797b1b41817111406b8b10a4f88b6e8fe5b5e59598b43b0"}, + {file = "SQLAlchemy-2.0.35-cp38-cp38-win_amd64.whl", hash = "sha256:0375a141e1c0878103eb3d719eb6d5aa444b490c96f3fedab8471c7f6ffe70ee"}, + {file = "SQLAlchemy-2.0.35-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ccae5de2a0140d8be6838c331604f91d6fafd0735dbdcee1ac78fc8fbaba76b4"}, + {file = "SQLAlchemy-2.0.35-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2a275a806f73e849e1c309ac11108ea1a14cd7058577aba962cd7190e27c9e3c"}, + {file = "SQLAlchemy-2.0.35-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:732e026240cdd1c1b2e3ac515c7a23820430ed94292ce33806a95869c46bd139"}, + {file = "SQLAlchemy-2.0.35-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:890da8cd1941fa3dab28c5bac3b9da8502e7e366f895b3b8e500896f12f94d11"}, + {file = "SQLAlchemy-2.0.35-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:c0d8326269dbf944b9201911b0d9f3dc524d64779a07518199a58384c3d37a44"}, + {file = "SQLAlchemy-2.0.35-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b76d63495b0508ab9fc23f8152bac63205d2a704cd009a2b0722f4c8e0cba8e0"}, + {file = "SQLAlchemy-2.0.35-cp39-cp39-win32.whl", hash = "sha256:69683e02e8a9de37f17985905a5eca18ad651bf592314b4d3d799029797d0eb3"}, + {file = "SQLAlchemy-2.0.35-cp39-cp39-win_amd64.whl", hash = "sha256:aee110e4ef3c528f3abbc3c2018c121e708938adeeff9006428dd7c8555e9b3f"}, + {file = "SQLAlchemy-2.0.35-py3-none-any.whl", hash = "sha256:2ab3f0336c0387662ce6221ad30ab3a5e6499aab01b9790879b6578fd9b8faa1"}, + {file = "sqlalchemy-2.0.35.tar.gz", hash = "sha256:e11d7ea4d24f0a262bccf9a7cd6284c976c5369dac21db237cff59586045ab9f"}, +] + +[package.dependencies] +greenlet = {version = "!=0.4.17", markers = "python_version < \"3.13\" and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\")"} +typing-extensions = ">=4.6.0" + +[package.extras] +aiomysql = ["aiomysql (>=0.2.0)", "greenlet (!=0.4.17)"] +aioodbc = ["aioodbc", "greenlet (!=0.4.17)"] +aiosqlite = ["aiosqlite", "greenlet (!=0.4.17)", "typing_extensions (!=3.10.0.1)"] +asyncio = ["greenlet (!=0.4.17)"] +asyncmy = ["asyncmy (>=0.2.3,!=0.2.4,!=0.2.6)", "greenlet (!=0.4.17)"] +mariadb-connector = ["mariadb (>=1.0.1,!=1.1.2,!=1.1.5)"] +mssql = ["pyodbc"] +mssql-pymssql = ["pymssql"] +mssql-pyodbc = ["pyodbc"] +mypy = ["mypy (>=0.910)"] +mysql = ["mysqlclient (>=1.4.0)"] +mysql-connector = ["mysql-connector-python"] +oracle = ["cx_oracle (>=8)"] +oracle-oracledb = ["oracledb (>=1.0.1)"] +postgresql = ["psycopg2 (>=2.7)"] +postgresql-asyncpg = ["asyncpg", "greenlet (!=0.4.17)"] +postgresql-pg8000 = ["pg8000 (>=1.29.1)"] +postgresql-psycopg = ["psycopg (>=3.0.7)"] +postgresql-psycopg2binary = ["psycopg2-binary"] +postgresql-psycopg2cffi = ["psycopg2cffi"] +postgresql-psycopgbinary = ["psycopg[binary] (>=3.0.7)"] +pymysql = ["pymysql"] +sqlcipher = ["sqlcipher3_binary"] + [[package]] name = "sqlitedict" version = "2.1.0" @@ -5175,17 +5539,20 @@ tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] [[package]] name = "sympy" -version = "1.12" +version = "1.13.3" description = "Computer algebra system (CAS) in Python" optional = false python-versions = ">=3.8" files = [ - {file = "sympy-1.12-py3-none-any.whl", hash = "sha256:c3588cd4295d0c0f603d0f2ae780587e64e2efeedb3521e46b9bb1d08d184fa5"}, - {file = "sympy-1.12.tar.gz", hash = "sha256:ebf595c8dac3e0fdc4152c51878b498396ec7f30e7a914d6071e674d49420fb8"}, + {file = "sympy-1.13.3-py3-none-any.whl", hash = "sha256:54612cf55a62755ee71824ce692986f23c88ffa77207b30c1368eda4a7060f73"}, + {file = "sympy-1.13.3.tar.gz", hash = "sha256:b27fd2c6530e0ab39e275fc9b683895367e51d5da91baa8d3d64db2565fec4d9"}, ] [package.dependencies] -mpmath = ">=0.19" +mpmath = ">=1.1.0,<1.4" + +[package.extras] +dev = ["hypothesis (>=6.70.0)", "pytest (>=7.1.0)"] [[package]] name = "tabulate" @@ -5203,13 +5570,13 @@ widechars = ["wcwidth"] [[package]] name = "tenacity" -version = "8.3.0" +version = "9.0.0" description = "Retry code until it succeeds" optional = false python-versions = ">=3.8" files = [ - {file = "tenacity-8.3.0-py3-none-any.whl", hash = "sha256:3649f6443dbc0d9b01b9d8020a9c4ec7a1ff5f6f3c6c8a036ef371f573fe9185"}, - {file = "tenacity-8.3.0.tar.gz", hash = "sha256:953d4e6ad24357bceffbc9707bc74349aca9d245f68eb65419cf0c249a1949a2"}, + {file = "tenacity-9.0.0-py3-none-any.whl", hash = "sha256:93de0c98785b27fcf659856aa9f54bfbd399e29969b0621bc7f762bd441b4539"}, + {file = "tenacity-9.0.0.tar.gz", hash = "sha256:807f37ca97d62aa361264d497b0e31e92b8027044942bfa756160d908320d73b"}, ] [package.extras] @@ -5269,44 +5636,44 @@ files = [ [[package]] name = "tomlkit" -version = "0.12.5" +version = "0.13.2" description = "Style preserving TOML library" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "tomlkit-0.12.5-py3-none-any.whl", hash = "sha256:af914f5a9c59ed9d0762c7b64d3b5d5df007448eb9cd2edc8a46b1eafead172f"}, - {file = "tomlkit-0.12.5.tar.gz", hash = "sha256:eef34fba39834d4d6b73c9ba7f3e4d1c417a4e56f89a7e96e090dd0d24b8fb3c"}, + {file = "tomlkit-0.13.2-py3-none-any.whl", hash = "sha256:7a974427f6e119197f670fbbbeae7bef749a6c14e793db934baefc1b5f03efde"}, + {file = "tomlkit-0.13.2.tar.gz", hash = "sha256:fff5fe59a87295b278abd31bec92c15d9bc4a06885ab12bcea52c71119392e79"}, ] [[package]] name = "tornado" -version = "6.4" +version = "6.4.1" description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." optional = false -python-versions = ">= 3.8" +python-versions = ">=3.8" files = [ - {file = "tornado-6.4-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:02ccefc7d8211e5a7f9e8bc3f9e5b0ad6262ba2fbb683a6443ecc804e5224ce0"}, - {file = "tornado-6.4-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:27787de946a9cffd63ce5814c33f734c627a87072ec7eed71f7fc4417bb16263"}, - {file = "tornado-6.4-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7894c581ecdcf91666a0912f18ce5e757213999e183ebfc2c3fdbf4d5bd764e"}, - {file = "tornado-6.4-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e43bc2e5370a6a8e413e1e1cd0c91bedc5bd62a74a532371042a18ef19e10579"}, - {file = "tornado-6.4-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0251554cdd50b4b44362f73ad5ba7126fc5b2c2895cc62b14a1c2d7ea32f212"}, - {file = "tornado-6.4-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fd03192e287fbd0899dd8f81c6fb9cbbc69194d2074b38f384cb6fa72b80e9c2"}, - {file = "tornado-6.4-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:88b84956273fbd73420e6d4b8d5ccbe913c65d31351b4c004ae362eba06e1f78"}, - {file = "tornado-6.4-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:71ddfc23a0e03ef2df1c1397d859868d158c8276a0603b96cf86892bff58149f"}, - {file = "tornado-6.4-cp38-abi3-win32.whl", hash = "sha256:6f8a6c77900f5ae93d8b4ae1196472d0ccc2775cc1dfdc9e7727889145c45052"}, - {file = "tornado-6.4-cp38-abi3-win_amd64.whl", hash = "sha256:10aeaa8006333433da48dec9fe417877f8bcc21f48dda8d661ae79da357b2a63"}, - {file = "tornado-6.4.tar.gz", hash = "sha256:72291fa6e6bc84e626589f1c29d90a5a6d593ef5ae68052ee2ef000dfd273dee"}, + {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:163b0aafc8e23d8cdc3c9dfb24c5368af84a81e3364745ccb4427669bf84aec8"}, + {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6d5ce3437e18a2b66fbadb183c1d3364fb03f2be71299e7d10dbeeb69f4b2a14"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e20b9113cd7293f164dc46fffb13535266e713cdb87bd2d15ddb336e96cfc4"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ae50a504a740365267b2a8d1a90c9fbc86b780a39170feca9bcc1787ff80842"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:613bf4ddf5c7a95509218b149b555621497a6cc0d46ac341b30bd9ec19eac7f3"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:25486eb223babe3eed4b8aecbac33b37e3dd6d776bc730ca14e1bf93888b979f"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:454db8a7ecfcf2ff6042dde58404164d969b6f5d58b926da15e6b23817950fc4"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a02a08cc7a9314b006f653ce40483b9b3c12cda222d6a46d4ac63bb6c9057698"}, + {file = "tornado-6.4.1-cp38-abi3-win32.whl", hash = "sha256:d9a566c40b89757c9aa8e6f032bcdb8ca8795d7c1a9762910c722b1635c9de4d"}, + {file = "tornado-6.4.1-cp38-abi3-win_amd64.whl", hash = "sha256:b24b8982ed444378d7f21d563f4180a2de31ced9d8d84443907a0a64da2072e7"}, + {file = "tornado-6.4.1.tar.gz", hash = "sha256:92d3ab53183d8c50f8204a51e6f91d18a15d5ef261e84d452800d4ff6fc504e9"}, ] [[package]] name = "tqdm" -version = "4.66.4" +version = "4.66.5" description = "Fast, Extensible Progress Meter" optional = false python-versions = ">=3.7" files = [ - {file = "tqdm-4.66.4-py3-none-any.whl", hash = "sha256:b75ca56b413b030bc3f00af51fd2c1a1a5eac6a0c1cca83cbb37a5c52abce644"}, - {file = "tqdm-4.66.4.tar.gz", hash = "sha256:e4d936c9de8727928f3be6079590e97d9abfe8d39a590be678eb5919ffc186bb"}, + {file = "tqdm-4.66.5-py3-none-any.whl", hash = "sha256:90279a3770753eafc9194a0364852159802111925aa30eb3f9d85b0e805ac7cd"}, + {file = "tqdm-4.66.5.tar.gz", hash = "sha256:e1020aef2e5096702d8a025ac7d16b1577279c9d63f8375b63083e9a5f0fcbad"}, ] [package.dependencies] @@ -5335,13 +5702,13 @@ test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0, [[package]] name = "typing-extensions" -version = "4.11.0" +version = "4.12.2" description = "Backported and Experimental Type Hints for Python 3.8+" optional = false python-versions = ">=3.8" files = [ - {file = "typing_extensions-4.11.0-py3-none-any.whl", hash = "sha256:c1f94d72897edaf4ce775bb7558d5b79d8126906a14ea5ed1635921406c0387a"}, - {file = "typing_extensions-4.11.0.tar.gz", hash = "sha256:83f085bd5ca59c80295fc2a82ab5dac679cbe02b9f33f7d83af68e241bea51b0"}, + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, ] [[package]] @@ -5357,23 +5724,20 @@ files = [ [[package]] name = "uncertainties" -version = "3.1.7" -description = "Transparent calculations with uncertainties on the quantities involved (aka error propagation); fast calculation of derivatives" +version = "3.2.2" +description = "calculations with values with uncertainties, error propagation" optional = false -python-versions = "*" +python-versions = ">=3.8" files = [ - {file = "uncertainties-3.1.7-py2.py3-none-any.whl", hash = "sha256:4040ec64d298215531922a68fa1506dc6b1cb86cd7cca8eca848fcfe0f987151"}, - {file = "uncertainties-3.1.7.tar.gz", hash = "sha256:80111e0839f239c5b233cb4772017b483a0b7a1573a581b92ab7746a35e6faab"}, + {file = "uncertainties-3.2.2-py3-none-any.whl", hash = "sha256:fd8543355952f4052786ed4150acaf12e23117bd0f5bd03ea07de466bce646e7"}, + {file = "uncertainties-3.2.2.tar.gz", hash = "sha256:e62c86fdc64429828229de6ab4e11466f114907e6bd343c077858994cc12e00b"}, ] -[package.dependencies] -future = "*" - [package.extras] -all = ["nose", "numpy", "sphinx"] -docs = ["sphinx"] -optional = ["numpy"] -tests = ["nose", "numpy"] +all = ["uncertainties[arrays,doc,test]"] +arrays = ["numpy"] +doc = ["python-docs-theme", "sphinx", "sphinx-copybutton"] +test = ["pytest", "pytest-cov"] [[package]] name = "unsync" @@ -5387,13 +5751,13 @@ files = [ [[package]] name = "urllib3" -version = "2.2.1" +version = "2.2.3" description = "HTTP library with thread-safe connection pooling, file post, and more." optional = false python-versions = ">=3.8" files = [ - {file = "urllib3-2.2.1-py3-none-any.whl", hash = "sha256:450b20ec296a467077128bff42b73080516e71b56ff59a60a02bef2232c4fa9d"}, - {file = "urllib3-2.2.1.tar.gz", hash = "sha256:d0570876c61ab9e520d776c38acbbb5b05a776d3f9ff98a5c8fd5162a444cf19"}, + {file = "urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac"}, + {file = "urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9"}, ] [package.extras] @@ -5404,13 +5768,13 @@ zstd = ["zstandard (>=0.18.0)"] [[package]] name = "versioningit" -version = "3.1.1" +version = "3.1.2" description = "Versioning It with your Version In Git" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "versioningit-3.1.1-py3-none-any.whl", hash = "sha256:3f5a855d98a2a85e909264f2eac3cce380b71f7632e7de55bc22bff9f03639ee"}, - {file = "versioningit-3.1.1.tar.gz", hash = "sha256:b0ba586e5af08b87dbe3354082910a1d0502c36202d496e1ae60ef3b41ee29c1"}, + {file = "versioningit-3.1.2-py3-none-any.whl", hash = "sha256:33c0905aeac7877b562171387c2c98af87b391aa9195f095455f21ddc47d4636"}, + {file = "versioningit-3.1.2.tar.gz", hash = "sha256:4db83ed99f56b07d83940bee3445ca46ca120d13b6b304cdb5fb44e5aa4edec0"}, ] [package.dependencies] @@ -5457,94 +5821,108 @@ files = [ [[package]] name = "websockets" -version = "12.0" +version = "13.0.1" description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)" optional = false python-versions = ">=3.8" files = [ - {file = "websockets-12.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d554236b2a2006e0ce16315c16eaa0d628dab009c33b63ea03f41c6107958374"}, - {file = "websockets-12.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2d225bb6886591b1746b17c0573e29804619c8f755b5598d875bb4235ea639be"}, - {file = "websockets-12.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:eb809e816916a3b210bed3c82fb88eaf16e8afcf9c115ebb2bacede1797d2547"}, - {file = "websockets-12.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c588f6abc13f78a67044c6b1273a99e1cf31038ad51815b3b016ce699f0d75c2"}, - {file = "websockets-12.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5aa9348186d79a5f232115ed3fa9020eab66d6c3437d72f9d2c8ac0c6858c558"}, - {file = "websockets-12.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6350b14a40c95ddd53e775dbdbbbc59b124a5c8ecd6fbb09c2e52029f7a9f480"}, - {file = "websockets-12.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:70ec754cc2a769bcd218ed8d7209055667b30860ffecb8633a834dde27d6307c"}, - {file = "websockets-12.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6e96f5ed1b83a8ddb07909b45bd94833b0710f738115751cdaa9da1fb0cb66e8"}, - {file = "websockets-12.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4d87be612cbef86f994178d5186add3d94e9f31cc3cb499a0482b866ec477603"}, - {file = "websockets-12.0-cp310-cp310-win32.whl", hash = "sha256:befe90632d66caaf72e8b2ed4d7f02b348913813c8b0a32fae1cc5fe3730902f"}, - {file = "websockets-12.0-cp310-cp310-win_amd64.whl", hash = "sha256:363f57ca8bc8576195d0540c648aa58ac18cf85b76ad5202b9f976918f4219cf"}, - {file = "websockets-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5d873c7de42dea355d73f170be0f23788cf3fa9f7bed718fd2830eefedce01b4"}, - {file = "websockets-12.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3f61726cae9f65b872502ff3c1496abc93ffbe31b278455c418492016e2afc8f"}, - {file = "websockets-12.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed2fcf7a07334c77fc8a230755c2209223a7cc44fc27597729b8ef5425aa61a3"}, - {file = "websockets-12.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e332c210b14b57904869ca9f9bf4ca32f5427a03eeb625da9b616c85a3a506c"}, - {file = "websockets-12.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5693ef74233122f8ebab026817b1b37fe25c411ecfca084b29bc7d6efc548f45"}, - {file = "websockets-12.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e9e7db18b4539a29cc5ad8c8b252738a30e2b13f033c2d6e9d0549b45841c04"}, - {file = "websockets-12.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6e2df67b8014767d0f785baa98393725739287684b9f8d8a1001eb2839031447"}, - {file = "websockets-12.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:bea88d71630c5900690fcb03161ab18f8f244805c59e2e0dc4ffadae0a7ee0ca"}, - {file = "websockets-12.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:dff6cdf35e31d1315790149fee351f9e52978130cef6c87c4b6c9b3baf78bc53"}, - {file = "websockets-12.0-cp311-cp311-win32.whl", hash = "sha256:3e3aa8c468af01d70332a382350ee95f6986db479ce7af14d5e81ec52aa2b402"}, - {file = "websockets-12.0-cp311-cp311-win_amd64.whl", hash = "sha256:25eb766c8ad27da0f79420b2af4b85d29914ba0edf69f547cc4f06ca6f1d403b"}, - {file = "websockets-12.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0e6e2711d5a8e6e482cacb927a49a3d432345dfe7dea8ace7b5790df5932e4df"}, - {file = "websockets-12.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:dbcf72a37f0b3316e993e13ecf32f10c0e1259c28ffd0a85cee26e8549595fbc"}, - {file = "websockets-12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:12743ab88ab2af1d17dd4acb4645677cb7063ef4db93abffbf164218a5d54c6b"}, - {file = "websockets-12.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b645f491f3c48d3f8a00d1fce07445fab7347fec54a3e65f0725d730d5b99cb"}, - {file = "websockets-12.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9893d1aa45a7f8b3bc4510f6ccf8db8c3b62120917af15e3de247f0780294b92"}, - {file = "websockets-12.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f38a7b376117ef7aff996e737583172bdf535932c9ca021746573bce40165ed"}, - {file = "websockets-12.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:f764ba54e33daf20e167915edc443b6f88956f37fb606449b4a5b10ba42235a5"}, - {file = "websockets-12.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:1e4b3f8ea6a9cfa8be8484c9221ec0257508e3a1ec43c36acdefb2a9c3b00aa2"}, - {file = "websockets-12.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9fdf06fd06c32205a07e47328ab49c40fc1407cdec801d698a7c41167ea45113"}, - {file = "websockets-12.0-cp312-cp312-win32.whl", hash = "sha256:baa386875b70cbd81798fa9f71be689c1bf484f65fd6fb08d051a0ee4e79924d"}, - {file = "websockets-12.0-cp312-cp312-win_amd64.whl", hash = "sha256:ae0a5da8f35a5be197f328d4727dbcfafa53d1824fac3d96cdd3a642fe09394f"}, - {file = "websockets-12.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5f6ffe2c6598f7f7207eef9a1228b6f5c818f9f4d53ee920aacd35cec8110438"}, - {file = "websockets-12.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9edf3fc590cc2ec20dc9d7a45108b5bbaf21c0d89f9fd3fd1685e223771dc0b2"}, - {file = "websockets-12.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8572132c7be52632201a35f5e08348137f658e5ffd21f51f94572ca6c05ea81d"}, - {file = "websockets-12.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:604428d1b87edbf02b233e2c207d7d528460fa978f9e391bd8aaf9c8311de137"}, - {file = "websockets-12.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1a9d160fd080c6285e202327aba140fc9a0d910b09e423afff4ae5cbbf1c7205"}, - {file = "websockets-12.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87b4aafed34653e465eb77b7c93ef058516cb5acf3eb21e42f33928616172def"}, - {file = "websockets-12.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b2ee7288b85959797970114deae81ab41b731f19ebcd3bd499ae9ca0e3f1d2c8"}, - {file = "websockets-12.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:7fa3d25e81bfe6a89718e9791128398a50dec6d57faf23770787ff441d851967"}, - {file = "websockets-12.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:a571f035a47212288e3b3519944f6bf4ac7bc7553243e41eac50dd48552b6df7"}, - {file = "websockets-12.0-cp38-cp38-win32.whl", hash = "sha256:3c6cc1360c10c17463aadd29dd3af332d4a1adaa8796f6b0e9f9df1fdb0bad62"}, - {file = "websockets-12.0-cp38-cp38-win_amd64.whl", hash = "sha256:1bf386089178ea69d720f8db6199a0504a406209a0fc23e603b27b300fdd6892"}, - {file = "websockets-12.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:ab3d732ad50a4fbd04a4490ef08acd0517b6ae6b77eb967251f4c263011a990d"}, - {file = "websockets-12.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1d9697f3337a89691e3bd8dc56dea45a6f6d975f92e7d5f773bc715c15dde28"}, - {file = "websockets-12.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1df2fbd2c8a98d38a66f5238484405b8d1d16f929bb7a33ed73e4801222a6f53"}, - {file = "websockets-12.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23509452b3bc38e3a057382c2e941d5ac2e01e251acce7adc74011d7d8de434c"}, - {file = "websockets-12.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e5fc14ec6ea568200ea4ef46545073da81900a2b67b3e666f04adf53ad452ec"}, - {file = "websockets-12.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46e71dbbd12850224243f5d2aeec90f0aaa0f2dde5aeeb8fc8df21e04d99eff9"}, - {file = "websockets-12.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b81f90dcc6c85a9b7f29873beb56c94c85d6f0dac2ea8b60d995bd18bf3e2aae"}, - {file = "websockets-12.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:a02413bc474feda2849c59ed2dfb2cddb4cd3d2f03a2fedec51d6e959d9b608b"}, - {file = "websockets-12.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bbe6013f9f791944ed31ca08b077e26249309639313fff132bfbf3ba105673b9"}, - {file = "websockets-12.0-cp39-cp39-win32.whl", hash = "sha256:cbe83a6bbdf207ff0541de01e11904827540aa069293696dd528a6640bd6a5f6"}, - {file = "websockets-12.0-cp39-cp39-win_amd64.whl", hash = "sha256:fc4e7fa5414512b481a2483775a8e8be7803a35b30ca805afa4998a84f9fd9e8"}, - {file = "websockets-12.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:248d8e2446e13c1d4326e0a6a4e9629cb13a11195051a73acf414812700badbd"}, - {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f44069528d45a933997a6fef143030d8ca8042f0dfaad753e2906398290e2870"}, - {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c4e37d36f0d19f0a4413d3e18c0d03d0c268ada2061868c1e6f5ab1a6d575077"}, - {file = "websockets-12.0-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d829f975fc2e527a3ef2f9c8f25e553eb7bc779c6665e8e1d52aa22800bb38b"}, - {file = "websockets-12.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:2c71bd45a777433dd9113847af751aae36e448bc6b8c361a566cb043eda6ec30"}, - {file = "websockets-12.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0bee75f400895aef54157b36ed6d3b308fcab62e5260703add87f44cee9c82a6"}, - {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:423fc1ed29f7512fceb727e2d2aecb952c46aa34895e9ed96071821309951123"}, - {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27a5e9964ef509016759f2ef3f2c1e13f403725a5e6a1775555994966a66e931"}, - {file = "websockets-12.0-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3181df4583c4d3994d31fb235dc681d2aaad744fbdbf94c4802485ececdecf2"}, - {file = "websockets-12.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:b067cb952ce8bf40115f6c19f478dc71c5e719b7fbaa511359795dfd9d1a6468"}, - {file = "websockets-12.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:00700340c6c7ab788f176d118775202aadea7602c5cc6be6ae127761c16d6b0b"}, - {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e469d01137942849cff40517c97a30a93ae79917752b34029f0ec72df6b46399"}, - {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffefa1374cd508d633646d51a8e9277763a9b78ae71324183693959cf94635a7"}, - {file = "websockets-12.0-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba0cab91b3956dfa9f512147860783a1829a8d905ee218a9837c18f683239611"}, - {file = "websockets-12.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:2cb388a5bfb56df4d9a406783b7f9dbefb888c09b71629351cc6b036e9259370"}, - {file = "websockets-12.0-py3-none-any.whl", hash = "sha256:dc284bbc8d7c78a6c69e0c7325ab46ee5e40bb4d50e494d8131a07ef47500e9e"}, - {file = "websockets-12.0.tar.gz", hash = "sha256:81df9cbcbb6c260de1e007e58c011bfebe2dafc8435107b0537f393dd38c8b1b"}, + {file = "websockets-13.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:1841c9082a3ba4a05ea824cf6d99570a6a2d8849ef0db16e9c826acb28089e8f"}, + {file = "websockets-13.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c5870b4a11b77e4caa3937142b650fbbc0914a3e07a0cf3131f35c0587489c1c"}, + {file = "websockets-13.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f1d3d1f2eb79fe7b0fb02e599b2bf76a7619c79300fc55f0b5e2d382881d4f7f"}, + {file = "websockets-13.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15c7d62ee071fa94a2fc52c2b472fed4af258d43f9030479d9c4a2de885fd543"}, + {file = "websockets-13.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6724b554b70d6195ba19650fef5759ef11346f946c07dbbe390e039bcaa7cc3d"}, + {file = "websockets-13.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:56a952fa2ae57a42ba7951e6b2605e08a24801a4931b5644dfc68939e041bc7f"}, + {file = "websockets-13.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:17118647c0ea14796364299e942c330d72acc4b248e07e639d34b75067b3cdd8"}, + {file = "websockets-13.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:64a11aae1de4c178fa653b07d90f2fb1a2ed31919a5ea2361a38760192e1858b"}, + {file = "websockets-13.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0617fd0b1d14309c7eab6ba5deae8a7179959861846cbc5cb528a7531c249448"}, + {file = "websockets-13.0.1-cp310-cp310-win32.whl", hash = "sha256:11f9976ecbc530248cf162e359a92f37b7b282de88d1d194f2167b5e7ad80ce3"}, + {file = "websockets-13.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:c3c493d0e5141ec055a7d6809a28ac2b88d5b878bb22df8c621ebe79a61123d0"}, + {file = "websockets-13.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:699ba9dd6a926f82a277063603fc8d586b89f4cb128efc353b749b641fcddda7"}, + {file = "websockets-13.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cf2fae6d85e5dc384bf846f8243ddaa9197f3a1a70044f59399af001fd1f51d4"}, + {file = "websockets-13.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:52aed6ef21a0f1a2a5e310fb5c42d7555e9c5855476bbd7173c3aa3d8a0302f2"}, + {file = "websockets-13.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8eb2b9a318542153674c6e377eb8cb9ca0fc011c04475110d3477862f15d29f0"}, + {file = "websockets-13.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5df891c86fe68b2c38da55b7aea7095beca105933c697d719f3f45f4220a5e0e"}, + {file = "websockets-13.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fac2d146ff30d9dd2fcf917e5d147db037a5c573f0446c564f16f1f94cf87462"}, + {file = "websockets-13.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b8ac5b46fd798bbbf2ac6620e0437c36a202b08e1f827832c4bf050da081b501"}, + {file = "websockets-13.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:46af561eba6f9b0848b2c9d2427086cabadf14e0abdd9fde9d72d447df268418"}, + {file = "websockets-13.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b5a06d7f60bc2fc378a333978470dfc4e1415ee52f5f0fce4f7853eb10c1e9df"}, + {file = "websockets-13.0.1-cp311-cp311-win32.whl", hash = "sha256:556e70e4f69be1082e6ef26dcb70efcd08d1850f5d6c5f4f2bcb4e397e68f01f"}, + {file = "websockets-13.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:67494e95d6565bf395476e9d040037ff69c8b3fa356a886b21d8422ad86ae075"}, + {file = "websockets-13.0.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:f9c9e258e3d5efe199ec23903f5da0eeaad58cf6fccb3547b74fd4750e5ac47a"}, + {file = "websockets-13.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6b41a1b3b561f1cba8321fb32987552a024a8f67f0d05f06fcf29f0090a1b956"}, + {file = "websockets-13.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f73e676a46b0fe9426612ce8caeca54c9073191a77c3e9d5c94697aef99296af"}, + {file = "websockets-13.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f613289f4a94142f914aafad6c6c87903de78eae1e140fa769a7385fb232fdf"}, + {file = "websockets-13.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f52504023b1480d458adf496dc1c9e9811df4ba4752f0bc1f89ae92f4f07d0c"}, + {file = "websockets-13.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:139add0f98206cb74109faf3611b7783ceafc928529c62b389917a037d4cfdf4"}, + {file = "websockets-13.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:47236c13be337ef36546004ce8c5580f4b1150d9538b27bf8a5ad8edf23ccfab"}, + {file = "websockets-13.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c44ca9ade59b2e376612df34e837013e2b273e6c92d7ed6636d0556b6f4db93d"}, + {file = "websockets-13.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9bbc525f4be3e51b89b2a700f5746c2a6907d2e2ef4513a8daafc98198b92237"}, + {file = "websockets-13.0.1-cp312-cp312-win32.whl", hash = "sha256:3624fd8664f2577cf8de996db3250662e259bfbc870dd8ebdcf5d7c6ac0b5185"}, + {file = "websockets-13.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0513c727fb8adffa6d9bf4a4463b2bade0186cbd8c3604ae5540fae18a90cb99"}, + {file = "websockets-13.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1ee4cc030a4bdab482a37462dbf3ffb7e09334d01dd37d1063be1136a0d825fa"}, + {file = "websockets-13.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dbb0b697cc0655719522406c059eae233abaa3243821cfdfab1215d02ac10231"}, + {file = "websockets-13.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:acbebec8cb3d4df6e2488fbf34702cbc37fc39ac7abf9449392cefb3305562e9"}, + {file = "websockets-13.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63848cdb6fcc0bf09d4a155464c46c64ffdb5807ede4fb251da2c2692559ce75"}, + {file = "websockets-13.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:872afa52a9f4c414d6955c365b6588bc4401272c629ff8321a55f44e3f62b553"}, + {file = "websockets-13.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e70fec7c54aad4d71eae8e8cab50525e899791fc389ec6f77b95312e4e9920"}, + {file = "websockets-13.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e82db3756ccb66266504f5a3de05ac6b32f287faacff72462612120074103329"}, + {file = "websockets-13.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4e85f46ce287f5c52438bb3703d86162263afccf034a5ef13dbe4318e98d86e7"}, + {file = "websockets-13.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f3fea72e4e6edb983908f0db373ae0732b275628901d909c382aae3b592589f2"}, + {file = "websockets-13.0.1-cp313-cp313-win32.whl", hash = "sha256:254ecf35572fca01a9f789a1d0f543898e222f7b69ecd7d5381d8d8047627bdb"}, + {file = "websockets-13.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:ca48914cdd9f2ccd94deab5bcb5ac98025a5ddce98881e5cce762854a5de330b"}, + {file = "websockets-13.0.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:b74593e9acf18ea5469c3edaa6b27fa7ecf97b30e9dabd5a94c4c940637ab96e"}, + {file = "websockets-13.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:132511bfd42e77d152c919147078460c88a795af16b50e42a0bd14f0ad71ddd2"}, + {file = "websockets-13.0.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:165bedf13556f985a2aa064309baa01462aa79bf6112fbd068ae38993a0e1f1b"}, + {file = "websockets-13.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e801ca2f448850685417d723ec70298feff3ce4ff687c6f20922c7474b4746ae"}, + {file = "websockets-13.0.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30d3a1f041360f029765d8704eae606781e673e8918e6b2c792e0775de51352f"}, + {file = "websockets-13.0.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67648f5e50231b5a7f6d83b32f9c525e319f0ddc841be0de64f24928cd75a603"}, + {file = "websockets-13.0.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:4f0426d51c8f0926a4879390f53c7f5a855e42d68df95fff6032c82c888b5f36"}, + {file = "websockets-13.0.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:ef48e4137e8799998a343706531e656fdec6797b80efd029117edacb74b0a10a"}, + {file = "websockets-13.0.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:249aab278810bee585cd0d4de2f08cfd67eed4fc75bde623be163798ed4db2eb"}, + {file = "websockets-13.0.1-cp38-cp38-win32.whl", hash = "sha256:06c0a667e466fcb56a0886d924b5f29a7f0886199102f0a0e1c60a02a3751cb4"}, + {file = "websockets-13.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1f3cf6d6ec1142412d4535adabc6bd72a63f5f148c43fe559f06298bc21953c9"}, + {file = "websockets-13.0.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:1fa082ea38d5de51dd409434edc27c0dcbd5fed2b09b9be982deb6f0508d25bc"}, + {file = "websockets-13.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4a365bcb7be554e6e1f9f3ed64016e67e2fa03d7b027a33e436aecf194febb63"}, + {file = "websockets-13.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:10a0dc7242215d794fb1918f69c6bb235f1f627aaf19e77f05336d147fce7c37"}, + {file = "websockets-13.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:59197afd478545b1f73367620407b0083303569c5f2d043afe5363676f2697c9"}, + {file = "websockets-13.0.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7d20516990d8ad557b5abeb48127b8b779b0b7e6771a265fa3e91767596d7d97"}, + {file = "websockets-13.0.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1a2e272d067030048e1fe41aa1ec8cfbbaabce733b3d634304fa2b19e5c897f"}, + {file = "websockets-13.0.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:ad327ac80ba7ee61da85383ca8822ff808ab5ada0e4a030d66703cc025b021c4"}, + {file = "websockets-13.0.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:518f90e6dd089d34eaade01101fd8a990921c3ba18ebbe9b0165b46ebff947f0"}, + {file = "websockets-13.0.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:68264802399aed6fe9652e89761031acc734fc4c653137a5911c2bfa995d6d6d"}, + {file = "websockets-13.0.1-cp39-cp39-win32.whl", hash = "sha256:a5dc0c42ded1557cc7c3f0240b24129aefbad88af4f09346164349391dea8e58"}, + {file = "websockets-13.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:b448a0690ef43db5ef31b3a0d9aea79043882b4632cfc3eaab20105edecf6097"}, + {file = "websockets-13.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:faef9ec6354fe4f9a2c0bbb52fb1ff852effc897e2a4501e25eb3a47cb0a4f89"}, + {file = "websockets-13.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:03d3f9ba172e0a53e37fa4e636b86cc60c3ab2cfee4935e66ed1d7acaa4625ad"}, + {file = "websockets-13.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d450f5a7a35662a9b91a64aefa852f0c0308ee256122f5218a42f1d13577d71e"}, + {file = "websockets-13.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3f55b36d17ac50aa8a171b771e15fbe1561217510c8768af3d546f56c7576cdc"}, + {file = "websockets-13.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14b9c006cac63772b31abbcd3e3abb6228233eec966bf062e89e7fa7ae0b7333"}, + {file = "websockets-13.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b79915a1179a91f6c5f04ece1e592e2e8a6bd245a0e45d12fd56b2b59e559a32"}, + {file = "websockets-13.0.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:f40de079779acbcdbb6ed4c65af9f018f8b77c5ec4e17a4b737c05c2db554491"}, + {file = "websockets-13.0.1-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:80e4ba642fc87fa532bac07e5ed7e19d56940b6af6a8c61d4429be48718a380f"}, + {file = "websockets-13.0.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2a02b0161c43cc9e0232711eff846569fad6ec836a7acab16b3cf97b2344c060"}, + {file = "websockets-13.0.1-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6aa74a45d4cdc028561a7d6ab3272c8b3018e23723100b12e58be9dfa5a24491"}, + {file = "websockets-13.0.1-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00fd961943b6c10ee6f0b1130753e50ac5dcd906130dcd77b0003c3ab797d026"}, + {file = "websockets-13.0.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:d93572720d781331fb10d3da9ca1067817d84ad1e7c31466e9f5e59965618096"}, + {file = "websockets-13.0.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:71e6e5a3a3728886caee9ab8752e8113670936a193284be9d6ad2176a137f376"}, + {file = "websockets-13.0.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:c4a6343e3b0714e80da0b0893543bf9a5b5fa71b846ae640e56e9abc6fbc4c83"}, + {file = "websockets-13.0.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a678532018e435396e37422a95e3ab87f75028ac79570ad11f5bf23cd2a7d8c"}, + {file = "websockets-13.0.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d6716c087e4aa0b9260c4e579bb82e068f84faddb9bfba9906cb87726fa2e870"}, + {file = "websockets-13.0.1-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e33505534f3f673270dd67f81e73550b11de5b538c56fe04435d63c02c3f26b5"}, + {file = "websockets-13.0.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:acab3539a027a85d568c2573291e864333ec9d912675107d6efceb7e2be5d980"}, + {file = "websockets-13.0.1-py3-none-any.whl", hash = "sha256:b80f0c51681c517604152eb6a572f5a9378f877763231fddb883ba2f968e8817"}, + {file = "websockets-13.0.1.tar.gz", hash = "sha256:4d6ece65099411cfd9a48d13701d7438d9c34f479046b34c50ff60bb8834e43e"}, ] [[package]] name = "werkzeug" -version = "3.0.3" +version = "3.0.4" description = "The comprehensive WSGI web application library." optional = false python-versions = ">=3.8" files = [ - {file = "werkzeug-3.0.3-py3-none-any.whl", hash = "sha256:fc9645dc43e03e4d630d23143a04a7f947a9a3b5727cd535fdfe155a17cc48c8"}, - {file = "werkzeug-3.0.3.tar.gz", hash = "sha256:097e5bfda9f0aba8da6b8545146def481d06aa7d3266e7448e2cccf67dd8bd18"}, + {file = "werkzeug-3.0.4-py3-none-any.whl", hash = "sha256:02c9eb92b7d6c06f31a782811505d2157837cea66aaede3e217c7c27c039476c"}, + {file = "werkzeug-3.0.4.tar.gz", hash = "sha256:34f2371506b250df4d4f84bfe7b0921e4762525762bbd936614909fe25cd7306"}, ] [package.dependencies] @@ -5555,13 +5933,13 @@ watchdog = ["watchdog (>=2.3)"] [[package]] name = "widgetsnbextension" -version = "4.0.10" +version = "4.0.13" description = "Jupyter interactive widgets for Jupyter Notebook" optional = false python-versions = ">=3.7" files = [ - {file = "widgetsnbextension-4.0.10-py3-none-any.whl", hash = "sha256:d37c3724ec32d8c48400a435ecfa7d3e259995201fbefa37163124a9fcb393cc"}, - {file = "widgetsnbextension-4.0.10.tar.gz", hash = "sha256:64196c5ff3b9a9183a8e699a4227fb0b7002f252c814098e66c4d1cd0644688f"}, + {file = "widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71"}, + {file = "widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6"}, ] [[package]] @@ -5662,13 +6040,13 @@ files = [ [[package]] name = "xarray" -version = "2024.5.0" +version = "2024.7.0" description = "N-D labeled arrays and datasets in Python" optional = false python-versions = ">=3.9" files = [ - {file = "xarray-2024.5.0-py3-none-any.whl", hash = "sha256:7ddedfe2294a0ab00f02d0fbdcb9c6300ec589f3cf436a9c7b7b577a12cd9bcf"}, - {file = "xarray-2024.5.0.tar.gz", hash = "sha256:e0eb1cb265f265126795f388ed9591f3c752f2aca491f6c0576711fd15b708f2"}, + {file = "xarray-2024.7.0-py3-none-any.whl", hash = "sha256:1b0fd51ec408474aa1f4a355d75c00cc1c02bd425d97b2c2e551fd21810e7f64"}, + {file = "xarray-2024.7.0.tar.gz", hash = "sha256:4cae512d121a8522d41e66d942fb06c526bc1fd32c2c181d5fe62fe65b671638"}, ] [package.dependencies] @@ -5739,13 +6117,13 @@ numpy = ">=1.14" [[package]] name = "zhinst-toolkit" -version = "0.6.3" +version = "0.6.4" description = "Zurich Instruments Toolkit High Level API" optional = false python-versions = ">=3.7" files = [ - {file = "zhinst-toolkit-0.6.3.tar.gz", hash = "sha256:26d1a55e570fa54557dbd81cdae8cfaf0295c19bb402d8cf3433ee9eac9a99ba"}, - {file = "zhinst_toolkit-0.6.3-py3-none-any.whl", hash = "sha256:9d97dcc790a8d58b11745db99face6adb081e07cf25b3f03876090f1697e6096"}, + {file = "zhinst_toolkit-0.6.4-py3-none-any.whl", hash = "sha256:d9a0c237d228636ec7438bf5f8c63312fd5e6dc4ac37df18a9ca3d9b450c42fa"}, + {file = "zhinst_toolkit-0.6.4.tar.gz", hash = "sha256:62d883cee6476cd3e00be8f8299cb01094f480aa91b3df754fc6005b452fa0f4"}, ] [package.dependencies] @@ -5774,28 +6152,34 @@ zhinst-timing-models = "*" [[package]] name = "zipp" -version = "3.18.2" +version = "3.20.2" description = "Backport of pathlib-compatible object wrapper for zip files" optional = false python-versions = ">=3.8" files = [ - {file = "zipp-3.18.2-py3-none-any.whl", hash = "sha256:dce197b859eb796242b0622af1b8beb0a722d52aa2f57133ead08edd5bf5374e"}, - {file = "zipp-3.18.2.tar.gz", hash = "sha256:6278d9ddbcfb1f1089a88fde84481528b07b0e10474e09dcfe53dad4069fa059"}, + {file = "zipp-3.20.2-py3-none-any.whl", hash = "sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350"}, + {file = "zipp-3.20.2.tar.gz", hash = "sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29"}, ] [package.extras] -docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -testing = ["big-O", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy", "pytest-ruff (>=0.2.1)"] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"] +cover = ["pytest-cov"] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +enabler = ["pytest-enabler (>=2.2)"] +test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"] +type = ["pytest-mypy"] [extras] -emulator = ["qutip", "scipy"] +bluefors = ["pyyaml"] +emulator = ["qutip"] los = ["pyvisa-py", "qcodes", "qcodes_contrib_drivers"] qblox = ["pyvisa-py", "qblox-instruments", "qcodes", "qcodes_contrib_drivers"] qm = ["qm-qua", "qualang-tools"] rfsoc = ["qibosoq"] +twpa = ["pyvisa-py", "qcodes", "qcodes_contrib_drivers"] zh = ["laboneq"] [metadata] lock-version = "2.0" -python-versions = ">=3.9,<3.12" -content-hash = "2e9555b32f971566f63c0505cb15a651f0dabd88ce630a265e96bc27cf250f6e" +python-versions = ">=3.9,<3.13" +content-hash = "485f57fe31738fb08e3eea772d14cea50505cd18b59720dacf6f6fc4a52af400" diff --git a/pyproject.toml b/pyproject.toml index ff0656b367..fb1cdcc942 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api" [tool.poetry] name = "qibolab" -version = "0.1.10" +version = "0.2.0" description = "Quantum hardware module and drivers for Qibo" authors = ["The Qibo team"] license = "Apache License 2.0" @@ -21,24 +21,22 @@ packages = [{ include = "qibolab", from = "src" }] include = ["*.out", "*.yml"] [tool.poetry.dependencies] -python = ">=3.9,<3.12" -qibo = ">=0.2.6" -networkx = "^3.0" +python = ">=3.9,<3.13" +qibo = "^0.2.8" numpy = "^1.26.4" -more-itertools = "^9.1.0" +scipy = "^1.13.0" +pydantic = "^2.6.4" qblox-instruments = { version = "0.12.0", optional = true } qcodes = { version = "^0.37.0", optional = true } qcodes_contrib_drivers = { version = "0.18.0", optional = true } pyvisa-py = { version = "0.5.3", optional = true } -qm-qua = { version = "==1.1.6", optional = true } -qualang-tools = { version = "^0.15.0", optional = true } +qm-qua = { version = "==1.1.6", python = "<3.12", optional = true } +qualang-tools = { version = "^0.15.0", python = "<3.12", optional = true } setuptools = { version = ">67.0.0", optional = true } laboneq = { version = "==2.25.0", optional = true } -qibosoq = { version = ">=0.1.2,<0.2", optional = true } -# TODO: unlock version -qutip = { version = "4.7.5", optional = true } -# TODO: remove this constraint, only needed for qutip 4.7.5 -scipy = { version = "<1.13.0", optional = true } +qibosoq = { version = ">=0.1.2,<0.2", python = "<3.12", optional = true } +qutip = { version = "^5.0.2", optional = true } +pyyaml = { version = "^6.0.2", optional = true } [tool.poetry.group.dev] optional = true @@ -63,10 +61,10 @@ sphinx-copybutton = "^0.5.1" qblox-instruments = "0.12.0" qcodes = "^0.37.0" qcodes_contrib_drivers = "0.18.0" -qibosoq = ">=0.1.2,<0.2" -qualang-tools = "^0.15.0" +qibosoq = { version = "^0.1.2", python = "<3.12" } +qualang-tools = { version = "^0.15.0", python = "<3.12" } laboneq = "==2.25.0" -qutip = "^4.7.5" +qutip = "^5.0.2" [tool.poetry.group.tests] optional = true @@ -89,7 +87,9 @@ qm = ["qm-qua", "qualang-tools"] zh = ["laboneq"] rfsoc = ["qibosoq"] los = ["qcodes", "qcodes_contrib_drivers", "pyvisa-py"] -emulator = ["qutip", "scipy"] +twpa = ["qcodes", "qcodes_contrib_drivers", "pyvisa-py"] +emulator = ["qutip"] +bluefors = ["pyyaml"] [tool.poe.tasks] @@ -103,6 +103,13 @@ test-docs = "make -C doc doctest" [tool.pylint.master] output-format = "colorized" disable = ["E1123", "E1120", "C0301"] +generated-members = [ + "qibolab._core.native.RxyFactory", + "pydantic.fields.FieldInfo", +] +# TODO: restore analysis when the support will cover the entier Python range, i.e. it +# will include py3.12 as well +ignored-modules = ["qm", "qualang_tools", "qibosoq"] [tool.pytest.ini_options] testpaths = ['tests/'] @@ -112,4 +119,12 @@ addopts = [ '--cov-report=xml', '--cov-report=html', '-m not qpu', + '-k not emulator', ] + +[tool.ruff.per-file-ignores] +"__init__.py" = ["F403"] + +[tool.pycln] +all = true +exclude = "__init__.py" diff --git a/src/qibolab/__init__.py b/src/qibolab/__init__.py index 9ab36e0338..3fe38ab632 100644 --- a/src/qibolab/__init__.py +++ b/src/qibolab/__init__.py @@ -1,16 +1,8 @@ -from .backends import MetaBackend, QibolabBackend, execute_qasm -from .execution_parameters import AcquisitionType, AveragingMode, ExecutionParameters -from .platform import Platform, create_platform -from .version import __version__ +from . import _core, _version, instruments +from ._core import * +from ._version import * -__all__ = [ - "AcquisitionType", - "AveragingMode", - "ExecutionParameters", - "MetaBackend", - "Platform", - "QibolabBackend", - "create_platform", - "execute_qasm", - "__version__", -] +__all__ = [] +__all__ += _core.__all__ +__all__ += _version.__all__ +__all__ += ["instruments"] diff --git a/src/qibolab/_core/__init__.py b/src/qibolab/_core/__init__.py new file mode 100644 index 0000000000..da4d93fd7b --- /dev/null +++ b/src/qibolab/_core/__init__.py @@ -0,0 +1,34 @@ +from . import ( + backends, + components, + dummy, + execution_parameters, + parameters, + platform, + pulses, + qubits, + sequence, + sweeper, +) +from .backends import * +from .components import * +from .dummy import * +from .execution_parameters import * +from .parameters import * +from .platform import * +from .pulses import * +from .qubits import * +from .sequence import * +from .sweeper import * + +__all__ = [] +__all__ += backends.__all__ +__all__ += components.__all__ +__all__ += dummy.__all__ +__all__ += execution_parameters.__all__ +__all__ += parameters.__all__ +__all__ += platform.__all__ +__all__ += pulses.__all__ +__all__ += qubits.__all__ +__all__ += sequence.__all__ +__all__ += sweeper.__all__ diff --git a/src/qibolab/backends.py b/src/qibolab/_core/backends.py similarity index 81% rename from src/qibolab/backends.py rename to src/qibolab/_core/backends.py index f17ce97f82..79fc32990e 100644 --- a/src/qibolab/backends.py +++ b/src/qibolab/_core/backends.py @@ -1,5 +1,3 @@ -from collections import deque - import numpy as np from qibo import __version__ as qibo_version from qibo.backends import NumpyBackend @@ -7,11 +5,13 @@ from qibo.models import Circuit from qibo.result import MeasurementOutcomes -from qibolab.compilers import Compiler -from qibolab.execution_parameters import ExecutionParameters -from qibolab.platform import Platform, create_platform -from qibolab.platform.load import available_platforms -from qibolab.version import __version__ as qibolab_version +from qibolab._version import __version__ as qibolab_version + +from .compilers import Compiler +from .platform import Platform, create_platform +from .platform.load import available_platforms + +__all__ = ["MetaBackend", "QibolabBackend"] def execute_qasm(circuit: str, platform, initial_state=None, nshots=1000): @@ -27,8 +27,6 @@ def execute_qasm(circuit: str, platform, initial_state=None, nshots=1000): Returns: ``MeasurementOutcomes`` object containing the results acquired from the execution. """ - from qibolab.backends import QibolabBackend - circuit = Circuit.from_qasm(circuit) return QibolabBackend(platform).execute_circuit( circuit, initial_state=initial_state, nshots=nshots @@ -60,17 +58,20 @@ def assign_measurements(self, measurement_map, readout): """Assigning measurement outcomes to :class:`qibo.states.MeasurementResult` for each gate. - This allows properly obtaining the measured shots from the :class:`qibolab.pulses.ReadoutPulse` object obtaned after pulse sequence execution. + This allows properly obtaining the measured shots from the :class:`qibolab.Readout` object obtaned after pulse sequence execution. Args: measurement_map (dict): Map from each measurement gate to the sequence of readout pulses implementing it. - readout (:class:`qibolab.pulses.ReadoutPulse`): Readout result object + readout (:class:`qibolab.Readout`): Readout result object containing the readout measurement shots. This is created in ``execute_circuit``. """ for gate, sequence in measurement_map.items(): - _samples = (readout[pulse.serial].samples for pulse in sequence.pulses) - samples = list(filter(lambda x: x is not None, _samples)) + samples = [ + s + for s in (readout[acq.id] for _, acq in sequence.acquisitions) + if s is not None + ] gate.result.backend = self gate.result.register_samples(np.array(samples).T) @@ -99,13 +100,10 @@ def execute_circuit(self, circuit, initial_state=None, nshots=1000): sequence, measurement_map = self.compiler.compile(circuit, self.platform) - if not self.platform.is_connected: - self.platform.connect() + self.platform.connect() - readout = self.platform.execute_pulse_sequence( - sequence, - ExecutionParameters(nshots=nshots), - ) + readout_ = self.platform.execute([sequence], nshots=nshots) + readout = {k: v for k, v in readout_.items()} self.platform.disconnect() @@ -144,26 +142,19 @@ def execute_circuits(self, circuits, initial_states=None, nshots=1000): *(self.compiler.compile(circuit, self.platform) for circuit in circuits) ) - if not self.platform.is_connected: - self.platform.connect() + self.platform.connect() - readout = self.platform.execute_pulse_sequences( - sequences, - ExecutionParameters(nshots=nshots), - ) + readout = self.platform.execute(sequences, nshots=nshots) self.platform.disconnect() results = [] - readout = {k: deque(v) for k, v in readout.items()} for circuit, measurement_map in zip(circuits, measurement_maps): results.append( MeasurementOutcomes(circuit.measurements, self, nshots=nshots) ) for gate, sequence in measurement_map.items(): - samples = [ - readout[pulse.serial].popleft().samples for pulse in sequence.pulses - ] + samples = [readout[acq.id] for _, acq in sequence.acquisitions] gate.result.backend = self gate.result.register_samples(np.array(samples).T) return results @@ -181,8 +172,6 @@ def load(platform: str): Returns: qibo.backends.abstract.Backend: The loaded backend. """ - from qibolab.backends import QibolabBackend - return QibolabBackend(platform=platform) def list_available(self) -> dict: diff --git a/src/qibolab/_core/compilers/__init__.py b/src/qibolab/_core/compilers/__init__.py new file mode 100644 index 0000000000..80aa9aee9b --- /dev/null +++ b/src/qibolab/_core/compilers/__init__.py @@ -0,0 +1,3 @@ +from .compiler import Compiler + +__all__ = ["Compiler"] diff --git a/src/qibolab/_core/compilers/compiler.py b/src/qibolab/_core/compilers/compiler.py new file mode 100644 index 0000000000..14cf7de6af --- /dev/null +++ b/src/qibolab/_core/compilers/compiler.py @@ -0,0 +1,195 @@ +from collections import defaultdict +from collections.abc import Callable +from dataclasses import dataclass, field + +from qibo import Circuit, gates + +from ..identifier import ChannelId, QubitId +from ..platform import Platform +from ..pulses import Delay +from ..sequence import PulseSequence +from .default import ( + align_rule, + cnot_rule, + cz_rule, + gpi2_rule, + gpi_rule, + identity_rule, + measurement_rule, + rz_rule, + z_rule, +) + +Rule = Callable[..., PulseSequence] +"""Compiler rule.""" + + +@dataclass +class Compiler: + """Compile native circuits into pulse sequences. + + It transforms a :class:`qibo.models.Circuit` to a :class:`qibolab.PulseSequence`. + + The transformation is done using a dictionary of rules which map each Qibo gate to a + pulse sequence and some virtual Z-phases. + """ + + rules: dict[type[gates.Gate], Rule] = field(default_factory=dict) + """Map from gates to compilation rules.""" + + @classmethod + def default(cls): + return cls( + { + gates.I: identity_rule, + gates.Z: z_rule, + gates.RZ: rz_rule, + gates.CZ: cz_rule, + gates.CNOT: cnot_rule, + gates.GPI2: gpi2_rule, + gates.GPI: gpi_rule, + gates.M: measurement_rule, + gates.Align: align_rule, + } + ) + + def register(self, gate_cls: type[gates.Gate]) -> Callable[[Rule], Rule]: + """Register a function as a rule in the compiler. + + Using this decorator is optional. Alternatively the user can set the rules directly + via ``__setitem__``. + + Args: + gate_cls: Qibo gate object that the rule will be assigned to. + """ + + def inner(func: Rule) -> Rule: + self.rules[gate_cls] = func + return func + + return inner + + def get_sequence(self, gate: gates.Gate, platform: Platform) -> PulseSequence: + """Get pulse sequence implementing the given gate. + + The sequence is obtained using the registered rules. + + Args: + gate (:class:`qibo.gates.Gate`): Qibo gate to convert to pulses. + platform (:class:`qibolab.Platform`): Qibolab platform to read the native gates from. + """ + # get local sequence for the current gate + rule = self.rules[type(gate)] + + natives = platform.natives + + if isinstance(gate, (gates.M)): + qubits = [natives.single_qubit[platform.qubit(q)[0]] for q in gate.qubits] + return rule(gate, qubits) + + if isinstance(gate, (gates.Align)): + qubits = [platform.qubit(q)[1] for q in gate.qubits] + return rule(gate, qubits) + + if isinstance(gate, (gates.Z, gates.RZ)): + qubit = platform.qubit(gate.target_qubits[0])[1] + return rule(gate, qubit) + + if len(gate.qubits) == 1: + qubit = platform.qubit(gate.target_qubits[0])[0] + return rule(gate, natives.single_qubit[qubit]) + + if len(gate.qubits) == 2: + pair = tuple(platform.qubit(q)[0] for q in gate.qubits) + assert len(pair) == 2 + return rule(gate, natives.two_qubit[pair]) + + raise NotImplementedError(f"{type(gate)} is not a native gate.") + + def _compile_gate( + self, + gate: gates.Gate, + platform: Platform, + channel_clock: defaultdict[ChannelId, float], + ) -> PulseSequence: + def qubit_clock(el: QubitId): + return max(channel_clock[ch] for ch in platform.qubits[el].channels) + + def coupler_clock(el: QubitId): + return max(channel_clock[ch] for ch in platform.couplers[el].channels) + + gate_seq = self.get_sequence(gate, platform) + # qubits receiving pulses + qubits = { + q + for q in [platform.qubit_channels.get(ch) for ch in gate_seq.channels] + if q is not None + } + # couplers receiving pulses + couplers = { + c + for c in [platform.coupler_channels.get(ch) for ch in gate_seq.channels] + if c is not None + } + + # add delays to pad all involved channels to begin at the same time + start = max( + [qubit_clock(q) for q in qubits] + [coupler_clock(c) for c in couplers], + default=0.0, + ) + initial = PulseSequence() + for ch in gate_seq.channels: + delay = start - channel_clock[ch] + if delay > 0: + initial.append((ch, Delay(duration=delay))) + channel_clock[ch] = start + gate_seq.channel_duration(ch) + + # pad all qubits to have at least one channel busy for the duration of the gate + # (drive arbitrarily chosen, as always present) + end = start + gate_seq.duration + final = PulseSequence() + for q in gate.qubits: + qubit = platform.qubit(q)[1] + # all actual qubits have a non-null drive channel, and couplers are not + # explicitedly listed in gates + assert qubit.drive is not None + delay = end - channel_clock[qubit.drive] + if delay > 0: + final.append((qubit.drive, Delay(duration=delay))) + channel_clock[qubit.drive] += delay + # couplers do not require individual padding, because they do are only + # involved in gates where both of the other qubits are involved + + return initial + gate_seq + final + + def compile( + self, circuit: Circuit, platform: Platform + ) -> tuple[PulseSequence, dict[gates.M, PulseSequence]]: + """Transform a circuit to pulse sequence. + + Args: + circuit: Qibo circuit that respects the platform's connectivity and native gates. + platform: Platform used to load the native pulse representations. + + Returns: + sequence: Pulse sequence that implements the circuit. + measurement_map: Map from each measurement gate to the sequence of readout pulse implementing it. + """ + sequence = PulseSequence() + + measurement_map = {} + channel_clock = defaultdict(float) + + # process circuit gates + for moment in circuit.queue.moments: + for gate in {x for x in moment if x is not None}: + gate_seq = self._compile_gate(gate, platform, channel_clock) + + # register readout sequences to ``measurement_map`` so that we can + # properly map acquisition results to measurement gates + if isinstance(gate, gates.M): + measurement_map[gate] = gate_seq + + sequence += gate_seq + + return sequence.trim(), measurement_map diff --git a/src/qibolab/_core/compilers/default.py b/src/qibolab/_core/compilers/default.py new file mode 100644 index 0000000000..308e723e90 --- /dev/null +++ b/src/qibolab/_core/compilers/default.py @@ -0,0 +1,75 @@ +"""Implementation of the default compiler. + +Uses I, Z, RZ, U3, CZ, and M as the set of native gates. +""" + +import math + +import numpy as np +from qibo.gates import Align, Gate + +from ..native import SingleQubitNatives, TwoQubitNatives +from ..pulses import Delay, VirtualZ +from ..qubits import Qubit +from ..sequence import PulseSequence + + +def z_rule(gate: Gate, qubit: Qubit) -> PulseSequence: + """Z gate applied virtually.""" + return PulseSequence([(qubit.drive, VirtualZ(phase=math.pi))]) + + +def rz_rule(gate: Gate, qubit: Qubit) -> PulseSequence: + """RZ gate applied virtually.""" + return PulseSequence([(qubit.drive, VirtualZ(phase=gate.parameters[0]))]) + + +def identity_rule(gate: Gate, natives: SingleQubitNatives) -> PulseSequence: + """Identity gate skipped.""" + return PulseSequence() + + +def gpi2_rule(gate: Gate, natives: SingleQubitNatives) -> PulseSequence: + """Rule for GPI2.""" + return natives.R(theta=np.pi / 2, phi=gate.parameters[0]) + + +def gpi_rule(gate: Gate, natives: SingleQubitNatives) -> PulseSequence: + """Rule for GPI.""" + # the following definition has a global phase difference compare to + # to the matrix representation. See + # https://github.com/qiboteam/qibolab/pull/804#pullrequestreview-1890205509 + # for more detail. + return natives.R(theta=np.pi, phi=gate.parameters[0]) + + +def cz_rule(gate: Gate, natives: TwoQubitNatives) -> PulseSequence: + """CZ applied as defined in the platform runcard. + + Applying the CZ gate may involve sending pulses on qubits that the + gate is not directly acting on. + """ + return natives.ensure("CZ").create_sequence() + + +def cnot_rule(gate: Gate, natives: TwoQubitNatives) -> PulseSequence: + """CNOT applied as defined in the platform runcard.""" + return natives.ensure("CNOT").create_sequence() + + +def measurement_rule(gate: Gate, natives: list[SingleQubitNatives]) -> PulseSequence: + """Measurement gate applied using the platform readout pulse.""" + seq = PulseSequence() + for qubit in natives: + seq.concatenate(qubit.ensure("MZ").create_sequence()) + return seq + + +def align_rule(gate: Align, qubits: list[Qubit]) -> PulseSequence: + """Measurement gate applied using the platform readout pulse.""" + delay = gate.parameters[0] + if delay == 0.0: + return PulseSequence() + return PulseSequence( + [(ch, Delay(duration=delay)) for qubit in qubits for ch in qubit.channels] + ) diff --git a/src/qibolab/_core/components/__init__.py b/src/qibolab/_core/components/__init__.py new file mode 100644 index 0000000000..1b9fab6884 --- /dev/null +++ b/src/qibolab/_core/components/__init__.py @@ -0,0 +1,23 @@ +"""Component (a.k.a. logical component) is a concept that is part of the +qibolab interface exposed to its users. + +Interacting with, and controlling a quantum computer means orchestrating +its control electronics/equipment. For a qibolab user quantum computer +is just a collection of control instruments. A component represents a +piece of equipment, functionality, or configuration that can be +individually addressed, configured, and referred to in any relevant +context. It can represent a single device, part of a bigger device, or a +collection of multiple devices. Qibolab defines a handful of specific +categories of components, and each platform definition shall have only +such components, independent of what specific electronics is used, how +it is used, etc. One basic requirement for all components is that they +have unique names, and in any relevant context can be referred to by +their name. +""" + +from . import channels +from .channels import * +from .configs import * + +__all__ = [] +__all__ += channels.__all__ diff --git a/src/qibolab/_core/components/channels.py b/src/qibolab/_core/components/channels.py new file mode 100644 index 0000000000..b2c8be26a9 --- /dev/null +++ b/src/qibolab/_core/components/channels.py @@ -0,0 +1,73 @@ +"""Define channels, representing the physical components handling signals. + +Channels are a specific type of component, that are responsible for +generating signals. A channel has a name, and it can refer to the names of +other components as needed. The default configuration of components should be +stored elsewhere (in Platform). By dissecting configuration in smaller pieces +and storing them externally (as opposed to storing the channel configuration +inside the channel itself) has multiple benefits, that. + +All revolve around the fact that channels may have shared components, e.g. + +- some instruments use one LO for more than one channel, +- for some use cases (like qutrit experiments, or CNOT gates), we need to define multiple channels that point to the same physical wire. + +If channels contain their configuration, it becomes cumbersome to make sure that user can easily see that some channels have shared +components, and changing configuration for one may affect the other as well. By storing component configurations externally we +make sure that there is only one copy of configuration for a component, plus users can clearly see when two different channels +share a component, because channels will refer to the same name for the component under discussion. +""" + +from typing import Optional + +from ..identifier import ChannelId +from ..serialize import Model + +__all__ = ["Channel", "DcChannel", "IqChannel", "AcquisitionChannel"] + + +class Channel(Model): + """Channel to communicate with the qubit.""" + + device: str = "" + """Name of the device.""" + path: str = "" + """Physical port addresss within the device.""" + + @property + def port(self) -> int: + return int(self.path) + + +class DcChannel(Channel): + """Channel that can be used to send DC pulses.""" + + +class IqChannel(Channel): + """Channel that can be used to send IQ pulses.""" + + mixer: Optional[str] + """Name of the IQ mixer component corresponding to this channel. + + None, if the channel does not have a mixer, or it does not need + configuration. + """ + lo: Optional[str] + """Name of the local oscillator component corresponding to this channel. + + None, if the channel does not have an LO, or it is not configurable. + """ + + +class AcquisitionChannel(Channel): + twpa_pump: Optional[str] + """Name of the TWPA pump component. + + None, if there is no TWPA, or it is not configurable. + """ + probe: Optional[ChannelId] = None + """Name of the corresponding measure/probe channel. + + FIXME: This is temporary solution to be able to relate acquisition channel to corresponding probe channel wherever needed in drivers, + until we make acquire channels completely independent, and users start putting explicit acquisition commands in pulse sequence. + """ diff --git a/src/qibolab/_core/components/configs.py b/src/qibolab/_core/components/configs.py new file mode 100644 index 0000000000..31caab3374 --- /dev/null +++ b/src/qibolab/_core/components/configs.py @@ -0,0 +1,125 @@ +"""Configuration for various components. + +These represent the minimal needed configuration that needs to be +exposed to users. Specific definitions of components can expose more, +and that can be used in any troubleshooting or debugging purposes by +users, but in general any user tool should try to depend only on the +configuration defined by these classes. +""" + +from typing import Annotated, Literal, Optional, Union + +from pydantic import Field + +from ..serialize import Model, NdArray + +__all__ = [ + "DcConfig", + "IqConfig", + "AcquisitionConfig", + "IqMixerConfig", + "OscillatorConfig", + "Config", + "ChannelConfig", +] + + +class Config(Model): + """Configuration values depot.""" + + +class DcConfig(Config): + """Configuration for a channel that can be used to send DC pulses (i.e. + just envelopes without modulation).""" + + kind: Literal["dc"] = "dc" + + offset: float + """DC offset/bias of the channel.""" + + +class OscillatorConfig(Config): + """Configuration for an oscillator.""" + + kind: Literal["oscillator"] = "oscillator" + + frequency: float + power: float + + +class IqMixerConfig(Config): + """Configuration for IQ mixer. + + Mixers usually have various imperfections, and one needs to + compensate for them. This class holds the compensation + configuration. + """ + + kind: Literal["iq-mixer"] = "iq-mixer" + + offset_i: float = 0.0 + """DC offset for the I component.""" + offset_q: float = 0.0 + """DC offset for the Q component.""" + scale_q: float = 1.0 + """The relative amplitude scale/factor of the q channel, to account for I-Q + amplitude imbalance.""" + phase_q: float = 0.0 + """The phase offset of the q channel, to account for I-Q phase + imbalance.""" + + +class IqConfig(Config): + """Configuration for an IQ channel.""" + + kind: Literal["iq"] = "iq" + + frequency: float + """The carrier frequency of the channel.""" + + +class AcquisitionConfig(Config): + """Configuration for acquisition channel. + + Currently, in qibolab, acquisition channels are FIXME: + """ + + kind: Literal["acquisition"] = "acquisition" + + delay: float + """Delay between readout pulse start and acquisition start.""" + smearing: float + """FIXME:""" + + # FIXME: this is temporary solution to deliver the information to drivers + # until we make acquisition channels first class citizens in the sequences + # so that each acquisition command carries the info with it. + threshold: Optional[float] = None + """Signal threshold for discriminating ground and excited states.""" + iq_angle: Optional[float] = None + """Signal angle in the IQ-plane for disciminating ground and excited + states.""" + kernel: Annotated[Optional[NdArray], Field(repr=False)] = None + """Integration weights to be used when post-processing the acquired + signal.""" + + def __eq__(self, other) -> bool: + """Explicit configuration equality. + + .. note:: + + the expliciti definition is required in order to solve the ambiguity about + the arrays equality + """ + return ( + (self.delay == other.delay) + and (self.smearing == other.smearing) + and (self.threshold == other.threshold) + and (self.iq_angle == other.iq_angle) + and (self.kernel == other.kernel).all() + ) + + +ChannelConfig = Union[ + DcConfig, IqMixerConfig, OscillatorConfig, IqConfig, AcquisitionConfig +] diff --git a/src/qibolab/dummy/__init__.py b/src/qibolab/_core/dummy/__init__.py similarity index 55% rename from src/qibolab/dummy/__init__.py rename to src/qibolab/_core/dummy/__init__.py index 137e075db3..1800fd3e28 100644 --- a/src/qibolab/dummy/__init__.py +++ b/src/qibolab/_core/dummy/__init__.py @@ -1 +1,3 @@ from .platform import create_dummy + +__all__ = ["create_dummy"] diff --git a/src/qibolab/_core/dummy/parameters.json b/src/qibolab/_core/dummy/parameters.json new file mode 100644 index 0000000000..f45eca98a1 --- /dev/null +++ b/src/qibolab/_core/dummy/parameters.json @@ -0,0 +1,878 @@ +{ + "settings": { + "nshots": 1024, + "relaxation_time": 0 + }, + "configs": { + "dummy/bounds": { + "kind": "bounds", + "waveforms": 0, + "readout": 0, + "instructions": 0 + }, + "0/drive": { + "kind": "iq", + "frequency": 4000000000.0 + }, + "1/drive": { + "kind": "iq", + "frequency": 4200000000.0 + }, + "2/drive": { + "kind": "iq", + "frequency": 4500000000.0 + }, + "3/drive": { + "kind": "iq", + "frequency": 4150000000.0 + }, + "4/drive": { + "kind": "iq", + "frequency": 4155663000.0 + }, + "0/drive12": { + "kind": "iq", + "frequency": 4700000000.0 + }, + "1/drive12": { + "kind": "iq", + "frequency": 4855663000.0 + }, + "2/drive12": { + "kind": "iq", + "frequency": 2700000000.0 + }, + "3/drive12": { + "kind": "iq", + "frequency": 5855663000.0 + }, + "4/drive12": { + "kind": "iq", + "frequency": 5855663000.0 + }, + "0/flux": { + "kind": "dc", + "offset": -0.1 + }, + "1/flux": { + "kind": "dc", + "offset": 0.0 + }, + "2/flux": { + "kind": "dc", + "offset": 0.1 + }, + "3/flux": { + "kind": "dc", + "offset": 0.2 + }, + "4/flux": { + "kind": "dc", + "offset": 0.15 + }, + "0/probe": { + "kind": "iq", + "frequency": 5200000000.0 + }, + "1/probe": { + "kind": "iq", + "frequency": 4900000000.0 + }, + "2/probe": { + "kind": "iq", + "frequency": 6100000000.0 + }, + "3/probe": { + "kind": "iq", + "frequency": 5800000000.0 + }, + "4/probe": { + "kind": "iq", + "frequency": 5500000000.0 + }, + "0/acquisition": { + "kind": "acquisition", + "delay": 0.0, + "smearing": 0.0, + "threshold": 0.0, + "iq_angle": 0.0, + "kernel": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDEwLCksIH0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAp5sDfS7uHlP2DIMKNvnKc/gCqN8KV/pT94FQCYYJC3PzSbwfi/894/APwg6C61rj8MSN3blizAP2ha9unQYsM/+BFjHTxcwT+gXaJazvbpPw==" + }, + "1/acquisition": { + "kind": "acquisition", + "delay": 0.0, + "smearing": 0.0, + "threshold": 0.0, + "iq_angle": 0.0, + "kernel": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDEwLCksIH0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAr4dT6V5tHrP1w+JhHImN8/sPePZeSUuj/4yTKrD5fRP/ysonZip98/6GJMAPV9xD/LTiJo4k7oP96aWXpxduU/6fUxETe/7z9GXEBNGebWPw==" + }, + "2/acquisition": { + "kind": "acquisition", + "delay": 0.0, + "smearing": 0.0, + "threshold": 0.0, + "iq_angle": 0.0, + "kernel": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDEwLCksIH0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIApUtcFdBpTsPzzwG8Xkbts/OAvkS0qo4z+OUcJpZ8HlP/jsO9cUwso/s6DVM7e/4T/NL4JYzUXvP9CibqEg98M/AENJ8QPkcD8wAOtI4pHNPw==" + }, + "3/acquisition": { + "kind": "acquisition", + "delay": 0.0, + "smearing": 0.0, + "threshold": 0.0, + "iq_angle": 0.0, + "kernel": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDEwLCksIH0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogk3D0+DqsP1ry/LSlMuM/ydJYpPk/6D8BJMdYs+zsP1CqhVqYz+o/1A3srA5z7j8CUqCE6lvqPwjNySZ1DuA/YHGvVmuFsz+XwaQKz/bqPw==" + }, + "4/acquisition": { + "kind": "acquisition", + "delay": 0.0, + "smearing": 0.0, + "threshold": 0.0, + "iq_angle": 0.0, + "kernel": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDEwLCksIH0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIArIY+/UbVjMP+yH0UH5xOU/YDXeTaxK4j/Au9mGjGjBPx1R4v/zy+Q/+OxfZT0Vzj/5ng1s2GzkP64nr91FXOk/9/ggMXmG4D+6NjR7dMHtPw==" + }, + "coupler_0/flux": { + "kind": "dc", + "offset": 0.0 + }, + "coupler_1/flux": { + "kind": "dc", + "offset": 0.0 + }, + "coupler_3/flux": { + "kind": "dc", + "offset": 0.0 + }, + "coupler_4/flux": { + "kind": "dc", + "offset": 0.0 + }, + "twpa_pump": { + "kind": "oscillator", + "frequency": 1000000000.0, + "power": 10.0 + } + }, + "native_gates": { + "single_qubit": { + "0": { + "RX": [ + [ + "0/drive", + { + "duration": 40.0, + "amplitude": 0.1, + "envelope": { + "kind": "gaussian", + "rel_sigma": 5.0 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "RX12": [ + [ + "0/drive12", + { + "duration": 40.0, + "amplitude": 0.005, + "envelope": { + "kind": "gaussian", + "rel_sigma": 5.0 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "MZ": [ + [ + "0/acquisition", + { + "kind": "readout", + "acquisition": { + "kind": "acquisition", + "duration": 2000.0 + }, + "probe": { + "duration": 2000.0, + "amplitude": 0.1, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + } + ] + ], + "CP": null + }, + "1": { + "RX": [ + [ + "1/drive", + { + "duration": 40.0, + "amplitude": 0.3, + "envelope": { + "kind": "drag", + "rel_sigma": 5.0, + "beta": 0.02 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "RX12": [ + [ + "1/drive12", + { + "duration": 40.0, + "amplitude": 0.0484, + "envelope": { + "kind": "drag", + "rel_sigma": 5.0, + "beta": 0.02 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "MZ": [ + [ + "1/acquisition", + { + "kind": "readout", + "acquisition": { + "kind": "acquisition", + "duration": 2000.0 + }, + "probe": { + "duration": 2000.0, + "amplitude": 0.1, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + } + ] + ], + "CP": null + }, + "2": { + "RX": [ + [ + "2/drive", + { + "duration": 40.0, + "amplitude": 0.3, + "envelope": { + "kind": "drag", + "rel_sigma": 5.0, + "beta": 0.02 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "RX12": [ + [ + "2/drive12", + { + "duration": 40.0, + "amplitude": 0.005, + "envelope": { + "kind": "gaussian", + "rel_sigma": 5.0 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "MZ": [ + [ + "2/acquisition", + { + "kind": "readout", + "acquisition": { + "kind": "acquisition", + "duration": 2000.0 + }, + "probe": { + "duration": 2000.0, + "amplitude": 0.1, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + } + ] + ], + "CP": null + }, + "3": { + "RX": [ + [ + "3/drive", + { + "duration": 40.0, + "amplitude": 0.3, + "envelope": { + "kind": "drag", + "rel_sigma": 5.0, + "beta": 0.02 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "RX12": [ + [ + "3/drive12", + { + "duration": 40.0, + "amplitude": 0.0484, + "envelope": { + "kind": "drag", + "rel_sigma": 5.0, + "beta": 0.02 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "MZ": [ + [ + "3/acquisition", + { + "kind": "readout", + "acquisition": { + "kind": "acquisition", + "duration": 2000.0 + }, + "probe": { + "duration": 2000.0, + "amplitude": 0.1, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + } + ] + ], + "CP": null + }, + "4": { + "RX": [ + [ + "4/drive", + { + "duration": 40.0, + "amplitude": 0.3, + "envelope": { + "kind": "drag", + "rel_sigma": 5.0, + "beta": 0.02 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "RX12": [ + [ + "4/drive12", + { + "duration": 40.0, + "amplitude": 0.0484, + "envelope": { + "kind": "drag", + "rel_sigma": 5.0, + "beta": 0.02 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "MZ": [ + [ + "4/acquisition", + { + "kind": "readout", + "acquisition": { + "kind": "acquisition", + "duration": 2000.0 + }, + "probe": { + "duration": 2000.0, + "amplitude": 0.1, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + } + ] + ], + "CP": null + } + }, + "coupler": { + "0": { + "RX": null, + "RX12": null, + "MZ": null, + "CP": [ + [ + "coupler_0/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ] + }, + "1": { + "RX": null, + "RX12": null, + "MZ": null, + "CP": [ + [ + "coupler_1/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ] + }, + "3": { + "RX": null, + "RX12": null, + "MZ": null, + "CP": [ + [ + "coupler_3/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ] + }, + "4": { + "RX": null, + "RX12": null, + "MZ": null, + "CP": [ + [ + "coupler_4/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ] + } + }, + "two_qubit": { + "0-2": { + "CZ": [ + [ + "2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ], + [ + "0/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "2/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "coupler_0/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "CNOT": null, + "iSWAP": [ + [ + "2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ], + [ + "0/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "2/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "coupler_0/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ] + }, + "1-2": { + "CZ": [ + [ + "2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ], + [ + "1/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "2/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "coupler_1/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "CNOT": null, + "iSWAP": [ + [ + "2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ], + [ + "1/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "2/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "coupler_1/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ] + }, + "2-3": { + "CZ": [ + [ + "2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ], + [ + "2/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "3/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ] + ], + "CNOT": [ + [ + "2/drive", + { + "duration": 40.0, + "amplitude": 0.3, + "envelope": { + "kind": "drag", + "rel_sigma": 5.0, + "beta": 0.02 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "iSWAP": [ + [ + "2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ], + [ + "2/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "3/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ] + ] + }, + "2-4": { + "CZ": [ + [ + "2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ], + [ + "4/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "coupler_4/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ], + "CNOT": null, + "iSWAP": [ + [ + "2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ], + [ + "2/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "4/drive", + { + "phase": 0.0, + "kind": "virtualz" + } + ], + [ + "coupler_4/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + }, + "relative_phase": 0.0, + "kind": "pulse" + } + ] + ] + } + } + } +} diff --git a/src/qibolab/_core/dummy/platform.py b/src/qibolab/_core/dummy/platform.py new file mode 100644 index 0000000000..e4c40330a8 --- /dev/null +++ b/src/qibolab/_core/dummy/platform.py @@ -0,0 +1,43 @@ +import pathlib + +from qibolab._core.components import AcquisitionChannel, DcChannel, IqChannel +from qibolab._core.instruments.dummy import DummyInstrument, DummyLocalOscillator +from qibolab._core.platform import Platform +from qibolab._core.qubits import Qubit + +FOLDER = pathlib.Path(__file__).parent + + +def create_dummy() -> Platform: + """Create a dummy platform using the dummy instrument.""" + qubits = {} + channels = {} + # attach the channels + pump_name = "twpa_pump" + for q in range(5): + drive12 = f"{q}/drive12" + qubits[q] = qubit = Qubit.default(q, drive_qudits={(1, 2): drive12}) + channels |= { + qubit.probe: IqChannel(mixer=None, lo=None), + qubit.acquisition: AcquisitionChannel( + twpa_pump=pump_name, probe=qubit.probe + ), + qubit.drive: IqChannel(mixer=None, lo=None), + drive12: IqChannel(mixer=None, lo=None), + qubit.flux: DcChannel(), + } + + couplers = {} + for c in (0, 1, 3, 4): + couplers[c] = coupler = Qubit(flux=f"coupler_{c}/flux") + channels |= {coupler.flux: DcChannel()} + + # register the instruments + instruments = { + "dummy": DummyInstrument(address="0.0.0.0", channels=channels), + pump_name: DummyLocalOscillator(address="0.0.0.0"), + } + + return Platform.load( + path=FOLDER, instruments=instruments, qubits=qubits, couplers=couplers + ) diff --git a/src/qibolab/_core/execution_parameters.py b/src/qibolab/_core/execution_parameters.py new file mode 100644 index 0000000000..3cfcf1931d --- /dev/null +++ b/src/qibolab/_core/execution_parameters.py @@ -0,0 +1,92 @@ +from enum import Enum, auto +from typing import Any, Optional + +from .serialize import Model +from .sweeper import ParallelSweepers + +__all__ = ["AcquisitionType", "AveragingMode"] + + +class AcquisitionType(Enum): + """Data acquisition from hardware.""" + + DISCRIMINATION = auto() + """Demodulate, integrate the waveform and discriminate among states based + on the voltages.""" + INTEGRATION = auto() + """Demodulate and integrate the waveform.""" + RAW = auto() + """Acquire the waveform as it is.""" + SPECTROSCOPY = auto() + """Zurich Integration mode for RO frequency sweeps.""" + + +class AveragingMode(Enum): + """Data averaging modes from hardware.""" + + CYCLIC = auto() + """Better averaging for short timescale noise.""" + SINGLESHOT = auto() + """SINGLESHOT: No averaging.""" + SEQUENTIAL = auto() + """SEQUENTIAL: Worse averaging for noise[Avoid]""" + + @property + def average(self) -> bool: + """Whether an average is performed or not.""" + return self is not AveragingMode.SINGLESHOT + + +ConfigUpdate = dict[str, dict[str, Any]] +"""Update for component configs. + +Maps component name to corresponding update, which in turn is a map from +config property name that needs an update to its new value. +""" + + +class ExecutionParameters(Model): + """Data structure to deal with execution parameters.""" + + nshots: Optional[int] = None + """Number of shots to sample from the experiment. + + Default is the runcard value. + """ + relaxation_time: Optional[int] = None + """Time to wait for the qubit to relax to its ground Sample between shots + in ns. + + Default is the runcard value. + """ + fast_reset: bool = False + """Enable or disable fast reset.""" + acquisition_type: AcquisitionType = AcquisitionType.DISCRIMINATION + """Data acquisition type.""" + averaging_mode: AveragingMode = AveragingMode.SINGLESHOT + """Data averaging mode.""" + updates: list[ConfigUpdate] = [] + """List of updates for component configs. + + Later entries in the list take precedence over earlier ones (if they + happen to update the same thing). These updates will be applied on + top of platform defaults. + """ + + def results_shape( + self, sweepers: list[ParallelSweepers], samples: Optional[int] = None + ) -> tuple[int, ...]: + """Compute the expected shape for collected data.""" + + shots = ( + (self.nshots,) if self.averaging_mode is AveragingMode.SINGLESHOT else () + ) + sweeps = tuple( + min(len(sweep.values) for sweep in parsweeps) for parsweeps in sweepers + ) + inner = { + AcquisitionType.DISCRIMINATION: (), + AcquisitionType.INTEGRATION: (2,), + AcquisitionType.RAW: (samples, 2), + }[self.acquisition_type] + return shots + sweeps + inner diff --git a/src/qibolab/_core/identifier.py b/src/qibolab/_core/identifier.py new file mode 100644 index 0000000000..98abec142f --- /dev/null +++ b/src/qibolab/_core/identifier.py @@ -0,0 +1,49 @@ +from typing import Annotated, Union + +import numpy as np +import numpy.typing as npt +from pydantic import BeforeValidator, Field, PlainSerializer + +QubitId = Annotated[Union[int, str], Field(union_mode="left_to_right")] +"""Qubit name.""" + +QubitPairId = Annotated[ + tuple[QubitId, QubitId], + BeforeValidator(lambda p: tuple(p.split("-")) if isinstance(p, str) else p), + PlainSerializer(lambda p: f"{p[0]}-{p[1]}"), +] +"""Type for holding ``QubitPair``s in the ``platform.pairs`` dictionary.""" + + +ChannelId = str +"""Unique identifier for a channel.""" + + +StateId = int +"""State identifier.""" + + +def _split(pair: Union[str, tuple]) -> tuple[str, str]: + if isinstance(pair, str): + a, b = pair.split("-") + return a, b + return pair + + +def _join(pair: tuple[str, str]) -> str: + return f"{pair[0]}-{pair[1]}" + + +TransitionId = Annotated[ + tuple[StateId, StateId], BeforeValidator(_split), PlainSerializer(_join) +] +"""Identifier for a state transition.""" + +QubitPairId = Annotated[ + tuple[QubitId, QubitId], BeforeValidator(_split), PlainSerializer(_join) +] +"""Two-qubit active interaction identifier.""" + + +Result = npt.NDArray[np.float64] +"""An array of results returned by instruments.""" diff --git a/src/qibolab/instruments/qblox/__init__.py b/src/qibolab/_core/instruments/__init__.py similarity index 100% rename from src/qibolab/instruments/qblox/__init__.py rename to src/qibolab/_core/instruments/__init__.py diff --git a/src/qibolab/_core/instruments/abstract.py b/src/qibolab/_core/instruments/abstract.py new file mode 100644 index 0000000000..283836a02f --- /dev/null +++ b/src/qibolab/_core/instruments/abstract.py @@ -0,0 +1,89 @@ +from abc import ABC, abstractmethod +from typing import Optional + +from pydantic import ConfigDict, Field + +from ..components import Channel, Config +from ..execution_parameters import ExecutionParameters +from ..identifier import ChannelId, Result +from ..sequence import PulseSequence +from ..serialize import Model +from ..sweeper import ParallelSweepers + +InstrumentId = str + + +class InstrumentSettings(Model): + """Container of settings that are dumped in the platform runcard json.""" + + model_config = ConfigDict(frozen=False) + + +class Instrument(Model, ABC): + """Parent class for all the instruments connected via TCPIP. + + Args: + address (str): Instrument network address. + """ + + model_config = ConfigDict(arbitrary_types_allowed=True, frozen=False, extra="allow") + + address: str + settings: Optional[InstrumentSettings] = None + + @property + def signature(self): + return f"{type(self).__name__}@{self.address}" + + @abstractmethod + def connect(self): + """Establish connection to the physical instrument.""" + + @abstractmethod + def disconnect(self): + """Close connection to the physical instrument.""" + + def setup(self, *args, **kwargs): + """Set instrument settings. + + Used primarily by non-controller instruments, to upload settings + (like LO frequency and power) to the instrument after + connecting. + """ + + +class Controller(Instrument): + """Instrument that can play pulses (using waveform generator).""" + + bounds: str + """Estimated limitations of the device memory.""" + channels: dict[ChannelId, Channel] = Field(default_factory=dict) + + @property + @abstractmethod + def sampling_rate(self) -> int: + """Sampling rate of control electronics in giga samples per second + (GSps).""" + + @abstractmethod + def play( + self, + configs: dict[str, Config], + sequences: list[PulseSequence], + options: ExecutionParameters, + sweepers: list[ParallelSweepers], + ) -> dict[int, Result]: + """Play a pulse sequence and retrieve feedback. + + If :class:`qibolab.Sweeper` objects are passed as arguments, they are + executed in real-time. If not possible, an error is raised. + + Returns a mapping with the id of the probe pulses used to acquired data. + """ + + +class InstrumentException(Exception): + def __init__(self, instrument: Instrument, message: str): + header = f"InstrumentException with {instrument.signature}" + full_msg = header + ": " + message + super().__init__(full_msg) diff --git a/src/qibolab/_core/instruments/bluefors.py b/src/qibolab/_core/instruments/bluefors.py new file mode 100644 index 0000000000..98829983c1 --- /dev/null +++ b/src/qibolab/_core/instruments/bluefors.py @@ -0,0 +1,67 @@ +import socket + +import yaml +from pydantic import Field +from qibo.config import log + +from qibolab._core.instruments.abstract import Instrument + +__all__ = ["TemperatureController"] + + +class TemperatureController(Instrument): + """Bluefors temperature controller. + + Example usage:: + + if __name__ == "__main__": + tc = TemperatureController("XLD1000_Temperature_Controller", "192.168.0.114", 8888) + tc.connect() + temperature_values = tc.read_data() + for temperature_value in temperature_values: + print(temperature_value) + """ + + address: str + """IP address of the board sending cryo temperature data.""" + port: int = 8888 + """Port of the board sending cryo temperature data.""" + client_socket: socket.socket = Field( + default_factory=lambda: socket.socket(socket.AF_INET, socket.SOCK_STREAM) + ) + _is_connected: bool = False + + def connect(self): + """Connect to the socket.""" + if self._is_connected: + return + log.info(f"Bluefors connection. IP: {self.address} Port: {self.port}") + self.client_socket.connect((self.address, self.port)) + self._is_connected = True + log.info("Bluefors Temperature Controller Connected") + + def disconnect(self): + """Disconnect from the socket.""" + if self._is_connected: + self.client_socket.close() + self._is_connected = False + + def get_data(self) -> dict[str, dict[str, float]]: + """Connect to the socket and get temperature data. + + The typical message looks like this:: + + flange_name: {'temperature':12.345678, 'timestamp':1234567890.123456} + + ``timestamp`` can be converted to datetime using ``datetime.fromtimestamp``. + + Returns: + message (dict[str, dict[str, float]]): socket message in this format: + {"flange_name": {'temperature': , 'timestamp':}} + """ + return yaml.safe_load(self.client_socket.recv(1024).decode()) + + def read_data(self): + """Continously read data from the temperature controller.""" + while True: + yield self.get_data() diff --git a/src/qibolab/_core/instruments/dummy.py b/src/qibolab/_core/instruments/dummy.py new file mode 100644 index 0000000000..e3d9a6a084 --- /dev/null +++ b/src/qibolab/_core/instruments/dummy.py @@ -0,0 +1,109 @@ +import numpy as np +from pydantic import Field +from qibo.config import log + +from qibolab._core.components import Channel, Config +from qibolab._core.execution_parameters import ( + AcquisitionType, + AveragingMode, + ExecutionParameters, +) +from qibolab._core.identifier import ChannelId +from qibolab._core.pulses import Acquisition +from qibolab._core.sequence import PulseSequence +from qibolab._core.sweeper import ParallelSweepers +from qibolab._core.unrolling import Bounds + +from .abstract import Controller +from .oscillator import LocalOscillator + +SAMPLING_RATE = 1 +BOUNDS = Bounds(waveforms=1, readout=1, instructions=1) + + +__all__ = ["DummyLocalOscillator", "DummyInstrument"] + + +class DummyDevice: + """Dummy device that does nothing but follows the QCoDeS interface. + + Used by :class:`qibolab.instruments.dummy.DummyLocalOscillator`. + """ + + def set(self, name, value): + """Set device property.""" + + def get(self, name): + """Get device property.""" + return 0 + + def on(self): + """Turn device on.""" + + def off(self): + """Turn device on.""" + + def close(self): + """Close connection with device.""" + + +class DummyLocalOscillator(LocalOscillator): + """Dummy local oscillator instrument. + + Useful for testing the interface defined in :class:`qibolab.instruments.oscillator.LocalOscillator`. + """ + + def create(self): + return DummyDevice() + + +class DummyInstrument(Controller): + """Dummy instrument that returns random voltage values. + + Useful for testing code without requiring access to hardware. + + Args: + name (str): name of the instrument. + address (int): address to connect to the instrument. + Not used since the instrument is dummy, it only + exists to keep the same interface with other + instruments. + """ + + address: str + bounds: str = "dummy/bounds" + channels: dict[ChannelId, Channel] = Field(default_factory=dict) + + @property + def sampling_rate(self) -> int: + return SAMPLING_RATE + + def connect(self): + log.info(f"Connecting to dummy instrument.") + + def disconnect(self): + log.info(f"Disconnecting dummy instrument.") + + def values(self, options: ExecutionParameters, shape: tuple[int, ...]): + if options.acquisition_type is AcquisitionType.DISCRIMINATION: + if options.averaging_mode is AveragingMode.SINGLESHOT: + return np.random.randint(2, size=shape) + return np.random.rand(*shape) + return np.random.rand(*shape) * 100 + + def play( + self, + configs: dict[str, Config], + sequences: list[PulseSequence], + options: ExecutionParameters, + sweepers: list[ParallelSweepers], + ): + def values(acq: Acquisition): + samples = int(acq.duration * self.sampling_rate) + return np.array( + self.values(options, options.results_shape(sweepers, samples)) + ) + + return { + acq.id: values(acq) for seq in sequences for (_, acq) in seq.acquisitions + } diff --git a/src/qibolab/instruments/erasynth.py b/src/qibolab/_core/instruments/erasynth.py similarity index 89% rename from src/qibolab/instruments/erasynth.py rename to src/qibolab/_core/instruments/erasynth.py index 9f4b136527..b9d73270ed 100644 --- a/src/qibolab/instruments/erasynth.py +++ b/src/qibolab/_core/instruments/erasynth.py @@ -4,7 +4,9 @@ from qcodes_contrib_drivers.drivers.ERAInstruments import ERASynthPlusPlus from qibo.config import log -from qibolab.instruments.oscillator import LocalOscillator +from .oscillator import LocalOscillator, LocalOscillatorSettings + +__all__ = ["ERASynth"] RECONNECTION_ATTEMPTS = 10 """Number of times to attempt sending requests to the web server in case of @@ -117,7 +119,7 @@ def close(self): self.off() -class ERA(LocalOscillator): +class ERASynth(LocalOscillator): """Driver to control the ERAsynth++ local oscillator. This driver is using: @@ -127,12 +129,16 @@ class ERA(LocalOscillator): if we are connected via ethernet. """ - def __init__(self, name, address, ethernet=True, ref_osc_source=None): - super().__init__(name, address, ref_osc_source) + def __init__(self, address, ethernet=True, ref_osc_source=None): + super().__init__( + address=address, + settings=LocalOscillatorSettings(ref_osc_source=ref_osc_source), + ) self.ethernet = ethernet def create(self): + name = f"{type(self).__name__}{id(self)}" if self.ethernet: - return ERASynthEthernet(self.name, self.address) + return ERASynthEthernet(name, self.address) else: - return ERASynthPlusPlus(f"{self.name}", f"TCPIP::{self.address}::INSTR") + return ERASynthPlusPlus(name, f"TCPIP::{self.address}::INSTR") diff --git a/src/qibolab/instruments/oscillator.py b/src/qibolab/_core/instruments/oscillator.py similarity index 60% rename from src/qibolab/instruments/oscillator.py rename to src/qibolab/_core/instruments/oscillator.py index 3fb7b4123a..917e1025ce 100644 --- a/src/qibolab/instruments/oscillator.py +++ b/src/qibolab/_core/instruments/oscillator.py @@ -1,14 +1,37 @@ from abc import abstractmethod -from dataclasses import dataclass, fields -from typing import Optional +from typing import Any, Optional, Protocol, runtime_checkable -from qibolab.instruments.abstract import Instrument, InstrumentSettings +from pydantic import Field + +from .abstract import Instrument, InstrumentSettings RECONNECTION_ATTEMPTS = 3 """Number of times to attempt connecting to instrument in case of failure.""" -@dataclass +@runtime_checkable +class Device(Protocol): + """Dummy device that does nothing but follows the QCoDeS interface. + + Used by :class:`qibolab.instruments.dummy.DummyLocalOscillator`. + """ + + def set(self, name: str, value: Any): + """Set device property.""" + + def get(self, name: str) -> Any: + """Get device property.""" + + def on(self): + """Turn device on.""" + + def off(self): + """Turn device on.""" + + def close(self): + """Close connection with device.""" + + class LocalOscillatorSettings(InstrumentSettings): """Local oscillator parameters that are saved in the platform runcard.""" @@ -16,17 +39,6 @@ class LocalOscillatorSettings(InstrumentSettings): frequency: Optional[float] = None ref_osc_source: Optional[str] = None - def dump(self): - """Dictionary containing local oscillator settings. - - The reference clock is excluded as it is not a calibrated - parameter. None values are also excluded. - """ - data = super().dump() - return { - k: v for k, v in data.items() if k != "ref_osc_source" and v is not None - } - def _setter(instrument, parameter, value): """Set value of a setting. @@ -39,15 +51,16 @@ def _setter(instrument, parameter, value): """ if getattr(instrument, parameter) != value: setattr(instrument.settings, parameter, value) - if instrument.is_connected: + if instrument.device is not None: instrument.device.set(parameter, value) def _property(parameter): - """Creates an instrument property.""" - getter = lambda self: getattr(self.settings, parameter) - setter = lambda self, value: _setter(self, parameter, value) - return property(getter, setter) + """Create an instrument property.""" + return property( + lambda self: getattr(self.settings, parameter), + lambda self, value: _setter(self, parameter, value), + ) class LocalOscillator(Instrument): @@ -58,42 +71,35 @@ class LocalOscillator(Instrument): qubits and resonators. They cannot be used to play or sweep pulses. """ + device: Optional[Device] = None + settings: Optional[InstrumentSettings] = Field( + default_factory=lambda: LocalOscillatorSettings() + ) + frequency = _property("frequency") power = _property("power") ref_osc_source = _property("ref_osc_source") - def __init__(self, name, address, ref_osc_source=None): - super().__init__(name, address) - self.device = None - self.settings = LocalOscillatorSettings(ref_osc_source=ref_osc_source) - @abstractmethod - def create(self): + def create(self) -> Device: """Create instance of physical device.""" def connect(self): - """Connects to the instrument using the IP address set in the - runcard.""" - if not self.is_connected: + """Connect to the instrument.""" + if self.device is None: self.device = self.create() - self.is_connected = True - if not self.is_connected: - raise RuntimeError(f"Unable to connect to {self.name}.") - else: - raise RuntimeError( - f"There is an open connection to the instrument {self.name}." - ) - for fld in fields(self.settings): - self.sync(fld.name) + assert self.settings is not None + for fld in self.settings.model_fields: + self.sync(fld) self.device.on() def disconnect(self): - if self.is_connected: + if self.device is not None: self.device.off() self.device.close() - self.is_connected = False + self.device = None def sync(self, parameter): """Sync parameter value between our cache and the instrument. @@ -105,6 +111,7 @@ def sync(self, parameter): parameter (str): Parameter name to be synced. """ value = getattr(self, parameter) + assert self.device is not None if value is None: setattr(self.settings, parameter, self.device.get(parameter)) else: @@ -119,11 +126,8 @@ def setup(self, **kwargs): Args: **kwargs: Instrument settings loaded from the runcard. """ - type_ = self.__class__ - _fields = {fld.name for fld in fields(self.settings)} + assert self.settings is not None for name, value in kwargs.items(): - if name not in _fields: - raise KeyError( - f"Cannot set {name} to instrument {self.name} of type {type_.__name__}" - ) + if name not in self.settings.model_fields: + raise KeyError(f"Cannot set {name} to instrument {type(self)}") setattr(self, name, value) diff --git a/src/qibolab/_core/instruments/qm/__init__.py b/src/qibolab/_core/instruments/qm/__init__.py new file mode 100644 index 0000000000..c479f96259 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/__init__.py @@ -0,0 +1,7 @@ +from . import components, controller +from .components import * +from .controller import * + +__all__ = [] +__all__ += components.__all__ +__all__ += controller.__all__ diff --git a/src/qibolab/_core/instruments/qm/components/__init__.py b/src/qibolab/_core/instruments/qm/components/__init__.py new file mode 100644 index 0000000000..23a39cbdad --- /dev/null +++ b/src/qibolab/_core/instruments/qm/components/__init__.py @@ -0,0 +1,5 @@ +from . import configs +from .configs import * + +__all__ = [] +__all__ += configs.__all__ diff --git a/src/qibolab/_core/instruments/qm/components/configs.py b/src/qibolab/_core/instruments/qm/components/configs.py new file mode 100644 index 0000000000..0ffbccf7e9 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/components/configs.py @@ -0,0 +1,44 @@ +from typing import Literal, Union + +from pydantic import Field + +from qibolab._core.components import AcquisitionConfig, DcConfig + +__all__ = ["OpxOutputConfig", "QmAcquisitionConfig", "QmConfigs"] + + +class OpxOutputConfig(DcConfig): + """DC channel config using QM OPX+.""" + + kind: Literal["opx-output"] = "opx-output" + + offset: float = 0.0 + """DC offset to be applied in V. + + Possible values are -0.5V to 0.5V. + """ + filter: dict[str, list[float]] = Field(default_factory=dict) + """FIR and IIR filters to be applied for correcting signal distortions. + + See + https://docs.quantum-machines.co/1.1.7/qm-qua-sdk/docs/Guides/output_filter/?h=filter#output-filter + for more details. + Changing the filters affects the calibration of single shot discrimination (threshold and angle). + """ + + +class QmAcquisitionConfig(AcquisitionConfig): + """Acquisition config for QM OPX+.""" + + kind: Literal["qm-acquisition"] = "qm-acquisition" + + gain: int = 0 + """Input gain in dB. + + Possible values are -12dB to 20dB in steps of 1dB. + """ + offset: float = 0.0 + """Constant voltage to be applied on the input.""" + + +QmConfigs = Union[OpxOutputConfig, QmAcquisitionConfig] diff --git a/src/qibolab/_core/instruments/qm/config/__init__.py b/src/qibolab/_core/instruments/qm/config/__init__.py new file mode 100644 index 0000000000..c8d5873880 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/config/__init__.py @@ -0,0 +1,2 @@ +from .config import Configuration +from .pulses import SAMPLING_RATE, operation diff --git a/src/qibolab/_core/instruments/qm/config/config.py b/src/qibolab/_core/instruments/qm/config/config.py new file mode 100644 index 0000000000..25bb7e49c4 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/config/config.py @@ -0,0 +1,160 @@ +from dataclasses import dataclass, field +from typing import Optional, Union + +from qibolab._core.components import ( + AcquisitionChannel, + DcChannel, + IqChannel, + IqConfig, + OscillatorConfig, +) +from qibolab._core.identifier import ChannelId +from qibolab._core.pulses import Pulse, Readout + +from ..components import OpxOutputConfig, QmAcquisitionConfig +from .devices import AnalogOutput, Controller, Octave, OctaveInput, OctaveOutput +from .elements import AcquireOctaveElement, DcElement, Element, RfOctaveElement +from .pulses import ( + QmAcquisition, + QmPulse, + Waveform, + integration_weights, + operation, + waveforms_from_pulse, +) + +__all__ = ["Configuration"] + +DEFAULT_DIGITAL_WAVEFORMS = {"ON": {"samples": [(1, 0)]}} +"""Required to be registered in the config for QM to work. + +Also used as triggering that allows the Octave LO signal to pass only +when we are executing something. +""" + + +@dataclass +class Configuration: + """Configuration for communicating with the ``QuantumMachinesManager``. + + Contains nested ``dataclass`` objects and is serialized using ``asdict`` + to be sent to the instrument. + """ + + version: int = 1 + controllers: dict[str, Controller] = field(default_factory=dict) + octaves: dict[str, Octave] = field(default_factory=dict) + elements: dict[str, Element] = field(default_factory=dict) + pulses: dict[str, Union[QmPulse, QmAcquisition]] = field(default_factory=dict) + waveforms: dict[str, Waveform] = field(default_factory=dict) + digital_waveforms: dict = field( + default_factory=lambda: DEFAULT_DIGITAL_WAVEFORMS.copy() + ) + integration_weights: dict = field(default_factory=dict) + mixers: dict = field(default_factory=dict) + + def add_controller(self, device: str): + if device not in self.controllers: + self.controllers[device] = Controller() + + def add_octave(self, device: str, connectivity: str): + if device not in self.octaves: + self.add_controller(connectivity) + self.octaves[device] = Octave(connectivity) + + def configure_dc_line( + self, id: ChannelId, channel: DcChannel, config: OpxOutputConfig + ): + controller = self.controllers[channel.device] + controller.analog_outputs[channel.port] = AnalogOutput.from_config(config) + self.elements[id] = DcElement.from_channel(channel) + + def configure_iq_line( + self, + id: ChannelId, + channel: IqChannel, + config: IqConfig, + lo_config: OscillatorConfig, + ): + port = channel.port + octave = self.octaves[channel.device] + octave.RF_outputs[port] = OctaveOutput.from_config(lo_config) + self.controllers[octave.connectivity].add_octave_output(port) + + intermediate_frequency = config.frequency - lo_config.frequency + self.elements[id] = RfOctaveElement.from_channel( + channel, octave.connectivity, intermediate_frequency + ) + + def configure_acquire_line( + self, + id: ChannelId, + acquire_channel: AcquisitionChannel, + probe_channel: IqChannel, + acquire_config: QmAcquisitionConfig, + probe_config: IqConfig, + lo_config: OscillatorConfig, + ): + port = acquire_channel.port + octave = self.octaves[acquire_channel.device] + octave.RF_inputs[port] = OctaveInput(lo_config.frequency) + self.controllers[octave.connectivity].add_octave_input(port, acquire_config) + + port = probe_channel.port + octave = self.octaves[probe_channel.device] + octave.RF_outputs[port] = OctaveOutput.from_config(lo_config) + self.controllers[octave.connectivity].add_octave_output(port) + + intermediate_frequency = probe_config.frequency - lo_config.frequency + self.elements[id] = AcquireOctaveElement.from_channel( + probe_channel, + acquire_channel, + octave.connectivity, + intermediate_frequency, + time_of_flight=acquire_config.delay, + smearing=acquire_config.smearing, + ) + + def register_waveforms( + self, pulse: Pulse, element: Optional[str] = None, dc: bool = False + ): + if dc: + qmpulse = QmPulse.from_dc_pulse(pulse) + else: + if element is None: + qmpulse = QmPulse.from_pulse(pulse) + else: + qmpulse = QmAcquisition.from_pulse(pulse, element) + waveforms = waveforms_from_pulse(pulse) + if dc: + self.waveforms[qmpulse.waveforms["single"]] = waveforms["I"] + else: + for mode in ["I", "Q"]: + self.waveforms[getattr(qmpulse.waveforms, mode)] = waveforms[mode] + return qmpulse + + def register_iq_pulse(self, element: str, pulse: Pulse): + op = operation(pulse) + if op not in self.pulses: + self.pulses[op] = self.register_waveforms(pulse) + self.elements[element].operations[op] = op + return op + + def register_dc_pulse(self, element: str, pulse: Pulse): + op = operation(pulse) + if op not in self.pulses: + self.pulses[op] = self.register_waveforms(pulse, dc=True) + self.elements[element].operations[op] = op + return op + + def register_acquisition_pulse(self, element: str, readout: Readout): + """Registers pulse, waveforms and integration weights in QM config.""" + op = operation(readout) + acquisition = f"{op}_{element}" + if acquisition not in self.pulses: + self.pulses[acquisition] = self.register_waveforms(readout.probe, element) + self.elements[element].operations[op] = acquisition + return op + + def register_integration_weights(self, element: str, duration: int, kernel): + self.integration_weights.update(integration_weights(element, duration, kernel)) diff --git a/src/qibolab/_core/instruments/qm/config/devices.py b/src/qibolab/_core/instruments/qm/config/devices.py new file mode 100644 index 0000000000..9cc8665d0b --- /dev/null +++ b/src/qibolab/_core/instruments/qm/config/devices.py @@ -0,0 +1,97 @@ +from dataclasses import dataclass, field +from typing import Any, Generic, TypeVar + +from qibolab._core.components import OscillatorConfig + +from ..components import OpxOutputConfig, QmAcquisitionConfig + +__all__ = ["AnalogOutput", "OctaveOutput", "OctaveInput", "Controller", "Octave"] + + +DEFAULT_INPUTS = {"1": {}, "2": {}} +"""Default controller config section. + +Inputs are always registered to avoid issues with automatic mixer +calibration when using Octaves. +""" + +V = TypeVar("V") + + +class PortDict(Generic[V], dict[str, V]): + """Dictionary that automatically converts keys to strings. + + Used to register input and output ports to controllers and Octaves + in the QUA config. + """ + + def __setitem__(self, key: Any, value: V): + super().__setitem__(str(key), value) + + +@dataclass(frozen=True) +class AnalogOutput: + offset: float = 0.0 + filter: dict[str, float] = field(default_factory=dict) + + @classmethod + def from_config(cls, config: OpxOutputConfig): + return cls(offset=config.offset, filter=config.filter) + + +@dataclass(frozen=True) +class AnalogInput: + offset: float = 0.0 + gain_db: int = 0 + + @classmethod + def from_config(cls, config: QmAcquisitionConfig): + return cls(offset=config.offset, gain_db=config.gain) + + +@dataclass(frozen=True) +class OctaveOutput: + LO_frequency: int + gain: int = 0 + LO_source: str = "internal" + output_mode: str = "triggered" + + @classmethod + def from_config(cls, config: OscillatorConfig): + return cls(LO_frequency=config.frequency, gain=config.power) + + +@dataclass(frozen=True) +class OctaveInput: + LO_frequency: int + LO_source: str = "internal" + IF_mode_I: str = "direct" + IF_mode_Q: str = "direct" + + +@dataclass +class Controller: + analog_outputs: PortDict[dict[str, AnalogOutput]] = field(default_factory=PortDict) + digital_outputs: PortDict[dict[str, dict]] = field(default_factory=PortDict) + analog_inputs: PortDict[dict[str, AnalogInput]] = field( + default_factory=lambda: PortDict(DEFAULT_INPUTS) + ) + + def add_octave_output(self, port: int): + # TODO: Add offset here? + self.analog_outputs[2 * port - 1] = AnalogOutput() + self.analog_outputs[2 * port] = AnalogOutput() + + self.digital_outputs[2 * port - 1] = {} + + def add_octave_input(self, port: int, config: QmAcquisitionConfig): + self.analog_inputs[2 * port - 1] = self.analog_inputs[2 * port] = ( + AnalogInput.from_config(config) + ) + + +@dataclass +class Octave: + connectivity: str + RF_outputs: PortDict[dict[str, OctaveOutput]] = field(default_factory=PortDict) + RF_inputs: PortDict[dict[str, OctaveInput]] = field(default_factory=PortDict) diff --git a/src/qibolab/_core/instruments/qm/config/elements.py b/src/qibolab/_core/instruments/qm/config/elements.py new file mode 100644 index 0000000000..1be37b2765 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/config/elements.py @@ -0,0 +1,113 @@ +from dataclasses import dataclass, field +from typing import Union + +import numpy as np + +from qibolab._core.components import Channel + +__all__ = ["DcElement", "RfOctaveElement", "AcquireOctaveElement", "Element"] + + +def iq_imbalance(g, phi): + """Create the correction matrix for the mixer imbalance. + + Mixer imbalance is caused by the gain and phase imbalances. + + More information here: + https://docs.qualang.io/libs/examples/mixer-calibration/#non-ideal-mixer + + Args: + g (float): relative gain imbalance between the I & Q ports (unit-less). + Set to 0 for no gain imbalance. + phi (float): relative phase imbalance between the I & Q ports (radians). + Set to 0 for no phase imbalance. + """ + c = np.cos(phi) + s = np.sin(phi) + N = 1 / ((1 - g**2) * (2 * c**2 - 1)) + return [float(N * x) for x in [(1 - g) * c, (1 + g) * s, (1 - g) * s, (1 + g) * c]] + + +@dataclass(frozen=True) +class OutputSwitch: + port: tuple[str, int] + delay: int = 57 + buffer: int = 18 + """Default calibration parameters for digital pulses. + + https://docs.quantum-machines.co/1.1.7/qm-qua-sdk/docs/Guides/octave/#calibrating-the-digital-pulse + + Digital markers are used for LO triggering. + """ + + +def _to_port(channel: Channel) -> dict[str, tuple[str, int]]: + """Convert a channel to the port dictionary required for the QUA config.""" + return {"port": (channel.device, channel.port)} + + +def output_switch(opx: str, port: int): + """Create output switch section.""" + return {"output_switch": OutputSwitch((opx, 2 * port - 1))} + + +@dataclass +class DcElement: + singleInput: dict[str, tuple[str, int]] + intermediate_frequency: int = 0 + operations: dict[str, str] = field(default_factory=dict) + + @classmethod + def from_channel(cls, channel: Channel): + return cls(_to_port(channel)) + + +@dataclass +class RfOctaveElement: + RF_inputs: dict[str, tuple[str, int]] + digitalInputs: dict[str, OutputSwitch] + intermediate_frequency: int + operations: dict[str, str] = field(default_factory=dict) + + @classmethod + def from_channel( + cls, channel: Channel, connectivity: str, intermediate_frequency: int + ): + return cls( + _to_port(channel), + output_switch(connectivity, channel.port), + intermediate_frequency, + ) + + +@dataclass +class AcquireOctaveElement: + RF_inputs: dict[str, tuple[str, int]] + RF_outputs: dict[str, tuple[str, int]] + digitalInputs: dict[str, OutputSwitch] + intermediate_frequency: int + time_of_flight: int = 24 + smearing: int = 0 + operations: dict[str, str] = field(default_factory=dict) + + @classmethod + def from_channel( + cls, + probe_channel: Channel, + acquire_channel: Channel, + connectivity: str, + intermediate_frequency: int, + time_of_flight: int, + smearing: int, + ): + return cls( + _to_port(probe_channel), + _to_port(acquire_channel), + output_switch(connectivity, probe_channel.port), + intermediate_frequency, + time_of_flight=time_of_flight, + smearing=smearing, + ) + + +Element = Union[DcElement, RfOctaveElement, AcquireOctaveElement] diff --git a/src/qibolab/_core/instruments/qm/config/pulses.py b/src/qibolab/_core/instruments/qm/config/pulses.py new file mode 100644 index 0000000000..983dc4d2b0 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/config/pulses.py @@ -0,0 +1,163 @@ +from dataclasses import dataclass, field +from typing import Union + +import numpy as np + +from qibolab._core.pulses import Pulse, Rectangular +from qibolab._core.pulses.modulation import rotate, wrap_phase + +SAMPLING_RATE = 1 +"""Sampling rate of Quantum Machines OPX+ in GSps.""" +MAX_VOLTAGE_OUTPUT = 0.5 +"""Maximum output of Quantum Machines OPX+ in Volts.""" + +__all__ = [ + "operation", + "Waveform", + "waveforms_from_pulse", + "integration_weights", + "QmPulse", + "QmAcquisition", +] + + +def operation(pulse): + """Generate operation name in QM ``config`` for the given pulse.""" + return str(hash(pulse)) + + +def baked_duration(duration: int) -> int: + """Calculate waveform length after pulse baking. + + QM can only play pulses with length that is >16ns and multiple of + 4ns. Waveforms that don't satisfy these constraints are padded with + zeros. + """ + return int(np.maximum((duration + 3) // 4 * 4, 16)) + + +@dataclass(frozen=True) +class ConstantWaveform: + sample: float + type: str = "constant" + + @classmethod + def from_pulse(cls, pulse: Pulse) -> dict[str, "Waveform"]: + phase = wrap_phase(pulse.relative_phase) + voltage_amp = pulse.amplitude * MAX_VOLTAGE_OUTPUT + return { + "I": cls(voltage_amp * np.cos(phase)), + "Q": cls(voltage_amp * np.sin(phase)), + } + + +@dataclass(frozen=True) +class ArbitraryWaveform: + samples: list[float] + type: str = "arbitrary" + + @classmethod + def from_pulse(cls, pulse: Pulse) -> dict[str, "Waveform"]: + original_waveforms = pulse.envelopes(SAMPLING_RATE) * MAX_VOLTAGE_OUTPUT + rotated_waveforms = rotate(original_waveforms, pulse.relative_phase) + new_duration = baked_duration(pulse.duration) + pad_len = new_duration - int(pulse.duration) + baked_waveforms = np.pad(rotated_waveforms, ((0, 0), (0, pad_len))) + return { + "I": cls(baked_waveforms[0]), + "Q": cls(baked_waveforms[1]), + } + + +Waveform = Union[ConstantWaveform, ArbitraryWaveform] + + +def waveforms_from_pulse(pulse: Pulse) -> dict[str, Waveform]: + """Register QM waveforms for a given pulse.""" + needs_baking = pulse.duration < 16 or pulse.duration % 4 != 0 + wvtype = ( + ConstantWaveform + if isinstance(pulse.envelope, Rectangular) and not needs_baking + else ArbitraryWaveform + ) + return wvtype.from_pulse(pulse) + + +@dataclass(frozen=True) +class Waveforms: + I: str + Q: str + + @classmethod + def from_op(cls, op: str): + return cls(f"{op}_i", f"{op}_q") + + +@dataclass(frozen=True) +class QmPulse: + length: int + waveforms: Union[Waveforms, dict[str, str]] + digital_marker: str = "ON" + operation: str = "control" + + @classmethod + def from_pulse(cls, pulse: Pulse): + op = operation(pulse) + return cls( + length=baked_duration(pulse.duration), + waveforms=Waveforms.from_op(op), + ) + + @classmethod + def from_dc_pulse(cls, pulse: Pulse): + op = operation(pulse) + return cls( + length=baked_duration(pulse.duration), + waveforms={"single": op}, + ) + + +def integration_weights(element: str, readout_len: int, kernel=None, angle: float = 0): + """Create integration weights section for QM config.""" + cos, sin = np.cos(angle), np.sin(angle) + if kernel is None: + convert = lambda x: [(x, readout_len)] + else: + cos = kernel * cos + sin = kernel * sin + convert = lambda x: x + + return { + f"cosine_weights_{element}": { + "cosine": convert(cos), + "sine": convert(-sin), + }, + f"sine_weights_{element}": { + "cosine": convert(sin), + "sine": convert(cos), + }, + f"minus_sine_weights_{element}": { + "cosine": convert(-sin), + "sine": convert(-cos), + }, + } + + +@dataclass(frozen=True) +class QmAcquisition(QmPulse): + operation: str = "measurement" + integration_weights: dict[str, str] = field(default_factory=dict) + + @classmethod + def from_pulse(cls, pulse: Pulse, element: str): + op = operation(pulse) + integration_weights = { + "cos": f"cosine_weights_{element}", + "sin": f"sine_weights_{element}", + "minus_sin": f"minus_sine_weights_{element}", + } + return cls( + length=pulse.duration, + waveforms=Waveforms.from_op(op), + integration_weights=integration_weights, + ) diff --git a/src/qibolab/_core/instruments/qm/controller.py b/src/qibolab/_core/instruments/qm/controller.py new file mode 100644 index 0000000000..f8efb7a21e --- /dev/null +++ b/src/qibolab/_core/instruments/qm/controller.py @@ -0,0 +1,498 @@ +import shutil +import tempfile +import warnings +from collections import defaultdict +from dataclasses import asdict, dataclass +from os import PathLike +from pathlib import Path +from typing import Optional, Union + +from pydantic import Field +from qm import QuantumMachinesManager, SimulationConfig, generate_qua_script +from qm.octave import QmOctaveConfig +from qm.simulate.credentials import create_credentials +from qualang_tools.simulator_tools import create_simulator_controller_connections + +from qibolab._core.components import ( + AcquisitionChannel, + Config, + DcChannel, + IqChannel, + IqConfig, + OscillatorConfig, +) +from qibolab._core.execution_parameters import ExecutionParameters +from qibolab._core.identifier import ChannelId +from qibolab._core.instruments.abstract import Controller +from qibolab._core.pulses import Acquisition, Align, Delay, Pulse, Readout +from qibolab._core.sequence import PulseSequence +from qibolab._core.sweeper import ParallelSweepers, Parameter, Sweeper +from qibolab._core.unrolling import Bounds, unroll_sequences + +from .components import OpxOutputConfig, QmAcquisitionConfig +from .config import SAMPLING_RATE, Configuration +from .program import ExecutionArguments, create_acquisition, program +from .program.sweepers import find_lo_frequencies, sweeper_amplitude + +CALIBRATION_DB = "calibration_db.json" +"""Name of the file where the mixer calibration is stored.""" + +__all__ = ["QmController", "Octave"] + +BOUNDS = Bounds( + waveforms=int(4e4), + readout=30, + instructions=int(1e6), +) + + +@dataclass(frozen=True) +class Octave: + """User-facing object for defining Octave configuration.""" + + name: str + """Name of the device.""" + port: int + """Network port of the Octave in the cluster configuration.""" + connectivity: str + """OPXplus that acts as the waveform generator for the Octave.""" + + +def declare_octaves(octaves, host, calibration_path=None): + """Initiate Octave configuration and add octaves info. + + Args: + octaves (dict): Dictionary containing :class:`qibolab.instruments.qm.devices.Octave` objects + for each Octave device in the experiment configuration. + host (str): IP of the Quantum Machines controller. + calibration_path (str): Path to the JSON file with the mixer calibration. + """ + if len(octaves) == 0: + return None + + config = QmOctaveConfig() + if calibration_path is not None: + config.set_calibration_db(calibration_path) + for octave in octaves.values(): + config.add_device_info(octave.name, host, octave.port) + return config + + +def fetch_results(result, acquisitions): + """Fetches results from an executed experiment. + + Args: + result: Result of the executed experiment. + acquisition: Dictionary containing :class:`qibolab.instruments.qm.acquisition.Acquisition` objects. + + Returns: + Dictionary with the results in the format required by the platform. + """ + handles = result.result_handles + handles.wait_for_all_values() # for async replace with ``handles.is_processing()`` + results = defaultdict(list) + for acquisition in acquisitions: + data = acquisition.fetch(handles) + for serial, result in zip(acquisition.keys, data): + results[serial].append(result) + + # collapse single element lists for back-compatibility + return { + key: value[0] if len(value) == 1 else value for key, value in results.items() + } + + +def find_sweepers( + sweepers: list[ParallelSweepers], parameter: Parameter +) -> list[Sweeper]: + """Find sweepers of given parameter in order to register specific pulses. + + Duration and amplitude sweepers may require registering additional pulses + in the QM ``config``. + """ + return [s for ps in sweepers for s in ps if s.parameter is parameter] + + +class QmController(Controller): + """:class:`qibolab.instruments.abstract.Controller` object for controlling + a Quantum Machines cluster. + + Playing pulses on QM controllers requires a ``config`` dictionary and a program + written in QUA language. + The ``config`` file is generated using the ``dataclass`` objects defined in + :mod:`qibolab.instruments.qm.config`. + The QUA program is generated using the methods in :mod:`qibolab.instruments.qm.program`. + Controllers, elements and pulses are added in the ``config`` after a pulse sequence is given, + so that only elements related to the participating channels are registered. + """ + + address: str + """IP address and port for connecting to the OPX instruments. + + Has the form XXX.XXX.XXX.XXX:XXX. + """ + + octaves: dict[str, Octave] = Field(default_factory=dict) + """Dictionary containing the + :class:`qibolab.instruments.qm.controller.Octave` instruments being + used.""" + + bounds: str = "qm/bounds" + """Maximum bounds used for batching in sequence unrolling.""" + calibration_path: Optional[PathLike] = None + """Path to the JSON file that contains the mixer calibration.""" + write_calibration: bool = False + """Require writing permissions on calibration DB.""" + _calibration_path: Optional[PathLike] = None + """The calibration path for internal use. + + Cf. :attr:`calibration_path` for its role. This might be set to a different one + internally to avoid writing attempts over a file for which the user has only read + access (because TinyDB, through QUA, is often attempting to open it in append mode). + """ + script_file_name: Optional[str] = None + """Name of the file that the QUA program will dumped in that after every + execution. + + If ``None`` the program will not be dumped. + """ + + manager: Optional[QuantumMachinesManager] = None + """Manager object used for controlling the Quantum Machines cluster.""" + + config: Configuration = Field(default_factory=Configuration) + """Configuration dictionary required for pulse execution on the OPXs.""" + + simulation_duration: Optional[int] = None + """Duration for the simulation in ns. + + If given the simulator will be used instead of actual hardware + execution. + """ + cloud: bool = False + """If ``True`` the QM cloud simulator is used which does not require access + to physical instruments. + + This assumes that a proper cloud address has been given. + If ``False`` and ``simulation_duration`` was given, then the built-in simulator + of the instruments is used. This requires connection to instruments. + Default is ``False``. + """ + + def model_post_init(self, __context): + if self.simulation_duration is not None: + # convert simulation duration from ns to clock cycles + self.simulation_duration //= 4 + + @property + def sampling_rate(self): + """Sampling rate of Quantum Machines instruments.""" + return SAMPLING_RATE + + def _temporary_calibration(self): + if self.calibration_path is not None: + if self.write_calibration: + self._calibration_path = self.calibration_path + else: + self._calibration_path = tempfile.mkdtemp() + shutil.copy( + Path(self.calibration_path) / CALIBRATION_DB, + Path(self._calibration_path) / CALIBRATION_DB, + ) + + def _reset_temporary_calibration(self): + if self._calibration_path != self.calibration_path: + assert self._calibration_path is not None + shutil.rmtree(self._calibration_path) + self._calibration_path = None + + def connect(self): + """Connect to the Quantum Machines manager.""" + host, port = self.address.split(":") + self._temporary_calibration() + octave = declare_octaves(self.octaves, host, self._calibration_path) + credentials = None + if self.cloud: + credentials = create_credentials() + self.manager = QuantumMachinesManager( + host=host, port=int(port), octave=octave, credentials=credentials + ) + + def disconnect(self): + """Disconnect from QM manager.""" + self._reset_temporary_calibration() + if self.manager is not None: + self.manager.close_all_quantum_machines() + self.manager.close() + self.manager = None + + def configure_device(self, device: str): + """Add device in the ``config``.""" + if "octave" in device: + self.config.add_octave(device, self.octaves[device].connectivity) + else: + self.config.add_controller(device) + + def configure_channel( + self, channel: ChannelId, configs: dict[str, Config] + ) -> Optional[ChannelId]: + """Add element (QM version of channel) in the config. + + When an ``AcquisitionChannel`` is registered it returns the corresponding probe + channel in order to build an (acquisition, probe) map. + """ + config = configs[channel] + ch = self.channels[channel] + self.configure_device(ch.device) + + if isinstance(ch, DcChannel): + assert isinstance(config, OpxOutputConfig) + self.config.configure_dc_line(channel, ch, config) + + elif isinstance(ch, IqChannel): + assert ch.lo is not None + assert isinstance(config, IqConfig) + lo_config = configs[ch.lo] + assert isinstance(lo_config, OscillatorConfig) + self.config.configure_iq_line(channel, ch, config, lo_config) + + elif isinstance(ch, AcquisitionChannel): + assert ch.probe is not None + assert isinstance(config, QmAcquisitionConfig) + probe = self.channels[ch.probe] + probe_config = configs[ch.probe] + assert isinstance(probe, IqChannel) + assert isinstance(probe_config, IqConfig) + assert probe.lo is not None + lo_config = configs[probe.lo] + assert isinstance(lo_config, OscillatorConfig) + self.configure_device(ch.device) + self.config.configure_acquire_line( + channel, ch, probe, config, probe_config, lo_config + ) + return ch.probe + + else: + raise TypeError(f"Unknown channel type: {type(ch)}.") + + return None + + def configure_channels( + self, configs: dict[str, Config], channels: set[ChannelId] + ) -> dict[ChannelId, ChannelId]: + """Register channels in the sequence in the QM ``config``. + + Builds a map from probe channels to the corresponding ``AcquisitionChannel``. + This is useful when sweeping frequency of probe channels, as these are + registered as acquire elements in the QM config. + """ + probe_map = {} + for id in channels: + probe = self.configure_channel(id, configs) + if probe is not None: + probe_map[probe] = id + return probe_map + + def register_pulse(self, channel: ChannelId, pulse: Union[Pulse, Readout]) -> str: + """Add pulse in the QM ``config``. + + And return corresponding operation. + """ + ch = self.channels[channel] + if isinstance(ch, DcChannel): + assert isinstance(pulse, Pulse) + return self.config.register_dc_pulse(channel, pulse) + if isinstance(ch, IqChannel): + assert isinstance(pulse, Pulse) + return self.config.register_iq_pulse(channel, pulse) + assert isinstance(pulse, Readout) + return self.config.register_acquisition_pulse(channel, pulse) + + def register_pulses(self, configs: dict[str, Config], sequence: PulseSequence): + """Adds all pulses except measurements of a given sequence in the QM + ``config``. + + Returns: + acquisitions (dict): Map from measurement instructions to acquisition objects. + """ + for id, pulse in sequence: + if hasattr(pulse, "duration") and not pulse.duration.is_integer(): + raise ValueError( + f"Quantum Machines cannot play pulse with duration {pulse.duration}. " + "Only integer duration in ns is supported." + ) + + if isinstance(pulse, Pulse): + self.register_pulse(id, pulse) + elif isinstance(pulse, Readout): + self.register_pulse(id, pulse) + + def register_duration_sweeper_pulses( + self, args: ExecutionArguments, sweeper: Sweeper + ): + """Register pulse with many different durations. + + Needed when sweeping duration. + """ + for pulse in sweeper.pulses: + if isinstance(pulse, (Align, Delay)): + continue + + params = args.parameters[pulse.id] + ids = args.sequence.pulse_channels(pulse.id) + original_pulse = ( + pulse if params.amplitude_pulse is None else params.amplitude_pulse + ) + for value in sweeper.values.astype(int): + sweep_pulse = original_pulse.model_copy(update={"duration": value}) + sweep_op = self.register_pulse(ids[0], sweep_pulse) + params.duration_ops.append((value, sweep_op)) + + def register_amplitude_sweeper_pulses( + self, args: ExecutionArguments, sweeper: Sweeper + ): + """Register pulse with different amplitude. + + Needed when sweeping amplitude because the original amplitude + may not sufficient to reach all the sweeper values. + """ + amplitude = sweeper_amplitude(sweeper.values) + for pulse in sweeper.pulses: + sweep_pulse = pulse.model_copy(update={"amplitude": amplitude}) + ids = args.sequence.pulse_channels(pulse.id) + params = args.parameters[pulse.id] + params.amplitude_pulse = sweep_pulse + params.amplitude_op = self.register_pulse(ids[0], sweep_pulse) + + def register_acquisitions( + self, + configs: dict[str, Config], + sequence: PulseSequence, + options: ExecutionParameters, + ): + """Add all measurements of a given sequence in the QM ``config``. + + Returns: + acquisitions (dict): Map from measurement instructions to acquisition objects. + """ + acquisitions = {} + for channel_id, readout in sequence: + if not isinstance(readout, Readout): + continue + + if readout.probe.duration != readout.acquisition.duration: + raise ValueError( + "Quantum Machines does not support acquisition with different duration than probe." + ) + + op = self.config.register_acquisition_pulse(channel_id, readout) + + acq_config = configs[channel_id] + assert isinstance(acq_config, QmAcquisitionConfig) + self.config.register_integration_weights( + channel_id, readout.duration, acq_config.kernel + ) + if (op, channel_id) in acquisitions: + acquisition = acquisitions[(op, channel_id)] + else: + acquisition = acquisitions[(op, channel_id)] = create_acquisition( + op, channel_id, options, acq_config.threshold, acq_config.iq_angle + ) + acquisition.keys.append(readout.acquisition.id) + + return acquisitions + + def preprocess_sweeps( + self, + sweepers: list[ParallelSweepers], + configs: dict[str, Config], + args: ExecutionArguments, + probe_map: dict[ChannelId, ChannelId], + ): + """Preprocessing and checks needed before executing some sweeps. + + Amplitude and duration sweeps require registering additional pulses in the QM ``config. + """ + for sweeper in find_sweepers(sweepers, Parameter.frequency): + channels = [(id, self.channels[id]) for id in sweeper.channels] + find_lo_frequencies(args, channels, configs, sweeper.values) + for id in sweeper.channels: + args.parameters[id].element = probe_map.get(id, id) + for sweeper in find_sweepers(sweepers, Parameter.offset): + for id in sweeper.channels: + args.parameters[id].element = id + for sweeper in find_sweepers(sweepers, Parameter.amplitude): + self.register_amplitude_sweeper_pulses(args, sweeper) + for sweeper in find_sweepers(sweepers, Parameter.duration): + self.register_duration_sweeper_pulses(args, sweeper) + + def execute_program(self, program): + """Executes an arbitrary program written in QUA language.""" + machine = self.manager.open_qm(asdict(self.config)) + return machine.execute(program) + + def simulate_program(self, program): + """Simulates an arbitrary program written in QUA language.""" + ncontrollers = len(self.config.controllers) + controller_connections = create_simulator_controller_connections(ncontrollers) + simulation_config = SimulationConfig( + duration=self.simulation_duration, + controller_connections=controller_connections, + ) + return self.manager.simulate(asdict(self.config), program, simulation_config) + + def play( + self, + configs: dict[str, Config], + sequences: list[PulseSequence], + options: ExecutionParameters, + sweepers: list[ParallelSweepers], + ): + if len(sequences) == 0: + return {} + elif len(sequences) == 1: + sequence = sequences[0] + else: + sequence, _ = unroll_sequences(sequences, options.relaxation_time) + + if len(sequence) == 0: + return {} + + # register DC elements so that all qubits are + # sweetspot even when they are not used + for id, channel in self.channels.items(): + if isinstance(channel, DcChannel): + self.configure_channel(id, configs) + + probe_map = self.configure_channels(configs, sequence.channels) + self.register_pulses(configs, sequence) + acquisitions = self.register_acquisitions(configs, sequence, options) + + args = ExecutionArguments(sequence, acquisitions, options.relaxation_time) + self.preprocess_sweeps(sweepers, configs, args, probe_map) + experiment = program(args, options, sweepers) + + if self.script_file_name is not None: + script_config = ( + {"version": 1} if self.manager is None else asdict(self.config) + ) + script = generate_qua_script(experiment, script_config) + with open(self.script_file_name, "w") as file: + file.write(script) + + if self.manager is None: + warnings.warn( + "Not connected to Quantum Machines. Returning program and config." + ) + return {"program": experiment, "config": asdict(self.config)} + + if self.simulation_duration is not None: + result = self.simulate_program(experiment) + results = {} + for _, pulse in sequence: + if isinstance(pulse, Acquisition): + results[pulse.id] = result + return results + + result = self.execute_program(experiment) + return fetch_results(result, acquisitions.values()) diff --git a/src/qibolab/_core/instruments/qm/program/__init__.py b/src/qibolab/_core/instruments/qm/program/__init__.py new file mode 100644 index 0000000000..e4fc749212 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/program/__init__.py @@ -0,0 +1,3 @@ +from .acquisition import Acquisitions, create_acquisition +from .arguments import ExecutionArguments +from .instructions import program diff --git a/src/qibolab/_core/instruments/qm/program/acquisition.py b/src/qibolab/_core/instruments/qm/program/acquisition.py new file mode 100644 index 0000000000..9aea9d0795 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/program/acquisition.py @@ -0,0 +1,267 @@ +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from typing import Optional + +import numpy as np +from qm import qua +from qm.qua import declare, declare_stream, fixed +from qm.qua._dsl import _ResultSource, _Variable # for type declaration only +from qualang_tools.addons.variables import assign_variables_to_element +from qualang_tools.units import unit + +from qibolab._core.execution_parameters import ( + AcquisitionType, + AveragingMode, + ExecutionParameters, +) + + +def _collect(i, q, npulses): + """Collect I and Q components of signal. + + I and Q should be the the last dimension of the returned array, + except when multiple results are acquired to the same stream in the + instrument, when they should be second to last. + """ + signal = np.stack([i, q]) + return np.moveaxis(signal, 0, -1 - int(npulses > 1)) + + +def _split(data, npulses): + """Split results of different readout pulses to list. + + These results were acquired in the same acquisition stream in the + instrument. + """ + if npulses == 1: + return [data] + return list(np.moveaxis(data, -1, 0)) + + +@dataclass +class Acquisition(ABC): + """QUA variables used for saving of acquisition results. + + This class can be instantiated only within a QUA program scope. Each + readout pulse is associated with its own set of acquisition + variables. + """ + + operation: str + element: str + """Element from QM ``config`` that the pulse will be applied on.""" + average: bool + keys: list[int] = field(default_factory=list) + + @property + def name(self): + """Identifier to download results from the instruments.""" + return f"{self.operation}_{self.element}" + + @property + def npulses(self): + return len(self.keys) + + @abstractmethod + def declare(self): + """Declares QUA variables related to this acquisition. + + Assigns acquisition variables to the corresponding QM + controller. This was proposed by QM to avoid crashes. + """ + + @abstractmethod + def measure(self, operation): + """Send measurement pulse and acquire results. + + Args: + operation (str): Operation (from ``config``) corresponding to the pulse to be played. + """ + + @abstractmethod + def download(self, *dimensions): + """Save streams to prepare for fetching from host device. + + Args: + dimensions (int): Dimensions to use for buffer of data. + """ + + @abstractmethod + def fetch(self): + """Fetch downloaded streams to host device.""" + + +@dataclass +class RawAcquisition(Acquisition): + """QUA variables used for raw waveform acquisition.""" + + adc_stream: Optional[_ResultSource] = None + """Stream to collect raw ADC data.""" + + def declare(self): + self.adc_stream = declare_stream(adc_trace=True) + + def measure(self, operation): + qua.reset_phase(self.element) + qua.measure(operation, self.element, self.adc_stream) + + def download(self, *dimensions): + istream = self.adc_stream.input1() + qstream = self.adc_stream.input2() + if self.average: + istream = istream.average() + qstream = qstream.average() + istream.save(f"{self.name}_I") + qstream.save(f"{self.name}_Q") + + def fetch(self, handles): + ires = handles.get(f"{self.name}_I").fetch_all() + qres = handles.get(f"{self.name}_Q").fetch_all() + # convert raw ADC signal to volts + u = unit() + signal = _collect(u.raw2volts(ires), u.raw2volts(qres), self.npulses) + return _split(signal, self.npulses) + + +@dataclass +class IntegratedAcquisition(Acquisition): + """QUA variables used for integrated acquisition.""" + + i: Optional[_Variable] = None + q: Optional[_Variable] = None + """Variables to save the (I, Q) values acquired from a single shot.""" + istream: Optional[_ResultSource] = None + qstream: Optional[_ResultSource] = None + """Streams to collect the results of all shots.""" + + def declare(self): + self.i = declare(fixed) + self.q = declare(fixed) + self.istream = declare_stream() + self.qstream = declare_stream() + assign_variables_to_element(self.element, self.i, self.q) + + def measure(self, operation): + qua.measure( + operation, + self.element, + None, + qua.dual_demod.full("cos", "out1", "sin", "out2", self.i), + qua.dual_demod.full("minus_sin", "out1", "cos", "out2", self.q), + ) + qua.save(self.i, self.istream) + qua.save(self.q, self.qstream) + + def download(self, *dimensions): + istream = self.istream + qstream = self.qstream + if self.npulses > 1: + istream = istream.buffer(self.npulses) + qstream = qstream.buffer(self.npulses) + for dim in dimensions: + istream = istream.buffer(dim) + qstream = qstream.buffer(dim) + if self.average: + istream = istream.average() + qstream = qstream.average() + istream.save(f"{self.name}_I") + qstream.save(f"{self.name}_Q") + + def fetch(self, handles): + ires = handles.get(f"{self.name}_I").fetch_all() + qres = handles.get(f"{self.name}_Q").fetch_all() + signal = _collect(ires, qres, self.npulses) + return _split(signal, self.npulses) + + +@dataclass +class ShotsAcquisition(Acquisition): + """QUA variables used for shot classification. + + Threshold and angle must be given in order to classify shots. + """ + + threshold: Optional[float] = None + """Threshold to be used for classification of single shots.""" + angle: Optional[float] = None + """Angle in the IQ plane to be used for classification of single shots.""" + + i: Optional[_Variable] = None + q: Optional[_Variable] = None + """Variables to save the (I, Q) values acquired from a single shot.""" + shot: Optional[_Variable] = None + """Variable for calculating an individual shots.""" + shots: Optional[_ResultSource] = None + """Stream to collect multiple shots.""" + + def __post_init__(self): + self.cos = np.cos(self.angle) + self.sin = np.sin(self.angle) + + def declare(self): + self.i = declare(fixed) + self.q = declare(fixed) + self.shot = declare(int) + self.shots = declare_stream() + assign_variables_to_element(self.element, self.i, self.q, self.shot) + + def measure(self, operation): + qua.measure( + operation, + self.element, + None, + qua.dual_demod.full("cos", "out1", "sin", "out2", self.i), + qua.dual_demod.full("minus_sin", "out1", "cos", "out2", self.q), + ) + qua.assign( + self.shot, + qua.Cast.to_int(self.i * self.cos - self.q * self.sin > self.threshold), + ) + qua.save(self.shot, self.shots) + + def download(self, *dimensions): + shots = self.shots + if self.npulses > 1: + shots = shots.buffer(self.npulses) + for dim in dimensions: + shots = shots.buffer(dim) + if self.average: + shots = shots.average() + shots.save(f"{self.name}_shots") + + def fetch(self, handles): + shots = handles.get(f"{self.name}_shots").fetch_all() + return _split(shots, self.npulses) + + +ACQUISITION_TYPES = { + AcquisitionType.RAW: RawAcquisition, + AcquisitionType.INTEGRATION: IntegratedAcquisition, + AcquisitionType.DISCRIMINATION: ShotsAcquisition, +} + + +def create_acquisition( + operation: str, + element: str, + options: ExecutionParameters, + threshold: float, + angle: float, +) -> Acquisition: + """Create container for the variables used for saving acquisition in the + QUA program. + + Returns: + ``Acquisition`` object containing acquisition variables. + """ + average = options.averaging_mode is AveragingMode.CYCLIC + kwargs = {} + if options.acquisition_type is AcquisitionType.DISCRIMINATION: + kwargs = {"threshold": threshold, "angle": angle} + acquisition = ACQUISITION_TYPES[options.acquisition_type]( + operation, element, average, **kwargs + ) + return acquisition + + +Acquisitions = dict[tuple[str, str], Acquisition] diff --git a/src/qibolab/_core/instruments/qm/program/arguments.py b/src/qibolab/_core/instruments/qm/program/arguments.py new file mode 100644 index 0000000000..4f93f70dfe --- /dev/null +++ b/src/qibolab/_core/instruments/qm/program/arguments.py @@ -0,0 +1,45 @@ +from collections import defaultdict +from dataclasses import dataclass, field +from typing import Optional, Union + +from qm.qua._dsl import _Variable # for type declaration only + +from qibolab._core.identifier import ChannelId +from qibolab._core.pulses import Pulse +from qibolab._core.sequence import PulseSequence + +from .acquisition import Acquisitions + + +@dataclass +class Parameters: + """Container of QUA variables and other parameters needed for sweeping.""" + + amplitude: Optional[_Variable] = None + amplitude_pulse: Optional[Pulse] = None + amplitude_op: Optional[str] = None + + phase: Optional[_Variable] = None + + duration: Optional[_Variable] = None + duration_ops: list[tuple[float, str]] = field(default_factory=list) + interpolated: bool = False + + element: Optional[str] = None + lo_frequency: Optional[int] = None + + +@dataclass +class ExecutionArguments: + """Container of arguments required to generate the QUA program. + + These are collected in a single class because they are passed to all + the different sweeper types. + """ + + sequence: PulseSequence + acquisitions: Acquisitions + relaxation_time: int = 0 + parameters: dict[Union[str, ChannelId], Parameters] = field( + default_factory=lambda: defaultdict(Parameters) + ) diff --git a/src/qibolab/_core/instruments/qm/program/instructions.py b/src/qibolab/_core/instruments/qm/program/instructions.py new file mode 100644 index 0000000000..f1dc1de501 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/program/instructions.py @@ -0,0 +1,189 @@ +from typing import Optional + +from qm import qua +from qm.qua import declare, fixed, for_ +from qualang_tools.loops import from_array + +from qibolab._core.execution_parameters import AcquisitionType, ExecutionParameters +from qibolab._core.pulses import Align, Delay, Pulse, Readout, VirtualZ +from qibolab._core.sweeper import ParallelSweepers, Parameter, Sweeper + +from ..config import operation +from .acquisition import Acquisition +from .arguments import ExecutionArguments, Parameters +from .sweepers import INT_TYPE, NORMALIZERS, SWEEPER_METHODS, normalize_phase + + +def _delay(pulse: Delay, element: str, parameters: Parameters): + # TODO: How to play delays on multiple elements? + if parameters.duration is None: + duration = max(int(pulse.duration) // 4 + 1, 4) + qua.wait(duration, element) + elif parameters.interpolated: + duration = parameters.duration + 1 + qua.wait(duration, element) + else: + duration = parameters.duration / 4 + with qua.if_(duration < 4): + qua.wait(4, element) + with qua.else_(): + qua.wait(duration, element) + + +def _play_multiple_waveforms(element: str, parameters: Parameters): + """Sweeping pulse duration using distinctly uploaded waveforms.""" + with qua.switch_(parameters.duration, unsafe=True): + for value, sweep_op in parameters.duration_ops: + if parameters.amplitude is not None: + sweep_op = sweep_op * parameters.amplitude + with qua.case_(value): + qua.play(sweep_op, element) + + +def _play_single_waveform( + op: str, + element: str, + parameters: Parameters, + acquisition: Optional[Acquisition] = None, +): + if parameters.amplitude is not None: + op = parameters.amplitude_op * parameters.amplitude + if acquisition is not None: + acquisition.measure(op) + else: + qua.play(op, element, duration=parameters.duration) + + +def _play( + op: str, + element: str, + parameters: Parameters, + acquisition: Optional[Acquisition] = None, +): + if parameters.phase is not None: + qua.frame_rotation_2pi(parameters.phase, element) + + if len(parameters.duration_ops) > 0: + _play_multiple_waveforms(element, parameters) + else: + _play_single_waveform(op, element, parameters, acquisition) + + if parameters.phase is not None: + qua.reset_frame(element) + + +def play(args: ExecutionArguments): + """Part of QUA program that plays an arbitrary pulse sequence. + + Should be used inside a ``program()`` context. + """ + qua.align() + + # keep track of ``Align`` command that were already played + # because the same ``Align`` will appear on multiple channels + # in the sequence + processed_aligns = set() + + for channel_id, pulse in args.sequence: + element = str(channel_id) + op = operation(pulse) + params = args.parameters[pulse.id] + if isinstance(pulse, Delay): + _delay(pulse, element, params) + elif isinstance(pulse, Pulse): + _play(op, element, params) + elif isinstance(pulse, Readout): + acquisition = args.acquisitions.get((op, element)) + _play(op, element, params, acquisition) + elif isinstance(pulse, VirtualZ): + qua.frame_rotation_2pi(normalize_phase(pulse.phase), element) + elif isinstance(pulse, Align) and pulse.id not in processed_aligns: + channel_ids = args.sequence.pulse_channels(pulse.id) + qua.align(*(str(ch) for ch in channel_ids)) + processed_aligns.add(pulse.id) + + if args.relaxation_time > 0: + qua.wait(args.relaxation_time // 4) + + +def _process_sweeper(sweeper: Sweeper, args: ExecutionArguments): + parameter = sweeper.parameter + if parameter not in SWEEPER_METHODS: + raise NotImplementedError(f"Sweeper for {parameter} is not implemented.") + + if parameter in INT_TYPE: + variable = declare(int) + values = sweeper.values.astype(int) + else: + variable = declare(fixed) + values = sweeper.values + + if parameter is Parameter.frequency: + lo_frequency = args.parameters[sweeper.channels[0]].lo_frequency + values = NORMALIZERS[parameter](values, lo_frequency) + elif parameter in NORMALIZERS: + values = NORMALIZERS[parameter](values) + + return variable, values + + +def sweep( + sweepers: list[ParallelSweepers], + args: ExecutionArguments, +): + """Unrolls a list of qibolab sweepers to the corresponding QUA for loops. + + Uses recursion to handle nested sweepers. + """ + if len(sweepers) > 0: + parallel_sweepers = sweepers[0] + + variables, all_values = zip( + *(_process_sweeper(sweeper, args) for sweeper in parallel_sweepers) + ) + if len(parallel_sweepers) > 1: + loop = qua.for_each_(variables, all_values) + else: + loop = for_(*from_array(variables[0], all_values[0])) + + with loop: + for sweeper, variable, values in zip( + parallel_sweepers, variables, all_values + ): + method = SWEEPER_METHODS[sweeper.parameter] + if sweeper.pulses is not None: + for pulse in sweeper.pulses: + params = args.parameters[pulse.id] + method(variable, params) + else: + for channel in sweeper.channels: + params = args.parameters[channel] + method(variable, params) + + sweep(sweepers[1:], args) + + else: + play(args) + + +def program( + args: ExecutionArguments, + options: ExecutionParameters, + sweepers: list[ParallelSweepers], +): + """QUA program implementing the required experiment.""" + with qua.program() as experiment: + n = declare(int) + # declare acquisition variables + for acquisition in args.acquisitions.values(): + acquisition.declare() + # execute pulses + with for_(n, 0, n < options.nshots, n + 1): + sweep(list(sweepers), args) + # download acquisitions + has_iq = options.acquisition_type is AcquisitionType.INTEGRATION + buffer_dims = options.results_shape(sweepers)[::-1][int(has_iq) :] + with qua.stream_processing(): + for acquisition in args.acquisitions.values(): + acquisition.download(*buffer_dims) + return experiment diff --git a/src/qibolab/_core/instruments/qm/program/sweepers.py b/src/qibolab/_core/instruments/qm/program/sweepers.py new file mode 100644 index 0000000000..64fb0680f7 --- /dev/null +++ b/src/qibolab/_core/instruments/qm/program/sweepers.py @@ -0,0 +1,145 @@ +import numpy as np +import numpy.typing as npt +from qm import qua +from qm.qua._dsl import _Variable # for type declaration only + +from qibolab._core.components import Channel, Config +from qibolab._core.identifier import ChannelId +from qibolab._core.sweeper import Parameter + +from .arguments import ExecutionArguments, Parameters + +MAX_OFFSET = 0.5 +"""Maximum voltage supported by Quantum Machines OPX+ instrument in volts.""" +MAX_AMPLITUDE_FACTOR = 1.99 +"""Maximum multiplication factor for ``qua.amp`` used when sweeping amplitude. + +https://docs.quantum-machines.co/1.2.0/docs/API_references/qua/dsl_main/#qm.qua._dsl.amp +""" +FREQUENCY_BANDWIDTH = 4e8 +"""Quantum Machines OPX+ frequency bandwidth in Hz.""" + + +def find_lo_frequencies( + args: ExecutionArguments, + channels: list[tuple[ChannelId, Channel]], + configs: dict[str, Config], + values: npt.NDArray, +): + """Register LO frequencies of swept channels in execution arguments. + + These are needed to calculate the proper IF when sweeping frequency. + It also checks if frequency sweep is within the supported instrument + bandwidth [-400, 400] MHz. + """ + lo_freqs = {configs[channel.lo].frequency for _, channel in channels} + if len(lo_freqs) > 1: + raise ValueError( + "Cannot sweep frequency of channels using different LO using the same `Sweeper` object. Please use parallel sweepers instead." + ) + lo_frequency = lo_freqs.pop() + for id, channel in channels: + max_freq = max(abs(values - lo_frequency)) + if max_freq > FREQUENCY_BANDWIDTH: + raise ValueError( + f"Frequency {max_freq} for channel {id} is beyond instrument bandwidth." + ) + args.parameters[id].lo_frequency = int(lo_frequency) + + +def sweeper_amplitude(values: npt.NDArray) -> float: + """Pulse amplitude to be registered in the QM ``config`` when sweeping + amplitude. + + The multiplicative factor used in the ``qua.amp`` command is limited, so we + may need to register a pulse with different amplitude than the original pulse + in the sequence, in order to reach all sweeper values when sweeping amplitude. + """ + return max(abs(values)) / MAX_AMPLITUDE_FACTOR + + +def normalize_amplitude(values: npt.NDArray) -> npt.NDArray: + """Normalize amplitude factor to [-MAX_AMPLITUDE_FACTOR, + MAX_AMPLITUDE_FACTOR].""" + return values / sweeper_amplitude(values) + + +def normalize_phase(values: npt.NDArray) -> npt.NDArray: + """Normalize phase from [0, 2pi] to [0, 1].""" + return values / (2 * np.pi) + + +def normalize_duration(values: npt.NDArray) -> npt.NDArray: + """Convert duration from ns to clock cycles (clock cycle = 4ns).""" + if any(values < 16) or not all(values % 4 == 0): + raise ValueError( + "Cannot use interpolated duration sweeper for durations that are not multiple of 4ns or are less than 16ns. Please use normal duration sweeper." + ) + return (values // 4).astype(int) + + +def normalize_frequency(values: npt.NDArray, lo_frequency: int) -> npt.NDArray: + """Convert frequencies to integer and subtract LO frequency. + + QUA gives an error if the raw frequency values are uploaded to sweep + over. + """ + return (values - lo_frequency).astype(int) + + +def _amplitude(variable: _Variable, parameters: Parameters): + parameters.amplitude = qua.amp(variable) + + +def _relative_phase(variable: _Variable, parameters: Parameters): + parameters.phase = variable + + +def _duration(variable: _Variable, parameters: Parameters): + parameters.duration = variable + + +def _duration_interpolated(variable: _Variable, parameters: Parameters): + parameters.duration = variable + parameters.interpolated = True + + +def _offset(variable: _Variable, parameters: Parameters): + with qua.if_(variable >= MAX_OFFSET): + qua.set_dc_offset(parameters.element, "single", MAX_OFFSET) + with qua.elif_(variable <= -MAX_OFFSET): + qua.set_dc_offset(parameters.element, "single", -MAX_OFFSET) + with qua.else_(): + qua.set_dc_offset(parameters.element, "single", variable) + + +def _frequency(variable: _Variable, parameters: Parameters): + qua.update_frequency(parameters.element, variable) + + +INT_TYPE = {Parameter.frequency, Parameter.duration, Parameter.duration_interpolated} +"""Sweeper parameters for which we need ``int`` variable type. + +The rest parameters need ``fixed`` type. +""" + +NORMALIZERS = { + Parameter.frequency: normalize_frequency, + Parameter.amplitude: normalize_amplitude, + Parameter.relative_phase: normalize_phase, + Parameter.duration_interpolated: normalize_duration, +} +"""Functions to normalize sweeper values. + +The rest parameters do not need normalization (identity function). +""" + +SWEEPER_METHODS = { + Parameter.frequency: _frequency, + Parameter.amplitude: _amplitude, + Parameter.duration: _duration, + Parameter.duration_interpolated: _duration_interpolated, + Parameter.relative_phase: _relative_phase, + Parameter.offset: _offset, +} +"""Methods that return part of QUA program to be used inside the loop.""" diff --git a/src/qibolab/_core/instruments/rohde_schwarz.py b/src/qibolab/_core/instruments/rohde_schwarz.py new file mode 100644 index 0000000000..2abf802a43 --- /dev/null +++ b/src/qibolab/_core/instruments/rohde_schwarz.py @@ -0,0 +1,19 @@ +import qcodes.instrument_drivers.rohde_schwarz.SGS100A as LO_SGS100A + +from qibolab._core.instruments.oscillator import LocalOscillator + +__all__ = ["SGS100A"] + + +class SGS100A(LocalOscillator): + """Driver to control the Rohde-Schwarz SGS100A local oscillator. + + This driver is using: + https://qcodes.github.io/Qcodes/api/generated/qcodes.instrument_drivers.rohde_schwarz.html#module-qcodes.instrument_drivers.rohde_schwarz.SGS100A + """ + + def create(self): + name = f"{type(self).__name__}{id(self)}" + return LO_SGS100A.RohdeSchwarz_SGS100A( + name, f"TCPIP0::{self.address}::5025::SOCKET" + ) diff --git a/src/qibolab/_core/instruments/zhinst/__init__.py b/src/qibolab/_core/instruments/zhinst/__init__.py new file mode 100644 index 0000000000..e5a00e1b89 --- /dev/null +++ b/src/qibolab/_core/instruments/zhinst/__init__.py @@ -0,0 +1,3 @@ +from .components import * +from .executor import Zurich +from .sweep import ProcessedSweeps, classify_sweepers diff --git a/src/qibolab/_core/instruments/zhinst/components/__init__.py b/src/qibolab/_core/instruments/zhinst/components/__init__.py new file mode 100644 index 0000000000..f1fd439eb3 --- /dev/null +++ b/src/qibolab/_core/instruments/zhinst/components/__init__.py @@ -0,0 +1,2 @@ +from .channel import * +from .configs import * diff --git a/src/qibolab/_core/instruments/zhinst/components/channel.py b/src/qibolab/_core/instruments/zhinst/components/channel.py new file mode 100644 index 0000000000..898625de0c --- /dev/null +++ b/src/qibolab/_core/instruments/zhinst/components/channel.py @@ -0,0 +1,19 @@ +from dataclasses import dataclass + +from qibolab._core.components import Channel + +__all__ = [ + "ZiChannel", +] + + +@dataclass(frozen=True) +class ZiChannel: + """Channel for Zurich Instruments (ZI) devices.""" + + logical_channel: Channel + """Corresponding logical channel.""" + device: str + """Name of the device.""" + path: str + """Path of the device node.""" diff --git a/src/qibolab/_core/instruments/zhinst/components/configs.py b/src/qibolab/_core/instruments/zhinst/components/configs.py new file mode 100644 index 0000000000..c48bc465ce --- /dev/null +++ b/src/qibolab/_core/instruments/zhinst/components/configs.py @@ -0,0 +1,37 @@ +from qibolab._core.components import AcquisitionConfig, DcConfig, IqConfig + +__all__ = [ + "ZiDcConfig", + "ZiIqConfig", + "ZiAcquisitionConfig", +] + + +class ZiDcConfig(DcConfig): + """DC channel config using ZI HDAWG.""" + + power_range: float + """Power range in volts. + + Possible values are [0.2 0.4 0.6 0.8 1. 2. 3. 4. 5.]. + """ + + +class ZiIqConfig(IqConfig): + """IQ channel config for ZI SHF* line instrument.""" + + power_range: float + """Power range in dBm. + + Possible values are [-30. -25. -20. -15. -10. -5. 0. 5. 10.]. + """ + + +class ZiAcquisitionConfig(AcquisitionConfig): + """Acquisition config for ZI SHF* line instrument.""" + + power_range: float = 0 + """Power range in dBm. + + Possible values are [-30. -25. -20. -15. -10. -5. 0. 5. 10.]. + """ diff --git a/src/qibolab/_core/instruments/zhinst/constants.py b/src/qibolab/_core/instruments/zhinst/constants.py new file mode 100644 index 0000000000..a9c1a449e6 --- /dev/null +++ b/src/qibolab/_core/instruments/zhinst/constants.py @@ -0,0 +1,4 @@ +"""Shared constants.""" + +SAMPLING_RATE = 2 +NANO_TO_SECONDS = 1e-9 diff --git a/src/qibolab/_core/instruments/zhinst/executor.py b/src/qibolab/_core/instruments/zhinst/executor.py new file mode 100644 index 0000000000..e8dd48352e --- /dev/null +++ b/src/qibolab/_core/instruments/zhinst/executor.py @@ -0,0 +1,552 @@ +"""Executing pulse sequences on a Zurich Instruments devices.""" + +import re +from itertools import chain +from typing import Any, Optional, Union + +import laboneq.simple as laboneq +import numpy as np +from laboneq.dsl.device import create_connection + +from qibolab._core.execution_parameters import ( + AcquisitionType, + AveragingMode, + ExecutionParameters, +) +from qibolab._core.instruments.abstract import Controller +from qibolab._core.pulses import Delay, Pulse +from qibolab._core.sequence import PulseSequence +from qibolab._core.sweeper import Parameter, Sweeper +from qibolab._core.unrolling import Bounds + +from ...components import AcquisitionChannel, Config, DcChannel, IqChannel +from .components import ZiChannel +from .constants import NANO_TO_SECONDS, SAMPLING_RATE +from .pulse import select_pulse +from .sweep import ProcessedSweeps, classify_sweepers + +COMPILER_SETTINGS = { + "SHFSG_MIN_PLAYWAVE_HINT": 32, + "SHFSG_MIN_PLAYZERO_HINT": 32, + "HDAWG_MIN_PLAYWAVE_HINT": 64, + "HDAWG_MIN_PLAYZERO_HINT": 64, +} +"""Translating to Zurich ExecutionParameters.""" +ACQUISITION_TYPE = { + AcquisitionType.INTEGRATION: laboneq.AcquisitionType.INTEGRATION, + AcquisitionType.RAW: laboneq.AcquisitionType.RAW, + AcquisitionType.DISCRIMINATION: laboneq.AcquisitionType.DISCRIMINATION, +} + +AVERAGING_MODE = { + AveragingMode.CYCLIC: laboneq.AveragingMode.CYCLIC, + AveragingMode.SINGLESHOT: laboneq.AveragingMode.SINGLE_SHOT, +} + + +def _acquisition_handle(seq_idx: int, pulse_idx: int, acquisition_name: str) -> str: + return f"sequence_{seq_idx}_{acquisition_name}_{pulse_idx}" + + +class Zurich(Controller): + """Driver for a collection of ZI instruments that are automatically + synchronized via ZSync protocol.""" + + def __init__( + self, + device_setup, + channels: list[ZiChannel], + time_of_flight=0.0, + smearing=0.0, + ): + super().__init__(address=None) + + self.signal_map = {} + "Signals to lines mapping" + self.calibration = laboneq.Calibration() + "Zurich calibration object)" + + for ch in channels: + device_setup.add_connections( + ch.device, + create_connection(to_signal=ch.logical_channel.name, ports=ch.path), + ) + self.device_setup = device_setup + self.session = None + "Zurich device parameters for connection" + + self.channels = {ch.logical_channel.name: ch for ch in channels} + + self.time_of_flight = time_of_flight + self.smearing = smearing + "Parameters read from the runcard not part of ExecutionParameters" + + self.experiment = None + self.results = None + "Zurich experiment definitions" + + self.bounds = Bounds( + waveforms=int(4e4), + readout=250, + instructions=int(1e6), + ) + + self.acquisition_type = None + "To store if the AcquisitionType.SPECTROSCOPY needs to be enabled by parsing the sequence" + + self.sequences: list[PulseSequence] = [] + "Pulse sequences" + + self.processed_sweeps: Optional[ProcessedSweeps] = None + self.nt_sweeps: list[Sweeper] = [] + self.rt_sweeps: list[Sweeper] = [] + + @property + def sampling_rate(self): + return SAMPLING_RATE + + def _probe_channels(self) -> set[str]: + return { + ch.logical_channel.name + for ch in self.channels.values() + if isinstance(ch.logical_channel, IqChannel) + and ch.logical_channel.acquisition is not None + } + + def connect(self): + if self.session is None: + # To fully remove logging #configure_logging=False + # I strongly advise to set it to 20 to have time estimates of the experiment duration! + self.session = laboneq.Session(self.device_setup, log_level=20) + _ = self.session.connect() + + def disconnect(self): + if self.session is None: + _ = self.session.disconnect() + self.session = None + + def calibration_step(self, configs: dict[str, Config], options): + """Zurich general pre experiment calibration definitions. + + Change to get frequencies from sequence + """ + + for ch in self.channels.values(): + if isinstance(ch.logical_channel, DcChannel): + self.configure_dc_line(ch.logical_channel, configs) + if isinstance(ch.logical_channel, IqChannel): + self.configure_iq_line(ch.logical_channel, configs) + if isinstance(ch.logical_channel, AcquisitionChannel): + self.configure_acquire_line(ch.logical_channel, configs) + self.device_setup.set_calibration(self.calibration) + + def configure_dc_line(self, channel: DcChannel, configs: dict[str, Config]): + signal = self.device_setup.logical_signal_by_uid(channel.name) + self.signal_map[channel.name] = signal + self.calibration[signal.name] = laboneq.SignalCalibration( + range=configs[channel.name].power_range, + port_delay=None, + delay_signal=0, + voltage_offset=configs[channel.name].offset, + ) + + def configure_iq_line(self, channel: IqChannel, configs: dict[str, Config]): + intermediate_frequency = ( + configs[channel.name].frequency - configs[channel.lo].frequency + ) + signal = self.device_setup.logical_signal_by_uid(channel.name) + self.signal_map[channel.name] = signal + self.calibration[signal.path] = laboneq.SignalCalibration( + oscillator=laboneq.Oscillator( + frequency=intermediate_frequency, + modulation_type=( + laboneq.ModulationType.HARDWARE + if channel.acquisition is None + else laboneq.ModulationType.SOFTWARE + ), + ), + local_oscillator=laboneq.Oscillator( + frequency=int(configs[channel.lo].frequency), + ), + range=configs[channel.name].power_range, + port_delay=None, + delay_signal=0, + ) + + def configure_acquire_line( + self, channel: AcquisitionChannel, configs: dict[str, Config] + ): + intermediate_frequency = ( + configs[channel.probe].frequency + - configs[self.channels[channel.probe].logical_channel.lo].frequency + ) + acquire_signal = self.device_setup.logical_signal_by_uid(channel.name) + self.signal_map[channel.name] = acquire_signal + + oscillator = laboneq.Oscillator( + frequency=intermediate_frequency, + modulation_type=laboneq.ModulationType.SOFTWARE, + ) + threshold = None + + # FIXME: + # if options.acquisition_type == AcquisitionType.DISCRIMINATION: + # if qubit.kernel is not None: + # # Kernels don't work with the software modulation on the acquire signal + # oscillator = None + # else: + # # To keep compatibility with angle and threshold discrimination (Remove when possible) + # threshold = qubit.threshold + + self.calibration[acquire_signal.path] = laboneq.SignalCalibration( + oscillator=oscillator, + range=configs[channel.name].power_range, + port_delay=self.time_of_flight * NANO_TO_SECONDS, + threshold=threshold, + ) + + def run_exp(self): + """ + Compilation settings, compilation step, execution step and data retrival + - Save a experiment Python object: + self.experiment.save("saved_exp") + - Save a experiment compiled experiment (): + self.exp.save("saved_exp") # saving compiled experiment + """ + compiled_experiment = self.session.compile( + self.experiment, compiler_settings=COMPILER_SETTINGS + ) + self.results = self.session.run(compiled_experiment) + + def experiment_flow( + self, + configs: dict[str, Config], + sequences: list[PulseSequence], + integration_setup, + options: ExecutionParameters, + ): + """Create the experiment object for the devices, following the steps + separated one on each method: + + Translation, Calibration, Experiment Definition. + + Args: + sequences: list of sequences to be played in the experiment. + options: execution options/parameters + """ + self.sequences = sequences + self.calibration_step(configs, options) + self.create_exp(integration_setup, options) + + def create_exp(self, integration_setup, options): + """Zurich experiment initialization using their Experiment class.""" + if self.acquisition_type: + acquisition_type = self.acquisition_type + else: + acquisition_type = ACQUISITION_TYPE[options.acquisition_type] + averaging_mode = AVERAGING_MODE[options.averaging_mode] + exp_options = options.copy( + update={ + "acquisition_type": acquisition_type, + "averaging_mode": averaging_mode, + } + ) + + signals = [laboneq.ExperimentSignal(name) for name in self.signal_map.keys()] + exp = laboneq.Experiment( + uid="Sequence", + signals=signals, + ) + + contexts = self._contexts(exp, exp_options) + self._populate_exp(exp, integration_setup, exp_options, contexts) + self.set_calibration_for_rt_sweep(exp) + exp.set_signal_map(self.signal_map) + self.experiment = exp + + def _contexts( + self, exp: laboneq.Experiment, exp_options: ExecutionParameters + ) -> list[tuple[Optional[Sweeper], Any]]: + """To construct a laboneq experiment, we need to first define a certain + sequence of nested contexts. + + This method returns the corresponding sequence of context + managers. + """ + sweep_contexts = [] + for i, sweeper in enumerate(self.nt_sweeps): + ctx = exp.sweep( + uid=f"nt_sweep_{sweeper.parameter.name.lower()}_{i}", + parameter=[ + sweep_param + for sweep_param in self.processed_sweeps.sweeps_for_sweeper(sweeper) + ], + ) + sweep_contexts.append((sweeper, ctx)) + + shots_ctx = exp.acquire_loop_rt( + uid="shots", + count=exp_options.nshots, + acquisition_type=exp_options.acquisition_type, + averaging_mode=exp_options.averaging_mode, + ) + sweep_contexts.append((None, shots_ctx)) + + for i, sweeper in enumerate(self.rt_sweeps): + ctx = exp.sweep( + uid=f"rt_sweep_{sweeper.parameter.name.lower()}_{i}", + parameter=[ + sweep_param + for sweep_param in self.processed_sweeps.sweeps_for_sweeper(sweeper) + ], + reset_oscillator_phase=True, + ) + sweep_contexts.append((sweeper, ctx)) + + return sweep_contexts + + def _populate_exp( + self, + exp: laboneq.Experiment, + integration_setup, + exp_options: ExecutionParameters, + contexts, + ): + """Recursively activate the nested contexts, then define the main + experiment body inside the innermost context.""" + if len(contexts) == 0: + self.select_exp(exp, integration_setup, exp_options) + return + + sweeper, ctx = contexts[0] + with ctx: + if sweeper in self.nt_sweeps: + self.set_instrument_nodes_for_nt_sweep(exp, sweeper) + self._populate_exp(exp, integration_setup, exp_options, contexts[1:]) + + def set_calibration_for_rt_sweep(self, exp: laboneq.Experiment) -> None: + """Set laboneq calibration of parameters that are to be swept in real- + time.""" + if self.processed_sweeps: + calib = laboneq.Calibration() + for ch in ( + set(chain(*(seq.keys() for seq in self.sequences))) + | self.processed_sweeps.channels_with_sweeps() + ): + for param, sweep_param in self.processed_sweeps.sweeps_for_channel(ch): + if param is Parameter.frequency: + calib[ch] = laboneq.SignalCalibration( + oscillator=laboneq.Oscillator( + frequency=sweep_param, + modulation_type=laboneq.ModulationType.HARDWARE, + ) + ) + exp.set_calibration(calib) + + def set_instrument_nodes_for_nt_sweep( + self, exp: laboneq.Experiment, sweeper: Sweeper + ) -> None: + """In some cases there is no straightforward way to sweep a parameter. + + In these cases we achieve sweeping by directly manipulating the + instrument nodes + """ + for ch, param, sweep_param in self.processed_sweeps.channel_sweeps_for_sweeper( + sweeper + ): + channel_node_path = self.get_channel_node_path(ch) + if param is Parameter.offset: + offset_node_path = f"{channel_node_path}/offset" + exp.set_node(path=offset_node_path, value=sweep_param) + + # This is supposed to happen only for measurement, but we do not validate it here. + if param is Parameter.amplitude: + a, b = re.match(r"(.*)/(\d)/.*", channel_node_path).groups() + gain_node_path = f"{a}/{b}/oscs/{b}/gain" + exp.set_node(path=gain_node_path, value=sweep_param) + + def get_channel_node_path(self, channel_name: str) -> str: + """Return the path of the instrument node corresponding to the given + channel.""" + logical_signal = self.signal_map[channel_name] + for instrument in self.device_setup.instruments: + for conn in instrument.connections: + if conn.remote_path == logical_signal.path: + return f"{instrument.address}/{conn.local_port}" + raise RuntimeError( + f"Could not find instrument node corresponding to channel {channel_name}" + ) + + def select_exp(self, exp, integration_setup, exp_options): + """Build Zurich Experiment selecting the relevant sections.""" + probe_channels = self._probe_channels() + kernels = {} + previous_section = None + for i, seq in enumerate(self.sequences): + other_channels = set(seq.keys()) - probe_channels + section_uid = f"sequence_{i}" + with exp.section(uid=section_uid, play_after=previous_section): + with exp.section(uid=f"sequence_{i}_control"): + for ch in other_channels: + for pulse in seq[ch]: + self.play_pulse( + exp, + ch, + pulse, + self.processed_sweeps.sweeps_for_pulse(pulse), + ) + for ch in set(seq.keys()) - other_channels: + for j, pulse in enumerate(seq[ch]): + with exp.section(uid=f"sequence_{i}_probe_{j}"): + acquisition_name = self.channels[ + ch + ].logical_channel.acquisition + + exp.delay( + signal=acquisition_name, + time=self.smearing * NANO_TO_SECONDS, + ) + + self.play_pulse( + exp, + ch, + pulse, + self.processed_sweeps.sweeps_for_pulse(pulse), + ) + exp.delay( + signal=acquisition_name, + time=self.time_of_flight * NANO_TO_SECONDS, + ) # FIXME + + kernel = kernels.setdefault( + acquisition_name, + self._construct_kernel( + acquisition_name, + integration_setup, + pulse.duration, + exp_options, + ), + ) + exp.acquire( + signal=acquisition_name, + handle=_acquisition_handle(i, j, acquisition_name), + kernel=kernel, + ) + if j == len(seq[ch]) - 1: + exp.delay( + signal=acquisition_name, + time=exp_options.relaxation_time * NANO_TO_SECONDS, + ) + + previous_section = section_uid + + def _construct_kernel( + self, + acquisition_name: str, + integration_setup: dict[str, tuple[np.ndarray, float]], + duration: float, + exp_options, + ): + kernel, iq_angle = integration_setup[acquisition_name] + if ( + kernel is not None + and exp_options.acquisition_type == laboneq.AcquisitionType.DISCRIMINATION + ): + return laboneq.pulse_library.sampled_pulse_complex( + samples=kernel * np.exp(1j * iq_angle), + ) + + else: + if exp_options.acquisition_type == laboneq.AcquisitionType.DISCRIMINATION: + return laboneq.pulse_library.sampled_pulse_complex( + samples=np.ones( + [int(duration * 2 - 3 * self.smearing * NANO_TO_SECONDS)] + ) + * np.exp(1j * iq_angle), + ) + else: + return laboneq.pulse_library.const( + length=round(duration * NANO_TO_SECONDS, 9) + - 1.5 * self.smearing * NANO_TO_SECONDS, + amplitude=1, + ) + + @staticmethod + def play_pulse( + exp, + channel: str, + pulse: Union[Pulse, Delay], + sweeps: list[tuple[Parameter, laboneq.SweepParameter]], + ): + """Play a pulse or delay by taking care of setting parameters to any + associated sweeps.""" + if isinstance(pulse, Delay): + duration = pulse.duration + for p, zhs in sweeps: + if p is Parameter.duration: + duration = zhs + else: + raise ValueError(f"Cannot sweep parameter {p} of a delay.") + exp.delay(signal=channel, time=duration) + elif isinstance(pulse, Pulse): + zhpulse = select_pulse(pulse) + play_parameters = {} + for p, zhs in sweeps: + if p is Parameter.amplitude: + max_value = max(np.abs(zhs.values)) + zhpulse.amplitude *= max_value + zhs.values /= max_value + play_parameters["amplitude"] = zhs + if p is Parameter.duration: + play_parameters["length"] = zhs + if p is Parameter.relative_phase: + play_parameters["phase"] = zhs + if "phase" not in play_parameters: + play_parameters["phase"] = pulse.relative_phase + exp.play(signal=channel, pulse=zhpulse, **play_parameters) + else: + raise ValueError(f"Cannot play pulse: {pulse}") + + def play( + self, + configs: dict[str, Config], + sequences: list[PulseSequence], + options, + integration_setup: dict[str, tuple[np.ndarray, float]], + *sweepers, + ): + """Play pulse and sweepers sequence.""" + + self.signal_map = {} + self.processed_sweeps = ProcessedSweeps(sweepers, self.channels, configs) + self.nt_sweeps, self.rt_sweeps = classify_sweepers(sweepers) + + self.acquisition_type = None + probe_channels = self._probe_channels() + for sweeper in sweepers: + if sweeper.parameter in {Parameter.frequency}: + for ch in sweeper.channels: + if ch in probe_channels: + self.acquisition_type = laboneq.AcquisitionType.SPECTROSCOPY + + self.experiment_flow(configs, sequences, integration_setup, options) + self.run_exp() + + # Get the results back + results = {} + for ch in probe_channels: + acquisition_name = self.channels[ch].logical_channel.acquisition + for i, seq in enumerate(self.sequences): + for j, ropulse in enumerate(seq[ch]): + handle = _acquisition_handle(i, j, acquisition_name) + data = self.results.get_data(handle) + + if options.acquisition_type is AcquisitionType.DISCRIMINATION: + data = ( + np.ones(data.shape) - data.real + ) # Probability inversion patch + + id_ = ropulse.id + results[id_] = options.results_type(data) + + return results diff --git a/src/qibolab/_core/instruments/zhinst/pulse.py b/src/qibolab/_core/instruments/zhinst/pulse.py new file mode 100644 index 0000000000..dab9c48aae --- /dev/null +++ b/src/qibolab/_core/instruments/zhinst/pulse.py @@ -0,0 +1,70 @@ +"""Wrapper for qibolab and laboneq pulses and sweeps.""" + +import laboneq.simple as laboneq +import numpy as np +from laboneq.dsl.experiment.pulse_library import ( + sampled_pulse_complex, + sampled_pulse_real, +) + +from qibolab._core.pulses import Drag, Gaussian, GaussianSquare, Pulse, Rectangular + +from .constants import NANO_TO_SECONDS, SAMPLING_RATE + + +def select_pulse(pulse: Pulse): + """Return laboneq pulse object corresponding to the given qibolab pulse.""" + if isinstance(pulse.envelope, Rectangular): + # FIXME: + # can_compress = pulse.type is not PulseType.READOUT + can_compress = False + return laboneq.pulse_library.const( + length=round(pulse.duration * NANO_TO_SECONDS, 9), + amplitude=pulse.amplitude, + can_compress=can_compress, + ) + if isinstance(pulse.envelope, Gaussian): + sigma = pulse.envelope.rel_sigma + return laboneq.pulse_library.gaussian( + length=round(pulse.duration * NANO_TO_SECONDS, 9), + amplitude=pulse.amplitude, + sigma=2 / sigma, + zero_boundaries=False, + ) + + if isinstance(pulse.envelope, GaussianSquare): + sigma = pulse.envelope.rel_sigma + width = pulse.envelope.width + # FIXME: + # can_compress = pulse.type is not PulseType.READOUT + can_compress = False + return laboneq.pulse_library.gaussian_square( + length=round(pulse.duration * NANO_TO_SECONDS, 9), + width=round(pulse.duration * NANO_TO_SECONDS, 9) * width, + amplitude=pulse.amplitude, + can_compress=can_compress, + sigma=2 / sigma, + zero_boundaries=False, + ) + + if isinstance(pulse.envelope, Drag): + sigma = pulse.envelope.rel_sigma + beta = pulse.envelope.beta + return laboneq.pulse_library.drag( + length=round(pulse.duration * NANO_TO_SECONDS, 9), + amplitude=pulse.amplitude, + sigma=2 / sigma, + beta=beta, + zero_boundaries=False, + ) + + if np.all(pulse.q(SAMPLING_RATE) == 0): + return sampled_pulse_real( + samples=pulse.i(SAMPLING_RATE), + can_compress=True, + ) + else: + return sampled_pulse_complex( + samples=pulse.i(SAMPLING_RATE) + (1j * pulse.q(SAMPLING_RATE)), + can_compress=True, + ) diff --git a/src/qibolab/_core/instruments/zhinst/sweep.py b/src/qibolab/_core/instruments/zhinst/sweep.py new file mode 100644 index 0000000000..6123c5d708 --- /dev/null +++ b/src/qibolab/_core/instruments/zhinst/sweep.py @@ -0,0 +1,129 @@ +"""Pre-execution processing of sweeps.""" + +from collections.abc import Iterable +from copy import copy + +import laboneq.simple as laboneq + +from qibolab._core.components import Config +from qibolab._core.pulses import Pulse +from qibolab._core.sweeper import Parameter, Sweeper + +from . import ZiChannel +from .constants import NANO_TO_SECONDS + + +def classify_sweepers( + sweepers: Iterable[Sweeper], +) -> tuple[list[Sweeper], list[Sweeper]]: + """Divide sweepers into two lists: 1. sweeps that can be done in the laboneq near-time sweep loop, 2. sweeps that + can be done in real-time (i.e. on hardware)""" + nt_sweepers, rt_sweepers = [], [] + for sweeper in sweepers: + if sweeper.parameter is Parameter.offset or ( + sweeper.parameter is Parameter.amplitude + # FIXME: + # and sweeper.pulses[0].type is PulseType.READOUT + and False + ): + nt_sweepers.append(sweeper) + else: + rt_sweepers.append(sweeper) + return nt_sweepers, rt_sweepers + + +class ProcessedSweeps: + """Data type that centralizes and allows extracting information about given + sweeps. + + In laboneq, sweeps are represented with the help of SweepParameter + instances. When adding pulses to a laboneq experiment, some + properties can be set to be an instance of SweepParameter instead of + a fixed numeric value. In case of channel property sweeps, either + the relevant calibration property or the instrument node directly + can be set ot a SweepParameter instance. Parts of the laboneq + experiment that define the sweep loops refer to SweepParameter + instances as well. These should be linkable to instances that are + either set to a pulse property, a channel calibration or instrument + node. To achieve this, we use the exact same SweepParameter instance + in both places. This class takes care of creating these + SweepParameter instances and giving access to them in a consistent + way (i.e. whenever they need to be the same instance they will be + the same instance). When constructing sweep loops you may ask from + this class to provide all the SweepParameter instances related to a + given qibolab Sweeper (parallel sweeps). Later, when adding pulses + or setting channel properties, you may ask from this class to + provide all SweepParameter instances related to a given pulse or + channel, and you will get parameters that are linkable to the ones + in the sweep loop definition + """ + + def __init__( + self, + sweepers: Iterable[Sweeper], + channels: dict[str, ZiChannel], + configs: dict[str, Config], + ): + pulse_sweeps = [] + channel_sweeps = [] + parallel_sweeps = [] + for sweeper in sweepers: + for pulse in sweeper.pulses or []: + if sweeper.parameter is Parameter.duration: + sweep_param = laboneq.SweepParameter( + values=sweeper.values * NANO_TO_SECONDS + ) + else: + sweep_param = laboneq.SweepParameter(values=copy(sweeper.values)) + pulse_sweeps.append((pulse, sweeper.parameter, sweep_param)) + parallel_sweeps.append((sweeper, sweep_param)) + + for ch in sweeper.channels or []: + logical_channel = channels[ch].logical_channel + if sweeper.parameter is Parameter.offset: + sweep_param = laboneq.SweepParameter( + values=sweeper.values + configs[logical_channel.name].offset + ) + elif sweeper.parameter is Parameter.frequency: + intermediate_frequency = ( + configs[logical_channel.name].frequency + - configs[logical_channel.lo].frequency + ) + sweep_param = laboneq.SweepParameter( + values=sweeper.values + intermediate_frequency + ) + else: + raise ValueError( + f"Sweeping {sweeper.parameter.name} for {ch} is not supported" + ) + channel_sweeps.append((ch, sweeper.parameter, sweep_param)) + parallel_sweeps.append((sweeper, sweep_param)) + + self._pulse_sweeps = pulse_sweeps + self._channel_sweeps = channel_sweeps + self._parallel_sweeps = parallel_sweeps + + def sweeps_for_pulse( + self, pulse: Pulse + ) -> list[tuple[Parameter, laboneq.SweepParameter]]: + return [item[1:] for item in self._pulse_sweeps if item[0] == pulse] + + def sweeps_for_channel( + self, ch: str + ) -> list[tuple[Parameter, laboneq.SweepParameter]]: + return [item[1:] for item in self._channel_sweeps if item[0] == ch] + + def sweeps_for_sweeper(self, sweeper: Sweeper) -> list[laboneq.SweepParameter]: + return [item[1] for item in self._parallel_sweeps if item[0] == sweeper] + + def channel_sweeps_for_sweeper( + self, sweeper: Sweeper + ) -> list[tuple[str, Parameter, laboneq.SweepParameter]]: + return [ + item + for item in self._channel_sweeps + if item[2] in self.sweeps_for_sweeper(sweeper) + ] + + def channels_with_sweeps(self) -> set[str]: + return {ch for ch, _, _ in self._channel_sweeps} diff --git a/src/qibolab/_core/native.py b/src/qibolab/_core/native.py new file mode 100644 index 0000000000..fd1131f0bc --- /dev/null +++ b/src/qibolab/_core/native.py @@ -0,0 +1,100 @@ +from copy import deepcopy +from typing import Annotated, Optional + +import numpy as np + +from .pulses import Pulse +from .sequence import PulseSequence +from .serialize import Model, replace + + +class Native(PulseSequence): + def create_sequence(self) -> PulseSequence: + """Create the sequence associated to the gate.""" + return deepcopy(self) + + def __call__(self, *args, **kwargs) -> PulseSequence: + """Create the sequence associated to the gate. + + Alias to :meth:`create_sequence`. + """ + return self.create_sequence(*args, **kwargs) + + +def _normalize_angles(theta, phi): + """Normalize theta to (-pi, pi], and phi to [0, 2*pi).""" + theta = theta % (2 * np.pi) + theta = theta - 2 * np.pi * (theta > np.pi) + phi = phi % (2 * np.pi) + return theta, phi + + +def rotation( + seq: PulseSequence, theta: float = np.pi, phi: float = 0.0 +) -> PulseSequence: + """Create a sequence for single-qubit rotation. + + ``theta`` will be the angle of the rotation, while ``phi`` the angle that the rotation axis forms with x axis. + """ + theta, phi = _normalize_angles(theta, phi) + ch, pulse = seq[0] + assert isinstance(pulse, Pulse) + new_amplitude = pulse.amplitude * theta / np.pi + return PulseSequence( + [(ch, replace(pulse, amplitude=new_amplitude, relative_phase=phi))] + ) + + +class MissingNative(RuntimeError): + """Missing native gate.""" + + def __init__(self, gate: str): + super().__init__(f"Native gate definition not found, for gate {gate}") + + +class NativeContainer(Model): + def ensure(self, name: str) -> Native: + value = getattr(self, name) + if value is None: + raise MissingNative(value) + return value + + +class SingleQubitNatives(NativeContainer): + """Container with the native single-qubit gates acting on a specific + qubit.""" + + RX: Optional[Native] = None + """Pulse to drive the qubit from state 0 to state 1.""" + RX12: Optional[Native] = None + """Pulse to drive to qubit from state 1 to state 2.""" + MZ: Optional[Native] = None + """Measurement pulse.""" + CP: Optional[Native] = None + """Pulse to activate coupler.""" + + def R(self, theta: float = np.pi, phi: float = 0.0) -> PulseSequence: + """Create a sequence for single-qubit rotation. + + ``theta`` will be the angle of the rotation, while ``phi`` the angle that the rotation axis forms with x axis. + """ + assert self.RX is not None + return rotation(self.RX, theta, phi) + + +class TwoQubitNatives(NativeContainer): + """Container with the native two-qubit gates acting on a specific pair of + qubits.""" + + CZ: Annotated[Optional[Native], {"symmetric": True}] = None + CNOT: Annotated[Optional[Native], {"symmetric": False}] = None + iSWAP: Annotated[Optional[Native], {"symmetric": True}] = None + + @property + def symmetric(self): + """Check if the defined two-qubit gates are symmetric between target + and control qubits.""" + return all( + info.metadata[0]["symmetric"] or getattr(self, fld) is None + for fld, info in self.model_fields.items() + ) diff --git a/src/qibolab/_core/parameters.py b/src/qibolab/_core/parameters.py new file mode 100644 index 0000000000..1ad0957cd0 --- /dev/null +++ b/src/qibolab/_core/parameters.py @@ -0,0 +1,181 @@ +"""Helper methods for (de)serializing parameters. + +The format is explained in the :ref:`Loading platform parameters from +JSON ` example. +""" + +from collections.abc import Callable, Iterable +from typing import Annotated, Any, Union + +from pydantic import BeforeValidator, Field, PlainSerializer, TypeAdapter +from pydantic_core import core_schema + +from .components import ChannelConfig, Config +from .execution_parameters import ConfigUpdate, ExecutionParameters +from .identifier import QubitId, QubitPairId +from .native import SingleQubitNatives, TwoQubitNatives +from .serialize import Model, replace +from .unrolling import Bounds + +__all__ = ["ConfigKinds"] + + +def update_configs(configs: dict[str, Config], updates: list[ConfigUpdate]): + """Apply updates to configs in place. + + Args: + configs: configs to update. Maps component name to respective config. + updates: list of config updates. Later entries in the list take precedence over earlier entries + (if they happen to update the same thing). + """ + for update in updates: + for name, changes in update.items(): + if name not in configs: + raise ValueError( + f"Cannot update configuration for unknown component {name}" + ) + configs[name] = replace(configs[name], **changes) + + +class Settings(Model): + """Default platform execution settings.""" + + nshots: int = 1000 + """Default number of repetitions when executing a pulse sequence.""" + relaxation_time: int = int(1e5) + """Time in ns to wait for the qubit to relax to its ground state between + shots.""" + + def fill(self, options: ExecutionParameters): + """Use default values for missing execution options.""" + if options.nshots is None: + options = replace(options, nshots=self.nshots) + + if options.relaxation_time is None: + options = replace(options, relaxation_time=self.relaxation_time) + + return options + + +class TwoQubitContainer(dict[QubitPairId, TwoQubitNatives]): + @classmethod + def __get_pydantic_core_schema__( + cls, source_type: Any, handler: Callable[[Any], core_schema.CoreSchema] + ) -> core_schema.CoreSchema: + schema = handler(dict[QubitPairId, TwoQubitNatives]) + return core_schema.no_info_after_validator_function( + cls._validate, + schema, + serialization=core_schema.plain_serializer_function_ser_schema( + cls._serialize, info_arg=False + ), + ) + + @classmethod + def _validate(cls, value): + return cls(value) + + @staticmethod + def _serialize(value): + return TypeAdapter(dict[QubitPairId, TwoQubitNatives]).dump_python(value) + + def __getitem__(self, key: QubitPairId): + try: + return super().__getitem__(key) + except KeyError: + value = super().__getitem__((key[1], key[0])) + if value.symmetric: + return value + raise + + +class NativeGates(Model): + """Native gates parameters. + + This is a container for the parameters of the whole platform. + """ + + single_qubit: dict[QubitId, SingleQubitNatives] = Field(default_factory=dict) + coupler: dict[QubitId, SingleQubitNatives] = Field(default_factory=dict) + two_qubit: TwoQubitContainer = Field(default_factory=dict) + + +ComponentId = str +"""Identifier of a generic component. + +This is assumed to always be in its serialized form. +""" + +# TODO: replace _UnionType with UnionType, once py3.9 will be abandoned +_UnionType = Any +_ChannelConfigT = Union[_UnionType, type[Config]] +_BUILTIN_CONFIGS: tuple[_ChannelConfigT, ...] = (ChannelConfig, Bounds) + + +class ConfigKinds: + """Registered configuration kinds. + + This class is handling the known configuration kinds for deserialization. + + .. attention:: + + Beware that is managing a global state. This should not be a major issue, as the + known configurations should be fixed per run. But prefer avoiding changing them + during a single session, unless you are clearly controlling the sequence of all + loading operations. + """ + + _registered: list[_ChannelConfigT] = list(_BUILTIN_CONFIGS) + + @classmethod + def extend(cls, kinds: Iterable[_ChannelConfigT]): + """Extend the known configuration kinds. + + Nested unions are supported (i.e. :class:`Union` as elements of ``kinds``). + """ + cls._registered.extend(kinds) + + @classmethod + def reset(cls): + """Reset known configuration kinds to built-ins.""" + cls._registered = list(_BUILTIN_CONFIGS) + + @classmethod + def registered(cls) -> list[_ChannelConfigT]: + """Retrieve registered configuration kinds.""" + return cls._registered.copy() + + @classmethod + def adapted(cls) -> TypeAdapter: + """Construct tailored pydantic type adapter. + + The adapter will be able to directly load all the registered + configuration kinds as the appropriate Python objects. + """ + return TypeAdapter( + Annotated[ + Union[tuple(ConfigKinds._registered)], Field(discriminator="kind") + ] + ) + + +def _load_configs(raw: dict[str, dict]) -> dict[ComponentId, Config]: + a = ConfigKinds.adapted() + return {k: a.validate_python(v) for k, v in raw.items()} + + +def _dump_configs(obj: dict[ComponentId, Config]) -> dict[str, dict]: + a = ConfigKinds.adapted() + return {k: a.dump_python(v) for k, v in obj.items()} + + +class Parameters(Model): + """Serializable parameters.""" + + settings: Settings = Field(default_factory=Settings) + configs: Annotated[ + dict[ComponentId, Config], + BeforeValidator(_load_configs), + PlainSerializer(_dump_configs), + ] = Field(default_factory=dict) + native_gates: NativeGates = Field(default_factory=NativeGates) diff --git a/src/qibolab/_core/platform/__init__.py b/src/qibolab/_core/platform/__init__.py new file mode 100644 index 0000000000..15b665f43c --- /dev/null +++ b/src/qibolab/_core/platform/__init__.py @@ -0,0 +1,7 @@ +from . import load, platform +from .load import * +from .platform import * + +__all__ = [] +__all__ += load.__all__ +__all__ += platform.__all__ diff --git a/src/qibolab/platform/load.py b/src/qibolab/_core/platform/load.py similarity index 71% rename from src/qibolab/platform/load.py rename to src/qibolab/_core/platform/load.py index 8faf0ba388..effe85e5d8 100644 --- a/src/qibolab/platform/load.py +++ b/src/qibolab/_core/platform/load.py @@ -1,13 +1,15 @@ import importlib.util import os from pathlib import Path +from typing import Optional from qibo.config import raise_error -from qibolab.serialize import PLATFORM - from .platform import Platform +__all__ = ["create_platform", "locate_platform"] + +PLATFORM = "platform.py" PLATFORMS = "QIBOLAB_PLATFORMS" @@ -25,7 +27,7 @@ def _platforms_paths() -> list[Path]: def _search(name: str, paths: list[Path]) -> Path: """Search paths for given platform name.""" - for path in _platforms_paths(): + for path in paths: platform = path / name if platform.exists(): return platform @@ -45,21 +47,35 @@ def _load(platform: Path) -> Platform: return module.create() +def locate_platform(name: str, paths: Optional[list[Path]] = None) -> Path: + """Locate platform's path. + + The ``name`` corresponds to the name of the folder in which the platform is defined, + i.e. the one containing the ``platform.py`` file. + + If ``paths`` are specified, the environment is ignored, and the folder search + happens only in the specified paths. + """ + if paths is None: + paths = _platforms_paths() + return _search(name, paths) + + def create_platform(name: str) -> Platform: """A platform for executing quantum algorithms. It consists of a quantum processor QPU and a set of controlling instruments. Args: - name (str): name of the platform. Options are 'tiiq', 'qili' and 'icarusq'. + name (str): name of the platform. path (pathlib.Path): path with platform serialization Returns: The plaform class. """ - if name == "dummy" or name == "dummy_couplers": - from qibolab.dummy import create_dummy + if name == "dummy": + from qibolab._core.dummy import create_dummy - return create_dummy(with_couplers=name == "dummy_couplers") + return create_dummy() return _load(_search(name, _platforms_paths())) diff --git a/src/qibolab/_core/platform/platform.py b/src/qibolab/_core/platform/platform.py new file mode 100644 index 0000000000..218fbdb0e3 --- /dev/null +++ b/src/qibolab/_core/platform/platform.py @@ -0,0 +1,339 @@ +"""A platform for executing quantum algorithms.""" + +from dataclasses import dataclass, field +from math import prod +from pathlib import Path +from typing import Literal, Optional, TypeVar + +from qibo.config import log, raise_error + +from ..components import Config +from ..components.channels import Channel +from ..execution_parameters import ExecutionParameters +from ..identifier import ChannelId, QubitId, QubitPairId, Result +from ..instruments.abstract import Controller, Instrument, InstrumentId +from ..parameters import NativeGates, Parameters, Settings, update_configs +from ..pulses import PulseId +from ..qubits import Qubit +from ..sequence import PulseSequence +from ..sweeper import ParallelSweepers +from ..unrolling import Bounds, batch + +__all__ = ["Platform"] + +QubitMap = dict[QubitId, Qubit] +QubitPairMap = list[QubitPairId] +InstrumentMap = dict[InstrumentId, Instrument] + +NS_TO_SEC = 1e-9 +PARAMETERS = "parameters.json" + +# TODO: replace with https://docs.python.org/3/reference/compound_stmts.html#type-params +T = TypeVar("T") + + +# TODO: lift for general usage in Qibolab +def default(value: Optional[T], default: T) -> T: + """None replacement shortcut.""" + return value if value is not None else default + + +def _channels_map(elements: QubitMap) -> dict[ChannelId, QubitId]: + """Map channel names to element (qubit or coupler).""" + return {ch: id for id, el in elements.items() for ch in el.channels} + + +def estimate_duration( + sequences: list[PulseSequence], + options: ExecutionParameters, + sweepers: list[ParallelSweepers], +) -> float: + """Estimate experiment duration.""" + duration = sum(seq.duration for seq in sequences) + relaxation = default(options.relaxation_time, 0) + nshots = default(options.nshots, 0) + return ( + (duration + len(sequences) * relaxation) + * nshots + * NS_TO_SEC + * prod(len(s[0].values) for s in sweepers) + ) + + +def _unique_acquisitions(sequences: list[PulseSequence]) -> bool: + """Check unique acquisition identifiers.""" + ids = [] + for seq in sequences: + ids += (p.id for _, p in seq.acquisitions) + + return len(ids) == len(set(ids)) + + +@dataclass +class Platform: + """Platform for controlling quantum devices.""" + + name: str + """Name of the platform.""" + parameters: Parameters + """...""" + instruments: InstrumentMap + """Mapping instrument names to + :class:`qibolab.instruments.abstract.Instrument` objects.""" + qubits: QubitMap + """Qubit controllers. + + The mapped objects hold the :class:`qubit.components.channels.Channel` instances + required to send pulses addressing the desired qubits. + """ + couplers: QubitMap = field(default_factory=dict) + """Coupler controllers. + + Fully analogue to :attr:`qubits`. Only the flux channel is expected to be populated + in the mapped objects. + """ + resonator_type: Literal["2D", "3D"] = "2D" + """Type of resonator (2D or 3D) in the used QPU.""" + is_connected: bool = False + """Flag for whether we are connected to the physical instruments.""" + + def __post_init__(self): + log.info("Loading platform %s", self.name) + if self.resonator_type is None: + self.resonator_type = "3D" if self.nqubits == 1 else "2D" + + def __str__(self): + return self.name + + @property + def nqubits(self) -> int: + """Total number of usable qubits in the QPU.""" + return len(self.qubits) + + @property + def pairs(self) -> list[QubitPairId]: + """Available pairs in thee platform.""" + return list(self.parameters.native_gates.two_qubit) + + @property + def ordered_pairs(self): + """List of qubit pairs that are connected in the QPU.""" + return sorted({tuple(sorted(pair)) for pair in self.pairs}) + + @property + def settings(self) -> Settings: + """Container with default execution settings.""" + return self.parameters.settings + + @property + def natives(self) -> NativeGates: + """Native gates containers.""" + return self.parameters.native_gates + + @property + def sampling_rate(self): + """Sampling rate of control electronics in giga samples per second + (GSps).""" + for instrument in self.instruments.values(): + if isinstance(instrument, Controller): + return instrument.sampling_rate + + @property + def components(self) -> set[str]: + """Names of all components available in the platform.""" + return set(self.parameters.configs.keys()) + + @property + def channels(self) -> dict[ChannelId, Channel]: + """Channels in the platform.""" + return { + id: ch + for instr in self.instruments.values() + if isinstance(instr, Controller) + for id, ch in instr.channels.items() + } + + @property + def qubit_channels(self) -> dict[ChannelId, QubitId]: + """Channel to qubit map.""" + return _channels_map(self.qubits) + + @property + def coupler_channels(self): + """Channel to coupler map.""" + return _channels_map(self.couplers) + + def config(self, name: str) -> Config: + """Returns configuration of given component.""" + # pylint: disable=unsubscriptable-object + return self.parameters.configs[name] + + def connect(self): + """Connect to all instruments.""" + if not self.is_connected: + for name, instrument in self.instruments.items(): + try: + instrument.connect() + except Exception as exception: + raise_error( + RuntimeError, + f"Cannot establish connection to instrument {name}. Error captured: '{exception}'", + ) + self.is_connected = True + + def disconnect(self): + """Disconnects from instruments.""" + if self.is_connected: + for instrument in self.instruments.values(): + instrument.disconnect() + self.is_connected = False + + @property + def _controller(self): + """Identify controller instrument. + + Used for splitting the unrolled sequences to batches. + + This method does not support platforms with more than one + controller instruments. + """ + controllers = [ + instr + for instr in self.instruments.values() + if isinstance(instr, Controller) + ] + assert len(controllers) == 1 + return controllers[0] + + def _execute( + self, + sequences: list[PulseSequence], + options: ExecutionParameters, + configs: dict[str, Config], + sweepers: list[ParallelSweepers], + ) -> dict[PulseId, Result]: + """Execute sequences on the controllers.""" + result = {} + + for instrument in self.instruments.values(): + if isinstance(instrument, Controller): + new_result = instrument.play(configs, sequences, options, sweepers) + if isinstance(new_result, dict): + result.update(new_result) + + return result + + def execute( + self, + sequences: list[PulseSequence], + sweepers: Optional[list[ParallelSweepers]] = None, + **options, + ) -> dict[PulseId, Result]: + """Execute pulse sequences. + + If any sweeper is passed, the execution is performed for the different values + of sweeped parameters. + + Returns readout results acquired by after execution. + + Example: + .. testcode:: + + import numpy as np + from qibolab import Parameter, PulseSequence, Sweeper, create_dummy + + + platform = create_dummy() + qubit = platform.qubits[0] + natives = platform.natives.single_qubit[0] + sequence = natives.MZ.create_sequence() + parameter_range = np.random.randint(10, size=10) + sweeper = [ + Sweeper( + parameter=Parameter.frequency, + values=parameter_range, + channels=[qubit.probe], + ) + ] + platform.execute([sequence], [sweeper]) + """ + if sweepers is None: + sweepers = [] + if not _unique_acquisitions(sequences): + raise ValueError( + "The acquisitions' identifiers have to be unique across all sequences." + ) + + options = self.settings.fill(ExecutionParameters(**options)) + + time = estimate_duration(sequences, options, sweepers) + log.info(f"Minimal execution time: {time}") + + configs = self.parameters.configs.copy() + update_configs(configs, options.updates) + + # for components that represent aux external instruments (e.g. lo) to the main + # control instrument set the config directly + for name, cfg in configs.items(): + if name in self.instruments: + self.instruments[name].setup(**cfg.model_dump(exclude={"kind"})) + + results = {} + # pylint: disable=unsubscriptable-object + bounds = self.parameters.configs[self._controller.bounds] + assert isinstance(bounds, Bounds) + for b in batch(sequences, bounds): + results |= self._execute(b, options, configs, sweepers) + + return results + + @classmethod + def load( + cls, + path: Path, + instruments: InstrumentMap, + qubits: QubitMap, + couplers: Optional[QubitMap] = None, + name: Optional[str] = None, + ) -> "Platform": + """Dump platform.""" + if name is None: + name = path.name + if couplers is None: + couplers = {} + + return cls( + name=name, + parameters=Parameters.model_validate_json((path / PARAMETERS).read_text()), + instruments=instruments, + qubits=qubits, + couplers=couplers, + ) + + def dump(self, path: Path): + """Dump platform.""" + (path / PARAMETERS).write_text(self.parameters.model_dump_json(indent=4)) + + def _element(self, qubit: QubitId, coupler=False) -> tuple[QubitId, Qubit]: + elements = self.qubits if not coupler else self.couplers + try: + return qubit, elements[qubit] + except KeyError: + assert isinstance(qubit, int) + return list(self.qubits.items())[qubit] + + def qubit(self, qubit: QubitId) -> tuple[QubitId, Qubit]: + """Retrieve physical qubit name and object. + + Temporary fix for the compiler to work for platforms where the + qubits are not named as 0, 1, 2, ... + """ + return self._element(qubit) + + def coupler(self, coupler: QubitId) -> tuple[QubitId, Qubit]: + """Retrieve physical coupler name and object. + + Temporary fix for the compiler to work for platforms where the + couplers are not named as 0, 1, 2, ... + """ + return self._element(coupler, coupler=True) diff --git a/src/qibolab/_core/pulses/__init__.py b/src/qibolab/_core/pulses/__init__.py new file mode 100644 index 0000000000..7c402aefd1 --- /dev/null +++ b/src/qibolab/_core/pulses/__init__.py @@ -0,0 +1,7 @@ +from . import envelope, pulse +from .envelope import * +from .pulse import * + +__all__ = [] +__all__ += envelope.__all__ +__all__ += pulse.__all__ diff --git a/src/qibolab/_core/pulses/envelope.py b/src/qibolab/_core/pulses/envelope.py new file mode 100644 index 0000000000..24f1083c08 --- /dev/null +++ b/src/qibolab/_core/pulses/envelope.py @@ -0,0 +1,391 @@ +"""Library of pulse envelopes.""" + +from abc import ABC +from typing import Annotated, Literal, Union + +import numpy as np +import numpy.typing as npt +from pydantic import Field +from scipy.signal import lfilter +from scipy.signal.windows import gaussian + +from ..serialize import Model, NdArray, eq + +__all__ = [ + "Waveform", + "IqWaveform", + "BaseEnvelope", + "Envelope", + "Rectangular", + "Exponential", + "Gaussian", + "GaussianSquare", + "Drag", + "Iir", + "Snz", + "ECap", + "Custom", +] + + +# TODO: they could be distinguished among them, and distinguished from generic float +# arrays, using the NewType pattern -> but this require some more effort to encforce +# types throughout the whole code base +Waveform = npt.NDArray[np.float64] +"""Single component waveform, either I (in-phase) or Q (quadrature).""" +IqWaveform = npt.NDArray[np.float64] +"""Full shape, both I and Q components.""" + + +class BaseEnvelope(ABC, Model): + """Pulse envelopes. + + Generates both i (in-phase) and q (quadrature) components. + """ + + def i(self, samples: int) -> Waveform: + """In-phase envelope.""" + return np.zeros(samples) + + def q(self, samples: int) -> Waveform: + """Quadrature envelope.""" + return np.zeros(samples) + + def envelopes(self, samples: int) -> IqWaveform: + """Stacked i and q envelope waveforms of the pulse.""" + return np.array([self.i(samples), self.q(samples)]) + + +class Rectangular(BaseEnvelope): + """Rectangular envelope.""" + + kind: Literal["rectangular"] = "rectangular" + + def i(self, samples: int) -> Waveform: + """Generate a rectangular envelope.""" + return np.ones(samples) + + +class Exponential(BaseEnvelope): + r"""Exponential shape, i.e. square pulse with an exponential decay. + + .. math:: + + \frac{\exp\left(-\frac{x}{\text{upsilon}}\right) + g \exp\left(-\frac{x}{\text{tau}}\right)}{1 + g} + """ + + kind: Literal["exponential"] = "exponential" + + tau: float + """The decay rate of the first exponential function. + + In units of the interval duration. + """ + upsilon: float + """The decay rate of the second exponential function. + + In units of the interval duration. + """ + g: float = 0.1 + """Weight of the second exponential function.""" + + def i(self, samples: int) -> Waveform: + """Generate a combination of two exponential decays.""" + x = np.arange(samples) + upsilon = self.upsilon * samples + tau = self.tau * samples + return (np.exp(-x / upsilon) + self.g * np.exp(-x / tau)) / (1 + self.g) + + +def _samples_sigma(rel_sigma: float, samples: int) -> float: + """Convert standard deviation in samples. + + `rel_sigma` is assumed in units of the interval duration, and it is turned in units + of samples, by counting the number of samples in the interval. + """ + return rel_sigma * samples + + +class Gaussian(BaseEnvelope): + r"""Gaussian pulse shape. + + Args: + rel_sigma (float): + + .. math:: + + A\exp^{-\frac{1}{2}\frac{(t-\mu)^2}{\sigma^2}} + """ + + kind: Literal["gaussian"] = "gaussian" + + rel_sigma: float + """Relative Gaussian standard deviation. + + In units of the interval duration. + """ + + def i(self, samples: int) -> Waveform: + """Generate a Gaussian window.""" + return gaussian(samples, _samples_sigma(self.rel_sigma, samples)) + + +class GaussianSquare(BaseEnvelope): + r"""Rectangular envelope with Gaussian rise and fall. + + .. math:: + + A\exp^{-\frac{1}{2}\frac{(t-\mu)^2}{\sigma^2}}[Rise] + Flat + A\exp^{-\frac{1}{2}\frac{(t-\mu)^2}{\sigma^2}}[Decay] + """ + + kind: Literal["gaussian_square"] = "gaussian_square" + + rel_sigma: float + """Relative Gaussian standard deviation. + + In units of the interval duration. + """ + width: float + """Length of the flat portion.""" + + def i(self, samples: int) -> Waveform: + """Generate a Gaussian envelope, with a flat central window.""" + + pulse = np.ones(samples) + u, hw = samples / 2, self.width / 2 + ts = np.arange(samples) + tails = (ts < (u - hw)) | ((u + hw) < ts) + pulse[tails] = gaussian(len(ts[tails]), _samples_sigma(self.rel_sigma, samples)) + + return pulse + + +class Drag(BaseEnvelope): + """Derivative Removal by Adiabatic Gate (DRAG) pulse envelope. + + .. todo:: + + - add expression + - add reference + """ + + kind: Literal["drag"] = "drag" + + rel_sigma: float + """Relative Gaussian standard deviation. + + In units of the interval duration. + """ + beta: float + """Beta. + + .. todo:: + + Add docstring + """ + + def i(self, samples: int) -> Waveform: + """Generate a Gaussian envelope.""" + return gaussian(samples, _samples_sigma(self.rel_sigma, samples)) + + def q(self, samples: int) -> Waveform: + """Generate ... + + .. todo:: + + Add docstring + """ + ts = np.arange(samples) + mu = (samples - 1) / 2 + sigma = _samples_sigma(self.rel_sigma, samples) + return self.beta * (-(ts - mu) / (sigma**2)) * self.i(samples) + + +class Iir(BaseEnvelope): + """IIR Filter using scipy.signal lfilter. + + https://arxiv.org/pdf/1907.04818.pdf (page 11 - filter formula S22):: + + p = [A, tau_iir] + p = [b0 = 1−k +k ·α, b1 = −(1−k)·(1−α),a0 = 1 and a1 = −(1−α)] + p = [b0, b1, a0, a1] + """ + + kind: Literal["iir"] = "iir" + + a: NdArray + b: NdArray + target: BaseEnvelope + + def _data(self, target: npt.NDArray) -> npt.NDArray: + a = self.a / self.a[0] + gain = np.sum(self.b) / np.sum(a) + b = self.b / gain if gain != 0 else self.b + + data = lfilter(b=b, a=a, x=target) + if np.max(np.abs(data)) != 0: + data /= np.max(np.abs(data)) + return data + + def i(self, samples: int) -> Waveform: + """I. + + .. todo:: + + Add docstring + """ + return self._data(self.target.i(samples)) + + def q(self, samples: int) -> Waveform: + """Q. + .. todo:: + + Add docstring + """ + return self._data(self.target.q(samples)) + + def __eq__(self, other) -> bool: + """Eq. + + .. todo:: + + Add docstring + """ + return eq(self, other) + + +class Snz(BaseEnvelope): + """Sudden variant Net Zero. + + https://arxiv.org/abs/2008.07411 + (Supplementary materials: FIG. S1.) + + .. todo:: + + - expression + """ + + kind: Literal["snz"] = "snz" + + t_idling: float + """Fraction of interval where idling.""" + b_amplitude: float = 0.5 + """Relative B amplitude (wrt A).""" + + def i(self, samples: int) -> Waveform: + """I. + + .. todo:: + + Add docstring + """ + # convert timings to samples + half_pulse_duration = (1 - self.t_idling) * samples / 2 + aspan = np.sum(np.arange(samples) < half_pulse_duration) + idle = samples - 2 * (aspan + 1) + + pulse = np.ones(samples) + # the aspan + 1 sample is B (and so the aspan + 1 + idle + 1), indexes are 0-based + pulse[aspan] = pulse[aspan + 1 + idle] = self.b_amplitude + # set idle time to 0 + pulse[aspan + 1 : aspan + 1 + idle] = 0 + return pulse + + +class ECap(BaseEnvelope): + r"""ECap pulse envelope. + + .. todo:: + + - add reference + + .. math:: + + e_{\cap(t,\alpha)} &=& A[1 + \tanh(\alpha t/t_\theta)][1 + \tanh(\alpha (1 - t/t_\theta))]\\ + &\times& [1 + \tanh(\alpha/2)]^{-2} + """ + + kind: Literal["ecap"] = "ecap" + + alpha: float + """In units of the inverse interval duration.""" + + def i(self, samples: int) -> Waveform: + """I. + + .. todo:: + + Add docstring + """ + ss = np.arange(samples) + x = ss / samples + return ( + (1 + np.tanh(self.alpha * ss)) + * (1 + np.tanh(self.alpha * (1 - x))) + / (1 + np.tanh(self.alpha / 2)) ** 2 + ) + + +class Custom(BaseEnvelope): + """Arbitrary envelope. + + .. todo:: + + - expand description + - add attribute docstrings + """ + + kind: Literal["custom"] = "custom" + + i_: npt.NDArray + q_: npt.NDArray + + def i(self, samples: int) -> Waveform: + """I. + + .. todo:: + + Add docstring + """ + if len(self.i_) != samples: + raise ValueError + + return self.i_ + + def q(self, samples: int) -> Waveform: + """Q. + + .. todo:: + + Add docstring + """ + if len(self.q_) != samples: + raise ValueError + + return self.q_ + + def __eq__(self, other) -> bool: + """Eq. + + .. todo:: + + Add docstring + """ + return eq(self, other) + + +Envelope = Annotated[ + Union[ + Rectangular, + Exponential, + Gaussian, + GaussianSquare, + Drag, + Iir, + Snz, + ECap, + Custom, + ], + Field(discriminator="kind"), +] +"""Available pulse shapes.""" diff --git a/src/qibolab/_core/pulses/modulation.py b/src/qibolab/_core/pulses/modulation.py new file mode 100644 index 0000000000..2088ba6a43 --- /dev/null +++ b/src/qibolab/_core/pulses/modulation.py @@ -0,0 +1,75 @@ +import numpy as np + +from .envelope import IqWaveform + +__all__ = ["wrap_phase", "rotate", "modulate", "demodulate"] + + +def wrap_phase(phase: float): + """Limit phase to [0, 2pi).""" + return phase % (2 * np.pi) + + +def rotate(envelope: IqWaveform, phase: float) -> IqWaveform: + """Rotate envelopes in the IQ-plane according to a phase.""" + wrapped_phase = wrap_phase(phase) + cos = np.cos(wrapped_phase) + sin = np.sin(wrapped_phase) + mod = np.array([[cos, -sin], [sin, cos]]) + return np.einsum("ij,jt->it", mod, envelope) + + +def modulate( + envelope: IqWaveform, + freq: float, + rate: float, + phase: float = 0.0, +) -> IqWaveform: + """Modulate the envelope waveform with a carrier. + + `envelope` is a `(2, n)`-shaped array of I and Q (first dimension) envelope signals, + as a function of time (second dimension), and `freq` the frequency of the carrier to + modulate with (usually the IF) in GHz. + `rate` is an optional sampling rate, in Gs/s, to sample the carrier. + + .. note:: + + Only the combination `freq / rate` is actually relevant, but it is frequently + convenient to specify one in GHz and the other in Gs/s. Thus the two arguments + are provided for the simplicity of their interpretation. + + `phase` is an optional initial phase for the carrier. + """ + samples = np.arange(envelope.shape[1]) + phases = (2 * np.pi * freq / rate) * samples + phase + cos = np.cos(phases) + sin = np.sin(phases) + mod = np.array([[cos, -sin], [sin, cos]]) + + # the normalization is related to `mod`, but only applied at the end for the sake of + # performances + return np.einsum("ijt,jt->it", mod, envelope) / np.sqrt(2) + + +def demodulate( + modulated: IqWaveform, + freq: float, + rate: float, +) -> IqWaveform: + """Demodulate the acquired pulse. + + The role of the arguments is the same of the corresponding ones in :func:`modulate`, + which is essentially the inverse of this function. + """ + # in case the offsets have not been removed in hardware + modulated = modulated - np.mean(modulated) + + samples = np.arange(modulated.shape[1]) + phases = (2 * np.pi * freq / rate) * samples + cos = np.cos(phases) + sin = np.sin(phases) + demod = np.array([[cos, sin], [-sin, cos]]) + + # the normalization is related to `demod`, but only applied at the end for the sake + # of performances + return np.sqrt(2) * np.einsum("ijt,jt->it", demod, modulated) diff --git a/src/qibolab/_core/pulses/plot.py b/src/qibolab/_core/pulses/plot.py new file mode 100644 index 0000000000..d169a21107 --- /dev/null +++ b/src/qibolab/_core/pulses/plot.py @@ -0,0 +1,200 @@ +"""Plotting tools for pulses and related entities.""" + +from collections import defaultdict +from typing import Optional + +import matplotlib.pyplot as plt +import numpy as np + +from qibolab._core.sequence import PulseSequence + +from .envelope import Waveform +from .modulation import modulate +from .pulse import Delay, Pulse, VirtualZ + +SAMPLING_RATE = 1 +"""Default sampling rate in gigasamples per second (GSps). + +Used for generating waveform envelopes if the instruments do not provide +a different value. +""" + + +def waveform(wf: Waveform, filename=None): + """Plot the waveform. + + Args: + filename (str): a file path. If provided the plot is save to a file. + """ + plt.figure(figsize=(14, 5), dpi=200) + plt.plot(wf, c="C0", linestyle="dashed") + plt.xlabel("Sample Number") + plt.ylabel("Amplitude") + plt.grid(visible=True, which="both", axis="both", color="#888888", linestyle="-") + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close() + + +def pulse(pulse_: Pulse, freq: Optional[float] = None, filename: Optional[str] = None): + """Plot the pulse envelope and modulated waveforms. + + Args: + freq: Carrier frequency used to plot modulated waveform. None if modulated plot is not needed. + filename (str): a file path. If provided the plot is save to a file. + """ + import matplotlib.pyplot as plt + from matplotlib import gridspec + + waveform_i = pulse_.i(SAMPLING_RATE) + waveform_q = pulse_.q(SAMPLING_RATE) + + num_samples = len(waveform_i) + time = np.arange(num_samples) / SAMPLING_RATE + _ = plt.figure(figsize=(14, 5), dpi=200) + gs = gridspec.GridSpec(ncols=2, nrows=1, width_ratios=np.array([2, 1])) + ax1 = plt.subplot(gs[0]) + ax1.plot( + time, + waveform_i, + label="envelope i", + c="C0", + linestyle="dashed", + ) + ax1.plot( + time, + waveform_q, + label="envelope q", + c="C1", + linestyle="dashed", + ) + + envelope = pulse_.envelopes(SAMPLING_RATE) + modulated = ( + modulate(np.array(envelope), freq, rate=SAMPLING_RATE) + if freq is not None + else None + ) + + if modulated is not None: + ax1.plot(time, modulated[0], label="modulated i", c="C0") + ax1.plot(time, modulated[1], label="modulated q", c="C1") + + ax1.plot(time, -waveform_i, c="silver", linestyle="dashed") + ax1.set_xlabel("Time [ns]") + ax1.set_ylabel("Amplitude") + + ax1.grid(visible=True, which="both", axis="both", color="#888888", linestyle="-") + start = 0 + finish = float(pulse_.duration) + ax1.axis((start, finish, -1.0, 1.0)) + ax1.legend() + + ax2 = plt.subplot(gs[1]) + ax2.plot(waveform_i, waveform_q, label="envelope", c="C2") + if modulated is not None: + ax2.plot(modulated[0], modulated[1], label="modulated", c="C3") + ax2.plot( + modulated[0][0], + modulated[1][0], + marker="o", + markersize=5, + label="start", + c="lightcoral", + ) + ax2.plot( + modulated[0][-1], + modulated[1][-1], + marker="o", + markersize=5, + label="finish", + c="darkred", + ) + + ax2.plot( + np.cos(time * 2 * np.pi / pulse_.duration), + np.sin(time * 2 * np.pi / pulse_.duration), + c="silver", + linestyle="dashed", + ) + + ax2.grid(visible=True, which="both", axis="both", color="#888888", linestyle="-") + ax2.legend() + # ax2.axis([ -1, 1, -1, 1]) + ax2.axis("equal") + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close() + + +def sequence(ps: PulseSequence, freq: dict[str, float], filename=None): + """Plot the sequence of pulses. + + Args: + freq: frequency per channel, used to plot modulated waveforms of corresponding pulses. If a channel is missing from this dict, + only /un-modulated/ waveforms are plotted for that channel. + filename (str): a file path. If provided the plot is save to a file. + """ + if len(ps) > 0: + import matplotlib.pyplot as plt + from matplotlib import gridspec + + # compile ``Align`` to delays as it is not supported here + ps = ps.align_to_delays() + num_pulses = len(ps) + _ = plt.figure(figsize=(14, 2 * num_pulses), dpi=200) + gs = gridspec.GridSpec(ncols=1, nrows=num_pulses) + vertical_lines = [] + starts = defaultdict(float) + for ch, pulse in ps: + if not isinstance(pulse, Delay): + vertical_lines.append(starts[ch]) + vertical_lines.append(starts[ch] + pulse.duration) + starts[ch] += pulse.duration + + n = -1 + for ch in ps.channels: + n += 1 + ax = plt.subplot(gs[n]) + ax.axis((0.0, ps.duration, -1.0, 1.0)) + start = 0 + for pulse in ps.channel(ch): + if isinstance(pulse, (Delay, VirtualZ)): + start += pulse.duration + continue + + envelope = pulse.envelopes(SAMPLING_RATE) + num_samples = envelope[0].size + time = start + np.arange(num_samples) / SAMPLING_RATE + if ch in freq: + modulated = modulate( + np.array(envelope), freq[ch], rate=SAMPLING_RATE + ) + ax.plot(time, modulated[1], c="lightgrey") + ax.plot(time, modulated[0], c=f"C{str(n)}") + ax.plot(time, pulse.i(SAMPLING_RATE), c=f"C{str(n)}") + ax.plot(time, -pulse.i(SAMPLING_RATE), c=f"C{str(n)}") + # TODO: if they overlap use different shades + ax.axhline(0, c="dimgrey") + ax.set_ylabel(f"channel {ch}") + for vl in vertical_lines: + ax.axvline(vl, c="slategrey", linestyle="--") + ax.axis((0, ps.duration, -1, 1)) + ax.grid( + visible=True, + which="both", + axis="both", + color="#CCCCCC", + linestyle="-", + ) + start += pulse.duration + + if filename: + plt.savefig(filename) + else: + plt.show() + plt.close() diff --git a/src/qibolab/_core/pulses/pulse.py b/src/qibolab/_core/pulses/pulse.py new file mode 100644 index 0000000000..ff9885b9c8 --- /dev/null +++ b/src/qibolab/_core/pulses/pulse.py @@ -0,0 +1,160 @@ +"""Pulse class.""" + +from typing import Annotated, Literal, Union + +import numpy as np +from pydantic import Field + +from ..serialize import Model +from .envelope import Envelope, IqWaveform, Waveform + +__all__ = [ + "Acquisition", + "Align", + "Delay", + "Pulse", + "PulseId", + "PulseLike", + "Readout", + "VirtualZ", +] + +PulseId = int +"""Unique identifier for a pulse.""" + + +class _PulseLike(Model): + @property + def id(self) -> PulseId: + """Instruction identifier.""" + return id(self) + + +class Pulse(_PulseLike): + """A pulse to be sent to the QPU. + + Valid on any channel, except acquisition ones. + """ + + kind: Literal["pulse"] = "pulse" + + duration: float + """Pulse duration.""" + + amplitude: float + """Pulse digital amplitude (unitless). + + Pulse amplitudes are normalised between -1 and 1. + """ + envelope: Envelope + """The pulse envelope shape. + + See :class:`qibolab.Envelope` for list of available shapes. + """ + relative_phase: float = 0.0 + """Relative phase of the pulse, in radians.""" + + def i(self, sampling_rate: float) -> Waveform: + """Compute the envelope of the waveform i component.""" + samples = int(self.duration * sampling_rate) + return self.amplitude * self.envelope.i(samples) + + def q(self, sampling_rate: float) -> Waveform: + """Compute the envelope of the waveform q component.""" + samples = int(self.duration * sampling_rate) + return self.amplitude * self.envelope.q(samples) + + def envelopes(self, sampling_rate: float) -> IqWaveform: + """Compute a tuple with the i and q envelopes.""" + return np.array([self.i(sampling_rate), self.q(sampling_rate)]) + + +class Delay(_PulseLike): + """Wait instruction. + + During its length no pulse is sent on the same channel. + + Valid on any channel. + """ + + kind: Literal["delay"] = "delay" + + duration: float + """Duration in ns.""" + + +class VirtualZ(_PulseLike): + """Implementation of Z-rotations using virtual phase. + + Only valid on a drive channel. + """ + + kind: Literal["virtualz"] = "virtualz" + + phase: float + """Phase that implements the rotation.""" + + @property + def duration(self): + """Duration of the virtual gate should always be zero.""" + return 0 + + +class Acquisition(_PulseLike): + """Acquisition instruction. + + This event instructs the device to acquire samples for the event + span. + + Only valid on an acquisition channel. + """ + + kind: Literal["acquisition"] = "acquisition" + + duration: float + """Duration in ns.""" + + +class Readout(_PulseLike): + """Readout instruction. + + This event instructs the device to acquire samples for the event + span. + + Only valid on an acquisition channel. + """ + + kind: Literal["readout"] = "readout" + + acquisition: Acquisition + probe: Pulse + + @classmethod + def from_probe(cls, probe: Pulse): + """Create a whole readout operation from its probe pulse. + + The acquisition is made to match the same probe duration. + """ + return cls(acquisition=Acquisition(duration=probe.duration), probe=probe) + + @property + def duration(self) -> float: + """Duration in ns.""" + return self.acquisition.duration + + @property + def id(self) -> int: + """Instruction identifier.""" + return self.acquisition.id + + +class Align(_PulseLike): + """Brings different channels at the same point in time.""" + + kind: Literal["align"] = "align" + + +PulseLike = Annotated[ + Union[Align, Pulse, Delay, VirtualZ, Acquisition, Readout], + Field(discriminator="kind"), +] diff --git a/src/qibolab/_core/qubits.py b/src/qibolab/_core/qubits.py new file mode 100644 index 0000000000..1e6128a1fa --- /dev/null +++ b/src/qibolab/_core/qubits.py @@ -0,0 +1,70 @@ +from typing import Annotated, Optional + +from pydantic import ConfigDict, Field + +from .identifier import ChannelId, QubitId, TransitionId +from .serialize import Model + +__all__ = ["Qubit"] + +DefaultChannelType = Annotated[Optional[ChannelId], True] +"""If ``True`` the channel is included in the default qubit constructor.""" + + +class Qubit(Model): + """Representation of a physical qubit. + + Contains the channel ids used to control the qubit and is instantiated + in the function that creates the corresponding + :class:`qibolab.Platform` + """ + + model_config = ConfigDict(frozen=False) + + drive: DefaultChannelType = None + """Ouput channel, to drive the qubit state.""" + drive_qudits: Annotated[dict[TransitionId, ChannelId], False] = Field( + default_factory=dict + ) + """Output channels collection, to drive non-qubit transitions.""" + flux: DefaultChannelType = None + """Output channel, to control the qubit flux.""" + probe: DefaultChannelType = None + """Output channel, to probe the resonator.""" + acquisition: DefaultChannelType = None + """Input channel, to acquire the readout results.""" + + @property + def channels(self) -> list[ChannelId]: + return [ + x + for x in ( + [getattr(self, ch) for ch in ["probe", "acquisition", "drive", "flux"]] + + list(self.drive_qudits.values()) + ) + if x is not None + ] + + @classmethod + def default(cls, name: QubitId, channels: Optional[list[str]] = None, **kwargs): + """Create a qubit with default channel names. + + Default channel names follow the convention: + '{qubit_name}/{channel_type}' + + Args: + name: Name for the qubit to be used for channel ids. + channels: List of channels to add to the qubit. + If ``None`` the following channels will be added: + probe, acquisition, drive and flux. + """ + if channels is None: + channels = [name for name, f in cls.model_fields.items() if f.metadata[0]] + return cls(**{ch: f"{name}/{ch}" for ch in channels}, **kwargs) + + +class QubitPair(Model): + """Represent a two-qubit interaction.""" + + drive: Optional[ChannelId] = None + """Output channel, for cross-resonance driving.""" diff --git a/src/qibolab/_core/sequence.py b/src/qibolab/_core/sequence.py new file mode 100644 index 0000000000..fcfb05cf3f --- /dev/null +++ b/src/qibolab/_core/sequence.py @@ -0,0 +1,211 @@ +"""PulseSequence class.""" + +from collections import UserList +from collections.abc import Callable, Iterable +from typing import Any, Union + +from pydantic import TypeAdapter +from pydantic_core import core_schema + +from .identifier import ChannelId +from .pulses import Acquisition, Align, Delay, PulseLike, Readout + +__all__ = ["PulseSequence"] + +_Element = tuple[ChannelId, PulseLike] +InputOps = Union[Readout, Acquisition] + +_adapted_sequence = TypeAdapter(list[_Element]) + + +def _synchronize(sequence: "PulseSequence", channels: Iterable[ChannelId]) -> None: + """Helper for ``concatenate`` and ``align_to_delays``. + + Modifies given ``sequence`` in-place! + """ + durations = {ch: sequence.channel_duration(ch) for ch in channels} + max_duration = max(durations.values(), default=0.0) + for ch, duration in durations.items(): + delay = max_duration - duration + if delay > 0: + sequence.append((ch, Delay(duration=delay))) + + +class PulseSequence(UserList[_Element]): + """Synchronized sequence of control instructions across multiple channels. + + The sequence is a linear stream of instructions, which may be + executed in parallel over multiple channels. + + Each instruction is composed by the pulse-like object representing + the action, and the channel on which it should be performed. + """ + + @classmethod + def __get_pydantic_core_schema__( + cls, source_type: Any, handler: Callable[[Any], core_schema.CoreSchema] + ) -> core_schema.CoreSchema: + schema = handler(list[_Element]) + return core_schema.no_info_after_validator_function( + cls._validate, + schema, + serialization=core_schema.plain_serializer_function_ser_schema( + cls._serialize, info_arg=False + ), + ) + + @classmethod + def _validate(cls, value): + return cls(value) + + @staticmethod + def _serialize(value): + return _adapted_sequence.dump_python(list(value)) + + @classmethod + def load(cls, value: list[tuple[str, PulseLike]]): + return TypeAdapter(cls).validate_python(value) + + @property + def duration(self) -> float: + """Duration of the entire sequence.""" + return max((self.channel_duration(ch) for ch in self.channels), default=0.0) + + @property + def channels(self) -> set[ChannelId]: + """Channels involved in the sequence.""" + return {ch for (ch, _) in self} + + def channel(self, channel: ChannelId) -> Iterable[PulseLike]: + """Isolate pulses on a given channel.""" + return (pulse for (ch, pulse) in self if ch == channel) + + def channel_duration(self, channel: ChannelId) -> float: + """Duration of the given channel.""" + sequence = ( + self.align_to_delays() + if any(isinstance(pulse, Align) for _, pulse in self) + else self + ) + return sum(pulse.duration for pulse in sequence.channel(channel)) + + def pulse_channels(self, pulse_id: int) -> list[ChannelId]: + """Find channels on which a pulse with a given id plays.""" + return [channel for channel, pulse in self if pulse.id == pulse_id] + + def concatenate(self, other: Iterable[_Element]) -> None: + """Concatenate two sequences. + + Appends ``other`` in-place such that the result is: + - ``self`` + - necessary delays to synchronize channels + - ``other`` + Guarantees that the all the channels in the concatenated + sequence will start simultaneously + """ + _synchronize(self, PulseSequence(other).channels) + self.extend(other) + + def __ilshift__(self, other: Iterable[_Element]) -> "PulseSequence": + """Juxtapose two sequences. + + Alias to :meth:`concatenate`. + """ + self.concatenate(other) + return self + + def __lshift__(self, other: Iterable[_Element]) -> "PulseSequence": + """Juxtapose two sequences. + + A copy is made, and no input is altered. + + Other than that, it is based on :meth:`concatenate`. + """ + copy = self.copy() + copy <<= other + return copy + + def juxtapose(self, other: Iterable[_Element]) -> None: + """Juxtapose two sequences. + + Appends ``other`` in-place such that the result is: + - ``self`` + - necessary delays to synchronize channels + - ``other`` + Guarantee simultaneous start and no overlap. + """ + _synchronize(self, PulseSequence(other).channels | self.channels) + self.extend(other) + + def __ior__(self, other: Iterable[_Element]) -> "PulseSequence": + """Juxtapose two sequences. + + Alias to :meth:`concatenate`. + """ + self.juxtapose(other) + return self + + def __or__(self, other: Iterable[_Element]) -> "PulseSequence": + """Juxtapose two sequences. + + A copy is made, and no input is altered. + + Other than that, it is based on :meth:`concatenate`. + """ + copy = self.copy() + copy |= other + return copy + + def align(self, channels: list[ChannelId]) -> Align: + """Introduce align commands to the sequence.""" + align = Align() + for channel in channels: + self.append((channel, align)) + return align + + def align_to_delays(self) -> "PulseSequence": + """Compile align commands to delays.""" + + # keep track of ``Align`` command that were already played + # because the same ``Align`` will appear on multiple channels + # in the sequence + processed_aligns = set() + + new = type(self)() + for channel, pulse in self: + if isinstance(pulse, Align): + if pulse.id not in processed_aligns: + channels = self.pulse_channels(pulse.id) + _synchronize(new, channels) + processed_aligns.add(pulse.id) + else: + new.append((channel, pulse)) + return new + + def trim(self) -> "PulseSequence": + """Drop final delays. + + The operation is not in place, and does not modify the original + sequence. + """ + terminated = set() + new = [] + for ch, pulse in reversed(self): + if ch not in terminated: + if isinstance(pulse, Delay): + continue + terminated.add(ch) + new.append((ch, pulse)) + return type(self)(reversed(new)) + + @property + def acquisitions(self) -> list[tuple[ChannelId, InputOps]]: + """Return list of the readout pulses in this sequence. + + .. note:: + + This selects only the :class:`Acquisition` events, and not all the + instructions directed to an acquistion channel + """ + # pulse filter needed to exclude delays + return [(ch, p) for ch, p in self if isinstance(p, (Acquisition, Readout))] diff --git a/src/qibolab/_core/serialize.py b/src/qibolab/_core/serialize.py new file mode 100644 index 0000000000..bab6707e17 --- /dev/null +++ b/src/qibolab/_core/serialize.py @@ -0,0 +1,72 @@ +"""Serialization utilities.""" + +import base64 +import io +from typing import Annotated, TypeVar, Union + +import numpy as np +import numpy.typing as npt +from pydantic import BaseModel, ConfigDict, PlainSerializer, PlainValidator + + +def ndarray_serialize(ar: npt.NDArray) -> str: + """Serialize array to string.""" + buffer = io.BytesIO() + np.save(buffer, ar) + buffer.seek(0) + return base64.standard_b64encode(buffer.read()).decode() + + +def ndarray_deserialize(x: Union[str, npt.NDArray]) -> npt.NDArray: + """Deserialize array.""" + if isinstance(x, np.ndarray): + return x + + buffer = io.BytesIO() + buffer.write(base64.standard_b64decode(x)) + buffer.seek(0) + return np.load(buffer) + + +NdArray = Annotated[ + npt.NDArray, + PlainValidator(ndarray_deserialize), + PlainSerializer(ndarray_serialize, return_type=str), +] +"""Pydantic-compatible array representation.""" + + +def eq(obj1: BaseModel, obj2: BaseModel) -> bool: + """Compare two models with non-default equality. + + Currently, defines custom equality for NumPy arrays. + """ + obj2d = obj2.model_dump() + comparisons = [] + for field, value1 in obj1.model_dump().items(): + value2 = obj2d[field] + if isinstance(value1, np.ndarray): + comparisons.append( + (value1.shape == value2.shape) and (value1 == value2).all() + ) + + comparisons.append(value1 == value2) + + return all(comparisons) + + +class Model(BaseModel): + """Global qibolab model, holding common configurations.""" + + model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid", frozen=True) + + +M = TypeVar("M", bound=BaseModel) + + +def replace(model: M, **update) -> M: + """Replace interface for pydantic models. + + To have the same familiar syntax of :func:`dataclasses.replace`. + """ + return model.model_copy(update=update) diff --git a/src/qibolab/_core/sweeper.py b/src/qibolab/_core/sweeper.py new file mode 100644 index 0000000000..58472fd951 --- /dev/null +++ b/src/qibolab/_core/sweeper.py @@ -0,0 +1,111 @@ +from enum import Enum, auto +from functools import cache +from typing import Any, Optional + +import numpy as np +import numpy.typing as npt +from pydantic import model_validator + +from .identifier import ChannelId +from .pulses import PulseLike +from .serialize import Model + +__all__ = ["Parameter", "ParallelSweepers", "Sweeper"] + +_PULSE = "pulse" +_CHANNEL = "channel" + + +class Parameter(Enum): + """Sweeping parameters.""" + + frequency = (auto(), _CHANNEL) + amplitude = (auto(), _PULSE) + duration = (auto(), _PULSE) + duration_interpolated = (auto(), _PULSE) + relative_phase = (auto(), _PULSE) + offset = (auto(), _CHANNEL) + + @classmethod + @cache + def channels(cls) -> set["Parameter"]: + """Set of parameters to be swept on the channel.""" + return {p for p in cls if p.value[1] == _CHANNEL} + + +_Field = tuple[Any, str] + + +def _alternative_fields(a: _Field, b: _Field): + if (a[0] is None) == (b[0] is None): + raise ValueError( + f"Either '{a[1]}' or '{b[1]}' needs to be provided, and only one of them." + ) + + +class Sweeper(Model): + """Data structure for Sweeper object. + + This object is passed as an argument to the method :func:`qibolab.Platform.execute` + which enables the user to sweep a specific parameter for one or more pulses. For information on how to + perform sweeps see :func:`qibolab.Platform.execute`. + + Example: + .. testcode:: + + import numpy as np + from qibolab import Parameter, PulseSequence, Sweeper, create_dummy + + + platform = create_dummy() + qubit = platform.qubits[0] + natives = platform.natives.single_qubit[0] + sequence = natives.MZ.create_sequence() + parameter_range = np.random.randint(10, size=10) + sweeper = Sweeper( + parameter=Parameter.frequency, values=parameter_range, channels=[qubit.probe] + ) + platform.execute([sequence], [[sweeper]]) + + Args: + parameter: parameter to be swept, possible choices are frequency, attenuation, amplitude, current and gain. + values: array of parameter values to sweep over. + range: tuple of ``(start, stop, step)`` to sweep over the array ``np.arange(start, stop, step)``. + Can be provided instead of ``values`` for more efficient sweeps on some instruments. + pulses : list of `qibolab.Pulse` to be swept. + channels: list of channel names for which the parameter should be swept. + """ + + parameter: Parameter + values: Optional[npt.NDArray] = None + range: Optional[tuple[float, float, float]] = None + pulses: Optional[list[PulseLike]] = None + channels: Optional[list[ChannelId]] = None + + @model_validator(mode="after") + def check_values(self): + _alternative_fields((self.pulses, "pulses"), (self.channels, "channels")) + _alternative_fields((self.range, "range"), (self.values, "values")) + + if self.pulses is not None and self.parameter in Parameter.channels(): + raise ValueError( + f"Cannot create a sweeper for {self.parameter} without specifying channels." + ) + if self.parameter not in Parameter.channels() and (self.channels is not None): + raise ValueError( + f"Cannot create a sweeper for {self.parameter} without specifying pulses." + ) + + if self.range is not None: + object.__setattr__(self, "values", np.arange(*self.range)) + + if self.parameter is Parameter.amplitude and max(abs(self.values)) > 1: + raise ValueError( + "Amplitude sweeper cannot have absolute values larger than 1." + ) + + return self + + +ParallelSweepers = list[Sweeper] +"""Sweepers that should be iterated in parallel.""" diff --git a/src/qibolab/_core/unrolling.py b/src/qibolab/_core/unrolling.py new file mode 100644 index 0000000000..f7ccf4eba1 --- /dev/null +++ b/src/qibolab/_core/unrolling.py @@ -0,0 +1,133 @@ +"""Utilities for sequence unrolling. + +May be reused by different instruments. +""" + +from collections import defaultdict +from functools import total_ordering +from typing import Annotated, Literal + +from pydantic.fields import FieldInfo + +from .components.configs import Config +from .pulses import Delay, Pulse +from .pulses.envelope import Rectangular +from .sequence import PulseSequence + + +def _waveform(sequence: PulseSequence): + # TODO: deduplicate pulses (Not yet as drivers may not support it yet) + # TODO: VirtualZ deserves a separate handling + # TODO: any constant part of a pulse should be counted only once (Zurich Instruments supports this) + # TODO: handle multiple qubits or do all devices have the same memory for each channel ? + return sum( + ( + (pulse.duration if not isinstance(pulse.envelope, Rectangular) else 1) + if isinstance(pulse, Pulse) + else 1 + ) + for _, pulse in sequence + ) + + +def _readout(sequence: PulseSequence): + # TODO: Do we count 1 readout per pulse or 1 readout per multiplexed readout ? + return len(sequence.acquisitions) + + +def _instructions(sequence: PulseSequence): + return len(sequence) + + +@total_ordering +class Bounds(Config): + """Instument memory limitations proxies.""" + + kind: Literal["bounds"] = "bounds" + + waveforms: Annotated[int, {"count": _waveform}] + """Waveforms estimated size.""" + readout: Annotated[int, {"count": _readout}] + """Number of readouts.""" + instructions: Annotated[int, {"count": _instructions}] + """Instructions estimated size.""" + + @classmethod + def update(cls, sequence: PulseSequence): + up = {} + for name, info in cls._entries().items(): + up[name] = info.metadata[0]["count"](sequence) + + return cls(**up) + + def __add__(self, other: "Bounds") -> "Bounds": + """Sum bounds element by element.""" + new = {} + for (k, x), (_, y) in zip( + self.model_dump().items(), other.model_dump().items() + ): + if k in type(self)._entries(): + new[k] = x + y + + return type(self)(**new) + + def __gt__(self, other: "Bounds") -> bool: + """Define ordering as exceeding any bound.""" + return any(getattr(self, f) > getattr(other, f) for f in type(self)._entries()) + + @classmethod + def _entries(cls) -> dict[str, FieldInfo]: + return { + n: f + for n, f in cls.model_fields.items() + if "count" in next(iter(f.metadata), {}) + } + + +def batch(sequences: list[PulseSequence], bounds: Bounds): + """Split a list of sequences to batches. + + Takes into account the various limitations throught the mechanics defined in + :class:`Bounds`, and the numerical limitations specified by the `bounds` argument. + """ + counters = Bounds(waveforms=0, readout=0, instructions=0) + batch = [] + for sequence in sequences: + update = Bounds.update(sequence) + if counters + update > bounds: + yield batch + counters, batch = update, [sequence] + else: + batch.append(sequence) + counters += update + yield batch + + +def unroll_sequences( + sequences: list[PulseSequence], relaxation_time: int +) -> tuple[PulseSequence, dict[int, list[int]]]: + """Unrolls a list of pulse sequences to a single sequence. + + The resulting sequence may contain multiple measurements. + + `relaxation_time` is the time in ns to wait for the qubit to relax between playing + different sequences. + + It returns both the unrolled pulse sequence, and the map from original readout pulse + serials to the unrolled readout pulse serials. Required to construct the results + dictionary that is returned after execution. + """ + total_sequence = PulseSequence() + readout_map = defaultdict(list) + for sequence in sequences: + total_sequence.concatenate(sequence) + # TODO: Fix unrolling results + for _, acq in sequence.acquisitions: + readout_map[acq.id].append(acq.id) + + length = sequence.duration + relaxation_time + for channel in sequence.channels: + delay = length - sequence.channel_duration(channel) + total_sequence.append((channel, Delay(duration=delay))) + + return total_sequence, readout_map diff --git a/src/qibolab/version.py b/src/qibolab/_version.py similarity index 72% rename from src/qibolab/version.py rename to src/qibolab/_version.py index dc57e90bf0..d5b2658b1b 100644 --- a/src/qibolab/version.py +++ b/src/qibolab/_version.py @@ -1,3 +1,5 @@ import importlib.metadata as im +__all__ = ["__version__"] + __version__ = im.version(__package__) diff --git a/src/qibolab/channels.py b/src/qibolab/channels.py deleted file mode 100644 index b4a9164780..0000000000 --- a/src/qibolab/channels.py +++ /dev/null @@ -1,168 +0,0 @@ -from dataclasses import dataclass, field -from typing import Dict, Optional - -from qibo.config import raise_error - -from qibolab.instruments.oscillator import LocalOscillator -from qibolab.instruments.port import Port - - -def check_max_offset(offset, max_offset): - """Checks if a given offset value exceeds the maximum supported offset. - - This is to avoid sending high currents that could damage lab - equipment such as amplifiers. - """ - if max_offset is not None and abs(offset) > max_offset: - raise_error( - ValueError, f"{offset} exceeds the maximum allowed offset {max_offset}." - ) - - -@dataclass -class Channel: - """Representation of physical wire connection (channel).""" - - name: str - """Name of the channel from the lab schematics.""" - port: Optional[Port] = None - """Instrument port that is connected to this channel.""" - local_oscillator: Optional[LocalOscillator] = None - """Instrument object controlling the local oscillator connected to this - channel. - - Not applicable for setups that do not use external local oscillators - because the controller can send sufficiently high frequencies or - contains internal local oscillators. - """ - max_offset: Optional[float] = None - """Maximum DC voltage that we can safely send through this channel. - - Sending high voltages for prolonged times may damage amplifiers or - other lab equipment. If the user attempts to send a higher value an - error will be raised to prevent execution in real instruments. - """ - - @property - def offset(self): - """DC offset that is applied to this port.""" - return self.port.offset - - @offset.setter - def offset(self, value): - check_max_offset(value, self.max_offset) - self.port.offset = value - - @property - def lo_frequency(self): - if self.local_oscillator is not None: - return self.local_oscillator.frequency - return self.port.lo_frequency - - @lo_frequency.setter - def lo_frequency(self, value): - if self.local_oscillator is not None: - self.local_oscillator.frequency = value - else: - self.port.lo_frequency = value - - @property - def lo_power(self): - if self.local_oscillator is not None: - return self.local_oscillator.power - return self.port.lo_power - - @lo_power.setter - def lo_power(self, value): - if self.local_oscillator is not None: - self.local_oscillator.power = value - else: - self.port.lo_power = value - - # TODO: gain, attenuation and power range can be unified to a single property - @property - def gain(self): - return self.port.gain - - @gain.setter - def gain(self, value): - self.port.gain = value - - @property - def attenuation(self): - return self.port.attenuation - - @attenuation.setter - def attenuation(self, value): - self.port.attenuation = value - - @property - def power_range(self): - return self.port.power_range - - @power_range.setter - def power_range(self, value): - self.port.power_range = value - - @property - def filter(self): - return self.port.filter - - @filter.setter - def filter(self, value): - self.port.filter = value - - -@dataclass -class ChannelMap: - """Collection of :class:`qibolab.designs.channel.Channel` objects - identified by name. - - Essentially, it allows creating a mapping of names to channels just - specifying the names. - """ - - _channels: Dict[str, Channel] = field(default_factory=dict) - - def add(self, *items): - """Add multiple items to the channel map. - - If :class: `qibolab.channels.Channel` objects are given they are dded to the channel map. - If a different type is given, a :class: `qibolab.channels.Channel` with the corresponding name - is created and added to the channel map. - """ - for item in items: - if isinstance(item, Channel): - self[item.name] = item - else: - self[item] = Channel(item) - return self - - def __getitem__(self, name): - return self._channels[name] - - def __setitem__(self, name, channel): - if not isinstance(channel, Channel): - raise_error( - TypeError, f"Cannot add channel of type {type(channel)} to ChannelMap." - ) - self._channels[name] = channel - - def __contains__(self, name): - return name in self._channels - - def __or__(self, channel_map): - channels = self._channels.copy() - channels.update(channel_map._channels) - return self.__class__(channels) - - def __ior__(self, items): - if not isinstance(items, type(self)): - try: - if isinstance(items, str): - raise TypeError - items = type(self)().add(*items) - except TypeError: - items = type(self)().add(items) - self._channels.update(items._channels) - return self diff --git a/src/qibolab/compilers/__init__.py b/src/qibolab/compilers/__init__.py deleted file mode 100644 index 20bd73cd94..0000000000 --- a/src/qibolab/compilers/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from qibolab.compilers.compiler import Compiler diff --git a/src/qibolab/compilers/compiler.py b/src/qibolab/compilers/compiler.py deleted file mode 100644 index 316fde2586..0000000000 --- a/src/qibolab/compilers/compiler.py +++ /dev/null @@ -1,171 +0,0 @@ -from collections import defaultdict -from dataclasses import dataclass, field - -from qibo import gates -from qibo.config import raise_error - -from qibolab.compilers.default import ( - cnot_rule, - cz_rule, - gpi2_rule, - gpi_rule, - identity_rule, - measurement_rule, - rz_rule, - u3_rule, - z_rule, -) -from qibolab.pulses import PulseSequence, ReadoutPulse - - -@dataclass -class Compiler: - """Compiler that transforms a :class:`qibo.models.Circuit` to a - :class:`qibolab.pulses.PulseSequence`. - - The transformation is done using a dictionary of rules which map each Qibo gate to a - pulse sequence and some virtual Z-phases. - - A rule is a function that takes two argumens: - - gate (:class:`qibo.gates.abstract.Gate`): Gate object to be compiled. - - platform (:class:`qibolab.platforms.abstract.AbstractPlatform`): Platform object to read - native gate pulses from. - - and returns: - - sequence (:class:`qibolab.pulses.PulseSequence`): Sequence of pulses that implement - the given gate. - - virtual_z_phases (dict): Dictionary mapping qubits to virtual Z-phases induced by the gate. - - See :class:`qibolab.compilers.default` for an example of a compiler implementation. - """ - - rules: dict = field(default_factory=dict) - """Map from gates to compilation rules.""" - - @classmethod - def default(cls): - return cls( - { - gates.I: identity_rule, - gates.Z: z_rule, - gates.RZ: rz_rule, - gates.U3: u3_rule, - gates.CZ: cz_rule, - gates.CNOT: cnot_rule, - gates.GPI2: gpi2_rule, - gates.GPI: gpi_rule, - gates.M: measurement_rule, - } - ) - - def __setitem__(self, key, rule): - """Sets a new rule to the compiler. - - If a rule already exists for the gate, it will be overwritten. - """ - self.rules[key] = rule - - def __getitem__(self, item): - """Get an existing rule for a given gate.""" - try: - return self.rules[item] - except KeyError: - raise_error(KeyError, f"Compiler rule not available for {item}.") - - def __delitem__(self, item): - """Remove rule for the given gate.""" - try: - del self.rules[item] - except KeyError: - raise_error( - KeyError, - f"Cannot remove {item} from compiler because it does not exist.", - ) - - def register(self, gate_cls): - """Decorator for registering a function as a rule in the compiler. - - Using this decorator is optional. Alternatively the user can set the rules directly - via ``__setitem__``. - - Args: - gate_cls: Qibo gate object that the rule will be assigned to. - """ - - def inner(func): - self[gate_cls] = func - return func - - return inner - - def _compile_gate( - self, gate, platform, sequence, virtual_z_phases, moment_start, delays - ): - """Adds a single gate to the pulse sequence.""" - rule = self[gate.__class__] - # get local sequence and phases for the current gate - gate_sequence, gate_phases = rule(gate, platform) - - # update global pulse sequence - # determine the right start time based on the availability of the qubits involved - all_qubits = {*gate_sequence.qubits, *gate.qubits} - start = max( - *[ - sequence.get_qubit_pulses(qubit).finish + delays[qubit] - for qubit in all_qubits - ], - moment_start, - ) - # shift start time and phase according to the global sequence - for pulse in gate_sequence: - pulse.start += start - if not isinstance(pulse, ReadoutPulse): - pulse.relative_phase += virtual_z_phases[pulse.qubit] - sequence.add(pulse) - - return gate_sequence, gate_phases - - def compile(self, circuit, platform): - """Transforms a circuit to pulse sequence. - - Args: - circuit (qibo.models.Circuit): Qibo circuit that respects the platform's - connectivity and native gates. - platform (qibolab.platforms.abstract.AbstractPlatform): Platform used - to load the native pulse representations. - - Returns: - sequence (qibolab.pulses.PulseSequence): Pulse sequence that implements the circuit. - measurement_map (dict): Map from each measurement gate to the sequence of readout pulse implementing it. - """ - sequence = PulseSequence() - # FIXME: This will not work with qubits that have string names - # TODO: Implement a mapping between circuit qubit ids and platform ``Qubit``s - virtual_z_phases = defaultdict(int) - - measurement_map = {} - # process circuit gates - delays = defaultdict(int) - for moment in circuit.queue.moments: - moment_start = sequence.finish - for gate in set(filter(lambda x: x is not None, moment)): - if isinstance(gate, gates.Align): - for qubit in gate.qubits: - delays[qubit] += gate.delay - continue - gate_sequence, gate_phases = self._compile_gate( - gate, platform, sequence, virtual_z_phases, moment_start, delays - ) - for qubit in gate.qubits: - delays[qubit] = 0 - - # update virtual Z phases - for qubit, phase in gate_phases.items(): - virtual_z_phases[qubit] += phase - - # register readout sequences to ``measurement_map`` so that we can - # properly map acquisition results to measurement gates - if isinstance(gate, gates.M): - measurement_map[gate] = gate_sequence - - return sequence, measurement_map diff --git a/src/qibolab/compilers/default.py b/src/qibolab/compilers/default.py deleted file mode 100644 index a9bc0a8d3c..0000000000 --- a/src/qibolab/compilers/default.py +++ /dev/null @@ -1,102 +0,0 @@ -"""Implementation of the default compiler. - -Uses I, Z, RZ, U3, CZ, and M as the set of native gates. -""" - -import math - -from qibolab.pulses import PulseSequence - - -def identity_rule(gate, platform): - """Identity gate skipped.""" - return PulseSequence(), {} - - -def z_rule(gate, platform): - """Z gate applied virtually.""" - qubit = list(platform.qubits)[gate.target_qubits[0]] - return PulseSequence(), {qubit: math.pi} - - -def rz_rule(gate, platform): - """RZ gate applied virtually.""" - qubit = list(platform.qubits)[gate.target_qubits[0]] - return PulseSequence(), {qubit: gate.parameters[0]} - - -def gpi2_rule(gate, platform): - """Rule for GPI2.""" - qubit = list(platform.qubits)[gate.target_qubits[0]] - theta = gate.parameters[0] - sequence = PulseSequence() - pulse = platform.create_RX90_pulse(qubit, start=0, relative_phase=theta) - sequence.add(pulse) - return sequence, {} - - -def gpi_rule(gate, platform): - """Rule for GPI.""" - qubit = list(platform.qubits)[gate.target_qubits[0]] - theta = gate.parameters[0] - sequence = PulseSequence() - # the following definition has a global phase difference compare to - # to the matrix representation. See - # https://github.com/qiboteam/qibolab/pull/804#pullrequestreview-1890205509 - # for more detail. - pulse = platform.create_RX_pulse(qubit, start=0, relative_phase=theta) - sequence.add(pulse) - return sequence, {} - - -def u3_rule(gate, platform): - """U3 applied as RZ-RX90-RZ-RX90-RZ.""" - qubit = list(platform.qubits)[gate.target_qubits[0]] - # Transform gate to U3 and add pi/2-pulses - theta, phi, lam = gate.parameters - # apply RZ(lam) - virtual_z_phases = {qubit: lam} - sequence = PulseSequence() - # Fetch pi/2 pulse from calibration - RX90_pulse_1 = platform.create_RX90_pulse( - qubit, start=0, relative_phase=virtual_z_phases[qubit] - ) - # apply RX(pi/2) - sequence.add(RX90_pulse_1) - # apply RZ(theta) - virtual_z_phases[qubit] += theta - # Fetch pi/2 pulse from calibration - RX90_pulse_2 = platform.create_RX90_pulse( - qubit, - start=RX90_pulse_1.finish, - relative_phase=virtual_z_phases[qubit] - math.pi, - ) - # apply RX(-pi/2) - sequence.add(RX90_pulse_2) - # apply RZ(phi) - virtual_z_phases[qubit] += phi - - return sequence, virtual_z_phases - - -def cz_rule(gate, platform): - """CZ applied as defined in the platform runcard. - - Applying the CZ gate may involve sending pulses on qubits that the - gate is not directly acting on. - """ - return platform.create_CZ_pulse_sequence(gate.qubits) - - -def cnot_rule(gate, platform): - """CNOT applied as defined in the platform runcard.""" - return platform.create_CNOT_pulse_sequence(gate.qubits) - - -def measurement_rule(gate, platform): - """Measurement gate applied using the platform readout pulse.""" - sequence = PulseSequence() - for qubit in gate.target_qubits: - MZ_pulse = platform.create_MZ_pulse(qubit, start=0) - sequence.add(MZ_pulse) - return sequence, {} diff --git a/src/qibolab/couplers.py b/src/qibolab/couplers.py deleted file mode 100644 index 8f1884dda9..0000000000 --- a/src/qibolab/couplers.py +++ /dev/null @@ -1,53 +0,0 @@ -from dataclasses import dataclass, field -from typing import Dict, Optional, Union - -from qibolab.channels import Channel -from qibolab.native import CouplerNatives - -QubitId = Union[str, int] -"""Type for Coupler names.""" - - -@dataclass -class Coupler: - """Representation of a physical coupler. - - Coupler objects are instantiated by - :class: `qibolab.platforms.platform.Platform` - and are passed to instruments to play pulses on them. - """ - - name: QubitId - "Coupler number or name." - - sweetspot: float = 0 - "Coupler sweetspot to center it's flux dependence if needed." - native_pulse: CouplerNatives = field(default_factory=CouplerNatives) - "For now this only contains the calibrated pulse to activate the coupler." - - _flux: Optional[Channel] = None - "flux (:class:`qibolab.platforms.utils.Channel`): Channel used to send flux pulses to the qubit." - - # TODO: With topology or conectivity - # qubits: Optional[Dict[QubitId, Qubit]] = field(default_factory=dict) - qubits: Dict = field(default_factory=dict) - "Qubits the coupler acts on" - - def __post_init__(self): - if self.flux is not None and self.sweetspot != 0: - self.flux.offset = self.sweetspot - - @property - def flux(self): - return self._flux - - @flux.setter - def flux(self, channel): - if self.sweetspot != 0: - channel.offset = self.sweetspot - self._flux = channel - - @property - def channels(self): - if self.flux is not None: - yield self.flux diff --git a/src/qibolab/dummy/kernels.npz b/src/qibolab/dummy/kernels.npz deleted file mode 100644 index 15cb0ecb3e..0000000000 Binary files a/src/qibolab/dummy/kernels.npz and /dev/null differ diff --git a/src/qibolab/dummy/parameters.json b/src/qibolab/dummy/parameters.json deleted file mode 100644 index 498ab97d58..0000000000 --- a/src/qibolab/dummy/parameters.json +++ /dev/null @@ -1,719 +0,0 @@ -{ - "nqubits": 5, - "settings": { - "nshots": 1024, - "relaxation_time": 0 - }, - "qubits": [ - 0, - 1, - 2, - 3, - 4 - ], - "couplers": [ - 0, - 1, - 3, - 4 - ], - "topology": { - "0": [ - 0, - 2 - ], - "1": [ - 1, - 2 - ], - "3": [ - 2, - 3 - ], - "4": [ - 2, - 4 - ] - }, - "instruments": { - "dummy": { - "bounds": { - "waveforms": 0, - "readout": 0, - "instructions": 0 - } - }, - "twpa_pump": { - "power": 10, - "frequency": 1000000000.0 - } - }, - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 40, - "amplitude": 0.1, - "shape": "Gaussian(5)", - "frequency": 4000000000.0, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "RX12": { - "duration": 40, - "amplitude": 0.005, - "shape": "Gaussian(5)", - "frequency": 4700000000, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "MZ": { - "duration": 2000, - "amplitude": 0.1, - "shape": "GaussianSquare(5, 0.75)", - "frequency": 5200000000.0, - "relative_start": 0, - "phase": 0, - "type": "ro" - } - }, - "1": { - "RX": { - "duration": 40, - "amplitude": 0.3, - "shape": "Drag(5, -0.02)", - "frequency": 4200000000.0, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "RX12": { - "duration": 40, - "amplitude": 0.0484, - "shape": "Drag(5, -0.02)", - "frequency": 4855663000, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "MZ": { - "duration": 2000, - "amplitude": 0.1, - "shape": "GaussianSquare(5, 0.75)", - "frequency": 4900000000.0, - "relative_start": 0, - "phase": 0, - "type": "ro" - } - }, - "2": { - "RX": { - "duration": 40, - "amplitude": 0.3, - "shape": "Drag(5, -0.02)", - "frequency": 4500000000.0, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "RX12": { - "duration": 40, - "amplitude": 0.005, - "shape": "Gaussian(5)", - "frequency": 2700000000, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "MZ": { - "duration": 2000, - "amplitude": 0.1, - "shape": "GaussianSquare(5, 0.75)", - "frequency": 6100000000.0, - "relative_start": 0, - "phase": 0, - "type": "ro" - } - }, - "3": { - "RX": { - "duration": 40, - "amplitude": 0.3, - "shape": "Drag(5, -0.02)", - "frequency": 4150000000.0, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "RX12": { - "duration": 40, - "amplitude": 0.0484, - "shape": "Drag(5, -0.02)", - "frequency": 5855663000, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "MZ": { - "duration": 2000, - "amplitude": 0.1, - "shape": "GaussianSquare(5, 0.75)", - "frequency": 5800000000.0, - "relative_start": 0, - "phase": 0, - "type": "ro" - } - }, - "4": { - "RX": { - "duration": 40, - "amplitude": 0.3, - "shape": "Drag(5, -0.02)", - "frequency": 4155663000, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "RX12": { - "duration": 40, - "amplitude": 0.0484, - "shape": "Drag(5, -0.02)", - "frequency": 5855663000, - "relative_start": 0, - "phase": 0, - "type": "qd" - }, - "MZ": { - "duration": 2000, - "amplitude": 0.1, - "shape": "GaussianSquare(5, 0.75)", - "frequency": 5500000000.0, - "relative_start": 0, - "phase": 0, - "type": "ro" - } - } - }, - "coupler": { - "0": { - "CP": { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "relative_start": 0, - "type": "coupler", - "coupler": 0 - } - }, - "1": { - "CP": { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "relative_start": 0, - "type": "coupler", - "coupler": 1 - } - }, - "3": { - "CP": { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "relative_start": 0, - "type": "coupler", - "coupler": 3 - } - }, - "4": { - "CP": { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "relative_start": 0, - "type": "coupler", - "coupler": 4 - } - } - }, - "two_qubit": { - "0-2": { - "CZ": [ - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 0 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 2 - }, - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "coupler": 0, - "relative_start": 0, - "type": "coupler" - } - ], - "iSWAP": [ - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 2 - }, - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "coupler": 0, - "relative_start": 0, - "type": "coupler" - } - ] - }, - "1-2": { - "CZ": [ - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 2 - }, - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "coupler": 1, - "relative_start": 0, - "type": "coupler" - } - ], - "iSWAP": [ - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 2 - }, - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "coupler": 1, - "relative_start": 0, - "type": "coupler" - } - ] - }, - "2-3": { - "CZ": [ - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 3 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 2 - }, - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "coupler": 3, - "relative_start": 0, - "type": "coupler" - } - ], - "iSWAP": [ - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 2 - }, - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "coupler": 3, - "relative_start": 0, - "type": "coupler" - } - ], - "CNOT": [ - { - "duration": 40, - "amplitude": 0.3, - "shape": "Drag(5, -0.02)", - "frequency": 4150000000.0, - "relative_start": 0, - "phase": 0, - "type": "qd", - "qubit": 2 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 2 - } - ] - }, - "2-4": { - "CZ": [ - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 4 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 2 - }, - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "coupler": 4, - "relative_start": 0, - "type": "coupler" - } - ], - "iSWAP": [ - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": 0.0, - "qubit": 2 - }, - { - "duration": 30, - "amplitude": 0.05, - "shape": "GaussianSquare(5, 0.75)", - "coupler": 4, - "relative_start": 0, - "type": "coupler" - } - ] - } - } - }, - "characterization": { - "single_qubit": { - "0": { - "bare_resonator_frequency": 0, - "readout_frequency": 5200000000.0, - "drive_frequency": 4000000000.0, - "anharmonicity": 0, - "sweetspot": 0.0, - "asymmetry": 0.0, - "crosstalk_matrix": { - "0": 1 - }, - "Ec": 0.0, - "Ej": 0.0, - "g": 0.0, - "assignment_fidelity": [0.5, 0.1], - "gate_fidelity": [0.5, 0.1], - "peak_voltage": 0, - "pi_pulse_amplitude": 0, - "T1": 0.0, - "T2": 0.0, - "T2_spin_echo": 0, - "state0_voltage": 0, - "state1_voltage": 0, - "mean_gnd_states": [ - 0, - 1 - ], - "mean_exc_states": [ - 1, - 0 - ], - "threshold": 0.0, - "iq_angle": 0.0, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "1": { - "bare_resonator_frequency": 0, - "readout_frequency": 4900000000.0, - "drive_frequency": 4200000000.0, - "anharmonicity": 0, - "sweetspot": 0.0, - "asymmetry": 0.0, - "crosstalk_matrix": { - "1": 1 - }, - "Ec": 0.0, - "Ej": 0.0, - "g": 0.0, - "assignment_fidelity": [0.5, 0.1], - "gate_fidelity": [0.5, 0.1], - "peak_voltage": 0, - "pi_pulse_amplitude": 0, - "T1": 0.0, - "T2": 0.0, - "T2_spin_echo": 0, - "state0_voltage": 0, - "state1_voltage": 0, - "mean_gnd_states": [ - 0.25, - 0 - ], - "mean_exc_states": [ - 0, - 0.25 - ], - "threshold": 0.0, - "iq_angle": 0.0, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "2": { - "bare_resonator_frequency": 0, - "readout_frequency": 6100000000.0, - "drive_frequency": 4500000000.0, - "anharmonicity": 0, - "sweetspot": 0.0, - "asymmetry": 0.0, - "crosstalk_matrix": { - "2": 1 - }, - "Ec": 0.0, - "Ej": 0.0, - "g": 0.0, - "assignment_fidelity": [0.5, 0.1], - "gate_fidelity": [0.5, 0.1], - "peak_voltage": 0, - "pi_pulse_amplitude": 0, - "T1": 0.0, - "T2": 0.0, - "T2_spin_echo": 0, - "state0_voltage": 0, - "state1_voltage": 0, - "mean_gnd_states": [ - 0.5, - 0 - ], - "mean_exc_states": [ - 0, - 0.5 - ], - "threshold": 0.0, - "iq_angle": 0.0, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "3": { - "bare_resonator_frequency": 0, - "readout_frequency": 5800000000.0, - "drive_frequency": 4150000000.0, - "anharmonicity": 0, - "sweetspot": 0.0, - "asymmetry": 0.0, - "crosstalk_matrix": { - "3": 1 - }, - "Ec": 0.0, - "Ej": 0.0, - "g": 0.0, - "assignment_fidelity": [0.5, 0.1], - "gate_fidelity": [0.5, 0.1], - "peak_voltage": 0, - "pi_pulse_amplitude": 0, - "T1": 0.0, - "T2": 0.0, - "T2_spin_echo": 0, - "state0_voltage": 0, - "state1_voltage": 0, - "mean_gnd_states": [ - 0.75, - 0 - ], - "mean_exc_states": [ - 0, - 0.75 - ], - "threshold": 0.0, - "iq_angle": 0.0, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "4": { - "bare_resonator_frequency": 0, - "readout_frequency": 5500000000.0, - "drive_frequency": 4100000000.0, - "anharmonicity": 0, - "sweetspot": 0.0, - "asymmetry": 0.0, - "crosstalk_matrix": { - "4": 1 - }, - "Ec": 0.0, - "Ej": 0.0, - "g": 0.0, - "assignment_fidelity": [0.5, 0.1], - "gate_fidelity": [0.5, 0.1], - "peak_voltage": 0, - "pi_pulse_amplitude": 0, - "T1": 0.0, - "T2": 0.0, - "T2_spin_echo": 0, - "state0_voltage": 0, - "state1_voltage": 0, - "mean_gnd_states": [ - 1, - 0 - ], - "mean_exc_states": [ - 0, - 1 - ], - "threshold": 0.0, - "iq_angle": 0.0, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - } - }, - "two_qubit":{ - "0-2": { - "gate_fidelity": [0.5, 0.1], - "cz_fidelity": [0.5, 0.1] - }, - "1-2": { - "gate_fidelity": [0.5, 0.1], - "cz_fidelity": [0.5, 0.1] - }, - "2-3": { - "gate_fidelity": [0.5, 0.1], - "cz_fidelity": [0.5, 0.1] - }, - "2-4": { - "gate_fidelity": [0.5, 0.1], - "cz_fidelity": [0.5, 0.1] - } - }, - "coupler": { - "0": { - "sweetspot": 0.0 - }, - "1": { - "sweetspot": 0.0 - }, - "3": { - "sweetspot": 0.0 - }, - "4": { - "sweetspot": 0.0 - } - } - } -} diff --git a/src/qibolab/dummy/platform.py b/src/qibolab/dummy/platform.py deleted file mode 100644 index 05e91fcd0c..0000000000 --- a/src/qibolab/dummy/platform.py +++ /dev/null @@ -1,92 +0,0 @@ -import itertools -import pathlib - -from qibolab.channels import Channel, ChannelMap -from qibolab.instruments.dummy import DummyInstrument, DummyLocalOscillator -from qibolab.kernels import Kernels -from qibolab.platform import Platform -from qibolab.serialize import load_qubits, load_runcard, load_settings - -FOLDER = pathlib.Path(__file__).parent - - -def remove_couplers(runcard): - """Remove coupler sections from runcard to create a dummy platform without - couplers.""" - runcard["topology"] = list(runcard["topology"].values()) - del runcard["couplers"] - del runcard["native_gates"]["coupler"] - del runcard["characterization"]["coupler"] - two_qubit = runcard["native_gates"]["two_qubit"] - for i, gates in two_qubit.items(): - for j, gate in gates.items(): - two_qubit[i][j] = [pulse for pulse in gate if pulse["type"] != "coupler"] - return runcard - - -def create_dummy(with_couplers: bool = True): - """Create a dummy platform using the dummy instrument. - - Args: - with_couplers (bool): Selects whether the dummy platform will have coupler qubits. - """ - # Create dummy controller - instrument = DummyInstrument("dummy", 0) - - # Create local oscillator - twpa_pump = DummyLocalOscillator(name="twpa_pump", address=0) - twpa_pump.frequency = 1e9 - twpa_pump.power = 10 - - runcard = load_runcard(FOLDER) - kernels = Kernels.load(FOLDER) - - if not with_couplers: - runcard = remove_couplers(runcard) - - # Create channel objects - nqubits = runcard["nqubits"] - channels = ChannelMap() - channels |= Channel("readout", port=instrument.ports("readout")) - channels |= ( - Channel(f"drive-{i}", port=instrument.ports(f"drive-{i}")) - for i in range(nqubits) - ) - channels |= ( - Channel(f"flux-{i}", port=instrument.ports(f"flux-{i}")) for i in range(nqubits) - ) - channels |= Channel("twpa", port=None) - if with_couplers: - channels |= ( - Channel(f"flux_coupler-{c}", port=instrument.ports(f"flux_coupler-{c}")) - for c in itertools.chain(range(0, 2), range(3, 5)) - ) - channels["readout"].attenuation = 0 - channels["twpa"].local_oscillator = twpa_pump - - qubits, couplers, pairs = load_qubits(runcard, kernels) - settings = load_settings(runcard) - - # map channels to qubits - for q, qubit in qubits.items(): - qubit.readout = channels["readout"] - qubit.drive = channels[f"drive-{q}"] - qubit.flux = channels[f"flux-{q}"] - qubit.twpa = channels["twpa"] - - if with_couplers: - # map channels to couplers - for c, coupler in couplers.items(): - coupler.flux = channels[f"flux_coupler-{c}"] - - instruments = {instrument.name: instrument, twpa_pump.name: twpa_pump} - name = "dummy_couplers" if with_couplers else "dummy" - return Platform( - name, - qubits, - pairs, - instruments, - settings, - resonator_type="2D", - couplers=couplers, - ) diff --git a/src/qibolab/execution_parameters.py b/src/qibolab/execution_parameters.py deleted file mode 100644 index b317caf138..0000000000 --- a/src/qibolab/execution_parameters.py +++ /dev/null @@ -1,79 +0,0 @@ -from dataclasses import dataclass -from enum import Enum, auto -from typing import Optional - -from qibolab.result import ( - AveragedIntegratedResults, - AveragedRawWaveformResults, - AveragedSampleResults, - IntegratedResults, - RawWaveformResults, - SampleResults, -) - - -class AcquisitionType(Enum): - """Data acquisition from hardware.""" - - DISCRIMINATION = auto() - """Demodulate, integrate the waveform and discriminate among states based - on the voltages.""" - INTEGRATION = auto() - """Demodulate and integrate the waveform.""" - RAW = auto() - """Acquire the waveform as it is.""" - SPECTROSCOPY = auto() - """Zurich Integration mode for RO frequency sweeps.""" - - -class AveragingMode(Enum): - """Data averaging modes from hardware.""" - - CYCLIC = auto() - """Better averaging for short timescale noise.""" - SINGLESHOT = auto() - """SINGLESHOT: No averaging.""" - SEQUENTIAL = auto() - """SEQUENTIAL: Worse averaging for noise[Avoid]""" - - -RESULTS_TYPE = { - AveragingMode.CYCLIC: { - AcquisitionType.INTEGRATION: AveragedIntegratedResults, - AcquisitionType.RAW: AveragedRawWaveformResults, - AcquisitionType.DISCRIMINATION: AveragedSampleResults, - }, - AveragingMode.SINGLESHOT: { - AcquisitionType.INTEGRATION: IntegratedResults, - AcquisitionType.RAW: RawWaveformResults, - AcquisitionType.DISCRIMINATION: SampleResults, - }, -} - - -@dataclass(frozen=True) -class ExecutionParameters: - """Data structure to deal with execution parameters.""" - - nshots: Optional[int] = None - """Number of shots to sample from the experiment. - - Default is the runcard value. - """ - relaxation_time: Optional[int] = None - """Time to wait for the qubit to relax to its ground Sample between shots - in ns. - - Default is the runcard value. - """ - fast_reset: bool = False - """Enable or disable fast reset.""" - acquisition_type: AcquisitionType = AcquisitionType.DISCRIMINATION - """Data acquisition type.""" - averaging_mode: AveragingMode = AveragingMode.SINGLESHOT - """Data averaging mode.""" - - @property - def results_type(self): - """Returns corresponding results class.""" - return RESULTS_TYPE[self.averaging_mode][self.acquisition_type] diff --git a/src/qibolab/instruments/__init__.py b/src/qibolab/instruments/__init__.py index e69de29bb2..0daca1f553 100644 --- a/src/qibolab/instruments/__init__.py +++ b/src/qibolab/instruments/__init__.py @@ -0,0 +1,5 @@ +from . import dummy +from .dummy import * + +__all__ = [] +__all__ += dummy.__all__ diff --git a/src/qibolab/instruments/abstract.py b/src/qibolab/instruments/abstract.py deleted file mode 100644 index bdd44e66ca..0000000000 --- a/src/qibolab/instruments/abstract.py +++ /dev/null @@ -1,119 +0,0 @@ -from abc import ABC, abstractmethod -from dataclasses import asdict, dataclass -from typing import Optional - -from qibolab.unrolling import Bounds - -from .port import Port - -InstrumentId = str - - -@dataclass -class InstrumentSettings: - """Container of settings that are dumped in the platform runcard json.""" - - def dump(self): - """Dictionary containing the settings. - - Useful when dumping the instruments to the runcard JSON. - """ - return asdict(self) - - -class Instrument(ABC): - """Parent class for all the instruments connected via TCPIP. - - Args: - name (str): Instrument name. - address (str): Instrument network address. - """ - - def __init__(self, name, address): - self.name: InstrumentId = name - self.address: str = address - self.is_connected: bool = False - self.settings: Optional[InstrumentSettings] = None - - @property - def signature(self): - return f"{type(self).__name__}@{self.address}" - - @abstractmethod - def connect(self): - """Establish connection to the physical instrument.""" - - @abstractmethod - def disconnect(self): - """Close connection to the physical instrument.""" - - @abstractmethod - def setup(self, *args, **kwargs): - """Set instrument settings.""" - - -class Controller(Instrument): - """Instrument that can play pulses (using waveform generator).""" - - PortType = Port - """Class used by the instrument to instantiate ports.""" - - def __init__(self, name, address): - super().__init__(name, address) - self._ports = {} - self.bounds: Bounds = Bounds(0, 0, 0) - """Estimated limitations of the device memory.""" - - def setup(self, bounds): - """Set unrolling batch bounds.""" - self.bounds = Bounds(**bounds) - - def dump(self): - """Dump unrolling batch bounds.""" - return {"bounds": asdict(self.bounds)} - - @property - @abstractmethod - def sampling_rate(self): - """Sampling rate of control electronics in giga samples per second - (GSps).""" - - def ports(self, port_name, *args, **kwargs): - """Get ports associated to this controller. - - Args: - port_name: Identifier for the port. The type of the identifier - depends on the specialized port defined for each instrument. - - Returns: - :class:`qibolab.instruments.port.Port` object providing the interface - for setting instrument parameters. - """ - if port_name not in self._ports: - self._ports[port_name] = self.PortType(port_name) - return self._ports[port_name] - - @abstractmethod - def play(self, *args, **kwargs): - """Play a pulse sequence and retrieve feedback. - - Returns: - (Dict[ResultType]) mapping the serial of the readout pulses used to - the acquired :class:`qibolab.result.ExecutionResults` object. - """ - - @abstractmethod - def sweep(self, *args, **kwargs): - """Play a pulse sequence while sweeping one or more parameters. - - Returns: - (dict) mapping the serial of the readout pulses used to - the acquired :class:`qibolab.result.ExecutionResults` object. - """ - - -class InstrumentException(Exception): - def __init__(self, instrument: Instrument, message: str): - header = f"InstrumentException with {instrument.signature}" - full_msg = header + ": " + message - super().__init__(full_msg) diff --git a/src/qibolab/instruments/bluefors.py b/src/qibolab/instruments/bluefors.py index feea38f7b4..e0b502c2ed 100644 --- a/src/qibolab/instruments/bluefors.py +++ b/src/qibolab/instruments/bluefors.py @@ -1,68 +1,10 @@ -import socket +"""Bluefors drivers. -import yaml -from qibo.config import log +https://bluefors.com/ +""" -from qibolab.instruments.abstract import Instrument +from qibolab._core.instruments import bluefors +from qibolab._core.instruments.bluefors import * # noqa: F403 - -class TemperatureController(Instrument): - """Bluefors temperature controller. - - ``` - # Example usage - if __name__ == "__main__": - tc = TemperatureController("XLD1000_Temperature_Controller", "192.168.0.114", 8888) - tc.connect() - temperature_values = tc.read_data() - for temperature_value in temperature_values: - print(temperature_value) - ``` - """ - - def __init__(self, name: str, address: str, port: int = 8888): - """Creation of the controller object. - - Args: - name (str): name of the instrument. - address (str): IP address of the board sending cryo temperature data. - port (int): port of the board sending cryo temperature data. - """ - super().__init__(name, address) - self.port = port - self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - - def connect(self): - """Connect to the socket.""" - if self.is_connected: - return - log.info(f"Bluefors connection. IP: {self.address} Port: {self.port}") - self.client_socket.connect((self.address, self.port)) - self.is_connected = True - log.info("Bluefors Temperature Controller Connected") - - def disconnect(self): - """Disconnect from the socket.""" - if self.is_connected: - self.client_socket.close() - self.is_connected = False - - def setup(self): - """Required by parent class, but not used here.""" - - def get_data(self) -> dict[str, dict[str, float]]: - """Connect to the socket and get temperature data. - - The typical message looks like this: - flange_name: {'temperature':12.345678, 'timestamp':1234567890.123456} - `timestamp` can be converted to datetime using `datetime.fromtimestamp`. - Returns: - message (dict[str, dict[str, float]]): socket message in this format: - {"flange_name": {'temperature': , 'timestamp':}} - """ - return yaml.safe_load(self.client_socket.recv(1024).decode()) - - def read_data(self): - """Continously read data from the temperature controller.""" - while True: - yield self.get_data() +__all__ = [] +__all__ += bluefors.__all__ diff --git a/src/qibolab/instruments/dummy.py b/src/qibolab/instruments/dummy.py index ed78c2b761..9a6f812e06 100644 --- a/src/qibolab/instruments/dummy.py +++ b/src/qibolab/instruments/dummy.py @@ -1,161 +1,10 @@ -from dataclasses import dataclass -from typing import Dict, List, Optional +"""Dummy drivers. -import numpy as np -from qibo.config import log +Define instruments mainly used for testing purposes. +""" -from qibolab.couplers import Coupler -from qibolab.execution_parameters import ( - AcquisitionType, - AveragingMode, - ExecutionParameters, -) -from qibolab.pulses import PulseSequence -from qibolab.qubits import Qubit, QubitId -from qibolab.sweeper import Sweeper -from qibolab.unrolling import Bounds +from qibolab._core.instruments import dummy +from qibolab._core.instruments.dummy import * # noqa: F403 -from .abstract import Controller -from .oscillator import LocalOscillator -from .port import Port - -SAMPLING_RATE = 1 - - -@dataclass -class DummyPort(Port): - name: str - offset: float = 0.0 - lo_frequency: int = 0 - lo_power: int = 0 - gain: int = 0 - attenuation: int = 0 - power_range: int = 0 - filters: Optional[dict] = None - - -class DummyDevice: - """Dummy device that does nothing but follows the QCoDeS interface. - - Used by :class:`qibolab.instruments.dummy.DummyLocalOscillator`. - """ - - def set(self, name, value): - """Set device property.""" - - def get(self, name): - """Get device property.""" - return 0 - - def on(self): - """Turn device on.""" - - def off(self): - """Turn device on.""" - - def close(self): - """Close connection with device.""" - - -class DummyLocalOscillator(LocalOscillator): - """Dummy local oscillator instrument. - - Useful for testing the interface defined in :class:`qibolab.instruments.oscillator.LocalOscillator`. - """ - - def create(self): - return DummyDevice() - - -class DummyInstrument(Controller): - """Dummy instrument that returns random voltage values. - - Useful for testing code without requiring access to hardware. - - Args: - name (str): name of the instrument. - address (int): address to connect to the instrument. - Not used since the instrument is dummy, it only - exists to keep the same interface with other - instruments. - """ - - BOUNDS = Bounds(1, 1, 1) - - PortType = DummyPort - - @property - def sampling_rate(self): - return SAMPLING_RATE - - def connect(self): - log.info(f"Connecting to {self.name} instrument.") - - def disconnect(self): - log.info(f"Disconnecting {self.name} instrument.") - - def setup(self, *args, **kwargs): - log.info(f"Setting up {self.name} instrument.") - - def get_values(self, options, ro_pulse, shape): - if options.acquisition_type is AcquisitionType.DISCRIMINATION: - if options.averaging_mode is AveragingMode.SINGLESHOT: - values = np.random.randint(2, size=shape) - elif options.averaging_mode is AveragingMode.CYCLIC: - values = np.random.rand(*shape) - elif options.acquisition_type is AcquisitionType.RAW: - samples = int(ro_pulse.duration * SAMPLING_RATE) - waveform_shape = tuple(samples * dim for dim in shape) - values = ( - np.random.rand(*waveform_shape) * 100 - + 1j * np.random.rand(*waveform_shape) * 100 - ) - elif options.acquisition_type is AcquisitionType.INTEGRATION: - values = np.random.rand(*shape) * 100 + 1j * np.random.rand(*shape) * 100 - return values - - def play( - self, - qubits: Dict[QubitId, Qubit], - couplers: Dict[QubitId, Coupler], - sequence: PulseSequence, - options: ExecutionParameters, - ): - exp_points = ( - 1 if options.averaging_mode is AveragingMode.CYCLIC else options.nshots - ) - shape = (exp_points,) - results = {} - - for ro_pulse in sequence.ro_pulses: - values = np.squeeze(self.get_values(options, ro_pulse, shape)) - results[ro_pulse.qubit] = results[ro_pulse.serial] = options.results_type( - values - ) - - return results - - def sweep( - self, - qubits: Dict[QubitId, Qubit], - couplers: Dict[QubitId, Coupler], - sequence: PulseSequence, - options: ExecutionParameters, - *sweepers: List[Sweeper], - ): - results = {} - - if options.averaging_mode is not AveragingMode.CYCLIC: - shape = (options.nshots,) + tuple( - len(sweeper.values) for sweeper in sweepers - ) - else: - shape = tuple(len(sweeper.values) for sweeper in sweepers) - - for ro_pulse in sequence.ro_pulses: - values = self.get_values(options, ro_pulse, shape) - results[ro_pulse.qubit] = results[ro_pulse.serial] = options.results_type( - values - ) - - return results +__all__ = [] +__all__ += dummy.__all__ diff --git a/src/qibolab/instruments/emulator/engines/generic.py b/src/qibolab/instruments/emulator/engines/generic.py deleted file mode 100644 index 87807e4954..0000000000 --- a/src/qibolab/instruments/emulator/engines/generic.py +++ /dev/null @@ -1,163 +0,0 @@ -from collections import OrderedDict -from typing import List, Optional - -import numpy as np - - -def specify_hilbert_space(model_config: dict, little_endian: bool) -> tuple: - """Creates a tuple that specifies the Hilbert Space to be used by the - quantum dynamics simulation. - - Args: - model_config (dict): Model configuration dictionary. - little_endian (bool): Flag to indicate if Hilbert Space is in little endian (True) or big endian (False). - - Returns: - tuple: Contains the ordered list of qubit and coupler indices and the corresponding ordered list of nlevels. - """ - - nlevels_q = model_config["nlevels_q"] # as per runcard, big endian - nlevels_c = model_config["nlevels_c"] # as per runcard, big endian - qubits_list = model_config["qubits_list"] # as per runcard, big endian - couplers_list = model_config["couplers_list"] # as per runcard, big endian - - nlevels_HS = np.flip( - nlevels_c + nlevels_q - ).tolist() # little endian, qubits first then couplers - HS_list = np.flip( - couplers_list + qubits_list - ) # little endian, qubits first then couplers - - return HS_list, nlevels_HS - - -def function_from_array(y: np.ndarray, x: np.ndarray): - """Return function given a data array y and time array x.""" - - if y.shape[0] != x.shape[0]: - raise ValueError("y and x must have the same first dimension") - - yx = np.column_stack((y, x)) - yx = yx[yx[:, -1].argsort()] - - def func(t, args): - idx = np.searchsorted(yx[1:, -1], t, side="right") - return yx[idx, 0] - - return func - - -def dec_to_basis_string(x: int, nlevels: list = [2]) -> list: - """Converts an integer to a generalized bitstring in the computation basis - of the full Hilbert space. - - Args: - x (int): The integer (decimal number) to be converted. - nlevels (list): The list of nlevels to convert the decimal number to. Defaults to [2]. - - Returns: - list: Generalized bitstring of x. - """ - nqubits = len(nlevels) - output_list = [] - y = x - subdims_ = np.multiply.accumulate(nlevels) - subdims = (subdims_[-1] / subdims_).astype(int) - - for sub_dim in subdims: - coeff = np.divmod(y, sub_dim)[0] - output_list.append(coeff) - y -= coeff * sub_dim - - return output_list - - -def op_from_instruction( - inst: tuple[float, str, list], - op_dict: Optional[dict] = None, - op_connectors_dict: Optional[dict] = None, - multiply_coeff: bool = True, -): - """Converts an instruction tuple into a quantum operator. - - Args: - inst (tuple): The instruction tuple. - op_dict (dict, optional): Dictionary mapping operator names to strings. Defaults to None. - op_connectors_dict (dict, optional): Dictionary mapping operator connectors to operations. Defaults to None. - multiply_coeff (bool): Multiplies coefficient to final quantum operator if True, or keep them separate in a tuple otherwise. Defaults to True. - - Returns: - The quantum operator if multiply_coeff is True, or a tuple containing the coefficient and operator string otherwise. - """ - coeff, s, op_qid_list = inst - - # construct op_dict and op_connectors_dict check dictionaries (involves strings and string operations) - if op_dict is None: - op_dict_check = { - "b": {}, - "bdag": {}, - "O": {}, - "X": {}, - "Z01": {}, - "sp01": {}, - } - for k in op_qid_list: - op_dict_check["b"].update({k: f"op_b_{k}"}) - op_dict_check["bdag"].update({k: f"op_bdag_{k}"}) - op_dict_check["O"].update({k: f"op_O_{k}"}) - op_dict_check["X"].update({k: f"op_X_{k}"}) - op_dict_check["Z01"].update({k: f"op_Z01_{k}"}) - op_dict_check["sp01"].update({k: f"op_sp01_{k}"}) - op_dict = op_dict_check - - if op_connectors_dict is None: - op_connectors_dict_check = OrderedDict( - [ - ("^", lambda a, b: f"tensor({a},{b})"), - ("*", lambda a, b: f"times({a},{b})"), - ("+", lambda a, b: f"plus({a},{b})"), - ("-", lambda a, b: f"minus({a},{b})"), - ] - ) - op_connectors_dict = op_connectors_dict_check - - def process_op(op_list: list, connector_list: List[str], connector: str) -> list: - """Implements connectors between operators.""" - index_list = [] - for i in range(connector_list.count(connector)): - ind = connector_list.index(connector) - index_list.append(ind + len(index_list)) - connector_list.pop(ind) - - new_op_list = [] - for i, op in enumerate(op_list): - if i in index_list: - next_op = op_list[i + 1] - if i - 1 in index_list: - new_op_list[-1] = op_connectors_dict[connector]( - new_op_list[-1], next_op - ) - else: - new_op_list.append(op_connectors_dict[connector](op, next_op)) - elif i - 1 in index_list: - pass - else: - new_op_list.append(op) - return new_op_list, connector_list - - # convert operator instruction strings into list of components - split_inst = s.split(" ") - op_list = [] - # implement operators - for op_key in split_inst[::2]: - op_name, qid = op_key.split("_") - op_list.append(op_dict[op_name][qid]) - # implement operator connections - connector_list = split_inst[1::2] - for connector in list(op_connectors_dict.keys()): - op_list, connector_list = process_op(op_list, connector_list, connector) - - if multiply_coeff: - return coeff * op_list[0] - else: - return coeff, op_list[0] diff --git a/src/qibolab/instruments/emulator/engines/qutip_engine.py b/src/qibolab/instruments/emulator/engines/qutip_engine.py deleted file mode 100644 index f290d43e26..0000000000 --- a/src/qibolab/instruments/emulator/engines/qutip_engine.py +++ /dev/null @@ -1,527 +0,0 @@ -""" -qutip_engine.py ----------------- -This module provides a engine for Quantum Toolbox in Python (QuTiP) to simulate QPUs. -""" - -from collections import OrderedDict -from timeit import default_timer as timer -from typing import Dict, List, Optional - -import numpy as np -from qutip import Options, Qobj, basis, expect, ket2dm, mesolve, ptrace -from qutip.operators import identity as Id -from qutip.tensor import tensor -from qutip.ui.progressbar import EnhancedTextProgressBar - -from qibolab.instruments.emulator.engines.generic import ( - dec_to_basis_string, - function_from_array, - op_from_instruction, - specify_hilbert_space, -) - -LITTLE_ENDIAN = True - - -def get_default_qutip_sim_opts(): - """Returns the default simulation options for the Qutip engine. - - Returns: - Options: The default simulation options. - """ - sim_opts = Options(atol=1e-11, rtol=1e-9, nsteps=int(1e6)) - sim_opts.normalize_output = False # mesolve is x3 faster if this is False - - return sim_opts - - -class QutipSimulator: - """Builds pulse simulator components in qutip engine. Pulse simulation is - implemented by `qevolve` method. QutipSimulator does not interact with - Qibolab. - - Note that objects have either little or big endian order. - Little endian: decreasing order of qubit/coupler index (smallest index = 0). - Big endian: increasing order of qubit index/coupler index. - Full system Hilbert space structure: little endian, qubits first then couplers. - """ - - def __init__(self, model_config: dict, sim_opts: Optional[Options] = None): - """Initializes with qutip simulation engine with model_config and qutip - simulation options. - - Args: - model_config (dict): Model configuration dictionary. - sim_opts (`qutip.Options`, optional): Qutip simulation options. If None, default - options are used. - """ - self.model_config = model_config - if sim_opts is None: - sim_opts = get_default_qutip_sim_opts() - self.sim_opts = sim_opts - self.update() - - def update(self): - """Updates the simulation engine by loading all parameters from - `self.model_config` and `self.sim_opts`.""" - ### from model_config ### - self.nlevels_q = self.model_config["nlevels_q"] # as per runcard, big endian - self.nlevels_c = self.model_config["nlevels_c"] # as per runcard, big endian - self.qubits_list = self.model_config[ - "qubits_list" - ] # as per runcard, big endian - self.couplers_list = self.model_config[ - "couplers_list" - ] # as per runcard, big endian - self.HS_list, self.nlevels_HS = specify_hilbert_space( - self.model_config, LITTLE_ENDIAN - ) - - self.topology = self.model_config["topology"] - self.nqubits = len(self.qubits_list) - self.ncouplers = len(self.couplers_list) - self.sim_method = self.model_config["method"] - - ### derived parameters ### - self.qid_nlevels_map = {} # coupler and qubit cannot have the same label - for i, c in enumerate(self.couplers_list): - self.qid_nlevels_map.update({c: self.nlevels_c[i]}) - for i, q in enumerate(self.qubits_list): - self.qid_nlevels_map.update({q: self.nlevels_q[i]}) - - ### n-level qubit/coupler base operators ### - self.op_dict = {"basis": {}, "sig": {}, "pm1_matrix": {}, "id": {}} - for qid, nlevels in self.qid_nlevels_map.items(): - basis_list = [basis(nlevels, i) for i in range(nlevels)] - sig = [ - [basis_list[i] * basis_list[j].dag() for j in range(nlevels)] - for i in range(nlevels) - ] - self.op_dict["basis"].update({qid: basis_list}) - self.op_dict["sig"].update({qid: sig}) - self.op_dict["pm1_matrix"].update( - {qid: [(sig[i][i + 1] + sig[i + 1][i]) / 2 for i in range(nlevels - 1)]} - ) - Id = sig[0][0] - for i in range(1, nlevels): - Id += sig[i][i] - self.op_dict["id"].update({qid: Id}) - - ### operator connector dictionary ### - self.op_connectors_dict = OrderedDict( - [ - ("^", lambda a, b: tensor(a, b)), - ("*", lambda a, b: a * b), - ("+", lambda a, b: a + b), - ("-", lambda a, b: a - b), - ] - ) - - ### multi-qubit qubit-coupler up-state ### - self.basis_list = self.op_dict["basis"] - self.psi0 = Qobj(1) - for i, qind in enumerate(self.HS_list): - if i == 0: - self.psi0 = self.basis_list[qind][0] - else: - self.psi0 = tensor(self.psi0, self.basis_list[qind][0]) - - ### build dictionary of base qutip operators ### - self.op_dict.update( - { - "b": {}, - "bdag": {}, - "O": {}, - "X": {}, - "Z01": {}, - "sp01": {}, - } - ) - - ### Construct qutip op_dict for each qubit and coupler ### - for qid, nlevels in self.qid_nlevels_map.items(): - sig = self.op_dict["sig"][qid] - b = sig[0][1] - for i in range(nlevels - 2): - b += np.sqrt(i + 2) * sig[i + 1][i + 2] - bdag = b.dag() - O = bdag * b - X = b + bdag - Z01 = sig[0][0] - sig[1][1] - sp01 = sig[0][1] - - self.op_dict["b"].update({qid: b}) - self.op_dict["bdag"].update({qid: bdag}) - self.op_dict["O"].update({qid: O}) - self.op_dict["X"].update({qid: X}) - self.op_dict["Z01"].update({qid: Z01}) - self.op_dict["sp01"].update({qid: sp01}) - - ## initialize operators ## - self.drift = Qobj(dims=[self.nlevels_HS, self.nlevels_HS]) - self.operators = {} - self.static_dissipators = [] - - ### drift ### - for op_instruction in self.model_config["drift"]["one_body"]: - self.drift += self.make_operator(op_instruction) - for op_instruction in self.model_config["drift"]["two_body"]: - self.drift += self.make_operator(op_instruction) - - ### drive ### - for channel_name, op_instruction_list in self.model_config["drive"].items(): - channel_op = Qobj(dims=[self.nlevels_HS, self.nlevels_HS]) - for op_instruction in op_instruction_list: - channel_op += self.make_operator(op_instruction) - self.operators.update({channel_name: channel_op}) - - ### dissipation ### - for op_instruction in self.model_config["dissipation"]["t1"]: - self.static_dissipators += [self.make_operator(op_instruction)] - for op_instruction in self.model_config["dissipation"]["t2"]: - self.static_dissipators += [self.make_operator(op_instruction)] - - def make_arbitrary_state( - self, statedata: np.ndarray, is_qibo_state_vector: bool = False - ) -> Qobj: - """Creates a quantum state object of the full system Hilbert space - using the given state data. - - Args: - statedata (np.ndarray): The state data, in little endian order for compatibility with pulse simulation. - is_qibo_state_vector (bool): Flag to change statedata from big endian (qibo convention) to little endian order. - - Returns: - `qutip.Qobj`: The quantum state object. - """ - if len(statedata.shape) == 1: # statevector - dims = [self.nlevels_HS, np.ones(len(self.nlevels_HS), dtype=int).tolist()] - else: # density matrix - dims = [self.nlevels_HS, self.nlevels_HS] - arbitrary_state = make_arbitrary_state(statedata, dims) - if is_qibo_state_vector is True: - arbitrary_state = self.flip_HS(arbitrary_state) - - return arbitrary_state - - def extend_op_dim( - self, op_qobj: Qobj, op_indices_q: List[int] = [0], op_indices_c: List[int] = [] - ) -> Qobj: - """Extends the dimension of an operator from its local Hilbert space to - the full system Hilbert space. - - Args: - op_qobj (`qutip.Qobj`): The quantum object representation of the operator in the local Hilbert space. - op_indices_q (list): List of qubit indices involved in the operator, in little endian order. - op_indices_c (list): List of coupler indices involved in the operator, in little endian order. - - Returns: - `qutip.Qobj`: The quantum object representation of the operator in the full system Hilbert space. - """ - return extend_op_dim( - op_qobj, - op_indices_q, - op_indices_c, - nlevels_q=self.nlevels_q, - nlevels_c=self.nlevels_c, - ) - - def make_operator(self, op_instruction) -> Qobj: - """Constructs the operator specified by op_instruction as a Qobj and - extends it to the full system Hilbert space. - - Args: - op_instruction (tuple): The instruction tuple containing the coefficient, operator string, and a list of qubit IDs that the operator acts on. The operator string and the qubit ID list are required to be in little endian order, and should have consistent qubit IDs. - - Returns: - `qutip.Qobj`: The quantum object representation of the operator in the full system Hibert space. - """ - coeff, s, op_qid_list = op_instruction - op_localHS = op_from_instruction( - op_instruction, - op_dict=self.op_dict, - op_connectors_dict=self.op_connectors_dict, - ) - - op_indices_q = [] - op_indices_c = [] - for k in op_qid_list: - if k in self.qubits_list: - op_indices_q.append(self.qubits_list.index(k)) - if k in self.couplers_list: - op_indices_c.append(self.couplers_list.index(k)) - - op_fullHS = self.extend_op_dim( - op_localHS, op_indices_q=op_indices_q, op_indices_c=op_indices_c - ) - return op_fullHS - - def flip_HS(self, state: Qobj): - """Changes state from little endian ordering (qubits, couplers) to big - endian (qubits, couplers) and vice versa, while retaining the same - Hilbert space structure with qubits first followed by couplers.""" - nqubits_total = self.nqubits + self.ncouplers - flipped_q_indices = np.flip(range(nqubits_total)[: self.nqubits]) - flipped_c_indices = np.flip(range(nqubits_total)[self.nqubits :]) - reordering_flip = np.append(flipped_q_indices, flipped_c_indices).astype(int) - - return state.permute(reordering_flip) - - def qevolve( - self, - channel_waveforms: dict, - simulate_dissipation: bool = False, - ) -> tuple[np.ndarray, List[int]]: - """Performs the quantum dynamics simulation. - - Args: - channel_waveforms (dict): The dictionary containing the list of discretized time steps and the corresponding channel waveform amplitudes labelled by the respective channel names. - simulate_dissipation (bool): Flag to add (True) or not (False) the dissipation terms associated with T1 and T2 times. - - Returns: - tuple: A tuple containing a dictionary of time-related information (sequence duration, simulation time step, and simulation time), the reduced density matrix of the quantum state at the end of simulation in the Hilbert space specified by the qubits present in the readout channels (little endian), as well as the corresponding list of qubit indices. - """ - full_time_list = channel_waveforms["time"] - channel_names = list(channel_waveforms["channels"].keys()) - - fp_list = [] - for channel_name in channel_names: - fp_list.append( - function_from_array( - channel_waveforms["channels"][channel_name], full_time_list - ) - ) - - drift = self.drift - scheduled_operators = [] - ro_qubit_list = [] - - # add corresponding operators for non-readout channels to scheduled_operators; add qubit indices of readout channels to ro_qubit_list - for channel_name in channel_names: - if channel_name[:2] != "R-": - scheduled_operators.append(self.operators[channel_name]) - else: - ro_qubit_list.append(int(channel_name[2:])) - ro_qubit_list = np.flip(np.sort(ro_qubit_list)) - - if simulate_dissipation is True: - static_dissipators = self.static_dissipators - else: - static_dissipators = [] - - H = [drift] - for i, op in enumerate(scheduled_operators): - H.append([op, fp_list[i]]) - - sim_start_time = timer() - if self.sim_method == "master_equation": - result = mesolve( - H, - self.psi0, - full_time_list, - c_ops=static_dissipators, - options=self.sim_opts, - progress_bar=EnhancedTextProgressBar( - len(full_time_list), int(len(full_time_list) / 100) - ), - ) - - sim_end_time = timer() - sim_time = sim_end_time - sim_start_time - - final_state = result.states[ - -1 - ] # result.states in little endian, opposite to qibo convention - - times_dict = { - "sequence_duration": full_time_list[-1], - "simulation_dt": full_time_list[1], - "simulation_time": sim_time, - } - - return ( - times_dict, - result.states, - *self.qobj_to_reduced_dm(final_state, ro_qubit_list), - ) - - def qobj_to_reduced_dm( - self, emu_qstate: Qobj, qubit_list: List[int] - ) -> tuple[np.ndarray, List[int]]: - """Computes the reduced density matrix of the emulator quantum state - specified by `qubit_list`. - - Args: - emu_qstate (`qutip.Qobj`): Quantum state (full system Hilbert space). - qubit_list (list): List of target qubit indices to keep in the reduced density matrix. Order of qubit indices is not important. - - Returns: - tuple: The resulting reduced density matrix and the little endian ordered list of qubit indices specifying the Hilbert space of the reduced density matrix. - """ - hilbert_space_ind_list = [] - for qubit_ind in qubit_list: - hilbert_space_ind_list.append( - self.nqubits - 1 - qubit_ind - ) # based on little endian order of HS, qubits only; independent of couplers - reduced_dm = ptrace(emu_qstate, hilbert_space_ind_list).full() - rdm_qubit_list = np.flip(np.sort(qubit_list)).tolist() - - return reduced_dm, rdm_qubit_list - - def state_from_basis_vector( - self, basis_vector: List[int], cbasis_vector: List[int] = None - ) -> Qobj: - """Constructs the corresponding computational basis state of the - generalized Hilbert space specified by qubit_list. - - Args: - basis_vector (List[int]): Generalized bitstring that specifies the computational basis state corresponding to the qubits in big endian order. - cbasis_vector (List[int]): Generalized bitstring that specifies the computational basis state corresponding to the couplers in big endian order. - - Returns: - `qutip.Qobj`: Computational basis state consistent with Hilbert space - structure: little endian, qubits first then couplers. - Raises: - Exception: If the length of basis_vector is not equal to `self.nqubits` or the length of cbasis_vector is not equal to `self.ncouplers`. - """ - # checks - if len(basis_vector) != self.nqubits: - raise Exception("length of basis_vector does not match number of qubits!") - if cbasis_vector is None: - cbasis_vector = [0 for c in range(self.ncouplers)] - else: - if len(cbasis_vector) != self.ncouplers: - raise Exception( - "length of cbasis_vector does not match number of couplers!" - ) - - basis_list = self.op_dict["basis"] - fullstate = Qobj(1) - - combined_basis_vector = cbasis_vector + basis_vector - combined_list = self.couplers_list + self.qubits_list - for ind, coeff in enumerate(combined_basis_vector): - qind = combined_list[ind] - fullstate = tensor( - basis_list[qind][coeff], fullstate - ) # constructs little endian HS, qubits first then couplers, as per evolution - - return fullstate - - def compute_overlaps( - self, - target_states: List[Qobj], - reference_states: Optional[Dict[str, Qobj]] = None, - ) -> dict: - """Calculates the overlaps between a list of target device states, with - respect to a list of reference device states. - - Args: - target_states (list): List of target states (`qutip.Qobj`) of interest. - reference_states (dict, optional): Reference states labelled by their respective keys to compare `target_states` with. If not provided, all basis states of the full device Hilbert space labelled by their generalized bitstrings will be used. - - Returns: - dict: Overlaps for each target state with each reference state. - """ - if reference_states is None: - reference_states = {} - - full_HS_dim = np.prod(self.nlevels_HS) - for state_id in range(full_HS_dim): - basis_string = dec_to_basis_string(state_id, self.nlevels_HS) - basis_state = self.state_from_basis_vector( - basis_string[: self.nqubits], basis_string[self.nqubits :] - ) - psi = ket2dm(basis_state) - reference_states.update({str(basis_string): psi}) - - total_samples = len(target_states) - all_overlaps = {} - for label, ref_state in reference_states.items(): - fid_list = [expect(ref_state, state) for state in target_states] - all_overlaps.update({label: fid_list}) - - return all_overlaps - - -def make_arbitrary_state(statedata: np.ndarray, dims: list[int]) -> Qobj: - """Create a quantum state object using the given state data and dimensions. - - Args: - statedata (np.ndarray): The state data. - dims (list): The dimensions of the state. - - Returns: - `qutip.Qobj`: The quantum state object. - """ - shape = (np.prod(dims[0]), np.prod(dims[1])) - if shape[1] == 1: - statetype = "ket" - elif shape[0] == shape[1]: - statetype = "oper" - - return Qobj(statedata, dims=dims, shape=shape, type=statetype) - - -def extend_op_dim( - op_qobj: Qobj, - op_indices_q: List[int] = [0], - op_indices_c: List[int] = [], - nlevels_q: List[int] = [2], - nlevels_c: List[int] = [], -) -> Qobj: - """Extenda the dimension of the input operator from its local Hilbert space - to a larger n-body Hilbert space. - - Args: - op_qobj (`qutip.Qobj`): The quantum object representation of the operator in the local Hilbert space. - op_indices_q (list): List of qubit indices involved in the operator, in little endian order. Defaults to [0]. - op_indices_c (list): List of coupler indices involved in the operator, in little endian order. Defaults to []. - nlevels_q (list): List of the number of levels for each qubit, in big endian order. Defaults to [2]. - nlevels_c (list): List of the number of levels for each coupler, in big endian order. Defaults to []. - - Returns: - `qutip.Qobj`: The quantum object representation of the operator in the Hilbert space with extended dimensions. Hilbert space structure: little endian, qubits first then couplers. - - Raises: - Exception: If the length of op_qobj.dims[0] does not match the sum of the lengths of op_indices_q and op_indices_c, or if nlevels_q and nlevels_c inputs do not support op_indices_q and op_indices_c, or if dimensions of local Hilbert space operator do not match the nlevels of op_indices_q and op_indices_c. - """ - - ncouplers = len(nlevels_c) - nqubits = len(nlevels_q) - nlevels_cq = nlevels_c + nlevels_q # reverse order from Hilbert space structure - op_indices_q_shifted = [ind + ncouplers for ind in op_indices_q] - op_indices_full = op_indices_q_shifted + op_indices_c - - full_index_list = np.flip(range(nqubits + ncouplers)) - missing_indices = list(full_index_list.copy()) - for ind in full_index_list: - if ind in op_indices_full: - pos = np.where(ind == missing_indices)[0][0] - missing_indices.pop(pos) - - unordered_index_list = op_indices_full + missing_indices - - # checks - if len(op_qobj.dims[0]) != len(op_indices_q) + len(op_indices_c): - raise Exception("op indices and op mismatch!") - try: - nlevels_HS_local = [] - for ind_q in op_indices_q: - nlevels_HS_local.append(nlevels_q[ind_q]) - for ind_c in op_indices_c: - nlevels_HS_local.append(nlevels_c[ind_c]) - except: - raise Exception("op indices dim and nlevels mismatch!") - for ind, nlevel in enumerate(nlevels_HS_local): - if nlevel != op_qobj.dims[0][ind]: - raise Exception(f"mismatch in op dim: index {ind}!") - - full_qobj = op_qobj - for ind in missing_indices: - full_qobj = tensor(full_qobj, Id(nlevels_cq[ind])) - - inverse_qubit_order = np.flip(np.argsort(unordered_index_list)) - - return full_qobj.permute(inverse_qubit_order) diff --git a/src/qibolab/instruments/emulator/models/general_no_coupler_model.py b/src/qibolab/instruments/emulator/models/general_no_coupler_model.py deleted file mode 100644 index c7b37aa1d9..0000000000 --- a/src/qibolab/instruments/emulator/models/general_no_coupler_model.py +++ /dev/null @@ -1,156 +0,0 @@ -from typing import Optional - -import numpy as np - -from qibolab.instruments.emulator.models.methods import ( - default_noflux_platform_to_simulator_channels, -) - - -# model template for 0-1 system -def generate_default_params(): - # all time in ns and frequency in GHz - """Returns template model parameters dictionary.""" - model_params = { - "model_name": "general_no_coupler_model", - "topology": [[0, 1]], - "nqubits": 2, - "ncouplers": 0, - "qubits_list": ["0", "1"], - "couplers_list": [], - "nlevels_q": [2, 2], - "nlevels_c": [], - "readout_error": { - # same key datatype as per runcard - 0: [0.01, 0.02], - 1: [0.01, 0.02], - }, - "drive_freq": { - "0": 5.0, - "1": 5.1, - }, - "T1": { - "0": 0.0, - "1": 0.0, - }, - "T2": { - "0": 0.0, - "1": 0.0, - }, - "lo_freq": { - "0": 5.0, - "1": 5.1, - }, - "rabi_freq": { - "0": 0.2, - "1": 0.2, - }, - "anharmonicity": { - "0": -0.20, - "1": -0.21, - }, - "coupling_strength": { - "1_0": 5.0e-3, - }, - } - return model_params - - -def generate_model_config( - model_params: dict = None, - nlevels_q: Optional[list] = None, - topology: Optional[list] = None, -) -> dict: - """Generates the model configuration dictionary. - - Args: - model_params(dict): Dictionary containing the model parameters. - nlevels_q(list, optional): List of the dimensions of each qubit to be simulated, in big endian order. Defaults to None, in which case it will use the values of model_params['nlevels_q'] will be used. - topology(list, optional): List containing all pairs of qubit indices that are nearest neighbours. Defaults to none, in which case the value of model_params['topology'] will be used. - - Returns: - dict: Model configuration dictionary with all frequencies in GHz and times in ns. - """ - if model_params is None: - model_params = generate_default_params() - - # allows for user to overwrite topology in model_params for quick test - if topology is None: - topology = model_params["topology"] - - model_name = model_params["model_name"] - readout_error = model_params["readout_error"] - qubits_list = model_params["qubits_list"] - - rabi_freq_dict = model_params["rabi_freq"] - - if nlevels_q is None: - nlevels_q = model_params["nlevels_q"] - - drift_hamiltonian_dict = {"one_body": [], "two_body": []} - drive_hamiltonian_dict = {} - - dissipation_dict = {"t1": [], "t2": []} - - # generate instructions - # single qubit terms - for i, q in enumerate(qubits_list): - # drift Hamiltonian terms (constant in time) - drift_hamiltonian_dict["one_body"].append( - (2 * np.pi * model_params["lo_freq"][q], f"O_{q}", [q]) - ) - drift_hamiltonian_dict["one_body"].append( - ( - np.pi * model_params["anharmonicity"][q], - f"O_{q} * O_{q} - O_{q}", - [q], - ) - ) - - # drive Hamiltonian terms (amplitude determined by pulse sequence) - drive_hamiltonian_dict.update({f"D-{qubits_list[i]}": []}) - drive_hamiltonian_dict[f"D-{qubits_list[i]}"].append( - (2 * np.pi * model_params["rabi_freq"][q], f"X_{q}", [q]) - ) - - # dissipation terms (one qubit, constant in time) - t1 = model_params["T1"][q] - g1 = 0 if t1 == 0 else 1.0 / t1 * 2 * np.pi - t2 = model_params["T2"][q] - g2 = 0 if t1 == 0 else 1.0 / t2 * 2 * np.pi - - dissipation_dict["t1"].append((np.sqrt(g1 / 2), f"sp01_{q}", [q])) - dissipation_dict["t2"].append((np.sqrt(g2 / 2), f"Z01_{q}", [q])) - - # two-body terms (couplings) - for key in list(model_params["coupling_strength"].keys()): - ind2, ind1 = key.split( - "_" - ) # ind2 > ind1 with ind_qubit > ind_coupler as per Hilbert space ordering - coupling = model_params["coupling_strength"][key] - drift_hamiltonian_dict["two_body"].append( - ( - 2 * np.pi * coupling, - f"bdag_{ind2} ^ b_{ind1} + b_{ind2} ^ bdag_{ind1}", - [ind2, ind1], - ) - ) - - model_config = { - "model_name": model_name, - "topology": topology, - "qubits_list": qubits_list, - "nlevels_q": nlevels_q, - "couplers_list": [], - "nlevels_c": [], - "drift": drift_hamiltonian_dict, - "drive": drive_hamiltonian_dict, - "dissipation": dissipation_dict, - "method": "master_equation", - "readout_error": readout_error, - "platform_to_simulator_channels": default_noflux_platform_to_simulator_channels( - qubits_list, couplers_list=[] - ), - } - - return model_config diff --git a/src/qibolab/instruments/emulator/models/methods.py b/src/qibolab/instruments/emulator/models/methods.py deleted file mode 100644 index 1ab27f4d1d..0000000000 --- a/src/qibolab/instruments/emulator/models/methods.py +++ /dev/null @@ -1,20 +0,0 @@ -import operator -from functools import reduce - - -def default_noflux_platform_to_simulator_channels( - qubits_list: list, couplers_list: list -) -> dict: - """Returns the default dictionary that maps platform channel names to simulator channel names. - Args: - qubits_list (list): List of qubit names to be included in the simulation. - couplers_list (list): List of coupler names to be included in the simulation. - - Returns: - dict: Mapping between platform channel names to simulator chanel names. - """ - return reduce( - operator.or_, - [{f"drive-{q}": f"D-{q}", f"readout-{q}": f"R-{q}"} for q in qubits_list] - + [{f"drive-{c}": f"D-{c}"} for c in couplers_list], - ) diff --git a/src/qibolab/instruments/emulator/models/models_template.py b/src/qibolab/instruments/emulator/models/models_template.py deleted file mode 100644 index 2efed9b8da..0000000000 --- a/src/qibolab/instruments/emulator/models/models_template.py +++ /dev/null @@ -1,178 +0,0 @@ -import numpy as np - -from qibolab.instruments.emulator.models.methods import ( - default_noflux_platform_to_simulator_channels, -) - - -# model template for 0-c1-1 system -def generate_default_params(): - # all time in ns and frequency in GHz - """Returns template model parameters dictionary.""" - model_params = { - "model_name": "models_template", - "topology": [[0, 1]], - "nqubits": 2, - "ncouplers": 1, - "qubits_list": ["0", "1"], - "couplers_list": ["c1"], - "sampling_rate": 2.0, # units of samples/ns - "readout_error": { - # same key datatype as per runcard - 0: [0.01, 0.02], - 1: [0.01, 0.02], - }, - "drive_freq": { - "0": 5.0, - "1": 5.1, - }, - "T1": { - "0": 0.0, - "1": 0.0, - }, - "T2": { - "0": 0.0, - "1": 0.0, - }, - "lo_freq": { - "0": 5.0, - "1": 5.1, - "c1": 6.5, - }, - "rabi_freq": { - "0": 0.2, - "1": 0.2, - }, - "anharmonicity": { - "0": -0.20, - "1": -0.21, - "c1": -0.1, - }, - "coupling_strength": { - "1_c1": 101.0e-3, - "0_c1": 100.0e-3, - "1_0": 5.0e-3, - }, - } - return model_params - - -# template for general (no flux) model -def generate_model_config( - model_params: dict = None, - nlevels_q: list = None, - nlevels_c: list = None, - topology: list = None, -) -> dict: - """Generates a template model configuration dictionary. - - Args: - model_params(dict): Dictionary containing the model parameters. - nlevels_q(list, optional): List of the dimensions of each qubit to be simulated, in big endian order. Defaults to none, in which case a list of 2s with the same length as model_params['qubits_list'] will be used. - nlevels_c(list, optional): List of the dimensions of each coupler to be simulated, in big endian order. Defaults to none, in which case a list of 2s with the same length as model_params['couplers_list'] will be used. - topology(list, optional): List containing all pairs of qubit indices that are nearest neighbours. Defaults to none, in which case the value of model_params['topology'] will be used. - - Returns: - dict: Model configuration dictionary with all frequencies in GHz and times in ns. - """ - if model_params is None: - model_params = generate_default_params() - - # allows for user to overwrite topology in model_params for quick test - if topology is None: - topology = model_params["topology"] - - model_name = model_params["model_name"] - sampling_rate = model_params["sampling_rate"] - readout_error = model_params["readout_error"] - qubits_list = model_params["qubits_list"] - couplers_list = model_params["couplers_list"] - - if nlevels_q is None: - nlevels_q = [2 for q in qubits_list] - if nlevels_c is None: - nlevels_c = [2 for c in couplers_list] - - rabi_freq_dict = model_params["rabi_freq"] - - drift_hamiltonian_dict = {"one_body": [], "two_body": []} - drive_hamiltonian_dict = {} - - dissipation_dict = {"t1": [], "t2": []} - - # generate instructions - # single qubit terms - for i, q in enumerate(qubits_list): - # drift Hamiltonian terms (constant in time) - drift_hamiltonian_dict["one_body"].append( - (2 * np.pi * model_params["lo_freq"][q], f"O_{q}", [q]) - ) - drift_hamiltonian_dict["one_body"].append( - ( - np.pi * model_params["anharmonicity"][q], - f"O_{q} * O_{q} - O_{q}", - [q], - ) - ) - - # drive Hamiltonian terms (amplitude determined by pulse sequence) - drive_hamiltonian_dict.update({f"D-{qubits_list[i]}": []}) - drive_hamiltonian_dict[f"D-{qubits_list[i]}"].append( - (2 * np.pi * model_params["rabi_freq"][q], f"X_{q}", [q]) - ) - - # dissipation terms (one qubit, constant in time) - t1 = model_params["T1"][q] - g1 = 0 if t1 == 0 else 1.0 / t1 - t2 = model_params["T2"][q] - g2 = 0 if t1 == 0 else 1.0 / t2 - - dissipation_dict["t1"].append((np.sqrt(g1), f"sp01_{q}", [q])) - dissipation_dict["t2"].append((np.sqrt(g2), f"Z01_{q}", [q])) - - # single coupler terms - for i, c in enumerate(couplers_list): - # drift Hamiltonian terms (constant in time) - drift_hamiltonian_dict["one_body"].append( - (2 * np.pi * model_params["lo_freq"][c], f"O_{c}", [c]) - ) - drift_hamiltonian_dict["one_body"].append( - ( - np.pi * model_params["anharmonicity"][c], - f"O_{c} * O_{c} - O_{c}", - [c], - ) - ) - - ## two-body terms (couplings) - for key in list(model_params["coupling_strength"].keys()): - ind2, ind1 = key.split( - "_" - ) # ind2 > ind1 with ind_qubit > ind_coupler as per Hilbert space ordering - coupling = model_params["coupling_strength"][key] - drift_hamiltonian_dict["two_body"].append( - ( - 2 * np.pi * coupling, - f"bdag_{ind2} ^ b_{ind1} + b_{ind2} ^ bdag_{ind1}", - [ind2, ind1], - ) - ) - - model_config = { - "model_name": model_name, - "topology": topology, - "qubits_list": qubits_list, - "nlevels_q": nlevels_q, - "couplers_list": couplers_list, - "nlevels_c": nlevels_c, - "drift": drift_hamiltonian_dict, - "drive": drive_hamiltonian_dict, - "dissipation": dissipation_dict, - "method": "master_equation", - "readout_error": readout_error, - "platform_to_simulator_channels": default_noflux_platform_to_simulator_channels( - qubits_list, couplers_list - ), - } - - return model_config diff --git a/src/qibolab/instruments/emulator/pulse_simulator.py b/src/qibolab/instruments/emulator/pulse_simulator.py deleted file mode 100644 index 07e40aceb7..0000000000 --- a/src/qibolab/instruments/emulator/pulse_simulator.py +++ /dev/null @@ -1,761 +0,0 @@ -"""Pulse simulator module for running quantum dynamics simulation of model of -device.""" - -import copy -import operator -from typing import Dict, List, Union - -import numpy as np - -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters -from qibolab.couplers import Coupler -from qibolab.instruments.abstract import Controller -from qibolab.instruments.emulator.engines.qutip_engine import QutipSimulator -from qibolab.instruments.emulator.models import general_no_coupler_model -from qibolab.pulses import PulseSequence, PulseType, ReadoutPulse -from qibolab.qubits import Qubit, QubitId -from qibolab.result import IntegratedResults, SampleResults -from qibolab.sweeper import Parameter, Sweeper, SweeperType - -AVAILABLE_SWEEP_PARAMETERS = { - Parameter.amplitude, - Parameter.duration, - Parameter.frequency, - Parameter.relative_phase, - Parameter.start, -} - -SIMULATION_ENGINES = { - "Qutip": QutipSimulator, -} - -MODELS = { - "general_no_coupler_model": general_no_coupler_model, -} - -GHZ = 1e9 - - -class PulseSimulator(Controller): - """Runs quantum dynamics simulation of model of device. - - Interfaces with Qibolab. Useful for testing code without requiring - access to hardware. - """ - - PortType = None - - def __init__(self): - super().__init__(name=None, address=None) - - @property - def sampling_rate(self): - return self._sampling_rate - - def setup(self, **kwargs): - """Updates the pulse simulator by loading all parameters from - `model_config` and `simulation_config`.""" - super().setup(kwargs["bounds"]) - self.settings = kwargs - - simulation_config = kwargs["simulation_config"] - model_params = kwargs["model_params"] - sim_opts = kwargs["sim_opts"] - - model_name = model_params["model_name"] - model_config = MODELS[model_name].generate_model_config(model_params) - - simulation_engine_name = simulation_config["simulation_engine_name"] - self.simulation_engine = SIMULATION_ENGINES[simulation_engine_name]( - model_config, sim_opts - ) - - # Settings for pulse processing - self._sampling_rate = simulation_config["sampling_rate"] - self.sim_sampling_boost = simulation_config["sim_sampling_boost"] - self.runcard_duration_in_dt_units = simulation_config[ - "runcard_duration_in_dt_units" - ] - self.instant_measurement = simulation_config["instant_measurement"] - self.platform_to_simulator_channels = model_config[ - "platform_to_simulator_channels" - ] - - self.readout_error = { - int(k): v for k, v in model_config["readout_error"].items() - } - self.simulate_dissipation = simulation_config["simulate_dissipation"] - self.output_state_history = simulation_config["output_state_history"] - - def connect(self): - pass - - def disconnect(self): - pass - - def dump(self): - return self.settings | super().dump() - - def run_pulse_simulation( - self, - sequence: PulseSequence, - instant_measurement: bool = True, - ) -> tuple[np.ndarray, list]: - """Simulates the input pulse sequence. - - Args: - sequence (`qibolab.pulses.PulseSequence`): Pulse sequece to simulate. - instant_measurement (bool): Collapses readout pulses to duration of 1 if True. Defaults to True. - - Returns: - tuple: A tuple containing a dictionary of time-related information (sequence duration, simulation time step, and simulation time), the reduced density matrix of the quantum state at the end of simulation in the Hilbert space specified by the qubits present in the readout channels (little endian), as well as the corresponding list of qubit indices. - """ - # reduces measurement time to 1 dt to save simulation time - if instant_measurement: - sequence = truncate_ro_pulses(sequence) - - # extract waveforms from pulse sequence - channel_waveforms = ps_to_waveform_dict( - sequence, - self.platform_to_simulator_channels, - self.sampling_rate, - self.sim_sampling_boost, - self.runcard_duration_in_dt_units, - ) - - # execute pulse simulation in emulator - simulation_results = self.simulation_engine.qevolve( - channel_waveforms, self.simulate_dissipation - ) - - return simulation_results - - def play( - self, - qubits: Dict[QubitId, Qubit], - couplers: Dict[QubitId, Coupler], - sequence: PulseSequence, - execution_parameters: ExecutionParameters, - ) -> dict[str, Union[IntegratedResults, SampleResults]]: - """Executes the sequence of instructions and generates readout results, - as well as simulation-related time and states data. - - Args: - qubits (dict): Qubits involved in the device. Does not affect emulator. - couplers (dict): Couplers involved in the device. Does not affect emulator. - sequence (`qibolab.pulses.PulseSequence`): Pulse sequence to simulate. - execution_parameters (`qibolab.ExecutionParameters`): Parameters (nshots, - relaxation_time, - fast_reset, - acquisition_type, - averaging_mode) - - Returns: - dict: A dictionary mapping the readout pulses serial and respective qubits to - Qibolab results object, as well as simulation-related time and states data. - """ - nshots = execution_parameters.nshots - ro_pulse_list = sequence.ro_pulses - times_dict, output_states, ro_reduced_dm, rdm_qubit_list = ( - self.run_pulse_simulation(sequence, self.instant_measurement) - ) - if not self.output_state_history: - output_states = output_states[-1] - - samples = get_samples( - nshots, - ro_reduced_dm, - rdm_qubit_list, - self.simulation_engine.qid_nlevels_map, - ) - # apply default readout noise - if self.readout_error is not None: - samples = apply_readout_noise(samples, self.readout_error) - # generate result object - results = get_results_from_samples(ro_pulse_list, samples, execution_parameters) - results["simulation"] = { - "sequence_duration": times_dict["sequence_duration"], - "simulation_dt": times_dict["simulation_dt"], - "simulation_time": times_dict["simulation_time"], - "output_states": output_states, - } - - return results - - ### sweeper adapted from icarusqfpga ### - def sweep( - self, - qubits: Dict[QubitId, Qubit], - couplers: Dict[QubitId, Coupler], - sequence: PulseSequence, - execution_parameters: ExecutionParameters, - *sweeper: List[Sweeper], - ) -> dict[str, Union[IntegratedResults, SampleResults, dict]]: - """Executes the sweep and generates readout results, as well as - simulation-related time and states data. - - Args: - qubits (dict): Qubits involved in the device. Does not affect emulator. - couplers (dict): Couplers involved in the device. Does not affect emulator. - sequence (`qibolab.pulses.PulseSequence`): Pulse sequence to simulate. - execution_parameters (`qibolab.ExecutionParameters`): Parameters (nshots, - relaxation_time, - fast_reset, - acquisition_type, - averaging_mode) - *sweepers (`qibolab.Sweeper`): Sweeper objects. - - Returns: - dict: A dictionary mapping the readout pulses serial and respective qubits to - Qibolab results objects, as well as simulation-related time and states data. - - Raises: - NotImplementedError: If sweep.parameter is not in AVAILABLE_SWEEP_PARAMETERS. - """ - sweeper_shape = [len(sweep.values) for sweep in sweeper] - - # Record pulse values before sweeper modification - bsv = [] - for sweep in sweeper: - param_name = sweep.parameter.name.lower() - if sweep.parameter not in AVAILABLE_SWEEP_PARAMETERS: - raise NotImplementedError( - "Sweep parameter requested not available", param_name - ) - base_sweeper_values = [getattr(pulse, param_name) for pulse in sweep.pulses] - bsv.append(base_sweeper_values) - - sweep_samples = self._sweep_recursion( - qubits, couplers, sequence, execution_parameters, *sweeper - ) - output_states_list = sweep_samples.pop("output_states") - sequence_duration_array = sweep_samples.pop("sequence_duration") - simulation_dt_array = sweep_samples.pop("simulation_dt") - simulation_time_array = sweep_samples.pop("simulation_time") - - # reshape output_states to sweeper dimensions - output_states_array = np.ndarray(sweeper_shape, dtype=list) - listlen = len(output_states_list) // np.prod(sweeper_shape) - array_indices = make_array_index_list(sweeper_shape) - for index in array_indices: - output_states_array[tuple(index)] = output_states_list[:listlen] - output_states_list = output_states_list[listlen:] - - # reshape time data to sweeper dimensions - sequence_duration_array = np.array(sequence_duration_array).reshape( - sweeper_shape - ) - simulation_dt_array = np.array(simulation_dt_array).reshape(sweeper_shape) - simulation_time_array = np.array(simulation_time_array).reshape(sweeper_shape) - - # reshape and reformat samples to results format - results = get_results_from_samples( - sequence.ro_pulses, sweep_samples, execution_parameters, sweeper_shape - ) - - # Reset pulse values back to original values (following icarusqfpga) - for sweep, base_sweeper_values in zip(sweeper, bsv): - param_name = sweep.parameter.name.lower() - for pulse, value in zip(sweep.pulses, base_sweeper_values): - setattr(pulse, param_name, value) - # Since the sweeper will modify the readout pulse serial, we collate the results with the qubit number. - # This is only for qibocal compatiability and will be removed with IcarusQ v2. - if pulse.type is PulseType.READOUT: - results[pulse.serial] = results[pulse.qubit] - - results.update( - { - "simulation": { - "sequence_duration": sequence_duration_array, - "simulation_dt": simulation_dt_array, - "simulation_time": simulation_time_array, - "output_states": output_states_array, - } - } - ) - - return results - - def _sweep_recursion( - self, - qubits: Dict[QubitId, Qubit], - couplers: Dict[QubitId, Coupler], - sequence: PulseSequence, - execution_parameters: ExecutionParameters, - *sweeper: Sweeper, - ) -> dict[Union[str, int], list]: - """Performs sweep by recursion. Appends sampled lists and other - simulation data obtained from each call of `self._sweep_play`. - - Args: - qubits (dict): Qubits involved in the device. Does not affect emulator. - couplers (dict): Couplers involved in the device. Does not affect emulator. - sequence (`qibolab.pulses.PulseSequence`): Pulse sequence to simulate. - execution_parameters (`qibolab.ExecutionParameters`): Parameters (nshots, - relaxation_time, - fast_reset, - acquisition_type, - averaging_mode) - *sweepers (`qibolab.Sweeper`): Sweeper objects. - - Returns: - dict: A dictionary mapping the qubit indices to list of sampled values, simulation-related time data, and simulated states data. - """ - - if len(sweeper) == 0: - times_dict, output_states, samples = self._sweep_play( - qubits, couplers, sequence, execution_parameters - ) - if not self.output_state_history: - output_states = [output_states[-1]] - samples.update({"output_states": output_states}) - for k, v in times_dict.items(): - samples.update({k: [v]}) - return samples - - sweep = sweeper[0] - param = sweep.parameter - param_name = param.name.lower() - - base_sweeper_values = [getattr(pulse, param_name) for pulse in sweep.pulses] - sweeper_op = _sweeper_operation.get(sweep.type) - ret = {} - - for value in sweep.values: - for idx, pulse in enumerate(sweep.pulses): - base = base_sweeper_values[idx] - setattr(pulse, param_name, sweeper_op(value, base)) - - self.merge_sweep_results( - ret, - self._sweep_recursion( - qubits, couplers, sequence, execution_parameters, *sweeper[1:] - ), - ) - - return ret - - def _sweep_play( - self, - qubits: Dict[QubitId, Qubit], - couplers: Dict[QubitId, Coupler], - sequence: PulseSequence, - execution_parameters: ExecutionParameters, - ) -> dict[Union[str, int], list]: - """Generates simulation-related time data, simulated states data, and - samples list labelled by qubit index. - - Args: - qubits (dict): Qubits involved in the device. Does not affect emulator. - couplers (dict): Couplers involved in the device. Does not affect emulator. - sequence (`qibolab.pulses.PulseSequence`): Pulse sequence to simulate. - execution_parameters (`qibolab.ExecutionParameters`): Parameters (nshots, - relaxation_time, - fast_reset, - acquisition_type, - averaging_mode) - - Returns: - dict: A tuple with dictionary containing simulation-related time data, a list of states at each time step in the simulation, and a dictionary mapping the qubit indices to list of sampled values. - """ - nshots = execution_parameters.nshots - ro_pulse_list = sequence.ro_pulses - - # run pulse simulation - times_dict, state_history, ro_reduced_dm, rdm_qubit_list = ( - self.run_pulse_simulation(sequence, self.instant_measurement) - ) - # generate samples - samples = get_samples( - nshots, - ro_reduced_dm, - rdm_qubit_list, - self.simulation_engine.qid_nlevels_map, - ) - # apply default readout noise - if self.readout_error is not None: - samples = apply_readout_noise(samples, self.readout_error) - - return times_dict, state_history, samples - - @staticmethod - def merge_sweep_results( - dict_a: """dict[str, Union[IntegratedResults, SampleResults, list]]""", - dict_b: """dict[str, Union[IntegratedResults, SampleResults, list]]""", - ) -> """dict[str, Union[IntegratedResults, SampleResults, list]]""": - """Merges two dictionary mapping pulse serial to Qibolab results - object. - - If dict_b has a key (serial) that dict_a does not have, simply add it, - otherwise sum the two results - - Args: - dict_a (dict): dict mapping ro pulses serial to qibolab res objects - dict_b (dict): dict mapping ro pulses serial to qibolab res objects - Returns: - A dict mapping the readout pulses serial to Qibolab results objects - """ - for serial in dict_b: - if serial in dict_a: - dict_a[serial] = dict_a[serial] + dict_b[serial] - else: - dict_a[serial] = dict_b[serial] - return dict_a - - -_sweeper_operation = { - SweeperType.ABSOLUTE: lambda value, base: value, - SweeperType.OFFSET: operator.add, - SweeperType.FACTOR: operator.mul, -} - - -def ps_to_waveform_dict( - sequence: PulseSequence, - platform_to_simulator_channels: dict, - sampling_rate: float = 1.0, - sim_sampling_boost: int = 1, - runcard_duration_in_dt_units: bool = False, -) -> dict[str, Union[np.ndarray, dict[str, np.ndarray]]]: - """Converts pulse sequence to dictionary of time and channel separated - waveforms. - - Args: - sequence (`qibolab.pulses.PulseSequence`): Pulse sequence to simulate. - platform_to_simulator_channels (dict): A dictionary that maps platform channel names to simulator channel names. - sampling_rate (float): Sampling rate in units of samples/ns. Defaults to 1. - sim_sampling_boost (int): Additional factor multiplied to sampling_rate for improving numerical accuracy in simulation. Defaults to 1. - runcard_duration_in_dt_units (bool): If True, assumes that all time-related quantities in the runcard are expressed in units of inverse sampling rate and implements the necessary routines to account for that. If False, assumes that runcard time units are in ns. Defaults to False. - - Returns: - dict: A dictionary containing the full list of simulation time steps, as well as the corresponding discretized channel waveforms labelled by their respective simulation channel names. - """ - times_list = [] - signals_list = [] - emulator_channel_name_list = [] - - def channel_translator(platform_channel_name, frequency): - """Option to add frequency specific channel operators.""" - try: - # frequency dependent channel operation - return platform_to_simulator_channels[platform_channel_name + frequency] - except: - # frequency independent channel operation (default) - return platform_to_simulator_channels[platform_channel_name] - - if runcard_duration_in_dt_units: - """Assumes pulse duration in runcard is in units of dt=1/sampling_rate, - i.e. time interval between samples. - - Pulse duration in this case is simply the total number of time - samples; pulse.start and pulse.duration are therefore integers, - and sampling_rate is only used to construct the value of dt in - ns. - """ - for qubit in sequence.qubits: - qubit_pulses = sequence.get_qubit_pulses(qubit) - for channel in qubit_pulses.channels: - channel_pulses = qubit_pulses.get_channel_pulses(channel) - for i, pulse in enumerate(channel_pulses): - start = int(pulse.start * sim_sampling_boost) - actual_pulse_frequency = ( - pulse.frequency - ) # store actual pulse frequency for channel_translator - # rescale frequency to be compatible with sampling_rate = 1 - pulse.frequency = pulse.frequency / sampling_rate - # need to first set pulse._if in GHz to use modulated_waveform_i method - pulse._if = pulse.frequency / GHZ - - i_env = pulse.envelope_waveform_i(sim_sampling_boost).data - q_env = pulse.envelope_waveform_q(sim_sampling_boost).data - - # Qubit drive microwave signals - end = start + len(i_env) - t = np.arange(start, end) / sampling_rate / sim_sampling_boost - cosalpha = np.cos( - 2 * np.pi * pulse._if * sampling_rate * t + pulse.relative_phase - ) - sinalpha = np.sin( - 2 * np.pi * pulse._if * sampling_rate * t + pulse.relative_phase - ) - pulse_signal = i_env * sinalpha + q_env * cosalpha - # pulse_signal = pulse_signal/np.sqrt(2) # uncomment for ibm runcard - - times_list.append(t) - signals_list.append(pulse_signal) - - if pulse.type.value == "qd": - platform_channel_name = f"drive-{qubit}" - # TODO: to add during flux pulse update - # elif pulse.type.value == "qf": - # platform_channel_name = f"flux-{qubit}" - elif pulse.type.value == "ro": - platform_channel_name = f"readout-{qubit}" - - # restore pulse frequency values - pulse.frequency = actual_pulse_frequency - pulse._if = pulse.frequency / GHZ - - emulator_channel_name_list.append( - channel_translator(platform_channel_name, pulse._if) - ) - - tmin, tmax = [], [] - for times in times_list: - tmin.append(np.amin(times)) - tmax.append(np.amax(times)) - - tmin = np.amin(tmin) - tmax = np.amax(tmax) - Nt = int(np.round((tmax - tmin) * sampling_rate * sim_sampling_boost) + 1) - full_time_list = np.linspace(tmin, tmax, Nt) - - else: - """Assumes pulse duration in runcard is in ns.""" - for qubit in sequence.qubits: - qubit_pulses = sequence.get_qubit_pulses(qubit) - for channel in qubit_pulses.channels: - channel_pulses = qubit_pulses.get_channel_pulses(channel) - for i, pulse in enumerate(channel_pulses): - sim_sampling_rate = sampling_rate * sim_sampling_boost - - start = int(pulse.start * sim_sampling_rate) - # need to first set pulse._if in GHz to use modulated_waveform_i method - pulse._if = pulse.frequency / GHZ - - i_env = pulse.envelope_waveform_i(sim_sampling_rate).data - q_env = pulse.envelope_waveform_q(sim_sampling_rate).data - - # Qubit drive microwave signals - end = start + len(i_env) - t = np.arange(start, end) / sim_sampling_rate - cosalpha = np.cos(2 * np.pi * pulse._if * t + pulse.relative_phase) - sinalpha = np.sin(2 * np.pi * pulse._if * t + pulse.relative_phase) - pulse_signal = i_env * sinalpha + q_env * cosalpha - # pulse_signal = pulse_signal/np.sqrt(2) # uncomment for ibm runcard - - times_list.append(t) - signals_list.append(pulse_signal) - - if pulse.type.value == "qd": - platform_channel_name = f"drive-{qubit}" - # TODO: add during flux pulse update - # elif pulse.type.value == "qf": - # platform_channel_name = f"flux-{qubit}" - elif pulse.type.value == "ro": - platform_channel_name = f"readout-{qubit}" - - emulator_channel_name_list.append( - channel_translator(platform_channel_name, pulse._if) - ) - - tmin, tmax = [], [] - for times in times_list: - tmin.append(np.amin(times)) - tmax.append(np.amax(times)) - - tmin = np.amin(tmin) - tmax = np.amax(tmax) - Nt = int(np.round((tmax - tmin) * sampling_rate * sim_sampling_boost) + 1) - full_time_list = np.linspace(tmin, tmax, Nt) - - channel_waveforms = {"time": full_time_list, "channels": {}} - - unique_channel_names = np.unique(emulator_channel_name_list) - for channel_name in unique_channel_names: - waveform = np.zeros(len(full_time_list)) - - for i, pulse_signal in enumerate(signals_list): - if emulator_channel_name_list[i] == channel_name: - for t_ind, t in enumerate(times_list[i]): - full_t_ind = int( - np.round((t - tmin) * sampling_rate * sim_sampling_boost) - ) - waveform[full_t_ind] += pulse_signal[t_ind] - - channel_waveforms["channels"].update({channel_name: waveform}) - - return channel_waveforms - - -def apply_readout_noise( - samples: dict[Union[str, int], list], - readout_error: dict[Union[int, str], list], -) -> dict[Union[str, int], list]: - """Applies readout noise to samples. - - Args: - samples (dict): Samples generated from get_samples. - readout_error (dict): Dictionary specifying the readout noise for each qubit. Readout noise is specified by a list containing probabilities of prepare 0 measure 1, and prepare 1 measure 0. - - Returns: - dict: The noisy sampled qubit values for each qubit labelled by its index. - - Raises: - ValueError: If the readout qubits given by samples.keys() is not a subset of the qubits with readout errors specified in readout_error. - """ - # check if readout error is specified for all ro qubits - ro_qubit_list = list(samples.keys()) - if not set(ro_qubit_list).issubset(readout_error.keys()): - raise ValueError(f"Not all readout qubits are present in readout_error!") - noisy_samples = {} - for ro_qubit in ro_qubit_list: # samples.keys(): - noisy_samples.update({ro_qubit: []}) - p0m1, p1m0 = readout_error[ro_qubit] - qubit_values = samples[ro_qubit] - - for i, v in enumerate(qubit_values): - if v == 0: - noisy_samples[ro_qubit].append( - np.random.choice([0, 1], p=[1 - p0m1, p0m1]) - ) - else: - noisy_samples[ro_qubit].append( - np.random.choice([0, 1], p=[p1m0, 1 - p1m0]) - ) - - return noisy_samples - - -def make_comp_basis( - qubit_list: List[Union[int, str]], qid_nlevels_map: dict[Union[int, str], int] -) -> np.ndarray: - """Generates the computational basis states of the Hilbert space. - - Args: - qubit_list (list): List of target qubit indices to generate the local Hilbert space of the qubits that respects the order given by qubit_list. - qid_nlevels_map (dict): Dictionary mapping the qubit IDs given in qubit_list to their respective Hilbert space dimensions. - - Returns: - `np.ndarray`: The list of computation basis states of the local Hilbert space in a numpy array. - """ - nqubits = len(qubit_list) - qid_list = [str(qubit) for qubit in qubit_list] - nlevels = [qid_nlevels_map[qid] for qid in qid_list] - - return make_array_index_list(nlevels) - - -def make_array_index_list(array_shape: list): - """Generates all indices of an array of arbitrary shape in ascending - order.""" - return np.indices(array_shape).reshape(len(array_shape), -1).T - - -def get_results_from_samples( - ro_pulse_list: list, - samples: dict[Union[str, int], list], - execution_parameters: ExecutionParameters, - prepend_to_shape: list = [], -) -> dict[str, Union[IntegratedResults, SampleResults]]: - """Converts samples into Qibolab results format. - - Args: - ro_pulse_list (list): List of readout pulse sequences. - samples (dict): Samples generated by get_samples. - append_to_shape (list): Specifies additional dimensions for the shape of the results. Defaults to empty list. - execution_parameters (`qibolab.ExecutionParameters`): Parameters (nshots, - relaxation_time, - fast_reset, - acquisition_type, - averaging_mode) - - Returns: - dict: Qibolab result data. - - Raises: - ValueError: If execution_parameters.acquisition_type is not supported. - """ - shape = prepend_to_shape + [execution_parameters.nshots] - tshape = [-1] + list(range(len(prepend_to_shape))) - - results = {} - for ro_pulse in ro_pulse_list: - values = np.array(samples[ro_pulse.qubit]).reshape(shape).transpose(tshape) - - if execution_parameters.acquisition_type is AcquisitionType.DISCRIMINATION: - processed_values = SampleResults(values) - - elif execution_parameters.acquisition_type is AcquisitionType.INTEGRATION: - processed_values = IntegratedResults(values.astype(np.complex128)) - - else: - raise ValueError( - f"Current emulator does not support requested AcquisitionType {execution_parameters.acquisition_type}" - ) - - if execution_parameters.averaging_mode is AveragingMode.CYCLIC: - processed_values = ( - processed_values.average - ) # generates AveragedSampleResults - - results[ro_pulse.qubit] = results[ro_pulse.serial] = processed_values - return results - - -def get_samples( - nshots: int, - ro_reduced_dm: np.ndarray, - ro_qubit_list: list, - qid_nlevels_map: dict[Union[int, str], int], -) -> dict[Union[str, int], list]: - """Gets samples from the density matrix corresponding to the system or - subsystem specified by the ordered qubit indices. - - Args: - nshots (int): Number of shots corresponding to the number of samples in the output. - ro_reduced_dm (np.ndarray): Input density matrix. - ro_qubit_list (list): Qubit indices corresponding to the Hilbert space structure of the reduced density matrix (ro_reduced_dm). - qid_nlevels_map (dict): Dictionary mapping the qubit IDs given in qubit_list to their respective Hilbert space dimensions. - - Returns: - dict: The sampled qubit values for each qubit labelled by its index. - """ - # use the real diagonal part of the reduced density matrix as the probability distribution - ro_probability_distribution = np.diag(ro_reduced_dm).real - - # preprocess distribution - ro_probability_distribution = np.maximum( - ro_probability_distribution, 0 - ) # to remove small negative values - ro_probability_sum = np.sum(ro_probability_distribution) - ro_probability_distribution = ro_probability_distribution / ro_probability_sum - ro_qubits_dim = len(ro_probability_distribution) - - # create array of computational basis states of the reduced (measured) Hilbert space - reduced_computation_basis = make_comp_basis(ro_qubit_list, qid_nlevels_map) - - # sample computation basis index nshots times from distribution - sample_all_ro_list = np.random.choice( - ro_qubits_dim, nshots, True, ro_probability_distribution - ) - - samples = {} - for ind, ro_qubit in enumerate(ro_qubit_list): - # extracts sampled values for each readout qubit from sample_all_ro_list - outcomes = [ - reduced_computation_basis[outcome][ind] for outcome in sample_all_ro_list - ] - samples[ro_qubit] = outcomes - - return samples - - -def truncate_ro_pulses( - sequence: PulseSequence, -) -> PulseSequence: - """Creates a deepcopy of the original sequence with truncated readout - pulses to one time step. - - Args: - sequence (`qibolab.pulses.PulseSequence`): Pulse sequence. - - Returns: - `qibolab.pulses.PulseSequence`: Modified pulse sequence with one time step readout pulses. - """ - sequence = copy.deepcopy(sequence) - for i in range(len(sequence)): - if type(sequence[i]) is ReadoutPulse: - sequence[i].duration = 1 - - return sequence diff --git a/src/qibolab/instruments/era.py b/src/qibolab/instruments/era.py new file mode 100644 index 0000000000..0b8f543ba4 --- /dev/null +++ b/src/qibolab/instruments/era.py @@ -0,0 +1,10 @@ +"""ERA drivers. + +http://erainstruments.com/ +""" + +from qibolab._core.instruments import erasynth +from qibolab._core.instruments.erasynth import * # noqa: F403 + +__all__ = [] +__all__ += erasynth.__all__ diff --git a/src/qibolab/instruments/icarusq.py b/src/qibolab/instruments/icarusq.py deleted file mode 100644 index ac4e681762..0000000000 --- a/src/qibolab/instruments/icarusq.py +++ /dev/null @@ -1,39 +0,0 @@ -import urllib3 -from icarusq_rfsoc_driver.quicsyn import QuicSyn as LO_QuicSyn # pylint: disable=E0401 - -from qibolab.instruments.abstract import Instrument -from qibolab.instruments.oscillator import LocalOscillator - - -class MCAttenuator(Instrument): - """Driver for the MiniCircuit RCDAT-8000-30 variable attenuator.""" - - def connect(self): - pass - - @property - def attenuation(self): - http = urllib3.PoolManager() - res = http.request("GET", f"http://{self.address}/GETATT?") - return float(res._body) - - @attenuation.setter - def attenuation(self, attenuation: float): - http = urllib3.PoolManager() - http.request("GET", f"http://{self.address}/SETATT={attenuation}") - - def setup(self): - pass - - def disconnect(self): - pass - - -class QuicSyn(LocalOscillator): - """Driver for the National Instrument QuicSyn Lite local oscillator.""" - - def create(self): - return LO_QuicSyn(self.name, self.address) - - def __del__(self): - self.disconnect() diff --git a/src/qibolab/instruments/icarusqfpga.py b/src/qibolab/instruments/icarusqfpga.py deleted file mode 100644 index b16cb83975..0000000000 --- a/src/qibolab/instruments/icarusqfpga.py +++ /dev/null @@ -1,423 +0,0 @@ -import operator -from dataclasses import dataclass -from typing import Dict, List, Union - -import numpy as np -from icarusq_rfsoc_driver import IcarusQRFSoC # pylint: disable=E0401 -from icarusq_rfsoc_driver.rfsoc_settings import TRIGGER_MODE # pylint: disable=E0401 -from qibo.config import log - -from qibolab.execution_parameters import ( - AcquisitionType, - AveragingMode, - ExecutionParameters, -) -from qibolab.instruments.abstract import Controller -from qibolab.instruments.port import Port -from qibolab.pulses import Pulse, PulseSequence, PulseType -from qibolab.qubits import Qubit, QubitId -from qibolab.result import IntegratedResults, SampleResults -from qibolab.sweeper import Parameter, Sweeper, SweeperType - -DAC_SAMPLNG_RATE_MHZ = 5898.24 -ADC_SAMPLNG_RATE_MHZ = 1966.08 -ICARUSQ_PORT = 8080 - - -@dataclass -class RFSOCPort(Port): - name: str - dac: int = None - adc: int = None - - -class RFSOC(Controller): - """Driver for the IcarusQ RFSoC socket-based implementation.""" - - PortType = RFSOCPort - - def __init__( - self, - name, - address, - delay_samples_offset_dac: int = 0, - delay_samples_offset_adc: int = 0, - ): - super().__init__(name, address) - - self.channel_delay_offset_dac = delay_samples_offset_dac - self.channel_delay_offset_adc = delay_samples_offset_adc - - def connect(self): - self.device = IcarusQRFSoC(self.address, ICARUSQ_PORT) - - for dac in range(self.device.dac_nchannels): - self.device.dac[dac].delay = self.channel_delay_offset_dac - for adc in range(self.device.adc_nchannels): - self.device.adc[adc].delay = self.channel_delay_offset_adc - - self.device.set_adc_trigger_mode(TRIGGER_MODE.SLAVE) - ver = self.device.get_server_version() - log.info(f"Connected to {self.name}, version: {ver}") - - def setup(self): - pass - - @property - def sampling_rate(self): - return self.device.dac_sampling_rate / 1e3 # MHz to GHz - - def play( - self, - qubits: Dict[QubitId, Qubit], - couplers, - sequence: PulseSequence, - options: ExecutionParameters, - ): - """Plays the given pulse sequence without acquisition. - - Arguments: - qubits (dict): Dictionary of qubit IDs mapped to qubit objects. - sequence (PulseSequence): Pulse sequence to be played on this instrument. - options (ExecutionParameters): Execution parameters for readout and repetition. - """ - - waveform_array = {dac.id: np.zeros(dac.max_samples) for dac in self.device.dac} - - dac_end_addr = {dac.id: 0 for dac in self.device.dac} - dac_sampling_rate = self.device.dac_sampling_rate * 1e6 - dac_sr_ghz = dac_sampling_rate / 1e9 - - # We iterate over the seuence of pulses and generate the waveforms for each type of pulses - for pulse in sequence.pulses: - if pulse.channel not in self._ports: - continue - - dac = self.ports(pulse.channel).dac - start = int(pulse.start * 1e-9 * dac_sampling_rate) - i_env = pulse.envelope_waveform_i(dac_sr_ghz).data - q_env = pulse.envelope_waveform_q(dac_sr_ghz).data - - # Flux pulses - # TODO: Add envelope support for flux pulses - if pulse.type == PulseType.FLUX: - wfm = i_env - end = start + len(wfm) - - # Qubit drive microwave signals - elif pulse.type == PulseType.DRIVE: - end = start + len(i_env) - t = np.arange(start, end) / dac_sampling_rate - cosalpha = np.cos( - 2 * np.pi * pulse.frequency * t + pulse.relative_phase - ) - sinalpha = np.sin( - 2 * np.pi * pulse.frequency * t + pulse.relative_phase - ) - wfm = i_env * sinalpha + q_env * cosalpha - - elif pulse.type == PulseType.READOUT: - # For readout pulses, we move the corresponding DAC/ADC pair to the start of the pulse to save memory - # This locks the phase of the readout in the demodulation - adc = self.ports(pulse.channel).adc - start = 0 - - end = start + len(i_env) - t = np.arange(start, end) / dac_sampling_rate - cosalpha = np.cos( - 2 * np.pi * pulse.frequency * t + pulse.relative_phase - ) - sinalpha = np.sin( - 2 * np.pi * pulse.frequency * t + pulse.relative_phase - ) - wfm = i_env * sinalpha + q_env * cosalpha - - # First we convert the pulse starting time to number of ADC samples - # Then, we convert this number to the number of ADC clock cycles (8 samples per clock cycle) - # Next, we raise it to the next nearest integer to prevent an overlap between drive and readout pulses - # Finally, we ensure that the number is even for the DAC delay conversion - delay_start_adc = int( - int( - np.ceil( - self.device.adc_sampling_rate * 1e6 * pulse.start * 1e-9 / 8 - ) - / 2 - ) - * 2 - ) - - # For the DAC, currently the sampling rate is 3x higher than the ADC - # The number of clock cycles is 16 samples per clock cycle - # Hence, we multiply the adc delay clock cycles by 1.5x to align the DAC/ADC pair - delay_start_dac = int(delay_start_adc * 1.5) - - self.device.dac[dac].delay = ( - delay_start_dac + self.channel_delay_offset_dac - ) - self.device.adc[adc].delay = ( - delay_start_adc + self.channel_delay_offset_adc - ) - # ADC0 complete marks the end of acquisition, so we also need to move ADC0 - self.device.adc[0].delay = ( - delay_start_adc + self.channel_delay_offset_adc - ) - - if ( - options.acquisition_type is AcquisitionType.DISCRIMINATION - or AcquisitionType.INTEGRATION - ): - self.device.program_qunit( - readout_frequency=pulse.frequency, - readout_time=pulse.duration * 1e-9, - qunit=pulse.qubit, - ) - - end = start + len(wfm) - waveform_array[dac][start:end] += self.device.dac_max_amplitude * wfm - dac_end_addr[dac] = max(end >> 4, dac_end_addr[dac]) - - payload = [ - (dac, wfm, dac_end_addr[dac]) - for dac, wfm in waveform_array.items() - if dac_end_addr[dac] != 0 - ] - self.device.upload_waveform(payload) - - def disconnect(self): - if self.is_connected: - self.device.sock.close() - - def sweep(self): - pass - - -class RFSOC_RO(RFSOC): - """IcarusQ RFSoC attached with readout capability.""" - - available_sweep_parameters = { - Parameter.amplitude, - Parameter.duration, - Parameter.frequency, - Parameter.relative_phase, - Parameter.start, - } - - def __init__( - self, - name, - address, - delay_samples_offset_dac: int = 0, - delay_samples_offset_adc: int = 0, - adcs_to_read: List[int] = [], - ): - super().__init__( - name, address, delay_samples_offset_dac, delay_samples_offset_adc - ) - self.adcs_to_read = adcs_to_read - - def connect(self): - super().connect() - self.device.init_qunit() - self.device.set_adc_trigger_mode(TRIGGER_MODE.MASTER) - - def play( - self, - qubits: Dict[QubitId, Qubit], - couplers, - sequence: PulseSequence, - options: ExecutionParameters, - ): - """Plays the pulse sequence on the IcarusQ RFSoC and awaits acquisition - at the end. - - Arguments: - qubits (dict): Dictionary of qubit IDs mapped to qubit objects. - sequence (PulseSequence): Pulse sequence to be played on this instrument. - options (ExecutionParameters): Object representing acquisition type and number of shots. - """ - super().play(qubits, couplers, sequence, options) - self.device.set_adc_trigger_repetition_rate(int(options.relaxation_time / 1e3)) - readout_pulses = [ - pulse for pulse in sequence.pulses if pulse.type is PulseType.READOUT - ] - readout_qubits = [pulse.qubit for pulse in readout_pulses] - - if options.acquisition_type is AcquisitionType.RAW: - self.device.set_adc_trigger_mode(0) - self.device.arm_adc(self.adcs_to_read, options.nshots) - raw = self.device.result() - return self.process_readout_signal(raw, readout_pulses, qubits, options) - - # Currently qunit only supports single qubit readout demodulation - elif options.acquisition_type is AcquisitionType.INTEGRATION: - self.device.set_adc_trigger_mode(1) - self.device.set_qunit_mode(0) - raw = self.device.start_qunit_acquisition(options.nshots, readout_qubits) - - qunit_mapping = { - ro_pulse.qubit: ro_pulse.serial for ro_pulse in readout_pulses - } - - if options.averaging_mode is not AveragingMode.SINGLESHOT: - res = { - qunit_mapping[qunit]: IntegratedResults(i + 1j * q).average - for qunit, (i, q) in raw.items() - } - else: - res = { - qunit_mapping[qunit]: IntegratedResults(i + 1j * q) - for qunit, (i, q) in raw.items() - } - # Temp fix for readout pulse sweepers, to be removed with IcarusQ v2 - for ro_pulse in readout_pulses: - res[ro_pulse.qubit] = res[ro_pulse.serial] - return res - - elif options.acquisition_type is AcquisitionType.DISCRIMINATION: - self.device.set_adc_trigger_mode(1) - self.device.set_qunit_mode(1) - raw = self.device.start_qunit_acquisition(options.nshots, readout_qubits) - res = {qubit: SampleResults(states) for qubit, states in raw.items()} - # Temp fix for readout pulse sweepers, to be removed with IcarusQ v2 - for ro_pulse in readout_pulses: - res[ro_pulse.qubit] = res[ro_pulse.serial] - return res - - def process_readout_signal( - self, - adc_raw_data: Dict[int, np.ndarray], - sequence: List[Pulse], - qubits: Dict[QubitId, Qubit], - options: ExecutionParameters, - ): - """Processes the raw signal from the ADC into IQ values.""" - - adc_sampling_rate = self.device.adc_sampling_rate * 1e6 - t = np.arange(self.device.adc_sample_size) / adc_sampling_rate - results = {} - - for readout_pulse in sequence: - qubit = qubits[readout_pulse.qubit] - _, adc = qubit.readout.ports - - raw_signal = adc_raw_data[adc] - sin = np.sin(2 * np.pi * readout_pulse.frequency * t) - cos = np.sin(2 * np.pi * readout_pulse.frequency * t) - - i = np.dot(raw_signal, cos) - q = np.dot(raw_signal, sin) - singleshot = IntegratedResults(i + 1j * q) - results[readout_pulse.serial] = ( - singleshot.average - if options.averaging_mode is not AveragingMode.SINGLESHOT - else singleshot - ) - # Temp fix for readout pulse sweepers, to be removed with IcarusQ v2 - results[readout_pulse.qubit] = results[readout_pulse.serial] - - return results - - def sweep( - self, - qubits: Dict[QubitId, Qubit], - couplers, - sequence: PulseSequence, - options: ExecutionParameters, - *sweeper: Sweeper, - ): - # Record pulse values before sweeper modification - bsv = [] - for sweep in sweeper: - if sweep.parameter not in self.available_sweep_parameters: - raise NotImplementedError( - "Sweep parameter requested not available", param_name - ) - - param_name = sweep.parameter.name.lower() - base_sweeper_values = [getattr(pulse, param_name) for pulse in sweep.pulses] - bsv.append(base_sweeper_values) - - res = self._sweep_recursion(qubits, couplers, sequence, options, *sweeper) - - # Reset pulse values back to original values - for sweep, base_sweeper_values in zip(sweeper, bsv): - param_name = sweep.parameter.name.lower() - for pulse, value in zip(sweep.pulses, base_sweeper_values): - setattr(pulse, param_name, value) - - # Since the sweeper will modify the readout pulse serial, we collate the results with the qubit number. - # This is only for qibocal compatiability and will be removed with IcarusQ v2. - if pulse.type is PulseType.READOUT: - res[pulse.serial] = res[pulse.qubit] - - return res - - def _sweep_recursion( - self, - qubits: Dict[QubitId, Qubit], - couplers, - sequence: PulseSequence, - options: ExecutionParameters, - *sweeper: Sweeper, - ): - """Recursive python-based sweeper functionaltiy for the IcarusQ - RFSoC.""" - if len(sweeper) == 0: - return self.play(qubits, couplers, sequence, options) - - sweep = sweeper[0] - param = sweep.parameter - param_name = param.name.lower() - - if param not in self.available_sweep_parameters: - raise NotImplementedError( - "Sweep parameter requested not available", param_name - ) - - base_sweeper_values = [getattr(pulse, param_name) for pulse in sweep.pulses] - sweeper_op = _sweeper_operation.get(sweep.type) - ret = {} - - for value in sweep.values: - for idx, pulse in enumerate(sweep.pulses): - base = base_sweeper_values[idx] - setattr(pulse, param_name, sweeper_op(value, base)) - - self.merge_sweep_results( - ret, - self._sweep_recursion( - qubits, couplers, sequence, options, *sweeper[1:] - ), - ) - - return ret - - @staticmethod - def merge_sweep_results( - dict_a: """dict[str, Union[IntegratedResults, SampleResults]]""", - dict_b: """dict[str, Union[IntegratedResults, SampleResults]]""", - ) -> """dict[str, Union[IntegratedResults, SampleResults]]""": - """Merge two dictionary mapping pulse serial to Results object. - - If dict_b has a key (serial) that dict_a does not have, simply add it, - otherwise sum the two results - - Args: - dict_a (dict): dict mapping ro pulses serial to qibolab res objects - dict_b (dict): dict mapping ro pulses serial to qibolab res objects - Returns: - A dict mapping the readout pulses serial to qibolab results objects - """ - for serial in dict_b: - if serial in dict_a: - dict_a[serial] = dict_a[serial] + dict_b[serial] - else: - dict_a[serial] = dict_b[serial] - return dict_a - - -_sweeper_operation = { - SweeperType.ABSOLUTE: lambda value, base: value, - SweeperType.OFFSET: operator.add, - SweeperType.FACTOR: operator.mul, -} diff --git a/src/qibolab/instruments/port.py b/src/qibolab/instruments/port.py deleted file mode 100644 index d4759fa661..0000000000 --- a/src/qibolab/instruments/port.py +++ /dev/null @@ -1,35 +0,0 @@ -class Port: - """Abstract interface for instrument parameters. - - These parameters are exposed to the user through :class:`qibolab.channels.Channel`. - - Drivers should subclass this interface and implement the getters - and setters for all the parameters that are available for the - corresponding instruments. - - Each port is identified by the ``name`` attribute. - Note that the type of the identifier can be different of each port implementation. - """ - - name: str - """Name of the port that acts as its identifier.""" - offset: float - """DC offset that is applied to this port.""" - lo_frequency: float - """Local oscillator frequency for the given port. - - Relevant only for controllers with internal local oscillators. - """ - lo_power: float - """Local oscillator power for the given port. - - Relevant only for controllers with internal local oscillators. - """ - # TODO: Maybe gain, attenuation and power range can be unified to a single attribute - gain: float - """Gain that is applied to this port.""" - attenuation: float - """Attenuation that is applied to this port.""" - power_range: int - """Similar to attenuation (negative) and gain (positive) for (Zurich - instruments).""" diff --git a/src/qibolab/instruments/qblox/acquisition.py b/src/qibolab/instruments/qblox/acquisition.py deleted file mode 100644 index 69da4e5e6b..0000000000 --- a/src/qibolab/instruments/qblox/acquisition.py +++ /dev/null @@ -1,137 +0,0 @@ -from dataclasses import dataclass -from typing import List, Optional - -import numpy as np - -SAMPLING_RATE = 1 - - -def demodulate(input_i, input_q, frequency): - """Demodulates and integrates the acquired pulse.""" - # DOWN Conversion - # qblox does not remove the offsets in hardware - modulated_i = input_i - np.mean(input_i) - modulated_q = input_q - np.mean(input_q) - - num_samples = modulated_i.shape[0] - time = np.arange(num_samples) - phase = 2 * np.pi * frequency * time / SAMPLING_RATE - cosalpha = np.cos(phase) - sinalpha = np.sin(phase) - demod_matrix = np.sqrt(2) * np.array([[cosalpha, sinalpha], [-sinalpha, cosalpha]]) - result = np.einsum("ijt,jt->i", demod_matrix, np.stack([modulated_i, modulated_q])) - return np.sqrt(2) * result / num_samples - - -@dataclass -class AveragedAcquisition: - """Software Demodulation. - - Every readout pulse triggers an acquisition, where the 16384 i and q - samples of the waveform acquired by the ADC are saved into a - dedicated memory within the FPGA. This is what qblox calls *scoped - acquisition*. The results of multiple shots are averaged in this - memory, and cannot be retrieved independently. The resulting - waveforms averages (i and q) are then demodulated and integrated in - software (and finally divided by the number of samples). Since - Software Demodulation relies on the data of the scoped acquisition - and that data is the average of all acquisitions, **only one readout - pulse per qubit is supported**, so that the averages all correspond - to reading the same quantum state. - """ - - results: dict - """Data returned by qblox acquisition.""" - duration: int - """Duration of the readout pulse.""" - frequency: int - """Frequency of the readout pulse used for demodulation.""" - - i: Optional[List[float]] = None - q: Optional[List[float]] = None - - @property - def scope(self): - return self.results["acquisition"]["scope"] - - @property - def raw_i(self): - """Average of the i waveforms for every readout pulse.""" - return np.array(self.scope["path0"]["data"][0 : self.duration]) - - @property - def raw_q(self): - """Average of the q waveforms for every readout pulse.""" - return np.array(self.scope["path1"]["data"][0 : self.duration]) - - @property - def data(self): - """Acquisition data to be returned to the platform. - - Ignores the data available in acquisition results and returns - only i and q voltages. - """ - # TODO: to be updated once the functionality of ExecutionResults is extended - if self.i is None or self.q is None: - self.i, self.q = demodulate(self.raw_i, self.raw_q, self.frequency) - return (self.i, self.q) - - -@dataclass -class DemodulatedAcquisition: - """Hardware Demodulation. - - With hardware demodulation activated, the FPGA can demodulate, - integrate (average over time), and classify each shot individually, - saving the results on separate bins. The raw data of each - acquisition continues to be averaged as with software modulation, so - there is no way to access the raw data of each shot (unless executed - one shot at a time). The FPGA uses fixed point arithmetic for the - demodulation and integration; if the power level of the signal at - the input port is low (the minimum resolution of the ADC is 240uV) - rounding precission errors can accumulate and render wrong results. - It is advisable to have a power level at least higher than 5mV. - """ - - scope: dict - """Data returned by scope qblox acquisition.""" - bins: dict - """Binned acquisition data returned by qblox.""" - duration: int - """Duration of the readout pulse.""" - - @property - def raw(self): - return self.scope["acquisition"]["scope"] - - @property - def integration(self): - return self.bins["integration"] - - @property - def shots_i(self): - """I-component after demodulating and integrating every shot - waveform.""" - return np.array(self.integration["path0"]) / self.duration - - @property - def shots_q(self): - """Q-component after demodulating and integrating every shot - waveform.""" - return np.array(self.integration["path1"]) / self.duration - - @property - def raw_i(self): - """Average of the raw i waveforms for every readout pulse.""" - return np.array(self.raw["path0"]["data"][0 : self.duration]) - - @property - def raw_q(self): - """Average of the raw q waveforms for every readout pulse.""" - return np.array(self.raw["path1"]["data"][0 : self.duration]) - - @property - def classified(self): - """List with the results of demodulating, integrating and classifying - every shot.""" - return np.array(self.bins["threshold"]) diff --git a/src/qibolab/instruments/qblox/cluster_qcm_bb.py b/src/qibolab/instruments/qblox/cluster_qcm_bb.py deleted file mode 100644 index e95cf69ef9..0000000000 --- a/src/qibolab/instruments/qblox/cluster_qcm_bb.py +++ /dev/null @@ -1,761 +0,0 @@ -"""Qblox Cluster QCM driver.""" - -import json - -from qblox_instruments.native.generic_func import SequencerStates -from qblox_instruments.qcodes_drivers.cluster import Cluster -from qblox_instruments.qcodes_drivers.module import Module -from qibo.config import log - -from qibolab.instruments.qblox.module import ClusterModule -from qibolab.instruments.qblox.q1asm import ( - Block, - Register, - convert_phase, - loop_block, - wait_block, -) -from qibolab.instruments.qblox.sequencer import Sequencer, WaveformsBuffer -from qibolab.instruments.qblox.sweeper import QbloxSweeper, QbloxSweeperType -from qibolab.pulses import Pulse, PulseSequence, PulseType -from qibolab.sweeper import Parameter, Sweeper, SweeperType - - -class QcmBb(ClusterModule): - """Qblox Cluster Qubit Control Module Baseband driver. - - Qubit Control Module (QCM) is an arbitratry wave generator with two DACs connected to - four output ports. It can sinthesise either four independent real signals or two - complex signals, using ports 0 and 2 to output the i(in-phase) component and - ports 1 and 3 the q(quadrature) component. The sampling rate of its DAC is 1 GSPS. - https://www.qblox.com/cluster - - The class aims to simplify the configuration of the instrument, exposing only - those parameters most frequencly used and hiding other more complex components. - - A reference to the underlying `qblox_instruments.qcodes_drivers.qcm_qrm.QRM_QCM` - object is provided via the attribute `device`, allowing the advanced user to gain - access to the features that are not exposed directly by the class. - - In order to accelerate the execution, the instrument settings are cached, so that - the communication with the instrument only happens when the parameters change. - This caching is done with the method `_set_device_parameter(target, *parameters, value)`. - - .. code-block:: text - - ports: - o1: - channel : L4-1 - gain : 0.2 # -1.0<=v<=1.0 - offset : 0 # -2.5<=v<=2.5 - o2: - channel : L4-2 - gain : 0.2 # -1.0<=v<=1.0 - offset : 0 # -2.5<=v<=2.5 - o3: - channel : L4-3 - gain : 0.2 # -1.0<=v<=1.0 - offset : 0 # -2.5<=v<=2.5 - o4: - channel : L4-4 - gain : 0.2 # -1.0<=v<=1.0 - offset : 0 # -2.5<=v<=2.5 - - Attributes: - name (str): A unique name given to the instrument. - address (str): IP_address:module_number (the IP address of the cluster and - the module number) - device (QbloxQrmQcm): A reference to the underlying - `qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm` object. It can be used to access other - features not directly exposed by this wrapper. - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/api_reference/qcm_qrm.html - ports = A dictionary giving access to the output ports objects. - - - ports['o1'] - - ports['o2'] - - ports['o3'] - - ports['o4'] - - - ports['oX'].channel (int | str): the id of the refrigerator channel the port is connected to. - - ports['oX'].gain (float): (mapped to qrm.sequencers[0].gain_awg_path0 and qrm.sequencers[0].gain_awg_path1) - Sets the gain on both paths of the output port. - - ports['oX'].offset (float): (mapped to qrm.outX_offset) - Sets the offset on the output port. - - ports['oX'].hardware_mod_en (bool): (mapped to qrm.sequencers[0].mod_en_awg) Enables pulse - modulation in hardware. When set to False, pulse modulation is done at the host computer - and a modulated pulse waveform should be uploaded to the instrument. When set to True, - the envelope of the pulse should be uploaded to the instrument and it modulates it in - real time by its FPGA using the sequencer nco (numerically controlled oscillator). - - ports['oX'].nco_freq (int): (mapped to qrm.sequencers[0].nco_freq) # TODO mapped, but not configurable from the runcard - - ports['oX'].nco_phase_offs = (mapped to qrm.sequencers[0].nco_phase_offs) # TODO mapped, but not configurable from the runcard - - - Sequencer 0 is always the first sequencer used to synthesise pulses on port o1. - - Sequencer 1 is always the first sequencer used to synthesise pulses on port o2. - - Sequencer 2 is always the first sequencer used to synthesise pulses on port o3. - - Sequencer 3 is always the first sequencer used to synthesise pulses on port o4. - - Sequencer 4 to 6 are used as needed to sinthesise simultaneous pulses on the same channel - or when the memory of the default sequencers rans out. - """ - - DEFAULT_SEQUENCERS = {"o1": 0, "o2": 1, "o3": 2, "o4": 3} - FREQUENCY_LIMIT = 500e6 - OUT_PORT_PATH = {0: "I", 1: "Q", 2: "I", 3: "Q"} - - def __init__(self, name: str, address: str): - """Initialize a Qblox QCM baseband module. - - Parameters: - - name: An arbitrary name to identify the module. - - address: The network address of the instrument, specified as "cluster_IP:module_slot_idx". - - cluster: The Cluster object to which the QCM baseband module is connected. - - Example: - To create a QcmBb instance named 'qcm_bb' connected to slot 2 of a Cluster at address '192.168.0.100': - >>> cluster_instance = Cluster("cluster","192.168.1.100", settings) - >>> qcm_module = QcmBb(name="qcm_bb", address="192.168.1.100:2", cluster=cluster_instance) - """ - super().__init__(name, address) - self._ports: dict = {} - self.device: Module = None - - self._debug_folder: str = "" - self._sequencers: dict[Sequencer] = {} - self.channel_map: dict = {} - self._device_num_output_ports = 2 - self._device_num_sequencers: int - self._free_sequencers_numbers: list[int] = ( - [] - ) # TODO: we can create only list and put three flags: free, used, unused - self._used_sequencers_numbers: list[int] = [] - self._unused_sequencers_numbers: list[int] = [] - - def _set_default_values(self): - # disable all sequencer connections - self.device.disconnect_outputs() - - # set offset to zero on all ports. Default values after reboot = 0 - [self.device.set(f"out{idx}_offset", value=0) for idx in range(4)] - - # initialise the parameters of the default sequencers to the default values, - # the rest of the sequencers are disconnected, but will be configured - # with the same parameters as the default in process_pulse_sequence() - default_sequencers = [ - self.device.sequencers[i] for i in self.DEFAULT_SEQUENCERS.values() - ] - for target in default_sequencers: - for name, value in self.DEFAULT_SEQUENCERS_VALUES.items(): - target.set(name, value) - - # connect the default sequencers to the out ports - for port_num, value in self.OUT_PORT_PATH.items(): - self.device.sequencers[port_num].set(f"connect_out{port_num}", value) - - def connect(self, cluster: Cluster = None): - """Connects to the instrument using the instrument settings in the - runcard. - - Once connected, it creates port classes with properties mapped - to various instrument parameters, and initialises the the - underlying device parameters. It uploads to the module the port - settings loaded from the runcard. - """ - if self.is_connected: - return - - elif cluster is not None: - self.device = cluster.modules[int(self.address.split(":")[1]) - 1] - # test connection with module - if not self.device.present(): - raise ConnectionError( - f"Module {self.device.name} not connected to cluster {cluster.name}" - ) - # once connected, initialise the parameters of the device to the default values - self._device_num_sequencers = len(self.device.sequencers) - self._set_default_values() - # then set the value loaded from the runcard - try: - for port in self._ports: - self._sequencers[port] = [] - self._ports[port].hardware_mod_en = True - self._ports[port].nco_freq = 0 - self._ports[port].nco_phase_offs = 0 - self._ports[port].offset = self._ports[port].offset - except Exception as error: - raise RuntimeError( - f"Unable to initialize port parameters on module {self.name}: {error}" - ) - - self.is_connected = True - - def setup(self, **settings): - """Cache the settings of the runcard and instantiate the ports of the - module. - - Args: - **settings: dict = A dictionary of settings loaded from the runcard: - - - settings[oX]['offset'] (float): [-2.5 - 2.5 V] offset in volts applied to the output port. - - settings[oX]['hardware_mod_en'] (bool): enables Hardware Modulation. In this mode, pulses are modulated to the intermediate frequency - using the numerically controlled oscillator within the fpga. It only requires the upload of the pulse envelope waveform. - At the moment this param is not loaded but is always set to True. - """ - pass - - def _get_next_sequencer(self, port, frequency, qubits: dict): - """Retrieves and configures the next avaliable sequencer. - - The parameters of the new sequencer are copied from those of the default sequencer, except for the - intermediate frequency and classification parameters. - Args: - port (str): - frequency (): - qubit (): - Raises: - Exception = If attempting to set a parameter without a connection to the instrument. - """ - # select the qubit with flux line, if present, connected to the specific port - qubit = None - for _qubit in qubits.values(): - name = _qubit.flux.port.name - module = _qubit.flux.port.module - if _qubit.flux is not None and (name, module) == (port, self): - qubit = _qubit - - # select a new sequencer and configure it as required - next_sequencer_number = self._free_sequencers_numbers.pop(0) - if next_sequencer_number != self.DEFAULT_SEQUENCERS[port]: - for parameter in self.device.sequencers[ - self.DEFAULT_SEQUENCERS[port] - ].parameters: - # exclude read-only parameter `sequence` - if parameter not in ["sequence"]: - value = self.device.sequencers[self.DEFAULT_SEQUENCERS[port]].get( - param_name=parameter - ) - if value: - target = self.device.sequencers[next_sequencer_number] - target.set(parameter, value) - - # if hardware modulation is enabled configure nco_frequency - if self._ports[port].hardware_mod_en: - self.device.sequencers[next_sequencer_number].set("nco_freq", frequency) - # Assumes all pulses in non_overlapping_pulses set - # have the same frequency. Non-overlapping pulses of different frequencies on the same - # qubit channel with hardware_demod_en would lead to wrong results. - # TODO: Throw error in that event or implement for non_overlapping_same_frequency_pulses - # Even better, set the frequency before each pulse is played (would work with hardware modulation only) - - # create sequencer wrapper - sequencer = Sequencer(next_sequencer_number) - sequencer.qubit = qubit.name if qubit else None - return sequencer - - def get_if(self, pulse): - """Returns the intermediate frequency needed to synthesise a pulse - based on the port lo frequency.""" - - _rf = pulse.frequency - _lo = 0 # QCMs do not have local oscillator - _if = _rf - _lo - if abs(_if) > self.FREQUENCY_LIMIT: - raise RuntimeError( - f""" - Pulse frequency {_rf:_} cannot be synthesised, it exceeds the maximum frequency of {self.FREQUENCY_LIMIT:_}""" - ) - return _if - - def process_pulse_sequence( - self, - qubits: dict, - instrument_pulses: PulseSequence, - navgs: int, - nshots: int, - repetition_duration: int, - sweepers=None, - ): - """Processes a list of pulses, generating the waveforms and sequence - program required by the instrument to synthesise them. - - The output of the process is a list of sequencers used for each port, configured with the information - required to play the sequence. - The following features are supported: - - - overlapping pulses - - hardware modulation - - software modulation, with support for arbitrary pulses - - real-time sweepers of - - - pulse frequency (requires hardware modulation) - - pulse relative phase (requires hardware modulation) - - pulse amplitude - - pulse start - - pulse duration - - port gain - - port offset - - - sequencer memory optimisation (waveforms cache) - - extended waveform memory with the use of multiple sequencers - - pulses of up to 8192 pairs of i, q samples - - intrument parameters cache - - Args: - instrument_pulses (PulseSequence): A collection of Pulse objects to be played by the instrument. - navgs (int): The number of times the sequence of pulses should be executed averaging the results. - nshots (int): The number of times the sequence of pulses should be executed without averaging. - repetition_duration (int): The total duration of the pulse sequence execution plus the reset/relaxation time. - sweepers (list(Sweeper)): A list of Sweeper objects to be implemented. - """ - if sweepers is None: - sweepers = [] - sequencer: Sequencer - sweeper: Sweeper - - self._free_sequencers_numbers = list(range(len(self._ports), 6)) - - # process the pulses for every port - for port in self._ports: - # split the collection of instruments pulses by ports - port_channel = [ - chan.name - for chan in self.channel_map.values() - if chan.port.name == port - ] - port_pulses: PulseSequence = instrument_pulses.get_channel_pulses( - *port_channel - ) - - # initialise the list of sequencers required by the port - self._sequencers[port] = [] - - # initialise the list of free sequencer numbers to include the default for each port {'o1': 0, 'o2': 1, 'o3': 2, 'o4': 3} - self._free_sequencers_numbers = [ - self.DEFAULT_SEQUENCERS[port] - ] + self._free_sequencers_numbers - - if not port_pulses.is_empty: - # split the collection of port pulses in non overlapping pulses - non_overlapping_pulses: PulseSequence - for non_overlapping_pulses in port_pulses.separate_overlapping_pulses(): - # TODO: for non_overlapping_same_frequency_pulses in non_overlapping_pulses.separate_different_frequency_pulses(): - - # each set of not overlapping pulses will be played by a separate sequencer - # check sequencer availability - if len(self._free_sequencers_numbers) == 0: - raise Exception( - f"The number of sequencers requried to play the sequence exceeds the number available {self._device_num_sequencers}." - ) - # get next sequencer - sequencer = self._get_next_sequencer( - port=port, - frequency=self.get_if(non_overlapping_pulses[0]), - qubits=qubits, - ) - # add the sequencer to the list of sequencers required by the port - self._sequencers[port].append(sequencer) - - # make a temporary copy of the pulses to be processed - pulses_to_be_processed = non_overlapping_pulses.shallow_copy() - while not pulses_to_be_processed.is_empty: - pulse: Pulse = pulses_to_be_processed[0] - # attempt to save the waveforms to the sequencer waveforms buffer - try: - sequencer.waveforms_buffer.add_waveforms( - pulse, self._ports[port].hardware_mod_en, sweepers - ) - sequencer.pulses.add(pulse) - pulses_to_be_processed.remove(pulse) - - # if there is not enough memory in the current sequencer, use another one - except WaveformsBuffer.NotEnoughMemory: - if ( - len(pulse.waveform_i) + len(pulse.waveform_q) - > WaveformsBuffer.SIZE - ): - raise NotImplementedError( - f"Pulses with waveforms longer than the memory of a sequencer ({WaveformsBuffer.SIZE // 2}) are not supported." - ) - if len(self._free_sequencers_numbers) == 0: - raise Exception( - f"The number of sequencers requried to play the sequence exceeds the number available {self._device_num_sequencers}." - ) - # get next sequencer - sequencer = self._get_next_sequencer( - port=port, - frequency=self.get_if(non_overlapping_pulses[0]), - qubits=qubits, - ) - # add the sequencer to the list of sequencers required by the port - self._sequencers[port].append(sequencer) - else: - sequencer = self._get_next_sequencer( - port=port, frequency=0, qubits=qubits - ) - # add the sequencer to the list of sequencers required by the port - self._sequencers[port].append(sequencer) - - # update the lists of used and unused sequencers that will be needed later on - self._used_sequencers_numbers = [] - for port in self._ports: - for sequencer in self._sequencers[port]: - self._used_sequencers_numbers.append(sequencer.number) - self._unused_sequencers_numbers = [] - for n in range(self._device_num_sequencers): - if not n in self._used_sequencers_numbers: - self._unused_sequencers_numbers.append(n) - - # generate and store the Waveforms dictionary, the Acquisitions dictionary, the Weights and the Program - for port in self._ports: - for sequencer in self._sequencers[port]: - pulses = sequencer.pulses - program = sequencer.program - - ## pre-process sweepers ## - # TODO: move qibolab sweepers preprocessing to qblox controller - - # attach a sweeper attribute to the pulse so that it is easily accesible by the code that generates - # the pseudo-assembly program - pulse = None - for pulse in pulses: - pulse.sweeper = None - - pulse_sweeper_parameters = [ - Parameter.frequency, - Parameter.amplitude, - Parameter.duration, - Parameter.relative_phase, - Parameter.start, - ] - - for sweeper in sweepers: - if sweeper.parameter in pulse_sweeper_parameters: - # check if this sequencer takes an active role in the sweep - if sweeper.pulses and set(sequencer.pulses) & set( - sweeper.pulses - ): - # plays an active role - reference_value = None - if ( - sweeper.parameter == Parameter.frequency - and sequencer.pulses - ): - reference_value = self.get_if(sequencer.pulses[0]) - if sweeper.parameter == Parameter.amplitude: - for pulse in pulses: - if pulse in sweeper.pulses: - reference_value = ( - pulse.amplitude - ) # uses the amplitude of the first pulse - if ( - sweeper.parameter == Parameter.duration - and pulse in sweeper.pulses - ): - # for duration sweepers bake waveforms - sweeper.qs = QbloxSweeper( - program=program, - type=QbloxSweeperType.duration, - rel_values=pulse.idx_range, - ) - else: - # create QbloxSweepers and attach them to qibolab sweeper - if ( - sweeper.type == SweeperType.OFFSET - and reference_value - ): - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, - sweeper=sweeper, - add_to=reference_value, - ) - elif ( - sweeper.type == SweeperType.FACTOR - and reference_value - ): - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, - sweeper=sweeper, - multiply_to=reference_value, - ) - else: - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, sweeper=sweeper - ) - - # finally attach QbloxSweepers to the pulses being swept - sweeper.qs.update_parameters = True - pulse.sweeper = sweeper.qs - else: - # does not play an active role - sweeper.qs = QbloxSweeper( - program=program, - type=QbloxSweeperType.number, - rel_values=range(len(sweeper.values)), - name=sweeper.parameter.name, - ) - - else: # qubit_sweeper_parameters - if sequencer.qubit in [qubit.name for qubit in sweeper.qubits]: - # plays an active role - if sweeper.parameter == Parameter.bias: - reference_value = self._ports[port].offset - # create QbloxSweepers and attach them to qibolab sweeper - if sweeper.type == SweeperType.ABSOLUTE: - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, - sweeper=sweeper, - add_to=-reference_value, - ) - elif sweeper.type == SweeperType.OFFSET: - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, sweeper=sweeper - ) - elif sweeper.type == SweeperType.FACTOR: - raise Exception( - "SweeperType.FACTOR for Parameter.bias not supported" - ) - sweeper.qs.update_parameters = True - else: - # does not play an active role - sweeper.qs = QbloxSweeper( - program=program, - type=QbloxSweeperType.number, - rel_values=range(len(sweeper.values)), - name=sweeper.parameter.name, - ) - - # FIXME: for qubit sweepers (Parameter.bias, Parameter.attenuation, Parameter.gain), the qubit - # information alone is not enough to determine what instrument parameter is to be swept. - # For example port gain, both the drive and readout ports have gain parameters. - # Until this is resolved, and since bias is only implemented with QCMs offset, this instrument will - # never take an active role in those sweeps. - - # Waveforms - for index, waveform in enumerate( - sequencer.waveforms_buffer.unique_waveforms - ): - sequencer.waveforms[waveform.serial] = { - "data": waveform.data.tolist(), - "index": index, - } - - # Program - minimum_delay_between_instructions = 4 - - sequence_total_duration = ( - pulses.finish - ) # the minimum delay between instructions is 4ns - time_between_repetitions = repetition_duration - sequence_total_duration - assert time_between_repetitions > minimum_delay_between_instructions - # TODO: currently relaxation_time needs to be greater than acquisition_hold_off - # so that the time_between_repetitions is equal to the sequence_total_duration + relaxation_time - # to be compatible with th erest of the platforms, change it so that time_between_repetitions - # is equal to pulsesequence duration + acquisition_hold_off if relaxation_time < acquisition_hold_off - - # create registers for key variables - # nshots is used in the loop that iterates over the number of shots - nshots_register = Register(program, "nshots") - # navgs is used in the loop of hardware averages - navgs_register = Register(program, "navgs") - - header_block = Block("setup") - - body_block = Block() - - body_block.append(f"wait_sync {minimum_delay_between_instructions}") - if self._ports[port].hardware_mod_en: - body_block.append("reset_ph") - body_block.append_spacer() - - pulses_block = Block("play") - # Add an initial wait instruction for the first pulse of the sequence - initial_wait_block = wait_block( - wait_time=pulses.start, - register=Register(program), - force_multiples_of_four=False, - ) - pulses_block += initial_wait_block - - for n in range(pulses.count): - if ( - pulses[n].sweeper - and pulses[n].sweeper.type == QbloxSweeperType.start - ): - pulses_block.append(f"wait {pulses[n].sweeper.register}") - - if self._ports[port].hardware_mod_en: - # # Set frequency - # _if = self.get_if(pulses[n]) - # pulses_block.append(f"set_freq {convert_frequency(_if)}", f"set intermediate frequency to {_if} Hz") - - # Set phase - if ( - pulses[n].sweeper - and pulses[n].sweeper.type - == QbloxSweeperType.relative_phase - ): - pulses_block.append(f"set_ph {pulses[n].sweeper.register}") - else: - pulses_block.append( - f"set_ph {convert_phase(pulses[n].relative_phase)}", - comment=f"set relative phase {pulses[n].relative_phase} rads", - ) - - # Calculate the delay_after_play that is to be used as an argument to the play instruction - if len(pulses) > n + 1: - # If there are more pulses to be played, the delay is the time between the pulse end and the next pulse start - delay_after_play = pulses[n + 1].start - pulses[n].start - else: - delay_after_play = sequence_total_duration - pulses[n].start - - if delay_after_play < minimum_delay_between_instructions: - raise Exception( - f"The minimum delay between the start of two pulses in the same channel is {minimum_delay_between_instructions}ns." - ) - - if ( - pulses[n].sweeper - and pulses[n].sweeper.type == QbloxSweeperType.duration - ): - RI = pulses[n].sweeper.register - if pulses[n].type == PulseType.FLUX: - RQ = pulses[n].sweeper.register - else: - RQ = pulses[n].sweeper.aux_register - - pulses_block.append( - f"play {RI},{RQ},{delay_after_play}", # FIXME delay_after_play won't work as the duration increases - comment=f"play pulse {pulses[n]} sweeping its duration", - ) - else: - # Prepare play instruction: play wave_i_index, wave_q_index, delay_next_instruction - pulses_block.append( - f"play {sequencer.waveforms_buffer.unique_waveforms.index(pulses[n].waveform_i)},{sequencer.waveforms_buffer.unique_waveforms.index(pulses[n].waveform_q)},{delay_after_play}", - comment=f"play waveforms {pulses[n]}", - ) - - body_block += pulses_block - body_block.append_spacer() - - final_reset_block = wait_block( - wait_time=time_between_repetitions, - register=Register(program), - force_multiples_of_four=False, - ) - body_block += final_reset_block - - footer_block = Block("cleanup") - footer_block.append(f"stop") - - # wrap pulses block in sweepers loop blocks - for sweeper in sweepers: - body_block = sweeper.qs.block(inner_block=body_block) - - nshots_block: Block = loop_block( - start=0, - stop=nshots, - step=1, - register=nshots_register, - block=body_block, - ) - navgs_block = loop_block( - start=0, - stop=navgs, - step=1, - register=navgs_register, - block=nshots_block, - ) - program.add_blocks(header_block, navgs_block, footer_block) - - sequencer.program = repr(program) - - def upload(self): - """Uploads waveforms and programs of all sequencers and arms them in - preparation for execution. - - This method should be called after `process_pulse_sequence()`. - It configures certain parameters of the instrument based on the - needs of resources determined while processing the pulse - sequence. - """ - # Setup - for sequencer_number in self._used_sequencers_numbers: - target = self.device.sequencers[sequencer_number] - target.set("sync_en", True) - target.set("marker_ovr_en", True) # Default after reboot = False - target.set("marker_ovr_value", 15) # Default after reboot = 0 - - for sequencer_number in self._unused_sequencers_numbers: - target = self.device.sequencers[sequencer_number] - target.set("sync_en", False) - target.set("marker_ovr_en", True) # Default after reboot = False - target.set("marker_ovr_value", 0) # Default after reboot = 0 - if sequencer_number >= 4: # Never disconnect default sequencers - target.set("connect_out0", "off") - target.set("connect_out1", "off") - target.set("connect_out2", "off") - target.set("connect_out3", "off") - - # Upload waveforms and program - qblox_dict = {} - sequencer: Sequencer - for port in self._ports: - for sequencer in self._sequencers[port]: - # Add sequence program and waveforms to single dictionary - qblox_dict[sequencer] = { - "waveforms": sequencer.waveforms, - "weights": sequencer.weights, - "acquisitions": sequencer.acquisitions, - "program": sequencer.program, - } - - # Upload dictionary to the device sequencers - self.device.sequencers[sequencer.number].sequence(qblox_dict[sequencer]) - - # DEBUG: QCM Save sequence to file - if self._debug_folder != "": - filename = ( - self._debug_folder - + f"Z_{self.name}_sequencer{sequencer.number}_sequence.json" - ) - with open(filename, "w", encoding="utf-8") as file: - json.dump(qblox_dict[sequencer], file, indent=4) - file.write(sequencer.program) - - # Arm sequencers - for sequencer_number in self._used_sequencers_numbers: - self.device.arm_sequencer(sequencer_number) - - # DEBUG: QCM Print Readable Snapshot - # print(self.name) - # self.device.print_readable_snapshot(update=True) - - # DEBUG: QCM Save Readable Snapshot - from qibolab.instruments.qblox.debug import print_readable_snapshot - - if self._debug_folder != "": - filename = self._debug_folder + f"Z_{self.name}_snapshot.json" - with open(filename, "w", encoding="utf-8") as file: - print_readable_snapshot(self.device, file, update=True) - - def play_sequence(self): - """Executes the sequence of instructions.""" - - for sequencer_number in self._used_sequencers_numbers: - # Start used sequencers - self.device.start_sequencer(sequencer_number) - - def disconnect(self): - """Stops all sequencers, disconnect all the outputs from the AWG paths - of the sequencers.""" - if not self.is_connected: - return - for sequencer_number in self._used_sequencers_numbers: - status = self.device.get_sequencer_status(sequencer_number) - if status.state is not SequencerStates.STOPPED: - log.warning( - f"Device {self.device.sequencers[sequencer_number].name} did not stop normally\nstatus: {status}" - ) - - self.device.stop_sequencer() - self.device.disconnect_outputs() - self.is_connected = False - self.device = None diff --git a/src/qibolab/instruments/qblox/cluster_qcm_rf.py b/src/qibolab/instruments/qblox/cluster_qcm_rf.py deleted file mode 100644 index cd91832577..0000000000 --- a/src/qibolab/instruments/qblox/cluster_qcm_rf.py +++ /dev/null @@ -1,760 +0,0 @@ -"""Qblox Cluster QCM-RF driver.""" - -import json - -from qblox_instruments.native.generic_func import SequencerStates -from qblox_instruments.qcodes_drivers.cluster import Cluster -from qblox_instruments.qcodes_drivers.module import Module -from qibo.config import log - -from qibolab.instruments.qblox.module import ClusterModule -from qibolab.instruments.qblox.q1asm import ( - Block, - Register, - convert_phase, - loop_block, - wait_block, -) -from qibolab.instruments.qblox.sequencer import Sequencer, WaveformsBuffer -from qibolab.instruments.qblox.sweeper import QbloxSweeper, QbloxSweeperType -from qibolab.pulses import Pulse, PulseSequence, PulseType -from qibolab.sweeper import Parameter, Sweeper, SweeperType - - -class QcmRf(ClusterModule): - """Qblox Cluster Qubit Control Module RF driver. - - Qubit Control Module RF (QCM-RF) is an instrument that integrates an arbitratry - wave generator, with a local oscillator and a mixer. It has two output ports - Each port has a path0 and path1 for the i(in-phase) and q(quadrature) components - of the RF signal. The sampling rate of its ADC/DAC is 1 GSPS. - https://www.qblox.com/cluster - - The class aims to simplify the configuration of the instrument, exposing only - those parameters most frequencly used and hiding other more complex components. - - A reference to the underlying `qblox_instruments.qcodes_drivers.qcm_qrm.QRM_QCM` - object is provided via the attribute `device`, allowing the advanced user to gain - access to the features that are not exposed directly by the class. - - In order to accelerate the execution, the instrument settings are cached, so that - the communication with the instrument only happens when the parameters change. - This caching is done with the method `_set_device_parameter(target, *parameters, value)`. - - .. code-block:: text - - ports: - o1: # output port settings - channel : L3-11 - attenuation : 24 # (dB) 0 to 60, must be multiple of 2 - lo_enabled : true - lo_frequency : 4_042_590_000 # (Hz) from 2e9 to 18e9 - gain : 0.17 # for path0 and path1 -1.0<=v<=1.0 - o2: - channel : L3-12 - attenuation : 24 # (dB) 0 to 60, must be multiple of 2 - lo_enabled : true - lo_frequency : 5_091_155_529 # (Hz) from 2e9 to 18e9 - gain : 0.28 # for path0 and path1 -1.0<=v<=1.0 - - Attributes: - name (str): A unique name given to the instrument. - address (str): IP_address:module_number (the IP address of the cluster and - the module number) - device (QcmQrm): A reference to the underlying - `qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm` object. It can be used to access other - features not directly exposed by this wrapper. - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/api_reference/qcm_qrm.html - - ports = A dictionary giving access to the output ports objects. - - - ports['o1'] - - ports['o2'] - - - ports['o1'].channel (int | str): the id of the refrigerator channel the port is connected to. - - ports['o1'].attenuation (int): (mapped to qrm.out0_att) Controls the attenuation applied to - the output port. Must be a multiple of 2 - - ports['o1'].lo_enabled (bool): (mapped to qrm.out0_in0_lo_en) Enables or disables the - local oscillator. - - ports['o1'].lo_frequency (int): (mapped to qrm.out0_in0_lo_freq) Sets the frequency of the - local oscillator. - - ports['o1'].gain (float): (mapped to qrm.sequencers[0].gain_awg_path0 and qrm.sequencers[0].gain_awg_path1) - Sets the gain on both paths of the output port. - - ports['o1'].hardware_mod_en (bool): (mapped to qrm.sequencers[0].mod_en_awg) Enables pulse - modulation in hardware. When set to False, pulse modulation is done at the host computer - and a modulated pulse waveform should be uploaded to the instrument. When set to True, - the envelope of the pulse should be uploaded to the instrument and it modulates it in - real time by its FPGA using the sequencer nco (numerically controlled oscillator). - - ports['o1'].nco_freq (int): (mapped to qrm.sequencers[0].nco_freq) # TODO mapped, but not configurable from the runcard - - ports['o1'].nco_phase_offs = (mapped to qrm.sequencers[0].nco_phase_offs) # TODO mapped, but not configurable from the runcard - - - ports['o2'].channel (int | str): the id of the refrigerator channel the port is connected to. - - ports['o2'].attenuation (int): (mapped to qrm.out1_att) Controls the attenuation applied to - the output port. Must be a multiple of 2 - - ports['o2'].lo_enabled (bool): (mapped to qrm.out1_lo_en) Enables or disables the - local oscillator. - - ports['o2'].lo_frequency (int): (mapped to qrm.out1_lo_freq) Sets the frequency of the - local oscillator. - - ports['o2'].gain (float): (mapped to qrm.sequencers[1].gain_awg_path0 and qrm.sequencers[0].gain_awg_path1) - Sets the gain on both paths of the output port. - - ports['o2'].hardware_mod_en (bool): (mapped to qrm.sequencers[1].mod_en_awg) Enables pulse - modulation in hardware. When set to False, pulse modulation is done at the host computer - and a modulated pulse waveform should be uploaded to the instrument. When set to True, - the envelope of the pulse should be uploaded to the instrument and it modulates it in - real time by its FPGA using the sequencer nco (numerically controlled oscillator). - - ports['o2'].nco_freq (int): (mapped to qrm.sequencers[1].nco_freq) # TODO mapped, but not configurable from the runcard - - ports['o2'].nco_phase_offs = (mapped to qrm.sequencers[1].nco_phase_offs) # TODO mapped, but not configurable from the runcard - - - Sequencer 0 is always the first sequencer used to synthesise pulses on port o1. - - Sequencer 1 is always the first sequencer used to synthesise pulses on port o2. - - Sequencer 2 to 6 are used as needed to sinthesise simultaneous pulses on the same channel - or when the memory of the default sequencers rans out. - - - channels (list): A list of the channels to which the instrument is connected. - """ - - DEFAULT_SEQUENCERS = {"o1": 0, "o2": 1} - FREQUENCY_LIMIT = 500e6 - - def __init__(self, name: str, address: str): - """Initialize a Qblox QCM-RF module. - - Parameters: - - name: An arbitrary name to identify the module. - - address: The network address of the instrument, specified as "cluster_IP:module_slot_idx". - - cluster: The Cluster object to which the QCM-RF module is connected. - - Example: - To create a QcmRf instance named 'qcm_rf' connected to slot 2 of a Cluster at address '192.168.0.100': - >>> cluster_instance = Cluster("cluster","192.168.1.100", settings) - >>> qcm_module = QcmRf(name="qcm_rf", address="192.168.1.100:2", cluster=cluster_instance) - """ - super().__init__(name, address) - self.device: Module = None - self.settings = {} - - self._debug_folder: str = "" - self._sequencers: dict[Sequencer] = {} - self.channel_map: dict = {} - self._device_num_output_ports = 2 - self._device_num_sequencers: int - self._free_sequencers_numbers: list[int] = [] - self._used_sequencers_numbers: list[int] = [] - self._unused_sequencers_numbers: list[int] = [] - - def _set_default_values(self): - # disable all sequencer connections - self.device.disconnect_outputs() - # set I (path0) and Q (path1) offset to zero on output port 0 and 1. Default values after reboot = 7.625 - for i in range(2): - [self.device.set(f"out{i}_offset_path{j}", 0) for j in range(2)] - - # initialise the parameters of the default sequencers to the default values, - # the rest of the sequencers are disconnected but will be configured - # with the same parameters as the default in process_pulse_sequence() - default_sequencers = [ - self.device.sequencers[i] for i in self.DEFAULT_SEQUENCERS.values() - ] - for target in default_sequencers: - for name, value in self.DEFAULT_SEQUENCERS_VALUES.items(): - target.set(name, value) - - # connect the default sequencers to the out port - self.device.sequencers[self.DEFAULT_SEQUENCERS["o1"]].set("connect_out0", "IQ") - self.device.sequencers[self.DEFAULT_SEQUENCERS["o1"]].set("connect_out1", "off") - self.device.sequencers[self.DEFAULT_SEQUENCERS["o2"]].set("connect_out1", "IQ") - self.device.sequencers[self.DEFAULT_SEQUENCERS["o2"]].set("connect_out0", "off") - - def connect(self, cluster: Cluster = None): - """Connects to the instrument using the instrument settings in the - runcard. - - Once connected, it creates port classes with properties mapped - to various instrument parameters, and initialises the the - underlying device parameters. It uploads to the module the port - settings loaded from the runcard. - """ - if self.is_connected: - return - - elif cluster is not None: - self.device = cluster.modules[int(self.address.split(":")[1]) - 1] - # test connection with module - if not self.device.present(): - raise ConnectionError( - f"Module {self.device.name} not connected to cluster {cluster.name}" - ) - # once connected, initialise the parameters of the device to the default values - self._device_num_sequencers = len(self.device.sequencers) - self._set_default_values() - # then set the value loaded from the runcard - try: - for port in self.settings: - self._sequencers[port] = [] - if self.settings[port]["lo_frequency"]: - self._ports[port].lo_enabled = True - self._ports[port].lo_frequency = self.settings[port][ - "lo_frequency" - ] - self._ports[port].attenuation = self.settings[port]["attenuation"] - self._ports[port].hardware_mod_en = True - self._ports[port].nco_freq = 0 - self._ports[port].nco_phase_offs = 0 - except Exception as error: - raise RuntimeError( - f"Unable to initialize port parameters on module {self.name}: {error}" - ) - self.is_connected = True - - def setup(self, **settings): - """Cache the settings of the runcard and instantiate the ports of the - module. - - Args: - **settings: dict = A dictionary of settings loaded from the runcard: - - - settings['o1']['attenuation'] (int): [0 to 60 dBm, in multiples of 2] attenuation at the output. - - settings['o1']['lo_frequency'] (int): [2_000_000_000 to 18_000_000_000 Hz] local oscillator frequency. - - settings['o1']['hardware_mod_en'] (bool): enables Hardware Modulation. In this mode, pulses are modulated to the intermediate frequency - using the numerically controlled oscillator within the fpga. It only requires the upload of the pulse envelope waveform. - At the moment this param is not loaded but is always set to True. - - - settings['o2']['attenuation'] (int): [0 to 60 dBm, in multiples of 2] attenuation at the output. - - settings['o2']['lo_frequency'] (int): [2_000_000_000 to 18_000_000_000 Hz] local oscillator frequency. - - settings['o2']['hardware_mod_en'] (bool): enables Hardware Modulation. In this mode, pulses are modulated to the intermediate frequency - using the numerically controlled oscillator within the fpga. It only requires the upload of the pulse envelope waveform. - At the moment this param is not loaded but is always set to True. - """ - self.settings = settings if settings else self.settings - - def _get_next_sequencer(self, port, frequency, qubit: None): - """Retrieves and configures the next avaliable sequencer. - - The parameters of the new sequencer are copied from those of the default sequencer, except for the - intermediate frequency and classification parameters. - Args: - port (str): - frequency (): - qubit (): - Raises: - Exception = If attempting to set a parameter without a connection to the instrument. - """ - - # select a new sequencer and configure it as required - next_sequencer_number = self._free_sequencers_numbers.pop(0) - if next_sequencer_number != self.DEFAULT_SEQUENCERS[port]: - for parameter in self.device.sequencers[ - self.DEFAULT_SEQUENCERS[port] - ].parameters: - # exclude read-only parameter `sequence` - if parameter not in ["sequence"]: - value = self.device.sequencers[self.DEFAULT_SEQUENCERS[port]].get( - param_name=parameter - ) - if value: - target = self.device.sequencers[next_sequencer_number] - target.set(parameter, value) - - # if hardware modulation is enabled configure nco_frequency - if self._ports[port].hardware_mod_en: - self.device.sequencers[next_sequencer_number].set("nco_freq", frequency) - # Assumes all pulses in non_overlapping_pulses set - # have the same frequency. Non-overlapping pulses of different frequencies on the same - # qubit channel with hardware_demod_en would lead to wrong results. - # TODO: Throw error in that event or implement for non_overlapping_same_frequency_pulses - # Even better, set the frequency before each pulse is played (would work with hardware modulation only) - - # create sequencer wrapper - sequencer = Sequencer(next_sequencer_number) - sequencer.qubit = qubit - return sequencer - - def get_if(self, pulse): - """Returns the intermediate frequency needed to synthesise a pulse - based on the port lo frequency.""" - - _rf = pulse.frequency - _lo = self.channel_map[pulse.channel].lo_frequency - _if = _rf - _lo - if abs(_if) > self.FREQUENCY_LIMIT: - raise Exception( - f""" - Pulse frequency {_rf:_} cannot be synthesised with current lo frequency {_lo:_}. - The intermediate frequency {_if:_} would exceed the maximum frequency of {self.FREQUENCY_LIMIT:_} - """ - ) - return _if - - def process_pulse_sequence( - self, - qubits: dict, - instrument_pulses: PulseSequence, - navgs: int, - nshots: int, - repetition_duration: int, - sweepers=None, - ): - """Processes a sequence of pulses and sweepers, generating the - waveforms and program required by the instrument to synthesise them. - - The output of the process is a list of sequencers used for each port, configured with the information - required to play the sequence. - The following features are supported: - - - overlapping pulses - - hardware modulation - - software modulation, with support for arbitrary pulses - - real-time sweepers of - - - pulse frequency (requires hardware modulation) - - pulse relative phase (requires hardware modulation) - - pulse amplitude - - pulse start - - pulse duration - - port gain - - port offset - - - sequencer memory optimisation (waveforms cache) - - extended waveform memory with the use of multiple sequencers - - pulses of up to 8192 pairs of i, q samples - - intrument parameters cache - - Args: - instrument_pulses (PulseSequence): A collection of Pulse objects to be played by the instrument. - navgs (int): The number of times the sequence of pulses should be executed averaging the results. - nshots (int): The number of times the sequence of pulses should be executed without averaging. - repetition_duration (int): The total duration of the pulse sequence execution plus the reset/relaxation time. - sweepers (list(Sweeper)): A list of Sweeper objects to be implemented. - """ - if sweepers is None: - sweepers = [] - sequencer: Sequencer - sweeper: Sweeper - - self._free_sequencers_numbers = list(range(len(self._ports), 6)) - - # process the pulses for every port - for port in self._ports: - # split the collection of instruments pulses by ports - port_channel = [ - chan.name - for chan in self.channel_map.values() - if chan.port.name == port - ] - port_pulses: PulseSequence = instrument_pulses.get_channel_pulses( - *port_channel - ) - - # initialise the list of sequencers required by the port - self._sequencers[port] = [] - - if not port_pulses.is_empty: - # initialise the list of free sequencer numbers to include the default for each port {'o1': 0, 'o2': 1} - self._free_sequencers_numbers = [ - self.DEFAULT_SEQUENCERS[port] - ] + self._free_sequencers_numbers - - # split the collection of port pulses in non overlapping pulses - non_overlapping_pulses: PulseSequence - for non_overlapping_pulses in port_pulses.separate_overlapping_pulses(): - # each set of not overlapping pulses will be played by a separate sequencer - # check sequencer availability - if len(self._free_sequencers_numbers) == 0: - raise Exception( - f"The number of sequencers requried to play the sequence exceeds the number available {self._device_num_sequencers}." - ) - - # get next sequencer - sequencer = self._get_next_sequencer( - port=port, - frequency=self.get_if(non_overlapping_pulses[0]), - qubit=non_overlapping_pulses[0].qubit, - ) - # add the sequencer to the list of sequencers required by the port - self._sequencers[port].append(sequencer) - - # make a temporary copy of the pulses to be processed - pulses_to_be_processed = non_overlapping_pulses.shallow_copy() - while not pulses_to_be_processed.is_empty: - pulse: Pulse = pulses_to_be_processed[0] - # attempt to save the waveforms to the sequencer waveforms buffer - try: - sequencer.waveforms_buffer.add_waveforms( - pulse, self._ports[port].hardware_mod_en, sweepers - ) - sequencer.pulses.add(pulse) - pulses_to_be_processed.remove(pulse) - - # if there is not enough memory in the current sequencer, use another one - except WaveformsBuffer.NotEnoughMemory: - if ( - len(pulse.waveform_i) + len(pulse.waveform_q) - > WaveformsBuffer.SIZE - ): - raise NotImplementedError( - f"Pulses with waveforms longer than the memory of a sequencer ({WaveformsBuffer.SIZE // 2}) are not supported." - ) - if len(self._free_sequencers_numbers) == 0: - raise Exception( - f"The number of sequencers requried to play the sequence exceeds the number available {self._device_num_sequencers}." - ) - # get next sequencer - sequencer = self._get_next_sequencer( - port=port, - frequency=self.get_if(non_overlapping_pulses[0]), - qubit=non_overlapping_pulses[0].qubit, - ) - # add the sequencer to the list of sequencers required by the port - self._sequencers[port].append(sequencer) - - # update the lists of used and unused sequencers that will be needed later on - self._used_sequencers_numbers = [] - for port in self._ports: - for sequencer in self._sequencers[port]: - self._used_sequencers_numbers.append(sequencer.number) - self._unused_sequencers_numbers = [] - for n in range(self._device_num_sequencers): - if not n in self._used_sequencers_numbers: - self._unused_sequencers_numbers.append(n) - - # generate and store the Waveforms dictionary, the Acquisitions dictionary, the Weights and the Program - for port in self._ports: - for sequencer in self._sequencers[port]: - pulses = sequencer.pulses - program = sequencer.program - - ## pre-process sweepers ## - # TODO: move qibolab sweepers preprocessing to qblox controller - - # attach a sweeper attribute to the pulse so that it is easily accesible by the code that generates - # the pseudo-assembly program - pulse = None - for pulse in pulses: - pulse.sweeper = None - - pulse_sweeper_parameters = [ - Parameter.frequency, - Parameter.amplitude, - Parameter.duration, - Parameter.relative_phase, - Parameter.start, - ] - - for sweeper in sweepers: - if sweeper.parameter in pulse_sweeper_parameters: - # check if this sequencer takes an active role in the sweep - if sweeper.pulses and set(sequencer.pulses) & set( - sweeper.pulses - ): - # plays an active role - reference_value = None - if ( - sweeper.parameter == Parameter.frequency - and sequencer.pulses - ): - reference_value = self.get_if(sequencer.pulses[0]) - if sweeper.parameter == Parameter.amplitude: - for pulse in pulses: - if pulse in sweeper.pulses: - reference_value = ( - pulse.amplitude - ) # uses the amplitude of the first pulse - if ( - sweeper.parameter == Parameter.duration - and pulse in sweeper.pulses - ): - # for duration sweepers bake waveforms - sweeper.qs = QbloxSweeper( - program=program, - type=QbloxSweeperType.duration, - rel_values=pulse.idx_range, - ) - else: - # create QbloxSweepers and attach them to qibolab sweeper - if ( - sweeper.type == SweeperType.OFFSET - and reference_value - ): - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, - sweeper=sweeper, - add_to=reference_value, - ) - elif ( - sweeper.type == SweeperType.FACTOR - and reference_value - ): - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, - sweeper=sweeper, - multiply_to=reference_value, - ) - else: - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, sweeper=sweeper - ) - - # finally attach QbloxSweepers to the pulses being swept - sweeper.qs.update_parameters = True - pulse.sweeper = sweeper.qs - else: - # does not play an active role - sweeper.qs = QbloxSweeper( - program=program, - type=QbloxSweeperType.number, - rel_values=range(len(sweeper.values)), - name=sweeper.parameter.name, - ) - - else: - # does not play an active role - sweeper.qs = QbloxSweeper( - program=program, - type=QbloxSweeperType.number, - rel_values=range(len(sweeper.values)), - name=sweeper.parameter.name, - ) - - # # FIXME: for qubit sweepers (Parameter.bias, Parameter.attenuation, Parameter.gain), the qubit - # # information alone is not enough to determine what instrument parameter is to be swept. - # # For example port gain, both the drive and readout ports have gain parameters. - # # Until this is resolved, and since bias is only implemented with QCMs offset, this instrument will - # # never take an active role in those sweeps. - - # Waveforms - for index, waveform in enumerate( - sequencer.waveforms_buffer.unique_waveforms - ): - sequencer.waveforms[waveform.serial] = { - "data": waveform.data.tolist(), - "index": index, - } - - # Program - minimum_delay_between_instructions = 4 - - sequence_total_duration = ( - pulses.finish - ) # the minimum delay between instructions is 4ns - time_between_repetitions = repetition_duration - sequence_total_duration - assert time_between_repetitions > minimum_delay_between_instructions - # TODO: currently relaxation_time needs to be greater than acquisition_hold_off - # so that the time_between_repetitions is equal to the sequence_total_duration + relaxation_time - # to be compatible with th erest of the platforms, change it so that time_between_repetitions - # is equal to pulsesequence duration + acquisition_hold_off if relaxation_time < acquisition_hold_off - - # create registers for key variables - # nshots is used in the loop that iterates over the number of shots - nshots_register = Register(program, "nshots") - # navgs is used in the loop of hardware averages - navgs_register = Register(program, "navgs") - - header_block = Block("setup") - - body_block = Block() - - body_block.append(f"wait_sync {minimum_delay_between_instructions}") - if self._ports[port].hardware_mod_en: - body_block.append("reset_ph") - body_block.append_spacer() - - pulses_block = Block("play") - # Add an initial wait instruction for the first pulse of the sequence - initial_wait_block = wait_block( - wait_time=pulses[0].start, - register=Register(program), - force_multiples_of_four=False, - ) - pulses_block += initial_wait_block - - for n in range(pulses.count): - if ( - pulses[n].sweeper - and pulses[n].sweeper.type == QbloxSweeperType.start - ): - pulses_block.append(f"wait {pulses[n].sweeper.register}") - - if self._ports[port].hardware_mod_en: - # # Set frequency - # _if = self.get_if(pulses[n]) - # pulses_block.append(f"set_freq {convert_frequency(_if)}", f"set intermediate frequency to {_if} Hz") - - # Set phase - if ( - pulses[n].sweeper - and pulses[n].sweeper.type - == QbloxSweeperType.relative_phase - ): - pulses_block.append(f"set_ph {pulses[n].sweeper.register}") - else: - pulses_block.append( - f"set_ph {convert_phase(pulses[n].relative_phase)}", - comment=f"set relative phase {pulses[n].relative_phase} rads", - ) - - # Calculate the delay_after_play that is to be used as an argument to the play instruction - if len(pulses) > n + 1: - # If there are more pulses to be played, the delay is the time between the pulse end and the next pulse start - delay_after_play = pulses[n + 1].start - pulses[n].start - else: - delay_after_play = sequence_total_duration - pulses[n].start - - if delay_after_play < minimum_delay_between_instructions: - raise Exception( - f"The minimum delay between the start of two pulses in the same channel is {minimum_delay_between_instructions}ns." - ) - - if ( - pulses[n].sweeper - and pulses[n].sweeper.type == QbloxSweeperType.duration - ): - RI = pulses[n].sweeper.register - if pulses[n].type == PulseType.FLUX: - RQ = pulses[n].sweeper.register - else: - RQ = pulses[n].sweeper.aux_register - - pulses_block.append( - f"play {RI},{RQ},{delay_after_play}", # FIXME delay_after_play won't work as the duration increases - comment=f"play pulse {pulses[n]} sweeping its duration", - ) - else: - # Prepare play instruction: play wave_i_index, wave_q_index, delay_next_instruction - pulses_block.append( - f"play {sequencer.waveforms_buffer.unique_waveforms.index(pulses[n].waveform_i)},{sequencer.waveforms_buffer.unique_waveforms.index(pulses[n].waveform_q)},{delay_after_play}", - comment=f"play waveforms {pulses[n]}", - ) - - body_block += pulses_block - body_block.append_spacer() - - final_reset_block = wait_block( - wait_time=time_between_repetitions, - register=Register(program), - force_multiples_of_four=False, - ) - - body_block += final_reset_block - - footer_block = Block("cleanup") - footer_block.append(f"stop") - - # wrap pulses block in sweepers loop blocks - for sweeper in sweepers: - body_block = sweeper.qs.block(inner_block=body_block) - - nshots_block: Block = loop_block( - start=0, - stop=nshots, - step=1, - register=nshots_register, - block=body_block, - ) - - navgs_block = loop_block( - start=0, - stop=navgs, - step=1, - register=navgs_register, - block=nshots_block, - ) - program.add_blocks(header_block, navgs_block, footer_block) - - sequencer.program = repr(program) - - def upload(self): - """Uploads waveforms and programs of all sequencers and arms them in - preparation for execution. - - This method should be called after `process_pulse_sequence()`. - It configures certain parameters of the instrument based on the - needs of resources determined while processing the pulse - sequence. - """ - # Setup - for sequencer_number in self._used_sequencers_numbers: - target = self.device.sequencers[sequencer_number] - - target.set("sync_en", True) - target.set("marker_ovr_en", True) - target.set("marker_ovr_value", 15) # Default after reboot = 0 - for sequencer_number in self._unused_sequencers_numbers: - target = self.device.sequencers[sequencer_number] - - target.set("marker_ovr_value", 0) # Default after reboot = 0 - target.set("marker_ovr_en", True) # Default after reboot = False - target.set("sync_en", False) - if sequencer_number >= 2: # Never disconnect default sequencers - target.set("connect_out0", "off") - target.set("connect_out1", "off") - - # Upload waveforms and program - qblox_dict = {} - sequencer: Sequencer - for port in self._ports: - for sequencer in self._sequencers[port]: - # Add sequence program and waveforms to single dictionary - qblox_dict[sequencer] = { - "waveforms": sequencer.waveforms, - "weights": sequencer.weights, - "acquisitions": sequencer.acquisitions, - "program": sequencer.program, - } - - # Upload dictionary to the device sequencers - self.device.sequencers[sequencer.number].sequence(qblox_dict[sequencer]) - - # DEBUG: QCM RF Save sequence to file - if self._debug_folder != "": - filename = ( - self._debug_folder - + f"Z_{self.name}_sequencer{sequencer.number}_sequence.json" - ) - with open(filename, "w", encoding="utf-8") as file: - json.dump(qblox_dict[sequencer], file, indent=4) - file.write(sequencer.program) - - # Arm sequencers - for sequencer_number in self._used_sequencers_numbers: - self.device.arm_sequencer(sequencer_number) - - # DEBUG: QCM RF Print Readable Snapshot - # print(self.name) - # self.device.print_readable_snapshot(update=True) - - # DEBUG: QCM RF Save Readable Snapshot - from qibolab.instruments.qblox.debug import print_readable_snapshot - - if self._debug_folder != "": - filename = self._debug_folder + f"Z_{self.name}_snapshot.json" - with open(filename, "w", encoding="utf-8") as file: - print_readable_snapshot(self.device, file, update=True) - - def play_sequence(self): - """Plays the sequence of pulses. - - Starts the sequencers needed to play the sequence of pulses. - """ - - for sequencer_number in self._used_sequencers_numbers: - # Start used sequencers - self.device.start_sequencer(sequencer_number) - - def disconnect(self): - """Stops all sequencers, disconnect all the outputs from the AWG paths - of the sequencers.""" - if not self.is_connected: - return - for sequencer_number in self._used_sequencers_numbers: - status = self.device.get_sequencer_status(sequencer_number) - if status.state is not SequencerStates.STOPPED: - log.warning( - f"Device {self.device.sequencers[sequencer_number].name} did not stop normally\nstate: {status}" - ) - - self.device.stop_sequencer() - self.device.disconnect_outputs() - - self.is_connected = False - self.device = None diff --git a/src/qibolab/instruments/qblox/cluster_qrm_rf.py b/src/qibolab/instruments/qblox/cluster_qrm_rf.py deleted file mode 100644 index a70d26c428..0000000000 --- a/src/qibolab/instruments/qblox/cluster_qrm_rf.py +++ /dev/null @@ -1,1034 +0,0 @@ -"""Qblox Cluster QRM-RF driver.""" - -import json -import time - -import numpy as np -from qblox_instruments.native.generic_func import SequencerStates -from qblox_instruments.qcodes_drivers.cluster import Cluster -from qblox_instruments.qcodes_drivers.module import Module -from qibo.config import log - -from qibolab.pulses import Pulse, PulseSequence, PulseType -from qibolab.sweeper import Parameter, Sweeper, SweeperType - -from .acquisition import AveragedAcquisition, DemodulatedAcquisition -from .module import ClusterModule -from .q1asm import Block, Register, convert_phase, loop_block, wait_block -from .sequencer import Sequencer, WaveformsBuffer -from .sweeper import QbloxSweeper, QbloxSweeperType - - -class QrmRf(ClusterModule): - """Qblox Cluster Qubit Readout Module RF driver. - - Qubit Readout Module RF (QRM-RF) is an instrument that integrates an arbitrary wave generator, a digitizer, - a local oscillator and a mixer. It has one output and one input port. Each port has a path0 and path1 for the - i(in-phase) and q(quadrature) components of the RF signal. The sampling rate of its ADC/DAC is 1 GSPS. - https://www.qblox.com/cluster - - The class aims to simplify the configuration of the instrument, exposing only those parameters most frequently - used and hiding other more complex settings. - - A reference to the underlying `qblox_instruments.qcodes_drivers.qcm_qrm.QRM_QCM` object is provided via the - attribute `device`, allowing the advanced user to gain access to the features that are not exposed directly - by the class. - - In order to accelerate the execution, the instrument settings are cached, so that the communication with the - instrument only happens when the parameters change. This caching is done with the method - `_set_device_parameter(target, *parameters, value)`. - - .. code-block:: text - - ports: - o1: # output port settings - channel : L3-25a - attenuation : 30 # (dB) 0 to 60, must be multiple of 2 - lo_enabled : true - lo_frequency : 6_000_000_000 # (Hz) from 2e9 to 18e9 - gain : 1 # for path0 and path1 -1.0<=v<=1.0 - i1: # input port settings - channel : L2-5a - acquisition_hold_off : 130 # minimum 4ns - acquisition_duration : 1800 - - classification_parameters: - 0: # qubit id - rotation_angle : 0 # in degrees 0.0<=v<=360.0 - threshold : 0 # in V - 1: - rotation_angle : 194.272 - threshold : 0.011197 - 2: - rotation_angle : 104.002 - threshold : 0.012745 - - Attributes: - name (str): A unique name given to the instrument. - address (str): IP_address:module_number; the IP address of the cluster and - the module number. - device (QcmQrm): A reference to the underlying `qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm` object. - It can be used to access other features not directly exposed by this wrapper. - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/api_reference/qcm_qrm.html - - ports = A dictionary giving access to the input and output ports objects. - - - ports['o1']: Output port - - ports['i1']: Input port - - - ports['o1'].channel (int | str): the id of the refrigerator channel the output port o1 is connected to. - - ports['o1'].attenuation (int): (mapped to qrm.out0_att) Controls the attenuation applied to the output - port. It must be a multiple of 2. - - ports['o1'].lo_enabled (bool): (mapped to qrm.out0_in0_lo_en) Enables or disables the local oscillator. - - ports['o1'].lo_frequency (int): (mapped to qrm.out0_in0_lo_freq) Sets the frequency of the local oscillator. - - ports['o1'].gain (float): (mapped to qrm.sequencers[0].gain_awg_path0 and qrm.sequencers[0].gain_awg_path1) - Sets the gain on both paths of the output port. - - ports['o1'].hardware_mod_en (bool): (mapped to qrm.sequencers[0].mod_en_awg) Enables pulse modulation - in hardware. When set to False, pulse modulation is done in software, at the host computer, and the - modulated pulse waveform is uploaded to the instrument. When set to True, the envelope of the pulse - is uploaded to the instrument and it is modulated in real time by the FPGA of the instrument, using - the sequencer nco (numerically controlled oscillator). - - ports['o1'].nco_freq (int): (mapped to qrm.sequencers[0].nco_freq). Mapped, but not configurable from - the runcard. - - ports['o1'].nco_phase_offs = (mapped to qrm.sequencers[0].nco_phase_offs). Mapped, but not configurable - from the runcard. - - - ports['i1'].channel (int | str): the id of the refrigerator channel the input port o1 is connected to. - - ports['i1'].acquisition_hold_off (int): Delay between the moment the readout pulse starts to be played and - the start of the acquisition, in ns. It must be > 0 and multiple of 4. - - ports['i1'].acquisition_duration (int): (mapped to qrm.sequencers[0].integration_length_acq) Duration - of the pulse acquisition, in ns. It must be > 0 and multiple of 4. - - ports['i1'].hardware_demod_en (bool): (mapped to qrm.sequencers[0].demod_en_acq) Enables demodulation - and integration of the acquired pulses in hardware. When set to False, the filtration, demodulation - and integration of the acquired pulses is done at the host computer. When set to True, the - demodulation, integration and discretization of the pulse is done in real time at the FPGA of the - instrument. - - - Sequencer 0 is used always for acquisitions and it is the first sequencer used to synthesise pulses. - - Sequencer 1 to 6 are used as needed to synthesise simultaneous pulses on the same channel (required in - multiplexed readout) or when the memory of the default sequencers rans out. - - classification_parameters (dict): A dictionary containing the parameters needed classify the state of each qubit. - from a single shot measurement: - qubit_id (dict): the id of the qubit - rotation_angle (float): 0 # in degrees 0.0<=v<=360.0. The angle of the rotation applied at the - origin of the i q plane, that put the centroids of the state ``|0>`` and state ``|1>`` in a horizontal line. - The rotation puts the centroid of state ``|1>`` to the right side of centroid of state ``|0>``. - threshold (float): 0 # in V. The real component of the point along the horizontal line - connecting both state centroids (after being rotated), that maximises the fidelity of the - classification. - - channels (list): A list of the channels to which the instrument is connected. - """ - - DEFAULT_SEQUENCERS: dict = {"o1": 0, "i1": 0} - FREQUENCY_LIMIT = 500e6 # 500 MHz - - def __init__(self, name: str, address: str): - """Initialize a Qblox QRM-RF module. - - Parameters: - - name: An arbitrary name to identify the module. - - address: The network address of the instrument, specified as "cluster_IP:module_slot_idx". - - cluster: The Cluster object to which the QRM-RF module is connected. - - Example: - To create a QrmRf instance named 'qrm_rf' connected to slot 2 of a Cluster at address '192.168.0.100': - >>> cluster_instance = Cluster("cluster","192.168.1.100", settings) - >>> qrm_module = QrmRf(name="qrm_rf", address="192.168.1.100:2", cluster=cluster_instance) - """ - - super().__init__(name, address) - self.device: Module = None - self.classification_parameters: dict = {} - self.settings: dict = {} - - self._debug_folder: str = "" - self._input_ports_keys = ["i1"] - self._output_ports_keys = ["o1"] - self._sequencers: dict[Sequencer] = {"o1": []} - self.channel_map: dict = {} - self._device_num_output_ports = 1 - self._device_num_sequencers: int - self._free_sequencers_numbers: list[int] = [] - self._used_sequencers_numbers: list[int] = [] - self._unused_sequencers_numbers: list[int] = [] - self._execution_time: float = 0 - - def _set_default_values(self): - # disable all sequencer connections - self.device.disconnect_outputs() - self.device.disconnect_inputs() - - # set I (path0) and Q (path1) offset to zero on output port 0. Default values after reboot = 7.625 - [self.device.set(f"out0_offset_path{i}", 0) for i in range(2)] - # set input port parameters to default - self.device.set("in0_att", 0) - self.device.set("scope_acq_avg_mode_en_path0", True) - self.device.set("scope_acq_avg_mode_en_path1", True) - self.device.set("scope_acq_sequencer_select", self.DEFAULT_SEQUENCERS["i1"]) - self.device.set("scope_acq_trigger_level_path0", 0) - self.device.set("scope_acq_trigger_level_path1", 0) - self.device.set("scope_acq_trigger_mode_path0", "sequencer") - self.device.set("scope_acq_trigger_mode_path1", "sequencer") - # initialise the parameters of the default sequencer to the default values, - # the rest of the sequencers are disconnected, but will be configured - # with the same parameters as the default in process_pulse_sequence() - target = self.device.sequencers[self.DEFAULT_SEQUENCERS["o1"]] - for name, value in self.DEFAULT_SEQUENCERS_VALUES.items(): - target.set(name, value) - - # connect sequencer to out/in ports - target.set("connect_out0", "IQ") - target.set("connect_acq", "in0") - - def connect(self, cluster: Cluster = None): - """Connects to the instrument using the instrument settings in the - runcard. - - Once connected, it creates port classes with properties mapped - to various instrument parameters, and initialises the the - underlying device parameters. It uploads to the module the port - settings loaded from the runcard. - """ - if self.is_connected: - return - - elif cluster is not None: - self.device = cluster.modules[int(self.address.split(":")[1]) - 1] - # test connection with module - if not self.device.present(): - raise ConnectionError( - f"Module {self.device.name} not connected to cluster {cluster.name}" - ) - # once connected, initialise the parameters of the device to the default values - self._device_num_sequencers = len(self.device.sequencers) - self._set_default_values() - # then set the value loaded from the runcard - try: - if "o1" in self.settings: - self._ports["o1"].attenuation = self.settings["o1"]["attenuation"] - if self.settings["o1"]["lo_frequency"]: - self._ports["o1"].lo_enabled = True - self._ports["o1"].lo_frequency = self.settings["o1"][ - "lo_frequency" - ] - self._ports["o1"].hardware_mod_en = True - self._ports["o1"].nco_freq = 0 - self._ports["o1"].nco_phase_offs = 0 - - if "i1" in self.settings: - self._ports["i1"].hardware_demod_en = True - self._ports["i1"].acquisition_hold_off = self.settings["i1"][ - "acquisition_hold_off" - ] - self._ports["i1"].acquisition_duration = self.settings["i1"][ - "acquisition_duration" - ] - except Exception as error: - raise RuntimeError( - f"Unable to initialize port parameters on module {self.name}: {error}" - ) - self.is_connected = True - - def setup(self, **settings): - """Cache the settings of the runcard and instantiate the ports of the - module. - - Args: - **settings: dict = A dictionary of settings loaded from the runcard: - - - settings['o1']['attenuation'] (int): [0 to 60 dBm, in multiples of 2] attenuation at the output. - - settings['o1']['lo_enabled'] (bool): enable or disable local oscillator for up-conversion. - - settings['o1']['lo_frequency'] (int): [2_000_000_000 to 18_000_000_000 Hz] local oscillator - frequency. - - settings['o1']['hardware_mod_en'] (bool): enables Hardware Modulation. In this mode, pulses are - modulated to the intermediate frequency using the numerically controlled oscillator within the - fpga. It only requires the upload of the pulse envelope waveform. - At the moment this param is not loaded but is always set to True. - - - settings['i1']['hardware_demod_en'] (bool): enables Hardware Demodulation. In this mode, the - sequencers of the fpga demodulate, integrate and classify the results for every shot. Once - integrated, the i and q values and the result of the classification requires much less memory, - so they can be stored for every shot in separate `bins` and retrieved later. Hardware Demodulation - also allows making multiple readouts on the same qubit at different points in the circuit, which is - not possible with Software Demodulation. At the moment this param is not loaded but is always set to True. - - settings['i1']['acquisition_hold_off'] (int): [0 to 16834 ns, in multiples of 4] the time between the moment - the start of the readout pulse begins to be played, and the start of the acquisition. This is used - to account for the time of flight of the pulses from the output port to the input port. - - settings['i1']['acquisition_duration'] (int): [0 to 8192 ns] the duration of the acquisition. It is limited by - the amount of memory available in the fpga to store i q samples. - """ - self.settings = settings if settings else self.settings - - def _get_next_sequencer(self, port: str, frequency: int, qubits: dict, qubit: None): - """Retrieves and configures the next avaliable sequencer. - - The parameters of the new sequencer are copied from those of the default sequencer, except for the intermediate - frequency and classification parameters. - - Args: - port (str): - frequency (int): - qubit (str|int): - Raises: - Exception = If attempting to set a parameter without a connection to the instrument. - """ - - # select a new sequencer and configure it as required - next_sequencer_number = self._free_sequencers_numbers.pop(0) - if next_sequencer_number != self.DEFAULT_SEQUENCERS[port]: - for parameter in self.device.sequencers[ - self.DEFAULT_SEQUENCERS[port] - ].parameters: - # exclude read-only parameter `sequence` and others that have wrong default values (qblox bug) - if not parameter in [ - "sequence", - "thresholded_acq_marker_address", - "thresholded_acq_trigger_address", - ]: - value = self.device.sequencers[self.DEFAULT_SEQUENCERS[port]].get( - param_name=parameter - ) - if value: - target = self.device.sequencers[next_sequencer_number] - target.set(parameter, value) - - # if hardware demodulation is enabled, configure nco_frequency and classification parameters - if self._ports["i1"].hardware_demod_en or self._ports["o1"].hardware_mod_en: - self.device.sequencers[next_sequencer_number].set("nco_freq", frequency) - # It assumes all pulses in non_overlapping_pulses set have the same frequency. - # Non-overlapping pulses of different frequencies on the same qubit channel, with hardware_demod_en - # would lead to wrong results. - # TODO: Throw error in that event or implement non_overlapping_same_frequency_pulses - # Even better, set the frequency before each pulse is played (would work with hardware modulation only) - - # if self._ports["i1"].hardware_demod_en and qubit in self.classification_parameters: - if self._ports["i1"].hardware_demod_en and not qubits[qubit].threshold is None: - self.device.sequencers[next_sequencer_number].set( - "thresholded_acq_rotation", - (qubits[qubit].iq_angle * 360 / (2 * np.pi)) % 360, - ) - self.device.sequencers[next_sequencer_number].set( - "thresholded_acq_threshold", - qubits[qubit].threshold * self._ports["i1"].acquisition_duration, - ) - # create sequencer wrapper - sequencer = Sequencer(next_sequencer_number) - sequencer.qubit = qubit - return sequencer - - def get_if(self, pulse: Pulse): - """Returns the intermediate frequency needed to synthesise a pulse - based on the port lo frequency.""" - - _rf = pulse.frequency - _lo = self.channel_map[pulse.channel].lo_frequency - _if = _rf - _lo - if abs(_if) > self.FREQUENCY_LIMIT: - raise Exception( - f""" - Pulse frequency {_rf:_} cannot be synthesised with current lo frequency {_lo:_}. - The intermediate frequency {_if:_} would exceed the maximum frequency of {self.FREQUENCY_LIMIT:_} - """ - ) - return _if - - def process_pulse_sequence( - self, - qubits: dict, - instrument_pulses: PulseSequence, - navgs: int, - nshots: int, - repetition_duration: int, - sweepers=None, - ): - """Processes a sequence of pulses and sweepers, generating the - waveforms and program required by the instrument to synthesise them. - - The output of the process is a list of sequencers used for each port, configured with the information - required to play the sequence. - The following features are supported: - - - multiplexed readout of up to 6 qubits - - overlapping pulses - - hardware modulation, demodulation, and classification - - software modulation, with support for arbitrary pulses - - software demodulation - - binned acquisition - - real-time sweepers of - - - pulse frequency (requires hardware modulation) - - pulse relative phase (requires hardware modulation) - - pulse amplitude - - pulse start - - pulse duration - - port gain - - port offset - - - multiple readouts for the same qubit (sequence unrolling) - - pulses of up to 8192 pairs of i, q samples - - sequencer memory optimisation (waveforms cache) - - extended waveform memory with the use of multiple sequencers - - intrument parameters cache - - Args: - instrument_pulses (PulseSequence): A collection of Pulse objects to be played by the instrument. - navgs (int): The number of times the sequence of pulses should be executed averaging the results. - nshots (int): The number of times the sequence of pulses should be executed without averaging. - repetition_duration (int): The total duration of the pulse sequence execution plus the reset/relaxation time. - sweepers (list(Sweeper)): A list of Sweeper objects to be implemented. - """ - if sweepers is None: - sweepers = [] - sequencer: Sequencer - sweeper: Sweeper - # calculate the number of bins - num_bins = nshots - for sweeper in sweepers: - num_bins *= len(sweeper.values) - - # estimate the execution time - self._execution_time = ( - navgs * num_bins * ((repetition_duration + 1000 * len(sweepers)) * 1e-9) - ) - - port = "o1" - # initialise the list of free sequencer numbers to include the default for each port {'o1': 0} - self._free_sequencers_numbers = [self.DEFAULT_SEQUENCERS[port]] + [ - 1, - 2, - 3, - 4, - 5, - ] - - # split the collection of instruments pulses by ports - # ro_channel = None - # feed_channel = None - port_channel = [ - chan.name for chan in self.channel_map.values() if chan.port.name == port - ] - port_pulses: PulseSequence = instrument_pulses.get_channel_pulses(*port_channel) - - # initialise the list of sequencers required by the port - self._sequencers[port] = [] - - if not port_pulses.is_empty: - # split the collection of port pulses in non overlapping pulses - non_overlapping_pulses: PulseSequence - for non_overlapping_pulses in port_pulses.separate_overlapping_pulses(): - # each set of not overlapping pulses will be played by a separate sequencer - # check sequencer availability - if len(self._free_sequencers_numbers) == 0: - raise Exception( - f"The number of sequencers requried to play the sequence exceeds the number available {self._device_num_sequencers}." - ) - # get next sequencer - sequencer = self._get_next_sequencer( - port=port, - frequency=self.get_if(non_overlapping_pulses[0]), - qubits=qubits, - qubit=non_overlapping_pulses[0].qubit, - ) - # add the sequencer to the list of sequencers required by the port - self._sequencers[port].append(sequencer) - - # make a temporary copy of the pulses to be processed - pulses_to_be_processed = non_overlapping_pulses.shallow_copy() - while not pulses_to_be_processed.is_empty: - pulse: Pulse = pulses_to_be_processed[0] - # attempt to save the waveforms to the sequencer waveforms buffer - try: - sequencer.waveforms_buffer.add_waveforms( - pulse, self._ports[port].hardware_mod_en, sweepers - ) - sequencer.pulses.add(pulse) - pulses_to_be_processed.remove(pulse) - - # if there is not enough memory in the current sequencer, use another one - except WaveformsBuffer.NotEnoughMemory: - if ( - len(pulse.waveform_i) + len(pulse.waveform_q) - > WaveformsBuffer.SIZE - ): - raise NotImplementedError( - f"Pulses with waveforms longer than the memory of a sequencer ({WaveformsBuffer.SIZE // 2}) are not supported." - ) - if len(self._free_sequencers_numbers) == 0: - raise Exception( - f"The number of sequencers requried to play the sequence exceeds the number available {self._device_num_sequencers}." - ) - # get next sequencer - sequencer = self._get_next_sequencer( - port=port, - frequency=self.get_if(non_overlapping_pulses[0]), - qubits=qubits, - qubit=non_overlapping_pulses[0].qubit, - ) - # add the sequencer to the list of sequencers required by the port - self._sequencers[port].append(sequencer) - - # update the lists of used and unused sequencers that will be needed later on - self._used_sequencers_numbers = [] - for port in self._output_ports_keys: - for sequencer in self._sequencers[port]: - self._used_sequencers_numbers.append(sequencer.number) - self._unused_sequencers_numbers = [] - for n in range(self._device_num_sequencers): - if not n in self._used_sequencers_numbers: - self._unused_sequencers_numbers.append(n) - - # generate and store the Waveforms dictionary, the Acquisitions dictionary, the Weights and the Program - for port in self._output_ports_keys: - for sequencer in self._sequencers[port]: - pulses = sequencer.pulses - program = sequencer.program - - ## pre-process sweepers ## - # TODO: move qibolab sweepers preprocessing to qblox controller - - # attach a sweeper attribute to the pulse so that it is easily accesible by the code that generates - # the pseudo-assembly program - pulse = None - for pulse in pulses: - pulse.sweeper = None - - pulse_sweeper_parameters = [ - Parameter.frequency, - Parameter.amplitude, - Parameter.duration, - Parameter.relative_phase, - Parameter.start, - ] - - for sweeper in sweepers: - if sweeper.parameter in pulse_sweeper_parameters: - # check if this sequencer takes an active role in the sweep - if sweeper.pulses and set(sequencer.pulses) & set( - sweeper.pulses - ): - # plays an active role - reference_value = None - if sweeper.parameter == Parameter.frequency: - if sequencer.pulses: - reference_value = self.get_if( - sequencer.pulses[0] - ) # uses the frequency of the first pulse (assuming all same freq) - if sweeper.parameter == Parameter.amplitude: - for pulse in pulses: - if pulse in sweeper.pulses: - reference_value = ( - pulse.amplitude - ) # uses the amplitude of the first pulse - if ( - sweeper.parameter == Parameter.duration - and pulse in sweeper.pulses - ): - # for duration sweepers bake waveforms - sweeper.qs = QbloxSweeper( - program=program, - type=QbloxSweeperType.duration, - rel_values=pulse.idx_range, - ) - else: - # create QbloxSweepers and attach them to qibolab sweeper - if ( - sweeper.type == SweeperType.OFFSET - and reference_value - ): - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, - sweeper=sweeper, - add_to=reference_value, - ) - elif ( - sweeper.type == SweeperType.FACTOR - and reference_value - ): - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, - sweeper=sweeper, - multiply_to=reference_value, - ) - else: - sweeper.qs = QbloxSweeper.from_sweeper( - program=program, sweeper=sweeper - ) - - # finally attach QbloxSweepers to the pulses being swept - sweeper.qs.update_parameters = True - pulse.sweeper = sweeper.qs - else: - # does not play an active role - sweeper.qs = QbloxSweeper( - program=program, - type=QbloxSweeperType.number, - rel_values=range(len(sweeper.values)), - name=sweeper.parameter.name, - ) - - # else: # qubit_sweeper_parameters - # if sweeper.qubits and sequencer.qubit in [_.name for _ in sweeper.qubits]: - # # plays an active role - # if sweeper.parameter == Parameter.bias: - # reference_value = self._ports[port].offset - # # create QbloxSweepers and attach them to qibolab sweeper - # if sweeper.type == SweeperType.ABSOLUTE: - # sweeper.qs = QbloxSweeper.from_sweeper( - # program=program, sweeper=sweeper, add_to=-reference_value - # ) - # elif sweeper.type == SweeperType.OFFSET: - # sweeper.qs = QbloxSweeper.from_sweeper(program=program, sweeper=sweeper) - # elif sweeper.type == SweeperType.FACTOR: - # raise Exception("SweeperType.FACTOR for Parameter.bias not supported") - # sweeper.qs.update_parameters = True - # else: - # # does not play an active role - # sweeper.qs = QbloxSweeper( - # program=program, type=QbloxSweeperType.number, rel_values=range(len(sweeper.values)), - # name = sweeper.parameter.name - # ) - else: - # does not play an active role - sweeper.qs = QbloxSweeper( - program=program, - type=QbloxSweeperType.number, - rel_values=range(len(sweeper.values)), - name=sweeper.parameter.name, - ) - - # # FIXME: for qubit sweepers (Parameter.bias, Parameter.attenuation, Parameter.gain), the qubit - # # information alone is not enough to determine what instrument parameter is to be swept. - # # For example port gain, both the drive and readout ports have gain parameters. - # # Until this is resolved, and since bias is only implemented with QCMs offset, this instrument will - # # never take an active role in those sweeps. - - # Waveforms - for index, waveform in enumerate( - sequencer.waveforms_buffer.unique_waveforms - ): - sequencer.waveforms[waveform.serial] = { - "data": waveform.data.tolist(), - "index": index, - } - - # Acquisitions - pulse = None - for acquisition_index, pulse in enumerate(sequencer.pulses.ro_pulses): - sequencer.acquisitions[pulse.serial] = { - "num_bins": num_bins, - "index": acquisition_index, - } - - # Add scope_acquisition to default sequencer - if ( - sequencer.number == self.DEFAULT_SEQUENCERS[port] - and pulse is not None - ): - sequencer.acquisitions["scope_acquisition"] = { - "num_bins": 1, - "index": acquisition_index + 1, - } - - # Program - minimum_delay_between_instructions = 4 - - # Active reset is not fully tested yet - active_reset = False - active_reset_address = 1 - active_reset_pulse_idx_I = 1 - active_reset_pulse_idx_Q = 1 - - sequence_total_duration = ( - pulses.finish - ) # the minimum delay between instructions is 4ns - time_between_repetitions = repetition_duration - sequence_total_duration - assert time_between_repetitions > minimum_delay_between_instructions - # TODO: currently relaxation_time needs to be greater than acquisition_hold_off - # so that the time_between_repetitions is equal to the sequence_total_duration + relaxation_time - # to be compatible with th erest of the platforms, change it so that time_between_repetitions - # is equal to pulsesequence duration + acquisition_hold_off if relaxation_time < acquisition_hold_off - - # create registers for key variables - # nshots is used in the loop that iterates over the number of shots - nshots_register = Register(program, "nshots") - # during a sweep, each shot is saved in the bin bin_n - bin_n = Register(program, "bin_n") - # navgs is used in the loop of hardware averages - navgs_register = Register(program, "navgs") - - header_block = Block("setup") - if active_reset: - header_block.append( - f"set_latch_en {active_reset_address}, 4", - f"monitor triggers on address {active_reset_address}", - ) - - body_block = Block() - - body_block.append(f"wait_sync {minimum_delay_between_instructions}") - if ( - self._ports["i1"].hardware_demod_en - or self._ports["o1"].hardware_mod_en - ): - body_block.append("reset_ph") - body_block.append_spacer() - - pulses_block = Block("play_and_acquire") - # Add an initial wait instruction for the first pulse of the sequence - initial_wait_block = wait_block( - wait_time=pulses[0].start, - register=Register(program), - force_multiples_of_four=True, - ) - pulses_block += initial_wait_block - - for n in range(pulses.count): - if ( - pulses[n].sweeper - and pulses[n].sweeper.type == QbloxSweeperType.start - ): - pulses_block.append(f"wait {pulses[n].sweeper.register}") - - if self._ports["o1"].hardware_mod_en: - # # Set frequency - # _if = self.get_if(pulses[n]) - # pulses_block.append(f"set_freq {convert_frequency(_if)}", f"set intermediate frequency to {_if} Hz") - - # Set phase - if ( - pulses[n].sweeper - and pulses[n].sweeper.type - == QbloxSweeperType.relative_phase - ): - pulses_block.append(f"set_ph {pulses[n].sweeper.register}") - else: - pulses_block.append( - f"set_ph {convert_phase(pulses[n].relative_phase)}", - comment=f"set relative phase {pulses[n].relative_phase} rads", - ) - - if pulses[n].type == PulseType.READOUT: - delay_after_play = self._ports["i1"].acquisition_hold_off - - if len(pulses) > n + 1: - # If there are more pulses to be played, the delay is the time between the pulse end and the next pulse start - delay_after_acquire = ( - pulses[n + 1].start - - pulses[n].start - - self._ports["i1"].acquisition_hold_off - ) - else: - delay_after_acquire = ( - sequence_total_duration - pulses[n].start - ) - time_between_repetitions = ( - repetition_duration - - sequence_total_duration - - self._ports["i1"].acquisition_hold_off - ) - assert time_between_repetitions > 0 - - if delay_after_acquire < minimum_delay_between_instructions: - raise Exception( - f"The minimum delay after starting acquisition is {minimum_delay_between_instructions}ns." - ) - - if ( - pulses[n].sweeper - and pulses[n].sweeper.type == QbloxSweeperType.duration - ): - RI = pulses[n].sweeper.register - if pulses[n].type == PulseType.FLUX: - RQ = pulses[n].sweeper.register - else: - RQ = pulses[n].sweeper.aux_register - - pulses_block.append( - f"play {RI},{RQ},{delay_after_play}", # FIXME delay_after_play won't work as the duration increases - comment=f"play pulse {pulses[n]} sweeping its duration", - ) - else: - # Prepare play instruction: play wave_i_index, wave_q_index, delay_next_instruction - pulses_block.append( - f"play {sequencer.waveforms_buffer.unique_waveforms.index(pulses[n].waveform_i)},{sequencer.waveforms_buffer.unique_waveforms.index(pulses[n].waveform_q)},{delay_after_play}", - comment=f"play waveforms {pulses[n]}", - ) - - # Prepare acquire instruction: acquire acquisition_index, bin_index, delay_next_instruction - if active_reset: - pulses_block.append( - f"acquire {pulses.ro_pulses.index(pulses[n])},{bin_n},4" - ) - pulses_block.append( - f"latch_rst {delay_after_acquire + 300 - 4}" - ) - else: - pulses_block.append( - f"acquire {pulses.ro_pulses.index(pulses[n])},{bin_n},{delay_after_acquire}" - ) - - else: - # Calculate the delay_after_play that is to be used as an argument to the play instruction - if len(pulses) > n + 1: - # If there are more pulses to be played, the delay is the time between the pulse end and the next pulse start - delay_after_play = pulses[n + 1].start - pulses[n].start - else: - delay_after_play = sequence_total_duration - pulses[n].start - - if delay_after_play < minimum_delay_between_instructions: - raise Exception( - f"The minimum delay between the start of two pulses in the same channel is {minimum_delay_between_instructions}ns." - ) - - if ( - pulses[n].sweeper - and pulses[n].sweeper.type == QbloxSweeperType.duration - ): - RI = pulses[n].sweeper.register - if pulses[n].type == PulseType.FLUX: - RQ = pulses[n].sweeper.register - else: - RQ = pulses[n].sweeper.aux_register - - pulses_block.append( - f"play {RI},{RQ},{delay_after_play}", # FIXME delay_after_play won't work as the duration increases - comment=f"play pulse {pulses[n]} sweeping its duration", - ) - else: - # Prepare play instruction: play wave_i_index, wave_q_index, delay_next_instruction - pulses_block.append( - f"play {sequencer.waveforms_buffer.unique_waveforms.index(pulses[n].waveform_i)},{sequencer.waveforms_buffer.unique_waveforms.index(pulses[n].waveform_q)},{delay_after_play}", - comment=f"play waveforms {pulses[n]}", - ) - - body_block += pulses_block - body_block.append_spacer() - - if active_reset: - final_reset_block = Block() - final_reset_block.append( - f"set_cond 1, {active_reset_address}, 0, 4", - comment="active reset", - ) - final_reset_block.append( - f"play {active_reset_pulse_idx_I}, {active_reset_pulse_idx_Q}, 4", - level=1, - ) - final_reset_block.append( - f"set_cond 0, {active_reset_address}, 0, 4" - ) - else: - final_reset_block = wait_block( - wait_time=time_between_repetitions, - register=Register(program), - force_multiples_of_four=False, - ) - final_reset_block.append_spacer() - final_reset_block.append( - f"add {bin_n}, 1, {bin_n}", "increase bin counter" - ) - - body_block += final_reset_block - - footer_block = Block("cleanup") - footer_block.append(f"stop") - - # wrap pulses block in sweepers loop blocks - for sweeper in sweepers: - body_block = sweeper.qs.block(inner_block=body_block) - - nshots_block: Block = loop_block( - start=0, - stop=nshots, - step=1, - register=nshots_register, - block=body_block, - ) - nshots_block.prepend(f"move 0, {bin_n}", "reset bin counter") - nshots_block.append_spacer() - - navgs_block = loop_block( - start=0, - stop=navgs, - step=1, - register=navgs_register, - block=nshots_block, - ) - program.add_blocks(header_block, navgs_block, footer_block) - - sequencer.program = repr(program) - - def upload(self): - """Uploads waveforms and programs of all sequencers and arms them in - preparation for execution. - - This method should be called after `process_pulse_sequence()`. - It configures certain parameters of the instrument based on the - needs of resources determined while processing the pulse - sequence. - """ - # Setup - for sequencer_number in self._used_sequencers_numbers: - target = self.device.sequencers[sequencer_number] - target.set("sync_en", True) - target.set("marker_ovr_en", True) # Default after reboot = False - target.set("marker_ovr_value", 15) # Default after reboot = 0 - for sequencer_number in self._unused_sequencers_numbers: - target = self.device.sequencers[sequencer_number] - target.set("sync_en", False) - target.set("marker_ovr_en", False) # Default after reboot = False - target.set("marker_ovr_value", 0) # Default after reboot = 0 - if sequencer_number >= 1: # Never disconnect default sequencers - target.set("connect_out0", "off") - target.set("connect_acq", "in0") - - # Upload waveforms and program - qblox_dict = {} - sequencer: Sequencer - for port in self._output_ports_keys: - for sequencer in self._sequencers[port]: - # Add sequence program and waveforms to single dictionary - qblox_dict[sequencer] = { - "waveforms": sequencer.waveforms, - "weights": sequencer.weights, - "acquisitions": sequencer.acquisitions, - "program": sequencer.program, - } - - # Upload dictionary to the device sequencers - self.device.sequencers[sequencer.number].sequence(qblox_dict[sequencer]) - # DEBUG: QRM RF Save sequence to file - if self._debug_folder != "": - filename = ( - self._debug_folder - + f"Z_{self.name}_sequencer{sequencer.number}_sequence.json" - ) - with open(filename, "w", encoding="utf-8") as file: - json.dump(qblox_dict[sequencer], file, indent=4) - file.write(sequencer.program) - - # Clear acquisition memory and arm sequencers - for sequencer_number in self._used_sequencers_numbers: - self.device.sequencers[sequencer_number].delete_acquisition_data(all=True) - self.device.arm_sequencer(sequencer_number) - - # DEBUG: QRM RF Print Readable Snapshot - # print(self.name) - # self.device.print_readable_snapshot(update=True) - - # DEBUG: QRM RF Save Readable Snapshot - from qibolab.instruments.qblox.debug import print_readable_snapshot - - if self._debug_folder != "": - filename = self._debug_folder + f"Z_{self.name}_snapshot.json" - with open(filename, "w", encoding="utf-8") as file: - print_readable_snapshot(self.device, file, update=True) - - def play_sequence(self): - """Plays the sequence of pulses. - - Starts the sequencers needed to play the sequence of pulses. - """ - - # Start used sequencers - for sequencer_number in self._used_sequencers_numbers: - self.device.start_sequencer(sequencer_number) - - def acquire(self): - """Retrieves the readout results. - - The results returned vary depending on whether demodulation is performed in software or hardware. - See :class:`qibolab.instruments.qblox.acquisition.AveragedAcquisition` and - :class:`qibolab.instruments.qblox.acquisition.DemodulatedAcquisition` for - more details - """ - # wait until all sequencers stop - time_out = int(self._execution_time) + 60 - t = time.time() - for sequencer_number in self._used_sequencers_numbers: - while True: - status = self.device.get_sequencer_status(sequencer_number) - if status.state is SequencerStates.STOPPED: - # TODO: check flags for errors - break - elif time.time() - t > time_out: - log.info( - f"Timeout - {self.device.sequencers[sequencer_number].name} status: {status}" - ) - self.device.stop_sequencer(sequencer_number) - break - time.sleep(0.5) - - # Qblox qrm modules only have one memory for scope acquisition. - # Only one sequencer can save data to that memory. - # Several acquisitions at different points in the circuit will result in the undesired averaging - # of the results. - # Scope Acquisition should only be used with one acquisition per module. - # Several readout pulses are supported for as long as they take place symultaneously. - # Scope Acquisition data should be ignored with more than one acquisition or with Hardware Demodulation. - - # Software Demodulation requires the data from Scope Acquisition, therefore Software Demodulation only works - # with one acquisition per module. - - # The data is retrieved by storing it first in one of the acquisitions of one of the sequencers. - # Any could be used, but we always use 'scope_acquisition' acquisition of the default sequencer to store it. - - acquisitions = {} - duration = self._ports["i1"].acquisition_duration - hardware_demod_enabled = self._ports["i1"].hardware_demod_en - for port in self._output_ports_keys: - for sequencer in self._sequencers[port]: - # Store scope acquisition data on 'scope_acquisition' acquisition of the default sequencer - # TODO: Maybe this store_scope can be done only if needed to optimize the process! - if sequencer.number == self.DEFAULT_SEQUENCERS[port]: - self.device.store_scope_acquisition( - sequencer.number, "scope_acquisition" - ) - scope = self.device.get_acquisitions(sequencer.number)[ - "scope_acquisition" - ] - if not hardware_demod_enabled: # Software Demodulation - if len(sequencer.pulses.ro_pulses) == 1: - pulse = sequencer.pulses.ro_pulses[0] - frequency = self.get_if(pulse) - acquisitions[pulse.qubit] = acquisitions[pulse.serial] = ( - AveragedAcquisition(scope, duration, frequency) - ) - else: - raise RuntimeError( - "Software Demodulation only supports one acquisition per channel. " - "Multiple readout pulses are supported as long as they are symultaneous (requiring one acquisition)." - ) - else: # Hardware Demodulation - results = self.device.get_acquisitions(sequencer.number) - for pulse in sequencer.pulses.ro_pulses: - bins = results[pulse.serial]["acquisition"]["bins"] - acquisitions[pulse.qubit] = acquisitions[pulse.serial] = ( - DemodulatedAcquisition(scope, bins, duration) - ) - - # TODO: to be updated once the functionality of ExecutionResults is extended - return {key: acquisition for key, acquisition in acquisitions.items()} - - def disconnect(self): - """Stops all sequencers, disconnect all the outputs from the AWG paths - of the sequencers and disconnect all the inputs from the acquisition - paths of the sequencers.""" - - if not self.is_connected: - return - - for sequencer_number in self._used_sequencers_numbers: - status = self.device.get_sequencer_status(sequencer_number) - if status.state is not SequencerStates.STOPPED: - log.warning( - f"Device {self.device.sequencers[sequencer_number].name} did not stop normally\nstatus: {status}" - ) - self.device.stop_sequencer() - self.device.disconnect_outputs() - self.device.disconnect_inputs() - - self.is_connected = False - self.device = None diff --git a/src/qibolab/instruments/qblox/controller.py b/src/qibolab/instruments/qblox/controller.py deleted file mode 100644 index f125677583..0000000000 --- a/src/qibolab/instruments/qblox/controller.py +++ /dev/null @@ -1,541 +0,0 @@ -import signal -from dataclasses import replace - -import numpy as np -from qblox_instruments.qcodes_drivers.cluster import Cluster as QbloxCluster -from qibo.config import log, raise_error - -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters -from qibolab.instruments.abstract import Controller -from qibolab.instruments.qblox.cluster_qcm_bb import QcmBb -from qibolab.instruments.qblox.cluster_qcm_rf import QcmRf -from qibolab.instruments.qblox.cluster_qrm_rf import QrmRf -from qibolab.instruments.qblox.sequencer import SAMPLING_RATE -from qibolab.pulses import PulseSequence, PulseType -from qibolab.result import SampleResults -from qibolab.sweeper import Parameter, Sweeper, SweeperType -from qibolab.unrolling import Bounds - -MAX_NUM_BINS = 98304 -"""Maximum number of bins that should be used per sequencer in a readout -module. - -One sequencer can have up to 2 ** 17 bins, however the 6 sequencers in -module allocate bins from a shared memory, and this memory is smaller -than 6 * 2 ** 17. Hence, if all sequencers are used at once, each cannot -support 2 ** 17 bins. In fact, the total bin memory for the module is 3 -* (2 ** 17 + 2 ** 16). This means up to three sequencers used at once -can support 2 ** 17 bins each, but four or more sequencers cannot. So -the limitation on the number of bins technically depends on the number -of sequencers used, but to keep things simple we limit ourselves to max -number of bins that works regardless of situation. -""" - - -class QbloxController(Controller): - """A controller to manage qblox devices. - - Attributes: - is_connected (bool): . - modules (dict): A dictionay with the qblox modules connected to the experiment. - """ - - def __init__( - self, name, address: str, modules, internal_reference_clock: bool = True - ): - """Initialises the controller.""" - super().__init__(name=name, address=address) - self.is_connected = False - self.cluster: QbloxCluster = None - self.modules: dict = modules - self._reference_clock = "internal" if internal_reference_clock else "external" - self.bounds = Bounds( - waveforms=int( - 4e4 - ), # Translate SEQUENCER_MEMORY = 2**17 into pulse duration - readout=int(1e6), - instructions=int(1e6), - ) - signal.signal(signal.SIGTERM, self._termination_handler) - - @property - def sampling_rate(self): - return SAMPLING_RATE - - def connect(self): - """Connects to the modules.""" - - if self.is_connected: - return - try: - # Connect cluster - QbloxCluster.close_all() - self.cluster = QbloxCluster(self.name, self.address) - self.cluster.reset() - self.cluster.set("reference_source", self._reference_clock) - # Connect modules - for module in self.modules.values(): - module.connect(self.cluster) - self.is_connected = True - log.info("QbloxController: all modules connected.") - - except Exception as exception: - raise ConnectionError(f"Unable to connect:\n{str(exception)}\n") - # TODO: check for exception 'The module qrm_rf0 does not have parameters in0_att' and reboot the cluster - - def disconnect(self): - """Disconnects all modules.""" - if self.is_connected: - for module in self.modules.values(): - module.disconnect() - self.cluster.close() - self.is_connected = False - - def _termination_handler(self, signum, frame): - """Calls all modules to stop if the program receives a termination - signal.""" - - log.warning("Termination signal received, disconnecting modules.") - if self.is_connected: - for name in self.modules: - self.modules[name].disconnect() - log.warning("QbloxController: all modules are disconnected.") - exit(0) - - def _set_module_channel_map(self, module: QrmRf, qubits: dict): - """Retrieve all the channels connected to a specific Qblox module. - - This method updates the `channel_port_map` attribute of the - specified Qblox module based on the information contained in the - provided qubits dictionary (dict of `qubit` objects). - - Return the list of channels connected to module_name - """ - for qubit in qubits.values(): - for channel in qubit.channels: - if channel.port and channel.port.module.name == module.name: - module.channel_map[channel.name] = channel - return list(module.channel_map) - - def _execute_pulse_sequence( - self, - qubits: dict, - sequence: PulseSequence, - options: ExecutionParameters, - sweepers: list() = [], # list(Sweeper) = [] - **kwargs, - # nshots=None, - # navgs=None, - # relaxation_time=None, - ): - """Executes a sequence of pulses or a sweep. - - Args: - sequence (:class:`qibolab.pulses.PulseSequence`): The sequence of pulses to execute. - options (:class:`qibolab.platforms.platform.ExecutionParameters`): Object holding the execution options. - sweepers (list(Sweeper)): A list of Sweeper objects defining parameter sweeps. - """ - if not self.is_connected: - raise_error( - RuntimeError, "Execution failed because modules are not connected." - ) - - if options.averaging_mode is AveragingMode.SINGLESHOT: - nshots = options.nshots - navgs = 1 - else: - navgs = options.nshots - nshots = 1 - - relaxation_time = options.relaxation_time - repetition_duration = sequence.finish + relaxation_time - - # shots results are stored in separate bins - # calculate number of shots - num_bins = nshots - for sweeper in sweepers: - num_bins *= len(sweeper.values) - - # DEBUG: Plot Pulse Sequence - # sequence.plot('plot.png') - # DEBUG: sync_en - # from qblox_instruments.qcodes_drivers.cluster import Cluster - # cluster:Cluster = self.modules['cluster'].device - # for module in cluster.modules: - # if module.get("present"): - # for sequencer in module.sequencers: - # if sequencer.get('sync_en'): - # print(f"type: {module.module_type}, sequencer: {sequencer.name}, sync_en: True") - - # Process Pulse Sequence. Assign pulses to modules and generate waveforms & program - module_pulses = {} - data = {} - for name, module in self.modules.items(): - # from the pulse sequence, select those pulses to be synthesised by the module - module_channels = self._set_module_channel_map(module, qubits) - module_pulses[name] = sequence.get_channel_pulses(*module_channels) - - # ask each module to generate waveforms & program and upload them to the device - module.process_pulse_sequence( - qubits, - module_pulses[name], - navgs, - nshots, - repetition_duration, - sweepers, - ) - - # log.info(f"{self.modules[name]}: Uploading pulse sequence") - module.upload() - - # play the sequence or sweep - for module in self.modules.values(): - if isinstance(module, (QrmRf, QcmRf, QcmBb)): - module.play_sequence() - - # retrieve the results - acquisition_results = {} - for name, module in self.modules.items(): - if isinstance(module, QrmRf) and not module_pulses[name].ro_pulses.is_empty: - results = module.acquire() - for key, value in results.items(): - acquisition_results[key] = value - # TODO: move to QRM_RF.acquire() - shape = tuple(len(sweeper.values) for sweeper in reversed(sweepers)) - shots_shape = (nshots,) + shape - for ro_pulse in sequence.ro_pulses: - if options.acquisition_type is AcquisitionType.DISCRIMINATION: - _res = acquisition_results[ro_pulse.serial].classified - _res = np.reshape(_res, shots_shape) - if options.averaging_mode is not AveragingMode.SINGLESHOT: - _res = np.mean(_res, axis=0) - elif options.acquisition_type is AcquisitionType.RAW: - i_raw = acquisition_results[ro_pulse.serial].raw_i - q_raw = acquisition_results[ro_pulse.serial].raw_q - _res = i_raw + 1j * q_raw - elif options.acquisition_type is AcquisitionType.INTEGRATION: - ires = acquisition_results[ro_pulse.serial].shots_i - qres = acquisition_results[ro_pulse.serial].shots_q - _res = ires + 1j * qres - if options.averaging_mode is AveragingMode.SINGLESHOT: - _res = np.reshape(_res, shots_shape) - else: - _res = np.reshape(_res, shape) - - acquisition = options.results_type(np.squeeze(_res)) - data[ro_pulse.serial] = data[ro_pulse.qubit] = acquisition - - return data - - def play(self, qubits, couplers, sequence, options): - return self._execute_pulse_sequence(qubits, sequence, options) - - def sweep( - self, - qubits: dict, - couplers: dict, - sequence: PulseSequence, - options: ExecutionParameters, - *sweepers, - ): - """Executes a sequence of pulses while sweeping one or more parameters. - - The parameters to be swept are defined in :class:`qibolab.sweeper.Sweeper` object. - Args: - sequence (:class:`qibolab.pulses.PulseSequence`): The sequence of pulses to execute. - options (:class:`qibolab.platforms.platform.ExecutionParameters`): Object holding the execution options. - sweepers (list(Sweeper)): A list of Sweeper objects defining parameter sweeps. - """ - id_results = {} - map_id_serial = {} - - # during the sweep, pulse parameters need to be changed - # to avoid affecting the user, make a copy of the pulse sequence - # and the sweepers, as they contain references to pulses - sequence_copy = sequence.copy() - sweepers_copy = [] - for sweeper in sweepers: - if sweeper.pulses: - ps = [ - sequence_copy[sequence_copy.index(pulse)] - for pulse in sweeper.pulses - if pulse in sequence_copy - ] - else: - ps = None - sweepers_copy.append( - Sweeper( - parameter=sweeper.parameter, - values=sweeper.values, - pulses=ps, - qubits=sweeper.qubits, - type=sweeper.type, - ) - ) - - # reverse sweepers exept for res punchout att - contains_attenuation_frequency = any( - sweepers_copy[i].parameter == Parameter.attenuation - and sweepers_copy[i + 1].parameter == Parameter.frequency - for i in range(len(sweepers_copy) - 1) - ) - - if not contains_attenuation_frequency: - sweepers_copy.reverse() - - # create a map between the pulse id, which never changes, and the original serial - for pulse in sequence_copy.ro_pulses: - map_id_serial[pulse.id] = pulse.serial - id_results[pulse.id] = None - id_results[pulse.qubit] = None - - # execute the each sweeper recursively - self._sweep_recursion( - qubits, - sequence_copy, - options, - *tuple(sweepers_copy), - results=id_results, - ) - - # return the results using the original serials - serial_results = {} - for pulse in sequence_copy.ro_pulses: - serial_results[map_id_serial[pulse.id]] = id_results[pulse.id] - serial_results[pulse.qubit] = id_results[pulse.id] - return serial_results - - def _sweep_recursion( - self, - qubits, - sequence, - options: ExecutionParameters, - *sweepers, - results, - ): - """Executes a sweep recursively. - - Args: - sequence (:class:`qibolab.pulses.PulseSequence`): The sequence of pulses to execute. - sweepers (list(Sweeper)): A list of Sweeper objects defining parameter sweeps. - results (:class:`qibolab.results.ExecutionResults`): A results object to update with the reults of the execution. - nshots (int): The number of times the sequence of pulses should be executed. - average (bool): A flag to indicate if the results of the shots should be averaged. - relaxation_time (int): The the time to wait between repetitions to allow the qubit relax to ground state. - """ - - for_loop_sweepers = [Parameter.attenuation, Parameter.lo_frequency] - sweeper: Sweeper = sweepers[0] - - # until sweeper contains the information to determine whether the sweep should be relative or - # absolute: - - # elif sweeper.parameter is Parameter.relative_phase: - # initial = {} - # for pulse in sweeper.pulses: - # initial[pulse.id] = pulse.relative_phase - - # elif sweeper.parameter is Parameter.frequency: - # initial = {} - # for pulse in sweeper.pulses: - # initial[pulse.id] = pulse.frequency - - if sweeper.parameter in for_loop_sweepers: - # perform sweep recursively - for value in sweeper.values: - if sweeper.parameter is Parameter.attenuation: - initial = {} - for qubit in sweeper.qubits: - initial[qubit.name] = qubits[qubit.name].readout.attenuation - if sweeper.type == SweeperType.ABSOLUTE: - qubit.readout.attenuation = value - elif sweeper.type == SweeperType.OFFSET: - qubit.readout.attenuation = initial[qubit.name] + value - elif sweeper.type == SweeperType.FACTOR: - qubit.readout.attenuation = initial[qubit.name] * value - - elif sweeper.parameter is Parameter.lo_frequency: - initial = {} - for pulse in sweeper.pulses: - if pulse.type == PulseType.READOUT: - initial[pulse.id] = qubits[pulse.qubit].readout.lo_frequency - if sweeper.type == SweeperType.ABSOLUTE: - qubits[pulse.qubit].readout.lo_frequency = value - elif sweeper.type == SweeperType.OFFSET: - qubits[pulse.qubit].readout.lo_frequency = ( - initial[pulse.id] + value - ) - elif sweeper.type == SweeperType.FACTOR: - qubits[pulse.qubit].readout.lo_frequency = ( - initial[pulse.id] * value - ) - - elif pulse.type == PulseType.DRIVE: - initial[pulse.id] = qubits[pulse.qubit].drive.lo_frequency - if sweeper.type == SweeperType.ABSOLUTE: - qubits[pulse.qubit].drive.lo_frequency = value - elif sweeper.type == SweeperType.OFFSET: - qubits[pulse.qubit].drive.lo_frequency = ( - initial[pulse.id] + value - ) - elif sweeper.type == SweeperType.FACTOR: - qubits[pulse.qubit].drive.lo_frequency = ( - initial[pulse.id] * value - ) - - if len(sweepers) > 1: - self._sweep_recursion( - qubits, - sequence, - options, - *sweepers[1:], - results=results, - ) - else: - result = self._execute_pulse_sequence( - qubits=qubits, sequence=sequence, options=options - ) - for pulse in sequence.ro_pulses: - if results[pulse.id]: - results[pulse.id] += result[pulse.serial] - else: - results[pulse.id] = result[pulse.serial] - results[pulse.qubit] = results[pulse.id] - else: - # rt sweeps - # relative phase sweeps that cross 0 need to be split in two separate sweeps - split_relative_phase = False - rt_sweepers = [ - Parameter.frequency, - Parameter.gain, - Parameter.bias, - Parameter.amplitude, - Parameter.start, - Parameter.duration, - Parameter.relative_phase, - ] - - if sweeper.parameter == Parameter.relative_phase: - if sweeper.type != SweeperType.ABSOLUTE: - raise_error( - ValueError, - "relative_phase sweeps other than ABSOLUTE are not supported by qblox yet", - ) - from qibolab.instruments.qblox.q1asm import convert_phase - - c_values = np.array([convert_phase(v) for v in sweeper.values]) - if any(np.diff(c_values) < 0): - split_relative_phase = True - _from = 0 - for idx in np.append( - np.where(np.diff(c_values) < 0), len(c_values) - 1 - ): - _to = idx + 1 - _values = sweeper.values[_from:_to] - split_sweeper = Sweeper( - parameter=sweeper.parameter, - values=_values, - pulses=sweeper.pulses, - qubits=sweeper.qubits, - ) - self._sweep_recursion( - qubits, - sequence, - options, - *((split_sweeper,) + sweepers[1:]), - results=results, - ) - _from = _to - - if not split_relative_phase: - if any(s.parameter not in rt_sweepers for s in sweepers): - # TODO: reorder the sequence of the sweepers and the results - raise Exception( - "cannot execute a for-loop sweeper nested inside of a rt sweeper" - ) - nshots = ( - options.nshots - if options.averaging_mode == AveragingMode.SINGLESHOT - else 1 - ) - navgs = ( - options.nshots - if options.averaging_mode != AveragingMode.SINGLESHOT - else 1 - ) - num_bins = nshots - for sweeper in sweepers: - num_bins *= len(sweeper.values) - - # split the sweep if the number of bins is larget than the memory of the sequencer (2**17) - if num_bins < MAX_NUM_BINS: - # for sweeper in sweepers: - # if sweeper.parameter is Parameter.amplitude: - # # qblox cannot sweep amplitude in real time, but sweeping gain is quivalent - # for pulse in sweeper.pulses: - # pulse.amplitude = 1 - - # elif sweeper.parameter is Parameter.gain: - # for pulse in sweeper.pulses: - # # qblox has an external and an internal gains - # # when sweeping the internal, set the external to 1 - # # TODO check if it needs to be restored after execution - # if pulse.type == PulseType.READOUT: - # qubits[pulse.qubit].readout.gain = 1 - # elif pulse.type == PulseType.DRIVE: - # qubits[pulse.qubit].drive.gain = 1 - - result = self._execute_pulse_sequence( - qubits, sequence, options, sweepers - ) - self._add_to_results(sequence, results, result) - else: - sweepers_repetitions = 1 - for sweeper in sweepers: - sweepers_repetitions *= len(sweeper.values) - if sweepers_repetitions > MAX_NUM_BINS: - raise ValueError( - f"Requested sweep has {sweepers_repetitions} total number of sweep points. " - f"Maximum supported is {MAX_NUM_BINS}" - ) - - max_rt_nshots = MAX_NUM_BINS // sweepers_repetitions - num_full_sft_iterations = nshots // max_rt_nshots - result_chunks = [] - for sft_iteration in range(num_full_sft_iterations + 1): - _nshots = min( - max_rt_nshots, nshots - sft_iteration * max_rt_nshots - ) - - res = self._execute_pulse_sequence( - qubits, - sequence, - replace(options, nshots=_nshots), - sweepers, - ) - result_chunks.append(res) - result = self._combine_result_chunks(result_chunks) - self._add_to_results(sequence, results, result) - - @staticmethod - def _combine_result_chunks(chunks): - some_chunk = next(iter(chunks)) - some_result = next(iter(some_chunk.values())) - attribute = "samples" if isinstance(some_result, SampleResults) else "voltage" - return { - key: some_result.__class__( - np.concatenate( - [getattr(chunk[key], attribute) for chunk in chunks], axis=0 - ) - ) - for key in some_chunk.keys() - } - - @staticmethod - def _add_to_results(sequence, results, results_to_add): - for pulse in sequence.ro_pulses: - if results[pulse.id]: - results[pulse.id] += results_to_add[pulse.serial] - else: - results[pulse.id] = results_to_add[pulse.serial] - results[pulse.qubit] = results[pulse.id] diff --git a/src/qibolab/instruments/qblox/debug.py b/src/qibolab/instruments/qblox/debug.py deleted file mode 100644 index e2d582ca8c..0000000000 --- a/src/qibolab/instruments/qblox/debug.py +++ /dev/null @@ -1,57 +0,0 @@ -import numpy as np - - -def print_readable_snapshot( - device, file, update: bool = False, max_chars: int = 80 -) -> None: - """Prints a readable version of the snapshot. The readable snapshot - includes the name, value and unit of each parameter. A convenience function - to quickly get an overview of the status of an instrument. - - Args: - update: If ``True``, update the state by querying the - instrument. If ``False``, just use the latest values in memory. - This argument gets passed to the snapshot function. - max_chars: the maximum number of characters per line. The - readable snapshot will be cropped if this value is exceeded. - Defaults to 80 to be consistent with default terminal width. - """ - floating_types = (float, np.integer, np.floating) - snapshot = device.snapshot(update=update) - - par_lengths = [len(p) for p in snapshot["parameters"]] - - # Min of 50 is to prevent a super long parameter name to break this - # function - par_field_len = min(max(par_lengths) + 1, 50) - - file.write(device.name + ":" + "\n") - file.write("{0:<{1}}".format("\tparameter ", par_field_len) + "value" + "\n") - file.write("-" * max_chars + "\n") - for par in sorted(snapshot["parameters"]): - name = snapshot["parameters"][par]["name"] - msg = "{0:<{1}}:".format(name, par_field_len) - - # in case of e.g. ArrayParameters, that usually have - # snapshot_value == False, the parameter may not have - # a value in the snapshot - val = snapshot["parameters"][par].get("value", "Not available") - - unit = snapshot["parameters"][par].get("unit", None) - if unit is None: - # this may be a multi parameter - unit = snapshot["parameters"][par].get("units", None) - if isinstance(val, floating_types): - msg += f"\t{val:.5g} " - # numpy float and int types format like builtins - else: - msg += f"\t{val} " - if unit != "": # corresponds to no unit - msg += f"({unit})" - # Truncate the message if it is longer than max length - if len(msg) > max_chars and not max_chars == -1: - msg = msg[0 : max_chars - 3] + "..." - file.write(msg + "\n") - - for submodule in device.submodules.values(): - print_readable_snapshot(submodule, file, update=update, max_chars=max_chars) diff --git a/src/qibolab/instruments/qblox/module.py b/src/qibolab/instruments/qblox/module.py deleted file mode 100644 index 10b2c8b4fe..0000000000 --- a/src/qibolab/instruments/qblox/module.py +++ /dev/null @@ -1,61 +0,0 @@ -"""Qblox Cluster QCM driver.""" - -from qibolab.instruments.abstract import Instrument -from qibolab.instruments.qblox.port import QbloxInputPort, QbloxOutputPort - - -class ClusterModule(Instrument): - """This class defines common features shared by all Qblox modules (QCM-BB, - QCM-RF, QRM-RF). - - It serves as a foundational class, unifying the behavior of the - three distinct modules. All module-specific classes are intended to - inherit from this base class. - """ - - DEFAULT_SEQUENCERS_VALUES = { - "cont_mode_en_awg_path0": False, - "cont_mode_en_awg_path1": False, - "cont_mode_waveform_idx_awg_path0": 0, - "cont_mode_waveform_idx_awg_path1": 0, - "marker_ovr_en": True, # Default after reboot = False - "marker_ovr_value": 15, # Default after reboot = 0 - "mixer_corr_gain_ratio": 1, - "mixer_corr_phase_offset_degree": 0, - "offset_awg_path0": 0, - "offset_awg_path1": 0, - "sync_en": False, # Default after reboot = False - "upsample_rate_awg_path0": 0, - "upsample_rate_awg_path1": 0, - } - - def __init__(self, name: str, address: str): - super().__init__(name, address) - self._ports: dict = {} - - def ports(self, name: str, out: bool = True): - """Adds an entry to the dictionary `self._ports` with key 'name' and - value a `QbloxOutputPort` (or `QbloxInputPort` if `out=False`) object. - To the object is assigned the provided name, and the `port_number` is - automatically determined based on the number of ports of the same type - inside `self._ports`. - - Returns this port object. - - Example: - >>> qrm_module = QrmRf("qrm_rf", f"{IP_ADDRESS}:{SLOT_IDX}") - >>> output_port = qrm_module.add_port("o1") - >>> input_port = qrm_module.add_port("i1", out=False) - >>> qrm_module.ports - { - 'o1': QbloxOutputPort(module=qrm_module, port_number=0, port_name='o1'), - 'i1': QbloxInputPort(module=qrm_module, port_number=0, port_name='i1') - } - """ - - def count(cls): - return len(list(filter(lambda x: isinstance(x, cls), self._ports.values()))) - - port_cls = QbloxOutputPort if out else QbloxInputPort - self._ports[name] = port_cls(self, port_number=count(port_cls), port_name=name) - return self._ports[name] diff --git a/src/qibolab/instruments/qblox/port.py b/src/qibolab/instruments/qblox/port.py deleted file mode 100644 index c83cf391e3..0000000000 --- a/src/qibolab/instruments/qblox/port.py +++ /dev/null @@ -1,284 +0,0 @@ -from dataclasses import dataclass - -import numpy as np -from qibo.config import log, raise_error - -from qibolab.instruments.port import Port - -FREQUENCY_LIMIT = 500e6 -MAX_OFFSET = 2.5 -MIN_PULSE_DURATION = 4 - - -@dataclass -class QbloxOutputPort_Settings: - attenuation: int = 60 - offset: float = 0.0 - hardware_mod_en: bool = True - nco_freq: int = 0 - nco_phase_offs: float = 0 - lo_enabled: bool = True - lo_frequency: int = 2_000_000_000 - - -@dataclass -class QbloxInputPort_Settings: - channel: str = None - acquisition_hold_off: int = 0 - acquisition_duration: int = 1000 - hardware_demod_en: bool = True - - -class QbloxOutputPort(Port): - """qibolab.instruments.port.Port interface implementation for Qblox - instruments.""" - - def __init__(self, module, port_number: int, port_name: str = None): - self.name = port_name - self.module = module - self.sequencer_number: int = port_number - self.port_number: int = port_number - self._settings = QbloxOutputPort_Settings() - - @property - def attenuation(self) -> str: - """Attenuation that is applied to this port.""" - return self._settings.attenuation - - @attenuation.setter - def attenuation(self, value): - if isinstance(value, (float, np.floating)): - value = int(value) - if isinstance(value, (int, np.integer)): - if value > 60: - log.warning( - f"Qblox attenuation needs to be between 0 and 60 dB. Adjusting {value} to 60dB" - ) - value = 60 - - elif value < 0: - log.warning( - f"Qblox attenuation needs to be between 0 and 60 dB. Adjusting {value} to 0" - ) - value = 0 - - if (value % 2) != 0: - log.warning( - f"Qblox attenuation needs to be a multiple of 2 dB. Adjusting {value} to {round(value/2) * 2}" - ) - value = round(value / 2) * 2 - else: - raise_error(ValueError, f"Invalid attenuation {value}") - - self._settings.attenuation = value - if self.module.device: - self.module.device.set(f"out{self.port_number}_att", value=value) - - @property - def offset(self): - """DC offset that is applied to this port.""" - return self._settings.offset - - @offset.setter - def offset(self, value): - if isinstance(value, (int, np.integer)): - value = float(value) - if isinstance(value, (float, np.floating)): - if value > MAX_OFFSET: - log.warning( - f"Qblox offset needs to be between -2.5 and 2.5 V. Adjusting {value} to 2.5 V" - ) - value = MAX_OFFSET - - elif value < -MAX_OFFSET: - log.warning( - f"Qblox offset needs to be between -2.5 and 2.5 V. Adjusting {value} to -2.5 V" - ) - value = -MAX_OFFSET - else: - raise_error(ValueError, f"Invalid offset {value}") - - self._settings.offset = value - if self.module.device: - self.module.device.set(f"out{self.port_number}_offset", value=value) - - # Additional attributes needed by the driver - @property - def hardware_mod_en(self): - """Flag to enable hardware modulation.""" - return self._settings.hardware_mod_en - - @hardware_mod_en.setter - def hardware_mod_en(self, value): - if not isinstance(value, bool): - raise_error(ValueError, f"Invalid hardware_mod_en {value}") - - self._settings.hardware_mod_en = value - if self.module.device: - self.module.device.sequencers[self.sequencer_number].set( - "mod_en_awg", value=value - ) - - @property - def nco_freq(self): - """nco_freq that is applied to this port.""" - return self._settings.nco_freq - - @nco_freq.setter - def nco_freq(self, value): - if isinstance(value, (float, np.floating)): - value = int(value) - if isinstance(value, (int, np.integer)): - if value > FREQUENCY_LIMIT: - log.warning( - f"Qblox nco_freq needs to be between -{FREQUENCY_LIMIT} and {FREQUENCY_LIMIT} MHz. Adjusting {value} to {FREQUENCY_LIMIT} MHz" - ) - value = int(FREQUENCY_LIMIT) - - elif value < -FREQUENCY_LIMIT: - log.warning( - f"Qblox nco_freq needs to be between -{FREQUENCY_LIMIT} and {FREQUENCY_LIMIT} MHz. Adjusting {value} to -{FREQUENCY_LIMIT} MHz" - ) - value = int(-FREQUENCY_LIMIT) - else: - raise_error(ValueError, f"Invalid nco_freq {value}") - - self._settings.nco_freq = value - if self.module.device: - self.module.device.sequencers[self.sequencer_number].set( - "nco_freq", value=value - ) - - @property - def nco_phase_offs(self): - """nco_phase_offs that is applied to this port.""" - return self._settings.nco_phase_offs - - @nco_phase_offs.setter - def nco_phase_offs(self, value): - if isinstance(value, (int, np.integer)): - value = float(value) - if isinstance(value, (float, np.floating)): - value = value % 360 - else: - raise_error(ValueError, f"Invalid nco_phase_offs {value}") - - self._settings.nco_phase_offs = value - if self.module.device: - self.module.device.sequencers[self.sequencer_number].set( - "nco_phase_offs", value=value - ) - - @property - def lo_enabled(self): - """Flag to enable local oscillator.""" - return self._settings.lo_enabled - - @lo_enabled.setter - def lo_enabled(self, value): - if not isinstance(value, bool): - raise_error(ValueError, f"Invalid lo_enabled {value}") - - self._settings.lo_enabled = value - if self.module.device: - if self.module.device.is_qrm_type: - self.module.device.set( - f"out{self.port_number}_in{self.port_number}_lo_en", value=value - ) - elif self.module.device.is_qcm_type: - self.module.device.set(f"out{self.port_number}_lo_en", value=value) - - @property - def lo_frequency(self): - """Local oscillator frequency for the given port.""" - return self._settings.lo_frequency - - @lo_frequency.setter - def lo_frequency(self, value): - if isinstance(value, (float, np.floating)): - value = int(value) - if isinstance(value, (int, np.integer)): - if value > 18e9: - log.warning( - f"Qblox lo_frequency needs to be between 2e9 and 18e9 Hz. Adjusting {value} to 18e9 Hz" - ) - value = int(18e9) - - elif value < 2e9: - log.warning( - f"Qblox lo_frequency needs to be between 2e9 and 18e9 Hz. Adjusting {value} to 2e9 Hz" - ) - value = int(2e9) - else: - raise_error(ValueError, f"Invalid lo-frequency {value}") - - self._settings.lo_frequency = value - if self.module.device: - if self.module.device.is_qrm_type: - self.module.device.set( - f"out{self.port_number}_in{self.port_number}_lo_freq", value=value - ) - elif self.module.device.is_qcm_type: - self.module.device.set(f"out{self.port_number}_lo_freq", value=value) - - -class QbloxInputPort: - def __init__(self, module, port_number: int, port_name: str = None): - self.name = port_name - self.module = module - self.output_sequencer_number: int = 0 # output_sequencer_number - self.input_sequencer_number: int = 0 # input_sequencer_number - self.port_number: int = port_number - - self.acquisition_hold_off = 4 # To be discontinued - - self._settings = QbloxInputPort_Settings() - - @property - def hardware_demod_en(self): - """Flag to enable hardware demodulation.""" - return self._settings.hardware_demod_en - - @hardware_demod_en.setter - def hardware_demod_en(self, value): - if not isinstance(value, bool): - raise_error(ValueError, f"Invalid hardware_demod_en {value}") - - self._settings.hardware_demod_en = value - if self.module.device: - self.module.device.sequencers[self.input_sequencer_number].set( - "demod_en_acq", value=value - ) - - @property - def acquisition_duration(self): - """Duration of the pulse acquisition, in ns. - - It must be > 0 and multiple of 4. - """ - return self._settings.acquisition_duration - - @acquisition_duration.setter - def acquisition_duration(self, value): - if isinstance(value, (float, np.floating)): - value = int(value) - if isinstance(value, (int, np.integer)): - if value < MIN_PULSE_DURATION: - log.warning( - f"Qblox hardware_demod_en needs to be > 4ns. Adjusting {value} to {MIN_PULSE_DURATION} ns" - ) - value = MIN_PULSE_DURATION - if (value % MIN_PULSE_DURATION) != 0: - log.warning( - f"Qblox hardware_demod_en needs to be a multiple of 4 ns. Adjusting {value} to {round(value/MIN_PULSE_DURATION) * MIN_PULSE_DURATION}" - ) - value = round(value / MIN_PULSE_DURATION) * MIN_PULSE_DURATION - - else: - raise_error(ValueError, f"Invalid acquisition_duration {value}") - - self._settings.acquisition_duration = value - if self.module.device: - self.module.device.sequencers[self.output_sequencer_number].set( - "integration_length_acq", value=value - ) diff --git a/src/qibolab/instruments/qblox/q1asm.py b/src/qibolab/instruments/qblox/q1asm.py deleted file mode 100644 index 1b0327b88f..0000000000 --- a/src/qibolab/instruments/qblox/q1asm.py +++ /dev/null @@ -1,370 +0,0 @@ -"""A library to support generating qblox q1asm programs.""" - -import numpy as np - -END_OF_LINE = "\n" - - -class Program: - """A class to represent a sequencer q1asm assembly program. - - A q1asm program is made of blocks of code (:class:`qibolab.instruments.qblox.qblox_q1asm.Block`). - Real time registers (variables) are necessary to implement sweeps in real time. - This class keeps track of the registers used and has a method to provide the next available register. - """ - - MAX_REGISTERS = 64 - - def next_register(self): - """Provides the number of the next available register.""" - self._next_register_number += 1 - if self._next_register_number >= Program.MAX_REGISTERS: - raise RuntimeError("There are no more registers available.") - return self._next_register_number - - def __init__(self): - self._blocks: list = [] - self._next_register_number: int = -1 - - def add_blocks(self, *blocks): - """Adds a :class:`qibolab.instruments.qblox.qblox_q1asm.Block` of code - to the list of blocks.""" - for block in blocks: - self._blocks.append(block) - - def __repr__(self) -> str: - """Returns the program.""" - block_str: str = "" - for block in self._blocks: - block_str += repr(block) + END_OF_LINE - return block_str - - -class Block: - """A class to represent a block of q1asm assembly code. - - A block is comprised of code lines. - Attributes: - name (str): A name for the block of code. - lines (list(tupple)): A list of lines of code (code, comment, indentation level). - """ - - # TODO: replace tupples used for code lines with a Line object - - GLOBAL_INDENTATION_LEVEL = 3 - SPACES_PER_LEVEL = 4 - SPACES_BEFORE_COMMENT = 4 - - def __init__(self, name=""): - self.name = name - self.lines: list = [] - self._indentation = 0 - - def _indentation_string(self, level): - return " " * Block.SPACES_PER_LEVEL * level - - @property - def indentation(self): - return self._indentation - - @indentation.setter - def indentation(self, value): - if not isinstance(value, int): - raise TypeError( - f"indentation type should be int, got {type(value).__name__}" - ) - - diff = value - self._indentation - self._indentation = value - self.lines = [ - (line, comment, level + diff) for (line, comment, level) in self.lines - ] - - def append(self, line, comment="", level=0): - self.lines = self.lines + [(line, comment, self._indentation + level)] - - def prepend(self, line, comment="", level=0): - self.lines = [(line, comment, self._indentation + level)] + self.lines - - def append_spacer(self): - self.lines = self.lines + [("", "", self._indentation)] - - def __repr__(self) -> str: - """Returns a string with the block of code, taking care of the - indentation of instructions and comments.""" - - def comment_col(line, level): - col = Block.SPACES_PER_LEVEL * (level + Block.GLOBAL_INDENTATION_LEVEL) - col += len(line) - return col - - max_col: int = 0 - for line, comment, level in self.lines: - if comment: - max_col = max(max_col, comment_col(line, level)) - - block_str: str = "" - if self.name: - block_str += ( - self._indentation_string( - self._indentation + Block.GLOBAL_INDENTATION_LEVEL - ) - + "# " - + self.name - + END_OF_LINE - ) - - for line, comment, level in self.lines: - block_str += ( - self._indentation_string(level + Block.GLOBAL_INDENTATION_LEVEL) + line - ) - if comment: - block_str += ( - " " - * (max_col - comment_col(line, level) + Block.SPACES_BEFORE_COMMENT) - + " # " - + comment - ) - block_str += END_OF_LINE - - return block_str - - def __add__(self, other): - if isinstance(other, Block): - block = Block() - for line, comment, level in self.lines: - block.append(line, comment, level) - for line, comment, level in other.lines: - block.append(line, comment, level) - else: - raise TypeError(f"Expected Block, got {type(other).__name__}") - return block - - def __radd__(self, other): - if isinstance(other, Block): - block = Block() - for line, comment, level in other.lines: - block.append(line, comment, level) - for line, comment, level in self.lines: - block.append(line, comment, level) - else: - raise TypeError(f"Expected Block, got {type(other).__name__}") - return block - - def __iadd__(self, other): - if isinstance(other, Block): - for line, comment, level in other.lines: - self.append(line, comment, level) - else: - raise TypeError(f"Expected Block, got {type(other).__name__}") - return self - - -class Register: - """A class to represent a q1asm program register. - - Registers are used as variables in real time FPGA code. - Attributes: - name (str): a name to identify the register - """ - - def __init__(self, program: Program, name: str = ""): - self._number = program.next_register() - self._name = name - self._type = type - - def __repr__(self) -> str: - return "R" + str(self._number) - - @property - def name(self): - return self._name - - @name.setter - def name(self, value): - self._name = value - - -def wait_block( - wait_time: int, register: Register, force_multiples_of_four: bool = False -): - """Generates blocks of code to implement long delays. - - Arguments: - wait_time (int): the total time to wait. - register (:class:`qibolab.instruments.qblox.qblox_q1asm.Register`): the register used to loop - force_multiples_of_four (bool): a flag that forces the delay to be a multiple of 4(ns) - """ - n_loops: int - loop_wait: int - wait: int - block = Block() - - # constrains - # extra_wait and wait_loop_step need to be within (4,65535) (2**16 bits variable) - # extra_wait and wait_loop_step need to be multiples of 4ns * - - if wait_time < 0: - raise ValueError("wait_time must be positive.") - - elif wait_time == 0: - n_loops = 0 - loop_wait = 0 - wait = 0 - - elif wait_time > 0 and wait_time < 4: - # TODO: log("wait_time > 0 and wait_time < 4 is not supported by the instrument, wait_time changed to 4ns") - n_loops = 0 - loop_wait = 0 - wait = 4 - - elif wait_time >= 4 and wait_time < 2**16: # 65536ns - n_loops = 0 - loop_wait = 0 - wait = wait_time - elif wait_time >= 2**16 and wait_time < 2**32: # 4.29s - loop_wait = 2**16 - 4 - n_loops = wait_time // loop_wait - wait = wait_time % loop_wait - - while loop_wait >= 4 and (wait > 0 and wait < 4): - loop_wait -= 4 - n_loops = wait_time // loop_wait - wait = wait_time % loop_wait - - if loop_wait < 4 or (wait > 0 and wait < 4): - raise ValueError( - f"Unable to decompose {wait_time} into valid (n_loops * loop_wait + wait)" - ) - else: - raise ValueError("wait_time > 65535**2 is not supported yet.") - - if force_multiples_of_four: - wait = int(np.ceil(wait / 4)) * 4 - - wait_time = n_loops * loop_wait + wait - - if n_loops > 0: - block.append(f"# wait {wait_time} ns") - block.append(f"move {n_loops}, {register}") - block.append(f"wait_loop_{register}:") - block.append(f"wait {loop_wait}", level=1) - block.append(f"loop {register}, @wait_loop_{register}", level=1) - if wait > 0: - block.append(f"wait {wait}") - - return block - - -def loop_block( - start: int, stop: int, step: int, register: Register, block: Block -): # validate values - """Generates blocks of code to implement loops. - - Its behaviour is similar to range(): it includes the first value, but never the last. - - Arguments: - start (int): the initial value. - stop (int): the final value (excluded). - step (int): the step in which the register is incremented. - register (:class:`qibolab.instruments.qblox.qblox_q1asm.Register`): the register modified within the loop. - block (:class:`qibolab.instruments.qblox.qblox_q1asm.Register`): the block of code to be iterated. - """ - - if not (isinstance(start, int) and isinstance(stop, int) and isinstance(step, int)): - raise ValueError("begin, end and step must be int") - if stop != start and step == 0: - raise ValueError("step must not be 0") - if (stop > start and not step > 0) or (stop < start and not step < 0): - raise ValueError("invalid step") - if start < 0 or stop < 0: - raise ValueError("sweep possitive values only") - - header_block = Block() - # same behaviour as range() includes the first but never the last - header_block.append(f"move {start}, {register}", comment=register.name + " loop") - header_block.append("nop") - header_block.append(f"loop_{register}:") - header_block.append_spacer() - - body_block = Block() - body_block.indentation = 1 - body_block += block - - footer_block = Block() - footer_block.append_spacer() - if stop > start: - footer_block.append(f"add {register}, {step}, {register}") - footer_block.append("nop") - footer_block.append( - f"jlt {register}, {stop}, @loop_{register}", comment=register.name + " loop" - ) - elif stop < start: - footer_block.append(f"sub {register}, {abs(step)}, {register}") - footer_block.append("nop") - footer_block.append( - f"jge {register}, {stop + 1}, @loop_{register}", - comment=register.name + " loop", - ) - - return header_block + body_block + footer_block - - -def convert_phase(phase_rad: float): - """Converts phase values in radiants to the encoding used in qblox FPGAs. - - The phase is divided into 1e9 steps between 0° and 360°, expressed - as an integer between 0 and 1e9 (e.g 45°=125e6). - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/api_reference/sequencer.html - """ - phase_deg = (phase_rad * 360 / (2 * np.pi)) % 360 - return int(phase_deg * 1e9 / 360) - - -def convert_frequency(freq: float): - """Converts frequency values to the encoding used in qblox FPGAs. - - The frequency is divided into 4e9 steps between -500 and 500 MHz and - expressed as an integer between -2e9 and 2e9. (e.g. 1 MHz=4e6). - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/api_reference/sequencer.html - """ - if not (freq >= -500e6 and freq <= 500e6): - raise ValueError("frequency must be a float between -500e6 and 500e6 Hz") - return int(freq * 4) % 2**32 # two's complement of 18? TODO: confirm with qblox - - -def convert_gain(gain: float): - """Converts gain values to the encoding used in qblox FPGAs. - - Both gain values are divided in 2**sample path width steps. QCM DACs - resolution 16bits, QRM DACs and ADCs 12 bit - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/api_reference/sequencer.html - """ - if not (gain >= -1 and gain <= 1): - raise ValueError("gain must be a float between -1 and 1") - if gain == 1: - return 2**15 - 1 - else: - return int(np.floor(gain * 2**15)) % 2**32 # two's complement 32 bit number - - -def convert_offset(offset: float): - """Converts offset values to the encoding used in qblox FPGAs. - - Both offset values are divided in 2**sample path width steps. QCM - DACs resolution 16bits, QRM DACs and ADCs 12 bit QCM 5Vpp, QRM 2Vpp - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/api_reference/sequencer.html - """ - scale_factor = 1.25 * np.sqrt(2) - normalised_offset = offset / scale_factor - - if not (normalised_offset >= -1 and normalised_offset <= 1): - raise ValueError( - f"offset must be a float between {-scale_factor:.3f} and {scale_factor:.3f} V" - ) - if normalised_offset == 1: - return 2**15 - 1 - else: - return ( - int(np.floor(normalised_offset * 2**15)) % 2**32 - ) # two's complement 32 bit number? or 12 or 24? diff --git a/src/qibolab/instruments/qblox/sequencer.py b/src/qibolab/instruments/qblox/sequencer.py deleted file mode 100644 index 185375185d..0000000000 --- a/src/qibolab/instruments/qblox/sequencer.py +++ /dev/null @@ -1,234 +0,0 @@ -import numpy as np -from qblox_instruments.qcodes_drivers.sequencer import Sequencer as QbloxSequencer - -from qibolab.instruments.qblox.q1asm import Program -from qibolab.pulses import Pulse, PulseSequence, PulseType -from qibolab.sweeper import Parameter, Sweeper - -SAMPLING_RATE = 1 -"""Sampling rate for qblox instruments in GSps.""" - - -class WaveformsBuffer: - """A class to represent a buffer that holds the unique waveforms used by a - sequencer. - - Attributes: - unique_waveforms (list): A list of unique Waveform objects. - available_memory (int): The amount of memory available expressed in numbers of samples. - """ - - SIZE: int = 16383 - - class NotEnoughMemory(Exception): - """An error raised when there is not enough memory left to add more - waveforms.""" - - class NotEnoughMemoryForBaking(Exception): - """An error raised when there is not enough memory left to bake - pulses.""" - - def __init__(self): - """Initialises the buffer with an empty list of unique waveforms.""" - self.unique_waveforms: list = [] # Waveform - self.available_memory: int = WaveformsBuffer.SIZE - - def add_waveforms( - self, pulse: Pulse, hardware_mod_en: bool, sweepers: list[Sweeper] - ): - """Adds a pair of i and q waveforms to the list of unique waveforms. - - Waveforms are added to the list if they were not there before. - Each of the waveforms (i and q) is processed individually. - - Args: - waveform_i (Waveform): A Waveform object containing the samples of the real component of the pulse wave. - waveform_q (Waveform): A Waveform object containing the samples of the imaginary component of the pulse wave. - - Raises: - NotEnoughMemory: If the memory needed to store the waveforms in more than the memory avalible. - """ - pulse_copy = pulse.copy() - for sweeper in sweepers: - if sweeper.pulses and sweeper.parameter == Parameter.amplitude: - if pulse in sweeper.pulses: - pulse_copy.amplitude = 1 - - baking_required = False - for sweeper in sweepers: - if sweeper.pulses and sweeper.parameter == Parameter.duration: - if pulse in sweeper.pulses: - baking_required = True - values = sweeper.get_values(pulse.duration) - - if not baking_required: - if hardware_mod_en: - waveform_i, waveform_q = pulse_copy.envelope_waveforms(SAMPLING_RATE) - else: - waveform_i, waveform_q = pulse_copy.modulated_waveforms(SAMPLING_RATE) - - pulse.waveform_i = waveform_i - pulse.waveform_q = waveform_q - - if ( - waveform_i not in self.unique_waveforms - or waveform_q not in self.unique_waveforms - ): - memory_needed = 0 - if not waveform_i in self.unique_waveforms: - memory_needed += len(waveform_i) - if not waveform_q in self.unique_waveforms: - memory_needed += len(waveform_q) - - if self.available_memory >= memory_needed: - if not waveform_i in self.unique_waveforms: - self.unique_waveforms.append(waveform_i) - if not waveform_q in self.unique_waveforms: - self.unique_waveforms.append(waveform_q) - self.available_memory -= memory_needed - else: - raise WaveformsBuffer.NotEnoughMemory - else: - pulse.idx_range = self.bake_pulse_waveforms( - pulse_copy, values, hardware_mod_en - ) - - def bake_pulse_waveforms( - self, pulse: Pulse, values: list(), hardware_mod_en: bool - ): # bake_pulse_waveforms(self, pulse: Pulse, values: list(int), hardware_mod_en: bool): - """Generates and stores a set of i and q waveforms required for a pulse - duration sweep. - - These waveforms are generated and stored in a predefined order so that they can later be retrieved within the - sweeper q1asm code. It bakes pulses from as short as 1ns, padding them at the end with 0s if required so that - their length is a multiple of 4ns. It also supports the modulation of the pulse both in hardware (default) - or software. - With no other pulses stored in the sequencer memory, it supports values up to range(1, 126) for regular pulses and - range(1, 180) for flux pulses. - - Args: - pulse (:class:`qibolab.pulses.Pulse`): The pulse to be swept. - values (list(int)): The list of values to sweep the pulse duration with. - hardware_mod_en (bool): If set to True the pulses are assumed to be modulated in hardware and their - envelope waveforms are uploaded; if False, software modulated waveforms are uploaded. - - Returns: - idx_range (numpy.ndarray): An array with the indices of the set of pulses. For each pulse duration in - `values` the i component is saved in the next avalable index, followed by the q component. For flux - pulses, since both i and q components are equal, they are only saved once. - - Raises: - NotEnoughMemory: If the memory needed to store the waveforms in more than the memory avalible. - """ - # In order to generate waveforms for each duration value, the pulse will need to be modified. - # To avoid any conflicts, make a copy of the pulse first. - pulse_copy = pulse.copy() - - # there may be other waveforms stored already, set first index as the next available - first_idx = len(self.unique_waveforms) - - if pulse.type == PulseType.FLUX: - # for flux pulses, store i waveforms - idx_range = np.arange(first_idx, first_idx + len(values), 1) - - for duration in values: - pulse_copy.duration = duration - if hardware_mod_en: - waveform = pulse_copy.envelope_waveform_i(SAMPLING_RATE) - else: - waveform = pulse_copy.modulated_waveform_i(SAMPLING_RATE) - - padded_duration = int(np.ceil(duration / 4)) * 4 - memory_needed = padded_duration - padding = np.zeros(padded_duration - duration) - waveform.data = np.append(waveform.data, padding) - - if self.available_memory >= memory_needed: - self.unique_waveforms.append(waveform) - self.available_memory -= memory_needed - else: - raise WaveformsBuffer.NotEnoughMemoryForBaking - else: - # for any other pulse type, store both i and q waveforms - idx_range = np.arange(first_idx, first_idx + len(values) * 2, 2) - - for duration in values: - pulse_copy.duration = duration - if hardware_mod_en: - waveform_i, waveform_q = pulse_copy.envelope_waveforms( - SAMPLING_RATE - ) - else: - waveform_i, waveform_q = pulse_copy.modulated_waveforms( - SAMPLING_RATE - ) - - padded_duration = int(np.ceil(duration / 4)) * 4 - memory_needed = padded_duration * 2 - padding = np.zeros(padded_duration - duration) - waveform_i.data = np.append(waveform_i.data, padding) - waveform_q.data = np.append(waveform_q.data, padding) - - if self.available_memory >= memory_needed: - self.unique_waveforms.append(waveform_i) - self.unique_waveforms.append(waveform_q) - self.available_memory -= memory_needed - else: - raise WaveformsBuffer.NotEnoughMemoryForBaking - - return idx_range - - -class Sequencer: - """A class to extend the functionality of qblox_instruments Sequencer. - - A sequencer is a hardware component synthesised in the instrument FPGA, responsible for fetching waveforms from - memory, pre-processing them, sending them to the DACs, and processing the acquisitions from the ADCs (QRM modules). - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/documentation/sequencer.html - - This class extends the sequencer functionality by holding additional data required when - processing a pulse sequence: - - - the sequencer number, - - the sequence of pulses to be played, - - a buffer of unique waveforms, and - - the four components of the sequence file: - - - waveforms dictionary - - acquisition dictionary - - weights dictionary - - program - - Attributes: - device (QbloxSequencer): A reference to the underlying `qblox_instruments.qcodes_drivers.sequencer.Sequencer` - object. It can be used to access other features not directly exposed by this wrapper. - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/documentation/sequencer.html - number (int): An integer between 0 and 5 that identifies the number of the sequencer. - pulses (PulseSequence): The sequence of pulses to be played by the sequencer. - waveforms_buffer (WaveformsBuffer): A buffer of unique waveforms to be played by the sequencer. - waveforms (dict): A dictionary containing the waveforms to be played by the sequencer in qblox format. - acquisitions (dict): A dictionary containing the list of acquisitions to be made by the sequencer in qblox - format. - weights (dict): A dictionary containing the list of weights to be used by the sequencer when demodulating - and integrating the response, in qblox format. - program (str): The pseudo assembly (q1asm) program to be executed by the sequencer. - https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/documentation/sequencer.html#instructions - - qubit (str): The id of the qubit associated with the sequencer, if there is only one. - """ - - def __init__(self, number: int): - """Initialises the sequencer. - - All class attributes are defined and initialised. - """ - - self.device: QbloxSequencer = None - self.number: int = number - self.pulses: PulseSequence = PulseSequence() - self.waveforms_buffer: WaveformsBuffer = WaveformsBuffer() - self.waveforms: dict = {} - self.acquisitions: dict = {} - self.weights: dict = {} - self.program: Program = Program() - self.qubit = None # self.qubit: int | str = None diff --git a/src/qibolab/instruments/qblox/sweeper.py b/src/qibolab/instruments/qblox/sweeper.py deleted file mode 100644 index 1409220558..0000000000 --- a/src/qibolab/instruments/qblox/sweeper.py +++ /dev/null @@ -1,397 +0,0 @@ -from enum import Enum, auto - -import numpy as np - -from qibolab.instruments.qblox.q1asm import ( - Block, - Program, - Register, - convert_frequency, - convert_gain, - convert_offset, - convert_phase, -) -from qibolab.sweeper import Parameter, Sweeper - - -class QbloxSweeperType(Enum): - """An enumeration for the different types of sweepers supported by qblox. - - - frequency: sweeps pulse frequency by adjusting the sequencer `nco_freq` with q1asm command `set_freq`. - - gain: sweeps sequencer gain by adjusting the sequencer `gain_awg_path0` and `gain_awg_path1` with q1asm command - `set_awg_gain`. Since the gain is a parameter between -1 and 1 that multiplies the samples of the waveforms - before they are fed to the DACs, it can be used to sweep the pulse amplitude. - - offset: sweeps sequencer offset by adjusting the sequencer `offset_awg_path0` and `offset_awg_path1` with q1asm - command `set_awg_offs` - - start: sweeps pulse start. - - duration: sweeps pulse duration. - """ - - frequency = auto() - gain = auto() - offset = auto() - start = auto() - duration = auto() - - number = auto() # internal - relative_phase = auto() # not implemented yet - time = auto() # not implemented yet - - -class QbloxSweeper: - """A custom sweeper object with the data and functionality required by - qblox instruments. - - It is responsible for generating the q1asm code required to execute sweeps in a sequencer. The object can be - initialised with either: - - - a :class:`qibolab.sweepers.Sweeper` using the :func:`qibolab.instruments.qblox.QbloxSweeper.from_sweeper`, or - - a range of values and a sweeper type (:class:`qibolab.instruments.qblox.QbloxSweeperType`) - - Like most FPGAs, qblox FPGAs do not support floating point arithmetics. All parameters that can be manipulated in - real time within the FPGA are represented as two's complement integers. - - Attributes: - type (:class:`qibolab.instruments.qblox.QbloxSweeperType`): the type of sweeper - name (str): a name given for the sweep that is later used within the q1asm code to identify the loops. - register (:class:`qibolab.instruments.qblox_q1asm.Register`): the main Register (q1asm variable) used in the loop. - aux_register (:class:`qibolab.instruments.qblox_q1asm.Register`): an auxialiry Register requried in duration - sweeps. - update_parameters (Bool): a flag to instruct the sweeper to update the paramters or not depending on whether - a parameter of the sequencer needs to be swept or not. - - Methods: - block(inner_block: :class:`qibolab.instruments.qblox_q1asm.Block`): generates the block of q1asm code that implements - the sweep. - """ - - FREQUENCY_LIMIT = 500e6 - - def __init__( - self, - program: Program, - rel_values: list, - type: QbloxSweeperType = QbloxSweeperType.number, - add_to: float = 0, - multiply_to: float = 1, - name: str = "", - ): - """Creates an instance from a range of values and a sweeper type - (:class:`qibolab.instruments.qblox.QbloxSweeperType`). - - Args: - program (:class:`qibolab.instruments.qblox_q1asm.Program`): a program object representing the q1asm program - of a sequencer. - rel_values (list): a list of values to iterate over. Currently qblox only supports a list of equally spaced - values, like those created with `np.arange(start, stop, step)`. These values are considered relative - values. They will later be added to the `add_to` parameter and multiplied to the `multiply_to` - parameter. - type (:class:`qibolab.instruments.qblox.QbloxSweeperType`): the type of sweeper. - add_to (float): a value to be added to each value of the range of values defined in `sweeper.values` or - `rel_values`. - multiply_to (float): a value to be multiplied by each value of the range of values defined in - `sweeper.values` or `rel_values`. - name (str): a name given for the sweep that is later used within the q1as m code to identify the loops. - """ - - self.type: QbloxSweeperType = type - self.name: str = None - self.register: Register = None - self.aux_register: Register = None - self.update_parameters: bool = False - - # Number of iterations in the loop - self._n: int = None - - # Absolute values - self._abs_start = None - self._abs_step = None - self._abs_stop = None - self._abs_values: np.ndarray = None - - # Converted values (converted to q1asm values, two's complement) - self._con_start: int = None - self._con_step: int = None - self._con_stop: int = None - self._con_values: np.ndarray = None - - # Validate input parameters - if not len(rel_values) > 1: - raise ValueError("values must contain at least 2 elements.") - elif rel_values[1] == rel_values[0]: - raise ValueError("values must contain different elements.") - - self._n = len(rel_values) - 1 - rel_start = rel_values[0] - rel_step = rel_values[1] - rel_values[0] - - if name != "": - self.name = name - else: - self.name = self.type.name - - # create the registers (variables) to be used in the loop - self.register: Register = Register(program, self.name) - if type == QbloxSweeperType.duration: - self.aux_register: Register = Register(program, self.name + "_aux") - - # Calculate absolute values - self._abs_start = (rel_start + add_to) * multiply_to - self._abs_step = rel_step * multiply_to - self._abs_stop = self._abs_start + self._abs_step * (self._n) - self._abs_values = np.arange(self._abs_start, self._abs_stop, self._abs_step) - - # Verify that all values are within acceptable ranges - check_values = { - QbloxSweeperType.frequency: ( - lambda v: all( - (-self.FREQUENCY_LIMIT <= x and x <= self.FREQUENCY_LIMIT) - for x in v - ) - ), - QbloxSweeperType.gain: (lambda v: all((-1 <= x and x <= 1) for x in v)), - QbloxSweeperType.offset: ( - lambda v: all( - (-1.25 * np.sqrt(2) <= x and x <= 1.25 * np.sqrt(2)) for x in v - ) - ), - QbloxSweeperType.relative_phase: (lambda v: True), - QbloxSweeperType.start: (lambda v: all((4 <= x and x < 2**16) for x in v)), - QbloxSweeperType.duration: ( - lambda v: all((0 <= x and x < 2**16) for x in v) - ), - QbloxSweeperType.number: ( - lambda v: all((-(2**16) < x and x < 2**16) for x in v) - ), - } - - if not check_values[type](np.append(self._abs_values, [self._abs_stop])): - raise ValueError( - f"Sweeper {self.name} values are not within the allowed range" - ) - - # Convert absolute values to q1asm values - convert = { - QbloxSweeperType.frequency: convert_frequency, - QbloxSweeperType.gain: convert_gain, - QbloxSweeperType.offset: convert_offset, - QbloxSweeperType.relative_phase: convert_phase, - QbloxSweeperType.start: (lambda x: int(x) % 2**16), - QbloxSweeperType.duration: (lambda x: int(x) % 2**16), - QbloxSweeperType.number: (lambda x: int(x) % 2**32), - } - - self._con_start = convert[type](self._abs_start) - self._con_step = convert[type](self._abs_step) - self._con_stop = (self._con_start + self._con_step * (self._n) + 1) % 2**32 - self._con_values = np.array( - [(self._con_start + self._con_step * m) % 2**32 for m in range(self._n + 1)] - ) - - # log.info(f"Qblox sweeper converted values: {self._con_values}") - - if not ( - isinstance(self._con_start, int) - and isinstance(self._con_stop, int) - and isinstance(self._con_step, int) - ): - raise ValueError("start, stop and step must be int") - - @classmethod - def from_sweeper( - cls, - program: Program, - sweeper: Sweeper, - add_to: float = 0, - multiply_to: float = 1, - name: str = "", - ): - """Creates an instance form a :class:`qibolab.sweepers.Sweeper` object. - - Args: - program (:class:`qibolab.instruments.qblox_q1asm.Program`): a program object representing the q1asm program of a - sequencer. - sweeper (:class:`qibolab.sweepers.Sweeper`): the original qibolab sweeper. - associated with the sweep. If no name is provided it uses the sweeper type as name. - add_to (float): a value to be added to each value of the range of values defined in `sweeper.values`, - `rel_values`. - multiply_to (float): a value to be multiplied by each value of the range of values defined in `sweeper.values`, - `rel_values`. - name (str): a name given for the sweep that is later used within the q1asm code to identify the loops. - """ - type_c = { - Parameter.frequency: QbloxSweeperType.frequency, - Parameter.gain: QbloxSweeperType.gain, - Parameter.amplitude: QbloxSweeperType.gain, - Parameter.bias: QbloxSweeperType.offset, - Parameter.start: QbloxSweeperType.start, - Parameter.duration: QbloxSweeperType.duration, - Parameter.relative_phase: QbloxSweeperType.relative_phase, - } - if sweeper.parameter in type_c: - type = type_c[sweeper.parameter] - rel_values = sweeper.values - else: - raise ValueError( - f"Sweeper parameter {sweeper.parameter} is not supported by qblox driver yet." - ) - return cls( - program=program, - rel_values=rel_values, - type=type, - add_to=add_to, - multiply_to=multiply_to, - name=name, - ) - - def block(self, inner_block: Block): - """Generates the block of q1asm code that implements the sweep. - - The q1asm code for a sweeper has the following structure: - - .. code-block:: text - - # header_block - # initialise register with start value - move 0, R0 # 0 = start value, R0 = register name - nop # wait an instruction cycle (4ns) for the register to be updated with its value - loop_R0: # loop label - - # update_parameter_block - # update parameters, in this case pulse frequency - set_freq R0 # sets the frequency of the sequencer nco to the value stored in R0 - upd_param 100 # makes the change effective and wait 100ns - - # inner block - play 0,1,4 # play waveforms with index 0 and 1 (i and q) and wait 4ns - - # footer_block - # increment or decrement register with step value - add R0, 2500, R0 # R0 = R0 + 2500 - nop # wait an instruction cycle (4ns) for the register to be updated with its value - # check condition and loop - jlt R0, 10001, @loop_R0 # while R0 is less than the stop value loop to loop_R0 - # in this example it would loop 5 times - # with R0 values of 0, 2500, 5000, 7500 and 10000 - - Args: - inner_block (:class:`qibolab.instruments.qblox_q1asm.Block`): the block of q1asm code to be repeated within - the loop. - """ - # Initialisation - header_block = Block() - header_block.append( - f"move {self._con_start}, {self.register}", - comment=f"{self.register.name} loop, start: {round(self._abs_start, 6):_}", - ) - header_block.append("nop") - header_block.append(f"loop_{self.register}:") - - # Parameter update - if self.update_parameters: - update_parameter_block = Block() - update_time = 1000 - if self.type == QbloxSweeperType.frequency: - update_parameter_block.append( - f"set_freq {self.register}" - ) # TODO: move to pulse - update_parameter_block.append(f"upd_param {update_time}") - if self.type == QbloxSweeperType.gain: - update_parameter_block.append( - f"set_awg_gain {self.register}, {self.register}" - ) # TODO: move to pulse - update_parameter_block.append(f"upd_param {update_time}") - if self.type == QbloxSweeperType.offset: - update_parameter_block.append( - f"set_awg_offs {self.register}, {self.register}" - ) - update_parameter_block.append(f"upd_param {update_time}") - - if self.type == QbloxSweeperType.start: - pass - if self.type == QbloxSweeperType.duration: - update_parameter_block.append( - f"add {self.register}, 1, {self.aux_register}" - ) - if self.type == QbloxSweeperType.time: - pass - if self.type == QbloxSweeperType.number: - pass - if self.type == QbloxSweeperType.relative_phase: - pass - header_block += update_parameter_block - header_block.append_spacer() - - # Main code - body_block = Block() - body_block.indentation = 1 - body_block += inner_block - - # Loop instructions - footer_block = Block() - footer_block.append_spacer() - - footer_block.append( - f"add {self.register}, {self._con_step}, {self.register}", - comment=f"{self.register.name} loop, step: {round(self._abs_step, 6):_}", - ) - footer_block.append("nop") - - # Qblox fpgas implement negative numbers using two's complement however their conditional jump instructions - # (jlt and jge) only work with unsigned integers. Negative numbers (from 2**31 to 2**32) are greater than - # possitive numbers (0 to 2**31). There is therefore a discontinuity between negative and possitive numbers. - # Depending on whether the sweep increases or decreases the register, and on whether it crosses the - # discontinuity or not, there are 4 scenarios: - - if self._abs_step > 0: # increasing - if (self._abs_start < 0 and self._abs_stop < 0) or ( - self._abs_stop > 0 and self._abs_start >= 0 - ): # no crossing 0 - footer_block.append( - f"jlt {self.register}, {self._con_stop}, @loop_{self.register}", - comment=f"{self.register.name} loop, stop: {round(self._abs_stop, 6):_}", - ) - elif self._abs_start < 0 and self._abs_stop >= 0: # crossing 0 - # wait until the register crosses 0 to possitive values - footer_block.append( - f"jge {self.register}, {2**31}, @loop_{self.register}", - ) - # loop if the register is less than the stop value - footer_block.append( - f"jlt {self.register}, {self._con_stop}, @loop_{self.register}", - comment=f"{self.register.name} loop, stop: {round(self._abs_stop, 6):_}", - ) - else: - raise ValueError( - f"incorrect values for abs_start: {self._abs_start}, abs_stop: {self._abs_stop}, abs_step: {self._abs_step}" - ) - elif self._abs_step < 0: # decreasing - if (self._abs_start < 0 and self._abs_stop < 0) or ( - self._abs_stop >= 0 and self._abs_start > 0 - ): # no crossing 0 - footer_block.append( - f"jge {self.register}, {self._con_stop + 1}, @loop_{self.register}", - comment=f"{self.register.name} loop, stop: {round(self._abs_stop, 6):_}", - ) - elif self._abs_start >= 0 and self._abs_stop < 0: # crossing 0 - if self._con_stop + 1 != 2**32: - # wait until the register crosses 0 to negative values - footer_block.append( - f"jlt {self.register}, {2**31}, @loop_{self.register}", - ) - # loop if the register is greater than the stop value - footer_block.append( - f"jge {self.register}, {self._con_stop + 1}, @loop_{self.register}", - comment=f"{self.register.name} loop, stop: {round(self._abs_stop, 6):_}", - ) - else: # special case when stopping at -1 - footer_block.append( - f"jlt {self.register}, {2**31}, @loop_{self.register}", - comment=f"{self.register.name} loop, stop: {round(self._abs_stop, 6):_}", - ) - else: - raise ValueError( - f"incorrect values for abs_start: {self._abs_start}, abs_stop: {self._abs_stop}, abs_step: {self._abs_step}" - ) - - return header_block + body_block + footer_block diff --git a/src/qibolab/instruments/qm.py b/src/qibolab/instruments/qm.py new file mode 100644 index 0000000000..31d08d46df --- /dev/null +++ b/src/qibolab/instruments/qm.py @@ -0,0 +1,10 @@ +"""Quantum machines drivers. + +https://quantum-machines.co/ +""" + +from qibolab._core.instruments import qm +from qibolab._core.instruments.qm import * # noqa: F403 + +__all__ = [] +__all__ += qm.__all__ diff --git a/src/qibolab/instruments/qm/__init__.py b/src/qibolab/instruments/qm/__init__.py deleted file mode 100644 index e053aa970a..0000000000 --- a/src/qibolab/instruments/qm/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .controller import QMController -from .devices import Octave, OPXplus diff --git a/src/qibolab/instruments/qm/acquisition.py b/src/qibolab/instruments/qm/acquisition.py deleted file mode 100644 index f22aa752f2..0000000000 --- a/src/qibolab/instruments/qm/acquisition.py +++ /dev/null @@ -1,294 +0,0 @@ -from abc import ABC, abstractmethod -from dataclasses import dataclass, field -from typing import Optional - -import numpy as np -from qm import qua -from qm.qua import declare, declare_stream, fixed -from qm.qua._dsl import _ResultSource, _Variable # for type declaration only -from qualang_tools.addons.variables import assign_variables_to_element -from qualang_tools.units import unit - -from qibolab.execution_parameters import AcquisitionType, AveragingMode -from qibolab.qubits import QubitId -from qibolab.result import ( - AveragedIntegratedResults, - AveragedRawWaveformResults, - AveragedSampleResults, - IntegratedResults, - RawWaveformResults, - SampleResults, -) - - -@dataclass -class Acquisition(ABC): - """QUA variables used for saving of acquisition results. - - This class can be instantiated only within a QUA program scope. Each - readout pulse is associated with its own set of acquisition - variables. - """ - - name: str - """Name of the acquisition used as identifier to download results from the - instruments.""" - qubit: QubitId - average: bool - - keys: list[str] = field(default_factory=list) - - RESULT_CLS = IntegratedResults - """Result object type that corresponds to this acquisition type.""" - AVERAGED_RESULT_CLS = AveragedIntegratedResults - """Averaged result object type that corresponds to this acquisition - type.""" - - @property - def npulses(self): - return len(self.keys) - - @abstractmethod - def assign_element(self, element): - """Assign acquisition variables to the corresponding QM controlled. - - Proposed to do by QM to avoid crashes. - - Args: - element (str): Element (from ``config``) that the pulse will be applied on. - """ - - @abstractmethod - def measure(self, operation, element): - """Send measurement pulse and acquire results. - - Args: - operation (str): Operation (from ``config``) corresponding to the pulse to be played. - element (str): Element (from ``config``) that the pulse will be applied on. - """ - - @abstractmethod - def download(self, *dimensions): - """Save streams to prepare for fetching from host device. - - Args: - dimensions (int): Dimensions to use for buffer of data. - """ - - @abstractmethod - def fetch(self): - """Fetch downloaded streams to host device.""" - - def result(self, data): - """Creates Qibolab result object that is returned to the platform.""" - res_cls = self.AVERAGED_RESULT_CLS if self.average else self.RESULT_CLS - if self.npulses > 1: - return [res_cls(data[..., i]) for i in range(self.npulses)] - return [res_cls(data)] - - -@dataclass -class RawAcquisition(Acquisition): - """QUA variables used for raw waveform acquisition.""" - - adc_stream: _ResultSource = field( - default_factory=lambda: declare_stream(adc_trace=True) - ) - """Stream to collect raw ADC data.""" - - RESULT_CLS = RawWaveformResults - AVERAGED_RESULT_CLS = AveragedRawWaveformResults - - def assign_element(self, element): - pass - - def measure(self, operation, element): - qua.reset_phase(element) - qua.measure(operation, element, self.adc_stream) - - def download(self, *dimensions): - istream = self.adc_stream.input1() - qstream = self.adc_stream.input2() - if self.average: - istream = istream.average() - qstream = qstream.average() - istream.save(f"{self.name}_I") - qstream.save(f"{self.name}_Q") - - def fetch(self, handles): - ires = handles.get(f"{self.name}_I").fetch_all() - qres = handles.get(f"{self.name}_Q").fetch_all() - # convert raw ADC signal to volts - u = unit() - signal = u.raw2volts(ires) + 1j * u.raw2volts(qres) - return self.result(signal) - - -@dataclass -class IntegratedAcquisition(Acquisition): - """QUA variables used for integrated acquisition.""" - - i: _Variable = field(default_factory=lambda: declare(fixed)) - q: _Variable = field(default_factory=lambda: declare(fixed)) - """Variables to save the (I, Q) values acquired from a single shot.""" - istream: _ResultSource = field(default_factory=lambda: declare_stream()) - qstream: _ResultSource = field(default_factory=lambda: declare_stream()) - """Streams to collect the results of all shots.""" - - RESULT_CLS = IntegratedResults - AVERAGED_RESULT_CLS = AveragedIntegratedResults - - def assign_element(self, element): - assign_variables_to_element(element, self.i, self.q) - - def measure(self, operation, element): - qua.measure( - operation, - element, - None, - qua.dual_demod.full("cos", "out1", "sin", "out2", self.i), - qua.dual_demod.full("minus_sin", "out1", "cos", "out2", self.q), - ) - qua.save(self.i, self.istream) - qua.save(self.q, self.qstream) - - def download(self, *dimensions): - istream = self.istream - qstream = self.qstream - if self.npulses > 1: - istream = istream.buffer(self.npulses) - qstream = qstream.buffer(self.npulses) - for dim in dimensions: - istream = istream.buffer(dim) - qstream = qstream.buffer(dim) - if self.average: - istream = istream.average() - qstream = qstream.average() - istream.save(f"{self.name}_I") - qstream.save(f"{self.name}_Q") - - def fetch(self, handles): - ires = handles.get(f"{self.name}_I").fetch_all() - qres = handles.get(f"{self.name}_Q").fetch_all() - return self.result(ires + 1j * qres) - - -@dataclass -class ShotsAcquisition(Acquisition): - """QUA variables used for shot classification. - - Threshold and angle must be given in order to classify shots. - """ - - threshold: Optional[float] = None - """Threshold to be used for classification of single shots.""" - angle: Optional[float] = None - """Angle in the IQ plane to be used for classification of single shots.""" - - i: _Variable = field(default_factory=lambda: declare(fixed)) - q: _Variable = field(default_factory=lambda: declare(fixed)) - """Variables to save the (I, Q) values acquired from a single shot.""" - shot: _Variable = field(default_factory=lambda: declare(int)) - """Variable for calculating an individual shots.""" - shots: _ResultSource = field(default_factory=lambda: declare_stream()) - """Stream to collect multiple shots.""" - - RESULT_CLS = SampleResults - AVERAGED_RESULT_CLS = AveragedSampleResults - - def __post_init__(self): - self.cos = np.cos(self.angle) - self.sin = np.sin(self.angle) - - def assign_element(self, element): - assign_variables_to_element(element, self.i, self.q, self.shot) - - def measure(self, operation, element): - qua.measure( - operation, - element, - None, - qua.dual_demod.full("cos", "out1", "sin", "out2", self.i), - qua.dual_demod.full("minus_sin", "out1", "cos", "out2", self.q), - ) - qua.assign( - self.shot, - qua.Cast.to_int(self.i * self.cos - self.q * self.sin > self.threshold), - ) - qua.save(self.shot, self.shots) - - def download(self, *dimensions): - shots = self.shots - if self.npulses > 1: - shots = shots.buffer(self.npulses) - for dim in dimensions: - shots = shots.buffer(dim) - if self.average: - shots = shots.average() - shots.save(f"{self.name}_shots") - - def fetch(self, handles): - shots = handles.get(f"{self.name}_shots").fetch_all() - return self.result(shots) - - -ACQUISITION_TYPES = { - AcquisitionType.RAW: RawAcquisition, - AcquisitionType.INTEGRATION: IntegratedAcquisition, - AcquisitionType.DISCRIMINATION: ShotsAcquisition, -} - - -def declare_acquisitions(ro_pulses, qubits, options): - """Declares variables for saving acquisition in the QUA program. - - Args: - ro_pulses (list): List of readout pulses in the sequence. - qubits (dict): Dictionary containing all the :class:`qibolab.qubits.Qubit` - objects of the platform. - options (:class:`qibolab.execution_parameters.ExecutionParameters`): Execution - options containing acquisition type and averaging mode. - - Returns: - List of all :class:`qibolab.instruments.qm.acquisition.Acquisition` objects. - """ - acquisitions = {} - for qmpulse in ro_pulses: - qubit = qmpulse.pulse.qubit - name = f"{qmpulse.operation}_{qubit}" - if name not in acquisitions: - average = options.averaging_mode is AveragingMode.CYCLIC - kwargs = {} - if options.acquisition_type is AcquisitionType.DISCRIMINATION: - kwargs["threshold"] = qubits[qubit].threshold - kwargs["angle"] = qubits[qubit].iq_angle - - acquisition = ACQUISITION_TYPES[options.acquisition_type]( - name, qubit, average, **kwargs - ) - acquisition.assign_element(qmpulse.element) - acquisitions[name] = acquisition - - acquisitions[name].keys.append(qmpulse.pulse.serial) - qmpulse.acquisition = acquisitions[name] - return list(acquisitions.values()) - - -def fetch_results(result, acquisitions): - """Fetches results from an executed experiment. - - Args: - result: Result of the executed experiment. - acquisition (dict): Dictionary containing :class:`qibolab.instruments.qm.acquisition.Acquisition` objects. - - Returns: - Dictionary with the results in the format required by the platform. - """ - handles = result.result_handles - handles.wait_for_all_values() # for async replace with ``handles.is_processing()`` - results = {} - for acquisition in acquisitions: - data = acquisition.fetch(handles) - for serial, result in zip(acquisition.keys, data): - results[acquisition.qubit] = results[serial] = result - return results diff --git a/src/qibolab/instruments/qm/config.py b/src/qibolab/instruments/qm/config.py deleted file mode 100644 index 41c1f3e4af..0000000000 --- a/src/qibolab/instruments/qm/config.py +++ /dev/null @@ -1,389 +0,0 @@ -import math -from dataclasses import dataclass, field - -import numpy as np -from qibo.config import raise_error - -from qibolab.pulses import PulseType, Rectangular - -from .ports import OPXIQ, OctaveInput, OctaveOutput, OPXOutput - -SAMPLING_RATE = 1 -"""Sampling rate of Quantum Machines OPX in GSps.""" - -DEFAULT_INPUTS = {1: {}, 2: {}} -"""Default controller config section. - -Inputs are always registered to avoid issues with automatic mixer -calibration when using Octaves. -""" - - -@dataclass -class QMConfig: - """Configuration for communicating with the ``QuantumMachinesManager``.""" - - version: int = 1 - controllers: dict = field(default_factory=dict) - octaves: dict = field(default_factory=dict) - elements: dict = field(default_factory=dict) - pulses: dict = field(default_factory=dict) - waveforms: dict = field(default_factory=dict) - digital_waveforms: dict = field( - default_factory=lambda: {"ON": {"samples": [(1, 0)]}} - ) - integration_weights: dict = field(default_factory=dict) - mixers: dict = field(default_factory=dict) - - def register_port(self, port): - """Register controllers and octaves sections in the ``config``. - - Args: - ports (QMPort): Port we are registering. - Contains information about the controller and port number and - some parameters, such as offset, gain, filter, etc.). - """ - if isinstance(port, OPXIQ): - self.register_port(port.i) - self.register_port(port.q) - else: - is_octave = isinstance(port, (OctaveOutput, OctaveInput)) - controllers = self.octaves if is_octave else self.controllers - if port.device not in controllers: - if is_octave: - controllers[port.device] = {} - else: - controllers[port.device] = { - "analog_inputs": DEFAULT_INPUTS, - "digital_outputs": {}, - } - - device = controllers[port.device] - if port.key in device: - device[port.key].update(port.config) - else: - device[port.key] = port.config - - if is_octave: - con = port.opx_port.i.device - number = port.opx_port.i.number - device["connectivity"] = con - self.register_port(port.opx_port) - self.controllers[con]["digital_outputs"][number] = {} - - @staticmethod - def iq_imbalance(g, phi): - """Creates the correction matrix for the mixer imbalance caused by the - gain and phase imbalances. - - More information here: - https://docs.qualang.io/libs/examples/mixer-calibration/#non-ideal-mixer - - Args: - g (float): relative gain imbalance between the I & Q ports (unit-less). - Set to 0 for no gain imbalance. - phi (float): relative phase imbalance between the I & Q ports (radians). - Set to 0 for no phase imbalance. - """ - c = np.cos(phi) - s = np.sin(phi) - N = 1 / ((1 - g**2) * (2 * c**2 - 1)) - return [ - float(N * x) for x in [(1 - g) * c, (1 + g) * s, (1 - g) * s, (1 + g) * c] - ] - - def _new_frequency_element(self, qubit, intermediate_frequency, mode="drive"): - """Register element on existing port but with different frequency.""" - element = f"{mode}{qubit.name}" - current_if = self.elements[element]["intermediate_frequency"] - if intermediate_frequency == current_if: - return element - - if isinstance(getattr(qubit, mode).port, (OPXIQ, OPXOutput)): - raise NotImplementedError( - f"Cannot play two different frequencies on the same {mode} line." - ) - new_element = f"{element}_{intermediate_frequency}" - self.elements[new_element] = dict(self.elements[element]) - self.elements[new_element]["intermediate_frequency"] = intermediate_frequency - return new_element - - def register_drive_element(self, qubit, intermediate_frequency=0): - """Register qubit drive elements and controllers in the QM config. - - Args: - qubit (:class:`qibolab.platforms.utils.Qubit`): Qubit to add elements for. - intermediate_frequency (int): Intermediate frequency that the OPX - will send to this qubit. This frequency will be mixed with the - LO connected to the same channel. - """ - element = f"drive{qubit.name}" - if element in self.elements: - return self._new_frequency_element(qubit, intermediate_frequency, "drive") - - if isinstance(qubit.drive.port, OPXIQ): - lo_frequency = math.floor(qubit.drive.lo_frequency) - self.elements[element] = { - "mixInputs": { - "I": qubit.drive.port.i.pair, - "Q": qubit.drive.port.q.pair, - "lo_frequency": lo_frequency, - "mixer": f"mixer_drive{qubit.name}", - }, - } - drive_g = qubit.mixer_drive_g - drive_phi = qubit.mixer_drive_phi - self.mixers[f"mixer_drive{qubit.name}"] = [ - { - "intermediate_frequency": intermediate_frequency, - "lo_frequency": lo_frequency, - "correction": self.iq_imbalance(drive_g, drive_phi), - } - ] - else: - self.elements[element] = { - "RF_inputs": {"port": qubit.drive.port.pair}, - "digitalInputs": qubit.drive.port.digital_inputs, - } - self.elements[element].update( - { - "intermediate_frequency": intermediate_frequency, - "operations": {}, - } - ) - return element - - def register_readout_element( - self, qubit, intermediate_frequency=0, time_of_flight=0, smearing=0 - ): - """Register resonator elements and controllers in the QM config. - - Args: - qubit (:class:`qibolab.platforms.utils.Qubit`): Qubit to add elements for. - intermediate_frequency (int): Intermediate frequency that the OPX - will send to this qubit. This frequency will be mixed with the - LO connected to the same channel. - """ - element = f"readout{qubit.name}" - if element in self.elements: - return self._new_frequency_element(qubit, intermediate_frequency, "readout") - - if isinstance(qubit.readout.port, OPXIQ): - lo_frequency = math.floor(qubit.readout.lo_frequency) - self.elements[element] = { - "mixInputs": { - "I": qubit.readout.port.i.pair, - "Q": qubit.readout.port.q.pair, - "lo_frequency": lo_frequency, - "mixer": f"mixer_readout{qubit.name}", - }, - "outputs": { - "out1": qubit.feedback.port.i.pair, - "out2": qubit.feedback.port.q.pair, - }, - } - readout_g = qubit.mixer_readout_g - readout_phi = qubit.mixer_readout_phi - self.mixers[f"mixer_readout{qubit.name}"] = [ - { - "intermediate_frequency": intermediate_frequency, - "lo_frequency": lo_frequency, - "correction": self.iq_imbalance(readout_g, readout_phi), - } - ] - else: - self.elements[element] = { - "RF_inputs": {"port": qubit.readout.port.pair}, - "RF_outputs": {"port": qubit.feedback.port.pair}, - "digitalInputs": qubit.readout.port.digital_inputs, - } - self.elements[element].update( - { - "intermediate_frequency": intermediate_frequency, - "operations": {}, - "time_of_flight": time_of_flight, - "smearing": smearing, - } - ) - return element - - def register_flux_element(self, qubit, intermediate_frequency=0): - """Register qubit flux elements and controllers in the QM config. - - Args: - qubit (:class:`qibolab.platforms.utils.Qubit`): Qubit to add elements for. - intermediate_frequency (int): Intermediate frequency that the OPX - will send to this qubit. This frequency will be mixed with the - LO connected to the same channel. - """ - element = f"flux{qubit.name}" - if element in self.elements: - return self._new_frequency_element(qubit, intermediate_frequency, "flux") - - self.elements[element] = { - "singleInput": { - "port": qubit.flux.port.pair, - }, - "intermediate_frequency": intermediate_frequency, - "operations": {}, - } - return element - - def register_element(self, qubit, pulse, time_of_flight=0, smearing=0): - if pulse.type is PulseType.DRIVE: - # register drive element - if_frequency = pulse.frequency - math.floor(qubit.drive.lo_frequency) - element = self.register_drive_element(qubit, if_frequency) - # register flux element (if available) - if qubit.flux: - self.register_flux_element(qubit) - elif pulse.type is PulseType.READOUT: - # register readout element (if it does not already exist) - if_frequency = pulse.frequency - math.floor(qubit.readout.lo_frequency) - element = self.register_readout_element( - qubit, if_frequency, time_of_flight, smearing - ) - # register flux element (if available) - if qubit.flux: - self.register_flux_element(qubit) - else: - # register flux element - element = self.register_flux_element(qubit, pulse.frequency) - return element - - def register_pulse(self, qubit, qmpulse): - """Registers pulse, waveforms and integration weights in QM config. - - Args: - qubit (:class:`qibolab.platforms.utils.Qubit`): Qubit that the pulse acts on. - pulse (:class:`qibolab.pulses.Pulse`): Pulse object to register. - - Returns: - element (str): Name of the element this pulse will be played on. - Elements are a part of the QM config and are generated during - instantiation of the Qubit objects. They are named as - "drive0", "drive1", "flux0", "readout0", ... - """ - pulse = qmpulse.pulse - if qmpulse.operation not in self.pulses: - if pulse.type is PulseType.DRIVE: - serial_i = self.register_waveform(pulse, "i") - serial_q = self.register_waveform(pulse, "q") - self.pulses[qmpulse.operation] = { - "operation": "control", - "length": pulse.duration, - "waveforms": {"I": serial_i, "Q": serial_q}, - "digital_marker": "ON", - } - # register drive pulse in elements - self.elements[qmpulse.element]["operations"][ - qmpulse.operation - ] = qmpulse.operation - - elif pulse.type is PulseType.FLUX: - serial = self.register_waveform(pulse) - self.pulses[qmpulse.operation] = { - "operation": "control", - "length": pulse.duration, - "waveforms": { - "single": serial, - }, - } - # register flux pulse in elements - self.elements[qmpulse.element]["operations"][ - qmpulse.operation - ] = qmpulse.operation - - elif pulse.type is PulseType.READOUT: - serial_i = self.register_waveform(pulse, "i") - serial_q = self.register_waveform(pulse, "q") - self.register_integration_weights(qubit, pulse.duration) - self.pulses[qmpulse.operation] = { - "operation": "measurement", - "length": pulse.duration, - "waveforms": { - "I": serial_i, - "Q": serial_q, - }, - "integration_weights": { - "cos": f"cosine_weights{qubit.name}", - "sin": f"sine_weights{qubit.name}", - "minus_sin": f"minus_sine_weights{qubit.name}", - }, - "digital_marker": "ON", - } - # register readout pulse in elements - self.elements[qmpulse.element]["operations"][ - qmpulse.operation - ] = qmpulse.operation - - else: - raise_error(TypeError, f"Unknown pulse type {pulse.type.name}.") - - def register_waveform(self, pulse, mode="i"): - """Registers waveforms in QM config. - - QM supports two kinds of waveforms, examples: - "zero_wf": {"type": "constant", "sample": 0.0} - "x90_wf": {"type": "arbitrary", "samples": x90_wf.tolist()} - - Args: - pulse (:class:`qibolab.pulses.Pulse`): Pulse object to read the waveform from. - mode (str): "i" or "q" specifying which channel the waveform will be played. - - Returns: - serial (str): String with a serialization of the waveform. - Used as key to identify the waveform in the config. - """ - if pulse.type is PulseType.READOUT and mode == "q": - # Force zero q waveforms for readout - serial = "zero_wf" - if serial not in self.waveforms: - self.waveforms[serial] = {"type": "constant", "sample": 0.0} - elif isinstance(pulse.shape, Rectangular): - serial = f"constant_wf{pulse.amplitude}" - if serial not in self.waveforms: - self.waveforms[serial] = {"type": "constant", "sample": pulse.amplitude} - else: - waveform = getattr(pulse, f"envelope_waveform_{mode}")(SAMPLING_RATE) - serial = waveform.serial - if serial not in self.waveforms: - self.waveforms[serial] = { - "type": "arbitrary", - "samples": waveform.data.tolist(), - } - return serial - - def register_integration_weights(self, qubit, readout_len): - """Registers integration weights in QM config. - - Args: - qubit (:class:`qibolab.platforms.quantum_machines.Qubit`): Qubit - object that the integration weights will be used for. - readout_len (int): Duration of the readout pulse in ns. - """ - angle = 0 - cos, sin = np.cos(angle), np.sin(angle) - if qubit.kernel is None: - convert = lambda x: [(x, readout_len)] - else: - cos = qubit.kernel * cos - sin = qubit.kernel * sin - convert = lambda x: x - - self.integration_weights.update( - { - f"cosine_weights{qubit.name}": { - "cosine": convert(cos), - "sine": convert(-sin), - }, - f"sine_weights{qubit.name}": { - "cosine": convert(sin), - "sine": convert(cos), - }, - f"minus_sine_weights{qubit.name}": { - "cosine": convert(-sin), - "sine": convert(-cos), - }, - } - ) diff --git a/src/qibolab/instruments/qm/controller.py b/src/qibolab/instruments/qm/controller.py deleted file mode 100644 index 08d3f23f6e..0000000000 --- a/src/qibolab/instruments/qm/controller.py +++ /dev/null @@ -1,403 +0,0 @@ -import shutil -import tempfile -from dataclasses import dataclass, field -from pathlib import Path -from typing import Dict, Optional - -from qm import QuantumMachinesManager, SimulationConfig, generate_qua_script, qua -from qm.octave import QmOctaveConfig -from qm.qua import declare, for_ -from qm.simulate.credentials import create_credentials -from qualang_tools.simulator_tools import create_simulator_controller_connections - -from qibolab import AveragingMode -from qibolab.instruments.abstract import Controller -from qibolab.pulses import PulseType -from qibolab.sweeper import Parameter -from qibolab.unrolling import Bounds - -from .acquisition import declare_acquisitions, fetch_results -from .config import SAMPLING_RATE, QMConfig -from .devices import Octave, OPXplus -from .ports import OPXIQ -from .sequence import BakedPulse, QMPulse, Sequence -from .sweepers import sweep - -OCTAVE_ADDRESS_OFFSET = 11000 -"""Offset to be added to Octave addresses, because they must be 11xxx, where -xxx are the last three digits of the Octave IP address.""" -CALIBRATION_DB = "calibration_db.json" -"""Name of the file where the mixer calibration is stored.""" - - -def declare_octaves(octaves, host, calibration_path=None): - """Initiate Octave configuration and add octaves info. - - Args: - octaves (dict): Dictionary containing :class:`qibolab.instruments.qm.devices.Octave` objects - for each Octave device in the experiment configuration. - host (str): IP of the Quantum Machines controller. - calibration_path (str): Path to the JSON file with the mixer calibration. - """ - if len(octaves) == 0: - return None - - config = QmOctaveConfig() - if calibration_path is not None: - config.set_calibration_db(calibration_path) - for octave in octaves.values(): - config.add_device_info(octave.name, host, OCTAVE_ADDRESS_OFFSET + octave.port) - return config - - -def find_baking_pulses(sweepers): - """Find pulses that require baking because we are sweeping their duration. - - Args: - sweepers (list): List of :class:`qibolab.sweeper.Sweeper` objects. - """ - to_bake = set() - for sweeper in sweepers: - values = sweeper.values - step = values[1] - values[0] if len(values) > 0 else values[0] - if sweeper.parameter is Parameter.duration and step % 4 != 0: - for pulse in sweeper.pulses: - to_bake.add(pulse.serial) - - return to_bake - - -def controllers_config(qubits, time_of_flight, smearing=0): - """Create a Quantum Machines configuration without pulses. - - This contains the readout and drive elements and controllers and - is used by :meth:`qibolab.instruments.qm.controller.QMController.calibrate_mixers`. - - Args: - qubits (list): List of :class:`qibolab.qubits.Qubit` objects to be - included in the config. - time_of_flight (int): Time of flight used on readout elements. - smearing (int): Smearing used on readout elements. - """ - config = QMConfig() - for qubit in qubits: - if qubit.readout is not None: - config.register_port(qubit.readout.port) - config.register_readout_element( - qubit, qubit.mixer_frequencies["MZ"][1], time_of_flight, smearing - ) - if qubit.drive is not None: - config.register_port(qubit.drive.port) - config.register_drive_element(qubit, qubit.mixer_frequencies["RX"][1]) - return config - - -@dataclass -class QMController(Controller): - """:class:`qibolab.instruments.abstract.Controller` object for controlling - a Quantum Machines cluster. - - A cluster consists of multiple :class:`qibolab.instruments.qm.devices.QMDevice` devices. - - Playing pulses on QM controllers requires a ``config`` dictionary and a program - written in QUA language. - The ``config`` file is generated in parts in :class:`qibolab.instruments.qm.config.QMConfig`. - Controllers, elements and pulses are all registered after a pulse sequence is given, so that - the config contains only elements related to the participating qubits. - The QUA program for executing an arbitrary :class:`qibolab.pulses.PulseSequence` is written in - :meth:`qibolab.instruments.qm.controller.QMController.play` and executed in - :meth:`qibolab.instruments.qm.controller.QMController.execute_program`. - """ - - name: str - """Name of the instrument instance.""" - address: str - """IP address and port for connecting to the OPX instruments. - - Has the form XXX.XXX.XXX.XXX:XXX. - """ - - opxs: Dict[int, OPXplus] = field(default_factory=dict) - """Dictionary containing the - :class:`qibolab.instruments.qm.devices.OPXplus` instruments being used.""" - octaves: Dict[int, Octave] = field(default_factory=dict) - """Dictionary containing the :class:`qibolab.instruments.qm.devices.Octave` - instruments being used.""" - - time_of_flight: int = 0 - """Time of flight used for hardware signal integration.""" - smearing: int = 0 - """Smearing used for hardware signal integration.""" - bounds: Bounds = Bounds(0, 0, 0) - """Maximum bounds used for batching in sequence unrolling.""" - calibration_path: Optional[str] = None - """Path to the JSON file that contains the mixer calibration.""" - write_calibration: bool = False - """Require writing permissions on calibration DB.""" - _calibration_path: Optional[str] = None - """The calibration path for internal use. - - Cf. :attr:`calibration_path` for its role. This might be set to a different one - internally to avoid writing attempts over a file for which the user has only read - access (because TinyDB, through QUA, is often attempting to open it in append mode). - """ - script_file_name: Optional[str] = None - """Name of the file that the QUA program will dumped in that after every - execution. - - If ``None`` the program will not be dumped. - """ - - manager: Optional[QuantumMachinesManager] = None - """Manager object used for controlling the Quantum Machines cluster.""" - config: QMConfig = field(default_factory=QMConfig) - """Configuration dictionary required for pulse execution on the OPXs.""" - is_connected: bool = False - """Boolean that shows whether we are connected to the QM manager.""" - - simulation_duration: Optional[int] = None - """Duration for the simulation in ns. - - If given the simulator will be used instead of actual hardware - execution. - """ - cloud: bool = False - """If ``True`` the QM cloud simulator is used which does not require access - to physical instruments. - - This assumes that a proper cloud address has been given. - If ``False`` and ``simulation_duration`` was given, then the built-in simulator - of the instruments is used. This requires connection to instruments. - Default is ``False``. - """ - - def __post_init__(self): - super().__init__(self.name, self.address) - # redefine bounds because abstract instrument overwrites them - self.bounds = Bounds( - waveforms=int(4e4), - readout=30, - instructions=int(1e6), - ) - # convert lists to dicts - if not isinstance(self.opxs, dict): - self.opxs = {instr.name: instr for instr in self.opxs} - if not isinstance(self.octaves, dict): - self.octaves = {instr.name: instr for instr in self.octaves} - - if self.simulation_duration is not None: - # convert simulation duration from ns to clock cycles - self.simulation_duration //= 4 - - def ports(self, name, output=True): - """Provides instrument ports to the user. - - Note that individual ports can also be accessed from the corresponding devices - using :meth:`qibolab.instruments.qm.devices.QMDevice.ports`. - - Args: - name (tuple): Contains the numbers of controller and port to be obtained. - For example ``((conX, Y),)`` returns port-Y of OPX+ controller X. - ``((conX, Y), (conX, Z))`` returns port-Y and Z of OPX+ controller X - as an :class:`qibolab.instruments.qm.ports.OPXIQ` port pair. - output (bool): ``True`` for obtaining an output port, otherwise an - input port is returned. Default is ``True``. - """ - if len(name) == 1: - con, port = name[0] - return self.opxs[con].ports(port, output) - elif len(name) == 2: - (con1, port1), (con2, port2) = name - return OPXIQ( - self.opxs[con1].ports(port1, output), - self.opxs[con2].ports(port2, output), - ) - else: - raise ValueError(f"Invalid port {name} for Quantum Machines controller.") - - @property - def sampling_rate(self): - """Sampling rate of Quantum Machines instruments.""" - return SAMPLING_RATE - - def _temporary_calibration(self): - if self.calibration_path is not None: - if self.write_calibration: - self._calibration_path = self.calibration_path - else: - self._calibration_path = tempfile.mkdtemp() - shutil.copy( - Path(self.calibration_path) / CALIBRATION_DB, - Path(self._calibration_path) / CALIBRATION_DB, - ) - - def _reset_temporary_calibration(self): - if self._calibration_path != self.calibration_path: - assert self._calibration_path is not None - shutil.rmtree(self._calibration_path) - self._calibration_path = None - - def connect(self): - """Connect to the Quantum Machines manager.""" - host, port = self.address.split(":") - self._temporary_calibration() - octave = declare_octaves(self.octaves, host, self._calibration_path) - credentials = None - if self.cloud: - credentials = create_credentials() - self.manager = QuantumMachinesManager( - host=host, port=int(port), octave=octave, credentials=credentials - ) - self.is_connected = True - - def disconnect(self): - """Disconnect from QM manager.""" - self._reset_temporary_calibration() - if self.manager is not None: - self.manager.close_all_quantum_machines() - self.manager.close() - self.is_connected = False - - def calibrate_mixers(self, qubits): - """Calibrate Octave mixers for readout and drive lines of given qubits. - - Args: - qubits (list): List of :class:`qibolab.qubits.Qubit` objects for - which mixers will be calibrated. - """ - if isinstance(qubits, dict): - qubits = list(qubits.values()) - - config = controllers_config(qubits, self.time_of_flight, self.smearing) - machine = self.manager.open_qm(config.__dict__) - for qubit in qubits: - print(f"Calibrating mixers for qubit {qubit.name}") - if qubit.readout is not None: - _lo, _if = qubit.mixer_frequencies["MZ"] - machine.calibrate_element(f"readout{qubit.name}", {_lo: (_if,)}) - if qubit.drive is not None: - _lo, _if = qubit.mixer_frequencies["RX"] - machine.calibrate_element(f"drive{qubit.name}", {_lo: (_if,)}) - - def execute_program(self, program): - """Executes an arbitrary program written in QUA language. - - Args: - program: QUA program. - """ - machine = self.manager.open_qm(self.config.__dict__) - return machine.execute(program) - - def simulate_program(self, program): - """Simulates an arbitrary program written in QUA language. - - Args: - program: QUA program. - """ - ncontrollers = len(self.config.controllers) - controller_connections = create_simulator_controller_connections(ncontrollers) - simulation_config = SimulationConfig( - duration=self.simulation_duration, - controller_connections=controller_connections, - ) - return self.manager.simulate(self.config.__dict__, program, simulation_config) - - def create_sequence(self, qubits, sequence, sweepers): - """Translates a :class:`qibolab.pulses.PulseSequence` to a - :class:`qibolab.instruments.qm.sequence.Sequence`. - - Args: - qubits (list): List of :class:`qibolab.platforms.abstract.Qubit` objects - passed from the platform. - sequence (:class:`qibolab.pulses.PulseSequence`). Pulse sequence to translate. - sweepers (list): List of sweeper objects so that pulses that require baking are identified. - Returns: - (:class:`qibolab.instruments.qm.sequence.Sequence`) containing the pulses from given pulse sequence. - """ - # Current driver cannot play overlapping pulses on drive and flux channels - # If we want to play overlapping pulses we need to define different elements on the same ports - # like we do for readout multiplex - - pulses_to_bake = find_baking_pulses(sweepers) - - qmsequence = Sequence() - ro_pulses = [] - for pulse in sorted( - sequence.pulses, key=lambda pulse: (pulse.start, pulse.duration) - ): - qubit = qubits[pulse.qubit] - - self.config.register_port(getattr(qubit, pulse.type.name.lower()).port) - if pulse.type is PulseType.READOUT: - self.config.register_port(qubit.feedback.port) - - element = self.config.register_element( - qubit, pulse, self.time_of_flight, self.smearing - ) - if ( - pulse.duration % 4 != 0 - or pulse.duration < 16 - or pulse.serial in pulses_to_bake - ): - qmpulse = BakedPulse(pulse, element) - qmpulse.bake(self.config, durations=[pulse.duration]) - else: - qmpulse = QMPulse(pulse, element) - if pulse.type is PulseType.READOUT: - ro_pulses.append(qmpulse) - self.config.register_pulse(qubit, qmpulse) - qmsequence.add(qmpulse) - - qmsequence.shift() - return qmsequence, ro_pulses - - def play(self, qubits, couplers, sequence, options): - return self.sweep(qubits, couplers, sequence, options) - - def sweep(self, qubits, couplers, sequence, options, *sweepers): - if not sequence: - return {} - - buffer_dims = [len(sweeper.values) for sweeper in reversed(sweepers)] - if options.averaging_mode is AveragingMode.SINGLESHOT: - buffer_dims.append(options.nshots) - - # register flux elements for all qubits so that they are - # always at sweetspot even when they are not used - for qubit in qubits.values(): - if qubit.flux: - self.config.register_port(qubit.flux.port) - self.config.register_flux_element(qubit) - - qmsequence, ro_pulses = self.create_sequence(qubits, sequence, sweepers) - # play pulses using QUA - with qua.program() as experiment: - n = declare(int) - acquisitions = declare_acquisitions(ro_pulses, qubits, options) - with for_(n, 0, n < options.nshots, n + 1): - sweep( - list(sweepers), - qubits, - qmsequence, - options.relaxation_time, - self.config, - ) - - with qua.stream_processing(): - for acquisition in acquisitions: - acquisition.download(*buffer_dims) - - if self.script_file_name is not None: - with open(self.script_file_name, "w") as file: - file.write(generate_qua_script(experiment, self.config.__dict__)) - - if self.simulation_duration is not None: - result = self.simulate_program(experiment) - results = {} - for qmpulse in ro_pulses: - pulse = qmpulse.pulse - results[pulse.qubit] = results[pulse.serial] = result - return results - else: - result = self.execute_program(experiment) - return fetch_results(result, acquisitions) diff --git a/src/qibolab/instruments/qm/devices.py b/src/qibolab/instruments/qm/devices.py deleted file mode 100644 index 6ec0674d88..0000000000 --- a/src/qibolab/instruments/qm/devices.py +++ /dev/null @@ -1,121 +0,0 @@ -from collections import defaultdict -from dataclasses import dataclass, field -from itertools import chain -from typing import Dict - -from qibolab.instruments.abstract import Instrument - -from .ports import ( - OPXIQ, - OctaveInput, - OctaveOutput, - OPXInput, - OPXOutput, - QMInput, - QMOutput, -) - - -class PortsDefaultdict(defaultdict): - """Dictionary mapping port numbers to - :class:`qibolab.instruments.qm.ports.QMPort` objects. - - Automatically instantiates ports that have not yet been created. - Used by :class:`qibolab.instruments.qm.devices.QMDevice` - - https://stackoverflow.com/questions/2912231/is-there-a-clever-way-to-pass-the-key-to-defaultdicts-default-factory - """ - - def __missing__(self, key): - ret = self[key] = self.default_factory(key) # pylint: disable=E1102 - return ret - - -@dataclass -class QMDevice(Instrument): - """Abstract class for an individual Quantum Machines devices.""" - - name: str - """Name of the device.""" - - outputs: Dict[int, QMOutput] = field(init=False) - """Dictionary containing the instrument's output ports.""" - inputs: Dict[int, QMInput] = field(init=False) - """Dictionary containing the instrument's input ports.""" - - def ports(self, number, output=True): - """Provides instrument's ports to the user. - - Args: - number (int): Port number. - Can be 1 to 10 for :class:`qibolab.instruments.qm.devices.OPXplus` - and 1 to 5 for :class:`qibolab.instruments.qm.devices.Octave`. - output (bool): ``True`` for obtaining an output port, otherwise an - input port is returned. Default is ``True``. - """ - ports_ = self.outputs if output else self.inputs - return ports_[number] - - def connect(self): - """Only applicable for - :class:`qibolab.instruments.qm.controller.QMController`, not individual - devices.""" - - def setup(self, **kwargs): - for name, settings in kwargs.items(): - number = int(name[1:]) - if name[0] == "o": - self.outputs[number].setup(**settings) - elif name[0] == "i": - self.inputs[number].setup(**settings) - else: - raise ValueError( - f"Invalid port name {name} in instrument settings for {self.name}." - ) - - def disconnect(self): - """Only applicable for - :class:`qibolab.instruments.qm.controller.QMController`, not individual - devices.""" - - def dump(self): - """Serializes device settings to a dictionary for dumping to the - runcard YAML.""" - ports = chain(self.outputs.values(), self.inputs.values()) - return {port.name: port.settings for port in ports if len(port.settings) > 0} - - -@dataclass -class OPXplus(QMDevice): - """Device handling OPX+ controllers.""" - - def __post_init__(self): - self.outputs = PortsDefaultdict(lambda n: OPXOutput(self.name, n)) - self.inputs = PortsDefaultdict(lambda n: OPXInput(self.name, n)) - - -@dataclass -class Octave(QMDevice): - """Device handling Octaves.""" - - port: int - """Network port of the Octave in the cluster configuration.""" - connectivity: OPXplus - """OPXplus that acts as the waveform generator for the Octave.""" - - def __post_init__(self): - self.outputs = PortsDefaultdict(lambda n: OctaveOutput(self.name, n)) - self.inputs = PortsDefaultdict(lambda n: OctaveInput(self.name, n)) - - def ports(self, number, output=True): - """Provides Octave ports. - - Extension of the abstract :meth:`qibolab.instruments.qm.devices.QMDevice.ports` - because Octave ports are used for mixing two existing (I, Q) OPX+ ports. - """ - port = super().ports(number, output) - if port.opx_port is None: - iport = self.connectivity.ports(2 * number - 1, output) - qport = self.connectivity.ports(2 * number, output) - port.opx_port = OPXIQ(iport, qport) - return port diff --git a/src/qibolab/instruments/qm/ports.py b/src/qibolab/instruments/qm/ports.py deleted file mode 100644 index 1d6ce2d444..0000000000 --- a/src/qibolab/instruments/qm/ports.py +++ /dev/null @@ -1,196 +0,0 @@ -from dataclasses import dataclass, field, fields -from typing import ClassVar, Dict, Optional, Union - -DIGITAL_DELAY = 57 -DIGITAL_BUFFER = 18 -"""Default calibration parameters for digital pulses. - -https://docs.quantum-machines.co/1.1.7/qm-qua-sdk/docs/Guides/octave/#calibrating-the-digital-pulse - -Digital markers are used for LO triggering. -""" - - -@dataclass -class QMPort: - """Abstract representation of Quantum Machine instrument ports. - - Contains the ports settings for each device. - """ - - device: str - """Name of the device holding this port.""" - number: int - """Number of this port in the device.""" - - key: ClassVar[Optional[str]] = None - """Key corresponding to this port type in the Quantum Machines config. - - Used in :meth:`qibolab.instruments.qm.config.QMConfig.register_port`. - """ - - @property - def pair(self): - """Representation of the port in the Quantum Machines config.""" - return (self.device, self.number) - - def setup(self, **kwargs): - """Updates port settings.""" - for name, value in kwargs.items(): - if not hasattr(self, name): - raise KeyError(f"Unknown port setting {name}.") - setattr(self, name, value) - - @property - def settings(self): - """Serialization of the port settings to dump in the runcard YAML. - - Only fields that provide the ``metadata['settings']`` flag are dumped - in the serialization. - """ - return { - fld.name: getattr(self, fld.name) - for fld in fields(self) - if fld.metadata.get("settings", False) - } - - @property - def config(self): - """Port settings in the format of the Quantum Machines config. - - Field ``metadata['config']`` are used to translate qibolab port setting names - to the corresponding Quantum Machine config properties. - """ - data = {} - for fld in fields(self): - if "config" in fld.metadata: - data[fld.metadata["config"]] = getattr(self, fld.name) - return {self.number: data} - - -class QMOutput(QMPort): - """Abstract Quantum Machines output port.""" - - @property - def name(self): - """Name of the port when dumping instrument settings on the runcard - YAML.""" - return f"o{self.number}" - - -class QMInput(QMPort): - """Abstract Quantum Machines input port.""" - - @property - def name(self): - """Name of the port when dumping instrument settings on the runcard - YAML.""" - return f"i{self.number}" - - -@dataclass -class OPXOutput(QMOutput): - key: ClassVar[str] = "analog_outputs" - - offset: float = field(default=0.0, metadata={"config": "offset"}) - """Constant voltage to be applied on the output.""" - filter: Dict[str, float] = field( - default_factory=dict, metadata={"config": "filter", "settings": True} - ) - """FIR and IIR filters to be applied to correct signal distortions.""" - - @property - def settings(self): - """OPX+ output settings to be dumped to the runcard YAML. - - Filter is removed if empty to simplify the runcard. - """ - data = super().settings - if len(self.filter) == 0: - del data["filter"] - return data - - -@dataclass -class OPXInput(QMInput): - key: ClassVar[str] = "analog_inputs" - - offset: float = field(default=0.0, metadata={"config": "offset"}) - """Constant voltage to be applied on the output.""" - gain: int = field(default=0, metadata={"config": "gain_db", "settings": True}) - """Gain applied to amplify the input.""" - - -@dataclass -class OPXIQ: - """Pair of I-Q ports.""" - - i: Union[OPXOutput, OPXInput] - """Port implementing the I-component of the signal.""" - q: Union[OPXOutput, OPXInput] - """Port implementing the Q-component of the signal.""" - - -@dataclass -class OctaveOutput(QMOutput): - key: ClassVar[str] = "RF_outputs" - - lo_frequency: float = field( - default=0.0, metadata={"config": "LO_frequency", "settings": True} - ) - """Local oscillator frequency.""" - gain: int = field(default=0, metadata={"config": "gain", "settings": True}) - """Local oscillator gain. - - Can be in the range [-20 : 0.5 : 20] dB. - """ - lo_source: str = field(default="internal", metadata={"config": "LO_source"}) - """Local oscillator clock source. - - Can be external or internal. - """ - output_mode: str = field(default="triggered", metadata={"config": "output_mode"}) - """Can be: "always_on" / "always_off"/ "triggered" / "triggered_reversed".""" - digital_delay: int = DIGITAL_DELAY - """Delay for digital output channel.""" - digital_buffer: int = DIGITAL_BUFFER - """Buffer for digital output channel.""" - - opx_port: Optional[OPXOutput] = None - """OPX+ port that is connected to the Octave port.""" - - @property - def digital_inputs(self): - """Generates `digitalInputs` entry for elements in QM config. - - Digital markers are used to switch LOs on in triggered mode. - """ - opx = self.opx_port.i.device - number = self.opx_port.i.number - return { - "output_switch": { - "port": (opx, number), - "delay": self.digital_delay, - "buffer": self.digital_buffer, - } - } - - -@dataclass -class OctaveInput(QMInput): - key: ClassVar[str] = "RF_inputs" - - lo_frequency: float = field( - default=0.0, metadata={"config": "LO_frequency", "settings": True} - ) - """Local oscillator frequency.""" - lo_source: str = field(default="internal", metadata={"config": "LO_source"}) - """Local oscillator clock source. - - Can be external or internal. - """ - IF_mode_I: str = field(default="direct", metadata={"config": "IF_mode_I"}) - IF_mode_Q: str = field(default="direct", metadata={"config": "IF_mode_Q"}) - - opx_port: Optional[OPXIQ] = None - """OPX+ port that is connected to the Octave port.""" diff --git a/src/qibolab/instruments/qm/sequence.py b/src/qibolab/instruments/qm/sequence.py deleted file mode 100644 index 0e4fa58afd..0000000000 --- a/src/qibolab/instruments/qm/sequence.py +++ /dev/null @@ -1,279 +0,0 @@ -import collections -from dataclasses import dataclass, field -from typing import Dict, List, Optional, Set, Union - -import numpy as np -from numpy import typing as npt -from qm import qua -from qm.qua._dsl import _Variable # for type declaration only -from qualang_tools.bakery import baking -from qualang_tools.bakery.bakery import Baking - -from qibolab.instruments.qm.acquisition import Acquisition -from qibolab.pulses import Pulse, PulseType - -from .config import SAMPLING_RATE, QMConfig - -DurationsType = Union[List[int], npt.NDArray[int]] -"""Type of values that can be accepted in a duration sweeper.""" - - -@dataclass -class QMPulse: - """Wrapper around :class:`qibolab.pulses.Pulse` for easier translation to - QUA program. - - These pulses are defined when :meth:`qibolab.instruments.qm.QMOPX.play` is called - and hold attributes for the ``element`` and ``operation`` that corresponds to each pulse, - as defined in the QM config. - """ - - pulse: Pulse - """:class:`qibolab.pulses.Pulse` corresponding to the ``QMPulse``.""" - element: Optional[str] = None - """Element that the pulse will be played on, as defined in the QM - config.""" - operation: Optional[str] = None - """Name of the operation that is implementing the pulse in the QM - config.""" - relative_phase: Optional[float] = None - """Relative phase of the pulse normalized to follow QM convention. - - May be overwritten when sweeping phase. - """ - wait_time: int = 0 - """Time (in clock cycles) to wait before playing this pulse. - - Calculated and assigned by - :meth: `qibolab.instruments.qm.Sequence.add`. - """ - wait_time_variable: Optional[_Variable] = None - """Time (in clock cycles) to wait before playing this pulse when we are - sweeping start.""" - swept_duration: Optional[_Variable] = None - """Pulse duration when sweeping it.""" - - acquisition: Optional[Acquisition] = None - """Data class containing the variables required for data acquisition for - the instrument.""" - - next_: Set["QMPulse"] = field(default_factory=set) - """Pulses that will be played after the current pulse. - - These pulses need to be re-aligned if we are sweeping the start or - duration. - """ - elements_to_align: Set[str] = field(default_factory=set) - - def __post_init__(self): - pulse_type = self.pulse.type.name.lower() - amplitude = format(self.pulse.amplitude, ".6f").rstrip("0").rstrip(".") - if self.element is None: - self.element = f"{pulse_type}{self.pulse.qubit}" - self.operation: str = ( - f"{pulse_type}({self.pulse.duration}, {amplitude}, {self.pulse.shape})" - ) - self.relative_phase: float = self.pulse.relative_phase / (2 * np.pi) - self.elements_to_align.add(self.element) - - def __hash__(self): - return hash(self.pulse) - - @property - def duration(self): - """Duration of the pulse as defined in the - :class:`qibolab.pulses.PulseSequence`. - - Remains constant even when we are sweeping the duration of this - pulse. - """ - return self.pulse.duration - - @property - def wait_cycles(self): - """Instrument clock cycles (1 cycle = 4ns) to wait before playing the - pulse. - - This property will be used in the QUA ``wait`` command, so that it is compatible - with and without start sweepers. - """ - if self.wait_time_variable is not None: - return self.wait_time_variable + self.wait_time - if self.wait_time >= 4: - return self.wait_time - return None - - def play(self): - """Play the pulse. - - Relevant only in the context of a QUA program. - """ - qua.play(self.operation, self.element, duration=self.swept_duration) - - -@dataclass -class BakedPulse(QMPulse): - """Baking allows 1ns resolution in the pulse waveforms.""" - - segments: List[Baking] = field(default_factory=list) - """Baked segments implementing the pulse.""" - amplitude: Optional[float] = None - """Amplitude of the baked pulse. - - Relevant only when sweeping amplitude. - """ - durations: Optional[DurationsType] = None - - def __hash__(self): - return super().__hash__() - - @property - def duration(self): - return self.segments[-1].get_op_length() - - @staticmethod - def calculate_waveform(original_waveform, t): - if t == 0: # Otherwise, the baking will be empty and will not be created - return [0.0] * 16 - - expanded_waveform = list(original_waveform) - for i in range(t // len(original_waveform)): - expanded_waveform.extend(original_waveform) - return expanded_waveform[:t] - - def bake(self, config: QMConfig, durations: DurationsType): - self.segments = [] - self.durations = durations - for t in durations: - with baking(config.__dict__, padding_method="right") as segment: - if self.pulse.type is PulseType.FLUX: - waveform = self.pulse.envelope_waveform_i( - SAMPLING_RATE - ).data.tolist() - waveform = self.calculate_waveform(waveform, t) - else: - waveform_i = self.pulse.envelope_waveform_i( - SAMPLING_RATE - ).data.tolist() - waveform_q = self.pulse.envelope_waveform_q( - SAMPLING_RATE - ).data.tolist() - waveform = [ - self.calculate_waveform(waveform_i, t), - self.calculate_waveform(waveform_q, t), - ] - segment.add_op(self.operation, self.element, waveform) - segment.play(self.operation, self.element) - self.segments.append(segment) - - @property - def amplitude_array(self): - if self.amplitude is None: - return None - return [(self.element, self.amplitude)] - - def play(self): - if self.swept_duration is not None: - with qua.switch_(self.swept_duration): - for dur, segment in zip(self.durations, self.segments): - with qua.case_(dur): - segment.run(amp_array=self.amplitude_array) - else: - segment = self.segments[0] - segment.run(amp_array=self.amplitude_array) - - -@dataclass -class Sequence: - """Pulse sequence containing QM specific pulses (``qmpulse``). - - Defined in :meth:`qibolab.instruments.qm.QMOPX.play`. - Holds attributes for the ``element`` and ``operation`` that - corresponds to each pulse, as defined in the QM config. - """ - - qmpulses: List[QMPulse] = field(default_factory=list) - """List of :class:`qibolab.instruments.qm.QMPulse` objects corresponding to - the original pulses.""" - pulse_to_qmpulse: Dict[Pulse, QMPulse] = field(default_factory=dict) - """Map from qibolab pulses to QMPulses (useful when sweeping).""" - clock: Dict[str, int] = field(default_factory=lambda: collections.defaultdict(int)) - """Dictionary used to keep track of times of each element, in order to - calculate wait times.""" - pulse_finish: Dict[int, List[QMPulse]] = field( - default_factory=lambda: collections.defaultdict(list) - ) - """Map to find all pulses that finish at a given time (useful for - ``_find_previous``).""" - - def _find_previous(self, pulse): - for finish in reversed(sorted(self.pulse_finish.keys())): - if finish <= pulse.start: - # first try to find a previous pulse targeting the same qubit - last_pulses = self.pulse_finish[finish] - for previous in reversed(last_pulses): - if previous.pulse.qubit == pulse.qubit: - return previous - # otherwise - if finish == pulse.start: - return last_pulses[-1] - return None - - def add(self, qmpulse: QMPulse): - pulse = qmpulse.pulse - self.pulse_to_qmpulse[pulse.serial] = qmpulse - - previous = self._find_previous(pulse) - if previous is not None: - previous.next_.add(qmpulse) - - wait_time = pulse.start - self.clock[qmpulse.element] - if wait_time >= 12: - qmpulse.wait_time = wait_time // 4 + 1 - self.clock[qmpulse.element] += 4 * qmpulse.wait_time - self.clock[qmpulse.element] += qmpulse.duration - - self.pulse_finish[pulse.finish].append(qmpulse) - self.qmpulses.append(qmpulse) - - def shift(self): - """Shift all pulses that come after a ``BakedPulse`` a bit to avoid - overlapping pulses.""" - to_shift = collections.deque() - for qmpulse in self.qmpulses: - if isinstance(qmpulse, BakedPulse): - to_shift.extend(qmpulse.next_) - while to_shift: - qmpulse = to_shift.popleft() - qmpulse.wait_time += 2 - to_shift.extend(qmpulse.next_) - - def play(self, relaxation_time=0): - """Part of QUA program that plays an arbitrary pulse sequence. - - Should be used inside a ``program()`` context. - """ - needs_reset = False - qua.align() - for qmpulse in self.qmpulses: - pulse = qmpulse.pulse - if qmpulse.wait_cycles is not None: - qua.wait(qmpulse.wait_cycles, qmpulse.element) - if pulse.type is PulseType.READOUT: - qmpulse.acquisition.measure(qmpulse.operation, qmpulse.element) - else: - if ( - not isinstance(qmpulse.relative_phase, float) - or qmpulse.relative_phase != 0 - ): - qua.frame_rotation_2pi(qmpulse.relative_phase, qmpulse.element) - needs_reset = True - qmpulse.play() - if needs_reset: - qua.reset_frame(qmpulse.element) - needs_reset = False - if len(qmpulse.elements_to_align) > 1: - qua.align(*qmpulse.elements_to_align) - - if relaxation_time > 0: - qua.wait(relaxation_time // 4) diff --git a/src/qibolab/instruments/qm/sweepers.py b/src/qibolab/instruments/qm/sweepers.py deleted file mode 100644 index 3110e1f3d8..0000000000 --- a/src/qibolab/instruments/qm/sweepers.py +++ /dev/null @@ -1,205 +0,0 @@ -import math - -import numpy as np -from qibo.config import raise_error -from qm import qua -from qm.qua import declare, fixed, for_ -from qualang_tools.loops import from_array - -from qibolab.channels import check_max_offset -from qibolab.instruments.qm.sequence import BakedPulse -from qibolab.pulses import PulseType -from qibolab.sweeper import Parameter - - -def maximum_sweep_value(values, value0): - """Calculates maximum value that is reached during a sweep. - - Useful to check whether a sweep exceeds the range of allowed values. - Note that both the array of values we sweep and the center value can - be negative, so we need to make sure that the maximum absolute value - is within range. - - Args: - values (np.ndarray): Array of values we will sweep over. - value0 (float, int): Center value of the sweep. - """ - return max(abs(min(values) + value0), abs(max(values) + value0)) - - -def _update_baked_pulses(sweeper, qmsequence, config): - """Updates baked pulse if duration sweeper is used.""" - qmpulse = qmsequence.pulse_to_qmpulse[sweeper.pulses[0].serial] - is_baked = isinstance(qmpulse, BakedPulse) - for pulse in sweeper.pulses: - qmpulse = qmsequence.pulse_to_qmpulse[pulse.serial] - if isinstance(qmpulse, BakedPulse): - if not is_baked: - raise_error( - TypeError, - "Duration sweeper cannot contain both baked and not baked pulses.", - ) - values = np.array(sweeper.values).astype(int) - qmpulse.bake(config, values) - - -def sweep(sweepers, qubits, qmsequence, relaxation_time, config): - """Public sweep function that is called by the driver.""" - for sweeper in sweepers: - if sweeper.parameter is Parameter.duration: - _update_baked_pulses(sweeper, qmsequence, config) - _sweep_recursion(sweepers, qubits, qmsequence, relaxation_time) - - -def _sweep_recursion(sweepers, qubits, qmsequence, relaxation_time): - """Unrolls a list of qibolab sweepers to the corresponding QUA for loops - using recursion.""" - if len(sweepers) > 0: - parameter = sweepers[0].parameter.name - func_name = f"_sweep_{parameter}" - if func_name in globals(): - globals()[func_name](sweepers, qubits, qmsequence, relaxation_time) - else: - raise_error( - NotImplementedError, f"Sweeper for {parameter} is not implemented." - ) - else: - qmsequence.play(relaxation_time) - - -def _sweep_frequency(sweepers, qubits, qmsequence, relaxation_time): - sweeper = sweepers[0] - freqs0 = [] - for pulse in sweeper.pulses: - qubit = qubits[pulse.qubit] - if pulse.type is PulseType.DRIVE: - lo_frequency = math.floor(qubit.drive.lo_frequency) - elif pulse.type is PulseType.READOUT: - lo_frequency = math.floor(qubit.readout.lo_frequency) - else: - raise_error( - NotImplementedError, - f"Cannot sweep frequency of pulse of type {pulse.type}.", - ) - # convert to IF frequency for readout and drive pulses - f0 = math.floor(pulse.frequency - lo_frequency) - freqs0.append(declare(int, value=f0)) - # check if sweep is within the supported bandwidth [-400, 400] MHz - max_freq = maximum_sweep_value(sweeper.values, f0) - if max_freq > 4e8: - raise_error( - ValueError, - f"Frequency {max_freq} for qubit {qubit.name} is beyond instrument bandwidth.", - ) - - # is it fine to have this declaration inside the ``nshots`` QUA loop? - f = declare(int) - with for_(*from_array(f, sweeper.values.astype(int))): - for pulse, f0 in zip(sweeper.pulses, freqs0): - qmpulse = qmsequence.pulse_to_qmpulse[pulse.serial] - qua.update_frequency(qmpulse.element, f + f0) - - _sweep_recursion(sweepers[1:], qubits, qmsequence, relaxation_time) - - -def _sweep_amplitude(sweepers, qubits, qmsequence, relaxation_time): - sweeper = sweepers[0] - # TODO: Consider sweeping amplitude without multiplication - if min(sweeper.values) < -2: - raise_error( - ValueError, "Amplitude sweep values are <-2 which is not supported." - ) - if max(sweeper.values) > 2: - raise_error(ValueError, "Amplitude sweep values are >2 which is not supported.") - - a = declare(fixed) - with for_(*from_array(a, sweeper.values)): - for pulse in sweeper.pulses: - qmpulse = qmsequence.pulse_to_qmpulse[pulse.serial] - if isinstance(qmpulse, BakedPulse): - qmpulse.amplitude = a - else: - qmpulse.operation = qmpulse.operation * qua.amp(a) - - _sweep_recursion(sweepers[1:], qubits, qmsequence, relaxation_time) - - -def _sweep_relative_phase(sweepers, qubits, qmsequence, relaxation_time): - sweeper = sweepers[0] - relphase = declare(fixed) - with for_(*from_array(relphase, sweeper.values / (2 * np.pi))): - for pulse in sweeper.pulses: - qmpulse = qmsequence.pulse_to_qmpulse[pulse.serial] - qmpulse.relative_phase = relphase - - _sweep_recursion(sweepers[1:], qubits, qmsequence, relaxation_time) - - -def _sweep_bias(sweepers, qubits, qmsequence, relaxation_time): - sweeper = sweepers[0] - offset0 = [] - for qubit in sweeper.qubits: - b0 = qubit.flux.offset - max_offset = qubit.flux.max_offset - max_value = maximum_sweep_value(sweeper.values, b0) - check_max_offset(max_value, max_offset) - offset0.append(declare(fixed, value=b0)) - b = declare(fixed) - with for_(*from_array(b, sweeper.values)): - for qubit, b0 in zip(sweeper.qubits, offset0): - with qua.if_((b + b0) >= 0.49): - qua.set_dc_offset(f"flux{qubit.name}", "single", 0.49) - with qua.elif_((b + b0) <= -0.49): - qua.set_dc_offset(f"flux{qubit.name}", "single", -0.49) - with qua.else_(): - qua.set_dc_offset(f"flux{qubit.name}", "single", (b + b0)) - - _sweep_recursion(sweepers[1:], qubits, qmsequence, relaxation_time) - - -def _sweep_start(sweepers, qubits, qmsequence, relaxation_time): - sweeper = sweepers[0] - start = declare(int) - values = (np.array(sweeper.values) // 4).astype(int) - - if len(np.unique(values[1:] - values[:-1])) > 1: - loop = qua.for_each_(start, values) - else: - loop = for_(*from_array(start, values)) - - with loop: - for pulse in sweeper.pulses: - qmpulse = qmsequence.pulse_to_qmpulse[pulse.serial] - # find all pulses that are connected to ``qmpulse`` and update their starts - to_process = {qmpulse} - while to_process: - next_qmpulse = to_process.pop() - to_process |= next_qmpulse.next_ - next_qmpulse.wait_time_variable = start - - _sweep_recursion(sweepers[1:], qubits, qmsequence, relaxation_time) - - -def _sweep_duration(sweepers, qubits, qmsequence, relaxation_time): - sweeper = sweepers[0] - qmpulse = qmsequence.pulse_to_qmpulse[sweeper.pulses[0].serial] - if isinstance(qmpulse, BakedPulse): - values = np.array(sweeper.values).astype(int) - else: - values = np.array(sweeper.values).astype(int) // 4 - - dur = declare(int) - with for_(*from_array(dur, values)): - for pulse in sweeper.pulses: - qmpulse = qmsequence.pulse_to_qmpulse[pulse.serial] - qmpulse.swept_duration = dur - # find all pulses that are connected to ``qmpulse`` and align them - if not isinstance(qmpulse, BakedPulse): - to_process = set(qmpulse.next_) - while to_process: - next_qmpulse = to_process.pop() - to_process |= next_qmpulse.next_ - qmpulse.elements_to_align.add(next_qmpulse.element) - next_qmpulse.wait_time -= qmpulse.wait_time + qmpulse.duration // 4 - - _sweep_recursion(sweepers[1:], qubits, qmsequence, relaxation_time) diff --git a/src/qibolab/instruments/rfsoc/__init__.py b/src/qibolab/instruments/rfsoc/__init__.py deleted file mode 100644 index 4b2ba2f1b3..0000000000 --- a/src/qibolab/instruments/rfsoc/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -"""RFSoC module driver for qibosoq.""" - -from .driver import RFSoC diff --git a/src/qibolab/instruments/rfsoc/convert.py b/src/qibolab/instruments/rfsoc/convert.py deleted file mode 100644 index b151682060..0000000000 --- a/src/qibolab/instruments/rfsoc/convert.py +++ /dev/null @@ -1,200 +0,0 @@ -"""Convert helper functions for rfsoc driver.""" - -from copy import deepcopy -from dataclasses import asdict -from functools import singledispatch - -import numpy as np -import qibosoq.components.base as rfsoc -import qibosoq.components.pulses as rfsoc_pulses - -from qibolab.pulses import Pulse, PulseSequence, PulseShape -from qibolab.qubits import Qubit -from qibolab.sweeper import BIAS, DURATION, START, Parameter, Sweeper - -HZ_TO_MHZ = 1e-6 -NS_TO_US = 1e-3 - - -def replace_pulse_shape( - rfsoc_pulse: rfsoc_pulses.Pulse, shape: PulseShape, sampling_rate: float -) -> rfsoc_pulses.Pulse: - """Set pulse shape parameters in rfsoc_pulses pulse object.""" - if shape.name not in {"Gaussian", "Drag", "Rectangular", "Exponential"}: - new_pulse = rfsoc_pulses.Arbitrary( - **asdict(rfsoc_pulse), - i_values=shape.envelope_waveform_i(sampling_rate), - q_values=shape.envelope_waveform_q(sampling_rate), - ) - return new_pulse - new_pulse_cls = getattr(rfsoc_pulses, shape.name) - if shape.name == "Rectangular": - return new_pulse_cls(**asdict(rfsoc_pulse)) - if shape.name == "Gaussian": - return new_pulse_cls(**asdict(rfsoc_pulse), rel_sigma=shape.rel_sigma) - if shape.name == "Drag": - return new_pulse_cls( - **asdict(rfsoc_pulse), rel_sigma=shape.rel_sigma, beta=shape.beta - ) - if shape.name == "Exponential": - return new_pulse_cls( - **asdict(rfsoc_pulse), tau=shape.tau, upsilon=shape.upsilon, weight=shape.g - ) - - -def pulse_lo_frequency(pulse: Pulse, qubits: dict[int, Qubit]) -> int: - """Return local_oscillator frequency (HZ) of a pulse.""" - pulse_type = pulse.type.name.lower() - try: - lo_frequency = getattr( - qubits[pulse.qubit], pulse_type - ).local_oscillator.frequency - except AttributeError: - lo_frequency = 0 - return lo_frequency - - -def convert_units_sweeper( - sweeper: rfsoc.Sweeper, sequence: PulseSequence, qubits: dict[int, Qubit] -) -> rfsoc.Sweeper: - """Convert units for `qibosoq.abstract.Sweeper` considering also LOs.""" - sweeper = deepcopy(sweeper) - for idx, jdx in enumerate(sweeper.indexes): - parameter = sweeper.parameters[idx] - if parameter is rfsoc.Parameter.FREQUENCY: - pulse = sequence[jdx] - lo_frequency = pulse_lo_frequency(pulse, qubits) - sweeper.starts[idx] = (sweeper.starts[idx] - lo_frequency) * HZ_TO_MHZ - sweeper.stops[idx] = (sweeper.stops[idx] - lo_frequency) * HZ_TO_MHZ - elif parameter is rfsoc.Parameter.DELAY: - sweeper.starts[idx] *= NS_TO_US - sweeper.stops[idx] *= NS_TO_US - elif parameter is rfsoc.Parameter.RELATIVE_PHASE: - sweeper.starts[idx] = np.degrees(sweeper.starts[idx]) - sweeper.stops[idx] = np.degrees(sweeper.stops[idx]) - return sweeper - - -@singledispatch -def convert(*args): - """Convert from qibolab obj to qibosoq obj, overloaded.""" - raise ValueError(f"Convert function received bad parameters ({type(args[0])}).") - - -@convert.register -def _(qubit: Qubit) -> rfsoc.Qubit: - """Convert `qibolab.platforms.abstract.Qubit` to - `qibosoq.abstract.Qubit`.""" - if qubit.flux: - return rfsoc.Qubit(qubit.flux.offset, qubit.flux.port.name) - return rfsoc.Qubit(0.0, None) - - -@convert.register -def _( - sequence: PulseSequence, qubits: dict[int, Qubit], sampling_rate: float -) -> list[rfsoc_pulses.Pulse]: - """Convert PulseSequence to list of rfosc pulses with relative time.""" - last_pulse_start = 0 - list_sequence = [] - for pulse in sorted(sequence.pulses, key=lambda item: item.start): - start_delay = (pulse.start - last_pulse_start) * NS_TO_US - pulse_dict = asdict(convert(pulse, qubits, start_delay, sampling_rate)) - list_sequence.append(pulse_dict) - - last_pulse_start = pulse.start - return list_sequence - - -@convert.register -def _( - pulse: Pulse, qubits: dict[int, Qubit], start_delay: float, sampling_rate: float -) -> rfsoc_pulses.Pulse: - """Convert `qibolab.pulses.pulse` to `qibosoq.abstract.Pulse`.""" - pulse_type = pulse.type.name.lower() - dac = getattr(qubits[pulse.qubit], pulse_type).port.name - adc = qubits[pulse.qubit].feedback.port.name if pulse_type == "readout" else None - lo_frequency = pulse_lo_frequency(pulse, qubits) - - rfsoc_pulse = rfsoc_pulses.Pulse( - frequency=(pulse.frequency - lo_frequency) * HZ_TO_MHZ, - amplitude=pulse.amplitude, - relative_phase=np.degrees(pulse.relative_phase), - start_delay=start_delay, - duration=pulse.duration * NS_TO_US, - dac=dac, - adc=adc, - name=pulse.serial, - type=pulse_type, - ) - return replace_pulse_shape(rfsoc_pulse, pulse.shape, sampling_rate) - - -@convert.register -def _(par: Parameter) -> rfsoc.Parameter: - """Convert a qibolab sweeper.Parameter into a qibosoq.Parameter.""" - return getattr(rfsoc.Parameter, par.name.upper()) - - -@convert.register -def _( - sweeper: Sweeper, sequence: PulseSequence, qubits: dict[int, Qubit] -) -> rfsoc.Sweeper: - """Convert `qibolab.sweeper.Sweeper` to `qibosoq.abstract.Sweeper`. - - Note that any unit conversion is not done in this function (to avoid - to do it multiple times). Conversion will be done in - `convert_units_sweeper`. - """ - parameters = [] - starts = [] - stops = [] - indexes = [] - - if sweeper.parameter is BIAS: - for qubit in sweeper.qubits: - parameters.append(rfsoc.Parameter.BIAS) - indexes.append(list(qubits.values()).index(qubit)) - base_value = qubit.flux.offset - values = sweeper.get_values(base_value) - starts.append(values[0]) - stops.append(values[-1]) - - if max(np.abs(starts)) > 1 or max(np.abs(stops)) > 1: - raise ValueError("Sweeper amplitude is set to reach values higher than 1") - else: - for pulse in sweeper.pulses: - idx_sweep = sequence.index(pulse) - indexes.append(idx_sweep) - base_value = getattr(pulse, sweeper.parameter.name) - if idx_sweep != 0 and sweeper.parameter is START: - # do the conversion from start to delay - base_value = base_value - sequence[idx_sweep - 1].start - values = sweeper.get_values(base_value) - starts.append(values[0]) - stops.append(values[-1]) - - if sweeper.parameter is START: - parameters.append(rfsoc.Parameter.DELAY) - elif sweeper.parameter is DURATION: - parameters.append(rfsoc.Parameter.DURATION) - delta_start = values[0] - base_value - delta_stop = values[-1] - base_value - - if len(sequence) > idx_sweep + 1: - # if duration-swept pulse is not last - indexes.append(idx_sweep + 1) - t_start = sequence[idx_sweep + 1].start - sequence[idx_sweep].start - parameters.append(rfsoc.Parameter.DELAY) - starts.append(t_start + delta_start) - stops.append(t_start + delta_stop) - else: - parameters.append(convert(sweeper.parameter)) - - return rfsoc.Sweeper( - parameters=parameters, - indexes=indexes, - starts=starts, - stops=stops, - expts=len(sweeper.values), - ) diff --git a/src/qibolab/instruments/rfsoc/driver.py b/src/qibolab/instruments/rfsoc/driver.py deleted file mode 100644 index bb8ae34420..0000000000 --- a/src/qibolab/instruments/rfsoc/driver.py +++ /dev/null @@ -1,610 +0,0 @@ -"""RFSoC FPGA driver.""" - -import re -from dataclasses import asdict, dataclass -from typing import Union - -import numpy as np -import numpy.typing as npt -import qibosoq.components.base as rfsoc -from qibo.config import log -from qibosoq import client - -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters -from qibolab.couplers import Coupler -from qibolab.instruments.abstract import Controller -from qibolab.instruments.port import Port -from qibolab.pulses import PulseSequence, PulseType -from qibolab.qubits import Qubit -from qibolab.result import AveragedSampleResults, IntegratedResults, SampleResults -from qibolab.sweeper import BIAS, Sweeper - -from .convert import convert, convert_units_sweeper - -HZ_TO_MHZ = 1e-6 -NS_TO_US = 1e-3 - - -@dataclass -class RFSoCPort(Port): - """Port object of the RFSoC.""" - - name: int - """DAC number.""" - offset: float = 0.0 - """Amplitude factor for biasing.""" - - -class RFSoC(Controller): - """Instrument object for controlling RFSoC FPGAs. - - The two way of executing pulses are with ``play`` (for arbitrary - qibolab ``PulseSequence``) or with ``sweep`` that execute a - ``PulseSequence`` object with one or more ``Sweeper``. - - Attributes: - cfg (rfsoc.Config): Configuration dictionary required for pulse execution. - """ - - PortType = RFSoCPort - - def __init__(self, name: str, address: str, port: int, sampling_rate: float = 1.0): - """Set server information and base configuration. - - Args: - name (str): Name of the instrument instance. - address (str): IP and port of the server (ex. 192.168.0.10) - port (int): Port of the server (ex.6000) - """ - super().__init__(name, address=address) - self.host = address - self.port = port - self.cfg = rfsoc.Config() - self._sampling_rate = sampling_rate - - @property - def sampling_rate(self): - return self._sampling_rate - - def connect(self): - """Empty method to comply with Instrument interface.""" - - def disconnect(self): - """Empty method to comply with Instrument interface.""" - - @staticmethod - def _try_to_execute(server_commands, host, port): - try: - return client.connect(server_commands, host, port) - except RuntimeError as e: - if "exception in readout loop" in str(e): - log.warning( - "%s %s", - "Exception in readout loop. Attempting again", - "You may want to increase the relaxation time.", - ) - return client.connect(server_commands, host, port) - buffer_overflow = r"buffer length must be \d+ samples or less" - if re.search(buffer_overflow, str(e)) is not None: - log.warning("Buffer full! Use shorter pulses.") - raise e - - @staticmethod - def convert_and_discriminate_samples(discriminated_shots, execution_parameters): - if execution_parameters.averaging_mode is AveragingMode.CYCLIC: - _, counts = np.unique(discriminated_shots, return_counts=True, axis=0) - freqs = counts / discriminated_shots.shape[0] - result = execution_parameters.results_type(freqs, discriminated_shots) - else: - result = execution_parameters.results_type(discriminated_shots) - return result - - @staticmethod - def validate_input_command( - sequence: PulseSequence, execution_parameters: ExecutionParameters, sweep: bool - ): - """Check if sequence and execution_parameters are supported.""" - if execution_parameters.acquisition_type is AcquisitionType.RAW: - if sweep: - raise NotImplementedError( - "Raw data acquisition is not compatible with sweepers" - ) - if len(sequence.ro_pulses) != 1: - raise NotImplementedError( - "Raw data acquisition is compatible only with a single readout" - ) - if execution_parameters.averaging_mode is not AveragingMode.CYCLIC: - raise NotImplementedError("Raw data acquisition can only be averaged") - if execution_parameters.fast_reset: - raise NotImplementedError("Fast reset is not supported") - - @staticmethod - def merge_sweep_results( - dict_a: dict[str, Union[IntegratedResults, SampleResults]], - dict_b: dict[str, Union[IntegratedResults, SampleResults]], - ) -> dict[str, Union[IntegratedResults, SampleResults]]: - """Merge two dictionary mapping pulse serial to Results object. - - If dict_b has a key (serial) that dict_a does not have, simply add it, - otherwise sum the two results - - Args: - dict_a (dict): dict mapping ro pulses serial to qibolab res objects - dict_b (dict): dict mapping ro pulses serial to qibolab res objects - Returns: - A dict mapping the readout pulses serial to qibolab results objects - """ - for serial in dict_b: - if serial in dict_a: - data = lambda res: ( - res.voltage if isinstance(res, IntegratedResults) else res.samples - ) - dict_a[serial] = type(dict_a[serial])( - np.append(data(dict_a[serial]), data(dict_b[serial])) - ) - else: - dict_a[serial] = dict_b[serial] - return dict_a - - @staticmethod - def reshape_sweep_results(results, sweepers, execution_parameters): - shape = [len(sweeper.values) for sweeper in sweepers] - if execution_parameters.averaging_mode is not AveragingMode.CYCLIC: - shape.insert(0, execution_parameters.nshots) - - def data(value): - if isinstance(value, IntegratedResults): - data = value.voltage - elif isinstance(value, AveragedSampleResults): - data = value.statistical_frequency - else: - data = value.samples - return type(value)(data.reshape(shape)) - - return {key: data(value) for key, value in results.items()} - - def _execute_pulse_sequence( - self, - sequence: PulseSequence, - qubits: dict[int, Qubit], - opcode: rfsoc.OperationCode, - ) -> tuple[list, list]: - """Prepare the commands dictionary to send to the qibosoq server. - - Args: - sequence (`qibolab.pulses.PulseSequence`): arbitrary PulseSequence object to execute - qubits: list of qubits (`qibolab.platforms.abstract.Qubit`) of the platform in the form of a dictionary - opcode: can be `rfsoc.OperationCode.EXECUTE_PULSE_SEQUENCE` or `rfsoc.OperationCode.EXECUTE_PULSE_SEQUENCE_RAW` - Returns: - Lists of I and Q value measured - """ - server_commands = { - "operation_code": opcode, - "cfg": asdict(self.cfg), - "sequence": convert(sequence, qubits, self.sampling_rate), - "qubits": [asdict(convert(qubits[idx])) for idx in qubits], - } - return self._try_to_execute(server_commands, self.host, self.port) - - def _execute_sweeps( - self, - sequence: PulseSequence, - qubits: dict[int, Qubit], - sweepers: list[rfsoc.Sweeper], - ) -> tuple[list, list]: - """Prepare the commands dictionary to send to the qibosoq server. - - Args: - sequence (`qibolab.pulses.PulseSequence`): arbitrary PulseSequence object to execute - qubits: list of qubits (`qibolab.platforms.abstract.Qubit`) of the platform in the form of a dictionary - sweepers: list of `qibosoq.abstract.Sweeper` objects - Returns: - Lists of I and Q value measured - """ - converted_sweepers = [ - convert_units_sweeper(sweeper, sequence, qubits) for sweeper in sweepers - ] - server_commands = { - "operation_code": rfsoc.OperationCode.EXECUTE_SWEEPS, - "cfg": asdict(self.cfg), - "sequence": convert(sequence, qubits, self.sampling_rate), - "qubits": [asdict(convert(qubits[idx])) for idx in qubits], - "sweepers": [sweeper.serialized for sweeper in converted_sweepers], - } - return self._try_to_execute(server_commands, self.host, self.port) - - def play( - self, - qubits: dict[int, Qubit], - couplers: dict[int, Coupler], - sequence: PulseSequence, - execution_parameters: ExecutionParameters, - ) -> dict[str, Union[IntegratedResults, SampleResults]]: - """Execute the sequence of instructions and retrieves readout results. - - Each readout pulse generates a separate acquisition. - The relaxation_time and the number of shots have default values. - - Args: - qubits (dict): List of `qibolab.platforms.utils.Qubit` objects - passed from the platform. - execution_parameters (`qibolab.ExecutionParameters`): Parameters (nshots, - relaxation_time, - fast_reset, - acquisition_type, - averaging_mode) - sequence (`qibolab.pulses.PulseSequence`): Pulse sequence to play. - Returns: - A dictionary mapping the readout pulses serial and respective qubits to - qibolab results objects - """ - if couplers != {}: - raise NotImplementedError( - "The RFSoC driver currently does not support couplers." - ) - - self.validate_input_command(sequence, execution_parameters, sweep=False) - self.update_cfg(execution_parameters) - - if execution_parameters.acquisition_type is AcquisitionType.DISCRIMINATION: - self.cfg.average = False - else: - self.cfg.average = ( - execution_parameters.averaging_mode is AveragingMode.CYCLIC - ) - - if execution_parameters.acquisition_type is AcquisitionType.RAW: - opcode = rfsoc.OperationCode.EXECUTE_PULSE_SEQUENCE_RAW - else: - opcode = rfsoc.OperationCode.EXECUTE_PULSE_SEQUENCE - toti, totq = self._execute_pulse_sequence(sequence, qubits, opcode) - - results = {} - probed_qubits = np.unique([p.qubit for p in sequence.ro_pulses]) - - for j, qubit in enumerate(probed_qubits): - for i, ro_pulse in enumerate(sequence.ro_pulses.get_qubit_pulses(qubit)): - i_pulse = np.array(toti[j][i]) - q_pulse = np.array(totq[j][i]) - - if ( - execution_parameters.acquisition_type - is AcquisitionType.DISCRIMINATION - ): - discriminated_shots = self.classify_shots( - i_pulse, q_pulse, qubits[ro_pulse.qubit] - ) - result = self.convert_and_discriminate_samples( - discriminated_shots, execution_parameters - ) - else: - result = execution_parameters.results_type(i_pulse + 1j * q_pulse) - results[ro_pulse.qubit] = results[ro_pulse.serial] = result - - return results - - def update_cfg(self, execution_parameters: ExecutionParameters): - """Update rfsoc.Config object with new parameters.""" - if execution_parameters.nshots is not None: - self.cfg.reps = execution_parameters.nshots - if execution_parameters.relaxation_time is not None: - self.cfg.relaxation_time = execution_parameters.relaxation_time * NS_TO_US - - def classify_shots( - self, - i_values: npt.NDArray[np.float64], - q_values: npt.NDArray[np.float64], - qubit: Qubit, - ) -> npt.NDArray[np.float64]: - """Classify IQ values using qubit threshold and rotation_angle if - available in runcard.""" - if qubit.iq_angle is None or qubit.threshold is None: - raise ValueError("Classification parameters were not provided") - angle = qubit.iq_angle - threshold = qubit.threshold - - rotated = np.cos(angle) * np.array(i_values) - np.sin(angle) * np.array( - q_values - ) - shots = np.heaviside(np.array(rotated) - threshold, 0) - if isinstance(shots, float): - return np.array([shots]) - return shots - - def play_sequence_in_sweep_recursion( - self, - qubits: dict[int, Qubit], - couplers: dict[int, Coupler], - sequence: PulseSequence, - or_sequence: PulseSequence, - execution_parameters: ExecutionParameters, - ) -> dict[str, Union[IntegratedResults, SampleResults]]: - """Last recursion layer, if no sweeps are present. - - After playing the sequence, the resulting dictionary keys need - to be converted to the correct values. Even indexes correspond - to qubit number and are not changed. Odd indexes correspond to - readout pulses serials and are convert to match the original - sequence (of the sweep) and not the one just executed. - """ - res = self.play(qubits, couplers, sequence, execution_parameters) - newres = {} - serials = [pulse.serial for pulse in or_sequence.ro_pulses] - for idx, key in enumerate(res): - if idx % 2 == 1: - newres[serials[idx // 2]] = res[key] - else: - newres[key] = res[key] - - return newres - - def recursive_python_sweep( - self, - qubits: dict[int, Qubit], - couplers: dict[int, Coupler], - sequence: PulseSequence, - or_sequence: PulseSequence, - *sweepers: rfsoc.Sweeper, - execution_parameters: ExecutionParameters, - ) -> dict[str, Union[IntegratedResults, SampleResults]]: - """Execute a sweep of an arbitrary number of Sweepers via recursion. - - Args: - qubits (list): List of `qibolab.platforms.utils.Qubit` objects - passed from the platform. - sequence (`qibolab.pulses.PulseSequence`): Pulse sequence to play. - This object is a deep copy of the original - sequence and gets modified. - or_sequence (`qibolab.pulses.PulseSequence`): Reference to original - sequence to not modify. - *sweepers (`qibolab.Sweeper`): Sweeper objects. - execution_parameters (`qibolab.ExecutionParameters`): Parameters (nshots, - relaxation_time, - fast_reset, - acquisition_type, - averaging_mode) - Returns: - A dictionary mapping the readout pulses serial and respective qubits to - results objects - """ - # If there are no sweepers run ExecutePulseSequence acquisition. - # Last layer for recursion. - - if len(sweepers) == 0: - return self.play_sequence_in_sweep_recursion( - qubits, couplers, sequence, or_sequence, execution_parameters - ) - - if not self.get_if_python_sweep(sequence, *sweepers): - toti, totq = self._execute_sweeps(sequence, qubits, sweepers) - res = self.convert_sweep_results( - or_sequence, qubits, toti, totq, execution_parameters - ) - return res - - sweeper = sweepers[0] - values = [] - for idx, _ in enumerate(sweeper.indexes): - val = np.linspace(sweeper.starts[idx], sweeper.stops[idx], sweeper.expts) - if sweeper.parameters[idx] in rfsoc.Parameter.variants( - {"duration", "delay"} - ): - val = val.astype(int) - values.append(val) - - results: dict[str, Union[IntegratedResults, SampleResults]] = {} - for idx in range(sweeper.expts): - # update values - for jdx, kdx in enumerate(sweeper.indexes): - sweeper_parameter = sweeper.parameters[jdx] - if sweeper_parameter is rfsoc.Parameter.BIAS: - qubits[list(qubits)[kdx]].flux.offset = values[jdx][idx] - elif sweeper_parameter in rfsoc.Parameter.variants( - { - "amplitude", - "frequency", - "relative_phase", - "duration", - } - ): - setattr( - sequence[kdx], sweeper_parameter.name.lower(), values[jdx][idx] - ) - if sweeper_parameter is rfsoc.Parameter.DURATION: - for pulse_idx in range( - kdx + 1, - len(sequence.get_qubit_pulses(sequence[kdx].qubit)), - ): - # TODO: this is a patch and works just for simple experiments - sequence[pulse_idx].start = sequence[pulse_idx - 1].finish - elif sweeper_parameter is rfsoc.Parameter.DELAY: - sequence[kdx].start_delay = values[jdx][idx] - - res = self.recursive_python_sweep( - qubits, - couplers, - sequence, - or_sequence, - *sweepers[1:], - execution_parameters=execution_parameters, - ) - results = self.merge_sweep_results(results, res) - return results - - def get_if_python_sweep( - self, sequence: PulseSequence, *sweepers: rfsoc.Sweeper - ) -> bool: - """Check if a sweeper must be run with python loop or on hardware. - - To be run on qick internal loop a sweep must: - * not be on the readout frequency - * not be a duration sweeper - * only one pulse per channel supported - * flux pulses are not compatible with sweepers - - Args: - sequence (`qibolab.pulses.PulseSequence`). Pulse sequence to play. - *sweepers (`qibosoq.abstract.Sweeper`): Sweeper objects. - Returns: - A boolean value true if the sweeper must be executed by python - loop, false otherwise - """ - if any(pulse.type is PulseType.FLUX for pulse in sequence): - return True - for sweeper in sweepers: - if all( - parameter is rfsoc.Parameter.BIAS for parameter in sweeper.parameters - ): - continue - if all( - parameter is rfsoc.Parameter.DELAY for parameter in sweeper.parameters - ): - continue - if any( - parameter is rfsoc.Parameter.DURATION - for parameter in sweeper.parameters - ): - return True - - for sweep_idx, parameter in enumerate(sweeper.parameters): - is_freq = parameter is rfsoc.Parameter.FREQUENCY - is_ro = sequence[sweeper.indexes[sweep_idx]].type == PulseType.READOUT - # if it's a sweep on the readout freq do a python sweep - if is_freq and is_ro: - return True - - for idx in sweeper.indexes: - sweep_pulse = sequence[idx] - channel = sweep_pulse.channel - ch_pulses = sequence.get_channel_pulses(channel) - if len(ch_pulses) > 1: - return True - # if all passed, do a firmware sweep - return False - - def convert_sweep_results( - self, - original_ro: PulseSequence, - qubits: dict[int, Qubit], - toti: list[list[list[float]]], - totq: list[list[list[float]]], - execution_parameters: ExecutionParameters, - ) -> dict[str, Union[IntegratedResults, SampleResults]]: - """Convert sweep res to qibolab dict res. - - Args: - original_ro (`qibolab.pulses.PulseSequence`): Original PulseSequence - qubits (list): List of `qibolab.platforms.utils.Qubit` objects - passed from the platform. - toti (list): i values - totq (list): q values - results_type: qibolab results object - execution_parameters (`qibolab.ExecutionParameters`): Parameters (nshots, - relaxation_time, - fast_reset, - acquisition_type, - averaging_mode) - Returns: - A dict mapping the readout pulses serial to qibolab results objects - """ - results = {} - - adcs = np.unique([qubits[p.qubit].feedback.port.name for p in original_ro]) - for k, k_val in enumerate(adcs): - adc_ro = [ - pulse - for pulse in original_ro - if qubits[pulse.qubit].feedback.port.name == k_val - ] - for i, ro_pulse in enumerate(adc_ro): - i_vals = np.array(toti[k][i]) - q_vals = np.array(totq[k][i]) - - if not self.cfg.average: - i_vals = np.reshape(i_vals, (self.cfg.reps, *i_vals.shape[:-1])) - q_vals = np.reshape(q_vals, (self.cfg.reps, *q_vals.shape[:-1])) - - if ( - execution_parameters.acquisition_type - is AcquisitionType.DISCRIMINATION - ): - qubit = qubits[ro_pulse.qubit] - discriminated_shots = self.classify_shots(i_vals, q_vals, qubit) - result = self.convert_and_discriminate_samples( - discriminated_shots, execution_parameters - ) - - else: - result = execution_parameters.results_type(i_vals + 1j * q_vals) - - results[ro_pulse.qubit] = results[ro_pulse.serial] = result - return results - - def sweep( - self, - qubits: dict[int, Qubit], - couplers: dict[int, Coupler], - sequence: PulseSequence, - execution_parameters: ExecutionParameters, - *sweepers: Sweeper, - ) -> dict[str, Union[IntegratedResults, SampleResults]]: - """Execute the sweep and retrieves the readout results. - - Each readout pulse generates a separate acquisition. - The relaxation_time and the number of shots have default values. - - Args: - qubits (list): List of `qibolab.platforms.utils.Qubit` objects - passed from the platform. - execution_parameters (`qibolab.ExecutionParameters`): Parameters (nshots, - relaxation_time, - fast_reset, - acquisition_type, - averaging_mode) - sequence (`qibolab.pulses.PulseSequence`). Pulse sequence to play. - *sweepers (`qibolab.Sweeper`): Sweeper objects. - Returns: - A dictionary mapping the readout pulses serial and respective qubits to - results objects - """ - if couplers != {}: - raise NotImplementedError( - "The RFSoC driver currently does not support couplers." - ) - - self.validate_input_command(sequence, execution_parameters, sweep=True) - self.update_cfg(execution_parameters) - - if execution_parameters.acquisition_type is AcquisitionType.DISCRIMINATION: - self.cfg.average = False - else: - self.cfg.average = ( - execution_parameters.averaging_mode is AveragingMode.CYCLIC - ) - - rfsoc_sweepers = [convert(sweep, sequence, qubits) for sweep in sweepers] - - sweepsequence = sequence.copy() - - bias_change = any(sweep.parameter is BIAS for sweep in sweepers) - if bias_change: - initial_biases = [ - qubits[idx].flux.offset if qubits[idx].flux is not None else None - for idx in qubits - ] - - results = self.recursive_python_sweep( - qubits, - couplers, - sweepsequence, - sequence.ro_pulses, - *rfsoc_sweepers, - execution_parameters=execution_parameters, - ) - - if bias_change: - for idx, qubit in enumerate(qubits.values()): - if qubit.flux is not None: - qubit.flux.offset = initial_biases[idx] - - return self.reshape_sweep_results(results, sweepers, execution_parameters) diff --git a/src/qibolab/instruments/rohde_schwarz.py b/src/qibolab/instruments/rohde_schwarz.py index 3658949fd0..b0ebca85f5 100644 --- a/src/qibolab/instruments/rohde_schwarz.py +++ b/src/qibolab/instruments/rohde_schwarz.py @@ -1,16 +1,10 @@ -import qcodes.instrument_drivers.rohde_schwarz.SGS100A as LO_SGS100A +"""Rohde & Schwarz drivers. -from qibolab.instruments.oscillator import LocalOscillator +https://www.rohde-schwarz.com/ +""" +from qibolab._core.instruments import rohde_schwarz +from qibolab._core.instruments.rohde_schwarz import * # noqa: F403 -class SGS100A(LocalOscillator): - """Driver to control the Rohde-Schwarz SGS100A local oscillator. - - This driver is using: - https://qcodes.github.io/Qcodes/api/generated/qcodes.instrument_drivers.rohde_schwarz.html#module-qcodes.instrument_drivers.rohde_schwarz.SGS100A - """ - - def create(self): - return LO_SGS100A.RohdeSchwarz_SGS100A( - self.name, f"TCPIP0::{self.address}::5025::SOCKET" - ) +__all__ = [] +__all__ += rohde_schwarz.__all__ diff --git a/src/qibolab/instruments/zhinst/__init__.py b/src/qibolab/instruments/zhinst/__init__.py deleted file mode 100644 index 6eff487e61..0000000000 --- a/src/qibolab/instruments/zhinst/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from .executor import Zurich -from .pulse import ZhPulse -from .sweep import ProcessedSweeps, classify_sweepers -from .util import acquire_channel_name, measure_channel_name diff --git a/src/qibolab/instruments/zhinst/executor.py b/src/qibolab/instruments/zhinst/executor.py deleted file mode 100644 index bfba7a6d98..0000000000 --- a/src/qibolab/instruments/zhinst/executor.py +++ /dev/null @@ -1,735 +0,0 @@ -"""Executing pulse sequences on a Zurich Instruments devices.""" - -import re -from collections import defaultdict -from dataclasses import dataclass, replace -from typing import Any, Optional - -import laboneq.simple as lo -import numpy as np -from qibo.config import log - -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters -from qibolab.couplers import Coupler -from qibolab.instruments.abstract import Controller -from qibolab.instruments.port import Port -from qibolab.pulses import FluxPulse, PulseSequence, PulseType -from qibolab.qubits import Qubit -from qibolab.sweeper import Parameter, Sweeper -from qibolab.unrolling import Bounds - -from .pulse import ZhPulse -from .sweep import ProcessedSweeps, classify_sweepers -from .util import ( - NANO_TO_SECONDS, - SAMPLING_RATE, - acquire_channel_name, - measure_channel_name, -) - -COMPILER_SETTINGS = { - "SHFSG_MIN_PLAYWAVE_HINT": 32, - "SHFSG_MIN_PLAYZERO_HINT": 32, - "HDAWG_MIN_PLAYWAVE_HINT": 64, - "HDAWG_MIN_PLAYZERO_HINT": 64, -} -"""Translating to Zurich ExecutionParameters.""" -ACQUISITION_TYPE = { - AcquisitionType.INTEGRATION: lo.AcquisitionType.INTEGRATION, - AcquisitionType.RAW: lo.AcquisitionType.RAW, - AcquisitionType.DISCRIMINATION: lo.AcquisitionType.DISCRIMINATION, -} - -AVERAGING_MODE = { - AveragingMode.CYCLIC: lo.AveragingMode.CYCLIC, - AveragingMode.SINGLESHOT: lo.AveragingMode.SINGLE_SHOT, -} - - -@dataclass -class ZhPort(Port): - name: tuple[str, str] - offset: float = 0.0 - power_range: int = 0 - - -@dataclass -class SubSequence: - """A subsequence is a slice (in time) of a sequence that contains at most - one measurement per qubit. - - When the driver is asked to execute a sequence, it will first split - it into sub-sequences. This is needed so that we can create a - separate laboneq section for each measurement (multiple measurements - per section are not allowed). When splitting a sequence, it is - assumed that 1. a measurement operation can be parallel (in time) to - another measurement operation (i.e. measuring multiple qubits - simultaneously), but other channels (e.g. drive) do not contain any - pulses parallel to measurements, 2. ith measurement on some channel - is in the same subsequence as the ith measurement (if any) on - another measurement channel, 3. all measurements in one subsequence - happen at the same time. - """ - - measurements: list[tuple[str, ZhPulse]] - control_sequence: dict[str, list[ZhPulse]] - - -class Zurich(Controller): - """Driver for a collection of ZI instruments that are automatically - synchronized via ZSync protocol.""" - - PortType = ZhPort - - def __init__(self, name, device_setup, time_of_flight=0.0, smearing=0.0): - super().__init__(name, None) - - self.signal_map = {} - "Signals to lines mapping" - self.calibration = lo.Calibration() - "Zurich calibration object)" - - self.device_setup = device_setup - self.session = None - "Zurich device parameters for connection" - - self.time_of_flight = time_of_flight - self.smearing = smearing - "Parameters read from the runcard not part of ExecutionParameters" - - self.experiment = None - self.results = None - "Zurich experiment definitions" - - self.bounds = Bounds( - waveforms=int(4e4), - readout=250, - instructions=int(1e6), - ) - - self.acquisition_type = None - "To store if the AcquisitionType.SPECTROSCOPY needs to be enabled by parsing the sequence" - - self.sequence = defaultdict(list) - "Zurich pulse sequence" - self.sub_sequences: list[SubSequence] = [] - "Sub sequences between each measurement" - self.unsplit_channels: set[str] = set() - "Names of channels that were not split into sub-sequences" - - self.processed_sweeps: Optional[ProcessedSweeps] = None - self.nt_sweeps: list[Sweeper] = [] - self.rt_sweeps: list[Sweeper] = [] - - @property - def sampling_rate(self): - return SAMPLING_RATE - - def connect(self): - if self.is_connected is False: - # To fully remove logging #configure_logging=False - # I strongly advise to set it to 20 to have time estimates of the experiment duration! - self.session = lo.Session(self.device_setup, log_level=20) - _ = self.session.connect() - self.is_connected = True - - def disconnect(self): - if self.is_connected: - _ = self.session.disconnect() - self.is_connected = False - - def calibration_step(self, qubits, couplers, options): - """Zurich general pre experiment calibration definitions. - - Change to get frequencies from sequence - """ - - for coupler in couplers.values(): - self.register_couplerflux_line(coupler) - - for qubit in qubits.values(): - if qubit.flux is not None: - self.register_flux_line(qubit) - if len(self.sequence[qubit.drive.name]) != 0: - self.register_drive_line( - qubit=qubit, - intermediate_frequency=qubit.drive_frequency - - qubit.drive.local_oscillator.frequency, - ) - if len(self.sequence[measure_channel_name(qubit)]) != 0: - self.register_readout_line( - qubit=qubit, - intermediate_frequency=qubit.readout_frequency - - qubit.readout.local_oscillator.frequency, - options=options, - ) - self.device_setup.set_calibration(self.calibration) - - def register_readout_line(self, qubit, intermediate_frequency, options): - """Registers qubit measure and acquire lines to calibration and signal - map. - - Note - ---- - To allow debugging with and oscilloscope, just set the following:: - - self.calibration[f"/logical_signal_groups/q{q}/measure_line"] = lo.SignalCalibration( - ..., - local_oscillator=lo.Oscillator( - ... - frequency=0.0, - ), - ..., - port_mode=lo.PortMode.LF, - ..., - ) - """ - - q = qubit.name # pylint: disable=C0103 - self.signal_map[measure_channel_name(qubit)] = ( - self.device_setup.logical_signal_groups[f"q{q}"].logical_signals[ - "measure_line" - ] - ) - self.calibration[f"/logical_signal_groups/q{q}/measure_line"] = ( - lo.SignalCalibration( - oscillator=lo.Oscillator( - frequency=intermediate_frequency, - modulation_type=lo.ModulationType.SOFTWARE, - ), - local_oscillator=lo.Oscillator( - frequency=int(qubit.readout.local_oscillator.frequency), - ), - range=qubit.readout.power_range, - port_delay=None, - delay_signal=0, - ) - ) - - self.signal_map[acquire_channel_name(qubit)] = ( - self.device_setup.logical_signal_groups[f"q{q}"].logical_signals[ - "acquire_line" - ] - ) - - oscillator = lo.Oscillator( - frequency=intermediate_frequency, - modulation_type=lo.ModulationType.SOFTWARE, - ) - threshold = None - - if options.acquisition_type == AcquisitionType.DISCRIMINATION: - if qubit.kernel is not None: - # Kernels don't work with the software modulation on the acquire signal - oscillator = None - else: - # To keep compatibility with angle and threshold discrimination (Remove when possible) - threshold = qubit.threshold - - self.calibration[f"/logical_signal_groups/q{q}/acquire_line"] = ( - lo.SignalCalibration( - oscillator=oscillator, - range=qubit.feedback.power_range, - port_delay=self.time_of_flight * NANO_TO_SECONDS, - threshold=threshold, - ) - ) - - def register_drive_line(self, qubit, intermediate_frequency): - """Registers qubit drive line to calibration and signal map.""" - q = qubit.name # pylint: disable=C0103 - self.signal_map[qubit.drive.name] = self.device_setup.logical_signal_groups[ - f"q{q}" - ].logical_signals["drive_line"] - self.calibration[f"/logical_signal_groups/q{q}/drive_line"] = ( - lo.SignalCalibration( - oscillator=lo.Oscillator( - frequency=intermediate_frequency, - modulation_type=lo.ModulationType.HARDWARE, - ), - local_oscillator=lo.Oscillator( - frequency=int(qubit.drive.local_oscillator.frequency), - ), - range=qubit.drive.power_range, - port_delay=None, - delay_signal=0, - ) - ) - - def register_flux_line(self, qubit): - """Registers qubit flux line to calibration and signal map.""" - q = qubit.name # pylint: disable=C0103 - self.signal_map[qubit.flux.name] = self.device_setup.logical_signal_groups[ - f"q{q}" - ].logical_signals["flux_line"] - self.calibration[f"/logical_signal_groups/q{q}/flux_line"] = ( - lo.SignalCalibration( - range=qubit.flux.power_range, - port_delay=None, - delay_signal=0, - voltage_offset=qubit.flux.offset, - ) - ) - - def register_couplerflux_line(self, coupler): - """Registers qubit flux line to calibration and signal map.""" - c = coupler.name # pylint: disable=C0103 - self.signal_map[coupler.flux.name] = self.device_setup.logical_signal_groups[ - f"qc{c}" - ].logical_signals["flux_line"] - self.calibration[f"/logical_signal_groups/qc{c}/flux_line"] = ( - lo.SignalCalibration( - range=coupler.flux.power_range, - port_delay=None, - delay_signal=0, - voltage_offset=coupler.flux.offset, - ) - ) - - def run_exp(self): - """ - Compilation settings, compilation step, execution step and data retrival - - Save a experiment Python object: - self.experiment.save("saved_exp") - - Save a experiment compiled experiment (): - self.exp.save("saved_exp") # saving compiled experiment - """ - compiled_experiment = self.session.compile( - self.experiment, compiler_settings=COMPILER_SETTINGS - ) - self.results = self.session.run(compiled_experiment) - - @staticmethod - def frequency_from_pulses(qubits, sequence): - """Gets the frequencies from the pulses to the qubits.""" - for pulse in sequence: - qubit = qubits[pulse.qubit] - if pulse.type is PulseType.READOUT: - qubit.readout_frequency = pulse.frequency - if pulse.type is PulseType.DRIVE: - qubit.drive_frequency = pulse.frequency - - def create_sub_sequences( - self, qubits: list[Qubit] - ) -> tuple[list[SubSequence], set[str]]: - """Create subsequences based on locations of measurements. - - Returns list of subsequences and a set of channel names that - were not split - """ - measure_channels = {measure_channel_name(qb) for qb in qubits} - other_channels = set(self.sequence.keys()) - measure_channels - - measurement_groups = defaultdict(list) - for ch in measure_channels: - for i, pulse in enumerate(self.sequence[ch]): - measurement_groups[i].append((ch, pulse)) - - measurement_start_end = {} - for i, group in measurement_groups.items(): - starts = np.array([meas.pulse.start for _, meas in group]) - ends = np.array([meas.pulse.finish for _, meas in group]) - measurement_start_end[i] = ( - max(starts), - max(ends), - ) # max is intended for float arithmetic errors only - - # FIXME: this is a hotfix specifically made for any flux experiments in flux pulse mode, where the flux - # pulses extend through the entire duration of the experiment. This should be removed once the sub-sequence - # splitting logic is removed from the driver. - channels_overlapping_measurement = set() - if len(measurement_groups) == 1: - for ch in other_channels: - for pulse in self.sequence[ch]: - if not isinstance(pulse.pulse, FluxPulse): - break - start, end = measurement_start_end[0] - if pulse.pulse.start < end and pulse.pulse.finish > start: - channels_overlapping_measurement.add(ch) - break - - # split non-measurement channels according to the locations of the measurements - sub_sequences = defaultdict(lambda: defaultdict(list)) - for ch in other_channels - channels_overlapping_measurement: - measurement_index = 0 - for pulse in self.sequence[ch]: - start, _ = measurement_start_end[measurement_index] - if pulse.pulse.finish > start: - measurement_index += 1 - sub_sequences[measurement_index][ch].append(pulse) - if len(sub_sequences) > len(measurement_groups): - log.warning("There are control pulses after the last measurement start.") - - return [ - SubSequence(measurement_groups[i], sub_sequences[i]) - for i in range(len(measurement_groups)) - ], channels_overlapping_measurement - - def experiment_flow( - self, - qubits: dict[str, Qubit], - couplers: dict[str, Coupler], - sequence: PulseSequence, - options: ExecutionParameters, - ): - """Create the experiment object for the devices, following the steps - separated one on each method: - - Translation, Calibration, Experiment Definition. - - Args: - qubits (dict[str, Qubit]): qubits for the platform. - couplers (dict[str, Coupler]): couplers for the platform. - sequence (PulseSequence): sequence of pulses to be played in the experiment. - """ - self.sequence = self.sequence_zh(sequence, qubits) - self.sub_sequences, self.unsplit_channels = self.create_sub_sequences( - list(qubits.values()) - ) - self.calibration_step(qubits, couplers, options) - self.create_exp(qubits, options) - - # pylint: disable=W0221 - def play(self, qubits, couplers, sequence, options): - """Play pulse sequence.""" - return self.sweep(qubits, couplers, sequence, options) - - def sequence_zh( - self, sequence: PulseSequence, qubits: dict[str, Qubit] - ) -> dict[str, list[ZhPulse]]: - """Convert Qibo sequence to a sequence where all pulses are replaced - with ZhPulse instances. - - The resulting object is a dictionary mapping from channel name - to corresponding sequence of ZhPulse instances - """ - # Define and assign the sequence - zhsequence = defaultdict(list) - - # Fill the sequences with pulses according to their lines in temporal order - for pulse in sequence: - if pulse.type == PulseType.READOUT: - ch = measure_channel_name(qubits[pulse.qubit]) - else: - ch = pulse.channel - zhsequence[ch].append(ZhPulse(pulse)) - - if self.processed_sweeps: - for ch, zhpulses in zhsequence.items(): - for zhpulse in zhpulses: - for param, sweep in self.processed_sweeps.sweeps_for_pulse( - zhpulse.pulse - ): - zhpulse.add_sweeper(param, sweep) - - return zhsequence - - def create_exp(self, qubits, options): - """Zurich experiment initialization using their Experiment class.""" - if self.acquisition_type: - acquisition_type = self.acquisition_type - else: - acquisition_type = ACQUISITION_TYPE[options.acquisition_type] - averaging_mode = AVERAGING_MODE[options.averaging_mode] - exp_options = replace( - options, acquisition_type=acquisition_type, averaging_mode=averaging_mode - ) - - signals = [lo.ExperimentSignal(name) for name in self.signal_map.keys()] - exp = lo.Experiment( - uid="Sequence", - signals=signals, - ) - - contexts = self._contexts(exp, exp_options) - self._populate_exp(qubits, exp, exp_options, contexts) - self.set_calibration_for_rt_sweep(exp) - exp.set_signal_map(self.signal_map) - self.experiment = exp - - def _contexts( - self, exp: lo.Experiment, exp_options: ExecutionParameters - ) -> list[tuple[Optional[Sweeper], Any]]: - """To construct a laboneq experiment, we need to first define a certain - sequence of nested contexts. - - This method returns the corresponding sequence of context - managers. - """ - sweep_contexts = [] - for i, sweeper in enumerate(self.nt_sweeps): - ctx = exp.sweep( - uid=f"nt_sweep_{sweeper.parameter.name.lower()}_{i}", - parameter=[ - sweep_param - for sweep_param in self.processed_sweeps.sweeps_for_sweeper(sweeper) - ], - ) - sweep_contexts.append((sweeper, ctx)) - - shots_ctx = exp.acquire_loop_rt( - uid="shots", - count=exp_options.nshots, - acquisition_type=exp_options.acquisition_type, - averaging_mode=exp_options.averaging_mode, - ) - sweep_contexts.append((None, shots_ctx)) - - for i, sweeper in enumerate(self.rt_sweeps): - ctx = exp.sweep( - uid=f"rt_sweep_{sweeper.parameter.name.lower()}_{i}", - parameter=[ - sweep_param - for sweep_param in self.processed_sweeps.sweeps_for_sweeper(sweeper) - ], - reset_oscillator_phase=True, - ) - sweep_contexts.append((sweeper, ctx)) - - return sweep_contexts - - def _populate_exp( - self, - qubits: dict[str, Qubit], - exp: lo.Experiment, - exp_options: ExecutionParameters, - contexts, - ): - """Recursively activate the nested contexts, then define the main - experiment body inside the innermost context.""" - if len(contexts) == 0: - self.select_exp(exp, qubits, exp_options) - return - - sweeper, ctx = contexts[0] - with ctx: - if sweeper in self.nt_sweeps: - self.set_instrument_nodes_for_nt_sweep(exp, sweeper) - self._populate_exp(qubits, exp, exp_options, contexts[1:]) - - def set_calibration_for_rt_sweep(self, exp: lo.Experiment) -> None: - """Set laboneq calibration of parameters that are to be swept in real- - time.""" - if self.processed_sweeps: - calib = lo.Calibration() - for ch in ( - set(self.sequence.keys()) | self.processed_sweeps.channels_with_sweeps() - ): - for param, sweep_param in self.processed_sweeps.sweeps_for_channel(ch): - if param is Parameter.frequency: - calib[ch] = lo.SignalCalibration( - oscillator=lo.Oscillator( - frequency=sweep_param, - modulation_type=lo.ModulationType.HARDWARE, - ) - ) - exp.set_calibration(calib) - - def set_instrument_nodes_for_nt_sweep( - self, exp: lo.Experiment, sweeper: Sweeper - ) -> None: - """In some cases there is no straightforward way to sweep a parameter. - - In these cases we achieve sweeping by directly manipulating the - instrument nodes - """ - for ch, param, sweep_param in self.processed_sweeps.channel_sweeps_for_sweeper( - sweeper - ): - channel_node_path = self.get_channel_node_path(ch) - if param is Parameter.bias: - offset_node_path = f"{channel_node_path}/offset" - exp.set_node(path=offset_node_path, value=sweep_param) - - # This is supposed to happen only for measurement, but we do not validate it here. - if param is Parameter.amplitude: - a, b = re.match(r"(.*)/(\d)/.*", channel_node_path).groups() - gain_node_path = f"{a}/{b}/oscs/{b}/gain" - exp.set_node(path=gain_node_path, value=sweep_param) - - def get_channel_node_path(self, channel_name: str) -> str: - """Return the path of the instrument node corresponding to the given - channel.""" - logical_signal = self.signal_map[channel_name] - for instrument in self.device_setup.instruments: - for conn in instrument.connections: - if conn.remote_path == logical_signal.path: - return f"{instrument.address}/{conn.local_port}" - raise RuntimeError( - f"Could not find instrument node corresponding to channel {channel_name}" - ) - - def select_exp(self, exp, qubits, exp_options): - """Build Zurich Experiment selecting the relevant sections.""" - # channels that were not split are just applied in parallel to the rest of the experiment - with exp.section(uid="unsplit_channels"): - for ch in self.unsplit_channels: - for pulse in self.sequence[ch]: - exp.delay(signal=ch, time=pulse.pulse.start) - self.play_sweep(exp, ch, pulse) - - weights = {} - previous_section = None - for i, seq in enumerate(self.sub_sequences): - section_uid = f"control_{i}" - with exp.section(uid=section_uid, play_after=previous_section): - for ch, pulses in seq.control_sequence.items(): - time = 0 - for pulse in pulses: - if pulse.delay_sweeper: - exp.delay(signal=ch, time=pulse.delay_sweeper) - exp.delay( - signal=ch, - time=round(pulse.pulse.start * NANO_TO_SECONDS, 9) - time, - ) - time = round(pulse.pulse.duration * NANO_TO_SECONDS, 9) + round( - pulse.pulse.start * NANO_TO_SECONDS, 9 - ) - if pulse.zhsweepers: - self.play_sweep(exp, ch, pulse) - else: - exp.play( - signal=ch, - pulse=pulse.zhpulse, - phase=pulse.pulse.relative_phase, - ) - previous_section = section_uid - - if any(m.delay_sweeper is not None for _, m in seq.measurements): - section_uid = f"measurement_delay_{i}" - with exp.section(uid=section_uid, play_after=previous_section): - for ch, m in seq.measurements: - if m.delay_sweeper: - exp.delay(signal=ch, time=m.delay_sweeper) - previous_section = section_uid - - section_uid = f"measure_{i}" - with exp.section(uid=section_uid, play_after=previous_section): - for ch, pulse in seq.measurements: - qubit = qubits[pulse.pulse.qubit] - q = qubit.name - - exp.delay( - signal=acquire_channel_name(qubit), - time=self.smearing * NANO_TO_SECONDS, - ) - - if ( - qubit.kernel is not None - and exp_options.acquisition_type - == lo.AcquisitionType.DISCRIMINATION - ): - weight = lo.pulse_library.sampled_pulse_complex( - samples=qubit.kernel * np.exp(1j * qubit.iq_angle), - ) - - else: - if i == 0: - if ( - exp_options.acquisition_type - == lo.AcquisitionType.DISCRIMINATION - ): - weight = lo.pulse_library.sampled_pulse_complex( - samples=np.ones( - [ - int( - pulse.pulse.duration * 2 - - 3 * self.smearing * NANO_TO_SECONDS - ) - ] - ) - * np.exp(1j * qubit.iq_angle), - ) - weights[q] = weight - else: - weight = lo.pulse_library.const( - length=round( - pulse.pulse.duration * NANO_TO_SECONDS, 9 - ) - - 1.5 * self.smearing * NANO_TO_SECONDS, - amplitude=1, - ) - - weights[q] = weight - elif i != 0: - weight = weights[q] - - measure_pulse_parameters = {"phase": 0} - - if i == len(self.sequence[measure_channel_name(qubit)]) - 1: - reset_delay = exp_options.relaxation_time * NANO_TO_SECONDS - else: - reset_delay = 0 - - exp.measure( - acquire_signal=acquire_channel_name(qubit), - handle=f"sequence{q}_{i}", - integration_kernel=weight, - integration_kernel_parameters=None, - integration_length=None, - measure_signal=measure_channel_name(qubit), - measure_pulse=pulse.zhpulse, - measure_pulse_length=round( - pulse.pulse.duration * NANO_TO_SECONDS, 9 - ), - measure_pulse_parameters=measure_pulse_parameters, - measure_pulse_amplitude=None, - acquire_delay=self.time_of_flight * NANO_TO_SECONDS, - reset_delay=reset_delay, - ) - previous_section = section_uid - - @staticmethod - def play_sweep(exp, channel_name, pulse): - """Play Zurich pulse when a single sweeper is involved.""" - play_parameters = {} - for p, zhs in pulse.zhsweepers: - if p is Parameter.amplitude: - max_value = max(np.abs(zhs.values)) - pulse.zhpulse.amplitude *= max_value - zhs.values /= max_value - play_parameters["amplitude"] = zhs - if p is Parameter.duration: - play_parameters["length"] = zhs - if p is Parameter.relative_phase: - play_parameters["phase"] = zhs - if "phase" not in play_parameters: - play_parameters["phase"] = pulse.pulse.relative_phase - - exp.play(signal=channel_name, pulse=pulse.zhpulse, **play_parameters) - - def sweep(self, qubits, couplers, sequence: PulseSequence, options, *sweepers): - """Play pulse and sweepers sequence.""" - - self.signal_map = {} - self.frequency_from_pulses(qubits, sequence) - self.processed_sweeps = ProcessedSweeps(sweepers, qubits) - self.nt_sweeps, self.rt_sweeps = classify_sweepers(sweepers) - - self.acquisition_type = None - for sweeper in sweepers: - if sweeper.parameter in {Parameter.frequency, Parameter.amplitude}: - for pulse in sweeper.pulses: - if pulse.type is PulseType.READOUT: - self.acquisition_type = lo.AcquisitionType.SPECTROSCOPY - - self.experiment_flow(qubits, couplers, sequence, options) - self.run_exp() - - # Get the results back - results = {} - for qubit in qubits.values(): - q = qubit.name # pylint: disable=C0103 - for i, ropulse in enumerate(self.sequence[measure_channel_name(qubit)]): - data = self.results.get_data(f"sequence{q}_{i}") - - if options.acquisition_type is AcquisitionType.DISCRIMINATION: - data = ( - np.ones(data.shape) - data.real - ) # Probability inversion patch - - serial = ropulse.pulse.serial - qubit = ropulse.pulse.qubit - results[serial] = results[qubit] = options.results_type(data) - - return results diff --git a/src/qibolab/instruments/zhinst/pulse.py b/src/qibolab/instruments/zhinst/pulse.py deleted file mode 100644 index 44c223ea63..0000000000 --- a/src/qibolab/instruments/zhinst/pulse.py +++ /dev/null @@ -1,106 +0,0 @@ -"""Wrapper for qibolab and laboneq pulses and sweeps.""" - -from typing import Optional - -import laboneq.simple as lo -import numpy as np -from laboneq.dsl.experiment.pulse_library import ( - sampled_pulse_complex, - sampled_pulse_real, -) - -from qibolab.pulses import Drag, Gaussian, GaussianSquare, Pulse, PulseType, Rectangular -from qibolab.sweeper import Parameter - -from .util import NANO_TO_SECONDS, SAMPLING_RATE - - -def select_pulse(pulse: Pulse): - """Return laboneq pulse object corresponding to the given qibolab pulse.""" - if isinstance(pulse.shape, Rectangular): - can_compress = pulse.type is not PulseType.READOUT - return lo.pulse_library.const( - length=round(pulse.duration * NANO_TO_SECONDS, 9), - amplitude=pulse.amplitude, - can_compress=can_compress, - ) - if isinstance(pulse.shape, Gaussian): - sigma = pulse.shape.rel_sigma - return lo.pulse_library.gaussian( - length=round(pulse.duration * NANO_TO_SECONDS, 9), - amplitude=pulse.amplitude, - sigma=2 / sigma, - zero_boundaries=False, - ) - - if isinstance(pulse.shape, GaussianSquare): - sigma = pulse.shape.rel_sigma - width = pulse.shape.width - can_compress = pulse.type is not PulseType.READOUT - return lo.pulse_library.gaussian_square( - length=round(pulse.duration * NANO_TO_SECONDS, 9), - width=round(pulse.duration * NANO_TO_SECONDS, 9) * width, - amplitude=pulse.amplitude, - can_compress=can_compress, - sigma=2 / sigma, - zero_boundaries=False, - ) - - if isinstance(pulse.shape, Drag): - sigma = pulse.shape.rel_sigma - beta = pulse.shape.beta - return lo.pulse_library.drag( - length=round(pulse.duration * NANO_TO_SECONDS, 9), - amplitude=pulse.amplitude, - sigma=2 / sigma, - beta=beta, - zero_boundaries=False, - ) - - if np.all(pulse.envelope_waveform_q(SAMPLING_RATE).data == 0): - return sampled_pulse_real( - samples=pulse.envelope_waveform_i(SAMPLING_RATE).data, - can_compress=True, - ) - else: - return sampled_pulse_complex( - samples=pulse.envelope_waveform_i(SAMPLING_RATE).data - + (1j * pulse.envelope_waveform_q(SAMPLING_RATE).data), - can_compress=True, - ) - - -class ZhPulse: - """Wrapper data type that holds a qibolab pulse, the corresponding laboneq - pulse object, and any sweeps associated with this pulse.""" - - def __init__(self, pulse): - self.pulse: Pulse = pulse - """Qibolab pulse.""" - self.zhpulse = select_pulse(pulse) - """Laboneq pulse.""" - self.zhsweepers: list[tuple[Parameter, lo.SweepParameter]] = [] - """Parameters to be swept, along with their laboneq sweep parameter - definitions.""" - self.delay_sweeper: Optional[lo.SweepParameter] = None - """Laboneq sweep parameter if the delay of the pulse should be - swept.""" - - # pylint: disable=R0903 - def add_sweeper(self, param: Parameter, sweeper: lo.SweepParameter): - """Add sweeper to list of sweepers associated with this pulse.""" - if param in { - Parameter.amplitude, - Parameter.frequency, - Parameter.duration, - Parameter.relative_phase, - }: - self.zhsweepers.append((param, sweeper)) - elif param is Parameter.start: - if self.delay_sweeper: - raise ValueError( - "Cannot have multiple delay sweepers for a single pulse" - ) - self.delay_sweeper = sweeper - else: - raise ValueError(f"Sweeping {param} is not supported") diff --git a/src/qibolab/instruments/zhinst/sweep.py b/src/qibolab/instruments/zhinst/sweep.py deleted file mode 100644 index d2371c79e4..0000000000 --- a/src/qibolab/instruments/zhinst/sweep.py +++ /dev/null @@ -1,164 +0,0 @@ -"""Pre-execution processing of sweeps.""" - -from collections.abc import Iterable -from copy import copy - -import laboneq.simple as lo -import numpy as np - -from qibolab.pulses import Pulse, PulseType -from qibolab.qubits import Qubit -from qibolab.sweeper import Parameter, Sweeper - -from .util import NANO_TO_SECONDS, measure_channel_name - - -def classify_sweepers( - sweepers: Iterable[Sweeper], -) -> tuple[list[Sweeper], list[Sweeper]]: - """Divide sweepers into two lists: 1. sweeps that can be done in the laboneq near-time sweep loop, 2. sweeps that - can be done in real-time (i.e. on hardware)""" - nt_sweepers, rt_sweepers = [], [] - for sweeper in sweepers: - if sweeper.parameter is Parameter.bias or ( - sweeper.parameter is Parameter.amplitude - and sweeper.pulses[0].type is PulseType.READOUT - ): - nt_sweepers.append(sweeper) - else: - rt_sweepers.append(sweeper) - return nt_sweepers, rt_sweepers - - -class ProcessedSweeps: - """Data type that centralizes and allows extracting information about given - sweeps. - - In laboneq, sweeps are represented with the help of SweepParameter - instances. When adding pulses to a laboneq experiment, some - properties can be set to be an instance of SweepParameter instead of - a fixed numeric value. In case of channel property sweeps, either - the relevant calibration property or the instrument node directly - can be set ot a SweepParameter instance. Parts of the laboneq - experiment that define the sweep loops refer to SweepParameter - instances as well. These should be linkable to instances that are - either set to a pulse property, a channel calibration or instrument - node. To achieve this, we use the exact same SweepParameter instance - in both places. This class takes care of creating these - SweepParameter instances and giving access to them in a consistent - way (i.e. whenever they need to be the same instance they will be - the same instance). When constructing sweep loops you may ask from - this class to provide all the SweepParameter instances related to a - given qibolab Sweeper (parallel sweeps). Later, when adding pulses - or setting channel properties, you may ask from this class to - provide all SweepParameter instances related to a given pulse or - channel, and you will get parameters that are linkable to the ones - in the sweep loop definition - """ - - def __init__(self, sweepers: Iterable[Sweeper], qubits: dict[str, Qubit]): - pulse_sweeps = [] - channel_sweeps = [] - parallel_sweeps = [] - for sweeper in sweepers: - for pulse in sweeper.pulses or []: - if sweeper.parameter in (Parameter.duration, Parameter.start): - sweep_param = lo.SweepParameter( - values=sweeper.values * NANO_TO_SECONDS - ) - pulse_sweeps.append((pulse, sweeper.parameter, sweep_param)) - elif sweeper.parameter is Parameter.frequency: - ptype, qubit = pulse.type, qubits[pulse.qubit] - if ptype is PulseType.READOUT: - ch = measure_channel_name(qubit) - intermediate_frequency = ( - qubit.readout_frequency - - qubit.readout.local_oscillator.frequency - ) - elif ptype is PulseType.DRIVE: - ch = qubit.drive.name - intermediate_frequency = ( - qubit.drive_frequency - - qubit.drive.local_oscillator.frequency - ) - else: - raise ValueError( - f"Cannot sweep frequency of pulse of type {ptype}, because it does not have associated frequency" - ) - sweep_param = lo.SweepParameter( - values=sweeper.values + intermediate_frequency - ) - channel_sweeps.append((ch, sweeper.parameter, sweep_param)) - elif ( - pulse.type is PulseType.READOUT - and sweeper.parameter is Parameter.amplitude - ): - max_value = max(np.abs(sweeper.values)) - sweep_param = lo.SweepParameter(values=sweeper.values / max_value) - # FIXME: this implicitly relies on the fact that pulse is the same python object as appears in the - # sequence that is being executed, hence the mutation is propagated. This is bad programming and - # should be fixed once things become simpler - pulse.amplitude *= max_value - - channel_sweeps.append( - ( - measure_channel_name(qubits[pulse.qubit]), - sweeper.parameter, - sweep_param, - ) - ) - else: - sweep_param = lo.SweepParameter(values=copy(sweeper.values)) - pulse_sweeps.append((pulse, sweeper.parameter, sweep_param)) - parallel_sweeps.append((sweeper, sweep_param)) - - for qubit in sweeper.qubits or []: - if sweeper.parameter is not Parameter.bias: - raise ValueError( - f"Sweeping {sweeper.parameter.name} for {qubit} is not supported" - ) - sweep_param = lo.SweepParameter( - values=sweeper.values + qubit.flux.offset - ) - channel_sweeps.append((qubit.flux.name, sweeper.parameter, sweep_param)) - parallel_sweeps.append((sweeper, sweep_param)) - - for coupler in sweeper.couplers or []: - if sweeper.parameter is not Parameter.bias: - raise ValueError( - f"Sweeping {sweeper.parameter.name} for {coupler} is not supported" - ) - sweep_param = lo.SweepParameter( - values=sweeper.values + coupler.flux.offset - ) - channel_sweeps.append( - (coupler.flux.name, sweeper.parameter, sweep_param) - ) - parallel_sweeps.append((sweeper, sweep_param)) - - self._pulse_sweeps = pulse_sweeps - self._channel_sweeps = channel_sweeps - self._parallel_sweeps = parallel_sweeps - - def sweeps_for_pulse( - self, pulse: Pulse - ) -> list[tuple[Parameter, lo.SweepParameter]]: - return [item[1:] for item in self._pulse_sweeps if item[0] == pulse] - - def sweeps_for_channel(self, ch: str) -> list[tuple[Parameter, lo.SweepParameter]]: - return [item[1:] for item in self._channel_sweeps if item[0] == ch] - - def sweeps_for_sweeper(self, sweeper: Sweeper) -> list[lo.SweepParameter]: - return [item[1] for item in self._parallel_sweeps if item[0] == sweeper] - - def channel_sweeps_for_sweeper( - self, sweeper: Sweeper - ) -> list[tuple[str, Parameter, lo.SweepParameter]]: - return [ - item - for item in self._channel_sweeps - if item[2] in self.sweeps_for_sweeper(sweeper) - ] - - def channels_with_sweeps(self) -> set[str]: - return {ch for ch, _, _ in self._channel_sweeps} diff --git a/src/qibolab/instruments/zhinst/util.py b/src/qibolab/instruments/zhinst/util.py deleted file mode 100644 index 8ca8843060..0000000000 --- a/src/qibolab/instruments/zhinst/util.py +++ /dev/null @@ -1,24 +0,0 @@ -"""Utility methods.""" - -from qibolab.qubits import Qubit - -SAMPLING_RATE = 2 -NANO_TO_SECONDS = 1e-9 - - -def measure_channel_name(qubit: Qubit) -> str: - """Construct and return a name for qubit's measure channel. - - FIXME: We cannot use channel name directly, because currently channels are named after wires, and due to multiplexed readout - multiple qubits have the same channel name for their readout. Should be fixed once channels are refactored. - """ - return f"{qubit.readout.name}_{qubit.name}" - - -def acquire_channel_name(qubit: Qubit) -> str: - """Construct and return a name for qubit's acquire channel. - - FIXME: We cannot use acquire channel name, because qibolab does not have a concept of acquire channel. This function shall be removed - once all channel refactoring is done. - """ - return f"acquire{qubit.name}" diff --git a/src/qibolab/kernels.py b/src/qibolab/kernels.py deleted file mode 100644 index 9ee1ae60d8..0000000000 --- a/src/qibolab/kernels.py +++ /dev/null @@ -1,39 +0,0 @@ -import json -from pathlib import Path - -import numpy as np - -from qibolab.qubits import QubitId - -KERNELS = "kernels.npz" - - -class Kernels(dict[QubitId, np.ndarray]): - """A dictionary subclass for handling Qubit Kernels. - - This class extends the built-in dict class and maps QubitId to numpy - arrays. It provides methods to load and dump the kernels from and to - a file. - """ - - @classmethod - def load(cls, path: Path): - """Class method to load kernels from a file. - - The file should contain a serialized dictionary where keys are - serialized QubitId and values are numpy arrays. - """ - return cls( - {json.loads(key): value for key, value in np.load(path / KERNELS).items()} - ) - - def dump(self, path: Path): - """Instance method to dump the kernels to a file. - - The keys (QubitId) are serialized to strings and the values - (numpy arrays) are kept as is. - """ - np.savez( - path / KERNELS, - **{json.dumps(qubit_id): value for qubit_id, value in self.items()} - ) diff --git a/src/qibolab/native.py b/src/qibolab/native.py deleted file mode 100644 index b411cc9de2..0000000000 --- a/src/qibolab/native.py +++ /dev/null @@ -1,377 +0,0 @@ -from collections import defaultdict -from dataclasses import dataclass, field, fields, replace -from typing import List, Optional, Union - -from qibolab.pulses import ( - CouplerFluxPulse, - FluxPulse, - PulseConstructor, - PulseSequence, - PulseType, -) - - -@dataclass -class NativePulse: - """Container with parameters required to generate a pulse implementing a - native gate.""" - - name: str - """Name of the gate that the pulse implements.""" - duration: int - amplitude: float - shape: str - pulse_type: PulseType - qubit: "qubits.Qubit" - frequency: int = 0 - relative_start: int = 0 - """Relative start is relevant for two-qubit gate operations which - correspond to a pulse sequence.""" - - # used for qblox - if_frequency: Optional[int] = None - # TODO: Note sure if the following parameters are useful to be in the runcard - start: int = 0 - phase: float = 0.0 - - @classmethod - def from_dict(cls, name, pulse, qubit): - """Parse the dictionary provided by the runcard. - - Args: - name (str): Name of the native gate (dictionary key). - pulse (dict): Dictionary containing the parameters of the pulse implementing - the gate, as loaded from the runcard. - qubits (:class:`qibolab.platforms.abstract.Qubit`): Qubit that the - pulse is acting on - """ - kwargs = pulse.copy() - kwargs["pulse_type"] = PulseType(kwargs.pop("type")) - kwargs["qubit"] = qubit - return cls(name, **kwargs) - - @property - def raw(self): - data = { - fld.name: getattr(self, fld.name) - for fld in fields(self) - if getattr(self, fld.name) is not None - } - del data["name"] - del data["start"] - if self.pulse_type is PulseType.FLUX: - del data["frequency"] - del data["phase"] - data["qubit"] = self.qubit.name - data["type"] = data.pop("pulse_type").value - return data - - def pulse(self, start, relative_phase=0.0): - """Construct the :class:`qibolab.pulses.Pulse` object implementing the - gate. - - Args: - start (int): Start time of the pulse in the sequence. - relative_phase (float): Relative phase of the pulse. - - Returns: - A :class:`qibolab.pulses.DrivePulse` or :class:`qibolab.pulses.DrivePulse` - or :class:`qibolab.pulses.FluxPulse` with the pulse parameters of the gate. - """ - if self.pulse_type is PulseType.FLUX: - return FluxPulse( - start + self.relative_start, - self.duration, - self.amplitude, - self.shape, - channel=self.qubit.flux.name, - qubit=self.qubit.name, - ) - - pulse_cls = PulseConstructor[self.pulse_type.name].value - channel = getattr(self.qubit, self.pulse_type.name.lower()).name - return pulse_cls( - start + self.relative_start, - self.duration, - self.amplitude, - self.frequency, - relative_phase, - self.shape, - channel, - qubit=self.qubit.name, - ) - - -@dataclass -class VirtualZPulse: - """Container with parameters required to add a virtual Z phase in a pulse - sequence.""" - - phase: float - qubit: "qubits.Qubit" - - @property - def raw(self): - return {"type": "virtual_z", "phase": self.phase, "qubit": self.qubit.name} - - -@dataclass -class CouplerPulse: - """Container with parameters required to add a coupler pulse in a pulse - sequence.""" - - duration: int - amplitude: float - shape: str - coupler: "couplers.Coupler" - relative_start: int = 0 - - @classmethod - def from_dict(cls, pulse, coupler): - """Parse the dictionary provided by the runcard. - - Args: - name (str): Name of the native gate (dictionary key). - pulse (dict): Dictionary containing the parameters of the pulse implementing - the gate, as loaded from the runcard. - coupler (:class:`qibolab.platforms.abstract.Coupler`): Coupler that the - pulse is acting on - """ - kwargs = pulse.copy() - kwargs["coupler"] = coupler - kwargs.pop("type") - return cls(**kwargs) - - @property - def raw(self): - return { - "type": "coupler", - "duration": self.duration, - "amplitude": self.amplitude, - "shape": self.shape, - "coupler": self.coupler.name, - "relative_start": self.relative_start, - } - - def pulse(self, start): - """Construct the :class:`qibolab.pulses.Pulse` object implementing the - gate. - - Args: - start (int): Start time of the pulse in the sequence. - - Returns: - A :class:`qibolab.pulses.FluxPulse` with the pulse parameters of the gate. - """ - return CouplerFluxPulse( - start + self.relative_start, - self.duration, - self.amplitude, - self.shape, - channel=self.coupler.flux.name, - qubit=self.coupler.name, - ) - - -@dataclass -class NativeSequence: - """List of :class:`qibolab.platforms.native.NativePulse` objects - implementing a gate. - - Relevant for two-qubit gates, which usually require a sequence of - pulses to be implemented. These pulses may act on qubits different - than the qubits the gate is targeting. - """ - - name: str - pulses: List[Union[NativePulse, VirtualZPulse]] = field(default_factory=list) - coupler_pulses: List[CouplerPulse] = field(default_factory=list) - - @classmethod - def from_dict(cls, name, sequence, qubits, couplers): - """Constructs the native sequence from the dictionaries provided in the - runcard. - - Args: - name (str): Name of the gate the sequence is applying. - sequence (dict): Dictionary describing the sequence as provided in the runcard. - qubits (list): List of :class:`qibolab.qubits.Qubit` object for all - qubits in the platform. All qubits are required because the sequence may be - acting on qubits that the implemented gate is not targeting. - couplers (list): List of :class:`qibolab.couplers.Coupler` object for all - couplers in the platform. All couplers are required because the sequence may be - acting on couplers that the implemented gate is not targeting. - """ - pulses = [] - coupler_pulses = [] - - # If sequence contains only one pulse dictionary, convert it into a list that can be iterated below - if isinstance(sequence, dict): - sequence = [sequence] - - for i, pulse in enumerate(sequence): - pulse = pulse.copy() - pulse_type = pulse.pop("type") - if pulse_type == "coupler": - pulse["coupler"] = couplers[pulse.pop("coupler")] - coupler_pulses.append(CouplerPulse(**pulse)) - else: - qubit = qubits[pulse.pop("qubit")] - if pulse_type == "virtual_z": - phase = pulse["phase"] - pulses.append(VirtualZPulse(phase, qubit)) - else: - pulses.append( - NativePulse( - f"{name}{i}", - **pulse, - pulse_type=PulseType(pulse_type), - qubit=qubit, - ) - ) - return cls(name, pulses, coupler_pulses) - - @property - def raw(self): - pulses = [pulse.raw for pulse in self.pulses] - coupler_pulses = [pulse.raw for pulse in self.coupler_pulses] - return pulses + coupler_pulses - - def sequence(self, start=0): - """Creates a :class:`qibolab.pulses.PulseSequence` object implementing - the sequence.""" - sequence = PulseSequence() - virtual_z_phases = defaultdict(int) - - for pulse in self.pulses: - if isinstance(pulse, NativePulse): - sequence.add(pulse.pulse(start=start)) - else: - virtual_z_phases[pulse.qubit.name] += pulse.phase - - for coupler_pulse in self.coupler_pulses: - sequence.add(coupler_pulse.pulse(start=start)) - # TODO: Maybe ``virtual_z_phases`` should be an attribute of ``PulseSequence`` - return sequence, virtual_z_phases - - -@dataclass -class SingleQubitNatives: - """Container with the native single-qubit gates acting on a specific - qubit.""" - - RX: Optional[NativePulse] = None - """Pulse to drive the qubit from state 0 to state 1.""" - RX12: Optional[NativePulse] = None - """Pulse to drive to qubit from state 1 to state 2.""" - MZ: Optional[NativePulse] = None - """Measurement pulse.""" - - @property - def RX90(self) -> NativePulse: - """RX90 native pulse is inferred from RX by halving its amplitude.""" - return replace(self.RX, name="RX90", amplitude=self.RX.amplitude / 2.0) - - @classmethod - def from_dict(cls, qubit, native_gates): - """Parse native gates of the qubit from the runcard. - - Args: - qubit (:class:`qibolab.qubits.Qubit`): Qubit object that the - native gates are acting on. - native_gates (dict): Dictionary with native gate pulse parameters as loaded - from the runcard. - """ - pulses = { - n: NativePulse.from_dict(n, pulse, qubit=qubit) - for n, pulse in native_gates.items() - } - return cls(**pulses) - - @property - def raw(self): - """Serialize native gate pulses. - - ``None`` gates are not included. - """ - data = {} - for fld in fields(self): - attr = getattr(self, fld.name) - if attr is not None: - data[fld.name] = attr.raw - del data[fld.name]["qubit"] - return data - - -@dataclass -class CouplerNatives: - """Container with the native single-qubit gates acting on a specific - qubit.""" - - CP: Optional[NativePulse] = None - """Pulse to activate the coupler.""" - - @classmethod - def from_dict(cls, coupler, native_gates): - """Parse coupler native gates from the runcard. - - Args: - coupler (:class:`qibolab.couplers.Coupler`): Coupler object that the - native pulses are acting on. - native_gates (dict): Dictionary with native gate pulse parameters as loaded - from the runcard [Reusing the dict from qubits]. - """ - pulses = { - n: CouplerPulse.from_dict(pulse, coupler=coupler) - for n, pulse in native_gates.items() - } - return cls(**pulses) - - @property - def raw(self): - """Serialize native gate pulses. - - ``None`` gates are not included. - """ - data = {} - for fld in fields(self): - attr = getattr(self, fld.name) - if attr is not None: - data[fld.name] = attr.raw - return data - - -@dataclass -class TwoQubitNatives: - """Container with the native two-qubit gates acting on a specific pair of - qubits.""" - - CZ: Optional[NativeSequence] = field(default=None, metadata={"symmetric": True}) - CNOT: Optional[NativeSequence] = field(default=None, metadata={"symmetric": False}) - iSWAP: Optional[NativeSequence] = field(default=None, metadata={"symmetric": True}) - - @property - def symmetric(self): - """Check if the defined two-qubit gates are symmetric between target - and control qubits.""" - return all( - fld.metadata["symmetric"] or getattr(self, fld.name) is None - for fld in fields(self) - ) - - @classmethod - def from_dict(cls, qubits, couplers, native_gates): - sequences = { - n: NativeSequence.from_dict(n, seq, qubits, couplers) - for n, seq in native_gates.items() - } - return cls(**sequences) - - @property - def raw(self): - data = {} - for fld in fields(self): - gate = getattr(self, fld.name) - if gate is not None: - data[fld.name] = gate.raw - return data diff --git a/src/qibolab/platform/__init__.py b/src/qibolab/platform/__init__.py deleted file mode 100644 index 0b4565f39a..0000000000 --- a/src/qibolab/platform/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from .load import create_platform -from .platform import Platform, unroll_sequences - -__all__ = ["Platform", "create_platform", "unroll_sequences"] diff --git a/src/qibolab/platform/platform.py b/src/qibolab/platform/platform.py deleted file mode 100644 index 7477405caf..0000000000 --- a/src/qibolab/platform/platform.py +++ /dev/null @@ -1,427 +0,0 @@ -"""A platform for executing quantum algorithms.""" - -from collections import defaultdict -from dataclasses import dataclass, field, replace -from typing import Dict, List, Optional, Tuple - -import networkx as nx -from qibo.config import log, raise_error - -from qibolab.couplers import Coupler -from qibolab.execution_parameters import ExecutionParameters -from qibolab.instruments.abstract import Controller, Instrument, InstrumentId -from qibolab.pulses import Drag, FluxPulse, PulseSequence, ReadoutPulse -from qibolab.qubits import Qubit, QubitId, QubitPair, QubitPairId -from qibolab.sweeper import Sweeper -from qibolab.unrolling import batch - -InstrumentMap = Dict[InstrumentId, Instrument] -QubitMap = Dict[QubitId, Qubit] -CouplerMap = Dict[QubitId, Coupler] -QubitPairMap = Dict[QubitPairId, QubitPair] - -NS_TO_SEC = 1e-9 - - -def unroll_sequences( - sequences: List[PulseSequence], relaxation_time: int -) -> Tuple[PulseSequence, Dict[str, str]]: - """Unrolls a list of pulse sequences to a single pulse sequence with - multiple measurements. - - Args: - sequences (list): List of pulse sequences to unroll. - relaxation_time (int): Time in ns to wait for the qubit to relax between - playing different sequences. - - Returns: - total_sequence (:class:`qibolab.pulses.PulseSequence`): Unrolled pulse sequence containing - multiple measurements. - readout_map (dict): Map from original readout pulse serials to the unrolled readout pulse - serials. Required to construct the results dictionary that is returned after execution. - """ - total_sequence = PulseSequence() - readout_map = defaultdict(list) - start = 0 - for sequence in sequences: - for pulse in sequence: - new_pulse = pulse.copy() - new_pulse.start += start - total_sequence.add(new_pulse) - if isinstance(pulse, ReadoutPulse): - readout_map[pulse.serial].append(new_pulse.serial) - start = total_sequence.finish + relaxation_time - return total_sequence, readout_map - - -@dataclass -class Settings: - """Default execution settings read from the runcard.""" - - nshots: int = 1024 - """Default number of repetitions when executing a pulse sequence.""" - relaxation_time: int = int(1e5) - """Time in ns to wait for the qubit to relax to its ground state between - shots.""" - - def fill(self, options: ExecutionParameters): - """Use default values for missing execution options.""" - if options.nshots is None: - options = replace(options, nshots=self.nshots) - - if options.relaxation_time is None: - options = replace(options, relaxation_time=self.relaxation_time) - - return options - - -@dataclass -class Platform: - """Platform for controlling quantum devices.""" - - name: str - """Name of the platform.""" - qubits: QubitMap - """Dictionary mapping qubit names to :class:`qibolab.qubits.Qubit` - objects.""" - pairs: QubitPairMap - """Dictionary mapping tuples of qubit names to - :class:`qibolab.qubits.QubitPair` objects.""" - instruments: InstrumentMap - """Dictionary mapping instrument names to - :class:`qibolab.instruments.abstract.Instrument` objects.""" - - settings: Settings = field(default_factory=Settings) - """Container with default execution settings.""" - resonator_type: Optional[str] = None - """Type of resonator (2D or 3D) in the used QPU. - - Default is 3D for single-qubit chips and 2D for multi-qubit. - """ - - couplers: CouplerMap = field(default_factory=dict) - """Dictionary mapping coupler names to :class:`qibolab.couplers.Coupler` - objects.""" - - is_connected: bool = False - """Flag for whether we are connected to the physical instruments.""" - - topology: nx.Graph = field(default_factory=nx.Graph) - """Graph representing the qubit connectivity in the quantum chip.""" - - def __post_init__(self): - log.info("Loading platform %s", self.name) - if self.resonator_type is None: - self.resonator_type = "3D" if self.nqubits == 1 else "2D" - - self.topology.add_nodes_from(self.qubits.keys()) - self.topology.add_edges_from( - [(pair.qubit1.name, pair.qubit2.name) for pair in self.pairs.values()] - ) - - def __str__(self): - return self.name - - @property - def nqubits(self) -> int: - """Total number of usable qubits in the QPU.""" - return len(self.qubits) - - @property - def ordered_pairs(self): - """List of qubit pairs that are connected in the QPU.""" - return sorted({tuple(sorted(pair)) for pair in self.pairs}) - - @property - def sampling_rate(self): - """Sampling rate of control electronics in giga samples per second - (GSps).""" - for instrument in self.instruments.values(): - if isinstance(instrument, Controller): - return instrument.sampling_rate - - def connect(self): - """Connect to all instruments.""" - if not self.is_connected: - for instrument in self.instruments.values(): - try: - log.info(f"Connecting to instrument {instrument}.") - instrument.connect() - except Exception as exception: - raise_error( - RuntimeError, - f"Cannot establish connection to {instrument} instruments. Error captured: '{exception}'", - ) - self.is_connected = True - - def disconnect(self): - """Disconnects from instruments.""" - if self.is_connected: - for instrument in self.instruments.values(): - instrument.disconnect() - self.is_connected = False - - def _execute(self, sequence, options, **kwargs): - """Executes sequence on the controllers.""" - result = {} - - for instrument in self.instruments.values(): - if isinstance(instrument, Controller): - new_result = instrument.play( - self.qubits, self.couplers, sequence, options - ) - if isinstance(new_result, dict): - result.update(new_result) - - return result - - def execute_pulse_sequence( - self, sequence: PulseSequence, options: ExecutionParameters, **kwargs - ): - """ - Args: - sequence (:class:`qibolab.pulses.PulseSequence`): Pulse sequences to execute. - options (:class:`qibolab.platforms.platform.ExecutionParameters`): Object holding the execution options. - **kwargs: May need them for something - Returns: - Readout results acquired by after execution. - """ - options = self.settings.fill(options) - - time = ( - (sequence.duration + options.relaxation_time) * options.nshots * NS_TO_SEC - ) - log.info(f"Minimal execution time (sequence): {time}") - - return self._execute(sequence, options, **kwargs) - - @property - def _controller(self): - """Controller instrument used for splitting the unrolled sequences to - batches. - - Used only by :meth:`qibolab.platform.Platform.execute_pulse_sequences` (unrolling). - This method does not support platforms with more than one controller instruments. - """ - controllers = [ - instr - for instr in self.instruments.values() - if isinstance(instr, Controller) - ] - assert len(controllers) == 1 - return controllers[0] - - def execute_pulse_sequences( - self, sequences: List[PulseSequence], options: ExecutionParameters, **kwargs - ): - """ - Args: - sequence (List[:class:`qibolab.pulses.PulseSequence`]): Pulse sequences to execute. - options (:class:`qibolab.platforms.platform.ExecutionParameters`): Object holding the execution options. - **kwargs: May need them for something - Returns: - Readout results acquired by after execution. - """ - options = self.settings.fill(options) - - duration = sum(seq.duration for seq in sequences) - time = ( - (duration + len(sequences) * options.relaxation_time) - * options.nshots - * NS_TO_SEC - ) - log.info(f"Minimal execution time (unrolling): {time}") - - # find readout pulses - ro_pulses = { - pulse.serial: pulse.qubit - for sequence in sequences - for pulse in sequence.ro_pulses - } - - results = defaultdict(list) - bounds = kwargs.get("bounds", self._controller.bounds) - for b in batch(sequences, bounds): - sequence, readouts = unroll_sequences(b, options.relaxation_time) - result = self._execute(sequence, options, **kwargs) - for serial, new_serials in readouts.items(): - results[serial].extend(result[ser] for ser in new_serials) - - for serial, qubit in ro_pulses.items(): - results[qubit] = results[serial] - - return results - - def sweep( - self, sequence: PulseSequence, options: ExecutionParameters, *sweepers: Sweeper - ): - """Executes a pulse sequence for different values of sweeped - parameters. - - Useful for performing chip characterization. - - Example: - .. testcode:: - - import numpy as np - from qibolab.dummy import create_dummy - from qibolab.sweeper import Sweeper, Parameter - from qibolab.pulses import PulseSequence - from qibolab.execution_parameters import ExecutionParameters - - - platform = create_dummy() - sequence = PulseSequence() - parameter = Parameter.frequency - pulse = platform.create_qubit_readout_pulse(qubit=0, start=0) - sequence.add(pulse) - parameter_range = np.random.randint(10, size=10) - sweeper = Sweeper(parameter, parameter_range, [pulse]) - platform.sweep(sequence, ExecutionParameters(), sweeper) - - Returns: - Readout results acquired by after execution. - """ - if options.nshots is None: - options = replace(options, nshots=self.settings.nshots) - - if options.relaxation_time is None: - options = replace(options, relaxation_time=self.settings.relaxation_time) - - time = ( - (sequence.duration + options.relaxation_time) * options.nshots * NS_TO_SEC - ) - for sweep in sweepers: - time *= len(sweep.values) - log.info(f"Minimal execution time (sweep): {time}") - - result = {} - for instrument in self.instruments.values(): - if isinstance(instrument, Controller): - new_result = instrument.sweep( - self.qubits, self.couplers, sequence, options, *sweepers - ) - if isinstance(new_result, dict): - result.update(new_result) - return result - - def __call__(self, sequence, options): - return self.execute_pulse_sequence(sequence, options) - - def get_qubit(self, qubit): - """Return the name of the physical qubit corresponding to a logical - qubit. - - Temporary fix for the compiler to work for platforms where the - qubits are not named as 0, 1, 2, ... - """ - try: - return self.qubits[qubit].name - except KeyError: - return list(self.qubits.keys())[qubit] - - def get_coupler(self, coupler): - """Return the name of the physical coupler corresponding to a logical - coupler. - - Temporary fix for the compiler to work for platforms where the - couplers are not named as 0, 1, 2, ... - """ - try: - return self.couplers[coupler].name - except KeyError: - return list(self.couplers.keys())[coupler] - - def create_RX90_pulse(self, qubit, start=0, relative_phase=0): - qubit = self.get_qubit(qubit) - return self.qubits[qubit].native_gates.RX90.pulse(start, relative_phase) - - def create_RX_pulse(self, qubit, start=0, relative_phase=0): - qubit = self.get_qubit(qubit) - return self.qubits[qubit].native_gates.RX.pulse(start, relative_phase) - - def create_RX12_pulse(self, qubit, start=0, relative_phase=0): - qubit = self.get_qubit(qubit) - return self.qubits[qubit].native_gates.RX12.pulse(start, relative_phase) - - def create_CZ_pulse_sequence(self, qubits, start=0): - pair = tuple(self.get_qubit(q) for q in qubits) - if pair not in self.pairs or self.pairs[pair].native_gates.CZ is None: - raise_error( - ValueError, - f"Calibration for CZ gate between qubits {qubits[0]} and {qubits[1]} not found.", - ) - return self.pairs[pair].native_gates.CZ.sequence(start) - - def create_iSWAP_pulse_sequence(self, qubits, start=0): - pair = tuple(self.get_qubit(q) for q in qubits) - if pair not in self.pairs or self.pairs[pair].native_gates.iSWAP is None: - raise_error( - ValueError, - f"Calibration for iSWAP gate between qubits {qubits[0]} and {qubits[1]} not found.", - ) - return self.pairs[pair].native_gates.iSWAP.sequence(start) - - def create_CNOT_pulse_sequence(self, qubits, start=0): - pair = tuple(self.get_qubit(q) for q in qubits) - if pair not in self.pairs or self.pairs[pair].native_gates.CNOT is None: - raise_error( - ValueError, - f"Calibration for CNOT gate between qubits {qubits[0]} and {qubits[1]} not found.", - ) - return self.pairs[pair].native_gates.CNOT.sequence(start) - - def create_MZ_pulse(self, qubit, start): - qubit = self.get_qubit(qubit) - return self.qubits[qubit].native_gates.MZ.pulse(start) - - def create_qubit_drive_pulse(self, qubit, start, duration, relative_phase=0): - qubit = self.get_qubit(qubit) - pulse = self.qubits[qubit].native_gates.RX.pulse(start, relative_phase) - pulse.duration = duration - return pulse - - def create_qubit_readout_pulse(self, qubit, start): - qubit = self.get_qubit(qubit) - return self.create_MZ_pulse(qubit, start) - - def create_qubit_flux_pulse(self, qubit, start, duration, amplitude=1): - qubit = self.get_qubit(qubit) - pulse = FluxPulse( - start=start, - duration=duration, - amplitude=amplitude, - shape="Rectangular", - channel=self.qubits[qubit].flux.name, - qubit=qubit, - ) - pulse.duration = duration - return pulse - - def create_coupler_pulse(self, coupler, start, duration=None, amplitude=None): - coupler = self.get_coupler(coupler) - pulse = self.couplers[coupler].native_pulse.CP.pulse(start) - if duration is not None: - pulse.duration = duration - if amplitude is not None: - pulse.amplitude = amplitude - return pulse - - # TODO Remove RX90_drag_pulse and RX_drag_pulse, replace them with create_qubit_drive_pulse - # TODO Add RY90 and RY pulses - - def create_RX90_drag_pulse(self, qubit, start, beta, relative_phase=0): - """Create native RX90 pulse with Drag shape.""" - qubit = self.get_qubit(qubit) - pulse = self.qubits[qubit].native_gates.RX90.pulse(start, relative_phase) - pulse.shape = Drag(rel_sigma=pulse.shape.rel_sigma, beta=beta) - pulse.shape.pulse = pulse - return pulse - - def create_RX_drag_pulse(self, qubit, start, beta, relative_phase=0): - """Create native RX pulse with Drag shape.""" - qubit = self.get_qubit(qubit) - pulse = self.qubits[qubit].native_gates.RX.pulse(start, relative_phase) - pulse.shape = Drag(rel_sigma=pulse.shape.rel_sigma, beta=beta) - pulse.shape.pulse = pulse - return pulse diff --git a/src/qibolab/pulses.py b/src/qibolab/pulses.py deleted file mode 100644 index 8da469bb9e..0000000000 --- a/src/qibolab/pulses.py +++ /dev/null @@ -1,1649 +0,0 @@ -"""Pulse and PulseSequence classes.""" - -import copy -import re -from abc import ABC, abstractmethod -from dataclasses import dataclass -from enum import Enum -from typing import Optional - -import numpy as np -from qibo.config import log -from scipy.signal import lfilter - -SAMPLING_RATE = 1 -"""Default sampling rate in gigasamples per second (GSps). - -Used for generating waveform envelopes if the instruments do not provide -a different value. -""" - - -class PulseType(Enum): - """An enumeration to distinguish different types of pulses. - - READOUT pulses triger acquisitions. DRIVE pulses are used to control - qubit states. FLUX pulses are used to shift the frequency of flux - tunable qubits and with it implement two-qubit gates. - """ - - READOUT = "ro" - DRIVE = "qd" - FLUX = "qf" - COUPLERFLUX = "cf" - - -class Waveform: - """A class to save pulse waveforms. - - A waveform is a list of samples, or discrete data points, used by the digital to analogue converters (DACs) - to synthesise pulses. - - Attributes: - data (np.ndarray): a numpy array containing the samples. - serial (str): a string that can be used as a lable to identify the waveform. It is not automatically - generated, it must be set by the user. - """ - - DECIMALS = 5 - - def __init__(self, data): - """Initialises the waveform with a of samples.""" - - self.data: np.ndarray = np.array(data) - self.serial: str = "" - - def __len__(self): - """Returns the length of the waveform, the number of samples.""" - - return len(self.data) - - def __eq__(self, other): - """Compares two waveforms. - - Two waveforms are considered equal if their samples, rounded to - `Waveform.DECIMALS` decimal places, are all equal. - """ - - return self.__hash__() == other.__hash__() - - def __hash__(self): - """Returns a hash of the array of data, after rounding each sample to - `Waveform.DECIMALS` decimal places.""" - - return hash(str(np.around(self.data, Waveform.DECIMALS) + 0)) - - def __repr__(self): - """Returns the waveform serial as its string representation.""" - - return self.serial - - def plot(self, savefig_filename=None): - """Plots the waveform. - - Args: - savefig_filename (str): a file path. If provided the plot is save to a file. - """ - - import matplotlib.pyplot as plt - - plt.figure(figsize=(14, 5), dpi=200) - plt.plot(self.data, c="C0", linestyle="dashed") - plt.xlabel("Sample Number") - plt.ylabel("Amplitude") - plt.grid( - visible=True, which="both", axis="both", color="#888888", linestyle="-" - ) - plt.suptitle(self.serial) - if savefig_filename: - plt.savefig(savefig_filename) - else: - plt.show() - plt.close() - - -class ShapeInitError(RuntimeError): - """Error raised when a pulse has not been fully defined.""" - - default_msg = "PulseShape attribute pulse must be initialised in order to be able to generate pulse waveforms" - - def __init__(self, msg=None, *args): - if msg is None: - msg = self.default_msg - super().__init__(msg, *args) - - -class PulseShape(ABC): - """Abstract class for pulse shapes. - - This object is responsible for generating envelope and modulated - waveforms from a set of pulse parameters and its type. Generates - both i (in-phase) and q (quadrature) components. - """ - - pulse = None - """Pulse (Pulse): the pulse associated with it. - - Its parameters are used to generate pulse waveforms. - """ - - @abstractmethod - def envelope_waveform_i( - self, sampling_rate=SAMPLING_RATE - ) -> Waveform: # pragma: no cover - raise NotImplementedError - - @abstractmethod - def envelope_waveform_q( - self, sampling_rate=SAMPLING_RATE - ) -> Waveform: # pragma: no cover - raise NotImplementedError - - def envelope_waveforms( - self, sampling_rate=SAMPLING_RATE - ): # -> tuple[Waveform, Waveform]: # pragma: no cover - """A tuple with the i and q envelope waveforms of the pulse.""" - - return ( - self.envelope_waveform_i(sampling_rate), - self.envelope_waveform_q(sampling_rate), - ) - - def modulated_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The waveform of the i component of the pulse, modulated with its - frequency.""" - - return self.modulated_waveforms(sampling_rate)[0] - - def modulated_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The waveform of the q component of the pulse, modulated with its - frequency.""" - - return self.modulated_waveforms(sampling_rate)[1] - - def modulated_waveforms(self, sampling_rate=SAMPLING_RATE): - """A tuple with the i and q waveforms of the pulse, modulated with its - frequency.""" - - pulse = self.pulse - if abs(pulse._if) * 2 > sampling_rate: - log.info( - f"WARNING: The frequency of pulse {pulse.serial} is higher than the nyqusit frequency ({int(sampling_rate // 2)}) for the device sampling rate: {int(sampling_rate)}" - ) - num_samples = int(np.rint(pulse.duration * sampling_rate)) - time = np.arange(num_samples) / sampling_rate - global_phase = pulse.global_phase - cosalpha = np.cos( - 2 * np.pi * pulse._if * time + global_phase + pulse.relative_phase - ) - sinalpha = np.sin( - 2 * np.pi * pulse._if * time + global_phase + pulse.relative_phase - ) - - mod_matrix = np.array([[cosalpha, -sinalpha], [sinalpha, cosalpha]]) / np.sqrt( - 2 - ) - - (envelope_waveform_i, envelope_waveform_q) = self.envelope_waveforms( - sampling_rate - ) - result = [] - for n, t, ii, qq in zip( - np.arange(num_samples), - time, - envelope_waveform_i.data, - envelope_waveform_q.data, - ): - result.append(mod_matrix[:, :, n] @ np.array([ii, qq])) - mod_signals = np.array(result) - - modulated_waveform_i = Waveform(mod_signals[:, 0]) - modulated_waveform_i.serial = f"Modulated_Waveform_I(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)}, frequency = {format(pulse._if, '_')}, phase = {format(global_phase + pulse.relative_phase, '.6f').rstrip('0').rstrip('.')})" - modulated_waveform_q = Waveform(mod_signals[:, 1]) - modulated_waveform_q.serial = f"Modulated_Waveform_Q(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)}, frequency = {format(pulse._if, '_')}, phase = {format(global_phase + pulse.relative_phase, '.6f').rstrip('0').rstrip('.')})" - return (modulated_waveform_i, modulated_waveform_q) - - def __eq__(self, item) -> bool: - """Overloads == operator.""" - return isinstance(item, type(self)) - - @staticmethod - def eval(value: str) -> "PulseShape": - """Deserialize string representation. - - .. todo:: - - To be replaced by proper serialization. - """ - shape_name = re.findall(r"(\w+)", value)[0] - if shape_name not in globals(): - raise ValueError(f"shape {value} not found") - shape_parameters = re.findall(r"[-\w+\d\.\d]+", value)[1:] - # TODO: create multiple tests to prove regex working correctly - return globals()[shape_name](*shape_parameters) - - -class Rectangular(PulseShape): - """Rectangular pulse shape.""" - - def __init__(self): - self.name = "Rectangular" - self.pulse: Pulse = None - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the i component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - waveform = Waveform(self.pulse.amplitude * np.ones(num_samples)) - waveform.serial = f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the q component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - waveform = Waveform(np.zeros(num_samples)) - waveform.serial = f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def __repr__(self): - return f"{self.name}()" - - -class Exponential(PulseShape): - r"""Exponential pulse shape (Square pulse with an exponential decay). - - Args: - tau (float): Parameter that controls the decay of the first exponential function - upsilon (float): Parameter that controls the decay of the second exponential function - g (float): Parameter that weights the second exponential function - - - .. math:: - - A\frac{\exp\left(-\frac{x}{\text{upsilon}}\right) + g \exp\left(-\frac{x}{\text{tau}}\right)}{1 + g} - """ - - def __init__(self, tau: float, upsilon: float, g: float = 0.1): - self.name = "Exponential" - self.pulse: Pulse = None - self.tau: float = float(tau) - self.upsilon: float = float(upsilon) - self.g: float = float(g) - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the i component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - x = np.arange(0, num_samples, 1) - waveform = Waveform( - self.pulse.amplitude - * ( - (np.ones(num_samples) * np.exp(-x / self.upsilon)) - + self.g * np.exp(-x / self.tau) - ) - / (1 + self.g) - ) - - waveform.serial = f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the q component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - waveform = Waveform(np.zeros(num_samples)) - waveform.serial = f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def __repr__(self): - return f"{self.name}({format(self.tau, '.3f').rstrip('0').rstrip('.')}, {format(self.upsilon, '.3f').rstrip('0').rstrip('.')}, {format(self.g, '.3f').rstrip('0').rstrip('.')})" - - -class Gaussian(PulseShape): - r"""Gaussian pulse shape. - - Args: - rel_sigma (float): relative sigma so that the pulse standard deviation (sigma) = duration / rel_sigma - - .. math:: - - A\exp^{-\frac{1}{2}\frac{(t-\mu)^2}{\sigma^2}} - """ - - def __init__(self, rel_sigma: float): - self.name = "Gaussian" - self.pulse: Pulse = None - self.rel_sigma: float = float(rel_sigma) - - def __eq__(self, item) -> bool: - """Overloads == operator.""" - if super().__eq__(item): - return self.rel_sigma == item.rel_sigma - return False - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the i component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - x = np.arange(0, num_samples, 1) - waveform = Waveform( - self.pulse.amplitude - * np.exp( - -(1 / 2) - * ( - ((x - (num_samples - 1) / 2) ** 2) - / (((num_samples) / self.rel_sigma) ** 2) - ) - ) - ) - waveform.serial = f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the q component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - waveform = Waveform(np.zeros(num_samples)) - waveform.serial = f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def __repr__(self): - return f"{self.name}({format(self.rel_sigma, '.6f').rstrip('0').rstrip('.')})" - - -class GaussianSquare(PulseShape): - r"""GaussianSquare pulse shape. - - Args: - rel_sigma (float): relative sigma so that the pulse standard deviation (sigma) = duration / rel_sigma - width (float): Percentage of the pulse that is flat - - .. math:: - - A\exp^{-\frac{1}{2}\frac{(t-\mu)^2}{\sigma^2}}[Rise] + Flat + A\exp^{-\frac{1}{2}\frac{(t-\mu)^2}{\sigma^2}}[Decay] - """ - - def __init__(self, rel_sigma: float, width: float): - self.name = "GaussianSquare" - self.pulse: Pulse = None - self.rel_sigma: float = float(rel_sigma) - self.width: float = float(width) - - def __eq__(self, item) -> bool: - """Overloads == operator.""" - if super().__eq__(item): - return self.rel_sigma == item.rel_sigma and self.width == item.width - return False - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the i component of the pulse.""" - - if self.pulse: - - def gaussian(t, rel_sigma, gaussian_samples): - mu = (2 * gaussian_samples - 1) / 2 - sigma = (2 * gaussian_samples) / rel_sigma - return np.exp(-0.5 * ((t - mu) / sigma) ** 2) - - def fvec(t, gaussian_samples, rel_sigma, length=None): - if length is None: - length = t.shape[0] - - pulse = np.ones_like(t, dtype=float) - rise = t < gaussian_samples - fall = t > length - gaussian_samples - 1 - pulse[rise] = gaussian(t[rise], rel_sigma, gaussian_samples) - pulse[fall] = gaussian(t[rise], rel_sigma, gaussian_samples)[::-1] - return pulse - - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - gaussian_samples = num_samples * (1 - self.width) // 2 - t = np.arange(0, num_samples) - - pulse = fvec(t, gaussian_samples, rel_sigma=self.rel_sigma) - - waveform = Waveform(self.pulse.amplitude * pulse) - waveform.serial = f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - - raise ShapeInitError - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the q component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - waveform = Waveform(np.zeros(num_samples)) - waveform.serial = f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def __repr__(self): - return f"{self.name}({format(self.rel_sigma, '.6f').rstrip('0').rstrip('.')}, {format(self.width, '.6f').rstrip('0').rstrip('.')})" - - -class Drag(PulseShape): - """Derivative Removal by Adiabatic Gate (DRAG) pulse shape. - - Args: - rel_sigma (float): relative sigma so that the pulse standard deviation (sigma) = duration / rel_sigma - beta (float): relative sigma so that the pulse standard deviation (sigma) = duration / rel_sigma - .. math:: - """ - - def __init__(self, rel_sigma, beta): - self.name = "Drag" - self.pulse: Pulse = None - self.rel_sigma = float(rel_sigma) - self.beta = float(beta) - - def __eq__(self, item) -> bool: - """Overloads == operator.""" - if super().__eq__(item): - return self.rel_sigma == item.rel_sigma and self.beta == item.beta - return False - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the i component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - x = np.arange(0, num_samples, 1) - i = self.pulse.amplitude * np.exp( - -(1 / 2) - * ( - ((x - (num_samples - 1) / 2) ** 2) - / (((num_samples) / self.rel_sigma) ** 2) - ) - ) - waveform = Waveform(i) - waveform.serial = f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the q component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - x = np.arange(0, num_samples, 1) - i = self.pulse.amplitude * np.exp( - -(1 / 2) - * ( - ((x - (num_samples - 1) / 2) ** 2) - / (((num_samples) / self.rel_sigma) ** 2) - ) - ) - q = ( - self.beta - * (-(x - (num_samples - 1) / 2) / ((num_samples / self.rel_sigma) ** 2)) - * i - ) - waveform = Waveform(q) - waveform.serial = f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def __repr__(self): - return f"{self.name}({format(self.rel_sigma, '.6f').rstrip('0').rstrip('.')}, {format(self.beta, '.6f').rstrip('0').rstrip('.')})" - - -class IIR(PulseShape): - """IIR Filter using scipy.signal lfilter.""" - - # https://arxiv.org/pdf/1907.04818.pdf (page 11 - filter formula S22) - # p = [A, tau_iir] - # p = [b0 = 1−k +k ·α, b1 = −(1−k)·(1−α),a0 = 1 and a1 = −(1−α)] - # p = [b0, b1, a0, a1] - - def __init__(self, b, a, target: PulseShape): - self.name = "IIR" - self.target: PulseShape = target - self._pulse: Pulse = None - self.a: np.ndarray = np.array(a) - self.b: np.ndarray = np.array(b) - # Check len(a) = len(b) = 2 - - def __eq__(self, item) -> bool: - """Overloads == operator.""" - if super().__eq__(item): - return ( - self.target == item.target - and (self.a == item.a).all() - and (self.b == item.b).all() - ) - return False - - @property - def pulse(self): - return self._pulse - - @pulse.setter - def pulse(self, value): - self._pulse = value - self.target.pulse = value - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the i component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - self.a = self.a / self.a[0] - gain = np.sum(self.b) / np.sum(self.a) - if not gain == 0: - self.b = self.b / gain - data = lfilter( - b=self.b, - a=self.a, - x=self.target.envelope_waveform_i(sampling_rate).data, - ) - if not np.max(np.abs(data)) == 0: - data = data / np.max(np.abs(data)) - data = np.abs(self.pulse.amplitude) * data - waveform = Waveform(data) - waveform.serial = f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the q component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - self.a = self.a / self.a[0] - gain = np.sum(self.b) / np.sum(self.a) - if not gain == 0: - self.b = self.b / gain - data = lfilter( - b=self.b, - a=self.a, - x=self.target.envelope_waveform_q(sampling_rate).data, - ) - if not np.max(np.abs(data)) == 0: - data = data / np.max(np.abs(data)) - data = np.abs(self.pulse.amplitude) * data - waveform = Waveform(data) - waveform.serial = f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def __repr__(self): - formatted_b = [round(b, 3) for b in self.b] - formatted_a = [round(a, 3) for a in self.a] - return f"{self.name}({formatted_b}, {formatted_a}, {self.target})" - - -class SNZ(PulseShape): - """Sudden variant Net Zero. - - https://arxiv.org/abs/2008.07411 - (Supplementary materials: FIG. S1.) - """ - - def __init__(self, t_idling, b_amplitude=None): - self.name = "SNZ" - self.pulse: Pulse = None - self.t_idling: float = t_idling - self.b_amplitude = b_amplitude - - def __eq__(self, item) -> bool: - """Overloads == operator.""" - if super().__eq__(item): - return ( - self.t_idling == item.t_idling and self.b_amplitude == item.b_amplitude - ) - return False - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the i component of the pulse.""" - - if self.pulse: - if self.t_idling > self.pulse.duration: - raise ValueError( - f"Cannot put idling time {self.t_idling} higher than duration {self.pulse.duration}." - ) - if self.b_amplitude is None: - self.b_amplitude = self.pulse.amplitude / 2 - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - half_pulse_duration = (self.pulse.duration - self.t_idling) / 2 - half_flux_pulse_samples = int( - np.rint(num_samples * half_pulse_duration / self.pulse.duration) - ) - idling_samples = num_samples - 2 * half_flux_pulse_samples - waveform = Waveform( - np.concatenate( - ( - self.pulse.amplitude * np.ones(half_flux_pulse_samples - 1), - np.array([self.b_amplitude]), - np.zeros(idling_samples), - -np.array([self.b_amplitude]), - -self.pulse.amplitude * np.ones(half_flux_pulse_samples - 1), - ) - ) - ) - waveform.serial = f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the q component of the pulse.""" - - if self.pulse: - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - waveform = Waveform(np.zeros(num_samples)) - waveform.serial = f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def __repr__(self): - return f"{self.name}({self.t_idling})" - - -class eCap(PulseShape): - r"""ECap pulse shape. - - Args: - alpha (float): - - .. math:: - - e_{\cap(t,\alpha)} &=& A[1 + \tanh(\alpha t/t_\theta)][1 + \tanh(\alpha (1 - t/t_\theta))]\\ - &\times& [1 + \tanh(\alpha/2)]^{-2} - """ - - def __init__(self, alpha: float): - self.name = "eCap" - self.pulse: Pulse = None - self.alpha: float = float(alpha) - - def __eq__(self, item) -> bool: - """Overloads == operator.""" - if super().__eq__(item): - return self.alpha == item.alpha - return False - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - if self.pulse: - num_samples = int(self.pulse.duration * sampling_rate) - x = np.arange(0, num_samples, 1) - waveform = Waveform( - self.pulse.amplitude - * (1 + np.tanh(self.alpha * x / num_samples)) - * (1 + np.tanh(self.alpha * (1 - x / num_samples))) - / (1 + np.tanh(self.alpha / 2)) ** 2 - ) - waveform.serial = f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - if self.pulse: - num_samples = int(self.pulse.duration * sampling_rate) - waveform = Waveform(np.zeros(num_samples)) - waveform.serial = f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def __repr__(self): - return f"{self.name}({format(self.alpha, '.6f').rstrip('0').rstrip('.')})" - - -class Custom(PulseShape): - """Arbitrary shape.""" - - def __init__(self, envelope_i, envelope_q=None): - self.name = "Custom" - self.pulse: Pulse = None - self.envelope_i: np.ndarray = np.array(envelope_i) - if envelope_q is not None: - self.envelope_q: np.ndarray = np.array(envelope_q) - else: - self.envelope_q = self.envelope_i - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the i component of the pulse.""" - - if self.pulse: - if self.pulse.duration != len(self.envelope_i): - raise ValueError("Length of envelope_i must be equal to pulse duration") - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - - waveform = Waveform(self.envelope_i * self.pulse.amplitude) - waveform.serial = f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the q component of the pulse.""" - - if self.pulse: - if self.pulse.duration != len(self.envelope_q): - raise ValueError("Length of envelope_q must be equal to pulse duration") - num_samples = int(np.rint(self.pulse.duration * sampling_rate)) - - waveform = Waveform(self.envelope_q * self.pulse.amplitude) - waveform.serial = f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(self.pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {repr(self)})" - return waveform - raise ShapeInitError - - def __repr__(self): - return f"{self.name}({self.envelope_i[:3]}, ..., {self.envelope_q[:3]}, ...)" - - -@dataclass -class Pulse: - """A class to represent a pulse to be sent to the QPU.""" - - start: int - """Start time of pulse in ns.""" - duration: int - """Pulse duration in ns.""" - amplitude: float - """Pulse digital amplitude (unitless). - - Pulse amplitudes are normalised between -1 and 1. - """ - frequency: int - """Pulse Intermediate Frequency in Hz. - - The value has to be in the range [10e6 to 300e6]. - """ - relative_phase: float - """Relative phase of the pulse, in radians.""" - shape: PulseShape - """Pulse shape, as a PulseShape object. - - See - :py: mod:`qibolab.pulses` for list of available shapes. - """ - channel: Optional[str] = None - """Channel on which the pulse should be played. - - When a sequence of pulses is sent to the platform for execution, - each pulse is sent to the instrument responsible for playing pulses - the pulse channel. The connection of instruments with channels is - defined in the platform runcard. - """ - type: PulseType = PulseType.DRIVE - """Pulse type, as an element of PulseType enumeration.""" - qubit: int = 0 - """Qubit or coupler addressed by the pulse.""" - _if: int = 0 - - def __post_init__(self): - if isinstance(self.type, str): - self.type = PulseType(self.type) - if isinstance(self.shape, str): - self.shape = PulseShape.eval(self.shape) - # TODO: drop the cyclic reference - self.shape.pulse = self - - @property - def finish(self) -> Optional[int]: - """Time when the pulse is scheduled to finish.""" - if None in {self.start, self.duration}: - return None - return self.start + self.duration - - @property - def global_phase(self): - """Global phase of the pulse, in radians. - - This phase is calculated from the pulse start time and frequency - as `2 * pi * frequency * start`. - """ - - # pulse start, duration and finish are in ns - return 2 * np.pi * self.frequency * self.start / 1e9 - - @property - def phase(self) -> float: - """Total phase of the pulse, in radians. - - The total phase is computed as the sum of the global and - relative phases. - """ - return self.global_phase + self.relative_phase - - @property - def serial(self) -> str: - """Returns a string representation of the pulse.""" - - return f"Pulse({self.start}, {self.duration}, {format(self.amplitude, '.6f').rstrip('0').rstrip('.')}, {format(self.frequency, '_')}, {format(self.relative_phase, '.6f').rstrip('0').rstrip('.')}, {self.shape}, {self.channel}, {self.type}, {self.qubit})" - - @property - def id(self) -> int: - return id(self) - - def envelope_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the i component of the pulse.""" - - return self.shape.envelope_waveform_i(sampling_rate) - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The envelope waveform of the q component of the pulse.""" - - return self.shape.envelope_waveform_q(sampling_rate) - - def envelope_waveforms( - self, sampling_rate=SAMPLING_RATE - ): # -> tuple[Waveform, Waveform]: - """A tuple with the i and q envelope waveforms of the pulse.""" - - return ( - self.shape.envelope_waveform_i(sampling_rate), - self.shape.envelope_waveform_q(sampling_rate), - ) - - def modulated_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The waveform of the i component of the pulse, modulated with its - frequency.""" - - return self.shape.modulated_waveform_i(sampling_rate) - - def modulated_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """The waveform of the q component of the pulse, modulated with its - frequency.""" - - return self.shape.modulated_waveform_q(sampling_rate) - - def modulated_waveforms(self, sampling_rate): # -> tuple[Waveform, Waveform]: - """A tuple with the i and q waveforms of the pulse, modulated with its - frequency.""" - - return self.shape.modulated_waveforms(sampling_rate) - - def __repr__(self): - return self.serial - - def __hash__(self): - return hash(self.serial) - - def __eq__(self, other): - if isinstance(other, Pulse): - return self.serial == other.serial - return False - - def __add__(self, other): - if isinstance(other, Pulse): - return PulseSequence(self, other) - if isinstance(other, PulseSequence): - return PulseSequence(self, *other.pulses) - raise TypeError(f"Expected Pulse or PulseSequence; got {type(other).__name__}") - - def __mul__(self, n): - if not isinstance(n, int): - raise TypeError(f"Expected int; got {type(n).__name__}") - if n < 0: - raise TypeError(f"argument n should be >=0, got {n}") - return PulseSequence(*([self.copy()] * n)) - - def __rmul__(self, n): - return self.__mul__(n) - - def copy(self): # -> Pulse|ReadoutPulse|DrivePulse|FluxPulse: - """Returns a new Pulse object with the same attributes.""" - - if type(self) == ReadoutPulse: - return ReadoutPulse( - self.start, - self.duration, - self.amplitude, - self.frequency, - self.relative_phase, - repr(self.shape), # self.shape, - self.channel, - self.qubit, - ) - elif type(self) == DrivePulse: - return DrivePulse( - self.start, - self.duration, - self.amplitude, - self.frequency, - self.relative_phase, - repr(self.shape), # self.shape, - self.channel, - self.qubit, - ) - - elif type(self) == FluxPulse: - return FluxPulse( - self.start, - self.duration, - self.amplitude, - self.shape, - self.channel, - self.qubit, - ) - else: - # return eval(self.serial) - return Pulse( - self.start, - self.duration, - self.amplitude, - self.frequency, - self.relative_phase, - repr(self.shape), # self.shape, - self.channel, - self.type, - self.qubit, - ) - - def shallow_copy(self): # -> Pulse: - return Pulse( - self.start, - self.duration, - self.amplitude, - self.frequency, - self.relative_phase, - self.shape, - self.channel, - self.type, - self.qubit, - ) - - def is_equal_ignoring_start(self, item) -> bool: - """Check if two pulses are equal ignoring start time.""" - return ( - self.duration == item.duration - and self.amplitude == item.amplitude - and self.frequency == item.frequency - and self.relative_phase == item.relative_phase - and self.shape == item.shape - and self.channel == item.channel - and self.type == item.type - and self.qubit == item.qubit - ) - - def plot(self, savefig_filename=None, sampling_rate=SAMPLING_RATE): - """Plots the pulse envelope and modulated waveforms. - - Args: - savefig_filename (str): a file path. If provided the plot is save to a file. - """ - - import matplotlib.pyplot as plt - from matplotlib import gridspec - - waveform_i = self.shape.envelope_waveform_i(sampling_rate) - waveform_q = self.shape.envelope_waveform_q(sampling_rate) - - num_samples = len(waveform_i) - time = self.start + np.arange(num_samples) / sampling_rate - fig = plt.figure(figsize=(14, 5), dpi=200) - gs = gridspec.GridSpec(ncols=2, nrows=1, width_ratios=[2, 1]) - ax1 = plt.subplot(gs[0]) - ax1.plot( - time, - waveform_i.data, - label="envelope i", - c="C0", - linestyle="dashed", - ) - ax1.plot( - time, - waveform_q.data, - label="envelope q", - c="C1", - linestyle="dashed", - ) - ax1.plot( - time, - self.shape.modulated_waveform_i(sampling_rate).data, - label="modulated i", - c="C0", - ) - ax1.plot( - time, - self.shape.modulated_waveform_q(sampling_rate).data, - label="modulated q", - c="C1", - ) - ax1.plot(time, -waveform_i.data, c="silver", linestyle="dashed") - ax1.set_xlabel("Time [ns]") - ax1.set_ylabel("Amplitude") - - ax1.grid( - visible=True, which="both", axis="both", color="#888888", linestyle="-" - ) - ax1.axis([self.start, self.finish, -1, 1]) - ax1.legend() - - modulated_i = self.shape.modulated_waveform_i(sampling_rate).data - modulated_q = self.shape.modulated_waveform_q(sampling_rate).data - ax2 = plt.subplot(gs[1]) - ax2.plot( - modulated_i, - modulated_q, - label="modulated", - c="C3", - ) - ax2.plot( - waveform_i.data, - waveform_q.data, - label="envelope", - c="C2", - ) - ax2.plot( - modulated_i[0], - modulated_q[0], - marker="o", - markersize=5, - label="start", - c="lightcoral", - ) - ax2.plot( - modulated_i[-1], - modulated_q[-1], - marker="o", - markersize=5, - label="finish", - c="darkred", - ) - - ax2.plot( - np.cos(time * 2 * np.pi / self.duration), - np.sin(time * 2 * np.pi / self.duration), - c="silver", - linestyle="dashed", - ) - - ax2.grid( - visible=True, which="both", axis="both", color="#888888", linestyle="-" - ) - ax2.legend() - # ax2.axis([ -1, 1, -1, 1]) - ax2.axis("equal") - plt.suptitle(self.serial) - if savefig_filename: - plt.savefig(savefig_filename) - else: - plt.show() - plt.close() - - -class ReadoutPulse(Pulse): - """Describes a readout pulse. - - See - :class: `qibolab.pulses.Pulse` for argument desciption. - """ - - def __init__( - self, - start, - duration, - amplitude, - frequency, - relative_phase, - shape, - channel=0, - qubit=0, - ): - super().__init__( - start, - duration, - amplitude, - frequency, - relative_phase, - shape, - channel, - type=PulseType.READOUT, - qubit=qubit, - ) - - @property - def serial(self): - return f"ReadoutPulse({self.start}, {self.duration}, {format(self.amplitude, '.6f').rstrip('0').rstrip('.')}, {format(self.frequency, '_')}, {format(self.relative_phase, '.6f').rstrip('0').rstrip('.')}, {self.shape}, {self.channel}, {self.qubit})" - - @property - def global_phase(self): - # readout pulses should have zero global phase so that we can - # calculate probabilities in the i-q plane - return 0 - - def copy(self): # -> Pulse|ReadoutPulse|DrivePulse|FluxPulse: - """Returns a new Pulse object with the same attributes.""" - - return ReadoutPulse( - self.start, - self.duration, - self.amplitude, - self.frequency, - self.relative_phase, - copy.deepcopy(self.shape), # self.shape, - self.channel, - self.qubit, - ) - - -class DrivePulse(Pulse): - """Describes a qubit drive pulse. - - See - :class: `qibolab.pulses.Pulse` for argument desciption. - """ - - def __init__( - self, - start, - duration, - amplitude, - frequency, - relative_phase, - shape, - channel=0, - qubit=0, - ): - super().__init__( - start, - duration, - amplitude, - frequency, - relative_phase, - shape, - channel, - type=PulseType.DRIVE, - qubit=qubit, - ) - - @property - def serial(self): - return f"DrivePulse({self.start}, {self.duration}, {format(self.amplitude, '.6f').rstrip('0').rstrip('.')}, {format(self.frequency, '_')}, {format(self.relative_phase, '.6f').rstrip('0').rstrip('.')}, {self.shape}, {self.channel}, {self.qubit})" - - -class FluxPulse(Pulse): - """Describes a qubit flux pulse. - - Flux pulses have frequency and relative_phase equal to 0. Their i - and q components are equal. See - :class: `qibolab.pulses.Pulse` for argument desciption. - """ - - PULSE_TYPE = PulseType.FLUX - - def __init__(self, start, duration, amplitude, shape, channel=0, qubit=0): - super().__init__( - start, - duration, - amplitude, - 0, - 0, - shape, - channel, - type=self.PULSE_TYPE, - qubit=qubit, - ) - - def envelope_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - """Flux pulses only have i component.""" - return self.shape.envelope_waveform_i(sampling_rate) - - def modulated_waveform_i(self, sampling_rate=SAMPLING_RATE) -> Waveform: - return self.shape.envelope_waveform_i(sampling_rate) - - def modulated_waveform_q(self, sampling_rate=SAMPLING_RATE) -> Waveform: - return self.shape.envelope_waveform_i(sampling_rate) - - @property - def serial(self): - return f"{self.__class__.__name__}({self.start}, {self.duration}, {format(self.amplitude, '.6f').rstrip('0').rstrip('.')}, {self.shape}, {self.channel}, {self.qubit})" - - -class CouplerFluxPulse(FluxPulse): - """Describes a coupler flux pulse. - - See - :class: `qibolab.pulses.FluxPulse` for argument desciption. - """ - - PULSE_TYPE = PulseType.COUPLERFLUX - - -class PulseConstructor(Enum): - """An enumeration to map each ``PulseType`` to the proper pulse - constructor.""" - - READOUT = ReadoutPulse - DRIVE = DrivePulse - FLUX = FluxPulse - - -class PulseSequence: - """A collection of scheduled pulses. - - A quantum circuit can be translated into a set of scheduled pulses - that implement the circuit gates. This class contains many - supporting fuctions to facilitate the creation and manipulation of - these collections of pulses. None of the methods of PulseSequence - modify any of the properties of its pulses. - """ - - def __init__(self, *pulses): - self.pulses = [] #: list[Pulse] = [] - """Pulses (list): a list containing the pulses, ordered by their - channel and start times.""" - self.add(*pulses) - - def __len__(self): - return len(self.pulses) - - def __iter__(self): - return iter(self.pulses) - - def __getitem__(self, index): - return self.pulses[index] - - def __setitem__(self, index, value): - self.pulses[index] = value - - def __delitem__(self, index): - del self.pulses[index] - - def __contains__(self, pulse): - return pulse in self.pulses - - def __repr__(self): - return self.serial - - @property - def serial(self): - """Returns a string representation of the pulse sequence.""" - - return "PulseSequence\n" + "\n".join(f"{pulse.serial}" for pulse in self.pulses) - - def __eq__(self, other): - if not isinstance(other, PulseSequence): - raise TypeError(f"Expected PulseSequence; got {type(other).__name__}") - return self.serial == other.serial - - def __ne__(self, other): - if not isinstance(other, PulseSequence): - raise TypeError(f"Expected PulseSequence; got {type(other).__name__}") - return self.serial != other.serial - - def __hash__(self): - return hash(self.serial) - - def __add__(self, other): - if isinstance(other, PulseSequence): - return PulseSequence(*self.pulses, *other.pulses) - if isinstance(other, Pulse): - return PulseSequence(*self.pulses, other) - raise TypeError(f"Expected PulseSequence or Pulse; got {type(other).__name__}") - - def __radd__(self, other): - if isinstance(other, PulseSequence): - return PulseSequence(*other.pulses, *self.pulses) - if isinstance(other, Pulse): - return PulseSequence(other, *self.pulses) - raise TypeError(f"Expected PulseSequence or Pulse; got {type(other).__name__}") - - def __iadd__(self, other): - if isinstance(other, PulseSequence): - self.add(*other.pulses) - elif isinstance(other, Pulse): - self.add(other) - else: - raise TypeError( - f"Expected PulseSequence or Pulse; got {type(other).__name__}" - ) - return self - - def __mul__(self, n): - if not isinstance(n, int): - raise TypeError(f"Expected int; got {type(n).__name__}") - if n < 0: - raise TypeError(f"argument n should be >=0, got {n}") - return PulseSequence(*(self.pulses * n)) - - def __rmul__(self, n): - if not isinstance(n, int): - raise TypeError(f"Expected int; got {type(n).__name__}") - if n < 0: - raise TypeError(f"argument n should be >=0, got {n}") - return PulseSequence(*(self.pulses * n)) - - def __imul__(self, n): - if not isinstance(n, int): - raise TypeError(f"Expected int; got {type(n).__name__}") - if n < 1: - raise TypeError(f"argument n should be >=1, got {n}") - original_set = self.shallow_copy() - for x in range(n - 1): - self.add(*original_set.pulses) - return self - - @property - def count(self): - """Returns the number of pulses in the sequence.""" - - return len(self.pulses) - - def add(self, *items): - """Adds pulses to the sequence and sorts them by channel and start - time.""" - - for item in items: - if isinstance(item, Pulse): - pulse = item - self.pulses.append(pulse) - elif isinstance(item, PulseSequence): - ps = item - for pulse in ps.pulses: - self.pulses.append(pulse) - self.pulses.sort(key=lambda item: (item.start, item.channel)) - - def index(self, pulse): - """Returns the index of a pulse in the sequence.""" - - return self.pulses.index(pulse) - - def pop(self, index=-1): - """Returns the pulse with the index provided and removes it from the - sequence.""" - - return self.pulses.pop(index) - - def remove(self, pulse): - """Removes a pulse from the sequence.""" - - while pulse in self.pulses: - self.pulses.remove(pulse) - - def clear(self): - """Removes all pulses from the sequence.""" - - self.pulses.clear() - - def shallow_copy(self): - """Returns a shallow copy of the sequence. - - It returns a new PulseSequence object with references to the - same Pulse objects. - """ - - return PulseSequence(*self.pulses) - - def copy(self): - """Returns a deep copy of the sequence. - - It returns a new PulseSequence with replicates of each of the - pulses contained in the original sequence. - """ - - return PulseSequence(*[pulse.copy() for pulse in self.pulses]) - - @property - def ro_pulses(self): - """Returns a new PulseSequence containing only its readout pulses.""" - - new_pc = PulseSequence() - for pulse in self.pulses: - if pulse.type == PulseType.READOUT: - new_pc.add(pulse) - return new_pc - - @property - def qd_pulses(self): - """Returns a new PulseSequence containing only its qubit drive - pulses.""" - - new_pc = PulseSequence() - for pulse in self.pulses: - if pulse.type == PulseType.DRIVE: - new_pc.add(pulse) - return new_pc - - @property - def qf_pulses(self): - """Returns a new PulseSequence containing only its qubit flux - pulses.""" - - new_pc = PulseSequence() - for pulse in self.pulses: - if pulse.type == PulseType.FLUX: - new_pc.add(pulse) - return new_pc - - @property - def cf_pulses(self): - """Returns a new PulseSequence containing only its coupler flux - pulses.""" - - new_pc = PulseSequence() - for pulse in self.pulses: - if pulse.type is PulseType.COUPLERFLUX: - new_pc.add(pulse) - return new_pc - - def get_channel_pulses(self, *channels): - """Returns a new PulseSequence containing only the pulses on a specific - set of channels.""" - - new_pc = PulseSequence() - for pulse in self.pulses: - if pulse.channel in channels: - new_pc.add(pulse) - return new_pc - - def get_qubit_pulses(self, *qubits): - """Returns a new PulseSequence containing only the pulses on a specific - set of qubits.""" - - new_pc = PulseSequence() - for pulse in self.pulses: - if not isinstance(pulse, CouplerFluxPulse): - if pulse.qubit in qubits: - new_pc.add(pulse) - return new_pc - - def coupler_pulses(self, *couplers): - """Returns a new PulseSequence containing only the pulses on a specific - set of couplers.""" - - new_pc = PulseSequence() - for pulse in self.pulses: - if isinstance(pulse, CouplerFluxPulse): - if pulse.qubit in couplers: - new_pc.add(pulse) - return new_pc - - @property - def is_empty(self): - """Returns True if the sequence does not contain any pulses.""" - - return len(self.pulses) == 0 - - @property - def finish(self) -> int: - """Returns the time when the last pulse of the sequence finishes.""" - - t: int = 0 - for pulse in self.pulses: - if pulse.finish > t: - t = pulse.finish - return t - - @property - def start(self) -> int: - """Returns the start time of the first pulse of the sequence.""" - - t = self.finish - for pulse in self.pulses: - if pulse.start < t: - t = pulse.start - return t - - @property - def duration(self) -> int: - """Returns duration of the sequence calculated as its finish - start times.""" - - return self.finish - self.start - - @property - def channels(self) -> list: - """Returns list containing the channels used by the pulses in the - sequence.""" - - channels = [] - for pulse in self.pulses: - if not pulse.channel in channels: - channels.append(pulse.channel) - channels.sort() - return channels - - @property - def qubits(self) -> list: - """Returns list containing the qubits associated with the pulses in the - sequence.""" - - qubits = [] - for pulse in self.pulses: - if not pulse.qubit in qubits: - qubits.append(pulse.qubit) - qubits.sort() - return qubits - - def get_pulse_overlaps(self): # -> dict((int,int): PulseSequence): - """Returns a dictionary of slices of time (tuples with start and finish - times) where pulses overlap.""" - - times = [] - for pulse in self.pulses: - if not pulse.start in times: - times.append(pulse.start) - if not pulse.finish in times: - times.append(pulse.finish) - times.sort() - - overlaps = {} - for n in range(len(times) - 1): - overlaps[(times[n], times[n + 1])] = PulseSequence() - for pulse in self.pulses: - if (pulse.start <= times[n]) & (pulse.finish >= times[n + 1]): - overlaps[(times[n], times[n + 1])] += pulse - return overlaps - - def separate_overlapping_pulses(self): # -> dict((int,int): PulseSequence): - """Separates a sequence of overlapping pulses into a list of non- - overlapping sequences.""" - - # This routine separates the pulses of a sequence into non-overlapping sets - # but it does not check if the frequencies of the pulses within a set have the same frequency - - separated_pulses = [] - for new_pulse in self.pulses: - stored = False - for ps in separated_pulses: - overlaps = False - for existing_pulse in ps: - if ( - new_pulse.start < existing_pulse.finish - and new_pulse.finish > existing_pulse.start - ): - overlaps = True - break - if not overlaps: - ps.add(new_pulse) - stored = True - break - if not stored: - separated_pulses.append(PulseSequence(new_pulse)) - return separated_pulses - - # TODO: Implement separate_different_frequency_pulses() - - @property - def pulses_overlap(self) -> bool: - """Returns True if any of the pulses in the sequence overlap.""" - - overlap = False - for pc in self.get_pulse_overlaps().values(): - if pc.count > 1: - overlap = True - return overlap - - def plot(self, savefig_filename=None, sampling_rate=SAMPLING_RATE): - """Plots the sequence of pulses. - - Args: - savefig_filename (str): a file path. If provided the plot is save to a file. - """ - - if not self.is_empty: - import matplotlib.pyplot as plt - from matplotlib import gridspec - - fig = plt.figure(figsize=(14, 2 * self.count), dpi=200) - gs = gridspec.GridSpec(ncols=1, nrows=self.count) - vertical_lines = [] - for pulse in self.pulses: - vertical_lines.append(pulse.start) - vertical_lines.append(pulse.finish) - - n = -1 - for qubit in self.qubits: - qubit_pulses = self.get_qubit_pulses(qubit) - for channel in qubit_pulses.channels: - n += 1 - channel_pulses = qubit_pulses.get_channel_pulses(channel) - ax = plt.subplot(gs[n]) - ax.axis([0, self.finish, -1, 1]) - for pulse in channel_pulses: - num_samples = len( - pulse.shape.modulated_waveform_i(sampling_rate) - ) - time = pulse.start + np.arange(num_samples) / sampling_rate - ax.plot( - time, - pulse.shape.modulated_waveform_q(sampling_rate).data, - c="lightgrey", - ) - ax.plot( - time, - pulse.shape.modulated_waveform_i(sampling_rate).data, - c=f"C{str(n)}", - ) - ax.plot( - time, - pulse.shape.envelope_waveform_i(sampling_rate).data, - c=f"C{str(n)}", - ) - ax.plot( - time, - -pulse.shape.envelope_waveform_i(sampling_rate).data, - c=f"C{str(n)}", - ) - # TODO: if they overlap use different shades - ax.axhline(0, c="dimgrey") - ax.set_ylabel(f"qubit {qubit} \n channel {channel}") - for vl in vertical_lines: - ax.axvline(vl, c="slategrey", linestyle="--") - ax.axis([0, self.finish, -1, 1]) - ax.grid( - visible=True, - which="both", - axis="both", - color="#CCCCCC", - linestyle="-", - ) - if savefig_filename: - plt.savefig(savefig_filename) - else: - plt.show() - plt.close() diff --git a/src/qibolab/qubits.py b/src/qibolab/qubits.py deleted file mode 100644 index 41142af981..0000000000 --- a/src/qibolab/qubits.py +++ /dev/null @@ -1,194 +0,0 @@ -from dataclasses import dataclass, field, fields -from typing import List, Optional, Tuple, Union - -import numpy as np - -from qibolab.channels import Channel -from qibolab.couplers import Coupler -from qibolab.native import SingleQubitNatives, TwoQubitNatives - -QubitId = Union[str, int] -"""Type for qubit names.""" - -CHANNEL_NAMES = ("readout", "feedback", "drive", "flux", "twpa") -"""Names of channels that belong to a qubit. - -Not all channels are required to operate a qubit. -""" -EXCLUDED_FIELDS = CHANNEL_NAMES + ( - "name", - "native_gates", - "kernel", - "_flux", - "qubit1", - "qubit2", - "coupler", -) -"""Qubit dataclass fields that are excluded by the ``characterization`` -property.""" - - -@dataclass -class Qubit: - """Representation of a physical qubit. - - Qubit objects are instantiated by :class:`qibolab.platforms.platform.Platform` - but they are passed to instrument designs in order to play pulses. - - Args: - name (int, str): Qubit number or name. - readout (:class:`qibolab.platforms.utils.Channel`): Channel used to - readout pulses to the qubit. - feedback (:class:`qibolab.platforms.utils.Channel`): Channel used to - get readout feedback from the qubit. - drive (:class:`qibolab.platforms.utils.Channel`): Channel used to - send drive pulses to the qubit. - flux (:class:`qibolab.platforms.utils.Channel`): Channel used to - send flux pulses to the qubit. - Other characterization parameters for the qubit, loaded from the runcard. - """ - - name: QubitId - - bare_resonator_frequency: int = 0 - readout_frequency: int = 0 - """Readout dressed frequency.""" - drive_frequency: int = 0 - anharmonicity: int = 0 - sweetspot: float = 0.0 - asymmetry: float = 0.0 - crosstalk_matrix: dict[QubitId, float] = field(default_factory=dict) - """Crosstalk matrix for voltages.""" - Ec: float = 0.0 - """Readout Charge Energy.""" - Ej: float = 0.0 - """Readout Josephson Energy.""" - g: float = 0.0 - """Readout coupling.""" - assignment_fidelity: float = 0.0 - """Assignment fidelity.""" - readout_fidelity: float = 0.0 - """Readout fidelity.""" - gate_fidelity: float = 0.0 - """Gate fidelity from standard RB.""" - - effective_temperature: float = 0.0 - """Effective temperature.""" - peak_voltage: float = 0 - pi_pulse_amplitude: float = 0 - resonator_depletion_time: int = 0 - T1: int = 0 - T2: int = 0 - T2_spin_echo: int = 0 - state0_voltage: int = 0 - state1_voltage: int = 0 - mean_gnd_states: List[float] = field(default_factory=lambda: [0, 0]) - mean_exc_states: List[float] = field(default_factory=lambda: [0, 0]) - - # parameters for single shot classification - threshold: float = 0.0 - iq_angle: float = 0.0 - kernel: Optional[np.ndarray] = field(default=None, repr=False) - # required for mixers (not sure if it should be here) - mixer_drive_g: float = 0.0 - mixer_drive_phi: float = 0.0 - mixer_readout_g: float = 0.0 - mixer_readout_phi: float = 0.0 - - readout: Optional[Channel] = None - feedback: Optional[Channel] = None - twpa: Optional[Channel] = None - drive: Optional[Channel] = None - _flux: Optional[Channel] = None - - native_gates: SingleQubitNatives = field(default_factory=SingleQubitNatives) - - def __post_init__(self): - if self.flux is not None and self.sweetspot != 0: - self.flux.offset = self.sweetspot - - @property - def flux(self): - return self._flux - - @flux.setter - def flux(self, channel): - if self.sweetspot != 0: - channel.offset = self.sweetspot - self._flux = channel - - @property - def channels(self): - for name in CHANNEL_NAMES: - channel = getattr(self, name) - if channel is not None: - yield channel - - @property - def characterization(self): - """Dictionary containing characterization parameters.""" - return { - fld.name: getattr(self, fld.name) - for fld in fields(self) - if fld.name not in EXCLUDED_FIELDS - } - - @property - def mixer_frequencies(self): - """Get local oscillator and intermediate frequencies of native gates. - - Assumes RF = LO + IF. - """ - freqs = {} - for gate in fields(self.native_gates): - native = getattr(self.native_gates, gate.name) - if native is not None: - channel_type = native.pulse_type.name.lower() - _lo = getattr(self, channel_type).lo_frequency - _if = native.frequency - _lo - freqs[gate.name] = _lo, _if - return freqs - - -QubitPairId = Tuple[QubitId, QubitId] -"""Type for holding ``QubitPair``s in the ``platform.pairs`` dictionary.""" - - -@dataclass -class QubitPair: - """Data structure for holding the native two-qubit gates acting on a pair - of qubits. - - This is needed for symmetry to the single-qubit gates which are storred in the - :class:`qibolab.platforms.abstract.Qubit`. - """ - - qubit1: Qubit - """First qubit of the pair. - - Acts as control on two-qubit gates. - """ - qubit2: Qubit - """Second qubit of the pair. - - Acts as target on two-qubit gates. - """ - - gate_fidelity: float = 0.0 - """Gate fidelity from standard 2q RB.""" - - cz_fidelity: float = 0.0 - """Gate fidelity from CZ interleaved RB.""" - - coupler: Optional[Coupler] = None - - native_gates: TwoQubitNatives = field(default_factory=TwoQubitNatives) - - @property - def characterization(self): - """Dictionary containing characterization parameters.""" - return { - fld.name: getattr(self, fld.name) - for fld in fields(self) - if fld.name not in EXCLUDED_FIELDS - } diff --git a/src/qibolab/result.py b/src/qibolab/result.py deleted file mode 100644 index 837d7fba10..0000000000 --- a/src/qibolab/result.py +++ /dev/null @@ -1,189 +0,0 @@ -from functools import cached_property, lru_cache -from typing import Optional - -import numpy as np -import numpy.typing as npt - - -class IntegratedResults: - """Data structure to deal with the output of :func:`qibolab.platforms.abstr - act.AbstractPlatform.execute_pulse_sequence` - :func:`qibolab.platforms.abstract.AbstractPlatform.sweep` - - Associated with AcquisitionType.INTEGRATION and - AveragingMode.SINGLESHOT - """ - - def __init__(self, data: np.ndarray): - self.voltage: npt.NDArray[np.complex128] = data - - def __add__(self, data): - return self.__class__(np.append(self.voltage, data.voltage)) - - @property - def voltage_i(self): - """Signal component i in volts.""" - return self.voltage.real - - @property - def voltage_q(self): - """Signal component q in volts.""" - return self.voltage.imag - - @cached_property - def magnitude(self): - """Signal magnitude in volts.""" - return np.sqrt(self.voltage_i**2 + self.voltage_q**2) - - @cached_property - def phase(self): - """Signal phase in radians.""" - return np.unwrap(np.arctan2(self.voltage_i, self.voltage_q)) - - @cached_property - def phase_std(self): - """Signal phase in radians.""" - return np.std(self.phase, axis=0, ddof=1) / np.sqrt(self.phase.shape[0]) - - @property - def serialize(self): - """Serialize as a dictionary.""" - serialized_dict = { - "MSR[V]": self.magnitude.flatten(), - "i[V]": self.voltage_i.flatten(), - "q[V]": self.voltage_q.flatten(), - "phase[rad]": self.phase.flatten(), - } - return serialized_dict - - @property - def average(self): - """Perform average over i and q.""" - average_data = np.mean(self.voltage, axis=0) - std_data = np.std(self.voltage, axis=0, ddof=1) / np.sqrt(self.voltage.shape[0]) - return AveragedIntegratedResults(average_data, std_data) - - -class AveragedIntegratedResults(IntegratedResults): - """Data structure to deal with the output of :func:`qibolab.platforms.abstr - act.AbstractPlatform.execute_pulse_sequence` - :func:`qibolab.platforms.abstract.AbstractPlatform.sweep` - - Associated with AcquisitionType.INTEGRATION and AveragingMode.CYCLIC - or the averages of ``IntegratedResults`` - """ - - def __init__(self, data: np.ndarray, std: Optional[np.ndarray] = None): - super().__init__(data) - self.std: Optional[npt.NDArray[np.float64]] = std - - def __add__(self, data): - new_res = super().__add__(data) - new_res.std = np.append(self.std, data.std) - return new_res - - @property - def average(self): - """Average on AveragedIntegratedResults is itself.""" - return self - - @cached_property - def phase_std(self): - """Standard deviation is None for AveragedIntegratedResults.""" - return None - - @cached_property - def phase(self): - """Phase not unwrapped because it is a single value.""" - return np.arctan2(self.voltage_i, self.voltage_q) - - -class RawWaveformResults(IntegratedResults): - """Data structure to deal with the output of :func:`qibolab.platforms.abstr - act.AbstractPlatform.execute_pulse_sequence` - :func:`qibolab.platforms.abstract.AbstractPlatform.sweep` - - Associated with AcquisitionType.RAW and AveragingMode.SINGLESHOT may - also be used to store the integration weights ? - """ - - -class AveragedRawWaveformResults(AveragedIntegratedResults): - """Data structure to deal with the output of :func:`qibolab.platforms.abstr - act.AbstractPlatform.execute_pulse_sequence` - :func:`qibolab.platforms.abstract.AbstractPlatform.sweep` - - Associated with AcquisitionType.RAW and AveragingMode.CYCLIC - or the averages of ``RawWaveformResults`` - """ - - -class SampleResults: - """Data structure to deal with the output of :func:`qibolab.platforms.abstr - act.AbstractPlatform.execute_pulse_sequence` - :func:`qibolab.platforms.abstract.AbstractPlatform.sweep` - - Associated with AcquisitionType.DISCRIMINATION and - AveragingMode.SINGLESHOT - """ - - def __init__(self, data: np.ndarray): - self.samples: npt.NDArray[np.uint32] = np.array(data).astype(np.uint32) - - def __add__(self, data): - return self.__class__(np.append(self.samples, data.samples)) - - @lru_cache - def probability(self, state=0): - """Returns the statistical frequency of the specified state (0 or - 1).""" - return abs(1 - state - np.mean(self.samples, axis=0)) - - @property - def serialize(self): - """Serialize as a dictionary.""" - serialized_dict = { - "0": self.probability(0).flatten(), - } - return serialized_dict - - @property - def average(self): - """Perform samples average.""" - average = self.probability(1) - std = np.std(self.samples, axis=0, ddof=1) / np.sqrt(self.samples.shape[0]) - return AveragedSampleResults(average, self.samples, std=std) - - -class AveragedSampleResults(SampleResults): - """Data structure to deal with the output of :func:`qibolab.platforms.abstr - act.AbstractPlatform.execute_pulse_sequence` - :func:`qibolab.platforms.abstract.AbstractPlatform.sweep` - - Associated with AcquisitionType.DISCRIMINATION and AveragingMode.CYCLIC - or the averages of ``SampleResults`` - """ - - def __init__( - self, - statistical_frequency: np.ndarray, - samples: np.ndarray = np.array([]), - std: np.ndarray = np.array([]), - ): - super().__init__(samples) - self.statistical_frequency: npt.NDArray[np.float64] = statistical_frequency - self.std: Optional[npt.NDArray[np.float64]] = std - - def __add__(self, data): - new_res = super().__add__(data) - new_res.statistical_frequency = np.append( - self.statistical_frequency, data.statistical_frequency - ) - new_res.std = np.append(self.std, data.std) - return new_res - - @lru_cache - def probability(self, state=0): - """Returns the statistical frequency of the specified state (0 or - 1).""" - return abs(1 - state - self.statistical_frequency) diff --git a/src/qibolab/serialize.py b/src/qibolab/serialize.py deleted file mode 100644 index cf89896ad3..0000000000 --- a/src/qibolab/serialize.py +++ /dev/null @@ -1,292 +0,0 @@ -"""Helper methods for loading and saving to runcards. - -The format of runcards in the ``qiboteam/qibolab_platforms_qrc`` -repository is assumed here. See :ref:`Using runcards ` -example for more details. -""" - -import json -from dataclasses import asdict -from pathlib import Path -from typing import Tuple - -from qibolab.couplers import Coupler -from qibolab.kernels import Kernels -from qibolab.native import CouplerNatives, SingleQubitNatives, TwoQubitNatives -from qibolab.platform.platform import ( - CouplerMap, - InstrumentMap, - Platform, - QubitMap, - QubitPairMap, - Settings, -) -from qibolab.qubits import Qubit, QubitId, QubitPair - -RUNCARD = "parameters.json" -PLATFORM = "platform.py" - - -def load_runcard(path: Path) -> dict: - """Load runcard JSON to a dictionary.""" - return json.loads((path / RUNCARD).read_text()) - - -def load_settings(runcard: dict) -> Settings: - """Load platform settings section from the runcard.""" - return Settings(**runcard["settings"]) - - -def load_qubit_name(name: str) -> QubitId: - """Convert qubit name from string to integer or string.""" - try: - return int(name) - except ValueError: - return name - - -def load_qubits( - runcard: dict, kernels: Kernels = None -) -> Tuple[QubitMap, CouplerMap, QubitPairMap]: - """Load qubits and pairs from the runcard. - - Uses the native gate and characterization sections of the runcard to - parse the - :class: `qibolab.qubits.Qubit` and - :class: `qibolab.qubits.QubitPair` - objects. - """ - qubits = {} - for q, char in runcard["characterization"]["single_qubit"].items(): - raw_qubit = Qubit(load_qubit_name(q), **char) - raw_qubit.crosstalk_matrix = { - load_qubit_name(key): value - for key, value in raw_qubit.crosstalk_matrix.items() - } - qubits[load_qubit_name(q)] = raw_qubit - - if kernels is not None: - for q in kernels: - qubits[q].kernel = kernels[q] - - couplers = {} - pairs = {} - two_qubit_characterization = runcard["characterization"].get("two_qubit", {}) - if "coupler" in runcard["characterization"]: - couplers = { - load_qubit_name(c): Coupler(load_qubit_name(c), **char) - for c, char in runcard["characterization"]["coupler"].items() - } - for c, pair in runcard["topology"].items(): - q0, q1 = pair - char = two_qubit_characterization.get(str(q0) + "-" + str(q1), {}) - pairs[(q0, q1)] = pairs[(q1, q0)] = QubitPair( - qubits[q0], qubits[q1], **char, coupler=couplers[load_qubit_name(c)] - ) - else: - for pair in runcard["topology"]: - q0, q1 = pair - char = two_qubit_characterization.get(str(q0) + "-" + str(q1), {}) - pairs[(q0, q1)] = pairs[(q1, q0)] = QubitPair( - qubits[q0], qubits[q1], **char, coupler=None - ) - - qubits, pairs, couplers = register_gates(runcard, qubits, pairs, couplers) - - return qubits, couplers, pairs - - -# This creates the compiler error -def register_gates( - runcard: dict, qubits: QubitMap, pairs: QubitPairMap, couplers: CouplerMap = None -) -> Tuple[QubitMap, QubitPairMap]: - """Register single qubit native gates to ``Qubit`` objects from the - runcard. - - Uses the native gate and characterization sections of the runcard - to parse the :class:`qibolab.qubits.Qubit` and :class:`qibolab.qubits.QubitPair` - objects. - """ - - native_gates = runcard.get("native_gates", {}) - for q, gates in native_gates.get("single_qubit", {}).items(): - qubits[load_qubit_name(q)].native_gates = SingleQubitNatives.from_dict( - qubits[load_qubit_name(q)], gates - ) - - for c, gates in native_gates.get("coupler", {}).items(): - couplers[load_qubit_name(c)].native_pulse = CouplerNatives.from_dict( - couplers[load_qubit_name(c)], gates - ) - - # register two-qubit native gates to ``QubitPair`` objects - for pair, gatedict in native_gates.get("two_qubit", {}).items(): - q0, q1 = tuple(int(q) if q.isdigit() else q for q in pair.split("-")) - native_gates = TwoQubitNatives.from_dict(qubits, couplers, gatedict) - pairs[(q0, q1)].native_gates = native_gates - if native_gates.symmetric: - pairs[(q1, q0)] = pairs[(q0, q1)] - - return qubits, pairs, couplers - - -def load_instrument_settings( - runcard: dict, instruments: InstrumentMap -) -> InstrumentMap: - """Setup instruments according to the settings given in the runcard.""" - for name, settings in runcard.get("instruments", {}).items(): - instruments[name].setup(**settings) - return instruments - - -def dump_qubit_name(name: QubitId) -> str: - """Convert qubit name from integer or string to string.""" - if isinstance(name, int): - return str(name) - return name - - -def dump_native_gates( - qubits: QubitMap, pairs: QubitPairMap, couplers: CouplerMap = None -) -> dict: - """Dump native gates section to dictionary following the runcard format, - using qubit and pair objects.""" - # single-qubit native gates - native_gates = { - "single_qubit": { - dump_qubit_name(q): qubit.native_gates.raw for q, qubit in qubits.items() - } - } - if couplers: - native_gates["coupler"] = { - dump_qubit_name(c): coupler.native_pulse.raw - for c, coupler in couplers.items() - } - - # two-qubit native gates - if len(pairs) > 0: - native_gates["two_qubit"] = {} - for pair in pairs.values(): - natives = pair.native_gates.raw - if len(natives) > 0: - pair_name = f"{pair.qubit1.name}-{pair.qubit2.name}" - native_gates["two_qubit"][pair_name] = natives - - return native_gates - - -def dump_characterization( - qubits: QubitMap, pairs: QubitPairMap = None, couplers: CouplerMap = None -) -> dict: - """Dump qubit characterization section to dictionary following the runcard - format, using qubit and pair objects.""" - single_qubit = {} - for q, qubit in qubits.items(): - char = qubit.characterization - char["crosstalk_matrix"] = { - dump_qubit_name(q): c for q, c in qubit.crosstalk_matrix.items() - } - single_qubit[dump_qubit_name(q)] = char - - characterization = {"single_qubit": single_qubit} - if len(pairs) > 0: - characterization["two_qubit"] = { - f"{q1}-{q2}": pair.characterization for (q1, q2), pair in pairs.items() - } - - if couplers: - characterization["coupler"] = { - dump_qubit_name(c.name): {"sweetspot": c.sweetspot} - for c in couplers.values() - } - return characterization - - -def dump_instruments(instruments: InstrumentMap) -> dict: - """Dump instrument settings to a dictionary following the runcard - format.""" - # Qblox modules settings are dictionaries and not dataclasses - data = {} - for name, instrument in instruments.items(): - try: - # TODO: Migrate all instruments to this approach - # (I think it is also useful for qblox) - settings = instrument.dump() - if len(settings) > 0: - data[name] = settings - except AttributeError: - settings = instrument.settings - if settings is not None: - if isinstance(settings, dict): - data[name] = settings - else: - data[name] = settings.dump() - - return data - - -def dump_runcard(platform: Platform, path: Path): - """Serializes the platform and saves it as a json runcard file. - - The file saved follows the format explained in :ref:`Using runcards `. - - Args: - platform (qibolab.platform.Platform): The platform to be serialized. - path (pathlib.Path): Path that the json file will be saved. - """ - - settings = { - "nqubits": platform.nqubits, - "settings": asdict(platform.settings), - "qubits": list(platform.qubits), - "topology": [list(pair) for pair in platform.ordered_pairs], - "instruments": dump_instruments(platform.instruments), - } - - if platform.couplers: - settings["couplers"] = list(platform.couplers) - settings["topology"] = { - platform.pairs[pair].coupler.name: list(pair) - for pair in platform.ordered_pairs - } - - settings["native_gates"] = dump_native_gates( - platform.qubits, platform.pairs, platform.couplers - ) - - settings["characterization"] = dump_characterization( - platform.qubits, platform.pairs, platform.couplers - ) - - (path / RUNCARD).write_text(json.dumps(settings, sort_keys=False, indent=4)) - - -def dump_kernels(platform: Platform, path: Path): - """Creates Kernels instance from platform and dumps as npz. - - Args: - platform (qibolab.platform.Platform): The platform to be serialized. - path (pathlib.Path): Path that the kernels file will be saved. - """ - - # create kernels - kernels = Kernels() - for qubit in platform.qubits.values(): - if qubit.kernel is not None: - kernels[qubit.name] = qubit.kernel - - # dump only if not None - if kernels: - kernels.dump(path) - - -def dump_platform(platform: Platform, path: Path): - """Platform serialization as runcard (json) and kernels (npz). - - Args: - platform (qibolab.platform.Platform): The platform to be serialized. - path (pathlib.Path): Path where json and npz will be dumped. - """ - - dump_kernels(platform=platform, path=path) - dump_runcard(platform=platform, path=path) diff --git a/src/qibolab/sweeper.py b/src/qibolab/sweeper.py deleted file mode 100644 index c8539faca1..0000000000 --- a/src/qibolab/sweeper.py +++ /dev/null @@ -1,115 +0,0 @@ -import operator -from dataclasses import dataclass -from enum import Enum, auto -from functools import partial -from typing import Optional - -import numpy.typing as npt - - -class Parameter(Enum): - """Sweeping parameters.""" - - frequency = auto() - amplitude = auto() - duration = auto() - relative_phase = auto() - start = auto() - - attenuation = auto() - gain = auto() - bias = auto() - lo_frequency = auto() - - -FREQUENCY = Parameter.frequency -AMPLITUDE = Parameter.amplitude -DURATION = Parameter.duration -RELATIVE_PHASE = Parameter.relative_phase -START = Parameter.start -ATTENUATION = Parameter.attenuation -GAIN = Parameter.gain -BIAS = Parameter.bias - - -class SweeperType(Enum): - """Type of the Sweeper.""" - - ABSOLUTE = partial(lambda x, y=None: x) - FACTOR = operator.mul - OFFSET = operator.add - - -QubitParameter = {Parameter.bias, Parameter.attenuation, Parameter.gain} - - -@dataclass -class Sweeper: - """Data structure for Sweeper object. - - This object is passed as an argument to the method :func:`qibolab.platforms.abstract.Platform.sweep` - which enables the user to sweep a specific parameter for one or more pulses. For information on how to - perform sweeps see :func:`qibolab.platforms.abstract.Platform.sweep`. - - Example: - .. testcode:: - - import numpy as np - from qibolab.dummy import create_dummy - from qibolab.sweeper import Sweeper, Parameter - from qibolab.pulses import PulseSequence - from qibolab import ExecutionParameters - - - platform = create_dummy() - sequence = PulseSequence() - parameter = Parameter.frequency - pulse = platform.create_qubit_readout_pulse(qubit=0, start=0) - sequence.add(pulse) - parameter_range = np.random.randint(10, size=10) - sweeper = Sweeper(parameter, parameter_range, [pulse]) - platform.sweep(sequence, ExecutionParameters(), sweeper) - - Args: - parameter (`qibolab.sweeper.Parameter`): parameter to be swept, possible choices are frequency, attenuation, amplitude, current and gain. - _values (np.ndarray): sweep range. If the parameter of the sweep is a pulse parameter, if the sweeper type is not ABSOLUTE, the base value - will be taken from the runcard pulse parameters. If the sweep parameter is Bias, the base value will be the sweetspot of the qubits. - pulses (list) : list of `qibolab.pulses.Pulse` to be swept (optional). - qubits (list): list of `qibolab.platforms.abstract.Qubit` to be swept (optional). - type (SweeperType): can be ABSOLUTE (the sweeper range is swept directly), - FACTOR (sweeper values are multiplied by base value), OFFSET (sweeper values are added - to base value) - """ - - parameter: Parameter - values: npt.NDArray - pulses: Optional[list] = None - qubits: Optional[list] = None - couplers: Optional[list] = None - type: Optional[SweeperType] = SweeperType.ABSOLUTE - - def __post_init__(self): - if ( - self.pulses is not None - and self.qubits is not None - and self.couplers is not None - ): - raise ValueError("Cannot use a sweeper on both pulses and qubits.") - if self.pulses is not None and self.parameter in QubitParameter: - raise ValueError( - f"Cannot sweep {self.parameter} without specifying qubits or couplers." - ) - if self.parameter not in QubitParameter and ( - self.qubits is not None or self.couplers is not None - ): - raise ValueError( - f"Cannot sweep {self.parameter} without specifying pulses." - ) - if self.pulses is None and self.qubits is None and self.couplers is None: - raise ValueError( - "Cannot use a sweeper without specifying pulses, qubits or couplers." - ) - - def get_values(self, base_value): - """Convert sweeper values depending on the sweeper type.""" - return self.type.value(self.values, base_value) diff --git a/src/qibolab/unrolling.py b/src/qibolab/unrolling.py deleted file mode 100644 index df9b250845..0000000000 --- a/src/qibolab/unrolling.py +++ /dev/null @@ -1,79 +0,0 @@ -"""Utilities for sequence unrolling. - -May be reused by different instruments. -""" - -from dataclasses import asdict, dataclass, field, fields -from functools import total_ordering - -from .pulses import PulseSequence - - -def _waveform(sequence: PulseSequence): - # TODO: deduplicate pulses (Not yet as drivers may not support it yet) - # TODO: count Rectangular and delays separately (Zurich Instruments supports this) - # TODO: Any constant part of a pulse should be counted only once (Zurich Instruments supports this) - # TODO: check if readout duration is faithful for the readout pulse (I would only check the control pulses) - # TODO: Handle multiple qubits or do all devices have the same memory for each channel ? - return sequence.duration - sequence.ro_pulses.duration - - -def _readout(sequence: PulseSequence): - # TODO: Do we count 1 readout per pulse or 1 readout per multiplexed readout ? - return len(sequence.ro_pulses) - - -def _instructions(sequence: PulseSequence): - return len(sequence) - - -@total_ordering -@dataclass(frozen=True, eq=True) -class Bounds: - """Instument memory limitations proxies.""" - - waveforms: int = field(metadata={"count": _waveform}) - """Waveforms estimated size.""" - readout: int = field(metadata={"count": _readout}) - """Number of readouts.""" - instructions: int = field(metadata={"count": _instructions}) - """Instructions estimated size.""" - - @classmethod - def update(cls, sequence: PulseSequence): - up = {} - for f in fields(cls): - up[f.name] = f.metadata["count"](sequence) - - return cls(**up) - - def __add__(self, other: "Bounds") -> "Bounds": - """Sum bounds element by element.""" - new = {} - for (k, x), (_, y) in zip(asdict(self).items(), asdict(other).items()): - new[k] = x + y - - return type(self)(**new) - - def __gt__(self, other: "Bounds") -> bool: - """Define ordering as exceeding any bound.""" - return any(getattr(self, f.name) > getattr(other, f.name) for f in fields(self)) - - -def batch(sequences: list[PulseSequence], bounds: Bounds): - """Split a list of sequences to batches. - - Takes into account the various limitations throught the mechanics defined in - :cls:`Bounds`, and the numerical limitations specified by the `bounds` argument. - """ - counters = Bounds(0, 0, 0) - batch = [] - for sequence in sequences: - update = Bounds.update(sequence) - if counters + update > bounds: - yield batch - counters, batch = update, [sequence] - else: - batch.append(sequence) - counters += update - yield batch diff --git a/tests/test_instruments_qblox_debug.py b/tests/channel/__init__.py similarity index 100% rename from tests/test_instruments_qblox_debug.py rename to tests/channel/__init__.py diff --git a/tests/conftest.py b/tests/conftest.py index 2e4add6eb1..6996d50fa5 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,20 +1,18 @@ import os import pathlib +from collections.abc import Callable +from typing import Optional +import numpy.typing as npt import pytest -from qibolab.platform import create_platform -from qibolab.platform.load import PLATFORMS +from qibolab import AcquisitionType, AveragingMode, Platform, create_platform +from qibolab._core.platform.load import PLATFORMS +from qibolab._core.sequence import PulseSequence +from qibolab._core.sweeper import ParallelSweepers, Parameter, Sweeper ORIGINAL_PLATFORMS = os.environ.get(PLATFORMS, "") -TESTING_PLATFORM_NAMES = [ - "dummy_couplers", - "qm", - "qm_octave", - "qblox", - "rfsoc", - "zurich", -] +TESTING_PLATFORM_NAMES = ["dummy"] """Platforms used for testing without access to real instruments.""" @@ -64,26 +62,6 @@ def emulators(): os.environ[PLATFORMS] = str(pathlib.Path(__file__).parent / "emulators") -def find_instrument(platform, instrument_type): - for instrument in platform.instruments.values(): - if isinstance(instrument, instrument_type): - return instrument - return None - - -def get_instrument(platform, instrument_type): - """Finds if an instrument of a given type exists in the given platform. - - If the platform does not have such an instrument, the corresponding - test that asked for this instrument is skipped. This ensures that - QPU tests are executed only on the available instruments. - """ - instrument = find_instrument(platform, instrument_type) - if instrument is None: - pytest.skip(f"Skipping {instrument_type.__name__} test for {platform.name}.") - return instrument - - @pytest.fixture(scope="module", params=TESTING_PLATFORM_NAMES) def platform(request): """Dummy platform to be used when there is no access to QPU. @@ -108,8 +86,66 @@ def connected_platform(request): the ``QIBOLAB_PLATFORMS`` environment variable. """ os.environ[PLATFORMS] = ORIGINAL_PLATFORMS - name = request.config.getoption("--platform") + name = request.config.getoption("--device", default="dummy") platform = create_platform(name) platform.connect() yield platform platform.disconnect() + + +Execution = Callable[ + [AcquisitionType, AveragingMode, int, Optional[list[ParallelSweepers]]], npt.NDArray +] + + +@pytest.fixture +def execute(connected_platform: Platform) -> Execution: + def wrapped( + acquisition_type: AcquisitionType, + averaging_mode: AveragingMode, + nshots: int = 1000, + sweepers: Optional[list[ParallelSweepers]] = None, + sequence: Optional[PulseSequence] = None, + target: Optional[int] = None, + ) -> npt.NDArray: + options = dict( + nshots=nshots, + acquisition_type=acquisition_type, + averaging_mode=averaging_mode, + ) + + qubit = next(iter(connected_platform.qubits.values())) + natives = connected_platform.natives.single_qubit[0] + + if sequence is None: + qd_seq = natives.RX() + probe_seq = natives.MZ() + probe_pulse = probe_seq[0][1].probe + acq = probe_seq[0][1].acquisition + wrapped.acquisition_duration = acq.duration + sequence = PulseSequence() + sequence.concatenate(qd_seq) + sequence.concatenate(probe_seq) + if sweepers is None: + sweeper1 = Sweeper( + parameter=Parameter.offset, + range=(0.01, 0.06, 0.01), + channels=[qubit.flux], + ) + sweeper2 = Sweeper( + parameter=Parameter.amplitude, + range=(0, 0.8, 0.1), + pulses=[probe_pulse], + ) + sweepers = [[sweeper1], [sweeper2]] + if target is None: + target = acq.id + + # default target and sweepers only supported for default sequence + assert target is not None + assert sweepers is not None + + results = connected_platform.execute([sequence], sweepers, **options) + return results[target] + + return wrapped diff --git a/tests/dummy_qrc/qblox/parameters.json b/tests/dummy_qrc/qblox/parameters.json deleted file mode 100644 index 7a5099b5fe..0000000000 --- a/tests/dummy_qrc/qblox/parameters.json +++ /dev/null @@ -1,423 +0,0 @@ -{ - "nqubits": 5, - "settings": { - "nshots": 1024, - "relaxation_time": 20000 - }, - "qubits": [ - 0, - 1, - 2, - 3, - 4 - ], - "topology": [ - [ - 0, - 2 - ], - [ - 1, - 2 - ], - [ - 2, - 3 - ], - [ - 2, - 4 - ] - ], - "instruments": { - "qblox_controller": { - "bounds": { - "instructions": 1000000, - "readout": 250, - "waveforms": 40000 - } - }, - "twpa_pump": { - "frequency": 6535900000, - "power": 4 - }, - "qcm_rf0": { - "o1": { - "attenuation": 20, - "lo_frequency": 5252833073, - "gain": 0.47 - }, - "o2": { - "attenuation": 20, - "lo_frequency": 5652833073, - "gain": 0.57 - } - }, - "qcm_rf1": { - "o1": { - "attenuation": 20, - "lo_frequency": 5995371914, - "gain": 0.55 - }, - "o2": { - "attenuation": 20, - "lo_frequency": 6961018001, - "gain": 0.596 - } - }, - "qcm_rf2": { - "o1": { - "attenuation": 20, - "lo_frequency": 6786543060, - "gain": 0.47 - } - }, - "qrm_rf_a": { - "o1": { - "attenuation": 36, - "lo_frequency": 7300000000, - "gain": 0.6 - }, - "i1": { - "acquisition_hold_off": 500, - "acquisition_duration": 900 - } - }, - "qrm_rf_b": { - "o1": { - "attenuation": 36, - "lo_frequency": 7850000000, - "gain": 0.6 - }, - "i1": { - "acquisition_hold_off": 500, - "acquisition_duration": 900 - } - } - }, - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 40, - "amplitude": 0.5028, - "frequency": 5050304836, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.5028, - "frequency": 5050304836, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 2000, - "amplitude": 0.1, - "frequency": 7213299307, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "1": { - "RX": { - "duration": 40, - "amplitude": 0.5078, - "frequency": 4852833073, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.5078, - "frequency": 4852833073, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 2000, - "amplitude": 0.2, - "frequency": 7452990931, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "2": { - "RX": { - "duration": 40, - "amplitude": 0.5016, - "frequency": 5795371914, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.5016, - "frequency": 5795371914, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 2000, - "amplitude": 0.25, - "frequency": 7655083068, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "3": { - "RX": { - "duration": 40, - "amplitude": 0.5026, - "frequency": 6761018001, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.5026, - "frequency": 6761018001, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 2000, - "amplitude": 0.2, - "frequency": 7803441221, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "4": { - "RX": { - "duration": 40, - "amplitude": 0.5172, - "frequency": 6586543060, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.5172, - "frequency": 6586543060, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 2000, - "amplitude": 0.4, - "frequency": 8058947261, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - } - }, - "two_qubit": { - "2-3": { - "CZ": [ - { - "duration": 32, - "amplitude": -0.6025, - "shape": "Exponential(12, 5000, 0.1)", - "qubit": 3, - "relative_start": 0, - "type": "qf" - }, - { - "duration": 20, - "amplitude": 0, - "shape": "Rectangular())", - "qubit": 3, - "relative_start": 32, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -3.63, - "qubit": 3 - }, - { - "duration": 32, - "amplitude": 0, - "shape": "Rectangular())", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "duration": 20, - "amplitude": 0, - "shape": "Rectangular())", - "qubit": 2, - "relative_start": 32, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -0.041, - "qubit": 2 - } - ] - }, - "0-2": { - "CZ": [ - { - "duration": 28, - "amplitude": -0.142, - "shape": "Exponential(12, 5000, 0.1)", - "qubit": 2, - "relative_start": 0, - "type": "qf" - } - ] - }, - "1-2": { - "CZ": [ - { - "duration": 32, - "amplitude": -0.6025, - "shape": "Exponential(12, 5000, 0.1)", - "qubit": 3, - "relative_start": 0, - "type": "qf" - }, - { - "duration": 20, - "amplitude": 0, - "shape": "Rectangular())", - "qubit": 3, - "relative_start": 32, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -3.63, - "qubit": 3 - }, - { - "duration": 32, - "amplitude": 0, - "shape": "Rectangular())", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "duration": 20, - "amplitude": 0, - "shape": "Rectangular())", - "qubit": 2, - "relative_start": 32, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -0.041, - "qubit": 2 - } - ] - } - } - }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 7213299307, - "drive_frequency": 5050304836, - "anharmonicity": 291463266, - "T1": 5857, - "T2": 0, - "sweetspot": 0.5507 - }, - "1": { - "readout_frequency": 7452990931, - "drive_frequency": 4852833073, - "anharmonicity": 292584018, - "T1": 1253, - "T2": 0, - "sweetspot": 0.2227, - "iq_angle": 146.297, - "threshold": 0.003488 - }, - "2": { - "readout_frequency": 7655083068, - "drive_frequency": 5795371914, - "anharmonicity": 276187576, - "T1": 4563, - "T2": 0, - "sweetspot": -0.378, - "iq_angle": 97.821, - "threshold": 0.002904 - }, - "3": { - "readout_frequency": 7803441221, - "drive_frequency": 6761018001, - "anharmonicity": 262310994, - "T1": 4232, - "T2": 0, - "sweetspot": -0.8899, - "iq_angle": 91.209, - "threshold": 0.004318 - }, - "4": { - "readout_frequency": 8058947261, - "drive_frequency": 6586543060, - "anharmonicity": 261390626, - "T1": 492, - "T2": 0, - "sweetspot": 0.589, - "iq_angle": 7.997, - "threshold": 0.002323 - } - }, - "two_qubit":{ - "0-2": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "1-2": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "2-3": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "2-4": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - } - } - } -} diff --git a/tests/dummy_qrc/qblox/platform.py b/tests/dummy_qrc/qblox/platform.py deleted file mode 100644 index a60a600d8f..0000000000 --- a/tests/dummy_qrc/qblox/platform.py +++ /dev/null @@ -1,105 +0,0 @@ -import pathlib - -from qibolab.channels import Channel, ChannelMap -from qibolab.instruments.qblox.cluster_qcm_bb import QcmBb -from qibolab.instruments.qblox.cluster_qcm_rf import QcmRf -from qibolab.instruments.qblox.cluster_qrm_rf import QrmRf -from qibolab.instruments.qblox.controller import QbloxController -from qibolab.instruments.rohde_schwarz import SGS100A -from qibolab.platform import Platform -from qibolab.serialize import ( - load_instrument_settings, - load_qubits, - load_runcard, - load_settings, -) - -ADDRESS = "192.168.0.6" -TIME_OF_FLIGHT = 500 -FOLDER = pathlib.Path(__file__).parent - - -def create(): - """QuantWare 5q-chip controlled using qblox cluster. - - Args: - runcard_path (str): Path to the runcard file. - """ - - runcard = load_runcard(FOLDER) - modules = { - "qcm_bb0": QcmBb("qcm_bb0", f"{ADDRESS}:2"), - "qcm_bb1": QcmBb("qcm_bb1", f"{ADDRESS}:4"), - "qcm_rf0": QcmRf("qcm_rf0", f"{ADDRESS}:6"), - "qcm_rf1": QcmRf("qcm_rf1", f"{ADDRESS}:8"), - "qcm_rf2": QcmRf("qcm_rf2", f"{ADDRESS}:10"), - "qrm_rf_a": QrmRf("qrm_rf_a", f"{ADDRESS}:16"), - "qrm_rf_b": QrmRf("qrm_rf_b", f"{ADDRESS}:18"), - } - - controller = QbloxController("qblox_controller", ADDRESS, modules) - twpa_pump = SGS100A(name="twpa_pump", address="192.168.0.36") - - instruments = { - controller.name: controller, - twpa_pump.name: twpa_pump, - } - instruments.update(modules) - instruments = load_instrument_settings(runcard, instruments) - - # Create channel objects - channels = ChannelMap() - # Readout - channels |= Channel(name="L3-25_a", port=modules["qrm_rf_a"].ports("o1")) - channels |= Channel(name="L3-25_b", port=modules["qrm_rf_b"].ports("o1")) - # Feedback - channels |= Channel(name="L2-5_a", port=modules["qrm_rf_a"].ports("i1", out=False)) - channels |= Channel(name="L2-5_b", port=modules["qrm_rf_b"].ports("i1", out=False)) - # Drive - channels |= Channel(name="L3-15", port=modules["qcm_rf0"].ports("o1")) - channels |= Channel(name="L3-11", port=modules["qcm_rf0"].ports("o2")) - channels |= Channel(name="L3-12", port=modules["qcm_rf1"].ports("o1")) - channels |= Channel(name="L3-13", port=modules["qcm_rf1"].ports("o2")) - channels |= Channel(name="L3-14", port=modules["qcm_rf2"].ports("o1")) - # Flux - channels |= Channel(name="L4-5", port=modules["qcm_bb0"].ports("o1")) - channels |= Channel(name="L4-1", port=modules["qcm_bb0"].ports("o2")) - channels |= Channel(name="L4-2", port=modules["qcm_bb0"].ports("o3")) - channels |= Channel(name="L4-3", port=modules["qcm_bb0"].ports("o4")) - channels |= Channel(name="L4-4", port=modules["qcm_bb1"].ports("o1")) - # TWPA - channels |= Channel(name="L3-28", port=None) - channels["L3-28"].local_oscillator = twpa_pump - - # create qubit objects - - qubits, couplers, pairs = load_qubits(runcard) - # remove witness qubit - # del qubits[5] - # assign channels to qubits - for q in [0, 1]: - qubits[q].readout = channels["L3-25_a"] - qubits[q].feedback = channels["L2-5_a"] - qubits[q].twpa = channels["L3-28"] - for q in [2, 3, 4]: - qubits[q].readout = channels["L3-25_b"] - qubits[q].feedback = channels["L2-5_b"] - qubits[q].twpa = channels["L3-28"] - - qubits[0].drive = channels["L3-15"] - qubits[0].flux = channels["L4-5"] - channels["L4-5"].qubit = qubits[0] - for q in range(1, 5): - qubits[q].drive = channels[f"L3-{10 + q}"] - qubits[q].flux = channels[f"L4-{q}"] - channels[f"L4-{q}"].qubit = qubits[q] - - # set maximum allowed bias - for q in range(5): - qubits[q].flux.max_bias = 2.5 - - settings = load_settings(runcard) - - return Platform( - str(FOLDER), qubits, pairs, instruments, settings, resonator_type="2D" - ) diff --git a/tests/dummy_qrc/qm/parameters.json b/tests/dummy_qrc/qm/parameters.json deleted file mode 100644 index 86b76bff5c..0000000000 --- a/tests/dummy_qrc/qm/parameters.json +++ /dev/null @@ -1,361 +0,0 @@ -{ - "nqubits": 5, - "qubits": [ - 0, - 1, - 2, - 3, - 4 - ], - "settings": { - "nshots": 1024, - "relaxation_time": 50000 - }, - "topology": [ - [ - 0, - 2 - ], - [ - 1, - 2 - ], - [ - 2, - 3 - ], - [ - 2, - 4 - ] - ], - "instruments": { - "qm": { - "bounds": { - "waveforms" : 10000, - "readout": 30, - "instructions": 1000000 - } - }, - "con1": { - "i1": {"gain": 0}, - "i2": {"gain": 0} - }, - "con2": { - "o2": { - "filter": { - "feedforward": [1.0684635881381783, -1.0163217174522334], - "feedback": [0.947858129314055] - } - }, - "i1": {"gain": 0}, - "i2": {"gain": 0} - }, - "lo_readout_a": { - "frequency": 7300000000, - "power": 18 - }, - "lo_readout_b": { - "frequency": 7900000000, - "power": 15 - }, - "lo_drive_low": { - "frequency": 4700000000, - "power": 16 - }, - "lo_drive_mid": { - "frequency": 5600000000, - "power": 16 - }, - "lo_drive_high": { - "frequency": 6500000000, - "power": 16 - }, - "twpa_a": { - "frequency": 6511000000, - "power": 4.5 - } - }, - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 40, - "amplitude": 0.005, - "frequency": 4700000000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.005, - "frequency": 4700000000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 1000, - "amplitude": 0.0025, - "frequency": 7226500000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "1": { - "RX": { - "duration": 40, - "amplitude": 0.0484, - "frequency": 4855663000, - "shape": "Drag(5, -0.02)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.0484, - "frequency": 4855663000, - "shape": "Drag(5, -0.02)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 620, - "amplitude": 0.003575, - "frequency": 7453265000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "2": { - "RX": { - "duration": 40, - "amplitude": 0.05682, - "frequency": 5800563000, - "shape": "Drag(5, -0.04)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.05682, - "frequency": 5800563000, - "shape": "Drag(5, -0.04)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 960, - "amplitude": 0.00325, - "frequency": 7655107000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "3": { - "RX": { - "duration": 40, - "amplitude": 0.138, - "frequency": 6760922000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.138, - "frequency": 6760922000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 960, - "amplitude": 0.004225, - "frequency": 7802191000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "4": { - "RX": { - "duration": 40, - "amplitude": 0.0617, - "frequency": 6585053000, - "shape": "Drag(5, 0.0)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.0617, - "frequency": 6585053000, - "shape": "Drag(5, 0.0)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 640, - "amplitude": 0.0039, - "frequency": 8057668000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - } - }, - "two_qubit": { - "1-2": { - "CZ": [ - { - "duration": 30, - "amplitude": 0.055, - "shape": "Rectangular()", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 2 - } - ] - }, - "2-3": { - "CZ": [ - { - "duration": 32, - "amplitude": -0.0513, - "shape": "Rectangular()", - "qubit": 3, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 2 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 3 - } - ] - } - } - }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 0.0, - "drive_frequency": 0.0, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0.0, - "threshold": 0.0, - "iq_angle": 0.0, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "1": { - "readout_frequency": 7453265000, - "drive_frequency": 4855663000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.047, - "threshold": 0.00028502261712637096, - "iq_angle": 1.283105298787488, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "2": { - "readout_frequency": 7655107000, - "drive_frequency": 5799876000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.045, - "threshold": 0.0002694329123116206, - "iq_angle": 4.912447775569025, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "3": { - "readout_frequency": 7802391000, - "drive_frequency": 6760700000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0.034, - "threshold": 0.0003363427381347193, - "iq_angle": 1.6124890998581591, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "4": { - "readout_frequency": 8057668000, - "drive_frequency": 6585053000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.057, - "threshold": 0.00013079660165463033, - "iq_angle": 5.6303684840135, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - } - }, - "two_qubit":{ - "0-2": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "1-2": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "2-3": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "2-4": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - } - } - } -} diff --git a/tests/dummy_qrc/qm/platform.py b/tests/dummy_qrc/qm/platform.py deleted file mode 100644 index 40e2db638f..0000000000 --- a/tests/dummy_qrc/qm/platform.py +++ /dev/null @@ -1,95 +0,0 @@ -import pathlib - -from qibolab.channels import Channel, ChannelMap -from qibolab.instruments.dummy import DummyLocalOscillator as LocalOscillator -from qibolab.instruments.qm import OPXplus, QMController -from qibolab.platform import Platform -from qibolab.serialize import ( - load_instrument_settings, - load_qubits, - load_runcard, - load_settings, -) - -FOLDER = pathlib.Path(__file__).parent - - -def create(): - """Dummy platform using Quantum Machines (QM) OPXs and Rohde Schwarz local - oscillators. - - Based on QuantWare 5-qubit device. - - Used in ``test_instruments_qm.py`` and ``test_instruments_qmsim.py`` - """ - opxs = [OPXplus(f"con{i}") for i in range(1, 4)] - controller = QMController("qm", "192.168.0.101:80", opxs=opxs, time_of_flight=280) - - # Create channel objects and map controllers to channels - channels = ChannelMap() - # readout - channels |= Channel("L3-25_a", port=controller.ports((("con1", 10), ("con1", 9)))) - channels |= Channel("L3-25_b", port=controller.ports((("con2", 10), ("con2", 9)))) - # feedback - channels |= Channel( - "L2-5_a", port=controller.ports((("con1", 2), ("con1", 1)), output=False) - ) - channels |= Channel( - "L2-5_b", port=controller.ports((("con2", 2), ("con2", 1)), output=False) - ) - # drive - channels |= ( - Channel( - f"L3-1{i}", port=controller.ports((("con1", 2 * i), ("con1", 2 * i - 1))) - ) - for i in range(1, 5) - ) - channels |= Channel("L3-15", port=controller.ports((("con3", 2), ("con3", 1)))) - # flux - channels |= (Channel(f"L4-{i}", port=opxs[1].ports(i)) for i in range(1, 6)) - # TWPA - channels |= "L4-26" - - # Instantiate local oscillators - local_oscillators = [ - LocalOscillator("lo_readout_a", "192.168.0.39"), - LocalOscillator("lo_readout_b", "192.168.0.31"), - LocalOscillator("lo_drive_low", "192.168.0.32"), - LocalOscillator("lo_drive_mid", "192.168.0.33"), - LocalOscillator("lo_drive_high", "192.168.0.34"), - LocalOscillator("twpa_a", "192.168.0.35"), - ] - # Map LOs to channels - channels["L3-25_a"].local_oscillator = local_oscillators[0] - channels["L3-25_b"].local_oscillator = local_oscillators[1] - channels["L3-15"].local_oscillator = local_oscillators[2] - channels["L3-11"].local_oscillator = local_oscillators[2] - channels["L3-12"].local_oscillator = local_oscillators[3] - channels["L3-13"].local_oscillator = local_oscillators[4] - channels["L3-14"].local_oscillator = local_oscillators[4] - channels["L4-26"].local_oscillator = local_oscillators[5] - - # create qubit objects - runcard = load_runcard(FOLDER) - qubits, couplers, pairs = load_qubits(runcard) - - # assign channels to qubits - for q in [0, 1]: - qubits[q].readout = channels["L3-25_a"] - qubits[q].feedback = channels["L2-5_a"] - for q in [2, 3, 4]: - qubits[q].readout = channels["L3-25_b"] - qubits[q].feedback = channels["L2-5_b"] - - qubits[0].drive = channels["L3-15"] - qubits[0].flux = channels["L4-5"] - for q in range(1, 5): - qubits[q].drive = channels[f"L3-{10 + q}"] - qubits[q].flux = channels[f"L4-{q}"] - - instruments = {controller.name: controller} - instruments.update(controller.opxs) - instruments.update({lo.name: lo for lo in local_oscillators}) - settings = load_settings(runcard) - instruments = load_instrument_settings(runcard, instruments) - return Platform("qm", qubits, pairs, instruments, settings, resonator_type="2D") diff --git a/tests/dummy_qrc/qm_octave/parameters.json b/tests/dummy_qrc/qm_octave/parameters.json index db430ede9b..822b549c37 100644 --- a/tests/dummy_qrc/qm_octave/parameters.json +++ b/tests/dummy_qrc/qm_octave/parameters.json @@ -1,383 +1,248 @@ { - "nqubits": 5, - "qubits": [ - 0, - 1, - 2, - 3, - 4 - ], - "settings": { - "nshots": 1024, - "relaxation_time": 50000 + "nqubits": 5, + "qubits": [0, 1, 2, 3, 4], + "settings": { + "nshots": 1024, + "relaxation_time": 50000 + }, + "topology": [ + [0, 2], + [1, 2], + [2, 3], + [2, 4] + ], + "instruments": { + "qm": { + "bounds": { + "waveforms": 10000, + "readout": 30, + "instructions": 1000000 + } }, - "topology": [ - [ - 0, - 2 - ], - [ - 1, - 2 - ], - [ - 2, - 3 - ], - [ - 2, - 4 - ] - ], - "instruments": { - "qm": { - "bounds": { - "waveforms" : 10000, - "readout": 30, - "instructions": 1000000 - } + "con1": { + "i1": { + "gain": 0 + }, + "i2": { + "gain": 0 + } + }, + "con2": { + "i1": { + "gain": 0 + }, + "i2": { + "gain": 0 + } + }, + "octave1": { + "o1": { + "lo_frequency": 4700000000, + "gain": 0 + }, + "o2": { + "lo_frequency": 5600000000, + "gain": 0 + }, + "o3": { + "lo_frequency": 6500000000, + "gain": 0 + }, + "o4": { + "lo_frequency": 6500000000, + "gain": 0 + }, + "o5": { + "lo_frequency": 7300000000, + "gain": 0 + }, + "i1": { + "lo_frequency": 7300000000 + } + }, + "octave2": { + "o5": { + "lo_frequency": 7900000000, + "gain": 0 + }, + "i1": { + "lo_frequency": 7900000000 + } + }, + "octave3": { + "o1": { + "lo_frequency": 4700000000, + "gain": 0 + } + }, + "twpa_a": { + "frequency": 6511000000, + "power": 4.5 + } + }, + "native_gates": { + "single_qubit": { + "0": { + "RX": { + "duration": 40, + "amplitude": 0.005, + "frequency": 4700000000, + "envelope": { "kind": "gaussian", "rel_sigma": 0.2 }, + "type": "qd" }, - "con1": { - "i1": { - "gain": 0 - }, - "i2": { - "gain": 0 - } + "RX12": { + "duration": 40, + "amplitude": 0.005, + "frequency": 4700000000, + "envelope": { "kind": "gaussian", "rel_sigma": 0.2 }, + "type": "qd" }, - "con2": { - "i1": { - "gain": 0 - }, - "i2": { - "gain": 0 - } + "MZ": { + "duration": 1000, + "amplitude": 0.0025, + "frequency": 7226500000, + "envelope": { "kind": "rectangular" }, + "type": "ro" + } + }, + "1": { + "RX": { + "duration": 40, + "amplitude": 0.0484, + "frequency": 4855663000, + "envelope": { "kind": "drag", "rel_sigma": 0.2, "beta": 0.02 }, + "type": "qd" }, - "octave1": { - "o1": { - "lo_frequency": 4700000000, - "gain": 0 - }, - "o2": { - "lo_frequency": 5600000000, - "gain": 0 - }, - "o3": { - "lo_frequency": 6500000000, - "gain": 0 - }, - "o4": { - "lo_frequency": 6500000000, - "gain": 0 - }, - "o5": { - "lo_frequency": 7300000000, - "gain": 0 - }, - "i1": { - "lo_frequency": 7300000000 - } + "RX12": { + "duration": 40, + "amplitude": 0.0484, + "frequency": 4855663000, + "envelope": { "kind": "drag", "rel_sigma": 0.2, "beta": 0.02 }, + "type": "qd" }, - "octave2": { - "o5": { - "lo_frequency": 7900000000, - "gain": 0 - }, - "i1": { - "lo_frequency": 7900000000 - } + "MZ": { + "duration": 620, + "amplitude": 0.003575, + "frequency": 7453265000, + "envelope": { "kind": "rectangular" }, + "type": "ro" + } + }, + "2": { + "RX": { + "duration": 40, + "amplitude": 0.05682, + "frequency": 5800563000, + "envelope": { "kind": "drag", "rel_sigma": 0.2, "beta": 0.04 }, + "type": "qd" }, - "octave3": { - "o1": { - "lo_frequency": 4700000000, - "gain": 0 - } + "RX12": { + "duration": 40, + "amplitude": 0.05682, + "frequency": 5800563000, + "envelope": { "kind": "drag", "rel_sigma": 0.2, "beta": 0.04 }, + "type": "qd" }, - "twpa_a": { - "frequency": 6511000000, - "power": 4.5 + "MZ": { + "duration": 960, + "amplitude": 0.00325, + "frequency": 7655107000, + "envelope": { "kind": "rectangular" }, + "type": "ro" } - }, - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 40, - "amplitude": 0.005, - "frequency": 4700000000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.005, - "frequency": 4700000000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 1000, - "amplitude": 0.0025, - "frequency": 7226500000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "1": { - "RX": { - "duration": 40, - "amplitude": 0.0484, - "frequency": 4855663000, - "shape": "Drag(5, -0.02)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.0484, - "frequency": 4855663000, - "shape": "Drag(5, -0.02)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 620, - "amplitude": 0.003575, - "frequency": 7453265000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "2": { - "RX": { - "duration": 40, - "amplitude": 0.05682, - "frequency": 5800563000, - "shape": "Drag(5, -0.04)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.05682, - "frequency": 5800563000, - "shape": "Drag(5, -0.04)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 960, - "amplitude": 0.00325, - "frequency": 7655107000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "3": { - "RX": { - "duration": 40, - "amplitude": 0.138, - "frequency": 6760922000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.138, - "frequency": 6760922000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 960, - "amplitude": 0.004225, - "frequency": 7802191000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "4": { - "RX": { - "duration": 40, - "amplitude": 0.0617, - "frequency": 6585053000, - "shape": "Drag(5, 0.0)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.0617, - "frequency": 6585053000, - "shape": "Drag(5, 0.0)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 640, - "amplitude": 0.0039, - "frequency": 8057668000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - } + }, + "3": { + "RX": { + "duration": 40, + "amplitude": 0.138, + "frequency": 6760922000, + "envelope": { "kind": "gaussian", "rel_sigma": 0.2 }, + "type": "qd" }, - "two_qubit": { - "1-2": { - "CZ": [ - { - "duration": 30, - "amplitude": 0.055, - "shape": "Rectangular()", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 2 - } - ] - }, - "2-3": { - "CZ": [ - { - "duration": 32, - "amplitude": -0.0513, - "shape": "Rectangular()", - "qubit": 3, - "relative_start": 0, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 2 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 3 - } - ] - } + "RX12": { + "duration": 40, + "amplitude": 0.138, + "frequency": 6760922000, + "envelope": { "kind": "gaussian", "rel_sigma": 0.2 }, + "type": "qd" + }, + "MZ": { + "duration": 960, + "amplitude": 0.004225, + "frequency": 7802191000, + "envelope": { "kind": "rectangular" }, + "type": "ro" } - }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 0.0, - "drive_frequency": 0.0, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0.0, - "threshold": 0.0, - "iq_angle": 0.0, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "1": { - "readout_frequency": 7453265000, - "drive_frequency": 4855663000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.047, - "threshold": 0.00028502261712637096, - "iq_angle": 1.283105298787488, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "2": { - "readout_frequency": 7655107000, - "drive_frequency": 5799876000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.045, - "threshold": 0.0002694329123116206, - "iq_angle": 4.912447775569025, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "3": { - "readout_frequency": 7802391000, - "drive_frequency": 6760700000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0.034, - "threshold": 0.0003363427381347193, - "iq_angle": 1.6124890998581591, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - }, - "4": { - "readout_frequency": 8057668000, - "drive_frequency": 6585053000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": -0.057, - "threshold": 0.00013079660165463033, - "iq_angle": 5.6303684840135, - "mixer_drive_g": 0.0, - "mixer_drive_phi": 0.0, - "mixer_readout_g": 0.0, - "mixer_readout_phi": 0.0 - } + }, + "4": { + "RX": { + "duration": 40, + "amplitude": 0.0617, + "frequency": 6585053000, + "envelope": { "kind": "drag", "rel_sigma": 0.2, "beta": 0 }, + "type": "qd" }, - "two_qubit":{ - "0-2": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "1-2": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "2-3": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "2-4": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - } + "RX12": { + "duration": 40, + "amplitude": 0.0617, + "frequency": 6585053000, + "envelope": { "kind": "drag", "rel_sigma": 0.2, "beta": 0 }, + "type": "qd" + }, + "MZ": { + "duration": 640, + "amplitude": 0.0039, + "frequency": 8057668000, + "envelope": { "kind": "rectangular" }, + "type": "ro" } + } + }, + "two_qubit": { + "1-2": { + "CZ": [ + { + "duration": 30, + "amplitude": 0.055, + "envelope": { "kind": "rectangular" }, + "qubit": 2, + "frequency": 0, + "type": "qf" + }, + { + "type": "vz", + "phase": -1.5707963267948966, + "qubit": 1 + }, + { + "type": "vz", + "phase": -1.5707963267948966, + "qubit": 2 + } + ] + }, + "2-3": { + "CZ": [ + { + "duration": 32, + "amplitude": -0.0513, + "envelope": { "kind": "rectangular" }, + "qubit": 3, + "frequency": 0, + "type": "qf" + }, + { + "type": "vz", + "phase": -1.5707963267948966, + "qubit": 2 + }, + { + "type": "vz", + "phase": -1.5707963267948966, + "qubit": 3 + } + ] + } } + } } diff --git a/tests/dummy_qrc/qm_octave/platform.py b/tests/dummy_qrc/qm_octave/platform.py index 3d3d307bf3..2b8aeb1e91 100644 --- a/tests/dummy_qrc/qm_octave/platform.py +++ b/tests/dummy_qrc/qm_octave/platform.py @@ -1,15 +1,9 @@ import pathlib -from qibolab.channels import Channel, ChannelMap -from qibolab.instruments.dummy import DummyLocalOscillator as LocalOscillator -from qibolab.instruments.qm import Octave, OPXplus, QMController -from qibolab.platform import Platform -from qibolab.serialize import ( - load_instrument_settings, - load_qubits, - load_runcard, - load_settings, -) +from qibolab._core.channel import Channel, ChannelMap +from qibolab._core.instruments.dummy import DummyLocalOscillator as LocalOscillator +from qibolab._core.instruments.qm import Octave, OPXplus, QMController +from qibolab._core.platform import Platform RUNCARD = pathlib.Path(__file__).parent @@ -26,7 +20,6 @@ def create(runcard_path=RUNCARD): octave2 = Octave("octave2", port=101, connectivity=opxs[1]) octave3 = Octave("octave3", port=102, connectivity=opxs[2]) controller = QMController( - "qm", "192.168.0.101:80", opxs=opxs, octaves=[octave1, octave2, octave3], @@ -50,7 +43,7 @@ def create(runcard_path=RUNCARD): channels |= "L4-26" # Instantiate local oscillators - twpa = LocalOscillator("twpa_a", "192.168.0.35") + twpa = LocalOscillator("192.168.0.35") # Map LOs to channels channels["L4-26"].local_oscillator = twpa @@ -72,11 +65,10 @@ def create(runcard_path=RUNCARD): qubits[q].drive = channels[f"L3-{10 + q}"] qubits[q].flux = channels[f"L4-{q}"] - instruments = {controller.name: controller, twpa.name: twpa} + instruments = {"qm": controller, "twpa_a": twpa} instruments.update(controller.opxs) instruments.update(controller.octaves) settings = load_settings(runcard) - instruments = load_instrument_settings(runcard, instruments) return Platform( "qm_octave", qubits, pairs, instruments, settings, resonator_type="2D" ) diff --git a/tests/dummy_qrc/rfsoc/parameters.json b/tests/dummy_qrc/rfsoc/parameters.json deleted file mode 100644 index 65e71e7da5..0000000000 --- a/tests/dummy_qrc/rfsoc/parameters.json +++ /dev/null @@ -1,83 +0,0 @@ -{ - "nqubits": 1, - "qubits": [ - 0 - ], - "topology": [], - "settings": { - "nshots": 1024, - "relaxation_time": 100000 - }, - "instruments": { - "tii_rfsoc4x2": { - "bounds": { - "waveforms": 0, - "readout": 0, - "instructions": 0 - } - }, - "twpa_a": { - "frequency": 6200000000, - "power": -1 - }, - "ErasynthLO": { - "frequency": 0, - "power": 0 - } - }, - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 30, - "amplitude": 0.05284168507293318, - "frequency": 5542341844, - "shape": "Rectangular()", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 30, - "amplitude": 0.05284168507293318, - "frequency": 5542341844, - "shape": "Rectangular()", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 600, - "amplitude": 0.03, - "frequency": 7371258599, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - } - } - }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 7371258599, - "drive_frequency": 5542341844, - "pi_pulse_amplitude": 0.05284168507293318, - "T1": 10441.64173639732, - "T2": 4083.4697338939845, - "threshold": -0.8981346462690887, - "iq_angle": -1.2621946150226666, - "mean_gnd_states": [ - -0.17994037940379404, - -2.4709365853658536 - ], - "mean_exc_states": [ - 0.6854460704607047, - 0.24369105691056914 - ], - "T2_spin_echo": 5425.5448969467925 - } - } - } -} diff --git a/tests/dummy_qrc/rfsoc/platform.py b/tests/dummy_qrc/rfsoc/platform.py deleted file mode 100644 index 48082cda01..0000000000 --- a/tests/dummy_qrc/rfsoc/platform.py +++ /dev/null @@ -1,51 +0,0 @@ -import pathlib - -from qibolab.channels import Channel, ChannelMap -from qibolab.instruments.erasynth import ERA -from qibolab.instruments.rfsoc import RFSoC -from qibolab.instruments.rohde_schwarz import SGS100A -from qibolab.platform import Platform -from qibolab.serialize import ( - load_instrument_settings, - load_qubits, - load_runcard, - load_settings, -) - -FOLDER = pathlib.Path(__file__).parent - - -def create(): - """Dummy platform using QICK project on the RFSoC4x2 board. - - Used in ``test_instruments_rfsoc.py``. - """ - # Instantiate QICK instruments - controller = RFSoC("tii_rfsoc4x2", "0.0.0.0", 0, sampling_rate=9.8304) - - # Create channel objects and map to instrument controllers - channels = ChannelMap() - channels |= Channel("L3-18_ro", port=controller.ports(0)) # readout (DAC) - channels |= Channel("L2-RO", port=controller.ports(0)) # feedback (readout DAC) - channels |= Channel("L3-18_qd", port=controller.ports(1)) # drive - channels |= Channel("L2-22_qf", port=controller.ports(2)) # flux - - lo_twpa = SGS100A("twpa_a", "192.168.0.32") - lo_era = ERA("ErasynthLO", "192.168.0.212", ethernet=True) - channels["L3-18_ro"].local_oscillator = lo_era - - runcard = load_runcard(FOLDER) - qubits, couplers, pairs = load_qubits(runcard) - - # assign channels to qubits - qubits[0].readout = channels["L3-18_ro"] - qubits[0].feedback = channels["L2-RO"] - qubits[0].drive = channels["L3-18_qd"] - qubits[0].flux = channels["L2-22_qf"] - - instruments = {inst.name: inst for inst in [controller, lo_twpa, lo_era]} - settings = load_settings(runcard) - instruments = load_instrument_settings(runcard, instruments) - return Platform( - str(FOLDER), qubits, pairs, instruments, settings, resonator_type="3D" - ) diff --git a/tests/dummy_qrc/zurich/parameters.json b/tests/dummy_qrc/zurich/parameters.json index e49acba7c6..ccf64499e9 100644 --- a/tests/dummy_qrc/zurich/parameters.json +++ b/tests/dummy_qrc/zurich/parameters.json @@ -1,415 +1,540 @@ { - "nqubits": 5, - "qubits": [ - 0, - 1, - 2, - 3, - 4 - ], - "couplers": [ - 0, - 1, - 3, - 4 - ], - "topology": { - "0": [ - 0, - 2 + "nqubits": 5, + "settings": { + "nshots": 4096, + "relaxation_time": 300000 + }, + "instruments": { + "EL_ZURO": { + "bounds": { + "instructions": 1000000, + "readout": 250, + "waveforms": 40000 + } + } + }, + "components": { + "qubit_0/drive": { + "kind": "iq", + "frequency": 4000000000, + "power_range": 5 + }, + "qubit_1/drive": { + "kind": "iq", + "frequency": 4200000000, + "power_range": 0 + }, + "qubit_2/drive": { + "kind": "iq", + "frequency": 4500000000, + "power_range": -5 + }, + "qubit_3/drive": { + "kind": "iq", + "frequency": 4150000000, + "power_range": -10 + }, + "qubit_4/drive": { + "kind": "iq", + "frequency": 4155663000, + "power_range": 5 + }, + "qubit_0/flux": { + "kind": "dc", + "offset": -0.1, + "power_range": 0.2 + }, + "qubit_1/flux": { + "kind": "dc", + "offset": 0.0, + "power_range": 0.6 + }, + "qubit_2/flux": { + "kind": "dc", + "offset": 0.1, + "power_range": 0.4 + }, + "qubit_3/flux": { + "kind": "dc", + "offset": 0.2, + "power_range": 1 + }, + "qubit_4/flux": { + "kind": "dc", + "offset": 0.15, + "power_range": 5 + }, + "qubit_0/probe": { + "kind": "iq", + "frequency": 5200000000, + "power_range": -10 + }, + "qubit_1/probe": { + "kind": "iq", + "frequency": 4900000000, + "power_range": -10 + }, + "qubit_2/probe": { + "kind": "iq", + "frequency": 6100000000, + "power_range": -10 + }, + "qubit_3/probe": { + "kind": "iq", + "frequency": 5800000000, + "power_range": -10 + }, + "qubit_4/probe": { + "kind": "iq", + "frequency": 5500000000, + "power_range": -10 + }, + "qubit_0/acquire": { + "kind": "acquisition", + "delay": 0, + "iq_angle": null, + "smearing": 0, + "power_range": 10, + "threshold": null + }, + "qubit_1/acquire": { + "kind": "acquisition", + "delay": 0, + "iq_angle": null, + "smearing": 0, + "power_range": 10, + "threshold": null + }, + "qubit_2/acquire": { + "kind": "acquisition", + "delay": 0, + "iq_angle": null, + "smearing": 0, + "power_range": 10, + "threshold": null + }, + "qubit_3/acquire": { + "kind": "acquisition", + "delay": 0, + "iq_angle": null, + "smearing": 0, + "power_range": 10, + "threshold": null + }, + "qubit_4/acquire": { + "kind": "acquisition", + "delay": 0, + "iq_angle": null, + "smearing": 0, + "power_range": 10, + "threshold": null + }, + "coupler_0/flux": { + "kind": "dc", + "offset": 0.0, + "power_range": 3 + }, + "coupler_1/flux": { + "kind": "dc", + "offset": 0.0, + "power_range": 1 + }, + "coupler_3/flux": { + "kind": "dc", + "offset": 0.0, + "power_range": 0.4 + }, + "coupler_4/flux": { + "kind": "dc", + "offset": 0.0, + "power_range": 0.4 + }, + "readout/lo": { + "kind": "oscillator", + "power": 10, + "frequency": 6000000000.0 + }, + "qubit_0_1/drive/lo": { + "kind": "oscillator", + "power": 10, + "frequency": 3000000000.0 + }, + "qubit_2_3/drive/lo": { + "kind": "oscillator", + "power": 10, + "frequency": 3500000000.0 + }, + "qubit_4/drive/lo": { + "kind": "oscillator", + "power": 10, + "frequency": 4000000000.0 + } + }, + "native_gates": { + "single_qubit": { + "0": { + "RX": [ + [ + "qubit_0/drive", + { + "duration": 40.0, + "amplitude": 0.5, + "envelope": { + "kind": "gaussian", + "rel_sigma": 2.0 + } + } + ] + ], + "MZ": [ + [ + "qubit_0/probe", + { + "duration": 2000.0, + "amplitude": 0.1, + "envelope": { + "kind": "rectangular" + } + } + ] + ] + }, + "1": { + "RX": [ + [ + "qubit_1/drive", + { + "duration": 40.0, + "amplitude": 0.5, + "envelope": { + "kind": "gaussian", + "rel_sigma": 2.0 + } + } + ] ], - "1": [ - 1, - 2 + "MZ": [ + [ + "qubit_1/probe", + { + "duration": 2000.0, + "amplitude": 0.2, + "envelope": { + "kind": "rectangular" + } + } + ] + ] + }, + "2": { + "RX": [ + [ + "qubit_2/drive", + { + "duration": 40.0, + "amplitude": 0.54, + "envelope": { + "kind": "gaussian", + "rel_sigma": 2.0 + } + } + ] ], - "3": [ - 2, - 3 + "MZ": [ + [ + "qubit_2/probe", + { + "duration": 2000.0, + "amplitude": 0.02, + "envelope": { + "kind": "rectangular" + } + } + ] + ] + }, + "3": { + "RX": [ + [ + "qubit_3/drive", + { + "duration": 40.0, + "amplitude": 0.454, + "envelope": { + "kind": "gaussian", + "rel_sigma": 2.0 + } + } + ] ], - "4": [ - 2, - 4 + "MZ": [ + [ + "qubit_3/probe", + { + "duration": 2000.0, + "amplitude": 0.25, + "envelope": { + "kind": "rectangular" + } + } + ] ] - }, - "settings": { - "nshots": 4096, - "relaxation_time": 300000 - }, - "instruments": { - "EL_ZURO": { - "bounds": { - "instructions": 1000000, - "readout": 250, - "waveforms": 40000 + }, + "4": { + "RX": [ + [ + "qubit_4/drive", + { + "duration": 40.0, + "amplitude": 0.6, + "envelope": { + "kind": "gaussian", + "rel_sigma": 2.0 + } } - }, - "lo_readout": { - "frequency": 5500000000 - }, - "lo_drive_0": { - "frequency": 4200000000 - }, - "lo_drive_1": { - "frequency": 4600000000 - }, - "lo_drive_2": { - "frequency": 4800000000 - } + ] + ], + "MZ": [ + [ + "qubit_4/probe", + { + "duration": 2000.0, + "amplitude": 0.31, + "envelope": { + "kind": "rectangular" + } + } + ] + ] + } }, - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 40, - "amplitude": 0.625, - "frequency": 4095830788, - "shape": "Drag(5, 0.04)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.625, - "frequency": 4095830788, - "shape": "Drag(5, 0.04)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 2000, - "amplitude": 0.5, - "frequency": 5229200000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "1": { - "RX": { - "duration": 90, - "amplitude": 0.2, - "frequency": 4170000000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 90, - "amplitude": 0.2, - "frequency": 4170000000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 1000, - "amplitude": 0.1, - "frequency": 4931000000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "2": { - "RX": { - "duration": 40, - "amplitude": 0.59, - "frequency": 4300587281, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 40, - "amplitude": 0.59, - "frequency": 4300587281, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 2000, - "amplitude": 0.54, - "frequency": 6109000000.0, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "3": { - "RX": { - "duration": 90, - "amplitude": 0.75, - "frequency": 4100000000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 90, - "amplitude": 0.75, - "frequency": 4100000000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 2000, - "amplitude": 0.01, - "frequency": 5783000000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } - }, - "4": { - "RX": { - "duration": 53, - "amplitude": 1, - "frequency": 4196800000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "RX12": { - "duration": 53, - "amplitude": 1, - "frequency": 4196800000, - "shape": "Gaussian(5)", - "type": "qd", - "relative_start": 0, - "phase": 0 - }, - "MZ": { - "duration": 1000, - "amplitude": 0.5, - "frequency": 5515000000, - "shape": "Rectangular()", - "type": "ro", - "relative_start": 0, - "phase": 0 - } + "coupler": { + "0": { + "CP": [ + [ + "coupler_0/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + } + } + ] + ] + }, + "1": { + "CP": [ + [ + "coupler_1/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + } } - }, - "coupler": { - "0": { - "CP": { - "type": "coupler", - "duration": 1000, - "amplitude": 0.5, - "shape": "Rectangular()", - "coupler": 0, - "relative_start": 0 - } - }, - "1": { - "CP": { - "type": "coupler", - "duration": 1000, - "amplitude": 0.5, - "shape": "Rectangular()", - "coupler": 1, - "relative_start": 0 - } - }, - "3": { - "CP": { - "type": "coupler", - "duration": 1000, - "amplitude": 0.5, - "shape": "Rectangular()", - "coupler": 3, - "relative_start": 0 - } - }, - "4": { - "CP": { - "type": "coupler", - "duration": 1000, - "amplitude": 0.5, - "shape": "Rectangular()", - "coupler": 4, - "relative_start": 0 - } + ] + ] + }, + "3": { + "CP": [ + [ + "coupler_3/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + } } - }, - "two_qubit": { - "1-2": { - "CZ": [ - { - "duration": 32, - "amplitude": -0.6025, - "shape": "Exponential(12, 5000, 0.1)", - "qubit": 3, - "relative_start": 0, - "type": "qf" - }, - { - "duration": 20, - "amplitude": 0, - "shape": "Rectangular())", - "qubit": 3, - "relative_start": 32, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -3.63, - "qubit": 3 - }, - { - "duration": 32, - "amplitude": 0, - "shape": "Rectangular())", - "qubit": 2, - "relative_start": 0, - "type": "qf" - }, - { - "duration": 20, - "amplitude": 0, - "shape": "Rectangular())", - "qubit": 2, - "relative_start": 32, - "type": "qf" - }, - { - "type": "virtual_z", - "phase": -0.041, - "qubit": 2 - } - ] + ] + ] + }, + "4": { + "CP": [ + [ + "coupler_4/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5.0, + "width": 0.75 + } } - } + ] + ] + } }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 5229200000, - "drive_frequency": 4095830788, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0.05, - "mean_gnd_states": [ - 1.542, - 0.1813 - ], - "mean_exc_states": [ - 2.4499, - -0.5629 - ], - "threshold": 0.8836, - "iq_angle": -1.551 - }, - "1": { - "readout_frequency": 4931000000, - "drive_frequency": 4170000000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0.0, - "mean_gnd_states": [ - 0, - 0 - ], - "mean_exc_states": [ - 0, - 0 - ] - }, - "2": { - "readout_frequency": 6109000000.0, - "drive_frequency": 4300587281, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0.0, - "mean_gnd_states": [ - -1.8243, - 1.5926 - ], - "mean_exc_states": [ - -0.8083, - 2.3929 - ], - "threshold": -0.0593, - "iq_angle": -0.667 - }, - "3": { - "readout_frequency": 5783000000, - "drive_frequency": 4100000000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0.0, - "mean_gnd_states": [ - 0, - 0 - ], - "mean_exc_states": [ - 0, - 0 - ] - }, - "4": { - "readout_frequency": 5515000000, - "drive_frequency": 4196800000, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0.0, - "mean_gnd_states": [ - 0, - 0 - ], - "mean_exc_states": [ - 0, - 0 - ], - "threshold": 0.233806, - "iq_angle": 0.481 + "two_qubit": { + "0-2": { + "CZ": [ + [ + "qubit_2/flux", + { + "duration": 80.0, + "amplitude": 0.057, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5, + "width": 0.75 + } } - }, - "two_qubit":{ - "0-2": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "1-2": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "2-3": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] - }, - "2-4": { - "gate_fidelity": [0.0, 0.0], - "cz_fidelity": [0.0, 0.0] + ], + [ + "qubit_0/drive", + { + "phase": 0.0 } - }, - "coupler": { - "0": { - "sweetspot": 0.0 - }, - "1": { - "sweetspot": 0.0 - }, - "3": { - "sweetspot": 0.0 - }, - "4": { - "sweetspot": 0.0 + ], + [ + "qubit_2/drive", + { + "phase": 0.0 } - } + ], + [ + "coupler_0/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5, + "width": 0.75 + } + } + ] + ] + }, + "1-2": { + "CZ": [ + [ + "qubit_2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5, + "width": 0.75 + } + } + ], + [ + "qubit_1/drive", + { + "phase": 0.0 + } + ], + [ + "qubit_2/drive", + { + "phase": 0.0 + } + ], + [ + "coupler_1/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5, + "width": 0.75 + } + } + ] + ] + }, + "2-3": { + "CZ": [ + [ + "qubit_2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5, + "width": 0.75 + } + } + ], + [ + "qubit_2/drive", + { + "phase": 0.0 + } + ], + [ + "qubit_3/drive", + { + "phase": 0.0 + } + ], + [ + "coupler_3/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5, + "width": 0.75 + } + } + ] + ] + }, + "2-4": { + "CZ": [ + [ + "qubit_2/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5, + "width": 0.75 + } + } + ], + [ + "qubit_2/drive", + { + "phase": 0.0 + } + ], + [ + "qubit_4/drive", + { + "phase": 0.0 + } + ], + [ + "coupler_4/flux", + { + "duration": 30.0, + "amplitude": 0.05, + "envelope": { + "kind": "gaussian_square", + "rel_sigma": 5, + "width": 0.75 + } + } + ] + ] + } } + } } diff --git a/tests/dummy_qrc/zurich/platform.py b/tests/dummy_qrc/zurich/platform.py index b9254813e1..bacd30b466 100644 --- a/tests/dummy_qrc/zurich/platform.py +++ b/tests/dummy_qrc/zurich/platform.py @@ -1,4 +1,3 @@ -import itertools import pathlib from laboneq.dsl.device import create_connection @@ -6,73 +5,37 @@ from laboneq.simple import DeviceSetup from qibolab import Platform -from qibolab.channels import Channel, ChannelMap -from qibolab.instruments.dummy import DummyLocalOscillator as LocalOscillator -from qibolab.instruments.zhinst import Zurich -from qibolab.kernels import Kernels -from qibolab.serialize import ( - load_instrument_settings, - load_qubits, - load_runcard, - load_settings, +from qibolab._core.components import ( + AcquisitionChannel, + DcChannel, + IqChannel, + OscillatorConfig, ) +from qibolab._core.instruments.zhinst import ( + ZiAcquisitionConfig, + ZiChannel, + ZiDcConfig, + ZiIqConfig, + Zurich, +) +from qibolab._core.kernels import Kernels +from qibolab._core.parameters import Parameters FOLDER = pathlib.Path(__file__).parent -N_QUBITS = 5 def create(): - """IQM 5q-chip controlled Zurich Instruments (Zh) SHFQC, HDAWGs and - PQSC.""" + """A platform representing a chip with star topology, featuring 5 qubits + and 4 couplers, controlled by Zurich Instruments SHFQC, HDAWGs and PQSC.""" - device_setup = DeviceSetup("EL_ZURO") - # Dataserver + device_setup = DeviceSetup("device setup") device_setup.add_dataserver(host="localhost", port=8004) - # Instruments device_setup.add_instruments( HDAWG("device_hdawg", address="DEV8660"), HDAWG("device_hdawg2", address="DEV8673"), PQSC("device_pqsc", address="DEV10055", reference_clock_source="internal"), SHFQC("device_shfqc", address="DEV12146"), ) - device_setup.add_connections( - "device_shfqc", - *[ - create_connection( - to_signal=f"q{i}/drive_line", ports=[f"SGCHANNELS/{i}/OUTPUT"] - ) - for i in range(N_QUBITS) - ], - *[ - create_connection( - to_signal=f"q{i}/measure_line", ports=["QACHANNELS/0/OUTPUT"] - ) - for i in range(N_QUBITS) - ], - *[ - create_connection( - to_signal=f"q{i}/acquire_line", ports=["QACHANNELS/0/INPUT"] - ) - for i in range(N_QUBITS) - ], - ) - device_setup.add_connections( - "device_hdawg", - *[ - create_connection(to_signal=f"q{i}/flux_line", ports=f"SIGOUTS/{i}") - for i in range(N_QUBITS) - ], - *[ - create_connection(to_signal=f"qc{c}/flux_line", ports=f"SIGOUTS/{i}") - for c, i in zip(itertools.chain(range(0, 2), range(3, 4)), range(5, 8)) - ], - ) - - device_setup.add_connections( - "device_hdawg2", - create_connection(to_signal="qc4/flux_line", ports=["SIGOUTS/0"]), - ) - device_setup.add_connections( "device_pqsc", create_connection(to_instrument="device_hdawg2", ports="ZSYNCS/1"), @@ -80,121 +43,94 @@ def create(): create_connection(to_instrument="device_shfqc", ports="ZSYNCS/2"), ) - controller = Zurich( - "EL_ZURO", - device_setup=device_setup, - time_of_flight=75, - smearing=50, + parameters = Parameters.load(FOLDER) + kernels = Kernels.load(FOLDER) + qubits, couplers, pairs = ( + parameters.native_gates.single_qubit, + parameters.native_gates.coupler, + parameters.native_gates.two_qubit, ) - # Create channel objects and map controllers - channels = ChannelMap() - # feedback - channels |= Channel( - "L2-7", port=controller.ports(("device_shfqc", "[QACHANNELS/0/INPUT]")) - ) - # readout - channels |= Channel( - "L3-31", port=controller.ports(("device_shfqc", "[QACHANNELS/0/OUTPUT]")) - ) - # drive - channels |= ( - Channel( - f"L4-{i}", - port=controller.ports(("device_shfqc", f"SGCHANNELS/{i-5}/OUTPUT")), + configs = parameters.configs + readout_lo = "readout/lo" + drive_los = { + 0: "qubit_0_1/drive/lo", + 1: "qubit_0_1/drive/lo", + 2: "qubit_2_3/drive/lo", + 3: "qubit_2_3/drive/lo", + 4: "qubit_4/drive/lo", + } + configs[readout_lo] = OscillatorConfig(**component_params[readout_lo]) + zi_channels = [] + for q in qubits: + probe_name = f"qubit_{q}/probe" + acquisition_name = f"qubit_{q}/acquire" + configs[probe_name] = ZiIqConfig(**component_params[probe_name]) + qubits[q].probe = IqChannel( + name=probe_name, lo=readout_lo, mixer=None, acquisition=acquisition_name + ) + zi_channels.append( + ZiChannel( + qubits[q].probe, device="device_shfqc", path="QACHANNELS/0/OUTPUT" + ) ) - for i in range(15, 20) - ) - # flux qubits (CAREFUL WITH THIS !!!) - channels |= ( - Channel(f"L4-{i}", port=controller.ports(("device_hdawg", f"SIGOUTS/{i-6}"))) - for i in range(6, 11) - ) - # flux couplers - channels |= ( - Channel(f"L4-{i}", port=controller.ports(("device_hdawg", f"SIGOUTS/{i-11+5}"))) - for i in range(11, 14) - ) - channels |= Channel("L4-14", port=controller.ports(("device_hdawg2", "SIGOUTS/0"))) - # TWPA pump(EraSynth) - channels |= Channel("L3-32") - - # SHFQC - # Sets the maximal Range of the Signal Output power. - # The instrument selects the closest available Range [-50. -30. -25. -20. -15. -10. -5. 0. 5. 10.] - # with a resolution of 5 dBm. - - # readout "gain": Set to max power range (10 Dbm) if no distorsion - channels["L3-31"].power_range = -15 # -15 - # feedback "gain": play with the power range to calibrate the best RO - channels["L2-7"].power_range = 10 - - # drive - # The instrument selects the closest available Range [-30. -25. -20. -15. -10. -5. 0. 5. 10.] - channels["L4-15"].power_range = -10 # q0 - channels["L4-16"].power_range = -5 # q1 - channels["L4-17"].power_range = -10 # q2 - channels["L4-18"].power_range = -5 # q3 - channels["L4-19"].power_range = -10 # q4 - - # HDAWGS - # Sets the output voltage range. - # The instrument selects the next higher available Range with a resolution of 0.4 Volts. - - # flux - for i in range(6, 11): - channels[f"L4-{i}"].power_range = 0.8 - # flux couplers - for i in range(11, 15): - channels[f"L4-{i}"].power_range = 0.8 - # Instantiate local oscillators - local_oscillators = [ - LocalOscillator(f"lo_{kind}", None) - for kind in ["readout"] + [f"drive_{n}" for n in range(3)] - ] + configs[acquisition_name] = ZiAcquisitionConfig( + **component_params[acquisition_name], kernel=kernels.get(q) + ) + qubits[q].acquisition = AcquisitionChannel( + name=acquisition_name, + twpa_pump=None, + probe=probe_name, + ) + zi_channels.append( + ZiChannel( + qubits[q].acquisition, device="device_shfqc", path="QACHANNELS/0/INPUT" + ) + ) - # Map LOs to channels - ch_to_lo = { - "L3-31": 0, - "L4-15": 1, - "L4-16": 1, - "L4-17": 2, - "L4-18": 2, - "L4-19": 3, - } - for ch, lo in ch_to_lo.items(): - channels[ch].local_oscillator = local_oscillators[lo] + drive_name = f"qubit_{q}/drive" + configs[drive_los[q]] = OscillatorConfig(**component_params[drive_los[q]]) + configs[drive_name] = ZiIqConfig(**component_params[drive_name]) + qubits[q].drive = IqChannel( + name=drive_name, + mixer=None, + lo=drive_los[q], + ) + zi_channels.append( + ZiChannel( + qubits[q].drive, device="device_shfqc", path=f"SGCHANNELS/{q}/OUTPUT" + ) + ) - # create qubit objects - runcard = load_runcard(FOLDER) - kernels = Kernels.load(FOLDER) - qubits, couplers, pairs = load_qubits(runcard, kernels) - settings = load_settings(runcard) + flux_name = f"qubit_{q}/flux" + configs[flux_name] = ZiDcConfig(**component_params[flux_name]) + qubits[q].flux = DcChannel( + name=flux_name, + ) + zi_channels.append( + ZiChannel(qubits[q].flux, device="device_hdawg", path=f"SIGOUTS/{q}") + ) - # assign channels to qubits and sweetspots(operating points) - for q in range(0, 5): - qubits[q].readout = channels["L3-31"] - qubits[q].feedback = channels["L2-7"] + for i, c in enumerate(couplers): + flux_name = f"coupler_{c}/flux" + configs[flux_name] = ZiDcConfig(**component_params[flux_name]) + couplers[c].flux = DcChannel(name=flux_name) + zi_channels.append( + ZiChannel(couplers[c].flux, device="device_hdawg2", path=f"SIGOUTS/{i}") + ) - for q in range(0, 5): - qubits[q].drive = channels[f"L4-{15 + q}"] - qubits[q].flux = channels[f"L4-{6 + q}"] - qubits[q].twpa = channels["L3-32"] - channels[f"L4-{6 + q}"].qubit = qubits[q] + controller = Zurich( + device_setup=device_setup, + channels=zi_channels, + time_of_flight=75, + smearing=50, + ) - # assign channels to couplers and sweetspots(operating points) - for c, coupler in enumerate(couplers.values()): - coupler.flux = channels[f"L4-{11 + c}"] - instruments = {controller.name: controller} - instruments.update({lo.name: lo for lo in local_oscillators}) - instruments = load_instrument_settings(runcard, instruments) return Platform( - str(FOLDER), - qubits, - pairs, - instruments, - settings, - resonator_type="2D", - couplers=couplers, + name=str(FOLDER), + configs=configs, + parameters=parameters, + instruments={"EL_ZURO": controller}, + resonator_type="3D", ) diff --git a/tests/emulators/default_q0/parameters.json b/tests/emulators/default_q0/parameters.json deleted file mode 100644 index 319e727c58..0000000000 --- a/tests/emulators/default_q0/parameters.json +++ /dev/null @@ -1,95 +0,0 @@ -{ - "device_name": "default_q0", - "nqubits": 1, - "ncouplers": 0, - "description": "IBM 5-qubit device FakeBelem, q0 only", - "settings": { - "nshots": 4096, - "relaxation_time": 300000 - }, - "instruments": { - "pulse_simulator": { - "model_params": { - "model_name": "general_no_coupler_model", - "topology": [], - "nqubits": 1, - "ncouplers": 0, - "qubits_list": ["0"], - "couplers_list": [], - "nlevels_q": [3], - "nlevels_c": [], - "readout_error": {"0": [0.01, 0.02]}, - "drive_freq": {"0": 5.090167234445013}, - "T1": {"0": 88578.48970762537}, - "T2": {"0": 106797.94866226273}, - "lo_freq": {"0": 5.090167234445013}, - "rabi_freq": {"0": 0.333}, - "anharmonicity": {"0": -0.3361230051821652}, - "coupling_strength": {} - }, - "simulation_config": { - "simulation_engine_name": "Qutip", - "sampling_rate": 4.5, - "sim_sampling_boost": 10, - "runcard_duration_in_dt_units": false, - "instant_measurement": true, - "simulate_dissipation": true, - "output_state_history": true - }, - "sim_opts": null, - "bounds": { - "waveforms": 1, - "readout": 1, - "instructions": 1 - } - } - }, - "qubits": [ - 0 - ], - "couplers": [], - "topology": [], - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 25.687, - "amplitude":0.1, - "frequency": 5090167234.445013, - "shape": "Drag(4, -4)", - "type": "qd", - "start": 0, - "phase": 0 - }, - "MZ": { - "duration": 4977.777777777777, - "amplitude": 0.03, - "frequency": 7301661824.000001, - "shape": "Rectangular()", - "type": "ro", - "start": 0, - "phase": 1.5636758979377372 - } - } - } - }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 7301661824.000001, - "drive_frequency": 5090167234.445013, - "anharmonicity": -336123005.1821652, - "Ec": 0, - "Ej": 0, - "g": 0, - "T1": 88578.48970762537, - "T2": 106797.94866226273, - "sweetspot": 0, - "mean_gnd_states": "1.5417+0.1817j", - "mean_exc_states": "2.5332-0.5914j", - "threshold": 1.5435, - "iq_angle": 2.602 - } - } - } -} diff --git a/tests/emulators/default_q0/platform.py b/tests/emulators/default_q0/platform.py deleted file mode 100644 index 136350a805..0000000000 --- a/tests/emulators/default_q0/platform.py +++ /dev/null @@ -1,52 +0,0 @@ -import pathlib - -from qibolab.channels import ChannelMap -from qibolab.instruments.emulator.pulse_simulator import PulseSimulator -from qibolab.platform import Platform -from qibolab.serialize import ( - load_instrument_settings, - load_qubits, - load_runcard, - load_settings, -) - -FOLDER = pathlib.Path(__file__).parent - - -def create(): - """Create a one qubit emulator platform.""" - - # load runcard and model params - runcard = load_runcard(FOLDER) - device_name = runcard["device_name"] - - # Specify emulator controller - pulse_simulator = PulseSimulator() - instruments = {"pulse_simulator": pulse_simulator} - instruments = load_instrument_settings(runcard, instruments) - - # extract quantities from runcard for platform declaration - qubits, couplers, pairs = load_qubits(runcard) - settings = load_settings(runcard) - - # Create channel object - channels = ChannelMap() - channels |= (f"readout-{q}" for q in qubits) - channels |= (f"drive-{q}" for q in qubits) - - # map channels to qubits - for q, qubit in qubits.items(): - qubit.readout = channels[f"readout-{q}"] - qubit.drive = channels[f"drive-{q}"] - - channels[f"drive-{q}"].qubit = qubit - qubit.sweetspot = 0 # not used - - return Platform( - device_name, - qubits, - pairs, - instruments, - settings, - resonator_type="2D", - ) diff --git a/tests/emulators/ibmfakebelem_q01/parameters.json b/tests/emulators/ibmfakebelem_q01/parameters.json deleted file mode 100644 index 39ef172066..0000000000 --- a/tests/emulators/ibmfakebelem_q01/parameters.json +++ /dev/null @@ -1,284 +0,0 @@ -{ - "device_name": "ibmfakebelem_q01", - "nqubits": 2, - "ncouplers": 0, - "description": "IBM 5-qubit device FakeBelem, q0 and q1 only", - "settings": { - "nshots": 4096, - "relaxation_time": 300000 - }, - "instruments": { - "pulse_simulator": { - "model_params": { - "model_name": "general_no_coupler_model", - "topology": [ - [0, 1] - ], - "nqubits": 2, - "ncouplers": 0, - "qubits_list": ["0", "1"], - "couplers_list": [], - "nlevels_q": [2, 2], - "nlevels_c": [], - "readout_error": { - "0": [0.01, 0.02], - "1": [0.01, 0.02] - }, - "drive_freq": { - "0": 5.090167234445013, - "1": 5.245306068285918 - }, - "T1": { - "0": 88578.48970762537, - "1": 78050.43996837796 - }, - "T2": { - "0": 106797.94866226273, - "1": 63765.78004446571 - }, - "lo_freq": { - "0": 5.090167234445013, - "1": 5.245306068285918 - }, - "rabi_freq": { - "0": 0.12545753819061986, - "1": 0.12144270034090286 - }, - "anharmonicity": { - "0": -0.3361230051821652, - "1": -0.316572131412737 - }, - "coupling_strength": { - "1_0": 0.0018736137364449845 - } - }, - "simulation_config": { - "simulation_engine_name": "Qutip", - "sampling_rate": 4.5, - "sim_sampling_boost": 10, - "runcard_duration_in_dt_units": true, - "instant_measurement": true, - "simulate_dissipation": true, - "output_state_history": true - }, - "sim_opts": null, - "bounds": { - "waveforms": 1, - "readout": 1, - "instructions": 1 - } - } - }, - "qubits": [0, 1], - "couplers": [], - "topology": [ - [0, 1] - ], - "native_gates": { - "single_qubit": { - "0": { - "RX": { - "duration": 61.117, - "amplitude": 0.5, - "frequency": 5090167234.445013, - "shape": "Drag(4, -2.4305800297101414)", - "type": "qd", - "start": 0, - "phase": 0 - }, - "MZ": { - "duration": 22400, - "amplitude": 0.03, - "frequency": 7301661824.000001, - "shape": "Rectangular()", - "type": "ro", - "start": 0, - "phase": 1.5636758979377372 - } - }, - "1": { - "RX": { - "duration": 63.394, - "amplitude": 0.5, - "frequency": 5245306068.285917, - "shape": "Drag(4, 0.6571522139248822)", - "type": "qd", - "start": 0, - "phase": 0 - }, - "MZ": { - "duration": 22400, - "amplitude": 0.056500000000000015, - "frequency": 7393428047.0, - "shape": "Rectangular()", - "type": "ro", - "start": 0, - "phase": -3.022547221302854 - } - } - }, - "two_qubit": { - "0-1": { - "CNOT": [ - { - "type": "virtual_z", - "phase": -3.141592653589793, - "qubit": 0 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 1 - }, - { - "duration": 160, - "amplitude": 0.11622814090041741, - "frequency": 5090167234.445013, - "shape": "Drag(4, -2.4030014266125312)", - "type": "qd", - "relative_start": 0, - "phase": 1.6155738267853115, - "qubit": 0 - }, - { - "duration": 160, - "amplitude": 0.11976666126366188, - "frequency": 5245306068.285917, - "shape": "Drag(4, 0.6889687213780946)", - "type": "qd", - "relative_start": 0, - "phase": 0.02175043021781017, - "qubit": 1 - }, - { - "duration": 1584, - "amplitude": 0.023676707660000004, - "frequency": 5090167234.445013, - "shape": "GaussianSquare(6.4, 1328)", - "type": "qd", - "relative_start": 160, - "phase": 0.16645972884560645, - "qubit": 0 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 1 - }, - { - "duration": 1584, - "amplitude": 0.14343084605450945, - "frequency": 5090167234.445013, - "shape": "GaussianSquare(6.4, 1328)", - "type": "qd", - "relative_start": 160, - "phase": -2.9352017171062608, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": 1.5707963267948966, - "qubit": 1 - }, - { - "duration": 160, - "amplitude": 0.24840043468596693, - "frequency": 5245306068.285917, - "shape": "Drag(4, 0.6571522139248822)", - "type": "qd", - "relative_start": 1744, - "phase": 0.0, - "qubit": 1 - }, - { - "duration": 1584, - "amplitude": 0.023676707660000004, - "frequency": 5090167234.445013, - "shape": "GaussianSquare(6.4, 1328)", - "type": "qd", - "relative_start": 1904, - "phase": -2.975132924744187, - "qubit": 0 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 1 - }, - { - "duration": 1584, - "amplitude": 0.14343084605450945, - "frequency": 5090167234.445013, - "shape": "GaussianSquare(6.4, 1328)", - "type": "qd", - "relative_start": 1904, - "phase": 0.20639093648353235, - "qubit": 1 - }, - { - "type": "virtual_z", - "phase": -1.5707963267948966, - "qubit": 0 - }, - { - "type": "virtual_z", - "phase": 1.5707963267948966, - "qubit": 1 - }, - { - "duration": 160, - "amplitude": 0.11622814090041741, - "frequency": 5090167234.445013, - "shape": "Drag(4, -2.4030014266125312)", - "type": "qd", - "relative_start": 3488, - "phase": 0.04477749999041481, - "qubit": 0 - }, - { - "duration": 160, - "amplitude": 0.11976666126366188, - "frequency": 5245306068.285917, - "shape": "Drag(4, 0.6889687213780946)", - "type": "qd", - "relative_start": 3488, - "phase": -1.549045896577087, - "qubit": 1 - } - ] - } - } - }, - "characterization": { - "single_qubit": { - "0": { - "readout_frequency": 7301661824.000001, - "drive_frequency": 5090167234.445013, - "anharmonicity": -336123005.1821652, - "Ec": 0, - "Ej": 0, - "g": 0, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0, - "mean_gnd_states": "1.5417+0.1817j", - "mean_exc_states": "2.5332-0.5914j", - "threshold": 1.5435, - "iq_angle": 2.602 - }, - "1": { - "readout_frequency": 7393428047.0, - "drive_frequency": 5245306068.285917, - "anharmonicity": -316572131.412737, - "Ec": 0, - "Ej": 0, - "g": 0, - "T1": 0.0, - "T2": 0.0, - "sweetspot": 0, - "mean_gnd_states": "(0+0j)", - "mean_exc_states": "(0+0j)" - } - } - } -} diff --git a/tests/emulators/ibmfakebelem_q01/platform.py b/tests/emulators/ibmfakebelem_q01/platform.py deleted file mode 100644 index 136350a805..0000000000 --- a/tests/emulators/ibmfakebelem_q01/platform.py +++ /dev/null @@ -1,52 +0,0 @@ -import pathlib - -from qibolab.channels import ChannelMap -from qibolab.instruments.emulator.pulse_simulator import PulseSimulator -from qibolab.platform import Platform -from qibolab.serialize import ( - load_instrument_settings, - load_qubits, - load_runcard, - load_settings, -) - -FOLDER = pathlib.Path(__file__).parent - - -def create(): - """Create a one qubit emulator platform.""" - - # load runcard and model params - runcard = load_runcard(FOLDER) - device_name = runcard["device_name"] - - # Specify emulator controller - pulse_simulator = PulseSimulator() - instruments = {"pulse_simulator": pulse_simulator} - instruments = load_instrument_settings(runcard, instruments) - - # extract quantities from runcard for platform declaration - qubits, couplers, pairs = load_qubits(runcard) - settings = load_settings(runcard) - - # Create channel object - channels = ChannelMap() - channels |= (f"readout-{q}" for q in qubits) - channels |= (f"drive-{q}" for q in qubits) - - # map channels to qubits - for q, qubit in qubits.items(): - qubit.readout = channels[f"readout-{q}"] - qubit.drive = channels[f"drive-{q}"] - - channels[f"drive-{q}"].qubit = qubit - qubit.sweetspot = 0 # not used - - return Platform( - device_name, - qubits, - pairs, - instruments, - settings, - resonator_type="2D", - ) diff --git a/tests/test_instruments_qblox_port.py b/tests/instruments/__init__.py similarity index 100% rename from tests/test_instruments_qblox_port.py rename to tests/instruments/__init__.py diff --git a/tests/instruments/conftest.py b/tests/instruments/conftest.py new file mode 100644 index 0000000000..a997390287 --- /dev/null +++ b/tests/instruments/conftest.py @@ -0,0 +1,21 @@ +import pytest + + +def find_instrument(platform, instrument_type): + for instrument in platform.instruments.values(): + if isinstance(instrument, instrument_type): + return instrument + return None + + +def get_instrument(platform, instrument_type): + """Finds if an instrument of a given type exists in the given platform. + + If the platform does not have such an instrument, the corresponding + test that asked for this instrument is skipped. This ensures that + QPU tests are executed only on the available instruments. + """ + instrument = find_instrument(platform, instrument_type) + if instrument is None: + pytest.skip(f"Skipping {instrument_type.__name__} test for {platform.name}.") + return instrument diff --git a/tests/test_instruments_bluefors.py b/tests/instruments/test_bluefors.py similarity index 74% rename from tests/test_instruments_bluefors.py rename to tests/instruments/test_bluefors.py index 84975b0cdf..75154568bd 100644 --- a/tests/test_instruments_bluefors.py +++ b/tests/instruments/test_bluefors.py @@ -3,7 +3,7 @@ import pytest import yaml -from qibolab.instruments.bluefors import TemperatureController +from qibolab._core.instruments.bluefors import TemperatureController messages = [ "4K-flange: {'temperature':3.065067, 'timestamp':1710912431.128234}", @@ -14,24 +14,21 @@ def test_connect(): with mock.patch("socket.socket"): - tc = TemperatureController("Test_Temperature_Controller", "") - assert tc.is_connected is False + tc = TemperatureController(name="Test_Temperature_Controller", address="") # if already connected, it should stay connected for _ in range(2): tc.connect() - assert tc.is_connected is True @pytest.mark.parametrize("already_connected", [True, False]) def test_disconnect(already_connected): with mock.patch("socket.socket"): - tc = TemperatureController("Test_Temperature_Controller", "") + tc = TemperatureController(name="Test_Temperature_Controller", address="") if not already_connected: tc.connect() # if already disconnected, it should stay disconnected for _ in range(2): tc.disconnect() - assert tc.is_connected is False def test_continuously_read_data(): @@ -39,7 +36,7 @@ def test_continuously_read_data(): "qibolab.instruments.bluefors.TemperatureController.get_data", new=lambda _: yaml.safe_load(messages[0]), ): - tc = TemperatureController("Test_Temperature_Controller", "") + tc = TemperatureController(name="Test_Temperature_Controller", address="") read_temperatures = tc.read_data() for read_temperature in read_temperatures: assert read_temperature == yaml.safe_load(messages[0]) diff --git a/tests/test_instruments_erasynth.py b/tests/instruments/test_erasynth.py similarity index 75% rename from tests/test_instruments_erasynth.py rename to tests/instruments/test_erasynth.py index 1aacd04ddf..78e097e8ab 100644 --- a/tests/test_instruments_erasynth.py +++ b/tests/instruments/test_erasynth.py @@ -1,18 +1,18 @@ import pytest -from qibolab.instruments.erasynth import ERA +from qibolab._core.instruments.erasynth import ERASynth from .conftest import get_instrument @pytest.fixture(scope="module") def era(connected_platform): - return get_instrument(connected_platform, ERA) + return get_instrument(connected_platform, ERASynth) @pytest.mark.qpu def test_instruments_erasynth_connect(era): - assert era.is_connected == True + assert instrument.device is not None @pytest.mark.qpu diff --git a/tests/test_instruments_oscillator.py b/tests/instruments/test_oscillator.py similarity index 76% rename from tests/test_instruments_oscillator.py rename to tests/instruments/test_oscillator.py index 56a92deacf..6f4d36cdd6 100644 --- a/tests/test_instruments_oscillator.py +++ b/tests/instruments/test_oscillator.py @@ -1,11 +1,11 @@ import pytest -from qibolab.instruments.dummy import DummyDevice, DummyLocalOscillator +from qibolab._core.instruments.dummy import DummyDevice, DummyLocalOscillator @pytest.fixture def lo(): - return DummyLocalOscillator("lo", "0") + return DummyLocalOscillator(name="lo", address="0") def test_oscillator_init(lo): @@ -18,10 +18,9 @@ def test_oscillator_init(lo): def test_oscillator_connect(lo): assert lo.device is None lo.connect() - assert lo.is_connected assert isinstance(lo.device, DummyDevice) lo.disconnect() - assert not lo.is_connected + assert lo.device is None def test_oscillator_setup(lo): diff --git a/tests/test_instruments_rohde_schwarz.py b/tests/instruments/test_rohde_schwarz.py similarity index 94% rename from tests/test_instruments_rohde_schwarz.py rename to tests/instruments/test_rohde_schwarz.py index 5c156d28eb..f6d73d1d13 100644 --- a/tests/test_instruments_rohde_schwarz.py +++ b/tests/instruments/test_rohde_schwarz.py @@ -1,7 +1,7 @@ import numpy as np import pytest -from qibolab.instruments.rohde_schwarz import SGS100A +from qibolab._core.instruments.rohde_schwarz import SGS100A from .conftest import get_instrument @@ -13,8 +13,7 @@ def instrument(connected_platform): @pytest.mark.qpu def test_instruments_rohde_schwarz_init(instrument): - assert instrument.is_connected - assert instrument.device + assert instrument.device is not None @pytest.mark.qpu diff --git a/tests/test_instruments_qblox_q1asm.py b/tests/integration/__init__.py similarity index 100% rename from tests/test_instruments_qblox_q1asm.py rename to tests/integration/__init__.py diff --git a/tests/integration/test_sequence.py b/tests/integration/test_sequence.py new file mode 100644 index 0000000000..6f216f1259 --- /dev/null +++ b/tests/integration/test_sequence.py @@ -0,0 +1,38 @@ +from qibolab import create_platform +from qibolab._core.pulses import Delay + + +def test_sequence_creation(): + platform = create_platform("dummy") + + single = platform.natives.single_qubit + two = platform.natives.two_qubit + + # How a complex sequence is supposed to be constructed + # ---------------------------------------------------- + + p02 = two[(0, 2)] + p12 = two[(1, 2)] + q0 = single[0] + q1 = single[1] + q2 = single[2] + ch1 = platform.qubits[1] + + seq = ( + q1.RX() + | p12.CZ() + | [(ch1.drive, Delay(duration=6.5))] + | q2.RX() + | q0.RX12() + | p02.CZ() + ) + for q in range(3): + seq |= single[q].MZ() + + # ---------------------------------------------------- + + nshots = 17 + res = platform.execute([seq], nshots=nshots) + + for r in res.values(): + assert r.shape == (nshots,) diff --git a/tests/test_instruments_qblox_sequencer.py b/tests/pulses/__init__.py similarity index 100% rename from tests/test_instruments_qblox_sequencer.py rename to tests/pulses/__init__.py diff --git a/tests/pulses/test_envelope.py b/tests/pulses/test_envelope.py new file mode 100644 index 0000000000..c4b777de92 --- /dev/null +++ b/tests/pulses/test_envelope.py @@ -0,0 +1,218 @@ +import numpy as np +import pytest + +from qibolab._core.pulses import ( + Drag, + ECap, + Gaussian, + GaussianSquare, + Iir, + Pulse, + Rectangular, + Snz, +) + + +@pytest.mark.parametrize( + "shape", + [ + Rectangular(), + Gaussian(rel_sigma=5), + GaussianSquare(rel_sigma=5, width=0.9), + Drag(rel_sigma=5, beta=1), + ], +) +def test_sampling_rate(shape): + pulse = Pulse( + duration=40, + amplitude=0.9, + envelope=shape, + relative_phase=0, + ) + assert len(pulse.i(sampling_rate=1)) == 40 + assert len(pulse.i(sampling_rate=100)) == 4000 + + +def test_drag_shape(): + pulse = Pulse( + duration=2, + amplitude=1, + envelope=Drag(rel_sigma=0.5, beta=1), + relative_phase=0, + ) + # envelope i & envelope q should cross nearly at 0 and at 2 + waveform = pulse.i(sampling_rate=10) + target_waveform = np.array( + [ + 0.63683161, + 0.69680478, + 0.7548396, + 0.80957165, + 0.85963276, + 0.90370708, + 0.94058806, + 0.96923323, + 0.98881304, + 0.99875078, + 0.99875078, + 0.98881304, + 0.96923323, + 0.94058806, + 0.90370708, + 0.85963276, + 0.80957165, + 0.7548396, + 0.69680478, + 0.63683161, + ] + ) + np.testing.assert_allclose(waveform, target_waveform) + + +def test_rectangular(): + pulse = Pulse( + duration=50, + amplitude=1, + relative_phase=0, + envelope=Rectangular(), + ) + + assert pulse.duration == 50 + assert isinstance(pulse.envelope, Rectangular) + + sampling_rate = 1 + num_samples = int(pulse.duration / sampling_rate) + i, q = ( + pulse.amplitude * np.ones(num_samples), + pulse.amplitude * np.zeros(num_samples), + ) + + np.testing.assert_allclose(pulse.i(sampling_rate), i) + np.testing.assert_allclose(pulse.q(sampling_rate), q) + + +def test_gaussian(): + pulse = Pulse( + duration=50, + amplitude=1, + relative_phase=0, + envelope=Gaussian(rel_sigma=5), + ) + + assert pulse.duration == 50 + assert isinstance(pulse.envelope, Gaussian) + assert pulse.envelope.rel_sigma == 5 + + sampling_rate = 1 + num_samples = int(pulse.duration / sampling_rate) + x = np.arange(0, num_samples, 1) + i = pulse.amplitude * np.exp( + -( + ((x - (num_samples - 1) / 2) ** 2) + / (2 * (num_samples * pulse.envelope.rel_sigma) ** 2) + ) + ) + q = pulse.amplitude * np.zeros(num_samples) + + np.testing.assert_allclose(pulse.i(sampling_rate), i) + np.testing.assert_allclose(pulse.q(sampling_rate), q) + + +def test_drag(): + pulse = Pulse( + duration=50, + amplitude=1, + relative_phase=0, + envelope=Drag(rel_sigma=0.2, beta=0.2), + ) + + assert pulse.duration == 50 + assert isinstance(pulse.envelope, Drag) + assert pulse.envelope.rel_sigma == 0.2 + assert pulse.envelope.beta == 0.2 + + sampling_rate = 1 + num_samples = int(pulse.duration / sampling_rate) + x = np.arange(num_samples) + i = pulse.amplitude * np.exp( + -( + ((x - (num_samples - 1) / 2) ** 2) + / (2 * (num_samples * pulse.envelope.rel_sigma) ** 2) + ) + ) + q = pulse.amplitude * ( + pulse.envelope.beta + * ( + -(x - (num_samples - 1) / 2) + / ((num_samples * pulse.envelope.rel_sigma) ** 2) + ) + * i + * sampling_rate + ) + + np.testing.assert_allclose(pulse.i(sampling_rate), i) + np.testing.assert_allclose(pulse.q(sampling_rate), q) + + +def test_eq(): + """Checks == operator for pulse shapes.""" + + shape1 = Rectangular() + shape2 = Rectangular() + shape3 = Gaussian(rel_sigma=5) + assert shape1 == shape2 + assert not shape1 == shape3 + + shape1 = Gaussian(rel_sigma=4) + shape2 = Gaussian(rel_sigma=4) + shape3 = Gaussian(rel_sigma=5) + assert shape1 == shape2 + assert not shape1 == shape3 + + shape1 = GaussianSquare(rel_sigma=4, width=0.01) + shape2 = GaussianSquare(rel_sigma=4, width=0.01) + shape3 = GaussianSquare(rel_sigma=5, width=0.01) + shape4 = GaussianSquare(rel_sigma=4, width=0.05) + shape5 = GaussianSquare(rel_sigma=5, width=0.05) + assert shape1 == shape2 + assert not shape1 == shape3 + assert not shape1 == shape4 + assert not shape1 == shape5 + + shape1 = Drag(rel_sigma=4, beta=0.01) + shape2 = Drag(rel_sigma=4, beta=0.01) + shape3 = Drag(rel_sigma=5, beta=0.01) + shape4 = Drag(rel_sigma=4, beta=0.05) + shape5 = Drag(rel_sigma=5, beta=0.05) + assert shape1 == shape2 + assert not shape1 == shape3 + assert not shape1 == shape4 + assert not shape1 == shape5 + + shape1 = Iir(a=np.array([-0.5, 2]), b=np.array([1]), target=Rectangular()) + shape2 = Iir(a=np.array([-0.5, 2]), b=np.array([1]), target=Rectangular()) + shape3 = Iir(a=np.array([-0.5, 4]), b=np.array([1]), target=Rectangular()) + shape4 = Iir(a=np.array([-0.4, 2]), b=np.array([1]), target=Rectangular()) + shape5 = Iir(a=np.array([-0.5, 2]), b=np.array([2]), target=Rectangular()) + shape6 = Iir(a=np.array([-0.5, 2]), b=np.array([2]), target=Gaussian(rel_sigma=5)) + assert shape1 == shape2 + assert not shape1 == shape3 + assert not shape1 == shape4 + assert not shape1 == shape5 + assert not shape1 == shape6 + + shape1 = Snz(t_idling=5) + shape2 = Snz(t_idling=5) + shape3 = Snz(t_idling=2) + shape4 = Snz(t_idling=2, b_amplitude=0.1) + shape5 = Snz(t_idling=2, b_amplitude=0.1) + assert shape1 == shape2 + assert not shape1 == shape3 + assert not shape1 == shape4 + assert not shape1 == shape5 + + shape1 = ECap(alpha=4) + shape2 = ECap(alpha=4) + shape3 = ECap(alpha=5) + assert shape1 == shape2 + assert not shape1 == shape3 diff --git a/tests/pulses/test_modulation.py b/tests/pulses/test_modulation.py new file mode 100644 index 0000000000..fcefc72cfb --- /dev/null +++ b/tests/pulses/test_modulation.py @@ -0,0 +1,72 @@ +import numpy as np + +from qibolab._core.pulses import Gaussian, IqWaveform, Rectangular +from qibolab._core.pulses.modulation import demodulate, modulate + + +def test_modulation(): + amplitude = 0.9 + renvs: IqWaveform = Rectangular().envelopes(30) * amplitude + # fmt: off + np.testing.assert_allclose(modulate(renvs, 0.04, rate=1), + np.array([[ 6.36396103e-01, 6.16402549e-01, 5.57678156e-01, + 4.63912794e-01, 3.40998084e-01, 1.96657211e-01, + 3.99596419e-02, -1.19248738e-01, -2.70964282e-01, + -4.05654143e-01, -5.14855263e-01, -5.91706132e-01, + -6.31377930e-01, -6.31377930e-01, -5.91706132e-01, + -5.14855263e-01, -4.05654143e-01, -2.70964282e-01, + -1.19248738e-01, 3.99596419e-02, 1.96657211e-01, + 3.40998084e-01, 4.63912794e-01, 5.57678156e-01, + 6.16402549e-01, 6.36396103e-01, 6.16402549e-01, + 5.57678156e-01, 4.63912794e-01, 3.40998084e-01], + [ 0.00000000e+00, 1.58265275e-01, 3.06586161e-01, + 4.35643111e-01, 5.37327002e-01, 6.05248661e-01, + 6.35140321e-01, 6.25123778e-01, 5.75828410e-01, + 4.90351625e-01, 3.74064244e-01, 2.34273031e-01, + 7.97615814e-02, -7.97615814e-02, -2.34273031e-01, + -3.74064244e-01, -4.90351625e-01, -5.75828410e-01, + -6.25123778e-01, -6.35140321e-01, -6.05248661e-01, + -5.37327002e-01, -4.35643111e-01, -3.06586161e-01, + -1.58265275e-01, 4.09361195e-16, 1.58265275e-01, + 3.06586161e-01, 4.35643111e-01, 5.37327002e-01]]) + ) + # fmt: on + + genvs: IqWaveform = Gaussian(rel_sigma=0.5).envelopes(20) + # fmt: off + np.testing.assert_allclose(modulate(genvs, 0.3,rate=1), + np.array([[ 4.50307953e-01, -1.52257426e-01, -4.31814602e-01, + 4.63124693e-01, 1.87836646e-01, -6.39017403e-01, + 2.05526028e-01, 5.54460924e-01, -5.65661777e-01, + -2.18235048e-01, 7.06223450e-01, -2.16063573e-01, + -5.54460924e-01, 5.38074127e-01, 1.97467237e-01, + -6.07852156e-01, 1.76897892e-01, 4.31814602e-01, + -3.98615117e-01, -1.39152810e-01], + [ 0.00000000e+00, 4.68600175e-01, -3.13731672e-01, + -3.36479785e-01, 5.78101754e-01, 2.34771185e-16, + -6.32544073e-01, 4.02839441e-01, 4.10977338e-01, + -6.71658414e-01, -5.18924572e-16, 6.64975301e-01, + -4.02839441e-01, -3.90933736e-01, 6.07741665e-01, + 6.69963778e-16, -5.44435729e-01, 3.13731672e-01, + 2.89610835e-01, -4.28268313e-01]]) + ) + # fmt: on + + +def test_demodulation(): + signal = np.ones((2, 100)) + freq = 0.15 + rate = 1 + mod = modulate(signal, freq, rate) + + demod = demodulate(mod, freq, rate) + np.testing.assert_allclose(demod, signal) + + mod1 = modulate(demod, freq * 3.0, rate=3.0) + np.testing.assert_allclose(mod1, mod) + + mod2 = modulate(signal, freq, rate, phase=2 * np.pi) + np.testing.assert_allclose(mod2, mod) + + demod1 = demodulate(mod + np.ones_like(mod), freq, rate) + np.testing.assert_allclose(demod1, demod) diff --git a/tests/pulses/test_plot.py b/tests/pulses/test_plot.py new file mode 100644 index 0000000000..83309a704c --- /dev/null +++ b/tests/pulses/test_plot.py @@ -0,0 +1,91 @@ +import os +import pathlib + +import numpy as np + +from qibolab._core.pulses import ( + Drag, + ECap, + Gaussian, + GaussianSquare, + Iir, + Pulse, + Rectangular, + Snz, + plot, +) +from qibolab._core.pulses.modulation import modulate +from qibolab._core.sequence import PulseSequence + +HERE = pathlib.Path(__file__).parent +SAMPLING_RATE = 1 + + +def test_plot_functions(): + p0 = Pulse( + duration=40, + amplitude=0.9, + envelope=Rectangular(), + relative_phase=0, + ) + p1 = Pulse( + duration=40, + amplitude=0.9, + envelope=Gaussian(rel_sigma=0.2), + relative_phase=0, + ) + p2 = Pulse( + duration=40, + amplitude=0.9, + envelope=Drag(rel_sigma=0.2, beta=2), + relative_phase=0, + ) + p3 = Pulse( + duration=40, + amplitude=0.9, + envelope=Iir(a=np.array([-0.5, 2]), b=np.array([1]), target=Rectangular()), + ) + p4 = Pulse(duration=40, amplitude=0.9, envelope=Snz(t_idling=10)) + p5 = Pulse( + duration=40, + amplitude=0.9, + envelope=ECap(alpha=2), + relative_phase=0, + ) + p6 = Pulse( + duration=40, + amplitude=0.9, + envelope=GaussianSquare(rel_sigma=0.2, width=0.9), + relative_phase=0, + ) + ps = PulseSequence( + [ + ("q0/flux", p0), + ("q2/drive", p1), + ("q200/drive", p2), + ("q200/flux", p3), + ("q200/flux", p4), + ("q0/drive", p5), + ("q2/drive", p6), + ] + ) + envelope = p0.envelopes(SAMPLING_RATE) + wf = modulate(np.array(envelope), 0.0, rate=SAMPLING_RATE) + + plot_file = HERE / "test_plot.png" + + plot.waveform(wf, filename=plot_file) + assert os.path.exists(plot_file) + os.remove(plot_file) + + plot.pulse(p0, filename=plot_file) + assert os.path.exists(plot_file) + os.remove(plot_file) + + plot.pulse(p0, freq=2e9, filename=plot_file) + assert os.path.exists(plot_file) + os.remove(plot_file) + + plot.sequence(ps, {"q200/drive": 3e9}, filename=plot_file) + assert os.path.exists(plot_file) + os.remove(plot_file) diff --git a/tests/pulses/test_pulse.py b/tests/pulses/test_pulse.py new file mode 100644 index 0000000000..b4957ebc85 --- /dev/null +++ b/tests/pulses/test_pulse.py @@ -0,0 +1,40 @@ +"""Tests ``pulses.py``.""" + +import numpy as np +from pytest import approx, raises + +from qibolab._core.pulses import Acquisition, Custom, Pulse, Rectangular, VirtualZ +from qibolab._core.pulses.pulse import Readout + + +def test_virtual_z(): + vz = VirtualZ(phase=-0.3) + assert vz.duration == 0 + + +def test_readout(): + p = Pulse(duration=5, amplitude=0.9, envelope=Rectangular()) + a = Acquisition(duration=60) + r = Readout(acquisition=a, probe=p) + assert r.duration == a.duration + assert r.id == a.id + + +def test_envelope_waveform_i_q(): + d = 1000 + p = Pulse(duration=d, amplitude=1, envelope=Rectangular()) + assert approx(p.i(1)) == np.ones(d) + assert approx(p.i(2)) == np.ones(2 * d) + assert approx(p.q(1)) == np.zeros(d) + assert approx(p.envelopes(1)) == np.stack([np.ones(d), np.zeros(d)]) + + envelope_i = np.cos(np.arange(0, 10, 0.01)) + envelope_q = np.sin(np.arange(0, 10, 0.01)) + custom_shape_pulse = Custom(i_=envelope_i, q_=envelope_q) + pulse = Pulse(duration=1000, amplitude=1, relative_phase=0, envelope=Rectangular()) + + custom_shape_pulse = custom_shape_pulse.model_copy(update={"i_": pulse.i(1)}) + with raises(ValueError): + custom_shape_pulse.i(samples=10) + with raises(ValueError): + custom_shape_pulse.q(samples=10) diff --git a/tests/qblox_fixtures.py b/tests/qblox_fixtures.py deleted file mode 100644 index 98c6dcd934..0000000000 --- a/tests/qblox_fixtures.py +++ /dev/null @@ -1,20 +0,0 @@ -import pytest - -from qibolab.instruments.qblox.controller import QbloxController - - -def get_controller(platform): - for instrument in platform.instruments.values(): - if isinstance(instrument, QbloxController): - return instrument - pytest.skip(f"Skipping qblox test for {platform.name}.") - - -@pytest.fixture(scope="module") -def controller(platform): - return get_controller(platform) - - -@pytest.fixture(scope="module") -def connected_controller(connected_platform): - return get_controller(connected_platform) diff --git a/tests/test_backends.py b/tests/test_backends.py index 886d1a5bdc..0165efba90 100644 --- a/tests/test_backends.py +++ b/tests/test_backends.py @@ -8,7 +8,8 @@ from qibo.models import Circuit from qibolab import MetaBackend, create_platform -from qibolab.backends import QibolabBackend +from qibolab._core.backends import QibolabBackend +from qibolab._core.platform.platform import Platform def generate_circuit_with_gate(nqubits, gate, **kwargs): @@ -43,7 +44,6 @@ def test_execute_circuit_initial_state(): (gates.Z, {}), (gates.GPI, {"phi": np.pi / 8}), (gates.GPI2, {"phi": np.pi / 8}), - (gates.U3, {"theta": 0.1, "phi": 0.2, "lam": 0.3}), ], ) def test_execute_circuit(gate, kwargs): @@ -107,12 +107,21 @@ def test_multiple_measurements(): def dummy_string_qubit_names(): """Create dummy platform with string-named qubits.""" platform = create_platform("dummy") - for q, qubit in platform.qubits.items(): - qubit.name = f"A{q}" - platform.qubits = {qubit.name: qubit for qubit in platform.qubits.values()} - platform.pairs = { - (f"A{q0}", f"A{q1}"): pair for (q0, q1), pair in platform.pairs.items() - } + for q, qubit in platform.qubits.copy().items(): + name = f"A{q}" + platform.qubits[name] = qubit + del platform.qubits[q] + platform.natives.single_qubit[name] = platform.natives.single_qubit[q] + del platform.natives.single_qubit[q] + for q0, q1 in platform.pairs: + name = (f"A{q0}", f"A{q1}") + try: + platform.natives.two_qubit[name] = platform.natives.two_qubit[(q0, q1)] + del platform.natives.two_qubit[(q0, q1)] + except KeyError: + # the symmetrized pair is only present in pairs, not in the natives + pass + return platform @@ -132,7 +141,7 @@ def test_execute_circuit_str_qubit_names(): @pytest.mark.xfail( raises=AssertionError, reason="Probabilities are not well calibrated" ) -def test_ground_state_probabilities_circuit(connected_backend): +def test_ground_state_probabilities_circuit(connected_backend: QibolabBackend): nshots = 5000 nqubits = connected_backend.platform.nqubits circuit = Circuit(nqubits) @@ -150,7 +159,7 @@ def test_ground_state_probabilities_circuit(connected_backend): @pytest.mark.xfail( raises=AssertionError, reason="Probabilities are not well calibrated" ) -def test_excited_state_probabilities_circuit(connected_backend): +def test_excited_state_probabilities_circuit(connected_backend: QibolabBackend): nshots = 5000 nqubits = connected_backend.platform.nqubits circuit = Circuit(nqubits) @@ -169,7 +178,7 @@ def test_excited_state_probabilities_circuit(connected_backend): @pytest.mark.xfail( raises=AssertionError, reason="Probabilities are not well calibrated" ) -def test_superposition_for_all_qubits(connected_backend): +def test_superposition_for_all_qubits(connected_backend: QibolabBackend): """Applies an H gate to each qubit of the circuit and measures the probabilities.""" nshots = 5000 @@ -196,21 +205,20 @@ def test_superposition_for_all_qubits(connected_backend): # TODO: test_circuit_result_representation -def test_metabackend_load(dummy_qrc): - for platform in Path("tests/dummy_qrc/").iterdir(): - backend = MetaBackend.load(platform.name) - assert isinstance(backend, QibolabBackend) - assert Path(backend.platform.name).name == platform.name +def test_metabackend_load(platform: Platform): + backend = MetaBackend.load(platform.name) + assert isinstance(backend, QibolabBackend) + assert backend.platform.name == platform.name -def test_metabackend_list_available(tmpdir): +def test_metabackend_list_available(tmp_path: Path): for platform in ( "valid_platform/platform.py", "invalid_platform/invalid_platform.py", ): - path = Path(tmpdir / platform) + path = tmp_path / platform path.parent.mkdir(parents=True, exist_ok=True) path.touch() - os.environ["QIBOLAB_PLATFORMS"] = str(tmpdir) + os.environ["QIBOLAB_PLATFORMS"] = str(tmp_path) available_platforms = {"valid_platform": True} assert MetaBackend().list_available() == available_platforms diff --git a/tests/test_channels.py b/tests/test_channels.py deleted file mode 100644 index ea16b14371..0000000000 --- a/tests/test_channels.py +++ /dev/null @@ -1,90 +0,0 @@ -import pytest - -from qibolab.channels import Channel, ChannelMap -from qibolab.instruments.dummy import DummyPort - - -def test_channel_init(): - channel = Channel("L1-test") - assert channel.name == "L1-test" - - -def test_channel_errors(): - channel = Channel("L1-test", port=DummyPort("test")) - channel.offset = 0.1 - channel.filter = {} - # attempt to set bias higher than the allowed value - channel.max_offset = 0.2 - with pytest.raises(ValueError): - channel.offset = 0.3 - - -def test_channel_map_add(): - channels = ChannelMap().add("a", "b") - assert "a" in channels - assert "b" in channels - assert isinstance(channels["a"], Channel) - assert isinstance(channels["b"], Channel) - assert channels["a"].name == "a" - assert channels["b"].name == "b" - - -def test_channel_map_setitem(): - channels = ChannelMap() - with pytest.raises(TypeError): - channels["c"] = "test" - channels["c"] = Channel("c") - assert isinstance(channels["c"], Channel) - - -def test_channel_map_union(): - channels1 = ChannelMap().add("a", "b") - channels2 = ChannelMap().add("c", "d") - channels = channels1 | channels2 - for name in ["a", "b", "c", "d"]: - assert name in channels - assert isinstance(channels[name], Channel) - assert channels[name].name == name - assert "a" not in channels2 - assert "b" not in channels2 - assert "c" not in channels1 - assert "d" not in channels1 - - -def test_channel_map_union_update(): - channels = ChannelMap().add("a", "b") - channels |= ChannelMap().add("c", "d") - for name in ["a", "b", "c", "d"]: - assert name in channels - assert isinstance(channels[name], Channel) - assert channels[name].name == name - - -@pytest.fixture -def first_qubit(platform): - return next(iter(platform.qubits.values())) - - -def test_platform_lo_drive_frequency(first_qubit): - first_qubit.drive.lo_frequency = 5.5e9 - assert first_qubit.drive.lo_frequency == 5.5e9 - - -def test_platform_lo_readout_frequency(first_qubit): - first_qubit.readout.lo_frequency = 7e9 - assert first_qubit.readout.lo_frequency == 7e9 - - -def test_platform_attenuation(first_qubit): - first_qubit.drive.attenuation = 10 - assert first_qubit.drive.attenuation == 10 - - -def test_platform_gain(first_qubit): - first_qubit.readout.gain = 0 - assert first_qubit.readout.gain == 0 - - -def test_platform_bias(first_qubit): - first_qubit.flux.offset = 0.05 - assert first_qubit.flux.offset == 0.05 diff --git a/tests/test_compilers_default.py b/tests/test_compilers_default.py index a1a85c3667..9332f57998 100644 --- a/tests/test_compilers_default.py +++ b/tests/test_compilers_default.py @@ -5,11 +5,16 @@ from qibo.models import Circuit from qibolab import create_platform -from qibolab.compilers import Compiler -from qibolab.pulses import PulseSequence +from qibolab._core.compilers import Compiler +from qibolab._core.identifier import ChannelId +from qibolab._core.native import Native, TwoQubitNatives +from qibolab._core.platform import Platform +from qibolab._core.pulses import Delay, Pulse +from qibolab._core.pulses.envelope import Rectangular +from qibolab._core.sequence import PulseSequence -def generate_circuit_with_gate(nqubits, gate, *params, **kwargs): +def generate_circuit_with_gate(nqubits: int, gate, *params, **kwargs): circuit = Circuit(nqubits) circuit.add(gate(q, *params, **kwargs) for q in range(nqubits)) circuit.add(gates.M(*range(nqubits))) @@ -29,11 +34,10 @@ def test_u3_sim_agreement(): np.testing.assert_allclose(u3_matrix, target_matrix) -def compile_circuit(circuit, platform): +def compile_circuit(circuit: Circuit, platform: Platform) -> PulseSequence: """Compile a circuit to a pulse sequence.""" compiler = Compiler.default() - sequence, _ = compiler.compile(circuit, platform) - return sequence + return compiler.compile(circuit, platform)[0] @pytest.mark.parametrize( @@ -44,185 +48,251 @@ def compile_circuit(circuit, platform): (gates.GPI, np.pi / 8), (gates.GPI2, -np.pi / 8), (gates.RZ, np.pi / 4), - (gates.U3, 0.1, 0.2, 0.3), ], ) -def test_compile(platform, gateargs): +def test_compile(platform: Platform, gateargs): nqubits = platform.nqubits - if gateargs[0] is gates.U3: - nseq = 2 - elif gateargs[0] in (gates.GPI, gates.GPI2): - nseq = 1 - else: - nseq = 0 circuit = generate_circuit_with_gate(nqubits, *gateargs) sequence = compile_circuit(circuit, platform) - assert len(sequence) == (nseq + 1) * nqubits + assert len(sequence.channels) == nqubits * int(gateargs[0] != gates.I) + nqubits * 1 -def test_compile_two_gates(platform): +def test_compile_two_gates(platform: Platform): circuit = Circuit(1) circuit.add(gates.GPI2(0, phi=0.1)) - circuit.add(gates.U3(0, theta=0.1, phi=0.2, lam=0.3)) + circuit.add(gates.GPI(0, 0.2)) circuit.add(gates.M(0)) sequence = compile_circuit(circuit, platform) - assert len(sequence.pulses) == 4 - assert len(sequence.qd_pulses) == 3 - assert len(sequence.ro_pulses) == 1 + qubit = platform.qubits[0] + assert len(sequence.channels) == 2 + assert len(list(sequence.channel(qubit.drive))) == 2 + assert len(list(sequence.channel(qubit.acquisition))) == 2 # includes delay -def test_measurement(platform): +def test_measurement(platform: Platform): nqubits = platform.nqubits circuit = Circuit(nqubits) qubits = [qubit for qubit in range(nqubits)] circuit.add(gates.M(*qubits)) sequence = compile_circuit(circuit, platform) - assert len(sequence) == 1 * nqubits - assert len(sequence.qd_pulses) == 0 * nqubits - assert len(sequence.qf_pulses) == 0 * nqubits - assert len(sequence.ro_pulses) == 1 * nqubits + assert len(sequence.channels) == 1 * nqubits + assert len(sequence.acquisitions) == 1 * nqubits -def test_rz_to_sequence(platform): +def test_rz_to_sequence(platform: Platform): circuit = Circuit(1) circuit.add(gates.RZ(0, theta=0.2)) circuit.add(gates.Z(0)) sequence = compile_circuit(circuit, platform) - assert len(sequence) == 0 + assert len(sequence.channels) == 1 + assert len(sequence) == 2 + +def test_gpi_to_sequence(platform: Platform): + natives = platform.natives -def test_gpi_to_sequence(platform): circuit = Circuit(1) circuit.add(gates.GPI(0, phi=0.2)) sequence = compile_circuit(circuit, platform) - assert len(sequence.pulses) == 1 - assert len(sequence.qd_pulses) == 1 - - RX_pulse = platform.create_RX_pulse(0, start=0, relative_phase=0.2) - s = PulseSequence(RX_pulse) - - np.testing.assert_allclose(sequence.duration, RX_pulse.duration) - assert sequence.serial == s.serial + assert len(sequence.channels) == 1 + rx_seq = natives.single_qubit[0].R(phi=0.2) -def test_gpi2_to_sequence(platform): - circuit = Circuit(1) - circuit.add(gates.GPI2(0, phi=0.2)) - sequence = compile_circuit(circuit, platform) - assert len(sequence.pulses) == 1 - assert len(sequence.qd_pulses) == 1 + np.testing.assert_allclose(sequence.duration, rx_seq.duration) - RX90_pulse = platform.create_RX90_pulse(0, start=0, relative_phase=0.2) - s = PulseSequence(RX90_pulse) - np.testing.assert_allclose(sequence.duration, RX90_pulse.duration) - assert sequence.serial == s.serial +def test_gpi2_to_sequence(platform: Platform): + natives = platform.natives - -def test_u3_to_sequence(platform): circuit = Circuit(1) - circuit.add(gates.U3(0, 0.1, 0.2, 0.3)) - - sequence = compile_circuit(circuit, platform) - assert len(sequence.pulses) == 2 - assert len(sequence.qd_pulses) == 2 - - RX90_pulse1 = platform.create_RX90_pulse(0, start=0, relative_phase=0.3) - RX90_pulse2 = platform.create_RX90_pulse( - 0, start=RX90_pulse1.finish, relative_phase=0.4 - np.pi - ) - s = PulseSequence(RX90_pulse1, RX90_pulse2) - - np.testing.assert_allclose( - sequence.duration, RX90_pulse1.duration + RX90_pulse2.duration - ) - assert sequence.serial == s.serial - - -def test_two_u3_to_sequence(platform): - circuit = Circuit(1) - circuit.add(gates.U3(0, 0.1, 0.2, 0.3)) - circuit.add(gates.U3(0, 0.4, 0.6, 0.5)) - + circuit.add(gates.GPI2(0, phi=0.2)) sequence = compile_circuit(circuit, platform) - assert len(sequence.pulses) == 4 - assert len(sequence.qd_pulses) == 4 + assert len(sequence.channels) == 1 - RX90_pulse = platform.create_RX90_pulse(0) + rx90_seq = natives.single_qubit[0].R(theta=np.pi / 2, phi=0.2) - np.testing.assert_allclose(sequence.duration, 2 * 2 * RX90_pulse.duration) + np.testing.assert_allclose(sequence.duration, rx90_seq.duration) + assert sequence == rx90_seq - RX90_pulse1 = platform.create_RX90_pulse(0, start=0, relative_phase=0.3) - RX90_pulse2 = platform.create_RX90_pulse( - 0, start=RX90_pulse1.finish, relative_phase=0.4 - np.pi - ) - RX90_pulse3 = platform.create_RX90_pulse( - 0, start=RX90_pulse2.finish, relative_phase=1.1 - ) - RX90_pulse4 = platform.create_RX90_pulse( - 0, start=RX90_pulse3.finish, relative_phase=1.5 - np.pi - ) - s = PulseSequence(RX90_pulse1, RX90_pulse2, RX90_pulse3, RX90_pulse4) - assert sequence.serial == s.serial - -def test_cz_to_sequence(platform): - if (1, 2) not in platform.pairs: - pytest.skip( - f"Skipping CZ test for {platform} because pair (1, 2) is not available." - ) +def test_cz_to_sequence(): + platform = create_platform("dummy") + natives = platform.natives circuit = Circuit(3) circuit.add(gates.CZ(1, 2)) sequence = compile_circuit(circuit, platform) - test_sequence, virtual_z_phases = platform.create_CZ_pulse_sequence((2, 1)) + test_sequence = natives.two_qubit[(2, 1)].CZ.create_sequence() assert sequence == test_sequence def test_cnot_to_sequence(): platform = create_platform("dummy") + natives = platform.natives + circuit = Circuit(4) circuit.add(gates.CNOT(2, 3)) sequence = compile_circuit(circuit, platform) - test_sequence, virtual_z_phases = platform.create_CNOT_pulse_sequence((2, 3)) - assert len(sequence) == len(test_sequence) - assert sequence.pulses[0] == test_sequence.pulses[0] + test_sequence = natives.two_qubit[(2, 3)].CNOT.create_sequence() + assert sequence == test_sequence -def test_add_measurement_to_sequence(platform): +def test_add_measurement_to_sequence(platform: Platform): + natives = platform.natives + circuit = Circuit(1) - circuit.add(gates.U3(0, 0.1, 0.2, 0.3)) + circuit.add(gates.GPI2(0, 0.1)) + circuit.add(gates.GPI2(0, 0.2)) circuit.add(gates.M(0)) sequence = compile_circuit(circuit, platform) - assert len(sequence.pulses) == 3 - assert len(sequence.qd_pulses) == 2 - assert len(sequence.ro_pulses) == 1 + qubit = platform.qubits[0] + assert len(sequence.channels) == 2 + assert len(list(sequence.channel(qubit.drive))) == 2 + assert len(list(sequence.channel(qubit.acquisition))) == 2 # include delay - RX90_pulse1 = platform.create_RX90_pulse(0, start=0, relative_phase=0.3) - RX90_pulse2 = platform.create_RX90_pulse( - 0, start=RX90_pulse1.finish, relative_phase=0.4 - np.pi - ) - MZ_pulse = platform.create_MZ_pulse(0, start=RX90_pulse2.finish) - s = PulseSequence(RX90_pulse1, RX90_pulse2, MZ_pulse) - assert sequence.serial == s.serial + s = PulseSequence() + s.concatenate(natives.single_qubit[0].R(theta=np.pi / 2, phi=0.1)) + s.concatenate(natives.single_qubit[0].R(theta=np.pi / 2, phi=0.2)) + s.append((qubit.acquisition, Delay(duration=s.duration))) + s.concatenate(natives.single_qubit[0].MZ.create_sequence()) + + # the delay sorting depends on PulseSequence.channels, which is a set, and it's + # order is not guaranteed + def without_delays(seq: PulseSequence) -> PulseSequence: + return [el for el in seq if not isinstance(el[1], Delay)] + + def delays(seq: PulseSequence) -> set[tuple[ChannelId, Delay]]: + return {el for el in seq if isinstance(el[1], Delay)} + + assert without_delays(sequence) == without_delays(s) + assert delays(sequence) == delays(s) @pytest.mark.parametrize("delay", [0, 100]) -def test_align_delay_measurement(platform, delay): +def test_align_delay_measurement(platform: Platform, delay): + natives = platform.natives + circuit = Circuit(1) circuit.add(gates.Align(0, delay=delay)) circuit.add(gates.M(0)) + sequence = compile_circuit(circuit, platform) + + target_sequence = PulseSequence() + if delay > 0: + target_sequence.append((platform.qubits[0].acquisition, Delay(duration=delay))) + target_sequence.concatenate(natives.single_qubit[0].MZ.create_sequence()) + assert sequence == target_sequence + assert len(sequence.acquisitions) == 1 + + +def test_align_multiqubit(platform: Platform): + main, coupled = 0, 2 + circuit = Circuit(3) + circuit.add(gates.GPI2(main, phi=0.2)) + circuit.add(gates.CZ(main, coupled)) + circuit.add(gates.M(main, coupled)) sequence = compile_circuit(circuit, platform) - assert len(sequence.pulses) == 1 - assert len(sequence.ro_pulses) == 1 + qubits = platform.qubits + flux_duration = sequence.channel_duration(qubits[coupled].flux) + for q in (main, coupled): + probe_delay = next(iter(sequence.channel(qubits[q].acquisition))) + assert isinstance(probe_delay, Delay) + assert flux_duration == probe_delay.duration + + +@pytest.mark.parametrize("joint", [True, False]) +def test_inactive_qubits(platform: Platform, joint: bool): + main, coupled = 0, 1 + circuit = Circuit(2) + circuit.add(gates.CZ(main, coupled)) + # another gate on drive is needed, to prevent trimming the delay, if alone + circuit.add(gates.GPI2(coupled, phi=0.15)) + if joint: + circuit.add(gates.M(main, coupled)) + else: + circuit.add(gates.M(main)) + circuit.add(gates.M(coupled)) + + natives = platform.natives.two_qubit[(main, coupled)] = TwoQubitNatives( + CZ=Native([]) + ) + assert natives.CZ is not None + natives.CZ.clear() + sequence = compile_circuit(circuit, platform) + + qm = platform.qubit(main)[1] + qc = platform.qubit(coupled)[1] + readouts = {qm.probe, qm.acquisition, qc.probe, qc.acquisition} + + def no_measurement(seq: PulseSequence): + return [el for el in seq if el[0] not in readouts] + + assert len(no_measurement(sequence)) == 1 + + qubits = platform.qubits + mflux = qubits[main].flux + cdrive = qubits[coupled].drive + duration = 200 + natives.CZ.extend( + PulseSequence.load( + [ + ( + mflux, + Pulse(duration=duration, amplitude=0.42, envelope=Rectangular()), + ) + ] + ) + ) + padded_seq = compile_circuit(circuit, platform) + assert len(no_measurement(padded_seq)) == 3 + cdrive_delay = next(iter(padded_seq.channel(cdrive))) + assert isinstance(cdrive_delay, Delay) + assert cdrive_delay.duration == next(iter(padded_seq.channel(mflux))).duration + + +def test_joint_split_equivalence(platform: Platform): + """Test joint-split equivalence after 2q gate. - MZ_pulse = platform.create_MZ_pulse(0, start=delay) - s = PulseSequence(MZ_pulse) - assert sequence.serial == s.serial + Joint measurements are only equivalent to split in specific + circumstances. When the two qubits involved are just coming out of a + mutual interaction is one of those cases. + + Cf. + https://github.com/qiboteam/qibolab/pull/992#issuecomment-2302708439 + """ + circuit = Circuit(3) + circuit.add(gates.CZ(1, 2)) + circuit.add(gates.GPI2(2, phi=0.15)) + circuit.add(gates.CZ(0, 2)) + + joint = Circuit(3) + joint.add(gates.M(0, 2)) + + joint_seq = compile_circuit(circuit + joint, platform) + + split = Circuit(3) + split.add(gates.M(0)) + split.add(gates.M(2)) + + split_seq = compile_circuit(circuit + split, platform) + + # the inter-channel sorting is unreliable, and mostly irrelevant (unless align + # instructions are involved, which is not the case) + assert not any( + isinstance(p, gates.Align) for seq in (joint_seq, split_seq) for _, p in seq + ) # TODO: gates.Align is just a placeholder, replace with the pulse-like when available + qubits = platform.qubits + for ch in ( + qubits[0].acquisition, + qubits[2].acquisition, + qubits[0].probe, + qubits[2].probe, + ): + assert list(joint_seq.channel(ch)) == list(split_seq.channel(ch)) diff --git a/tests/test_dummy.py b/tests/test_dummy.py index 42f454f252..75e533bbab 100644 --- a/tests/test_dummy.py +++ b/tests/test_dummy.py @@ -1,377 +1,69 @@ -import numpy as np import pytest -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters, create_platform -from qibolab.pulses import CouplerFluxPulse, PulseSequence -from qibolab.qubits import QubitPair -from qibolab.sweeper import Parameter, QubitParameter, Sweeper +from qibolab import AcquisitionType, create_platform +from qibolab._core.platform.platform import Platform +from qibolab._core.pulses import Delay, GaussianSquare, Pulse +from qibolab._core.sequence import PulseSequence SWEPT_POINTS = 5 -PLATFORM_NAMES = ["dummy", "dummy_couplers"] -@pytest.mark.parametrize("name", PLATFORM_NAMES) -def test_dummy_initialization(name): - platform = create_platform(name) - platform.connect() - platform.disconnect() - - -@pytest.mark.parametrize("name", PLATFORM_NAMES) -@pytest.mark.parametrize( - "acquisition", [AcquisitionType.INTEGRATION, AcquisitionType.RAW] -) -def test_dummy_execute_pulse_sequence(name, acquisition): - nshots = 100 - platform = create_platform(name) - ro_pulse = platform.create_qubit_readout_pulse(0, 0) - sequence = PulseSequence() - sequence.add(platform.create_qubit_readout_pulse(0, 0)) - sequence.add(platform.create_RX12_pulse(0, 0)) - options = ExecutionParameters(nshots=100, acquisition_type=acquisition) - result = platform.execute_pulse_sequence(sequence, options) - if acquisition is AcquisitionType.INTEGRATION: - assert result[0].magnitude.shape == (nshots,) - elif acquisition is AcquisitionType.RAW: - assert result[0].magnitude.shape == (nshots * ro_pulse.duration,) - - -def test_dummy_execute_flux_pulse(): - platform = create_platform("dummy") - sequence = PulseSequence() - - pulse = platform.create_qubit_flux_pulse(qubit=0, start=0, duration=50) - sequence.add(pulse) +@pytest.fixture +def platform() -> Platform: + return create_platform("dummy") - options = ExecutionParameters(nshots=None) - _ = platform.execute_pulse_sequence(sequence, options) - test_pulse = "FluxPulse(0, 50, 1, Rectangular(), flux-0, 0)" - - assert test_pulse == pulse.serial +def test_dummy_initialization(platform: Platform): + platform.connect() + platform.disconnect() -def test_dummy_execute_coupler_pulse(): - platform = create_platform("dummy_couplers") +def test_dummy_execute_coupler_pulse(platform: Platform): sequence = PulseSequence() - pulse = platform.create_coupler_pulse(coupler=0, start=0) - sequence.add(pulse) - - options = ExecutionParameters(nshots=None) - result = platform.execute_pulse_sequence(sequence, options) - - test_pulse = ( - "CouplerFluxPulse(0, 30, 0.05, GaussianSquare(5, 0.75), flux_coupler-0, 0)" + channel = platform.coupler(0)[1].flux + pulse = Pulse( + duration=30, + amplitude=0.05, + envelope=GaussianSquare(rel_sigma=5, width=0.75), ) + sequence.append((channel, pulse)) - assert test_pulse == pulse.serial + _ = platform.execute([sequence], nshots=None) def test_dummy_execute_pulse_sequence_couplers(): - platform = create_platform("dummy_couplers") - qubit_ordered_pair = QubitPair( - platform.qubits[1], platform.qubits[2], coupler=platform.couplers[1] - ) + platform = create_platform("dummy") sequence = PulseSequence() - cz, cz_phases = platform.create_CZ_pulse_sequence( - qubits=(qubit_ordered_pair.qubit1.name, qubit_ordered_pair.qubit2.name), - start=0, - ) - sequence.add(cz.get_qubit_pulses(qubit_ordered_pair.qubit1.name)) - sequence.add(cz.get_qubit_pulses(qubit_ordered_pair.qubit2.name)) - sequence.add(cz.coupler_pulses(qubit_ordered_pair.coupler.name)) - sequence.add(platform.create_qubit_readout_pulse(0, 40)) - sequence.add(platform.create_qubit_readout_pulse(2, 40)) - options = ExecutionParameters(nshots=None) - result = platform.execute_pulse_sequence(sequence, options) - - test_pulses = "PulseSequence\nFluxPulse(0, 30, 0.05, GaussianSquare(5, 0.75), flux-2, 2)\nCouplerFluxPulse(0, 30, 0.05, GaussianSquare(5, 0.75), flux_coupler-1, 1)" - test_phases = {1: 0.0, 2: 0.0} - - assert test_pulses == cz.serial - assert test_phases == cz_phases + natives = platform.natives + cz = natives.two_qubit[(1, 2)].CZ() - -@pytest.mark.parametrize("name", PLATFORM_NAMES) -def test_dummy_execute_pulse_sequence_fast_reset(name): - platform = create_platform(name) - sequence = PulseSequence() - sequence.add(platform.create_qubit_readout_pulse(0, 0)) - options = ExecutionParameters(nshots=None, fast_reset=True) - result = platform.execute_pulse_sequence(sequence, options) + sequence.concatenate(cz) + sequence.append((platform.qubits[0].probe, Delay(duration=40))) + sequence.append((platform.qubits[2].probe, Delay(duration=40))) + sequence.concatenate(natives.single_qubit[0].MZ()) + sequence.concatenate(natives.single_qubit[2].MZ()) + _ = platform.execute([sequence], nshots=None) -@pytest.mark.parametrize("name", PLATFORM_NAMES) @pytest.mark.parametrize( "acquisition", [AcquisitionType.INTEGRATION, AcquisitionType.DISCRIMINATION] ) @pytest.mark.parametrize("batch_size", [None, 3, 5]) -def test_dummy_execute_pulse_sequence_unrolling(name, acquisition, batch_size): +def test_dummy_execute_pulse_sequence_unrolling( + platform: Platform, acquisition, batch_size +): nshots = 100 nsequences = 10 - platform = create_platform(name) - platform.instruments["dummy"].UNROLLING_BATCH_SIZE = batch_size + natives = platform.natives sequences = [] - sequence = PulseSequence() - sequence.add(platform.create_qubit_readout_pulse(0, 0)) for _ in range(nsequences): - sequences.append(sequence) - options = ExecutionParameters(nshots=nshots, acquisition_type=acquisition) - result = platform.execute_pulse_sequences(sequences, options) - assert len(result[0]) == nsequences - for r in result[0]: + sequences.append(natives.single_qubit[0].MZ()) + result = platform.execute(sequences, nshots=nshots, acquisition_type=acquisition) + assert len(next(iter(result.values()))) == nshots + for r in result.values(): if acquisition is AcquisitionType.INTEGRATION: - assert r.magnitude.shape == (nshots,) + assert r.shape == (nshots, 2) if acquisition is AcquisitionType.DISCRIMINATION: - assert r.samples.shape == (nshots,) - - -@pytest.mark.parametrize("name", PLATFORM_NAMES) -def test_dummy_single_sweep_raw(name): - platform = create_platform(name) - sequence = PulseSequence() - pulse = platform.create_qubit_readout_pulse(qubit=0, start=0) - - parameter_range = np.random.randint(SWEPT_POINTS, size=SWEPT_POINTS) - sequence.add(pulse) - sweeper = Sweeper(Parameter.frequency, parameter_range, pulses=[pulse]) - options = ExecutionParameters( - nshots=10, - averaging_mode=AveragingMode.CYCLIC, - acquisition_type=AcquisitionType.RAW, - ) - results = platform.sweep(sequence, options, sweeper) - assert pulse.serial and pulse.qubit in results - shape = results[pulse.qubit].magnitude.shape - assert shape == (pulse.duration * SWEPT_POINTS,) - - -@pytest.mark.parametrize("fast_reset", [True, False]) -@pytest.mark.parametrize( - "parameter", [Parameter.amplitude, Parameter.duration, Parameter.bias] -) -@pytest.mark.parametrize("average", [AveragingMode.SINGLESHOT, AveragingMode.CYCLIC]) -@pytest.mark.parametrize( - "acquisition", [AcquisitionType.INTEGRATION, AcquisitionType.DISCRIMINATION] -) -@pytest.mark.parametrize("nshots", [10, 20]) -def test_dummy_single_sweep_coupler( - fast_reset, parameter, average, acquisition, nshots -): - platform = create_platform("dummy_couplers") - sequence = PulseSequence() - ro_pulse = platform.create_qubit_readout_pulse(qubit=0, start=0) - coupler_pulse = CouplerFluxPulse( - start=0, - duration=40, - amplitude=0.5, - shape="GaussianSquare(5, 0.75)", - channel="flux_coupler-0", - qubit=0, - ) - if parameter is Parameter.amplitude: - parameter_range = np.random.rand(SWEPT_POINTS) - else: - parameter_range = np.random.randint(SWEPT_POINTS, size=SWEPT_POINTS) - sequence.add(ro_pulse) - if parameter in QubitParameter: - sweeper = Sweeper(parameter, parameter_range, couplers=[platform.couplers[0]]) - else: - sweeper = Sweeper(parameter, parameter_range, pulses=[coupler_pulse]) - options = ExecutionParameters( - nshots=nshots, - averaging_mode=average, - acquisition_type=acquisition, - fast_reset=fast_reset, - ) - average = not options.averaging_mode is AveragingMode.SINGLESHOT - results = platform.sweep(sequence, options, sweeper) - - assert ro_pulse.serial and ro_pulse.qubit in results - if average: - results_shape = ( - results[ro_pulse.qubit].magnitude.shape - if acquisition is AcquisitionType.INTEGRATION - else results[ro_pulse.qubit].statistical_frequency.shape - ) - else: - results_shape = ( - results[ro_pulse.qubit].magnitude.shape - if acquisition is AcquisitionType.INTEGRATION - else results[ro_pulse.qubit].samples.shape - ) - assert results_shape == (SWEPT_POINTS,) if average else (nshots, SWEPT_POINTS) - - -@pytest.mark.parametrize("name", PLATFORM_NAMES) -@pytest.mark.parametrize("fast_reset", [True, False]) -@pytest.mark.parametrize("parameter", Parameter) -@pytest.mark.parametrize("average", [AveragingMode.SINGLESHOT, AveragingMode.CYCLIC]) -@pytest.mark.parametrize( - "acquisition", [AcquisitionType.INTEGRATION, AcquisitionType.DISCRIMINATION] -) -@pytest.mark.parametrize("nshots", [10, 20]) -def test_dummy_single_sweep(name, fast_reset, parameter, average, acquisition, nshots): - platform = create_platform(name) - sequence = PulseSequence() - pulse = platform.create_qubit_readout_pulse(qubit=0, start=0) - if parameter is Parameter.amplitude: - parameter_range = np.random.rand(SWEPT_POINTS) - else: - parameter_range = np.random.randint(SWEPT_POINTS, size=SWEPT_POINTS) - sequence.add(pulse) - if parameter in QubitParameter: - sweeper = Sweeper(parameter, parameter_range, qubits=[platform.qubits[0]]) - else: - sweeper = Sweeper(parameter, parameter_range, pulses=[pulse]) - options = ExecutionParameters( - nshots=nshots, - averaging_mode=average, - acquisition_type=acquisition, - fast_reset=fast_reset, - ) - average = not options.averaging_mode is AveragingMode.SINGLESHOT - results = platform.sweep(sequence, options, sweeper) - - assert pulse.serial and pulse.qubit in results - if average: - results_shape = ( - results[pulse.qubit].magnitude.shape - if acquisition is AcquisitionType.INTEGRATION - else results[pulse.qubit].statistical_frequency.shape - ) - else: - results_shape = ( - results[pulse.qubit].magnitude.shape - if acquisition is AcquisitionType.INTEGRATION - else results[pulse.qubit].samples.shape - ) - assert results_shape == (SWEPT_POINTS,) if average else (nshots, SWEPT_POINTS) - - -@pytest.mark.parametrize("name", PLATFORM_NAMES) -@pytest.mark.parametrize("parameter1", Parameter) -@pytest.mark.parametrize("parameter2", Parameter) -@pytest.mark.parametrize("average", [AveragingMode.SINGLESHOT, AveragingMode.CYCLIC]) -@pytest.mark.parametrize( - "acquisition", [AcquisitionType.INTEGRATION, AcquisitionType.DISCRIMINATION] -) -@pytest.mark.parametrize("nshots", [10, 20]) -def test_dummy_double_sweep(name, parameter1, parameter2, average, acquisition, nshots): - platform = create_platform(name) - sequence = PulseSequence() - pulse = platform.create_qubit_drive_pulse(qubit=0, start=0, duration=1000) - ro_pulse = platform.create_qubit_readout_pulse(qubit=0, start=pulse.finish) - sequence.add(pulse) - sequence.add(ro_pulse) - parameter_range_1 = ( - np.random.rand(SWEPT_POINTS) - if parameter1 is Parameter.amplitude - else np.random.randint(SWEPT_POINTS, size=SWEPT_POINTS) - ) - parameter_range_2 = ( - np.random.rand(SWEPT_POINTS) - if parameter2 is Parameter.amplitude - else np.random.randint(SWEPT_POINTS, size=SWEPT_POINTS) - ) - - if parameter1 in QubitParameter: - sweeper1 = Sweeper(parameter1, parameter_range_1, qubits=[platform.qubits[0]]) - else: - sweeper1 = Sweeper(parameter1, parameter_range_1, pulses=[ro_pulse]) - if parameter2 in QubitParameter: - sweeper2 = Sweeper(parameter2, parameter_range_2, qubits=[platform.qubits[0]]) - else: - sweeper2 = Sweeper(parameter2, parameter_range_2, pulses=[pulse]) - - options = ExecutionParameters( - nshots=nshots, - averaging_mode=average, - acquisition_type=acquisition, - ) - average = not options.averaging_mode is AveragingMode.SINGLESHOT - results = platform.sweep(sequence, options, sweeper1, sweeper2) - - assert ro_pulse.serial and ro_pulse.qubit in results - - if average: - results_shape = ( - results[pulse.qubit].magnitude.shape - if acquisition is AcquisitionType.INTEGRATION - else results[pulse.qubit].statistical_frequency.shape - ) - else: - results_shape = ( - results[pulse.qubit].magnitude.shape - if acquisition is AcquisitionType.INTEGRATION - else results[pulse.qubit].samples.shape - ) - - assert ( - results_shape == (SWEPT_POINTS, SWEPT_POINTS) - if average - else (nshots, SWEPT_POINTS, SWEPT_POINTS) - ) - - -@pytest.mark.parametrize("name", PLATFORM_NAMES) -@pytest.mark.parametrize("parameter", Parameter) -@pytest.mark.parametrize("average", [AveragingMode.SINGLESHOT, AveragingMode.CYCLIC]) -@pytest.mark.parametrize( - "acquisition", [AcquisitionType.INTEGRATION, AcquisitionType.DISCRIMINATION] -) -@pytest.mark.parametrize("nshots", [10, 20]) -def test_dummy_single_sweep_multiplex(name, parameter, average, acquisition, nshots): - platform = create_platform(name) - sequence = PulseSequence() - ro_pulses = {} - for qubit in platform.qubits: - ro_pulses[qubit] = platform.create_qubit_readout_pulse(qubit=qubit, start=0) - sequence.add(ro_pulses[qubit]) - parameter_range = ( - np.random.rand(SWEPT_POINTS) - if parameter is Parameter.amplitude - else np.random.randint(SWEPT_POINTS, size=SWEPT_POINTS) - ) - - if parameter in QubitParameter: - sweeper1 = Sweeper( - parameter, - parameter_range, - qubits=[platform.qubits[qubit] for qubit in platform.qubits], - ) - else: - sweeper1 = Sweeper( - parameter, - parameter_range, - pulses=[ro_pulses[qubit] for qubit in platform.qubits], - ) - - options = ExecutionParameters( - nshots=nshots, - averaging_mode=average, - acquisition_type=acquisition, - ) - average = not options.averaging_mode is AveragingMode.SINGLESHOT - results = platform.sweep(sequence, options, sweeper1) - - for ro_pulse in ro_pulses.values(): - assert ro_pulse.serial and ro_pulse.qubit in results - if average: - results_shape = ( - results[ro_pulse.qubit].magnitude.shape - if acquisition is AcquisitionType.INTEGRATION - else results[ro_pulse.qubit].statistical_frequency.shape - ) - else: - results_shape = ( - results[ro_pulse.qubit].magnitude.shape - if acquisition is AcquisitionType.INTEGRATION - else results[ro_pulse.qubit].samples.shape - ) - assert results_shape == (SWEPT_POINTS,) if average else (nshots, SWEPT_POINTS) - - -# TODO: add test_dummy_double_sweep_multiplex + assert r.shape == (nshots,) diff --git a/tests/test_emulator.py b/tests/test_emulator.py deleted file mode 100644 index f87a6e014d..0000000000 --- a/tests/test_emulator.py +++ /dev/null @@ -1,352 +0,0 @@ -import os -import pathlib - -import numpy as np -import pytest -from qutip import Options, identity, tensor - -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters, create_platform -from qibolab.instruments.emulator.engines.generic import op_from_instruction -from qibolab.instruments.emulator.engines.qutip_engine import ( - QutipSimulator, - extend_op_dim, - function_from_array, -) -from qibolab.instruments.emulator.models import ( - general_no_coupler_model, - models_template, -) -from qibolab.instruments.emulator.pulse_simulator import AVAILABLE_SWEEP_PARAMETERS -from qibolab.platform.load import PLATFORMS -from qibolab.pulses import PulseSequence -from qibolab.sweeper import Parameter, QubitParameter, Sweeper - -os.environ[PLATFORMS] = str(pathlib.Path(__file__).parent / "emulators/") - -SWEPT_POINTS = 2 -EMULATORS = ["default_q0"] -MODELS = [models_template, general_no_coupler_model] - - -@pytest.mark.parametrize("emulator", EMULATORS) -def test_emulator_initialization(emulators, emulator): - platform = create_platform(emulator) - platform.connect() - platform.disconnect() - - -@pytest.mark.parametrize("emulator", EMULATORS) -@pytest.mark.parametrize( - "acquisition", - [AcquisitionType.DISCRIMINATION, AcquisitionType.INTEGRATION, AcquisitionType.RAW], -) -def test_emulator_execute_pulse_sequence_compute_overlaps( - emulators, emulator, acquisition -): - nshots = 10 # 100 - platform = create_platform(emulator) - pulse_simulator = platform.instruments["pulse_simulator"] - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(0, 0)) - sequence.add(platform.create_qubit_readout_pulse(0, 0)) - options = ExecutionParameters(nshots=nshots, acquisition_type=acquisition) - if ( - acquisition is AcquisitionType.DISCRIMINATION - or acquisition is AcquisitionType.INTEGRATION - ): - results = platform.execute_pulse_sequence(sequence, options) - simulated_states = results["simulation"]["output_states"] - overlaps = pulse_simulator.simulation_engine.compute_overlaps(simulated_states) - if acquisition is AcquisitionType.DISCRIMINATION: - assert results[0].samples.shape == (nshots,) - else: - assert results[0].voltage.shape == (nshots,) - else: - with pytest.raises(ValueError) as excinfo: - platform.execute_pulse_sequence(sequence, options) - assert "Current emulator does not support requested AcquisitionType" in str( - excinfo.value - ) - - -@pytest.mark.parametrize("emulator", EMULATORS) -def test_emulator_execute_pulse_sequence_fast_reset(emulators, emulator): - platform = create_platform(emulator) - sequence = PulseSequence() - sequence.add(platform.create_qubit_readout_pulse(0, 0)) - options = ExecutionParameters( - nshots=None, fast_reset=True - ) # fast_reset does nothing in emulator - result = platform.execute_pulse_sequence(sequence, options) - - -@pytest.mark.parametrize("emulator", EMULATORS) -@pytest.mark.parametrize("fast_reset", [True, False]) -@pytest.mark.parametrize("parameter", Parameter) -@pytest.mark.parametrize("average", [AveragingMode.SINGLESHOT, AveragingMode.CYCLIC]) -@pytest.mark.parametrize("acquisition", [AcquisitionType.DISCRIMINATION]) -@pytest.mark.parametrize("nshots", [10, 20]) -def test_emulator_single_sweep( - emulators, emulator, fast_reset, parameter, average, acquisition, nshots -): - platform = create_platform(emulator) - sequence = PulseSequence() - pulse = platform.create_qubit_readout_pulse(qubit=0, start=0) - if parameter is Parameter.amplitude: - parameter_range = np.random.rand(SWEPT_POINTS) - else: - parameter_range = np.random.randint(1, 4, size=SWEPT_POINTS) - sequence.add(pulse) - if parameter in QubitParameter: - sweeper = Sweeper(parameter, parameter_range, qubits=[platform.qubits[0]]) - else: - sweeper = Sweeper(parameter, parameter_range, pulses=[pulse]) - - options = ExecutionParameters( - nshots=nshots, - averaging_mode=average, - acquisition_type=acquisition, - fast_reset=fast_reset, - ) - average = not options.averaging_mode is AveragingMode.SINGLESHOT - if parameter in AVAILABLE_SWEEP_PARAMETERS: - results = platform.sweep(sequence, options, sweeper) - - assert pulse.serial and pulse.qubit in results - if average: - results_shape = results[pulse.qubit].statistical_frequency.shape - else: - results_shape = results[pulse.qubit].samples.shape - assert results_shape == (SWEPT_POINTS,) if average else (nshots, SWEPT_POINTS) - else: - with pytest.raises(NotImplementedError) as excinfo: - platform.sweep(sequence, options, sweeper) - assert "Sweep parameter requested not available" in str(excinfo.value) - - -@pytest.mark.parametrize("emulator", EMULATORS) -@pytest.mark.parametrize("parameter1", Parameter) -@pytest.mark.parametrize("parameter2", Parameter) -@pytest.mark.parametrize("average", [AveragingMode.SINGLESHOT, AveragingMode.CYCLIC]) -@pytest.mark.parametrize("acquisition", [AcquisitionType.DISCRIMINATION]) -@pytest.mark.parametrize("nshots", [10, 20]) -def test_emulator_double_sweep_false_history( - emulators, emulator, parameter1, parameter2, average, acquisition, nshots -): - platform = create_platform(emulator) - pulse_simulator = platform.instruments["pulse_simulator"] - pulse_simulator.output_state_history = False - sequence = PulseSequence() - pulse = platform.create_qubit_drive_pulse(qubit=0, start=0, duration=2) - ro_pulse = platform.create_qubit_readout_pulse(qubit=0, start=pulse.finish) - sequence.add(pulse) - sequence.add(ro_pulse) - parameter_range_1 = ( - np.random.rand(SWEPT_POINTS) - if parameter1 is Parameter.amplitude - else np.random.randint(1, 4, size=SWEPT_POINTS) - ) - parameter_range_2 = ( - np.random.rand(SWEPT_POINTS) - if parameter2 is Parameter.amplitude - else np.random.randint(1, 4, size=SWEPT_POINTS) - ) - if parameter1 in QubitParameter: - sweeper1 = Sweeper(parameter1, parameter_range_1, qubits=[platform.qubits[0]]) - else: - sweeper1 = Sweeper(parameter1, parameter_range_1, pulses=[ro_pulse]) - if parameter2 in QubitParameter: - sweeper2 = Sweeper(parameter2, parameter_range_2, qubits=[platform.qubits[0]]) - else: - sweeper2 = Sweeper(parameter2, parameter_range_2, pulses=[pulse]) - - options = ExecutionParameters( - nshots=nshots, - averaging_mode=average, - acquisition_type=acquisition, - ) - average = not options.averaging_mode is AveragingMode.SINGLESHOT - - if ( - parameter1 in AVAILABLE_SWEEP_PARAMETERS - and parameter2 in AVAILABLE_SWEEP_PARAMETERS - ): - results = platform.sweep(sequence, options, sweeper1, sweeper2) - - assert ro_pulse.serial and ro_pulse.qubit in results - - if average: - results_shape = results[pulse.qubit].statistical_frequency.shape - else: - results_shape = results[pulse.qubit].samples.shape - - assert ( - results_shape == (SWEPT_POINTS, SWEPT_POINTS) - if average - else (nshots, SWEPT_POINTS, SWEPT_POINTS) - ) - - -@pytest.mark.parametrize("emulator", EMULATORS) -@pytest.mark.parametrize("parameter", Parameter) -@pytest.mark.parametrize("average", [AveragingMode.SINGLESHOT, AveragingMode.CYCLIC]) -@pytest.mark.parametrize("acquisition", [AcquisitionType.DISCRIMINATION]) -@pytest.mark.parametrize("nshots", [10, 20]) -def test_emulator_single_sweep_multiplex( - emulators, emulator, parameter, average, acquisition, nshots -): - platform = create_platform(emulator) - sequence = PulseSequence() - ro_pulses = {} - for qubit in platform.qubits: - ro_pulses[qubit] = platform.create_qubit_readout_pulse(qubit=qubit, start=0) - sequence.add(ro_pulses[qubit]) - parameter_range = ( - np.random.rand(SWEPT_POINTS) - if parameter is Parameter.amplitude - else np.random.randint(1, 4, size=SWEPT_POINTS) - ) - - if parameter in QubitParameter: - sweeper1 = Sweeper( - parameter, - parameter_range, - qubits=[platform.qubits[qubit] for qubit in platform.qubits], - ) - else: - sweeper1 = Sweeper( - parameter, - parameter_range, - pulses=[ro_pulses[qubit] for qubit in platform.qubits], - ) - - options = ExecutionParameters( - nshots=nshots, - averaging_mode=average, - acquisition_type=acquisition, - ) - average = not options.averaging_mode is AveragingMode.SINGLESHOT - if parameter in AVAILABLE_SWEEP_PARAMETERS: - results = platform.sweep(sequence, options, sweeper1) - - for ro_pulse in ro_pulses.values(): - assert ro_pulse.serial and ro_pulse.qubit in results - if average: - results_shape = results[ro_pulse.qubit].statistical_frequency.shape - else: - results_shape = results[ro_pulse.qubit].samples.shape - assert ( - results_shape == (SWEPT_POINTS,) if average else (nshots, SWEPT_POINTS) - ) - - -# pulse_simulator -def test_pulse_simulator_initialization(emulators): - emulator = "default_q0" - platform = create_platform(emulator) - sim_opts = Options(atol=1e-11, rtol=1e-9, nsteps=int(1e6)) - pulse_simulator = platform.instruments["pulse_simulator"] - pulse_simulator.connect() - pulse_simulator.disconnect() - pulse_simulator.dump() - - -def test_pulse_simulator_play_no_dissipation_dt_units_false_history_ro_exception( - emulators, -): - emulator = "default_q0" - platform = create_platform(emulator) - pulse_simulator = platform.instruments["pulse_simulator"] - pulse_simulator.readout_error = {1: [0.1, 0.1]} - pulse_simulator.runcard_duration_in_dt_units = True - pulse_simulator.simulate_dissipation = False - pulse_simulator.output_state_history = False - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(0, 0)) - sequence.add(platform.create_qubit_readout_pulse(0, 0)) - execution_parameters = ExecutionParameters(nshots=10) - with pytest.raises(ValueError) as excinfo: - pulse_simulator.play({0: 0}, {}, sequence, execution_parameters) - assert "Not all readout qubits are present in readout_error!" in str(excinfo.value) - - -# models.methods -def test_op_from_instruction(): - model = models_template - model_config = model.generate_model_config() - test_inst = model_config["drift"]["one_body"][1] - test_inst2 = model_config["drift"]["two_body"][0] - test_inst3 = (1.0, "b_2 ^ b_1 ^ b_0", ["2", "1", "0"]) - op_from_instruction(test_inst, multiply_coeff=False) - op_from_instruction(test_inst2, multiply_coeff=False) - op_from_instruction(test_inst3, multiply_coeff=False) - - -# engines.qutip_engine -@pytest.mark.parametrize("model", MODELS) -def test_update_sim_opts(model): - model_config = model.generate_model_config() - simulation_engine = QutipSimulator(model_config) - sim_opts = Options(atol=1e-11, rtol=1e-9, nsteps=int(1e6)) - - -@pytest.mark.parametrize("model", MODELS) -def test_make_arbitrary_state(model): - model_config = model.generate_model_config() - simulation_engine = QutipSimulator(model_config) - zerostate = simulation_engine.psi0.copy() - dim = zerostate.shape[0] - qibo_statevector = np.zeros(dim) - qibo_statevector[2] = 1 - qibo_statevector = np.array(qibo_statevector.tolist()) - qibo_statedm = np.kron( - qibo_statevector.reshape([dim, 1]), qibo_statevector.reshape([1, dim]) - ) - teststate = simulation_engine.make_arbitrary_state( - qibo_statevector, is_qibo_state_vector=True - ) - teststatedm = simulation_engine.make_arbitrary_state( - qibo_statedm, is_qibo_state_vector=True - ) - - -@pytest.mark.parametrize("model", MODELS) -def test_state_from_basis_vector_exception(model): - model_config = model.generate_model_config() - simulation_engine = QutipSimulator(model_config) - basis_vector0 = [0 for i in range(simulation_engine.nqubits)] - cbasis_vector0 = [0 for i in range(simulation_engine.ncouplers)] - simulation_engine.state_from_basis_vector(basis_vector0, None) - combined_vector_list = [ - [basis_vector0 + [0], cbasis_vector0, "basis_vector"], - [basis_vector0, cbasis_vector0 + [0], "cbasis_vector"], - ] - for combined_vector in combined_vector_list: - with pytest.raises(Exception) as excinfo: - basis_vector, cbasis_vector, error_vector = combined_vector - simulation_engine.state_from_basis_vector(basis_vector, cbasis_vector) - assert f"length of {error_vector} does not match" in str(excinfo.value) - - -def test_function_from_array_exception(): - y = np.ones([2, 2]) - x = np.ones([3, 2]) - with pytest.raises(ValueError) as excinfo: - function_from_array(y, x) - assert "y and x must have the same" in str(excinfo.value) - - -def test_extend_op_dim_exceptions(): - I2 = identity(2) - I4 = identity(4) - op_qobj = tensor(I2, I4) - - index_list1 = [[0], [0, 1], [2, 3], [4, 5, 6]] - index_list2 = [[0], [4], [2, 3], [4, 5]] - index_list3 = [[0], [0], [2, 3], [5, 4]] - index_lists = [index_list1, index_list2, index_list3] - - for index_list in index_lists: - with pytest.raises(Exception) as excinfo: - extend_op_dim(op_qobj, *index_list) - assert "mismatch" in str(excinfo.value) diff --git a/tests/test_execute_qasm.py b/tests/test_execute_qasm.py index 4271758ec5..9716a8f9c3 100644 --- a/tests/test_execute_qasm.py +++ b/tests/test_execute_qasm.py @@ -1,7 +1,6 @@ from qibo import Circuit, __version__ -from qibolab import execute_qasm -from qibolab.backends import QibolabBackend +from qibolab._core.backends import QibolabBackend, execute_qasm def test_execute_qasm(): diff --git a/tests/test_instruments_qblox_cluster_qcm_bb.py b/tests/test_instruments_qblox_cluster_qcm_bb.py deleted file mode 100644 index 5af689fe09..0000000000 --- a/tests/test_instruments_qblox_cluster_qcm_bb.py +++ /dev/null @@ -1,176 +0,0 @@ -import math - -import numpy as np -import pytest - -from qibolab.instruments.abstract import Instrument -from qibolab.instruments.qblox.cluster_qcm_bb import QcmBb -from qibolab.instruments.qblox.port import QbloxOutputPort -from qibolab.pulses import FluxPulse, PulseSequence -from qibolab.sweeper import Parameter, Sweeper, SweeperType - -from .qblox_fixtures import connected_controller, controller - -O1_OUTPUT_CHANNEL = "L4-5" -O2_OUTPUT_CHANNEL = "L4-1" -O3_OUTPUT_CHANNEL = "L4-2" -O4_OUTPUT_CHANNEL = "L4-3" - -PORT_SETTINGS = ["o1", "o2", "o3", "o4"] - - -def get_qcm_bb(controller): - for module in controller.modules.values(): - if isinstance(module, QcmBb): - return QcmBb(module.name, module.address) - - -@pytest.fixture(scope="module") -def qcm_bb(controller): - return get_qcm_bb(controller) - - -@pytest.fixture(scope="module") -def connected_qcm_bb(connected_controller): - qcm_bb = get_qcm_bb(connected_controller) - for port in PORT_SETTINGS: - qcm_bb.ports(port) - qcm_bb.connect(connected_controller.cluster) - yield qcm_bb - qcm_bb.disconnect() - connected_controller.disconnect() - - -def test_instrument_interface(qcm_bb: QcmBb): - # Test compliance with :class:`qibolab.instruments.abstract.Instrument` interface - for abstract_method in Instrument.__abstractmethods__: - assert hasattr(qcm_bb, abstract_method) - - for attribute in [ - "name", - "address", - "is_connected", - ]: - assert hasattr(qcm_bb, attribute) - - -def test_init(qcm_bb: QcmBb): - assert qcm_bb.device == None - - -def test_setup(qcm_bb: QcmBb): - qcm_bb.setup() - - -@pytest.mark.qpu -def test_connect(connected_qcm_bb: QcmBb): - qcm_bb = connected_qcm_bb - - assert qcm_bb.is_connected - assert not qcm_bb is None - for idx, port in enumerate(qcm_bb._ports): - assert type(qcm_bb._ports[port]) == QbloxOutputPort - assert qcm_bb._ports[port].sequencer_number == idx - - o1_default_sequencer = qcm_bb.device.sequencers[qcm_bb.DEFAULT_SEQUENCERS["o1"]] - o2_default_sequencer = qcm_bb.device.sequencers[qcm_bb.DEFAULT_SEQUENCERS["o2"]] - o3_default_sequencer = qcm_bb.device.sequencers[qcm_bb.DEFAULT_SEQUENCERS["o3"]] - o4_default_sequencer = qcm_bb.device.sequencers[qcm_bb.DEFAULT_SEQUENCERS["o4"]] - for default_sequencer in [ - o1_default_sequencer, - o2_default_sequencer, - o3_default_sequencer, - o4_default_sequencer, - ]: - assert default_sequencer.get("cont_mode_en_awg_path0") == False - assert default_sequencer.get("cont_mode_en_awg_path1") == False - assert default_sequencer.get("cont_mode_waveform_idx_awg_path0") == 0 - assert default_sequencer.get("cont_mode_waveform_idx_awg_path1") == 0 - assert default_sequencer.get("marker_ovr_en") == True - assert default_sequencer.get("marker_ovr_value") == 15 - assert default_sequencer.get("mixer_corr_gain_ratio") == 1 - assert default_sequencer.get("mixer_corr_phase_offset_degree") == 0 - assert default_sequencer.get("offset_awg_path0") == 0 - assert default_sequencer.get("offset_awg_path1") == 0 - assert default_sequencer.get("sync_en") == False - assert default_sequencer.get("upsample_rate_awg_path0") == 0 - assert default_sequencer.get("upsample_rate_awg_path1") == 0 - - assert o1_default_sequencer.get("connect_out0") == "I" - assert o2_default_sequencer.get("connect_out1") == "Q" - assert o3_default_sequencer.get("connect_out2") == "I" - assert o4_default_sequencer.get("connect_out3") == "Q" - - _device_num_sequencers = len(qcm_bb.device.sequencers) - for s in range(4, _device_num_sequencers): - assert qcm_bb.device.sequencers[s].get("connect_out0") == "off" - assert qcm_bb.device.sequencers[s].get("connect_out1") == "off" - assert qcm_bb.device.sequencers[s].get("connect_out2") == "off" - assert qcm_bb.device.sequencers[s].get("connect_out3") == "off" - - o1_default_sequencer = qcm_bb.device.sequencers[qcm_bb.DEFAULT_SEQUENCERS["o1"]] - assert math.isclose(o1_default_sequencer.get("gain_awg_path1"), 1, rel_tol=1e-4) - assert o1_default_sequencer.get("mod_en_awg") == True - assert qcm_bb._ports["o1"].nco_freq == 0 - assert qcm_bb._ports["o1"].nco_phase_offs == 0 - - o2_default_sequencer = qcm_bb.device.sequencers[qcm_bb.DEFAULT_SEQUENCERS["o2"]] - assert math.isclose(o2_default_sequencer.get("gain_awg_path1"), 1, rel_tol=1e-4) - assert o2_default_sequencer.get("mod_en_awg") == True - assert qcm_bb._ports["o2"].nco_freq == 0 - assert qcm_bb._ports["o2"].nco_phase_offs == 0 - - o3_default_sequencer = qcm_bb.device.sequencers[qcm_bb.DEFAULT_SEQUENCERS["o3"]] - assert math.isclose(o3_default_sequencer.get("gain_awg_path1"), 1, rel_tol=1e-4) - assert o3_default_sequencer.get("mod_en_awg") == True - assert qcm_bb._ports["o3"].nco_freq == 0 - assert qcm_bb._ports["o3"].nco_phase_offs == 0 - - o4_default_sequencer = qcm_bb.device.sequencers[qcm_bb.DEFAULT_SEQUENCERS["o4"]] - assert math.isclose(o4_default_sequencer.get("gain_awg_path1"), 1, rel_tol=1e-4) - assert o1_default_sequencer.get("mod_en_awg") == True - assert qcm_bb._ports["o4"].nco_freq == 0 - assert qcm_bb._ports["o4"].nco_phase_offs == 0 - - -@pytest.mark.qpu -def test_pulse_sequence(connected_platform, connected_qcm_bb: QcmBb): - ps = PulseSequence() - ps.add(FluxPulse(40, 70, 0.5, "Rectangular", O1_OUTPUT_CHANNEL)) - ps.add(FluxPulse(0, 50, 0.3, "Rectangular", O2_OUTPUT_CHANNEL)) - ps.add(FluxPulse(20, 100, 0.02, "Rectangular", O3_OUTPUT_CHANNEL)) - ps.add(FluxPulse(32, 48, 0.4, "Rectangular", O4_OUTPUT_CHANNEL)) - qubits = connected_platform.qubits - connected_qcm_bb._ports["o2"].hardware_mod_en = True - connected_qcm_bb.process_pulse_sequence(qubits, ps, 1000, 1, 10000) - connected_qcm_bb.upload() - connected_qcm_bb.play_sequence() - - connected_qcm_bb._ports["o2"].hardware_mod_en = False - connected_qcm_bb.process_pulse_sequence(qubits, ps, 1000, 1, 10000) - connected_qcm_bb.upload() - connected_qcm_bb.play_sequence() - - -@pytest.mark.qpu -def test_sweepers(connected_platform, connected_qcm_bb: QcmBb): - ps = PulseSequence() - ps.add(FluxPulse(40, 70, 0.5, "Rectangular", O1_OUTPUT_CHANNEL)) - ps.add(FluxPulse(0, 50, 0.3, "Rectangular", O2_OUTPUT_CHANNEL)) - ps.add(FluxPulse(20, 100, 0.02, "Rectangular", O3_OUTPUT_CHANNEL)) - ps.add(FluxPulse(32, 48, 0.4, "Rectangular", O4_OUTPUT_CHANNEL)) - qubits = connected_platform.qubits - - amplitude_range = np.linspace(0, 0.25, 50) - sweeper = Sweeper( - Parameter.amplitude, - amplitude_range, - pulses=ps.pulses, - type=SweeperType.OFFSET, - ) - - connected_qcm_bb.process_pulse_sequence( - qubits, ps, 1000, 1, 10000, sweepers=[sweeper] - ) - connected_qcm_bb.upload() - connected_qcm_bb.play_sequence() diff --git a/tests/test_instruments_qblox_cluster_qcm_rf.py b/tests/test_instruments_qblox_cluster_qcm_rf.py deleted file mode 100644 index 5d046de2d6..0000000000 --- a/tests/test_instruments_qblox_cluster_qcm_rf.py +++ /dev/null @@ -1,246 +0,0 @@ -import numpy as np -import pytest - -from qibolab.instruments.abstract import Instrument -from qibolab.instruments.qblox.cluster_qcm_rf import QcmRf -from qibolab.instruments.qblox.port import QbloxOutputPort -from qibolab.pulses import DrivePulse, PulseSequence -from qibolab.sweeper import Parameter, Sweeper, SweeperType - -from .qblox_fixtures import connected_controller, controller - -O1_OUTPUT_CHANNEL = "L3-15" -O1_ATTENUATION = 20 -O1_LO_FREQUENCY = 5_052_833_073 - -O2_OUTPUT_CHANNEL = "L3-11" -O2_ATTENUATION = 20 -O2_LO_FREQUENCY = 5_995_371_914 -SETTINGS = { - "o1": { - "attenuation": O1_ATTENUATION, - "lo_frequency": O1_LO_FREQUENCY, - }, - "o2": { - "attenuation": O2_ATTENUATION, - "lo_frequency": O2_LO_FREQUENCY, - }, -} - - -def get_qcm_rf(controller): - for module in controller.modules.values(): - if isinstance(module, QcmRf): - return QcmRf(module.name, module.address) - - -@pytest.fixture(scope="module") -def qcm_rf(controller): - return get_qcm_rf(controller) - - -@pytest.fixture(scope="module") -def connected_qcm_rf(connected_controller): - qcm_rf = get_qcm_rf(connected_controller) - qcm_rf.setup(**SETTINGS) - for port in SETTINGS: - qcm_rf.ports(port) - qcm_rf.connect(connected_controller.cluster) - yield qcm_rf - - qcm_rf.disconnect() - connected_controller.disconnect() - - -def test_instrument_interface(qcm_rf: QcmRf): - # Test compliance with :class:`qibolab.instruments.abstract.Instrument` interface - for abstract_method in Instrument.__abstractmethods__: - assert hasattr(qcm_rf, abstract_method) - - for attribute in [ - "name", - "address", - "is_connected", - ]: - assert hasattr(qcm_rf, attribute) - - -def test_init(qcm_rf: QcmRf): - assert qcm_rf.device == None - assert type(qcm_rf._ports) == dict - - -def test_setup(qcm_rf: QcmRf): - qcm_rf.setup(**SETTINGS) - assert qcm_rf.settings == SETTINGS - - -@pytest.mark.qpu -def test_connect(connected_qcm_rf: QcmRf): - qcm_rf = connected_qcm_rf - - assert qcm_rf.is_connected - assert not qcm_rf is None - # test configuration after connection - assert qcm_rf.device.get("out0_offset_path0") == 0 - assert qcm_rf.device.get("out0_offset_path1") == 0 - assert qcm_rf.device.get("out1_offset_path0") == 0 - assert qcm_rf.device.get("out1_offset_path1") == 0 - - o1_default_sequencer = qcm_rf.device.sequencers[qcm_rf.DEFAULT_SEQUENCERS["o1"]] - o2_default_sequencer = qcm_rf.device.sequencers[qcm_rf.DEFAULT_SEQUENCERS["o2"]] - for default_sequencer in [o1_default_sequencer, o2_default_sequencer]: - assert default_sequencer.get("cont_mode_en_awg_path0") == False - assert default_sequencer.get("cont_mode_en_awg_path1") == False - assert default_sequencer.get("cont_mode_waveform_idx_awg_path0") == 0 - assert default_sequencer.get("cont_mode_waveform_idx_awg_path1") == 0 - assert default_sequencer.get("marker_ovr_en") == True - assert default_sequencer.get("marker_ovr_value") == 15 - assert default_sequencer.get("mixer_corr_gain_ratio") == 1 - assert default_sequencer.get("mixer_corr_phase_offset_degree") == 0 - assert default_sequencer.get("offset_awg_path0") == 0 - assert default_sequencer.get("offset_awg_path1") == 0 - assert default_sequencer.get("sync_en") == False - assert default_sequencer.get("upsample_rate_awg_path0") == 0 - assert default_sequencer.get("upsample_rate_awg_path1") == 0 - - assert o1_default_sequencer.get("connect_out0") == "IQ" - assert o1_default_sequencer.get("connect_out1") == "off" - - assert o2_default_sequencer.get("connect_out1") == "IQ" - assert o2_default_sequencer.get("connect_out0") == "off" - - _device_num_sequencers = len(qcm_rf.device.sequencers) - for s in range(2, _device_num_sequencers): - assert qcm_rf.device.sequencers[s].get("connect_out0") == "off" - assert qcm_rf.device.sequencers[s].get("connect_out1") == "off" - - assert qcm_rf.device.get("out0_att") == O1_ATTENUATION - assert qcm_rf.device.get("out0_lo_en") == True - assert qcm_rf.device.get("out0_lo_freq") == O1_LO_FREQUENCY - assert qcm_rf.device.get("out0_lo_freq") == O1_LO_FREQUENCY - - o1_default_sequencer = qcm_rf.device.sequencers[qcm_rf.DEFAULT_SEQUENCERS["o1"]] - - assert o1_default_sequencer.get("mod_en_awg") == True - - assert qcm_rf._ports["o1"].nco_freq == 0 - assert qcm_rf._ports["o1"].nco_phase_offs == 0 - - assert qcm_rf.device.get("out1_att") == O2_ATTENUATION - assert qcm_rf.device.get("out1_lo_en") == True - assert qcm_rf.device.get("out1_lo_freq") == O2_LO_FREQUENCY - assert qcm_rf.device.get("out1_lo_freq") == O2_LO_FREQUENCY - - o2_default_sequencer = qcm_rf.device.sequencers[qcm_rf.DEFAULT_SEQUENCERS["o2"]] - - assert o2_default_sequencer.get("mod_en_awg") == True - - assert qcm_rf._ports["o2"].nco_freq == 0 - assert qcm_rf._ports["o2"].nco_phase_offs == 0 - - for port in qcm_rf.settings: - assert type(qcm_rf._ports[port]) == QbloxOutputPort - assert type(qcm_rf._sequencers[port]) == list - o1_output_port: QbloxOutputPort = qcm_rf._ports["o1"] - o2_output_port: QbloxOutputPort = qcm_rf._ports["o2"] - assert o1_output_port.sequencer_number == 0 - assert o2_output_port.sequencer_number == 1 - - -@pytest.mark.qpu -def test_pulse_sequence(connected_platform, connected_qcm_rf: QcmRf): - ps = PulseSequence() - ps.add( - DrivePulse( - 0, - 200, - 1, - O1_LO_FREQUENCY - 200e6, - np.pi / 2, - "Gaussian(5)", - O1_OUTPUT_CHANNEL, - ) - ) - ps.add( - DrivePulse( - 0, - 200, - 1, - O2_LO_FREQUENCY - 200e6, - np.pi / 2, - "Gaussian(5)", - O2_OUTPUT_CHANNEL, - ) - ) - - qubits = connected_platform.qubits - connected_qcm_rf._ports["o2"].hardware_mod_en = True - connected_qcm_rf.process_pulse_sequence(qubits, ps, 1000, 1, 10000) - connected_qcm_rf.upload() - connected_qcm_rf.play_sequence() - - connected_qcm_rf._ports["o2"].hardware_mod_en = False - connected_qcm_rf.process_pulse_sequence(qubits, ps, 1000, 1, 10000) - connected_qcm_rf.upload() - connected_qcm_rf.play_sequence() - - -@pytest.mark.qpu -def test_sweepers(connected_platform, connected_qcm_rf: QcmRf): - ps = PulseSequence() - ps.add( - DrivePulse( - 0, - 200, - 1, - O1_LO_FREQUENCY - 200e6, - np.pi / 2, - "Gaussian(5)", - O1_OUTPUT_CHANNEL, - ) - ) - ps.add( - DrivePulse( - 0, - 200, - 1, - O2_LO_FREQUENCY - 200e6, - np.pi / 2, - "Gaussian(5)", - O2_OUTPUT_CHANNEL, - ) - ) - - qubits = connected_platform.qubits - - freq_width = 300e6 * 2 - freq_step = freq_width // 100 - - delta_frequency_range = np.arange(-freq_width // 2, freq_width // 2, freq_step) - sweeper = Sweeper( - Parameter.frequency, - delta_frequency_range, - pulses=ps.pulses, - type=SweeperType.OFFSET, - ) - - connected_qcm_rf.process_pulse_sequence( - qubits, ps, 1000, 1, 10000, sweepers=[sweeper] - ) - connected_qcm_rf.upload() - connected_qcm_rf.play_sequence() - - amplitude_range = np.linspace(0, 1, 50) - sweeper = Sweeper( - Parameter.amplitude, - amplitude_range, - pulses=ps.pulses, - type=SweeperType.ABSOLUTE, - ) - - connected_qcm_rf.process_pulse_sequence( - qubits, ps, 1000, 1, 10000, sweepers=[sweeper] - ) - connected_qcm_rf.upload() - connected_qcm_rf.play_sequence() diff --git a/tests/test_instruments_qblox_cluster_qrm_rf.py b/tests/test_instruments_qblox_cluster_qrm_rf.py deleted file mode 100644 index 21978461a5..0000000000 --- a/tests/test_instruments_qblox_cluster_qrm_rf.py +++ /dev/null @@ -1,226 +0,0 @@ -import numpy as np -import pytest - -from qibolab.instruments.abstract import Instrument -from qibolab.instruments.qblox.cluster_qrm_rf import QrmRf -from qibolab.instruments.qblox.port import QbloxInputPort, QbloxOutputPort -from qibolab.pulses import DrivePulse, PulseSequence, ReadoutPulse -from qibolab.sweeper import Parameter, Sweeper, SweeperType - -from .qblox_fixtures import connected_controller, controller - -OUTPUT_CHANNEL = "L3-25_a" -INPUT_CHANNEL = "L2-5_a" -ATTENUATION = 38 -LO_FREQUENCY = 7_000_000_000 -TIME_OF_FLIGHT = 500 -ACQUISITION_DURATION = 900 -SETTINGS = { - "o1": { - "attenuation": ATTENUATION, - "lo_frequency": LO_FREQUENCY, - }, - "i1": { - "acquisition_hold_off": TIME_OF_FLIGHT, - "acquisition_duration": ACQUISITION_DURATION, - }, -} - - -def get_qrm_rf(controller): - for module in controller.modules.values(): - if isinstance(module, QrmRf): - return QrmRf(module.name, module.address) - - -@pytest.fixture(scope="module") -def qrm_rf(controller): - return get_qrm_rf(controller) - - -@pytest.fixture(scope="module") -def connected_qrm_rf(connected_controller): - qrm_rf = get_qrm_rf(connected_controller) - qrm_rf.setup(**SETTINGS) - qrm_rf.ports("o1") - qrm_rf.ports("i1", out=False) - qrm_rf.connect(connected_controller.cluster) - - yield qrm_rf - qrm_rf.disconnect() - connected_controller.disconnect() - - -def test_instrument_interface(qrm_rf: QrmRf): - # Test compliance with :class:`qibolab.instruments.abstract.Instrument` interface - for abstract_method in Instrument.__abstractmethods__: - assert hasattr(qrm_rf, abstract_method) - - for attribute in [ - "name", - "address", - "is_connected", - ]: - assert hasattr(qrm_rf, attribute) - - -def test_init(qrm_rf: QrmRf): - assert qrm_rf.device == None - - -def test_setup(qrm_rf: QrmRf): - qrm_rf.setup(**SETTINGS) - assert qrm_rf.settings == SETTINGS - - -@pytest.mark.qpu -def test_connect(connected_qrm_rf: QrmRf): - qrm_rf = connected_qrm_rf - - assert qrm_rf.is_connected - assert not qrm_rf is None - # test configuration after connection - assert qrm_rf.device.get("in0_att") == 0 - assert qrm_rf.device.get("out0_offset_path0") == 0 - assert qrm_rf.device.get("out0_offset_path1") == 0 - assert qrm_rf.device.get("scope_acq_avg_mode_en_path0") == True - assert qrm_rf.device.get("scope_acq_avg_mode_en_path1") == True - assert ( - qrm_rf.device.get("scope_acq_sequencer_select") - == qrm_rf.DEFAULT_SEQUENCERS["i1"] - ) - assert qrm_rf.device.get("scope_acq_trigger_level_path0") == 0 - assert qrm_rf.device.get("scope_acq_trigger_level_path1") == 0 - assert qrm_rf.device.get("scope_acq_trigger_mode_path0") == "sequencer" - assert qrm_rf.device.get("scope_acq_trigger_mode_path1") == "sequencer" - - default_sequencer = qrm_rf.device.sequencers[qrm_rf.DEFAULT_SEQUENCERS["o1"]] - assert default_sequencer.get("connect_out0") == "IQ" - assert default_sequencer.get("connect_acq") == "in0" - assert default_sequencer.get("cont_mode_en_awg_path0") == False - assert default_sequencer.get("cont_mode_en_awg_path1") == False - assert default_sequencer.get("cont_mode_waveform_idx_awg_path0") == 0 - assert default_sequencer.get("cont_mode_waveform_idx_awg_path1") == 0 - assert default_sequencer.get("marker_ovr_en") == True - assert default_sequencer.get("marker_ovr_value") == 15 - assert default_sequencer.get("mixer_corr_gain_ratio") == 1 - assert default_sequencer.get("mixer_corr_phase_offset_degree") == 0 - assert default_sequencer.get("offset_awg_path0") == 0 - assert default_sequencer.get("offset_awg_path1") == 0 - assert default_sequencer.get("sync_en") == False - assert default_sequencer.get("upsample_rate_awg_path0") == 0 - assert default_sequencer.get("upsample_rate_awg_path1") == 0 - - _device_num_sequencers = len(qrm_rf.device.sequencers) - for s in range(1, _device_num_sequencers): - assert qrm_rf.device.sequencers[s].get("connect_out0") == "off" - assert qrm_rf.device.sequencers[s].get("connect_acq") == "off" - - assert qrm_rf.device.get("out0_att") == ATTENUATION - assert qrm_rf.device.get("out0_in0_lo_en") == True - assert qrm_rf.device.get("out0_in0_lo_freq") == LO_FREQUENCY - assert qrm_rf.device.get("out0_in0_lo_freq") == LO_FREQUENCY - - default_sequencer = qrm_rf.device.sequencers[qrm_rf.DEFAULT_SEQUENCERS["o1"]] - - assert default_sequencer.get("mod_en_awg") == True - - assert qrm_rf._ports["o1"].nco_freq == 0 - assert qrm_rf._ports["o1"].nco_phase_offs == 0 - - assert default_sequencer.get("demod_en_acq") == True - - assert qrm_rf._ports["i1"].acquisition_hold_off == TIME_OF_FLIGHT - assert qrm_rf._ports["i1"].acquisition_duration == ACQUISITION_DURATION - assert type(qrm_rf._ports["o1"]) == QbloxOutputPort - assert type(qrm_rf._ports["i1"]) == QbloxInputPort - output_port: QbloxOutputPort = qrm_rf._ports["o1"] - assert output_port.sequencer_number == 0 - input_port: QbloxInputPort = qrm_rf._ports["i1"] - assert input_port.input_sequencer_number == 0 - assert input_port.output_sequencer_number == 0 - - -@pytest.mark.qpu -def test_pulse_sequence(connected_platform, connected_qrm_rf: QrmRf): - ps = PulseSequence() - for channel in connected_qrm_rf.channel_map: - ps.add(DrivePulse(0, 200, 1, 6.8e9, np.pi / 2, "Gaussian(5)", channel)) - ps.add( - ReadoutPulse( - 200, 2000, 1, 7.1e9, np.pi / 2, "Rectangular()", channel, qubit=0 - ) - ) - ps.add( - ReadoutPulse( - 200, 2000, 1, 7.2e9, np.pi / 2, "Rectangular()", channel, qubit=1 - ) - ) - qubits = connected_platform.qubits - connected_qrm_rf._ports["i1"].hardware_demod_en = True - connected_qrm_rf.process_pulse_sequence(qubits, ps, 1000, 1, 10000) - connected_qrm_rf.upload() - connected_qrm_rf.play_sequence() - results = connected_qrm_rf.acquire() - connected_qrm_rf._ports["i1"].hardware_demod_en = False - connected_qrm_rf.process_pulse_sequence(qubits, ps, 1000, 1, 10000) - connected_qrm_rf.upload() - connected_qrm_rf.play_sequence() - results = connected_qrm_rf.acquire() - - -@pytest.mark.qpu -def test_sweepers(connected_platform, connected_qrm_rf: QrmRf): - ps = PulseSequence() - qd_pulses = {} - ro_pulses = {} - for channel in connected_qrm_rf.channel_map: - qd_pulses[0] = DrivePulse( - 0, 200, 1, 7e9, np.pi / 2, "Gaussian(5)", channel, qubit=0 - ) - ro_pulses[0] = ReadoutPulse( - 200, 2000, 1, 7.1e9, np.pi / 2, "Rectangular()", channel, qubit=0 - ) - ro_pulses[1] = ReadoutPulse( - 200, 2000, 1, 7.2e9, np.pi / 2, "Rectangular()", channel, qubit=1 - ) - ps.add(qd_pulses[0], ro_pulses[0], ro_pulses[1]) - - qubits = connected_platform.qubits - - freq_width = 300e6 * 2 - freq_step = freq_width // 100 - - delta_frequency_range = np.arange(-freq_width // 2, freq_width // 2, freq_step) - sweeper = Sweeper( - Parameter.frequency, - delta_frequency_range, - pulses=ro_pulses, - type=SweeperType.OFFSET, - ) - - connected_qrm_rf.process_pulse_sequence( - qubits, ps, 1000, 1, 10000, sweepers=[sweeper] - ) - connected_qrm_rf.upload() - connected_qrm_rf.play_sequence() - results = connected_qrm_rf.acquire() - - delta_duration_range = np.arange(0, 140, 1) - sweeper = Sweeper( - Parameter.duration, - delta_duration_range, - pulses=qd_pulses, - type=SweeperType.ABSOLUTE, - ) - - connected_qrm_rf.process_pulse_sequence( - qubits, ps, 1000, 1, 10000, sweepers=[sweeper] - ) - connected_qrm_rf.upload() - connected_qrm_rf.play_sequence() - results = connected_qrm_rf.acquire() - - -def test_process_acquisition_results(): - pass diff --git a/tests/test_instruments_qblox_controller.py b/tests/test_instruments_qblox_controller.py deleted file mode 100644 index fde3682f07..0000000000 --- a/tests/test_instruments_qblox_controller.py +++ /dev/null @@ -1,78 +0,0 @@ -from unittest.mock import Mock - -import numpy as np -import pytest - -from qibolab import AveragingMode, ExecutionParameters -from qibolab.instruments.qblox.controller import MAX_NUM_BINS, QbloxController -from qibolab.pulses import Gaussian, Pulse, PulseSequence, ReadoutPulse, Rectangular -from qibolab.result import IntegratedResults -from qibolab.sweeper import Parameter, Sweeper - -from .qblox_fixtures import connected_controller, controller - - -def test_init(controller: QbloxController): - assert controller.is_connected is False - assert type(controller.modules) == dict - assert controller.cluster == None - assert controller._reference_clock in ["internal", "external"] - - -def test_sweep_too_many_bins(platform, controller): - """Sweeps that require more bins than the hardware supports should be split - and executed.""" - qubit = platform.qubits[0] - pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Gaussian(5), qubit.drive.name, qubit=0) - ro_pulse = ReadoutPulse( - 0, 40, 0.05, int(3e9), 0.0, Rectangular(), qubit.readout.name, qubit=0 - ) - sequence = PulseSequence(pulse, ro_pulse) - - # These values shall result into execution in two rounds - shots = 128 - sweep_len = (MAX_NUM_BINS + 431) // shots - - mock_data = np.array([1, 2, 3, 4]) - sweep_ampl = Sweeper(Parameter.amplitude, np.random.rand(sweep_len), pulses=[pulse]) - params = ExecutionParameters( - nshots=shots, relaxation_time=10, averaging_mode=AveragingMode.SINGLESHOT - ) - controller._execute_pulse_sequence = Mock( - return_value={ro_pulse.serial: IntegratedResults(mock_data)} - ) - res = controller.sweep( - {0: platform.qubits[0]}, platform.couplers, sequence, params, sweep_ampl - ) - expected_data = np.append(mock_data, mock_data) # - assert np.array_equal(res[ro_pulse.serial].voltage, expected_data) - - -def test_sweep_too_many_sweep_points(platform, controller): - """Sweeps that require too many bins because simply the number of sweep - points is too large should be rejected.""" - qubit = platform.qubits[0] - pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Gaussian(5), qubit.drive.name, qubit=0) - sweep = Sweeper( - Parameter.amplitude, np.random.rand(MAX_NUM_BINS + 17), pulses=[pulse] - ) - params = ExecutionParameters(nshots=12, relaxation_time=10) - with pytest.raises(ValueError, match="total number of sweep points"): - controller.sweep({0: qubit}, {}, PulseSequence(pulse), params, sweep) - - -@pytest.mark.qpu -def connect(connected_controller: QbloxController): - connected_controller.connect() - assert connected_controller.is_connected - for module in connected_controller.modules.values(): - assert module.is_connected - - -@pytest.mark.qpu -def disconnect(connected_controller: QbloxController): - connected_controller.connect() - connected_controller.disconnect() - assert connected_controller.is_connected is False - for module in connected_controller.modules.values(): - assert module.is_connected is False diff --git a/tests/test_instruments_qm.py b/tests/test_instruments_qm.py deleted file mode 100644 index fee8633709..0000000000 --- a/tests/test_instruments_qm.py +++ /dev/null @@ -1,487 +0,0 @@ -from unittest.mock import patch - -import numpy as np -import pytest -from qm import qua - -from qibolab import AcquisitionType, ExecutionParameters, create_platform -from qibolab.instruments.qm import OPXplus, QMController -from qibolab.instruments.qm.acquisition import Acquisition, declare_acquisitions -from qibolab.instruments.qm.controller import controllers_config -from qibolab.instruments.qm.sequence import BakedPulse, QMPulse, Sequence -from qibolab.pulses import FluxPulse, Pulse, PulseSequence, ReadoutPulse, Rectangular -from qibolab.qubits import Qubit -from qibolab.sweeper import Parameter, Sweeper - -from .conftest import set_platform_profile - - -def test_qmpulse(): - pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), "ch0", qubit=0) - qmpulse = QMPulse(pulse) - assert qmpulse.operation == "drive(40, 0.05, Rectangular())" - assert qmpulse.relative_phase == 0 - - -@pytest.mark.parametrize("acquisition_type", AcquisitionType) -def test_qmpulse_declare_output(acquisition_type): - options = ExecutionParameters(acquisition_type=acquisition_type) - pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), "ch0", qubit=0) - qmpulse = QMPulse(pulse) - qubits = {0: Qubit(0, threshold=0.1, iq_angle=0.2)} - if acquisition_type is AcquisitionType.SPECTROSCOPY: - with pytest.raises(KeyError): - with qua.program() as _: - declare_acquisitions([qmpulse], qubits, options) - else: - with qua.program() as _: - declare_acquisitions([qmpulse], qubits, options) - acquisition = qmpulse.acquisition - assert isinstance(acquisition, Acquisition) - if acquisition_type is AcquisitionType.DISCRIMINATION: - assert acquisition.threshold == 0.1 - assert acquisition.cos == np.cos(0.2) - assert acquisition.sin == np.sin(0.2) - assert isinstance(acquisition.shot, qua._dsl._Variable) - assert isinstance(acquisition.shots, qua._dsl._ResultSource) - elif acquisition_type is AcquisitionType.INTEGRATION: - assert isinstance(acquisition.i, qua._dsl._Variable) - assert isinstance(acquisition.q, qua._dsl._Variable) - assert isinstance(acquisition.istream, qua._dsl._ResultSource) - assert isinstance(acquisition.qstream, qua._dsl._ResultSource) - elif acquisition_type is AcquisitionType.RAW: - assert isinstance(acquisition.adc_stream, qua._dsl._ResultSource) - - -def test_qmsequence(): - qd_pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), "ch0", qubit=0) - ro_pulse = ReadoutPulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), "ch1", qubit=0) - qmsequence = Sequence() - with pytest.raises(AttributeError): - qmsequence.add("test") - qmsequence.add(QMPulse(qd_pulse)) - qmsequence.add(QMPulse(ro_pulse)) - assert len(qmsequence.pulse_to_qmpulse) == 2 - assert len(qmsequence.qmpulses) == 2 - - -def test_qmpulse_previous_and_next(): - nqubits = 5 - qmsequence = Sequence() - qd_qmpulses = [] - ro_qmpulses = [] - for qubit in range(nqubits): - qd_pulse = QMPulse( - Pulse( - 0, 40, 0.05, int(3e9), 0.0, Rectangular(), f"drive{qubit}", qubit=qubit - ) - ) - qd_qmpulses.append(qd_pulse) - qmsequence.add(qd_pulse) - for qubit in range(nqubits): - ro_pulse = QMPulse( - ReadoutPulse( - 40, - 100, - 0.05, - int(3e9), - 0.0, - Rectangular(), - f"readout{qubit}", - qubit=qubit, - ) - ) - ro_qmpulses.append(ro_pulse) - qmsequence.add(ro_pulse) - - for qd_qmpulse, ro_qmpulse in zip(qd_qmpulses, ro_qmpulses): - assert len(qd_qmpulse.next_) == 1 - assert len(ro_qmpulse.next_) == 0 - - -def test_qmpulse_previous_and_next_flux(): - y90_pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), f"drive1", qubit=1) - x_pulse_start = Pulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), f"drive2", qubit=2) - flux_pulse = FluxPulse( - start=y90_pulse.finish, - duration=30, - amplitude=0.055, - shape=Rectangular(), - channel="flux2", - qubit=2, - ) - theta_pulse = Pulse(70, 40, 0.05, int(3e9), 0.0, Rectangular(), f"drive1", qubit=1) - x_pulse_end = Pulse(70, 40, 0.05, int(3e9), 0.0, Rectangular(), f"drive2", qubit=2) - - measure_lowfreq = ReadoutPulse( - 110, 100, 0.05, int(3e9), 0.0, Rectangular(), "readout1", qubit=1 - ) - measure_highfreq = ReadoutPulse( - 110, 100, 0.05, int(3e9), 0.0, Rectangular(), "readout2", qubit=2 - ) - - drive11 = QMPulse(y90_pulse) - drive21 = QMPulse(x_pulse_start) - flux2 = QMPulse(flux_pulse) - drive12 = QMPulse(theta_pulse) - drive22 = QMPulse(x_pulse_end) - measure1 = QMPulse(measure_lowfreq) - measure2 = QMPulse(measure_highfreq) - - qmsequence = Sequence() - qmsequence.add(drive11) - qmsequence.add(drive21) - qmsequence.add(flux2) - qmsequence.add(drive12) - qmsequence.add(drive22) - qmsequence.add(measure1) - qmsequence.add(measure2) - assert drive11.next_ == set() - assert drive21.next_ == {flux2} - assert flux2.next_ == {drive12, drive22} - assert drive12.next_ == {measure1} - assert drive22.next_ == {measure2} - - -@pytest.fixture -def qmcontroller(): - name = "test" - address = "0.0.0.0:0" - return QMController(name, address, opxs=[OPXplus("con1")]) - - -@pytest.mark.parametrize("offset", [0.0, 0.005]) -def test_qm_register_port(qmcontroller, offset): - port = qmcontroller.ports((("con1", 1),)) - port.offset = offset - qmcontroller.config.register_port(port) - controllers = qmcontroller.config.controllers - assert controllers == { - "con1": { - "analog_inputs": {1: {}, 2: {}}, - "analog_outputs": {1: {"offset": offset, "filter": {}}}, - "digital_outputs": {}, - } - } - - -def test_qm_register_port_filter(qmcontroller): - port = qmcontroller.ports((("con1", 2),)) - port.offset = 0.005 - port.filter = {"feedforward": [1, -1], "feedback": [0.95]} - qmcontroller.config.register_port(port) - controllers = qmcontroller.config.controllers - assert controllers == { - "con1": { - "analog_inputs": {1: {}, 2: {}}, - "analog_outputs": { - 2: { - "filter": {"feedback": [0.95], "feedforward": [1, -1]}, - "offset": 0.005, - } - }, - "digital_outputs": {}, - } - } - - -@pytest.fixture(params=["qm", "qm_octave"]) -def qmplatform(request): - set_platform_profile() - return create_platform(request.param) - - -def test_controllers_config(qmplatform): - config = controllers_config(list(qmplatform.qubits.values()), time_of_flight=30) - assert len(config.controllers) == 3 - assert len(config.elements) == 10 - - -# TODO: Test connect/disconnect - - -def test_qm_setup(qmplatform): - platform = qmplatform - controller = platform.instruments["qm"] - assert controller.time_of_flight == 280 - - -def test_qm_register_drive_element(qmplatform): - platform = qmplatform - controller = platform.instruments["qm"] - controller.config.register_drive_element( - platform.qubits[0], intermediate_frequency=int(1e6) - ) - assert "drive0" in controller.config.elements - if platform.name == "qm": - target_element = { - "mixInputs": { - "I": ("con3", 2), - "Q": ("con3", 1), - "lo_frequency": 4700000000, - "mixer": "mixer_drive0", - }, - "intermediate_frequency": 1000000, - "operations": {}, - } - assert controller.config.elements["drive0"] == target_element - target_mixer = [ - { - "intermediate_frequency": 1000000, - "lo_frequency": 4700000000, - "correction": [1.0, 0.0, 0.0, 1.0], - } - ] - assert controller.config.mixers["mixer_drive0"] == target_mixer - else: - target_element = { - "RF_inputs": {"port": ("octave3", 1)}, - "digitalInputs": { - "output_switch": {"buffer": 18, "delay": 57, "port": ("con3", 1)} - }, - "intermediate_frequency": 1000000, - "operations": {}, - } - assert controller.config.elements["drive0"] == target_element - assert "mixer_drive0" not in controller.config.mixers - - -def test_qm_register_readout_element(qmplatform): - platform = qmplatform - controller = platform.instruments["qm"] - controller.config.register_readout_element( - platform.qubits[2], int(1e6), controller.time_of_flight, controller.smearing - ) - assert "readout2" in controller.config.elements - if platform.name == "qm": - target_element = { - "mixInputs": { - "I": ("con2", 10), - "Q": ("con2", 9), - "lo_frequency": 7900000000, - "mixer": "mixer_readout2", - }, - "intermediate_frequency": 1000000, - "operations": {}, - "outputs": { - "out1": ("con2", 2), - "out2": ("con2", 1), - }, - "time_of_flight": 280, - "smearing": 0, - } - assert controller.config.elements["readout2"] == target_element - target_mixer = [ - { - "intermediate_frequency": 1000000, - "lo_frequency": 7900000000, - "correction": [1.0, 0.0, 0.0, 1.0], - } - ] - assert controller.config.mixers["mixer_readout2"] == target_mixer - else: - target_element = { - "RF_inputs": {"port": ("octave2", 5)}, - "RF_outputs": {"port": ("octave2", 1)}, - "digitalInputs": { - "output_switch": {"buffer": 18, "delay": 57, "port": ("con2", 9)} - }, - "intermediate_frequency": 1000000, - "operations": {}, - "time_of_flight": 280, - "smearing": 0, - } - assert controller.config.elements["readout2"] == target_element - assert "mixer_readout2" not in controller.config.mixers - - -@pytest.mark.parametrize("pulse_type,qubit", [("drive", 2), ("readout", 1)]) -def test_qm_register_pulse(qmplatform, pulse_type, qubit): - platform = qmplatform - controller = platform.instruments["qm"] - if pulse_type == "drive": - pulse = platform.create_RX_pulse(qubit, start=0) - target_pulse = { - "operation": "control", - "length": pulse.duration, - "digital_marker": "ON", - "waveforms": { - "I": pulse.envelope_waveform_i().serial, - "Q": pulse.envelope_waveform_q().serial, - }, - } - - else: - pulse = platform.create_MZ_pulse(qubit, start=0) - target_pulse = { - "operation": "measurement", - "length": pulse.duration, - "waveforms": {"I": "constant_wf0.003575", "Q": "zero_wf"}, - "digital_marker": "ON", - "integration_weights": { - "cos": "cosine_weights1", - "minus_sin": "minus_sine_weights1", - "sin": "sine_weights1", - }, - } - - controller.config.register_element( - platform.qubits[qubit], pulse, controller.time_of_flight, controller.smearing - ) - qmpulse = QMPulse(pulse) - controller.config.register_pulse(platform.qubits[qubit], qmpulse) - assert controller.config.pulses[qmpulse.operation] == target_pulse - assert target_pulse["waveforms"]["I"] in controller.config.waveforms - assert target_pulse["waveforms"]["Q"] in controller.config.waveforms - - -def test_qm_register_flux_pulse(qmplatform): - qubit = 2 - platform = qmplatform - controller = platform.instruments["qm"] - pulse = FluxPulse( - 0, 30, 0.005, Rectangular(), platform.qubits[qubit].flux.name, qubit - ) - target_pulse = { - "operation": "control", - "length": pulse.duration, - "waveforms": {"single": "constant_wf0.005"}, - } - qmpulse = QMPulse(pulse) - controller.config.register_element(platform.qubits[qubit], pulse) - controller.config.register_pulse(platform.qubits[qubit], qmpulse) - assert controller.config.pulses[qmpulse.operation] == target_pulse - assert target_pulse["waveforms"]["single"] in controller.config.waveforms - - -def test_qm_register_pulses_with_different_frequencies(qmplatform): - platform = qmplatform - controller = platform.instruments["qm"] - qubit = next(iter(platform.qubits.keys())) - qd_pulse1 = platform.create_RX_pulse(qubit, start=0) - qd_pulse2 = platform.create_RX_pulse(qubit, start=qd_pulse1.finish) - qd_pulse2.frequency = qd_pulse2.frequency - int(5e6) - ro_pulse1 = platform.create_MZ_pulse(qubit, start=qd_pulse2.finish) - ro_pulse2 = platform.create_MZ_pulse(qubit, start=qd_pulse2.finish) - ro_pulse2.frequency = ro_pulse2.frequency + int(5e6) - - sequence = PulseSequence() - sequence.add(qd_pulse1) - sequence.add(qd_pulse2) - sequence.add(ro_pulse1) - sequence.add(ro_pulse2) - - if qmplatform.name == "qm_octave": - qmsequence, ro_pulses = controller.create_sequence( - platform.qubits, sequence, [] - ) - assert len(qmsequence.qmpulses) == 4 - elements = {qmpulse.element for qmpulse in qmsequence.qmpulses} - assert len(elements) == 4 - for element in elements: - if "readout" in element: - assert ( - controller.config.elements[element]["RF_inputs"] - == controller.config.elements["readout0"]["RF_inputs"] - ) - assert ( - controller.config.elements[element]["RF_outputs"] - == controller.config.elements["readout0"]["RF_outputs"] - ) - else: - assert ( - controller.config.elements[element]["RF_inputs"] - == controller.config.elements["drive0"]["RF_inputs"] - ) - else: - with pytest.raises(NotImplementedError): - qmsequence, ro_pulses = controller.create_sequence( - platform.qubits, sequence, [] - ) - - -@pytest.mark.parametrize("duration", [0, 30]) -def test_qm_register_baked_pulse(qmplatform, duration): - platform = qmplatform - qubit = platform.qubits[3] - controller = platform.instruments["qm"] - controller.config.register_flux_element(qubit) - pulse = FluxPulse( - 3, duration, 0.05, Rectangular(), qubit.flux.name, qubit=qubit.name - ) - qmpulse = BakedPulse(pulse) - config = controller.config - qmpulse.bake(config, [pulse.duration]) - - assert config.elements["flux3"]["operations"] == { - "baked_Op_0": "flux3_baked_pulse_0" - } - if duration == 0: - assert config.pulses["flux3_baked_pulse_0"] == { - "operation": "control", - "length": 16, - "waveforms": {"single": "flux3_baked_wf_0"}, - } - assert config.waveforms["flux3_baked_wf_0"] == { - "type": "arbitrary", - "samples": 16 * [0], - "is_overridable": False, - } - else: - assert config.pulses["flux3_baked_pulse_0"] == { - "operation": "control", - "length": 32, - "waveforms": {"single": "flux3_baked_wf_0"}, - } - assert config.waveforms["flux3_baked_wf_0"] == { - "type": "arbitrary", - "samples": 30 * [0.05] + 2 * [0], - "is_overridable": False, - } - - -@patch("qibolab.instruments.qm.QMController.execute_program") -def test_qm_qubit_spectroscopy(mocker, qmplatform): - platform = qmplatform - controller = platform.instruments["qm"] - # disable program dump otherwise it will fail if we don't connect - controller.script_file_name = None - sequence = PulseSequence() - qd_pulses = {} - ro_pulses = {} - for qubit in [1, 2, 3]: - qd_pulses[qubit] = platform.create_qubit_drive_pulse( - qubit, start=0, duration=500 - ) - ro_pulses[qubit] = platform.create_qubit_readout_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(qd_pulses[qubit]) - sequence.add(ro_pulses[qubit]) - options = ExecutionParameters(nshots=1024, relaxation_time=100000) - result = controller.play(platform.qubits, platform.couplers, sequence, options) - - -@patch("qibolab.instruments.qm.QMController.execute_program") -def test_qm_duration_sweeper(mocker, qmplatform): - platform = qmplatform - controller = platform.instruments["qm"] - # disable program dump otherwise it will fail if we don't connect - controller.script_file_name = None - qubit = 1 - sequence = PulseSequence() - qd_pulse = platform.create_RX_pulse(qubit, start=0) - sequence.add(qd_pulse) - sequence.add(platform.create_MZ_pulse(qubit, start=qd_pulse.finish)) - sweeper = Sweeper(Parameter.duration, np.arange(2, 12, 2), pulses=[qd_pulse]) - options = ExecutionParameters(nshots=1024, relaxation_time=100000) - if platform.name == "qm": - result = controller.sweep( - platform.qubits, platform.couplers, sequence, options, sweeper - ) - else: - with pytest.raises(ValueError): - # TODO: Figure what is wrong with baking and Octaves - result = controller.sweep( - platform.qubits, platform.couplers, sequence, options, sweeper - ) diff --git a/tests/test_instruments_qmsim.py b/tests/test_instruments_qmsim.py deleted file mode 100644 index 3eaaa8d11e..0000000000 --- a/tests/test_instruments_qmsim.py +++ /dev/null @@ -1,530 +0,0 @@ -"""Test compilation of different pulse sequences using the Quantum Machines -simulator. - -In order to run these tests, provide the following options through the ``pytest`` parser: - address (str): token for the QM simulator - simulation-duration (int): Duration for the simulation in ns. - folder (str): Optional folder to save the generated waveforms for each test. -If a folder is provided the waveforms will be generated and saved during the first run. -For every other run, the generated waveforms will be compared with the saved ones and errors -will be raised if there is disagreement. -If an error is raised or a waveform is generated for the first time, a plot will also be -created so that the user can check if the waveform looks as expected. -""" - -import os - -import h5py -import matplotlib.pyplot as plt -import numpy as np -import pytest -from qibo import gates -from qibo.models import Circuit - -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters, create_platform -from qibolab.backends import QibolabBackend -from qibolab.pulses import SNZ, FluxPulse, PulseSequence, Rectangular -from qibolab.sweeper import Parameter, Sweeper - -from .conftest import set_platform_profile - - -@pytest.fixture(scope="module") -def simulator(request): - """Platform using the QM cloud simulator. - - Requires the address for connecting to the simulator, which is - provided via command line. If an address is not provided these tests - are skipped. - """ - set_platform_profile() - address = request.config.getoption("--address") - if address is None: - pytest.skip("Skipping QM simulator tests because address was not provided.") - - platform = create_platform("qm") - controller = platform.instruments["qm"] - controller.simulation_duration = request.config.getoption("--simulation-duration") - controller.time_of_flight = 280 - # controller.cloud = True - - platform.connect() - yield platform - platform.disconnect() - - -@pytest.fixture(scope="module") -def folder(request): - return request.config.getoption("--folder") - - -def assert_regression(samples, folder=None, filename=None): - """Assert that simulated data agree with the saved regression. - - If a regression does not exist it is created and the corresponding - waveforms are plotted, so that the user can confirm that they look - as expected. - - Args: - samples (dict): Dictionary holding the waveforms as returned by the QM simulator. - filename (str): Name of the file that contains the regressions to compare with. - """ - - def plot(): - plt.figure() - plt.title(filename) - for con in ["con1", "con2", "con3"]: - if hasattr(samples, con): - sample = getattr(samples, con) - sample.plot() - plt.show() - - if folder is None: - plot() - else: - path = os.path.join(folder, f"{filename}.hdf5") - if os.path.exists(path): - file = h5py.File(path, "r") - for con, target_data in file.items(): - sample = getattr(samples, con) - for port, target_waveform in target_data.items(): - waveform = sample.analog[port] - try: - np.testing.assert_allclose(waveform, target_waveform[:]) - except AssertionError as exception: - np.savetxt(os.path.join(folder, "waveform.txt"), waveform) - np.savetxt( - os.path.join(folder, "target_waveform.txt"), - target_waveform[:], - ) - plot() - raise exception - - else: - plot() - if not os.path.exists(folder): - os.mkdir(folder) - file = h5py.File(path, "w") - # TODO: Generalize for arbitrary number of controllers - for con in ["con1", "con2", "con3"]: - if hasattr(samples, con): - sample = getattr(samples, con) - group = file.create_group(con) - for port, waveform in sample.analog.items(): - group.create_dataset(port, data=waveform, compression="gzip") - - -def test_qmsim_resonator_spectroscopy(simulator, folder): - qubits = list(range(simulator.nqubits)) - sequence = PulseSequence() - ro_pulses = {} - for qubit in qubits: - ro_pulses[qubit] = simulator.create_qubit_readout_pulse(qubit, start=0) - sequence.add(ro_pulses[qubit]) - options = ExecutionParameters(nshots=1) - result = simulator.execute_pulse_sequence(sequence, options) - samples = result.get_simulated_samples() - assert_regression(samples, folder, "resonator_spectroscopy") - - -def test_qmsim_qubit_spectroscopy(simulator, folder): - qubits = list(range(simulator.nqubits)) - sequence = PulseSequence() - qd_pulses = {} - ro_pulses = {} - for qubit in qubits: - qd_pulses[qubit] = simulator.create_qubit_drive_pulse( - qubit, start=0, duration=500 - ) - qd_pulses[qubit].amplitude = 0.05 - ro_pulses[qubit] = simulator.create_qubit_readout_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(qd_pulses[qubit]) - sequence.add(ro_pulses[qubit]) - options = ExecutionParameters(nshots=1) - result = simulator.execute_pulse_sequence(sequence, options) - samples = result.get_simulated_samples() - assert_regression(samples, folder, "qubit_spectroscopy") - - -@pytest.mark.parametrize( - "parameter,values", - [ - (Parameter.frequency, np.array([0, 1e6])), - (Parameter.amplitude, np.array([0.5, 1.0])), - (Parameter.relative_phase, np.array([0, 1.0])), - ], -) -def test_qmsim_sweep(simulator, folder, parameter, values): - qubits = list(range(simulator.nqubits)) - sequence = PulseSequence() - qd_pulses = {} - ro_pulses = {} - for qubit in qubits: - qd_pulses[qubit] = simulator.create_RX_pulse(qubit, start=0) - ro_pulses[qubit] = simulator.create_MZ_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(qd_pulses[qubit]) - sequence.add(ro_pulses[qubit]) - pulses = [qd_pulses[qubit] for qubit in qubits] - sweeper = Sweeper(parameter, values, pulses) - options = ExecutionParameters( - nshots=1, - relaxation_time=20, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - result = simulator.sweep(sequence, options, sweeper) - samples = result.get_simulated_samples() - assert_regression(samples, folder, f"sweep_{parameter.name}") - - -def test_qmsim_sweep_bias(simulator, folder): - qubits = list(range(simulator.nqubits)) - sequence = PulseSequence() - ro_pulses = {} - for qubit in qubits: - ro_pulses[qubit] = simulator.create_MZ_pulse(qubit, start=0) - sequence.add(ro_pulses[qubit]) - values = [0, 0.005] - sweeper = Sweeper( - Parameter.bias, values, qubits=[simulator.qubits[q] for q in qubits] - ) - options = ExecutionParameters( - nshots=1, - relaxation_time=20, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - result = simulator.sweep(sequence, options, sweeper) - samples = result.get_simulated_samples() - assert_regression(samples, folder, "sweep_bias") - - -def test_qmsim_sweep_start(simulator, folder): - qubits = list(range(simulator.nqubits)) - sequence = PulseSequence() - qd_pulses = {} - ro_pulses = {} - for qubit in qubits: - qd_pulses[qubit] = simulator.create_RX_pulse(qubit, start=0) - ro_pulses[qubit] = simulator.create_MZ_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(qd_pulses[qubit]) - sequence.add(ro_pulses[qubit]) - values = [20, 40] - pulses = [ro_pulses[qubit] for qubit in qubits] - sweeper = Sweeper(Parameter.start, values, pulses=pulses) - options = ExecutionParameters( - nshots=1, - relaxation_time=0, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - result = simulator.sweep(sequence, options, sweeper) - samples = result.get_simulated_samples() - assert_regression(samples, folder, "sweep_start") - - -def test_qmsim_sweep_start_two_pulses(simulator, folder): - qubits = list(range(simulator.nqubits)) - sequence = PulseSequence() - qd_pulses1 = {} - qd_pulses2 = {} - ro_pulses = {} - for qubit in qubits: - qd_pulses1[qubit] = simulator.create_RX_pulse(qubit, start=0) - qd_pulses2[qubit] = simulator.create_RX_pulse( - qubit, start=qd_pulses1[qubit].finish - ) - ro_pulses[qubit] = simulator.create_MZ_pulse( - qubit, start=qd_pulses2[qubit].finish - ) - sequence.add(qd_pulses1[qubit]) - sequence.add(qd_pulses2[qubit]) - sequence.add(ro_pulses[qubit]) - values = [20, 60] - pulses = [qd_pulses2[qubit] for qubit in qubits] - sweeper = Sweeper(Parameter.start, values, pulses=pulses) - options = ExecutionParameters( - nshots=1, - relaxation_time=0, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - result = simulator.sweep(sequence, options, sweeper) - samples = result.get_simulated_samples() - assert_regression(samples, folder, "sweep_start_two_pulses") - - -def test_qmsim_sweep_duration(simulator, folder): - controller = simulator.instruments["qmopx"] - original_duration = controller.simulation_duration - controller.simulation_duration = 1250 - qubits = list(range(simulator.nqubits)) - sequence = PulseSequence() - qd_pulses = {} - ro_pulses = {} - for qubit in qubits: - qd_pulses[qubit] = simulator.create_RX_pulse(qubit, start=0) - ro_pulses[qubit] = simulator.create_MZ_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(qd_pulses[qubit]) - sequence.add(ro_pulses[qubit]) - values = [20, 60] - pulses = [qd_pulses[qubit] for qubit in qubits] - sweeper = Sweeper(Parameter.duration, values, pulses=pulses) - options = ExecutionParameters( - nshots=1, - relaxation_time=0, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - result = simulator.sweep(sequence, options, sweeper) - samples = result.get_simulated_samples() - assert_regression(samples, folder, "sweep_duration") - controller.simulation_duration = original_duration - - -def test_qmsim_sweep_duration_two_pulses(simulator, folder): - controller = simulator.instruments["qmopx"] - original_duration = controller.simulation_duration - controller.simulation_duration = 1250 - qubits = list(range(simulator.nqubits)) - sequence = PulseSequence() - qd_pulses1 = {} - qd_pulses2 = {} - ro_pulses = {} - for qubit in qubits: - qd_pulses1[qubit] = simulator.create_RX_pulse(qubit, start=0) - qd_pulses2[qubit] = simulator.create_RX_pulse( - qubit, start=qd_pulses1[qubit].finish - ) - ro_pulses[qubit] = simulator.create_MZ_pulse( - qubit, start=qd_pulses2[qubit].finish - ) - sequence.add(qd_pulses1[qubit]) - sequence.add(qd_pulses2[qubit]) - sequence.add(ro_pulses[qubit]) - values = [20, 60] - pulses = [qd_pulses1[qubit] for qubit in qubits] - sweeper = Sweeper(Parameter.duration, values, pulses=pulses) - options = ExecutionParameters( - nshots=1, - relaxation_time=0, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - result = simulator.sweep(sequence, options, sweeper) - samples = result.get_simulated_samples() - assert_regression(samples, folder, "sweep_duration_two_pulses") - controller.simulation_duration = original_duration - - -gatelist = [ - ["I", "I"], - ["RX(pi)", "RX(pi)"], - ["RY(pi)", "RY(pi)"], - ["RX(pi)", "RY(pi)"], - ["RY(pi)", "RX(pi)"], - ["RX(pi/2)", "I"], - ["RY(pi/2)", "I"], - ["RX(pi/2)", "RY(pi/2)"], - ["RY(pi/2)", "RX(pi/2)"], - ["RX(pi/2)", "RY(pi)"], - ["RY(pi/2)", "RX(pi)"], - ["RX(pi)", "RY(pi/2)"], - ["RY(pi)", "RX(pi/2)"], - ["RX(pi/2)", "RX(pi)"], - ["RX(pi)", "RX(pi/2)"], - ["RY(pi/2)", "RY(pi)"], - ["RY(pi)", "RY(pi/2)"], - ["RX(pi)", "I"], - ["RY(pi)", "I"], - ["RX(pi/2)", "RX(pi/2)"], - ["RY(pi/2)", "RY(pi/2)"], -] - - -@pytest.mark.parametrize("count,gate_pair", enumerate(gatelist)) -def test_qmsim_allxy(simulator, folder, count, gate_pair): - qubits = [1, 2, 3, 4] - allxy_pulses = { - "I": lambda qubit, start: None, - "RX(pi)": lambda qubit, start: simulator.create_RX_pulse(qubit, start=start), - "RX(pi/2)": lambda qubit, start: simulator.create_RX90_pulse( - qubit, start=start - ), - "RY(pi)": lambda qubit, start: simulator.create_RX_pulse( - qubit, start=start, relative_phase=np.pi / 2 - ), - "RY(pi/2)": lambda qubit, start: simulator.create_RX90_pulse( - qubit, start=start, relative_phase=np.pi / 2 - ), - } - - sequence = PulseSequence() - for qubit in qubits: - start = 0 - for gate in gate_pair: - pulse = allxy_pulses[gate](qubit, start) - if pulse is not None: - sequence.add(pulse) - start += pulse.duration - sequence.add(simulator.create_MZ_pulse(qubit, start=start)) - - options = ExecutionParameters(nshots=1) - result = simulator.execute_pulse_sequence(sequence, options) - samples = result.get_simulated_samples() - assert_regression(samples, folder, f"allxy{count}") - - -@pytest.mark.parametrize("sweep", [None, "1D", "2D"]) -def test_qmsim_chevron(simulator, folder, sweep): - lowfreq, highfreq = 1, 2 - initialize_1 = simulator.create_RX_pulse(lowfreq, start=0, relative_phase=0) - initialize_2 = simulator.create_RX_pulse(highfreq, start=0, relative_phase=0) - flux_pulse = FluxPulse( - start=initialize_2.finish, - duration=31, - amplitude=0.05, - shape=Rectangular(), - channel=simulator.qubits[highfreq].flux.name, - qubit=highfreq, - ) - measure_lowfreq = simulator.create_qubit_readout_pulse( - lowfreq, start=flux_pulse.finish - ) - measure_highfreq = simulator.create_qubit_readout_pulse( - highfreq, start=flux_pulse.finish - ) - sequence = PulseSequence() - sequence.add(initialize_1) - sequence.add(initialize_2) - sequence.add(flux_pulse) - sequence.add(measure_lowfreq) - sequence.add(measure_highfreq) - - options = ExecutionParameters( - nshots=1, - relaxation_time=0, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - if sweep is None: - result = simulator.execute_pulse_sequence(sequence, options) - elif sweep == "1D": - sweeper = Sweeper(Parameter.duration, [10, 60], pulses=[flux_pulse]) - result = simulator.sweep(sequence, options, sweeper) - elif sweep == "2D": - duration_sweeper = Sweeper(Parameter.duration, [10, 40], pulses=[flux_pulse]) - amplitude_sweeper = Sweeper(Parameter.amplitude, [0.5, 2], pulses=[flux_pulse]) - result = simulator.sweep(sequence, options, duration_sweeper, amplitude_sweeper) - samples = result.get_simulated_samples() - if sweep is None: - assert_regression(samples, folder, "chevron") - else: - assert_regression(samples, folder, f"chevron_sweep_{sweep}") - - -@pytest.mark.parametrize("qubits", [[1, 2], [2, 3]]) -@pytest.mark.parametrize("use_flux_pulse", [True, False]) -def test_qmsim_tune_landscape(simulator, folder, qubits, use_flux_pulse): - lowfreq, highfreq = min(qubits), max(qubits) - - y90_pulse = simulator.create_RX90_pulse(lowfreq, start=0, relative_phase=np.pi / 2) - x_pulse_start = simulator.create_RX_pulse(highfreq, start=0, relative_phase=0) - if use_flux_pulse: - flux_pulse = FluxPulse( - start=y90_pulse.finish, - duration=30, - amplitude=0.055, - shape=Rectangular(), - channel=simulator.qubits[highfreq].flux.name, - qubit=highfreq, - ) - theta_pulse = simulator.create_RX90_pulse( - lowfreq, start=flux_pulse.finish, relative_phase=np.pi / 3 - ) - x_pulse_end = simulator.create_RX_pulse( - highfreq, start=flux_pulse.finish, relative_phase=0 - ) - else: - theta_pulse = simulator.create_RX90_pulse( - lowfreq, start=y90_pulse.finish, relative_phase=np.pi / 3 - ) - x_pulse_end = simulator.create_RX_pulse( - highfreq, start=x_pulse_start.finish, relative_phase=0 - ) - - measure_lowfreq = simulator.create_qubit_readout_pulse( - lowfreq, start=theta_pulse.finish - ) - measure_highfreq = simulator.create_qubit_readout_pulse( - highfreq, start=x_pulse_end.finish - ) - - sequence = x_pulse_start + y90_pulse - if use_flux_pulse: - sequence += flux_pulse - sequence += theta_pulse + x_pulse_end - sequence += measure_lowfreq + measure_highfreq - - options = ExecutionParameters(nshots=1) - result = simulator.execute_pulse_sequence(sequence, options) - samples = result.get_simulated_samples() - qubitstr = "".join(str(q) for q in qubits) - if use_flux_pulse: - assert_regression(samples, folder, f"tune_landscape_{qubitstr}") - else: - assert_regression(samples, folder, f"tune_landscape_noflux_{qubitstr}") - - -@pytest.mark.parametrize("qubit", [2, 3]) -def test_qmsim_snz_pulse(simulator, folder, qubit): - duration = 30 - amplitude = 0.01 - sequence = PulseSequence() - shape = SNZ(t_half_flux_pulse=duration // 2, b_amplitude=2) - channel = simulator.qubits[qubit].flux.name - qd_pulse = simulator.create_RX_pulse(qubit, start=0) - flux_pulse = FluxPulse(qd_pulse.finish, duration, amplitude, shape, channel, qubit) - ro_pulse = simulator.create_MZ_pulse(qubit, start=flux_pulse.finish) - sequence.add(qd_pulse) - sequence.add(flux_pulse) - sequence.add(ro_pulse) - options = ExecutionParameters(nshots=1) - result = simulator.execute_pulse_sequence(sequence, options) - samples = result.get_simulated_samples() - assert_regression(samples, folder, f"snz_pulse_{qubit}") - - -@pytest.mark.parametrize("qubits", [[1, 2], [2, 3]]) -def test_qmsim_bell_circuit(simulator, folder, qubits): - backend = QibolabBackend(simulator) - circuit = Circuit(5) - circuit.add(gates.H(qubits[0])) - circuit.add(gates.CNOT(*qubits)) - circuit.add(gates.M(*qubits)) - result = backend.execute_circuit(circuit, nshots=1) - result = result.execution_result - samples = result.get_simulated_samples() - qubitstr = "".join(str(q) for q in qubits) - assert_regression(samples, folder, f"bell_circuit_{qubitstr}") - - -def test_qmsim_ghz_circuit(simulator, folder): - backend = QibolabBackend(simulator) - circuit = Circuit(5) - circuit.add(gates.H(2)) - circuit.add(gates.CNOT(2, 1)) - circuit.add(gates.CNOT(2, 3)) - circuit.add(gates.M(1, 2, 3)) - result = backend.execute_circuit(circuit, nshots=1) - result = result.execution_result - samples = result.get_simulated_samples() - assert_regression(samples, folder, "ghz_circuit_123") diff --git a/tests/test_instruments_rfsoc.py b/tests/test_instruments_rfsoc.py deleted file mode 100644 index f20e65408f..0000000000 --- a/tests/test_instruments_rfsoc.py +++ /dev/null @@ -1,939 +0,0 @@ -"""Tests for RFSoC driver.""" - -from dataclasses import asdict - -import numpy as np -import pytest -import qibosoq.components.base as rfsoc -import qibosoq.components.pulses as rfsoc_pulses - -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters, create_platform -from qibolab.instruments.rfsoc import RFSoC -from qibolab.instruments.rfsoc.convert import ( - convert, - convert_units_sweeper, - replace_pulse_shape, -) -from qibolab.pulses import Drag, Gaussian, Pulse, PulseSequence, PulseType, Rectangular -from qibolab.qubits import Qubit -from qibolab.result import ( - AveragedIntegratedResults, - AveragedSampleResults, - IntegratedResults, -) -from qibolab.sweeper import Parameter, Sweeper, SweeperType - -from .conftest import get_instrument - - -def test_convert_default(dummy_qrc): - """Test convert function raises errors when parameter have wrong types.""" - platform = create_platform("rfsoc") - integer = 12 - qubits = platform.qubits - sequence = PulseSequence() - sequence.add(Pulse(0, 40, 0.9, 50e6, 0, Drag(5, 2), 0, PulseType.DRIVE, 0)) - parameter = Parameter.frequency - - with pytest.raises(ValueError): - res = convert(integer) # this conversion does not exist - - with pytest.raises(ValueError): - res = convert(qubits, sequence) # the order is wrong - - with pytest.raises(TypeError): - # functools understand that is a convert_parameter and raises an error for the int - _ = convert(parameter, integer) - - -def test_convert_qubit(dummy_qrc): - """Tests conversion from `qibolab.platforms.abstract.Qubit` to - `rfsoc.Qubit`. - - Test conversion for flux qubit and for non-flux qubit. - """ - platform = create_platform("rfsoc") - qubit = platform.qubits[0] - qubit.flux.port = platform.instruments["tii_rfsoc4x2"].ports(4) - qubit.flux.offset = 0.05 - qubit = convert(qubit) - targ = rfsoc.Qubit(0.05, 4) - - assert qubit == targ - - platform = create_platform("rfsoc") - qubit = platform.qubits[0] - qubit.flux = None - qubit = convert(qubit) - targ = rfsoc.Qubit(0.0, None) - - assert qubit == targ - - -def test_replace_pulse_shape(dummy_qrc): - """Test rfsoc pulse conversions.""" - - pulse = rfsoc_pulses.Pulse(50, 0.9, 0, 0, 0.04, "name", "drive", 4, None) - - new_pulse = replace_pulse_shape(pulse, Rectangular(), sampling_rate=1) - assert isinstance(new_pulse, rfsoc_pulses.Rectangular) - for key in asdict(pulse): - assert asdict(pulse)[key] == asdict(new_pulse)[key] - - new_pulse = replace_pulse_shape(pulse, Gaussian(5), sampling_rate=1) - assert isinstance(new_pulse, rfsoc_pulses.Gaussian) - assert new_pulse.rel_sigma == 5 - for key in asdict(pulse): - assert asdict(pulse)[key] == asdict(new_pulse)[key] - - new_pulse = replace_pulse_shape(pulse, Drag(5, 7), sampling_rate=1) - assert isinstance(new_pulse, rfsoc_pulses.Drag) - assert new_pulse.rel_sigma == 5 - assert new_pulse.beta == 7 - for key in asdict(pulse): - assert asdict(pulse)[key] == asdict(new_pulse)[key] - - -def test_convert_pulse(dummy_qrc): - """Tests conversion from `qibolab.pulses.Pulse` to `rfsoc.Pulse`. - - Test drive pulse (gaussian and drag), and readout with LO. - """ - platform = create_platform("rfsoc") - controller = platform.instruments["tii_rfsoc4x2"] - qubit = platform.qubits[0] - qubit.drive.port = controller.ports(4) - qubit.readout.port = controller.ports(2) - qubit.feedback.port = controller.ports(1) - qubit.readout.local_oscillator.frequency = 1e6 - - pulse = Pulse( - start=0, - duration=40, - amplitude=0.9, - frequency=50e6, - relative_phase=0, - shape=Drag(5, 2), - channel=0, - type=PulseType.DRIVE, - qubit=0, - ) - targ = rfsoc_pulses.Drag( - type="drive", - frequency=50, - amplitude=0.9, - start_delay=0, - duration=0.04, - adc=None, - dac=4, - name=pulse.serial, - relative_phase=0, - rel_sigma=5, - beta=2, - ) - assert convert(pulse, platform.qubits, 0, sampling_rate=1) == targ - - pulse = Pulse( - start=0, - duration=40, - amplitude=0.9, - frequency=50e6, - relative_phase=0, - shape=Gaussian(2), - channel=0, - type=PulseType.DRIVE, - qubit=0, - ) - targ = rfsoc_pulses.Gaussian( - frequency=50, - amplitude=0.9, - start_delay=0, - relative_phase=0, - duration=0.04, - name=pulse.serial, - type="drive", - dac=4, - adc=None, - rel_sigma=2, - ) - assert convert(pulse, platform.qubits, 0, sampling_rate=1) == targ - - pulse = Pulse( - start=0, - duration=40, - amplitude=0.9, - frequency=50e6, - relative_phase=0, - shape=Rectangular(), - channel=0, - type=PulseType.READOUT, - qubit=0, - ) - targ = rfsoc_pulses.Rectangular( - frequency=49, - amplitude=0.9, - start_delay=0, - relative_phase=0, - duration=0.04, - name=pulse.serial, - type="readout", - dac=2, - adc=1, - ) - assert convert(pulse, platform.qubits, 0, sampling_rate=1) == targ - - -def test_convert_units_sweeper(dummy_qrc): - """Tests units conversion for `rfsoc.Sweeper` objects. - - Test frequency conversion (with and without LO), start and relative - phase sweepers. - """ - platform = create_platform("rfsoc") - qubit = platform.qubits[0] - qubit.drive.ports = [("name", 4)] - qubit.readout.ports = [("name", 2)] - qubit.feedback.ports = [("name", 1)] - qubit.readout.local_oscillator.frequency = 1e6 - - seq = PulseSequence() - pulse0 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(2), 0, PulseType.DRIVE, 0) - pulse1 = Pulse(40, 40, 0.9, 50e6, 0, Rectangular(), 0, PulseType.READOUT, 0) - seq.add(pulse0) - seq.add(pulse1) - - # frequency sweeper - sweeper = rfsoc.Sweeper( - parameters=[rfsoc.Parameter.FREQUENCY], - indexes=[1], - starts=[0], - stops=[10e6], - expts=100, - ) - sweeper = convert_units_sweeper(sweeper, seq, platform.qubits) - - assert sweeper.starts == [-1] - assert sweeper.stops == [9] - - qubit.readout.local_oscillator.frequency = 0 - sweeper = rfsoc.Sweeper( - parameters=[rfsoc.Parameter.FREQUENCY], - indexes=[1], - starts=[0], - stops=[10e6], - expts=100, - ) - sweeper = convert_units_sweeper(sweeper, seq, platform.qubits) - assert sweeper.starts == [0] - assert sweeper.stops == [10] - - # start sweeper - sweeper = rfsoc.Sweeper( - parameters=[rfsoc.Parameter.DELAY, rfsoc.Parameter.DELAY], - indexes=[0, 1], - starts=[0, 40], - stops=[100, 140], - expts=100, - ) - sweeper = convert_units_sweeper(sweeper, seq, platform.qubits) - assert (sweeper.starts == [0, 0.04]).all() - assert (sweeper.stops == [0.1, 0.14]).all() - - # phase sweeper - sweeper = rfsoc.Sweeper( - parameters=[rfsoc.Parameter.RELATIVE_PHASE], - indexes=[0], - starts=[0], - stops=[np.pi], - expts=180, - ) - sweeper = convert_units_sweeper(sweeper, seq, platform.qubits) - assert sweeper.starts == [0] - assert sweeper.stops == [180] - - -def test_convert_sweep(dummy_qrc): - """Test conversion between `Sweeper` and `rfsoc.Sweeper` objects. - - Test bias sweep, amplitude error, frequency sweep, duration, start. - """ - platform = create_platform("rfsoc") - qubit = platform.qubits[0] - qubit.flux.offset = 0.05 - qubit.flux.ports = [("name", 4)] - qubit.drive.ports = [("name", 4)] - qubit.readout.ports = [("name", 2)] - - seq = PulseSequence() - pulse0 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(2), 0, PulseType.DRIVE, 0) - pulse1 = Pulse(40, 40, 0.9, 50e6, 0, Rectangular(), 0, PulseType.READOUT, 0) - seq.add(pulse0) - seq.add(pulse1) - - sweeper = Sweeper( - parameter=Parameter.bias, values=np.arange(-0.5, +0.5, 0.1), qubits=[qubit] - ) - rfsoc_sweeper = convert(sweeper, seq, platform.qubits) - targ = rfsoc.Sweeper( - expts=10, - parameters=[rfsoc.Parameter.BIAS], - starts=[-0.5], - stops=[0.4], - indexes=[0], - ) - assert targ.expts == rfsoc_sweeper.expts - assert targ.parameters == rfsoc_sweeper.parameters - assert targ.starts == rfsoc_sweeper.starts - assert targ.stops == np.round(rfsoc_sweeper.stops, 2) - assert targ.indexes == rfsoc_sweeper.indexes - sweeper = Sweeper( - parameter=Parameter.bias, - values=np.arange(-0.5, +0.5, 0.1), - qubits=[qubit], - type=SweeperType.OFFSET, - ) - rfsoc_sweeper = convert(sweeper, seq, platform.qubits) - targ = rfsoc.Sweeper( - expts=10, - parameters=[rfsoc.Parameter.BIAS], - starts=[-0.45], - stops=[0.45], - indexes=[0], - ) - assert targ.expts == rfsoc_sweeper.expts - assert targ.parameters == rfsoc_sweeper.parameters - assert targ.starts == rfsoc_sweeper.starts - assert targ.stops == np.round(rfsoc_sweeper.stops, 2) - assert targ.indexes == rfsoc_sweeper.indexes - - qubit.flux.offset = 0.5 - sweeper = Sweeper( - parameter=Parameter.bias, - values=np.arange(0, +1, 0.1), - qubits=[qubit], - type=SweeperType.OFFSET, - ) - with pytest.raises(ValueError): - rfsoc_sweeper = convert(sweeper, seq, platform.qubits) - - sweeper = Sweeper( - parameter=Parameter.frequency, values=np.arange(0, 100, 1), pulses=[pulse0] - ) - rfsoc_sweeper = convert(sweeper, seq, platform.qubits) - targ = rfsoc.Sweeper( - expts=100, - parameters=[rfsoc.Parameter.FREQUENCY], - starts=[0], - stops=[99], - indexes=[0], - ) - assert rfsoc_sweeper == targ - - sweeper = Sweeper( - parameter=Parameter.duration, values=np.arange(40, 100, 1), pulses=[pulse0] - ) - rfsoc_sweeper = convert(sweeper, seq, platform.qubits) - targ = rfsoc.Sweeper( - expts=60, - parameters=[rfsoc.Parameter.DURATION, rfsoc.Parameter.DELAY], - starts=[40, 40], - stops=[99, 99], - indexes=[0, 1], - ) - assert (rfsoc_sweeper.starts == targ.starts).all() - assert (rfsoc_sweeper.stops == targ.stops).all() - assert rfsoc_sweeper.expts == targ.expts - assert rfsoc_sweeper.parameters == targ.parameters - assert rfsoc_sweeper.indexes == targ.indexes - - sweeper = Sweeper( - parameter=Parameter.start, values=np.arange(0, 10, 1), pulses=[pulse0] - ) - rfsoc_sweeper = convert(sweeper, seq, platform.qubits) - targ = rfsoc.Sweeper( - expts=10, - parameters=[rfsoc.Parameter.DELAY], - starts=[0], - stops=[9], - indexes=[0], - ) - assert rfsoc_sweeper == targ - - -def test_rfsoc_init(dummy_qrc): - """Tests instrument can initilize and its attribute are assigned.""" - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - assert instrument.host == "0.0.0.0" - assert instrument.port == 0 - assert isinstance(instrument.cfg, rfsoc.Config) - - -def test_play(mocker, dummy_qrc): - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - seq = PulseSequence() - pulse0 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(2), 0, PulseType.DRIVE, 0) - pulse1 = Pulse(40, 40, 0.9, 50e6, 0, Rectangular(), 0, PulseType.READOUT, 0) - seq.add(pulse0) - seq.add(pulse1) - - nshots = 100 - server_results = ([[np.random.rand(nshots)]], [[np.random.rand(nshots)]]) - mocker.patch("qibosoq.client.connect", return_value=server_results) - parameters = ExecutionParameters( - nshots=nshots, - acquisition_type=AcquisitionType.DISCRIMINATION, - averaging_mode=AveragingMode.SINGLESHOT, - ) - results = instrument.play(platform.qubits, platform.couplers, seq, parameters) - assert pulse1.serial in results.keys() - - parameters = ExecutionParameters( - nshots=nshots, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.SINGLESHOT, - ) - results = instrument.play(platform.qubits, platform.couplers, seq, parameters) - assert pulse1.serial in results.keys() - - parameters = ExecutionParameters( - nshots=nshots, - acquisition_type=AcquisitionType.DISCRIMINATION, - averaging_mode=AveragingMode.CYCLIC, - ) - results = instrument.play(platform.qubits, platform.couplers, seq, parameters) - assert pulse1.serial in results.keys() - - -def test_sweep(mocker, dummy_qrc): - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - qubit = platform.qubits[0] - qubit.flux.offset = 0.05 - qubit.flux.ports = [("name", 4)] - - seq = PulseSequence() - pulse0 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(2), 0, PulseType.DRIVE, 0) - pulse1 = Pulse(40, 40, 0.9, 50e6, 0, Rectangular(), 0, PulseType.READOUT, 0) - seq.add(pulse0) - seq.add(pulse1) - sweeper0 = Sweeper( - parameter=Parameter.frequency, values=np.arange(0, 100, 1), pulses=[pulse0] - ) - sweeper1 = Sweeper( - parameter=Parameter.bias, values=np.arange(0, 0.1, 0.01), qubits=[qubit] - ) - - nshots = 100 - server_results = ( - [[[np.random.rand(nshots)] * 10]], - [[[np.random.rand(nshots)] * 10]], - ) - mocker.patch("qibosoq.client.connect", return_value=server_results) - parameters = ExecutionParameters( - nshots=nshots, - acquisition_type=AcquisitionType.DISCRIMINATION, - averaging_mode=AveragingMode.SINGLESHOT, - ) - results = instrument.sweep( - platform.qubits, platform.couplers, seq, parameters, sweeper0, sweeper1 - ) - assert pulse1.serial in results.keys() - - parameters = ExecutionParameters( - nshots=nshots, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.SINGLESHOT, - ) - results = instrument.sweep( - platform.qubits, platform.couplers, seq, parameters, sweeper0, sweeper1 - ) - assert pulse1.serial in results.keys() - - parameters = ExecutionParameters( - nshots=nshots, - acquisition_type=AcquisitionType.DISCRIMINATION, - averaging_mode=AveragingMode.CYCLIC, - ) - results = instrument.sweep( - platform.qubits, platform.couplers, seq, parameters, sweeper0, sweeper1 - ) - assert pulse1.serial in results.keys() - - -def test_validate_input_command(dummy_qrc): - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - seq = PulseSequence() - pulse0 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(2), 0, PulseType.DRIVE, 0) - pulse1 = Pulse(40, 40, 0.9, 50e6, 0, Rectangular(), 0, PulseType.READOUT, 0) - seq.add(pulse0) - seq.add(pulse1) - - parameters = ExecutionParameters(acquisition_type=AcquisitionType.RAW) - with pytest.raises(NotImplementedError): - results = instrument.play(platform.qubits, platform.couplers, seq, parameters) - - parameters = ExecutionParameters(fast_reset=True) - with pytest.raises(NotImplementedError): - results = instrument.play(platform.qubits, platform.couplers, seq, parameters) - - -def test_update_cfg(mocker, dummy_qrc): - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - seq = PulseSequence() - pulse0 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(2), 0, PulseType.DRIVE, 0) - pulse1 = Pulse(40, 40, 0.9, 50e6, 0, Rectangular(), 0, PulseType.READOUT, 0) - seq.add(pulse0) - seq.add(pulse1) - - nshots = 333 - relax_time = 1e6 - server_results = ([[np.random.rand(nshots)]], [[np.random.rand(nshots)]]) - mocker.patch("qibosoq.client.connect", return_value=server_results) - parameters = ExecutionParameters( - nshots=nshots, - acquisition_type=AcquisitionType.DISCRIMINATION, - averaging_mode=AveragingMode.SINGLESHOT, - relaxation_time=relax_time, - ) - results = instrument.play(platform.qubits, platform.couplers, seq, parameters) - assert instrument.cfg.reps == nshots - relax_time = relax_time * 1e-3 - assert instrument.cfg.relaxation_time == relax_time - - -def test_classify_shots(dummy_qrc): - """Creates fake IQ values and check classification works as expected.""" - qubit0 = Qubit(name="q0", threshold=1, iq_angle=np.pi / 2) - qubit1 = Qubit( - name="q1", - ) - i_val = [0] * 7 - q_val = [-5, -1.5, -0.5, 0, 0.5, 1.5, 5] - - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - shots = instrument.classify_shots(i_val, q_val, qubit0) - target_shots = np.array([1, 1, 0, 0, 0, 0, 0]) - - assert (target_shots == shots).all() - shots = instrument.classify_shots(i_val, q_val, qubit1) - assert shots.shape == (7,) - - -def test_merge_sweep_results(dummy_qrc): - """Creates fake dictionary of results and check merging works as - expected.""" - dict_a = {"serial1": AveragedIntegratedResults(np.array([0 + 1j * 1]))} - dict_b = { - "serial1": AveragedIntegratedResults(np.array([4 + 1j * 4])), - "serial2": AveragedIntegratedResults(np.array([5 + 1j * 5])), - } - dict_c = {} - targ_dict = { - "serial1": AveragedIntegratedResults(np.array([0 + 1j * 1, 4 + 1j * 4])), - "serial2": AveragedIntegratedResults(np.array([5 + 1j * 5])), - } - - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - out_dict1 = instrument.merge_sweep_results(dict_a, dict_b) - out_dict2 = instrument.merge_sweep_results(dict_c, dict_a) - - assert targ_dict.keys() == out_dict1.keys() - assert ( - out_dict1["serial1"].serialize["MSR[V]"] - == targ_dict["serial1"].serialize["MSR[V]"] - ).all() - assert ( - out_dict1["serial1"].serialize["MSR[V]"] - == targ_dict["serial1"].serialize["MSR[V]"] - ).all() - - assert dict_a.keys() == out_dict2.keys() - assert ( - out_dict2["serial1"].serialize["MSR[V]"] - == dict_a["serial1"].serialize["MSR[V]"] - ).all() - assert ( - out_dict2["serial1"].serialize["MSR[V]"] - == dict_a["serial1"].serialize["MSR[V]"] - ).all() - - -def test_get_if_python_sweep(dummy_qrc): - """Creates pulse sequences and check if they can be swept by the firmware. - - Qibosoq does not support sweep on readout frequency, more than one - sweep at the same time, sweep on channels where multiple pulses are - sent. If Qibosoq does not support the sweep, the driver will use a - python loop - """ - - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - sequence_1 = PulseSequence() - sequence_1.add(platform.create_RX_pulse(qubit=0, start=0)) - sequence_1.add(platform.create_MZ_pulse(qubit=0, start=100)) - - sweep1 = Sweeper( - parameter=Parameter.frequency, - values=np.arange(10, 100, 10), - pulses=[sequence_1[0]], - ) - sweep2 = Sweeper( - parameter=Parameter.frequency, - values=np.arange(10, 100, 10), - pulses=[sequence_1[1]], - ) - sweep3 = Sweeper( - parameter=Parameter.amplitude, - values=np.arange(0.01, 0.5, 0.1), - pulses=[sequence_1[1]], - ) - sweep1 = convert(sweep1, sequence_1, platform.qubits) - sweep2 = convert(sweep2, sequence_1, platform.qubits) - sweep3 = convert(sweep3, sequence_1, platform.qubits) - - assert instrument.get_if_python_sweep(sequence_1, sweep2) - assert not instrument.get_if_python_sweep(sequence_1, sweep1) - assert not instrument.get_if_python_sweep(sequence_1, sweep3) - - sequence_2 = PulseSequence() - sequence_2.add(platform.create_RX_pulse(qubit=0, start=0)) - - sweep1 = Sweeper( - parameter=Parameter.frequency, - values=np.arange(10, 100, 10), - pulses=[sequence_2[0]], - ) - sweep2 = Sweeper( - parameter=Parameter.amplitude, - values=np.arange(0.01, 0.5, 0.1), - pulses=[sequence_2[0]], - ) - sweep1 = convert(sweep1, sequence_2, platform.qubits) - sweep2 = convert(sweep2, sequence_2, platform.qubits) - - assert not instrument.get_if_python_sweep(sequence_2, sweep1) - assert not instrument.get_if_python_sweep(sequence_2, sweep1, sweep2) - - # TODO repetition - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - sequence_1 = PulseSequence() - sequence_1.add(platform.create_RX_pulse(qubit=0, start=0)) - sweep1 = Sweeper( - parameter=Parameter.frequency, - values=np.arange(10, 100, 10), - pulses=[sequence_1[0]], - ) - sweep2 = Sweeper( - parameter=Parameter.relative_phase, - values=np.arange(0, 1, 0.01), - pulses=[sequence_1[0]], - ) - sweep3 = Sweeper( - parameter=Parameter.bias, - values=np.arange(-0.1, 0.1, 0.001), - qubits=[platform.qubits[0]], - ) - sweep1 = convert(sweep1, sequence_1, platform.qubits) - sweep2 = convert(sweep2, sequence_1, platform.qubits) - sweep3 = convert(sweep3, sequence_1, platform.qubits) - assert not instrument.get_if_python_sweep(sequence_1, sweep1, sweep2, sweep3) - - platform.qubits[0].flux.offset = 0.5 - sweep1 = Sweeper(parameter=Parameter.bias, values=np.arange(-1, 1, 0.1), qubits=[0]) - with pytest.raises(ValueError): - sweep1 = convert(sweep1, sequence_1, platform.qubits) - - -def test_convert_av_sweep_results(dummy_qrc): - """Qibosoq sends results using nested lists, check if the conversion to - dictionary of AveragedResults, for averaged sweep, works as expected.""" - - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(qubit=0, start=0)) - sequence.add(platform.create_MZ_pulse(qubit=0, start=100)) - sequence.add(platform.create_MZ_pulse(qubit=0, start=200)) - sweep1 = Sweeper( - parameter=Parameter.frequency, - values=np.arange(10, 35, 10), - pulses=[sequence[0]], - ) - sweep1 = convert(sweep1, sequence, platform.qubits) - serial1 = sequence[1].serial - serial2 = sequence[2].serial - - avgi = [[[1, 2, 3], [4, 1, 2]]] - avgq = [[[7, 8, 9], [-1, -2, -3]]] - - execution_parameters = ExecutionParameters( - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - out_dict = instrument.convert_sweep_results( - sequence.ro_pulses, platform.qubits, avgi, avgq, execution_parameters - ) - targ_dict = { - serial1: AveragedIntegratedResults( - np.array([1, 2, 3]) + 1j * np.array([7, 8, 9]) - ), - serial2: AveragedIntegratedResults( - np.array([4, 1, 2]) + 1j * np.array([-1, -2, -3]) - ), - } - - assert ( - out_dict[serial1].serialize["i[V]"] == targ_dict[serial1].serialize["i[V]"] - ).all() - assert ( - out_dict[serial1].serialize["q[V]"] == targ_dict[serial1].serialize["q[V]"] - ).all() - assert ( - out_dict[serial2].serialize["i[V]"] == targ_dict[serial2].serialize["i[V]"] - ).all() - assert ( - out_dict[serial2].serialize["q[V]"] == targ_dict[serial2].serialize["q[V]"] - ).all() - - -def test_convert_nav_sweep_results(dummy_qrc): - """Qibosoq sends results using nested lists, check if the conversion to - dictionary of ExecutionResults, for not averaged sweep, works as - expected.""" - platform = create_platform("rfsoc") - instrument = platform.instruments["tii_rfsoc4x2"] - - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(qubit=0, start=0)) - sequence.add(platform.create_MZ_pulse(qubit=0, start=100)) - sequence.add(platform.create_MZ_pulse(qubit=0, start=200)) - sweep1 = Sweeper( - parameter=Parameter.frequency, - values=np.arange(10, 35, 10), - pulses=[sequence[0]], - ) - sweep1 = convert(sweep1, sequence, platform.qubits) - serial1 = sequence[1].serial - serial2 = sequence[2].serial - - avgi = [[[[1, 1], [2, 2], [3, 3]], [[4, 4], [1, 1], [2, 2]]]] - avgq = [[[[7, 7], [8, 8], [9, 9]], [[-1, -1], [-2, -2], [-3, -3]]]] - - execution_parameters = ExecutionParameters( - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - out_dict = instrument.convert_sweep_results( - sequence.ro_pulses, platform.qubits, avgi, avgq, execution_parameters - ) - targ_dict = { - serial1: AveragedIntegratedResults( - np.array([1, 1, 2, 2, 3, 3]) + 1j * np.array([7, 7, 8, 8, 9, 9]) - ), - serial2: AveragedIntegratedResults( - np.array([4, 4, 1, 1, 2, 2]) + 1j * np.array([-1, -1, -2, -2, -3, -3]) - ), - } - - assert ( - out_dict[serial1].serialize["i[V]"] == targ_dict[serial1].serialize["i[V]"] - ).all() - assert ( - out_dict[serial1].serialize["q[V]"] == targ_dict[serial1].serialize["q[V]"] - ).all() - assert ( - out_dict[serial2].serialize["i[V]"] == targ_dict[serial2].serialize["i[V]"] - ).all() - assert ( - out_dict[serial2].serialize["q[V]"] == targ_dict[serial2].serialize["q[V]"] - ).all() - - -@pytest.fixture(scope="module") -def instrument(connected_platform): - return get_instrument(connected_platform, RFSoC) - - -@pytest.mark.qpu -def test_call_executepulsesequence(connected_platform, instrument): - """Executes a PulseSequence and check if result shape is as expected. - - Both for averaged results and not averaged results. - """ - platform = connected_platform - instrument = platform.instruments["tii_rfsoc4x2"] - - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(qubit=0, start=0)) - sequence.add(platform.create_MZ_pulse(qubit=0, start=100)) - - instrument.cfg.average = False - i_vals_nav, q_vals_nav = instrument._execute_pulse_sequence( - sequence, platform.qubits, rfsoc.OperationCode.EXECUTE_PULSE_SEQUENCE - ) - instrument.cfg.average = True - i_vals_av, q_vals_av = instrument._execute_pulse_sequence( - sequence, platform.qubits, rfsoc.OperationCode.EXECUTE_PULSE_SEQUENCE - ) - - assert np.shape(i_vals_nav) == (1, 1, 1000) - assert np.shape(q_vals_nav) == (1, 1, 1000) - assert np.shape(i_vals_av) == (1, 1) - assert np.shape(q_vals_av) == (1, 1) - - -@pytest.mark.qpu -def test_call_execute_sweeps(connected_platform, instrument): - """Execute a firmware sweep and check if result shape is as expected. - - Both for averaged results and not averaged results. - """ - platform = connected_platform - instrument = platform.instruments["tii_rfsoc4x2"] - - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(qubit=0, start=0)) - sequence.add(platform.create_MZ_pulse(qubit=0, start=100)) - sweep = Sweeper( - parameter=Parameter.frequency, - values=np.arange(10, 35, 10), - pulses=[sequence[0]], - ) - expts = len(sweep.values) - - sweep = [convert(sweep, sequence, platform.qubits)] - instrument.cfg.average = False - i_vals_nav, q_vals_nav = instrument._execute_sweeps( - sequence, platform.qubits, sweep - ) - instrument.cfg.average = True - i_vals_av, q_vals_av = instrument._execute_sweeps(sequence, platform.qubits, sweep) - - assert np.shape(i_vals_nav) == (1, 1, expts, 1000) - assert np.shape(q_vals_nav) == (1, 1, expts, 1000) - assert np.shape(i_vals_av) == (1, 1, expts) - assert np.shape(q_vals_av) == (1, 1, expts) - - -@pytest.mark.qpu -def test_play_qpu(connected_platform, instrument): - """Sends a PulseSequence using `play` and check results are what - expected.""" - platform = connected_platform - instrument = platform.instruments["tii_rfsoc4x2"] - - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(qubit=0, start=0)) - sequence.add(platform.create_MZ_pulse(qubit=0, start=100)) - - out_dict = instrument.play( - platform.qubits, - sequence, - ExecutionParameters(acquisition_type=AcquisitionType.INTEGRATION), - ) - - assert sequence[1].serial in out_dict - assert isinstance(out_dict[sequence[1].serial], IntegratedResults) - assert np.shape(out_dict[sequence[1].serial].voltage_i) == (1000,) - - -@pytest.mark.qpu -def test_sweep_qpu(connected_platform, instrument): - """Sends a PulseSequence using `sweep` and check results are what - expected.""" - platform = connected_platform - instrument = platform.instruments["tii_rfsoc4x2"] - - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(qubit=0, start=0)) - sequence.add(platform.create_MZ_pulse(qubit=0, start=100)) - sweep = Sweeper( - parameter=Parameter.frequency, - values=np.arange(10, 35, 10), - pulses=[sequence[0]], - ) - - out_dict1 = instrument.sweep( - platform.qubits, - platform.couplers, - sequence, - ExecutionParameters( - relaxation_time=100_000, averaging_mode=AveragingMode.CYCLIC - ), - sweep, - ) - out_dict2 = instrument.sweep( - platform.qubits, - platform.couplers, - sequence, - ExecutionParameters( - relaxation_time=100_000, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.SINGLESHOT, - ), - sweep, - ) - - assert sequence[1].serial in out_dict1 - assert sequence[1].serial in out_dict2 - assert isinstance(out_dict1[sequence[1].serial], AveragedSampleResults) - assert isinstance(out_dict2[sequence[1].serial], IntegratedResults) - assert np.shape(out_dict2[sequence[1].serial].voltage_i) == ( - 1000, - len(sweep.values), - ) - assert np.shape(out_dict1[sequence[1].serial].statistical_frequency) == ( - len(sweep.values), - ) - - -@pytest.mark.qpu -def test_python_reqursive_sweep(connected_platform, instrument): - """Sends a PulseSequence directly to `python_reqursive_sweep` and check - results are what expected.""" - platform = connected_platform - instrument = platform.instruments["tii_rfsoc4x2"] - - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(qubit=0, start=0)) - sequence.add(platform.create_MZ_pulse(qubit=0, start=100)) - sweep1 = Sweeper( - parameter=Parameter.amplitude, - values=np.arange(0.01, 0.03, 10), - pulses=[sequence[0]], - ) - sweep2 = Sweeper( - parameter=Parameter.frequency, - values=np.arange(10, 35, 10), - pulses=[sequence[0]], - ) - - out_dict = instrument.sweep( - platform.qubits, - platform.couplers, - sequence, - ExecutionParameters( - relaxation_time=100_000, averaging_mode=AveragingMode.CYCLIC - ), - sweep1, - sweep2, - ) - - assert sequence[1].serial in out_dict diff --git a/tests/test_instruments_zhinst.py b/tests/test_instruments_zhinst.py deleted file mode 100644 index bbea85ecb6..0000000000 --- a/tests/test_instruments_zhinst.py +++ /dev/null @@ -1,973 +0,0 @@ -import math -from collections import defaultdict - -import laboneq.dsl.experiment.pulse as laboneq_pulse -import laboneq.simple as lo -import numpy as np -import pytest - -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters, create_platform -from qibolab.instruments.zhinst import ( - ProcessedSweeps, - ZhPulse, - Zurich, - acquire_channel_name, - classify_sweepers, - measure_channel_name, -) -from qibolab.pulses import ( - IIR, - SNZ, - CouplerFluxPulse, - Drag, - FluxPulse, - Gaussian, - Pulse, - PulseSequence, - PulseType, - ReadoutPulse, - Rectangular, -) -from qibolab.sweeper import Parameter, Sweeper -from qibolab.unrolling import batch - -from .conftest import get_instrument - - -@pytest.mark.parametrize( - "pulse", - [ - Pulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), "ch0", qubit=0), - Pulse(0, 40, 0.05, int(3e9), 0.0, Gaussian(5), "ch0", qubit=0), - Pulse(0, 40, 0.05, int(3e9), 0.0, Gaussian(5), "ch0", qubit=0), - Pulse(0, 40, 0.05, int(3e9), 0.0, Drag(5, 0.4), "ch0", qubit=0), - Pulse(0, 40, 0.05, int(3e9), 0.0, SNZ(10, 0.01), "ch0", qubit=0), - Pulse( - 0, - 40, - 0.05, - int(3e9), - 0.0, - IIR([10, 1], [0.4, 1], target=Gaussian(5)), - "ch0", - qubit=0, - ), - ], -) -def test_zhpulse_pulse_conversion(pulse): - shape = pulse.shape - zhpulse = ZhPulse(pulse).zhpulse - assert isinstance(zhpulse, laboneq_pulse.Pulse) - if isinstance(shape, (SNZ, IIR)): - assert len(zhpulse.samples) == 80 - else: - assert zhpulse.length == 40e-9 - - -def test_zhpulse_add_sweeper(): - pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Gaussian(5), "ch", qubit=0) - zhpulse = ZhPulse(pulse) - assert zhpulse.zhsweepers == [] - assert zhpulse.delay_sweeper is None - - zhpulse.add_sweeper( - Parameter.duration, lo.SweepParameter(values=np.array([1, 2, 3])) - ) - assert len(zhpulse.zhsweepers) == 1 - assert zhpulse.delay_sweeper is None - - zhpulse.add_sweeper( - Parameter.start, lo.SweepParameter(values=np.array([4, 5, 6, 7])) - ) - assert len(zhpulse.zhsweepers) == 1 - assert zhpulse.delay_sweeper is not None - - zhpulse.add_sweeper( - Parameter.amplitude, lo.SweepParameter(values=np.array([3, 2, 1, 0])) - ) - assert len(zhpulse.zhsweepers) == 2 - assert zhpulse.delay_sweeper is not None - - -def test_measure_channel_name(dummy_qrc): - platform = create_platform("zurich") - qubits = platform.qubits.values() - meas_ch_names = {measure_channel_name(q) for q in qubits} - assert len(qubits) > 0 - assert len(meas_ch_names) == len(qubits) - - -def test_acquire_channel_name(dummy_qrc): - platform = create_platform("zurich") - qubits = platform.qubits.values() - acq_ch_names = {acquire_channel_name(q) for q in qubits} - assert len(qubits) > 0 - assert len(acq_ch_names) == len(qubits) - - -def test_classify_sweepers(dummy_qrc): - platform = create_platform("zurich") - qubit_id, qubit = 0, platform.qubits[0] - pulse_1 = Pulse(0, 40, 0.05, int(3e9), 0.0, Gaussian(5), "ch0", qubit=qubit_id) - pulse_2 = Pulse( - 0, - 40, - 0.05, - int(3e9), - 0.0, - Rectangular(), - "ch7", - PulseType.READOUT, - qubit=qubit_id, - ) - amplitude_sweeper = Sweeper(Parameter.amplitude, np.array([1, 2, 3]), [pulse_1]) - readout_amplitude_sweeper = Sweeper( - Parameter.amplitude, np.array([1, 2, 3, 4, 5]), [pulse_2] - ) - freq_sweeper = Sweeper(Parameter.frequency, np.array([4, 5, 6, 7]), [pulse_1]) - bias_sweeper = Sweeper(Parameter.bias, np.array([3, 2, 1]), qubits=[qubit]) - nt_sweeps, rt_sweeps = classify_sweepers( - [amplitude_sweeper, readout_amplitude_sweeper, bias_sweeper, freq_sweeper] - ) - - assert amplitude_sweeper in rt_sweeps - assert freq_sweeper in rt_sweeps - assert bias_sweeper in nt_sweeps - assert readout_amplitude_sweeper in nt_sweeps - - -def test_processed_sweeps_pulse_properties(dummy_qrc): - platform = create_platform("zurich") - qubit_id_1, qubit_1 = 0, platform.qubits[0] - qubit_id_2, qubit_2 = 3, platform.qubits[3] - pulse_1 = Pulse( - 0, 40, 0.05, int(3e9), 0.0, Gaussian(5), qubit_1.drive.name, qubit=qubit_id_1 - ) - pulse_2 = Pulse( - 0, 40, 0.05, int(3e9), 0.0, Gaussian(5), qubit_2.drive.name, qubit=qubit_id_2 - ) - sweeper_amplitude = Sweeper( - Parameter.amplitude, np.array([1, 2, 3]), [pulse_1, pulse_2] - ) - sweeper_duration = Sweeper(Parameter.duration, np.array([1, 2, 3, 4]), [pulse_2]) - processed_sweeps = ProcessedSweeps( - [sweeper_duration, sweeper_amplitude], qubits=platform.qubits - ) - - assert len(processed_sweeps.sweeps_for_pulse(pulse_1)) == 1 - assert processed_sweeps.sweeps_for_pulse(pulse_1)[0][0] == Parameter.amplitude - assert isinstance( - processed_sweeps.sweeps_for_pulse(pulse_1)[0][1], lo.SweepParameter - ) - assert len(processed_sweeps.sweeps_for_pulse(pulse_2)) == 2 - - assert len(processed_sweeps.sweeps_for_sweeper(sweeper_amplitude)) == 2 - parallel_sweep_ids = { - s.uid for s in processed_sweeps.sweeps_for_sweeper(sweeper_amplitude) - } - assert len(parallel_sweep_ids) == 2 - assert processed_sweeps.sweeps_for_pulse(pulse_1)[0][1].uid in parallel_sweep_ids - assert any( - s.uid in parallel_sweep_ids - for _, s in processed_sweeps.sweeps_for_pulse(pulse_2) - ) - - assert len(processed_sweeps.sweeps_for_sweeper(sweeper_duration)) == 1 - pulse_2_sweep_ids = {s.uid for _, s in processed_sweeps.sweeps_for_pulse(pulse_2)} - assert len(pulse_2_sweep_ids) == 2 - assert ( - processed_sweeps.sweeps_for_sweeper(sweeper_duration)[0].uid - in pulse_2_sweep_ids - ) - - assert processed_sweeps.channels_with_sweeps() == set() - - -def test_processed_sweeps_frequency(dummy_qrc): - platform = create_platform("zurich") - qubit_id, qubit = 1, platform.qubits[1] - pulse = Pulse( - 0, 40, 0.05, int(3e9), 0.0, Gaussian(5), qubit.drive.name, qubit=qubit_id - ) - freq_sweeper = Sweeper(Parameter.frequency, np.array([1, 2, 3]), [pulse]) - processed_sweeps = ProcessedSweeps([freq_sweeper], platform.qubits) - - # Frequency sweepers should result into channel property sweeps - assert len(processed_sweeps.sweeps_for_pulse(pulse)) == 0 - assert processed_sweeps.channels_with_sweeps() == {qubit.drive.name} - assert len(processed_sweeps.sweeps_for_channel(qubit.drive.name)) == 1 - - with pytest.raises(ValueError): - flux_pulse = Pulse( - 0, - 40, - 0.05, - int(3e9), - 0.0, - Gaussian(5), - qubit.flux.name, - PulseType.FLUX, - qubit=qubit_id, - ) - freq_sweeper = Sweeper( - Parameter.frequency, np.array([1, 3, 5, 7]), [flux_pulse] - ) - ProcessedSweeps([freq_sweeper], platform.qubits) - - -def test_processed_sweeps_readout_amplitude(dummy_qrc): - platform = create_platform("zurich") - qubit_id, qubit = 0, platform.qubits[0] - readout_ch = measure_channel_name(qubit) - pulse_readout = Pulse( - 0, - 40, - 0.05, - int(3e9), - 0.0, - Rectangular(), - readout_ch, - PulseType.READOUT, - qubit_id, - ) - readout_amplitude_sweeper = Sweeper( - Parameter.amplitude, np.array([1, 2, 3, 4]), [pulse_readout] - ) - processed_sweeps = ProcessedSweeps( - [readout_amplitude_sweeper], qubits=platform.qubits - ) - - # Readout amplitude should result into channel property (gain) sweep - assert len(processed_sweeps.sweeps_for_pulse(pulse_readout)) == 0 - assert processed_sweeps.channels_with_sweeps() == { - readout_ch, - } - assert len(processed_sweeps.sweeps_for_channel(readout_ch)) == 1 - - -def test_zhinst_setup(dummy_qrc): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - assert IQM5q.time_of_flight == 75 - - -def test_zhsequence(dummy_qrc): - IQM5q = create_platform("zurich") - controller = IQM5q.instruments["EL_ZURO"] - - drive_channel, readout_channel = IQM5q.qubits[0].drive.name, measure_channel_name( - IQM5q.qubits[0] - ) - qd_pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), drive_channel, qubit=0) - ro_pulse = ReadoutPulse( - 0, 40, 0.05, int(3e9), 0.0, Rectangular(), readout_channel, qubit=0 - ) - sequence = PulseSequence() - sequence.add(qd_pulse) - sequence.add(qd_pulse) - sequence.add(ro_pulse) - - zhsequence = controller.sequence_zh(sequence, IQM5q.qubits) - - assert len(zhsequence) == 2 - assert len(zhsequence[drive_channel]) == 2 - assert len(zhsequence[readout_channel]) == 1 - - with pytest.raises(AttributeError): - controller.sequence_zh("sequence", IQM5q.qubits) - - -def test_zhsequence_couplers(dummy_qrc): - IQM5q = create_platform("zurich") - controller = IQM5q.instruments["EL_ZURO"] - - drive_channel, readout_channel = IQM5q.qubits[0].drive.name, measure_channel_name( - IQM5q.qubits[0] - ) - couplerflux_channel = IQM5q.couplers[0].flux.name - qd_pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), drive_channel, qubit=0) - ro_pulse = ReadoutPulse( - 0, 40, 0.05, int(3e9), 0.0, Rectangular(), readout_channel, qubit=0 - ) - qc_pulse = CouplerFluxPulse( - 0, 40, 0.05, Rectangular(), couplerflux_channel, qubit=3 - ) - sequence = PulseSequence() - sequence.add(qd_pulse) - sequence.add(ro_pulse) - sequence.add(qc_pulse) - - zhsequence = controller.sequence_zh(sequence, IQM5q.qubits) - - assert len(zhsequence) == 3 - assert len(zhsequence[couplerflux_channel]) == 1 - - -def test_zhsequence_multiple_ro(dummy_qrc): - platform = create_platform("zurich") - readout_channel = measure_channel_name(platform.qubits[0]) - sequence = PulseSequence() - qd_pulse = Pulse(0, 40, 0.05, int(3e9), 0.0, Rectangular(), "ch0", qubit=0) - sequence.add(qd_pulse) - ro_pulse = ReadoutPulse( - 0, 40, 0.05, int(3e9), 0.0, Rectangular(), readout_channel, qubit=0 - ) - sequence.add(ro_pulse) - ro_pulse = ReadoutPulse( - 0, 5000, 0.05, int(3e9), 0.0, Rectangular(), readout_channel, qubit=0 - ) - sequence.add(ro_pulse) - platform = create_platform("zurich") - - controller = platform.instruments["EL_ZURO"] - zhsequence = controller.sequence_zh(sequence, platform.qubits) - - assert len(zhsequence) == 2 - assert len(zhsequence[readout_channel]) == 2 - - -def test_zhinst_register_readout_line(dummy_qrc): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - qubit = platform.qubits[0] - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - IQM5q.register_readout_line(qubit, intermediate_frequency=int(1e6), options=options) - - assert measure_channel_name(qubit) in IQM5q.signal_map - assert acquire_channel_name(qubit) in IQM5q.signal_map - assert ( - "/logical_signal_groups/q0/measure_line" in IQM5q.calibration.calibration_items - ) - - -def test_zhinst_register_drive_line(dummy_qrc): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - qubit = platform.qubits[0] - IQM5q.register_drive_line(qubit, intermediate_frequency=int(1e6)) - - assert qubit.drive.name in IQM5q.signal_map - assert "/logical_signal_groups/q0/drive_line" in IQM5q.calibration.calibration_items - - -def test_zhinst_register_flux_line(dummy_qrc): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - qubit = platform.qubits[0] - IQM5q.register_flux_line(qubit) - - assert qubit.flux.name in IQM5q.signal_map - assert "/logical_signal_groups/q0/flux_line" in IQM5q.calibration.calibration_items - - -def test_experiment_flow(dummy_qrc): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - - sequence = PulseSequence() - qubits = {0: platform.qubits[0], 2: platform.qubits[2]} - platform.qubits = qubits - couplers = {} - - ro_pulses = {} - qf_pulses = {} - for qubit in qubits.values(): - q = qubit.name - qf_pulses[q] = FluxPulse( - start=0, - duration=500, - amplitude=1, - shape=Rectangular(), - channel=platform.qubits[q].flux.name, - qubit=q, - ) - sequence.add(qf_pulses[q]) - ro_pulses[q] = platform.create_qubit_readout_pulse(q, start=qf_pulses[q].finish) - sequence.add(ro_pulses[q]) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - IQM5q.experiment_flow(qubits, couplers, sequence, options) - - assert qubits[0].flux.name in IQM5q.experiment.signals - assert measure_channel_name(qubits[0]) in IQM5q.experiment.signals - assert acquire_channel_name(qubits[0]) in IQM5q.experiment.signals - - -def test_experiment_flow_coupler(dummy_qrc): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - - sequence = PulseSequence() - qubits = {0: platform.qubits[0], 2: platform.qubits[2]} - platform.qubits = qubits - couplers = {0: platform.couplers[0]} - platform.couplers = couplers - - ro_pulses = {} - qf_pulses = {} - for qubit in qubits.values(): - q = qubit.name - qf_pulses[q] = FluxPulse( - start=0, - duration=500, - amplitude=1, - shape=Rectangular(), - channel=platform.qubits[q].flux.name, - qubit=q, - ) - sequence.add(qf_pulses[q]) - ro_pulses[q] = platform.create_qubit_readout_pulse(q, start=qf_pulses[q].finish) - sequence.add(ro_pulses[q]) - - cf_pulses = {} - for coupler in couplers.values(): - c = coupler.name - cf_pulses[c] = CouplerFluxPulse( - start=0, - duration=500, - amplitude=1, - shape=Rectangular(), - channel=platform.couplers[c].flux.name, - qubit=c, - ) - sequence.add(cf_pulses[c]) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - IQM5q.experiment_flow(qubits, couplers, sequence, options) - - assert qubits[0].flux.name in IQM5q.experiment.signals - assert measure_channel_name(qubits[0]) in IQM5q.experiment.signals - assert acquire_channel_name(qubits[0]) in IQM5q.experiment.signals - - -def test_sweep_and_play_sim(dummy_qrc): - """Test end-to-end experiment run using ZI emulated connection.""" - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - - sequence = PulseSequence() - qubits = {0: platform.qubits[0], 2: platform.qubits[2]} - platform.qubits = qubits - couplers = {} - - ro_pulses = {} - qf_pulses = {} - for qubit in qubits.values(): - q = qubit.name - qf_pulses[q] = FluxPulse( - start=0, - duration=500, - amplitude=1, - shape=Rectangular(), - channel=platform.qubits[q].flux.name, - qubit=q, - ) - sequence.add(qf_pulses[q]) - ro_pulses[q] = platform.create_qubit_readout_pulse(q, start=qf_pulses[q].finish) - sequence.add(ro_pulses[q]) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - nshots=12, - ) - - # check play - IQM5q.session = lo.Session(IQM5q.device_setup) - IQM5q.session.connect(do_emulation=True) - res = IQM5q.play(qubits, couplers, sequence, options) - assert res is not None - assert all(qubit in res for qubit in qubits) - - # check sweep with empty list of sweeps - res = IQM5q.sweep(qubits, couplers, sequence, options) - assert res is not None - assert all(qubit in res for qubit in qubits) - - # check sweep with sweeps - sweep_1 = Sweeper(Parameter.start, np.array([1, 2, 3, 4]), list(qf_pulses.values())) - sweep_2 = Sweeper(Parameter.bias, np.array([1, 2, 3]), qubits=[qubits[0]]) - res = IQM5q.sweep(qubits, couplers, sequence, options, sweep_1, sweep_2) - assert res is not None - assert all(qubit in res for qubit in qubits) - - -@pytest.mark.parametrize("parameter1", [Parameter.start, Parameter.duration]) -def test_experiment_sweep_single(dummy_qrc, parameter1): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - - qubits = {0: platform.qubits[0]} - couplers = {} - - swept_points = 5 - sequence = PulseSequence() - ro_pulses = {} - qd_pulses = {} - for qubit in qubits: - qd_pulses[qubit] = platform.create_RX_pulse(qubit, start=0) - sequence.add(qd_pulses[qubit]) - ro_pulses[qubit] = platform.create_qubit_readout_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(ro_pulses[qubit]) - - parameter_range_1 = ( - np.random.rand(swept_points) - if parameter1 is Parameter.amplitude - else np.random.randint(swept_points, size=swept_points) - ) - - sweepers = [] - sweepers.append(Sweeper(parameter1, parameter_range_1, pulses=[qd_pulses[qubit]])) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - IQM5q.experiment_flow(qubits, couplers, sequence, options) - - assert qubits[0].drive.name in IQM5q.experiment.signals - assert measure_channel_name(qubits[0]) in IQM5q.experiment.signals - assert acquire_channel_name(qubits[0]) in IQM5q.experiment.signals - - -@pytest.mark.parametrize("parameter1", [Parameter.start, Parameter.duration]) -def test_experiment_sweep_single_coupler(dummy_qrc, parameter1): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - - qubits = {0: platform.qubits[0], 2: platform.qubits[2]} - couplers = {0: platform.couplers[0]} - - swept_points = 5 - sequence = PulseSequence() - ro_pulses = {} - qd_pulses = {} - for qubit in qubits: - qd_pulses[qubit] = platform.create_RX_pulse(qubit, start=0) - sequence.add(qd_pulses[qubit]) - ro_pulses[qubit] = platform.create_qubit_readout_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(ro_pulses[qubit]) - - cf_pulses = {} - for coupler in couplers.values(): - c = coupler.name - cf_pulses[c] = CouplerFluxPulse( - start=0, - duration=500, - amplitude=1, - shape=Rectangular(), - channel=platform.couplers[c].flux.name, - qubit=c, - ) - sequence.add(cf_pulses[c]) - - parameter_range_1 = ( - np.random.rand(swept_points) - if parameter1 is Parameter.amplitude - else np.random.randint(swept_points, size=swept_points) - ) - - sweepers = [] - sweepers.append(Sweeper(parameter1, parameter_range_1, pulses=[cf_pulses[c]])) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - IQM5q.experiment_flow(qubits, couplers, sequence, options) - - assert couplers[0].flux.name in IQM5q.experiment.signals - assert qubits[0].drive.name in IQM5q.experiment.signals - assert measure_channel_name(qubits[0]) in IQM5q.experiment.signals - assert acquire_channel_name(qubits[0]) in IQM5q.experiment.signals - - -SweeperParameter = { - Parameter.frequency, - Parameter.amplitude, - Parameter.duration, - Parameter.start, - Parameter.relative_phase, -} - - -@pytest.mark.parametrize("parameter1", Parameter) -@pytest.mark.parametrize("parameter2", Parameter) -def test_experiment_sweep_2d_general(dummy_qrc, parameter1, parameter2): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - - qubits = {0: platform.qubits[0]} - couplers = {} - - swept_points = 5 - sequence = PulseSequence() - ro_pulses = {} - qd_pulses = {} - for qubit in qubits: - qd_pulses[qubit] = platform.create_RX_pulse(qubit, start=0) - sequence.add(qd_pulses[qubit]) - ro_pulses[qubit] = platform.create_qubit_readout_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(ro_pulses[qubit]) - - parameter_range_1 = ( - np.random.rand(swept_points) - if parameter1 is Parameter.amplitude - else np.random.randint(swept_points, size=swept_points) - ) - - parameter_range_2 = ( - np.random.rand(swept_points) - if parameter2 is Parameter.amplitude - else np.random.randint(swept_points, size=swept_points) - ) - - sweepers = [] - if parameter1 in SweeperParameter: - if parameter1 is not Parameter.start: - sweepers.append( - Sweeper(parameter1, parameter_range_1, pulses=[ro_pulses[qubit]]) - ) - if parameter2 in SweeperParameter: - if parameter2 is Parameter.amplitude: - if parameter1 is not Parameter.amplitude: - sweepers.append( - Sweeper(parameter2, parameter_range_2, pulses=[qd_pulses[qubit]]) - ) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - IQM5q.experiment_flow(qubits, couplers, sequence, options) - - assert qubits[0].drive.name in IQM5q.experiment.signals - assert measure_channel_name(qubits[0]) in IQM5q.experiment.signals - assert acquire_channel_name(qubits[0]) in IQM5q.experiment.signals - - -def test_experiment_sweep_2d_specific(dummy_qrc): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - - qubits = {0: platform.qubits[0]} - couplers = {} - - swept_points = 5 - sequence = PulseSequence() - ro_pulses = {} - qd_pulses = {} - for qubit in qubits: - qd_pulses[qubit] = platform.create_RX_pulse(qubit, start=0) - sequence.add(qd_pulses[qubit]) - ro_pulses[qubit] = platform.create_qubit_readout_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(ro_pulses[qubit]) - - parameter1 = Parameter.relative_phase - parameter2 = Parameter.frequency - - parameter_range_1 = ( - np.random.rand(swept_points) - if parameter1 is Parameter.amplitude - else np.random.randint(swept_points, size=swept_points) - ) - - parameter_range_2 = ( - np.random.rand(swept_points) - if parameter2 is Parameter.amplitude - else np.random.randint(swept_points, size=swept_points) - ) - - sweepers = [] - sweepers.append(Sweeper(parameter1, parameter_range_1, pulses=[qd_pulses[qubit]])) - sweepers.append(Sweeper(parameter2, parameter_range_2, pulses=[qd_pulses[qubit]])) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - IQM5q.experiment_flow(qubits, couplers, sequence, options) - - assert qubits[0].drive.name in IQM5q.experiment.signals - assert measure_channel_name(qubits[0]) in IQM5q.experiment.signals - assert acquire_channel_name(qubits[0]) in IQM5q.experiment.signals - - -@pytest.mark.parametrize( - "parameter", [Parameter.frequency, Parameter.amplitude, Parameter.bias] -) -def test_experiment_sweep_punchouts(dummy_qrc, parameter): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - - qubits = {0: platform.qubits[0]} - couplers = {} - - if parameter is Parameter.frequency: - parameter1 = Parameter.frequency - parameter2 = Parameter.amplitude - if parameter is Parameter.amplitude: - parameter1 = Parameter.amplitude - parameter2 = Parameter.frequency - if parameter is Parameter.bias: - parameter1 = Parameter.bias - parameter2 = Parameter.frequency - - swept_points = 5 - sequence = PulseSequence() - ro_pulses = {} - for qubit in qubits: - ro_pulses[qubit] = platform.create_qubit_readout_pulse(qubit, start=0) - sequence.add(ro_pulses[qubit]) - - parameter_range_1 = ( - np.random.rand(swept_points) - if parameter1 in [Parameter.amplitude, Parameter.bias] - else np.random.randint(swept_points, size=swept_points) - ) - - parameter_range_2 = ( - np.random.rand(swept_points) - if parameter2 is Parameter.amplitude - else np.random.randint(swept_points, size=swept_points) - ) - - sweepers = [] - if parameter1 is Parameter.bias: - sweepers.append(Sweeper(parameter1, parameter_range_1, qubits=[qubits[qubit]])) - else: - sweepers.append( - Sweeper(parameter1, parameter_range_1, pulses=[ro_pulses[qubit]]) - ) - sweepers.append(Sweeper(parameter2, parameter_range_2, pulses=[ro_pulses[qubit]])) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - IQM5q.experiment_flow(qubits, couplers, sequence, options) - - assert measure_channel_name(qubits[0]) in IQM5q.experiment.signals - assert acquire_channel_name(qubits[0]) in IQM5q.experiment.signals - - -def test_batching(dummy_qrc): - platform = create_platform("zurich") - instrument = platform.instruments["EL_ZURO"] - - sequence = PulseSequence() - sequence.add(platform.create_RX_pulse(0, start=0)) - sequence.add(platform.create_RX_pulse(1, start=0)) - measurement_start = sequence.finish - sequence.add(platform.create_MZ_pulse(0, start=measurement_start)) - sequence.add(platform.create_MZ_pulse(1, start=measurement_start)) - - batches = list(batch(600 * [sequence], instrument.bounds)) - # These sequences get limited by the number of measuraments (600/250/2) - assert len(batches) == 5 - assert len(batches[0]) == 125 - assert len(batches[1]) == 125 - - -@pytest.fixture(scope="module") -def instrument(connected_platform): - return get_instrument(connected_platform, Zurich) - - -@pytest.mark.qpu -def test_connections(instrument): - instrument.start() - instrument.stop() - instrument.disconnect() - instrument.connect() - - -@pytest.mark.qpu -def test_experiment_execute_pulse_sequence_qpu(connected_platform, instrument): - platform = connected_platform - sequence = PulseSequence() - qubits = {0: platform.qubits[0], "c0": platform.qubits["c0"]} - platform.qubits = qubits - - ro_pulses = {} - qf_pulses = {} - for qubit in qubits.values(): - q = qubit.name - qf_pulses[q] = FluxPulse( - start=0, - duration=500, - amplitude=1, - shape=Rectangular(), - channel=platform.qubits[q].flux.name, - qubit=q, - ) - sequence.add(qf_pulses[q]) - if qubit.flux_coupler: - continue - ro_pulses[q] = platform.create_qubit_readout_pulse(q, start=qf_pulses[q].finish) - sequence.add(ro_pulses[q]) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - results = platform.execute_pulse_sequence( - sequence, - options, - ) - - assert len(results[ro_pulses[q].serial]) > 0 - - -@pytest.mark.qpu -def test_experiment_sweep_2d_specific_qpu(connected_platform, instrument): - platform = connected_platform - qubits = {0: platform.qubits[0]} - - swept_points = 5 - sequence = PulseSequence() - ro_pulses = {} - qd_pulses = {} - for qubit in qubits: - qd_pulses[qubit] = platform.create_RX_pulse(qubit, start=0) - sequence.add(qd_pulses[qubit]) - ro_pulses[qubit] = platform.create_qubit_readout_pulse( - qubit, start=qd_pulses[qubit].finish - ) - sequence.add(ro_pulses[qubit]) - - parameter1 = Parameter.relative_phase - parameter2 = Parameter.frequency - - parameter_range_1 = ( - np.random.rand(swept_points) - if parameter1 is Parameter.amplitude - else np.random.randint(swept_points, size=swept_points) - ) - - parameter_range_2 = ( - np.random.rand(swept_points) - if parameter2 is Parameter.amplitude - else np.random.randint(swept_points, size=swept_points) - ) - - sweepers = [] - sweepers.append(Sweeper(parameter1, parameter_range_1, pulses=[qd_pulses[qubit]])) - sweepers.append(Sweeper(parameter2, parameter_range_2, pulses=[qd_pulses[qubit]])) - - options = ExecutionParameters( - relaxation_time=300e-6, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - results = platform.sweep( - sequence, - options, - sweepers[0], - sweepers[1], - ) - - assert len(results[ro_pulses[qubit].serial]) > 0 - - -def get_previous_subsequence_finish(instrument, name): - """Look recursively for sub_section finish times.""" - section = next( - iter(ch for ch in instrument.experiment.sections[0].children if ch.uid == name) - ) - finish = defaultdict(int) - for pulse in section.children: - try: - finish[pulse.signal] += pulse.time - except AttributeError: - # not a laboneq Delay class object, skipping - pass - try: - finish[pulse.signal] += pulse.pulse.length - except AttributeError: - # not a laboneq PlayPulse class object, skipping - pass - return max(finish.values()) - - -def test_experiment_measurement_sequence(dummy_qrc): - platform = create_platform("zurich") - IQM5q = platform.instruments["EL_ZURO"] - - sequence = PulseSequence() - qubits = {0: platform.qubits[0]} - platform.qubits = qubits - couplers = {} - - readout_pulse_start = 40 - - for qubit in qubits: - qubit_drive_pulse_1 = platform.create_qubit_drive_pulse( - qubit, start=0, duration=40 - ) - ro_pulse = platform.create_qubit_readout_pulse(qubit, start=readout_pulse_start) - qubit_drive_pulse_2 = platform.create_qubit_drive_pulse( - qubit, start=readout_pulse_start + 50, duration=40 - ) - sequence.add(qubit_drive_pulse_1) - sequence.add(ro_pulse) - sequence.add(qubit_drive_pulse_2) - - options = ExecutionParameters( - relaxation_time=4, - acquisition_type=AcquisitionType.INTEGRATION, - averaging_mode=AveragingMode.CYCLIC, - ) - - IQM5q.experiment_flow(qubits, couplers, sequence, options) - measure_start = 0 - for section in IQM5q.experiment.sections[0].children: - if section.uid == "measure_0": - measure_start += get_previous_subsequence_finish(IQM5q, section.play_after) - for pulse in section.children: - try: - if pulse.signal == measure_channel_name(qubits[0]): - measure_start += pulse.time - except AttributeError: - # not a laboneq delay class object, skipping - pass - - assert math.isclose(measure_start * 1e9, readout_pulse_start, rel_tol=1e-4) diff --git a/tests/test_native.py b/tests/test_native.py new file mode 100644 index 0000000000..28c33a05ae --- /dev/null +++ b/tests/test_native.py @@ -0,0 +1,119 @@ +import numpy as np +import pytest + +from qibolab._core.native import Native, TwoQubitNatives, rotation +from qibolab._core.pulses import Drag, Gaussian, Pulse, Rectangular +from qibolab._core.sequence import PulseSequence + + +def test_fixed_sequence_factory(): + seq = PulseSequence( + [ + ( + "channel_1/probe", + Pulse(duration=40, amplitude=0.3, envelope=Gaussian(rel_sigma=3.0)), + ), + ( + "channel_17/drive", + Pulse(duration=125, amplitude=1.0, envelope=Rectangular()), + ), + ] + ) + factory = Native(seq) + + fseq1 = factory.create_sequence() + fseq2 = factory.create_sequence() + assert fseq1 == seq + assert fseq2 == seq + # while representing the same sequence, the objects are actually different + assert fseq1[0][1].id != fseq2[0][1].id + + np = "new/probe" + fseq1.append( + ( + np, + Pulse(duration=30, amplitude=0.04, envelope=Drag(rel_sigma=4.0, beta=0.02)), + ) + ) + assert np not in seq.channels + assert np not in fseq2.channels + + # test alias + assert factory() == seq + + +@pytest.mark.parametrize( + "args,amplitude,phase", + [ + ({}, 1.0, 0.0), + ({"theta": np.pi / 2}, 0.5, 0.0), + ({"phi": np.pi / 4}, 1.0, np.pi / 4), + ({"theta": np.pi / 4, "phi": np.pi / 3}, 1.0 / 4, np.pi / 3), + ({"theta": 3 * np.pi / 2}, -0.5, 0.0), + ({"theta": 7 * np.pi}, 1.0, 0.0), + ({"theta": 7.5 * np.pi}, -0.5, 0.0), + ({"phi": 7.5 * np.pi}, 1.0, 1.5 * np.pi), + ], +) +def test_rotation(args, amplitude, phase): + seq = PulseSequence( + [ + ( + "1/drive", + Pulse(duration=40, amplitude=1.0, envelope=Gaussian(rel_sigma=3.0)), + ) + ] + ) + + fseq1 = rotation(seq, **args) + fseq2 = rotation(seq, **args) + assert fseq1 == fseq2 + np = "new/probe" + fseq2.append((np, Pulse(duration=56, amplitude=0.43, envelope=Rectangular()))) + assert np not in fseq1.channels + + pulse = next(iter(fseq1.channel("1/drive"))) + assert pulse.amplitude == pytest.approx(amplitude) + assert pulse.relative_phase == pytest.approx(phase) + + +def test_two_qubit_natives_symmetric(): + natives = TwoQubitNatives( + CZ=Native(PulseSequence()), + CNOT=Native(PulseSequence()), + iSWAP=Native(PulseSequence()), + ) + assert natives.symmetric is False + + natives = TwoQubitNatives( + CZ=Native(PulseSequence()), + iSWAP=Native(PulseSequence()), + ) + assert natives.symmetric is True + + natives = TwoQubitNatives( + CZ=Native(PulseSequence()), + ) + assert natives.symmetric is True + + natives = TwoQubitNatives( + iSWAP=Native(PulseSequence()), + ) + assert natives.symmetric is True + + natives = TwoQubitNatives( + CNOT=Native(PulseSequence()), + ) + assert natives.symmetric is False + + natives = TwoQubitNatives( + CZ=Native(PulseSequence()), + CNOT=Native(PulseSequence()), + ) + assert natives.symmetric is False + + natives = TwoQubitNatives( + CNOT=Native(PulseSequence()), + iSWAP=Native(PulseSequence()), + ) + assert natives.symmetric is False diff --git a/tests/test_parameters.py b/tests/test_parameters.py new file mode 100644 index 0000000000..5cc956a9df --- /dev/null +++ b/tests/test_parameters.py @@ -0,0 +1,79 @@ +from typing import Literal + +import pytest + +from qibolab._core.components.configs import Config +from qibolab._core.native import Native, TwoQubitNatives +from qibolab._core.parameters import ConfigKinds, Parameters, TwoQubitContainer + + +def test_two_qubit_container(): + """The container guarantees access to symmetric interactions. + + Swapped indexing is working (only with getitem, not other dict + methods) if all the registered natives are symmetric. + """ + symmetric = TwoQubitContainer({(0, 1): TwoQubitNatives(CZ=Native())}) + assert symmetric[1, 0].CZ is not None + + asymmetric = TwoQubitContainer({(0, 1): TwoQubitNatives(CNOT=Native())}) + with pytest.raises(KeyError): + asymmetric[(1, 0)] + + empty = TwoQubitContainer({(0, 1): TwoQubitNatives()}) + assert empty[(1, 0)] is not None + + +class DummyConfig(Config): + kind: Literal["dummy"] = "dummy" + ciao: str + + +class DummyConfig1(Config): + kind: Literal["dummy1"] = "dummy1" + come: int + + +class TestConfigKinds: + # TODO: add @staticmethod and drop unused `self`, once py3.9 will be abandoned + @pytest.fixture(autouse=True) + def clean_kinds(self): + ConfigKinds.reset() + + def test_manipulation(self): + ConfigKinds.extend([DummyConfig]) + assert DummyConfig in ConfigKinds.registered() + + ConfigKinds.reset() + assert DummyConfig not in ConfigKinds.registered() + + ConfigKinds.extend([DummyConfig, DummyConfig1]) + assert DummyConfig in ConfigKinds.registered() + assert DummyConfig1 in ConfigKinds.registered() + + def test_adapted(self): + ConfigKinds.extend([DummyConfig, DummyConfig1]) + adapted = ConfigKinds.adapted() + + dummy = DummyConfig(ciao="come") + dump = adapted.dump_python(dummy) + assert dump["ciao"] == "come" + reloaded = adapted.validate_python(dump) + assert reloaded == dummy + + dummy1 = DummyConfig1(come=42) + dump1 = adapted.dump_python(dummy1) + assert dump1["come"] == 42 + reloaded1 = adapted.validate_python(dump1) + assert reloaded1 == dummy1 + + def test_within_parameters(self): + ConfigKinds.extend([DummyConfig, DummyConfig1]) + pars = Parameters(configs={"come": DummyConfig1(come=42)}) + + dump = pars.model_dump() + assert dump["configs"]["come"]["come"] == 42 + assert "dummy1" in pars.model_dump_json() + + reloaded = Parameters.model_validate(dump) + assert reloaded == pars diff --git a/tests/test_platform.py b/tests/test_platform.py index 4389681eeb..9ad52f4f8c 100644 --- a/tests/test_platform.py +++ b/tests/test_platform.py @@ -1,10 +1,6 @@ -"""Tests :class:`qibolab.platforms.multiqubit.MultiqubitPlatform` and -:class:`qibolab.platforms.platform.DesignPlatform`.""" - import inspect import os import pathlib -import pickle import warnings from pathlib import Path @@ -14,45 +10,22 @@ from qibo.result import CircuitResult from qibolab import create_platform -from qibolab.backends import QibolabBackend -from qibolab.dummy import create_dummy -from qibolab.dummy.platform import FOLDER -from qibolab.execution_parameters import ExecutionParameters -from qibolab.instruments.qblox.controller import QbloxController -from qibolab.instruments.rfsoc.driver import RFSoC -from qibolab.kernels import Kernels -from qibolab.platform import Platform, unroll_sequences -from qibolab.platform.load import PLATFORMS -from qibolab.pulses import Drag, PulseSequence, Rectangular -from qibolab.serialize import ( - PLATFORM, - dump_kernels, - dump_platform, - dump_runcard, - load_runcard, - load_settings, -) - -from .conftest import find_instrument +from qibolab._core.backends import QibolabBackend +from qibolab._core.components import AcquisitionConfig, IqConfig, OscillatorConfig +from qibolab._core.dummy import create_dummy +from qibolab._core.dummy.platform import FOLDER +from qibolab._core.native import SingleQubitNatives, TwoQubitNatives +from qibolab._core.parameters import NativeGates, Parameters, update_configs +from qibolab._core.platform import Platform +from qibolab._core.platform.load import PLATFORM, PLATFORMS, locate_platform +from qibolab._core.platform.platform import PARAMETERS +from qibolab._core.pulses import Delay, Gaussian, Pulse, Rectangular +from qibolab._core.sequence import PulseSequence +from qibolab._core.serialize import replace nshots = 1024 -def test_unroll_sequences(platform): - qubit = next(iter(platform.qubits)) - sequence = PulseSequence() - qd_pulse = platform.create_RX_pulse(qubit, start=0) - ro_pulse = platform.create_MZ_pulse(qubit, start=qd_pulse.finish) - sequence.add(qd_pulse) - sequence.add(ro_pulse) - total_sequence, readouts = unroll_sequences(10 * [sequence], relaxation_time=10000) - assert len(total_sequence) == 20 - assert len(total_sequence.ro_pulses) == 10 - assert total_sequence.finish == 10 * sequence.finish + 90000 - assert len(readouts) == 1 - assert len(readouts[ro_pulse.serial]) == 10 - - def test_create_platform(platform): assert isinstance(platform, Platform) @@ -62,6 +35,52 @@ def test_create_platform_error(): platform = create_platform("nonexistent") +def test_platform_basics(): + platform = Platform( + name="ciao", + parameters=Parameters(native_gates=NativeGates()), + instruments={}, + qubits={}, + ) + assert str(platform) == "ciao" + assert platform.pairs == [] + + qs = {q: SingleQubitNatives() for q in range(10)} + ts = {(q1, q2): TwoQubitNatives() for q1 in range(3) for q2 in range(4, 8)} + platform2 = Platform( + name="come va?", + parameters=Parameters( + native_gates=NativeGates( + single_qubit=qs, + two_qubit=ts, + coupler={}, + ) + ), + instruments={}, + qubits=qs, + ) + assert str(platform2) == "come va?" + assert (1, 6) in platform2.pairs + + +def test_locate_platform(tmp_path: Path): + some = tmp_path / "some" + some.mkdir() + + for p in [some / "platform0", some / "platform1"]: + p.mkdir() + (p / PLATFORM).write_text("'Ciao'") + + assert locate_platform("platform0", [some]) == some / "platform0" + + with pytest.raises(ValueError): + locate_platform("platform3") + + os.environ[PLATFORMS] = str(some) + + assert locate_platform("platform1") == some / "platform1" + + def test_create_platform_multipath(tmp_path: Path): some = tmp_path / "some" others = tmp_path / "others" @@ -78,10 +97,10 @@ def test_create_platform_multipath(tmp_path: Path): (p / PLATFORM).write_text( inspect.cleandoc( f""" - from qibolab.platform import Platform + from qibolab._core.platform import Platform def create(): - return Platform("{p.parent.name}-{p.name}", {{}}, {{}}, {{}}) + return Platform("{p.parent.name}-{p.name}", {{}}, {{}}, {{}}, {{}}) """ ) ) @@ -102,72 +121,111 @@ def test_platform_sampling_rate(platform): assert platform.sampling_rate >= 1 -@pytest.mark.xfail(reason="Cannot pickle all platforms") -def test_platform_pickle(platform): - serial = pickle.dumps(platform) - new_platform = pickle.loads(serial) - assert new_platform.name == platform.name - assert new_platform.is_connected == platform.is_connected +def test_duplicated_acquisition(): + """A shallow copy will duplicate the object. + + This leads to non-unique identifiers across all sequences, and it's + then flagged as an error (since unique identifiers are assumed in + the return type, to avoid overwriting dict entries). + """ + platform = create_platform("dummy") + sequence = platform.natives.single_qubit[0].MZ.create_sequence() + + with pytest.raises(ValueError, match="unique"): + _ = platform.execute([sequence, sequence.copy()]) + + +def test_update_configs(platform): + drive_name = "q0/drive" + pump_name = "twpa_pump" + configs = { + drive_name: IqConfig(frequency=4.1e9), + pump_name: OscillatorConfig(frequency=3e9, power=-5), + } + + updated = update_configs(configs, [{drive_name: {"frequency": 4.2e9}}]) + assert updated is None + assert configs[drive_name].frequency == 4.2e9 + + update_configs( + configs, [{drive_name: {"frequency": 4.3e9}, pump_name: {"power": -10}}] + ) + assert configs[drive_name].frequency == 4.3e9 + assert configs[pump_name].frequency == 3e9 + assert configs[pump_name].power == -10 + + update_configs( + configs, + [{drive_name: {"frequency": 4.4e9}}, {drive_name: {"frequency": 4.5e9}}], + ) + assert configs[drive_name].frequency == 4.5e9 + with pytest.raises(ValueError, match="unknown component"): + update_configs(configs, [{"non existent": {"property": 1.0}}]) -def test_dump_runcard(platform, tmp_path): - dump_runcard(platform, tmp_path) - final_runcard = load_runcard(tmp_path) - if platform.name == "dummy" or platform.name == "dummy_couplers": - target_runcard = load_runcard(FOLDER) + +def test_dump_parameters(platform: Platform, tmp_path: Path): + (tmp_path / PARAMETERS).write_text(platform.parameters.model_dump_json()) + final = Parameters.model_validate_json((tmp_path / PARAMETERS).read_text()) + if platform.name == "dummy": + target = Parameters.model_validate_json((FOLDER / PARAMETERS).read_text()) else: target_path = pathlib.Path(__file__).parent / "dummy_qrc" / f"{platform.name}" - target_runcard = load_runcard(target_path) - # for the characterization section the dumped runcard may contain - # some default ``Qubit`` parameters - target_char = target_runcard.pop("characterization")["single_qubit"] - final_char = final_runcard.pop("characterization")["single_qubit"] - assert final_runcard == target_runcard - for qubit, values in target_char.items(): - for name, value in values.items(): - assert final_char[qubit][name] == value - # assert instrument section is dumped properly in the runcard - target_instruments = target_runcard.pop("instruments") - final_instruments = final_runcard.pop("instruments") - assert final_instruments == target_instruments - - -@pytest.mark.parametrize("has_kernels", [False, True]) -def test_kernels(tmp_path, has_kernels): + target = Parameters.model_validate_json((target_path / PARAMETERS).read_text()) + + # assert configs section is dumped properly in the parameters + assert final.configs == target.configs + + +def test_dump_parameters_with_updates(platform: Platform, tmp_path: Path): + qubit = next(iter(platform.qubits.values())) + frequency = platform.config(qubit.drive).frequency + 1.5e9 + smearing = platform.config(qubit.acquisition).smearing + 10 + update = { + str(qubit.drive): {"frequency": frequency}, + str(qubit.acquisition): {"smearing": smearing}, + } + update_configs(platform.parameters.configs, [update]) + (tmp_path / PARAMETERS).write_text(platform.parameters.model_dump_json()) + final = Parameters.model_validate_json((tmp_path / PARAMETERS).read_text()) + assert final.configs[qubit.drive].frequency == frequency + assert final.configs[qubit.acquisition].smearing == smearing + + +def test_kernels(tmp_path: Path): """Test dumping and loading of `Kernels`.""" platform = create_dummy() - if has_kernels: - for qubit in platform.qubits: - platform.qubits[qubit].kernel = np.random.rand(10) + for name, config in platform.parameters.configs.items(): + if isinstance(config, AcquisitionConfig): + platform.parameters.configs[name] = replace( + config, kernel=np.random.rand(10) + ) - dump_kernels(platform, tmp_path) + platform.dump(tmp_path) + reloaded = Platform.load( + tmp_path, + instruments=platform.instruments, + qubits=platform.qubits, + couplers=platform.couplers, + ) - if has_kernels: - kernels = Kernels.load(tmp_path) - for qubit in platform.qubits: - np.testing.assert_array_equal(platform.qubits[qubit].kernel, kernels[qubit]) - else: - with pytest.raises(FileNotFoundError): - Kernels.load(tmp_path) + for qubit in platform.qubits.values(): + orig = platform.parameters.configs[qubit.acquisition].kernel + load = reloaded.parameters.configs[qubit.acquisition].kernel + np.testing.assert_array_equal(orig, load) -@pytest.mark.parametrize("has_kernels", [False, True]) -def test_dump_platform(tmp_path, has_kernels): - """Test platform dump and loading runcard and kernels.""" +def test_dump_platform(tmp_path): + """Test platform dump and loading parameters and kernels.""" platform = create_dummy() - if has_kernels: - for qubit in platform.qubits: - platform.qubits[qubit].kernel = np.random.rand(10) - dump_platform(platform, tmp_path) + platform.dump(tmp_path) - settings = load_settings(load_runcard(tmp_path)) - if has_kernels: - kernels = Kernels.load(tmp_path) - for qubit in platform.qubits: - np.testing.assert_array_equal(platform.qubits[qubit].kernel, kernels[qubit]) + settings = Parameters.model_validate_json( + (tmp_path / PARAMETERS).read_text() + ).settings assert settings == platform.settings @@ -183,17 +241,25 @@ def test_platform_execute_empty(qpu_platform): # an empty pulse sequence platform = qpu_platform sequence = PulseSequence() - platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots)) + result = platform.execute([sequence], nshots=nshots) + assert result is not None @pytest.mark.qpu def test_platform_execute_one_drive_pulse(qpu_platform): # One drive pulse platform = qpu_platform - qubit = next(iter(platform.qubits)) - sequence = PulseSequence() - sequence.add(platform.create_qubit_drive_pulse(qubit, start=0, duration=200)) - platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots)) + qubit = next(iter(platform.qubits.values())) + sequence = PulseSequence( + [ + ( + qubit.drive, + Pulse(duration=200, amplitude=0.07, envelope=Gaussian(0.2)), + ) + ] + ) + result = platform.execute([sequence], nshots=nshots) + assert result is not None @pytest.mark.qpu @@ -202,144 +268,138 @@ def test_platform_execute_one_coupler_pulse(qpu_platform): platform = qpu_platform if len(platform.couplers) == 0: pytest.skip("The platform does not have couplers") - coupler = next(iter(platform.couplers)) - sequence = PulseSequence() - sequence.add( - platform.create_coupler_pulse(coupler, start=0, duration=200, amplitude=1) + coupler = next(iter(platform.couplers.values())) + sequence = PulseSequence( + [ + ( + coupler.flux, + Pulse(duration=200, amplitude=0.31, envelope=Rectangular()), + ) + ] ) - platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots)) - assert len(sequence.cf_pulses) > 0 + result = platform.execute([sequence], nshots=nshots) + assert result is not None @pytest.mark.qpu def test_platform_execute_one_flux_pulse(qpu_platform): # One flux pulse platform = qpu_platform - qubit = next(iter(platform.qubits)) - sequence = PulseSequence() - sequence.add( - platform.create_qubit_flux_pulse(qubit, start=0, duration=200, amplitude=1) + qubit = next(iter(platform.qubits.values())) + sequence = PulseSequence( + [ + ( + qubit.flux, + Pulse(duration=200, amplitude=0.28, envelope=Rectangular()), + ) + ] ) - platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots)) - assert len(sequence.qf_pulses) == 1 - assert len(sequence) == 1 + result = platform.execute([sequence], nshots=nshots) + assert result is not None @pytest.mark.qpu def test_platform_execute_one_long_drive_pulse(qpu_platform): # Long duration platform = qpu_platform - qubit = next(iter(platform.qubits)) - pulse = platform.create_qubit_drive_pulse(qubit, start=0, duration=8192 + 200) - sequence = PulseSequence() - sequence.add(pulse) - options = ExecutionParameters(nshots=nshots) - if find_instrument(platform, QbloxController) is not None: - with pytest.raises(NotImplementedError): - platform.execute_pulse_sequence(sequence, options) - elif find_instrument(platform, RFSoC) is not None and not isinstance( - pulse.shape, Rectangular - ): - with pytest.raises(RuntimeError): - platform.execute_pulse_sequence(sequence, options) - else: - platform.execute_pulse_sequence(sequence, options) + qubit = next(iter(platform.qubits.values())) + pulse = Pulse(duration=8192 + 200, amplitude=0.12, envelope=Gaussian(5)) + sequence = PulseSequence([(qubit.drive, pulse)]) + platform.execute([sequence], nshots=nshots) @pytest.mark.qpu def test_platform_execute_one_extralong_drive_pulse(qpu_platform): # Extra Long duration platform = qpu_platform - qubit = next(iter(platform.qubits)) - pulse = platform.create_qubit_drive_pulse(qubit, start=0, duration=2 * 8192 + 200) - sequence = PulseSequence() - sequence.add(pulse) - options = ExecutionParameters(nshots=nshots) - if find_instrument(platform, QbloxController) is not None: - with pytest.raises(NotImplementedError): - platform.execute_pulse_sequence(sequence, options) - elif find_instrument(platform, RFSoC) is not None and not isinstance( - pulse.shape, Rectangular - ): - with pytest.raises(RuntimeError): - platform.execute_pulse_sequence(sequence, options) - else: - platform.execute_pulse_sequence(sequence, options) + qubit = next(iter(platform.qubits.values())) + pulse = Pulse(duration=2 * 8192 + 200, amplitude=0.12, envelope=Gaussian(0.2)) + sequence = PulseSequence([(qubit.drive, pulse)]) + platform.execute([sequence], nshots=nshots) @pytest.mark.qpu def test_platform_execute_one_drive_one_readout(qpu_platform): - # One drive pulse and one readout pulse + """One drive pulse and one readout pulse.""" platform = qpu_platform - qubit = next(iter(platform.qubits)) + qubit_id, qubit = next(iter(platform.qubits.items())) sequence = PulseSequence() - sequence.add(platform.create_qubit_drive_pulse(qubit, start=0, duration=200)) - sequence.add(platform.create_qubit_readout_pulse(qubit, start=200)) - platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots)) + sequence.concatenate(platform.create_RX_pulse(qubit_id)) + sequence.append((qubit.probe, Delay(duration=200))) + sequence.concatenate(platform.create_MZ_pulse(qubit_id)) + platform.execute([sequence], nshots=nshots) @pytest.mark.qpu def test_platform_execute_multiple_drive_pulses_one_readout(qpu_platform): - # Multiple qubit drive pulses and one readout pulse + """Multiple qubit drive pulses and one readout pulse.""" platform = qpu_platform - qubit = next(iter(platform.qubits)) + qubit_id, qubit = next(iter(platform.qubits.items())) sequence = PulseSequence() - sequence.add(platform.create_qubit_drive_pulse(qubit, start=0, duration=200)) - sequence.add(platform.create_qubit_drive_pulse(qubit, start=204, duration=200)) - sequence.add(platform.create_qubit_drive_pulse(qubit, start=408, duration=400)) - sequence.add(platform.create_qubit_readout_pulse(qubit, start=808)) - platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots)) + sequence.concatenate(platform.create_RX_pulse(qubit_id)) + sequence.append((qubit.drive, Delay(duration=4))) + sequence.concatenate(platform.create_RX_pulse(qubit_id)) + sequence.append((qubit.drive, Delay(duration=4))) + sequence.concatenate(platform.create_RX_pulse(qubit_id)) + sequence.append((qubit.probe, Delay(duration=808))) + sequence.concatenate(platform.create_MZ_pulse(qubit_id)) + platform.execute([sequence], nshots=nshots) @pytest.mark.qpu def test_platform_execute_multiple_drive_pulses_one_readout_no_spacing( qpu_platform, ): - # Multiple qubit drive pulses and one readout pulse with no spacing between them + """Multiple qubit drive pulses and one readout pulse with no spacing + between them.""" platform = qpu_platform - qubit = next(iter(platform.qubits)) + qubit_id, qubit = next(iter(platform.qubits.items())) sequence = PulseSequence() - sequence.add(platform.create_qubit_drive_pulse(qubit, start=0, duration=200)) - sequence.add(platform.create_qubit_drive_pulse(qubit, start=200, duration=200)) - sequence.add(platform.create_qubit_drive_pulse(qubit, start=400, duration=400)) - sequence.add(platform.create_qubit_readout_pulse(qubit, start=800)) - platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots)) + sequence.concatenate(platform.create_RX_pulse(qubit_id)) + sequence.concatenate(platform.create_RX_pulse(qubit_id)) + sequence.concatenate(platform.create_RX_pulse(qubit_id)) + sequence.append((qubit.probe, Delay(duration=800))) + sequence.concatenate(platform.create_MZ_pulse(qubit_id)) + platform.execute([sequence], nshots=nshots) @pytest.mark.qpu def test_platform_execute_multiple_overlaping_drive_pulses_one_readout( qpu_platform, ): - # Multiple overlapping qubit drive pulses and one readout pulse + """Multiple overlapping qubit drive pulses and one readout pulse.""" platform = qpu_platform - qubit = next(iter(platform.qubits)) - sequence = PulseSequence() - sequence.add(platform.create_qubit_drive_pulse(qubit, start=0, duration=200)) - sequence.add(platform.create_qubit_drive_pulse(qubit, start=200, duration=200)) - sequence.add(platform.create_qubit_drive_pulse(qubit, start=50, duration=400)) - sequence.add(platform.create_qubit_readout_pulse(qubit, start=800)) - platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots)) + qubit_id, qubit = next(iter(platform.qubits.items())) + pulse = Pulse(duration=200, amplitude=0.08, envelope=Gaussian(rel_sigma=1 / 7)) + sequence = PulseSequence( + [ + (qubit.drive, pulse), + (qubit.drive12, pulse.model_copy()), + (qubit.probe, Delay(duration=800)), + ] + ) + sequence.concatenate(platform.create_MZ_pulse(qubit_id)) + platform.execute([sequence], nshots=nshots) @pytest.mark.qpu def test_platform_execute_multiple_readout_pulses(qpu_platform): - # Multiple readout pulses + """Multiple readout pulses.""" platform = qpu_platform - qubit = next(iter(platform.qubits)) + qubit_id, qubit = next(iter(platform.qubits.items())) sequence = PulseSequence() - qd_pulse1 = platform.create_qubit_drive_pulse(qubit, start=0, duration=200) - ro_pulse1 = platform.create_qubit_readout_pulse(qubit, start=200) - qd_pulse2 = platform.create_qubit_drive_pulse( - qubit, start=(ro_pulse1.start + ro_pulse1.duration), duration=400 - ) - ro_pulse2 = platform.create_qubit_readout_pulse( - qubit, start=(ro_pulse1.start + ro_pulse1.duration + 400) - ) - sequence.add(qd_pulse1) - sequence.add(ro_pulse1) - sequence.add(qd_pulse2) - sequence.add(ro_pulse2) - platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=nshots)) + qd_seq1 = platform.create_RX_pulse(qubit_id) + ro_seq1 = platform.create_MZ_pulse(qubit_id) + qd_seq2 = platform.create_RX_pulse(qubit_id) + ro_seq2 = platform.create_MZ_pulse(qubit_id) + sequence.concatenate(qd_seq1) + sequence.append((qubit.probe, Delay(duration=qd_seq1.duration))) + sequence.concatenate(ro_seq1) + sequence.append((qubit.drive, Delay(duration=ro_seq1.duration))) + sequence.concatenate(qd_seq2) + sequence.append((qubit.probe, Delay(duration=qd_seq2.duration))) + sequence.concatenate(ro_seq2) + platform.execute([sequence], nshots=nshots) @pytest.mark.skip(reason="no way of currently testing this") @@ -349,20 +409,19 @@ def test_platform_execute_multiple_readout_pulses(qpu_platform): ) def test_excited_state_probabilities_pulses(qpu_platform): platform = qpu_platform - qubits = [q for q, qb in platform.qubits.items() if qb.drive is not None] backend = QibolabBackend(platform) sequence = PulseSequence() - for qubit in qubits: - qd_pulse = platform.create_RX_pulse(qubit) - ro_pulse = platform.create_MZ_pulse(qubit, start=qd_pulse.duration) - sequence.add(qd_pulse) - sequence.add(ro_pulse) - result = platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=5000)) - - nqubits = len(qubits) + for qubit_id, qubit in platform.qubits.items(): + sequence.concatenate(platform.create_RX_pulse(qubit_id)) + sequence.append((qubit.probe, Delay(duration=sequence.duration))) + sequence.concatenate(platform.create_MZ_pulse(qubit_id)) + result = platform.execute([sequence], nshots=5000) + + nqubits = len(platform.qubits) cr = CircuitResult(backend, Circuit(nqubits), result, nshots=5000) probs = [ - backend.circuit_result_probabilities(cr, qubits=[qubit]) for qubit in qubits + backend.circuit_result_probabilities(cr, qubits=[qubit]) + for qubit in platform.qubits ] warnings.warn(f"Excited state probabilities: {probs}") target_probs = np.zeros((nqubits, 2)) @@ -378,40 +437,28 @@ def test_excited_state_probabilities_pulses(qpu_platform): ) def test_ground_state_probabilities_pulses(qpu_platform, start_zero): platform = qpu_platform - qubits = [q for q, qb in platform.qubits.items() if qb.drive is not None] backend = QibolabBackend(platform) sequence = PulseSequence() - for qubit in qubits: - if start_zero: - ro_pulse = platform.create_MZ_pulse(qubit, start=0) - else: - qd_pulse = platform.create_RX_pulse(qubit) - ro_pulse = platform.create_MZ_pulse(qubit, start=qd_pulse.duration) - sequence.add(ro_pulse) - result = platform.execute_pulse_sequence(sequence, ExecutionParameters(nshots=5000)) - - nqubits = len(qubits) + for qubit_id, qubit in platform.qubits.items(): + if not start_zero: + sequence.append( + ( + qubit.probe, + Delay( + duration=platform.create_RX_pulse(qubit_id).duration, + ), + ) + ) + sequence.concatenate(platform.create_MZ_pulse(qubit_id)) + result = platform.execute([sequence], nshots=5000) + + nqubits = len(platform.qubits) cr = CircuitResult(backend, Circuit(nqubits), result, nshots=5000) probs = [ - backend.circuit_result_probabilities(cr, qubits=[qubit]) for qubit in qubits + backend.circuit_result_probabilities(cr, qubits=[qubit]) + for qubit in platform.qubits ] warnings.warn(f"Ground state probabilities: {probs}") target_probs = np.zeros((nqubits, 2)) target_probs[:, 0] = 1 np.testing.assert_allclose(probs, target_probs, atol=0.05) - - -def test_create_RX_drag_pulses(): - platform = create_dummy() - qubits = [q for q, qb in platform.qubits.items() if qb.drive is not None] - beta = 0.1234 - for qubit in qubits: - drag_pi = platform.create_RX_drag_pulse(qubit, 0, beta=beta) - assert drag_pi.shape == Drag(drag_pi.shape.rel_sigma, beta=beta) - drag_pi_half = platform.create_RX90_drag_pulse(qubit, drag_pi.finish, beta=beta) - assert drag_pi_half.shape == Drag(drag_pi_half.shape.rel_sigma, beta=beta) - np.testing.assert_almost_equal(drag_pi.amplitude, 2 * drag_pi_half.amplitude) - - # to check ShapeInitError - drag_pi.shape.envelope_waveforms() - drag_pi_half.shape.envelope_waveforms() diff --git a/tests/test_pulses.py b/tests/test_pulses.py deleted file mode 100644 index 9939b8faec..0000000000 --- a/tests/test_pulses.py +++ /dev/null @@ -1,1103 +0,0 @@ -"""Tests ``pulses.py``.""" - -import os -import pathlib - -import numpy as np -import pytest - -from qibolab.pulses import ( - IIR, - SNZ, - Custom, - Drag, - DrivePulse, - FluxPulse, - Gaussian, - GaussianSquare, - Pulse, - PulseSequence, - PulseShape, - PulseType, - ReadoutPulse, - Rectangular, - ShapeInitError, - Waveform, - eCap, -) - -HERE = pathlib.Path(__file__).parent - - -def test_pulses_plot_functions(): - p0 = Pulse(0, 40, 0.9, 0, 0, Rectangular(), 0, PulseType.FLUX, 0) - p1 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(5), 0, PulseType.DRIVE, 2) - p2 = Pulse(0, 40, 0.9, 50e6, 0, Drag(5, 2), 0, PulseType.DRIVE, 200) - p3 = FluxPulse(0, 40, 0.9, IIR([-0.5, 2], [1], Rectangular()), 0, 200) - p4 = FluxPulse(0, 40, 0.9, SNZ(t_idling=10), 0, 200) - p5 = Pulse(0, 40, 0.9, 400e6, 0, eCap(alpha=2), 0, PulseType.DRIVE) - p6 = Pulse(0, 40, 0.9, 50e6, 0, GaussianSquare(5, 0.9), 0, PulseType.DRIVE, 2) - ps = p0 + p1 + p2 + p3 + p4 + p5 + p6 - wf = p0.modulated_waveform_i() - - plot_file = HERE / "test_plot.png" - - wf.plot(plot_file) - assert os.path.exists(plot_file) - os.remove(plot_file) - - p0.plot(plot_file) - assert os.path.exists(plot_file) - os.remove(plot_file) - - ps.plot(plot_file) - assert os.path.exists(plot_file) - os.remove(plot_file) - - -def test_pulses_pulse_init(): - # standard initialisation - p0 = Pulse( - start=0, - duration=50, - amplitude=0.9, - frequency=20_000_000, - relative_phase=0.0, - shape=Rectangular(), - channel=0, - type=PulseType.READOUT, - qubit=0, - ) - assert ( - repr(p0) - == "Pulse(0, 50, 0.9, 20_000_000, 0, Rectangular(), 0, PulseType.READOUT, 0)" - ) - - p1 = Pulse( - start=100, - duration=50, - amplitude=0.9, - frequency=20_000_000, - relative_phase=0.0, - shape=Rectangular(), - channel=0, - type=PulseType.READOUT, - qubit=0, - ) - assert ( - repr(p1) - == "Pulse(100, 50, 0.9, 20_000_000, 0, Rectangular(), 0, PulseType.READOUT, 0)" - ) - - # initialisation with non int (float) frequency - p2 = Pulse( - start=0, - duration=50, - amplitude=0.9, - frequency=int(20e6), - relative_phase=0, - shape=Rectangular(), - channel=0, - type=PulseType.READOUT, - qubit=0, - ) - assert ( - repr(p2) - == "Pulse(0, 50, 0.9, 20_000_000, 0, Rectangular(), 0, PulseType.READOUT, 0)" - ) - assert isinstance(p2.frequency, int) and p2.frequency == 20_000_000 - - # initialisation with non float (int) relative_phase - p3 = Pulse( - start=0, - duration=50, - amplitude=0.9, - frequency=20_000_000, - relative_phase=1.0, - shape=Rectangular(), - channel=0, - type=PulseType.READOUT, - qubit=0, - ) - assert ( - repr(p3) - == "Pulse(0, 50, 0.9, 20_000_000, 1, Rectangular(), 0, PulseType.READOUT, 0)" - ) - assert isinstance(p3.relative_phase, float) and p3.relative_phase == 1.0 - - # initialisation with str shape - p4 = Pulse( - start=0, - duration=50, - amplitude=0.9, - frequency=20_000_000, - relative_phase=0, - shape="Rectangular()", - channel=0, - type=PulseType.READOUT, - qubit=0, - ) - assert ( - repr(p4) - == "Pulse(0, 50, 0.9, 20_000_000, 0, Rectangular(), 0, PulseType.READOUT, 0)" - ) - - # initialisation with str channel and str qubit - p5 = Pulse( - start=0, - duration=50, - amplitude=0.9, - frequency=20_000_000, - relative_phase=0, - shape="Rectangular()", - channel="channel0", - type=PulseType.READOUT, - qubit="qubit0", - ) - assert ( - repr(p5) - == "Pulse(0, 50, 0.9, 20_000_000, 0, Rectangular(), channel0, PulseType.READOUT, qubit0)" - ) - assert p5.qubit == "qubit0" - - # initialisation with different frequencies, shapes and types - p6 = Pulse(0, 40, 0.9, -50e6, 0, Rectangular(), 0, PulseType.READOUT) - p7 = Pulse(0, 40, 0.9, 0, 0, Rectangular(), 0, PulseType.FLUX, 0) - p8 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(5), 0, PulseType.DRIVE, 2) - p9 = Pulse(0, 40, 0.9, 50e6, 0, Drag(5, 2), 0, PulseType.DRIVE, 200) - p10 = FluxPulse(0, 40, 0.9, IIR([-1, 1], [-0.1, 0.1001], Rectangular()), 0, 200) - p11 = FluxPulse(0, 40, 0.9, SNZ(t_idling=10, b_amplitude=0.5), 0, 200) - p13 = Pulse(0, 40, 0.9, 400e6, 0, eCap(alpha=2), 0, PulseType.DRIVE) - p14 = Pulse(0, 40, 0.9, 50e6, 0, GaussianSquare(5, 0.9), 0, PulseType.READOUT, 2) - - # initialisation with float duration and start - p12 = Pulse( - start=5.5, - duration=34.33, - amplitude=0.9, - frequency=20_000_000, - relative_phase=1, - shape=Rectangular(), - channel=0, - type=PulseType.READOUT, - qubit=0, - ) - assert ( - repr(p12) - == "Pulse(5.5, 34.33, 0.9, 20_000_000, 1, Rectangular(), 0, PulseType.READOUT, 0)" - ) - assert isinstance(p12.start, float) - assert isinstance(p12.duration, float) - assert p12.finish == 5.5 + 34.33 - - -def test_pulses_pulse_attributes(): - channel = 0 - qubit = 0 - - p10 = Pulse( - start=10, - duration=50, - amplitude=0.9, - frequency=20_000_000, - relative_phase=0.0, - shape=Rectangular(), - channel=channel, - type=PulseType.READOUT, - qubit=qubit, - ) - - assert type(p10.start) == int and p10.start == 10 - assert type(p10.duration) == int and p10.duration == 50 - assert type(p10.amplitude) == float and p10.amplitude == 0.9 - assert type(p10.frequency) == int and p10.frequency == 20_000_000 - assert type(p10.phase) == float and np.allclose( - p10.phase, 2 * np.pi * p10.start * p10.frequency / 1e9 - ) - assert isinstance(p10.shape, PulseShape) and repr(p10.shape) == "Rectangular()" - assert type(p10.channel) == type(channel) and p10.channel == channel - assert type(p10.qubit) == type(qubit) and p10.qubit == qubit - assert isinstance(p10.finish, int) and p10.finish == 60 - - p0 = Pulse( - start=0, - duration=50, - amplitude=0.9, - frequency=20_000_000, - relative_phase=0.0, - shape=Rectangular(), - channel=0, - type=PulseType.READOUT, - qubit=0, - ) - p0.start = 50 - assert p0.finish == 100 - - -def test_pulses_is_equal_ignoring_start(): - """Checks if two pulses are equal, not looking at start time.""" - - p1 = Pulse(0, 40, 0.9, 0, 0, Rectangular(), 0, PulseType.FLUX, 0) - p2 = Pulse(100, 40, 0.9, 0, 0, Rectangular(), 0, PulseType.FLUX, 0) - p3 = Pulse(0, 40, 0.9, 0, 0, Rectangular(), 0, PulseType.FLUX, 0) - p4 = Pulse(200, 40, 0.9, 0, 0, Rectangular(), 2, PulseType.FLUX, 0) - assert p1.is_equal_ignoring_start(p2) - assert p1.is_equal_ignoring_start(p3) - assert not p1.is_equal_ignoring_start(p4) - - p1 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(5), 0, PulseType.DRIVE, 2) - p2 = Pulse(10, 40, 0.9, 50e6, 0, Gaussian(5), 0, PulseType.DRIVE, 2) - p3 = Pulse(20, 50, 0.8, 50e6, 0, Gaussian(5), 0, PulseType.DRIVE, 2) - p4 = Pulse(30, 40, 0.9, 50e6, 0, Gaussian(4), 0, PulseType.DRIVE, 2) - assert p1.is_equal_ignoring_start(p2) - assert not p1.is_equal_ignoring_start(p3) - assert not p1.is_equal_ignoring_start(p4) - - -def test_pulses_pulse_serial(): - p11 = Pulse(0, 40, 0.9, 50_000_000, 0, Gaussian(5), 0, PulseType.DRIVE) - assert ( - p11.serial - == "Pulse(0, 40, 0.9, 50_000_000, 0, Gaussian(5), 0, PulseType.DRIVE, 0)" - ) - assert repr(p11) == p11.serial - - -@pytest.mark.parametrize( - "shape", [Rectangular(), Gaussian(5), GaussianSquare(5, 0.9), Drag(5, 1)] -) -def test_pulses_pulseshape_sampling_rate(shape): - pulse = Pulse(0, 40, 0.9, 100e6, 0, shape, 0, PulseType.DRIVE) - assert len(pulse.envelope_waveform_i(sampling_rate=1).data) == 40 - assert len(pulse.envelope_waveform_i(sampling_rate=100).data) == 4000 - - -def test_pulseshape_eval(): - shape = PulseShape.eval("Rectangular()") - assert isinstance(shape, Rectangular) - with pytest.raises(ValueError): - shape = PulseShape.eval("Ciao()") - - -@pytest.mark.parametrize("rel_sigma,beta", [(5, 1), (5, -1), (3, -0.03), (4, 0.02)]) -def test_drag_shape_eval(rel_sigma, beta): - shape = PulseShape.eval(f"Drag({rel_sigma}, {beta})") - assert isinstance(shape, Drag) - assert shape.rel_sigma == rel_sigma - assert shape.beta == beta - - -def test_raise_shapeiniterror(): - shape = Rectangular() - with pytest.raises(ShapeInitError): - shape.envelope_waveform_i() - with pytest.raises(ShapeInitError): - shape.envelope_waveform_q() - - shape = Gaussian(0) - with pytest.raises(ShapeInitError): - shape.envelope_waveform_i() - with pytest.raises(ShapeInitError): - shape.envelope_waveform_q() - - shape = GaussianSquare(0, 1) - with pytest.raises(ShapeInitError): - shape.envelope_waveform_i() - with pytest.raises(ShapeInitError): - shape.envelope_waveform_q() - - shape = Drag(0, 0) - with pytest.raises(ShapeInitError): - shape.envelope_waveform_i() - with pytest.raises(ShapeInitError): - shape.envelope_waveform_q() - - shape = IIR([0], [0], None) - with pytest.raises(ShapeInitError): - shape.envelope_waveform_i() - with pytest.raises(ShapeInitError): - shape.envelope_waveform_q() - - shape = SNZ(0) - with pytest.raises(ShapeInitError): - shape.envelope_waveform_i() - with pytest.raises(ShapeInitError): - shape.envelope_waveform_q() - - shape = eCap(0) - with pytest.raises(ShapeInitError): - shape.envelope_waveform_i() - with pytest.raises(ShapeInitError): - shape.envelope_waveform_q() - - -def test_pulses_pulseshape_drag_shape(): - pulse = Pulse(0, 2, 1, 4e9, 0, Drag(2, 1), 0, PulseType.DRIVE) - # envelope i & envelope q should cross nearly at 0 and at 2 - waveform = pulse.envelope_waveform_i(sampling_rate=10).data - target_waveform = np.array( - [ - 0.63683161, - 0.69680478, - 0.7548396, - 0.80957165, - 0.85963276, - 0.90370708, - 0.94058806, - 0.96923323, - 0.98881304, - 0.99875078, - 0.99875078, - 0.98881304, - 0.96923323, - 0.94058806, - 0.90370708, - 0.85963276, - 0.80957165, - 0.7548396, - 0.69680478, - 0.63683161, - ] - ) - np.testing.assert_allclose(waveform, target_waveform) - - -def test_pulses_pulse_hash(): - rp = Pulse(0, 40, 0.9, 100e6, 0, Rectangular(), 0, PulseType.DRIVE) - dp = Pulse(0, 40, 0.9, 100e6, 0, Drag(5, 1), 0, PulseType.DRIVE) - hash(rp) - my_dict = {rp: 1, dp: 2} - assert list(my_dict.keys())[0] == rp - assert list(my_dict.keys())[1] == dp - - p1 = Pulse(0, 40, 0.9, 100e6, 0, Drag(5, 1), 0, PulseType.DRIVE) - p2 = Pulse(0, 40, 0.9, 100e6, 0, Drag(5, 1), 0, PulseType.DRIVE) - - assert p1 == p2 - - t0 = 0 - p1 = Pulse(t0, 40, 0.9, 100e6, 0, Drag(5, 1), 0, PulseType.DRIVE) - p2 = p1.shallow_copy() - p3 = p1.copy() - assert p1 == p2 - assert p1 == p3 - - -def test_pulses_pulse_aliases(): - rop = ReadoutPulse( - start=0, - duration=50, - amplitude=0.9, - frequency=20_000_000, - relative_phase=0.0, - shape=Rectangular(), - channel=0, - qubit=0, - ) - assert repr(rop) == "ReadoutPulse(0, 50, 0.9, 20_000_000, 0, Rectangular(), 0, 0)" - - dp = DrivePulse( - start=0, - duration=2000, - amplitude=0.9, - frequency=200_000_000, - relative_phase=0.0, - shape=Gaussian(5), - channel=0, - qubit=0, - ) - assert repr(dp) == "DrivePulse(0, 2000, 0.9, 200_000_000, 0, Gaussian(5), 0, 0)" - - fp = FluxPulse( - start=0, duration=300, amplitude=0.9, shape=Rectangular(), channel=0, qubit=0 - ) - assert repr(fp) == "FluxPulse(0, 300, 0.9, Rectangular(), 0, 0)" - - -def test_pulses_pulsesequence_init(): - p1 = Pulse(400, 40, 0.9, 100e6, 0, Drag(5, 1), 3, PulseType.DRIVE) - p2 = Pulse(500, 40, 0.9, 100e6, 0, Drag(5, 1), 2, PulseType.DRIVE) - p3 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5, 1), 1, PulseType.DRIVE) - - ps = PulseSequence() - assert type(ps) == PulseSequence - - ps = PulseSequence(p1, p2, p3) - assert ps.count == 3 and len(ps) == 3 - assert ps[0] == p1 - assert ps[1] == p2 - assert ps[2] == p3 - - other_ps = p1 + p2 + p3 - assert other_ps.count == 3 and len(other_ps) == 3 - assert other_ps[0] == p1 - assert other_ps[1] == p2 - assert other_ps[2] == p3 - - plist = [p1, p2, p3] - n = 0 - for pulse in ps: - assert plist[n] == pulse - n += 1 - - -def test_pulses_pulsesequence_operators(): - ps = PulseSequence() - ps += ReadoutPulse(800, 200, 0.9, 20e6, 0, Rectangular(), 1) - ps = ps + ReadoutPulse(800, 200, 0.9, 20e6, 0, Rectangular(), 2) - ps = ReadoutPulse(800, 200, 0.9, 20e6, 0, Rectangular(), 3) + ps - - p4 = Pulse(100, 40, 0.9, 50e6, 0, Gaussian(5), 3, PulseType.DRIVE) - p5 = Pulse(200, 40, 0.9, 50e6, 0, Gaussian(5), 2, PulseType.DRIVE) - p6 = Pulse(300, 40, 0.9, 50e6, 0, Gaussian(5), 1, PulseType.DRIVE) - - another_ps = PulseSequence() - another_ps.add(p4) - another_ps.add(p5, p6) - - assert another_ps[0] == p4 - assert another_ps[1] == p5 - assert another_ps[2] == p6 - - ps += another_ps - - assert ps.count == 6 - assert p5 in ps - - # ps.plot() - - p7 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5, 1), 1, PulseType.DRIVE) - yet_another_ps = PulseSequence(p7) - assert yet_another_ps.count == 1 - yet_another_ps *= 3 - assert yet_another_ps.count == 3 - yet_another_ps *= 3 - assert yet_another_ps.count == 9 - - p8 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5, 1), 1, PulseType.DRIVE) - p9 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5, 1), 2, PulseType.DRIVE) - and_yet_another_ps = 2 * p9 + p8 * 3 - assert and_yet_another_ps.count == 5 - - -def test_pulses_pulsesequence_add(): - p0 = Pulse(0, 40, 0.9, 50e6, 0, Gaussian(5), 10, PulseType.DRIVE, 1) - p1 = Pulse(100, 40, 0.9, 50e6, 0, Gaussian(5), 20, PulseType.DRIVE, 2) - - p2 = Pulse(200, 40, 0.9, 50e6, 0, Gaussian(5), 30, PulseType.DRIVE, 3) - p3 = Pulse(400, 40, 0.9, 50e6, 0, Gaussian(5), 40, PulseType.DRIVE, 4) - - ps = PulseSequence() - ps.add(p0) - ps.add(p1) - psx = PulseSequence(p2, p3) - ps.add(psx) - - assert ps.count == 4 - assert ps.qubits == [1, 2, 3, 4] - assert ps.channels == [10, 20, 30, 40] - assert ps.start == 0 - assert ps.finish == 440 - - -def test_pulses_pulsesequence_clear(): - p1 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5, 1), 1, PulseType.DRIVE) - p2 = Pulse(600, 40, 0.9, 100e6, 0, Drag(5, 1), 2, PulseType.DRIVE) - ps = 2 * p2 + p1 * 3 - assert ps.count == 5 - ps.clear() - assert ps.count == 0 - assert ps.is_empty - - -def test_pulses_pulsesequence_start_finish(): - p1 = Pulse(20, 40, 0.9, 200e6, 0, Drag(5, 1), 1, PulseType.DRIVE) - p2 = Pulse(60, 1000, 0.9, 20e6, 0, Rectangular(), 2, PulseType.READOUT) - ps = p1 + p2 - assert ps.start == p1.start - assert ps.finish == p2.finish - - p1.start = None - assert p1.finish is None - p2.duration = None - assert p2.finish is None - - -def test_pulses_pulsesequence_get_channel_pulses(): - p1 = DrivePulse(0, 400, 0.9, 20e6, 0, Gaussian(5), 10) - p2 = ReadoutPulse(100, 400, 0.9, 20e6, 0, Rectangular(), 30) - p3 = DrivePulse(300, 400, 0.9, 20e6, 0, Drag(5, 50), 20) - p4 = DrivePulse(400, 400, 0.9, 20e6, 0, Drag(5, 50), 30) - p5 = ReadoutPulse(500, 400, 0.9, 20e6, 0, Rectangular(), 20) - p6 = DrivePulse(600, 400, 0.9, 20e6, 0, Gaussian(5), 30) - - ps = PulseSequence(p1, p2, p3, p4, p5, p6) - assert ps.channels == [10, 20, 30] - assert ps.get_channel_pulses(10).count == 1 - assert ps.get_channel_pulses(20).count == 2 - assert ps.get_channel_pulses(30).count == 3 - assert ps.get_channel_pulses(20, 30).count == 5 - - -def test_pulses_pulsesequence_get_qubit_pulses(): - p1 = DrivePulse(0, 400, 0.9, 20e6, 0, Gaussian(5), 10, 0) - p2 = ReadoutPulse(100, 400, 0.9, 20e6, 0, Rectangular(), 30, 0) - p3 = DrivePulse(300, 400, 0.9, 20e6, 0, Drag(5, 50), 20, 1) - p4 = DrivePulse(400, 400, 0.9, 20e6, 0, Drag(5, 50), 30, 1) - p5 = ReadoutPulse(500, 400, 0.9, 20e6, 0, Rectangular(), 30, 1) - p6 = FluxPulse(600, 400, 0.9, Rectangular(), 40, 1) - p7 = FluxPulse(900, 400, 0.9, Rectangular(), 40, 2) - - ps = PulseSequence(p1, p2, p3, p4, p5, p6, p7) - assert ps.qubits == [0, 1, 2] - assert ps.get_qubit_pulses(0).count == 2 - assert ps.get_qubit_pulses(1).count == 4 - assert ps.get_qubit_pulses(2).count == 1 - assert ps.get_qubit_pulses(0, 1).count == 6 - - -def test_pulses_pulsesequence_pulses_overlap(): - p1 = DrivePulse(0, 400, 0.9, 20e6, 0, Gaussian(5), 10) - p2 = ReadoutPulse(100, 400, 0.9, 20e6, 0, Rectangular(), 30) - p3 = DrivePulse(300, 400, 0.9, 20e6, 0, Drag(5, 50), 20) - p4 = DrivePulse(400, 400, 0.9, 20e6, 0, Drag(5, 50), 30) - p5 = ReadoutPulse(500, 400, 0.9, 20e6, 0, Rectangular(), 20) - p6 = DrivePulse(600, 400, 0.9, 20e6, 0, Gaussian(5), 30) - - ps = PulseSequence(p1, p2, p3, p4, p5, p6) - assert ps.pulses_overlap == True - assert ps.get_channel_pulses(10).pulses_overlap == False - assert ps.get_channel_pulses(20).pulses_overlap == True - assert ps.get_channel_pulses(30).pulses_overlap == True - - -def test_pulses_pulsesequence_separate_overlapping_pulses(): - p1 = DrivePulse(0, 400, 0.9, 20e6, 0, Gaussian(5), 10) - p2 = ReadoutPulse(100, 400, 0.9, 20e6, 0, Rectangular(), 30) - p3 = DrivePulse(300, 400, 0.9, 20e6, 0, Drag(5, 50), 20) - p4 = DrivePulse(400, 400, 0.9, 20e6, 0, Drag(5, 50), 30) - p5 = ReadoutPulse(500, 400, 0.9, 20e6, 0, Rectangular(), 20) - p6 = DrivePulse(600, 400, 0.9, 20e6, 0, Gaussian(5), 30) - - ps = PulseSequence(p1, p2, p3, p4, p5, p6) - n = 70 - for segregated_ps in ps.separate_overlapping_pulses(): - n += 1 - for pulse in segregated_ps: - pulse.channel = n - - -def test_pulses_pulse_pulse_order(): - t0 = 0 - t = 0 - p1 = DrivePulse(t0, 400, 0.9, 20e6, 0, Gaussian(5), 10) - p2 = ReadoutPulse(p1.finish + t, 400, 0.9, 20e6, 0, Rectangular(), 30) - p3 = DrivePulse(p2.finish, 400, 0.9, 20e6, 0, Drag(5, 50), 20) - ps1 = p1 + p2 + p3 - ps2 = p3 + p1 + p2 - assert ps1 == ps2 - assert hash(ps1) == hash(ps2) - - -def test_pulses_waveform(): - wf1 = Waveform(np.ones(100)) - wf2 = Waveform(np.zeros(100)) - wf3 = Waveform(np.ones(100)) - assert wf1 != wf2 - assert wf1 == wf3 - np.testing.assert_allclose(wf1.data, wf3.data) - assert hash(wf1) == hash(str(np.around(np.ones(100), Waveform.DECIMALS) + 0)) - wf1.serial = "Serial works as a tag. The user can set is as desired" - assert repr(wf1) == wf1.serial - - -def modulate( - i: np.ndarray, - q: np.ndarray, - num_samples: int, - frequency: int, - phase: float, - sampling_rate: float, -): # -> tuple[np.ndarray, np.ndarray]: - time = np.arange(num_samples) / sampling_rate - cosalpha = np.cos(2 * np.pi * frequency * time + phase) - sinalpha = np.sin(2 * np.pi * frequency * time + phase) - mod_matrix = np.array([[cosalpha, -sinalpha], [sinalpha, cosalpha]]) / np.sqrt(2) - result = [] - for n, t, ii, qq in zip(np.arange(num_samples), time, i, q): - result.append(mod_matrix[:, :, n] @ np.array([ii, qq])) - mod_signals = np.array(result) - return mod_signals[:, 0], mod_signals[:, 1] - - -def test_pulses_pulseshape_rectangular(): - pulse = Pulse( - start=0, - duration=50, - amplitude=1, - frequency=200_000_000, - relative_phase=0, - shape=Rectangular(), - channel=1, - qubit=0, - ) - - assert pulse.duration == 50 - assert isinstance(pulse.shape, Rectangular) - assert pulse.shape.name == "Rectangular" - assert repr(pulse.shape) == "Rectangular()" - assert isinstance(pulse.shape.envelope_waveform_i(), Waveform) - assert isinstance(pulse.shape.envelope_waveform_q(), Waveform) - assert isinstance(pulse.shape.modulated_waveform_i(), Waveform) - assert isinstance(pulse.shape.modulated_waveform_q(), Waveform) - - sampling_rate = 1 - num_samples = int(pulse.duration / sampling_rate) - i, q = ( - pulse.amplitude * np.ones(num_samples), - pulse.amplitude * np.zeros(num_samples), - ) - global_phase = ( - 2 * np.pi * pulse._if * pulse.start / 1e9 - ) # pulse start, duration and finish are in ns - mod_i, mod_q = modulate( - i, q, num_samples, pulse._if, global_phase + pulse.relative_phase, sampling_rate - ) - - np.testing.assert_allclose(pulse.shape.envelope_waveform_i(sampling_rate).data, i) - np.testing.assert_allclose(pulse.shape.envelope_waveform_q(sampling_rate).data, q) - np.testing.assert_allclose( - pulse.shape.modulated_waveform_i(sampling_rate).data, mod_i - ) - np.testing.assert_allclose( - pulse.shape.modulated_waveform_q(sampling_rate).data, mod_q - ) - - assert ( - pulse.shape.envelope_waveform_i().serial - == f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)})" - ) - assert ( - pulse.shape.envelope_waveform_q().serial - == f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)})" - ) - assert ( - pulse.shape.modulated_waveform_i().serial - == f"Modulated_Waveform_I(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)}, frequency = {format(pulse._if, '_')}, phase = {format(global_phase + pulse.relative_phase, '.6f').rstrip('0').rstrip('.')})" - ) - assert ( - pulse.shape.modulated_waveform_q().serial - == f"Modulated_Waveform_Q(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)}, frequency = {format(pulse._if, '_')}, phase = {format(global_phase + pulse.relative_phase, '.6f').rstrip('0').rstrip('.')})" - ) - - -def test_pulses_pulseshape_gaussian(): - pulse = Pulse( - start=0, - duration=50, - amplitude=1, - frequency=200_000_000, - relative_phase=0, - shape=Gaussian(5), - channel=1, - qubit=0, - ) - - assert pulse.duration == 50 - assert isinstance(pulse.shape, Gaussian) - assert pulse.shape.name == "Gaussian" - assert pulse.shape.rel_sigma == 5 - assert repr(pulse.shape) == "Gaussian(5)" - assert isinstance(pulse.shape.envelope_waveform_i(), Waveform) - assert isinstance(pulse.shape.envelope_waveform_q(), Waveform) - assert isinstance(pulse.shape.modulated_waveform_i(), Waveform) - assert isinstance(pulse.shape.modulated_waveform_q(), Waveform) - - sampling_rate = 1 - num_samples = int(pulse.duration / sampling_rate) - x = np.arange(0, num_samples, 1) - i = pulse.amplitude * np.exp( - -(1 / 2) - * ( - ((x - (num_samples - 1) / 2) ** 2) - / (((num_samples) / pulse.shape.rel_sigma) ** 2) - ) - ) - q = pulse.amplitude * np.zeros(num_samples) - global_phase = ( - 2 * np.pi * pulse.frequency * pulse.start / 1e9 - ) # pulse start, duration and finish are in ns - mod_i, mod_q = modulate( - i, q, num_samples, pulse._if, global_phase + pulse.relative_phase, sampling_rate - ) - - np.testing.assert_allclose(pulse.shape.envelope_waveform_i(sampling_rate).data, i) - np.testing.assert_allclose(pulse.shape.envelope_waveform_q(sampling_rate).data, q) - np.testing.assert_allclose( - pulse.shape.modulated_waveform_i(sampling_rate).data, mod_i - ) - np.testing.assert_allclose( - pulse.shape.modulated_waveform_q(sampling_rate).data, mod_q - ) - - assert ( - pulse.shape.envelope_waveform_i().serial - == f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)})" - ) - assert ( - pulse.shape.envelope_waveform_q().serial - == f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)})" - ) - assert ( - pulse.shape.modulated_waveform_i().serial - == f"Modulated_Waveform_I(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)}, frequency = {format(pulse._if, '_')}, phase = {format(global_phase + pulse.relative_phase, '.6f').rstrip('0').rstrip('.')})" - ) - assert ( - pulse.shape.modulated_waveform_q().serial - == f"Modulated_Waveform_Q(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)}, frequency = {format(pulse._if, '_')}, phase = {format(global_phase + pulse.relative_phase, '.6f').rstrip('0').rstrip('.')})" - ) - - -def test_pulses_pulseshape_drag(): - pulse = Pulse( - start=0, - duration=50, - amplitude=1, - frequency=200_000_000, - relative_phase=0, - shape=Drag(5, 0.2), - channel=1, - qubit=0, - ) - - assert pulse.duration == 50 - assert isinstance(pulse.shape, Drag) - assert pulse.shape.name == "Drag" - assert pulse.shape.rel_sigma == 5 - assert pulse.shape.beta == 0.2 - assert repr(pulse.shape) == "Drag(5, 0.2)" - assert isinstance(pulse.shape.envelope_waveform_i(), Waveform) - assert isinstance(pulse.shape.envelope_waveform_q(), Waveform) - assert isinstance(pulse.shape.modulated_waveform_i(), Waveform) - assert isinstance(pulse.shape.modulated_waveform_q(), Waveform) - - sampling_rate = 1 - num_samples = int(pulse.duration / 1 * sampling_rate) - x = np.arange(0, num_samples, 1) - i = pulse.amplitude * np.exp( - -(1 / 2) - * ( - ((x - (num_samples - 1) / 2) ** 2) - / (((num_samples) / pulse.shape.rel_sigma) ** 2) - ) - ) - q = ( - pulse.shape.beta - * (-(x - (num_samples - 1) / 2) / ((num_samples / pulse.shape.rel_sigma) ** 2)) - * i - * sampling_rate - ) - global_phase = ( - 2 * np.pi * pulse._if * pulse.start / 1e9 - ) # pulse start, duration and finish are in ns - mod_i, mod_q = modulate( - i, q, num_samples, pulse._if, global_phase + pulse.relative_phase, sampling_rate - ) - - np.testing.assert_allclose(pulse.shape.envelope_waveform_i(sampling_rate).data, i) - np.testing.assert_allclose(pulse.shape.envelope_waveform_q(sampling_rate).data, q) - np.testing.assert_allclose( - pulse.shape.modulated_waveform_i(sampling_rate).data, mod_i - ) - np.testing.assert_allclose( - pulse.shape.modulated_waveform_q(sampling_rate).data, mod_q - ) - - assert ( - pulse.shape.envelope_waveform_i().serial - == f"Envelope_Waveform_I(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)})" - ) - assert ( - pulse.shape.envelope_waveform_q().serial - == f"Envelope_Waveform_Q(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)})" - ) - assert ( - pulse.shape.modulated_waveform_i().serial - == f"Modulated_Waveform_I(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)}, frequency = {format(pulse._if, '_')}, phase = {format(global_phase + pulse.relative_phase, '.6f').rstrip('0').rstrip('.')})" - ) - assert ( - pulse.shape.modulated_waveform_q().serial - == f"Modulated_Waveform_Q(num_samples = {num_samples}, amplitude = {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, shape = {str(pulse.shape)}, frequency = {format(pulse._if, '_')}, phase = {format(global_phase + pulse.relative_phase, '.6f').rstrip('0').rstrip('.')})" - ) - - -def test_pulses_pulseshape_eq(): - """Checks == operator for pulse shapes.""" - - shape1 = Rectangular() - shape2 = Rectangular() - shape3 = Gaussian(5) - assert shape1 == shape2 - assert not shape1 == shape3 - - shape1 = Gaussian(4) - shape2 = Gaussian(4) - shape3 = Gaussian(5) - assert shape1 == shape2 - assert not shape1 == shape3 - - shape1 = GaussianSquare(4, 0.01) - shape2 = GaussianSquare(4, 0.01) - shape3 = GaussianSquare(5, 0.01) - shape4 = GaussianSquare(4, 0.05) - shape5 = GaussianSquare(5, 0.05) - assert shape1 == shape2 - assert not shape1 == shape3 - assert not shape1 == shape4 - assert not shape1 == shape5 - - shape1 = Drag(4, 0.01) - shape2 = Drag(4, 0.01) - shape3 = Drag(5, 0.01) - shape4 = Drag(4, 0.05) - shape5 = Drag(5, 0.05) - assert shape1 == shape2 - assert not shape1 == shape3 - assert not shape1 == shape4 - assert not shape1 == shape5 - - shape1 = IIR([-0.5, 2], [1], Rectangular()) - shape2 = IIR([-0.5, 2], [1], Rectangular()) - shape3 = IIR([-0.5, 4], [1], Rectangular()) - shape4 = IIR([-0.4, 2], [1], Rectangular()) - shape5 = IIR([-0.5, 2], [2], Rectangular()) - shape6 = IIR([-0.5, 2], [2], Gaussian(5)) - assert shape1 == shape2 - assert not shape1 == shape3 - assert not shape1 == shape4 - assert not shape1 == shape5 - assert not shape1 == shape6 - - shape1 = SNZ(5) - shape2 = SNZ(5) - shape3 = SNZ(2) - shape4 = SNZ(2, 0.1) - shape5 = SNZ(2, 0.1) - assert shape1 == shape2 - assert not shape1 == shape3 - assert not shape1 == shape4 - assert not shape1 == shape5 - - shape1 = eCap(4) - shape2 = eCap(4) - shape3 = eCap(5) - assert shape1 == shape2 - assert not shape1 == shape3 - - -def test_pulse(): - duration = 50 - rel_sigma = 5 - beta = 2 - pulse = Pulse( - start=0, - frequency=200_000_000, - amplitude=1, - duration=duration, - relative_phase=0, - shape=f"Drag({rel_sigma}, {beta})", - channel=1, - ) - - target = f"Pulse({pulse.start}, {pulse.duration}, {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, {format(pulse.frequency, '_')}, {format(pulse.relative_phase, '.6f').rstrip('0').rstrip('.')}, {pulse.shape}, {pulse.channel}, {pulse.type}, {pulse.qubit})" - assert pulse.serial == target - assert repr(pulse) == target - - -def test_readout_pulse(): - duration = 2000 - pulse = ReadoutPulse( - start=0, - frequency=200_000_000, - amplitude=1, - duration=duration, - relative_phase=0, - shape=f"Rectangular()", - channel=11, - ) - - target = f"ReadoutPulse({pulse.start}, {pulse.duration}, {format(pulse.amplitude, '.6f').rstrip('0').rstrip('.')}, {format(pulse.frequency, '_')}, {format(pulse.relative_phase, '.6f').rstrip('0').rstrip('.')}, {pulse.shape}, {pulse.channel}, {pulse.qubit})" - assert pulse.serial == target - assert repr(pulse) == target - - -def test_pulse_sequence_add(): - sequence = PulseSequence() - sequence.add( - Pulse( - start=0, - frequency=200_000_000, - amplitude=0.3, - duration=60, - relative_phase=0, - shape="Gaussian(5)", - channel=1, - ) - ) - sequence.add( - Pulse( - start=64, - frequency=200_000_000, - amplitude=0.3, - duration=30, - relative_phase=0, - shape="Gaussian(5)", - channel=1, - ) - ) - assert len(sequence.pulses) == 2 - assert len(sequence.qd_pulses) == 2 - - -def test_pulse_sequence__add__(): - sequence = PulseSequence() - sequence.add( - Pulse( - start=0, - frequency=200_000_000, - amplitude=0.3, - duration=60, - relative_phase=0, - shape="Gaussian(5)", - channel=1, - ) - ) - sequence.add( - Pulse( - start=64, - frequency=200_000_000, - amplitude=0.3, - duration=30, - relative_phase=0, - shape="Gaussian(5)", - channel=1, - ) - ) - with pytest.raises(TypeError): - sequence + 2 - with pytest.raises(TypeError): - 2 + sequence - - -def test_pulse_sequence__mul__(): - sequence = PulseSequence() - sequence.add( - Pulse( - start=0, - frequency=200_000_000, - amplitude=0.3, - duration=60, - relative_phase=0, - shape="Gaussian(5)", - channel=1, - ) - ) - sequence.add( - Pulse( - start=64, - frequency=200_000_000, - amplitude=0.3, - duration=30, - relative_phase=0, - shape="Gaussian(5)", - channel=1, - ) - ) - with pytest.raises(TypeError): - sequence * 2.5 - with pytest.raises(TypeError): - sequence *= 2.5 - with pytest.raises(TypeError): - sequence *= -1 - with pytest.raises(TypeError): - sequence * -1 - with pytest.raises(TypeError): - 2.5 * sequence - - -def test_pulse_sequence_add_readout(): - sequence = PulseSequence() - sequence.add( - Pulse( - start=0, - frequency=200_000_000, - amplitude=0.3, - duration=60, - relative_phase=0, - shape="Gaussian(5)", - channel=1, - ) - ) - - sequence.add( - Pulse( - start=64, - frequency=200_000_000, - amplitude=0.3, - duration=60, - relative_phase=0, - shape="Drag(5, 2)", - channel=1, - type="qf", - ) - ) - - sequence.add( - ReadoutPulse( - start=128, - frequency=20_000_000, - amplitude=0.9, - duration=2000, - relative_phase=0, - shape="Rectangular()", - channel=11, - ) - ) - assert len(sequence.pulses) == 3 - assert len(sequence.ro_pulses) == 1 - assert len(sequence.qd_pulses) == 1 - assert len(sequence.qf_pulses) == 1 - - -def test_envelope_waveform_i_q(): - envelope_i = np.cos(np.arange(0, 10, 0.01)) - envelope_q = np.sin(np.arange(0, 10, 0.01)) - custom_shape_pulse = Custom(envelope_i, envelope_q) - custom_shape_pulse_old_behaviour = Custom(envelope_i) - pulse = Pulse( - start=0, - duration=1000, - amplitude=1, - frequency=10e6, - relative_phase=0, - shape="Rectangular()", - channel=1, - ) - - with pytest.raises(ShapeInitError): - custom_shape_pulse.envelope_waveform_i() - with pytest.raises(ShapeInitError): - custom_shape_pulse.envelope_waveform_q() - - custom_shape_pulse.pulse = pulse - custom_shape_pulse_old_behaviour.pulse = pulse - assert isinstance(custom_shape_pulse.envelope_waveform_i(), Waveform) - assert isinstance(custom_shape_pulse.envelope_waveform_q(), Waveform) - assert isinstance(custom_shape_pulse_old_behaviour.envelope_waveform_q(), Waveform) - pulse.duration = 2000 - with pytest.raises(ValueError): - custom_shape_pulse.pulse = pulse - custom_shape_pulse.envelope_waveform_i() - with pytest.raises(ValueError): - custom_shape_pulse.pulse = pulse - custom_shape_pulse.envelope_waveform_q() diff --git a/tests/test_result.py b/tests/test_result.py deleted file mode 100644 index e861f56796..0000000000 --- a/tests/test_result.py +++ /dev/null @@ -1,162 +0,0 @@ -"""Testing result.py.""" - -import numpy as np -import pytest - -from qibolab.result import ( - AveragedIntegratedResults, - AveragedSampleResults, - IntegratedResults, - RawWaveformResults, - SampleResults, -) - - -def generate_random_iq_result(length=5): - data = np.random.rand(length, length, length) - return IntegratedResults(data) - - -def generate_random_raw_result(length=5): - data = np.random.rand(length, length, length) - return IntegratedResults(data) - - -def generate_random_state_result(length=5): - data = np.random.randint(low=2, size=(length, length, length)) - return SampleResults(data) - - -def generate_random_avg_iq_result(length=5): - data = np.random.rand(length, length, length) - return AveragedIntegratedResults(data) - - -def generate_random_avg_raw_result(length=5): - data = np.random.rand(length, length, length) - return AveragedIntegratedResults(data) - - -def generate_random_avg_state_result(length=5): - data = np.random.randint(low=2, size=(length, length, length)) - return AveragedSampleResults(data) - - -def test_iq_constructor(): - """Testing ExecutionResults constructor.""" - test = np.array([(1, 2), (1, 2)]) - IntegratedResults(test) - - -def test_raw_constructor(): - """Testing ExecutionResults constructor.""" - test = np.array([(1, 2), (1, 2)]) - RawWaveformResults(test) - - -def test_state_constructor(): - """Testing ExecutionResults constructor.""" - test = np.array([1, 1, 0]) - SampleResults(test) - - -@pytest.mark.parametrize("result", ["iq", "raw"]) -def test_integrated_result_properties(result): - """Testing IntegratedResults and RawWaveformResults properties.""" - if result == "iq": - results = generate_random_iq_result(5) - else: - results = generate_random_raw_result(5) - np.testing.assert_equal( - np.sqrt(results.voltage_i**2 + results.voltage_q**2), results.magnitude - ) - np.testing.assert_equal( - np.unwrap(np.arctan2(results.voltage_i, results.voltage_q)), results.phase - ) - - -@pytest.mark.parametrize("state", [0, 1]) -def test_state_probability(state): - """Testing raw_probability method.""" - results = generate_random_state_result(5) - if state == 0: - target_dict = {"probability": results.probability(0)} - else: - target_dict = {"probability": results.probability(1)} - - assert np.allclose( - target_dict["probability"], results.probability(state=state), atol=1e-08 - ) - - -@pytest.mark.parametrize("average", [True, False]) -@pytest.mark.parametrize("result", ["iq", "raw"]) -def test_serialize(average, result): - """Testing to_dict method.""" - if not average: - if result == "iq": - results = generate_random_iq_result(5) - else: - results = generate_random_raw_result(5) - output = results.serialize - target_dict = { - "MSR[V]": results.magnitude, - "i[V]": results.voltage_i, - "q[V]": results.voltage_q, - "phase[rad]": results.phase, - } - assert output.keys() == target_dict.keys() - for key in output: - np.testing.assert_equal(output[key], target_dict[key].flatten()) - else: - if result == "iq": - results = generate_random_avg_iq_result(5) - else: - results = generate_random_avg_iq_result(5) - output = results.serialize - avg = results - target_dict = { - "MSR[V]": np.sqrt(avg.voltage_i**2 + avg.voltage_q**2), - "i[V]": avg.voltage_i, - "q[V]": avg.voltage_q, - "phase[rad]": np.unwrap(np.arctan2(avg.voltage_i, avg.voltage_q)), - } - assert avg.serialize.keys() == target_dict.keys() - for key in output: - np.testing.assert_equal(avg.serialize[key], target_dict[key].flatten()) - - -@pytest.mark.parametrize("average", [True, False]) -def test_serialize_state(average): - """Testing to_dict method.""" - if not average: - results = generate_random_state_result(5) - output = results.serialize - target_dict = { - "0": abs(1 - np.mean(results.samples, axis=0)), - } - assert output.keys() == target_dict.keys() - for key in output: - np.testing.assert_equal(output[key], target_dict[key].flatten()) - else: - results = generate_random_avg_state_result(5) - assert len(results.serialize["0"]) == 125 - - -@pytest.mark.parametrize("result", ["iq", "raw"]) -def test_serialize_averaged_iq_results(result): - """Testing to_dict method.""" - if result == "iq": - results = generate_random_avg_iq_result(5) - else: - results = generate_random_avg_raw_result(5) - output = results.serialize - target_dict = { - "MSR[V]": np.sqrt(results.voltage_i**2 + results.voltage_q**2), - "i[V]": results.voltage_i, - "q[V]": results.voltage_q, - "phase[rad]": np.unwrap(np.arctan2(results.voltage_i, results.voltage_q)), - } - assert output.keys() == target_dict.keys() - for key in output: - np.testing.assert_equal(output[key], target_dict[key].flatten()) diff --git a/tests/test_result_shapes.py b/tests/test_result_shapes.py index 9bb149d3e1..f6bc0704be 100644 --- a/tests/test_result_shapes.py +++ b/tests/test_result_shapes.py @@ -1,95 +1,58 @@ -import numpy as np import pytest -from qibolab import AcquisitionType, AveragingMode, ExecutionParameters -from qibolab.pulses import PulseSequence -from qibolab.result import ( - AveragedIntegratedResults, - AveragedSampleResults, - IntegratedResults, - SampleResults, -) -from qibolab.sweeper import Parameter, Sweeper +from qibolab import AcquisitionType as Acq +from qibolab import AveragingMode as Av NSHOTS = 50 NSWEEP1 = 5 NSWEEP2 = 8 -def execute(platform, acquisition_type, averaging_mode, sweep=False): - qubit = next(iter(platform.qubits)) - - qd_pulse = platform.create_RX_pulse(qubit, start=0) - ro_pulse = platform.create_MZ_pulse(qubit, start=qd_pulse.finish) - sequence = PulseSequence() - sequence.add(qd_pulse) - sequence.add(ro_pulse) - - options = ExecutionParameters( - nshots=NSHOTS, acquisition_type=acquisition_type, averaging_mode=averaging_mode - ) - if sweep: - amp_values = np.arange(0.01, 0.06, 0.01) - freq_values = np.arange(-4e6, 4e6, 1e6) - sweeper1 = Sweeper(Parameter.bias, amp_values, qubits=[platform.qubits[qubit]]) - # sweeper1 = Sweeper(Parameter.amplitude, amp_values, pulses=[qd_pulse]) - sweeper2 = Sweeper(Parameter.frequency, freq_values, pulses=[ro_pulse]) - results = platform.sweep(sequence, options, sweeper1, sweeper2) +@pytest.fixture(params=[False, True]) +def sweep(request): + return None if request.param else [] + + +def test_discrimination_singleshot(execute, sweep): + result = execute(Acq.DISCRIMINATION, Av.SINGLESHOT, NSHOTS, sweep) + if sweep == []: + assert result.shape == (NSHOTS,) else: - results = platform.execute_pulse_sequence(sequence, options) - return results[qubit] - - -@pytest.mark.qpu -@pytest.mark.parametrize("sweep", [False, True]) -def test_discrimination_singleshot(connected_platform, sweep): - result = execute( - connected_platform, - AcquisitionType.DISCRIMINATION, - AveragingMode.SINGLESHOT, - sweep, - ) - assert isinstance(result, SampleResults) - if sweep: - assert result.samples.shape == (NSHOTS, NSWEEP1, NSWEEP2) + assert result.shape == (NSHOTS, NSWEEP1, NSWEEP2) + + +def test_discrimination_cyclic(execute, sweep): + result = execute(Acq.DISCRIMINATION, Av.CYCLIC, NSHOTS, sweep) + if sweep == []: + assert result.shape == tuple() else: - assert result.samples.shape == (NSHOTS,) - - -@pytest.mark.qpu -@pytest.mark.parametrize("sweep", [False, True]) -def test_discrimination_cyclic(connected_platform, sweep): - result = execute( - connected_platform, AcquisitionType.DISCRIMINATION, AveragingMode.CYCLIC, sweep - ) - assert isinstance(result, AveragedSampleResults) - if sweep: - assert result.statistical_frequency.shape == (NSWEEP1, NSWEEP2) + assert result.shape == (NSWEEP1, NSWEEP2) + + +def test_integration_singleshot(execute, sweep): + result = execute(Acq.INTEGRATION, Av.SINGLESHOT, NSHOTS, sweep) + if sweep == []: + assert result.shape == (NSHOTS, 2) else: - assert result.statistical_frequency.shape == tuple() - - -@pytest.mark.qpu -@pytest.mark.parametrize("sweep", [False, True]) -def test_integration_singleshot(connected_platform, sweep): - result = execute( - connected_platform, AcquisitionType.INTEGRATION, AveragingMode.SINGLESHOT, sweep - ) - assert isinstance(result, IntegratedResults) - if sweep: - assert result.voltage.shape == (NSHOTS, NSWEEP1, NSWEEP2) + assert result.shape == (NSHOTS, NSWEEP1, NSWEEP2, 2) + + +def test_integration_cyclic(execute, sweep): + result = execute(Acq.INTEGRATION, Av.CYCLIC, NSHOTS, sweep) + if sweep == []: + assert result.shape == (2,) else: - assert result.voltage.shape == (NSHOTS,) - - -@pytest.mark.qpu -@pytest.mark.parametrize("sweep", [False, True]) -def test_integration_cyclic(connected_platform, sweep): - result = execute( - connected_platform, AcquisitionType.INTEGRATION, AveragingMode.CYCLIC, sweep - ) - assert isinstance(result, AveragedIntegratedResults) - if sweep: - assert result.voltage.shape == (NSWEEP1, NSWEEP2) + assert result.shape == (NSWEEP1, NSWEEP2, 2) + + +def test_raw_singleshot(execute): + result = execute(Acq.RAW, Av.SINGLESHOT, NSHOTS, []) + assert result.shape == (NSHOTS, int(execute.acquisition_duration), 2) + + +def test_raw_cyclic(execute, sweep): + result = execute(Acq.RAW, Av.CYCLIC, NSHOTS, sweep) + if sweep == []: + assert result.shape == (int(execute.acquisition_duration), 2) else: - assert result.voltage.shape == tuple() + assert result.shape == (NSWEEP1, NSWEEP2, int(execute.acquisition_duration), 2) diff --git a/tests/test_sequence.py b/tests/test_sequence.py new file mode 100644 index 0000000000..84eb3de596 --- /dev/null +++ b/tests/test_sequence.py @@ -0,0 +1,377 @@ +from copy import deepcopy + +from pydantic import TypeAdapter + +from qibolab._core.pulses import ( + Acquisition, + Delay, + Drag, + Gaussian, + Pulse, + Readout, + Rectangular, + VirtualZ, +) +from qibolab._core.sequence import PulseSequence + + +def test_init(): + sequence = PulseSequence() + assert len(sequence) == 0 + + +def test_init_with_iterable(): + sc = "some/probe" + oc = "other/drive" + c5 = "5/drive" + seq = PulseSequence( + [ + (sc, p) + for p in [ + Pulse(duration=20, amplitude=0.1, envelope=Gaussian(rel_sigma=3)), + Pulse(duration=30, amplitude=0.5, envelope=Gaussian(rel_sigma=3)), + ] + ] + + [(oc, Pulse(duration=40, amplitude=0.2, envelope=Gaussian(rel_sigma=3)))] + + [ + (c5, p) + for p in [ + Pulse(duration=45, amplitude=1.0, envelope=Gaussian(rel_sigma=3)), + Pulse(duration=50, amplitude=0.7, envelope=Gaussian(rel_sigma=3)), + Pulse(duration=60, amplitude=-0.65, envelope=Gaussian(rel_sigma=3)), + ] + ] + ) + + assert len(seq) == 6 + assert set(seq.channels) == {sc, oc, c5} + assert len(list(seq.channel(sc))) == 2 + assert len(list(seq.channel(oc))) == 1 + assert len(list(seq.channel(c5))) == 3 + + +def test_serialization(): + sp = "some/probe" + sa = "some/acquisition" + od = "other/drive" + of = "other/flux" + + seq = PulseSequence( + [ + (sp, Delay(duration=10)), + (sa, Delay(duration=20)), + (of, Pulse(duration=10, amplitude=1, envelope=Rectangular())), + (od, VirtualZ(phase=0.6)), + (od, Pulse(duration=10, amplitude=1, envelope=Rectangular())), + (sp, Pulse(duration=100, amplitude=0.3, envelope=Gaussian(rel_sigma=0.1))), + (sa, Acquisition(duration=150)), + ] + ) + + aslist = TypeAdapter(PulseSequence).dump_python(seq) + assert PulseSequence.load(aslist) == seq + + +def test_durations(): + sequence = PulseSequence() + sequence.append(("ch1/probe", Delay(duration=20))) + sequence.append( + ("ch1/probe", Pulse(duration=1000, amplitude=0.9, envelope=Rectangular())) + ) + sequence.append( + ( + "ch2/drive", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ) + ) + assert sequence.channel_duration("ch1/probe") == 20 + 1000 + assert sequence.channel_duration("ch2/drive") == 40 + assert sequence.duration == 20 + 1000 + + sequence.append( + ("ch2/drive", Pulse(duration=1200, amplitude=0.9, envelope=Rectangular())) + ) + assert sequence.duration == 40 + 1200 + + +def test_concatenate(): + p1 = Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)) + sequence1 = PulseSequence([("ch1", p1)]) + p2 = Pulse(duration=60, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)) + sequence2 = PulseSequence([("ch2", p2)]) + + sequence1.concatenate(sequence2) + assert set(sequence1.channels) == {"ch1", "ch2"} + assert len(list(sequence1.channel("ch1"))) == 1 + assert len(list(sequence1.channel("ch2"))) == 1 + assert sequence1.duration == 60 + + sequence3 = PulseSequence( + [ + ( + "ch2", + Pulse(duration=80, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch3", + Pulse( + duration=100, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1) + ), + ), + ] + ) + + sequence1.concatenate(sequence3) + assert sequence1.channels == {"ch1", "ch2", "ch3"} + assert len(list(sequence1.channel("ch1"))) == 1 + assert len(list(sequence1.channel("ch2"))) == 2 + assert len(list(sequence1.channel("ch3"))) == 2 + assert isinstance(next(iter(sequence1.channel("ch3"))), Delay) + assert sequence1.duration == 60 + 100 + assert sequence1.channel_duration("ch1") == 40 + assert sequence1.channel_duration("ch2") == 60 + 80 + assert sequence1.channel_duration("ch3") == 60 + 100 + + # Check order preservation, even with various channels + vz = VirtualZ(phase=0.1) + s1 = PulseSequence([("a", p1), ("b", vz)]) + s2 = PulseSequence([("a", vz), ("a", p2)]) + s1.concatenate(s2) + assert isinstance(s1[0][1], Pulse) + assert s1[0][0] == "a" + assert isinstance(s1[1][1], VirtualZ) + assert s1[1][0] == "b" + assert isinstance(s1[2][1], VirtualZ) + assert s1[2][0] == "a" + assert isinstance(s1[3][1], Pulse) + assert s1[3][0] == "a" + + # Check aliases + sa1 = deepcopy(s1) + sc1 = deepcopy(s1) + sa1 <<= s2 + sc1.concatenate(s2) + assert sa1 == sc1 + assert sc1 == s1 << s2 + + +def test_juxtapose(): + p1 = Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)) + sequence1 = PulseSequence([("ch1", p1)]) + p2 = Pulse(duration=60, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)) + sequence2 = PulseSequence([("ch2", p2)]) + + sequence1.juxtapose(sequence2) + assert set(sequence1.channels) == {"ch1", "ch2"} + assert len(list(sequence1.channel("ch1"))) == 1 + assert len(list(sequence1.channel("ch2"))) == 2 + assert sequence1.duration == 40 + 60 + channel, delay = sequence1[1] + assert channel == "ch2" + assert isinstance(delay, Delay) + assert delay.duration == 40 + + sequence3 = PulseSequence( + [ + ( + "ch2", + Pulse(duration=80, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch3", + Pulse( + duration=100, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1) + ), + ), + ] + ) + + sequence1.juxtapose(sequence3) + assert sequence1.channels == {"ch1", "ch2", "ch3"} + assert len(list(sequence1.channel("ch1"))) == 2 + assert len(list(sequence1.channel("ch2"))) == 3 + assert len(list(sequence1.channel("ch3"))) == 2 + assert isinstance(next(iter(sequence1.channel("ch3"))), Delay) + assert sequence1.duration == 40 + 60 + 100 + assert sequence1.channel_duration("ch1") == 40 + 60 + assert sequence1.channel_duration("ch2") == 40 + 60 + 80 + assert sequence1.channel_duration("ch3") == 40 + 60 + 100 + delay = list(sequence1.channel("ch3"))[0] + assert isinstance(delay, Delay) + assert delay.duration == 100 + + # Check order preservation, even with various channels + vz = VirtualZ(phase=0.1) + s1 = PulseSequence([("a", p1), ("b", vz)]) + s2 = PulseSequence([("a", vz), ("a", p2)]) + s1.juxtapose(s2) + target_channels = ["a", "b", "b", "a", "a"] + target_pulse_types = [Pulse, VirtualZ, Delay, VirtualZ, Pulse] + for i, (channel, pulse) in enumerate(s1): + assert channel == target_channels[i] + assert isinstance(pulse, target_pulse_types[i]) + + # Check aliases + sa1 = deepcopy(s1) + sc1 = deepcopy(s1) + sa1 |= s2 + sc1.juxtapose(s2) + assert sa1 == sc1 + assert sc1 == s1 | s2 + + +def test_copy(): + sequence = PulseSequence( + [ + ( + "ch1", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch2", + Pulse(duration=60, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch2", + Pulse(duration=80, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ] + ) + + sequence_copy = sequence.copy() + assert isinstance(sequence_copy, PulseSequence) + assert sequence_copy == sequence + + sequence_copy.append( + ( + "ch3", + Pulse(duration=100, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ) + ) + assert "ch3" not in sequence + + +def test_align_to_delay(): + sequence = PulseSequence( + [ + ( + "ch1", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch1", + Delay(duration=20), + ), + ( + "ch1", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch2", + Pulse(duration=60, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch2", + Pulse(duration=80, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ] + ) + sequence.align(["ch1", "ch2"]) + sequence.append( + ( + "ch1", + Pulse(duration=20, amplitude=0.1, envelope=Gaussian(rel_sigma=3)), + ) + ) + sequence.append( + ( + "ch2", + Pulse(duration=30, amplitude=0.1, envelope=Gaussian(rel_sigma=3)), + ) + ) + + delay_sequence = sequence.align_to_delays() + assert len(delay_sequence) == len(sequence) - 1 + for (ch1, p1), (ch2, p2) in zip(sequence[:5], delay_sequence[:5]): + assert ch1 == ch2 + assert p1 is p2 + assert delay_sequence[5] == ("ch1", Delay(duration=40)) + for (ch1, p1), (ch2, p2) in zip(sequence[7:], delay_sequence[6:]): + assert ch1 == ch2 + assert p1 is p2 + # assert that pulses after align start simultaneously + sequence_without_last = delay_sequence[:-2] + ch1_start = sequence_without_last.channel_duration("ch1") + ch2_start = sequence_without_last.channel_duration("ch2") + assert ch1_start == ch2_start + + +def test_trim(): + p = Pulse(duration=40, amplitude=0.9, envelope=Rectangular()) + d = Delay(duration=10) + vz = VirtualZ(phase=0.1) + sequence = PulseSequence( + [ + ("a", p), + ("a", d), + ("b", d), + ("b", d), + ("c", d), + ("c", p), + ("d", p), + ("d", vz), + ] + ) + trimmed = sequence.trim() + # the final delay is dropped + assert len(list(trimmed.channel("a"))) == 1 + # only delays, all dropped + assert len(list(trimmed.channel("b"))) == 0 + # initial delay is kept + assert len(list(trimmed.channel("c"))) == 2 + # the order is preserved + assert isinstance(next(iter(trimmed.channel("d"))), Pulse) + + +def test_acquisitions(): + probe = Pulse(duration=10, amplitude=1, envelope=Rectangular()) + acq = Acquisition(duration=10) + sequence = PulseSequence.load( + [ + ("1/drive", VirtualZ(phase=0.7)), + ("1/probe", Delay(duration=15)), + ("1/acquisition", Delay(duration=20)), + ("1/probe", probe), + ("1/acquisition", acq), + ("1/flux", probe), + ] + ) + acqs = sequence.acquisitions + assert len(acqs) == 1 + assert acqs[0][1] is acq + + +def test_readouts(): + probe = Pulse(duration=10, amplitude=1, envelope=Rectangular()) + acq = Acquisition(duration=10) + sequence = PulseSequence([("1/acquisition", Readout(probe=probe, acquisition=acq))]) + assert len(sequence) == 1 + ro = sequence[0][1] + assert isinstance(ro, Readout) + assert ro.duration == acq.duration + assert ro.id == acq.id + + sequence = PulseSequence( + [ + ("1/drive", VirtualZ(phase=0.7)), + ("1/acquisition", Delay(duration=20)), + ("1/acquisition", Readout(probe=probe, acquisition=acq)), + ("1/flux", probe), + ] + ) + assert len(sequence) == 4 + assert len(sequence.acquisitions) == 1 + assert isinstance(sequence.acquisitions[0][1], Readout) + + aslist = TypeAdapter(PulseSequence).dump_python(sequence) + assert PulseSequence.load(aslist) == sequence diff --git a/tests/test_serialize.py b/tests/test_serialize.py new file mode 100644 index 0000000000..914c6bcfb7 --- /dev/null +++ b/tests/test_serialize.py @@ -0,0 +1,21 @@ +import numpy as np +from pydantic import BaseModel, ConfigDict + +from qibolab._core.serialize import NdArray, eq + + +class ArrayModel(BaseModel): + ar: NdArray + + model_config = ConfigDict(arbitrary_types_allowed=True) + + +def test_equality(): + assert eq(ArrayModel(ar=np.arange(10)), ArrayModel(ar=np.arange(10))) + assert not eq(ArrayModel(ar=np.arange(10)), ArrayModel(ar=np.arange(11))) + ar = np.arange(10) + ar[5:] = 42 + assert not eq(ArrayModel(ar=np.arange(10)), ArrayModel(ar=ar)) + + assert not eq(ArrayModel(ar=np.arange(10)), ArrayModel(ar=np.ones((10, 2)))) + assert eq(ArrayModel(ar=np.ones((10, 2))), ArrayModel(ar=np.ones((10, 2)))) diff --git a/tests/test_sweeper.py b/tests/test_sweeper.py index 6bf1d465d7..7f337acf7a 100644 --- a/tests/test_sweeper.py +++ b/tests/test_sweeper.py @@ -1,43 +1,75 @@ import numpy as np import pytest -from qibolab.pulses import Pulse, Rectangular -from qibolab.qubits import Qubit -from qibolab.sweeper import Parameter, QubitParameter, Sweeper +from qibolab._core.pulses import Pulse, Rectangular +from qibolab._core.sweeper import Parameter, Sweeper @pytest.mark.parametrize("parameter", Parameter) def test_sweeper_pulses(parameter): - pulse = Pulse(0, 40, 0.1, int(1e9), 0.0, Rectangular(), "channel") + pulse = Pulse( + duration=40, + amplitude=0.1, + envelope=Rectangular(), + ) if parameter is Parameter.amplitude: parameter_range = np.random.rand(10) else: parameter_range = np.random.randint(10, size=10) - if parameter in QubitParameter: - with pytest.raises(ValueError): - sweeper = Sweeper(parameter, parameter_range, [pulse]) + if parameter in Parameter.channels(): + with pytest.raises(ValueError, match="channels"): + _ = Sweeper(parameter=parameter, values=parameter_range, pulses=[pulse]) else: - sweeper = Sweeper(parameter, parameter_range, [pulse]) + sweeper = Sweeper(parameter=parameter, values=parameter_range, pulses=[pulse]) assert sweeper.parameter is parameter @pytest.mark.parametrize("parameter", Parameter) -def test_sweeper_qubits(parameter): - qubit = Qubit(0) +def test_sweeper_channels(parameter): + channel = "0/probe" parameter_range = np.random.randint(10, size=10) - if parameter in QubitParameter: - sweeper = Sweeper(parameter, parameter_range, qubits=[qubit]) + if parameter in Parameter.channels(): + sweeper = Sweeper( + parameter=parameter, values=parameter_range, channels=[channel] + ) assert sweeper.parameter is parameter else: - with pytest.raises(ValueError): - sweeper = Sweeper(parameter, parameter_range, qubits=[qubit]) + with pytest.raises(ValueError, match="pulses"): + _ = Sweeper(parameter=parameter, values=parameter_range, channels=[channel]) def test_sweeper_errors(): - pulse = Pulse(0, 40, 0.1, int(1e9), 0.0, Rectangular(), "channel") - qubit = Qubit(0) + channel = "0/probe" + pulse = Pulse( + duration=40, + amplitude=0.1, + envelope=Rectangular(), + ) parameter_range = np.random.randint(10, size=10) - with pytest.raises(ValueError): - Sweeper(Parameter.frequency, parameter_range) - with pytest.raises(ValueError): - Sweeper(Parameter.frequency, parameter_range, [pulse], [qubit]) + with pytest.raises(ValueError, match="(?=.*pulses)(?=.*channels)"): + Sweeper(parameter=Parameter.frequency, values=parameter_range) + with pytest.raises(ValueError, match="(?=.*pulses)(?=.*channels)"): + Sweeper( + parameter=Parameter.frequency, + values=parameter_range, + pulses=[pulse], + channels=[channel], + ) + with pytest.raises(ValueError, match="(?=.*range)(?=.*values)"): + Sweeper( + parameter=Parameter.frequency, + values=parameter_range, + range=(0, 10, 1), + channels=[channel], + ) + with pytest.raises(ValueError, match="(?=.*range)(?=.*values)"): + Sweeper( + parameter=Parameter.frequency, + channels=[channel], + ) + with pytest.raises(ValueError, match="Amplitude"): + Sweeper( + parameter=Parameter.amplitude, + range=(0, 2, 0.2), + pulses=[pulse], + ) diff --git a/tests/test_unrolling.py b/tests/test_unrolling.py index 95ca775050..e81fe0ce74 100644 --- a/tests/test_unrolling.py +++ b/tests/test_unrolling.py @@ -2,30 +2,57 @@ import pytest -from qibolab.pulses import Drag, Pulse, PulseSequence, PulseType, Rectangular -from qibolab.unrolling import Bounds, batch +from qibolab._core.platform import Platform +from qibolab._core.pulses import Delay, Drag, Pulse, Rectangular +from qibolab._core.pulses.pulse import Acquisition +from qibolab._core.sequence import PulseSequence +from qibolab._core.unrolling import Bounds, batch, unroll_sequences def test_bounds_update(): - p1 = Pulse(400, 40, 0.9, int(100e6), 0, Drag(5, 1), 3, PulseType.DRIVE) - p2 = Pulse(500, 40, 0.9, int(100e6), 0, Drag(5, 1), 2, PulseType.DRIVE) - p3 = Pulse(600, 40, 0.9, int(100e6), 0, Drag(5, 1), 1, PulseType.DRIVE) + ps = PulseSequence.load( + [ + ( + "ch3/drive", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch2/drive", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch1/drive", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch3/probe", + Pulse(duration=1000, amplitude=0.9, envelope=Rectangular()), + ), + ( + "ch2/probe", + Pulse(duration=1000, amplitude=0.9, envelope=Rectangular()), + ), + ( + "ch1/probe", + Pulse(duration=1000, amplitude=0.9, envelope=Rectangular()), + ), + ( + "ch1/acquisition", + Acquisition(duration=3000), + ), + ] + ) - p4 = Pulse(440, 1000, 0.9, int(20e6), 0, Rectangular(), 3, PulseType.READOUT) - p5 = Pulse(540, 1000, 0.9, int(20e6), 0, Rectangular(), 2, PulseType.READOUT) - p6 = Pulse(640, 1000, 0.9, int(20e6), 0, Rectangular(), 1, PulseType.READOUT) - - ps = PulseSequence(p1, p2, p3, p4, p5, p6) bounds = Bounds.update(ps) assert bounds.waveforms >= 40 - assert bounds.readout == 3 + assert bounds.readout == 1 assert bounds.instructions > 1 def test_bounds_add(): - bounds1 = Bounds(2, 1, 3) - bounds2 = Bounds(1, 2, 1) + bounds1 = Bounds(waveforms=2, readout=1, instructions=3) + bounds2 = Bounds(waveforms=1, readout=2, instructions=1) bounds_sum = bounds1 + bounds2 @@ -35,8 +62,8 @@ def test_bounds_add(): def test_bounds_comparison(): - bounds1 = Bounds(2, 1, 3) - bounds2 = Bounds(1, 2, 1) + bounds1 = Bounds(waveforms=2, readout=1, instructions=3) + bounds2 = Bounds(waveforms=1, readout=2, instructions=1) assert bounds1 > bounds2 assert not bounds2 < bounds1 @@ -45,23 +72,52 @@ def test_bounds_comparison(): @pytest.mark.parametrize( "bounds", [ - Bounds(150, int(10e6), int(10e6)), - Bounds(int(10e6), 10, int(10e6)), - Bounds(int(10e6), int(10e6), 20), + Bounds(waveforms=150, readout=int(10e6), instructions=int(10e6)), + Bounds(waveforms=int(10e6), readout=10, instructions=int(10e6)), + Bounds(waveforms=int(10e6), readout=int(10e6), instructions=20), ], ) def test_batch(bounds): - p1 = Pulse(400, 40, 0.9, int(100e6), 0, Drag(5, 1), 3, PulseType.DRIVE) - p2 = Pulse(500, 40, 0.9, int(100e6), 0, Drag(5, 1), 2, PulseType.DRIVE) - p3 = Pulse(600, 40, 0.9, int(100e6), 0, Drag(5, 1), 1, PulseType.DRIVE) - - p4 = Pulse(440, 1000, 0.9, int(20e6), 0, Rectangular(), 3, PulseType.READOUT) - p5 = Pulse(540, 1000, 0.9, int(20e6), 0, Rectangular(), 2, PulseType.READOUT) - p6 = Pulse(640, 1000, 0.9, int(20e6), 0, Rectangular(), 1, PulseType.READOUT) - - ps = PulseSequence(p1, p2, p3, p4, p5, p6) + ps = PulseSequence.load( + [ + ( + "ch3/drive", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch2/drive", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ( + "ch1/drive", + Pulse(duration=40, amplitude=0.9, envelope=Drag(rel_sigma=0.2, beta=1)), + ), + ("ch3/probe", Pulse(duration=1000, amplitude=0.9, envelope=Rectangular())), + ("ch3/acquisition", Acquisition(duration=1000)), + ("ch2/probe", Pulse(duration=1000, amplitude=0.9, envelope=Rectangular())), + ("ch2/acquisition", Acquisition(duration=1000)), + ("ch1/probe", Pulse(duration=1000, amplitude=0.9, envelope=Rectangular())), + ("ch1/acquisition", Acquisition(duration=1000)), + ] + ) sequences = 10 * [ps] batches = list(batch(sequences, bounds)) assert len(batches) > 1 + + +def test_unroll_sequences(platform: Platform): + qubit = next(iter(platform.qubits.values())) + assert qubit.probe is not None + natives = platform.natives.single_qubit[0] + assert natives.RX is not None + assert natives.MZ is not None + sequence = PulseSequence() + sequence.concatenate(natives.RX.create_sequence()) + sequence.append((qubit.probe, Delay(duration=sequence.duration))) + sequence.concatenate(natives.MZ.create_sequence()) + total_sequence, readouts = unroll_sequences(10 * [sequence], relaxation_time=10000) + assert len(total_sequence.acquisitions) == 10 + assert len(readouts) == 1 + assert all(len(readouts[acq.id]) == 10 for _, acq in sequence.acquisitions)