diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 6dd0a1f4c0..9b6d9db5d1 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -10,7 +10,7 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - python-version: [3.6, 3.7, 3.8, 3.9] + python-version: [3.7, 3.8, 3.9] os: ["ubuntu-latest", "macOS-latest", "windows-latest"] steps: - uses: actions/checkout@v2 diff --git a/docs/_ext/autodoc_analysis.py b/docs/_ext/autodoc_analysis.py new file mode 100644 index 0000000000..73c0cac5a9 --- /dev/null +++ b/docs/_ext/autodoc_analysis.py @@ -0,0 +1,67 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Documentation extension for analysis class. +""" + +from typing import Any + +from docs._ext.custom_styles.styles import AnalysisDocstring +from qiskit_experiments.framework.base_analysis import BaseAnalysis +from sphinx.application import Sphinx +from sphinx.ext.autodoc import ClassDocumenter + + +class AnalysisDocumenter(ClassDocumenter): + """Sphinx extension for the custom documentation of the standard analysis class.""" + + objtype = "analysis" + directivetype = 'class' + priority = 10 + ClassDocumenter.priority + option_spec = dict(ClassDocumenter.option_spec) + + @classmethod + def can_document_member( + cls, member: Any, membername: str, isattr: bool, parent: Any + ) -> bool: + return isinstance(member, BaseAnalysis) + + def add_content(self, more_content: Any, no_docstring: bool = False) -> None: + sourcename = self.get_sourcename() + + # analysis class doesn't have explicit init method. + class_doc = self.get_doc()[0] + + # format experiment documentation into the analysis style + class_doc_parser = AnalysisDocstring( + target_cls=self.object, + docstring_lines=class_doc, + config=self.env.app.config, + indent=self.content_indent, + ) + + # write introduction + for i, line in enumerate(self.process_doc(class_doc_parser.generate_class_docs())): + self.add_line(line, sourcename, i) + self.add_line("", sourcename) + + # method and attributes + if more_content: + for line, src in zip(more_content.data, more_content.items): + self.add_line(line, src[0], src[1]) + + +def setup(app: Sphinx): + existing_documenter = app.registry.documenters.get(AnalysisDocumenter.objtype) + if existing_documenter is None or not issubclass(existing_documenter, AnalysisDocumenter): + app.add_autodocumenter(AnalysisDocumenter, override=True) diff --git a/docs/_ext/autodoc_experiment.py b/docs/_ext/autodoc_experiment.py new file mode 100644 index 0000000000..389854d881 --- /dev/null +++ b/docs/_ext/autodoc_experiment.py @@ -0,0 +1,80 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Documentation extension for experiment class. +""" + +from typing import Any + +from docs._ext.custom_styles.styles import ExperimentDocstring +from qiskit.exceptions import QiskitError +from qiskit_experiments.framework.base_experiment import BaseExperiment +from sphinx.application import Sphinx +from sphinx.ext.autodoc import ClassDocumenter + + +class ExperimentDocumenter(ClassDocumenter): + """Sphinx extension for the custom documentation of the standard experiment class.""" + + objtype = "experiment" + directivetype = 'class' + priority = 10 + ClassDocumenter.priority + option_spec = dict(ClassDocumenter.option_spec) + + @classmethod + def can_document_member( + cls, member: Any, membername: str, isattr: bool, parent: Any + ) -> bool: + return isinstance(member, BaseExperiment) + + def add_content(self, more_content: Any, no_docstring: bool = False) -> None: + sourcename = self.get_sourcename() + + try: + class_doc, init_doc = self.get_doc() + except ValueError: + raise QiskitError( + f"Documentation of {self.name} doesn't match with the expected format." + "Please run sphinx build without using the experiment template." + ) + + # format experiment documentation into the experiment style + class_doc_parser = ExperimentDocstring( + target_cls=self.object, + docstring_lines=class_doc, + config=self.env.app.config, + indent=self.content_indent, + ) + + # write introduction + for i, line in enumerate(self.process_doc(class_doc_parser.generate_class_docs())): + self.add_line(line, sourcename, i) + self.add_line("", sourcename) + + # write init method documentation + self.add_line(".. rubric:: Initialization", sourcename) + self.add_line("", sourcename) + for i, line in enumerate(self.process_doc([init_doc])): + self.add_line(line, sourcename, i) + self.add_line("", sourcename) + + # method and attributes + if more_content: + for line, src in zip(more_content.data, more_content.items): + self.add_line(line, src[0], src[1]) + + +def setup(app: Sphinx): + existing_documenter = app.registry.documenters.get(ExperimentDocumenter.objtype) + if existing_documenter is None or not issubclass(existing_documenter, ExperimentDocumenter): + app.add_autodocumenter(ExperimentDocumenter, override=True) diff --git a/docs/_ext/autoref.py b/docs/_ext/autoref.py new file mode 100644 index 0000000000..6a4c42a4ae --- /dev/null +++ b/docs/_ext/autoref.py @@ -0,0 +1,105 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Helper directive to generate reference in convenient form. +""" +import arxiv + +from docutils import nodes +from docutils.parsers.rst import Directive +from sphinx.application import Sphinx + + +class WebSite(Directive): + """A custom helper directive for showing website link. + + This can be used, for example, + + .. code-block:: + + .. ref_website:: qiskit-experiments, https://github.com/Qiskit/qiskit-experiments + + """ + required_arguments = 1 + optional_arguments = 0 + final_argument_whitespace = True + + def run(self): + try: + name, url = self.arguments[0].split(",") + except ValueError: + raise ValueError( + f"{self.arguments[0]} is invalid website directive format. " + "Name and URL should be separated by a single comma." + ) + + link_name = nodes.paragraph(text=f"{name} ") + link_name += nodes.reference(text="(open)", refuri=url) + + return [link_name] + + +class Arxiv(Directive): + """A custom helper directive for generating journal information from arXiv id. + + This directive takes two arguments + + - Arbitrary reference name (no white space should be included) + + - arXiv ID + + This can be used, for example, + + .. code-block:: + + .. ref_arxiv:: qasm3-paper 2104.14722 + + If an article is not found, no journal information will be shown. + + """ + required_arguments = 2 + optional_arguments = 0 + final_argument_whitespace = False + + def run(self): + + # search arXiv database + try: + search = arxiv.Search(id_list=[self.arguments[1]]) + paper = next(search.results()) + except Exception: + return [] + + # generate journal link nodes + ret_node = nodes.paragraph() + + journal = "" + if paper.journal_ref: + journal += f", {paper.journal_ref}, " + if paper.doi: + journal += f"doi: {paper.doi}" + + ret_node += nodes.Text(f"[{self.arguments[0]}] ") + ret_node += nodes.Text(", ".join([author.name for author in paper.authors]) + ", ") + ret_node += nodes.emphasis(text=f"{paper.title}") + if journal: + ret_node += nodes.Text(journal) + ret_node += nodes.Text(" ") + ret_node += nodes.reference(text="(open)", refuri=paper.pdf_url) + + return [ret_node] + + +def setup(app: Sphinx): + app.add_directive("ref_arxiv", Arxiv) + app.add_directive("ref_website", WebSite) diff --git a/docs/_ext/custom_styles/example/__init__.py b/docs/_ext/custom_styles/example/__init__.py new file mode 100644 index 0000000000..fc54e4b2c8 --- /dev/null +++ b/docs/_ext/custom_styles/example/__init__.py @@ -0,0 +1,48 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +======================================================================= +Example Documentation (:mod:`qiskit_experiments.documentation.example`) +======================================================================= + +.. currentmodule:: qiskit_experiments.documentation.example + + +.. warning:: + + This module is just an example for documentation. Do not import. + +.. note:: + + Under the autosummary directive you need to set template to trigger custom documentation. + + +Experiments +=========== +.. autosummary:: + :toctree: ../stubs/ + :template: autosummary/experiment.rst + + DocumentedExperiment + +Analysis +======== +.. autosummary:: + :toctree: ../stubs/ + :template: autosummary/analysis.rst + + DocumentedCurveAnalysis + +""" + +from .example_experiment import DocumentedExperiment, DocumentedCurveAnalysis diff --git a/docs/_ext/custom_styles/example/example_experiment.py b/docs/_ext/custom_styles/example/example_experiment.py new file mode 100644 index 0000000000..1fa3a0ac4a --- /dev/null +++ b/docs/_ext/custom_styles/example/example_experiment.py @@ -0,0 +1,218 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Class documentation examples. + +.. warning:: + + This module is just an example for documentation. Do not import. + +""" + +from qiskit.providers import Options + +from qiskit_experiments.curve_analysis.curve_analysis import CurveAnalysis +from qiskit_experiments.framework.base_experiment import BaseExperiment + + +class DocumentedCurveAnalysis(CurveAnalysis): + r"""One line summary of this class. This is shown in the top level contains list. + + # section: overview + Overview of this analysis. It is recommended to write this section. + Here you can explain technical aspect of fit algorithm or fit model. + Standard reStructuredText directives can be used. + + You can use following sections + + - ``warning`` + - ``note`` + - ``example`` + - ``reference`` + - ``tutorial`` + + See :class:`DocumentedExperiment` for description of these sections. + In addition to above sections, analysis template provides following extra sections. + + # section: fit_model + Here you can describe your fitting model. + Standard reStructuredText directives can be used. For example: + + .. math:: + + F(x) = a \exp(-(x-f)^2/(2\sigma^2)) + b + + enables you to use the Latex syntax to write your equation. + + # section: fit_parameters + Here you can explain fit parameter details. + This section provides a special syntax to describe details of each parameter. + Documentation except for this syntax will be just ignored. + + defpar a: + desc: Description of parameter :math:`a`. + init_guess: Here you can describe how this analysis estimate initial guess of + parameter :math:`a`. + bounds: Here you can describe how this analysis bounds parameter :math:`a` value + during the fit. + + defpar b: + desc: Description of parameter :math:`b`. + init_guess: Here you can describe how this analysis estimate initial guess of + parameter :math:`b`. + bounds: Here you can describe how this analysis bounds parameter :math:`b` value + during the fit. + + Note that you cannot write text block (i.e. bullet lines, math mode, parsed literal, ...) + in the ``defpar`` syntax items. These are a single line description of parameters. + You can write multiple ``defpar`` block for each fitting parameter. + + It would be nice if parameter names conform to the parameter key values appearing in the + analysis result. For example, if fit model defines the parameter :math:`\sigma` and + this appears as ``eta`` in the result, user cannot find correspondence of these parameters. + + """ + + @classmethod + def _default_options(cls) -> Options: + """Default analysis options. + + .. note:: + + This method documentation should conforms to the below documentation syntax. + Namely, the title should be "Analysis Options" followed by a single colon + and description should be written in the Google docstring style. + Numpy style is not accepted. + + Google style docstring guideline: + https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html + + Documentation except for the analysis options will be just ignored, e.g. this note. + If analysis options contains some values from the parent class, + the custom Sphinx parser searches for the parent class method documentation + and automatically generate documentation for all available options. + If there is any missing documentation the Sphinx build will fail. + + Analysis Options: + opt1 (int): Description for the option1. + opt2 (bool): Description for the option2. + opt3 (str): Description for the option3. + + """ + opts = super()._default_options() + opts.opt1 = 1.0 + opts.opt2 = True + opts.opt3 = "opt3" + + return opts + + +class DocumentedExperiment(BaseExperiment): + """One line summary of this class. This is shown in the top level contains list. + + # section: overview + Overview of this experiment. It is recommended to write this section. + Here you can explain technical aspect of experiment, protocol, etc... + Standard reStructuredText directives can be used. + + # section: warning + Warning about this experiment if exist. + Some functionality is not available or under development, + you should write these details here. + + # section: note + Notification about this experiment if exist. + + # section: example + Example code of this experiment. + If this experiment requires user to manage complicated options, + it might be convenient for users to have some code example here. + + You can write code example, for example, as follows + + .. code-block:: python + + import qiskit_experiments + my_experiment = qiskit_experiments.MyExperiment(**options) + + # section: reference + Currently this supports article reference in arXiv database. + You can use following helper directive. + + .. ref_arxiv:: Auth2020a 21xx.01xxx + + This directive takes two arguments separated by a whitespace. + The first argument is arbitrary label for this article, which may be used to + refer to this paper from other sections. + Second argument is the arXiv ID of the paper referring to. + Once this directive is inserted, Sphinx searches the arXiv database and + automatically generates a formatted bibliography with the hyperlink to the online PDF. + + # section: tutorial + You can refer to the arbitrary web page here. + Following helper directive can be used. + + .. ref_website:: Qiskit Experiment Github, https://github.com/Qiskit/qiskit-experiments + + This directive takes two arguments separated by a comma. + The first argument is arbitrary label shown before the link. Whitespace can be included. + The second argument is the URL of the website to hyperlink. + + """ + + @classmethod + def _default_experiment_options(cls) -> Options: + """Default experiment options. + + .. note:: + + This method documentation should conforms to the below documentation syntax. + Namely, the title should be "Experiment Options" followed by a single colon + and description should be written in the Google docstring style. + Numpy style is not accepted. + + Google style docstring guideline: + https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html + + Documentation except for the experiment options will be just ignored, e.g. this note. + If experiment options contains some values from the parent class, + the custom Sphinx parser searches for the parent class method documentation + and automatically generate documentation for all available options. + If there is any missing documentation the Sphinx build will fail. + + Experiment Options: + opt1 (int): Description for the option1. + opt2 (bool): Description for the option2. + opt3 (str): Description for the option3. + + """ + opts = super()._default_experiment_options() + opts.opt1 = 1.0 + opts.opt2 = True + opts.opt3 = "opt3" + + return opts + + def __init__(self, qubit: int): + """Create new experiment. + + .. note:: + + This documentation is shown as-is. + + Args: + qubit: The qubit to run experiment. + """ + super().__init__(qubits=[qubit]) + + def circuits(self, backend=None): + pass diff --git a/docs/_ext/custom_styles/formatter.py b/docs/_ext/custom_styles/formatter.py new file mode 100644 index 0000000000..40c61892ac --- /dev/null +++ b/docs/_ext/custom_styles/formatter.py @@ -0,0 +1,205 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +A class that formats documentation sections. +""" +from typing import List +from .utils import _check_no_indent + + +class DocstringSectionFormatter: + """A class that formats parsed docstring lines. + + This formatter formats sections with Google Style Python Docstrings with + several reStructuredText directives. + """ + + def __init__(self, indent: str): + self.indent = indent + + def format_header(self, lines: List[str]) -> List[str]: + """Format header section.""" + format_lines = lines + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_overview(self, lines: List[str]) -> List[str]: + """Format overview section.""" + format_lines = [".. rubric:: Overview", ""] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_reference(self, lines: List[str]) -> List[str]: + """Format reference section.""" + format_lines = [".. rubric:: References", ""] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + def format_warning(self, lines: List[str]) -> List[str]: + """Format warning section.""" + format_lines = [".. warning::", ""] + for line in lines: + format_lines.append(self.indent + line) + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_example(self, lines: List[str]) -> List[str]: + """Format example section.""" + format_lines = [".. rubric:: Example", ""] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + def format_note(self, lines: List[str]) -> List[str]: + """Format notification section.""" + format_lines = [".. note::", ""] + for line in lines: + format_lines.append(self.indent + line) + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_tutorial(self, lines: List[str]) -> List[str]: + """Format tutorial section.""" + format_lines = [".. rubric:: Tutorials", ""] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + +class ExperimentSectionFormatter(DocstringSectionFormatter): + """Formatter for experiment class.""" + + @_check_no_indent + def format_analysis_ref(self, lines: List[str]) -> List[str]: + """Format analysis class reference section.""" + format_lines = [".. rubric:: Analysis Class Reference", ""] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_experiment_opts(self, lines: List[str]) -> List[str]: + """Format experiment options section.""" + format_lines = [ + ".. rubric:: Experiment Options", + "", + "These options can be set by :py:meth:`set_experiment_options` method.", + "", + ] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_analysis_opts(self, lines: List[str]) -> List[str]: + """Format analysis options section.""" + format_lines = [ + ".. rubric:: Analysis Options", + "", + "These options can be set by :py:meth:`set_analysis_options` method.", + "", + ] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_transpiler_opts(self, lines: List[str]) -> List[str]: + """Format transpiler options section.""" + format_lines = [ + ".. rubric:: Transpiler Options", + "", + "This option can be set by :py:meth:`set_transpile_options` method.", + "", + ] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_run_opts(self, lines: List[str]) -> List[str]: + """Format run options section.""" + format_lines = [ + ".. rubric:: Backend Run Options", + "", + "This option can be set by :py:meth:`set_run_options` method.", + "", + ] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + +class AnalysisSectionFormatter(DocstringSectionFormatter): + """Formatter for analysis class.""" + + @_check_no_indent + def format_analysis_opts(self, lines: List[str]) -> List[str]: + """Format analysis options section.""" + format_lines = [ + ".. rubric:: Run Options", + "", + "These are the keyword arguments of :py:meth:`run` method.", + "", + ] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_fit_model(self, lines: List[str]) -> List[str]: + """Format fit model section.""" + format_lines = [ + ".. rubric:: Fit Model", + "", + "This is the curve fitting analysis. ", + "Following equation(s) are used to represent curve(s).", + "", + ] + format_lines.extend(lines) + format_lines.append("") + + return format_lines + + @_check_no_indent + def format_fit_parameters(self, lines: List[str]) -> List[str]: + """Format fit parameter section.""" + format_lines = [ + ".. rubric:: Fit Parameters", + "", + "Following fit parameters are estimated during the analysis.", + "", + ] + format_lines.extend(lines) + format_lines.append("") + + return format_lines diff --git a/docs/_ext/custom_styles/section_parsers.py b/docs/_ext/custom_styles/section_parsers.py new file mode 100644 index 0000000000..870d2011ae --- /dev/null +++ b/docs/_ext/custom_styles/section_parsers.py @@ -0,0 +1,90 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Documentation section parsers. +""" + +import re +from typing import List + +from .utils import _trim_empty_lines + + +def load_standard_section(docstring_lines: List[str]) -> List[str]: + """Load standard docstring section.""" + return _trim_empty_lines(docstring_lines) + + +def load_fit_parameters(docstring_lines: List[str]) -> List[str]: + """Load fit parameter section.""" + regex_paramdef = re.compile(r"defpar (?P.+):") + + # item finder + description_kind = { + "desc": re.compile(r"desc: (?P.+)"), + "init_guess": re.compile(r"init_guess: (?P.+)"), + "bounds": re.compile(r"bounds: (?P.+)"), + } + + # parse lines + parameter_desc = dict() + current_param = None + current_item = None + for line in docstring_lines: + if not list: + # remove line feed + continue + + # check if line is new parameter definition + match = re.match(regex_paramdef, line) + if match: + current_param = match["param"] + parameter_desc[current_param] = { + "desc": "", + "init_guess": "", + "bounds": "", + } + continue + + # check description + for kind, regex in description_kind.items(): + match = re.search(regex, line) + if match: + current_item = kind + line = match["s"].rstrip() + + # add line if parameter and item are already set + if current_param and current_item: + if parameter_desc[current_param][current_item]: + parameter_desc[current_param][current_item] += " " + line.lstrip() + else: + parameter_desc[current_param][current_item] = line.lstrip() + + section_lines = list() + + def write_description(header: str, kind: str): + section_lines.append(header) + for param, desc in parameter_desc.items(): + if not desc: + section_lines.append( + f" - :math:`{param}`: No description is provided. See source for details." + ) + else: + section_lines.append(f" - :math:`{param}`: {desc[kind]}") + section_lines.append("") + + write_description("Descriptions", "desc") + write_description("Initial Guess", "init_guess") + write_description("Boundaries", "bounds") + + return _trim_empty_lines(section_lines) diff --git a/docs/_ext/custom_styles/styles.py b/docs/_ext/custom_styles/styles.py new file mode 100644 index 0000000000..91d2dfaa3c --- /dev/null +++ b/docs/_ext/custom_styles/styles.py @@ -0,0 +1,323 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Documentation extension for experiment class. +""" +import copy +import re +import sys +from abc import ABC +from typing import Union, List, Dict + +from qiskit_experiments.framework.base_analysis import BaseAnalysis +from qiskit_experiments.framework.base_experiment import BaseExperiment +from sphinx.config import Config as SphinxConfig + +from .formatter import ( + ExperimentSectionFormatter, + AnalysisSectionFormatter, + DocstringSectionFormatter, +) +from .section_parsers import load_standard_section, load_fit_parameters +from .utils import _generate_options_documentation, _format_default_options + +section_regex = re.compile(r"# section: (?P\S+)") + + +class QiskitExperimentDocstring(ABC): + """Qiskit Experiment style docstring parser base class.""" + + # mapping of sections supported by this style to parsing method or function + __sections__ = {} + + # section formatter + __formatter__ = DocstringSectionFormatter + + def __init__( + self, + target_cls: object, + docstring_lines: Union[str, List[str]], + config: SphinxConfig, + indent: str = "", + ): + """Create new parser and parse formatted docstring.""" + + if isinstance(docstring_lines, str): + lines = docstring_lines.splitlines() + else: + lines = docstring_lines + + self._target_cls = target_cls + self._indent = indent + self._config = config + + self._parsed_lines = self._classify(lines) + + def _classify(self, docstrings: List[str]) -> Dict[str, List[str]]: + """Classify formatted docstring into sections.""" + sectioned_docstrings = dict() + + def add_new_section(section: str, lines: List[str]): + if lines: + parser = self.__sections__[section] + if not parser: + raise KeyError( + f"Section {section} is automatically generated section. " + "This section cannot be overridden by class docstring." + ) + sectioned_docstrings[section] = parser(temp_lines) + + current_section = list(self.__sections__.keys())[0] + temp_lines = list() + margin = sys.maxsize + for docstring_line in docstrings: + match = re.match(section_regex, docstring_line.strip()) + if match: + section_name = match["section_name"] + if section_name in self.__sections__: + # parse previous section + if margin < sys.maxsize: + temp_lines = [l[margin:] for l in temp_lines] + add_new_section(current_section, temp_lines) + # set new section + current_section = section_name + temp_lines.clear() + margin = sys.maxsize + else: + raise KeyError(f"Section name {section_name} is invalid.") + continue + + # calculate section indent + if len(docstring_line) > 0 and not docstring_line.isspace(): + # ignore empty line + indent = len(docstring_line) - len(docstring_line.lstrip()) + margin = min(indent, margin) + + temp_lines.append(docstring_line) + + # parse final section + if margin < sys.maxsize: + temp_lines = [l[margin:] for l in temp_lines] + add_new_section(current_section, temp_lines) + + for section, lines in self._extra_sections().items(): + sectioned_docstrings[section] = lines + + return sectioned_docstrings + + def _extra_sections(self) -> Dict[str, List[str]]: + """Generate extra sections.""" + pass + + def _format(self) -> Dict[str, List[str]]: + """Format each section with predefined formatter.""" + formatter = self.__formatter__(self._indent) + + formatted_sections = {section: None for section in self.__sections__} + for section, lines in self._parsed_lines.items(): + if not lines: + continue + section_formatter = getattr(formatter, f"format_{section}", None) + if section_formatter: + formatted_sections[section] = section_formatter(lines) + else: + formatted_sections[section] = lines + [""] + + return formatted_sections + + def generate_class_docs(self) -> List[List[str]]: + """Output formatted experiment class documentation.""" + formatted_sections = self._format() + + classdoc_lines = [] + for section_lines in formatted_sections.values(): + if section_lines: + classdoc_lines.extend(section_lines) + + return [classdoc_lines] + + +class ExperimentDocstring(QiskitExperimentDocstring): + """Documentation parser for the experiment class introduction.""" + + __sections__ = { + "header": load_standard_section, + "warning": load_standard_section, + "overview": load_standard_section, + "reference": load_standard_section, + "tutorial": load_standard_section, + "analysis_ref": None, + "experiment_opts": None, + "analysis_opts": None, + "transpiler_opts": None, + "run_opts": None, + "example": load_standard_section, + "note": load_standard_section, + } + + __formatter__ = ExperimentSectionFormatter + + def __init__( + self, + target_cls: BaseExperiment, + docstring_lines: Union[str, List[str]], + config: SphinxConfig, + indent: str = "", + ): + """Create new parser and parse formatted docstring.""" + super().__init__(target_cls, docstring_lines, config, indent) + + def _extra_sections(self) -> Dict[str, List[str]]: + """Generate extra sections.""" + parsed_sections = {} + + # add analysis class reference + analysis_class = getattr(self._target_cls, "__analysis_class__", None) + if analysis_class: + analysis_ref = f":py:class:`~{analysis_class.__module__}.{analysis_class.__name__}`" + parsed_sections["analysis_ref"] = [analysis_ref] + + # add experiment option + exp_option_desc = [] + + exp_docs_config = copy.copy(self._config) + exp_docs_config.napoleon_custom_sections = [("experiment options", "args")] + exp_option = _generate_options_documentation( + current_class=self._target_cls, + method_name="_default_experiment_options", + config=exp_docs_config, + indent=self._indent, + ) + if exp_option: + exp_option_desc.extend(exp_option) + exp_option_desc.append("") + exp_option_desc.extend( + _format_default_options( + defaults=self._target_cls._default_experiment_options().__dict__, + indent=self._indent, + ) + ) + else: + exp_option_desc.append("No experiment option available for this experiment.") + + parsed_sections["experiment_opts"] = exp_option_desc + + # add analysis option + analysis_option_desc = [] + + if analysis_class: + analysis_docs_config = copy.copy(self._config) + analysis_docs_config.napoleon_custom_sections = [("analysis options", "args")] + analysis_option = _generate_options_documentation( + current_class=analysis_class, + method_name="_default_options", + config=analysis_docs_config, + indent=self._indent, + ) + + if analysis_option: + analysis_option_desc.extend(analysis_option) + analysis_option_desc.append("") + analysis_option_desc.extend( + _format_default_options( + defaults=analysis_class._default_options().__dict__, + indent=self._indent, + ) + ) + else: + analysis_option_desc.append("No analysis option available for this experiment.") + + parsed_sections["analysis_opts"] = analysis_option_desc + + # add transpiler option + transpiler_option_desc = [ + "This option is used for circuit optimization. ", + "See `Qiskit Transpiler `_ documentation for available options.", + "", + ] + transpiler_option_desc.extend( + _format_default_options( + defaults=self._target_cls._default_transpile_options().__dict__, + indent=self._indent, + ) + ) + + parsed_sections["transpiler_opts"] = transpiler_option_desc + + # add run option + run_option_desc = [ + "This option is used for controlling job execution condition. " + "Note that this option is provider dependent. " + "See provider's backend runner API for available options. " + "See `here `_ for IBM Quantum Service.", + "", + ] + run_option_desc.extend( + _format_default_options( + defaults=self._target_cls._default_run_options().__dict__, + indent=self._indent, + ) + ) + + parsed_sections["run_opts"] = run_option_desc + + return parsed_sections + + +class AnalysisDocstring(QiskitExperimentDocstring): + """Documentation parser for the analysis class introduction.""" + + __sections__ = { + "header": load_standard_section, + "warning": load_standard_section, + "overview": load_standard_section, + "fit_model": load_standard_section, + "fit_parameters": load_fit_parameters, + "reference": load_standard_section, + "tutorial": load_standard_section, + "analysis_opts": None, + "example": load_standard_section, + "note": load_standard_section, + } + + __formatter__ = AnalysisSectionFormatter + + def __init__( + self, + target_cls: BaseAnalysis, + docstring_lines: Union[str, List[str]], + config: SphinxConfig, + indent: str = "", + ): + """Create new parser and parse formatted docstring.""" + super().__init__(target_cls, docstring_lines, config, indent) + + def _extra_sections(self) -> Dict[str, List[str]]: + """Generate extra sections.""" + parsed_sections = {} + + # add analysis option + analysis_docs_config = copy.copy(self._config) + analysis_docs_config.napoleon_custom_sections = [("analysis options", "args")] + analysis_option = _generate_options_documentation( + current_class=self._target_cls, + method_name="_default_options", + config=analysis_docs_config, + indent=self._indent, + ) + if analysis_option: + parsed_sections["analysis_opts"] = analysis_option + + return parsed_sections diff --git a/docs/_ext/custom_styles/utils.py b/docs/_ext/custom_styles/utils.py new file mode 100644 index 0000000000..46e7e63381 --- /dev/null +++ b/docs/_ext/custom_styles/utils.py @@ -0,0 +1,162 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +A collection of utilities to generate documentation. +""" + +import inspect +import re +from typing import List, Tuple, Dict, Any, Callable + +from sphinx.config import Config as SphinxConfig +from sphinx.ext.napoleon.docstring import GoogleDocstring +from sphinx.util.docstrings import prepare_docstring + + +def _trim_empty_lines(docstring_lines: List[str]) -> List[str]: + """A helper function to remove redundant line feeds.""" + i_start = 0 + lines_iter = iter(docstring_lines) + while not next(lines_iter): + i_start += 1 + + i_end = len(docstring_lines) + lines_iter = iter(docstring_lines[::-1]) + while not next(lines_iter): + i_end -= 1 + + return docstring_lines[i_start:i_end] + + +def _parse_option_field( + docstring: str, + config: SphinxConfig, + target_args: List[str], + indent: str = "", +) -> Tuple[List[str], List[str]]: + """A helper function to extract descriptions of target arguments.""" + + # use GoogleDocstring parameter parser + experiment_option_parser = GoogleDocstring( + docstring=prepare_docstring(docstring, tabsize=len(indent)), config=config + ) + parsed_lines = experiment_option_parser.lines() + + # remove redundant descriptions + param_regex = re.compile(r":(param|type) (?P\S+):") + target_params_description = [] + described_params = set() + valid_line = False + for line in parsed_lines: + is_item = re.match(param_regex, line) + if is_item: + if is_item["pname"] in target_args: + valid_line = True + described_params.add(is_item["pname"]) + else: + valid_line = False + if valid_line: + target_params_description.append(line) + + # find missing parameters + missing = set(target_args) - described_params + + return target_params_description, list(missing) + + +def _generate_options_documentation( + current_class: object, + method_name: str, + target_args: List[str] = None, + config: SphinxConfig = None, + indent: str = "", +) -> List[str]: + """Automatically generate documentation from the default options method.""" + + if current_class == object: + # check if no more base class + raise Exception(f"Option docstring for {', '.join(target_args)} is missing.") + + options_docstring_lines = [] + + default_opts = getattr(current_class, method_name, None) + if not default_opts: + # getter option is not defined + return [] + + if not target_args: + target_args = list(default_opts().__dict__.keys()) + + # parse default options method + parsed_lines, target_args = _parse_option_field( + docstring=default_opts.__doc__ or "", + config=config, + target_args=target_args, + indent=indent, + ) + + if target_args: + # parse parent class method docstring if some arg documentation is missing + parent_parsed_lines = _generate_options_documentation( + current_class=inspect.getmro(current_class)[1], + method_name=method_name, + target_args=target_args, + config=config, + indent=indent, + ) + options_docstring_lines.extend(parent_parsed_lines) + + options_docstring_lines.extend(parsed_lines) + + if options_docstring_lines: + return _trim_empty_lines(options_docstring_lines) + + return options_docstring_lines + + +def _format_default_options(defaults: Dict[str, Any], indent: str = "") -> List[str]: + """Format default options to docstring lines.""" + docstring_lines = [ + ".. dropdown:: Default values", + indent + ":animate: fade-in-slide-down", + "", + ] + + if not defaults: + docstring_lines.append(indent + "No default options are set.") + else: + docstring_lines.append(indent + "Following values are set by default.") + docstring_lines.append("") + docstring_lines.append(indent + ".. parsed-literal::") + docstring_lines.append("") + for par, value in defaults.items(): + if callable(value): + value_repr = f"Callable {value.__name__}" + else: + value_repr = repr(value) + docstring_lines.append(indent * 2 + f"{par:<25} := {value_repr}") + + return docstring_lines + + +def _check_no_indent(method: Callable) -> Callable: + """Check indent of lines and return if this block is correctly indented.""" + def wraps(self, lines: List[str], *args, **kwargs): + if all(l.startswith(" ") for l in lines): + text_block = "\n".join(lines) + raise ValueError( + "Following documentation may have invalid indentation. " + f"Please carefully check all indent levels are aligned. \n\n{text_block}" + ) + return method(self, lines, *args, **kwargs) + + return wraps diff --git a/docs/_templates/autosummary/analysis.rst b/docs/_templates/autosummary/analysis.rst new file mode 100644 index 0000000000..222df215af --- /dev/null +++ b/docs/_templates/autosummary/analysis.rst @@ -0,0 +1,49 @@ +{% if referencefile %} +.. include:: {{ referencefile }} +{% endif %} + +{{ objname }} +{{ underline }} + +.. currentmodule:: {{ module }} + +.. autoanalysis:: {{ objname }} + :no-members: + :no-inherited-members: + :no-special-members: + + {% block attributes_summary %} + {% if attributes %} + + .. rubric:: Attributes + + .. autosummary:: + :toctree: ../stubs/ + {% for item in all_attributes %} + {%- if not item.startswith('_') %} + {{ name }}.{{ item }} + {%- endif -%} + {%- endfor %} + {% endif %} + {% endblock %} + + {% block methods_summary %} + {% if methods %} + + .. rubric:: Methods + + .. autosummary:: + :toctree: ../stubs/ + {% for item in all_methods %} + {%- if not item.startswith('_') or item in ['__call__', '__mul__', '__getitem__', '__len__'] %} + {{ name }}.{{ item }} + {%- endif -%} + {%- endfor %} + {% for item in inherited_members %} + {%- if item in ['__call__', '__mul__', '__getitem__', '__len__'] %} + {{ name }}.{{ item }} + {%- endif -%} + {%- endfor %} + + {% endif %} + {% endblock %} diff --git a/docs/_templates/autosummary/experiment.rst b/docs/_templates/autosummary/experiment.rst new file mode 100644 index 0000000000..01800ea10b --- /dev/null +++ b/docs/_templates/autosummary/experiment.rst @@ -0,0 +1,49 @@ +{% if referencefile %} +.. include:: {{ referencefile }} +{% endif %} + +{{ objname }} +{{ underline }} + +.. currentmodule:: {{ module }} + +.. autoexperiment:: {{ objname }} + :no-members: + :no-inherited-members: + :no-special-members: + + {% block attributes_summary %} + {% if attributes %} + + .. rubric:: Attributes + + .. autosummary:: + :toctree: ../stubs/ + {% for item in all_attributes %} + {%- if not item.startswith('_') %} + {{ name }}.{{ item }} + {%- endif -%} + {%- endfor %} + {% endif %} + {% endblock %} + + {% block methods_summary %} + {% if methods %} + + .. rubric:: Methods + + .. autosummary:: + :toctree: ../stubs/ + {% for item in all_methods %} + {%- if not item.startswith('_') or item in ['__call__', '__mul__', '__getitem__', '__len__'] %} + {{ name }}.{{ item }} + {%- endif -%} + {%- endfor %} + {% for item in inherited_members %} + {%- if item in ['__call__', '__mul__', '__getitem__', '__len__'] %} + {{ name }}.{{ item }} + {%- endif -%} + {%- endfor %} + + {% endif %} + {% endblock %} diff --git a/docs/conf.py b/docs/conf.py index 79c501e4fd..9fed00b22b 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -23,9 +23,10 @@ # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # -# import os -# import sys -# sys.path.insert(0, os.path.abspath('.')) +import os +import sys +sys.path.insert(0, os.path.abspath('.')) +sys.path.append(os.path.abspath("./_ext")) """ Sphinx documentation builder @@ -37,7 +38,7 @@ os.environ['QISKIT_DOCS'] = 'TRUE' # -- Project information ----------------------------------------------------- -project = 'Qiskit ODE Solvers' +project = 'Qiskit Experiments' copyright = '2021, Qiskit Development Team' # pylint: disable=redefined-builtin author = 'Qiskit Development Team' @@ -92,6 +93,9 @@ 'sphinx_panels', 'sphinx.ext.intersphinx', 'nbsphinx', + 'autoref', + 'autodoc_experiment', + 'autodoc_analysis', ] html_static_path = ['_static'] templates_path = ['_templates'] diff --git a/docs/tutorials/calibrating_armonk.ipynb b/docs/tutorials/calibrating_armonk.ipynb new file mode 100644 index 0000000000..9a2df7d01d --- /dev/null +++ b/docs/tutorials/calibrating_armonk.ipynb @@ -0,0 +1,1956 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "charged-grill", + "metadata": {}, + "source": [ + "# Calibrating single-qubit gates on Armonk\n", + "\n", + "In this tutorial we demonstrate how to calibrate single-qubit gates on Armonk using the Calibration framework in qiskit-experiments. We will run experiments to find the qubit frequency, calibrate the amplitude of DRAG pulses and chose the value of the DRAG parameter that minimizes leakage. The calibration framework requires the user to\n", + "\n", + "* setup an instance of `Calibrations` or `BackendCalibrations`,\n", + "* run calibration experiments which can be found either in `qiskit_experiments.library.calibration` or `qiskit_experiments.library.characterization`, and\n", + "* update the values of the parameters stored in the instance of `Calibrations` (or `BackendCalibrations`) using `Update` classes. \n", + "\n", + "You will see that the `Update` classes are not meant to be instantiated but provide an `update` class method to extract calibrated parameter values and add them to the calibrations." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "czech-strength", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "import qiskit.pulse as pulse\n", + "from qiskit.circuit import Parameter\n", + "\n", + "from qiskit_experiments.calibration_management.backend_calibrations import BackendCalibrations\n", + "\n", + "from qiskit import IBMQ, schedule" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "oriental-league", + "metadata": {}, + "outputs": [], + "source": [ + "IBMQ.load_account()\n", + "provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')\n", + "backend = provider.get_backend('ibmq_armonk')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "every-diploma", + "metadata": {}, + "outputs": [], + "source": [ + "qubit = 0 # The qubit we will work with" + ] + }, + { + "cell_type": "markdown", + "id": "local-entry", + "metadata": {}, + "source": [ + "The two functions below show how to setup an instance of `BackendCalibrations`. To do this the user defines the template schedules to calibrate. These template schedules are fully parameterized, even the channel indices on which the pulses are played. Furthermore, the name of the parameter in the channel index must follow the convention laid out in the documentation of the calibration module. Note that the parameters in the channel indices are automatically mapped to the channel index when `get_schedule` is called. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "indie-dominican", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_cals(backend) -> BackendCalibrations:\n", + " \"\"\"A function to instantiate calibrations and add a couple of template schedules.\"\"\"\n", + " cals = BackendCalibrations(backend)\n", + "\n", + " dur = Parameter(\"dur\")\n", + " amp = Parameter(\"amp\")\n", + " sigma = Parameter(\"σ\")\n", + " beta = Parameter(\"β\")\n", + " drive = pulse.DriveChannel(Parameter(\"ch0\"))\n", + "\n", + " # Define and add template schedules.\n", + " with pulse.build(name=\"xp\") as xp:\n", + " pulse.play(pulse.Drag(dur, amp, sigma, beta), drive)\n", + "\n", + " with pulse.build(name=\"xm\") as xm:\n", + " pulse.play(pulse.Drag(dur, -amp, sigma, beta), drive)\n", + " \n", + " with pulse.build(name=\"x90p\") as x90p:\n", + " pulse.play(pulse.Drag(dur, Parameter(\"amp\"), sigma, Parameter(\"β\")), drive)\n", + "\n", + " cals.add_schedule(xp)\n", + " cals.add_schedule(xm)\n", + " cals.add_schedule(x90p)\n", + " \n", + " return cals\n", + "\n", + "def add_parameter_guesses(cals: BackendCalibrations):\n", + " \"\"\"Add guesses for the parameter values to the calibrations.\"\"\"\n", + " for sched in [\"xp\", \"x90p\"]:\n", + " cals.add_parameter_value(80, \"σ\", schedule=sched)\n", + " cals.add_parameter_value(0.5, \"β\", schedule=sched)\n", + " cals.add_parameter_value(320, \"dur\", schedule=sched)\n", + " cals.add_parameter_value(0.5, \"amp\", schedule=sched)" + ] + }, + { + "cell_type": "markdown", + "id": "opened-ghost", + "metadata": {}, + "source": [ + "When setting up the calibrations we add three pulses: a $\\pi$-rotation, with a schedule named `xp`, a schedule `xm` identical to `xp` but with a nagative amplitude, and a $\\pi/2$-rotation, with a schedule named `x90p`. Here, we have linked the amplitude of the `xp` and `xm` pulses. Therefore, calibrating the parameters of `xp` will also calibrate the parameters of `xm`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "numerical-bradford", + "metadata": {}, + "outputs": [], + "source": [ + "cals = setup_cals(backend)\n", + "add_parameter_guesses(cals)" + ] + }, + { + "cell_type": "markdown", + "id": "stupid-investigation", + "metadata": {}, + "source": [ + "## 1. Finding qubits with spectroscopy\n", + "\n", + "Here, we are using a backend for which we already know the qubit frequency. We will therefore use the spectroscopy experiment to confirm that there is a resonance at the qubit frequency reported by the backend." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "located-roots", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_experiments.library.characterization.qubit_spectroscopy import QubitSpectroscopy" + ] + }, + { + "cell_type": "markdown", + "id": "diagnostic-thailand", + "metadata": {}, + "source": [ + "We first show the contents of the calibrations for qubit 0. Note that the guess values that we added before apply to all qubits on the chip. We see this in the table below as an empty tuple `()` in the qubits column. Observe that the parameter values of `xm` do not appear in this table as they are given by the values of `xp`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "indirect-faculty", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
valuedate_timevalidexp_idgroupqubitsparameterschedule
05.000000e-012021-07-20 19:25:02.649323+0000TrueNonedefault()βx90p
13.200000e+022021-07-20 19:25:02.649313+0000TrueNonedefault()durxp
24.971659e+092021-07-20 19:25:02.648323+0000TrueNonedefault(0,)qubit_lo_freqNone
35.000000e-012021-07-20 19:25:02.649331+0000TrueNonedefault()ampx90p
46.993371e+092021-07-20 19:25:02.648345+0000TrueNonedefault(0,)meas_lo_freqNone
58.000000e+012021-07-20 19:25:02.649298+0000TrueNonedefault()σxp
63.200000e+022021-07-20 19:25:02.649328+0000TrueNonedefault()durx90p
75.000000e-012021-07-20 19:25:02.649308+0000TrueNonedefault()βxp
85.000000e-012021-07-20 19:25:02.649316+0000TrueNonedefault()ampxp
98.000000e+012021-07-20 19:25:02.649320+0000TrueNonedefault()σx90p
\n", + "
" + ], + "text/plain": [ + " value date_time valid exp_id group \\\n", + "0 5.000000e-01 2021-07-20 19:25:02.649323+0000 True None default \n", + "1 3.200000e+02 2021-07-20 19:25:02.649313+0000 True None default \n", + "2 4.971659e+09 2021-07-20 19:25:02.648323+0000 True None default \n", + "3 5.000000e-01 2021-07-20 19:25:02.649331+0000 True None default \n", + "4 6.993371e+09 2021-07-20 19:25:02.648345+0000 True None default \n", + "5 8.000000e+01 2021-07-20 19:25:02.649298+0000 True None default \n", + "6 3.200000e+02 2021-07-20 19:25:02.649328+0000 True None default \n", + "7 5.000000e-01 2021-07-20 19:25:02.649308+0000 True None default \n", + "8 5.000000e-01 2021-07-20 19:25:02.649316+0000 True None default \n", + "9 8.000000e+01 2021-07-20 19:25:02.649320+0000 True None default \n", + "\n", + " qubits parameter schedule \n", + "0 () β x90p \n", + "1 () dur xp \n", + "2 (0,) qubit_lo_freq None \n", + "3 () amp x90p \n", + "4 (0,) meas_lo_freq None \n", + "5 () σ xp \n", + "6 () dur x90p \n", + "7 () β xp \n", + "8 () amp xp \n", + "9 () σ x90p " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "pd.DataFrame(cals.parameters_table(qubit_list=[qubit, ()]))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "quantitative-rates", + "metadata": {}, + "outputs": [], + "source": [ + "freq01_estimate = backend.defaults().qubit_freq_est[qubit]\n", + "frequencies = np.linspace(freq01_estimate -15e6, freq01_estimate + 15e6, 51)\n", + "spec = QubitSpectroscopy(qubit, frequencies)\n", + "spec.set_experiment_options(amp=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "medical-instrument", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circuit = spec.circuits(backend)[0]\n", + "circuit.draw(output=\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "saved-relations", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "schedule(circuit, backend).draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ready-packaging", + "metadata": {}, + "outputs": [], + "source": [ + "spec_data = spec.run(backend)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "nominated-orange", + "metadata": {}, + "outputs": [], + "source": [ + "spec_data.block_for_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "weird-buyer", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "spec_data.figure(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "inclusive-yacht", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------\n", + "Experiment: QubitSpectroscopy\n", + "Experiment ID: 98e1cf76-cd87-43b7-a42a-d830edde8832\n", + "Status: DONE\n", + "Backend: ibmq_armonk\n", + "Data: 51\n", + "Analysis Results: 1\n", + "Figures: 1\n", + "---------------------------------------------------\n", + "Last Analysis Result:\n", + "\n", + "Analysis Result: QubitSpectroscopy\n", + "Analysis Result ID: e8da1b69-b115-49f8-ab2a-3d7d03d7c146\n", + "Experiment ID: 98e1cf76-cd87-43b7-a42a-d830edde8832\n", + "Device Components: []\n", + "Quality: good\n", + "Verified: True\n", + "Result Data:, >\n", + " - a: -0.997711616147317 ± 0.013412900337231153\n", + " - sigma: 3182353.179077804 ± 47682.951132104696\n", + " - freq: 4971726352.692174 ± 45118.837185988334\n", + " - b: 0.9674999638307883 ± 0.0043760971999863415\n" + ] + } + ], + "source": [ + "print(spec_data)" + ] + }, + { + "cell_type": "markdown", + "id": "presidential-amplifier", + "metadata": {}, + "source": [ + "We now update the instance of `Calibrations` with the value of the frequency that we measured using the `Frequency.update` function. Note that for the remainder of this notebook we use the value of the qubit frequency in the backend as it is not yet possible to updated qubit frequencies with the circuit path." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "global-advocacy", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_experiments.calibration_management.update_library import Frequency\n", + "\n", + "Frequency.update(cals, spec_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "naval-dialogue", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
valuedate_timevalidexp_idgroupqubitsparameterschedule
04.971659e+092021-07-20 19:25:02.648323+0000TrueNonedefault(0,)qubit_lo_freqNone
14.971726e+092021-07-20 21:26:14.962000+0200True98e1cf76-cd87-43b7-a42a-d830edde8832default(0,)qubit_lo_freqNone
26.993371e+092021-07-20 19:25:02.648345+0000TrueNonedefault(0,)meas_lo_freqNone
\n", + "
" + ], + "text/plain": [ + " value date_time valid \\\n", + "0 4.971659e+09 2021-07-20 19:25:02.648323+0000 True \n", + "1 4.971726e+09 2021-07-20 21:26:14.962000+0200 True \n", + "2 6.993371e+09 2021-07-20 19:25:02.648345+0000 True \n", + "\n", + " exp_id group qubits parameter \\\n", + "0 None default (0,) qubit_lo_freq \n", + "1 98e1cf76-cd87-43b7-a42a-d830edde8832 default (0,) qubit_lo_freq \n", + "2 None default (0,) meas_lo_freq \n", + "\n", + " schedule \n", + "0 None \n", + "1 None \n", + "2 None " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(cals.parameters_table(qubit_list=[qubit]))" + ] + }, + { + "cell_type": "markdown", + "id": "adjusted-heritage", + "metadata": {}, + "source": [ + "As seen from the table above the measured frequency has been added to the calibrations." + ] + }, + { + "cell_type": "markdown", + "id": "minus-vitamin", + "metadata": {}, + "source": [ + "## 2. Calibrating the pulse amplitudes with a Rabi experiment\n", + "\n", + "In the Rabi experiment we apply a pulse at the frequency of the qubit and scan its amplitude to find the amplitude that creates a rotation of a desired angle." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "considered-advocate", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_experiments.library.calibration import Rabi\n", + "from qiskit_experiments.calibration_management.update_library import Amplitude" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "accurate-pursuit", + "metadata": {}, + "outputs": [], + "source": [ + "rabi = Rabi(qubit)\n", + "rabi.set_experiment_options(\n", + " amplitudes=np.linspace(-0.95, 0.95, 51), \n", + " schedule=cals.get_schedule(\"xp\", (0,), assign_params={\"amp\": Parameter(\"amp\")}),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "powered-pacific", + "metadata": {}, + "outputs": [], + "source": [ + "rabi_data = rabi.run(backend)\n", + "rabi_data.block_for_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "biological-repository", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rabi_data.figure(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "outer-being", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---------------------------------------------------\n", + "Experiment: Rabi\n", + "Experiment ID: dedf23f2-98f6-4714-aaba-37806fa94f51\n", + "Status: DONE\n", + "Backend: ibmq_armonk\n", + "Data: 51\n", + "Analysis Results: 1\n", + "Figures: 1\n", + "---------------------------------------------------\n", + "Last Analysis Result:\n", + "\n", + "Analysis Result: Rabi\n", + "Analysis Result ID: 5949a598-68d0-45ac-b093-67b349f8dc1c\n", + "Experiment ID: dedf23f2-98f6-4714-aaba-37806fa94f51\n", + "Device Components: []\n", + "Quality: good\n", + "Verified: True\n", + "Result Data:, >\n", + " - amp: 0.488796705224479 ± 0.002341718272038815\n", + " - freq: 0.6347478478973844 ± 0.0022653212032643327\n", + " - phase: 0.018155363229460934 ± 0.0067989940385690525\n", + " - baseline: 0.49406829235869 ± 0.0020205738937396638\n" + ] + } + ], + "source": [ + "print(rabi_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "unavailable-james", + "metadata": {}, + "outputs": [], + "source": [ + "Amplitude.update(cals, rabi_data, angles_schedules=[(np.pi, \"amp\", \"xp\"), (np.pi/2, \"amp\", \"x90p\")])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "architectural-afternoon", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
valuedate_timevalidexp_idgroupqubitsparameterschedule
00.5000002021-07-20 19:25:02.649331+0000TrueNonedefault()ampx90p
10.5000002021-07-20 19:25:02.649316+0000TrueNonedefault()ampxp
20.3938572021-07-20 21:27:25.663000+0200Truededf23f2-98f6-4714-aaba-37806fa94f51default(0,)ampx90p
30.7877142021-07-20 21:27:25.663000+0200Truededf23f2-98f6-4714-aaba-37806fa94f51default(0,)ampxp
\n", + "
" + ], + "text/plain": [ + " value date_time valid \\\n", + "0 0.500000 2021-07-20 19:25:02.649331+0000 True \n", + "1 0.500000 2021-07-20 19:25:02.649316+0000 True \n", + "2 0.393857 2021-07-20 21:27:25.663000+0200 True \n", + "3 0.787714 2021-07-20 21:27:25.663000+0200 True \n", + "\n", + " exp_id group qubits parameter schedule \n", + "0 None default () amp x90p \n", + "1 None default () amp xp \n", + "2 dedf23f2-98f6-4714-aaba-37806fa94f51 default (0,) amp x90p \n", + "3 dedf23f2-98f6-4714-aaba-37806fa94f51 default (0,) amp xp " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(cals.parameters_table(qubit_list=[qubit, ()], parameters=\"amp\"))" + ] + }, + { + "cell_type": "markdown", + "id": "innovative-wealth", + "metadata": {}, + "source": [ + "The table above shows that we have now updated the amplitude of our $\\pi$-pulse from 0.5 to the value obtained in the most recent Rabi experiment. Importantly, since we linked the amplitudes of the `xp` and `xm` schedules we will see that the amplitude of the `xm` schedule has also been updated as seen when requesting schedules form the `Calibrations` instance. Furthermore, we used the result from the `Rabi` experiment to also update the value of the `x90p` pulse. This was achieved by specifying `(np.pi/2, \"amp\", \"x90p\")` when calling `update`." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "intended-announcement", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ScheduleBlock(Play(Drag(duration=320, amp=(0.39385718+0j), sigma=80, beta=0.5), DriveChannel(0)), name=\"x90p\", transform=AlignLeft())" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cals.get_schedule(\"x90p\", 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fresh-royal", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ScheduleBlock(Play(Drag(duration=320, amp=(0.78771437+0j), sigma=80, beta=0.5), DriveChannel(0)), name=\"xp\", transform=AlignLeft())" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cals.get_schedule(\"xp\", 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "divine-banks", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ScheduleBlock(Play(Drag(duration=320, amp=(-0.78771437+0j), sigma=80, beta=0.5), DriveChannel(0)), name=\"xm\", transform=AlignLeft())" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cals.get_schedule(\"xm\", 0)" + ] + }, + { + "cell_type": "markdown", + "id": "broke-accuracy", + "metadata": {}, + "source": [ + "## 3. Saving and loading calibrations\n", + "\n", + "The values of the calibrated parameters can be saved to a `.csv` file and reloaded at a later point in time. " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "confident-millennium", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/daniel/Documents/IBM/qiskit/qiskit-experiments/qiskit_experiments/calibration_management/calibrations.py:937: UserWarning: Schedules are only saved in text format. They cannot be re-loaded.\n", + " warnings.warn(\"Schedules are only saved in text format. They cannot be re-loaded.\")\n" + ] + } + ], + "source": [ + "cals.save(file_type=\"csv\", overwrite=True, file_prefix=\"Armonk\")" + ] + }, + { + "cell_type": "markdown", + "id": "complete-transcription", + "metadata": {}, + "source": [ + "After saving the values of the parameters you may restart your kernel. If you do so, you will only need to run the following cell to recover the state of your calibrations. Since the schedules are currently not stored we need to call our `setup_cals` function to populate an instance of `Calibrations` with the template schedules. By contrast, the value of the parameters will be recovered from the file." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "gorgeous-comparison", + "metadata": {}, + "outputs": [], + "source": [ + "cals = setup_cals(backend)\n", + "cals.load_parameter_values(file_name=\"Armonkparameter_values.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "spectacular-communication", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
valuedate_timevalidexp_idgroupqubitsparameterschedule
00.5000002021-07-20 19:25:02.649331+0000Truedefault()ampx90p
10.5000002021-07-20 19:25:02.649316+0000Truedefault()ampxp
20.3938572021-07-20 21:27:25.663000+0200Truededf23f2-98f6-4714-aaba-37806fa94f51default(0,)ampx90p
30.7877142021-07-20 21:27:25.663000+0200Truededf23f2-98f6-4714-aaba-37806fa94f51default(0,)ampxp
\n", + "
" + ], + "text/plain": [ + " value date_time valid \\\n", + "0 0.500000 2021-07-20 19:25:02.649331+0000 True \n", + "1 0.500000 2021-07-20 19:25:02.649316+0000 True \n", + "2 0.393857 2021-07-20 21:27:25.663000+0200 True \n", + "3 0.787714 2021-07-20 21:27:25.663000+0200 True \n", + "\n", + " exp_id group qubits parameter schedule \n", + "0 default () amp x90p \n", + "1 default () amp xp \n", + "2 dedf23f2-98f6-4714-aaba-37806fa94f51 default (0,) amp x90p \n", + "3 dedf23f2-98f6-4714-aaba-37806fa94f51 default (0,) amp xp " + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(cals.parameters_table(qubit_list=[qubit, ()], parameters=\"amp\"))" + ] + }, + { + "cell_type": "markdown", + "id": "about-train", + "metadata": {}, + "source": [ + "## 4. Calibrating the value of the DRAG coefficient\n", + "\n", + "A Derivative Removal by Adiabatic Gate (DRAG) pulse is designed to minimize leakage\n", + "to a neighbouring transition. It is a standard pulse with an additional derivative\n", + "component. It is designed to reduce the frequency spectrum of a normal pulse near\n", + "the $|1\\rangle$ - $|2\\rangle$ transition, reducing the chance of leakage\n", + "to the $|2\\rangle$ state. The optimal value of the DRAG parameter is chosen to\n", + "minimize both leakage and phase errors resulting from the AC Stark shift.\n", + "The pulse envelope is $f(t) = \\Omega_x(t) + j \\beta \\frac{\\rm d}{{\\rm d }t} \\Omega_x(t)$.\n", + "Here, $\\Omega_x$ is the envelop of the in-phase component of the pulse and\n", + "$\\beta$ is the strength of the quadrature which we refer to as the DRAG\n", + "parameter and seek to calibrate in this experiment. \n", + "The DRAG calibration will run\n", + "several series of circuits. In a given circuit a Rp(β) - Rm(β) block is repeated\n", + "$N$ times. Here, Rp is a rotation with a positive angle and Rm is the same rotation\n", + "with a negative amplitude." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "respected-shift", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_experiments.library.calibration.drag import DragCal\n", + "from qiskit_experiments.calibration_management.update_library import Drag" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "ambient-positive", + "metadata": {}, + "outputs": [], + "source": [ + "cal_drag = DragCal(qubit)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "finished-arizona", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cal_drag.set_experiment_options(\n", + " rp=cals.get_schedule(\"xp\", 0, assign_params={\"β\": Parameter(\"β\")}),\n", + " betas=np.linspace(-20, 20, 25),\n", + " reps=[3, 5, 7]\n", + ")\n", + "\n", + "cal_drag.circuits(backend)[1].draw(output='mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "increasing-spyware", + "metadata": {}, + "outputs": [], + "source": [ + "drag_data = cal_drag.run(backend)\n", + "drag_data.block_for_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "robust-observer", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "drag_data.figure(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "better-eight", + "metadata": {}, + "outputs": [], + "source": [ + "Drag.update(cals, drag_data, parameter=\"β\", schedule=\"xp\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "protected-restriction", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
valuedate_timevalidexp_idgroupqubitsparameterschedule
00.5000002021-07-20 19:25:02.649323+0000Truedefault()βx90p
10.5000002021-07-20 19:25:02.649308+0000Truedefault()βxp
2-0.8151542021-07-20 22:19:03.010000+0200Truefb95c5bf-d80a-48a4-b70c-1658b322ccdedefault(0,)βxp
\n", + "
" + ], + "text/plain": [ + " value date_time valid \\\n", + "0 0.500000 2021-07-20 19:25:02.649323+0000 True \n", + "1 0.500000 2021-07-20 19:25:02.649308+0000 True \n", + "2 -0.815154 2021-07-20 22:19:03.010000+0200 True \n", + "\n", + " exp_id group qubits parameter schedule \n", + "0 default () β x90p \n", + "1 default () β xp \n", + "2 fb95c5bf-d80a-48a4-b70c-1658b322ccde default (0,) β xp " + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(cals.parameters_table(qubit_list=[qubit, ()], parameters=\"β\"))" + ] + }, + { + "cell_type": "markdown", + "id": "accepting-oxford", + "metadata": {}, + "source": [ + "## 5. Fine amplitude calibration\n", + "\n", + "The `FineAmplitude` calibration experiment repeats $N$ times a gate with a pulse\n", + "to amplify the under or over-rotations in the gate to determine the optimal amplitude.\n", + "The circuits that are run have a custom gate with the pulse schedule attached to it\n", + "through the calibrations." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "environmental-peace", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_experiments.library.calibration.fine_amplitude import FineXAmplitude\n", + "from qiskit_experiments.calibration_management.update_library import Amplitude" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "proof-wrestling", + "metadata": {}, + "outputs": [], + "source": [ + "amp_x_cal = FineXAmplitude(qubit)\n", + "amp_x_cal.set_experiment_options(schedule=cals.get_schedule(\"xp\", 0))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "applied-mountain", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "amp_x_cal.circuits(backend)[5].draw(output=\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "possible-johnson", + "metadata": {}, + "outputs": [], + "source": [ + "data_fine = amp_x_cal.run(backend)\n", + "data_fine.block_for_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "respected-piece", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_fine.figure(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "royal-episode", + "metadata": {}, + "outputs": [], + "source": [ + "result = data_fine.analysis_results(-1).data()" + ] + }, + { + "cell_type": "markdown", + "id": "twelve-limitation", + "metadata": {}, + "source": [ + "The cell below shows how the amplitude is updated based on the error in the rotation angle measured by the `FineXAmplitude` experiment. Note that this calculation is automatically done by the `Amplitude.update` function." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "hundred-inspiration", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The ideal angle is 3.14 rad. We measured a deviation of -0.056 rad.\n", + "Thus, scale the 0.7877 pulse amplitude by 1.018 to obtain 0.80198.\n" + ] + } + ], + "source": [ + "dtheta = result[\"popt\"][1]\n", + "target_angle = np.pi\n", + "scale = target_angle / (target_angle + dtheta)\n", + "pulse_amp = cals.get_parameter_value(\"amp\", 0, \"xp\")\n", + "print(f\"The ideal angle is {target_angle:.2f} rad. We measured a deviation of {dtheta:.3f} rad.\")\n", + "print(f\"Thus, scale the {pulse_amp:.4f} pulse amplitude by {scale:.3f} to obtain {pulse_amp*scale:.5f}.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "scientific-friend", + "metadata": {}, + "outputs": [], + "source": [ + "Amplitude.update(cals, data_fine, angles_schedules=[(target_angle, \"amp\", \"xp\")])" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "harmful-transition", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
valuedate_timevalidexp_idgroupqubitsparameterschedule
00.5000002021-07-20 19:25:02.649331+0000Truedefault()ampx90p
10.5000002021-07-20 19:25:02.649316+0000Truedefault()ampxp
20.3938572021-07-20 21:27:25.663000+0200Truededf23f2-98f6-4714-aaba-37806fa94f51default(0,)ampx90p
30.7877142021-07-20 21:27:25.663000+0200Truededf23f2-98f6-4714-aaba-37806fa94f51default(0,)ampxp
40.8019782021-07-20 22:21:40.070000+0200Trued6a5c8a7-173a-4cd1-9453-5fafe1aab331default(0,)ampxp
\n", + "
" + ], + "text/plain": [ + " value date_time valid \\\n", + "0 0.500000 2021-07-20 19:25:02.649331+0000 True \n", + "1 0.500000 2021-07-20 19:25:02.649316+0000 True \n", + "2 0.393857 2021-07-20 21:27:25.663000+0200 True \n", + "3 0.787714 2021-07-20 21:27:25.663000+0200 True \n", + "4 0.801978 2021-07-20 22:21:40.070000+0200 True \n", + "\n", + " exp_id group qubits parameter schedule \n", + "0 default () amp x90p \n", + "1 default () amp xp \n", + "2 dedf23f2-98f6-4714-aaba-37806fa94f51 default (0,) amp x90p \n", + "3 dedf23f2-98f6-4714-aaba-37806fa94f51 default (0,) amp xp \n", + "4 d6a5c8a7-173a-4cd1-9453-5fafe1aab331 default (0,) amp xp " + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(cals.parameters_table(qubit_list=[qubit, ()], parameters=\"amp\"))" + ] + }, + { + "cell_type": "markdown", + "id": "miniature-commission", + "metadata": {}, + "source": [ + "To check that we have managed to reduce the error in the rotation angle we will run the fine amplitude calibration experiment once again." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "comparable-feeding", + "metadata": {}, + "outputs": [], + "source": [ + "amp_x_cal.set_experiment_options(schedule=cals.get_schedule(\"xp\", 0))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "canadian-jamaica", + "metadata": {}, + "outputs": [], + "source": [ + "data_fine2 = amp_x_cal.run(backend)\n", + "data_fine2.block_for_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "geographic-paradise", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_fine2.figure(0)" + ] + }, + { + "cell_type": "markdown", + "id": "addressed-project", + "metadata": {}, + "source": [ + "As can be seen from the data above and the analysis result below we have managed to reduce the error in the rotation angle ${\\rm d}\\theta$." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "royal-found", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'analysis_type': 'FineAmplitudeAnalysis',\n", + " 'popt': array([-0.80247685, -0.00554933, 0.4864584 ]),\n", + " 'popt_keys': ['amp', 'd_theta', 'baseline'],\n", + " 'popt_err': array([0.02131984, 0.00123576, 0.00403482]),\n", + " 'pcov': array([[ 4.54535634e-04, -3.73966148e-06, 3.25586390e-05],\n", + " [-3.73966148e-06, 1.52711350e-06, -5.22463483e-07],\n", + " [ 3.25586390e-05, -5.22463483e-07, 1.62797864e-05]]),\n", + " 'reduced_chisq': 1.4103179033516524,\n", + " 'dof': 13,\n", + " 'xrange': [0.0, 14.0],\n", + " 'success': True,\n", + " 'quality': 'good'}" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_fine2.analysis_results(-1).data()" + ] + }, + { + "cell_type": "markdown", + "id": "bright-edgar", + "metadata": {}, + "source": [ + "### Fine amplitude calibration of the $\\pi/2$ rotation\n", + "\n", + "We now wish to calibrate the amplitude of the $\\pi/2$ rotation." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "seeing-words", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_experiments.library.calibration.fine_amplitude import FineSXAmplitude" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "durable-charm", + "metadata": {}, + "outputs": [], + "source": [ + "amp_sx_cal = FineSXAmplitude(qubit)\n", + "amp_sx_cal.set_experiment_options(schedule=cals.get_schedule(\"x90p\", 0))" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "selected-malta", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "amp_sx_cal.circuits(backend)[5].draw(output=\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "pleasant-modeling", + "metadata": {}, + "outputs": [], + "source": [ + "data_fine_sx = amp_sx_cal.run(backend)\n", + "data_fine_sx.block_for_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "upper-recorder", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_fine_sx.figure(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "excited-depth", + "metadata": {}, + "outputs": [], + "source": [ + "Amplitude.update(cals, data_fine_sx, angles_schedules=[(np.pi/2, \"amp\", \"x90p\")])" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "excellent-mother", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
valuedate_timevalidexp_idgroupqubitsparameterschedule
00.5000002021-07-20 19:25:02.649331+0000Truedefault()ampx90p
10.5000002021-07-20 19:25:02.649316+0000Truedefault()ampxp
20.3938572021-07-20 21:27:25.663000+0200Truededf23f2-98f6-4714-aaba-37806fa94f51default(0,)ampx90p
30.3782932021-07-20 22:23:41.990000+0200Truef142b771-79bd-46ea-be11-32e9d0b7e2fadefault(0,)ampx90p
40.7877142021-07-20 21:27:25.663000+0200Truededf23f2-98f6-4714-aaba-37806fa94f51default(0,)ampxp
50.8019782021-07-20 22:21:40.070000+0200Trued6a5c8a7-173a-4cd1-9453-5fafe1aab331default(0,)ampxp
\n", + "
" + ], + "text/plain": [ + " value date_time valid \\\n", + "0 0.500000 2021-07-20 19:25:02.649331+0000 True \n", + "1 0.500000 2021-07-20 19:25:02.649316+0000 True \n", + "2 0.393857 2021-07-20 21:27:25.663000+0200 True \n", + "3 0.378293 2021-07-20 22:23:41.990000+0200 True \n", + "4 0.787714 2021-07-20 21:27:25.663000+0200 True \n", + "5 0.801978 2021-07-20 22:21:40.070000+0200 True \n", + "\n", + " exp_id group qubits parameter schedule \n", + "0 default () amp x90p \n", + "1 default () amp xp \n", + "2 dedf23f2-98f6-4714-aaba-37806fa94f51 default (0,) amp x90p \n", + "3 f142b771-79bd-46ea-be11-32e9d0b7e2fa default (0,) amp x90p \n", + "4 dedf23f2-98f6-4714-aaba-37806fa94f51 default (0,) amp xp \n", + "5 d6a5c8a7-173a-4cd1-9453-5fafe1aab331 default (0,) amp xp " + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(cals.parameters_table(qubit_list=[qubit, ()], parameters=\"amp\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "asian-fault", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ScheduleBlock(Play(Drag(duration=320, amp=(0.378293207284159+0j), sigma=80, beta=0.5), DriveChannel(0)), name=\"x90p\", transform=AlignLeft())" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cals.get_schedule(\"x90p\", 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "turkish-moment", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ScheduleBlock(Play(Drag(duration=320, amp=(0.801978295624676+0j), sigma=80, beta=-0.815154476359888), DriveChannel(0)), name=\"xp\", transform=AlignLeft())" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cals.get_schedule(\"xp\", 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "mature-induction", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ScheduleBlock(Play(Drag(duration=320, amp=(-0.801978295624676+0j), sigma=80, beta=-0.815154476359888), DriveChannel(0)), name=\"xm\", transform=AlignLeft())" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cals.get_schedule(\"xm\", 0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "documented-aside", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/qst_example.ipynb b/docs/tutorials/qst_example.ipynb deleted file mode 100644 index 631b00028f..0000000000 --- a/docs/tutorials/qst_example.ipynb +++ /dev/null @@ -1,421 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Quantum State Tomography" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 1, - "source": [ - "from pprint import pprint\n", - "import qiskit\n", - "from qiskit_experiments.framework import ParallelExperiment\n", - "from qiskit_experiments.library import StateTomography\n", - "\n", - "# For simulation\n", - "from qiskit.providers.aer import AerSimulator\n", - "from qiskit.test.mock import FakeParis\n", - "\n", - "# Noisy simulator backend\n", - "backend = AerSimulator.from_backend(FakeParis())" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## State Tomography Experiment\n", - "\n", - "To run a state tomography experiment we initialize the experiment with a circuit to prepare the state to be measured. We can also pass in an `Operator`, or a `Statevector` to describe the preparation circuit." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 2, - "source": [ - "# Run experiments\n", - "\n", - "# GHZ State preparation circuit\n", - "nq = 2\n", - "qc_ghz = qiskit.QuantumCircuit(nq)\n", - "qc_ghz.h(0)\n", - "qc_ghz.s(0)\n", - "for i in range(1, nq):\n", - " qc_ghz.cx(0, i)\n", - "\n", - "# QST Experiment\n", - "qstexp1 = StateTomography(qc_ghz)\n", - "qstdata1 = qstexp1.run(backend, seed_simulation=100)\n", - "qstresult = qstdata1.analysis_result(-1)\n", - "\n", - "print('FIT RESULT')\n", - "pprint(qstresult)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "FIT RESULT\n", - "{'fitter_metadata': {'fitter': 'linear_inversion',\n", - " 'fitter_time': 0.0015842914581298828},\n", - " 'state': DensityMatrix([[ 0.47981771+0.j , 0.00439453-0.0086263j ,\n", - " 0.00260417-0.00651042j, -0.01416016-0.44482422j],\n", - " [ 0.00439453+0.0086263j , 0.01920573+0.j ,\n", - " -0.00537109+0.00341797j, 0.01432292+0.00130208j],\n", - " [ 0.00260417+0.00651042j, -0.00537109-0.00341797j,\n", - " 0.03450521+0.j , 0.00146484-0.02034505j],\n", - " [-0.01416016+0.44482422j, 0.01432292-0.00130208j,\n", - " 0.00146484+0.02034505j, 0.46647135+0.j ]],\n", - " dims=(2, 2)),\n", - " 'state_fidelity': 0.91796875,\n", - " 'state_metadata': {'eigvals': array([0.91887418, 0.0471276 , 0.01804304, 0.01595518]),\n", - " 'positive': True,\n", - " 'positive_delta': 0.0,\n", - " 'trace': 1.0000000000000002},\n", - " 'success': True}\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### Tomography Results\n", - "\n", - "The main results for tomography are the fitted state, which is stored in the `\"state\"` key as a `DensityMatrix` object:" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 3, - "source": [ - "print(qstresult[\"state\"])" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "DensityMatrix([[ 0.47981771+0.j , 0.00439453-0.0086263j ,\n", - " 0.00260417-0.00651042j, -0.01416016-0.44482422j],\n", - " [ 0.00439453+0.0086263j , 0.01920573+0.j ,\n", - " -0.00537109+0.00341797j, 0.01432292+0.00130208j],\n", - " [ 0.00260417+0.00651042j, -0.00537109-0.00341797j,\n", - " 0.03450521+0.j , 0.00146484-0.02034505j],\n", - " [-0.01416016+0.44482422j, 0.01432292-0.00130208j,\n", - " 0.00146484+0.02034505j, 0.46647135+0.j ]],\n", - " dims=(2, 2))\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "The state fidelity of the fitted state with the ideal state prepared by the input circuit is stored in the `\"state_fidelity\"` result field. Note that if the input circuit contained any measurements the ideal state cannot be automatically generated and this field will be set to `None`." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 4, - "source": [ - "print(\"State Fidelity = {:.5f}\".format(qstresult[\"state_fidelity\"]))" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "State Fidelity = 0.91797\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Additional state metadata\n", - "\n", - "Additional data is stored in the tomography under the `\"state_metadata\"` field. This includes\n", - "- `eigvals`: the eigenvalues of the fitted state\n", - "- `trace`: the trace of the fitted state\n", - "- `positive`: Whether the eigenvalues are all non-negative\n", - "- `positive_delta`: the deviation from positivity given by 1-norm of negative eigenvalues.\n", - "\n", - "If trace rescaling was performed this dictionary will also contain a `raw_trace` field containing the trace before rescaling.\n", - "Futhermore, if the state was rescaled to be positive or trace 1 an additional field `raw_eigvals` will contain the state eigenvalues before rescaling was performed." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 5, - "source": [ - "pprint(qstresult[\"state_metadata\"])" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "{'eigvals': array([0.91887418, 0.0471276 , 0.01804304, 0.01595518]),\n", - " 'positive': True,\n", - " 'positive_delta': 0.0,\n", - " 'trace': 1.0000000000000002}\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "To see the effect of rescaling we can perform a \"bad\" fit with very low counts" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 6, - "source": [ - "# QST Experiment\n", - "bad_data = qstexp1.run(backend, shots=10, seed_simulation=100)\n", - "bad_result = bad_data.analysis_result(-1)\n", - "\n", - "print(bad_result[\"state_fidelity\"])\n", - "pprint(bad_result[\"state_metadata\"])" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "0.8405316844521707\n", - "{'eigvals': array([0.89168942, 0.10831058, 0. , 0. ]),\n", - " 'positive': True,\n", - " 'positive_delta': 0.0,\n", - " 'raw_eigvals': array([ 1.05462832, 0.27124948, -0.06026308, -0.26561472]),\n", - " 'trace': 0.9999999999999993}\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Tomography Fitters\n", - "\n", - "The default fitters is `linear_inversion`, which reconstructs the state using *dual basis* of the tomography basis. This will typically result in a non-postive reconstructed state. This state is rescaled to be postive-semidfinite (PSD) by computing its eigen-decomposition and rescaling its eigenvalues using the approach from *J Smolin, JM Gambetta, G Smith, Phys. Rev. Lett. 108, 070502 (2012), [open access](https://arxiv.org/abs/arXiv:1106.5458).\n", - "\n", - "There are several other fitters are included (See API documentation for details). For example if `cvxpy` is installed we can use the `cvxpy_gaussian_lstsq` fitter which allows constraining the fit to be PSD without requiring rescaling." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 7, - "source": [ - "qstexp1.run_analysis(qstdata1, fitter='cvxpy_linear_lstsq')\n", - "qstresult2 = qstdata1.analysis_result(-1)\n", - "\n", - "print('FIT RESULT')\n", - "pprint(qstresult2)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "FIT RESULT\n", - "{'fitter_metadata': {'cvxpy_solver': 'CVXOPT',\n", - " 'cvxpy_status': 'optimal',\n", - " 'fitter': 'cvxpy_linear_lstsq',\n", - " 'fitter_time': 0.057753801345825195},\n", - " 'state': DensityMatrix([[ 0.47981944+0.00000000e+00j, 0.00439546-8.62489044e-03j,\n", - " 0.00260244-6.51111631e-03j, -0.01416025-4.44827007e-01j],\n", - " [ 0.00439546+8.62489044e-03j, 0.01920331+0.00000000e+00j,\n", - " -0.00537229+3.41858268e-03j, 0.01432449+1.30294300e-03j],\n", - " [ 0.00260244+6.51111631e-03j, -0.00537229-3.41858268e-03j,\n", - " 0.03450426-8.67361738e-19j, 0.00146412-2.03467865e-02j],\n", - " [-0.01416025+4.44827007e-01j, 0.01432449-1.30294300e-03j,\n", - " 0.00146412+2.03467865e-02j, 0.46647299+1.73472348e-18j]],\n", - " dims=(2, 2)),\n", - " 'state_fidelity': 0.9179732199819044,\n", - " 'state_metadata': {'eigvals': array([0.91887865, 0.04713024, 0.01804001, 0.0159511 ]),\n", - " 'positive': True,\n", - " 'positive_delta': 0.0,\n", - " 'raw_eigvals': array([0.91887729, 0.04713017, 0.01803999, 0.01595107]),\n", - " 'raw_trace': 0.999998525291621,\n", - " 'trace': 0.9999999999999999},\n", - " 'success': True}\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Parallel Tomography Experiment\n", - "\n", - "We can also use the `qiskit_experiments.ParallelExperiment` class to run subsystem tomography on multiple qubits in parallel.\n", - "\n", - "For example if we want to perform 1-qubit QST on several qubits at once:" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 8, - "source": [ - "from math import pi\n", - "num_qubits = 5\n", - "gates = [qiskit.circuit.library.RXGate(i * pi / (num_qubits - 1))\n", - " for i in range(num_qubits)]\n", - "\n", - "subexps = [\n", - " StateTomography(gate, qubits=[i])\n", - " for i, gate in enumerate(gates)\n", - "]\n", - "parexp = ParallelExperiment(subexps)\n", - "pardata = parexp.run(backend, seed_simulation=100)\n", - "print(pardata.analysis_result(-1))" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - "- experiment_types: ['StateTomography', 'StateTomography', 'StateTomography', 'StateTomography', 'StateTomography']\n", - "- experiment_ids: ['e8025a8b-edcb-483d-b1a6-131ca638c7d2', 'f8f971b7-d99d-4d16-bfdf-c8d489b0d0f1', '15b3f86a-b34d-4f8d-9167-e70aa9efdcc9', '9f35847c-d601-41b3-a2e8-57a701023a16', 'cc2c46b9-292b-4017-b353-465271580b5e']\n", - "- experiment_qubits: [(0,), (1,), (2,), (3,), (4,)]\n", - "- success: True\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "View component experiment analysis results" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 9, - "source": [ - "for i in range(parexp.num_experiments):\n", - " expdata = pardata.component_experiment_data(i)\n", - " result = expdata.analysis_result(-1)\n", - " \n", - " print(f'\\nPARALLEL EXP {i}: FIT RESULT')\n", - " pprint(result)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - "PARALLEL EXP 0: FIT RESULT\n", - "{'fitter_metadata': {'fitter': 'linear_inversion',\n", - " 'fitter_time': 0.00016832351684570312},\n", - " 'state': DensityMatrix([[ 0.98339844+0.j , -0.01953125-0.01757812j],\n", - " [-0.01953125+0.01757812j, 0.01660156+0.j ]],\n", - " dims=(2,)),\n", - " 'state_fidelity': 0.9833984374999999,\n", - " 'state_metadata': {'eigvals': array([0.98411208, 0.01588792]),\n", - " 'positive': True,\n", - " 'positive_delta': 0.0,\n", - " 'trace': 1.0000000000000002},\n", - " 'success': True}\n", - "\n", - "PARALLEL EXP 1: FIT RESULT\n", - "{'fitter_metadata': {'fitter': 'linear_inversion',\n", - " 'fitter_time': 9.083747863769531e-05},\n", - " 'state': DensityMatrix([[0.8515625 +0.j , 0.00878906+0.31933594j],\n", - " [0.00878906-0.31933594j, 0.1484375 +0.j ]],\n", - " dims=(2,)),\n", - " 'state_fidelity': 0.9743968346437093,\n", - " 'state_metadata': {'eigvals': array([0.97502514, 0.02497486]),\n", - " 'positive': True,\n", - " 'positive_delta': 0.0,\n", - " 'trace': 1.0000000000000004},\n", - " 'success': True}\n", - "\n", - "PARALLEL EXP 2: FIT RESULT\n", - "{'fitter_metadata': {'fitter': 'linear_inversion',\n", - " 'fitter_time': 8.916854858398438e-05},\n", - " 'state': DensityMatrix([[0.50976563+0.j , 0.01953125+0.46972656j],\n", - " [0.01953125-0.46972656j, 0.49023438+0.j ]],\n", - " dims=(2,)),\n", - " 'state_fidelity': 0.9697265625000003,\n", - " 'state_metadata': {'eigvals': array([0.97023386, 0.02976614]),\n", - " 'positive': True,\n", - " 'positive_delta': 0.0,\n", - " 'trace': 1.0000000000000004},\n", - " 'success': True}\n", - "\n", - "PARALLEL EXP 3: FIT RESULT\n", - "{'fitter_metadata': {'fitter': 'linear_inversion',\n", - " 'fitter_time': 8.487701416015625e-05},\n", - " 'state': DensityMatrix([[0.171875 +0.j , 0.02734375+0.32128906j],\n", - " [0.02734375-0.32128906j, 0.828125 +0.j ]],\n", - " dims=(2,)),\n", - " 'state_fidelity': 0.9592050873916542,\n", - " 'state_metadata': {'eigvals': array([0.96004387, 0.03995613]),\n", - " 'positive': True,\n", - " 'positive_delta': 0.0,\n", - " 'trace': 0.9999999999999999},\n", - " 'success': True}\n", - "\n", - "PARALLEL EXP 4: FIT RESULT\n", - "{'fitter_metadata': {'fitter': 'linear_inversion',\n", - " 'fitter_time': 8.893013000488281e-05},\n", - " 'state': DensityMatrix([[0.03808594+0.j, 0.00585938+0.j],\n", - " [0.00585938+0.j, 0.96191406+0.j]],\n", - " dims=(2,)),\n", - " 'state_fidelity': 0.9619140625,\n", - " 'state_metadata': {'eigvals': array([0.96195122, 0.03804878]),\n", - " 'positive': True,\n", - " 'positive_delta': 0.0,\n", - " 'trace': 1.0000000000000002},\n", - " 'success': True}\n" - ] - } - ], - "metadata": {} - } - ], - "metadata": { - "interpreter": { - "hash": "c45f46a7fd077198472649b02925a2e599779de14e258f4f9ba8eb1d4e684fd2" - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3.7.7 64-bit ('qiskit-dev': conda)" - }, - "language_info": { - "name": "python", - "version": "3.7.7" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file diff --git a/docs/tutorials/rb_example.ipynb b/docs/tutorials/rb_example.ipynb index a0bf8558e2..54fb24c1e2 100644 --- a/docs/tutorials/rb_example.ipynb +++ b/docs/tutorials/rb_example.ipynb @@ -2,17 +2,19 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# Randomized Benchmarking\n", "\n", "A **randomized benchmarking (RB)** experiment consists of the generation of random Clifford circuits on the given qubits such that the unitary computed by the circuits is the identity. After running the circuits, the number of shots resulting in an error (i.e. an output different than the ground state) are counted, and from this data one can infer error estimates for the quantum device, by calculating the Error Per Clifford. \n", "See [Qiskit Textbook](https://qiskit.org/textbook/ch-quantum-hardware/randomized-benchmarking.html) for an explanation on the RB method, which is based on Ref. [1, 2]." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 1, + "metadata": {}, + "outputs": [], "source": [ "import numpy as np\n", "from qiskit_experiments.library import StandardRB, InterleavedRB\n", @@ -25,14 +27,13 @@ "from qiskit.test.mock import FakeParis\n", "\n", "backend = AerSimulator.from_backend(FakeParis())" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "# 1. RB experiment\n", + "## 1. RB experiment\n", "\n", "To run the RB experiment we need need to provide the following RB parameters, in order to generate the RB circuits and run them on a backend:\n", "\n", @@ -56,37 +57,23 @@ "- `alpha`: The depolarizing parameter. The fitting function is $a \\cdot \\alpha^m + b$, where $m$ is the Clifford length.\n", "\n", "- `EPG`: The Error Per Gate calculated from the EPC, only for 1-qubit or 2-qubit quantum gates (see Ref. [3])." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "## Running 1-qubit RB experiment" - ], - "metadata": {} + "### Running 1-qubit RB experiment" + ] }, { "cell_type": "code", "execution_count": 42, - "source": [ - "lengths = np.arange(1, 1000, 100)\n", - "num_samples = 10\n", - "seed = 1010\n", - "qubits = [0]\n", - "# Run an RB experiment on qubit 0\n", - "exp1 = StandardRB(qubits, lengths, num_samples=num_samples, seed=seed)\n", - "expdata1 = exp1.run(backend)\n", - "expdata1.block_for_results()\n", - "result = expdata1.analysis_results(0)\n", - "# View result data\n", - "print(result)\n", - "display(expdata1.figure(0))" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Analysis Result: StandardRB\n", @@ -102,30 +89,83 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" } ], - "metadata": {} + "source": [ + "lengths = np.arange(1, 1000, 100)\n", + "num_samples = 10\n", + "seed = 1010\n", + "qubits = [0]\n", + "# Run an RB experiment on qubit 0\n", + "exp1 = StandardRB(qubits, lengths, num_samples=num_samples, seed=seed)\n", + "expdata1 = exp1.run(backend)\n", + "expdata1.block_for_results()\n", + "result = expdata1.analysis_results(0)\n", + "# View result data\n", + "print(result)\n", + "display(expdata1.figure(0))" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "## Running 2-qubit RB experiment\n", + "### Running 2-qubit RB experiment\n", "\n", "Running a 1-qubit RB experiment and a 2-qubit RB experiment, in order to calculate the gate error (EPG) of the `cx` gate:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 44, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Analysis Result: StandardRB\n", + "Analysis Result ID: c458cbc5-8f70-4c93-a416-5a82dc345f6e\n", + "Experiment ID: b70311b0-ea64-4af3-b1d2-ab0b95ff79dc\n", + "Device Components: [, ]\n", + "Quality: None\n", + "Verified: False\n", + "Result Data:, >\n", + " - a: 0.6929359057250185 ± 0.022809600699452162\n", + " - alpha: 0.9544996812764374 ± 0.003341829326697232\n", + " - b: 0.2647774987044865 ± 0.006159040209452071\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Backend's reported EPG of the cx gate: 0.012438847900902494\n", + "Experiment computed EPG of the cx gate: 0.01262803065926493\n" + ] + } + ], "source": [ "lengths = np.arange(1, 200, 30)\n", "num_samples = 10\n", @@ -162,87 +202,43 @@ "exp2_epg = expdata2.analysis_results(0).data()['EPG'][qubits]['cx']\n", "print(\"Backend's reported EPG of the cx gate:\", expected_epg)\n", "print(\"Experiment computed EPG of the cx gate:\", exp2_epg)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - "Analysis Result: StandardRB\n", - "Analysis Result ID: c458cbc5-8f70-4c93-a416-5a82dc345f6e\n", - "Experiment ID: b70311b0-ea64-4af3-b1d2-ab0b95ff79dc\n", - "Device Components: [, ]\n", - "Quality: None\n", - "Verified: False\n", - "Result Data:, >\n", - " - a: 0.6929359057250185 ± 0.022809600699452162\n", - " - alpha: 0.9544996812764374 ± 0.003341829326697232\n", - " - b: 0.2647774987044865 ± 0.006159040209452071\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Backend's reported EPG of the cx gate: 0.012438847900902494\n", - "Experiment computed EPG of the cx gate: 0.01262803065926493\n" - ] - } - ], - "metadata": { - "scrolled": false - } + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "## Displaying the RB circuits\n", + "### Displaying the RB circuits\n", "\n", "Generating an example RB circuit:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 45, + "metadata": {}, + "outputs": [], "source": [ "# Run an RB experiment on qubit 0\n", "exp = StandardRB(qubits=[0], lengths=[10], num_samples=1, seed=seed)\n", "c = exp.circuits()[0]" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "We transpile the circuit into the backend's basis gate set:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 46, - "source": [ - "from qiskit import transpile\n", - "basis_gates = backend.configuration().basis_gates\n", - "print(transpile(c, basis_gates=basis_gates))" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "global phase: π/2\n", " ░ ┌──────────┐┌────┐┌───────┐ ░ ┌────┐┌─────────┐ ░ ┌──────────┐┌────┐»\n", @@ -268,12 +264,17 @@ ] } ], - "metadata": {} + "source": [ + "from qiskit import transpile\n", + "basis_gates = backend.configuration().basis_gates\n", + "print(transpile(c, basis_gates=basis_gates))" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "# 2. Interleaved RB experiment\n", + "## 2. Interleaved RB experiment\n", "\n", "Interleaved RB experiment is used to estimate the gate error of the interleaved gate (see Ref. [4]).\n", "\n", @@ -292,40 +293,23 @@ "- `EPC_systematic_err`: The systematic error of the interleaved gate error (see Ref. [4]).\n", "\n", "- `EPC_systematic_bounds`: The systematic error bounds of the interleaved gate error (see Ref. [4]).\n" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "## Running 1-qubit interleaved RB experiment" - ], - "metadata": {} + "### Running 1-qubit interleaved RB experiment" + ] }, { "cell_type": "code", "execution_count": 53, - "source": [ - "lengths = np.arange(1, 1000, 100)\n", - "num_samples = 10\n", - "seed = 1010\n", - "qubits = [0]\n", - "\n", - "# Run an Interleaved RB experiment on qubit 0\n", - "# The interleaved gate is the x gate\n", - "int_exp1 = InterleavedRB(\n", - " circuits.XGate(), qubits, lengths, num_samples=num_samples, seed=seed)\n", - "int_expdata1 = int_exp1.run(backend)\n", - "int_expdata1.block_for_results()\n", - "result = int_expdata1.analysis_results(0)\n", - "# View result data\n", - "print(result)\n", - "display(int_expdata1.figure(0))" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Analysis Result: InterleavedRB\n", @@ -342,49 +326,49 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" } ], - "metadata": {} + "source": [ + "lengths = np.arange(1, 1000, 100)\n", + "num_samples = 10\n", + "seed = 1010\n", + "qubits = [0]\n", + "\n", + "# Run an Interleaved RB experiment on qubit 0\n", + "# The interleaved gate is the x gate\n", + "int_exp1 = InterleavedRB(\n", + " circuits.XGate(), qubits, lengths, num_samples=num_samples, seed=seed)\n", + "int_expdata1 = int_exp1.run(backend)\n", + "int_expdata1.block_for_results()\n", + "result = int_expdata1.analysis_results(0)\n", + "# View result data\n", + "print(result)\n", + "display(int_expdata1.figure(0))" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "## Running 2-qubit interleaved RB experiment" - ], - "metadata": {} + "### Running 2-qubit interleaved RB experiment" + ] }, { "cell_type": "code", "execution_count": 54, - "source": [ - "lengths = np.arange(1, 200, 30)\n", - "num_samples = 10\n", - "seed = 1010\n", - "qubits = [4,6]\n", - "\n", - "# Run an Interleaved RB experiment on qubits 4, 6\n", - "# The interleaved gate is the cx gate\n", - "int_exp2 = InterleavedRB(\n", - " circuits.CXGate(), qubits, lengths, num_samples=num_samples, seed=seed)\n", - "int_expdata2 = int_exp2.run(backend)\n", - "int_expdata2.block_for_results()\n", - "result = int_expdata2.analysis_results(0)\n", - "# View result data\n", - "print(result)\n", - "display(int_expdata2.figure(0))" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Analysis Result: InterleavedRB\n", @@ -401,51 +385,53 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" } ], - "metadata": {} + "source": [ + "lengths = np.arange(1, 200, 30)\n", + "num_samples = 10\n", + "seed = 1010\n", + "qubits = [4,6]\n", + "\n", + "# Run an Interleaved RB experiment on qubits 4, 6\n", + "# The interleaved gate is the cx gate\n", + "int_exp2 = InterleavedRB(\n", + " circuits.CXGate(), qubits, lengths, num_samples=num_samples, seed=seed)\n", + "int_expdata2 = int_exp2.run(backend)\n", + "int_expdata2.block_for_results()\n", + "result = int_expdata2.analysis_results(0)\n", + "# View result data\n", + "print(result)\n", + "display(int_expdata2.figure(0))" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "# 3. Simultaneous RB experiment\n", + "## 3. Simultaneous RB experiment\n", "\n", "We use `ParallelExperiment` to run the RB experiment simultaneously on different qubits (see Ref. [5])" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 55, - "source": [ - "lengths = np.arange(1, 1000, 100)\n", - "num_samples = 10\n", - "seed = 1010\n", - "qubits = range(5)\n", - "\n", - "# Run a parallel 1-qubit RB experiment on qubits 0, 1, 2, 3, 4\n", - "exps = [StandardRB([i], lengths, num_samples=num_samples, seed=seed + i)\n", - " for i in qubits]\n", - "\n", - "par_exp = ParallelExperiment(exps)\n", - "par_expdata = par_exp.run(backend)\n", - "par_expdata.block_for_results()\n", - "result = par_expdata.analysis_results(0)\n", - "# View result data\n", - "print(result)" - ], + "metadata": { + "scrolled": false + }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Analysis Result: ParallelExperiment\n", @@ -462,32 +448,41 @@ ] } ], - "metadata": { - "scrolled": false - } + "source": [ + "lengths = np.arange(1, 1000, 100)\n", + "num_samples = 10\n", + "seed = 1010\n", + "qubits = range(5)\n", + "\n", + "# Run a parallel 1-qubit RB experiment on qubits 0, 1, 2, 3, 4\n", + "exps = [StandardRB([i], lengths, num_samples=num_samples, seed=seed + i)\n", + " for i in qubits]\n", + "\n", + "par_exp = ParallelExperiment(exps)\n", + "par_expdata = par_exp.run(backend)\n", + "par_expdata.block_for_results()\n", + "result = par_expdata.analysis_results(0)\n", + "# View result data\n", + "print(result)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "## Viewing sub experiment data\n", + "### Viewing sub experiment data\n", "\n", "The experiment data returned from a batched experiment also contains individual experiment data for each sub experiment which can be accessed using `experiment_data(index)`" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 56, - "source": [ - "# Print sub-experiment data\n", - "for i in range(par_exp.num_experiments):\n", - " print(par_expdata.component_experiment_data(i).analysis_results(0), '\\n')\n", - " display(par_expdata.component_experiment_data(i).figure(0))" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Analysis Result: StandardRB\n", @@ -504,18 +499,18 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Analysis Result: StandardRB\n", @@ -532,18 +527,18 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAFGCAYAAABgwUY+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAB2uUlEQVR4nO3dd3hUVfrA8e+ZSS8QauhNkCoiCVWlKCi2tawFUQTXrrgqVrBgWf1ZsLB2LCioVNG1KxYQpUkIKkVApBhI6CUhfeb9/XEyk5lkUkkl7+d57jOZe8+9c+YS8t7TjYiglFJKqWOfo7ozoJRSSqmqoUFfKaWUqiM06CullFJ1hAZ9pZRSqo7QoK+UUkrVERr0lVJKqToiqLozUJkaN24s7dq1q7DrHTlyhMjIyAq7ngpM73PV0XtdNfQ+Vw29z1ZCQsJeEWkS6NgxHfTbtWvHypUrK+x6CxcuZMiQIRV2PRWY3ueqo/e6auh9rhp6ny1jzLaijmn1vlJKKVVHaNBXSiml6ggN+koppVQdoUFfKaWUqiM06CullFJ1hAZ9pZRSqo7QoK+UUkrVEcf0OH2lqst5551HcnJydWejRJmZmYSFhVV3No55ep8rT/Pmzfn000+rOxu1hgZ9pSpBcnJyhU4MVVlSU1OJjo6u7mwc8/Q+V574+PjqzkKtotX7SimlVB2hQV8ppZSqIzToK6WUUnWEBn2llFKqjqjyoG+MGWSM+cQYs8MYI8aYsaU45wRjzCJjTEbeeQ8ZY0wVZFepOuu7775j4MCBREdH06xZM+69915yc3OLPWfXrl2MHTuWFi1aEBERwYgRI9i0aVPAtCLCWWedhTGGefPm+R17/PHHOfnkk4mMjKSi/6u/8sortG/fnrCwMOLi4li8eLHf8alTpzJ06FBiYmIwxrB169YK/fyCbrjhBowxTJ48udh0ixYtYuDAgTRq1Ijw8HC6dOlS6JycnBweffRRjjvuOMLCwjjxxBP56quvCl0rOTmZMWPG0KRJE8LCwujWrRuLFi066u/y+++/M3jwYMLDw2nZsiWPPvooIhIw7cyZMzHGcO655x7156rSq46SfhSwBrgNyCgpsTGmHrAA2AX0yTvvbmB8JeZRqTrt119/5eyzz2b48OEkJiYye/ZsPvnkE+67774izxERLrjgAjZt2sTHH39MYmIibdu2ZdiwYRw5cqRQ+meffRaHI/CfoKysLC666CJuv/32ivpKAMyePZvbbruNiRMnkpiYyMCBAznrrLPYvn27N016ejpnnHEGDz/8cKmvW96Hg3nz5rFixQpatGhRYtqoqCj+/e9/8+OPP7Ju3ToeeOABJk2axCuvvOJN88ADD/Dqq6/y3//+l3Xr1nHjjTdy4YUXkpiY6E1z8OBBTj75ZESEzz//nPXr1/Piiy/StGnTMuff1+HDhxk+fDixsbH88ssvTJkyhWeeeYbnnnuuUNq//vqLu+++m1NPPfWoPlOVg4hU2wakAWNLSHMTcBgI99n3ALADMMWdGxcXJxXphx9+kMzMCr2kCuCHH36o7iwctfL+7qWlpcl1110n9erVk0aNGsnEiRMlNTVVIiIiZOvWrRWcS5HDhw8H3D9hwgTp1auX375PPvlEwsLCijxnw4YNAsjq1au9+1wulzRp0kTeeOMNv7QrVqyQVq1aya5duwSQuXPnBrzm3Llzxf6ZKmzt2rVy9tlnS1RUlDRp0kRGjhwpycnJRX5XEZG+ffvKtdde67evY8eOct999xVK+8svvwggW7ZsKfaaIlJiukD3bOvWrdKiRQtZt26dtG3bVp555pkSP6egCy+8UEaOHOl937x5c3nhhRf80lx00UVyxRVXeN9PmDBBBg4cWOx1s7Ky5J577pGWLVtKeHi4xMfHy1dffVXsOa+88opER0dLenq6d99jjz0mLVq0ELfb7d2XnZ0tffv2lXfeeUfGjBkj55xzTqm+a1F8/68dC387KgKwUoqIi7WhTX8AsFhEfGsFvgZaAO2qMiMisHu3fVWqMvzrX//i+++/59tvv2XmzJlMmTKFcePG0aVLF9q2bVvkeWeddRZRUVHFbmWRlZVVaDKZ8PBwMjMzSUhIKPIcwO88h8NBaGgoP/30k3dfamoqo0aNYurUqeUuXSYnJzNo0CB69OjBihUr+Pbbb0lLS+P888/H7XYHPCc7O5uEhATOOOMMv/1nnHEGS5YsKVc+yis3N5fLL7+cBx54gK5du5brGomJiSxZsoTBgwd79xX17+Z7/z/++GP69evHZZddRtOmTenVqxcvvfSSXzX81VdfzaJFi/jggw9Ys2YNY8aM4bzzzuPXX38tMj9Lly7l1FNPJTw83LvvzDPPZOfOnX61IPfffz/t2rVjzJgx5fre6ujUhsl5mgFJBfbt8jm2pSoy4flDcuQIZGZCaKi7yKpJpcpj7969zJ07l3fffZc+ffoAcOmllzJt2jQee+yxYs998803ycgosbWs1M4880yef/553nvvPUaOHMmuXbt49NFHAYqcabBLly60adOGiRMn8sYbbxAVFcXzzz9PUlKS3zk33ngjI0aM4Kyzzip3/l599VVOPPFEnnrqKe++6dOn07BhQ1auXEnfvn0LnbN3715cLhexsbF++2NjY/n222/L9Pndu3dn27ZthfZ5+h+0bduWtWvXFnn+pEmTaNy4MTfddFOZPhegVatW7Nmzh9zcXCZNmsSNN97oPXbmmWfywgsvMGTIEDp16sR3333H/Pnzcblc3jR//fUXr7zyCnfccQf33Xcfq1ev5tZbbwVg3LhxbN68mZkzZ7J161batGnj3f/tt9/y+uuv+zUn+EpJSaFVq1Z++zz3OiUlhfbt2/PNN98wZ84cVq9eXebvrSpGbQj6ZWKMuR64Huwv3MKFC4/6mgcPHiQ3V3A6g0lKWsivv4LTeYCgIENMTMxRX1/5S0tLq5B/t+qUmZlJampqmc759ddfERFOOOEE77knnngiYP+YF3e9evXqUa9evWKvH+h8l8sVcP+AAQN4/PHHueWWWxg7diyhoaHcc889LF68mKysrCLzMmPGDMaNG0ejRo1wOp0MGTKE4cOH43a7SU1NZebMmSQmJrJo0SK/a2RkZAS8pudBpuCx5cuX8+OPPwaswVizZg0HDhzgn//8p3ffCy+8wKBBgwDbZu97vaysLG/+fHn6IaSlpRU6NmfOHHJycrzvTzrpJObNm0fz5s0BCA4O9jvH9z4vXryYadOm8fPPP3v3iUix99XXl19+yZEjR/jll1946KGHaNasGZdffjlgO0DeeuutdOvWDWMM7du354orruC9997zXtvtdnPSSScxceJEADp27MjatWt58cUXGTNmDD///DMiQrdu3fw+Nysri0GDBpGamkrfvn35+++/Afu7Mn/+fHJzc8nJyfH7Dmlpad57uWXLFsaMGcPbb7+N0+kkNTWVnJwccnNzy/x/xVdmZqb378Wx8Lej0hVV718VG6Vr058OfF5gXx9AgPbFnVsRbfq5uS4ZPHiRBAVly7PPfi/GuCUkJEeCgrJl8OBFkpvrOurPUP6OhXa58vzurVq1SgDZtm2bd99HH30kDRo0KPHcESNGSGRkZLFbIEW1z3u43W7ZsWOHpKeny7p16wSQFStWlJifgwcPyu7du0XEtqPffPPNIiIyZswYMcaI0+n0boA4HA45+eSTC12nqDb9ESNGyPnnny+bNm0qtB0+fFjS09ML7cvKyhKn0ylz5szxu9bNN98sgwYNKvQZldWmP2nSpCLvQcuWLUv8LF+PPfaYdOjQodD+jIwMSUpKErfbLffcc49069bNe6xNmzZyzTXX+KWfPn26REREiIjIrFmzxBgj69atK3Rvk5KSRMT2Ryi4b/To0XL22Wf7XXfFihUCyF9//SU//PCDAH7fO28ElzidTvnjjz/K9N09tE2/MIpp068NJf2lwFPGmDARyczbNxzYCWyt7A9/6CFhyZL+5OYGI2IQMWRn29u2ZEl/HnpIePzxys6Fqgvat2+Pw+Fg06ZN3mrVTz75hAMHDnDo0CHq169f5LkVXb3vYYzx9iyfOXMmrVu3pnfv3iWe58nrpk2bWLlypbd54vHHH+euu+7yS3vCCScwefJkzj///FLnq3fv3syZM4e2bdsSHBwcME3Hjh0L7YuLi2PBggVccskl3n0LFizwqxWobDfffDMXX3yx374zzzyTyy+/nOuuu65M13K73d6+FL7CwsJo2bIlOTk5fPjhh1x66aXeYyeffDIbNmzwS79x40Zvn5GTTjoJESElJYWhQ4cG/NxA/UsGDBjAvffe67e40IIFC2jRogXt2rWjadOm/P77737nPPDAAxw4cICXX36Z9u3bl+m7q3Iq6mmgsjbskL1eeVs68FDez23yjv8f8J1P+vpACjAL6AFchO3Nf2dJn3W0Jf39+0XCwtxiu+6JnHXWZu/Pni0szC0HDhzVx6gCjoWn9fL+7l188cVy2mmnyZEjR+SPP/6Q6OhoadGihcyYMaOCc2gVV9J/+umn5bfffpM1a9bIo48+KsHBwfLRRx95jyclJUnnzp1l/vz53n1z5syR77//XjZv3iwff/yxtG3bVi666KJi80CA3vvbtm2TxMREeeaZZwSQxMRESUxMlNTUVBER2bFjhzRp0kQuvPBCWbZsmWzevFkWLFgg1113XbHfadasWRIcHCxvvPGGrFu3Tv79739LZGSk38iI5ORkSUxMlPfff18A+fzzzyUxMVH27dvnTbN7925JTk4ucvPUcpTmPotIwN77o0ePltGjR3vf//e//5VPP/1UNm7cKBs3bpQ333xToqOj5d577/WmWbZsmXz44YeyefNm+fHHH+W0006T9u3bywGfP1IrVqyQoKAg+c9//iObNm2SOXPmSL169eSll17yprniiiukTZs2MnfuXNm8ebP88ssv8swzz8iHH35Y5Hc4ePCgxMbGymWXXSa///67fPjhhxIdHS2TJ08u8hztvV85KKakXx1Bfwi2ar7g9k7e8XeArQXOOQH4EcgEkoFJlDBcTyog6E+dKhIZ6S4U6H23yEi3TJ16VB+jCjgW/uOW93dv165dcsEFF0jDhg2lYcOG8uyzz8oXX3whLVq0kEmTJlVsJqX4YDR06FCpX7++hIWFSb9+/eSLL77wO75lyxYBZNq0ad59U6ZMkVatWklwcLC0adNGHnjgAcnKyio2D4GC/pgxYwL9jfD73di4caP885//lJiYGAkLC5Pjjz9exo0bV+Lnvfzyy9K2bVsJCQmR3r17y6JFi/yOT5o0KeBn+37Ptm3bBkzj2dq2bet3zfIE/cGDB8vgwYO9759//nnp1q2bRERESL169eSkk06Sl19+WVyu/CbGhQsXSteuXSU0NFQaNWoko0ePlh07dhT6vM8++0x69uwpoaGh0qlTJ5kyZUqhYXWTJk2S9u3bS3BwsMTGxsp5550nK1euLPZ7/Pbbb3LqqadKaGioNGvWTB5++GG/6xakQb9yFBf0jT1+bIqPj5ejWd70scdg0iRBxPbIDQ/PISPDvyrRGOGRRwwPPnhUWVU+Fi5cyJAhQ6o7G0clPj5el9ZVXnqfK4/v/7Vj4W9HRTDGJIhIwDWHdcxZMZo1A58hp5x44p5CacLDbTqllFKqptOgX4yLLwbfeT7i4lIKpXG7wadPkFJKKVVjadAvRoMGcNddEBpqFxlp1+6w3/GQkFyuuw50qL5SSqnaQIN+CR591HDllbsJDs7F4fD00wFj3Fx00T5uuskQYMSMUkopVeNo0C+R8K9/beXJJ2fQtGk2numig4LcnH9+EkFBwuHDxV9BKaWUqgk06JfAGENoaCj9+3emZctQJk409O0r5OQE8csvTYmIMBw8CD5TWysV0NixYzHGFNr69+/vTdOuXTvv/oiICHr06MHUqVP9rpOdnc0zzzzDSSedREREBA0bNqR///68/vrrASdqqSzz58/njDPOoEmTJkRHR9OvXz8++eSTEs9btWoVw4cPJyYmhkaNGnH99dd7p2v1CHSfXnvtNb80c+bMoVevXkRERNC2bVueeeaZCvleWVlZ3HrrrTRu3JjIyEj+8Y9/kJSUv/zHnj17OPPMM2nRogWhoaG0bt2aW265hUOHDlXI5wNs3bqVa665hg4dOhAeHk6HDh2YMGFCiRMw/d///R99+vShXr16NGnShPPOO481a9b4pZk/fz5nnnkmTZo0wRgTcNraqVOnMnToUGJiYsq9bHBRPvzwQ7p160ZoaCjdunXjo48+KjLtDTfcgDGGyZMnV9jn13Ua9EshLi6OAQMGkLeWBv/8p/1h+fLWGGM78wVYLlypQoYNG0ZycrLf9sUXX/ileeihh0hOTua3337jggsu4IYbbmD27NmADfhnnnkmjz/+OFdffTU///wzCQkJjB8/nmnTprF06dIq+y6LFi3itNNO4/PPPycxMZGzzz6bCy+8kMWLFxd5zs6dOxk2bBgdOnRg+fLlfPXVV6xdu5axY8cWSvvGG2/43SffVdm+/PJLRo0axfXXX8+aNWt45ZVXeP7553nppZeO+nvdfvvtfPjhh8ycOZPFixdz+PBhzj33XO+iNQ6HgwsvvJBPP/2UjRs38s477/Ddd98VO5ve4sWLadeuXanz8Mcff+ByuXj11Ve98+JPnz6d2267rdjzFi5cyM0338ySJUv4/vvvCQoKYtiwYezfv9+b5siRIwwcODDgOvce6enpnHHGGTz88MOlznNpLF26lMsuu4wrrriC1atXc8UVV3DJJZewfPnyQmnnzZvHihUrvDNCqgpS1AD+Y2GriLn3ff3www+yY4dIYqJIaKiIMSIrVohs3SpSium5VSkdCxNsBPrdK81EJIEmaenUqZN3zfSnnnpKjDHyyy+/FDrX5XLJoUOHypTPkiaNKas+ffrI+PHjizz++uuvS6NGjSQ3N9e777fffhNANm3a5N1HgAl7fF1++eVywQUX+O3773//K61atfKbDOaTTz6R3r17S2hoqLRr104mTpxY7OQ9Bw8elODgYHnvvfe8+7Zv3y7GmGLXk58yZYo0a9asyOOff/55oQl7yurll1+Whg0blumc1NRUcTgc8sknnxQ6tmfPnkITHhVU3PoDSUlJctlll0lMTIzExMTI2WefLRs3biw2P5deeqkMGzbMb9/pp5/u/f322Lp1q7Ro0ULWrVsX8P+EL52cpzCKmZxHS/plVL++HZt/xhl2Tr6PPoLgYMjKskvuKlXRwsLCvCu6vf/++wwbNoz4+MLzbjgcjmJX2ouKiiq0NW/e3Pvz0Sx165GamkqDBg2KPJ6VlUVwcDBOp9O7z7P+uu+a7wC33XYbjRs3pk+fPrz22mve5a091wm0bnxSUpJ3yduvv/6aK664gnHjxrF27Vrefvtt5s2b511dLpCEhARycnI444wzvPtat25N165dWbJkScBzdu7cyfz58/3Wta8Mhw8fLvbeBpKamorb7S7zeSVJT09n6NChhIWFsWjRIpYuXUrz5s0ZNmwY6enpRZ63dOlSv3sLdt0B33ubm5vL5ZdfzgMPPEDXrl0rNN9Kq/fLLDwcHA47hh9gzhwb/IOCoAKb9NQx6quvvioUeO+9996AaXNzc3nnnXf4/fffOf300wG7gE15/xCuXr260PbTTz95f37zzTfL/b0AXn75ZZKSkhg9enSRaU477TT27t3Lk08+SXZ2NgcOHOC+++4DIDk52Zvu0UcfZfbs2Xz77beMHDmSO++8kyeeeMJ7/Mwzz+R///sf33zzDW63m40bN/Lss8/6Xefxxx/n7rvv5uqrr+a4445j6NChPPXUU7z22mue6b0LSUlJwel00rhxY7/9sbGxpKT4z9Nx+eWXExERQcuWLYmOjmbatGneY9u3b/f7N/7nP/9ZaN+NN95YmtsKwLZt25g8eTI333xzqc8B++DUq1cvBgwYUKbzSjJr1ixEhGnTptGzZ0+6dOnC66+/TlpaGp999lmR56WkpBAbG+u3r+C9nTRpEo0bN+amm26q0DwrqzasslejOBwQHQ39+kHTprB5M6xcCfHxNug3bgw+hRil/AwaNKhQx7yYAhM93H///Tz88MNkZWUREhLC3XffzQ033ABQZLAqjUCrzlXU9LAffvghd999N7Nnzw64AptH9+7deffddxk/fjz3338/QUFB/Pvf/yY2NhaHI78M8qDPvNa9evXC5XLx+OOP88ADDwBw3XXXsXnzZs4//3xycnKoV68et912Gw8//LD3OgkJCaxYsYKnnnrKey23201GRgYpKSlMmzbN70Fi3bp1ZfrOzz//PJMmTWLjxo1MmDCB22+/nddffx2AFi1asHr1am/ahQsX8vDDD/t1miuuVsbXrl27GDFiBMOHD+eOO+4odf7Gjx/PTz/9xE8//eRXs1IREhIS2LJlS6HfnfT0dDZv3sz27dvp1q2bd//EiROLrWHxWLhwIe+8847fvVMVS4N+OdSrZwP8JZfAyy/DzJnQp489lpZmmwCUCiQiIiJg8PU1fvx4rrnmGiIiImjevDnG04MUOP7441m/fn25PjsqKqrY46eeeipffvllma87b948rrrqKqZPn855551XYvpRo0YxatQodu3aRWRkJMYYnnvuOTp06FDkOf369ePw4cPs2rWL2NhYjDE89dRTPPHEE6SkpNCkSRO+++47AO913G43kyZN8ltG16NJkybceOONfkvOtmjRgmbNmuFyudi7dy9NmjTxHtu1axennnqq3zWaNWtGs2bN6NKlCw0bNuTUU0/lgQceoHXr1gQFBfn9O2/cuLHQvtJISUnhtNNOo0ePHsyYMcPvd6E4d9xxB7NmzeKHH34o9r6Wl9vtplevXsyaNavQsYYNG1KvXj2/wN2wYUPA3rNdu3b5pd+1axfN8uYyX7hwIcnJyTRv3tx73OVyce+99/LCCy/4jaJQ5aNBvxzCwmyJ/9JLbdD/9FN49FG7f98++1BQyv+bShXSqFGjIoPDqFGjmDBhAitXrizUru92u0lLSyuyBBmo9JSWluZ9GAj3XWiilObMmcOYMWN49913C60RXxJPNe/bb79NWFgYw4cPLzLt6tWrCQsLK1Qr4nQ6admyJQAzZ85kwIAB3mDdu3dv/vjjjyLvZcOGDb3ByCMuLo7g4GAWLFjAqFGjAEhKSmL9+vUMHDiwyPx5+htU5JDJ5ORkhg4dSvfu3Zk5cyZBQaX7c33bbbcxe/ZsfvjhB7p06VJh+fHVu3dvZs6cSePGjQv9m3gEuu8DBgxgwYIF3H333d59CxYs8N7bm2++udDv0Zlnnsnll19e7OgIVXoa9MvB4bCleYfDVvMvXw6ffAKjRkFGht0iIqo7l6omysrKKtQ27HQ6/UqVxbn99tv5/PPPGT58OI888giDBg2ifv36JCYmMnnyZJ544okiVxmr6Or9WbNmMXr0aCZPnsygQYO83yskJMQbTD/66CMmTJjAd9995w3OL730EgMGDCA6OtobAJ588klv8Pj0009JSUlhwIABhIeH88MPP/DQQw9x/fXXExoaCsDevXuZO3cuQ4YMISsri2nTpjF37lwWLVrkzd9DDz3EueeeS9u2bbn00ksJCgpizZo1rFixgqeffjrgd6pfvz7XXHMN99xzD02bNqVRo0aMHz+enj17MmzYMAA+++wz9u3bR1xcHFFRUaxdu5a7776b/v37e++xy+Viz578BbqOP/54li1b5vdvHx4eTv0iqgV37tzJkCFDaNGiBS+88AJ79+71HmvSpIm3ur5Lly6MGzeOcePGAXDLLbcwY8YMPv74Yxo0aOD9PE8/AoD9+/ezfft2Dh48CMCff/5JTEyMt+YCbA1DSkoKGzduBGzTx8GDB2nTpg0NGzbkiiuuYPLkyZx//vk8+uijtGnThr///pv//e9/3HjjjXTq1Cng97rtttsYNGgQTz75JBdccAEfffQRP/zwg7cTZ9OmTWnatKnfOcHBwTRr1ozOnTsHvKYqo6K69R8LW2UM2fNITxf54w+R558XAZHevUV27BDZvFnk778r9GPrnGNh2E1RQ/YIsPZ6y5YtvWlKGp4kIpKZmSlPPvmk9OzZU8LCwiQmJkb69esnr732WolryRd0NEP2Bg8eHPD7+K4BP23atEJDvkaPHi0NGzaUkJAQ6dmzp0yfPt3vul9++aX06tVLoqKiJCIiQnr06CEvvPCC5OTkeNPs2bNH+vfvL5GRkRIRESGnn366LFu2rFAev/76aznllFMkPDxcoqOjJS4uTl588cViv1dmZqaMGzdOGjZsKOHh4XLuuefK9u3bvccXLFgg/fv3l/r160tYWJh06tRJ7rnnHtm/f783zZYtWwLeG99tzJgxRebBc98Cbb73EpBJkyb5vQ+0+aYp6tq+aSZNmhQwzbRp07xpUlJSZOzYsdKkSRMJCQmRdu3aydVXXy179uwp9v7OnTtXOnfuLMHBwdKlSxf58MMPi02vQ/bKjmKG7Bk5io5BNV18fLxU5Jrmvms1i8Bff9mZ+OLibFv+Dz/A8cdDaiq0bw8hIRX20XXKsbAmtu8a3zWZrvNeNfQ+Vx7f/2vHwt+OimCMSRCRwuN60SF75WZMfhX/+efbfTNn2lenE52PXymlVI2jQf8oREfbkn5efx/mzYPsbDuW/8ABnY9fKaVUzaJB/yiEhNjZ+Lp3h65dYf9+WLDA1gKI2Cp/pZRSqqbQoH8UjIFGjWzpfuRIu88zbNUzfO8Y7jKhlFKqltGgf5QiIuwqexddZEv+P/wASUl2Wt7sbDt8T6nqNHbsWM4999zqzkat1aNHjwpfbU6p6qJB/ygFB0NkpN3OPdeW7N97zx4LDbVV/kpVtrFjxwZcg3716tVMmTKF9zy/lMCQIUO847pVzfXKK6/Qvn17wsLCiIuLK3bJYrCT+YwaNYouXbrgdDoDLlc8d+5c4uPjiYmJITIykl69evHuu++W+bOzsrK49dZbady4MZGRkfzjH//Q2fJqCQ36FSAmxpbqPeuMzJpl34eGwpEjdgU+pSrbsGHD/NafT05OpkePHtSvX7/IWdPqiuzs7OrOQpnMnj2b2267jYkTJ5KYmMjAgQM566yz2L59e5HnZGVl0bhxY+677z769esXME2jRo144IEHWLZsGb/99htXX30111xzDV988UWZPvv222/nww8/ZObMmSxevJjDhw9z7rnn4tLeyzVfUQP4j4WtMifn8ZWbK7Jxo52Up0sXO1nPq6/ayXr+/FNk164KzcYx71iYYKOif/dKMmbMGDnnnHNKPBZogqBAa6WPHTtWGjduLI8//rh3319//SXBwcEyY8aMIvPx4YcfygknnCBhYWHSoEEDGTRokKSkpHiPP/XUUxIbGyuRkZEyevRomTRpkt8684G+x6RJk6R79+7e9ytWrJDhw4dLo0aNJDo6Wk4++WRZsmSJ3zmAvPTSS3LhhRdKRESE3HnnnSIi8sknn0jv3r0lNDRU2rVrJxMnTvSb0GjXrl3yj3/8Q8LCwqRNmzby1ltvSffu3f0mrimPsk6C1LdvX7n22mv99nXs2FHuu+++Up1/zjnnFDv5j6+TTjrJ77olffbBgwclODhY3nvvPe/x7du3izFGvvrqq1J9ZkXSyXkKo5jJebSkXwGcTjt8Lysrv7Q/Y4Z9DQuzw/dyc6svf0p5TJkyhQEDBnD11VeTnJzMpk2baN26daF0zz33HP/3f//Hgw8+yIYNGwA7rW3nzp29c9IXlJKSwsiRIxkzZgzr16/nxx9/9Ftmd86cOTzwwAM88sgjrFq1is6dO/Pcc8+V+TukpqYyevRoFi9ezIoVK+jVqxdnn302+/bt80v3yCOPcPbZZ/P7779zyy238PXXX3PFFVcwbtw41q5dy9tvv828efP8Vn8bO3Ysf/75J99++y0ff/wx06dPZ+vWrcXmZ/HixYWWSy64TZ48udTfLzs7m4SEhELrzp9xxhl+684fLRHhu+++Y8OGDQwaNKjUn52QkEBOTo5fmtatW9O1a9cKzZ+qHDr3fgWpX9+uvPfPf8Ljj8OSJfDnn9Cxo53A5/BhKLC2h1IV6quvvvJbSS/Qqnn169cnJCSEiIgImjVrRmpqasBlVxs0aMC1117LvHnzmD59OpdffjkffPAB8+fP91sC19fOnTvJycnh4osv9i6v26NHD+/xF154gTFjxniXCb7//vv54Ycf+PPPP8v0PU877TS/9y+++CIffvghX375JVdeeaV3/2WXXca1117rfT9mzBjuvvturr76agCOO+44nnrqKa688kqeeeYZNm3axJdffslPP/3EySefDMC7775b4ip18fHxJS4FGxwcXOrvt3fvXlwuV8B157/99ttSX6cohw4domXLlmRlZeF0Onn55Zc566yzSv3ZKSkpOJ1OGjduXChNwXUlVM2jQb+ChIXZHvshIXDhhfD++zB9ul19LzzcduiLibEPAEpVhkGDBjF16lTv+/KsmlfQVVddxYQJE/j999/p06cP5+dNP/n+++97gzfAl19+ycCBAxk2bBg9evTgjDPOYNiwYVx88cXexYTWr1/vF4TBrrpW1qC/e/duHnzwQX744Qd27dqFy+UiIyOjUHt3wVUIExISWLFiBU899ZR3n9vtJiMjg5SUFNavX4/D4aBv377e423btqVFixbF5ic8PLzEJXNTU1NL+/UqXXR0NKtXryYtLY3vvvuO8ePH065dO04//fTqzpqqAhqCKogx0KABZGbCVVfZffPm2SF7Docd1qeT9ajKFBERQceOHb2bZ1W7o3HBBRdw4MABPv30Ux5//HHv/n/84x+sXr3au8XHx+N0Ovnmm2/45ptv6NmzJ2+99RadOnXi119/LfXnORwOpMDkFjk5OX7vx4wZwy+//MLzzz/PkiVLWL16Na1atSrUWS8yMtLvvdvtZtKkSX75/u2339i0aZPfKoelXbPeo6Kr9xs3bozT6Sx23fmj4XA46NixI7169eLOO+/kkksu4Yknnij1Zzdr1gyXy+W38l9F5k9VLi3pV6CoKNizB3r0gJNOgsREu+TuZZfZmoC9e23bfxn/pihVoUJCQkrdyzoiIoJOnTphjPErCUZHRwdcQMYYw4ABAxgwYAAPPfQQ3bt3Z/bs2Zx44ol07dqVZcuW8a9//cubftmyZX7nN2nSpFBVecH3P/30E//9738555xzABtskpOTS/wuvXv35o8//iiyVN6lSxfcbjcrVqzwru++fft2du7cWex1K7p6PyQkhLi4OBYsWMAll1zi3b9gwQL++c9/lvo6peV2u8nKG2JUms+Oi4sjODiYBQsWePt3JCUlsX79eu99UzWXBv0KFBJiq/I9w/cSE20V/2WX2ar/jAxIT7dj+pWqLu3atWPFihXeDmqRkZFFttMvWLCAVatWERUVRXp6OhEREUVed9myZXz77beceeaZxMbGkpiYyN9//023bt0Au5b6VVddRZ8+fRgyZAjz5s1j+fLlNPTp7HLaaafx9NNP8/bbbzNo0CDmz5/Pzz//TKtWrbxpjj/+eN577z369evHkSNHuOeeewgpxZKWDz30EOeeey5t27bl0ksvJSgoiDVr1rBixQqefvppOnfuzIgRI7jhhhuYOnUq4eHhjB8/vsRmksqo3h8/fjyjR4+mb9++nHzyybz22mvs3LmTG2+80ZvmqrwqxenTp3v3eR4+Dh8+jMPhYPXq1YSEhHj/DR5//HH69etHhw4dyMrK4osvvmDGjBm8+OKLpf7s+vXrc80113DPPffQtGlTGjVqxPjx4+nZsyfDhg0r0/dU1aCobv3HwlZVQ/Z8HT4s8scfdqheTIwdvvfZZ3b43pYtItu2VWiWjknHwrCbmjpkT0Rkw4YN0r9/fwkPDy9yyJ5Hnz595Pzzz5c2bdoUO1RPRGTdunUyYsQIadq0qYSEhMhxxx0nTz31lF+aJ554Qpo0aSKRkZFy+eWXFxqyJ2KH6DVr1kzq1asnN910k0yYMMFvyN7q1aulb9++EhYWJh06dJDp06cXGlYHyNy5cwvl8euvv5ZTTjlFwsPDJTo6WuLi4uTFF1/0Hk9JSZHzzjtPwsLCpFWrVvLGG29Uy5A9EZGXX35Z2rZtKyEhIdK7d29ZtGiR3/HBgwfL4MGD/fZRYDgm4Hd/77vvPunYsaN3SOWAAQPkgw8+KPNnZ2Zmyrhx46Rhw4YSHh4u5557rmzfvr3M37Ei6JC9wihmyF61B+bK3Koj6HvG7Cclidx0k73DF11kg/6OHfaBID29QrN1zDkW/uNWddAvr+KC0fz588XhcMiaNWtk4sSJMnz48Ar//GeeeaZQ0D8WlSfoq9LRoF9YcUFfO/JVMKfTDt/LzISxY20nvk8/BU+/mOBgnZpX1Xxut5sHH3yQyy+/nO7du3PVVVfx3Xff8eqrrxbqwKWUqj2qJegbY242xmwxxmQaYxKMMaeWkP4WY8x6Y0yGMWaDMeaqqspredSrZyfjadUKRoyAnBz/yXpSU3VqXlWzvf/++2zYsIFHHnkEgM6dO/PYY4/x4IMPcvfdd1dz7pRS5VXlQd8YcxkwBXgCOAlYAnxpjGlTRPqbgKeAR4HuwCTgZWPMeVWT47ILC7Od+nJzwdNRecaM/ECvpX1V040ePZqcnByOO+44776JEyeyd+9epk2bVmGfc9ddd5U4451SquJUR0l/PPCOiLwhIutF5FYgGbipiPSjgTdEZKaI/CUis4CpwL1VlN9yadTIVvH37w/dutnhep9+ao+Fh9vZ+2rZGiBKKaVquSoN+saYECAO+KbAoW+AogZ4hgKZBfZlAH2NMaUf/FrFfIflXXONfX3rLbv0LtghfAcPVnm2lFJK1WFVXdJvDDiBXQX27wKKmsrpa+Bfxpg+xooHrgWC865XIzmdtm0/MxPOP9/O1vfbb7BypT0eHm6DfoHJxpRSSqlKUxsm53kM+0CwBDDYB4R3gXsAd8HExpjrgevBLgCxcOHCCstIWlpama4nYqvwHQ4YMaI9M2e25fnnd3P//esAOzXv9u221K/ylfU+10Th4eF+i83UVCJS5mlnVdnpfa48DRo08P69OBb+dlQ2IyIlp6qoD7PV++nA5SIy12f/y0APERlczLnBQCy2/f96bOe+GBEpFPg94uPjZaWnaF0BFi5cyJAhQ0qdXgS2bLFBffdu274PsHQptGxpjx85Ah06aOD3Vdb7rMpP73XV0PtcNfQ+W8aYBBGJD3SsSqv3RSQbSACGFzg0HFuSL+7cHBFJEhEXMBL4rLiAXxMYk9+hr0ULOPdccLls277nuDG2U59SSilV2aqj9/5zwFhjzLXGmK7GmClAC+A1AGPMdGOMdzJpY8zxxpjRxphOxpi+xphZQA9gYjXkvcw8HfpEwDNt9vvvw+HD9ufwcNi3zw7vU0oppSpTlQd9EZkN3A48AKwGTgHOFpFteUna5G0eTuwwv1+BBUAYMFBEtlZNjo9OUFD+DH09e8LAgXaJ3ffft8cdDlva9zwEKKWUUpWlWmbkE5FXRKSdiISKSJyI/OhzbIiIDPF5v15EThKRCBGpLyIXiMiG6sh3edWvn1+SvylvNoI338wfpx8ebsfxa2lfKaVUZdK596tAWBiEhtrheUOHQufOkJIC//ufPa6lfaWUUlVBg34V8XToMwZuuMHue/31/Ml6tLSvlFKqsmnQryKRkXbCHrcbLrgAYmNh/XpYtMge19K+UkqpyqZBv4o4HBATAxkZtqrfMzXvq6/mp9Ge/EoppSqTBv0qVK+eLekDXHmlLf3/9JOdnhfsgwHouH2llFKVQ4N+FQoJsYE+K8v26L/ySrv/xRfz00REaGlfKaVU5dCgX8UaNrRBH+D66+2DwJdfwqZNdp8xtsR/4ED15VEppdSxSYN+FQsPt4E+NxeaNYPLLrM9+H1L++HhsH+/rsCnlFKqYmnQr2LGQOPGtkMfwM032179H38M27blpwkKsoFfKaWUqiga9KtBVFT+8L02beDCC+1CPK+8kp8mLAwOHsxvClBKKaWOlgb9auBw2Lb9zEz7/tZbbel+zhxITrb7PKX9ffuqL59KKaWOLRr0q0l0tC3di0DHjnD22XYu/tdfz08THg6pqfkPB0oppdTR0KBfTYKD81ffA/j3v+3re+/5l+6Dg2HPnqrPn1JKqWOPBv1qFBOT30O/Rw847TTbwc+3tB8WBunpcORItWRRKaXUMUSDfjUKC7OT8XiW2B0/3r5Om2YX3/FNt3t3/uI8SimlVHlo0K9mjRrl99A/6SQ4/XRbsvedkz842D4YpKZWTx6VUkodGzToV7OICBvUPdPu3nWXfX3nHVu69023e7ft/KeUUkqVhwb9amYMNGmS36GvZ08480z73nfcvmdcvy7Go5RSqrw06NcAkZE2qHtK8Z62/RkzICUlP11EhG3r18V4lFJKlYcG/RrA4bBT83pK+z162HH7mZnw8sv+6RwOnbBHKaVU+WjQryGiouyr221fPaX999+HnTvz04WH2xX4dMIepZRSZaVBv4ZwOm1Pfs9CPF27wnnn2Z79L7yQn84YCA3VIXxKKaXKToN+DVKvni3pe4L5XXfZh4FZs+DPP/PThYbah4O0tOrJp1JKqdpJg34NEhQEDRrkl/Y7doSRI20Hv6ef9k8bHq5D+JRSSpWNBv0apkGD/IV4AO64w87I9/nnsHp1frqgIJtOh/AppZQqLQ36NUxwsH9pv3lzuOYa+/MTT/i340dG2iF8nml8lVJKqeJo0K+BYmL8S/s332xX5Pv5Z/jxx/x0xtg2f12FTymlVGlo0K+BQkJs4PcMy4uJgVtusT8/8UT+sD6wbfupqboKn1JKqZJp0K+hGjSwy+56Svv/+hc0awZr1sAnn/inDQ+HXbv8HwaUUkqpgjTo11AFS/vh4XDnnfbn//s//8l5goNtc8DBg1WdS6WUUrWJBv0arGFDW9r3uOwyO2lPUhK88YZ/2ogI27avnfqUUkoVRYN+DRYSYjvweXryO53w0EP25xdf9O/AZ4wdxrdrl87Up5RSKjAN+jVco0b+bfuDBsGwYbbj3jPP+KcND7f7daY+pZRSgWjQr+FCQvzH7QM8+KAt1c+cCevW+aePiLClfTvkz7/IX/C9UkqpuqVagr4x5mZjzBZjTKYxJsEYc2oJ6UcZY1YbY9KNMSnGmPeMMc2qKr/VrWFD/3H7HTvCVVfZ3vqPPOJfnR8UZF+/+241S5Ys8QZ6EWHJkiUkJCRUce6VUkrVFFUe9I0xlwFTgCeAk4AlwJfGmDZFpD8ZmAG8C3QHLgC6Ae9XRX5rguBgG/h9S/t33GF79//0E3z7rX/6sDBh7dqd/PRTgjfwL1myhOXLl7N582Yt8SulVB1VHSX98cA7IvKGiKwXkVuBZOCmItIPAJJE5HkR2SIiy4AXgX5VlN8aoUED/xX4GjaE22+3Pz/8sF2C18MYaNOmKYcORbB06XKmTp3K8uXLAWjVqlWV5lsppVTNUaVB3xgTAsQB3xQ49A0wsIjTfgaaG2POM1ZjYCTwReXltOYJCrKBPj09f9/YsdCpE2zdCq+/nr/fGEP//nH07HkSBw4Y9u3bR2ZmJv3792fAgAEYY6o6+0oppWoAU5VVvcaYFsAOYLCI/Oiz/yHgChHpXMR5FwHvAOFAELAAOF9EMgKkvR64HiA2NjZu1qxZFZb/tLQ0oqKiKux65ZGVBQ6fR7XExBjuvbcXoaEu3nprBU2b5hf5jxxJJzX1CEFBLoyB6OhoIiMjqyHXZVMT7nNdofe6auh9rhp6n62hQ4cmiEh8oGNBVZ2ZsjLGdMNW5z8GfA00B54BXgeuKpheRKYCUwHi4+NlyJAhFZaXhQsXUpHXK48DB+z4fM/vdffusHgxfPaZk5kzBzB1qu20t3LlShITN5Cb6yAyMoLQ0F0YA/369WPgwIE1urRfE+5zXaH3umrofa4aep9LVtVt+nsBFxBbYH8skFLEOROAFSLyjIj8JiJfAzcDo40xda6Bun59O0mPy5W/76GH7Bj9zz/PX4UvOTkZgL59e3HRRaPo1u1kAHbs2FHVWVZKKVVDVGnQF5FsIAEYXuDQcGwv/kAisA8Kvjzv69w8Aw4HNGni37bfsiXcdpv9+cEHISfH0K5dO3r37k18fDzR0YZ27fpy0kn9Oe6442p0KV8ppVTlqY6g+Rww1hhzrTGmqzFmCtACeA3AGDPdGDPdJ/2nwPnGmJuMMR3yhvD9F1glIturPPc1QHQ0hIb6z7N//fXQvj38+Se8+SYkJSXx999/c/HFcPHFEBIi/PrrLrZs2VZ9GVdKKVWtqjzoi8hs4HbgAWA1cApwtoh4olGbvM2T/h3sML9xwBpgHrAROL+q8lzTGANNm/qvtBcaCo89Zn9+7jlh504nSUlJ7N27FxC++up/bNuWwr59Lty6Bq9SStVJ1VI9LiKviEg7EQkVkTjfnvwiMkREhhRI/6KIdBeRCBFpLiJXiEhSlWe8BomIsJ35fAP/0KFw3nmQkWFYtOgMWrVqTVZWFjt27ODvv//muOOaceqp/yQ7u861iiillKIOtokfS5o08V+MB+DRR6FePfj+e0Nm5vmkpUVy6FA0q1d3Z/DgfxAR4SA52U70o5RSqm7RoF+LhYbaqXh9p+dt2hQmTrQ/33234cCB+hw+XI/vvz+V3r2FCRNSyM6GffuqJctKKaWqkQb9Wq5hQ1tq9y2579jhxhg3YLD/xIacnBByc4P48MNGvPyym337/EcAKKWUOvZp0K/lgoP9h/AdPAhTpzoQCfxPm5MTzNSpDnJyYOdOyM2turwqpZSqXhr0jwH169u5+XNy7AQ9TmfxUys7ncJXX9mfd+3y7xOglFLq2KVB/xjgcEBsrG3b373b9t4vTkaGYfduOwIgLQ0OH66ijCqllKpWGvSPEZGRdtKemBgIDy++6B4eLjRtmn/erl3+S/MqpZQ6NmnQP4Y0aQLDh4PLVXxJ3+UynHuu/dnhsP0CdBifUkod+zToH0NCQqBDB/jXv9yEhATuoedwuLnhBjf16+fvCw21/QH27KmijCqllKoWZVpa1xjTHxgB9MfOlx+OXTlvA7AI+FhEDlR0JlXpNWgA48c72LbtLxYsaI/L5cDtNoSGCllZIGIYMaJwTUBkpF22NyLCNhMopZQ69pSqpG+MGWOM+R27Et4d2JXvNgHLgQNAP+BNYIcx5h1jTPtKyq8qgdMJzZvDs892ZNUqQ9u2hlat4LHHDFddZYP+HXf4T9/rERlpq/l9F/JRSil17CixpG+M+Q1oAkwHrgJWixQe5GWMqQ+cC1wBrDPGjM1bXEdVMU+nvowMQ2ys3XfFFXYs/+LFsGEDPPUUTJrkf57TaYf+7dwJbdrY9n6llFLHjtL8WX8LaC8i94pIYqCADyAih0TkfRE5G1v9f7AC86nKKCkpgZUrE/H8c4kIa9eu5LbbNuF0wtSp9gGgoLAwW9LX9n2llDr2lBj0RWSKiASoDC72nF9F5OvyZ0sdDRFh27bNbNq0hNtuS2TePGHlypWsWrWK0ND13H67fRC4/XY7g19BUVG2ff/QoSrNtlJKqUqmFbjHKBEhKCiNtWsTePfdmaxatYqcnBxEhFtvhd69ISUlf3GegqKi7PFAbf9KKaVqp1IHfWPMBcaYacaY5caYTXnb8rx9F1RiHlU5tG7dmpCQYByOPezefYgjR9IJCgqiRYsWBAXBiy/anvr/+x989FHh8x0OO5Rvxw6dn18ppY4VJQZ9Y0wDY8xPwHxgKHaI3rK8bS8wBJhvjPnZGNOgEvOqSskYQ//+/WnevDlBQbmEhqaRnR1MbGwscXFxGGNo1w4eecSmnzABtm8vfJ2QEPuanKzz8yul1LGgNCX9Z4E2wGARaSci54jI6LztHBFpDwwCWgKTKzOzqnREhGXLlpGSkoIxhqiobJxOITl5LwkJCd7OfZdfDmedBampcPPNgYfqhYfbXv9791bxl1BKKVXhShP0/wHcJSIB+npbIvITcC9wQQXlSx2lv//+m+zsbCIiIoiNbUJsrJv0dGHHjp3eNMbA5MnQsiUkJsKTTwa+VlQU7NunC/MopVRtV5qgH4qdgKckB4GQo8qNqjDGGIKDgxkwYADXXXcdgwb1oV69XHJy/KdmiImBV16xY/Rffx2+/TbQtWzg37nTruSnlFKqdipN0F8K3G+MKXJy1rxjE7Az9qlqZozhuOOOY8CAAQwYMABjDAMGDOD003vRtm0bcnP9p+GNj4d777U/3367De4FORy2qn/HDjtPv1JKqdqnNHPv3w4sBLYZYz4H1pBf8m8AdAfOAVzYjn6qBoiLi0NEMMYGeGMMp5wygIwMw/btduY94xP7b7oJliyBhQvh1lth9mybxldwsO3Jv2OHztinlFK1UWkm51kHnAi8CwwAngBey9ueAE7GTtHbS0TWVl5WVVkZYwq9j4iwi/Kkp/undThgyhRo2hSWLbPT9AYSHm5L+ikp2qNfKaVqm1KV1UQkWUTuEJGOQCS2p35LIEpEjss7FqBSWNVEjRvbNvyCvfUbN4ZXX7XHXnkFPv888PmRkbZTn/boV0qp2qXMFbQikpn3EJAsItqtqxZyOqFFC/KW2vU/1r8/PPCA/Xn8ePjzz8DXiI62QT/QNL5KKaVqptJMznNRWS9qjGlujOlfviypqhAWBk2aQFpa4WPXXQfnnWePXXstHDlSOI0xNvCnpAS+hlJKqZqnNCX9F40xq40xNxpjGhaX0BhzqjFmKvAn0LNCcqgqTYMGNvgXnF/fGHj2WejUCTZtgjvvDNx+73DYqv4dO3SOfqWUqg1KE/Q7YafgfRTYZYz5zRgzwxjznDHm/4wxrxljvjHG7Mf28u8EDBeRqZWXbVURjIHmzW3HPLfb/1hkJLz5ph2f/+mnto0/EKfTztGflBR4Rj+llFI1R2l676eLyKNAK+BKIAGIA/4F3AGcBziBKUB3ERkqIjpev5YICbGBP1AVfceOtkc/wP/9H3zzTdHXcDpt4NfFeZRSquYqdUc+EckGvgNuEpFuIhIjImEi0lJETheRR0Tkj8rLqqos9epB/fqB2+5HjIC777bV++PGwYYNga8RGmrTJCWBy1W5+VVKKVU+penI5zTGPGyMOQDsAg4bYz40xsRUeu5UlWnaNPAwPoDbboN//MM+FFx9NezfH/ga4eE24O/cWbi5QCmlVPUrTUn/RuAhIBG7it7/gPOB5ysxX6qK+Q7jKxiwjYHnnoOePWHbNrjhhqKn4g0Pt/Pzp6Ro4FdKqZqmNEH/OuANETlNRO4VkUuAW4ArjTG6wM4xJCwMYmMDt++Hh8Nbb9lhfkuWwIQJRc/IFxVlr7Frl87ap5RSNUlpgn4HYG6BfbOxnffaludDjTE3G2O2GGMyjTEJxphTi0n7jjFGAmwBWqDV0apf324Fp+kFWxMwbZp9OJg5E158sejrREXZWft279bAr5RSNUVpgn4UUHAl9dS81yJX3iuKMeYybE//J4CTsCvzfWmMaVPEKbcBzQtsfwFzyvrZqmTG2PZ9h8NW9Rd00knw0ks23VNPwUcfFX2t6Gg7Y9/evRr4lVKqJiht7/2WxpgOng1b+i+0P+9YScYD74jIGyKyXkRuBZKBmwIlFpFDIpLi2YDj8j7/jVLmXZWR0wktW9pOfYF64p91FkyaZH8ePx6WLi36WlFRsG+f3TTwK6VU9Spt0J8HbPLZPEPzPi6wf1NxF8nrAxAHFBzx/Q0wsJR5uQ5Yq3MBVK7QUFudf+RI4GB93XVwzTX2weCaa+zMfYF4puvVwK+UUtXPSAl/hY0xY8pyQRF5t5hrtQB2AINF5Eef/Q8BV4hI5xLyUh9bKzBBRKYUkeZ64HqA2NjYuFmzZpUl+8VKS0sjKiqqwq5XG+Tm2tK+I8DjocsFjz3WnSVLmtC4cSYvvJBI06YB2gTyuN22FiEoqPjPrIv3ubrova4aep+rht5na+jQoQkiEh/oWIlBvyJVQNC/BXgWaCEiRYwWzxcfHy8rV648ylznW7hwIUOGDKmw69UGngl3srNtD/6CMjJg1ChYsQKOOw4+/hgaFrFCgwikpkKjRnYZX2MCp6uL97m66L2uGnqfq4beZ8sYU2TQL/PSukdpL+ACYgvsjwVSSnH+dcCHpQn4qmJ45uc3JvDEPeHh8M470LUrbN4Mo0cXveqeb1V/UZ37Cj6EVuVDqVJKHeuqNOjnTeWbAAwvcGg4thd/kYwxfYET0Q58VS4oqPiOffXrw/vvQ5s2sHq1XY43UM9/8A/8BYfzJSQksNSnV6CIsHTpUhISEir2CymlVB1V1SV9gOeAscaYa40xXY0xU4AWwGsAxpjpxpjpAc67HtgkIgurLqvKo6SOfbGx8MEHdvKexYvh5puLnrXPGDvf/4ED+TP3iQhZWVmsWbOGI0eOeAP+mjVryMrK0hK/UkpVgCoP+iIyG7gdeABYDZwCnC0i2/KStMnbvIwx0cBI4M0qy6gqJCqq6Bn7ANq3h/fesyX/r76Cf/+7+MV36tWzbfzJySBiCAkJISoqioyMDN544w3WrFlDVFQUISEhmKI6ACillCq1EvpRVw4ReQUIuEK7iAwJsC8VO0mQqmYxMbaa/9Ah+xBQUI8etqp/5Ej45BO77O7zzwfu/Q/5U/YmJQkZGdmkpqYSExMD2J64IkJ2djYiooFfKaWOUnVU76tazBhbhR8REXiqXrCz9r33nk0zbx7cd1/x4/OjoiA729CqVX8iIuohIuzdu5fMzEyio6Pp37+/BnyllKoAGvRVmTkctkd/UJAdshdInz62V39YmC35T5xY/Kp74eHCL7+sYvt2MMZBo0aNCAsLIy0tjWXLlmmbvlJKVQAN+qpcPFP1QuChfAAnn2xX5gsNhenT4d57iw78xhiio4OJjIzA7Q4iNzeIyMhIbdNXSqkKpEFflVtwMLRqZYN+bm7gNEOG5K/M98EHcOedgTv3edrus7IOEx4exumn/4vjjjuR1NRUb5u+Ukqpo6NBXx2V0FAb+DMyiu6pP3gwvPuunchnzhy4/fbCDwnGGEJDQ+nSpQuRkRFERhpatuxH27a9CA0N1ZK+UkpVAA366qhFRNiq/iNHiq6+P+UU27YfGQnz59tx/AUn8OnZsydxcXFs3gyXXgrR0YY2bfrQpk2cLtSjlFIVQIO+qhBRUXbynrS0ogN/v3428EdHw+efw9ix9kHB47fffvObfc8YYePGBH788Xd27ix+zL9SSqmSadBXFaZevfzJe4oqmffpY4fxNW4MP/5ox/MfOGDb9Ldu3cqqVatwu92AsHLlShITV7FnzxbS04Xt24vuNKiUUqpkGvRVhWrQAJo2tTPtFRX4e/SAjz6yfQFWrYKLL7bT8TZv3hwAl8vFrl27WLVqFWD3R0TYc7duLXp+AKWUUsXToK8qXMOGtiRfXODv0MEG/k6d4I8/4IILDPXrx3P88X1wuRzs2xfO8uUdOf74PsTHx+d19LOjALZv99QOVO33Ukqp2k6DvqoUjRvbrbiq/hYtbKe+k06CpCQ480xhzJgTcbmcHD5cj++/P5WxY0/krrt2e68RFGT7D+zebWsHtJ1fKaVKT4O+qjSNGtlSf3El/oYNYe5c6NBByM524HI5SUxsChhyckLIzXUyf34jnn46v3egw2E7A6aloe38SilVBhr0VaUxxpb2GzUqPvBnZdmSvsf773fzO56dHcTrrxsOHfI/LzLSvm7daq+vlFKqeBr0VaXyBP7i2vg//xyCgoqffMfpNHz2WeH9oaF20p+kJNizp/j5/ZVSqq7ToK8qnSfwF9Wrf/du/4V7rrpqTaFrZGTYdIE4nXa44MGDWt2vlFLF0aCvqkzDhnYc/+HD/iXypk3tKnsePXvuLXRuaKjQtGnR1zbGVve73ba6//DhCsy4UkodIzToqyrVoIHttZ+amt/z/pxzwOUqvno/M9MQFFTy9cPCbHX/zp3au18ppQrSoK+qXP36dmKeI0fswjsxMXDjjUJoaOAI7XDYaoHx4+Gxx4pe0c/DU92flmZL/b5NB0opVZdp0FfVIjoa2rSBzEzbBn/33YYLL9xDUJAnogvBwdkEBeVyySW7efhhG8xfew1GjYJ9+0r+jIgIO65/2zbYu1c7+SmlVCkqTJWqHBER0LYt/P035Oa66dnzaxo1SsPp7EKDBmn07/8LHTqsp2XLKEaPHs0JJzi48Ub4+Wc480x49VU7l39xgoNt4N+/35b8mzWzTQBKKVUXaUlfVavQUFvidzgMERGNiIjIwel0Exl5iO7dfyUiIoeYmBiMMfTvD19+CXFxkJwM//wnvPJKySV4Y+wsfiK2un//fi31K6XqJg36qtqFhNjA36ZNLA5HPb9j4eHhtGjRwvu+eXO7St8NN9hOeo8/DmPG2EBektBQ26ywd68d2peZWdHfRCmlajYN+qpGCAoytGxpaNOmHjExBxk1aj4Oh4MmTZoQEhKCMfm9+0NC4KGH4J13bCfA77+H4cNttX9JfEv92tavlKprNOirGkFE2LJlMwcPbiIoSIiMbEpwcBg7duxg69atSICp/IYPh2++gfh4OzzvssvgP/+x0/qWJDTUBv/9+3W5XqVU3aFBX9UIIsL+/ftxuXIJDQ3i9tsvpUGD5mRmCgcPHgwY9AFatoQPP4Q777QL8bz6Kpx3HmzaVPJnekr9Tqet7k9OLnk4oFJK1WYa9FWN4HA46NOnD8cddxxut5tZs94kPHw3bdu2pUuX3jgcRf+qBgXZMfzz59vRAGvXwogR8MYbpau6Dw624/qPHIG//oJDh4peHEgppWozDfqqxoiPj2fkyJHe90FBbm655Tz69j2h2FX68s+31f2XXWY76T38MFx8MWzZUrrPj4iwW0qKbe8v7aQ+BWshiqqVUEqp6qZBX9UYIsKyZcv89v3yyzKaNxeaNLFT95ZU/R4VBc89B9Om2Tn9ly+HYcPg7bdLV+p3OGwPf7CBPzkZcnKKTp+QkMDSpUu9gV5EWLp0KQkJCSV/mFJKVTEN+qpG8ATLNWvWEB4eznXXXUePHj1Ys2YNy5YtpUEDoU0bO3tfaUrgZ5xhe/VfdJEt9T/4IFx4IWzcWLr8hITYKv/0dFvlH2hsv4iQlZXFmjVrvIHf8x2ysrK0xK+UqnF0Rj5VIxhjCA0NpUePHmRnZ2OMYcCAAQCEhoZijPHO4JeSYkv9UVG2M15RGjSAF1+0C/pMmAArV9qHgXHj4NZbbQ/+koSH22C/dy8cOABNmtiaAGPwy+OaNWtYs8YuCdyjRw8GDBjgN8xQKaVqAi3pqxojLi7OG0QhP6jGxcV59wUH28V6GjWygb+4qnePESNg4UK48kqb/vnnSz+uH2yVf1SULf0nJ/sP8fMN/B4a8JVSNZUGfVWjFAyWgYKnMdC4sS315+aWbox9/frw1FPw0UfQsSNs3gyXXgq33GJrDkrD6bSlfIfDrhfw99+QkSEsWbLEL92SJUu0al8pVSNp0Fe1Vng4tGsHkZFw+LCdlrckffvaHv733GMX3vn4Yxg0CF5/vXS1BmBrG6KjISdHeO21L/nqq9/p1KkH1113Hd27d2fZsmXMnTtXA79SqsaplqBvjLnZGLPFGJNpjEkwxpxaQvoQY8yjeedkGWO2G2P+XVX5VTWX02nn42/RwnbwK00nv9BQuO02W+U/YoQdn//oo7aX//ffl/6zQ0MhO3sfWVlCcnIoycmQnW3IycnhwIED5f5OSilVWao86BtjLgOmAE8AJwFLgC+NMW2KOW0WMAK4HugMXAL8VslZVbVIvXrQvr1tdz98uHTD81q3hrfegnfftTUGf/4Jo0fbtv/S9vLv0qUL4eEONmxYydtvz+TrrzeQmRlD5849j+r7KKVUZaiOkv544B0ReUNE1ovIrUAycFOgxMaYM4DTgbNFZIGIbBWR5SKysOqyrGoDTye/5s1tO39pJ9fxlPAffNBW2//wg903YQLs2VP0ecYY4uPj6d27N1lZWaSl7QVS6dYtntjY/iQnG13JTylVo1Rp0DfGhABxwDcFDn0DDCzitAuAX4DxxpgkY8wmY8x/jTFRlZdTVVsZYzvttWtn2+xL29YfGgo33gg//WRL+yIwfToMHAiTJ0NaWvHnf/DBRXzwwUV51xLq1bMPHdu2eTr86dS+SqnqZ6qys5ExpgWwAxgsIj/67H8IuEJEOgc45ytgCPAd8CgQA7wI/CYiFwdIfz22GYDY2Ni4WbNmVVj+09LSiIrSZ43KVpH32e3O76BXzPT9hWzdGsG0aR1YurQxAPXrZzNq1DbOOSeZkJD8toP09HTS0jLYuzcGEUNUVDrh4VlERYUTEREB2GDvdtvPDwoqWz4qm/5OVw29z1VD77M1dOjQBBGJD3SsNgT9b4BTgWYicihv3xnA13n7dhX1efHx8bJy5coKy//ChQsZMmRIhV1PBVbR9zk3106uc/CgLf2HhJT+3BUr4PHH7cQ+YJsObrvNzu8fFCRcf/1GFiw4DpfLiQiEhrpxuYThwzczderxOBz5Qw6zs+2yv8HBdp4Bzwp/1Ul/p6uG3ueqoffZMsYUGfSrusyxF3ABsQX2xwJFjZZOBnZ4An6e9XmvxXX+Uwqwpetmzey4fhE7qU9pOvqBHeL38cd2Lv+uXe3kPPfdZ4f5jR1r+Pbb48jNDULEAIasLCe5uUF8991xTJ7sP8dASIjtMxAcDLt22el99+61DwNKKVUVqjToi0g2kAAML3BoOLYXfyA/Ay0KtOEfn/e6rWJzqI5lnnH9sbG2o196euna2Y2x0/d+8w289hp06mTb6b/7DnJyAs9knZ0dxGuvCYcOFT7mdNpSfni4ndr3r78gKan0+VFKqfKqjtbF54CxxphrjTFdjTFTgBbAawDGmOnGmOk+6T8A9gHTjDHdjTEnY4f8zROR3VWdeVW7GQMxMXZ4X3S0LfVnZZXuXIcDzjvPBvvLLy9+3n8Ap9Pw2WfFXy8y0g43zM62DxJbtsChQyWvJqiUUuVR5QvuiMhsY0wj4AGgObAGOxzPU2pvUyB9mjFmGLbz3i/AAeBj4L4qy7Q65gQH2xJ//fqwe7ft5R8RYZsCSuJ0QsuW5M24V3Tkz8gQdu8u3Rz8YWF2y821Vf8iNm/169v9OpW/vd++0zIXfK+UKlm1rLInIq8ArxRxbEiAfRuAMyo5W6oOCguzk/Skp9tgm5Fhg39JHeyaNoWICFPsvP8Ohyl13wGPoCBb9S9iZwo8dMg+oDRoYPcHB5fteseKhIQEsrKyvIsZeZYxDg0N9VuQSSlVvBo0eEip6mGMrWZv1872zs/KsuPyiwvY55wDLlfxDfAuFzz3nO3p/803pe886MlTeHh+x7+9e/Pb/o8cKdu1ajsRISsrizVr1rB06VJvwF+zZg1ZWVm6xoFSZVAtJX2laiKHw7avexbw2bvX7g8PLzy2PibGTubzyis55OQULn4HBeXQrVsQf/5p+OknO+lPu3Z24p/LLrMl99JyOm2ewD6QJCXZ/NSvbx8KjvXqf9/li9esWcOaNWsA6NGjhy5jrFQZaUlfqQKcThuUO3Sw4+kzMgKXrsePd3PyyWtxOnMxxg0IwcHZOJ25nHLKWj791M3KlXZ631atYOtWeOwxiI+H22+HVavK3ls/NNQG+ogI2wlx+/b8oX9ZWcdu73/fwO+hAV+pstOgr1QRnE5o2NA/+PtW+wcFOTnrrDWMG/cW9esfpF69wwwevJBx497krLPWEBTkpH59WyOwZIkd6z90KGRmwty5diTA8OHw9tt26F5Z+Fb/h4baiYe2brW9//fvL/kBwF3gCabg+5rGU6Xvy1PVX5MVzF9Nz6869mn1vlIl8AT/+vVttf++fTbwh4a6iYyMJDh4D9dc8w4OhwO3240xhsjIWNxuN468dgGn0471P+MMG5jfew9mz4b1621NwH/+A2efDZdeCiefXLaZ+hwOW/IH249g3z5b8g8Kss0QERH2wcBTKJ4/fz6ZmZmMHDkSsAF/1qxZhIWFcdFFF1XgnasYvm34nip9z3uouSV+386HgHY+VDWClvSVKiVPtX/79na4X06OISsrBLfbRmhPgDfG4HA4igxE7dvbQJ+QYCf7GTzYjtP/6CM7/r9vX3jiCdi0qXx5jIzM7+m/b59d9MfTBHDkiJv09Ey2bt2KZ12KWbNmsXXrVjIzM2tkid8YQ2hoqF8b/oABA+jRowehoaE1MuAX7HwIaOdDVSNoSV+pMnI6bak/KgoaNcpi375wXC4nUVGh5OSklXr8eGioreI/7zw7Mc/cuTBvng3SL79stxNOgAsugH/8A1q0KHs+PR0A3W47/G//fgd9+ozk8OGP2bBhM8Y42Lp1K+3atWPkyJHeB5eaJi4uzu++egJ/TQz4ULjzYcOGDdm/f792PlTVrmb+D1eqFnA6Dd27t6Fbt0hatnQTFCQ4HPWJiWlB69Zty/SHvXVrGD8efv4Z5s+HUaNse/3vv9vOf337wsUX2+V+PaMKysLhsH0AoqIgKsrB8OHnc/hwFC6XkwMH6nHGGZeRk+M4ZjsCVgftfKhqIg36SpWTiJCdnU1aWipxcd24994rGDKkLSL7SUtzkZoq3mV9S8sY6NcPnnkGVq+GN96wbf0hIbB0KUyYACedBJdcAu++a2cTLKvffvuVOXOmExKSjTGCiPDf/37AZ5/9zubNkJJiOyyWNe+VKSEhwa/jnqd9PCEhoZpzVrTa2vlQHdu0el+pcvK0NZ9wwgneEtygQf0JDhaCgoTmzQ3799uhdUFBZR9PHxZmA/7ZZ9sOhF99BZ99Bj/+aEcDLFkC998PcXFw1llw5pm2v0BxXC4Xq1at4sCBAzRo0ICmTZvSoMERDhzYwx9/rCQ+vhvp6U4OH7a9/4OD7dwFns6A1bEUsG/7OODXka9Hjx41cjregp0Ps7OzadGiRY3vfFhb6RTNpadBX6mjUFJbc716doje4cN2WB3YUntISNk+p14927P/0ktt2/zXX8Pnn8PixbBypd0eewyOPx6GDbNDAXv3LryWgNPppGnTpgC8/fZZ1K+/huDgYO8DQHCw02+q39xc+3n79tn3oaE2L2FhVfcQUBsn5ynY+XDRokXe71BTOx/WVjpKomw06Ct1lAr+AS/43rOYTqNGdpKfgwdt6d/hsPvLGjjr189/AEhLg4ULbS3At9/Cxo12e+UVO1xv6FC7DR4MjRvb81u3bk2TJk38rtm9e3fCwsIKfVZQkP+DQ06OnQfA7bY1AaGhtp9ARIR9kCnNgkXl4Qn8noAPNb+0XNs6H9ZGBWuBgBpfC1TdNOgrVUWcTltK9iylm5ZmHwDS022wDA0tPN1vSaKi4Nxz7ZadDStW2OC/YIGdrOejj+xmDPTsCYMHC02bhpCevhyXqyUAR44cITExkd69e5f4RzI4mIA1Afv35zcHREbaLTjYPghUxN9cT+nt2WfPBeDOOz9j6dKlNT6IlvRAqI6OjpIoOw36SlWDkBA74U+DBrb6PzXVBk+3u3zt/55rnnKK3SZNgs2b4Ycf7LZsGfz6K/z6qwG6EBR0HMbAggXpHDjQgJNOSiQ5ObnM36NgTYDLZR9mDh2y742x3yUy0r6WpzZARJg7dy5JSUlERnanXr169OjRg2XLlpGUlMQll1yif9zrMGMM/fv39yvt9+/fX38niqBBX6lq5JlONzzcVr972v8PH7bHnc7yPQAYAx072u266+wUwkuWwKJFwuzZ2aSlhQLwySedAFi8uDexsWns2gUDBkDXruVrr3c67XfxEMlvEnC5bL48wwcjI23tRnBw6R8EPB3ftQe88li5ciUbN270G9kxa9Ysjj/+eOLj46s5dzWPBn2lagjPdLoREdC0af4DQGpqfg1AeZoAwAbZ00+HhASDy5XfizA+PpmVK5sDhl27onn4Ybs/Ohr69LHDB/v0sU0DvsG8tIwp3HHR7bZNEenpNoiL5D8seEYJeB4EjLEluUsuuYSvvlrOzp3C33+n8tprLkaNGsiIEf20RFeHud1uNm7c6J1gqnHjxmRnZ7N161YAevfuXWMnnKouGvSVqoEKPgBkZdlq88OHbTu6w2GDY1mqyg8ehNdeE7Ky8oPkyJEb8oK+53OFFi0MSUnw/fd2A/s5J5xghwf27m23Vq3K117vyXtoaP4+t9vWCHjWNYD8B4bwcJg82fDii/3IyhJEDHPmDGDevCDuusvw6KM1d2lhHUpWuRwOB8cffzwAaWlp7N27l7S0NNq1a8fxxx+vAT8ADfpK1XCe6nBPE4CnlHzokK0FMCa/FqC4ePL553YWweKEhRn+/W/b43/FCli+3A4H/OMPSEy0m0eTJnaioBNPzN8aNiz/dyxYIyBiH3AefRTeflvIzDSAzX92tu1N+NxzQm6u4bHHKm/kQHnpULKqER8fT+/evXnzzTe9+2rylNLVrYb9N1FKFceY/FJygwY2KHo6Aqal2UBpTH7PeV+7d0NGhuAJnIFkZAi7dxtatLBz/l9wgd2fmmoD/sqV9nXVKtizB775xm4erVvbGoEePex2wgm2pqK83/XIEXjzTf/aCV/p6YbnnxcuusgQE2Pvi2eIpKeTYVBQ+ZpEjobvULJx47pz440QElI7hpL5rg4Z6H1NIyIsW7bMb9+yZcu0934RNOgrVYsFBXnm07cBPysrvy+A5yHA6bQPAU2bQni4IT296OuFh5uAQTo6GgYNshvY627dah8A7KgAu07A33/b7Ysv8s9t0gS6dbNb9+62k2CHDqWboMjWThSfxum0cxWMGmUfglJTbVOGb1+/4OD8hyVPs4jTWXkPBL5DyY4cOUJOTg5r1mys8UPJfJdd9iwVXZuWXdaZD0umQV+pY4RneFxYmJ2Yx+WyTQEZGTYQDhkCLlfxJX2XSzj33JL/SBpjp/xt3x48sSA31y4HvGZN/rZ2ra0RWLTIbh5BQXZkQefOdjv+eOjUCdq186+mt7UTxeclI8Om89Rw+M4j4OHpM5CZmT+xkKdWxNPHICQkvxOh05m/lfehYNWqVRw6ZDh4MILcXCfLlnWhdWvDqlWramT1vtvtJjMzky1btjBr1ixGjhzJrFmz2LJlC+3bt6+RJX6d+bDsNOgrdYzy9IgPD7dt7a1awR13GKZMETIyCv8xDA8Xrr/eUL9++T4vKMiW4rt2tQsCgQ2sf/9tg/+6dXb74w+7fPAff9jNV3CwrQU47jj7ULB7N4SEGLKyiv7comonfHn6DATidtsHpCNH8K454Mm7MfY+evobhIQEfigoGFvcbuHBB4UFC+JxuZzk5jqYM6c/s2YZhg//lc8+ExyOmhWQHA4HnTp14sCBA2zZsoUnn3wSESEmJoZOnTrVuIDv4Zn5cOhQw6hRMGSIznxYHA36StURTic88QTs2ZPMjBmx5OTYP4ohITmAk3PO2cNNN8V6FwgKCgpcai4LY6BNG7uddVb+/vR0O13wH3/Y102b7GtSEmzYYLfSys0tXe1EURwOuxX1XX0fCjzDJ315Hgw8/ShCQuCJJ4Rvvz2R3Nz8i2Zn26eOb789kYceEv7zn5oVlESEnJwcgoKCvKV6t9tNUFAQOTk5Nbofgio9DfpK1SnC8OGLadlyJ6++OoagIDfnn7+Qrl3X0LVrC9q3v5ScHENmpu0TkJaWd5bkPwRURC/5iAjo1ctuvo4csTMJ/vmn3TZtguXLJW/Bn8ABJzvbcMop0Latfbho3Tr/tVUraNnSf3hgWZX0UAD2ocDttvlPSoIXXzTk5AQ+IScnmMmThX/9y67H4OlX4HDk1xxUR6HaGEO/fv1ITExERHC5XADk5ubSr1/NnQ/BM0oCdJREaWjQV6oO8fwxDwpKIyoqDafTRe/eCeTk5OB2uwgKEkJCDJGRNiB52sJzcmzbeXp6/oMA2ODkeRioiJgQGWknAurZM3+f2w3XXbeRBQuOw+VyAAaHw42IITIyh5ycEPbvt8sY+w4p9DDGdmJs2dJurVpBixb+W6NGR5d/T1V/cLCd26CkoZEOh2HmzPxmkEB8a1sKjkQItB3t/Xe73cyePZuDBw/yzjtjCQoK4l//ms7BgweZPXt2jRwGJyJs3ryZpKQkDh/uDtgFd5YtW0arVq3o3bt3jX1YgeqZx0GDvlJ1iMPhID09nbCwsLxpS4Xc3FzCwsJIT08v9EfddyKdqCi7zzO1rqdjXEaG3TzT7Ho6x3mC1NH+DXM4DLfemkG3bu/y9tsX4nI56ddvOSeeuJ3TTounZ89e7NkD27fbvgLbttnStmckwc6dsGuX3VatCvwZISHQrJn/Fhub/9q0qX2NjCz5+5RmaGRmpnDwoPHe04JE7MOO2+3f+bBg04L/fcqvLfB9SCj4oOD59/H92b462L17N5mZ4Rw5Ug+Xy8GaNQNo3z6B3bt317iA79GyZUs2btxDUpKLjAw3L7xwhJ49Q2nZsmV1Z61YvvM4GGOqrIZCg75SdYjb7SYiIoKdO3cCkhdI3GRkZNCyZctS9dD2nVo3MjJ/f26ufRDIzc1/EPBMtevhKRGXZaicy+UiMTEROEhUVDohIUH07r2e3NxcEhMTOeGEE4iNdRIba6cMLig3F1JSYMcO+zCQlGQfBHbuhORk+3rokH1o2L69+LyEh9vg36SJ3Ro3LvzqGUVR3KiD8PDi5y/w9BMoy/oHnocCz0NZVpb/Pt90gR9cXMybN4hly3ridjsQMcydOxCXayCnnJLI2LEugoOd3ocE3wcG3/dVy/DVVwN5+un+5OQYcnMdfPzxKfzvf6eRleVg4MCaWcovuCTwgAEDqmxJYA36StUhxhjatGnDX3/9xdix79K48fHs3y84nU7atGlzVH9ofFfci462ryK2BsDzMJCZmb/5llqLqx1wOBzeDmb169cjOjqagQMHsmTJEnJyckp8SAkKslX6rVrZtQQCSU+3DwbJyfZ11y7/1z177M8ZGXZ+gryp3Yvhfx9ff72n3/vsbPsdFy60kyw1aGCHWUZHl79mxPOgUB4i8PTTDn75pScuV35Y8Mx8uGRJbyZOdHD77SVfy7dWwbePgu8+31EPZd18PfQQPPccZGfnf/GcHNth8rnn7JPOY4+V755UJmMMISEhREVFsWbNGm/wj4qKIiQkpFKr+DXoK1XH7Ny5k/DwcNLT0zHG4HA4CA8Pzyv9VyzPFMEFHwbAPgy4XPk1BFlZdsvIKFiNbejVawC5uVksWhSNiPGunlZRY7EjIuxQwQ4dik4jYvsz7NplHwL27IG9e/NfPdu+fbb2ICcn/9xNm/znJ87NNdx9d+HPcDqhfn27xcTk/1y/PtSrl//q2aKj/V/Dw8v30HDoELz+uiE7O3BIyMkJ4u234dZbKXFIp2cOBE/zhMuVv6/gVh6eh4fDh+GZZ4qfrXHyZOGaawwNGvj3eyj4EBHo56KO+b6Wl4iQnZ1NamoqR44cISoqirS0NO9+LekrpSqEMYb27dvntd1mArYkHRoaSvv27au005OnxBdo/LzbbR8GPA8FjRqdQFaWMGuWIScHjhwxdOkSjzGGtLTApciKZowNrtHRdg6B4uTmuhg5cjXLl5+I2+3guut+5+23u+N2G1q12sXgwc04fNjBgQN4t0OH7EPF/v12Kw+nMz+PnpkafX+OjLSb78+RkVBgFtsir/3ZZ3DFFcWnq+yqfs8Dw9dfl/wZxsD778Ollxaef8H3euVdOMr31fc7+74WrKmwxwydOvXnt992sH9/GmlpBwgKchEbG0v//v21pK+Uqhhut5tNmzZx6NAh2rdvT7NmzXC73WzZsoVNmzYRFxdXIzpsBZpMx/ePs+dhwFOSzMmxVeaeLTe38LlFVTtXBqfTwT33uPj++zeYMeMyunbdy9Ch39O162ZOOy2OPn2aBww0OTk2+B88aLdDh/y31FRbwj140P7see/5OTMz/9yKlp4uPP20HXXgmfTJdwsLK/xa1OY7JbLv+9L8e3iC59695C3CVLTMTMPBg/59TyqK70OE78+Q34/CU8tROL0wc+Ysdu/OZOPG/jgc4URF7SUray1vvPEG119/vZb0lVJHz+FwEBYWRvv27Rk5ciQ//vijd7rVsLCwGhHwAynY09nhEBISiu7p7Kle9jQheDbPA0HBh4OCpb2CvdzLOizOGEOfvF6F8+cfwel007Pn75x66qn06dOnyD/owcG2M2DjxmW6PV7Z2ba2wPMQ4JlQyPOalmZ/9rx6hmD+9Rds2SK43cV9QeNtwqgsngmOfKdF9p0N0ff9rl323yRvOgEAPv30OL/rBQXZuR5mzMifotmzBQXZ6/gOiyzqteAWHOxfwi8rl0tYsKAzS5ac6O00GRycw8cfD2XIkJVce62UOOyzvDToK1XHXHTRRX699B0OR40cg+1Rnp7Ope397vtw4NsGnZvrv3k6IgZqh/Z8dMEHBbfbze+/r+WyyxbTsGErtm2DtWvXEhcXh7O8Pe5KEBJip1wu6xLHBw9C794UO91xSIgwe7bB6bQPC54RGr7DNj2dNH33+3be9PTb8LzPzvbf5xkKeuRI+b7/okWt/d7n5MD//me3iubbX8V3ASffn31ffUetpKQYkpN7I5L/e+vpgPjjj32YNAn+85+KzzNUU9A3xtwM3A00B9YCt4vI4iLSDgF+CHCoq4j8EWC/UqoEhcfj18yAD/4r1vn2dK6IFevKOjTO82BQcBPxf0jIynIxffoM9u8/jDHhOJ0h5OaGkZKSytSpHzBq1Ci/wF+wPbjgcLjK/ueJiYEbbzS8+mpuwM58ISG53HRTEH37Vl4eRPybaDwPCZ73vj97On5+9JHw3XdCbq69Qeecs5nPP7elfVu7YujVy3hrdTwPFZ7mIM/DXHGvvqNPfB8CfeerKLuif2ezs4N49lm46y7771LRqjzoG2MuA6YANwM/5b1+aYzpJiLFjZLtDvh2b9lTeblUStUknsDvCfhQPcumlrYfgIiDevUO4HQeYciQIeTm5nLRRU1YuPBHIiKgXTtHoV7unj4Kvq+eNmHfPgql6XhWnmFwd97pZsOGP/n22464XPlVziIOTjvtT+6883ig8p4+jMlv2y+tc8813HXXbubNa4zLZRg69G+++aY1Ik4uvngvkyfHVshMkYF4Zqv07XDqeUDw/Pt5Nt8mpi++gLfeKr5WxemEuXPhuusqPt/VUdIfD7wjIm/kvb/VGDMCuAmYUMx5u0WkEluTlFI1lWe2Ml9Lly6tsaupGWMYNGgQGRkZnHzyySxatIhBg07OW/kwnPDwsufZ9yHBd9hbwfeeDmS+TRYFN8/DhOe95eC55zoxbdqHTJ06HLfbQXx8AvHxe7j66ovJyAgc8Isb0lbSsLiCP5edcOmlW2nSZD4zZlyGw+Fi8OCFdO26maFDewNNKa5UfTR8Z6ssi4ULITu7+Bkb09OFlJRjoE3fGBMCxAGTCxz6BhhYwukrjTGhwDrgPyISqMpfKXWM8QR8Txu+b5s+VE+JvzQ8S7568maM4eSTTy53Xiuzqt8+AAhLliynfftD3H77KxjjwO0WmjZtSkrKCvr16w+YQr3VfZs4inpf3ANKUdMLl6ZGw+Vyk5i4EZFcIiJsh8kuXTYgAqtXb6JLl3gcDmeh6/i+L+rnsqQt7hoFjzVpUvKMjRERdgroymCkvDMklOfDjGkB7AAGi8iPPvsfAq4Qkc4BzukMDAV+AUKA0cCNedco1A/AGHM9cD1AbGxs3KxZsyos/2lpaUQVNVm2qjB6n6tObbnX6enpiAiRPmOvjhw5gjGGiIiIasxZ6dSm+3zkyBHvCnsATqeTyMjIar/PRYWq3bt343K52bevEc2aZeJyZXg7qjYtYq7j4sJeUcdKEypLk8blgvXri09rDJx4YvlnWBw6dGiCiMQHOlbje++LyAbAd3XtpcaYdtiOgIWCvohMBaYCxMfHy5AhQyosLwsXLqQir6cC0/tcdWrTva6OFckqSm24z263m9dff509e/bQsWNH71DOjRs30qRJE2644YYa2eFz5cqVrF+/nhdf7M5tt60lKGgnERERHH98V+/MjTXNkiXC5MluMjMLR/WwMBd33eXg9NMrqVmiUq5atL2AC4gtsD8WSCnDdZYDnSoqU0qpmq/wsLzaEfBrC8+UzCEhId51GNq0aUNISAgOh6NG3m/PtLXp6em8885WuncP5oQTTiA9Pd07nW1N9MgjcNZZfxAUlIMxbkAIDs4mKCiHs876g0ceqbzPrtKSvohkG2MSgOHAXJ9Dw4EPy3CpXkByBWZNKaXqNGMM119/PT///DPr1q1j3bp1AJxyyilH1RehMhljCA0N5YQTTmDAgAEsWrTIO7yzotZlqBzCsGGL6Nz5c9au7Up6ej0iIg7Tvfs6WreOBrpSWR0Qq6N6/zlghjFmBfAztn2+BfAagDFmOoCIXJX3/nZgK3Y8fwhwJXAB8M+qzbZSSh3bPJ0NPQEfqLEB3yNQh8ma2rnTwxhDw4YN2b9/P336rMbpdOJyubz7j6m590VktjGmEfAAdnKeNcDZIrItL0mbAqeEAM8ArYAMbPA/R0S+qKIsK6VUnVDbhkbWZp7VLY0xfqvsVXa/iWrpyCcirwCvFHFsSIH3TwNPV0G2lFKqzqqtQyN912WA/O9R1LoMNYExhg4dOpCbm0taWhoAUVFRREVF0aFDh2OrpK+UUqrm8bSP+05vXNPbxwuuywCUuC5DTeDpgJiWllboAcvTAVFX2VNKKVWpalv7eMF1GTzt5BWxLkNlqs4HLA36SimlvGrb0Miasi5DWVXXA1bNm2lBKaWUKqWiOh/W1DH6vqrjAUtL+koppWqlgp0Ps7OzadGiRY3vfFidtKSvlFKqVirYNg420Pfo0aPGdj6sblrSV0opVWvVts6H1U1L+koppWq12tb5sDpp0FdKKaXqCA36SimlVB2hQV8ppZSqIzToK6WUUnWEBn2llFKqjtCgr5RSStURGvSVUkqpOkKDvlJKKVVHaNBXSiml6ggN+koppVQdoUFfKaWUqiM06CullFJ1hAZ9pZRSqo7QoK+UUkrVERr0lVJKqTpCg75SSilVR2jQV0oppeoIIyLVnYdKY4zZA2yrwEs2BvZW4PVUYHqfq47e66qh97lq6H222opIk0AHjumgX9GMMStFJL6683Gs0/tcdfReVw29z1VD73PJtHpfKaWUqiM06CullFJ1hAb9spla3RmoI/Q+Vx2911VD73PV0PtcAm3TV0oppeoILekrpZRSdYQGfaWUUqqO0KBfSsaYm40xW4wxmcaYBGPMqdWdp9rCGDPBGPOLMeawMWaPMeZTY0yPAmmMMeZhY8xOY0yGMWahMaZ7gTQNjDEzjDGH8rYZxpiYKv0ytUjefRdjzEs++/Q+VxBjTHNjzLt5v9OZxph1xpjBPsf1Xh8lY4zTGPOYz9/eLcaY/xhjgnzS6H0uAw36pWCMuQyYAjwBnAQsAb40xrSp1ozVHkOAV4CBwGlALvCtMaahT5p7gDuBW4E+wG5ggTEm2ifNB0BvYETe1huYUdmZr42MMf2B64HfChzS+1wB8gLGz4ABzgG6Yu/pbp9keq+P3r3ALcC/gS7AbXnvJ/ik0ftcFiKiWwkbsBx4o8C+TcD/VXfeauMGRAEu4Ly89wZIBu73SRMOpAI35L3vCghwsk+aU/L2da7u71STNqA+sBkYCiwEXtL7XOH3+Ang52KO672umPv8GfBugX3vAp/pfS7fpiX9EhhjQoA44JsCh77BllxV2UVja5kO5L1vDzTD5x6LSAbwI/n3eACQhq1l8fgZOIL+OxQ0FZgnIj8U2K/3ueJcACw3xsw2xuw2xqw2xowzxpi843qvK8ZPwFBjTBcAY0w3bG3hF3nH9T6XUVDJSeq8xoAT2FVg/y5gWNVn55gwBVgNLM173yzvNdA9bumTZo/kPaYDiIgYY3b7nF/nGWOuAzoCVwY4rPe54nQAbgaeB54EegEv5h17Cb3XFeUpbCFhnTHGhY1Zj4vIK3nH9T6XkQZ9VaWMMc9hq9ZOERFXdefnWGKM6Yytdj5FRHKqOz/HOAewUkQ8bcuJxphO2Pbml4o+TZXRZcBVwChgLfbhaooxZouIvFWdGauttHq/ZHux7c+xBfbHAilVn53ayxjzPHA5cJqI/OVzyHMfi7vHKUATn+pT8n5uiv47eAzA1kytNcbkGmNygcHAzXk/78tLp/f56CUD6wrsWw94Ovfq73TFeAaYLCKzROR3EZkBPEd+Rz69z2WkQb8EIpINJADDCxwajn8bkSqGMWYK+QH/jwKHt2D/8w33SR8GnEr+PV6K7QA4wOe8AUAk+u/g8TFwArY05NlWArPyft6I3ueK8jPQucC+48lfylt/pytGBLbQ5ctFfuzS+1xW1d2TsDZs2CqmbOBabE/QKdiOIW2rO2+1YQNeBg5jO+A089mifNLcCxwCLgJ6YAPVTiDaJ82XwO/Y/7AD8n7+tLq/X03e8Om9r/e5Qu9rHyAHuB/bh+KSvPt6i97rCr3P7wBJ2GGR7YALgT3As3qfy3lPqzsDtWXDdtrZCmRhS/6DqjtPtWXDDo0JtD3sk8YAD2OrTTOBRUCPAtdpALyX9wBxOO/nmOr+fjV5CxD09T5X3L09B/g17z5uxI4lN3qvK/QeRwMvYGtQMoC/sP1WwvQ+l2/TBXeUUkqpOkLb9JVSSqk6QoO+UkopVUdo0FdKKaXqCA36SimlVB2hQV8ppZSqIzToK6WUUnWEBn2lqoExZoAxZo4xZqcxJtsYs88Ys8AYM8YY48xLM9YYI8aYdj7nbTXGvFPgWucZY343xmTmpY8xxjiMMS8YY5KNMW5jzMeV+F3a5X3u2BLSeb5Px8rKS3kZYy4wxowPsH9IXp51cS11TNAFd5SqYsaY27Hzh3+PnU1sG3bykDOAV4GDwP+KOP1C7OQinmsFAe9jpxO9BTtzZCpwMXAbcCd2GtJ9ha6kfF2AXTXzuWrOh1KVSoO+UlXIGDMIG1heEpF/Fzj8v7xVCCOLOl9EEgvsaomdtWyOiPzo8zld8358QUTcFZDvUBHJOtrrKKWql1bvK1W17gX2A/cEOigim0Xkt6JO9q3eN8Y8jJ0aGuCtvGrohcaYrdhpSQFcvlXvxpjmxpjpxpi9xpgsY8xvxpgrC3yGpxp+kDFmrjHmILA871iEMeaVvOaINGPMJ0CrctyHIhljrjfG/JrXXLHXGPOWMaZhgTRijPmPMebfxpgtxphUY8wiY0z3AumceemSjTHpxpjvjTFd8s5/OC/NO8AYoGXefsm7h74ijDEv5eVnrzHmPWNMTEV+b6Wqgpb0laoieW31Q4GPRSSzAi75JrAGmAv8B/gcW/Ufip0Hfiz5K4ttNsZEYuclbwBMBP4GrgRmGGMiRGRqgeu/D8zENhV4/la8jl2A6hHgF+zqZh9UwHcBwBjzJLZJ4r/A3diajP8APYwxA0XEd8W1K4EN2GaMEOwyrP8zxnQRkdy8NI/kfddngG+BOOCTAh/7GNAEu4jOP/L2FazVmAJ8hl3XvTPwNHa1tzFH832Vqmoa9JWqOo2BcPKXXz0qIpJkjFmd93aziCzzHDPG7MhL47tvHNAJGCoiC/N2f2mMiQX+Y4x5q0BQnSci9/ic3xkb9O4XkSfzdn9jjIkCbjza75PXYfFu4BERedRn/0bgJ+A87PLBHjnAuSKSk5cO7ANQX2CJMaYBcDvwmojcm3fOAmNMNvCs5yIistkYswfI9r1fBfwoIrfm/fxN3r241hgzVnQBE1WLaPW+UnXHIGCHT8D3eA9b0u1WYP9HBd73w/7NmFNg/6wKyt/wvOu/b4wJ8mzYpoVUbP59LfAE/Dy/5722yXs9Ads/Ym6B8+aVI2+fF3j/O7ZGJbYc11Kq2mhJX6mqsw+7PGjbavr8htjlRwtK8Tnuq2Da5nmvuwrsL/i+vJrmvf5ZxPFGBd7vL/DeUyUflvfqye/uAunKk9+SPkupWkGDvlJVRERyjTELgeHV1Bt+P7Y9uqBmPsd9Fay29jwExGLXNcfnfUXwDCs8AzhQzPHS8uS3KbDWZ7+WzlWdpdX7SlWtJ7El1qcDHTTGtDfG9Kykz14EtDLGnFxg/yhsaXhdCecvB9zApQX2j6yY7LEg7/ptRGRlgG1LGa/3O3AEuKTA/oLvwZbcw8ueZaVqFy3pK1WFROTHvJnfnjPGdAPeAbZje9SfDlyLDcJFDts7Cu9ge7rPN8bcDyQBV2Db0m8o0IkvUN43GGM+AB41xjiwvffPAM4uYz5GGGNSCuw7JCILjDFPAS/ldZRbBGQCrfPy+KaI/FDaDxGRA8aYF4CJxphUbO/93sA1eUl85y9YBzQ0xtwErAQyReR3lDrGaNBXqoqJyAvGmBXAHcBkbK/+VGywuQH4tJI+94gxZjC2luFJ7KQ+G4DRIvJeKS9zA5AG3IUdJvc99iHlpzJk5cUA+9YCPURkojFmPXZ2wVuwTQx/A98Bm8rwGR6TAIMN9P/G1laMBX4GDvmkexPoDzwBxGBHWLQrx+cpVaMZHW2ilKpLjDEXY3v0DxKRxdWdH6WqkgZ9pdQxyxjTDzgHW8LPxE7Ocx+2hmOgjrFXdY1W7yuljmVp2PH9twD1sB0W5wATNOCrukhL+koppVQdoUP2lFJKqTpCg75SSilVR2jQV0oppeoIDfpKKaVUHaFBXymllKojNOgrpZRSdcT/A4bbDf2rZlSFAAAAAElFTkSuQmCC" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Analysis Result: StandardRB\n", @@ -560,18 +555,18 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Analysis Result: StandardRB\n", @@ -588,18 +583,18 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAFGCAYAAABgwUY+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABlnElEQVR4nO3dd3hUVfrA8e+ZSZkUCD2hF0WKWVCKFBUBARUbP1eFFWkqiCvuIpYFbFhXAdtiQXDFteKCsoqKikqVJghKUSmCiCZAqElInXl/f9zMMDOZVCaTCXk/zzNPZu49986ZwzDvPeeeYkQEpZRSSp3+bJWdAaWUUkqFhgZ9pZRSqprQoK+UUkpVExr0lVJKqWpCg75SSilVTWjQV0oppaqJiMrOQEWqV6+etGjRImjny8zMJC4uLmjnU4FpOYeOlnVoaDmHhpazZcOGDWkiUj/QvtM66Ldo0YL169cH7XxLly6ld+/eQTufCkzLOXS0rENDyzk0tJwtxphfi9qnzftKKaVUNaFBXymllKomNOgrpZRS1YQGfaWUUqqa0KCvlFJKVRMa9JVSSqlqQoO+UkopVU2EfJy+MaYXcDfQGWgEjBKR10s45k/AC8B5wGHgFeBREZGKza1S5XPllVeSkpJS2dkoUXZ2Ng6Ho7KzcdrTcq44DRs2ZOHChZWdjSqjMibniQe2AG8UPIpljKkJLAaWA12BtsAcIBN4uuKyqVT5paSkBHViqIqSnp5OjRo1Kjsbpz0t54rTpUuXys5ClRLyoC8inwKfAhhjXi/FIUOBWGCEiGQBW4wxbYEJxphntLavlFJKlU5VuKffA1hREPDdPse6NdCiUnKklFJKVUFVYe79JGCf37b9Xvt2e+8wxowBxgAkJiaydOnSoGUkIyMjqOdTgZ0O5ZydnU16enplZ6NETqezSuSzqtNyrjjZ2dme34vT4bejolWFoF8mIjILmAXQpUsXCebiC7qYQ2icDuXscDiqxD1cvdccGlrOFcfhcHh+L06H346KVhWa91OBRL9tiV77lFIV4KuvvqJnz57UqFGDpKQk/vGPf5Cfn1/icdu3b+eaa66hVq1axMbG0qlTJ3788UfP/l27dvF///d/1K9fn5o1a3L99dezf/9+n3McOXKEYcOGkZCQQEJCAsOGDePo0aOn/JlEhClTptCoUSNiYmLo3bs3W7du9Unz+OOPc/755xMXF4cx5pTfM5DU1FSGDRtGUlISsbGxdOzYkbfffrvYY15//XWMMYUe2dnZAdP/85//xBjDuHHjfLZ/8MEHXHLJJdSvXx9jTFBrxsuWLaNz5844HA5atWrFzJkzffa/+OKLdOjQgZo1a1KzZk169OjBJ598ErT3VyWrCkF/NXChMcZ7vEt/4A9gT6XkSKnT3Pfff8/AgQPp378/Gzdu5L333uOjjz5i4sSJxR63e/duzj//fFq2bMnXX3/Nli1beOyxx4iPjwes9c4HDBiAiPD111/zzTffkJuby5VXXonL5fKc54YbbuC7777js88+47PPPuO7775j2LBhp/y5pk6dytNPP82MGTP49ttvadCgAf379/dpes/JyeGaa65h/PjxpTrnnj17ynxxMHz4cH788Uc+/PBDtmzZwvDhwxk2bBjLly8v9rjY2FhSUlJ8HoGGAq5Zs4ZZs2bRoUOHQvsyMzPp2bMnzzzzTJnyXJLdu3czcOBAevbsycaNG5k0aRJ33HEH77//vidNkyZNeOqpp/juu+9Yv349ffv2ZdCgQfzwww9BzYsqhoiE9IE1ZO+cgscJ4MGC580K9v8T+MorfQJWjX4ukAxcAxwH7irpvTp37izBtGTJkqCeTwV2OpRzeb97GRkZMnr0aKlZs6bUrVtXJk+eLOnp6RIbGyt79uwJci5Fjh8/HnD7pEmT5JxzzvHZ9tFHH4nD4SjyGBGRv/zlL3LDDTcUuf/zzz8XY4wcPnzYs+3o0aNijJHFixeLiMi2bdsEkJUrV3rSrFixQgD56aefPNu++eYb6dWrl8TExEijRo1k7NixcuzYsSLf2+VySVJSkjz22GOebSdOnJD4+HiZOXNmofTz5s0T6yeyeLt37y4xnX+ZxcXFyWuvveazrVmzZjJt2rQizzFnzhyJi4srMT9Hjx6VVq1ayddffy0XXXSR3H777QHTHTx4UICA/9+OHj0qo0ePlvr160t8fLz06tVLvv3222Lf995775UzzzzTZ9vNN98s3bt3L/a42rVrByz/0vL+v3Y6/HYEA7BeioiLlVHT7wJsLHjEAA8XPH+kYH9D4Ax3YhE5hlWzbwSsB17EGp8f3MtUpcLATTfdxNdff82XX37Ju+++y/PPP8+4ceNo27YtzZs3L/K4yy67jPj4+GIfZZGTk1OoBhkTE0N2djYbNmwIeIzL5WLhwoW0b9+eSy+9lPr169O1a1fee+89n/MaY3zO7XA4sNlsrFy5EoDVq1cTHx9Pz549PWncze2rVq0CYPPmzQwYMICrrrqK77//ng8++IBNmzZx0003FfmZdu/eTWpqKgMGDPD5TL169fKcN1QuuOAC/vvf/3Lo0CFcLhcffvghBw8epF+/fsUel5WVRfPmzWnSpAlXXHEFGzduLJRmzJgxXHvttfTp06dceRMRLr/8cn7//Xc+/vhjNm7cSK9evejbt2+xE06tXr3ap2wBLrnkEtavX09eXl6h9E6nk7lz55KRkeHzb60qVmWM018KFNkWJiIjA2zbDPSquFyVzOl0ApCZCXFx1mu73V6ZWVKnmbS0NObNm8d//vMfunbtCsD111/PnDlzePTRR4s99tVXXyUrK6vYNGVxySWX8Oyzz/LWW28xZMgQ9u/fzyOPWNflRf3wHzhwgIyMDJ544gkeffRRnnzySb7++muGDh1KfHw8l19+Od27dyc+Pp577rmHp556CoCJEyfidDo9501NTfXcb3YzxtCgQQNSU61uPNOmTWPw4MHcddddnjQvv/wy5557LgcOHKBBgwaF8uc+NjHRt4tQYmIiv//+e5nKx/siSgqmCvHeduGFF7Jo0aIij//vf//LkCFDqFevHhEREURHR/Puu+9yzjnnFHlMmzZteO211+jYsSPp6ek8//zznH/++Xz//fe0bt0agNmzZ7Nz507eeuutMn0eb0uWLGHTpk0cPHiQmJgYAB599FEWLlzIm2++yb333hvwuNTU1EIXLYmJieTn55OWlkbDhg0B64KtR48eZGdnEx8fz4IFC/jTn/5U7vyqsjnteu9XhFdffZWcnBzatTubjAxwOJzMnDmT6OhobrnllsrOnjpN7Ny5ExGhR48enm3dunVjzpw5XHPNNcUe27hx46DmZcCAAUyfPp3bb7+dkSNHEh0dzQMPPMCKFSuw2QI3ELrvyV999dVMmDABgHPOOYf169fzwgsvcPnll1O/fn3mzZvHbbfdxksvvYTNZuMvf/kLnTp1KvK8gWzYsIGdO3f6tCK4g++uXbtYvHgxt956q2ffokWLgnqRvmnTJs/z33//nd69e/tscwfLotx///2kpaXx5ZdfUq9ePf73v/8xfPhwli9fTseOHQMe06NHD5/vRs+ePTnnnHOYMWMG//rXv/j555+ZPHkyK1euJDIystyfbcOGDZw4cYL69ev7bM/OzmbXrl2A7wXOjTfeWKjDXnHatGnDpk2bOHbsGPPnz2fEiBEsXbqU5OTkcudZlZ4G/RI4nU5ycnI4dOgQaWkHycqyAv6hQ4eoW7eu1vhV0ERHRwMQFRXl2ZaYmEjt2rVp3759scdedtllrFixotg0GRkZZcrPhAkTuPPOO0lJSaF27drs2bOHSZMm0apVq4Dp3bVW/7y2a9eOuXPnel4PGDCAXbt2kZaWRkREBLVq1SIpKclz3qSkJA4ePIiIeGr7IsKBAwdISkoCrAuMW265hTvvvLNQPho3bkxycjLdunXz2eZuSdi/fz/NmjXz7Nu/f7/nvKV15plnep5HREQU2lacXbt2MWPGDDZt2uQJ8B07dmTFihXMmDGDV199tVTnsdvtdOnShR07dgBW83paWhpnn322J43T6WT58uXMnDmTzMxMz3esOC6Xi8TExIDfp5o1awK+Fz3ubUlJSYVGYezfv5+IiAjq1avn2RYVFeUpq86dO/Ptt9/y7LPP8u9//7tUn1udGg36JbDb7YwdO5ZnnpnD8eNR3HDDOurVa8aFF0YzduwoDfgqaFq2bInNZmPHjh2eoPTRRx9x5MgRjh07RkJCQpHHBrt5380YQ6NGjQB49913adq0KZ06dQqYNioqiq5du/Lzzz/7bN++fXvA/gjuQPD1119z4MABrrrqKsCq0WZkZLB69WrPvd7Vq1d7ep0DdOrUia1btxYbaP3Hxbds2ZKkpCQWL17suX2SnZ3NihUrmDZtWollESwnTpwAKPTbYbfbfUYwlERE+OGHHzwXDoMGDSo0D/2oUaNo3bo1kydP9rmYLE6nTp3Yv38/NputyAu8QOXeo0cPFixY4LNt8eLFdOnSpdiWB5fLRU5OTqnypoKgqB5+p8MjGL33XS6Ra6/dJpGRefL0018LuCQyMkciI/Pk2mu3ict1ym+h/JwOPXDL+9279tprpW/fvpKZmSk//fST1KhRQxo1aiRvvvlmkHNoKa4n/tSpU+WHH36QLVu2yCOPPCKRkZGyYMECz/59+/ZJmzZt5IMPPvBsW7BggURGRsorr7wiO3bskFmzZklERIR8/PHHnjSvvfaarFq1Snbu3Clvvvmm1KlTRyZMmODz3pdeeqkkJyfLqlWrZNWqVZKcnCxXXHGFZ//3338vMTExcuutt8p3330nO3bskIULF8qYMWOK/bxPPvmk1KxZU95//33ZvHmzDB48WBo2bOhTDr/++qts3LhRpk2bJoBs3LhRNm7cKOnp6Z40KSkpxT4OHTpUZDnn5ubKmWeeKRdeeKGsXbtWdu7cKdOnTxdjjHz00UeedH379pWJEyd6Xk+ZMkU+++wz2bVrl2zcuFFGjRolERERsnbt2iI/b6De+4cOHZKNGzfKkiVLBJDZs2fLxo0bJSUlRUSsUQ4XXHCBJCcny6effiq//PKLrFq1Sh588EFZvnx5ke/1yy+/SGxsrPz973+Xbdu2yezZsyUyMlLmz5/vSfOPf/xDli9fLrt375YffvhBJk6cKMYY+fTTT4s8b0m0935hFNN7v9IDc0U+ghH077vPKVFRuQIi06cvERDPIyoqV+67z3nK76F8nQ7/ccv73du/f78MGjRI6tSpI3Xq1JGnn35aPv30U2nUqJE89NBDwc2kFB/0+/TpIwkJCeJwOKRbt26FfpjdQ9XmzJnjs33OnDnSunVrcTgc8qc//Uneeecdn/3/+Mc/JDExUSIjI6V169by9NNPi8vv6vnw4cMydOhQqVGjhtSoUUOGDh0qR44c8Unz7bffyiWXXCI1atSQ2NhYSU5OlgceeKDYz+tyueShhx6SpKQkiY6Oll69esnmzZt90owYMUKAQg/v72Wg/d6Piy66yOec/uW8fft2ueaaa6RBgwYSGxsrHTp0kNdff90nTfPmzWXEiBGe1+PHj5dmzZpJVFSU1K9fXwYMGCCrVq0q9vMGCvpz5swJmGfv79fx48flb3/7mzRu3FgiIyOlSZMmMnjwYNm5c2ex77d06VI599xzJSoqSlq0aCEvv/yyz/4RI0b4fIaLL75YPvvss2LPWRIN+oUVF/SNtf/01KVLFzmV5U2PHIFGjYTsbOu+4pgx3zNrlm8nG4dDSEkx1Kp1KjlV3k6HqTS7dOmiS+sqDy3niuP9f+10+O0IBmPMBhEJuOZwVZiRr9LMnw92+8lhQ/4BH6z98+aFMldKKaVU+WjQL0ZqKpw4UXxLyIkTQqquAKCUUqoK0KBfjKQkiI0tPk1srJVOKaWUCnca9Itx7bVQMBFfkZxOuO660ORHKaWUOhUa9ItRuzbcfbfB4bAif1SU7xWAw+Hk7ru1E59SSqmqQYN+CR5+WBg8+HciIvKIj88FwG7PJSIij8GDf+fhh0/f0Q8quEaOHBlwPfTu3bt70rRo0cKzPTY2luTkZGbNmuVzntzcXKZNm8a5555LbGwsderUoXv37rzyyishneQkJSWFG264gbZt22K32xk5cmSpjvP+jO6H/5K9gcrJe6rX7OxsRo4cSYcOHYiMjAxqj+2cnBzuuOMO6tWrR1xcHFdddRX79u3z7P/+++/5y1/+QtOmTYmJiaFNmzZMnTq1TBPrlEV2djYdO3bEGFOmESH//Oc/McYwbtw4n+0iwpQpU2jUqBExMTH07t2brVu3evYvXbo0YPkbY5gXhF7L77//Pu3btyc6Opr27dsXmtDngQceoG3btsTFxVG7dm0uvvjikC+IdDrToF8CY+DSS1dx773PU7NmNgAdO27m7ruf59JLV1HGZbRVNdevX79C66F/+umnPmkefPBBUlJS+OGHHxg0aBC33nqrZ4753NxcLrnkEh5//HFGjRrFN998w4YNG5gwYQJz5sxh9erVIfssOTk51KtXj4kTJ/pMeVsa7s/oftx///2F0syePdsnzYgRIzz7nE4nDoeDcePGcfnll5/yZ/E2fvx43n//fd59911WrFjB8ePHueKKKzyLbm3YsIH69evz5ptvsnXrVh5++GHPAkNFWbFiBS1atChXfu6++26aNGlSpmPWrFnDrFmz6NChQ6F9U6dO5emnn2bGjBl8++23NGjQgP79+5Oeng5Yc/r7f0cnTZpEfHw8l112Wbk+g9vq1asZPHgwQ4cOZdOmTQwdOpTrrruOtWvXetK0adOGF198kc2bN7Ny5UpatmzJpZdeWmiKX1VORQ3gPx0ewZicx+l0yksvvSSPPPKIdOqUIiAyatQaeeihx+Sll14Sp1Mn5wm202GCjUDfvREjRsjll19e7HHNmzcvtKZ669atZciQISIi8tRTT4kxJuDa5k6ns9j15AMpbnKesrj88st9JpIpTqDP6A+QefPmlep8t99+e6HJcNw++ugj6dSpk0RHR0uLFi1k8uTJkpOTU+S5jh49KpGRkfLWW295tu3du1eMMcVOInPPPfdIp06ditz/ySefSPPmzUv8LP7+97//Sfv27WXbtm0ClLimvYj1GVq1aiVff/11ocl5XC6XJCUlyWOPPebZduLECYmPjy92TfvWrVvL6NGjfbbt27dPBg8eLLVq1ZJatWrJwIEDZfv27cXm7frrr5d+/fr5bLv44os93+9Ajh07JkCR5a+T8xRGMZPzaE2/BDabjcTERM444wzci061atWVFi3OIDExsUwrgylVHg6Hw7Me+dtvv02/fv0KzbEO1nfVvfhJIPHx8YUeDRs29Dw/1VpcWUyfPp26detyzjnn8Pjjj5Obm1sozd///nfq1atH165dmTlzZpmbzz///HOGDh3KuHHj2Lp1K6+99hrz589n8uTJRR6zYcMG8vLyfNaFb9q0Ke3atSu2ifn48ePUrl27TPkryb59+7jtttt45513Sly1z9uYMWO49tpr6dOnT6F9u3fvJjU11efzxcTE0KtXryI/39KlS9mxYwdjxozxbDtx4gR9+vTB4XCwbNkyVq9eTcOGDenXr59nbYFAVq9e7fPeYC3jXNR75+bmMmvWLGrWrFnsssOq9HTBnVK45pprcLlcfPihdV/v6FEbf//79dSooQFflc1nn33msywpwO233+5ZW95bfn4+b731Fps3b+a2224DYMeOHeW+f+29MppbRkaGJz9lCSyn4m9/+xvnnnsudevWZd26dUycOJHdu3f7rC73yCOP0KdPH+Lj4/nqq6+46667SEtLC3gboCiPP/4499xzD6NGjQLgjDPO4KmnnuLGG29k2rRpnhX8vKWmpmK3231WhQNrtcPUIibk+O6773j99dd5++23Pdv27t3rs9qge7XO0i5J63Q6GTp0KHfddRcdO3Zkz549pfrMs2fPZufOnbz11lsB97s/Q2JiYqHP9/vvvwc8ZtasWZxzzjk+F5pz585FRJgzZ46nHF955RUaNGjAxx9/zPXXX1/k+wd6b/+y/fjjjxkyZAgnTpygYcOGLF68uNBxqnw06JeSzWajVi2rtnX4MLhcGvBV2fXq1atQx7xafsM/7rvvPqZMmUJOTg5RUVHcc889nrXh5RSmzQ60MlplTA87YcIEz/MOHTpQs2ZNBg8ezFNPPUXdunUBqzOX2znnnIPT6eTxxx8vU9DfsGED69at87mgcrlcZGVlkZqaypw5c3jiiSc8+7Zt21bmz/Lzzz9z+eWXM378eP785z97tjdq1MjnImvp0qVMmTKFpUuXerYV1yrzxBNPEBUV5VNWpcnL5MmTWblyZbGr2pXFoUOH+OCDD3jmmWd8tm/YsIHdu3cX+u6cOHGCXbt2FbromTx5crEtLP769OnDpk2bSEtLY/bs2Vx//fWe1gR1ajTol0Ht2lbQP3IEClpblSqT2NjYEtddnzBhAjfffDOxsbE0bNjQp0Z61lln8eOPP5brvf1bGPxdeOGFLFq0qFznPhXuToA7d+70BP1AaY4fP87+/ftLXeNzuVw89NBDXBdgIo369eszduxYnxppo0aNSEpKwul0kpaWRn33/TysdeEvvPBCn3P89NNP9OnThyFDhhTqxBcREeHz77x9+/ZC24rz1VdfsWLFikLBu3v37gwePNinVcFt9erVpKWlcfbZZ3u2OZ1Oli9fzsyZM8nMzCSpYCax/fv3e5Zvdr9OCjDL2BtvvIHdbmfo0KE+210uF+eccw5z584tdEydOnWoWbOmz0VPnTp1AEhKSirUIS/Qe8fFxXHmmWdy5pln0r17d1q3bs2rr77qczGoykeDfhkkJFj3HTXoq4pUt27dIoPDDTfcwKRJk1i/fn2h+/oul4uMjIwia5Dh0rzvz52v4mpxmzZtwuFwFGoVKU6nTp346aefiizLOnXqeIKRW+fOnYmMjGTx4sXccMMNgHVv/ccff6Rnz56edNu2baNv375cf/31PPvss6XOU2nNmTOHzMxMz+s//viDSy65hLfffpvzzz8/4DGDBg0q9J0YNWoUrVu3ZvLkyURFRdGyZUuSkpJYvHgxXbt2BawhgStWrGDatGmFzvnqq69y3XXXkZCQ4LO9U6dOvPvuu9SrV6/If5NA5d6jRw8WL17MPffc49m2ePFin7INxOVyhXQ46ulMg34ZeDfvB+h3pFSJcnJyCt2/tNvtPrXK4owfP55PPvmE/v378/DDD9OrVy8SEhLYuHEj06dP54knnijynn9FNO+7A/bx48ex2Wxs2rSJqKgoT9PuggULmDRpEl999RWNGzdm9erVrFmzhj59+pCQkMC3337LnXfeyVVXXeWpeS5cuJDU1FR69OhBTEwMS5Ys4cEHH2TMmDFER0d73nvbtm3k5uaSlpZGRkaGJy/uDl8PPvggV1xxBc2bN+f6668nIiKCLVu2sG7dOqZOnRrw8yQkJHDzzTdz77330qBBA+rWrcuECRPo0KED/fr1A2Dr1q307duXPn36MHnyZJ9/T3eN1el0cvDgQc/2s846izVr1vikjYmJKRRM3Vq2bOnz2n1hdsYZZ/gM32vbti3jxo1j3Lhx1KpVq1AAjouLo06dOiQnJ3u2jR8/nieeeIK2bdty1lln8dhjjxEfH++5yHFbuXIl27ZtK3Q7CmDo0KFMnz6dq6++mkceeYRmzZrx22+/8eGHHzJ27Fhat24d8HP9/e9/p1evXjz55JMMGjSIBQsWsGTJElauXAlY36OpU6dy5ZVX0rBhQw4ePMiLL77Ivn37iuwnoMqoqG79p8MjGEP2vL3zzmoBkcaNRXbsCOqplZfTYdhNUUP2CLCOeePGjT1pSjOcLTs7W5588knp0KGDOBwOqVWrlnTr1k1mzpxZ7HC0QE51yF6gz+M9NM29dvvu3btFRGTDhg3SrVs3SUhIEIfDIW3atJGHHnpIMjMzPccsWrRIzjnnHImPj5fY2FhJTk6W5557TvLy8nzeu3nz5gHf39vnn38uF1xwgcTExEiNGjWkc+fOMmPGjGI/U3Z2towbN07q1KkjMTExcsUVV8jevXs9+x966KGA7+v93rt37y4yjftR2iGO3ufzH7IHyEMPPVTkcf5D9kSsYXsPPfSQJCUlSXR0tPTq1Us2b95c6Njhw4dLu3btijx3amqqjBw5UurXry9RUVHSokULGTVqlBw8eLDYzzJv3jxp06aNREZGStu2beX999/37MvMzJRBgwZJw4YNJSoqSho2bChXXXWVrFmzpsjz6ZC9wihmyJ6RU+gYFO66dOkiwVzTfNGiFQwceCEOB2zaBK1bg47YC77TYU1s7zW+w5mu8x4aWs4Vx/v/2unw2xEMxpgNIlJ4XC86I1+ZOBxOHA7IzoasLKigWTeVUkqpCqFBvwyMAXfn4kOHSl6BTymllAonGvTLyD1nx5EjGvSVUkpVLRr0y8gd9A8f1qCvlFKqatGgX0bukVU6Vl9VFSNHjuSKK66o7GxUWcnJyUyZMqWys6FUUGjQLyPv5n0N+ipcjBw5MuD655s2beL555/3mYu9d+/ehdZYV+HnpZdeomXLljgcDjp37syKFStKPGbZsmV07twZh8NBq1atipzbH+Cf//wnxphC34VA3yNjDLfffrsnTUZGBnfccQdNmjQhJiaGNm3aVMgkRSr4dHKeMmrQwPp79KhO0KPCS79+/XjzzTd9ttWrV4+ICP1vnpubS1RUVGVno9Tee+89/v73v/PSSy9xwQUX8NJLL3HZZZexbds2n+lzve3evZuBAwdy00038dZbb7Fy5Ur++te/Ur9+fZ91AQDWrFnDrFmz6NChQ6HzpKSk+Lxev349V155pc/kOBMmTODLL7/kzTffpGXLlixfvpzRo0dTr149hg0bFoQSUBVFa/pl5G7eP3xYa/oqvERHR5OUlOTziIiI8GneHzlyJMuWLePFF1/EGEPNmjUDruA2atQo6tev77Mgze7du4mKiipyBTeADz74gA4dOhATE0OdOnW46KKLfOZanzp1KklJScTHxzN8+HCmTJlCixYtPPsD3YqYMmWKz4xy3377LQMGDKBevXrUrFmTCy64gNWrV/scY4zhxRdf5JprriEuLs6z2MvChQs9NeGWLVty3333+Szre+DAAa6++mpiYmJo3rw5r732WjElXnGeeeYZRo4cyejRo2nXrh0zZsygYcOGvPzyy0UeM3PmTBo1asSMGTNo164do0ePZsSIEUyfPt0n3bFjxxg6dCivvfZawOWA/b9DH374IWeddRYXXXSRJ82qVasYNmwYffr0oUWLFgwfPpzu3buzdu3a4BWCqhAa9MvIvdbH4cOQnw+n8dxG6jT0/PPP06NHD0aNGkVKSgo7duygadOmhdI988wz/POf/+SBBx7g559/Bqxpbdu0aVNoula31NRUhgwZwogRI/jxxx9Zvny5T63vv//9L/fffz8PP/ww3333HW3atCm0eltppKenM2zYMFasWMG6des455xzGDhwIIcOHfJJ9/DDDzNw4EA2b97M7bffzueff87QoUMZN24cW7du5bXXXmP+/Pk+q7+NHDmSnTt38uWXX/K///2PN954o8RlbVesWEF8fHyxD//AW5zc3Fw2bNhQaN35AQMGFLnuPBS9Vv369evJ86qhjBkzhmuvvZY+ffqUmJeMjAzmzp3L6NGjfbZfcMEFLFy4kN9++w2wLgI2bdrEpZdeWuI5VeXSdr8y8q7pgzVBj91eeflRyu2zzz7zWUkv0Kp5CQkJREVFERsbS1JSEunp6dgDfIFr167NLbfcwvz583njjTf4y1/+wjvvvMMHH3yArYhpKP/44w/y8vK49tprad68OYBPDf25555jxIgRnmWC77vvPpYsWcLOnTvL9Dn79u3r83rGjBm8//77LFq0iBtvvNGzffDgwdxyyy2e1yNGjOCee+5h1KhRgDWP/VNPPcWNN97ItGnT2LFjB4sWLWLlypWeRW3+85//0KpVq2Lz06VLl4CLGXkry1K3aWlpOJ3OgOvOf/nll0Uel5qa6lkfwPuY/Px80tLSaNiwIbNnz2bnzp3FttZ4e+edd8jNzWXEiBE+2//1r39x66230qxZM8/toxkzZmiH0SqgUoK+MeavwD1AQ2ArMF5EiuylYoy5HRgHtAD2Ao+LyBshyGoh7v+H7kqF06lBX4WHXr16+SyOEoxV84YPH86kSZPYvHkzXbt25eqrrwbg7bff9gRvgEWLFtGzZ0/69etHcnIyAwYMoF+/flx77bWexYR+/PFHnyAM1qprZQ36Bw4c4IEHHmDJkiXs378fp9NJVlYWe/fu9Unnv+Lchg0bWLduHU899ZRnm8vlIisri9TUVH788UdsNhvnnXeeZ3/z5s1p1KhRsfmJiYkpccnc9PT00n68CvPzzz8zefJkVq5cWeqLkNmzZ3P11VcXWhBqxowZrFq1io8++ojmzZuzfPly7r77blq0aKG1/TAX8qBvjBkMPA/8FVhZ8HeRMaa9iOwNkP424ClgNLAWOA+YbYw5IiILQ5dzi7sjn3fQVyocxMbGlnq99tIaNGgQY8eOZeHChT61zKuuuopu3bp5Xjdu3Bi73c4XX3zBmjVr+OKLL/j3v//NpEmTWLZsGR07dizV+9lsNvzXA8nz6zwzYsQI9u/fz7PPPkuLFi2Ijo7m4osv9rk3D9YKc95cLhcPPfQQ1113XaH39Q5qxphS5dVtxYoVXHbZZcWmueuuu3j44YdLdb569epht9tLte68t6LWqo+IiKBevXp8/vnnpKWlcfbZZ3v2O51Oli9fzsyZM8nMzPRZxXDTpk2sX7/ep18HQFZWFpMmTWLevHlceeWVAHTo0IFNmzYxffp0DfphrjJq+hOA10VkdsHrO4wxlwK3AZMCpB8GzBaRdwte/2KM6Qr8Awh50K9ZEyIjITPTmoNfg76qaqKionCW8osbGxtL69atMcZw8cUXe7bXqFEj4AIyxhh69OhBjx49ePDBBzn77LN577336NixI+3atWPNmjXcdNNNnvRr1qzxOb5+/fqFmsr9X69cuZJ//etfXH755YAV2Px7nAfSqVMnfvrppyIvjNq2bYvL5WLdunWe9d337t3LH3/8Uex5g928HxUVRefOnVm8eLHPBcrixYsL9cL31qNHDxYsWOCzbfHixXTp0oXIyEgGDRpUqPVj1KhRtG7dmsmTJxca3TBr1ixatmxZ6JZBXl4eeXl5hW4L2e12XLogSdgLadA3xkQBnQH/Xi1fAD2LOCwayPbblgWcZ4yJFJGQ9qE3BurUgf37rbH6+fmhfHelTl2LFi1Yt26dp4NaXFxckffpFy9ezHfffUd8fDwnTpwgNja2yPOuWbOGL7/8kksuuYTExEQ2btzIb7/9Rvv27QFrLfXhw4fTtWtXevfuzfz581m7di116tTxnKNv375MnTqV1157jV69evHBBx/wzTff+Kwhf9ZZZ/HWW2/RrVs3MjMzuffee0s1HO/BBx/kiiuuoHnz5lx//fVERESwZcsW1q1bx9SpU2nTpg2XXnopt956K7NmzSImJoYJEyaUeJukIpr3J0yYwLBhwzjvvPM4//zzmTlzJn/88Qdjx471pBk+fDgAb7xh3ekcO3YsL7zwAuPHj+fWW2/lm2++4fXXX+fdd636Uq1atahVq5bP+8TFxVGnTh2fvhcAJ06c4O233+bee+8t1PJRs2ZNLrroIiZOnEh8fDzNmzdn2bJlvPHGG0ydOrVMn1OFXqhr+vUAO7Dfb/t+oF/h5AB8DtxsjPkAWI910XALEFlwPp9LfGPMGGAMWJ1Yli5dGqy8k5GRwdKlS4mL6wLEs3nzevLyMtBh0MHlLueqLDs7O6T3cfPy8sjPzw/4nv77xo4dy9ixY2nfvj1ZWVls3rzZ0/HO38SJE7n88sv54YcfePvttxkyZEiReYiIiGDZsmX861//4tixYzRu3Jh7772Xq6++mvT0dAYOHMikSZOYPHkyWVlZXHbZZdx+++288847nrz17NmTiRMnetJcd9113HLLLXz66aeeNDNmzOBvf/sbnTt3JikpiUmTJrF//35ycnJ8Pn9WVpbP6549ezJv3jymTp3K9OnTiYiI4Mwzz+SGG27wpHvhhRe444476Nu3L3Xr1mXixImkpqYWOndZOZ3OMh0/cOBAnnzySR599FFSU1Np37498+fPp06dOp7z7N69Gzh5QVGvXj3mz5/PpEmTePnll2nYsCFTp05lwIABRb630+kkNze30P633nqLzMxMrrvuuoDHvvrqq0yZMoUbbriBI0eO0LRpU+6//35GjBgR8v4L2dnZnt+L0+G3o8KJSMgeQCNAgF5+2x8Efi7imBjgNSAPyAd+x7rHL0Bice/XuXNnCaYlS5aIiEivXiIg8vrrIvv2BfUtlJws56os2N+9inL8+PEi933wwQdis9lky5YtMnnyZOnfv3/Q33/atGnSvHnzoJ833BRXzurUeP9fOx1+O4IBWC9FxMVQj9NPA5xAot/2RCA10AEikiUiNwGxWL33mwF7gHTgYEVltDjeU/HqrHzqdORyuXjggQf4y1/+wtlnn83w4cP56quvePnll0lLS6vs7CmlyimkQV9EcoENQH+/Xf2BomedsI7NE5F9IuIEhgAfi0il9BrxXnRHJ+hRp6O3336bn3/+2dPjvE2bNjz66KM88MAD3HPPPZWcO6VUeVXGjHzPACONMbcYY9oZY57HavafCWCMecMY4xmDb4w5yxgzzBjT2hhznjFmLpAMTA549hDwnqBHRHvwq9PPsGHDyMvL44wzzvBsmzx5MmlpacyZMydo73P33XeXOOOdUip4Qt4FTUTeM8bUBe7HmpxnCzBQRH4tSOK/moQda5hfG6z7+kuAniKyJzQ5Lswd9L3H6mtnPqWUUuGuUkKViLwEvFTEvt5+r38Ezg1BtkrNf4Ke/HzwmtNCKaWUCku64E45eAd9Y3SsvlJKqapBG6XLwTvo22yQk1O5+VHhp2HDhoVmPwtH2dnZOByOys7GaU/LueI0bNiwsrNQpWjQLwfvoB8RoUFfFbZwYchniC6XpUuX0rt378rOxmlPy1mFCw365VCnjrWyXnq6Nu0rpZSqOvSefjlEREDt2tbzo0et3vu6zoRSSqlwp0G/nNxrhOgSu0oppaoKDfrlVLeu9dc9QY828yullAp3GvTLyR303cP2tKavlFIq3GnQLyf3ojvuYXu68I5SSqlwp0G/nLyn4rXbddieUkqp8KdBv5y8x+pr0FdKKVUVaNAvJ++V9ux2yMur3PwopZRSJdGgX06JidZfd0c+XWJXKaVUuNOgX07u5v2DB62/OmxPKaVUuNOgX05Nmlh/U1OtgK/D9pRSSoU7DfrlVKsWxMVBVhYcO2Zt0/v6SimlwpkG/XIyBpKSrOcpKVZnPh2rr5RSKpxp0C8nm02DvlJKqapFg3452Wwne/CnpFgr7+lYfaWUUuFMg345GQMNG1rP//jDugjIz7c69SmllFLhSIP+KXAH/ZQU668O21NKKRXONOifgsaNrb/uoK/D9pRSSoUzDfqnwD/og9b0lVJKhS8N+qegaVPrrzvo22w6Vl8ppVT40qB/CurVg5gYyMiA9HQr6OuwPaWUUuFKg/4piIgoPFY/O7ty86SUUkoVRYP+KbDbC4/V1+Z9pZRS4UqD/inwn5XPGHC5tDOfUkqp8KRB/xT4B33QsfpKKaXClwb9U+A/FS9YtX0N+koppcKRBv1TYEzhoG+36xz8SimlwpMG/VMQqHlfe/ArpZQKV5US9I0xfzXG7DbGZBtjNhhjLiwh/Q3GmE3GmBPGmFRjzFvGmKRQ5bcodrvvojtg9eDXoK+UUiochTzoG2MGA88DTwDnAquARcaYZkWkPx94E/gPcDYwCGgPvB2K/BbHGGuCnqgoOHYMMjNPrranc/ArpZQKN5VR058AvC4is0XkRxG5A0gBbisifQ9gn4g8KyK7RWQNMAPoFqL8FisysnATv3bmU0opFY5CGvSNMVFAZ+ALv11fAD2LOOwboKEx5kpjqQcMAT6tuJyWXlRU4aAPGvSVUkqFn1DX9OsBdmC/3/b9QMB79CKyGivIvw3kAgcBA4youGyWnv9UvKBz8CullApPEZWdgZIYY9pjNec/CnwONASmAa8AwwOkHwOMAUhMTGTp0qVBy0tGRkah8zmd4HC0Aprx/fe/cPbZexGB3butpn9VdoHKWVUMLevQ0HIODS3nkoU66KcBTiDRb3sikFrEMZOAdSIyreD1D8aYTGCFMWayiOzzTiwis4BZAF26dJHevXsHK+8sXboU//NlZID7O+Z0tuLss1vhdFpz8LdqFbS3rlYClbOqGFrWoaHlHBpaziULafO+iOQCG4D+frv6Y/XiDyQW60LBm/t1pc8z4D1sz3usfn6+NQ+/UkopFS4qo3n/GeBNY8w6rE56Y4FGwEwAY8wbACLibrpfCMw2xtzGyeb954DvRGRvaLNemP9Ke97y862OfkoppVQ4CHnQF5H3jDF1gfuxAvgWYKCI/FqQpJlf+teNMTWAccDTwDHga+Afoct10QLNv++mQV8ppVQ4qZSOfCLyEvBSEft6B9g2A6szX9ix260JeiIi4PBhazY+h8Maq5+bC7GxlZ1DpZRSylLp98SrOmN8h+2lFnRHtNshK6vy8qWUUkr506AfBIFm5YuM1Dn4lVJKhRcN+kHgHfTdC+/Y7dawPZHKy5dSSinlTYN+EERGFt+ZTymllAoHGvSDICoqcNAXsWr7SimlVDjQoB8EdnvgRXeM0aCvlFIqfGjQD4Kign5EhHbmU0opFT406AeB9wQ97o58oEFfKaVUeNGgHwR2O9SvD9HRkJZmLcLj3p6bqz34lVJKhQcN+kFgs1kBvnlz6/WePdZfY7Qzn1JKqfChQT8IbDbr0bKl9XrXLt/9GvSVUkqFAw36QRIZCS1aWM937z653WbT+/pKKaXCgwb9IImIONm87x30IyLgxInKyZNSSinlTYN+kERFnQz6v/xycrt7Dn7tzKeUUqqyadAPkshIaNbMeu5d03d35tPpeJVSSlU2DfpBEhFhDduLjYUjR6yHt9zcysmXUkop5aZBP0jsdqtW7+7B79+ZLyencvKllFJKuWnQDxJbQUm6g773ff2ICMjMDH2elFJKKW8RZUlsjOkOXAp0BxoBMUAa8DOwDPifiBwp+gynL7vd+tuqlfXXu6YfGWn14BexWgOUUkqpylCqmr4xZoQxZjOwCrgTiAV2AGuBI0A34FXgd2PM68aYlhWU37Bls1lBPVDzvnbmU0opFQ5KrOkbY34A6gNvAMOBTSKFB6AZYxKAK4ChwDZjzEgReS/I+Q1b7ql43TV97+Z9t7w8q9avlFJKVYbSNO//G3hFRIqdV05EjgFvA28bYzoCSUHIX5USEeE7bM+7Od89M19sbOXlTymlVPVWYvO+iDxfUsAPcMz3IvJ5+bNVNUVGQkIC1KplrbR38ODJfTozn1JKqcqmvfeDKCoKXK7A9/UjIyErS2fmU0opVXlKHfSNMYOMMXOMMWuNMTsKHmsLtg2qwDxWGRERvkHf+76+MdY+7cynlFKqspSmI19tYCHQE9gLbAW2F+yuA/QGRhhjVgNXVNche2DV5kUCD9sDK/BrZz6llFKVpTQd+Z4GmgEXiciKQAmMMRcAbwHTgZuDl72qpbhhe+79OTnamU8ppVTlKE3z/lXA3UUFfAARWQn8AxgUpHxVSe6peIsatqcz8ymllKpMpQn60VgT8JTkKBB1Srmp4tyz8rlr+nv2WPfx3XSZXaWUUpWpNEF/NXCfMaZGUQkK9k3CmrGv2nI379eoYa24l50NKSkn9xsDTqd25lNKKVU5SnNPfzywFPjVGPMJsIWTNf/awNnA5YAT6BP8LFYdNptVm3f34D940Grib9z4ZBpjrPv62plPKaVUqJUY9EVkW8EMe/cCVwI3AO5lYwTYgzVF7zQR+aOC8lllREVZNfmWLWHdOqsz34UXntxvt1v39ePjKy+PSimlqqdSrbInIilYC+3caYxxYNXwAY6KSFZFZa4qio62avJFdeaLitLOfEoppSpHmWfkE5FsEUkpeJQr4Btj/mqM2W2MyTbGbDDGXFhM2teNMRLgEZah0+Gw7tsXNWzPbrdaAvLyQp83pZRS1VuJQd8Yc01ZT2qMaWiM6V7EvsHA88ATwLlYnf8WGWOaFXG6vwMN/R6/AP8ta75CIaKg7aS41fZEIDc3dHlSSimloHQ1/RnGmE3GmLHGmDrFJTTGXGiMmQXsBDoUkWwC8LqIzBaRH0XkDiAFuC1QYhE5JiKp7gdwBtAKmF2KvIec3W4F9RYtrNd79xau1eviO0oppSpDae7ptwbuBh7BugD4EfgeOAjkYN3fbwV0ARKA5UB/ESk0fM8YEwV0xpq5z9sXWNP8lsZoYGug84cDd00/JgaaN4dff4WdO6Fdu5NpoqIgPd0a1qeUUkqFSml6758AHjHGPAn8H3Ap0A1oBDiAQ8BPWE3274nIT8Wcrh5gB/b7bd8P9CspL8aYBOB6rDkBikozBhgDkJiYyNKlS0s6ballZGSU6ny5udbQvGbN2vPrrw347LMfcbl8P7LLZbUCqMJKW87q1GlZh4aWc2hoOZesVL33AUQk1xjzFfChiGRXYJ6KcyPWLYk3i0ogIrOAWQBdunSR3r17B+3Nly5dSmnOt2+f1Vnv/PNhxQo4cqQdZ5/dzidNRoY1fj8uLmjZO22UtpzVqdOyDg0t59DQci5ZaTry2Y0xU4wxR7Bq5MeNMe8bY2qV4/3SsCbxSfTbngikluL40cD7InK4HO8dMtHRVg/+P/3Jer15c+E0djtk6WBHpZRSIVSajnxjgQeBjVj34j8ErgaeLeubiUgusAHo77erPyVM4WuMOQ/oSJh24PPmcFjN98nJ1uutW33n4AdrRr709NDnTSmlVPVVmqA/GpgtIn1F5B8ich1wO3BjQce8snoGGGmMucUY084Y8zxW/4CZAMaYN4wxbwQ4bgywQ0SWluM9QyoiwurBX68eNGxoTcbjP14/IsLq1a/z8CullAqV0gT9VsA8v23vYXXIa17WNxSR97Dm878f2ARcAAwUkV8LkjQreHgULOgzBHi1rO9XGdyr7cHJ2v6WLYXT6Xh9pZRSoVSaoB8PHPfb5m6YLnLlveKIyEsi0kJEokWks4gs99rXW0R6+6VPF5F4EZlanvcLNXdNH/S+vlJKqfBR2t77jY0xrbxe2722H/VOKCIB5qCrXrxX2ysu6LvH69etG9r8KaWUqp5KG/TnF7H9fwG22QNsq3aio6179t7N+yLW+H23iAgr6DudvrcElFJKqYpQmqA/qsJzcRqKioLsbKsjX926cOiQNX6/adPCaXNyIDY29HlUSilVvZRmRr7/hCIjpxuHA44etWr2ycmwbJnVxO8f9CMirIl6NOgrpZSqaGVeWleVTqDOfIF68EdHw/HjJ9MqpZRSFUWDfgUJNGwvUGc+m826p5+TE5p8KaWUqr406FeQ0tb0wQr8OnRPKaVURdOgX0G8h+01bw41a8KBA7Dff31BrCb+o0dDnkWllFLVjAb9ChQdbU2zawycfba1LVATf0SENTNfXl5o86eUUqp60aBfgdyr7UHx9/XBujDQJn6llFIVSYN+BYqOPrm6nvu+/tatgdNGRlq9+JVSSqmKokG/ApV2Dn6wJvM5ceJky4BSSikVbBr0K5D3sL0zzrAm7Nm3Dw4fLpzWGOsCQYfuKaWUqiga9CuQd03fbodzz7Wer11bdPqMjNDkTSmlVPWjQb8CuYftuZvszz/f+vvNN4HT6+x8SimlKpIG/QoWF3dyKJ476K9cGTitzWZ1/NMmfqWUUhVBg34Fi421xuoDnHMOxMTAjh2BJ+kB6zaANvErpZSqCBr0K1hk5MnnUVHQvbv1vLgm/qNHTw71U0oppYJFg34Fi4ryfV3SfX33Ajw6UY9SSqlg06BfwWw2K/C7m/gvuMD6W1TQB6t14Nixis+bUkqp6kWDfgh4d+Zr3x5q1YLffoNffw2c3uGA9PSTFwpKKaVUMGjQD4GYmJMB3G6HHj2s58XV9o2xZuhTSimlgkWDfghERlpB3K00TfzR0YFn7lNKKaXKS4N+CHj34AffznxFTcQTGWmN19cx+0oppYJFg34I2GxWzd19X//MMyExEQ4ehO3biz9Ox+wrpZQKFg36IRIXd/K+vjElD90Dqy/A0aM6La9SSqng0KAfIjExvsvmljQlL1g1/fx8HbOvlFIqODToh0hkpG+N3R30V6/2vRgIdJx26FNKKRUMGvRDJDLSqrm7A3/TptC8ubWq3qZNRR/ncFj39bVDn1JKqVOlQT9EjLECuLszH0C/ftbfhQuLPzYy0rq3r5RSSp0KDfoh5N2ZD+Dqq62/CxcWv8COw2FNy+t9waCUUkqVlQb9EHI4fIN7p05WM39qKqxdW/Rxxli3Bo4fr/g8KqWUOn1VStA3xvzVGLPbGJNtjNlgjLmwhPRRxphHCo7JMcbsNcb8LVT5DRb/znzGnKztf/hh8cc6HFaHvuI6/SmllFLFCXnQN8YMBp4HngDOBVYBi4wxzYo5bC5wKTAGaANcB/xQwVkNuogIa+5978B/1VXW308+Kb753t0JUCfrUUopVV6VUdOfALwuIrNF5EcRuQNIAW4LlNgYMwC4GBgoIotFZI+IrBWRpaHLcnAYY93X9+6J3769NUPf4cPFj9kHa6x/WppO1qOUUqp8Qhr0jTFRQGfgC79dXwA9izhsEPAtMMEYs88Ys8MY8y9jTHzF5bTi1KjhW6M3BgYNsp6X1MRvt1sdATMzKyx7SimlTmOhrunXA+zAfr/t+4GkIo5pBVwAdAT+DIzDaup/vWKyWLEcDt8V9+BkE/9nn0F2dvHHx8TAgQPF9/ZXSimlAomo7AyUgg0Q4AYROQZgjBkHfG6MSRQRnwsIY8wYrHv/JCYmsnTp0qBlJCMjIyjny821/noH/zPP7MzOnTX4z3+2cMEFacUe73LB7t1Wzf90FKxyViXTsg4NLefQ0HIuWaiDfhrgBBL9ticCqUUckwL87g74BX4s+NsMv1YDEZkFzALo0qWL9O7d+xSzfNLSpUsJxvmOHbNq63FxJ7cNGQKPPQYbNyZz663FH+9yWfPxt2xpdQ483QSrnFXJtKxDQ8s5NLScSxbS5n0RyQU2AP39dvXH6sUfyDdAI797+GcV/P01uDkMDf/x+nCyiX/x4pLv2dtsVivBkSMVkz+llFKnp8rovf8MMNIYc4sxpp0x5nmgETATwBjzhjHmDa/07wCHgDnGmLONMedjDfmbLyIHQp35YIiKssbse4+5b9wYuna17ul/9FHJ54iJsXr8u28VKKWUUiUJedAXkfeA8cD9wCasTnoDRcRda29W8HCnzwD6AQlYvfj/CywDbgpZpoPMGKhZs3DAvvFG6+8rr5TcUc8Yq2n/4MGKyaNSSqnTT6XMyCciL4lICxGJFpHOIrLca19vEentl/5nERkgIrEi0lhEbheR9JBnPIj85+EHa3a+hg1hxw748suSzxETA+np1v19pZRSqiQ6934liY62auveE+1ERsLo0dbzl18u3XkcDmvufh3Cp5RSqiQa9CuJzQbx8YWb+IcOtZr+162D9etLPk9UlDXZz6FDFZNPpZRSpw8N+pWoZs3C8+3Hx8Pw4dbzmTNLd564OGt6Xm3mV0opVRwN+pXI4Qg8j/7NN1s1+M8+g507Sz6PMRAbC3/8oavwKaWUKpoG/UoUEWHd2/ev7TdoANdea10QzJpVunO5l+1NK34yP6WUUtWYBv1KVqdO4Pn2b73VqsHPn2/N3lcasbHWhD26/K5SSqlANOhXsvh4aw59/973Z54Jl1xiLcP7zDOlP5+7md97+V6llFIKNOhXOpsNatcOXNu/5x7rFsBbb8HGjaU7X0SE1dT/+++F5wFQSilVvWnQDwM1awbugNe2rTVuXwQmTSp9J73oaOuY3393+bQguHQwv1JKVWsa9MNAZCTUqBG4tn/nndCoEWzeDG+8UXh/UZYs+ZR58z5m/34XIlbAnzt3Lh988EHwMq6UUqpK0aAfJmrXDrx4TlwcPPqo9fypp2D//sJp/LlcLnJyckhL28Pbb3/CoUNWwN+zZw/Z2dla41dKqWpKg36YcDish//wPbA69F18sTXP/iOPlHwum83G1VdfTdOmTTl4cDePPz6LrVtTaNGiBUOGDMFm0392pZSqjvTXP0wYA3XrBm7iNwYee8y6KPjf/2Dp0pLP5w78xkBUVC6ZmXH06zcEY/SfXCmlqiuNAGEkLi7w8D2AZs1g/Hjr+bhxsHdv8edyuVx8+OGHgHXREB2dyxtvfMyBA66AswAqpZQ6/WnQDyM2m1XbP3Ei8P6//hX69rUm4LnpJsjMDJzOHfB/++03mjZtyrhx42jWrCkHD+7hzTc/ITXVpavyKaVUNaRBP8wkJFhj7QPd27fb4YUX4Iwz4McfrZp/oOBts9mIjo6madOmXH311Z6m/mbNmlKrlp30dJuO41dKqWooorIzoHzZbJCUZDXfR0YW3p+QAK+9BldcAZ9+Cs8/bw3r8zdw4EBcLpen05478LtfZ2XBnj3QuDHExFTgB1JKKRU2tKYfhmJjreBeVDP/mWfCiy9a9+qnT4eCW/eF2Gw2/vxn+POfT752i4mxLip+/dW6XaD3+ZVSAOL3Y+D/WlVtGvTDVP36ViAuaha+iy+G++6zno8bB+++WzhNSf95IyOtuf8PHIB9+wLPE6CUqj42bNjA6tWrPb8VIsLq1avZsGFDJeeseHqhUnoa9MNURAQkJhbdWQ9g7Fi4+27rvv7dd1u1f/d3/YcffmD9+vXAyf+869ev54cffvA5h81mzQaYlwe7d8Phw4H7CSilTm8iQk5ODlu2bPEE/tWrV7NlyxZycnLCNpBW1QuVyqL39MNYjRpWU392tjVG358x1v382rXh/vvhiSfg0CG4/37rP+933/3C3r3J2GwOnnhiD/Xq/UKnTq0QEYwxPudyOKw5+9PS4NgxaNDAem+/ZCoA//IMVL7hpirmWVUsYww9evQAYMuWLWzZsgWA5ORkevToEZbfD+8LFTf3hUpycrJ+rwPQoB/GjDnZqS83F6KiAqcbOdIK/H/7G7zyCuzbZ4iKas7HH3ciP98gAq++2gSRZvz5z2l06RL4P4ExVnN/Xh789pt1379+fSv4q8A2bNhATk6O50fRXcuIjo6mc+fOlZ29gLzzDFSJPKvQcAd+7yAargEfCl+o1KlTh8OHD4f1hYq3yrj41ub9MBcVBU2aQE5O8UPsrr4aXn/dmuDnk09gwYL65OXZEbEBhtzcSPLy7CxYUI9p04pvpouMtFb+E7EuOPbutToVhqJ1ryrdm6uKzaH+eQbCPs9uVem7UVW5v8PevJvOw5F34HerCgG/sm5LaNCvAhwOaNrUCrzF3W/v0wfmz3c3yQf+wufk2Jk503DsWMnvGxV1ctnf336z7vkfO1Zx4/vd/wncwv3enPvHJjk5mS1btjB79mxPs2K4/ugYY4iKiiI+Pp4tW7aQlpbGli1biI+PJyoqKizzDFX3vm1VulAREebNm8eaNWtITk5m9OjRJCcns2bNGubNmxe2ea+KFyrui+/Nmzf7VBg2b95c4RffGvSriNhYa4ndjIzia9ybN4PDUfwXxm4XPv649O8dHW31L4iMtFb5++UXSEmxOhkGq9Ofdw00MzOzStSawQqi3bt399nWvXv3sA2eIkJubi7Hjx8nIyMDgIyMDI4fP05ubm5YlnNVbFGBqnuhAvjkOZz5X6jUq1evSlyouC++a9SowebNm5k9ezabN2+mRo0aFX7xrff0qxB3rXv//pPz9Ps7cCDwoj3eTpyw0pWV3W7d8xexJvc5ftxqVahZ07oocDgC56k0jDGkpKSQl5dHVlYWs2fPBiAvL4+UlJSwDaLr169n+/btPtvmzp3LWWedRZcuXSopV0UzxhAZGYnT6WTGjD9z110/k5WVRXR0NJGRkWFZzu4fyLi4OJ8OZnFxcWHbOuFdk3Nz1+T+9Kc/hWUHM2MM1113Hd988w1bt25l69atAJx33nmcf/75YZdftyNHjvhcsLovbI8cOVLJOSuaO48ZGRlkZmYSFxdHZmYmxhjPZ6mo8taafhVTu7Z1jz8rK3Bwb9AgcE9/b8bAli2Qmlq+PBhjvUeNGtbFR2amNc5/586Tk/1kZ5etFcDlcpGTk8PRo0fJL7h/cPjwYY4ePUpOTg6uMBxH6HK52L59O3v27CE+Pp5bbrmF+Ph49uzZw/bt28M2zzt27ODo0aMFPyoGu93O0aNH2bFjR1jmWUT45Zdf2L9/P+np6QCkp6ezf/9+fvnll7CszfnX5NLS0kJWkzsVCxYsYO/evUyffgVPP30FIsLevXtZsGBBZWetSLVq1UJEWLt2LWlpaaxduxYRoVatWpWdtSK5Wwjj4+PJzs7m0KFDZGdnEx8fX+EthRr0q6D4eGjRwhpj7z+O//LLweUq/gsjYvjsMzjvPKvn/yefWLcNysMYq5d/jRrWA6xhf7/+evIiIC3NymdubtG3Jmw2G4MHDyYhIQERITU1ldzcXBISEhg8eLDPbILhwmaz4XA4SEhIYMqU3rRrl0p6ejoJCQk4HI6wzbO7RiHiAoS8vDyMMWRmZoZlngEaN27M0aOG5cvb8N//tmH58jYcPWpo3LhxZWctIP+aHEBmZiYZGRlhexvF5XKRnZ3Nrl27yM/PR8SqRe/atYvs7OywvCAEaNKkCfn5NXjiieHs21ebZcvOIj+/Bk2aNKnsrBVJRFizZg3p6ek4HA7q1auHw+EgPT2dNWvWVOj3Q5v3q6ioKGu53YMHrZq1w2Ftq1ULxo4VZs50kZNTuK09KsrJZZfZyMszfPEFLF5sPSIjoVs3a6a/Pn2sRX3K8/sfGem7ZkB+vtX579Ah67UxVj5jYqw8R0ZaExHZbMK///0qGRkZiJzFnDk9GTXqP2RkZPDqq68yZsyYsKsdiQj5+fmcOHECl8uJ3W4nMzMTp9NZ8KMZfk24TqeT3Nxc8vLysDp7Gowx5OXlkZubi9NpfY5wIgJPP12LhQvHYYyQlxdJZGQen356CVu2bKdHj/CbT8Jdk9uzZw9paWnk5+eTnZ1NUlJS2Pb5MMbQvHlzfvppP8ePx+J0RrB6dTIdO+6gefPmYZlnMCxa1IOpU7uRn2/D6bSzaNEAFi2ykZNjo2fPcMzzyduZ+fn5xMfHAxAfHx+S25nheVmvSsVms2bta9bMep2ebgXZu++Gvn13YrfnY4xVm4uMzMVuz+fii3fywgswezasXw8PPABdu1p9BVauhIcfht694U9/ghtvhGeega++gt9/L9+QvYgI35aA+Hgr3xkZJ6f/3bMHdu4UUlPj+PXXmjiddg4fTmDNmi4cOBBFTo4hJ0dwOsNvjQAR4ehRw9GjMRw4EMvSpa05etSEZU0OwG6307VrV6A26elx5OfbWLeuI1Cbrl27hl3AB3joIfj00zbk50eSlxcFGPLyosjPj+TTT9vw0EOVncPCRIT58+eza9dhNm3qSmZmTTZt6squXYeZP39+mH4/DM89V4cnn7yDw4frcPRoAosWDeDJJ+/guefqUNSIoMr04IPC9Oku8vIiCoYnQ15eFHl5EUyf7uLBB8OxnK1WlQMHDnD48GGee+5q3nlnNPHx8Rw+fJgDBw5UaKuK1vRPA7Gx0Ly51YR+4ADk5Ajnnrucli0XM2/eCKKj47nggi3UqbOKevUigdaAoX59ayrfsWOt6XeXLbMC/OrV1v3+JUush1tcHJx1ltUK0KyZ1begaVPrb/36pV+tLyLCenhzOmHJkmRWrkzmqadWcvx4AosX9+OLLwbQo8c2+vc/2UnQZrOeWy0EJ8/nfm6M9bDZTj4v6gHlryW6XMJ//nMGixdfg9NpL7htcgmLFl1K//7fc+21gt0eXj+ULpfw8MN2vvjiNpxOO06nvSDPhnXrfmDhQsFmC588HzliLSqVkxP4pyonJ4Lp04W77rJaucKFCLz+eisWL/4/bDahW7dVfPhhTxYs6F3w3Qi/1okHHxQ+/vgs8vJOXvhZF1nw8cdn8eCDwqOPhk+mq+p3A6yaft26dUlNzebgwUj2709nwYJ6tG+/n7p162rvfVUy92x6sbFw4oQhPt5BVpaLunWFhAQYMsTJmjVCbGxswC9UnTrwf/9nPUTgjz/gu++sx+bNsGOHdW9+40brEUiNGlbwr1/f6nBYq9bJh7uWHx9vXTzExVkXCe7HK68YvvkmGafT/ZU05OdbPzhr17bnlVcM995r7RGxOgm6XFbLRk6Otc293Z2mLP9v/C8Q3NuK+/vUU4Yvv+xIfv7J+xnuH8kvv+zIvfcaJk/2fQ9/3u8XSEn7ixPouEceERYv7hAwz4sXd2DiROHBB8Pnh/2tt0q+zWSzWelGjQpNnkrj4Yel0HcjN/fkd2PiROGhh8KnnN0BNDs7cEtPdrad6dOFsWPDJ4C+/XbV/G6A1a9qw4breO45IS/Pev3hh7356KOLufdeG9ddV3HfDROezUzB0aVLF7EWnQmOpUuX0rt376CdryKtX7+erVu3c/hwNllZ0eTn24iNjeOMM1rQuXOHQjXt0jh8GLZvh127rGb5ffusSXt+/93qW5CXF5y82+0unM7C/5tbtLD6A0REWDV9/4cx1l93SwBYz90BvbiaPxQOsP5B0/t1Xh58/LEU22nSZhOuvtr49HHwVpoLk7IGfPd/50DH5ebChx/65rl79z9Ys6ZRoTwXNeVzqG3dao00KUlyMpx9dsXnpzRKW86DBhX93Qi1X36B774TnM6iv3B2u9Cpk6FVqxBmrBiBvhv+5Qzh9d1w27wZfv45cHnHxgoTJhgefbT85zfGbBCRgGOGKyXoG2P+CtwDNAS2AuNFZEURaXsDSwLsaiciPxX3PtU16HtPXpKRkUFcXBzHj58gJqYmrVol07bteeTlGZ8arX/wLPt7wtGjVvA/cMDqvHf06MlHRsbJR3q6NaQvK8t6HDoEGRlCON4zVEqpUHM4hJQUU+5WleKCfsib940xg4Hngb8CKwv+LjLGtBeRvcUcejZw2Ov1wYrLZdXm33M4u2BAf+PGiVx6aVdsNoPLZdVW3c3jOTlWDSUry2oiD1QLLam2nJBgPVq3LtuFw7PPwtNPG08t9cknlzFx4kWF0t10EwwdauXZ6Sz8cOfb/drd5O9u9vf/C75p3O/v/9z7r9vnn8Pnn5d0oSIMGGDo16+IvSVcbwf7evyrr6yRGt7+/Oefef/9Nj7b+ve3RnGEIk8lycqyVo8sburniAiYPLn0fUoq2ldfwZdf+n43rrlmOx98cJZXKqFfP1NkOYfaunVWy1VeXtHf58hI4YorDOedF8KMFcP6bgj5+UWXc0SEMHmyCZvvBpSurO12mDcPRo8O/vtXxj39CcDrIjK74PUdxphLgduAScUcd0BE0io8d6cB/zGg8fHxZGRkeMaA9ujRA5vNEB1tTbEbF+d7vMt1Moi6n4tYP7zu++juff5p/O+tl0ZCgnVlm5Vl/SeIiCgcWWJihJYtDU2alP1+fUXIzITly60fnqLExMCFF1qLIYWDvDxYufJkOQP06JHiE/RjYoRevQz/93+VkcPADhxw8e9/Wz20/UVG5nPzzTaGDg2fgUj5+fDNN77fjZ49//AJRjExcNFFcM01lZDBAC6+GD79tPj/VDab1UelZs0QZaoUDh6EV1/N93w3vMs5MjKfW26xM3RoZeawsJQUfC5UAjlxwpR78rSShDToG2OigM7AdL9dXwA9Szh8vTEmGtgGPCYigZr8Fb6zgbk77cXHx5d6URX3ffBgCFRT9n9+663w+OMln+fWW60LhHAwenTp8jxmTPh0fLLyXPLETeGUZ4BnnzXs3v09X33VoWCcfgSRkfmIGPr2/YFnn+0UtO9rMFTF7wbAnXe6eOYZF7m5hcNCVFQ+d95po0OHMCporO9GQoKNp5/OJz/fyltkZC5g4667bEyZYiq9guCvbVvrou/EiaLTxMZay6pXhJDe0zfGNAJ+By4SkeVe2x8EhopImwDHtAH6AN8CUcAwYGzBOQr1AzDGjAHGACQmJnaeO3du0PKfkZHhmUgh3GVmZpKVlUVMTIxnXmfv1+Hmjz+sNQVcLmjSJIN9+06Ws3s+gkaNijlBJfjjD2toY6D/QsZY/2nDPc/eZR2ueQY4ePAgublOsrNjEInEmDwcjiyiouzUr1+/srNXSFUt5507T3D8eAwiVqS0AqZQs2YWZ54ZW6l5K8qRI0fIysrlxAkHtWpZfYhiY7OJiYmidu3alZ29QpxO+P774m+VGQMdO5Z/LZM+ffqEzz39shKRn4GfvTatNsa0wOoIWCjoi8gsYBZYHfmC2fGuqnTkA2uFr5ycHM8Sr+7OfdHR0XTu3Lmys1eICIwe/QdvvpnIE0+s4O67LyIqKh+wMWzYfsaPbxR2V+wul3Ddddv46KM2uFx2XC5wOFzk5wtXXfUz8+a1D6sx7+Bbzvn5NqZOXcZDD11EXp6LYcP2c+ed4VfOAK+++io5OTnY7XZsNlvBlLFOoqOjue666yo7e4WIwC23/M4bbzTAGOGf/1zFpEk9ETEMH36AO+9sHJblXKPGBg4cyGX8+O7k5homTRKaNl1DgwY1w/J3w+l08txzz5GRkYHNZiMhoS0pKT/hcrmIj49n/PjxYTnh1JIlLqZNc5KbW3j4RlRUHvfcY+fiiyumVSXUQT8NcAKJftsTgbLcwVgLDAlWpk5HnTt39pkG1r32e3hOpQkgjBq1mxYtFhAR0Za6ddPp23ctHTtup3fvc7AGeoRX3o2BCROOcu65r/Cvf/0FlyvCJ8/hWNTGwG23pfDnP+9l/PhuREVZsy42a/Yt9etHYjXGhZ+bb76Zb775hm3btgHWGgLJycmcf/75lZyzwFwuJ+eeu4D69TP56adkatUyDBy4mLZtN9OkSTwu121hGYw6d+6My+WiYUPryztmjMHl6ha2azLYbDbi4+M5ceIEMTExGGOIiYkhKyuL+Pj4sM33o4/a2LRpE59//ifPxF5RUfm4XNC//2YefbRThb13SIO+iOQaYzYA/YF5Xrv6A++X4VTnAClBzNppyT/Ah2/AtxhjiI3NwW53UadOBt27b/ZsD0fGGHr2tLqi2GwzPdsvuugievbsGZb5di/5+ttvW4iLa0d0NCQnW8M7a9ZMDsv1AtytVNu2bSM5OZkePXp4hqTabLawvJi12Wzk5eVRo0Y+99xTi7y8PO65J5KlS53k5eWFbTBytxAuWXKyhXDNmjVh20JojKFLly5kZWV5lgKuUaMG3bt391wEhCfhyiu/pVOnZbz88oiCCsNq2rXbSuPGccC5VFQlpzKa958B3jTGrAO+wbo/3wiYCWCMeQNARIYXvB4P7MEazx8F3AgMAv4c2myrimSMITo6mm7dupGSksLdd3+MSBzJyclER0eH8X/eqnVx5W7xAavfR15eHlu2bPcE03DMu/u74Z1H92cI1++GMYZevXqRnZ1Nz549WbZsmecC0eFwhGWeRYRdu3axb98+AM/F1Zo1a2jSpAmdOnUKy3x36tSJVatW+bRqGmPo1KniasunSkSoUaMGERH7ueOOFzy3rABq1Eiq0IvvkAd9EXnPGFMXuB+rzXYLMFBEfi1I0szvkChgGtAEyMIK/peLyKchyrIKkV9//ZU//viDxETr7o+IsHHjRho1ahSWtQx3DXTNmjU4HA5Ph8k1a9YAhHUQtYLmycaycM2rW9W7XRU4z+HaAuTWuHFj9u3bx5o1azyTe7m3hyP3/8GtW7eSnJxMbm4ujRo1YsuWLWH9HTHG0KxZM/bu3UtOTg4ulwsRITo6mmbNmlVoniuljUlEXhKRFiISLSKdvXvyi0hvEent9XqqiLQWkRgRqSMiF2rAP/04nU5SUlI4fNiaf+nmm2/G6XRy+PBhUlJScDqdlZzDwNy1om7dujFmzBi6devmsz0cuX8o77rrYxITjwGwevXqMF357aSq1KLiVpXy7L4o6datG9nZ2Z6Jvbp16xa2Fyv+rUBgXcCGewuhMQaHw0GTJk18LgqbNGlS4S1BYd97X1UPdrud8847j3Xr1uF0OnnqqacAqFu3Luedd15YdnoyxhAREUFiYqJPs/OePXuIiIgIyx8c7yma/WtGEP41flXxqtKFClTNViARITs7m3379mGMwW6343Q62bdvHy1atKjQ5v3w7E2iqqWuXbsyduxYn21jx44tWP89/IgISUlJniZ9d6enzMxMkpKSwrLmXFVrRqri+d+uqlu3Lg6HgzVr1oR9S1BVu1ARETZv3kxeXh5nnHEGEydO5IwzziAvL4/NmzdXaFlrTV+FDZfLxXvvvefTs/m9995jyJAhYdnb2btD2ZYtWzy15XDuFAdVs2akQsP7dlXPnj1ZtWoVa9euDevbVVWRzWYjMTGRhIQEz+/bkCFDmDt3Lg6Ho0J/7zToq7DgcrmYO3cue/bsoW3btkycONHzeu7cuWEf+Ld4rfFZFQJoVasZqYpnjOGMM86gcePGnnv44T7ioCq75pprcLlcnt81d+Cv6N+58PsVVdWSzWbD4XDQokUL6tSp4/kP0KJFiwq/8j0V7iZRb+HeFKpUUTp37uzTac8d+MNx9MzpwP93LRS/c1rTV2HDfeW7fLk1mCNUV77l5d8pznvSGKgaNX6l/Gkr0OlNg74KK5Vx5VteVXHSGKVU9aZBX6lToJ3ilFJVSfhWo5SqIqpic6h/nwPtg6BU9aBBX6lqZsOGDT6dDd19EzZs2FDJOVNKVTRt3leqGnGvsuc9xNC7M2I4rrKnlAoeDfpKVSP+EwrVqVOHw4cPh/2EQkqp4NDmfaWqGe/A76YBX6nqQYO+UtWMTiikVPWlzftKVSO6yp5S1ZvW9JWqRnSVPaWqN63pK1XN6IRCSlVfWtNXqhqqihMKKaVOnQZ9pZRSqprQoK+UUkpVExr0lVJKqWpCg75SSilVTWjQV0oppaoJDfpKKaVUNaFBXymllKomNOgrpZRS1YQGfaWUUqqa0KCvlFJKVRMa9JVSSqlqQoO+UkopVU1o0FdKKaWqCQ36SimlVDWhQV8ppZSqJjToK6WUUtWEBn2llFKqmjAiUtl5qDDGmIPAr0E8ZT0gLYjnU4FpOYeOlnVoaDmHhpazpbmI1A+047QO+sFmjFkvIl0qOx+nOy3n0NGyDg0t59DQci6ZNu8rpZRS1YQGfaWUUqqa0KBfNrMqOwPVhJZz6GhZh4aWc2hoOZdA7+krpZRS1YTW9JVSSqlqQoO+UkopVU1o0C8lY8xfjTG7jTHZxpgNxpgLKztPVYUxZpIx5ltjzHFjzEFjzEJjTLJfGmOMmWKM+cMYk2WMWWqMOdsvTW1jzJvGmGMFjzeNMbVC+mGqkIJyF2PMC17btJyDxBjT0Bjzn4LvdLYxZpsx5iKv/VrWp8gYYzfGPOr127vbGPOYMSbCK42Wcxlo0C8FY8xg4HngCeBcYBWwyBjTrFIzVnX0Bl4CegJ9gXzgS2NMHa809wJ3AXcAXYEDwGJjTA2vNO8AnYBLCx6dgDcrOvNVkTGmOzAG+MFvl5ZzEBQEjG8AA1wOtMMq0wNeybSsT90/gNuBvwFtgb8XvJ7klUbLuSxERB8lPIC1wGy/bTuAf1Z23qriA4gHnMCVBa8NkALc55UmBkgHbi143Q4Q4HyvNBcUbGtT2Z8pnB5AArAL6AMsBV7Qcg56GT8BfFPMfi3r4JTzx8B//Lb9B/hYy7l8D63pl8AYEwV0Br7w2/UFVs1VlV0NrFamIwWvWwJJeJWxiGQByzlZxj2ADKxWFrdvgEz038HfLGC+iCzx267lHDyDgLXGmPeMMQeMMZuMMeOMMaZgv5Z1cKwE+hhj2gIYY9pjtRZ+WrBfy7mMIkpOUu3VA+zAfr/t+4F+oc/OaeF5YBOwuuB1UsHfQGXc2CvNQSm4TAcQETHGHPA6vtozxowGzgRuDLBbyzl4WgF/BZ4FngTOAWYU7HsBLetgeQqrkrDNGOPEilmPi8hLBfu1nMtIg74KKWPMM1hNaxeIiLOy83M6Mca0wWp2vkBE8io7P6c5G7BeRNz3ljcaY1pj3W9+oejDVBkNBoYDNwBbsS6unjfG7BaRf1dmxqoqbd4vWRrW/edEv+2JQGros1N1GWOeBf4C9BWRX7x2ucuxuDJOBep7NZ9S8LwB+u/g1gOrZWqrMSbfGJMPXAT8teD5oYJ0Ws6nLgXY5rftR8DduVe/08ExDZguInNFZLOIvAk8w8mOfFrOZaRBvwQikgtsAPr77eqP7z0iVQxjzPOcDPg/+e3ejfWfr79XegdwISfLeDVWB8AeXsf1AOLQfwe3/wF/wqoNuR/rgbkFz7ej5Rws3wBt/LadxcmlvPU7HRyxWJUub05Oxi4t57Kq7J6EVeGB1cSUC9yC1RP0eayOIc0rO29V4QG8CBzH6oCT5PWI90rzD+AYcA2QjBWo/gBqeKVZBGzG+g/bo+D5wsr+fOH8wKv3vpZzUMu1K5AH3IfVh+K6gnK9Xcs6qOX8OrAPa1hkC+D/gIPA01rO5SzTys5AVXlgddrZA+Rg1fx7VXaeqsoDa2hMoMcUrzQGmILVbJoNLAOS/c5TG3ir4ALieMHzWpX9+cL5ESDoazkHr2wvB74vKMftWGPJjZZ1UMu4BvAcVgtKFvALVr8Vh5Zz+R664I5SSilVTeg9faWUUqqa0KCvlFJKVRMa9JVSSqlqQoO+UkopVU1o0FdKKaWqCQ36SimlVDWhQV+pSmCM6WGM+a8x5g9jTK4x5pAxZrExZoQxxl6QZqQxRowxLbyO22OMed3vXFcaYzYbY7IL0tcyxtiMMc8ZY1KMMS5jzP8q8LO0KHjfkSWkc3+eMysqL+VljBlkjJkQYHvvgjzr4lrqtKAL7igVYsaY8Vjzh3+NNZvYr1iThwwAXgaOAh8Wcfj/YU0u4j5XBPA21nSit2PNHJkOXAv8HbgLaxrSQ4XOpLwNwlo185lKzodSFUqDvlIhZIzphRVYXhCRv/nt/rBgFcK4oo4XkY1+mxpjzVr2XxFZ7vU+7QqePiciriDkO1pEck71PEqpyqXN+0qF1j+Aw8C9gXaKyC4R+aGog72b940xU7Cmhgb4d0Ez9FJjzB6saUkBnN5N78aYhsaYN4wxacaYHGPMD8aYG/3ew90M38sYM88YcxRYW7Av1hjzUsHtiAxjzEdAk3KUQ5GMMWOMMd8X3K5IM8b82xhTxy+NGGMeM8b8zRiz2xiTboxZZow52y+dvSBdijHmhDHma2NM24LjpxSkeR0YATQu2C4FZegt1hjzQkF+0owxbxljagXzcysVClrTVypECu7V9wH+JyLZQTjlq8AWYB7wGPAJVtN/NNY88CM5ubLYLmNMHNa85LWBycBvwI3Am8aYWBGZ5Xf+t4F3sW4VuH8rXsFagOph4Fus1c3eCcJnAcAY8yTWLYl/AfdgtWQ8BiQbY3qKiPeKazcCP2PdxojCWob1Q2NMWxHJL0jzcMFnnQZ8CXQGPvJ720eB+liL6FxVsM2/VeN54GOsdd3bAFOxVnsbcSqfV6lQ06CvVOjUA2I4ufzqKRGRfcaYTQUvd4nIGvc+Y8zvBWm8t40DWgN9RGRpweZFxphE4DFjzL/9gup8EbnX6/g2WEHvPhF5smDzF8aYeGDsqX6egg6L9wAPi8gjXtu3AyuBK7GWD3bLA64QkbyCdGBdAJ0HrDLG1AbGAzNF5B8Fxyw2xuQCT7tPIiK7jDEHgVzv8vKzXETuKHj+RUFZ3GKMGSm6gImqQrR5X6nqoxfwu1fAd3sLq6bb3m/7Ar/X3bB+M/7rt31ukPLXv+D8bxtjItwPrFsL6Vj597bYHfALbC7426zg75+w+kfM8ztufjny9onf681YLSqJ5TiXUpVGa/pKhc4hrOVBm1fS+9fBWn7UX6rXfm/+aRsW/N3vt93/dXk1KPi7s4j9df1eH/Z77W6SdxT8def3gF+68uS3pPdSqkrQoK9UiIhIvjFmKdC/knrDH8a6H+0vyWu/N/9ma/dFQCLWuuZ4vQ4G97DCAcCRYvaXlju/DYCtXtu1dq6qLW3eVyq0nsSqsU4NtNMY09IY06GC3nsZ0MQYc77f9huwasPbSjh+LeACrvfbPiQ42WNxwfmbicj6AI/dZTzfZiATuM5vu/9rsGruMWXPslJVi9b0lQohEVleMPPbM8aY9sDrwF6sHvUXA7dgBeEih+2dgtexerp/YIy5D9gHDMW6l36rXye+QHn/2RjzDvCIMcaG1Xt/ADCwjPm41BiT6rftmIgsNsY8BbxQ0FFuGZANNC3I46sisqS0byIiR4wxzwGTjTHpWL33OwE3FyTxnr9gG1DHGHMbsB7IFpHNKHWa0aCvVIiJyHPGmHXAncB0rF796VjB5lZgYQW9b6Yx5iKsVoYnsSb1+RkYJiJvlfI0twIZwN1Yw+S+xrpIWVmGrMwIsG0rkCwik40xP2LNLng71i2G34CvgB1leA+3hwCDFej/htVaMRL4Bjjmle5VoDvwBFALa4RFi3K8n1JhzehoE6VUdWKMuRarR38vEVlR2flRKpQ06CulTlvGmG7A5Vg1/GysyXkmYrVw9NQx9qq60eZ9pdTpLANrfP/tQE2sDov/BSZpwFfVkdb0lVJKqWpCh+wppZRS1YQGfaWUUqqa0KCvlFJKVRMa9JVSSqlqQoO+UkopVU1o0FdKKaWqif8Hm99tR797MIgAAAAASUVORK5CYII=", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Analysis Result: StandardRB\n", @@ -616,20 +611,26 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" } ], - "metadata": {} + "source": [ + "# Print sub-experiment data\n", + "for i in range(par_exp.num_experiments):\n", + " print(par_expdata.component_experiment_data(i).analysis_results(0), '\\n')\n", + " display(par_expdata.component_experiment_data(i).figure(0))" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## References\n", "\n", @@ -645,15 +646,14 @@ "\n", "[5] Jay M. Gambetta, A. D. C´orcoles, S. T. Merkel, B. R. Johnson, John A. Smolin, Jerry M. Chow, Colm A. Ryan, Chad Rigetti, S. Poletto, Thomas A. Ohki, Mark B. Ketchen, and M. Steffen, *Characterization of addressability by simultaneous randomized benchmarking*, https://arxiv.org/pdf/1204.6308\n", "\n" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, - "source": [], + "metadata": {}, "outputs": [], - "metadata": {} + "source": [] } ], "metadata": { @@ -661,9 +661,9 @@ "hash": "42e50baa22dbe56fc7f4f6bf32ac20952839a6a23dcf2ef84eded7e8cac03444" }, "kernelspec": { - "display_name": "qiskit37", + "display_name": "Python 3", "language": "python", - "name": "qiskit37" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -675,9 +675,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.7.6" } }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/docs/tutorials/resultsdb_tutorial.ipynb b/docs/tutorials/resultsdb_tutorial.ipynb new file mode 100644 index 0000000000..a1b710fa93 --- /dev/null +++ b/docs/tutorials/resultsdb_tutorial.ipynb @@ -0,0 +1,877 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Saving Experiment Data to the Cloud" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Qiskit Experiments is designed to work with Qiskit's online experiment database, where you can view and share results of experiments you've run. This tutorial shows how to save your experimental results to the database. You will need to have `qiskit-ibmq-provider` installed locally and an account in the Qiskit cloud service. We will use the `ibmq_armonk` backend which is open and available to everyone." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "outputs": [], + "source": [ + "from qiskit import IBMQ\n", + "\n", + "IBMQ.load_account()\n", + "provider = IBMQ.get_provider(hub=\"ibm-q\", group=\"open\", project=\"main\")\n", + "backend = provider.get_backend(\"ibmq_armonk\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## T1 Experiment\n", + "\n", + "Let's run a T1 experiment and save the results to the experiment database." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ┌───┐ ░ ┌──────────────┐ ░ ┌─┐\n", + "q_0: ┤ X ├─░─┤ Delay(0[us]) ├─░─┤M├\n", + " └───┘ ░ └──────────────┘ ░ └╥┘\n", + "c: 1/════════════════════════════╩═\n", + " 0 \n" + ] + } + ], + "source": [ + "from qiskit_experiments.library.characterization import T1\n", + "\n", + "t1_delays = list(range(0, 800, 50))\n", + "\n", + "# Create an experiment for qubit 0,\n", + "# setting the unit to microseconds,\n", + "# with the specified time intervals\n", + "exp = T1(qubit=0, delays=t1_delays, unit=\"us\")\n", + "print(exp.circuits()[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Let's run the experiment. `block_for_results()` blocks execution until the experiment is complete, then `save()` is called to save the data to ResultsDB." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the experiment circuits with 1000 shots each,\n", + "# and analyze the result\n", + "\n", + "t1_expdata = exp.run(backend=backend, shots=1000).block_for_results()\n", + "t1_expdata.save()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that calling `save()` before the experiment is complete will instantiate an experiment entry in the database, but it will not have complete data. To fix this, you can call `save()` again once the experiment is done running." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our T1 figure and analysis results:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true, + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "{'value': 0.000208167519396112,\n", + " 'stderr': 6.911222830912447e-06,\n", + " 'unit': 's',\n", + " 'label': 'T1',\n", + " 'fit': {'popt': array([8.39666449e-01, 2.08167519e-04, 6.63064336e-02]),\n", + " 'popt_keys': ['a', 'tau', 'c'],\n", + " 'popt_err': array([9.45331195e-03, 6.91122283e-06, 6.90642194e-03]),\n", + " 'pcov': array([[ 8.93651068e-05, 1.32876205e-08, -3.28388193e-05],\n", + " [ 1.32876205e-08, 4.77650010e-11, -4.02667425e-08],\n", + " [-3.28388193e-05, -4.02667425e-08, 4.76986640e-05]]),\n", + " 'reduced_chisq': 0.5661772016311409,\n", + " 'dof': 13,\n", + " 'xrange': [0.0, 0.00075],\n", + " 'circuit_unit': 'us'},\n", + " 'quality': 'bad',\n", + " 'success': True}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(t1_expdata.figure(0))\n", + "t1_expdata.analysis_results(0).data()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "You can also view the results at the [IBM Quantum Experiments pane](https://quantum-computing.ibm.com/experiments?date_interval=last-90-days&owner=me) on the cloud." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, the interface displays all experiments you have privilege to see, but this link shows your own experiments. You can change that setting by clicking on the All Experiments dropdown. You can also filter by device, date, provider, and result by clicking on the filter icon." + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Individual experiment pages show the plot, and one or more important analysis results, which for the T1 experiment is the fitted T1 value." + ] + }, + { + "attachments": { + "image-4.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image-4.png](attachment:image-4.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can change the quality and verify/unverify the results upon selection of an analysis result. Quality is an automatic parameter generated by the experiment analysis based on pre-set criteria; in this case the T1 fit is considered bad because the amplitude parameter is not close enough to 1. The verification field is for a human to determine whether the result is acceptable." + ] + }, + { + "attachments": { + "Screen%20Shot%202021-07-21%20at%204.53.56%20PM.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Screen%20Shot%202021-07-21%20at%204.53.56%20PM.png](attachment:Screen%20Shot%202021-07-21%20at%204.53.56%20PM.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load an experiment from the database" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also load the full saved experiment from the database service. Let's load an [example public experiment](https://quantum-computing.ibm.com/experiments/6cc66a03-de43-4d36-9c39-f56d5ee8c011):" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_experiments.database_service import DbExperimentDataV1 as DbExperimentData\n", + "\n", + "load_exp = DbExperimentData.load(\"6cc66a03-de43-4d36-9c39-f56d5ee8c011\", provider.service(\"experiment\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To display the figure, which is serialized into a string, we need the SVG library:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " 2021-07-21T14:42:53.789392\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.4.2, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import SVG\n", + "SVG(load_exp.figure(0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We've also retrieved the full analysis results from the database:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'fit': {'dof': 13,\n", + " 'pcov': array([[ 9.25590417e-05, 1.69155694e-08, -3.72037925e-05],\n", + " [ 1.69155694e-08, 5.49557488e-11, -4.59738214e-08],\n", + " [-3.72037925e-05, -4.59738214e-08, 5.31552561e-05]]),\n", + " 'popt': array([8.27525912e-01, 2.15400430e-04, 7.05351749e-02]),\n", + " 'xrange': [0, 0.00075],\n", + " 'popt_err': array([9.62076097e-03, 7.41321447e-06, 7.29076513e-03]),\n", + " 'popt_keys': ['a', 'tau', 'c'],\n", + " 'circuit_unit': 'us',\n", + " 'reduced_chisq': 1.3609095467472334},\n", + " 'unit': 's',\n", + " 'label': 'T1',\n", + " 'value': 0.00021540042996137575,\n", + " 'stderr': 7.413214470196464e-06,\n", + " 'quality': 'bad',\n", + " 'success': True}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "load_exp.analysis_results(0).data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Auto save an experiment" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "There is also the `auto_save` feature, which saves the data of an experiment preemptively. In the future, you will be able to set `provider.experiment.set_option(auto_save=True)` to turn `auto_save` on by default at the experiment service level." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": false, + "slideshow": { + "slide_type": "-" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Not all post-processing has finished. Consider calling save() again after all post-processing is done to save any newly generated data.\n", + "Analysis result cannot be saved because no experiment service is available.\n" + ] + } + ], + "source": [ + "exp = T1(qubit=0, delays=t1_delays, unit=\"us\")\n", + "\n", + "t1_expdata = exp.run(backend=backend, shots=1000)\n", + "t1_expdata.auto_save = True\n", + "t1_expdata.block_for_results()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## RB Experiment\n", + "Let's now do a standard RB experiment and save the results to ResultsDB." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import qiskit_experiments as qe\n", + "\n", + "rb = qe.library.randomized_benchmarking\n", + "\n", + "lengths = np.arange(1, 1000, 200)\n", + "num_samples = 10\n", + "seed = 1010\n", + "\n", + "rb_exp = rb.StandardRB([0], lengths, num_samples=num_samples, seed=seed)\n", + "rb_expdata = rb_exp.run(backend)\n", + "rb_expdata.block_for_results()\n", + "rb_expdata.save()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "{'analysis_type': 'RBAnalysis',\n", + " 'popt': array([9.36670735e-01, 9.99551934e-01, 6.66037165e-14]),\n", + " 'popt_keys': ['a', 'alpha', 'b'],\n", + " 'popt_err': array([1.52118353e+00, 8.28652723e-04, 1.52343583e+00]),\n", + " 'pcov': array([[ 2.31399934e+00, 1.25843445e-03, -2.31739302e+00],\n", + " [ 1.25843445e-03, 6.86665336e-07, -1.26048728e-03],\n", + " [-2.31739302e+00, -1.26048728e-03, 2.32085673e+00]]),\n", + " 'reduced_chisq': 0.11955890357808392,\n", + " 'dof': 2,\n", + " 'xrange': [1.0, 801.0],\n", + " 'success': True,\n", + " 'EPC': 0.00022403283474575764,\n", + " 'EPC_err': 0.0004145120902580399,\n", + " 'EPG': {0: {'rz': 0.0,\n", + " 'sx': 7.250382396729012e-05,\n", + " 'x': 7.250382396729012e-05}}}" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(rb_expdata.figure(0))\n", + "rb_expdata.analysis_results(0).data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is the view of the same job on the database service:" + ] + }, + { + "attachments": { + "Screen%20Shot%202021-07-21%20at%204.52.06%20PM.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABkUAAAN8CAYAAADmpa2SAAAKJWlDQ1BJQ0MgUHJvZmlsZQAASImVlgdUFFcXx+/M9kZbel16720B6b1JkS4qyy4dVliqiA0JKhgLIiKoRCQIomA0AhIrolhRUMQekCCgxGABCyqZFaPJl3O+73z3nDf3N3fe3Hff3HfO/AFodZz09FRUDCCNnyUI9nRhRURGsUi/ARloQAUGqHO4menOgYF+gNlf/p82fRsQob9pKMz17+f/1SR4cZlcACQa41ReJjcN44sYO3DTBVkAKBlj9dysdCEbYCwpwArE2EnICXMcIuTYOU78PCck2BXjAgAyncMRJABQ12NxVg43ActDbcDYhM9L4mN85/NaiRweAE0WY4O0tKVCdsNYB5ufjrFwT+zYv+VM+Ef+2K/5OZyErzy3r7k9hkWYWVhas1w5qUmxAk5WHO///Ej/y9JSs/9aS9gJehw/dAHm1bChCGEQAWZgAZZgDSxwBQ6kQhLEggCjLIgDrJisuLws4cuuS9OXCZISErNYzlgn41jefK6RAcvMxMwEQHgu5paYvvWl387fYgV6AE4EAELvt1gk1pcjdQBKXd9iqhEAjDCAlkputiBnLoYXXgjYaRMFSZADZVAHHTDEarYCO3ACd/CBAAiBSFgMXEiENKzyXCiANVAMpbAFtkMV1MA+aIBDcATa4ASchQtwBW5AP9yHQRiBZzAJ0zCDIAgJYSBMRA5RQTQRfcQMYSMOiDvihwQjkUgMkoDwkWykAFmLlCJlSBWyF2lEfkKOI2eRS0gvchcZQsaRl8h7FIfSUUlUCdVCjVE26oz6oiHoIjQBzUDz0SJ0E1qJ1qIH0Vb0LHoF7UcH0WfoFA5wNJw0ThVniGPjXHEBuChcPE6AW4krwVXganHNuA5cN+4mbhA3gXuHJ+KZeBbeEG+H98KH4rn4DPxK/EZ8Fb4B34rvwt/ED+En8Z8IDIIiQZ9gS/AmRBASCLmEYkIFoZ5wjHCe0E8YIUwTiURpojbRmuhFjCQmE5cTNxJ3E1uIZ4i9xGHiFIlEkiPpk+xJASQOKYtUTNpJOkg6TeojjZDekmlkFbIZ2YMcReaTC8kV5APkU+Q+8ih5hiJG0aTYUgIoPMoyymZKHaWDcp0yQpmhilO1qfbUEGoydQ21ktpMPU99QH1Fo9HUaDa0IFoSbTWtknaYdpE2RHtHl6Dr0V3p0fRs+ib6fvoZ+l36KwaDocVwYkQxshibGI2Mc4xHjLciTBEjEW8RnsgqkWqRVpE+keeiFFFNUWfRxaL5ohWiR0Wvi06IUcS0xFzFOGIrxarFjosNiE2JM8VNxQPE08Q3ih8QvyQ+JkGS0JJwl+BJFEnskzgnMczEMdWZrkwucy2zjnmeOSJJlNSW9JZMliyVPCTZIzkpJSFlIRUmlSdVLXVSalAaJ60l7S2dKr1Z+oj0ben3MkoyzjJxMhtkmmX6ZN7IKsg6ycbJlsi2yPbLvpdjybnLpchtlWuTeyiPl9eTD5LPld8jf15+QkFSwU6Bq1CicEThniKqqKcYrLhccZ/iVcUpJWUlT6V0pZ1K55QmlKWVnZSTlcuVTymPqzBVHFSSVMpVTqs8ZUmxnFmprEpWF2tSVVHVSzVbda9qj+qMmrZaqFqhWovaQ3WqOls9Xr1cvVN9UkNFw1+jQKNJ454mRZOtmai5Q7Nb842Wtla41jqtNq0xbVltb+187SbtBzoMHUedDJ1anVu6RF22borubt0beqiepV6iXrXedX1U30o/SX+3fq8BwcDGgG9QazBgSDd0NswxbDIcMpI28jMqNGozem6sYRxlvNW42/iTiaVJqkmdyX1TCVMf00LTDtOXZnpmXLNqs1vmDHMP81Xm7eYvLPQt4iz2WNyxZFr6W66z7LT8aGVtJbBqthq31rCOsd5lPcCWZAeyN7Iv2hBsXGxW2ZyweWdrZZtle8T2DztDuxS7A3Zj87Tnxc2rmzdsr2bPsd9rP+jAcohx+MFh0FHVkeNY6/jYSd2J51TvNOqs65zsfND5uYuJi8DlmMsbV1vXFa5n3HBunm4lbj3uEu6h7lXujzzUPBI8mjwmPS09l3ue8SJ4+Xpt9RrwVvLmejd6T/pY+6zw6fKl+y7wrfJ97KfnJ/Dr8Ef9ffy3+T+YrzmfP78tAAK8A7YFPAzUDswI/CWIGBQYVB30JNg0uCC4ewFzwZIFBxZMh7iEbA65H6oTmh3aGSYaFh3WGPYm3C28LHwwwjhiRcSVSPnIpMj2KFJUWFR91NRC94XbF45EW0YXR99epL0ob9GlxfKLUxefXCK6hLPkaAwhJjzmQMwHTgCnljMV6x27K3aS68rdwX3Gc+KV88bj7OPK4kbj7ePL4scS7BO2JYwnOiZWJE4kuSZVJb1I9kquSX6TEpCyP2U2NTy1JY2cFpN2nC/BT+F3LVVemre0N10/vTh9MMM2Y3vGpMBXUJ+JZC7KbM+SxH7AV7N1sr/LHspxyKnOeZsblns0TzyPn3d1md6yDctG8z3yf1yOX85d3lmgWrCmYGiF84q9K5GVsSs7V6mvKlo1stpzdcMa6pqUNdcKTQrLCl+vDV/bUaRUtLpo+DvP75qKRYoFxQPr7NbVrMevT1rfs8F8w84Nn0p4JZdLTUorSj9s5G68/L3p95Xfz26K39Sz2Wrzni3ELfwtt7c6bm0oEy/LLxve5r+ttZxVXlL+evuS7ZcqLCpqdlB3ZO8YrPSrbN+psXPLzg9ViVX91S7VLbsUd23Y9WY3b3ffHqc9zTVKNaU1739I+uHOXs+9rbVatRX7iPty9j2pC6vr/pH9Y2O9fH1p/cf9/P2DDcENXY3WjY0HFA9sbkKbspvGD0YfvHHI7VB7s2Hz3hbpltLDcDj78NOfYn66fcT3SOdR9tHmnzV/3nWMeaykFWld1jrZltg22B7Z3nvc53hnh13HsV+Mftl/QvVE9Umpk5tPUU8VnZo9nX966kz6mYmzCWeHO5d03j8Xce5WV1BXz3nf8xcveFw41+3cffqi/cUTl2wvHb/Mvtx2xepK61XLq8euWV471mPV03rd+nr7DZsbHb3zek/1Ofadvel288It71tX+uf3994OvX1nIHpg8A7vztjd1Lsv7uXcm7m/+gHhQclDsYcVjxQf1f6q+2vLoNXgySG3oauPFzy+P8wdfvZb5m8fRoqeMJ5UjKqMNo6ZjZ0Y9xi/8XTh05Fn6c9mJop/F/9913Od5z//4fTH1cmIyZEXghezLze+knu1/7XF686pwKlH02nTM29K3sq9bXjHftf9Pvz96EzuB9KHyo+6Hzs++X56MJs2O5vOEXA+SwEcNtD4eICX+zGdEAnAvIHpqYVzuu2LvkFUzL8qnb8Yxi584+66OW332awA9g0AhCwH8LsGsLMKQAvLL4rpzUBRLG4HyDT+6/himfHmZl/WEMbQ2dnZD0IPMPvZvkwT3o/O6UWhRWEa7LipkO7Lev1Lo81pyb/t8T89fK3gH/5PM1HJsDXsaPkAAABWZVhJZk1NACoAAAAIAAGHaQAEAAAAAQAAABoAAAAAAAOShgAHAAAAEgAAAESgAgAEAAAAAQAABkWgAwAEAAAAAQAAA3wAAAAAQVNDSUkAAABTY3JlZW5zaG90TXvuZAAAAddpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iPgogICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+ODkyPC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxYRGltZW5zaW9uPjE2MDU8L2V4aWY6UGl4ZWxYRGltZW5zaW9uPgogICAgICAgICA8ZXhpZjpVc2VyQ29tbWVudD5TY3JlZW5zaG90PC9leGlmOlVzZXJDb21tZW50PgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KGsfXHgAAQABJREFUeAHs3QeYJFXVBuCzZJCcRLJEAck55wxKzhhAJEkOEiUpCMiPoGQlKiA5CihhyTmLsKCLBImSWUBY4K9TYw09sxN6Z3Z2unfe+zyzHarq1u23eni0vjn3Dpp22mm/DI0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMIYLjDWGfz4fjwABAgQIECBAgAABAgQIECBAgAABAgQIECBQCghFfBEIECBAgAABAgQIECBAgAABAgQIECBAgACBASEgFBkQl9mHJECAAAECBAgQIECAAAECBAgQIECAAAECBIQivgMECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAgBAQigyIy+xDEiBAgAABAgQIECBAgAABAgQIECBAgAABAkIR3wECBAgQIECAAAECBAgQIECAAAECBAgQIEBgQAgIRQbEZfYhCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAaGI7wABAgQIECBAgAABAgQIECBAgAABAgQIECAwIASEIgPiMvuQBAgQIECAAAECBAgQIECAAAECBAgQIECAgFDEd4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYEAJCkQFxmX1IAgQIECBAgAABAgQIECBAgAABAgQIECBAQCjiO0CAAAECBAgQIECAAAECBAgQIECAAAECBAgMCIFxevopJ5tssphvvvnKw99///3429/+1trVTDPNFPmT7aWXXip/qo3f/va3Y9JJJy1fPvXUU/Hee+9VmzwSIECAAAECBAgQIECAAAECBAgQIECAAIGGEMh72Xl/u9nuYef993nmmSeWWmqp8jExn3766bjvvvvKx7yf3+gtP8PGG28cSy65ZDnU+++/P84555xRMuxB00477Zc96WmZZZaJK6+8sjz0nnvuiQ033LC1m/322y/23Xff8vWvfvWrOP7441u35TF5bLY8Jo/VCBAgQIAAAQIECBAgQIAAAQIECBAgQIBAfwvkveu8t73sssu2DiWDkRtuuCHyXnejByRrrLFGHHfccWVhQgYJf//738vPMe+885YBQwYi+++/f/zlL39p/XyN9mTGGWeM008/PQYNGlQGOTnm/Fxffvll7LTTTvHyyy/3asg9rhTp1VkdTIAAAQIECBAgQIAAAQIECBAgQIAAAQIEGkQgZ0Y68sgjY4sttog//elPsccee8SLL75Yji4Dknx/8803j4022qjNrEkNMvwyBMkwJMODk046qfzpaGz5uTJwyFAkw5FGrBrJIosMdI466qjWj5Cf6dBDDy0Dn6222qr1/Z486XEoklhVlUdOg1XbMjmrtuXz2la7byOC147VcwIECBAgQIAAAQIECBAgQIAAAQIECBAY8wXyBvzaa6/d4exGea/7zDPPLG/SX3HFFQ0ZjGSQkBUW6623Xmt1SEdXLcOFv/71r+XsThmiZOVFI7WqomXHHXccYVg59sceeyxyn6oCZoSd6nijx9Nn1dF3w+9SleFUA83A5qc//Wn58tJLL40JJ5yw2hTPPfdcXH755XHXXXe1vpfJ1KKLLhrbb799vPXWW63v55MDDjgglltuuTJB/PDDD9tsq15k+U8eu/7668css8wSzz//fFx99dVx7rnnVruMtseVVlopcpwPPfTQaDunExEgQIAAAQIECBAgQIAAAQIECBAgQKC/BaqlIupZ7iGXh8hpnLJipFFaVodk9UdtIJLBwSGHHFKuK5LjzCmnTj755LjsssvKYef26667rgxFGmkqrWr6r4UWWqhD3qFDh0ZWiuT6KD1tY/X0wDHhuDfffLP8YuSiLRl2/O53v2v9WIssskhcddVVceyxx5Y/GRaccsopseaaa7buM9dcc0X+VEFKtSG/UFtvvXUsvvjiMfbYY1dvt3kca6yx4ve//30cccQRMc4448Stt94aE0wwQRx99NFxxhlnlPOltTmgj1/kZ6vWgenjU+meAAECBAgQIECAAAECBAgQIECAAAECDSOQa2TnlFnV7EddDWz33Xcv1xvJRdgboeW97az4yCqK2uqJ6h5zVoJkiJDTUeV+ee86W+6bx+R72UejtJxdqq/HM6BDkf/+979luc1HH31Uzg+X1SC17fHHH48777yz/PnjH/8YgwcPbhOK5L5nnXVW+UvwrW99q/XQLLX62c9+1vq6oyfbbLNNrLvuumXwko977713WZ715z//OTbYYIOywiSPW3rppeO2226L733ve63dnH/++XH99de3vl5qqaXikksuiSFDhpSPGcjUthtvvDHOPvvs2HjjjcsE7dFHHy1Tw9wnq2UefvjhmHrqqcsQJ881zzzzlFUy+fz//u//Wrvaa6+9yrHMOeec5Xu//OUvy9crrLBC3HTTTWU/2267bUw11VRltcuzzz4b5513Xkw00UStfXhCgAABAgQIECBAgAABAgQIECBAgACBRhLISpF6ApEccy4XkVUXOdVWI7QMOTJEyICjts0wwwzle1kFklUVGfx88MEHraFI7pvH5LFVUFJ7fH89z7H++9//jk022WSEIeR7ua03VSLZaY/XFJlpppnKhWWyk/wSXHzxxfm0bPklyp9s+WWq/ULlgjR5Iz5bpm/t1xwpNzTgP3PPPXesttpq5ZendniffPJJmaZlxUcutLPWWmtFvnf77bfX7jbC8wUXXLB8L8OE2pZf0pxOq0oaJ5544vJLOc0007TuNvvss8d0001Xvs4pvrLiJM+ZfWVAkUHGE088EU8++WS5T4YcOT3X17/+9XKKrpVXXrlclCbLoz7//PN44YUXymvy2WefRVbPDB8+PLKSJX8Z3n777dbzTj/99OV71bRiM888c/k6K2VeffXVcsxZ6ZKhTh6X/aXHKqusUpZitXbkCQECBAgQIECAAAECBAgQIECAAAECBBpAIBdYz1Ytql7PkEZm33r6680+Sy65ZFkF0r6PrA6prRzJ8GOSSSYZYWH1rCDJPnobNLQ/f29eZ4CTlS5ZiJDjy+qR1VdfPTbddNPoaK2RkT1Xr0KRHFy2DD1qQ5Fll122dSqmX/3qV21CkQwOagOTRg5Fqvnh8jOON954ceGFF0ZWXbRv1157bfl5Mx3MCpFddtml/S4jvM5QKVvOgVbb/vnPf5YvM3Cop3388cdlFUke9+6775a2Oe5MzapQJPvJee5yTrxPP/20rOLIsWY4lYHWdtttV1aZ5CI1GVpl+9rXvlY+1vPP/vvvH7key89//vPYYYcdWkuxssolpyDL70MGMBoBAgQIECBAgAABAgQIECBAgAABAgQaSeC9995rpOGM9FjyD9trw4+qgyrkyFmG8o/9c62OrBSp3q/2y2MbqVIkx5VjzNmVck3vDEJq38v72b1tA3r6rO7wMtzIxdLzZ7PNNosFFlggDjvssBEO++KLLyLDnzPPPLMMOXJ6qu5aTt2VLdcTqW3jjjtu+TIrP+ptjzzySGQ51I9+9KPyC57HVaFL1UdWgGQgki2ntcpWTYNVvujFP6+88kp59DPPPFM+vvbaa+Xj008/XT5mZYtGgAABAgQIECBAgAABAgQIECBAgACBRhTIG+35h931tvyj/0b+Y//az5FVILlO9uWXX14GDVl10Qwtr0lWheSMS/mTz0dFIJKfve0d+ZHQyIueQUC29l+Au+++u7Wn2uf5Zu2CNe2Paz2oQZ7klFA5tVS2fDzttNPiyCOP7DAYyWqRffbZp9Wku4+Qc59ly6QuKzSqll/SbFWwUL3f2WOu35HVK9NOO225pkcVfHS2f76fIU5ftPb9tn/dF+fUJwECBAgQIECAAAECBAgQIECAAAECBHojcMMNN5RLI+QfvXdXOfLjH/+4nM4pj2mElpUeeY+5q5ZhQvs1R6r9s0qkffVIta2/Hn/4wx+W615Xy3BU48jPkX+If84551Rv9eixV6HI8ccf3+FJ268jUrtT7TRbte83w/Os7mhf2VGNOwOAvFjV9FfV+5093nzzzeX+WQaUFzH7nmCCCWKdddYpD8nt2bLCI1vtF6Ba0yPfz2mwcqqtnLYr51nL5w8++GBu6lXLSpUPP/ywTcVJ7Xl71bmDCRAgQIAAAQIECBAgQIAAAQIECBAg0CACeZ87l33IP4jfY489Oh1VrgO97777Ru7fXXjSaSejeEOuudHVmLNC5K9//WunZ80/0u8sMOn0oD7akOuenH766eU96Vx7Oz9bbcvtuRREri+y0047jbA+Su2+XT3vcSjSVadjyrZcRySDimwZNiR4Vwuo1xuIZH+33HJLPP7447HEEktETn+Vi6RnwDHllFOWFR933HFH7lYumJ5rhWRY8txzz5XhSC66XlWEVCVDiy66aFlGtOWWW5bbZptttnIuuI7mkys7rvkn55J76623yi/bzjvvHOeff34MGzYsssonS6tyEfmsXMl55zQCBAgQIECAAAECBAgQIECAAAECBAiMSQIZcOR6zLlWcy5LkCFD+1mOskIkA5FcmL2RpqDK+795fzfH3FG4kcs15LrUHbU8Jo+t5x5yR8eP6vdyDZEcz/LLL99p10cddVRZHHDIIYdErnXdkzag1xTJNTUyVFhooYXKaa8yNattV1xxRTltVk6dlSFGVk8k9qhoufB5LhJz9dVXRyZcW2+9dUw88cSR58zFznN7tqxAOe6442L48OHltF35JX7xxRdbh3DnnXeWgUqGJjmF15AhQ+LEE0+MXMdjscUWa92vqyeff/55HHvssZGVIIcffng5ntw/K0+yv0zdNthgg9Kgq35sI0CAAAECBAgQIECAAAECBAgQIECAQDMK/O1vfyuDkUGDBsVDDz1U/uS92vx5/fXXY7/99ivvIVfhQ97DbYSWAU2OLcfV0YLpOXNTR7M35b55TB7bKCHPxhtv3GGw0945w59NNtmk/dt1vx5UrEXRcve97kNadsxSoSwnypZJUm1YkF+IXJg82yWXXNIG/ec//3nrxckpn/LLNtDbqquuGhdeeGGkTa5bkgFI+5ZhyBRTTBFvvPFG+03l60woM7SpFnDvcKcevjn99NOXlSLWCOkhoMMIECBAgAABAgQIECBAgAABAgQIEGgagbz3nbP6VC2rRnINkWrKrLz/nTfmM1ToKHCojhudj/kH7jPMMENZPVFb+bHrrruWwzjllFNah5OBSP4hfq57nQuYN0LLdVHyHnnOgFRPGzp0aGy11VY9Wg+lx9NnZXXDsssuW44v07PaliVG1bZ77723dlPMN998scwyy5TvZR9alBeuqkLZc889yyqP9i6fffZZp4FI7lv9QrY/blS8fuWVV0ZFN/ogQIAAAQIECBAgQIAAAQIECBAgQIBAwwvkH/J39cf8VRBSTVdVve7PD5YVH7nWyXXXXVcGNtXYasOQHF8GOfmT64zkMQOx9TgUGYhYffWZc/2OnCct1++o1jDpq3PplwABAgQIECBAgAABAgQIECBAgAABAgR6J1AFIVX4UL3uXa89PzqnwMqqj1wXOsORDD7uu+++1vVCsjokqzFyzY5cLiEXMh+orcfTZ+V0TVn1kS3Ba5OzrBTJn2xZWlS7KE2WHlUVIk899VSfVjiUA/APAQIECBAgQIAAAQIECBAgQIAAAQIECBDoA4GcSqu7ypI+OG2XXeb99wxBllxyydalLHJKrfvvv78MSRplDZHaD5HjzYXWt9xyy9q3O31+0UUXRS66XjtVWKc7t9vQ41CkXT9eEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQaWmCshh6dwREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIERpGAUGQUQeqGAAECBAgQIECAAAECBAgQIECAAAECBAgQaGwBoUhjXx+jI0CAAAECBAgQIECAAAECBAgQIECAAAECBEaRgFBkFEHqhgABAgQIECBAgAABAgQIECBAgAABAgQIEGhsAaFIY18foyNAgAABAgQIECBAgAABAgQIECBAgAABAgRGkYBQZBRB6oYAAQIECBAgQIAAAQIECBAgQIAAAQIECBBobAGhSGNfH6MjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIERpGAUGQUQeqGAAECBAgQIECAAAECBAgQIECAAAECBAgQaGwBoUhjXx+jI0CAAAECBAgQIECAAAECBAgQIECAAAECBEaRgFBkFEHqhgABAgQIECBAgAABAgQIECBAgAABAgQIEGhsAaFIY18foyNAgAABAgQIECBAgAABAgQIECBAgAABAgRGkYBQZBRB6oYAAQIECBAgQIAAAQIECBAgQIAAAQIECBBobAGhSGNfH6MjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIERpGAUGQUQeqGAAECBAgQIECAAAECBAgQIECAAAECBAgQaGyBQV8WrbGHaHQECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgd4LqBTpvaEeCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgSYQEIo0wUUyRAIECBAgQIAAAQIECBAgQIAAAQIECBAgQKD3AkKR3hvqgQABAgQIECBAgAABAgQIECBAgAABAgQIEGgCAaFIE1wkQyRAgAABAgQIECBAgAABAgQIECBAgAABAgR6LyAU6b2hHggQIECAAAECBAgQIECAAAECBAgQIECAAIEmEBCKNMFFMkQCBAgQIECAAAECBAgQIECAAAECBAgQIECg9wJCkd4b6oEAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoAgGhSBNcJEMkQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEei8gFOm9oR4IECBAgAABAgQIECBAgAABAgQIECBAgACBJhAQijTBRTJEAgQIECBAgAABAgQIECBAgAABAgQIECBAoPcCQpHeG+qBAAECBAgQIECAAAECBAgQIECAAAECBAgQaAIBoUgTXCRDJECAAAECBAgQIECAAAECBAgQIECAAAECBHovIBTpvaEeCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgSYQEIo0wUUyRAIECBAgQIAAAQIECBAgQIAAAQIECBAgQKD3AkKR3hvqgQABAgQIECBAgAABAgQIECBAgAABAgQIEGgCAaFIE1wkQyRAgAABAgQIECBAgAABAgQIECBAgAABAgR6LyAU6b2hHggQIECAAAECBAgQIECAAAECBAgQIECAAIEmEBCKNMFFMkQCBAgQIECAAAECBAgQIECAAAECBAgQIECg9wJCkd4b6oEAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoAgGhSBNcJEMkQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEei8gFOm9oR4IECBAgAABAgQIECBAgAABAgQIECBAgACBJhAQijTBRTJEAgQIECBAgAABAgQIECBAgAABAgQIECBAoPcCQpHeG+qBAAECBAgQIECAAAECBAgQIECAAAECBAgQaAIBoUgTXCRDJECAAAECBAgQIECAAAECBAgQIECAAAECBHovIBTpvaEeCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgSYQEIo0wUUyRAIECBAgQIAAAQIECBAgQIAAAQIECBAgQKD3AkKR3hvqgQABAgQIECBAgAABAgQIECBAgAABAgQIEGgCAaFIE1wkQyRAgAABAgQIECBAgAABAgQIECBAgAABAgR6LyAU6b1hw/YwfPjwOPDAA+Ptt99u2DEaGAECBAgQIECAAAECBAgQIECAAAECBAgQGF0CQpHRJd0P53n44Yfj2muvjSmmmKIfzu6UBAgQIECAAAECBAgQIECAAAECBAgQIECgsQSEIh1cjwf/EfHeRx1saLK3brvttlhxxRVj0KBBTTZywyVAgAABAgQIECBAgAABAgQIECBAgAABAqNeYJxR3+XI9Xj05RGPPDfiMYduEbHgrCO+PzreOfDsiF2+E7HRUqPjbCOe4/0ikHn9vYg5vzHitpF5J0ORHXbYYWQOsS8BAgQIECBAgAABAgQIECBAgAABAgQIEBhjBfo9FBn6SsQ3p4v47pJtjWedtu3r0fnqhqMixh17dJ6x7bnuezbij4Mjztuz7fsj8yrXEXnyySdjpZVWGpnD7EuAAAECBAgQIECAAAECBAgQIECAAAECBMZYgYaYPmvmIgBZbp62P5NNFPHm+xEb/iLi7y995X/e4IiD/tDy+t4hEbueEXH5vRGrHBix0k8jzr71q33z2ctvRXz/1xFL7B6x3pERtz/11fZh/41Y94iI516NOOSPEcdd2bJtz99FZN/Zqn1uejRihf0iVj4g4sI7WqbX2vn0Ysz7RPzisois7qjaJ59GHHhBxLJ7t4zrjL9UW1oec8w3PBLxg5OK4/eNOP6qiA8/adl28vURh55TfOZ/tozt/iIgyXZjcf7VD45YfLeIrU+I+OdrLe939u8dd9wR8847b0w99dSd7eJ9AgQIECBAgAABAgQIECBAgAABAgQIECAwoAQaIhTpTHyaSYugY6EiJCgChi++jHjhzYjTigBhu1Vbjsgg4pFnIl59N+L0IizYbOWW7Tc/0bJ9+BdFIFIECEvMHXFtEYhsukLEPqd9FSh8UWx/6eUiDLkiYoLxIpYu9sv2wutfhRzVPg8U64z8bq8ikFitCDEuijjqkqLv4nxHbx9x15MRl93Xcmz+e2AR2rzzYcQlhxTPtygeB0dcdOdX27P/y++O2G39iMO/F3HTg8X4ip9s6y4asc4yETNMV4Q/m0XMNX1LMHPQWS1Tel15eBGkzBdx7q3l7p3+c+utt8Yqq6zS6XYbCBAgQIAAAQIECBAgQIAAAQIECBAgQIDAQBMYpxE+8B9uKkKC278ayVhFVHPrMS2vd1kr4i9FYPCHYvuNDxdBRPF6jm98te/XJoz4ydotrzNAeOnNiIvviFhtgWL/ohpj8kmKapL/bf/+ShF3/i3igsFFGFGEFVX7ybrdr1/y4zUivj5ZS0hxaTGWGaaKWOp/IcqQ5YpgpOh3uyKDeKNYC+SOYpyDfxUxSTG2GaaM+Ncbxfhvidhy+eqMRdXKEhGLztby+ukimBlcBCu5ffYiDMmfoa8WlSbztGwf+noUi6VHrLVwxIRFeLNzYdBdGzx4cJx++und7WY7AQIECBAgQIAAAQIECBAgQIAAAQIECBAYMAINEYqsuEixpkgRElQtA4Cq5doex/ywmGrq2IhZZojIcKK2TTBB7atiiquiiuLX/5sGa8grEZ8X1SCn3fjVPsM/bwkcvnonYrav177q+PlERRhRtdmKcUw0fvWqJSj50+CW1/8owoxxi30zxKnaK28X1SxFMPJlUe1SfbYMN6o2z4wRf76/ejXi48zTRExThDBbHBex9uIR6xc/GbZ01v7+97/HsGHDYvHFix01AgQIECBAgAABAgQIECBAgAABAgQIECBAoBRoiFBkpuKmf1UV0dF1yWm0xi5GOt64EWPVBCYd7Tt+sc9/P23Zkmt7jF1UnVRBRL671Lcipi0qPnrT2o+h9vXHxTnzde05s6rkx99tmQJs7A7GX3t8R+Map/gMlxxQrGVSTMH14LMRZ10T8cP1vqqQaX/MbbfdFssuu2yMO26BoREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKlQEOEIl1di6yu2P/cokpitWJKrUcjzi8qML6/0ldHfF5UftS2x/9VhB5FCJFt5mKN8eeLyo2d1mx5nf9+Vuyf1Sd91WYpAp7hw1sqWqqwI6tVMiSpXvfk3JNO1PI58rPk+iZ7ndp1KLLuusWcYBoBAgQIECBAgAABAgQIECBAgAABAgQIECDQKlDUIPR/yymtsqqj9icXVs927uCIDz6K2KOojPh5sSj5KVdEvPxWuan8583i+SNDW17n2hzX31esvbFYy+t1Fo148p8R9xfVFdmG/Tdiq2Ktj/uGtLzui39zvZMZizVBqim7MhD5xWURJ11X/9nahydPvhCxwymFw8ctfQz7pOUcHfX40Ucfxf3332+R9Y5wvEeAAAECBAgQIECAAAECBAgQIECAAAECA1qgISpFzimmg8qf2nbKXi2LmZ9xdbEw+k8jcgqphb9ZBB5LRxx0flExUmzPNt20xULsj0XsfUbEO+9ErFgso7H1Ci3bpioWWT9m+4h9im05k1ROq7V2cXy1QHrLXqP+3xN+FLFncc6Lbm6ZMmvuWSN+8+P6z5PjO6MIURbeqZgy65CIb80YMXUxhdhqB0ZM+rWI8cePOGDTjvu75557YoYZZohZZpml4x28S4AAAQIECBAgQIAAAQIECBAgQIAAAQIEBqjAoC+L1qyf/aZiOq3fXBtx3c++qqKYZMKOP82rRWCSa4nkGiOjq731QcuC7LWLqvfm3MOLqpN3PiwWXS8Cks7awQcfHF988UUcc8wxne3ifQIECBAgQIAAAQIECBAgQIAAAQIECBAgMCAFRmNE0Le+GYZ0Fojkmb8xxegNRPKcWakyqgKR7C+rZboKRHKfXGR95ZVXzqcaAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCPQ1KHIZMXi47N9o+bTDPCnn332Weywww6x3HLLDXAJH58AAQIECBAgQIAAAQIECBAgQIAAAQIECIwo0NTTZ434cbxDgAABAgQIECBAgAABAgQIECBAgAABAgQIEOhYoKkrRTr+SN4lQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIwoIBQZ0cQ7BAgQIECAAAECBAgQIECAAAECBAgQIECAwBgoIBQZAy+qj0SAAAECBAgQIECAAAECBAgQIECAAAECBHorcP7550f+jEnNmiJj0tX0WQgQIECAAAECBAgQIECAAAECBAgQIECAwCgQePDBB2O99dYre7ruuuti8cUXHwW99n8X4/T/EIyAAAECBAgQIECAAAECBAgQIECAAAECBAgQaCSBOeaYI2afffZySPl8TGkqRcaUK+lzECBAgAABAgQIECBAgAABAgQIECBAgAABAl0KWFOkSx4bCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgTFFQCgyplxJn4MAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoUkAo0iWPjQQIECBAgAABAgQIECBAgAABAgQIECBAYGAKDBkyJPJnTGpCkQa6moMHD44tttgi9txzzwYaVduhvPnmm+UYc5xvv/12241eESBAgAABAgQIECBAgAABAgQIECBAgMAYIZBhyAorrFD+jEnByDiNdHWGDRsWF1xwQTz++OPxr3/9K95///2YZpppYq655ooNNtggll566Rg0aFAjDXmUjuXVV1+N2267LWadddZR2u+o7Ozjjz8ux5h9fvLJJyN0feKJJ5bXbYQNxRt57aaddtqYY445YvHFF4/JJpuso93K97rqJ3eYdNJJW/uZbrrpOu3HBgIECBAgQIAAAQIECBAgQIAAAQIECBAgUAk0TChy6aWXxqGHHhrvvPNONbby8R//+Efce++9cd5558XGG28cJ510Uow77rht9skX//znP+Mvf/lLzDbbbLHmmmuOsN0bo0fg3HPPjddee63bk0011VRxxBFHxKabbtrhvvX2M+GEE8Z+++0Xu+yyyxgdmHWI5E0CBAgQIECAAAECBAgQIECAAAECBAj0kcDcc88dd9xxR9l7Ph9TWkOEIhl65JRRw4cPj/yr/yzJWXHFFWPKKaeMhx9+OB588MG488474/LLL4+cvumcc86JiSeeuM01eOqpp+Lwww+PddZZRyjSRqZ/Xiy33HKxyCKLjHDyxx57LO6+++5466234ic/+Ul5jVddddUR9qve6Kqfe+65J7Jy5cgjjyyrTrbZZpvqMI8ECBAgQIAAAQIECBAgQIAAAQIECBAg0EuBMSkMqSgaIhQ56KCDykBk+eWXjz/96U8x9thjV+OLVVZZpXz+5z//OXbaaaeyauSWW26J7373u637eNJ4Ahl0ZPVGRy0DkfXWWy+GDh0aBxxwQDzwwAOdVnl01c+7775bhmBZJZRVJ5tttlmMN954HZ3SewQIECBAgAABAgQIECBAgAABAgQIECBAIPp9ofWPPvoonnnmmfJSZLVIbSBSe32yAiSn2Lruuus6DETaT7tVe6znjSWQU2flQu3ZXnzxxXjllVd6NMDJJ588ttpqq/LYXH8mp1rTCBAgQIAAAQIECBAgQIAAAQIECBAgQIBAZwL9XimS1QJffPFFOb4ZZ5yxs3GW7y+55JIjbD/77LPLqZgyMMmW/Z1++unl81zIe8sttyyfV//kubLSJCtPXn755bKy4Jvf/GYstdRSse6663ZasZALoA8ZMiSyXGjllVeOl156qexn8ODBZR/zzTdf/OAHP+hy8fAcw9tvv12eO6cFe+ONN2KJJZYopwtbeOGFqyF2+fjkk0+W1TS5EH0udD7LLLNEnjvDgQkmmKDDY5999tm49dZby8XJqxAh33viiSfiP//5T2y//fZt1mnJacyuv/76eOihhyL3+/a3vx3LLrtsZCXPqGpZAXT00UeX3WWYMcMMM/So67wWRx11VHlsXpN55523R/04iAABAgQIECBAgAABAgQIECBAgAABAgS+EshChLxnni3vF08xxRRfbWziZ/0eiuRN/ao9/vjjMeuss1Yv63o85phjIqsEqpZVJ4cddlj5co455mgTinz22WdlcHHzzTdXu7c+nnXWWZHBRC7wneuatG9XX311XHTRRWV/GbZ85zvfieyvark9j82fBRdcsHq7zWOGEN///vfbVEbkWDIcyAXku2u//vWvIz9vbcu1VrL95je/iVNOOSWWWWaZ2s3l81zHI01mnnnmMjzZa6+94sILL2zdb9ttt20NRTK0yZAk1+uoWgY/v/3tb8vqjn322ad6u1ePtRVBn3/+eY/7qq0ymWmmmXrcjwMJECBAgAABAgQIECBAgAABAgQIECBA4CuB/GP2XLogWz5ffPHFv9rYxM/6PRSZZJJJYv7554+sgDjkkEPKioHFFlusbtJcrDsX27799tvjkUceiQxC1l9//fL4qaeeurWfrBDZddddI0OI2WabLTbccMOy8mGsscYq17TIUOHRRx+N3XbbLS655JJOK0aysmKPPfaI7bbbLpZeeukyTMiqj1NPPbUMO3JbVqLU3vTPQeSXJ8eV1R25gPyPf/zjssIjqzKyIiOrHdZee+3W8bZ/khUxGYhkILPpppuWC9FPO+20ZfVKBirZ/4477hgZYOT0VJ210047rTUQyQqZ7C8NsuVYMux57rnnYpxxxikDpPyi5zXKsOm8886LM888s7OuR+r9u+66q3X/3oQZGVRlm3766WPOOeds7dMTAgQIECBAgAABAgQIECBAgAABAgQIEOi5QN4bPv7448sOxpRAJD9Mv4ciOYisgMhAIKeTynKcDBvWWmutsuohp0PKG/SdtQwhsuXaJBmKzDXXXOXi3e33z2qEDEZye1Z1ZDBRtZyWa9FFFy2DkjvuuCOyYmWhhRaqNrd5zO3XXHNNm+2rrbZaOdZNNtkknn766bjpppvKBcBrD8zPmIFInv+KK66IaaaZpnVzrpeSU2/lY2ctq1ImnnjiuPjii2ORRRZp3S3Hufrqq5fTW6VfLlTf2QLnr732WvnZf/e735XThdWOITvMKcgyEBl//PHL/Wqn9MoFz3fYYYdyMfPWk/fwSX6W/BzZ0iODrM7asGHDyim+ard/+eWX5TXKkq20zmnDTjjhhNZql9p9PSdAgAABAgQIECBAgAABAgQIECBAgACBngl873vf69mBDXxU52nDaBx0rlmRN7j33Xff8mb3vffeG/mTLSsZMiDJKosMHwYNGtSjkY077rhxxhlnxHvvvdcmEKk6y2mnck2TXGfk73//e5vQo9onH3MNkI4Ck1xvo6p4yaqK2oAjp3i6/PLLy25+8YtftAlEqr5zaqttttkmTjzxxOqtNo9ZBbLRRht1eGwGPBmMZCCSY++sZSXIBRdc0GEfeUxWy2Tbeeedy6nEyhc1/4w33niR02dl+NNde/DBB+Occ85ps1sVZtxwww3ldcgKlQMPPLDLa/qrX/0q8qezls5ZYTT77LN3tov3CRAgQIAAAQIECBAgQIAAAQIECBAgQIBAKdAQoUiOZIEFFogbb7wx7r777rjuuuviL3/5SzkdVYYYebM/fzJ4OPnkk8upknpy/XJKq9oKkfZ9VKHI66+/3n5T6+uuFoPPioecBiwXQa9t+V5WqmRFw3LLLVe7qc3z2vVV2mz434v2lR21+1QLlWc1SGctp5jqrI8PPvigdX64NdZYo7MuyoXdO91YsyEXss+fzlpeh5wOrDY86mjfCSecsKxcab8tK4M+/fTT8hwZZGWlSH6HNAIECBAgQIAAAQIECBAgQIAAAQIECBAg0JlAw4QiOcCsHMjgI3+OPfbYsmrj1ltvjSuvvLJc+DsXFd9ss83itttu6/VUSe+++25k+PHWW2+V02rl+TMY6E2rApdc46S2vfjii+XLDD2q9Ttqt4/s85xSKsee02Vl9Ue2DAa6a12duxpj9pFrjfS25RRf8803X5tuctqwHHtOkZZVO1m9013bf//9O5wOLEORXLsl1xTJx6xeye9FFQ5116/tBAgQIECAAAECBAgQIECAAAECBAgQIDDwBBoqFGnPn1UZOWdZ/mSlyO67716ueXHuueeW61u037+71xmE5Hoa559/fhkqdLd/T7e3n+LrpZdeKrvK6ad62rLSJA3OOuusLqfI6mn/taFKPWFFd+fJ6c7ar22SoVEuCp/hVoYjk08+eXfddLp9ookmKqdUy7VoVllllXLB+aw8+e1vf9vpMTYQIECAAAECBAgQIECAAAECBAgQIECAwMAWaOhQpPbSbL755mXFSFYDPPTQQyMdiuQi59nHY489Vq5TssUWW8Sss84ak046aeuaFmeeeWY8//zztacdJc9zgfTetoMPPrhcoyMDizXXXDNyHZYMGarqj5tvvrmsmOjpeUbFGLs7d65V8vvf/z7ef//9MrzItUB628YZZ5xySrIhQ4bEww8/3NvuHE+AAAECBAgQIECAAAECBAgQIECAAAECY7BA04QieQ3mmmuucoqkXLh8ZNvZZ59dBiJf//rXy/VKpptuuhG6uPbaa/skFMlF1LPlVF09aRnkVIuWZ7XIsssuO0I32XdOI9XTVo0xj3/77bdjkkkm6WlXnR43xRRTxPbbb19Wi2TFTi4e39kaJ5120sGG7DdbbbVLB7t5iwABAgQIECBAgAABAgQIECBAgAABAgQGuMBYjfD5H3300XJR9e7GUk1DlQuaj2x75JFHykNWWmml6CgQyY1ffvnlyHZb1/5V4PDqq6+WVRKdHZTrZHTUqrHndGIdBSJ5TG/HnouwZ9VFtqy66Kx1NsbO9m//fk6plVUpue7Kr3/96/abe/Q611fJNttss/XoeAcRIECAAAECBAgQIECAAAECBAgQIECAwMAQ6PdQ5KqrrorvfOc75eLbzz77bKfqL7zwQtx+++3l9vnnn7/T/TrbUIUGnVWZfPbZZ/H000+Xh1f7dtbXyL6/+OKLlwuAZ79drXlxxx13dNh1NZ6cdirX4uioPfnkk+Xb1b4d7dPVe2OPPXast9565S4nn3xypyFLZ2Psqu/abbmOyA477FC+lWu7/Pvf/67dPNLP0+PWW28tj1t44YVH+ngHECBAgAABAgQIECBAgAABAgQIECBAgMDAEej3UOQb3/hG5KLZGVbk4tx//OMf41//+lebK3DPPffENttsUwYCuQ7IZptt1mZ7vuhuEfNcgyNbLvL9wAMPlM+rfzJs+MlPflJWMOR77RdKr/br6WOuA7LHHnuUh5966qmRP1988UVrd1k18ctf/rLTNTGqsec4c9qp2jZ8+PA47bTTWgOd3ox9n332KT/7gw8+GLvttlubqpYMW6655ppyoffa8/fk+U477VROz/Xpp5/GCSec0GUXafPuu++O8PPcc8+V03Cts846ZbCS13+vvfbqsi8bCRAgQIAAAQIECBAgQIAAAQIECBAgQGBgC/R7KLLkkkvG9ddfHznFVN783nvvvSPfW3DBBWOttdaKeeedNzbccMPIKpJc5+L0009vDS9qL90qq6xSvrzpppvKBdQzPNlvv/1ad9luu+0ip4jKluHL8ssvX95E33bbbWORRRaJXJeims4pb9Tn8VmdMqraVlttFauvvnpkRcoRRxzR+rmySiY/63333Rf7779/h6dLjzXWWKPcdvTRR8cCCywQOQ3Vj370o1hiiSXiiiuuiBtuuKEMl+6+++5y7Ln2yMi2XLPlpz/9aRmMXHrppeV5clH3TTfdtDQ66KCDyiBiZPttv39Wi/z4xz8u385xDh06tP0ura+PO+64mHvuuUf4WW655SItnnnmmcjQKUOlWWaZpfU4TwgQIECAAAECBAgQIECAAAECBAgQIECAQHuBfg9FckC5Rsif//znyIBisskmK8f42muvRa41kguIjz/++PHDH/4w7r///uhsiqSlllqqDFSy8iSrC/InKxGqlv1ecsklscIKK5RvZchy4YUXRoYIq666ahx11FGRN9oPPPDAyLU78vieTkVVnbP2MW/c53RRe+65Z0w66aTxzjvvRFbA5GfMz5QLqec+nbWcdusHP/hB5DRXuYbG5ZdfXgYhGfTkIvK5YHlOe5VTdeXYP//888666vL9rLbIapTsN/vJRd6zumbKKacsx582o6LlIuvpkJUuxx9/fI+6zDHmlF/XXnttbL311j3qw0EECBAgQIAAAQIECBAgQIAAAQIECBAgMHAEBhU3/vtmdfEeGmaQ8fzzz0cuSp5t9tlnL9fjGGusUZffZN95jpxyaaGFFmpdYLyHQx7pw5I8p3964403YrHFFosJJpig7j6ymiYrKz744INYdNFFO6yaqbuzbnbMKc0yPMo1XKaaaqpu9raZAAECBAgQIECAAAECBAgQIECAAAECBAg0tkDDhSKNzWV0BAgQIECAAAECBAgQIECAAAECBAgQIECAQLMKjLryi2YVMG4CBAgQIECAAAECBAgQIECAAAECBAgQIEBgQAgIRQbEZfYhCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAaGI7wABAgQIECBAgAABAgQIECBAgAABAgQIECAwIASEIgPiMvuQBAgQIECAAAECBAgQIECAAAECBAgQIECAgFDEd4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYEAJCkQFxmX1IAgQIECBAgAABAgQIECBAgAABAgQIECBAQCjiO0CAAAECBAgQIECAAAECBAgQIECAAAECBAgMCAGhyIC4zD4kAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIBTxHSBAgAABAgQIECBAgAABAgQIECBAgAABAgQGhIBQZEBcZh+SAAECBAgQIECAAAECBAgQIECAAAECBAgQEIr4DhAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIDQkAoMiAusw9JgAABAgQIECBAgAABAgQIECBAgAABAgQICEV8BwgQIECAAAECBAgQIECAAAECBAgQIECAAIEBISAUGRCX2YckQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhCK+AwQIECBAgAABAgQIECBAgAABAgQIECBAgMCAEBCKDIjL7EMSIECAAAECBAgQIECAAAECBAgQIECAAAECQhHfAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGBACAhFBsRl9iEJECBAgAABAgQIECBAgAABAgQIECBAgAABocho+A488cQTcdlll42GM43cKe655574xz/+MXIHjea9X3nllbj55ptH81mdrjuBzz77rPxO56NGgAABAgQIECBAgAABAgQIECBAgACBZhEYpz8H+s4778T555/fOoTpp58+Nt100/L1qaeeGtUN1/HGGy++8Y1vxHLLLRdTTz116/71Pskb6z/96U9jo402ig033LDew9rs9/vf/z4eeOCB+OUvfxlTTDFFm21dvfjjH/9YfsZ55pknNt544xg0aFDZz/HHH18GEvPOO2/87Gc/i7nnnru1m4ceeigOP/zw1tf5ZNxxx40rr7yyzXu9fXHGGWfE8ssvH3PMMUevunr44YfjsMMO67CPdPv617/e4bb2b5500knx17/+Nfbaa69YddVVy80ZKKXVaqut1n73bl/n96ez673nnnv2qM/ak+a1veCCC+Ltt9+OpZdeOn7+85/HJJNMUrtL+byr7069fbTv9LXXXotDDz00Xn311dhjjz1i9dVXb7PLyHyHuhpfm05rXnz88cex6667xhprrFF+N2s2tT79z3/+E0cccUTcddddkb/DOcYDDzwwvva1r7XuUz3pbAz1fI7HHnssjjnmmPj73/9e/vdhm222ie23377quvXx008/Lc0mnXTSOOCAA2Lsscdu3ZZPLrzwwvIn/xtz7rnnttmWL2688cb47W9/Gy+//HLMNddccfDBB8eCCy44wn7eIECAAAECBAgQIECAAAECBAgQIECgcQX6NRSZeOKJy5vWeTNygQUWiEUXXbRV6oUXXoh11103pptuujIcyWAjb5yuv/76kUFCve3WW2+NY489NnbZZZf47ne/W+9hrft98MEHcdBBB8Xnn38ev/jFL0YqEMlO7rzzzthggw1i5513Lvt87rnn4ic/+Ul5c3ihhRaKrNbYeuut489//nNMO+205T4vvvhieRM5w4GqjTVW4xb1vPfee/Hhhx+WztV4n3nmmTIo6egGeLVP7WPe0M4b0VNOOWW89dZbtZt6/PyLL76IBx98sAyTqhvgGZTkTfPxxx+/x/3mgZdcckkZiBxyyCHldbv00kvL63jNNde09tvdd6eePlo7q3ly7bXXxv777x9bbbVV/POf/4w333yzZmvL03q+Q92Nb4ROR/KNE088sQzEzj777MjvSAaK++23X2TgWbXuxtDd58hw5rjjjisDlwzmhgwZUv5uTTDBBOX1qM4zdOjQ2GeffWLZZZctQ6Tq+5DbM5zde++9y2M32WST8rpWx1WPf/rTn+LII4+Mo446qvxvVQakm222WfzhD3+IxRdfvNrNIwECBAgQIECAAAECBAgQIECAAAECDS7Qr3fas/ph5plnLm9Q583w9hUFM800U/kX2fPNN1950zNvZp933nnx3//+t2S9//77y4qK6nV767yh+oMf/KC8CdtZIJJ/xZ5/7Z7VEnmTM8OY2pZ/jZ/VHXkjt6MqlUcffbQ8LitBMvjI11X7/ve/H7fcckucdtppscoqq8SXX34Zv/nNb8qbtVnB8M1vfrN8nuf/3e9+Vx0W7777bvm5s4qj+smbubUtp5TKaoqsMNlhhx3iX//6V+3mDp9fffXV5U3h/Ov22hvT1c554zhvCudfwWdVy2233VZtKj9X+nT0OWebbbbYaaedYskll2z9efLJJ8vKnAy+umvpkjf586b2ZJNN1uHuGTosscQSZXBWa5U7dzbuvPGdFUJLLbVU67gyQKiqjjo80f/ezOqPHXfcMfK7l9VLaVfbMmjLG+RZvVRVDeSN/8GDB7fu1t13p54+WjureZLf+7POOqusesgKjI5aPd+h7sbX1Xe7Ouff/va3WHPNNcvvRQYeVXVXbs8QMUOjhRdeOFZaaaWyMidDnNrW3Ri6+xwTTjhhWd3xox/9qAxL8/cqQ9PaaeEyHNtyyy1j8803j3333XeEypas/MhAMn+nOqv8yAArf5+z2iz/W5GBVIa2jTgtXq2v5wQIECBAgAABAgQIECBAgAABAgQItBXo11Ck7VC6f5XTaw0fPry1kiCrJ2r/4rt9D1lZkjf588Zq/tX6FVdcUVZ8VPvlDdqcZif/SjwDgDnnnLPcv7qxmxULeUzeHL/ooovi5JNPHuFma07DlAHC9ddfHxni5E3Xqu2+++7lTfW8aZx/ZZ7hSv4le+5X22acccbIyoqq5XinmmqquOOOO8q/rr/qqqsib+xWLasqsvIl+8+qgQyTMpTIcKGzlsdkhUreyM2/es+byTk1VdVyaqG84Zvhyw033FA+zz5zmqY8d1efc9ZZZ40tttii6qr0zpvF2223Xet7XT3JSqH8y/6sqOmoZZVQ/uRf5WfIlRUH1TojXY17nHHGKa9tbZVNhgk//OEPy2vR0bmq93IqrPy+pW/eUM8pqjIoyfbRRx+VUyi1v475Oq9vtu6+O/X0UXbUwT85tgxjumrdfYe6G19317w693XXXRf/93//V04dlgHj0UcfXW0qH/N3Kc+V3+GcKiyn3Kpad2PI/br7HFVfWTGS4UZOCZff9W233bbaVH5X8ncvQ7vTTz89snIl+63a/PPPX1Y5TTTRRNVbIzxmxVNt0JI75H8/8jNoBAgQIECAAAECBAgQIECAAAECBAg0j0C/Tp81skx5YzOnPcobmnnDOqet6Wrqmttvvz1mn332slogb9znzdtclyPXgciWN8jzr7/XWmut8nWuf5A383Ndi3XWWSfuu+++yMAi/wI+K1qy+uGEE06Iqmohb7ZnGFJVQ2QgklUMOUVWBiw5Hdg000wTWUlR3cTOSoX2Uzfl61x/oWo5nc8jjzxShhZ5Yz/XMcjptc4888xyl7ypmzd9q+qXDFzynOnz/vvvt7l5m587q3AyUMiqk5wKLNu3vvWtcuzli+Kf/Bw5VVk1ZVe6LbLIIuV7uU9Xn7Pqo3rMkCNvNH/729+u3irDgmHDhpWvs7qh2pZBQ1ZMdLVeSlaPZCiRLasysgIo16LJdUa6G3d50P/+ybUnnn766TLgqt7PsCWDn6rluLOCKU2r65rX7+KLLy4Dkvy+VNcqg5zaVnsdu/vu1NNHZ9ey9pydPe/uO9Td+Lr7blfn3W233crKm6yoyYAyf1dyjZz8LmbL70JWAWXLYO073/lO+Tz/6W4MuU93nyP3yZZ9Z/CS1yR/T/KaVS3/OzDLLLOU06Zl1UpWb+XvVE6tN/nkk1e7dfmY/z3I9VDyvx0rrrhiGRxmdVb+jmgECBAgQIAAAQIECBAgQIAAAQIECDSPQFOFIsma1RDtQ4WOuHO/vGmZfx2eFSPZcqqfnHIq1wPIqZiyOiOrLPIGadVyiqwMGLI9//zzZR85jVA1tVdWKuTC3xmMZMuKi6zoeOmll8ppvfKGet7wzlCko5b7t6/oyNf5ftWy8iSn1MoQI1vePM4AJP/KPqf3yfFl9ULV8gZ2tVB7Lkxduy2n68ppr/Kv2qvFy6vjatf7ePbZZ8vAodqWjzlVVtXq/ZxZYXDOOee0hi/V8XnTOoOebBkw5Vof2TKIyqmIMoTprNWOM/dZeeWVWysSuht3bZ/5PUjb2im6MmBKo6rlGGeYYYYyEHn88cfLMCfXS8m1L9oHGR1dxyoo6e67U+3XVR+dXctqrF09dvcd6m582Xc917z22uQUWRnkpFOGgdny2uZ3N7/DWeGT39Wc0ixbPWPo7nOUHRX/nHTSSeV3KQOPDNCyIiTHky3Pk8FX/p5mcJPVK7mez7nFGjb5vaynVb9DGZZlUJmhZP43IcNFjQABAgQIECBAgAABAgQIECBAgACB5hFoqlAk1w7JaXKy8qG7ltNsffLJJ+XC7NW+WZ2Q63jk9DoZimRfeZO0+qv23C9v4lYLvueN8KxEqQKR3J4Lvedfwlctb5bmVEgZvuT0O7XTXFX71D5m6JJrT9S2fF27XknesK1t2XduzxAnQ5H8XJ1NG5YVKXkzv2rVX8KnXVdhUld9Zl/1fs6sssm+1ltvvWoI5WNOnZRTXWWrxp5rY+SN6pyuqzLJG9bpmUFEValRHlTzT36OvHbZuht3dVg1hdNNN91UvVU+5g30XI+iatXN/KwIymnG8sZ62teuW5Pfv/zOZMXSFFNMUc5hHwcAAEAASURBVB1afobqOnb33amnj86uZesJu3jS3Xeou/Fl1/Ve82oYVdCT16RqGRLmdzCrsbJSKCtJsnIk/eoZQ3efozpPnjsrnbbeeut4+OGHy4qtKhTJ82SlR/W9yzHllHb534F6W4Y5Bx98cBn2ZZCVv4sZqrT/ntfbn/0IECBAgAABAgQIECBAgAABAgQIEOgfgaYKRfJmfy6IXN3o74osb3zmgtq1c/5nUJLT8VQ3snNqqQUWWKBcj6PqK2/K57HZcsqdnJ6ptuVfwVfH53RMWYGRVQ/VMTnNUlctp2fKtTzy5m3V8vViiy1WvSwDgfwr/eombgYAeWO3Om+uXZEWuQB41arQI6emypvD7VtWP2TFS07/VLX0qFr2mdMM1baqz5H5nDl92DbbbNPqUfXXUZCVFTs5fVX7xa3z/QwkMizJltektuXnyGnNsnU17tpjctqjnOooF+GubZNMMknkT23Lz51Tq11zzTWt1TNZCVS1rBTIfvK6ZciWLS2feuqp8sZ5vu7uu1NPH51dy+y/u5ahUlffoe7GV+81r/0OZZVNfmer71+GRrW/q/k8bfOY/H3pbgz5Gbv7HBlQZHVKbfVP/p4MHTq0lSgrk2r/O5Ab8ve4GmfrjnU8yTAnz5kLxOeaObWVMnUcbhcCBAgQIECAAAECBAgQIECAAAECBPpZYKx+Pn+Xp8+bp3lDPP/CPG+45poB+RfeVWVHri2RC6F3Vp2Ri6zn2hP//ve/yyqF/Mvuzz//vFxMPE+8+eabl4suv/rqq+U48kZqrhdQVS3kX7fnTfs8b44lA5C8WV+tQZI3RPOmbVW1kGuOVItxd/bBcjqgHHP1V+r33HNPDB48uM0i47lOQ04rlZ89+z/llFPKG9xZ3ZIt+8iwplooPftYZZVVRggPaseQaznceOON5dRh+X5OKVRbUZILsOfny37TM6cbyr+0z6m66v2cue+9994b3/ve92pP3enzXPg97Wt/lllmmXIqpNowKgOJauqtdLv88stbK4C6Gnd14rx2ee3rXfg9A4usRsn1X7Llzf1aq3wvF6U/+eSTy+9K3iQ/9dRTywCgWmOiu+9OPX3kPh21/DxZjZE/ee78nuTzDByq1t13qLvx1XvN83cj2+uvv14ucp79ZuCRa7fk9G8ZrmTL38EMmpZaaqnWwKy7MeRx3X2OnKotq7uqa5W/g/n9WGGFFfLwsuV/B3JNnryG6ZVTeeXvXJ6/apVnVjPlPtXr/O9F+3bYYYeV/03aZ5992m/ymgABAgQIECBAgAABAgQIECBAgACBBhfo10qRvJF63HHHlTfh88Z3TnuT62ZULcOAbPkX81n1kWtlZKVF1YYMGRJ33XVXGZR09BfbOTVS3rjMMCGn15l00knLG7PVFEcZJGTFRt5Azb9izxug+Rfg1V+dZ3VDLtqci4/nIuo5rVPeDK9uhua6IRlQLL300mUFS/aTU+xkpUR+ltq/kq/GnAs952LnOQ1X3njPc+aaFlnxULUMRHbZZZdyXZIMKLI6JtfDqPrLm7l5gzcDgfxMOW1XOlbVKlU/tY+5RklOh7TBBhuU/WX4k2OpWk4Rljf287PlZ8228847t66NUs/nzCqRHFteq3pahltVwFXtn69zqqL8qVoump1VIzvssEN5c33DDTdsDV66G3f2UQU9OYVSPS2rHXKKpwxtcgqvrLLJtSR23333skJk7bXXLquL/vGPf5RVLnkd87uSAVzVuvvu5H477bRTdNVH1Vf7x1zT5te//nXr2xk85Hhz6q9cNydbd9+h7sbX3Xe7uj5ZjZJBx8svv1zaZEiRLdejyd+/DB7zmmawtOyyy5ZBUrlD8U93Y8j9uvsc+fubAUxWWuV1yAA1/zuRYUrVcg2a/O7k71z+tyRDpVzXJH//s+XrrFqpbdXr/L2qqqsydMrpvzKMzQXku/p9q+3LcwIECBAgQIAAAQIECBAgQIAAAQIEGkdgUPFX0V82znBGbiQ59AwqOgpEanvKSo68KdvZzfq8KZp/ad7Z9uwrK0byJm61bkJt//lX5fkX5hlQ1Nuqaow8Z/tgoOojp/jJ0KR2TZNqWz5mhUBOCzQy0wClV461Clhq+8vnaZqVG9lndeO72qcnn7M6dlQ85hRiOb6OnLsad0/PndcoK3+qEK2jfvJGeU7fVK1F0tE+XX13cv96+uio33re6+47lH10Nb56rnl+D3Naugzv2rf83crvU05p1dkaMd2NIbd39znyd/yNN96I6aefvtOwIseSFVD5O1dNTdd+vF4TIECAAAECBAgQIECAAAECBAgQIDBmCzR1KDJmXxqfjgABAgQIECBAgAABAgQIECBAgAABAgQIEBiVAl/NUTQqe9UXAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKDBBIQiDXZBDIcAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoGwGhSN+46pUAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoMAGhSINdEMMhQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+kZAKNI3rnolQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEGkxAKNJgF8RwCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgb4REIr0jateCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgQYTEIo02AUxHAIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBvBIQifeOqVwIECBAgQIAAAQIECBAgQIAAAQIECBAgQKDBBIQiDXZBDIcAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoGwGhSN+46pUAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoMAGhSINdEMMhQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+kZAKNI3rnolQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEGkxAKNJgF8RwCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgb4REIr0jateCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgQYTEIo02AUxHAIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBvBIQifeOqVwIECBAgQIAAAQIECBAgQIAAAQIECBAgQKDBBIQiDXZBDIcAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoGwGhSN+46pUAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoMAGhSINdEMMhQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+kZAKNI3rnolQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEGkxAKNJgF8RwCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgb4REIr0jateCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgQYTEIo02AUxHAIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBvBIQifeOqVwIECBAgQIAAAQIECBAgQIAAAQIECBAgQKDBBIQiDXZBDIcAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoGwGhSN+46pUAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoMAGhSINdEMMhQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+kZAKNI3rnolQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEGkxAKNJgF8RwCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgb4REIr0jateCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgQYTEIo02AUxHAIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBvBIQifeOqVwIECBAgQIAAAQIECBAgQIAAAQIECBAgQKDBBIQiDXZBDIcAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoGwGhSN+46pUAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoMAGhSINdEMMhQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+kZAKNI3rnolQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEGkxgjAxFrn0w4v2PWqTfKx4f/EeDqRsOAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMNoFxhntZxzJEx59ecQjz4140KFbRCw464jv5ztHXRAxx/4Rk04UccsTEadeE3Hz0S37Zljy+nsRc36j42O3PTHi4/92sm2ViO8u0fE27xIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKNLdDwocjQVyK+OV0RRizZFnLWadu+7uzVRktFrL/4V1vvezbij4Mjztvzq/dqn+26TsTwL1reOeTciHWXjlh67pbX3/x67Z7dP3/7w4i/PhYx70wR88/S/f72IECAAAECBAgQIECAAAECBAgQIECAAAECBPpOoOFDkfzoMxcByHLzdIzw5ZcRx18Vcc1dEZNMHHHg5m33u3dIxB8GR5yyY8TJ1xeByF8ivihCj3WPiPjZlhFLztV2/6X+F4DkuxOMHzH39G3Pfdk9ERfcEvHO+xGrFmHLjqtHTDfFV31cdGfEmcV5stpk4qJSZZ+Nv9p+46MRJ1wW8W5x7FyzRhy5dcTsReCjESBAgAABAgQIECBAgAABAgQIECBAgAABAn0v0PRripw7uCUQ+fH6EScVwcd9RQgy/LOv4HK6rBdeb3m97qIR6ywTMUMRRBy0WRFMFIHHyLSX/hNx2nUR+28ScfruES8W/Z5RhCxVe+KFIqC5KOLYH0VcW4Qus88QcVMRhEwzacSwIiQ56KyIXb4TceXhRdAyX8S5t1ZHeiRAgAABAgQIECBAgAABAgQIECBAgAABAgT6WqApKkX+cFPE5bd/RTFWEeXcekzL60sGR2xdVGt8b6WW13t/N+LimqCi5d2Wf7MqI3+GvhqxbCeVJ7X7t38+09QRV/+sqACZoGXLTmtH7HlqxGH/q07JqpT5i8qTJeZo2b71SkUQcnbL89ffjRg0KGKthSMmHC9i57Va3vcvAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMHoEmiIUWXGRtgucZ7iQLafOev2NiBXmbXmd/45TBCbjjPvV61H9LM+Z02C9WSzW/laxZsiHxU/VZi5Ckz/9ryol3xtaPJ9skpatM09TVIxMFbHFcRFrF9Nu5TonM0xZHemRAAECBAgQIECAAAECBAgQIECAAAECBAgQ6GuBpghFZioChY4qOz4vAorPP48Yvw9DkNoL8F4xFdfaBxcLp89WTL01Y8RHxZRYtW3FYkqs3xVVLZsVwUeug3LP4xGHbtuyR4Y1lxwQcWGx5siDz0acdU3ED9eL+ElRbaIRIECAAAECBAgQIECAAAECBAgQIECAAAECfS/QFKFIZwwZNEw2WcRjz0fM8Y2v9sqF1PuiXXxXxEJzR5y6U0vvLxZrjFxZsy5ITus1/zcjpi7GNMmExSLsa0bMWTOuSSeK2Kl4L38e+EfEXsXUW0KRvrhS+iRAgAABAgQIECBAgAABAgQIECBAgAABAiMKFLfxG78NL6pBPvm07c8XRZVItlWLaaguvqNYTP3Nltc5tdVnxb6dtbH+N/VWZ9u7en+iYi2Qd4rpsnIKrWx3PtXyWP17f1EB8tS/imqSYt2Q1RaI+MYU1ZaIJ1+I2OGUiA8+bnlv2CcRMxbrm2gECBAgQIAAAQIECBAgQIAAAQIECBAgQIDA6BFoilDknGKqqSV2bftz99MtQHsWU1BNOH7Ed4pprVY9KOK1YkHz8f+3EHpHhEvNHfGvVyIWLqo9nn65oz06f2+DJVu2Lb9fxDqHFwuuF9Ugyy9WrHdyVMv7y3wr4o23I7b6ZcRGR0asuE/xeHQRlLwY8a1iuq2pJy3CkgMjVi/GesIVEbut3/m5bCFAgAABAgQIECBAgAABAgQIECBAgAABAgRGrcCgL4s2arvsn97eLio4spJjguKnr9u7w4pzFUHMeO0mH9vv3CL8mCli+1VbRvBZUeFy0nURLxfTbP16+5b3hhdTe2W1yTRFQKIRIECAAAECBAgQIECAAAECBAgQIECAAAECo0+g3W390XfiUX2mKSce1T123t/kX+t421vvR7xfLMaeU31lOJPhyfOvtVSUVEfkOigCkUrDIwECBAgQIECAAAECBAgQIECAAAECBAgQGH0CY0ylyOgj6/xM/ywCkMMujHipeMz6m/HGjVhqvoifbtSy8HrnR9pCgAABAgQIECBAgAABAgQIECBAgAABAgQI9LWAUKSvhfVPgAABAgQIECBAgAABAgQIECBAgAABAgQINIRAUyy03hBSBkGAAAECBAgQIECAAAECBAgQIECAAAECBAg0tYBQpKkvn8ETIECAAAECBAgQIECAAAECBAgQIECAAAEC9QoIReqVsh8BAgQIECBAgAABAgQIECBAgAABAgQIECDQ1AJCkaa+fAZPgAABAgQIECBAgAABAgQIECBAgAABAgQI1CsgFKlXyn4ECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAUwsIRZr68hk8AQIECBAgQIAAAQIECBAgQIAAAQIECBAgUK+AUKReKfsRIECAAAECBAgQIECAAAECBAgQIECAAAECTS0gFGnqy2fwBAgQIECAAAECBAgQIECAAAECBAgQIECAQL0CQpF6pexHgAABAgQIECBAgAABAgQIECBAgAABAgQINLWAUKSpL5/BEyBAgAABAgQIECBAgAABAgQIECBAgAABAvUKCEXqlbIfAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0NQCQpGmvnwGT4AAAQIECBAgQIAAAQIECBAgQIAAAQIECNQrIBSpV8p+BAgQIECAAAECBAgQIECAAAECBAgQIECAQFMLCEWa+vIZPAECBAgQIECAAAECBAgQIECAAAECBAgQIFCvgFCkXin7ESBAgAABAgQIECBAgAABAgQIECBAgAABAk0tIBRp6stn8AQIECBAgAABAgQIECBAgAABAgQIECBAgEC9AkKReqXsR4AAAQIECBAgQIAAAQIECBAgQIAAAQIECDS1gFCkqS+fwRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQL1CghF6pWyHwECBAgQIECAAAECBAgQIECAAAECBAgQINDUAkKRpr58Bk+AAAECBAgQIECAAAECBAgQIECAAAECBAjUKyAUqVfKfgQIECBAgAABAgQIECBAgAABAgQIECBAgEBTCwhFmvryGTwBAgQIECBAgAABAgQIECBAgAABAgQIECBQr4BQpF4p+xEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJNLSAUaerLZ/AECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAvQJCkXql7EeAAAECBAgQIECAAAECBAgQIECAAAECBAg0tYBQpKkvn8ETIECAAAECBAgQIECAAAECBAgQIECAAAEC9QoIReqVsh8BAgQIECBAgAABAgQIECBAgAABAgQIECDQ1AJCkaa+fAZPgAABAgQIECBAgAABAgQIECBAgAABAgQI1CsgFKlXyn4ECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAUwsIRZr68hk8AQIECBAgQIAAAQIECBAgQIAAAQIECBAgUK+AUKReKfsRIECAAAECBAgQIECAAAECBAgQIECAAAECTS0wzgsvvNDUH8DgCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQL1CAz68MMPv6xnR/sQIECAAAECBAgQIECAAAECBAgQIECAAAECBJpZwPRZzXz1jJ0AAQIECBAgQIAAAQIECBAgQIAAAQIECBCoW0AoUjeVHQkQIECAAAECBAgQIECAAAECBAgQIECAAIFmFhCKNPPVM3YCBAgQIECAAAECBAgQIECAAAECBAgQIECgbgGhSN1UdiRAgAABAgQIECBAgAABAgQIECBAgAABAgSaWUAo0sxXz9gJECBAgAABAgQIECBAgAABAgQIECBAgACBugWEInVT2ZEAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoZgGhSDNfPWMnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6hYQitRNZUcCBAgQIECAAAECBAgQIECAAAECBAgQIECgmQWEIs189YydAAECBAgQIECAAAECBAgQIECAAAECBAgQqFtAKFI3lR0JECBAgAABAgQIECBAgAABAgQIECBAgACBZhYQijTz1TN2AgQIECBAgAABAgQIECBAgAABAgQIECBAoG4BoUjdVHYkQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEmllAKNLMV8/YCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboFhCJ1U9mRAAECBAgQIECAAAECBAgQIECAAAECBAgQaGYBoUgzXz1jJ0CAAAECBAgQIECAAAECBAgQIECAAAECBOoWEIrUTWVHAgQIECBAgAABAgQIECBAgAABAgQIECBAoJkFhCLNfPWMnQABAgQIECBAgAABAgQIECBAgAABAgQIEKhbQChSN5UdCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgWYWEIo089UzdgIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBuAaFI3VR2JECAAAECBAgQIECAAAECBAgQIECAAAECBJpZQCjSzFfP2AkQIECAAAECBAgQIECAAAECBAgQIECAAIG6BYQidVPZkQABAgQIECBAgAABAgQIECBAgAABAgQIEGhmAaFIM189YydAgAABAgQIECBAgAABAgQIECBAgAABAgTqFhin7j37YMevfe1rfdCrLgkQIECAAAECBAgQIECAAAECBAgQIECAAIFmEBg2bNhoHaZKkdHK7WQECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAfwkIRfpL3nkJECBAgAABAgQIECBAgAABAgQIECBAgACB0SogFBmt3E5GgAABAgQIECBAgAABAgQIECBAgAABAgQI9JeAUKS/5J2XAAECBAgQIECAAAECBAgQIECAAAECBAgQGK0CQpHRyu1kBAgQIECAAAECBAgQIECAAAECBAgQIECAQH8JCEX6S955CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgdEqIBQZrdxORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECPSXgFCkv+SdlwABAgQIECBAgAABAgQIECBAgAABAgQIEBitAkKR0crtZAQIECBAgAABAgQIECBAgAABAgQIECBAgEB/CQhF+kveeQkQIECAAAECBAgQIECAAAECBAgQIECAAIHRKiAUGa3cTkaAAAECBAgQIECAAAECBAgQIECAAAECBAj0l4BQpL/knZcAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYrQJCkdHK7WQECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAfwkIRfpL3nkJECBAgAABAgQIECBAgAABAgQIECBAgACB0SogFBmt3E5GgAABAgQIECBAgAABAgQIECBAgAABAgQI9JeAUKS/5J2XAAECBAgQIECAAAECBAgQIECAAAECBAgQGK0CQpHRyu1kBAgQIECAAAECBAgQIECAAAECBAgQIECAQH8JCEX6S955CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgdEqIBQZrdxORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECPSXgFCkv+SdlwABAgQIECBAgAABAgQIECBAgAABAgQIEBitAkKR0crtZAQIECBAgAABAgQIECBAgAABAgQIECBAgEB/CQhF+kveeQkQIECAAAECBAgQIECAAAECBAgQIECAAIHRKiAUGa3cTkaAAAECBAgQIECAAAECBAgQIECAAAECBAj0l4BQpL/knZcAAQIECBAgQIAAgT4XeOGFF/r8HE5AgAABAgQIECBAgEDzCAhFmudaGSkBAgQIECBAgAABAgQIECBAgAABAgQIECDQCwGhSC/wHEqAAAECBAgQIECAAAECBAgQIECAAAECBAg0j4BQpA+v1VNPPRXXXHNNfPnll+VZ7r777rjsssvi008/7cOz6poAAQIECBAgQKCZBW6++eZ44IEH2nyEd999N6699tq455572rzvBQECBAgQIECAAAECBAiMnMA4I7d78+294447xr///e9y4GONNVbMMssssdxyy8Vmm20WgwYNqvsDPfHEE/H666/H6quvXvcxu+22W2QwMnjw4JhnnnnilFNOiVtuuSVWXXXVGG+88erux44ECBAgQIAAAQKNLXDffffFz3/+83KQv/zlL+Pb3/52XQNu/78xM/zYeuutY/LJJ48hQ4aUfTz22GOx3nrrxWeffRZrrbVWLLPMMnX13dVO+b9PJ5544lhsscW62s02AgQIECBAgAABAgQIjHECY3wokv9Hc+jQobHxxhvHF198Ec8880xceeWVZcXGH/7whxh//PHruqi//e1v44YbboiXXnqprv1zp4MOOiiee+65mGOOOeo+xo4ECBAgQIAAAQLNJ3DJJZfE008/HcOGDYsrrrii7lCk/f/GzDDkmGOOiSmmmKIV4aqrrioDkfzfsAsuuGDr+715suuuu8b8888fF198cW+6cSwBAgQIECBAgAABAgSaTmBATJ+VFSGnnnpqnH766fHXv/419t5777jjjjviuOOOa71gGV5ssskmMeecc8aKK64YGZhUbYMNNiinwcq/zlt55ZXjwgsvLDdl5cgOO+xQ/h/K1VZbLU488cR4//33q8Mipz7I/4P80Ucftb5X+yT/EvD/2bsPMEuqan/YGxhylJwRRJIoSaKABCWqKAiIgIAfIIioCIoBE6AgiIoJUaIYiYqCCQEBAUWyiOQchpxmGOJ889v/W8czTafp6emZPv3u5/acOhV2Vb2F96lTq9ba++yzT1luueXKG97whvKhD31okoIu7X2ZJkCAAAECBAgQmDoCL7/8cjn//PPL1ltvXVZbbbVa5qrrkSTD48Mf/nDNIM695X/+85/S0z1m7h9TKivty1/+cvnlL39Zpw888MAaMMmXvu5Dm/vMlVZaqWy44Yb1vjclXe+///6yxhprlMcee6xcddVV9d42wZy03Bsn6LLkkkuWzTffvKT0q0aAAAECBAgQIECAAIFOExgRQZGuFy0/8tKuvfba+vn000/XkgT5/r73va/Oy4/OvJWXttBCC5XZZputlttaYIEFyuyzz17nH3TQQeWiiy4qG2ywQR03JKUSmh+tWeHee++tP3iTodJd+9rXvlazVlLOK0GV9HXGGWd0t6p5BAgQIECAAAEC06jAZZddVp588smy5ZZb1r/cA6bkVXtL4CEZzHvuuWe54ooryvPPP9/jPWbWveOOO+rmyRjJfWja/PPPX+add9463dd96K677lrvM/PyzZxzzlmOOeaYcsIJJ5QZZpihlpNNJzPOOGPJve2oUaPqfW/WWXjhheuLQgmefOtb36r78g8BAgQIECBAgAABAgQ6SaDjy2d1d7GWWWaZOjs/WNMSyMjbdN/4xjfK7rvvXn/U5q26448/vr7Bl8+NNtqo/jjNm3tN++Y3v1keeeSRmimSH7YrrLBCLcuVcUz60/KDd5ZZZqn7yY/S22+/vWaM9Gdb6xAgQIAAAQIECEwbAueee269p8v9Ysqm5sWXZHqsuuqqEx1gyrD++Mc/rtkZc801V70H7O4es32jT37ykzW747TTTitf//rX631nlvd2H5qATAZq32qrrcrJJ59cX95JFsgmm2xSFllkkXLSSSeV5Zdfvh5fUz6reTHn0EMPLWuvvXa9x819qkaAAAECBAgQIECAAIFOExiRQZGUwUprMj4yzkha3tpLGa20vJHXDG5ZZ3TzTzJI0leCKilhkB+OTaClm9VfMysZKylbkB+eGTDzgx/8oPFHXqNkBgECBAgQIEBg2hXIveB5551XXv/619es3xxpxgVJUOSLX/ziRAeeMq3bbLPNRPMG+qW3+9DmHjb3mGkpJXvwwQf3uquU9zr22GPrIO+5L81xvuc97+l1GwsJECBAgAABAgQIECAwHAVGZFDkyiuvrNcq9ZLTxo0b1/p87rnn6vS73vWu+pnSV9NPP32dbv8nNZkzBkjGKHnLW95SFl100fLCCy/0e+D29JW60ilXkDFKzjzzzFo6K4Ozf+ITn2jflWkCBAgQIECAAIFpVODSSy+tGcfJOt5jjz1aR5nv119//UQDo6d01WC0vu5Dc0+alkzk/rbVV1+9jr/305/+tFx44YXlT3/6U/n1r39dx8frbx/WI0CAAAECBAgQIECAwHAQGHFBkTFjxpSmTEBKCKQtvfTS9TN1oD/wgQ/U6YcffrjWec6bdd21u+66q/z5z3+ug1Dmx2Nafkym//62/KDdeeedy7777ltLFGy66aY1MCIo0l9B6xEgQIAAAQIEpq5ASmelfelLXypzzz13nc54ID/84Q9rtkgGLh/s1td96FJLLVV32WRD58sFF1xQ1lprrZKyXT21ZJZkfL28MJSXdxIcSanYBRdcsKdNzB/mAvlvqRk/cSCnkt8zyUxKObaefjcNpN9paZtXXnmljkW52mqr1TF5pqVjcywECBAgQIAAAQIDExgRQZHcrOeHXcobXH755SXZIBlXZJdddqlqO+64Y/ne975XUms5g64ne+O73/1uHQhz//33r+tk/ZTWOu644+qg6PnxMPPMM5f8kLjmmmvqX/p98cUX64/ODJzetWXgyrTUcf7Yxz5Wdtttt/Loo4+WffbZp87PG4WpQ60RIECAAAECBAhM+wK5t/zDH/5QS2ftt99+rQPOWHMnnnhiDYoccsghrfndTXS9x0yJrb5aBlzv7T707W9/e1l88cXr4On5zHFm0PS99tqrfPWrX60Dr88333wlY5zk3jbZzwni/OQnPykZwyTb3H333XUfvQVR+jpOyycWSEm1O++8s85MJnp+T2TcmeWWW27iFYfw289//vOSF8PWWGONfu31ySefrFn0TQAwv1/y303+O3/d617Xrz6G20r538/PfvazsvLKKwuKDLeL53gJECBAgAABAj0IvLYuVA8rDvfZqfWcN+QWWGCB+sPvj3/8Y6ukQGpAZzD1BDTyll/+kj2y7bbbtk577733LiuuuGL5yle+Um644Yb6ll0yOpJRsvXWW9egSH5MzjrrrDXbo7Vh20R+cKbUVoIveeMoGSL50XzAAQfUv/wIzjKNAAECBAgQIEBg2he45JJLaumsd77znRMdbO4HN9xwwxpYyH1jb63rPWZv6zbLEqjo7T40ZbPyEk4yPDI4e8YKSYb05z73udpFynhljJGxY8fWe9tnnnmm3vfm5ZzDDz+8Bk8yLwETg6036pP/mTEIc00ShMh/Mym/m6BafpdMrZb/JvobEMkx/u1vfyv/+te/WoebQEh+vwxVQCQvqWUcSI0AAQIECBAgQIDA5AhMNyG7YfzkdDA52zYDnU9OH4O97YMPPljy5lzevutPy5tDKZmVATUH2p544omSsUvy1p9GgAABAgQIECBAoD8C/bkPfeyxx0ruuROo6U/LCzvJBkiGc3fj6vWnj2ltnXvuuac0JcWm5rGdcMIJ9Tjag2i5hocddljZddddS5MllAf/KcuWjPIc9w477FB/n+TYM15MSgHffPPNZY455qgl0TbbbLPWaf3nP/8peRks1zAZKBknMb8xbr/99vL3v/+9BusS2EgpqJR2O/XUU8vb3va2mq3erPOmN72pBmvy+2TjjTeu22QHOf7sN/89zTnnnDUwl4z8ZNh//OMfb/1+Sj+//e1v6/EvscQSZfvtt2+VYGv2scIKK9RSxPndlePvKVs+wbnTTz+9Hn8CL1k/QaXFFlusnnNv+8oKvVnm5baMm/PAAw/UrJ0cx5vf/Obab/s/KSf32c9+tnz0ox+t2V95kS4u66yzTmu1XMdzzjmn3HjjjWWmmWYq66+/fl0nK+SaxSgvyGUMovxvMS/V9bZNq2MTBAgQIECAAIERIjApQ1IMBsmIyRTpL1be2OpvQCR95k28yQmIpI95551XQCQQGgECBAgQIECAQL8F+nMfmgfi/Q2IZMdZN/fDnRIQ6TfmVFox1zABqIceeqgeQQIhJ598cg0UfOYzn6kP65ONnizztL/+9a+1FPCBBx5Yxya89dZbSwJfaXm567TTTqulfhOkSEZRvidwkWBXyv7+5S9/qdc3pbvSMmZMlqXlM/2lJFZKreXB/vnnn18SaElLeeCUe0vQ5L3vfW8tOZy+E1TIZ1qOJcGTBFxSLjjBi5QpTiAhLftIoCLfs4/8t5bSVD21BESSrZTyXBnvJuPkpNRxWl/76ssyfSfolGyZBKoSLGqcuzuejJ2S8SBTnu6ss85quWfd9JUf8p/61Kdq1lUCUFdeeWXtpjH6/e9/XwMmTfCrt2262795BAgQIECAAAECgyfw/+4oB68/PREgQIAAAQIECBAgQIBAPwXy0D+BiLQ8mF9vvfVaGQsJPqRc1U033VTL8CYQ8IY3vKGWBE5Z4AQemnbZZZfVbZMFkpYgQkp2NQOgv/zyy2X33XevD+abbbp+JijWjI2YYM3jjz9ex2RcaaWV6tg5yRBJoK15sN91+xx/sj6aPjI+TY79n//8Zw2yZP3ZZputbLDBBnXTd7/73bX/BIUWWWSRrt3VAEpKDicrJpkvyTzJuCwJ6vS1r/5YbrXVVrX0V7JQUua4t5ZgSAJNcbn++utrsChl8pLNku+HHnpoDeCkrwRkUl6vPZskmSg5/rT+btPb8VhGgAABAgQIECAwcAFBkYHb2ZIAAQIECBAgQIAAAQKTJZBMgiZTPcGBPHhPRkjTEhBIRkdaBvtOyac8VM94h/neBD1SDqr9IXzm5wF+0zI4eko79daa42jWSZmrlOPqb8vxN0GZZpscZ5MJk3nJjmlaxrdJgCPn111QJOWyEmDIGJAp55WgUDzS+tpXfyyTpfLWt761BkSWXHLJ5rC6/Wy3SwZMc00SeMo5JTukaSlfluNuMmgyP0GspvW1TXNNm/V9EiBAgAABAgQIDK6AoMjgeuqNAAECBAgQIECAAAEC/RbIA/RmLIuMM5HSZe0PxRPoSFAgbfXVV6/jeVx33XV13I7f/OY35ZOf/GSd12xbVxykf/Kwvyl91Z8us2570CPb5HtToqu7Pnor1ZayVmeffXa54447SoI+KTucrJW0vvbVePRk+f73v79cffXVtSTXj370o2q89957d3eIr5nX3mf2k+/t83KcGfukPSjS3klf27T31b6daQIECBAgQIAAgcEREBQZHEe9ECBAgAABAgQIECBAYJIEkvmQrIGmHFUyI1JiaaONNmr1k3EuklHRtKybvzxwP/7448sNN9xQB0vPg/j77ruvZj406+bhe9cgRbOsu8+uY2pkkPqUg+pvS2mtu+++uw4A32yTsUyWX3755uskfSYrJAGjZJM0mTGNRV/76ssywZg111yz/mUw9K9+9av1WjTjrfT3QLOfuGXw9SaYkayWroGS9v4Gsk379qYJECBAgAABAgQmT8BA65PnZ2sCBAgQIECAAAECBAj0SyAPzxOoyEP4jI1x4okn1iBGE3hYa621yqWXXlqefvrp2l9KMH3jG99oZVr88pe/rEGQZmfjxo0rCy64YP2aMlAZ2+L++++v32+//fZy9NFH9zp4eNNP8/nEE0+UBELSMnB7MilWXXXVZnHroX9rRpeJtddeu9x444118PUsyqDqXQM1XTbp9WtKd2UMlYz3kUHR27NK+tpXb5bxP+6442oQJAeQ8VYSbEmJsUltCaLkGjQlzxIQOffcc8uf//znHrvqa5tc9zPPPLPk+qb19b3HHVlAgAABAgQIECDQrYBMkW5ZzCRAgAABAgQIECBAgMDgCvzxj38s+cvD/TwYTzmsTTfdtLWTZEOsu+665cgjj6wDkucBewYjzwDoaVn2i1/8opaUSh8JGDRZJhlfJAGIb3/723X9jA+y/fbbT5Rl0tpRDxMZ9yJBjVNOOaUO/p7jy8DvTcs+Tj/99HLRRReVww8/vJnd+kxGyEYTsly+853v1PFLks2y8847l2RGDKQl0JP9JWCRvvKZ7I5tttmmZp/0tq++LBNo+f73v18HR0/fGRw+g94PpO26667l1FNPrYOr55plfJLddtut16562ybZNpdddlnNAMpYK31973VHFhIgQIAAAQIECLxGYLrnnntu/GvmDtGM2WeffYj2ZDcECBAgQIAAAQIECIxEgWQ+JMtgOLU8WH/22Wd7zFwYM2ZMfYDflJJqP7dko0z4jdfjtu3rtk8nGJKAzac//elWhsJAgwQ5/gwGn8yLpqRU+776M52yYieddFI54IADWsGKp556qnzzm9+s46ikfFZaX/vqyzJZORncfqDH2X4ucc+A7O2Dsrcv7266p21yjdt/L/f1vbu+zSNAgAABAgQIDBeB3OsMZZMpMpTa9kWAAAECBAgQIECAAIE+BJIF0lspp/aH5V27GmgZqPZ+BhoMafrI8c8zzzzN1wF9psRV/hI0yPEk2JMyUpk3atT/fsb2ta++LHtzntQDzxgok9p62qbrNe7r+6Tu1/oECBAgQIAAgZEs8L+7yZGs4NwJECBAgAABAgQIECAwggVSomvhhReeZgRSguptb3tbHUw+47AkkyODye++++6THXCZZk7SgRAgQIAAAQIECEwVAeWzpgq7nRIgQIAAAQIECBAgMBQCw7F81lC42AcBAgQIECBAgACBaUVgqMtnTT+tnLjjIECAAAECBAgQIECAAAECBAgQIECAAAECBAhMSQFBkSmpq28CBAgQIECAAAECBAgQIECAAAECBAgQIEBgmhEQFJlmLoUDIUCAAAECBAgQIECAAAECBAgQIECAAAECBKakgKDIlNTVNwECBAgQIECAAAECBAgQIECAAAECBAgQIDDNCAiKTDOXwoEQIECAAAECBAgQIECAAAECBAgQIECAAAECU1JAUGRK6uqbAAECBAgQIECAAAECBAgQIECAAAECBAgQmGYEBEWmmUvhQAgQIECAAAECBAgQIECAAAECBAgQIECAAIEpKSAoMiV19U2AAAECBAgQIECAAAECBAgQIECAAAECBAhMMwKCItPMpXAgBAgQIECAAAECBAgQIECAAAECBAgQIECAwJQUEBSZkrr6JkCAAAECBAgQIECAAAECBAgQIECAAAECBKYZAUGRaeZSOBACBAgQIECAAAECBAgQIECAAAECBAgQIEBgSgoIikxJ3Snc9x133FHy17QLLrigPPjgg81Xn/0U4NZPKKsRIECAAAECQyowduzYcs8995Rx48aVF198sTz22GOt/T/55JMlfxoBAgQIECBAgAABAgQITJpAxwdFnnnmmfLrX/+6HH744eVrX/taOe2008oDDzwwaUrdrD1+/Pj6I7WbRUM26wc/+EHJX9OOOOKIcsMNNzRfffZTgFs/oaxGgAABAgQIvEbg3nvvLX/961/LmDFjJlqWAMYVV1wx0bxJ+fLss8+WCy+8sIwePboGRB566KHyj3/8o9XF3XffXfKnESBAgAABAgQIECBAgMCkCXR0UCSBi+OPP7688sorZeeddy677bZbWWKJJcp5551X8ubd5LQXXnihfP/735+cLiZ7229+85slfxoBAgQIECBAgMDUEXj++efL008/Xa655pqJDiCZHZOTyfHII4+Uueeeu6y11lplrrnmKksttVTZcsstJ9qHLwQIECBAgAABAgQIECAw6QKjJn2T4bPFyy+/XMsM7LjjjmXJJZesB7744ouXjTbaqE7/+9//LjfddFPJ8qbdf//95Q9/+EPZa6+9SgIfv/rVr8rNN99c5phjjvqjdLPNNiv//e9/6/z0f/TRR5c111yz1eff/va3cumll9YyByuvvHLZdttty0wzzVS7v+iii2qAJpkq//nPf8rSSy9ddt1119p/SjjNOuusZfPNNy8rrLBCXf/hhx8uP/zhD8vuu+9elllmmeYQW58/+tGP6vRHP/rR1ry8VZgA0FVXXVVWW2218p3vfKcsssgidXn6eumll+q+s7+3vvWtJX3k7cZjjz22/vA+8MADy8Ybb9zq77e//W056qijynPPPVc+8pGP1PJca6yxRnnf+97XWqeniVdffbV8/etfL+kjftlm3333LTPOOGPdZO+99y4f/OAH67EmwyVZPJdffnk55ZRTyqqrrlq+/e1vl9e//vUlmRyjRo0qX/3qV+v+c2323HPP1m5TMuzTn/50+ec//1lyfT/3uc+VXKe0vLX57ne/uxx66KHlsMMOq8GwffbZpxq1OmibyDXdb7/96jVt30fbKiYJECBAgAABAhMJLLDAAvUe77777qsv4Ey0sO3Lo48+Wq677rqS+7V555235J5qzjnnbFvj/03mPvH2228vuS/505/+VO9LMp1566233mvWb2bceuut5bbbbqv3e4sttlhZffXVywwzzFAX5/7z+uuvLwnizDfffD3uu+nLJwECBAgQIECAAAECBDpVoKMzRfLwPQ/XTz/99BoIyEP69pYH7ldffXUNYDTzr7322rLgggvWrwkWJBiQQEECDfmhmVIIefC+1VZblemnn768973vLQl+pKWkQcokJIiRB+9PPPFE3XddOOGfp556qj64TxAly1Mf+qSTTip5EzDbLLvssjUwkAyXpmUfPbWUUchfezvjjDPqQ/30m/NNv03LurHYfvvtyy9/+ct6bnvssUf9gX3iiSeWt73tbSUBlsYpP8g/9rGPla233rqWIEvQJlk2jz/+eNNlr59nn312SeApQY4EJbLPmDYt46EkaJPjimdayp1dcsklNZB07rnnlje96U01GJPzSvmzT33qUzVIkkBVWh4QbLfddmWhhRYqWSdBlv3337/kOqYlSyiBr4svvrh873vfKwnEfP7zn++x3MRnP/vZet3a3WpH/iFAgAABAgQI9CKQAEeCDnkBpbuWe8q8OJP7yLyAMs8889TyWLmX6dqS2Zy/ZIjkXjYvl6TfBFN6anfddVcday5Bk7e//e31xZC8JJOWfeQeNfdVW2yxRVl44YVr8KSnvswnQIAAAQIECBAgQIBAJwv0/MS9Q856m222KSuuuGI59dRTyxe+8IXyxz/+sRUEyQ/MlCLIQ/Om5cdsMizSEgB5wxveUPL2X7I6EiCYf/756w/TBFQSsHjjG99Y52X9ZIIkSJIfu/l7z3veU4Mu7TWmE/hYaaWVan/5wZpa0M2P0wQGEpBItkpafrB+5Stf6TZLpK7QzT/JesmP4fXXX7+W98r53Hjjja0111133fKOd7yjZr0kQPCvf/2rHHTQQWW55ZYrBx98cA0iNOOS/OxnPysbbLBBDSIkeyUBlHj0tyUz5OSTT64/wNPPBz7wgXLOOedMtHkyOr71rW+VnXbaqTU/b04mSyPXLdcsHu9617uqW84vwZtYp+V6JviUjJ08NEgWSdZNVkx7y/ycYzJz1l577ZJMma4tpdYS2DrhhBNqZkrX5b4TIECAAAECBHoSSMZHsjPa77va183LNXnxJvc3r3vd6+p9S17gyb1g15a+8jfzzDPXFz+arOOu67V/TyZz7mHTd/5WWWWVkvFOUsYr2SFpuT+dffbZa1Zyskg0AgQIECBAgAABAgQIjESBji6flQs622yz1UyHTTfdtJapyoCVCQQccsgh9Xrnx2OCAHm7L2WYkqXRlNpKBkgGaU/2Qn7A5vt0003X7X8nCWYk4yNlDdoHck/gJKUS8gM0rSkdlemUtUpJgyYbJH0n4yH95O3AgbRmP9k2feW477zzzvLmN7+5dpdsj6Yl0JHjSWmqtCbIk/UTYEgmR9zaW3v/7fO7m865JbCUGtsJXDSZNu3rdlcWrP0YE5BKkKR9Xo47x5aWjJEEl5rSEJm3ySab1GySTDetffu8Jdls3yxPkCXluzJGS+p3awQIECBAgACBSRXIPUayavPSTdeWjOHmHrNZlhdgMh7J5LbcvyaLJPeQ2U9a5uXesinVlXu43AfnHjPHkXtkjQABAgQIECBAgAABAiNRoOMzRZqLOssss9S35z7+8Y/XH4d5cy7tLW95S7nllltqSYL2LJEsyxt0yVjID8qMi3H44Yf3WLYgZQkSGMnD+azf/KX0VEofdNeyTtfW3byu60zK97xh2Lwd2HW7JhjTPr99XsZUyfYDbZdddlkd2yO1sBMYStmIgbT2Y8r27UY5t/aAR5bn+9ixYzPZbevaX1bKMaasVjJOBnqc3e7MTAIECBAgQGDECCSjIy+k5J6ya0tJz+ZFlGZZvndXPqtZ3t/P9J0gSPs9Tu6X8lJM7oEznUzhBERyT3b++efXF0v627/1CBAgQIAAAQIECBAg0EkCHZ8pkh9+yTZoWn585sfhk08+Wd+SSwmtvC2XkgP5AZvySu0t5bHylx+aKa+UrJKUb+ra8iM4ZQ7y4zOlCZqWH6ntWQzN/Cn12V7HOmOW5Lzaj2dS9psSEBmbY7fddmttNik/3DOI+2c+85ladisdZEyRM888s9XXYEykrFlKaLW31M/O/ElpKVOW0mfJGDnyyCNrAGxStrcuAQIECBAgQCACKdeZzOFkbbS33HMmg/b1E0qwNi3fk9k7ua25v829W0pnNS0v7DSBkmQHJ9s2f9nv3//+9xrAadb1SYAAAQIECBAgQIAAgZEi0NGZIvkxetRRR5Urr7yyZoKkpnIGuEx2QfsP0pSKSlZDfjjmx2TT8hC/GV8j8xJkaAZhb89WaNZfa621asZBE5jItgmkDLRlLJIMHp4ATn9b3vzL/nOO3//+92uWSsbQGEjLmCgJOPzzn/+sm2cAz+7efOyp75RpSFAqLcGh/Pge7JbxQ0aPHl0yKHuuXx5CJKsnA65PSkugLC0BkZ/+9Kfluuuum5TNrUuAAAECBAgQqAIJQiQTOfck7S0vbKTEalPeKvcvKS/afk/avn5f013vRdN/xsnLPVdaxmS75JJL6nTuJXOv29yj5jMv82gECBAgQIAAAQIECBAYiQIdnSmSAEbKX/3mN78pZ511Vr2+eVCfbJD2cSPywzUZDO985zsn+m8gg5L/4he/KGeffXZ9yy6DjCdrJC0DrieAcuCBB5YM5r7hhhvWUlEZg+RLX/pSSeZIs6+JOp2ELwnqJJCw/PLLT/TWX29d5FxyHvkhnNJXP/7xjycax6S3bbsuyyDoO+ywQ82giGXG7mgGoe+6bnffP/KRj5QDDjig2scipany/Ytf/GI57LDDuttkkuflbcgTTzyxpCxaslISSNp3331LBnkfSMv13Weffep1TUmtrmUuBtKnbQgQIECAAIGRJZAs5KY8a3PmGT8k93QXXHBBK4s4L67kHmkgLWPTXXHFFbX81pprrllWWmmlkmzZvByS+5fcB66zzjq169z35gWQ3//+93V+spjzUpBGgAABAgQIECBAgACBkSgw3YTxE8ZPrRMf6I/AgRxvsjySKdLd+B4pjZVAxn777Vfyg7Vry4P2/JDsbxmsjMWRMlODcX7Z90D6eeihh+q5dH2LsOu59ed7xueI3TzzzFNLaW2wwQY12NSfbbNOskUSRBqMY+ltnw8++GAtldY+mH1v61tGgAABAgQIEBhqgdx3JqN3Sg10nnvQZIt0Ny5c9p371CZDdqjPfWrt75577ilLLbXU1Nq9/RIgQIAAAQIECBAg0IdAnoEPZevoTJF2yPz46+4HYAbVzpt8KSHQXUAkfUxqUCI/Qrv7Idp+PP2dntR9N/3m7cHBavnR3t0P9wSSEojorh188MGtrJr2MV26W3ew5i266KKD1ZV+CBAgQIAAAQJTRCAviXR3XzVYO0uWSE+Zrtl3d/fDg7Vv/RAgQIAAAQIECBAgQGA4CIyYoEhPF+N60/B1AABAAElEQVTf//53LTUw0HJLPfXbqfNT9zpZH2mbb755efbZZ7s91WadbheaSYAAAQIECBAgQIAAAQIECBAgQIAAAQIEpoLAiCmfNRVs7ZIAAQIECBAgQIAAgaksoHzWVL4Adk+AAAECBAgQIECgD4GhLp81fR/HYzEBAgQIECBAgAABAgQIECBAgAABAgQIECBAoCMEBEU64jI6CQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAvAUGRvoQsJ0CAAAECBAgQIECAAAECBAgQIECAAAECBDpCQFCkIy6jkyBAgAABAgQIECBAgAABAgQIECBAgAABAgT6EhAU6UvIcgIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAjBARFOuIyOgkCBAgQIECAAAECBAgQIECAAAECBAgQIECgLwFBkb6ELCdAgAABAgQIECBAgAABAgQIECBAgAABAgQ6QkBQpCMuo5MgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+hIQFOlLyHICBAgQIECAAAECBAgQIECAAAECBAgQIECgIwQERTriMjoJAgQIECBAgAABAgQIECBAgAABAgQIECBAoC8BQZG+hCwnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEOkJAUKQjLqOTIECAAAECBAgQIECAAAECBAgQIECAAAECBPoSEBTpS8hyAgQIECBAgAABAgQIECBAgAABAgQIECBAoCMEBEU64jI6CQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAvAUGRvoQsJ0CAAAECBAgQIECAAAECBAgQIECAAAECBDpCQFCkIy6jkyBAgAABAgQIECBAgAABAgQIECBAgAABAgT6EhAU6UvIcgIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAjBARFOuIyOgkCBAgQIECAAAECBAgQIECAAAECBAgQIECgLwFBkb6ELCdAgAABAgQIECBAgAABAgQIECBAgAABAgQ6QkBQZJhdxuuvv77kTyNAgAABAgQIECBAgAABAgQIECBAgAABAgQmTWDUpK0+/Nb+3e9+V+68887Wgc8zzzxljTXWKCuuuGKZYYYZWvOHy8SZZ55ZD3WVVVYZLofsOAkQIECAAAECBAgQIECAAAECBAgQIECAwDQh0PFBkdGjR5cFF1ywBkIiPmbMmHLBBReUhx9+uLzjHe+YJi5Cpx/EZZddVu6+++6yyy67dPqpOj8CBAgQIECAAAECBAgQIECAAAECBAgQmIYFRkT5rPnnn78st9xy9W+11VYrb3/728tVV13VuizHH398uf/++1vf//Of/5Rf/OIXre8XXXRRufDCC8vZZ59dvvjFL9Zljz32WGv5P/7xj/KVr3ylvPDCC6157RPXXntt2WGHHWp2yr777lvyvWkJ0myyySYlgYPNN9+8bLDBBuXnP/95s7jHz0MOOaSsvPLK5ROf+EQNOLSvePnll9e+ll122bLddtuV22+/vbX4j3/8YznwwANb3zOx6667to4p2+69997ln//8Z9lrr73K73//+4nWzZcnnniifOQjHylvetObyvbbb19++9vfTrROAlHpM/vfaKONSnzj3rQTTzyxrLvuutVj//33L88991yzyCcBAgQIECBAgAABAgQIECBAgAABAgQIEJhiAiMiKNJV75577imLLbZYa3ayRl588cXW9+eff760Bz2eeuqpGkRJYCWBgmeeeaYkuNC06aefvsdSXK+++mr55Cc/WYMT5513XlliiSXKQQcd1GxaXnnllXLTTTeViy++uHzve9+rAYnPf/7zrwl0tDaYMHHJJZfU4Mlpp51WEoA4+uijW4vvuuuu8qEPfahstdVWNYiTwMl73/veMnbs2LrOk08++Zq+b7vttlZgIueWgNGxxx5bVlpppRpIanX+fxOHH354WXTRRUtKk+200041MJNASdNyfnPPPXdJsOjQQw+t5zbTTDPVxaeffno57rjjygEHHFBOPvnkkuPZZ599mk19EiBAgAABAgQIECBAgAABAgQIECBAgACBKSbQ8eWzInfjjTfW7IZM5yH8Aw88UPbYY4987Xdbeumla2ZGNkhGxwknnFDGjx9fpptuurLmmmvWv+46S8AkwZA55pijLk7AINsmEPHGN76xtUmCLQsttFANQiTYkBJfe+65Z2t5+0T2l2NIS9ZHgiAJvmRfP/nJT8p6661XAxVZ/pa3vKX8+c9/Lr/+9a/7fc7JeMkxzjrrrOniNS2BjuZ8lllmmfKrX/2qBkh22223uu7f//73csYZZ5T55puvbLjhhiXjnyRAkvP9wQ9+UANLyZxJW2qppWoWya233tptAKau5B8CBAgQIECAAAECBAgQIECAAAECBAgQIDAIAiMiKDLzzDOXueaaq4wbN67897//LZ/97GfLwgsvPEl8M844Y2v9ZJmk7FWyL2afffbW/J4mElxIdsd9991XS2ylr2SitAdF2gMQKUt1xx139NTdRMGKrJssjWSzzDvvvOXmm28u22yzzUTbpjxX5ve3LbLIIhPto+t2CYhcf/315ZZbbqkZJs8+++xEmTUJdOT4M6B9MmHunjCeSAIkL7/8ci3lleNpWva1wgor1ONLJo5GgAABAgQIECBAgAABAgQIECBAgAABAgSmlMCICIrkYfs73/nOanjvvffW8TO23HLLAZsmO2RSWrIiEkBZe+21y2yzzVazOnrbPhkf/W1d181+2gMs6SffUxZrsNoxxxxTM082mjBeSMZr6TqWSsqFfeELXyhXXnllDUKlZFgGtX/ppZdqYKS742vKew3WMeqHAAECBAgQIECAAAECBAgQIECAAAECBAh0FRgRQZH2k87D+Z/97Gdl4403LrPMMktdlMyHlNVqWkpRDVa77rrratZExulosk1SbmpKtZT5yr523HHH1i7yPYPLpyWIkfJh7S3ZHP1tCYCkRNe5557bKneVDJj2lqyQLbbYoiy//PLVOdM59/ylRFiOZ/HFF6+bJBiSMVVy3BoBAgQIECBAgAABAgQIECBAgAABAgQIEJiSAv1PSZiSRzGEfWfw8Hnmmadcdtllrb1m3jXXXFPLayUgMimlptJJsk/OPvvsbjNAUl7rueeeKxm8Pa19fJM6Y5D/ycDnGQQ+gYa0nOe1115b3v/+99fv66+/fnnwwQdb53/DDTeUDDTf3zZq1KiScmSPPvpo3SRlu1JKq70dccQRZd111y3JxkkJrWzTtA984AM1KNUMbp8ASzJJMk6KRoAAAQIECBAgQIAAAQIECBAgQIAAAQIEpqTA/55WT8m9TEN9p/TVpptuWs4555w6CPhMM81UH8jfeeed5ctf/nKZe+6564Dqedjf35axNRJ8yODnXccYybgh2223XQ0SLLjggnWfKS21yy67lKuvvroOjt7f/fRnvWSE7LPPPmWrrbaqZbMyGPz3v//9suSSS9bNU7rq4IMPLnvvvXfN3MgxZ4yU/rYZZpihfOYznykf+9jH6mDr2TYDr3/84x8vCS4lEJIAzKc//enaf4JMMd5+++3LV77ylZLSWhlsPkGQHEvGdsmg7ulXI0CAAAECBAgQIECAAAECBAgQIECAAAECU1JguglZDOOn5A5667trAKG3dYdiWcbdyJgf7ZkN/dlvAg8pA9Xb+WSQ9xdffLEO+N6fPid3nQxq/sgjj5QMZN7dGCgZ3yMDtKec1UBagh3ZPuW42tttt91WPvzhD5fzzz+/zDnnnHVRMlNStuy8885rlcmKVzJoEijSCBAgQIAAAQIECEwpgXvuuacstdRSU6p7/RIgQIAAAQIECBAgMJkCY8aMmcweJm3zEZcp0hvPXHPN1dviHpcl6NBbQCQbZvySZgyTHjsaxAUJ7Cy66KI99tiM79HjCn0syADvXQMi2ST/ASfY8dhjj9WgSIIvd911V52fsltNS/ApfxoBAgQIECBAgAABAgQIECBAgAABAgQIEBgqAUGRoZIeIftZddVVy+67714++MEP1jFaEjBK6a6MHdJbkGaE8DhNAgQIECBAgAABAgQIECBAgAABAgQIEJiKAspnTUV8uyZAgAABAgQIECBAYMoKKJ81ZX31ToAAAQIECBAgQGByBYa6fNb0k3vAtidAgAABAgQIECBAgAABAgQIECBAgAABAgQIDAcBQZHhcJUcIwECBAgQIECAAAECBAgQIECAAAECBAgQIDDZAoIik02oAwIECBAgQIAAAQIECBAgQIAAAQIECBAgQGA4CAiKDIer5BgJECBAgAABAgQIECBAgAABAgQIECBAgACByRYQFJlsQh0QIECAAAECBAgQIECAAAECBAgQIECAAAECw0FAUGQ4XCXHSIAAAQIECBAgQIAAAQIECBAgQIAAAQIECEy2gKDIZBPqgAABAgQIECBAgAABAgQIECBAgAABAgQIEBgOAoIiw+EqOUYCBAgQIECAAAECBAgQIECAAAECBAgQIEBgsgUERSabUAcECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAcBAQFBkOV8kxEiBAgAABAgQIECBAgAABAgQIECBAgAABApMtICgy2YQ6IECAAAECBAgQIECAAAECBAgQIECAAAECBIaDgKDIcLhKjpEAAQIECBAgQIAAAQIECBAgQIAAAQIECBCYbAFBkckm1AEBAgQIECBAgAABAgQIECBAgAABAgQIECAwHAQERYbDVXKMBAgQIECAAAECBAgQIECAAAECBAgQIECAwGQLCIpMNqEOCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgeEgICgyHK6SYyRAgAABAgQIECBAgAABAgQIECBAgAABAgQmW0BQZLIJdUCAAAECBAgQIECAAAECBAgQIECAAAECBAgMBwFBkeFwlRwjAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMNkCgiKTTagDAgQIECBAgAABAgQIECBAgAABAgQIECBAYDgIjPigyH333VfyN7XaU089Vf7zn/8Mye6zn+xvqNqDDz5YLrjggh5399JLL5Uzzzyz5DPt1VdfLRdffHH97HEjCwgQIECAAAECBAgQIECAAAECBAgQIECAwAAFRg1wu2Gz2TPPPFP+8Ic/lNtuu61MN910ZckllyybbLJJWWyxxeo5/Otf/6qfSyyxxFQ5pwRk/vjHP5aVVlppiu//vPPOK1tssUWZZ555+rWv7bffvjz//POtdVddddWyww47lLe85S2teb1N3HDDDeXoo48u73jHO7pdLX3vt99+ZbPNNiszzjhjeeihh8ouu+xS/vGPf7SuT7cbmkmAAAECBAgQIECAAAECBAgQIECAAAECBAYg0NFBkfHjx5fjjz++PmDfeeed64P322+/vSQ4kIfvs8022wDIRs4m11xzTfnc5z5Xll9++XrS99xzT4njqaeeWlZfffVBh0ig6q677qrXadA71yEBAgQIECBAgAABAgQIECBAgAABAgQIjHiBjg6KvPzyy+Wxxx4rO+64Y80QydVefPHFy0YbbfSaC3/22WeXa6+9tqy44oo1c2H++eev6ySw8vvf/75cd911ZeaZZ67BgI033rjMMMMMdXkCBGuvvXa5++67y/3331/23HPPOv9vf/tbufTSS8u4cePKyiuvXLbddtsy00wzvWa/3c1IVsu5555bHn300bLUUkvV7Iz55puv3HTTTSXZFzvttFNrs1tvvbVcffXVrXmTst9f/vKX5bnnnit77bVXq7+uE6usskpZc8016+wNNtig7j8lrxIUSYbLX/7yl3LMMce0Ntt1113Lpz71qbLaaqu15p1xxhk1Y+SVV14p++67b8uotcL/TYwZM6a8+93vLr/73e/K7LPPXuem/NYRRxxRbTfccMPyhS98obz+9a/vuqnvBAgQIECAAAECBAgQIECAAAECBAgQIECgT4GOHlMkJZlS8un000+v43ZkzIruWgILyy23XA0OpNxWHvY3LQGHBx54oHz4wx8u733ve2tpp/YxQB555JEaGMhYHW9+85vrZin/dMUVV5Tdd9+97LPPPuWJJ56ox9D02dtnAiEnn3xyDcx85jOfKQsttFD54Q9/WBJQSIAk2RvtJa1S/mvhhRce0H4T2Jl++kn7TyCBoyZI8uSTT9ZgUPv5JKCTQEvTMq5I/n72s59VjyOPPLLHcUZyjgn85DMtzh/96EfLxz/+8RooiUU8E6jSCBAgQIAAAQIECBAgQIAAAQIECBAgQIDApAp0dKZIMLbZZpty0UUX1ZJPCQC8/e1vr5kis8wyS8tq6aWXrtkcmbH55puXE044oT54zxgkyYjIGBpNlsdaa61VAxNNACTbJBMk2SNNy/4SQElWStp73vOemk3xvve9r5UB0azb9TOZHuutt14rwJJ+EvhIsCDHkcBIpt/61rfW4MG///3veszpZ1L3m/FB+mrf+973ygILLFBXu/766+ug9D2NEdJdX3PPPXf5xCc+URcl8HTvvfeWn/70pz2OM9Lex0knnVSSeZJrmHbooYe2xoZpX880AQIECBAgQIAAAQIECBAgQIAAAQIECBDoj0DHB0UybsjWW29dNt1003LzzTeXCy+8sAYZDjnkkJZPMkqalnEtUsZp7NixNYCRQEoyHzKeRuaPHj16okyIbNeU2sp0slGSPZKxS5Jh0rT0kyyQpixUM7/rZwYbn2uuucpf//rX1qI55pij9pkZKWeVEloJiiQrY9555y0prTW5+23trMtE9p2B2RMgShmyWM4555xd1ur5a9fzTfDo61//es8btC3J+bWXCothM75J22omCRAgQIAAAQIECBAgQIAAAQIECBAgQIBAvwQ6PijSKCQzJONcJKsjAZFkLCy55JLN4tZnHv63tzyYP+WUU8oKK6xQgx8vvPBC++LXTGcckwQoUpqqva8EExLs6Ku99NJLtaRV+7brrLNOef3/jaORbJGMuZH1brzxxhokSZ+Tu9+ejmuPPfZolcvqaZ1JmZ9xWdrLf/W2bcZjacZu6W09ywgQIECAAAECBAgQIECAAAECBAgQIECAQH8EOj4okuyMpvxTQEaNGlUSIMl4GN0FRbqipSTVlltuWdZff/26KOOFpJxVTy1ltpJJkfJaTfmsrJtxMvrzgD9ZH0sssUQt8dXso33blKNadNFFayZKxtzIwOVpk7vfZl+T8pkMmfZsmGzbjAfS9JPgTXvLmCTtLu3Luk7HISW7tt9++9aiBKUSWNEIECBAgAABAgQIECBAgAABAgQIECBAgMCkCkzaKNuT2vtUXj9lrI466qhy5ZVX1syKF198sVx66aU1U6HJvOjrEPMA/tlnn62rJQMkmSN9tYw78qc//anuM+um3NXxxx/f7WbtGSFZIdvmGJ9++um6foI63/jGNybKrkgJrZQBS3BnwQUXbPXb13677ivBnexroC2Bogyiftlll9Uucp4PP/zwRN3dd999dQyWzEwQ56yzzirvfve76zpdj2eiDSd82W677cp5551X/bLs8ssvL5tssknLtev6vhMgQIAAAQIECBAgQIAAAQIECBAgQIAAgd4EOjpTJAGDPffcs/zmN7+pD+MDkTEuMnh3Mi760zbaaKPyq1/9qlx99dU1QyFZC/l+zjnnlAyc3l3bbLPNyq9//evypS99qWZwNPvsbt0EZxKsOfzww2tZrxVXXLGsu+665cgjjywZDyWBmAQRZp111tbmCYr89re/LVtssUVrXib62u+qq65aTjvttJIB1jMmyVVXXVUDPhtssMFE/fT3S47p4IMPLnvvvXfJuCwZpD5jsrS3ZZZZpvzhD38oe+21V80qidmHPvShukoyanLMK620Ug1cdS0vlvNLpkhTeiweCXK1jwHTvi/TBAgQIECAAAECBAgQIECAAAECBAgQIECgN4HpJgwiPr63Fabksq6DcE/JfWV8igQfuj547+8+ky2SQcf7ym5o7y+lnjLWx0DOM8GQ7LO/wZuB7DelrbKfyS1HlX6eeOKJstBCC7UfxkTTOZfx48cPyD/9P/7442XhhReeqE9fCBAgQIAAAQIECPQlcM8995Slllqqr9UsJ0CAAAECBAgQIEBgKgmMGTNmSPc8YoIiQ6pqZwQIECBAgAABAgQITBMCgiLTxGVwEAQIECBAgAABAgR6FBjqoEhHjynSo7IFBAgQIECAAAECBAgQIECAAAECBAgQIECAwIgTEBQZcZfcCRMgQIAAAQIECBAgQIAAAQIECBAgQIAAgZEpICgyMq+7syZAgAABAgQIECBAgAABAgQIECBAgAABAiNOQFBkxF1yJ0yAAAECBAgQIECAAAECBAgQIECAAAECBEamgKDIyLzuzpoAAQIECBAgQIAAAQIECBAgQIAAAQIECIw4AUGREXfJnTABAgQIECBAgAABAgQIECBAgAABAgQIEBiZAoIiI/O6O2sCBAgQIECAAAECBAgQIECAAAECBAgQIDDiBARFRtwld8IECBAgQIAAAQIECBAgQIAAAQIECBAgQGBkCgiKjMzr7qwJECBAgAABAgQIECBAgAABAgQIECBAgMCIExAUGXGX3AkTIECAAAECBAgQIECAAAECBAgQIECAAIGRKSAoMjKvu7MmQIAAAQIECBAgQIAAAQIECBAgQIAAAQIjTkBQZMRdcidMgAABAgQIECBAgAABAgQIECBAgAABAgRGpoCgyMi87s6aAAECBAgQIECAAAECBAgQIECAAAECBAiMOAFBkRF3yZ0wAQIECBAgQIAAAQIECBAgQIAAAQIECBAYmQKCIiPzujtrAgQIECBAgAABAgQIECBAgAABAgQIECAw4gQERUbcJXfCBAgQIECAAAECBAgQIECAAAECBAgQIEBgZAoIiozM6+6sCRAgQIAAAQIECBAgQIAAAQIECBAgQIDAiBMQFBlxl9wJEyBAgAABAgQIECBAgAABAgQIECBAgACBkSkgKDIyr7uzJkCAAAECBAgQIECAAAECBAgQIECAAAECI05AUGTEXXInTIAAAQIECBAgQIAAAQIECBAgQIAAAQIERqaAoMjIvO7OmgABAgQIECBAgAABAgQIECBAgAABAgQIjDgBQZFBvuTjx48v//3vf0s+e2rXXnttef7553taPNnzn3rqqXLVVVe1+rn++utL/qalNnr06HLppZdOS4dUj+Wiiy4qjz/++BQ5rlyTXBuNAAECBAgQIECAAAECBAgQIECAAAECBKaOQMcHRX73u9+VY489tvX305/+tNx8883l1VdfnSLieej9k5/8pNeH36effnp58sknp8j+0+lf//rXsv/++7f6P/PMM0v+pqX2q1/9qvztb3+blg6pvPTSS2WfffYpM8000xQ5rlyTXBuNAAECBAgQIECAAAECBAgQIECAAAECBKaOwKips9uh22syEhZccMGyxhpr1J2OGTOm/OlPfyoPPvhg2XTTTQf9QF73uteVo446qswwwwyD3nd/O9xuu+3Ke97znv6uPlXWu+CCC8rnP//5qbLvnnZ6xRVXlJVXXrnMOeecPa0yWfOTGTPjjDNOVh82JkCAAAECBAgQIECAAAECBAgQIECAAIGBC3R8pkho5p9//rLccsvVv9VWW628/e1vL//617+q2u23315OPfXUctddd5VTTjmlVWYqGR8//vGPy+c+97ka5Ljpppvq+s8880z51re+VV5++eX6Pf+MHTu2fPvb367zXnjhhbo8n2kpo3XeeeeVL33pS+XII48st9xyS53f/s9tt91WjjnmmPLZz362HHfccROVb+ru+JLl8vWvf71ceOGF7d20pi+//PKy3377tb43E1/+8pfLSiutVDbZZJOSAEDTsv7ee+9dfvjDH5Y3vvGN5Z3vfGf1ue6668r73ve+svbaa5cTTjihWb3Xz5QO23rrrcvyyy9fjyEZIdlve4ttzmvNNddszT7xxBPLuuuuW1ZcccWa5fLcc8+1luW4fvCDH9R+ujv+rHjZZZeVzTbbrCy77LJlhx12KPfcc09r++b8fvnLX9Z9vv/97y+Z17X95S9/Ke94xztas2OSDJv0u8IKK9Trk+t52GGHlVVXXbV85CMfKbl2Tct1Ofzww+s+Nt544/Ld7363Zp80y3NNmv0mOJfrkOPefPPNywYbbFB+/vOfN6v6JECAAAECBAgQIECAAAECBAgQIECAAIEpIDAigiJd3fLAfOmll66zM7ZHAiJ5IL7ooouWhRZaqJbWykP4ueaaq+y77741KJAH1vfee2+dlzJLt956a6vbf//732X22Wcvo0aNqkGQBx54oDWmSB56/+Mf/6gPvnffffcaDMj2TXv00UfLySefXB+8f+Yzn6n7TxDglVde6fH4pptuupqJks/uWgI3d9xxx0SLMlZGHuT/+te/LmuttVbZaaedWsGXrH/JJZfUslHnnntuedOb3lQf+J9xxhnla1/7WvnUpz5VjjjiiFp2bKJOu3zJee24445l8cUXL7/4xS/Ke9/73npucWtvOZYNN9ywemV+yoklGHTAAQfU9VNaLGWsmvbQQw+VBDR6Ov6c6//3//1/9TjTdwI7CXw0zjm/XIcEr372s5/VwFB3QaOUtmoPiqTfs846qwbFErQ6//zzy4c+9KEauEkZtnHjxlWX5jjPPvvskv8WElw79NBD6zG3l8tKfzmWtFzfBNouvvji8r3vfa8GpZI5c/fdd9fl/iFAgAABAgQIECBAgAABAgQIECBAgACBwRfo+PJZIbvxxhvLE088UfXywD1v9yfY0bRkfSRg0YwlkUHJ8yZ/Mg6mn376suSSS5aHH364ZmZkvVVWWaVmlCRrIS3rZ153LZkByUx529veVhdvueWWJQ/um5ZxNdZbb73y5je/uc5KICFZLHlg/pa3vKXO63p8mXnwwQfXZf39J4GQZH2kJWMlpZySBZFsh7R555237LnnnnX6C1/4Qi0j9a53vasGEHKeyXbJcSeTIw/2k+nRtNe//vV1+5QlS+Dh+9//fqtMVIIEN9xwQ7Nq/eyakZEA1F577VW9s8JSSy1VktGTwFMyfNJ6O/6M4bLbbruVLbbYoq771a9+tZ5b9rPVVlvVefPMM08NnOTLF7/4xXLaaafVIE/OJ+3OO++sgYoEVNpb/htIMCZ/CRzlvBNwSTvooIPKtttuWzOEEhCLb7JkZp111rr8Ax/4QDnnnHNax1Vndvkn551AXM4z49+krFhzHbqs6isBAgQIECBAgAABAgQIECBAgAABAgQITKbAiAiKZByH2WabrVLl4X8eXC+xxBIturnnnrsVEMnMZCak/FMCIk3Lw/MEBtISAMmD/5RLevHFF2uQZeedd25WbX2m1FIyQVJ6qWnps31ciewrGSntGQVzzDFHeeSRR5pNStfjay2YhIlksrS3lHdqzyZpHuRnnQUWWKAGOdrn5Rya9RO0SaZJ05LpkOBBlifA035+XfebDIlkR6TMVFoCPgk0pJRU0xZZZJFqdvPNN7eCIl37aT/+lOxKYCHXpGkpmdZe2qr9XHJ8CUJkv01QpGuWSNNP+3b5byJZQE2LSQJEjz32WFl44YVr9k6mr7nmmhqES1An33tr7f0nQ6cx7m0bywgQIECAAAECBAgQIECAAAECBAgQIEBgYAIjIiiSh9cZJ6O/LYGO9gf72S7fMz8tD+3zkD6ljp5++ulaiqsJutQV/u+fBEUSBEgWQU8tJZ4SKGkvhbXOOuuUZF9MyTbzzDO3Sjl1t5/2gFCWtx/f+uuv3xp7JcuShZGWcVRmmWWWOt3TPwkYNJklWSfnn8BIe3Ag8/M9WSc9tfbjTwm0DGzffowf/OAHyxprrNHT5hOtm5WSVdKePdTdhr2ZZP2U6ErmRwI2Ocf2cVG666/rvK79d13uOwECBAgQIECAAAECBAgQIECAAAECBAhMnkDPT+snr99hvXWyDFL2qb0lAJL5TUtpq5S4SqZAT6Wz8pA7WR4ZUyOZDE1rxgvJ9/nmm69mrWy00UbN4hpIyUP+wWwJPLS3a6+9to6V0j6vv9MpM5bMiK4tY4mkJFd7a8b1aOYl+NAeoErwIzZXXXVVHYsk6yUYEttm3JfM6+34E4DI9WgfhyT77RrYSj/dtZRKSwm0psRZd+v0Z96PfvSjknFh9thjj7p6xkHp6tGffqxDgAABAgQIECBAgAABAgQIECBAgAABAlNG4H/1oaZM/8Oy1wQ5kgFy3XXX1QHTU8oqQYRkcDQt6+TB/S233NIa+6NZ1v6ZsSgyrsjjjz9eZ2d8k/ZAQcbKyPge2V9aym194xvfKMl+6K39/ve/n2iw997WzbJkMeQYkr2ScSsy+Pu73/3uvjabpOUJdmTslQyynnNMsCH7am/53j6YeZZl7I0MgJ5tk42TMUJS3mzNNddsbdrb8Wdw95NOOqmWPcsGGR8k47g0pq1OepjIWCFrr732RCXUeli119nJHsr1S0vg6+9//3uv61tIgAABAgQIECBAgAABAgQIECBAgAABAkMrIFOkG+883M7b/nm4f8YZZ5Rx48bVkkirr756a+08tM8D/AUXXLBkDJCe2mabbVZOPfXUOoZGskKSEdJeYipjWqy77rp18POU4Mo4JQlWdC0n1d5/HrjnQX723wxE3r68u+nsY//9968ZEcluyWDjzUDx3a0/kHkZi+TYY48tBx54YMlg5xm0PKW2EjhKe/DBB+tYGyuvvPJE3X/yk5+sg5YnCJLzThbKCSecUEtiNSv2dvwZjyRjumy44Ya1lFd8cn7J0ulP65q90p9tulsng9YfcMAB5ayzzqrl1Y4++uj6Pcdy2GGHdbeJeQQIECBAgAABAgQIECBAgAABAgQIECAwhALTTRj3YPwQ7m+iXXUdPHuihdPIl6eeeqrMOeecEz2gH8ihJWsiZad6KumUYMizzz7b7wf5KTGV4MqkjkORTIbBGLi9N4OUukpWSspi/fjHPy5XXHFFOfnkk8tpp51WM26+9a1vdbt5zinjcCTQ1N4SVEhLYKG3489+szxjvvS3JXNmtdVWK+eff35ZdNFF+7tZr+vlGFJqrX2Mk143sJAAAQIECBAgQGCKCdxzzz1lqaWWmmL965gAAQIECBAgQIAAgckTyLPzoWwyRfrQbgYR72O1Phf3FQBqxh/ps6P/W6G7gd37s22yOaZ0y8Dy7WOoNPtLRsZOO+3UfH3NZ86pr/Pq7fiz30kJiOQAMnbMvPPOO2gBkfTZ2zFmuUaAAAECBAgQIECAAAECBAgQIECAAAECU0dAUGTquI+YvSZjIgOhp33zm9+sAYj6ZRL+WWyxxSZh7Ulbddllly1nn332pG1kbQIECBAgQIAAAQIECBAgQIAAAQIECBAYlgLKZw3Ly+agCRAgQIAAAQIECBDoj4DyWf1Rsg4BAgQIECBAgACBqScw1OWzpp96p2rPBAgQIECAAAECBAgQmLICxhOZsr56J0CAAAECBAgQIDDcBARFhtsVc7wECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAgAQERQbEZiMCBAgQIECAAAECBAgQIECAAAECBAgQIEBguAkIigy3K+Z4CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgQEJCIoMiM1GBAgQIECAAAECBAgQIECAAAECBAgQIECAwHATEBQZblfM8RIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIDEhAUGRCbjQgQIECAAAECBAgQIECAAAECBAgQIECAAIHhJiAoMtyumOMlQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEBiQgKDIgNhsRIECAAAECBAgQIECAAAECBAgQIECAAAECw01AUGS4XTHHS4AAAQIECBAgQIAAAQIECBAgQIAAAQIECAxIQFBkQGw2IkCAAAECBAgQIECAAAECBAgQIECAAAECBIabgKDIcLtijpcAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYkICgyIDYbESAAAECBAgQIECAAAECBAgQIECAAAECBAgMNwFBkeF2xRwvAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMCABQZEBsdmIAAECBAgQIECAAAECBAgQIECAAAECBAgQGG4CgiLD7Yo5XgIECBAgQIAAAQIECBAgQIAAAQIECBAgQGBAAoIiA2KzEQECBAgQIECAAAECBAgQIECAAAECBAgQIDDcBARFhtsVc7wECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAgAQERQbEZiMCBAgQIECAAAECBAgQIECAAAECBAgQIEBguAkIigy3K+Z4CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgQEJCIoMiM1GBAgQIECAAAECBAgQIECAAAECBAgQIECAwHATEBQZblfM8RIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIDEhAUGRCbjQgQIECAAAECBAgQIECAAAECBAgQIECAAIHhJiAoMtyumOMlQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEBiQwakBbDdJGY8aMGaSedEOAAAECBAgQIECAAAECBAgQIECAAAECBAgQ6F1ApkjvPpYSIECAAAECBAgQIECAAAECBAgQIECAAAECHSIgKNIhF9JpECBAgAABAgQIECBAgAABAgQIECBAgAABAr0LCIr07mMpAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0CECgiIdciGdBgECBAgQIECAAAECBAgQIECAAAECBAgQINC7gKBI7z6WEiBAgAABAgQIECBAgAABAgQIECBAgAABAh0iICjSIRfSaRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQK9CwiK9O5jKQECBAgQIECAAAECBAgQIECAAAECBAgQINAhAoIiHXIhnQYBAgQIECBAgAABAgQIECBAgAABAgQIECDQu4CgSO8+lhIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIdIiAo0iEX0mkQIECAAAECBAgQIECAAAECBAgQIECAAAECvQsIivTuYykBAgQIECBAgAABAgQIECBAgAABAgQIECDQIQKCIh1yIZ0GAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0LuAoEjvPpYSIECAAAECBAgQIECAAAECBAgQIECAAAECHSIgKNIhF9JpECBAgAABAgQIECBAgAABAgQIECBAgAABAr0LCIr07mMpAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0CECgiIdciGdBgECBAgQIECAAAECBAgQIECAAAECBAgQINC7gKBI7z6WEiBAgAABAgQIECBAgAABAgQIECBAgAABAh0iICjSIRfSaRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQK9CwiK9O5jKQECBAgQIECAAAECBAgQIECAAAECBAgQINAhAoIiHXIhnQYBAgQIECBAgAABAgQIECBAgAABAgQIECDQu4CgSO8+lhIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIdIiAo0iEX0mkQIECAAAECBAgQIECAAAECBAgQIECAAAECvQsIivTuYykBAgQIECBAgAABAgQIECBAgAABAgQIECDQIQKjpuZ5zD777FNz9/ZNgAABAgQIECBAgAABAgQIECBAgAABAgQITEWBMWPGDOneZYoMKbedESBAgAABAgQIECBAgAABAgQIECBAgAABAlNLQFBkasnbLwECBAgQIECAAAECBAgQIECAAAECBAgQIDCkAoIiQ8ptZwQIECBAgAABAgQIECBAgAABAgQIECBAgMDUEhAUmVry9kuAAAECBAgQIECAAAECBAgQIECAAAECBAgMqYCgyJBy2xkBAgQIECBAgAABAgQIECBAgAABAgQIECAwtQQERaaWvP0SIECAAAECBAgQIECAAAECBAgQIECAAAECQyogKDKk3HZGgAABAgQIECBAgAABAgQIECBAgAABAgQITC0BQZGpJW+/BAgQIECAAAECBAgQIECAAAECBAgQIECAwJAKCIoMKbedESBAgAABAgQIECBAgAABAgQIECBAgAABAlNLQFBkasnbLwECBAgQIECAAAECBAgQIECAAAECBAgQIDCkAoIiQ8ptZwQIECBAgAABAgQIECBAgAABAgQIECBAgMDUEhAUmVry9kuAAAECBAgQIECAAAECBAgQIECAAAECBAgMqYCgyJBy2xkBAgQIECBAgAABAgQIECBAgAABAgQIECAwtQQERaaWvP0SIECAAAECBAgQIECAAAECBAgQIECAAAECQyogKDKk3HZGgAABAgQIECBAgAABAgQIECBAgAABAgQITC0BQZGpJW+/BAgQIECAAAECBAgQIECAAAECBAgQIECAwJAKCIoMKbedESBAgAABAgQIECBAgAABAgQIECBAgAABAlNLQFBkasnbLwECBAgQIECAAAECBAgQIECAAAECBAgQIDCkAoIiE7j//ve/lzPPPLO8+OKLQ4r/5JNPlkMOOaSMGzeu1/0+++yzdb18agQIECBAgAABAgQIECBAgAABAgQIECBAgMDABDo+KPKRj3ykvOtd72r9ve997ysHH3xwefDBB1tiP/jBD8p+++1XxowZ05rX18TFF19c/vWvf/W1Wo/LX3755bLbbruVTTbZpMwyyyx1vYcffrjstdde9Vj/8pe/tLadc845y5prrlmXjR8/vjXfBAECBAgQIECAAAECBAgQIECAAAECBAgQINB/gY4Pitxwww3lqquuKssss0z9W2CBBco555xT3vGOd5SHHnqo/1Jd1kwQ5Zvf/GaXuf3/etxxx5VVVlmlBkWy1e9+97uy8cYblyWXXLKMHTu2PProoxN1ts0225SFF164/PSnP51ovi8ECBAgQIAAAQIECBAgQIAAAQIECBAgQIBA/wQ6PigShummm65897vfrX8//vGPy+67714ef/zxkmyPntqf/vSnGjh5wxveULbeeusaWMm6999/f1ljjTXKY489VuclkHHzzTfXbo466qga6EhgY/PNN69lubrr/9VXXy2nnHJK+ehHP9pa/I9//KP85Cc/KV/84hfLTDPN1JrfPvGxj32snHDCCe2zTBMgQIAAAQIECBAgQIAAAQIECBAgQIAAgSki8Ktf/ap84hOfmCJ9T61OR0RQpCtuAiJps802W9dF9fuVV15ZS1slANIEPbbddtty9913lxlmmKEstdRSdb0ZZ5yxJPNk1KhR5Te/+U055phjajbH+9///ho8+da3vtVt/7fffnuZddZZyyKLLNJafvjhh5f111+/9b27iWWXXbY8/fTTk5Xh0l2/5hEgQIAAAQIECBAgQIAAAQIECBAgQIAAgXaBBESSZHDjjTd2VGBkVPtJdup0xuHIWB1pGdz88ssvL3PMMUd529ve1u0pZ4yRbJPB11deeeWSrJEPfehD9T+Ar3/96+Wkk04qyy+/fFl11VVL/sNIO+OMM+rnoYceWtZee+3yyCOPtMYKqQva/hk9enQNnrTN6vdkSmil7/aASr83tiIBAgQIECBAgAABAgQIECBAgAABAgQIEOhDoAmIZCiKtIzVnYyRY489to8tp/3FIyZT5Nxzzy35u/TSS8sSSyxRy1DNP//83V6h//73vyWDmycgkrbOOuvUz8zvqW2xxRZ10c4771wDKNlPskG6axnQvacSWd2t3z4v203KgPDt25omQIAAAQIECBAgQIAAAQIECBAgQIAAAQK9CbQHROaee+6SvwRHOiVjZMQERW699daSv7vuuqtk/I6UxeqpvfDCC7UkVrO8CWA8//zzzazXfK6++urlRz/6UXnzm99cLrzwwjpeSAIk3bX55puvPPvss90t6nNetuspmNPnxlYgQIAAAQIECBAgQIAAAQIECBAgQIAAAQI9CHQNiDSrdVJgZEQERTLQehPR6mkckebi5nPppZeuZbYefPDBOvvf//53/VxmmWXqZ0//pGxWImYZM2TTTTctl1xySS111XX9xRdfvI450nV+X99T0uvhhx9WOqsvKMsJECBAgAABAgQIECBAgAABAgQIECBAYJIFmuBHPru2ZllTNanr8uHyfUQERfq6GBmnIy1jhbz00kulyfD45Cc/WX7+85+XQw45pC5v5qe0VrI97rvvvnLcccfVclZHH3102WijjcoPf/jD8uc//7kOyj7zzDOXueaaq27b/k/GA8mYJgmeNO3ll18u48aNq38JfuQ48j1ZK0279tpryxve8IZa2quZ55MAAQIECBAgQIAAAQIECBAgQIAAAQIECAyGwJZbblkTDHrqK4GRrDOc23TPPffc+Kl1ArPPPvsU3/W6665bS2Ylw6Kndt1115VPf/rT5YYbbqjrzjLLLOXII4+sAY8XX3yx5Dg///nPlz333LPVxamnnlq+853vlGSTZPuxY8eW/fffv06/8sorZYEFFihHHXVU2WqrrVrbtE8cc8wxNejxhS98oc4+4ogjan/t62Q6/TSZKgcffHBZdtllW4PGd13XdwIECBAgQIAAAQIECBAgQIAAAQIECBAgMJwEhnoM7Y4PikzOxU/2xujRo2u5qumn719STcYdefLJJ0uyT3rbZkIwqo5rcvbZZ9eB3/s6zltuuaXsscce5eKLLx7wIO197cNyAgQIECBAgAABAgQIECBAgAABAgQIECAwlAJDHRTp35P+oRSYhvY1atSosthii/Ua3Oh6uLPOOmtZdNFF+9wm5bMyMPtBBx1UM0a69tP+PYOrJ1PlhBNOEBBphzFNgAABAgQIECBAgAABAgQIECBAgAABAgQmQUCmyCRgWZUAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYPAGZIoNnqScCBAgQIECAAAECBAgQIECAAAECBAgQIECAQEtA+awWhQkCBAgQIECAAAECBAgQIECAAAECBAgQIECgkwUERTr56jo3AgQIECBAgAABAgQIECBAgAABAgQIECBAoCUgKNKiMEGAAAECBAgQIECAAAECBAgQIECAAAECBAh0soCgSCdfXedGgAABAgQIECBAgAABAgQIECBAgAABAgQItAQERVoUJggQIECAAAECBAgQIECAAAECBAgQIECAAIFOFhAU6eSr69wIECBAgAABAgQIECBAgAABAgQIECBAgACBloCgSIvCBAECBAgQIECAAAECBAgQIECAAAECBAgQINDJAoIinXx1nRsBAgQIECBAgAABAgQIECBAgAABAgQIECDQEhAUaVGYIECAAAECBAgQIECAAAECBAgQIECAAAECBDpZQFCkk6+ucyNAgAABAgQIECBAgAABAgQIECBAgAABAgRaAoIiLQoTBAgQIECAAAECBAgQIECAAAECBAgQIECAQCcLCIp08tV1bgQIECBAgAABAgQIECBAgAABAgQIECBAgEBLQFCkRWGCAAECBAgQIECAAAECBAgQIECAAAECBAgQ6GQBQZFOvrrOjQABAgQIECBAgAABAgQIECBAgAABAgQIEGgJCIq0KEwQIECAAAECBAgQIECAAAECBAgQIECAAAECnSwgKNLJV9e5ESBAgAABAgQIECBAgAABAgQIECBAgAABAi0BQZEWhQkCBAgQIECAAAECBAgQIECAAAECBAgQIECgkwUERTr56jo3AgQIECBAgAABAgQIECBAgAABAgQIECBAoCUgKNKiMEGAAAECBAgQIECAAAECBAgQIECAAAECBAh0soCgSCdfXedGgAABAgQIECBAgAABAgQIECBAgAABAgQItAQERVoUJggQIECAAAECBAgQIECAAAECBAgQIECAAIFOFhAU6eSr69wIECBAgAABAgQIECBAgAABAgQIECBAgACBloCgSIvCBAECBAgQIECAAAECBAgQIECAAAECBAgQINDJAoIinXx1nRsBAgQIECBAgAABAgQIECBAgAABAgQIECDQEhAUaVGYIECAAAECBAgQIECAAAECBAgQIECAAAECBDpZQFCkk6+ucyNAgAABAgQIECBAgAABAgQIECBAgAABAgRaAoIiLQoTBAgQIECAAAECBAgQIECAAAECBAgQIECAQCcLCIp08tV1bgQIECBAgAABAgQIECBAgAABAgQIECBAgEBLQFCkRWGCAAECBAgQIECAAAECBAgQIECAAAECBAgQ6GQBQZFOvrrOjQABAgQIECBAgAABAgQIECBAgAABAgQIEGgJCIq0KEwQIECAAAECBAgQIECAAAECBAgQIECAAAECnSwgKNLJV9e5ESBAgAABAgQIECBAgAABAgQIECBAgAABAi0BQZEWhQkCBAgQIECAAAECBAgQIECAAAECBAgQIECgkwUERTr56jo3AgQIECBAgAABAgQIECBAgAABAgQIECBAoCUgKNKiMEGAAAECBAgQIECAAAECBAgQIECAAAECBAh0ssCoTj65aencLr/88vLQQw+VhRZaqM/DGj9+fJnwf2W66abrc93BWCH7S7O/wdAsE64dz8GR/F8vU8M0//Prz/8mRo8eXeaYY46y+eab/++ATREgQIAAAQIECBAgQIAAAQIECBAgME0KCIoM0WW59957yyuvvFJmmWWWPvf42GNPlTFjZiqzzz5bn+sOxgpjxz4zoZvpymyzzTkY3fXZx7hxY8rLL7804UHyPH2uOxgrvPjiuPLCC2PKnHPONxjd9dlHzu25554s88yzYJ/rDsYK+e/qmWceKa973SKD0V2/+nj88fvLfPMt3q91B2OlJ598sMw998Jl+umHJrnt8cdHlyWWmLfMOmvf/y9y1KhR5eabbxYUGYwLrQ8CBAgQIECAAAECBAgQIECAAAECU1ig7yd+U/gARkr3Cy+88ISHunOX1VZbrc9TfuihRyc85J5lwkP8oQlS5AF+giJDFaQYO/bZCUGRF8pcc83fp8VgrPDCC2PL888/OyFI0XeWzmDs76WXXpxw/R6dEDRYbDC667OPBEWeeOKBssACS/a57mCtMHr0vBOynpYerO767OfRR+eb4LnkkAVFRo++vyy77IIT/jc4U5/HNu+88/a5jhUIECBAgAABAgQIECBAgAABAgQIEJg2BIbmtetp41wdBQECBAgQIECAAAECBAgQIECAAAECBAgQIDCCBQRFRvDFd+oECBAgQIAAAQIECBAgQIAAAQIECBAgQGAkCSifNZKudoee63PPPVvuuOOWHs/uxRefnzCmyNghHVNkzJgnJpRLe6jHYxrMBf8bU+SRwey2l77Gl8cff6A8/PDjvawzuIv+35gij9TyWaus8tbB7VxvBAgQIECAAAECBAgQIECAAAECBAiMGAFBkRFzqTv7RP/619+UFVZYvtuTHD/+lTrIfQYjH4o2fvyrE/aXwdafGIrdTdjH+PLSSy+UsWOfGqL9lQn7e76MG/fsEO5vXD2/Z599uQiKDBm7HREgQIAAAQIECBAgQIAAAQIECBDoOAFBkY67pCP3hHbbbdduT/7VV18tCYzMMMOM3S4f7Jnjx4+vQZFRo/oepHsw9j3U+8sxJwgz44wzD8bh96uPl19+sdx0083l0kuv7tf6ViJAgAABAgQIECBAgAABAgQIECBAgEB3AsYU6U7FPAK9CDz88MPlG984opx11hndrpX5u+zywYmWZd5OO+0w0bx8+dKXDimHHfbV18zvacYll1xcrrnmf4GB++67t1xwwZ/LJZdc0tMm3c6///77y6c//aluz+HOO++ox5RzzLk27dhjv13Pu5mXY8l5NX/Nen19dne+t99+24RzuLivTS0nQIAAAQIECBAgQIAAAQIECBAgQIDAZAkIivTAd/fdd5fpppuuzDbbbOWUU055zVq77LJLXZ51mpbpJZZYoqy33nrNLJ8dKLDDDtuW8877XXn00UfLZz/76YnOMAGLD35wx7LtMbOjJQAAQABJREFUttuVmWaarowePbr8/+zdd3xX1f3H8Xd2QkLCHrJ3AUURRIYyFEGtigooVlFA60ItdbWuH1BxVKtWLRapiCLWAQhqteIoKDIEQQVEQUCQvRIge//OOfH75ZuQSb75EpLXfTy+ufeee+4Zz/tN/rifnHNeemmqC4gMGzbcm2bT7fW//GVSvvuLO7H5P//8c7311hveYMb48Q9p5szXCr2tsOCDJ+NFF52vU0451Yy+WHtUMOKxxx5x2WwfL730Indsy4qIiFDdunXVt28vl2bbsm7dOqWmpmn+/I88RRe537Vrl04+uYP69evn+m7PPdsdd9xWpuCQ5z72CCCAAAIIIIAAAggggAACCCCAAAIIIIBAWQQIihShNXfuXDNVzyKzjkGKbrnllny5Vq9erddff91MyZSrO++8U6+9duSl9LZt27RkyZJ8+Tk5/gKTJj2s2rVjdNZZPfXUU0/ql1+25muUHaVQ8JMvg8/JsmVLTd4luvnmW7Vy5dc+V6Qnn/yr/v3vt1xQ5KGHJmjNmtX67LNP9cYbb2vo0OHypK1Z851efXWmC5Z06tTJlfHKKy/rkksudAGDUaOuyVeuPbFBiYceGq/rrhuj5cu/ctdffvlVZWRkHJXXJsydO6fQdE+iDU788ssvLrjjSbP7f/3rZVeP7WNaWpq7tGvXTnXq1Fmnn97NBEbquTTbFvtZtOhz3X77H1zaww9PULt2rVwfbDDId7MBowsu+K0JqvTX88+/4B3x8thjk3T22Wf7ZuUYAQQQQAABBBBAAAEEEEAAAQQQQAABBBCoEIHQCim1ChS6YsUKMwVS3ovpMWPGaMOGDWrfvr3rWePGjb09zMzMNNMXfaqRI0eqf//+bvSIvWgDJp79e++9Z16Or9GZZ54p3/+OdxkK/EhISDDrNeSYT7S2bFmvpk2bFsjh/9O0tCRTaJCpM+8FuP9ryF9iRkaqWXMjw3yy8l84xrPk5CQTGEhTVlZmESXk6pFHHjYBjG81Y8YrevTRSfrDH8bly79w4YKj7u3du89RaTbhzDN7mpf4vTRo0GAzcmNhvnLuvPMu9enT0wTKZmrZsiXKycnWgAEDXPBj/vxP9e67c12aLccGNq67brS7tnjxMv3pT/fozTff1h//eJcGDx5o2nin16hdu/bq0aOnq6t9+3b6+uuvvfXahd3tmime/tu+2lFLa9euMSNRxrvv4gMPPGSr9G42wHLKKZ3MM88w5fbw3uvNYA5sOePHT3TX4uMP6Pzzz1NoaIgLlNh+eeqzwaTJk//pzqdMecGMXHnD1fn++++Zdi73FmmPbVDE3mf7Y4MpdqDVP/7xnLZu3eF+jzxlem/69cDWZxevT009pISEI1N6Fcznr/PU1AQTLMpVUlLJfyLtiCH7d4ANAQQQQAABBBBAAAEEEEAAAQQQQAABBCq/QMlv/Cp/HyqkhdHR0d4AR3h4uPnP9yOLZtevX9/VaV88jxs3Tl27dnXnCxbkvVi3L8FfeOEF3XrrrS69S5cuSk5OVkxMjOLi4optrx2Fkp5uX7DW188//2xeHnfytqPYG8t10QZw7FRhxbetXFX43BwUFGxecIf5rb6cnGDzsj5MwcEhPrUcObRBA7t17nyKrrzyd5o3b95ReQtbk+PBBwsv76235rjgyscff2SCF+fnK6tbtzPcSJF33pntAh52dIj9njRv3sKMFvm3atWqZabXusYEvH426cEaNuwK/fjjj/rvf//rysrKyjYBuPV68MHxskGFevXyRmV06NBRK1Z85eqy1/v16++t15afnZ3jPbejUez24YcfuHLcic8PO3olKytLBw8mmUDEJ5o48f90ww03+eSQ7PRat956my68MG/6rLVr1xq39zVw4HmKjAxxbbfe7747T7fd9gdv3aGhoeY42ARFpCFDLjPf5Qx99923zqBXrz768stFJng4wARBtsie33jjGA0ffqW7f/PmjSZg9Yhp8//la4s9sUEfW19YWKTfvjdHVeKTkJJif19rms+R33ufy/kOa9asme+cEwQQQAABBBBAAAEEEEAAAQQQQAABBBCovAIERYp4Nn369NH69evdS+mXX35ZzzzzjL755huX2wZBPCNBJk6c6EaILFy40Lzk7eWmOIqPj9dJJ53k8toX1q1atTIvgbeal8n2hW6NImrMS7YjSbb8HKUDB6RatQ+aeoLdfcXeVM6LeSNEgkzbo8pZUulutyNEsrKC/VZfZmaWe2FuX8YXtuWYmMh1140yIzHu1uLFX7oX8nYUhJ36ybN9+mleQMtzXtx+2rR/ucv2Bb8NQNh67YiMs8/uZ0aFnKMfflhngiYzNWbMKF1xxQg3msSOPLJTUDVr1tyNkoiNjdNvf3u+CdR01qRJE82okq/VoUMHPf30U2aaqk5uhJANKvhudior2+49e3ab4MQgV2/euiFBLij05ZdfuKmp7MgNG+R64omnXBDChBRcuqes3/ymow4fPmxGdMxwwZmRI68zIzBS9fjjj5p1PR5x66Q0aNBQsbGx5v68Mm1Az7Zz+vRprhj7vbb9fuONmXr77Xc8Reuyy4bq739/2kyz1V0NGzY0QY+bzciZs9x1u47KHXeMVX8zouqmm27Qtm27Tf07vPfWrl3HLDw/wXvue2ADXzaIFBoa4bfvjW/5BY9tPVFRNczva8lBEft7HRYWVrAIzhFAAAEEEEAAAQQQQAABBBBAAAEEEECgEgoU/ha5EjY00E0aNWqUfvrpJ9n/Av/uu+9c9XatEBsosZt9KXzttdeaNSAu0WmnnebSLrjgAvOf/8N09913mwWqL3VpZf3x6cddtXjRmfpyQR999J9B2rzJjuJgK6/AlClTTYCrvu666x4zAme7W+y7vGXu2LHXG1g555xzzYvxIzHGWbPeNoGRf+erwo7+mD59hkuzAYOMjFzNnj3LrTdi1+qIjo5x5dm0du065LvXntj8/fr1M9+7Ueb7dSRgYoMoX3211Ez1lOxzj/3eeD4+yebQTp01bdp0M7XVCtnghx3NYrfBgwe7vW1HmzZtzfRey2UDfHabN+8/JohzsVtX5Ntvv3dpmzdvMqNE7nDHnh9///vzZvqvu11QsHv3MzzJbm/7/OOPG91i8bYv9tx3+/vfn/M95RgBBBBAAAEEEEAAAQQQQAABBBBAAAEEEPC7QFBSUtJxe+tup6iqLpsdSWKnzvJMtVVYvz/4j3T7DZlq2DRJhw9GKHF/DfU8N1t/f77waZwKK+NY0pKSEsxtQWaqoFrHcnuZ70lJSTQjRdLNSIS8qaHKXECBG5KSEjV16l9lF+wubMsxQ0Xs9EshIYH5b347isiufxEaWvIog8LaW9a0QNdn25eZmW6CQBFlbeox58/KytD33/9g1iFZaaZAG3PM5ZT2xj17tqtt2wYmKFryM9y8ebNbM2jIkCGlLZ58CCCAAAIIIIAAAggggAACCCCAAAIIIPCrgF16IpAbI0UCqV1CXR+8L2WlhSnxYKSSEvKm2dq0IUj795VwI5cRQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEECgRAGCIiUSBS7DSU3z6qpZK03hUXaxdSl+d7A+/jgvnZ+lE7DrbJx33gDvx95l1+Jo0aKJmf6pnZneKW/Kp6VLl5hFvi9XeHiQmQKts/LW4ihdHQVzPfjgfbr88kvMmhgPujVLfK8//PAE1xZbT94aIEeuPvvsM+6aJ+UDM1yoUaN6R5XhuV5wb9cZsflnznwt36UVK5ZrxIhh+dJKc7Jo0ReF3mfbffHFF+iqq644qpixY2/22vm6l9bT5mvSpIG3DE8F1qagl+caewQQQAABBBBAAAEEEEAAAQQQQAABBBBA4FgECIoci1oF3TN0qFS78SFXenhkpsKjk3W2WebhlSnSyBHSsqUVVHEVK9YuoP7JJwu8H0/3nn767+Yl+6OaPPl5l9SvXx916XKqW6vj3Xc/8GQ7pr1dl+Odd94zC65P0tixt+Qrw66tMXv2PFfPB2Y4kGedDhuUuf/+P3nP161bp1WrVpr1Qb7Wqaee7C3DphcVHKhdO0YLFnzh8k6dar4ov2733nuXac8cz6l3b4MWRW3p6ekuYFTYfZdcMkSjRo056tY///keb/vtxe3bt3nd+/bt780/f/5/ZT8FN9u3zz//XHZ9liee+Kvsud2WLFlsFmL/pWB2zhFAAAEEEEAAAQQQQAABBBBAAAEEEEAAgXIJHFkZulzFcLM/BDp2kp54Jl5z56Zq3draOqvfdrOQdd5i1X9/Wrr3NqlFO2nsH6SevfxRY9UswwYQ1q37XpGRkW4x70cf/etRHbWLhNvNBlDs1qJFS/dxJ7/+KCwQ4cnvm88ed+16ukuaMeMV2eCC73bBBb/1nrZo0cKsNRJq1hzJlg1cLFq01Cx0fqm7bhdLb9++vWvH7353tTZt2qR3350rz5x6Z53VU19+ucxblj0IDg5WR/PFqVnTLtL+oG688WY99dQT6tPnbC1e/KU3r+3Lvn173bmnXwX7Yttz+eVDtXr1d977PAennnqaNm78yXPq9p9++onefvtNnXnmkS/j9u3b3cgXu6j9LbfcKhsYueSSCzVkyGV69dXpOnTosK644kpvOZ4+24SBAwe6BeM7dOigv5sv/NVXX6OFCxd483KAAAIIIIAAAggggAACCCCAAAIIIIAAAgiUV4CgSHkF/Xi/fVEeVWObrr0uUkFBNbR27T7zInu/6tevp3F3StffIE17ieBIaciHDRvusoWEHPmK26mf2rZta0Zy3G5GbWS4he+LK6tg0KC4vPbaW2+9of/85z29+OK/Cs36t7/91QQdhpkF5mNdQKRXr946/fRuZqTFAZc/JCREUVFR7jgqqob5Dkh2JMbBg8myo0rsuQ1YfPnlIpfnllvGmjSTaLbw8HAXbPnuu281adJflJCQZEZePOau2R/9+vVzff7hh3Wy9YaH5190fubMGW76qm++WasJE/7Pe19xB4888hdt3rzNTanlGf3yv/99oTPO6OFGtnxuRoDUrVtPN998q3FvZxa6D3E+9erV048//qCYmBiX5ulznTp1XXX33Xevc8rKyso3CqW4tnANAQQQQAABBBBAAAEEEEAAAQQQQAABBBAojQDTZ5VGKUB57EvjPn36qFWrVrIviE8++WQXEPFUXzNWLjjygfnn+W498oIjTKvl0Tmyz8nJcYEHO6XVpZde5r3w3/9+YkaQ/KRnnnlOv/lNRzNqIW+qMk+Ggmtg2BEVBT+evAX39t7HH3/UjJx4R61bt3GXU1KSZT92u+eeu9SsWXNdeeVV7twGRuxn0qSJSk1NdfXY0SY//bTBXZ82baor5+GHHzEjPhaZ0R9PutEWdlRI79593Mdl/PXHhg0b1KPHmbr77j/qrrvuceX269ff7W0WO2Jj4MBBLvfAgee5819vdbstW342I1aG57vPt/2+ee1xdHSkzj13oMvfuXNnE8Bb67LYgIjdzjtvkA4fPqTOnU82z+Bi813+jQtwzJjxuvlu13Htt1OX+fb5s88+defTpv1Ltv/Ll3+ldu3aFzl1mKuIHwgggAACCCCAAAIIIIAAAggggAACCCCAQBkEjvwbfRluImvFCaxatcpMiWT/i7+hmz7JvkC2UyP5bp7gSMGRI/c9JHXq7Juzeh7bKaVefnma/vGP501QIkUPPGBgzBYWlv/rPn36DHXrdqrWrFltFmDvpOeem5wPrCwjReyL/IMHE1x5tWvX0UcfzdfEieNdoMEGNGybNm7coFdeeVn33feAHnwwb9ouW+GCBf/zTuNl2/Poo5O8bTnllFNdX+y6JKec0sW177TTunrbOWfOPDMaI9ZNx7V69To3fZbn4uefL/TWc955R9YS8Rx/YtZd8Wy+7fHct3fvHt1++1gzAma2C0y89NJUJSUluumxkpPTjGeEu90Gjvr16+uO+/btbabT6umm7nrggbwRJw89NMGsM/Kxvv32G5fHt/02Yd68uW6xe5vP9vHAgcMunw00fW5Gm9jnkJWV4dL4gQACCCCAAAIIIIAAAggggAACCCCAAAIIlEcgKCkpKbc8BZTn3ujo6PLcfkLdu3DhQjddU9euR15oF9YB8zzMC+T/affuXPdf882bNyssW760RPMO2U6r9c7rZq2R/tId46SmJd/mLSMpKcEcB5npjGp50yryICUl0bzkTjcjJer5pRr7on7q1L/qsccmFVqeHTmSm5ttpmrKP2VUoZn9kJibm2uCFJlmOqtwP5RWchGBrs+2KDMz3RsUKbmF5c9hgyLff/+DWYNlpRltc/SC7+WvIX8Je/ZsN1N+NTAByZKf4ebNm01gbY0ZyTMkfyGcIYAAAggggAACCCCAAAIIIIAAAggggECJAp41lUvM6KcMTJ/lJ0h/FZOZmSn7Et8uxm3XVCjN5hk5YqfVOqmJ9DuzbrdZM1vbt5XmbvIggAACCCCAAAIIIIAAAggggAACCCCAAAIIIFA9BAiKVLLnvHXrVrVp09asD9FDO3bsUFpaeqlb6BscscfDBhMcKTVegYwF1xcpcLnSnS5a9IVbKL28Ddu6dUt5i9CcObOOKmPPnt1HpZGAAAIIIIAAAggggAACCCCAAAIIIIAAAggEWoCgSDHiW7ZsMWtAvFJojueff15BQUFHXZs4ceJRaWVJOO2009SwYUNFRkbqjDPOMPu8dRvKUoYNiJhlGDR7vsy0UQRHSmNnFyi3a2N4Prt27XK32fMTIUDy3XfflaabReb55JP5qlEjzKzfcb9uuGH0Ufl69DjdrSXia2HTwsOP/A588MF/3Pns2bNM3nOUnJzkyvn7358yi8w3zpf3qApIQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEAiBAUKQI5DfffFN2HZD+/furVq38a22kp6fr6aefNgGHXBcY8bxAt/nGjx/v0rZv315EyaVPPpaAiG/pdl2RJ58mOOJrUtTx3r173WLrdlFv+/n3v80CLWazC6iPG3eHC5Z47r3wwsGaP/8jdzp58vN6++03PZfcftKkiTr//EE67bST3flXXy3TNddcZcqY4AILNvG88wa4a77HNsBg01u0OEmHDh3SsmVLNWHCQ2bx9Otd/TNmvKJGjeqaNTWGas+ePWYk0Xb9+c/36MILB7n83gKP4WDZsmVmvY6lmjHj35o5c8ZRJSxfvqrEtPfem2fsJuiNN942fWjhFrC3vyPjxt1ljOYoI+O4LV90VNtJQAABBBBAAAEEEEAAAQQQQAABBBBAAIHqKRBaPbtdcq8XLVqke+65Ry1bttTQoUO1b98+1a9f391ogyWeReJffPFFPfLIIy4YYvPZbfr06Vq6dKmGDx/uAid2IWYbJAkPDzf/PZ/s8hT3Iy0tzb1ATk8PKS5bqa/VbyBNekzaMTZYk5+PdNNqnTVYuvW2NDVpmmPqSnNlpaeXvKh0qSstJmNGRqpZiDxD6ekpxeQq/SVbTk5OtluLpbC7cnPtQuu5RV639zRv3lx2pMPMma+5Be7tKAe7tsvIkdea5z9cXbqc6r3/P//5rzp37iC7f/311/Tll8vyPVc7uiQ5Oc0t7G7LuPTSi00AY49WrVqpzz9f6MqxI3jsNbvZ74Q9TkvLdudz5szW4sWLzMiNaL322qv66actWr9+vVnI+7fauXOfevfu4QIXtl82zwcffCQbiMnJyd/HQYPOdeX5/vj44898T73HK1d+rT/+8U7Xjt///mZ9/fUKnX56N+91e5BnmFeHr6enH02aNNXs2W/rgQcekg2QnHzyyeY7H6E//eke1atX1/yePGza/YbatWufr9zSnOQ9wxyzzk663743xdVr60lNTVFwcGZx2dy11NRUs/B8yflKLIgMCCCAAAIIIIAAAggggAACCCCAAAIIIFDhAgRFiiDeuXOnGjQw0QSz2b1d38MTFBk8eLAZCXC+rrjiCvcf++ecc4677snfqFEj/fjjj96S161bp19++cX8l38jJSYmetOLOrAvYzMyssxLWf/+Z32dumZarQmHtPP3oXrxn7H63cWR6nlupq4dlaHGJ2WZF8CBGThkgxg2KBISElYUQZnS09KSTHmZ5qV9XlCh4M2eF/hBQYVft/nDw8NcEGvQIBMtMpudJsqWd+DAfrcvWPZf/vKw7rvvXv3jH5Pd9YkT/88ENVLNyI37XVAgOjrSlbNjx25vGV27nmbK/fzXdub+upfWrfveHQ8efJ7Wrl1jRobcZIIfO3X11SNNIORSd+3+++/V5ZcP1bBhlyopKcnVbStITc1wgQwbmMgLHBzpY9++fV0bfH8U7IfnWuvWrbR//z4zzVWkqXu7mjRp7G2fJ4/de+rw7PPS8uocM2aMuzcyMkSjR49Rz549TX9W65RTTtaTTz5lAjcPm2DJXN15592+RZbqOO8ZZpvggw1WlPw7VKpCi8mUmZlmglU2MFbyn8jSBDqLqYpLCCCAAAIIIIAAAggggAACCCCAAAIIIBBAgZLf+AWwMZWpqj59+rj/zu/ataueeuopPfaYGWrhs9mXtLNmzXIv0ufPn2+mSjrNLY5u823cuNEd2+x23ZGLL75YNWvWVFxcnAuM+BRT6GFubogJGES6ewrNUM5EOxvYs/+Qtm8z+2fCdOvIFup9Xo7uvDtYdsqtit5SUhLdf/zHxtbzS1WhoTUUFhZZZJDFBgxsQKS4IExQUIgZ/RPjzWOfm82fkHDQBLKSvemeBp9++hkmaHGVmRbqHZf0xBNPeS7poosuMYGRB80ok2tMEOQLnXvueZo3b55OPfU0M2KiniurqYHev/+A+46lpKS4tP3792v37gNu1EdIiP0OhKh27bru2ty575vpvdqZUSlfqU6dOi5oY0cvjR49Sn/72zMm/Uv163eOy+tpSP/+R6bo8qQVZdCt2xmurXYUx4cffqDGjd/V3Llz3G2XXTbU7fNMbLvCXCDGU5Zn37Rpc02Z8pL69h2gF1543gRF+piAYiMz9ddfzHRzz5ny3tFzz03O10ZPu0ra2983W09UVKyZzq5hSdnLfT09PdM8qwbmd7Dk0VP2+Xmm0Ct3xRSAAAIIIIAAAggggAACCCCAAAIIIIAAAhUqEJihARXahYopvEuXLi6wMXr0aPPy+2pXyeTJk2XXGrGbXVB95MiRbsRIr169XJodOWLT58yZY6Zb6uLSKvMPz5ojM+YeNiMAAr8ge1JSyVOJHS+/vn37u6pvueVWtxaInRLLd7v33jvd+hkF022eMWOuc2uKzJkzy0299c477+rTTz8x3503XODF5rnqqt9pwICz3ciRYcOusEluBIVdV2Tt2rVmxEYLl+b7Y/nyb0y5A92C5TExNb3Teg0adI7q1q1rppXKmwbNc4/tQ8GP51rBvR2VYje7hsqPP250x9u2majZr9sdd4x1I1ruv//Pbn0Tm2zbar/no0df64I0njS71omdUsxurVu30eOPP+HyduzYyUzJdbpL5wcCCCCAAAIIIIAAAggggAACCCCAAAIIIHA8BILMVDz+naOpDL3wrMtRhlsCnnXLli1uXRFbsZ1Cy25NmjQxaz4sVkxMjPnv/1NdmueHZ3F2z7lnb9PtSBE78qSkbdeufTp8uOJGihSsPykpwSQF6WBCLTNyRFpk1hDve4F0xzj5feTImjVrzcv7JPPSv4m+/36j2rRpYxblbl6wSWU6T0pK1NSpfzWjeSYVel/e1FLFjxQp9MYiErdu3aI//OF2M/rjfRPI+IMZuVFXDz74f97cdlSDnc4rNPToUQZ2PZAlS5Z78/rjoLj6/FF+YWXYaazCwiIKu1QhaVlZGeb78oNZDH6lWWh+TIXU4Vvonj3b1bZt6UaKbDZrBq1Zs8ZMdTbEtwiOEUAAAQQQQAABBBBAAAEEEEAAAQQQQKAUAoGenp6RIiU8FLvQumezwRD7sZudXqtgQMSm9+/f3+5OyM0zcmT2fOkk083fXSrde5e0bKn/umPXl7Av8ZctW+aXgIj/Wlb6kmxQxE5ZZbenn35WAweeV+qb7agJNgQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIHjI8CaIsfHvVLXaoMj4+6Urr/BTKf0kgmM3Ca1aCeN/YPUM2+msGNuf2JiklnAOsWslVFbdk2M8o4S8W1IVlaW76n32DNSJDc3yJtWnoPevc9yt3vq6979DLNGypG680Zu2POjY472Xt+85WmH597i6vPk8ffe9sGuwxKozd9mgWo39SCAAAIIIIAAAggggAACCCCAAAIIIIBA5RIgKFK5nkelak3NWP8HR+xQqGbNmqp+/bratGm7C5BER9cod79TUlJ1111/KrScnJwsM51VlluMvdAMfk7Mycl2C8mHh5e/X6VpWm5ujjIyUhUREV2a7H7Ik6u0tGRFRsb4oazSFZGenmzWJamh9u1PLt0N5EIAAQQQQAABBBBAAAEEEEAAAQQQQAABBAoRIChSCApJ+QX8GRxJSEgwL9QTzfoqNXXw4EH3KW9QxC46/uCDT+VvtM9ZenqKUlMTVatWQ5/UijvMzMwwa8LsM4uf5021VnE15ZWcnZ2t+PgdJtBUvrVZytLOPXt+VsOGrcpyS7ny7tu3xXg2V3Dw0aNvylUwNyOAAAIIIIAAAggggAACCCCAAAIIIIBAtRLgDWO1etzl66wnOPLBAqlbj7xptUaOKNuaI0FBQfppQ7xmz/pRSUlJZgom/0xpVb6ecTcCCCCAAAIIIIAAAggggAACCCCAAAIIIIBAdRAgKFIdnrKf+1gwOPJ/90o2ODJndskVxcTEmCmzkvXNqqZmxEia+e//uiXfRA4EEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBPwgQFDED4jVtQhPcOTjRdKQodKLz0qD+hYfHImPj3cLjQcHB5kprVKVkpJSXfnoNwIIIIAAAggggAACCCCAAAIIIIAAAggggECABQiKBBi8qlY3bLhkgyM33l58cOSXrTFa/d1pSjgQp+XLumnP7qoqQr8QQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEKpsAQZHK9kRO8PYUFRxJPCxt3yZNeb6xNnzfVOlpYfp6YSc981TkCd5jmo8AAggggAACCCCAAAIIIIAAAggggAACCCBwoggQFDlRntQJ1k5PcOTuB6S5s6TfDpCeeEzavz1/EOTnDZFa/+MJ1jmaiwACCCCAAAIIIIAAAggggAACCCCAAAIIIHBCChAUKeGxbdmypcgcixaZ+aLYihUYNFia+ZYJiPxD2rQhL2tqUoRycoLcSVZmjjkutgguIoAAAggggAACCCCAAAIIIIAAAggggAACCCDgFwGCIkUwzp8/X2FhYZo4caJGjx59VK7WrVvrySef1IABA+QJnAQFBekvf/mLu+eoG6p5Qs9e0j+mSnENpOysEO39pZYTadY6WG3bVXMcuo8AAggggAACCCCAAAIIIIAAAggggAACCCAQEAGCIkUwL1u2TEuXLtX06dP1+uuv58u1bt06hYSE6L333tMpp5yit94yQyF+3YYMGaLx48d7Ttn7CLRqLd18xza1P/UnNWxxQJGxSVr/jfTAn/PWG/HJyiECCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAn4XCPV7iVWkwJUrV+ruu+92vRk3bpzsebdu3dx5p06d1LVrV9mRIXbLzc11+wkTJujVV1/VN998owULFnivTZ06VevXr9e5556r2rVru/Tifhw6lKg0sxB5ampUcdn8di09PcmUFaSUlEN+K7Oogho2+knDrkjXL780U+PGaxQTfbLendtBwwZHqlP3DA0fcVDduqcWdfsxpWdlpSkzM00ZGWnHdH9Zb8rOzjLP77DsPhBbTk62eXYJ3u9hxdeZq6SkA+b7H7iYqq0vJyc3YHXa+nbsSFNkZMl/Infs2GG+X5kVz04NCCCAAAIIIIAAAggggAACCCCAAAIIIFBugZLf+JW7ihOzgI4dOyo+Pl7R0dFKTExUy5YtvR3ZtGmTFi9e7F5C33TTTXrttdc0cuRI7wgRO92WnVrrnnvucfdce+21+vzzz1W/fn01a9bMW05RB2Fh+02dkYqJqVlUFr+mJycnmPKCTF/zprTya+EFCqtXr5k2b47XV0ulyy9v6EzOOVdKPJyjl6eF69EHG6iFmU7r1juknr38s9hIenqKCVIkKi6uYYHWVMxpZmaGeX7hqlOnScVUUKBUG3wJDg6WtQ3MlmsCFNkBrM/2Ksd4NjX9DAlIF+2aN40b1ze/g+El1peVlaX9+/eXmI8MCCCAAAIIIIAAAggggAACCCCAAAIIIHD8BQiKFPEMevTooc8++0z9+/fXm2++qX/+85+aOXOmQkNDNXDgQDMKIFv79u0zozlS9f3332vhwoUucGKDKK+88ooLqNii7WiSqKgo8x/nke7FtZ12q6TNvuC2/4Vv94HY8v7jPygg9W3btl0H9ifprLPra+fOXcamhmJjayrOxGP+eJd0w++laS9JfzZBkToNgzVyjDR0WPkUAu0Z6Ppyc0MC+n2xTyOQ38+8+uz3MyQg39Ej/Qtx0+TZ8+I2+7wD9btaXDu4hgACCCCAAAIIIIAAAggggAACCCCAAAIlCwTmrXvJ7ah0OYYOHar+JiBigx0JCXYkhZScnOz29erV029/+1vZabT27Nmjxx9/3KW3atVKvXv31ocffliqabLcTdXsh7XLzNqt0LCvXcDIBkR8t5qx0rg7pS9WSteY9e1ffFYa1FeaM9s3F8cIIIAAAggggAACCCCAAAIIIIAAAggggAACCJRdgJEixZjZKbNGjRrlzWGnyvJs06ZN8xy6vQ2geNYWyXeBk6MErFNKSrJq1Ch+jY9hwyX7mT1Leu1l6dnHzKiRa6Qx10s2eMKGAAIIIIAAAggggAACCCCAAAIIIIAAAggggEBZBBgpUhYt8pZbYNWqVWbasf1q0qSpNm7caBag31BimTYwMu9D6Yl/SCuWSb8dYAIkz0jbt5V4KxkQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEPAKEBTxUnAQCIE+fXqrRYsWJiDyk5tqrEOH9qWutmcvaeZbecERGxAZNli616xDQnCk1IRkRAABBBBAAAEEEEAAAQQQQAABBBBAAAEEqrUAQZFq/fgD3/mtW39RYuJhsx5LZ23atEkHDx4qcyNscOTJp820WvNlpizLC46MHCEtW1rmorgBAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAoBoJsKZINXrYlaGrjRo1MmuJhCkiIkxxcfVVq1bcMTerabO84EjiBGnaS2bUyG1Si3bSpcPM2iPmw4YAAggggAACCCCAAAIIIIAAAggggAACCCCAgK8AI0V8NTiucIGIiHBFR8e4epo2beKX+uyi6+PulD5YIA0ZKr34rDSorzRntmQGpbAhgAACCCCAAAIIIIAAAggggAACCCCAAAIIIOAECIrwRagyAjY4Yhdl/3iRdOPt0msv5y3K/o/nIs2UXUFVpp90BAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQODYBAiKHJsbd1VyARscmfdh3qLsK5cHa/jgBizKXsmfGc1DAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQqWoCgSEULU/5xFbCLsk+fmaKXZx3wLsp+y+9ZlP24PhQqRwABBBBAAAEEEEAAAQQQQAABBBBAAAEEjpMAQZHjBE+1gRU4qUmWnnxamj1f6tAxb1H2kSPy1h3xZ0t27dqtb7/91hW5evUabdmy1Z/FUxYCCCCAAAIIIIAAAggggAACCCCAAAIIIIBAOQQIipQDj1tPPIGmzQpflP3laf5ZlL1x40aKjIzUqlWrlJmZqZYtW5x4SLQYAQQQQAABBBBAAAEEEEAAAQQQQAABBBCoogIERYp5sK+88opq1qxp/tt/y1G5BgwYoKCgIPfxXFy3bp1q166thQsXepLYV1KBgouy/+/jvEXZn31G2r7t2BudmZml/fv3Kzg4WAcPHjQLvCcde2HciQACCCCAAAIIIIAAAggggAACCCCAAAIIIOBXAYIiRXBOmTJFbdu2NS+1E3XKKafky7V+/XrFx8ebNSpydffdd+umm25y188880wlJCRo2bJlsgESthNDwC7KPvOtvEXZbUBk2GAzvdZd0rrvy97+nTt3au/evYqLi9OePXu0dSvTZ5VdkTsQQAABBBBAAAEEEEAAAQQQQAABBBBAAIGKEQitmGJP/FIXL16soUOHuo5ce+212rRpk9q0aePOGzdurNTUVE2cOFExMTEaOHCgu27z2c3mW7p0qTp16uQCJ0uWLNHq1avVpUsXHThwwOUp7kdi4mFTfrrJkllcNr9dS01NdGXl5ub4rcziCkpPT1F2doYZZROYmFxmZppsnSEhYcU1S51PlvvsvDFEM1+L1k0jQ9W0da6uGpmqAeekFXuv52JGRpKZPitIS5fkqEHDCNPPVBNYi/dcrpB9Tk620tKSKrwe38anpwe2vrS0ZCUlxQfsO2P7d/BgmDIySv4TaUcE2anS2BBAAAEEEEAAAQQQQAABBBBAAAEEEECg8guU/Mav8vehQloYGhrqnRorPDz8qDrOP/9888I0Q77XPMdhYWHmBXyI956IiAiXz06p5JvuzVDgwOazU3MFBx8po0AWv57auqTA1mcDIoHrn/UsfX123ZE/35+sW28L0rtzI/X832q4z+ib001wJF2xsblF+mdnZ7uAVnx8rGpEb1VOTk4A+pkb0O+LZOsrvWeRWGW4kDdVXeDqzOtf6X5fS/M7XYaukhUBBBBAAAEEEEAAAQQQQAABBBBAAAEEKlCAoEgRuHYqLDtNVr169TR16lQ988wzbo0Im/3bb7/V+++/r59//tmNFnnvvfc0efJkb74NGzbIBk3sZl/mdu/e3fyXe5Jbn6RWrVouvbgfqamZZoRBpKKjaxaXzW/X8kaIBJn64vxWZnEF2RfOWVnpAasvNDTMPYey9i86Wrr51rzP7FnSvNkRmvJ0hAZdIo0aI9ngScGtVasO5nuzUQf2R6pZ8xpm1FDHCn+ONhBjR1KUtX8F216W86SkhIDWl5Ji66vl1mopSzuPNW9SUqIJfsWZ39mjA6IFy7RT6dlAKBsCCCCAAAIIIIAAAggggAACCCCAAAIIVH6BwMxfVPkdjmqhDWqcd9555sVorAt42Ayvv/66PvroI/Xv39997KLqn376qcaMMW/Izfb444+7l+92ai07VRZb1RHwXXfk0KEj644sW5q/j7t37zZTdWWYF/jRiq4RpW3bzCIlbAgggAACCCCAAAIIIIAAAggggAACCCCAAAKVQqBajhSxIznsYuh2FIcdEdK+ffujHkbLli2VkpKSL33s2LHe8+nTp8t+fLfbb79d9sNWdQV69pLsZ/sfJTt65N7bpDoNpZEmLjZ0mMwIn2zVqhXnRjTUqlXbfceqrgY9QwABBBBAAAEEEEAAAQQQQAABBBBAAAEETiyBajVS5MMPP1TdunXVq1cvffzxx5o/f747tmn2GhsCpRWwU2eNu1P6YIF0zWjpxWelQX2l999tpZzsjjp0KE2HD9dXp04dS1sk+RBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQqWKBajRRJT0/XgQMHCiWdO3duoekkIlCcQM1YM5XW8LyPnUrrLw9Kb/yrhWrUStfqFSHa9kuW7ry7Wv2aFcfFNQQQQAABBBBAAAEEEEAAAQQQQAABBBBA4LgKVKuRIpdddlmR2MVdK/ImLiDgI9C4sRQWnq2wqBzl5gYpIzlUs2eE6l8v+mTiEAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQOC4CVSroMi6desUGhqqyMhIt9ZDVFSUOz9u+lRcpQT27JHi94SY71aumrWOd33LyZJen5Y3tdbLZp94uEp1mc4ggAACCCCAAAIIIIAAAggggAACCCCAAAInlEC1CorYhdI//fRTpaWlmf/kz1Vqaqq+/vpr2eAIGwLlFahXT6pRM38pkTHSUy9IN94u/e9j6bcDzOLsd5mF2rflz8cZAggggAACCCCAAAIIIIAAAggggAACCCCAQMULVKugSLdu3SpelBqqrUDrNtJlV2Yrtk6aM4iIls4+L0PduuetOTLzLWnKDJmAnDkfLI0cIX1iAiVsCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAoERqFYrQN97771qbBZ+6Nu3r/r376+lS5e6kSO7du0KjDa1VHmBq65ONuuKfKvvvmmpLlcu1YgRzU2fm3j73amz9OTTZhqtCdK0l8zxw+YzSRpxnTTcLNhuF25nQwABBBBAAAEEEEAAAQQQQAABBBBAAAEEEKgYgWo1UqRBgwbKzs7WO++8o379+unNN99UVlaW6tevXzG6lFrtBOxUbI1PSpSCUtSgwR7FxcUVamCDH+PulD5exNRahQKRiAACCCCAAAIIIIAAAggggAACCCCAAAIIVIBAtQqKfPTRR46wdu3abqRIrVq1vKRffPGF95gDBI5VYOfOnSbQlqng4CCFhoRqx44dJRY1zIwQsVNr/Xte3tRav7s0b2qtObNLvJUMCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAmUQqFbTZ9nAx7PPPqsbb7zRTaO1efNmrV+/Xt999506derkptUqgx1ZEThKICgoSHa0SHR0jOqZldfteWm3ps1+nVrrsPT229KLz5rPc2Zx9sukMdcztVZpHcmHAAIIIIAAAggggAACCCCAAAIIIIAAAggUJVCtgiKPPvqo+8/9FStWaPny5Tp06JC6du3qgiRNmhxZ98GDtWXLFi1cuFCjRo3yJLm9Tdu4cWO+UQDjx4/XxIkT3fVmzZppzJgx+e7hpHoItGjRXLGxMfpiYbq6d++uOnXL/itmp9a6/oa8z8fzpXdmSef1lPpeII0yXyu7Lsnx3Hbu3KWQkLwWZGZmKSys7H08nu2nbgQQQAABBBBAAAEEEEAAAQQQQAABBBCovgLV7m1mbGysGxVy6aVmjqJitlmzZunDDz90a49ERkYqLS0tX+62bdvKfp5//nn97ne/c9cmTJjggij5MnJSrQSysrKVkJCgk5rU0IH4eIVHRCsmJvqYDQYNluxn+zZp+svSzddKdRqa6bVMcGTosGMu9phvjI9P0Jo1a9SqVQNt375KoaGhOvXULsdcHjcigAACCCCAAAIIIIAAAggggAACCCCAAAKBFKhWQZGxY8dq+vTpat26tVtcfcGCBUVaf/XVV7rnnntcAGX06NFKTExUzZo1Xf7+/fu7fVJSklu0fc6cOd5y5s2bp+uuu857npub60ak2Pujo6OVmZnpvVbUQXZ2lnJyssyi8FlFZfFrel49QQGtL9D9y8nJDkj/kpOTtW3bVp3RI0ybNyerVq3TzXRaEeV+Xo1Pku5/ULrtDumTj0P12jTp2cekgRebAMm12aoRHZj+xcXVVLduXbVixQLzfW6kPn16B8Q1JyfH1JOp3Nxfh6iUW7T4Auz3xa4Nk5lZ8vRnWVlZJm9gfleLbzVXEUAAAQQQQAABBBBAAAEEEEAAAQQQQKAkgSDzYj+3pEwVdd0GCQK5NWjQwK0f0rhxY11xxRW6//77ddpppxXaBLsWhA1o2M1Oi9WvXz+3OLtv5ilTprg1SZ555hmXbKfVOnz4sIYMGeK915bx6quv6ocffnD3d+5c8txHBw8mmpEpYYqMjPKtrsKO09KSXNmRkTEVVodvwenpqSbok2mCBWaeqABsmZnp5uV2qmrUqBWA2qQ9e3abURQ/m8BbUzVvbhYKqaBt5ddR+uD9mlq+IEIduibrksvS1a9/cgXVdqTYn3/eYp5fslJSctW0aRPVrl37yMUKOkpM3GeCMHXNAvbBFVRD/mIPHTqghg1jze9gyXHjX375Rbt379awYcdh6E7+ZnOGAAIIIIAAAggggAACCCCAAAIIIIDACSdg/9E8kFu1Coo0bdrUvKze7nxvueUWXXzxxbrwwgsL9baBkBEjRqhDhw5usWw70iMmJn/QoGfPnpo5c6abRsu3EM/aInadEc9mAyZxcXFuDRNPWlH7Xbv2meBKpHdkSlH5/JWelJRgigoy/QtM0CAlJdH8Z326WXujnr+6UGw56ekpSk1NNKM2zLxTFbzZ9Ta+/361mV6qifmuHTBBkeZmZFKrCq31YEK2XpicqoXzzffTDGwYYQYqDR9ecQuzr169xgQMYhQeXttNK9e4caMK7Z8tfN++Lapbt3nAgiJ79mw3v9cNzO9geIl927x5s5tSzAZD2RBAAAEEEEAAAQQQQAABBBBAAAEEEECgbAKBDoqU/G/QZWt/pc7drl07tW/fXhEREe6zevVqPfnkk67NBafS6tKlix5//HE3QsTmtwGRyZMnmxezdV2wZMmSJeY/5VO8AREb9Pj888/d1Fx2bRHPKJNKDULj/C5w0kmNzcLjweblfZYaN25tRjfU8HsdBQu0C7P//qZ4M71WjOzC7DPM2iNTn8pbmP1yM3ihZ6+Cd5TvPCwszBUQHh5uRozklK8w7kYAAQQQQAABBBBAAAEEEEAAAQQQQAABBAIoUK2CIgUDH8U5X3bZZW5Uhw12eBZZP/XUU723ZGRk6LnnnvOeew5WrFihVatWeU7ZV0OBWrVqm5E+drqnig+IFOQtuDD7vbcdWZh90KDyjx5JSkp2oyLi43+jzIzd6tZd6t3bz1GXgp3iHAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQ8JNAtQqKlNWsZcuWGjVqlPe2s846y3vsWWzdk2DPC6Z5rrGvXgLp6Wmuw3ZJGrM0zXHZmpqlTB4ys7fZz+xZ0mtm9IhdmL1nf2nUGKlTyUvbFNrumJhotWnTRj9tSDGdO6ROnQiIFApFIgIIIIAAAggggAACCCCAAAIIIIAAAghUSoHArFpcKbtOoxDwv8DmzT/rm2++UXp6upYvX64ffvjR/5WUscRhZn2ReR9KU2bITOsm3XytNHKENGd2GQsy2e1IkQ0bNpjpwULcZ+PGjWUvhDsQQAABBBBAAAEEEEAAAQQQQAABBBBAAIHjJEBQ5DjBU23VFLCLqjds2NAFRuxaNB07/qbSdNSODnnyaemDBdKQoXmjR/p2kyZNlLZvK10zDx8+LLvwUY0aUYqKjNTevXtLdyO5EEAAAQQQQAABBBBAAAEEEEAAAQQQQACBSiBAUKQSPASaUHUEcnJyFR+foNjYWB06dEipqXlTaVWmHtqF2T2jR574h0w7zfng0o0esQvJDx482PUrLi5OF154QWXqGm1BAAEEEEAAAQQQQAABBBBAAAEEEEAAAQSKFSAoUiwPFxEom0BSUpJq1qxp1tropKZNmyoxMbFsBQQ4d0+zJIgdPfLJMqn/QOnFZ6XiRo/YIM/PP/9sFpGPNi0N0k8/MX1WgB8Z1SGAAAIIIIAAAggggAACCCCAAAIIIIBAOQQIipQDj1sRKCgQG1tT7du3d8lt2rRWgwb1C2aplOd29Mj1N0gfL5KKGz0SFRWpJk2aKCoqykwN1sn0r0Gl7A+NQgABBBBAAAEEEEAAAQQQQAABBBBAAAEEChMgKFKYCmkIVGOBkkaP2GCP3SIiQhQXZ6IpbAgggAACCCCAAAIIIIAAAggggAACCCCAwAkiQFDkBHlQNBOBQAsUNXrksotStWZ1rLKzc3XgQHygm0V9CCCAAAIIIIAAAggggAACCCCAAAIIIIDAMQsQFDlmOm5EoPoIeEaPvPrObjVq8oNWLYnTHTcE6b5707R9W9VyyMzM8nYoNzfXe8wBAggggAACCCCAAAIIIIAAAggggAACCJz4AgRFTvxnSA8QCJhArVqNVKd2W3U/a5MiaiQrPe0kDRssjRwhzZkdsGZUWEVZWdlasWKFEhMTtWvXLn355ZciMFJh3BSMAAIIIIAAAggggAACCCCAAAIIIIBAwAUIigScnAoROHEF/vZEtj57P1aZmeFKPRStbT+n6Yl/Sv0HSq+9LPXtJk2aKK37/sTsY2hoiEJDQ7V+/XotXbpEkZGRCgoKOjE7Q6sRQAABBBBAAAEEEEAAAQQQQAABBBBA4CgBgiJHkeQlbNmyxb0MrVGjhl555ZV8uRYuXKgBAwa4zznnnKOJE81bYLNNnTrV3eM5z3cTJwic4AI7d0g//RiSrxcpByO1Yrl0/Q3SvA+lKTOkQ4ekm6+VLr0wb/RI4uF8t1T6k8zMTKWmpungwYPKyMio9O2lgQgggAACCCCAAAIIIIAAAggggAACCCBQegGCIkVYzZ07V4sWLVJKSopuueWWfLn69++vBQsWuM/WrVs1atQod/0Pf/iDm2onIiJCK1euzHcPJwic6AJmAIXCwo/uRVTUkbROnaUnn5Y+WCBdMzpv9MhvB0j33nVijB7Jzs7Rzp07dehgXe3e1Vr295sNAQQQQAABBBBAAAEEEEAAAQQQQAABBKqOgHnNyVaYgF1X4JprrnGXxowZow0bNqh9+/b5si5ZskRNmjRRixYt3HWbz25t2rRxQZFu3bq5IMmcOXO0du1a9e7d271wzVdIIScJCYfNf6qHmSmKkgq56v+ktLS8ejIyUv1feCElZmSkKDs7U1lZmYVc9X9SVlaa+Y//VOXk5Pi/8EJKtH1LTT1kRg0FJuaYk5Ot5OQEhYSEFdIa/yWFmuIvuDhbXywMUfMWh5Rwyl41bJSus/uGKT7+6AXJzzlXsp/1P4brP+/H6KaREYqsIQ25MkkXX5KsmjVL/zySkw8qODiswk0zMzMUHp5tLENNfdnuO7Nt2zZznn+EjK/q3r17ze9qYL7LvvVyjAACCCCAAAIIIIAAAggggAACCCCAAAJlFyAoUoRZdHS09yW6fSEaHn70v8jPmDFDv//9710J9rrnxand2/s9W8+ePV1ZsbGxql27tie5yH1mpn3BHGHKiCkyjz8v5K2ZEGTqi/NnsUWWZQM+2dkZiokp2aLIQspwwQZhgoNDA1ZfVlaGed7ZAasvOzvbvJRPD0h9w4ZLtWrlaN26ZDVtXlu/uzpHHX5zdEDE9/F06y51627yTEzTO3PC9N47MZr5zxid2stMsTU0W+cOLDmgkJ6ebL6ftc1zrPhAU2xsPW3aKLPYeq4LetarV8+3O0cdHzLzhW3fvv2odBIQQAABBBBAAAEEEEAAAQQQQAABBBBAoPIJBCUlJRX/RrMC2+wbOKjAao6paLuOiF1kecSIEeY/2muaF6SJWrx4sSurT58+Mm6yL0vT0tK85Xvy2TVFrrrqqnwjS+w6JHFxceratas3f1EHu3bt0+HDka7eovL4Mz0pKcEUF2ReqtfyZ7FFlpWSkmhGiaTLvnwOxJaenmJGbiSal/kNA1GdCVBkmOe3T3XrNglIfTYoEh+/Q/XrNw9IfbaSl/61Vd26tVDX04+tyu3bpNmzpA/nmvuDzALtZkTJKDPQqmmzwsvbt2+L8Wxe4UGRw4cTNW/ePO3Z3co8w2z16v2TGzFm/xYUtW3evFlr1qzRkCFDispCOgIIIIAAAggggAACCCCAAAIIIIAAAggUIZCcnFzElYpJrvh/u66Ydld4qaNGjXIBjwYNGrgXnrbCb7/9VnYqHbvNnDlTI0eOdMeeHzZoYvP369cvX0DEc509AgjkCdjgx7g7pY8XSXc/kLc4+7DB0sgRx3dx9iizQEqzZs0UbEZ72bWB7FR4ds+GAAIIIIAAAggggAACCCCAAAIIIIAAAlVDgOmzinmONjBiP55t7NixnkPdfPPN3mPPQZcuXWTXF2BDAIHSCwwywRD7SZwgvf123uLszz4m9eyfN3rELt4eqC0sLFQNGzZUZES6goNC1bhxLbOOiRnKwoYAAggggAACCCCAAKGVgXgAAEAASURBVAIIIIAAAggggAACVUKAkSJV4jHSCQROfIGasdL1N0jzPpSmzJDs+c3XmoBJX+nNN2prx/bABSfq1q2r1q1bm7Vvsk98WHqAAAIIIIAAAggggAACCCCAAAIIIIAAAl4BgiJeCg4QQKA0AvHxdg2ait3s6JCHxktfrJRuvF1a9XWUhp8fpFt+L33ycQXX3amjQkKC3bRZnTsHcJhKxXaL0hFAAAEEEEAAAQQQQAABBBBAAAEEEEDACBAU4WuAAAKlFti7d5+WL19uRlBkafPmrVq5clWp7z3WjMOGS088tVOzPspV9zOlJx82C7N3kyZNlNZ9f6ylch8CCCCAAAIIIIAAAggggAACCCCAAAIIVEcBgiLV8anTZwSOUaBBg/qya+ccPHhQCQkJOv3004+xpLLf1qRprpteyy7ObqfXOnQob3qtSy+UXp5m1iQ5XPYyuQMBBBBAAAEEEEAAAQQQQAABBBBAAAEEqpcAQZHq9bzpLQLlFoiPj1doaJgyMtJlj4/HZqfXevJp6YMF0jWjpf+ZKbXO66mATK91PPpLnQgggAACCCCAAAIIIIAAAggggAACCCDgHwGCIv5xpBQEqoVAVla2UlJSFBcXp3bt2unw4eM7PMMuxm6n15r5ljR7vvw2vVZSUpD27q0Wj5ROIoAAAggggAACCCCAAAIIIIAAAgggUK0ECIpUq8dNZxEon0BoaIh69DhDJ52Uq3r16qhVq5blK9CPdzdtpkKn1xrUN296re3bSq5sx3ZpnFnYfcVy6c0ZQbrJLOy+e3fJ95EDAQQQQAABBBBAAAEEEEAAAQQQQAABBE4MAYIiJ8ZzopUIVCqBbt1z1TVwy4mUue+e6bW+WCndaIIcy5eaESWD86bXmjO76OJee1Va9pmUkhykxIPSf2dJr75SdH6uIIAAAggggAACCCCAAAIIIIAAAggggMCJJUBQ5MR6XrQWAQTKKGCn15ry0pHptV57WerbTbr3LhMAMcESz5aRIX27ynN2ZP/FwiPHHCGAAAIIIIAAAggggAACCCCAAAIIIIDAiS1AUOTEfn60HoGAC6xevcbVGR+foJ07dwW8/mOt0DO91rwPTZBkhmTXI7n3NslOrzVporR3j9Sw8dGlt2p1dBopCCCAAAIIIIAAAggggAACCCCAAAIIIHBiChAUKea5vfLKKxo9erS2bNlSaK7HH39cQUFBWrhwobs+ceJEeT6F3kAiAlVAIDMz0/xO/KwVK1acsL2x02s9NF6y02vd/YB06FDe9Fob1plgSV0pOyvvT2Nrk+96s64IGwIIIIAAAggggAACCCCAAAIIIIAAAghUDYHQqtEN//di2rRpCgkJ0fjx43XyyScrKSkpXyW9e/fWkiVL9Oc//9kbFJkwYYJyc3Pz5eMEgaom0MoMnVi27BPFxDQ2C64XMrTiBOvwILPWiP0kTpDmz5dmTpd++q6h2p0qPfH0YbN2ihlSwoYAAggggAACCCCAAAIIIIAAAggggAACVUKAoEgRj3H58uW677771LJlS1155ZXatWuXGjfOewF84MABLV26VJ07d1bt2rU1adIkbyn9+vVT27ZtZYMqdrNBkvXr12vr1q1q06aNEhMTvXmLOkhNTVVGRo5SU4OKyuLX9PT0FFNekAkCBebrYOvLzs4w/csfaPJrp3wKy8y0nqkBqy8rK1OZmWkBqy8nJ9vUF5j+HTp0UGvWrFXr1i2VnCx9883X+s1vfuOjXTGH1jMtLcmMzKq4wW2hYdJ5gzLUqPEaffet/V2PMCNINikhoatCQ4v+3Ug2EHb0DBsCCCCAAAIIIIAAAggggAACCCCAAAIIVH6Bot/0Vf62V2gL9+7dqwYNGrg67H7Pnj3eoMiaNWvctQ8++MBNl2WnEerfv78LgOzbt089evRwo0dsmt3s9Fu7d+9W06ZNzYvyVJdW3I+MjHTzkjXXvMivuBfAvvVnZqa704wM81Y4AJt9wZ2dnekCFQGozgUobJ02MBKIzRMUCVR9NiiSlZURkP5FRUWYoF8rE5xIM78PJ5l6swJSrzW1wbTg4JAKf4RNmzbSxp/2mO9NiJo3b+4CHsUFPdLS0iq8TVSAAAIIIIAAAggggAACCCCAAAIIIIAAAv4RIChShGOfPn3cCI+uXbvqqaee0mOPPebNaYMdNWrUcKNI7MiQWbNm6Z577nHX69ev7wIknkCJXXPk/PPPV2RkpOLi4ryBFm9hhRxkZweZl86RqlmzZiFX/Z+UN0IkyEyHVMv/hRdSYkpKonmZnq7Y2HqFXPV/kn2ZHhoabvzr+7/wQkrMzMwwqbkBqy87Oy8oEqj+2Xr27Pk5YP2zxBkZyaa+BiYoUrGBwpSUVK1a9aUOHmqqFDMSZtWqVRoyZIgiIiIKedJ5SXZqvZ07dxZ5nQsIIIAAAggggAACCCCAAAIIIIAAAgggUHkECIoU8Sy6dOniRnxcc801uvrqq12uyZMnq27duhoxYoRZS+EkXXTRRWYKoWS37ohdbH3AgAG6+OKL3RRZ06ebhQnYEKiCAnZ0SFXdatSIctPfbd1qp5QLUadOnYoNiFRVB/qFAAIIIIAAAggggAACCCCAAAIIIIBAVRUgKFLEkx00aJCbNsdOfWXXFbHbVVdd5fb2x+LFi7Vu3Tr30tSTaNcPWbRokc4++2xPEnsEqpRAWlq6WUfkG/M7UU/btm0363ykqV27tlWqj+Hh4QoPzzaDfcIUFsafyCr1cOkMAggggAACCCCAAAIIIIAAAggggEC1F+CNXwlfAU9AxGarU6dOvtz2v8gLbgRECopwXpUEIiMjVLt2bTO13AYzpVWYzjzzzKrUPdcXG9ysW6eeoqLqmrVvfq5y/aNDCCCAAAIIIIAAAggggAACCCCAAAIIVGeBip2gvzrL0ncEqqiAXU8nIyPNrNMSqujo6CrXy44df6OQkCAzbVZ4vpFgVa6jdAgBBBBAAAEEEEAAAQQQQAABBBBAAIFqKEBQpBo+dLqMwLEKHDgQrw0bNqhDh45uXZ21a9cea1GV9r6vvlpups7LVkpKipYvX15p20nDEEAAAQQQQAABBBBAAAEEEEAAAQQQQKDsAkyfVXYz7kCg2grUrVtHPXr0UGrqfrVo0arKOSQlJWv37t3avSdXKck71fikHTrllFPMVFpRVa6vdAgBBBBAAAEEEEAAAQQQQAABBBBAAIHqKMBIker41OkzAuUQiI2tWY67K/etMTHR6tq1q9LNAvLJySnq3bs3AZHK/choHQIIIIAAAggggAACCCCAAAIIIIAAAmUSIChSJi4yI4BAVRawI0W++eYbRUZFmvVSamjJkiVKMwESNgQQQAABBBBAAAEEEEAAAQQQQAABBBCoGgJMn1U1niO9QAABPwjYkSKNGjUyo0XqqmnTmtqxI0iRkZF+KJkiEEAAAQQQQAABBBBAAAEEEEAAAQQQQKAyCBAUqQxPgTYggEClETjzzB7as2e74uJqmcDImZWmXTQEAQQQQAABBBBAAAEEEEAAAQQQQAABBMovwPRZ5TekBAQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEDgBBAiKnAAPiSYigAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBA+QUIipRguGXLliJzpKamatasWfmuL1y4MN85JwgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIFA5BAiKFPEc5s+fr4iICE2ZMkWjR48+KtcNN9ygGjVquKCIJxASFBSkffv2uYWZExMTj7qHBAQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEDh+Aiy0XoT9smXLtHjxYnXv3l3h4eGaPn16vpxz5sxx50888YRatmzpjsPCwjR8+HDt2LFDK1euVP/+/V06PxBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQOD4CxAUKeIZ2KDG3Xff7a6OGzfOBTm6devmzr/99lsdPHjQBT0GDRqk66+/XgMHDpTNZ7f27dt7gyK5ubmaPHmyNm3apHPPPVdxcXEuT3E/Dh9OUlpamFJSIovL5rdr6enJrqzk5AS/lVlcQRkZqcrJyVJqamBG02RlpSszM03p6SnFNctv17Kzs8zzS1RWVobfyiyuoJycHPNdSTCm2cVl8+u1xMT9fi2vpMKSkg4oOztbQUGBGdyWmBiv7dtTzWixkJKapm3btpnvV2aJ+ciAAAIIIIAAAggggAACCCCAAAIIIIAAAsdfgKBIEc+gY8eOio+PV3R0tOxUWJ7RIDZ7s2bN1KVLFy1YsMBNn/Xaa6/JTqflmTLr8OHD6tChg7fkW265RXaKrdq1a6tVq1be9KIOdu3ap8OHI1WzZmxRWfyanpQUb8oLUkxMbb+WW1RhKSmHTcAgXbGx9YvK4td0G/SxAZhatRr5tdyiCsvMTDffhX2qU6dpUVn8mm6DMAkJIapXr6Vfyy26sFxzKVcNGpT8XS66jLJdCQ4OMp7NFBxccpCibCUXlTtUTZo0ML+D4UVlyJeekBCYgGK+SjlBAAEEEEAAAQQQQAABBBBAAAEEEEAAgTILBObfrsvcrON/Q48ePfTZZ5/JLrT+5ptvqm7duvrXv/7lPQ4ODta6devcp1evXu76G2+84Rp+1VVXyTOqxK4zEhIS4j72uGwfE6oICsTH065A1GXrqPr1mV4G6NnleUrBAa4vkP3L+3uQ970JzHc07/l5vqfF723rbNvYEEAAAQQQQAABBBBAAAEEEEAAAQQQQKDyCxAUKeIZDR061E2PZUd4eP4L3C687tm++eYbjR071p3ed999bm+n1Jo4caLslFmNGzf2ZGWPAAInkMDXX68005GlmpFiB7R8+fITqOU0FQEEEEAAAQQQQAABBBBAAAEEEEAAAQRKEmD6rGKEWrZsqVGjRnlzXHvttd5je2Cnzyq4jR8/vmAS5wggcAIJNGzY0IwA+05bt6aqb9+eJ1DLaSoCCCCAAAIIIIAAAggggAACCCCAAAIIlCTASJGShLiOAALVSiAqKsos6p7lRnzVqFGjWvWdziKAAAIIIIAAAggggAACCCCAAAIIIFDVBQiKVPUnTP8QQKDUAunpGfrhhx/Utm07ty7Q6tWrlZWVVer7yYgAAggggAACCCCAAAIIIIAAAggggAAClVuA6bMq9/OhdQggEECBiIhwnXHGGTp0aJ+aNGlggiPNFRrKn8kAPgKqQgABBBBAAAEEEEAAAQQQQAABBBBAoEIFGClSobwUjgACJ5pAZGSEt8kERLwUHCCAAAIIIIAAAggggAACCCCAAAIIIFAlBAiKVInHSCcQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEECgJAGCIiUJcR0BBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQSqhABBkSrxGOkEAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIlCRAUKQkIa4jgAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAlRAgKFIlHiOdQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgZIECIqUJMR1BBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQqBICBEWqxGOkEwgggAACCCCAAAIIIIAAAggggAACCCCAAAIIIFCSAEGRkoS4jgACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAlVCILRK9OIE6MTu3bs1f/58LV26tMTW/vjjegUFhatFi1Yl5vVHhk2bNrhi2rRp74/iSixjy5bNysrKVNu2HUrM648Mu3fvUFJSUsDqS0iI14ED+wJWX2pqinbs2Baw+nJycrR5808Bq89+BzZuXK9mzVooIiLSH1+JEsv46af1atKkkerUiSsx7/79+xUbG1tiPjIggAACCCCAAAIIIIAAAggggAACCCCAwPEXCDIvi3OPVzOio6OPV9UBrzcjI6PUdX722Wdq1KiROnfuXOp7ypPxq6++MkGYIPXo0aM8xZT63jVr1si+SB4wYECp7ylPxs2bN2vdunW66KKLylNMqe/ds2ePFi5cqCuvvLLU95Qnow34zJo1S6NHjy5PMaW+1wZFXnjhBd12222lvqe8GV966SVdffXVioqKKm9Rpbr/3//+twYNGqR69eqVKr/NFB4eXuq8ZEQAAQQQQAABBBBAAAEEEEAAAQQQQACBPIHk5OSAUjBSJEDcZXlhWrduXYWFhQXsJWtERIRTKEsby8Nm+1a7du2A9c/W17Rp04DW16FDh4DW17Vr14DVZ4MiZ511VsDqs9+17t27B/R3olOnTgGtrzy/T9yLAAIIIIAAAggggAACCCCAAAIIIIAAAqUXYKRI6a3IiQACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAn4UCPRIERZa9+PD81dRduqllStX+qs4bznx8fGyU2VNnDjRm2YPbH3247sVluZ7vTTHmzZtcnU99thjsmuqeDbbt4qo79NPP9UVV1yhgvVt2bJFr7zyiqd6ty+sDfkylOGkoFVh9RWWVoYqXFZbj3129vPWW2/lu73gM/VHfZ4KZsyY4VztNGSerWB9Nr2wNE/+0uxt/+w0WbYcz8dzX2FlF5bmyV/a/fbt23XnnXe66cd877HfF2vou/mjPt/yOEYAAQQQQAABBBBAAAEEEEAAAQQQQACBwAsQFAm8ebE12rU9Pv/8c73xxhtHvagt9sZSXHz++ef10Ucf5cvpqc/WaV8O282T9p///Meblu+mUp488sgjLuf777/vXc/Drn1h++Zbn63X1uWbVsoq8mVbvHixhg8f7taBGDhwoLtm67Mvs+2aLr179/amFWxDvoLKcGIDTcOGDXNtt7fZ+u644w5XQmRk3qLghbWhDFXky2oDB/3793drztgLu3btcmuz9OvXTzVq1HB5C2tDvkLKcGLNxo4d61x/+eWXfPXZ74mtv7A2lKGKfFnbtm0r25fVq1fr5JNPdtdsv2yab312ejLftHyFlOHk/PPP16mnnqq1a9fK2trN89zsc7SWdivYBpfIDwQQQAABBBBAAAEEEEAAAQQQQAABBBA44QSYPquSPTL7QjYtLc0tDP7yyy/rb3/7m19baF/y2hfAnv9699RnK/Ece/Z2cfIbbrhBS5YsKXcb7Avt3Nxc3X333RozZozsmg2eeuy1vXv3qn79+t608lRo221HjNh++tZn6zl8+LDre8E2HGt91113nQv42DrHjx/v6jvzzDNdEKGw+jxpNWvWLHOV9qW9fW5DhgxxgZHTTjvNBZO2bdumW265xQUNPP1r06ZNvrRjqc+WFRcX5z7PPPOMW8jdBq889f3zn/9Us2bNXD88aeXpnwfELhxv22u/L4mJibr55pv1+uuvy7e+//3vf3r66ae9aRdddJHn9jLtbeDF9sm62oXq7dosvvXZ0U72ufqm2T4fa31lahyZEUAAAQQQQAABBBBAAAEEEEAAAQQQqAYCTJ9VDR5ycV3s1auXu2yDBhUxhZYt3L7s9mye+ux5enq6S/ak2TYsXbrUk/WY9xMmTNDcuXPd/U899ZQLiNgTT3125IMNiPimuZNj+GGDIeedd557oW5v963PtsOa+qZ52nAMVentt9+W75RSnvrsaBW7FVafJ81lOIYf9gV9nTp1XNDH3m7707FjR1eSp+zC0o6hKq1atUo9e/bUH//4RxfImjp1ar76bL22Ln/V52njzJkzNW7cOHdqy27fvr079q3vkksuyZfmubese/tdt6NOPvzwQx08eND1pbD6CqaVtR7yI4AAAggggAACCCCAAAIIIIAAAggggEDlEGCkSOV4Dt5W2Gl6UlJStH79er3zzju67777vNf8cWBHitgptKZNm+aK89RnTzzHnr1tg30hbl8YH+vmGZFiX+bbza73cfnll7sX0Z567OiCAwcOuJf9nrRjrc9zny3TjjTwrS8kJESpqakuKFKwDZ77yrJv1aqVRo0a5YI8L7zwghu9ER4eLjuC44ILLlBoaKh7ljYI46nP0wabrzybDf7Y4IsNJtnAjB354ltfw4YN86UdS312yjHrZ5+d/d7Yz6233uqtz45kat26tetGwTYcS30eDxuIsYERO5WWbYP9TmRlZcm3PjvVmm2XJ80G1sq6fffdd3r00Ufd+iw///yz/vSnP7l6fevbs2eP7rrrrqPacCz1lbV95EcAAQQQQAABBBBAAAEEEEAAAQQQQKA6CAR6pEhodUA9kfpoX9rbQIJ9Gf3ee+/5tem23O+//96VaaeVslNzeeqzowzsx26FpbkLZfxhX9zXqlXLTYn10EMP6eGHH1a3bt3cGg52hIanPrt/4IEHNGXKFG9aGaty2W3/7H/02+mXPJutr3v37u4F+rXXXiv7sr6wNnjyl2VvX6TbbaGZ1sqWaV/Sf/zxx7r00ktlgyRRUVHe+gq2oSz1ePLa/tnRO19//bXs+il2pIqdXuqyyy5zwQn7Mt/TP9uG4OBgbxs8ZZRlb8uy01jZ70pMTIx7NnbqKE99Nlhg1xmxmyfN04ay1OOb107VZoOCNiBiN9sGW6Y19q3vwgsvdGuK+Kb5llOaY7uWiDW0U2bZ76N9RrY++9zsQuu33Xab5s2bV2QbSlMHeRBAAAEEEEAAAQQQQAABBBBAAAEEEECgcgkwUqRyPY8KbY19sey7VfR/u/uOMLHrh5xzzjm+1VfIse2jnV6qXbt27uW2p5ItW7aoZcuWnlO/7j2uvp6F1VdYWlkaYoMidrMLjPvWZdNsGwqmlbc+W67dbIBnxIgRzjUvpfD6CmuDJ39p94VZ2nsLK7uwtNLW48m3ceNG/fe//3VBGDu6x7MVZueP+jzls0cAAQQQQAABBBBAAAEEEEAAAQQQQACBPIFAjxQhKMI3DwEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBI6LQKCDIsHHpZdUigACCCCAAAIIIIAAAggggAAC/9/efYBJVZ2PHz8gVuyAoqigWLFjCRhj74qaCFY0CfqzV2JU7CUxURNbVFRENCpGsWEXRcSI2BXBLiDWoKioICoqf74n/zO5DLNldpeZnd3veZ7dmbntnPu5d3af533vOUcBBRRQQAEFFFBAgRILmBQpMbjVKaCAAgoooIACCiiggAIKKKCAAgoooIACCiigQHkETIqUx91aSyDw1ltvxcm5t9566ziZNpNnMzH4XnvtFWtnIvghQ4bE98zX0aJFizh3BRO/d+jQIU54X2wzqSu/cOw0H0j+uvp8zh7z3HPPjW2vz/HcVwEFFFBAAQUUUEABBRRQQAEFFFBAAQUUaOoCJkWa+hVupufHOHQ77bRTaNu2bbj11lvDNddcE0aMGDGHxu233x569eoVl5EImTVrVpysfOTIkeGjjz4KZ511Vlz3/fffB37yy7Bhw3KLXn/99fDZZ5/NMbl7bmU1b9gvvzDJN/Xnl7Fjx86xaNCgQbnPLVu2jG1/+umnw4wZM3LLfaOAAgoooIACCiiggAIKKKCAAgoooIACCijwP4FW/3vrOwWajsDw4cNDp06dQr9+/eJJtW/fPmy66aaxp0g6S3pabLnlloEkCCXb8yKtu+mmm8KECRPi+lVWWSUMHDgwbjf//POH0047LSZSDjjggDBmzJjwwQcfhO222y5uW9Mvjk+9JG9WXXXVcMstt4ShQ4eGwYMHh7XWWiser0ePHqFPnz6xPpI2W221VfxJbZ40aVKuzfPNN1/o27dvWGKJJcIll1wSl3fp0qWmZrheAQUUUEABBRRQQAEFFFBAAQUUUEABBRRoVgL2FGlWl7v5nOzNN98cjjzyyFqdMD1C2rRpE3uGpN4hvG6wwQbhtddeiz1M6GVy/fXXh6lTp8Zjjh8/PiZEPvnkk8DPuHHjYiLjrrvuqlWdV111VXj88cfDs88+GxMjd999d0xofPrpp4EECImNv/3tb/FYfE7tGDBgQFyWbSfvf/rpp0AShPe77rpruO2222rVDjdSQAEFFFBAAQUUUEABBRRQQAEFFFBAAQWak4BJkeZ0tZvRuTIsVpovpDanTVIkvzD/CL1LUjnmmGNyPU0OPPDAuPiVV14J9NKg0DNl7bXXju9r+vXjjz+GQw89NGyzzTbhxRdfDK+++mrchd4gFI41ZcqU+H6RRRaJCQ8+7LvvvnFZoV/0EqFk9y20ncsUUEABBRRQQAEFFFBAAQUUUEABBRRQQIHmKmBSpLle+SZ+3ptvvnkYNWpUoEdGKgwvVVUplBRZb731Qv/+/XO78J5l2bLzzjvn5hEZPXp0wblAstun91tssUVg2C16i9BOhsTKLyuuuGJctO666wYmiWeuERIo7dq1y990rs/LLLPMXMtcoIACCiiggAIKKKCAAgoooIACCiiggAIKNHcBkyLN/Q5ooue/3HLLxXk6mKujRYsWoWvXrrleH0y+nl8WXHDB/EXxM3N8sP9mm20W5/sotBEJjcUXXzzO48GQW4UKc5OQUOnevXvcrnPnzoE5Qzh2x44dC+0Sj8mKZ555JjB/yG677RY23njjXG8VepUwz0maC2WhhRYqeBwXKqCAAgoooIACCiiggAIKKKCAAgoooIACCvxXoMW0adNmlQujdevW5araehWoGAGSHgwHNmPGjHDFFVeEQYMGVUzbbagCCiiggAIKKKCAAgoooIACCiiggAIKKFCdwPTp06tb3eDrTIo0OKkHVKBhBRgy6/777w8rrLBC7GnChOoWBRRQQAEFFFBAAQUUUEABBRRQQAEFFFCgKQiYFGkKV9FzUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAgRoFSp0UcU6RGi+JGyiggAIKKKCAAgoooIACCiiggAIKKKCAAgoooEBTEDAp0hSuoueggAIKKKCAAgoooIACCiiggAIKKKCAAgoooIACNQqYFKmRyA0UUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFCgKQiYFGkKV9FzUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAgRoFTIrUSOQGCiiggAIKKKCAAgoooIACCiiggAIKKKCAAgoo0BQETIo0havoOSiggAIKKKCAAgoooIACCiiggAIKKKCAAgoooECNAiZFaiRyAwUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFGgKAiZFmsJV9BwUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFCgRgGTIjUSuYECCiiggAIKKKCAAgoooIACCiiggAIKKKCAAgo0BQGTIk3hKnoOCiiggAIKKKCAAgoooIACCiiggAIKKKCAAgooUKOASZEaidxAAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFmoKASZGmcBU9BwUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFKhRwKRIjURuoIACCiiggAIKKKCAAgoooIACCiiggAIKKKCAAk1BwKRIU7iKnoMCCiiggAIKKKCAAgoooIACCiiggAIKKKCAAgrUKNAskiJTp04NL774Yvjmm2/CrFmzwptvvhlfa9RpxhtkzZoxg6eugAIKKKCAAgoooIACCiiggAIKKKCAAgoo0IQEWjWhcyl4Kp9++mno379/WH311cMKK6wQfvzxxzBgwIBw+umnh6WWWqrgPo1l4b///e8wYcKE0LNnz9C6deuim8W+jzzySNh9991Dhw4dar1/vtliiy0Wfv7553DvvfeGN954I8w333xh/fXXDzvssENo0aJFPO7MmTPDVVddNVcd++yzT2jfvv1cy4tdwHV7+OGHw6uvvhqv4WqrrRZ69OgRFl100dyhvv7663D33XeH9957L17bLbfcMrYzbVCbY7Dts88+G5555pl47IMPPjjtXuMr+4wePTpMmzYtdO7cOfzmN78JCy20UNxv1KhR4YUXXpjrGNj26dNnruXZBSSo7rvvvngvLLjggmHDDTcM22+/fWjZ8n85za+++iqeO6/bbbddWHvttXOHSPvmFmTerLzyyvH+YBFuDzzwQPT93e9+F5ZYYonMliE89dRTMbmYXdixY8ew5557ZhfN8f6ll14KI0aMCLSrbdu2YaeddorfxbQR99Xjjz8e2O67774Lq6yySthjjz0CLtWVmq7Rv/71rzB58uQ5DvHLX/4ybLzxxnMs48NPP/0UrrjiirmWswDnLl26FFznQgUUUEABBRRQQAEFFFBAAQUUUEABBRSoPIEmnxR59913w/LLLx/222+/3NW58MILY2A/tyDzhkDqxIkTYyB08cUXz6wp3VuCw3feeWdMROy1115FJ0ToDfPEE0+EsWPHxsB8MQkRzrKQ2W233RaDxwceeGB8HTZsWHjwwQfDrrvuGmG+/fbbGIQmmJ4tSy65ZPZjnd8PHjw4JmB69+4dSMA89thjMbl1wgknxGMS2CYps8kmm4Sdd945TJkyJSZxSCKsueaacZuajjF9+vTAef7nP/8JG220UUxw1LbBzz//fNx+t912iwF9EiDXXnttOPbYY+Mhvvjii5gU6N69e+6QbENd1ZXvv/8+XH311aFr164xQE/CiuTUDz/8EJNC7DtmzJhw++23h27duoXPPvss9ojKHpNzWWONNeKiJ598MvaSImFEIdlGYoLkGUk4Ek0YYJxfPvroo7DSSivNkXCpLlnHuZG82HrrrWNijIQaCck//OEPuUQZyQvOiXpJwpAcueSSS+I2hY5d22s0fvz4mBzKJj7btWuXf0rxM+fPd/7oo4/OJZq4n2hrq1ZN/k9kQRMXKqCAAgoooIACCiiggAIKKKCAAgoo0FQFmnTE79FHH41PtxNYvuiiiwK9FpZddtlw+eWXx2A1AXOCn0OHDo3B2Pnnnz+wjMA/T/jzdDuB0RNPPDF3/QkeE6zdfPPN47Ibb7wx/OIXvwjvzX7K/sMPPwyHHHJIXD5y5MgYZCbBsc4668TkxAILLJA7TnVv6O1ADwzaUagQsGYbkh4ck7YQeE6FYPvTTz8dTjnllILJHwLLJF3efvvtmDAiUE/vA0ohM86XwPuf//zn3PH233//cPbZZ4dtttkmLLzwwmHGjBmBJBI9cqoqBOyHDBkSPvjgg9hrZ9ttt80lLKraJy3n2nGuqWcK1+riiy8OXFuuGcOjEVTnmJRlllkmBvbpXZKSIjUd48svv4wJDRIvBNXp9VHbQoLooIMOCvS8oJAcueCCC+JQbdRPUoKeHfSEoJC4IiGw4447xs9V/eLcjj/++FyPE3rd4Pjyyy/nkiL0CCIZRe8ZElr5haRgKvS0oe7sdeIe/fzzz2MigmtIUqRQIfHFeWT3zW5HAuShhx4K/fr1i9eEth5xxBG5TegpQjKNBBHrSEZw3Q4//PDYdjakrdxr3JvckyRWSHZxftjV9hrRVnrLZHsS5RqS94aeTyTS6N2T7i+SM9xPmFoUUEABBRRQQAEFFFBAAQUUUEABBRRQoOkI/G/8naZzTrkzYYgnfgjAMsQPQVkCwjzxziuFp+MJJBN4JjhLkoSgPQF4hlti22xhKCOGaUqFp9xJJLB83XXXjYsJDhNQJ5DLMQkC8yR/bQpDLxGQ5Ul+jkOPCOrIFo5FYqNv374x2cLQTAzdlAoJGYZQYu4UkjjvvPNOWhVfGU6JHhzHHXdcTOjceuut8XisLGRG7xmGMyJ4nAqJEgLIBNMpBKEJQBPEJvDNUEsE21PBkiGKVl111dhuei/885//jImntE11ryQHUsCa7d6bnYQiaM1yCvUuvfTS8X36xWeWp1LTMRherVevXvHap31q80qvDYL1+fXTSyHVTyKBc0/lrbfeimYbbLBBWlTlaxqCK20wadKkmNxLn3/961/XK3jP8UkEtWnTJh2y4CvXeJFFFgn0iiH5QTImW0j6ZO+RtI774OOPPw533XVXoLdG6rXC9iS3svc3lnyXuL9TyQ4TVptrxHebOkm68F3gO0TPoaoKxyc5lb2/6FFDsjG7rKr9Xa6AAgoooIACCiiggAIKKKCAAgoooIAClSPQpHuK0FuAHwL36YnvbKCey0TCgKGJSJhQCFKzjKGIalvoCZLtqcEcCiRhCOBSmNPj73//eyB4XWhIoGw9BJoJptOjgiA7vU9IbBx55JGxFwIJGZ6kP/fcc2PvAbal5wBBXNpM4JoA9GuvvRZ7StCrhN4SzNOw1VZbxapoR0omEKR+7rnnwiuvvBKYc6GQGRPUFxpGiIA2SRwKQWy2I/BNwmXcuHHhidlDeP3xj3+MddFDgeXMQ0KhXuajILFRbKFXCsHuLbbYIrcrddNjJVtoM9cbA9qaLYWOkV1f1XuSHPROoXB8hiajbkp+HVmfuEHmF9eLHjopiUAg//33389tQYKpUJKChB3DUB111FG5bUv1hnuL+T9oG0kGkl8M75Z6TTF0GT/5hR5GGHE+JAnTObPdeuutF+9d7gO+gyTTcE0JJhKaZ8/ukVRM4fpQB8lD2sr3mbYec8wxYcUVV6zxUBjzHTrssMNq3NYNFFBAAQUUUEABBRRQQAEFFFBAAQUUUKCyBJp0UqQ2l4JALUmFVHhqvdh5MFJChWPwdDrHoPdJtpcJT6NTT01JEbYh4EwgOM1pMnDgwPhkPokRem0QbKd3SCr0UmA/AuvsSxsYeigNiUUCgQm0CV4TcCYhQuA3BfhJHKTkRjpm9jU/2J/WUV9aR7CZp+2pk6freeL/jDPOiD1mSMbQboYuy5blllsu+7FW7zm3m266KQbNs4ko2kF78gvunHO2VHWM7DZVvadXDT01KNw7nGMyyK8/65M9HteIniJ77713bjE9aZhLIxWGZMvOg8NyEmLXX399HLKsU6dOadOSvTLEFMmsdB1J1nFfkUyrrkfF6aefHnsE0cPksssuCyeddFLu3iZ5yDBiN9xwQ0wGck3pZUUypK6F692zZ8+YcKEXDNehf//+MbmYhrer7tgkrJiQPT/JVt0+rlNAAQUUUEABBRRQQAEFFFBAAQUUUECByhCYM1pcGW1u0FYS0CVgOmjQoJhMIODNsFJ1LQS3CbrzpHo2UMyE5CnJUd2xSVAQ8M5uS+8V5hCh0OuB42aPzVP1BKwJ/rI/QXrmU0gl7U+PGQLaBLPpHcJcFzxJT5urKwydRS+BbEl1sT+FRBI9blJh+DGOzxP3lNTutL4ur7gy5BZtYa6K7LBKtJFkQ7awXRrmKy2v7hhpm+peDz300JxXqh8Drge9T7JJLz4nn+wx6Q3B9ckm37hm55xzTm4z/LKFnhZXXnllnJ+Ga12OQo+obGGoNYbRYrir7ITm2W14TxKOHkh8B5gLhXlEUkKL4bj69OkTvzN4kpBg7pDUUyT/WLX5TFJk0003zW3KtaFHCr1caiokB2kjQ9NZFFBAAQUUUEABBRRQQAEFFFBAAQUUUKDpCTT7pAgBVOY4oNcCAVom406BbD4TUGXC9TTME0H16grBbAL0zC+Shs9ie+YqyQ4bVNUx6H3AUFPZQkA8BdtZz7EIKqfECG3iPT8Ek0lykBxJgfU0vBPnQ3KCwDNDCaWn8ZnzpLrC5NcEi+mpkJI1JDsIdqdeMiRJGLYoO/8F9aZgOe2id0S2FBrWKrs++55zpIcIbSAhkob/SttgzRBg2cLQY9lrUNMxsvtW9T5dh+x6gvkY0fsmeVAXRky4ni30oGGuGBIB+SXdY/nLsSchQpKJoc/KVUjyZHtPpPsquyzbNu4Hkj0pecQ6/Lg38wvbcJ4k7H7729/mry76c6G2cv/XVOilstJKK8XrWdO2rldAAQUUUEABBRRQQAEFFFBAAQUUUECByhNoWXlNbtgWEwQlwE4Sg3lHsgFe3nea3WuDScwJctPzYOLEiTU2gKfUCe4S9KeQ5Ljmmmtq3I8NaAdP3jPZOnUyLBbDDqWn9OnpwVP3w4cPj8djm3vvvTfOmcACgvLM1cFT8QSfmevjidlze7AsTZZOIigFtDkngvnVFQLZTBROrwDqIynDe3oKpEQPE9YPGDAgGrENc5q8N3sy9NRuntRnWDEsSKCQaLrwwgvjsFrV1Z3WDR48OE5mTjKBADq2/FAXZa211ornRA8YCscn+cOE7qnUdAy2S8clsUQ70+dUTzpW/iu9ZJjQm2A8++HP/YN7tnAtSSylOW6y6wq95xqSEGGSdhIsqT28Ug+FtqXlvOf6pM+FjlloGeeb3Sd95lgU1l1wwQWxFwWfuUfxpV0pEcacKMwpk6zwvvPOO+O+HIdrzzbcS/mF41933XVx2Krseu5f5tdhiLhUUjurukYMW/fXv/41fPLJJ3EXkmP0Tkn3Igu5PszNky20m148v/rVr7KL43u+h3fccUcuocO5cL1TYd6e119/PX30VQEFFFBAAQUUUEABBRRQQAEFFFBAAQUaqUCz7ynC3AFMgv7CCy/ES0TwluF7fv/738eeFttvv3245557YgCYhAQTa9dUmEz8tttuC2eeeWY8BkmFAw88sKbd4nq25Ul55llgomh6FhBwZ76OVDjWjTfeGNtEIJcn27NP1x9wwAFxmCnmu2A9832k+kkoMPzSLbfcEoPZDOHEvA4EsOntQFKmUNl///0Dc5v069cvBuMxyvZaYNJwgs9nnXVWTJQQsGdyd4LmFBIBtAEXfij0dknzU8QF1fwaO3Zs7InC/BTZ0qNHj7DtttvGeUMY2oph0IYOHRoD8cyhwvVNpaZjYMXE8NmSPvfq1SvOnZFdl33PuZD04fxJOnEdC81fQfKoUNA9e6zse4LxBPf5IWCfLQzxxLUnQfXoo4/mVpHkIpFAEuy8887LLa/uDYmXbMKPpAKFOWK4t+jxse+++8Zrx7FJ/qy88sqhd+/eucPSE4g2cq9y/twf3GennnpqTGRx7zExe+fOnXP78IYEC/cWx+OeyRZMmT+H3lz0OqrNNeI7utXseWwuv/zy2HuKxBITwHOfpMIx2Y7EXiokSbhvSeDlFxJ8nBvD7dGrjCG28Npuu+3ipiSI2K9Lly75u/pZAQUUUEABBRRQQAEFFFBAAQUUUEABBRqRQIvZQ9b893HzMjSKwGk5CwFQgr8EdkkcUBjyh8A683B069Yt1zwCtwxvlIasyq2o5g3H4mn2up4ndbIvAelCheGGGCIrDZOVvw1P2dPeQsMGce6sT0OF5e9b1Wd6lhDcTr0D8rfjnDkuAexCVtSbhiMrtD7/eHX5zPE5r9SLpS7HqOs+9GIgCE9CoimWdP3oXZXtVcW5si7N45I9d5ZxX5CAq8s1536qy3eIBCffIRJy+d8hrhHLirlHsu3g2Fzr9D0gSYQJ3w2LAgoooIACCiiggAIKKKCAAgoooIACCtRegLhbKUuz7ilCUBNwfgjoUhhWigm784Oo2Umxa3uBCJLyk8p7s582HzFiRPo4xyu9NLK9QVhZU501JTSqCyQTnK5p/zka+P8/FEqwZLfLP+fsOt5Tb/55MTzZG2+8kb9p/EwvmezT/AU3yltY1dwceZvNk4/cN/n3zjypqEwHLXT9UlNYV+ie456p6b5Jxyj0WuiYhbbLX0bCgzl4CpWUzCi0rqpl2XZw7GxCJT9BVNUxXK6AAgoooIACCiiggAIKKKCAAgoooIAC5RVo1j1FoB83blxgPgB6XVAIfDIPRXYi87iiAX7Rg4E5FQoVEhQMH9QcC0NDkYgqVJgMvl27doVWuUwBBRRQQAEFFFBAAQUUUEABBRRQQAEFFFCgwgVK3VOk2SdFKvx+sfkKKKCAAgoooIACCiiggAIKKKCAAgoooIACClSsQKmTIg6AX7G3ig1XQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUECBYgRMihSj5bYKKKCAAgoooIACCiiggAIKKKCAAgoooIACCihQsQImRSr20tlwBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUKEbApEgxWm6rgAIKKKCAAgoooIACCiiggAIKKKCAAgoooIACFStgUqRiL50NV0ABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAgWIETIoUo+W2CiiggAIKKKCAAgoooIACCiiggAIKKKCAAgooULECJkUq9tLZcAUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFChGwKRIMVpuq4ACCiiggAIKKKCAAgoooIACCiiggAIKKKCAAhUrYFKkYi+dDVdAAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQQIFiBEyKFKPltgoooIACCiiggAIKKKCAAgoooIACCiiggAIKKFCxAiZFKvbS2XAFFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRQoRsCkSDFabquAAgoooIACCiiggAIKKKCAAgoooIACCiiggAIVK2BSpGIvnQ1XQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUECBYgRMihSj5bYKKKCAAgoooIACCiiggAIKKKCAAgoooIACCihQsQImRSr20tlwBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUKEbApEgxWm6rgAIKKKCAAgoooIACCiiggAIKKKCAAgoooIACFSvQqpwtnzRpUjmrt24FFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRQoo0Dbtm1LWnuLadOmzSppjZnKWrdunfnkWwWajgAJv44dOzadE/JMFFBAAQUUUEABBRRQQAEFFFBAgQoSMDZTQRerETS10u+XSm//9OnTS3oXOHxWSbmtTAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBcolYFKkXPLWq4ACCiiggAIKKKCAAgoooIACCiiggAIKKKCAAiUVMClSUm4rU0ABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAgXIJmBQpl7z1KqCAAgoooIACCiiggAIKKKCAAgoooIACCiigQEkFTIqUlNvKFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQoFwCJkXKJW+9CiiggAIKKKCAAgoooIACCiiggAIKKKCAAgooUFIBkyIl5bYyBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUKJeASZFyyVuvAgoooIACCiiggAIKKKCAAgoooIACCiiggAIKlFTApEhJua1MAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFyiVgUqRc8targAIKKKCAAgoooIACCiiggAIKKKCAAgoooIACJRUwKVJSbitTQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUECBcgmYFCmXvPUqoIACCiiggAIKKKCAAgoooIACCiiggAIKKKBASQVMipSU28oUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFCgXAImRcolb70KKKCAAgoooIACCiiggAIKKKCAAgoooIACCihQUgGTIiXltjIFFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRQol4BJkXLJW68CCiiggAIKKKCAAgoooIACCiiggAIKKKCAAgqUVMCkSEm5rUwBBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQXKJWBSpFzy1qtAhQl8/PHH4a677gqfffZZvVs+fvz4wI9FAQUUUEABBRRQQAEFFFBAAQUUUGDeCvz000/hiSeeCCNHjpy3FXl0BSpEoKKTIh9++GHYbbfdcj8nn3xyjp11//nPf3KffVN5AoMHD47X9ne/+13Bxj/33HOhV69eYcMNNwwHHHBAeOuttwpuV+kLa3Ko6vy4///v//4vGj766KNVbVar5e+++27o0aNHePLJJ8PUqVML7lNMfVdeeWXgJ5WvvvoqvPPOO+mjrwoooIACCiiggAIKKKCAAgoooECjEahrbKaxnMAxxxwTBg4cGMaMGVNlkyr9HKs8sUa2YsaMGY2sRTU3pxLbXNNZVXRSpF27duFPf/pT+Prrr8Pmm28eDjnkkNz5XnvttWHIkCG5z74pToAA9S233BImT55c3I4NsPWXX34Zfv/734crrrgibLPNNgX/YNO+o48+Ouy///6x98Iuu+wSEyOffvppA7SgcRyiNg5VtfS+++4LW2+9dVhppZXCt99+W+/eHaNHjw5dunQJl156aVhttdXmqrbY+v72t78FflJ55plnwplnnpk++qqAAgoooIACCiiggAIKKKCAAgqUXaA+sZmyNz7TgKeeeiqceOKJ4dhjj80s/e/bcp/jzz//HO6+++5Q3wd65zqxRriAGPZrr73WCFtWfZNoM21vSqWikyILLrhg2GCDDcIiiywSg78pWHvQQQeFQYMGhQEDBsSgespm0Xtkv/32i0HdbbfdNnYbSxfz6aefDoceemi46qqr4vrtt98+vPDCC+GVV14Jv/71r8MvfvGLcN1116XN4+tDDz0UNttss9C5c+fQs2fPwNP0hUo6NkmaTTfdNGy00UZzHas2baNnBE/+33///XNVQ7t58v6ss86KwWuSCQSyU+EPDAmkTTbZJAbLL7/88jBz5sy0Or4//fTT475du3YNBx98cFh//fXDYostFreprn300Fh33XUDge2GKNS1zDLLhMceeyy2odAx//GPf8QkCNdm5ZVXju932GGHuVwL7Zu/7KKLLgr0VKiqsC4bwK9qu4ZeXhuHqup89tln4/1/xhlnhAUWWKCqzeZYzhMD3bt3D2uttVbgCYJp06bF9SRC/v73v8f7ifuK70R+Kba+q6++OvBD4fjUx/2dvW+/++678Mc//jGss8468XvDPZ7K9OnT47YPP/xw7Cm08cYbh5tvvjn2YiE5ut5664Vzzz13juv69ttvx94u3C/cK+xrUUABBRRQQAEFFFBAAQUUUEABBaoSqE9sptAx51UMiiHPGUWF2CgPyQ4bNixWT8KDWMuUKVPC4YcfHk444YS5mlXsOaaYDHHAHXfcMcaRiN9k44wvv/xy2HvvveO6I444IvA5W4i5EpshprrddtuFN954Y46HcInpduvWLcYp+/btG1Jsl2PUNh6bra8xvOcakFxo2bLywvG0mbZzDk2lVN5VqIX8cccdF4OoJDYIjBIU/vHHH8Nee+0Vg77//ve/Q+/evUOfPn1yiQyyXQwNxLb33ntvWHvttcNhhx0We5v8+c9/DnwB//KXv8QvKU3gDwDrybIyHt9WW20Vu6EVah7Hpk7+QBG4ZTiov/71rzHoz/a1advzzz8fLrvssvjHYPXVV5+rmk8++STceuutMUl02223xfMnAfT555/HbZkLYty4ceGGG26IJmw7fPjw3HEIiI8aNSo88MADgf35Q/bqq6/GhFNN7WvRokVo1apV4LUhCgmWCy64INZd1fFIxKy44opzrF5hhRXCm2++Ocey2nzgOCRXCiVGWPab3/wmvP/++7U5VINuUxuHqiokAUbvqdqW22+/PfTv3z/+cyShyD9N/llS0hB13Hd8nzp16hSXZ38VWx/3Kz8Ujr/PPvuEVVddNR5/zTXXjMv5h/rFF1+ERx55JCb0brzxxkBXTgpjYfLHmH/A3K8kNPv16xfOPvvs+L0maUZSLdtbjO8qQ63xdAR/I+hNlv2HHQ/sLwUUUEABBRRQQAEFFFBAAQUUUOD/C9QnNlMIcV7EoFLcbtlll41xEEZV4eFTEhGLLrpojLW0bt06xnkYmSW/FHuOKSZD/PTiiy+OMRtiLeeff348NA9mH3/88TEOS5yRcyYmkwoPwRIbJWny4osvhj322CPceeeduTgfMct//vOfMW7zr3/9K3zwwQe5/YuJx6b6GsMrMbCmMGw855DieY3BtT5taFWfnRvrvvTEaNu2bQzepsAwX1SWpW5i/BEYMWJETBIQ0KUsvfTSuSG4TjvttPiEOgFbhg3ihy8y+/AkPfMnkATYeeedw8ILLxyHcqrOY4klloiBWLYhuEyQnS842dAHH3ywxrZ9//33sRcEdVVV6IXgyRuNAAAd4klEQVRCcJ9C0oVEzB133BGTNyzfddddY1tZv++++8auaTvttBMfY0Ik9brgM/NHsD9/SGtqH+eTn/HlGPOyMNk3PYWyhc91yVhiQeH86a7HtaKkhAgJMnrWNMZCoi07dw7/yOaff/6im0ovI3oh8Q+J0rFjx5hAoHcF15fM/aRJk4pKtNS2ESRDeJKBnlbp+8owaAzJNXbs2NhbqUOHDmHixImx9wv3ZCo8bcA/fdp40003xX+g9N6i8ITEE088kftOv/fee+GUU04JHIsfvg8WBRRQQAEFFFBAAQUUUEABBRRQoFQC8yIGxUgYPFRKL5T55psvPjDNQ8OMuEGPC2ItxIoYbYeRNRqqkHhZbrnl4oPl1MvDrQyNTq8CYqgkZCgkRBh9h4A68R8edGaodxIjPGTNQ+c8HE3caZVVVontPu+883Jt5Zj0KiF+y3kWE49tqHOtz3E4L+J3TaUQX/vhhx9i7LCSz6lJJkUKXRD+GJA5ZZ6KVPiczdJlEw7MV0KSJLuMJ9jHjx8fdydozHwNe+65Z9h9993jK4HWqgoZ2WyhK1vKoNambfyRybYle6z0vlAdqb38cSJh8NJLL8U/IAS7swkEzmfChAnpUPF9+/bt4+fatC+3Y4neYDFr1qw5auNzTUZz7JD5kP9PiVX0EGnMCRHaeP311wd6RaTC9a3uPkzbZV/5HpCQoDtlKtxv3O90XyThUOrC93KhhRYK9A5J5aOPPorfv+x1z17vNdZYY47rz+cbZveMSoV/oEcddVTo1atXTGbSa8SigAIKKKCAAgoooIACCiiggAIKlFKgoWNQxG623HLLmBBJ50GMhxFv5mXJxiEZQYeRcog1ElMlXsOIPPTy4EFvkjKsIylCPJXhsHjIl1FfSBrQu4Q4LDEqYplMRcCINxTiQMQ1WU5ip5h47Lw8f49d2QLNJilC16z8IZ5++ctfhhT4L3QZ88d4yw4PxbGY24PhsBjC58ILL4xDbDEsT20KvRrSeHh1aVtt60iT4NCNjZ4AJGM6zR7+KM0XkY7z29/+NvYSYD4G/gDRfY2sLmVetS/VXZdXev3kD3fFZ5bXtWT/KXGtG3tChPPkfuOapcI/nmILQ0hxzbMJBo7BZzL35Sh8N/iHl/3O8Y/y5JNPjv8oC7Up//ua/5mnDuiOSe8RrjXz6/D9tSiggAIKKKCAAgoooIACCiiggAKlFGjIGBQxlHLHdHiwlUIMkcJIJMSUmKOZuaBJeqSy1FJLxbmM2YbYLHEaeossueSScR+G58rGcIkNMWQ6I4XUNx6b2lDKVx5EZ7oGelg0hUJcmYepK700m6QINyBPn/OkeCoEg+sy1FDan2GWOB4/TBLNHCVVJUXy5y5guCmCvJSGahuB7WyhDv74UJjU+qSTTgpp7EDG52NorVRI0pDVpXcA58XE2m3atImrG6p9qa6GeGWYKOY8YYikVPjMhNv1KemfEhnpxjpkVvb8FltssTi8VHZZse/5x8k/FuatSfck/7iYs4NJyctRuOfoisfwWCm5wT9F/hGmz8W2iyQL/3D5YQzKrl275rpuFnsst1dAAQUUUEABBRRQQAEFFFBAAQXqI9BQMShiNwyhlS3EeOZ1TCcbh2TkEuIuPHz+yiuvxF4dtCHFXZkbJFtoG1MSsD3D2aeh0Emg8MAvw/1nh/rKxnCLicdm6yzne5IIWGRHLCpne+paNz196vNAel3rnRf7tZwXB20Mx8wPnDI3CIkLenVQCIoy8TrB77oUAvD0rvjmm2/i7vS8YG6EqgrdxfgDQXn99dfjE+vM20FpqLbRG4SJ1elWxiTTzz77bJwbhDro0sY8HBSCy0yqni08Mc82/NH51a9+FRZffPHc6prax3h+PMH/4Ycf5vap7xsyy/wQGOd80mfaTuHaMXk8lhSuI5llhjOrb+GfUmNJiKTzrsqhqnPlH1PaFz/+efCZLouFCufMPUDXRepizEkmwqI3RW1KsfXlHzP/+8ofWb5Pabg7rjuTvF9yySX5u9bqM99PkiHpnw/nyD+j6nqK1erAbqSAAgoooIACCiiggAIKKKCAAk1aIMVXio3N1AalIWJQxO0mT54cmE+ZHhkMkT506NA4T3Bt2sA2dTnHe+65Jx6euq+55poYUyTWQnyROEwaIYf5YokdpsKDuIy4Qwxvl112CQx/ni2Y8LB2imExks1+++0XNyk2Hps9brnfk0xgVJpsr5lyt6m29dNm2t5UEiKcd0X3FCHAyXBQBGT5UjA0Dj8UgvtM8NO/f/8YOKfXAxMMHXroobHLEl9M5hZImci4UxG/mGx9mWWWiT0TODZP25999tlVHoGJgh566KE4hBVzI5AFPeigg+L2DdW27t27ByY5GjNmTBzH74wzzogTxFMJ3dBOOOGE6MMfJyZf4jPbMHlRz54946TvQ4YMiW3ClF4mAwcOjD1GqrNjTL8bZs/dwPiFqadBPEgdf1E3PQWyJX3mjybJKOaDOPXUU2PSh14uBM2ZW4NAflMptXGo6ly5vpdeemluNVl6egqRbU9jMuZWzn5z/PHHx4mvSIJwL5MsYBIssvy1KcXWl39M7t2LL7443j/Dhg2L9y33HPct7eD6Mm4k/2TrUpjci4nV+d7Ru4Y/5scee2y9e9nUpS3uo4ACCiiggAIKKKCAAgoooIAClSFQn9hMqc6Q4aiI3xHnIPbDg+CMvEEMpDalrudI/Khbt27xIekuXbqEQYMGxep40JWHmYn1EDvdYostwmmnnRZ69+4dh+tnmCyWEYukkGyiJ0Xfvn3jMuKVvGeUGHqOcH7EdynFxmPjTo3oFw+hk1yotEKbud5NqbSYnbmbc7bqEp4dwflylI8//jgOF1TbgG91beQPx5dffhmDzVVtRxc2gsbDhw+PPUt4cj/bEyO7X13bRnKDQoKDHiF0JWO8uvzCOrJ62bkaCBCT0OCp/PXXXz/uQkb34IMPDnvsscccmeWq2kfGlwmRSl1oO70b+OOZPadStyO/PiaJSomc/HWN+TPZeq49/7QaS6H3E/8EG+qPL/cLw4U1pvulsVjbDgUUUEABBRRQQAEFFFBAAQWaikClxmbq40/cjgdi07BV9TlWVfsyfzGJDx5WJ1ZDXLRQHIneJyQ88mOgt99+e3xwPCVRiJOOHDkyPrzNVACpkNyht0iheGNt4rHpOLV9rfT7pdLbz/UuZanoniJ1hVp++eXruutc+zHBTzGTW/OUenWlIdpWXXsKreMPDEkNfkgyECwmecKXKU2UlNpcVfsK/YFK+8zLV4ZdqqpN87Lepnpskg/8NKaS5rZpqDY5ZFZDSXocBRRQQAEFFFBAAQUUUEABBRRoTAKljpGRfCmUEMGEmGJ+XJHlU6ZMicO8pweseUCX4fHzt+Vh+qoeqC82Hku9FgWyAs0yKZIFKMV7MqKrr776PK2qQ4cOdT4+WV2GLjr//PNj9zQORNe0Aw88sNZd7epcuTsqoIACCiiggAIKKKCAAgoooIACCiigQEUIMPIOI83UdQQeRqZhaPftt98+PpzNA88cj6H5LQqUSqBZDp9VKlzrab4Cld5lrfleOc9cAQUUUEABBRRQQAEFFFBAAQWagoCxmaZwFUt3DpV+v1R6+0s9fFbL0t1a1qSAAgoooIACCiiggAIKKKCAAgoooIACCiiggAIKlE/ApEj57K1ZAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFSihgUqSE2FalgAIKKKCAAgoooIACCiiggAIKKKCAAgoooIAC5RMwKVI+e2tWQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUECBEgqYFCkhtlUpoIACCiiggAIKKKCAAgoooIACCiiggAIKKKBA+QRMipTP3poVUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFCghAImRUqIbVUKKKCAAgoooIACCiiggAIKKKCAAgoooIACCihQPgGTIuWzt2YFFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRQooYBJkRJiW5UCCiiggAIKKKCAAgoooIACCiiggAIKKKCAAgqUT8CkSPnsrVkBBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQVKKGBSpITYVqWAAgoooIACCiiggAIKKKCAAgoooIACCiiggALlEzApUj57a1ZAAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQQIESCpgUKSG2VSmggAIKKKCAAgoooIACCiiggAIKKKCAAgoooED5BEyKlM/emhVQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUKCEAiZFSohtVQoooIACCiiggAIKKKCAAgoooIACCiiggAIKKFA+gRbTpk2bVb7qrVkBBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUKI2APUVK42wtCiiggAIKKKCAAgoooIACCiiggAIKKKCAAgooUGYBkyJlvgBWr4ACCiiggAIKKKCAAgoooIACCiiggAIKKKCAAqURMClSGmdrUUABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAgTILmBQp8wWwegUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFCiNgEmR0jhbiwIKKKCAAgoooIACCiiggAIKKKCAAgoooIACCpRZwKRImS+A1SuggAIKKKCAAgoooIACCiiggAIKKKCAAgoooEBpBEyKlMbZWhRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUKDMAiZFynwBrF4BBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQVKI2BSpDTO1qKAAgoooIACCiiggAIKKKCAAgoooIACCiiggAJlFjApUuYLYPUKKKCAAgoooIACCiiggAIKKKCAAgoooIACCihQGgGTIqVxthYFFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRQos4BJkTJfAKtXQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUECB0giYFCmNs7UooIACCiiggAIKKKCAAgoooIACCiiggAIKKKBAmQVMipT5Ali9AgoooIACCiiggAIKKKCAAgoooIACCiiggAIKlEbApEhpnK1FAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFyixgUqTMF8DqFVBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQoDQCJkVK42wtCiiggAIKKKCAAgoooIACCiiggAIKKKCAAgooUGYBkyJlvgBWr4ACCiiggAIKKKCAAgoooIACCiiggAIKKKCAAqURMClSGmdrUUABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAgTILmBQp8wWwegUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFCiNgEmR0jhbiwIKKKCAAgoooIACCiiggAIKKKCAAgoooIACCpRZwKRImS+A1SuggAIKKKCAAgoooIACCiiggAIKKKCAAgoooEBpBEyKlMbZWhRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUKDMAiZFynwBrF4BBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQVKI2BSpDTO1qKAAgoooIACCiiggAIKKKCAAgoooIACCiiggAJlFjApUuYLYPUKKKCAAgoooIACCiiggAIKKKCAAgoooIACCihQGgGTIqVxthYFFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRQos0CzSYrcd9994fHHH6839/fffx/uvffe8P7779f7WOU4QEM5lKPt1qmAAgoooIACCiiggAIKKKCAAgoooIACCiigQH0EWkybNm1WfQ7QUPvecMMN4YEHHggLLLBAuPHGG0OrVq0a6tDxOF26dAkrrbRSePjhh+t13GHDhoXDDz887LjjjqF///5FHeuaa64Jjz322Bz7LL/88qF3795hk002mWP5vPqQ7/Dtt9+GUaNGhdVWWy106tRpXlXrcRVQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUKLtAo+kpQiLk7bffDqNHjw5PPfVU2WGqagDJi5NPPjkccsghVW1S5fJJkyaFF198MSy66KIxAbHiiiuGMWPGhP322y+MHDmyyv3m5YqPPvooHHbYYfVOFs3LNnpsBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUaQqBRJEVee+21QMLghBNOCPPPP3948MEH5zi3O+64I+yyyy7hkUceiQH8DTbYIBx66KFh+vTpue2ef/75cNBBB4UNN9wwvt522225dflv+vXrF3bffffw3Xff5VZddtllYbfddgvffPNN+Oqrr8Jxxx0XqGfdddeNdX344Ydx288++ywMHTo0PPfcc7l9L7300tC9e/ew1lprhT333DMmdnIrC7w54ogjwkUXXRQuvvji8Kc//Sn8/PPP4f77789t+eijj4YePXrEunv16hVeeuml3Lrq2kabcBo8eHBue5x69uyZ+5x9Q6+ZfffdNy4aNGhQbHtaX+w5pf18VUABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFCgsQo0iqQISZD55psv7LHHHjG5QFLgxx9/zJl9/vnn4c033wwXXnhhHF5r4YUXjsNQsR1lxowZ4cgjjwwTJ04M2223XXj33XcDiQ+SLYVK586dw7hx4+bokXL77bcHjrvYYovFhAVzb5Do2HrrrWMvjrvvvjseirpoy+TJk+Nntrv88svDsssuG9tPz4srr7yyULUFl33xxRdxefv27ePrs88+G4fnmjp1akxmvPfee2H//fcPKSlDMqWqts0eCi22bcqUKbm6JkyYEN56663c5+ybhRZaKKR6F1lkkdCmTZu4ur7nlK3D9woooIACCiiggAIKKKCAAgoooIACCiiggAIKNBaBhp24o45nRVJko402CksttVTYfvvtw5NPPhkTFltttdUcRzzggANCnz59whtvvBF23XXX8PTTT8feDSQzrr322rDyyiuHJZdcMjzzzDMxkXDPPfeEtddee45j8IH5QM4///yYWCGJ8vrrr4dPPvkkHpv1JBFIGPzjH/+Ic5uQWODYhUpKOJx++ulh4403DvQkYd/qCr0wll566TBz5sx4Di1btgxbbrll3OW6664Ls2bNCvTcWHXVVUO3bt0CPUvo/XHSSScV1bbq2sA6fJk4nuPvs88+MRnD8rqcE/tZFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRRozAJl7ylCjw2GzqKnBcNjkRCgPPTQQ3O5MSk5hUnBKePHj4+v/GKoKxIbTNj+xBNPxOWpd0X8kPnFXB5MOP7444/H+tLk5yRLKNtuu20cWoukwR/+8Ifw6aefhhYtWmSO8L+3JFUoJGsYqopETU1JEZI2JILo6UJSYuDAgTGhwnGYV4UhxG6++eZwzjnn5CZmZzmlmLbFHerwqy7nVIdq3EUBBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAgZIKlD0pkuYPYcgmeiyceeaZESB/CK2sSn6CgiGoSGDstddeYdiwYXEIqez2hd6TAGGYKZIyI0aMCOuss05YYYUV4qbMTXLqqacGhpSitwnDV1111VWFDhOTMcxHQo8UkjHMi3LwwQcX3DYtvOWWW2Lyg0QOw4TRQyYVkiSc37fffhvnTOE9c4J07do1blJM29Ixi32lXcWeU7F1uL0CCiiggAIKKKCAAgoooIACCiiggAIKKKCAAqUWaBRJkbZt28bhrBjSih96QzCnxqhRo2rlQSLkgw8+CCeeeGIcZuq8886rcb+ddtopbjN8+PCYGEm9RFhIbxWGk+K49Opo165dSHOKFDrwJptsEm699dbw6quvxuQM7WYYraoK86e0atUq9ixhm2zCpWPHjuGHH34IxxxzTJxDhXlU+vbtG+dMYdvq2oYjhXlNUmEOlLqUYs+pLnW4jwIKKKCAAgoooIACCiiggAIKKKCAAgoooIACpRQo65wi9NJ4//33Q69evcK+++6bO28SAyQr6EWS5trIrSzwpkOHDnHpyy+/HMaOHRuGDBkSJ2RnknImRV9zzTXj8FxffvllGDp0aJwQnSG4mCeE4bZ++umnkJIkP//8c0xWMLk7PT5IQpCgWWWVVQrUHGKPCub/OOqoowLtYCiwBRdcME7YXnCHzMIddtghcK70innnnXfisGAkY55//vlw/PHHh/322y8mewYMGBBuuummsOGGG1bbNnq7LLHEEjGZw3wkJEfoDbPAAgvkamWYsqxDp06d4rrnnnsuTrTOtaCXSF3PKVeRbxRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUaGQCZe0p8sADD0SObbbZZg4WeiksvvjiMVnA8FI1lc022ywwDwZzkuy9995h9dVXj0mKiRMnhpdeeinuTtKC3hnXX3997nD0Dvn666/jhOadO3eOy5n0/JBDDgn0sDj55JPDKaecEtdX1ftk9913D+xLj46jjz46fPPNN+GSSy6pcV4RKkt1kXi5+uqrY/177rln7CXC5O9MrM58Iz169IjDe6Xtq2ob6xm+i/P8y1/+EofmYv6UbMl3WGONNWLy5YUXXsj1WKnPOWXr8r0CCiiggAIKKKCAAgoooIACCiiggAIKKKCAAo1JoMW0adP+O7N5Y2pVHdtCgoNeGvzUpjCPyXHHHReTGQxRlV/oUUHPkTZt2uSvmusziQp6lNATg+REfQu9VyZPnhzat29f8HjVtW3mzJmxLQz7VZ/S0OdUn7a4rwIKKKCAAgoooIACCiiggAIKKKCAAgoooIAC9RVoUkmRYjDOOeecMHr06DhsFT1MGG7KooACCiiggAIKKKCAAgoooIACCiiggAIKKKCAAk1XoP5dGirUZsKECXGILiZ2NyFSoRfRZiuggAIKKKCAAgoooIACCiiggAIKKKCAAgooUIRAs+0pUoSRmyqggAIKKKCAAgoooIACCiiggAIKKKCAAgoooEATEGi2PUWawLXzFBRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUKAIAZMiRWC5qQIKKKCAAgoooIACCiiggAIKKKCAAgoooIACClSugEmRyr12tlwBBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQWKEDApUgSWmyqggAIKKKCAAgoooIACCiiggAIKKKCAAgoooEDlCpgUqdxrZ8sVUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFCgCAGTIkVguakCCiiggAIKKKCAAgoooIACCiiggAIKKKCAAgpUroBJkcq9drZcAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFihAwKVIElpsqoIACCiiggAIKKKCAAgoooIACCiiggAIKKKBA5QqYFKnca2fLFVBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRRQoAgBkyJFYLmpAgoooIACCiiggAIKKKCAAgoooIACCiiggAIKVK6ASZHKvXa2XAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBYoQMClSBJabKqCAAgoooIACCiiggAIKKKCAAgoooIACCiigQOUKmBSp3GtnyxVQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQUUUKAIAZMiRWC5qQIKKKCAAgoooIACCiiggAIKKKCAAgoooIACClSuQMtZs2ZVbuttuQIKKKCAAgoooIACCiiggAIKKKCAAgoooIACCihQS4GWLVq0qOWmbqaAAgoooIACCiiggAIKKKCAAgoooIACCiiggAIKVK6Aw2dV7rWz5QoooIACCiiggAIKKKCAAgoooIACCiiggAIKKFCEQCt6ipRrCK3WrVsX0VQ3VUABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAgaYkMH369JKeTuwpUq6kSEnP1MoUUEABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFCgWQu0fGHMa6FVq1bNGsGTV0ABBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAgaYv0PKMC68KP/30U3DC9aZ/sT1DBRRQQAEFFFBAAQUUUEABBRRQQAEFFFBAAQWas8B83y7U4eyvv5oatuzWteQOCyywQMnrtEIFFFBAAQUUUEABBRRQQAEFFFBAAQUUUEABBRRoHAIzZ84sWUNatmwZ5vs2LHH20y+8GqZO/TLsuPUvw88//xxYUYpiUqQUytahgAIKKKCAAgoooIACCiiggAIKKKCAAgoooEDjFChFUiTlPXj9fw4EVEe+NVZRAAAAAElFTkSuQmCC" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Screen%20Shot%202021-07-21%20at%204.52.06%20PM.png](attachment:Screen%20Shot%202021-07-21%20at%204.52.06%20PM.png)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "experiments-venv", + "language": "python", + "name": "experiments-venv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/tutorials/state_tomography.ipynb b/docs/tutorials/state_tomography.ipynb new file mode 100644 index 0000000000..5cbb6c4dee --- /dev/null +++ b/docs/tutorials/state_tomography.ipynb @@ -0,0 +1,465 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Quantum State Tomography" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit_experiments.framework import ParallelExperiment\n", + "from qiskit_experiments.library import StateTomography\n", + "\n", + "# For simulation\n", + "from qiskit.providers.aer import AerSimulator\n", + "from qiskit.test.mock import FakeParis\n", + "\n", + "# Noisy simulator backend\n", + "backend = AerSimulator.from_backend(FakeParis())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## State Tomography Experiment\n", + "\n", + "To run a state tomography experiment we initialize the experiment with a circuit to prepare the state to be measured. We can also pass in an `Operator`, or a `Statevector` to describe the preparation circuit." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FIT RESULT\n", + "\n", + "Analysis Result: StateTomography\n", + "Analysis Result ID: 95c2123e-8164-4fe2-a7c0-bbc1ccf04328\n", + "Experiment ID: a903a1ad-4535-4c28-b7c8-db5f9aec54ae\n", + "Device Components: [, ]\n", + "Quality: None\n", + "Verified: False\n", + "Result Data:\n", + "- state: DensityMatrix([[ 0.47672008+0.00000000e+00j, 0.01743136+3.38352041e-03j,\n", + " 0.02372273-1.18893984e-02j, 0.00085292-4.48489363e-01j],\n", + " [ 0.01743136-3.38352041e-03j, 0.02290845+0.00000000e+00j,\n", + " 0.00348649+5.07348117e-03j, 0.00482618+1.28395469e-03j],\n", + " [ 0.02372273+1.18893984e-02j, 0.00348649-5.07348117e-03j,\n", + " 0.03314588+0.00000000e+00j, -0.01239848-2.14036205e-02j],\n", + " [ 0.00085292+4.48489363e-01j, 0.00482618-1.28395469e-03j,\n", + " -0.01239848+2.14036205e-02j, 0.46722559-2.71050543e-20j]],\n", + " dims=(2, 2))\n", + "- fitter_metadata: {'fitter': 'linear_inversion', 'fitter_time': 0.002125263214111328}\n", + "- success: True\n", + "- state_metadata: {'eigvals': array([0.92178556, 0.04662193, 0.03159251, 0. ]), 'raw_eigvals': array([ 0.92515401, 0.04999039, 0.03496096, -0.01010536]), 'trace': 0.9999999999999997, 'positive': True, 'positive_delta': 0.0}\n", + "- state_fidelity: 0.9204621973308564\n" + ] + } + ], + "source": [ + "# Run experiments\n", + "\n", + "# GHZ State preparation circuit\n", + "nq = 2\n", + "qc_ghz = qiskit.QuantumCircuit(nq)\n", + "qc_ghz.h(0)\n", + "qc_ghz.s(0)\n", + "for i in range(1, nq):\n", + " qc_ghz.cx(0, i)\n", + "\n", + "# QST Experiment\n", + "qstexp1 = StateTomography(qc_ghz)\n", + "qstdata1 = qstexp1.run(backend, seed_simulation=100).block_for_results()\n", + "qstresult = qstdata1.analysis_results(0)\n", + "\n", + "print('FIT RESULT')\n", + "print(qstresult)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tomography Results\n", + "\n", + "The main results for tomography are the fitted state, which is stored in the `\"state\"` key as a `DensityMatrix` object:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DensityMatrix([[ 0.47672008+0.00000000e+00j, 0.01743136+3.38352041e-03j,\n", + " 0.02372273-1.18893984e-02j, 0.00085292-4.48489363e-01j],\n", + " [ 0.01743136-3.38352041e-03j, 0.02290845+0.00000000e+00j,\n", + " 0.00348649+5.07348117e-03j, 0.00482618+1.28395469e-03j],\n", + " [ 0.02372273+1.18893984e-02j, 0.00348649-5.07348117e-03j,\n", + " 0.03314588+0.00000000e+00j, -0.01239848-2.14036205e-02j],\n", + " [ 0.00085292+4.48489363e-01j, 0.00482618-1.28395469e-03j,\n", + " -0.01239848+2.14036205e-02j, 0.46722559-2.71050543e-20j]],\n", + " dims=(2, 2))\n" + ] + } + ], + "source": [ + "print(qstresult.data()[\"state\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The state fidelity of the fitted state with the ideal state prepared by the input circuit is stored in the `\"state_fidelity\"` result field. Note that if the input circuit contained any measurements the ideal state cannot be automatically generated and this field will be set to `None`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "State Fidelity = 0.92046\n" + ] + } + ], + "source": [ + "print(\"State Fidelity = {:.5f}\".format(qstresult.data()[\"state_fidelity\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Additional state metadata\n", + "\n", + "Additional data is stored in the tomography under the `\"state_metadata\"` field. This includes\n", + "- `eigvals`: the eigenvalues of the fitted state\n", + "- `trace`: the trace of the fitted state\n", + "- `positive`: Whether the eigenvalues are all non-negative\n", + "- `positive_delta`: the deviation from positivity given by 1-norm of negative eigenvalues.\n", + "\n", + "If trace rescaling was performed this dictionary will also contain a `raw_trace` field containing the trace before rescaling.\n", + "Futhermore, if the state was rescaled to be positive or trace 1 an additional field `raw_eigvals` will contain the state eigenvalues before rescaling was performed." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pretty printing has been turned OFF\n" + ] + } + ], + "source": [ + "pprint(qstresult.data()[\"state_metadata\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To see the effect of rescaling we can perform a \"bad\" fit with very low counts" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8686814149289035\n", + "- eigvals: [0.92074124 0.07925876 0. 0. ]\n", + "- raw_eigvals: [ 1.00806592 0.16658344 0.07029948 -0.24494884]\n", + "- trace: 1.0000000000000049\n", + "- positive: True\n", + "- positive_delta: 0.0\n" + ] + } + ], + "source": [ + "# QST Experiment\n", + "bad_data = qstexp1.run(backend, shots=10, seed_simulation=100).block_for_results()\n", + "bad_result = bad_data.analysis_results(0)\n", + "\n", + "print(bad_result.data()[\"state_fidelity\"])\n", + "for key, val in bad_result.data()[\"state_metadata\"].items():\n", + " print(f'- {key}: {val}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tomography Fitters\n", + "\n", + "The default fitters is `linear_inversion`, which reconstructs the state using *dual basis* of the tomography basis. This will typically result in a non-postive reconstructed state. This state is rescaled to be postive-semidfinite (PSD) by computing its eigen-decomposition and rescaling its eigenvalues using the approach from *J Smolin, JM Gambetta, G Smith, Phys. Rev. Lett. 108, 070502 (2012), [open access](https://arxiv.org/abs/arXiv:1106.5458).\n", + "\n", + "There are several other fitters are included (See API documentation for details). For example if `cvxpy` is installed we can use the `cvxpy_gaussian_lstsq` fitter which allows constraining the fit to be PSD without requiring rescaling." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FIT RESULT\n", + "\n", + "Analysis Result: StateTomography\n", + "Analysis Result ID: ce355bf5-8b51-401f-ac79-786cbb28c266\n", + "Experiment ID: a903a1ad-4535-4c28-b7c8-db5f9aec54ae\n", + "Device Components: [, ]\n", + "Quality: None\n", + "Verified: False\n", + "Result Data:\n", + "- state: DensityMatrix([[ 0.47635077+0.00000000e+00j, 0.01748862+3.89240856e-03j,\n", + " 0.02422926-1.18500323e-02j, 0.0008573 -4.47804563e-01j],\n", + " [ 0.01748862-3.89240856e-03j, 0.02291869+0.00000000e+00j,\n", + " 0.00348893+5.05709989e-03j, 0.00532333+1.37176137e-03j],\n", + " [ 0.02422926+1.18500323e-02j, 0.00348893-5.05709989e-03j,\n", + " 0.03382784-8.67361738e-19j, -0.01236219-2.08270256e-02j],\n", + " [ 0.0008573 +4.47804563e-01j, 0.00532333-1.37176137e-03j,\n", + " -0.01236219+2.08270256e-02j, 0.46690269+2.71050543e-20j]],\n", + " dims=(2, 2))\n", + "- fitter_metadata: {'cvxpy_solver': 'CVXOPT', 'cvxpy_status': 'optimal', 'fitter': 'cvxpy_linear_lstsq', 'fitter_time': 0.04554319381713867}\n", + "- success: True\n", + "- state_metadata: {'eigvals': array([9.20753015e-01, 4.72726011e-02, 3.19743598e-02, 2.41266305e-08]), 'raw_eigvals': array([9.22144103e-01, 4.73440213e-02, 3.20226672e-02, 2.41630814e-08]), 'trace': 1.0000000000000002, 'raw_trace': 1.0015108160829784, 'positive': True, 'positive_delta': 0.0}\n", + "- state_fidelity: 0.9194312965227169\n" + ] + } + ], + "source": [ + "qstexp1.run_analysis(qstdata1, fitter='cvxpy_linear_lstsq')\n", + "qstresult2 = qstdata1.analysis_results(-1)\n", + "\n", + "print('FIT RESULT')\n", + "print(qstresult2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parallel Tomography Experiment\n", + "\n", + "We can also use the `qiskit_experiments.ParallelExperiment` class to run subsystem tomography on multiple qubits in parallel.\n", + "\n", + "For example if we want to perform 1-qubit QST on several qubits at once:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Analysis Result: ParallelExperiment\n", + "Analysis Result ID: 04a4fb78-fbf5-4705-9032-77b81a85b019\n", + "Experiment ID: b761f6c3-f280-4cbe-bfc5-a9a78270697c\n", + "Device Components: [, , , , ]\n", + "Quality: None\n", + "Verified: False\n", + "Result Data:\n", + "- experiment_types: ['StateTomography', 'StateTomography', 'StateTomography', 'StateTomography', 'StateTomography']\n", + "- experiment_ids: ['d79b01b2-d62a-4eed-ae57-efdab09f46d7', 'e4a8c99b-62bd-45c4-8506-8c28a5a91b2a', '451a1368-15c1-4194-b3b4-c7c0a0e5cc23', '81636e00-bbef-4ca1-802d-c1b55f414110', '80dd68ce-390e-479f-8542-07fe6c21427a']\n", + "- experiment_qubits: [(0,), (1,), (2,), (3,), (4,)]\n", + "- success: True\n" + ] + } + ], + "source": [ + "from math import pi\n", + "num_qubits = 5\n", + "gates = [qiskit.circuit.library.RXGate(i * pi / (num_qubits - 1))\n", + " for i in range(num_qubits)]\n", + "\n", + "subexps = [\n", + " StateTomography(gate, qubits=[i])\n", + " for i, gate in enumerate(gates)\n", + "]\n", + "parexp = ParallelExperiment(subexps)\n", + "pardata = parexp.run(backend, seed_simulation=100).block_for_results()\n", + "print(pardata.analysis_results(-1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "View component experiment analysis results" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "PARALLEL EXP 0: FIT RESULT\n", + "\n", + "Analysis Result: StateTomography\n", + "Analysis Result ID: 5db46640-4a02-4c78-aa82-d0cb8be8e4dc\n", + "Experiment ID: d79b01b2-d62a-4eed-ae57-efdab09f46d7\n", + "Device Components: []\n", + "Quality: None\n", + "Verified: False\n", + "Result Data:\n", + "- state: DensityMatrix([[0.98144531+0.j , 0.00878906-0.03417969j],\n", + " [0.00878906+0.03417969j, 0.01855469+0.j ]],\n", + " dims=(2,))\n", + "- fitter_metadata: {'fitter': 'linear_inversion', 'fitter_time': 0.00010895729064941406}\n", + "- success: True\n", + "- state_metadata: {'eigvals': array([0.98273708, 0.01726292]), 'trace': 1.0000000000000002, 'positive': True, 'positive_delta': 0.0}\n", + "- state_fidelity: 0.9814453125\n", + "\n", + "PARALLEL EXP 1: FIT RESULT\n", + "\n", + "Analysis Result: StateTomography\n", + "Analysis Result ID: 911eeebb-139e-42d8-b9ba-785cc49fbac0\n", + "Experiment ID: e4a8c99b-62bd-45c4-8506-8c28a5a91b2a\n", + "Device Components: []\n", + "Quality: None\n", + "Verified: False\n", + "Result Data:\n", + "- state: DensityMatrix([[0.85644531+0.j , 0.015625 +0.33496094j],\n", + " [0.015625 -0.33496094j, 0.14355469+0.j ]],\n", + " dims=(2,))\n", + "- fitter_metadata: {'fitter': 'linear_inversion', 'fitter_time': 8.511543273925781e-05}\n", + "- success: True\n", + "- state_metadata: {'eigvals': array([0.98938352, 0.01061648]), 'trace': 0.9999999999999999, 'positive': True, 'positive_delta': 0.0}\n", + "- state_fidelity: 0.9888980479297614\n", + "\n", + "PARALLEL EXP 2: FIT RESULT\n", + "\n", + "Analysis Result: StateTomography\n", + "Analysis Result ID: a1b9436d-e63a-4cb6-b9f5-a38b11875fde\n", + "Experiment ID: 451a1368-15c1-4194-b3b4-c7c0a0e5cc23\n", + "Device Components: []\n", + "Quality: None\n", + "Verified: False\n", + "Result Data:\n", + "- state: DensityMatrix([[ 0.4921875 +0.j , -0.00585938+0.47070313j],\n", + " [-0.00585938-0.47070313j, 0.5078125 +0.j ]],\n", + " dims=(2,))\n", + "- fitter_metadata: {'fitter': 'linear_inversion', 'fitter_time': 0.00010514259338378906}\n", + "- success: True\n", + "- state_metadata: {'eigvals': array([0.97080442, 0.02919558]), 'trace': 1.0, 'positive': True, 'positive_delta': 0.0}\n", + "- state_fidelity: 0.9707031249999997\n", + "\n", + "PARALLEL EXP 3: FIT RESULT\n", + "\n", + "Analysis Result: StateTomography\n", + "Analysis Result ID: 29425f7d-0a50-4a99-a0a0-d45dd9115ba1\n", + "Experiment ID: 81636e00-bbef-4ca1-802d-c1b55f414110\n", + "Device Components: []\n", + "Quality: None\n", + "Verified: False\n", + "Result Data:\n", + "- state: DensityMatrix([[0.17578125+0.j , 0.01269531+0.31542969j],\n", + " [0.01269531-0.31542969j, 0.82421875+0.j ]],\n", + " dims=(2,))\n", + "- fitter_metadata: {'fitter': 'linear_inversion', 'fitter_time': 9.799003601074219e-05}\n", + "- success: True\n", + "- state_metadata: {'eigvals': array([0.95252056, 0.04747944]), 'trace': 1.0, 'positive': True, 'positive_delta': 0.0}\n", + "- state_fidelity: 0.9522997477316296\n", + "\n", + "PARALLEL EXP 4: FIT RESULT\n", + "\n", + "Analysis Result: StateTomography\n", + "Analysis Result ID: 49bdcc86-c1cd-494d-94e3-336ff3f19f2a\n", + "Experiment ID: 80dd68ce-390e-479f-8542-07fe6c21427a\n", + "Device Components: []\n", + "Quality: None\n", + "Verified: False\n", + "Result Data:\n", + "- state: DensityMatrix([[0.01953125+0.j , 0.01074219-0.0234375j],\n", + " [0.01074219+0.0234375j, 0.98046875+0.j ]],\n", + " dims=(2,))\n", + "- fitter_metadata: {'fitter': 'linear_inversion', 'fitter_time': 9.965896606445312e-05}\n", + "- success: True\n", + "- state_metadata: {'eigvals': array([0.98115998, 0.01884002]), 'trace': 0.9999999999999997, 'positive': True, 'positive_delta': 0.0}\n", + "- state_fidelity: 0.9804687499999988\n" + ] + } + ], + "source": [ + "for i in range(parexp.num_experiments):\n", + " expdata = pardata.component_experiment_data(i)\n", + " result = expdata.analysis_results(-1)\n", + " \n", + " print(f'\\nPARALLEL EXP {i}: FIT RESULT')\n", + " print(result)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "c45f46a7fd077198472649b02925a2e599779de14e258f4f9ba8eb1d4e684fd2" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/qiskit_experiments/calibration_management/calibrations.py b/qiskit_experiments/calibration_management/calibrations.py index cb9cb786be..3adf7770c8 100644 --- a/qiskit_experiments/calibration_management/calibrations.py +++ b/qiskit_experiments/calibration_management/calibrations.py @@ -14,7 +14,7 @@ import os from collections import defaultdict -from datetime import datetime +from datetime import datetime, timezone from typing import Any, Dict, Set, Tuple, Union, List, Optional import csv import dataclasses @@ -380,7 +380,7 @@ def add_parameter_value( qubits = self._to_tuple(qubits) if isinstance(value, (int, float, complex)): - value = ParameterValue(value, datetime.now()) + value = ParameterValue(value, datetime.now(timezone.utc)) param_name = param.name if isinstance(param, Parameter) else param sched_name = schedule.name if isinstance(schedule, ScheduleBlock) else schedule diff --git a/qiskit_experiments/calibration_management/update_library.py b/qiskit_experiments/calibration_management/update_library.py index 44f6052178..393106f3fd 100644 --- a/qiskit_experiments/calibration_management/update_library.py +++ b/qiskit_experiments/calibration_management/update_library.py @@ -13,7 +13,7 @@ """A library of experiment calibrations.""" from abc import ABC -from datetime import datetime +from datetime import datetime, timezone from typing import List, Optional, Tuple, Union import numpy as np @@ -58,7 +58,7 @@ def _time_stamp(exp_data: ExperimentData) -> datetime: if all_times: return max(all_times) - return datetime.now() + return datetime.now(timezone.utc) @classmethod def _add_parameter_value( diff --git a/qiskit_experiments/curve_analysis/curve_analysis.py b/qiskit_experiments/curve_analysis/curve_analysis.py index a31a4d5a43..d43029201d 100644 --- a/qiskit_experiments/curve_analysis/curve_analysis.py +++ b/qiskit_experiments/curve_analysis/curve_analysis.py @@ -17,6 +17,7 @@ import dataclasses import inspect +from abc import ABC import functools from typing import Any, Dict, List, Tuple, Callable, Union, Optional @@ -41,7 +42,7 @@ from qiskit_experiments.curve_analysis.utils import get_opt_value, get_opt_error -class CurveAnalysis(BaseAnalysis): +class CurveAnalysis(BaseAnalysis, ABC): """A base class for curve fit type analysis. The subclasses can override class attributes to define the behavior of @@ -270,48 +271,29 @@ def __init__(self): setattr(self, f"__{key}", None) @classmethod - def _default_options(cls): + def _default_options(cls) -> Options: """Return default analysis options. - Options: - curve_fitter: A callback function to perform fitting with formatted data. - This function should have signature: - - .. code-block:: - - def curve_fitter( - funcs: List[Callable], - series: ndarray, - xdata: ndarray, - ydata: ndarray, - p0: ndarray, - sigma: Optional[ndarray], - weights: Optional[ndarray], - bounds: Optional[ - Union[Dict[str, Tuple[float, float]], Tuple[ndarray, ndarray]] - ], - ) -> CurveAnalysisResultData: - - See :func:`~qiskit_experiment.curve_analysis.multi_curve_fit` for example. - data_processor: A callback function to format experiment data. - This function should have signature: - - .. code-block:: - - def data_processor(data: Dict[str, Any]) -> Tuple[float, float] - - This can be a :class:`~qiskit_experiment.data_processing.DataProcessor` + Analysis Options: + curve_fitter (Callable): A callback function to perform fitting with formatted data. + See :func:`~qiskit_experiments.analysis.multi_curve_fit` for example. + data_processor (Callable): A callback function to format experiment data. + This can be a :class:`~qiskit_experiments.data_processing.DataProcessor` instance that defines the `self.__call__` method. - normalization: Set ``True`` to normalize y values within range [-1, 1]. - p0: Array-like or dictionary of initial parameters. - bounds: Array-like or dictionary of (min, max) tuple of fit parameter boundaries. - x_key: Circuit metadata key representing a scanned value. - plot: Set ``True`` to create figure for fit result. - axis: Optional. A matplotlib axis object to draw. - xlabel: X label of fit result figure. - ylabel: Y label of fit result figure. - fit_reports: Mapping of fit parameters and representation in the fit report. - return_data_points: Set ``True`` to return formatted XY data. + normalization (bool) : Set ``True`` to normalize y values within range [-1, 1]. + p0 (Dict[str, float]): Array-like or dictionary + of initial parameters. + bounds (Dict[str, Tuple[float, float]]): Array-like or dictionary + of (min, max) tuple of fit parameter boundaries. + x_key (str): Circuit metadata key representing a scanned value. + plot (bool): Set ``True`` to create figure for fit result. + axis (AxesSubplot): Optional. A matplotlib axis object to draw. + xlabel (str): X label of fit result figure. + ylabel (str): Y label of fit result figure. + ylim (Tuple[float, float]): Min and max height limit of fit plot. + fit_reports (Dict[str, str]): Mapping of fit parameters and representation + in the fit report. + return_data_points (bool): Set ``True`` to return formatted XY data. """ return Options( curve_fitter=multi_curve_fit, diff --git a/qiskit_experiments/curve_analysis/curve_fit.py b/qiskit_experiments/curve_analysis/curve_fit.py index 41d654e308..13045c21e2 100644 --- a/qiskit_experiments/curve_analysis/curve_fit.py +++ b/qiskit_experiments/curve_analysis/curve_fit.py @@ -85,7 +85,7 @@ def curve_fit( upper = [bounds[key][1] for key in param_keys] param_bounds = (lower, upper) else: - param_bounds = None + param_bounds = ([-np.inf] * len(param_keys), [np.inf] * len(param_keys)) # Convert fit function def fit_func(x, *params): @@ -94,7 +94,10 @@ def fit_func(x, *params): else: param_keys = None param_p0 = p0 - param_bounds = bounds + if bounds: + param_bounds = bounds + else: + param_bounds = ([-np.inf] * len(p0), [np.inf] * len(p0)) fit_func = func # Check the degrees of freedom is greater than 0 diff --git a/qiskit_experiments/database_service/utils.py b/qiskit_experiments/database_service/utils.py index 8c0322f382..ad78e7e271 100644 --- a/qiskit_experiments/database_service/utils.py +++ b/qiskit_experiments/database_service/utils.py @@ -86,7 +86,9 @@ def plot_to_svg_bytes(figure: "pyplot.Figure") -> bytes: buf = io.BytesIO() opaque_color = list(figure.get_facecolor()) opaque_color[3] = 1.0 # set alpha to opaque - figure.savefig(buf, format="svg", facecolor=tuple(opaque_color), edgecolor="none") + figure.savefig( + buf, format="svg", facecolor=tuple(opaque_color), edgecolor="none", bbox_inches="tight" + ) buf.seek(0) figure_data = buf.read() buf.close() diff --git a/qiskit_experiments/library/characterization/t1_analysis.py b/qiskit_experiments/library/characterization/t1_analysis.py index 12103883c3..d7addafccc 100644 --- a/qiskit_experiments/library/characterization/t1_analysis.py +++ b/qiskit_experiments/library/characterization/t1_analysis.py @@ -47,11 +47,6 @@ class T1Analysis(BaseAnalysis): - :math:`amplitude\_guess`: Determined by :math:`(y_0 - offset\_guess)` - :math:`offset\_guess`: Determined by the last :math:`y` - :math:`t1\_guess`: Determined by the mean of the data points - - Bounds - - :math:`amplitude\_bounds`: [0, 1] - - :math:`offset\_bounds`: [0, 1] - - :math:`t1\_bounds`: [0, infinity] """ @classmethod @@ -60,9 +55,6 @@ def _default_options(cls): t1_guess=None, amplitude_guess=None, offset_guess=None, - t1_bounds=None, - amplitude_bounds=None, - offset_bounds=None, ) # pylint: disable=arguments-differ @@ -72,9 +64,6 @@ def _run_analysis( t1_guess=None, amplitude_guess=None, offset_guess=None, - t1_bounds=None, - amplitude_bounds=None, - offset_bounds=None, plot=True, ax=None, ) -> Tuple[List[CurveAnalysisResultData], List["matplotlib.figure.Figure"]]: @@ -87,11 +76,6 @@ def _run_analysis( amplitude_guess (float): Optional, an initial guess of the coefficient of the exponent offset_guess (float): Optional, an initial guess of the offset - t1_bounds (list of two floats): Optional, lower bound and upper bound to T1 - amplitude_bounds (list of two floats): Optional, lower bound and upper - bound to the amplitude - offset_bounds (list of two floats): Optional, lower bound and upper - bound to the offset plot (bool): Generator plot of exponential fit. ax (AxesSubplot): Optional, axes to add figure to. @@ -120,20 +104,13 @@ def _run_analysis( offset_guess = ydata[-1] if amplitude_guess is None: amplitude_guess = ydata[0] - offset_guess - if t1_bounds is None: - t1_bounds = [0, np.inf] - if amplitude_bounds is None: - amplitude_bounds = [0, 1] - if offset_bounds is None: - offset_bounds = [0, 1] # Perform fit def fit_fun(x, a, tau, c): return a * np.exp(-x / tau) + c init = {"a": amplitude_guess, "tau": t1_guess, "c": offset_guess} - bounds = {"a": amplitude_bounds, "tau": t1_bounds, "c": offset_bounds} - fit_result = curve_fit(fit_fun, xdata, ydata, init, sigma=sigma, bounds=bounds) + fit_result = curve_fit(fit_fun, xdata, ydata, init, sigma=sigma) result_data = { "value": fit_result["popt"][1], diff --git a/qiskit_experiments/test/utils.py b/qiskit_experiments/test/utils.py index 7d94822ed2..297e737d86 100644 --- a/qiskit_experiments/test/utils.py +++ b/qiskit_experiments/test/utils.py @@ -14,7 +14,7 @@ import uuid from typing import Optional, Union, Dict -from datetime import datetime +from datetime import datetime, timezone import time from qiskit.providers.job import JobV1 as Job @@ -45,7 +45,7 @@ def submit(self): @staticmethod def time_per_step() -> Dict[str, datetime]: """Return the completion time.""" - return {"COMPLETED": datetime.now()} + return {"COMPLETED": datetime.now(timezone.utc)} def status(self) -> JobStatus: """Return the status of the job, among the values of ``JobStatus``.""" diff --git a/requirements-dev.txt b/requirements-dev.txt index cd0c8eb3a5..10ab15adf9 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -10,6 +10,7 @@ pygments>=2.4 reno>=3.2.0 sphinx-panels nbsphinx +arxiv ddt~=1.4.2 qiskit-aer>=0.8.0 diff --git a/requirements.txt b/requirements.txt index 9fa126e95f..4e9bd895db 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,3 @@ numpy>=1.17 scipy>=1.4 -qiskit-terra>=0.16.0 +qiskit-terra>=0.18.0 diff --git a/setup.py b/setup.py index 3b173d8b45..46f7639f3b 100755 --- a/setup.py +++ b/setup.py @@ -52,7 +52,6 @@ "Operating System :: MacOS", "Operating System :: POSIX :: Linux", "Programming Language :: Python :: 3 :: Only", - "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", @@ -62,7 +61,7 @@ packages=find_packages(exclude=['test*']), install_requires=REQUIREMENTS, include_package_data=True, - python_requires=">=3.6", + python_requires=">=3.7", project_urls={ "Bug Tracker": "https://github.com/Qiskit/qiskit-experiments/issues", "Documentation": "https://qiskit.org/documentation/", diff --git a/test/test_t1.py b/test/test_t1.py index 0227a576b2..68f81e7f19 100644 --- a/test/test_t1.py +++ b/test/test_t1.py @@ -87,9 +87,9 @@ def test_t1_parallel_different_analysis_options(self): delays = list(range(1, 40, 3)) exp0 = T1(0, delays) - exp0.set_analysis_options(t1_bounds=[10, 30]) + exp0.set_analysis_options(t1_guess=30) exp1 = T1(1, delays) - exp1.set_analysis_options(t1_bounds=[100, 200]) + exp1.set_analysis_options(t1_guess=1000000) par_exp = ParallelExperiment([exp0, exp1]) res = par_exp.run(T1Backend([t1, t1])) @@ -101,7 +101,7 @@ def test_t1_parallel_different_analysis_options(self): self.assertEqual(sub_res[0].quality, "good") self.assertAlmostEqual(sub_res[0].data()["value"], t1, delta=3) - self.assertFalse(sub_res[1].data()["success"]) + self.assertEqual(sub_res[1].quality, "bad") def test_t1_analysis(self): """ diff --git a/tox.ini b/tox.ini index aa69e4a514..4253440351 100644 --- a/tox.ini +++ b/tox.ini @@ -11,7 +11,6 @@ setenv = QISKIT_SUPPRESS_PACKAGING_WARNINGS=Y deps = -r{toxinidir}/requirements-dev.txt - git+https://github.com/Qiskit/qiskit-terra commands = stestr run {posargs} [testenv:lint]