From e8507607ec5fb5d53ce967cba66215e88388302b Mon Sep 17 00:00:00 2001 From: Vyron Vasileiadis Date: Wed, 2 Sep 2026 03:39:45 +0300 Subject: [PATCH 1/9] Carry a swept variable's label and units onto the result coordinate The executor took a variable's id when it built an axis and dropped everything else, so every result coordinate arrived with an empty attrs dict. A program that declared label="Drive amplitude", units="V" had both strings sitting on the Variable and no way to reach them from the result. Each axis now carries the attributes alongside its coords, and _finalize writes them onto the matching coordinate of every field array. The keys are long_name and units, which is what xarray's own plotting accessor reads, so result.get(m0).sel(IQ="I").plot() labels its x axis rather than falling back to the variable id. A key the variable did not declare is left out instead of written as None, which xarray would render. The array's own attrs and name are untouched: a measurement has no unit the executor knows, and the y axis of a readout plot is physics. Three doc passages said otherwise and move with it: variables.md listed the executor and the result objects among the things that ignore units, rabi.md explained that the axis label had to be typed out by hand, and the array contract in measurements.md said nothing about coordinate attributes. --- changelog/34.added.md | 1 + docs/examples/rabi.md | 13 +++++--- docs/guide/measurements.md | 4 +++ docs/guide/variables.md | 6 ++-- src/qprogram/executor.py | 61 +++++++++++++++++++++++++++++++++-- tests/test_executor.py | 66 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 142 insertions(+), 9 deletions(-) create mode 100644 changelog/34.added.md diff --git a/changelog/34.added.md b/changelog/34.added.md new file mode 100644 index 0000000..d4145da --- /dev/null +++ b/changelog/34.added.md @@ -0,0 +1 @@ +A swept variable's `label` and `units` now reach the result. The executor writes them onto that variable's coordinate as the `long_name` and `units` attributes, which is what xarray's own plotting reads, so `result.get(m0).sel(IQ="I").plot()` labels its x axis instead of falling back to the variable id. diff --git a/docs/examples/rabi.md b/docs/examples/rabi.md index f9451be..71d7b71 100644 --- a/docs/examples/rabi.md +++ b/docs/examples/rabi.md @@ -233,10 +233,15 @@ plt.legend() ![Readout response against drive amplitude. I rises to a maximum of 1 at 0.5 V and falls back to 0 by 1.0 V, while Q stays flat at 0.](../assets/plots/rabi-light.png#only-light) ![Readout response against drive amplitude. I rises to a maximum of 1 at 0.5 V and falls back to 0 by 1.0 V, while Q stays flat at 0.](../assets/plots/rabi-dark.png#only-dark) -The axis label is written out here rather than read from the variable. The -`label` and `units` given to `program.variable` travel with the program into -`.qp` and are there for tooling and for whoever reads the file; the executor -does not copy them onto the xarray coordinate. +The axis label is written out here, but it does not have to be. The `label` and +`units` given to `program.variable` reach the coordinate as its `long_name` and +`units` attributes, so `data.coords["gain"].attrs` holds both and anything that +reads them labels the axis itself: + +```python +data.coords["gain"].attrs # {"long_name": "Drive amplitude", "units": "V"} +data.sel(IQ="I").plot() # x axis reads "Drive amplitude [V]" +``` ## Adapting it diff --git a/docs/guide/measurements.md b/docs/guide/measurements.md index 02832c0..38c9f3e 100644 --- a/docs/guide/measurements.md +++ b/docs/guide/measurements.md @@ -395,6 +395,10 @@ values as its coordinate. The trailing dimensions belong to the field: `"IQ"` with coordinates `["I", "Q"]` for `iq`, `"time"` with an integer coordinate for `raw`, and nothing for `state`. The full order is `(*sweeps, *field dims)`. +A sweep coordinate also carries whatever `label` and `units` its variable +declared, as the `long_name` and `units` attributes. The field dimensions carry +none: neither comes from a variable. + ```python program = qp.QProgram(label="spectroscopy", schema=schema) freq = program.variable("freq", units="Hz") diff --git a/docs/guide/variables.md b/docs/guide/variables.md index 6516872..78a62b5 100644 --- a/docs/guide/variables.md +++ b/docs/guide/variables.md @@ -95,8 +95,10 @@ phi = program.variable( All three are free-form strings and none of them affects execution. They are written into the `var` line of a `.qp` file, parsed back from it, and carried across fragment expansion when a fragment-local variable is renamed onto the -host program. Nothing else reads them: validation, the capability token -vocabulary, the executor, and the result objects all ignore `units`. +host program. `label` and `units` travel one step further: the executor writes +them onto the swept coordinate of every result array, as the `long_name` and +`units` attributes that xarray's own plotting reads. Validation and the +capability token vocabulary ignore all three, and nothing reads `description`. That means `units="ns"` records what the numbers mean and converts nothing. A variable swept over `Range(0, 200, 4)` and passed to `wait` carries diff --git a/src/qprogram/executor.py b/src/qprogram/executor.py index 15d62f1..1aadc8a 100644 --- a/src/qprogram/executor.py +++ b/src/qprogram/executor.py @@ -22,6 +22,8 @@ - dims = enclosing ``Sweep`` blocks, outermost first, named by variable id; ``Parallel`` contributes one shared ``"a|b"`` dim carrying every composed variable's coords. +- A swept variable's ``label`` and ``units`` reach its coordinate as the ``long_name`` and + ``units`` attributes, the two keys xarray's plotting accessor reads. - ``average(shots)`` contributes **no** dim — ``iq``/``raw`` are means over shots, ``state`` averages to the excited-state population. - Measurement-field shapes: ``iq`` → ``(*sweeps, "IQ"[2])``; ``state`` → ``(*sweeps)``; @@ -225,6 +227,9 @@ class _Axis: size (int): Number of points along the dimension. coords (dict[str, numpy.ndarray]): Coordinate name to values. One entry for a plain sweep; a parallel composition attaches one per composed variable, all on the shared dimension. + attrs (dict[str, dict[str, str]]): Coordinate name to the xarray attributes carrying that + variable's presentation metadata. Keyed the same way as ``coords``; a variable that + declared neither a label nor units maps to an empty dict. """ # Sweep | Parallel @@ -233,6 +238,29 @@ class _Axis: size: int # coord name -> values (Parallel attaches one per variable) coords: dict[str, np.ndarray] + # coord name -> {"long_name": ..., "units": ...} + attrs: dict[str, dict[str, str]] = field(default_factory=dict) + + +def _coord_attrs(variable: Variable) -> dict[str, str]: + """Map a swept variable's label and units onto xarray coordinate attributes. + + ``long_name`` and ``units`` are the two keys xarray's own plotting accessor reads, so a + coordinate carrying them labels itself. A key the variable did not declare is left out rather + than written as ``None``, which xarray would render. + + Args: + variable (Variable): The variable the sweep binds. + + Returns: + The attributes for that variable's coordinate, empty when it declared neither. + """ + attrs: dict[str, str] = {} + if variable.label is not None: + attrs["long_name"] = variable.label + if variable.units is not None: + attrs["units"] = variable.units + return attrs def _axis_for(node: Block) -> _Axis | None: @@ -249,10 +277,17 @@ def _axis_for(node: Block) -> _Axis | None: dim = "|".join(lp.variable.id for lp in node.loops) size = node.loops[0].num_iterations() coords = {lp.variable.id: lp.source.values() for lp in node.loops} - return _Axis(node=node, dim=dim, size=size, coords=coords) + attrs = {lp.variable.id: _coord_attrs(lp.variable) for lp in node.loops} + return _Axis(node=node, dim=dim, size=size, coords=coords, attrs=attrs) if isinstance(node, Sweep): values = node.source.values() - return _Axis(node=node, dim=node.variable.id, size=len(values), coords={node.variable.id: values}) + return _Axis( + node=node, + dim=node.variable.id, + size=len(values), + coords={node.variable.id: values}, + attrs={node.variable.id: _coord_attrs(node.variable)}, + ) # Average / Conditional / plain Block contribute no dimension return None @@ -570,12 +605,16 @@ def _finalize(self) -> QProgramResult: for slot in self._slots: dims = [axis.dim for axis in slot.axes] coords: dict[str, object] = {} + coord_attrs: dict[str, dict[str, str]] = {} for axis in slot.axes: for name, values in axis.coords.items(): coords[name] = (axis.dim, values) if name != axis.dim else values + coord_attrs.update({name: attrs for name, attrs in axis.attrs.items() if attrs}) fields: dict[str, xr.DataArray] = {} for field_name in slot.op.fields: - fields[field_name] = self._field_array(slot, field_name, dims, coords) + array = self._field_array(slot, field_name, dims, coords) + _apply_coord_attrs(array, coord_attrs) + fields[field_name] = array # ``iq`` is the primary whenever requested; otherwise the first field in canonical # order (see MeasurementField's declaration order). primary = fields.get(MeasurementField.IQ, fields[slot.op.fields[0]]) @@ -620,6 +659,22 @@ def _field_array( return xr.DataArray(mean, dims=dims, coords=coords) +def _apply_coord_attrs(array: xr.DataArray, coord_attrs: dict[str, dict[str, str]]) -> None: + """Write each swept variable's attributes onto the matching coordinate of ``array``, in place. + + Only coordinates the array actually carries are touched, so a field with no sweep dimensions, + such as ``state`` on an unswept measurement, is left alone. ``IQ`` and ``time`` never appear + here: neither comes from a variable. + + Args: + array (xarray.DataArray): The field array to annotate. + coord_attrs (dict[str, dict[str, str]]): Coordinate name to its attributes. + """ + for name, attrs in coord_attrs.items(): + if name in array.coords: + array.coords[name].attrs.update(attrs) + + def _safe_mean(total: np.ndarray, count: np.ndarray) -> np.ndarray: """Divide ``total`` by ``count``, leaving NaN where ``count`` is zero. diff --git a/tests/test_executor.py b/tests/test_executor.py index 879495e..b8e8632 100644 --- a/tests/test_executor.py +++ b/tests/test_executor.py @@ -91,6 +91,72 @@ def test_parallel_loops_share_one_dimension_with_both_coords(): assert np.allclose(da.coords["b"].values, [10.0, 15.0, 20.0]) +def test_swept_variable_label_and_units_reach_the_coordinate(): + p = QProgram() + gain = p.variable("gain", label="Drive amplitude", units="V") + with p.sweep(gain, Range(0.0, 1.0, 0.5)): + p.measure("readout_q0", _ro(), "w") + da = simulate(p).get("m0") + assert da.coords["gain"].attrs == {"long_name": "Drive amplitude", "units": "V"} + + +@pytest.mark.parametrize( + ("kwargs", "expected"), + [ + ({}, {}), + ({"label": "Delay"}, {"long_name": "Delay"}), + ({"units": "ns"}, {"units": "ns"}), + ], +) +def test_coordinate_attrs_omit_what_the_variable_did_not_declare(kwargs, expected): + p = QProgram() + t = p.variable("t", **kwargs) + with p.sweep(t, Range(0.0, 1.0, 0.5)): + p.measure("readout_q0", _ro(), "w") + da = simulate(p).get("m0") + assert da.coords["t"].attrs == expected + + +def test_parallel_composition_labels_each_composed_coordinate(): + p = QProgram() + a = p.variable("a", label="Gain", units="V") + b = p.variable("b", label="Frequency", units="Hz") + with p.sweep(a, Range(0.0, 1.0, 0.5)) | p.sweep(b, Range(10.0, 20.0, 5.0)): + p.measure("readout_q0", _ro(), "w") + da = simulate(p).get("m0") + assert da.coords["a"].attrs == {"long_name": "Gain", "units": "V"} + assert da.coords["b"].attrs == {"long_name": "Frequency", "units": "Hz"} + # The joined dim is not itself a coordinate, so there is nothing to annotate on it. + assert "a|b" not in da.coords + + +def test_only_variable_coordinates_are_annotated(): + model = MockMeasurementModel(raw_samples=8) + p = QProgram() + g = p.variable("g", label="Gain", units="V") + with p.sweep(g, Range(0.0, 1.0, 0.5)): + p.measure("readout_q0", _ro(), "w", fields=("iq", "state", "raw")) + result = simulate(p, model=model) + raw = result.get("m0", field="raw") + assert raw.coords["g"].attrs == {"long_name": "Gain", "units": "V"} + assert raw.coords["IQ"].attrs == {} + assert raw.coords["time"].attrs == {} + # Every field carries the annotation, not just the primary one. + assert result.get("m0", field="state").coords["g"].attrs == {"long_name": "Gain", "units": "V"} + # The array itself is left alone: a measurement has no unit the executor knows. + assert raw.attrs == {} + + +def test_coordinate_attrs_survive_a_qp_round_trip(): + p = QProgram() + freq = p.variable("freq", label="Drive frequency", units="Hz") + with p.sweep(freq, Range(4e9, 5e9, 0.5e9)): + p.measure("readout_q0", _ro(), "w") + reloaded = qp.loads(qp.dumps(p)) + da = simulate(reloaded).get("m0") + assert da.coords["freq"].attrs == {"long_name": "Drive frequency", "units": "Hz"} + + def test_no_loop_measurement_is_scalar(): p = QProgram() p.measure("readout_q0", _ro(), "w", fields=("iq", "state")) From 60de981ed56db1ba86af02e5292deb4d3c498b15 Mon Sep 17 00:00:00 2001 From: Vyron Vasileiadis Date: Wed, 2 Sep 2026 04:05:51 +0300 Subject: [PATCH 2/9] Draw a result with result.plot(), behind a pluggable renderer A QProgramResult handed back a bare DataArray and the docs told you to write matplotlib. xarray's own .plot() does not fill the gap: a measurement array carries a trailing IQ dimension, so a 1-D sweep looks two-dimensional and comes back as a heatmap with IQ on the x axis. result.plot() looks the array up the way get() does and works the figure out from its shape. Every dimension but IQ is a plot dimension, time included, so a raw trace draws against time; one of them gives a line per quadrature, two give a heatmap, and kind="scatter" puts I against Q, which no dimension count implies. channels= says what to make of the quadratures, x= and y= which coordinate goes on which axis, and value_label= names the measured quantity, which is the one label nothing in the result knows. An argument that cannot choose anything for the kind in hand raises rather than being ignored. A dimension built by a parallel composition is the case worth the error. It carries one coordinate per composed variable and coords["a|b"] answers with a plain integer range rather than failing, so guessing would produce a wrong axis that looks entirely plausible. x= is required there. The drawing sits behind a renderer resolved by name, registered the way register_sweep_source registers a sweep source. build_figure returns a Figure of Line, Points and Mesh marks holding numpy arrays and two axis labels, and knows nothing about colour or canvas; Style and Theme are frozen dataclasses, so a palette of your own is a constructor call and a variant is one replace(). Only matplotlib_renderer imports a plotting library, and it is imported the first time something is drawn, so import qprogram still pulls in numpy and xarray and nothing else. The guide gains a page for it, and three example pages drop the matplotlib they had been hand-rolling. Qubit spectroscopy keeps its own, because its figure reads in gigahertz and rescaling a coordinate is arithmetic on the array; single-shot readout keeps its own, because two colours and a threshold line are a layout, not something the result implies. A result gets no _repr_html_ for the same reason: a waveform is one shape with one picture, a result holds every measurement of a run and they need not share a shape. --- changelog/35.added.md | 1 + docs/developer/architecture.md | 19 +- docs/examples/cz-chevron.md | 20 +- docs/examples/qubit-spectroscopy.md | 5 + docs/examples/rabi.md | 26 +- docs/examples/single-shot-readout.md | 6 + docs/getting-started.md | 17 +- docs/guide/execution.md | 5 +- docs/guide/index.md | 1 + docs/guide/measurements.md | 5 + docs/guide/plotting.md | 189 +++++ docs/reference/api-qprogram.md | 58 +- src/qprogram/plotting/__init__.py | 65 ++ src/qprogram/plotting/build.py | 494 ++++++++++++++ src/qprogram/plotting/matplotlib_renderer.py | 190 ++++++ src/qprogram/plotting/model.py | 107 +++ src/qprogram/plotting/renderers.py | 121 ++++ src/qprogram/plotting/theme.py | 114 ++++ src/qprogram/result.py | 88 ++- tests/test_plotting.py | 684 +++++++++++++++++++ zensical.toml | 1 + 21 files changed, 2171 insertions(+), 45 deletions(-) create mode 100644 changelog/35.added.md create mode 100644 docs/guide/plotting.md create mode 100644 src/qprogram/plotting/__init__.py create mode 100644 src/qprogram/plotting/build.py create mode 100644 src/qprogram/plotting/matplotlib_renderer.py create mode 100644 src/qprogram/plotting/model.py create mode 100644 src/qprogram/plotting/renderers.py create mode 100644 src/qprogram/plotting/theme.py create mode 100644 tests/test_plotting.py diff --git a/changelog/35.added.md b/changelog/35.added.md new file mode 100644 index 0000000..0635a05 --- /dev/null +++ b/changelog/35.added.md @@ -0,0 +1 @@ +`QProgramResult.plot` draws a measurement. The array is looked up the way `get` looks it up, and its shape chooses the figure: one dimension besides `IQ` gives a line per quadrature, two give a heatmap, and `kind="scatter"` puts I against Q. `channels=` says what to make of the quadratures, `x=` and `y=` which coordinate goes on which axis, and a swept variable's `label` and `units` reach the axis on their own. The drawing sits behind a renderer registered by name, so matplotlib is one implementation rather than the only one: `qp.plotting.build_figure` describes a figure using numpy and xarray alone, and `qp.plotting.Style` and `Theme` are frozen dataclasses a light or dark palette of your own replaces. diff --git a/docs/developer/architecture.md b/docs/developer/architecture.md index e33a3b4..d5d79cb 100644 --- a/docs/developer/architecture.md +++ b/docs/developer/architecture.md @@ -47,6 +47,7 @@ qprogram/ ├── optimization.py # optimize(): plan-improving program rewrites ├── executor.py # ReferencePlatform + simulate(): the reference interpreter ├── lsp.py # check_text(), the check|explain|serve CLI, the language server + ├── plotting/ # the figure model, the themes, and the renderer registry ├── operations/ # one module per leaf op, plus the Operation base ├── blocks/ # Block, Sweep, Average, Parallel, Conditional ├── sweeps/ # SweepSource contract, built-in sources, combinators @@ -102,13 +103,17 @@ plain string everywhere downstream. The rest of the AST layer is supporting structure. `fragments.py` holds `Fragment`, `Parameter`, and the `expand_program` lowering that inlines every call site. `result.py` holds `MeasurementHandle`, `MeasurementResult`, and -`QProgramResult`. `waveform_library.py` resolves a waveform alias per bus and -owns the `.wfl` text format, which is deliberately not part of a `.qp` file: -calibration state travels alongside a program, not inside it. `errors.py` -defines the whole exception hierarchy under `QProgramError`, including the -platform-side classes that core QProgram never raises but every backend shares. -`_reserved.py` holds `RESERVED_KEYWORDS`, and `_structural.py` the two equality -helpers described below. +`QProgramResult`. `plotting/` is what `QProgramResult.plot` runs: `build.py` +turns a result array into the `Figure` description in `model.py`, and a +renderer registered in `renderers.py` draws it. Only `matplotlib_renderer.py` +imports a plotting library, and it is imported on first use, which is what +keeps `matplotlib` optional. `waveform_library.py` resolves a waveform alias +per bus and owns the `.wfl` text format, which is deliberately not part of a +`.qp` file: calibration state travels alongside a program, not inside it. +`errors.py` defines the whole exception hierarchy under `QProgramError`, +including the platform-side classes that core QProgram never raises but every +backend shares. `_reserved.py` holds `RESERVED_KEYWORDS`, and `_structural.py` +the two equality helpers described below. Analysis sits above the AST. `protocol.py` defines what a platform declares: `PlatformCapabilities` (per-bus profiles plus one platform-wide profile), diff --git a/docs/examples/cz-chevron.md b/docs/examples/cz-chevron.md index 3b2c082..16ceff0 100644 --- a/docs/examples/cz-chevron.md +++ b/docs/examples/cz-chevron.md @@ -188,24 +188,22 @@ shot count it recorded there. A grid point holds `NaN` when that count is zero, which happens only for a measurement inside a conditional arm the program never selected at that point. -To plot the chevron, pick the IQ component you want; the array is already on -the grid, so no reshaping is needed: +Two swept dimensions besides `IQ` give a heatmap, and the array is already on +the grid, so no reshaping is needed. A heatmap colours one surface, so name the +quadrature you want; leaving `channels` out takes the magnitude instead: ```python -import matplotlib.pyplot as plt - -plt.pcolormesh(data0.coords["dur"], data0.coords["amp"], data0.sel(IQ="I")) -plt.xlabel("Flux duration (ns)") -plt.ylabel("Flux amplitude (V)") +result.plot(m0, channels="i", value_label="Population transferred") ``` ![Heatmap of transferred population against flux duration and amplitude, with interference fringes converging to a chevron tip at 0.5 V.](../assets/plots/cz-chevron-light.png#only-light) ![Heatmap of transferred population against flux duration and amplitude, with interference fringes converging to a chevron tip at 0.5 V.](../assets/plots/cz-chevron-dark.png#only-dark) -`pcolormesh` takes the x axis first, so the inner sweep goes first and the -outer one second, the opposite of the dimension order in `data0.dims`. -matplotlib is not a runtime dependency; it comes with the `viz` extra, -installed with `pip install "qprogram[viz]"`. +The inner sweep runs along the x axis and the outer one up the y axis, matching +the loop nesting rather than the dimension order in `data0.dims`; `x=` and `y=` +say otherwise. matplotlib is not a runtime dependency; it comes with the `viz` +extra, installed with `pip install "qprogram[viz]"`. +[Plotting results](../guide/plotting.md) covers the rest. ## Adapting it diff --git a/docs/examples/qubit-spectroscopy.md b/docs/examples/qubit-spectroscopy.md index 82882d3..57e3651 100644 --- a/docs/examples/qubit-spectroscopy.md +++ b/docs/examples/qubit-spectroscopy.md @@ -180,6 +180,11 @@ which is what `.values` is for; handing it the labelled array raises data dimensions, ndim=0`. matplotlib is not a runtime dependency; it comes with the `viz` extra, installed with `pip install "qprogram[viz]"`. +`result.plot(m0, channels="magnitude")` draws the same curve without the four +lines above. The code is written out here because the figure reads in +gigahertz, and rescaling a coordinate is arithmetic on the array rather than +anything the result knows about. + ## Adapting it The scan above is the coarse one. Once it has put `f01` near 5 GHz, the next diff --git a/docs/examples/rabi.md b/docs/examples/rabi.md index 71d7b71..22be77d 100644 --- a/docs/examples/rabi.md +++ b/docs/examples/rabi.md @@ -218,31 +218,31 @@ It comes with the `viz` extra: pip install "qprogram[viz]" ``` -The `IQ` dimension is a coordinate, so the two quadratures come out by label: +`result.plot` works the figure out from the array's shape. One swept dimension +besides `IQ` gives a line per quadrature: ```python -import matplotlib.pyplot as plt - -data = result.get(m0) -plt.plot(data.coords["gain"], data.sel(IQ="I"), label="I") -plt.plot(data.coords["gain"], data.sel(IQ="Q"), label="Q") -plt.xlabel("Drive amplitude (V)") -plt.legend() +result.plot(m0, value_label="Readout response") ``` ![Readout response against drive amplitude. I rises to a maximum of 1 at 0.5 V and falls back to 0 by 1.0 V, while Q stays flat at 0.](../assets/plots/rabi-light.png#only-light) ![Readout response against drive amplitude. I rises to a maximum of 1 at 0.5 V and falls back to 0 by 1.0 V, while Q stays flat at 0.](../assets/plots/rabi-dark.png#only-dark) -The axis label is written out here, but it does not have to be. The `label` and -`units` given to `program.variable` reach the coordinate as its `long_name` and -`units` attributes, so `data.coords["gain"].attrs` holds both and anything that -reads them labels the axis itself: +Nothing about the x axis is typed out. The `label` and `units` given to +`program.variable` reach the coordinate as its `long_name` and `units` +attributes, and the axis reads them: ```python data.coords["gain"].attrs # {"long_name": "Drive amplitude", "units": "V"} -data.sel(IQ="I").plot() # x axis reads "Drive amplitude [V]" ``` +`value_label` is there because the other axis has no such source: what a +demodulated point means is the readout chain's business, not the program's. The +call returns the matplotlib `Axes`, so anything else the figure does not decide +is a method away on it. [Plotting results](../guide/plotting.md) has the rest: +heatmaps and scatters, the `channels` argument, themes, and registering a +renderer of your own. + ## Adapting it For a chip that is not a fixed-frequency transmon, change the schema. The diff --git a/docs/examples/single-shot-readout.md b/docs/examples/single-shot-readout.md index 19db9f2..a1ff848 100644 --- a/docs/examples/single-shot-readout.md +++ b/docs/examples/single-shot-readout.md @@ -201,6 +201,12 @@ plt.legend() ![Scatter of single shots in the IQ plane: two well-separated gaussian blobs for the ground and excited preparations, split by a threshold at I = 2.](../assets/plots/single-shot-readout-light.png#only-light) ![Scatter of single shots in the IQ plane: two well-separated gaussian blobs for the ground and excited preparations, split by a threshold at I = 2.](../assets/plots/single-shot-readout-dark.png#only-dark) +`result.plot(shots, kind="scatter")` draws the same plane in one call, but as a +single cloud: two colours by prepared state and a line at the threshold are a +layout, and nothing on the result says those three things belong in one figure. +[Plotting results](../guide/plotting.md) draws the line between what `plot` +infers and what stays here. + Four thousand shots run in well under a tenth of a second, so this is the cheapest program in the section despite having the most records. The combination to be careful with is not the shot count but the shot count times diff --git a/docs/getting-started.md b/docs/getting-started.md index 357e7ca..f6ae2fd 100644 --- a/docs/getting-started.md +++ b/docs/getting-started.md @@ -18,19 +18,20 @@ pip install "qprogram[viz]" # matplotlib >= 3.10.9 pip install "qprogram[lsp]" # pygls >= 2, < 3 ``` -The `viz` extra is what `Waveform.plot()` and `IQWaveform.plot()` need, and -`lsp` is what `python -m qprogram.lsp serve` needs. Both packages are imported -inside the call that uses them, so a missing extra raises -`ModuleNotFoundError` at that call rather than breaking `import qprogram`; the -language server catches that error and re-raises it naming the extra to -install, while `plot()` lets Python's own message through. The other two -language-server front-ends, `python -m qprogram.lsp check` and +The `viz` extra is what `QProgramResult.plot()`, `Waveform.plot()`, and +`IQWaveform.plot()` need, and `lsp` is what `python -m qprogram.lsp serve` +needs. Both packages are imported inside the call that uses them, so a missing +extra raises `ModuleNotFoundError` at that call rather than breaking +`import qprogram`; the language server catches that error and re-raises it +naming the extra to install, while `plot()` lets Python's own message through. +The other two language-server front-ends, `python -m qprogram.lsp check` and `python -m qprogram.lsp explain`, need no extra at all: they run the parser and validator the base install already carries, which is why an editor integration can spawn them directly. The base install covers the AST, expressions, sweep sources, waveforms, bus -schemas, serialization, validation, and the reference platform. +schemas, serialization, validation, the reference platform, and the half of +plotting that describes a figure without drawing it. Vendor-specific operations come from separate packages that follow the protocol described in [Building a vendor extension](developer/vendor-extensions.md). diff --git a/docs/guide/execution.md b/docs/guide/execution.md index d29dda3..da44c35 100644 --- a/docs/guide/execution.md +++ b/docs/guide/execution.md @@ -52,9 +52,12 @@ with p.average(1000), p.sweep(g, qp.Range(0.0, 1.0, 0.01)): result = qp.simulate(p, model=model) da = result.get("m0") # dims ("g", "IQ"), coords from the sweep -da.sel(IQ="I").plot() # a noisy Rabi oscillation (needs matplotlib, the `viz` extra) +result.plot("m0") # a noisy Rabi oscillation (needs matplotlib, the `viz` extra) ``` +`plot` takes the same arguments `get` does and draws what it finds, choosing +the figure from the array's shape. [Plotting results](plotting.md) covers it. + `simulate` raises rather than returning a partial result. A program that validation rejects raises `UnsupportedOperationError`, an operation whose expression references a variable no enclosing loop binds raises diff --git a/docs/guide/index.md b/docs/guide/index.md index 9a9b1fa..bd8b491 100644 --- a/docs/guide/index.md +++ b/docs/guide/index.md @@ -18,6 +18,7 @@ where they are used. | [Measurements and results](measurements.md) | The `measure` signature and its `fields` argument, how names are allocated and how they survive a `.qp` round trip, and `QProgramResult` access by handle, by name, and by index, with the dimensions a result carries. | | [Capabilities, diagnostics, and profiles](capabilities.md) | `PlatformCapabilities`, the routing that decides which slot checks a node, the ten diagnostic codes and what produces each, the `ExecutionPlan` and `explain()`, numeric limits, predicates, and `Profile` bundles. | | [Running programs](execution.md) | `qp.simulate` and `ReferencePlatform`: the result shapes a run produces, measurement models and the mock default, what the reference executor does not model, and what implementing `PlatformProtocol` involves. | +| [Plotting results](plotting.md) | `QProgramResult.plot`: the figure a result's shape asks for, the `channels` argument that decides what becomes of the `IQ` dimension, where an axis label comes from, the `Style` and `Theme` dataclasses, and registering a renderer of your own. | | [Saving and loading](serialization.md) | `dumps`, `loads`, `save`, and `load`: what the round trip preserves and what it drops, the format version and `require` lines, vendor activation at parse time, the normalizations the writer applies, and the `WaveformLibrary` that quoted aliases resolve through, with its own `.wfl` file. | Two worked programs, each given in full from the builder calls to the result diff --git a/docs/guide/measurements.md b/docs/guide/measurements.md index 38c9f3e..5c32999 100644 --- a/docs/guide/measurements.md +++ b/docs/guide/measurements.md @@ -387,6 +387,11 @@ primary array lives. result.measurements[0].data # the "iq" field if requested, else the first in canonical order ``` +`result.plot` takes the same measurement, `bus`, and `field` arguments and +draws the array rather than returning it, working the figure out from the +dimensions below. [Plotting results](plotting.md) covers what it makes of each +shape. + ## Result dimensions The dimensions of every returned array are the enclosing `sweep` blocks, diff --git a/docs/guide/plotting.md b/docs/guide/plotting.md new file mode 100644 index 0000000..c8ba83c --- /dev/null +++ b/docs/guide/plotting.md @@ -0,0 +1,189 @@ +# Plotting results + +`QProgramResult.plot` draws one measurement. It looks the array up exactly the +way `get` does, works out what kind of figure its shape asks for, and hands the +drawing to a renderer: + +```python +result = qp.simulate(program) + +result.plot(m0) # a line per quadrature +result.plot(m0, channels="magnitude") # hypot(I, Q) +result.plot(m0, field="state") # the classified outcome +``` + +The default renderer is matplotlib, which comes with the `viz` extra and is +imported the first time something is drawn, so `import qprogram` never pulls in +a plotting library. It returns the `Axes` it drew on, which is the point: a +figure is a starting position, not a finished picture, and everything the call +does not decide is one method away on the object that comes back. + +```python +ax = result.plot(m0) +ax.axvline(0.5, linestyle="--") +ax.set_ylabel("Readout response") +``` + +Behind that call are two halves that never meet. `qp.plotting.build_figure` +reads the array and returns a `Figure`: marks holding numpy arrays, two axis +labels, and nothing about colour or canvas. A renderer takes that figure and a +`Style` and draws it. The seam is what lets a second backend exist, and what +lets a test check the shape of a figure without a display attached. + +## What the shape decides + +Every dimension except `IQ` is a plot dimension. `IQ` is the one that never +becomes an axis: it holds the two quadratures of a single measured point, so it +becomes the series of a line figure or the two axes of a scatter. `time` is an +ordinary plot dimension, which is why a raw trace draws against it. + +| Plot dimensions | Figure | Example | +|-----------------|-----------------|---------------------------------------------| +| one | lines | a Rabi sweep, `("gain", "IQ")` | +| two | a heatmap | a chevron, `("amp", "dur", "IQ")` | +| none | `ValidationError` | an unswept measurement, `("IQ",)` | +| three or more | `ValidationError` | select one down with `data.sel()` first | + +`kind=` overrides the inference, and `kind="scatter"` is the one shape that is +never inferred: plotting I against Q is a choice no dimension count implies. It +puts I on one axis and Q on the other and flattens every other dimension into +the cloud. + +```python +result.plot(shots, kind="scatter") +``` + +Its axes are settled by what they are, so `x`, `y`, and `channels` all raise +there rather than being quietly ignored. `y` raises on a line figure for the +same reason: only a heatmap has a second dimension to put on an axis. + +## The two quadratures + +`channels=` says what to make of the `IQ` dimension. + +| `channels` | What is drawn | +|---------------|-----------------------------------------------------| +| `"iq"` | one line per quadrature, labeled `I` and `Q` | +| `"i"`, `"q"` | that quadrature alone | +| `"magnitude"` | `hypot(I, Q)`, the reading a rotation cannot change | +| `"phase"` | `arctan2(Q, I)`, in radians | + +A line figure takes both quadratures by default, since that is the pair the +measurement produced. A heatmap colours one surface and has to reduce them, so +it takes the magnitude instead; `channels="iq"` on a heatmap raises rather than +picking a quadrature for you. An array with no `IQ` dimension, a `state` field +for instance, is already one number per point and rejects `channels` outright. + +## Axis labels and which axis is which + +An axis labels itself from the coordinate. A variable declared with a `label` +and `units` carries both onto its coordinate, and the axis reads +`Drive amplitude (V)` with nothing typed out: + +```python +gain = program.variable("gain", label="Drive amplitude", units="V") +``` + +Without a label the axis falls back to the variable id, and without units it is +the label alone. +[Variables and expressions](variables.md#label-units-and-description) has what +the two strings are and where else they travel. + +The other axis is the measured quantity, and there the result has less to go +on: a demodulated point is whatever the readout chain makes of it, and no unit +follows from the program. It is labeled from the channel by default, `Signal` +for a pair of quadratures and `Magnitude` for their hypotenuse, and +`value_label=` says what it really is. On a heatmap the same string labels the +colour bar. + +```python +result.plot(m0, value_label="Readout response") +``` + +For a heatmap the innermost sweep runs along the x axis and the outermost up +the y axis, matching the loop nesting: the variable that changes fastest goes +left to right. `x=` and `y=` override that, and naming one settles the other: + +```python +result.plot(m0) # x is "dur", the inner sweep +result.plot(m0, x="amp") # x is "amp", so "dur" moves to y +``` + +A dimension built by a parallel composition is the case where the default has +no answer. It composes several variables onto one dimension and carries one +coordinate per variable, so there is no single set of values to put on the +axis. Asking anyway raises, because the alternative is worse: `coords["a|b"]` +returns a plain integer range rather than failing, so a guess would produce a +wrong axis that looks entirely plausible. + +```python +result.plot(m0) # ValidationError: 'a|b' composes 2 swept variables +result.plot(m0, x="a") # that variable's values, and its label +result.plot(m0, x="a|b") # the sweep index, if that is what you meant +``` + +## Themes + +A `Style` is a palette plus the handful of settings that decide how heavy the +marks are. Two themes ship, `qp.plotting.LIGHT` and `qp.plotting.DARK`, and +both are frozen dataclasses, so a variant is one `dataclasses.replace` away and +a palette of your own is a constructor call. + +```python +from dataclasses import replace + +import qprogram as qp + +result.plot(m0, style=qp.plotting.Style(theme=qp.plotting.DARK)) +result.plot(m0, style=qp.plotting.Style(markers=True, legend=False)) + +house = replace(qp.plotting.LIGHT, series=("#3b6ea5", "#c1554a")) +result.plot(m0, style=qp.plotting.Style(theme=house)) +``` + +`Style` carries `size`, `linewidth`, `markers`, `markersize`, `point_size`, +`point_alpha`, `grid`, `legend`, and `colorbar` alongside `theme`. `markers` is +worth turning on for a coarse sweep, where the points are the measurement and +the line between them is interpolation. + +## Another renderer + +A renderer is any callable taking a figure, a `Style`, and a surface to draw +on. Registering one works the way `register_sweep_source` works: one name, one +implementation, and a different object under a name already taken raises. + +```python +import qprogram as qp +from qprogram.plotting import Line, register_renderer + + +def to_text(figure, style, target=None): + """Print a figure instead of drawing it.""" + print(f"{figure.x_label} against {figure.y_label}") + for mark in figure.marks: + if isinstance(mark, Line): + print(f" {mark.label or 'series'}: {len(mark.x)} points") + + +register_renderer("text", to_text) +result.plot(m0, renderer="text") +``` + +`build_figure` is the half worth reading first when writing one. It returns a +`Figure` holding `Line`, `Points`, and `Mesh` marks, each a small frozen +dataclass of numpy arrays, and a renderer dispatches on their types. Nothing in +that half imports a plotting library, so a renderer for any backend reads the +same description. + +## What it does not draw + +`plot` returns composable axes rather than trying to be the whole figure. A +layout of several panels, a fit drawn over the data, an annotation pointing at +a peak: none of those follow from anything the result knows, and all of them +are ordinary calls on the axes that come back. The example pages that build one +keep their own plotting code for exactly that reason. + +A result does not draw itself in a Jupyter cell the way a waveform does. A +waveform is one shape and has one picture; a result holds every measurement of +a run, and they need not share a field, a shape, or an axis. `repr` stays the +list of what is in there, and `plot` draws the one you name. diff --git a/docs/reference/api-qprogram.md b/docs/reference/api-qprogram.md index 7d740ae..ceadc3b 100644 --- a/docs/reference/api-qprogram.md +++ b/docs/reference/api-qprogram.md @@ -11,9 +11,10 @@ dotted path, so another page can link to a single member: The supported surface is `qprogram.__all__`, the names that resolve directly on the package after `import qprogram as qp`. Three other kinds of name appear -here under a longer dotted path. The waveform, operation, and block classes -live in submodules the top level does not re-export, so they are written -`qp.waveforms.Gaussian`, `qp.operations.Play`, and `qp.blocks.Sweep`. A few +here under a longer dotted path. The waveform, operation, block, and plotting +classes live in submodules the top level does not re-export, so they are +written `qp.waveforms.Gaussian`, `qp.operations.Play`, `qp.blocks.Sweep`, and +`qp.plotting.Style`. A few names the top level does re-export are grouped with the submodule that defines them instead, because they read better next to related material: `Call` and `MeasurementField` sit with the rest of `qprogram.operations`, `UNASSIGNED` and @@ -448,6 +449,57 @@ compared, hashed, and serialized in. options: show_root_full_path: false +## Plotting + +`QProgramResult.plot` above is the front door. It runs `build_figure` to +describe the figure and a renderer to draw it, and the two halves are separate +so that a backend other than matplotlib is possible: everything down to +`Renderer` reads numpy and xarray only. See +[Plotting results](../guide/plotting.md) for the walkthrough. These names live +in `qprogram.plotting`, which the top level does not re-export. + +::: qprogram.plotting.build_figure + +::: qprogram.plotting.Figure + options: + show_root_full_path: false + +::: qprogram.plotting.Line + options: + show_root_full_path: false + +::: qprogram.plotting.Points + options: + show_root_full_path: false + +::: qprogram.plotting.Mesh + options: + show_root_full_path: false + +::: qprogram.plotting.Style + options: + show_root_full_path: false + +::: qprogram.plotting.Theme + options: + show_root_full_path: false + +::: qprogram.plotting.LIGHT + +::: qprogram.plotting.DARK + +::: qprogram.plotting.Renderer + options: + show_root_full_path: false + +::: qprogram.plotting.register_renderer + +::: qprogram.plotting.resolve_renderer + +::: qprogram.plotting.available_renderers + +::: qprogram.plotting.matplotlib_renderer.render + ## Vendor protocol A vendor extension groups its operations as methods on a `VendorNamespace` diff --git a/src/qprogram/plotting/__init__.py b/src/qprogram/plotting/__init__.py new file mode 100644 index 0000000..e17c08c --- /dev/null +++ b/src/qprogram/plotting/__init__.py @@ -0,0 +1,65 @@ +# Copyright 2026 Qilimanjaro Quantum Tech +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Plotting for results, in two halves that never meet. + +[`build_figure`][qprogram.plotting.build_figure] reads a measurement array and returns a +[`Figure`][qprogram.plotting.Figure]: marks holding numpy arrays, two axis labels, nothing about colour or canvas. +A [`Renderer`][qprogram.plotting.Renderer] takes that figure and a [`Style`][qprogram.plotting.Style] and draws it. +The seam is what lets a second backend exist, and what lets a test check the shape of a figure with +no display attached. + +[`QProgramResult.plot`][qprogram.QProgramResult.plot] is the front door and runs both halves:: + + result = qp.simulate(program) + result.plot(m0) # a line per quadrature, kind inferred + result.plot(m0, channels="magnitude") # hypot(I, Q) + result.plot(m0, x="freq", style=Style(theme=DARK)) + +Only the drawing half needs matplotlib, which ships in the ``viz`` extra and is imported the first +time a figure is rendered. +""" + +from __future__ import annotations + +from qprogram.plotting.build import CHANNELS, IQ_DIM, KINDS, build_figure +from qprogram.plotting.model import Figure, Line, Mark, Mesh, Points +from qprogram.plotting.renderers import ( + DEFAULT_RENDERER, + Renderer, + available_renderers, + register_renderer, + resolve_renderer, +) +from qprogram.plotting.theme import DARK, LIGHT, Style, Theme + +__all__ = [ + "CHANNELS", + "DARK", + "DEFAULT_RENDERER", + "IQ_DIM", + "KINDS", + "LIGHT", + "Figure", + "Line", + "Mark", + "Mesh", + "Points", + "Renderer", + "Style", + "Theme", + "available_renderers", + "build_figure", + "register_renderer", + "resolve_renderer", +] diff --git a/src/qprogram/plotting/build.py b/src/qprogram/plotting/build.py new file mode 100644 index 0000000..c0c0ce1 --- /dev/null +++ b/src/qprogram/plotting/build.py @@ -0,0 +1,494 @@ +# Copyright 2026 Qilimanjaro Quantum Tech +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Turning a result array into a [`Figure`][qprogram.plotting.Figure]. + +This is the whole of the reasoning about *what* to draw, and it uses numpy and xarray only. It reads +the dimensions the executor gave the array, decides which of them is an axis and which is a series, +pulls the axis labels off the coordinate attributes a swept variable left there, and hands back a +figure a renderer can draw without knowing any of it. + +The ``"IQ"`` dimension is the one that is never an axis. It carries the two quadratures of a single +measured point, so it becomes the series of a line figure, the two axes of a scatter, or a single +derived surface for a heatmap — see the ``channels`` argument. Every other dimension, ``"time"`` +included, is a plot dimension, which is what makes a raw trace plot against time on its own. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, cast + +import numpy as np + +from qprogram.errors import ValidationError +from qprogram.plotting.model import Figure, Line, Mesh, Points + +if TYPE_CHECKING: + import xarray as xr + + from qprogram.plotting.model import Mark + +IQ_DIM = "IQ" +"""The dimension carrying the in-phase and quadrature halves of one measured point.""" + +KINDS = ("line", "heatmap", "scatter") +"""The figure shapes [`build_figure`][qprogram.plotting.build_figure] knows how to build.""" + +CHANNELS = ("iq", "i", "q", "magnitude", "phase") +"""The ways the ``"IQ"`` dimension can be turned into something plottable.""" + +# Channel name -> the label for the measured quantity, when the array itself carries none. +_CHANNEL_LABELS = { + "iq": "Signal", + "i": "I", + "q": "Q", + "magnitude": "Magnitude", + "phase": "Phase (rad)", +} + + +def build_figure( # ruff: ignore[too-many-arguments] # every argument is one decision about the figure + data: xr.DataArray, + *, + kind: str | None = None, + x: str | None = None, + y: str | None = None, + channels: str | None = None, + value_label: str | None = None, + title: str | None = None, +) -> Figure: + """Describe the figure that ``data`` should be drawn as. + + Args: + data (xarray.DataArray): A measurement field array, as + [`QProgramResult.get`][qprogram.QProgramResult.get] returns it. Any array with at most one + ``"IQ"`` dimension works. + kind (str | None): One of `KINDS`. ``None`` infers it from the shape: one plot + dimension gives ``"line"``, two give ``"heatmap"``. ``"scatter"`` is never inferred — + plotting I against Q is a choice no shape implies. + x (str | None): Dimension or coordinate to put on the x axis. Required when the dimension + composes several swept variables, since it holds one coordinate per variable and no + preference between them. + y (str | None): The same for the y axis of a ``"heatmap"``. The two arguments name different + dimensions; naming one leaves the other for the axis not named. Only a heatmap has a + second axis to choose, so a line or a scatter rejects it rather than ignoring it. + channels (str | None): One of `CHANNELS`, deciding what the ``"IQ"`` dimension + becomes. ``"iq"`` draws a line per quadrature, ``"i"`` and ``"q"`` one of them, + ``"magnitude"`` gives ``hypot(I, Q)`` and ``"phase"`` gives ``arctan2(Q, I)``. ``None`` + takes ``"iq"`` for a line and ``"magnitude"`` for a heatmap, which needs a single + surface and has no rotation to prefer I with. Rejected for an array with no ``"IQ"`` + dimension, such as a ``state`` field. + value_label (str | None): Label for the measured quantity — the y axis of a line figure, the + colour bar of a heatmap. Defaults to the array's own ``long_name`` attribute, then to + its name, then to what the channel implies. + title (str | None): Title for the figure. No title by default. + + Returns: + The [`Figure`][qprogram.plotting.Figure] to hand a renderer. + + Raises: + ValidationError: If ``kind`` or ``channels`` is not a known name, if the array's shape does + not suit the requested kind, if ``x`` or ``y`` names something that is not a coordinate + on a plot dimension, or if a composed dimension is left without one. + """ + if kind is not None and kind not in KINDS: + msg = f"kind must be one of {', '.join(KINDS)}, got {kind!r}" + raise ValidationError(msg) + if channels is not None and channels not in CHANNELS: + msg = f"channels must be one of {', '.join(CHANNELS)}, got {channels!r}" + raise ValidationError(msg) + + dims = tuple(str(dim) for dim in data.dims if dim != IQ_DIM) + kind = kind or _infer_kind(data, dims) + if kind == "scatter": + return _scatter(data, x, y, channels, title) + if kind == "line": + return _lines(data, dims, x, y, channels, value_label, title) + return _heatmap(data, dims, x, y, channels, value_label, title) + + +def _infer_kind(data: xr.DataArray, dims: tuple[str, ...]) -> str: + """Choose a figure shape from the dimensions left once ``"IQ"`` is set aside. + + Args: + data (xarray.DataArray): The array being plotted, used only to phrase the error. + dims (tuple[str, ...]): The plot dimensions, in array order. + + Returns: + ``"line"`` for one dimension, ``"heatmap"`` for two. + + Raises: + ValidationError: For no dimensions at all, or more than two. + """ + if len(dims) == 1: + return "line" + if len(dims) == 2: + return "heatmap" + if not dims: + msg = ( + f"Nothing to plot: {_shape(data)} is a single measured point with no dimension to plot " + f"it against. Sweep a variable, or plot the raw trace, which carries a 'time' dimension." + ) + raise ValidationError(msg) + msg = ( + f"Cannot infer a figure for {_shape(data)}: {len(dims)} dimensions besides 'IQ' " + f"({', '.join(dims)}) is more than a line or a heatmap can show. Select one down first, " + f"with data.sel({dims[0]}=...), or pass kind='scatter' to plot I against Q." + ) + raise ValidationError(msg) + + +def _shape(data: xr.DataArray) -> str: + """Describe an array's dimensions the way an error message wants to read them. + + Args: + data (xarray.DataArray): The array to describe. + + Returns: + A parenthesised dimension list, e.g. ``"an array with dims ('gain', 'IQ')"``. + """ + return f"an array with dims {tuple(str(dim) for dim in data.dims)}" + + +def _lines( # ruff: ignore[too-many-arguments] + data: xr.DataArray, + dims: tuple[str, ...], + x: str | None, + y: str | None, + channels: str | None, + value_label: str | None, + title: str | None, +) -> Figure: + """Build a line per channel against a single plot dimension. + + Args: + data (xarray.DataArray): The array to plot. + dims (tuple[str, ...]): Its plot dimensions. + x (str | None): Dimension or coordinate for the x axis. + y (str | None): Must be ``None``: a line figure's y axis is the measured value. + channels (str | None): Requested channel treatment. + value_label (str | None): Label for the y axis. + title (str | None): Figure title. + + Returns: + A figure of [`Line`][qprogram.plotting.Line] marks. + + Raises: + ValidationError: If the array does not have exactly one plot dimension, or if ``y`` was + given. + """ + if y is not None: + msg = f"y={y!r} chooses a second dimension, which only a heatmap has; a line's y axis is the measured value." + raise ValidationError(msg) + if len(dims) != 1: + msg = ( + f"kind='line' needs exactly one dimension besides 'IQ'; {_shape(data)} has " + f"{len(dims)} ({', '.join(dims) or 'none'}). Select the others down with data.sel()." + ) + raise ValidationError(msg) + dim = dims[0] + positions, x_label = _axis(data, dim, x, "x") + channels = channels or _default_channels(data, "line") + marks: tuple[Mark, ...] = tuple( + Line(x=positions, y=np.asarray(values.transpose(dim).values), label=label) + for label, values in _channels(data, channels, "line") + ) + return Figure(marks=marks, x_label=x_label, y_label=_value_label(data, channels, value_label), title=title) + + +def _heatmap( # ruff: ignore[too-many-arguments] + data: xr.DataArray, + dims: tuple[str, ...], + x: str | None, + y: str | None, + channels: str | None, + value_label: str | None, + title: str | None, +) -> Figure: + """Build a single coloured surface over two plot dimensions. + + Args: + data (xarray.DataArray): The array to plot. + dims (tuple[str, ...]): Its plot dimensions. + x (str | None): Dimension or coordinate for the x axis. + y (str | None): Dimension or coordinate for the y axis. + channels (str | None): Requested channel treatment; must name a single surface. + value_label (str | None): Label for the colour bar. + title (str | None): Figure title. + + Returns: + A figure holding one [`Mesh`][qprogram.plotting.Mesh]. + + Raises: + ValidationError: If the array does not have exactly two plot dimensions, or if ``x`` and + ``y`` name the same one. + """ + if len(dims) != 2: + msg = ( + f"kind='heatmap' needs exactly two dimensions besides 'IQ'; {_shape(data)} has " + f"{len(dims)} ({', '.join(dims) or 'none'})." + ) + raise ValidationError(msg) + x_dim, y_dim = _mesh_dims(data, dims, x, y) + columns, x_label = _axis(data, x_dim, x, "x") + rows, y_label = _axis(data, y_dim, y, "y") + channels = channels or _default_channels(data, "heatmap") + ((_, values),) = _channels(data, channels, "heatmap") + mesh = Mesh( + x=columns, + y=rows, + values=np.asarray(values.transpose(y_dim, x_dim).values), + label=_value_label(data, channels, value_label), + ) + return Figure(marks=(mesh,), x_label=x_label, y_label=y_label, title=title) + + +def _mesh_dims( + data: xr.DataArray, + dims: tuple[str, ...], + x: str | None, + y: str | None, +) -> tuple[str, str]: + """Decide which plot dimension goes on which axis of a heatmap. + + The default puts the innermost sweep on the x axis and the outermost on the y axis, so the + picture matches the loop nesting: the variable that changes fastest runs left to right. + + Args: + data (xarray.DataArray): The array being plotted. + dims (tuple[str, ...]): Its two plot dimensions, in array order. + x (str | None): Dimension or coordinate requested for the x axis. + y (str | None): Dimension or coordinate requested for the y axis. + + Returns: + The ``(x_dim, y_dim)`` pair. + + Raises: + ValidationError: If both arguments resolve to the same dimension. + """ + outer, inner = dims + x_dim = _dim_of(data, dims, x, "x") if x is not None else None + y_dim = _dim_of(data, dims, y, "y") if y is not None else None + if x_dim is not None and y_dim is not None and x_dim == y_dim: + msg = f"x={x!r} and y={y!r} both name dimension {x_dim!r}; a heatmap needs one on each axis" + raise ValidationError(msg) + if x_dim is None: + x_dim = outer if y_dim == inner else inner + if y_dim is None: + y_dim = inner if x_dim == outer else outer + return x_dim, y_dim + + +def _dim_of(data: xr.DataArray, dims: tuple[str, ...], name: str, argument: str) -> str: + """Return the plot dimension ``name`` sits on. + + Args: + data (xarray.DataArray): The array being plotted. + dims (tuple[str, ...]): Its plot dimensions. + name (str): A dimension name or the name of a coordinate on one. + argument (str): ``"x"`` or ``"y"``, so the error names the argument the caller passed. + + Returns: + The dimension name. + + Raises: + ValidationError: If ``name`` is neither a plot dimension nor a coordinate on one. + """ + if name in dims: + return name + coord = data.coords.get(name) + if coord is not None and len(coord.dims) == 1 and str(coord.dims[0]) in dims: + return str(coord.dims[0]) + msg = ( + f"{argument}={name!r} is not a dimension or a coordinate of this result. " + f"Dimensions: {', '.join(dims)}. Coordinates: {', '.join(str(c) for c in data.coords) or 'none'}." + ) + raise ValidationError(msg) + + +def _axis(data: xr.DataArray, dim: str, requested: str | None, argument: str) -> tuple[np.ndarray, str]: + """Resolve the positions and the label for one axis. + + Args: + data (xarray.DataArray): The array being plotted. + dim (str): The plot dimension this axis shows. + requested (str | None): The dimension or coordinate the caller named for this axis, if any. + argument (str): ``"x"`` or ``"y"``, for the error messages. + + Returns: + The positions along the axis and the text to label it with. + + Raises: + ValidationError: If ``requested`` is not a coordinate on ``dim``, or if the dimension + composes several variables and nothing chose between them. + """ + if requested is not None: + _dim_of(data, (dim,), requested, argument) + return _coordinate(data, dim, requested) + if dim in data.coords: + return _coordinate(data, dim, dim) + candidates = [str(name) for name, coord in data.coords.items() if coord.dims == (dim,)] + if len(candidates) == 1: + return _coordinate(data, dim, candidates[0]) + if not candidates: + return np.arange(data.sizes[dim]), dim + choices = " or ".join(f"{argument}={name!r}" for name in candidates) + msg = ( + f"Dimension {dim!r} composes {len(candidates)} swept variables, so it carries no single " + f"coordinate to put on the {argument} axis. Name one with {choices}, or {argument}={dim!r} " + f"for the sweep index." + ) + raise ValidationError(msg) + + +def _coordinate(data: xr.DataArray, dim: str, name: str) -> tuple[np.ndarray, str]: + """Return one coordinate's values and its axis label. + + Args: + data (xarray.DataArray): The array being plotted. + dim (str): The dimension the coordinate lies along. + name (str): The coordinate's name, or ``dim`` itself for a dimension with no coordinate. + + Returns: + The values along the axis and the text to label it with. + """ + if name not in data.coords: + # A dimension named explicitly but carrying no coordinate: plot against the sweep index. + return np.arange(data.sizes[dim]), name + coord = data.coords[name] + label = str(coord.attrs.get("long_name") or name) + units = coord.attrs.get("units") + return np.asarray(coord.values), f"{label} ({units})" if units else label + + +def _default_channels(data: xr.DataArray, kind: str) -> str | None: + """Choose what to do with the quadratures when the caller did not say. + + A line figure draws both, which is the pair a measurement produced. A heatmap colours one + surface and has to reduce them: it takes the magnitude, the one function of I and Q that does + not depend on a readout rotation the executor never applied. + + Args: + data (xarray.DataArray): The array being plotted. + kind (str): The figure kind being built. + + Returns: + The channel name, or ``None`` for an array with no ``"IQ"`` dimension to reduce. + """ + if IQ_DIM not in data.dims: + return None + return "magnitude" if kind == "heatmap" else "iq" + + +def _channels(data: xr.DataArray, channels: str | None, kind: str) -> list[tuple[str | None, xr.DataArray]]: + """Turn the ``"IQ"`` dimension into the series a figure draws. + + Args: + data (xarray.DataArray): The array to read the quadratures from. + channels (str | None): One of `CHANNELS`, or ``None`` for an array with no quadratures. + kind (str): The figure kind, so the error can say why a pair will not do. + + Returns: + One ``(label, values)`` pair per series, each ``values`` array without the ``"IQ"`` + dimension. + + Raises: + ValidationError: If the array has no ``"IQ"`` dimension to reduce, or if a heatmap was asked + for both quadratures at once. + """ + if IQ_DIM not in data.dims: + if channels not in {"iq", None}: + msg = ( + f"channels={channels!r} needs an 'IQ' dimension; {_shape(data)} has none. " + f"A 'state' field is already one number per point." + ) + raise ValidationError(msg) + return [(None, data)] + if channels == "iq" and kind == "heatmap": + msg = "A heatmap colours one surface, and channels='iq' is two. Pass channels='magnitude', 'phase', 'i' or 'q'." + raise ValidationError(msg) + in_phase = data.sel({IQ_DIM: "I"}) + quadrature = data.sel({IQ_DIM: "Q"}) + if channels == "iq": + return [("I", in_phase), ("Q", quadrature)] + if channels == "i": + return [("I", in_phase)] + if channels == "q": + return [("Q", quadrature)] + # numpy's ufuncs dispatch through xarray and hand back a DataArray with the coordinates intact; + # the cast is only to say so, since their annotations stop at ndarray. + if channels == "magnitude": + return [("Magnitude", cast("xr.DataArray", np.hypot(in_phase, quadrature)))] + return [("Phase", cast("xr.DataArray", np.arctan2(quadrature, in_phase)))] + + +def _value_label(data: xr.DataArray, channels: str | None, requested: str | None) -> str: + """Choose the label for the measured quantity. + + Args: + data (xarray.DataArray): The array being plotted, read for its own attributes. + channels (str | None): The channel treatment in force. + requested (str | None): The caller's label, which wins when given. + + Returns: + The axis or colour-bar text. + """ + if requested is not None: + return requested + long_name = data.attrs.get("long_name") + if long_name: + units = data.attrs.get("units") + return f"{long_name} ({units})" if units else str(long_name) + if data.name: + return str(data.name) + if channels is None: + return "Value" + return _CHANNEL_LABELS[channels] + + +def _scatter( + data: xr.DataArray, + x: str | None, + y: str | None, + channels: str | None, + title: str | None, +) -> Figure: + """Build I against Q, every other dimension flattened into the cloud. + + Args: + data (xarray.DataArray): The array to plot. + x (str | None): Must be ``None``: the x axis of a scatter is the in-phase quadrature. + y (str | None): Must be ``None``: the y axis is the other one. + channels (str | None): Must be ``None``: the axes of a scatter *are* the quadratures. + title (str | None): Figure title. + + Returns: + A figure holding one [`Points`][qprogram.plotting.Points] mark. + + Raises: + ValidationError: If the array has no ``"IQ"`` dimension, or if any of the three arguments + that choose an axis was given. + """ + if IQ_DIM not in data.dims: + msg = f"kind='scatter' plots I against Q, and {_shape(data)} has no 'IQ' dimension." + raise ValidationError(msg) + named = [name for name, value in (("x", x), ("y", y), ("channels", channels)) if value is not None] + if named: + msg = ( + f"kind='scatter' already puts I on one axis and Q on the other; " + f"{', '.join(named)} has nothing left to choose." + ) + raise ValidationError(msg) + in_phase = np.asarray(data.sel({IQ_DIM: "I"}).values).reshape(-1) + quadrature = np.asarray(data.sel({IQ_DIM: "Q"}).values).reshape(-1) + return Figure(marks=(Points(x=in_phase, y=quadrature),), x_label="I", y_label="Q", title=title) diff --git a/src/qprogram/plotting/matplotlib_renderer.py b/src/qprogram/plotting/matplotlib_renderer.py new file mode 100644 index 0000000..2afee04 --- /dev/null +++ b/src/qprogram/plotting/matplotlib_renderer.py @@ -0,0 +1,190 @@ +# Copyright 2026 Qilimanjaro Quantum Tech +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""The matplotlib renderer — the one implementation of [`Renderer`][qprogram.plotting.Renderer] that ships. + +Nothing else in the package imports it. It is loaded the first time something resolves the +``"matplotlib"`` renderer, which is what keeps ``import qprogram`` free of a plotting library; +matplotlib itself comes with the ``viz`` extra, so a missing install surfaces here as a plain +`ModuleNotFoundError`. + +The frame it draws is deliberately quiet: no top or right spine, ticks with no marks, grid lines +behind the data, and a legend with no box. What should carry the eye is the data. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, cast + +import matplotlib.pyplot as plt +from matplotlib.colors import LinearSegmentedColormap + +from qprogram.plotting.model import Line, Points + +if TYPE_CHECKING: + from matplotlib.axes import Axes + from matplotlib.figure import Figure as MatplotlibFigure + + from qprogram.plotting.model import Figure, Mesh + from qprogram.plotting.theme import Style + +# Data sits above the grid and below the annotations that point at it. +_DATA_LAYER = 3 + + +def render(figure: Figure, style: Style, target: Any = None) -> Axes: # ruff: ignore[any-type] + """Draw ``figure`` on a matplotlib `Axes`. + + Args: + figure (Figure): What to draw. + style (Style): The palette and the weights to draw it with. + target (Any): An `Axes` to draw on. A fresh figure is created when ``None``, sized + by `Style.size` and filled with the theme's surface colour. + + Returns: + The `Axes` the marks were drawn on. + """ + ax = target + if ax is None: + fig, ax = plt.subplots(figsize=style.size) + fig.set_facecolor(style.theme.surface) + _frame(ax, style) + + series = 0 + for mark in figure.marks: + if isinstance(mark, Line): + _line(ax, mark, style, series) + series += 1 + elif isinstance(mark, Points): + _points(ax, mark, style, series) + series += 1 + else: + # ``Mark`` is a closed union of the three, so what is left is a Mesh. + _mesh(ax, mark, style) + + ax.set_xlabel(figure.x_label) + ax.set_ylabel(figure.y_label) + if figure.title: + ax.set_title(figure.title, color=style.theme.text, fontsize=10, loc="left", pad=6) + _legend(ax, figure, style) + return ax + + +def _frame(ax: Axes, style: Style) -> None: + """Push the axes furniture back so the data reads first. + + Args: + ax (Axes): The axes to restyle. + style (Style): The palette and whether a grid is wanted. + """ + theme = style.theme + ax.set_facecolor(theme.surface) + # Line properties alongside ``visible=False`` are what matplotlib warns about, so the off case + # passes nothing but the switch. + if style.grid: + ax.grid(visible=True, color=theme.grid, linewidth=0.8, zorder=0) + else: + ax.grid(visible=False) + ax.set_axisbelow(True) + for side in ("top", "right"): + ax.spines[side].set_visible(False) + for side in ("left", "bottom"): + ax.spines[side].set_color(theme.grid) + ax.tick_params(colors=theme.muted, labelsize=9, length=0) + ax.xaxis.label.set_color(theme.muted) + ax.yaxis.label.set_color(theme.muted) + ax.xaxis.label.set_fontsize(10) + ax.yaxis.label.set_fontsize(10) + + +def _line(ax: Axes, mark: Line, style: Style, series: int) -> None: + """Draw one polyline. + + Args: + ax (Axes): The axes to draw on. + mark (Line): The samples and the legend entry. + style (Style): The palette and the stroke weight. + series (int): Which categorical colour slot this mark takes. + """ + ax.plot( + mark.x, + mark.y, + color=style.color(series), + linewidth=style.linewidth, + marker="o" if style.markers else None, + markersize=style.markersize, + label=mark.label, + zorder=_DATA_LAYER, + ) + + +def _points(ax: Axes, mark: Points, style: Style, series: int) -> None: + """Draw one cloud of samples. + + Args: + ax (Axes): The axes to draw on. + mark (Points): The samples and the legend entry. + style (Style): The palette, the point size, and the opacity that keeps a dense cloud + readable. + series (int): Which categorical colour slot this mark takes. + """ + ax.scatter( + mark.x, + mark.y, + s=style.point_size, + alpha=style.point_alpha, + linewidths=0, + color=style.color(series), + label=mark.label, + zorder=_DATA_LAYER, + ) + + +def _mesh(ax: Axes, mark: Mesh, style: Style) -> None: + """Draw one coloured surface, with its colour bar. + + Args: + ax (Axes): The axes to draw on. + mark (Mesh): The grid and its colour-bar label. + style (Style): The palette the ramp is built from, and whether a colour bar is wanted. + """ + theme = style.theme + cmap = LinearSegmentedColormap.from_list("qprogram-sequential", theme.ramp) + mesh = ax.pcolormesh(mark.x, mark.y, mark.values, cmap=cmap, shading="nearest", rasterized=True) + if not style.colorbar: + return + # An Axes always belongs to a figure; the annotation admits None for an axes under teardown. + bar = cast("MatplotlibFigure", ax.get_figure()).colorbar(mesh, ax=ax, pad=0.02) + if mark.label: + bar.set_label(mark.label, color=theme.muted, fontsize=10) + bar.ax.tick_params(colors=theme.muted, labelsize=9, length=0) + bar.outline.set_edgecolor(theme.grid) + bar.outline.set_linewidth(0.8) + + +def _legend(ax: Axes, figure: Figure, style: Style) -> None: + """Add a legend when there is more than one named mark to tell apart. + + A single named series needs no legend: the axis label already says what the curve is. + + Args: + ax (Axes): The axes to draw on. + figure (Figure): Read for how many of its marks carry a label. + style (Style): The palette, and whether a legend is wanted at all. + """ + named = [mark for mark in figure.marks if mark.label] + if not style.legend or len(named) < 2: + return + legend = ax.legend(frameon=False, fontsize=9) + for text in legend.get_texts(): + text.set_color(style.theme.text) diff --git a/src/qprogram/plotting/model.py b/src/qprogram/plotting/model.py new file mode 100644 index 0000000..30f2994 --- /dev/null +++ b/src/qprogram/plotting/model.py @@ -0,0 +1,107 @@ +# Copyright 2026 Qilimanjaro Quantum Tech +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""What a figure *is*, with nothing about how it is drawn. + +A [`Figure`][qprogram.plotting.Figure] is a sequence of marks and the two axis labels they share. A mark is one of +three shapes — a [`Line`][qprogram.plotting.Line], a [`Points`][qprogram.plotting.Points] cloud, or a +[`Mesh`][qprogram.plotting.Mesh] — each holding plain numpy arrays. There is no colour here, no figure size, and no +reference to a plotting library: those belong to [`Style`][qprogram.plotting.Style] and to the renderer. + +Keeping the description separate is what makes a second renderer possible at all. It is also what +lets a caller inspect what would be drawn without drawing it, which is how the tests in +``tests/test_plotting.py`` check the shape of a figure without a display. + +The dataclasses are frozen and compare by identity: a field holding a numpy array has no equality +that answers `True` or `False`, so an ``==`` between two figures would raise rather than +report a difference. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING, TypeAlias + +if TYPE_CHECKING: + import numpy as np + + +@dataclass(frozen=True, eq=False) +class Line: + """A polyline through ``(x, y)``, drawn in the order the samples are given. + + Attributes: + x (numpy.ndarray): Positions along the x axis. Same length as ``y``. + y (numpy.ndarray): The values plotted against them. + label (str | None): Legend entry. ``None`` for a figure whose single line needs no name. + """ + + x: np.ndarray + y: np.ndarray + label: str | None = None + + +@dataclass(frozen=True, eq=False) +class Points: + """An unordered cloud of ``(x, y)`` samples — a scatter. + + Attributes: + x (numpy.ndarray): Positions along the x axis. Same length as ``y``. + y (numpy.ndarray): The values plotted against them. + label (str | None): Legend entry, or ``None``. + """ + + x: np.ndarray + y: np.ndarray + label: str | None = None + + +@dataclass(frozen=True, eq=False) +class Mesh: + """A rectangular grid of values, coloured by magnitude — a heatmap. + + Attributes: + x (numpy.ndarray): Column positions, of length ``values.shape[1]``. + y (numpy.ndarray): Row positions, of length ``values.shape[0]``. + values (numpy.ndarray): The grid itself, indexed ``[row, column]`` — the layout + `xarray.DataArray.values` gives for dimensions ordered ``(y, x)``. + label (str | None): Colour-bar label, or ``None``. + """ + + x: np.ndarray + y: np.ndarray + values: np.ndarray + label: str | None = None + + +Mark: TypeAlias = Line | Points | Mesh +"""Any one of the three shapes a figure is built from.""" + + +@dataclass(frozen=True, eq=False) +class Figure: + """A set of marks sharing one pair of axes. + + Attributes: + marks (tuple[Mark, ...]): What to draw, in drawing order. A renderer dispatches on the type + of each one, so a figure may mix a [`Mesh`][qprogram.plotting.Mesh] with the + [`Line`][qprogram.plotting.Line] s drawn over it. + x_label (str): Text for the x axis, already carrying its units. + y_label (str): Text for the y axis, already carrying its units. + title (str | None): Title above the axes, or ``None`` for none. + """ + + marks: tuple[Mark, ...] + x_label: str + y_label: str + title: str | None = None diff --git a/src/qprogram/plotting/renderers.py b/src/qprogram/plotting/renderers.py new file mode 100644 index 0000000..d80d68f --- /dev/null +++ b/src/qprogram/plotting/renderers.py @@ -0,0 +1,121 @@ +# Copyright 2026 Qilimanjaro Quantum Tech +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""The registry that decides who draws a [`Figure`][qprogram.plotting.Figure]. + +A renderer is any callable taking a figure, a [`Style`][qprogram.plotting.Style], and an optional surface to draw on. +What it returns is its own business — the matplotlib one hands back the `Axes` it drew, +which is what makes a figure composable with the rest of a notebook. + +Registration mirrors [`register_sweep_source`][qprogram.register_sweep_source]: one name, one +implementation, and re-registering the same object is a no-op while a different one under a taken +name raises. ``"matplotlib"`` is the default and is registered on first use, so importing +``qprogram`` never imports a plotting library. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Protocol + +if TYPE_CHECKING: + from qprogram.plotting.model import Figure + from qprogram.plotting.theme import Style + +DEFAULT_RENDERER = "matplotlib" +"""The renderer used when a call names none.""" + + +class Renderer(Protocol): + """What [`register_renderer`][qprogram.plotting.register_renderer] accepts: a callable that draws a figure. + + A plain function satisfies it, and so does an instance of a class with ``__call__``, which is + the way to carry per-renderer configuration. + """ + + def __call__(self, figure: Figure, style: Style, target: Any = None) -> Any: # ruff: ignore[any-type] + """Draw ``figure``. + + Args: + figure (Figure): What to draw. Marks are given in drawing order. + style (Style): The palette and the weights to draw it with. + target (Any): An existing surface to draw on — a matplotlib `Axes` for the + built-in renderer — or ``None`` to make a new one. + + Returns: + Whatever handle the backend gives back for further work. + """ + ... + + +_renderers: dict[str, Renderer] = {} + + +def register_renderer(name: str, renderer: Renderer) -> Renderer: + """Register ``renderer`` under ``name``. + + Args: + name (str): The name callers pass as ``renderer=``. + renderer (Renderer): The callable that draws a figure. + + Returns: + ``renderer``, so a class or function can be registered where it is defined. + + Raises: + ValueError: If ``name`` is already registered to a different object. Replacing a renderer + silently would change every plot in the process. + """ + existing = _renderers.get(name) + if existing is not None and existing is not renderer: + msg = f"renderer {name!r} is already registered to {existing!r}; pick another name" + raise ValueError(msg) + _renderers[name] = renderer + return renderer + + +def resolve_renderer(name: str | None = None) -> Renderer: + """Return the renderer registered under ``name``. + + Args: + name (str | None): A registered name, or ``None`` for `DEFAULT_RENDERER`. + + Returns: + The renderer to draw with. + + Raises: + KeyError: If ``name`` names no registered renderer. + ModuleNotFoundError: If the default renderer is asked for without ``matplotlib`` + installed — install ``qprogram[viz]``. + """ + name = name or DEFAULT_RENDERER + if name == DEFAULT_RENDERER and name not in _renderers: + # Imported on first use, so that `import qprogram` never pulls in matplotlib. + from qprogram.plotting import matplotlib_renderer # ruff: ignore[import-outside-top-level] + + register_renderer(DEFAULT_RENDERER, matplotlib_renderer.render) + if name not in _renderers: + available = ", ".join(sorted(_renderers)) or "none" + msg = f"No renderer named {name!r}; registered: {available}" + raise KeyError(msg) + return _renderers[name] + + +def available_renderers() -> tuple[str, ...]: + """List the renderers registered so far, in name order. + + The default is absent until something has drawn with it, because it registers itself on first + use rather than at import. + + Returns: + The registered names. + """ + return tuple(sorted(_renderers)) diff --git a/src/qprogram/plotting/theme.py b/src/qprogram/plotting/theme.py new file mode 100644 index 0000000..9e57b07 --- /dev/null +++ b/src/qprogram/plotting/theme.py @@ -0,0 +1,114 @@ +# Copyright 2026 Qilimanjaro Quantum Tech +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Colours and drawing settings, held apart from both the figure and the renderer. + +A [`Theme`][qprogram.plotting.Theme] is the palette and nothing else; a [`Style`][qprogram.plotting.Style] is a theme +plus the handful of settings that decide how heavy the marks are. Neither imports a plotting library, +so a renderer for any backend reads the same two objects. + +Two themes ship: [`LIGHT`][qprogram.plotting.LIGHT] and [`DARK`][qprogram.plotting.DARK]. Both are frozen dataclasses, +so a variant is one `dataclasses.replace` away and a whole palette of your own is a constructor call. +""" + +from __future__ import annotations + +from dataclasses import dataclass + + +@dataclass(frozen=True) +class Theme: + """A palette: the surface a figure sits on, its text and frame, and the colours the data takes. + + Attributes: + surface (str): Background of the figure and the axes. + text (str): Titles and legend entries — the type meant to be read. + muted (str): Axis labels, tick labels, and annotations, one step back from ``text``. + grid (str): Grid lines and the axis spines, the furthest back of the three. + series (tuple[str, ...]): Categorical slots, used in order, one per series. Cycled when a + figure carries more series than the theme has slots. + ramp (tuple[str, ...]): Sequential ramp for a [`Mesh`][qprogram.plotting.Mesh], darkest-to-lightest or the + reverse, whichever runs away from ``surface``. Interpolated by the renderer. + """ + + surface: str + text: str + muted: str + grid: str + series: tuple[str, ...] + ramp: tuple[str, ...] + + +LIGHT = Theme( + surface="#ffffff", + text="#0b0b0b", + muted="#52514e", + grid="#e6e6e3", + series=("#2a78d6", "#eb6834", "#1baf7a", "#eda100"), + ramp=("#cde2fb", "#9ec5f4", "#5598e7", "#2a78d6", "#256abf", "#184f95", "#0d366b"), +) +"""The palette for a light surface: four categorical hues and a ramp that darkens away from white.""" + +DARK = Theme( + surface="#1e2129", + text="#e2e4e9", + muted="#a2a7b3", + grid="#33373f", + series=("#3987e5", "#d95926", "#199e70", "#c98500"), + ramp=("#232733", "#1d3a63", "#1c5497", "#2a78d6", "#5598e7", "#9ec5f4", "#cde2fb"), +) +"""The palette for a dark surface. The same four hues, stepped for slate rather than flipped, and a +ramp that lightens away from it — so in both themes the strongest mark is the one furthest off the +page.""" + + +@dataclass(frozen=True) +class Style: + """A theme plus the settings that decide how the marks are drawn. + + Attributes: + theme (Theme): The palette. Defaults to [`LIGHT`][qprogram.plotting.LIGHT]. + size (tuple[float, float]): Figure size in inches, ``(width, height)``. + linewidth (float): Stroke width of a [`Line`][qprogram.plotting.Line]. + markers (bool): Draw a marker at every sample of a line. Worth turning on for a coarse + sweep, where the points are the measurement and the line between them is interpolation. + markersize (float): Size of those markers. + point_size (float): Size of a [`Points`][qprogram.plotting.Points] mark. + point_alpha (float): Opacity of a [`Points`][qprogram.plotting.Points] mark, which is what keeps a few thousand + single shots readable where they pile up. + grid (bool): Draw grid lines behind the data. + legend (bool): Draw a legend when the figure has more than one labelled mark. + colorbar (bool): Draw a colour bar beside a [`Mesh`][qprogram.plotting.Mesh]. + """ + + theme: Theme = LIGHT + size: tuple[float, float] = (7.2, 4.0) + linewidth: float = 1.8 + markers: bool = False + markersize: float = 3.5 + point_size: float = 5.0 + point_alpha: float = 0.45 + grid: bool = True + legend: bool = True + colorbar: bool = True + + def color(self, index: int) -> str: + """Return the categorical colour for series ``index``, cycling when the theme runs out. + + Args: + index (int): Zero-based position of the series in the figure. + + Returns: + One of the theme's `series` colours. + """ + return self.theme.series[index % len(self.theme.series)] diff --git a/src/qprogram/result.py b/src/qprogram/result.py index d50814e..e62ac91 100644 --- a/src/qprogram/result.py +++ b/src/qprogram/result.py @@ -22,16 +22,21 @@ from __future__ import annotations from dataclasses import dataclass, field -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Any from qprogram.errors import ValidationError from qprogram.operations.operation import MeasurementField +from qprogram.plotting import Style, build_figure, resolve_renderer if TYPE_CHECKING: import xarray as xr from qprogram.variable import _HandleFieldAccess, _UnassignedType +# The label for a field whose meaning the executor defines. ``iq`` and ``raw`` have none: what a +# demodulated point means is the readout chain's business, so their label comes from the channel. +_FIELD_LABELS = {MeasurementField.STATE.value: "State"} + class MeasurementHandle: """A reference to a measurement performed by a [`QProgram`][qprogram.QProgram]. @@ -159,7 +164,7 @@ class QProgramResult: Results are stored in construction order and addressable by handle, by name string, or by integer position via `get`, which returns the `IQ` field unless a - different one is named. + different one is named. `plot` takes the same arguments and draws what it finds. """ def __init__(self) -> None: @@ -265,6 +270,85 @@ def get( raise KeyError(msg) return record.fields[name] + def plot( # ruff: ignore[too-many-arguments] # every argument is one decision about the figure + self, + measurement: MeasurementHandle | str | int = 0, + bus: str | None = None, + field: MeasurementField | str = MeasurementField.IQ, + *, + kind: str | None = None, + x: str | None = None, + y: str | None = None, + channels: str | None = None, + value_label: str | None = None, + title: str | None = None, + style: Style | None = None, + renderer: str | None = None, + target: Any = None, # ruff: ignore[any-type] + ) -> Any: # ruff: ignore[any-type] # whatever handle the renderer gives back + """Draw one measurement field. + + The array is looked up exactly as `get` looks it up, described as a + [`Figure`][qprogram.plotting.Figure] by [`build_figure`][qprogram.plotting.build_figure], and handed to a + renderer. The default renderer is matplotlib, from the ``viz`` extra, and it returns the + `Axes` it drew on, so anything the figure does not decide — a limit, an + annotation, a second series from elsewhere — is a call away on the object that comes back. + + The shape of the array chooses the figure. One dimension besides ``"IQ"`` gives a line per + quadrature, two give a heatmap of the magnitude, and ``kind="scatter"`` plots I against Q, + which no shape implies on its own. A swept variable's ``label`` and ``units`` reach the axis + from the coordinate the executor wrote them onto. + + Args: + measurement (MeasurementHandle | str | int): Which measurement to draw, by handle, by + name, or by position, exactly as in `get`. + bus (str | None): Bus name filter, applied before that lookup. + field (MeasurementField | str): Which measurement field to draw. Defaults to + `IQ`. + kind (str | None): ``"line"``, ``"heatmap"`` or ``"scatter"``. Inferred from the shape + when omitted. + x (str | None): Dimension or coordinate for the x axis. Required when the dimension + composes several swept variables in parallel, because it holds one coordinate per + variable and the sweep index is a plausible-looking wrong answer. + y (str | None): The same for the y axis of a heatmap. + channels (str | None): What to make of the ``"IQ"`` dimension — ``"iq"``, ``"i"``, + ``"q"``, ``"magnitude"`` or ``"phase"``. Defaults to both quadratures for a line and + to the magnitude for a heatmap, which colours one surface. + value_label (str | None): Label for the measured quantity — the y axis of a line figure, + the colour bar of a heatmap. Defaults to what the field and the channel imply, since + what a demodulated point means is the readout chain's business and not the + executor's. + title (str | None): Title for the figure. None by default. + style (Style | None): Palette and drawing weights. Defaults to + [`Style`][qprogram.plotting.Style]``()``, which is the light theme. + renderer (str | None): A name passed to + [`resolve_renderer`][qprogram.plotting.resolve_renderer]. Defaults to ``"matplotlib"``. + target (Any): An existing surface for the renderer to draw on — a matplotlib + `Axes` for the default one. A new figure is made when omitted. + + Returns: + Whatever the renderer returns: the `Axes` for the matplotlib one. + + Raises: + KeyError: When the measurement or the field has no match, or ``renderer`` names none. + IndexError: When ``measurement`` is a position outside the range in scope. + ValidationError: When an argument does not suit the array's shape — see + [`build_figure`][qprogram.plotting.build_figure]. + ModuleNotFoundError: When the matplotlib renderer is used without matplotlib + installed — install ``qprogram[viz]``. + """ + data = self.get(measurement, bus=bus, field=field) + figure = build_figure( + data, + kind=kind, + x=x, + y=y, + channels=channels, + value_label=value_label or _FIELD_LABELS.get(str(field)), + title=title, + ) + return resolve_renderer(renderer)(figure, style or Style(), target) + @staticmethod def _lookup_by_name( candidates: list[MeasurementResult], diff --git a/tests/test_plotting.py b/tests/test_plotting.py new file mode 100644 index 0000000..463a3fc --- /dev/null +++ b/tests/test_plotting.py @@ -0,0 +1,684 @@ +# Copyright 2026 Qilimanjaro Quantum Tech +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Tests for qprogram.plotting: the figure model, the builder, and the renderers. + +The builder half needs no display and no matplotlib: it turns an array into a description, and the +assertions read that description. The renderer half draws for real, on the Agg backend. +""" + +from __future__ import annotations + +import matplotlib as mpl +import matplotlib.pyplot as plt +import numpy as np +import pytest +import xarray as xr + +import qprogram as qp +from qprogram import ValidationError +from qprogram.plotting import ( + DARK, + LIGHT, + Figure, + Line, + Mesh, + Points, + Style, + Theme, + available_renderers, + build_figure, + matplotlib_renderer, + register_renderer, + resolve_renderer, +) + +mpl.use("Agg") + + +@pytest.fixture(autouse=True) +def _close_figures(): + """Close every figure a test opened, so the suite never trips matplotlib's open-figure warning.""" + yield + plt.close("all") + + +# --------------------------------------------------------------------------- +# Arrays shaped like the executor's output +# --------------------------------------------------------------------------- + + +def _sweep_iq(n: int = 5, *, attrs: dict[str, str] | None = None) -> xr.DataArray: + """One sweep dimension named ``gain`` plus ``IQ``, the shape of a 1-D Rabi result.""" + gain = xr.DataArray(np.linspace(0.0, 1.0, n), dims="gain", attrs=attrs or {}) + values = np.stack([np.arange(n, dtype=float), np.arange(n, dtype=float) * 2], axis=-1) + return xr.DataArray(values, dims=("gain", "IQ"), coords={"gain": gain, "IQ": ["I", "Q"]}) + + +def _grid_iq() -> xr.DataArray: + """Two sweep dimensions plus ``IQ``, the shape of a chevron result.""" + values = np.arange(2 * 3 * 2, dtype=float).reshape(2, 3, 2) + return xr.DataArray( + values, + dims=("amp", "dur", "IQ"), + coords={ + "amp": xr.DataArray([0.0, 1.0], dims="amp", attrs={"long_name": "Flux amplitude", "units": "V"}), + "dur": xr.DataArray([10, 20, 30], dims="dur", attrs={"units": "ns"}), + "IQ": ["I", "Q"], + }, + ) + + +def _state() -> xr.DataArray: + """A ``state`` field over one sweep: no ``IQ`` dimension at all.""" + return xr.DataArray( + np.array([0.0, 0.5, 1.0]), + dims="tau", + coords={"tau": xr.DataArray([1.0, 2.0, 3.0], dims="tau", attrs={"long_name": "Spacing"})}, + ) + + +def _composed() -> xr.DataArray: + """A parallel composition: one dimension, one coordinate per composed variable, no index.""" + return xr.DataArray( + np.arange(4 * 2, dtype=float).reshape(4, 2), + dims=("a|b", "IQ"), + coords={ + "a": xr.DataArray([0.0, 1.0, 2.0, 3.0], dims="a|b", attrs={"long_name": "Gain", "units": "V"}), + "b": xr.DataArray([10.0, 20.0, 30.0, 40.0], dims="a|b"), + "IQ": ["I", "Q"], + }, + ) + + +# --------------------------------------------------------------------------- +# Kind inference +# --------------------------------------------------------------------------- + + +def test_one_dimension_besides_iq_gives_lines(): + figure = build_figure(_sweep_iq()) + assert [type(mark) for mark in figure.marks] == [Line, Line] + assert [mark.label for mark in figure.marks] == ["I", "Q"] + + +def test_two_dimensions_besides_iq_give_a_heatmap(): + figure = build_figure(_grid_iq()) + assert [type(mark) for mark in figure.marks] == [Mesh] + + +def test_time_counts_as_a_plot_dimension(): + # A raw trace with no sweep is (time, IQ): one plot dimension, so it draws against time. + raw = xr.DataArray( + np.zeros((8, 2)), + dims=("time", "IQ"), + coords={"time": np.arange(8), "IQ": ["I", "Q"]}, + ) + figure = build_figure(raw) + assert [type(mark) for mark in figure.marks] == [Line, Line] + assert figure.x_label == "time" + + +def test_a_single_point_has_nothing_to_plot(): + scalar = xr.DataArray(np.zeros(2), dims="IQ", coords={"IQ": ["I", "Q"]}) + with pytest.raises(ValidationError, match="single measured point"): + build_figure(scalar) + + +def test_three_dimensions_cannot_be_inferred(): + cube = xr.DataArray(np.zeros((2, 2, 2, 2)), dims=("a", "b", "c", "IQ")) + with pytest.raises(ValidationError, match="more than a line or a heatmap"): + build_figure(cube) + + +def test_unknown_kind_is_rejected(): + with pytest.raises(ValidationError, match="kind must be one of"): + build_figure(_sweep_iq(), kind="bar") + + +def test_line_rejects_a_two_dimensional_array(): + with pytest.raises(ValidationError, match="exactly one dimension besides 'IQ'"): + build_figure(_grid_iq(), kind="line") + + +def test_heatmap_rejects_a_one_dimensional_array(): + with pytest.raises(ValidationError, match="exactly two dimensions besides 'IQ'"): + build_figure(_sweep_iq(), kind="heatmap") + + +# --------------------------------------------------------------------------- +# Axes and their labels +# --------------------------------------------------------------------------- + + +def test_coordinate_attributes_become_the_axis_label(): + data = _sweep_iq(attrs={"long_name": "Drive amplitude", "units": "V"}) + assert build_figure(data).x_label == "Drive amplitude (V)" + + +def test_a_label_without_units_stands_alone(): + data = _sweep_iq(attrs={"long_name": "Drive amplitude"}) + assert build_figure(data).x_label == "Drive amplitude" + + +def test_units_without_a_label_fall_back_to_the_dimension_name(): + data = _sweep_iq(attrs={"units": "V"}) + assert build_figure(data).x_label == "gain (V)" + + +def test_a_bare_coordinate_labels_itself_with_the_variable_id(): + assert build_figure(_sweep_iq()).x_label == "gain" + + +def test_line_x_values_come_from_the_coordinate(): + figure = build_figure(_sweep_iq(n=4)) + assert np.allclose(figure.marks[0].x, [0.0, 1.0 / 3, 2.0 / 3, 1.0]) + + +# --------------------------------------------------------------------------- +# Composed sweep dimensions +# --------------------------------------------------------------------------- + + +def test_a_composed_dimension_refuses_to_guess_an_axis(): + with pytest.raises(ValidationError, match="composes 2 swept variables"): + build_figure(_composed()) + + +def test_x_names_one_of_the_composed_coordinates(): + figure = build_figure(_composed(), x="a") + assert figure.x_label == "Gain (V)" + assert np.allclose(figure.marks[0].x, [0.0, 1.0, 2.0, 3.0]) + + +def test_naming_the_composed_dimension_plots_the_sweep_index(): + figure = build_figure(_composed(), x="a|b") + assert figure.x_label == "a|b" + assert np.allclose(figure.marks[0].x, [0, 1, 2, 3]) + + +def test_an_unknown_x_names_what_is_available(): + with pytest.raises(ValidationError, match="Coordinates: a, b, IQ"): + build_figure(_composed(), x="nope") + + +def test_a_lone_coordinate_on_a_bare_dimension_needs_no_choosing(): + data = xr.DataArray( + np.zeros((3, 2)), + dims=("a|", "IQ"), + coords={"a": xr.DataArray([1.0, 2.0, 3.0], dims="a|"), "IQ": ["I", "Q"]}, + ) + assert build_figure(data).x_label == "a" + + +def test_a_dimension_with_no_coordinate_at_all_plots_its_index(): + data = xr.DataArray(np.zeros((3, 2)), dims=("shot", "IQ"), coords={"IQ": ["I", "Q"]}) + figure = build_figure(data) + assert figure.x_label == "shot" + assert np.allclose(figure.marks[0].x, [0, 1, 2]) + + +# --------------------------------------------------------------------------- +# Channels +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize( + ("channels", "labels"), + [ + ("iq", ["I", "Q"]), + ("i", ["I"]), + ("q", ["Q"]), + ("magnitude", ["Magnitude"]), + ("phase", ["Phase"]), + ], +) +def test_each_channel_draws_its_own_series(channels, labels): + figure = build_figure(_sweep_iq(), channels=channels) + assert [mark.label for mark in figure.marks] == labels + + +def test_magnitude_is_the_hypotenuse(): + data = _sweep_iq(n=3) + figure = build_figure(data, channels="magnitude") + assert np.allclose(figure.marks[0].y, np.hypot(data.sel(IQ="I"), data.sel(IQ="Q"))) + + +def test_phase_is_the_arctangent(): + data = _sweep_iq(n=3) + figure = build_figure(data, channels="phase") + assert np.allclose(figure.marks[0].y, np.arctan2(data.sel(IQ="Q"), data.sel(IQ="I"))) + + +def test_unknown_channels_are_rejected(): + with pytest.raises(ValidationError, match="channels must be one of"): + build_figure(_sweep_iq(), channels="abs") + + +def test_channels_need_quadratures_to_choose_between(): + with pytest.raises(ValidationError, match="needs an 'IQ' dimension"): + build_figure(_state(), channels="i") + + +def test_an_array_without_quadratures_draws_one_unnamed_line(): + figure = build_figure(_state()) + assert [mark.label for mark in figure.marks] == [None] + assert figure.y_label == "Value" + + +# --------------------------------------------------------------------------- +# Heatmaps +# --------------------------------------------------------------------------- + + +def test_the_innermost_sweep_runs_along_the_x_axis(): + figure = build_figure(_grid_iq()) + assert figure.x_label == "dur (ns)" + assert figure.y_label == "Flux amplitude (V)" + + +def test_x_swaps_the_two_axes(): + figure = build_figure(_grid_iq(), x="amp") + assert figure.x_label == "Flux amplitude (V)" + assert figure.y_label == "dur (ns)" + + +def test_y_alone_settles_both_axes(): + figure = build_figure(_grid_iq(), y="dur") + assert figure.x_label == "Flux amplitude (V)" + assert figure.y_label == "dur (ns)" + + +def test_x_and_y_cannot_name_the_same_dimension(): + with pytest.raises(ValidationError, match="a heatmap needs one on each axis"): + build_figure(_grid_iq(), x="amp", y="amp") + + +def test_the_grid_is_indexed_row_by_column(): + data = _grid_iq() + mesh = build_figure(data, channels="i").marks[0] + assert mesh.values.shape == (len(mesh.y), len(mesh.x)) + assert np.allclose(mesh.values, data.sel(IQ="I").transpose("amp", "dur").values) + + +def test_a_swapped_heatmap_transposes_its_grid(): + data = _grid_iq() + mesh = build_figure(data, x="amp", channels="i").marks[0] + assert np.allclose(mesh.values, data.sel(IQ="I").transpose("dur", "amp").values) + + +def test_a_heatmap_defaults_to_the_magnitude(): + data = _grid_iq() + mesh = build_figure(data).marks[0] + assert mesh.label == "Magnitude" + assert np.allclose(mesh.values, np.hypot(data.sel(IQ="I"), data.sel(IQ="Q")).transpose("amp", "dur")) + + +def test_a_heatmap_cannot_colour_both_quadratures(): + with pytest.raises(ValidationError, match="colours one surface"): + build_figure(_grid_iq(), channels="iq") + + +def test_a_heatmap_without_quadratures_needs_no_channel(): + data = xr.DataArray(np.zeros((2, 3)), dims=("a", "b")) + mesh = build_figure(data).marks[0] + assert isinstance(mesh, Mesh) + assert mesh.label == "Value" + + +# --------------------------------------------------------------------------- +# Scatter +# --------------------------------------------------------------------------- + + +def test_scatter_is_never_inferred(): + assert [type(mark) for mark in build_figure(_sweep_iq()).marks] == [Line, Line] + + +def test_scatter_puts_i_against_q(): + data = _sweep_iq(n=4) + figure = build_figure(data, kind="scatter") + (points,) = figure.marks + assert isinstance(points, Points) + assert (figure.x_label, figure.y_label) == ("I", "Q") + assert np.allclose(points.x, data.sel(IQ="I").values) + assert np.allclose(points.y, data.sel(IQ="Q").values) + + +def test_scatter_flattens_every_other_dimension(): + (points,) = build_figure(_grid_iq(), kind="scatter").marks + assert points.x.shape == (6,) + + +def test_scatter_needs_quadratures(): + with pytest.raises(ValidationError, match="no 'IQ' dimension"): + build_figure(_state(), kind="scatter") + + +@pytest.mark.parametrize("argument", ["x", "y", "channels"]) +def test_scatter_has_nothing_left_for_an_axis_argument_to_choose(argument): + with pytest.raises(ValidationError, match=f"{argument} has nothing left to choose"): + build_figure(_sweep_iq(), kind="scatter", **{argument: "i"}) + + +def test_a_line_figure_has_no_second_dimension_for_y_to_name(): + with pytest.raises(ValidationError, match="only a heatmap has"): + build_figure(_sweep_iq(), y="gain") + + +# --------------------------------------------------------------------------- +# The label on the measured quantity +# --------------------------------------------------------------------------- + + +def test_the_caller_s_value_label_wins(): + assert build_figure(_sweep_iq(), value_label="Readout response").y_label == "Readout response" + + +def test_the_array_s_own_attributes_are_read_next(): + data = _sweep_iq() + data.attrs = {"long_name": "Transmission", "units": "dB"} + assert build_figure(data).y_label == "Transmission (dB)" + + +def test_an_attribute_without_units_stands_alone(): + data = _sweep_iq() + data.attrs = {"long_name": "Transmission"} + assert build_figure(data).y_label == "Transmission" + + +def test_the_array_name_is_read_after_that(): + assert build_figure(_sweep_iq().rename("m0")).y_label == "m0" + + +@pytest.mark.parametrize( + ("channels", "expected"), + [("iq", "Signal"), ("i", "I"), ("q", "Q"), ("magnitude", "Magnitude"), ("phase", "Phase (rad)")], +) +def test_otherwise_the_channel_says_what_the_axis_is(channels, expected): + assert build_figure(_sweep_iq(), channels=channels).y_label == expected + + +def test_a_title_is_carried_through(): + assert build_figure(_sweep_iq(), title="Rabi").title == "Rabi" + + +def test_no_title_by_default(): + assert build_figure(_sweep_iq()).title is None + + +# --------------------------------------------------------------------------- +# Themes and styles +# --------------------------------------------------------------------------- + + +def test_series_colours_cycle(): + style = Style(theme=Theme(surface="w", text="k", muted="k", grid="k", series=("a", "b"), ramp=("a",))) + assert [style.color(i) for i in range(4)] == ["a", "b", "a", "b"] + + +def test_the_default_style_is_the_light_theme(): + assert Style().theme is LIGHT + + +def test_the_two_themes_differ_where_it_matters(): + assert LIGHT.surface != DARK.surface + assert LIGHT.ramp[0] != DARK.ramp[0] + + +# --------------------------------------------------------------------------- +# The renderer registry +# --------------------------------------------------------------------------- + + +def test_the_default_renderer_is_matplotlib(): + assert resolve_renderer() is matplotlib_renderer.render + assert "matplotlib" in available_renderers() + + +def test_a_renderer_can_be_registered_and_resolved(): + def fake(figure, style, target=None): # ruff: ignore[unused-function-argument] + return "drawn" + + try: + register_renderer("test-registry", fake) + assert resolve_renderer("test-registry") is fake + assert "test-registry" in available_renderers() + finally: + qp.plotting.renderers._renderers.pop("test-registry", None) + + +def test_registering_the_same_renderer_twice_is_a_no_op(): + def fake(figure, style, target=None): # ruff: ignore[unused-function-argument] + return None + + try: + assert register_renderer("test-idempotent", fake) is fake + register_renderer("test-idempotent", fake) + finally: + qp.plotting.renderers._renderers.pop("test-idempotent", None) + + +def test_a_taken_name_cannot_be_reassigned(): + def one(figure, style, target=None): # ruff: ignore[unused-function-argument] + return None + + def two(figure, style, target=None): # ruff: ignore[unused-function-argument] + return None + + try: + register_renderer("test-taken", one) + with pytest.raises(ValueError, match="already registered"): + register_renderer("test-taken", two) + finally: + qp.plotting.renderers._renderers.pop("test-taken", None) + + +def test_an_unknown_renderer_lists_the_known_ones(): + resolve_renderer() # make sure the default is registered, so the message is not empty + with pytest.raises(KeyError, match="registered: "): + resolve_renderer("svg") + + +# --------------------------------------------------------------------------- +# The matplotlib renderer +# --------------------------------------------------------------------------- + + +def test_rendering_returns_the_axes_it_drew_on(): + ax = matplotlib_renderer.render(build_figure(_sweep_iq()), Style()) + assert isinstance(ax, plt.Axes) + assert len(ax.lines) == 2 + + +def test_the_axis_labels_reach_the_axes(): + data = _sweep_iq(attrs={"long_name": "Drive amplitude", "units": "V"}) + ax = matplotlib_renderer.render(build_figure(data, title="Rabi"), Style()) + assert ax.get_xlabel() == "Drive amplitude (V)" + assert ax.get_ylabel() == "Signal" + assert ax.get_title(loc="left") == "Rabi" + + +def test_an_existing_axes_is_drawn_on_rather_than_replaced(): + _, ax = plt.subplots() + returned = matplotlib_renderer.render(build_figure(_sweep_iq()), Style(), ax) + assert returned is ax + + +def test_two_series_get_a_legend_and_one_does_not(): + with_two = matplotlib_renderer.render(build_figure(_sweep_iq()), Style()) + assert with_two.get_legend() is not None + with_one = matplotlib_renderer.render(build_figure(_sweep_iq(), channels="i"), Style()) + assert with_one.get_legend() is None + + +def test_the_legend_can_be_switched_off(): + ax = matplotlib_renderer.render(build_figure(_sweep_iq()), Style(legend=False)) + assert ax.get_legend() is None + + +def test_the_theme_paints_the_surface(): + ax = matplotlib_renderer.render(build_figure(_sweep_iq()), Style(theme=DARK)) + assert mpl.colors.to_hex(ax.get_facecolor()) == DARK.surface + + +def test_the_grid_can_be_switched_off(): + ax = matplotlib_renderer.render(build_figure(_sweep_iq()), Style(grid=False)) + assert not any(line.get_visible() for line in ax.get_xgridlines()) + + +def test_markers_are_off_by_default_and_can_be_turned_on(): + plain = matplotlib_renderer.render(build_figure(_sweep_iq()), Style()) + assert plain.lines[0].get_marker() == "None" + marked = matplotlib_renderer.render(build_figure(_sweep_iq()), Style(markers=True)) + assert marked.lines[0].get_marker() == "o" + + +def test_a_heatmap_draws_a_mesh_and_a_colour_bar(): + ax = matplotlib_renderer.render(build_figure(_grid_iq()), Style()) + assert len(ax.collections) == 1 + assert any(other is not ax for other in ax.get_figure().axes) + + +def test_the_colour_bar_can_be_switched_off(): + ax = matplotlib_renderer.render(build_figure(_grid_iq()), Style(colorbar=False)) + assert ax.get_figure().axes == [ax] + + +def test_a_scatter_draws_one_collection(): + ax = matplotlib_renderer.render(build_figure(_sweep_iq(), kind="scatter"), Style()) + assert len(ax.collections) == 1 + + +def test_a_figure_can_mix_marks(): + figure = Figure( + marks=( + Mesh(x=np.arange(3), y=np.arange(2), values=np.zeros((2, 3)), label=None), + Line(x=np.arange(3), y=np.zeros(3), label=None), + ), + x_label="x", + y_label="y", + ) + ax = matplotlib_renderer.render(figure, Style()) + assert len(ax.collections) == 1 + assert len(ax.lines) == 1 + + +# --------------------------------------------------------------------------- +# QProgramResult.plot +# --------------------------------------------------------------------------- + +_READOUT = qp.waveforms.IQPair(qp.waveforms.Square(1.0, 200), qp.waveforms.Square(0.0, 200)) +_WEIGHTS = qp.waveforms.IQPair(qp.waveforms.Square(1.0, 200), qp.waveforms.Square(1.0, 200)) +_LIBRARY = {"pi": qp.waveforms.IQDrag(0.5, 40, 8, 0.1), "readout": _READOUT, "weights": _WEIGHTS} + + +def _rabi_response(bus: str, env: dict) -> complex: # ruff: ignore[unused-function-argument] + return np.sin(np.pi * env["gain"]) ** 2 + 0j + + +def _rabi_population(bus: str, env: dict) -> float: # ruff: ignore[unused-function-argument] + return float(env["gain"]) + + +def _rabi_result() -> tuple[qp.QProgramResult, qp.MeasurementHandle]: + """Run a small labelled sweep, so the coordinate attributes are the executor's own.""" + schema = qp.BusSchema.transmon() + program = qp.QProgram(label="rabi", schema=schema) + gain = program.variable("gain", label="Drive amplitude", units="V") + with program.average(4), program.sweep(gain, qp.Range(0.0, 1.0, 0.25)): + program.set_gain(schema.q[0].drive, gain) + program.play(schema.q[0].drive, "pi") + program.sync() + handle = program.measure( + schema.q[0].readout, + "readout", + "weights", + fields=(qp.MeasurementField.IQ, qp.MeasurementField.STATE), + ) + model = qp.MockMeasurementModel(response=_rabi_response, p_excited=_rabi_population, seed=0) + return qp.simulate(program.with_waveforms(_LIBRARY), model=model), handle + + +def test_plot_labels_its_axis_from_the_swept_variable(): + result, handle = _rabi_result() + ax = result.plot(handle) + assert ax.get_xlabel() == "Drive amplitude (V)" + assert len(ax.lines) == 2 + + +def test_plot_finds_a_measurement_the_same_ways_get_does(): + result, handle = _rabi_result() + by_position = result.plot(0) + by_name = result.plot(handle.name) + by_bus = result.plot(0, bus="q0/readout") + assert all(isinstance(ax, plt.Axes) for ax in (by_position, by_name, by_bus)) + + +def test_plot_names_the_state_field_on_the_axis(): + result, handle = _rabi_result() + ax = result.plot(handle, field=qp.MeasurementField.STATE) + assert ax.get_ylabel() == "State" + assert len(ax.lines) == 1 + + +def test_plot_passes_the_style_through(): + result, handle = _rabi_result() + ax = result.plot(handle, style=Style(theme=DARK)) + assert mpl.colors.to_hex(ax.get_facecolor()) == DARK.surface + + +def test_plot_draws_on_an_axes_it_is_given(): + result, handle = _rabi_result() + _, ax = plt.subplots() + assert result.plot(handle, target=ax) is ax + + +def test_plot_uses_the_renderer_it_is_told_to(): + result, handle = _rabi_result() + + def fake(figure, style, target=None): # ruff: ignore[unused-function-argument] + return figure + + try: + register_renderer("test-plot", fake) + figure = result.plot(handle, renderer="test-plot") + finally: + qp.plotting.renderers._renderers.pop("test-plot", None) + assert isinstance(figure, Figure) + assert figure.x_label == "Drive amplitude (V)" + + +def test_plot_takes_a_label_for_the_measured_quantity(): + result, handle = _rabi_result() + ax = result.plot(handle, value_label="Readout response") + assert ax.get_ylabel() == "Readout response" + + +def test_plot_reports_a_missing_field_the_way_get_does(): + result, handle = _rabi_result() + with pytest.raises(KeyError, match="has no field 'raw'"): + result.plot(handle, field=qp.MeasurementField.RAW) + + +def test_plot_of_a_parallel_sweep_asks_which_variable_to_use(): + schema = qp.BusSchema.transmon() + program = qp.QProgram(label="parallel", schema=schema) + amp = program.variable("amp", label="Amplitude", units="V") + freq = program.variable("freq", label="Frequency", units="Hz") + with program.sweep(amp, qp.Range(0.0, 1.0, 0.25)) | program.sweep(freq, qp.Range(4e9, 5e9, 0.25e9)): + handle = program.measure(schema.q[0].readout, "readout", "weights") + result = qp.simulate(program.with_waveforms(_LIBRARY)) + with pytest.raises(ValidationError, match="composes 2 swept variables"): + result.plot(handle) + assert result.plot(handle, x="freq").get_xlabel() == "Frequency (Hz)" diff --git a/zensical.toml b/zensical.toml index 864385e..1c410e3 100644 --- a/zensical.toml +++ b/zensical.toml @@ -25,6 +25,7 @@ nav = [ { "Measurements and results" = "guide/measurements.md" }, { "Capabilities, diagnostics, and profiles" = "guide/capabilities.md" }, { "Running programs" = "guide/execution.md" }, + { "Plotting results" = "guide/plotting.md" }, { "Saving and loading" = "guide/serialization.md" }, ] }, { "Examples" = [ From 01fa80c118956ab5a8373e7178554b1c91d78220 Mon Sep 17 00:00:00 2001 From: Vyron Vasileiadis Date: Wed, 2 Sep 2026 04:09:50 +0300 Subject: [PATCH 3/9] Clear the SonarCloud findings the new code opened Twelve pytest.raises blocks built their array inside the block, so the assertion covered the setup as well as the call under test. The setup is hoisted above the with, the way the rest of the suite already writes one. Two Any annotations narrow. The matplotlib renderer draws on an Axes and nothing else, so its target says Axes | None. QProgramResult.plot forwards its target to whichever renderer was asked for, and object accepts every surface one of them could take while claiming less than Any does. The return type of plot stays Any: what comes back is the chosen renderer's, and the matplotlib one hands back the Axes the docs tell you to keep working on. --- src/qprogram/plotting/matplotlib_renderer.py | 8 ++--- src/qprogram/result.py | 4 +-- tests/test_plotting.py | 36 +++++++++++++------- 3 files changed, 30 insertions(+), 18 deletions(-) diff --git a/src/qprogram/plotting/matplotlib_renderer.py b/src/qprogram/plotting/matplotlib_renderer.py index 2afee04..ffc95da 100644 --- a/src/qprogram/plotting/matplotlib_renderer.py +++ b/src/qprogram/plotting/matplotlib_renderer.py @@ -24,7 +24,7 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any, cast +from typing import TYPE_CHECKING, cast import matplotlib.pyplot as plt from matplotlib.colors import LinearSegmentedColormap @@ -42,14 +42,14 @@ _DATA_LAYER = 3 -def render(figure: Figure, style: Style, target: Any = None) -> Axes: # ruff: ignore[any-type] +def render(figure: Figure, style: Style, target: Axes | None = None) -> Axes: """Draw ``figure`` on a matplotlib `Axes`. Args: figure (Figure): What to draw. style (Style): The palette and the weights to draw it with. - target (Any): An `Axes` to draw on. A fresh figure is created when ``None``, sized - by `Style.size` and filled with the theme's surface colour. + target (matplotlib.axes.Axes | None): An `Axes` to draw on. A fresh figure is created when + ``None``, sized by `Style.size` and filled with the theme's surface colour. Returns: The `Axes` the marks were drawn on. diff --git a/src/qprogram/result.py b/src/qprogram/result.py index e62ac91..834eaf0 100644 --- a/src/qprogram/result.py +++ b/src/qprogram/result.py @@ -284,7 +284,7 @@ def plot( # ruff: ignore[too-many-arguments] # every argument is one decision title: str | None = None, style: Style | None = None, renderer: str | None = None, - target: Any = None, # ruff: ignore[any-type] + target: object = None, ) -> Any: # ruff: ignore[any-type] # whatever handle the renderer gives back """Draw one measurement field. @@ -323,7 +323,7 @@ def plot( # ruff: ignore[too-many-arguments] # every argument is one decision [`Style`][qprogram.plotting.Style]``()``, which is the light theme. renderer (str | None): A name passed to [`resolve_renderer`][qprogram.plotting.resolve_renderer]. Defaults to ``"matplotlib"``. - target (Any): An existing surface for the renderer to draw on — a matplotlib + target (object): An existing surface for the renderer to draw on — a matplotlib `Axes` for the default one. A new figure is made when omitted. Returns: diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 463a3fc..269c001 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -142,18 +142,21 @@ def test_three_dimensions_cannot_be_inferred(): def test_unknown_kind_is_rejected(): + data = _sweep_iq() with pytest.raises(ValidationError, match="kind must be one of"): - build_figure(_sweep_iq(), kind="bar") + build_figure(data, kind="bar") def test_line_rejects_a_two_dimensional_array(): + data = _grid_iq() with pytest.raises(ValidationError, match="exactly one dimension besides 'IQ'"): - build_figure(_grid_iq(), kind="line") + build_figure(data, kind="line") def test_heatmap_rejects_a_one_dimensional_array(): + data = _sweep_iq() with pytest.raises(ValidationError, match="exactly two dimensions besides 'IQ'"): - build_figure(_sweep_iq(), kind="heatmap") + build_figure(data, kind="heatmap") # --------------------------------------------------------------------------- @@ -191,8 +194,9 @@ def test_line_x_values_come_from_the_coordinate(): def test_a_composed_dimension_refuses_to_guess_an_axis(): + data = _composed() with pytest.raises(ValidationError, match="composes 2 swept variables"): - build_figure(_composed()) + build_figure(data) def test_x_names_one_of_the_composed_coordinates(): @@ -208,8 +212,9 @@ def test_naming_the_composed_dimension_plots_the_sweep_index(): def test_an_unknown_x_names_what_is_available(): + data = _composed() with pytest.raises(ValidationError, match="Coordinates: a, b, IQ"): - build_figure(_composed(), x="nope") + build_figure(data, x="nope") def test_a_lone_coordinate_on_a_bare_dimension_needs_no_choosing(): @@ -261,13 +266,15 @@ def test_phase_is_the_arctangent(): def test_unknown_channels_are_rejected(): + data = _sweep_iq() with pytest.raises(ValidationError, match="channels must be one of"): - build_figure(_sweep_iq(), channels="abs") + build_figure(data, channels="abs") def test_channels_need_quadratures_to_choose_between(): + data = _state() with pytest.raises(ValidationError, match="needs an 'IQ' dimension"): - build_figure(_state(), channels="i") + build_figure(data, channels="i") def test_an_array_without_quadratures_draws_one_unnamed_line(): @@ -300,8 +307,9 @@ def test_y_alone_settles_both_axes(): def test_x_and_y_cannot_name_the_same_dimension(): + data = _grid_iq() with pytest.raises(ValidationError, match="a heatmap needs one on each axis"): - build_figure(_grid_iq(), x="amp", y="amp") + build_figure(data, x="amp", y="amp") def test_the_grid_is_indexed_row_by_column(): @@ -325,8 +333,9 @@ def test_a_heatmap_defaults_to_the_magnitude(): def test_a_heatmap_cannot_colour_both_quadratures(): + data = _grid_iq() with pytest.raises(ValidationError, match="colours one surface"): - build_figure(_grid_iq(), channels="iq") + build_figure(data, channels="iq") def test_a_heatmap_without_quadratures_needs_no_channel(): @@ -361,19 +370,22 @@ def test_scatter_flattens_every_other_dimension(): def test_scatter_needs_quadratures(): + data = _state() with pytest.raises(ValidationError, match="no 'IQ' dimension"): - build_figure(_state(), kind="scatter") + build_figure(data, kind="scatter") @pytest.mark.parametrize("argument", ["x", "y", "channels"]) def test_scatter_has_nothing_left_for_an_axis_argument_to_choose(argument): + data = _sweep_iq() with pytest.raises(ValidationError, match=f"{argument} has nothing left to choose"): - build_figure(_sweep_iq(), kind="scatter", **{argument: "i"}) + build_figure(data, kind="scatter", **{argument: "i"}) def test_a_line_figure_has_no_second_dimension_for_y_to_name(): + data = _sweep_iq() with pytest.raises(ValidationError, match="only a heatmap has"): - build_figure(_sweep_iq(), y="gain") + build_figure(data, y="gain") # --------------------------------------------------------------------------- From 2a13243907ab54d177db40dd2143779dc52ccec3 Mon Sep 17 00:00:00 2001 From: Vyron Vasileiadis Date: Wed, 2 Sep 2026 05:29:09 +0300 Subject: [PATCH 4/9] Restate a quantity for a figure with coords= and value= A result carries hertz because the instrument takes hertz, and the figure of it wants gigahertz. There was no way to ask for that: the qubit spectroscopy page hand-rolled four lines of matplotlib for it and the guide had a paragraph explaining why it had to. qp.plotting.Quantity carries the three things that have to travel together when a quantity is restated: what to call it, what unit to read it in, and the arithmetic that gets there. coords= takes one per swept coordinate, keyed by the name the axis resolved to, and value= takes one for the measured quantity, which is the y axis of a line, the colour bar of a heatmap and both axes of a scatter. value_label= is gone; a label alone is Quantity("Readout response"). One rule, in both directions: a change of unit and a change of numbers travel together. Rescaling values that carry a unit has to say what the unit is now, and a unit that contradicts the one already there has to come with the arithmetic that earns it. Both fire only where there is an inherited unit to falsify, so correcting a unit the program never recorded still works, and Quantity(units="Hz", transform=lambda v: v - v[0]) says a shift keeps its unit. What no check here can catch is arithmetic that does not match the unit it claims; that needs a registry, and Variable.units legitimately holds "arb". A transform is handed a copy, so the ordinary spelling of a baseline (v -= v[0]) cannot rewrite the measurement the figure is of. It is checked for raising, for changing the shape, for returning something other than real numbers, and for turning a finite value non-finite, each naming the argument that carried it. A NaN the measurement already held is not blamed on it. A coords key that reaches no axis raises rather than doing nothing, and says which of the three mistakes it was: a typo, a coordinate that lost the axis to a sibling on a composed dimension, or a dimension name where the coordinate along it is drawn. Four defects the review turned up go with it. A scatter never received the label argument at all, so it was silently dropped; it now takes units and a transform for the pair and refuses a label, since I and Q already name themselves. An explicit channels="iq" was accepted on an array with no quadratures and labelled the axis "Signal". A coordinate named after one dimension but living on another, which xarray allows and the executor builds when one variable is swept at two nesting levels, was drawn under the wrong dimension's label. And "phase" took its unit from the channel while keeping the array's own name, so an annotated array read "Readout voltage (rad)". The guide gains the rules, what is not checked, and why this moves the data rather than the tick labels. Qubit spectroscopy drops its matplotlib and reads in gigahertz off the program, and T1 gains the microsecond axis its figure has always had. --- changelog/35.added.md | 2 +- docs/examples/cz-chevron.md | 2 +- docs/examples/qubit-spectroscopy.md | 40 +-- docs/examples/rabi.md | 15 +- docs/examples/t1-and-ramsey.md | 19 +- docs/guide/index.md | 2 +- docs/guide/plotting.md | 91 ++++++- docs/reference/api-qprogram.md | 4 + src/qprogram/plotting/__init__.py | 2 + src/qprogram/plotting/build.py | 327 ++++++++++++++++++++----- src/qprogram/plotting/quantity.py | 288 ++++++++++++++++++++++ src/qprogram/result.py | 58 ++++- tests/test_plotting.py | 367 +++++++++++++++++++++++++++- 13 files changed, 1105 insertions(+), 112 deletions(-) create mode 100644 src/qprogram/plotting/quantity.py diff --git a/changelog/35.added.md b/changelog/35.added.md index 0635a05..e4cf14c 100644 --- a/changelog/35.added.md +++ b/changelog/35.added.md @@ -1 +1 @@ -`QProgramResult.plot` draws a measurement. The array is looked up the way `get` looks it up, and its shape chooses the figure: one dimension besides `IQ` gives a line per quadrature, two give a heatmap, and `kind="scatter"` puts I against Q. `channels=` says what to make of the quadratures, `x=` and `y=` which coordinate goes on which axis, and a swept variable's `label` and `units` reach the axis on their own. The drawing sits behind a renderer registered by name, so matplotlib is one implementation rather than the only one: `qp.plotting.build_figure` describes a figure using numpy and xarray alone, and `qp.plotting.Style` and `Theme` are frozen dataclasses a light or dark palette of your own replaces. +`QProgramResult.plot` draws a measurement. The array is looked up the way `get` looks it up, and its shape chooses the figure: one dimension besides `IQ` gives a line per quadrature, two give a heatmap, and `kind="scatter"` puts I against Q. `channels=` says what to make of the quadratures, `x=` and `y=` which coordinate goes on which axis, and a swept variable's `label` and `units` reach the axis on their own. `coords=` and `value=` restate a quantity for the figure: a `qp.plotting.Quantity` carries the arithmetic and the words it produces in one object, so `{"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}` draws the axis in gigahertz and labels it so, and rescaling values without saying what unit they are now in raises rather than printing a label that contradicts its own numbers. The drawing sits behind a renderer registered by name, so matplotlib is one implementation rather than the only one: `qp.plotting.build_figure` describes a figure using numpy and xarray alone, and `qp.plotting.Style` and `Theme` are frozen dataclasses a light or dark palette of your own replaces. diff --git a/docs/examples/cz-chevron.md b/docs/examples/cz-chevron.md index 16ceff0..408b177 100644 --- a/docs/examples/cz-chevron.md +++ b/docs/examples/cz-chevron.md @@ -193,7 +193,7 @@ the grid, so no reshaping is needed. A heatmap colours one surface, so name the quadrature you want; leaving `channels` out takes the magnitude instead: ```python -result.plot(m0, channels="i", value_label="Population transferred") +result.plot(m0, channels="i", value=qp.plotting.Quantity("Population transferred")) ``` ![Heatmap of transferred population against flux duration and amplitude, with interference fringes converging to a chevron tip at 0.5 V.](../assets/plots/cz-chevron-light.png#only-light) diff --git a/docs/examples/qubit-spectroscopy.md b/docs/examples/qubit-spectroscopy.md index 57e3651..a91c0ce 100644 --- a/docs/examples/qubit-spectroscopy.md +++ b/docs/examples/qubit-spectroscopy.md @@ -159,31 +159,39 @@ since the phase of the transmitted signal depends on cable length and the feature does not: ```python -import matplotlib.pyplot as plt - -magnitude = np.hypot(data.sel(IQ="I"), data.sel(IQ="Q")) -plt.plot(data.coords["freq"] / 1e9, magnitude) -plt.xlabel("Drive frequency (GHz)") -plt.ylabel("Readout magnitude") - -f01 = float(data.coords["freq"][int(np.argmax(magnitude.values))]) # 5.0e9 +result.plot( + m0, + channels="magnitude", + coords={"freq": qp.plotting.Quantity(units="GHz", transform=lambda v: v / 1e9)}, + value=qp.plotting.Quantity("Readout magnitude"), +) ``` ![Readout magnitude against drive frequency, flat except for a sharp peak at 5.000 GHz marked as f01.](../assets/plots/qubit-spectroscopy-light.png#only-light) ![Readout magnitude against drive frequency, flat except for a sharp peak at 5.000 GHz marked as f01.](../assets/plots/qubit-spectroscopy-dark.png#only-dark) +`channels="magnitude"` is `np.hypot(I, Q)`, and the `qp.plotting.Quantity` on +`coords` restates the axis in gigahertz: the arithmetic and the unit it +produces travel as one object, so the axis cannot end up reading `(Hz)` over +numbers running 4.6 to 5.4. matplotlib is not a runtime dependency; it comes +with the `viz` extra, installed with `pip install "qprogram[viz]"`. + +The figure is restated; the result is not. Reading the peak back is arithmetic +on the array, and the array is still in hertz: + +```python +magnitude = np.hypot(data.sel(IQ="I"), data.sel(IQ="Q")) +f01 = float(data.coords["freq"][int(np.argmax(magnitude.values))]) # 5.0e9 +``` + `np.hypot` over two `sel` results returns a `DataArray` with dims `("freq",)`, -so the coordinate survives the arithmetic and the peak can be read back as a +so the coordinate survives the arithmetic and the peak comes back as a frequency. `np.argmax` wants the underlying array rather than the `DataArray`, which is what `.values` is for; handing it the labelled array raises `ValueError: dimensions ('freq',) must have the same length as the number of -data dimensions, ndim=0`. matplotlib is not a runtime dependency; it comes with -the `viz` extra, installed with `pip install "qprogram[viz]"`. - -`result.plot(m0, channels="magnitude")` draws the same curve without the four -lines above. The code is written out here because the figure reads in -gigahertz, and rescaling a coordinate is arithmetic on the array rather than -anything the result knows about. +data dimensions, ndim=0`. The same split is worth remembering for anything you +draw on the axes `plot` returns: they are in the figure's units, so marking the +peak is `ax.axvline(f01 / 1e9)`. ## Adapting it diff --git a/docs/examples/rabi.md b/docs/examples/rabi.md index 22be77d..daaa11b 100644 --- a/docs/examples/rabi.md +++ b/docs/examples/rabi.md @@ -222,7 +222,7 @@ pip install "qprogram[viz]" besides `IQ` gives a line per quadrature: ```python -result.plot(m0, value_label="Readout response") +result.plot(m0, value=qp.plotting.Quantity("Readout response")) ``` ![Readout response against drive amplitude. I rises to a maximum of 1 at 0.5 V and falls back to 0 by 1.0 V, while Q stays flat at 0.](../assets/plots/rabi-light.png#only-light) @@ -236,12 +236,13 @@ attributes, and the axis reads them: data.coords["gain"].attrs # {"long_name": "Drive amplitude", "units": "V"} ``` -`value_label` is there because the other axis has no such source: what a -demodulated point means is the readout chain's business, not the program's. The -call returns the matplotlib `Axes`, so anything else the figure does not decide -is a method away on it. [Plotting results](../guide/plotting.md) has the rest: -heatmaps and scatters, the `channels` argument, themes, and registering a -renderer of your own. +`value=` is there because the other axis has no such source: what a demodulated +point means is the readout chain's business, not the program's. A +`qp.plotting.Quantity` is also how a coordinate gets restated for the figure, +in the units you want to read it in. The call returns the matplotlib `Axes`, so +anything else the figure does not decide is a method away on it. +[Plotting results](../guide/plotting.md) has the rest: heatmaps and scatters, +the `channels` argument, themes, and registering a renderer of your own. ## Adapting it diff --git a/docs/examples/t1-and-ramsey.md b/docs/examples/t1-and-ramsey.md index 4eb5733..cdb31f6 100644 --- a/docs/examples/t1-and-ramsey.md +++ b/docs/examples/t1-and-ramsey.md @@ -200,11 +200,28 @@ against `env["delay"]` is all it takes to give the curve a shape. Without a `p_excited` argument every shot classifies as 0. The curve is the exponential the model was given, sampled a thousand shots per -point, and the scatter around it is the Bernoulli noise of that count: +point, and the scatter around it is the Bernoulli noise of that count. `delay` +was declared in nanoseconds and runs to 40000, which is not how anyone reads a +T1, so the figure restates it: + +```python +result.plot( + m0, + field=qp.MeasurementField.STATE, + coords={"delay": qp.plotting.Quantity(units="μs", transform=lambda v: v / 1000)}, + value=qp.plotting.Quantity("Excited-state population"), + style=qp.plotting.Style(markers=True), +) +``` ![Excited-state population against delay, decaying exponentially from 1 toward 0 over 40 microseconds.](../assets/plots/t1-light.png#only-light) ![Excited-state population against delay, decaying exponentially from 1 toward 0 over 40 microseconds.](../assets/plots/t1-dark.png#only-dark) +The `label` the variable was given survives the restatement and only the unit +moves, so the axis reads `Delay (μs)`. `markers=True` earns its place on a +41-point sweep, where the points are the measurement and the line between them +is interpolation. [Plotting results](../guide/plotting.md) covers the rest. + The `STATE` array has no trailing `"IQ"` dimension, because a classified outcome is one number per shot rather than a pair. `result.get(m0)` on the same handle still returns the IQ field with dims `("delay", "IQ")` and shape diff --git a/docs/guide/index.md b/docs/guide/index.md index bd8b491..d29e0d5 100644 --- a/docs/guide/index.md +++ b/docs/guide/index.md @@ -18,7 +18,7 @@ where they are used. | [Measurements and results](measurements.md) | The `measure` signature and its `fields` argument, how names are allocated and how they survive a `.qp` round trip, and `QProgramResult` access by handle, by name, and by index, with the dimensions a result carries. | | [Capabilities, diagnostics, and profiles](capabilities.md) | `PlatformCapabilities`, the routing that decides which slot checks a node, the ten diagnostic codes and what produces each, the `ExecutionPlan` and `explain()`, numeric limits, predicates, and `Profile` bundles. | | [Running programs](execution.md) | `qp.simulate` and `ReferencePlatform`: the result shapes a run produces, measurement models and the mock default, what the reference executor does not model, and what implementing `PlatformProtocol` involves. | -| [Plotting results](plotting.md) | `QProgramResult.plot`: the figure a result's shape asks for, the `channels` argument that decides what becomes of the `IQ` dimension, where an axis label comes from, the `Style` and `Theme` dataclasses, and registering a renderer of your own. | +| [Plotting results](plotting.md) | `QProgramResult.plot`: the figure a result's shape asks for, the `channels` argument that decides what becomes of the `IQ` dimension, where an axis label comes from, the `Quantity` that restates a coordinate in the units you want to read it in, the `Style` and `Theme` dataclasses, and registering a renderer of your own. | | [Saving and loading](serialization.md) | `dumps`, `loads`, `save`, and `load`: what the round trip preserves and what it drops, the format version and `require` lines, vendor activation at parse time, the normalizations the writer applies, and the `WaveformLibrary` that quoted aliases resolve through, with its own `.wfl` file. | Two worked programs, each given in full from the builder calls to the result diff --git a/docs/guide/plotting.md b/docs/guide/plotting.md index c8ba83c..fecb03a 100644 --- a/docs/guide/plotting.md +++ b/docs/guide/plotting.md @@ -92,12 +92,11 @@ the two strings are and where else they travel. The other axis is the measured quantity, and there the result has less to go on: a demodulated point is whatever the readout chain makes of it, and no unit follows from the program. It is labeled from the channel by default, `Signal` -for a pair of quadratures and `Magnitude` for their hypotenuse, and -`value_label=` says what it really is. On a heatmap the same string labels the -colour bar. +for a pair of quadratures and `Magnitude` for their hypotenuse, and `value=` +says what it really is. The same words label the colour bar of a heatmap. ```python -result.plot(m0, value_label="Readout response") +result.plot(m0, value=qp.plotting.Quantity("Readout response")) ``` For a heatmap the innermost sweep runs along the x axis and the outermost up @@ -122,6 +121,90 @@ result.plot(m0, x="a") # that variable's values, and its label result.plot(m0, x="a|b") # the sweep index, if that is what you meant ``` +## Restating a quantity + +A result carries hertz because the instrument takes hertz, and the figure of it +wants gigahertz. That is two changes at once, arithmetic on the numbers and a +new unit on the axis, and `Quantity` carries the pair so that neither can +travel without the other: + +```python +from qprogram.plotting import Quantity + +result.plot( + m0, + channels="magnitude", + coords={"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}, + value=Quantity("Readout magnitude"), +) +``` + +`coords=` is keyed by the name the axis resolved to, which is the same string +`x=` takes: the coordinate on the axis, or the dimension when no coordinate is. +A key that reaches no axis raises rather than doing nothing, since a figure +that ignored it would print the axis it was asked to change. `value=` is the +measured quantity wherever it lands: the y axis of a line, the colour bar of a +heatmap, both axes of a scatter. + +| Field | What it does | +|---|---| +| `label` | Replaces the coordinate's `long_name`, or the name the channel implies. `None` keeps it. | +| `units` | Replaces the coordinate's `units`. `None` keeps it, `""` says the numbers now carry none. | +| `transform` | Arithmetic on the values. Gets a copy of the whole array that would have been drawn, and returns one real number per value. | + +Read positionally the three are the sentence the axis makes: + +```python +result.plot(m0, coords={"freq": Quantity("Detuning", "MHz", lambda f: (f - 5e9) / 1e6)}) +``` + +A `Quantity` describes presentation only. `result.get(m0)` is still in hertz +after the figure of it has been drawn in gigahertz, which is what you want when +the next line fits a peak, and what to remember when the line after that draws +on the axes: everything you hand the returned `Axes` is in the figure's units, +so a frequency read back off the array needs the same `/ 1e9` the figure got. + +### One rule, in both directions + +A change of unit and a change of numbers travel together. Rescaling values that +carry a unit has to say what the unit is now, and a unit that contradicts the +one already there has to come with the arithmetic that earns it: + +```python +# On a coordinate that declares units="Hz": +Quantity(transform=lambda v: v / 1e9) # raises: the axis would read (Hz) over gigahertz +Quantity(units="GHz") # raises: relabels the unit, changes no number +Quantity(units="GHz", transform=lambda v: v / 1e9) # both halves, and the figure is drawn +Quantity(units="Hz", transform=lambda v: v - v[0]) # a shift keeps its unit, and says so +``` + +Both fire only where there is a claim to falsify, so a coordinate that declared +no unit, or a demodulated magnitude that has none to declare, takes either half +alone. That is also how you correct a unit the program never recorded: +`Quantity(units="V")` on an unlabeled coordinate is a statement, not a +contradiction. + +A transform is checked for the things that produce a broken figure rather than +a wrong one: it must not raise, must return the shape it was given, must return +real numbers, and must not turn a finite value into an infinity or a NaN. A NaN +the measurement itself carries, from a grid point a conditional arm never +reached, passes through untouched. What cannot be checked is whether the +arithmetic matches the unit — `Quantity(units="GHz", transform=lambda v: v / 1e6)` +is a lie no check here can catch, because `Variable.units` is free-form text +that legitimately holds `arb`, `counts` and `shots`. + +### Why this moves the data, not the tick labels + +matplotlib would let a formatter rewrite the tick text and leave the numbers +alone, and that is what `EngFormatter` and `FuncFormatter` do. This does not, +for three reasons. The figure model is numpy and xarray only, so a formatter +would be a rendering contract smuggled into the description. A transform like +`v - v[0]` or `v / v.max()` reads the whole array, which no per-tick formatter +can see. And a ticks-only rescale leaves `ax.get_xlim()`, a fit, and any +`axvline` in the old unit while the axis reads the new one, which is the +mismatch this page spends its rules preventing. The numbers on the axis are the +numbers drawn. + ## Themes A `Style` is a palette plus the handful of settings that decide how heavy the diff --git a/docs/reference/api-qprogram.md b/docs/reference/api-qprogram.md index ceadc3b..567af73 100644 --- a/docs/reference/api-qprogram.md +++ b/docs/reference/api-qprogram.md @@ -460,6 +460,10 @@ in `qprogram.plotting`, which the top level does not re-export. ::: qprogram.plotting.build_figure +::: qprogram.plotting.Quantity + options: + show_root_full_path: false + ::: qprogram.plotting.Figure options: show_root_full_path: false diff --git a/src/qprogram/plotting/__init__.py b/src/qprogram/plotting/__init__.py index e17c08c..5fd6aba 100644 --- a/src/qprogram/plotting/__init__.py +++ b/src/qprogram/plotting/__init__.py @@ -34,6 +34,7 @@ from qprogram.plotting.build import CHANNELS, IQ_DIM, KINDS, build_figure from qprogram.plotting.model import Figure, Line, Mark, Mesh, Points +from qprogram.plotting.quantity import Quantity from qprogram.plotting.renderers import ( DEFAULT_RENDERER, Renderer, @@ -55,6 +56,7 @@ "Mark", "Mesh", "Points", + "Quantity", "Renderer", "Style", "Theme", diff --git a/src/qprogram/plotting/build.py b/src/qprogram/plotting/build.py index c0c0ce1..67c854e 100644 --- a/src/qprogram/plotting/build.py +++ b/src/qprogram/plotting/build.py @@ -26,14 +26,18 @@ from __future__ import annotations +from dataclasses import dataclass from typing import TYPE_CHECKING, cast import numpy as np from qprogram.errors import ValidationError from qprogram.plotting.model import Figure, Line, Mesh, Points +from qprogram.plotting.quantity import Quantity, checked, restated, text if TYPE_CHECKING: + from collections.abc import Mapping + import xarray as xr from qprogram.plotting.model import Mark @@ -47,16 +51,38 @@ CHANNELS = ("iq", "i", "q", "magnitude", "phase") """The ways the ``"IQ"`` dimension can be turned into something plottable.""" -# Channel name -> the label for the measured quantity, when the array itself carries none. +# Channel name -> the (label, units) of the quantity it produces, for an array that names neither. +# The unit is held apart from the label rather than written into it, so that restating it is a +# change one rule can see: ``Quantity(units="deg", transform=numpy.degrees)`` composes "Phase (deg)" +# rather than "Phase (rad) (deg)", and forgetting the units= there fails like anywhere else. Only +# ``phase`` names a unit of its own — the others carry whatever the measured values carry. _CHANNEL_LABELS = { - "iq": "Signal", - "i": "I", - "q": "Q", - "magnitude": "Magnitude", - "phase": "Phase (rad)", + "iq": ("Signal", None), + "i": ("I", None), + "q": ("Q", None), + "magnitude": ("Magnitude", None), + "phase": ("Phase", "rad"), } +@dataclass(frozen=True, eq=False) +class _Resolved: + """One axis after resolution, with its label and unit still held apart. + + Attributes: + name (str): What this axis resolved to — the coordinate drawn on it, or the dimension when + no coordinate is. This is the name a ``coords`` key has to match. + values (numpy.ndarray): The positions along the axis. + label (str): The name inherited from the coordinate, before any restatement. + units (str | None): The unit inherited with it, or ``None`` for none. + """ + + name: str + values: np.ndarray + label: str + units: str | None + + def build_figure( # ruff: ignore[too-many-arguments] # every argument is one decision about the figure data: xr.DataArray, *, @@ -64,7 +90,8 @@ def build_figure( # ruff: ignore[too-many-arguments] # every argument is one d x: str | None = None, y: str | None = None, channels: str | None = None, - value_label: str | None = None, + coords: Mapping[str, Quantity] | None = None, + value: Quantity | None = None, title: str | None = None, ) -> Figure: """Describe the figure that ``data`` should be drawn as. @@ -88,18 +115,30 @@ def build_figure( # ruff: ignore[too-many-arguments] # every argument is one d takes ``"iq"`` for a line and ``"magnitude"`` for a heatmap, which needs a single surface and has no rotation to prefer I with. Rejected for an array with no ``"IQ"`` dimension, such as a ``state`` field. - value_label (str | None): Label for the measured quantity — the y axis of a line figure, the - colour bar of a heatmap. Defaults to the array's own ``long_name`` attribute, then to - its name, then to what the channel implies. + coords (collections.abc.Mapping[str, Quantity] | None): Restatements for the swept + coordinates, keyed by the name each axis resolved to — the same string ``x=`` or ``y=`` + takes, or the coordinate's own name when neither was given. Each + [`Quantity`][qprogram.plotting.Quantity] carries the arithmetic and the words it produces + together, so ``{"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}`` puts + gigahertz on the axis and says so. A key naming no axis this figure draws raises: a + figure that ignored it would print the axis it was asked to change. + value (Quantity | None): Restatement for the measured quantity — the y axis of a line, the + colour bar of a heatmap, both axes of a scatter. Its transform runs over each drawn + series separately, once per quadrature for a line and over the ``[row, column]`` grid + for a mesh, so ``lambda v: v - v[0]`` baselines each series against its own first point + and ``lambda v: v - v[:, :1]`` is the per-row spelling. title (str | None): Title for the figure. No title by default. Returns: The [`Figure`][qprogram.plotting.Figure] to hand a renderer. Raises: - ValidationError: If ``kind`` or ``channels`` is not a known name, if the array's shape does - not suit the requested kind, if ``x`` or ``y`` names something that is not a coordinate - on a plot dimension, or if a composed dimension is left without one. + ValidationError: If ``kind`` or ``channels`` is not a known name; if the array's shape does + not suit the requested kind; if ``x`` or ``y`` names something that is not a coordinate + on a plot dimension, or a composed dimension is left without one; if ``coords`` or + ``value`` holds anything but a [`Quantity`][qprogram.plotting.Quantity]; if a ``coords`` + key names no axis this figure draws; or if a restatement changes the numbers without the + unit, or the unit without the numbers. """ if kind is not None and kind not in KINDS: msg = f"kind must be one of {', '.join(KINDS)}, got {kind!r}" @@ -107,14 +146,44 @@ def build_figure( # ruff: ignore[too-many-arguments] # every argument is one d if channels is not None and channels not in CHANNELS: msg = f"channels must be one of {', '.join(CHANNELS)}, got {channels!r}" raise ValidationError(msg) + rescales = _rescales(coords) + value = checked(value, "value=") dims = tuple(str(dim) for dim in data.dims if dim != IQ_DIM) kind = kind or _infer_kind(data, dims) if kind == "scatter": - return _scatter(data, x, y, channels, title) + return _scatter(data, x, y, channels, rescales, value, title) if kind == "line": - return _lines(data, dims, x, y, channels, value_label, title) - return _heatmap(data, dims, x, y, channels, value_label, title) + return _lines(data, dims, x, y, channels, rescales, value, title) + return _heatmap(data, dims, x, y, channels, rescales, value, title) + + +def _rescales(coords: Mapping[str, Quantity] | None) -> dict[str, Quantity]: + """Copy the ``coords`` mapping, checking every value is a [`Quantity`][qprogram.plotting.Quantity]. + + The copy is what the builders pop from as they consume keys, so whatever is left at the end is + by definition a key that named nothing the figure drew. + + Args: + coords (collections.abc.Mapping[str, Quantity] | None): The caller's mapping, or ``None``. + + Returns: + A mutable copy keyed by string. + + Raises: + ValidationError: If ``coords`` is not a mapping, or holds anything but quantities. + """ + if coords is None: + return {} + try: + items = list(coords.items()) + except AttributeError as exc: + msg = ( + f"coords= must be a mapping of coordinate name to Quantity, got " + f"{type(coords).__name__}, e.g. {{'freq': Quantity(units='GHz', transform=f)}}." + ) + raise ValidationError(msg) from exc + return {str(name): cast("Quantity", checked(q, f"coords[{name!r}]")) for name, q in items} def _infer_kind(data: xr.DataArray, dims: tuple[str, ...]) -> str: @@ -166,7 +235,8 @@ def _lines( # ruff: ignore[too-many-arguments] x: str | None, y: str | None, channels: str | None, - value_label: str | None, + rescales: dict[str, Quantity], + value: Quantity | None, title: str | None, ) -> Figure: """Build a line per channel against a single plot dimension. @@ -177,7 +247,8 @@ def _lines( # ruff: ignore[too-many-arguments] x (str | None): Dimension or coordinate for the x axis. y (str | None): Must be ``None``: a line figure's y axis is the measured value. channels (str | None): Requested channel treatment. - value_label (str | None): Label for the y axis. + rescales (dict[str, Quantity]): Restatements keyed by coordinate, consumed as they are used. + value (Quantity | None): Restatement for the measured quantity. title (str | None): Figure title. Returns: @@ -197,13 +268,20 @@ def _lines( # ruff: ignore[too-many-arguments] ) raise ValidationError(msg) dim = dims[0] - positions, x_label = _axis(data, dim, x, "x") + resolved = _axis(data, dim, x, "x") + positions, x_label = _consume(rescales, resolved) + _unused(rescales, ((resolved.name, "the x axis"),), data, "line") channels = channels or _default_channels(data, "line") + label, units = _measured(data, channels) marks: tuple[Mark, ...] = tuple( - Line(x=positions, y=np.asarray(values.transpose(dim).values), label=label) - for label, values in _channels(data, channels, "line") + Line( + x=positions, + y=restated(value, np.asarray(values.transpose(dim).values), "value="), + label=series, + ) + for series, values in _channels(data, channels, "line") ) - return Figure(marks=marks, x_label=x_label, y_label=_value_label(data, channels, value_label), title=title) + return Figure(marks=marks, x_label=x_label, y_label=text(value, label, units, "value="), title=title) def _heatmap( # ruff: ignore[too-many-arguments] @@ -212,7 +290,8 @@ def _heatmap( # ruff: ignore[too-many-arguments] x: str | None, y: str | None, channels: str | None, - value_label: str | None, + rescales: dict[str, Quantity], + value: Quantity | None, title: str | None, ) -> Figure: """Build a single coloured surface over two plot dimensions. @@ -223,7 +302,8 @@ def _heatmap( # ruff: ignore[too-many-arguments] x (str | None): Dimension or coordinate for the x axis. y (str | None): Dimension or coordinate for the y axis. channels (str | None): Requested channel treatment; must name a single surface. - value_label (str | None): Label for the colour bar. + rescales (dict[str, Quantity]): Restatements keyed by coordinate, consumed as they are used. + value (Quantity | None): Restatement for the coloured values and the colour bar. title (str | None): Figure title. Returns: @@ -240,19 +320,100 @@ def _heatmap( # ruff: ignore[too-many-arguments] ) raise ValidationError(msg) x_dim, y_dim = _mesh_dims(data, dims, x, y) - columns, x_label = _axis(data, x_dim, x, "x") - rows, y_label = _axis(data, y_dim, y, "y") + across = _axis(data, x_dim, x, "x") + up = _axis(data, y_dim, y, "y") + columns, x_label = _consume(rescales, across) + rows, y_label = _consume(rescales, up) + _unused(rescales, ((across.name, "the x axis"), (up.name, "the y axis")), data, "heatmap") channels = channels or _default_channels(data, "heatmap") ((_, values),) = _channels(data, channels, "heatmap") + label, units = _measured(data, channels) mesh = Mesh( x=columns, y=rows, - values=np.asarray(values.transpose(y_dim, x_dim).values), - label=_value_label(data, channels, value_label), + values=restated(value, np.asarray(values.transpose(y_dim, x_dim).values), "value="), + label=text(value, label, units, "value="), ) return Figure(marks=(mesh,), x_label=x_label, y_label=y_label, title=title) +def _consume(rescales: dict[str, Quantity], resolved: _Resolved) -> tuple[np.ndarray, str]: + """Take the restatement for one resolved axis out of the mapping and apply it. + + Popping as the figure is built is what makes a silent no-op inexpressible: a key is either + consumed by an axis or it is left over for `_unused` to raise on. + + Args: + rescales (dict[str, Quantity]): The remaining restatements. Mutated. + resolved (_Resolved): The axis to draw. + + Returns: + The positions along the axis and the text to label it with. + + Raises: + ValidationError: If the restatement changes the numbers without the unit, or the unit + without the numbers, or its transform misbehaves. + """ + where = f"coords[{resolved.name!r}]" + quantity = rescales.pop(resolved.name, None) + return ( + restated(quantity, resolved.values, where), + text(quantity, resolved.label, resolved.units, where), + ) + + +def _unused( + rescales: dict[str, Quantity], + drawn: tuple[tuple[str, str], ...], + data: xr.DataArray, + kind: str, +) -> None: + """Raise for every ``coords`` key no axis consumed, all of them in one message. + + Three mistakes end up here and they have three different fixes: a typo, a real coordinate that + lost the axis to a sibling on a composed dimension, and a dimension name where the coordinate + along it is what gets drawn. The message tells them apart and then lists what this figure + actually draws, so the caller does not have to work out the difference. + + Args: + rescales (dict[str, Quantity]): Whatever is left after every axis has taken its own. + drawn (tuple[tuple[str, str], ...]): The ``(name, role)`` of each axis this figure draws. + data (xarray.DataArray): The array being plotted, for the listing of what is on it. + kind (str): The figure kind, to name it in the message. + + Raises: + ValidationError: If anything is left. + """ + if not rescales: + return + reasons = "; ".join(_unused_reason(key, data) for key in sorted(rescales)) + listing = ", ".join(f"{name!r} ({role})" for name, role in drawn) + msg = ( + f"{reasons}. This {kind} draws: {listing}. The measured quantity is not keyed here — name " + f"it with value=Quantity(...). Coordinates on this result: " + f"{', '.join(str(name) for name in data.coords) or 'none'}." + ) + raise ValidationError(msg) + + +def _unused_reason(key: str, data: xr.DataArray) -> str: + """Say which of the three mistakes one leftover key is. + + Args: + key (str): The unconsumed ``coords`` key. + data (xarray.DataArray): The array being plotted. + + Returns: + A clause naming what the key turned out to be. + """ + prefix = f"coords[{key!r}]" + if key in data.dims: + return f"{prefix} names a dimension, and this figure draws a coordinate along it, not the sweep index" + if key in data.coords: + return f"{prefix} names a coordinate this figure does not draw" + return f"{prefix} names nothing on this result" + + def _mesh_dims( data: xr.DataArray, dims: tuple[str, ...], @@ -316,8 +477,8 @@ def _dim_of(data: xr.DataArray, dims: tuple[str, ...], name: str, argument: str) raise ValidationError(msg) -def _axis(data: xr.DataArray, dim: str, requested: str | None, argument: str) -> tuple[np.ndarray, str]: - """Resolve the positions and the label for one axis. +def _axis(data: xr.DataArray, dim: str, requested: str | None, argument: str) -> _Resolved: + """Resolve the positions, the name and the inherited label of one axis. Args: data (xarray.DataArray): The array being plotted. @@ -326,7 +487,7 @@ def _axis(data: xr.DataArray, dim: str, requested: str | None, argument: str) -> argument (str): ``"x"`` or ``"y"``, for the error messages. Returns: - The positions along the axis and the text to label it with. + What this axis draws, still unrestated. Raises: ValidationError: If ``requested`` is not a coordinate on ``dim``, or if the dimension @@ -341,7 +502,7 @@ def _axis(data: xr.DataArray, dim: str, requested: str | None, argument: str) -> if len(candidates) == 1: return _coordinate(data, dim, candidates[0]) if not candidates: - return np.arange(data.sizes[dim]), dim + return _Resolved(name=dim, values=np.arange(data.sizes[dim]), label=dim, units=None) choices = " or ".join(f"{argument}={name!r}" for name in candidates) msg = ( f"Dimension {dim!r} composes {len(candidates)} swept variables, so it carries no single " @@ -351,8 +512,8 @@ def _axis(data: xr.DataArray, dim: str, requested: str | None, argument: str) -> raise ValidationError(msg) -def _coordinate(data: xr.DataArray, dim: str, name: str) -> tuple[np.ndarray, str]: - """Return one coordinate's values and its axis label. +def _coordinate(data: xr.DataArray, dim: str, name: str) -> _Resolved: + """Return one coordinate's values, with its name and unit still held apart. Args: data (xarray.DataArray): The array being plotted. @@ -360,15 +521,24 @@ def _coordinate(data: xr.DataArray, dim: str, name: str) -> tuple[np.ndarray, st name (str): The coordinate's name, or ``dim`` itself for a dimension with no coordinate. Returns: - The values along the axis and the text to label it with. + What this axis draws, still unrestated. """ - if name not in data.coords: - # A dimension named explicitly but carrying no coordinate: plot against the sweep index. - return np.arange(data.sizes[dim]), name + if name not in data.coords or data.coords[name].dims != (dim,): + # A dimension carrying no coordinate of its own, or a name that belongs to another + # dimension: either way this axis has no values but its own index. xarray allows a + # coordinate named after one dimension to live on a second, and the executor builds exactly + # that when one variable is swept at two nesting levels, so taking the name at face value + # here would draw the other dimension's values under this one's label. + return _Resolved(name=name, values=np.arange(data.sizes[dim]), label=name, units=None) coord = data.coords[name] - label = str(coord.attrs.get("long_name") or name) + label = coord.attrs.get("long_name") units = coord.attrs.get("units") - return np.asarray(coord.values), f"{label} ({units})" if units else label + return _Resolved( + name=name, + values=np.asarray(coord.values), + label=str(label) if label else name, + units=str(units) if units else None, + ) def _default_channels(data: xr.DataArray, kind: str) -> str | None: @@ -407,7 +577,7 @@ def _channels(data: xr.DataArray, channels: str | None, kind: str) -> list[tuple for both quadratures at once. """ if IQ_DIM not in data.dims: - if channels not in {"iq", None}: + if channels is not None: msg = ( f"channels={channels!r} needs an 'IQ' dimension; {_shape(data)} has none. " f"A 'state' field is already one number per point." @@ -432,35 +602,38 @@ def _channels(data: xr.DataArray, channels: str | None, kind: str) -> list[tuple return [("Phase", cast("xr.DataArray", np.arctan2(quadrature, in_phase)))] -def _value_label(data: xr.DataArray, channels: str | None, requested: str | None) -> str: - """Choose the label for the measured quantity. +def _measured(data: xr.DataArray, channels: str | None) -> tuple[str, str | None]: + """Return the inherited label and unit of the measured quantity. + + The array's own ``long_name`` is read first, then its name, then the name the channel implies. + The unit is the channel's when the channel defines one — only ``"phase"`` does, since an + arctangent is radians whatever went into it — and otherwise the array's own. Args: - data (xarray.DataArray): The array being plotted, read for its own attributes. + data (xarray.DataArray): The array being plotted. channels (str | None): The channel treatment in force. - requested (str | None): The caller's label, which wins when given. Returns: - The axis or colour-bar text. + The ``(label, units)`` a [`Quantity`][qprogram.plotting.Quantity] restates. """ - if requested is not None: - return requested - long_name = data.attrs.get("long_name") - if long_name: - units = data.attrs.get("units") - return f"{long_name} ({units})" if units else str(long_name) - if data.name: - return str(data.name) - if channels is None: - return "Value" - return _CHANNEL_LABELS[channels] - - -def _scatter( + label, units = _CHANNEL_LABELS.get(channels, ("Value", None)) if channels is not None else ("Value", None) + if units is not None: + # A channel declares a unit only where it made a new quantity out of the pair, and there its + # own name belongs with its own unit: the array names the values that went in, not the + # arctangent that came out. + return label, units + attribute = data.attrs.get("units") + inherited = data.attrs.get("long_name") or data.name + return (str(inherited) if inherited else label), (str(attribute) if attribute else None) + + +def _scatter( # ruff: ignore[too-many-arguments] data: xr.DataArray, x: str | None, y: str | None, channels: str | None, + rescales: dict[str, Quantity], + value: Quantity | None, title: str | None, ) -> Figure: """Build I against Q, every other dimension flattened into the cloud. @@ -470,25 +643,45 @@ def _scatter( x (str | None): Must be ``None``: the x axis of a scatter is the in-phase quadrature. y (str | None): Must be ``None``: the y axis is the other one. channels (str | None): Must be ``None``: the axes of a scatter *are* the quadratures. + rescales (dict[str, Quantity]): Must be empty: a scatter draws no coordinate. + value (Quantity | None): Restatement for the pair. Its ``units`` and ``transform`` reach + both axes; a ``label`` is refused, since I and Q already name themselves. title (str | None): Figure title. Returns: A figure holding one [`Points`][qprogram.plotting.Points] mark. Raises: - ValidationError: If the array has no ``"IQ"`` dimension, or if any of the three arguments - that choose an axis was given. + ValidationError: If the array has no ``"IQ"`` dimension, if any of the arguments that choose + an axis was given, or if ``value`` carries a label. """ if IQ_DIM not in data.dims: msg = f"kind='scatter' plots I against Q, and {_shape(data)} has no 'IQ' dimension." raise ValidationError(msg) - named = [name for name, value in (("x", x), ("y", y), ("channels", channels)) if value is not None] + named = [name for name, given in (("x", x), ("y", y), ("channels", channels)) if given is not None] + if rescales: + named.append("coords") if named: + pointer = " A scatter draws no coordinate; restate the quadratures with value=." if rescales else "" msg = ( f"kind='scatter' already puts I on one axis and Q on the other; " - f"{', '.join(named)} has nothing left to choose." + f"{', '.join(named)} has nothing left to choose.{pointer}" ) raise ValidationError(msg) - in_phase = np.asarray(data.sel({IQ_DIM: "I"}).values).reshape(-1) - quadrature = np.asarray(data.sel({IQ_DIM: "Q"}).values).reshape(-1) - return Figure(marks=(Points(x=in_phase, y=quadrature),), x_label="I", y_label="Q", title=title) + if value is not None and value.label is not None: + msg = ( + "value=Quantity(label=...) names one quantity, and a scatter's two axes are I and Q, " + "which already name themselves — one label on both would hide which is which. Pass " + "units= and transform= to restate the pair, and title= to name the figure." + ) + raise ValidationError(msg) + units = data.attrs.get("units") + units = str(units) if units else None + in_phase = restated(value, np.asarray(data.sel({IQ_DIM: "I"}).values).reshape(-1), "value=") + quadrature = restated(value, np.asarray(data.sel({IQ_DIM: "Q"}).values).reshape(-1), "value=") + return Figure( + marks=(Points(x=in_phase, y=quadrature),), + x_label=text(value, "I", units, "value="), + y_label=text(value, "Q", units, "value="), + title=title, + ) diff --git a/src/qprogram/plotting/quantity.py b/src/qprogram/plotting/quantity.py new file mode 100644 index 0000000..b2b8851 --- /dev/null +++ b/src/qprogram/plotting/quantity.py @@ -0,0 +1,288 @@ +# Copyright 2026 Qilimanjaro Quantum Tech +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Restating a quantity for a figure: the numbers and the words that name them, held together. + +A result carries hertz because the instrument takes hertz, and the figure of it wants gigahertz. +That is two changes at once — arithmetic on the numbers and a new unit on the axis — and doing +either without the other is how an axis comes to read ``(Hz)`` over values running 4.6 to 5.4. +[`Quantity`][qprogram.plotting.Quantity] carries the pair, which is what lets the builder refuse the +half-done version. + +The module imports numpy and the error hierarchy and nothing else, so it stays on the numeric side +of the seam that [`build_figure`][qprogram.plotting.build_figure] sits on. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING + +import numpy as np + +from qprogram.errors import ValidationError + +if TYPE_CHECKING: + from collections.abc import Callable + + +@dataclass(frozen=True) +class Quantity: + """One quantity restated: what to call it, what unit to read it in, and how to get there. + + A ``Quantity`` describes presentation only. It never touches the array, so + ``data.coords["freq"]`` is still in hertz after the figure of it has been drawn in gigahertz. + The two sides part company there: the drawn numbers moved, so anything handed to the axes + afterwards is in the figure's units, and a frequency read back off the array needs the same + arithmetic the figure got. + + One rule is enforced, in both directions: **a change of unit and a change of numbers travel + together.** A ``transform`` over values that carry a unit must say what the unit is now, and a + ``units`` that contradicts the one already there must come with the arithmetic that earns it. + Either half alone would produce an axis whose numbers and label disagree, which is the + plausible-looking wrong figure this type exists to prevent. What cannot be checked is whether + the arithmetic matches the unit: ``Quantity(units="GHz", transform=lambda v: v / 1e6)`` is a lie + no check here can catch, because ``Variable.units`` is free-form text and legitimately holds + ``"arb"``, ``"counts"`` and ``"shots"``. + + Attributes: + label (str | None): Name for the quantity, replacing the coordinate's ``long_name`` or the + name the channel implies. ``None`` keeps the inherited one. + units (str | None): Unit to read the numbers in, replacing the coordinate's ``units`` + attribute. ``None`` keeps the inherited one, and ``""`` says the numbers now carry no + unit at all — a ratio, a normalised population. + transform (Callable[[numpy.ndarray], numpy.ndarray] | None): Arithmetic on the values, + called with the whole array that would otherwise have been drawn and returning one real + number per value. It gets a copy, so an in-place transform cannot reach the stored + result, and it is called once per drawn series, so write it pure. + + Raises: + ValidationError: If all three are ``None``, so the object restates nothing; if ``label`` or + ``units`` is not a string; or if ``transform`` is not callable. + """ + + label: str | None = None + units: str | None = None + transform: Callable[[np.ndarray], np.ndarray] | None = None + + def __post_init__(self) -> None: + """Reject a ``Quantity`` that could not restate anything, before any data exists. + + Raises: + ValidationError: As documented on the class. + """ + if self.label is None and self.units is None and self.transform is None: + msg = ( + "Quantity() restates nothing. Give it a label=, units=, a transform=, or some of " + "the three; leave the argument out entirely to keep what the array already says." + ) + raise ValidationError(msg) + for name, value in (("label", self.label), ("units", self.units)): + if value is not None and not isinstance(value, str): + msg = f"Quantity {name} must be a string, got {type(value).__name__}" + raise ValidationError(msg) + if self.transform is not None and not callable(self.transform): + msg = ( + f"Quantity transform must be callable, got {type(self.transform).__name__}. It is " + f"the arithmetic that restates the values, so write it as a function of the array." + ) + raise ValidationError(msg) + + +def checked(value: object, where: str) -> Quantity | None: + """Return ``value`` if it is a [`Quantity`][qprogram.plotting.Quantity] or ``None``, and raise otherwise. + + The gate runs before anything reads a field off the argument, so a wrong type gives the message + below rather than an ``AttributeError`` from somewhere further in. + + Args: + value (object): Whatever the caller passed. + where (str): How to name the argument in the error, e.g. ``"value="`` or ``"coords['freq']"``. + + Returns: + The quantity, or ``None``. + + Raises: + ValidationError: If ``value`` is anything else. + """ + if value is None or isinstance(value, Quantity): + return value + if isinstance(value, str): + hint = ( + f"A bare string names the quantity without saying what unit to read it in; write it as Quantity({value!r})." + ) + elif callable(value): + hint = ( + "A bare function rescales the numbers without saying what they are now, which is how " + "an axis comes to read '(Hz)' over gigahertz; wrap it as " + "Quantity(units='GHz', transform=f)." + ) + else: + hint = "Wrap it as Quantity(label=..., units=..., transform=...)." + msg = f"{where} must be a Quantity, got {type(value).__name__}. {hint}" + raise ValidationError(msg) + + +def restated(quantity: Quantity | None, values: np.ndarray, where: str) -> np.ndarray: + """Run one transform over an array and check what came back. + + The input is copied first: the arrays reaching here share memory with the stored result, and the + ordinary numpy spelling of a baseline (``v -= v[0]``) would otherwise rewrite the measurement + the figure is of. + + What is checked is the transform's shape and dtype, and whether it turned a finite value into a + non-finite one. A value the measurement itself carries as NaN — the executor writes one into a + grid point a conditional arm never reached — passes through untouched. + + Args: + quantity (Quantity | None): The restatement, or ``None`` for none. + values (numpy.ndarray): The numbers to restate. + where (str): How to name the argument that carried it, in any error. + + Returns: + The restated numbers, or ``values`` unchanged when there is no transform. + + Raises: + ValidationError: If the transform raises, returns a different shape, returns something other + than real numbers, or introduces a non-finite value. + """ + if quantity is None or quantity.transform is None: + return values + try: + restated_values = np.asarray(quantity.transform(np.array(values, copy=True))) + except Exception as exc: + msg = ( + f"{where} raised {type(exc).__name__}: {exc}. It is called once with a numpy array of " + f"shape {values.shape} and must return one number per value, so write it as arithmetic " + f"over the whole array rather than over a single point." + ) + raise ValidationError(msg) from exc + if restated_values.shape != values.shape: + msg = ( + f"{where} returned shape {restated_values.shape} for an input of shape {values.shape}. " + f"A transform restates each value in place; select points with data.sel() before " + f"plotting rather than inside it." + ) + raise ValidationError(msg) + if not _is_real(restated_values): + msg = ( + f"{where} returned dtype {restated_values.dtype}, and an axis is drawn on real numbers. " + f"Return the restated values themselves — numpy.abs(v) or v.real for a complex " + f"result — and use label= for the words." + ) + raise ValidationError(msg) + _check_finite(values, restated_values, where) + return restated_values + + +def text(quantity: Quantity | None, label: str, units: str | None, where: str) -> str: + """Compose the text for one quantity, with the restatement applied. + + This holds the rule the type exists for: a change of unit and a change of numbers travel + together. It fires only where there is a claim to falsify — a non-empty inherited unit — so a + coordinate that declared none, or a demodulated magnitude that has none to declare, takes a bare + transform or a bare ``units`` without complaint. + + Args: + quantity (Quantity | None): The restatement, or ``None`` for none. + label (str): The inherited name. + units (str | None): The inherited unit, or ``None`` for none. + where (str): How to name the argument that carried it, in any error. + + Returns: + ``"Label (unit)"``, or the label alone when there is no unit. + + Raises: + ValidationError: If a transform rescales values whose inherited unit was not restated with + it, or if a unit contradicts the inherited one with no arithmetic to earn the change. + """ + if quantity is None: + return _joined(label, units) + if quantity.units is None: + if quantity.transform is not None and units: + msg = ( + f"{where} rescales the values, so the inherited unit {units!r} no longer describes " + f"them and the axis would read ({units}) over numbers that are not in {units}. Pass " + f"units= for what they are now, units='' if they are now a bare ratio, or " + f"units={units!r} if the transform leaves the unit alone, as subtracting a baseline " + f"does." + ) + raise ValidationError(msg) + return _joined(quantity.label if quantity.label is not None else label, units) + if quantity.units and quantity.transform is None and units and quantity.units != units: + msg = ( + f"{where} relabels the unit from {units!r} to {quantity.units!r} without changing the " + f"numbers, so the axis would read ({quantity.units}) over values still in {units}. Pass " + f"the transform= that converts them, or correct the unit on the variable the " + f"coordinate came from." + ) + raise ValidationError(msg) + return _joined(quantity.label if quantity.label is not None else label, quantity.units) + + +def _joined(label: str, units: str | None) -> str: + """Put a label and a unit together the way an axis reads them. + + Args: + label (str): The quantity's name. + units (str | None): Its unit, or ``None`` or ``""`` for none. + + Returns: + ``"Label (unit)"``, or the label alone. + """ + return f"{label} ({units})" if units else label + + +def _is_real(values: np.ndarray) -> bool: + """Report whether an array holds real numbers, which is what an axis is drawn on. + + Args: + values (numpy.ndarray): The array to inspect. + + Returns: + ``True`` for a real numeric dtype, ``False`` for complex, text, or anything else. + """ + return np.issubdtype(values.dtype, np.number) and not np.issubdtype(values.dtype, np.complexfloating) + + +def _check_finite(values: np.ndarray, restated_values: np.ndarray, where: str) -> None: + """Raise when the transform turned a finite value non-finite. + + The comparison is elementwise and against the input, so a NaN the measurement already carried is + not blamed on the transform, and one pre-existing NaN does not disable the check for the rest of + the array. It is skipped when the input is not real numbers, since `numpy.isfinite` has + nothing to say about a text coordinate. + + Args: + values (numpy.ndarray): What the transform was given. + restated_values (numpy.ndarray): What it returned. + where (str): How to name the argument that carried it, in the error. + + Raises: + ValidationError: If any value that was finite no longer is. + """ + if not _is_real(values): + return + introduced = np.isfinite(values) & ~np.isfinite(restated_values) + if not introduced.any(): + return + first = int(np.flatnonzero(introduced.reshape(-1))[0]) + before = values.reshape(-1)[first] + after = restated_values.reshape(-1)[first] + msg = ( + f"{where} turned {int(introduced.sum())} of {int(np.isfinite(values).sum())} finite values " + f"into inf or nan, the first at index {first} of the flattened array ({before} became " + f"{after}). Check for a division by zero or a logarithm of a non-positive value, and clip " + f"or shift the input first if the transform has a domain." + ) + raise ValidationError(msg) diff --git a/src/qprogram/result.py b/src/qprogram/result.py index 834eaf0..b0a780a 100644 --- a/src/qprogram/result.py +++ b/src/qprogram/result.py @@ -21,14 +21,17 @@ from __future__ import annotations -from dataclasses import dataclass, field +from dataclasses import dataclass, field, replace from typing import TYPE_CHECKING, Any from qprogram.errors import ValidationError from qprogram.operations.operation import MeasurementField -from qprogram.plotting import Style, build_figure, resolve_renderer +from qprogram.plotting import Quantity, Style, build_figure, resolve_renderer +from qprogram.plotting.quantity import checked if TYPE_CHECKING: + from collections.abc import Mapping + import xarray as xr from qprogram.variable import _HandleFieldAccess, _UnassignedType @@ -38,6 +41,35 @@ _FIELD_LABELS = {MeasurementField.STATE.value: "State"} +def _field_value(value: object, field: str, kind: str | None) -> Quantity | None: + """Gate the caller's ``value=``, then fill in the label the field implies. + + The gate runs first and unconditionally: reading a field off an unchecked argument is how + ``value="Excited population"`` would become a silently discarded argument rather than an error + naming the constructor to wrap it in. A scatter takes no label at all, so the field's is not + filled in there either. + + Args: + value (object): Whatever the caller passed for ``value=``. + field (str): The measurement field being drawn. + kind (str | None): The figure kind the caller asked for, if any. + + Returns: + The [`Quantity`][qprogram.plotting.Quantity] to hand + [`build_figure`][qprogram.plotting.build_figure], or ``None``. + + Raises: + ValidationError: If ``value`` is neither a [`Quantity`][qprogram.plotting.Quantity] nor ``None``. + """ + quantity = checked(value, "value=") + label = _FIELD_LABELS.get(field) + if label is None or kind == "scatter": + return quantity + if quantity is None: + return Quantity(label=label) + return quantity if quantity.label is not None else replace(quantity, label=label) + + class MeasurementHandle: """A reference to a measurement performed by a [`QProgram`][qprogram.QProgram]. @@ -280,7 +312,8 @@ def plot( # ruff: ignore[too-many-arguments] # every argument is one decision x: str | None = None, y: str | None = None, channels: str | None = None, - value_label: str | None = None, + coords: Mapping[str, Quantity] | None = None, + value: Quantity | None = None, title: str | None = None, style: Style | None = None, renderer: str | None = None, @@ -314,10 +347,15 @@ def plot( # ruff: ignore[too-many-arguments] # every argument is one decision channels (str | None): What to make of the ``"IQ"`` dimension — ``"iq"``, ``"i"``, ``"q"``, ``"magnitude"`` or ``"phase"``. Defaults to both quadratures for a line and to the magnitude for a heatmap, which colours one surface. - value_label (str | None): Label for the measured quantity — the y axis of a line figure, - the colour bar of a heatmap. Defaults to what the field and the channel imply, since - what a demodulated point means is the readout chain's business and not the - executor's. + coords (collections.abc.Mapping[str, Quantity] | None): Restatements for the swept + coordinates, keyed by the name the axis resolved to — the same string ``x=`` takes. + A [`Quantity`][qprogram.plotting.Quantity] carries the arithmetic and the words it + produces together, so ``{"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}`` + draws the axis in gigahertz and labels it so. The array itself is untouched. + value (Quantity | None): The same for the measured quantity — the y axis of a line, the + colour bar of a heatmap, both axes of a scatter. Its label defaults to what the + field and the channel imply, since what a demodulated point means is the readout + chain's business and not the executor's. title (str | None): Title for the figure. None by default. style (Style | None): Palette and drawing weights. Defaults to [`Style`][qprogram.plotting.Style]``()``, which is the light theme. @@ -332,7 +370,8 @@ def plot( # ruff: ignore[too-many-arguments] # every argument is one decision Raises: KeyError: When the measurement or the field has no match, or ``renderer`` names none. IndexError: When ``measurement`` is a position outside the range in scope. - ValidationError: When an argument does not suit the array's shape — see + ValidationError: When an argument does not suit the array's shape, or a restatement + changes the numbers without the unit — see [`build_figure`][qprogram.plotting.build_figure]. ModuleNotFoundError: When the matplotlib renderer is used without matplotlib installed — install ``qprogram[viz]``. @@ -344,7 +383,8 @@ def plot( # ruff: ignore[too-many-arguments] # every argument is one decision x=x, y=y, channels=channels, - value_label=value_label or _FIELD_LABELS.get(str(field)), + coords=coords, + value=_field_value(value, str(field), kind), title=title, ) return resolve_renderer(renderer)(figure, style or Style(), target) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 269c001..28e9915 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -34,6 +34,7 @@ Line, Mesh, Points, + Quantity, Style, Theme, available_renderers, @@ -226,6 +227,21 @@ def test_a_lone_coordinate_on_a_bare_dimension_needs_no_choosing(): assert build_figure(data).x_label == "a" +def test_a_coordinate_belonging_to_another_dimension_is_not_this_axis_s(): + # xarray allows a coordinate named after one dimension to live on a second, and the executor + # builds exactly that when one variable is swept at two nesting levels. Taking the name at face + # value would draw the other dimension's values under this one's label. + data = xr.DataArray( + np.arange(12.0).reshape(3, 4), + dims=("a", "b"), + coords={"a": ("b", np.arange(4.0))}, + ) + mesh = build_figure(data, x="b", y="a").marks[0] + assert len(mesh.y) == data.sizes["a"] + assert np.allclose(mesh.y, [0, 1, 2]) + assert mesh.values.shape == (len(mesh.y), len(mesh.x)) + + def test_a_dimension_with_no_coordinate_at_all_plots_its_index(): data = xr.DataArray(np.zeros((3, 2)), dims=("shot", "IQ"), coords={"IQ": ["I", "Q"]}) figure = build_figure(data) @@ -271,10 +287,11 @@ def test_unknown_channels_are_rejected(): build_figure(data, channels="abs") -def test_channels_need_quadratures_to_choose_between(): +@pytest.mark.parametrize("channels", ["iq", "i", "q", "magnitude", "phase"]) +def test_every_channel_needs_quadratures_to_choose_between(channels): data = _state() with pytest.raises(ValidationError, match="needs an 'IQ' dimension"): - build_figure(data, channels="i") + build_figure(data, channels=channels) def test_an_array_without_quadratures_draws_one_unnamed_line(): @@ -283,6 +300,15 @@ def test_an_array_without_quadratures_draws_one_unnamed_line(): assert figure.y_label == "Value" +def test_a_derived_channel_names_the_quantity_it_derived(): + # The array names the values that went in; an arctangent of them is a different quantity, so + # its own name travels with its own unit rather than borrowing half of each. + data = _sweep_iq() + data.attrs = {"long_name": "Readout voltage", "units": "V"} + assert build_figure(data, channels="phase").y_label == "Phase (rad)" + assert build_figure(data, channels="magnitude").y_label == "Readout voltage (V)" + + # --------------------------------------------------------------------------- # Heatmaps # --------------------------------------------------------------------------- @@ -393,8 +419,8 @@ def test_a_line_figure_has_no_second_dimension_for_y_to_name(): # --------------------------------------------------------------------------- -def test_the_caller_s_value_label_wins(): - assert build_figure(_sweep_iq(), value_label="Readout response").y_label == "Readout response" +def test_the_caller_s_label_for_the_measured_quantity_wins(): + assert build_figure(_sweep_iq(), value=Quantity("Readout response")).y_label == "Readout response" def test_the_array_s_own_attributes_are_read_next(): @@ -429,6 +455,298 @@ def test_no_title_by_default(): assert build_figure(_sweep_iq()).title is None +# --------------------------------------------------------------------------- +# Quantity: construction +# --------------------------------------------------------------------------- + + +def test_a_quantity_that_restates_nothing_is_refused(): + with pytest.raises(ValidationError, match="restates nothing"): + Quantity() + + +@pytest.mark.parametrize("field", ["label", "units"]) +def test_the_words_of_a_quantity_must_be_words(field): + with pytest.raises(ValidationError, match=f"Quantity {field} must be a string"): + Quantity(**{field: 1e-9}) + + +def test_the_arithmetic_of_a_quantity_must_be_arithmetic(): + with pytest.raises(ValidationError, match="transform must be callable"): + Quantity(units="GHz", transform=1e-9) + + +def test_a_quantity_reads_positionally_as_the_sentence_the_axis_does(): + quantity = Quantity("Detuning", "MHz", abs) + assert (quantity.label, quantity.units, quantity.transform) == ("Detuning", "MHz", abs) + + +# --------------------------------------------------------------------------- +# Restating a coordinate +# --------------------------------------------------------------------------- + + +_HERTZ = np.linspace(4.6e9, 5.4e9, 5) + + +def _hertz() -> xr.DataArray: + """A frequency sweep whose coordinate declares a name and a unit, as the executor writes them.""" + freq = xr.DataArray(_HERTZ, dims="freq", attrs={"long_name": "Drive frequency", "units": "Hz"}) + values = np.stack([np.arange(5.0), np.arange(5.0) * 2], axis=-1) + return xr.DataArray(values, dims=("freq", "IQ"), coords={"freq": freq, "IQ": ["I", "Q"]}) + + +def test_a_restatement_moves_the_numbers_and_the_unit_together(): + figure = build_figure(_hertz(), coords={"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}) + assert figure.x_label == "Drive frequency (GHz)" + assert np.allclose(figure.marks[0].x, _HERTZ / 1e9) + + +def test_a_restatement_can_rename_as_well_as_rescale(): + figure = build_figure(_hertz(), coords={"freq": Quantity("Detuning", "MHz", lambda v: (v - 5e9) / 1e6)}) + assert figure.x_label == "Detuning (MHz)" + assert np.allclose(figure.marks[0].x, [-400.0, -200.0, 0.0, 200.0, 400.0]) + + +def test_a_label_alone_leaves_the_unit_it_inherited(): + assert build_figure(_hertz(), coords={"freq": Quantity("Frequency")}).x_label == "Frequency (Hz)" + + +def test_an_empty_unit_drops_the_one_it_inherited(): + assert build_figure(_hertz(), coords={"freq": Quantity(units="")}).x_label == "Drive frequency" + + +def test_a_unit_the_coordinate_never_declared_is_taken_as_a_correction(): + data = _sweep_iq(attrs={"long_name": "Drive amplitude"}) + assert build_figure(data, coords={"gain": Quantity(units="V")}).x_label == "Drive amplitude (V)" + + +def test_rescaling_without_saying_the_new_unit_is_refused(): + data = _hertz() + with pytest.raises(ValidationError, match="no longer describes them"): + build_figure(data, coords={"freq": Quantity(transform=lambda v: v / 1e9)}) + + +def test_renaming_the_unit_without_the_arithmetic_is_refused(): + data = _hertz() + with pytest.raises(ValidationError, match="without changing the numbers"): + build_figure(data, coords={"freq": Quantity(units="GHz")}) + + +def test_a_shift_that_keeps_its_unit_says_so_by_repeating_it(): + figure = build_figure(_hertz(), coords={"freq": Quantity(units="Hz", transform=lambda v: v - v[0])}) + assert figure.x_label == "Drive frequency (Hz)" + assert figure.marks[0].x[0] == 0.0 + + +def test_a_coordinate_with_no_unit_takes_a_bare_transform(): + data = _sweep_iq(attrs={"long_name": "Shot"}) + figure = build_figure(data, coords={"gain": Quantity(transform=lambda v: v * 2)}) + assert figure.x_label == "Shot" + + +def test_the_array_the_figure_came_from_is_left_alone(): + data = _hertz() + before = data.coords["freq"].values.copy() + build_figure(data, coords={"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}) + assert np.array_equal(data.coords["freq"].values, before) + + +def test_an_in_place_transform_cannot_reach_the_stored_result(): + data = _hertz() + before = data.coords["freq"].values.copy() + + def baseline(values): + values -= values[0] + return values + + build_figure(data, coords={"freq": Quantity(units="Hz", transform=baseline)}) + assert np.array_equal(data.coords["freq"].values, before) + + +def test_both_axes_of_a_heatmap_can_be_restated(): + figure = build_figure( + _grid_iq(), + channels="i", + coords={ + "amp": Quantity(units="mV", transform=lambda v: v * 1e3), + "dur": Quantity(units="us", transform=lambda v: v / 1e3), + }, + ) + assert (figure.x_label, figure.y_label) == ("dur (us)", "Flux amplitude (mV)") + assert np.allclose(figure.marks[0].y, [0.0, 1000.0]) + + +def test_a_composed_dimension_is_keyed_by_the_coordinate_that_won_the_axis(): + figure = build_figure(_composed(), x="a", coords={"a": Quantity(units="mV", transform=lambda v: v * 1e3)}) + assert figure.x_label == "Gain (mV)" + + +def test_the_sweep_index_of_a_composed_dimension_is_keyed_by_the_dimension(): + figure = build_figure(_composed(), x="a|b", coords={"a|b": Quantity("Sweep step")}) + assert figure.x_label == "Sweep step" + + +# --------------------------------------------------------------------------- +# A key that reaches no axis +# --------------------------------------------------------------------------- + + +def test_a_misspelled_key_names_what_the_figure_draws(): + data = _hertz() + with pytest.raises(ValidationError, match="names nothing on this result"): + build_figure(data, coords={"frequency": Quantity("Frequency")}) + + +def test_the_error_lists_the_axes_with_their_roles(): + data = _grid_iq() + with pytest.raises(ValidationError, match=r"'dur' \(the x axis\), 'amp' \(the y axis\)"): + build_figure(data, channels="i", coords={"nope": Quantity("X")}) + + +def test_the_error_points_at_the_argument_the_measured_quantity_uses(): + data = _hertz() + with pytest.raises(ValidationError, match="name it with value=Quantity"): + build_figure(data, coords={"nope": Quantity("X")}) + + +def test_a_sibling_coordinate_that_lost_the_axis_is_told_apart_from_a_typo(): + data = _composed() + with pytest.raises(ValidationError, match=r"'b'\] names a coordinate this figure does not draw"): + build_figure(data, x="a", coords={"b": Quantity("B")}) + + +def test_a_dimension_name_where_a_coordinate_is_drawn_is_told_apart_too(): + data = _composed() + with pytest.raises(ValidationError, match="names a dimension, and this figure draws a coordinate"): + build_figure(data, x="a", coords={"a|b": Quantity("Step")}) + + +def test_every_unused_key_is_reported_at_once(): + data = _hertz() + with pytest.raises(ValidationError, match=r"'first'.*'second'"): + build_figure(data, coords={"second": Quantity("B"), "first": Quantity("A")}) + + +# --------------------------------------------------------------------------- +# The type gates +# --------------------------------------------------------------------------- + + +def test_a_bare_function_says_what_it_is_missing(): + data = _hertz() + with pytest.raises(ValidationError, match="A bare function rescales the numbers"): + build_figure(data, coords={"freq": lambda v: v / 1e9}) + + +def test_a_bare_string_says_what_to_wrap_it_in(): + data = _sweep_iq() + with pytest.raises(ValidationError, match=r"write it as Quantity\('Readout response'\)"): + build_figure(data, value="Readout response") + + +def test_a_coords_argument_that_is_not_a_mapping_is_refused(): + data = _sweep_iq() + with pytest.raises(ValidationError, match="must be a mapping"): + build_figure(data, coords=[("gain", Quantity("G"))]) + + +# --------------------------------------------------------------------------- +# What a transform is checked for +# --------------------------------------------------------------------------- + + +def test_an_exception_inside_a_transform_names_the_argument_that_carried_it(): + data = _hertz() + with pytest.raises(ValidationError, match=r"coords\['freq'\] raised IndexError"): + build_figure(data, coords={"freq": Quantity(units="GHz", transform=lambda v: v[99])}) + + +def test_a_transform_that_changes_the_shape_is_refused(): + data = _hertz() + with pytest.raises(ValidationError, match=r"returned shape \(2,\) for an input of shape \(5,\)"): + build_figure(data, coords={"freq": Quantity(units="GHz", transform=lambda v: v[:2])}) + + +def test_a_transform_that_returns_complex_numbers_is_refused(): + data = _hertz() + with pytest.raises(ValidationError, match="an axis is drawn on real numbers"): + build_figure(data, coords={"freq": Quantity(units="GHz", transform=lambda v: v.astype(complex))}) + + +def test_a_transform_that_introduces_a_non_finite_value_names_the_first_one(): + data = _hertz() + with pytest.raises(ValidationError, match=r"turned 5 of 5 finite values into inf or nan"): + build_figure(data, coords={"freq": Quantity(units="GHz", transform=lambda v: np.full_like(v, np.nan))}) + + +def test_a_nan_the_measurement_already_carried_is_not_blamed_on_the_transform(): + data = _sweep_iq(n=4) + data.values[0, 0] = np.nan + figure = build_figure(data, channels="i", value=Quantity(transform=lambda v: v * 2)) + assert np.isnan(figure.marks[0].y[0]) + + +def test_a_coordinate_that_is_not_numbers_skips_the_finiteness_check(): + data = xr.DataArray( + np.zeros((3, 2)), + dims=("label", "IQ"), + coords={"label": ["a", "b", "c"], "IQ": ["I", "Q"]}, + ) + figure = build_figure(data, coords={"label": Quantity(transform=lambda v: np.arange(len(v), dtype=float))}) + assert np.allclose(figure.marks[0].x, [0, 1, 2]) + + +# --------------------------------------------------------------------------- +# Restating the measured quantity +# --------------------------------------------------------------------------- + + +def test_the_measured_values_of_a_line_are_restated_per_series(): + data = _sweep_iq(n=3) + figure = build_figure(data, value=Quantity("Change", transform=lambda v: v - v[0])) + assert figure.y_label == "Change" + assert [float(mark.y[0]) for mark in figure.marks] == [0.0, 0.0] + + +def test_the_coloured_values_of_a_heatmap_are_restated_with_their_bar(): + figure = build_figure( + _grid_iq(), + channels="i", + value=Quantity("Population transferred", "%", lambda v: v * 100), + ) + mesh = figure.marks[0] + assert mesh.label == "Population transferred (%)" + assert np.allclose(mesh.values, _grid_iq().sel(IQ="I").transpose("amp", "dur").values * 100) + + +def test_a_scatter_restates_both_quadratures_at_once(): + data = _sweep_iq(n=4) + figure = build_figure(data, kind="scatter", value=Quantity(units="mV", transform=lambda v: v * 1e3)) + assert (figure.x_label, figure.y_label) == ("I (mV)", "Q (mV)") + assert np.allclose(figure.marks[0].x, data.sel(IQ="I").values * 1e3) + assert np.allclose(figure.marks[0].y, data.sel(IQ="Q").values * 1e3) + + +def test_a_scatter_refuses_one_label_for_its_two_axes(): + data = _sweep_iq() + with pytest.raises(ValidationError, match="which already name themselves"): + build_figure(data, kind="scatter", value=Quantity("Readout")) + + +def test_a_scatter_draws_no_coordinate_to_restate(): + data = _sweep_iq() + with pytest.raises(ValidationError, match="A scatter draws no coordinate"): + build_figure(data, kind="scatter", coords={"gain": Quantity("G")}) + + +def test_the_unit_of_a_phase_is_its_own_and_can_be_restated(): + data = _sweep_iq() + assert build_figure(data, channels="phase").y_label == "Phase (rad)" + figure = build_figure(data, channels="phase", value=Quantity(units="deg", transform=np.degrees)) + assert figure.y_label == "Phase (deg)" + + # --------------------------------------------------------------------------- # Themes and styles # --------------------------------------------------------------------------- @@ -673,10 +991,49 @@ def fake(figure, style, target=None): # ruff: ignore[unused-function-argument] def test_plot_takes_a_label_for_the_measured_quantity(): result, handle = _rabi_result() - ax = result.plot(handle, value_label="Readout response") + ax = result.plot(handle, value=Quantity("Readout response")) assert ax.get_ylabel() == "Readout response" +def test_plot_restates_a_coordinate_for_the_axis(): + result, handle = _rabi_result() + ax = result.plot(handle, coords={"gain": Quantity(units="mV", transform=lambda v: v * 1e3)}) + assert ax.get_xlabel() == "Drive amplitude (mV)" + assert np.allclose(ax.lines[0].get_xdata(), [0.0, 250.0, 500.0, 750.0, 1000.0]) + + +def test_plot_leaves_the_result_in_the_units_it_was_measured_in(): + result, handle = _rabi_result() + result.plot(handle, coords={"gain": Quantity(units="mV", transform=lambda v: v * 1e3)}) + assert np.allclose(result.get(handle).coords["gain"].values, [0.0, 0.25, 0.5, 0.75, 1.0]) + + +def test_plot_fills_in_the_label_a_field_implies_and_yields_to_the_caller_s(): + result, handle = _rabi_result() + implied = result.plot(handle, field=qp.MeasurementField.STATE) + assert implied.get_ylabel() == "State" + named = result.plot(handle, field=qp.MeasurementField.STATE, value=Quantity("Excited population")) + assert named.get_ylabel() == "Excited population" + + +def test_plot_restates_a_field_whose_label_it_supplies(): + result, handle = _rabi_result() + ax = result.plot(handle, field=qp.MeasurementField.STATE, value=Quantity(units="%", transform=lambda v: v * 100)) + assert ax.get_ylabel() == "State (%)" + + +def test_plot_refuses_a_bare_string_where_a_quantity_belongs(): + result, handle = _rabi_result() + with pytest.raises(ValidationError, match="must be a Quantity, got str"): + result.plot(handle, field=qp.MeasurementField.STATE, value="Excited population") + + +def test_plot_of_a_scatter_takes_no_label_from_the_field(): + result, handle = _rabi_result() + ax = result.plot(handle, kind="scatter", value=Quantity(units="mV", transform=lambda v: v * 1e3)) + assert (ax.get_xlabel(), ax.get_ylabel()) == ("I (mV)", "Q (mV)") + + def test_plot_reports_a_missing_field_the_way_get_does(): result, handle = _rabi_result() with pytest.raises(KeyError, match="has no field 'raw'"): From ee91739e6231ea72abab2489c54b3bf3270dc59a Mon Sep 17 00:00:00 2001 From: Vyron Vasileiadis Date: Wed, 2 Sep 2026 05:31:47 +0300 Subject: [PATCH 5/9] Clear the SonarCloud findings the restatement opened Fifteen pytest.raises blocks built their Quantity inside the block. A Quantity rejects its own arguments, so the assertion covered the constructor as well as the call under test; hoisting it above the with is also what makes those tests say the error comes from build_figure. The string naming the measured quantity's argument in an error becomes a constant. A coordinate's restatement is named by the key that carried it; the measured quantity has no key, only the argument, and it was spelled out nine times. --- src/qprogram/plotting/build.py | 22 ++++++++++------- tests/test_plotting.py | 45 ++++++++++++++++++++++------------ 2 files changed, 43 insertions(+), 24 deletions(-) diff --git a/src/qprogram/plotting/build.py b/src/qprogram/plotting/build.py index 67c854e..bd02cc6 100644 --- a/src/qprogram/plotting/build.py +++ b/src/qprogram/plotting/build.py @@ -45,6 +45,10 @@ IQ_DIM = "IQ" """The dimension carrying the in-phase and quadrature halves of one measured point.""" +# How the measured quantity's argument is named in an error. A coordinate's restatement is named by +# the key that carried it, ``coords['freq']``; the measured quantity has no key, only this argument. +_VALUE = "value=" + KINDS = ("line", "heatmap", "scatter") """The figure shapes [`build_figure`][qprogram.plotting.build_figure] knows how to build.""" @@ -147,7 +151,7 @@ def build_figure( # ruff: ignore[too-many-arguments] # every argument is one d msg = f"channels must be one of {', '.join(CHANNELS)}, got {channels!r}" raise ValidationError(msg) rescales = _rescales(coords) - value = checked(value, "value=") + value = checked(value, _VALUE) dims = tuple(str(dim) for dim in data.dims if dim != IQ_DIM) kind = kind or _infer_kind(data, dims) @@ -276,12 +280,12 @@ def _lines( # ruff: ignore[too-many-arguments] marks: tuple[Mark, ...] = tuple( Line( x=positions, - y=restated(value, np.asarray(values.transpose(dim).values), "value="), + y=restated(value, np.asarray(values.transpose(dim).values), _VALUE), label=series, ) for series, values in _channels(data, channels, "line") ) - return Figure(marks=marks, x_label=x_label, y_label=text(value, label, units, "value="), title=title) + return Figure(marks=marks, x_label=x_label, y_label=text(value, label, units, _VALUE), title=title) def _heatmap( # ruff: ignore[too-many-arguments] @@ -331,8 +335,8 @@ def _heatmap( # ruff: ignore[too-many-arguments] mesh = Mesh( x=columns, y=rows, - values=restated(value, np.asarray(values.transpose(y_dim, x_dim).values), "value="), - label=text(value, label, units, "value="), + values=restated(value, np.asarray(values.transpose(y_dim, x_dim).values), _VALUE), + label=text(value, label, units, _VALUE), ) return Figure(marks=(mesh,), x_label=x_label, y_label=y_label, title=title) @@ -677,11 +681,11 @@ def _scatter( # ruff: ignore[too-many-arguments] raise ValidationError(msg) units = data.attrs.get("units") units = str(units) if units else None - in_phase = restated(value, np.asarray(data.sel({IQ_DIM: "I"}).values).reshape(-1), "value=") - quadrature = restated(value, np.asarray(data.sel({IQ_DIM: "Q"}).values).reshape(-1), "value=") + in_phase = restated(value, np.asarray(data.sel({IQ_DIM: "I"}).values).reshape(-1), _VALUE) + quadrature = restated(value, np.asarray(data.sel({IQ_DIM: "Q"}).values).reshape(-1), _VALUE) return Figure( marks=(Points(x=in_phase, y=quadrature),), - x_label=text(value, "I", units, "value="), - y_label=text(value, "Q", units, "value="), + x_label=text(value, "I", units, _VALUE), + y_label=text(value, "Q", units, _VALUE), title=title, ) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 28e9915..51d5f52 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -523,14 +523,16 @@ def test_a_unit_the_coordinate_never_declared_is_taken_as_a_correction(): def test_rescaling_without_saying_the_new_unit_is_refused(): data = _hertz() + quantity = Quantity(transform=lambda v: v / 1e9) with pytest.raises(ValidationError, match="no longer describes them"): - build_figure(data, coords={"freq": Quantity(transform=lambda v: v / 1e9)}) + build_figure(data, coords={"freq": quantity}) def test_renaming_the_unit_without_the_arithmetic_is_refused(): data = _hertz() + quantity = Quantity(units="GHz") with pytest.raises(ValidationError, match="without changing the numbers"): - build_figure(data, coords={"freq": Quantity(units="GHz")}) + build_figure(data, coords={"freq": quantity}) def test_a_shift_that_keeps_its_unit_says_so_by_repeating_it(): @@ -594,38 +596,44 @@ def test_the_sweep_index_of_a_composed_dimension_is_keyed_by_the_dimension(): def test_a_misspelled_key_names_what_the_figure_draws(): data = _hertz() + coords = {"frequency": Quantity("Frequency")} with pytest.raises(ValidationError, match="names nothing on this result"): - build_figure(data, coords={"frequency": Quantity("Frequency")}) + build_figure(data, coords=coords) def test_the_error_lists_the_axes_with_their_roles(): data = _grid_iq() + coords = {"nope": Quantity("X")} with pytest.raises(ValidationError, match=r"'dur' \(the x axis\), 'amp' \(the y axis\)"): - build_figure(data, channels="i", coords={"nope": Quantity("X")}) + build_figure(data, channels="i", coords=coords) def test_the_error_points_at_the_argument_the_measured_quantity_uses(): data = _hertz() + coords = {"nope": Quantity("X")} with pytest.raises(ValidationError, match="name it with value=Quantity"): - build_figure(data, coords={"nope": Quantity("X")}) + build_figure(data, coords=coords) def test_a_sibling_coordinate_that_lost_the_axis_is_told_apart_from_a_typo(): data = _composed() + coords = {"b": Quantity("B")} with pytest.raises(ValidationError, match=r"'b'\] names a coordinate this figure does not draw"): - build_figure(data, x="a", coords={"b": Quantity("B")}) + build_figure(data, x="a", coords=coords) def test_a_dimension_name_where_a_coordinate_is_drawn_is_told_apart_too(): data = _composed() + coords = {"a|b": Quantity("Step")} with pytest.raises(ValidationError, match="names a dimension, and this figure draws a coordinate"): - build_figure(data, x="a", coords={"a|b": Quantity("Step")}) + build_figure(data, x="a", coords=coords) def test_every_unused_key_is_reported_at_once(): data = _hertz() + coords = {"second": Quantity("B"), "first": Quantity("A")} with pytest.raises(ValidationError, match=r"'first'.*'second'"): - build_figure(data, coords={"second": Quantity("B"), "first": Quantity("A")}) + build_figure(data, coords=coords) # --------------------------------------------------------------------------- @@ -647,8 +655,9 @@ def test_a_bare_string_says_what_to_wrap_it_in(): def test_a_coords_argument_that_is_not_a_mapping_is_refused(): data = _sweep_iq() + pairs = [("gain", Quantity("G"))] with pytest.raises(ValidationError, match="must be a mapping"): - build_figure(data, coords=[("gain", Quantity("G"))]) + build_figure(data, coords=pairs) # --------------------------------------------------------------------------- @@ -658,26 +667,30 @@ def test_a_coords_argument_that_is_not_a_mapping_is_refused(): def test_an_exception_inside_a_transform_names_the_argument_that_carried_it(): data = _hertz() + quantity = Quantity(units="GHz", transform=lambda v: v[99]) with pytest.raises(ValidationError, match=r"coords\['freq'\] raised IndexError"): - build_figure(data, coords={"freq": Quantity(units="GHz", transform=lambda v: v[99])}) + build_figure(data, coords={"freq": quantity}) def test_a_transform_that_changes_the_shape_is_refused(): data = _hertz() + quantity = Quantity(units="GHz", transform=lambda v: v[:2]) with pytest.raises(ValidationError, match=r"returned shape \(2,\) for an input of shape \(5,\)"): - build_figure(data, coords={"freq": Quantity(units="GHz", transform=lambda v: v[:2])}) + build_figure(data, coords={"freq": quantity}) def test_a_transform_that_returns_complex_numbers_is_refused(): data = _hertz() + quantity = Quantity(units="GHz", transform=lambda v: v.astype(complex)) with pytest.raises(ValidationError, match="an axis is drawn on real numbers"): - build_figure(data, coords={"freq": Quantity(units="GHz", transform=lambda v: v.astype(complex))}) + build_figure(data, coords={"freq": quantity}) def test_a_transform_that_introduces_a_non_finite_value_names_the_first_one(): data = _hertz() + quantity = Quantity(units="GHz", transform=lambda v: np.full_like(v, np.nan)) with pytest.raises(ValidationError, match=r"turned 5 of 5 finite values into inf or nan"): - build_figure(data, coords={"freq": Quantity(units="GHz", transform=lambda v: np.full_like(v, np.nan))}) + build_figure(data, coords={"freq": quantity}) def test_a_nan_the_measurement_already_carried_is_not_blamed_on_the_transform(): @@ -730,14 +743,16 @@ def test_a_scatter_restates_both_quadratures_at_once(): def test_a_scatter_refuses_one_label_for_its_two_axes(): data = _sweep_iq() + quantity = Quantity("Readout") with pytest.raises(ValidationError, match="which already name themselves"): - build_figure(data, kind="scatter", value=Quantity("Readout")) + build_figure(data, kind="scatter", value=quantity) def test_a_scatter_draws_no_coordinate_to_restate(): data = _sweep_iq() + coords = {"gain": Quantity("G")} with pytest.raises(ValidationError, match="A scatter draws no coordinate"): - build_figure(data, kind="scatter", coords={"gain": Quantity("G")}) + build_figure(data, kind="scatter", coords=coords) def test_the_unit_of_a_phase_is_its_own_and_can_be_restated(): From 12445cd2b297353fb1994e43f244eb1e94e90ab9 Mon Sep 17 00:00:00 2001 From: Vyron Vasileiadis Date: Wed, 2 Sep 2026 11:29:11 +0300 Subject: [PATCH 6/9] regenerate documentation plots --- .demos/plotting.ipynb | 0 docs/assets/plots/cz-chevron-dark.png | Bin 64019 -> 63339 bytes docs/assets/plots/cz-chevron-light.png | Bin 64713 -> 63955 bytes docs/assets/plots/qubit-spectroscopy-dark.png | Bin 42079 -> 38064 bytes .../assets/plots/qubit-spectroscopy-light.png | Bin 43168 -> 39133 bytes docs/assets/plots/rabi-dark.png | Bin 48421 -> 48426 bytes docs/assets/plots/rabi-light.png | Bin 49944 -> 49939 bytes docs/assets/plots/t1-dark.png | Bin 40325 -> 40956 bytes docs/assets/plots/t1-light.png | Bin 41432 -> 42179 bytes docs/examples/qubit-spectroscopy.md | 4 ++-- 10 files changed, 2 insertions(+), 2 deletions(-) create mode 100644 .demos/plotting.ipynb diff --git a/.demos/plotting.ipynb b/.demos/plotting.ipynb new file mode 100644 index 0000000..e69de29 diff --git a/docs/assets/plots/cz-chevron-dark.png b/docs/assets/plots/cz-chevron-dark.png index ebb4c04ff66e5dc0c244955241c68d700fdfd5b6..71e2f5663f1f256d86aa204dae860bbd44641e51 100644 GIT binary patch literal 63339 zcmeFZXH-*byEZy$0wPrny@Oanuc3EP6vP^&H$frvUIGXTh!8-fNs(q-QUVe>K|q4i zEf5GjG^KY!2%L$o_3r)d{hl+<&+o^VF*0EAgv>dgdDrW@?iqj8)QI^w&v5_%m@gXZ zUjqP|B>PH~G&^2j-kU*O~g9TkI|eEf>`TeN+7&nA!5rt2cL0?I#%Rdwh@m`1Wlydahm&Ina{% z?(NUFni@Yw=LUN+*1pli{dpPpdozUtB7a_AHLO1*{Q3K-bN~0(qn-FaVjteR=Cf++ z|9(9-GcXY6Id(#Of~*q0cf*u?URv4+Va?AGPkSfpMd(ik&l7d7ob10}KyxG&jf~s2 z)#XgN(}jkpsD(P?Gf#K12ZRX5D(tT;9`(&WoUH$_pS}n?(3~m%dTm4=+nypC8@ka) zmTc6p`Ey7B@SW|!SqF|s%R1un3q@1DHBGI_g^?~CvdDYXaqF;6EDp)LdV1o@?OWGA zNmB$269vAR7>#0oKHnC2_x^p`^yllc!C!7DC@8$FDmkr1{*2OF@%%b{E<@3c<=3xY zeFI~U8bbpd$(Ry`2QN8McYYtXXimzyA#QM>;c+;5d#Y{C5j=0LL;207w6UfWdXG+g zIy&D%!2_VX`%0X?NYKPbl>KCZ<=R9vE79_Bf2T2Mlk!w*IMi-v{dvv8a_B^zV1sP_ z+qbft2g~(`I#3%Q^36jfw*kJcEDcUA(i-a|895*R$NFQc{1;|z2!jnICIG-9_bw_Z zD^mgLy{(nK`#jfQU2g3#FO>1a%VcZ#z8Y+Di72YZ?P&Y^D{{mKxD)E=u%xZ)u%(6B z%*yhh&r8OyzXkdK=-f@mVG~@C8w$h2cVzv4DZGaVyGZj_{q{Cvdj*9P+Tr0eJiO9G z@KSFllA2IEfh*L&6G1IBTkP#?o0mda8`k!C8g^TJ86E&LGc&vRR#eQ`V1@GqDxg=3 z%o7{}5Q0^bl!yy+-m#)nI3jg|4(r+tzq!%n}wQb>O1 z=?VY}HccZJaA$spjfdvreO^DVjfAa*V|z;l&!0aJ085CH(WL4sjLnw6!>fdCO$GN| zFQ6Iih^w=%MoxFwKjGD)YJJ39ZS$eNl&OZjrpmFNpH;+p-)^MF`>dDf>=K{cF@VYf zW!9c8q!+jlbZ#RfPr-9OMHWcPV^K7WFy+Om3)3gfNd0W@BBYMjE`>34Ab;+B$YGs! zDV~e&?WL!k-f8bSy+E=XgKS!%`J{D^osq1TCO7tPL{XZkB0V~1SvpCb$lPRKdO#(L zlyea?4(nJ^-)x9h?-BIssxRJgJgA?XV|roPHK(^tew3|+AEAN^n02WAz=!ii64B&Z zQlN)cZ%dCLtnJ>AW1=$)14T_@LodLxV%(~Seh;oUOW!$iMetPAcC6U%yJGON z)E+n(3`FKuQw~Wh5yv=t^STKK5tgbs;SYo$3kMf7g4D@vS5!ac&2w0P*m;{V)3&(3 z6Ew1ZzV^4VY^qUye#?9DqM~ZI$GH((Qd+7>_V4Zv_cs4BH;-n}ENefhG8mEefi zR6FxKP@QAZ5jb3MIXwcauzau8AT%T{e)8t~BqPk&@rVJw?5@s9xlqRVcg6@;D zauMYSU%Ye!-!`w0Wk@M7Nh}+nq;5RvQqvKO#qmJiR#Iv&Ma<12XiWAWcU!P9Yu#yy z5g-M_zxS<&7MhP|_t39rXyc&yT5>%OagpLd9R*Ed4laoc!y=^=V<@C`LRhbCPZ{Se z<1qcE^e}vRk=sd5aGz!2*RQKLt)tUs?|%3Ywi>WgJr=}I#F;f~2sW}hJ3Fg{%?thF zm&P#W}TX#wdjNmSB1ytuD_-MlK5aZ z-sqh=x<@J0=N>68>BTbR2Ad9yZc{AP1#p7nflHGGl%#?70PtNGD2?|W^2=d=`RkJECr1ruY=TJ!e5!tIzH>cB;o%w_{QP*Vr?iqs5NB?BrxEv<%2ALjG)!!7+|d94 zuTuSK&=A*tMC@#pmXSW2A!D{Nn9{?>Fw&*VnX1eS1C5E+YJq+fvfE#`?e{jhxzs$= z4~P+aCfQmMEX>TzZ{EE#Jpa6fsaK0&r1ku_znpsdlELP_R^T?YX{$FP!kX~jk_;Ir z3GY-v+8t{0;jz+#diC}{3mWOc2q_aVvisM8Bu}EvmS=y*59OI=ooLyBk)Xx>J~}nv zLsiuz{rI7jz`?GB46;T436CNV;I+NTy+8X?!h3J?tvcn@pNj3;{iEx`p#)oZnl^ej z-N58hwm0tC&~)sDQd6u+x|H=s6{oaKGjaTo<^KKq=9ZQT+uH$FO<_xeL$KN1Sak(@mCcM6`uBJhwKEd0%XyjhS1DgzZ0{w4^qGK~HjIb@0BQ*2AMC>AH6vGxQu>liUt+lLmEmn6wPqyRg@B)nVUd67VTrxd<#3 zFDhAW9fH_X zSic$koh8}NJ`i8J76V;j;`n<_xBtS@pADyj2w}@UEEw#6Elvpdd5md%^(;$*X1_p+ zqQYr8C6`2&6ugy`PE((Jsk0g+`m?a=slK(5FylIjIVV>zMKhQ z2!r65b~MTs@eQ^-K*b2^9@m9^O5*72`IYYVS2C(AS=zlW<)4qF zhCQ!BN1lBP5Mwz-3st`xk5Li3HI)j6zYm{;(NeK=H(ExKw=nTp?RC1xknTi3s1_?! zo#j}cHrMEPjwejKx)rp`d>GpR55knmWfpS@fwv-aOQ zJ7c9u@;!?5EzKhSz(fjB94$p4HTQ}`u${uMem(Ui1T=`L8`1=(;j$tR#yYGzdPLzO z0a2t3zI1vLoBbRI<9e`@+Uj_))Lb;NazdDtLud(h$2JEnVokWF&@3@PPQ%`1DdJ+W0v(t`JKad4e?1r2CR$vc{D zOBY}KH;eh(-Du|}RyvqX{^QbbGvi$HNsMfN0`=_i(rXHCy*B#tqdeq^XiDzljyMsj zKJ^RLkb+qqbsKpv|$x1bI2s&Y}n+QP}@Qz%BvKe$rxUJHxMT_I&&ZQ{_ z1v~o4o2by>U;l~V2HOA21h-RN7_}Y_B^~p1AD4Ez z{AF*GJwZO@8y=GB{TWHaaY@t>m?*C~UC-3XkA+UY7&+Er^QDxF7$zo2X4suAUJcXm}QCoIo!DoLXW;}Bdzve2n>0>?0v zuW{BLvO=+O{8+O!QglvXSdY*CDQ@Q--cICal^2zZ8=0_o1~eH-l3X}lziIVKy5)`< zJ>2fvSH!)dq*xpuDx1|_@2@mU1%o5oYORbNp`xa6%ah0Vl$4#hN+(Hs4)q51juSK~ zsIEwWX8e|g?sL;Nz5-uksBHOCdX9_hYl00c7@kJ|mE1%OF8yOtr>GkH{$Ez2v=fGl zdFxzP%G~?&`^Z%>4RBhhd(82dD~ybA<461`L^f?CUu=v6&}@&+C|}cN;!&t<3osrz zv--JLH^LO~=m4&ovcjjgtMpUff7JYTw{i9KB!-C-?U>WHh*{jp(pycYP0KF#z6`AT zWLU!ACm=d?eK9MY1!ifm3wHe)a^|XOI9jFUKIIt;0XJirq(@AMkCG7mB6B&*XY%d} za<*j-p}!L-$JcteU{nVtuIGM+Ety9G{-=O;!3G7Zyz zJx6mXZA?J=?_#WI^U~iXL=;_lxQz2MIsI$V?Y}Kj|M4@Mdw-CbbJV~3E(ZGbBMS@6 z3#NUOQ&y?|Xez;nAgujHJC`{NWQ%ji{%Cz3@34kFI0&Nk)`KfvHaOr3h%7 zBjY-nAmd)dGJ$g4-0T)F>gcg;8ec_W(Rkc3=&L!M)Pd?;IFW$Wi&kA6H8e~y!D0c11x^5pM|E+n7ZTyD1FN$oI7$sk^NUU@ zb*dzc_xrL<%rR;7?vlU+x#_ZYejdpm(!^ItcszZH^Y2Q^K)dXNN#KW9|0xw5<(Mwd4|&H76BgC0&^9@l3P4SW;K(b0ujw`67!h9 z%&gr?V2x2%diRUCKCZ<9gU_@$$TjbE?iJRvfyJB}LL#&n8@Ec=-uiwIO+jmh3dkhh&4?gF2M*$n4AAo&%`>HOEF%uTm= zh$E4Ynaj;?lv`>eJzqMeVL!SWr?_`ENklf6DI`5SyfBfqlG-}1qCvnuJM&KsA#&}% zER6lChD}}Je>AR;eCxWxgl%MJTALklk(mqg<|GqzX0@FqFU)qhy3!!bI621fyYUT% za@ua=INT&|p)W7?%ErEMFXu-m~Arr|ZW zd7x@}wKP61#>IvB8Xf&9K@Hx|-a{XVNR*iL}sDkZdlEZOJ=F{vNfBA?o>S&ez*7fK??4od#_=n>fHrb& zQ@ygwWdO)E7Wl796wCsCMsEMX4a)&ic(JwgRJzo^@357irC9ur;KD9a=Yh{+AP+j5 zRai6t^O75dPm$#)@ATl6b4dS2>g=IM=E4L>YLQ`PpaCN-ISNF*aYC1RbXEZYa*oJ- z#*rc2ghu`Ul??x>$0pK8$n!?tC}|5)4O$N|uGf5)$nCCQEh2n(;yit#@A z46x@>5RDSVK}7A%IklXOk84k4L|d^W`VV<%ZKxy=>7vA0+FF!Z7==k`Z{tS~7DMku zcuog6%$;QtAD-qA7bQlC7q$oTYF0pQ%^T-9XB++kc-}eg@DMz+1!QZ(OXT?zPo~DD zN=|>;?sV`KJCjannxwWzW{uzGA8e3(k(cuX1{}kS*v%5+jDFe0cc*Nmx7EBSq+WHk zi;t_oVI#q!U8hn=h`pRaEdmiGfcK6sHw6CY;8>ki-wcZ z?GyfbkLyImr}CTjI|>=hdoB_ffyGf%k-M-sNBi za)^D!gOLh>F-9m^X*nGWX+d5K(NCkS_w$8_EsnVO27X_6(bwMYY(}R-2YV|Y8IIUf$oW`Ytw%KLZT|!i;CRt3`E2hX|9kdPnSKd(G1eMr9>5`=nUA#f5;Nhy6U z;WkOt84^@Cvt=G<`agE&pX3Ne{{OsE4rnLikPS9%($--4QSGjC_D(=&FY=t&( zjOGU0P>+O%PF<6{p>aKYw%%3{mWmPai{Hh)x^N445lufHWmLb6KxE{;hwG^x^rt6X z)hC&*&_PRS`^H~v1-1rsKJc-}0V?^es4y&5=t;;ZMkY!v_7S=zj|>fPBDdm%U#FUk zkzL7-i4+AGMYi446Qcg1!Cu-^f;mv#gsVVNy>5Mh}J}B+{N9*wpKP_Dm6f8&c3#%%0yQKb2ZCk>O9o^ zdF$Hx60}-|Nw|Ohh4|$TYDMVXX}oTPn1H@VXf8d?L^-7*@A){3!urgMYJbpQeDc1; zu+FWi2ykz-&@a1oF_dSMCq?{+BtK(dV#F51MR%Cy;~sL_cyP?V&F5M{cu#opgjgaT ztmh+z?k7dk-Q!^GTz$#S6b?J;#T}z!ntT|8(cThzN%1{T(`rPSV$gUoAdj}28seF7 z>nr7f{$w@-?Dl)%Psw16{y{U*2EzHboDXuv%G3Cj4|}3dFpi|47gcI)`+NzIYff`W zmMB9Xsja(lJ%bmPzB2!N3i!j9u=jy0{Qq%<;TbC3W4?fL?6m4}7p8u+vS)eUDW?0* z$}EabYBoxeUyXCbr%sl?%r>Du$IjtG1Mql?I;If@?N>gD^g}Fv_1f!baHu`3%ozFqC+iAztXxd#cx&n&5DNil-Lsid5FLN7Dy|$k~ZebeQ^O!a%si+ z)Y_a&gC+0Z^C?y-f@?;hmX@aE$2j7fk`g^Pw+pJO&;{i0{!f3ed7my}bwZC-l!r3m zv$pNriAE40>T8{OJ1QBsEiB@Dk;_b6%E%T)$H0i`!rdRz5lN!4tXsq0JGa5$l3!P+ zs=f=-qt3q+YCHmNeq3`jTI&Mo(Vy2P%G_+_UAo)9s4cf73+vS%l+@O8dp43($E>j| zO}6uWbS0K+SFGiF+Tr^w6O*!#EC+PuV!IR6Jv$LaFNSGtK>$GdlS+gnj#ott`po3z z<6{XO@_%7Aq7Vxyk*Si4h7Lwl3Ek*O4nRW2)5KH9GE#Dp@}O-R5V9jWbwTzVvA6S{ zz|uB8IukSbW&sXj!JIUp8IiH_*EZX=4sxM0i`Qoi6+R4vxEyCGUxx+*mMdTKHQK_d z1D&us&)R0y1q6HxW+i4V+N6Z?r2sDxu>k`It5WglhfiQq?JJyVac4s>3xPE?lEx?E z1YBS8%Zeve=w&-93>WJN47v}INA-gdNzWff%M%@$O$NKmPo$-VchSj}y3kZ(TXNn=^~_4V{D+4k~>Xh#%N&DV^%%`r(VJ7E@S6=8ITw6Dh2C0C9@X)pAWk}{D zmV@Bg809y-uFoI&_S-8e0J+(U^9D)k(g@qbo;zV1s6!f%qi>$?cl3gnVXlMr6m|N- zN*hSWgP-!=C!h}KN=i!NJ~;$UpUi9NvZ(Yvq_9rL9p97JDww8$?`F*^% zvuR2$a5*e&|0K#`xq%K|^~?DK=EL;T+#kGg>iT?07)T2hU3{AI*=el}aEe%Dh!ekg+a0XXH?1#8Ylpxn9hOty+Q zU+F?YQ>mu3)*tHpl(bgIc!Y+m)4WWZgKRb|{2gI-AU~R(3J^6+TI@gAUK(W{^heuG z7W{?nP0j}$Q2oxGJ6^x0w6woK;OW;9*5q9(4mDj@Cj^!}e_W8BJc&Z`*zSG3y*BWoj0my-Z%Ru)N>-0OdPGID zI?G!&V^vIV#|odhhov%MLaQXZ!A?s~LN};}#x6SuxR@EQtMCFG9uDkP&5(jZbnU9J zYHZ?DV}44m(qiad7?uU@p0wW+ZW7roF_&-D{(erH5kNQRROLhD_8BZ?lJ?cvIet`* zu&^+XWL8%#4fbZ>5bSD7riFSKN`)6hZAWtFTx`<~4k@Gyf3LXD#fSl~6xC*qcM0Vs zk~=pc(++_z7+7QI+_Uu;v(GZ7Q8CEP!f$K0z}?jVFHvDf>qSkP7?j$uKx@a2^Ns-| ziw26WW#9%6sPhbA@*qrBK)r}vEr8`t&v+lZ8pM;9t?jSwXy}*Ey72(>kNz6RtV7CD z1^J3)@9-^+Nlq1gPLxZ;>$grja}MiYu<6e&dR|-@CJ@l~e{=@DDd1=|deU4z*;>C{ zdAIv7m4HQ8X+HnM*9id$kH0L^4&ALu_HgTLvTkZc>DVwJ|=d^+H5bx`usWO77@0kmjq|8Kaj8T4gJ` zb`FdeU`{v=#-SRrsNkoW&UCNM`4k)2pLXdSGZi#%afpdr{d2yf>1lpJ0Xfj)hE;IB z+>m`RuJw8NNa$fSs07&^(4x>tS=Zqew~x%H6T3ss&?KH2QTJ5}SjG=T7uI|KEEpBZ z>1ooC06F>+ot(qmOO~3JoJ0N#*o{xpjvdMQK{GR)=$IX6>YmQ^!?4O+Pk}&mF$G zwF}at6ODo6I^dVx?aqBcj{5EY#uv}|X&khWHeB7@S|>h6%ewYeb(h}z<^pJ=1`3P{ zh6ZD=ER1)4sT_^YZE_?TzOw8nkXKL++2m45ik_$*tCR~^Q~{cYGZg1}# zO|osurtI|GceFvru_ks~tZPGiP6eDOk7>foTHHMg!4-zikc;!{-oSpHf>XPDU3??q zFgC#05l~LM+L0yB1GdC`_q&h{(}6t>zEF3XX8Sps_{t&OdyD)2aJ;0@THfOAjM({J zhk7j9^I}pwSWVGF@9MYnVfdld*d@)Lq)dbxlSfK$ywNZBk19S9PIJ|YhW9kn;g@?L zy_=s^@&chcnwW8}7ZE=_sFL46)OxKt9UY%74l3j7s4at_*PZ!%9A?qY93$(-Z6G$} zXjN(?;@=_cfLoR?H(2a&EOcSgN{!=ZY`4(!n+|yC{qckNWiI*HQ9e*EkmF)5Cm=2> zM{pDkg*vdS`FPN1Up4IE>1F3VH4c*yA zn6GT``i+Le1JefV1+tjo_3I}wh|veN8?!`tR5**vt&u1u&fdaz6~_y4PYe`z46Zwh zV%%@V5ezw(G*-7?cuqXc+dCl;vda!e@=1KZD3^k(jHXX-qn9=3N~!JO)`=Uh>*_*o z+_?3!wzhUbbR>ySGX_j?VD^hF+aFtT938Iq{<$uGy;eUumz?%DnLeX)gC;?&ykbWp_tPp^VG2x>cPYdZB*O)L3BKFv8w-@nMTx&FZ(^GKYuj{Wpy8|<0eX6J}OeZ#wn~e ziUGT;!tX5_e`O(-!T-omj-bkoSmti1Tt)!esyXdXv3oGhjiK?6Z~7fe_d1k;)o?-S zrd2*EE0sK~pyBT`eSD3*p^pVn@!eB6IPg3?2Ku^gxE_rv2P2wQ1(yt3W?7uho~~Ftnc;SlrtW_VDAY ze2q{|0b75S*@16AwE;ZdmG8pwd{O`MwpruvpLs6WQ@!NVr2Q!DeTL9`X@6Ta@2`Lt zdSU0>Wu&|i<`O>_F6>j8mF+V6c7g@!I3dIcry!-trDM~Vw~f`I06%^ zm`#=CDW}mLf4xg#%m*PmGB48)I~|o%~${vY)&54_IE*Og+8xJfN}9rtTju z;t%&FF1>g@E16(1_@Q!Z)xA+I;vlZX!r9G;zjN(aDG7#)EQ#nLgakHeo*LC>)dB;n z+I@=)W`o74vI}b!cO#cFxVFPT^BCZ^)r(yO=G^i~NSa|M85Atdzk0zf({#d8Pv)sOtZYD$7?E}SMU&T3N<7U=*o|9x-ZKjPbuHD%cZhVWQ-!lZR+OH$@m8o~nG`5KpF9^4#4iHhuciDpmjc z(ap;K5DcQ*9b9$^_)Jexu+X-P$EQ&4v;;#P=+`TcrS;_r3bWVWs0?n+5clF#M$!8{ zpr!O+C)R zAgYBjx>XF%vvPJzftPo1$RF1|mj6Dgo&gkIQPvypfNX@4h?WHKwVf#DXM_b$C~Cjstb=t$Km@uN-O%G!xh^_13bF;bl0ze^yE%wJHH$xc_ovd zl@skNX%7vWW#EFxeBlTz+WC>(4<#U@BV*=`U8O>eXT9^<>Zl286@8q{b8Ez{&)Mw) ztyUSmp@3Hh<LlMUAZEE%HMt2 z&_GSkx{PaT4DBDeteNxD_`d^XYSsRovu+0^4Gnw|yGDlsZ*OpbigfH$M@sAM#M`%S zP4$~;Jc@sMhM42;)<1SPIQG7#AJv>db`HqJDW;+pAM8*U*XDTM2Mpg)v&5jdO9#-B)> z@oIR_+Y=zji6C@I#Lirxz_%kPSph}5C&1t8_zrC@Dr2F6qM-^UEiaoXr1?&7=7yS{&bcm zJywyQ;~i56jHifXV8x~wd#bqn%a=-2gtPZSpz;2fAd6t`OYikwSL6Q1L1>O}5Xz6@ z1WqcTa;{4e*$wtkS8v}&T|N{2s=ZxPwPLLBZ_yb0xr@BYP4oa*^a%@u&D-C&8L_&| z2TFX8aGzOpFAae4Bs}&T-u5V*D*V?0sKQOjTWX-Lci_FvL$&1w-s+J$uA{ePcenAY zYj4WRj1;mOr#1Z7#cYBOhNuM*D*p-usa1Ek&S$G2`8sdEZ=08OG{0_{kafWkEa~ty zlNt?MvkM(g#z7Xs=M3zv$7JeUtd=)x4W~SuPAASAZ9+;Zism{+Ny|65z%Zp2<+^JxR9_aAy}|{ zBl!u5n+Y!&@29?T${Mw(UmE?rG)( zDlZL=cZDBS4hBH}t#HRtAix*?>}fYu8qwLjCX%)~Ozs$5H&U#*9VF`}`ibHZt7&U? z*}Temu~P9+Rda%4RWN}8_UdIp?(%cP#jmr3F|&2HoI#xjE^k+()Oc{BQEKV5i-1X6 z(x+)?lp)U@C-g-E<-swYq3}oJEIMsrxiiVljfR>FYn0KZ@X&J4ae-&gpXWCj`{G*_tgV2&na65A|>nA0yw7Uq9 z)z6Ex_R^Yi;E2uV&{5VT56w4*fc%LdVPZq?z zpUm9RwXul}9udud3(~NF(7mMPsJ4;^#@wR_ZIOUdlc`%!2py0MbKq3+aOMqcNZ#Py z9XXi{PuD}50;`{clFwALGvTQijKz}Mhu~Ih+TZ_@kLZ=#KyV4$8v$Mgvl}w$IFhkN zqW6fGt!6)yBb(=PgJt;$Ky%-X~vxKMA*Fz?o? z8@UUfF5Cv);D{DDd*MRsqn!aqP$nO=c^zesFQ2rwt#l+S9c`)iw{Cg=zxg(i$u|NK z6pz{&CC~!w=X#cQyUX&Zf!%{2W*=;t!WiG)I1Y{~8CY1rQZF8eIieX4EmZzMRU&i> zce~&~^MK@wpM#3ZF5@NFuDc;Qub}^%PHk&<0ff)eKYpk}x?VI?u69(&vYz66Hjy|Y zZF3KW>#Rds{Q0ut4%YP@+lU{-X-luc#@22>3smrDW!>3rLZv~*V$T|i?_3JK>96?8 z49iGtPdsY=k31d@<>k5b`kU)Lk9M@9k=OL9{o+_769O^IV2W*j;7qsI1ofaB_?3+x+q=ucbg4qNlY&=9S!RW9B27gD(qIGP`E||m zMyVrm0wa%;ujZsHU`Klwgrd#^HZA+%G#pgEsrx}R9JmeRkuTy@YRw$wKHVvbIC-P* zK=YbKTT<6U3|S>U4K3^Dm7u@qTGRvCGkM`@`z#YjZ89OHClcT>+<>_H(KFWALXuw@ z*~`T!)3UCt&l2HcaQ;`KBNd7FqeL}308ScF9vLjEo5V>85srx==Zc`5hVBG~Ou-I{ zAjmRz@Y#W69~ph>d%tL`EMnNN%eI`2P>rDTS{i>@>C$T;#&JXyrCeHr6>~lBG9ZId z-)o^HK^C!hLcefSFaX5rBco_!?IyIlGSviGodnuJ4B^PqRD5=?3JRkC5Rbjjr!1?P z5X472 z{mPg|5UF_1dwFq)`cVImU47*RC))Pc=d?aL=8>sqrQtCoCdkK)3c&9i*Zmb!N@1EQr#P0Qm`_KP5q{b`G;npGW)SDT@GC!5R$+WLz=~aGo7VT6wWz z1|+W?%c>UFppyO+;VDq7RRN3a<_G4p0+LBl{AK}`8+SsKNAL4Ff(nghdr5|`CzJOt zfWxJrK|kD>Tl!O|MQ7OyV@dgbL8O8g*fhsXHKD4gCt`{( z-Mnb^;gB*;VV>=_jDz{kfvn)MBZ@DzxYKKDSJr*_13T#726CSZ&#zm$%1BLf0o$|8 zJf4n|7XZ_?uy?AZ!Cm4}=Ob|r1?(GZ6~;NtmVZ4%x4B&_4Ss9<=u@4$C#OiYR;Lj9 z8J`_veg9I68D=rVs#DCgHQ4D1Zo0zqMQoR_7%qV3`s4~uis|H61S0>Ek3gz#U**H| zdOfTIh(a-+dnEIr{f{2D5G>8^{v_CGnhgI{K)&)c&bnwseI@9$`f{sifYVRQSaB~S zk(*TUS7Gd6)N2*FIm__8bIKji*7a9#FpAE>cnL7}qd^6A_QQGCB9=%qT|XA4U<>L8 z0$}mnaYyW?*$%IyGChx|X1rReofuFfyTR9dAQf*U8F3*6ro_+{AsW==jO@su34Hs3 zWVNQcOG!MoJlySTbf({Ur*oDb8{K8$q!vjp(;t#0_|1QnJW1!$lmqkSkybxEvD~<# z6SfwJeV{xR#5~uNV^C2@UTD4Cz8z?}b}l|)+t;Ocs+cpc^@21u5*$FYAKRzPkaOk% z=ZT}u3vm-;WPxUKeSpKpD`pkHdAoep+kcx(GdPpRd_qu`8j!iSe(G|T`a@*6OL^(D zXKexA0(`H7I2OK+}ulCsd!_^ZKI2SfAJ_qR`j z)*jBufcc^81(xmUnJdd7p)r5U*o*MbClZ?Jls(6&!Pd-<_=?%pO|kmoB@1kg>&kSn zfK;{?3Z%{LH|P7`yq~sb{!DYrMMU--#Ec4vMVNqW$2>J4%i$lNf)Evxqr;21-Oa_J zlzC*0;;*G#BEnPKFaS7)xNoXqqR^QQuhjnqWrwImeBG8$n~83Ur5(!@?i~CY{%*}Qdo;F)IG_j$@LGr)h55yMb5pL>$_Y;j&eBy%noZ4O{fSOr{Tju6b7L{`jpy_eJ)}z%(U;~GC?tDcpkokvIwg#rR zh+p;=5_S=YA&Kqt9ZzkFOP!>L`Eeho&s~=V@6_cNnl$~c+eR0Qubuz=ryCprk_0qk z&Ru`y(AHtD61ICapH)Ko(sDugYO?T=Io|Efj2#|k)g<1`8~UTzd9%YtO+@bF`VrLyC78JP1ER@3$9`f=#`bE_0aHoXtdJf9ip|N|EWH`YxJ@g=ue2^17s`5|Gx) zRs)|P36E2*@-xp_BuPxN$RzbMyxiI`6bW#Wcf%(lOa>kd-DS!(mtPs&CcNrzEKgC5 zeDsSCMgRV6@BT?Np`*Hs6?)c4)IW`~=Y;HlW1NLmdlh>n-PIzE^5AU!Rc-u3BPRpK zr~pii95DsBn{~*Y0#(NCb3C7ovp(~YCNT4h;Rald@d_v)1N^>c;EX4dze4CoB2(rE@SfS6iiU2rSsK&gR{CX*&$8{Zpk+s%h^+npXre&IEUF=IpTX=}+KA3I zh&2wVMTpt~8BBj6BnD4~$!Jjp2N%XHG~TLBoJxr!nmVW<@!>okzMTR0>TJka;x`vy z{821F3x6h=jq`XNW748Lz-C=DM`uyQQXVs^>p>4_GR4fS1}MfZDu)&IRQPLGgr-qc z8FtW_m~ka0s`c@=;_Svf@|Jwktv&V-dof=Qph&a|+`zX92D`!S4|3hH7%uU=^segY z+wG|IZj+lcvjiD)*^Fi76op=sw{6-)csoZy=Lc(LO4Oi6%xkTn*8bX)OTP*lkLb`zJ$momzK^~O;5t#813&v}^lc&eN~$a5FlU3f)q$}W^~WGA z3`EmWlP~*~Ax~+b{Sq5yj!YwK1Q{!~QxiKk^C+g08`*m8pz8qYa@FO*v58dLSx<~c z?i1lsz7WD!NWq1UY=dKe8AFc)s@Gi_)%K0+$8DkC!^4HB6-sK`iC zDU_L!WM%J_glv^P3Z=5CBl9TZ*h1NR9Aq3E>zMcT&gc8P@5lW|k9P{0_G(wAEV&1sTe|T&*h*lO~XH-@jwQp2c^y;guA&`Anvt zjD$e%0T;)fpcZXZYSHnu^VzRn9YI~u>yZ=0Q^nX$9 z<;maRE7TC{`V((>(_Wuh{9CVpjjry70QxxZ|5ytZ)yv-7EGVO{Y-#f3Rl~D0cFF(0by)I zLW}J$;o@gIK`qlR(v)~f$2D}md-9GzU}#|2Co=TrabEt{qKqnJzV@P=Aul5gDJn^4 zJHDFlrUZ-SW##w#QGMBH8!N?6Yd#Msx0+&QxX|J}+5d8&t0T9eUpL{&%2`wJX}vGi zyXG@@zQ@|M%!|CxP4UMLmvX#3;kZieShzkBn zYK!IT{eIb^avm^!9vgPctZb2Rr^tF{lquLD2c3tcl*pZZ`HjsviJ$~IS6>wN1a zAeT~dAwL6>+w6mS3g$thIcL7A3WU=ErUQIYmoFdWR)E%1XgWijYl5UbqU2?+~Q#9fN3(bh90oWW*i5LoG;8k+o*#ZgMSJn|WPV>y|7^^v{9m|B)g$`hJjaEw$}!xIB6Cr0U%d1(1sT>g#y^T0o}_SYg8pi&1MA0;cy1nvCg| zIJ-+sf_g7rH8$q@Y&8wa^> z^KegzskHJ;k`lh?g=P3gvkO4po2uvj4rM?-`+=rGu)QaX|rO}JrIN*}P|0~YOuj~lX z>q|l?nXhtM#npH>@1Tdfj|C%Uk2co6`}~;!3D@{-(TT`luW{WEtz^#E8%t&k{e|=`kbWNW_&N28KOvNtIg&2uEPakHCT99#@Px-@Elcx%VW)2 z7g23DCrJY_zkf3EFYM^cEd3<58ABS>r_VXp)#s_WgwfBqeO#0?pJcCG@KYlMkqH{w zQNgv2$hh0&h_g0W{O_69DBptdy7keheN5wpW~lJj*w|R!_?v5eWvIr+#;BXlFNVB9 zMU)Ra;Zs(Y0)V}oTLT26#gS7RGaBB%)3tvI>rbdfyt<=m@HGNblu+=U{Xn}tZO$G1 zoRvlRM(780pH;F&QD2_}#F6Pk$h{C^q?g!kxM%J zt-0kD2OX})F7^H{J>>@Xn;51dp4N3;)h^k$Q9E^lvkJZT=VNSCJUltH%m&Ksq)87F zA+Ny3r;EpEHk9mLSPpaRBU!YE!U>N!`>O7SLhIg`TdB(tw)|%@(#GWpz0%?X06oAatQ4U35M5=){DIc+xi>r$>81OvYJinJ7 zlN%^7JLn~P&^I^h@$4u^VXKVHt*+`V{OV+v_`DyKx~pBp*l^{}yHUEVg`9GlvOQ8UDu3E{x-!P<3ho7vleqfSJ` zjxKn}y^?mogF^E_%GBtH-wx7!Kil0dnH?Ig^7DT-rO)*Pmhl}et(W)C1yl#pj)ir1 zkMtCzzYiDLin3L&&nR-31G*FeN^ftSbLMwzH*n)$8vgyeXVtcnP`&f(g!>c+$~)@5mLLj$eUU-*XxkSstclV^!l8wy_~_n z+V8ATZT?4D#^4bb?6wEXrN@FO@JGDM&Zg1)c&i%dx}`zey-p|n?;22QrtbZWrH?RA zy*)Fn!p#_L{P*h&m?5g=cgBbDj^)E!3&kU)w9%@Zeu8H3R#Q~?ZtLrZK}?KZ>2I(0 z!pcfc)UUqAkT_XLpOHcg52K|QoUMjmn&85Xf4#dJhc#k=z%_Q}3wl*`M+s}LKB+qc z%!o?PRFu_f7(W=H`xu|yi}E#5uC5pyt6um{wE3PJf<(*x$*b&GC4fA(%3OY(a=;F!4}OCR zPT5NmfDztI5k1jh$|%3F>jH|k;M@Y_Uz}2SiT5o3cdFcVKeBh(V~wK@wV0ThS~H{B zdrOC>J=}0-*?gl&evcYq^2n)Zf7XWJ&7_iJa=w#;co+#U^4_%F>vOuwK|w~#-V;Gy zK~IyHl~pZSNyGBhS8#`40a&Ka?x;cv%K7wtMS zIOp>mq!%qM4dzRY2-eVDC;}>6M^_PaGNkqyXiA>pn=Q7R=qdxPb&FvULgt=~pvU=J z{G=OO2t(?d=NrfCV>4n&~sS>-XU6 z(TyhCq}*3=ZvBm-L=1*L`2)Y%#DlT3lQWS8XPTA@?bga3{gCx7#y@-%-rbY$(&Rc( zV%uM4#V*Pj8T!!3qcYihc(Lt|j9hQbi+HQy*8zVIh!Uh?BJ|8MLu_Xge)X`&7YVkx zQH8tRYKjyIgj?{KNMLl|Am9UF24^ZbA3+?JmU;WL6^lyM?a3Qhd-+m9JPP#Jb6lsYm3RB}WB40#L!Op>$D*Y?rlJES=oJ$Q;U;Jek#b<6X{y7f1 zBNhGU@~xR)0$Fg3pU;i!h_?9HesUTeVZ{weS2UyncoUYqbI55Ij*2KBpJ5>?-I zsH~GjNH)aLa3pxmZUF=EYpCm`-FThJ@|({=ifK|l3xdw`eZk?hyZ=R!M$;w#Aar#t zq()j;G{~`PKDc8ssI9M$S@GE&kiMtgJ%YFaRJAW8=q4lrOn15*ga2b=$Wp-x6uLGC z8)`o}Yvb2d)D>lAs)WRZi$J_V$EkO=EjAo5SSnwaZmj?MkbVS6d(z&&Ckr135SRge zN5VIAjWM(2x77=&NB?ez{(w(lw(?wV(f~w9Re7z;_pCDQ-r}ktcq9B+?e5N&y|n56 z;e9nA7pKhI+oaH`+govSZ8%+I%gj_TrXu`?dB?_I?AB!nVvD@-0Y1E^Pb~|8-b2dK z2%kL}Y5g)cZA{LmjS+tpptJlTrRrV!xPO~J!IR2_@2-1n)d!avEdQYcNtfLYWR^bQ z8q(dOYUbkTCK0+FsMus53w~5j^+SaD8%riZxbZlV@y7^&5aG2zy-~Ke)2;25l>DzJ zUhxUottoaqz4gVV`Pm)L5cAl{49zudoXom7H0(*T9tZcfHGCp8pJvcZB4uDX_{ZBX4*467f(dDh@NFi&UY6flr zJJoFio;p)lm&&nLN4ZW-KorbV-A)p6eKIZQ!1OhyX1IF}K{kM3G=})N63)_pZ&W4X zn}J)1+k9XQmyZr$7;Cfciv@i-T<&F?pr>wM<*}rv0C$k27IyOpr|aS)IJ5aPLqN5R z0f&+9KjQV>BNTF|=?K0Ac+|zK1p@S7f!pC%X38m-mOoDm_f54XrV{0V132#9-zq-q zPvyc@F&%nQue^Tzd~aTZx8QTa7TgPe>Gk1l%oG_^kq}`O!6xK z$C!<~FOIhv^Sv+);d_f~*~;NFDXEENVe&t)A#%T_*;e~p$a1l0!MGWgO(2$qr~TyO z2BVLA|8|jkOlEDbjGazKYw=w7QMR-qxiF3J*nmjEr4RXA-zuj^3LF}=#7##f!3_Z9 zip?XxvQVK$)uE19#}<>QAn6+i7kk**W>uE@PpLw`-_wBiF}pRjI{wpY!0rV+&-W(a*Z03WWpak9HlhPD!p2-voOc8EUGv zPk!m|&j2F0W55vi{n>6GX>_|}4!dgVg?88%#UDAZH53el(2sSma#Ee8l%tuf45~Rn zoC=k1g2N|B9@TVx>$9dn6aWRr6KC$-*G`{TxN{K1RN(gkrNH>w zjUA}o+JV6Q`}ZV(4yK~o8o32e*2ubwKUD71H0}>PblHG955JSHWU@9_(o;C;Kl=&v z6bQ0kNpSfy!U|Tp#VT*)zfEvqxFOlHypvq8{81~7{eQYak9Cx7s1~UvXU49JNgD1< zv>?><#4#-3S8L-JlmMx%v{P8Oefuf*^N+6D1T4ITbmvNCpV83J; zjQ(m@sHB0Re|!;s1k)d5v^;SZsjQ%TgUuPVynF<_7z~M$*3G22{b!on{jV)-6a&=- zU4-YdrgoS<*h<^v_nO7~2b|WGk*Hn>t^9M}Iv3E{QK*khY8z#imNd}rEzXw1-fF2y zf5_pv4JDTmcF#a;@lsLh?)QGfWjOj5=PqfC7qsotE>v!DZo@C_u<6ZwAqj`w*$8x9 zX>T(E*A|N?-O4S&L@W-3V#>H4nv%jw8F ztkge3FTn@4I``(^X*j@gL_dPCQj_N$4vmR%YdHx~`6;K7Z>=MJTv#9<`_G7R~2!Z{3;+V;e5R3lU2`eaWo@$LJlyVc#cWPv_FJeav%~ z9Hv9=LyM|WSs0#_qdLt#yWOY90fsLhV)q{Tc%8--eQTsWwVVERHRJ9eP6lJu`vP7b zG2L{BCL?#oqRXB<6qyJ84<3C<*phOlxbIm07Jc`iUy0bsjq+=M zi>w>s6zU4M#Mg!O7+Z^|#(OY)r>PjV3%w1QW{c)xld$q+0 zk-;@BWlk-l1&TH3gFO(XbGx`kL6dOb?=+SPv`khxdBw*6H&Pa(Wz3~@3ni%9JV(^*yX*m zC27_FmHIc>w`y2th7h=>O_@NB0*2rSbU{}<5=m(TUl%Ik-cDTiaBw(wkcK75qBE1N zno=`Q@oz%nM$xBzK;>=%zO}_$aRa!-MPwgTDZl25SzkYq$5qD2)>fo@Xw&RAiPmt*%+vsM?40hHmfYb#->Ar2hC9cJ zH~TKh2mK04=6{B(doa>^lH&+#8nx#xx>BKgCQ3w2s%@#)|Ldgb@=r=p4jelQlD%s1 z?2L)jdXss#MXhBCzGy9tmk9)~tNhbSH(Dgk5-%W3eLlW`~C z8n0zess5sE@Dr?Xw{>HMq9r87M<*JN)vt`3@8`KIQXuRLsO1hd#pG4Ny7~3{x6ZV} zUnhQ#_Mx+{8%CZ;a%Jr=kGto<#01)lS<4O0%oh0Ge!H#06B~70duK7${m(;~FH{jr zeFWf zhr=cEP!kkASWFT^fmIRYtT`Zm$jXkJk;A^lM9e65P=vKeaeeu#Ax_|t0ORMPfaxk@ z2MY(c=HSJ^Np9nCLo-HGEJ)%_#^>AJ$K!;+SDj$HxAxu5;7cgc;d8>aji{-n_xZ&` zkHsd+Q_MKciNe&e2d+qmkZN0s?>Mo_`(!n>V2htJ;$)bowuE@cCrz_OY{DDJuJ9RH zu&d!({MsE~1WsRBum#m4N0?(V?cw{Sto9gr9el&;@K!|OcoPfuHYNuCVM(J1 zO)?*=j0m4O*Gu>f4wPxVtE%@)XZhv-nCVL!l!b)y8f-;NsX%Rt{1jz!Py!M5>(+ zu_?Grd7|`y-IP9p+#T^!**}rqbbSp(bTSa?#zu%dGHm6@Lg9eZ|QiKb|+J>P>9w3 zrbU~l0^cRi#wJ%&Y=+I-hTrWwn-&h}dX2+RP>riyF2T+Uhoqiim+)-*yj^Q>7f9%E~cAf*ec~gNkUzA?Quon(%{7X{d^om7RYu6|H1b^J(&+%_~~*@Nde^kRlKYbmWUu{)Z0Bm!j*L9pi9b%j=Pr zB;DZMFr~3DM+2&nd0dJg=FlPL3pCGi|8s zZ&E%kn^MwaRF%wZ*BG2YhjPp5Bf);#Jku#z*AXNkCBQazA@w6i+0X@StL2-GO>S~0_Zj+unS`B9Y3;60E{={U zRQXNkvkGp#R84iF@iYK?hQg)w9)n>D3k&n|PAWMAX9|$$CvoUD1xvL{v>ca%pi_S{ zP;_R0{dQbZ4-2b`EBKW2xmFdW4jgsZ-1)^oIM;H42|OFm zTM2pPWEG;+?dY1EbB)cNX0H_gB6=z+k)3;GZh|ceXT_exoE0$P@Wk>JDpjk;1koLE zs1bOklF_3mk1*3`cZg{}q`DsO@cuxjJdUu9`E_n9mn_~z2P7tw`l`QTZEyr;px1jJ5ls$; ze8&Iej}WMwboH-vJ&HcG%$7ErNvMzqv>DVn_vlIk^4zCwwTJjoc(!mAAD8npWefGVS^68>blPtNYI+ao!tl`JXRVPUb*Dr~bX z6-q&S0&`ltSMubm1h{s@Ued6>f+iGH`tVYt0aK|$E2A&d{?8Qjpv;9(`qw8Fz#gBy zVjq75s4Gu95G$;&=uzgz`k>%EEUA=fJ+&6ut!Zlxk-CvBmqYrTjR&BCKaUkCQ0wwTj?FYW1_}Wx@jJKtrHvgZ;pOK zl{Iyj1fSu!sCT|f`{L^E&O9s~77G?D^fd|OSB!0r^RZPeG;Cump?Ur+;*ntK;l+~Z zmMsX%mRZ%eKlaew?wQJR{i$}9D#j;#J#AyU3uAM3uOj|DaJH&UrJ9gS!8FrZ=>|5- z`0=mJytZR9Dxw@u$|q(B-D>pC;PL%VnX*az87NfcrVftr>Kbt@Si-#xw`4d3wAz=SR{M`(*j>AKr>M1_0ZLSoZtZpN&(|YukdxLgg;QUR2b~gRdsfFH`~WU^n`cbdBq7 z-ud{DHK3L%XZIH1h*-o1JK`{{k#-H3l59g7nS&?>j8;nSk13hQ^0(^wQ&1?(@5CJ4 z2&D~Pt)%Qg;fQ$Kj3c6ulSYudg$aAWL)HF?^s-*DDb&Q~O`hy}PoHD#O#%aPz1fEC zQbd8c*PO=z-?lFDLh)B_+n4-zoFFZu|6xnjHjx7HY58UcA_;)z9h;^(COmMt?RN+s&n+qxCdj!AzMEH#OH*F zU(GRg-B8~Y;nAsKZf=)zUB?zTJnJ~wRxxWo6U5xkK_~KxUoCbtqLL&4Ndr`^$uc3~ z;R}Qi8H}w^NwjB!-dCRwD~z0jm*_6j`qUV2nW;-LF*n;Zg$IWLKyh$} zu9{cX?L6np3f$xj#ZkdgbYNZo@@jVkcqHutLn);}dnxi@&5}dXtLa%k85(0+;iTZa zE9g~Leil>Gzb2s;d-I_c=eL$YD_y3Q(1!}EPXRLcD}xC6eNbG7@T zXO&FgRytRGG?K(vVPKW(RPr||5ByECh;v}o_)jV{q4ciJ0_#0Y>XK&yMQg61-dCKl z2oO6}cD^w&Oo;T4EBYVy6{OO7V>4~%zoA-)Vw)$*>UT8}orHEfFxyob0H`4I#-Yh` z(%J1LcTya_=9nCL&XdLZU{U9Ih+V+2Fts`<=5dTh#M$koj*SyLkI2)%jnn+Myd;)3}{X_)=hib z!WgX@682!~+H#m|;czIzEv7*l)N;n4j;H_=!s{j?Rljoj5= zC1u4F^@JC9OdX6a|YcmOp;wvn+R0nTUu*DE?)KjOd2}9Ga&CgCdwkRZROO)Sq9sqCs`A zI+u^u6^`S{Y0<RgK+k|WBFCl^AwN$J^+s_@0owb@vKlLy?zZE zQdPi*vpwZ|EI6uq)JI8?2R|OB2>M~mvvt=Sq}UvuWYaxsAc!00+2?zt&wF%)o7I!L zC0g-bv+Qbh$1I3C9RiZ9|p~I6u?d2a6O-JIUvVB|L1N=Sp)8H*meEx3fjpes%Cdv^9P=I1tZzr@C zq$|^{H;C+406{C5XwMH`KyV>C*#(~wlZ|$)TzFSkS5{qCR+b$i7J=f_GRsit*PZ|xU}|9OM~}khaY&fteX6*0bw5-gBllslXoZNw*?>w>L_T; z{l}${FeIc72J+Hs=qnlU=|7RuqZjuvjBsM4et%_UNDfw7Q6j#TAf@@(Vi^~k?&}_g z8ymc-bDP+v#>RYTh-|PnL)!uH6CM?t{AXc~N=pMw$Qtw}->1^op)5+h9N$ zjIHVY9S{^Se2ztw#hjX{pod}k__ZTCe8CWvSrt~(V$xoC8&DVCQ>ABE&xb7kx)-WA zS8v1c?Tu#-`l+R%$ec*^dW%deM9;3>Ry47XG18-or=DR4Bg!|&xMJ(4l5KQhhj-uo zx>naO(@bP!BS#6ho3b}KzJRYX`a%_M^`T$VKp_gW_x^Tw0qbOiJuwP*&&QSA4U1|Q+W%tFfZJ*maJ z+R>}7`!`%vYsBU)b3ww!`A7e+b^Pkc)I4_gFEqm_Ul3zLr@WjAyN?b9k##zyR+Oi2 z#sxtK06T$e61$VSr_A*~_sU9uOLty1#594e^vGOa2{~L~0dg4z+Hj&&2S!wBS8i^d z5zafa^1j}-sncAoaPTDuIjW1!r2k>5iP#YSwJRGnRc~dU!ev<-S~C8w1e5nA@T3G) zP3%3f^Jj@i+izS`&QbLyFBWK_O5&5Jfln$zF>o8Y%TUT-6r{F@;*k)fkqx-u;3PPi zK+e77`kJ)R6&BB>(W`^5vkhc9i>+#EYTwx`+K}`_eRhNK1PVN5}~>)Zsr%LHe{lX0Y{reJRJ;9U$0C@DyJ+d#Fhi zpN@ixDO$^d-G2O!Bi1I~4SlVy(KyD4oz>jrehj_7+WYj2Lf-I9YeR)276 z@WkIVuB!3_l9>tWyv33>ABJIsMOj9qyvt4q&HxdPBSl~Whosfhudixq^4?YTnn?Ut znY|GeLSqd8=R-h}D3!0{%JSP};au|0e>T3v8rEdW?L0svB7+mB?ZcenzO1dncVpIJ?UliWkQxOaja@BnOm0M2!M912q4{)F!B;aOmsi=7 z;gDs`(C@BRI1-)n`KyqHdGV>TFsot(st1z2H@Z>`G1;=VPX+p;S7WR>JcTrM1Ksou zWgc{ihcwU3`{IwGxh+o@B}Us} zhLUsCio=RP=L&K5HO;dk$=}^L%rnYgF2sbz*0xw~H38ppNWwt>amr$&iD$Ox6>9fF#F zcRfh+zmCvz8X(ZXjX$vvk=H!CUmae4jt-pOoC+udMWzsAMB;G8(x_b?#rb7K_*Zbg zEe&*g+4)reRfv=hYgTLHtPt!AbrF=fX}P(a92|$m#Fxy%YCpk+sGa9c2{N>G&lNev zbbiufvi++ui}LC&7(g&KLlh{T@6$|32*({QXD98)eJiXR%_gZ-C{Usvtu%D!%F>S3 zE{8P3I)v=^`EhN#U2^ZZjEhy-vh@65KS(>}WGmSoTp8*(HnAAPF430XlVrU^8$$j; z#VII^4E-zS{qXCBn4#zB{F;c^!J7c!t1@0a;JbG3I}HA5Agij?BK9Yo>~ASZ?s_4l zXwIp@{}3*aH8n?U{F)NcsIlBIFx0I0D6=5s=Wjndbs6HuBC*BW(i0?e2$V27#mD%X zng_3P*Ey*c-z-uB5C&=tUv>A5VszRGC&%Ifd*Ws#$QM(OoG{y7GaG-)r-%cdA)@8F zgRAs&O4&=M2Iix8AqyqE7lVUYKtX_l#@xOMQ));VWj%nEwy$6%{h@ybhuy}a@xUaBthY=pXFia=riW@ z;%x!m&1kvafYN4160TVc{GIQ9+Pm)!Umw>4Q_A$kPt`oiWluIKwr;PGIv?9>8hYz&eLL;<5B zhD7cpL6+oX=BE{zNUUdXpfT>cHb3cVc2S#O{qT7cW+%q6N(6!+abww&iBaj`ut zsCzMiAuVrlZb7-F1KVX;p^3OgW6x{UY>5D5_DCn3&XlB1dyLI<;Hz3QBZVZ?|70R#NDJW zRA}Y>{u)?$r6iBVzmFm;8q!{RTF_=9ldf_GB9MeEw0LM97K)e z?REQrZBgMFB!k3Ve8e;KU|nL!)l1zk;y?4P{hvW)x8Xxv1bw(fAyt_gwFsf_BNM^n z;H>WH39748nj6N_8Ey>bA#@U=fq|P#`#tS9Wpl&*NY|{^s|bOt+u%!vC(%@6qe0 z9FI$VlCgC?Q2Ox%UxV(~yPh_7m*(+1(e%;PaQ3jDOytETChh*>j^YcHzegz+ZA#lh zhCaibAH)bJ;uY4AmUwctT>kvyIoSdxaF$&UkcJeew`SlF=gi`P*uPKQS4&)L&`b@Z zMb2;Cp>3p}Z(hL_)Q!PF*S9=~B6$ksOIDX1E9HRvEHcPCHxDSQquUp3U z9OyOGDILbw4x%N^1$@&p#QyH3UK2f9fzKwD^2=_~ZFE*CE9v*~^I+aa-L|2%JvfOc z(VW1;?o`Y=$codsc|l7yZlM^{xb51Jb*hx-E;#(5ntAvB5em|6kf+MrnwTCX`wawO zkmauA;Bcu6TO={H^Z&&kZwze?b>^K%D)@!cUS(o<_}q*5TbT?Ywe)bY#y9WkPMH&r zvPqz)2%tz={2=Ue!lW*IcC#4TFhQN~hoE<_E5@$UJvr(&>J2m~H`67JjDPo{z5khL zm%&@f5*$d7_a_kls}1pV+URg6MoNpC+tFgex^q9-?t%aBqB2cLHAU8ov&aa z%m64Fy`8l7@uL!|m)acl1XR)?m!FMP<>s9|-zI0t5-f(=QARTsPl`_GL`?t3M2yh|o7s>T*ApJ)?*o#9hAd*6t4vrb1BYy(L zmG9Q61gsUJM1tgdrl(j4h5;$z?e35)uNJ!^!s5Bw$$I#xyuo~o0{>rc@pmvUP@tYQ z<%E<~;z6*7LS4`o#SVVUv?<~DFqR|L2tQk?XMoovPPL8-$ded4X2bxv@cL79Tb2Pn zP?+N}zBsDTQ)uSUirZ&Q`2|tWtJ?Z~Wc9re*BIbV`4-~`(YqD4$oy&7zYT_C%<@}@ zQ6u3p1SLNE9ZL!A?DAvc;@=S2K(0r>UP*39U*8<#*KmplLw7T7EYB|i0Z`o>UnFAQ zibgcegz_RL(2UdqPc7o!%#zV*5y~!o1ZD4i!UN1*pR)3Bh!1FE@qJbuL}`Kn#Q-s~ zBDN23J5Mip$AWQ&{2)zDoAcnZn%4Vhn8LH(EsL4gfKTJze`Dgn20Y~MLTg{&hPDkx4XU1(;CNfG6b1k@F_c6 z(b7__y9}d-9GZl|A~qzvS#-wg%;fKeW3FSd@;Guj+0cJ=AF$KN@ds=CLMB1n^og^N zfJVx+^ERk;;vn0MMbz|+^LumV`PJ1`oysv)9@_UdA=9FAwXu9FR|I5FM8s!t5n;gD89CB!9tTT zzNmhA!vbkW)dK(~fOskmQxz>O!Ca%Nc-DsY4B3_2k7*mFCs*qVo_yfXSFCF~*SsWy z9EV33-<;>AY+ja1ebbnRUpf>|V@=RAb$Isb#kAE{OC&ComXYP#b?HQzpVy^z8_}_amyinsz9O05< z3I+Xls|z%&gA^k;9i2{eH>GJVIV!S8FXQPuJHe-i>uSHiec5=l|w%hUNtYo(OxK`e%hkKxZnLIb>~4XaPwESed!B*m-_-bRU33AxS&)mwAU8 z!WZN@F~rWYF|%#n`|>@8tcbUJuJ0T9*4q3`vOmS*!X{nJmH!{1kmnU)+>r+v1gBm% z80aXc4G!N+W}cl1-8q0h88+reCI8aPV|@e+pdJM7{U5m8Y?mu&{dcr%17Ypo#A+jg z>4tt0uPNQVxMDBnkmzjO`iItHo!?!~Snq<55@q;;im*Ic%EH9CZ$=ZJ_ zmYy(%S$aa3<&~dhoMMu+pLhZz4~o``jUnjmFa(6`?P~0q6pxSNG^+Nt_IA0Xe0JG) z7ku`d>UkHAN>f}^LGyCkt{?Vv2tpjbEuh^8o426j@2fCbh@Rh%KXqHM;E>PHI)06! zsE?c-e9aV#^!n!^_z5n>uTF65Z_w-O%D{9y-@7lt$b{p$!6%`t;DCyps|+U7;Zfxi zqtY>UFj%*>Bo}-y%^g^bUm{9AYfzv)EC|un-Y+O)RIVJpa)n$CPp^NwRl)IAiFDzy z9ML@TP_2aOn<)CMi-h9B0naThookL_63mzO48}3iAv8o%>_SXy8>{GWFaGD+ai|=o z%05zH+rGZ$3Tkl?JWYiPmLLv9+g$37&v7^v;#^qri*b@7{`{a=aKnT2Bs`7+CtOz& z+3dpLKqC}1LEjY`Mam9sGe=99rxfYw>b$0yG&ar7ex=;}^jvfCsgQ>I_ZL6picfa$ zF_?dtUVbYMoru$(42#qgdeq7j>y1}33lu2CM8vy3(7#HUob1KTC-lu>1zxL`FKs3y zg|pQ&O`1b(=I4J<-z^c6FluqwJ?kVH-MF?_bYL!KVs1@U9-nMN8WAL(7u=-!CNN+I z5lO-@8W?+%v$gESmD0WA?>%MC;hsX3s=ptOrXqiQ!cDzwC!oY(sx>V=og9gY)Yl&r z&x_QE7d?tXlE-E%;cS4*FMnmtY%p9~yBlnEZ-H-XAf@dfuIk>RskLcK{k3yCQOHDr zY(p$9SH-%w=NOC>dabd`hzsZZ@$Rbs64*=?p$5mRv*n%rBNI-Jv&$_-?Sb+A&-|`( zD0_hXMz!r2NQIHS(T3T!{cipGmntq2eoGFq00Q@k6bL9J;iOE?-3>CdSfrmGf0&SH zH&Op+wo<~j&zCna*XvPHTH%pmVcl>%{&BY9x zSV}hbTMBu4M$ zaV~^i2EL|djK3I~pF{=(4?^xjGMQ7*wdc8;?}YUEWGpjzC?} zc5Jhg`~KT&=i47Rlz}5mE5@zA1@G+mPdCmxGmem5T3|U9o`f|AnhB}o9(c|PZgn4+?=lAt5SqS2jKFTxr5v?x%yCUQfe zwzR+VA#7=5!g;ygL9QWGC|Yq$P1V8k?4!@u3+VOPf`z{o6H&UQZz*DQJc9x2_}6)c zKQ828B_GLXDL4~bgV)hJTz@M6_@Xbjxty{E{8tje9Bo&DH?w~-lTVBAZE-#tA~{P&7V*l*6M;U zz|eAvnT)D4y>80qX7_bWB-y^tM`qi;p=O0VmQnSHnh6!1V`qMQDyNxQ(V%l@isF)l zvRMVLN;9_6G`d}E{rpKXyue5=`zigPZ8luz*$IlHJuFpI4S><0AL!RjH7vW%=uc0M z{et|O#JwpWBfw@q<=F!Ic7Td@PFc-i-G_*XUUP(m^qE_4dU&uIxXlFQYRojgb(rKS zCtjMUxar&~wD-%r!CaITNxJ~7g&&D%wYa&Bci!9Fw+|SzkNG_L`|gbkPJs=eKyq5%fUcpfO{{D8Z$uXkrxV(8@LVqJxBe^FW%dr z=L6m7NNyS7M>W?Th3{O#OT*o0-gG zP7{lqZ{IM>{XHIOubJ@GnbE>qhOeQH1A^{k4nvo%82dz$DmZ)TgBGLV(>DG}#hA{> zjp)~-r%s$qG+E+jOlY!Elk5IUUm&gPdDb{wnDUN;)dlWHr+ovbt$uvZFDN;4_zYQ0 z4}0+C`)`(DrX+rh?=*ARqH2iv#RnIGp0OH#GB=24+)_?!f#VY&DPfs>7jFH~= z>5tasf=}hR*wtvHR1efvs0vHHEb>_YV@c3RM*Cs+`msO28F$;@j$c#kg@+2b+H6zd zKACTruT?~}B2TZ(G}wY6pRVKp*MI8o<8biDXwaTx;4k^efdUOBC#fcL5uPkENDet^ zAzc#2)cxS{A`Y9(eYXpcQ`}!bvm;YW@@MZOV07erg{63$Tm*DLW6P6j8?|lT&*2~+ zZ;>>pCa3eJp=KI-F6=Y8zSNg+-*wz6$MU~fv`+sdFGn9Jb&#`3lm}uAHbXZm??T0G zxV0%sAAwui-I7`QeGGd|S=ssMeK=F|QoR`iX*p{Yz?WRMuzRL1A~nc|^ke;qXU+8> z*{G{H!M2Wer&&|1X^XpaG2SjBJAS3d_$G?A&^jU8#YM1PweT#DG{yN|?@Oi^uXjxW zlK(1OR>1NKM9{uIOf0Rxndp}DxDV!_%#}K2R+nGkKp7UdcDa6Ru|$(Kl{)45henB~ zT%nyslS(V{XS@7WScipS9E);RbAPSnwD%n?%OOlso&^g;mMf*^sO1F_n`ru`gW{)(f|{l- zudP2;?n8IgT@rO{{VRSoa=6WcKqYKC1OWjMm&cRo1qY@s^Ssv&Cw*k2LCj{34Xzk8 zdypP9(g`!6;PzV>Pv0MX6E%bZ7%<7u!WL+W&kwQ@!GXu{4%4j^sase)#7Jzk7Vk2w z5A7NK&rG1=+NE)?^oModhQWKf_uMx`70t_xkSxs<4}3RCmgV2lVTeMX1qyV(Ti8tY z&R@`TH-yd_lKj?7E4}->gxoGi^W1iHv2sT9-Bm6oKfsu`)L>n8%>gF)h?KB$RzA`} zwVf*awsX1HyOVF=%?;v)29Fu124BmM%zMw3qebUqVJOIeV!Ar&%5!@$3FS2PD;v*_ zg-Dp;T1HQA@Zn=SbtjqyPKHU4p;*leO27glLFUUPjthOx@*tH-Qh5-?4H^1xmbmX_ z{A7Re3dY7{Jm=EP9$^3c3fH{E5B)EyoB#je>#f78?7HpYO-V|3BOTHW(ntzO2ugzp zN_R-NbV*2em(n00DP0oMozmUk+Qxf+=Q{88{qgv0-LT*_Z%XJp~IOF3O z3a$lZ7|P)2OTVtwHbizH4`>I8H0|n1(Rkivy?{a-Mt%H}`^LR%JwB{^BS_+=lqP@& zkaGbh((?_B_g<6eponi>3p!2&yOEyTl{;5go*sXR({KGIs`P7x_Uf)1LXPN_$)Si7 zz&2@Id%wqz4wcRXtwgNwr(pEes;c%dlIQQPj8@riI6(*5W-0-NNf?n3{>P6R{C2DC zV8$c#tmaHaq-_@3TU1lNi;2Jhq!IcT%LyDdi)YzoWvi9XiFCU7z&(4tW__EAajdP0wx16^&e&(0SHXGZRDR4;mEZx59?#B{MW} z{Dw%uda~rN3K|LL9e_X%1_FjlaDXzGj!$HsXwTA5(X;-{p%ro;Q}hLwX4l zI_t;64Z>Zq81nsGhq9ubrNmOwz05?$h>s47{d!g*F+IGWhIq@9i)L0mu|SP^t~{Be zMK?qyHO8UkGE@)?-BqcEAzKM5DHjWeJW?M|sb1yVvHtx$yyJ4H7gljZw$2rC(H;ZU z{0+-34R3DcZQiJR#Iw)fCg^#&fzLU(K}Mb>8RXic6ywil8Qq8bLFbLEB5SO|DyQXq z#GsJaW_>q@Ob>)I7+`2vKj_2+(;9^8#9U_2;@8t0BNExmVS))x7GBNg$~7z3kJ&<# zpk>xxFKhQfPV4Su&0=MSBjM3zcK^&`;nNdS1(4gB$0*begT zxm`jT8)|s3(UWQ>MjJ&~K$9BigA#Txo0t$jaYKXFOCW&L@Y=&s>rcQk8U!64KKi_u zFeR1Efkq^V3qX*tla7FOk*caTVM2Sw2OF^R_G-3FWS0xM9>ME*tgQ)Cg#Ye3$nL=c zy$#3ro0*a4oA%RefYt^YFk?g%oI?*BU^xjlPTR<=&Lsk>wjE%+Z826hDKToM|16%2 zbC50*ux&{ikefy~gmtelVPQMjf8Sk16vpp-`t$K-^a_kO_rouV*4eL_q|Zrsc{g5W zvFQ0qrOPTt1cC~gNknJG6e+3*V55^Vwx_v(U*+O86=`XIkp6il2Kt8dWAl#X^+QS} zUzOkB3+cyHg0=nbiqUnKrs1#Jo?&5UJA6l5(q5l(2<)$XEd==I0$9{uvm`BVcn0=A zwz&IVQ4bfNK?(#2H{zqH6wIOTbFt8MZ|wQ@KQ0q+>UtCpbngf3Q9}nVIc8>!(nMi- z5u<`>A^gAVZW?u06biPw_My@+gxs9*-IOstl3^R zuxxmgcw7(Y@&Cm_xC5yL!)Ksc3m8j$0Ld3M_GJbPwCio*4rWDluknS!Rn4Rd@UWiy z9vG`l7$7aBI*TUlx5S?EmN(G1+-)76yV2sFg8wLxuvB0)d;jS$egOFXC0fpvuZ2 zfK6^cu)zy~$Kvz?MN3TDV>n3qAjPVu6|(#T69Ce(AgP33(fZD*D&EC%tR(#A?l>7? z#o`zpRf(=A00jht@hT?MqzWg3EMD)UTApcH#30zg9AwZWec5b+y}qFes0Iut(3XAU zoik^W6yOs82x915aU^K-E4FOCxj8^wkckmq$18@SyFudmZ?mIsP#~+v)C*UDgBz$; z>^B&I(M?n+(+3bxMFNTRCBVNf4K|ASLWjJd;KN$o=>GPCM>pG(M1NxVW=*CnNxh zHHj%WQ}g(EN1l=({=|5OP$rOtF9njn$N>ZvUKwATnnQ0O;PtI8N}PeO%~(aCbN%~l zJ6zI@&eAtId!!EmIS^0L^Ql|mAOlh$!7QQ1!rx=0%0ibwMsE*EGJc6U4i(GtQmPd2 zo*nW-!pOb+)l6){Az**NoUm77zFFH)Y#*ioYoTiQIEEpMgF* zN#zx2@fWWIYzvv)rw~Oz_S~J@%kCYd%D3I{NOTe zzR1dI!y14rBtzFv*bCB|=}0fl+4(iLUj4}eZE@$PdrfmnNi^Jr8&88(YKbNSgx>hh zm2{}7EFl~w9+V4M@~bT@o)ov|t2X4NmQ12&t+}_n{>rSqkKT8s(rh&c1)jlpD@>#c zf+}GtQR_MjuW0LNALWLE*hC3j{Ivim0lb_@Lo}Q$nVzVMt=_WGZLl0DQkcjab3$mO zXtxs`GI>&9yhnX-U70H?zF)jP0jK>19RkEwS8b1(<$O$@3C)x%)P!qIRE?D(B<-gJ zuMKI~=>v`U`BI4cXnMxEZJ#l#Zt~znRO~CE;rdg<{k|#c*Vp z9TIH@58$}`j@vY&Z|CJ1of^#U?`xeGMxN`srnR<|``SHy`3MP%hKh!UlOOVcgx(^> zey?tBY~~A>&=(xH2Krz9N>i!BJwNBH=)*W73@j`x&=P6_;qVxn8 zUFmK;`KTV#oNn*#K3wX&qcQGrK3;mgcOFg9?6owe4r5{D61Z=vVaTqk6*smj^j!*X zdXW=(i1}u8OBFsxmP*47u4s1cs%>3;iN~#dT~UJnp#f#^AY+jGTUDFPmNxJ&&Ws;n zyycLRaeOUv4w%HScuh~qE>^L7ArRHCZFlnGs*sGA?kyOfaC!4D6xY}Vq|<3h`&g6r zGq_F6a%>dq-TYT{Py+myweTeh)O~C}VM@`GcS{gaB0dk7H_PEPli#RhBIAPS;4i>f zvNBq*YBfKORzS;&?OpX2VpJKVv0x5(2J1~1a4GjKl2>53pSFsYLs7|f@YEw>j06R_ zAi~%qGs=6LAHQvtRDywKwUvKhE&sUEMoERdn{HuO1tlCeQX0YKPI9T zOV^p5VIvX~qh`RHJmOY}@bM#FK?#G5q~xvH{(Qx9#-EAJ;I1%Nga9qC$*=6mi1VjF zD7+IuE?PnLc`gwx+#QY5w)#re7q1^05E^gL zO^_bBtcT7vSoJ4IMu1PCxF?|)9UX;%2({c8wSq2;$XpGcQzO~P2nSLm=I19}go9OM z!v$87R38<5ltU;5k=9tLC_4+M^#_~{q6www5g5eLv+QNR@rFbZA!P~}iG>&GC1a{k z2lgJ$M&lGxWg7= zM8Ot8AZHv-CGu42y~DDM7K37DIg%T;tN{`dSj2BvQFGp$z0BcL9Ms*rPPBiOV4PYL;7;E6koRx(j^hlt6g zb{9FMH1wU46(8B6Y>K=HsDUL!@>KV)3h6FV$wTpsi_j?bY-xJ@u(*QV`F{Pe#o(JS znf3KV$jHb@7^pHbjmu4fPi=<(^h>y>bq@ADrn`GyH}CAS0+FUauyZ!j+ykL`|(tTr)ZDeA4`}~$fiS+OG zj3ma0mWye+J|BTWpMD#L3Af@uOiwNDpj4j19&Hjo? z9pU$%^)8>89!=~zarqNTWkEXsZ3QGFJl1i8yNTb7B3~V`>26QVwkLv+VdK3vqbv$U zhfZL&Yr{!N!z{i+Srs!CGjD~JKqB2jH3_o=PHc?m2Q|U~Opywyp;tgFDa2a=__Uc2 zADnnXD_Un))p|myd?csX_Vp9Qksh$t{An-IFR|O#xfg7OST!k&a>6Q{l)xWvAMe?--6c$M+=N`vJuRKF?j*B2_A+rv#&sHfz_J}zW z%C9sYb0#@*CXH}xws0ue(PKLJF5wcYdZbs<EGwrF(S!f#n1$*C%Ib}yMI*WPs8OjrX*BA$;5`MR$oJ3xXwW~fn*2- zSa#Yl3%K-aO{It-ZTs{%*XE%O#K5jOJh*{GN!sVQ;a#H^>frIxN5QV?V2appxxlU( z%cD4}lLFZ1M_hLVhPHBl8|F;3sCJ4@16ht)dAvI_nwwtd_qNDX?^t8+FrPBc_7);_ z`4W242K+#tf$`ShkI!A1EfIVXV8g*N`y7jKW0Yudv)ovoXt-cM5ql_k*h{gnP2G_~ zE#yuU-7Id9$8IrG0ZGaMWhs355S}4|aY?JX2$tB9Ty4}Df{zQU0IeMPPicEhcH@H-O+V&rh{9<7^*?}Lfq{mSqF5p^;eKQ>gZ-C9*Q5j(I5#tZO)l4{S2@x zIV(DXdFr>v9WOuhp8i}85oeNt9kgH&sdgM zRydy6KbV+vC77O`v8nnj@lsjc0nN_-czA9u9FYHJ)Yl`w`GP<+1~v>Y0FlBI7evD> zN}8J2_tL*_$L9vfQ9Qe!^1w8RIfu0#m64J0$lQ29k+BT$<;W7FCXc+9K;m-J5gExCpavtg~*b#cY`yH4sz5ubh{F53Z~N&CMxoGmfNEqrod z{CzNK?7nt*ScOHe3HRlfFNZS=ci12h?{!;VUOvbcy(;WpXm4waijR+|cRdE2^DWYv z1m#95OBuRUV1d58G5uy$Yupzf`5jsie5H8gI=cm)xuN zr^UsuG36)$W4dJ=>_Er+-~Pf3&E{JR*REelLxl~@XZ!VxFJIvHt)_#)ic-??;_pn9 zcE=Tt+00lvFNRO*ld0=ER#!utSW2maAAnM-*)Y5P1WU=+OI{jU+Lb^azUB6Fz8$Y; zIPhaDc&e&uhSjg0+wZXmmN(#btl4E2Z8Jci{HK9w`L&Z@t#-FJD1Tp<#EhU~g$QZ7 zpMRqsmyp@mNV2iBeGsInFRrYN0e&k=CZ<;}mDSX6JWu<)x;6DZeZH6~feQRXOUqIQ z03O-5^hAWPn@?D@G{+x;>jK5rHWmU24<~4f=hLgRxwJhDOf%K{<_>9%rlt+tCgPqm zw14Wm=@1XIogtWhTI9RwZ$rr_E06LCZZ$)Y5ndXLFkiqU2>Y$7LG>cgmtu*%oh1>dWY3au$MXKDrnql0jY8@;jEdD86!{`{ZUk> zQXbvNpvS5qjBKHHVYjcUuNB=Xl}tG&NBQC6QH6mxX^>q&qaN4|h%Iei24t{pX=$83 z#xA7Ln7frmP0+_nlC7Z67Yi}jo9FqRi)1r`T> zltY?oYP(|df+WX@`sv&=wB%S{1w8Q#w;}ov@29agvuOLX7n@~oF(QM-LLqn4@#G}?7 z75TY?i!ZPct(qI+ALA27_s!N0lYeOWb2L?rupt>`H4j+XV)cP)CIWZ%(<9I8fb!|I&6mqwV=MGLzK)b>VBgjFU@Xv{83DXJZL2F}M zm~W^)jhQ@}=!0>fD+75UJUQEy@4 znw$@}hmq0csBph+%VB9PAx%VlRMy~;_n)Vg~UO!Uw5)DECroIHYe@v20D`VWr zr>XxaM&1DnDfnuwfquy~_f);8x)I&bBeh~srP@i8C1HY1ehArhuAy#TxAN|V-uCr2Jf{8tpo$dh6^W$xuTB{c+bvce_bZ{-H^6BAfy`{rmI_hT=FG7JPHVlhc0+fp19%oyO0^Rv_Ik~SI;*#gz83M+jB?PEsf7$l z_dkf{RPo=<&@yJOww827Z%$Ved^0<<{e)HhTzlfZ&iC7#c~AYXXF6utqo16l>EJp_ z5Vy3rZFFQesJ7nYQhKfjMxYj^e%L_OxW+poy>VzJY~FdTd$9k>$#Kr3Hn&ErDLsM2RYc!DPV7p70NI#E-tQBX*cfuxv9xjR$jgsB;${L6Ft+m`g$OKf<-q$sg^Er8Wa1d4x?UL|3Rr10NOx0LKUQPgq1m8YShS?*673yzH3Z+SLzHdN!v-9*Io<`ESK z@_4?|8Ad-&Y|O!?vGOC}qB{Wr@^%%PVro2xflyGp55Rbb^`rioifEya8I@Kjb& zQR2l5bSCD$>povU$tW&UuqqvgMdIW6Z$XLh9AM2;4Ze{05UgAj04W#VFpE zMy#E^I@F&6_ED)TRwYXLI6}=+5m}Fh-s7&X5oFlh!MdL;UElhhO(pWfBh*j67+_9Z z5Z!E11)lY9K7;cdf@XH^`GusmTsu-|uL<=DiJJ;wrOV1Tw%NF9#3CjR%$8vuaThpO zFyc(IS-8cZa<(FuM<*~|3FH$nn1n_DKPdJXg4l~9P^qTm1X=s-w6gkW z{0Fws24Erig9a>GYi?BViyz801m_`_Q&AD9a2xQ?PzW{PwdA@3=Z9I&Yb3t5RThC% zrZ3z-He>@H&ZG9nAR5q{3AIsRF5G2?+jDr3%rwaJXp3u2V9D-l$i9KZ423nH#e9o3 zo89{ABQAToG|%<-HiD__y6A(un`YfX`_^Yu>v`3+Mm?h@7k1rFzb=;TA!2SF*$v`z-u!aeT{Rd3@n(*p6n2g!ngiDQTJP;$l>wbKY4~N|BwL+i6VlS)_jLtR+z=V1t^yq(+HCPz9pWjha z$3*{B*Q8dh|0f{q zU5xOkmpf-vs$!Is4=U=p7v>_>AAC2IF~W@Dq>(eVN!vbG-nvZ?A@1DBlS{8Bl%)yM z{+7pvJLr`udF4lOizmpv2V2Y1e2)Bvs`WWu8w1vKIc^CuBuYYPS3-8YAb=J{Tn|JV zOo|#TeC*ovC(f*yPwEsUgnaKPrN?clYCSR)`SIu0M(ev;HO(?_LpEGZf(r&IrNQMf z-7Gi#0>#OnG=#~^i)*wdV4pU`Q`chQE1BE*=C-NNO{W3>c7A2>|4R1%tc#Dg`E(EJ zzltIj0>i(T2=Iedv0yd3ACJSZ(KTM?>oMjiaSe;h`ADM+bjX0LooP`CJq+wEmLSd7 z7Xo!X-;u?TRo681EU1B#z`Z?yfjm^069W0w_Hq z&VsTEIBhC++@Rj>(^`t1o60@u zA~iH2wYbKdg<$s}@%q}2uzUU+>IhmN#5q;#LP%q15KMbaK*286=gm{IHq&erKP=xl zupkMKNM+HH#-OLHTqDP2Ket`|U5n~9yh9LCp=8hv?wg$Bx&uu@f()~4iA8*Wc4|;y zr}rl+^o{BeV}0xOu-aqkwzl|+CDqWL_x78X+e~?b9<||z5c~Z7PiyZSAGpaI>g?Hh zSgI3A(Zh3xbjKNab$aT*o9V4kF7(20L)7@@FOiWlPpRTu-+WelRYv2*$8qpP{f68i z=XTpXTeVShy!d>^FVd8FV%p4oQBmkm`SZE=^52)wDGl5}dE{>e?*A<)c|!|I!2d|m z1`ceos97-w6!eVuiaV$dM}vn(>574kQ_qwf75QN3VW$;M7f-Ua>LF7g>tkCK#l~?X zj~0sqN<$E3H>L5r5JMfoc1##)aI|A^e;{n4Cv)L<(Z(^hhdmVmMd(j(CqV;p;`V!P z0hBb17D{+^;71bGxhT2aKLmEPr0KL^LPzbRy=+T`=-&gAGiuI*-9=laFRj1Hd1=L_ zs+B;9gm?=sLX}4uqAbtxu$ij$gM94kho7$Tno<5z14YvevzBa3I(m^H&3Dhh8Q^p+9Zf0Dj zVz2>~Cdq8j(P&%8HPpqshD%n=P!z>CRY18X3a-+0Re3!m#$fFcp&yWkMi zQ`p;iAf$nmJ*Z(BBBFqP6w`*SVJT-Fl@MJawIuM-Qhnc5{*La~C{ZtCKu>)iuo!<^ zM!zP98hs6w1j2ZRYH{g>Os-+Ip9G+k>(;(HyC$(j;t;qnB?Eju1P>wwE^*ggwaBNjr8=dBWGoMaXRn9EZ z)G}o#tyM3*kD2%;XHw)Csamg+$2h6Bz55++=W!>`avOp`TZ4mh{cxvQTLb4?A+gH4 z!B!$U!RN$1=9rVEBwE&tWjh~x{cnAI9Crda3EaJ`ihjY{l9guid>d_$9seYsy5p&l zgyuF=P{f8ilUZ^1BD&FFv~f=}X@l}td7QmbPB@B3X4Sf;#$Gx2M(xn7TlsRCaZ!bi z<7$UA&C{0>5k7USbFvi0*1Ccjy)W3=4RB@(_C@5F;MC2BPS=L`bA(~NzsnJ+Fh_W&bP5sk)|^d=A4hsG{A ztf`dL>sv+S`y?V>?>L-9hIMhIW;u#TNqif?U)*d=@Jwy2-bplyPBpgtK}+656Fx9&@7p& z#l^5(7(6gk+!2Ro2#R1a@ODjH>Tb?;E6P2IWB*qX@J|I57n7d^fF1tddg|XdkaB=L zSOvdXdO=4NYT*|Z1XsB=RY-D?9@WKD;7!{@C=p|VhZy7Pna^H63Roa&q>)FuRE6*Q zkSS@Dl!c1bUgz%-lZG=)A(d}odWUiuBN3C6!Kz`9GN?kYVUxCpNqT8-E4M4o5DVK1 zTAmWk>W&IjVRo|El+6T2Q~6oe(bJiPN4Y4oF>UK7)%qZfvhA&Z#JGem+L@=HlqSAyp?%`-m_Ja^U=ftmcb zo9DOR_%A^Wj1TBtfK-V?dEe);1-)*3cEf9#*cu+}5Nb$?uA>)7DI=B0m9=;K7^zy6&{E`*(xQAGwxOLd&N)Vw`WESNssuI&jsZ1(im%KQw?=O>^Llx zG|F)q@;7CqjS4bP>WSW(-XUjkeQvokH&rdj{P6-;+(B?A=JT!mZ7LyJF+YXE1`ea* zxc+StQ{r&h7g05Yjmw=T!2`LQ8{r#qgOcU7zs=?UbHDtT^~hF)%eb`7(}mkO>}Eor z?(zHavMvK9Z0s^8#DMQvffibTS^$k)CN+q*ZY0(+1gYn8_bUhmaFx6;Q%Qg1BB{i{ z?uEgRfMno-2w$qW>?h2Q71o3{Cx1&|@8~dG!-LQcPofISjPD~FITR~w-%fBhXvH!4 zKNsXZso`P}A)zu*AtR)>EEcVkduI-wS>iqe^EN)QITltGF0b)W;EJ zH`r4xJ9W#rf(OMI@;Uiml>KzBR&B{a8Tvt_Sb!cjMv#LP+cKT>h+S#pQW>}*$``4I zcHYZ%?AS+n!s(co|B`JfpH^#UqO8g=QKCP0&i@H#{{^?d-%wUxb|cDE#9O2?2}K@a zM64A@U%{%;7%xUHmzjN0J^x*QCz^ZdA%3qql^h5e>Pk7|q!;d(KBR{a4&jD~kue&` zVKvjlqxuLKB}TkAmaZTAwDyW;=?CRUM!1!e0Jg%Ja`m!zrdPhGA3fry;vF8~NPvb8 zf&}Aq!5${Nv^KV6YmSPfbW{Rp7HEhi?twqO^3H{G(U8Un-kH$^D^1f2RACO!nHF9_ z7{gT29;;V#W$K_5s+|OYz$R7mHD7sV|gakHnu6_05edx|B;I2ImkMJj*xu=X z3$v=CRQVWr7fHq6TP{7h=!xt%e>XoKjcaaVOS#i}IZHXPFjZVzuFy1a5Jw<)SVCY^ z`K~{pCda~5(2oaiM@4-z? zgg8npNDbnFGC72>HP%g9Ppcz01yH3_&-3#5(xiMflhp7S`8H_&G}GJYSz~l{m&B#n zYf8eG<}4+k*jQ4$9Y9wtDXkrI#F=BC_}ThUm(`T?Lhs8SE5WqiNlKB3!oGl#ZCUg+ z#_cYQ+e}il;)Be`MBC12CZw`EeF2^_Nx4{NM2JTlbhWe|CVOspyHVdG`OW^c=1`FC zQr?{py+*yHnEZ=W`2V+)Sb|YD_oH$zBb8L#ek01NPT8+UT47r2<@(}yE#4?pqO4Tk z`%J)jy|Ek;6H6piEO7D4RpAF+SUZ(S+zT2+a(VHPK+oq1(|(vgveETNiG=e|XmMte ze#E1l2o()IMccs^u{WWNYsM6EEXbU%5V+L(2;0`d&T3+y6I`~T{y+pY-i*ZZvL16# zmXyC)7>|$_OU!zLv@2~fQ)Hh#tk>bG`*UA*$xqcR^HHM8_Lq)kC9LUUp~PXa%|b#} zGs*&03+4xd;q5)v3mk7*R{qO@7Xz7&>wk^~=E0H6k#9oxADGSW)xi+=^n_Vo2grVP zZcyF_{X}S~v2}^iZL06!$J!B@d=A>tC=sFQ>I*E1uSS$9M%r^!j)7-A-^(*3S|d5x zm0a#~p}?!<;SD}qX6Jo9R?DFNXcV!FCYTKig*2|fdg{ijEXk!+H=C-MYf*ki(x4iaOq%r z&&GFnvx_3&Fhyu2;GX1j2`g%_#>-v9F-(UJM;6VCZs|}5q!A<2#nos86v}TXQG0|E zx-pThgm}uJC67@kGSup)S|YGdiDH1RLJtn&uAjru*K=dNZ#OVreJLC`_8aRUFs*hpI-2;9+44}_V2Yq6K;+2hn$U7B_5 z{BA^K9ZI^MZXt0dDJBX!5<{DYj~Co*XtqBE16+sy+N2&L#Kr5FE-nri z4l+174hqZUqF0B?m1c*k7WWn;7QCG%7VSEJ(Apz53d-qW*Ay;XGXy5PT(I~o{V z+mF5w4IdRu-_0=iNCX|w51V=hEz4laqdhrM13r{0cTpVjNfISsjEMX}FpQC1%j-qq z94_I0-Lhk@gf@gslw>YUJ4TU0AA8>gUnZb?xh)h(?(Qx<&|Iv6Ai9kfr;dn&vMY@y zrSYr$hh7K7sPmfHopq-DB#9J=Nvlbu~pJ=p$0_hEZ&`hQ>qrRkmHaeYfL?J1w&W1gSMZutDhW#`i- z0C0i!luf}V1hTmIeow~1fg5s8c@2GOX2uXfRxDw@ll#x&&G@Tznv*pa+)j#5Z@=!_ zQfo{~btj#PPaSqTy*3#VfA@~~?n3#Fv^0U0>JcaQi())oUEQgp5k&Htl6u?6pa-$s zN0y#_p%R_>N3%HirZn?T*n*b?zy*ME#;r`8b1nbeOC>P3^p}YcXR77HG>$7=tEQ#W>sxBgGHB*r+=0<|06Yyj;)JRwR904MRoHO&`ubLYp2UUQMgm+-5}>k)iB(fkvq!Ji z>`&P#4E+yYO6vCL7}cg5G_!EI58^)p`l`-#=Y>O;8^8${VbWLLxiKRO{f|eT09yP& zLGr7&rh#a&G$)sgZIMRLn1o4x%KK(<=CQ9C)Sl^nk9bWKJ*#v*wF|dzY0jBsz2SJ2-_U&a%cfut?&k3m%f#KgnLA?!k6#80d|!V4I({L_nqV%QzV9+JNljR$5{}AB8-CJ@FQ21@_%PnS-3pF~@abEV z@VIrwB@^}rF^x8i?w4x>xA&|JDUpr) z^$Qy-3qLRLLC2c(3YAb2;1TpT9L@8WABT=#$;u*G zX?aisP!lFOmJe|201RU^L$3`&4grf9%y2yDhC}s2PwAh+?!ELG9%g@SvS9$08Ym`U zNherGI`ia@Z8@HGE~U6|aZ0Y)@HY)M^Xtx=zW&=mwh`^xlCrU3|NO;1DoFs2P57Jy zbmuP|y}BRe_aP(?tXC_Jaci;QS8?-U5LW2-OxECdbQx@ouGQJ@K9-z*3Pmh^UrBr- zges;liW36Di|8Z)DC0{)olE7&0q@EPked$%ZFfIU_q!&El9rvcJ1?PBB>*qa$<3t( z0E#bf2D&KpJUUH<&L;Ngdn46B>;7Vd;#PgKMr0_+X@8@=z=C%%o6@gtRmxF`JGU=x8sm;MlB8Ye%J~`e|FYz?qoj>cIhxJ%z*d z9WTOwujJRD8E-q>^2^j@gVIY62AJ+4Xx6K|d>(OdU<3GQ1XtIF+OHb-I?FvT_wVMG zI5vMJja_su+~iJvhWa3=FOm#$_j+)D#&#ckcIM=@JD)f{HWLbbp1KBEXJwK6&1$|E z6DvK$yR8iYx(mCzyMWj3VG6%3>GS6!TF%{W{e!(-WX|&eKwoPR?8kF+b7pk%si2~w zY?~=Em(@!8j_w(YuTTh=d}LfkP2Ph9)@n)`8u$Rf)j1Gu&LPB1;(B>(Q+E+HxqH7y z;Pu3iZNsTvr=Yl0T0?_2LW4|tFhz$&+jBRg=85MGq33;XC}>2hs9^5tcwvAe?&NWc z*L-oqHD$qzi`(D5>s-%*+Sv6i3LDop))rvUe~7O zUXfuTZRs~#_Ywed2T%mNrySa~?*302TX>rmjDcE8>qsvOsem1!=}?Nef&v!{KJ)tO z`trogp4cll!FYZ9$4&s0?Y;Y=L??W86_=a)$I9+Q>ns38`XDD)w=s_x_32aKxVcpu z;=VO+)58(1Htpt-0vG48nW=^~N#H4;0vd81Rsw(lX-zI~30cphgGWR(?u}#2{+f(4 z9Yfm(fy{{fgx)`OI;?>Hb|p33IumH7gA;1B{o^edlQ32^T!MuVo+n6Mwa;5StyGKN zpkJSR_{GP^i(7uVup_xU@EhO(rL^vr9rT75X-98g0V{Ps78-4eA zl-jSMQ4X~Cn@+pT8JM5=0<0ad1}IEwCsltr`AH)L0EAU-SX+72Lj9 z5QFyQ^6b4MJdcN`r!FhinoBnPDk^mu_b7;8ff@0TR;h{E@{<;n+B?_K#qL80AiXMt zN6${@lN9L``x4QE+LtN^N0w|B4-C&OeugD|xv7awXnI$LRy+6;->&1~X!a({HIr@fqbDYlXhNHH7k!s%GJ~*B~eJsZ;xLJQv zQeY+uIop!dP^p6eR7_{vxSGdQGvd)WTTZU>QxIFddpEdrbJ+l60xmLs@Y8@Jf}?wQ zVj;;r0a9xehEI7^w6u8O**6AVmE%$bdEmUxHoOA97chWr$ZEKvaq_IszK0iU)@?Du zv(m362Uip@ri{;@VfFVeNOvtQ;m8U2-eR-hqY@KukIc-hJXaoAySApIp^5nJ8HpHx ziVq7xcfD+L&jlDLR^VMgAP8Wfk?oy96{hEtIA^1VU$JrKERWrFQzspNRP*dnAmU)- zJhYU2S6KKKvUq%C2)S5_^z`lMpy4M)|B+rU3C1{nEz~-r0HdxNspAeG#CL zz$dVKTtxZNEGIt=Upn+rg@wm`dk z4!ZN;qVoQ1aakQ4n(Tjj-7GF66ExW^_4Mf@P9_wv8HR?2-+OvGxfX6=P&U{Im%fs{ z2aj)1sRhz3Odz?ItB?Sc8SeJU{q}+DgotTt7f-rPvtk@wlgn^|Ah4;){oKOx?T3r0 zoSfCW)`lNHxM$t_EM2y@_R+U_?M_N7?s#X{t7o-ICcZrEp?en69h2KPGCCS2Dbgkl za}p%;vh+oca+4|gY>n%>U$d5D5fC&v) zg#?(hY8YDSyy;sI$O*%4y``=je;3g6TEamQ4WIRu@BP`zeZ&v$edlM1NNsKHmG8#i zf%9s7UgooNJH8Q8ygD!C4U2)e_lVc>fGn>n;-6WuUdA4uS zx-~YwxwYjpXC-54`EcH4R|CNQ(ZJ_j9-{!EO}K?jNyN&P(4moG6%2sm1L1=Di?|hl zFO>n|f$G?3R7}kDy-Q=MwaxMq%?xWB<7CR(*PKN*;`)%({iLo^Z4oJ3TdY^FUO_E= zVmf55(aC5`h-B8WU!VWcwV>XV#Sw-=e4mfh8S@qKlbI-IuwyPqJ^Pfry!h5%FFy?_ ztSrnlA?M1-4^O)lik?_^6U-cr1nt8?$}^5K0W~M|0s-*DEP$W}19ngl^+a-cW>ym# zT`V#J!ZD)7*ktp7$n<&bt>8?pyq=y2NT5{QR)dGMzkN*jXmo8lqvCbv?gg2tG}dt0 z>f9Kfo(=*20E%2}doR)eTp79R2{Ke7g~IDZ+)L^E$6rNGZuJz+M;?=3z@^$QE)?DX zhGUnaWzvDwGV6IBzKlE_XJSo2rKJsmu?as_sjjZcYMB0dcG!DfwjXZ{!WO;S(6A6# zh{M6eYk82@egFPl3S96?X~G<fb!ar;8c`SB6soAqC>Bg`BJ|3`5ziIW#klSyC?Z6yXV z2T8J0&KgeHCV%|#>S2UT(7Kr!SKo;+$GW2uQC~(c-MZz}{w+xre`2tjM6(7!0~Izz zA;WX$A{*2vCZ6%Z_Nx(gaAi%p2Uj=o;=b)N2fzQ&Q8Ox&^G=)z$UCB{S~YP`?xezx zsnYSKFA05f;>LiHY%br0p_q#=wtXPi8p zZ{+E@85qDLHZCb13C_aTbamzS87D=9X){H~`mdZgcXEN?NZf|J*RO50xTD7#zotYP z7X=?W;x{pc>-b(lTw!(!PxXX5eHeQE>a5Xhe;|UnfsL$-X~X7dp1;=diQ7D^>>+Y; zFWj%h7ekd=v?jjdj)~f+Z4Gw7lo38>@bwiZ$ZkiW05R?^dA0kYs?ii#{~9d_Oo-mN z@E&-sX5HwVk6->OE8C*>t5psNl$DhY{7t&Ly3qT21T_fL4Z@4k-3<&I1}A8NGV}AB zxp6@G*4EY!-=iy9m3NOX-tFn}x_p$N6TKC48dyU3gnGYU-46An$BefU3WXM)-j!al z)r#8r61PIi;UBGpd7sa+FGA(Jk<nl)l2ivRXo+?x z(Co;d@q+MbsD5)bYrh+L-Q5;i^sh{j-Mb$$Pq^z|?-7k}o0@cmgkBXZS#UY*m-9C?gxsnIJI|qDCyYrL*U~a@X12_#9R7s|r zYn2Al6*%`D%!7F2_Q#SQV~HYwI3l8>Yk#eQB_zi}GIYA_cGkl~1Q^&lp`0$Tp{#=@ z>{7?chG>9bS}T9!pS*k#uB^ioEW^)SWo&@}hU~v;x`r%16ds`%xo2i&37kKF-h#la zfRqR=@3auEO&etRN9qdl0S~NF^zM%~U{~ys8Yg~bkkiu5Zkgp0uyDza2Ki@oHT2H- zFu%6`EDT&aobw}^yi$iG~i(r3Ik4 z4a-dC5|phzA#>$OZ4C*}w~xSDokWr5)JmwLBh!C3KnpKLn69fr98OT36XU%#q!A@V zTB~><^AM1UTCDD8HfYFwTo2v7bo7P|LylNpz`P11G^x1fzDH&nTT_u3Dh-ccO|!DL za_4*unccvZDbMYsQo|E){?w6%h53C@QqNY<&djR-$R5OT+jy9{6L8_O(^fEW7w3Hg zt*sBkRXQ;~Go!Lr;3fG;fz8}HY1ofmT1uiW^TPp_)6_)YeYQ^)!VRp2MPPq`4{aFr z9i7|~j*vPr)zx8%>WBG(w?c)$UC^++e&3xjz2MhFXVYADjap6uU$7JL;*&_|>`SRt zj5Zwuuf^pwS5*jM>tRI7S#$GjPiuDrKgnQbQ%s`y<;dsHuj(5Zq?5YBS&QBpfy*LW zC1hTT@JmEB|1@PtQmL6j?v-)JvvW)=ibde>j!(?i&yQT|=JsUk&?a&mljrM)?!nqm z&il~2*?PfRsP5hTjwMjk#{)$G2kW${=`lI^Oh}WDN=r{kA3PNTbC(Q2|+gyl@^PImois8+K!|Ua~3VzqDC6#`rQd(;yG?r&lRsg2)~TO z#arVDVNKBscCdTq&e5PKqBqBHaqKhr)W=`5zWXx$@O)XuZTi3ns~YKfT{#}NTN3~c z`K+U1L@r0>g4HE@z>F)S&!J$bP9n9=yNjql+ph&RKt@FczxdBTXO;BJ1uN-LZoTlx z`uFUD1E*CY|H}gsdEoRvURQnaul`#WhSt`9IvYXo{HKc=nvni!PlCpif44FsO`m7} z(-`{CbcFxm+d4IV{OEP`gtE-Oj&7|-Ut5|DXZy?BsgLYbUg*S}Eb&qa@*j)D62aKl zUmo}->(BUQFVJBnZ%NMV-XoXMuI4p%C^R%YI{qYB7Xf9mctH)X@bbrwi4k}ttR5au zBIECNQ+QQ1K#m^JHa*r`cC*`J<C>lm4G<9I;h8w08=xNqJb$%|dgh0vjVYIYInmQpVCiAY8~>Dv#I<-W#`@d}w+%&vBG;>o`yd?&BNucd%46)Fn&pu~-^0## zN;N)e>Y+mDcuEXJ#nqWMUem8>4|ue7b@c{4G|u|c1ch$%Fs7@YJgv#B*rlpZBa?1_!k@W4lu-wc2#vsE z->b~bQ4bX}N}d4V?RfEtU{y^~G+~uf^fGsi~=`q<9!`8$iBhzMGH(?W)0^EikiX z$Dy?gP%ntwA14b)&1(-yUCbjJbOiu=CU)+qi+W$k8KT;OjmS5>y}ffeJQjgpz-g@( zV(bN31kp+Kdei>MF&inJGOxZ<$l%QYa|-m~BRdKKRm`kJ+o>ntEiIM8Q-YKME&aeT zNLZfp5`*y?@Yah%)^VS5#JXac&Z0%9qo#epA%kXP_{bnp_(XcdGib>6BmFQl{c z0%~+mDKZX({&JTn2BR`agJ~s@6|%Uea)Wn+3@VJdg6X26rM;G+;bC^*hHY$WI=jFmMB;c0SinmY`7YKvj*7^n zg*fL{Yz0OvLiK{SYwtbOtft6Y!JmEwAHDKsCZ`XnF}LcvUv*Vrn#EQ07EmL)1hBu)*qG zj|tN)R6lmhnJ#glWu|g*n^4O@VlF$h&2m2~UdbBH-=B(MaA*+x5J6A~A#P242CITy z0@;V*s%Z?;Hf@Rm4_-E++(f1APfxGJAZha*NJ|L>&KA%bTzZS`&XE*j0NTFa)rs=R z&LUKDI=C{rU{ju}eb%-InjxIs$|b?%+py>zYB)$DuPEGcZl&{PUi5X^^#IY}H2+jq zsQ1|wQ@&z?mWgE3A`Cy|L-_<3@~63Qd{1kusN^>$>QJV|P=SKi)<4r%buzDFaQ; zQZB6YtlEl#J(2ZYns|8H3u{(4_ZJZuQC)nRA>12dVTSs96je6Krl)h9JKNH*@rj8R z7hj!fnJVR`H>H`Q3VLFDUrNRIC9ByKha8q6M51N@?diPj7)s@Ij9Y=IZA1tlOM~T)g)?Y)!hB`+&G0oGIqp>_1_qYxGwCpg5o=VCsr* zu_pmU=yiN+|7I2Q@W37CJ7-5%l9QA3Rw$2r=h6-Dg2Rswl@|Q*R%5~HyW6)>As>&? z3f}(tr{Su)6V~k7&w@k1){uy0+ax8E0O;Dt9Jk{C^7mC{z-9khHU-tx{F@!APZaF% zz+nSQhd$|{d?Vm$Abg6zQ!)5h>)Ftv*1q#I0yl)VNc8jX6{4c=?TGm?H9-6{ z8LkE%Q8Y^btie#}l-XdjGI{6s;3b7T+^YlBhAtO|$26IAMh>02s{iHrNJTmq$zlo6HK2KG}axf{fQISGvDP@&ezlh^xU z2iip|h*71brE^Wq%CEDt(K%)Vk+76N=r)!$Tc=ZJm`5E|q)r_#v)kjrvD+YXD z88O7yEziWG9wzt9c65(dUhMA*NO=A{7PNfOEUa9v;!NH2ah!IQ{NQ&3LCQ?2>Ao^_ zGPNg!z)m3OgNTdQ4GeeOX?^crYyer{uA;W6sL7r+J7Ks19xrj~)F}~Z>DVOm{%mO! zWMH@Q35T@4a6^4$j%q0A8D+`T`g!21cojw<^1=qX2$r&+Ol(t=C+hT>p>@Cv2_4w7 zd2>C~d4gbmd%j0H^EXVGL2TFC26_E?E{oYUh{#2u_oOxzj2u=M4bGOg>29YqFk8DR)%f>w2D z`YqlT(wFaGy5W3Fs&z3eW_&yDgt+WC${g>0nKeWORTGNy$`ywbaEAC$5i!Dcuy-<% zY%4ok`AdhGa4NuSa&!|yKqeh`7%m%N%Q9v-0-&@+M#k1Y2#cxX%S+|R#M(E!&-49q z3?#Y3)ipJ+`QZ^LoEOtlqae-!R@$SX(QRMGYJRtX|3KcQP#5vd%TEMnVk1ySnPqEh zc#8pLfe7xY{;V<$4_g@stg@=A+ZV@L3_(`|;i$;9?>$>hs1qV~-s($dm6i80!m*_w zsDVZuhxmf~{|;posRP`VQ&QR`DcJ!ckO$*y5?^0vcsO#tdi(l3($55Kfw3nUr>oWu zNphPGCHl6cB!shSx{?{4S5Z)~&Aps^Fg0*e6VnIJpaKApu-;xNmzD8{e79tR^CTyp z?MISXGqGfASta+*W%hjM4dO_CLz=EXYm^&M#6N5M2`QuuF#$Kb8HA$;m74BCSIy?l z5=*=;oZ0pJrM*%gtO|SW%MjKTn7u?D?QI>|jtm}bou7~aLiK!LtB`v|9MYF}+_A-H zpp~|nLa_#k@N5c~V30_G)ssGWQ0hexa^5x}Rg00wHN*IfO77}oXxwjV77>#gzDt}1m4B6$z`O6a zVev_7>Q~_3Wc&vQBszZw?Bp4tG90tbi4SZU~w_>3JNw|ojEp!1_mbqx!D%1r2Zto z1f<^nnS-bUqobq4u*;=pp&ThoVRYOp4E-5l9~=)BrC--i~*#8D`S zYntO6z%5d)z0YG^XeK12m$PQiv16OD92wp=??N?XCUR_(PVN4^gYm%&SVVH~!m&AT zr};%ipI`(t5UV{IhT7GE`&`A_QXtE*b>|;J7A2l)kOqo^KHj>Tng#`s@>)gNNULOd zqN9byWl#Do&l+MaKo~@Y06!XAU%y43y9$5&EC__~mhknTSylhLf^)4^?Ek)w{r|W9 hk5TErd%%=eWID1E3 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 diff --git a/docs/assets/plots/cz-chevron-light.png b/docs/assets/plots/cz-chevron-light.png index fb7770d58cd8dcb216276b11a94a4e6fc2268489..17c9cfebbaaba1f5975fcc3ac02a8cd5deb86914 100644 GIT binary patch literal 63955 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

ur(K6#zo?T*^) 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 diff --git a/docs/assets/plots/qubit-spectroscopy-light.png b/docs/assets/plots/qubit-spectroscopy-light.png index 0ce91fa6357fb0dbd1fbb487df5f7bb4114a1643..f55e8c48fea6f3189078579fabaee179d23639cf 100644 GIT binary patch literal 39133 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

P{L@7bZtz1n^&m zMLbaKlElM8BMQu_w5z8(Q?a<+tyRf^N*FzqFteV*Sl{zCy7$c2YP^Ag!QnOC#`IBB zN#}pxqHH%2Yupx3aEcd#)fNEzXFQe6jKm1;0jzBZnLT9t?d6rIG+Cid@z-asbzI!H zEb|i@?pxM`_-z^AYS2Oc`9B2RCj~3EBZl z8C;<4iRGmsqjlIJ;+x-~#0$a%DF{Ba)AUV+Kh{SSw=O6IL8`acPty?Jnw?vb$~q=% zgTnB42WK(X5JsA!A4}p@cltV}Ayg|$E==Y14nlOt6LaAddp7>Vj11x9FoaHmYuE!7 zm3OnCY)=Va+8T@Vqam;S)r(95OW#Me3oF+8Shj|}*126bjz>AR)lIi2Ws->YDFi(q5pX}B|gRx^dD|p#(h-;xHEtl0IYnyFOk^Suk`(U>lL!A zRmc9!w1|?oH+w949NIogMicKv#;3erI>F|)P_<3PYm&z#E5!A%2Gla@_nO2wTlmw) z%e|LLDA5owyDjI?XvvK|1{~jVnoXbJcv^0AFcty1L>CZkqblUdaVPq<#$EDnZOgJ6 zJ&KbvHa0G)4GIbp$KQOS920OIjBJLn{rxVmi9#Vh5dCDgaY`BG+s$;@uLp;QO5#c4 zcB#R92Jm?%G3OPs>J_=Mv7@#&C`7w@;THoI$6mJLDRpCIyoyV@Y^Ci4K3==V=ZftU z3?|m*vPRtQkItWP2d?x*W*!OUy|+{eF}pjV&XZNg z@(dcO1TFW==xg;145m|3Gh4sEi^Fq>fZC*shdvL&mMCz(iAoiAbj5cY)|+TMLx}w{ zAOzG*I@aS%Y$>qU5(truSPi`}hiM!;VnD0#-` ztyiD?JcftJYmKqsw-nXqzlQ=OXF2DYgaeJ;z%_7a&vd2N(SgFh$R4iuocw!=|1rM6 zB(TxKpk27_n#jytzxvB}zw>=>F4x?bKrXxKJVJk9Ky2?>HhcLoQ+lrRluRKO_G3I4 zCsoz1`Et!NXXDu(w_xqU8R0*r>DjvLgL8{81MU{YJ+HKyQFBDwwq3=?7yfi*_)Gx2 z)5)nHZ2=`NLNJjSb84ob)oDhYYMHYF{yxm@@=3F1Lf7qf|_}o83>Rb4DXya75=p&nHt193Yma^(Ly46g`DR#~dKS0p}Uox%u4QC(Qr+ z^WcuQ_Tl@W4#o9nI+kPOj=ot7;CP0D0txUJHTU0$uTj7=-+V4@g=lq6>M;r-lGJVj zxqz9v;us-nsZ7CIWc>^g!xz}PUn}i0T~kR>G`XX2-_jA^L$nG^gn!7%Ktpfuz+M0b zDvlYBK1RDLb)1M2b%NEl{Tx+Owh~J`dN67-dtbfxurY->JL9L?AzP%SdJ=f ze|uwbByvB+Xjbk0?VHbwf_zwg%bjDiA9I_9c%o}yKd+xMYxZvGq(P_jFFk~0umf4mf8lBj;E0WbrS76s)U82lM79B%1DbUMj3=^G zuxh^TG^l}8kt^r?wX@u0zP&%8<;bh2hE%WHR&akHcWKkUsn&ISj>oR!;UnA5&hB~+zVa#K&X$%~ zm-)|<%M*>HJ$qZGnbQjlejRq*y8;HIM=_UZxsI*!TiRx^0uofJ8cRT&-%F7&if4by zBQt?lSA_#H8Ry@*aFQWUf7zfhY|#%%{XnAOLA#8=)sHq#Wtu3tQEdB?^TrKs{rXm_ zTSi$_)YPkUJX)zaIhUKXz<4EJiRb*_6-o}+r1eB%)2_C&l{ zSeAanSzthBRI?sGD=<_RR z7S7Od2Cy6FG#zDt`~U#p&sH)^OiC@J4*5GPr*v-9?(baEq!+J?T)6PT;YwWX8vsqI zdG?JFWHsKeUJ-*`Qc+A*@TIkPRR4AYbDPh^{@AM23l6F8S=4Q8EcZ$Tg>ZGo9VD2_ zXe>O3@%1@Ld`9t>>RXx%L!IO)s)@8g!K=h26?u75_{-CF2mTyTEV$_;i}F3lS2hRM zjy~LX-?jVxyN;Qa^;PS4Q16Ru7KlOPc?>$=c)6~BEevJl-hlfQpew{0PqvhSq-2uz zNBw^M_>r}po11gkuRqFX%NZw^saa+_A5@#+RKG zG|L%3>IPN;H!|?w)WVn4H2Wh0YfkSE4ehUGywnf9bO(PkRO$PCA}9UB4HcXqr1rkp z;RL6wrR(dRuecnaL$I^MA0gF3^K=taQw2rEv)$b}$~!S{!paw7Y#r4?Ugh0wacwo4 zVk^T^G!X&i9ErH2vd(l27iGR zv!M>-E7RkV79Eg%TdlitacXCoeRje1>}&3Xz?7~a_Tbv0B*1zp}U#o zOF2JXED|FkBS+U%%hZ?&Z|1M?A1|;Py|-^w#$|A)PWJtdxclT6?rl)} z-@oYcu|1R9sO2%B>~z(9iB1ItW@a|?exOIVE#}p6Z9lhX+kbtA?MaS}z1?467T7*T zqC)#IJNph^udttAP!p)ZhlZg(dBe{#>-&C5aE7-p$Ls4?>-q}^w{-JEPI3j}h{=A7iq`yY^<;Wc zACu*f#=atLuQbI}w!Jz=`evs;W#Ou&Mjyz8N5tXUje@zPX!~M==I8`j;Z5Zs4<0SA zW8@EWQ&m_(*h3q}3JH*2=ahC}~h~?jruJX^c#>kv?anZulp0qd7_|9Eay&YqGR!?1pytyHbK# zz{w;Gl)92$6e=CuJ6cQU^8VXf>LggT&+N=#Nul}YRWh@IqC1g179pKFot1Y86x7vE z{b2`$8T6YtB6|2m7AHN!CrdWa7Us(3y76L=u02z0 z|Aq54kpAEi9vKocqCQH2#skPA4v?juh0TBRR%&C)Y}%96`9U?rl+y>2E0~*`zrPQT z_Tw1wbU1}E!8ce6%I{ozLq zjt?ff&^7!QPla>Eh!#58|0Z0r&j9R?A#?NiEFpTv$18`emVTI85TF%ioWG=&2C=9xOd0RS4 z=j=7rPvk<5TK8$J;?0Yv6looY?@-;c3_xNs0&)Ryo3D6;Aot_6AxX0(J=rL&6YX+NEx;^iK#TmYLQY@)`@BU5YS}id7D(Q+* zHfv7!cmSVYoxA~wQB}25B7tul;;!o;9I5sprN$Z;N?r{K3d*A?DL3mMrWeKH?CknS zZ}B0qjLf>!@nk79wnf4hkLSgBMiuO%h0ITHvzY zwNmzq9T7a&OElwoH44J*wx{n%gpPR#Uo27ig)mH;h|d5S(IF*T&-XhTAeyP$-3@W{5jy>R2+MYoL) zA*?EC(-9^(xrf^C)_M)&{USIS3jCib=3#6 z$Ul5YU)az&Z}rGei0N4zJge36$SUs(TNUxEd7cMR!M#2oA}#mL=X7qrwL81aXBL#v zoSf44)4s=*tOG<`SkT0UPW%{`?-`bmnGF6v56tFn0#qa5}& zQ&LhoQZq|~zJCC*|8r!W*Ya)=U`*BU+s#OHfIy<+Vm@FNRKl@!I*T3`z`DvcJ;O<|i3=;7>3K-> zG6~f~ijM+&s^F2Iic0TjdkQWg%xOzGktQO%k!$eOoRC-E^{gc01F^IY z1B+CAwx3K)3#aBw{&biX{!F{3c9VsjU3NmtQX79C>NV`I6yYz`oE@Bd$uQ}N=of_t z4AWBLU?I5GLuuxJ19QAc38h94VkYD?-*BwYYs!fe8%sR2Vk!$FNmUqLou^0 zw=dh8lqDsE@)Q=Zj`wz5z0-pw{?X1$L;!m@duxzqPzYS3?>qXYsdB{Q|j}{#6&ufN!ld)cCgx_)o zjQu@ZZIJ>7%LvhhO}KJ4L7(8;w{J&rZADh2cmePLEedZNHAuiAkPBUe*_VMVB_t&o zac@cA;^<)IlPMW8Hb63eWx#PFEef z*iu6-{3%+{MS|F4d2v!#7HjPYra`2NgFPSSZQX--P%dk&iXQ&Vu`)kuJ0LI5Y!dq+yroCLv6sk zlaw9YQjU_$ZC`XEyuP4yL{!?Kz~T|gY2%mBO#eYP3eRNUPIEZ&8oK%owA2Y#gOq8t zQU1MN+U7e-HXI~k@J#NhyjjSxT0|IDpoP-fW%+pxYC#CUk4KF^&a?SF--?vne1VV& zR%%OrU9IuJ)5sT+0+W%1tux4Fbb=9L1s5a6ThM~3FADzyC)5%hmOf7L7uFR?MEcLM zmkyV{D1ds&+((+3O8C6}L&v_^A(n3$^_r#mHeYv)r*N;LMJCd}T_mi#eClJ|8dRl{38yAwgkM3tk0m2J2x zs9865Jy?5YhZkJ%cCi`3w?G*_G5ktbqy^UD5-3($K)pAclnn=o7ovIMvHu5)T1}KJ zHCfFCOS*#iZTDg`BzbWax3pOV%e{2wYtA9vqKRCj+GMdECg|hiEV$c2iHAhYQAP(2 zzl4Q$~vJnjskR>u0j`l z=t~Caa+e`pQ%|K~P^pWKAOwO($Djc3Ybob5V{l$rsY0X5N$bz@Dk{l9P=$HaTSO%O z^!Ou)Ys>H66=AqHdkyj!LT+2rJQZb{7cN}ba&3Cj+1V*(r&-vae*dDIa@;-tuHT~M zucyL*syT*6C2ml=B$Aq0z9sjkbT=e~U5hERn*|3nDwU9{w+!FrY3YbOk5Db$(Ql*> zXe+9yutR#1`LWiWJI}to?UzMLgU+&U+&Om9Rs73@+w$9~l(e*#)rx&DAUQ*8A#Get zL_}FE&{)+ow+SjZ8*ipx-3}|}H?L5T3}FocGWe^`JNN^&?m&{+ZJQNNP9??6F3mg{ z$hw2)(wl6_+Ey#H=qtKDViOV?YPz-3jpP$LAYx?m2g780dM1G$&8v+dfjW%oH_>w&cw z&6^v#{{IM9_%`v)yqEEp#6x*_eM6z`6wM;k8>foNIlXbA`gccx&JznGGRN7p%!f`+ z8^&Jm)F~}&hBs48XB0GLVku;I(*6=P@zJ)Qne_F`0tLP8LEhCr)_(?Lqac-0Ja1Uh z^7I*jer~T`ZZFs4N{q&OuGZuiO4$%>8PD<{TUki|+@Gq)h5a@2%|^ZRepyO2NFD!Y zn~F}xP)#P^n%0EuLzsZ3_vSZ-tqfYYo*U`+62uIhwsi-G$PdUb%VbOf*VbX&-X~}P ztmJAFzlE`WLv~c~yLa?;Lmb!NkB3muGsKNPj{W>uMOJ9B2q}Z!T^Ej(9K~Z_e~oCv zDVWxW*6R+mLygiw_0g%gUNv@O!?DVzKlPbej$izF-&)#Pp$lj7#N~-9=Vu?QZ~sj? zsVXw%-DI8Zy|L3luwNd1t@ftfRKD}dLQGO(G2iT-88`Q}+SSPg^~|!ZR|vHIcu|Wr zw4rk?rgrolc2g=wolU8v3V`V#ZqkHIBlT~J;|dT?OUo{w5))OaZ>Dt*SBX~B5iJUqOZsaT9`uiJ5OT(bU zPz67)4me5CStXlTgl~U|4+$pH{r2V^R&agxhPLq6bw>f`wcaE~9KyA?nXbyZV)Ho0q#UE}PmxL^a*rt#v2MxcweNoP)7ohRX3rGJ<6d znGQRPk5*UOWv8EQ{{gaIJ?SLFT31M8*4*$ZY-nslhx&A;bIlTb0_XcJls%y7zysFBC-v{B$=i*S}t4-u?*RBXMS-|ZIc zE4E9GcHGGh(9OxsUCoWz6(P7B=HBv-GEt^|;Pa3PWLAqe6Dy9*&UBU(vXxGb1WX8Q z3={lk{ZPjkWFT6izBs?~`hq}_Q&+Fm5aJ@Zj6DV&_Pw?iDlQtejy#9TvJiUF=VH&P zxUKUNY24lr6ZcuPoF|QJOcWkmI9CP)T?F^`jZS$b79Mt4N+zj}Uc;DFsLE@ZP) z(vc;$n9&cu7vENi!x(AaYK`<~cP4s2k7HR7!sQ~=0LUvUVo~t;ZRC369UU=5W{hJs z-auvw%&v87x`9jj@rZYH+Cp`<^evmG* zeS_?Gd|{A9<@qMq+;kw2CSNyCO!BDRobgV+lA<-_&Z%$Go+u5(9lvU>!CPo#X%d*3 z)gy;gBq0in(MdmyyEkPhyq`elyl@B#)9#TEcvyVD4uMkf^t36L_3uyEH;{Fml>vja zm@H+4mNr?z+4+B--v5Q3x0Mj2^5o3fvr|8Eo4Uevm=URAwg09S*`V%%0YI6>V&phQ z(JM+M-3p|d5>wHjdAj;%kuzt`SeK~J(eaE;>YlpA45#cQ3Xy)c-IUr`YG7ZPWFSw4 z!dl;2lvd*_6?!DI-jonUDq5d+p~UIlZ)+6eiu~WWAo2g=f~t*(Q_g{Q>3I~z_lYxvlp)wY>xu5*4y`SQFT84#p| zL{TFYk(a7G4vN$0!J3D#XMHG ztZ!&&-#n)t_Pg~k=BdVWuE%eF0d}82N*gb&wOJc~|5@fT(^?yCXg~%Bb z&yH%~URyaQROleZ5&8N3V~a)kf69d=)&gKd%nuYl6coR9v~^`F(|Ek(hP;wecfs!J zlm!lNUN*)A*^Mc3kBz`ruU-do!^|nLKea^^eX{$z;e2QyL=$*7^Us_2%68gbn>=~a z5kN00>NnM&8Pk=a5yxJ>Awa}Hh{4Pq9B730ST`t7{Zp|o1L&)GX5M4^qQg&G>mM77 zl#Dp&bhP{Ei|jZ<9%q%&#P=rjHXw(zs{t-v#uaajNFs1Et2QVkL;~NHsTG=K1>5Pz zO{m25<+Gv40<B zXo#?Yigfw?z4curHHp2-!z24BNv0jb06e!Ia-NDrE^SDAqf$Xm-$9?dt01 zCsw|U`s0>(6p)?`WO~rG(j| zR)BF0%!t?iSy{Nqql%MEQ@&c}) zU@YvG*9gp<%hnbb%pL7~dVQg^6Ya%HY`ZMA;JCwsfqIZb{WjLt{d*OkKK=6nK{Tz& zq|Ty4H~N`VzrJWNeZC@v#tGMh&uWWcSwqa16TtgkJHm5^^~IwKZ_A0FUBmB;BdlBm zF_<+jpi%{me!@>tWX!yMJpJ}y65ceH8Hs=5Hr{b$PP<*Y{QvOJONCTYYqD zB+2*fOQHH+feG#O3quFAQtCgie5U0<`ZK0z&*u)>I9HTPHXlkc5lj=mKziOy=*E2J z38-j!icpnbG%PE;9W#Gl!dB;`X9s*!_qY(Q!&_G6#=i z3ff(kjW*Gaux&`Y-gzJT{K*-CsE>)!P)azm}0+wfBEq)l-!lca3h@Tb+n&tB!dqJC0dy% zS*wFodBW}B{ynR`hl!7)_?H^pgA8@LnCVD2Gyn9nSA|)4gNZsxQU815;8#y2>&b94 zpj5EG^SxLupL!mYJsH-e2{L{-t>TKy6x%bA-j4e5r zL8_tIA*0W@G745FQo+<+NsbF~g z_4Cg!Pc+Xdif*c$?d0A}QVB~Gejwgq0v5zpNy_F$Wui2-9a7q#n0OD0HrjvPr%67^ zaPK=%`Ol8cw*v~g%qOd_kRY@@>j9HTcr`L1y__}S;oD;q6R9aFa)pETxzKq=HIaD~ zVXzJKJx})?*xyM$oz3H=DhD>E^R_g?96dWzAS@A6DYPpO3a{npQOhy zTe*+<6i|3w3Eg!~YdqFJ8X9NXoZvijbCW{v$SJk+7u1QW5c3MU_<=yJ&^#CmOa}Yx zUe_G_XR2-HN5pD4cIqhs`SihkP?pN%3?-zFCk5!hatb;_|5I}ILwrzRAho@Rxr|Ju zRaCZKoeuKuiRmGar+)nN8!uuekYcT$`4kM%u0s2bs?7dYvhZewgDR|-=}TtMSkBkw zYmAMNK8%WE>HacrO6FLa{ZVFYO#aH3!@?}dzNYwyBDUl!8X17j|LBo_(2!@ctu&0l zW894;~f|EgIyWd9nWB_fCRWPt9BqW%ZkcT#kG*@vyP?Kg&!7v+K|H=M`r zjKXPZjpO`40MH5_pZF~i7)6#-Ih?uG^FvXqGu<4Zx9P3drJTaj`$ zu&rih55gz}#x6ZPde(4qrjuVulb8%rG`DS`>5K!`q2a!H=HMj~6E-VQtJk*{myl266BFJ%ku{vHjOfcL5(p>pxtVdAHHV54O- z5&Ir%iuAMn$gVY>Ef;PJ)pE~(WCBnX#?{`qxtlUHg3fO^XYG+zLNhfe>g*ZTRQuX2LJyL`Dw2Tc84Uk-ZWGUwH{t4Z(Awq_$GKu}Zi{izwjF|xKZN}9C(Q1uXC zZGWpQ#dx7Wus~%ul@}`tX?9CpaX5Xn=qn+Ljz>#y#Bzu#O6q`r>dfR2Eh%5=nxo_X z?25Yp9M9k(#H+k`9WeeH7cqi3KT)?6hf^Jr5PzA z(S?u+tA#d&e#|sVc_ALn<~v z=-}5zm4}%TK2d^4t!dBBwe#5UG>Z!!BWdi)NL6O*9Y_lvYdnww3X*O6B5ewf2?&`# zDWC0HnG9`7!472*_>2=i*=}~|@8<>H4Q(im4K$%H+tR}g2R#j3p8;*OZG1VpL_oJc zQ8Kr*`2#&P9jF!I(;r{&A6uJutr3j}HheAW%o#NkK`tFa%wwK| zxt4OXTQXPHZLbDt$9JFhRpcd0^`iuXEK{R_?NwsZpAw&cw&3geEcp__q@2iF#`(bj-CZ(t+Xc(#G;bstn7Wn?)x_l zHQs2uzaa0c(lDK$Ue(^z3gOgebPe*JNw;WjFv<2_7#t1Jksp#GWverCnO(&F*}cth z4}p+OI^RN1FAxR3t5;``WZ-&HIoNXbA!Cm68~f;Y z(OYNryjg9W_I-m*j10oTYp9|J>czmardZ|ZuQHm5t+@GC$Ll@KeplZ?(Fr!W?^kDg zZc5;-%OGs@-E@;JN~u&_hGL?X1zL1!%%(i45=Nb=z8dFf<<4i#y;SK;8K|lUD|et5 z1c}De^RX%3L|(bvPIqPS_kzxc(kaG!(wO#-GKD4|6H1dBc>xzgj}sV+LLucM(Gxs; z1O>Z8RtcPM=2e1QnAzJ?QvF!Tde*jh@>LaD-^ZT>FUW@qq@;ky$!`5eWs3LJxTU;5 zPt&k(|H*E8FCTkIY^|VH=uz=vdiv6qGV>`+mLaMF+MBM486Hl7H_dGd&2rDTHTz%1 zjeI)AQe!X~S{r=y$+m%A9Nk_KGY+vu+^8+eqT4Bwh`Dy+NwMSnp(9js)8cI}@S~Ft zo%k#>EB7e&_lhL6(oKveE`ZJOK$YW5lBE6Q(8VL}TSAFiiSXVrWB%sJa;RcRH(Y)A zaK6dlP2$zvwK3@w9lK+gN;1%5X6grz z_wDze^L9O*vuGa5Fpd5h3+9X;>dInWkQn_j`TDoQ{NnK`Qh5K^;ewbfi*j?`+`=~+ z)JJY7Y}yMtTI~ni{~oA>94l zA~NW%7$aElOXvQ*^@cVZB{I4F>Pn$gl7(C|D=yteT{&CWwV>5NruiEo5_c zjMCgox%s$6TfAGAr9IQ1J@BiDSoJ&!Yg5az5^39{d-$P#Q>xP9rDW1#-Fv)lP$V~a z7BMd_Vf)txKiv4E6?cRhUJpilQ`8}h%~?>(cMOry77bu426#)gOjI)ep} zB2`d8ML@cA=>pQ5NRt{J6;uS2UIe5_htNAjWsoMl1PBo6gb+dtB_YY#kN@|av(BgU z<-FfcmTL`bGzm}J_ul*7*YA3D|McwW#?0&=Uc(bL7iq{TJIZaG-<*^fDIyBFC?axy zF8g0%yR8|0;Gh|OL&?SIPv=v^n4Y3}G-sxD%ghxAPlCYBrgWOnQg$kr?%z&5$%E+{ zn#sOQW3!zZzfKEm{HMLp-#-K@cxV#*X9#6>M1anhd3p3a>)bf{Ds)vh`kO)*BL4b^#?n4Sls}h_QOBnC?r z+U!*QwXk_iwzQyjzP>TBq5ckApw1Wa(Cbb0oUzH?e^T{`y;}KR1Fg5rydQr2u`zE9 z8>oknYvAycC{~fx_XTYru`o_1Zj4jMrD(*#rYwup2U*iUX4*t@l-`_a5)t>kSHyZY zCBtnl9egEPM(RD%dh;kkHU&r<)=EQRW* z|1#Fu+i_>eR(hOESbn(bYf;%IId`4ynx4Tydfdrokz*R1kr^rqPs{Cfqs-~G24ao* zx)}oHzRhv@oRrx-N_%&?y*l$6-TroLkhqB2^g&yXPWYPN^e`HkNwLnZtkOkY zg#J&bSrW_A??j^7x*(={wXT?Q-MXdxGE}TOcF*(7-}^WR#KmcPM)L;EtP${i#ulVL zxT6HehBNcHCc?FfLwQ(Q`wr9Qh{M-+_`9YJ1M}M4AHvt~LoTJ9Mek>2`NAP7r%?;Z z(h=+BV`pr)L?%=HwTvy$}Z9;Bvt$IRjM65VvQi^B9_SvdTSOX(EC0vai^0}iF? zj_(eqyk$Bl#`W0MHokn)9a1$1x$@0*ijwhhV<*o3oq7wePsAr z+JH2EMVH3bIkalMK3Mg9aBtrWOAeW5&x%;NQ}W3}5{rZp3F=dumy4e)hsa}!86DYV zDRBagC5?W)fIU}BtM1@wJNri+s0P1b{b(on-Sib}B(orhSp6$<@vhb_Mm*>r@89!= zgKYed2%wUX*^VXeI!$@HI-=t5^%wx!h+b~ zBvmuJs-jpyDFyPCppJfnVSam3MP53bbu)ha@=!Rd+@0{#A)P%F4Pstj%|~SXJR3Kc zNxw8Kq-;t!IE@#3dUQfGlX`Ts2o{Cbn`;L;M`1h8WPBPWlP$Szx_o zu1o2Zvl%{SGy1+#>VjNq?!h>%n~4E=Zkz2^9B`~7F2PIeZL<=CGorJew1Fkb!I{lA z0{meeofDni*k(F!ZjYwuVrN{AvcV;uJ$$p{!tRy2)kkHjUwj!g@p0^;HT` zY&h8GDtOO*BY%W7`-4tMaI}nP@5R@m8oIMy+=auV1*c~_jZJ2Cnm3ahBx^;@eh_tW z-S;;3y?k4V>6YESc<)Z7zN|+9e`_V5K+^{(G~?w``BF#Lm{~Jo8Y6|ls%tL%9aZ_f z_^gx>gPMk{F>YNUG+%;FWmEe3kW1;QM^n3bhxa_caY23IwwHbk00;`l#%^)>&S>wY zfgqhGUb5$1KyAFJ1I+V7|lOOVgYB`wT>-_?C%(E1SJ|}7Qi_dx{ zJ@was-p=2SPv_PX))FUM>=UzKtKSt3kWUK!nm-*^z^)(}$_y*(>|47$TDyLprBhCy zw6e|2-?|^UWT0?XGGjJsV?3fT%{NY}FU)*L9gZvgTAiZNSq9dbOACkM7JHo3Lgc}8 zi_aFDMB7Ns6q`IQyYGsgS=$~B_ww~-jLfX%)=uOv`bAVq_}MJ$?BJ;q;vrl|FdS4`vRf?tP{!%v_CeG+crm## zHtBEX`B_`7UtHR;<9$Pq^KNu!)vMe_TODP2#RGEW8aunORQjl0G;VE$cF^ z9U}wE&&s?DEqQQE%!f@DevbDYH@Dq16J@g!#~Wki=~DmfWs*1Xw`U$34`h(yYGAZq z&c$sF^8z=y!6)C5Udk<)sx&t;u&|b!-j&fV6Ol)hZEr6w54bzcEbk+_&}UjRMwQT? zmWQM~8BF+1k9auqx0d9IwD2bl+S5|7%TMxpZQ5s@^c2dpSUMSG3nCULhGRD{kCn^FWmJFC%nH4+ngH}KQWYW=23Db?RTm*XjO2Q7I`yD^RPRwZU%wQ2} zwsa}Dl#3lgpkUf<;<=?{sSk~2U3L{YByviNKutqkqwWNEZ+Beh6tj*a)ORblefE0) z9I=c;=T5l(0qM%vR2~SZ40#j$)fu}Tw;6w16N&PHwC|=tl)r;Y#jcIk`DAS_C!h7k z^ppCb%|S0tQ#mSmqry2~7k7@%WL2u2vFBek{M*Y^rPt5YD{$L7*%j?r`(W^6qPK;S zP1${4BZFBx;~0`ic}82dOV~uE{~s#t?IL;~Ty!IxL+j<3nC`-h8pOZ{M6zPj3T9`y z_o?tj6%9dsE6pk`xiX5J+x%+qd$VQccekU`l{TrJi)@jjEz)eKUY~;3)F!DbgMzF?(Gn*A-p}rakg4kXNOh&t?71_gJXkKawxkNeu@S5xXd z{WGG2Gf$m7Tw3PEG?=mx%+V{`DSzJu%)z@Uau)WA{=iQ5U(K4oWXH2ya(5a=%c?y` zU!}Y{oP0YTL~+@=ku$BwQdjI`&PVcQmreU9mE4Ns-3c&{iF13qFno_6?WzgN=3&8CatSmbk{9YjNa{2 zt066$^~sg_jKt2YH?JGC;IuEx`+|Cjxi#b}F5mq=Y_Mxc6;eASBjKo zxd}b+xS#DgNP==Mbl4N+C!G?|i<|N7?f02GRbNy1J6v;6FZAh0?`C`bc!!Ayldl%} zQd#QIAAMeui4i+1$jp)%*J#Z>I8Q({hi@cE5vK}p#+|3pe&M}TnmnlvdrmqQ5vwwplrqG zC;dE8Qn{N_TK>vlSnQcEt&i{3VXoFT(2RnL;`KNt!^U6JRr7B5r5*VL_nR{pH~ugi z^|@bGX)u)2=F*;$fS0V|YqGuCGMQ?ZN-EBw1b#2lc;(H&jQZ`ZHl8biNAL9fh#nL# z?nQ+z;h$zuny@1X&upIeGgvlv=G`lzJy=uvAt?}IEiIPb0|r*T`S1Sd>GTmI-lRGYo`k1p;b(yXD-vW1d> zeCdHcSsU7zUyu|Sr~hf5T=HO|Pa(}JL|HPl#6!rqL)u$%VSVe|@X#-PjhC4GDy$uU z)vW)r<5*U~F$KDR9Dnu~^owri1nc2G>qjAFHbR;H^SdKMDMt>BNZQzPxLhi}`HA5h z7&~OECm4q2G-D9<-uz@fEW+kTq%4;zo~bZl%{w{L`;z;!(I;kjzpHQyfYBet}uu zRd9w^`}=oW243n-7J8JlnlS4xI%l#4%fmd(n0nxEOK zGe7j>fq5#^?!}kA)7g}Mvfi$gw^sB2ApcJiBpkeH*}MZ1zCN4p+e<1XxWqM>sy89q z@YpD1S4b$NhdC>${blXo#JaSaI6Aq}9g22ZYZKWG3*_2N7NC?*Op~ZL1F`ahrRgnQ zb5V?vM9Xj=f4YWvk}1Rgcq#z{{CZ)je$Jk#4k!L!jI4@oJ*SAPsO`u5#SLA(X~xTf zyIX99vVo@Nsbkz?pR3|z7nt;m4QP_Nm6}ZR zTLl+d7J0OaG^7*QnX1ZyTi@V%**x@_z}k)~kWns$o%c;#7k$KcQtKLKG0q`hNZh4% zmHJR96k6t4Zj(d3Ni7$0NsWCXyV!z?h9Q ze?Y}VhJ@rmo8$F?GG#VWonevcdOz)t@yAH@^IMxk#1fd13-jOAY+MUG_@s#ldAYqCheuZ_SUa`IfU ziJnze4zKVoZf}!_@xL3bd1}rE3I~wfBXb!Sx^ztCUA^%S%c>l=JHb?TPkKd12faVJ zqkU~(C3$(`z^cCaval?lKq8mga zljE;aV3QVfg20Mjc;0E-pBBQ+-!D%2O5e(DoM5&Ufz%&JFqvF8z3m5bdI3$Mworq- zVbA^8fkFkn+ zt+6lAMu67`Rm5u}B1M)`g~20ZsvQJRWcm``s|#}D4VZM%PzXMD*tcs=FsZ_ma01j8 zK07cQ39rl({3rh&$kyUPlymyJx`jZZot>M_HAHXLO(h3W6B0#d7m9V+(`8|j9$vYx zL@uhneyzxVZK;|Rm?{?t?@f*W^gqY0_Z=BRf!ANZw}<~X{{a0Hv5}XzH!7V+uBwzi zEKuQAp@FO`bKw7Bwei0kH~!E6^vxzdEM$kVrAz)CmjB}|W67aPIe&E!C9-wz|Mm*` zUzQ>N*ME?akKc!OTMwDrL|*B?2j%`>e)!(^Vc`@=@6cF`q?3}8Qe2k}2!@;9G#76^ z0|%5Whjzz`cE>R1nsce$S0Y;aC*92&y8QDV(hF8RPMCmFF*2QMba<$i;{^7SUme5r zl{HApN<5d>SyQ{Qg!yHHF)HL0=#fC1l--5%Yp7dWugqQqeT!?A4;6nQ2<>T3B!74U zdI;yru7>6*Ji2TB*{!vm0MatKz58AHI=-dI6u^a5d$9>Nh=4+LCv^pa?pbyGnK;)6al<2e=C|4BeMW_oAM) z;};edj#VI6E-o%^M1=}F`+zq3d=7qhllrD>cJ-M!YQnS=X0<@wmX_D93ZQigS^jni zPtYr5czL2)3FfJJdH|#~#$beSYdbg?Wp|nB>*uC2myBV~C+zG^0~DPYmds^a)r8l) zM@m9t`j9Ic+FXj;Uo6YQLZQ;|3;+Nbmbtg?#UnlS|tIhBMbbXv;lL!(#Wp`Iz8rOLj2KhC|lyE<- zvaK*~VsM3Tk|}{(4Bax@z{_nY4bTra(l^fmgyE%YJ%OEttJYBcN8J^XWB)8A#o0G? zz%OAUAu0Kv<3s;jNuBJH1>)B}9*BpCSv#qP`ZJ)&GN(Qu9~iTOfuJ6)ogKpIJ$!g7 zYIXVWHFmXOwm+S|O}fY=|N>Y{?`I zgh+#PYdE_qthBU|>N7C}COn=?B`r=s=+Kt+0aPRa`LW-Z{TVxU5E+&-?{Y!&Yx z4IC7N-zT%X^3TSgp@m|gu52LH31WFa+^1fH`dItc4{2-9Zc*ow(3D>oG8P%{?!;O+ zF#lkE-*4C>3;fhj01WqhRMzMXVbU+;&3C0x5*l}?0ycJb#BBKnos*X}qnoV;rxZgs zKwh{&-?DRrH}^Es7+2+9l7oxt7dg3nA7dGTJ5(ZC9J=lxOYQ?kpeejj$IL7lkwm1`LM1bYzxYI}w zwax`A(%zrXRbWji(9Te<3cO1j_gSZastJh#-SW&&MRm*bC7e&Iq#QREgiv=~%0_@j zr{LB4EyRB1!$r`_=qM;OG;U8F1)7L8b-8Ybx|lEQ_3Oo_6u2d~$qpRo#WTyLt!<3SpMSnQ!)M%A$JH6{&MXG_>oyU=FSqp0U3}nl9!K z<{=_Xw;+Gn+-K2w`FR`gCB*INY{#C@cdp+=chC1T<>>d|T1Q>s;VfHU=1U3ObWq7c zwehR_Dhd}pD-kRXN+BgFTXY#BGspD}&%5gCXD7S!oe zrxt37K}Db)frly#)K-x*+RMJKb#xwT+od>yvOH%?bipYYS4>ZGt<^`y`>9(z7vKN^ zl?1WzHlmZ{C4`VMT5DIgZe=Ki^$DYP1T;RCW8Q_T!BAp!TpZduT-pG6C$9r3Q9^}# zHl<_sDPgsRyLY&Rw)pGil`H-?_}+@_J&r4P$e0Ks0$*#908__4*3?jF2yk=@Dj<4X=|OR#ugHR3pO|tPZcG`~YzT{N_VFY5oMjXp%O3vovpN zTY%V}8?~fu<~K4s>V$5Xd0ImuRap>UvQ6l!sN^D~M2_%!f7;A+L^%xQ(n(|~ui6BC zClN69dJ3|AnMW2*QJoN*z$zoh5N&RDZiU+lo?JqSG7sp?4YajOF004qfIMH}!0Xq? zWl=!+g#ZH5qEvX^m@Lkum|~dGj1RB73DeaB`i6A97?2>|IFF28XK5y9fyIT^X3wTQ zP{6DCU4`SYM17E;vko(FC;N>Oz}kegRs-LANrm&e63qBkD(qiGx~7tilB+Nm(-bygJ=NT=M90qTOS!oA<7x3|q4~{TwclnfWlxNFOQ5 z&_wbUke=Ivx~OGiY<&EukDWc8>QzhHM0xV@p1W@4_M5%818IVW6r<3kuGy-0rY&Ug z-=o4hwzjs{g2zaMSS%5gFTIfcXF+=5NxcQGX~<}4nxT0RaNLa&Z&;=mNG7ohntr~L z@~ogR*V=5{8+O$Y_#Ysl#Wg^3ZVyWYb$5M)N(+<9hq%fmhbii^5Y&0_mt257{T{mF zBcIIBz(8hJR#v4_>{0gJ&j^_dP#Z-@g{rTPG~uivaVa6$*$`s|{nk4P$Y<3O=5V#1 zc(}DTe)ekt^q|sB=^^(N}ZjZSJ397s1%{b?GqX|S2J_EDgd8Pry62F z|IZQ3Dzp8U*^_UI?QI0VN99*Wsx1|8-R(bE&TXuz2`_dCH}>G&>ZS8mNO02`+_6m4 zluu3#9lxl4J0vlYld_?!wfOuG)+L>Fo__Jcv9W7Fv@o>rHR3_-e&l7!$Ag-1qgR>7 zae2(mi|FFx=|_l_ZQH=ozZjynr&+GcZ-M4X9#ScwY+qG7p=fEM5oR8=qsZm4k=3{(hV1$)K>5ENXl!i^7J^zoOjsgcDl|Jm2rM;JQ8O=dW zcvLam=f}AuH9YHf@x;yAY#fQPk|Z?t@ht40hs$o>KzNiOHbPYPNczlE&rF$!XVfCL zhroA9TC!Z$2K0^Bs+LeMXcfWHQjJ2PP$y~RjWLhzy!7;{PCVE|HU7N z6x}tM?Z$=q_MoVq?TAG{W&DDIVfZusVbL+Mgm(f(eZzrU0IbbjtaQVIwssKVX~OXI zV(t|lY{hX&4myHYN7h$5595@VVpB@6&*6n0HQ~n3KYl17CO~E~5x)V=2!Ua#j7eDQ zK=%N`5gyte1opqu#O4V0etvTa*%YD$Q&K5|oKopZLGkw*`<-@5E#EJzeBSr*&+hSL z*`0xt?X9hE+GG|HfGKiySaV!Q|%Do3AJnsA?{2j9Ms!EPr9rX1k4J6-_cgT8964vuTp;=q=Lz8$yO2U)_fr zh-fxbnPLk}Q0>&a{Ku_5G;;Sq3s2zv_z#aD!{At{R*v9K3|O$_y!H4^5Ix_*k+JIw zAuwFVbaN-bZw0?aL`3Ugk@TAx`*e8R7z_p(WM&Xou}jadZ`4^~)Fn7jbmQ*b)PUU* zggbgX)dNDAi+~e&P9aHj43cBe*Hh}ips*15c>irUErbJk_|x+ii0v{Uh8w`3Q1n$c ztP|idYj?8^y*XHKBx@q|P~r^-6lAB@Qxulj<8#8t5lk*}mJp8V+S>Z;)0$C+uA0Zm zsusbxj?>y@QDB;*y4HP29;_3hlad4gR?)CEp^Tx%$ls2acXJ(UOj({PY2nrn3To7p zAw)lSnsRYS0W|?cneUQhVk>0Dhy@2g*KcI05j}m7Pz5j~0^Hy97oGfdbP+e_lb2keg-UtemU8pbf6HE$%f3bWir7WsD&b ztib2u24bbP$}z?5uy&CV&iuGb8%%*SWe^&Iqw?s!zWTO(zvm-JK|$-}xB7aXGIg{&M0PGQ zA05p*9@LTy8G&V;EFS0`dQj=zu~fxSDa7pe?~g%Pl8}*fY}1VDSm!_#OPCDlZ{(cFA@YEb3);@{!WgL1Mo;+QkhToHyE}y2bf#K_SAZ! z4CS8LQ-^uTvv=2yLZFcgq(PO7>7W1B)wRI&6Z9X5?Us^KaHZ==dT=oHLrt@QLD2_Z zaB90SH$4`0&qL$Gjhkq-nKMXsWWlUAL2$PSj8zNeXHy?srM&o4!lC;^ES>^tHZwVF zitD`UB`%A&*KjNyvwht~b(eP;ua9~zOWWmv{TEV&gic=V2du)dVE&+dh`<=Ckolle zu9Aa`>BWid`-!F;bTf3q7JLLsueUerox6vYHs2Rx;r0O%KA{Xp(%!oHq{cK+mL>*X zOB!+;#m|m4;7W~LNQ{DVNB^;J8cGJ4MWU(?4B`GU~{?3h};#{&y``#<)`- zwalu*m>%IWq=`|5N(GVps`PzSE~cs&LN@KxHl-Mu30}9Xdmt|bQmFvkVBi}e^1GvG z8@MU2(iagVF0}b_{AIajU}z@a`O`5v9&H5+5tGNU29 z3;mVfvi3zRhA1!aTR@a+r=~9~Gatg!Xb5%`0Mz??QQorbHO9@pA=|Z~WrD(R)l#zA z=S>{8j=;i$%;Sys!kQI!CP@-r9O6E*6FoS;-Zs5jPEoP<8nz4}#>81{2>bMx-9E%4 zYBVxpWZW1~lM*oHuF?nH$Ws{MoFqhs`rVZY@R#46iq#e^78;)uu~b1aNpMN^4~xK^ z*PNW3;_iJ6m)WK_KaK2CPl{Tg2VbB0lnsPIS?2c+7dI=D3Pu4mAu28OfQdc|&k>UK zjt8uV)h@K0af0giX-%Sp+r%wd+E3lcO!sLS{9j&LAEKiAB@amqJE0rX&sYSQ&wuha zAFlacC@)ZVFgwx{=Tc=4Js1!~-JhMCa{$Dr-)2I#zP341H-ULbd3B)dxT3CZ6eFOC z$7|zyi{o&yCBKl6Huwo4P*_Oew8O%}kcSa0tR8$_2YW&I19q@qyL(r!s1E`)XA#)u zhOXu*$YN4aQQ|S4k591B_97< zMOi~yX2!Qrx9VR*KS<79Qu``31RN9oy~6hkf9qA17m+%?jJCzPCX5g0HJUpjVmM#RTFBs<(%McXs|S@yGwgPi%yEm24Fxg z5a6M71;EUJiCbfu@A_Q3RmrQuWzQPZi(AbAMnR(#%MPDJLKxJEi;Mh$JI!bOro*t8 zR1hfG_r^+3q?HT^U^N*>p!|zGdJa5IeG`-X8hlVbLbHkVTu2M4ppgfPAxHF&1^2{9HNcWUe(`xRdU}#|o6aqu1XBDf>1a6ctqhzyg@OBj#r4lAk;~B6v z?l1W1POyn10+&t&N}jGp#6CsV1jNYeR2g~z28Wf z)z`0IQ=53)KIif83%0aJh|t?z`*T!(HeWHp|My8=Z5Tj9b3O(7&D zLkxb9w!b4*MQLP2x|W)l+Duhjh~-S;qlQot~VtCT$EvD=X) zyS}u(w_hEBGeP&z`)i4tI?BvVeG7AkQ_TCC)XedRV5tC=@dV$S2DYb#; z7C_?ZDl{^fJxfEL)LNLY7}${SdlX10dCFH~w`T{459HL)9SN`ptfRcLb$SfcVwy zZoh@7Fi?!|NY>T4>t+VMN_}AT3jZdEm)e9P<`#ZGIg$f6YXE#;IEKku{*@jo^t-Z$ zB+njb)}tlXA&^!fW={y=choNRqh)HekZfcs%&}J==wFKdp0BL{tLqhBka2M)*u$JaR3X> zFDcQM_1hSLYo9T#70>Q{I&tXTtD#v(6EmOjZe((nN+k+c*py+m)LdOt4zh65T>Dl2+t~-@8W$%N~p^bij&HRCH+(&@0e>_zO{K4y)!2p|T5x!m}N#7{^xK z3@;iHVDqEy2fZZkz|zwl=y{6cVJC887pIN#8;s^7~A9MI2<)>=d!= zS~5a%Dd>0)RFbMNG+E2LQmd^^Y!0A;-5?+0A*>7oIunsK-}GMkFzBf7?p^{;rB|Co zMrDJbJ`gN$-U=)%)$F6 zkWL6JIF)r6s5oSPJ%0(f?p)~Sp!O-pKJ@bPs%0|#A)Ob0^6LTxXqxOz7w#`yMtF`M z^FjFz{hE4r?%b(s30$WbLVrN2JYYw3C!q0p;LgsD%v5WJCp6V^?7CC-(jXH=m>z9b zBZ0tVsxsRe3ykA+*j+yv1H@H8{Cs`B7oi<(tSa*?0^D$MNIn%%|Hv&+8wT|!Ae4e4 zd0`uYN=43qCba3WNX?|oLpMA_-?oA_p;dMl1{gw!rC7VB`}SlA8HxvSzYPwg%XP{B z#+wpk<%Jjw0M(FjGPrJnf84@!gnT4oL(9T_>)~s~=2DJe1VjxbKf;rvZfCH8cHA6+ zAzWEg`;(X%r8xvSe6IkyzJN)?SU|IK&+|VK0ab07!ey-?(Ci;C4FuOyzvU4-!~#Ti zb=w*-?6nNx;->6$%aV6F-irn~<~i}Iz&@(R+Wo(r5H=yq@*>Pp*xq?1JBL)v5IlLC zL_DWdt`G-wwb%#>J>a$j_4q@Gk$pFRaY zdr1ii2k4zVt{C-%E_elv3ItMp8=Ke2ZXN8t2QL9~YXD}D;pFPU8usla6Vq@rB6O{G z>jvY1lK1|qJM0HC9_i_gP3^n-`T8oSMpC(h(~?G#W7OrujS1(h290w`4Mi$ZSw`yS zZ`()}j+H;eT`ve#?|t{@zoln+FC3}+x?efy)EChXglVAu7{w_#(a zOB&;mY-+|O|Aer;I^EuJGjsRf02Szp#X90DPpL$vS{SnMaFbTfo0!%=(>`zjp~Xkm z)zuZ%6=8PibYbb(zCLTP5BwNX7g9vTTLc9K4Xq}0!f?=edy4_sZte>UtpE&b#(vlNL{cjf=AnJxUttZHuUa4d845b-W0N~XKtRgvJ&JXG$M~;eCq4lG+*=R9|gAz zUX>E}lPtKSYwH!R z&EZgt>mS!>m}pz3O*~tdn0;)AGbImp6i9oZ3ZXf9L%izKC+CLhfLzMFtiQKYcS=@B z?VC6Eo#KDBoM?7j;X4u8t2I47XVs!M|46B z-mmkqC?WQ&*x;4&2y;J&nyHf~!0ijV|AdAZ@?!YSAV-eN=WoS-iDObhU6NvT=CbGG zPc=2t#r;KHp7@F*NUkth9i%ckkXrDdwFpj_ZA{uxqWz6I5(~6y9Aavex~Q zo(m#$$1YO}q2I8jqocyJZOXeUk@w0KLKxPff7pGRi}hq*e?PAZBny(x%%!rd3u#ai zx*R-Q2(itf=fbqVmmbmh2+4OULW}>xh0(du&vU*unb{BwzUm{7;*(C1q)xc8a^Te1 z*zt&86Wy9xvyt&Df0&k*c7&BxJ5I=KhD5S{Qk8WGyS=@?(7ZuaMJ0))>D5m<4KkYC zAbOGRvuD*5KiDWu+3i1>S6B$mhq&)ev^HFevc-A9A?QO>c0IZmN)BK=u0BA%?(JLX z!Mz2OwNsp&kojb7L37aCF&v)Z-c1*iODf;KeS`mFprH|VrcDN z%R5l41v_87e3Ft~Y5wM{+}tTH?5+ic`MRSMvhbuukDRy1avwi_@ywYsfL?$aBw+d^ zh?C+Ff$*=y6YShYa3vrq;;4*^3CukZ!8Eu2G4`v6e&WPQ2>9|q$1I}Ol8$ih=Qn2QOFq<#D^9b=Rg5K0a0JRvn zyMI)QsJSE0+%a?6baM)CYf~9*bjh!8XrS~oMexh`y{aH>uRfIpJ0n2x4Fiik5#YMk{P~3cv>z1 ztGk)Eiu(F=TvRlN*xc&IM^Qk?0ROk_T2DecZ8<5s`fZeRxZ%&AV{YT3)}jf~H+ z6&V$RO&He9hu$~Wu)g*b&dF7eN1wf#TfdxQKdtI`MB{z9R{bjt}s^pV|I$$-18lsG*- zo&Ws#9w=RN%QxadVvU=l{jsO$7-(dlJE?Z`Z2=GB7%m$x+B6A^amx$pNxgoKCh6EPm+zmXHt1T(zY|v zh2@0t+*(=ccrFC4{F%@$Tq?fTy>el+B7d$Eb=%zB!sX=(+n+rfCbo-kz4h;SklwPV zGHGHeeOf_lVjALC$E2NypCqNa)vp4*v^%D248zju^IZphya!1*57zn>%cFx*zGE{0DA@=^Xq1cJlwxOHASuQN!l zu@Tm=K0^Nw%L99UwIhQ<)mf%F`BA*S)&3lnDEj2U@xzCsVxp1@Gc!9SEx&J)aGt>2 z4dc4mm322zQ&Tr=f7wXEc&FO@xg;F8=Y9F10B5*f}dxV$0q%|0CV3);Ko|5kA< zei&VA4PGg{MndM%5TxN>R5lh>RvN$~dq46=_&GNp3%I)Q$wmF&UxkO4RWRs>hW8&9 z{MSz^(AvD8-yRtg(_U|X{_4Lr*05e@NvHo>wN-I-%5~mf_$4cI?Wbxy=F6>Vk`P>^ z1B6wEP9JbNaG>z$Tl4BC--^3e7LG5D-@*Wfj!%GiJBd6$HI;t&q}8ai+eqoJH(Lgc z`JG8p4x39%y}Ng<>H-53t42Rbdt{9V?RhSMpt*h}!bpjbii^Q6d8B`PxM5R0{;!PF zZjD8OX9+U;W`fK)RZ5#mr^)%o&A+^AcarAbzxT9xoLS{h9>UA`uxCi8NP8H=g^0|= z&`Go27AVN6CB(&BVL(Mj&drT1$>Z%$5k)l}N3FY8&dtx;4dXip%7Kl_i1gfCGJ+A3 z_Q#?l$+vq_lH5`NB<5cpM4ulLxoD$S3cUdd*Rf}iY;{ihSL|1-=)5zG_4V~_>*!FM z?@l#@O(UqItg!Q4H&L#14}+l>YQcw!ICfYh49%95GYhNHTzJ8}h=9o9+E&1QTZH8DWV0UACuh`=@6px1Q(7d1(Z(TsG_1 zufJTzhU=TZefu6NSSuOAV~5-M!JyuG8S^nE>-~oKC7F`N$)_qB<7se>(&FPE!gSX8 z5cB@heNE^=e(pVAV-W51lg@2O!oA@9Ca7Ny4i;PbGK;RRma%yGBp7!6457AG3&Amj0(MFcs^vV8xD^&%~z!HJKsGI^`Xt(k3> zTQtC>ql7P&uO@(6oSa(;e(*2J?YgQ5WCb3g=HsK%UEEI5_whs*RbPI(^#c zkAyBxJLP6^o~rFloPeH@Z(k7|27>bP3d-wJVA)W=92FTU=`dcabxB1xYi!}kWHUQt zGK-^w7FV=V!~=L#5=AZ={BiJJD;&p&U5bwDxxL{73JYq`O7C* zK>s~_;o?+tDD?TOgyZ7rKY*+0~<^;3K7KNVQIVzWa+ zkb9?KBYtyvB;(bqd*k$cbZimc8y8U?h%?}liOx6>A)5|=u|uWu%QN3dx{h7Y($Z=Q zVdUh%IjP9kOu3bN;3&7Y)zo8%x4AjRx4~h+asB>J2%H(NbtGlg@e&0j`$FU8K12HV z`t?@->slEo0qtpY{Tf}+!RTVOVbKy>YDwg0mx8X25Bc3etcUx{POZW}< z^t)PgU+BX+O7O|uArSmoXo^r#2^6V=h7iA7;h0UOVsMRIupZF<$oSI(x<>CpZ7(L9qg?iKsPR{qR{PO{E3rS zkSoYBL2RVWIrOHV@hq<%&g!OM+4{B*U-xrrK9?-n6~4B<-XC=|wQowXTR>jkf=R_* z@g@%z`uj9tCp_21U0fLI;oP!6a{mr5y!77{ey2EdaCX0 zTtD0Uz7<@n3!0diNDS&YHtyb{byGaHa;c-WxM)m-N^@QPk0({{_U-b{isanf$i%tB zd#YuS&P0(PJl7wyv*!)Zn3~Q^E(^K2xg9vTX~5k3$EoATM_k{CI1X^Y!`{}^RMsii z6r$YWEZNc0f-RO65qVI>_!W|OBgi!J)ETMVad)jGNi%o%sB(X-CNhRKR>KLmX|5gG z{M|dw#f`=-xwODjCr{=>0U1mR|5*Z;*0_4bVRm-T5zjb=bovx^wzy@H+^9E0`5brt z4QMC8_?`f)06J|YCm>n4Dk`dT(#k3(u{NV~>zqf^LqQXU;TLBW17F{S`uYZm$M>Uu zgmYypggiyQXz%fl$)a864L^~RV&?YrR1$;1Kz_y-i_}$q{dyaASgc5RjFyqnAw7K~ zJ{}&610k>MzrW&0%8)lf=G%97cRgYJ1UfSwNth6|v)7+y`cXuYXALsy3VMCj6x0^J z>pTPS#5yq~Rka6q`ZyG{FXDf^1gnZ@Y{(oOfHJ+f$56W#ZD>ne%Y;EC0)10XCm%jcJN#HerU*U zto#!JJ>0{1%9A~NSkw0apZKfIS{vdS1{LU97|0|$_?Pw&@4z^9O~Ln?V7 z)?K)>Z;z?X@EkN5d)|hhmn(qw11!QYyIlre*}z!e4a}Go8`@$ zg;%{nRq$`qk;%uopF9Crg}r-jKtCLSPbUj4m~JqV(@R~49CMaT#`A4)b8{6=_Vy+} zMGJh}a*^BfMDRBeH7;gkOmAD{`{xf+TfNWU+#ehoZ0qjUf|BR+!oqPp1xVWqo~IrG wT?Jm6X~=QG>&X!WwekP|@c;2iXlMSxrLi%8;*XN&$jMbv)Vx=8_tC%q2W`(xh5!Hn literal 43168 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 Ks%Lk$C&`wxecAx%=f7Y>Dj{7{ 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 KY+Y^X6aO~|G~3hw diff --git a/docs/assets/plots/rabi-dark.png b/docs/assets/plots/rabi-dark.png index 4ef317aaf5bb94a38a6be4ae1d65f6a13c6e6021..e12a152f27ba86dac1128c2548ab73c45900fe7f 100644 GIT binary patch literal 48426 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 literal 48421 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 z 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 KOXo@Ic>foR3b2^~ literal 49944 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 LlF7Mm;QK!S7lX`! diff --git a/docs/assets/plots/t1-dark.png b/docs/assets/plots/t1-dark.png index 7ac2f7bfaa4731f078e3eb43321377c31d0daaf7..4737e6dda5c5e5e1f406c688a69f63c14808d5a9 100644 GIT binary patch literal 40956 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 N$kWx&Wt~$(696y`aO?m8 literal 40325 zcmd?Rby!qy*ET$2f*?OZLd0YQX#@f35@Doc2x$f^Ek#0m7 zx}uZ!<#k#)JQ4bA@a9lfqc9mxOUp5U%;9sraH$!dRHT;I)iDPiR9(MRmNqKo& zX{rR$cH@_YcN+%3RhZ~cbBz=&ytBBMuzesSznvyfgs$Z4KG+f!jp-0_S@rPw=b5

jnEb+Z36GhG;OAX)XJ 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 diff --git a/docs/assets/plots/t1-light.png b/docs/assets/plots/t1-light.png index f0296a3af5506491cedc5875af78fd4a98b5dc89..a4da23b310f5a9db8fe57bc61e4f6c7d8a74a401 100644 GIT binary patch literal 42179 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 D2T=<0 literal 41432 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 L`njxgN@xNAL;_Hi diff --git a/docs/examples/qubit-spectroscopy.md b/docs/examples/qubit-spectroscopy.md index a91c0ce..73a99af 100644 --- a/docs/examples/qubit-spectroscopy.md +++ b/docs/examples/qubit-spectroscopy.md @@ -167,8 +167,8 @@ result.plot( ) ``` -![Readout magnitude against drive frequency, flat except for a sharp peak at 5.000 GHz marked as f01.](../assets/plots/qubit-spectroscopy-light.png#only-light) -![Readout magnitude against drive frequency, flat except for a sharp peak at 5.000 GHz marked as f01.](../assets/plots/qubit-spectroscopy-dark.png#only-dark) +![Readout magnitude against drive frequency, flat except for a sharp peak at 5.000 GHz.](../assets/plots/qubit-spectroscopy-light.png#only-light) +![Readout magnitude against drive frequency, flat except for a sharp peak at 5.000 GHz.](../assets/plots/qubit-spectroscopy-dark.png#only-dark) `channels="magnitude"` is `np.hypot(I, Q)`, and the `qp.plotting.Quantity` on `coords` restates the axis in gigahertz: the arithmetic and the unit it From 2f9c7f676ff63c630d974d20e35890276936b300 Mon Sep 17 00:00:00 2001 From: Vyron Vasileiadis Date: Wed, 2 Sep 2026 12:31:08 +0300 Subject: [PATCH 7/9] add twin axes for plotting parallel sweeps --- .demos/plotting.ipynb | 173 +++++++++++++++++ changelog/35.added.md | 2 +- docs/examples/cz-chevron.md | 3 +- docs/examples/rabi.md | 5 +- docs/guide/control-flow.md | 4 +- docs/guide/execution.md | 5 + docs/guide/plotting.md | 51 +++-- docs/reference/api-qprogram.md | 4 + src/qprogram/plotting/__init__.py | 3 +- src/qprogram/plotting/build.py | 188 +++++++++++++----- src/qprogram/plotting/matplotlib_renderer.py | 111 ++++++++++- src/qprogram/plotting/model.py | 35 +++- src/qprogram/plotting/theme.py | 4 + src/qprogram/result.py | 14 +- tests/test_plotting.py | 189 +++++++++++++++++-- 15 files changed, 707 insertions(+), 84 deletions(-) diff --git a/.demos/plotting.ipynb b/.demos/plotting.ipynb index e69de29..1a1c5e7 100644 --- a/.demos/plotting.ipynb +++ b/.demos/plotting.ipynb @@ -0,0 +1,173 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "28650207", + "metadata": {}, + "outputs": [], + "source": [ + "import qprogram as qp\n", + "\n", + "schema = qp.BusSchema.transmon()\n", + "q = schema.q\n", + "\n", + "program = qp.QProgram(\n", + " label=\"qubit_spectroscopy\",\n", + " description=\"Two-tone spectroscopy of q0\",\n", + " schema=schema,\n", + ")\n", + "freq = program.variable(\"freq\", label=\"Drive frequency\", units=\"Hz\")\n", + "time = program.variable(id=\"time\", label=\"Time\", units=\"ns\")\n", + "\n", + "with program.average(shots=1000):\n", + " with program.sweep(freq, qp.Linspace(4.6e9, 5.4e9, num=201)) | program.sweep(time, qp.Range(0, 200)):\n", + " program.set_frequency(q[0].drive, freq)\n", + " program.play(q[0].drive, \"saturation\")\n", + " program.sync()\n", + " m0 = program.measure(q[0].readout, \"readout\", \"weights\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d376d9cd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('freq|time', 'IQ')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "library = {\n", + " \"saturation\": qp.waveforms.IQPair(qp.waveforms.Square(0.02, 20000), qp.waveforms.Square(0.0, 20000)),\n", + " \"readout\": qp.waveforms.IQPair(qp.waveforms.Square(1.0, 2000), qp.waveforms.Square(0.0, 2000)),\n", + " \"weights\": qp.waveforms.IQPair(qp.waveforms.Square(1.0, 2000), qp.waveforms.Square(1.0, 2000)),\n", + "}\n", + "\n", + "\n", + "def lorentzian(bus, env):\n", + " \"\"\"A saturated transition: unit height at 5 GHz, 8 MHz half width.\"\"\"\n", + " f0, hwhm = 5.0e9, 8e6\n", + " return 1.0 / (1.0 + ((env[\"freq\"] - f0) / hwhm) ** 2) + 0j\n", + "\n", + "\n", + "result = qp.simulate(\n", + " program.with_waveforms(library),\n", + " model=qp.MockMeasurementModel(response=lorentzian, noise=0.01),\n", + ")\n", + "\n", + "data = result.get(m0)\n", + "data.dims # (\"freq\", \"IQ\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a7a565f", + "metadata": {}, + "outputs": [], + "source": [ + "dummy_result = qp.simulate(program.with_waveforms(library))\n", + "dummy_result.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ca899518", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot(m0, channels=\"magnitude\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "293e004d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot(\n", + " m0,\n", + " channels=\"magnitude\",\n", + " coords={\"freq\": qp.plotting.Quantity(units=\"GHz\", transform=lambda v: v / 1e9)},\n", + " value=qp.plotting.Quantity(\"Readout magnitude\"),\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qprogram (3.14.x)", + "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.14.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/changelog/35.added.md b/changelog/35.added.md index e4cf14c..56a656a 100644 --- a/changelog/35.added.md +++ b/changelog/35.added.md @@ -1 +1 @@ -`QProgramResult.plot` draws a measurement. The array is looked up the way `get` looks it up, and its shape chooses the figure: one dimension besides `IQ` gives a line per quadrature, two give a heatmap, and `kind="scatter"` puts I against Q. `channels=` says what to make of the quadratures, `x=` and `y=` which coordinate goes on which axis, and a swept variable's `label` and `units` reach the axis on their own. `coords=` and `value=` restate a quantity for the figure: a `qp.plotting.Quantity` carries the arithmetic and the words it produces in one object, so `{"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}` draws the axis in gigahertz and labels it so, and rescaling values without saying what unit they are now in raises rather than printing a label that contradicts its own numbers. The drawing sits behind a renderer registered by name, so matplotlib is one implementation rather than the only one: `qp.plotting.build_figure` describes a figure using numpy and xarray alone, and `qp.plotting.Style` and `Theme` are frozen dataclasses a light or dark palette of your own replaces. +`QProgramResult.plot` draws a measurement. The array is looked up the way `get` looks it up, and its shape chooses the figure: one dimension besides `IQ` gives a line per quadrature, two give a heatmap, and `kind="scatter"` puts I against Q. `channels=` says what to make of the quadratures, `x=` and `y=` which coordinate goes on which axis, and a swept variable's `label` and `units` reach the axis on their own. A dimension a parallel composition built carries one coordinate per composed variable, and both readings are drawn rather than one being chosen: the first runs along the axis and the second along a twin scale opposite it, in the order the dimension name gives them, so `"freq|time"` reads frequency across the bottom and time across the top. `coords=` and `value=` restate a quantity for the figure: a `qp.plotting.Quantity` carries the arithmetic and the words it produces in one object, so `{"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}` draws the axis in gigahertz and labels it so, and rescaling values without saying what unit they are now in raises rather than printing a label that contradicts its own numbers. The drawing sits behind a renderer registered by name, so matplotlib is one implementation rather than the only one: `qp.plotting.build_figure` describes a figure using numpy and xarray alone, and `qp.plotting.Style` and `Theme` are frozen dataclasses a light or dark palette of your own replaces. diff --git a/docs/examples/cz-chevron.md b/docs/examples/cz-chevron.md index 408b177..6e98cb3 100644 --- a/docs/examples/cz-chevron.md +++ b/docs/examples/cz-chevron.md @@ -221,7 +221,8 @@ The two sources must then hold the same number of points, and both do here at `ValidationError: parallel loops must have the same number of iterations to advance in lockstep; got Sweep('amp'): 11, Sweep('dur'): 12`. The results come back on one `"amp|dur"` dimension of 101 points carrying `amp` and `dur` as -coordinates along it. See [Control flow](../guide/control-flow.md). +coordinates along it, which `plot` draws as one axis with the other above it. +See [Control flow](../guide/control-flow.md). For the SNZ flavor of CZ, swap the waveform and leave the rest of the program alone: diff --git a/docs/examples/rabi.md b/docs/examples/rabi.md index daaa11b..a94715b 100644 --- a/docs/examples/rabi.md +++ b/docs/examples/rabi.md @@ -256,8 +256,9 @@ subclassing `BusSchema` gives typed accessors. See To sweep frequency as well, add `program.set_frequency(q[0].drive, freq)` and a second sweep. Nesting the two gives the full grid and a two-dimensional result; composing them with `|` advances them in lockstep and gives one -`"gain|freq"` dimension carrying both coordinates. Both loops must then have -the same length. See [Control flow](../guide/control-flow.md). +`"gain|freq"` dimension carrying both coordinates, which `plot` draws as one +axis and a twin axis above it. Both loops must then have the same length. See +[Control flow](../guide/control-flow.md). To read the classified state instead of the IQ point, request `fields=(qp.MeasurementField.STATE,)` and read diff --git a/docs/guide/control-flow.md b/docs/guide/control-flow.md index be9d992..85319ec 100644 --- a/docs/guide/control-flow.md +++ b/docs/guide/control-flow.md @@ -485,7 +485,9 @@ in, since the inherited walk over the body alone would miss them. In the result `DataArray` a parallel composition is one dimension, named by joining the variable ids with `|` (`"freq|gain"`), and each variable contributes -its own coordinate array on that shared dimension. +its own coordinate array on that shared dimension. `plot` reads the first two of +them on an axis and a twin axis opposite it, in the order the name gives — see +[Plotting results](plotting.md#two-variables-on-one-axis). `Parallel` has no context-manager method of its own. Constructing one directly, as an analyzer or a code generator might, is `qp.blocks.Parallel(loops=[...])` diff --git a/docs/guide/execution.md b/docs/guide/execution.md index da44c35..593bc23 100644 --- a/docs/guide/execution.md +++ b/docs/guide/execution.md @@ -124,6 +124,11 @@ da.coords["a"].values # [0.0, 0.5, 1.0] da.coords["b"].values # [10.0, 15.0, 20.0] ``` +Both coordinates describe the same three samples, which is why a figure of them +reads one along the axis and the other on a twin scale opposite it rather than +picking between them. See +[Plotting results](plotting.md#two-variables-on-one-axis). + The trailing dimensions depend on which field you ask for. Writing `*sweeps` for the loop dimensions above: diff --git a/docs/guide/plotting.md b/docs/guide/plotting.md index fecb03a..64c143d 100644 --- a/docs/guide/plotting.md +++ b/docs/guide/plotting.md @@ -108,19 +108,45 @@ result.plot(m0) # x is "dur", the inner sweep result.plot(m0, x="amp") # x is "amp", so "dur" moves to y ``` -A dimension built by a parallel composition is the case where the default has -no answer. It composes several variables onto one dimension and carries one -coordinate per variable, so there is no single set of values to put on the -axis. Asking anyway raises, because the alternative is worse: `coords["a|b"]` -returns a plain integer range rather than failing, so a guess would produce a -wrong axis that looks entirely plausible. +## Two variables on one axis + +A dimension built by a parallel composition carries one coordinate per composed +variable and none of its own, so there are two readings of every sample and no +reason to throw one away. Both are drawn: the first goes on the axis and the +second on a twin scale opposite it, which is matplotlib's `secondary_xaxis`, +the position-tracking form of `twiny`. The order is the order the dimension +name gives, which is the order the loops were written in, so `"freq|time"` +draws frequency along the bottom and time along the top. + +```python +with program.sweep(freq, qp.Range(4e9, 5e9, 25e6)) | program.sweep(time, qp.Range(0, 400, 10)): + m0 = program.measure(q[0].readout, "readout", "weights") + +result.plot(m0) # freq along the bottom, time along the top +``` + +The twin ticks at samples rather than at round numbers. The two loops advanced +in lockstep, so tick *i* and sample *i* are the same measurement, and putting a +tick anywhere else would mean interpolating between measured points to label a +position nothing was measured at. `Style(twin_ticks=...)` is how many to aim +for; a sweep shorter than that gets one per sample. + +`x=` and `y=` name an axis to draw on its own, which is how an axis with +nothing above it is asked for: ```python -result.plot(m0) # ValidationError: 'a|b' composes 2 swept variables -result.plot(m0, x="a") # that variable's values, and its label -result.plot(m0, x="a|b") # the sweep index, if that is what you meant +result.plot(m0, x="freq") # frequency along the bottom, nothing on top +result.plot(m0, x="time") # time along the bottom instead +result.plot(m0, x="freq|time") # the sweep index, if that is what you meant ``` +A heatmap twins each axis separately, so a chevron whose inner loop is a +composition reads its second variable across the top and a composition on the +outer loop reads up the right-hand side. A composition of three or more +variables draws the first two and leaves the rest: two scales on one axis is +already the most a reader can follow, and the coordinates are all still on the +array for a caller who wants a different one. + ## Restating a quantity A result carries hertz because the instrument takes hertz, and the figure of it @@ -141,6 +167,7 @@ result.plot( `coords=` is keyed by the name the axis resolved to, which is the same string `x=` takes: the coordinate on the axis, or the dimension when no coordinate is. +A twin scale is keyed by its own coordinate the same way. A key that reaches no axis raises rather than doing nothing, since a figure that ignored it would print the axis it was asked to change. `value=` is the measured quantity wherever it lands: the y axis of a line, the colour bar of a @@ -225,9 +252,9 @@ result.plot(m0, style=qp.plotting.Style(theme=house)) ``` `Style` carries `size`, `linewidth`, `markers`, `markersize`, `point_size`, -`point_alpha`, `grid`, `legend`, and `colorbar` alongside `theme`. `markers` is -worth turning on for a coarse sweep, where the points are the measurement and -the line between them is interpolation. +`point_alpha`, `grid`, `legend`, `colorbar`, and `twin_ticks` alongside `theme`. +`markers` is worth turning on for a coarse sweep, where the points are the +measurement and the line between them is interpolation. ## Another renderer diff --git a/docs/reference/api-qprogram.md b/docs/reference/api-qprogram.md index 567af73..f89f500 100644 --- a/docs/reference/api-qprogram.md +++ b/docs/reference/api-qprogram.md @@ -480,6 +480,10 @@ in `qprogram.plotting`, which the top level does not re-export. options: show_root_full_path: false +::: qprogram.plotting.Twin + options: + show_root_full_path: false + ::: qprogram.plotting.Style options: show_root_full_path: false diff --git a/src/qprogram/plotting/__init__.py b/src/qprogram/plotting/__init__.py index 5fd6aba..a62b015 100644 --- a/src/qprogram/plotting/__init__.py +++ b/src/qprogram/plotting/__init__.py @@ -33,7 +33,7 @@ from __future__ import annotations from qprogram.plotting.build import CHANNELS, IQ_DIM, KINDS, build_figure -from qprogram.plotting.model import Figure, Line, Mark, Mesh, Points +from qprogram.plotting.model import Figure, Line, Mark, Mesh, Points, Twin from qprogram.plotting.quantity import Quantity from qprogram.plotting.renderers import ( DEFAULT_RENDERER, @@ -60,6 +60,7 @@ "Renderer", "Style", "Theme", + "Twin", "available_renderers", "build_figure", "register_renderer", diff --git a/src/qprogram/plotting/build.py b/src/qprogram/plotting/build.py index bd02cc6..d3d6b72 100644 --- a/src/qprogram/plotting/build.py +++ b/src/qprogram/plotting/build.py @@ -22,6 +22,11 @@ measured point, so it becomes the series of a line figure, the two axes of a scatter, or a single derived surface for a heatmap — see the ``channels`` argument. Every other dimension, ``"time"`` included, is a plot dimension, which is what makes a raw trace plot against time on its own. + +A dimension a parallel composition built carries one coordinate per composed variable rather than +one for itself. The first two become an axis and its [`Twin`][qprogram.plotting.Twin], in the order +the dimension name gives them, because the loops advanced in lockstep and both readings describe the +same samples. """ from __future__ import annotations @@ -32,7 +37,7 @@ import numpy as np from qprogram.errors import ValidationError -from qprogram.plotting.model import Figure, Line, Mesh, Points +from qprogram.plotting.model import Figure, Line, Mesh, Points, Twin from qprogram.plotting.quantity import Quantity, checked, restated, text if TYPE_CHECKING: @@ -87,6 +92,25 @@ class _Resolved: units: str | None +@dataclass(frozen=True, eq=False) +class _Axis: + """One finished axis: the numbers to draw on it, the words for it, and the twin beside it. + + Attributes: + positions (numpy.ndarray): The positions along the axis, restated. + label (str): The text for the axis, restated. + twin (Twin | None): The second scale a composed dimension left over, or ``None``. + drawn (tuple[tuple[str, str], ...]): The ``(name, role)`` of everything this axis consumed a + ``coords`` key for — one entry, or two when it carries a twin. `_unused` lists these back + to a caller whose key reached nothing. + """ + + positions: np.ndarray + label: str + twin: Twin | None + drawn: tuple[tuple[str, str], ...] + + def build_figure( # ruff: ignore[too-many-arguments] # every argument is one decision about the figure data: xr.DataArray, *, @@ -107,9 +131,11 @@ def build_figure( # ruff: ignore[too-many-arguments] # every argument is one d kind (str | None): One of `KINDS`. ``None`` infers it from the shape: one plot dimension gives ``"line"``, two give ``"heatmap"``. ``"scatter"`` is never inferred — plotting I against Q is a choice no shape implies. - x (str | None): Dimension or coordinate to put on the x axis. Required when the dimension - composes several swept variables, since it holds one coordinate per variable and no - preference between them. + x (str | None): Dimension or coordinate to put on the x axis, drawn alone — naming an axis + is what settles it, so no [`Twin`][qprogram.plotting.Twin] follows. ``None`` takes the + dimension's own coordinate, or for a dimension a parallel composition built, the first + two coordinates in the order the dimension name gives them: the first on the axis and + the second as its twin. y (str | None): The same for the y axis of a ``"heatmap"``. The two arguments name different dimensions; naming one leaves the other for the axis not named. Only a heatmap has a second axis to choose, so a line or a scatter rejects it rather than ignoring it. @@ -120,8 +146,9 @@ def build_figure( # ruff: ignore[too-many-arguments] # every argument is one d surface and has no rotation to prefer I with. Rejected for an array with no ``"IQ"`` dimension, such as a ``state`` field. coords (collections.abc.Mapping[str, Quantity] | None): Restatements for the swept - coordinates, keyed by the name each axis resolved to — the same string ``x=`` or ``y=`` - takes, or the coordinate's own name when neither was given. Each + coordinates, keyed by the name each axis or [`Twin`][qprogram.plotting.Twin] resolved to + — the same string ``x=`` or ``y=`` takes, or the coordinate's own name when neither was + given. Each [`Quantity`][qprogram.plotting.Quantity] carries the arithmetic and the words it produces together, so ``{"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}`` puts gigahertz on the axis and says so. A key naming no axis this figure draws raises: a @@ -139,10 +166,10 @@ def build_figure( # ruff: ignore[too-many-arguments] # every argument is one d Raises: ValidationError: If ``kind`` or ``channels`` is not a known name; if the array's shape does not suit the requested kind; if ``x`` or ``y`` names something that is not a coordinate - on a plot dimension, or a composed dimension is left without one; if ``coords`` or - ``value`` holds anything but a [`Quantity`][qprogram.plotting.Quantity]; if a ``coords`` - key names no axis this figure draws; or if a restatement changes the numbers without the - unit, or the unit without the numbers. + on a plot dimension; if ``coords`` or ``value`` holds anything but a + [`Quantity`][qprogram.plotting.Quantity]; if a ``coords`` key names no axis this figure + draws; or if a restatement changes the numbers without the unit, or the unit without the + numbers. """ if kind is not None and kind not in KINDS: msg = f"kind must be one of {', '.join(KINDS)}, got {kind!r}" @@ -272,20 +299,25 @@ def _lines( # ruff: ignore[too-many-arguments] ) raise ValidationError(msg) dim = dims[0] - resolved = _axis(data, dim, x, "x") - positions, x_label = _consume(rescales, resolved) - _unused(rescales, ((resolved.name, "the x axis"),), data, "line") + across = _axis(data, dim, x, "x", rescales) + _unused(rescales, across.drawn, data, "line") channels = channels or _default_channels(data, "line") label, units = _measured(data, channels) marks: tuple[Mark, ...] = tuple( Line( - x=positions, + x=across.positions, y=restated(value, np.asarray(values.transpose(dim).values), _VALUE), label=series, ) for series, values in _channels(data, channels, "line") ) - return Figure(marks=marks, x_label=x_label, y_label=text(value, label, units, _VALUE), title=title) + return Figure( + marks=marks, + x_label=across.label, + y_label=text(value, label, units, _VALUE), + title=title, + x_twin=across.twin, + ) def _heatmap( # ruff: ignore[too-many-arguments] @@ -324,21 +356,26 @@ def _heatmap( # ruff: ignore[too-many-arguments] ) raise ValidationError(msg) x_dim, y_dim = _mesh_dims(data, dims, x, y) - across = _axis(data, x_dim, x, "x") - up = _axis(data, y_dim, y, "y") - columns, x_label = _consume(rescales, across) - rows, y_label = _consume(rescales, up) - _unused(rescales, ((across.name, "the x axis"), (up.name, "the y axis")), data, "heatmap") + across = _axis(data, x_dim, x, "x", rescales) + up = _axis(data, y_dim, y, "y", rescales) + _unused(rescales, across.drawn + up.drawn, data, "heatmap") channels = channels or _default_channels(data, "heatmap") ((_, values),) = _channels(data, channels, "heatmap") label, units = _measured(data, channels) mesh = Mesh( - x=columns, - y=rows, + x=across.positions, + y=up.positions, values=restated(value, np.asarray(values.transpose(y_dim, x_dim).values), _VALUE), label=text(value, label, units, _VALUE), ) - return Figure(marks=(mesh,), x_label=x_label, y_label=y_label, title=title) + return Figure( + marks=(mesh,), + x_label=across.label, + y_label=up.label, + title=title, + x_twin=across.twin, + y_twin=up.twin, + ) def _consume(rescales: dict[str, Quantity], resolved: _Resolved) -> tuple[np.ndarray, str]: @@ -481,39 +518,106 @@ def _dim_of(data: xr.DataArray, dims: tuple[str, ...], name: str, argument: str) raise ValidationError(msg) -def _axis(data: xr.DataArray, dim: str, requested: str | None, argument: str) -> _Resolved: - """Resolve the positions, the name and the inherited label of one axis. +def _axis( + data: xr.DataArray, + dim: str, + requested: str | None, + argument: str, + rescales: dict[str, Quantity], +) -> _Axis: + """Resolve one axis of a figure, restate it, and pick up any twin beside it. Args: data (xarray.DataArray): The array being plotted. dim (str): The plot dimension this axis shows. requested (str | None): The dimension or coordinate the caller named for this axis, if any. - argument (str): ``"x"`` or ``"y"``, for the error messages. + argument (str): ``"x"`` or ``"y"``, for the error messages and the roles in them. + rescales (dict[str, Quantity]): Restatements keyed by coordinate. Mutated: this axis and its + twin each pop their own. Returns: - What this axis draws, still unrestated. + The finished axis. + + Raises: + ValidationError: If ``requested`` is not a coordinate on ``dim``, or if a restatement this + axis consumed changes the numbers without the unit, or the unit without the numbers. + """ + primary, partner = _coordinates(data, dim, requested, argument) + positions, label = _consume(rescales, primary) + role = f"the {argument} axis" + if partner is None: + return _Axis(positions=positions, label=label, twin=None, drawn=((primary.name, role),)) + values, twin_label = _consume(rescales, partner) + return _Axis( + positions=positions, + label=label, + twin=Twin(positions=positions, values=values, label=twin_label), + drawn=((primary.name, role), (partner.name, f"the twin of {role}")), + ) + + +def _coordinates( + data: xr.DataArray, + dim: str, + requested: str | None, + argument: str, +) -> tuple[_Resolved, _Resolved | None]: + """Choose the coordinate an axis draws, and the one that doubles it. + + A dimension a parallel composition built carries one coordinate per composed variable and none + of its own. Its loops advanced in lockstep, though, so every one of those coordinates describes + the same samples, and the second reading of them is a twin axis rather than a choice to be made: + the first two coordinates go on the axis and opposite it. Naming ``x=`` or ``y=`` draws that one + alone, which is how an axis with nothing above it is asked for. + + A composition of three or more leaves the rest undrawn. Two scales on one axis is already the + most a reader can follow, and a third would be a legend rather than an axis; the coordinates are + all still on the array for a caller who wants one of them instead. + + Args: + data (xarray.DataArray): The array being plotted. + dim (str): The plot dimension this axis shows. + requested (str | None): The dimension or coordinate the caller named for this axis, if any. + argument (str): ``"x"`` or ``"y"``, for the error message. + + Returns: + The coordinate on the axis, and the one to twin it with or ``None``. Raises: - ValidationError: If ``requested`` is not a coordinate on ``dim``, or if the dimension - composes several variables and nothing chose between them. + ValidationError: If ``requested`` is not a coordinate on ``dim``. """ if requested is not None: _dim_of(data, (dim,), requested, argument) - return _coordinate(data, dim, requested) + return _coordinate(data, dim, requested), None if dim in data.coords: - return _coordinate(data, dim, dim) - candidates = [str(name) for name, coord in data.coords.items() if coord.dims == (dim,)] - if len(candidates) == 1: - return _coordinate(data, dim, candidates[0]) + return _coordinate(data, dim, dim), None + candidates = _candidates(data, dim) if not candidates: - return _Resolved(name=dim, values=np.arange(data.sizes[dim]), label=dim, units=None) - choices = " or ".join(f"{argument}={name!r}" for name in candidates) - msg = ( - f"Dimension {dim!r} composes {len(candidates)} swept variables, so it carries no single " - f"coordinate to put on the {argument} axis. Name one with {choices}, or {argument}={dim!r} " - f"for the sweep index." - ) - raise ValidationError(msg) + return _Resolved(name=dim, values=np.arange(data.sizes[dim]), label=dim, units=None), None + primary = _coordinate(data, dim, candidates[0]) + if len(candidates) == 1: + return primary, None + return primary, _coordinate(data, dim, candidates[1]) + + +def _candidates(data: xr.DataArray, dim: str) -> list[str]: + """List the coordinates lying along ``dim``, in the order the dimension name gives them. + + A parallel composition names its dimension by joining the ids of the variables it composes with + ``"|"``, so the name is the declaration order of the loops — which is the order the axis and its + twin are wanted in, and not what a mapping of coordinates hands back. A name that spells none of + them out, which is any array not built by the executor, leaves the array's own order alone. + + Args: + data (xarray.DataArray): The array being plotted. + dim (str): The dimension to look along. + + Returns: + The coordinate names, the ones the dimension name spells out first. + """ + along = [str(name) for name, coord in data.coords.items() if coord.dims == (dim,)] + ranked = [part for part in dim.split("|") if part in along] + return ranked + [name for name in along if name not in ranked] def _coordinate(data: xr.DataArray, dim: str, name: str) -> _Resolved: diff --git a/src/qprogram/plotting/matplotlib_renderer.py b/src/qprogram/plotting/matplotlib_renderer.py index ffc95da..4b28186 100644 --- a/src/qprogram/plotting/matplotlib_renderer.py +++ b/src/qprogram/plotting/matplotlib_renderer.py @@ -19,7 +19,9 @@ `ModuleNotFoundError`. The frame it draws is deliberately quiet: no top or right spine, ticks with no marks, grid lines -behind the data, and a legend with no box. What should carry the eye is the data. +behind the data, and a legend with no box. What should carry the eye is the data. The exception is a +[`Twin`][qprogram.plotting.Twin], which puts a spine back on the side it reads from, because a +second scale that does not announce itself is worse than no second scale. """ from __future__ import annotations @@ -27,20 +29,35 @@ from typing import TYPE_CHECKING, cast import matplotlib.pyplot as plt +import numpy as np from matplotlib.colors import LinearSegmentedColormap from qprogram.plotting.model import Line, Points if TYPE_CHECKING: + from typing import Literal + from matplotlib.axes import Axes from matplotlib.figure import Figure as MatplotlibFigure + from numpy.typing import ArrayLike - from qprogram.plotting.model import Figure, Mesh + from qprogram.plotting.model import Figure, Mesh, Twin from qprogram.plotting.theme import Style # Data sits above the grid and below the annotations that point at it. _DATA_LAYER = 3 +# Gap between the axes and the colour bar, in fractions of the axes width. The twinned figure needs +# the wider one: its y twin reads up the right-hand side, where the narrow gap would put the colour +# bar through the tick labels. +_COLORBAR_PAD = 0.02 +_TWINNED_COLORBAR_PAD = 0.13 + +# Significant figures on a twin's tick labels. The ticks sit at samples rather than at round +# numbers, so most of them are values no formatter would have chosen and four digits is where they +# stop growing the axis without saying more. +_TWIN_TICK_DIGITS = 4 + def render(figure: Figure, style: Style, target: Axes | None = None) -> Axes: """Draw ``figure`` on a matplotlib `Axes`. @@ -56,7 +73,11 @@ def render(figure: Figure, style: Style, target: Axes | None = None) -> Axes: """ ax = target if ax is None: - fig, ax = plt.subplots(figsize=style.size) + # A twin puts a scale where the default margins have nothing reserved — above the title, or + # between the axes and the colour bar — so a figure carrying one is laid out constrained. + # A figure the caller brought keeps whatever layout the caller gave it. + twinned = figure.x_twin is not None or figure.y_twin is not None + fig, ax = plt.subplots(figsize=style.size, layout="constrained" if twinned else None) fig.set_facecolor(style.theme.surface) _frame(ax, style) @@ -70,13 +91,17 @@ def render(figure: Figure, style: Style, target: Axes | None = None) -> Axes: series += 1 else: # ``Mark`` is a closed union of the three, so what is left is a Mesh. - _mesh(ax, mark, style) + _mesh(ax, mark, style, _TWINNED_COLORBAR_PAD if figure.y_twin else _COLORBAR_PAD) ax.set_xlabel(figure.x_label) ax.set_ylabel(figure.y_label) if figure.title: ax.set_title(figure.title, color=style.theme.text, fontsize=10, loc="left", pad=6) _legend(ax, figure, style) + # Last, because a twin is furniture over a finished axis: it reads the scale and the limits the + # marks and the labels above have already settled. + _twin(ax, figure.x_twin, style, "x") + _twin(ax, figure.y_twin, style, "y") return ax @@ -150,13 +175,14 @@ def _points(ax: Axes, mark: Points, style: Style, series: int) -> None: ) -def _mesh(ax: Axes, mark: Mesh, style: Style) -> None: +def _mesh(ax: Axes, mark: Mesh, style: Style, pad: float) -> None: """Draw one coloured surface, with its colour bar. Args: ax (Axes): The axes to draw on. mark (Mesh): The grid and its colour-bar label. style (Style): The palette the ramp is built from, and whether a colour bar is wanted. + pad (float): Gap between the axes and the colour bar, as a fraction of the axes width. """ theme = style.theme cmap = LinearSegmentedColormap.from_list("qprogram-sequential", theme.ramp) @@ -164,7 +190,7 @@ def _mesh(ax: Axes, mark: Mesh, style: Style) -> None: if not style.colorbar: return # An Axes always belongs to a figure; the annotation admits None for an axes under teardown. - bar = cast("MatplotlibFigure", ax.get_figure()).colorbar(mesh, ax=ax, pad=0.02) + bar = cast("MatplotlibFigure", ax.get_figure()).colorbar(mesh, ax=ax, pad=pad) if mark.label: bar.set_label(mark.label, color=theme.muted, fontsize=10) bar.ax.tick_params(colors=theme.muted, labelsize=9, length=0) @@ -172,6 +198,79 @@ def _mesh(ax: Axes, mark: Mesh, style: Style) -> None: bar.outline.set_linewidth(0.8) +def _identity(values: ArrayLike) -> ArrayLike: + """Return ``values`` unchanged. + + A secondary axis is defined by the pair of functions mapping between its scale and the parent's. + A twin shares the parent's samples, so the pair is this function twice and the ticks are placed + at positions the builder already worked out. + + Args: + values (numpy.typing.ArrayLike): Positions on either scale. + + Returns: + The same positions. + """ + return values + + +def _twin(ax: Axes, twin: Twin | None, style: Style, orientation: Literal["x", "y"]) -> None: + """Draw the second scale a parallel composition left on one axis. + + matplotlib's `Axes.secondary_xaxis` rather than `Axes.twiny`: a secondary axis is an artist of + the axes it doubles, so it follows the position a colour bar shrank and the limits a later + ``set_xlim`` changes, where a twinned Axes is a second Axes that has to be kept in step by hand. + The scale is the identity and the ticks are fixed at the samples, since the two variables + advanced in lockstep and every tick is a measurement rather than a round number. + + Args: + ax (Axes): The axes to add the scale to. + twin (Twin | None): The scale to draw, or ``None`` to draw none. + style (Style): The palette, and how many ticks a twin gets. + orientation (Literal["x", "y"]): ``"x"`` for a scale along the top, ``"y"`` for one up the + right side. + """ + if twin is None: + return + theme = style.theme + if orientation == "x": + secondary = ax.secondary_xaxis("top", functions=(_identity, _identity)) + side, axis = "top", secondary.xaxis + else: + secondary = ax.secondary_yaxis("right", functions=(_identity, _identity)) + side, axis = "right", secondary.yaxis + positions, labels = _twin_ticks(twin, style.twin_ticks) + secondary.set_ticks(positions, labels=labels) + axis.set_label_text(twin.label) + axis.label.set_color(theme.muted) + axis.label.set_fontsize(10) + secondary.tick_params(colors=theme.muted, labelsize=9, length=0) + # The secondary axes is a sliver the height of a hairline, so its patch would paint a line of + # surface colour over the spine it sits on. + secondary.patch.set_visible(False) + secondary.spines[side].set_color(theme.grid) + + +def _twin_ticks(twin: Twin, wanted: int) -> tuple[np.ndarray, list[str]]: + """Choose where to tick a twin scale and what to write at each tick. + + The ticks land on samples, evenly spaced through the sweep and always including its ends. A + parallel sweep need not be linear in either variable, and putting the ticks anywhere else would + mean interpolating between measured points to label a position nothing was measured at. + + Args: + twin (Twin): The scale being drawn. + wanted (int): How many ticks to aim for. A sweep with fewer samples than that gets one per + sample. + + Returns: + The tick positions, on the parent axis's scale, and the text for each. + """ + total = len(twin.positions) + indices = np.unique(np.linspace(0, total - 1, min(max(wanted, 2), total)).round().astype(int)) + return twin.positions[indices], [f"{value:.{_TWIN_TICK_DIGITS}g}" for value in twin.values[indices]] + + def _legend(ax: Axes, figure: Figure, style: Style) -> None: """Add a legend when there is more than one named mark to tell apart. diff --git a/src/qprogram/plotting/model.py b/src/qprogram/plotting/model.py index 30f2994..883245a 100644 --- a/src/qprogram/plotting/model.py +++ b/src/qprogram/plotting/model.py @@ -15,8 +15,10 @@ A [`Figure`][qprogram.plotting.Figure] is a sequence of marks and the two axis labels they share. A mark is one of three shapes — a [`Line`][qprogram.plotting.Line], a [`Points`][qprogram.plotting.Points] cloud, or a -[`Mesh`][qprogram.plotting.Mesh] — each holding plain numpy arrays. There is no colour here, no figure size, and no -reference to a plotting library: those belong to [`Style`][qprogram.plotting.Style] and to the renderer. +[`Mesh`][qprogram.plotting.Mesh] — each holding plain numpy arrays. An axis may also carry a +[`Twin`][qprogram.plotting.Twin], a second scale reading the same samples in another variable. There is no colour +here, no figure size, and no reference to a plotting library: those belong to +[`Style`][qprogram.plotting.Style] and to the renderer. Keeping the description separate is what makes a second renderer possible at all. It is also what lets a caller inspect what would be drawn without drawing it, which is how the tests in @@ -88,6 +90,29 @@ class Mesh: """Any one of the three shapes a figure is built from.""" +@dataclass(frozen=True, eq=False) +class Twin: + """A second scale along one axis, reading the same samples as another variable. + + This is what a parallel composition leaves behind. Its loops advance in lockstep, so the + variables it composes share one dimension and one set of samples, and sample *i* of the axis and + tick *i* of the twin are the same measurement. That is what makes the second scale a fact about + the data rather than a coincidence of two ranges, and it is why nothing here needs interpolating. + + Attributes: + positions (numpy.ndarray): Where the samples sit along the axis this twin doubles, in that + axis's own drawn numbers — so a renderer places a tick without knowing which axis it is + or what it was restated by. + values (numpy.ndarray): What the twinned variable read at those same samples, in the same + order. Same length as ``positions``. + label (str): Text for the twin axis, already carrying its units. + """ + + positions: np.ndarray + values: np.ndarray + label: str + + @dataclass(frozen=True, eq=False) class Figure: """A set of marks sharing one pair of axes. @@ -99,9 +124,15 @@ class Figure: x_label (str): Text for the x axis, already carrying its units. y_label (str): Text for the y axis, already carrying its units. title (str | None): Title above the axes, or ``None`` for none. + x_twin (Twin | None): A second scale to draw opposite the x axis, or ``None`` for none. A + renderer with nowhere to put one may ignore it: it repeats what the x axis already + shows, in another variable. + y_twin (Twin | None): The same for the y axis. """ marks: tuple[Mark, ...] x_label: str y_label: str title: str | None = None + x_twin: Twin | None = None + y_twin: Twin | None = None diff --git a/src/qprogram/plotting/theme.py b/src/qprogram/plotting/theme.py index 9e57b07..da5f6f6 100644 --- a/src/qprogram/plotting/theme.py +++ b/src/qprogram/plotting/theme.py @@ -89,6 +89,9 @@ class Style: grid (bool): Draw grid lines behind the data. legend (bool): Draw a legend when the figure has more than one labelled mark. colorbar (bool): Draw a colour bar beside a [`Mesh`][qprogram.plotting.Mesh]. + twin_ticks (int): How many ticks a [`Twin`][qprogram.plotting.Twin] scale gets. They land on + samples rather than on round numbers, so this is the count the renderer aims for and a + sweep shorter than it gets one tick per sample; two is the floor. """ theme: Theme = LIGHT @@ -101,6 +104,7 @@ class Style: grid: bool = True legend: bool = True colorbar: bool = True + twin_ticks: int = 5 def color(self, index: int) -> str: """Return the categorical colour for series ``index``, cycling when the theme runs out. diff --git a/src/qprogram/result.py b/src/qprogram/result.py index b0a780a..69d426b 100644 --- a/src/qprogram/result.py +++ b/src/qprogram/result.py @@ -330,7 +330,8 @@ def plot( # ruff: ignore[too-many-arguments] # every argument is one decision The shape of the array chooses the figure. One dimension besides ``"IQ"`` gives a line per quadrature, two give a heatmap of the magnitude, and ``kind="scatter"`` plots I against Q, which no shape implies on its own. A swept variable's ``label`` and ``units`` reach the axis - from the coordinate the executor wrote them onto. + from the coordinate the executor wrote them onto, and a dimension a parallel composition + built brings two of them, the second read on a twin axis opposite the first. Args: measurement (MeasurementHandle | str | int): Which measurement to draw, by handle, by @@ -340,15 +341,18 @@ def plot( # ruff: ignore[too-many-arguments] # every argument is one decision `IQ`. kind (str | None): ``"line"``, ``"heatmap"`` or ``"scatter"``. Inferred from the shape when omitted. - x (str | None): Dimension or coordinate for the x axis. Required when the dimension - composes several swept variables in parallel, because it holds one coordinate per - variable and the sweep index is a plausible-looking wrong answer. + x (str | None): Dimension or coordinate for the x axis, drawn on its own. A dimension a + parallel composition built needs no such argument: its loops advanced in lockstep, + so its first two coordinates go on the axis and opposite it as a + [`Twin`][qprogram.plotting.Twin] scale, in the order the dimension name gives them. + Naming one here is how a bare axis is asked for instead. y (str | None): The same for the y axis of a heatmap. channels (str | None): What to make of the ``"IQ"`` dimension — ``"iq"``, ``"i"``, ``"q"``, ``"magnitude"`` or ``"phase"``. Defaults to both quadratures for a line and to the magnitude for a heatmap, which colours one surface. coords (collections.abc.Mapping[str, Quantity] | None): Restatements for the swept - coordinates, keyed by the name the axis resolved to — the same string ``x=`` takes. + coordinates, keyed by the name each axis or twin resolved to — the same string + ``x=`` takes. A [`Quantity`][qprogram.plotting.Quantity] carries the arithmetic and the words it produces together, so ``{"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}`` draws the axis in gigahertz and labels it so. The array itself is untouched. diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 51d5f52..2ff4b76 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -96,7 +96,7 @@ def _composed() -> xr.DataArray: dims=("a|b", "IQ"), coords={ "a": xr.DataArray([0.0, 1.0, 2.0, 3.0], dims="a|b", attrs={"long_name": "Gain", "units": "V"}), - "b": xr.DataArray([10.0, 20.0, 30.0, 40.0], dims="a|b"), + "b": xr.DataArray([10.0, 20.0, 30.0, 40.0], dims="a|b", attrs={"units": "ns"}), "IQ": ["I", "Q"], }, ) @@ -194,22 +194,99 @@ def test_line_x_values_come_from_the_coordinate(): # --------------------------------------------------------------------------- -def test_a_composed_dimension_refuses_to_guess_an_axis(): - data = _composed() - with pytest.raises(ValidationError, match="composes 2 swept variables"): - build_figure(data) +def test_a_composed_dimension_draws_its_first_coordinate_and_twins_the_second(): + figure = build_figure(_composed()) + assert figure.x_label == "Gain (V)" + assert np.allclose(figure.marks[0].x, [0.0, 1.0, 2.0, 3.0]) + assert figure.x_twin.label == "b (ns)" + assert np.allclose(figure.x_twin.values, [10.0, 20.0, 30.0, 40.0]) + + +def test_a_twin_carries_the_positions_of_the_axis_it_doubles(): + figure = build_figure(_composed()) + assert np.allclose(figure.x_twin.positions, figure.marks[0].x) + + +def test_the_dimension_name_orders_the_axis_and_its_twin(): + data = _composed().rename({"a|b": "b|a"}) + figure = build_figure(data) + assert (figure.x_label, figure.x_twin.label) == ("b (ns)", "Gain (V)") + assert np.allclose(figure.marks[0].x, [10.0, 20.0, 30.0, 40.0]) -def test_x_names_one_of_the_composed_coordinates(): +def test_a_composition_of_three_draws_the_first_two(): + data = _composed().assign_coords(c=xr.DataArray([7.0, 8.0, 9.0, 10.0], dims="a|b")).rename({"a|b": "a|b|c"}) + figure = build_figure(data) + assert (figure.x_label, figure.x_twin.label) == ("Gain (V)", "b (ns)") + + +def test_x_names_one_of_the_composed_coordinates_and_leaves_no_twin(): figure = build_figure(_composed(), x="a") assert figure.x_label == "Gain (V)" assert np.allclose(figure.marks[0].x, [0.0, 1.0, 2.0, 3.0]) + assert figure.x_twin is None + + +def test_x_can_name_the_second_composed_coordinate(): + figure = build_figure(_composed(), x="b") + assert figure.x_label == "b (ns)" + assert np.allclose(figure.marks[0].x, [10.0, 20.0, 30.0, 40.0]) + assert figure.x_twin is None def test_naming_the_composed_dimension_plots_the_sweep_index(): figure = build_figure(_composed(), x="a|b") assert figure.x_label == "a|b" assert np.allclose(figure.marks[0].x, [0, 1, 2, 3]) + assert figure.x_twin is None + + +def test_an_ordinary_sweep_has_no_twin(): + figure = build_figure(_sweep_iq()) + assert figure.x_twin is None + assert figure.y_twin is None + + +def test_a_twin_is_restated_by_its_own_key(): + figure = build_figure(_composed(), coords={"b": Quantity(units="us", transform=lambda v: v / 1e3)}) + assert figure.x_twin.label == "b (us)" + assert np.allclose(figure.x_twin.values, [0.01, 0.02, 0.03, 0.04]) + + +def test_a_twin_carries_the_restated_positions_of_its_axis(): + figure = build_figure(_composed(), coords={"a": Quantity(units="mV", transform=lambda v: v * 1e3)}) + assert np.allclose(figure.x_twin.positions, [0.0, 1000.0, 2000.0, 3000.0]) + + +def test_the_third_of_a_composition_is_told_it_is_not_drawn(): + data = _composed().assign_coords(c=xr.DataArray([7.0, 8.0, 9.0, 10.0], dims="a|b")).rename({"a|b": "a|b|c"}) + with pytest.raises(ValidationError, match=r"'c'\] names a coordinate this figure does not draw"): + build_figure(data, coords={"c": Quantity("C")}) + + +def test_a_twin_is_named_as_a_twin_when_a_key_reaches_nothing(): + data = _composed() + with pytest.raises(ValidationError, match=r"'a' \(the x axis\), 'b' \(the twin of the x axis\)"): + build_figure(data, coords={"nope": Quantity("X")}) + + +def test_a_heatmap_twins_both_of_its_axes(): + values = np.arange(4 * 3 * 2, dtype=float).reshape(4, 3, 2) + data = xr.DataArray( + values, + dims=("a|b", "c|d", "IQ"), + coords={ + "a": xr.DataArray([0.0, 1.0, 2.0, 3.0], dims="a|b"), + "b": xr.DataArray([10.0, 20.0, 30.0, 40.0], dims="a|b"), + "c": xr.DataArray([0.0, 0.5, 1.0], dims="c|d"), + "d": xr.DataArray([100.0, 200.0, 300.0], dims="c|d"), + "IQ": ["I", "Q"], + }, + ) + figure = build_figure(data) + # The inner dimension runs along x, so 'c|d' is across and 'a|b' is up. + assert (figure.x_label, figure.x_twin.label) == ("c", "d") + assert (figure.y_label, figure.y_twin.label) == ("a", "b") def test_an_unknown_x_names_what_is_available(): @@ -905,6 +982,49 @@ def test_a_scatter_draws_one_collection(): assert len(ax.collections) == 1 +def test_a_twin_reads_from_the_top_of_a_line_figure(): + ax = matplotlib_renderer.render(build_figure(_composed()), Style()) + (twin,) = ax.child_axes + assert twin.xaxis.get_label_position() == "top" + assert twin.get_xlabel() == "b (ns)" + assert twin.spines["top"].get_edgecolor() == mpl.colors.to_rgba(LIGHT.grid) + + +def test_a_twin_ticks_every_sample_of_a_sweep_shorter_than_the_style_asks_for(): + data = _composed().isel({"a|b": [0, 1, 2]}) + ax = matplotlib_renderer.render(build_figure(data), Style()) + (twin,) = ax.child_axes + assert [text.get_text() for text in twin.get_xticklabels()] == ["10", "20", "30"] + + +def test_a_twinned_figure_is_laid_out_constrained_to_make_room_for_the_scale(): + twinned = matplotlib_renderer.render(build_figure(_composed()), Style()) + assert twinned.get_figure().get_layout_engine() is not None + plain = matplotlib_renderer.render(build_figure(_sweep_iq()), Style()) + assert plain.get_figure().get_layout_engine() is None + + +def test_a_twinned_heatmap_keeps_the_colour_bar_clear_of_the_right_hand_scale(): + values = np.arange(4 * 3 * 2, dtype=float).reshape(4, 3, 2) + data = xr.DataArray( + values, + dims=("a|b", "dur", "IQ"), + coords={ + "a": xr.DataArray([0.0, 1.0, 2.0, 3.0], dims="a|b"), + "b": xr.DataArray([10.0, 20.0, 30.0, 40.0], dims="a|b"), + "dur": xr.DataArray([1.0, 2.0, 3.0], dims="dur"), + "IQ": ["I", "Q"], + }, + ) + ax = matplotlib_renderer.render(build_figure(data), Style()) + (twin,) = ax.child_axes + assert twin.yaxis.get_label_position() == "right" + fig = ax.get_figure() + fig.canvas.draw() + (bar,) = (other for other in fig.axes if other is not ax) + assert bar.get_position().x0 > twin.get_tightbbox().transformed(fig.transFigure.inverted()).x1 + + def test_a_figure_can_mix_marks(): figure = Figure( marks=( @@ -1055,14 +1175,61 @@ def test_plot_reports_a_missing_field_the_way_get_does(): result.plot(handle, field=qp.MeasurementField.RAW) -def test_plot_of_a_parallel_sweep_asks_which_variable_to_use(): +def _parallel_result() -> tuple[qp.QProgramResult, qp.MeasurementHandle]: + """Run a parallel composition, so the dimension and its coordinates are the executor's own.""" schema = qp.BusSchema.transmon() program = qp.QProgram(label="parallel", schema=schema) amp = program.variable("amp", label="Amplitude", units="V") freq = program.variable("freq", label="Frequency", units="Hz") with program.sweep(amp, qp.Range(0.0, 1.0, 0.25)) | program.sweep(freq, qp.Range(4e9, 5e9, 0.25e9)): handle = program.measure(schema.q[0].readout, "readout", "weights") - result = qp.simulate(program.with_waveforms(_LIBRARY)) - with pytest.raises(ValidationError, match="composes 2 swept variables"): - result.plot(handle) - assert result.plot(handle, x="freq").get_xlabel() == "Frequency (Hz)" + return qp.simulate(program.with_waveforms(_LIBRARY)), handle + + +def test_plot_of_a_parallel_sweep_reads_the_second_variable_on_a_twin_axis(): + result, handle = _parallel_result() + ax = result.plot(handle) + assert ax.get_xlabel() == "Amplitude (V)" + (twin,) = ax.child_axes + assert twin.get_xlabel() == "Frequency (Hz)" + assert twin.xaxis.get_label_position() == "top" + + +def test_plot_of_a_parallel_sweep_takes_the_axis_it_is_told_to(): + result, handle = _parallel_result() + ax = result.plot(handle, x="freq") + assert ax.get_xlabel() == "Frequency (Hz)" + assert ax.child_axes == [] + + +def test_a_twin_ticks_at_the_samples_it_shares_with_its_axis(): + result, handle = _parallel_result() + ax = result.plot(handle) + (twin,) = ax.child_axes + ax.get_figure().canvas.draw() + assert np.allclose(twin.get_xticks(), [0.0, 0.25, 0.5, 0.75, 1.0]) + assert [text.get_text() for text in twin.get_xticklabels()] == ["4e+09", "4.25e+09", "4.5e+09", "4.75e+09", "5e+09"] + + +def test_twin_ticks_thin_out_a_sweep_longer_than_the_style_asks_for(): + result, handle = _parallel_result() + ax = result.plot(handle, style=Style(twin_ticks=3)) + (twin,) = ax.child_axes + assert np.allclose(twin.get_xticks(), [0.0, 0.5, 1.0]) + + +def test_a_twin_takes_the_limits_of_the_axis_it_doubles(): + result, handle = _parallel_result() + ax = result.plot(handle) + (twin,) = ax.child_axes + ax.set_xlim(0.2, 0.8) + ax.get_figure().canvas.draw() + assert twin.get_xlim() == ax.get_xlim() + + +def test_a_twin_reads_in_whatever_unit_it_was_restated_to(): + result, handle = _parallel_result() + ax = result.plot(handle, coords={"freq": Quantity(units="GHz", transform=lambda v: v / 1e9)}) + (twin,) = ax.child_axes + assert twin.get_xlabel() == "Frequency (GHz)" + assert [text.get_text() for text in twin.get_xticklabels()] == ["4", "4.25", "4.5", "4.75", "5"] From f9e3e0ce3fb9ff26001938ffa7831d6b3570c3d9 Mon Sep 17 00:00:00 2001 From: Vyron Vasileiadis Date: Wed, 2 Sep 2026 12:45:12 +0300 Subject: [PATCH 8/9] fix testing --- tests/test_plotting.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index 2ff4b76..a349fa3 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -260,14 +260,16 @@ def test_a_twin_carries_the_restated_positions_of_its_axis(): def test_the_third_of_a_composition_is_told_it_is_not_drawn(): data = _composed().assign_coords(c=xr.DataArray([7.0, 8.0, 9.0, 10.0], dims="a|b")).rename({"a|b": "a|b|c"}) + coords = {"c": Quantity("C")} with pytest.raises(ValidationError, match=r"'c'\] names a coordinate this figure does not draw"): - build_figure(data, coords={"c": Quantity("C")}) + build_figure(data, coords=coords) def test_a_twin_is_named_as_a_twin_when_a_key_reaches_nothing(): data = _composed() + coords = {"nope": Quantity("X")} with pytest.raises(ValidationError, match=r"'a' \(the x axis\), 'b' \(the twin of the x axis\)"): - build_figure(data, coords={"nope": Quantity("X")}) + build_figure(data, coords=coords) def test_a_heatmap_twins_both_of_its_axes(): From ea6f154cbfe9989bb18cc1777fdcdcfa63a36031 Mon Sep 17 00:00:00 2001 From: Vyron Vasileiadis Date: Thu, 3 Sep 2026 12:47:42 +0300 Subject: [PATCH 9/9] Answer the review of the restatement and the registry Three findings, all of them a check that let through the case it was written to catch. units="" now obeys the rule the rest of a restatement obeys. The contradiction check guarded on a truthy new unit, so Quantity(units="") over a coordinate declaring "Hz" drew "Drive frequency" over values still running 4.6e9 and said nothing. An emptied unit is the claim that the numbers are dimensionless, which is a change like any other and comes with the arithmetic that made them a ratio; Quantity(units="", transform=lambda v: v / v[-1]) is how the normalised case was always meant to read, and it still draws. The error says the axis would carry no unit at all rather than that it would read (), which is what the old message would have printed with the unit emptied. An empty renderer= raises instead of resolving to matplotlib. `name or DEFAULT_RENDERER` read "" as "whatever is installed", but a name that arrived empty got lost on the way and drawing anyway hides that; only None asks for the default now. The message a wrong name gets lists matplotlib whether or not it has registered itself, since it registers on the first call that asks for it and the reader of "registered: none" cannot see that it is one call away. restated() no longer claims to copy on the path that copies nothing. The transform is handed a copy, and that is what protects the stored result; where there is no transform the array is handed back as it stands, and the docstring said the input was copied first without qualification. --- docs/guide/plotting.md | 6 ++++++ src/qprogram/plotting/quantity.py | 26 +++++++++++++++----------- src/qprogram/plotting/renderers.py | 11 +++++++++-- tests/test_plotting.py | 26 ++++++++++++++++++++++---- 4 files changed, 52 insertions(+), 17 deletions(-) diff --git a/docs/guide/plotting.md b/docs/guide/plotting.md index 64c143d..d644c4e 100644 --- a/docs/guide/plotting.md +++ b/docs/guide/plotting.md @@ -201,10 +201,16 @@ one already there has to come with the arithmetic that earns it: # On a coordinate that declares units="Hz": Quantity(transform=lambda v: v / 1e9) # raises: the axis would read (Hz) over gigahertz Quantity(units="GHz") # raises: relabels the unit, changes no number +Quantity(units="") # raises: calls hertz dimensionless, changes no number Quantity(units="GHz", transform=lambda v: v / 1e9) # both halves, and the figure is drawn Quantity(units="Hz", transform=lambda v: v - v[0]) # a shift keeps its unit, and says so +Quantity(units="", transform=lambda v: v / v[-1]) # a bare ratio, and the arithmetic that made one ``` +Emptying a unit is a change like any other rather than a way around the rule: +`units=""` says the numbers carry no unit at all, which over values that +arrived in hertz needs the arithmetic that made them a ratio. + Both fire only where there is a claim to falsify, so a coordinate that declared no unit, or a demodulated magnitude that has none to declare, takes either half alone. That is also how you correct a unit the program never recorded: diff --git a/src/qprogram/plotting/quantity.py b/src/qprogram/plotting/quantity.py index b2b8851..f6c2387 100644 --- a/src/qprogram/plotting/quantity.py +++ b/src/qprogram/plotting/quantity.py @@ -60,7 +60,8 @@ class Quantity: name the channel implies. ``None`` keeps the inherited one. units (str | None): Unit to read the numbers in, replacing the coordinate's ``units`` attribute. ``None`` keeps the inherited one, and ``""`` says the numbers now carry no - unit at all — a ratio, a normalised population. + unit at all — a ratio, a normalised population — which over values that arrived with a + unit is a change like any other and comes with the ``transform`` that made them one. transform (Callable[[numpy.ndarray], numpy.ndarray] | None): Arithmetic on the values, called with the whole array that would otherwise have been drawn and returning one real number per value. It gets a copy, so an in-place transform cannot reach the stored @@ -136,9 +137,10 @@ def checked(value: object, where: str) -> Quantity | None: def restated(quantity: Quantity | None, values: np.ndarray, where: str) -> np.ndarray: """Run one transform over an array and check what came back. - The input is copied first: the arrays reaching here share memory with the stored result, and the - ordinary numpy spelling of a baseline (``v -= v[0]``) would otherwise rewrite the measurement - the figure is of. + A transform is handed a copy: the arrays reaching here share memory with the stored result, and + the ordinary numpy spelling of a baseline (``v -= v[0]``) would otherwise rewrite the + measurement the figure is of. Where there is no transform there is nothing to guard against and + ``values`` is handed back as it stands, so the copy is the transform's, not the return value's. What is checked is the transform's shape and dtype, and whether it turned a finite value into a non-finite one. A value the measurement itself carries as NaN — the executor writes one into a @@ -150,7 +152,7 @@ def restated(quantity: Quantity | None, values: np.ndarray, where: str) -> np.nd where (str): How to name the argument that carried it, in any error. Returns: - The restated numbers, or ``values`` unchanged when there is no transform. + The restated numbers, or ``values`` itself when there is no transform. Raises: ValidationError: If the transform raises, returns a different shape, returns something other @@ -191,7 +193,9 @@ def text(quantity: Quantity | None, label: str, units: str | None, where: str) - This holds the rule the type exists for: a change of unit and a change of numbers travel together. It fires only where there is a claim to falsify — a non-empty inherited unit — so a coordinate that declared none, or a demodulated magnitude that has none to declare, takes a bare - transform or a bare ``units`` without complaint. + transform or a bare ``units`` without complaint. Over values that did come with a unit, ``""`` + is a restatement like any other and needs the arithmetic that earns it: an axis whose numbers + are still hertz reads as dimensionless once the unit is dropped from under them. Args: quantity (Quantity | None): The restatement, or ``None`` for none. @@ -219,12 +223,12 @@ def text(quantity: Quantity | None, label: str, units: str | None, where: str) - ) raise ValidationError(msg) return _joined(quantity.label if quantity.label is not None else label, units) - if quantity.units and quantity.transform is None and units and quantity.units != units: + if quantity.transform is None and units and quantity.units != units: + reads = f"read ({quantity.units})" if quantity.units else "carry no unit at all" msg = ( - f"{where} relabels the unit from {units!r} to {quantity.units!r} without changing the " - f"numbers, so the axis would read ({quantity.units}) over values still in {units}. Pass " - f"the transform= that converts them, or correct the unit on the variable the " - f"coordinate came from." + f"{where} restates the unit from {units!r} to {quantity.units!r} without changing the " + f"numbers, so the axis would {reads} over values still in {units}. Pass the transform= " + f"that converts them, or correct the unit on the variable the coordinate came from." ) raise ValidationError(msg) return _joined(quantity.label if quantity.label is not None else label, quantity.units) diff --git a/src/qprogram/plotting/renderers.py b/src/qprogram/plotting/renderers.py index d80d68f..7ee348b 100644 --- a/src/qprogram/plotting/renderers.py +++ b/src/qprogram/plotting/renderers.py @@ -85,6 +85,10 @@ def register_renderer(name: str, renderer: Renderer) -> Renderer: def resolve_renderer(name: str | None = None) -> Renderer: """Return the renderer registered under ``name``. + Only ``None`` asks for the default. Every other value has to name something, ``""`` included: + an empty ``renderer=`` is a name that got lost on the way rather than a request for whatever is + installed, and silently drawing with matplotlib would hide that. + Args: name (str | None): A registered name, or ``None`` for `DEFAULT_RENDERER`. @@ -96,14 +100,17 @@ def resolve_renderer(name: str | None = None) -> Renderer: ModuleNotFoundError: If the default renderer is asked for without ``matplotlib`` installed — install ``qprogram[viz]``. """ - name = name or DEFAULT_RENDERER + if name is None: + name = DEFAULT_RENDERER if name == DEFAULT_RENDERER and name not in _renderers: # Imported on first use, so that `import qprogram` never pulls in matplotlib. from qprogram.plotting import matplotlib_renderer # ruff: ignore[import-outside-top-level] register_renderer(DEFAULT_RENDERER, matplotlib_renderer.render) if name not in _renderers: - available = ", ".join(sorted(_renderers)) or "none" + # The default is listed whether or not it has registered itself yet, since it registers on + # the first call that asks for it and a reader of the message cannot see that it has not. + available = ", ".join(sorted(set(_renderers) | {DEFAULT_RENDERER})) msg = f"No renderer named {name!r}; registered: {available}" raise KeyError(msg) return _renderers[name] diff --git a/tests/test_plotting.py b/tests/test_plotting.py index a349fa3..96b4862 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -591,8 +591,22 @@ def test_a_label_alone_leaves_the_unit_it_inherited(): assert build_figure(_hertz(), coords={"freq": Quantity("Frequency")}).x_label == "Frequency (Hz)" -def test_an_empty_unit_drops_the_one_it_inherited(): - assert build_figure(_hertz(), coords={"freq": Quantity(units="")}).x_label == "Drive frequency" +def test_emptying_a_unit_without_the_arithmetic_is_refused(): + data = _hertz() + quantity = Quantity(units="") + with pytest.raises(ValidationError, match="carry no unit at all"): + build_figure(data, coords={"freq": quantity}) + + +def test_a_transform_that_leaves_a_bare_ratio_says_so_with_an_empty_unit(): + figure = build_figure(_hertz(), coords={"freq": Quantity(units="", transform=lambda v: v / v[-1])}) + assert figure.x_label == "Drive frequency" + assert figure.marks[0].x[-1] == 1.0 + + +def test_an_empty_unit_drops_nothing_where_the_coordinate_declared_none(): + data = _sweep_iq(attrs={"long_name": "Shot"}) + assert build_figure(data, coords={"gain": Quantity(units="")}).x_label == "Shot" def test_a_unit_the_coordinate_never_declared_is_taken_as_a_correction(): @@ -909,11 +923,15 @@ def two(figure, style, target=None): # ruff: ignore[unused-function-argument] def test_an_unknown_renderer_lists_the_known_ones(): - resolve_renderer() # make sure the default is registered, so the message is not empty - with pytest.raises(KeyError, match="registered: "): + with pytest.raises(KeyError, match="registered: matplotlib"): resolve_renderer("svg") +def test_an_empty_renderer_name_is_a_lost_name_and_not_a_request_for_the_default(): + with pytest.raises(KeyError, match="No renderer named ''"): + resolve_renderer("") + + # --------------------------------------------------------------------------- # The matplotlib renderer # ---------------------------------------------------------------------------

yZ&~j9LpcDM` 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 literal 64713 zcmeFZcT`hr_bt5XLMVzFdNl}0s8XdP3IPNwQl&Quy@cM2N=K?7pa(>xh7zPVA#@a^ zhAK^ZiS**#=<&S2Gwyr8Z;bo*%@_{-vac42K9^tPt;Db`=DzrGiKhkFoNck80qy|47% zDj!_WUx>ZN;%;)J`SVm~Ty+GWG2gqMFn=;XHod$v;XTwkQiY3eW~JB6I5X(UW3=*hKJ;Dzwm^`&<6$* z(KwDzE)V9TO%JS|wY~j5kxxT?W8c_ACPRDG=_u#VC0ONPjhU@)I3|Zc;R=r)Sqx0! zxA83elPxnsryd&cbYqc>$(vEgif0n5wR zDCvdHpB(OJ<<*6=dI4oteM&r+n&-@-TRXTjU-Z82DzTr?JKmM3M$!w@wzjrC*vQgo=v zEi#SF(>Uk`^l;1v^7Y|xmKioW#itwn@pzjp_v?_#1Nl$-4t3-WQ!)4kZvwxQw5gf! zZlLStPGkr>luc$Cqv9p>hH{RCQvjVZ1nNvv5Cr?Dc%+s$J6D0$EgMg5$B5N-o&+KRRLLBXu2jLg%OE}a}_IT2rMQReDl+UbdzMrmHUnycw^ja|w8Q{7;UNySi z-{0#kqxmcM?$UtAPrq0HIkwP;pSdEhyjMzXcPe9anKBGmRW>x_fAM0szVwN{J|t_4 z?}zET7|DJfTKifx)^o(K_-WQpy+6L;u=Az;bt#e4PmjG6^nc!@Fj{eXU!cwa7~|jd zcqfX9iW(0Wy*?MJ)FZGu-%#$Mb)|28!>ZK`ZP{g3(@?y=V>vvm^SczJ-!PtL2O670 z@q5?w%dI(RpA(Z((xxWJ?K*3KDuSorCyY>53^=~$4 z(4#(i0FBZcwNX(_5~3${Z{866^eNiX9#x5C%Z#g^r#)Gajq>{OogC1qv9~LmUm21h z9ow;9fKn_a1mMqe=&g&>RloG%G#Q1#ty<%ol#bMm)G6?+`A?5Td+szp)S-UK&)#)w z*YjGsy^%Twy5^7&!dk^o;8-AY`@TK$&HbcExQjo0r`Eg?*8Wnj)X$@)pj$+-M5vp1 zbQh7#pZ?5_=ZS=GRsGLIwGuXHFg5* zP0jZ@q=oexS#k3P-9rLQR+^auLjqJ15%{oC50fSuAN4CZOHjLj+lf?$kv}No#*_NqxZPv$&c%=PA4lJj5Ja_U}yPO!oZ*9s-_HW z)7^7rmOY=6deXiW>Z3F=e2|Pry7v9wWTOs$tVIL`5&EG0WW|yDgtFedPp{cpTQ?qi z;sKzAT88I=;iX?eqv6O=fzw#+!k2&c-lz}GQI{W`b-*w5Hq};v&_;#T^DAq_-r=E_ z48D7627j=tQ%ltN^JHrNePLm1&;fq4jj34Tq)sI!CVU^V2krk>M{>4^ zF>>4I0e19}H0sf##EAv3A zmL4PD)|tq+72G9oYq)5l#0*RQb#RcAp7Pt<2mwT2#P5v-f0;U!oyP197UUoMcX>ka zy+_o(-LV`uh0UKG5D^FufM>A$bfx6!;0M`LXhiGozW%B|?Odfj?!}{g?KjTDMY5+) z9zG1g`R&-s>^Gk1fE#OQ4DQH!79a=wR{4%@#`!gx-rH-wT^gxLS%iRNKS z@e?<)fU-V0GVTly+8fF4lPhQo3qwadf92ciYKqI3FZ00R%Gl`FdSzX|3txZqS;g`6 z^rV;E4DkK%KzoP;e8G1!3P{9V9i0TV;YgdhyzJ%y5$|N?3fnutJM!TL5q%+^{4^NL z!qSk8ZAh~27?*cIPE)CfeidJ+qhbRgG7h^p z6ilnGC?zDsH6?Ubg=L0&)F5k1U=BD(fO0PxB|0UlKT(Bef&4>Ee%-HPbu{uNc<1t<@@_6UB$wu76Wr4eH_<3oQDSy6ag&G=em$NCM_Gwzl&ahVVoBQPQ zu8emrf4b*-_M6VcizB7c2TjnsZA$IdLT@c1+d3{{FD^vUYi*ZN*$%6;z2I+*U3)Aj zWunt^kA>7<5649izFILt*r~J0%*2Om5FHXrR_Tz6Oe9bUNWivxZ0c(hX$D`=WdJ^Q z^lrshBauV_@@maAh!n$Mu5*Gjf7*i5KtH@d2>A0mtm5Zg=YRJWFuw1dH7QG- z|LG1A_f8V{FLl_|!KiqyG#Mlq5iR^aT+pF)={C{Rufd(%krct1YM*J{!5$ zaX(o@K(t#RbW<}IUmP`Xm$y-by2E%|-|R%hk%U+61w1$*D%pc#<~^J)s)DIZlzA_; z5)4fEn?y})JU{bb-uDN|RE;Lxmy!%cnvQInRoc>WTBrl3vLRDR8ATirtu<5SEMT9T{w|bJg_P%%<7o&kgd{Zb^dB` zcy6Ws7}u8q`_ia!%;^mc8q7|zRdbp2MV&E=rP;Y6(l~my^O}2iuJP{H8ZIL0GzVG; z8r65H)YbMz`xkWeBoJE_lw@N?{G+dPA_l62+Hh{K#2xOS_u@qE_cytlq!+aBF`tIbGg*#qW(t+&5>|&D>Bdxez%9#3R~iv0W)#O zyl0>zXE3d+@TFLmDT%IJxk8oOF97+0h%dS3Ey>L5qC*4F!X93;NhKQ5QH$No4as>B zO|)X2pLD+NQfY$D2s?zMEIQ|sQaim|r6gb3^H>q6$dJx@fk3_$pVf?oa92lq=tQe8 z+&ofT{bsw4H76etAi;2cmD!SN<44L~)Ue%T80Ivrqw1{GSzxzYOlk?mxRy8P@eDCRN2h zJ4}Xt{${wVM6?1ARK*BgzAkqU9T`jSsTm`-iX9i~!lOy8A>Y;7f$uCsOfh0ju!bnBX*p3@=C8`$hkh#q`j6-g3H zpb)?60xe*S(IxC`SBQM6JVei+0?-tgSrE{QkOBm>qF}nyk>qaNV}jf%&uCGtN`7dm zh>BW!)paGiTfFzJd2NXkGLxzHb)!~9i* z|NE&|eOIaw4gYlobq)UO3bs}CCx{p4A62PE>@hEj7E3EWy^2T`vzTyNzV491uJ$ujSXIL7Y01crL(N4U zoV)7P9<6ltrEWhqhvXcI0nZ7M+qz?-cOn;i`WNqTwaRsOcIcScY)8%aw&{KnsVZ^5 z0<)8QHBE(WUm-7<^XZbrzpM&>om(&)S>Dx#;kTPqp`B+^HH=BqI&ZSAr+ZCC-JNXT z2ix{OxmFX07mqbdpQr!;M%9|8OJh6w>+jg(ssC9{5?@tz%fp`kk^2A6eUvU7vU{Gx z6({34|4M+kylk$N{K7GdH&@{ryou|jcSWI3NP#EeCa65(y)VPBnpNHueBjT5Hz|3x zyKm~rokql!Fy=Ph6-P$iesGRxR)2){<9DIeUJOGznakFF=%#Y;1)KbU7#Vg%P!Mu7 z3_&Yuou;oN#iWjLA2pzlPF)#YfHStIsGZMfIp`HHy~ygq0Ff*YGl_RnZRtYJyv{bE zLyVSV(v+UD-fUsCX{VoZxksx;$1yAMl%eq+?f&JfE()w4q z^&GvmmV>2~7dpOYrRcG1Eajq`LMpKBu4||z8fq+cKbdq!mvAX4$yh$l72JBi+9?=Q z_Pn-JeEvT~OdLG-&+7b!7=J1RnD_pa2Xms61;cavlY0+jOhyfo)H=N)FIDqjyv(=z z36aWA^&0l3?SU$KFV=aeC@tHPD9P0+iLjT`h2Ud{rj^Yp2+cV9y5ha~Co0m1(;Gs8>tMzw0g@oGl%93QDLMHIy3n zktsP9SMC9uWugEfhH%Z7-Hf3i z=I|f#^4|;h??ma1;3|m@?MDaXW^=8En=}dSDu}u0CWMHhV`YHN(pU+oxdr6ddEca< zkkK|dtXCIPoJ>6Gp~{}f^;ZWYsd;=!b~0MHGh@Krz!6M*$or6j>&XZ0#t1I!&)93Z zj_*oIhR}r@q9YeeLMNosxCvN+R>BNqpixtZXTjERvo!OMmnG8B5GyL$>&ZE^u(pNr zfEIQY{TleCuXmKT0oDYp(l+B;%%@u}7uc+7M^(p<0q8gA^R2b>&*G|KA(5e@AarAv zfbVx(*(CR%knmB$-I3$&=5@j+a&N?9o#lD+D~x z2G=F^&)PgQm-@3X9g=i)hPJkHF>_b{JawVN`JbXfl^`w{0^L|k;MeG|;W6y*7vg)z zai{#zVxTb`S%@AtfL<}Nb?QQCo5KDI1;6|>C*a84Qykv2gTV)+g)YWM^#vUO?6=2q z-uRj0B$Cp)_J?~sYT%!vNuHy#+S=R^LXYF^l-1u~I@o@w7U)L3f-ZptkO`wtOM%ih zvXls<%bN#z-Dt!OR*xECk*aJk+ciE22??A(IDnnM^2Sw|76#=e@B*eZ{X|%iW(lNS zaUU@3eA?X$MmU4-TuT|E=lYyWoxYsc#k-UW2?5Vyowc>u=GRKuE3^8J^=`uMUI2p3 zSHs))sbUw20|17<{Ad@RdTX`32+nT6%r-BA$p%_7tgu@ZQ>#m%-*(gR(Um!fF&-5k zgQ>-so6u%zJs9H0JtLMF5H(}cPTWb(c~2z6n_6M3P8ai~dSQ`rK-*Kvt%rNzs{K=I%aNLG{UjScH^d0Zp>5T zPqf*@lF?4kvTUC+;;qB?Ra$Nr>H|k7E-|X!_x+4LS`p35$oWdt`*PWCHgeDcUmXMc zLZlFo-BxB+5xDvQ*c<>)-JEwP;KZJyur+6@782*XvHqKIQZ}dgvvToNKhjVf{|(Q) ztBTFw+o=ASSyt{brG;*%f~J^59++}y!ppnj?WmWx5AdO0u1#Yo&q2*Eau+AsT>&;@*ZMLBpdoZ_al&e(sBv1-w$0fnhi9A7!z$R0>Wl!av1=P~$4a=7ALB_2Dv-pta_19?m+b3T&lUPGZF)Krae*K6O;Eby(|{bX4yGebOS z5toSx+?=w6SRj52XN+(*C$Llm+j}h##;_}Q-t@!Unkb?I@L=w6C6lD7f#|joF-;Ma zYT4m9loy~-l(7Zaf-2AL--e;-=xQU~mZ+Z@+ge#@p3JFmN1N+dF*BXsPO*$hi5J94V zbL2H<9J&O>TqzM>E#ADqY^_)*#+dV~8HRT5W!JQuZX2HJwQaTy!(U&h_cG>o?MVg~CoOK$r;J6sOiT#7Q-6SSY5h(l5>i zhE7zl()HuhP=*tIkN$+@zc%xCi47&N^ZhTH*wUY@FsfjbMhCLJ?wv`?-9h1=%R(Sz zqb>WipHgVjd}n1_F!`h5f+iZ~Mia3`GR>7Y|0Ky&E54s8bJ(D*dhROkS3q8?M5K}* zkrYXm1np|00Kc0Qt{xMjr_IX6`}JPe1#FuHQ$1#u^Y)?g#<8(YC67%sjpkLvm?x8O zYFCo!1~*~~Q*JL_Z$s-#VWpLe)&C1~*qrX!(AH6VsWS59TvgXOK8VUenDw*xOOE%o z&rhH9SRr<(!9>CyD^$q@Ly474cm{Jhm(AF!W39;dU85_qd&hv$%{1Gk6x%B2wz(O6D#O;;9Mg89s>M!QuU!^PAx0!GWU`5V}cK2!z-;sYaM^%I9 zObaL8C;>?-3Ckj^QV>{lFoKYRvbl2It~Xp8Sd)a}}gIS$afM^`fiM38RE79wVCgevT6k=beV@GJ|b(9$1uGv*#r>L6!gq{qfTKYPQHOSVmMO%fy5y zXGIz~lOuYpY7OZ|sq+j;OpgW)x{`)ixXAZSoNEVF4s7#4D&m4mDt}?kGp<3h?qV_J zcra|0@2>~Lq;SKxZ6+|H_UoVcx&K>8Uj4N1tQ)xjRwPS(S}Qv=^%wQzGt zjak!exIursfijVx?sPKO`)7%zcW;PiieYRg!|Ww&lf`XQuXOj>FdgmOgGP4}Hh8p9 z!9EuWm=@^|G?K|fgv?CbZz)brIex8m2!eI@LiaDj=0V=ois5{LWaC%`$xNJrG}Mxg z-NZf0t>-Ap?k^vCHkwCsFzrVU)Zu1k=cfbR3ku}a(n6C%CLYEAs-Gjx>)jTsDFgwv zfE0JER3?c6p$u{9&PVG2Yg;)j^`3NL7Sx0rS$qdfhLz^nPab1G5v0QAORryP-*k)4 zXzZ;!sMh;Ab@id24qgKSu(N@Ei!HscrMG%<4ko(=srx5v>&nALhAee&PeP#^{GzCJ z=Hmmcy|?e)y<2j4QcOo@;CMmv#z6wKa^Uml08ofO|3Lm2c>WXN!z$-P?6=>-_U3_& zP5zGlFHB@^G&npw^Cp~CK_vClQf_A8^Ujy59OAT!1PglWHeCA^zr*HS@JsJsy zFqS>(fuPF3AurD+U$xB0?DgHzLx#1$umg`MYkJY=G#vcQlP?ESeOTEkZ6#3ugr6!Cac ze>&CbG*A^5WELY!Ex+H;mF9=r8q5FL^jC~rWNzjmQ(H8Pl^u7Ss_|HP3;;+>IrCA= z?Z>_=<=4kd=MEne=W7=>hfy(o2JH93#i20 zix^uTuiDyMrJ~yTrIoI3(F=o`K*ZtU4S0$?ja(+pl+@1}?+}r6kN%GDV}(rO4wE5+ zHU14vpJtstnF`O%&#$2!$pVTDYu-9E_yGZqAK$nch5R{5iyZm{~!aqOS? zr8_U%9FGbN+U$Gn2KZ<$wy3vVhaa(L~oCOS7Dv>&Mdhm48TDx&#zX(35kPhfZ** zj(}*=TDLc2RZ`1hwd|phdx72}9IB?Wz@=X!syfi>4xd^=uG_QE=wlqe9-brL;oN!3 z-(=+mGBWOuZzPMc=^f!3b3bD z7EShNP7eHH-!0C#0Nh&G@X9S1ZByrEJ|UMO${%aPF@7m>SM=RZr*YF&O% ztfR~spk;cufNE0!?m%`p_(L|*_j8-mP5rx;o+=4z=J0qtoD^miy232 zL*4{yv2tUoakhK8HxXUKcN;{#cj3pY)wU%Tc*{seSyJxTJ``8r5&!YPF)w;DwLQSnH3ffC5e((JVlP?dMDaV)-p(=)w|UGP*sJBw zlGf?TQOoR>@%)R+pg@1i&+n9VJ_5=Q0HEvZ^O&}s-RvW;2j_#aYojM0Up=fI=UlZt zg-0gmbl{dt6O57~sWxFxchkXkBWZ{#1!A{W>KVs9wH>BQTagA^!O<3su9#GD*sJTw ztH`05dj8cue79Rgdon`)Q`P{UBsU^e;pp7*S?bWuiZ_ zG9Acr5j*f4)@j7f4*~upsU((sKS4xV<@hK}8S{V@aVS_m?wiGKtoc{5DN5}9BJZx4 ziOa-|`<68iRAmupD{Sam-F?r(gXg3B{FIw(`l`{8EMEahl^7{X3&U#TiRy}viy1YJ z3#nEdmndd}X(q9tPmBQcJY3Y2@r=0vhUnnnpkq}Dc6do8Mvk&8SrB_sOD4<_7I~9~ zg`i<7yifiov;WVd2WPglAD?F^)-j*IO>oLL0B73@3Qvjgm)oNhsNU~?SGqUpO~)jT zR9Nh_@b*p2mXh`Q0RV6VAvPundxaQQ*|biujBl>jfF9TC4ZrkXyJ%Iul-F)@5kJ$( zSJW)%?+LN&O^Hsu{%+%*-^{J#ED+atAKQU|<>QZd2x#iqTy^=`vkl^t2g0aztWLd; z6sz}-xVnt|k00sjjGULA_$SNSfS!WIbQe~r;FFM_$BUPJ&@&K92ANA~;&z{YEDZp_ zV#eND-Flt0!@5C%egia|d3$QAn1)f5{^W?J5i~e%4%ikoUr>ou(bc6}{V*P?d)+GQ z!v~7c&`^4LKhrUzzkZ#0`(rAG8<$Yyo;2@jHwEEFrwpcOdas@J;0Kygms`SPMpm}$ zlOf=XHV<|+vS^42_vh^zns5$v&vnbJOuH6(RAIE=N6;6krGDH6k+#iYp*Q5r4nagC z3CN#rC3;K;Hkf{C4%I1laOX;rLyoIB6Coj%$;a2-!j+-3eroHJg_ny=foqcz)r=r#FYeTEE zDp8D4@$vC>_h;4BrDtg>r=IsE@wdE4DCuX2MOlu$>=rPp8P9V{g73cAvWNd^6Sw4(dNeHd)mn~ zr_`Rk&Fea!SsJm*`Xnx2&a0|74*Wd*v64S-o?(us20U~PxAp8?-b|Tgr05vp#+zZP zLXW#eZePi+4UC++q2Bo9GGzUV394p!A5qC;Jt@`dx!|r2SM-3x;g^IQ$j-Pi`FE>} z23Br%flmoUu%*MDAc3Yo^18}Cj_aHQ9eJR+32G4LN)0^i5N=)Y#W~$$5>I{Z{3U4B5Z}R$A_vc zka+mxRb!bT0T8_y30k$}W~t=Y#V2!8Cr{*9M{F%{JX58<5lRcygH#JAm;u^I9Ykk7 zW4DEyNj=NRNKEWYDd`L#OB^ZHQ9(%Oan@-4AM}RHu7>|zf)!V7ahT*n{Smd#4A_aN zQHc60%&=H;E8;Dvzl!&D>N2Rek?x15ImNrDYhZd7pI~V8Utb-pF|2J6waa)|!F8u> zxTXK$1DoMH*Sz^{@W}7j4x|l(<+-cfzNUHe@LMbZ=UfT}w%xs?yo(U^`YOm=i&zSn z9r1U*JtYuT?!lFCG-Lf_5%{8*5?7x|`|yvRC9Q<;=NUAo00K>O*u8U{gp-z(?JZm@ zm5R7D*1s@n$fYwTqrQzvJd#<+wkfvg|L{Q~c`&47g6zJeMCt5R(^Rujrw5N5CaJ-$ zP2fd43o}LVLNyEiU=Gxi@f}-9DxmeSPYcwRuhnw3W<=46Cm@&hk;kMyu(-@xO`x3{ zZ%#1kaEqhf*S6iy0Tkp=M7P~GEGQyHtB6ZjYF^V>=B|LYs5 zd#%Rd5?vZP`ejq{zS!-cO5|FbYQQsoP(UNl8!{Hi?XyWO@ib=PD=S|Scen|4x00?a zNp1-$Fi1M>Zv@LIBvCD1BO4ga!Cvh^R%wn{=9E#$4Gf{a0b z*YdmbVM|k`!&iH@zZkZop5OY|eNurWWjw?-e?Z3h!vkW%=5!lu&5OFd%o!|` z8gKLqkb~`)F$*N8jARB~QbW(A244Kv>C{^!5z#YA%9?x#-rZJrge9-5 zxdP-D>7wE`Z>l>!j3q{r_%3+C%qRhQ?bl(p1W5P^@W{2-6dJl0c2xnvqY9$ zAeK#NFBv?o*-O)k9!Mlk$!>JS$^x`r2grydZFd~&(@)P3nx8UknVM7=QxOKQk(MTJ^heII;EId=5{j)mLDTodovgKKw4CDQR^RX?oEjtFo6R9-f8oSwLoBrU1j zO{OVnQ`EKYOaN?!c+wg#HiVtCgSweF41P`Pa*qSeS|i`Cvq^A?KF?^VvqbEyN(xYJ zpDswxbi^+~5=#@yvcy5ryW~ZvIT}>Up6L@}G?4NtroN`di6q}ExS(UVf;Zur z)HMo0pW3a$lbB_yPYkJzB0%wMd68tw;WVVmzS*iMS!0{3DQN5)tXn`WXqK@{*CVw| zsHRO$N?Ln#+{9KQ(d?Sieess0DEjD>N`E5We4FVe=fRzY?GIjf-ns__nGju7ZN=D7 zwlTs%RaGc2UYD@kXU@YMi=K+NUgAisgFXAI)d{fb(6Qs1pyza^MYFp5u!4}9d^@3G zyAqgk*k22!JW`X$#qD$CU(8HU6-h6HVqis&22*2F?H(lsv}YaYtf@w~Qo~?0z>Ui( zUAi>~=FDef3ZIohw6ZxH7dinhfPM`}=7COyU3haAmtj?6$)51GQAI@s&lLJfj`%hn z|0S=yJkcwG^-u7t_Ue=vv#wVi6(x*;aG9{Eeql^|`JR{c-!oqERIc-Nx3=++&y@}h zmR;BQP$rALuK@rYUFq+?53+K9y?e(9oIgkW8T5&}3h=4x`|C&i8TyL9emj!>`2}!v zWoPd)U(&2ZLp>G9QMH29=ZkxP-Ih4HWHQ@E<+0ttE#yCG!0b79Z~suDK6TwbS0m8v zH)_&tN(}Q~djRs4Y#Vhy$$RBhnzw(X5t+j=atAK2}aodk2n{|`r9~B2D2?NTW`i|Gh zBS;_-7B*j^=3$T0-u2+!J)6Y})jY=+I)7BehByME12T!H{pFt97c%+lCcur$DlvK+ zlj$vW(mi5@c=fL1FdOV#&m%+z-j!-yM8t#o+wvMV&9ebLJMv1rFZvNJKTz6?Ch_z% zz&#OR^d)Z`vpx+Tz3h~B)U_)CJUr;e_Vhk=(dB8J!qA0w&$G0n_4KR}=st-`{YxSn z_=opbM@K4iM#@}7a1u}I8P3Cw?v&p2^fWv45u$$^0|{g7LM7xTX=jrE2_kcXiEF)8 z$3cWZgQNk8~bkei- z8b)2_lWPG<6#`&3nm*=cI87fioaK*EO4)hxp30pdkXHXIMkeIN3yNBNFU~u`yY5N4 z$G49CT~u%1U781fwR%e@s(I+D^{F>!#>3C`L9g8+%+~>!A=yM8u~CIult*>65Os8@ z6_JSn_DF-^5Al00+Z#YcJ3-D>ULheAL9TUIm;sO_F z$YWjXo+p;j#Z!egE0Jv$ClNzD7OI+Z84_NWST;Kjdbfi%bySn4;!76yUR6E_K!%?u zryvS=n^pDT76+bwoE0pFm&F!_K|CmskKc4(L7Zp3`23X-q;auEm4bUhkI~&~lG;yQ z}%g&r!X7xE}yUd8SX)$u7%z4tvZ?#k`AAG2WthOVH|{WoB-kpR2a+fl4h z_x^I(K&?go$q>2DZdogALbz~CSM;uZecr@ zRZ=1}FfnfRPu#tNEFsby7U}lnUmbF=dd``E^B)o?cE|hVXRliwuezB0b5q21ZHQ`b zVo!n8dkOsDQZ3{G9PYs1M7RQ{DszVNm_e#vymW@{lZ*sC?JhIrG!cjZ71ngpq0#1w z_@Uw1$h7nTo%IOWbA8OWZw7B7x%ot{+@LBWf-64G{v6L2o*k1A_qhSK?-a+b=&==2 z^&qK*N|=$_s>llBY#x||^eZvJQ)jXPvCi@6=Q`cAI&>U?ZgTkgJp7hI@eNw*$2enw z{P$eJ=M}hVt%s#Tv+`-d3$E2%pc8u;AZ7`h7**mOWuE4C8$AYqCo!IppdDiOhTZ%D z0bbmk!wk6F+`O)uV(3Z5Mk5AmFT^y-?Ajfe&AdM_KJz0SaNNGHXf}7Zf<#aIOBXATZC_j~N0~}N(JEJ^>3QugQq{=*Eu(K%=4g!;2 zD|g^}9|3acFr;zK-E4pJ0?57=n|yu$Wzz$W?m1$BPId=%@W1Jc##MlswcJMAQvH?Y z)gBu(IMb3e*_+Be|B>qrCgW2~*_yFBUTbN-oIszjBnN~3lwqpXzlGpz!1kN$*1`b# zypT@NQdF4+v%%+e(}1lgbN+Lf{3EH?Y>b)7*>Yt|P41sd%u**jiRKVZQ(whC^;pcD zlP4Pr@9EQ5>95v}mjJ$gP1`f{jFNg@?ZUC)u&CrxlLO1Cmi)BGq<){~pa(acq_k#+ z*fBpX=?NtWC*PNgzwclxF?W5~0(TC0p|r53pKc`pI`9Ly^6JNAlAd<3FalWuNY*Jg zsyQ7PDiqlFQCW;uPQY|cDk`_XVMOPQ)b!vw)F+L?34PWl>$?n4H``_8=U#?*H;T*0 zhIrqnnMPFs$K^%YD&WA;8Ixt)@vYTkGw{f%HSzJye6D+jaHfb zEoYOykqp<*cGGO)<0oxvsPWhDGJb#DDv_bJ2BI&cZZqHLC$<0KtnAq*b#`?T03a>f z2&#G|X*$d-&3zxk!BJ8L*P)P%2K693VqvlUECOx!#=0jI$wZbvgl9UmWSpuV6B zjB0=GoRaO?e3?vFU=JA3Ji1Z8TX9h@?{6WtP~-6=i+=Twi?y504UW?#!JCEGdy&<# zxD4}?Z?c1--ue|>J+mg-unbqytFCwph2qMx9!kS62g*dfVa) z4Z&IkDR80pV5sOOkP(Uv9hGuOo@cr`>yxSSZGpW&HG$YqEahenkd;KNj{ZlRcR}Ux zpNj#jZHd?!Mpmc+2S=KmfK2@nna+%h(5}nOM|GhiTdNI`DeHP`nZ=-^D2G;_cHzCw%_Ri-E=L!J~$LYH+`}< z*_tlJX0|pa=CS%kWwVkyvoWQG8Y}!Vru9urxV{6&-&E&XmsMBNOdVCI+9V05tKLft(U_+exB@= zcg8X++*swAiqI-4oAWZT%_tbT zRQ!I&$pok>7&qO9(I7ZdY~Z?;Bl)w2&UA8I>g;j~`Jc+1-Jjy@jsY=phe8=%hp8H< z2fvDY$UrCxOF=;)WZVespAdj|8L+69wtG8qtT4W^^KBD7>v%#XkKK_tX1;YRYAFa5 z%^B8He{F+j;D zJdBzpY39k_IaMDNog~gi;O{W3BXAuZtw&=Owp*u18>Y+QY;Qk&C|%mP8AjQ9cI%7% zt&8U=Nw1Hz?DB;QnZ0_OUcx2uQqtyCFH+s!^7%GQO}4{SpCF@qS*D!XG0v#Ea?ydufT(3GwhK|V(dWZlvN-zA2rwtEy7&xs5E z8qJGGM9Ah&VK2T3_QSik)uTSJ?Ctr`)1Me{6BkJ~aU~Q)UE80wj+4C!m*`*u(ebUev5-}4X48;E93oV7kK#BC{fqhWW4I?(`)#2HQ|#RA5ZpDq*0m!!{6$j2;K%2 zvJNbB1jtk@%*h`9_K(-k1+C${3io8zz7*(QckG)$iJj~XX#J$pl0T7{oyCIoqx|A3 zaTY^cF)6f1rkL$jAPco2C+W2G7O&G|!3>G!^j^+Q^xO3TO`qKegx}}SJ`DLq8+G<@$sbIULVC=h3 z;uKG>%s65kdOcO8@@*l_X5QROZlFR0Yj;-~B?*J~P2AW3?aqIfk|j!eA0RpCz`jHx}k z6=v~Lgp!i^(vQSW9%?a;Tft*$2r02@(M|aedI{-T08Mk4GWuE+gcD{wGs)H*6jAAN zEPh?_TIjc?KfQ!kdok>x9H;#bhK;kDyt8zRAVXsTcxNiSzcTMimN#KfRRU*&s<*0ZP%|1_j!i zdGBtXea5ap`}ZNhK9ATIE`4Ot@2!=fJ-9OOXcXC>XLeo6?8!2e{xOV-&_d41j0S-7 z_fKlZ%>+pgn`vF#qpZkQ=!|xUr1prFCDz$Kdu|e-|De}35cNUNNRQsw_uRdAU*}C# z6(L*LHAO{=uNN+Y2J1rFjypRokB)bom=hs7fB7$Bysp2{4?L)Lm3uaZB`w@~C5OxL z>lUD^qvtnZ1z0cJdHKWV6}?i|k0zOVAk7mLvK;UReC%-+b{l=G28$f39lCXcQ50^y zTfaIj`tlMKtkGTEaBkQ7_AYv2ug)Z?@-KN4b+-2pgs_d?N_j4|4ED1&YRMZ-no%n9 zqsnXuFZ0J14voVB>~lehxIOz=BI5yOW?Ld`wZ)TD$JUd0`;*Px9|wWG0kCBCX2%=(QRyEY+-WZn%JsL?e8lKHpdiDNXi{FIB6Ptrw+1hNRj%cCh0n8T%6ktj*2a@0%}PD zVLGQ43J)4Mh2NdUs%Bkjm5{P=PfP1{ZmTFMGV=7XTSPQ853$z-X3urDSCt zlVOoK1^*PzSam!ZPqvdxnEdnM-wh}R(p(}0PAeUAFg})rnAi{Te(~Z3Iu=h3jFpOL zefu|Xl$Q+EezK6>ycn?Z*z-dk=${~vCo&izp>$sjOzO+Z8fBNmCW)H?RDuL&J=dw%3o)r&Zz z=BR3c_NJfT0y0~ghN!O`FPhJ?f2>#A|LIl7H{JNGX5gfb$9&==y5_@nIyd~jwpT3q z;HK3XIg9lr>A^`sPWIw30y_x>uR%6r2~3r+3Je#PPT|2w?8i1*CRzJqilJ(1<&UUcf`+_AMc5yw`*5$Ny2JEq{b@+ATZevWWq#yJO4(bu2E|k2=dnB}yOAGO%sfHb zvgrTyDSk&=*UD0OhLWMF$Bi4Y4#RWHO+`GPln9(JO?c$5z`M(AS%{x@-d$H;#!p{t zPf<0xIvByDy;QO5RRf7G{!qyvs)G)i{8J0_W&e{b(ct1sN>xcAJoG#?lsZkPkQ!23 z4k2k;>moy*+lp+|WEh7ok-wli%#R=cqfMP42BMJ2OJx z4;ahyx@scn90H1<-1pIT5$`WtwTW$<#^n~^cL}(QA3VAIRzHKoz=e^T2 zb>r+PN1b1BP?v*C^BF7V1QCr^i)eCPJz%IQr=A{O^_BqrsIJM7u$Y-k#n8r6JFjAx z9COa@<>!2>5RW(_ORp_SW<%utb{MEp2!hxgSm1Q)ojfYfJRPMFv1(bXmL+K+n~JjypIehs3~@%nR|B9!i_DJhjGis9Ju^!qs3+QJV~8cya{RaI5A*kxn-CG~18 zr-d|#V72;s6*pkG-nnH=88;%!8PxX;xUi*6==R}at z6u#@16t4j-^HP)kkPlSR`DGkBRLoj!ijYt-=O`;fmJs*OdRh7V&!1g`%lCI@%10xy zyQhgrncF`&9$6tr5YU(PCQr9Hh!i_#!s{~v(RQ$8%*t(1vSeM60#hX<2o8UA*fK9&+hp;v#u z_q}9PyC%U5$f}`6-XFW>C`l$0jLQT0Heut&Rrn!9uIqmSXRQj3qk?b;hm(72b#9kn z{1V^m`B*So8w*eKvtsO0veaOJvv|Dpv%z-W%lzUb&RagI+5| zD}PRvTeE~7YR~5UqNUYV%nmx*Sd{M&M{sMt!4A0-p@2hIK8pPo>`Q`pozY|M(azEe zOZD!%1d%u>K`(DxNMUv|cXkMM+#7I9?Y=mpjX6yS7kr@F3$z^?Eoa6sUZ>nXCc&iV ziDyS&D=P16!4A9zB(M4E?yQ^mRQqW4@?7qI#SY$1RjY)Pnyh5IRSfaIn6WAMhV^BZPrg-qG{iZdesC&V9 z*}+)%?M1Lj8wtYbw9~z@=}`NN3JV1P{V&iXfy+_Dg!k)i0P11FQp2 z1_;l&JoElQJ1HU&<0{U!Rvaegp3e6)aF}g z6CgySlvgA_8#rkhdU$xqx8)fcjazYUtuI1~-*B17C67Lto-7;RymUdc2j@-)et<^B z*Z;~3F<@_i22A|&h0Ba~HHED)_x%K$X?H|c^VZF*N#CHDlQ1Fr)zu1C@ceL+Cc4KZ*A?ue` zS96lK{7=h@0mMi&fl;OEK~FRnL}la_eUjCMi!P4Jb@q z?q`zKP?0c;1n;tVilnRxZWW{#>@HIl^`U>TS}Jqc`!P7PTkYc5EH+o<3)|%AVY#o^ zq?TfH)3y0_h*~5-bc^f({S$Ra9>D_buHTk9k_(ZitHehdib& z%=^9_hpzH(Rd~8aKTC=T!58N{d!#4JV6l^ON}PE_SOALdfeS$Ps?Xgo%SqF=g&Rd` zh&L@MR}_R(B8dD^>|tzX87+=Y-abV5dZ z5KpOczk`PIn{=-Y4;9kh-tO#Ha`y|KinUzFMDWT_BCbS>Uq6L1QmQB@3bwvpysN3% zdw(Ngzr^Q^^oz0Dgkeml#ZZycqNPqj-MCG2tS}vPu+?bnnSnR{thG=R6g~J707P|x zTR)r8f1dKx=5Wn6fQkgNyV#>0gX(uBhNgsnMdDn8Z}X_LAkV7<6W()%k`1{32n6cq zHn>sFhVa9Cw$vG*x`c0hw^@^p{j}2%cF-}a>SxH@89owFH(tzQvj4!x4JRBM@A}7z zi;KJBd@|+*^irq_xn#F1c5^P**!g!Nsr4_l?xdg7>iQnUR^{uoN|KZJ8Jz}}5pS>> z^n2pTQDn=z)?vH`qzz$8lI)+R8=qrz&IB%(;?d~fKQ14VZ7vd zL%!|glCWnUH?`$nYO6kPJrTj)$t#GW`p-zu6*7o243gTP^c2Tqlb3@{_Fm0qmLG?5 zgE}-W?{kXi|Gif?NKw))nlCd=ouSNdXR@?!b#;E&elI88$H#rZWm@9uuC|H6%B8w7 zA9CI*KC5j(a8^9NlklQ%Q2lq@%erxA{3p6>(;oo2h*d>!|~=9Vg)8$bi8)+G|I~^1@8U+ z$eFyR!_Fj%AdcaSU~(xbVMN*!eI-oG#??E2d%4%BDeBK!7wQ0yGl~WfA_%z?sp!E6 z^XLZFGSKW@VDVzYo*K|@U((WU8XBH~ItUJj!i7_prh;^p|W;KtLe8@Ttv00d~%EA(o>g zHcfn%)w)i51gMB!fltx&!uIwLWda0xkvC?U#fdX!^GfRrgQQ3nm^IkK8cKaIe-jnk zQ=P2Lw9(wdtt~k?*m{$Lj#Pj8`uf7RFmhM;8Vn`OEVhy&yoG6>%MgZy+Ax3qPB>3} ziCV+NwEOfElZW7hDroVr4eK6LN-Ss2u@blc21suXOV)jDNsGs^ul!q=9pixXB^-I; z)nJmF@@@9qb%p%59DTg0<|3-u=PN?@U)&5O{+eAOI%J7C+UblT?&|Fm>^3&0fPV58 z;cSoiAC5DY$Xm8mna*2{<^*n!77Rz-^NhnRNj8}xO||ov6IL~&m=I^8 zso@tz?o%$MK^TAJy`(v1Pil(rA~wb~zBf0wwZy7XwqB$AY}v4ASXObUxSgh_w|@1* z>z3E4!7MpyjZiHK-#7uEY;Dp_j`pkR98G~~jtzV6Tx(fvzs zZ*bb7%(1^L{gT0A>TDVSG$;iP9KYgh6(Dv70N3`E80U^pH-=+$N{FrjSFqGSJQxI& zg~48l3*6ZksTy2i?{xJ_j;fg2wiZ*h6>KUSQm^9yL7N z+}(R@mAF(6u*xO--~8w|TXNU_Jn93KXpH361n-rOR*Y@=f#?z=`f$e?&9GeV_(^3m z@%^Lq@1;@1d%hn#-fOZ?fLvYqBF6&}j@6W4&6AYedU659lS!y7OI9C%s;P;u{3ZO| zM7TI5TsQ0ohGmnMr<<2E-R~9~R+C(TfYlKK-3P zKG&(um0gUU-*D{Znx)_t+h009+Wbk;ue+F8@`iMw+$vZUd|ktPt$5VpYO#9b04>z|jZ$3D3Zto_ z@L8Mw7?y$Z$FjTGSXws2`06IV$JUii_c96EMZ_BI{%M23r6(Tv?xH$G(ZWXu78MJ| z{X80#KW1QrLoZ7RwnhUvul^qKg*%83HEn^Oz|?i1Yp^_Z@$YaFNv2uuyuU(wC`ERX zhVlKf5Lx%mnkcli{ZT^m=fWcwuR-a%4KAN#jH^~I&Y154_YLss92T@ozym8xPs;4f zI^=<4f)0R;IhYiFd?gAgL)RCjqJMBWwS1wCC8pDPZsobEt+9@uep&P3_pf3qz-{{G z##dKYZGQdgrnh2oYFyARNY}__M5Th~c`Lo25vjJGCqgp216JG05fIOql?23 zqd;@OKx(+C>za#Cu-8)AZ@nkfkBd%_Xkr zu$>mGn-uV>xaFIuayU()6XDs@>Z!9y`}LANE2Gaa3)3I^bLvdAtWr~&hix?Wc~cF; z<#?w?uKk^uiWRp44B{_kVyHX`Ayq-R zJ}hw%%;g-9DRWcLL4w@m)V#j7mFIX_Zp30_oWoR+Za@poO;Z9d1|3F$#qJ$%7roaZ z$ApokFu~Ue&wct@$i9VsEtYBA_9errkhM$Ct{G&`Wp)YRqm1r#eF7^Mh9I-fx0;g0 zpNMK_v8DqIzlrLLdcS|I9zHQ^wwfO7afBu?N5@o8{qM17i!Im~m7MD=@ud{)q30Na zVP(K|HnVf!V;8D4FiCLp%q(Z8CL6#-O8vE>g~%}bK@A{rU3;?AQdJwsu-sU#U-dJE zZqAzBlnS-2S(> zSNRS#I{TvilC;Fh1AyH=74Ccs3m)nh396Hme(l*t$yaa}1Vsv+y>M|(2$GC(|GIpM zGr|4H-tLNm^K=|G?_dW($Xv2jOEMdz*?*!-9tjlIleu+E#A6N^IO}!6?$0SE>F0o& z)W!aH!DbH$~H`ePh>2N9xi;gVwP zbOV;VBZ|F|Q?ANtd^NNv;)>~%*J4MZjOKv2q6U_TN7=CaIP*$~gU_uPB8ato8tS}o zW~KreIpg4=r}Ee|GMPG7)n<^l%p>k|RWXmr2|ClLe6zwMm7TxCBCJOa&DfnawS*{) z%&(pByWJdgYmLc6nlq^k-O)Yvktm!&jyX7i3TKBMWTiQE9~sN;@Zis9V1>^ z{Ne}xsCb~{^`KujuiWW(kcnge#R+orr9;i8Yw_30vfs?BB0VRClRLWoTZ}%PslsVX zoJX~(g6um5To(mcte93?wt1u~>ZB#3rN$;OBiJPDHe+kHUQ^)XaW6|IKc zDUxk%+uFyj;8GxY#7cX|U5{$>$2*}+g+--zi#^YrhFusC>y6&&u{EnWf=pq~$l}|r zi#4Iwp}ZYKMqbsiNK01_Vf9nsW}^v~>e}q_rIa@tJ}BI5r4KSS1EEcgFLfPF%WX4t zB6nhy$t*$5cNzuO1n9lZyFY4tb*g8){iBRBK>O&tv{>vs9Cn=p9F{(~CJW zx=XGuVh&zR&THNhv93ZplQ&FalxX^Pj&Z_6P)ht&b@bMVwbSbe+l+-oU0trf<8;f> zsM0R~uBbwFYoqx+rv{-TY3CAUuN-Tj-jJ5Y^q6IvyU}WpVhhVH6*g&RRpm9j(spOL>YGd4w)_L1!^B}8L5kl7W3^g<}ub$7}& zVo8a1^0ALxwYsiaT_pGol&^UA#&do`8s*x_O!-n%u|sQ zn#J6QgX8>>JuT_;hejufZ3Qlvms1DSSnoOUeUIRYUG^W|r-j?z$!4jN^kY^QzOZ3- z{milYbn8`&-ao6yH%Nd)JNZCS@_@VKh#wyo24^gypY-7k}OWEQAe2b=d`Rdt+O*Gn2lI1^qMGg z7@F|}zm-j%%TiQ5mxF2hr$2EUz4UX`%z5=hGP+--S9I%^+RzJ?NAQz%6MD;5xTn34lZ_Yr5*S`wI`x({vX1)a)FnTx2Q z+-GvqIo`D^n&ND2mo3L^3-3O7@WQTbTL|2|dakBNKqB?>V{klXCgYz>>NL0Z#(7ly z_Dk*8O9tMr09~qz27~{(lvx zqgBL*NqjfEPMLi0+9!x!SdcWszOvMJ&t~?%F?;Ys`ieo>a3?{M0#Xiy2Y1Nf+fR#t zn?e|+ZVK=b+BVQ`B|>OFIUR3BqCX|7ZhsPav7drLXe5!81swRNuUxGzJve8kWFRHW zQwCP?`q_|ckOJSHXV(3g#ctwWnDu6ljmB03XOxtcUW{8*5oV`v2gh65qtVrVH@K)s z6!Gq!t?8Y{#AaB&B390}`bh6azEQ$`UZO$8-(r$Gt~UmRs8gCMrJu^zMC1~5EQc}z z%=IG#$Q91oi>oMq4LzZsDUx^^(P0)~4?Qt?6}3HWW#QKkxla`d8cH%hl`R%DTrFz= zgklyKddQL5>CTNmPLZ*=!n#|vuh|KrKDTHOeROUhqJD&R|$4mVRMjX%n+zUYtv!IH_#x z$*~$5z}B%^9OfM#@Wi%kosy0F-cSiskM0>qbs^ecolo<{KqxpE#jfJ493~qR9B_Z= z0(+Rbxpphr#4l0B4_0YS@t5Bbe=aoKkRObg{uZaqw))hJA$T*0NsJH?FK)XWQXlWs zLoZ}c|F|vY6&wPipT9e1<{!O=lc{&_o>G%gvD#@yiqh{aB!U%Q(r$gD@lXDyVAuF z1Bh`!ydm2km45=Y-=lf&8D(*1Js;=-kh>c9!=r;fv%=+dOQaz2pdoAST#sGba0$tk z_NTl$;(cAC(3ThyHiA*UsD1QYmcgF*fMb6;?5Mel{ssa{;@+UaAi)X|H#_SvLDSRLf3-_EN}-Ope_Whq*sljq*;J`y8#-}wca zJI+?l>(9?9$QpWl7mwJP5Sgvou>jklW>j4NI9NgzgMK|{*XhJRvGvTbIXyUR^=hVQZGI`wx6nh%p*f=3*G`f5vQ6`2CzE3(1xT}ytNkV85SRP4NY>y9i2Uw~ zHl2U=aFs7Q6hY*u=^K5vWtnFeRxl+~g~O-7b_F_;_O)REeJdq!d#8Q?rv+bc)?|aRbmz%>EpI zM?g#QVtB&El?xc@FmH`U~aGh+#@BfDqF1p4|PEPK}{xB3BJ+Ey(Ixv06i$#vT zJjXEt*W4YMe|3{hy0Nj5|KS7|8iNGkNmW42#LV#K6@l16YO5zqaep7ZWHZZOeG`iK z68nvf92{Ey#t0H|JK@G_3B@@l5#@0ICQMcQo7@vmtk#5U0^fBBeG>)0}B&QMgZ ziy*Am|J*j3nr8@DwHQ7o80l{`<dSYtVYX65v*hLDw22af$H|A$+g=HbUsCp|QTPz*xEPsIqf{VK(%qvm+;Yla<8G zprFcT9G65wmdmgsDfI){Y0IW;c?G$ZtNj}zPAo6OJQh|~im9@SX$oeTs5Y;rnz1?= zF2yvtM`&y|irShSPH;)^=XUyN;FP))YV>P%bo|+X_w!aiR8|oAGq*X6*|sD*Y2Vve z?LsQc^k^Y#rS!qKKgO=r0Zw=FaRpL4TTAp7%ZSzXG-Uf7h>p zMBj6UolaN%yeUSd;5PtKBQ#J?Pi4RpSPL2G3UPOB(K*T%Qi53q6f|!OX65 zxawn@g3`HsR&naR?}Q_v5y;gCO8t3$QXP`n^Rwa=Z~aOD9(~BB5#-le!#$rfZR`*R zT__?O$-S%@U3oUy{Q4cQ{JTMDz^n)YoR0l)sQSj zg8XH8&W0Rrbeij#&3^TWTFmLe2xzm35&M}wK@TPic7UOVyC31FxGW^aG<=<&Oq##R zeM+9+9c|WMX&9wKOF}5R5c~-vVN%tl@2{KV&>d=Gk};hY^G@Pe`wnkXdf9Q4HVGpS zTiVAUu@?&+CBX_BwDrDtT8#6`kBB2_GXBG47SS?z{<(RP2J+Q`*Pb@5kxo7p*CxSkX$VmH-XE8#S}F6FgN4}kHV zS^Tc&ohbfnp5iVJIAIx&4qke%)VGgKW2Rt5jqM5;wI%}g2mTwdxRP!oT}wI;^KNa- z1OV1R46L|GrrC@rYnBR3R3ZoEWl>&$TpMHwU zesHibQToMbvQ#PW^uk~n-+vOB5KLFfw-e)i%T-ME%QbF*Uwl^DMHHm)hfbcHl;wD) z6el`b;Y(Q+BBOM})6?^F@qy#H^Q;olP2>HyxdAv(ypAh-6_G+sc6-+XvYdVQ1rZ&a z8fB=H^+(r~V#ehs1Fmhi+>DT~vK6w8+AnFP zLr@SHAC)z1;5}$q0p>&V7-C!PMV*l)C31_%QcPoQrVTb)uDA7G-=_cxV(dqX0X8^W) z?cwEj_HgCbxoM>VcDJq~<4gqR&YGa7z~oDnzp#w`KXZ(m5QI+8dRdR$2?0+_!3ZqCK@xbjucUh%j9oTWXntU5G5i|lfLjEJ zgxk7+Kb6~yKphtm{*}VX<){#Z+n9O7%Y(?KH6LLs)X6DFgV;r^{~W4 z2Md4V8I}AR7Xn0fPg}n7c3QLJm)Zs*4b3aH44>y~g z+W3}jjtL`Uck#`JrZa<|rm4NlOAVkF6;+vuQTKlPK7Dt{vRP;t0#j6uIuH3zhYW;= zsSgE_i6(%wLa?If#%qNv1m zmsgNVVhtH`+2%n4>C6-q6h@b?luyjx*NSP)$a@V3lhn8Jj??vj9nejD5R)@54oiTT zBzW*D?RTA8a<#K9Gz$;QoLby>=KZ1jb{B!|D}Jw*tS_4wBX1v_kp?GICpU%7huu7q zis)qe$Whh1+R^D4;URj?&LcLXb3auN#py!$m z+ilb50>as|9l*6G&tm4E#PTWGk>{zee*_8qxpQN%b=|i5NcQ& z9w1l1j5m}G`9-@Aj%8tJ>haIxXka%DWTHfADUqFs^Ws@$i;ej3C?mHeEPtizA$jG= z++U#9h`#dyw8B?s=j;Rqphzv=Vy%jKU3$=x>2?fFCYBrk!tI%i_7O?Y=EGTvJKP0$S-R zu&k_a9XlL#`Et%Z7?L3KNmYa2i@8LPFGzfaYi(BQ8rj;vyEEl~n;oEjf+h8EF3Mri zmy?MQ$SjQ<2cp`fKzK#%6#m=WPgVV%S8p2i$mwEv2zw0sN_a{ot~U;{5x-;Ss?HgH z;$@Mt#El=c;yq_t3)@is)}q*UTY{N?DZ zq$*C03nhiz$A$M#P>z_ck#%zRCDh7jG%8{e%z8}gi6u$1rYD`&SnZgQ;5PT`-&<5h ziCn(vT4hz}&_3O3)G#W>f77Ll!?k3x^VMUe4dd~QwT<%Rc+Xj#Cqu$a8h!3>m2(ok zUBnO7>)zG?r$?6R?F+9~j>dX5gdeJ~ou&||6S}#%tpCHnW$eMIylS8Oc1hXd>ed_e z-dLK(ak~dXjiAhc%MBR;KC{hQ`Cp~@LCGRU2?$u^jODi!Oo^J#bdCUW?drhW(fEVL z^BZMk>ioXk0z7;hcH|KvQ?1cq|NWtCK481mDA?Irmz({htN9Okz`pHG>^&?FS&KyVWW0?d~$8Jn*~%%1e8pY z;+NwT&_m)O$&yjJ;0i&J31bj@D8o;G({#Gk`cxI&!tQv&j{#{@%Gdw_!F$=$4k33% zX+=$VOcL$$0rBLIiT-hngZYCARob~qTkd18i0cTJHd~&_rRh?UX%TMD0tA7P?* z;UFv7r;CS|mhWBz@4se!Td=T{T(FU`WP~Uw^OL%&IhAN;jo-(S@AX7z+X~i!<)0BQrnwM?+;4y{wxydW`ytIie9CGiO=EK-a!Z_%u=iED9GBu^W zq4H#wmm!qqNqldf@hH)r`)x+{04z5PXr4t9aI4Z&Ib-gg8RyUQM>?GsvKr2)*%{Ed zO*s2{6+;|Ccr8BR`NvSejD;?UTU?QH%P$~`_T0B6ykKROj_Spmoh ztj4CG=vk_vJGJny2G|uX#K(}bY+eN0bw{b2laA|*v73(JFwpYx&O4Wy<0Z(!xy6bm zg+NN(oAqC>pnijxoDANOy~Qm^uSPd1Z61osO_bwCAzIXS#; z;gRngDwQ*LPoW&MM)pGy2tEx8QxX-CE_L95Y6E|r1ljprr#{v$?QfEQ`JhIemsdaS z?zXE5!n;`nfvvNHW}|!T*#5v*G{N6rpKMyL*>aef(@U*y_=dN>dK3YBuj~uAgU6nY zrVS99N__4kKF&q|lsoul3;ulX1t+bu-Y8?z_WuMAP zN;jnCmTA;@$$%7yvrX_=O3n>fGVg`68p?CC@tKktet7n5BCiNiskl$Pf)ym!*g!5` zAquDiS(VY`T;3Eh{(d8*lacd2bT_reG<%{S<`%PeKp~<>rN}2Y*t<1v9j**kzLAL!*aEiFllfxK}LqR zCHs_1xk8A`!sBQ5$X$9knN!QhRy3z96LPQJqvd#7JvCflyl1@1M*b-^V98OFYcNA} zbq9=MZDHEnlc6qg@(Ki?hxG_@7N-n0T+l6iD1yBIrfS-^)um;-(zs2=i8+io;|8&p z2M$`hkS@4~`gZi)er4)=p<9b#Q}ky4aQrp#GMv94WY|`tid}?W23C9{pJ8?SUKTh-mcw|RZ{(!&c+wZsJgu73;W z)Grxdt58ojXr>Vat#)Bjm90?F3a2r>Yy0|;g^lK6d+d;_>RHb69sp%YNlg0m$^mjR z%C|kFCH6KZXi&y6clJAkGmrU8?c5`AjVyxmKAUfSaH>|ymBg1HFbN5U~fX*V|U9w z_9mQAfKg^-b@~z6Jm8-(LU2v#GTZiOhQ1w~$m5`aEgC$^xY+&yeQnp`*znx@&Jp%U zk)dm4g&A#_#~ArOcYXsUCf>u#DOVEM8lCEegWplI!6GI38&k`%)543Y5wb@S&rqR7 zcHNvqXOhFY+On>VN3rXO%XbEyOX9v0`WBK^lg_}R3N)O?u`8y@Y_^4L&VeH0n@i~J zw$Nc!IX~s^XM-Rw?OuGXet)|iVKjOA^dVd8b}?6tDGiorqXwNP#UK4S4V1!hZ}E|X zx4u7MJ{KrV{Z~VX>H87^$~FDA#aE^C0)7vg`qIW}i7rmWaZB8IIoj zLq6Fe5rgl1TN053PPlg)ia$S7o)df8yjmS0zp8`%6xt?sQn1iT`;w{Ge-m8;Aq1K? zfwl#*M5)n$qkB3!C3Sxxj6$|#x<#>z7qSdS3C)M|DMG&BX?8#-!5Ucl4?N2kfVfk1 zh(r(&HCO!V)+zq)p(b>T`yg=M* z{cKj5vO6m1Y8hQD)F0yvpx~+9}%)UDi?+C=w4A!4gY9TV)vxO z8*Pr>!_g6^>vc3_&_yBQ>Y7%({SRuU{dv@;L;`-Lr(J53L+)xeHEAoz6SQ?MeB!5g z)CwI40O$}un>&eqbDj7K4uffVb6P4v(WLud*VF<)4yvRCbg1J(aMNvI2s6{u2@v}~ zKR3mQaSN%*A@yET$HjhE_##LE9gn=-;=v;~;!tyADhe8XP0gqXQn4sL-TMm~wPnU?cS^MnTvekAqQSLz;WE5KR~5+J}N5QBBBpAN}#UiQk& z;nU1HRN+OpaZrtVn-J065WH$g_j2@91)dcf0(j6j!e1a09Z5Z^mbv3Oaz>cG=po?mpw{)%@R z8Yo1Q6d*F=o`%NDdmrlzI+H%edcykzIYKOZOWHqwbtMAtwz+34^(1dE-|xQ4pI%ar zuE(avcF|3p0*ac+rmH*cHX&;U>YbSPfAZIaO%<*PNv0T!WwA}1=WJx%PfF*}qpQMyp5V2%T4f;o+*Mec~@e`?9S>B1L%NF|y@gIYiV>d}|# z@6O)IwYflY?hKlBer;>vTZjRT#>c5OV?_45+=`e&Ea$7`t|BsO!+CzF zt~zTN^XOtZ5wmVbrT42`#TQAVISD*XDCwff0V`7oZ=-@3C-hf53_Y#?;L*?vU080G z=90mEX7!1ucY^9F<4~UOU^c9+f0T1)^1~AhqtIL{!{~{rhQ6#qOF^_)GCkrQ&@tuh z2gykMk+w##sEMBn5Nco9;H3>PT%A&UdD{rMri(YuNJ`~_9)|+hA}ZwfV6pJZDsGqI z$Nx7d*Y3XQ@>ji$rnvNHdj41&23Aw5c<;8mxErmc<`&t*4z8_@S^tkgqNgia%Pr&- zBzBg3oxzj3vDptK{3VON`vcb1ic9#-S2YuUbbEfc$ms~5Fy8!o9&`3>&PYgA4|OLy zum4hC%Jh=-|1+pw0R4TC$draV&L`m5;Uy}fXn$tcW5A&tL14GHzQOnUknI6T*uM#P zIJ!fD03f!*hX}bYT!4+&yjXHjReNl&)yQ!s_(01hvfzeFol8YP$?=cWH(Sq7R*Zcu ztmj1m%Q8&jU4%#|nBRc9YP8p6F9@FC7~X4_292rquyg{zWE0oKX9z*;FqrD4;tp1C zd`|(jlZxsEw@6;y<463mfGI;kke)(2PBc6rs82WN(Is>Pd*a>0Fc}AJ3xm0b9xzEH z&@3O~@yS8mTnYEcY(a~8mnH3@#Z1k4RRoFjTogcE@Q62vxF8T4SGO)zOpE4xlsVK! zZ@W+Kg!r@E^bcYJEBtWh0mJ=BDpJwKw%BpLDz|Nq2w56u(SHRE3JH>?nR^<$H%5!L z|t}fV6NJhn0-C}&RTN!-_0W5A_Hv&EF|LqU4|Vh zX0QkRrCeCh&_{FB`~>RRpWWR?;Q!l58Jzi%Y}oO^50b$bXJ=Rbex9LfpOyCyLuoLo z3o_FxAi4(KjSWbF5M;<}f6&7c_s*;Q4Ue|a`1bJr_0%D!GF8*_wM>_oeMu-RYaZl6 zmc2H*jsz8o8aRu)`Ntn+5;~gTS#)ByE2HM+ah~m;DX<7fS$vP4QVcYQrzK7&c$MV{ z7Gv%yNzcqB2#AuW`SOeeLU3Y*XfQj5t5V=t^C+*}3I@UWU)8*Ea*z#BoOWu&*?nq6 zdFZOYx#WFnZQ)~$o66mAbzCzl2Sxl13XRE8&g%T0^PrEZMp@-WEGZ_)QU@)r;kA^9-sQ< zQX7vNgjkOx+K;|0C*UhfanztsrFkoQiAtSt;WW#&*aiJ?v+IHEUob(z3c7a_Ud zV-(B^G4>|&Wwyh8aC2JM&3jdZvInFGGf8>gXyqAN&vOZog&FNIy~?a_F%2!lX)W4s zko}=mveD;-Ch9Xt9Xp0zM#EySP{h7bR@9KbzOOT3-Bk$o-xw?(9yX3xk7`etz{~cXR!?D;Z z(8LZ4GMq~S^~VJ~2G8biFY0CPKCpq5;@Dxr=&>;vgATd0dL%X;gA9pkD#qxb-R0lJ>J!HJ( zx*l-A@ZtF)n|@90Yh5_@WM|6e>VP}*wd#d(Qi|cbdtd3|_vsuT+#l&&)a@FZ9#;SV zSC#PL7B=36U97)(mH^A{J*xm!mP^3>*GG1U1SEhEEwO?HuXOG1O&s%}n?}Fu^gMQC z-F10Q)vJGeadc3>MZeVbWX67P9wc)${VpXNJU{T!$M0KKLzRV`lc9%v=;9umMWPHh zrrttQT%&@a!Z+%-nOu~wzN4@?uN{3EsRrS!EGsn{*w{mT(Jt&gJF*lab|vfmr?b@G z4k0y^(les)KfV2VvhNm&ORG~Ei(WJ3jWXToa(hFozx_8IZv-J$Tw)hT*kRx z=XZXqU+azQn!g#Bh7%S9lV2XP@0+R$B8FbGUgrtLA~(O)zR!D?@<~uVBZor@1sJAp z(6*mCv#RL}SP!u^q-{?Zz1H$%Tx4DCeM~Kn{rI{~OwD0RB=u{T4mRT%X&w7RL!(o% zoHP;FM77`Rx}k9>=7UAVAUw2c#BZs9xB8ZgNQqviLwcS?zfj4}N&vbI05spPfcg@8 zr`CO+2r1iqDB+XHTI4hvG!{xNv%9-8yA6c$A;j6y>oV(#)OEk=7ht~Dyqpb|2q>L> z9d^d@FjQJ?Px4t$DremGr)2s)jtVRxJeF5{r`{+iAyqk{tiG+SZfkuO_2I7l?#NBy zW~4M4T2MBB!Q}itFCEMqV3y2lXhVWYl~8v1g=vuVZ4KGTOISf*s6DImb@PAdQI&Xg+K-(~q-cCdRe6jE-3A%Uy>HFn6AhBMxNh53x#{vNIg@$N99 z%*_vrj0^@#oRD@tyj_5=p^Mhw4U~CRow|T(z?_gk^{r>M0a?&R&32_%!)_V-9*)Er5_a=^ZoZ!RefODe4rthR-G+;gk}^3T z+uQ2iUfNmR|DK${Tcf6~?~4lMf^kEEaP|}R%RLLWVrJW6P!3PXge@fHCG*0tx?_8( zA(S2E|6p}TsE%Xrej+T~a{JYr<3Ro(L+2TUu`H+^u=SxWuzM_{XiICrb~SKwXZ2md zY-@jPBP@5z*lGCXwkuf*k#EAgJ0zR#lH%I~tELN=tpAwm*SRg0`Tk0klmYL@a_OS( z3)GfA+nrfW6TFX0{`sF)>Kl$v4dy^nZyVTWQocuIjnl=B|4@z`<5b_HhrSRs^o%~I zv4LeP71O!HW$B;L2o7zl-IEub=5M&%B0fS+KI75X23!8z=QnBE3)7nW9MOouVlYJA z)$1Qvy!-d+$r&z7s!W!KS;`tG;Z>z=RrYMMNlF@M+)Q|Wd6{wE3oVBnAtm?dDS>Y_ zvsqxbGpv8B%Tr{huJ8u*B7kZ<*;?e)EgFe;+kXT3pfzBg0+58?{rh1?=aK8_EABH> z@*Eb?QM~{Trx#59Nxh2|o3L1!FtWx6XVhC~_6>EV$95c3e7M{i)DqE89g!+mwc;51 zp(HTrHDN`Byq)M1HKz0DQa->kKC<`OTndzeoI!*UCnlo`o4a@wxD`2?``?1U);qu> z`Zb$yu|&kgWB-OlU}Ue{icS*U-W4}2e3?`QQyQKcTB{;jn9f48?ldCr-zIV8-o%S5 zROJlIP)EqU&f)ZneV%if1f8c2lU=cV8B-^za2GzmI?xCiFv#5-lAjXm*U?Z@Pzi6) z(NF{_5VK&L#H*{(PTc1k&3PZK>iRT?d9UJwS{=N{@vWc?g5j{(Hp?~NHiBMXmU^5Z z9`d&O)qnL?2k*-2GaoU2S;R&~>HPi>t7+2WkcS5L)~t2$fBOf~!pj+dX!{|@hF_D7Bv z343CbpVJn^DY$qb4>HoyV*gR+SKEz7G1%-=fS@6hUs6+Vfw?vtOp_(Jp<-}i7EE+5 zp1Y>>@^4RmwwJAmw?rWV5F{GCz8Bh*id5_*4v*)}x%t(e zq@^8w!C+NY4pjF3X5Ej?Sr4zS|3tkQ1^rm7#JgNngKl$7QCL1mV)`jxDwhD*Yl35+ z@Y4JuhAI<_Unth$b>C$e{@!j_4c|Sd&xKCCm2rv1H*=off#@2CT+((&9y!6Zffm9L z%y0v1G(RapZ~Gw?Y@x2Um#*dN{R#lde={NlB~#NBn=KCWXB4N3YS_YCX*<8)n330% zr6DsUbmr21`@9ptGuCYsQfI1=p7~?yO+#h+Fwwr>%sFeoky-=m8{X?P`SeeVgBe4! z!+1XH=R+<-hk6Mj`0o_`XuyBJHN~V|_yeDo9re7f1K%t_7b+6a;#7$wkoRJ0Z%mt? zi8WW6z0ug?PO|j21?)%Ve(pzl5B2dr3L`crY?T&LC5teE5#j_1hO{Z0^^P}b6Z<&# z&9FsbA*}3H-~n*hYA@W$%PBKTOsDtrLmdTdTyh$6P-ej0{#!!W1bMT96|`|KY{H+G zG#^`XadFk#(;a|JH&sGGCvflq_A%^E4Hlvo|C{}^vD5)e?6OHu?**)DaX(gRe@jwg z53&WZ_x^`V1mY%NnQToyR+&baj9P(>n#XluFNm19FwVHTcQ(g0?L#`oul3Uj4H=&Z z=Tz%lM+-@?!l}-#I|#?V=9c%CG(PeAn^mh>fo_ks zcj?gC+A%t|(`q=_|Bo?(e;Oq2%pyzFp;tX+i!1@Z4$$=aF_z+YO*t;$6%upE1;)Fh zW>~*sjEoXI$_>eExaCCut69lgXF2jPU+(@#mrB-tA%pm>eg&VlrI|KyR)9 zhbH&C_^-b1SMO?Ll~2zh^Yin7NirmU2`5c%>Xym^ zs1OCGIc%0_o{Uo#IzOn1o8h>3`xuV+zd!pKuYG*iyk(%DwT|Gp z#CjIOkkYPxhLI5SS*|hGQTfhck9FG$1-;G3=R0f)Rta!!E#obGZxP=&MYo} z@jPBAM7p_bJ2+ddiBu#wcW?KMRm-Pqv?YigcdpqzNnyJ3@dndUR}G+7*#95M|FBwH zayHw8|7XRUUknskO#*&6`x2h`6Z7+SiB8bb+9L{py1Sb^Vo#oBDdjkR^7TWqt0!lo ze`w=+p?~)aaf=|d(?=in7;y7D@_3dT&UR-)8(CaV;6$fXcKmF2?mdQ*Z(&MJ(voN0 zry7hA|F&=a>wLPMLIGn!`r+vB>LH+%_B$XDM@$1lH`Rbiq{rw_`VPczCRV-ZX@Uht z!tTWYZj0umr$z~mKIKPDl?flDnE%!Z*&>Imh)Jgj-^F3H>g$om|>~g9lluF#v57Y?I-`U zO3V6mJ?g_J66}xZS;WsweWJ2lf~2{<;N|QYzLS_oaUJ(+noNTAZHOwq=voNwnB*D3 zx1D9vA@-}8|UrJ(caw==P?TW!YxXo2aece=nl z9AFuGP6j{;teBDwI_hj8n7+BBA5ii^9n)Q zHc1}qJa+2Z3qX}{ELj}h@_1C`sNI)_nE=n1 z?%{wy)n;EJm_gtOfDfU|rf`*RcU+|ZfyI8Uy#8k|bbmEe=x`n#BH<4Ja-eE2RfmFt ztk~-^?9v3}27jENashC)x-gO7XUI09C(AzwR55X~IxMY=D8Ij3abVdWAQS;1(Z&Ma zJ}-Db4$x}616X-V3e(-Sj_!eKSmdV8D93>=HF{{x_BzyBdvP(LRg%^1*-cwT$P)I3A6ZO!4E6ahx59UK)zNG^ZL(GpcC z`|9?%gqn59S?YVI@_k~;$@4{98?S~yX%MfQvQ)Y9@ni!9P@jq>h${z=J#3)}xDv{oK-1APGf;Kuow!=C z+O3}+H$Cf~4`AxWRf4lD!OJ>0ou=AxX&ddi6x6nOS$|2cYd|2d_;PT&#FYq<@O3~U z+1<1`J8B-$L_`2a=tDpzJ&7f3on!fX8qe>#b{T8byq3lQYzPI=Mb5jotYzQ&u3?`n zxFOHxojp(pG%T4w0_>LH`*+f|yJ8qqas(K!mq%GnvAI%%6zg5XhbzMSpAr(7$y3?=Y^ILcSQO;8E{TN=nyJgphVj_2H6Ar=N z|2hu-3GMewI34*H1+x94hjVZ4k7j{>Opm&F>9m9-YWNYQhS?p~lqd*X4{y=E%cp9? zuR=3%Cm^q!NA|k`1<>4joN)#eRe7Gi2da7x9(GnGul=48xXesN@i4Xg4sE7+n#POu z6(;b5m2u9?pq!k}+zLWHMa~hNIP338p=eBDN~rU27frA zb;~g=#^KQPWg5?mi!UOA^iMXATZ60UQp~?;l$dfdE6K|c-z&~ut9wn930U94w)09~ zkR;ltcb1=E`Vz^=R*R~7*-i&pxG=shPjxzZNTWSsYSH45^LCm$Huga)XtVOG3{_o> zh$31(i!1RCd2=$#951lk`M@w@eVg@$KR z{F(P;yuH!Ai6v?OdCZq>I%*Z2?f>be{2h=y(f1b~@phrZb-raEKs89&4j?xi{37w! z51{3MR<{};KI_96eMp$M+c|y=RFjSa{&2w&bo8&@$%C5O-_08F|Iray90ROLt3NJA zm;=>x1;|!gB)Jqr&Q<`$mzR}z+?OQXDmq5~>pey`p8Z)qlI|EsKqR=9|9~Ghv$^ud zT+wYu0de9{Igo(-4A*f@5p;b1{y)wwQQW4NBC zLGeJ~XjW92R9Yn`<35~{ES*^| z)&ZkljbytDs%AjI=atM~!>yg2on4n8j9f*UjJ$6Rbf*Hmxvp<~E0@VM#rrIt))lmW z7Z1_E>NlQ8W-{Ae8gT(fbMUC;*uV?$0g(|y%7pt;#cb-#Mc8W5E5Gcz;u1KztfcOk0(5`Z~Ij!m&Tpf+~= z#gX%JP5Kn~5NQ*XDJ(ag{K%fij{m???`e0MeYuJ;!HQ>JbLXfg}4iOPsO6-z4mQY-(La))#aO z8Z{@t%40a$xC;UeHO)@cypb98RfB4b4vv|IR@b`7B^1Y8PPU0w)O3~ES=4{GhWSCb zEO*o0^~Ae8*v(?_i|!fir%0Tjf)RR0fX2vn9cJc^iM*U_p7B`OW34jgmSbkKvgTKf z6dii$O|dZrcx;9Yd*S_G?@9M`4^-cgLhR+{-RkC#hsxSCs|JUQv|I?qb3$_B3vy+l z(9HpG{eqA!^!%W{hD_l;HTXs;)H6nY?d4!a-z9zj7mEkX=dOxjUKYM{(TCP;4AWr z5L}A_pMU*+6*|J0dj3Kv0|%rsFkhNoRA#$f+nSyQP>H1hsRSEPTl1OAteyMv;SR>V zhS#`CLD0(YrXsVD*YigUR{W%VRIf|`Et8#=I^glFjoWY7PknW4qx?-h~wB{^5`yc zD26rao=+&IYHj{xf921+e|EzQ&T;d3DYM(jLW=2fUv0l-tz!YD4@-ZoiHnQNe1AdI zn{!vcE{*sKZQSu`9A_bKkWQQFU%zbH6YwonK@qyB7dNgzdwVCbf!Z9d3t>&dn3M^y4ML6w=PKxn!a?g`(@z&f?fB{5Ou2LN9SPNz_I7PVWwix z{5$oWQ48Z@g2mk~*HE1;H`Ckp3~vq)F6I%uo6n_gGK=3<HnL(q z7a0@Xi+Z_*+A08)k>KNVm-o?u=Vl9(FNSV73W4~w9e2*<{?US#)Jh%ORo87hpy@!q zj-IM)x_a;ZhYy<(w$6%(ljp8wm>9Wa>X$mDgORT4{iWKC!7&s3nq_OT>$DQ+Qslkd zF7e<88pPnk=IK5EeYAj}U`%v$##N^(MYKU_Bm|uMIaCp@EB{$NhazAfbNo4i(mpeK z4E(}%njQZd@uOw+0^bfNMa_s5DP&b%HRv`XGOB&IdPxCzj(~e(vU>NM3smh0YTjm{ zd9P8QuS0h-izWT0A6)l)rSOg&QBPdmhw9W?FFHGPau%KYypW$@wK{R!8ugi3(eBv^ zAT!t8=%%Fk>O8l3a90^62}Pgw`TV6z&1zk!{M?)J@1LZdSFn7eT~0{~Rj+VhM{(Cv zCr4$3Cat7t!8nanS%Q^fM7!D1om@H(;_=(MFX5O6xw`DUg19p&#T_|MNru8Qnfj0E zbqPG9zSm<0PBB{ciQQ5BM*aN+ubkkS`j^LbqB!<~{?R8wG?WLMxX?&DMAiG(unb3}scwDU%Js zi#IdKEQa)R$<5pI?<`K|aMu5G2sv4PN`H2)(bJh*mhfBjSO@~iCDeWBz#~(ZS&z8~U#_at*eDUhrXX4)7yJ60p!#i7y z?1PI@Y?g~r0}~@Z6^+y$`X4HnW3Bx55t_XE7En}2RR6bjh{|q zCt4>%H}so*zf?if`f?Ky^Z|hvrxvC@(%VEm+|awmh;xjm2{3_@n9IE77pCh8MSJI(RXIE|zZ(!;I~8(D5MMbY z90&C?zhMP}Vi+Ac8nYmx-Fabd14>b<{F>PuT=!aFZ#dmiXEaQcBE03kRAJX%TVypZ zcL-jXVpj+ri(`@AmFg*&4Eo2GYfYhhhQ+UN_y%7=Iwf_LD7V(9iWutzaPn?@u-?83 zy|1A8C6d{hqtO6atKebhXJizC*23%WJ}lG;%*T{t7_&%Y$kjh7h?A@qbo>;>)%FoK=OykUtI-pQd|%vtZ3C6czt^8fI#=(;_`E zag*a1dp_>%I&~Q(KGeUE(iJhepq?`$_dqol>~|`Xg68}4ugrtB#U43@x=K(q4Lc+o z^|!sa#@=*mjJhc@!;k%X6L+gykm;g`%-q)1KQAp$$gqSPH6s?_ZcK2!;9TeU{q9x#oNTH-v)C3tZ*Tn)G1jd&6M-HmQ=F(FWnKv zd`&d5v?j4my-^t|>5>xn{q$b4pDF4Tt-CQL>1ot@{BUKFP=TwYBvqv#`@Ffm@9P-d zC@}8OCP~IrrT+61^!n4a0E|8{$08L84ywEIYg|c^VVBJ6q|Sss zr|M&xhH*v!tIa*;99{lB0CjLyEIh5jXUGf~_0*2TlmRc><}X*wZKpG>3wt4lcUaHP`Ewt&6TNq zq7_Aq&Zv5|0;grCj@$6ToTS|HJ}*Rh(>(0MEBGSW*^ms2ftTD*a7cFUgBusVo^JcB z)8xId>Br+@5vKpmwGZ3HKyRBI0m~nLDd}6e@B03G98;QGeE2$Vy-Nz=a-Vld@c-I- zoppcQPyDcR)xVzOA1`pWorrsxizYst`qB2s_fTkr$8SG+YUFQwMUlG-P8Shl3{`Bn zft391seU7sU4zh%in-^^F#}9=q|i_s2&y3S`pupe+`vzOPtf4$d+)<;YI78g9?+hOXa2 z;8`X^w}#pjtm85)rjiOTOefwR9Kv3hj*`69sJvw_d=bUsk4jgjZH>`%%uKlYq&HsE z5&h|-*7%}d)I#r$f@UtTEZ!u^(hE}@o_2ns7<;EWwweQdINCnd0;o%nOqAL08owX+ zbK9UZ)_ML`824E5{pyZha|4Oy95~)pm~m61bjaL;lv0LkhB?deeY;kY)|m7_PIq3t zyL4zo$RZWlIp)M=PIlV-`;m~3GV>=j#Au)Vt(cT>njrTI{-vN6amo6YVaS*h zs(L(#7$ai%K5WYj{e9ff_M1v{DNH}Vv~o=03+^X*HAnOj=e$%3Jd=@qt5{s=XXx1x zQ8qLK-TZu#5*+o(3?vN%Z36ch;|?wzpE815i%%_wZ_G)OeiTV`%oS}P=Ax=cjIv18 z(kq`J=__tz?*Cd$dT$Z@rk@)2?5!utPt$B~?74sI-{J)=Rn*`69QTyxn z@0)E93BtX1Q-Xqs^sBeL$t|Jn8)I9&ZN2mpn=i>6O{}XFS0m?;BCtU zgiv+dP{vz~`StQL9HTOYhAf}4YNyHWr9w-8iPx`{;ig5fsa~2JEFQw7cmKWZi+nbn z%TFR#U)+RJ|Kx=7inN5TB>CyQ{TTTrPRG=N0JbYj)`j#oxbdfBZ{((R<+Gz1#4WK0 zm*lBoZt0Q()Ni8~-0$KSh;0;i{vM}CRIx2*=$qyB(k$G6(RlfnO)#z;a~k$B z9e>g-loV_c(qtJ=4BfuobS)j#dH#aEQ7hVw8|PxIn;L`KN?h1E6YG$4<$?dZ@GdiU zz{0BI0~F=}Ke^svX@9@&!DRPQk4qDa3EFXCs8lU5;82g8-2vtth8F!|n>4_pD)T7h zY##pLBzfBl1)Ld0K5LC_uQ-a><^pR0n6L@w<$o)T`EMt~P`ViFRB!#9oE&Cx_fKvT zzS~P(U@$m0DCoo{$uncH#1RQ7=K&k0Aqe_<4z|_sES{t28vlKKJ(3cOW2RIk!I?jNZDz#hJ4!<~bJ zV@@8Vs5?_?>ZCqLyPcZ}w@xnOR|f3^bpirv013=zAStC<^V%9;JGz@?>@(-=0|=Ut z!d}i@Uot^SM1)z=>#do&dFxS1TwGR;)^ZofJ2sXBtN(_s4_*&d*+$(`tI-Ak8@{6< zFx4gm<|2)N3@fvgj{~-39l)jR``Vad4r}~&1*(rmD=T(q#%#tvKg5=dg>au-K385| zu3u%7W@cvQ-qpd!#a5==os*S}IZ{1(0Dzx(K>FBQ?MvrofY!%$1B5^Kft0kgF)`Wm zWh|e;SI03&(zPms$*Cz0MXqM9 z^NY^#-O!#sn$s?DPM8sNmfQ5imV##IdD9uoKnRyjkdoenm|}Q-G=zQQ2aR%p3=G1B z>o-BR(a0h)7@-eZy*k*-Yjh{{VQ<4MLb~;C$l&V4*)4v8+%xOIO_B7OM7w=lU2)63@S{{$yykCg(=a;2#7;95oW;c9>k`9OdqBY z%Yflf9FQ|L`pSS|c=#d~UQ@nD@qtNbcGevI`5rRtp4*8#AS!x8=oD){m$DAB;(>2& zU6;X^gBoz`#Q9KeEi~rCsn)4iV7lq>^A(PHX*0w3<_V#aY+0U zY7osbBqYdA>APj?S9wL2I1He+Sj1=hhHk|jx$c1d$t5Bp5AgkcKzAmOmapn(IU0y( zmH1U@&8)D8cYc2O$i04(U;}u-^=tg%0ZvupcHXr5Lx(T*U}y=V$RYvHEv#Bt9`baE znDqwB%%#X26MMPKgS;<GWUbqiORqgchKH{yY8GYW#sw)Wsc`!ns$z&l&Pu{metiWA9Hot_KRH46 z*~FRy7@`;HxvXRfxRjsrGxmB8mE?fV;TIyHUyOj{*b^}49kaMhSC-Tddq(-kGgXFB@!xuOf1^4Tn5nZ;wM7bCcGt{P=R{}#zaw5RaG@+T1+hS{<6Ybwd~ar5vSqL z5?@tf$Ce3fhtIPHOP9y}<;iLP=h$CFqB6p4YBHB6LSkpT>U9J%2Y}AVz+-iASjc!Y zXNiFy^t!}OAj_cG9loeN)?@6U<~IO91&MHyJHbc`vMV$lE`i4ylqz^!1TXr4U5Cwf z9nWx4OZ+L%9gH|nL3Y^&aqXLFdq}kJ_Ci;(rwYu;3FB1lSSappdZ9?1u}Z>ydGrxD zLZF_i?c@}G;R5#^lYEfrDr$Dr)8%d5)5+7%^j#`1a&Po+Nj{(18=|E{tcL#jKL4EZ zaHaHeS$8Lzh()NPgM1a=3tvbFnW!wgut8yzAKKj>H6Bp+*9Ld0Mq1|o~x^S*xmpqV8B?Zi{AeKyy zWBRt={EdUgFz{=JO(MA2+w5X|s2FdQ{VO<5!2{GT&7A$EqZSwx&S|$NaM*+TV@q3` zI_R%vuC;}pQPkA@tg`io48ZwXs<40WC!KohXyV-Ftj7NFKN)YBnowrDr+8UzU+JmW zq#Earl#v!34%QlrZgCdGfMe(}yEPP$2T+dlgxcL?P_%k_z(Ogwj9=|>>*!gVZruQL z@b;i257a_RYlaS!t=J4l7l++C;>Ju?eLr$2*L3&s8uXTqMNS{zXivO1H|o2j`S9V( z#_+3o+9rW$@XsjCSVbjNRdVjvp7%5I(N+%*kl!Kz0TkiDQNysSA~iAtzrEKXit<}| zhp1h!YlWxjqJWrCj>*xUC$o^vbH^p8sJiiLW*}CB2D&Wz9rw3GYksfM`tMF(K|oSF zve=G(@jQ{7=~sf!;F8nz1g&Qg%6E9#s+I?xlnK#*q>KpEyUqHZ-WZ`)6|#P|SS5r`s?L()P!0%kisPnB|` zQ|GRAwwL~vdmVCSwQT#z)z{m038JfvEW+cQpoMHbSm~LEh>8;S`biI;)7K86rZ zK(l-8h7c_I)53R2cpA`&#ECaUqRU$^>ja13irE}oj1A;2s(4!Yg8RuQehq+aRo@$}=H}tn z1a`1BE^+L$|h zX9o4Sl=#8>uDb{#c?KoGtfIRKB9tnzW9F4G-Os-cZtKH1;~>E(b#eBNrpOx^H=+GM z&qx)Pl7u<4`*8~bLwOBwV=u>jSY_M-{S67zpXV`_C#VL9U)bI6yrNgo`D8ANDKT*f z=4M{x=;+#6Z?CIZu@s})@}T<_%vbuo6!kzHWM`=B@`U{h8{V{Ig|8GixSDN3U^}oc z;1=?e;8HHZ={}D8#zWN>rT$Qrr-iSHsFFzd#=juP@)&A-_6Gc-4~5vA{;!OR-ch;XM#aDK z)IZK1B(|Gw9TIN)VORc^{wQR{tVT81VHH>i73D;_=t09MVwQu;)KA{V{}Gd-0FrR& zX|rlH9dpNAzfl9@=}DN+b0hx`BpPEZB^)i}1e{V~PepsNcaulEtT%hK=&!e*vEhM` zoHE#mDEqg;n9yXi47LNHB80@Px1+9%$KC6mbqgaF<7lst{Nd=2=dFw5 zWYbwHG_g^jhR=Plt7uD%JUp+0=BqgXTiud_T3ScP*2o% z(`r_dXqj%R6sm(4b~SpTB=y>|KNSl!XVh-Lj})DuTeL`cGE`FGM6eE`Y~rTGW*T>c z`Mm#~@_(Utw*K$5{%^gMLJ;KoUiW3oalT0N{8s{oH<)3clNpqVG~bJKUrNEUL02O2 zh770>9n*g})mA8@YdC~8wyzU?6KP0|>co6xFK(rgDtz_K@Fg7P9ofV$L6jCVMm8|i zFoZKWaSl9t5ExLEKCE6il*iBrGDtO0eoEhTLhy@PW0*p0!4O7hCrvqIQF^pi%bkTPKX^mYrMO7O?^KmraT;FgrJNBPjT&o#TkYOu_ycLEIPGC2Enu zREelU7x&+cutaPJ=|lAl*HX$BJvTD?hU~BppX!Fz4OUnQnKrOp2bEEYMNvN^sP}Ngye}wjF6w*ND~*&4md2Fv4nS||z8l8a zzbd~e!@}WY;GAe5d(7XN_CX;b!1lp&;^6ee*AvbqUov88L|;M zD=;>0vBB)7A70I>Va{)V>`?0L3-2o;55x!Kv0p+~lf)X|pF)6&(r4+v7=S-rrDE@| zqgQ#C{=1(3XFs0B-43i)`5?GCs{8L#D?CXPQ~14K2_?jT3To3p^X)x6s7v>oTb~Du zn3+|7G6RknalMT1LZ5`Wg}vDELe%xE_LZ2AcS+vp#R}c+c)cgh@W2Fo?1h`ui)+l_ zNNa)5*43)bzWeZCZN0??kiafb+=TKs(<~wu)FDU=l)f466m(H&57N9;iT=m~?NkOe zaFmBlGMH?Ey-h)eReaZ~cQG18Nh3dt`bp{d{uFstiFz(-ZJNxqV;M9cwnY#>XZ+fh zWBFSuPP)&Y|4aIT{yqs*HrE33is9(k1^$P5Y3~ptO*0@8z#I~2Qi=v`AZaDo9OET# z`SgbWu7m$`Cflm&zyE*yaQjg-$v^@*Oe44{c5h)lIAXF`Q`3m67v%C-e0;t`w1MIV z=7$cnd?5Ggb5@fgQ63!`yPpcW*zY<<%}XBKexO*ohSp|n&OI40MPUFvRyO!LS;-*- zA^}rgN%-ZMEQr{a-Bo}+${)R_L-{-{hGtozb}NB%S>@PvnHq-ST2+aLj(%y(PZmW3 z0Uas+`HGUO_6t$?Be`xlbZMi~RP4e%uxG&~csX9l)|SxiWkGW17v(X+?Hv4h#*ulT4fmRLXwAAH5@lz~!me}Q7TY!W$pL-`=Kuiw?-RC^TE&A{xO%do{UF!3069f6cYEb1Rqhwa1L%YJw-&?X;yE?17n zT`*e|qp+{+lWq{-@2@!hyYM?dZRmD!9Rm+hEFX8Chj>?^jX~WiST^BUVK~s$!tf3;8kvu)o0KekOq zd;RzE>UV|WZ-7xmttosr3RU3~l*G}5L(x|c-=Wo6B|fRGU7bEQMIqn)%wU)IhWz(L zZHM3{y$RLKX}SL7f_e;p!UcJ6QH+NbsM1iVqS9|;0j}x+#F{>(NnKpWG?|dkK^Ow{ z&ztOZ`E{I8RUx?Y`O8cb>X>{vWSD-F$n0#fXs4z*x^4L;P0-mf;~&~Cx83zV!zbi0AM%Cx~BA!KEVSW zWSY7f9X_ru&t0(n)XP2)T?ljvNx51jAdC{KEFSiH5E(wj?!I10_$ zSi=lJy9jMz@TVnRE;f7jaXAK2Wi-(zr&}7Ie@$`H<7N8l73S$+xwSIz-WK_Bx;N@$ z0vxM}=QBBdhcWn)%%3o(0^O!DKQ(q6<;V=U0jQic`|u+CueBYvxvW%gd9H@5mS6_; z9HKWpF#%b1=G;}-$(O%oY1;+dimdFa2tT}Z$_X{9uBepr-#m;K>9gtnX>g|P<_aFu zk?45c`0l?toPYldv^s%HBR`Wb6ty;>N$kr`+&r;;RT%BKhwc?qqR9BE!Cw8-FOc)hR{+*E(AGq%xMI6jI!NL*F#0Gw&hVHT%;19v;E+sv59|Dd z4=^G|6AVO*{A2OAP#&MIJj_o5@jgB($o1;CfHsJ{WlqUJ^RPQsfZrj$QgYnQ`Wf%t@n;V-l7V^tg0lFnzFX-#qA~!^h$k&oi%Jc6VD2f_|!^s+>I(gFU`GA znn7Yu2HAhc4Zgu^JfsJ}9#)K>%mdM`1R});Z%3hX0WaA*yU+2T8GDhu*hXW>Lt~N$ zHcu$@8vcyjM&E5QlFu1(#1kADge#{!XHQ!+`TvNIZT}xZ^NWZaPsV>Wb3s$wWIo<@ z9h2u9x?yTx8JY3j!16BUl5a%w9)|BRX1n0;YoSPgiwO`bFw`=Dx!+oqV zaY{+B1mTQ!HvlduX3rt>vBA4?#Pe3d}LF7WOE5UxVLi{DNL*U{x z$hb58lt(XqGJ@Xpda~!iVgh9uq9(y!M(*8F^oG%tY0L~_2(sP;m;AhEup?7vf*qd~ z$Y)=qW3V!BNL4F?)_TM;i#*Y1F?!I83gIQc3RGNCE0e2k(GV)B5)P!AYYb@HVGi4> zFwFiiBaX&Oj4id*1X^pTG~l?cd-=tdHiB+#Cj$>DXqT z;o-p%Cqh%&XgG^nAQJR#&e3}N?0BP(x<6^k3xJn-b{|%bH6k49H(2@d4@M#}3}>ck zrVA)t+b9I&89x!!D->kBQQM6)qlk`!w$3uo%V7-R^LBKY zfYaG@|JaXzJ(2)nx_>7Ue=4~zcc0#W32$2xG5#;V{mI+;OH}}ph|)3RcpH*u6{F}; z;TWnhqtrmIl@?a)!FprN?Sh>^{L&C^1A{&*|G^_DLW&2GjE^(Q-2l2Ng{Z(R>N^S{ zWW7Hyco_ataOUGK(M%1yWRl*7HA05Tb>j>jo9zKeh-z5LIvheZ>@)gCH~Bi^(sS@4 z@p}%CmMcvABs=9TZpH}`70apnHhzNwLrR@BZyWTvwqO!&3wZ?lB&fy6Jo`;sI^&`E z$_^S6D{Q91Ua|s=ZDnv-w(x@TBb2l$8esDdUgKeFNl3b0wZWG*6>N!*qie zrv4Es`?F=?ZYe3WpSFW0(3NG3amxS0UCJcX^V^CvJ}7&sEQ``2g#cFTkZz`z#^Ioh z@}oJIG>E|mpi7p;ooND=xDe9z-j*NcR@q=UmGDW4QR_w|FVGIxS7*_TS0`mK-C?v%r!UQ(FcC)7Z)sLz- z9~s16oo}ajWFBYO)L}1b2RV36exd!VieqNjD}oevUI9mkz9b4#&aFu-S|O69KEc$A z;WFrL76%>$RIjalNDy(x066BQix<;hzCKBs{1BK1Xa_|4OUN6BB19To`Vmy+nxmZY zGfxsBitpYj0$MM8oQWR>YY(%ZXJbvI( z=4!LkI)@ly$`SJ98BwM9`1rjc+CayTj^up@w7&fStg_<+-~g~a{Oz3}Z2$G1LqC0& zJ*wSNSh%f9B1qwF%T?Zq7@l+{}2G*wcJ~4<%pP|d- zTjpRSuYnzT@(v z-JteIfo8ynZTCcL)vYe&QLSzEXSW(9<`d>759nEvlGgCx{D1;!ycKX2EYmjJqPWdJt5@SyI*M=6|pZomqtn$hvTVrj!ZH9rf9Emo7z5mfPv9D8rLtFQ7`u2_jr$a_ zCK_#L1BMJl257DvEP2*;?QM?Pj8>I1i#YjJJ0ZEuXGWfZHZvjvG>)}n;|{8-7hE>6 zyyW!?xojf!TgM0xgKBeL>fSkhvGo*?kCYVFCZ_nNKx_fu+-42>Yv{MiN6$3UAY8ZF zCiA|T=5M%AQEgWId4X)GJpmO7Im;xOp*a8~R)4MU7CS8__>94{8plU&+`9)uJpE|0 z`9d7P4G@>ET+zuJB7+5<+vG&}jw0=w!dVa*s>u>M+{#LJUuW92;Nx{K?GEh9?v>)B zT{7Ea>&g?GTCHPxgg^V8<-#}VH zwofE%TlkKltZ~~MvuLLirL^K(T(90-erT|&kKat`!+TV7y9`IzmV_vbx}`hG?o!W$ zy@fSY%t=6&4?>W}y_;<3lXBr$qoQ7Xr)0?$;{N2SWFB&{FXlp1RxLs|VhD}wU_EbS z&rGnUD@xhU5)vD`5|L$R?-*;i)B7iU~w(a33bQBzqSKb^|g{R270##5~H#bPk zISjHJrH2p@*djNRo12?AOa4Ax0%ioFIObQR3a}6{eR77rD?}Ef3J)~FF{Y1K!>>BT zTBthzoURRB_US>|nux6z^Iy>8`{&xX=tVy%%(7|{T8d)sr)KhS4zS(Y=_0P{cp3UT zf|Xxc>P&ld3cK9-P@=?{0NCu)p4GpJi}T+e@zgJI$N?=Dz)EG3H)J;3#Z4yl#9pE5$VdGM95ZwR5=Kt=OJ$ z2S9#hw?}j;SSRi_T|)*1{h)z^Mm5%XtY&S$pMBu3X~??gIH-W|Sm-y-L4E%GU~X;> z^nSFIl%~IV8U5L%)y&}%hbR0u@n*b+JDIHhztU(djVj?iV9@?)4i5CktlJaB9>p2D z=BSEo7QZc_BJbeM9P5sHtlxkDuR+OEc^0^Pa3Rn^hF+q{0lL>QPE;5Yxaqbk9WdwC znHRV&VdOKw2l!*1u}&j$fP=DgfcX0ZS7MazD*WT zX$yw!tjX`$kH;FGYoR<(|&SMQ4nwnn# z2YmiCFpw`F9Ps3K^@Ed!EGrXr@CMDu^&K6e)T_$m*wZIpGc1vSl!GScC7S)6e%%OK zKDI9{;V%3(JRV2KjR*M`Yc?1!F))CJAoSK(9}O|Qlv8kUFwOSeAH;S1?19wN=uHB~ zUjO04hy8`~H9Fe721C8k*l%oG&Dv6pYxUc$@Da!Nsd`lm~oXzsS1uGLPe)` zwx-3gv8joKudUTU=0WxSD_zWOhYsx``!IUxlapo#YilNRKuaojZPilHU?L+ktS?Mt zMALEruyt?FB<9(V3}S(UogXg$K&CGWOXV-PXROo<<>BcinB?_>_qGAvAQ|HYnN#bK z%mUvS=aP=@><4%EY$pr>k50Q8RfM~9v>nQnI-7Hwjc$JjiK&5sZt>IvgAgkqup`@( znU2&fVWf`z_L33#ul46dHHNYxwbUexz-*6pUpr3vGr?rPlDx`oZD)XKu>ng}G5(zv zX=v4E&+@t8h9m3Q$>!T^1OVV_Ia*xbjZRJ`AFAHT$Fy)D_-8+Pw+W_4Sl-szy}_^E z&Xo3*ho1WB?i2Si=d4t(-x}@767rgJfc88tD;WG1Xz9BXMz(W-i6FTLUS+p0$a{MS#u4W2PcOV5m=>W!fOo4DNZK-vLN+Ptpfw2 zIU=$d0AJ|mniLQD0tR?>p*ooCttlcd9)15{E@v%p-%lFMv)I(X*&NJ&R$ZfCrBJ(n z;P`AmA$QPUD<0m_-j07FVziv&R7QGMrne2Yxgp)~ee7=?Y3Wq8v4BbqHObXa9t*>1 zZXHr%Jpn?uXlsAV&`Em*hRy$IJXv4TRA_PxAn`0>riH7QSe3wZa2jC1Ec!iWdGH;; z5;njD^85!r>7HcI5ra8aVp7tz5f9Qb77*GfW;Ov`S1s~MfWmkP{#wgAuCA^>;4d2A zcAaCEP3&`YpU=s%?_Zgi?=6T*;J9tSzqJgGD4*TLcfQTITFJZ#b~$b?t{lw~;6BJm zpps)-6|4Jr1|9AF#6$8saUQThMF{Oa zoTl4c8p-OGGPVRHIVR*l6c4mczO$Czms+m^A)-cHWj|*_(`_3dpT#U{^AP|vQ1*G{ z-MrM;`YfOjD?D~nVPpakG-%>l~M42h*G3G(8^@*3EIePY*H z_wfC@cU`?X+X)d70A}!0!&d2P%-1C;pIpFF3Xmavp-gNfypC}n*#ANRW_ z9)#W6zBnlWmL-Ixue!=H@Ngi@2aH7_wLR-zq`U9`;==nl0F2P##)cNy=i<}7J?=QM z``Qi;No4d2G1XV@=+joLT$qZ)uRv{vi)V6=UK|71j<+YzGH0A(D>DHt_j@GC&5a`M zLw|sd*~3rAhdIJ$Qxh;jYOAY%?vUPp z8hFsUu3sBa4M>8=!~w4vcQ08KrWhL=nXt{gwe{PiwvRDHY{0_|ouWk+HR_fF2L#?d`2!X%*)CC|mI8 zVEjHJ13=ysfSlUX>-6dXrsm!*Od#Jf8Gs1J0=17XTTTg>H{M3{S_Gu%C#p(&BY?P( z0USsl<$&2xe6CjC8@~No6JQ=sann<0g9WHq{b~@6Kzsr2+8!VZ&J)Bg83ooq0Yho_ zLat8}F60&j&3!7Ea$j$+?E^~(LX>KNAJEj)bZ=z3PlkF#LV%Yn#&}k0ypM<=Jfgdw zOTI@yf`%;OyL*}EQyvPXvN<=TLyi~_hy*UiGxKFr;e-q=RdTSqL3dr0E=C`R{KO_TI0T~m1_lhBB zj%zIt)5-w(i2}lXDog~RT)W}5l^&$8iO##|-vPB&xZkqC(4WU2V}_nwe#;HwXGvQy zztxeeH({J#9&Q9e3i4TgaQ(B(RFe)T?a9~7f*vSH{I*T{7w0~74@mrav(!xBv!-Jr zPlm#W4-fPP%UoVxxOfrN?GrzK{2a;N15pGFHVhgpWe2nJ)eyxSO?(_S+oRgV{+P3f zTdLW=NytJI3-VwVY@4Jm0^Ai43kzdgX07U}fpU|s1nkh}g2}F|q$G#U*)FXR__A>t z3haydq0&?!b5RWZ)ZeQn6}rfhSU5I%L|nRIwdUR-~dpe zB2|ufDhd7u7eBp3@us%z=puak4#K&j$eR(|Ef8UR4ES&fWQdPPi-=N8d$^~>LO!>( zfbYhF-h_)Wsm`(fP4@$FWJJyG*Q>>F(q;0FCV70ir6MWU#1<$MRmLZJ;p#mU;mFA2 zU3X89@*@-9?XEfNB)#bafFz z(eablGW*a&LH@&mhwC-QzKhyqV6J6rEcs{${EjNhJ)r&aNZY%%v(l_~rPgDxsKo~$ zE_sfqdb{N5HVjYMpvt&!=2q=52ig*F$>K{p7eT6pZE3Qwu;64jPX&0kbJs*a^VRMc zmX7R6_^&lLZB`bAb#5(=<$!=WOvr-1OxS}RFkH|rlU8wkwAW6!B0Zxb+&*>{57*&GmFPq*>}thb9x9SsX6h;JHOV;*Y7#l&Q8 zY-}6_*WA(1zOPdAr_wP9O6QDTDFi%$>LBg~ zlkLTx%f|j2UG5`(J)3(oiSW&WL=7%MK`rN+)i)O|TySsU%7Sr1_YKcul4JevaM^bl zlPJO%w8Y*rf4F?77n)ab6xN2eO>SOCDD(3^_yDQbifpw9^`$I$JRzOY>T6+w14u#4$8Fp zudiz~tcYxDG>d&lNj(!>6n_Cg2Rk+BI6@>A4R2>rjyzS|7G8biH~O=TgBXL|@29Qy zpJbfdq|h|AJk9zVB?`nj{5U2X0&73w`|bdAFI+2$IkB%Z$S4F=A!0&6nXF*ha=-$74>l#_@|OH< zoTD|{nHjG}YT2e;LVjCETJVZ#P4G;|eS^WRzuuMLaHk6@Dn1aq7^ILxA5ry}v@(1E zE3X;&N=4t!rfbolKRZ$y=j7m^_xjD7LST^?lVk3_fJh+Ir|1WI-!^O&;_cb>MTFoj zay|dSBM=09KfOKS!O>7ZeC1KAkv!_Ad-0>yl}cL={_Z$i?WpZq(H=L`x46jB;)S$r zae<4FI~Yu1KRuOY6&X;_(P4oLwGJ`TzEa836whw%{3lObxC~(DDM%Sk5MwqnM&fET z2gozSaN-U9Vt4xV{W@z-zYA}^0Dxn>=C+!#mQ<^FVJ@FuHdrqZbTsB1EE&OET)8^i zUjXT~h{R)0amh#T^OV&Lt>@y}TQ3M-kkVnV7>Sv1 zzkiQ<((Y8Z=TWy39zTAPwSF+T4o<7r zEtB{~g=vYhy7_Ts9l&7sUK(wFzY-F-_)&rE1o4|Rjt>sAC4f;c`|;uOT^hssZmB6S z>Q3x>Nt+?ft}tU<0eHcD><^$DdDo~yu1bNY`9hImPyn>PJczV%&EL1C4T3(5029Gb zK0ZGAyP{&aPLrP-DE0(GIt&XtX6`kTTsM|XJ7PONC@8{RmY0W#E)7IV=;GNLKEiZ9 z5Z%(B>j#cmLoJgJd+OGG^v!^psa$!`m_4ermWHl(89D`tb@^^uanwKA;c}bUbSDN8#$PTty$6R>I)0d=8G z;Fgs~&VW$7!S+Z&Iw7Dz9ND+`#AJZZ-o1O}Vb<2xROTbiw7to@AcO?ORSx*qPll=m zLdssu8YHr+?q3O90K#~4o$QS-_$NAn2Vz%^C=-+1&m=QvlMkE%hsO3(=hL!a_i0Oy z4y;jub*k8uUuSGEV3&gkpiVGs1HYM5b{OfcW0?=)FtbZ*L?vMb3I|>4zrVEGOrcuF z@U8G__Fm9UA_%S0!soN+$#&`CMJ~lBPmFqc0)f7W&V6!eC4&|nRa<)me_3YNkO(Hg zt`NT6)C`@rJvbtH&k}!bn54?mlasT43)Qhb&2m2-v!a^XUF#wdlZ(Ny^DUz0kjz5yuz@>t1o!5==`zCWs@uv- z(j$a+9_qBjUtKxe%Z>>rc~Ul4?gDbLHEza$j_`r|YaQZe>qM8dU6;J56s51e6pxPL zCb~Vf$aAHjVHpVHe8F97MH`?* zfrK+rGbN2-ygcKW>Ak^cV@3KjoWj6DME$vux*^B1o!}=z=g3`JH&kN0%6uf z7KLrshAHXz-kiYOdhbiw^^n@;#F)J!%GF$&dZOKtv6K4#gQt;pY)m_~QU`iee`8b?T`J|*la z065}&X*?hP!#a`lgn!*)E)an9;o%41cU_2hHo#FOU7R22k%w4rDop0oXde=ZoY|j$ zcSFA^N!et++Pih>H^c%J2ZZ)SH)43j5fh6>^d{6!T$SKFN? zh;ssV{RI3n5DH`|8!AZJ68^m8_Qq4I#ws1(jvm;iNgq& zR`*1M#dJZgZ5@tZyHM3?#E)9t19JbLUxH3zI~GdrB(U0X^g3mqN6ml6dkwAoWsH zAxyQDpgGE&*gbZJ=CD-9Z(`u65?)rMwIx*bv9b6v1Bz1sf}9MAuJ`+sb<1PC6uq!S zq;pz5pt@=m5%A2a3>T2=@tSo^aL2-*tXAISP*4j&4tk4Ju6ld^37=82PR)3|Z_*{i zzvqO)9+M8>U{(J0_l3XzcnILEYcOwmS^?fy8rZd?*9d&n3%1BT9?{D2@%GC}>OkZp zr5`mZwFq4CotNH)g^CHV_tFe1UxX|?qDeSlh;GlIKZAan%j?%UKLybugwX1eM`qVFMv2MR#OF#Alia-m7>G2@>DIfMH$6QoL2O;wP;{9TrU{ za9Z|E4<9aFLrM>u)fuH!e#wJXL`O@Q!eB2iFXtr*^e%#yM{)ViJhpRvob34ec1Jr* zrg_Z9#3bNoAcz!3M$YZh4^@Yr$4=}NE6=~X@md7zBNi#t2}QV|k4Ins^%^#A@b;Wf zqkG03u6o5aB27JocjgN@63P;!60CHGldg0>XBd7bLS_NYWJjIp4$K7L=cXf znB+n7@%fnX(ohTRiRy) z17KiJn%}%rW5*7&-~m!esA$r$U>X(;u_`(E5>QdXIbhS>f;ef8g2}wK6(OwMq#3r2 zRHBUP6G8dfHXKlz#r0#1&D#D|z8u@SIk9hic6qDeaTAQFcAoaoe}Lf}Jg}??y|m-7 zl&cKIMaxA!Jv|b)Q-a{p@0xX9A4|y6a@m3`EX7#L)EB>71{!-8HZ9g|W9<=s-r6y% zcw3VZYkbg$*HnW1o{CmscpPwc;8>?q2|n4D%naydryv>H@A2rTh}$H5XE8d!Q{kVt zty>M|R7|$E0XH9Ar53nr!(5prlUsu9$TT!Gx(3;hHlWxF`t(q$wXPraA&sFAsm`n9 z5a=^W+p&fan2WZ85kP4pb>G887=uBD2-H2JqKaUk9id#vf=07*2$yWr@~55~(08cc z{9-)KeJF+kFO@g0DnF)-xyFR8&vbX$JdT=}S@TIXiK?8j>)rUmWbMMfc0|TO?cw6# z;Zf-@VwU+}{nlfK)P%|L4F3jF& zMR>F`$#P2)kkeG4_MwFf&VBiiGFzo@TU+-rm4>4;!<`G>Ev$#{(>veVuGe;iuGh9w zx_T?=5m+-%tlYL3ektt+@E=HCwd#-EXiPc&iDyBzN5k>_i0Jjbr4cm_0G4C*$frmA zw!Yn`q_g(9cSQBy3%%dY9!5t<;>X0fxa7iU0|K2uzS!^o@eu&GM7kR~sw%3goTkV} zEmxoWu&SEop>Rp0yCOQaSAO%E0oKyCSe&%}#?i^fJN)tQPXg|2mYeA4v>m=)0xw$a z*VD|}6&&bRQ$s=ix(f@m8U(o#3(BUV4_S>)V)Gk2N5@C0CL32>e{&0^#H(8$&#lud zcp4QIKE8V}e1wGPiugwlOYQh83x3j1Ps@EPwv?9Ucw8Ftb`kNF^=j~ICE%NPE?xj_ zPz~tX9p4&o3&iMGa!jYz>a3W*FOA=96}%`v-pw0zBzv`m7Nn`cK-op;_1JG zpHSz$vYck1{tEYU1$4|IJSeRPBg0a@-;fa0H$%1$53ePVrF_@QDcJ^NQXzb7_E)(=>e@;6={Xm8f%~Vm!5p zLwDPQC2e~J+tB<*&M!dX*SqrR7gV9Z6;vm6yi4dTH9I~tP=hP?ZgcXsu%MElgxwY< z@bEe}&APiMJ^SH~Q7GV>9F;1rYllX85RcC6n%na@ z9~fXwPp)x~0o3>$JP0OsZ0y4CS=1r|*;lQrzAz@wL-r&v_7(YNVQ9~y2c0Hka9AdL=$ zE)n`;&=0KG7+kAV5ugwH3nV#a&5xO9qNF6u(3+o z_n}Eet71NkmuMpDcYpt~X6L}=5u4D7OhxcLjJLE}wHvCzCasdRl%lHh~F;_`VKd`AV8q^_BRKylF()kB?V`;trWHNgciGNY++Vp_C%c4#mrJKGzG z*Y(I$$SN^BCjv&o?%#KQ-oVh(hU@~&M2TnjGml=#24_8s)UT+*nCv$jC?8C?vgrDy z6+Kj-yQGU!d`mdXsw>tAcR{ZVf~FN@aKwTEx2^^CO~+Lzg0-=Rv(+O-b#hRMt#!v% zzxIZjm1qj}13scl1%1@BFM^3TryBsBO4BS}RCBtrv|5hRPC#FivkGH4@$BncuQU?3_I8i^7lN=A_&AfPsq z5y_H8$x(8KslD;M&-H!p_g*veYktggJszNY_ugyOs&Lm`RULR;O_A*Qx#L7cL}XYc zIZYy>LzF~B2V9RGfmdprXt?2rgtPn&XD$2N&aUQ;7DTG%&JH&A&NfyzneJOSI$7D< z3GrRHz;}U%>5j9rgOdb5zwLir!DsJi$?w>Ea2@VK?4YFYL_|dW3i2EULOmM?$~lM{+KG{;Be5NiQKM# zXzQ*@Ug9khSOyUhliKa{gXnKWrM|cW=x<8L>JOp6gr2|?qrWgQV?Yq_Kbfma?C39# zd_q;wUx)dVFzJn_8` zqg{P2ot@o2x$kp61q54A`(0k1P`qe4_wjq#;^J}Dob2|v(xv5DdoN>?d{^xSR0l(^ zVJLsyoTy&7<-WJ$DRF-};PPtV5Y0juU-?7dv8MPp2?=&mdow~3_h&M)va+0Ojn^{L z({)7$9A71PuTGBmk|UCn!H1~?5bRCeuN2!V<1aC^WCXi>jnKp5y>>?O3te06u$qR3 z*jSE|5PB^l8n?$k5i&DU#^zlMVE_(%fw6 z^5>IRsS%&*tIJZHYe&(CafPZVr7ZmBP{OOli7_~BE&Q&1vh{*Cu{fHDsP3@Buvkn{ zBd$zYkRJTY2?AYPR>p@L_>RF=1}6_iMa3UpgbS)#XCfl%iTMtz2t{W%j8XH8#D&ig z#Ou}KqGoQs>}>RGwzLqFihY|Q@0q_{Ix_vu`NoO-2%GBtE5fs@gWq3KxA| zv3wQVb{3pUkDWsR;d&!@q8%mnRE=A*PbDNJb&RFdD5u$dZ5vx!x|?F&Tj)oUGf0Fc z9s7rI3*lCp4bZ4S1e*{#E*6VlSGl>-Y|39$;1si9DV$PU$dRCX8Hpms6y85&@fgCfJZ?U|*1a8XZ>rw$?7c11si_%K-XX8? zfmmtpBomL(lHNiq**iOZ*+U(1;!78k(iOb7IlS`*2N_BS7-G^h^YZvA*1s%Gx?LwC z8VSfqASMO3&h%S}z54T{LxxzgRkBsA`Lqh_$2!9A)r=1xZsdLZW5uwwwY3s&FP&#- zS0TGZ#iQ-z^%#y|b#@?y%6loUx7R>xO$LDn>ZxS z&CR_XrAqMD<=A`tK8)DG`+bt5s?uo={bP|M4`TSJ{zR)4CjroM!4Sl=*BQJ!brjv_5)us_<;YvWt382#-`ixRPM38Y`TB#Fh$xi= z2_>OLq?R+xWbB>D!JXcJ#cwJ^W(eLBe7^s&niK6ZcnB#>@AvO%L4Kj>F?$ev;OyTI zWT^;bA{V6WUm)zvYFN$S27Bm9)l zei!|R=us0IwF}xD2z1e{|M?p)J|l1x-Nf*4&~OqkD`zzMKKKXP)iZTv0T;jiXOz{(6 z_T8cF4Kas^h&zNz$0gZcoOF5L9P}UWf4G&5`Y89l=tY=NZBpytAwyL(`@a?w^AWoPhu52A?`}a&)&R(cRv^U@WL& zd8d_p9V2;S+gsb>0J2@d{iSk+5kFbVK8d(Enfv=UxrST%y0nG)QCS(_iFy{weI<5G zYB+=%BmMs0r-Z`^8^nhiIr@&r^>q*9zfI>Op=4j|Twy{N<;ZOVtiRM<2M^g6tnKxL zi;GLgz#wZb!A@A@V$ix+x>Z(AjtX0v#njxC=H0u`x4pbiu^uL35{;pv9y?)hpDMn@ zyYj$}u~i@$q#S@*+CSX;?XvfjB0JAc^Nz8y^7{m@DJ;Fj1E!=~xgURV89U9oz%$5m zm)t81_T~&K7B;gNHy&c2(-J*0q7-lXytq<-%y2H^_x29DuUUAC|F2)CJh#KEvdhY_ zQjwUDaB^`ca%abZIZAtV}}KqCp$h zTjP@REl1Fh#yI%t@knS=;&zpy)dyn zsby_zOV)Sx*r7uEc@u0~N9GEFf&0X1=we=~ZSdaTU_ONz8#)X@;%{_{-b zLbKVhvPkWNcaT^xe#74X^${1Doxx*M`e`=Qb5Q)AyivvJNZkfPX~QuS?jC<9e7qQc z4~O12ETkmqvec&tbbc4sm2d0oHqGiXeHb*aS<_aFzMi5ey{)067or7#nVj)*YE8|N zGpA2aeD-H-oe_5mrxYV1D&=y_stqtFD;}aPZt4gHSu;iu6aK8MDdQIx7jN3NI34X? zqnL4JR(qqx=rwZ-(uU6b#Pzgdo1W9XA{JBHpor=d2SYAp?d`UB>lqqO9}YhKKj2XP zGyh1=97ua#A%FNFb|-S|_8HfrMwh`=lYI5~xa^>xMgIa;z^y5Y7GDH~N^PyIiiNuaMF5;*tIUSaryL<-a-|9WbEuMj zBIL%Z@4S5(c$2p0xGw@~iI>^1v6tKm=*Sg2RyQ}T@To!vw~Upr_X07Q<>lOCt9f}p zH*co<9U?NSCRKdk_-R##?w7)rm^&Yn!l+7M3ZDjCoThGN@>j?CCg z7Fq5d9?m0m!{#BKgM;kYSdkt4^;@-9{LClXHb{=F(pENr6MV;2Ab90u{XuyQ)#*}* zA4=lx?A61~qNd&cj9bx&y+uSuPW^b70;y4#aJLBu*5Lgn@8JWF-}VJDN?&1PW3#rl z);2VJg_*1iBUsNPLqok2F;omrG7FaK5EpkP^0HTI&uSCwh`{W+yISqMoU za%4`&7`x02!Qa!NaAW|0uK9ezfcw&mZs%DS(L0^O-M+ScrB433`CdX(B6=o8*OVjq z+DTfZvt90XE8!13e&n_LK5>E&;;Eveqhqcmdkx<*-mX=(t8;z>66LSwt)pdMn@ZTH znvcBo&$xC3#N`ON;PMoARp;*7n$_+Xc`jZ~9d-4P)wzLOsdCq^{Z&cBL4)4jiM<8{ z$dB%ANAFHI?xp)aKbx6nSFlKOykls-Gp7Abk!N4m_v?Ug`E()Lc@Ee60BS?S$9)Xt zDTn2Wlk`&Vm^{xR{r3j*Ir{WYhNh zhSIxoWcmScX;CnOK-z-Qn9gugNJy@^|Mi6RVRv|3sMkIuptfT_%2^hI#>T%3KG$0B zGm$`CaIhfvQ)yo`dHqlP5u!)Vzv8I?GrV}fMR_y#jRfpuc^_5!om6Z&gw=dh`5(Y5 z#S(ttouBx51^nmF%ZTYy?k|_r@*{x`1&HDM8#^i0#9Rr1yAN*n7o;j|lTo8#>fcKu zRQ^zOJ_U@)zRsM5QrxXfB*dSs31L{8|q9kZc1>Y zVpwFiYT~a{1XQ)UjXWxJb3R`6^_5Rr@!sn8hWNAmE+jLjP(^xkc&($gH6c>~GSmaV z=0Va;C{~z!84h@+y+iTxCh>s7?`FqxDG9elxsJ=0ug>Xc8D_gheQS~NAtExvBwIQK zh{njYAVTNl2q$jTGfJX~YSM;?UAY;t*VbLNDXp0wsGYFCcjViLeR^zbusi>n0@x{}eXV z37UtR$8A+v=$rQ)c_p~I z=Fv`b3a%nUwSm%6Fy?!2FAFv+Gn3viv9~u6pPF9tgTMqaXf?3h^1yp>kfMfojLMI4 z%M#3F*|hyj!f-&ZU2J+@nR^7rYHiNg>ILAHAfs(9Sw9XMUG}v_C`8ImA1>jxVhZ9GBW?eRmAIpi=h?$`0BF~NS+0Bd6)T|0KnXTPcBAfVsf&T zqH2#`YV(Jpj-Dvi#U=b|-{tkBTFhbptJ@R)L*d=Zh}0eBwdbG0vE$l=Kse4IoF|xg zaVLYlCDXkmSc279P7fD9f0Q}()E)coN>7g>tKaS$58u`5L*(WWZu{#1bU|4{F^Mg2 z!2ekhHeF)KfqBDR!C740elL!|U#57+0tEL`zxtKf%nZLGX^RrazVTHX{{^us4V&iV z-m6sJ!c(`lYpXmj5Ql-8Yd?3juFI&|S6*HHM3wXW`E}0VhnS36XgO=7njWJ@%Q+oR zY`XbNy4J`W9O=a3D7W*>4~>fVw~M|d*y3$6v&sw*ZyL^_-s-n9Kh-R1qU=-+N|^d9 zS0%vilM?EaUar*p1P8BXxR6lsb|Lg!Ul*_YFFk1raD5I6<@YP!_%rOj<}izuviOP1sd0h})8qonRSc%lQm<0clMh^_p6E_bXf04aA4-G?N?1+TRs_$vNcTVVI*zmq!|l+4-xp$2&#Is zKi;YOQ!uu*Swv-4dc|J5rp$(=pPiL>xE?BE-<$F6TQI32Jn`3=cok~!0uJTF%W>ru zlX&_+=@=1U1^Fz)iSZphJxQWN4^-_d7Yxz?4#S4Uwaq`^o^0>5xz!&MUqT6wRCzTK zGq8YLp)?m*3BKTa-KUgd5gO+*>gRQp3I#u}3Z($W5rYSRw!7T2E10yiwn1G7K)sE%RJmyunQ+;H3y-!0!mWn?}3D2`|BnS=hT5wu_=1n)FqNm9S*WKiO zBYDe>NY3)LN#51HJJ9ReMn?}C6qtc~;vIb?NTVJlWt5^oBMOU($V+pJisb#t8A6BV z+avUH+ddyW%J%^TR!6Q;PsIJsoIDxzYBcZ3sJnCYd9h{gox(K1u$pQ%$nPL1A)8T( zy6{Tnj;&P~rn5t>$pHf=!4SBnf@Y#Ig15to(=06Tn0C7N6p-#;U>nY4X7ykfLt~0@ z%?O8WNNq}=UAY$Cd2Bh8R1qZd%RD+zm5dW*ST2b7JX#1(+*}UrTkN+3Owu@ezp;R) zVx^1LDu@*PoA$2=;xIC5nlS{OkKhE8yn2_-*Q~6qJGl9)QawG^Qkhvmdkr)q4infY zx6v5I34Zgz_Vk|QNU;pl>u=x4U0m*`UqCLi4g_QnErCZu^kg_l96+Fj1Z+4I7xw-F zX}1t_nc!n2OHOT!wn6wf$CimVekkYSTn{!eUiF8~bC<;QTCW#~VF_`bBpmxT(**Cs zU8y}z*?poGCw+qaVI>6O;nQ>IPaT?XK_$l*xT+G6rSjSmSpXtDILk;(QAvq~$O%xv zsEH#%C=xLoZL%TvUUE%*em5Qi*%0u9c-_F%&8g4fCOy!Uqxp@Gm zBlRKlO;vbvch`Q8D-T(mt2~)TK(-)rf#p8FVgslCF8x7MM`6fs4wdiQ8zefKnpsf1 zm<3D#p5olXLb^(PR*aBkHgLoA^z;&M_dMyv9mN7q9wZ87J!Ml#eU}l5GO6nDoPw`9 zdZsC_>`PVCt^9KP3hzAyULepXc=W!<@*h^lwjBNUgf3H$0kYl#w{WO&@Q0rgg1n5S zHHPlytSpLB{Bc+5Za009D;d1+&(qjeLpJ|!p3uOZ*H+NTrzcCG$u%rz&$~tAmlX1F z`FE^fk%>vZ-YXHi?=eDeMiw4i^!R23rL8yXt)R4?$?oijeoe%fZCLc_-Z^`WFpMX4 z`k~K+gosfa!KCD5&Fs8V-S+h6>l*jo(UI4NZtW6=cB(W6x?Q@5&STw2N28Wkr$l9^ zL+CE2hInmjm5udI7eO9&kF4s$!;NdIF$Vd-wtFtonrdm?x^<_otY|)?u+T>P9k{yZ z3YsxY*yHP%@zRymQ`b?tWl4CJ+v{G?B%`E6@4aP9C)@km^-ykj_fA8y z*j~%hQW4K`l!(bc$RYYE{RLkf&KG>1(hG3OV)38fs>ff7S=?%9Br$op>~YJq0R{{?y=246l7A^uD53JbTYx9i^6US_+6`E$BR{1;@i{WffekR0xLY(ePQ@t`&9~{-xDu3Gz z7G7~3bjcrUG0o^4Z_W!n?&;}?Pkr*_Np#=R(Jl|Dcg^4MbzclLy)zxzoMb!QmDhTU zamVL&b1VX4r#kh#Bxe?Q8XKlmI?W>aU)}on1Gc`cv$rElMOL@E5cp2zv6)(3N1~}M6B<22V8pJ-FlT*v8!NQ`B47O4_U5@iDbIR z06tMUdAPVZcskKl`7~R;!W<4KnxFl_P~^EKqg9iYHFfgqaUz+#XV#ynEiJBUA5=Js zCV>8NIV$T*RomWzxbyt{>aIghRdXMwOr)TBhro5)ysI6&m&Ok&}3)loMUf$;$Lg!GbpppZ)y7IYFb#i~!!r7Wvb{bYz zF=`2ylG4*_J_MK8-gUS`$SoP5xt{|xSgwIfE@tu$T_AY48hjl_rvJUToDTa3zaJ3w zF<<@6_M*GCJZ3wiggw5|HOC0)d2d>JXKHb%XBA{!`(3Mko$18)=T&Z(r$nOo zO_MTL+6!G8Z_j#ro8H-(DjDo}a`<^6Zc?!M11?=HQG!#?B!OKumM5w)4HzujfdbBW z3JPGApU1V`8~F=e{J~C~U0l*ucA*frvNP|gNFlWy091;Ot}er~-!X3zJHiP5$#zhg%We9({+1$ZVX+#cQYQaVrO4_%5R{AP8_T5_l7K_x5_(FE&dWsQEpnA{?K+! zw>FeTBXo2Mc$CR3)v_xpq-r3)px$B$Ct}T22@OZnh{w3APY`iKo-h_FwW;9{g%UBloFZ?_bptyf@w|i4Hoy_u8q3V*32tX?Y}m-%ORFj6Qb? zDol0Y%AzXQTgq0;Xq`6}&qz3~hj!%|r;NR~WW&NX%6>h|zF6cHD`IyeAGo26;`_kJX>Ts;`(AF|^B@@6@d~gOr_DvhJ>Ao9^<+wgRqD(ug45UB?qY>kmON zf)a^P`#(X|&$#nmVk$Oj?#j+BjnU>GT{Cv`#nb~9T%Bsfr)I9Ka0UZJ!mwEVB`kQ6 zM8>ZF0n$d$7rF&__sAN(G;`rxN9NCqFMx8$Bmp3Y;j@lDh}de~ZSZ;2&PfVEPy1~8 z$a9@apHNW`3>asU0nEhsB!Cf&M8fvs#O|r!op;DY$x2&(7Kd|$_;=~(=_%t4Vqa-d z1K3vTr~}?Xh5b94^VZcL39_$PD4Uvob9XrTD^waf%IEVsdmi`DfzB4*v~Up6WPNP6Gr5wSx1(ny?j>6R2-sfm8}#=rVm9Y6mjPQO0?k zT5qyaQ?>B`3iDDFgYPV*lL5_7QPmvT9CPdp5fLeemDGOONn*rC@Cv@SuWtpyFb?UP z5x53?*)LUg0i;eF6B>?G?mki9l&}EO42zOxMxsSKCnNStuc@+XdhB9!<29|-9`*6D_a*(^PSmV;muZxN?L=xX%6o+`%Akzo_pm(n)dej)_2(&^=_FTq%+3W-`RSVVYy5IGPbFmXrJT>4d(m!xdee#S>+G zm=DP1lP{9bBZUmQW{j>wM6l^Alb@ZnjTLu_#2{RagxfD4IKt(+ql}%m7&ktE(svFFaJ~^;RZ*z1!(rB6h6=DZbF`osFNZ7tA4gN(;UWZo?CI*43naU zKNm+wkZQTWeL2VkQ)tIdh}(c(VN5|aPg6zRvG%NZ_FQ?yS+y2C>@II-g?voU6dXz_LcT+~}!y&$%&k$=Z83k=E82uG;)3E$@*l}do+ zxuI>u1BzxP>&J?)4QGsFLT|Jjk{32hMRLSUgckS~9K25p;5rC&2llCdk(iM?Ti1|R~yrAs@C=@=m#(sYo z)=}_uxQW8Bc*}#btYUWhxmbc_#|5wy5@g*oJx*-cDzC+;-lC-nlr&HvILl)ww*#S) zvnI+C49AS;haI>tKBXew8uFGVAY@dv**HIQ4Ij1|ewqY2zOD`|LxlNPm zt#7&E(mp$|tcBz_L)uy&1>&_e6j8>H8B6?oj~tBB#Tc_z#J?9d)+Z3(?aI*|NUbkh zNH^>l8p@yTE3TVgvy|WgOFU0_NwY9KwCX`AaR>#3RS-e8drY?@NNJ#QTQq)?Qzg7jyGTU_T$o>7InXf@&{mMzpu0jURkBRAJ2cv0vxZ098H z?1`h;f^C!$Ky>NPSN`o=>9VkJtXXiu#?72Qv}!p8Y;#g}Hg`KSd8@wZwkf;01gm^oRah5%pdx{m_NgG%-n_Blm|$ofpsf0vdILjN07Uzaz~o zg$+Q6czG?$U&(QKDj^|JxKuIg4&Yde<}BRSw@x7tHBQkH6~SRf>8+Bay}cbvX~rVE zP}{!ahYl3*aNE9vC52sJac7s)rLJxare-+lW(104Bp$9ZF+WeSv$xW15@-PG?WkS= z9O;URnY9wak^;dqPOAdm|55*0;4k$LDxk46wKF;%7+WHoC}B9#Jg)royPX|8J$385 z{o~gKpZn*H_i7aJ>|WyDLfUD0I2{EpYlFIztIDBhtSm#6r=WlfRUVCNx>Y_uZ3+I0 z(Q2svTmyNpukr6FH?8=YXM9Y)+8Ak^2hyC37tSuSo0YT*1~*^L>R993ilIdNuH2FP z<>tE7fgjcM7p2rqEEa0so6?$NGOUwvA`I2Yv z&Q6@)PzqbB4*Act{Rc>2__Xic z3xt|;k^MYF#rEQJ=zpYJxc405DTnta6*v%yhZCqA3jV> z-#+Xxkyk$73E&qp@vhWbQX-jR2w4uRCwGE*}M#tjTU6WfZ<)By#LnL*w`3an=4{P?JLt&6M-yAEV0%-JD*Nvy%j$JIFXHT1=^Zl&U_jyUQ3uN}n< zdE39K6ZP5-XcKp_oq9xYJG^ z12PeEw{8*M*2aq1mKpIy?XIiuT^d^jPGz~rd;1CELWcG>=2?TNAqJe-Fqd`|@spEh zql`m~G!ei=i8=pyjhP%XvM#f`x<4f{8q^rhndAMz8ppet(+~5#5Es8Vrsy}DUpHzqQ!6LYk zGdw(k*goG&E9#r+YhcbN(cXQC1WBA{v$L~{kdmLiJ{ur)m_`tv+VWT%C_*v|m%W1& z)0w7w*J^_qbaZqgkW!y`yqfJ`p@ygDa9Rww(Tl2w5B$?p%!}RpR>BbCw%r@(ve~q^ zrYPY)@)mJ|K@$5;Q0L2?H@-nGq-X(20>OBodi-9ylv3;8Ss?>&i+3HMEK-O5k%aY8 z{$J<31mb|6D#8BhforJwvryJIbK_BBpM~9Yn4ZffTODTv;CgR<}@*M!PGgk zy9PYP^z7E*_6zY`@Q~0{a3#}KmD_B*!3vM%&FuV)eE!V?bp=mk&+#;#TU{@{PxYSm*` zy6^1rBs>WMc`8~r3B4aC#EVI>d~!P5{(vk(dHCiqj{ULpUeHUqT;sjnM-_eo;JwmW zLdJ5dQY}Y?pdJa?S%O3BWE&=imhYeVQGFi3BU?3~btSs1giLMYhkmVi5- z?rek$y+ZjarH~x^Pt=XC>_4VkwOb<56;W*@LGI|l$bRmj(>1vlVSSgQ0T{A{n(v-K z=g8bn&9ZzVkGdU%3;KUlR{!}#vlA(MCNXi=0@pVTX$BKk^1e;`Fu}jjxyK?aKQSHO zris;5^e9Jq51U_!WW9gSO3;8T<^~J*5lvBH44V4*#;LL^XDJmYiN!I4;9rudCsv49+P^33zGRb zpfNDbV?QlLK*idaEyIbO#*MSe=gRcHvau27l#v_o+>92CALpX9>BG;iv5$Vg@2$RW z90rL36Pu%BG@-f-yZMPV1mc6-*6J)-?ofeSN-(1&S7QMN`@e8VPlto3fBl>e$8n7Q z2!lRogoaWIgp|(6rISmXjy%`6TtRyCv#ad1H_R|Czo@Osn)hBaoSL20v2B*C*lbXy z2?A0FCT!SOB6%UDJKvL@y01h;Y3rKgP3Kizco7Dh z7?#r|!Q5r{zfqg~4=6v#>i?EiA_?4n#Hg<-aIRRoK=3nby;AQ2Xzg`KyEiwVP#sUF zQDJyc@p&{kIr;nLfq?;h>aSnJv=`yvmID*&ncX6Y3wZU%*-n!ZUJg5R%tQQ@(F|s% zG%$>1!$Qp&4}GQzSb$VovRfUUst8F`xqJjpfv?Wtj1Mn|aLkF{500oJGAaWZA$2{B zRqrwlJ{1fx95ZmQ*0{`h_bPB;ifjFAk1&(plMcoZLlaarF8%F4DHp{gtHn`vY6BrN zz>=Z#XEoNOk57e0pvjRyN`&-dWqha|;yLmg0JyHJYl+DQFWMTV%EEm(=cV4hN%zFX zkegwk$9KhkZ`1dC!O(nnN!5xAujxHs@YD5^&Qnl;LE{tpQ*nf0q zjhw|*fMw5~JsWX=_{&5_1p^MZIrCKls71^rVvuecTw@RJ34~*$w0d*&3>Od2@myd6 zc9pShDbR>%k!Aq|W!0Ntax}l;WuX;dmy9{lBZPVuU^)E7qti2?7))6 zff=6PM1-@_i*=Xy;u9akWY(wa$?1M7jt3Rc%)=c5){V+v$C1JdBA3qm?WoG#&b`21 zOGrWRsQ|^&B`*;XIsBslz!qthWf})xXTI<&4WCM7`oKh0^~HrXD_h$L%!@<;X4`v+ ze$u!dHg61zIFxcGWv#c3x?FHmL^;7wEL|j z*@BGoN4fL9cWhc&+gi0k+5WZwj3+x>Zr5Tcrkk);-Sh<3&EY`<-V63ooTY#Y4P6iN1%Vq``g(cKN>+ko>E~94y_Zg2LNh8dUhfr zu@Kg*jhl<`5!^~~BhRW&q^f%60Tdy|BK{d^_w`$uE;QdMV_u69a!pu82aFvM4V~FZyFWvAwL`qtQ)0-$6OabP zo)y%o_sL)n8hz&q=faBDiXcAh>x-m98yknAySZ~%_NayaxP%O?UlJ0vWAEBucYzj4 zq`;*$461Sr+PaF25_gm?f#$%Km3HTG<25BbPopMy4(LIE zM(Z?+hkrCGRvQ{OzxzwGylICKLbZzbW45{8uDP3AKp#QkDrO4&(1n#Z^|u?3mB_C0JMgU8J8Sh06%6w-^#P@f0Lo7QdW5u*=Ptvb!g z=yRI*oB)hG?i9qnAT_m%W^os-3NVu;{FSfszNuj~EfxJu+!x%icwi%-T>2e`Wgp7{ z$kuNG#;e6koGIP~!Z~TrzW?pz+zX)ghiJ%S z67b)XZ4C=P(sPz(*I^E$I;{uucX8i--XYB|;kWTL9V#6S4(@n~g&mCq#A$qHyQ}$of@g+- z!#X5K;dDoNa!22DHVO9xBfh9S%7M`Anj><8NhKws`()HJI_nb?sl-ODJ3bVG^E!T_5`(Tfc}0lyW=-^0gQ716sVOun4tBj@eam5D47 zN^^zOzBSA=p=}GQ&^OURwp1gW&ZE)UP#f;FH5%dlHYW@j%9uJ%CY%*~zzEIU)SOkO zAie#Gvj%w`_S6riSO2IzEZ8iUeeO4TjMf@5OCeTB zk|r!exzIr&Yn0^Wq=L9dMxd)kyTtd0`W!VPh^?Sj;w6n<==k?Sz=WzWWaF=eGR*(J zD*Q?|mTRBq`}dA;A-$F?SDC0R4z%73xBv9#ImeU?TYNIi$t^Cdf%XTYV}P2C&h<^) zq<>|@>)MQzYc$bOE+tMO>15NZrsWt(-Zgstf36_shbI6r>lkPi`xk_+IIm4W=k?V5 z8v8>!FkWKeqO9}zp;och;3a^aYAkMdGCvH3b#azAzA9Q(J~!4Z+^=B>FKxJOFMyhy zh3PIW&z*}>%YTmQXu8kQl0jKwJi+rCbOi-YQ~Ub*LaJJhv{<=aN_cAv45s_oBuA0= z-WK)+On0d~k3CyZBJAmEcNDkcawz;59+1-{U*J?4oc<|-fWH`wsZSH242JX*{P^*j z_m$}6k5*Qs60rB!-=&^S=(mKLm44}2UK19;yHLlpu3fc-8i$mNt1B`M6LNX=0?d7g ze+_{VfaPc4Twg>G<4*_Jd{IKibroJT_=xqRP4NT0?>t|5tu!Y3`mq{0&90O|-tRI! z>uSB{?d|sCx3jCulwQ?(4DcdpySuyJ-Anp%kzub+^;da79c3r(j`(wW@PIKGb`*jD z>xcVyij>EF&BmgzRy@IQkUYtP=G4HdzaMXk06;~;e~GrM+ibSVw+%L|=E{eA^`0OR+>H_EAS-otIc;{iRR?$>kTpgi2zuRN z$Vb9u(FX>^zZCZr=dKM6abROFS~X*ARYF_+lJ%bWi`Pj0Y{Fwm8Ka@!!Y)M;xhi{CTNH zd$^STl+rhg-xGUi-gtOa*zulS_>=By|9*Q!eS}k6TYuc-2|qcQc_Jl*roJ@+(jKPq zO_OV0(B@NkuBR-zZ!H7KspM7Vje86wskERce@KM;`XalwN?6mAFCNcobKiqtA+OC& znleOd6FEVXaXsMTjj*39?v$5TVKQ+gP<Wv9R#wI)|5H`sDYusx995%bwQG$hv*w(kKa$2jeYIsbPY2U$bsYb!l8Q5sb&n z3p0Ty{3_sY9w*^)4cKS9He9JuUdC*@Wz(@a*G0Mh+PE8{*u?dbH=_<>%h2Fs$U*r5 z+Tcs8HBKd{{3&^}C)KjL#`)bPZ?i>!-tlaAsuVC2HK*{zgo)YNR%reixnEv16+8W< zxH;Z66I7uST3(@Z=c~)d`tUaszZ2JAf_T=d*68Ce-Me(g99lWguy9ju&vFQzQpBBN z734!Am!Ej`a8b8O7ht+FDCGhrm3yl;IHMrT04f}OSa)CrlFwc2Qh&wJzcz6av?L4z z191GDj6#c%C&!%T6ED3kD7F)^zaX_&K zvg%W^g3RR5$lmJIayd+5N*E~L}pcM$fjM)_Pmh!j=xPzKvPllh%Nj{db+r^ zV=d++QJ9yTt3%sWHpTzsdw&;D!Cd{^$P zBA4m0w=QI4mdi6jRci8gz@+F2I_DwS-{~P=KRsbxr^Ey4F*%YJQJ+ETM2}tuWL=vO zW9!jXxVhk(5NR9#3g4!GQO%DKA9e#SBH51$b&+Gw@t8(NoioGdbLnqdf=%xapR*OD znSQyxrj9zf{h$^&qs%V%Z33;~g`uNQnk*7A4mSg&+F7AV8~JjAp#5(%I2AUueN@mS z2K|x*JURfbB++in(r!#=P`qPuxUA*2Kr%If?iw-*WtNIACH1*DZ|Y3bAt9#kolKHH zNq8lXH&}c)E<}A2G!d1`C*#q9_xdXclECOJ7l!s|L@;4>UElMV+TZDMrfPJK!U?cI7P>#;rQO<0^`0Y! zspq(y8ijrhG6Q`I{fY&Q&V3HbWXs5anR#%$ekd}*=!^*X%S5V>h@TfMMVkP?A;Y_P zEX8+*$mtk1^oUOpj`@-*f36HXRj1<>yUuykKk}ed^Ks|6CNnw0wEYjZzT-ZT#%HuF;0tF^ zjY1&~wXkc)3IBMSXBe;Ie8tMKr{>d(>_)LkU|)5-h;4t$810l3F>RUy8kyyloC3Q% zEY1df=RA#L2*sX)bl)p}@??A1J}U}kgPy&An5EKEYH~2LL~A#aHHPH;KRcFR{BM1L zWr^h@$SdFla#++6b)07^EC<7Jmh91o^gV4Cix|jwY13uhevezA3Wc_p3UIld^gOcZ z^m^mh2Fn(^KnIfdqesMQ8SU83M`{?sy>se_{Hp37mC8%9&~p(gi3;zeQ@1fY>L8}( zBj;y!Nflm-&DZA^*m4)f>A3{Pfnp(o=s{;Rso#Ck7xm{|V|b`l0F2OWpPa$7Zt8Yq zhI$V5FKC_t^yx>;o+v0_m@m?@q2aBI)O=N3(jA32mV4RejT=ICp*S2nHCO==VnqTh zhuibRhwDgqxBApGs?7C{u%0WeWW9^q*t**I?bkv>cG5`z`LZYkRY)}(Q#Egd8{(6c z6k1kSvgZFtnol3UjqWuGwPj+bNLAgz58~$2?yKW=&===UE=TGTU3|^)gWzd0*aa$5 zr5m4{{?t789R*kZqADN_mxUDc;kxviMe#1;Lrid$TBp1fI!*KC`-6!zg8YGn>%$B9NJU ze6ojeFyNg7kUyW7$HQ?{=i+*5adD!A$5p>yZmQ4M!DGA2_k??j&luc~P}lgJ zW4M28=+|-tJkNIYJI+_iY-3zI#(1qji1PZgLuKcZvv{vXdTRT%hbIMqChreG8C~Ps z!~H18-w1W5_;|T`ur&8p`xg10WSw3WQ^ zqI70F@5)-TrYkrIU1xY7-ni}M=Erh?h^ZVs90Hf|uB3V6pjO|gR3)=)YpUXSvFZ8m zeP<0sj5oOSS6iD7AA)`@^sxErw7iQJYnsUoyDNwLXr8fq+L)F|lx&~3G5(y>H^TEO z4qY+>x{OfBS|j-O2Hv_<_zy+q-&6Nvxt2dC#a}n%#ZqV!O&(#qqNs9)nCQdAf*LqM zKeLQqn|mCVSk*f(Y!7$58!o2_;%w%r>J@#+VG~h)KkONmbZpWi*d;k~dl{9l%8cQb zi;Hhv2Fep7s&*duu`~o#66~|*t0CCJn_4E#Ur6O)?PI9HXdb@{Sgv2@GumB)+g|!(FuB0=6g5JDV7x(u>Du0xuEXwzo!brLn8v82 z48g`JTb*gzJ(jJHnF92OBR-D@?h*s5b7CHuVX6i#$?B_QYBxS@U}^YI(Z@|U{Q*lM zYW*>=NR9EXM8Djn4qhE>bs>ZbBU0o!L|8m1Le~6-y}0u9moC?wz4T3W`x@fObX-04gP%NmyCQYeM6cUJ{r34R9-N`I z+YZU`vb++e> zQSGsFCH>4aOwTIc)w+Gf!jA<$=!t&touDyS#Z-un*Q{w>!1>ns{#}xy%3XdcTf*1j z^>3B=>6W`Uc2~pAr zCbm_2y!l=x1Cogi*Kwt_Q+L~Y#`laW6uaeZxlR6rA_6Vtvcxe7LQeeL84?~UVoR&| zYkJ!Wm$Y={Y?oZ)G#j}S!}B-Hj<7V^7FVhB^6x!;c2+7GpT-zrE^)PQG0V~lc9A{* z!`;PhCvcPYz9qs_;!*3p6*tVMyYP!5bE0i4*_~BMbH3HZ+Vi)m#hR-HQ`vFS+j7PioisHWhCWv^j^G8`OI=ZRbYIS>5=?=YfW$SCW{uXw}fVkb7jE}@oSq|Um z8}h3Z{Dkr_tdo%im|%9x$&m4^_b`Fbm-Y;8wZ zYRg3X^^(dF_?kU4XXLa5{KTHsaC>jMa7DX?8;xrD^|yFzN)_erWIb#?+D1L__4C}k zW@Gl=`L)zW?T_mkr5r}*ib7J}USm^c(1DF*&DTjz^{+Z@#I9N}89=h^hXlUTCV^3& z+;ERyH%Ha0Oy-D}_&$_ZWoyvSdudhp52~m?q`EM_@M4i+DC1+SFPF)7#w8c!- zB+}fAF^&_0FZ)9LmQ17&3D;=M2f2jJ?9og^F2ZE+^!?&dy`eDIj*4;7#e{yA%Gqx` zLp?jz9$Qr%m2>xCZ)(0vbGjy-Y#LiJb2r`CjoDjL8!?C9%q%AiCRP5X9hG{A-7Wt8 z%jf`+AR4~(KRLLAe!tYe&IT?yF0IH>r{(`@@4cd;%A$8)TNDHdDk4DvZ3#*a0s;~Q z5s{>lGYW`gkXWP=Q4A7e&u=$$6D+=$&MaRDoegfkS`DC4SjMGUK+P{M3 zI6RksTp>z)UMZY<3F#|(@$9Z4Z7bIMPCy6wN$+@uIa%JE@+gCUp{{mY@7W$nB`LI>HSlc^9U668Nm=??~R~B0p*uytw|D ztTt~WQRdoeR^EclPWo{Zn&x2U>(ero2BQ%PQ4)?Ju$){Y{^S%H`NdfCF-|X~X5BSP z!r!q^97lDn3w8H!o1RRL8*V2@-YF+{RM$Wzj~ZSwWZyIX3l=y`UCJ6p=}LJ{8mK%-Gt-8y=^3t&#Nr3%{Ee2oKZaP<~iyY^C)? zqdWE*e0u^bN_kYvs2{!kA~$J<;}(Q;;32xCY?3#^DqmYYKgFH-8#YXMk{DOa(OkPA1AOUb*z5yE^LQ$bWh^#&Ae8a9fnG7 zhr6wf{gZeLrGPn#lj~#9GfgWW^)(5Qzns@}{Dp9Xkku5!{eP0}F?zGIFPIwWc2*Ra z^A(zD|CAj(su#pKay&be$9_ou_kBbD&e`?g?LEWdXbMXJUQHh@|F7h^fN%^jh7V6n#3}=EY znMA0yL_P#qX$3uoTcp}5IpKsG;cLZRiPK=F&7c<56ya#a@>XNGJFu^>oV$4JlP^-* z0&(ilJNo|K-aLLI@z)O0sEG%F$4$m#!#ePueBo)ZsrLMOYc(i-u36bPlOq>~4uNKRJym0+Cv9-)s#CZ4d zV$*wh&0t@CCKr4Gk@pCyrz#;Ul9&)Rdhuhe_s2uQ7rZ zqw`_&Eis=_@Ft3CVKi31lpA&Yn|kC)qkYYw0rRnlvz1B!7tlqbJv1w0Q2WFbGUn<) zew5#O$=Ksh+3{H(`Mv7EcYO~YO%G!N(PUSNSVXbB2G3_bq8o*~3dVY-teU2JNd$#t7$0)uXjxkLgY>d4*qiN7LXn|YR zN#P!}i$-%TFx-Qqmw6C(D>5Z zRBZ&}g&4G3!psC(@r(!2&&}BzovD3K@kPxGP->jDmLiwUluVPy9Isu5*kDB{Z7w@5 zVzMi;K@}Ne#?v_6eeLvWynz>V36mp-)_c)nnS30%+ZJehx{e+SZ zoGz?mQ%SdsPYq6LaQXl*+4AJnH5SOcKVJGp4@($TQm8z}9^*Myw-?BMnT+(Pp3#?f zv*Socn891Le0gm1*3NJO?cadIF%FIQDiuU#}HoeT_J?<*s)imSVJHY~NxozR7)M&w9+S zyDTpNgKjtxbY9JohRg9K)_1!ew~NC1G+b<@jz$4vVpf{PxufC+b+XMHiPg2j&Lpu|U-pU% zqU7h+%J9;kQWm0HOE@x=qe6a+#r(57T|`zlwu!@~%bO)w;u;q3==rZn7V{g_C3X3{ zqgH%s>XOMAI^K5L$G=0Spy3FoYd$8GCb(2dMdEE9zaC+5MopY0|6pvtf6OPooLB$s zlykCA(r3r!@#yhOJFHCiB2V%Lw{>-8j;%r%TK|k5v6bTNjXbXw{Wn_9jWrX-#9uN7 zRWiAMlKIdDONXNYb{fsjCmC&2zg64`?;99karH4WGIGX*hnKMNCP2uFl(VvWCMk3E zeJAEoU78bwi$VC@!q(D_tT?;<%c}X zA-5!ho6Ocw9_J%lbsi>nxdhT|QN0;mX^AmjPygrq-rbga*WUlJxcOD{a`=x8A`J(* z)KsB&+6zrt41-!^T!Za-Go0|QQ7AcDN~3vU@eJPZO2&!3ete-3}l$c!W6QD zzg<6?Gd(Rl>u@32r*S^|+*>HcH;gO3)=>$*ve2lfqTUnoG0f%u!YJ`v^Q*I$ff1-@ zx`q=rLoYolY#^XejnQ6i)j*3} z3e_NW>q76}3o!?zhOCw2FnOgP=uEQipq+i@j>zOZQp`3^w#F_WYBb}n8_c$#99#=a zZt5$E#|k(v)JSwFWN6>~S^oK+lPV2okNz8A^YJRSy-tWoRARgCd-h7+yJ z{OH0+(*~!SX&$Bs#nfZp%;4mXk5?LRW*A@W`I`$4BnorKZq7CY$KFf7S|NL8t!X$Z z+rmn;G0ev*{EtbQ11I5$h(3?ao1hnW9O$+vd>C)axZn#MP6l22dg)T&BHccv4A<42 zhTQ|YuGxvT<`uh$y&+2<9J%);YHD|3lb+WL?9?aa9{5P7HPH2zi9IM|;xmhUoD^&= zB#vXRN#4XJ;#(WS82JL+r%qb1*R0Vkdyc*dc%fNVeszbbhIN(@DfBY5VVsKV%@xh}z73ZI|w zuZ}jTIQ7Qso!b~c}^XUoaWV&6YT!?>2 z1+JaSUtL~SU;O@Uto+#D*sSMEz7O-Yd~}RWIVFb|*2yg^Ziys1{yjVlaG8;5kfrjF zZ;&`@c&bQsC_U))$1O>MmR}S0Gy%wlfK2AB@2reo(3M`DGb}_a+7BcV>doOncMEeh z?AX!rivyF7RBlNRQ;KivqOtX{4LxI;rjMPCV}u9k>ff?VI#JZj{zknXpz}R#YXHle zg3P%OH41+ZO%43WXu^C)L`FEDpVw`DsLxrPq5!4efEDwj6FC`5LA-MMPxKyKFD`sk zbddVUKBvGUMX;fg&NHZ&{sXDzw@1UehYU}PCo~6Tla}JTq?mu#@BDBL-5uU(7<<#R zCNOLohdMd?d$Dq(lMq>WykXWhML7`Jql9J16AgByHF&#R7K|wk=48p6#uFC<&7lCd z!-rm#Z_H^(*QSyk4e&o*l;_%hYLnOULL@~K6Ycg3$OzP$a{x~S!_Vw=) zx(`lteqOAxkL%lbsl-=Vm^QugnWKcea94JiC|Z3eI)CjlUY+$uTydRnK3RYo{x$nC%8AZS>RAPq;zw^Q ziYG)V7PV^^XX?eYzkjHCqT=CfUne)1ad|NIk<^itpjY+g9t)FH%s1x23pE-a>PE~( z%^*)8D4z=1q^l#+i6>rKDmG^dSxZu-)yw3@ns=r*EWY1N{yJ8w^!n1S)$AS*^_KFf z4xy$d->{C#fDyp41sI+u=rYgM~&`Ik2;TOo}G z+J>?8HBVWWTt4YB`QAD-C*XIn6|)`av6`80u!p23C=1E_D)RMf@Td1%Za91#sQ$%4 zwakI;h8^3Sn7Dr8Gdl5`rGc}5qvX0&zg!-?+5m}`$tB+q^1T;v`3L4tIyUIGvNkBt zF%QuOuy%^Icmu_CN_@&QOYsN1bfCH#iJ@6x&&J=ck*Ph!b3 z2?G{Z#qzT@C#5uVQh0Zs4kZ3QO|9DgXn*}7>(%*)0+jUmxm%)BPoewfu*`z-)+-F* z-Xn$UOcnKO<*$;?lkVO&iu=l$-Ynf`ZDd0{>8j6gDOP zn53zVIS8E2Z7-JO&D}7T(Pm}OtGy|YeL8tu)}WT`L%Qzz%${JN>A8TMK^Vg?(a~vgsKfNs~ZdXRB`1_QP7SF9T`*W zCz?J(U+;)tCkfgz`=C{=e@MzrSAwAlN=Hx~)k4_45~e;%t}|`@K!({1KHA43_)Zk6 zlInCYA_v9StQq$?qn=R4GgHgIU51}nC6!Dxah}B zakP^!i%73g!V~`os{21|-T(6o(!B8JVY_wbQ=}gZj?$FgBkh%N{eN>$`C(7Xbhc3l zdU!ch03X!YZT_io{1d4B_;^?59XsS=7=NJHm_ZTMJWpLm`cJ2lIQ~pPwvjZ#+>R2a z4s?}L2wc7L9ni?~mxaDe#;0HJy+QBoq|i0yDsg^PPsCzPh9kQBAZe3mH}!~Q$lNTp z{p*G0@w-!s?1z~%ZE?IRdp(Rt2CS^hlp~{nEtqD|v+4fAnVp><4c#~MTHK``%Ph-( zYk3*2grb1rIIo4-^a=k~x>}Qmj6mb^1R0-vHov8>jVnaW(-ygev1iaq5Jwk z6^)m)D|_1UIqkaE;`H;%|CBF)07}Sp7Ni2&NwBVo>&Pb@`_bOf0>~y@SnUvQFL*^P zWT+!*bWlDH85))P5Cv)pGj`CHudX|2VR-v?z~P>gob=RoqO|AStQ^V3xCt^-QR|L@ zmrB9f08IcYRVfb}o2mn;|kM)Bw#n5K}Eos0RMnhbJL6|e&Ydwd< zA5=k;Xfd8F8f3) zgY3-QJ{`S+o*GrbehK!YcyJO4KezhJJQI8W-*<<=Y2I5?mc8Ji290k}<vAB1u}3GV5&v`8V^Y0* zZfMc5Yk)r?{OpWUT1tw%1pawWnZrn~q^qF%&KHneVsjukTWcf_fU+u8D?_6NCS%8E zR2A`%LJY_m?Mb3B_mfV5dPjX@YSylGM!jljW14cr1FU%BrHPM#aklUma4n-UK9&am z^aCqLhA5MQbdRr?NV~6%1)Nus+rCBWqaUiW+RO|QhF(K{;}U(KV*Llf0-7_j5G{KS z=OHTVx_$N@y(1zfoPJFyB`fQp+3u=f=-y30;kqvk3Ik`Uz}A)<>6O-0aAPb;KA77d z!W@y#;z!FISS5Y$fs6+`-bm3uz;Y1e@%uwu)nd}Vwy9}qf@7TyLRV;}LbXZz&W&Ya zQfW^dAFA`q8O7C^0Ek0dS@{i69+0l0m5NPA#C*tgrlS`gA>uq?khp`zd=bsiib{rh0Tfotc7xoxeC0XrCy45vo=$sgBb;p#zQbR3ilWeR$BY< zw@X!!^z=?SyM#b&=6?I>&V`@vCW~^-Pc{Qe72x6S0PdY^;^rL={;{)8U-D!+%6pTb z*FT!%l{NVpwaKAUP`6P8hYsn7{soBP%PQKe^A_P7hs|yaZ#au+Q27(3HA(btxu9+5 ziV4I6L?jIIm7@ytnbifdW9} zeFaoK{DZVzW}r#0IBfPlFf)g2Ot?<{c}!Yhltp>KZ0IsYbhXXV(c5%erjuYu6 zL;kO681c}uJ_iJS!l(~UlvP9b-?$eQ(44lIom0>aJ~#k3-h3PK-K+VLN>9kLk^79= zhU|`M8}gA*wWbIvNkwJ_l%3fnxoWGcIM4yFd}H&;O}K%2k4OjfO#N+scAD(hKVTQV zd%dpl>_P9yXoqvkoniM*KctCP%uY9SZW|Ef;paDG`C_dSdsq?xd=dTSMn|E|3N(*MZiHV8VWn_cOpiK{iui_Je z4+Y7oUFC;Ys`gD0l@GL$e%N6O{5a>4sF$xaI}}zu6&@GwIqyrFn3YrU)(lKj6^!6; zc>GpTfx5A4#1o$Z3TjxP!X&1Qh#f5Li9T7tSz`nKpD040`7DrugkOM9rGj(9vagf! zxvT8BXg-7VEUiWG`jL^Hc&ck+(r_Bolqx{NdN5elz$S!3p?G+C^&q2~J6?D1zb4wn zm3@%%!Usx6;9+?ZW_o&`89Tuj>bX=R2%I0F(OdX>fP3BRc^fokl6zmZbqjrXa0JRc zW00+LYh3EB@*D-RXSFEnkkWFQ^h(d07GBHvbWpLB`e1zwNdpNBix>TRfBr{&hK9or zd-{wK(8l~9`qYX z_jpdH&Rh|DOk1RcZH(~!C zm$^O)c~75bYzs%p|qG-O{$6x#Xy zEIxgKOI=r8ou8yM;kLcY90z)utc7%aF-_Mtrzn z5~DUY#VmevR_)H}KC6v{kRj{y^O!&(wcjqRsmpEF`5C`{EA6 zYx#&b1W3;zRjAsFw=0FV@DY#wM1(@Z!qUOvrk32v7_Za{VJ!ZZ0Zd~ZBV1XZOsw!X zXld`fMf!$}@__+eh6@Zf+qsfe>oZ0=T3R`{)e0?GE%hMX98KF4bDiNM%~9aL&bA79 zdHyPNtXO|qDZ@sZ*`2-X#|O(A&^-{H6OsgkEaRp&2{|555?3l`{nazGy7|jT^34vG zxK-ZzE?ez9b!sFmR+oD z)h_>U=(jC%#j`^r2M~eb87qU97I|y%Lwffg9Lh(0exD(+bvce*p~pil6A_X$OJ^ zDZhnC*-Z*`E}~ScsNfi%DuT@b z^p5w{sLmo1JW9^OiyfaS+jDgu=w~8)56E(`jiJ8xkW}f&FZ<4$&EJa!LHwTX9=5%} zwR>jYm4RM8>OD9a3~kGrGzpiSD~+p2+tnq2$y&yhb4OhXrMzMO^W@3uWV6(Mr`l9d zkVz(XbcLR`zd7k9HE}qQ;WPHcABYn$c@p>bydhn2I~aUOI+&G<=71DPnlsdjuW~Zq z2MA}tAS#f9gv(47u^^SKNb?!|3Gk!?)P` zpBm5N?S2VSo46Ci02i{i9$Hs`SdajHd68f{>m$7d9}kkvIpEf%ZCshY)hOhKl_6$< zy+)b+DAT$jrT@+i)_1kK02qLmJ-1%qr*w3nncN?9NJu6O7i+c(y|mg3SJ2A8;sQ}z z>N&^F^PEYt6oHgq!oz!FaX^*fNc354__M?m+nteJB~=`7`5UB^*5u(1?~)kdZv#Su z&3sX7i9bmSMzgin*$E{?LLdHZ;bD!gcU5&Ms+U}5)6F?Lg*U&3hdI@x1cqNW%vI>` z@7mvbjTjj5T;uC&6|80Q7#X|t?5&Kx%*5O7%ll96SREI5W=pz()LPs&^ANF$#mXiu zodp~!5I2tI`s9mqQg7V&{Llb}YNN{nf5NHFU1;=&L4TdM>V-{jdh7J_d8ea8SK;yk zV^o@Me$699q%Md)?2X;0wwmv;3eUWMudigj;d<#x_0jDS&!a$L;_jPHQZdK8s@Z|H zyBoC(y&~{-V5>8P8+zh@iiJ-pFE^XTVbCHTx2$Ud(2?1seFUnR<5)AVivU_kGq1z+ z%-Rz?v($REwY0ths^_lnrF-dT)s_ZX>SphOn-nB_JiIvoX8!W~0$tM4@83aF6y9fr z$s-)L?sxFacBme3|GuFvv$J;9u+TgVXq)W0w{G_^rDDv!dM;S5)z^Ve~Wo3TXC6k`Iu3|8n z;Wu1*zGXVVA@ZN;=UL_DF?W6l9r&Z$T+f|4(L_UWJYa0&%;eiQu$d|~AOClkbl4SX z`?hn;m2J`b!Ca|GTS6Qb$GE_GZt)_vnXLFrSLFN;dn3i92-vonPu1SO#TJ@hx#F$T z6Wz`+e)lWrPPG;nIe*0*gF+ew9UDl83}FLQ=m2ORa6O3TSZ4QvF~-LnI}rCxZ9DdX z)>le;TT6pzmdR(jJSTG|p|bF%)V$$ehoK7Dt#*lU>-7mv@V?-v(M|6}PS{3%^?mv( z3>&Se=%_3VMlQeQHv00m*!GxpL__CYUtLN-)-#s4G*%B)jE}_P5J-w~fB)nbLbu9v zGN5Th>NXCz)L;*lp)&X2e9Sl(zggWQlf*=CrzUX%0VQVBV~J2>5S4n|isMa~Lq}&^ zNnjeV2)nJmJx}cKgXsQo=RZQ!Ky`|3POjV(&;g4`kJZsEB%5xMiAKme4<`xaq;|ZY z24I`_GCD~n+KR0W*!NZjsSd#Fh68>C4&=S`l^yG3=6gFsBQdgdx`$KLdT{{f7{jq_ zo&NDOXn_Sx=A)#p*IMa0)OYaIMBnl8SOs6CH_#B012|B(*1U2A zzXSwlZ_g3whfN9qX|1egR8x{UqDGoO)V9kOFYm{wX+ zl8M3Rw6yT#>7!m>;HTxH7k3(Ea<6VkH3}<;Y6$uscofqSMWOm$D)g=H!-uI9YzHsI z9gPcmGc>YlYt>Jld>t=q5tNTPM~Vvz z3w;1rfsR_GwAB@(l86z6;NJFu^M{q3?{g3F}cDio+tybgjFO#)^{qm=Cz3J-MCb`{e zWV=y!Sb9X6M+7MsAVst2WcJRE__jJ!?MCB%IATHeha|dHjkV7XMputgZEfw49SEE2 z`z>kdOj-!`KX|leHFYdg4xlolN8P^zu5+g9Bf`|WDoZ}OUf7D$Q=muy8mt{b5Q@RpYe{^ z|7&=3U?AJ4-5{T**0WCQp|Z|&x-I%^vo#5PvmDMW?=WGb61$k%M5ub-LLDsZ}1;9n%+ z7S9bOrLlDgb0CC+r^X_pGut2moBxHsBk{8aD*L6+*3ZchmwJ(M!g*y$@i4Xew=~g1 zO+0_g$kQvF z^t%XX_R~9@Z8a>K5>ZbyECBc{_*SbHBX{kIt)<_ryu`;(qu@|XRk1S-p+o{o@w+~W?GsOf`K-yaf<_LcP@a-45HH@`5UVBi4o5=W89RK zmGE60cD;3zFy=hLT;%=TX90`pfrK7*Jv9$7(O}QZD)ao#YQ7Km4Bw5i^Tjs~o4Nf{ zp|Azjpa6^M*_`rnWk478lsOoc_+UG3$Yc+DfbEXotWhYWfN9x@`We6}-zE72DGgF2 z9QX$X#YQ~{EQs>T{+uUjBHf z=o}JxkFtPPz%|*FC+5e!}ymtcOyy*x!G8a-g)dlp!4#h*i7B$Jax_h62m3&}5Pkfk+J95e6@YXV`oqLYjxHZCRMKcjCo&r2E^v z?WW(J_FUuJ#_jgK;5QC+j6?iLXr=A7o-d-h@~DB%dXOXYM96- zuRkZhKRhjF-dc_n1`V8%9dFL`N;?${fB}g+Z0;9gFgrE~iudQc|L)PtX-NT3D3Q<1(!*L-%iUemASoL z7P~(T0UlB@5tyT%12uVoqBz_Crha+*8B8R^K{Q^<-By=_9syW@X@%`djjGOr2Y@9% z_UAwUR*O+^VEoSq9--|Z$1sky%NpQ3kp#))vt-!GfisUC#3!&i%<#lE<6eIT_GED4D+gK;xG}GO))MU=50h z%;8QD898JMitD9iC38>>PW8*lX|hpJ{|MXtOgLv+(1!yQID;{OqzQ46Yui`l=zx%- zo+P3KPH%{J2u#qQ@7w`3^iWf?9GRH%mz^7$tmD(U`udQH7>PuZ!u6dWh_HZD888u@ z1A?Do^wR8frI_9J(qpt!N4fo9D5Sv_^VhJcmh?m3f{Od$TL-S1c8zwBU&f#mLk4U z1+eUc`@(Rc%edz-svJW676w^sT-ynd>l}1>Z5A95WBR+Cxw8MUK%+5^mD3*J5VL4! zMq*EVzaD@UqDH_o2(Hd-H(BtFLxNE1UGU@xO&`!aZG;~h`ZAmBcNaJ^?-su!H68FM zGk=Ea7)Hed9)@Fn=lfTXBi{<`7NSNBBk~R1KW=QER%j~WQw6(|UJx{M7GN(jD1yNZ zo9`M~yi0RimlOtHfSgQ%%LBsX14A4weUZl&k=(3zJy4^_(f6}BrnmB zCEOV-3;QXFYB`V0_EO+MIk;E5<4JT-UAJiiKX1fAQKd3BAiT;Jh8 zdhqVmCiDy}%ynON8S$*?SWR=jg5U3ua4%exAFOIqh%jJ$Exd8Nfs2a`pF-|R3c=B9SWb{H`a|GzH z^CSFWkBPVd^8$>au1*$#u=~~4vdHDgaLmeV;r6Tin2}QmfJ- zN8e0LKE2{NQ(>pmw6v;xD;3MuT@3iLhH9q&aWcEm ztFSj879X81#%TxJd+S*&0f3mSgAhlT2$0U4wVee5#KIBmG16t zD(~rgg(K3Pf_%_lf>x*dDpw_)hh-BgPVU^eKUdKfu0d`>6hC$*u?oC9aj7I zPPOv#aH^D+_K$WdC@K>Al2>)_+uV>KK__Q%sEPf4>oFznj2Rxv05yX+;{3z*q;xB{~ko1 z0|ElvzE5aK$Ur$}(}a_YD;umim7n&HX670ffI&6v&tP_yb$njWD-VlE;GS&@AqN16 zSbs(dA%H^1p!D_|+Pc|ZaTyuK=ss;4>aG1PAAt+1*&JDz0*Nt~h~{rQRx7Kn@Wzgp zHMh26!!xfXcS2P?zC&WKl!lUWT_A#z1E|?!vy&DUdxV6;ljjxTO?{NX1JW>Z^Z<{& zA=I^s{q0z8=jNvU{rmU(`rj35WtJ9>9rKj>apG9L$uCi_4<9~IdmZe2zq(0#j>E>> zTs}rx;5x6g^2ygZe(8D2ckbA_Km5+c&25z^cC5Wq@PWb)D#Dg=uhTYWn*M^Crsm>c zw`Pg0PQdfcji|UN==0M38Y-D#-dXW@61Zr@QNJdq6zLl`GU0S@ewVQ>qcm+=HgKz_ z=($SI8}>_EQLr)rHH?q%B-l-K^(`>LA6U3*JQ4)fSEEG$w5(^Q+Ki_HZ&DbA(awFF)< zvzjv{iS6R~gM<1?%1xPiFm9bQt^(>{SO;bdrwVO`=-9ga;7 z>mR?g)_ukC`t`}f0u$HGlLWeo7~`LJnyy(tHMnyb1|<#6q3VlUw^T38OpY&`byv0U zuuARJEiBm1*e_DSfhVj#zI@WM2#zgV?M`hzgV&} z^uq`3d-vX^XJphm{aW@&=yW_IOFUh8*FP0`@|O-WbMbMv$FASMuA=(o%Xt=-?B?d? z6nvaKVhi-6Un$!V(|r-({a1m8M)xC2MKt%$sbtC@2cgoIR&hJ?&b z{NhU9j)+(>IICCSf1xBLscFfIESR%P)O*jZxV*=Iw!Llb6kX`2W=pDy(kI%V#I_~& z)!)2+&2K2j*s?i*w-;}<7vHz%mWlzo2Mg1jo`yz#`56nVC?B7u1ubqG!eieyR{vrB zP4lvl5LKRQ*ZQ(`UT5bd`jFQ%re=D5^pGu6)wQb~MH3TIiNzc(tZMDnrym`wUsjHV zOvui@3LOjp%NvrCS*O(x?S9FH4h^wH>1k)zJV}K5^F(5lb9!Az!HbDfyOkFy1?8R{ z67^;r3GM0Qi&%z>j2WRvJ7M`Ii*>syqOXk&ghkS5cI~6-A4hxI6kdI`3nGn1GUBA!IeciJwwjg)uk_=(X(ZtrNx31h@tiTlp z(vv6AEz{2-bd6mgo;g;?q~J7q;@As0ht$;6A-AIo4nAv-ReI)ox!p;71f^PKAEO*{ z@;$5X-+08t)M1?sKVDGmbjwp04rY~p+0A?wNcvRx!@7l(=P{#J%K=M^8O=>z`R8WZ0}UXBBuY_5r> zze#H}Kh|0=f6lP{C}Fd^`=OuL&L@v0Ut?rd9Eg5eT3YtZ%ToXB*)YhNk#X45(@PM9 z3h(nao&+oa^rS~6$``e=vB|+ z4v4%1(bq+JjgZH-wac+8{s`D?lPH~wH-v>#A#P#zOUp}b?b~GTZGWDPjeT(6HhUm1 zr>Cz^yS~som1LZ$DSLR&?*9GAPlXDChs*e^{Ia_vBgxnK_>AAFs6el0|2Q3O_DoQU zxv#z2EK3LUY#3WjFCrtIh3qw>wVjibj*3c_h=}fj@1!JVvbVR_dy-(bfJ2jNqPaQd zoJ@C;z$9%1pR?dBGaycH8~z%-8%fLnC&t zuIiI`p`Uwc61CeOu<_(Vk~^Wx4|Baf|$Rr*+7R!z#9mzGS%MNu$B=u?vFNh6+fuyRQ z{xsmiODeuPtv<_8?3Q(@W32cXU{=L$-ndrHzjnbdFfb4{8y3F=jkr{blClzt@!WDU zsiFh|m@P(g@~elP4P#+v#}XD50gx$Nvr?Opp{#4?*R?sb`Qd6~Bl5i0WGvD)HubK{ z%9{4}t_0Y^w2P1Lpcn=T|1YlEtyR1pYF7$!IH22R7H<}@bQt=TIn_LbLn=5Gr{IBR z%_6H-G2zF0u-j(o6uSoF7=mn7l@w!IvSMIhk>Mg7xSuT){A%$PeoxlH#eC^fUnqL3 z2nse)i4i%FP5iZo^AbY#c&^wS?O8}tZ-|Sh&&@qc6xa81DVqsqym9kpO25)C0Bc5w z{uxO3s8-)6)}}SGUjhe}x<`B$_zli+!hu$I_gU~m%+4zn8^d=w7B}1GVN2{*3fsrs z{@CWla3mMnnWy0Qca87fRrWn(Wn|2Nb;;esRM(TZoI?OC0GFlJ_JYx-H#zh!KLQC( zlDBuctzC908eib#=~?#xXmQ?$)q=Ju7&GV)!1(9eIShIgu%RbZNZa*woeXNjHf+An zs@Vp&KLPQZ(e@VBxw@L{SS&XcfUAxT|4Vcj;#2V_oWC%!m8IE_#pduEm5ucL``+x^ zpFj5;YG!3kRx0j%I(7{GM1KY=qQETnvyE!l)oH2dLL%I~J% z7p8}x+XC3Krjd3dly&xo`~vcU&>z9OpQ%8LXkEK>9cB-vk5%q-e$KS_A|qDF_IT zd;LWSzxn1y!v+6{yUQE6Ydha|_p)%cCQ!9-zw6-a?qGY1+0)w9&DPmTh*v;>SAd)O zj=TF^H*r2b$N##5*V)yE&vo#`Havy+uA-qE0ReR^@^uXD@%S|XK}r+)`Zb+_STfaxegi>fWoQ#W1tRB<#f9t;)d&|3whfxq7Ao|FI&IA6k9aV z5*2o`6V3XtUHPAH)Rw=<2u)m;<*U`jruQvV3o{gB!qXc^+dO7F;{)2nfz_2z4F9fA`>rtl-gis3%s(@xN01tKlU6o3Jw&V*EGEEGSqQ_)kVw zksbfdgC}7s_-_b^S+GanocsSDzMzr3-rNr(ZlAc8UBiDq{KYTB;m0|^az>oinW zVG>JS_*?R66z;BC5ydpyfBPqp4>uZqoZvxMjBN}jC#RmKri&U1w(1JQ%5xF|f+8bL z&BCSXW&dHH(S7)PtNRt$lz%tp(f`NIu}MDxqor149_vezBa$mSMj$g4j%=@CUP_8w z?cs32(eDJB|7T0_X8-bupQNWZq~~>3m#}rCPGqEhW?qRd`QBJHzR1y7Yvs}HE4&|8E}}aV8F4A4P6OO%J13{kf`E zQ5qMM)aB}k7kvYQOn9T&RTJV~*W(w1nNpEGwPU8k5``urTL>-pJ3R3Fw14B3nlWt3 z#3McP1W&KmO84b2iPbbsYT4Rmt*)(EIxRc<1<;cPDJd)K>b#D*7sM(pZJw5vw(n26 z)j!~!`04!l^WXVjUfbg0AK)&WKc87#tV0&Wie))2qi69(j+T;=N*QBhWPHoX z+0l`7$eBOgHaodUQ0!CM16x8j-2wVvvw?0HzbhOA!D|@PzwO(4S%cD>oUiKm?gupO z{Ip>+SI`Ra+tAgYD>Zi3^zbNA>FR#LSDkx^`$W!${`&RnZoj10{O8jbvfsXy86F-s zs=l4)fAGRQtFTaD&R}xVTHJX=qD9gxqIxL*@-&d>=j-1gvG@e)%V)en}ik8nI!vwzjTtX}A?H>YP6}_pNdK?muV# z$}CTl4OA5t%|8GSIB=rMACZ9R=I zK-bxM@bz7Xx=)7%3t#RxNR_*)(bCZhGRW4#{)9J8Vo*Cc>_Nx$+U8Ppbm<$|Wlzr* z-<`z~^?Q=muHA7tA8Y!8{C>=KWz1?HE*G$&O-)T#cYNpO<}l~?tagk?_bR@<%85XE zczR?pOPfb?R~QJTt9MOH9ja?Oe^}mKiLcnr=3+xX{MdfmPbp(_)6+1DvSg$*rEenx z)^Bw0Tdl2$>0VoxM#50i4;$vS>BNGzz2OYqcH{AzhEd{IuTFYa>KbY$H9r44-fz<| z=CWgU&3^phGu#J)yW%X^up9oh=9pcc`)=ZK)wr)}m#-IbbL9x>`We z54}5A>&LSmh@0t1*|k-)ZS$-<|on8S0&aNwOe0 zeY3N1MM5Lfw*Ry(YP2Z?NF8o{y8c;PT{@-BcXPSKX@6Ja(brN(5fKsFuB*#4MC5xK z()Y%K>h3@PyuP71v&=<@vnTi{lc}PZ@~b{n31eqxXX#WhTb(K9BC)xBm4HA^A+U>~ zP@>8EV$cXsb8h%;vj?PCgAh=A+N}B||`A%cB`}nETxZxW6J}1BRgwPCuiv-k+oD`ii{T(TG_V(Hy z8~?n@qoXS2fiR?q{*Gy^YWf9S` z%<^*iD9ZLP#1ts>P}%ac`-fmB${2PPYU$i7go6DqPd9Aq;G}DCjy!&o^3@gVZ2RNk zqq8+QDQr78v0qykY~3xV&WH>k6J{!I373+kegOf5;N zmR$GooYOZpu0+kQjMvpYCnD&4)%Zjhg8h7Ney?@3d6uy=F3cYnYd*VOXbDlfGp}rz zrEDl~Ys5!^VQ~>lMoI8sVf?QG75*Tsib3gu2#@h*OwD>)K!=FFc^d9;G^504t3ka= zx#>|C>*dQ|5?J0Qc}+d&#Eh$^TnXdzn>8nlb7AS!km||L%hS}?kA^6&YiyiSDeW4~ zTQzokzgFGP$kEa9@ks6Rec1kxa>?E`;n&lbvD22#Z^nd&E4`M32X9jcDk&)?_m&lZ zNq9OxEsbk<8|sxEfEyG|?!~5OIs5;z&(6x~=&Lzsc@jcIfW0BeLbegXKEFxsXMpJz zO}p#j5`6GGvG)AnG|}OfUrFNXXP^C_bRuq34%Mrji6u_MG3~p3(R^L&vo^LWs;>?< zmk-QLP2*iFB?VQr7Z(@34+d;H*W`{7gt1=aIvaSk*@EBiJ>Sl*?X!h7!oKOrG^fq9 z)(|og(RzOhI%Nsx1Kh$$iLtrafv#i!JI$7smd3WWzGQi-*@M~xd({}70`>jc+TPlL z`Kyl^IfRvUogdFC7A9mQNt886FzqCaEvt>@GGx$7dKWY9|5{GzHTT%?5ZHor6=^*n zz?AXs9rO7unS=4Q#IA{kh>gCj0HsCWHz%3v!&IIwU$cJSRsv;9yNz{N75K|9TzM z%xV)~m)GGhX`Jf0b+H|Zul`;1^Y>{R-C~>9IyyR7&;mhE4fL3~A8Ko9(Z>WyMXB$7 ztrmBkP;7P_J=m-z?`OJ(S*l!)s8~rp?QystkOJ;ZLVK0KiVj2U(qCeqQM1t!KzBE> zhAKmOWVUE&}!;ohF+eTg0TU6f;etHTL`yA>~TuPb_3%UWu` zbMV*k@MvD_NqICMORK$gOvc~eUpA8bq0G(xM2A}3k`H9d57{|6BH0y2L4-7QqgxWX zn`#9YF8yndzdk;Ej7b&Bh@&Z4>@WOfR5g*_z8ayvhmMS-e9Y+fk5lEwyj`Yh9`k+57+!-98frxG#la$f(1qX9de&eUjyQ6rFyAHMq!nm8K05%rsO%#V=tSYpOvF|MFapEpNpL`2t zVwyV`&8Vp{dw;t{$Hpe(a`l>8cZ5H;oOc7f{^@VOY*d zD%A9_tpB$EC*<^3ctB#BHl;j2F|TaCC#!@r`y%K(VzR#`eHc-*vABF^BSz%$=rMvK z>PV=rnC-u2%PMa06QRA=JEUh}ux5UfT;`oyHCyI`MbB<>Y&hPeZj5Gersvi?#>+@dHJWj zH8Zk)Gje5UOv3#sF~hU4wspJ+I#`Q$c(UCr)Ha(C>W@k~%2i8UiOvDjmEJ4$(%qk* zo?d^Ecz8WjYL~-ta6Kd@CU(NpM@LsT>(uF~pj}Rs{XcWvS=t*d&c3Rl606U8a}DV> zeOTCRGXEw>r9i64u##JBWLlEV*D(Hv-L z?|8bq+gC$d>h$A-xFoJQB5BgTz&Nf$^ktOwY@FNedHAaTQFFV+NOCGt|(}hghXCsaC z64M1+bcyZm78@f3e^*Io{?PojnH&(fnE&b1piY{DSo!-Rl?>5#R#O7E1Ec$l> zZ8D{fL+RwB9%cD8b4olWA7sGubu?YV#jlDNdo4>LNUC~en#%HWrxPSyH@6quT)SK8 z>Iy!UF|o#<)87|!+kYGlwIb0y_P|{b2ml+}hx9rfLt^FlQgoe<>XyVX)S^(5A_z%g zWQHcYW;P(XmuYWyLyNgkG)z(IK=0o_BLM2o$G^aNqQ+lJrhZb98-+b?mqus;X8Vmk zCKd)iD0XBHkwWxAuJyVQDGFIa!50X%@ZIRPbRB)CfFz25V20^vX?Jr}__Ls@VNN-^ zr6-{6BqvfYq5eEmG%l&ukP)8gjVBxoUkuR0U)7MBN~Tv3m!op?4b)6D@(77xmFG{# zFBtp3f944k0~3t@^JwQ2H}F4e{tq`FU(*$S<2<~$Jx#{xjPxNnHVS1_m-bUBRub~b^PM8sXCVI5o zhBC-T2nOMoS?MvU+szw9|NG~uw{`T$D8nxOxxVTcYaOzT=l{H7M?EVQ9it?$SJbXN}(&`lEZ~^%&1z@wI3QZvd(zOzP;t&vPZddu`X12?0^? z@7-EfMa|EGD(%ANvi48K9LDscxH7R|F)xndR(M9bw52#h+Xwrf6#xd zkob)+X98C-vOMJ$!46FUu1sB*u=(ymuoBntuSojdcrx0yf&YAu=))vr!wK<&_h^2` zLc&{zK@A)vtnAVov#mT3j|qi*(oCPu{!zZ>WGtm zk;Ej3>s&n=I!Dnl%S@X`iO2#M9eXc^f7=b=n^nI9=U+R!&x`WaF#KO{ZPCvKnjhk~>u4Q#)0G477v1Y5+n(TG7?ag$JBc6A(eQP5 z?Q8x)m)3IJGRH@UqgB=mcBr{G*G@PzN?FMFACuL+$VKrv`|KOqbFd^b_|1;YJozcB z=dUR9Qpzjk1$As#6}3|YG8IPz8k=ii;CCtFQa<0z6GFf=h54thQs`)EW_5OIdANHb z#gd#<2ylH|T-s<`toYziPj~k}wWEn&6d`V?-u}W*6yR0Kxc6HQle)QinR2_5&8y=Q zZklV%QQaPFC2mQP{fljPW=F+j?~ty(C~t9oVc|7Ed~ZA#eWjBud8)=Pn!3(fL;XUQ zH$OYuF(;}&*OSKAG`+^g;{=FS6;`aNFK=_Rbj+~{GdYj>)xD4R!bR$-GeJLpp7Yz| zThcWhz5+Dbovr+MJ6k6`dHJ-ZgPD4f&DSUEZt~Xt5dqorArn6$gQA-ZS;&Up#V8o#uOul3ZJ-@OJBIY~K}XjY|&wu`dws(W?>}6_u5i zCPpa@489?spxBuKR+em=M=y}AM~b;?SLn&&CEZH7n>r~1yoH5Nekyg8+-lagb9U}} zLQJ8nsY%mU`1jv`cMlIUL@9=)Zh1NMeL8_-L(6~tTDU|;@X?kfTkumKLm~aZQGo1x zW%ZdEO0mh`_uRKvSfF@+>UjF(@xfA$9F*sueL!wLu_2UKi;H5N=zWLtBK|R zE3uCY-PqLhqFl0#!DM-H*qK=^Lz}4_XUTbqrzeqd|M6u91FFHx7C)~K?{}!r$a(!p zJ3J^j)Npg_B2f7If8e)rpFd#meAqeQy(&^zo`v?*ePNQ}usruW>y=yN*}Xg~rdG7) z&noz*VFkwUEUNbc8n#uwdC}T>^3%SN5us%7mt8a`7hhlNme&)ub12*81WBX)DW!4~ z-j+BKpEsH(2*N5!6z&}#E%hC5dbna;=MEt;m8#*%HF_yuMT{`ekz({AnTs165h%2R z_ZFQZ+9ep3m68JW&*tXX?ydB|lLT?!NEEKSGM~Y!{8d0G99Nh_1Wf&0my)QW!pI+B=?E|M;(~--llbK*m;E$ za>b48%*H3rCLZpcZ6ZU$Vk(^^#m{#R16qC)OQEy7bWsRLjN4oU(z=AVd|eRT`FyhA z(wV=W4BM>F2ykAy)baaQefN(a+~~pgHf1rfu{wHs`Lz{?&c(MkI7LJ*XJ>v;oNkp= z|Ml%v^yqS*&$5%!RwzOOJyRjOPUiN^ASBxgLiZ&FASR5<9D0lN%{$VfO_SuKO)iu! z4tt5(?yOpCZk4Yj%Zqz0NkDC&ZB*j=6a_<=*{a38l5*Xuhl+&qvPddw$5%@7AVWG3 z1Nkm4gpgtCj3)MsVFNr~E7VFh&dh(dZLrWU_I9h3LK<7z+`>XP*nElgnvcMiwDe1sq_^?8e}b(52w9EaB*%r`l4n#r%tVU`?yc6SXA%#erwkN1gxeX-f+xZJ)_il zh_-5RO@8YLG8MC8!yZ)oY~5KNk#t$aeS1FXZTWTe%}_;UW$|u{u2G&Y`Xw2`gK!o> zvG$&hY@3Apg7+$Ow3ogQ9C_{H5xj1EOG=%>Nr4A#PWZI%85}p~5|+jC70K_NA^7~x z36SafpBKBc;*)OBc$h_8l|&&=t(CDwW&b)734R^nDU0hQF3;i!wVuP8h;aiRPo>9a zWRc{+D+W@N(^PkU|BNlZ_gl5GjqjNn`y2ed!$_thuzHora@xNDx)kXu@$6{Va+A5) z;7mO{NGwKjK7m!}Gb~N=Z6}R)M&mm8JNJ*?D$uV&rsd9b3U69RpkE|8g1BZTe&K-w z*WFdAbUDEfsgNMz?@a=vHDpa_d}1)4r3T}!{xj|`9YWVI=ifTRkg-SjD)f7*Os)ml z^Kh%X{75x1d-QA4I+|sEqNDQRsHZhUA=&&XBP7Igf2oXI86z$}=+me02i>|K0r?xb zgfAb;$OMryVNg)sjcnjS4;ld|Fd9zm*mA)!Ry+bYsscokF~{|)NU8BjGXBOF{-Eq^ zJ4k*F<9F{&w{8hB0Fylu~-#;RqbdK@A3=WRWeVX$|r4@?|qh5 z#4J@n+~VTts;k{CH!?OBq=d^AWpWdU3$KgbL?P%-d=m0=m+(f1k5m#@ewC3^nF0|x zYWg9XlTH zGIbu($PCdT&ToH(=#ZkMtu)UVh3?8|Q}ntAPk5HhMd1rLp|^T#xWH$*(p+Bt>!%HW z{BowosjxR=h4eA&d+*z3wtrg+Y}wk`VNkCah1eZk07Z`nFZi{O@&{#pdx@BTeB0QPxi#=j|J3Ha1g* zU`zSw1)!xU+jbJrEEh)vv8w7T4D{^={kO967`V{l{@k1V;D%v-w>DIsJ;fJ=x$sVh z;UYtf`@p0=bbYQnimGZ;nN}%citn%a*uEkqARsZ_)0PY5puszqS*r>W|9R(JgM6{+ zR_*=NhTRFjE&Jh^o+L+`cuDOwDwDUt8xh^z{h1~9Bh5Ec!6eUWHk=HQCZ%TOqKL!K zGXvfU33g7ub~_7pld-4gmA2{dhxXE|(!OP>V;awb0yf+>*4u?(-X>>zaLlcZC$V_{ zh<6plGNTnj=z9-+4}D_XmLycM;;H}~1WDxbczB>in$w$S%9F^qc|{rKnRaVk<*$=_ z;_fqVA@r?mlHM*{{y2W21u~*K%aquVRwJop9eiRGxJv- zc`e@iIxlh1@dNM(zjQDF7=&LCDb@bV6~Ol{(h1?~3UBLu{-8F$gTz3;m&<-z#^`6T z6{$v5+HyBUZl@wIFK*nmlD&UlK3xu6W%k^FqQKIhN=3~uQDwWetmdrSJ`&22<}Y+# zHy|1U&Gx}cS+}PLm`r(EY5zyPx&GQsW`1lfXHO73NP1o-$Wn3SZmHV692DRb$-OO7 zHX*HvwKC3*Ki(=FZsXoLDugn2_$=3?3^~)yVMR7c#f1iU8ql2EgNgtsc&I`z%|Uh?_$)HWFMABnoo+Sd{G7x(Ww zwZwZROtoHBzkh#e>@vP&K&&-e;Z+n0px@B%C>t(;LnZSXNb5wYfqvztIr=9 z7`Wbywx;30a_Q>xo4;-hm3C1g(IGJN$%EQNEdBYE=;M; z3EWm18$<(smEUToX)NiG0FDl%)QX=#$$tfE*gL|Lk zv%x!>iq_|H_P2ClTLxIOZ9YF}c=F7GEL>X&_WgBZgVkri1RFC<{spm42XF1{>*pSq z`Tt{=n2^9I`FlHMu+m0-_XKP<@r#5Dt`8E3p|Wv&dOLt$CBy0s#xYIsI#51{OJa&` zyNnU^hO7|)7ac7lPPCn)ZO77ZWwHOTQAtV3?JG(kHYu2~l05{{afmcydSYKSdO=2A z=@zgwG)jeD%_Em?27e-GS_c@J*fESr*g%1z2MY4_p=*sf#6pq=qv5328V8DM;79 z!?FeVPLEpVi;~DqQc}i1X^0Xk^3 zZTDuxmJPy+%?jR%AWpNk#-O_B3#Bg-5U?r*Xv=MKWFJe3z}HCD*K4{q?@3fFReZ&y zvIdb`UjgFj40)Z3gPkHG_IU8Jp@Hya!0+g-jY^)jMLmFkKb*>-oU$*dj`{W-nK7Fg z_6$@<2(6W>4Bj!vp~~o<2t?~_8kKoFWSGt~XTjw2GaDblo*reB*AO)KW`Yj;mP=)r z-)g_M}ZE^zoCr{i=OTUtx5!n$9yxpY9wLIGvNB4^^A=}v&UugAu#er$V>w9 zC##3`zW|Dx@uH2^rm`a%PI4vN97pJxFjyKSkcP>rWRU!tunuTZ^dZDZ-pC4fxV=)hzH-&>SKsd>=e3)_AzdlIBW3Kq!Mzopd)62Q$ z8PbxQL8)Iz2xRhSoY{jO;c2=#m z_I0Ev6x&Tc{}5tL9Vq49Rxe_4tJ>S!yVz-wmO;!_kug-EE4@v_@c#Yh0pN#4>N;&t zWauR+xN9AT{%$#Lam55Rs_TQHE zvO{`#zH&e>)IEpJwu!KYwXBy{88ppkD;U_vBH}pcgy_PP8JcLC?$vF0zN-_N~MH}s#(=C0NInW zvYXaVLIUP!>ehn@Vl(GZSXH_ThVn!gCBbX062Zu}T#Alpc#@M}p$F?yAIj7xq%NHV zX)!BI_o)kPH*zxaj<(?UY+ITXE-oc zO@`0*3|BqjiKd{R32coM*HsIWs}ErSz%i<2Y;2FY2xLVNNz$hhs;V*h;4+R)c~y05ByTAXfvDCfF*7&P@4me7E zv%Gpnzw67@I5m?(=-xkXZ2Yj<@}vgKS0whWi}b%_gZuPplon0AL1#Djw!G9-SgXu6 z4JZE@xc^&MZS9{U{CTJ5&d{gN zO}o2j=l2xYyMGCB z@Hv8ei;3+#uk;_LN&eDL#2{m z(e(zE<{6dCdX26TLuX9Ytu;O;+I)BIZTti z0%iL8M17)Pek=Fi{rMsF=DD$WRc8gqfXcEi15fQC@xoJ8yB!`LnHV)Iy!^SxkCO$w66^4B9d5$!)tJh&SX1< zWK2>hPz((Y76M(OYj3Z7C)PG5M$jW0Wji_|`Is@MuuwBEFAx5xX=Y~Dy>Mn}B#YOw zh4vW1$7dG?9{hg&?RmOI_6O16o3!JJkNeO5>E3|wif|~47c0b8a5Y< zui*B*mxsM3?p`ULNROSodqs9AziN&a=+fD-PbUB^8kp4k*jwJcQ&-Z*Lv~fq))sq# zr$Pr)EE@6!q6;h9>KyaZ06nBSlOs@ciGzy*Q5Y!C|3UPBgbKWN}D#KDxG4<^ApW6u0TtE*cxPj&V7n$;PIx z4=%qZUCZ4U`ZXPYyyK0RhBhA!l~~%Z_6TBpE++&0e8<^Yeg2n-sOT(}^kJ4$V(l;FaAW4t?`%!X}5oEar zwK@anCH-EwxQ|<`BM3jFni&TFZfKEdX zk%kUb8^@0LD-REwUJ8LMh~hT=DN90>gvy{haPCcOw}~4 z5Jn(yQ0QS63$zhl0^ahSHXd#Nw-`$RfbKf^w@BO-7Ib!QcIPQ7lT;{mi#=QH5RWV= zu`C&TbQ;O!yLSITyfks736GQCa2X<)ePUN`S$s9 za`!2~FXyO4njaYD(q;WtFa_=Cwv-_(=`ZRc=D(ZU@r(v(YVVG+d2Ak;-C3zV8Qn{!${ zed@gnZc`x3({ipU*W&QDam&ok?tJw06P6Ca)78}!DBEv_LTu<*(c0+n4?yfX1Pa01 z1kq#QB2%xkFsY>Ty^YgX**atp>_ig|+0nGpbMANjK_;8%aBhXmFOT^Tzcq39s?8+# zCw>i<*xTG0?nnvRSl3p+Q@2|(OF{+3)y0Zqzkqf2_kS40z4HKN+vKy{Fnv`_(n{wP z9u#+81W=4AcKPMKIJi**m7O^SyBbs#S*c@tT|Qe29lIX(-JR#8s5ZWl&I_I81Tdn~ z>CMiMrxCs*Y(zC!y=Gw_{YC)iCa^1@Sz==_y+V$ zyh`@ZMjrLq!G`qNp=X1TD9|;DYdvV9?JF>j_?8KX?_zTHxxL@IY>F7}qdpz5YHwV6 z2aJj)PH^&GqH#CJSLg+qR*xu05oHe!-y&w8nBWg8^!T-&bahF~1sx1>3RE0nH}X>YB49jn1>04Ts#_$@wPM|W0~yb=n!K>TZagoedY_zph6I;cmX9FKQ0HvMVdE?zQS!SwB+7gg@tprM?7%X!l~V zi1{>eO%-0gLd6SPxQ&P)|ID4!yc&M{D6x1o2I#cp=;doDD=Q!ERndiPGl>&MPnbSGcHL4-!cWZ3sV z!jRO#X9&al;K%t$m6ae43VN~(pi=^!6rR&wxQ2M?rRc7PC(uMy%`MOep=BJILM@KR zyoTEkneLP8q{{Ek(NB$K*ubT;QBYyk@wCIoDsMBm+7_Ld~Y`JM;iNKi~Q0xK9aG8STh z(J5jq$ld-r^71CgR8uX>N*H!kDb~7hnE&|m7(bSAD_MYq2wkjL61RX|nd^)e@fdVB z_1eEBa#?r=Mv5ha$CC6gM-l@c3<5LqCr%2H&LGBz_%1V9&aW$ zF0D2t9v*eR&3X-T;INXr|9Ls?KHeIUa4zf zaNZ-}1%A&=)izZO3U8IqeS6gxsc*^(u(ND*5VWj`vk0G%Orm}JOKiZchZTB z3~EJ-COCnSS}ZK|3Cw_n&f%Gy1h+IE86(s5osT_?nuTqXIrrwVu=z_OJdJ6N*wxU` zkzF0H6RWaiVQWZ7C=T1`2)z6woW<_Vk9f6#aKm*MZP!^|e|y&^&O3Y*Vo zX!$uSk{`|juu|kfQVz4_&sppl@*ygzJv^O|b)-d8k$}v1R!jmfLCK1QY+Vqrc6E1G zv^Ju6A6Dcx%F*sS1QL9*NCWdic$dKMhE%siZZ@~^wg3DoY6}gy*NNt5)~;y&L90ry z`m_cPm*dO9fau6ESV<3ZMC|oyk0$SmINMV+)w#ooX*_T0jca6{#CX#FK5L zP{WhGy_pw}4E{Ss^^yPjWhMIE?yx`Y5H$PVP_4g!JFe+)cO%oo&tXW9`AnF#q3sJ& z@cmb3JA_z@J~Nwnepz|;{TJ-XL?hPfQQti2u-R^-vgSMta|zuGeWV0pe9vELQbllF z#}D7A9D=@~oc+f;cxJMgwh(VB3%3#BT}1T7(owDf6eB|aq+8vL+6RT$n|EwB*h+{D>OwGU)px{Em9b%@KtX= zDs>#jysmdIH>ucro+Dzv=|D*poe47bp;D)g7kp9$o28{JOl2QZuLo>l+nN?V?Ln2a zJFD&=_xc`0Q_pZxYR5zV+rafC;H6xOSO`S_$u{>|RDTMca2MYQuKl3@>zjHQ$}lPo z$gB9PUJ2~#QgYIJJ?g5z4_BoMPz?&c?Qo_-fX)gy$5hN&uQH7_LJ1(+K# zEq{J-!4^P|ot;BB6XQ-E8GV1j^XE##uJemA{1(aimHveX+uxVZNi9tXwRSgS-$NIy z&tqJkDudY-vW@-(|4I8d@5S&G;yTS)QtEiM3?=0z9V4SCjQUO+w7oFv{VAb$;0Pcb zO(7-aSg#!2Q<6$lw@H*#hVw_n3|-K8Zg|Dio^N_}V{?cuf>8*t0Pn~E{ZGmPp-)x_ zQLDuc$Y@t3(Lai}>R$M_S9E+qbu5>zG+V$^jehUi4^~*Oy<G1K&k4C(BFI81dj~z}d$x-oD zT!(U{PQ3bH*IwLZ?*l3e5F+wh;FB`IbCQAdCAGg11Urn@GL|O2Ff?dXxA~%;R9WgR zoJ)ZtM3XG_Y^O3_=Vs>8_X=n=2tO{*{y&btp~?0AUHV-$uO<9#DKWjXb4uKICMgvg!hL8~M#F7DCs^@VW2r&D!G>{sG>(OMsuL(7MODs!&=gzQ(kYHa?f#Gdkw zZw*WRDFT^Rw;SuiGd6bL^YhgtSHC->PTAE4f{SUe^ zE@Hf?A%XaQHR)*_oi{TYP+m2zB51>afngDoiosys488E_^C~VQ_s&)3tCR(S!S32x zTjQ*IV9jof0&U>gQWAoXinqlhhW-&WU5NL74?LHKzfa@|+;xzlBw!35nPbgc{ed zZl3Kt_T`bx-P*NCaC~F3$$higFh6UPu=^U(q`Pj0z#A)%NOZJ;MA-;ze53!LR$nDU*1JR0& z(yKa#hG}1wot_V7R8}g79*l>72xKC;4K3yvagP{)`*H|r^SLzsii>Q3|M);A&Ub9e z*kkF(eeX?d2BE`wVuFve-`&4SfBE#EjdxArJ*iS@LF`8dq)Vs-@DF7>AJwvZ5a6${ z)*4#?q%)}ZA{~e9>>YcM=CRYFT?zSnb6Fb3I5(_-gAZ{0*V^o|PYTHs!Yi(R~LRPoO(R7n53`S>(yeTre4Au1a40_kf8y%nqog9k}@q;Xt(9%@o3K9P83o=L>16HX-^5* z^Xo57Q3#!>_8RR#dH{%)1ECM0^>6$90u*GdtE&D$03lLtW**m~W4}HljUF@8UDsM1 z(s~@Lp)z?B1vQk+UUHDwdZNkBuIA7|EfiY;-a?TZhu>s`SUxONj(*0PDvDe*6h)IUil zI#?Q?e;3{scae(_BN{7bb>fD)v=1Q7afD$#@bh6q>zmy7sKu>2UPUtaEkIJgg)Y+a z8y!qEPaUy#tQodXiOg$r#KAlX=fUz|$ zN>ZFVYl_tfdyRnMyHK@t2c7M-66_=*C;=*5e?`*)Z%Vj zzG;OB1hT^aHP>9~cl+o$5KCgm@VYb333uy9b>kW!{07FVY1VzCauk@qPHIYo@B^X% zbK7l22x0YR!`?SMp|Oe2V}peH6N9;S#9&ugY~hjjC-4Kb-Lv7$;rv>Qov+kQh)yZL?;Xzx*nX+U@_Ks zvZ=JYw>KTmLmQTgtbB4*?!82Os*d0K%CKArto|3^I-aC|BSdT6zh91;?Ju;%q`Lg# z2;9udq2mCW&3Bd*qAbbxyOd9O$fKZtV&5f4F7-Bu5xP=vn3z%8F7t#cvWOM1hztFN zrWj${RT@m{)`*`1#=VYI8B)_gjJRWkQ^gJ(>O|-|l`ybycA=-F)M+&XENb}TqXFs8 zLWlr1?R~lmmJ@CC-aC?v@d}v0xnY-S(+XS)lRoH00OG87CSqHF<#9M?c8=h{^>>6ugAzhxH9L zQtbMls-WboCRPJJha))|v7*Hv=sJ0T@74B+IRW<$C*%Qui<@x$jGSKar1qXygWQ7YJC0jO?qzZ z7#tRuO^a5>^j4MIwL|TFbiz%s22SzZj7bL}00$!bYFgZ!f$p3pF7ArIibzQbp7D7G zCFweco!xho=*?85rp!W?9VpFqXrpObT0Zt)sU7Vj4_J}b#5oLA$YX^4c3-*&K|CkC z2~vrhc2G6CszE%OYQ}P*k)zt~d)tL?aKJx7U=5{-DE$C6@7T+#NAD)TD?J*2uENeQ z0tpDeyO1}~NFdrB&Zw?d#Z3IZdkjj#%L2n+Et>SajI~0Y?_a&hSb)l^hxdUTV8)V~ z!`V2BvNW&Y(yyDUF%X2ku{%H!>3O-q#U4+Y_*Q?z>sEksN`j*z7#(fxp=BwEq-^N= z(65Yy5U~V5@=vb34$Ld6h`2hh#Vm+D^ZOof#oJINzVm3hjqU{BycAS-wq#gX)ztkr zd>#uhk!d2AkyD6W6jBo(=bR!PauTb9*o!*xG7?N1c9tOU=PSx4k?9}zvlE346RVc} z^Nin%7cb_%x3N2TbXpidBCy>ho-MI7FVBN=ym9??5D!sB3}LnUzX}M+H{UJD$kYvg z{02kbM%elH@3m`pzp8um4R2)vEe;dAer9Q8cX*H2KE|YFb&YL#yOg11JVi2ycG4w!duKTD~T1JtrI)9St9Y zQ&L)dX9$|*Wu7IzQs(J(VAUCSuZx(gIMqIBcd0b8y5J+*l%An;4B?|ts;vO98m8B5 zp>qjdsauOvNpy)SZ5M^1=iaJ7J^{(Bt>@#2N=eA;gp?K0kVRgS z;teAl!Ft^YAN~XEK98Ae1gfEk+r!;G6WDqX@a?w8d(B2hn{@|CuWADMUs6^!`--x_ zej}D^a>HAQ9%M{cbluyYe98#q=H%_=Sgtn5tUo@))eH^|!oFK!E*AX;NJ5e@+M)`>Y6K8yVV>|R|21u1ns6yIp1>Isy3bqC@ajjBoB!;e3*;<1#){W`nTT~fC~SjcQ$fX!aJT^-3jHqBw{UaD(ztAY zVvH4$x7Gct)>D*<7?Q3_tObgtWs=sRNIihczz~Da9k4j!eo`H