diff --git a/Makefile b/Makefile index ff2dfdc..35fd072 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: build clean test docs lint +.PHONY: build clean test check docs lint examples build: pip install -e . @@ -13,8 +13,15 @@ clean: test: python -m pytest tests/ -v +check: test + docs: python3 docs/generate_figures.py lint: ruff check src/ tests/ examples/ + +examples: + python3 examples/layouts.py + python3 examples/tensor.py + python3 examples/viz.py diff --git a/docs/analysis_api.md b/docs/analysis_api.md index 496118e..0d43f57 100644 --- a/docs/analysis_api.md +++ b/docs/analysis_api.md @@ -288,3 +288,84 @@ explain(complement, Layout(4, 2), 16) # complement = (2, 2) : (1, 8) # image(complement) = [0, 1, 8, 9] ``` + +## F2 Linear Layout Matrix + +`to_F2_matrix(layout)` converts a layout with power-of-2 shapes to its +binary matrix representation over GF(2). The layout mapping becomes +`offset_bits = M @ coord_bits (mod 2)`. + +This is the "linear layout" representation from arXiv 2603.02298 Section 2.4.4. +Swizzles (XOR operations) are linear over F2 and fold into the matrix. + +```python +from tensor_layouts.analysis import to_F2_matrix +``` + +### Identity (column-major) + +A contiguous column-major layout is the identity map over F2: + +```python +to_F2_matrix(Layout((4, 8), (1, 4))) +# [[1, 0, 0, 0, 0], +# [0, 1, 0, 0, 0], +# [0, 0, 1, 0, 0], +# [0, 0, 0, 1, 0], +# [0, 0, 0, 0, 1]] +``` + +### Row-major (bit permutation) + +Row-major swaps the row and column bit groups -- a permutation matrix: + +```python +to_F2_matrix(Layout((4, 8), (8, 1))) +# [[0, 0, 1, 0, 0], coord bits: [row0, row1, col0, col1, col2] +# [0, 0, 0, 1, 0], offset bits: row bits moved to high positions +# [0, 0, 0, 0, 1], +# [1, 0, 0, 0, 0], +# [0, 1, 0, 0, 0]] +``` + +### Swizzle (XOR connections) + +Swizzle(3,0,3) XORs offset bits 0-2 with bits 3-5, adding off-diagonal +1s to the identity: + +```python +to_F2_matrix(compose(Swizzle(3, 0, 3), Layout((8, 8), (8, 1)))) +# [[1, 0, 0, 1, 0, 0], col0 = col0 XOR row0 +# [0, 1, 0, 0, 1, 0], col1 = col1 XOR row1 +# [0, 0, 1, 0, 0, 1], col2 = col2 XOR row2 +# [1, 0, 0, 0, 0, 0], row0 = row0 +# [0, 1, 0, 0, 0, 0], row1 = row1 +# [0, 0, 1, 0, 0, 0]] row2 = row2 +``` + +### MMA register mapping + +The SM80 16x8x16 C accumulator layout maps (thread, value) bits to +(m, n) coordinates of the output tile. The F2 matrix reveals which +thread and value bits control which output dimensions: + +```python +from tensor_layouts.atoms_nv import SM80_16x8x16_F16F16F16F16_TN +c = SM80_16x8x16_F16F16F16F16_TN.c_layout +# ((4, 8), (2, 2)) : ((32, 1), (16, 8)) +# Thread bits T0-T4, Value bits V0-V1 -> m0-m3, n0-n2 + +to_F2_matrix(c) +# T0 T1 T2 T3 T4 V0 V1 +# m0 [ 0, 0, 1, 0, 0, 0, 0] m0 = T2 +# m1 [ 0, 0, 0, 1, 0, 0, 0] m1 = T3 +# m2 [ 0, 0, 0, 0, 1, 0, 0] m2 = T4 +# m3 [ 0, 0, 0, 0, 0, 0, 1] m3 = V1 +# n0 [ 0, 0, 0, 0, 0, 1, 0] n0 = V0 +# n1 [ 1, 0, 0, 0, 0, 0, 0] n1 = T0 +# n2 [ 0, 1, 0, 0, 0, 0, 0] n2 = T1 +``` + +Reading: threads 0-3 (T0, T1) select N-dimension column pairs, threads +within each group of 4 (T2-T4) select M-dimension rows, and the two +value bits split across M bit 3 and N bit 0. diff --git a/docs/generate_figures.py b/docs/generate_figures.py index 9e0402c..23f9b09 100644 --- a/docs/generate_figures.py +++ b/docs/generate_figures.py @@ -33,6 +33,9 @@ import shutil from pathlib import Path +import matplotlib.patches as patches +import matplotlib.pyplot as plt + from tensor_layouts import Layout, Swizzle from tensor_layouts.atoms_nv import SM80_16x8x16_F16F16F16F16_TN from tensor_layouts.layout_utils import tile_mma_grid @@ -49,6 +52,105 @@ IMAGES = Path(__file__).resolve().parent / "images" +def _generate_intile_oftile(path: Path) -> None: + """intile/oftile coordinate diagram: manual index math vs layout algebra. + + Three panels on a 4×8 matrix tiled by (2,4): + Left: cells show linear index i + Center: cells show 2D index (r,c) + Right: cells show intile coords — the output of logical_divide + Tile coloring (shared across all panels) shows the oftile grouping. + Formulas below each panel explain the conversion. + """ + M, K = 4, 8 + tm, tk = 2, 4 + tile_colors = { + (0, 0): "#DBEAFE", (0, 1): "#FEE2E2", + (1, 0): "#D1FAE5", (1, 1): "#EDE9FE", + } + + fig, axes = plt.subplots(1, 3, figsize=(18, 5.2)) + + def _draw_grid(ax, cell_text_fn, title, subtitle): + """Draw M×K grid with colored tiles and per-cell text.""" + for r in range(M): + for c in range(K): + om, im = r // tm, r % tm + ok, ik = c // tk, c % tk + y = M - 1 - r + rect = patches.Rectangle( + (c, y), 1, 1, + facecolor=tile_colors[(om, ok)], + edgecolor="#D1D5DB", linewidth=0.5, + ) + ax.add_patch(rect) + ax.text( + c + 0.5, y + 0.5, cell_text_fn(r, c), + ha="center", va="center", fontsize=9, + color="#374151", family="monospace", + ) + # thick tile borders + for i in range(0, M + 1, tm): + ax.plot([0, K], [i, i], color="#1F2937", lw=2.5, + solid_capstyle="butt") + for j in range(0, K + 1, tk): + ax.plot([j, j], [0, M], color="#1F2937", lw=2.5, + solid_capstyle="butt") + # oftile margin labels + for om in range(M // tm): + y_c = M - om * tm - tm / 2 + ax.text(-0.3, y_c, f"oftile\u2080={om}", ha="right", va="center", + fontsize=8, fontweight="bold", color="#7C3AED", + family="monospace") + for ok in range(K // tk): + x_c = ok * tk + tk / 2 + ax.text(x_c, M + 0.15, f"oftile\u2081={ok}", ha="center", + va="bottom", fontsize=8, fontweight="bold", color="#7C3AED", + family="monospace") + ax.set_xlim(-2.5, K + 0.5) + ax.set_ylim(-1.8, M + 0.8) + ax.axis("off") + ax.set_title(title, fontsize=10.5, fontweight="bold", pad=10) + ax.text(K / 2, -0.3, subtitle, ha="center", va="top", fontsize=8, + color="#6B7280", family="monospace", linespacing=1.6) + + # ── Panel 1: linear index ──────────────────────────────────── + _draw_grid( + axes[0], + lambda r, c: str(r * K + c), + "Linear index i", + "row = i // 8, col = i % 8\n" + "intile = (row % 2, col % 4)\n" + "oftile = (row // 2, col // 4)", + ) + + # ── Panel 2: 2D index ──────────────────────────────────────── + _draw_grid( + axes[1], + lambda r, c: f"{r},{c}", + "2D index (row, col)", + "intile = (row % 2, col % 4)\n" + "oftile = (row // 2, col // 4)", + ) + + # ── Panel 3: layout algebra ────────────────────────────────── + _draw_grid( + axes[2], + lambda r, c: f"{r % tm},{c % tk}", + "logical_divide((4,8):(8,1), (2,4))", + "result: ((2,2),(4,2)) : ((8,16),(1,4))\n" + "mode 0: (intile\u2080, oftile\u2080)\n" + "mode 1: (intile\u2081, oftile\u2081)", + ) + axes[2].text(K / 2, -1.45, "cells show (intile\u2080, intile\u2081)", + ha="center", va="top", fontsize=9, fontweight="bold", + color="#2563EB", family="monospace") + + plt.tight_layout() + fig.savefig(path, dpi=150, bbox_inches="tight") + plt.close(fig) + + def main(): IMAGES.mkdir(exist_ok=True) @@ -150,19 +252,8 @@ def main(): title="SM80 16x8x16 C \u2014 2x2 atoms", ) - # -- show_layout (no title) -- - draw_layout( - layout_8x8, - IMAGES / "show_layout.png", - colorize=True, - ) - - # -- show_swizzle (no colorize) -- - draw_swizzle( - layout_8x8, - Swizzle(3, 0, 3), - IMAGES / "show_swizzle.png", - ) + # -- intile / oftile (applications.ipynb §3.3.5) -- + _generate_intile_oftile(IMAGES / "intile_oftile.png") print(f"Generated {len(list(IMAGES.glob('*.png')))} figures in {IMAGES}") diff --git a/docs/images/draw_composite.png b/docs/images/draw_composite.png index 892ce80..4240301 100644 Binary files a/docs/images/draw_composite.png and b/docs/images/draw_composite.png differ diff --git a/docs/images/hierarchical.png b/docs/images/hierarchical.png index dd12516..c3a75b6 100644 Binary files a/docs/images/hierarchical.png and b/docs/images/hierarchical.png differ diff --git a/docs/images/intile_oftile.png b/docs/images/intile_oftile.png new file mode 100644 index 0000000..62622d1 Binary files /dev/null and b/docs/images/intile_oftile.png differ diff --git a/docs/layout_api.md b/docs/layout_api.md index 0857981..f190912 100644 --- a/docs/layout_api.md +++ b/docs/layout_api.md @@ -309,16 +309,7 @@ swizzled = compose(Swizzle(3, 0, 3), Layout((8, 8), (8, 1))) ## Tensor -`Tensor(layout, offset=0)` combines a Layout with a base offset (the -pointer equivalent from CuTe C++). Supports slicing: - -```python -t = Tensor(Layout((4, 8), (8, 1))) -t(2, 5) # 21 — same as layout(2, 5) -t[2, :] # Tensor(8:1, offset=16) — row 2 -t[:, 5] # Tensor(4:8, offset=5) — column 5 -t[2, 5] # 21 — fix all modes, returns int -``` +See [`docs/tensor_api.md`](tensor_api.md). ## Tile diff --git a/docs/tensor_api.md b/docs/tensor_api.md new file mode 100644 index 0000000..0e747c7 --- /dev/null +++ b/docs/tensor_api.md @@ -0,0 +1,328 @@ + + +# Tensor API + +A `Tensor` combines a `Layout` with a base offset and optional storage. +It is the Python equivalent of CuTe's `(Pointer, Layout)` pair. + +For layout algebra see [`docs/layout_api.md`](layout_api.md). +For visualization see [`docs/viz_api.md`](viz_api.md). + +## What is a Tensor? + +A `Layout` is a pure function from coordinates to offsets. A `Tensor` +adds two things: + +1. **A base offset** — an integer that shifts every computed offset, + modelling a pointer into a larger memory space. +2. **Optional storage** — any indexable object (list, numpy array, + torch tensor, etc.) so that element access returns actual data + values rather than raw offset integers. + +When storage is absent the Tensor is purely algebraic and behaves +exactly like a `(offset, Layout)` pair. When storage is present, +indexing reads and writes go through the layout mapping to reach +the correct position in the flat storage buffer. + +## Construction + +| Form | Description | +|------|-------------| +| `Tensor(layout)` | Algebraic, offset 0, no storage | +| `Tensor(layout, offset)` | Algebraic with explicit base offset | +| `Tensor(layout, data=buf)` | Data-backed, offset 0 | +| `Tensor(layout, offset, data=buf)` | Data-backed with explicit base offset | + +The storage must satisfy `len(data) >= cosize(layout)`. It is stored +by reference (no copy). Storage that is too small raises `ValueError`. + +```python +from tensor_layouts import Layout, Tensor + +layout = Layout((4, 8), (8, 1)) + +# Algebraic +t = Tensor(layout) +t(2, 5) # 21 + +# Data-backed +buf = list(range(32)) +t = Tensor(layout, data=buf) +t[2, 5] # buf[21] → 21 +``` + +## Coordinate Mapping — `__call__` + +`tensor(i, j)` always returns the **memory offset** (an integer), +regardless of whether storage is present. For swizzled layouts the +swizzle is applied to the total linear offset: + +``` +tensor(i, j) = swizzle(base_offset + crd2offset((i, j), shape, stride)) +``` + +This is unaffected by storage — use `__call__` when you need the raw +offset, and `__getitem__` when you want the data element. + +```python +t = Tensor(Layout((4, 8), (8, 1)), data=list(range(32))) +t(2, 3) # 19 — always the offset +t[2, 3] # 19 — data[19] (happens to equal 19 here) +``` + +## Element Access — `__getitem__` + +A bare integer performs **flat 1D evaluation** on any-rank tensor: the +index is decomposed via `idx2crd` into the natural coordinate and the +offset is computed. This matches CuTe C++ `Tensor::operator()(int)`. + +| Key | Returns | +|-----|---------| +| `tensor[i]` | Flat 1D evaluation — data element or offset | +| `tensor[i, j]` | All modes fixed — data element or offset | +| `tensor[i, :]` | Slicing — sub-Tensor (see [Slicing](#slicing)) | + +When storage is present, fully-resolved accesses return `data[offset]`. +When absent, they return the raw offset integer. + +```python +buf = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345") +t = Tensor(Layout((4, 8), (8, 1)), data=buf) +t[0, 0] # 'A' — buf[0] +t[0, 1] # 'B' — buf[1] +t[1, 0] # 'I' — buf[8] +t[3, 7] # '5' — buf[31] +``` + +### Flat 1D evaluation + +`tensor[i]` decomposes the flat index `i` into coordinates via `idx2crd`, +then computes the offset — even on rank-2+ tensors. This is consistent +with `__setitem__` and enables the canonical copy loop: + +```python +def copy(src: Tensor, dst: Tensor): + assert size(src.layout) == size(dst.layout) + for i in range(size(dst.layout)): + dst[i] = src[i] +``` + +Because `src` and `dst` can have different layouts (e.g. row-major vs +column-major), `copy` automatically remaps elements through each tensor's +layout function: + +```python +row_major = Layout((4, 8), (8, 1)) +col_major = Layout((4, 8), (1, 4)) + +src = Tensor(row_major, data=list(range(32))) +dst = Tensor(col_major, data=[0] * 32) + +for i in range(size(row_major)): + dst[i] = src[i] + +# Same logical element at every coordinate: +assert src[2, 5] == dst[2, 5] +``` + +To slice mode 0 (the old `tensor[i]` behavior), use `tensor[i, :]` +explicitly. + +## Element Assignment — `__setitem__` + +Scalar writes are supported when storage is present and mutable: + +```python +t[2, 3] = 'X' # writes buf[19] = 'X' +t[2, 3] # 'X' +``` + +Only fully-fixed coordinates are supported (all modes must be +integers). Attempting to write without storage raises `TypeError`. + +## Slicing + +Slicing fixes some coordinates and keeps others free. The result +is a new Tensor with a reduced layout and accumulated base offset. + +```python +t = Tensor(Layout((4, 8), (8, 1))) + +t[2, :] # Tensor with offset=16, layout=(8,):(1,) — row 2 +t[:, 5] # Tensor with offset=5, layout=(4,):(8,) — column 5 +t[2, 5] # 21 — all modes fixed, returns int (or data element) +``` + +Sub-Tensors produced by slicing **share the parent's storage** (view +semantics). Reading or writing through a sub-Tensor accesses the +same underlying buffer: + +```python +buf = list(range(32)) +t = Tensor(Layout((4, 8), (8, 1)), data=buf) + +row2 = t[2, :] # sub-Tensor viewing row 2 +row2[3] # buf[19] → 19 +row2[3] = 999 # buf[19] = 999 +t[2, 3] # 999 — visible through parent too +``` + +### Hierarchical partial slicing + +For layouts with nested (hierarchical) shapes, partial sub-coordinates +can be sliced using `None` as the free-dimension marker: + +```python +layout = Layout(((2, 4), 8), ((1, 16), 2)) +t = Tensor(layout) +t[(1, None), :] # fix first sub-mode of mode 0 to 1, keep rest free +``` + +## Storage + +### The `data` property + +`tensor.data` returns the storage reference, or `None` for algebraic +Tensors. It is assignable: + +```python +t = Tensor(Layout((4, 8), (8, 1)), data=list(range(32))) +t.data # [0, 1, 2, ..., 31] +t.data = list(range(100, 132)) # swap to new storage +t[0, 0] # 100 +``` + +The new storage must satisfy `len(new_data) >= cosize(layout)`. +Assigning `None` removes storage and returns the Tensor to algebraic +mode. + +### View aliasing + +Sub-Tensors hold their own reference to the storage object. +Reassigning `parent.data` does **not** update existing sub-Tensors — +they keep the old reference. This matches numpy/torch view semantics: + +```python +buf = list(range(32)) +t = Tensor(Layout((4, 8), (8, 1)), data=buf) +row = t[2, :] # row holds a reference to buf + +t.data = [0] * 32 # parent now points to new storage +row[0] # still reads from buf → 16 +``` + +### Storage can be larger than cosize + +The storage may be larger than `cosize(layout)`. Only offsets within +the layout's image are accessed; extra elements are simply unused. +This is useful when multiple Tensors with different layouts share the +same underlying buffer. + +## Views — `view()` + +`tensor.view(layout)` returns a new Tensor that shares the same backing +storage but uses a different layout. The new layout's cosize must not +exceed the storage length. + +```python +buf = list("ABCDEFGHIJKLMNOP") +t = Tensor(Layout((4, 4), (4, 1)), data=buf) # row-major + +# Flat 1D view of the same backing store +flat = t.view(Layout(16, 1)) +flat[0] # 'A' +flat[15] # 'P' + +# Column-major view +col = t.view(Layout((4, 4), (1, 4))) +col[0, 0] # 'A' — same element, different traversal order + +# The view shares storage — writes are visible everywhere +flat[0] = 'Z' +t[0, 0] # 'Z' +``` + +This is the Python equivalent of CuTe's `make_tensor(tensor.data(), new_layout)`. +It is useful for inspecting the physical storage order of a tensor: + +```python +src = Tensor(Layout((4, 8), (8, 1)), data=list(range(32))) +physical = src.view(Layout(len(src.data), 1)) # flat view of backing store +``` + +Calling `view()` on a Tensor without storage raises `TypeError`. +A layout whose cosize exceeds the storage length raises `ValueError`. + +## Visualization + +When a data-backed Tensor is passed to `draw_layout`, cells are +automatically labeled with data values instead of raw offsets: + +```python +from tensor_layouts import draw_layout + +buf = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345") +t = Tensor(Layout((4, 8), (8, 1)), data=buf) +draw_layout(t) # cells show A, B, C, ... +draw_layout(t, cell_labels="offset") # override: show raw offsets +draw_layout(t, cell_labels=False) # suppress all labels +``` + +## Equality and Hashing + +Two Tensors are equal if and only if they have the same layout, the +same offset, **and** the same data contents (element-wise comparison): + +```python +a = Tensor(Layout(8, 1), data=[1, 2, 3, 4, 5, 6, 7, 8]) +b = Tensor(Layout(8, 1), data=[1, 2, 3, 4, 5, 6, 7, 8]) +c = Tensor(Layout(8, 1), data=[8, 7, 6, 5, 4, 3, 2, 1]) + +a == b # True — same contents +a == c # False — different contents + +d = Tensor(Layout(8, 1)) +a == d # False — one has data, the other doesn't +``` + +`__hash__` is based on `(layout, offset)` only (data is not included). +This is correct per the hash contract: equal objects always have equal +hashes, and collisions when only data differs are harmless. + +## Properties + +| Property | Type | Description | +|----------|------|-------------| +| `layout` | `Layout` | The underlying layout | +| `offset` | `int` | Base offset in linear (pre-swizzle) space | +| `shape` | tuple | Shorthand for `layout.shape` | +| `stride` | tuple | Shorthand for `layout.stride` | +| `data` | indexable or `None` | Backing storage (read-write) | + +## Methods + +| Method | Returns | Description | +|--------|---------|-------------| +| `view(layout)` | `Tensor` | New Tensor sharing storage with a different layout | diff --git a/docs/viz_api.md b/docs/viz_api.md index 78dc71e..69e15a2 100644 --- a/docs/viz_api.md +++ b/docs/viz_api.md @@ -51,8 +51,9 @@ Every `draw_*` function accepts a `filename` parameter: | `"out.png"` | Save as PNG (raster) at specified `dpi` | | `"out.pdf"` | Save as PDF (vector) | -The `show_*` functions always display inline and return the matplotlib -`Figure` for further customization. +When `filename` is `None` (the default), figures are displayed inline +in Jupyter notebooks and the matplotlib `Figure` is returned for +further customization. ## draw_layout @@ -82,6 +83,8 @@ draw_layout(Layout((8, 8), (8, 1)), title="Row-Major 8x8", colorize=True) | `num_shades` | `int` | `8` | Number of distinct grayscale shades | | `flatten_hierarchical` | `bool` | `True` | Flatten nested shapes to 2D grid | | `label_hierarchy_levels` | `bool` | `False` | In nested hierarchical mode, annotate hierarchy levels at tile/block granularity; label colors match boundary colors | +| `cell_labels` | `bool`, `str`, or `list` | `True` | Controls cell text: `True` = full detail, `"offset"` = offset number only, `False` = no text, list/tuple = custom labels indexed by offset | +| `interleave_colors` | `bool` | `False` | Reorder rainbow palette so consecutive indices share hues (blue, lt blue, green, lt green, ...). | ### Coloring @@ -163,6 +166,31 @@ coordinates, e.g. `row[0]=...`, `row[1]=...`, `col[0]=...`, `col[1]=...`. For examples where the hierarchy itself is central to the lesson, enabling `label_hierarchy_levels=True` is recommended. +#### Cell Label Modes + +The verbose row/col/offset labels can be distracting on larger grids. Use +`cell_labels` to control what text appears inside cells: + +```python +hier = Layout(((2, 2), (2, 2)), ((1, 4), (2, 8))) + +# Offset number only — hierarchy boundaries and axis labels are preserved +draw_layout(hier, flatten_hierarchical=False, label_hierarchy_levels=True, + cell_labels="offset") + +# No text at all — just colored grid with hierarchy boundaries +draw_layout(hier, flatten_hierarchical=False, label_hierarchy_levels=True, + cell_labels=False, colorize=True) + +# Custom labels indexed by offset value +import string +draw_layout(hier, cell_labels=list(string.ascii_uppercase[:size(hier)]), + colorize=True) +``` + +`cell_labels` also works in flat mode (`flatten_hierarchical=True`), where +`False` suppresses offset numbers and a list provides custom labels. + You can push this further with deeper asymmetric hierarchies to test how the level labels behave when cells become small: @@ -323,22 +351,64 @@ draw_composite(panels, "comparison.png", | Parameter | Type | Default | Description | |-----------|------|---------|-------------| -| `panels` | `list` | required | List of Layouts to draw | -| `filename` | `str` | required | Output path | -| `arrangement` | `str` | `"horizontal"` | `"horizontal"` or `"vertical"` | +| `panels` | `list` | required | List of Layout/Tensor objects to draw | +| `filename` | `str` | `None` | Output path (or None for inline display) | +| `arrangement` | `str` | `"horizontal"` | `"horizontal"`, `"vertical"`, or `"grid:RxC"` | | `titles` | `list` | `None` | Per-panel titles | | `main_title` | `str` | `None` | Overall title | | `dpi` | `int` | `150` | Resolution | -| `panel_size` | `(w, h)` | `(4, 4)` | Size per panel | -| `colorize` | `bool` | `False` | Rainbow colors | -| `tv_mode` | `bool` | `False` | Use TV-layout rendering | -| `flatten_hierarchical` | `bool` | `True` | Flatten nested shapes to 2D grid | -| `label_hierarchy_levels` | `bool` | `False` | In nested hierarchical mode, annotate hierarchy levels | +| `panel_size` | `(w, h)` | `None` | Size per panel; auto-computed from layout dimensions when None | +| `**kwargs` | | | Default rendering options for all panels (see below) | + +**Rendering options** (passed as `**kwargs` or per-panel via `(Layout, opts_dict)`): + +| Option | Default | Description | +|--------|---------|-------------| +| `cell_labels` | `True` | `True` (auto: offsets for Layout, data for Tensor), `False`, `"offset"`, or a list | +| `colorize` | `False` | Rainbow colors | +| `color_layout` | `None` | Custom coloring layout | +| `num_colors` | `8` | Palette size | +| `tv_mode` | `False` | Use TV-layout rendering | +| `flatten_hierarchical` | `True` | Flatten nested shapes to 2D grid | +| `label_hierarchy_levels` | `False` | Annotate hierarchy levels | + +Per-panel option dicts override top-level `**kwargs`. + +## draw_gemm + +Draw GEMM operands in the standard matmul spatial arrangement. -Per-panel options (`(Layout, opts_dict)` tuples) override the top-level -defaults: `colorize`, `color_layout`, `num_colors`, `tv_mode`, -`flatten_hierarchical`, `label_hierarchy_levels`, and the TV-specific -`grid_rows`, `grid_cols`, `thr_id_layout`, `col_major`. +```python +from tensor_layouts import Layout, Tensor +from tensor_layouts.viz import draw_gemm + +A = Layout((4, 2), (1, 4)) +B = Layout((3, 2), (1, 3)) +C = Layout((4, 3), (1, 4)) +draw_gemm(A, B, C, main_title="NT GEMM -- offset maps") +``` + +The figure arranges A, B, C so shared dimensions align visually: + +``` + B^T (K×N) + A (M×K) C (M×N) +``` + +B is automatically transposed for display. Each operand can be a +Layout (shows offsets) or a Tensor (shows data values). + +**Parameters:** + +| Parameter | Type | Default | Description | +|-----------|------|---------|-------------| +| `A` | Layout/Tensor | required | Shape (M, K) | +| `B` | Layout/Tensor | required | Shape (N, K) | +| `C` | Layout/Tensor | required | Shape (M, N) | +| `filename` | `str` | `None` | Output path (or None for inline display) | +| `main_title` | `str` | `None` | Overall title | +| `dpi` | `int` | `150` | Resolution | +| `**kwargs` | | | Rendering options: `cell_labels`, `colorize`, `num_colors` | ## draw_tiled_grid @@ -438,29 +508,17 @@ draw_combined_mma_grid(a_grid, b_grid, c_grid, M, N, K, ## Jupyter Inline Display -Every `draw_*` function has a corresponding `show_*` that displays inline -and returns the matplotlib `Figure`: - -| `draw_*` | `show_*` | -|----------|----------| -| `draw_layout` | `show_layout` | -| `draw_swizzle` | `show_swizzle` | -| `draw_tv_layout` | `show_tv_layout` | -| `draw_mma_layout` | `show_mma_layout` | -| `draw_tiled_grid` | `show_tiled_grid` | -| `draw_copy_layout` | `show_copy_layout` | -| `draw_combined_mma_grid` | `show_combined_mma_grid` | -| `draw_slice` | `show_slice` | -| `draw_composite` | `show_composite` | +When `filename` is omitted (or `None`), all `draw_*` functions display +inline in Jupyter notebooks and return the matplotlib `Figure`: ```python -from tensor_layouts.viz import show_layout, show_swizzle, show_tv_layout +from tensor_layouts.viz import draw_layout, draw_swizzle, draw_tv_layout -fig = show_layout(Layout((8, 8), (8, 1)), colorize=True) -fig = show_swizzle(Layout((8, 8), (8, 1)), Swizzle(3, 0, 3)) -fig = show_tv_layout(Layout((4, 2), (2, 1)), colorize=True) +fig = draw_layout(Layout((8, 8), (8, 1)), colorize=True) +fig = draw_swizzle(Layout((8, 8), (8, 1)), Swizzle(3, 0, 3)) +fig = draw_tv_layout(Layout((4, 2), (2, 1)), colorize=True) ``` -| `show_layout` | `show_swizzle` | +| `draw_layout` | `draw_swizzle` | |----------------|----------------| -| ![show_layout](images/show_layout.png) | ![show_swizzle](images/show_swizzle.png) | +| ![draw_layout](images/draw_layout.png) | ![draw_swizzle](images/draw_swizzle.png) | diff --git a/examples/algorithms.ipynb b/examples/algorithms.ipynb new file mode 100644 index 0000000..30f5392 --- /dev/null +++ b/examples/algorithms.ipynb @@ -0,0 +1,2270 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Algorithms in Layout Algebra\n", + "\n", + "This notebook implements the core algorithms from Cecka,\n", + "*CuTe Layout Representation and Algebra* (arXiv:2603.02298v1, §2.6)\n", + "using pure layout algebra.\n", + "\n", + "- [**§2.6.1 COPY**](#copy) — element-wise transfer between tensors with different layouts\n", + "- [**REDUCE**](#reduce) — accumulation along a mode of a tensor\n", + "- [**§2.6.2 GEMM**](#gemm) — matrix multiply: BLAS variants, BLIS GEMM, GETT, Grouped GEMM, CONV\n", + "- [**Epilogue Fusion**](#epilogue-fusion) — composing GEMM + broadcast bias + pointwise activation\n", + "- [**Online Softmax**](#online-softmax) — fusing REDUCE(max) and REDUCE(sum) into one pass\n", + "\n", + "Each algorithm is expressed with `Tensor` flat indexing (`dst[i] = src[i]`)\n", + "and coordinate indexing (`C[m,n] += A[m,k] * B[n,k]`) — the same primitives\n", + "a GPU kernel uses, but executed element-by-element so we can visualize the\n", + "data movement through different layouts." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\", message=\"findfont\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from tensor_layouts import *\n", + "from tensor_layouts.viz import draw_layout, draw_composite, draw_gemm\n", + "from tensor_layouts.analysis import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## §2.6.1 COPY\n", + "\n", + "The generic COPY algorithm transfers elements between tensors of equal\n", + "size but potentially different layouts. It is a **rank-1 algorithm**:\n", + "it works on tensors of any rank by iterating over the flat index space." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def copy(src: Tensor, dst: Tensor):\n", + " assert size(src) == size(dst)\n", + " for i in range(size(dst)):\n", + " dst[i] = src[i]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`src[i]` decomposes the flat index `i` via `idx2crd` into coordinates,\n", + "computes the source offset through the source layout, and reads the\n", + "element. `dst[i]` does the same through the destination layout and\n", + "writes. Different layouts produce different physical orderings —\n", + "the copy remaps automatically.\n", + "\n", + "**Table 2** from the paper lists applications that are all just `copy()`\n", + "with different source and destination layouts:\n", + "\n", + "| Application | Source Layout | Destination Layout |\n", + "|---|---|---|\n", + "| 1D Arrays | `8:1` | `8:1` |\n", + "| ND Arrays | `(8,2,3):(1,16,32)` | `(8,2,3):(1,16,32)` |\n", + "| Gather | `(2,3,2):(42,1,128)` | `12:1` |\n", + "| Scatter | `12:1` | `(2,3,2):(42,1,128)` |\n", + "| Broadcast | `7:0` | `7:1` |\n", + "| Constant | `7:0` | `7:0` |\n", + "| Transpose | `(8,3):(1,8)` | `(8,3):(3,1)` |\n", + "| Tensor Transpose | `(8,(3,5)):((1,(57,8)))` | `(8,15):(1,8)` |\n", + "\n", + "It is well worth spending time to understand these examples in detail." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1D copy\n", + "\n", + "The simplest case: both tensors have the same layout, so the copy is\n", + "just a `memcpy()`. Offsets represent the index from the base address. The contents of these arrays is represented by letters. For each copy operation we show the offsets on the src and dst layouts, the logical contents of memory as seen through each layout, as well as the content in physical linear-addressed memory." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "output": { + "id": 961210486366498, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "letters = list(\"ABCDEFGH\")\n", + "src = Tensor(Layout(8, 1), data=list(letters))\n", + "dst = Tensor(Layout(8, 1), data=['.'] * 8)\n", + "\n", + "draw_composite(\n", + " [src.layout, dst.layout],\n", + " titles=['src layout 8:1', 'dst layout 8:1'],\n", + " main_title='1D Copy — offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "output": { + "id": 1201957665162403, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "copy(src, dst)\n", + "\n", + "draw_composite([src, dst], titles=['src 8:1', 'dst 8:1 (after copy)'],\n", + " main_title='1D Copy — data after copy()')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "output": { + "id": 928348793277502, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [src.view(Layout(len(src.data), 1)), dst.view(Layout(len(dst.data), 1))],\n", + " titles=['src backing store', 'dst backing store'],\n", + " main_title='1D Copy -- physical view (identical = memcpy)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Transpose — same `copy()`, different layouts\n", + "\n", + "Row-major `(M,N):(N,1)` → column-major `(M,N):(1,M)`. The copy\n", + "reads elements in row-major order and writes them in column-major\n", + "order, effecting a transpose of the physical storage." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "output": { + "id": 2186340785239254, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Transpose: row-major -> col-major using letters\n", + "M, N = 4, 8\n", + "letters = list(\"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\")[:M*N]\n", + "\n", + "src = Tensor(Layout((M, N), (N, 1)), data=list(letters)) # row-major\n", + "dst = Tensor(Layout((M, N), (1, M)), data=['.'] * (M*N)) # col-major\n", + "\n", + "# Show layouts (offsets) before copy\n", + "draw_composite(\n", + " [src.layout, dst.layout],\n", + " titles=['src layout (row-major)', 'dst layout (col-major)'],\n", + " main_title='Transpose -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "output": { + "id": 2202098613954012, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Perform copy and show data payload\n", + "copy(src, dst)\n", + "\n", + "draw_composite(\n", + " [src, dst],\n", + " titles=['src data (row-major)', 'dst data (col-major)'],\n", + " main_title='Transpose -- data after copy()')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "output": { + "id": 2012522579687765, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Physical view: different storage order -- this IS the transpose\n", + "draw_composite(\n", + " [src.view(Layout(len(src.data), 1)), dst.view(Layout(len(dst.data), 1))],\n", + " titles=['src backing store (row-major)', 'dst backing store (col-major)'],\n", + " arrangement='vertical',\n", + " main_title='Transpose -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gather and Scatter\n", + "\n", + "Gather copies from a strided source into contiguous destination.\n", + "Scatter is the reverse. Both are just `copy()` with different layouts." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "output": { + "id": 1626269545353092, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Gather: strided (2,3):(4,1) -> contiguous 6:1\n", + "src_buf = list(\"ABCDEFGHIJKL\") # larger than src\n", + "src = Tensor(Layout((2, 3), (4, 1)), data=src_buf)\n", + "dst = Tensor(Layout(6, 1), data=['.'] * 6)\n", + "\n", + "draw_composite(\n", + " [src.layout, dst.layout],\n", + " titles=['src layout (2,3):(4,1)', 'dst layout 6:1'],\n", + " main_title='Gather -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "output": { + "id": 1659670195187708, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "copy(src, dst) # non-contiguous reads, contiguous writes\n", + "\n", + "draw_composite(\n", + " [src, dst],\n", + " titles=['src (2,3):(4,1)', 'dst 6:1 (gathered)'],\n", + " main_title='Gather -- data after copy()')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "output": { + "id": 1219494326648538, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [src.view(Layout(len(src.data), 1)), dst.view(Layout(len(dst.data), 1))],\n", + " titles=['src backing store (12 elements)', 'dst backing store (6 elements)'],\n", + " arrangement='vertical',\n", + " main_title='Gather -- physical view')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "output": { + "id": 1226968985885307, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Scatter: contiguous 6:1 -> strided (2,3):(4,1)\n", + "src = Tensor(Layout(6, 1), data=list(\"ABCDEF\"))\n", + "dst_buf = ['.'] * 12 # larger than src\n", + "dst = Tensor(Layout((2, 3), (4, 1)), data=dst_buf)\n", + "\n", + "draw_composite(\n", + " [src.layout, dst.layout],\n", + " titles=['src layout 6:1', 'dst layout (2,3):(4,1)'],\n", + " main_title='Scatter -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "output": { + "id": 1221912383074247, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "copy(src, dst) # contiguous reads, non-contiguous writes\n", + "\n", + "draw_composite(\n", + " [src, dst],\n", + " titles=['src 6:1', 'dst (2,3):(4,1) (scattered)'],\n", + " main_title='Scatter -- data after copy()')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "output": { + "id": 1561014808895244, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0AAAAGxCAYAAABLMtbXAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAc11JREFUeJzt3Xl8Ddf/P/BXtnuzSYSQRRAkiCXEFrUlsW+hJKWWWkpLbW2/9UFR1NJPW1XVaj9qKUostbVUaalQO1V77UJTYt+yiUjO74/5Zdy59yZuIvcOmdfz8biP3JkzZ+575s7czHvmzBk7IYQAERERERGRBtirHQAREREREZGtMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREZBOTJk2CnZ2d/AoMDFQ7pHzr16+fYhkiIyPVDknh0qVLivjs7Oywfft2m8dRFL5rIiq6HNUOgIjUcfjwYSxYsAC7d+/GpUuXkJKSgmLFiqFEiRLw9vZGtWrVUKtWLdStWxdNmjRRO1wTP/74I44cOSIPBwYGol+/foU2PRERERVNTICINOg///kPZsyYASGEYvzdu3dx9+5dXLhwAfv37wcAlCxZErdu3VIjzDz9+OOPWLx4sTwcERHx1AQoP9MTERFR0cQEiEhjZs6cic8++0ztMIheSJ999hkmTZokDzs7O6sXzHPsnXfeUZxgcHTk4QYRPT/4i0SkIdnZ2fjvf/+rGFerVi2MHj0aISEhcHNzw927d3H69Gns2rULmzZtQnp6ukrREj1/vL294e3trXYYz73ixYujePHiaodBRGQWO0Eg0pDTp0/j5s2binE//fQTevTogdq1ayM4OBgNGjRAnz59MHfuXFy+fBnr1q3Lc5737t3DF198gfbt2yMgIAAuLi5wd3dHpUqV0LFjR8yaNQvJycmKOlu3bsWkSZPQqVMn1KhRA35+fnB2doaLiwv8/f3RsmVLfPrpp2ab3kVGRsLOzk7RnA0AduzYYfbm7/xOb+zSpUt4//33ER4eDm9vb+h0OpQsWRKNGjXClClTcPv27VzXjfH8Fy1ahAcPHmDcuHGoVq0aXF1dYWdnh0uXLuW5jtW2aNEik2UBpO2pX79+CAgIgF6vR0BAAAYMGJDv5Tl+/Dhee+01+Pv7Q6/Xo2zZsnjzzTdx5coVxXQ7d+5UxGBvb5/rZ82YMUMxbdmyZZGdnS2XnzlzBu+88w7q1KkDLy8vODk5wdPTE0FBQYiMjMTIkSPxww8/IDU1VTHf/HSCcO3aNUybNg3NmzeHr68v9Ho9PD09UblyZbzyyiuYO3cuHj9+rKizbt06jB07Fm3btkVISAh8fHyg0+ng5uaGcuXKoX379vjmm2+QkpKSr3VsqZ9++kmxfDqdDnfu3DE77cSJExXTVqpUSW5Wm59OEG7cuIGpU6ciIiICpUuXhk6ng5eXF+rUqYPRo0fj33//NamTkZEBFxcXxWf88ccfimkWLFigKJ88ebKi/MKFCybbtfE2R0RFlCAizdi9e7cAoHgdP368wPNbvny58PT0NJmn8evw4cOKerVq1XpqHQCiZMmSIj4+XlE3IiLCoroARHx8fL6nz5GdnS2mTp0qHB0d86xTvHhxsWHDBrPrx3jaKVOmiAoVKpiMT0hIKPB3YAsLFy40iXnVqlVCr9ebXSfu7u5ix44dJvOZOHGiYrry5cuLb7/9Vjg5OZmdj7+/v/j3338V8wgLC1NMM27cOLMx169fXzHd+PHj5bI1a9YInU5n0Taxd+9exXz79u2rKI+IiDD7+TNnzsx1/Ri+7t69q6hnyf6Us+7M7bsJCQl5btdPk5mZKXx8fBT158yZY3ba4OBgxXRTp06Vy8x91+YsWLBAuLq65rmser1ezJ8/36Ru8+bNFdNNmzZNUW78XbVo0cLksw3LK1eubPF6IqIXG68AEWmIr6+vybioqCiMGjUKv/zyC27cuGHxvBYvXowePXrg/v37hRmiwu3bt9GlS5c8r7JYy7hx4zB+/HiTM/TG7t27hy5duiA+Pv6p8/zwww+RkJBQWCGqqmfPnsjIyDBblpKSgi5duiApKSnPeVy5cgWDBg1CZmam2fKrV69izJgxinHDhw9XDC9cuBBZWVmKcQkJCTh48KA8bGdnh/79+wMAHj16hDfeeAOPHj3KM7ZnMXnyZLz77ru5rp/CcPnyZXTu3DnXdVdQjo6OeO211xTjli1bZjLdwYMHce7cOXnY3t4effv2zddnzZ07FwMGDEBaWlqe02VkZGDgwIFYsmSJYnzz5s0Vwzt37sxzeN++fYr92fiKkfH8iKjoYgJEpCEVK1ZEzZo1FeNu3bqF6dOno0OHDvDx8UHZsmXRvXt3LFmyxKT5T45r165h6NChinF2dnYYNGgQduzYgbNnz2Lfvn345JNPULFiRZP6pUuXRp8+fbBkyRL8/vvvOHbsGM6cOYNdu3Zh0qRJ0Ov18rT37t3DvHnz5OEVK1YgISEBMTExinmGh4cjISFB8WrYsGG+pwekLsI//vhjxfQ9e/ZEfHw8Tp8+jV9//RVNmzaVyx4/foyBAwc+9WD08ePH8PX1xbx583Dq1CkcPHgQn332Gdzd3fOs9zx6/PgxRo0ahYMHDyI+Ph6dOnVSlN+5cwdTpkx56jwcHBwwdepUnDhxAuvXr4e/v79imtWrVyvWa8+ePVGqVCl5+OrVq/j5558VdX744QfFcGRkpLwdnjhxQtGkq0SJEoiLi8PJkydx5swZ7Ny5E99++y169+6NEiVKWLAmlI4dO4YPP/xQMc7JyQmjR4/Gnj17cPbsWfzxxx+YMGGC2RMS5cqVw+DBg7FixQps374dJ0+exN9//434+Hi8++67sLd/8m/74sWLWLNmTb5jfJoBAwYohnfu3GnSDG358uWK4TZt2iAgIMDiz7h69Sreeecdxbi2bdti06ZNOH36NLZv346XX35ZUT58+HDcvXtXHjZOWPbs2SM3c7xy5QouXryoKE9NTcWhQ4fkYSZARBqm9iUoIrKtvXv3Cjc3N4ua2Xh7e4slS5aYzGPatGkm086aNcvs5z169EikpqbmK8Zhw4Yp5t22bVuTaSxtilSQ6QcMGKCYtkOHDibTpKSkCGdnZ8V0xk3hjNeRvb29OHr0qEXr4HlirgnciBEjFNNkZ2ebNG308PAQWVlZ8jTGzaIAiDFjxijms2rVKpNpTpw4oZhm3LhxivL27dsryuvUqaMoX7p0qVy2f//+p25bOR49eiTS09MV4562Hb3xxhsm8f/0009m55+cnCwyMzNz/XxzOnbsqJj34MGDFeXP2gQux0svvaSYx6effiqXZWVlCX9/f0X5qlWrFPWf1gRuypQpivKaNWsqthUhhHj8+LEoX768YrqvvvpKLs/MzBTFihVTlP/1119CCKl5bs44X19f+f306dOFEEIkJiYq6tnZ2YmbN2/mez0R0YuJV4CINKZhw4bYv38/2rRpI9/Mnptbt27htddeMznLbNzcy9/f3+SKUA4nJye4urqajN+4cSP69euHWrVqyTeh59yIPHv2bMW05m6CtqYdO3Yohjdu3Ghys7S7uzsePnyomM74jLKxzp07IzQ0tMBx3bp1C5cuXcr1lePhw4d5TlcYN9C//vrrimHDZmY5Hjx4gFOnTuU5n2HDhimGq1atajKN4Vl/AHjrrbcU3Spv3rwZiYmJAIDz58/jr7/+kss8PT3RtWtXebhatWpwcXFR1G3atClGjhyJuXPnYseOHXKzTicnp3x3c228b4SHh5tcHcvh7u5u0j10VlYWVqxYgVdffRXVqlWDp6cnHB0d5e3O+GqXtfYN4+/XsBnc9u3bcfXqVXnY29s712XMjfE+dvz4cTg4OCj2MUdHR1y+fFkxneE+5ujoqLgSCzxp9mbY/O3dd981qW+8r9asWZO9+xFpCBMgIg2qXr06Nm/ejIsXL+J///sfevXqhaCgoFynnzhxomLY8OAHAGrXrg0HBweLPjstLQ1t27ZFx44dsXjxYhw7dgz37t3L814ba/V4lZuC9gT1tHtewsLCCjTfHCNHjkSFChVyfeXYt29fntOtXr36meIAoPi8vMZdu3Yt13m4u7ujTJkyinGGyUkO422jTJkyiI2NlYezs7OxYMECAKbN33r27KmYp7u7O6ZNm6aYZteuXZgxYwYGDRqEyMhIlChRAo0aNTKZlyWM9426detaXPfmzZsIDw9Hjx49sHLlSpw6dQoPHjwwucfJkLX2je7du8PNzU0ePnLkiJzMGt8T1Lt3b+h0unzNv7D2sdzuA8pJcBwcHDBo0CC5S+5du3ZBCMHmb0QaxwSISMMCAwMxePBgLF26FOfOnUNSUhJmzpxpchB68uRJPHjwoFA+c+rUqfj111/zVUf8/651n3dPe2aS8f0tWleyZEmTcZYm0iNGjFAMf/fdd8jOzsbKlSsV443vZwGkKwLx8fGIjY2Fl5eXSXl2djb27t2L7t274/PPP7consLw9ttvK+5RsYS19o1ixYrhlVdeUYyLi4vDo0ePsHbtWsV4c+vYWoz3MXMJ0J07d3Dy5EkA0skZT09PNG7cGIB0NfHEiRNMgIg0jgkQEcl8fX3xzjvvmBxcAlB0iGB8IH/kyBHFM1byYnzzdLly5bB06VIcO3ZM7oxg8ODBBYi+8BgvX//+/U06TDD3+t///pfnfC09uH8RmOvNztw4czf6F4aXXnoJ9erVk4cTExPxxRdf4NixY/K40NDQXK/AREZGYtWqVbhz5w4SExOxfft2zJkzx+RAeNq0aRZv24DptmNpQvPo0SOTpqahoaFYs2YNTpw4IW9jHTt2tDiWZ2XcDG758uXYtGmTokligwYNUKNGjXzP23g9tWrVyqJ9bMOGDYp6tWvXVnRWcf36dSxcuFBODHOayBk2lVu7dq2iaaaDgwMiIiLyvQxE9OJiAkSkITdv3kT37t0VXQSbY9z7m4ODg+JsfVRUlKL86tWruR78Z2ZmKrq5NW768s4776BXr16oWbMmAgMDUaZMGezfv/+py2Lc5OZpV1/yM73xwy1/++03uLm5ITAw0OzL19cX8fHxit7JrGHRokUQQuT6Mow/r+n69ev3zLHkNDnLIYTAwoULFeM8PDzM3tNTWN5++23FsHGX2eauTGRlZeH69euKcQEBAYiIiMCgQYNMkpA7d+7kq3t4431j//79Jvft5EhJSZGb9926dcuka+5Jkyaha9euqF69OgIDA+Hl5YXDhw9bHMuzatq0KYKDg+Xhixcvmqxj4yTJUsb72N69e5GZmZnrPla2bFkcOnRI0UMkALMPozW8apeT+DRr1kwe9+WXXyqmr1u3Ljw8PAq0HET0YmICRKQhWVlZ+OGHH9CgQQOEhIRg9OjRWLduHY4cOYJz585hz549GD16NL755htFvcaNGysSiNdff11xfwAgdVE7ZMgQ7Ny5E+fPn8fBgwcxa9Ys1KxZE2fPnpWnM04S5s2bh82bN+PMmTPYtGkT2rRpY9FBnvF8jhw5gjVr1uD8+fO4dOmSyc3h+Zn+rbfeUnQQceXKFTRu3Bjz5s3DoUOHcO7cOezfvx/fffcd+vTpAz8/vwIfCL6oZs+ejTFjxuDPP//Ejh078PLLL+Po0aOKaXr27GnVq17dunVTXGEy7C5br9ejd+/eJnXS09MREBCAdu3aYcaMGdiyZQtOnjyJ8+fPY/fu3SbPGQJgsq3nZejQoYquqgEgJiYGY8eOxf79+3H+/Hns2bMH//3vfxESEiLfw+Pl5WXSIcKMGTOwfft2nD59GmvXrkVUVFSB750pKOPt+vTp0/J7V1dX9OjRo0Dz7d+/v6KpbUpKCiIjIzFz5kzs378f586dw59//omlS5di0KBBCAgIQGxsrNmmuMZX7Qzvw2rSpAkAoF69evLnGXaDbq4+EWmAjXudIyIVJSUlWdT9NYy6h/31119N5mX8FPW8XocPH5brGXdxbe7l5+eXZxe6QgixYcOGPOdhXCe/048ePTrf68qYcfnChQsL8K2pz1w32K6urnmui+LFi4t///1XMZ+ndY0sRP67cTbXtTYA0a1bN7PTJycn5+s7Ne7m2pLu1CdMmGDx/O/evSvXM+7i2pJ9w/jzC6sb7BxXr14VDg4OZmN57bXXcq1nyXf9v//9L9/7WEJCgsl8/v77b7PTVqlSRTFdVFSU2el+++23Aq8fInox8QoQkYY4OTnl66Gbzs7OmDNnDlq3bm1S9vrrr2PJkiX5bjry4Ycfolq1armW9+nTB2+88cZT59O2bVvUqVPH4s/N7/T//e9/MXXqVJOz8rnJz0Mgi4K1a9fmemXEzc0Na9euNenhzRoGDx5stgeywrgxv3z58oqH8Frqww8/xPTp0/PdM9qXX34JPz+/XMs/+OADs/uiNfn5+aFt27Zmy551HQ8ePBgLFiyw+Aqbt7e32V4CQ0JCzK434y6yjYcBqWlszlUiItIOJkBEGlKyZEncvn0bv/32Gz744AO0b98eVapUgYeHBxwcHKDX6+Hj44NmzZph0qRJOHPmDN58881c59e7d29cunQJM2bMQJs2beDn5we9Xg9XV1dUqFABHTp0wBdffIFKlSrJdUqUKIF9+/Zh7NixqFy5MnQ6HYoXL44mTZpgyZIlWLx48VOfTwRIzwD5/fff8d5776FKlSom9wY86/R2dnYYN24cLl68iAkTJqBJkyYoVaqU/GyYgIAAtGjRAmPHjsWOHTvwzz//PDXmoqRNmzY4cuQI+vfvj4CAAOh0Ovj7+6N///44duyYyb0w1uLr64tu3bopxpUrVw4tW7Y0O72bmxsOHDiAmTNnIjY2FqGhofDz84OTkxP0ej3KlCmD1q1bY9asWTh58qTiHpj8GDlyJBISEjB58mRERESgdOnS0Ol0KFasGIKCghATE4M5c+YoTkhUqFABhw8fxrBhw1C+fHk4OTnB29sbrVu3xsaNGzF58uQCxfKszCU6lSpVUtxXU1Cvv/46Ll26hI8//hgtWrSAr68v9Ho9dDodfH190bRpU/zf//0fNm3ahKtXr8LHx8fsfMxtb8YJj7l4GzZsaDapIqKizU6IF6R/WSIiUsWiRYtMHnL6PP3rmDJlCiZMmCAPT5gwAR9++KGKERER0fOMV4CIiOiFdebMGXz99dfysKOjo0VNKImISLssa9xORET0nNi/fz969eqF9PR0JCUlKa5Gvf7665q7H4uIiPKHCRAREb1Q0tPTceHCBZPxISEh+PTTT1WIiIiIXiRsAkdERC8sZ2dnhISEYNy4cdizZw88PT3VDomIiJ5z7ASBiIiIiIg0g1eAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBEZDWRkZGws7ODnZ0dAgMD1Q7HrEWLFskx2tnZYfv27RbVmzRpkqLepUuXrBonWU92djbCwsKeug1kZmZi7ty5aNmyJXx8fKDT6VC6dGmEhYVh2LBh+Ouvv6we66VLlxTb3aRJk6z+mSTZvn27vN7DwsIghFA7JCIqICZARERkllaSvKVLl+LIkSMAgPDwcERGRppMc/nyZYSFhWHQoEH4/fffcePGDWRmZuLmzZs4cuQIvv76a6xfv962gZNZ1tpuIyMjER4eDgA4cuQI4uLiCmW+RGR7jmoHQET0IqpWrRpiYmLkYTc3NxWjoYJ6/PgxJkyYIA+/9957JtM8ePAAkZGRigNpb29vVK9eHU5OTkhISMCFCxdsES6pbOTIkXjllVcAAB988AF69OgBBwcHlaMiovxiAkREVADdunVDt27d1A6DntGGDRtw+fJlAECxYsUQHR1tMs3777+vSH7ef/99TJw4EXq9Xh53+fJl3Lp1y+rxkro6duyIYsWKITk5GZcuXcLGjRvRqVMntcMionxiEziiF9ChQ4fQu3dvVKxYES4uLnB2dkZAQABeeuklvP322/jtt98U0xvfi/Pw4UN8+OGHqFKlCvR6vUmTn4SEBLz33nuoXbs2PD09odfrERAQgDZt2uC7774rcNxZWVn4/PPPUa1aNTg7O8Pf3x9Dhw7F7du3TabdsmULhgwZgoYNG6JcuXJwc3ODXq+Hn58f2rZtiyVLluTZBn/jxo3o1q0bypcvDxcXF3h4eKBy5cp4/fXXcfToUYviTUhIQEBAgLzuPDw8sHv3bgB5N7Mxd1/Rrl270L59exQvXhyurq5o1KiRyfeUIz09HR988AEqVqwIZ2dnVKhQAWPGjEFKSsoz3Ve1detWdO3aFeXKlYNer4erqyvKly+PiIgIjBo1Cvv27VPE/+GHHyrqV6hQIdfPzsjIwJw5c9CiRQuUKlUKOp0OJUuWRLNmzfDFF18gLS3NJB5z63Dp0qUIDw+Hu7s77OzsFNPfvn0bU6ZMQXh4OLy8vKDT6VCmTBl0795d/l7ya+7cufL7Tp06wdnZWVF+7949LFq0SB5u164dPvroI0XyAwDly5dH3bp18/35p0+fxtChQxESEgJ3d3e4uLigcuXKGD58eIGbbqWmpuKLL75As2bNULJkSeh0Ovj4+CA6OhobN240W8d4u0pJScHIkSNRtmxZuLq6om7duli7dq08/YIFCxAaGirvx8OHD0dycrLV4snMzMTMmTNRs2ZNODs7o1SpUujbty+uX78u18nvdnvv3j1MnDgRdevWhaenJ5ycnODt7Y1q1aqhZ8+e+PLLL/Hw4UPFvJydnRVJ8rx588x/CUT0fBNE9ELZsmWLcHJyEgByfbVo0UJRJyIiQi7z8/NTDAMQERER8rTfffedcHZ2znXetWrVsjhWw88JCAgQXbp0MTvP4OBgcePGDUXdXr165bmMAETXrl1FVlaWol5aWpp4+eWX86w3c+ZMefqFCxcqyuLj44UQQvz777+iQoUK8ngPDw+xZ88eud7EiRMV9RISEnKdZ7du3YSdnZ1JHA4ODmLbtm2K+NPT00Xjxo3Nxl27dm0RFhYmD5cvX97i78I4JnOvAQMGWDyt4WdfuXJF1KpVK8/pq1SpIi5evKiIyXgd9ujRw6Rejj179ggfH59c529nZycmT55s8foQQojU1FTFvjR//nyTaX788UfF5yxatEisWrVKvPXWW6Jnz55i5MiRJt+hpebMmZPnvuzu7i5++eUXRZ2EhATFNBMnTlSUnzlzRgQHB+f5XQwcOFBkZ2cr6hnuqz4+PqJevXpm6y5dulSMGDEi198d4/kWVjyRkZFm61arVk2kp6cLIfK33aampopq1ao9dfrExEST723evHlyuV6vF2lpaQX5+olIRUyAiF4wLVu2VBxAN27cWERHR4u6deuKEiVKyAcihowTHgDC09NTNG/eXDRu3Fi0atVKCCHEb7/9Juzt7RXT+fn5idatW4uoqCjh5uZW4AQo5xUcHCxatmwpPDw8FONfffVVRd1evXoJnU4natWqJZo3by46d+4soqKiRPHixRX1li9frqj32muvmRwYh4aGio4dO4patWoJOzu7pyZA169fF1WqVFGsq/379ys+Jz8JEADh5uYmoqKiRGBgoGK8YfIphBDvv/++olyv14uIiAhRs2bNXA/mLBEUFCTXc3Z2FlFRUaJDhw6idu3aolixYgJ4kgDFx8eLmJgYERISovi8du3aiZiYGBETEyPeeustIYQQ2dnZokGDBorpfH19RevWrUVAQIBifI0aNURmZmau6xCAcHJyEg0aNBCtWrUSxYsXF0IIkZSUJEqWLKn4Ths2bCjat29vkhStXLnS4nWyZcsWRd2jR4+aTGMco5+fn9kD5Y4dO4rk5GSLP3vz5s2KpNjV1VW0aNFCtGrVSnECwt3dXZw/f16ul1cClJaWJipVqqQor127tujQoYMoX768Yvwnn3yiiMfcvlqjRg3RpEkTxTgXFxcBQHh7e4tWrVrJ247h/mOteMqVKydatGgh3NzcFOMXLlwohMjfdrt06VLFNEFBQSI6Olo0a9ZMceLDXAJ09OhRRd2CJsBEpB4mQEQvmKpVq8r/eKdNm6Yoy87OFvv27TNJCowPJho0aKC44vLw4UMhhBD169dXTDdy5Ejx6NEjebrk5GSxYsUKi2M1/twBAwbIZ3oTEhJE6dKl5TJ7e3vFwcbZs2dFamqqyTxTUlJExYoV5XqxsbFy2YkTJxSf5+HhIXbs2KGof/r0abFr1y552DhZWbt2rQgNDZWHvby8xMGDB03iyE8C5O3tLc6cOSOEkA4KDZMZJycnkZGRIYSQrv4YJoY6nU6ReI0bN67ACZDhQXVcXJyiLDMzU8THx4sNGzZYvIw5fvrpJ8U0TZo0ESkpKfLytGrVSlFu+NnG8y9ZsqQ4dOiQXJ6zXb733nvyNA4ODmL37t3yNGlpaYqrFZUrV7Z4nXz66aeKzzfc1nMMGTLEbMJj7tW9e3eLP7tu3bpyvcDAQJGUlCSXXbhwQZFYvPHGG3JZXgnQV199pSgz3FcfP34sOnXqJJd5enoqrlwY76s5iYIQpldjAwMD5d+PjRs32iSerl27yt/Prl27FGV9+/ZVrFtLttuPP/5YLq9SpYrJleR///1XfPvtt+LevXsmdR89eqSY/2effWYyDRE933gPENELJigoSH6/dOlSfPPNN4iPj0dSUhLs7OwQHh6OV199Nc95zJo1C6VKlZKH9Xo9rl+/joMHD8rjqlatik8++QROTk7yOHd3d3Tv3r3AsU+dOlW+ryMwMBADBw6Uy7Kzs/HHH3/Iw4GBgYiLi0ObNm3g7+8PZ2dn2NnZwd3dHRcvXpSnO3v2rPze+H6C0aNHo1mzZopxVapUQePGjXON8c0338SxY8cAACVKlMDvv/+OevXqFWBpnxg8eDAqV64MAHBxcVHcc5WZmSnfA3Xo0CE8ePBALuvatSsaNGggD48bNw7FihUrUAyG283s2bMxf/587Nq1C7du3YKjoyMiIyPRsWPHfM9306ZNiuEJEybIPeI5Ozub3I+xefPmXOc1cuRI1KlTRx7Ouc/ml19+kce5ubnh888/R2xsLGJjY/Haa68p1tnZs2ct7pHtxo0b8nsPDw/Ftp7j0aNHJuPmzJmDBw8eYO/evfDz85PHr1y5En///fdTP/f69es4dOiQPOzg4IBhw4bJyzRq1Cg4Oj7po8h4HefGcD05ODhg1apV8jy7d++OxMREufz+/fvYs2dPrvMaP368/N5wGwSkfSTn98N4/0pKSrJKPJ9++qn8/TRu3FixHxh+pqUM94eEhARMmDABP/74I06fPo3Hjx+jTJkyePPNN+Hp6WlS18nJSfH5hvchEdGLgb3AEb1gxowZg02bNiErKwunTp3C0KFD5TJ/f39ER0dj7NixKFeunNn6Op1OfpaFoZyesHI0bNgQ9vaFd47Ey8sLvr6+inHVq1dXDOccEGVlZaFt27bYtm3bU+drePBrfNN4XolObgx78po9ezbCwsLyPQ9jxvMwPqjKyMgAAPz777+K8TVr1lQMu7i4oFKlSvIza/Jj3Lhx6NGjBwBg79692Lt3r1xWoUIFxMTEYMyYMShZsmS+5mu83Rh/p8bDxtMbatq0qdnxht/rgwcPsGbNmqfGVKlSpTynAaSb4HPkllh6eHgohuvXr49BgwYBkPaRESNG4P3335fLd+zYgWrVqj01PkMXLlzIM2m7cuUKsrKyntrdsuF6ysrKsmg9mVO8eHH4+/vLw+7u7opyw+UzLsvZlgsznmLFipl8n56ennKnC4afaamOHTuiVq1aOHr0KB49eoRp06bJZS4uLmjatCmGDx+e60kBDw8P+fMNtyMiejHwChDRC6Zx48Y4ePAgBgwYgIoVKyp6yrp69Sq+/fZbREREKBIDQz4+Pia9az1vVq1apUh+dDodmjVrhq5duyImJgbe3t5ymbDi09jfe+89JCQkPPN8SpQooRi29Lkhhfk9vfrqq4iPj0ePHj0QEBCgKEtISMBnn32G9u3b4/Hjx4X2mflleDXlWZjrcc6c4sWLy+9z68GsYsWKimHjA/Hg4GDF8N27dy367PwQQiA9Pb3Q55vbejJO0I1PhJi7KmLNeIz3H8DyfSg3er0eO3bswNSpUxEeHg4XFxe5LD09Hb/99huio6Nzfbjt/fv35feG2xERvRiYABG9gMLCwjB//nxcuHABaWlpOH78uKKp0aVLlxTNTwzldlWnfPnyiuF9+/YhOzu70GK+e/curl27phh36tQpxXDZsmUBwKQpzO7du7Fjxw6sWbMGq1evzvUqhXHXzAXpGnnEiBHyOkpKSkKrVq1M4rYW46t2p0+fVgynp6c/0wM3IyMjsWzZMiQmJiIlJQV//fUXhgwZIpcfOHAAf/75pzxsSQJmHLNxE7CTJ0/mOb0hS7bNihUrQkj3r+b6srQpX+nSpeX3Dx48MJv8NWzYUDFsnODcuXNHMWzYtDQ3xuugf//+T10m4yst5hiuJ1dXV6Snp+c5z2HDhj11ns9CrXgsPXHg6emJcePGYd++fUhNTUViYiLWrVunOEHwzTffmNTLzMxESkqKPGzJd05EzxcmQEQvmIULF2Lbtm3IysoCIN1nUaNGDfTq1UsxXV5Njczx8fFR3Oty+vRpjBkzRnFQmJ6ejh9++KHAsY8fP16+YvPPP/8onqFhb28v30+QmZmpqJdzTwkAzJ8/H2fOnDE7//bt2yuGP/nkE8V9RQBw/vz5PBOjLl264KuvvpKHL1y4gDZt2tikmUudOnUUZ9dXrVqF48ePy8PTpk3L9UrF03z55ZfYt2+fvP7d3NwQFhaGrl27KqYz3G4Mz4oD0hVGY+3atVMMT5kyRT6Tn5GRYXIPUNu2bfMdu+FnXLx4ER9//LFJcn779m3MmzcPb7/9tsXzrV27tmLYOCEHgLp166Jq1ary8I4dO+SmXZmZmVi6dKlieuNnapnj6+uraBa5fPly/P777ybTnT9/HlOmTMGcOXOeOk9AuZ7S0tIwcuRIk3uYkpOTsXz5cvTu3duieT4LteKxZLv966+/8N1338kJrJ2dHQICAtC5c2fFVT9zv6PGSX5hNJMlIhuzdi8LRFS4OnToIACI4sWLi8aNG4vOnTuL1q1bm3QrvXr1armOYY9KefUc9uuvv5o8r8bPz0+0adNGNG/eXHh4eDxzN9iVK1cWrVq1Mom3W7ducr0FCxaY9ObWvn17Ubt2bQFAEaPx8hj3WJXTDXZ0dLSoU6eOsLe3t+g5QMbdUTdu3FjRK11+eoEz7Br4aXXHjh2rKHNxcRFRUVHP3A129erVBQBRqlQpERERIV5++WURFRVl8synP//8U66zZs0aRZmPj4/o1KmTiImJkbsezsrKUvRoZrjNlC1bVjG+WrVqip7WLOmtSwjpOUPG3Z+XK1dOtG3bVrRv316EhITI3bcbdyuel5SUFOHo6CjP87vvvjM73YYNGxSf7enpKdq0aaPojdB4G36an3/+2WRfq1mzpoiOjhYtW7ZUrDvDntXy6gUuNTXVpJv10qVLi1atWsndwOc8d8h428nrN+Jp27NhmWGPbNaKRwih6Ebb+Du3ZLtdtWqVACAcHR1FjRo1RPv27UWnTp1MnlnUsWNHk8+eO3euXO7k5GS2t0oier4xASJ6weQkQHm9mjZtqnjeiqUJkBDSQ/70en2u8y5oAuTn5ydatGhhdp6VKlUS165dk+s9fPhQ0RW14atNmzaKZ5MYL09qaqro2LFjnuvHkgRICCH69OmjKGvXrp18AG+tBCivB6HWr19f1KlTRx4ODg62+LvISYDyehk/iyklJSXXh4++/fbb8nSJiYlmEzTDV3BwsOJ5Nk9bD8Z27typ6DY9t1fz5s0tXidCCNG2bVu57muvvZbrdB9//LHZh9nmvJo0aSLu37+fr8/++uuvn/pQYwCKB7w+7UGof//9t8mzd8y9KlasqKhnjQTIWvEIkXcCZMl2m5MA5fVyd3c32wW+4QN727Zta1JORM8/NoEjesFMmDABH3zwAaKiohAYGAh3d3c4OjrC29sbzZo1w6xZs7BlyxZFN7r5MXDgQJw4cQLvvvsuQkNDUaxYMTg5OcHf3x+tWrXCiBEjCjRfnU6HX375BVOnTkXlypWh1+vh6+uLwYMHY+/evfDx8ZGn1ev12L59OwYNGgQfHx/odDpUqlQJEydOxPr16/O8AdrV1RUbNmzA+vXrERMTg7Jly0Kv18Pd3R3BwcHo168foqKiLIp5/vz5aNOmjTy8adMm9OnTp1DvjTLm7OyMLVu2YPz48QgMDIROp0NgYCDGjBmD7du34+bNm/K0xr3q5WXWrFkYNWoUGjdujLJly8LFxQVOTk7w9fVF69atsXDhQsTFxSnquLm5YevWrYiOjoaXl1eu91YEBATgwIED+PrrrxEZGYkSJUrA0dERXl5eaNy4MWbMmIG//vrLop7ZctOkSROcOnUK06ZNQ6NGjeDl5QUHBwe4u7sjJCQEvXr1wvfff4+ffvopX/N988035fc//fRTrj2KjR49Grt370a3bt3g5+cHJycnFC9eHM2aNcPcuXMRHx9v0mPc0wwZMgTHjx/HiBEjULNmTRQrVgwODg7w8vJC3bp1MXToUGzatAljx461eJ4hISE4evQovvzyS0RFRcHb2xuOjo5wdXVFUFAQYmJiMGfOHBw4cCBfsRaUGvFYst1GRERg9uzZ6N69O0JCQlCyZEk4ODjAzc0N1atXx7Bhw3DkyBGTLvDT09OxYcMGeTinR0AierHYCWHFLpSIiCjfLl++bNIpBSA99+m1116ThydMmGByjw3lz+PHjxEUFCTf65HzrBoic3744Qf5WWjly5fH+fPnC3yyiYjUwwSIiOg54+LigpCQENSpUwd+fn5ISUnB4cOHsWPHDnkaLy8vnDlzhj1QFYLvv/8effv2BSD1+mb4jCQiQ+Hh4fLVqu+//15xQoKIXhxMgIiInjPOzs55PtzRz88Pa9euNemimQomOzsbdevWlR8wGx8fb1FvbqQt27dvl5vP1q5dG3/99ddz/0w1IjKPCRAR0XNm9uzZ2LJlC44fP46bN28iIyMDXl5eqF69Ojp27IjXX3+dD18kIiIqICZARERERESkGewFjoiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiAgAkJEBjB4N+PsDLi5AeDiwZYvaUVlXSgowcSLQti1QogRgZwcsWqR2VNZ18CAwbBhQvTrg5gaUKwd06wacPat2ZNZ18iTwyitAxYqAqyvg7Q00awZs2KB2ZLY3bZq0rdeooXYk1rN9u7SM5l779qkdHRGpzVHtAIjo+dCvH7B6NfDOO0BwsJQItG8PxMcDTZqoHJyV3LoFTJ4sJQG1akkHTUXdJ58Au3dLyUBoKHDtGjB7NlCnjnRgWFQPii9fBpKTgb59pSQ/LQ1Yswbo1An49lvgzTfVjtA2/v0X+OgjKfnVghEjgPr1leOCgtSJhYieH3ZCCKF2EESkrgMHpCs+06cDI0dK4x4+lA6GS5cG9uxRNz5rycgA7t4FfH2BP/+UDpQWLpSSwaJqzx6gXj1Ap3sy7tw5oGZNIDYWWLpUvdhsLSsLqFtX2tZPn1Y7Gtt49VXg5k1p2W/dAk6cUDsi69i+HYiKAlatkrZrIiJDbAJHRFi9GnBwUJ4Fd3YGBgwA9u4FEhPVi82a9Hop+dGSRo2UyQ8gXfGrXh04dUqdmNTi4ACULQvcu6d2JLbxxx/Svv7FF2pHYlvJycDjx2pHQUTPEyZARITDh4HKlQEPD+X4Bg2kv0eO2DwksiEhgOvXpftiirrUVOnKx4ULwMyZwKZNQIsWakdlfVlZwPDhwMCB0tU+rejfX/pdc3aWrgj9+afaERHR84D3ABERkpIAPz/T8Tnjrl61bTxkW3FxwJUr0v1QRd1770n3/ACAvT3Qtat0D1RRN2eOdB/U1q1qR2IbOh0QEyPdx+jtDfz9N/DZZ0DTplIz0LAwtSMkIjUxASIipKdLzcGMOTs/Kaei6fRpYOhQ4KWXpA4Cirp33pHuCbl6FfjhB+nKyKNHakdlXbdvAxMmAB98AJQqpXY0ttGokfTK0amT9L2HhgLvvw9s3qxebESkPjaBIyK4uEgdAhh7+PBJORU9164BHToAnp5P7gMr6qpWBVq2BPr0AX7+WeoKPTpaagZYVI0fL3XzPny42pGoKygI6NxZ6tkyK0vtaIhITUyAiAh+flIzOGM54/z9bRsPWd/9+0C7dlIHAJs3a/c7jo2Vno1UVJ+DdO4cMHeu1B301avApUvS6+FDIDNTen/njspB2lDZstIVv9RUtSMhIjUxASIi1K4tHQA+eKAcv3//k3IqOh4+lK56nD0rXQWpVk3tiNST07zz/n1147CWK1eA7GwpAapQ4clr/37p+69QQRv3fuW4eFFq2uvurnYkRKQm3gNERIiNlW4Qnjv3yXOAMjKkZ+KEh0tnTaloyMoCuneXujf/6Sfp3h8tuHFDeqaVocxM4PvvpSaeRTUJrFEDWLfOdPz48VL30LNmAZUq2T4ua7t50/R+p6NHgfXrpSuf9jz9S6RpTICICOHhwCuvSDcH37ghtZVfvFhqHrNggdrRWdfs2VIzsJye7jZsAP79V3o/fLh0f0xR8t570kFgdLTU9Mn4wae9e6sTl7UNGiRd4WzWDChTRrr/KS5O6gRixoyie0XA2xt4+WXT8TnPAjJXVhR07y4lto0aSYnv339LJ3hcXYGPP1Y7OiJSm50QRfnWTyKy1MOHUi9RS5cCd+9KvSVNmQK0aaN2ZNYVGCh1D2xOQoJUXpRERgI7duReXlT/I6xYISXzx49LvaIVKwbUrSsluZ06qR2d7UVGSs9DOnFC7Uis48svpQT3/Hkp8S1VSnre08SJ0gkeItI2JkBERERERKQZbAVLRERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINMNR7QCISEkIgbS0NLXDsDnD5XZ1dYWdnZ3KEdmGFpdbi8sMcLkBbS23Ia0uN9HzigkQ0XMmLS0N7u7uaodBRESFJCUlBW5ubmqHQUT/H5vAERERERGRZvAKENFz7Pr165o5a3jjxg1UrFgRADBjxgzo9XqVI7KNBw8eYOzYsQCALVu2wMXFReWIrO/OnTvo1KkTAKBv375wcnJSOSLbSEtLw7JlywAAx44dg6urq8oR2catW7fQsGFDAMCoUaOg0+lUjsg2Hj16hE8//VTtMIjIDCZARM8xNzc3zSRAhsup1+s1kwAZLqeLi4smEiDDZXRyctJMAmS4nK6urppJgAyXU6fTaSYBIqLnF5vAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0w1HtAIhedBkZwIQJwJIlwN27QGgoMHUq0KqV2pHl3zfffIOhQ4eiQYMG2L9/v9rhWN3u3buxaNEixbhixYrB398fbdq0Qc2aNdUJzEYSExPx/fffY//+/bh58yacnJwQFBSEli1bomvXrnB2dlY7xELRsGFD9OnTRx7OzMxEamoqrl69ihMnTmDv3r3IyMhQMULrWblyJd59991cyzds2IC6devaMCLbOXz4MNatW2e2rEmTJmjdurWNIyKi5wUTIKJn1K8fsHo18M47QHAwsGgR0L49EB8PNGmicnD5FBcXh8DAQBw4cADnz59HUFCQ2iHZROfOneHt7Q0hBB48eIA9e/bgyy+/xLBhw1CrVi21w7OKnTt3YvTo0dDpdOjQoQMqVaqEx48f48iRI5g1axYuXryI8ePHqx1modqwYQNu374Ne3t7eHp6Ijg4GLGxsWjRogXmzJmDK1euqB2i1fznP/9BuXLlTMYHBgbaPhgba968Oby8vBTjSpcurVI0RPQ8YAJE9AwOHABWrACmTwdGjpTG9ekD1KgBjBoF7Nmjbnz5kZCQgD179mDt2rUYNGgQ4uLiMHHiRLXDsokaNWooDgSbNGmC9957DwcOHCiSCdCVK1cwduxY+Pn5Yc6cOShVqpRc1q1bNyQmJmLnzp0qRmgdJ0+exD///CMP//rrr6hcuTKGDBmCwYMHY/LkycjMzFQxQutp3rx5kdyWLREcHIwyZcqoHQYRPUd4DxDRM1i9GnBwAN5888k4Z2dgwABg714gMVG92PIrLi4OXl5e6NChA2JjYxEXF6d2SKpxdXWFTqeDg4OD2qFYxeLFi5GWloYJEyYokp8cZcuWRc+ePVWIzPbOnj2LTZs2oWTJkmjQoIHa4RARkQ0wASJ6BocPA5UrAx4eyvE5x1FHjtg8pAKLi4tD165dodPp0KNHD5w7dw4HDx5UOyybSE9PR3JyMpKTk3HlyhUsXboUDx8+RMOGDdUOzSp27tyJMmXKaPaKgLGc+91CQkJUjsR6Hjx4gNu3byted+7cUTssm3j48CFSU1MVLyLSNjaBI3oGSUmAn5/p+JxxV6/aNp6COnToEE6fPo2vvvoKgNQELCAgAHFxcahfv77K0Vnf559/rhh2dHREv379UK1aNZUisp6UlBTcuHEDERERaofy3Lh37x7S0tLg7e2tdihW0717d5Nxer0eCQkJKkRjW4sXLzYZN3nyZBUiIaLnBRMgomeQng7o9abjczrPSk+3bTwFFRcXBx8fH0RFRQEA7Ozs0L17dyxduhQzZswosk3BcvTs2RM+Pj4ApDPl+/fvx/fffw9nZ2fUqVNH5egKV87Zbzc3N5Ujeb5kZGQUmV7vzPnoo49QsWJFxbiivl/n6NixI0qWLKl2GET0HGECRPQMXFykbrCNPXz4pPx5l5WVhRUrViAqKkpxNjg8PBwzZszA77//XuS7i61QoYKiE4QGDRpgypQpWLZsGUJDQ+HoWHR+KnMSHzYDUtLr9UhOTlY7DKsJCwvTbJPHMmXKsBMEIlLgPUBEz8DPT2oGZyxnnL+/beMpiG3btiEpKQkrVqxAcHCw/OrWrRsAaLIzBHt7e1SpUgX379/H9evX1Q6nULm7u6NUqVK4cOGC2qE8N4oXLw5XV1fcvHlT7VCIiMgGis5pTSIV1K4tPe/nwQNlRwg5zxCtXVuNqPInLi4OpUuXxtdff21StnbtWqxbtw5z5syBy4twOasQZWdnA0CRfEBm06ZNsXbtWhw7dgyhoaFqh6O68PBwAMCpU6dUjoSIiGyBV4CInkFsLJCVBcyd+2RcRgawcCEQHg6ULatebJZIT0/H2rVr0bFjR8TGxpq8hg0bhuTkZKxfv17tUG3q8ePHOHnyJBwdHeFnrpeLF1yfPn3g4uKCKVOm4Pbt2ybliYmJWLZsmQqR2V7lypXRrl073Lp1CwcOHFA7HCIisgFeASJ6BuHhwCuvAO+/D9y4AQQFAYsXA5cuAQsWqB3d061fvx7Jycno1KmT2fKGDRuiVKlSiIuLM9uLVFFx4sQJXLt2DYDUCcKBAwdw48YNtGvXrkhe+SpbtiymTZuG999/H7GxsejQoQMqVaqEzMxMHDt2DFu3bkV0dLTaYRa66tWrw9fXF/b29ihWrBiqVKmCqlWr4s6dO/jf//6Hx48fqx2i1Wzbtg3nz583GV+vXj2UL19ehYiIiNTDBIjoGX3/PfDBB8CSJcDdu0BoKPDzz0CzZmpH9nRxcXFwdnZGq1atzJbb29ujQ4cOiIuLw+3bt4tsT0o//fST/N7JyQm+vr7o1atXke4qOiIiAitWrMD333+PHTt2YPXq1dDpdAgKCsK7776LLl26qB1ioctJ6jIzM5GWloarV69i9erV2Lt3b5Fs6mho+vTpZsfPnDmTCRARaQ4TIKJn5OwMTJ8uvV40ljRtW7hwIRYuXGiDaGyvcePGaNy4sdphqKZcuXIYP3682mFY3b59+7Bv3z61w1BF9+7di/TV27yEhYUhLCxM7TCI6DnEe4CIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWmGo9oBEFHuUlNT1Q7BZgyXNSMjQ8VIbMtwWdPT01WMxHYMlzMzM1PFSGzLcFnT0tJUjMS2DJf10aNHKkZiW1paVqIXjZ0QQqgdBBE9kZqaCnd3d7XDICKiQpKSkgI3Nze1wyCi/49N4IiIiIiISDN4BYjoOSOE0FTzmByGy+3q6go7OzuVI7INLS63FpcZ4HID2lpuQ1pdbqLnFRMgIiIiIiLSDDaBIyIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABInqKSZMmwc7OTn5dunRJ7ZDQr18/RUzPo+3btytiXLRokUX1Fi1apKi3fft2q8ZJ1tWpU6dct4HExETMnj0bvXr1QqVKlRTfe2BgYK7zvHr1KhYuXIi+ffuiTp068Pf3h06nQ/HixdGgQQNMmTIF9+7ds+pyGXoefyOILly4AEdHR9jZ2cHf3x9paWlqh0T03GACRGRjPFgirSR5f/zxBzZs2AAAKFu2LHr16qUoX7NmDYYPH45ly5bh4sWLFs/3o48+wuuvv47vv/8ehw8fRlJSEjIzM3H//n0cPHgQEyZMQI0aNXDmzJlCXR4quMDAQHl7j4yMVDscTahUqRJiY2MBAElJSfj8889Vjojo+cEEiIieK4GBgYiJiZFfpUqVUjskKqCxY8fK74cPHw4nJ6dcp3V3d8+zPDcVKlRA+/btUadOHcX4K1eu4NVXX4UQIt/zJCoqRo4cKb//9NNPcffuXRWjIXp+MAEioudKZGQkVq9eLb+qV6+udkhUAEeOHMHu3bsBAHZ2dujRo4fJNHXr1sW8efNw7Ngx3L9/H/7+/hbN287ODp06dcL+/ftx8eJFbNy4EYcOHcKqVasUTUKPHDmCw4cPF84CEb2A6tWrh6CgIABAcnIylixZonJERM8HJkBE/9+CBQsQFhYGFxcX+Pj4oG/fvvj333+fWm/r1q3o2rUrypUrB71eD1dXV5QvXx4REREYNWoU9u3bB+BJs6cPP/xQUb9ChQoW3ffwNIsWLULdunXh6uqKUqVKoXfv3rh8+bLJdAcOHMC7776LZs2aITAwEB4eHtDpdChdujSioqIwe/ZsPHr0KNfP2bVrF/r27YugoCC4ubnBzc0NFStWRI8ePbBjxw6LYr19+zZq1qwpL7dOp8OaNWvk5citeZi5+4pOnDiBbt26wdvbG87OzqhduzaWLVtm9nOzsrLw+eefIyQkBHq9HmXKlMGQIUNw8+bNZ7qv6tChQ+jduzcqVqwIFxcXODs7IyAgAC+99BLefvtt/Pbbb4r4+/fvr6gfFRWV62dnZ2dj+fLlaN++PXx9fU3udblz545JPObW4S+//IKoqCh4enqaNL1MTU3FF198gWbNmqFkyZLQ6XTw8fFBdHQ0Nm7cmK91kePbb7+V3zdq1AgBAQEm0zRt2hQDBw5EzZo1YW9v+b+jcePG4aeffkKDBg0U42NjY9GkSRPFuHPnzuUrbiEE1qxZg06dOinuLWrcuDG+/vrrPPeNvJw+fRpDhw5FSEgI3N3d4eLigsqVK2P48OFmm8FeunRJ8R1OmjQJhw8fRvv27eHp6YkSJUqgW7duct07d+5gyJAh8PPze+p+UFjxXL58GQMGDICfnx/0ej2qVq2KWbNmKepFRkbCzs5O8Vu0Y8cOk3nlsHRfKix37tzB8OHDUaZMGTg7OyMkJASffPIJMjMz82y2t2XLFgwZMgQNGzZEuXLl4ObmBr1eDz8/P7Rt2xZLliwxe/UxZ33k/N5nZmbi448/RkhICJydneHv74+hQ4fi9u3bJnUfPnyIGTNmoFGjRihRogScnJxQokQJVKlSBTExMZg+fbrZet26dZPfz5s379lXGlFRIIhIvP322wKAyatUqVLi1VdfVYxLSEiQ6y1cuNBsPcPXgAEDLJ62fPnyFsXbt29fRb3hw4ebnV/p0qXFmTNnFHXHjRv31DheeuklkZaWpqiXlZUl3nrrrTzrvf322/L08fHxirKFCxcKIYS4f/++qFu3rjxep9OJdevW5bpO4+Pjc51nly5dhE6nMxvL4sWLFfFnZ2eL2NhYs9OWK1dOtGjRQjHOUlu2bBFOTk55rpcWLVqYjT+3V44HDx6I5s2b5zmtn5+f+PPPPxUxGa9D423YcDs+c+aMCA4OzvMzBg4cKLKzsy1eJ0II4e/vL9cfP368RXXKly+f733B2CuvvKKIfdOmTRbXTU1NFe3atctzXTRo0EDcunVLUW/ixIm5/kYIIcScOXPy3Ebc3d3FL7/8oqiTkJBgsg3p9Xqz3/+pU6dEpUqVLNoPCiuetm3bCk9PT7P1J0+eLNeLiIh46vY+ceJEIUT+9qXCcPPmTVGlShWzn9OmTRvFNhwREaGo26tXr6cuV9euXUVWVpainuH68PPzEy1btjRbNzg4WNy4cUOul52d/dTfAgBi586dJsu5ZcsWxTQXLlwotHVI9KJiAkSa98svv5j8E6lXr55o2rSp2X/Ghgc3QUFB8nhnZ2cRFRUlOnToIGrXri2KFSsmgCcJUHx8vIiJiREhISGK+bVr107ExMSImJgY8dZbb1kUs3ECBECULVtWtG7dWnh7eyvGN2zYUFF33LhxwsHBQVSvXl1ERkaKzp07i1atWgkfHx9Fvf/+97+Keh988IHJZ1apUkV06NBB1K9fXzg4ODw1AUpNTRVNmjSRx+l0OrF+/XrF5+QnAcqZR9OmTU3Wa2BgoGK+3377raLcwcFBNGrUSNSvX1/Y2dmZzNdShgcwDg4OonHjxiI6OlrUrVtXlChRQnHQduLECRETEyPq1aun+KxmzZrJ20BMTIw8b+OEzcvLS7Rq1Uqx3QEQvr6+4u7du7muQwDC3t5e1K5dW7Rt21b4+PiIhIQEkZaWZnLgXLt2bdGhQwdFMgJAfPLJJxavk3Pnzinq/vTTTxbVe9YEKC0tTZQuXVqeh4uLi7hz547F9Xv27GmyDeXsz8b7rKG8EqDNmzcrti9XV1fRokUL0apVK+Hs7CyPd3d3F+fPn5frGScchr8xxt+Ni4uLACBCQ0NFo0aN8twPCjMee3t7ER4erjihAUC4ubmJ5ORkIYQQEyZMEDExMcLV1VUu9/b2VmzvK1euFELkb18qDD169FDE7e7uLlq0aGGyfwHmEyCdTidq1aolmjdvLjp37iyioqJE8eLFFfWWL1+uqGcuIQwODhYtW7YUHh4eivGvvvqqXG/Xrl2KsjJlyoiOHTuK5s2bi+DgYGFvby8A8wnQvXv3FN/5d999V2jrkOhFxQSINK9Vq1aKfyzffPONXBYfH29ycGx4cGN4wBAXF6eYb2ZmpoiPjxcbNmxQjH/a2WJLGCdAbdu2FRkZGUIIIW7dumWSDOzZs0eum5CQIO7du2cyz0ePHonGjRvLderVqyeX3bp1S7GsDg4OYvXq1Yr6iYmJ4tdff1WsO8MY5syZozjA0ev1YuPGjSZx5CcB0ul0Yu/evUII6QpVmzZtcl23lStXVpQZXnWaN2+eyUGJpapWrSrXmTZtmqIsOztb7Nu3z+QgKK9lzHH06FHFNFWqVBHXr1+Xl7Vfv36KcsPPNp6/TqcTv/32m1z++PFj8fjxY/HVV18ppluxYoVimk6dOsllnp6eJlcFc/PDDz8o5nvu3DmL6j1rAmR8hfL//u//LK57/PhxRd0hQ4Yornp9+umnivLdu3fLZXnt04bJQWBgoEhKSpLLLly4IJ8oASDeeOMNucw44bC3t5f343v37ikSCgBi6NChcl3jq2DWiAeAWLNmjVw+cODAPLdpw+/WOJnIUZB9qaASExPlpAGAKFmypLydZmVliT59+uSZAJ09e1akpqaazDclJUVUrFhRrhcbG6soN06ABgwYIG9nCQkJigTe3t5eJCYmCiGEWLFihTzew8NDpKenK+Z769Yt8f333+f6/6RMmTJy/WHDhhVklREVKUyASNMyMzMVB/Zly5Y1abLQunXrXA8matSoIY9/6aWXxLx588TOnTvFzZs3c/1MayRAOUlAjrlz5+Z6cJydnS1WrFghOnXqJMqVK6dYfsOXh4eHXGflypWKMsMDo9wYJyuGV6acnZ3F5s2bzdbLTwLUu3dvRd0ZM2YoynMOGP/991/FeOOrYkIIk2ZglurYsaNcJyQkRHz99ddi27Zt4urVq7nWsSQB+vjjjxXTzJ07V1F+9epVRXnTpk1znf+gQYPMxmHY3MvBwUFxVj4mJkaEhYUp5rN161aL1sns2bMV9Sy9CvMsCdCoUaNM1kfOSQFLfPLJJ4r6zZs3V6wL498Bw2Z9ue3T165dU4yvVKmSyTr28vKSywMCAuR5GiccrVu3VsRr/N0Ybm/GiW3OflCY8TRp0kQRz5o1axTly5YtU5RbkgAVZF8qqKVLlyriHTNmjKLc+DfDOOZHjx6JuXPnitatWws/Pz+zzRMB6aqcIeMEyDABFUKIsWPHKspzTqz9+eefivHDhw8Xq1atEseOHRMPHz586vLWrFlTrvvKK68UYI0RFS2OINKwW7du4eHDh/Jw1apVTW7Grl69eq433o4bN07u3Wrv3r3Yu3evXFahQgXExMRgzJgxKFmypBWif6JatWqKYeOe0xITE+X3/fv3x+LFi586zwcPHsjvjW+Kbty4cb5jvHXrlvx+woQJaNOmTb7nYSwsLEwx7OnpqRjOyMgAAJPOLGrWrGkyr+rVq+f7hnkAGDNmDDZt2oSsrCycOnUKQ4cOlcv8/f0RHR2NsWPHoly5cvmar3EHFsbfqZ+fH7y8vORubc11eJGjadOmZscbfq9ZWVlyRxSWxpQb44eQFitWzKJ6BSGEwNChQ/G///1PHvfSSy/h559/hk6ns3g+xtv4tm3b8pzeknVhPM2FCxdw4cKFXKe/cuUKsrKy4ODgYFJmvI+7u7vL74sXLw4/Pz+zZcCT/aAw47F038sPa+1L5jztN6FMmTIoXry42QfqZmVloW3btk/dRgDl76gxLy8v+Pr6Ksbl9ttdp04dtGvXDps2bQIAfPXVV/jqq68AAE5OTggPD8cbb7yBPn36mP0sDw8P+b0tHxJM9LxiL3BEBvLb+9err76K+Ph49OjRw6SXq4SEBHz22Wdo3749Hj9+XJhhFti+ffsUyY+9vT0aNmyILl26ICYmBuXLl7dJHB999BEOHjz4zPMpUaKEYtjcgZo5+f2e89K4cWMcPHgQAwYMQMWKFRXzvnr1Kr799ltERETkeSBkbYYHx8/C0ifJFy9eXDGcnJxcKJ9vLCsrC/369VMkPy1btsSWLVsUB3zWYOm6yA8hBNLT082WGScYhidqjMtsEU9B9728qLkv5ec3YdWqVYrkR6fToVmzZujatStiYmLg7e0tl4lCeg6VnZ0d1q1bh1mzZiEiIkJxUiEzM1PunfPLL780W//+/fvye+P9k0iLmACRpuV0nZzj9OnTJv+wTp06lec8IiMjsWzZMiQmJiIlJQV//fUXhgwZIpcfOHAAf/75pzxcmAffOf7++2/FsHHMZcuWBQDs2bNHMX7lypXYu3cv1q5di9WrV6Nq1apm52/cPXfO813yY9CgQXB1dQUApKSkoF27dk9dt4UlZ/lznD592mSakydPFnj+YWFhmD9/Pi5cuIC0tDQcP35c0d35pUuX8Msvv8jDlmwDxme5jb/jpKQkxUMN8zornlsX04YJr6urK9LT0yGkptFmX8OGDXtq3ABQunRpxbC5rrqf1aNHj9CtWzd8//338riuXbvi559/hpubW77nZ5z879ixI891sXr16qfO0/g76d+/f57zFEKYXL0pTGrGY+nvXn73pYIyXhfGvwlXrlzJ9UqJ8e/o7t27sWPHDqxZswarV6+2+Ir/3bt3ce3aNcW43H67AUCv12PEiBHYvn07Hjx4gKSkJGzevFlx9eqbb74x+1mG+yAfLk3EBIg0ztHRUfHckH/++Qdz586Vh3fu3Jnncye+/PJL7Nu3T06a3NzcEBYWhq5duyqmM2x64uLioii7evXqMy0DAEyePFl+PsmdO3fw+eefK8pznmGRmZmpGG94oPjrr79i69atZuffokULRaL43XffmTSXSkpKynNdNWzYECtWrJDPFN++fRutW7fGP//885Sle3b+/v6K5O6PP/5QLOv8+fML1PwNABYuXIht27YhKysLAODs7IwaNWqgV69eiunyuw20a9dOMTxjxgy5GWF2djbGjx+vKG/btm2+Yzf8jLS0NIwcOdLkOTfJyclYvnw5evfubfF8a9eurRg2Tt6eVXp6Ojp37oy1a9fK4wYMGIAffvgBer2+QPM0Xt+jR482eabK48ePsW3bNvTs2dOiZ4T5+voqmootX74cv//+u8l058+fx5QpUzBnzpwCxW4pNeMx3OaTkpLMTlOQfSmv54blJSIiQnHVat68eXJzs+zsbIwdOzbXunn9js6fPx9nzpyxKAYAGD9+vPz/459//lE8p8fe3h7NmjUDICV+s2fPVvxW+Pr6ok2bNqhVq5Y8zlzTzHv37inWuXHzRSIt4j1ApHnvvvuu4mB48ODBWLBgAVxcXLBv3z5kZ2fnWnfu3Ll4++23UapUKVSrVg1eXl64f/++4l4gAPKTuI3fA9JZ6/DwcDg5OaFjx47o169fvpdh06ZNCAoKQkhICA4fPoybN2/KZQ0aNECjRo0AAPXr1zf57GbNmiE5OVl+YKs5JUuWxHvvvYdp06YBkJoexcbGomrVqggKCsKtW7dw6NAhDBkyBK1bt851PtHR0fjmm28waNAgAFI7/FatWmHXrl1WPyv5f//3f3jzzTfl4Xbt2qFhw4Z49OjRMzXHW7NmDTZu3IjixYujevXq8Pb2Rnp6usn6zGsbGDJkCJYtWwZnZ2c0aNAAo0aNQq1atdClSxesW7cOgHSGukqVKqhXrx4SEhIUCVvp0qXx1ltv5Tv2gQMHYubMmfL9L19//TVWrVqFWrVqQa/XIzExEX///TcyMzPz1TwyODgYfn5+8kHXn3/+iejoaJPpNm7ciClTpsjDhgdpSUlJaNiwoTz8zTffoE6dOgCke0U2b94slzk7O+PevXvo3r27yWcMGzbM5CGW5oSGhuKVV17BqlWrAEjNRcuVK4d69eqhePHiuHnzJo4fP46UlBQAUjNOS0yZMgXR0dEQQuDhw4do2bIlatasicDAQKSnp+PMmTPygffEiRMtmuezUCueoKAg+erG2bNnUbduXflBo5999hkCAwMLtC8VlL+/P7p37y4/LDYpKQk1a9ZE/fr1cenSJZw/fz7XuvXr11ckhw0bNkSTJk1w9epVHDlyBHZ2dhY3fVuwYAF27tyJ8uXLY//+/YrmfbGxsXLT6lu3bmH48OEYMWIEKleujAoVKkCv1yMhIQHHjh2T65hbNwcPHlTEExERYVFsREWa1bpXIHqBDB061GwPPh4eHiI6OtpsD09CCFG9enWz9Qxfhs9yEELqJtX4mTs5L8Pn6OTFuBe41157zez8vL29xalTpxR1jbuKznnVqlXL5LkzhrKyssQbb7yR57Ja8iBUIUyfKVSnTh1x//59IUT+eoEznOfT6ub1INSKFSsqukN3cnKy6HsQQogOHTo8dRto2rSpyMzMVMRi2IOg4atz587ydPfv33/qgyR9fHzE/v37LV4Pxv7+++9cH6JpvI7yY/DgwYrlN8eShwObWwZzz8HK7WW8jeQlOTk51/3D+PXPP//I9Z7Ws+PXX3/91Ad8AsoHiBr3upbzsNAchtuFcY95T/v+rRHP0/bNVatW5fo5hw8fFkIUbF/Kz7ZuLK8HoUZHRysehNqqVSu53sOHD0VoaKjZem3atFE868z4uzH83gICAsTLL79sdj6VKlUS165dk+sdPHjwqevGycnJ5LELQgjx/vvvy9NUrVrV4vVDVJSxCRwRpB515s6di9DQUOj1enh7e6N79+44dOiQfNbZnFmzZmHUqFFo3LgxypYtCxcXFzg5OcHX1xetW7fGwoULERcXp6jj5uaGrVu3Ijo6Gl5eXoVyT9DixYvx9ddfIzQ0FM7OzihZsiR69uyJgwcPmtzX8+OPP2L06NEoW7YsnJycULZsWYwYMQI7d+7M894Je3t7zJ07Fzt27EDv3r1RsWJFuLi4wMXFBRUqVED37t3RpUsXi+KdPHkyXn/9dXn4r7/+QqdOnRQ98hU2Ozs7rFixAjNmzECVKlWg0+ng7++Pt956CwcOHFB8tnHPTHmZMGECPvjgA0RFRSEwMBDu7u5wdHSEt7c3mjVrhlmzZmHLli1wdHxywd3Ozg6//PILXn31VZQuXTrXe3Q8PDzw+++/Y8mSJWjbti1Kly4NR0dHFCtWDPXq1cOkSZNw8uRJNGjQoMDrJSQkBEePHsWXX36JqKgoeHt7w9HREa6urggKCkJMTAzmzJmDAwcO5Gu+hlfbdu3ahStXrhQ4Rltxd3fHpk2bsHbtWnTp0gUBAQHQ6/XQ6XQICAhAq1atMG3aNJw9e9bkvrK8DBkyBMePH8eIESNQs2ZNFCtWDA4ODvDy8kLdunUxdOhQbNq0Kc9mV4VJjXhiY2Mxb9481KpVS9Gc1lBB9iXDe2i8vLxMesvLi7e3N/bs2YNhw4bB398fer0eVapUwSeffIIVK1bgxo0b8rSGvwl6vR7bt2/HoEGD4OPjA51Oh0qVKmHixIlYv369xR1CODg4YPXq1fjss88QEhICvV4PX19fDB48GHv37oWPj488bdWqVTF//nz07dsXNWrUkH8LXFxcEBwcjP79++PAgQPo2LGjyef88MMP8vucq+9EWmcnRCF1UUJE9Jy7fPmy2aZc27dvR8uWLeV7D/r06WNRV+GUt8aNG8s3jE+fPh0jR45UOSIqalq1aiU3Yf7uu+/Qv39/i+s+evQId+7cMXvCY+rUqfjggw/k4fzOOzeRkZHYsWMHAKnjDePu1wvbgQMHEB4eDkDqjv7SpUsmPfgRaRETICLSjJyrYQ0bNoS/vz8ePXqEU6dOYfPmzfK9XjqdDocPH87XmWQy748//pDvNyhbtiwuXLgAJycnlaOioiIjIwNeXl5IT09Hq1at8uyExZxr166hTJkyaNiwIWrUqAEfHx/cvXsXe/fuxaFDh+TpKlWqhJMnTxa4gw1Dtk6AunfvLl8Bmjx5siKpI9IydoJARJpy5syZXHtp8vDwwJIlS5j8FJJmzZohOjoaGzZsQGJiIuLi4grUyQeRObt370Z6ejpcXV3x7bffFmge2dnZ2LNnj0nX1jmCg4OxcePGQkl+bO3ChQtyb51+fn547733VI6I6PnBK0BEpBlxcXFYv349Dh8+jOvXryMtLQ2enp6oWrUqWrVqhTfffLPQHhpKRM+3jIwMzJw5E/Hx8Th9+jRu3ryJ7OxslCxZErVq1ULnzp3Rp08fk27rn4WtrwARkXlMgIiIiIiISDPYCxwREREREWkGEyAiIiIiItIMJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwAbJQRgYwejTg7w+4uADh4cCWLWpHZV0pKcDEiUDbtkCJEoCdHbBokdpRWdfBg8CwYUD16oCbG1CuHNCtG3D2rNqRWdfJk8ArrwAVKwKuroC3N9CsGbBhg9qR2da0adJ2XqOG2pFY1/bt0nKae+3bp3Z01vXXX0CnTtJvmqur9F1/+aXaUVlPv365f9d2dsCVK2pHaD3nzgGvvgoEBEjfddWqwOTJQFqa2pFZz6FD0v9sDw+gWDGgdWvgyBG1oypc+Tk2OXVKms7dXZr2tdeAmzdtGm6hsHSZDxwAhgwB6tYFnJyk6cg8R7UDeFH06wesXg288w4QHCxteO3bA/HxQJMmKgdnJbduSf8sypUDatWSDpqKuk8+AXbvlpKB0FDg2jVg9mygTh3pwLCoHhhfvgwkJwN9+0pJfloasGaNdKD47bfAm2+qHaH1/fsv8NFHUuKrFSNGAPXrK8cFBakTiy389hsQHQ2EhQEffCAdFF24IH33RdWgQUDLlspxQgCDBwOBgUCZMqqEZXWJiUCDBoCnp3RSq0QJYO9e6SDy0CHgp5/UjrDw/fWXdDxStqy0nNnZwDffABER0oFxlSpqR1g4LD02+fdf6USep6f0256SAnz2GXD8uLQ+dDqbhv1MLF3mX34B5s+Xjl8qViz6J2+fiaCn2r9fCECI6dOfjEtPF6JSJSFeekm9uKzt4UMhkpKk9wcPSutg4UJVQ7K63buFyMhQjjt7Vgi9XohevdSJSS2PHwtRq5YQVaqoHYltdO8uRPPmQkRECFG9utrRWFd8vLQ/r1qldiS2c/++ED4+QnTpIkRWltrRqGvnTun7nzZN7UisZ9o0aRlPnFCO79NHGn/njjpxWVP79kJ4eQlx69aTcVevCuHuLkTXrurFVdgsPTZ56y0hXFyEuHz5ybgtW6Tpv/3WJqEWGkuX+do1IdLSpPdDh0rTkXlsAmeB1asBBwflWXBnZ2DAAOmMUmKierFZk14P+PqqHYVtNWpkelYoOFhqEnfqlDoxqcXBQTqTeO+e2pFY3x9/SPv5F1+oHYntJScDjx+rHYX1LVsGXL8uNXO0twdSU6Uz5Fq0bJnUNKZnT7UjsZ4HD6S/Pj7K8X5+0vf/Ip39t9TOndLVvpIln4zz85OuAP38s3QFpCiw9NhkzRqgY0fpqkmOli2BypWBH36wXnzWYOky+/hIt2nQ0zEBssDhw9IO4+GhHN+ggfS3qLWvJSUhpAMnb2+1I7G+1FTpUvuFC8DMmcCmTUCLFmpHZV1ZWcDw4cDAgUDNmmpHY1v9+0u/a87OQFQU8OefakdkPVu3Sst65YrUFMjdXRp+6y3g4UO1o7OdzEzp4K9RI6kJXFEVGSn9HTBA+h+dmAisXAn8739S08+i2NQ1I8P8wa+rK/DoEXDihO1jUsuVK8CNG0C9eqZlDRpIx3WkbbwHyAJJSdJZFGM5465etW08ZFtxcdKP6eTJakdife+9J93zA0hnSbt2le6BKsrmzJHugdq6Ve1IbEenA2JipPsYvb2Bv/+W2sY3bQrs2SPdI1PUnDsnXenq3Fk6KP7vf6V29F99JV3lXL5c7Qht49dfgdu3gV691I7Eutq2BaZMke79WL/+yfhx44CpU9WLy5qqVJHuVc3Kkq7gA1Lis3+/9L4od3hhLClJ+pvbsdudO1LCqNfbNi56fjABskB6uvmdxNn5STkVTadPA0OHAi+9JHUQUNS98w4QGysl9T/8IP0jffRI7ais5/ZtYMIE6Yb4UqXUjsZ2GjWSXjk6dZK+99BQ4P33gc2b1YvNWlJSpM49Bg9+0utb167S9v3tt9IJjuBgdWO0hWXLpN6hunVTOxLrCwyUboKPiZGahW3cKCVEvr5SxwhFzZAh0hXNAQOAUaOkJp5Tpz5JBrR0rJKzrE87dmMCpF1sAmcBFxfpTIGxnGYTbG9ZNF27BnToIPUgk3MfWFFXtarURrpPnydtxqOjpWaARdH48VLvUMOHqx2J+oKCpKsj8fFS4lvU5PxO9+ihHJ9zH8zevbaNRw0pKVLvZ23aKO8TKYpWrJDu250/H3jjDSnZXbBAOpE1erR08qOoGTwYGDtWSnKrV5ea9F64ICVDgNTsUyty9nceu1FumABZwM/vyRkUQznj/P1tGw9Z3/37QLt2UtOYzZu1+x3HxkrPRiqKXWmeOwfMnSvdD3D1KnDpkvR6+FC6T+LSJamZhJaULStdEUlNVTuSwpezDxvfFF+6tPT37l3bxqOGH3+UroIV9eZvgNT9c1iY9AwgQ506SeugqN4DMm2adM/qzp3AsWPS73dOZx+VK6sbmy3lNH3L7ditRAle/dE6JkAWqF1bOgDM6VUmR0672tq1bR0RWdPDh9JVj7Nnpasg1aqpHZF6cpoR3L+vbhzWcOWKdGAwYgRQocKT1/790ndfoYI27vsydPGi1DykKJ4prltX+mt8H0TOPZxaaAIZFyd9t506qR2J9V2/bv5KZmam9Lco93zo5SU9DyinU5etW6VEsGpVdeOypTJlpH3aXMcuBw7wuI2YAFkkNlb6IZ0798m4jAxg4UIgPFw6a0pFQ1YW0L271Bxm1Srp3h8tuHHDdFxmJvD991IzgaKYBNaoAaxbZ/qqXl3qNnXdOqktfVFk7knoR49KN4u3bi11gFHU5NzzsmCBcvz8+YCj45New4qqmzelA+EuXaRewYq6ypWlqzzGV6+XL5e279BQdeKytZUrpatA77xTNPfrvMTESCcxDR9V8vvv0jbxyivqxUXPB3aCYIHwcGlnef996UAxKAhYvFhqImP8z7SomT1bagaWc5Z0w4YnT00fPly6P6Yoee896SAwOlpq/rR0qbK8d2914rK2QYOkK5zNmklnzq5dk84Wnz4NzJhRNK8IeHsDL79sOj7nWUDmyoqK7t2lxLZRI6kJ2N9/Syd4XF2Bjz9WOzrrCAsDXn8d+O476ex/RITUC9yqVdJve1Fv5rpypbTcWmj+BgD/+Y/UjX/TplKHByVLSgfDmzZJXd4Xxe/7jz+kq9atW0vLu2+fdKK2bVvg7bfVjq5wWXJsMnastH9HRUnLn5ICTJ8uXRnr31+10AvMkmW+fBlYskQal3P1K6fXw/Llgddes2nIzze1n8T6okhPF2LkSCF8fYXQ64WoX1+IzZvVjsr6ypeXniRs7pWQoHZ0hS8iIvflLcp7y/LlQrRsKYSPjxCOjtLTxFu2FOKnn9SOzPYiIoSoXl3tKKxr1iwhGjQQokQJ6fv28xOid28hzp1TOzLrevRIiEmTpN81JychgoKEmDlT7ahso2FDIUqXFuLxY7UjsZ39+4Vo1076v+3kJETlykJMmyZEZqbakVnH+fNCtG4thLe3dJxStaoQ//2vEBkZakdW+Cw9NjlxQlonrq5CFC8uRK9eQly7plbUz8aSZY6Pz32aiAj1Yn8e2QlRVPt3IiIiIiIiUtJYi1AiIiIiItIyJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDEe1A8gvIQTS0tLUDsPmDJfb1dUVdnZ2KkdkfVpcZoDLDXC5izotLjPA5Qa43EWdFpcZ0O5yG3rRlvuFS4DS0tLg7u6udhhERERERAQgJSUFbm5uaodhMTaBIyIiIiIizXjhrgAZun79+guVbT6LGzduoGLFigCAGTNmQK/XqxyR9T148ABjx44FAGzZsgUuLi4qR2Qbd+7cQadOnQAAffv2hZOTk8oR2UZaWhqWLVsGADh27BhcXV1Vjsg2bt26hYYNGwIARo0aBZ1Op3JE1peSkoIvvvgCALB06VI4OzurG5CN3Lt3DwMHDgQAtGvXDg4ODipHZBsZGRnYsmULAP7fLur4f1tb/7czMzOxePFitcMokBc6AXJzc9PMD6nhcur1ek38kBouo4uLi2Z+SA2X08nJSTM/pIbL6erqqpkEyHA5dTqdJhIgw2V0dnbWTAJkuJwODg5wdHyh/wVb7PHjx/J7/t8u2vh/W1v/t19kbAJHRERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBERERERKQZjtb+gIwMYMIEYMkS4O5dIDQUmDoVaNXK2p9c+L755hsMHToUDRo0wP79+9UOx2Zu3LiBX3/9FX///Tfu3bsHR0dHlClTBvXq1UOzZs2g0+nUDrFQrV+/Hh9++GGu5YsWLULNmjVtGBFZy8qVK/Huu+8qxpUsWRJVqlTBkCFD0Lx5c5Uis57Dhw9j3bp18rCjoyNcXFxQunRpVKlSBWFhYdDr9SpGaD1bt27FF198YbYsNjYW/fr1s2k8RESkDqsnQP36AatXA++8AwQHA4sWAe3bA/HxQJMm1v70whUXF4fAwEAcOHAA58+fR1BQkNohWd2xY8fw7bffwtHRES+99BL8/f2RlZWFc+fOYfXq1bh69Sr69OmjdphWMXjwYJQpU8ZkfEBAgArRkDX95z//Qbly5SCEwM2bN/HDDz+gd+/eWLx4MVq9iGdrLNC8eXN4eXkhKysLKSkpSEhIwKZNm7Bnzx707NkTvr6+aodoNb169TJZvvLly6sUDRER2ZpVE6ADB4AVK4Dp04GRI6VxffoANWoAo0YBe/ZY89MLV0JCAvbs2YO1a9di0KBBiIuLw8SJE9UOy6pu3ryJuXPnokSJEnjvvfdQvHhxuSwqKgo3btzAsWPH1AvQyho3boxq1aqpHQbZQPPmzVGrVi15uEePHqhVqxZ+/PHHIpsABQcHKxL8Zs2a4eLFi4iLi8OyZcswfPhwODk5qRih9dSrVw/BwcFqh0FERCqx6j1Aq1cDDg7Am28+GefsDAwYAOzdCyQmWvPTC1dcXBy8vLzQoUMHxMbGIi4uTu2QrO7XX39FRkYG+vbtq0h+cpQuXRotW7a0fWBEVubp6QlnZ2c4Olr9IvlzpWLFioiIiMC9e/dw9OhRtcMhIiKyCqsmQIcPA5UrAx4eyvENGkh/jxyx5qcXrri4OHTt2hU6nQ49evTAuXPncPDgQbXDsqqjR4+iVKlSmmjqZ05KSgru3r2reN27d0/tsMgKHjx4gNu3b+P27ds4c+YMxowZg9TUVHTt2lXt0Gwu50rYhQsXVI7EelJTU3H//n3Fi4iItMOqpzeTkgA/P9PxOeOuXrXmpxeeQ4cO4fTp0/jqq68AAE2aNEFAQADi4uJQv359laOzjvT0dNy7dw+1a9dWOxTVvPXWWybjdDod9u7dq0I0ZE3du3dXDOv1enz++eeIiIhQKSL15Fz9unPnjtqhWM348eNNxv38888qREJERGqwagKUng6Y60zI2flJ+YsgLi4OPj4+iIqKAgDY2dmhe/fuWLp0KWbMmAEHBweVIyx86f//y3HO+bI0aPTo0SY3Rtvbs+f4ouijjz5CxYoVAQC3bt3CmjVrMHLkSLi7u6N9+/YqR2d7Op0OGRkZaodhNW+99ZbZDk6IiEgbrJoAubhI3WAbe/jwSfnzLisrCytWrEBUVBQSEhLk8eHh4ZgxYwZ+//13tG7dWsUIrcPl/385D3O+LA2qUaMGO0HQiLCwMEUnCC+//DJat26NcePGoWXLlkWuq/enefToEdzc3NQOw2oqV67MThCIiDTMqqez/fykZnDGcsb5+1vz0wvHtm3bkJSUhBUrViA4OFh+devWDQCKbGcILi4uKF68OK5cuaJ2KEQ2Z29vj0aNGuH69euKEx9acP/+fTx8+BAlSpRQOxQiIiKrsOoVoNq1pef9PHig7Agh5xmiL8LtJXFxcShdujS+/vprk7K1a9di3bp1mDNnjnzFpCgJDQ3FH3/8gQsXLqBSpUpqh0NkU48fPwYg3TCvJTm9v2m18xMiIir6rHoFKDYWyMoC5s59Mi4jA1i4EAgPB8qWteanP7v09HSsXbsWHTt2RGxsrMlr2LBhSE5Oxvr169UO1SratGkDvV6PxYsX48GDByblN27cwNatW1WIjKzJyckJPj4+RboJ1NNkZmbijz/+gE6n01RTqYsXL2LHjh3w8vJCaGio2uFQIdPpdChTpgyKFSumdig2lZaWhtOnT+PWrVtqh2JTGRkZSEpKQnJystqh2Ex6ejoSEhJw9+5dtUOxKf7fzj+rXgEKDwdeeQV4/33gxg0gKAhYvBi4dAlYsMCan1w41q9fj+TkZHTq1MlsecOGDVGqVCnExcWZ9CJVFJQuXRoDBw7E3Llz8cEHH+Cll15CmTJl8PjxY1y4cAGHDh1Co0aN1A7Tanbv3o1Lly6ZjA8NDUVAQIDtA7KRwMBAvPvuu9i4cSM2btyodjg2sW3bNpw/fx6A1AnCunXrcPHiRQwbNqzIHiyeO3cOt27dQnZ2NlJSUnDx4kVcvHgRnp6e6NmzZ5F9CKqWBQcHY+rUqVixYgVWrlypdjg2c+DAAURFRWHixImYNGmS2uHYzKVLl/DZZ58hOjo61+OYoubkyZMYNGgQ3nzzTQwaNEjtcGxGi/+3n5XVn/L3/ffABx8AS5YAd+8CoaHAzz8DzZpZ+5OfXVxcHJydnXN9Ery9vT06dOiAuLg43L59GyVLlrRxhNZXu3ZtTJw4Eb/++iuOHDmCHTt2wNHREQEBAXjllVfQtGlTtUO0mjlz5pgdP3HixCKdAGnR9OnT5ffOzs6oVKkSPv74Y7z22msqRmVd27ZtAwA4ODjAxcUFPj4+aNeuHcLCwqA3130nERFREWH1BMjZGZg+XXq9aCxp2rZw4UIsXLjQBtGox8fHB3369FE7DJvp1KmTZs6WmXPu3DkMGTJE7TBsonv37kXy6m1ewsLCEBYWpnYYqmjZsiVatmypdhiqOXnyJLp06aJ2GDYXGRkJIYTaYdhclSpVMG/ePLXDsKl69erh0KFDaodhc1r6v11Y+FATIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESa4ah2AM8iNTVV7RBsxnBZMzIyVIzEdgyXMz09XcVIbMtwWTMzM1WMxLYMlzUtLU3FSGzLcFkfPXqkYiS2Y7icDx8+VDES2zJc1qysLBUjsS3DZeX/7aKN/7e1+3/7RWMnhBBqB5EfqampcHd3VzsMIiIiIiICkJKSAjc3N7XDsBibwBERERERkWa8cFeAhBCaah6Tw3C5XV1dYWdnp3JE1qfFZQa43ACXu6jT4jIDXG6Ay13UaXGZAe0ut6EXbblfuASIiIiIiIiooNgEjoiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSDCZARERERESkGUyAiIiIiIhIM5gAERERERGRZjABIiIiIiIizWACREREREREmsEEiIiIiIiINIMJEBERERERaQYTICIiIiIi0gwmQEREREREpBlMgIiIiIiISDOYABERERERkWYwASIiIiIiIs1gAkRERERERJrBBIiIiIiIiDSDCRAREREREWkGEyAiIiIiItIMJkBERERERKQZTICIiIiIiEgzmAAREREREZFmMAEiIiIiIiLNYAJERERERESawQSIiIiIiIg0gwkQERERERFpBhMgIiIiIiLSjP8Hh/c8wMfOpekAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [src.view(Layout(len(src.data), 1)), dst.view(Layout(len(dst.data), 1))],\n", + " titles=['src backing store (6 elements)', 'dst backing store (12 elements, gaps)'],\n", + " arrangement='vertical',\n", + " main_title='Scatter -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Broadcast\n", + "\n", + "A stride-0 source layout reads the same element for every index.\n", + "Copying into stride-1 broadcasts the single element to all positions." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "output": { + "id": 958586586559131, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "src = Tensor(Layout(7, 0), data=['✔️'])\n", + "dst = Tensor(Layout(7, 1), data=['x'] * 7)\n", + "\n", + "draw_composite(\n", + " [src.layout, dst.layout],\n", + " titles=['src layout 7:0 (stride-0)', 'dst layout 7:1'],\n", + " main_title='Broadcast -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "output": { + "id": 26924338847152060, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "copy(src, dst)\n", + "\n", + "draw_composite(\n", + " [src, dst],\n", + " titles=['src 7:0 (all read offset 0)', 'dst 7:1 (after copy)'],\n", + " main_title='Broadcast -- data after copy()')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "output": { + "id": 4201026146825997, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [src.view(Layout(len(src.data), 1)), dst.view(Layout(len(dst.data), 1))],\n", + " titles=['src backing store (1 element)', 'dst backing store (7 elements)'],\n", + " arrangement='vertical',\n", + " main_title='Broadcast -- physical view (1 element replicated to 7)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tensor Transpose\n", + "\n", + "A higher-order transpose reshapes a `(4,(2,3))` tensor into `(4,6)`\n", + "with different strides — flattening hierarchical modes." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "output": { + "id": 1321106933412734, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "src_layout = Layout((4, (2, 3)), (1, (14, 4)))\n", + "dst_layout = Layout((4, 6), (1, 4))\n", + "\n", + "letters = list(\"ABCDEFGHIJKLMNOPQRSTUVWX\")\n", + "buf_size = cosize(src_layout)\n", + "\n", + "src = Tensor(src_layout, data=['.'] * buf_size)\n", + "for i, letter in enumerate(letters):\n", + " src[i] = letter\n", + "dst = Tensor(dst_layout, data=['.'] * cosize(dst_layout))\n", + "\n", + "draw_composite(\n", + " [src_layout, dst_layout],\n", + " titles=[f'src: {src_layout}', f'dst: {dst_layout}'],\n", + " main_title='Tensor Transpose -- offset maps',\n", + " flatten_hierarchical=False, label_hierarchy_levels=False, cell_labels=\"offset\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "output": { + "id": 26347669331561376, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "copy(src, dst)\n", + "\n", + "draw_composite(\n", + " [src, dst],\n", + " titles=['src data (hierarchical)', 'dst data (flat)'],\n", + " main_title='Tensor Transpose -- data after copy()',\n", + " flatten_hierarchical=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "output": { + "id": 2427612131036325, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [src.view(Layout(len(src.data), 1)), dst.view(Layout(len(dst.data), 1))],\n", + " titles=['src backing store (hierarchical strides)',\n", + " 'dst backing store (contiguous)'],\n", + " arrangement='vertical',\n", + " main_title='Tensor Transpose -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## REDUCE\n", + "\n", + "The generic REDUCE algorithm accumulates elements along a mode of\n", + "a tensor. It is a **rank-2 algorithm**: two nested loops over\n", + "indices M and K.\n", + "\n", + "```python\n", + "# REDUCE: dst[m] = op(dst[m], src[m,k]) 2 indices, accumulate along K\n", + "for k in range(K):\n", + " for m in range(M):\n", + " dst[m] = op(dst[m], src[m, k])\n", + "```\n", + "\n", + "Where COPY iterates over a single flat index, REDUCE iterates over\n", + "a 2D index space (M × K) and accumulates along the K dimension.\n", + "The `op` parameter generalizes `+=` to any binary operator (`max`,\n", + "`min`, etc.).\n", + "\n", + "GEMM, which we will see next, extends this pattern with a third loop\n", + "over N and a multiply — making it a rank-3 algorithm.\n", + "\n", + "Like COPY, the same `reduce()` function produces different operations\n", + "depending on the layouts of src and dst." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def reduce(src: Tensor, dst: Tensor, op=lambda a, b: a + b):\n", + " \"\"\"Generic REDUCE: accumulate mode 1 of src into dst.\n", + " src: (M, K) -> dst: (M,)\n", + " Computes dst[m] = op(dst[m], src[m, k]) for all m, k\n", + " \"\"\"\n", + " M = size(mode(src, 0))\n", + " K = size(mode(src, 1))\n", + " assert size(dst) == M\n", + " for k in range(K):\n", + " for m in range(M):\n", + " dst[m] = op(dst[m], src[m, k])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Like COPY, different layouts make `reduce()` perform\n", + "different operations -- the function itself never changes:\n", + "\n", + "| Application | src Layout | dst Layout | op | What it does |\n", + "|---|---|---|---|---|\n", + "| Row sum | `(M,K):(K,1)` row-major | `M:1` | `+` | Sum across columns of each row |\n", + "| Column sum | `(M,K):(1,M)` col-major | `M:1` | `+` | Sum down rows of each column |\n", + "| Strided reduce | `(M,K):(d_m,d_k)` | `M:d_m` | `+` | Generically-strided |\n", + "| Max | `(M,K):(K,1)` | `M:1` | `max` | Max per row |\n", + "| Tensor reduce | `((M1,M2),K)` | `(M1,M2)` | `+` | Reduce over grouped modes |\n", + "\n", + "Note the parallel with Table 2 (COPY): layout\n", + "choices -- not code changes -- determine the semantics." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Row Sum\n", + "\n", + "Row-major source `(M,K):(K,1)`: mode 0 indexes rows, mode 1 indexes\n", + "columns. `reduce()` accumulates along mode 1 (K), summing each row\n", + "into a single output element." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "output": { + "id": 945902644962493, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Row sum: (4,3):(3,1) row-major -> 4:1\n", + "M, K = 4, 3\n", + "src = Tensor(Layout((M, K), (K, 1)), data=[1., 2., 3.,\n", + " 4., 5., 6.,\n", + " 7., 8., 9.,\n", + " 10.,11.,12.])\n", + "dst = Tensor(Layout(M, 1), data=[0.] * M)\n", + "\n", + "draw_composite(\n", + " [src.layout, dst.layout],\n", + " titles=[f'src layout (M,K)=({M},{K}) row-major', f'dst layout {M}:1'],\n", + " main_title='Row Sum -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "output": { + "id": 1478768060574785, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reduce(src, dst)\n", + "\n", + "draw_composite(\n", + " [src, dst],\n", + " titles=['src (row-major)', f'dst (after reduce): {list(dst._data[:size(dst)])}'],\n", + " main_title='Row Sum -- data after reduce()')" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "output": { + "id": 1471763641279078, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [src.view(Layout(len(src._data), 1)), dst.view(Layout(len(dst._data), 1))],\n", + " titles=['src backing store (row-major)', 'dst backing store'],\n", + " arrangement='vertical',\n", + " main_title='Row Sum -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Column Sum -- same `reduce()`, different layout\n", + "\n", + "Column-major source `(M,K):(1,M)`: now mode 0 indexes columns and\n", + "mode 1 indexes rows. The same `reduce()` call accumulates along\n", + "mode 1 -- but with col-major strides, that means summing down each\n", + "column. \"Row sum\" vs \"column sum\" is purely a layout choice." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "output": { + "id": 1309489891050448, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Column sum: (3,4):(1,3) col-major -> 3:1\n", + "# Same 12 values, but now M=3 (columns) and K=4 (rows to sum over)\n", + "M, K = 3, 4\n", + "src = Tensor(Layout((M, K), (1, M)), data=[ 1., 2., 3.,\n", + " 4., 5., 6.,\n", + " 7., 8., 9.,\n", + " 10., 11., 12.])\n", + "dst = Tensor(Layout(M, 1), data=[0.] * M)\n", + "\n", + "draw_composite(\n", + " [src.layout, dst.layout],\n", + " titles=[f'src layout (M,K)=({M},{K}) col-major', f'dst layout {M}:1'],\n", + " main_title='Column Sum -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "output": { + "id": 1488133132832838, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reduce(src, dst)\n", + "\n", + "draw_composite(\n", + " [src, dst],\n", + " titles=['src (col-major)', f'dst (after reduce): {list(dst._data[:size(dst)])}'],\n", + " main_title='Column Sum -- data after reduce()')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "output": { + "id": 1672491307435085, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [src.view(Layout(len(src._data), 1)), dst.view(Layout(len(dst._data), 1))],\n", + " titles=['src backing store (col-major)', 'dst backing store'],\n", + " arrangement='vertical',\n", + " main_title='Column Sum -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Max Reduction -- different operator\n", + "\n", + "Same `reduce()` function, same row-major layout, but `op=max` instead\n", + "of `+`. The operator is the only thing that changes -- layout algebra\n", + "handles the data movement, the operator handles the semantics." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "output": { + "id": 1700447604665748, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Max reduction: row-major (4,3):(3,1) -> 4:1 with op=max\n", + "M, K = 4, 3\n", + "src = Tensor(Layout((M, K), (K, 1)), data=[3., 1., 4.,\n", + " 1., 5., 9.,\n", + " 2., 6., 5.,\n", + " 3., 5., 8.])\n", + "dst = Tensor(Layout(M, 1), data=[float('-inf')] * M)\n", + "\n", + "reduce(src, dst, op=max)\n", + "\n", + "draw_composite(\n", + " [src, dst],\n", + " titles=['src (row-major)', f'dst (max per row): {list(dst._data[:size(dst)])}'],\n", + " main_title='Max Reduction -- data after reduce(op=max)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## §2.6.2 GEMM\n", + "\n", + "The generic GEMM algorithm computes `C += A × B`. It is a **rank-3\n", + "algorithm**: GEMM extends REDUCE by adding the N dimension and a\n", + "multiply, giving three nested loops over M, N, K.\n", + "\n", + "- `A` has shape `(M, K)` — M rows, K columns\n", + "- `B` has shape `(N, K)` — N rows, K columns (note: B is transposed vs. math convention)\n", + "- `C` has shape `(M, N)` — M rows, N columns\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "def gemm(A: Tensor, B: Tensor, C: Tensor):\n", + " \"\"\"Generic GEMM\n", + " A: (M, K), B: (N, K), C: (M, N)\n", + " Computes C += A × Bᵀ\n", + " \"\"\"\n", + " M = size(mode(A, 0))\n", + " N = size(mode(B, 0))\n", + " K = size(mode(A, 1))\n", + " assert size(mode(B, 1)) == K\n", + " assert size(mode(C, 0)) == M\n", + " assert size(mode(C, 1)) == N\n", + "\n", + " for k in range(K):\n", + " for n in range(N):\n", + " for m in range(M):\n", + " C[m, n] += A[m, k] * B[n, k]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By varying the layouts of A, B, C we get every BLAS transpose variant,\n", + "generically-strided BLIS GEMM, tensor contractions (GETT), grouped GEMM,\n", + "and convolutions (CONV) — all from the same 4-line loop nest.\n", + "\n", + "**Table 3** from the paper (extended with Grouped GEMM):\n", + "\n", + "| Application | A-Layout | B-Layout | C-Layout |\n", + "|---|---|---|---|\n", + "| NT GEMM | `(M,K):(1,lda)` | `(N,K):(1,ldb)` | `(M,N):(1,ldc)` |\n", + "| TN GEMM | `(M,K):(lda,1)` | `(N,K):(ldb,1)` | `(M,N):(1,ldc)` |\n", + "| NTT GEMM | `(N,K):(1,ldb)` | `(M,K):(1,lda)` | `(N,M):(1,ldc)` |\n", + "| BLIS GEMM | `(M,K):(dm,dk)` | `(N,K):(dn,dk)` | `(M,N):(dm,dn)` |\n", + "| GETT | `((M₁,M₂),K):((1,W),X)` | `(N,K):(K,1)` | `((M₁,M₂),N):((1,Y),Z)` |\n", + "| Grouped GEMM | `((M,G),K)` | `(N,K)` | `((M,G),N)` |\n", + "| CONV | `(K,(C,T,R,S)):D_A` | `((N,Z,P,Q),(C,T,R,S)):D_B` | `(K,(N,Z,P,Q)):D_C` |" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "output": { + "id": 930725189780383, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# NT GEMM: col-major A, B, C\n", + "M, N, K = 4, 3, 2\n", + "\n", + "A_data = [1., 0., 0., 1., 2., 1., 1., 0.] # 4×2\n", + "B_data = [1., 0., 1., 0., 1., 1.] # 3×2\n", + "C_data = [0.] * (M * N)\n", + "\n", + "A = Tensor(Layout((M, K), (1, M)), data=A_data) # col-major\n", + "B = Tensor(Layout((N, K), (1, N)), data=B_data) # col-major\n", + "C = Tensor(Layout((M, N), (1, M)), data=C_data) # col-major\n", + "\n", + "draw_gemm(A.layout, B.layout, C.layout,\n", + " main_title='NT GEMM -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "output": { + "id": 1266196775050983, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gemm(A, B, C)\n", + "\n", + "draw_gemm(A, B, C,\n", + " main_title='NT GEMM -- data after gemm()')" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "output": { + "id": 1880926719232890, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [A.view(Layout(len(A.data), 1)), B.view(Layout(len(B.data), 1)), C.view(Layout(len(C.data), 1))],\n", + " titles=['A backing store (col-major)', 'B backing store (col-major)', 'C backing store (col-major)'],\n", + " arrangement='vertical',\n", + " main_title='NT GEMM -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### TN GEMM (row-major A and B)\n", + "\n", + "A is transposed (row-major), B is not transposed (row-major).\n", + "Same `gemm()` function, just different strides." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "output": { + "id": 1880082162692111, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# TN GEMM: row-major A and B, col-major C\n", + "M, N, K = 4, 3, 2\n", + "\n", + "A = Tensor(Layout((M, K), (K, 1)), data=[1., 2., 0., 1., 0., 1., 1., 0.]) # row-major\n", + "B = Tensor(Layout((N, K), (K, 1)), data=[1., 0., 0., 1., 1., 1.]) # row-major\n", + "C = Tensor(Layout((M, N), (1, M)), data=[0.] * (M * N)) # col-major\n", + "\n", + "draw_gemm(A.layout, B.layout, C.layout,\n", + " main_title='TN GEMM -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "output": { + "id": 2056179808261409, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gemm(A, B, C)\n", + "\n", + "draw_gemm(A, B, C,\n", + " main_title='TN GEMM -- data after gemm()')" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "output": { + "id": 910428651831846, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [A.view(Layout(len(A.data), 1)), B.view(Layout(len(B.data), 1)), C.view(Layout(len(C.data), 1))],\n", + " titles=['A backing store (row-major)', 'B backing store (row-major)', 'C backing store (col-major)'],\n", + " arrangement='vertical',\n", + " main_title='TN GEMM -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### GETT — Generalized Tensor-Tensor contraction\n", + "\n", + "Any tensor contraction can be expressed as GEMM by grouping modes into\n", + "M (row), N (column), and K (reduction) groups. Hierarchical shapes\n", + "keep the original tensor structure visible.\n", + "\n", + "Example: contract a `(M₁, M₂, K)` tensor with a `(N, K)` tensor to produce\n", + "a `(M₁, M₂, N)` result — the two M modes are grouped into GEMM's M dimension." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "output": { + "id": 1681140786367040, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# GETT: A has shape ((M1,M2), K), B has shape (N, K)\n", + "M1, M2, Ng, Kg = 2, 3, 4, 2\n", + "\n", + "A = Tensor(Layout(((M1, M2), Kg), ((1, M1), M1*M2)), data=[float(x) for x in range(M1*M2*Kg)])\n", + "B = Tensor(Layout((Ng, Kg), (1, Ng)), data=[float(x) for x in range(Ng*Kg)])\n", + "C = Tensor(Layout(((M1, M2), Ng), ((1, M1), M1*M2)), data=[0.] * (M1*M2*Ng))\n", + "\n", + "draw_gemm(A.layout, B.layout, C.layout,\n", + " main_title=f'GETT -- offset maps\\nA(({M1},{M2}),{Kg}) × B({Ng},{Kg})ᵀ = C(({M1},{M2}),{Ng})')" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "output": { + "id": 2465155643933742, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gemm(A, B, C)\n", + "\n", + "draw_gemm(A, B, C,\n", + " main_title='GETT -- data after gemm()')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "output": { + "id": 934928636097168, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [A.view(Layout(len(A.data), 1)), B.view(Layout(len(B.data), 1)), C.view(Layout(len(C.data), 1))],\n", + " titles=['A backing store', 'B backing store', 'C backing store'],\n", + " arrangement='vertical',\n", + " main_title='GETT -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grouped GEMM — Batching as GETT\n", + "\n", + "A common workload is **grouped GEMM**: compute G independent matrix\n", + "multiplies `C_g += A_g × B_g^T` for `g = 0, 1, ..., G-1`, all with\n", + "the same dimensions M, N, K.\n", + "\n", + "When the operands share a common factor — typically B is the same\n", + "across all groups (as in multi-head attention where the projection\n", + "weights are shared) — the group dimension folds directly into GETT.\n", + "Stack the G copies of A into a single tensor with hierarchical shape\n", + "`((M, G), K)`, keep B as `(N, K)`, and the output becomes `((M, G), N)`.\n", + "The same `gemm()` function handles all G groups in one call — no loop,\n", + "no code change, just different layouts.\n", + "\n", + "Even when each group has its own B_g, we can fold G into **both** M and N:\n", + "A becomes `((M, G), K)` and B becomes `((N, G), K)`. This still works with\n", + "`gemm()`, but produces a `((M, G), (N, G))` output — all G² cross-group\n", + "products, not just the G diagonal blocks we want. The extra results are\n", + "computed and discarded, which is wasteful but algebraically valid.\n", + "\n", + "The example below shows the shared-B case: 3 groups of 2×2 GEMM with\n", + "a common 2×2 matrix B." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "output": { + "id": 1383377960165537, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Grouped GEMM: G=3 groups of 2x2 GEMM, shared B\n", + "M, N, K, G = 2, 2, 2, 3\n", + "\n", + "# Stack G copies of A into ((M, G), K) -- each group's 2x2 block is contiguous\n", + "A_data = [1., 2., 3., 4., # group 0\n", + " 5., 6., 7., 8., # group 1\n", + " 9.,10.,11.,12.] # group 2\n", + "A = Tensor(Layout(((M, G), K), ((1, M), M*G)), data=A_data)\n", + "\n", + "# Shared B: (N, K) -- same for all groups\n", + "B = Tensor(Layout((N, K), (1, N)), data=[1., 0., 0., 1.]) # identity\n", + "\n", + "# Output: ((M, G), N)\n", + "C = Tensor(Layout(((M, G), N), ((1, M), M*G)), data=[0.] * (M*G*N))\n", + "\n", + "draw_gemm(A.layout, B.layout, C.layout,\n", + " main_title='Grouped GEMM -- offset maps\\nA((2,3),2) x B(2,2)T = C((2,3),2)')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "output": { + "id": 839129948454902, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gemm(A, B, C)\n", + "\n", + "draw_gemm(A, B, C,\n", + " main_title='Grouped GEMM -- data after gemm()')" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "output": { + "id": 2031280164154862, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [A.view(Layout(len(A.data), 1)), B.view(Layout(len(B.data), 1)), C.view(Layout(len(C.data), 1))],\n", + " titles=['A backing store (3 groups stacked)', 'B backing store (shared)', 'C backing store (3 results stacked)'],\n", + " arrangement='vertical',\n", + " main_title='Grouped GEMM -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Beyond Layout Algebra: Variable-Size Grouped GEMM\n", + "\n", + "The shared-B grouped GEMM above works because folding G into M is\n", + "exactly GETT -- the group index is just another mode in a hierarchical\n", + "shape. Two harder variants do **not** fit cleanly into layout algebra:\n", + "\n", + "**Fully-independent batched GEMM** (each group has its own A_g *and* B_g):\n", + "Folding G into both M and N makes `gemm()` compute the full\n", + "`((M·G), (N·G))` output -- including all G² cross-group products\n", + "`C[(m, g_a), (n, g_b)]` for every pair `(g_a, g_b)`. We only want\n", + "the G diagonal blocks where `g_a = g_b`. Layout algebra maps coordinates\n", + "to offsets; it has no mechanism to *mask* or *skip* unwanted index\n", + "combinations. The practical solution is G separate `gemm()` calls.\n", + "\n", + "**Variable-size grouped GEMM** (different M_g, N_g, K_g per group):\n", + "This is even further outside the paradigm. A Layout's shape is fixed at\n", + "construction -- there is no single layout that describes groups with different\n", + "dimensions. Variable-size grouped GEMM is a scheduling and dispatch problem\n", + "(which group runs on which SM, how to pack irregular tiles into shared\n", + "memory), not an algebra problem. Libraries like CUTLASS handle this with\n", + "explicit group tables and runtime dispatch rather than layout composition." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### CONV — Convolution as implicit GEMM\n", + "\n", + "Convolution maps to GEMM by treating the filter as A and the\n", + "`im2col`-rearranged input as B. The key insight is that the B\n", + "tensor's layout encodes the `im2col` transformation implicitly —\n", + "no explicit data rearrangement is needed.\n", + "\n", + "Traditionally, `im2col` **copies** each sliding window into a row\n", + "of a new matrix so convolution becomes a standard GEMM:\n", + "\n", + "```python\n", + "def im2col(signal, P, S):\n", + " \"\"\"Explicitly build the im2col matrix for 1D convolution.\"\"\"\n", + " col = []\n", + " for p in range(P): # each output position\n", + " for s in range(S): # each filter tap\n", + " col.append(signal[p + s]) # gather from input\n", + " return col # flat P*S buffer, row-major\n", + "```\n", + "\n", + "For `signal = [0, 1, 3, 2, 4, 1]` with `S=3`, `P=4`:\n", + "\n", + "```\n", + "im2col = [[0, 1, 3], ← signal[0:3]\n", + " [1, 3, 2], ← signal[1:4]\n", + " [3, 2, 4], ← signal[2:5]\n", + " [2, 4, 1]] ← signal[3:6]\n", + "```\n", + "\n", + "With CuTe layouts, we skip the copy entirely. A `(P, S):(1, 1)`\n", + "layout over the original signal produces the same overlapping windows:\n", + "`B[p, s]` reads `signal[p·1 + s·1] = signal[p + s]` — the same\n", + "gather, expressed as a layout rather than a data copy.\n", + "\n", + "For a simple 1D convolution with input length `W`, filter size `S`,\n", + "and `K` output channels:\n", + "- A (filter): shape `(K, S)` — K filters of width S\n", + "- B (input): shape `(P, S)` — P output positions, S taps per position\n", + "- C (output): shape `(K, P)` — K channels × P positions" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "output": { + "id": 1584894199262150, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 1D Convolution: input_len=6, filter_size=3, num_filters=2\n", + "W, S, K = 6, 3, 2\n", + "P = W - S + 1 # output positions = 4\n", + "\n", + "# Filter: K filters of width S (row-major)\n", + "filters = [1., 0., -1., # filter 0: edge detector\n", + " 1., 1., 1.] # filter 1: box filter\n", + "A = Tensor(Layout((K, S), (S, 1)), data=filters)\n", + "\n", + "# Input signal\n", + "signal = [0., 1., 3., 2., 4., 1.]\n", + "\n", + "# B = im2col view of input: shape (P, S), stride (1, 1)\n", + "# B[p, s] reads signal[p + s] — the sliding window!\n", + "B = Tensor(Layout((P, S), (1, 1)), data=signal)\n", + "\n", + "# Output: K × P\n", + "C = Tensor(Layout((K, P), (P, 1)), data=[0.] * (K * P))\n", + "\n", + "draw_gemm(A.layout, B.layout, C.layout,\n", + " main_title='1D CONV -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "output": { + "id": 1255923503322781, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gemm(A, B, C)\n", + "\n", + "draw_gemm(A, B, C,\n", + " main_title='1D CONV -- data after gemm()')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "output": { + "id": 1515128936636086, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [A.view(Layout(len(A.data), 1)), B.view(Layout(len(B.data), 1)), C.view(Layout(len(C.data), 1))],\n", + " titles=['A backing store (filters)', 'B backing store (signal)', 'C backing store (output)'],\n", + " arrangement='vertical',\n", + " main_title='1D CONV -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2D Convolution\n", + "\n", + "A 2D convolution (NCHW format) maps to GEMM with:\n", + "- A (filter): `(K, (C, R, S))` — K output channels, C×R×S filter volume\n", + "- B (input): `((N, P, Q), (C, R, S))` — output positions × filter taps\n", + "- C (output): `(K, (N, P, Q))` — K channels × spatial positions\n", + "\n", + "The B layout encodes the `im2col` transformation: for each output\n", + "position `(n, p, q)`, the filter tap `(c, r, s)` reads `input[n, c, p+r, q+s]`.\n", + "\n", + "The `im2col` function generalizes naturally to N-D. Compare with the\n", + "1D version above — the structure is identical, just more spatial loops:\n", + "\n", + "```python\n", + "def im2col_2d(input, H, W, R, S):\n", + " \"\"\"Explicitly build the im2col matrix for 2D convolution.\"\"\"\n", + " P, Q = H - R + 1, W - S + 1\n", + " col = []\n", + " for p in range(P): # each output row\n", + " for q in range(Q): # each output column\n", + " for r in range(R): # each filter row\n", + " for s in range(S): # each filter column\n", + " col.append(input[(p + r) * W + (q + s)])\n", + " return col # flat P*Q*R*S buffer, row-major\n", + "```\n", + "\n", + "For a 4×4 input with a 2×2 filter (`P=Q=3`, `R=S=2`):\n", + "\n", + "```\n", + "im2col = [[inp[0], inp[1], inp[4], inp[5]], ← window at (0,0)\n", + " [inp[1], inp[2], inp[5], inp[6]], ← window at (0,1)\n", + " ... ← 9 rows total\n", + " [inp[9], inp[10], inp[13], inp[14]]] ← window at (2,2)\n", + "```\n", + "\n", + "Here we build the im2col buffer explicitly for clarity, but the\n", + "point is that the same `gemm()` function handles convolution\n", + "with no code changes." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "output": { + "id": 1284478940414975, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 2D Conv: 1 image, 1 input channel, 4×4 input, 2×2 filter, 1 output channel\n", + "Ni, Ci, H, Wi = 1, 1, 4, 4 # input\n", + "Ko, R, S = 1, 2, 2 # filter\n", + "P, Q = H - R + 1, Wi - S + 1 # output spatial: 3×3\n", + "\n", + "# Input image (single image/channel, row-major)\n", + "inp = [float(x) for x in range(H * Wi)]\n", + "\n", + "# Filter: 2×2 box filter\n", + "filt = [1., 1., 1., 1.]\n", + "\n", + "# A (filter): (K, C*R*S) = (1, 4)\n", + "A = Tensor(Layout((Ko, Ci*R*S), (Ci*R*S, 1)), data=filt)\n", + "\n", + "# B (im2col): shape (P*Q, C*R*S)\n", + "im2col = []\n", + "for p in range(P):\n", + " for q in range(Q):\n", + " for r in range(R):\n", + " for s in range(S):\n", + " im2col.append(inp[(p+r)*Wi + (q+s)])\n", + "\n", + "B = Tensor(Layout((P*Q, Ci*R*S), (Ci*R*S, 1)), data=im2col)\n", + "Cout = Tensor(Layout((Ko, P*Q), (P*Q, 1)), data=[0.] * (Ko * P * Q))\n", + "\n", + "draw_gemm(A.layout, B.layout, Cout.layout,\n", + " main_title='2D CONV -- offset maps')" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "output": { + "id": 1619737132567081, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gemm(A, B, Cout)\n", + "\n", + "draw_gemm(A, B, Cout,\n", + " main_title='2D CONV -- data after gemm()')" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "output": { + "id": 26398229113203772, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_composite(\n", + " [A.view(Layout(len(A.data), 1)), B.view(Layout(len(B.data), 1)), Cout.view(Layout(len(Cout.data), 1))],\n", + " titles=['A backing store (filter)', 'B backing store (im2col)', 'C backing store (output)'],\n", + " arrangement='vertical',\n", + " main_title='2D CONV -- physical view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## Epilogue Fusion\n", + "\n", + "Real GPU kernels rarely run GEMM in isolation. The output matrix C is\n", + "typically transformed in-place before being written back to global\n", + "memory — adding a bias vector, applying an activation function (ReLU,\n", + "GELU), or adding a residual tensor. Fusing these operations into the\n", + "GEMM's \"epilogue\" avoids a round-trip through global memory.\n", + "\n", + "From a layout algebra perspective, the epilogue composes familiar\n", + "primitives:\n", + "\n", + "- **Bias add** is the broadcast pattern from COPY (§2.6.1): a 1D bias\n", + " vector with stride 0 in one dimension is added to every row (or column)\n", + " of C.\n", + "- **Activation** is a pointwise map — no layout needed, just `f(C[i])`\n", + " for each element.\n", + "- Different bias layouts produce row bias vs column bias — the same\n", + " epilogue code, different layouts, different semantics." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "def gemm_epilogue(A, B, C, bias=None, activation=None):\n", + " \"\"\"GEMM + fused epilogue: bias add + pointwise activation.\n", + " bias: Tensor with same size as C (broadcast via stride-0 layout)\n", + " activation: callable applied element-wise (e.g., relu)\n", + " \"\"\"\n", + " gemm(A, B, C)\n", + " if bias is not None:\n", + " for i in range(size(C)):\n", + " C[i] += bias[i]\n", + " if activation is not None:\n", + " for i in range(size(C)):\n", + " C[i] = activation(C[i])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bias as Broadcast Layout\n", + "\n", + "A bias vector `bias: N:1` stores N values. To add it to every row of\n", + "an `(M, N)` output, we view it as `(M, N):(0, 1)` — stride 0 in the M\n", + "dimension means every row reads the same bias values. This is exactly\n", + "the broadcast pattern from §2.6.1:\n", + "\n", + "| Epilogue op | Bias layout | Effect |\n", + "|---|---|---|\n", + "| Column bias | `(M, N):(0, 1)` | Same bias added to every row |\n", + "| Row bias | `(M, N):(1, 0)` | Same bias added to every column |\n", + "\n", + "The same `gemm_epilogue()` function handles both — only the bias\n", + "layout changes." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "output": { + "id": 1503679521384547, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bias layout: (3, 3) : (0, 1)\n", + "bias offsets: [0, 0, 0, 1, 1, 1, 2, 2, 2]\n", + " -> each row reads the same 3 values from a 3-element buffer\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Epilogue: GEMM + column bias + ReLU\n", + "M, N, K = 3, 3, 2\n", + "\n", + "# A and B: col-major\n", + "A = Tensor(Layout((M, K), (1, M)), data=[1., 0., 2., -1., 1., 0.])\n", + "B = Tensor(Layout((N, K), (1, N)), data=[1., 0., 1., 0., 1., -1.])\n", + "\n", + "# Column bias: shape (M,N) with stride (0,1) — broadcasts along M\n", + "bias_data = [0.5, -0.5, 1.0]\n", + "bias = Tensor(Layout((M, N), (0, 1)), data=bias_data)\n", + "\n", + "# Show the bias broadcast layout\n", + "print(f\"bias layout: {bias.layout}\")\n", + "print(f\"bias offsets: {[bias.layout(i) for i in range(size(bias))]}\")\n", + "print(f\" -> each row reads the same 3 values from a 3-element buffer\")\n", + "\n", + "draw_composite(\n", + " [bias.layout, bias],\n", + " titles=[f'bias layout {bias.layout}', 'bias data (broadcast)'],\n", + " main_title='Column bias — stride-0 broadcast')" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "output": { + "id": 1523334476058337, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Run GEMM only first, to see the raw output\n", + "C_raw = Tensor(Layout((M, N), (1, M)), data=[0.] * (M * N))\n", + "gemm(A, B, C_raw)\n", + "\n", + "# Now run GEMM + bias + ReLU\n", + "relu = lambda x: max(0.0, x)\n", + "C_fused = Tensor(Layout((M, N), (1, M)), data=[0.] * (M * N))\n", + "gemm_epilogue(A, B, C_fused, bias=bias, activation=relu)\n", + "\n", + "draw_composite(\n", + " [C_raw, C_fused],\n", + " titles=['C after GEMM (raw)', 'C after GEMM + bias + ReLU'],\n", + " main_title='Epilogue Fusion — bias adds 0.5, -0.5, 1.0 per column, then ReLU clips negatives')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## Online Softmax\n", + "\n", + "Softmax normalizes a vector so its elements are positive and sum to 1:\n", + "\n", + "`softmax(x)[i] = exp(x[i] - max(x)) / sum_j exp(x[j] - max(x))`\n", + "\n", + "This decomposes into the primitives we've already defined:\n", + "\n", + "1. **REDUCE(max)** — find the maximum element (for numerical stability)\n", + "2. **Element-wise exp** — `exp(x[i] - max)`\n", + "3. **REDUCE(+)** — sum the exponentials\n", + "4. **Element-wise divide** — normalize by the sum\n", + "\n", + "The standard implementation requires **two passes** over the data (one\n", + "for max, one for exp+sum). The **online** algorithm fuses the two\n", + "reduces into a single pass by maintaining a running max and correcting\n", + "the running sum whenever the max increases:\n", + "\n", + "```\n", + "running_sum *= exp(old_max - new_max) # correct for new max\n", + "running_sum += exp(x[i] - new_max) # incorporate new element\n", + "```\n", + "\n", + "This is the key enabler for **Flash Attention**, where the attention\n", + "score matrix `S = Q × K^T` is too large to materialize. Online softmax\n", + "lets us process K in tiles, accumulating statistics across tiles without\n", + "ever storing the full S matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "def softmax(src, dst):\n", + " \"\"\"Two-pass softmax using reduce primitives.\n", + " src: (K,) -> dst: (K,)\n", + " Pass 1: m = reduce(src, max)\n", + " Pass 2: dst[i] = exp(src[i] - m), s = reduce(dst, +)\n", + " Pass 3: dst[i] /= s\n", + " \"\"\"\n", + " K = size(src)\n", + " assert size(dst) == K\n", + " # Pass 1: max (= reduce with op=max)\n", + " m = float('-inf')\n", + " for i in range(K):\n", + " m = max(m, src[i])\n", + " # Pass 2: exp and sum (= element-wise + reduce with op=+)\n", + " s = 0.0\n", + " for i in range(K):\n", + " dst[i] = math.exp(src[i] - m)\n", + " s += dst[i]\n", + " # Pass 3: normalize (= element-wise)\n", + " for i in range(K):\n", + " dst[i] /= s" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "def online_softmax(src, dst):\n", + " \"\"\"Online softmax: fuses reduce(max) and reduce(sum) into one pass.\n", + " When max increases, the running sum is corrected by the ratio\n", + " exp(old_max - new_max), avoiding a separate max-finding pass.\n", + " \"\"\"\n", + " K = size(src)\n", + " assert size(dst) == K\n", + " running_max = float('-inf')\n", + " running_sum = 0.0\n", + " # Single pass: track max and corrected sum\n", + " for i in range(K):\n", + " old_max = running_max\n", + " running_max = max(running_max, src[i])\n", + " running_sum = (running_sum * math.exp(old_max - running_max)\n", + " + math.exp(src[i] - running_max))\n", + " # Final pass: compute normalized values\n", + " for i in range(K):\n", + " dst[i] = math.exp(src[i] - running_max) / running_sum" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "output": { + "id": 958964540440684, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two-pass: [0.2333, 0.0858, 0.0349, 0.6343, 0.0116]\n", + "Online: [0.2333, 0.0858, 0.0349, 0.6343, 0.0116]\n", + "Sum: 1.000000\n", + "Match confirmed — identical results from both algorithms\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compare two-pass and online softmax on the same input\n", + "src = Tensor(Layout(5, 1), data=[2.0, 1.0, 0.1, 3.0, -1.0])\n", + "dst_two = Tensor(Layout(5, 1), data=[0.0] * 5)\n", + "dst_online = Tensor(Layout(5, 1), data=[0.0] * 5)\n", + "\n", + "softmax(src, dst_two)\n", + "online_softmax(src, dst_online)\n", + "\n", + "print(\"Two-pass: \", [round(dst_two[i], 4) for i in range(size(dst_two))])\n", + "print(\"Online: \", [round(dst_online[i], 4) for i in range(size(dst_online))])\n", + "print(f\"Sum: {sum(dst_online[i] for i in range(size(dst_online))):.6f}\")\n", + "\n", + "# Verify they match\n", + "assert all(abs(dst_two[i] - dst_online[i]) < 1e-10\n", + " for i in range(size(dst_two))), \"Mismatch!\"\n", + "print(\"Match confirmed — identical results from both algorithms\")\n", + "\n", + "draw_composite(\n", + " [src, dst_online],\n", + " titles=['src (logits)', 'dst (softmax probabilities)'],\n", + " main_title='Online Softmax — same result as two-pass',\n", + " precision=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Per-Row Softmax — Layout Determines the Reduction Axis\n", + "\n", + "In attention, softmax is applied **per-row** of the score matrix\n", + "`S = Q × K^T`. Each row represents one query's attention distribution\n", + "over all keys. With a row-major layout, each row is a contiguous\n", + "slice — `src[m, :]` — and we apply `online_softmax` to each\n", + "independently." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "output": { + "id": 972057142079188, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " row 0: [0.5745, 0.2114, 0.0859, 0.1282] (sum = 1.000000)\n", + " row 1: [0.0403, 0.8098, 0.1096, 0.0403] (sum = 1.000000)\n", + " row 2: [0.25, 0.25, 0.25, 0.25] (sum = 1.000000)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def row_softmax(src, dst):\n", + " \"\"\"Per-row softmax on a 2D tensor.\n", + " src: (M, K) -> dst: (M, K)\n", + " Applies online_softmax to each row independently.\n", + " \"\"\"\n", + " M = size(mode(src, 0))\n", + " for m in range(M):\n", + " online_softmax(src[m, :], dst[m, :])\n", + "\n", + "# 3x4 attention score matrix (row-major)\n", + "M, K = 3, 4\n", + "scores = [2.0, 1.0, 0.1, 0.5, # query 0\n", + " 0.0, 3.0, 1.0, 0.0, # query 1\n", + " 1.0, 1.0, 1.0, 1.0] # query 2 (uniform)\n", + "src = Tensor(Layout((M, K), (K, 1)), data=scores)\n", + "dst = Tensor(Layout((M, K), (K, 1)), data=[0.0] * (M * K))\n", + "\n", + "row_softmax(src, dst)\n", + "\n", + "# Verify each row sums to 1\n", + "for m in range(M):\n", + " row = [round(dst[m, k], 4) for k in range(K)]\n", + " row_sum = sum(dst[m, k] for k in range(K))\n", + " print(f\" row {m}: {row} (sum = {row_sum:.6f})\")\n", + "\n", + "draw_composite(\n", + " [src, dst],\n", + " titles=['Attention scores (logits)', 'Attention weights (softmax)'],\n", + " main_title='Per-Row Softmax — each row sums to 1.0',\n", + " precision=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Connection to Flash Attention\n", + "\n", + "Flash Attention combines three ideas from this notebook:\n", + "\n", + "1. **GEMM** (§2.6.2) computes the attention scores `S = Q × K^T`\n", + "2. **Tiling** (applications.ipynb §3.3.5) splits K into blocks via\n", + " `logical_divide`, so the full S matrix is never materialized\n", + "3. **Online softmax** processes one K-block at a time, using\n", + " `running_sum *= exp(old_max - new_max)` to correct statistics\n", + " across blocks\n", + "\n", + "Layout algebra handles the tiling and data movement; the online\n", + "algorithm handles the numerical fusion. Together they reduce attention\n", + "from O(N²) memory to O(N) — without changing the mathematical result." + ] + } + ], + "metadata": { + "fileHeader": "", + "fileUid": "c88e6701-f44e-46d9-bc13-d9a43c3c88b0", + "isAdHoc": false, + "kernelspec": { + "display_name": "jld-dev (conda)", + "language": "python", + "name": "conda_jld-dev" + }, + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/applications.ipynb b/examples/applications.ipynb new file mode 100644 index 0000000..f44d9c7 --- /dev/null +++ b/examples/applications.ipynb @@ -0,0 +1,1601 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Applications of Layout Algebra\n", + "\n", + "This notebook walks through six key application patterns from Cecka,\n", + "*CuTe Layout Representation and Algebra* (arXiv:2603.02298v1),\n", + "showing how the algebra primitives compose to solve real GPU programming tasks.\n", + "\n", + "**Context:** CuTe (CUDA Templates) is NVIDIA's C++ template library for writing\n", + "high-performance GPU kernels. Its core abstraction is the *layout* — a pure\n", + "function from logical coordinates to memory offsets. Layout algebra lets you\n", + "build complex data-distribution and tiling schemes by composing simple primitives,\n", + "rather than computing index arithmetic by hand. This library is a pure-Python\n", + "implementation of that algebra, useful for understanding, prototyping, and\n", + "visualizing layouts before writing CUDA code.\n", + "\n", + "The six sections build from simplest to most general:\n", + "\n", + "1. **§3.3.4 Partitioning** — Thread-Value (TV) layouts: how CUDA threads divide up data\n", + "2. **§3.3.5 Tiling** — `logical_divide` splits data into tiles for multi-level GPU memory\n", + "3. **§3.4.2 Vectorization** — `upcast`/`downcast` convert bit↔element coordinates for wide loads\n", + "4. **§3.4.4 Admissibility** — checking whether operations are valid before applying them\n", + "5. **§3.5.1 Logical Product** — replicating a tile pattern across a larger space\n", + "6. **§3.5.2 Logical Divide** — the complement-based construction underlying divide and product" + ] + }, + { + "cell_type": "code", + "execution_count": 633, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\", message=\"findfont\")\n", + "import logging\n", + "logging.getLogger('matplotlib.font_manager').setLevel(logging.ERROR)" + ] + }, + { + "cell_type": "code", + "execution_count": 634, + "metadata": {}, + "outputs": [], + "source": [ + "from tensor_layouts import *\n", + "from tensor_layouts.viz import draw_layout, draw_tv_layout, draw_composite\n", + "from tensor_layouts.analysis import contiguity, mode_contiguity, slice_contiguity, explain" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## §3.3.4 Partitioning — Thread-Value Layouts\n", + "\n", + "In CUDA, a kernel launches many threads that execute the same code in parallel.\n", + "When those threads need to cooperate on a shared data array, each thread must\n", + "know **which elements it is responsible for**. CuTe encodes this assignment as\n", + "a **TV (Thread-Value) layout** — a rank-2 `Layout(T, V)`:\n", + "\n", + "- **Mode 0 — Thread (T):** maps a thread index `t ∈ [0, num_threads)` to a\n", + " starting offset in the data array. This is the *thread layout*.\n", + "- **Mode 1 — Value (V):** maps a value index `v ∈ [0, values_per_thread)` to the\n", + " additional offsets each thread reads/writes. This is computed as\n", + " `complement(T, N)` — the set of offsets that `T` does *not* cover, which\n", + " together with `T` tile the full array of size `N`.\n", + "\n", + "The complete mapping is: **`offset = TV(t, v) = T(t) + V(v)`**.\n", + "\n", + "Different choices of the thread layout `T` give different distribution patterns:\n", + "\n", + "- **Blocked:** `T` has a large stride → threads own consecutive chunks\n", + "- **Striped:** `T` has stride 1 → threads own interleaved elements\n", + "- **Block-cyclic:** `T` has hierarchical shape → threads own scattered blocks" + ] + }, + { + "cell_type": "code", + "execution_count": 635, + "metadata": { + "output": { + "id": 876760842117368, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thread layout T = 4 : 2 → offsets: [0, 2, 4, 6]\n", + "complement(T, 8) = 2 : 1 → offsets: [0, 1]\n", + "TV layout = (4, 2) : (2, 1)\n", + "\n", + " Thread 0: offsets [0, 1]\n", + " Thread 1: offsets [2, 3]\n", + " Thread 2: offsets [4, 5]\n", + " Thread 3: offsets [6, 7]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Blocked TV layout — each thread owns consecutive elements\n", + "T = Layout(4, 2)\n", + "V = complement(T, 8)\n", + "TV_blocked = Layout(T, V)\n", + "\n", + "print(f\"Thread layout T = {T} → offsets: {[T(i) for i in range(size(T))]}\")\n", + "print(f\"complement(T, 8) = {V} → offsets: {[V(i) for i in range(size(V))]}\")\n", + "print(f\"TV layout = {TV_blocked}\")\n", + "print()\n", + "for t in range(size(T)):\n", + " offsets = [TV_blocked(t, v) for v in range(size(V))]\n", + " print(f\" Thread {t}: offsets {offsets}\")\n", + "\n", + "# Linear memory: offsets (left) → TV mapping (right)\n", + "draw_composite(\n", + " [(Layout(8, 1), {\"tv_mode\": False}),\n", + " (TV_blocked, {\"tv_mode\": True})],\n", + " titles=[\"Linear memory (offsets)\", \"Blocked TV layout\"],\n", + " grid_rows=1, grid_cols=8,\n", + " colorize=True,\n", + ")\n", + "\n", + "# 2D view: 4 rows (threads) × 2 cols (values), row-major\n", + "draw_tv_layout(TV_blocked, colorize=True, grid_shape=(4, 2), col_major=False,\n", + " title=f\"Blocked {TV_blocked} — 4×2 grid\")" + ] + }, + { + "cell_type": "code", + "execution_count": 636, + "metadata": { + "output": { + "id": 921753747137569, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thread layout T = 4 : 1 → offsets: [0, 1, 2, 3]\n", + "complement(T, 8) = 2 : 4 → offsets: [0, 4]\n", + "TV layout = (4, 2) : (1, 4)\n", + "\n", + " Thread 0: offsets [0, 4]\n", + " Thread 1: offsets [1, 5]\n", + " Thread 2: offsets [2, 6]\n", + " Thread 3: offsets [3, 7]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Striped TV layout — each thread owns interleaved elements\n", + "T = Layout(4, 1)\n", + "V = complement(T, 8)\n", + "TV_striped = Layout(T, V)\n", + "\n", + "print(f\"Thread layout T = {T} → offsets: {[T(i) for i in range(size(T))]}\")\n", + "print(f\"complement(T, 8) = {V} → offsets: {[V(i) for i in range(size(V))]}\")\n", + "print(f\"TV layout = {TV_striped}\")\n", + "print()\n", + "for t in range(size(T)):\n", + " offsets = [TV_striped(t, v) for v in range(size(V))]\n", + " print(f\" Thread {t}: offsets {offsets}\")\n", + "\n", + "# Linear memory: offsets (left) → TV mapping (right)\n", + "draw_composite(\n", + " [(Layout(8, 1), {\"tv_mode\": False}),\n", + " (TV_striped, {\"tv_mode\": True})],\n", + " titles=[\"Linear memory (offsets)\", \"Striped TV layout\"],\n", + " grid_rows=1, grid_cols=8,\n", + " colorize=True,\n", + ")\n", + "\n", + "# 2D view: 4 rows (threads) × 2 cols (values), row-major\n", + "draw_tv_layout(TV_striped, colorize=True, grid_shape=(4, 2), col_major=False,\n", + " title=f\"Striped {TV_striped} — 4×2 grid\")" + ] + }, + { + "cell_type": "code", + "execution_count": 637, + "metadata": { + "output": { + "id": 916597744585922, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Figure 6 — blocked vs striped on a 4×2 grid\n", + "draw_composite(\n", + " [TV_blocked, TV_striped],\n", + " titles=[f\"Blocked {TV_blocked}\", f\"Striped {TV_striped}\"],\n", + " main_title=\"Figure 6 — TV layouts on a 4×2 grid\",\n", + " tv_mode=True,\n", + " colorize=True,\n", + " grid_rows=4, grid_cols=2,\n", + " col_major=False,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Table 4 — Common Distribution Patterns\n", + "\n", + "The three canonical patterns differ only in how the thread layout `T` is strided.\n", + "All three distribute the same `T × V` elements across the same number of threads —\n", + "the choice depends on the memory access pattern the hardware prefers:\n", + "\n", + "| Pattern | TV Layout | Thread stride | When to use |\n", + "|---|---|---|---|\n", + "| **Blocked** | `(T,V):(V,1)` | `V` (block size) | Maximizes per-thread locality |\n", + "| **Striped** | `(T,V):(1,T)` | `1` (consecutive) | Maximizes coalesced global memory access |\n", + "| **Block-cyclic** | `(T,(B,V/B)):(B,(1,T·B))` | Hierarchical | Balances locality and coalescing |\n", + "\n", + "Block-cyclic generalizes both: each thread gets blocks of `B` consecutive\n", + "elements, with blocks spaced `T·B` apart. Setting `B = V` gives blocked;\n", + "setting `B = 1` gives striped.\n", + "\n", + "For GPU **global memory**, striped patterns typically give the best coalescing\n", + "(adjacent threads access adjacent addresses, fitting in one memory transaction).\n", + "For **registers** or **shared memory**, blocked patterns are better because\n", + "each thread's data is contiguous, enabling vector loads." + ] + }, + { + "cell_type": "code", + "execution_count": 638, + "metadata": { + "output": { + "id": 1418214443439876, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Block-cyclic thread→offset mapping (B=2):\n", + " Thread 0: offsets [0, 1, 16, 17]\n", + " Thread 1: offsets [2, 3, 18, 19]\n", + " Thread 2: offsets [4, 5, 20, 21]\n", + " Thread 3: offsets [6, 7, 22, 23]\n", + " Thread 4: offsets [8, 9, 24, 25]\n", + " Thread 5: offsets [10, 11, 26, 27]\n", + " Thread 6: offsets [12, 13, 28, 29]\n", + " Thread 7: offsets [14, 15, 30, 31]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Table 4 examples — 8 threads × 4 values = 32 elements\n", + "blocked = Layout((8, 4), (4, 1)) # B = V = 4\n", + "striped = Layout((8, 4), (1, 8)) # B = 1\n", + "block_cyclic = Layout((8, (2, 2)), (2, (1, 16))) # B = 2: two blocks of 2\n", + "\n", + "print(\"Block-cyclic thread→offset mapping (B=2):\")\n", + "for t in range(8):\n", + " offsets = [block_cyclic(t, v) for v in range(4)]\n", + " print(f\" Thread {t}: offsets {offsets}\")\n", + "\n", + "# Show all three as linear memory (4 rows × 8 cols, row-major order)\n", + "draw_composite(\n", + " [blocked, striped, block_cyclic],\n", + " titles=[f\"Blocked\\n{blocked}\",\n", + " f\"Striped\\n{striped}\",\n", + " f\"Block-cyclic (B=2)\\n{block_cyclic}\"],\n", + " main_title=\"Table 4 — 8 threads × 4 values = 32 elements\",\n", + " tv_mode=True,\n", + " colorize=True,\n", + " grid_rows=4, grid_cols=8,\n", + " col_major=False,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### TV Layouts Are Independent of Physical Data Layout\n", + "\n", + "A TV layout defines a partitioning of *logical coordinates* — abstract grid\n", + "positions — not physical memory addresses. The same TV layout assigns the\n", + "same logical matrix elements to each thread regardless of how the underlying\n", + "tensor is stored in memory.\n", + "\n", + "Consider an 8×8 matrix with 32 threads, each owning 2 values. The TV layout\n", + "`((4,8),2):((16,1),8)` assigns thread `t` to the pair of logical flat\n", + "coordinates `tv(t, 0)` and `tv(t, 1)`. These are positions in the abstract\n", + "8×8 index space — they say nothing about physical memory.\n", + "\n", + "When we **compose** this TV layout with a *data layout*, we get a mapping\n", + "from `(Thr, Val)` directly to physical memory offsets:\n", + "\n", + "```\n", + "compose(data_layout, tv_layout)(thr, val) = data_layout(tv_layout(thr, val))\n", + "```\n", + "\n", + "- **Col-major** `(8,8):(1,8)` — the identity on flat indices, so composed\n", + " offsets equal the logical coordinates.\n", + "- **Row-major** `(8,8):(8,1)` — transposes the offset mapping; the same thread\n", + " still owns the same matrix element, just at a different physical address.\n", + "- **Col-major interleaved** `((2,4),8):((1,16),2)` — pairs of rows share\n", + " adjacent memory; offsets are rearranged, but thread ownership is unchanged.\n", + "\n", + "The visualization below shows all three compositions alongside the pure\n", + "TV layout: same thread colors (same logical assignment), different grid\n", + "positions (different physical offsets)." + ] + }, + { + "cell_type": "code", + "execution_count": 639, + "metadata": { + "output": { + "id": 890310970712469, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TV layout: ((4, 8), 2) : ((16, 1), 8)\n", + "compose(col_major, tv): ((4, 8), 2) : ((16, 1), 8)\n", + "compose(row_major, tv): ((4, 8), 2) : ((2, 8), 1)\n", + "compose(interleaved, tv): ((4, (2, 4)), 2) : ((4, (1, 16)), 2)\n", + "\n", + "Thread 5 owns logical positions: [(1, 2), (1, 3)]\n", + " col_major → physical offsets [17, 25]\n", + " row_major → physical offsets [10, 11]\n", + " interleaved → physical offsets [5, 7]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# TV layout independence: same thread assignment, different physical offsets\n", + "tv = Layout(((4, 8), 2), ((16, 1), 8)) # 32 threads × 2 values\n", + "\n", + "# Three data layouts for the same 8×8 matrix\n", + "col_major = Layout((8, 8), (1, 8)) # offset = row + 8·col\n", + "row_major = Layout((8, 8), (8, 1)) # offset = 8·row + col\n", + "interleaved = Layout(((2, 4), 8), ((1, 16), 2)) # col-major, rows interleaved by 2\n", + "\n", + "# Compose: (Thr, Val) → Offset\n", + "comp_col = compose(col_major, tv)\n", + "comp_row = compose(row_major, tv)\n", + "comp_int = compose(interleaved, tv)\n", + "\n", + "print(f\"TV layout: {tv}\")\n", + "print(f\"compose(col_major, tv): {comp_col}\")\n", + "print(f\"compose(row_major, tv): {comp_row}\")\n", + "print(f\"compose(interleaved, tv): {comp_int}\")\n", + "\n", + "# Thread 5 — same logical position, different physical offsets\n", + "thr = 5\n", + "coords = [idx2crd(tv(thr, v), (8, 8)) for v in range(2)]\n", + "print(f\"\\nThread {thr} owns logical positions: {coords}\")\n", + "for name, comp in [(\"col_major\", comp_col), (\"row_major\", comp_row),\n", + " (\"interleaved\", comp_int)]:\n", + " offsets = [comp(thr, v) for v in range(2)]\n", + " print(f\" {name:12s} → physical offsets {offsets}\")\n", + "\n", + "# Visualize: same thread colors, different offset grids\n", + "draw_composite(\n", + " [tv, comp_col, comp_row, comp_int],\n", + " titles=[\"TV layout\\n(logical coords)\",\n", + " f\"Col-major\\n{comp_col}\",\n", + " f\"Row-major\\n{comp_row}\",\n", + " f\"Interleaved\\n{comp_int}\"],\n", + " main_title=\"Same TV layout, three data layouts — thread colors are identical\",\n", + " tv_mode=True,\n", + " colorize=True,\n", + " grid_rows=8, grid_cols=8,\n", + " arrangement=\"grid:2x2\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## §3.3.5 Tiling\n", + "\n", + "GPU kernels process data through multiple levels of the memory hierarchy:\n", + "**global memory → shared memory → Tensor Core atoms**. At each level, the data must be\n", + "**partitioned into tiles** that fit in the next-smaller storage. For example,\n", + "a GEMM kernel tiles the output matrix into thread-block tiles (shared memory),\n", + "then sub-tiles each of those into atom-shaped fragments that match a specific MMA\n", + "instruction (e.g., a 16×8×8 `mma.sync` on SM80). Each atom's TV layout prescribes\n", + "exactly how matrix elements are distributed across warp threads and per-thread\n", + "registers — see `atoms_*.py` for the full catalogue.\n", + "\n", + "### The index arithmetic you already know\n", + "\n", + "CUDA programmers tile matrices every day with manual divmod arithmetic. Given a\n", + "4×8 matrix tiled into 2×4 blocks, converting a linear index `i` or a 2D index\n", + "`(row, col)` to **intile** (position within a tile) and **oftile** (which tile)\n", + "requires the same pattern:\n", + "\n", + "```\n", + "intile = (row % 2, col % 4)\n", + "oftile = (row // 2, col // 4)\n", + "```\n", + "\n", + "This works — but it doesn't compose. When you nest multiple tiling levels\n", + "(thread-block → warp → atom), the index expressions multiply and interleave.\n", + "`logical_divide` replaces all of that with a single algebraic operation that\n", + "produces the same intile/oftile decomposition and composes naturally with\n", + "other layout operations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Manual index arithmetic vs logical_divide — same intile/oftile decomposition](../docs/images/intile_oftile.png)\n", + "\n", + "### `logical_divide` — the algebraic formulation\n", + "\n", + "`logical_divide(D, T)` splits a data layout `D` into tiles shaped like `T`.\n", + "The result is a hierarchical layout where each mode is replaced by a pair\n", + "**(intile, oftile)**:\n", + "\n", + "- **intile:** the coordinates inside a single tile\n", + "- **oftile:** which tile you're in\n", + "\n", + "The construction uses `complement` to find the residual (oftile) coordinates:\n", + "\n", + "```\n", + "logical_divide(D, T) = compose(D, Layout(T, complement(T, size(D))))\n", + "```\n", + "\n", + "CuTe provides several variants that rearrange the same tiled result:\n", + "\n", + "| Variant | Result structure | Use case |\n", + "|---|---|---|\n", + "| `logical_divide` | `((intile₀, oftile₀), (intile₁, oftile₁))` | Preserves per-mode hierarchy |\n", + "| `zipped_divide` | `((intile₀, intile₁), (oftile₀, oftile₁))` | Groups all intile / all oftile |\n", + "| `tiled_divide` | `((intile₀, intile₁), oftile₀, oftile₁)` | Zipped + outer modes flattened |\n", + "| `flat_divide` | `(intile₀, intile₁, oftile₀, oftile₁)` | Fully flat — easiest to iterate |" + ] + }, + { + "cell_type": "code", + "execution_count": 640, + "metadata": { + "output": { + "id": 25623011794038690, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D = 16 : 1\n", + "logical_divide(D, 4) = (4, 4) : (1, 4)\n", + " mode 0 (intile): size 4\n", + " mode 1 (oftile): size 4\n", + "\n", + "logical_divide(16 : 1, 4 : 1)\n", + " = compose(L, Layout(T, complement(T, size(L))))\n", + "\n", + " L = 16 : 1\n", + " T = 4 : 1\n", + " size(L) = 16\n", + " complement(T, 16) = 4 : 4\n", + " Layout(T, complement) = (4, 4) : (1, 4)\n", + " compose(L, (4, 4) : (1, 4)) = (4, 4) : (1, 4)\n", + "\n", + " result = (4, 4) : (1, 4)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 1D tiling: 16 elements into tiles of 4\n", + "D = Layout(16, 1)\n", + "result = logical_divide(D, 4)\n", + "print(f\"D = {D}\")\n", + "print(f\"logical_divide(D, 4) = {result}\")\n", + "print(f\" mode 0 (intile): size {size(mode(result, 0))}\")\n", + "print(f\" mode 1 (oftile): size {size(mode(result, 1))}\")\n", + "print()\n", + "explain(logical_divide, D, 4)\n", + "\n", + "draw_layout(result, title=f\"logical_divide({D}, 4)\",\n", + " colorize=True, flatten_hierarchical=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 641, + "metadata": { + "output": { + "id": 2101992157253328, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D = (4, 8) : (8, 1)\n", + "Tile by (2, 4)\n", + "\n", + "logical_divide → shape=((2, 2), (4, 2)) stride=((8, 16), (1, 4))\n", + "zipped_divide → shape=((2, 4), (2, 2)) stride=((8, 1), (16, 4))\n", + "tiled_divide → shape=((2, 4), 2, 2) stride=((8, 1), 16, 4)\n", + "flat_divide → shape=(2, 4, 2, 2) stride=(8, 1, 16, 4)\n" + ] + } + ], + "source": [ + "# 2D tiling: (4,8) row-major tiled by (2,4)\n", + "D = Layout((4, 8), (8, 1))\n", + "tiler = (2, 4)\n", + "print(f\"D = {D}\")\n", + "print(f\"Tile by {tiler}\\n\")\n", + "\n", + "ld = logical_divide(D, tiler)\n", + "zd = zipped_divide(D, tiler)\n", + "td = tiled_divide(D, tiler)\n", + "fd = flat_divide(D, tiler)\n", + "\n", + "for name, r in [(\"logical_divide\", ld), (\"zipped_divide\", zd),\n", + " (\"tiled_divide\", td), (\"flat_divide\", fd)]:\n", + " print(f\"{name:16s} → shape={r.shape} stride={r.stride}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 642, + "metadata": { + "output": { + "id": 1561214818307169, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the 2D tiling results\n", + "draw_composite(\n", + " [(ld, {\"flatten_hierarchical\": False}),\n", + " (zd, {\"flatten_hierarchical\": False})],\n", + " titles=[\"logical_divide\", \"zipped_divide\"],\n", + " main_title=f\"Tiling {D} by {tiler}\",\n", + " colorize=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 643, + "metadata": { + "output": { + "id": 27537391419194670, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Contiguous tile: logical_divide(16:1, 4) = (4, 4) : (1, 4)\n", + "Strided tile: logical_divide(16:1, 4:2) = (4, (2, 2)) : (2, (1, 8))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Non-contiguous tiling: Layout tiler selects strided elements\n", + "contiguous_tile = logical_divide(Layout(16, 1), 4)\n", + "strided_tile = logical_divide(Layout(16, 1), Layout(4, 2))\n", + "\n", + "print(f\"Contiguous tile: logical_divide(16:1, 4) = {contiguous_tile}\")\n", + "print(f\"Strided tile: logical_divide(16:1, 4:2) = {strided_tile}\")\n", + "\n", + "draw_composite(\n", + " [(contiguous_tile, {\"flatten_hierarchical\": False}),\n", + " (strided_tile, {\"flatten_hierarchical\": False})],\n", + " titles=[\"Contiguous tile (size 4)\", \"Strided tile (4:2)\"],\n", + " main_title=\"Contiguous vs strided tiling of 16:1\",\n", + " colorize=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## §3.4.2 Vectorization\n", + "\n", + "CUDA hardware can load or store multiple elements in a single transaction (e.g.,\n", + "`LDS.128` loads 128 bits at once — that's 8 × fp16 or 4 × fp32 elements).\n", + "To exploit this, CuTe internally represents memory layouts **in units of bits**,\n", + "then converts to typed element coordinates via `upcast` and `downcast`:\n", + "\n", + "- **`upcast(bit_layout, n)`** — groups every `n` consecutive bits into one element.\n", + " A layout mapping 32 bits per thread becomes 2 × fp16 elements per thread.\n", + "- **`downcast(elem_layout, n)`** — the inverse: expands each element back to `n` bits.\n", + "\n", + "The **contiguity** of a layout — how many consecutive flat-index elements\n", + "starting from offset 0 are truly adjacent in memory — determines the maximum\n", + "vector width. If `contiguity(L) = 4`, we can safely use 4-wide vector loads on `L`." + ] + }, + { + "cell_type": "code", + "execution_count": 644, + "metadata": { + "output": { + "id": 1952058278775263, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bit layout: (32, 32) : (32, 1)\n", + " 32 threads × 32 bits each\n", + "\n", + "upcast(bits, 16) → fp16 elements: (32, 2) : (2, 1)\n", + " 32 threads × 2 elements each\n", + "\n", + "downcast(elems, 16) → back to bits: (32, 32) : (32, 1)\n", + "✓ Roundtrip verified\n" + ] + } + ], + "source": [ + "# upcast / downcast — bit ↔ element coordinate conversion\n", + "bits = Layout((32, 32), (32, 1))\n", + "print(f\"Bit layout: {bits}\")\n", + "print(f\" 32 threads × 32 bits each\\n\")\n", + "\n", + "elems = upcast(bits, 16)\n", + "print(f\"upcast(bits, 16) → fp16 elements: {elems}\")\n", + "print(f\" 32 threads × {size(mode(elems, 1))} elements each\\n\")\n", + "\n", + "roundtrip = downcast(elems, 16)\n", + "print(f\"downcast(elems, 16) → back to bits: {roundtrip}\")\n", + "assert functionally_equal(roundtrip, bits), \"Roundtrip failed!\"\n", + "print(\"✓ Roundtrip verified\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hierarchical upcast: LDMATRIX\n", + "\n", + "NVIDIA's `LDMATRIX` instruction (Volta and later) loads matrix fragments from\n", + "shared memory directly into the register layout needed by Tensor Cores. Each\n", + "warp's 32 threads cooperatively load multiple 32-bit groups (e.g., 4 × 32 bits =\n", + "128 bits per thread) from **non-contiguous** shared-memory locations. The\n", + "resulting bit-layout is *hierarchical*: the inner mode covers 32 contiguous bits,\n", + "while the outer mode strides across matrix rows. `upcast` handles this hierarchy\n", + "automatically, dividing only the inner contiguous mode by the element width." + ] + }, + { + "cell_type": "code", + "execution_count": 645, + "metadata": { + "output": { + "id": 979654661409611, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LDMATRIX bit layout: (32, (32, 4)) : (32, (1, 1024))\n", + " 32 threads × 128 bits per thread\n", + " = 8 fp16 elements per thread\n", + "\n", + "upcast(bits, 16) → (32, (2, 4)) : (2, (1, 64))\n", + " 32 threads × 8 fp16 elements per thread\n" + ] + } + ], + "source": [ + "# Hierarchical upcast (LDMATRIX-style: 4 groups of 32 bits per thread)\n", + "bits = Layout((32, (32, 4)), (32, (1, 1024)))\n", + "print(f\"LDMATRIX bit layout: {bits}\")\n", + "print(f\" 32 threads × {size(mode(bits, 1))} bits per thread\")\n", + "print(f\" = {size(mode(bits, 1)) // 16} fp16 elements per thread\\n\")\n", + "\n", + "elems = upcast(bits, 16)\n", + "print(f\"upcast(bits, 16) → {elems}\")\n", + "print(f\" 32 threads × {size(mode(elems, 1))} fp16 elements per thread\")" + ] + }, + { + "cell_type": "code", + "execution_count": 646, + "metadata": { + "output": { + "id": 34700185676262584, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Layout contiguity mode_contiguity\n", + "-----------------------------------------------------------------\n", + "Contiguous 1D (16:1) 16 [16]\n", + "Strided 1D (8:2) 1 [1]\n", + "Col-major (4,8):(1,4) 32 [4, 1]\n", + "Row-major (4,8):(8,1) 1 [1, 8]\n", + "Gapped (4,4):(1,8) 4 [4, 1]\n", + "\n", + "Slice contiguity examples:\n", + " L = (4, 8) : (1, 4)\n", + " slice_contiguity(L, (0, None)) = 1 (fix row=0, free cols)\n", + " slice_contiguity(L, (None, 0)) = 4 (free rows, fix col=0)\n" + ] + } + ], + "source": [ + "# Contiguity analysis — determines maximum vector width\n", + "layouts = [\n", + " (\"Contiguous 1D (16:1)\", Layout(16, 1)),\n", + " (\"Strided 1D (8:2)\", Layout(8, 2)),\n", + " (\"Col-major (4,8):(1,4)\", Layout((4, 8), (1, 4))),\n", + " (\"Row-major (4,8):(8,1)\", Layout((4, 8), (8, 1))),\n", + " (\"Gapped (4,4):(1,8)\", Layout((4, 4), (1, 8))),\n", + "]\n", + "\n", + "print(f\"{'Layout':30s} contiguity mode_contiguity\")\n", + "print(\"-\" * 65)\n", + "for name, L in layouts:\n", + " c = contiguity(L)\n", + " mc = mode_contiguity(L)\n", + " print(f\"{name:30s} {c:10d} {mc}\")\n", + "\n", + "print(f\"\\nSlice contiguity examples:\")\n", + "L = Layout((4, 8), (1, 4))\n", + "print(f\" L = {L}\")\n", + "print(f\" slice_contiguity(L, (0, None)) = {slice_contiguity(L, (0, None))} (fix row=0, free cols)\")\n", + "print(f\" slice_contiguity(L, (None, 0)) = {slice_contiguity(L, (None, 0))} (free rows, fix col=0)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Key insight:** `contiguity(L) = max_common_vector(L, Layout(size(L)))` —\n", + "it measures how well `L` agrees with the identity (contiguous) layout.\n", + "A contiguity of `k` means we can safely issue `k`-wide vector loads/stores.\n", + "\n", + "Note the **column-major convention**: CuTe always iterates coordinates with\n", + "mode 0 (the leftmost) varying fastest, like Fortran/MATLAB. So `Layout((4,8))`\n", + "auto-computes column-major strides `(1,4)`, giving contiguity 32 (all elements\n", + "are consecutive). The \"row-major\" layout `(4,8):(8,1)` has contiguity **1** because\n", + "mode 0 has stride 8 — successive flat indices jump by 8 in memory. This doesn't\n", + "mean row-major is bad; it means you'd slice along mode 1 (`slice_contiguity` with\n", + "mode 0 fixed) to find the 8-wide contiguous runs there." + ] + }, + { + "cell_type": "code", + "execution_count": 647, + "metadata": { + "output": { + "id": 1506441441049941, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize contiguity — offsets in memory for three key patterns\n", + "draw_composite(\n", + " [Layout((4, 8), (1, 4)), # col-major: contiguity=32\n", + " Layout((4, 4), (1, 8)), # gapped: contiguity=4\n", + " Layout((4, 8), (8, 1))], # row-major: contiguity=1\n", + " titles=[\"Col-major (4,8):(1,4)\\ncontiguity = 32\",\n", + " \"Gapped (4,4):(1,8)\\ncontiguity = 4\",\n", + " \"Row-major (4,8):(8,1)\\ncontiguity = 1\"],\n", + " main_title=\"Contiguity — how offsets flow through memory\",\n", + " colorize=True,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## §3.4.4 Admissibility\n", + "\n", + "Not every tiler works with every layout, and not every pair of layouts can be\n", + "vectorized. Before issuing a `copy(src, dst)`, CuTe determines how wide a\n", + "vector instruction to use. Before applying `logical_divide(D, T)`, it verifies\n", + "that the tiler `T` is structurally compatible with `D`.\n", + "\n", + "Three predicates gate these operations:\n", + "\n", + "- **`max_common_vector(src, dst)`** — the longest contiguous prefix where `src`\n", + " and `dst` agree on their offset mapping. This is the vector width for a copy.\n", + "- **`compatible(A, B)`** — can shape `A` be regrouped into shape `B`? Required\n", + " when a tiler's shape must match the data's.\n", + "- **`weakly_congruent(A, B)`** — is `A`'s nesting profile no deeper than `B`'s?\n", + " Ensures a hierarchical tiler doesn't assume structure the data doesn't have." + ] + }, + { + "cell_type": "code", + "execution_count": 648, + "metadata": { + "output": { + "id": 1287931139958468, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max_common_vector(16 : 1, 16 : 1) = 16\n", + " → full vectorization\n", + "\n", + "max_common_layout((4, 4) : (1, 4), 16 : 1) = 16 : 1\n", + "max_common_vector((4, 4) : (1, 4), 16 : 1) = 16\n", + " → vectorize in chunks of 16\n", + "\n", + "max_common_vector((4, 4) : (1, 4), (4, 4) : (4, 1)) = 1\n", + " → element-by-element copy\n" + ] + } + ], + "source": [ + "# max_common_layout and max_common_vector\n", + "#\n", + "# These determine how wide a vector instruction copy(src, dst) can use.\n", + "# They compare the offset-mapping of two layouts starting from flat index 0\n", + "# and return the longest contiguous prefix where both agree.\n", + "\n", + "# Case 1: Identical layouts — full agreement\n", + "a = Layout(16, 1)\n", + "b = Layout(16, 1)\n", + "print(f\"max_common_vector({a}, {b}) = {max_common_vector(a, b)}\")\n", + "print(f\" → full vectorization\\n\")\n", + "\n", + "# Case 2: Different shapes, same mapping!\n", + "# (4,4):(1,4) has column-major strides → maps flat index i to offset i,\n", + "# exactly like 16:1. CuTe sees through the shape difference.\n", + "a = Layout((4, 4), (1, 4))\n", + "b = Layout(16, 1)\n", + "mcl = max_common_layout(a, b)\n", + "mcv = max_common_vector(a, b)\n", + "print(f\"max_common_layout({a}, {b}) = {mcl}\")\n", + "print(f\"max_common_vector({a}, {b}) = {mcv}\")\n", + "print(f\" → vectorize in chunks of {mcv}\\n\")\n", + "\n", + "# Case 3: Transposed layouts — disagree at the very first step\n", + "# (4,4):(1,4) sends flat 1 → offset 1; (4,4):(4,1) sends flat 1 → offset 4.\n", + "a = Layout((4, 4), (1, 4))\n", + "b = Layout((4, 4), (4, 1))\n", + "print(f\"max_common_vector({a}, {b}) = {max_common_vector(a, b)}\")\n", + "print(f\" → element-by-element copy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 649, + "metadata": { + "output": { + "id": 1493597448828480, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "compatible((2, 2, 3), (4, 3)) = True\n", + " 2×2 groups to 4 ✓\n", + "\n", + "compatible(12, (2, 2, 3)) = True\n", + " scalar compatible with any decomposition ✓\n", + "\n", + "compatible((2, 2, 3), (5, 2)) = False\n", + " sizes don't match: 12 ≠ 10 ✗\n" + ] + } + ], + "source": [ + "# compatible() — shape compatibility for tiling\n", + "print(\"compatible((2, 2, 3), (4, 3)) =\", compatible((2, 2, 3), (4, 3)))\n", + "print(\" 2×2 groups to 4 ✓\\n\")\n", + "\n", + "print(\"compatible(12, (2, 2, 3)) =\", compatible(12, (2, 2, 3)))\n", + "print(\" scalar compatible with any decomposition ✓\\n\")\n", + "\n", + "print(\"compatible((2, 2, 3), (5, 2)) =\", compatible((2, 2, 3), (5, 2)))\n", + "print(\" sizes don't match: 12 ≠ 10 ✗\")" + ] + }, + { + "cell_type": "code", + "execution_count": 650, + "metadata": { + "output": { + "id": 956248510422295, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAC/oAAAOSCAYAAAB+gkrTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgABAABJREFUeJzs3Xd8HPWd//H3qvcuq0u2Zcu994Yx7jaYXk0NoSQE4tzlAvcjJJdwuUAul0DASSAQeujFgHHH2Lg3We6yrC7Zsnrv2v39ITzWaCVLtmXv2ryej0ce2e93vjPzmdnZXQHv+Y4lNTXVJgAAAAAAAAAAAAAAAAAAAAAA4BRcHF0AAAAAAAAAAAAAAAAAAAAAAAA4jaA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOhKA/AAAAAAAAAAAAAAAAAAAAAABOxM3RBQAAAAAAAAAAADjCcy+8pLT0DKM9YdwY3b34FgdW5FzKysu1Zt0GpR49ptKyMjU2NhnL2p+rgoKTWrt+o9LSM1VRUaGmpmZj2YK5s7Rw/uyLWjsAAAAAAAAAXOoI+gMAAAAAAAAAVFJSqm07dpv6ZkyfKh8fbwdVBMCRiotL9L9/Xqrqmpoux2Zm5ej5pS+rqampy7GOdDQtXWnHTt/Y4e3tpauunObAigAAAAAAAACgcwT9AQAAAAAAAAAqKS3TV6vWmvomjh9D0B/4nlq1dn23Qv6S9MVXq5w+5C9JaccyTN9zIcHBBP0BAAAAAAAAOC2C/gAAAAAAAAAA4HvpvnvuUHObgLqnp6cDq3EuWdm5pnZCfJxuvek6+fn6SDKfq6zsHNPYoUMGadHCufL6boy3NzcMAQAAAAAAAMDZIugPAAAAAAAAAAC+lwID/B1dgtNqaGgwtQcPSlJCfGwnYxtN7ZHDhygmOuqC1QYAAAAAAAAA3weW1NRUm6OLAAAAAAAAgHN66jfPqLSszGgvmDtLs2deqTVff6Pde1JUWlYmXx8fDRyQpPlzZyosNESSVFJaptVrv9HBQ4dVVVUt/wB/DRk0UAvmzlRgYIDdfkpKSrXvwGHl5efr+ImTqq6uUW1trRqbmuTl5anQkGD1TojXpAljlRAfZ1rXarXqL0v/obT0DKMvJjpKj//7o3J1dTX6MjKz9Ke//F022+l/Hbb4ths1eeL48z5PFZVV2rptp1LTjulEwUnV1dbJzd1NAf7+iomO0sAB/TVpwlhTPafk5uVry7adSs/IUmlZuRoaGuTt7aWw0FAN6J+oqVMmKjQkuMP9Xqz35813PtD2nbuNdv/Evlry6EPatmO3Nm3ZpuMnCuTm6qaE+FjNmT1D/RP7SpIaGxu17ptvtWv3XpWUlsrTw1N9+yRo/tyZio/rOCwqSTabTQcOHtauPSnKyslVVVWVWppb5OPro+ioSA0ZNECTJo6Tt5eX3bolJaX61dPPmvp++siDiouN1tqvN2rvvgMqKS2Vm6ub4uJiNOuq6RoyaECntXRHyv6DevnVN422q6urfv/bX8r3u1mv2/pyxWqtWLXOaIeFhui/fvkLWSwWo89qtSo5Zb+SU/YrJydPVdXVstlsCvD3V5/eCZo4YYwGDUg6Y002m02HDqdqd3KKsrJzVVlZpcamJvn5+igoKEhJ/fpq3NhRiomO0tbtu/T2ux9261gnjBujuxffYuprbGzUth27deDQEeXlH1dNTa1cXCzy9/NTfFysRo0cplEjhsnFxcVuex3te+lzzyo7J0/r1m/QsfRMVVXXKLFPby159KFu1eiMjmVkasfOPcrMylF5RYUaGhrl4+OtoMAAJfbto1Ejh6lf3z5267W0tGh3copS9h1Udm6eqqtrJNnk6+uruJhoDR82WOPGjpa7m/2cPkfT0vX80pdNfb996nE1NDZq5eqvdfRYuurrGxQeFqqJ48foyiumGN9RBw4e1tcbNik3L1/Nzc2K6NVLkyeO07QpE03X6imPLHnc1L7z9ps1dvQIff3NJu1OTlFRcYlcXVwUFxejK6dN0YjhQzo8T3v3HVB2Tp5y8/JVWlqm2to61dbVydXVRb4+PoqKitSwIYM0ftxoY6b4tjr7/EdE9NKqNV/r4OFUlZdXqLm5WUufax333AsvmX4/2l/jPf2dUl5eoRWrv9bBw0dUVVklXz9fJfVL1JxZVyo6KrLDczlpwthOt3cm5/rZbF9DZ+68/eZuf3f89qnHFfrdb9CRo8e0bccu5eTkqbyiQk1NzfL29pKfr6/Cw0IVHx+rPgnxGtzJeayqqtamrdt1JDVNBScLVVdXLw8PD4WFBmtgUn9Nv2KygoOCTOu0/x3r6rjO5pzX1tZq4+ZtOnT4qAoLi1RXVyeLi4v8/HwV4O+n2JhoJcTHafCgJLu6Tjl4OFU7dycrKytHlVVVammxys/PVwnxsRo7eqRGjRjW4WfvlOMnCrRq7XodTUtXbW2d/P39NHhgkubPmSmr1drhNZzUP9Fod/Y731Zn3ymn3te2mpqatGNXsvYfOKTc/OOqqamRxeLy3Xdeb02dPFG9E+Ls1jtTLYdTj+qbjVuUlZWj+vp6BQUFaviwIZo/Z6Z8fDp/YkRjY5N27k7WwUNHlJOXr5qaWtlsVvn7+atXeKgGJPXXxAljFOBvf9PPuVxrp7S0tGjHrmTt3XdA+cdPqLq6RlarVb6+PvLz9VVUZIR6J8Spf79ExcVGd1o/AAAAAAAAvt+Y0R8AAAAAAADdVl1Toz/86QWdKDhp9JVXVGrbjl3af/CQfvrIg6qrq9dLr76h2to6Y0xZWbk2bdmmA4cO6xc/+4ldmDxl/0F9/NmXHe6ztrZOtbV1ys07rk1btmvG9Km68bqrjeUuLi66565b9fs/PK+a2lpJUv7xE1qxap2uXjBHUmvY8c13PjCF/EeNHNYjIf+vv/lWy75cqebmZlN/c0uL6usbVFhUrOSU/Ro9crgpiNbU1KQPP/lcm7fusNtmTU2tampqlZ2Tq7XrN2rRwrmaPfPKLmu5UO9Pe1abTa+9+a527dlr9DWoUYeOHNWRo8d01x03a+CA/vrL0n+Yamlqata+A4d06MhR/ejB+zQwqZ/dtsvKy/XPN/6ljMxsu2WVlVWqrKzSkdQ0rVqzXvfceWunQdC28o+f0Otvv6eKikpTLUfT0pV2LEN33HqjJk8c1+V2OjN08ED5+/upqqpaUmu4b8/efZo2ZaLd2N17UkztSRPGmcKbJ08W6dU33lH+8RN265aUlqmktEy79uzViOFDdPcdt8rLyz7sXFxSqtfffFeZ2Tl2yyoqq1RRWaXsnFw1NzfrphsWnfXxtnUsPVOvvfkvlbc5t+3rTU7Zr7jYaP3gnsXqFR7W5Ta37ditd977SFar9bxqcwbV1TV6690PdeDgYbtlVVXVqqqqVm7ecZWWltkF/Y+fKNCrr7+jgpOFduuWl1eovLxC+w8e1so163X/PYs7nWm9rZT9B7XsixVqbmkx7eeTZct15Ogx/eiBe/XZFyu0bv1G03q5efl6/6N85ebla/FtN3W5n6qqKj37f+bvIqk1KHw0LV1XXjFFN3dw7b39rw9VV19v19/S0qLGxgqVlVfo0OFUrVm3QT968F5FR0V2WUv+8QK98vrbqqmp7XJsd53rd0pWdq6WvvSq6fu3oqJSO3cnK3nvPt1z1209VuOF+Gz2hE+Wfal167+16z/1u3eysEgHDh2Rm5ubnv/j7+zGbdm2Ux9+skyNjU2m/rq6OuXmtf6tsH7jZt1607U98hvflZOFRXr+xZdUUVllXtDSorKycpWVlSs7J0+bt+7QtVfP05xZM0zDKioq9dpb7yrtWIbaO/U5T9l3UIl9e+v+e+/s8AkUe1MO6LU3/2X6XJeVlWvz1h3anZyiW2+6vmcOtpsys7L1zzfeNd2IeEphUbEKi4q1dfsuTZ08UbfcuKjDmyDbstps+uDjZdrw7RZTf3FJqb7+5lsdPnJUP//ZIx3e/HPk6DG9+c77ps/qKaVlZSotK9ORo8cU0Svc7gak87nWmpqa9MLfXlF6Rpbdfk/9LXP8RIF2J6do0MAk/eTh+894DgAAAAAAAPD9ZT+FEgAAAAAAANCJbzdvswtunlJTU6vX33pP//jnW6YQY1vl5RVa9uWKc96/zWbT1998qy3bzOH44KAg3XHbjaa+VWvXKyc3X5L06edfqai45PT44CDdcYt5/Ln4auVaffzZl3Yh/67YbDa98fb7HYb827NarfrsixVauebrLsderPcnIzPLFPJvX+/7H36mv738eqe1NDc361/vf2wX5K6pqdVflv6jw5B/e9U1Nfr7K2/oaFp6l2M//uzLDkN+Uut78dGnn6uuruNz0h2urq4aP3a0qa+j85Odk6vComKjbbFYNGH86fVKy8r03NKXOgz5t5ey76Beee0tu3NYXl6hP7/w9w5D/j0tOydXL/791Q6DxO3l5h3XX5a+bB+G7cDlEvKvr2/QX/76jw5D/l0pLinV80tf7jDk315JSale+Os/VNDJ562tT5YtN4WB2zp0OFUv/O0Vu5B/W1u27ezWZ+7LFWs6/fxL0jcbN+vbzdu63E5nSsvK9NIrb6ilk2Np65NlX/ZoyF86t++U6uoa/f2V1zv9/m1uadHrb73XI/VdqM/m+deV12HIv7s2bdmud977yC543V5zc7Peee9jbd+555z31V2fLFt+zueurq5Of/nrPzoM+beXnpGlpX9/VQ0Njab+EwUn9dpb73b6ua6vb+j2Uxd6Qm5evv7y11c6DPm3t2nLNr37wSddjsvIzLIL+bd1ouCk1qz7xq7/SGqa/vrSPzv9rJ65tvO71jZs2tphyB8AAAAAAAA4W8zoDwAAAAAAgG6z2WzqkxCvaxfNl5enl75csdoUYj1+okCSNHTIIC2YO1MtLVa99+GnpuDynr37tfi2m0wzuLq5uSmpf6KGDRmkXr3C5e/nK29vbzU0NOj4idYAV9vQ6NqvN9rNnjpy+FBNnTxBm7Zsl9QaOH/rXx/o2mvmmwKlLi4uuveu20yz65+L/OMn9NWqtaY+V1dXXXXlNA0fOlh+fr6ts88fTbML9Cen7Fdyyn5TX1RkhK5ZOFdhoSHKyzuuTz5frurqGmP58hVrNHrk8DPOunyh3p+O9hMQ4K+bb1ikqMgI7dq913QjQn1Dg3Jy8xTRK1w337BIAQH+WrNug3buTjbGlJSUKiMr2zSL+ZcrVpuC8JI0YvgQTZ86Wd7e3jp4+Ii+WrnWCIG3tLToX+9/rKf+89+7rHfQgP6aN3em3N3ctebrb5S89/T5b2ho1L4DhzVh3OhOt9GVyRPHmQLS6RlZKisvV3BQkNG3a/de0zqDBiaZln/48eeqbBMYDQzw18L5s9U7IV42m01HUtP0xVerjRtLDqemaduO3aaZwz/89HOVl1eY9hMXG6PZV01XTEyUrFarjh8vaH0vvnuSwKiRw5TUr68ys3P02pvvmtb92WMPKzgw0Gh7fjdjss1m0zvvfaymptMhSIvFojmzrtSIYUPU1NSsTVu3a+eu0+95WXmFln2xQncvvuWM59JqtWrQgP6aNfNKBQcGqrS8TMXFpWdcxxl9tWqN3U0b4WGhmjNrhnonxMnFxUUFJwuVvHe/mlvMNwt9+PEy0+dfkqZMGq/x40bL1cVVu5NTtH7DJmNZXX293vvwMy159KEz1mSz2TR75pUaP3aUSkvL9Na/PlR1zen9HE1Ll4uLi667Zr6GDBqgzOxcvffBJ6YQ8c7dyUrqn3jG/bS0tKhP73gtmDtL/v7+OnI0TV8uX2XazhfLV2nCuDHy8HA3+oKDgzSmT28l9eurgAB/+fn5yiKpsqpa+w8c0vqNm40nsxSXlCo5Zb/Gjh55xlqsVqt6hYfp6vlzFBsTrZraWh1JTTvjOl05l++U1eu+MZ76ccqwIYM0d/YMeXp6as/efVq5uusburpT2/l+Nn/71OOSpD/95W+mmwVmXDFFM6ZPNdq+fr5K6tdXkvSrp5811XH9ogUaNWKY0Q4KCtTefQdMY+JiY3Tt1fMUEhIsq9Wq8ooK5eef0NFjGcpoF5Iur6jUR59+YeobPDBJV06fqrCQEFVWVWn9hk1K2X/QWP7hx8s0bMhA+fj46IZrF2rhvFlav2GT1m/cfLquwAD922M/Mm3X18+3/Wnt1LF2If1FC+dp8KAB8vT0UF1dvQqLipSRma1DR47arbt8xRrTzTxenp5aOH+2+vfrK1dXV2VkZmvZlyuMm0Pyj5/QmnXfGE8rklo/R+1vNhw3dpSmTZ4oi8Wirdt3asu2nd0+nvPReu19pMbG0zcjRPQK1/y5MxUTHaXm5mYlpxzQmnXfGJ/jrdt3adyYURrQwRN+2m7Xw8ND1y9aoKR+fZWbf1zvffip6usbjDG7du/VNQvmGu2mpia99e6HdjcDjRoxTFMmj1doSIjq6+uVkZWjLe3+Rjvfa02yvy7Gjhmp6VMny8/PV01NTSouKVVObp6OpKaZnuoDAAAAAAAAtEfQHwAAAAAAAN3m5uqqh354j/z9/SRJixbOtZut2t/fTz+87065u7X+q6eF82fr5VffNJY3NTXpZGGRoqMijb4rpk7SFVMndbjPuNgYRUX20rP/94LRd7KwSJVVVQrw9zeNvfG6a3QsPdMIzh0/UaCXXnnDCJRJ0rw5V5nC5edqw7dbTNuVpB/ed6eGDx1stHuFh6lfYh/Numq6cT4k2c1k7eXlqX977GEjIBYTHaVevcL0x+f+aoyxWq3asnWHrlu0oNOaLtT705Hbbr5eI4YNkSRdvWCOvt2yzW7W7B/cc4diY6IlSbfcuEi79uw1nbP8/BPGe9HU3KxtO3aZ1k/s20cP/uBuox0fFyNXFxct+3Kl0VdUXKIjqWkaMnhgp7WGBAfr4Qfuldt3x3zfXbfrSOox04zb3ZlF/0wiI3qpT+94ZWa1zqRvs9m0a0+KZl81XVLr+7d77z7TOpMmjDVel5WXa9+BQ6blD/3wHiXExxnt2Jho1dXXm8LA327eagT9y8srtDfFHKTtkxCvnz76kOn6i46K1NgxI43wqJenp7w8PVVSaj8Dc3BgoEJDQ+z60zOy7M7Z3NkzTEHLfol9VFNdYwq47tydrJtvXCRvLy+7bZ7SOyFOP37oB3JxaX0gbUREuDSg0+FOqbm52bjp6JSw0BD94t9+YnzOpdbrZuTwoaZZ3kvLynTg0BHTuuPGjtIdt55+Ckmf3vFqamoy7SMtPUMFBScVGRnRaV0jhg3RddfMl9R6HYwfN1pff2OeYX36tMmaOeOK1voiI7T/wCFToDUvv+vPir+/nx778YNGiD8uNlouFos+WbbcGFNTW6uDh4+YwuBPPv6zDrcXGRmhpP6JKiwuMX2npR3L7DLo7+npoSWPPqzAgNO/F337JHR5DGdyLt8pO3aZZ/wOCw3RAz+4y7hJKToqUtXVNef1pAOpZz6bpz7zLi7mG6i8vb3tvg+8vrv5pz1fX1+7se2f1DF65HANGphktKMiIzRoQJJmXTXdFOKWpK3bd5puXoiOitSPHrzP9D2R2Le3fv30H4zZ5Ovq67Vj915dOa01YO333U2Ebbm4uHb4HdddLW2OycvLUzNnTDOuC0lKiI/VuDGjJMl0TE3Nzdrc7ulEi2+/SaNHDjcdo4uLRe+897HR9+2WbVo4f7YsFovq6uu1v91vfFL/RN17521Gu2+fBFVVVduNuxDSM7OUm3fcaLu6uuqxHz+goKDTN4vFx8WqrLzcdKPJxs1bzxj0l6Qbrl2oaVMmSmr9PqioqNSnn39lLC8uKVVDQ6M8PT0kSXv3HbC76e2q6VN14/XXmPri42I1feok1Tecfm/O91qTzNeFJF05bYr69I432jHRURoxbIiuWTDX7loHAAAAAAAA2iLoDwAAAAAAgG4bNDDJCJFL6jAcN2bUCFOoOKKDGehr24QhTykqLtHW7Tt1LD1TRcUlqqurU1NTs924U8rLK+yC/h4e7vrBPXfoD3960Zjhtm2wMLFvb82fM/MMR9h9R9PSTe3eCXGmkH9bbYOQVqvVbqbiUSOGmcK/ktSnd4JioqNMgc1j6ZlnrOlCvj9t+fh4a9iQQUbbYrEoNCTYFPSPiY4yQv6t6/jIz9dXVdWnZ7Ruu5/snFw1Np4O1kmtM5i3N3XyBFPQX2o9L2cK+k+ZNN4UvHR1dVV4WIhycvONvroujrk7Jk0YZwT9pdYZhk8F/dOOZaiizczYfr6+pusl7Zj9e/uHP73Y5T5z846rvqFBXp6eOtpuBmFJmj9vlun9but8nmqRlm6/r6mTJtj1TZk8wRQmtlqtyszM1uBBnSf3586+yghUnouSkgsz+7+vn2+noeb2snPy1NDQaOqbddV0u8/5KW3fi44+5x2d27ZPMDklLT3zjEH/8WPNT63o6Dui/ZMt2j9FpKvvB0kaO3qkaaZ+qfWpF22D/pKUmZVjCvpbrVbt2btP+/YfVP7xApVXVKixsckuIH5KeUVFh/1tTZk43hTy7wln+51SUlpmN5v/xPFj7J5EMnni+PMO+l/Iz+b5iouLNbWXr1itjKxsxURHqld4uCIjeikmOlJubm7y8jJ/1trPkH78RIEe/bf/7HKfx9IzjPD1hRAfF6P0737T6+sb9Ltn/6wBSf3UKzxMEb3CFRMdZQTd2x5TTk6e3W/eq6+/o1f1zhn3V11do4KThYqKjFBubr7dZ2PShHF260yaOO6iBP2Ptfsda2lp0ZP/9T9dr9fF3zaenh6a2ObGOEmKiOhlN662rtYI+rf/G83V1VUL5s/ucPsWi8V081lPXGvxcTE6dDjVWPa3f7ymIYMGKjKil3r1ClNUZIQieoXLYrHYXesAAAAAAABAWwT9AQAAAAAA0G1h7UKhHu7udmNCQ4JNbfcOxlhbzMG0TVu26/2PPus0zNmR9iHaU2Kio7Ro4Vy7QKmHh7vuveu28woQt1VRWWlqx7cLMHampqZWzS0tpr6wsNAOx4aFhpiC/uXt9tnR+LZ66v1pLzgoyO48urt7nHE/He2r7X7ahuBPCQ+zDyH7+PjI29vbFKJt/160FxER3mUtLV0cc3eMGTVCH336hRobW6/NvPzjxgzru/bsNY0dN3aUKShc0Y3AckdsNpuqqqrl5enZ4XmIj4s5p+12pf375ebqapq1+ZT216TU9fsV1+YGkXPxq6efPa/1O3Pn7TebnsJwJufzXnT0WejoO+Jczm37YH/H3xHmMWf63Ha6nxD72ry9veXj4216ekFlVZXxuqq6Wn996Z+msHxXGhq6ngk7NrbnPwNn+51SWVnVfniH72lH33ln60J+Ns/XwKR+Gj50sPH0kuaWFu0/cEj72zzNxN3dTYMHDtDc2VcpIf7072p5B5+L7ujo3Peka6+erxf+9ooxA3xhUbEKi4pNY3qFh2nShHGaceVU48ar7tyk0pmKyipFRUaYPj+nhIXa//Z29F5fCOd6TDU1tWppabG78eWU0JAQuxvWuvrbpaLd+x4eHnrGJ8m01RPX2owrpmrXnhQVF5dIaj3G9k/18PX10ZhRIzRvzswevxkJAAAAAAAAl4+e+a+aAAAAAAAA+F7w9jbPAN5RaL79mK6cKDh51iF/qTXg3JmMrGy7vsbGJuXkdD9Aeim6EO9PR3w62IaLxdLj++kpvh3Mou5i6fl/Nerl5anRI4eZ+nbu3qvm5mbt3XfA1D95ov2sy+fqVMD0chEYGODoEi5bPt7moKul3edWOr8nPZyPjz754qxC/pKkzn8GDBfieuqJ7xSL7M/998EDP7hLd95+s5L6J5pudjqlqalZKfsP6k/P/1UZmfa/5WfrQn8/Jvbtrf/3iyW6YuokhQTbh+yl1vD/si9X6NXX3u6RfZ46pgt5DVlt9n+TVdfUXJB92Ww2NTV3/gSnjj9vzvf5aXut+fn56omfP6arF8xRTHRUh9+1NTW12rhpq/73Ty+YboACAAAAAAAA2mJGfwAAAAAAADjUnr37TCF/i8Wi2TOv1PChg+Xn5ysXi0VFJaV64a//6Nb2Nm3Zrr0pBzpc9q/3P1ZCQqyCg4LOu+7AgAAVfTdTqyTl5OZ1az1fXx+5ubqaZvUvbrOdtopLStvt8/Kd8bWjMG5Rcan69ult6qupqTXN5i9JAQHOEwyfNGGctu3YbbR37dmr+PhYU4gvIT5O0VGRpvXaH7/FYtHj//6YXTC7I6dm6w7s4Dzk5OZryKABZ3UM3dG+3uaWFpWXVyg4OMjU3/4alrp+v3rqqRuO1Nl7kRAf1/W6HXwWiotLFNSuv6Nz29F+HaGk1L622to6uzBrgH/rd1pzc7P2puw3LYuJjtKCubPUq1eYPD1anxjywSef68DBw2dVizMEggM6+O4uKS2z6ysqtj9vZ+tCfjZ7gouLiyZNGKtJE8aqpaVFJaVlKiou0YkTBdq8dYcxG35zS4vWfr1BD95/t6TW4yo4WWhsZ+CA/rrjlhu63F9HNxP0tF7hYbr1put0602tv1GFRcUqKi5W2rEMbd2+y7gxcf/Bw8rLP67YmOgOP+c/evA+RUX06nJ//t99bvz9/eyWFZeU2f1udvRet+fqav7ebWy0v0Gi/ZMK2mt/TN5eXnri5491GHJv79RnvKe0/3upuKhEdfX13ZrVv6euNW8vL82fM1Pz58xUY2OTioqLVVRUopy8PG34dovq61ufSFJWXqHtO3drxvSp3Tk0AAAAAAAAfM8Q9AcAAAAAAIBDVVRUmtrRUZG69up5pr7kdgHQzhQUnNTHn31h6gsJDlZpWWugsqa2Vm+8/b4e+/ED5x0mTuqfaAr6Z2Xnav/Bwxo2ZJDd2PqGBrm7ucnV1VUuLi7q27e3jqalG8uT9+7XDdculE+bWWszs7KVf/yEaTv9EvueV83OLCE+Tu7u7qYZcTdv3a4J40abxm3eut1u3X6JfS54fd3VL7GPeoWHGYHI4pJSLftihWnMpAlj7dbr3+69tdlsOnQ4VXNnz+h0X8dPFKimtlahoSGSpKR+9tfHytXrNKCTmbNra+tMs7e7ubnajelsNuz29UqtN9lcs3CuXV9bLi4u6tsnocNt9pSlzz17QbffHQnxsfLw8FBjY6PRt3b9Ro0dPaLDp120fS86up43bdlu19/+3Ha2riPs2rNXixbOk4eHu9G3dftOu3G9E1pvfKiuqTXd/CRJC+bN0sjhQ412XV2d8vIuzaeyhIYEKyDAX5WVVUbfjt17NHvmdNNv0ZZtO857X8782aytrZObm5txXbi6uqpXeJh6hYdpyKABCg8L08v/fNMY3zZs3b9fX6UePWa0M7Oy1WK1qld4WIf7slqtStl/UEn9Ek39ru2+5853xv/yikrTTTi+vj7q4xuvPr3jNX7saGXn5Jl+ywtOFio2JloJ8XHy8HA3Ber37T+ooYMHdrqvktIyFRScNL7z4+Ni5eLiYrpZcuv2nRo/dpRpva3b7D977Xm3u6msuLhEzc3Nxm9HS0uLtmw98/XZv91vUF19vbKyczV2zMhO18nMypabm5tCLSFd1ng2kvonakub425uadGKVet0w7UL7cbabDbVNzQYNwH0xLVWUVmlAH8/4yYHDw93xURHKSY6SiNHDFVjQ6PWb9xsjG97rQMAAAAAAABtEfQHAAAAAACAQ/n5+ZraJwpO6utvvtWggUlqaGhUyv6DWrd+Y5fbaWpu1j/ffNcUmhs9criuW7RA//OHPxszp6Ydy9Dqtd9o3pyrzqvuK6ZO0pZtO42ZeiXplX++patmXKHhQwfL19dH1dXVSjuWqY2bt+rJX/zMCPJOmzLRFPSvb2jQn/7yd12zcK7Cw0KVm5uvTz5fbtqfi4uLpkwaf141OzN3NzdNmjBWGzdtNfrSM7L08j/f1JXTpsjb20sHD6Vq+co1pvXCwkI1aED/i13uGU2aMFbLvlxptE8WFhmvPTzcOww9BgcHadiQQdrfZrbyL75apeKSEo0ZNULBQUFqsbaotKxcOTl52n/wsHJy87Rg7iwj2BsUFKiRw4dq777TT7TIyMzW/z3/N82eOV0xUVGy2qwqOFmoXbv3Kjg4SDddf40x1s/Pfnborzds0pVXTDFmWw4I8Je7u7sS+/ZWdFSkjp8oMMauWrteNtk0YthQNTU3adOW7Tp85Khpe+PGjOrWjMqXOjc3N02dPEFff/Ot0VdcXKI//OlFzZk1Q70T4mSxWFRUXKK9KQfU0NCgH953p6TWm5OGDh6oA4eOGOvu3J0sT08PjR87Wq6urtq9Z69dULt/Yl9FRUZcnAPsQlVVtf7y15e1YO4sBQT463Bqmr5cvso0xsfHW0MHt94Y5ePtbRdYXrf+W/l4eysgwF8FBYVauWadytvdGHYpGT92tNZ+vcFoFxQU6qVX3tDMGVfIz89XyXv3d3jzxtly5s9memaW3njrPQ0ZMlBJ/foqolcv+fn5ymKxqLi4RKvWrjeN9/Q8Pcv7pPFjtWrNeiOY39DQqOdefEmzZlyhPr0T5Ovro7q6ep0sLNSx9EztP3hYlZVV+u1Tj8vX9/RNdP7t/uaoqq7Wt5u3Kal/otxcW28COBWk746XXnlDkjRk0ADFxcUoNCRYnp6eqq+v18FDqTpRcLLdMXlKOvWbN04bvt1iLNu8dYdqams1acI4hYYES5LKKyqUl3dcBw4dUXpGlsaPHa0h390M4OXlqWFDByll30FjG0fT0vX62+/piikTJVm0dftO0+9KZ2Kiokztuvp6vf7We5o980q1tDRrxap1HT6Foq3EPr0VEx1lurHh7fc+VE5enoYNGazAwAA1NTWpuLhUWdk52nfwkAoKCnXn7TcrLjamyxrPxohhQxUUGGD6zli3fqPKy8s1eeJ4hYQEq6GhUTm5udq0ZYfmzb5KI4YPkdQz19q69RuUvPeAhg0dpD6949UrPEze3t5qbm5Wbt5x7dqTYqq37bUOAAAAAAAAtEXQHwAAAAAAAA41YthQrVpzOtxntVr18WdfmsYEBviros1MyB357POvTOGywAB/3Xbz9fL19dEtN1yrN//1gbFs+co1GpDUT316x59z3bEx0Zo35yqtWLXO6GtuadHqteu1ul1Ysb1RI4Zp5Iih2ptyOpB9ouCkXn71zU7XWThvdqezyV4urp4/R0dS04zZ8CUpZd9BU4ixLVdXVy2+9Ua5utrPRO9IE8aN0RdfrTaFlk8ZOXxYp2Ham29YpKycXFVVVUtqnWV4y7adplmJu3LTDdcoKzvHFG7Myc3Tq6+/Yzd2xhVTTO2w0BD5+fmqurrG6Nu8dYc2t5nF+aePPKik/omyWCxafNtNeu7Fl4wwpM1m06o1602f57aCgwJ17TXzu30sl7oF82bpSGqaKXBdWFSst9/90G7s8KGDTe2bb1ikrOxcVdecfi82bdneaRDc28tLt958Xc8U3gM8PNyVmZWjpS/9s9Mx1yyYa8zs7uHhrsGDBuhAm0ByRmaWnl/6smmd7vwWOKvZM6dr+87dxudbkg4cOmK6oaP9U03OhbN/Nuvq67Vr917t2r23y7GnbgSRWm9kuvG6q/Xeh58afRUVlXZ/L3SlT2/7pxa03aZ0tk8FsSknN185uXldjvTy9DQ9dePq+bN1JDXNdDPY3pQDpr8NunLNgrk6eChVzc3NRt/OXcnauSvZaLd/ckBHhg0dbPcUkuSU/aYnKlksFtPNje1ZLBbdeftN+vMLLxnbaWpq1rr132rd+m87Xe9C8PBw152336y/vvya6bd4d/I+7U7ed8Z1e+paKy0r04Zvt5hu5uhM22sdAAAAAAAAaOv8nk8OAAAAAAAAnKeE+FjNnnllp8uDg4N07123n3EbBw4e1jcbN5v6Ft9+szGz6oTxYzRyxFBjmdVq1etvvWvM8n+urp4/R9cvWmDMAtxdFotF9955myZPHNflWBcXF1179fzzfgLBpcDX10eP/fiBbt2A4efrq4d+eI+S+idehMrOTmBggAYPTOpw2Zne89DQEP3sJw8rNia6W/txcXFRQIC/qS84KEhLHn1YCfGx3S+4zfbmzprR7fG9E+L0yMM/UGBgQJdjY2Oi9dgjDyqwXb2XM28vLz324wc6vRbOJCwsVD/9yYOK6BXe5djQkGA9+uMHnGY2f6k1fBwf1/k1eMXUSZo2ZaKp7+YbFp3x+pg/Z6YGDjj7c+ks/Hx99fAP75W3t3eHy93d3fWDe+6w73c7+/maLofPZlL/RLu/DaZNmajFt90kD4/uzX7u5+sr9+9uJjklOipSw9rdWHMxuLu76+47bzXd6OXj42PcPNUdFotFwUGBpr6oyAjde9dtnd7w5uvjo3sW39bltn18vHXzDYtksVg6XB4Q4K8brl3Y5Xbi42L12I9/2O2nIri5udk9ZaGnDBqYpB8/eJ/d72R39MS11l1zZs1wyr9lAAAAAAAA4ByY0R8AAAAAAAAOd9018xUfF6MN325RXt5xtVhbFBwUpOHDhmjurCtVV1ff6boVlVV6q90M2VMnT9CQQQNMfbffcoMyM7ON2aCLS0r13kef6t47uw7Ancmsq6Zr7JhR2rpth1KPpqvgZKHq6upaw2v+foqJidLApP7y9DSHxdzd3bX4tps0bcokbd2+U8fSM1VWVq6GxkZ5e3kpLCxESf37adrkCd0OzF0OgoOD9G+P/Uj7Dx7W7j0p381wX6WWFqt8fLwVExWpIYMHatLEcZ3OjO8MJk0cZ5qpW2oNb7edzbkjERHhevzfH9W+A4eUnLJf2dm5qqyqUlNTszw9PRUSHKTo6Egl9eurYUMGy9/fz24b4WGh+vmSR3TwcKr2JO9TVnaOKiur1NTcLD9fHwUFBSmpX1+NGzvKbt2rrpwmPz8/bdqyXcePn1B9Q8MZZ3Dun9hX//Xkf2jbjt3af/Cw8vOPq6amVhYXF/n5+SohPlajRw7XqBHD5OLy/Zt3xt/fT488fL/S0jO0c1eyMrNyjM+5r4+PgoIC1LdPb40eNdxu3eioSD35+M+0OzlFe/cdUE5OnqpramSztd4UExcbo+FDB2v82FFydz+3gOmF4u3trX//6Y+0fuNm7dyVrKLiYrm4uCguNkZXTptiuvHqlLDQED3xHz/VytVfa/+Bw6qorJS3l5fiYqN15fSpGjp4oN5854MO9nbp6J0Qp18+/jOtWL1OBw8dUVVVtXz9fJXUP1HzZ8+UOshY+3XwGe8OZ/xsDkzqp0d//IDSMzKNz0J1dY1q6+rk5uaqwIAAxcZGG3V1FDqfPHGchg8drC3bdurI0TSdKDip2to6yWaTj6+PwsPClBAfq4ED+mtgUr8OA/D337tYa9Z+o+SU/SouKelytvsz+cE9i3UsPUMZmdnKP35ClVXVqq6ukdVqlbeXl8LDQzWgfz9NnTxBwcFBdusHBgbop488qCOpadq5e+93T2SpUGNjkzw83BUUGKioqAj1S+yrYUMGKTQk2G4bo0YMU8TPw7VqzXqlph1TXW2dAgICNHjQAM2fO1MtbWb7P5PJE8cpKDBAa9dvVHZOrpqbWxQaEqzhw4Zozszpyss/0fVG1PrUhKf+89+1Z0+K9h04pJzcfFXXVKu5uUXeXl4KDQ1WbEy0kvonaujggZ3e/NITBg1M0m9++Qvt2JWsA4eOKC8vX9U1tZJs8vPzU0R4WOsTnvrY32B4PtfanFkz1Ld3b6VnZik7J0+VlZWqqq423tfQkBD16R2viePHntfTpQAAAAAAAHD5s6Smpnb+X2kAAAAAAAAAAADO4JElj5vad95+syZNGOugai5dK1av05dfrTbaLi4u+sPvfnVBg9C4/JWUlOpXTz9r6jubJwkAAAAAAAAAcBxm9AcAAAAAAAAAALjAVqxep/r6Bo0cPlRxsdFyc2v9TzQ1NbXasWuPVq5aZxo/asRQQv4AAAAAAAAA8D1G0B8AAAAAAAAAAOACq6mu0fqNm7X26w1ycXGRr4+PrDarampq7cYGBgbo+kULHVAlAAAAAAAAAMBZEPQHAAAAAADA91pFRaXq6uu7Pd7V1VXhYaEXsCI4Ul1dnSoqq85qnfCwULm6ul6gigBcjqxWq6qqqztclhAfq3vuvE3BwUEXtygAAAAAAAAAgFMh6A8AAAAAAIDvtWVfrtT2nbu7PT4kOFhP//qJC1gRHGnvvoN6+90Pz2qd3z71uEJDQy5QRQAuF9OmTFJAgL/S0jNVXFyiquoaNTQ0yNPTU8FBgYqPi9XokcM0aGCSXFxcHF0uAAAAAAAAAMDBCPoDAAAAAAAAAIBztvS5Zx1dwiUhIiJccyJmaM6sGY4uBd8joaEhfEYBAAAAAACAS5QlNTXV5ugiAAAAAAAAAAAAAAAAAAAAAABAK579CgAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAE3FzdAEAAAAAAAAAAAAAAACXsnXrN+qTZcslSRPGjdHdi2/pcFxLS4ue+eNfdPxEgdEXEhysp3/9xHnXsHLN1/pi+SpT308feVBJ/RNNfc+98JLS0jMkSQ/84C6NHD70vPabk5unP/zpRdlsNoWFherX/+/ncnE5Pe/k/oOHlZ6RpcysbOXk5qmxsclYduftN2vShLHntf9T0jOy9OcX/i6bzWb0LZg7SwvnzzaNW75ijb5atVaSdOUVU3TzDYt6ZP8AAAAA0NOY0R8AAAAAAAAAAAAAAOAc1dbWadWa9ZIki8WiOTOndzp21Zr1ppB/TzlZWKSVq9d1a+zsWVcarz//cqVaWlrOa9+ffv6VEa6fNeMKU8hfkt546z2tWfeNjqVnmkL+Pam5uVn/ev9jU8i/M9OvmCwPDw9J0qbN21RcXHJBagIAAACA80XQHwAAAAAAAAAAAAAA4BytW79RNbW1kqTBgwYoMjKiw3EFBSe1au36Ht+/zWbTu+9/oqam5m6NHzJogKK+q/FkYZG279x9zvs+kpqmo2npkiRfHx9NHD/mjOO9vb3PeV9nsnL11yo4WditsX6+vkadzS0t+nLlmgtSEwAAAACcL4L+AAAAAAAAAAAAAAAA56C5uVmbtm432mNHj+xwnM1m078++ETNzc3y8vLs0cD7lm07lJaeIUkKDg7q1jpt69y4ads57/ubb7cYr0cMHyJ3d3e7MXNnz9CPH7xPf/jdr3XjdVef8746c/xEgdas+0bSuR1/cvI+VVfX9HhdAAAAAHC+CPoDAAAAAAAAAAAAAACcg5R9B42QuLu7m4YPHdzhuG83b1N6RpYk6dqr58vby6tH9l9RUalPP18hSeqTEK+J4848o/4po0cNN17n5uUrJzfPbsxzL7ykR5Y8rkeWPK6nfvOM3fLy8godPHTEaI8ZNaLDfc2eeaWGDB4oX1+fbtV2NqxWq/71/sdqbmmRt7e3rrt6frfW69snQUFBgZJaZ/Xfdh5PNQAAAACAC4WgPwAAAAAAAAAAAAAAwDnYd+CQ8To+LlZeXp52Y8rLK7Tsy9YwfmLfPpo2ZWKP7f+Dj5eprq5Obq6uWnz7TbJYLN1ar1d4mIICA4z2vv2HzjC6YwcOHZHVapUkubi4KLFv77PexvnauGmrMrNyJEnXL1qggAD/bq1nsVjUP7Gv0T6X4wcAAACAC42gPwAAAAAAAAAAAAAAwDk4lp5hvE6Ii+1wzPsffab6+ga5ublp8a03djuM35WUfQe1d98BSdKcWTMUFRlxVusnJMQZr9PaHEd3HUvPNF7HREfK3d39rLdxPsrKyvXF8lWSpP79+mryxHFntX5C/Onjz87JVVNTU4/WBwAAAADni6A/AAAAAAAAAAAAAADAWaqqrlZ5RaXRjuwgaL9n7z5j1v/5c2YqIiK8R/ZdV1+v9z/+7Lv99tLc2TPOehtREafrzc3LP+v1c/NPrxMZcXY3GfSE9z76TPUNDXJ3d9cd53ADRVRkL+N1c3OzThSc7OkSAQAAAOC8uDm6AAAAAAAAAAAAAAAAgEtNVVW1qe3r62Nq19bW6cNPPpckxURHafbM6T22788+/0oVFZWyWCxafOtNcnM7+/iHj4+38bqhoVGNjY3y8PAw+pY8+tAZ16+uqjFetz/2C23Xnr06cPCwJGnB3FnqFR521tvw8THXXNnu/QQAAAAAR2NGfwAAAAAAAAAAAAAAgLNUV1dvant5epraq9euV2VllVxcXLT4thvl6uraI/s9UXBSm7fukCRdMXWS+vZJOKfteHl5mdq17Y6nK7V1dae31e7YL7SPPvlCkhQXG62ZM6ad0za8vMw117U5HgAAAABwBszoDwAAAAAAAAAAAAAAcJa8vc1B+fqGBlP71AzxNptNS1/6p2lZbe3pUHlZebl+8eRvJEl/+N2vu9xvVVW1bDabJGnHzj3atWevsayxsck09qVX35Crq6tuufFajR090rSsrt4c7Pdpdzxd8fH2VnVN66z+7Y/9Qquqbj23JwuL9J+/+m+jv6WlxTRuzdcbtGHTFo0dPVK33HitaVl9u+P39vYWAAAAADgTgv4AAAAAAAAAAAAAAABnyd/fz9Sura3tcJzNZlNNTcfLurP8TNqH9durr28N4Dc1Ndsta1uvh4e7PDw8zmrffv6+RtC/ppNjv9AaG5vsbm5oq6mpSU1NTcZ5aKt9zf5+vj1eHwAAAACcD4L+AAAAAAAAAAAAAAAAZ8nfz09BgQEqr6iUJJ0oKOzR7T/1m2dUWlYmSeqf2FdLHn2oR7df0Kbe2JgYu+XPvfCS0tIzJEkhwcF6+tdPmJbHxkQb2yjo4WOXpDff+UDbd+422kufe7ZHt9+2ZldXV0VFRvbo9gEAAADgfBH0BwAAAAAAAAAAAAAAOAf9Evtq1569kqSc3DzTsrsX36K7F9/S4XptQ/wdhejPJKl/Yqeh9+Ur1uirVWuN9k8feVBJ/RM7HJuVk2u87t+vT7f3b6yT2Fe7du+VJJ04UaDm5ma5udnHUF5+9U1VVLbeDFFdXWNatnL1Om3ask2SFBcbo9tuvr5b++7s+I+mpev5pS8b7QVzZ2nh/Nkdjm17/AnxsfLwcO/WvgEAAADgYiHoDwAAAAAAAAAAAAAAcA6GDx1sBP2zc/JU39AgL09PxxbVDScLi1Tx3ZMIJGnYkMFnvY2hgwfKxcVFVqtVzS0tSs/I0oCkfnbjcvOOGzc1tFdcUqriklJJkrvbxQva22w2HTuWYbTP5fgBAAAA4EJzcXQBAAAAAAAAAAAAAAAAl6IRw4fIz89XktTU1KQDBw73yHZbWlpUU3t69vvEvr17ZLun7ElOMV7HREepT+/4s95GUFCghgweaLR3t9lmT6isqjJe9+3Tu0e3nZ6RpfLvbnRwdXXVpAlje3T7AAAAANATmNEfAAAAAAAAAAAAAADgHLi5uWnKpPFatWa9JGnn7mSNHTOyy/We/vUTZ1yelZ2rhoZGSVKv8DDNm3NVt+pZOH+2Fs6f3eW4XW1C+dOnTe5wzJJHH+pyO9OnTdL+A4ckSXv3HdDNNyySu7t5Zv6ujrUjzc3NSs/IlNR6jhffdmO31kvqn6ilzz3b5bhTT2GQpNEjh8vf3++sawQAAACAC40Z/QEAAAAAAAAAAAAAAM7RrBnT5evjI0k6eDhVBQUnz3ubR46mSZIsFosW33aTXXj+fBw8dEQFBYWSpIhe4Zo4fsw5b2vQgCQl9U+UJNXU1Grbjt09UmNmVo4aG5skSfPnzFRkRK8e2a4kVdfUaPvO1jpdXV27dWMEAAAAADgCQX8AAAAAAAAAAAAAAIBz5OPjrbmzZ0iSbDabVq/bcN7bTD2aLkmaOnmC+iX2Oe/ttbWmTX2Lrp4nV1fX89re9YsWyGKxSJLWrt8oq9V6XtuTpNSjxyRJMdFRmj1z+nlvr60NG7cYNxFMmzJR4WGhPbp9AAAAAOgpltTUVJujiwAAAAAAAAAAAAAAAAAAAAAAAK2Y0R8AAAAAAAAAAAAAAAAAAAAAACdC0B8AAAAAAAAAAAAAAAAAAAAAACdC0B8AAAAAAAAAAAAAAAAAAAAAACfi5ugCAAAAAAAAAAAAAACAc1u3fqM+WbZckjRh3BjdvfgWh9TxyJLHjdeOrKMnLF+xRl+tWmu0f/vU4woNDXFgRRfX+Rz/m+98oO07dxvtpc892+P1XQhbt+/S2+9+aLR/+siDSuqfeNH239U5Lyou0W//54+yWq0KDPDXf/3yF/Lw8Lho9QEAAAAwI+gPAAAAAAAAAAAAAAA6VVtbp1Vr1kuSLBaL5syc7uCKAOfTEzehPPWbZ1RaViZJ6p/YV0sefajH6uuO8LBQjRoxVLuT96miskrrvvlW8+fMvKg1AAAAADiNoD8AAAAAAAAAAAAAAOjUuvUbVVNbK0kaPGiAIiMjHFzR5SEyspdGjhhqtD08v18zp38fjz80JNh0zH5+vg6spmMzZ0zX7uR9kqS16zZo+tRJ8vHxcXBVAAAAwPcTQX8AAAAAAAAAAAAAANCh5uZmbdq63WiPHT3SccVcZsaMGqExo0Y4ugyH+T4ef1L/RCX1T3R0GWeUEB+r8LBQFRWXqL6hQdt3JmvG9CmOLgsAAAD4XiLoDwAAAAAAAAAAAAAAOpSy76Cqq2skSe7ubho+dHCnYw8cPKxtO3crKztX1dXVcnVxVUCAv/r26a0Z06coNibaNP74iQJ9s3Gz0o5lqLyiQjabTYEBAUrs20fTp01WQnxsjx7L0bR0Pb/0ZaN95+03Kzg4SCtWrVVObr48PNw1fOhgXXvNfPn5+qqktExfLF+lw0eOqqGxUbHRUVo4f7YGDUwybffkySJt3b5TOXn5KikpVU1NrRoaG+Xl5amIXuEaNmSwpk+bLC8vT9N6y1es0Ver1hrt3z71uEJDQ877HD2y5HHj9YRxY7To6nn68qtVOnTkqCorqzR/zkwtnD/7vM5lT+jq+FtaWrR+wyZt2bZTJaVl8vPz1YhhQ3R1N2vPzsnVhm+3Kj0jUxWVVbJYpNCQEA0bMkhXzZgmfz8/0/iOro+E+Fh9tWqtjqalq6GhURG9wjV75nSNGzPKGPfUb55RaVmZaVvbd+7W9p27TduaNGGstm7fpbff/dDo/+kjDyqpf6Kee+ElpaVnmLaRlp5hei8XzJ0lFxeLvlyxRpJksVj06yf/Q+Fhoab1Plm2XOvWb5Qkubi46He/+X8K8Pfv1jk7ZfSo4Vq1Zr0kacu2HQT9AQAAAAch6A8AAAAAAAAAAAAAADq078Ah43V8XKxdWF2SGhub9Ppb7ypl/0FTf5OaVV/UoMKiYsVER5qC/us3bNYny76U1Wo1rVNcUqriklLt2LVHV8+fo3lzrurhIzptz959OnzkqGw223fH0agt23YqKztX9951m/6y9B+qrqkxxmdm5+ivL7+mR3/0Q9Os7McyMrXm6w1226+trVNmVo4ys3K0bccu/dtPf2QXLj+TnjhHpWVlevb//qLKyqpu7/eU9z78VFXV1We1zsJ5sxUdFXnW+2rPZrPp1TfeUcq+09dUeXmFNny7RYcOpyo8POyM63/51WqtXPO18d6ecqLgpE4UnNTWHbv04wfvU3xc5zeT7D94SO998ImaW1qMvvzjJ/T6W+/J2mLVhPFjzvHozt2UyRO0cvXXam5pkc1m05atO3TtNfNNY5L37jdeDxk80Bzyt7TboKV9R6ukfolG0P/4iQIVF5corN0NBQAAAAAuPIL+AAAAAAAAAAAAAACgQ8fazDKe0Eko+t0PPjGF/C0Wi6KjIhUcHKSysnIdP1FgGr//4GF99OnnpvEJ8bFycXFVVnaOrFarbDabvvhqlcLDQjVm9IgePqpWhw6nysvTU70T4pR/okBVVa2h9uMnCvS/f16qpqYm9U6IU1NTs/KPn5AkWa1WfbVyrSnof+oYwsNC5e/vLx8fbzU3N6vgZKHKysolSYVFxfryq9W6/ZYbulVbT52jtGOt719QYICioyJVUVllH/buxMFDqXYz1Xdl+tTJZzW+M99u3mYK+bu4uKh3QrxaWlqUk5unouKSTtfdvHW7VqxeZ7R9fLyVEB+n5qZmpWdmyWq1qqqqWn//x+v65RP/Lh8f7w63k7LvoNxcXZXYt49qampUcLLQWLZ85Roj6D9k8ABVVVdrb8oBY3lIcLDi42OMdmhI8BmPt1+/PvL189Ghw6lqbGySJPn5+qpfvz7GmMjIXgrw99eoUcO1c1eyJGnbzt26esEcubq6SpIys7JN79mkCWNN+2l/o0lnN54kxMfKYrEYN0qkpWcQ9AcAAAAcgKA/AAAAAAAAAAAAAACwU1VdrfKKSqMdGRlhN+b4iQLt2LXHaHt5eerhB+5V/8S+Rt/Jk0WmmfGXr1ht2saD99+t4UMHS5KOHD2mF//2ihEw/nLF6gsW9Pfy8tTj//6YeoWHqbCoWL/53f8ay5qamnT9ogWaddV0Wa1W/d/zf1VWdq4kKSMrW83NzXJza41cDBk8UL//7S/l728OTdtsNr325rvanZwiSdq770C3g/49eY6mTBqvW2+6zgiDNzU3d6sGR1q/YZOp/dAP79HQwQMlSdt37Nab//qgw/WsVqu++Or0uUuIj9VjjzwoL8/WJ1FkZefqj88tlc1mU0VllTZu3qp5szt+IoKbq6uWPPqQ+vROkNVq1V9ffk2HjxyVJJWUlqmkpFShoSG67ebrJUmPLHncWLd/v766e/Et3T7eq+fPkSQ99ZtnVNrYGtSPiozQA/fdZTd2xhVTjKB/ZWWV9h84rJEjhkqS9iTvM8b5+/sZ5+yUkDY3HPj7+cnDw73Dery9vRUY4G98/nPzjmvShG4fDgAAAIAeQtAfAAAAAAAAAAAAAADYOTXD/Sm+vj52Yw4eOmJqz555pSnkL0kREeGKULgkqaKySrl5x41lffskGAF2SRqY1E8Dk/rpcGqapNaZ8IuLS7qcTXx3cor27N1n1+/v52cEsdsbM2qEeoWHSZJ6hYfJx8dbtbV1klpvAph+xRRJrbPJJ/btbQT9W1paVFNTq8DAAEmts+UfPJyqbdt3KSc3TxWVVWpqarLbX3V1jWpra+XjY38e2+rJc+Tr46Mbr7vGCPlLkrtb96IiT//6iW6N62ll5eUqLCo22n379DYF1ieMH6NVa9frZGGR3bo5ufmm67apqVlvtbspwNXVVc3f3exw6HBqp0H/UaOGq0/vBEmt18CgAf2NoL/U+j6FhoacwxGen4T4OPVOiDOux01bt2vkiKGy2WxKTtlvjBs/drTpfZekkOCg069DgnQmPj4+RtC/sqqqZ4oHAAAAcFYI+gMAAAAAAAAAAAAAADt1dfWm9qlZ0dsqKS0ztRP79D7jNsvKyk3tqA6eEhAVGWGE2CWptKy8y6B/QUGh9qYcsOsPCQ7uYHTH+/b08DCC/mGhoaZAvKeH+dib28yKv3zFGn21au0Z6zulrr6hy6B/T56juNhoeXp6dKs2Z1FeXmFqR0X2shsTGdmrw6B/SWmpqX38RIGOnyjodF+l7a7ftuJiok1tb28vU7vZgU9GuPKKKXr9rfckSUdS01RSWqaKigqVtTl3kyaMtVuv7Yz+Z/psSJKX1+njbf9dAAAAAODiIOgPAAAAAAAAAAAAAADstA821zc0OKiSC6NtkFmSLBYX47V3u2WdKS+v0Mo1X5v64mKjFRIcLIuLRQUFhSo4WXh6oc127gWfg4CAgHNe970PP1VVdXXXA9tYOG+2oqMiz3mfF1tjB09eOKX9DRltrw9HGz1yuD5ZtlyVlVWy2Wzasm2HGupPfz57J8R1eIOIl6enlj73bLf2UV9/Otzf/rsAAAAAwMVB0B8AAAAAAAAAAAAAANjx9/cztWtra+3GhIaYZwVPz8xS/359O91mcHCQqX2ioNBuzImCk2dcpyML58/WwvmzuxzX07Kyc2W1Wo329YsWaNZV0432ux98Yg76d0NPniOLxXJW+27r4KFUlZZ1PuN9R6ZPnXzO+zslKCjQ1O7o/BV0cE4k+1nqF86brQXzZp13TRdLd98uV1dXTZ08QV+tbH2SxNbtu9R21UkTxp13LTVtPu/+fn5nGAkAAADgQnGe240BAAAAAAAAAAAAAIDT8PfzU1Dg6RnhOwqcDxk80NRes+4bpaVnmPoKi4qVnpElSQoM8FdsTLSxLCMzS/sPHjbaR9PSdeToMaMdHhaq8LDQ8zqOC6mlpcXU9vDwMF7n5h3Xzt3JZ73Ny+0cna3goCDT8aRnZOnQ4VSjvWNXsk4WFnW4bnxcjPz8fI32hm+3KC//uN24/OMn9Mmy5UrZd7DH6nZ3dzdeV1RWXvBtTJ08UW6urq1jKypVXlFpbGPM6BEdrrN8xRo9suRx438lJaUdjqutrVNlZZXRbns9AgAAALh4mNEfAAAAAAAAAAAAAAB0qF9iX+3as1eSlJObZ7c8OipS48aMMgLt9fUNev7FlxUdFamQ4CCVV1QqL/+4brh2oRL79pbUOvv+S6+8YWzj5VffVEJcrFxcXZSVnSubzWYsWzDv4s/Sfzbi42NlsViMmj/85HMlp+yXzWpTRla2abb/s+EM5+jpXz9xQbbbHVddOU3vf/SZ0f7bP15Xn97xamlpUXaO/XV4iqurqxbOm22sW11To2f++BfFxcYoMDBADQ0NOlFwUlVV1ZKkqMiIHqs5PCxUx08USJKOpKbp/57/mwICWmfCv2fxraabQM60jVNPMCgsKtYzf/xL61MzLNINixYqNDTEGBsY4K9RI4fb3UwycsRQeXt5ndexZOear7EzPaUDAAAAwIXDjP4AAAAAAAAAAAAAAKBDw4cONl5n5+SpvqHBbswdt96goUMGGW2bzab84ye0/+Bh5eblmwLDp7Z5w7UL5eLSGlmwWq3KzM5RekaWMUO+xWLRgrmzNH7sqAtxWD0mPCxUkyeOM9pWq1VH09KVlp4hf38/TZk0/py2ezmdo3MxdfIEDWtz7VmtVqVnZCkrO1eBAf5nDJ5fMXWS5syaIYvFIqn1eszJzdP+A4d0NC3dCPlLMs5vT5gwbrSpnZGZpb0pB7Q35YCam1s6WctsfLtt5Obla+++1m3U1tXbjZ8+bbJd3+QJ4+z6ztbRtNNP5YjoFa5e4WHnvU0AAAAAZ48Z/QEAAAAAAAAAAAAAQIdGDB8iPz9fVVfXqKmpSQcOHNbYMSNNYzw8PPSjB+7V/gOHtG3nbmVn56qqukauri4KDAhQ3z4JSuqfaFpn5owrNCCpnzZ8u0VpxzJUXlEhSQrw91di3z66Yuok9ekdf7EO87zcdvP1CgsN1ZZtO1RaVi5fXx8NHpikRVfP16bN2zpdr7nFHP52dXU1tS+nc3S2XFxc9MB9d2rd+m+1dftOlZaWydfXR0OHDNLVC+bos89XnHH9a6+ep5HDh2rTlm1Kz8hSWXmFmpub5ePtrfDwUPXtk6Dhw4aoX98+PVbzVVdOk9Vq07Ydu1RSUmr3/nbH6JHDVXdrvTZ8u0WFRUVqamo+4/g+veOVEB9rPOUgLDSkR2bf37N3n/F66uQJ5709AAAAAOfGkpqaaut6GAAAAAAAAAAAAAAA+D76fPlKrVqzXpI0dPBA/ejB+xxc0eXhH6+9pb0pByS1Btv/9Ien5e7GfI3oPqvVqqd//38qLCqWJF29YI7mz5l5XtvMys7V//75RUmSl6enfvurJ+Tr63PetQIAAAA4e/wTIgAAAAAAAAAAAAAA6NSsGdO1afN21dTW6uDhVBUUnFRkZISjy7pkrd+wWcdPnNC+/YeMvr59Egj5o9s2b92uquoapR49ZoT8PTw8NHXS+c++v279RuP1rKuuIOQPAAAAOJCLowsAAAAAAAAAAAAAAADOy8fHW3Nnz5Ak2Ww2rV63wcEVXdqWr1itLdt2ymq1SpJcXV11zYK5Dq4Kl5KVq9fri+WrdDQt3ehbtHCe/P39zmu7RcUl2ruv9SkTgQH+mjnjivPaHgAAAIDzw+3gAAAAAAAAAAAAAADgjGbOuILQbw/z9PRQ74R4LZg3S/369nF0ObgEubu7KzIiXFddOU3jx44+7+2Fh4XqhT/9vgcqAwAAANATLKmpqTZHFwEAAAAAAAAAAAAAAAAAAAAAAFq5OLoAAAAAAAAAAAAAAAAAAAAAAABwGkF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACcCEF/AAAAAAAAAAAAAAAAAAAAAACciJujCwAAAAAAAAAAAAAAAJenxkaLnn8+VMuWBaiy0kUDBjRoyZISTZlS6+jSnEZNjUWvvhqilBQv7d/vpYoKV/3+9wW64YZKR5fmNPbt89RnnwVq+3Zv5ee7KyioRSNG1GvJkmL16dPk6PKcQlqah154IVQHD3qquNhNXl429evXoPvvL9NVV9U4ujwAAAAA54AZ/QEAAAAAAAAAAAAAwAXxxBMRev31YF1zTaWefLJIrq7Sgw/GaNcuL0eX5jTKyly1dGmoMjI8NGBAg6PLcUqvvBKi1av9NGlSrZ58slC33FKhXbu8dcMNCTp61MPR5TmF48fdVVPjouuvb/2s/fjHJZKkH/0oRu+/H+jg6gAAAACcC0tqaqrN0UUAAAAAAAAAAAAAAIDLy759Xrr55nj94hdFuv/+MklSQ4NFV1+doNDQFr33Xq6DK3QOjY0WVVS4KDy8Rfv3e+qmmxKY0b+dPXu8NHRovTzaZPqzstx1zTUJmju3Wn/8Y4HjinNiLS3SDTfEq6HBRStXZjm6HAAAAABniRn9AQAAAAAAAAAAAABAj1u50k+urjbdemuF0efpadNNN1UoOdlbJ064ObA65+HhYVN4eIujy3Bqo0ebQ/6S1Lt3k/r3b1RGBjP6d8bVVYqKalZVFfEgAAAA4FLEX/IAAAAAAAAAAAAAAKDHHT7sqd69G+XnZzX1Dx9ebywHzpXNJhUXuyo4mJsk2qqttai01EU5Oe56/fUgbdzoq4kTax1dFgAAAIBzwO3xAAAAAAAAAAAAAACgxxUVuXU4U/2pvsJCIgs4d59/7q+TJ9312GMlji7FqTzzTLjefz9IkuTiYtPs2dX61a8KHVsUAAAAgHPCPzUDAAAAAAAAAAAAAIAeV19vkYeHza7f09NmLAfORXq6u377214aNapO119f6ehynMo995Rp3rxqFRa6asUKf1mtUlMTnzUAAADgUuTi6AIAAAAAAAAAAAAAAMDlx8vLpsZG+4BxQ4PFWA6craIiVz30UIz8/a16/vnjcnV1dEXOJTGxSZMn1+q666r00kvHVVvroocfjpGNjxsAAABwySHoDwAAAAAAAAAAAAAAelx4eLOKiuxT2Kf6evVqvtgl4RJXVeWiBx6IUVWVq155JV8RES2OLsnpzZ1brf37vZSZ6e7oUgAAAACcJYL+AAAAAAAAAAAAAACgxw0c2KCsLA9VV5ujCSkp3pKkQYMaHFEWLlENDRY9/HC0srI89Pe/56tfv0ZHl3RJqK9vfYJGdTWPPgAAAAAuNQT9AQAAAAAAAAAAAABAj5s3r1otLRa9/36g0dfYaNEnnwRoxIg6RUUxoz+6p6VFWrIkSnv3euv5509o1Kh6R5fkdEpK7IP8TU3SsmUB8vKyKjGRG2sAAACAS42bowsAAAAAAAAAAAAAAACXnxEj6jVvXpX+9KcwlZS4KiGhSZ9+GqD8fHf97ncnHV2eU3n77SBVVrqosLA1xrF+va8KClpf33VXufz9rY4sz+GeeSZcX3/tpxkzqlVe7qJly/xNy6+9tspBlTmPX/0qQtXVLho3rlYREc0qKnLTF1/4KyPDU088UShfX5ujSwQAAABwliypqan8JQ8AAAAAAAAAAAAAAHpcQ4NFzz0Xqi++CFBFhYsGDGjUT39arGnTah1dmlO56qo+ys9373DZunUZio39fj/94K67YrVjh0+ny1NTj17EapzT8uX++uijAB096qnyclf5+lo1ZEi97ryzXDNn1ji6PAAAAADngKA/AAAAAAAAAAAAAAAAAAAAAABOxMXRBQAAAAAAAAAAAAAAAAAAAAAAgNMI+gMAAAAAAAAAAAAAAAAAAAAA4ETcHF0AAAAAADirnNw8HTpyVJlZOcrKzlF1dY2xbMK4Mbp78S1nXD8jM1ubt25XWnqmKisr5eriKj9/P8XGRGnIoIGaPHHcWdVTXV2jlP0HlJHZWs/JwiLZbDZj+dLnnj27AwQAAAAAAAAAAAAAAIBTIugPAAAAAJ1YsWqd9h04dNbrWa1WffTpF9rw7RZTf5OaVd/QoOLiEuXk5J910D89I0v/ev+Ts64HAAAAAAAAAAAAAAAAlxaC/gAAAADQDT4+3qqtrevW2E+XLTeF/N1cXRUZGaHAwABVVFTqZGHhedfj7u4myaKmpqbz3hYAAAAAAAAAAAAAAACcC0F/AAAAAOjEqJHDNXb0SPVOiJMk/erpZ7tcJys7V+s3bjbaCfFxuveu29QrPMzoa2xsUtqx9LOuJzw8VLfceK16J8QrNiZKL/z1FaWlZ5z1dgAAAAAAAAAAAAAAAODcCPoDAAAAQCfGjx1lvC4pKe3WOus3bJLNZpMkubu76/577lBoaIhpjIeHu4YMHmi37pvvfKDtO3cb7aXPmW8siI6KVHRUZLfrBwAAAAAAAAAAAAAAwKWJoD8AAAAA9BCbzaZDR1KNdmKfBNU3NOjz5StVUlImT08P9U6I05hRI+Xp6eHASgEAAAAAAAAAAAAAAODMCPoDAAAAQA8pLS1TbW2d0T5ecFK//9/njRn+JWnz1h368qvVeuAHd6lP7wRHlAkAAAAAAAAAAAAAAAAn5+LoAgAAAADgclFdU2NqV1ZWmUL+p1RUVulvL7+u8orKi1UaAAAAAAAAAAAAAAAALiHM6A8AAAAAPaS5ucWub/CgAVp8641ydXXV+x9/puS9+yVJNbW1+mbDJl23aIEx9u7Ft+juxbdctHoBAAAAAAAAAAAAAADgnJjRHwAAAAB6iJeXp13fDdcuVFBQoPz9/XTzDdealh09lnGxSgMAAAAAAAAAAAAAAMAlhKA/AAAAAPSQ0JAQWSwWU19YWKjxOjDAX56eHka7rq7uotUGAAAAAAAAAAAAAACAS4ebowsAAAAAgMuFl5enoiIjdPxEgdFXW1unwAB/SVJzc7MaG5uMZX5+vhe9RgAAAAAAAFz+bDYbk0x0wWazqb6+XpLk5eVlN4EHOEfdxXk6O97e3pwjAAAAoJsI+gMAAABADxo3ZpSWfbnCaG/fsUtzZs2QJG3dvks2m81YltQv0bTum+98oO07dxvtpc89e4GrBQAAAAAAwOWorq5Oo0aNcnQZAGAnOTlZPj4+ji4DAAAAuCQQ9AcAAACATqxYtVYHDh2RJDU3t5iWHTx0RP/75xeN9n/87CeSpOnTJuvbzdtUWlYmSVr25UrtO3BILi6uysjMMsZ7e3npimmTz6qenNx8vf/Rp0a7oKDQtLxtPfPnzNTQIYPOavsAAAAAAAAAAAAAAABwDgT9AQAAAKATRcWlysrO7XBZdU2Nqmtq7Po9PT308AP36IW/vaKqqmpJUmZWjmmMt7e3HvzBXQoM8D+reurr6zutR5JpWVW1fW0AAAAAAAD4/nnttZPy8vJ1dBlOp6KiUA8/3FeStH79SXl7c47aKy0t1IIFreeI66hzXEtdq6ur0YwZEY4uAwAAALjkEPQHAAAAgB4WEx2lp574d639eoP2HTyk0tIy2WxSSHCQhgwaoKtmTFNwUJCjywQAAAAAAMD3gJeXLwHtDtTXnz4n3t6+8vHhHLVXV3f6nHAddY5rCQAAAMCFQtAfAAAAADpx9+JbdPfiW85pXV9fH117zXxde838HttfUv9ELX3u2XOqBwAAAAAAAAAAAAAAAJcOF0cXAAAAAAAAAAAAAAAAAAAAAAAATiPoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAEyHoDwAAAAAAAAAAAAAAAAAAAACAE3FzdAEAAAAAcDbWrd+oT5YtlyRNGDdGdy++RZL03AsvKS09Q5IUEhysp3/9RLe3+dRvnlFpWZkkqX9iXy159KEervrCePOdD7R9526jvfS5Zy/avtue7wd+cJdGDh960fYNAAAAAAAAAAAAAABwuSPoDwAAAOCSUVtbp1Vr1kuSLBaL5syc7uCKLoyjael6funLRvvO22/WpAljz2obJSWl+tXTp4P/C+bO0sL5s3usxtmzrjSC/p9/uVLDhgySq6trj20fAAAAAAAAAAAAAADg+4ygPwAAAIBLxrr1G1VTWytJGjxogCIjI4xl/fr1ka+fjyTJ38/PIfVdbAnxsWpobHDIvocMGqCoyAidKDipk4VF2r5ztyZPHO+QWgAAAAAAAAAAAAAAAC43BP0BAAAAXBKam5u1aet2oz129EjT8qvnz7nIFTne9GmTNX3aZIftf+zokfriq1WSpI2bthH0BwAAAAAAAAAAAAAA6CEE/QEAAABcElL2HVR1dY0kyd3dTcOHDjYtf+6Fl5SWniFJCgkO1tO/fsK0vLqmRstXrFHK/oOqqalVWGiIJk8cpxnTp3a5b5vNpr37Dmj7jt3Kyc1TdU2tPNzdFRUVobGjR2rKpPFyczP/49XyFWv01aq1Rvu3Tz2u/BMFWrd+o3Lz8iVJfRLitejq+UqIj5UklZSU6ldPP2u3/7ff/VBvv/uhaVuhoSF6850PtH3nbqN/6XOt6z6y5HG7bXy1aq2pnp8+8qBWrF6no2npxjn7zVO/kIuLi2m9Z//vBeXk5kmSoqMi9eTjPzOWjR413Aj65+blKyc3T/FxsZ2eRwAAAAAAAAAAAAAAAHQPQX8AAAAAl4R9Bw4Zr+PjYuXl5dntdauqqvWnv/xNhUXFRl/ByUJ9smy50jOzZLVZO123sbFR/3jtbR06nGrqr2tpUUZmtjIys7V95x79+KH75Ofr2+l2ln25UruTU0x9R44eU8aLf9fj//6YIiN6dft4esqV06YYQf/SsjIdSU3T4EEDjOXFxSVGyF+SJk0Ya1q/V3iYggIDVF5RKUnat/8QQX8AAAAAAAAAAAAAAIAe4NL1EAAAAABwvGPfzdYvSQlnGSb/4ONlppC/l6enBib1U6/wMKXsO6jy8opO133n/Y9NIf/QkGANHTxQsTHRRl92Tq7eePv9M9awOzlF3t7eGpjUTwEB/kZ/Y2OTVq/9RpLk4emhkSOGql9iH9O68XGxGjliqPE/D0+PM+5r5IihpsC+JEVG9DJtw8/PV8OGDlJIcLAxZvPWHaZ19uzdZ7x2dXXVuLGj7PaVkBBnvE5r8x4BAAAAAAAAAAAAAADg3DGjPwAAAACnV1VdbcwaL0mRkRHdXresrFzJKfuNtr+fn/7jZ48oNDRENptN/3r/Y23ZtrPDdY+fKNCu3XuN9hVTJ+mWG6+VxWKRJK35eoM++/wrSdKhw6nKyMxS3z69O9xWr/AwLXn0YQUG+Ku6pka/e/bPqqyskiSlHcswanvgvrt0NC1dzy992bTf9rPpn8kD992lkpJS/erpZ42+0SOHa+H82XZjr5g2yTiG/QcPq7KqSgH+rTcitA36DxsySP5+fnbrR0VEKEUHJUm5efndrhEAAAAAAAAAAAAAAACdY0Z/AAAAAE6vqqra1Pb19en2umnpGbLZbEZ7yqTxCg0NkSRZLBZdPX9Op+sePHTE1C44WahXXn9b/3jtLf3jtbeUmppmHt9m5v/2Zs+crsDvZvL38/U1PZWgsrKys9UuuMkTxsnDw12S1NLSom3bd0mSCouKlZt33BjX2Y0GPj7exuuGhkY1NjZewGoBAAAAAAAAAAAAAAC+H5jRHwAAAIDTq6urN7W9PD27vW55eYWpHRnZy9QODAyQj4+3amvr7NYtKS0ztY+mpZ9xX6Wl5Z0ui42JMbW9vL2M180tLWfc7oXk6+ujcWNGafPWHZKkzdt2avbMK02z+QcG+GvwoAEdru/l5WVq19bVy8PD48IVDAAAAAAAAAAAAAAA8D3AjP4AAAAAnJ63tzlMXt/QcM7bsshyvuV0qrGp89nsfdvMfC9JLhbn+cex6dMmG6+Li0uUmpauPcmng/7jx42Ri0vH9dbVm2/C8Gn3XgEAAAAAAAAAAAAAAODsMaM/AAAAAKfn7+9natfW1nZ73aCgQFP7xMmTpnZFZVWHs/lLUkhwsKm95NGH1D+xb7f3fa4slh64GeEsthETHaX+/foq7ViGJOnzL1cq//gJY/mkCWM7Xbfte+Hh4c5s/gAAAAAAAAAAAAAAAD3AeaaQBAAAAIBO+Pv5KSgwwGifKCjs9rr9E/uagvObt+5QaVmZJMlms2n5itWdrjtk8ABTe9nnK1RdU2Pqa2lpUerRY3rtzXdVVl7e7brOxN3d3dSuqKw86214nOU2rpw2xXidnZNrvO7bp7cieoV3ul5Bm/ciNibmbMsEAAAAAAAAAAAAAABAB5jRHwAAAMAloV9iX+3as1eSlJOb1+31goODNHLEUCXv3S9Jqqqq1u+e/bN6x8eptKxchUXFna4bEx2lUSOHGetmZufoqd/8XvFxsfL29lZ1dbWOnyhQQ0OjJGnRwrnneHRmYWEhslgsstlskqSVq9cpPT1THp4eCg0J0Q3XLuxyG35+vvL28lJdfb0kaev2XSoqLpGPj7c8PTx09+JbTeOHDxus4OAglZWVm/onTRhzxv1ktbkpoH+/Pt05PAAAAAAAAAAAAAAAAHSBGf0BAAAAXBKGDx1svM7OyVN9Q0O3173lxmsVFhZqtOvrG3Tk6DEVFhUrqX+iAgP8O133zttv1qCBSUa7sbFJx9Iztf/AIWVm5Rghf0lycemZf8Ty8/XVkEGnnybQ1NSsQ0eOam/KAR1JTevWNiwWi8aNHWW0rVarjqala2/KAe3bf8huvIuLi66YMsnU5+HhodGjRnS6j5OFRaqoOP2kgGFDBnc6FgAAAAAAAAAAAAAAAN1H0B8AAADAJWHE8CHy8/OVJDU1NenAgcPdXjfA31//seQRTZ08UQEB/nJzdVWv8DBdvWCOHnnoB3J17fxhZ16ennrkoR/ogR/cpRHDhygoKFBubm5yc3VVUFCgBg7or2sWztWvn/wPBQcHne9hGu6581ZNmTReQYEB53wDwQ3XLtTsq6YrNDSkW9uYMmm83NxOn4vRI4fJy9Oz0/F7klOM1zHRUerTO/6c6gQAAAAAAAAAAAAAAICZJTU11eboIgAAAACgOz5fvlKr1qyXJA0dPFA/evA+B1d0eSkpKdV//e5/ZbVaJUk/e+xh9evbp9PxTz/zfyooKJQk3XHrjZoyafxFqRMAAAAAAABnVltbq1GjWp/2+O671fLy8nVwRc6nvLxQ990XIUnatq1aPj6co/ZKSgo1Y0brOeI66hzXUtdqa2s0caKfJCk5OVk+Pj4OrggAAAC4NHQ+bSUAAAAAOJlZM6Zr0+btqqmt1cHDqSooOKnIyAhHl3VJq6uv1+Yt29XQ0Khde/YaIf+E+NgzhvwPHjpihPwjeoVr4vgxF6VeAAAAAAAAAAAAAACA7wMXRxcAAAAAAN3l4+OtubNnSJJsNptWr9vg4IoufbU1tfr086/01aq1KiwqliS5ubnp1puuO+N6a9qc+0VXz5Orq+uFLBMAAAAAAAAAAAAAAOB7hRn9AQAAAFxSZs64QjNnXOHoMi5LPj7eio+L1dXz5yghPu6MY5c8+tBFqgoAAAAAAODy1Nho0fPPh2rZsgBVVrpowIAGLVlSoilTah1dWo9qamrQu+/+St9885ZqasqUkDBcd9zx3xo5crajS3NaL7/8O7344i+VmDhEn356wNHlOI3jx9P07rtP6fDhTaqqKlV4eLymTbtD1133c3l6+ji6vIuutrZar732v9q/f7sOHNihysoyPf30a7r22nuNMVarVV988abWrv1ER44kq6KiVDExfTR//m26556fy9PTy3EHAAAAAKBLBP0BAAAA4HssNDRES5971tFlAAAAAAAAfO888USEVq3y1913l6l37yZ9+mmAHnwwRm+8kauxY+sdXV6P+ctf7tXWrR/p6quXKDq6v77++nX9938v0G9/u16DB091dHlOp6AgT6+88j/y9vZ1dClOpbg4V7/4xXj5+ARq/vyfyN8/RKmpW/Xee79Wevpu/b//t8zRJV50ZWXFeuml3yoqKl4DBozQzp3f2I2pr6/VU0/dp+HDJ+rmmx9WSEgv7du3VX/966+1ffs6vfLK17JYLBe/eAAAAADdQtAfAAAAAAAAAAAAAICLaN8+Ly1fHqBf/KJI999fJkm67rpKXX11gv74x3C9916ugyvsGUeP7tCmTe/pnnv+V9dd93NJ0pVX3q2f/nSo3nzzF3rmmS0OrtD5/OlPP9fw4RNltbaorKzY0eU4jdYnQpTrf/5nk+Ljh0iS5sx5UFarVd9886aqq8vk5xfs4CovrvDwKH399QmFhUXq4MFduv32cXZj3N099OabmzVy5GSj76abHlB0dG8j7D9x4qyLWTYAAACAs+Di6AIAAAAAAAAAAAAAAPg+WbnST66uNt16a4XR5+lp0003VSg52VsnTlwec/Zt3fqRXFxcNWfOg0afh4eXZs26X6mpW1VcfHnc0NBTdu3aqDVrPtIvfvGco0txOrW1lZKkoKAIU39wcJRcXFzk5ubhiLIcysPDU2FhkWcc4+7uYQr5n3LVVddLkjIyDl+Q2gAAAAD0DIL+AAAAAAAAAAAAAABcRIcPe6p370b5+VlN/cOH1xvLLweZmcmKjk6Sj0+Aqb9///HfLd/rgKqcU0tLi5555lHdcMMPlZQ0zNHlOJ2hQ6+UJL344v3KzNyr4uJcbdr0vlat+psWLnxMXl6+ji3wElNSUiBJCgoKc3AlAAAAAM7k8pgGAAAAAAAAAAAAAACAS0RRkZvCw1vs+k/1FRZeHv8pv7T0hIKDo+z6T/WVlh6/2CU5rQ8//LtOnMjWyy+vdXQpTmn06Hm6446n9dFH/6OdOz83+m+66UktXvzfDqzs0vTaa3+Qn1+Apk6d7+hSAAAAAJzB5fFvBwAAAAAAAAAAAAAAuETU11vk4WGz6/f0tBnLLweNjXVyd7d/OoG7u5exHFJ5eYmWLv2VHnzwKYWEhDu6HKcVHt5bQ4ZcoYkTb5S/f6h2716ujz/+HwUHR2rBgp84urxLxj/+8T/atm2tnnzyrwoICHJ0OQAAAADOgKA/AAAAAAAAAAAAAAAXkZeXTY2N9mH+hgaLsfxy4OHhraamBrv+pqZ6YzmkF174pQIDQ3THHY86uhSn9e237+lvf3tQS5ceVVhYrCRp0qQbZLNZ9eabj2vq1NsVEBDq4Cqd38qV7+vFF3+p66+/X7fe+iNHlwMAAACgCy6OLgAAAAAAAAAAAAAAgO+T8PBmFRW52vWf6uvVq/lil3RBhIREqazshF3/qb6QkOiLXZLTyc5O08cfv6w77nhMhYXHlZ+fpfz8LDU01Ku5uUn5+VmqqCh1dJkOt3LlX9W37ygj5H/KuHGL1NBQq8zMZAdVdunYunWNnnzybk2btlBPPfV3R5cDAAAAoBsI+gMAAAAAAAAAAAAAcBENHNigrCwPVVeb/5N9SkrrDPeDBtnPgn8p6t17pI4fP6ra2kpT/9Gj2yVJffqMdEBVzqWwMF9Wq1XPPPOY5s/vY/xv//7tys4+qvnz++jvf/+to8t0uPLyk7JaW+z6W1qavvv/y+PmmAtl377tWrLkeg0ZMlZ//OMHcnNzc3RJAAAAALqBv9wBAAAAAAAAAAAAALiI5s2r1j//GaL33w/U/feXSZIaGy365JMAjRhRp6ioyyO0PHnyTVq27I9avfplXXfdzyVJTU0N+vrr15SUNEFhYXEOrtDx+vUbquee+9Su/4UXfqna2io9/vjzio1NdEBlziU6Okl7965Wfv5RxcQkGf3ffvuuXFxc1Lv3cAdW59wyMg7rJz9ZqOjo3nrxxS/l5eXt6JIAAAAAdBNBfwAAAAAAAAAAAAAALqIRI+o1b16V/vSnMJWUuCohoUmffhqg/Hx3/e53Jx1dXo9JSpqgyZNv1ttv/6cqKgoVFdVP69e/ocLCLD3yyKuOLs8pBAeH6aqrrrPrf/vt5ySpw2XfR9dd9x/as2eFnnxymhYs+In8/UO1a9eX2rNnhWbN+qFCQqIdXaJDvPvui6qqKldh4XFJ0jfffKGTJ/MkSbff/qhcXFz08MNzVVlZpnvv/Q9t3LjctH5cXKJGjJh00esGAAAA0D0E/QEAAAAAAAAAAAAAuMj+8IcCPfdcqD7/PEAVFS4aMKBRf/97vsaNq3N0aT3qpz99U//611PasOEtVVeXKSFhuJ588ksNGXKFo0vDJWTIkCv0+99v0fvv/5dWrvyrqqpK1KtXHy1e/Dtdf/0vHF2ew7zxxh91/Hi20V637hOtW/eJJGnhwjslSQUFuZKk5557wm79RYvuIegPAAAAODFLamqqzdFFAAAAAAAAAAAAAACAnlFbW6tRo0ZJkt59t1peXr4Orsj5lJcX6r77IiRJ27ZVy8eHc9ReSUmhZsxoPUdcR53jWupabW2NJk70kyQlJyfLx8fHwRUBAAAAlwYXRxcAAAAAAAAAAAAAAAAAAAAAAABOI+gPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATIegPAAAAAAAAAAAAAAAAAAAAAIATcXN0ATg/jY0WPf98qJYtC1BlpYsGDGjQkiUlmjKl1tGlfS/V1Fj06qshSknx0v79XqqocNXvf1+gG26odHRp30v79nnqs88CtX27t/Lz3RUU1KIRI+q1ZEmx+vRpcnR53ztpaR564YVQHTzoqeJiN3l52dSvX4Puv79MV11V4+jyIOlvfwvRc8+FqX//Bn35Zbajy/ne2b7dW3ffHdfhsvffz9HIkfUXuSJI0sGDnnrhhVDt2eOthgaL4uKa/j979x0eVZmwcfiZSe+kkgIJHQWWDgqKFBHpAqKIFHHZVVzF8u0qNsTFsqyyu1hXXBWxoYhIEQSkqXSQjggIBEgICel1Uuf7IzBkSGgacg7M774uL+e0mSd5Jwknec57dOedWRo9OtPoaC7lySdr6+uvg865/YcfDql27ZIaTARJio/30Guvheqnn3yUleWmqKgS9e+frbFjM+TjYzc6nsvZvdtL//lPmLZt85bdblGbNgV6/PFUXXttodHRrnqXch548KCnXn45XFu3+sjDw66uXfP01FMnFRJSakDyq9PFjsfOnd6aOzdQO3d6a98+L5WUWLRv336DUl+9LmY8ysqkefMCtWyZv/bu9VJWlpvq1ClW3745Gjs2Q15e/EypLhf79TF7dpAWLAjQoUOeys62KiKiVNddl68HH0xTnTr8m6s6/ZbfJRYXS7fdFqeDB730xBMnNXZsRg0mvrpd7Hic6/ykfv0iLVkSX0NpAQAAAAAAAACugKL/Fe7JJ2tr6dIAjR6doXr1ivX114G6774YzZx5TO3bUwisaRkZbnrrrVBFRxeradNCbdrka3Qkl/beeyHautVHvXvnqGnTQp086a5PP62lIUPi9MUXR9WkSZHREV3K8eMeysuzavDgbEVElKqgwKJly/z1wAMxmjw5WcOGZRkd0aWdOOGu6dND5OtbZnQUlzdqVIb+8Afnn+GxsXy/MsKaNb4aNy5azZoV6i9/SZOvr11Hj3roxAn+CV3Thg3LUqdOzhey2u3S88/XVkxMMSV/AyQlueuOO2IVEFCmkSMzFRRUpu3bvfXGG2Has8db//3vcaMjupQ9e7x09911FRVVooceSldZmfTZZ7U0cmQdffnlUTVowEWul9PFngeeOOGuESPqKCCgTI89lqr8fKs++CBY+/d76ssvj8rTs4aDX6Uudjy+/95Pc+YEqUmTQtWpU6z4eAbgcriY8SgosOippyLVunWB7rorS6Ghpdq2zVtvvBGq9et99dFHCbJYDAh/FbrYr4+ff/ZSnTrF6tEjT4GBpUpI8NCXXwZp1So/zZ9/RLVrc3FSdfktv0v85JNaSkryqIF0rudSxsPTs0wvvpjstC4ggN+pAAAAAAAAAACqFy2lK9jOnd5atCjQaeamQYOy1b9/nKZODdfnnx8zOKHriYgo1Zo1BxUeXqpdu7w0dGic0ZFc2pgxGZo6NcmpMNO3b44GDIjTu++GaOrUE8aFc0Fdu+apa1fnmftHjszUkCGxmjEjmKK/wf75zzC1amVTWVn5H7ZhnPbtC9S7d67RMVxebq5VEyZEqlu3PL3+epKsVqMTubY2bWxq08b5ApgtW7xVUGDVgAE5BqVybeV3FHPTZ58dU+PG5RcjDRuWdWpW5iBlZVkVFETRqaa89lqovL3t+vzzowoOLv+8DxyYrVtvra///CdMb7yRZHDCq9vFnge+806ICgqsmjv3qKKjyy9QatnSpnvvraOvvw7i38PV5GLHY/jwTP35z+ny9rZr8uQIiv6XycWMh4eHXbNmHVXbtmd+1t95Z5ZiYor1xhthWr/eV507c+fK6nCxXx/PP59SaV3Pnrm6/fY4zZ8fqPvuYwb56nKpv0tMSysvov/pT+l6/fWwGkrpOi5lPNzdpdtu41wEAAAAAAAAAHB5UVm6gi1Z4i83N7tTGcDLy66hQ7O0bZuPkpK4jqOmeXraFR7OrGZm0batrdKsmPXqFatx4yIdOkSJwwzc3KSoqBLl5PDjyEibN/to6dIAPf105TIHjJGba1EJE5QbauHCAKWmuuuxx9JktUr5+RaV0Vk2lW++CZTFYlf//tlGR3FJubnlP7tDQ52/WYWHl8pqtcvDw25ELJe1ZYuPOnXKd5T8pfKiWseO+Vq1yk95eUyFfTld7HngsmX+6tYtz1Hyl6TOnfNVr16Rvv3W/3JGdCkXOx5hYaXy9uZ71eV2MePh6Smnkv9pt9xSfvHrwYOcv1eX3/N7q5iY8rvDZGdzYXh1utQxmTo1TPXrF2ngQP4NfDlc6niUlp75dzEAAAAAAAAAAJcDv4W+gu3d66V69Yrk7+/cOmvZ0ubYDsCZ3S6lpropOJgLMoySn29RerpVR4966MMPa+mHH/x0/fXMzmiU0lLphRciNHRolpo2LTI6DiQ99VSk2rVrrJYtG2vUqDratYuf50ZYv95X/v6lSk5216231lObNo3Vrl0jTZoUocJCCrNGKy6Wvv02QG3a2FSnDlfFGKFjx/Kf3c88E6m9e72UlOSuxYv9NWtWkEaNypSvL+XZmlRUZJG3d+Wrkby97SouturAAX6WGC052V1pae5q0aJymbllS5v27vU2IBVgbqmp5RNYcP5unIwMq9LS3LRrl5eeeipSktSpE+fvRtm501vz5gXq6adPysIpieEKCixq166R2rVrpI4dG+rvf4/g4koAAAAAAAAAQLVjyvcr2MmT7lXOMHR6XUoKwwucbcGCACUne+jhh9OMjuKypkwJ1xdf1JIkWa123XJLrp57jpnkjfL550E6ftxdH37I14TRPDzsuvXWHN10U56Cg0t18KCn3n8/RCNG1NXnnx9Ts2aFRkd0KfHxniottegvf4nW0KFZ+utfU7Vpk48+/jhYOTlW/fvfJ4yO6NLWrPFTZqabBgxgJlOj3HRTvh55JFXTp4do5cozM5GPG5emxx7jZ0pNq1+/WNu3+6i0tPyOSZJUVFReCJTKS+YwVkpK+cCEh1e+OCk8vESZmW4qKrLI05OLZIDT3nsvWP7+pbrppjyjo7ism25qoKKi8nliatUq1bPPpuiGGyj6G8Ful154IVx9++aoTRubEhL42W6k8PBS/elPGWrWzCa73aIff/TVZ5/V0i+/eOnjj4/JneEBAAAAAAAAAFQTfuV8BbPZqi4BeHnZHdsBnHHwoIcmT45QmzYFGjyYYqBR7rknQ7175yolxU3ffhugsjKpuJjvV0bIyLDq9dfD9Je/pCskhFkyjda2rU1t2yY5lm++OU+33pqrgQPj9K9/hen99xMNTOd68vMtKiiw6q67MvXssyclSb165aqoyKIvvqilhx9OU716xQandF3ffBMgDw+7+vTJMTqKS4uJKVb79gW69dZc1apVqtWr/TR9eojCw0s1cmSm0fFcyt13Z+r552vrmWdq609/ylBZmfTf/4bo5MnyU37ODY1XWFhelL3QOTxFf6DcO++EaN06P02alKzAwMp3LEHN+N//ElVYaNGhQ55asCBQBQX8PDHK3LmB2r/fS6+/nnThnXHZ/fWvqU7L/frlqF69Yv3nP2FaujRA/fpxngIAAAAAAAAAqB4U/a9g3t52FRVV/gNbYaHFsR1AuZMn3XT//TEKCCjTa68dd8x0iprXsGGxGjYsL8cOGpSjP/4xRuPGxejLL49y6/kaNm1amIKCSjVyZIbRUXAOcXHFuvnmXC1b5u80SzMuv9P/jurf37mgMWBAjr74opa2b/em6G+QvDyLVqzw14035ik4mOKfURYtCtBzz9XW0qXxiowsn6G8V69c2e3S1Klh6tcvm/GpQcOHZ+nECXe9/36Ivv46SJLUooVNY8em6513QuXnx1gYzcurfAw4hwcubPFif02bFqqhQ7N0991ZRsdxaddfXyBJ6to1XzffnKf+/ePk62vngr4alptr1b//HaaxYzMUFVX5zjAwhzFjMvTaa6Fat86Xoj8AAAAAAAAAoNpYjQ6A3y48vEQnT1Zu/J1eFxHBH34AScrJserPf45RTo6b3nsvUbVrM3O5mdx6a6527fLW4cMeRkdxKfHxHpo9O0ijRmUqJcVdCQnl/xUWWlRcbFFCgrsyM/lnghlERpaouNiqggLGoyad/ndUaKjzv6dCQsqXs7K46sIoy5f7q6DAqgEDKM8Y6bPPgnTttYWOkv9pPXrkqaDAqr17vQ1K5roeeyxNa9ce1KefHtWCBfH66qujsp/qjXNhkvEiIsrPQU7fZaGikyfdVatWKbP5A5LWrvXVE09Eqlu3PP3978lGx0EFsbHFatasUAsXBhgdxeW8/36wiost6ts3x3HufuJE+c+T7GyrEhLcVVRkcEjI29uuWrVKlZXFuTsAAAAAAAAAoPowo/8V7JprCrVxo69yc63y9z8zQ+OOHT6SpGuvLTQqGmAahYUWjRsXrfh4T82YkaBGjfjLp9nYbOUzmObmukmihFZTkpPdVVZm0YsvRujFFyMqbb/55gYaPTpDzzxz0oB0qCghwUNeXmXy9WU25prUvHmh1q71U3Kyuxo0OPO9KSWl/J/PISFcNGaUhQsD5etbph49co2O4tJSU90VFFT566D41JdLCdccGyIoqEzt29scy+vW+SkyslgNGvBvYKPVrl2ikJAS7d5d+SKYnTu9dc01nL8DO3Z466GHotWiRaGmTUuSO7+1NB2bzVLlnUlweSUluSsry039+tWrtO2dd0L1zjuhmjfvCL8LNlhurkUZGW6cKwIAAAAAAAAAqhV/MruC9e6dqw8+CNEXXwRp7NgMSVJRkUVz5waqVasCbuUMl1daKj36aJS2b/fR228fV5s2tgsfhMsmLc1NoaHOf+wsLpbmzw+Ut3eZGjbkD9I1qXHjQr31VmKl9dOmhSkvz6pnnklR3bpceFGT0tMrFwJ++cVTK1f6q0uXPFmZFLBG9emTo3ffDdGcOUHq1KnAsX7OnCC5u9vVsWO+gelcV3q6m9av91W/fjny8WHmayPVr1+kNWt8dfiwh+rXP/PzYtGiQFmtdjVtys91oy1e7K9du7w1YcJJfoaYRK9euZo3L1BJSe6O8/X1630UH++pMWMyDE4HGOvgQU/dd1+MYmKKNX16ory9+TlvlJISKS/PqqAg5wuNd+701v79Xurfn7sq1bRRozLVs6fzRa5pae567rnaGjIkSzffnKs6dTh/rynld0KU/P2dv0+9/Xao7HaLunThXBEAAAAAAAAAUH0o+l/BWrWyqXfvHP3732FKS3NTXFyxvv46UImJHnrpJW5vbpRPPqml7GyrY8bfVav8HLfTHjUqUwEBzMhcU6ZMCdfKlf7q3j1XmZlWzZ/vfHv5227jj9M16bnnais316oOHfJVu3aJTp5018KFATp0yEtPPpkiPz+KHDUpJKRMPXvmVVo/c2awJFW5DZfXo49Gydu7TG3a2BQaWqpff/XU7NlB8vYu09/+lmp0PJfTrFmhbr89S199FaTSUos6dMjXpk2+WrIkQPffn6batZml0QiLFweopMSiAQOyjY7i8saOzdAPP/hpxIi6GjEiU7VqlWr1an/98IOf7rgji6+RGrZ5s4/eeitEN9yQr1q1SrVjh4/mzg1Uly55Gj2aAnlNuJjzwHHj0rVkSYBGj66j0aMzlZ9v0fvvh6hJk0Ldfjvf16rTxYxHYqK75s8PlCTt3u0lSXr77RBJUnR0sQYN4nyxulxoPCwWu8aOjVF2tlVjx2Zr9Wo/p+NjY4u5cL8aXWg87HapW7cG6tMnR40bF8rHx679+700d26gAgLK9Je/pBkZ/6p0oTFp3rxQzZs7X0SZkFC+vVGjIs7fq9mFxiMry6rBg+PUr1+O465Ja9b46vvvyy/Sv/lm7jwGAAAAAAAAAKg+ln379tGsvIIVFlo0bVqoFi4MVFaWVU2bFumRR1KZOchAPXrUV2KiR5XbVqw4pDp1uNNCTRk1qo42bfI95/Z9+/bXYBosWhSgOXMCtX+/lzIz3eTnV6bmzW0aOTJTN9/MH6XNYtSoOsrIcNM33xwxOorL+eijWlq4MEBHj3oqN9eq4OBSdeqUr4ceSlNcHLMzGqG4WJo+PURz5wYpJcVd0dHFuvvuTI0Zk2l0NJc1bFhdHTvmoR9/PCQ3N6PTYOdOb73xRqj27i3/2R4TU6zBg7P1pz+ly51LymvU0aMe+vvfI7Rnj5fy8qyqU6d8LMaMyZCnp9HpXMPFngceOOCpKVPC9dNPPvLwsKtr1zw9+eRJhYVxcUx1upjx2LjRR6NH161yn44d8/XxxwmXM6JLudB4SNLNNzc45/GDB2dpyhQmtKguFxqPiIgSvfpquDZu9FViorsKC62KiChRp075euCBNH6vdRn8lt8lJiS46+abG+iJJ0467vSK6nGh8QgMLNMLL0Roxw5vpaS4q7RUiosr1oAB2frjHzPkUfWhAAAYIj8/X23atJEkzZqVK29vvwsc4XoyM1N07721JUkbNuTK15fP0dnS0lLUvXv554j30bnxXrqw/Pw8XX+9vyRp27Zt8vU999/xAQAAAJxB0R8AAAAAAAAAAAAAgKtIXl6e2rZtK0l6551D8vKieHy2rKwUPfroHyRJixYdlK+vv8GJzCc9PUW3317+Ofrvfw/K25vPUVV4L11YQUGe+vYtv9B/69at8vPjexIAAABwMSj6AwAAAAAAAAAAAABwFUlLS1Pnzp2NjgEAlaxbt06hoaFGxwAAAACuCFajAwAAAAAAAAAAAAAAAAAAAAAAgDPcjQ4AAAAAAAAAAAAAAACqj7e3t+PxjOQZ8vbzPs/erikrJUvjGoyTJK1KXiUfPx+DE5lPekq6+jboK4n30fnwXrqwgrwCda/dXZLz9ycAAAAA50fRHwAAAAAAAAAAAACAq4jFYnE89vbzpqBdBZufzfHYx89Hvn6+BqYxpwK/Asdj3kfnxnvp0lT8/gQAAADg/KxGBwAAAAAAAAAAAAAAAAAAAAAAAGdQ9AcAAAAAAAAAAAAAAAAAAAAAwEQo+gMAAAAAAAAAAAAAAAAAAAAAYCIU/QEAAAAAAAAAAAAAAAAAAAAAMBGK/gAAAAAAAAAAAAAAAAAAAAAAmAhFfwAAAAAAAAAAAAAAAAAAAAAATISiPwAAAAAAAAAAAAAAAAAAAAAAJkLRHwAAAAAAAAAAAAAAAAAAAAAAE6HoDwAAAAAAAAAAAAAAAAAAAACAiVD0BwAAAAAAAAAAAAAAAAAAAADARCj6AwAAAAAAAAAAAAAAAAAAAABgIhT9AQAAAAAAAAAAAAAAAAAAAAAwEYr+AAAAAAAAAAAAAAAAAAAAAACYCEV/AAAAAAAAAAAAAAAAAAAAAABMhKI/AAAAAAAAAAAAAAAAAAAAAAAmQtEfAAAAAAAAAAAAAAAAAAAAAAAToegPAAAAAAAAAAAAAAAAAAAAAICJUPQHAAAAAAAAAAAAAAAAAAAAAMBE3I0OYCS73a6CggKjY+AUu90um80mSfL29pbFYjE4ERgTc2E8zIXxMB/GxFwYD3NhPMyHMTEXxsNcGA9zYTzMhzExF8bDXBgP82FMzMvHx4fxAAAAAAAAAACTc+mif0FBgdq0aWN0DAAAAAAAAAAAgBqzbds2+fr6Gh0DAAAAAAAAAHAeVqMDAAAAAAAAAAAAAAAAAAAAAACAM1x6Rv+KZsxIlre3n9ExXFpWVorGjWsgSZqRPEPeft4GJ0JWSpbGNRgnSUpOniE/xsRQKSlZanB6PGbMkJ8342GklKwsNRhXPh6rViXLx4efIUZLT09R377lP0dWJa+Sj5+PwYlcW3pKuvo26CtJSk5eJT/Gw1ApKelqcHo8Vq2Snw/jYbSU9HQ16Fs+JpyLGI9zEXPhPMRcOA8xH85FzIXzEHPhPMR8OBcxl7yCAtXu3t3oGAAAAAAAAACAi0TR/xRvbz/KNQaz2c58/r39vCnXmIDNz+Z47OfnTcHGYH4Vx8Pbm4KNwfxsZ8bDx8dPvr78DDFaQcGZMfDx85GvH7efN1KBX4HjsZ+fj/wYD0P5VRwPHx/5+TIeRvMrODMmnIsYj3MRc+E8xFw4DzEfzkXMhfMQc+E8xHw4FwEAAAAAAAAA4LezGh0AAAAAAAAAAAAAAAAAAAAAAACcQdEfAAAAAAAAAAAAAAAAAAAAAAAToegPAAAAAAAAAAAAAAAAAAAAAICJuBsdAAAAAAAAAAAAAAAAV5KXZ9H774doxw5v7drlrawsN/3jHyc0ZEi20dGqXUFugea9Ok8HNh7QgU0HlJuRq/EzxqvHmB5GRzONzas3a2z3sVVu+3j9x2p1fasaTmROB386qE+f+VS/rPtFdrtdTTs11T2v3KP6resbHc0Q+bn5mvHqDO3auEu7N+1Wdka2Xpjxgm4bc5vTfnP+N0eLPlmkw78cVk5mjsKjw9WhWweNmzROMfViDEoPAAAA4GJQ9AcAAAAAAAAAAAAAoAZlZLjprbdCFR1drKZNC7Vpk6/RkS6bnNQczZ48W+Gx4arXqp52r95tdCTTuvvhu9WiQwundbGNYg1KYy4Htx7U0zc+rdC6oRo2aZjKysq05O0lerbrs3pl0yuKaep6hfWM1AxNnzxdUbFRatqqqTav3lzlfr9s+0Ux9WPUbWA3BQYHKvFwor7631f64Zsf9OWOLxURHVHDyQEAAABcLIr+AAAAAAAAAAAAAADUoIiIUq1Zc1Dh4aXatctLQ4fGGR3psgmOCtYHSR8oODJYv275VY93eNzoSKbVtktb9Rray+gYpjRr4ix5+nhqyvopCgwNlCR1HdlVDzZ5UJ88/YkmfDXB4IQ1LzwqXCuTViosMkx7tuzR8A7Dq9zv2befrbSux6Aeuqv9XVr40UKNfbLqu0kAAAAAMJ7V6AAAAAAAAAAAAAAAALgST0+7wsNLjY5RIzy8PBQcGWx0jCtGXk6eSkpKjI5hOj//+LNa9mzpKPlLUkhUiJp3ba4t32xRQW6BgemM4enlqbDIsN90bHS9aElSTmZOdUYCAAAAUM0o+gMAAAAAAAAAAAAAABjsuXufU6fATurg3UFju4/Vni17jI5kGsWFxfL08ay03svXSyVFJTq6+6gBqa4smWmZSktJ054tezTx3omSpOtuvs7gVAAAAADOx93oAAAAAAAAAAAAAAAAAK7Kw9NDPW/vqS59u6hWWC0d+vmQZk6dqTFdxuijdR/p2jbXGh3RcDFNY7R/w36VlpbKzc1NklRcVKwDGw9IktIT042Md0XoGdNTRYVFkqRaobX05OtPqtMtnQxOBQAAAOB8KPoDAAAAAAAAAAAAAAAYpHXn1mrdubVjufvA7rpl6C0a2nKoXnvqNb2z5B3jwplE77/01vQHpuutsW9p8BODVVZWpjkvzlFGUoYkqbCg0OCE5vf2t2+r0Faow3sP65tPvlFBXoHRkQAAAABcAEV/AAAAAAAAAAAAAAAAE4ltFKtut3XTirkrnGaxd1W9x/VW6rFUzX91vlbNXCVJatS+kQY9MUhzXpojH38fgxOaX8fuHSVJXfp0UffbumtIiyHy9ffV8IeGG5wMAAAAwLlYjQ4AAAAAAAAAAAAAAAAAZ5F1I1VcVMzM66eMfGmkZiTP0Es/vqRpO6fp1c2vyl5mlyRFN4k2ON2VpW7DurqmzTVa9Okio6MAAAAAOA9m9AcAAAAAAAAAAAAAADCZhEMJ8vL2kq+/r9FRTMM/2F/NbmzmWN6xfIdC64Qq5poYA1NdmQoLClVUWGR0DAAAAADnwYz+AAAAAAAAAAAAAAAABkk/mV5p3b4d+7R6wWp16tVJVivVjqqs+WKNft38qwY8OoDP0TmUlJQoOyO70vpdm3bpwK4Data+WRVHAQAAADALZvQHAAAAAAAAAAAAAKCGffJJLWVnW5WSUv5n+1Wr/HTiRPnjUaMyFRBQZmS8arX4zcXKy8xT+vHyQvvmhZuVlpAmSeo7vq/8gvyMjGe4x4c9Lm8fb7Xq3EohESE69PMhzXl3jnx8ffTolEeNjmcKe37Yo9mTZ6t1r9YKCA3Qvg37tHLGSrXp3Ub9H+lvdDzDzHpzlnIyc5RyPEWStHrhaiUnJEuSho8fLrvdrlvq3qLew3qrYfOG8vHz0YFdBzRvxjz5B/nr/on3G5geAAAAwIVQ9AcAAAAAAAAAAAAAoIZ98EGwEhM9HMvLlgVo2bIASdLAgdlXVdF/3tR5OnnkpGN5w9wN2jB3gySp68iuLl/07zGohxZ9ukgf//tj5WXnKTg8WD2H9NS4SeMU2yjW6HimEBITIqubVfNenaeCnAJF1I/Q3S/erYH/N1Bu7m5GxzPMzKkzdfzIccfyirkrtGLuCklSv5H9FBEdoSF/GqLNqzbruznfyVZgU0R0hPoM76P7nr1PMfVijIoOAAAA4CJQ9AcAAAAAAAAAAAAAoIatXHnY6Ag15t34d42OYGojHh6hEQ+PMDqGqUU1jNKkpZOMjmE6S+KXXHCfCdMm1EASAAAAAJeD1egAAAAAAAAAAAAAAAAAAAAAAADgDIr+AAAAAAAAAAAAAAAAAAAAAACYCEV/AAAAAAAAAAAAAAAAAAAAAABMhKI/AAAAAAAAAAAAAAAAAAAAAAAmQtEfAAAAAAAAAAAAAAAAAAAAAAAToegPAAAAAAAAAAAAAAAAAAAAAICJUPQHAAAAAAAAAAAAAAAAAAAAAMBEKPoDAAAAAAAAAAAAAAAAAAAAAGAiFP0BAAAAAAAAAAAAAAAAAAAAADARiv4AAAAAAAAAAAAAAAAAAAAAAJgIRX8AAAAAAAAAAAAAAAAAAAAAAEyEoj8AAAAAAAAAAAAAAAAAAAAAACZC0R8AAAAAAAAAAAAAAAAAAAAAABOh6A8AAAAAAAAAAAAAAAAAAAAAgIlQ9AcAAAAAAAAAAAAAAAAAAAAAwEQo+gMAAAAAAAAAAAAAAAAAAAAAYCIU/QEAAAAAAAAAAAAAAAAAAAAAMBGK/gAAAAAAAAAAAAAAAAAAAAAAmAhFfwAAAAAAAAAAAAAAAAAAAAAATISiPwAAAAAAAAAAAAAAAAAAAAAAJkLRHwAAAAAAAAAAAAAAAAAAAAAAE6HoDwAAAAAAAAAAAAAAAAAAAACAiRhe9C8qsujVV8N0440N1LJlI91xR12tXetrdKwrRnFxoT76aIL++MdoDRvmoyeeuE7bt39ndCyXVZBboFmTZmly78kaFTJKgy2DtfLDlUbHclmbNx/QQw+9q+bNH5af312Kjf2z7rzzVe3fn2h0NJe05+hR3fHKK2owbpx8hw1T2OjRuumZZ7Rw82ajo+GUd999SS1bWjR4cAujo7ikzas3q6WlZZX/7diww+h4Lmvr1p81cOB4hYTcKF/fjmrRYrBef/1To2O5nDHPPitLy5bn/C8xOdnoiC7p+PED+te/7tKf/lRHw4b56qGHrtEXX0xWYWG+0dFc0sGfDmpy78m6O/BuDQ8Yrud7Pa/D2w8bHcsl5OYWaNKkWerde7JCQkbJYhmsD89xHrh37zH17j1Z/v7DFRIySqNGTdPJk1k1nPjqlltQoEmzZqn35MkKGTVKlsGD9eHKyuOxaf9+/WX6dLX761/lMXSoLIMHG5D26pefn6u33pqkceN668YbQ9SypUXz53/otE9ZWZnmz/9Q48cP1C231FXHjn4aPLiF3n33RRUW2owJfpXKz83XW5Pe0rje43RjyI1qaWmp+R/Or7TfnP/N0b1d71W32t3UzqudetfvrYn3TlRiPL9PqW65ufmaNOkt9e49TiEhN8piaakPqxiTioqLi9Ws2SBZLC01deqHNRPUReTm52vSW2+p97hxCrnxRllattSH8yuPx7nOT64ZONCA1AAAAAAAAACAq5m70QGefLK2li4N0OjRGapXr1hffx2o++6L0cyZx9S+PX/Mu5DXXx+j9evnqH//RxUd3VgrV36oF1/sq8mTV6lZsxuNjudyclJzNHvybIXHhqteq3ravXq30ZFc2j//+bXWrv1Fd9zRWS1bxunEiUy9+eZitW37N23YMEUtWsQZHdGlHDl5Ujk2m+7p3l3RwcHKLyzUVxs2aODLL2v6Aw/ovl69jI7o0k6cSNB7770sHx8/o6O4vLsfvlstOjhfbBHbKNagNK5t2bJ1GjBgvNq0uUYTJ94vf38fHTyYoIQESuU17f477lDP6693Wme32zXuhRdULyZGMbVrG5TMdaWmHtMTT3SUr2+Q+vR5SAEBIdq3b70+/3ySDh78SU8/ff6CGqrXwa0H9fSNTyu0bqiGTRqmsrIyLXl7iZ7t+qxe2fSKYprGGB3xqpaamqPJk2crNjZcrVrV0+pznAcmJKTqppueVVCQr15+eYRyc22aOnW+du06ok2bXpGnp0cNJ786pebkaPLs2YoND1erevW0enfV47F461a9t3y5WsbFqUHt2tp//HgNJ3UNGRmpmj59sqKiYtW0aStt3ry60j42W74mTrxXLVterzvuGKeQkAjt3Lleb789SRs3rtB7762UxWKp+fBXoYzUDE2fPF1RsVFq2qqpNq+u+sL7X7b9opj6Meo2sJsCgwOVeDhRX/3vK/3wzQ/6cseXioiOqOHkV6/U1AxNnjxdsbFRatWqqVafY0wqeuONWTp6NKkG0rme1IwMTZ4+XbFRUWrVtKlWn2dyCi9PT733/PNO64L8/S9zQgAAAAAAAACAqzG06L9zp7cWLQrUE0+c1NixGZKkQYOy1b9/nKZODdfnnx8zMp7p7d+/SWvWfK577nlVgwb9TZLUrdtoPfJIC3300ROaMmWdwQldT3BUsD5I+kDBkcH6dcuverzD40ZHcmn/938D9dlnjzkVZoYNu0F/+MOjmjJlrj755DED07mevu3aqW+7dk7rHurbV+3+9jf9e8ECiv4G+/e//6aWLa9XWVmpMjJSjY7j0tp2aateQ/l6MFp2dq5Gj35G/frdpDlz/iWr1fAbYbm0Tq1aqVOrVk7r1mzdqnybTSP69jUolWtbvfpj5eVl6uWX1yg2trkkqVev+1RWVqbVqz9Sbm6G/P2DDU7pOmZNnCVPH09NWT9FgaGBkqSuI7vqwSYP6pOnP9GEryYYnPDqFhUVrKSkDxQZGawtW35Vh3OcB7788lfKy7Ppp5+mKjY2XJLUsWNj3XLL8/rww1W67z5+/leHqOBgJX3wgSKDg7Xl11/V4fGqx+OB3r01YfBg+Xh56aF336Xof5mEh0dp5cokhYVFas+eLRo+vEOlfTw8PPXRR2vVunVnx7qhQ/+s6Oh6jrL/9df3rMnYV63wqHCtTFqpsMgw7dmyR8M7DK9yv2fffrbSuh6Deuiu9ndp4UcLNfbJsZc7qsuIigpXUtJKRUaGacuWPepwjjE5LSUlTZMnT9eECX/Uc8+9VUMpXUdUeLiSVq5UZFiYtuzZow7Dzz0e7m5uGtm/fw2mAwAAAAAAAAC4IkMbS0uW+MvNza5hw87cpt7Ly66hQ7O0bZuPkpIMv+GAqa1fP0dWq5t69brPsc7T01s9e47Vvn3rlZrKhRI1zcPLQ8GRFJrMonPnayrNitm4cbSaN6+rvXsTDEqFitzc3FQ3LEyZeXlGR3FpW7b8oO++m6MnnphmdBSckpeTp5KSEqNjuLTPPlus5OQ0vfTSeFmtVuXl5ausrMzoWKjgs8WLZbFYdDdFf0Pk52dLkmrVcr6bQnBwlKxWq9zdPY2I5bJ+/vFntezZ0lHyl6SQqBA179pcW77ZooLcAgPTXf28vDwUeRHngV99tV79+7d3lPwlqWfPVmrSJFqzZ6+9nBFdipeHhyKDLzwetWvVko+XVw0kcm2enl4KC4s87z4eHp5OJf/TevQYLEk6dGjvZcnmijy9PBUWGfabjo2uFy1JysnMqc5ILs/Ly1ORlzAmTz75mpo2jdPIkf0uYyrX5eXpqciwix+P0tJSZefmXsZEAAAAAAAAAABXZ2jRf+9eL9WrVyR/f+fSVMuWNsd2nNvhw9sUHd1Evr6BTusbN+54avt2A1IB5ma325WcnKWwsMAL74zLIs9mU2p2tg4mJek/Cxbo261bdXPLlkbHclmlpaWaMmW8hgz5k5o0+YPRcSDpuXufU6fATurg3UFju4/Vni17jI7kkpYv36DAQH8lJqaoadMB8ve/XoGBnfTAAy/IZis0Op7LKy4u1uxly9S5dWvVi4kxOo5LatGimyTpzTfH6vDh7UpNPaY1a77Q0qX/Vb9+D8vb28/YgC6muLBYnj6VL67w8vVSSVGJju4+akAqVJSYmKaUlCy1b9+o0raOHRtr27ZDBqQCzC0t7YQkqVat31ZMx++XmZaptJQ07dmyRxPvnShJuu7m6wxO5bo2bdqlmTMXaNq0CbJYLEbHcXn5NpsCO3VSUOfOCrnxRj340kvKzc83OhYAAAAAAAAA4Cpj6JT5J0+6Kzy8tNL60+tSUpjR/3zS05MUHBxVaf3pdenp3HYeONunn36vxMQ0TZ58l9FRXNZfZ8zQ9GXLJElWq1VDrrtOb/75zwancl1ffvmOkpKO6N13lxsdxeV5eHqo5+091aVvF9UKq6VDPx/SzKkzNabLGH207iNd2+ZaoyO6lAMHjqqkpES33fawxo4don/84xGtXr1Fb7zxmTIzczRr1itGR3RpS9etU1pmpkYwm79h2rbtrbvvfkFz5ryszZsXONYPHfqMRox40cBkrimmaYz2b9iv0tJSubm5SZKKi4p1YOMBSVJ6YrqR8SApKSlDkhQVVXmm+aioYKWn56qwsFheXh6VtgOuasaMV+TvH6gbb+xjdBSX1TOmp4oKiyRJtUJr6cnXn1SnWzoZnMo12e12jR//Dw0bdqs6dWql+PhEoyO5tKjwcD1x771qe+21Kisr05K1a/X2F19ox/79Wv3++3J35+8aAAAAAAAAAIDqYehvnG02izw97ZXWe3nZHdtxbkVFBfLwqHzXAw8Pb8d2AGf88kuCHnzwf+rUqanuuae70XFc1qMDBmho5846np6u2WvXqrSsTEUlJUbHckmZmWl6663ndN99ExUSEm50HJfXunNrte7c2rHcfWB33TL0Fg1tOVSvPfWa3lnyjnHhXFBubr7y820aN+4Ovf76k5KkIUN6qqioWNOnf6nJkx9U48ZxBqd0XZ8tXiwPd3fdeeutRkdxaeHh9dS8+U26/vrbFRAQqp9+WqSvvnpZwcGR6tv3IaPjuZTef+mt6Q9M11tj39LgJwarrKxMc16co4xT5fLCAu5EYrSCgvKibFVFfm9vD8c+FP2Bcv/738vasGG5nnnmbQUG1jI6jst6+9u3VWgr1OG9h/XNJ9+oII/fNRrlww/na9euXzVnzr+NjgJJ/3jkEaflu/r0UZO4OD3zxhua8913uqsPFygBAMzBbj/zd/islCzZ/GwGpjGnrJQsx+O05DQV+PNv3rOlp5yZQCIzOVPe/t4GpjEv3ksXVvGcsuL3JwAAAADnZ2jR39vbrqKiymX+wkKLYzvOzdPTR8XFlQsbxcU2x3YA5U6cyFC/fi8qKMhXc+Y84ZjpFDXvmjp1dE2dOpKk0d27q9fzz2vASy9p4yuvcOv5GvbGG88qKChEd9893ugoOIfYRrHqdls3rZi7wmmWZlx+Pj7lF1MOH+5c0Lj77j6aPv1LrV+/g6K/QXLz8zV/1Srd2rmzQmvVMjqOy/rxx8/13//ep7fe2q+wsPKf6506DZHdXqaPPpqgG28crsDAUINTuo7e43or9Viq5r86X6tmrpIkNWrfSIOeGKQ5L82Rjz/nhkbz8fGUJBUWFlfaZrMVO+0DuLolS77Qm28+q8GDx2rYsAeMjuPSOnbvKEnq0qeLut/WXUNaDJGvv6+GPzTc4GSuJTs7V0899Zoef/we1a0baXQcnMNjo0Zp4ltvafmGDRT9AQCmYbOdKfaPazDOwCRXhn4N+xkdwfQeaMg52sXgvXRhNptNfn5+RscAAAAArghWI188PLxEJ09WLqydXhcRwQzP5xMSEqWMjKRK60+vCwmJrulIgCllZeWpT58XlJmZpyVLnlN0dIjRkVDB0M6dtfnXX7X/+HGjo7iUI0cO6Kuv3tXddz+slJTjSkyMV2JivAoLbSopKVZiYryystIv/ES47CLrRqq4qJjZM2tYdHSEJKl2beeickRE+XJGRnaNZ0K5eStXKt9m04h+/LHESEuWvK0GDdo4Sv6ndegwUIWF+Tp8eJtByVzXyJdGakbyDL3040uatnOaXt38quxl5RfPRzfh3NBoUVHBkqSkU3dZqCgpKUMhIf7M5g9IWr/+Oz3zzGh16dJPEydyRyszqduwrq5pc40WfbrI6CguZ+rUmSoqKtawYb0VH5+o+PhEJSQkSyo/L4mPT1RRUeULyVCzfLy9FRoUpPRszhUBAAAAAAAAANXH0Bn9r7mmUBs3+io31yp//zLH+h07ymcbvPbayrPV44x69Vpr165Vys/Plq9voGP9/v0bJUn167c2KBlgHjZbkQYMeFn79x/X8uXPq1mzukZHwlkKCsu/12fl5RmcxLWkpCSqrKxMU6Y8rClTHq60vU+f+hox4hFNmDCt5sPBScKhBHl5e8nX39foKC6lXbtm+u679UpMTFHTpvUd648fT5EkhYcHGxXN5X26aJH8fX01sFs3o6O4tMzMZPn7V/46KC0tPvV/Lto2gn+wv5rd2MyxvGP5DoXWCVXMNTEGpoIkxcSEKjw8UFu2/Fpp26ZNB9S6df0qjgJcy86dG/Xoo4PVvHl7TZ06W+7uhv7aElUoLChUUWGR0TFcztGjScrIyFbz5oMrbXv55ff08svvadu22Wrd+hoD0uG0nLw8pWZmKjyYc0UAgHl4e3s7Hicnz5Cfn/d59nZNKSlZanDqbgfJyavk58ddEc+WkpKuBg36SuJ9dD68ly4sL69AtWt3l+T8/QkAAADA+Rn6F7PevXP1wQch+uKLII0dWz6rXVGRRXPnBqpVqwJFRVEOOZ/OnYdq/vypWrbsXQ0a9DdJUnFxoVaunKEmTa5TWBiFZri20tJSDRs2VevX79P8+U+pUyf+4GmklMxMRdSq5bSuuKREH61eLR9PTzWry/esmtSoUQtNm/Z1pfVvvPGs8vNzNGHCa6pTp6EByVxX+sl0hYQ733Fk3459Wr1gtW7sc6OsVkNvxORy7ryzl6ZMeV/vv/+1evS4zrH+vffmyt3dXd26dTAwnes6mZ6u5Rs3anjv3vL14Q8lRoqObqLt25cpMXG/YmKaONb/+OMsWa1W1avX0sB0kKQ1X6zRr5t/1ZipY/gZYhK3395JM2eu0rFjqapbN0yStGLFTu3ff1yPPTbA4HSAsQ4d2quHHuqn6Oh6evPNb+Ttzc95o5SUlCg/J1+BwYFO63dt2qUDuw6oz919DErmuh5++G4NGtTDaV1KSrruv3+yxoy5Tbfd1l3163NRX02xFRaquKREAX5+TutfmD5ddrtdvW+4waBkAABUZrFYHI/9/LwpaFfBz89W4bGP/PyYcOdsfn4FFR7zPjoX3kuXpuL3JwAAAADnZ2jRv1Urm3r3ztG//x2mtDQ3xcUV6+uvA5WY6KGXXko2MtoVoUmT69S58x365JOnlJWVoqioRlq1aqZSUuL14IPvGx3PZS1+c7HyMvOUfjxdkrR54WalJaRJkvqO7yu/IL/zHY5q9Ne/fqgFCzZrwIAOSk/P0SefrHbaPnJkN0Nyuar733lH2fn5uql5c8WEhOhEZqY+/f57/ZKYqH+NGSN/Cps1Kjg4TD16DKq0/pNPpklSldtweT0+7HF5+3irVedWCokI0aGfD2nOu3Pk4+ujR6c8anQ8l9OmzbX64x8H64MPvlZJSam6dm2n1au36Msvl+mpp8YqOjrC6Igu6YulS1VSUqIR/foZHcXlDRr0uLZu/VbPPNNFffs+pICAUG3Z8o22bv1WPXv+SSEh0UZHdCl7ftij2ZNnq3Wv1goIDdC+Dfu0csZKtendRv0f6W90PJfw5puLlZmZp+OnzgMXLtyshFPngePH91VQkJ+efnqovvxynbp3n6hHHumv3FybXn11nv7whzjde+/NRsa/6ry5eLEy8/J0PP3UeGzerIS0U+PRt6+C/Px0JCVFH3//vSRpy8GDkqQXv/xSkhQXHq5R3Dmm2sya9aZycjKVknJckrR69UIlJydIkoYPHy+r1apx425VdnaGxox5XD/8sMjp+Lp1G6pVq041nvtqNevNWcrJzFHKqTtVrV64WskJ5b+HHT5+uOx2u26pe4t6D+uths0bysfPRwd2HdC8GfPkH+Sv+yfeb2D6q9Obb85SZmaO4+5hCxeuVsKpMRk/frjatm2mtm2bOR0TH58oSWrevGGliwDw+7w5a5Yyc3J0POXUeKxerYTkU+MxfLgysrPV5s47NbxPH11Tv/yOPEvXrdPiH39U7xtu0G3duxuWHQAAAAAAAABw9TH8HtivvHJC06aFasGCQGVlWdW0aZHeeSdRHToUXPhg6JFHPtJnn03U999/rNzcDMXFtdQzz3yj5s1vMjqay5o3dZ5OHjnpWN4wd4M2zN0gSeo6sitF/xq0ffthSeUlm4ULN1faTtG/Zg274Qa9v2KF/rtkidJychTg46N2DRvqn6NHa2DHjkbHAwzXY1APLfp0kT7+98fKy85TcHiweg7pqXGTxim2UazR8VzSO+88q9jYSM2YMV9ff71CcXHR+s9/Htejj44yOprL+nTRIkWEhKjn9dcbHcXlNW9+k/7xj3X64ovntWTJ28rJSVNERH2NGPGSBg9+wuh4LickJkRWN6vmvTpPBTkFiqgfobtfvFsD/2+g3NzdjI7nEqZOnacjFc4D587doLmnzgNHjuyqoCA/1a0bpu+/f1H/938z9OSTH8vT0139+rXTv/51r7y8PIyKflWaOm+ejpysMB4bNmjuhlPj0bWrgvz8dDglRRM/+8zpuNPLXZs3p+hfjWbOnKrjx484llesmKsVK+ZKkvr1GylJOnHimCRp2rQnKx0/cOA9FP2r0cypM3X8yHHH8oq5K7Ri7gpJUr+R/RQRHaEhfxqizas267s538lWYFNEdIT6DO+j+569TzH1mDm+uk2dOlNHKozJ3LkrNPfUmIwc2U9BQQFGRXNJU2fO1JHjFcZjxQrNXXFqPPr1U62AAPXv2lXfbdigmQsWqLSsTI3q1tXLDz+sv91zD3dSAgAAAAAAAABUK8OL/l5edk2YkKoJE1KNjnJF8vT01pgxr2rMmFeNjoJT3o1/1+gIOGX16heNjoAK7urSRXd16WJ0DFzABx+sNjqCyxrx8AiNeHiE0TFQgYeHhyZNekCTJj1gdBScsv6TT4yOgAqaNOmoiRMXGx0DkqIaRmnS0klGx3Bp8Rd5Hti8eayWMlaXXfy7Fx6Pbi1ayP711zWQBkuWxF9wn5077Zc/CCRJS+KXXHCfCdMm1EASnBZ/EWNytnr1YmS377wMaRC/5MLj8fHLL9dAEgAAAAAAAAAAJKaXAQAAAAAAAAAAAAAAAAAAAADARCj6AwAAAAAAAAAAAAAAAAAAAABgIhT9AQAAAAAAAAAAAAAAAAAAAAAwEYr+AAAAAAAAAAAAAAAAAAAAAACYCEV/AAAAAAAAAAAAAAAAAAAAAABMhKI/AAAAAAAAAAAAAAAAAAAAAAAmQtEfAAAAAAAAAAAAAAAAAAAAAAAToegPAAAAAAAAAAAAAAAAAAAAAICJUPQHAAAAAAAAAAAAAAAAAAAAAMBEKPoDAAAAAAAAAAAAAAAAAAAAAGAiFP0BAAAAAAAAAAAAAAAAAAAAADARiv4AAAAAAAAAAAAAAAAAAAAAAJgIRX8AAAAAAAAAAAAAAAAAAAAAAEyEoj8AAAAAAAAAAAAAAAAAAAAAACZC0R8AAAAAAAAAAAAAAAAAAAAAABOh6A8AAAAAAAAAAAAAAAAAAAAAgIlQ9AcAAAAAAAAAAAAAAAAAAAAAwEQo+gMAAAAAAAAAAAAAAAAAAAAAYCIU/QEAAAAAAAAAAAAAAAAAAAAAMBGK/gAAAAAAAAAAAAAAAAAAAAAAmAhFfwAAAAAAAAAAAAAAAAAAAAAATISiPwAAAAAAAAAAAAAAAAAAAAAAJkLRHwAAAAAAAAAAAAAAAAAAAAAAE6HoDwAAAAAAAAAAAABADdq500uTJ0eoX784tW7dSN261dcjj0Tp8GEPo6NVq82bD+ihh95V8+YPy8/vLsXG/ll33vmq9u9PNDqaKW3d+rMGDhyvkJAb5evbUS1aDNbrr39qdKwal5tboEmTZql378kKCRkli2WwPvxwZZX77t17TL17T5a//3CFhIzSqFHTdPJkVg0nNkZubr4mTXpLvXuPU0jIjbJYWurDD+ef95ji4mI1azZIFktLTZ36Yc0EBQAAAPCbuRsdAAAAAAAAAAAAAAAAV/LeeyHautVHvXvnqGnTQp086a5PP62lIUPi9MUXR9WkSZHREavFP//5tdau/UV33NFZLVvG6cSJTL355mK1bfs3bdgwRS1axBkd0TSWLVunAQPGq02bazRx4v3y9/fRwYMJSkhINjpajUtNzdHkybMVGxuuVq3qafXq3VXul5CQqptuelZBQb56+eURys21aerU+dq164g2bXpFnp5X14UzZ0tNzdDkydMVGxulVq2aavXqzRc85o03Zuno0aQaSAcAAACgOlD0BwAAAAAAAAAAAACgBo0Zk6GpU5Pk6XlmXd++ORowIE7vvhuiqVNPGBeuGv3f/w3UZ5895lS4HjbsBv3hD49qypS5+uSTxwxMZx7Z2bkaPfoZ9et3k+bM+ZesVqvRkQwVFRWspKQPFBkZrC1bflWHDo9Xud/LL3+lvDybfvppqmJjwyVJHTs21i23PK8PP1yl++7rVZOxa1xUVLiSklYqMjJMW7bsUYcOw8+7f0pKmiZPnq4JE/6o5557q4ZSAgAAAPg9XPvsEAAAAAAAAAAAAACAGta2rc2p5C9J9eoVq3HjIh065Fn1QVegzp2vqTSreuPG0WrevK727k0wKJX5fPbZYiUnp+mll8bLarUqLy9fZWVlRscyjJeXhyIjgy+431dfrVf//u0dJX9J6tmzlZo0idbs2WsvZ0RT8PLyVGRk2EXv/+STr6lp0ziNHNnvMqYCAAAAUJ0o+gMAAAAAAAAAAAAAYDC7XUpNdVNwcKnRUS4ru92u5OQshYUFGh3FNJYv36DAQH8lJqaoadMB8ve/XoGBnfTAAy/IZis0Op4pJSamKSUlS+3bN6q0rWPHxtq27ZABqcxr06ZdmjlzgaZNmyCLxWJ0HAAAAAAXiaI/AAAAAAAAAAAAAAAGW7AgQMnJHurTJ8foKJfVp59+r8TENA0bdoPRUUzjwIGjKikp0W23Paxbb71BX331b/3xj4P1zjtf6t57Jxodz5SSkjIkSVFRlWf+j4oKVnp6rgoLi2s6linZ7XaNH/8PDRt2qzp1amV0HAAAAACXwN3oAAAAAAAAAAAAAAAAuLKDBz00eXKE2rQp0ODB2UbHuWx++SVBDz74P3Xq1FT33NPd6DimkZubr/x8m8aNu0Ovv/6kJGnIkJ4qKirW9OlfavLkB9W4cZzBKc2loKBIkuTl5VFpm7e3h2Ofqra7mg8/nK9du37VnDn/NjoKAAAAgEvEjP4AAAAAAAAAAAAAABjk5Ek33X9/jAICyvTaa8fl5mZ0osvjxIkM9ev3ooKCfDVnzhNyu1o/0N/Ax8dLkjR8eB+n9XffXb68fv2OGs9kdj4+npJU5az9Nlux0z6uLDs7V0899Zoef/we1a0baXQcAAAAAJeIoj8AAAAAAAAAAAAAAAbIybHqz3+OUU6Om957L1G1a5caHemyyMrKU58+LygzM09Lljyn6OgQoyOZSnR0hCSpdu1Qp/UREeXLGRlX710efquoqGBJUlJSRqVtSUkZCgnxZzZ/SVOnzlRRUbGGDeut+PhExccnKiEhWVL5+yo+PlFFRZUvlgAAAABgDhT9AQAAAAAAAAAAAACoYYWFFo0bF634eE+9806iGjUqMjrSZWGzFWnAgJe1f/9xffPNM2rWrK7RkUynXbtmkqTExBSn9cePly+HhwfXeCazi4kJVXh4oLZs+bXStk2bDqh16/oGpDKfo0eTlJGRrebNB6t+/T6qX7+PunQZI0l6+eX3VL9+H/3880FjQwIAAAA4J3ejAwAAAAAAAAAAAAAA4EpKS6VHH43S9u0+evvt42rTxmZ0pMuitLRUw4ZN1fr1+zR//lPq1OkaoyOZ0p139tKUKe/r/fe/Vo8e1znWv/feXLm7u6tbtw4GpjOv22/vpJkzV+nYsVTVrRsmSVqxYqf27z+uxx4bYHA6c3j44bs1aFAPp3UpKem6//7JGjPmNt12W3fVrx9jUDoAAAAAF0LRHwAAAAAAAAAAAACAGjRlSrhWrvRX9+65ysy0av78AKftt92WY1Cy6vXXv36oBQs2a8CADkpPz9Enn6x22j5yZDdDcplNmzbX6o9/HKwPPvhaJSWl6tq1nVav3qIvv1ymp54aq+joCKMj1rg331yszMw8HT+eLklauHCzEhLSJEnjx/dVUJCfnn56qL78cp26d5+oRx7pr9xcm159dZ7+8Ic43XvvzUbGrzFvvjlLmZk5jrs/LFy4WgkJyZKk8eOHq23bZmrbtpnTMfHxiZKk5s0bVroIAAAAAIC5UPQHAAAAAAAAAAAAAKAG/fKLlyRp1Sp/rVrlX2n71VL03779sKTykvbChZsrbafof8Y77zyr2NhIzZgxX19/vUJxcdH6z38e16OPjjI6miGmTp2nI0dOOpbnzt2guXM3SJJGjuyqoCA/1a0bpu+/f1H/938z9OSTH8vT0139+rXTv/51r7y8PIyKXqOmTp2pI0eOO5bnzl2huXNXSJJGjuynoKCAcx0KAAAA4ApA0R8AAAAAAAAAAAAAgBr08ccJRkeoEatXv2h0hCuGh4eHJk16QJMmPWB0FFOIj3/3ovZr3jxWS5dOusxpzCs+fsklH1OvXozs9p2XIQ0AAACA6mY1OgAAAAAAAAAAAAAAAAAAAAAAADiDoj8AAAAAAAAAAAAAAAAAAAAAACZC0R8AAAAAAAAAAAAAAAAAAAAAABOh6A8AAAAAAAAAAAAAAAAAAAAAgIlQ9AcAAAAAAAAAAAAAAAAAAAAAwETcjQ5gFjZbntERXF5h4ZkxsOXZDEyC0wrzCh2P8xgTw+VVHA8b42G0vMIz41FQwM8QM6g4DgV5BQYmgeQ8BnmMh+EqjkFeAeNhBhXHgXMR43EuYi6ch5gL5yHmw7mIuXAeYi6ch5gP5yLmwhgAAAAAAAAAwJXFsm/fPrvRIYySn5+vNm3aGB0DAAAAAAAAAACgxmzbtk2+vr5GxwAAXEYV/xaemztLfn7eBicyn5SUTNWufa8kKTd3g/z8+Nl4tpSUNNWu3V0S76Pz4b10YXl5+fL3v14S/xYFAAAALoXV6AAAAAAAAAAAAAAAAAAAAAAAAOAMd6MDGMnHx0fbtm0zOgZOsdvtstlskiRvb29ZLBaDE4ExMRfGw1wYD/NhTMyF8TAXxsN8GBNzYTzMhfEwF8bDfBgTc2E8zIXxMB/GxLx8fHyMjgAAAAAAAAAAuACXLvpbLBZuB2Yyfn5+RkfAWRgTc2E8zIXxMB/GxFwYD3NhPMyHMTEXxsNcGA9zYTzMhzExF8bDXBgP82FMAAAAAAAAAAD4baxGBwAAAAAAAAAAAAAAAAAAAAAAAGdQ9AcAAAAAAAAAAAAAAAAAAAAAwEQo+gMAAAAAAAAAAAAAAAAAAAAAYCIU/QEAAAAAAAAAAAAAAAAAAAAAMBGK/gAAAAAAAAAAAAAAAAAAAAAAmAhFfwAAAAAAAAAAAAAAAAAAAAAATISiPwAAAAAAAAAAAAAAAAAAAAAAJkLRHwAAAAAAAAAAAAAAAAAAAAAAE6HoDwAAAAAAAAAAAAAAAAAAAACAiVD0BwAAAAAAAAAAAAAAAAAAAADARCj6AwAAAAAAAAAAAAAAAAAAAABgIhT9AQAAAAAAAAAAAAAAAAAAAAAwEYr+AAAAAAAAAAAAAAAAAAAAAACYCEV/AAAAAAAAAAAAAAAAAAAAAABMhKI/AAAAAAAAAAAAAAAAAAAAAAAmQtEfAAAAAAAAAAAAAAAAAAAAAAAToegPAAAAAAAAAAAAAAAAAAAAAICJUPQHAAAAAAAAAAAAAAAAAAAAAMBE3I0OAAAAAAAAAAAAAAAAqo/dbnc8TknJkp+fzcA05pSSkuV4nJycJn//AgPTmFNKSrrjcXJypvz9vQ1MY168ly4sL+/M56Ti9ycAAAAA52fZt28f/4IGAAAAAAAAAAAAAOAqkZaWps6dOxsdAwAqWbdunUJDQ42OAQAAAFwRrEYHAAAAAAAAAAAAAAAAAAAAAAAAZ7gbHQAAAAAAAAAAAAAAAFQfb29vx+PkGTPkV2EZ5VKystRg3DhJUvKqVfLz8TE4kfmkpKerQd++kngfnQ/vpQvLKyhQ7e7dJTl/fwIAAABwfhT9AQAAAAAAAAAAAAC4ilgsFsdjP29vCtpV8LPZzjz28ZGfr6+BaczJr6DgzGPeR+fEe+nSVPz+BAAAAOD8rEYHAAAAAAAAAAAAAAAAAAAAAAAAZ1D0BwAAAAAAAAAAAAAAAAAAAADARCj6AwAAAAAAAAAAAAAAAAAAAABgIhT9AQAAAAAAAAAAAAAAAAAAAAAwEYr+AAAAAAAAAAAAAAAAAAAAAACYCEV/AAAAAAAAAAAAAAAAAAAAAABMhKI/AAAAAAAAAAAAAAAAAAAAAAAmQtEfAAAAAAAAAAAAAAAAAAAAAAAToegPAAAAAAAAAAAAAAAAAAAAAICJUPQHAAAAAAAAAAAAAAAAAAAAAMBEKPoDAAAAAAAAAAAAAAAAAAAAAGAiFP0BAAAAAAAAAAAAAAAAAAAAADARiv4AAAAAAAAAAAAAAAAAAAAAAJgIRX8AAAAAAAAAAAAAAAAAAAAAAEyEoj8AAAAAAAAAAAAAAAAAAAAAACZC0R8AAAAAAAAAAAAAAAAAAAAAABOh6A8AAAAAAAAAAAAAAAAAAAAAgIlQ9AcAAAAAAAAAAAAAAAAAAAAAwEQo+gMAAAAAAAAAAAAAAAAAAAAAYCIU/QEAAAAAAAAAAAAAAAAAAAAAMBGK/gAAAAAAAAAAAAAAAAAAAAAAmAhFfwAAAAAAAAAAAAAAAAAAAAAATISiPwAAAAAAAAAAAAAAAAAAAAAAJkLRHwAAAAAAAAAAAAAAAAAAAAAAE6HoDwAAAAAAAAAAAAAAAAAAAACAiVD0BwAAAAAAAAAAAAAAAAAAAADARNyNDgAAAAAAAAAAAAAAgCs5cMBTb7wRqj17vJSa6i5vb7saNSrU2LEZ6tEjz+h41WbP0aN6/vPP9dOhQzqRkSFfLy81q1tXjw8apAEdOhgdzzTGPPusZi5YcM7tCd99p5jatWswkbFyCwr06rx52njggDYdOKCM3FzNGD9eY3r0cNpv0/79+nDVKm3cv187jxxRSWmp7F9/bVDqmpebn69XZ8zQxl27tGn3bmVkZ2vGCy9ozG23Oe13rvdX03r19Mt53ncAAAAAjEfRHwAAAAAAAAAAAACAGnT8uIfy8qwaPDhbERGlKiiwaNkyfz3wQIwmT07WsGFZRkesFkdOnlSOzaZ7undXdHCw8gsL9dWGDRr48sua/sADuq9XL6MjmsL9d9yhntdf77TObrdr3AsvqF5MjEuV/CUpNSdHk2fPVmx4uFrVq6fVu3dXud/irVv13vLlahkXpwa1a2v/8eM1nNRYqRkZmjx9umKjotSqaVOt3rz5nPt6eXrqveefd1oX5O9/mRMCAAAA+L0o+gMAAAAAAAAAAAAAUIO6ds1T167OM/ePHJmpIUNiNWNG8FVT9O/brp36tmvntO6hvn3V7m9/078XLKDof0qnVq3UqVUrp3Vrtm5Vvs2mEX37GpTKOFHBwUr64ANFBgdry6+/qsPjj1e53wO9e2vC4MHy8fLSQ+++63JF/6jwcCWtXKnIsDBt2bNHHYYPP+e+7m5uGtm/fw2mAwAAAFAdrEYHAAAAAAAAAAAAAADA1bm5SVFRJcrJubr/jO/m5qa6YWHKzMu78M4u7LPFi2WxWHS3Cxb9vTw8FBkcfMH9ateqJR8vrxpIZE5enp6KDAu76P1LS0uVnZt7GRMBAAAAqG7M6A8AAAAAAAAAAAAAgAHy8y2y2SzKzXXTypV++uEHP/Xpk2N0rGqXZ7OpoKhIWXl5WrB5s77dulXDbrzR6FimVVxcrNnLlqlz69aqFxNjdBxcBfJtNgV26qR8m03BgYEa3qeP/vnYY/L39TU6GgAAAIDzoOgPAAAAAAAAAAAAAIABpkwJ1xdf1JIkWa123XJLrp57LsXYUJfBX2fM0PRlyyRJVqtVQ667Tm/++c8GpzKvpevWKS0zUyNccDZ/VL+o8HA9ce+9anvttSorK9OStWv19hdfaMf+/Vr9/vtyd6c6BAAAAJgV/1oHAAAAAAAAAAAAAMAA99yTod69c5WS4qZvvw1QWZlUXGwxOla1e3TAAA3t3FnH09M1e+1alZaVqaikxOhYpvXZ4sXycHfXnbfeanQUXAX+8cgjTst39emjJnFxeuaNNzTnu+90V58+BiUDAAAAcCFWowMAAAAAAAAAAAAAAOCKGjYsVufO+Ro0KEfTpx9Xfr5V48bFyG43Oln1uqZOHfVs1Uqju3fXN88+q1ybTQNeekn2q+0DrQa5+fmav2qVbu3cWaG1ahkdB1epx0aNktVq1fING4yOAgAAAOA8KPoDAAAAAAAAAAAAAGACt96aq127vHX4sIfRUS6roZ07a/Ovv2r/8eNGRzGdeStXKt9m04h+/YyOgquYj7e3QoOClJ6dbXQUAAAAAOdB0R8AAAAAAAAAAAAAABOw2SySpNxcN4OTXF4FhYWSpKy8PIOTmM+nixbJ39dXA7t1MzoKrmI5eXlKzcxUeHCw0VEAAAAAnAdFfwAAAAAAAAAAAAAAalBaWuUif3GxNH9+oLy9y9SwYaEBqapfSmZmpXXFJSX6aPVq+Xh6qlndujUfysROpqdr+caNGtyjh3x9fIyOg6uArbBQOVVcUPPC9Omy2+3qfcMNBqQCAAAAcLHcjQ4AAAAAAAAAAAAAAIAree652srNtapDh3zVrl2ikyfdtXBhgA4d8tKTT6bIz89udMRqcf877yg7P183NW+umJAQncjM1Kfff69fEhP1rzFj5E+Z3ckXS5eqpKREI/r1MzqK4d5cvFiZeXk6np4uSVq4ebMS0tIkSeP79lWQn5+OpKTo4++/lyRtOXhQkvTil19KkuLCwzXKBe6K8OasWcrMydHxlBRJ0sLVq5WQnCxJGj98uDKys9Xmzjs1vE8fXVO/viRp6bp1Wvzjj+p9ww26rXt3w7IDAAAAuDCK/gAAAAAAAAAAAAAA1KC+fXM0Z06gZs2qpcxMN/n5lal5c5v+9rdU3Xxz5dm3r1TDbrhB769Yof8uWaK0nBwF+PioXcOG+ufo0RrYsaPR8Uzn00WLFBESop7XX290FMNNnTdPR06edCzP3bBBczdskCSN7NpVQX5+OpySoomffeZ03Onlrs2bu0TRf+rMmTpy/Lhjee6KFZq7YoUkaWS/fqoVEKD+Xbvquw0bNHPBApWWlalR3bp6+eGH9bd77pHVajUqOgAAAICLQNEfAAAAAAAAAAAAAIAa1K9fjvr1yzE6xmV3V5cuuqtLF6NjXDHWf/KJ0RFMI/7ddy+4T7cWLWT/+usaSGNe8UuWXHCfj19+uQaSAAAAALgcuDQXAAAAAAAAAAAAAAAAAAAAAAAToegPAAAAAAAAAAAAAAAAAAAAAICJUPQHAAAAAAAAAAAAAAAAAAAAAMBEKPoDAAAAAAAAAAAAAAAAAAAAAGAiFP0BAAAAAAAAAAAAAAAAAAAAADARiv4AAAAAAAAAAAAAAAAAAAAAAJgIRX8AAAAAAAAAAAAAAAAAAAAAAEyEoj8AAAAAAAAAAAAAAAAAAAAAACZC0R8AAAAAAAAAAAAAAAAAAAAAABOh6A8AAAAAAAAAAAAAAAAAAAAAgIlQ9AcAAAAAAAAAAAAAAAAAAAAAwEQo+gMAAAAAAAAAAAAAAAAAAAAAYCIU/QEAAAAAAAAAAAAAAAAAAAAAMBGK/gAAAAAAAAAAAAAAAAAAAAAAmAhFfwAAAAAAAAAAAAAAAAAAAAAATISiPwAAAAAAAAAAAAAAAAAAAAAAJkLRHwAAAAAAAAAAAAAAAAAAAAAAE6HoDwAAAAAAAAAAAAAAAAAAAACAiVD0BwAAAAAAAAAAAAAAAAAAAADARCj6AwAAAAAAAAAAAAAAAAAAAABgIhT9AQAAAAAAAAAAAAAAAAAAAAAwEYr+AAAAAAAAAAAAAAAAAAAAAACYCEV/AAAAAAAAAAAAAAAAAAAAAABMhKI/AAAAAAAAAAAAAAAAAAAAAAAmQtEfAAAAAAAAAAAAAAAAAAAAAAAToegPAAAAAAAAAAAAAAAAAAAAAICJUPQHAAAAAAAAAAAAAAAAAAAAAMBEKPoDAAAAAAAAAAAAAAAAAAAAAGAiFP0BAAAAAAAAAAAAAAAAAAAAADARd6MDAAAAAAAAAAAAAACAyyPPZjM6ginlFRaeeVxQYGAS86r4eeF9dG68ly6MzwsAAADw21j27dtnNzoEAAAAAAAAAAAAAACoHvn5+WrTpo3RMQCgkm3btsnX19foGAAAAMAVwWp0AAAAAAAAAAAAAAAAAAAAAAAAcAYz+gMAAAAAAAAAAAAAcBWx2+0qKCgwOoap2e122Ww2SZK3t7csFovBicyHz9HF4fN0aXx8fPgcAQAAABeJoj8AAAAAAAAAAAAAAAAAAAAAACZiNToAAAAAAAAAAAAAAAAAAAAAAAA4w93oAAAAAABwLitW/aC58xdJkq7r0E6jR9xZ5X6lpaWaMvV1HU864VgXEhysFyY9+bszLPlupRYuWuq07pEH71OTxg2d1k17Y7oOHDwkSfrzH0epdcsWv+t1jx5L0Cv/flN2u11hYaGa9PTfZLWe+1rtz774SmvXb3JaN3niBIWGhlzS655ITtHun3/R4fgjio8/qsysbMe2xg0b6NHx91d53KJvv9PipcslSd1uukF3DBl4Sa8LAAAAAAAAAAAAAACAM5jRHwAAAIAp5ecXaOl3qyRJFotFvW7ues59l363yqnkX12SU05qybIVF7XvLT27OR4v+GaJSktLf9drf71gsex2uySpZ/ebzlvyP/DrIa3bsPl3vd5pa9Zu0NfzF2n7jt1OJf8L6XpTZ3l6ejqeIzU1rVryAAAAAAAAAAAAAAAAuCKK/gAAAABMacWqH5SXny9JanZtU0VG1q5yvxMnkrV0+apqf3273a5ZX8xVcXHJRe3f/NqmijqVMTnlpDZu/uk3v/Yv+w5o/4GDkiQ/X19d37HdOfctLi7WZ1985bgooDr5+vpc9L7+fn6OnCWlpfpmyXfVngcAAAAAAAAAAAAAAMBVUPQHAAAAYDolJSVas36jY7l929ZV7me32/XZ7LkqKSmRt7eXfHwuvph+Ies2bNKBg4ckScHBtS7qmIo5f1iz4Te/9uof1zket2rZXB4eHufc99tlK5RyMlXSxec8n6ZNGmn03Xfquaf+pldemnRJx1b8+Ldt26nc3LzfnQcAAAAAAAAAAAAAAMAVUfQHAAAAYDo7du5xlMQ9PNzVskWzKvf7ce0GHTwUL0m6rX8f+Xh7V8vrZ2Vl6+sF30qS6sfF6voO555Rv6K2bVo6Hh9LSNTRYwmV9pn2xnQ9+OgEPfjoBE38+5RK2zMzs7Tn518cy+3atDrn6yUeT9LylT+Uv3brlmrSqOFF5TyfP7Ropus6tlPt2uGyWCyXdGyD+nGqVStIUvms/ht+x10NAAAAAAAAAAAAAAAAXBlFfwAAAACms3P3z47HsXXryNvbq9I+mZlZmv9NeRm/YYP66nLD9dX2+rO/mq+CggK5u7lpxPChF114jwgPU62gQMfyzl0/n2fvqu3++ReVlZVJkqxWqxo2qFflfmVlZfr0869UWloqP19f3Xn7bZf8WtXNYrGoccMGjuXf8vEDAAAAAAAAAAAAAACAoj8AAAAAE/r14CHH47i6darc54s582SzFcrd3V0jht1+ybPPn8uOnXu0feduSVKvnt0VFVn7ko6Pi6vreHygwsdxsX49eNjxOCY6Uh4eHlXut/qHtTpy9JgkafBt/RQQ4H/Jr3U5xMWe+fiPHD2m4uJiA9MAAAAAAAAAAAAAAABcmSj6AwAAADCVnNxcZWZlO5Yjqyjab92+0zHrf59eN6t27fBqee0Cm01ffDXv1OtG6NZbul/yc0TVPpP3WELiJR9/LPHMMZG1q77IIC09QwsXL5MkXdO0sTpd1/6SX+dyiYqMcDwuKSlR0olkA9MAAAAAAAAAAAAAAABcmdyNDgAAAAAAFeXk5Dot+/n5Oi3n5xfoy7kLJEkx0VG65eau1fba8xYsVlZWtiwWi0YMGyp390s/ZfL19XE8LiwsUlFRkTw9PR3rHh1//3mPz83Jczw++2M/7fPZc089r4eG3znkkjNeTr6+zpmzzxpPAAAAAAAAAAAAAAAAXBgz+gMAAAAwlYICm9Oyt5eX0/Ky5auUnZ0jq9WqEXfdLjc3t2p53aQTyVq7fpMk6aYbO6lB/bjf9Dze3t5Oy/lnfTwXkl9QcOa5zvrYJWnPz7/o51/2S5L69+mlsNCQ35Dy8vH2ds5cUOHjAQAAAAAAAAAAAAAAwMVhRn8AAAAApuLj41yUtxUWOi2fniHebrfrrekfOG3Lzz9TKs/IzNQTz/xdkvTKS5Mu+Lo5Obmy2+2SpE2bt2rL1u2ObUVFxU77Tn9/ptzc3HTn7bepfdvWTtsKbM7Fft+zPp4L8fXxUW5e+az+Z3/skvMM+Uu+W6mly1c5lgsLi5z2nfKv12WxWHT/2HvUsEG9S8rxW9nO+vh9fHzOsScAAAAAAAAAAAAAAADOhaI/AAAAAFMJCPB3Ws7Pz69yP7vdrry8qrddzPbzObusfzabrbyAX1xcUmlbxbyenh7y9PS8pNf2D/BzFP3zzvGxn3mt88+Wf3p7aWnpJWX4Pc7OHODvV2OvDQAAAAAAAAAAAAAAcLWg6A8AAADAVAL8/VUrKFCZWdmSpKQTKdX6/BP/PkXpGRmSpMYNG+jR8fdX6/OfqJC3TkxMpe3T3piuAwcPSZJCgoP1wqQnnbbXiYl2PMeJav7YJemjT2dr4+afHMtvTftntT5/xcxubm6Kioys1ucHAAAAAAAAAAAAAABwBRT9AQAAAJhOo4YNtGXrdknS0WMJTttGj7hTo0fcWeVxFUv8VZXoz6dJ44bnLL0v+vY7LV663LH8yIP3qUnjhlXuG3/0mONx40b1L/r1Hcc0bKAtP22XJCUlnVBJSYnc3c+cunW6rr06Xde+ymPPLvFPnjhBoaEhl/T6a9dv0roNm6rcdiwhUa/+503H8n1/HK2goECnfSp+/HGxdeTp6XFJrw8AAAAAAAAAAAAAAACK/gAAAABMqGWLZo6i/5GjCbIVFsrby8vYUBchOeWksk7diUCS/tC82SU/R4tm18hqtaqsrEwlpaU6eCheTZs0qs6Y55WZmaX4I8eq3GYrLHTaVlJS4rTdbrfr118POZZ/y8cPAAAAAAAAAAAAAAAAyWp0AAAAAAA4W6uWzeXv7ydJKi4u1u7de6vleUtLS5WXn+dYbtigXrU872lbt+1wPI6JjlL9erGX/By1agWpebNrHMs/VXjO6pCdk+N43KB+vWp97oOH4pV56kIHNze3c955AAAAAAAAAAAAAAAAAOfHjP4AAAAATMfd3V03dOqopd+tkiRt/mmb2rdrfcHjXpj05Hm3xx85psLCIklSRHiYevfqcVF5+vW5Rf363HLB/bZUKOV37dK5yn0eHX//BZ+na5dO2rX7Z0nS9p27dceQgfLw8LjgcaNH3KnRI+485/aSkhIdPHRYUvnneMRdt1fa52I/1qqcvguDJLVt3VIBAf6/6XkAAAAAAAAAAAAAAABcHTP6AwAAADClnt27ys/XV5K0Z+8+nTiR/Luf85f9ByRJFotFI+4aelHl+Yu15+dfdOJEiiSpdkS4ru/Y7jc/17VNm6hJ44aSpLy8fG3Y9FO1ZDwcf1RFRcWSpD69blZk7YhqeV5Jys3L08bN5Tnd3Nx+88UCAAAAAAAAAAAAAAAAoOgPAAAAwKR8fX106y3dJUl2u13LVnz/u59z3/6DkqQbO1+nRg3r/+7nq+i7CvkG9u8tNze33/V8gwf2lcVikSQtX/WDysrKftfzSdK+/b9KkmKio3TLzV1/9/NV9P0P6xwXEXS54XqFh4VW6/MDAAAAAAAAAAAAAAC4Esu+ffvsRocAAAAAAAAAAAAAAAAAAAAAAADlmNEfAAAAAAAAAAAAAAAAAAAAAAAToegPAAAAAAAAAAAAAAAAAAAAAICJUPQHAAAAAAAAAAAAAAAAAAAAAMBE3I0OAAAAALiyFat+0Nz5iyRJ13Vop9Ej7jQ4ketYv3GLPpn1pWP5kQfvU5PGDQ1MVLMWffudFi9d7liePHGCQkNDLurYjz6drY2bf3IsvzXtn9We73Iwcswrfr673XSD7hgysEZeFwAAAAAAAAAAAAAAXJko+gMAAAAGyc8v0NLvVkmSLBaLet3c1eBEwJXrwUcnOB7/1otmJv59itIzMiRJjRs20KPj76+2fF1v6qzlq35QUVGR1qzdoO433aCwsNBqe34AAAAAAAAAAAAAAHB1oegPAAAAGGTFqh+Ul58vSWp2bVNFRtY2OJFrCQ0JVutWLRzL/v5+Bqb57QpsNnl7eclisVzScZGREU4fv6eXZ3VHMx0jx9zfz0/Xd2ynH9asV0lpqb5Z8p3GjLyrxl4fAAAAAAAAAAAAAABcWSj6AwAAAAYoKSnRmvUbHcvt27Y2LoyLatK4oZo0bmh0jN+luKREb73zvoJr1dLoEXfKw8Pjoo9t16aV2rVpdRnTmY/RY96+bWv9sGa9JGnbtp0aOmjAFXuBCQAAAAAAAAAAAAAAuLwo+gMAAAAG2LFzj3Jz8yRJHh7uatmiWaV9pr0xXQcOHpIkhQQH67mn/6plK1Zry0/blZ6eofr14vTo+Psd+x9POqHVP6zVgV8PKTMrS3a7XUGBgWrYoL66dumsuNg6Ts//zPMvKzMzS5LUvl1r3TtquGPba2+9q/0HDkqSevboqsED+zq2/f2lV5VyMlWS1LJFM93/p3su6mNOS0vXcy/807Hc99aeavmHZlqwaKkOHY6X1WpV0yaNNHhAX4WGhigvL18LFy/Vjl17lJ9foNoR4brl5q7q0K6N0/NmZmVrzdoNOnIsQSdPpiovP182W6G8PD0VHh6qa5o2UfeuNygwIMDpuPUbt+iTWV86lh958L5KJfDUtHSt/mGt9u3/VWnp6SotKVVAgL/q1YvVjZ2v1zVNGlX6OCf+fYrSMzIkSY0bNtB9Y0fr26XLtX3nHmVmZalDuzYaPeLOi/qcXcjns+fqcPxRZQXnqLCo6JKK/ou+/U6Lly53LE+eOEGhoSGO5dLSUq36fo3WbdistPQM+fv7qdUfmqt/n1su6vmPHD2m739cr4OHDisrO0cWixQaEqI/NL9WPbp3UYC/v9P++w8c1GtvvetYHjn8DsXF1tHipcu1/8BBFRYWVfkeqPj5Pm3j5p+0cfNPTs/V6br25xzzil9rpx04eEgPPjrBsdz31p6yWi365tvvJEkWi0WTnnlc4WGhTsfNnb9IK1b9IEmyWq166e9PO957DerHqVatIGVmZqmktFQbNv+knt1vuqjPJwAAAAAAAAAAAAAAcC0U/QEAAAAD7Nz9s+NxbN068vb2Ou/+paUleuudDyqVkU9b9f1azZ3/jcrKypzWp6alKzUtXZu2bFX/Pr3Uu1cPx7bGDRto80/bJEkHD8VXeK1SxR856lg+eOiw43F2To6j5C9JjRs1OG/u8zl4OF7LVqxWSUmJY9227bt06FC8Hn7wPv33fx8qNTXNsS3xeJI+/PhzlZWW6bqO7RzrT5xI1rfLVlR6/gKbTUePJerosUSt37BZjz08TrUjwi8639btO/XxZ7NVVFTstD4jM0sZ23dp2/ZdurHzdbrrjsGyWCxVPkd+QYH+9drbOpGcctGve1pmVrZKK3xuzvbTtp3asOknWa1W3T64vwpPXdxwKWX/c7Hb7Xp/5qfasXPPmTyZWfr+x3X6ee8+hYeHnff4bxYv05LvVsputzutTzqRrKQTyVq/aYv+ct+9iq1b5xzPIO3a87M+nz1XJaWljnXneg/UlBs6X6cly1aqpLRUdrtd69Zv0m0D+jjts237Lsfj5s2ucbrAxGKxOH3d7dz1M0V/AAAAAAAAAAAAAABQJYr+AAAAgAF+rVDYjztP2fm0rOwcZWXnyMfbW3XrxqikpFRu7m6SpF179mrO1wsc+1osFsXF1pHV6qb4I0dVVlYmu92uhYuXKjwsVO3atpJUXtI/XTjOyMhURmamgmvVUkLicady+7FjiSouLpaHh4fTBQHlz+E8A/6l2Lf/V3l4uKtJ44ZKTU13zMqelZ2jKVNfV3FxsWKio+Tl5alDh484jlu05LsqS96hIcEKCgqSn6+PSsvKlJqa5rgoISc3V1/OXaCHxo29qGzHEhI18+PPnUrmdWKi5evro8PxR1VcXP75WbNuo0JDQtSrZ7cqnyfxeJIkyd/PT3XrRCu/oEBWa9UXBZzt7ekfOI4/n7KyMv3vg48lVX1Xgt/ix7UbnEr+VqtV9eJiVVpaqqPHEnSywgUYZ1u7fqPThRe+vj6Ki62rkuISHTwcr7KyMuXk5Oqd/32oZ5/8q3x9fap8nh0798jdzU0NG9RXXl6e08USFd8DzZs1VU5urrbv2O3YHhIcrNjYGMdyaEjweT/eRo3qy8/fVz/v3ed47/v7+alRo/qOfSIjIxQYEKA2bVpq85byr5sNm39S/7695OZW/rV4OP6I090FOl3XvtJrxcXWdXzdHTl6zPG1BQAAAAAAAAAAAAAAUBFFfwAAAKCG5eTmKjMr27EcGVn7oo6Li62rB+4bowB/f0lS8anZ3hd9u8xpv/vGjlbLFs0kSb/s/1Vv/vc9x8zq33y7zKnoX9HBQ/Fq37a1o8xvtVpVVlamktJSxR89psYNGzgV/X19fRQTHXmRH3VlFotFD//lPjWoH6eCggI9PeklR8m6uLhYN93YScOGDpIkvffhJ46Z0tPSM5SWlq7Q0BBJUt06MXpx0lMKDq5V6TXmLfxW361YXf652HdABTabfLy9L5jt22UrnEr+QwcPVPeuN0gqL+9Pnfa2ioqKJElLl69Ut5tukKdn1WXtFs2v1R9H3y0vL8/yj+08s/Sbxarv1zgt3/+ne9Si2TWSpI2bftJHn82u8riysjItXHzm/RgXW0cPP3ifvL3K71gRf+SYpk57S3a7XVnZOfph7Xr1vqVHlc/l7uamR8ffr/r14lRWVqa3352hvb/sl+T8HrjrjsGSpAcfneA4tnGjBho94s6L/nj79+klSZr49ylKLyov6kdF1taf7x1Vad/uN93gKPpnZ+do1+69at2qhSRp67adjv0CAvwdn7OKoiIjHI9LSkqUdCL5vHc2AAAAAAAAAAAAAAAAromiPwAAAFDDcnJynZb9/Hwv6rg7hgxwlPwlycPdXVnZOTqWcNyxrkH9OEfJX5KuadJI1zRppL37DkiSUk6mKjU1TWFhoYoID1OtWkHKzMySJB06fKS86H84XpLUtHFDHTmWoPz8Ah08FF+p6N+oQX1ZrVZJ0v4DB/X9mnVV5q6qLH06W4P6cZIkHx8f1Y4Id/pYKhbAGzVs4Cj6S+Wz/p8u+vv5+Srl5EktXLxM8UeOKiMzS8XFxY6LG06z2+1KTU1T3ToxOp+ysjLt/eWAYzm4VpC6dunkWI6JjlKHdq21dv0mSZLNVqjD8UfUtEmjSs9ltVp119BBjpK/VD5uF+OuOwapwFbotK6oqEifzPpSNluh4mLrqN+pgnrFbL9XRmam404IktSgfj2nwvp1Hdtp6fJVSk45WenYo8cSnd7fxcUl+visiwLc3NxUcupih5/37jtn0b9Nm5aqX6/8/WG1WnVt08aOor/k/B6oSXGxdVUvrq7ijxyTJK1Zv1GtW7WQ3W7Xth1n3qMd27d1zPRfka+v89d79lnfDwAAAAAAAAAAAAAAACSK/gAAAECNKyiwOS2fnu38fNzd3FQvLrbS+oyMTKflqCruDhAVWdtR9Jek9IxMhYWFSpIaN2ygzT+Vz05+usR/6PARSVLDhvXl5uam3T//ooOH4lVYWKSExDNF/Ip3BEhLz9D2Hbsv+HFUdPadDDw9z3wefHx8FBQU6Fj28vR02rekwqz46zZs1mdffFWp2F8V21nF+ark5eU7ZuuXpNq1IxwXNJwWFel8J4P0jIwqnys0JLjKOw1cjAb161Va98HMz2SzFcrPz1d/unekQoKDf9Nzn8/pCz9OqzgD/WmRkRFVFv3T0tOdlo8nndDxpBPnfK309Ko/b5JUNybaadnHx/lODCUG3hmh20036MOPP5dUfqeItPQMZWVlKaPC567Tde2rPNbb2/nrvaCg4PIFBQAAAAAAAAAAAAAAVyyK/gAAAEANO7uwbCu8cPk8IMBfFoul2rM0bnSm6H886YSOJSQqOztHktSwfj25Wa3a/fMvOhx/VIfi41VWVlbh2Ia/67V9vJ0/D9YKH9/Z286luKREX81b6FTyj6wdofDwMLm5WZWenqmjxxIc2y7mYoDqFBgYeOGdzuGnrTuUk5fnWE5OTtFP23ZIKr9AY+fuvZWOaf2H5qpVK+g3v2ZNKyouPue2s2e+t1is59iz5rVt3VJz5y9SdnaO7Ha71m3YpMIKF5HUi6tb5UU3kmSzOV/o4+Pjc1mzAgAAAAAAAAAAAACAKxNFfwAAAKCGBQT4Oy3n5+df8JhzlZzPni0+6URKpX2STiSf85iKs/KXlZVp+aofJElWq1X14uo6ZrIvKCjQmrUbHfv6+vooJvrMrPadrmt/zhnML6ekpGSnWfpvurGThg0d5FhetnyVU9H/Yvj5+crT09Mxq39ycorKysqcZvVPOuE8S33wOWbWt/6OizOWLl+lxONJVW7bvnO3tu+sfAeF6Mjav7vof/bxJ5Irv6dOVPE+k1TpDgP9et+ivr17/q48Nelih8vNzU03dr5Oi5cslySt37hFFQ/tdF2Hcx6bd9bXe4C/36XGBAAAAAAAAAAAAAAALsA8UyICAAAALiLA31+1gs7M9F5VOf9iBQUGqE5MtGP50OF47dpzZqb3/QcO6pf9vzqWw8NCFR4W6liOCA9zKnZv3bZTklS3TrQ8PT0VF1tH7v/f3r2HeVkX+P9/zQyHGQZQQERAOXjCxEA0D5AnPIWYx7XMQ6nrN6Nva7n7LXPXQ/tzzdzV2ixt1bWwssw0j5nmluAhRSFNzQxQROUgwxlmhoFhmN8f5gihZS5y3zM+HtfltZ/P/fnM8Oq9MBdc13PuqapKkjz97HNt79tx+6EbhO9FaWlp2eB51y5d2h4vXrI0Dz786N/8OSsrK/OBYTu1PV+6bHke+s2Utufz5r+Wqb/9Xdvz6q5ds/2QwX/zr1NWvbbccoPfIy/Omp0/PD+97fkT057KgrqFb/mxg7YbmO7rhesPPvxo5sydt9H75s6bn9vuvCdPP/PcRq+9W507d257vHzFivf8c+w3Zt+2PxvLl6/IsuUr2j7HnnuMfNuPW/+bJKqqqtJ/m23e9r0AAAAAAAAAwPuXO/oDAEABdtxh+0x78ndJ8jffcf7PHXnEYbn2+u+3Pb/uuz/I4O22TWVVZWa//GpaW1vbXhs/7rCNPn6nHbbP1N8+leT1u/onyfZDhyR5PVoeNGjbzHrp5Q0+z/o/CaBI/fv3S+fOndPc3Jwk+Z8HHswLs15K1y5dMmv2y2luXvuuPu+4ww/O7//wx7ZvJLjlZ3dmyuNTU1NTk5dmv9L26yXJYYcelC5dOr/dp3rX/uXcc9Lc3Jz//Pa1efmVV7P90CH5wuc+nU6d3vt/xh180P65+dY72p7/13/fkKFDBqWlpSUvv/L2v1+rqqpy5LjD2j62vqEhl13xrWy37cBssUXPrF69OvNfW5CVK+uTJP236bfJNvfdqk/mzX/9Jy38cfrMfP3K/0rPnq//9IzTTjkxXdb7JpC/9Dne+AkGdQsX5bIrvpU+vXslFcnxRx+ZPn16t713i549Mmr3EW1/dt6w+8jdUlNd/ba/xuxXXm17PHjQtu/J7x0AAAAAAAAAoP0r/hacAADwPjRit13bHr/8ypw0rV79v/pcxx9zZNsd9tetW5eXXn4lL86a3RaqV1RUZPxHDs3eHxq10ce/VbS//dDB6z0e8hYfs8O73rspVXftmiMOP2SDay/NfiV/nPFCKisrc8jYA97V5x203bb51Ckf3+AO76/OmZcZM1/cIPIfs+9eOfyQg97Vr/FO/PRnd+blV15Nr15b5qy//+RmifyTZL8x++SD6/0eXbduXV6cNTuzX341W/Ts8Re/0eOA/Ubn8EPHpqKiIknS2tqaV16dk2d//4fMmPliW+SfZJP+VIh99tpjg+ezXpqd3z39+/zu6d9n7dqWt/moDe39Z5/j1Tlz87tnXv8cjauaNnr/gfuP2ejamH32etvP39ramhdemNX2/IPDd33b9wIAAAAAAAAA72/u6A8AAAUYOWJ4unevTX19Q5qbm/P73z+fD+25+7v+fIeMPSDDdt4xDz78aGa+MCvLli9PkvTs0SM7bD80B+w3OkOHDHrLj32raHuH9eL+HbYfkl898GDb827dajJwwDbveuum9pHDxqZHj9pMevA3WVC3MNXVXbPTjtvn6CPHZdZLL7/tx73xTRBvqKqq2uD5h/bYPUMGbZfJD/0mz8+YmSVLlmVdS0u6d6/N0CGD8+HRe+cDu+z8nvxvesOHR++T6TNfzKfP+GR69Oj+nv5a66usrMynzzg1v570cB57fGqWLFma2tpu2W34B/LR8Yfnjrvu/Ysff8xHx2X3EbvlkUen5MVZs7N02fKsXbs23Wpq0rdvn2w/dHBGfHB4dtx+6CbbfPBB+2fdutZMeWJaFi9ekrUt7yzuX98eu4/IqhOb8uDDj6Zu4cK/+hMhhg4ZlMGDtm37KQdb9en9F78J4sVZs7Ns+Yokr/9+G73Ph/7mjQAAAAAAAADA+0PF9OnTW4seAQAA70d33XNffvk/k5Iku+26Sz571hkFL3p/ue3On+fXkx5ue/6vF5ybvlv1KXDRW2tpadnomxAoh3Xr1uXfvvb11C1clCT56PjDN/oJE+v7yS235+HfTEmS7LXnqJz+yU9slp0AAAAAAAAAQPvjjv4AAFCQQ8cemEd+83gaGhvz3PPT89prC7LNNv2KntXhPf7Eb/PKnLn5zWNPtF3r3atXKSP/ZOOfNEDxfvPY41lZ35DpM15oi/y7dOmS/Ubv87YfU9/QkMen/jbJ6/8/PfKIwzbLVgAAAAAAAACgfaosegAAALxfdetWk48cNjZJ0tramvt//WDBi94ffj354Ux+6Ddpbm5uu3bMUeMKXER7c9/9k3L3Pb/MjJkvtl07+shx6dGj+9t+zIMPPZo1a17/Pbf/h/ct7TeWAAAAAAAAAADl4I7+AABQoEPGHpBDxh5Q9Iz3pc6dO2fbAf1z+GFjM2K3XYueQzvUuXPnbNOvbw4+aP/s/aE9/uJ7jzziMHfxBwAAAAAAAADesYrp06e3Fj0CAAAAAAAAAAAAAAB4XWXRAwAAAAAAAAAAAAAAgDcJ/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEqkU9EDAACAv92aNRW58so+ufPOnlmxojLDhq3OOecszoc/3Fj0tNJoaKjId7/bO08/XZ1nn63O8uVV+drXXsvxx68oelppPPNM19xxxxZ5/PGazJ3bOVtu2ZKRI5tyzjmLMnRoc9HzSmPmzC759rf75LnnumbRok6prm7NjjuuzplnLs3BBzcUPQ8AAAAAAAAA6IDc0R8AANqh887rlxtu6JWjjlqR889fmKqq5KyzBmbatOqip5XG0qVVufrqPpk1q0uGDVtd9JxSuv763rn//u4ZPbox559fl49/fHmmTavJ8ccPzowZXYqeVxrz5nVOQ0Nljjvu9T9v//f/Lk6SfPazA3PzzVsUvA4AAAAAAAAA6Igqpk+f3lr0CAAA4J175pnqfOxjg3LuuQtz5plLkySrV1fkox8dnD59WvKTn7xa8MJyWLOmIsuXV6Zv35Y8+2zXnHDCYHf0/zNPPlmd3XZrSpf1mv7ZszvnqKMG5yMfqc8VV7xW3LiSa2lJjj9+UFavrsx9980ueg4AAAAAAAAA0MG4oz8AALQz993XPVVVrTnxxOVt17p2bc0JJyzPU0/VZP78TgWuK48uXVrTt29L0TNKbY89Noz8k2TIkObstNOazJrljv5/SVVV0r//2qxc6Z/VAAAAAAAAAMCmp0gAAIB25vnnu2bIkDXp3n3dBtdHjGhqex3erdbWZNGiqvTq5Zsk/lxjY0WWLKnMK690zg03bJmHHqrNvvs2Fj0LAAAAAAAAAOiA3OoTAADamYULO73lnerfuFZX56/5vHt33dUjCxZ0zuc/v7joKaVz2WV9c/PNWyZJKitbc9hh9bnoorpiRwEAAAAAAAAAHZICCAAA2pmmpop06dK60fWuXVvbXod348UXO+fii7fOqFGrctxxK4qeUzqnnbY048bVp66uKvfe2yPr1iXNzf68AQAAAAAAAACbXmXRAwAAgL9NdXVr1qzZOC5evbqi7XX4Wy1cWJXPfGZgevRYlyuvnJeqqqIXlc8OOzRnzJjGHHvsylx77bw0NlZmwoSBafVHDgAAAAAAAADYxIT+AADQzvTtuzYLF25cYb9xbeut127uSbRzK1dW5tOfHpiVK6ty/fVz069fS9GT2oWPfKQ+zz5bnZde6lz0FAAAAAAAAACggxH6AwBAO7PLLqsze3aX1Ndv+Nf5p5+uSZJ84AOri5hFO7V6dUUmTBiQ2bO75Jpr5mbHHdcUPandaGp6/ado1Nf78QcAAAAAAAAAwKYl9AcAgHZm3Lj6tLRU5Oabt2i7tmZNRW67rWdGjlyV/v3d0Z93pqUlOeec/vnd72py5ZXzM2pUU9GTSmnx4o1D/ubm5M47e6a6el122ME31wAAAAAAAAAAm1anogcAAAB/m5EjmzJu3Mp84xtbZfHiqgwe3Jzbb++ZuXM756tfXVD0vFK58cYts2JFZerqXv+nz6RJtXnttdcff/KTy9Kjx7oi5xXussv65oEHumfs2PosW1aZO+/sscHrxxyzsqBl5XLRRf1SX1+ZvfZqTL9+a7NwYafcfXePzJrVNeedV5fa2taiJwIAAAAAAAAAHUzF9OnTFQkAANDOrF5dkW9+s0/uvrtnli+vzLBha/KFLyzK/vs3Fj2tVA4+eGjmzu38lq/9+tezsu227++ffvDJT26bJ57o9ravT58+YzOuKa977umRW2/tmRkzumbZsqrU1q7L8OFNOfXUZTnkkIai5wEAAAAAAAAAHZDQHwAAAAAAAAAAAAAASqSy6AEAAAAAAAAAAAAAAMCbhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJdKp6AEAANBetLa2ZtWqVUXPKLXW1tY0NTUlSaqrq1NRUVHwonJyTn+dM/rb1NTUOCMAAAAAAAAA6ECE/gAA8A6tWrUqo0aNKnoGwEaeeuqpdOvWregZAAAAAAAAAMAmUln0AAAAAAAAAAAAAAAA4E3u6A8AAO/CxIkLUl1dW/SM0lm+vC4TJmyfJJm4YGKqa6sLXlROy+uWZ8L2E5IkCxZMTK1z2khd3fJs/8YZTZyY2mpn9OcamprS74wzip4BAAAAAAAAALwHhP4AAPAuVFfXCv3fQlPTm2dSXVst9H8bTbVNbY9ra6uF/m+hdv0zqq4W+gMAAAAAAAAA7yuVRQ8AAAAAAAAAAAAAAADeJPQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIAS6VT0AAAA2JTWrKnIlVf2yZ139syKFZUZNmx1zjlncT784caip21Szc2rc9NNF2Xy5B+moWFpBg8ekZNPviS7735Y0dNKY1X9qtxx+R2Z+fjMzHxiZuqX1ufsiWfn4NMPLnpaaUydOjPf//6kTJr0+8yeXZc+fXpk3313ziWXnJyddx5Y9LzSeO6VV/KvP/lJfjtrVl5bujTdunbNrtttly8de2yO2muvoucBAAAAAAAAAB2QO/oDANChnHdev9xwQ68cddSKnH/+wlRVJWedNTDTplUXPW2T+ta3Ts9dd30jBxxwSs4888pUVlblkkvG5w9/eKToaaWxctHK/PTin2bO83MyZOSQoueU0r//++352c+m5JBDRuTKK8/MWWcdnoce+kP22OOL+f3vXy56Xmm8vHBhVjY15bSxY3PlmWfmwo99LEly9KWX5rr77y94HQAAAAAAAADQEbmjPwAAHcYzz1Tnnnt65txzF+bMM5cmSY49dkU++tHBueKKvvnJT14teOGmMWPGE3nkkZ/ktNMuz7HHfjFJctBBn8oXvrBbfvCDc3PZZY8WvLAcevXvle/N/156bdMrL0x7IV/a60tFTyqdf/qno/PjH/9junTp3HbtxBM/nA9+8JxcdtltufHGfyxwXXmM33PPjN9zzw2u/cP48dnzi1/MN+66K2cdfnhBywAAAAAAAACAjsod/QEA6DDuu697qqpac+KJy9uude3amhNOWJ6nnqrJ/Pkd4/tcH3vs1lRWVuXww89qu9alS3UOPfTMTJ/+WBYt6hjf0PC/1blr5/TaplfRM0ptzJhdNoj8k2SnnQZk+PDt8vzzcwpa1T5UVVVlu622yrKGhqKnAAAAAAAAAAAdkNAfAIAO4/nnu2bIkDXp3n3dBtdHjGhqe70jeOmlpzJgwM7p1q3nBtd32mnvP73+uwJW0VG0trZmwYLl2Wqrnn/9ze8zDU1NWbRiRV6cPz//eddduffJJ3PIiBFFzwIAAAAAAAAAOqCOcUtTAABIsnBhp/Tt27LR9Teu1dV1jL/+LlkyP7169d/o+hvXliyZt7kn0YH86EcPZu7cxbn44k8UPaV0/t/Eibn2/vuTJJWVlTl+n31y1ac/XfAqAAAAAAAAAKAj6hilEwAAJGlqqkiXLq0bXe/atbXt9Y5gzZpV6dx5459O0Llzddvr8G788Y9z8rnP/XdGjx6W004bW/Sc0jnnqKNywpgxmbdkSX76m9+kZd26rFm7tuhZAAAAAAAAAEAHVFn0AAAA2FSqq1uzZs3GMf/q1RVtr3cEXbrUpLl59UbXm5ub2l6Hv9Vrry3NkUdeki226JZbbz03VVVVRU8qnV223TaHjhyZT40dm59fcEHqm5py1Fe/mtbWjvG1BQAAAAAAAAAoD6E/AAAdRt++a7Nw4cZx8hvXtt66Y9x5u3fv/lm6dP5G19+41rv3gM09iXZu+fKGHHHEv2XZsobcd99FGTCgd9GT2oUTxozJ1BdeyIx584qeAgAAAAAAAAB0MEJ/AAA6jF12WZ3Zs7ukvn7Dv+Y+/fTrd7j/wAc2vgt+ezRkyO6ZN29GGhtXbHB9xozHkyRDh+5ewCraq6amNTnqqEszY8a8/Pzn52fXXbcrelK7sWr1619Tljc0FLwEAAAAAAAAAOhohP4AAHQY48bVp6WlIjffvEXbtTVrKnLbbT0zcuSq9O/fMe7oP2bMCVm3riX3339d27Xm5tV54IGJ2XnnfbLVVkJt3pmWlpaceOIVeeyx6bnlli9l9Ohdip5USnXLlm10rXnt2vxg8uTUdOmSXbfzZw4AAAAAAAAA2LQ6FT0AAAA2lZEjmzJu3Mp84xtbZfHiqgwe3Jzbb++ZuXM756tfXVD0vE1m5533yZgxH8uNN/5zli+vS//+O2bSpO+nrm52Pve57xY9r1R+cdUv0rCsIUvmLUmSTL17ahbPWZwkGX/2+NRuUVvkvML9v/93Q+66a2qOOmqvLFmyMjfeOHmD10899aBCdpXNZ665JisaG3PA8OEZ2Lt3Xlu2LD968MH8ce7cfP3009O9pqboiQAAAAAAAABAByP0BwCgQ/mP/3gt3/xmn9x1V88sX16ZYcPW5Jpr5mavvVYVPW2T+sIXfpAf//jCPPjgD1NfvzSDB4/I+ef/PMOHH1D0tFK544o7svDlhW3Pp9w2JVNum5IkOfDUA9/3of/vfvdSkuTuu6fm7runbvS60P91J374w/nur3+d/7rvvixeuTI9amqy5w475N8/9akcvffeRc8DAAAAAAAAADogoT8AAB1K166t+fKXF+XLX15U9JT3VJcu1Tn99Mtz+umXFz2l1K6bfV3RE0pt8uRLip7QLnxi//3zif33L3oGAAAAAAAAAPA+Uln0AAAAAAAAAAAAAAAA4E1CfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASqRT0QMAAKC9aG1tbXu8fHldmppqC1xTTsuX17U9XrZgWaq7Vxe4pryW1y1ve7xgwbJ0d04bqVv/jJYtS/dqZ/TnGlavbnu8/tcnAAAAAAAAAKD9q5g+fboaAAAA3oHFixdnzJgxRc8A2Mijjz6aPn36FD0DAAAAAAAAANhEKoseAAAAAAAAAAAAAAAAvKlT0QMAAKC9qK6ubns8adKC1NTUFrimnJYsqcv48dsnSSYtmJSa2pqCF5XTkrolGb/9+CTJggWTUuucNlJXtyTbv3FGkyaltsYZ/bmGVavSb+zYJBt+fQIAAAAAAAAA2j+hPwAAvEMVFRVtj2tqatOtm9D/z61a9eaZ1NTWpFtttwLXlNeq2lVtj2tra1LrnDZSu/4Z1dSktpsz+kvW//oEAAAAAAAAALR/lUUPAAAAAAAAAAAAAAAA3iT0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwDQYTQ0VORb3+qTM88cmL333iHDhu2c227rWfSszeK6676aESMqctxxuxU9pTSmTp6aERUj3vK/p6c8XfS8UnnyyT/k6KPPTu/e+6Vbt72z227H5Vvf+lHRs0rj9AsuSMWIEW/739wFC4qeCAAAAAAAAAB0MJ2KHgAAAJvK0qVVufrqPhkwoDnDhq3OE090K3rSZvHaa3Ny/fWXpqamtugppXTy50/Obntt+A0Qg3YcVNCa8rn//kdz1FFnZ9SoXXLhhZ9J9+41efHFOZkzR7z+hs987GM5dN99N7jW2tqaCf/2bxkycGAG9utX0DIAAAAAAAAAoKMS+gMA0GFsvXVLHnnkxfTt25Jnn+2aE04YXPSkzeIb3/hiRozYN+vWtWTp0kVFzymdPfbfI4efcHjRM0ppxYr6fOpT5+fIIw/Irbd+PZWVfujbWxk9cmRGjxy5wbVHnnwyjU1NOWX8+IJWAQAAAAAAAAAdmYoDAIAOo0uX1vTt21L0jM1q2rSH8j//c2vOPfebRU8ptYaVDVm7dm3RM0rnxz/+RRYsWJyvfvXsVFZWpqGhMevWrSt6Vrvw41/8IhUVFTlZ6A8AAAAAAAAAvAeE/gAA0E61tLTkssvOzvHH/5/svPMHi55TWhedcVFG9xydvar3ypljz8xz054relJp/OpXU9KzZ/fMnVuXYcOOSvfu+6Znz9H57Gf/LU1Nq4ueV1rNzc356f33Z8zuu2fIwIFFzwEAAAAAAAAAOqBORQ8AAADenVtuuSbz57+c6677VdFTSqlzl8459O8Ozf7j98+WW22ZWX+Yle9f8f2cvv/p+cGjP8gHRn2g6ImFmznzlaxduzbHHPP5nHnm8fna176QyZOn5dvf/nGWLVuZm276j6InltIvH300i5ctyynu5g8AAAAAAAAAvEeE/gAA0A4tW7Y4V199Uc4668L07t236DmltPuY3bP7mN3bno89emwOO+GwnDDihFz5z1fmmvuuKW5cSdTXN6axsSkTJnws3/rWeUmS448/NGvWNOfaa2/JxRd/LjvtNLjgleXz41/8Ip07dcrHP/KRoqcAAAAAAAAAAB1UZdEDAACAv923v31Bttiid04++eyip7Qrg3YclIOOOShTJ01NS0tL0XMKV1PTNUly0klHbHD95JNff/7YY09v9k1lV9/YmDsnTcpHxoxJny23LHoOAAAAAAAAANBBCf0BAKCdefnlmfnZz67LySd/PnV18zJ37uzMnTs7q1c3Ze3a5sydOzvLly8pemZpbbPdNmle05xVDauKnlK4AQO2TpL069dng+tbb/3686VLV2z2TWV3xwMPpLGpKacceWTRUwAAAAAAAACADkzoDwAA7Uxd3dysW7cul132+RxxxNC2/5599vG8/PKMHHHE0FxzzcVFzyytObPmpGt113Tr3q3oKYXbc89dkyRz59ZtcH3evNef9+3ba7NvKrsf3XNPunfrlqMPOqjoKQAAAAAAAABAB9ap6AEAAMDfZscdd8s3v3n7Rte//e0L0ti4Ml/+8pXZdtsdClhWLksWLknvvr03uDb96emZfNfk7HfEfqms9H3PH//44bnssu/mu9+9PQcfvE/b9euvvy2dOnXKQQftVeC68lm4ZEl+9fjjOWncuHSrqSl6DgmZSrEAACGLSURBVAAAAAAAAADQgQn9AQDoUG68ccusWFGZurrX/6o7aVJtXnvt9cef/OSy9Oixrsh5m0SvXlvl4IOP3ej6jTd+M0ne8rX3oy+d+KVU11Rn5JiR6b1178z6w6zcet2tqelWk3MuO6foeaUwatQH8vd/f1y+973bs3ZtSw48cM9Mnjwtt9xyf/75n8/MgAFbFz2xVG7+5S+zdu3anHLkkUVPAQAAAAAAAAA6OKE/AAAdyve+1ytz53Zue37//T1y//09kiRHH72iQ4T+vDMHH3tw7vnRPfnhN36YhhUN6dW3Vw49/tBM+MqEDNpxUNHzSuOaay7IoEHbZOLEO3P77b/O4MED8p//+aWcc84ni55WOj+6555s3bt3Dt1336KnAAAAAAAAAAAdXMX06dNbix4BAADtQWNjY0aNGpUkmTKlPt261Ra8qHwWL67L2LH9kiRT6qekW223gheV0+K6xRnbb2ySpL5+Smqd00bq6han3xtnNGVKars5oz/X0NiY7n/6poOnnnoq3ZwRAAAAAAAAAHQYlUUPAAAAAAAAAAAAAAAA3iT0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIp2KHgAAAO1Fa2tr2+MlS+qyalVtgWvKacmSurbHixcszqruqwpcU15L6pa0PV6wYHG6O6eN1K1/RosXp/sqZ/TnGtY7k/W/PgEAAAAAAAAA7V/F9OnT1QAAAPAOLF68OGPGjCl6BsBGHn300fTp06foGQAAAAAAAADAJlJZ9AAAAAAAAAAAAAAAAOBNnYoeAAAA7UV1dXXb44kTF6S6urbANeW0fHldJkzYPkkyccHEVNdW/5WPeH9aXrc8E7afkCRZsGBiap3TRurqlmf7N85o4sTUVjujP9fQ1JR+Z5yRZMOvTwAAAAAAAABA+yf0BwCAd6iioqLtcXV1rdD/LTQ1vXkm1bXVQv+30VTb1Pa4trZa6P8Watc/o+pqof9fsf7XJwAAAAAAAACg/assegAAAAAAAAAAAAAAAPAmoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJRIp6IHAADApvLMM11zxx1b5PHHazJ3budsuWVLRo5syjnnLMrQoc1Fz9uk5s2bmZtuujDPP/9IVq5ckr59B2X//U/Oscd+MV27dit6Xmm8+NsX86Pzf5Q/PvrHtLa2ZtjoYTntP07L0N2HFj1ts6uvX5XLL78jjz8+M088MTNLl9Zn4sSzc/rpB2/03ueffzX/+I8T88gjz6dLl0458sg9841vnJG+fbcoYPnmVb9qVS6/4448PnNmnpg5M0vr6zPx7LNz+sEbntMTM2bkhkmT8viMGXnm5ZeztqUlrbffXtBqAAAAAAAAAKCjcUd/AAA6jOuv75377++e0aMbc/75dfn4x5dn2rSaHH/84MyY0aXoeZvMokWv5txz98706VNyxBH/kDPP/GaGDRudn/zkK/n6108qel5pvPjki/mX/f4lr816LSd+5cR8/KKPZ/7M+bngwAsyd/rcoudtdosWrczFF/80zz8/JyNHDnnb982ZsygHHHBBXnhhfi699JR88YvH5J57fpvDDvvXrFnTsb5h5q0sWrkyF//0p3l+zpyMHDLkbd/3iyefzPW/+lUqKiqyfb9+m28gAAAAAAAAAPC+4I7+AAB0GKefvjRXXDE/XdZr+sePX5mjjhqc667rnSuueK24cZvQ5Mk/TEPDslx66SMZNGh4kuTww8/KunXrMnnyD1JfvzTdu/cqeGXxbrrwpnSp6ZLLHrssPfv0TJIceOqB+dzOn8uN/3JjvvyzLxe8cPPq379X5s//XrbZplemTXshe+31pbd836WX/iwNDU357W+vyKBBfZMke++9Uw477F9zww2TctZZh2/O2Ztd/169Mv9738s2vXpl2gsvZK8vvfU5fXbcuHz5uONS07Vr/uG66zJj3rzNvBQAAAAAAAAA6Mjc0R8AgA5jjz2aNoj8k2TIkObstNOazJrVce7o39i4Ikmy5ZYb3kW8V6/+qaysTKdOHed/6//GHx7+Q0YcOqIt8k+S3v17Z/iBwzPt59Oyqn5Vges2v65dO2ebbf76N4D87GeP5aMf/VBb5J8khx46MjvvPCA//elv3suJpdC1c+ds0+uvn1O/LbdMTdeum2ERAAAAAAAAAPB+JPQHAKBDa21NFi2qSq9eLUVP2WR22+2gJMlVV52Zl176XRYtejWPPHJzfvnL/8qRR34+1dW1xQ4siebVzelSs/E3PXTt1jVr16zNK79/pYBV5TZ37uLU1S3Phz6040av7b33TnnqqVkFrAIAAAAAAAAAeP/pVPQAAAB4L911V48sWNA5n//84qKnbDJ77DEuJ5/8b7n11kszdepdbddPOOH8nHLKJQUuK5eBwwZmxpQZaWlpSVVVVZKkeU1zZj4+M0myZO6SIueV0vz5S5Mk/ftvfEf7/v17ZcmS+qxe3ZyuXTtv7mkAAAAAAAAAAO8rQn8AADqsF1/snIsv3jqjRq3KccetKHrOJtW375AMH35A9t3379KjR5/89rf35Gc/uzS9em2T8eP/oeh5pTDu/47LtZ+9NlefeXWOO/e4rFu3LrdecmuW/ilmX71qdcELy2fVqjVJ8pYhf3V157b3CP0BAAAAAAAAAN5bQn8AADqkhQur8pnPDEyPHuty5ZXz8qcbuncIDz/8k/zXf52Vq6+eka222jZJMnr08WltXZcf/ODL2W+/k9KzZ5+CVxZv3IRxWfTqotx5+Z2Z9P1JSZIdP7Rjjj332Nz61VtT072m4IXlU1PTJUmyenXzRq81NTVv8B4AAAAAAAAAAN47lUUPAACATW3lysp8+tMDs3JlVa6/fm769WspetImdd9938n2249qi/zfsNdeR2f16sa89NJTBS0rn1O/emomLpiYrz781XzzmW/m8qmXp3Vda5JkwM4DCl5XPv3790qSzP/TTz1Y3/z5S9O7d3d38wcAAAAAAAAA2Azc0R8AgA5l9eqKTJgwILNnd8nEiXOy445rip60yS1btiDdu/fa6HpLS/Of/u/azT2p1Lr36p5d99u17fnTv3o6fbbtk4G7DCxwVTkNHNgnffv2zLRpL2z02hNPzMzuuw8tYBUAAAAAAAAAwPuPO/oDANBhtLQk55zTP7/7XU2uvHJ+Ro1qKnrSe2LAgJ0za9ZTmTt3xgbXH374plRWVmbIkBEFLSu/R25+JC9MfSFHnXNUKiv9c+it/N3fjc7Pfz4tr766qO3ar3/9TGbMmJePfWxMgcsAAAAAAAAAAN4/3NEfAIAO47LL+uaBB7pn7Nj6LFtWmTvv7LHB68ccs7KgZZvWscd+KU8+eW/OP3//jB//D+nRo0+mTft5nnzy3hx66P9J794Dip5YCs899Fx+evFPs/vhu6dHnx6ZPmV6Hpj4QEaNG5WPfuGjRc8rxFVX/SLLljVk3rwlSZK7756aOXMWJ0nOPnt8ttiiNv/yLyfkllsezdixF+YLX/ho6uubcvnld+SDHxycM844pMj5m81Vv/hFljU0ZN6SP53T1KmZs/hP5zR+fLaorc3LdXX54YMPJkmmvfhikuSSW25Jkgzu2zefPOigzT8cAAAAAAAAAOgwhP4AAHQYf/xj1yTJpEndM2lS941e7yih//DhB+RrX3s0N9/8r7nvvu9k5crF2XrroTnllK/muOPOLXpeafQe2DuVVZW54/I7smrlqmw9dOucfMnJOfqfjk5Vp6qi5xXiiivuyMsvL2x7ftttU3LbbVOSJKeeemC22KI22223VR588JL80z9NzHnn/TBdunTKkUfuma9//Yx07dq5qOmb1RV33JGXF653TlOm5LYpfzqnAw/MFrW1eamuLhf++McbfNwbzw8cPlzoDwAAAAAAAAD8rwj9AQDoMH74wzlFT9hsdt5571x44S+KnlFq/Xfon6/88itFzyiV2bOve0fvGz58UH75Pj672df99XM6aLfd0nr77ZthDQAAAAAAAADwflRZ9AAAAAAAAAAAAAAAAOBNQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEqkU9EDAACgvWhtbW17vHx5XZqaagtcU07Ll9e1PV62YFmqu1cXuKa8ltctb3u8YMGydHdOG6lb/4yWLUv3amf05xpWr257vP7XJwAAAAAAAACg/auYPn26GgAAAN6BxYsXZ8yYMUXPANjIo48+mj59+hQ9AwAAAAAAAADYRCqLHgAAAAAAAAAAAAAAALypU9EDAACgvaiurm57PGnSgtTU1Ba4ppyWLKnL+PHbJ0kmLZiUmtqagheV05K6JRm//fgkyYIFk1LrnDZSV7ck279xRpMmpbbGGf25hlWr0m/s2CQbfn0CAAAAAAAAANo/oT8AALxDFRUVbY9ramrTrZvQ/8+tWvXmmdTU1qRbbbcC15TXqtpVbY9ra2tS65w2Urv+GdXUpLabM/pL1v/6BAAAAAAAAAC0f5VFDwAAAAAAAAAAAAAAAN4k9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMA0GHMnNkln/98/xxyyJCMHLlj9tlnh5xyyrZ54IHaoqf9rzQ21ufqq7+SCRPGZb/9emfEiIrceecNG7xn3bp1ufPOG3L22UfnsMO2y9571+a443bLddddktWrm4oZvhk11jfm6q9cnQnjJmS/3vtlRMWI3HnDnRu979b/vjVnHHhGDup3UPbsumfGDR2XC8+4MHNnzy1g9eZVX9+Yr3zl6owbNyG9e++XiooRueEtzmh9zc3N2XXXY1NRMSJXXHHD5hlasPrGxnzl6qszbsKE9N5vv1SMGJEb7tz4nE6/4IJUjBix0X+7HH10AasBAAAAAAAAgI6mU9EDAABgU5k3r3MaGipz3HErsvXWLVm1qiL33989n/3swFx88YKceOLyoie+K0uXLsq1116c/v0HZdiwkZk6dfJG72lqasyFF56RESP2zcc+NiG9e2+dZ555LN/5zlfy+OO/zvXXP5CKiorNP34zWbpoaa69+Nr0H9Q/w0YOy9TJU9/yfX986o8ZOHRgDjr6oPTs1TNzX5qbn/33z/LQzx/KLU/fkq0HbL2Zl28+ixYtzcUXX5tBg/pn5Mhhmfw2Z7S+b3/7przyyvzNsK48Fi1dmouvvTaD+vfPyGHDMnnq259T1y5dcv2//usG17bo3v09XggAAAAAAAAAvB8I/QEA6DAOPLAhBx7YsMG1U09dluOPH5SJE3u129C/b9/+eeCB+dlqq23y3HPTctJJe230ns6du+QHP/hNdt99TNu1E074dAYMGNIW+++776Gbc/Zm1bd/3zww/4Fstc1WeW7aczlpr5Pe8n0XfOeCja4dfOzB+cSHPpG7f3B3zjzvzPd6amH69++b+fMfyDbbbJVp057LXm9zRm+oq1uciy++Nl/+8t/noouu3kwri9e/b9/Mf+CBbLPVVpn23HPZ66S3P6dOVVU59aMf3YzrAAAAAAAAAID3i8qiBwAAwHupqirp339tVq5sv3/17dKla7baapu/+J7OnbtsEPm/4eCDj0uSzJr1/HuyrSy6dO2SrbbZ6l197IAhA5IkK5et3JSTSqdr1y7Z5m84o/POuzLDhg3Oqace+R6uKp+uXbpkm63e+Tm1tLRkRX39e7gIAAAAAAAAAHg/ckd/AAA6nMbGijQ1VaS+vioPPFCbhx6qzRFHdOyI++0sXvxakmTLLd9dBN9RLVu8LC0tLXntlddyzcXXJEn2OWSfgleVxxNPPJvvf/+uPPLI91NRUVH0nNJqbGpKz9Gj09jUlF49e+akI47Iv//jP6Z7t25FTwMAAAAAAAAA2jmhPwAAHc5ll/XNzTdvmSSprGzNYYfV56KL6oodVZCJE/8j3bv3zH77HVH0lFI5dOChWbN6TZJkyz5b5rxvnZfRh40ueFU5tLa25uyzv5YTT/xIRo8emdmz5xY9qZT69+2bc884I3t84ANZt25d7vvNb/Kdm2/O0zNmZPJ3v5tOnfxzGwAAAAAAAAB495QHAAB0OKedtjTjxtWnrq4q997bI+vWJc3N77+7kv/3f1+aKVN+lfPP/0569tyy6Dml8p17v5PVTavz0vMv5ec3/jyrGlYVPak0brjhzjz77Au59dZvFD2l1L72hS9s8PwTRxyRnQcPzvnf/nZu/Z//ySeO8M01AAAAAAAAAMC7V1n0AAAA2NR22KE5Y8Y05thjV+baa+elsbEyEyYMTGtr0cs2n/vuuzlXXXVBjjvuzJx44meLnlM6e4/dO/sfsX8+9U+fytdv+Xqu+f+uyU1X3VT0rMKtWFGff/7nK/OlL52W7bbbpug57c4/fvKTqayszK+mTCl6CgAAAAAAAADQzgn9AQDo8D7ykfo8+2x1Xnqpc9FTNovHHvufnH/+p7L//kfmwguvKXpO6W23w3bZZdQuuedH9xQ9pXBXXPH9rFnTnBNPHJfZs+dm9uy5mTNnQZJk6dIVmT17btasaS54ZXnVVFenzxZbZMmKFUVPAQAAAAAAAADauU5FDwAAgPdaU1NFkqS+vipJx46Un3nm8ZxzznEZPvxDueKKn6ZTJ3/lfydWr1qdNavXFD2jcK+8Mj9Ll67I8OHHbfTapZden0svvT5PPfXT7L77LgWsK7+VDQ1ZtGxZ+vbqVfQUAAAAAAAAAKCdU/0AANBhLF5clT59Wja41tyc3Hlnz1RXr8sOO6wuaNnmMWvW8/mHfzgyAwYMyVVX/TzV1TVFTyqVtWvXpnFlY3r26rnB9WefeDYzn52ZI04+oqBl5fH5z5+cY489eINrdXVL8pnPXJzTTz8mxxwzNkOHDixoXXk0rV6d5rVr06O2doPr/3bttWltbc24D3+4oGUAAAAAAAAAQEch9AcAoMO46KJ+qa+vzF57NaZfv7VZuLBT7r67R2bN6przzqtLbW1r0RPftZtuuiorVy5LXd28JMnkyXdnwYI5SZKTTjo7lZWVmTDhI1mxYmlOP/1Leeihezb4+O222yEjR47e7Ls3p5uuuikrl61M3by6JMnkuydnwZwFSZKTzj4pra2tOWy7wzLuxHHZYfgOqamtycxnZ+aOiXek+xbd85kLP1Pg+s3jqqtuyrJlKzPvT2d0992TM+dPZ3T22Sdljz12zR577LrBx8yePTdJMnz4Dht9E0BHddVNN2XZypWZV/enc5o8OXMW/OmcTjopS1esyKiPfzwnHXFEdhk6NEnyy0cfzS8efjjjPvzhHDN2bGHbAQAAAAAAAICOoWL69Ontt3YCAID13HNPj9x6a8/MmNE1y5ZVpbZ2XYYPb8qppy7LIYc0/K8/f2NjY0aNGpUkmTKlPt261f6Vj9h0xo0bknnzXn7L1+6996UkyRFHDH3bjz/66NNyySU3vBfTNrB4cV3Gju2XJJlSPyXdaru957/mG8YNGZd5L897y9fufenebD1g63zj3G9k6qSpmTd7XppWNWXrAVtnn0P3yVkXnJWBQzbfneoX1y3O2H6vx+D19VNSu5nOaciQcXn5bc7opZfuzZC3OIPZs+dm6NAjcvnl/5QvfvH093jhm+rqFqffG2c0ZUpqu22+30tDxo3Ly/Pe5pzuvTdb9uiRsy+7LFOeeSbz6urSsm5ddtxuu5xy5JH54mmnpXPnzptlZ0NjY7rvu2+S5Kmnnkq3zXhGAAAAAAAAAMB7S+gPAADvUJGhf3tRZOjfnhQV+rcnRYb+7YXQHwAAAAAAAAA6rsqiBwAAAAAAAAAAAAAAAG8S+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCKdih4AAADt0apVDUVPKKX1z2VVw6oCl5Tb+mfT4Jze0vrn0rDKGb0V5wIAAAAAAAAAHVfF9OnTW4seAQAA7UFjY2NGjRpV9AyAjTz11FPp1q1b0TMAAAAAAAAAgE2ksugBAAAAAAAAAAAAAADAm9zRHwAA3qHW1tasWrWq6Bml1tramqampiRJdXV1KioqCl5UTs7pr3NGf5uamhpnBAAAAAAAAAAdiNAfAAAAAAAAAAAAAABKpLLoAQAAAAAAAAAAAAAAwJuE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoESE/gAAAAAAAAAAAAAAUCJCfwAAAAAAAAAAAAAAKBGhPwAAAAAAAAAAAAAAlIjQHwAAAAAAAAAAAAAASkToDwAAAAAAAAAAAAAAJSL0BwAAAAAAAAAAAACAEhH6AwAAAAAAAAAAAABAiQj9AQAAAAAAAAAAAACgRIT+AAAAAAAAAAAAAABQIkJ/AAAAAAAAAAAAAAAoEaE/AAAAAAAAAAAAAACUiNAfAAAAAAAAAAAAAABKROgPAAAAAAAAAAAAAAAlIvQHAAAAAAAAAAAAAIASEfoDAAAAAAAAAAAAAECJCP0BAAAAAAAAAAAAAKBEhP4AAAAAAAAAAAAAAFAiQn8AAAAAAAAAAAAAACgRoT8AAAAAAAAAAAAAAJSI0B8AAAAAAAAAAAAAAEpE6A8AAAAAAAAAAAAAACUi9AcAAAAAAAAAAAAAgBIR+gMAAAAAAAAAAAAAQIkI/QEAAAAAAAAAAAAAoET+f52mSLGwG6BDAAAAAElFTkSuQmCC", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the three max_common_vector cases\n", + "draw_composite(\n", + " [Layout(16, 1), Layout((4, 4), (1, 4)), Layout((4, 4), (4, 1))],\n", + " titles=[\"16:1\\n(identity)\",\n", + " \"(4,4):(1,4)\\n(col-major = identity!)\",\n", + " \"(4,4):(4,1)\\n(row-major ≠ identity)\"],\n", + " main_title=\"max_common_vector — comparing offset sequences\",\n", + " colorize=True,\n", + " arrangement=\"grid:2x2\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 651, + "metadata": { + "output": { + "id": 1722139692089743, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "weakly_congruent(6, (2, 3)) = True\n", + " scalar a matches any b structure ✓\n", + "\n", + "weakly_congruent((2, 3), 6) = False\n", + " tuple a needs corresponding structure in b ✗\n", + "\n", + "weakly_congruent((2, (3, 4)), (5, 6)) = False\n", + " a's mode 1 is nested (3,4) but b's is flat 6 ✗\n" + ] + } + ], + "source": [ + "# weakly_congruent() — hierarchical profile matching\n", + "print(\"weakly_congruent(6, (2, 3)) =\", weakly_congruent(6, (2, 3)))\n", + "print(\" scalar a matches any b structure ✓\\n\")\n", + "\n", + "print(\"weakly_congruent((2, 3), 6) =\", weakly_congruent((2, 3), 6))\n", + "print(\" tuple a needs corresponding structure in b ✗\\n\")\n", + "\n", + "print(\"weakly_congruent((2, (3, 4)), (5, 6)) =\", weakly_congruent((2, (3, 4)), (5, 6)))\n", + "print(\" a's mode 1 is nested (3,4) but b's is flat 6 ✗\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Putting it together:** When CuTe copies data between layouts, it calls\n", + "`max_common_vector(src, dst)` to choose the widest safe vector instruction.\n", + "Before tiling a layout, it checks `compatible` (do the sizes decompose\n", + "correctly?) and `weakly_congruent` (does the tiler's nesting match the\n", + "data's structure?). These are the *type checks* of layout algebra — they\n", + "catch invalid compositions before they produce wrong results." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## §3.5.1 Logical Product\n", + "\n", + "In GPU kernels, a common pattern is: define a small tile pattern (e.g., how\n", + "one thread accesses a 4-element fragment), then **replicate** it across a\n", + "larger space (e.g., across all warps in a thread block, or across all tiles in\n", + "shared memory).\n", + "\n", + "`logical_product(A, B)` does exactly this — it places `size(B)` non-overlapping\n", + "copies of `A`'s pattern, using `complement` to find where each replica goes:\n", + "\n", + "```\n", + "logical_product(A, B) = Layout(A, compose(complement(A, size(A) * cosize(B)), B))\n", + "```\n", + "\n", + "`blocked_product` and `raked_product` are two common specializations:\n", + "- **`blocked_product(A, B)`** — replicas are placed in contiguous blocks:\n", + " `[A₀ A₁ A₂ A₃ | A₀ A₁ A₂ A₃]`\n", + "- **`raked_product(A, B)`** — replicas are interleaved:\n", + " `[A₀ A₀ | A₁ A₁ | A₂ A₂ | A₃ A₃]`" + ] + }, + { + "cell_type": "code", + "execution_count": 652, + "metadata": { + "output": { + "id": 1262281808821931, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A = 4 : 1\n", + "B = 3 : 1\n", + "logical_product(A, B) = (4, 3) : (1, 4)\n", + "\n", + "logical_product(4 : 1, 3 : 1)\n", + " = Layout(A, compose(complement(A, size(A)*size(B)), B))\n", + "\n", + " A = 4 : 1\n", + " B = 3 : 1\n", + " size(A) * size(B) = 12\n", + " complement(A, 12) = 3 : 4\n", + " compose(complement, B) = 3 : 4\n", + " Layout(A, 3 : 4) = (4, 3) : (1, 4)\n", + "\n", + " result = (4, 3) : (1, 4)\n", + "\n", + "Verification — offsets per replica:\n", + " Replica 0: [0, 1, 2, 3]\n", + " Replica 1: [4, 5, 6, 7]\n", + " Replica 2: [8, 9, 10, 11]\n" + ] + } + ], + "source": [ + "# Basic logical product\n", + "A = Layout(4, 1)\n", + "B = Layout(3, 1)\n", + "P = logical_product(A, B)\n", + "print(f\"A = {A}\")\n", + "print(f\"B = {B}\")\n", + "print(f\"logical_product(A, B) = {P}\\n\")\n", + "\n", + "_ = explain(logical_product, A, B)\n", + "\n", + "print(f\"\\nVerification — offsets per replica:\")\n", + "for b in range(size(B)):\n", + " offsets = [P(a, b) for a in range(size(A))]\n", + " print(f\" Replica {b}: {offsets}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 653, + "metadata": { + "output": { + "id": 985952563760789, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the product\n", + "draw_composite(\n", + " [A, P],\n", + " titles=[f\"A = {A}\", f\"logical_product(A, B) = {P}\"],\n", + " main_title=f\"Replicating A={A} by B={B}\",\n", + " colorize=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 654, + "metadata": { + "output": { + "id": 1268331948126170, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "blocked_product(4 : 1, 2 : 1) = ((4, 2),) : ((1, 4),)\n", + " offsets: [0, 1, 2, 3, 4, 5, 6, 7]\n", + "\n", + "raked_product(4 : 1, 2 : 1) = ((2, 4),) : ((4, 1),)\n", + " offsets: [0, 4, 1, 5, 2, 6, 3, 7]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# blocked_product vs raked_product\n", + "A = Layout(4, 1)\n", + "B = Layout(2, 1)\n", + "bp = blocked_product(A, B)\n", + "rp = raked_product(A, B)\n", + "\n", + "print(f\"blocked_product({A}, {B}) = {bp}\")\n", + "print(f\" offsets: {[bp(i) for i in range(size(bp))]}\\n\")\n", + "print(f\"raked_product({A}, {B}) = {rp}\")\n", + "print(f\" offsets: {[rp(i) for i in range(size(rp))]}\")\n", + "\n", + "draw_composite(\n", + " [bp, rp],\n", + " titles=[f\"blocked_product = {bp}\", f\"raked_product = {rp}\"],\n", + " main_title=\"Blocked vs Raked product\",\n", + " colorize=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 655, + "metadata": { + "output": { + "id": 921026444058654, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A = (2, 2) : (1, 2) (2×2 tile)\n", + "B = (3, 4) : (1, 3) (3×4 grid)\n", + "logical_product(A, B) = ((2, 2), (3, 4)) : ((1, 2), (4, 12))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 2D product — replicate a 2×2 tile across a 3×4 grid\n", + "A = Layout((2, 2), (1, 2))\n", + "B = Layout((3, 4), (1, 3))\n", + "P = logical_product(A, B)\n", + "print(f\"A = {A} (2×2 tile)\")\n", + "print(f\"B = {B} (3×4 grid)\")\n", + "print(f\"logical_product(A, B) = {P}\")\n", + "\n", + "draw_layout(P, title=f\"logical_product({A}, {B})\",\n", + " colorize=True, flatten_hierarchical=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## §3.5.2 Logical Divide — Complement-Based Construction\n", + "\n", + "Divide and product are **duals**: both are built from `complement`, but they\n", + "compose it differently. Understanding the shared construction makes the\n", + "entire algebra click:\n", + "\n", + "```\n", + "logical_divide(A, T) = compose(A, Layout(T, complement(T, size(A))))\n", + " ───────────────────────────────────────────\n", + " \"Bundle T with its complement, then apply A\"\n", + "\n", + "logical_product(A, B) = Layout(A, compose(complement(A, size(A) * cosize(B)), B))\n", + " ─────────────────────────────────────────────────────────\n", + " \"Find A's complement in a larger space, apply B to it\"\n", + "```\n", + "\n", + "In both cases, `complement` finds the \"other\" coordinates — the ones not covered\n", + "by the given layout. **Divide** bundles a tiler with its complement to split data\n", + "into tiles; **product** maps a replication pattern onto the complement to place copies." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Morton (Z-order) swizzle via `blocked_product`\n", + "\n", + "The **Morton curve** (Z-order) is a space-filling curve that maps 2D coordinates\n", + "to 1D by interleaving the bits of row and column indices. GPUs use Morton order\n", + "for texture memory because it preserves 2D locality — nearby pixels in both\n", + "dimensions map to nearby addresses, unlike row-major which only preserves locality\n", + "along one axis.\n", + "\n", + "In CuTe, the Morton layout is simply **iterated `blocked_product`** of the\n", + "elementary 2×2 Z-pattern `(2,2):(1,2)`:\n", + "\n", + "- `blocked_product(tile, tile)` → 4×4 Morton\n", + "- `blocked_product(tile, blocked_product(tile, tile))` → 8×8 Morton\n", + "\n", + "Each level of `blocked_product` replicates the previous Z-pattern into a 2×2\n", + "grid of copies, producing the next level of the fractal. The hierarchy\n", + "boundaries in the visualization below show the recursive structure.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 656, + "metadata": { + "output": { + "id": 926335483346252, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tile = (2, 2) : (1, 2)\n", + "morton_4x4 = ((2, 2), (2, 2)) : ((1, 4), (2, 8))\n", + "morton_8x8 = ((2, (2, 2)), (2, (2, 2))) : ((1, (4, 16)), (2, (8, 32)))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Morton (Z-order) curve via iterated blocked_product\n", + "tile = Layout((2, 2), (1, 2)) # 2×2 Z-pattern\n", + "morton_4x4 = blocked_product(tile, tile)\n", + "morton_8x8 = blocked_product(tile, blocked_product(tile, tile))\n", + "\n", + "print(f\"tile = {tile}\")\n", + "print(f\"morton_4x4 = {morton_4x4}\")\n", + "print(f\"morton_8x8 = {morton_8x8}\")\n", + "\n", + "# Show the recursive structure with hierarchy boundaries\n", + "draw_composite(\n", + " [(tile, {\"flatten_hierarchical\": True}),\n", + " (morton_4x4, {\"flatten_hierarchical\": False}),\n", + " (morton_8x8, {\"flatten_hierarchical\": False})],\n", + " titles=[\"2×2 tile\", \"4×4 Morton\", \"8×8 Morton\"],\n", + " main_title=\"Morton (Z-order) curve — blocked_product(tile, tile, ...)\",\n", + " colorize=True,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 657, + "metadata": { + "output": { + "id": 950811710651219, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A = 16 : 1\n", + "T = 4 : 1\n", + "complement(T, 16) = 4 : 4\n", + "\n", + "Layout(T, complement) = (4, 4) : (1, 4)\n", + "compose(A, bundled) = (4, 4) : (1, 4)\n", + "\n", + "logical_divide(A, T) = (4, 4) : (1, 4)\n", + "✓ Manual construction matches logical_divide\n", + "\n", + "logical_divide(16 : 1, 4 : 1)\n", + " = compose(L, Layout(T, complement(T, size(L))))\n", + "\n", + " L = 16 : 1\n", + " T = 4 : 1\n", + " size(L) = 16\n", + " complement(T, 16) = 4 : 4\n", + " Layout(T, complement) = (4, 4) : (1, 4)\n", + " compose(L, (4, 4) : (1, 4)) = (4, 4) : (1, 4)\n", + "\n", + " result = (4, 4) : (1, 4)\n" + ] + } + ], + "source": [ + "# Step-by-step logical_divide construction\n", + "A = Layout(16, 1)\n", + "T = Layout(4, 1)\n", + "\n", + "C = complement(T, size(A))\n", + "print(f\"A = {A}\")\n", + "print(f\"T = {T}\")\n", + "print(f\"complement(T, {size(A)}) = {C}\\n\")\n", + "\n", + "bundled = Layout(T, C)\n", + "print(f\"Layout(T, complement) = {bundled}\")\n", + "\n", + "result = compose(A, bundled)\n", + "print(f\"compose(A, bundled) = {result}\\n\")\n", + "\n", + "expected = logical_divide(A, T)\n", + "print(f\"logical_divide(A, T) = {expected}\")\n", + "assert functionally_equal(result, expected), \"Construction mismatch!\"\n", + "print(\"✓ Manual construction matches logical_divide\\n\")\n", + "\n", + "_ = explain(logical_divide, A, T)" + ] + }, + { + "cell_type": "code", + "execution_count": 658, + "metadata": { + "output": { + "id": 796202300209294, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the construction steps\n", + "draw_composite(\n", + " [T, C, bundled, result],\n", + " titles=[f\"T = {T}\", f\"complement(T,16) = {C}\",\n", + " f\"Layout(T, C) = {bundled}\", f\"compose(A, ·) = {result}\"],\n", + " main_title=\"Logical divide construction: A=16:1, T=4:1\",\n", + " colorize=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 659, + "metadata": { + "output": { + "id": 26473942522257096, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Start: A = 4 : 1\n", + "Product: logical_product(A, 4 : 1) = (4, 4) : (1, 4)\n", + "Divide: logical_divide(P, A) = (4, 4) : (1, 4)\n", + "\n", + "Product produces 16 elements in 4 replicas of 4\n", + "Divide recovers the tiled structure: 4 intile × 4 oftile\n" + ] + } + ], + "source": [ + "# Divide ↔ Product roundtrip\n", + "A = Layout(4, 1)\n", + "B = Layout(4, 1)\n", + "\n", + "P = logical_product(A, B)\n", + "print(f\"Start: A = {A}\")\n", + "print(f\"Product: logical_product(A, {B}) = {P}\")\n", + "\n", + "D = logical_divide(P, A)\n", + "print(f\"Divide: logical_divide(P, A) = {D}\")\n", + "print(f\"\\nProduct produces {size(P)} elements in {size(B)} replicas of {size(A)}\")\n", + "print(f\"Divide recovers the tiled structure: {size(mode(D, 0))} intile × {size(mode(D, 1))} oftile\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "The six applications above all derive from the same small set of algebra primitives.\n", + "The unifying concept is **`complement`** — given a layout's coverage pattern,\n", + "find the residual coordinates that complete the index space:\n", + "\n", + "| Application | Key Operation | What complement does |\n", + "|---|---|---|\n", + "| Partitioning (§3.3.4) | `Layout(T, complement(T, N))` | Finds per-thread values from thread layout |\n", + "| Tiling (§3.3.5) | `logical_divide(D, T)` | Finds oftile coords from intile shape |\n", + "| Vectorization (§3.4.2) | `upcast`, `downcast`, `contiguity` | (Uses complement indirectly via `max_common_vector`) |\n", + "| Admissibility (§3.4.4) | `max_common_vector`, `compatible` | Measures shared contiguous structure |\n", + "| Logical Product (§3.5.1) | `logical_product(A, B)` | Finds non-overlapping placement for replicas |\n", + "| Logical Divide (§3.5.2) | `compose(A, Layout(T, complement(...)))` | Dual of product — partitions instead of replicating |\n", + "\n", + "These operations compose naturally in a real GPU kernel:\n", + "1. **Partition** data across threads with a TV layout (§3.3.4)\n", + "2. **Tile** each thread's portion for shared memory and registers (§3.3.5)\n", + "3. **Vectorize** the innermost tile for wide loads/stores (§3.4.2)\n", + "4. **Check admissibility** before applying each transform (§3.4.4)\n", + "5. **Replicate** a small atom pattern to build larger tiles (§3.5.1)\n", + "\n", + "This compositional approach — building complex GPU data layouts from simple,\n", + "verifiable algebraic primitives — is the core insight of CuTe." + ] + } + ], + "metadata": { + "fileHeader": "", + "fileUid": "1fc79d3d-1064-4ee7-92b5-ce1ef0ec9b9c", + "isAdHoc": false, + "kernelspec": { + "display_name": "jld-dev (conda)", + "language": "python", + "name": "conda_jld-dev" + }, + "language_info": { + "name": "plaintext" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/tensor.py b/examples/tensor.py new file mode 100644 index 0000000..c538013 --- /dev/null +++ b/examples/tensor.py @@ -0,0 +1,333 @@ +#!/usr/bin/env python3 +# MIT License +# +# Copyright (c) 2026 Meta Platforms, Inc. and affiliates. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +"""Tensor Storage Examples — data-backed tensors. + +Demonstrates attaching storage to a Tensor so that coordinates return +actual data elements, writes go through the layout mapping, and +draw_layout auto-labels cells with data values. + +Run: + python tensor.py + +See also: + layouts.py — pure algebraic layout examples (no dependencies) + viz.py — visualization examples (requires matplotlib) + viz.ipynb — Jupyter notebook gallery +""" + +from pathlib import Path +import sys + +# Prefer the local repo sources when running this script from a checkout. +REPO_ROOT = Path(__file__).resolve().parents[1] +SRC_DIR = REPO_ROOT / "src" +if str(SRC_DIR) not in sys.path: + sys.path.insert(0, str(SRC_DIR)) + +from tensor_layouts import * +from tensor_layouts.viz import draw_layout, draw_composite + + +def setup_output_dir(name: str = "examples_output") -> Path: + output = Path(name) + output.mkdir(parents=True, exist_ok=True) + return output + + +# ============================================================================= +# Section 1: Attaching Storage +# ============================================================================= + +def example_storage(): + """Attach storage to a Tensor for element-level access. + + Without storage, tensor[i, j] returns the raw memory offset. + With storage, tensor[i, j] returns data[offset] — the actual element. + """ + print("\n" + "=" * 60) + print("1. Attaching Storage") + print("=" * 60) + + layout = Layout((4, 8), (8, 1)) # row-major 4x8 + + # --- Algebraic (no storage) --- + t_alg = Tensor(layout) + print(f" Algebraic: t[2, 3] = {t_alg[2, 3]} (raw offset)") + + # --- Data-backed --- + buf = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345") + t = Tensor(layout, data=buf) + print(f" With data: t[2, 3] = {t[2, 3]!r} (data[{t(2, 3)}])") + print(f" t(2, 3) still returns the offset: {t(2, 3)}") + + # Storage can be larger than the layout's codomain + big_buf = list(range(100)) + t_big = Tensor(layout, data=big_buf) + print(f"\n Storage length {len(big_buf)} >= cosize {cosize(layout)}: OK") + + # Storage too small raises ValueError + try: + Tensor(layout, data=[0, 1, 2]) + except ValueError as e: + print(f" Too small: {e}") + + +# ============================================================================= +# Section 2: Reading Through Coordinates +# ============================================================================= + +def example_reading(): + """Access elements using logical coordinates. + + The layout maps (row, col) to a flat offset; storage provides the + value at that offset. This is how CuTe's Tensor works: the layout + defines the access pattern, the storage holds the data. + """ + print("\n" + "=" * 60) + print("2. Reading Through Coordinates") + print("=" * 60) + + # Row-major: offset(i, j) = 8*i + j + row_major = Layout((4, 8), (8, 1)) + buf = list(range(32)) + t = Tensor(row_major, data=buf) + + print(f" Row-major layout: {row_major}") + print(f" Row 0: {[t[0, j] for j in range(8)]}") + print(f" Row 1: {[t[1, j] for j in range(8)]}") + print(f" Col 0: {[t[i, 0] for i in range(4)]}") + + # Column-major: offset(i, j) = i + 4*j + col_major = Layout((4, 8), (1, 4)) + t2 = Tensor(col_major, data=buf) + print(f"\n Col-major layout: {col_major}") + print(f" Row 0: {[t2[0, j] for j in range(8)]}") + print(f" Col 0: {[t2[i, 0] for i in range(4)]}") + + # Same data, different arrangement — this is the power of layouts + print(f"\n Same data, different layouts:") + print(f" row_major[1, 2] = {t[1, 2]} (data[{t(1, 2)}])") + print(f" col_major[1, 2] = {t2[1, 2]} (data[{t2(1, 2)}])") + + +# ============================================================================= +# Section 3: Writing Through Coordinates +# ============================================================================= + +def example_writing(): + """Write to storage through logical coordinates. + + tensor[i, j] = val writes to data[offset], where offset is computed + by the layout. This lets you populate storage using whichever + coordinate system the layout defines. + """ + print("\n" + "=" * 60) + print("3. Writing Through Coordinates") + print("=" * 60) + + layout = Layout((4, 8), (8, 1)) + buf = [0] * 32 + t = Tensor(layout, data=buf) + + # Write sequential values through row-major coordinates + for i in range(4): + for j in range(8): + t[i, j] = i * 10 + j + + print(f" After writing i*10+j through row-major:") + for i in range(4): + print(f" Row {i}: {[t[i, j] for j in range(8)]}") + + print(f"\n Underlying storage (first 16): {buf[:16]}") + + +# ============================================================================= +# Section 4: View Semantics (Slicing Shares Data) +# ============================================================================= + +def example_views(): + """Slicing produces sub-Tensors that share storage. + + Just like numpy views, writing through a sub-Tensor modifies the + same underlying buffer. This is how CuTe's Tensor slicing works: + the sub-Tensor gets a new layout and accumulated offset, but the + pointer (data reference) stays the same. + """ + print("\n" + "=" * 60) + print("4. View Semantics") + print("=" * 60) + + buf = list(range(32)) + t = Tensor(Layout((4, 8), (8, 1)), data=buf) + + # Slice row 2 + row2 = t[2, :] + print(f" t[2, :] = {row2}") + print(f" row2[3] = {row2[3]}") + print(f" t[2, 3] = {t[2, 3]} (same value)") + print(f" row2.data is t.data: {row2.data is t.data}") + + # Write through the slice + row2[3] = 999 + print(f"\n After row2[3] = 999:") + print(f" t[2, 3] = {t[2, 3]} (visible through parent)") + print(f" buf[{t(2, 3)}] = {buf[t(2, 3)]} (visible in raw buffer)") + + # Chained slicing: tensor[i, :][j] == tensor[i, j] + print(f"\n Chained slice consistency:") + for i in range(4): + for j in range(8): + assert t[i, :][j] == t[i, j] + print(f" t[i, :][j] == t[i, j] for all (i, j): OK") + + +# ============================================================================= +# Section 5: Swapping Storage +# ============================================================================= + +def example_swap(): + """The data property is writable — swap storage without rebuilding. + + Existing sub-Tensors keep their reference to the old storage. + This is the same tradeoff numpy makes with ndarray.data. + """ + print("\n" + "=" * 60) + print("5. Swapping Storage") + print("=" * 60) + + layout = Layout((4, 8), (8, 1)) + buf1 = list(range(32)) + buf2 = list(range(100, 132)) + + t = Tensor(layout, data=buf1) + row = t[2, :] + print(f" Before swap: t[0, 0] = {t[0, 0]}, row[0] = {row[0]}") + + t.data = buf2 + print(f" After swap: t[0, 0] = {t[0, 0]}, row[0] = {row[0]}") + print(f" (row still references old storage)") + + # Remove storage entirely + t.data = None + print(f" After t.data = None: t[0, 0] = {t[0, 0]} (offset, no data)") + + +# ============================================================================= +# Section 6: Two Layouts, One Buffer +# ============================================================================= + +def example_two_layouts(): + """Attach the same storage to two Tensors with different layouts. + + This demonstrates the core idea: the layout determines the mapping + from coordinates to physical positions, but the data is shared. + """ + print("\n" + "=" * 60) + print("6. Two Layouts, One Buffer") + print("=" * 60) + + buf = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345") + + row_major = Tensor(Layout((4, 8), (8, 1)), data=buf) + col_major = Tensor(Layout((4, 8), (1, 4)), data=buf) + + print(f" Same buffer viewed through two layouts:") + print(f" Row-major [0,:]: {''.join(str(row_major[0, j]) for j in range(8))}") + print(f" Col-major [0,:]: {''.join(str(col_major[0, j]) for j in range(8))}") + print() + print(f" Row-major [1,0] = {row_major[1, 0]!r} (data[8])") + print(f" Col-major [1,0] = {col_major[1, 0]!r} (data[1])") + + +# ============================================================================= +# Section 7: Auto-Labeling in draw_layout +# ============================================================================= + +def example_auto_label(output: Path): + """draw_layout auto-labels cells with data values. + + When a Tensor with storage is passed to draw_layout, cells show + data values instead of raw offsets. Override with cell_labels="offset" + or cell_labels=False. + """ + print("\n" + "=" * 60) + print("7. Auto-Labeling in draw_layout") + print("=" * 60) + + layout = Layout((4, 8), (8, 1)) + buf = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345") + t = Tensor(layout, data=buf) + + # Auto-label: cells show A, B, C, ... + draw_layout(t, output / "tensor_data_auto.svg", + title="Auto-labeled from data") + print(f" tensor_data_auto.svg — cells show data values") + + # Override: show raw offsets + draw_layout(t, output / "tensor_data_offsets.svg", + title="cell_labels='offset'", cell_labels="offset") + print(f" tensor_data_offsets.svg — cells show offsets") + + # Override: no labels + draw_layout(t, output / "tensor_data_nolabels.svg", + title="cell_labels=False", colorize=True, cell_labels=False) + print(f" tensor_data_nolabels.svg — no cell text") + + # Side-by-side: same data, two layouts + row_t = Tensor(Layout((4, 8), (8, 1)), data=buf) + col_t = Tensor(Layout((4, 8), (1, 4)), data=buf) + draw_composite([row_t, col_t], + output / "tensor_data_compare.svg", + titles=["Row-major", "Col-major"], + main_title="Same data, different layouts") + print(f" tensor_data_compare.svg — row vs col-major, same data") + + +# ============================================================================= +# Main +# ============================================================================= + +def main(): + """Run all Tensor storage examples.""" + output = setup_output_dir() + + print("=" * 70) + print("Tensor Storage Examples") + print("=" * 70) + + example_storage() + example_reading() + example_writing() + example_views() + example_swap() + example_two_layouts() + example_auto_label(output) + + print("\n" + "=" * 70) + print("All examples completed.") + print("=" * 70) + + +if __name__ == "__main__": + main() diff --git a/examples/viz.ipynb b/examples/viz.ipynb index c7bcd73..62b043e 100644 --- a/examples/viz.ipynb +++ b/examples/viz.ipynb @@ -1,1037 +1,1164 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# CuTe Layout Visualization Examples\n", - "\n", - "This notebook demonstrates the visualization capabilities of the layouts library,\n", - "following examples from NVIDIA's CuTe (CUDA Templates) documentation.\n", - "\n", - "All visualizations render inline — no files are written to disk.\n", - "\n", - "**Reference:** [CuTe Documentation](https://github.com/NVIDIA/cutlass/blob/main/media/docs/cpp/cute/)\n", - "\n", - "**Reference:** [MMA Atom Documentation](https://github.com/NVIDIA/cutlass/blob/main/media/docs/cpp/cute/0t_mma_atom.md)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": "import warnings\nwarnings.filterwarnings(\"ignore\", message=\"findfont\")" - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "output": { - "id": 1277541074276700, - "loadingStatus": "loaded" - } - }, - "outputs": [], - "source": [ - "from tensor_layouts import *\n", - "from tensor_layouts.viz import *\n", - "from tensor_layouts.layout_utils import *\n", - "from tensor_layouts.atoms_nv import *\n", - "from tensor_layouts.atoms_amd import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Basic 2D Layouts\n", - "\n", - "A CuTe Layout maps logical coordinates to memory offsets via `shape` and `stride`.\n", - "\n", - "- **Row-major** `(M,N):(N,1)` — consecutive elements in each row are adjacent in memory\n", - "- **Column-major** `(M,N):(1,M)` — consecutive elements in each column are adjacent" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "output": { - "id": 1550310722733610, - "loadingStatus": "loaded" - } - }, - "outputs": [ + "cells": [ { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CuTe Layout Visualization Examples\n", + "\n", + "This notebook demonstrates the visualization capabilities of the layouts library,\n", + "following examples from NVIDIA's CuTe (CUDA Templates) documentation.\n", + "\n", + "All visualizations render inline — no files are written to disk.\n", + "\n", + "**Reference:** [CuTe Documentation](https://github.com/NVIDIA/cutlass/blob/main/media/docs/cpp/cute/)\n", + "\n", + "**Reference:** [MMA Atom Documentation](https://github.com/NVIDIA/cutlass/blob/main/media/docs/cpp/cute/0t_mma_atom.md)" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Row-major 4×3: offset(i,j) = i*3 + j\n", - "draw_layout(Layout((4, 3), (3, 1)), title=\"Row-Major (4,3):(3,1)\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "output": { - "id": 805509571956944, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\", message=\"findfont\")" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Column-major 4×3: offset(i,j) = i + j*4\n", - "draw_layout(Layout((4, 3), (1, 4)), title=\"Col-Major (4,3):(1,4)\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "output": { - "id": 798884306577558, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 2, + "metadata": { + "output": { + "id": 1277541074276700, + "loadingStatus": "loaded" + } + }, + "outputs": [], + "source": [ + "from tensor_layouts import *\n", + "from tensor_layouts.viz import *\n", + "from tensor_layouts.layout_utils import *\n", + "from tensor_layouts.atoms_nv import *\n", + "from tensor_layouts.atoms_amd import *" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# 8×8 row-major with rainbow coloring\n", - "draw_layout(Layout((8, 8), (8, 1)), title=\"Row-Major (8,8):(8,1)\", colorize=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. Hierarchical Layouts\n", - "\n", - "CuTe supports nested (hierarchical) shapes. A layout with shape `((2,3),(2,4))` describes\n", - "2×2 tiles arranged in a 3×4 grid — the inner dimensions describe the tile, outer dimensions\n", - "describe the grid of tiles." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "output": { - "id": 1181989490677108, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Basic 2D Layouts\n", + "\n", + "A CuTe Layout maps logical coordinates to memory offsets via `shape` and `stride`.\n", + "\n", + "- **Row-major** `(M,N):(N,1)` — consecutive elements in each row are adjacent in memory\n", + "- **Column-major** `(M,N):(1,M)` — consecutive elements in each column are adjacent" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# 2×2 tiles in a 3×4 grid: ((2,3),(2,4)) : ((1,6),(2,12))\n", - "hier = Layout(((2, 3), (2, 4)), ((1, 6), (2, 12)))\n", - "\n", - "# Flat view — offsets only\n", - "draw_layout(hier, title=\"Flat: ((2,3),(2,4)):((1,6),(2,12))\", colorize=True, flatten_hierarchical=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAALaCAYAAABnOCEiAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgABAABJREFUeJzs3QlYVNX7B/Avm8gqoqAgimTijogb7guGhltauGYu5VauLWapqYmZWj+Xv2lqmpmVW2qauWsuKaYlrinuKIKAgIjsy/85Z5yBYR12uHw/zzMyc+fOzJ3D8eW89yxXLzU1NRVERERERESkGPolfQBERERERERUuJjoERERERERKQwTPSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IiIiIiIiBSGiR4REREREZHCMNEjUqh79+5BT09P6/bJJ59k2u/PP//U2mfOnDkojzKWV1GVw6RJk3L9jMDAQJiamsp9KlWqhKdPn2qee/LkCX755ReMHTsWrVq1Qs2aNWFsbAwLCwu4urri448/xqNHj/J1bIcOHcK7774r39fBwQEVK1aUtxo1aqBHjx5Yu3YtEhISMr1uw4YNmu/Ut29fFNSOHTs079e5c2et527fvo1Vq1Zh0KBBaNq0KapXr44KFSrA2toaHTp0wLJlyxAXF4fC8PPPP2f6PyS+a0YjRozQPL9kyZIs30sct6GhodzH3t4eMTExJV6XhOPHj2P27Nnw9PSElZVVof8fSE1NxebNm9GnTx/5vUVdrVq1Kho3box33nkHx44dU2Rd+ueff/DFF1+gd+/esLW11SpXUV+yc/nyZVmHXnvtNVlGNjY28pjEe7zyyiv4/vvvkZycnO/6pUtdJSIFSSUiRbp7926q+C+e/mZubp4aFhamtd+xY8e09pk9e3aJHXOnTp00x+Ho6Fii5VUU5XDr1q1UIyMj+f5mZmaZfhdqI0eO1BzHxx9/rPXc4sWLM/1eM96srKxST506lefjGzhwYK7v3bp169Tnz59rvS4hISG1Zs2amn1OnjyZml+JiYmpzs7Omvfat2+f1vM9e/bM9RgbNWqUGhwcnFoQ4ndjY2OT6b2///77TPteu3YtVU9PTz5fpUqV1MjIyFzLd968eSVel4SmTZtmW44F/T8QHh6e2qFDhxx/V8OHD1dkXerbt6/O3zk98Xm5HVPnzp1To6Oj81W/dK2rRKQM7NEjKkeio6Px9ddfl/RhlFui5yQxMVHeHz58OKpUqZJpnxs3buCHH36Q9w0MDDB58uRs38/Ozk72tLVp0wb6+mnhPDIyEt7e3nj+/Hm+jrN27dro1KkTvLy84OjoqPXc2bNnsXz5cq1tRkZGsndJLaueY12JHh1/f395v2HDhvL7ZadBgwbo2bOn/Jne1atXMWbMGBTE1KlTERoaqtO+4vNFWal7XL/66qss9/vwww819xctWoSIiIhSU5eEypUro7AkJSXJ393Jkyc12ywtLdG2bVt0794d9evX16qzSq5L+SlX0eMmehlFvXJycso0CuPTTz/NV/3Sta4SkUKUdKZJRMXXoyduFhYWWmf/2aNXPD16jx8/1vTAiFt2PW6TJk3S7NOtW7dMz4sePdFLcujQodSUlBTN9r/++ivV2NhY6zv8+uuveTrGI0eOpN6+fVtrW3JycuqHH36o9b6iJySjBw8eaHoKxO3ixYup+ZG+h8nHxyfT871795Y9IqJnIr2vv/5a6xj19fVTQ0ND83UMBw8e1LxPrVq1cu3REzZt2qTZp1q1arJnKisvv/yyZr9ly5aVaF0SVq5cmbpz587UR48eFWosWLRokdZ7jRgxIvXp06eZvkdWPXZKqEuiPmzevFnGlYyxJacevWbNmqVOmTIl9f79+1r/BydPnpyp115sz0/90rWuElHZx0SPqJwleuL2ySefaPbTpXEnGgLr1q1LfeWVV+RwNtHItLa2TvXw8Ej98ccfs2xwiG1r1qyRw4yqVq2aamhomGppaZlap04dmSiIoUXqxoxo+OQ2XClj40gkq59//nlqq1atZKNHHJO9vX3qgAEDchy2ePnyZTmsSrxGDHlr165d6u7du3NN9EQDP/3zotzy4ssvv9S81sHBQStJU4uNjU2tXLmyZr+1a9dm2ienYWTDhg3TOkbxmYVBNLTTv+8bb7yR5X5t27bV7DNhwoQ8f46vr6/W5/j7+2faJygoKNvXZ0zKxPvllRiW6uTkJF8vfn7zzTc6JXpRUVGpFStW1Oy3ffv2LPf79NNPNfs0btw4XyccCqsuZVRYiZ74vy+OS/0+TZo0kcMo80IJdUktL4ledscUFxenldyLW1axILf6lZe6SkRlH4duEpUT7u7umqFSK1asQHh4uE6ve/z4Mdq1a4e3335bLtYhhrOJIWPi9UeOHMGwYcPkQgvx8fFarxP7iyFPYphRWFiYHMoVFRUlFw3Yu3cvZs2ahRMnTuTru5w5cwaNGjXCZ599hr///lsOVRTHJBYh2bp1q1xIYd68eZle99dff6F169b47bff5GvE0EaxTRz///73PxQl8ZlqYlEIMTQrI1Ee6YdbdenSJdM+1apVy/YzxGIS6YnFNwpKnBDctGmT1jaxKERW0h/v7t27C1RGYjGYunXr5vodcyqb/Hx/US/v3r0r769evVouZKILsRhO8+bNs/wu2ZXRlStXcOfOnRKrS0VFLCjy8OFDzeMBAwbg8OHDcujokCFDMGXKFOzZs0fWrewooS7lR3bHJBaxEYvlpCeGwuanfulaV4mo7DMs6QMgouJRr149vPTSS3IlwWfPnsm5evPnz8/xNaIh9vrrr+PcuXOabWJuzcsvv4ybN2/KOUCCSNzEnKaVK1fKx6KRl351QrHKXsuWLeVqcQEBAbLxkX71RvGcmD8oVgAUSaEgGtivvvqq1j5CcHCwXMlOzC8RRCNXJG9ipTyx0p1ITMVxiyRQfGfRyBTE6nmikZl+NTqxmqRIGP38/PB///d/KCriM8+fP5/pu2SUPvEV36dOnTo6f4b4zgcPHtTaJubZ5ceXX34pj1f8Tq5du4YHDx5onhPzwUaNGpXl68RqnWri9ywSpozzi3KS/vtnV0bZEfXi4sWLWr9bUU/zQtQfsdKi+nuKhDarVTazI76/OHEgiLqcFfG9RJ1VJzliP/H/sjTVpYK6cOGC1mMRF4KCgrS2iXIWJ5927dqV5cmLsl6XCtu///6rNWdUxDwTE5N81y9d6ioRlX3s0SMqR0RvhbpXTyQ2ufXqiQRO3RhQJwD//fefPBt//fp1vPfee5rn1qxZo0kIxJLu6YlG0x9//IEDBw7I14tkbvv27XL5cEG8j3gski41say42Ka+qT9LLB6gTvLEAhOnTp2SPXziWEVjsEWLFlrfN/0y66LBmD4JEsmqOCaxYEOzZs1QVMSCDuqFM9QLQ+TWQM64KERuFi9erNU47d+/f57fQ02U6a+//irLJn2SN2HCBNkbLJZxz0rG7yUap3mR/vtnV0ZZEScQRo8erXXyQFxmIrvjzIrocRbL/Yv3EkvZ56eHN/0xi7qmrqcZe4bE8vf5LaPiqEsFlXERm4xJnpqvry/69euXZc9eWa5LhU0k9xkXhJkxY0aW++pav3Spq0RU9jHRIypHRG/cwIED5X3Rq5dbY1YkZ+mJpO+NN97Q3ERPWPoGkrpHKWPvwbRp0+S130SjQwyXFEOHRE+huO5bXqU/JjMzM/kd1McjhpGK4aFqIoETQ0WFo0ePar3PzJkzNWfERePoo48+yvFzxfWnXsxrlreM1+TKSUhIiNbjrFZIzLhfdvtk5ZtvvsH06dO1fs/fffcdCptI8kQiff/+/SyfFz1H6YneVV2JepG+t1XX7y8StLfeegu///67Zpuo4yIpzQtxAkFdn8Wqohm/iy50/f7p98u4j1jxNH09y3gtu6KuS4Uhq2stipMuYiipSFTTJxniJM3+/fsVVZcKk+hVFyMYRG9z+ngqtmUnp/qV1T457UdEZRuHbhKVM2JI45YtW5CSkiJ79dzc3HK8iHh6oicvJ+oEQAzVHDduHL799lv5+KeffpI3QfQoigRPDI0TF+fO65ny9MckkjrR85TbMYnEM/2coazO8qfvTSxsYj5geiLRzW2/7PbJSPSypl+C3tnZWc6HKshS+eqGrjge0QPr4+OjSbDFcN2JEydmOW8q45yhjN+7MMooPTEvVDTE088xEhea/vHHH7Oct5Yd0bP9+eefy/uiAa0+GZJXun7/9PvlpYyKui4VlozlIOadiYRV/N8X88xE0jd48GDN82Ieb/ph2mW5LhUm8T1EuYieTzUxsmHhwoU5vk6X+lWQ8iWisoM9ekTluFdPJEpLliwptPdOfxZd9DKJ+U3imlnpzx6LBFP07ImFGcSZ6aKW/pjSK87GW8ZFFERvam77ZbdPxuFb6ZM8cd0tMTdJzCkqDOJ4xDX6Ms6j2rdvn9bwQbWnT59men1ePiu93L6/+L326tVLq2H+5ptvYtu2bfJabHkh/h/ExsbK+8eOHZMnKtQ3kdSmJx6L7eI6Zfn9/un3y0sZFWVdKkwZ54SJXsr018zLuDBKVtd7K6t1qTCHv4qFVdIneaLXXvSq50aX+lWQ8iWisoOJHlE5n6sn5mNlJ+PFskXvWPphZRlv6S++K95f9NqJYVli/oeYlyfO3Kcf8ih6/ETil5fkK/0xiQZlTscjbqIBp155Lz2xyEh6oueqqIg5X+llNzcy/X45zZ8U30skyl988YVmm1gZVZRvTqty5pdo7IrkJv0Qt6yOL+M2Mc9SV2IYbvoVLnP6/iIx8/T0lD2X6ROwjRs3FngulRgqJ+qr+iYeZ/V8VicQdP3+6ffLSxkVRV0qCmKhj/SJXcZETpdyUkJdyi8xx7ljx45aQ+PFiYUFCxbo9Hpd6ldBypeIyg4mekTlkFicQb0aZU4yDqcSy6JnbPiK1SzFkE51QiWIfcTwIvX8OPU8GbEASvv27TXbRC9K+oUb0q8iJxrTWc31SX9MYvVOMXQxfbKofu3atWtlMpTd8vJixVFx7OrGnljMJCeid1IkouqbSKp0JYaFpu8ZyJhkqqWfs5hd4im+q1g0RMwjS18m4tIXuZ2VF8Pn0n+H9MNgxfxLMd8x4xww4YcfftA6ZjEULn3il933yrjAjZjnmP7zc/r+2ZWR+N127dpVa5Gg2bNny/LI7USB+lIE4iZ6mQpb+mMWJxayajyLIXLpFyfJWEbid5K+jDLO0SvMulQQOdUl8b1F8qQmhvuqe6bESYqMK5lmdemH8lqXREwTl4cRi12pF5wS821zm0Osa/3KS10lorKPc/SIyvFcPXHNuYxJUnpivpJYxvvs2bPy8c6dO1GzZk3ZeDA3N5fLkItrZqkTJjXxWAwzEjfR6ybmyImz7OI6d+kv1SASk/QLJaRfwlwki6KxJoaait4BsfKdWDr8ww8/xPfff6+ZUyKGLq5atUrOuRP7iZU3RcNSfK/0lxcQi7+IfdWrSIohemIImfryCkW5GIHoXRCLmIiFJ4T0y+OnJ45X3UsnGqFZLSkvlqVfv3695rH4zqLhLxaiyUgk87ok9IJIuD/44APZoBQnAkTjVSywIxqcGedqjhw5UjZAMxLXNFQTK//ldUl68f1Pnz6dYxmJSzukX5hCDAsW1wsTi/FkNHfuXJ3mXqoXQMmKSErE91UTdU8kGVlJ//1Fj0xWRP1P/1l5vQRGYdYlQcyTVa/MmH4hI0EkGOqFUuzs7OT/f12J3ifRSyZ6fwWRUIleZ5GEiAVZ1ER88fDwUExdUhPX8RQrAQsZrzEqtotLS6ilH54pViFVX8dRXe5iqLS4ZSTiXsYETdf6pUtdJaKyj4keUTklGvPe3t5yYZbsiLPVonGXftU3kWCJJCmj9EO1Mp6hzu6i0KIxmH54lJgXI+b2qZNP0ROh7o0Qz4lETzT6RA+iSNzUvU9iefD0l05QS5+MVKxYUS4II+YMqudjiQVa1Iu0iPfPeGHwwtS3b19N41z0BorGWMZeA9HgEsmvOokV5ZyxcZ5xbo0oq+wuKK2+fEVeiPcTDfH0jfH0xMXlsxtClr5eiP3yU0bq91ZfbzHjfK+M318MQctuQZ7iXC1RJEnpk4bsvn/6MhInMbK6kHdx1SV1z476RE5WQwjVl0rJOIw7N+IkjUiSRVIskj3xfy798EhBnJwRv7uses/Kel0SoxmyK1cxjF19vdCMMh5T+hiVkRgqnzHR06V+6VpXiajs49BNonLeq5ddgpb+jLJoVIpGmxgiKFbQEz1IInESPSFiyKYY8pc+0RINTJE0iWs/id4/9WuMjY1lY1MsBiMaqGJlzoxze0RDS5ztFj2A2RHDP0UCKIZftm3bVq4wKZI60csoEtihQ4fKOTbpF1cQxJAocfZcJK7ikgqid0R8prj0gzgDX5REg1c95E6UVfqz+GqiTMXy7mo5JeH5IXpg1UQvq/i9qIlFV0TDUTT6RONQ/A5FmYphmqJBLuZbiuvqiTJNP/9JLeN3Gjt2bI6fL3p3MhK9Oy4uLsXy/dMPIS4MolzUPTei8S16ZrIietFzKiMl1CU18f9QXNtR9IjWqlULFSpUkKs9it+zqGui9ymrhYPKe10qCF3ql651lYgUIJWIiIrFkCFDxJgqeXvvvfey3Oe///5L1dfXl/sYGhqmBgUFFdrnv/zyy5rPP3LkSGphWrhwoea927Vrl+n5+Pj4VFNTU/m8sbGx/J5ZWbNmjeZ9GjVqVGjH9/DhQ837Vq1aNTUkJCS1ML366qua958xY0aW+5w9e1azj4WFReqTJ0/y/XmsS8qtS/mla/3Spa4SkTIw0SMiKia3bt1KNTIykg0sMzOz1LCwsCz3GzlypKYh9vHHHxfKZ9+/f1/znu+8805qYUpISEh1cHDQvP+JEycy7fPnn39qnvfx8cn2vRITE1OdnZ01++7bt69QjnHDhg2a99y0aVNqYbp69Wqqnp6efG9ra+vUiIiILPcbMGCA5hg+//zzAn0m65Iy61JB6FK/dK2rRKQMTPSIiIrRxIkTNY2x2bNnZ9tjYGJiIvextLRMjYyMLPDnrlu3Tr6fnZ1doTfuvv/+e8136tOnT5b7zJo1Sz7v4uIiE8Oc/Prrr5r369SpU6Ec47Bhw+T7id6MwjZ8+HDN8f7vf//LNjEzMDDQ/A6eP39e4M9lXVJeXcovXeuXLnWViJRDT/xT0sNHiYiIiIiIqPBwMRYiIiIiIiKFYaJHRERERESkMEz0iIiIiIiIFIaJHhERERERkcIw0SMiIiIiIlIYJnpEREREREQKw0SPiIiIiIhIYZjoERERERERKQwTPSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IiIiIiIiBSGiR4REREREZHCMNEjIiIiIiJSGCZ6RERERERECsNEj4iIiIiISGGY6BERERERESkMEz0iIiIiIiKFYaJHRERERESkMEz0iIiIiIiIFIaJHhERERERkcIw0SMiIiIiIlIYJnpEREREREQKw0SPiIiIiIhIYZjoERERERERKQwTPSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IiIiIiIiBSGiR4REREREZHCMNEjIiIiIiJSGCZ6RERERERECsNEj4iIiIiISGGY6BERERERESkMEz0iIiIiIiKFYaJHRERERESkMEz0iIiIiIiIFIaJHhERERERkcIw0SMiIiIiIlIYJnpEREREREQKw0SPiIiIiIhIYZjoERERERERKQwTPSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IiIiIiIiBSGiR4REREREZHCMNEjIiIiIiJSGCZ6RERERERECsNEj4iIiIiISGGY6BERERERESkMEz0iIiIiIiKFYaJHRERERESkMEz0iIiIiIiIFIaJHhERERERkcIw0SMiIiIiIlIYJnpEREREREQKw0SPiIiIiIhIYZjoERERERERKQwTPSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihTEs6QMgIkrvQXgMOiw6Ju8vfsMF3i1qam1TWz2sObo3qo6EpBQs2n8df98Lx9VHUUhOSZXPX53bHWbGaSFuySF/LDtyU/O4hpUJ/preNd+FHx2fhP8d9Mfey48Q8TwRtaqYYpi7I95q4wg9PT3+UkuhslC3dP1MKl3KQt06e+cJtp5/iAsBEXgcFQcjQ30421rg3S510LmebT6/ORW1slC3Lj98iiWH/fFfUBSePE+A+AvoWMUUPZvYY3znOqhgyH6lksK/GkRUpsUmJuO7U3eL9TNTUlIx6vtz8g+p2q2QaMzefRWhz+LxYfd6xXo8pJy6VRKfScWvJH7Pv118hF//fZi2ISFZxrC/vw/HkoFN0a+ZQ7EeDymnbt0KfYaj10O0tvk/job/Y38EPY3Fl6+7FOvxUBqm2ERUpvwy2h33vuwpz1wKRgZ6GNG2Nr4Z4oZXGlbL9nVTX3GWr5vsUbfAx7DLL1CT5E3rUQ//znoF3RupPvvb47fl2VYqe0pD3dL1M6lsKQ11y1BfD2+618KBKR3x3+c9sKB/E81z3xy7XeD3p/Jbt2pZm+F/A5rizCddcX1eD6wf0ULTi/f7paACvz/lH3v0iKhQHbsRgrUn7sihHAnJKXCobIK32tTG8La18Tw+CcuP3MS+K8HyLJ9FRSO0qVMFH7zijJdszPP1eaYVDDGnTyN5P+MZxaKy5+Ij+dPc2BBjO9aBgb4exnd+GQeuPkZSSir2XQnCmI51iuVYypPyULdK4jOpfNStj3vU1xq6N7hVLfxw+h6uBz9DwBOenCoq5aFuNXesLG9qXetXQ71qFrgc+FQmnlRymOgRUaH56ex9zNh5RWvb7dDnOHUrTDYqhnx3FhcfRGqeC3+egL2XgnDCPxS73muHOvn8w1bcrgVFyZ81rU1lkic4VTVLe/6R6nkqPOWlblHxKy91K6s5nvFJKfKnraVxCRyR8pWXupVeXGIy/roVhhuPn8nHg1rVKulDKteY6BFRoRCLkyz447q8b2VqhKUDXdHKyRr3wmJw5dFT7LzwUPMHbXgbR3zQvR7+uhmGd3/+F8/ikrB4/w18O6x5ifw2tp1/gI+2X8pxn9ZO1tgyto28LxZfESzSNZzS3xeT0anwlKe6RcWrPNctkVDcDXsu7w9oUbNIjrE8K491y3nmPrkYjNqgljUxjXPWSxTn6BFRofjnfoT8wya8095JruImhpA0tLeUjYiTN8M0+4rFSiwrGuHVJnZo8WK4x8mboWX6N6Fa10yFq24WrvJet6jolNe69ffdcHy0/aK8L4bciZURqXCV17qV3uZzD/DlflWySyWDPXpEVCgi0vViOVXNPNwkMiZRM69NzENQq17JRLwazxOSEZ+UXCK/DbFctbjpqrKZER5HxePZiz/igvoPumBtmvb9qODKU92i4lUe69Y/98Mx8vu/EZOQjPrVLbB+eEsYGfC8f2Erj3XL3+dVOXRT9FRO3eKHR0/j8N3Ju3i7vRNsLSoWybFSzpjoEVGhqGxWQXP/blh0pufF0BV1QvQsLlHzhy34aaz8aVbBAMaGBmVimEpDO0s8jgqVq2uKaxSJeXrqIVDyeXvLIj/m8qQ81S0qXuWtbvk9iMSI9edkEiGSvJ/eaY1KPDFVJMpb3VKraGSA1i9VQY/Gdlj/1135N/JhRCwTvRLCUzhEVCjE8B9xZlJYd+qunEwem5CM68FR2Hr+Adq/XFWz7/8O+SMqLhH7rwTj/P0Iua193bTn80pMYBc3saKZWkSMaps4hsLWu6m95g/06hO35ees+vOWZgnzVxvbFfpnlmflqW6V1GeWV+Wpbl0JfIq31p2VIxHUSV4Vcy7CUlTKU91afOA6Dl97jJCoONmj929ABA5cDZbP6ekBDlail5JKAnv0iKhQiD9on3o1wKc7LyMiJhFvrf9b85y4ls+KIc3w898BuPTwKb7/6568pV/I5KMCTNh2m3co07b2C4/Jn+IaQeJ6QYU5TOU11xrY/PcDeS29RftvyJvauE515GqcVHjKU90qjM8k3ZWnuiWOPSpONcRcXFKhuc9hredPTuvC2FWIylPdOno9NNtrMYrVRW0tOWyzpLBHj4gKzZDWtfD9iJZoW6eK/EMlLpj6ko2ZPHMphqD8PNodozs4yesIiZ6vyqZG8GpSHTvfa4uXbS3KzG9CX18P60e2xKh2TqhmaYwKBvqoY2OGuX0a4QNPNsKLQnmpW1T8WLeIdatg3mjuIHswrc0qyKkMFhUN5aIyX/RrAp++jVnBSpBeampq+sXiiIhKHTEXrsMi1dnIX0a7ywvK5teSQ/5YduQmaliZ4K/pXQvxKKksYt0i1i0qaxi3SFccuklEZcrgtb7y5+phzdG9UfU8J3hErFtU3Bi3iHWLSgKHbhIRERERESkMh24SEREREREpDHv0iIiIiIiIFIaJHhERERERkcIw0SMiIiIiIlIYJnpEREREREQKw0SPiIiIiIhIYZjoERERERERKQwTPSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IiIiIiIiBSGiR4REREREZHCMNEjIiIiIiJSGCZ6RERERERECsNEj4iIiIiISGGY6BERERERESkMEz0iIiIiIiKFYaJHRERERESkMEz0iIiIiIiIFIaJHhERERERkcIw0SMiIiIiIlIYJnpEREREREQKw0SPiIiIiIhIYZjoERERERERKQwTPSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERApjWNIHQEQl49GjR+jTp4+8P3v2bPTu3Vtrm9pXX32Fzp07y/vPnz/Ht99+i8OHDyMyMhIODg544403MGDAAOjp6cl9Vq9ejbVr12peb2dnhz179uT7OHX5zOJQFsorMTERK1aswIULF3Djxg0kJyfL7SdOnICpqSmKS1koK10/sziUhfJi3cob1i3WLcYtxq3SgIkeEekkJSUFU6ZMkUmE2t27d7F48WI8efIE7777riI+sywfe1xcHH766SeUNaxbpb+8WLdK9++nsLBule6yYt0qH3GrMHHoJhFlSfQWnD9/XtODsG/fPs0ftAkTJsiehC5dusjHP/zwg+yBEMaOHStfN3r06AKXrK6fWRqUhvIyNDTEwIED8eWXX6JTp04orUpDWbFu5Q3rFusW4xbjVlmL84Zl5G9iUWKiR1RG/fXXXxg/frwMXu3atZPDtrZs2SKfi4mJwbJly9C3b1+4u7ujW7du+OSTT3D//v18f97BgwflTzMzMwwbNgxWVlYYPny43CaGCB45cqSQvlnRfGZ5KC8TExN89NFH8vgtLCzy/T7loaxYt/KGdYt1i3Gr6GKIrhi3SiZulWUcuklUBv36669YsGCB1rZ79+7h77//Rv/+/WUj/erVq5rnxByeQ4cO4cyZM9iwYQNq166d58/09/eXP2vUqAEDAwN539HRMdPzhamwPrO8lFdhKC9lxbpV/Fi3tOsey4t1K68YtyivmOgRlTFikv/y5cvl/UqVKmHevHlo1qwZHjx4gOvXr2Pv3r2ahrhYmEHMEzh79iymT5+O6OhofPPNN3IOQV6JBr367KVa+vsRERG5vodYCGLu3Lk57uPm5oY1a9YU2meWp/IqqPJUVqxbrFusW6Xj/2JBMW7xb2JR1S0l4NBNojLm0qVL8g+bMGTIELRt21YOT3B2dpar9ImGt5poiJubm8PDwwNNmzaV29I/X1Cpqama+8W1SmFeP7O8l1delPeyYt0qOqxbjFusW0WDcYtywh49ojJGfcY14/A2tadPn2rOwoqGuJqtra1mjlVCQkKeP1fMPwgNDdUkAur3Sv98bsSy8eJWnJ9ZnsqroMpTWbFusW6xbpWO/4sFxbjFv4mUPSZ6RGVM+j+0WS2AIYbcCeIPtRhOp26Qh4SEyJ/iemoVKlTI8+eKXh3RAAgMDJQTzcVcqvSfL54v7CE9hfGZ5am8Cqo8lRXrFusW61bp+L9YUIxb/JtYVHVLCTh0k6iMcXFx0cyZ+Pnnn+Hr6yuvFXPr1i3s3r0brVu31uwrLpgsGuTHjh3DxYsX5bb0z+eFp6enppH/448/yrOoYklkQTQGxBC+wlYYn1meyksQnyNu6XvWRE+c2Ca+d07KU1mxbuUd6xbrFuNW4caQvGLcKt64pQTs0SMqY0RDfPLkyfjiiy9ksBLXo1ETy+GLFRN37NiBa9eu4ZdffpG39K/N70VcX331VezatUteB2fFihXypiaWlLa3ty/0IT2F8ZnlqbwEsYx0Vu8jiOsSiWsUZac8lRXrFusW61bp+L8oMG7phnGreOuWErBHj6gMEsvcL126FC1btpQNbDFcTsypatWqlby/atUqvPnmm/KPsjizKIbcibOLYvl7JyenfH2mvr6+/MzBgwfDxsYGRkZGcil9cY0aseR+USiszywv5VUYyktZsW4VP9Ytxi3WrYJh3KI8SyUieiEwMDC1efPm8nbu3LkClcu3334r36dXr16KLV+WF8uKdavk8f8hy4t1q3Tg/8XShz16RJSlcePGoUWLFvjzzz/zVEJi7pZ43dq1a8tVybK8WFasWyWP/w9ZXqxbpQP/L5YOTPSIiIiIiIgURk9065X0QRAREREREVHhYY8eERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IiIiIiIiBSGiR4REREREZHCMNEjIiIiIiJSGCZ6RERERERECsNEj4iIiIiISGGY6BERERERESkMEz0iIiIiIiKFYaJHRERERESkMEz0iIiIiIiIFIaJHhERERERkcIw0SMiIiIiIlIYJnpEREREREQKw0SPiIiIiIhIYZjoERERERERKQwTPSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihTEs6QMgIqLilZKSioiYBK1tlU0rQF9fj78KYt2iUolxiyjvmOgREZUzIslr7nNYa9s/M7uhirlxiR0TKQPrFrFuEZUeHLpJRERERESkMHqpqampJX0QRJSzRYv+D0+fxrKYdPDs2R04OFRhWeUgNsUQ30e20to22OQ6TPSSWW45ePIkADVq2LKMcq1bTbW2va5/HRVZtxi3CohxK38Yt/LGxMQcEye+D6Xg0E2iMkAkeS1bTivpwygTjh8fjWnTWpb0YZRqT6KB7320t/X0moBKFTl0MycbNkzAtGn9ivaXU8Y9iU7G9z6BWtuaNZsAcyPWrZwwbulStxi38oNxK28WLdoJJeHQTSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IgoX4KCbsHHp6fm8c2bJ7FyZX+sWNEXp06ty/X1VyMeY77fn5h34RgOBt7UbI+JicLHH7sjKSlRMb+ZW7eC0LOnj+bxyZM30b//SvTtuwLr1p3S6T2O/KeHLl8ZouMiQ6w4mha6o6Ji4O7+MRITk6AUAQG38N57aXXLz+8kpk/vj2nT+mLPntzr1t8PH2Ps7j8x+rdj2HIlrW5FR0dh6FB3JCYqqW4FoGfP9zSPT570Q//+09G37zSsW7dHp/c48l8sunz1CB0XPcKKo08126OiouHuPlRR5cW4pTvGrbxh3Cq+uJVdzFJq3CoIJnpElC/btvmgV6/J8n5KShL++GMBBg1ainHjtuLy5X0IDb2d7WuTU1Ow9e4VjKnXEtObdsT50EAExTyTz5maWqJRo044fnyTYn4zPj7bMHlyL3k/KSkFCxb8gaVLB2Hr1nHYt+8ybt8OzfH1ScnAjJ0GWD8iCQenJmHnBX34P1Y9Z2lpik6dGmHTpuNQijVrfDB0qKpuJScnYePGBZgyZSnmz9+KM2f2ITAwh7qVkoKVf1/B7M4t8U2vjvjzbiDuR6rqlrm5JVq06IS9e5VUt9Zg8uSh8n5SUjIWLNiIpUunYOvW+di37wxu3w7M8fVJyamYsTMc60fY4OBUO+y88Bz+jxPkc5aW5ujUqQU2bdoLpWDc0h3jVt4wbhVP3MopZik1bhUEEz0ihQkJuYcxY2pjw4aPMGWKCyZMqI+IiGDMndtdPv7kk3YIDLyBoKDb+OijVlqvTUlJwahRdkhOTs7xM+LjY3Dp0mE0aeIhHwcGXoGVlT2srWvB0NAYDRp4wN//RLavvx8diSrGJrAxMYORvgFcq9jhSsSLzAVA27beOHp0A4ravXshqF17DD76aANcXKagfv0JCA6OQPfuc+Xjdu0+wY0bgbh9OwitWn2Uqazs7EblWlYxMfE4fPgSPDyayMdXrgTC3t4KtWpZw9jYEB4eDXDihH+O7+H3QA81rVPhVBWoaAR4NUnBoWtp4dvbuy02bDiKohYYeA89etTG119/hNdfd0GfPvURFhaMceO6y8dvvdUOd+/ewIMHtzFkSOa61bVr7nUrNjYGvr6H0bq1qm7duXMFVavao3r1WjAyMkaLFh64cCH7unUjLBLVzE1gb2mGCgYGaFfLTvbwqXl6euO334qjbgWidu0e+Oijr+Hi8jrq1++D4OAwdO8+Tj5u1+4t3LhxF7dvP0CrVkOyqFtddahbsTh82BceHq3l4ytX7sDevipq1aoOY2MjeHi0wIkTF3J8D78HCahpbQinqkaoaKQHryamOHQtVvO8t7cnNmz4DUWNcUt3jFt5w7ilrLiVW8wqzrhVFhiW9AEQUeF78uQh6tRxw4gRixEdHYEff5yOhg07wtt7Bo4d24jvvpuE2bMPIDIyWA6RDAt7gIoVzREVFQoHh4Y4c2Y7fv11Qab3XbLET/68efMcHBwawMDAQD6Ojg6DhYUN/vvvCCIiHsr7OfXoRSXEo1KFirj4JAhh8TGwNKqI4FhVr4vg5OSKu3cvyGMzNDQq0iry8OETuLnVweLFIxAREY3p039Ex44NMWOGNzZuPIZJk77DgQOzERwcKYdHPngQBnPziggNjULDhg7Yvv0MFiz4NdP7+vktkT/PnbuJBg0cNGUVFhYNGxsLHDnyHx4+jJD3c+vRC3kGVLME9l3Ww/1wPdhaAjfTche4ujrhwoW78viMjIo2rD9+/BANGrjhgw8WIyoqAkuXToebW0eMGTMDu3dvxMKFk/DttwdkAiiGzjx+/AAmJuaIiAjFSy81xKFD27FuXea6tW2bqm5dvXoOL72UVrciI8NQubINzp8/gpCQh7CyssmxRy8iLh5VTCvir4AgBD+LgbVJRQQ8Tatb9eq54vr1C/LYjIyKum49hptbAyxe/AEiIqIwffpSdOzohhkzxmDjxt2YNGkhDhz4VjakxPE8ePAY5uYmCA2NQMOGL2H79kNYsCDzUFU/v23y57lzV9GgwUvp6lYkbGwq48iR83j4MAQ2Nla59uiFPEtGNUsD7Lscg/vhSbC1NMDNx2lDnlxd6+HChevFUl6MW7pj3Mobxi3lxK3cYlZxx63SjokekQKJpK1Dh8Hyvrl5Zfj7+8LLa6J87O7eXyZ6gpNTM9y/f0kmdSJxq169DurVa4P27QfKW3YiIh6hUiXbTNtFT57wzz/bdTrOplXs5M9Twfe1thsYGMLExAJRUWGwtlbtU1RE0jZ4cAd5v3Jlc/j6+mPiRC/5uH9/d5noCc2aOeHSpfsyqROJW5061dGmTT0MHNhe3rLz6FEEbG0rZdouevKE7dv/0flYX22SCiAVP/pqD8YwNDSAhYUJwsKiYGdnjaJkamoOLy9V3bK0rIxLl3wxeLCqbnXr1l8mekL9+s1w8+YlfPfdApm41axZB02btkGPHgPlLTshIY9gbZ25bomePOHoUd3qlujJE/7w165bhoaGMDOzkAmkjU1R1y1TDB6sqkuVK1vC1/cSJk5UlV3//t1kg0lo1qw+Ll26iQULvpMNoDp1aqJNm6YYOLCHvGXn0aMQ2Npm/n2LM+LC9u269/K+2sRU/vzRNy0pVpeXhYWZbIzZ2dmgKDFu6Y5xK28Yt5QXt7KLWcUdt0o7JnpECmRmZqXTfvXrt8WNG2dgbGyG4ODbePYsHM2be+HUqS059uhVqGCChIQ4zXZzcxs8e5bWKyXuW1hkbqyrVapgjKfpXh+VGCd7+NJLSIiFsbEJipqVlZlO+7VtWx9nztyAmZkxbt8ORnj4M3h5NceWLady7NEzMamAuLi0+QM2NuYIDU37wyTu29pa5PjZojfvcVTa45Ao1bb0YmMTYGJijKJmYaFb3XJ1bYuLF8/AxMRMDuV8+jQcHTp4Yf/+LTn26FWsaIL4+LS6IXrwRG+gWmRkKCpXzr5uWZsY40lM2uvDY+NQxUS7bsXFFVfdyvn3qta2rSvOnLkIMzMTOSQqPPwpvLw6YMuW/TmeGTcxqYi4uHjNdnEmXJxVVwsNjYStbeUcP1ucGX8clTbUKiRKdbY8vdjYuGKpW4xbumPcyhvGLeXELV1iVnHGrdKOc/SIygFnZ3ecP69ayers2V1wdlaNjRe9d/v3r0K9eu4wN7fG5ctHNT16IqnLeFOrWbMRgoLSVjO0t2+EyMgghIc/QFJSPK5fPwZn546a58V8OzFvUK2WmRXC42MRGvcciSnJuBQejMaVq2mej4wMkcmnrg2/wuTu7ow9e87L+7t2nUXr1s7yvui9W7VqP9zd68Ha2hxHj17W9OiJpC7jTa1Ro5q4eTMo3WN7BAVF4sGDcMTHJ+HYsevo2FH1GYKYayfmDabn4pCKhxF6uBcGxCUC+6/o45WGKZrnQ0IiZQKqa+OvMLm4uOP4cVXdOnp0F5o0UdUtF5c22Lp1lXy+UiVr/P33UU2PnkjqMt7U6tRphICAtLrl5NQIYWFBcghoYmI8/vnnGJo1S6tbYr6dmDeoVreKFUKex+LRs+dISE7G6QfBaOWQVreePAmRyaelZUnULRfs2aNaNGfXrqNo3Vo1b7NNGxesWrVVPm9tXQlHj/6tOTMuGkcZb2qNGtXBzZsB6R47ISgoTA6lio9PxLFj/6Bjx2aa58WcFTH/Jj0Xhwp4GJGEe2GJiEtMxf4rsXilYVoSHBLyRDbkrKwynFlQeNzKGLMExi3GrcKIWxljlsC4pXvcyi1mlXTcKm3Yo0dUDgwaNBfLlw/HyZO/yCGREyasl9tffrkFHj3yR9Omnqhc2U4usGJhkfvQP3v7uvJneHiQHFophlp6eU3H5s2TkZKSjKZNe8PGpo5m/9DQADRo0E7z2EBfH95OjbHm+jmkpKaitY0D7EzTziKK42jZsg9Kwty5gzB8+HL88stJORxy/foJcnuLFi/D3/8RPD2bws6uslxgxdo69zOfdevay59BQeFyWKUYZjl9uhcmT96M5OQU9O7dFHXqpA0tCQgIRbt2qmGdakYGgM9ryRi5wRDJKYB38xQ4p+Uu8lj69GmJkvDuu3Mxc+Zw7Nv3ixwSOXeuqm41atQC9+/7o21bTzlEUiywIhK+3Dg6qupWaGiQfJ0YgvPWW9OxZImqbrVv3xs1aqTVraCgALi6ptUtQ319jG/ZGHOPqepWt5cc4JjuDLU4js6dS6puvYvhw2fil1/2yWFF69fPldtbtGgEf//78PRsK4cZiYUKRMKXm7p1HeXPoKBQ+TpRVtOnv4XJk5e8qFvtUadODc3+AQFBaNfOVes9jAz04POaNUZuCH1Rt8zgXK2C5nlxLH36dEZ5i1sZY5bAuMW4VRhxK2PMEhi3dI9bucWsko5bpY1eamqqmPRBRKXYjBmL0LLlNJQmhw+vQ0REELy9Z+a672efeWD06BWoWVM7gcnOnDmeeOed5XBwqJ/n4zp+fDSWLEm7BltpsG7dYQQFRWDmTO9c9/Xw+AwrVoxGgwY1dX5/T885WL78HdSv76DT/k+igeY+2hPUN73eDZUqlo5hLjt2rJNnw8eMyb1uvfOOBz79dIWcB6iLsWM9MX36cjg55b1ubdgwAV9/PRalybp1O2Qv3syZ2r3AWfHweAcrVnwq59PoytNzLJYvn4769Z102v9JdDKa+2gvpODTvBvMjYzLVNzKa8wSGLcYt3SJW3mNWQLjVtHGrfQWLdqJadM+g1Jw6CYR5UuXLiNgYVFVp30///yIzg0mccH0zp2H5SvJK61GjOiCqlV1m/dw5MjneUryxAXThw3rrHOSVxb07TsCVla61a3vvjuic4NJXDC9V69h+UrySqsRI/qialXdhqEeOaJaNEFX4sLDw4b1yldjqazHrbzELIFxi3FL17iVl5glMG4xbhUEEz0iyhexNHKPHuMKvfTEBdNFoqe0sho3LvtVyApCXDBdJHpKK68BAwq/bokLpvfurcS6NaBI3ltceHjYsN5QEsatvJUV41beyotxKy91i3GrODDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IiIiIiIiBSGiR4REREREZHCGJb0ARAVtRYtWmg9fv/99zFkyBB5PykpCd9//z1+//13hISEwNbWFr169cLIkSNhaKj677Fnzx7MnTtX6z3Onz+f7+PR5TOJiIiIiAqCrUoq1+bMmYP9+/drHgcGBmL16tUICAjAvHnzFPOZRERERFS+MNGjEpWcnIzU1NRi6cmaPXs2evfurXl84cIFTcLl7e2NsWPHyoRr27Zt2LdvH15//XW4urrK14hbVj17eaXrZ5ZFN2+exKFDS5CSkgxX1z5o3/7tHPe/GvEYu+7/h5TUVLS2dYBnjbooL1avPo7du/3w+PEznD8/U6fXHPlPDz57DZCcAgxokYIJXVNQXvj5ncTmzaq61aFDH/TunXPd+umSPw7ffoCwmDjsGdoT5cnq1Tuxe/dJPH4cgfPnv891//8disS2888R9DQZ976shfImL3ErJikRG/z/QURCHAz19NHKxgFd7F9CeZHXuPU0Bnj3ZwMERerByAB4o3kKRndk3MqK+Ds47eBpJCSnICUlFe41q+HNpvVQXuQ1bokyev3bx4hLTEVKCuDZyAQfeFoVy7GWNZyjR8VmzJgxchil+PnHH3+gf//+aNu2LW7fvo3r16/LIZUeHh5o06aNfG7NmjVITEyUrw0ODpavFTeREAm3bt3SbLtx44bcduDAAc22hw8f5ng8Bw8e1NwfPXo0rKys5E818V6FrSQ+Mye+vjsxdaorvL0rICTkXp5eGxR0Cz4+qkZ0SkoS/vhjAQYNWopx47bi8uV9CA29ne1rk1NTsPXuFYyp1xLTm3bE+dBABMU8k8/FxETh44/dkZSk+t2XFjt3+sLVdSoqVPDGvXsheXrtrVtB6NnTR/O4TZs62LBhlM6vT0oGZuw0wPoRSTg4NQk7L+jD/7HquaioGLi7f4zExCSUJkeO7IS3tyvc3CogMDBvdSsg4Bbee09Vt5KTk7Bx4wJMmbIU8+dvxZkz+xAYmH3dEprb2eCr7u0ybY+OjsLQoe6auFJa7Nx5BK6u3qhQwQ337gXm6bW3bgWgZ8/3NI/btGmCDRtm6fz6Ts4m2PVetSyfi4qKhrv70FJXXiUVt4RXazpjhmtnvN+kHc6GPkBAdKTczriVBT3g/VdScPTDJPw2IQlbz+vj0kM9+RTjljZ9PT3M6dwKy706YJlXB1wKfoLLj5/I5xi3MtPX18OGEbbYN9kOf0yujtO34+B7J65Ux62SwkSPit3Nmzdl75oYqih69BISEvD222/jxIkTePr0qfzPKZ4Tid4HH3wge/yqV6+OatVUjZErV65o/RQuX76s9dPGxgYODg45Hoc6OTQ3N4e1tbW8L36Kx4K/v3+hf/eS+MycuLv3w5Ilfqhc2T7Pr922zQe9ek2W9wMDr8DKyh7W1rVgaGiMBg084O9/ItvX3o+ORBVjE9iYmMFI3wCuVexwJUKVuZiaWqJRo044fnwTSpN+/dzh57cE9vaV8/xaH59tmDy5l+axi4sDbGwsdH693wM91LROhVNVoKIR4NUkBYeuqcK3paUpOnVqhE2bjqM08fDoh23b/GBrm/e6tWaND4YOVdWtO3euoGpVe1SvXgtGRsZo0cIDFy5kX7eE+jaVUcW0Yqbt5uaWaNGiE/buLW11ywN+fttgb2+b59f6+KzB5MlDNY9dXF6GjY3udbS5ozGqWWY9osLS0hydOrXApk17UZqUVNwyNTSCk4Uqbou4VbWiGaIS41XPMW5lUslE1K9UeV/ELccqqQiJUj3HuJWZubGR/BmfnIw40TZKTlZtZ9zKUiVT1d/A2MRUxCSkyt690hy3SgoTPSp2z549wxtvvIEjR47I4ZALFixAfHw8KlSogG+++QZHjx5F9+7d5b6nT5/GyZMn5X31kEZ1MicSPT09Pa2kT/1c06ZNcz2OyEjVmVgzMzOt7erHERERub6HWJRF3YOY3S39cNHC+MycPH0aikWLvDFligsmT26CCxdUPYQREcGYO7e73P7JJ+0QGKhKOPMrPj4Gly4dRpMmHvJxdHQYLCxs8N9/R3D69A/y/rNn2fd6RSXEo1KFirj4JAhHHt2GpVFFPE1QnY0T2rb1xtGjG1CUQkOfwtt7EVxcpqBJk8k4cOCC3B4cHIHu3efK7e3afYIbN/LWw5JRTEw8Dh++BA+PJvl+j5BnQDVLYN9lPXx7XB+2lsDjFw0mwdu7LTZsOIqiFB4eig8+8Mbrr7ugf/8m+OsvVd0KCwvGuHHd5fa33mqHu3cLVrdiY2Pg63sYrVur6lZkZBgqV7bB+fNH8McfP8DKygYREXnrUU3P09Mbv/1W1HUrHN7eH8DF5XU0adIfBw78JbcHB4ehe/dxcnu7dm/hxo27BfqcmJhYHD7sCw+P1igq3t6e2LDhNxSlshK30otMiMPD50/x0ovET2Dcyl7wU+DaIz20dFI1xgXGrcw+OXQGb/16GI1sKsPNzkaznXErawNXP0ZLn0C0qm2MTs4VizVulRWco0fFztLSElOniiFwFWBsbCyHYArt2rVD69aqBsv48eM1wxh9fX3RsWNHmeiJbaJHUPQCiuSuZs2amgRPbFP3iBXGPDd1ElmcCvqZ3303CXXquGHatG1y6OOTJ6rhq5s3z0bDhh3h7T0Dx45tlPvNnp39MNFTp7bg118XZNouzqILN2+eg4NDAxgYGGg9L86IC//8s12n421axU71ecH3tbY7Obni7t0L8jsYGqrOcha2SZO+g5tbHWzbNk0Oe3z4UDVMZvbszejYsSFmzPDGxo3H5H4HDszO9n22bDmFBQt+zbRd9P4J587dRIMGDpnKKj9ebSIaSan40Vf7HJ2rqxMuXLgrv4eRUdGE9S+/nIQGDdzw9dfbZK/748equrVy5Wy4uXXEmDEzsHv3RixcOAnffpt93dq/fwvWrctct0Tvn3D16jm89FLmuiV68oSjR3WrW9mpV88V169fkN/ByKio6taXcHNrgG3bvpaf8/Chqrd69uyV6NjRDTNmjMHGjbsxadJCHDjwbbbvs2XLfixYsC7TdtH7J5w7dxUNGrxUKHUrO66u9XDhwvUiLa+yFreSUpKx8eYF9HNsKHv51Bi3shafBEz6xQCzeiXLXj41xq3MFrzSBjGJiVh86gJuhj+FcxXVvDPGraxtGVsNz+JSMOmXMFx6mICmNY2LLW6VFUz0qNjVqlVLJnlCVFQUUsRMWkBeZkAt/X11L5g6eRP/cf/991/cuXMHr776qtwm5vz9/fffmjHZuiR6Yn6cGCL6/Plzre3qx+L53Igeu7xcaqEwPjMnfn4HMW7cKnlfJEjVqjnJ+/7+vvDymijvu7v3lw2mnLRvP1DeshMR8QiVKqX9jszNxZnwUM1jcd/CIvthaJUqGGv14EUlxskePjUDA0OYmFggKioM1taqZLCwHTzoh1Wrxsn7IjlyclINDfb19cfEiV7yfv/+7jLRy8nAge3lLTuPHkXA1rZSgY61WoYePDH8SWxTMzQ0gIWFCcLComBnl9bDUJjOnDmImTNVdUv84XRwUNWtS5d8MXiwqm5169ZfJno56dFjoLxlJyTkEayt0+qOqgcvrW5FRoaicuW8D3FUEws/mZlZyJ5CG5uiqltnsGrVTE1ZOTmphpH7+l7CxImD5f3+/bvJRC8nAwf2kLfsPHokLs9SNL/v9OVlYWGGsLBI2KXrYShMZSVuCWIqwaZbF9HQylZzokqNcSur8gLe32qALvVTX5yoSsO4lTVTIyO0sLfFsTsPNYke41b2LCrqo0t9E+z497km0SuOuFVWMNGjYqdO8tS9e/r6+jLZE9eUU0t/X5381KlTBxYWFnLo55YtW+RrGjduLHvB9u7di82bN2uGQdatm/sKjvXq1cOlS5cQHR2N8PBwOVdO/BSPBWdn51zfQyR548apkoXs2NnZySGqhfWZxdGTmNuZ8QoVTJCQLlGzt2+EyMgghIc/gKWlLa5fP4bXX097vRiGuXnzHKxZo1o4oZaZFcLjYxEa9xxWFSriUngwhtd10/qshIRYGBunO/1bSmQsq9x69ExMKiAuLkHn9xdDMOfM2Yx799Zotrk4pOJhhB7uhQHVKwH7r+jjm6Hai6/ExibAxET1R6500ctTj17FiiaIj0+rW05OjRAWFoTHjx/IBPCff47h3XfTXi+GYa5aJS5ZovuiHHFxpbVu5a1Hz8SkIuLiVHPEdCGGMs2Zswr37qVd3kUXsbFxpbJuFWXcyhiz1HbevwaLCsboVqNOlsfEuJUWt4TPf9eHjXkqxnfOerXN8hi3sopZkXHxSE5JlXOLk1NScCE4DI0znMRh3EqLW2HRyUhKTkX1Soby5wn/OLi/ZFwm4lZxY6JHJapixYpo0qQJLl68KOfjnTt3DvXr15eXHFBTD+cUCaHYV+z311+qOS/isdrZs2flT5H86TKUydPTU17WQFi7dq281IH4qaaeJ1iYivozXV09ceDAavTv/7Fc6EYMgbK1dYSzszvOn98DR8fGOHt2F5ydtef0WFpWRVjYA9ja1tbpzHjNmo0QFHRT60y2l9d0bN48WS5T3rRpb9jYpDWEQkMD0KBB2iqIBvr68HZqjDXXz6kur2DjADvTtMVJIiNDYGxsBjOzolsu2dPTFatXH8DHH/eXZSWGbjo62sLd3Rl79pxH48aO2LXrLFq31k6+q1a1xIMHYahd21anHr1GjWri5s0grW3Llh3BgQOqeaVeXsvg5dUEEyZ0lY8DAkLRrl0Drf3F0uQ+ryVj5AZDeXkF7+YpcE63UGJISCTMzIxhZaU997MwtWnjie3bV2PUKFXdEkM37e0d4eLijuPH96Bu3cY4enQXmjTRrluVK1dFcPAD1KhRW6cevTp1GiEgIK1uiTOzb701HUuWqOpW+/a9USNdIzsoKACurtorbH7/7384fu+RvD9ixxF0caqB4c3qy8dPnoTAxMQMlpZFWbfaYPXq7fj441Ev6tZjODraw93dBXv2HEfjxnWxa9dRtG6tPW+zatXKePAgGLVr19CpR69Rozq4eTNAa9uyZVtx4ICvvO/l9T68vNpgwgRv+TggIAjt2mmPdljwRwR+84uR992/CEQ/NzN83COtbEJCnsDMzARWVum6kAtZaYxbGWOWIFYGPhF8T8aqRZdUc8e72deBW1XVojCMW9pxS6wM/P1fBqhfPRWvLlMNN3+3czJ6N00t13Erq5j1NC4BX5/2k0lecmqqTPJ6Oqs+W2Dc0o5b4c+TMXnzE/n3MCklFa2djPFWG4tijVtlBRM9KnGTJk2Sc/LEgiziZ3ru7u5yfp6aGJIpEj3Rmyfm97388svyrK5IGOPi4vI0P69Zs2bo0aOHvK6dSL7UCZgghoTq8j55HbpZGJ+Zk3feWY7Vq8dj6lTVYjTDhi2UDaZBg+Zi+fLhOHnyFzkkcsKE9Vqv8/aehRUrRsnk6pNPdmkaTtmxt1f1mIaHB2mGVtat20HesnL16nGMHr1Ca1ujytXkLStiwYSWLfugKC1f/g7Gj1+Npk2nyscLFw6Tid7cuYMwfPhy/PLLSTkccv36CVqvmzXLG6NGrZANlF27PtEkfNmpW1fVCAwKCtcMq5w82UPesnL8+FWsWJF2yQ01jwap8GiQ9SUUxGIvffq0RFGaPn05fHzG4403VHVrypSFssH07rtzMXPmcOzb94scEjl3rnbdGjNmFmbPHiWTq6VLd2kaTtlxdFTVrdDQIM3QSlfXDvKWlfPnj+PTT7Xr1ki3BvKWFbHQS+fORV23pmP8eB80bfqGfLxw4RSZ6M2d+y6GD5+JX37ZJ4cVrV+vfV3OWbPGYNSo2bKBsmvXUk3Cl526dR3lz6CgUM3wpMmTB8hbVo4fP48VKz7V2vaJV2V5y45Y7KVPn84oSqUxbmUVs0SCt9Q9++syMm5pxy1xMurel9kvcV9e41ZWMcvRykJeWiE7jFvaccu5WgV5aYWSjFtlhV6qGHBOVAzE9fPE3Do3Nzd56YT0rl27Jnu2/Pz8EBsbK4c7it6tUaNGaQ31FK8X7yOIpOi7777Tem9h1apVaNmypVYyltUF04WkpCSsX79eDv18/PixvIRDz5495edmvIh7+gum5yW5yygvn6k2Y8YitGw5DaXJ4cPrEBERBG9v3S74nRdz5njKxp+Dg6oXJi+OHx+NJUtK10Wy1607jKCgCMycqepZKWyennNk4lq/fs6XFFF7Eg0099GeoL7p9W6oVLF0DHPZsWOdHPY0Zkzh162xYz1l48/JKe91a8OGCfj667EoTdat24GgoDDMnKmKi4XN03OsTFzr11fNm8vNk+hkNPfRXqnWp3k3mBuVjrrFuKU7xq28Ydwqu3ErvUWLdmLatM+gFOzRo2KTMblLr2HDhliyRDWnKSciScwqycrpvXMiEiuRJKqTx+JQEp9ZFLp0GYFDh9KGnRYWceHhzp2H5SvJK61GjOiCtWsPFcl7iwsPDxvWWeckryzo23cEfv218OuWuPBwr17D8pXklVYjRvTF2rWZ54gWBnHh4WHDeuWrsVRaMW7pjnErbxi38lK3GLeKC6+jR+WG6I0TvXs///xznl4nevLE69S9eaQi5kH26JHzQjT5IS48LBI9pZXVuHHZz7UqCHHhYZHoKa28Bgwo/LolLjzcu7cS61bWQzULSlx4eNgw7VEQZR3jVt7KinErb+XFuJWXusW4VRyY6BERERERESkMh26S4hVkPp0g5vVlnNtHRERERFSasUePiIiIiIhIYZjoERERERERKQwTPSIiIiIiIoVhokdERERERKQwTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekTlyJIlb2LSpEb48st+WtvPnNmBCRPqY+pUV9y/f7lAn7Fnz1I8fx6Z635+fofw7rt1MXJkdezcuQilzZtvLkGjRpPQr9+XWtt37DiD+vUnwNV1Ki5fvl+gz1i6dA8iI5/nul9AQCg6dPgUlpZDYGs7HB9+uAGpqakoTT755E3069cIU6Zo163Dh3egT5/68PZ2hb9/werWjz8uRVRU7nXr00/fQtu2leDioofAwHua7QsXToGHhz1atTLD2293xYMHt1ES3nzzEzRq1A/9+k3R2r5jx2HUr98Hrq7euHzZv0CfsXTpj4iMjMp1v7fe+hSVKrWFnp4L7t0LzPT8//63UT43Z85KlPeYFRoagE8/7YAhQywxfLgtNmz4UOv/4W+//Q/9+ulh8+Y5KCllIW4lJSXj4483olat0TA3H4w5czajvMes0NAg9OvXGC1bmqB9e2t89tkoJCTEIykpCUuWfAxPz1po3docK1eWZN0qHXErKCgUjRv3g4lJS1hbt8eoUZ8hPj4Bfn7X0aLFIJiatkKzZgNw7tyVAh2LUvCC6UTlREREMC5dOozvvw/O9NyhQ2swatRSuLn1KPDniEZT69avwczMKtt94uNj8NVXA9C4cRc4OjbBxo0fo0GDDqhfvw1Kg+DgCBw+fAnBwd9nem7NmkNYunQUevRwK/DniAbTa6+1hpWVWY77RUXFoEkTR3z4YV/8++8dfP75VrRqVRcDBrRDaRAWFgxf38M4dixz3dq+fQ2mTVuK9u0LXrd++mkpunZ9DZaW2dctQU9PDy1bdsGxY79pbU9IiMPEifNhZmaJBQsmYMGCiVi58g8Up+DgMBw+7Ivg4GOZnluzZjuWLp2GHj3aF/hzli79Ca+91hVWVpa5llWXLi3x22+Zj+fhw2D4+KxBSSlNMUuIiYmS8apv3w9x586/2Lr1c9St2wrt2g1AWNhDbN/ug5JUVuKWSACXL9+LhQuHwd7eGuHh0SjvMUtf3wC9er0JZ2cX3Lp1FUuWTEOTJq3x/Pkz/PzzckyZshA2NvaIigpHSShNccvAQB9vvtkLLi7OuHr1FqZNW4LWrZvg55//kM9t3OiDxYs3YNKkL3HmzCaUd+zRI1KYv//ejcmTm2DSpMb49tvxSE5OxsaN0/HZZ10RHR0uz4Crz45fv35aPv7vv1NYu3aC1tnxa9dOycfi9v77zRASck+TpH3zzWh89FFLTJ3aFCdO/Cy3nz69Xe4bEfEI8+Z5yfv+/mezPMabN/+WZ9D79JmKN96YAUPDCvDzO4Ditnv332jSZDIaN56E8eO/lWU1ffpGdO36mWx8iLPf6jPjp09fl49PnfoPEyas1TozfurUNflY3Jo1ex/37oXI7TEx8Rg9+hu0bPkRmjadip9/PiG3b99+Wu776FEEvLzmyftnz2Z/JrRxY0esXDkWffu2xvvv95HbHj0q/j/4x47tRv/+TeSZ53nzVHVr6dLpeOedrnj6NFyeAVefHffzOy0fX7hwSiZV6c+O//vvKflY3AYMaKbpdYuNjcGcOaMxeHBLvPFGU+zdq6pbBw9ul/uGhDzCe+95yfuXLmVdt4T583+QjauMZs36Fq+9NhKvvPI6XFzcERr6qAjr1jE0adJfnnkeP37ei7olGn3vIDz8qTz7rT4zfvq0n3x86tQFTJiwQOvM+KlT/8rH4ibOUqt73WJiYjF69By0bDkYTZu+gZ9/3iu3b99+UO776FEIvLzek/fPnr2U7XH+8MN82bDKypQpizBqVOZyLI8xS3B0bIyxY1eideu+6NPnfbktPFxVh9avF73Fo1Acynrc2rjxTwwd2hGTJvXCG2+0xZgxnijvMatKFVu8/fZ0tGrVFc2aqU7gmZpaYM+ejfDyGoqhQyfB0/MNvPHGGBSlshC3bG2rYPr0t9G1qzjJ0kxus7AwxfPnsahRoxrc3V3kT2PjCkVaVmWFXmppG/9DRJnMmLEILVtOy7VkRINm3LiX8OWXZ2Bj44jPP+8uGx8dOgyWjZ6ZMztjzZq0oWxqYvugQXPQuHFnzbYvvuiDDh2GoEOHQYiNfQY9PX1UrGiGTZtmwNy8Ml577UPExkbj/fddsXDhWVhaVpGvGzOmNnx8/oStbW35+Nq1k1i7dqLW50VHRyAsLACDB3+OgIArcp8WLXrh3XcL3ntw/PhoLFnSM9f9RGPmpZfG4cyZL+HoaIPu3T/HqFEeGDy4g2zwdO48E/fuZT4esX3OnEHo3LmxZlufPl9gyJAOGDSoA549i4W+vh7MzCpixoxNqFzZHB9++Bqio2Ph6vo+zp5diCpVVGcra9cegz//9EHt2rby8cmT1zBx4tpMn/nHH7PkmW9h4cId+OyzX3Dt2nLUqWOXrzJ6Eg009zHS2rbp9W6oVNE429eIBo2X10v48cczsLd3xLhx3fHaa6Pg5TVYNnrefrsz9u/PXLdGjeqM8ePFH/a0ujVxYh94eQ3Bq68OkmesRd0yNTXD8uUzYGlZGSNGfIiYmGjZOPrpp7OwslLVrR49amPduj9Ro4aqbv3zz0l8+aV23RK++eYPnDlzELNmjcS+fXc1+6uJIZuiUSYaVmPGzNS53DZsmICvvx6b636iMfPSS144c+ZHODrao3v3cTJhGjzYSzZ4Ond+G/fu7c/0us6dR2HOnPHo3LmlZlufPhMxZIgXBg16Fc+ePX9Rt0wxY8ZyVK5siQ8/HIHo6JgXDaOfUKWKquegdu0e+PPPdahdu4Z8fPLkP5g4UXs4n/DHH9/g4MEzGDlyFu7e3afZf9++kxg7dh7++28XzM3dMXv2OMyZ826u3/1JdDKa+2gPAfVp3g3mRsZlOmYJs2b9AWtre3l/x46F+OWXz7B8+TU8euSPb78di//7v/8weLA5Bg6cLY8tL8pT3GrW7AM0alQT//33UPbALFv2Nt58M+33WFhxq6zFLFtbezncXPD2HoeZM1fKIeh16jTC3bv/yV6/jz9eJnv+8kKpcatGjW7y/rhx3li5ciZOnPgHvXpNkO9bqZIFTp3agMaN6yKvFi3aiWnTPoNScOgmkYIEBt5AlSoOqFbNST5u1aqvPEMtGk151aBBe+zYsUAmZK6unnBycpXbL1zYLxtnx4+rhkQkJSXg8eM7mkZTRg0bdsCSJX5a2/76a5scuimGS3l6jpENL9GrV5xu3AiEg0MVODlVk4/79m0lz06LBlNetW/fAAsW7EBAQBg8PV3h6qoq//37L8iG2aZNx+XjhIQk3LnzWNNgyqhDh4bw81uS7ef8/vs5zJz5M1auHJPvJC+/7t27gWrVHODgoPpuXbr0xeXLZ2WjKa+aNWuPdesWICgoAG3beqJ+fVXd+uuv/YiLi8Hevaq6lZiYgIcP72gaTRk1b94B27Zp163ciLP4kyb1QePGrTByZO4nT/Ljxo17cHCoBicnB/m4b98uOHv2smww5VX79s2wYME6BAQEwdOzLVxd68vt+/f/hZiYOGzapDojnpCQiDt3HmoaTBl16NAcfn7bdPpMMS9InKH//PP3kJiYJLfFxSUgMTERRkbaDe3yErPSO3fud/z880yMGbMStraOmDvXU560Sk5O1AwRTkpKhKFh4ZaVUuJWXFwiHj58gi1bPsTixbswfvxqmWwaGhqgvMcskZT+888JLFs2HR06eCE+Pg6PHz/EokVbsGHDYvj4jEePHoNgaFj4zfeyFrdEQiqSu+nTl8HLqwO2bz8kh3POnfsuZs9eiY8/Xoq9e79BecdEj4iy1K/fNLRq9RouXjyEBQv6Yty41Zr5MFOn/oQ6dXSb65HV2fG4ONVEfjF8096+Hp49C0flysWbuBSmadP64bXXWuHQoYvo23cBVq8ep5kL89NPU+HmVken98npzPidO8EYMOArzJs3GKNHF91Qp+IwatQ0ObTS1/cQJk/ui1mzVmvmwyxY8BMaNtStbuV0djwrMTHP8d57PVGxoimWL/8NRkalf2jPtGmj5NDKQ4d80bfvZKxePUszF+annxbAza2hTu+T05nxjMQZcdH4Er18I0eqti1cuB6urvXkGfryGLPUPXrBwXfkSarBg+fB03O0jGEiafy//xspb8LOnQtlkil6Fkuzkopb1atboV27+ujevRnu3n2MI0cuITz8GWxtc57HpvSYJXr0mjZ1l7cfflgsk8iqVavD1bUd2rXrjsDAuzh79og8WSWGepb3uOXu3lTeFi/+QSaQ27Ydwtdff4Bu3dxx8+Z9fPDB14X+vcoiJnpEClKjRj08efJQDnmqWrWWnPvi4fGipZZHjx7dRI0azvImFh4Qw5NEo0mcKd+/fyXGj18DfX19XL9+BvXquctFHQQzs0p49uyJZhhUVmfHxdnut9+ugd27l8jFDcQZ9hYtch+2VJjq1ashzyqL4U61alWV815GjvTI13vdvPkIzs415E0sOuDv/0g2mMRZ8pUr92PNmvGyrM6cuQ5393qasqpUyQxPnjzTDIHK7sz49esP0avXfHkGXrz+zz+vyNeoX1ccateuJ88siyFPdna18Oefu9G3b/7q1v37N1G7trO8/fffv7h/3182msSZ8i1bVmL2bFXdunjxjJxLpy4vc/NKePr0iWYYVHZnx3//fZN8rXD06C65v2ikvf/+63II1Ny563Ht2j+oUKGibFQVtnr1auPhw8dyuFOtWnbYvftPjBzZN1/vJRoszs615e3ff/+Dv/992WASZ8lXrtyCNWtmv6hbF+XclLS6ZY4nT55qhkBld2Z806bf5WuFXbuOyv179eqIY8fWafbp0uVtDB/eR86JKa8xS3j48Drmz+8lew7F669c+VP2Rs6bl7ZAxaxZXdCly3A0aZL1vMeCUkLc6tbNRfYa/vbbWWzefArVq1eGjU0llOeYdebMIRm36tZtLBdjiYgIg6OjM9zdu8mETywstX//Zpn4WVvboCiUlbh16NAZGbfEsEyxGEtYWAScnR1Ru7Y9vv/+N9SsWR3r1u2U34eY6BEpirGxqWzMzJ/fWy5jLRokbdsOyNd7iYbRhQsHYGBgKOfOdO06Qm4fMGAW1q+fKhc1SElJls/NnLlXE6h79pwsl0S3sKiCt99eipdfbpHpvcWQJnGGfc2ad3H9+l946y3VGfDiZGpqLBsyvXvPl2UlGiMDBrTN13uJRtGBAxfk0CMxb2bECFUjb9asAZg6db1c0CA5OUU+t3fvTE1ZTZ7cUy6HXqWKBZYufRstWryc5fv7+vrj6dMYeeZd3ITZswfKOTfFxcTEFJ99tgYTJ6rqlptbe3Tvnr+6JRpGp0+r6padnSP69lXVrTFjZmHxYrFAj6puiee++Satbg0dOlkuiS6GRYlV8Ro1yly3hE8/Haa5L95PzM8RiZ74TEEkfILYntUcnYIyNTXBmjWfoXfviS/qlhsGDOier/cSjaIDB06/qFt2GDFC1fCaNWsMpk5dLBc0UNUtOzlMKa1uDZXLoYshUWJFvBYtGmX5/sOGfaq5L95PzM0RZ+LTz7cRRCNKLIJQXmOW4O/vi5iYp7LHUNyErObjiYTRyqpoTsIoIW4tWjQcoaFRGDZsGezsKuPHHydr3ru8xiwx/27nznUICroPMzMLuejKwIHjER0dhfDwUBnTqla1wxdf/FgkZVWW4paY1ykSufv3g2BhYYYxY97A+PED0bJlY4wf74MBAz5C/fq18d13JXcpitKEi7EQKWgxFtJ9UYPyLD+LsZDuixqUZ3ldjIVUGLd0qVuMW/nBuFW+F2Ph5RWIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhheB29Mqr29L1aj2f1aoi32zvJ+0sP++OvW2G4+PApEpJS5LYDUzqiXnULzf7bzj/AR9svab3HvS/zv1JhYnIKVh67je3/PsDjp/GoVskYb7jVxLtd6sDIgOcTiIiIiIiKExM9BVp36i6exSUV62d+uO0ifvN7pHn8IDwWSw77425YNJYOalasx0JEREREVN6xq6UIJKekyh6u4rD4DRfZE6fuzRMGtKiJ/w1oiqGta2X7Ou8WNeXrxOsL6u+74Zok7602jrgw6xX5U9jl9wjn7oUX+DOIiIiIiEh37NEroIGrz+Ds3XC0drLGoFY1sfzILQSEx2D3hHZITRXDKG/i/P1wxMQnw6GyCfq42uPdzi+jgqE+AiNj0e7Lo/J9lg50xWvNauBG8DN0X3pCbts7qT0a2VfC7ouPMOmXC3LbiY+6oFYV0xyPSQzjFO4/iUFx2HMxrSdvkkddVDarIH9uPHNf83zL2tbFcixERERERMQevULzX1AU3t96EXfDnssevfikFLy+6jQO//cYkTGJSEhOwZ2w5zLxG/PjeaSmpqKGlQnsK1WUr/d7EPniZ4TmPS8EqLb9e1+1rZqlca5JXkm4FhQlf1pUNERVc2N5X/wUj+Xzj1TPExERERFR8WCPXiGJikuSwxXff8UZ0fFJGLPxH5nsiZ679cNbokmNSpj12xXZO/fnjVAc+S8E3RpWQ4va1nLbhYAITXKnpwfZGyjuv+nuiAsvksAWjsXTK3bm9hMMXuub4z4iSf1reld5P+J5gvxpYaxdncRjMVcw/MXzRERERERUPDhHr5BUMjHCjJ4NYGVaAVXMjHE9WNWL1aWeDdrXrYpKpkb4wNNZs//Jm6HyZ8valeXP/4KeIT4pWfbsOVUxg1NVM1x4ECG3/feiR6zFi33LilT1Hb2SPQ4iIiIiovKGPXqFRCRmxoYG8v7T2ESkvMhy7CqZaPap/mKYphAekyh/ih49QQztFIua+D9+JufqCTsvBOL0rSfyOaG45rm1qVMlT5daEHPyEPYcz+K1V/oUPZuCtWmFQj/G8ibk2R3sPj66pA+jTEh+HIUPR+8u6cMo1eL1KgDWvbW2fb/5ExiDve85iQ2JxIcTVhXxb6dsi0cFwPwVrW37T7+PCqxbOWLc0qFuMW7lC+NW3iRDWZjoFRJjQ32t3j19PchkL/hpnGZ7+vvWpkbyZ71qFrCsaCiHfv5w+p58TbOaVhDjN3f8G4j1f92V+5kbG6KBnSVK49DNhnaW+Od+hBymGRYdL+fniZ/qSzw0tC+e41YyW4cqaDmtZUkfRplwfPRufNWzT0kfRqn2JBHY84/2tpFz30Ilc9XJKsrahgmr8NXY8SyenOpWXDL2/Bqota3HvFdgbs5iywnjVu4Yt/KHcStvFu3cCSXh0M0iYFLBAG61VMMsj90IwelbYbKXb8khf80+7evaqH4B+npwc1Tte/R6iPzZrFZlVbIH4NStsBfbrGAgskcdPI1JlPPi4hLTzktExam2Pc/Q61YYeje119xffuSmnLMnfmb1PBERERERFT326BWRT7zqY/Das3JBliHfndV6rkPdqujWwFbzWAzJFAu0iN68ikb6qF/dAnp6ejAxMkDsi2QtLwuxeC0/KS/dkJ73t2fkz9fdHPD1gKaFOnSzlZM1+rray2vpiUsqqC+rILzmas9LKxARERERFTP26BWR5o7W2D6uDTzq28qhmUYGeqhdxRSTur6M74a3kImcWosXPXqCWJ3T0EBf9t65OFTSbFcv2lJafeXdFFO61UVNaxP5XcVP8Xixd85JJRERERERFT726BXQlrFtsn3OxcEK60bkPq+q9UtZ96Dl9N45Uc+dK05GBvqY0s1Z3oiIiIiIqGSxR6+M+2j7JdSevhfrTqkWbdHVtvMP5OvE64mIiIiISFmY6BERERERESkMh26WUXlZLCUr3i1qyhsRERERESkPe/SIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhjO0SOiQnF89XH47fbDs8fPMPP8zFz3v/qfHnbtNUBKCtC6RQo8u6aUm9/E6uPHsdvPD4+fPcP5mbmXlXAkQg8+9w2QnAoMsE3BhBrlp7x2rt6Jk7tPIuJxBL4//32u+//9XyzW7Y2QdatbCzMM7Jp2TVKlW71zJ3afPInHERE4/33uZSUceRgLn38jVHWrjhkmNC4/5cW4pTvGraKLWQLjlu5xqzzHrLxijx4R5UvQrSD49PTRPK7Tpg5GbRil02uTk4GtOw0wZkQSpk9NwvkL+gh6rHouJioGH7t/jKTEJMX8Zm4FBaGnT1pZtalTBxtG6VZWQlIqMOOuAdbXS8LBpknYGaoP/xjVc1ExMXD/+GMkJimnvAJuBeC9nu9pHjdp0wSzNszS6bXJyalYuTMcs0fY4JupdvjzwnPcf5wgn4uOisZQ96FITEyEUtwKCEDP99LKqk2TJtgwS7eyEpJSUjHj73Cs72yDg73ssPPuc/hHqsorKjoa7kOVVV6MW7pj3Mp/3MpLzBIYt3SPWznFLKXGrYJgokdE+bLNZxt6Te6leezg4gALGwudXnv/gR6qWKfCpipgZAS4NknBlWuqcGRqaYpGnRrh+KbjivnN+Gzbhsm90srKxcEBNha6lZXgF62HmsapcDIBKuoDXlVScChCVV6Wpqbo1KgRNh1XTnmt8VmDoZOHah6/7PIyKttU1um1Nx4koJq1IeyrGqGCkR7aNTHF39di5XPmluZo0akF9m7aC6XwWbMGk4emlZXLyy/DprJuZSX4hSWgprkhnCyNUNFAD161THHooaq8LM3N0alFC2zaq5zyYtzSHeNW/uNWXmKWwLile9zKKWYpNW4VBBM9IoUJuReCMbXHYMNHGzDFZQom1J+AiOAIzO0+Vz7+pN0nCLwRiKDbQfio1Udar01JScEou1FIFl1uOYiPicelw5fQxKNJvo4x6hlQyRK4eFkPR47rw9ISeBqV9nxb77Y4uuEoitq9kBDUHjMGH23YAJcpU1B/wgQER0Sg+9y58nG7Tz7BjcBA3A4KQquPMpeV3ajcyyomPh6HL12CR5P8lZUQkgBUqwDse6KHbx/pw9YIeNFJJXm3bYsNR4u+vALvBaJH7R74+qOv8brL6+hTvw/CgsMwrvs4+fitdm/h7o27eHD7AYa0GpKpvLradc21vGJjYuF72BetPVrn6xgjniWjiqUB/rocg1+PR8Ha0gBPotI+09PbE79t+A1F7V5gIGr36IGPvv4aLq+/jvp9+iA4LAzdx42Tj9u99RZu3L2L2w8eoNWQzGVl1zX3soqJjcVhX194tM5fWQkhccmoZmqAfQEx+PZqFGxNDPA4Nu1zvT09seG3oi8vxi3dMW7lDeOWsuJWbjGrOONWWcA5ekQK9OThE9Rxq4MRi0cgOiIaP07/EQ07NoT3DG8c23gM3036DrMPzEZkcKQcIhn2IAwVzSsiKjQKDg0dcGb7Gfy64NdM77vEb4n8efPcTTg0cICBgUGBjrNpk1QAqTjlq33OycnVCXcv3JXHZmhUtGHq4ZMncKtTB4tHjEBEdDSm//gjOjZsiBne3th47BgmffcdDsyejeDISDk88kFYGMwrVkRoVBQaOjhg+5kzWPBr5rLyW6Iqq3M3b6KBQ8HLSni1iqq8fgzWLi9XJydcuHtXHp+RYdGW1+OHj9HArQE+WPwBoiKisHT6Urh1dMOYGWOwe+NuLJy0EN8e+FYmgGLozOMHj2FiboKI0Ai81PAlHNp+COsWrMv0vtv8tsmfV89dxUsNXipweYmePOEP32da2+u51sP1C9flsRmJ7uQi9PDxY7g1aIDFH3yAiKgoTF+6FB3d3DBjzBhs3L0bkxYuxIFvv5UNKXE8Dx4/hrmJCUIjItDwpZew/dAhLFiXuaz8tqnK6tzVq2jwUsHLSni1lqq8fvTXLi/XevVw4XrxlBfjlu4Yt/KGcUt5cSu7mFXccau0Y6JHpEAiaeswuIO8b17ZHP6+/vCa6CUfu/d3l4me4NTMCfcv3ZdJnUjcqtepjnpt6qH9wPbylp2IRxGoZJv/yc+VMvTgRUWptqkZGBrAxMIEUWFRsLazRlESSdvgDqqyqmxuDl9/f0z0UpVVf3d3megJzZyccOn+fZnUicStTvXqaFOvHga2by9v2XkUEQHbSgWbKC5689L34IUkqrapGRoYwMLEBGFRUbCzLtryMjU3hddgVflYVrbEJd9LGDxxsHzcrX83megJ9ZvVx81LN/Hdgu9k4lazTk00bdMUPQb2kLfshDwKgbVt/r9Dxh688ChVD5+aoaEhzCzMEBkWCRs7GxQlc1NTDH5RlypbWsL30iVMHKwqq/7duskGk9Csfn1cunkTC777TjaA6tSsiTZNm2Jgjx7ylp1HISGwLeDvu5o4Gx6TVl4hsclyW/rysjAzQ1hkJOxsira8GLd0x7iVN4xbyolbucWs4o5bpR0TPSIFMrMy02m/+m3r48aZGzA2M0bw7WA8C3+G5l7NcWrLqRx79CqYVEBCXLrMIxdiGObmOZux5t4a+biWQyrCI/QQGgZYVQIuXdHH8KHai4kkxCbA2MQYRc3KTLeyalu/Ps7cuAEzY2PcDg5G+LNn8GreHFtOncqxR8+kQgXEJeheVmII5pzNm3FvjaqsBBezVDyM18O9OKB6BWB/uD6+qatdXrEJCTAxLvrysrDSbW6ha1tXXDxzESZmJnIo59Pwp+jg1QH7t+zPsUevoklFxMfF63w8YhjmqjmrsP/efvm4rkMFhEQk4VFYIqpWMsTpK7H4eGgVrdfExcYVT93ScR5mW1dXnLl4EWYmJnJIVPjTp/Dq0AFb9u/P8cy4ScWKiIvXvazEUKY5q1bh3n5VWQkuVSrg4fMk3HuWiOqmhtj/IBbftNcur9i4uGKpW6UpbmWMWQLjVvYYt3SPWxljlsC4pXvc0iVmFWfcKu2Y6BGVA87uzji/5zwcGzvi7K6zcG7tLLeL3rvV41fDa4IXAq4G4NKRSxgybwgsrC1y7NGr2agmgm4GaW07suwIrhy4Iu8v81qGJl5N0HVCV/k4NCAUDdo10OwrRmx4v5aMNRsMVZdXaJ4Cu2pp7xUZEikbcbo2/AqTu7Mz9pw/j8aOjth19ixaO6vKSvTejV+9GhO8vHA1IABHLl3CvCFDYG1hkWOPXqOaNXEzSLuslh05ggNXVGXltWwZvJo0wYSuqrIKCA1FuwZpZSUY6QM+TskYed1QLiftbZMCZ9WoFSkkMlImoLomrYXJxd0Fx/ccR93GdXF011E0aa2ai+jSxgXzx8/HoAmDcPvqbZw9chYT5k1AJetKOfbo1WlUBwE3A7S2bV22Fb4HfOX9973eRxuvNvCe4C0fBwUEwbWdq2ZfQwM9jH/NGnM3hKour9DcDI7puj+fhDyRyaelVbou5GLi7uKCPcePo3Hduth19Chav5i32cbFBePnz8eEQYNw9fZtHDl7FvMmTIB1pUo5nhlvVKcObgZol9WyrVtxwFdVVl7vvw+vNm0wwVtVVgFBQWjnmlZWgpG+HnxaWmPksVBV3XrJDM5WaeUV8uSJTECtxETachS3MsYsgXGLcUvXuJWXmCUwbuket3KLWSUdt0obJnpE5cCguYOwfPhynPzlpBwSOWH9BLn95RYv45H/IzT1bIrKdpXlAiuisZQb+7r28md4ULhmaKXHZA95y8rV41cxesVorW2NGqSiUYOsLwkgjqNln5YoCXMHDcLw5cvxy8mTcjjk+gmqsmrx8svwf/QInk2bwq5yZbnAikjyclPXXlVWQeHhmmGVkz085C0rx69exYrR2mUleFROhUflrMtLHEufliVTXu/OfRczh8/Evl/2ySGRc9fPldsbtWiE+/730dazrRwiKRZYEUlebhzrOsqfoUGhmqGVAyYPkLesnD9+Hp+u+FRrW6sGJvKWFXEcnft0RkmY++67GD5zJn7Zt08OK1o/V1VWLRo1gv/9+/Bs21YOMxILFYgkLzd1HVVlFRQaqhmeNHnAAHnLyvHz57HiU+2yEjwcTOQtK+JY+nTuXO7iVlYxS2DcYtzSJW7lNWYJjFu6x62cYlZJx63SRi81NVXM7ieiUmzGohloOa1kGvLZObzuMCKCIuA9U3XWrTDN8ZyDd5a/A4f6Dnl+7fHRu7GkZx+UJusOH0ZQRARmvjhDWdg858zB8nfeQX0H3crrSSLQ/B/tCeqbZtZAJfOCL+pRGHas24GwoDCMmTmm0N97rOdYTF8+HU71nfL82g0TVuHrseNRmqzbsQNBYWGYOabwy0rwHDsWy6dPR30n3crrSVwymv8aqLXNZ2YizM1RKjBu6Y5xK28Yt8pu3Epv0c6dmPbZZ1AKXl6BiPKly4gusKiq+7XgdCUumN55WOd8JXml1YguXVA1D9fNywtxwfRhnTvrnOSVBX1H9IVVVatCf19xwfRew3rlK8krrUb07YuqVoVfVuoLDw/r1StfjaXSinFLd4xbecO4lYe6xbhVbJjoEVG+iKWRe4zLfv5QfokLpotET2llNS6HuVYFIS6YLhI9pZXXgHFZD+MpCHHB9N7DekNxdSubIU8FJS48PKy38sqLcUv3smLcylvdYtzKQ91i3CoWTPSIiIiIiIgUhokeERERERGRwjDRIyIiIiIiUhgmekRERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihTEs6QMgKmotWrTQevz+++9jyJAh8n5SUhK+//57/P777wgJCYGtrS169eqFkSNHwtBQ9d9jz549mDt3rtZ7nD9/Pt/Hs2bNGvz999+4du0aEhIS5LbNmzfj5Zdfzvd7EhERERGlx0SPyrU5c+Zg//79mseBgYFYvXo1AgICMG/evCL5zJ9//hnR0dFF8t5ERERERAKHblKJSk5Olr1qxWH27NmyJ07dm3fhwgVNkuft7Y3Dhw/Ln8K+ffvg5+cn7/fu3Vu+Try+MPTp00f2EL7++uuF8n5ERERERBkx0aNiM2bMGDmMUvz8448/0L9/f7Rt2xa3b9/G9evX5ZBKDw8PtGnTRj4nhjgmJibK1wYHB8vXiptIwoRbt25ptt24cUNuO3DggGbbw4cPczyegwcPau6PHj0aVlZW8qeaeK+iIL5nz549YW1tjZLmu9MXU12nwruCN0LuheTptUG3guDT00fz+ObJm1jZfyVW9F2BU+tO5fr6q//pYf5Xhpi3yBAHj6aFopioGHzs/jGSEovnBICudvr6wnXqVFTw9sa9kLyV1a2gIPT0SSur1cePo+eyZWiRbltujkTooYufITpeMMSKwLTyioqJgfvHHyOxmE6Y6OrIziPwdvWGWwU3BN4LzNNrA24F4L2e72ke+530w/T+0zGt7zTsWbcn19f/dCgSIxcEovf0AK3t0VHRGOo+VBNXSoudR47A1dsbFdzccC8wb2V1KyAAPd9LK6vVO3ei5/vvo8XIkTq9/n+XItFmZyBq/6RdVkJUdDTch5a+8iqpuBUTA6z8zkDGrYVLDHHsBONWTp4mAUOvGaCrnyG6XzTE2keMW9lJSUnFhyuDMWlZECYsCcKmg5Ga5xi3siiv1FT0OxCMV/8IQvffg/D1xchSH7dKChM9KnY3b96UvWNieKTo0RPz1N5++22cOHECT58+lf85xXMi0fvggw+QmpqK6tWro1q1avL1V65c0fopXL58WeunjY0NHBwccjwOdXJobm6uSbrET/FY8Pf3h9K593PHEr8lqGxfOc+v3eazDb0m95L3U5JS8MeCPzBo6SCM2zoOl/ddRujt0Gxfm5wMbN1pgDEjkjB9ahLOX9BH0GPVc6aWpmjUqRGObzqO0qSfuzv8liyBfeW8l5XPtm2Y3EtVVkKbOnWwYdQonV+flArMuGuA9fWScLBpEnaG6sM/RvWcpakpOjVqhE3HS1d5efTzwDa/bbC1t83za9f4rMHQyUPl/eSkZGxcsBFTlk7B/K3zcWbfGQTezjkZau5sgq/eU8WL9MwtzdGiUwvs3bQXpUk/Dw/4bdsGe9u8l5XPmjWYPFRVVkKbJk2wYdYsnV/fyc4Eu7pnLivB0twcnVq0wKa9pau8SipuQQ949ZUUzPgwCe9PSMLZ8/oIeKgnn2Lcytr7NVNw1DUJvzVJwtZQfVyKVpUX45Y2fX09zBlhi+WT7bBscnVcuh2Hy3fi5HOMW5np6+lhQ2db7POywx9e1XE6OA6+j+NKddwqKUz0qNg9e/YMb7zxBo4cOSIXOlmwYAHi4+NRoUIFfPPNNzh69Ci6d+8u9z19+jROnjwp77u6umolcyLR09PT00r61M81bdo01+OIjFSdATIzM9Parn4cERGR63uIIZ3qHsTsbmLoZ3F5GvoUi7wXYYrLFExuMhkXDlyQ2yOCIzC3+1y5/ZN2nyDwRt56DTKKj4nHpcOX0MSjiXwceCUQVvZWsK5lDUNjQzTwaAD/E9knyvcf6KGKdSpsqgJGRoBrkxRcuZYWjtp6t8XRDUdRlEKfPoX3okVwmTIFTSZPxoELqrIKjohA97lz5fZ2n3yCG3nsYckoJj4ehy9dgkcTVVkJLg4OsLGw0Pk9/KL1UNM4FU4mQEV9wKtKCg5FpJWXd9u22HC0aMsrPDQcH3h/gNddXkf/Jv3x14G/5Paw4DCM6z5Obn+r3Vu4e+NugT4nNiYWvod90dqjtXx858odVLWviuq1qsPI2AgtPFrgwgnV7yo79R2NUcUy6ynont6e+G3DbyhKoeHh8P7gA7i8/jqa9O+PA3+pyio4LAzdx42T29u99RZu3C1YWcXExuKwry88WqvKSnB5+WXY5OFkRHMbY1QzzX66vrenJzb8VrTlVVbilqkJ4OSYKu+LuFW1SiqiotKeZ9zSVskQaG6hKi8RtxwrpiIkXScL45Y2c1NVTI9PTEVcQioSElVlJzBuZVbJWFVescmpiElORVxyarHGrbKCi7FQsbO0tMRUMQSuQgUYGxvLIZhCu3bt0PpFg2X8+PGaoZO+vr7o2LGjTPTENtEjKHoBRXJXs2ZNTYIntql74dRJYUGok8iy5LtJ36GOWx1M2zZNDn188vCJ3L559mY07NgQ3jO8cWzjMbnf7APZzzk8teUUfl3wa6bt4iy6cPPcTTg0cICBgYF8HB0WDQsbC/x35D9EPIyQ93M6Mx71DKhkCVy8rIewcD1YWgLBL3r0BCdXJ9y9cFd+B0OjoglTk777Dm516mDbtGly2OPDJ6qymr15Mzo2bIgZ3t7YeOyY3O9ADvMzt5w6hQW/Zi4r0fsnnLt5Ew0c0soqP0ISgGoVgH1P9HA/Xg+2RsDN2LTnXZ2ccOHuXfk9jF6sFlvYvpz0JRq4NcDX276Wve6PH6p+YStnr4RbRzeMmTEGuzfuxsJJC/HtgW+zfZ/9W/Zj3YJ1mbaL3j/h6rmreKnBS5ryigyLRGWbyjh/5DxCHobAysYq1x69nNRzrYfrF67L72AkWutFYNKXX8KtQQNs+1pVVg8fq8pq9sqV6OjmhhljxmDj7t2YtHAhDnybfVlt2b8fC9ZlLivR+yecu3oVDV5KK6ui4FqvHi5cL9ryKitxK73Ip8DDR3p4ySmtccm4lb3gBODacz20fJH4CYxbmX2y+jFuPkzAKy3M4OZcUbOdcStrAw89xqUnCRhQxwyd7CoWa9wqK5joUbGrVauWTPKEqKgopKSkyPvi0gZq6e+re97UyZv4j/vvv//izp07ePXVV+U2MedPXLJAPSZbl0RPzMkTQ0SfP3+utV39WDyfG9FjV5BLLRQ2v4N+GLdqnLwvEqRqTqohWf6+/vCa6CXvu/d3lw2mnLQf2F7eshPxKAKVbCtl2i7OiAv/bP9Hp+Nt2kT80U/FKV/twQUGhgYwsTBBVFgUrO2KZi7jQT8/rBqnKiuRHDm9GBrs6++PiV6qsurv7i4TvZwMbN9e3rLzKCICtpUyl1V+vFpFVV4/BmuXl6GBASxMTBAWFQW7Ipr7eebgGcxcNVPeF384HZxUQ6Mv+V7C4ImD5f1u/bvJRC8nPQb2kLfshDwKgbVt5u8gevKEo9sL1nMpLptiZmEmE0gbOxsUhYNnzmDVzLSycnoxjNz30iVMHKwqq/7duslELycDe/SQt+w8EpeEKeK5vqK8LMzMEBYZCTuboimvsha3xHTYjb8YoF+vZNnLp8a4lbX4FGDSTQPMckyWvXxqjFuZLRhbDTFxKVj8S5hM+JxrGqvKinErS1teqYZniSmYdCoMl8IT0LSKcbHFrbKCiR4VO3WSp+7d09fXl8meuI6dWvr76oSrTp06sLCwkEM/t2zZIl/TuHFj2fO2d+9eeS069dDLunXr5noc9erVw6VLl+SlDsLDw+X8PPFTfekDZ2fnXN9DJHnjXiQL2bGzs5NDVEuzjL2XuZ0Zr2BSAQlxqmsACuY25ngW+kzzWNy3sM1+aKLozXuabsiTGP4ktqWXEJsAYxNV0C7NZZVbj55JhQqIe3G9xPwSvXmP072FGP4ktqUXm5AAE+PSV15iXlNeevQqmlREfFy8ZrvowYsITRtGHRkaicq2eZ+blV5cbFzprFt57NEzqVgRcfFpZVVUYuPiSmXdKu64JaSmApu2GqBh/dQXJ6q0MW5lLq/3bxmgi1XqixNV2hi3MjOtqI8W9U1w7N/nmkRPYNzKmoWRPrrYm2DHneeaRK80x63ixjl6VKIqVqyIJi/mLon5eOfOnZOJnLiWnZp6OKdICNX7/vVizot4LJI94ezZs/KneKzLUCZPT0/N/bVr18qeQ/FTTT1PsLCJXkzxWXFxqonDgkguxbYYsaxbAbh6uuLAatWQV7HQTch9VcLs7O6M83tUPY9nd52Fc2vtJNayqiXCHoRpHouz4qJxlPGmVrNRTQTdDNI8tm9kj8igSIQ/CEdSfBKuH7sO545pnyHm242pPUbzuJZDKsIj9BAaJnpogUtX9NG4oapnV4gMiYSxmTHMrLTnTxYmT1dXrD6QVlb3X5xccHd2xp4XvbS7zp5F6wwJf1VLSzwISysr0ZsnkrqMN7VGNWviZlBaWeVGzLWrPSatrAQXs1Q8jNfDvTggLgXYH66PVyqnlVdIZCTMjI1hlWG+aWFq49kG21dv15TXo/uPVMfm7oLje1QLwRzddRRNWqfNRRQqV62M4AfBmseiN08kdRlvanUa1UHAzbQVIJ0aOSEsKAyPHzxGYnwi/jn2D5p1bKZ5Xsy361E7+16vjJ6EPIGJmQksrTKcWShEnm3aYPX2tLK6/0hVVu4uLtjzYtGcXUePonW6eZtC1cqV8SA4raxEb55I6jLe1BrVqYObAZlXy8yOmLNSO4cewqyEPHkCMxMTWInx1UWkNMatjDFLbefv+rAwT0W3zmn//9QYtzKX1+f39WFTIRXja2Qur/Iat7KKWZHRyXgilimVx5mKC/5xqGad1hfDuKVdXmFxyQiOUZVXUkoqTgTHoaa5YbHGrbKCPXpU4iZNmiTn5IkFWcTP9Nzd3eX8PDUxJFMkhKI3T8zve/nll+VZXZEwqhMnXefnNWvWDD169JDX0tu2bZu8qYkhobq8T36Gbg4dOhRBGRr+77zzjvzZq1cveRH3/Hpn+TtYPX41pjadKh8PWzgMto62GDR3EJYPX46Tv5yUQyInrJ+g9TrvWd5YMWqFTK4+2fUJbGvnvPqffV17+TM8KFwOrRRDlryme2Hz5M1ISU5B095NYVMnbbhEaEAoGrRTDY8SRB7u/Voy1mwwhBi527p5CuzSLfwnFkxo2aclitLyd97B+NWr0XSqqqwWDhsGR1tbzB00CMOXL8cvJ0/K4ZDrJ2iX1Sxvb4xasUI2UHZ98glq57JSYl17VVkFhYdrhlUuO3IEB14sIOS1bBm8mjTBhK5d5eOA0FC0a5BWVoKRPuDjlIyR1w0h5pt726TA2TTtebHYS5+WRVte05dPh894H7zR9A35eMrCKbB3tMe7c9/FzOEzse+XfXJI5Nz1c7VeN2bWGMweNVsmV0t3LUWN2jVy/BzHuo7yZ2hQqBxaKYbgvDX9LSyZvETWrfa926NGnbT3CAoIgms77f+r3/8RgeN+qpMmI74IRBc3MwzvoRoZIBZ66dynM4rS8unTMd7HB03fUJXVwilT4Ghvj7nvvovhM2fil3375LCi9XO1y2rWmDEYNXu2bKDsWroUtWvkXFZ1HVVlFRQaqhmetGzrVhzw9ZX3vd5/H15t2mDCi+uDBgQFoV2GuLbg3wj8dk9VVu47AtHPyQwfN0sbti4We+nTuWjLqzTGrYwxSxArA5/4ywB21VOxaJnqPHm3zslwa6rqqWLc0i4vsTLw98EGqG+ailcvqcrrXftk9K6aWq7jVlYx6+nzZHy9+QmSU4DklFQ0djJGzzZpvcuMW9rlFR6XjMmnVeWVlJqK1rbGeMvZoljjVlmhlyrWricqBuL6eWJunZubm7x0QnrXrl2TvWniIuWxsbFyuKPoURs1apTWUE/xevE+gkjEvnsxf0r93sKqVavQMt0fD5GMCeKSDhlXwBQXa1+/fr0c+vn48WN5CQdxjTvxuSJQpyeGX4oLnQsFmZcnjiFjoqeWXaI3Y9EMtJxWtH8Q8+rwusOICIqA90xVIzInn3l8htErRqNmA9XiObmZ4zlHNv4c6ud8iYysHB+9G0t69kFpsu7wYQRFRGDmiwZ3Tjw++wwrRo9GgxcLDenCc84cmbjWz+WSImpPEoHm/2hPUN80swYqmRfdoh55sWPdDnk2fMzMzD0EGb3j8Q4+XfGpXMBFF2M9x8rGn1N9pzwf14YJq/D1WO2TUSVt3Y4dCAoLw8wselMy8njnHaz49FO5gIuuPMeOlYlrfSfdyutJXDKa/6q9WI7PzES8uGpNmYlbeY1ZAuMW45YucSuvMUtg3CrauJXeop07Me2zz6AU7NGjYpMxuUuvYcOGWJJuuFt2RJKYVZKV03vnRCRzIklUJ4/FobTP19NVlxFdcGjtIZ32/fzI5zq/r7hgeudhnfOV5JVWI7p0wdpDupXVkc91Lyv1BdOHde6sc5JXFvQd0Re/rs081yor3x3JeYGO9MSFh3sN65WvJK+0GtG3L9ZmMUc0K0dyWVgoI3Hh4WG9euWrsVTW41ZeYpbAuMW4pWvcykvMEhi3GLcKgnP0qNwQvXGid+/nn3/Oc2ImXqfuzSMVMQ+yx7i8zffRhbjwsEj0lFZW4/I4N0pX4sLDItFTWnkNGDeg0N9XXHi497Diu65lsdWtAYVfVuoLDw8rxuuAFgfGrbyVFeNW3sqLcSsPdYtxq1gw0SMiIiIiIlIYDt0kxSvode7EnLqMc/uIiIiIiEoz9ugREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IiIiIiIiBSGiR4REREREZHCMNEjIiIiIiJSGCZ6RERERERECsNEj4iIiIiISGGY6BGVI0veXIJJjSbhy35fam0/s+MMJtSfgKmuU3H/8v0CfcaepXvwPPJ5rvste2sZhlYain56/RByLwSlzZtLlqDRpEno96V2We04cwb1J0yA69SpuHy/YGW1dM8eRD7PvayCwsPReNIkmAwcCOthwzDq//4P8YmJKE0+efMT9GvUD1P6TdHafnjHYfSp3wfert7wv+xfoM/4cemPiIqMynW/T9/6FG0rtYWLngsC7wVqts8bPw/trdujpUlLDGk9BNf+vYaS8OYnn6BRv37oN0W7rHYcPoz6ffrA1dsbl/0LVlZLf/wRkVG5l9Vbn36KSm3bQs/FBfcC08pqxMyZcpv6Nn3pUpT3mBUaEIpPO3yKIZZDMNx2ODZ8uAGpqalYPmK5jGPq28bpG1FSSlPcCggNRYdPP4XlkCGwHT4cH25QlVftMWOg16+f1q28x6zQoFD0a9xPxiYRoz4b9RkS4hPQo3YPGcfS30pKaYlbQaGhaNyvH0xatoR1+/YY9dlniE9IkJ/dcvBgWLi7o/OoUbj/6FGBjkUpDEv6AIioeEQER+DS4Uv4Pvj7TM8dWnMIo5aOglsPtwJ/jmg0tX6tNcyszHLeUQ9o3KUx/v7tb5Q2wREROHzpEoK/z1xWaw4dwtJRo9DDreBlJRpMr7VuDSuznMvKQF8fb3bqBJfatXE1IADTNm5Ea2dnjO3eHaVBWHAYfA/74ljwsUzPbV+zHdOWTkP7Hu0L/Dk/Lf0JXV/rCksryxz309PTQ8suLXHsN+3jqdukLlp1aYUKFStg4eSF+OK9L7DpzCYUp+CwMBz29UXwscxltWb7diydNg092he8rJb+9BNe69oVVpa5l1WXli3xWxbH071tW0x/+215v5adHcp7zIqJioFjE0f0/bAv7vx7B1s/34q6rerK55p1b4b+0/vL+1VrVUVJKG1xKyomBk0cHfFh3774984dfL51K1rVrYvNH3yAuBcnqsauWgWTChVQ3mOWvoE+er3ZC84uzrh19RaWTFuCJq2bYOHmhUiIS5D7fD72c1Q0qYiSUJrilvx72KsXXJydcfXWLUxbsgStmzTBj7//jmfPn+OnBQvktrdnz8bhtWtR3jHRI1KYv3f/jZ9m/CTPnDbs0BCjV4yWj8/tPofo8Gh5BryaUzVM3zkd109fx+p3VyP4VjCCbgWhonlFTPlximzMXDt1DWsnrNU0BsX+trVtER8Tj+8mf4d7fveQlJCEfh/3Q8chHXF6+2ls89mGiEcRmOc1D4YVDDF+9Xg4t3bO8jgn/zAZRzccLdFEb/fff2PGT6qy6tCwIVaMHi0f7z53DuHR0fLst1O1atg5fTpOX7+Od1evxq3gYNwKCoJ5xYr4ccoU2ZA5de0aJqxNKyuxf21bW8TEx2Pyd9/B7949JCQl4eN+/TCkY0dsP30aPtu24VFEBLzmzUMFQ0OsHj9eJm9ZsbWywvTXX0dcQoKmcWVhYoLidmz3MfzfjP+T5eXWwQ2frvhUPv5z9594Gv5UngGv4VQDS3cuhd9pP8x/dz4CbgXgwa0HMDU3xfwf58O5iTP+PfUvFkxYoCmvJTuXoEbtGoiNiZUJ2A2/G0hMSMTIj0ei55CeOLj9INb6rEXIoxC85/UejCoYYdbqWXBpnfXZ7fk/zMdvG37LlOgNencQEhMT8SzyGaxtrWFmkcvJiALYfewYZvyfqqw6uLlhxaefyse7//wT4U+fyrPfTjVqYOfSpTjt54d358/HrYAA3HrwAOampvhx/nw0cXbGqX//xYQFaWW1c8kS1K5RAzGxsZi8cCH8btxAQmIiPh45EkN69sT2gwfhs3YtHoWEwOu991DByAirZ81Ca5esy+qH+fOx4bffskz0qletio7Nm0Nfv2gH/5SVmOXY2BFjV46V9xt3biwTvfBH4fKxVXUrNOzYsMjLqizFrcaOjlg5VlVenRs3loneo/BwDGjXTm67FxKCm0FB+N/IkSjvMauKbRW8Pf1txMfFw8LKQm4ztTBFU/em8r4YmRBwMwAf/u9DFKWyELdsq1SRJ6Di4uNhZaEqKwtTU/z733+YPHQo+nTpgjOXLuGrH36Q8d7IyAjlmV6q+G0SUak2Y9EMtJzWMtf9RINm3Evj8OWZL2HjaIPPu38Oj1Ee6DC4gxweObPzTKy5tybT68T2QXMGycaL2hd9vkCHIR3QYVAHxD6LhZ6+HiqaVcSmGZtgXtkcr334GmKjY/G+6/tYeHYhLKuozsCNqT0GPn/6yAaWcO3kNaydmPms2qw/ZsHvoB/+b+T/YfXd1Zr9C+r46N1Y0rNPrvuJxsxL48bhzJdfwtHGBt0//xyjPDwwuEMH2QDpPHMm7q3JXFZi+5xBg2TDRa3PF19gSIcOGNShA57FxkJfTw9mFStixqZNqGxujg9few3RsbFwff99nF24EFVenK0UQ5j+9PGRjSvh5LVrmJjFGcg/Zs2CvbW1ZojTuO7dZQNK/AHNjyeJQPN/tP/4bZpZA5XMDbJ9jWjQeL3khR/P/Ah7R3uM6z4Or416DV6DvWQj5O3Ob2P/vf2ZXjeq8yiMnzMeLTun1d+JfSbCa4gXXh30Kp4/ey7rlqmZKZbPWA7LypYY8eEIxETHyEbYT2d/glUVK/k6MYxp3Z/rZANL+OfkP/hyovYQNeGbP77BmYNnMGvkLOy7u0+zvzBzxEzs/mE3HOs6Yu2Rtahes7rO5bZhwip8PXZ8rvuJxsxLXl448+OPcLS3R/dx4zDqtdcw2MtLDo/s/PbbuLc/c1mJ4UZzxo9H55ZpZdVn4kQM8fLCoFdflWerZd0yNcWM5ctR2dISH44YgeiYGNkAO/vTT6hipSqr2j164M9162TjSjj5zz+YmGE4n/DHN9/g4JkzGDlrFu7u26fZXwzd/PmPP5CckgK3Bg2wYd48NHr55Vy/+5O4ZDT/NW0IqOAzMxHm5sqIWdb21vL+joU78Mtnv2D5teXYNm8bTv58EinJKXjJ7SVM3DARtRrVQl4oOW4JC3fswGe//IJry5ejzove4blbtsjEMfC77+TJrMKOW2UtZtna22qGZnqP88bMlTM1MX7V3FUycTwUeEgmhXmh1LhVo1s3eX+ctzdWzpwJx+7dUadmTWxdvBgDPvoIf547h8DDh2H/op7qatHOnZj22WdQCvboESlI4I1AVHGoIs9+C636toL/WX/ZaMqrBu0bYMeCHQgLCIOrpyucXJ3k9gv7L8jG2fFNx+VjcYb88Z3HmkZTRuIM/RK/JShtbgQGwqFKFXnmW+jbqhXO+vvLBlNetW/QAAt27EBAWBg8XV3h6qQqq/0XLsiG2abjqrISZ8fvPH6saTBlJM7O+y3JvqxE4+7EtWuY/uOP8GreHL3T/WEtavdu3EM1h2pwcHKQj7v07YLLZy/LRlNeNWvfDOsWrENQQBDaerZFfdf6cvtf+/9CXEwc9m7aKx+LM+QP7zzUNJoyat6hObb5bcvTZ4+dNRae3p7yzP2iqYvwv+3/Q2G7ce8eHKpVg5ODqqz6dumCs5cvywZTXrVv1gwL1q1DQFAQPNu2hWt9VVnt/+svxMTFYdNeVVmJs+N3Hj7UNJgy6tC8Ofy26V5Wr3frhsGvvio/Q5yBf2fOHJzZVPjDXMtizDr3+zn8PPNnjFk5BnZ17NDm9TbyeMVnrJu8Dt+88w0WnlmIolAW49bv585h5s8/Y+WYMZokT/QxbDx2DF5ubjoleeUlZomk9J8T/2DZ9GXo4NUBnXt3lmW1Z+MetPdqn+ckT8lxSySkJ/75B9OXLYNXhw6YOWYMxvv4wLZzZ9R4kdyZVCyZoa6lCRM9IspSv2n90Oq1Vrh46CIW9F2AcavHaebDTP1pKuq41dGp5HI6O64U0/r1w2utWuHQxYvou2ABVo8bp5kL89PUqXCro1tZ5XZm3L1ePXlbvGsX9v/7b7EmeoVp1LRRct6K7yFfTO47WQ5pUs+HWfDTAjR0a6jT++R0djw7NevUlLdzA85hy8otKO2mjRol56wc8vVF38mT5XAm9VwYMRfFraFuZZXTmfGs9O7cWXP/rwsX8G0ekkQlx6zgO8H4asBXGDxvMDxHe8rtLXun/T+8/td1HPj2AMqC4ohbd4KDMeCrrzBv8GCM9vTUeo1IHhcPH46yoDhilujRE0M1xe2HxT/IJFIkeuI1Inl8f/H7KCuKI265N20qb4t/+EEmkN/MmIE+nTsj8tkz7Dp6VCaalXOZo1weMNEjUpAa9WrgycMncsiTWBBAzH3xGOmRr/d6dPMRajjXkDex8MAj/0ey0STOlO9fuR/j14yX81Gun7mOeu71NENMzCqZ4dmTZ5phUNmdHf9z05+4ceaGvH9211m5v1gQobjUq1EDD588kcOdalWtKue9jPTIX1ndfPQIzjVqyJtYdMD/0SPZYBJnyVfu348141Vldeb6dZmoqcuqkpkZnjx7phkCld2Z8UN+fvLseuNateRiLGFRUXC2t0dxql2vNh4/fCyHPNnVspNzXPqO7Juv97p/8z5qO9eWt//+/Q/3/e/LRpM4Uy6Sr9lrZsvyunjmIlzcXTTlZV7JHE+fPNUMg8ru7Pjvm36XrxWO7joq9xeNtHnj5qF1t9YwNDTEkR1H5OcXhXq1a+Ph48dyuJNYxETMbxnZN39ldfP+fTjXri1vYg6K//37ssEkzpKv3LIFa2aryurMxYtwFytkquuWuTmePH2qGQKV3ZnxTb//Ll8riMaR2F800JZt2oS6jo6IiIrCL/v3o0WjRijvMevh9YeY32u+7DkUr7/y5xX5mrO/nYV9XXtER0Tj5C8nUaeFbgmS0uPW9YcP0Wv+fNlzKF7/55Ur8jXi9sOxY6hiYYFeLVqgqJSlmHXm0BkZt+o2risXY4kIi4Cjs6N8bs8Pe2QPYadenVCUykrcOnTmjIxbjevWlYuxhEVEwNnREXv+/BOx8fFyBc7/bdyIYb16FUKplH1M9IgUxNjUWDZm5veeL4d7iAZJ2wFt8/VeomF04cAFGBgayLkzXUd0ldsHzBqA9VPXY2rTqXJOinhu5t60uQQ9J/eUS6JbVLHA20vfxsstsp7Xs2zYMs198X7ifYoz0TM1NpYNmd7zVWUlGiMD2uavrESj6MCFCzA0MJDzZkZ0VZXVrAEDMHX9ejSdOlXOdRLP7Z2ZVlaTe/aUy6GLBs/St99Gi2zmQIlVxtYdPoz7oaFyEZYxnp4Y36MHipOJqQk+W/MZJvaeqFrYoL0bug/I36qfomF0+sBpWbfsHO3Qd4SqMTFm1hgsnroYbzR9Q9Yt8dw3e7/RlNfQyUPlkuii0SNWxWvUIuvk49Nhn2rui/cT83NEonfryi3s+2UfkpKS0KBZA3z6Tdp+hcnUxARrPvsMvSeqyqq9mxsG5HOFVNEoOnD6tKpu2dlhxIuG16wxYzB18WI0feMNVd2ys8Peb9LKSixKIJZDF0OixIp42SVqwz5NKwPxfmJujkj0/jx/HjNXrJDv1040/GfMQHmPWf6+/oh5GiN7DMVNGDh7IO5dvCeHcor3q9+uvmbBlvIet3z9/fE0Jkb2GIqbMHvgQNmTuO30aQzv0kUuulFUylLMEqtu7ly3E0H3g+QiUW+MeQMDxw+U8wwPbjuIPsP7yAVdilJZiVvy7+HOnbgfFAQLMzOMeeMNjB84UCZ/73/1FYyNjGTP3sIMl4Eor7gYC5GCFmMh3Rc1KM/ysxgL6b6oQXmW18VYSIVxS4e6xbiVL4xbKNeLsfCC6URERERERArDRI+IiIiIiEhhmOgREREREREpDBM9IiIiIiIihWGiR0REREREpDBM9IiIiIiIiBSGiR4REREREZHCMNEjIiIiIiJSGMOSPgAiylpKSioiYhLk/bgUQ0RHs6R0Ea9XQV5Yl7IXkUX5RD1PZpHlVrdQQV4QnHKoW/GZy+f5c5ZYrnWLcStXjFv5w7iVN7GphngSHY/KphWgr6+Hsk4vNTU1taQPgogyE4Gmuc9hFg0RERFRMfpnZjdUMTcu82XOoZtEREREREQKw0SPiIiIiIhIYZjoERERERERKQzn6BGVgcVYVqz4GhMmeJX0IZUJ77+/Ga+8MrekD6NUe56YgAWXTmhtOzw1EZXNSuyQyoTp009j+PB5JX0YpVpUfALe/T1j3aqOymYGJXZMZQHjVu4Yt/KHcStv9v6xAh9+MEExi7Fw1U2iUkoEGPVEYBP9JFQxZ0NJFxVSE2FuVPYnUBc3keRVMS/poyjdjJGIShVZt/JKJHmMXzlj3Mofxq3cMW7ljYlesiIWYVHj0E0iIiIiIiKFYaJHRERERESkMEz0iIiIiIiIFIaJHhERERERkcIw0SMiIiIiIlIYJnpEREREREQKw0SPiIiIiIhIYZjoERERERERKQwTPSIiIiIiIoVhokdE+XLrVgB69nxP8/jkST/07z8dfftOw7p1e3J9/f8ORaLNgkDUnh6gtT0qKhru7kORmJiomN9MUNAt+Pj01Dy+efMkVq7sjxUr+uLUqXW5vn7fA3/M+fcIpvjuzfRcTEwUPv7YHUlJyimvW7eC0LOnj+bxyZM30b//SvTtuwLr1p3K9fX/O6SPNgsMUXu6kdb2qKgYuLt/jMTEJChFQMAtvPdeWt3y8zuJ6dP7Y9q0vtizJ/e69dMlf4zceQS9f8pct6KjozB0qLui/i8ybumOcSuvdYtxS1eMW8WHiR4R5YuPzxpMnjxU3k9KSsaCBRuxdOkUbN06H/v2ncHt24E5vr6Tswl2vVct03ZLS3N06tQCmzZlbniWVdu2+aBXr8nyfkpKEv74YwEGDVqKceO24vLlfQgNvZ3j6+tb2WBq43ZZPmdqaolGjTrh+PFNUAofn22YPLmXvJ+UlIIFC/7A0qWDsHXrOOzbdxm3b4fm+PpOzqnY9V7mZM7S0hSdOjXCpk3HoRRr1vhg6FBV3UpOTsLGjQswZcpSzJ+/FWfO7ENgYM51q7mdDb7qnnXdMje3RIsWnbB3r5LqFuOWrhi38lq3GLd0xbhVfJjoESnMvXuBqF27Bz766Gu4uLyO+vX7IDg4DN27j5OP27V7Czdu3MXt2w/QqtUQrdempKTAzq4rkpOTc/yMmJhYHD7sCw+P1vLxlSt3YG9fFbVqVYexsRE8PFrgxIkLOb5Hc0djVLM0zPI5b29PbNjwG4paSMg9jBlTGxs2fIQpU1wwYUJ9REQEY+7c7vLxJ5+0Q2DgDQQF3cZHH7XKVFajRtnlWlbx8TG4dOkwmjTxkI8DA6/Aysoe1ta1YGhojAYNPODvfyLH93CyqIxKFSpm+3zbtt44enQDitq9eyGoXXsMPvpoA1xcpqB+/QkIDo5A9+5z5eN27T7BjRuBuH07CK1afZRF3RqlQ92Kx+HDl+Dh0UQ+vnIlEPb2VqhVyxrGxobw8GiAEyf8c3yP5o6pqGaZ9XPe3m2xYcNRFLXAwHvo0aM2vv76I7z+ugv69KmPsLBgjBvXXT5+6612uHv3Bh48uI0hQzLXra5dc69bsbEx8PU9jNatVXXrzp0rqFrVHtWr14KRkTFatPDAhQs51636NpVRxTT7uuXp6Y3ffiuOusW4pSvGrbzWLcYtXTFuKU/WrSwiKtMePnwMN7f/Z+9MwHLO2j/+TSWtKooSlUhJi2yRJfJPsoasY8tIRgozQ0aWTN4w77zFa+wZL2YsGQxjG8VYRhlLTYylrElP2kval/91zuN5Km1PKPW4P9f1u36/c37rc7rP3bnPfZ9zTPHdd18iLS0T3t6B6N/fGsuWuWHPnuPw9FyHs2e3cgOQhWU9f/4SKiqKSEpKQ+fO7XH48Dn4+1cM+4qMDOb769f/galpe8jKyvJ0cnI6tLQ0EBp6A3FxidDSUq/Ro1cdVladEBFxn3+bvHz58LsPTUpKHIyMrDFjxnfIykrD3r3e6Ny5P1xcluHChT3YudMTK1eeRXp6Ag+PTE5+jmbNVJCZmQQ9vc4ICzuMX37xr/DcgIBIvo+JuQ49PVNxWWVlJUNVVQv37oUiLS2OH9fk0asJQ0MrPHkSwb9PTq5uyysuLgXW1kb47rsZSEvLgrf3XvTv3xnLlrlgz54L8PTcibNnVyIhIZ2HSD5/ngwVlWZISspE5856OHw4DP7+v1R4bmRkAN9fvx4DU1O9MrKVBS0tVYSG3kNcXBo/rsmjVx1WVoaIiHjCv01evm7/Bb58GQdTU2t8+eV3yMxMQ2CgN6yt+8PNbRmOH9+Ddes8sXXrWW4AMll/+fI5FBVVkJaWhPbtO+PcucMICqooW8HBQtn655/raN++VLbS05OhoaGFGzdCkZgYB3V1rRo9ejXRqZMV7t+PqJe6SHpLckhv1Va2SG9JCukt6YIMPYKQQlRUlDBpkhM/1tBQQ3h4FObPn8TTY8YM5oYeo2tXE0RFxcDffyc33IyM2qJ3b0tMmODIt6qIj0+EtrZmhXzmyWMcPvx+HhM5OTmoqipzA1JHRwt1CTPa+vUTlo2Kigaio8Ph5DSfp21sxnBDj2Fo2BXPnkVxo44Zbq1bG6FTp97o23cC36oiLS0ezZtrV8hnnjzGzZuH3/s3yMrKQVFRFZmZydDU1EFdwoy2SZP68WMNDRWEh0dj/nyhrI0ZY8MNPUbXroaIinrGjTpmuBkZtUbv3p0wYUJfvlVFfHwatLWbV8hnnjzG4cM33+v75eRkoaqqiOTkTOjoVJThD4mSkgqcnISypaamgaiocEyaJJStwYPHcEOPYWLSFTExUdi5058bbm3bGsHSsjccHSfwrSoSE+OhqVlRtpgnj3H+/PvLFquLysqq3IjU0qpr2SK9JSmkt2orW6S3JIX0lnRBhh5BSCHq6qoSXdenjxXCwv6GsrIiD+VMTc2Ak1M/HDx4plqPnqJiM+Tm5onzmQePeQNFJCWlQ1tb471+Q05OLhQVFVDXKCurS3SdiUkfPHgQBgUFZSQkPMKrV6no1s0JV64crNaj17SpIvLzc8X5KipaePWq1CPFjlVVKzbWa0t+fg4UFBRR16irK0t0XZ8+JggLewBlZQU8epSA1NRXcHLqhoMHr1Tr0VNUbIrc3HxxvpaWCpKSXonT7FhbWzL5roqcnPx6kS1VVclky8qqD/7+OwyKiso8lDMjIxX9+jnhzJmD1Xr0mjVTRF5eqWwxDx7zBopIT0+Chsb7y1Zubn3JFuktSSG9VVvZIr0lKaS3pAsao0cQnwA2NhY4cUI4AcWxY+fRq5dw/FPv3hbYsuUQP6+p2Rznz/8l9ugxo+7tTYSZmRFiYkpnyzQzM4RAkMxDQPPyCnDhwk30799VfJ6Nt2PjBiUlMTGFG5/q6lUMtKpDjI1tcOOGcNbQa9eOwdhYOA6Ree/OnNmCTp1soKKiidu3z4s9esyoe3sT0batGQSCGHFaV9cM6ekCpKY+R2FhHu7fvwBj4/7i82ysHRs3WBvS0xO5ASpp4+9DYmNjjBMnbvDjY8euoVcvY37MvHdbtpyBjU0naGqq4Pz522KPHjPq3t5EmJm1RUyMoExaFwJBOp4/T0VeXiEuXLiP/v2F72Cw8XZs3KCkJCamc+NT0obfh8TCwgYXLwpl6/z5YzA3F8qWhUVvHDq0hZ9v3lwTf/11XuzRY0bd25sIIyMzxMaWypahoRmSkwU8BLSgIA83b15A166lssXG2rFxg7UhJSWRG6BqauqflN6qrc5ikN4ivSWJ3qqtzhLKFumtxqK3Ghrk0SOITwBf3y8wfboP9u8/zUMid+3y5fndu5shOvoZHBz68BBJNsEKazjVRMeO+nwvECTx+1h4l7f3NHh5BaCoqBgjRvSFkVEb8fWxsQLY2lqVe4b/qTT8GpnNj23+9QLO1spY4ihUyuw7Ro60w8dg4kRfbNw4HZcv7+fhkB4eu3h+hw7dER8fDUtLB2ho6PAJVlRVaw7909XtyPepqQIeVsnCLJ2cvHHggBeKi4tgaTkCWlpG4uuTkmJhalp+FsTjz+7hZko8P155KxTdW7bBiHYm4vPsW3r0GImPga/vREyfvhH791/mIZG7dnnw/O7dOyA6Oh4ODpbQ0dHgE6xoatbssenYUZfvBYJUHlrJQi29vZ3g5XXgjWxZwsioNJw3NjYJtrbCsE4R/qea4NdIYT+mzb/k4GxdjCWOxTzNvmPkyB74GHzxhS98fKbj9On9PBzS11coW2Zm3fHsWTT69HHg4ZFsghVm8NWEvr5QtpKSBPw+Vg+nTfNGQIBQtvr2HYE2bUplSyCIhZVVedn68dY9XHwqlK0ZR0Ix0LANpnctlS32LXZ2H0u2Pp7eqkxnMUhvkd56X71Vmc4SyhbpLWnQWw0NmZKSkpKP/REEQVTP+vWrsXixc4MqpqCgI7w33Men5p5Je/vPsWnTN3wcoCQ4OMzBxo3eMDExrPV3zZ69G8OGfY+GREhIENLSBHBx8anx2hUr7DF79ia0bVuxIVAVq1Y54PPPN0JPr/QfXXVkFeTB52ZIubybPgVooYIGQVBQCASCNPj4uNR4rb39CmzaNBumpm0leraDwyps3Pg5TEz0av1dHh4XMWdOqfexIXDkSBD34rm51Sxbn39uj2++2cTHAUrKnDkO8PbeCENDyWQrIzcPn/3ytmy1QQsV4YQxjUVv1VZnMUhvkd6SRG/VVmcJZYv0Vl3qrbIcPboeK1YshrRAoZsEQbwTM2aMQsuWkoVFhIYKJ3uRBLZg+tSpw9/JyGuoDBw4A6qqLSW6dvXq0FoZeWzBdDu7qRIbeY2BGTMGomVLycZrhYaulrjBxBZMnzrV7p2MvIbKqFEzoK4umWzt3Blaq8YSWzB9+PCp79RYaux6qzY6i0F6i/SWpHqrNjpLKFuktz51vfU+kKFHEMQ7waZ0d3cf/8FLjy2YPnXqCEhbWTk6utfJs9mC6czQkz7Zqt34KElgC6YzQ0/aymr8+LqRLbZg+ogR0ihbpLckLSvSW7WVLdJbkpYV6a36gQw9giAIgiAIgiAIKYMMPYIgCIIgCIIgCCmDDD2CIAiCIAiCIAgpgww9giAIgiAIgiAIKYMMPYIgCIIgCIIgCCmDDD2CIAiCIAiCIAgpgww9giAIgiAIgiAIKYMMPYIgCIIgCIIgCClD7mN/AEHUNd27dy+XXrRoESZPnsyPCwsL8eOPP+K3335DYmIitLW1MXz4cMycORNycsLqceLECfj6+pZ7xo0bN975eyR5J0EQBEEQBEG8D9SqJD5pVq1ahTNnzojTL168wLZt2xAbG4tvv/1Wat5JEARBEARBfFqQoUd8VIqKilBSUlIvnqyVK1dixIgR4nRERITY4HJxccGcOXO4wRUcHIzTp09j7NixsLKy4vewrTLPXm2R9J2NkcuXIxEQcABFRcUYObIfZs0qLevKCL2XA7+TaSgqBsZ3V4bHoOb4VLh4cRsiI4/j1auX8PGRzDv8T9pLHHt2D8UlJeilrQeHNh3xqXD5cgwCAs69kS0rzJrVt9rr/3OuCYJvNIEgQwZP1xbgU+Lo0W24fPk40tJe4scfa5atn6KiEfLoOZKzc3FiyjB8atRGb2VkF+OLn5MgSC+CvKwMxnVTxuz+avhUqK3eyi4swO7om0jLz4WcTBP01NLDQN32+FSojd4qLgbGbpVFboEMP3YwK8aXDsX4VKit3mL/Bxf/fhX5RcUoLi6BTdtW+MyyU718a2ODxugR9YabmxsPo2T7U6dOYcyYMejTpw8ePXqE+/fv85BKe3t79O7dm5/bvn07CgqEjbSEhAR+L9uYQcR4+PChOO/Bgwc87+zZs+K8uLi4ar/n999/Fx/Pnj0b6urqfC+CPetD8zHeWR1Hj4bCysoFTZta4+nTF7W69+HDWAwbNo8fFxYWwd9/DwIDF+DQoTU4fToMjx5V/bzCohIsO5qKXTO08PtCHRyNeI3ol/n8XGZmFmxspoj/9g2F8PCjWLjQCi4uTZGY+LRW9woED+HnV9qINjLqDVfX3RLfX1RSjENP7sCtUw94W/bHjaQXEGS/4ueyszOxZIkNCgsbVnkdPRoOK6uFaNrUBU+fJtbq3ocPBRg2zI8fFxYWw9//FAIDJ+LQIXecPn0bjx4lVXv/AOMSHJtXWCE/MzMbNjZLUFBQ8dzHJDT0KFxcrGBt3RQvXtROtmJjH2LevFLZMjfvjeXLJZetbjpa+PcQ20rPZWVlYsoUmwZXFz+W3oIMsOj/1HH+K1386tEah268RlRcHj9FeqtyhrY1xjIrOywyt8W1pOeIzUrn+aS3ytOkCbB7RhFOexXilFchrj6SQfhjmTeyRXrrbZrIyGCVXU9sdOqHDU79EJWQgtsvUxq03vpYkKFH1DsxMTHcu8ZCFZlHLz8/H7NmzcKlS5eQkZHBKyc7xwy9L7/8knv8WrdujVatWvH779y5U27PuH37drm9lpYW9PT0qv0OkXGooqICTU1Nfsz2LM2Ijo7+4L/9Y7yzOpyd7REZGQxdXe1a3+vntx1eXlP48Z07j6Gr2xLt2rWGgoI87O2749KliCrvjXyej7aacjBsKY9m8jJwMlfCubs5/JyamgoGDOiOfftOoiFhY+OMgIBIaGjo1vre4GA/DB/uJU7r6VlAVVVL4vufZaWjhYIitBSVId9EFlYtdHAn7SU/p6SkBjOzAbh4cR8aEs7ONoiMDICurkat7/XzC4aX13B+fOfOC+jqqqNdO00oKMjB3t4Uly5VX0+66ZegVSWOFjU1JQwYYIZ9+y6iIWFv74zg4Ehoa9detrZv98OUKaWy1aGDBTQ0JJctEy0NtFBqVuk5FRU1dO8+ACdPNjTZ+jh6q7liE3TTV+DHTG/pt5BDYmYRT5PeqoiSnDwMVYX/55jeatlMGZkFQsOY9FYl8qUk3OcUANn5Msh9Y6eQ3qocFQV5vs8rKkIua0sWFTVovfWxIEOPqHdevXqFcePGITQ0lIdD+vv7Iy8vD02bNsUPP/yA8+fPY8iQIfzaq1ev4vLly/xYFNIoMuaYoScjI1PO6BOds7S0rPE70tOFPYvKysrl8kXptLS0Gp/BJmUReRCr2sqGi36Id1ZHUlIqXFy+hIXFWJibj8HZs3/y/ISEZAwZ4s7zbW2n4cGDJ+/1nuzsHISEhMPevhdPJyenQ0tLA6GhN/C//52ClpY6EhOr/i2Jr4rQSk0Wp29nY+vFTGiryeLlmwYTw8XFAbt3/4q6JCMjCevXu2DBAgt4eZkjIkLoTU1LS4Cv7xCev3SpLV68EBrn70peXjaiokJgbm7/zs/IzM9D86bN8HeKAKHxj6Am3wwZ+bni8336uOD8ecm9OO9CUlIGXFzWw8JiAczNvXD2rLBBnJCQhiFDfHm+re1SPHhQOw/L22Rn5yEkJAr29uY8nZycBS0tVYSG3sP//neVHycmCr2Z74KLSx/s3n0edUlqahK+/NIFY8daYMwYc/z5p1C2kpMT4O4+hOdPm2aLJ0/eT7ZycrIRHh6CXr3eXbZqwsHBBb/+Wtey1Tj0VlkSMgpxNz4fPQxLjWTSW1WTnp+LuNcZaP/G8GOQ3qrIhG2y6OEnh54GxTwyoVS2SG9VxtJzYZj2SwjMtDRgraNVr3qrsUBj9Ih6R01NDQsXspCuplBQUOAhmAxbW1v06iX8Bzx37lxxGGN4eDj69+/PDT2WxzyCzAvIjLu2bduKDTyWJ/KIfYhxbiIjsj5533d6eq6FtbUpgoO/557RuDih12flys3o398ay5a5Yc+e4/D0XIezZ7dW+ZyDB8/A3z+oQj7rRWdcv/4PTE3bQ1ZWttx51iPOOHxYsob0UHNhF+be8PINdyurToiIuM9/g7y8sNfuQ7NzpyeMjKyxeHEwD3tMSRGG+h44sBKdO/eHi8syXLiwh1+3cmXVIbVXrhzEL7/4V8hn3j9GTMx16OmZViird8GyhY7wnQnPyuUbGlrhyZMI/jvk5OqmvDw9d8La2gjBwYt56GNcnDBMZuXKA+jfvzOWLXPBnj0X+HVnz66s8jkHD16Bv/8vFfKZ949x/XoMTE31KpEtU74/fPjme/0OKytDREQ84b9BXr5u/gWuXesJU1NrfP99MJfhly+FsrV580pYW/eHm9syHD++B+vWeWLr1qpl68yZgwgKqihbzPvH+Oef62jf/sPIVlV06mSF+/cj6rQuNja9lVdYAs/9KVg+XIN7+USQ3qqcwuIi7ImJgLN+Z+7lE0F6qxIZnlOEV7mA535ZRMXJwLKt0NgjvVU5/v/XG9kFBfjuSgRiUjNg3EK93vRWY4EMPaLeadeuHTfyGJmZmShmI48BvsyAiLLHIi+YyHhjFffWrVt4/Pgxhg4dyvPYmL+//vpLHJMtiaHHxsexENHXr1+Xyxel2fmaYB672iy18CHeWR2//x6GLVt8+DFTboaGwvDV8PAozJ8/iR+PGTOYN5iqY8IER75VRXw8WxaitGeW9YQnJZX2hCclpUNbu+qQvVZvefBY+BPLE8Em51FVVeY97jpleuk+JJGRv8Pdfcub98mjVStDfhwdHQ4np/n82MZmDDf0qqNv3wl8q4q0tHg0b177ELOyNG+qUM6Dl1mQyz18ImRl5aCoqIrMzGRoagqNwQ/N779HYssWd37MDCRDQ2EodXh4NObPd+LHY8bYcEOvOiZM6Mu3qoiPT4O2dunEPFpaKkhKKu0IYMfa2qrv/Dvk5GShqqqI5ORM6OiUyvCHJCzsd/j4bBHXQz09oWxFRYVj0iShbA0ePIYbetXh6DiBb1WRmBgPTc33k62aYHVRWVkV6enJ0NKqK9lqHHqLwYYSLDqUgoEmiuKOKhGktyovr30P/0ZndW1xR5UI0luVo9oMGGhSgiO3Sg090ltVoyQvj+662rjwOE5s6NWH3moskKFH1DsiI0/k3WvSpAk39tiaciLKHouMHyMjI6iqqvLQz4MHD/J7unTpwr1gJ0+exIEDB8RhkB071jwjYadOnRAVFYWsrCykpqbysXJsz9IMY2PjGp/BjDx3d2Hjtyp0dHR4iOqHemdd8LYjsaaecUXFZsjNFY61YJiZGUIgSMbz5y95Q+rChZvw9/9CfJ6FYa5atQVPnwpnHLXQa4q4tEI8TS5A6+ZyOHMnBz9MaVHuXTk5uVBUFI6HaUi87XWtyaPXtKki8ssYaTXBQjAPHFiF7dtLJ+Vop6yO1LwcJOW+hnrTZohKTcD0jtbl7svPz4GCgiIaennV5NFTVGyK3FzhxDwMMzNdCATpeP48Fdraarhw4T78/ceKz7MwzFWrDuDp0+0Sf1NOTn6DlC0+20ctPHrNmikiL09y2WKhTFu2sOVdajfhS25uQ5WtutNbb+ssEat/S4eWShPMtat8tk3SW+Vl6+izu1BtqoDBbYwqLa9PUW9VprOSs9gkZUDr5sL9pWgZ2LQvDd1kkN4qla303DwUFZfw8cVFxcWISEhGlzKdOA1Zb9U3ZOgRH5VmzZrB3Nwcf//9Nx+Pd/36dZiYmPAlB0SIwjmZQciuZdf9+adwDAdLi7h27RrfM+NPklAmBwcHvqwBY8eOHXypA7YXIRon+CGp63c6OPTGtm2HsWSJK5/ohoVA6evrwsbGAidOXESXLh1x7Nh59OpVWm6Mli018Px5AgwM2kjUM25mZoSYmFhxmvWeeXtPg5dXAJ9KesSIvjAyEj6LERsrgK1tqZeVTU3uN1oTM3cn8eUVXLopw7hVaQdAYmIKlJUVoa5ed1OXW1k54OzZbRgzZgkvKxa6qa2tD2NjG9y4cQL6+l1w7doxGBsL5U+EmlpLJCc/h7a2gUQevbZtzSAQxJTLCw3dgDt3hCF7GzY4wdzcCYMGefB0UlIsTE3Lz4Io26QJXAy7YPv968LlFbT0oKNU6tVKT0+EgoIylJXfzyNcHQ4OVti27SyWLBnzRrZSoK+vDRsbY5w4cQNduujj2LFr6NWrfGdFy5ZqeP48GQYG2hJ59MzM2iImRiBOs55sb28neHkJp8AfMcISRkalXt7Y2CTY2grDOkX4n2qCXyOFIXU2/5KDs3UxljgKIwcSE9OhrKwAdfXy42Q/JL17O+Dw4W1wdRXKFgvd1NXVh4WFDS5ePIGOHbvg/PljMDcvL1saGi2RkPAcbdoYSOTRMzIyQ2xsedk6dGgDwsOFsrVokRN693aCi4tQtgSCWFhZlZetH2/dw8Wn8fx4xpFQDDRsg+ldTcTnU1ISoaioDDW1upSthqe33tZZDDYz8I9/voJJa3kM3SCU0S/s1DDCUihLpLfKyxabGfhSwlOuq9ZHCcfaD9Y1gnVL3U9ab1Wms1JfA14H5Pj/w8JioJdhCab1Ll1egfRWednKyM3H91cjuZFXVFLCjbxhxkK9WV96q7FAhh7x0fH09ORj8tiELGxfFhsbGz4+TwQLyWSGHvPmsfF9HTp04D1vzGDMzc2t1fi8rl27wtHRka9rx4wvkQHGYCGhkjyntqGbH+Kd1bFxozfmzvWDpeU4nl63bgFvMPn6foHp032wf/9pHhK5a1f59QCXL3eDq+tKblwdOxYobjhVRceO+nwvECSJQyv79bPiW2VcvHgDmzZ9Uy7P3lSRb5XBJkwYOdIOdcnnn2/Etm1zsXChcOKeqVPXcUNv4kRfbNw4HZcv7+fhkB4eu8rd5+KyHJs2ufIGytKlx8QGX1Xo6gq9y6mpAnFYpb29F98q459/LmL27E0V8s00WvGtMthkLz16jERdsnHj55g7dxssLRfy9Lp1U3mDydd3IqZP34j9+y/zkMhdu4RGhYjly13g6rqJG1fHji0VN5yqomNHYSNQIEgVh1b269eRb5Vx8eI/2LSpdIkSxlKnYr5VBpvoZeTIHqhLvL03ws9vLsaNE8rWggXruKH3xRe+8PGZjtOn9/OwIl/f8rLl5rYcK1e68gZKYOAxscFXFfr6wjJJShKIw5PGj/fiW2XcuHER33xTXrZmWpvyrSrYZC92dnUtWw1Pb1Wms1hn1NO17ap8Pumt8rLFDLxAm6rXZvxU9VZlOsu4FfjSClVBequ8bOmrq/KlFT6m3mosyJSwAGqCqAfY+nlsbJ21tTVfOqEsd+/e5Z6tyMhI5OTk8HBH5t1ydXUtF+rJ7mfPYTCjaOfOneWezdiyZQt69OhRzhirbMF0RmFhIXbt2sVDP1++fMmXcBg2bBh/79uLuJddML02xt3b1OadItavX43Fi53RkAgKOsLDnnx8hH+PD4mDwxze+DMxEY5tqg2zZ+/GsGHfoyEREhKEtDQBXFyE45A+NKtWOXDDVU+v1BNTHVkFefC5GVIu76ZPAVoIV/n46AQFhUAgSIOPj8sHf7aDwyre+DMxqX75lcrw8LiIOXOEoVoNhSNHgpCcLICbW93I1pw5DtxwNTSUTLYycvPw2S9vy1YbtFCpuwljagPpLckhvVVb2SK91Vj1VlmOHl2PFSsWQ1ogjx5Rb7xt3JWlc+fOCAiouQHFjMTKjKzqnl0dzLBiRqLIeKwPPsY764IZM0Zhx46KYxbeF7bw8NSpw9/JyGuoDBw4A+fOlYbofkjYwsN2dlMlNvIaAzNmDMSOHec++HPZwsNTp9q9k5HXUBk1agZ++aVuZIstPDx8+NR3aiw1VEhvSQ7prdrKFuktSSG9VX/QOnrEJwPzxjHv3s8//1yr+5gnj90n8uYRQtg4SHf38R+8ONjCw1Onlve8SkNZOTpWP2nPu8IWHmaGnvTJVtVjrd4VtvAwM/SkrazGj68b2WILD48YIY2yRXpL0rIivVVb2SK9JWlZkd6qH8jQIwiCIAiCIAiCkDIodJOQet5nPB2Djet7e2wfQRAEQRAEQTRkyKNHEARBEARBEAQhZZChRxAEQRAEQRAEIWWQoUcQBEEQBEEQBCFlkKFHEARBEARBEAQhZZChRxAEQRAEQRAEIWWQoUcQBEEQBEEQBCFlkKFHEARBEARBEAQhZZChRxCfEJ99thRmZs5wdl5QLv/IkRCYmIyElZULbt+Ofq93BAbuRXp6Zo3XPX4cBweHOVBT6w09vcGIiLiHhkRAwGfw9DTD2rXO5fLDwo7Aw8MECxda4dmz2+/1jhMnAvH6dbrE17q66mDyZDX85z+TkZ+fi4bEZ58FwMzME87Oa8vlHzkSBhMTD1hZLcTt28/e6x2BgSeQnv66xuumTduA5s2nQEbGGU+fJorzIyOfoHv3r6CkNAFduy7C9esx+BgsXfoZnJ3NsGBBedkKCTmCkSNN4OJihejo95OtvXsDkZlZs2wJBLGYPr0fevdWw4AB2vj3v79CSUkJMjPTMG/eMPTp05zvWfpT11kCQRK6dHGGomIPaGr2havrCuTl5SMtLRPDhs1D8+Z9+J6lPxYNSW+lpgrg6dkFEyYoYupUTfz3v64oKMhDUNACuLrqYuJEZSxfPggCwSN86jpLRFFREaytvxTrrgULgqCr6wpl5YkYNGg5Hj0S4GPRkPSWqKzGj7eGhYUMXrx4Ks7fs+c/PG/z5lXv9S3SAi2YThCfCAkJyQgJCUdCwoUK57ZvP4zAwMVwdOz73u8JDPwJo0cPgrq6WpXXsIbk6NFekJWVxZ49a/D06QvIyMigoZCWloCoqBD8+GNChXPnzm2Hq2sgrK0d3/s9rMHUq9doKCurV3tdQsJj7Nq1EKNGfQU9PVNs2+YOM7MBGDJkDhoCCQlpCAmJQkLCjxXObd9+DoGBrnB0tH7v97BG0+jRvaCurlztdUyUBg7sgl9//atcvpfXTsjKNsGePV747rtj8PTcibCwdahPkpMTEB4eggsXKsrW4cPbsXhxIPr2fX/Z+umnQAwaNBpqatXLVlZWJjp2NMeMGV/h7t1b2LZtNczNe+LatVDcufMXli/fBn9/DwQGemPFim34VHUWg8nOZ58Nh4WFMf755yEWLw5Ar17muHXrHv766w62bVsODw9/eHsHYtu2FfjU9VaTJrIYMOAzGBhYIDb2H+zZsxjGxr14J9WUKWugpKSGHTs8sHPnfCxffgqfss4SsWnTqXLGZW5uPtasmQI1NSV4eOzA/Pk7cerUctQ3DU1vMfbv34SHD8sblgkJcdi+3e+9v0OaII8eQUgZx49fgLn5GN7zPHfut7zXizU8Bg36HKmpGbwHXNQ7fvVqJE9fuRLBGyhle8evXLnF02zr2nU8N8YY2dk5mD17FXr0mARLy3H4+eeTPP/w4d/5tfHxiXBymsePr12LqvQbmffu9u0Y/Pe/3hg1aiAWLJgKKysT1Dd//XUcXl7mvNd569a5vKz27GEN2kHIykrlvd+invH796/y9L17V3jjpGzP+N27V3iabYsWdUViorB3MS8vGz/8MBtff90DCxda4tKln3n+1auH+bVpafH49lsnfhwdfa3K72TPYRgaWqFTJxvIyTWFvLxCPZRQeY4f/wvm5l7o0sUTc+dufSNbezBo0AqkpmbxHnBR7/jVq/d5+sqVe7yBUrZ3/MqVuzzNNuZZE3ndsrPzMHv2D+jR42tYWi7Ezz9f4vmHD1/l18bHp8HJ6Vt+fO1a1V6c//3Pizeu3ub16zy0aaMJGxtjvldQkK+jkgIuXDiOMWPM4ezcBd9+K5QtZix9/vkgZGSk8t5vUc94ZORVno6IuMKNqrI947duXeFpto0f31Xcc52Tk41Vq2Zj0qQeGDfOEidPCmXr998P82sTE+Mxb54TP46Kqlq2OnbsAh+fzRg4cBSmTVvE89i9V6+ehZ3dSAwdOhEDBozg6U9ZZzG0tVvA23sWBg3qCVvbrjxPVVUJZ89exciRdpg4cShGjBjA03VJY9Fb6uraGDvWG+bmg2BqasvzFBVVue6wt5+J3r3HwtjYBqmp8fjUdRYjPj4Vvr6HMG/eUHEe+/vOnGmPsWN7c73FrqlLGoveYtdt3eqLCRPmlctfv34BRo92rcMSanzIlLCudYIgGjTr16/G4sXlwyUqgzVo2rd3QljYXujr62LIEHe4uo7GpElOvNFjZzcLT5+eqXCfnZ0rVq2aCzu7HuK8kSPnY/JkJ954efXqNZo0kYGyshKWLdsIDQ01fPXVDGRlZb9pHP2EFi2EPXAGBo74448gGBi04enLl29i/vzyoTHp6a/w7Fk87O174dKlmzA374ijRwPRrp3Oe5fV7Nm7MWzY9zVexxoz7u7tsXZtGLS09LF69RDY27uiX79JvMHj42OH7dtLw0FEsPyJE1ehSxc7cd6//jUS/fpNRr9+E5GT8woyMk3QrJky9u1bBhUVDYwe/RVycrKwaJEV1q27BjW1Fvw+NzcD+Pn9AW1tA56+e/cyduyYX+GdrLf7yJG1OHnyvzxtafl/WLHiDJo0ebe+uqyCPPjcDCmXd9OnAC1Uqr6HNWjat3dHWNha6OtrYciQ1XB1tcekSf14o8fOzgdPn26vcB/LX7VqIuzsuojzRo78FyZP7oeJE/vh1aucN7LVDMuW7YOGhgq++mo0srJyYGW1CNeurUOLFkJPi4GBG/74ww8GBto8ffnyXcyfv6PCO1mP9++/R2LmzP/iyZNt4usvXryD4cPXICsrF82bK+HKlX+hSxd9icvNw+Mi5swJqPE61phxcmqPvXvDoKurD3f3Ibzx4eQ0iTd4Zs2yw5kzFWXL1dUOc+cyg6RUtubPHwknp8nc4Hr9WihbSkrK2LhxGdTUNLgnLjs7izeMfvrpGtTVhbLl6GiAoKA/0KaNULZu3ryMtWsrytYPP5yCtrYuP961ax1++GEFjh27i1GjTDFlihdOnNgDe3tnHD26C7du5df42zNy8/DZL2/LVhu0UJFt1DqLcerUD9DV1YaMjAVPu7u7YPNmHygodIOX1xTs2XMCzs722LXrKPLzb6E2SKve0tTUhbOzMFqD/W3nzNksjt5gIZuLFllizBhvuLj4fHC91dh01sKFu3gHlIWFQQXdxUI2LS0Xwdt7DHx8XFAbpFFvtW7dDu3adYCxsQWWL5+J06ef4PHje/j22zk4duwebGxU4O6+El98UfvwzaNH12PFisWQFih0kyCkiAcPnkJPrxUMDfV4mnnLrl27zRtNtaVv367w9w9CbKwADg59xB63M2f+RHZ2LvbtE/aK5+cX8PF2okbT2/Tr1w2RkcHl8liP+pQpS6Gjo4Xg4O8xZYo3/vWvndi6tf5CUl68eIAWLfTQqpUhT/fsOYr3TrMGU20xNe2LI0f8kZwcCysrB+55Y0REnOENs4sX9/F0YWE+Xr58LG4wvU3nzv0QEBBZIT89PRGXLx/AhAkreejmf/87A2Fhv8DWtnb/8N+HBw9eQE+vBQwNW/H0qFEsvC+aN5pqS9++pvD3P4LY2GQ4OFjBykr4NzhzJoI3zvbtu8jT+fmFePz4pbjR9Db9+nVGZGTNDRgRu3aF8kaUr+9ErFx5AEuW7MXJkzU3MGvL06cP0KqVHvT0hL+Lectu377GG0y1pWvXvggK8udj6fr0cYCJiVC2/vzzDHJzs3HypFC2CgryERf3WNxgeptu3fohOLiibIm4ePE3bNrkg2++2Yy2bY0gJyfPt59//gvBwVshL98Un7LOKgszSlkHlbf3Bjg59YO8vBzf/vrrZ2zdGoymTevOU9yY9JYIZpTevXsJe/d6o1s3J/ToMQKvXqXC338kOnToidGj66ZR3Zh01vnzUfjjjzu4efPfOH78Os9jBiUjNfUVRo70R8+eHbB48WjUFY1Fb127dh5LlkzCsmWb8ccfx3keMyaZV3HevNUoLCzgeSxEuKCgAPLydVcfGwNk6BEEUSmLF7vycSvnzoVj1CgvPv5ENB7mp5/8YW3dWaKSq6x3nPW2Mz77bBiGDLFFly4deOOsseLsvBg9e47G33+fg7//KLi7bxOPhVm48CcYGUk21qOqnnFHR3dkZibB2XkJFBQUcfz4f3DnzoV6NfQ+JMw7PXp0T5w79zdGjfLnYw5F42F++mkhrK2NJHpOdb3jlREcfBXffz8TgwdbIiZGgC+/rDg+p6Hh6rqYj1kJDz8HL69RfMycaCyMv/9P6NxZMtmqzqPHGlpffz0e8+Z9i3HjZvN85uVLTX3Je/aTkgTQ0np/b3tj1lllPXo2NpZ8++67/3EjkuW9fJnKPZJswhbWgdUYqGu9JfLosXBzth079h1u3TrDQzn9/IZBQUEJ33zza511IjQmneXsbIPExAy0bSusfwwWDpqSsgfDhvlBSUkBv/76TZ12IjQWvZWamoTU1EQ4OLQV502e3AP5+XncuwfMFEcodOpkxb2KnzJk6BGEFNGpkwHi4l7ykCcWBnn8+B+YOXPUOz0rJuYZjI0N+MYmG4iOfsYbTaynfPPmg9i+fSUPHQwL+xs2NhbicJzmzVWQkpIhDoOqrHechU/p6rIQp2M8jDMqKgaenpNRn7Rp0wkpKXE83Klly3Z83AsbN/IuxMfHoE0bNu7LGI8f30J8fDRvMLFe8jNnNmPu3O28rO7fD+MNHlFZKSs3x6tXKeIQqKp6xqOjhZOKHDzoCz09Ezx5EsFDruqTTp3aIC4uhYc8tWvXko99YWNH3oWYmHgYG7fh261bjxEdHc8bTaynfPPmM9i+fe4b2boPG5tOZWRLGSkpr8ThTFX1ju/b9wfCwh7w42PHrvHr2Zg9tv/xx1C0bdsCQUEh/DfVBQYGnfDyZRwPd9LRacd7nUeNejfZevYsBgYGxny7d+8Wnj2L5g0m1kt+8OBmrFwplK2//w6DhUWpbKmoNEdGRoo4BKoqj96TJ/cxf/5w3gPP7r9+/Q/o6hqgX79hOHXqJ5w+fQCXLv2GYcM+w6essxjnzoVh377f0KVLRz4ZS3JyGoyN9bk376efTuHAgdP47bdLvAOrrmhMeisy8hz3CrZr14VPxpKZmQxdXWOsXz8WcXFsHNwuPHp0E/LyzfjzP2WdFReXjAEDzPjxmTO3sG7dUT5p1Nix63HvXhx27fLAzZuP0KyZPH/+p6y32IQrz58/FHsImUG3Zs0eaGoKy5gxa9ZAjBw5HT17DsKnDhl6BCFFKCkpYvv2FRgxYj6f2bJvX2uMHz/knZ7FGkZsUgE5OVno6+tgxgxh42v5cjcsXPgdn9SgqKiYnzt58gexomZjVdiU6Cwsis2K17278J9XWVRUlHD48Pfw8lqHkycvwd6+JxYvfrd/KO8K601mDZk1a0bwsmJhTH36jH+nZ7FGUUTEWcjKyvFxM4MGzeD548cv57NlsgkNiouL+Dkfn5Pisho2zItPh66q2gKzZgWiQ4fulT7f2LgnJk70xenTP6CgIBe2thO4l68+YT3KrDEzYsSaN7JlivHj+7zTs1jD6OzZiDeypYUZM4T/jJcvH8/HqbBJDYSypcVDK0tlaxifEr1FC1UEBs5C9+4dKn3+1KkbxMfseew5zNDbuXMe5s7dhvHj/w0TEz2ergsUFZWwYsV2zJ8vlC1r674YMuTdZIs1ithEKEy2dHT0MWqUULbc3Jbju+8W8gkNmGyxcz/8UCpbbHwdmw6dhUSxGfHMzCqXraiocLx6lYGwsHN8Y7CxLXPnruSNMzbmxcrKlqc/ZZ0lmnUzKOgonj0TQFVVGW5u4zB37gS8fp3Djco5c76Fra0VVq6ci7qiMektNutmSEgQkpKe8UlYHBzc4Og4F7t2CSfWYQYfgz2/snGFn5LO0tNryTeGaKKXnj07YsKEf/NjZvAx2PMrG1f4Kemt1q31+MaIjxfKTZcuPcXGoQjWYdWiRanx96lCk7EQhBRNxkJIPqnBp8y7TMZCSD6pwadMbSdjIYSQ3qoZ0lvvBumtT3syFlpegSAIgiAIgiAIQsogQ48gCIIgCIIgCELKIEOPIAiCIAiCIAhCyiBDjyAIgiAIgiAIQsogQ48gCIIgCIIgCELKoOUVGikG3ifLpZcP74xZfQ35cWBINP58mIy/4zKQX1jM884u6I9OrVXF1wffeI6vD0eVe8bTte++9o8k7yQIgiAIgiAIon4gQ08KCbryBK9yC6X+nQRBEARBEARBVA4ZenVAUXEJiktKIC9b95Gx342zgEv3tuXyxndvCzNdNdx8loafrsVWeh+7h22VefbeBUneSRAEQRAEQRBE/UCG3nsyYVsYrj1JRS9DTUzs2RYbQx8iNjUbxz1sUVLCQhpjcONZKrLziqCnoYiRVrr4wq4Dmso1wYv0HNiuPc+fEzjBCqO7tsGDhFcYEniJ55307Asz3eY4/nc8PPdH8LxLXw9EuxZK1X4TC+NkPEvJRn3xMd5JEARBEARBEETl0GQsH4h7gkwsOvQ3niS/5h69vMJijN1yFSH3XiI9uwD5RcV4nPyaG35ue2+gpKQEbdQVodu8Gb8/8nn6m32a+JkRscK8W8+Eea3UFGo08giCIAiCIAiCIMij94HIzC3EtN76WPR/xsjKK4Tbnpvc2GOeu13Te8C8TXMs//UO98798SAJofcSMbhzK3Q30OR5EbFpYuNORgbcG8iOP7PRR8QbI7C7vma9SGzYoxRM2hFe7TXMSP3Te1C9fA9BEARBEARBELWDPHofiOaK8lg2zBTqSk3RQlkB9xMyef7ATlro27ElmivJ40sHY/H1l2OS+L6HgQbf3xO8Ql5hEffsGbZQhmFLZUQ8T+N59+KFz+r+5lqCIAiCIAiCIIjqII/eB4IZZgpysvw4I6cAxSXCfJ3miuJrWr8J02SkZhfwPfPoMVho519PUhH98hUfq8c4GvECVx+m8HOMHm+urWt6G7V4r6UWiA+PIDYBX3lsoaKVgKyCVBy/OJvKqhry0RRQcCqXt2rRGSiU5FO5VUNGfi627PagMqqGPCZb8vblZct7NxRAskV66/0gvfVukN6qJVI2gTwZeh8IBbkm5bx7TWTAjb2EjFxxftljTSV5vu/UShVqzeR46Of/rj7l93Rtqw4Wv3nk1gvs+vMJv05FQQ6mOmqoDyh0s+Gho90ai52dP/ZnNApm796AYd9TR0V1ZGUBV/zK5636P0e0EKologo8Lp7FnO/nUPlUQ0ZWEUL9XpSXrekz0KKZsCOUIL31rpDeejdIb9WOo+uPQpqg0M06QLGpLKzbCcMsLzxIxNWHydzLF3AuWnxN345awj9AExlY6wuvPX8/ke+7ttMQGnsArjxMfpOnDllmPUpARnYBUl/nI7egSJyXmSvMe51XN10VH+OdBEEQBEEQBEFUDnn06oilTiaYtOMan5Bl8s5r5c7169gSg021xWkWkskmaGHevGbyTWDSWhUyMjJQlJdFzhvDqTYTsThtvMyXbiiLy9Ywvh9rrYfvx1t+8NDN930nQRAEQRAEQRAfDvLo1RHd9DVx2L037E20eWimvKwMDFoowXNQB+yc3p0bciK6v/HoMdjsnHKyTbj3zkKvuThfNGkLQRAEQRAEQRBETZBH7z05OKd3lecs9NQRNKNHjc/o1b5yD1p1z66Oj7HsAS21QBAEQRAEQRANB/LoNXK+PhwFA++TCLoinLRFUoJvPOf3sfsJgiAIgiAIgpAuyNAjCIIgCIIgCIKQMih0s5HyvuvcuXRvyzeCIAiCIAiCIKQP8ugRBEEQBEEQBEFIGWToEQRBEARBEARBSBlk6BEEQRAEQRAEQUgZNEaPIIgPwrajR3H88mW8TEvDjR9/rPH6/0SlI/jRawiyi/B0SrtP6q9wcdtFRB6PxKuXr+Bzw6fG60+fa4JrN5ogPUMGgWsL8Kmx7eJFHI+MxMtXr3DDp+by+s/zJghOagJBvgye2nxa5XV021FcPn4ZaS/T8OONmuvhT+fSEXLjNZIzinBi7adVDxmktySH9Fbd6SwG6S3SW3UBefQIgngnHsbGYti8eeJ0b3Nz7F6+XOL7B+go4tiQVhXyM7OyYDNlCgoKpKeBLngogN8wP3HaqLcRXHe7Sny/iXEJFs4rrPRcdmY2ltgsQWFB5ecbIw8FAgzzKy2v3kZG2O0qeXkNUC/BsS4VyyMzOxs2S5agoFB6yir2YSzmDSuth+a9zbF8t+T1sJuxIv49r2I9ZGRlZmGKjXTVRdJbkkN66931Vm11FoP0FumtuoAMPYIg3gm/7dvhNWWKOG3RoQO0NDQkvr+blgJaKVUMKlBTUcGA7t2x7+RJqfnLBPsFY7jXcHFaz0IPqlqqEt9vqF+C5mqVn1NSU4LZADNc3HcR0oJfcDC8hpeWl4WeHrRUJS+vbqolaNW0Yr6akhIGmJlh30XpKavtftsxxau0Hnaw6AANLcnroYm+AlqoVR7co6Kmgu4DuuPkPumpi6S3JIf01rvrrdrqLAbpLdJbdQEZegQhZTx98QIGjo74+vvvYTF2LExGjkRCcjKGuLvztO20aXjw5AkePX+OnpMnl7u3uLgYOoMGoaioqNp3ZOfkICQ8HPa9etXJb3BxcMDuX39FXZP4NBFuBm7Y/fVuLLBYAA8TD6QlpMF3iC9PL7VdihcPXkDwSICve35doaxcdVxrLKu87DxEhUTB3N68zn5HH5c+OL/7POqap4mJMHBzw9e7d8NiwQKYeHggIS0NQ3x9edp26VI8ePECjwQC9Py6YnnpuNZcXtl5eQiJioK9ed2Ul0ufPth9vu7L6sXTF3A0cMT3X3+PsRZjMdJkJJITkuE+xJ2np9lOw5MHT/D80XNM7lmxHg7Sqbke5mTnIDwkHL3s66YeMhxcHPDr7rqvi6S3JIf0Vi1li/SWxJDekj5ojB5BSCFxL1/C2tQU3335JdIyM+EdGIj+1tZY5uaGPcePw3PdOpzdupUbgCws6/nLl1BRVERSWho6t2+Pw+fOwT8oqMJzI4OD+f76P//AtH17yMrK1sn3W3XqhIj79/m3ycvLoy5JiUuBkbURZnw3A1lpWdjrvRed+3eGyzIXXNhzATs9d2Ll2ZVIT0jn4ZHJz5PRTKUZMpMyoddZD2GHw/CL/y8VnhsQGcD3MddjoGeqV2dlxTC0MsSTiCf8++Tk61atx6WkwNrICN/NmIG0rCx4792L/p07Y5mLC/ZcuADPnTtxduVKJKSn8xDJ58nJUGnWDEmZmeisp4fDYWHw/6VieUUGCMvrekwMTPXqrrysDA0R8eQJ/zZ5ubotq5dxL2FqbYovv/sSmWmZCPQOhHV/a7gtc8PxPcexznMdtp7dyg1AJusvn7+Eoooi0pLS0L5ze5w7fA5B/hXrYXCksB7+c/0ftDetu3rI6GTVCfcj6qcukt6SHNJbtZQt0lsSQ3pLuiBDjyCkEBUlJUxycuLHGmpqCI+KwvxJk3h6zODB3NBjdDUxQVRMDPx37uSGm1HbtuhtaYkJjo58q4r4xERoa2rW2ffLyclBVVkZyenp0NHSQl3CjLZ+k/rxYxUNFUSHR8NpvrDsbMbYcEOPYdjVEM+innGjjhlurY1ao1PvTug7oS/fqiItPg3NtZvX6W+QlZOFoqoiMpMzoalTd38XBjPaJvUTlpeGigrCo6Mx/42sjbGx4YYeo6uhIaKePeNGHTPcjFq3Ru9OnTChb1++VUV8Whq0m9ddecnJykJVURHJmZnQqUMZZiipKMFpkrBs1DTUEBUehUnzhfVw8JjB3NBjmHQ1QUxUDHb67+SGW1ujtrDsbQnHCY58q4rE+ERoatftb2B1UVlVGenJ6dDSqdu6SHpLckhv1VK2SG9JDOkt6YIMPYKQQtQlHBvQx8oKYX//DWVFRR7KmZqRAad+/XDwzJlqPXqKzZohNy9P4u9hYZirtmzB0zNnJL4nJzcXigoKqGuU1ZUlus6kjwkehD2AgrICEh4l4FXqK3Rz6oYrB69U69FrqtgU+bn5En8PC8E8sOoAtj/dXotfAeTn5ENBse7LS11ZsvLqY2KCsAcPoKyggEcJCUh99QpO3brh4JUr1Xr0FJs2RW6+5OXFwjBXHTiAp9slL6+c/Px6kS1VdcnqoVUfK/wd9jcUlRV5KGdGagb6OfXDmYNnqvXoNVNshrxcyeshC8HcsmoLzjyVvB4ycnNy60e2GpDeehedxSC9RXqrLnQWly3SWw1SbzV0yNAjiE8AGwsLnLh4EV06dsSx8+fR6834p94WFpi7Zg08Jk7EP48eIfTaNXzr4QHN5s2r9eiZGRkhJja2XN6GQ4dwNjycHzstWgSn3r3h4eLC07ECAWytrMpd738rDb8+zRZ+35EXcDZUxpKu6jydmJLCG3HqalXMQFKHGNsY48aJG9Dvoo9rx67BuJcxz2feu21zt8HJwwmx/8QiKjQKk7+dDFVN1Wo9em3N2kIQIyiXF7ohFHfO3uHHG5w2wNzJHIM8BvF0UmwSTG1Ny11//FQT3IwUDqle+S85dLcuxgjHYvH59MR0boBKarR+SGyMjXHixg100dfHsWvX0MtYWF7Mezd32zZ4ODnhn9hYhEZF4dvJk6GpqlqtR8+sbVvECMqX14bQUJy9Iywvpw0b4GRuDo9BwvKKTUqCrWn58vJ/1gS/pgjLy+aWHJxbFmNJO2F5Jaanc+NTUoP1Q2JhY4GLJy6iY5eOOH/sPMx7CeuhRW8LrJm7BhM9JuLRP49wLfQaPL71QHPN5tV69IzMjBAbU74eHtpwCOFnhfVwkdMi9HbqDRcPYT0UxApgZVu+Hv54Kg0XI4X1cMa/XmCgtTKmOwrrISMlMYUboGrqap+U3qpMZzFIb5HekkRv1VZncdkivSUVequhQYYeQXwC+H7xBab7+GD/6dM8JHKXry/P725mhuhnz+DQpw8PkWQTrLDGUk101Nfne0FSkji00mv8eL5VxsUbN7Dpm2/K5S211uBbZbDvGGlnh4/BRN+J2Dh9Iy7vv8zDIT12efD8Dt07ID46HpYOltDQ0eATrDAjryZ0O+ryfaogVRxWae9lz7fK+OfiP5i9aXa5vJFOxXyrCvYtPUb2wMfAd+JETN+4EfsvX+Yhkbs8hOXVvUMHRMfHw8HSEjoaGnyCFWbk1URHXWF5CVJTxaGVXvb2fKuMi//8g02zy5fXUv1ivlUG+46RPT5OWX3h+wV8pvvg9P7TPBzSd5ewHpp1N8Oz6Gfo49CHh0eyCVaYkVcT+h2F9TBJkCQOqxzvNZ5vlXHj4g18s6l8PZzppMG3qmDfYjfS7pPTW5XpLAbpLdJbkuit2uosLlukt6RCbzU0ZEpKSko+9kcQBFE961evxmJn5wZVTEFHjkCQnAwfN7cP/myHOXOw0dsbJoaGtb539u4NGPZ96dT8DYGQoBCkCdLg4iPsofzQrHJYhc83fg49Ez2Jrs/KAnz8yk+scbNbAVrU7VwbEhMUEgJBWhp83niEPyQOq1Zh4+efw0RPsrIqi8fFs5gT8AUaEkeCjiBZkAw3nw9fDxlzHObAe6M3DE0kq4sZWUX4zO9FubybY9ugRbO6mzCmNpDekhzSW7WULdJbjVZvleXo+qNYsXgFpAVaXoEgiHdixqhRaKleGirxoWALpk8dPvydjLyGysAZA6HasnZrKkkKWzDdbqqdxEZeY2DGwIFoWcs1qCSBLZg+1c7unYy8hsqoGaOg3vLD10PRgunDpw5/p8ZSQ4X0luSQ3qqlbJHekhjSW/UHGXoEQbwTbEp39ypCNd8HtmD61BEjIG1l5ehe9dih94EtmM4MPamTrWrGWr0rbMF0ZuhJW1mNd//w9VC0YPqIqdJXF0lvSV5WpLdqKVuktyQuK9Jb9QMZegRBEARBEARBEFIGGXoEQRAEQRAEQRBSBhl6BEEQBEEQBEEQUgYZegRBEARBEARBEFIGGXoEQRAEQRAEQRBSBhl6BEEQBEEQBEEQUgYZegRBEARBEARBEFKG3Mf+AIKoa7p3714uvWjRIkyePJkfFxYW4scff8Rvv/2GxMREaGtrY/jw4Zg5cybk5ITV48SJE/D19S33jBs3brzz92zfvh1//fUX7t69i/z8fJ534MABdOjQ4Z2fSRAEQRAEQRBlIUOP+KRZtWoVzpw5I06/ePEC27ZtQ2xsLL799ts6eefPP/+MrKysOnk2QRAEQRAEQTAodJP4qBQVFXGvWn2wcuVK7okTefMiIiLERp6LiwtCQkL4nnH69GlERkby4xEjRvD72P0fgpEjR3IP4dixYz/I8wiCIAiCIAjibcjQI+oNNzc3HkbJ9qdOncKYMWPQp08fPHr0CPfv3+chlfb29ujduzc/x0IcCwoK+L0JCQn8XrYxI4zx8OFDcd6DBw943tmzZ8V5cXFx1X7P77//Lj6ePXs21NXV+V4Ee1ZdwH7nsGHDoKmpiY/N0dBQWLm4oKm1NZ6+eFGrex/GxmLYvHni9OXISIzx9saoxYsRdOJEjfeHxuVg4PF49P81HpvuZIjzM7OyYDNlivhv31AIPxqOhVYL4dLUBYlPE2t1r+ChAH7D/MTpi9suYsOwDfDrXppXE//ck8Gaf8vh2/Vy+P18qerOzszGEpslKCyonw4TSTkaHg6rhQvR1MUFTxNrV14PBQIM8ystm8sxMRizeTNGbdqEoCtXarz/P8+boPctORiEy5fLz8zOhs2SJSiop84lSQk9GgoXKxdYN7XGi6e1q4exD2Mxb1hpPTy67SgWDVuEmd1nSnT/T+fSMdP/BUZ4x1Y4l5WZhSk2Da8ufiy9lZFXjCmhLzHoeDyG/CbAjnuZ4nOktyqSnQ1s3inL9da6ADlcuER6qyqKSwDnO7IYGiWHIX/L4fvnpWVFequS8iouwVebE+C5QQCPAAH2/Z7e4PXWx4IMPaLeiYmJ4d4xFh7JPHpsnNqsWbNw6dIlZGRk8MrJzjFD78svv0RJSQlat26NVq1a8fvv3LlTbs+4fft2ub2Wlhb09PSq/Q6RcaiioiI2utiepRnR0dGQdpzt7REZHAxdbe1a3+u3fTu8pkzhx4VFRfDfsweBCxbg0Jo1OB0WhkfVNMAKi0uw7K9U7LLTwu/DdXD0yWtEpwvHK6qpqGBA9+7Yd/IkGhI2zjYIiAyAhq5Gre8N9gvGcK/h4rRRbyO47naV+P6iIuDQUVm4zSiE98JC3IhoAsFL4TklNSWYDTDDxX0X0ZBwtrFBZEAAdDVqX15+wcHwGi4sr8LiYvifOoXAiRNxyN0dp2/fxqOkpGrvH6BegmNdKhpzakpKGGBmhn0XG1ZZ2TvbIzgyGNq6ta+H2/22Y4qXsB4yzHubY/nu5RLf381YEf+eJ9Stb6OipoLuA7rj5L6GVRc/lt6CDLDIQh3nR+ri16GtcejRa0Sl5PFTpLcqL6+h/1eMZV8VYpFHIa7daILYOBl+ivRWeZrIALtNinDaohCnLApxNUMG4ZnCsiK9VZEmTWSwaoY2NnrpYINXa0Q9ysXtx7kNWm99LMjQI+qdV69eYdy4cQgNDeUTnfj7+yMvLw9NmzbFDz/8gPPnz2PIkCH82qtXr+Ly5cv82MrKqpwxxww9GRmZckaf6JylpWWN35GeLuwBUlZWLpcvSqelpdX4DBbSKfIgVrWx0M/6Iik1FS5ffgmLsWNhPmYMzv75J89PSE7GEHd3nm87bRoePHnyXu/JzslBSHg47Hv14uk7jx9Dt2VLtGvdGgry8rDv3h2XIiKqvD8yOR9tVeRgqCaPZrIycGqnhHNxOeLzLg4O2P3rr6hLMpIysN5lPRZYLICXuRcizgq/Ny0hDb5DfHn+UtulePGgdh6Dt8nLzkNUSBTM7c3FeXoWelDVUpX4Gc+ey6CFZgm0WgLy8oCVeTHu3C1V331c+uD87vOoS5IyMuCyfj0sFiyAuZcXzr75+yakpWGIry/Pt126FA9q6WF5m+y8PIRERcHeXFhed168gK66OtppakJBTg72pqa4VEMnTDfVErRqWvk5lz59sPt83ZZValIqvnT5EmMtxmKM+Rj8eVZYD5MTkuE+xJ3nT7OdhicP3q8e5mTnIDwkHL3shfWQ0cGiAzS0JDeuTfQV0EKt6uH6Di4O+HV33dbFxqK3mjdtgm5aCvyY6S19VTkk5hSJz5PeKo+SImCoX8KPmd5q2aIEmaVOUNJbb8vXm2qYUwxkF8sgt7j0HOmtiqgoCf8H5hWUIDe/BPkFQlmrL73VWKDJWIh6R01NDQtZSFfTplBQUOAhmAxbW1v0evMPeO7cueLQyfDwcPTv358beiyPeQSZF5AZd23bthUbeCxP5IUTGYXvg8iIbEx4rl0La1NTBH//PfeMxr0Uun1Wbt6M/tbWWObmhj3Hj8Nz3Tqc3bq1yuccPHMG/kFBFfJZLzrj+j//wLR9e8jKyvJ0cno6tDQ0EHrjBuISE6Glrl5tz3hibhFaKcnidGw2nr0qhLaiLGIySsMsrDp1QsT9+/w3yLMWQh2w03MnjKyNsDh4MQ97TIlL4fkHVh5A5/6d4bLMBRf2XODXrTxb9fjMKwev4Bf/XyrkM+8fI+Z6DPRM9cRl9S5kvgKaqwF/35ZBcqoM1NSAhDcePYahlSGeRDzhv0NOvm7UuufOnbA2MkLw4sU89DEuRVheKw8cQP/OnbHMxQV7Llzg152tZjzrwStX4P9LxfJi3j/G9ZgYmOqVlldyVha0VFUReu8e4tLS+HFNHr3qsDI0RMSTJ/w3yL+ZWfdDs9ZzLUytTfF9sLAevowT/rE2r9wM6/7WcFvmhuN7jmOd5zpsPVt1PTxz8AyC/CvWQ+b9Y/xz/R+0Ny2th3VBJ6tOuB9Rt3WxseitsiRkF+Juaj569G4hziO9VTXpGUBcvAzaG5Y2xklvVWTCP7KIei2D8VrFGNC8tKxIb1XO0m0vEROXj//rrgxr42b1qrcaC2ToEfVOu3btuJHHyMzMRHGxsNuKLW0gouyxyPMmMt5Yxb116xYeP36MoUOH8jw25o8tWSCKyZbE0GNj8liI6OvXr8vli9LsfE0wj937LLXwofk9LAxbfHz4MVNuhm/CV8OjojB/0iR+PGbwYN5gqo4Jjo58q4p4thRFJWMMWY8447CEHpOh7ZT4fm/0q3L5bGkLVWVl3hDT0dJCXRD5eyTct7gL3ycvh1aGwvC16PBoOM134sc2Y2y4oVcdfSf05VtVpMWnobl28w/yzZbm7B9/Ca6Elw/GkJWThaKqIjKTM6GpUzdjP3+PjMQWd2F5MQPJ8E0odXh0NOY7CctrjI0NN/SqY0Lfvnyrivi0NGg3r1hezJPHOHzz5nv9DjlZWagqKiI5MxM6dTRONuz3MPhsKa2HeobCehgVHoVJ84X1cPCYwdzQqw7HCY58q4rE+ERoatftWF9WF5VVlZGenA4tnbqpi41Nb+UVlcDzSgqWd9PgXj4RpLcqhw2J3bNfFs7Di7iXTwTprYocNCvCq0LA86HQ4LNUERp7pLcqx39OK2TnFuO7/cnc4DNuq1BvequxQIYeUe+IjDyRd69Jkybc2GPr2IkoeywyuIyMjKCqqspDPw8ePMjv6dKlC/e8nTx5kq9FJwq97NixY43f0alTJ0RFRfGlDlJTU/n4PLYXLX1gbGxc4zOYkef+pvFbFTo6OjxEtSEjU8ueccVmzZCbJxybwmA94UllQl2T0tOhXc3YrFaKsniZXRryxMKfWF5ZcnJzoaggVNoNibc9vTV59JoqNkV+rnD84bvCvHkZZUKeWPgTyytLfk4+FBQbfnnV5NFTbNoUuW/Wl2Roqagg6VVpRwA71laVPOy1MnLy8xukbL1dEWvy6DVTbIa83NJ6WFfk5uQ2TNmqZ73FYGPGF11NwcA2iuKOqrKQ3nq7vIB9h2TR2aTkTUdVeUhvVURVDhioXoIjSaWGHpct0luVotSsCbqbKOLCrddiQ68h6636hsboER+VZs2awfzNWBw2Hu/69evckGNr2YkQhXMyg1B07Z9vxnCwNDP2GNeuXeN7lpYklMnBwUF8vGPHDu45ZHsRonGCHxrmxWTvys0VDhxmMOOS5WWzacreA4fevbHt8GF+zCa6eRYfz49tLCxw4s0EFMfOn0evN+UooqWGBp4nJIjTrFecNY7e3kSYGRkhJrZ0lj4zQ0MIkpPx/OVL5BUU4MLNm+jftav4PBtvZ1Cmp92iRVPEvS7E01cFyC0qwZnnOfg/vdKu3sSUFCgrKkKdxSjWEVYOVji77ay4rBKfCTsXjG2MceOE0Et77dg1GPcqb/CrtVRD8vNkcZp585hR9/Ymoq1ZWwhiBBJ/Fxtr52bgVi6vnV4JUtNkkJTMPNpA1J0m6NK5dABHemI6FJQVoKxefrzph8TBygrb3oRTc9l60xljY2yME2+82seuXUOvtzpIWqqp4XlyaXkxbx4z6t7eRJi1bYsYQWl5menqQpCejuepqcgrLMSF+/fRv8w72Hg7A7fy5VUdienpUFZQgPpbY3M/JL0deuPwttJ6GP9MWA8tbCxw8YSwHp4/dh7mvcrXQ42WGkh4XloPmTePGXVvbyKMzIwQG1NxtsyqYGNWHA2q9nhVRkpiChSVFaGmXnd1sSHqrbd1lojVN9OhpdgEc80qlgfprYr18OhvTaCqUoLBdmUGnH3ieqsynZVcACS86d8qLAEuZcigbWkkIumtt/RWelYRUjKEE24VFZUgIjoXrTTl6lVvNRbIo0d8dDw9PfmYPDYhC9uXxcbGho/PE8FCMplByLx5bHxfhw4duMeAGYwiw0nS8Xldu3aFo6MjX0svODiYbyJYSKgkz3mX0M0pU6ZAUOYfAuPzzz/n++HDh/NF3N+Vjd7emOvnB8tx43h63YIF0NfVhe8XX2C6jw/2nz7NQyJ3+fqWu2+5mxtcV67kxtWxwEAYtGlT7Xs66uvzvSApiYdWsjAJ72nT4BUQgKLiYozo2xdGZZ4RKxDAtkx5yjeRgV8PTcy8kISiEsClvTKM1Us9vWzChJF2dqhLPt/4ObbN3YaFlgt5euq6qdDW18ZE34nYOH0jLu+/zMMhPXZ5lLvPZbkLNrlu4g2UpceWQtug+pn/dDvq8n2qIFUcVhm6IRR3zgonENrgtAHmTuYY5DGIp5Nik2BqKwxTFMH6LVxGF2H7bjmwSOde3YqhU2aiRDbZS4+RPVCXbPz8c8zdtg2WC4XltW7qVOhra8N34kRM37gR+y9f5iGRuzzKl9dyFxe4btrEjatjS5fCoIaZEjvqCstLkJrKQytZyJK3kxO8DhwQypalJYzKhPPGJiXB9k1Ypwj/Z03wa4qwH9PmlhycWxZjSTthQ5NN9DKyR92WlfdGb/jN9cM4S2E9XLBuAXT1dfGF7xfwme6D0/tP87Ai313l66HbcjesdF3JGyiBxwLRxqD6eqjfUVgPkwRJ4vCkQxsOIfxsOD9e5LQIvZ16w8VDuD6oIFYAK9vyeu3HU2m4GCnsYJrxrxcYaK2M6Y6lYetsshe7kXVbFxui3npbZzHYzMA/PngFE3V5DD0l1OFfdFbDCAOhoUJ6q3w9ZDMDX/pTFjqtS7B+g7A+DrYrgrVlySettyrTWakFgNdDOf7/kBl6vdRKMK1VqXFMeqt8Xcx4XYTvD6SgqBgoKi5BF0MFDOutWq96q7EgU8LiEAiiHmDr57GxddbW1nzphLLcvXuXe9PYIuU5OTk83JF51FxdXcuFerL72XMYzBDb+WY8kOjZjC1btqBHmYYcM8YYbEmHt2fAZIu179q1i4d+vnz5ki/hwNa4Y+9ljYCysPBLttA5433G5bFveNvQE1GVobd+9WosdnZGQyLoyBHeG+4jgTfF/vPPsembb/hECJLgMGcOb/yZGBrW+rtm796AYd+XLmXQEAgJCkGaIA0uPsIGd3WssF+B2Ztmo62pcKIhSVjlsIobrnom1S8pIoJFJ/v4lR+gfrNbAVo0kDHrQSEhEKSlwcel5vKyX7ECm2bPhumbiZlqwmHVKt74M6lh+ZXK8Lh4FnMCvkBD4kjQESQLkuHmU3M9/Nz+c3yz6Rs+gYukzHGYww1XQxPJ6mJGVhE+8ys/ocnNsW3QolndTRhTF3qrtjqLQXqL9JYkequ2OovLFumtOtVbZTm6/ihWLF4BaYE8ekS98bZxV5bOnTsjoEwYRFUwI7EyI6u6Z1cHM+aYkSgyHuuDhj5eT1JmjBqFHZWMtaqM0Bom6CgLW3h46vDh72TkNVQGzhiIczvOSXTt6tDVtXo2WzDdbqqdxEZeY2DGwIHYcU6y8gpdLXl5sYWHp9rZvZOR11AZNWMUftkhWT3cGSp5PRQtPDx86vB3aiw1dr1VG53FIL1FektSvVUbncVli/QWPnW99T7QGD3ik4F545h37+eff661YcbuE3nzCCFsHKT7+PEfvDjYwsNT63HtwfoqK0f32o2NkhS28DAz9KROtqqZPfFdYQsPM0NP2spqvPuHr4eihYdHTJW+ukh6S/KyIr1VS9kivSVxWZHeqh/I0CMIgiAIgiAIgpAyKHSTkHred507Nqbu7bF9BEEQBEEQBNGQIY8eQRAEQRAEQRCElEGGHkEQBEEQBEEQhJRBhh5BEARBEARBEISUQYYeQRAEQRAEQRCElEGGHkEQBEEQBEEQhJRBhh5BEARBEARBEISUQYYeQRAEQRAEQRCElEGGHkEQBEEQBEEQhJRBhh5BfEJ8tnQpzJyd4bxgQbn8IyEhMBk5ElYuLrgdHf1e7wjcuxfpmZnVXvPH9euQsbAot83w8UFDIuCzAHiaeWKt89py+WFHwuBh4oGFVgvx7Paz93rHicATeJ3+WqJrT/73JFx1XTGj1Qzs/no3iouL0ZD4LCAAZp6ecF5bvryOhIXBxMMDVgsX4vaz9yuvwBMnkP665vKatmEDmk+ZAhlnZzxNTBTns/f3+PprqE6aBDsfHzwrc64+WfrZUjibOWOBc/l6GHIkBCNNRsLFygXRt9+vHu4N3IvM9OrrIUMQK8D0ftPRW603BmgPwL+/+jdKSkpw5uAZDOswDBYyFti8ajM+dZ3FECQloYuzMxR79IBm375wXbECefn5OHjmDDoMG8b12KrNH6+sGpreShWkwrOLJyYoTsBUzan4r+t/UZBXgK1zt/I0y1/cazEe3XqET11niSgqKoL1l1+KddfcrVuhOXUqFCdMQK/Fi3Hr0ccpq4amt0RlNd56PNdRL56+gM8MH34s2gK9A9/rW6QFuY/9AQRB1A8JyckICQ9HwoULFc5tP3wYgYsXw7Fv3/d+T+BPP2H0oEFQV1Or8hqrTp1wISiIHz958YI3mFheQyEtIQ1RIVH4MeHHCufObT8H10BXWDtav/d7WIOp1+heUFZXrva6F9EvsGvBLvyf2//B0MoQW923wsDSAHaf2aEhkJCWhpCoKCT8WLG8tp87h0BXVzhav395sUbT6F69oK5cfXnJABjYpQt+/euvcvms0fQqJwc/LVyIxXv2YNYPPyDE1xf1SXJCMsJDwnEhoWI9PLz9MBYHLkZfx/evhz8F/oRBowdBTb3qesjIysxCR/OOmPHVDNy9dRfbVm+DeU9zvH71GnYj7bA3YC8+Fg1JZzFkmzTBZ8OHw8LYGP88fIjFAQHoZW7O80fa2SFg78crq4aot5rINsGAzwbAwMIAsf/EYs/iPTDuZQx9c32YDzSHfDN5BHkFYfu87VgXtg6fss4SsenUqXLGpbm+Pgaam6OZvDy8goIwb/t2hK2r37JqiHqLsX/Tfjy8/bBcXp8hfTDLexY/1mmn897fIw2QoUcQUsbxCxew7L//5b3y/aytsembb3j6+B9/IDUjg/eAG7Zpg6OBgbgaGYkv1qzBw9hYPHz+HCpKSti7Zg3MjY1x5dYtePj782fKyMjgaEAADNq0QXZODrzWrUPkgwfILyjAkpkzMXnYMBz+/Xf47diB+MREOM2bh6by8ti2fDl6WVhU+EbWoLLr0YMfX7xxA/JycpgybFi9l9Vfx//CT8t+4mXVuV9nzN40m6evH7+OrNQs3vvdyrAVvI964/7V+9j2xTYkPEyA4KEAzVSaYcHeBbzRcvfKXezw2CEuK3a9toE28rLzsNNrJ55GPkVhfiGclzij/+T+uHr4KoL9gpEWn4Zvnb6FXFM5zN02lzeCKoPdzzx4IxaMQJtObXBw1UH8fe7vejf0jv/1F5b9JCyvfp07Y9Ps2Tx9/Pp1pGZl8R5ww1atcNTbG1fv38cX27bhYUICHgoEUGnWDHsXLOANlyt378JjR2l5sesNtLWRnZcHr507Efn0KfILC7HE2RmT+/fH4atX4RccjPi0NDh9+y2ayslh29y56GVceXn9z8sLu8+fr2Do3Xr8GF7Dh2Nkz54Ie/AA//71VxQUFnL5+9BcOH4B/10mrIfW/azxzaZvePqP438gIzWD9363MWyDwKOBiLwaiTVfrEHsw1g8f/gcSipKWLN3DYzNjXHryi34e5TWw4CjAWhj0AY52TlY57UODyIfoCC/ADOXzMSwycPw++HfscNvBxLjEzHPaR7km8pj+bblsOhVsR4yOnbpCJ/NQm96d7vu3NBj905dMJXn1Yeh1xh0FkO7RQt4z5qF3Lw8qKuq8jxVJSX+LEZ9GXqNRW+pa6tjrPdY5Ofmi41CRVVF/qzCgkLuFWyu3Zznfeo6ixGfmgrfQ4cwb+hQbPjtN573xdChXEcxr6B28+ZQVay7smpMeotdt9V3KybMm4CfNvwkzm/ZuiW69e+GJk0oYFEEGXoEIUWwBo3b6tUI27sX+rq6GOLujkNnz2LtggVwd3GB3axZiAwOFl/fx8qKp+1cXbFq7lyx8cVY/+OP8HZ1xcShQ/Hq9Ws0kWF+EmDNjh3oZGCAHatWISs7mzfChtjaYpyDA98MHB1x6ocfeAOLcfnmTcx/KzSGwa7R0dLCnhMnMLRvX2hpaqI+YY2ZLW5bsDZsLbT0tbB6yGpcPXQV09ZOg6O7I3zsfBAQGSC+3qSPCU+z/ImrJqKLXRfxuWPrj2GM9xj0m9gPOa9yINNEWFbBa4K5YTZvxzzkZOVgkdUiWA2xQp9xffjmZuCG5aeW88YV4+7lu9gxX9iYKMu4b8bx/e3zt3mjKTM5E2mCNNQnrEHjtmULwtauhb6WFoasXo1DV69i7bRpcHd05KGQkQGl5dXHxISnWf6qiRNh16W0vNYfOwbvMWMwsV8/7mETy1ZwMDq1aYMd8+YhKycHVosWYYiVFcb16cM3Azc3nFq+nDewGJfv3sX8N42vsrBrKqOlmhrCo6ORlJHB94VFRUjKzITuB5Y91phZ7bYae8P2QldfF+5D3HH20FksWLsALu4umGU3C8GRpfXQqo8VT7vauWLuqrnoYVdaD39c/yNcvV0xdOJQ7mUTydaONTtg0MkAq3asQnZWNm+A2Q6xhcM4B745Gjjih1M/8MYV4+blm1g7v2I9ZNdo6wrLM3hrMG9g2Y2ovw6ExqazdLW1eegmg33fJCcn1CeNSW+xazR1NXmIJmOI+xD0m9SPH2+evRkX/ncBOh11sPjw4jopq8amsxbu2oUZAwfCwsCg3LnZmzfjfxcuoKOODg4vrpuyamx6q3W71hg1YxSMLcobzqd+PoXf9v4GU2tTfLv7W3Qw64BPHTL0CEKKePD0KfRatYKhnh5Pjxo4ENdu336nxkjfrl3hHxSEWIEADn36wMrEhOef+fNPZOfmYt/JkzzNesgfx8Whhbp6pc/p161buYZaWS7duMHv/feXX6K+efHgBVroteA934yeo3oi+lq0uCFSG0z7muKI/xEkxybDysGKh1cyIs5E8IbZxX0XeZr1jr98/BJqLSoPS2G982UbaWXHIpgNMOM983LyclDRVEFTxaaoTx68eAG9Fi147zdjVM+euBYdjUn9al9efU1N4X/kCGKTk+FgZQUrQ2F5nYmI4I2zfReF5cV6yB+/fIkWVYTUsR76sg21mvBxccHcbdugPWMG2rRowfMUm374cnz64Cla6bWCnqGwHg4cNRC3r92G06Ta18OufbsiyD+Ij6Xr49AHJlbCevjnmT+Rm52Lk/uE9ZD1jsc9joN6i8rrYbd+3co10t7m4m8XsclnE77Z/A3aGrVFfdHYdBaDGaWXbt6E94YNcOrXDyPs6s8wbkx6SwQzSu9euou93nvRzakbeozoAZflLujj0gfbv9iOXQt31Ymx15h01vmoKPxx5w5u/vvf3NvIYAYlY7mLC1z69MEX27dzY7CujL3Goreunb+GJZOWYNnmZdzTyGDG5OCxgzF00lD+fOY1XPX5KuwL24dPHTL0CIKolMWurnzcyrnwcIzy8uIhTaLxMD/5+8O6c2eJSq663vHdx4/zxtaw/v0b9V/BebEzeo7uycMp/Uf5w32bu3gszMKfFsLI2kii51TXM776/GrER8dzI2+53XJo6wt7iBsji52dMbpnT5z7+2+M8vfHNnd38XgYNn7O2kiy8qqtR8/NwQEje/TgYVDHrl3jDTcNFRU0ZFwXu/IxK+HnwuE1youHM4nGwvj/5I/O1pLVw+o8eqyh9fX4rzHv23kYN1voPW6M1IfOYh49G0tLvn33v/9xI7I+Db3GpreYR6+TTSe+HfvuGG6ducUNPR0jHb7dGX8HZzafwaeus5xtbJCYkYG2s2eL89jEUbmHDsFIR4dv4+/cweYzDb+s6lpvpSalIjUxFQ5tHcR5k3tMxo3cG+J0xJ8RPEKBIEOPIKQKFp4U9/Ilnr54gXY6OnyMy8xRo97pWTHPnsHYwIBvt+7dQ/SzZ7zRxHrKNx88iO0rV/I4+LC//4YNmznzTShLcxUVpGRkiMOgquodZyFbh8+dw4xRo/jYmPqGhSalxKUg8WkiWrZryce92M+0f6dnxcfEo41xG749vvWYG2SswcR6yVkjZu72ubys7ofd5w0eUVkpN1fGq5RX4hCo6nrGj/37GNp2bouQnSGIuxcHrz1eqE9YeFJcSgqfCa5dy5Z87MtM+3crr5j4eBi3acM3Nm4uOj6eN5pYTzlryGyfKyyvsPv3YdOptLyaKysj5dUrcRhUVb3j+/74g4/BYzCDjl3PJkQ4cf06cvLzkVdQgP8cP46pAwagLmChSS/jXvKZ4NiEAKzXedTMd6uHz2KewcDYgG/3bt3Ds+hnvMHEeskPbj6IlduF9fDvsL9hYVNaD1WaqyAjJUMcAlWVR+/J/SeYP3w+74Fn91//4zp0DXSRLEjG80fP+TUxUTH4bd9v6P1/vdGildAT+inqrHNhYdj322/o0rEjn4wlOS0Nxvr6/HmPngvLKiomhl/zf717o9Ubr/Gnqrciz0Vyr2C7Lu34ZCws5FzXWBdb3LfAcrAlZOVkEX4knOd96jorLjkZA8zM+PGZW7ew7uhR7PHygvuWLRhsaQk5WVkcCQ+HsW7dlFVj0lsJcQl8TKDIQ7hr3S6s2bMG+zbsg35HfWSmZeLM/jMw6y4sz08d8ugRhBShpKiI7StWYMT8+XwwdV9ra4wfMuSdnsUaRmevXuX/YPR1dLhBxlju5oaF330Hy3HjUFRczM+d/OEHsaL2mjKFT4nOPHVsVrzub/55vc2R0FA+jmb6yJH4GCgoKfCGzJoRa3hZsTCmPuP7vNOzWKMo4mwEb7iwcTODZgzi+eOXj+dhSQstF6K4qJif8znpIy6rYV7D+HToqi1UMStwFjp0r3o8QVRoFPYv3w8tAy1u5FV3bV2gpKDAGzMj1gjLi4Uyje/zbuXFGkZnIyKEsqWlhRmDhOW1fPx4HppkuXChULa0tHDSp7S8vIYN41Oit1BVReCsWejeofIymLphg/iYPY89hxl6bGzeoh9/hIK8PJ+QZd20aagLFJUUsWL7CswfIayH1n2tMWT8u9VD1ii6evYqly0dfR0+LoXhttwN3y38DuMsx3HZYud+OFlaD6d4TeHTobOQKDYjXlWNnqjwKLzKeIWwc2F8Y7ivdEf803gc/99xng49Gsq3oAtBH9zQa0w6i82uGXT0KJ4JBFBVVobbuHGYO2EC3Hx98b/jwrI6GhrKNzarcF0Yeo1Jb7FZN0OCQpD0LIlPuOLg5gDHuY5YMWgFruy/gqLCIhh2NYTbD2741HWWXsuWfGOIloTp2bEjNv72G/ZfucLHE3c1NMQPbnVTVo1Jb7XWa803BtNTjC49u/DnsvBz9iwrWyse2kkAMiXsr0kQRINm/erVPHSEqJnZuzdg2PfDqaiqISsL8PEr70W92a0ALerfsdqo8Lh4FnMCvvjYn9Ggycgqwmd+L8rl3RzbBi2ayX60b2oMkN6qGdJb7wbprdpxdP1RrFi8AtICzT9KEARBEARBEAQhZZChRxAEQRAEQRAEIWWQoUcQBEEQBEEQBCFlkKFHEARBEARBEAQhZZChRxAEQRAEQRAEIWWQoUcQBEEQBEEQBCFlkKFHEARBEARBEAQhZZChRxAEQRAEQRAEIWXIfewPIAiicoqLS5CWnc+Pc0rkkJJbREUlAfloyhfWJarm9euKeWkFVGI1kYemfEFwomoyX1csn7Q8KrOaIL1VM6S33g3SW7Ujp1gOKVl50FBqiiZNZNDYkSkpKSn52B9BEERFmKLp5hdCRUMQBEEQBFGP3PQZjBYqCo2+zCl0kyAIgiAIgiAIQsogQ48gCIIgCAFcrLAAAHFPSURBVIIgCELKIEOPIAiCIAiCIAhCyqAxegTRCCZj+ff3mzDMyeNjf1Kj4MCBpfD1nfaxP6NBk/a6CIMDEsrlLbXoD2X5ph/tmxoDV68uwrff/t/H/owGTdprYHCAfLm8zcP7Q02BZKs6SG9JIlukt94F0lu1Y9OmCHh4fCM1k7HQrJsE0UBhCkY0EFhRpgjNmzX+QcH1gQLy0UJF9mN/RqODGXkq8iRjNctWvf1JpAZm5JH+qh7SW+8G6a2aIb1VOxSbFErFJCwiKHSTIAiCIAiCIAhCyiBDjyAIgiAIgiAIQsogQ48gCIIgCIIgCELKIEOPIAiCIAiCIAhCyiBDjyAIgiAIgiAIQsogQ48gCIIgCIIgCELKIEOPIAiCIAiCIAhCyiBDjyAIgiAIgiAIQsogQ48gCIIgCIIgCELKIEOPIIh3Ijb2IebNGyZOR0Zehrf3GCxePAonTgRVe29WXgF8QsPhfvwPePx2CUfvPS49l5WJKVNsUFBQIDV/mYcPYzFs2Dxx+vLlSIwZ441RoxYjKOhEjfdnZBdjys6XGPTveAwJEGDHpUzxuczMLNjYTJGq8hIIHsLPr1S2YmIuY/PmMdi0aRSuXKletrILC7D5bjjWRP6BdX9fwoX4UtnKzs7EkiU2KCyUnrJ6+FCAYcP8xOnLl2MwZsxmjBq1CUFBV2q8PyMbmLJTFoP+LYchAXLYcam0WZCZmQ0bmyUoKCiEtEB6S3JIb9UO0lu1kS3SW/UFGXoEQbwT27f7YcoUL35cVFSIPXv8sWBBINasOYSwsNN48eJR1TfLAFMsjLF1pB3+M9QW5x49R0xKOj+loqKG7t0H4OTJfVLzl/Hz2w4vryn8uLCwCP7+exAYuACHDq3B6dNhePToRfUPkAEW/Z86zn+li189WuPQjdeIisvjp9TUVDBgQHfs23cS0kJwsB+GDxfKVnFxIU6d8sfEiYFwdz+E27dPIympGtkCMLStMZZZ2WGRuS2uJT1HbJZQtpSU1GBmNgAXL0qTbAXDy2s4Py4sLIa//ykEBk7EoUPuOH36Nh49SpJAtopx/qtC/OpRiEM3miAqToafUlNTwoABZti37yKkBdJbkkN6q3aQ3qqNbJHeqi/I0CMIKePFi6dwdDTA999/jbFjLTBypAmSkxPg7j6Ep6dNs8WTJw/w/PkjTJ7cs9y9xcXFGDRIB0VFRdW+IycnG+HhIejVy56nHz++g5YtddG6dTvIyyuge3d7RERcqvJ+labyMNXS5MdNZWWhq6qMtByh4cJwcHDBr7/uRl3z9OkLGBg44uuvv4eFxViYmIxEQkIyhgxx52lb22l48OAJHj16jp49J1coKx2dQTWWVXZ2DkJCwmFv34un79x5DF3dlmjXrjUUFORhb98dly5FVPuM5opN0E1fgR83k5eBfgs5JGaWvtfFxQG7d/+KuiYx8Snc3Aywe/fXWLDAAh4eJkhLS4Cv7xCeXrrUFi9ePIBA8Ahff11Rtlxda5atvLxsREWFwNxcKFsvXtyBurouNDXbQU5OAaam9oiOrlq2lOTkYagqlC35JrJo2UwZmQWlstWnjwvOn68P2UqEgYEbvv56NywsFsDExAMJCWkYMsSXp21tl+LBgxd49EiAnj2/rkS2XCWQrTyEhETB3t6cp+/ceQFdXXW0a6cJBQU52Nub4tKl6Gqf0VwR6KZfwo+byQP6LUqQWOowhotLH+zefR51DektySG9VTtIb9VGtkhvSRtyH/sDCIL48Lx8GQdTU2t8+eV3yMxMQ2CgN6yt+8PNbRmOH9+Ddes8sXXrWW4AspC/ly+fQ1FRBWlpSWjfvjPOnTuMoCD/Cs8NDo7k+3/+uY727U0hKyvL0+npydDQ0MKNG6FITIyDurpW9R69MqRk5+JRagY697YU53XqZIX79yP4t8nLy6MuiYt7CWtrU3z33ZdIS8uEt3cg+ve3xrJlbtiz5zg8Pdfh7Nmt3ABk3/P8+UuoqCgiKSkNnTu3x+HD5+DvXzGcMDIymO+vX/8HpqbtxWWVnJwOLS0NhIbeQFxcIrS01Gv26JUhIaMQd+Pz0cOwhTjPyqoTIiLu10t5paTEwcjIGjNmfIesrDTs3euNzp37w8VlGS5c2IOdOz2xcuVZpKcn8BDJ5OTnaNZMBZmZSdDT64ywsMP45ZeKshUQIJStmJjr0NMrla2srGSoqmrh3r1QpKXF8eOaPHoi0vNzEfc6A+1VS2XL0NAKT55E8G+Tk6tr2UqBtbURvvtuBtLSsuDtvRf9+3fGsmUu2LPnAjw9d+Ls2ZVISEjn4ZHPnydDRaUZkpIy0bmzHg4fDoO//y8VnhsZGcD316/HwNRUr4xsZUFLSxWhofcQF5fGj2v06JUhIQO4Gy+DHoZCw49hZWWIiIgn/Pvk5eu2yUB6S3JIb9UO0lu1kS3SW9IEGXoEIYUoKanAyWkSP1ZT00BUVDgmTZrP04MHj+GGHsPEpCtiYqKwc6c/N9zatjWCpWVvODpO4FtVJCbGQ1NTu0I+8+Qxzp8/LNF3FhQV4bsrEfi8W2fu5RMhJycHZWVVbkBqaemgLlFRUcKkSU78WENDDeHhUZg/X1h2Y8YM5oYeo2tXE0RFxcDffyc33IyM2qJ3b0tMmODIt6qIj0+EtrbQw1QW5sljHD4subckr7AEnvtTsHy4BvfylS0vVVVlbkTq6GihLmFGW79+wvJRUdFAdHQ4nJyEsmVjM4YbegxDw6549iyKG3XMcGvd2gidOvVG374T+FYVaWnxaN68omwxTx7j5k3JZKuwuAh7YiLgrN+Ze/lEyMrKQVFRFZmZydDUrGvZaoZJk/rxYw0NFYSHR2P+fKGsjRljww09RteuhoiKesaNOma4GRm1Ru/enTBhQl++VUV8fBq0tZtXyGeePMbhwzcl/ta8QsBzvyyWDy/iXj4RcnKyUFVVRHJyJnR0Ksrxh4T0luSQ3qodpLdqI1ukt6QJMvQIQgpRVVWX6Dorqz74++8wKCoq81DOjIxU9OvnhDNnDlbr0WvWTBF5ebnifObBY95AEenpSdDQqNhYL0tJSQn+c/VvdG+jDdt2FRvcubk5UFAo0+KsI9TVVSW6rk8fK4SF/Q1lZUUeypmamgEnp344ePBMtR49RcVmyM0tDR1kHjzmDRSRlJQObW2NGt/PymvRoRQMNFHEUHOlCudzcnKhqCgM76xLlJUlky0Tkz548CAMCgrKSEh4hFevUtGtmxOuXDlYrUevaVNF5OeXypaKihZevSqVLXasqlqzbO17+Dc6q2vDskVF2crPry/ZUpbouj59TBAW9gDKygp49CgBqamv4OTUDQcPXqnWo6eo2BS5ufnifC0tFSQlvRKn2bG2ds3yXVICLDoki4EmJRhqXurNE5GTk18vskV6S3JIb9UO0lu1kS3SW9IEjdEjiE8ACwsbXLwonN3x/PljMDcXjhezsOiNQ4e28PPNm2vir7/Oiz16zKh7exNhZGSG2NgYcdrQ0AzJyQIeAlpQkIebNy+ga9f+4vNsvB0bN1iWnTfvQl1RAePMjCp8b0pKIjc+1dQkMyo+JDY2FjhxQjj5xLFj59Grl3D8U+/eFtiy5RA/r6nZHOfP/yX26DGj7u1NhJmZEWJiYsukDSEQJPMQ0Ly8Aly4cBP9+3cVn2dj7di4wbdZ/Vs6tFSaYK6dWoVziYkp3ABVV694rq4xNrbBjRtC2bp27RiMjYWyxbx3Z85sQadONlBR0cTt2+fFHj1m1L29iWjb1gwCQals6eqaIT1dgNTU5ygszMP9+xdgbFwqW2y8HRs3WJajz+5CtakCBrepKFvp6Ync+JS04fchsbExxokTN/jxsWPX0KuXMT9m3rstW87AxqYTNDVVcP78bbFHjxl1b28izMzaIiZGUCatC4EgHc+fpyIvrxAXLtxH//7CdzDYWDs2bvBtVv/WBFoqJZhrV1zhXGJiOjdAJW38SYveqkxnMUhvkd56X71Vmc5ikN6SDr3V0CCPHkF8AnzxhS98fKbj9On9PCTS13cXzzcz645nz6LRp48DD5FkE6ywhlNN6Ot35PukJAG/j4UOTpvmjYAALxQXF6Fv3xFoU6aRLRDEwsrKVpx+lv4Kxx88hYG6KjxPXeZ5Lp2N0M9Alx+z77CzG4mPga/vF5g+3Qf795/m4ZC7dvny/O7dzRAd/QwODn14eCSbYIUZfDXRsaM+3wsESfw+Vlbe3tPg5RWAoqJijBjRF0ZGbcTXx8YKYGtrVe4Z0S/z8eOfr2DSWh5DNwgb9l/YqWGEpfCfGPuWkSPt8DGYONEXGzdOx+XL+3lIpIeHULY6dOiO+PhoWFo6QENDh0+wovpmkpTq0NUVylZqqoCHVrJQSycnbxw4IJQtS8sR0NIqla2kpFiYmpbKliD7FS4lPIWOkirWRwlla7CuEaxbCmWLfUePHh9LtiZi+vSN2L//Mg+H3LXLg+d3794B0dHxcHCwhI6OBp9gRVOzZk9cx47C3yQQpPKwShZm6e3tBC+vA29kyxJGRqWhvLGxSbC1FYZ1ioh+Cfz4pyxMWpdg6AZh3+8XdkUYYSn07LFvGTmyBz41vfW2zmKQ3iK99SH01ts6i8sb6S2p0VsNDZkSFuNCEESDZvXq9XB2XoyGxJEjQbw33M3Np8ZrP//cHt98s4mPA5SEOXMc4O29EYaGJrX+rt27PfD993PQkAgKOsK9eD4+FXsl38be/nNs2vQNHwcoKQ4Oc7BxozdMTAwluj4lqwjd/MpPAOPXbTBU5Os+PE8SQkKCkJYmgItLzbK1YoU9Zs/ehLZtJZOtVasc8PnnG6GnV3vZunhxNgICStf3awgEBYVAIEiDj49Ljdfa26/Apk2zYWraVuLnOziswsaNn8PERE+i61OygG5+5Se52Td2MJo3U2hUequ2OotBeov0liR6q7Y6i0F6q271VlnWr7+OxYvXQFqg0E2CIN6JUaNmQF29pUTX7twZKnGDiS2YPnz41Hcy8hoqM2aMQsuWkoUKhoYKJ3uRFLZg+tSpwyU28hoDAwfOgKqqZLK1enWoxA0mtmC6nd3UdzLyGiozZgxEy5aSjTMNDV1dq8YSWzB96lS7d2osNXa9VRudxSC9RXpLUr1VG53FIL1Feut9IEOPIIh3gk3pPn68+wcvPbZg+ogRUyFtZeXuPr5Ons0WTJ86dQSkrbwcHT+8bLEF05mhJ32yVfWsr+8DWzCdGXrSBOmt2pUV6a3alRfprdrIFumt+oAMPYIgCIIgCIIgCCmDDD2CIAiCIAiCIAgpgww9giAIgiAIgiAIKYMMPYIgCIIgCIIgCCmDDD2CIAiCIAiCIAgpgww9giAIgiAIgiAIKYMMPYIgCIIgCIIgCClD7mN/AEHUNd27dy+XXrRoESZPnsyPCwsL8eOPP+K3335DYmIitLW1MXz4cMycORNycsLqceLECfj6+pZ7xo0bN975eyR5J0EQBEEQBEG8D9SqJD5pVq1ahTNnzojTL168wLZt2xAbG4tvv/1Wat5JEARBEARBfFpQ6CbxUSkqKuIervpg5cqV3BMn8uZFRESIDS4XFxeEhITwPeP06dOIjIzkxyNGjOD3sfvfF0nfSRAEQRAEQRDvAxl6RL3h5ubGwyjZ/tSpUxgzZgz69OmDR48e4f79+zyk0t7eHr179+bntm/fjoKCAn5vQkICv5dtzCBiPHz4UJz34MEDnnf27FlxXlxcXLXf8/vvv4uPZ8+eDXV1db4XwZ71ofkY76yO0NCjcHGxgrV1U7x48bRW98bGPsS8ecPE6cjIy/D2HoPFi0fhxImgGu//K+4l5hz/A7N/vYCDd2LE+VlZmZgyxUb8t28oHD0aCisrFzRtao2nT1/U6t6HD2MxbNg8cXrbtqMYNmwRunefKfEzQu/lYOC/49F/fTw2nc8Q52dmZsHGZkqDK6/w8KNYuNAKLi5NkZhYO9kSCB7Cz69UtmJiLmPz5jHYtGkUrlypWbZOP4/GqluhWBB+slx+dnYmliyxQWFhwyqro0fDYWW1EE2buuDp08Ra3fvwoQDDhvmJ09u2XcSwYRvQvXtpXnX851wT9PaXg4G3fIVzmZnZsLFZgoKC+umMa+h6KyuvAD6h4XA//gc8fruEo/cel54jvVWBjOxiTNn5EoP+HY8hAQLsuJQpPkd6qzzFJSUIuPMn1kddxrq/L+HUc2GbhkF6qyLFxYDzZlkM3SCHIQFy+P73Jg1eb30syNAj6p2YmBjuHWOhisyjl5+fj1mzZuHSpUvIyMjgDVZ2jhl6X375JUpKStC6dWu0atWK33/nzp1ye8bt27fL7bW0tKCnp1ftd4iMQxUVFWhqavJjtmdpRnR09Af/7R/jndVhb++M4OBIaGvr1vre7dv9MGWKFz8uKirEnj3+WLAgEGvWHEJY2Gm8ePGoynuLioux+a87WGnXAz8M748/nrzAs/RX/JyKihq6dx+Akyf3oSHh7GyPyMhg6Opq1/peP7/t8PKaIk737m2O3buXS3x/YVEJlh1Nxa4ZWvh9oQ6ORrxG9Mt8fk5NTQUDBnTHvn3ljZqPjY2NMwICIqGhUXvZCg72w/DhQtkqLi7EqVP+mDgxEO7uh3D79mkkJVUtWwwTdS0s7GJbIV9JSQ1mZgNw8WJDky0bREYGQFdXo9b3+vkFw8truDjdu7cRdu92lfj+AcYlODav8gaRmpoSBgwww759F9GQ+Fh6CzLAFAtjbB1ph/8MtcW5R88Rk5LOT5Heqry8Fv2fOs5/pYtfPVrj0I3XiIrL46dIb5WniYwM5pj0xGKLfvjaoh9iMlLwMDOFnyO9VZEmTYDdM4pw2qsQp7wKcfWRDMIfyzRovfWxIEOPqHdevXqFcePGITQ0lE904u/vj7y8PDRt2hQ//PADzp8/jyFDhvBrr169isuXL/NjKyurcsYcM/RkZGTKGX2ic5aWljV+R3q68B+0srJyuXxROi0trcZnsJBOkQexqo2Ffn7Id1ZHamoSvvzSBWPHWmDMGHP8+afQQ5icnAB39yE8f9o0Wzx5Utpb+C7k5GQjPDwEvXrZ8/Tjx3fQsqUuWrduB3l5BXTvbo+IiEtV3v8gOR2tVBShq6aMprKysG2nwz18IhwcXPDrr7tRlyQlpcLF5UtYWIyFufkYnD37J89PSEjGkCHuPN/WdhoePHjyXu/Jzs5BSEg47O17ifMsLDpAS0vyRn3k83y01ZSDYUt5NJOXgZO5Es7dzRGfd3FxwO7dv6IuychIwvr1LliwwAJeXuaIiBDKVlpaAnx9h/D8pUtt8eLF+8lWXl42oqJCYG4ulK0XL+5AXV0XmprtICenAFNTe0RHVy1bDENVDTRv2qzSc336uOD8+bqWrQy4uKyHhcUCmJt74ezZCJ6fkJCGIUN8eb6t7VI8eFA7z/DbZGfnISQkCvb25uI8Cws9aGmpSvyMbvolaKVW9XkXlz7Yvfs86pLGordUmsrDVEvYQcf0lq6qMtJyhIYLg/RWeZorNkE3fQV+zPSWfgs5JGYWic+T3iqPkpzQq55fXIS84iIUFJeWFemtijRXelOvC4DsfBnkFtSv3mos0GQsRL2jpqaGhQtZmFJTKCgo8BBMhq2tLXr1EjaG586dKw5jDA8PR//+/bmhx/KYR5B5AZlx17ZtW7GBx/JEHjGRUfg+iIzI+uR937l2rSdMTa3x/ffB3DP68qUwfHXz5pWwtu4PN7dlOH58D9at88TWrVWHiZ45cxBBQf4V8lkvOuOff66jfXtTyMrK8nR6ejI0NLRw40YoEhPjoK6uVW3PeFpuHlooNcOfsQIkvMqGpmIzxGYIPXqMTp2scP9+BP8N8vIVQ8o+BJ6ea2FtbYrg4O/5e+LeGJorV25G//7WWLbMDXv2HIen5zqcPbu1yuccPHgG/v4VQ76Y949x/fo/MDVtLy6rdyHxVRFaqcni9O1sPEsthLaaLGJelv5Xs7LqhIiI+3VaXjt3esLIyBqLFwfz0MeUFKFsHTiwEp0794eLyzJcuLCHX7dyZdWydeXKQfzyS0XZYt4/RkzMdejplcpWVlYyVFW1cO9eKNLS4vhxTR696jA0tMKTJxH8N8i9aVh9aDw9d8La2gjBwYt5+FBcnLBnfuXKA+jfvzOWLXPBnj0X+HVnz1Y99vfgwSvw9/+lQj7z/jGuX4+Bqanee8lWTVhZGSIi4gn/HfLyddNkaCx6qywp2bl4lJqBzr1LOxVJb1VNQkYh7sbno4dhC3Ee6a2K/PefMDx/nYFeWnowaa4lzie9VTkTtskiKk4G47sX8+iE+tRbjYVP+9cTH4V27dpxI4+RmZmJYhZsDfBlBkSUPRZ5wUTGG2sI3Lp1C48fP8bQoUN5Hhvz99dff4nHKUli6LHxcSxE9PXr1+XyRWl2viaYx642Sy18iHdWR1jY7/Dx2cKPWYNfT8+QH0dFhWPSpPn8ePDgMbzBVB2OjhP4VhWJifHQ1KwYwsh6xBnnzx+W6HuZJ49xKvpZuXy2zISysipviGlpCa/50Pz+exi2bPERl5WhoTDUNzw8CvPnT+LHY8YM5oZedUyY4Mi3qoiPZ0toCL0A78tQc2EX5t7wUqNYVF6qqspITk6Hjk5p4+BDEhn5O9zdhbLFDKRWrYSyFR0dDicnoWzZ2Izhhl519O07gW9VkZYWj+bNK8oW8+Qxbt6UTLaqQlZWDoqKqsjMTIamZl3JViS2bHHnx6yRYWgoDDsPD4/G/PlO/HjMGBtu6FXHhAl9+VYV8fFp0NZujrpETk4WqqqKSE7OhI7Oh5Hjxq63CoqK8N2VCHzerTP38okgvVU5eYUl8NyfguXDNbiXr2x5kd4qz3yz3sgtLMCehxHc4GunImwTkN6qnINzivAqF/DcLzT4LNuW1JveaiyQoUfUOyIjT+Tda9KkCTf22JpyIsoei4wfIyMjqKqq8tDPgwcP8nu6dOnCvWAnT57EgQMHxGGQHTt2rPE7OnXqhKioKGRlZSE1NZWPlWN7lmYYGxvX+Axm5Lm7Cxt0VaGjo8NDVD/UO+sGmVr1jDdrpoi8vFxxPusJT0tLEqfT05OgoVH1WDZNRQXeIy4iNScXLRTLh9rl5uZAQUERDY23na41efQUFZshN7c0vOtdYN68l2VCnlj4E8srS05OLhQVhWFSDYm3vdQ1efSaNlVEfn6pbKioaOHVq1LZYseqqrUfJ1mW/PyGKlsytfLoKSo2RW6ucKxmXZKTk98gZau+9RaDjRn/z9W/0b2NtrijqiyktyqW16JDKRhooijuqCoL6a2KNJOTh6m6Nq4nxYkNPQbprcpRbQYMNCnBkVulhl7D1lv1C43RIz4qzZo1g7m5uXg83vXr17khx9aVEyEK52QGoejaP/8UjqdiaWbsMa5du8b3LC1JKJODg4P4eMeOHdxzyPYiROMEPyR1/c7evR1w+LCw7NhEN/HxQk+ZhYUNLl4UGpvnzx+DuXnpeDGGhkZLJCQ8F6dZrzhrHL29iTAyMkNsbOlMmYaGZkhOFuDly+coKMjDzZsX0LVrf/F5Nt7O0dFAnO7YQh2Jr3MQ/+o18ouKcPV5AnrqCb0ejJSURCgqKkNN7f08nNXh4NAb27YdFpfVs2fx/NjGxgInTggHcR87dh69epWOf2K0bKmB588TxGnmzWNG3dubCDMzI8TExEr8XWysnYFBeQ+hhV5TxKUV4mlyAXILSnDmTg7+r3OpoZKYmAJlZUWoq1cz2Oo9sbJywNmzpbKVmCiULWNjG9y4IZSta9eOwdi4vGypqbVEcnKpbDFvHjPq3t5EtG1rBoGgVLZ0dc2Qni5AaupzFBbm4f79CzA2LpUtNt7Oza1UtmoiPT0RCgrKUFauS9mywrZtZ8vIlrDjysbGGCdOCCMAjh27hl69ynfstGyphufPk8Vp5s1jRt3bmwgzs7aIiRFI/F1szIqBgVutfktiYjqUlRWgrl5+XPGHpCHqrbd1loidN+9CXVEB48yMKpwjvVUxsmH1b+nQUmmCuXYVddOnqrcq01mvCvKQ/qaDq6ikGA8ykqHZrNQwJr1VXm8lZ7FwYOFxYRFwKVoGbTXrV281FsijR3x0PD09+Zg8NiEL25fFxsaGj88TwUIymUHIvHlsfF+HDh14LzgzGHNzc2s1Pq9r165wdHTk69oFBwfzTQQLCZXkObUN3fwQ76wOb++N8PObi3HjhONGFixYB11dfXzxhS98fKbj9On9PCTS13dXufvc3JZj5UpXblwFBh5DmzbVN5z19YUe06QkAQ+tZCE406Z5IyDAC8XFRejbdwTatCltCAkEsbCyKp0FUa5JE8zt0QW+F67zaaUHt9eDvnrpBBJswgQ7u5GoSzZu9MbcuX6wtBzH0+vWLYC+vi58fb/A9Ok+2L//NA8r2rXLt9x9y5e7wdV1JW+gHDsWCAODNtW+p2NHfb4XCJLEYZUbNhzC2bPh/NjJaRGcnHrDw0O4nmJsrAC2tuXlQF5WBn6jNTFzdxKKigGXbsowblXqGWeTvYwcaYe65PPPN2LbtrlYuFAoW1OnroO2tj4mTvTFxo3Tcfnyfh4S6eFRXrZcXJZj0yZXblwtXXoM2trVy5aurlC2UlMFPLSShSw5OXnjwAGhbFlajoCWVqlsJSXFwtS0/Aybx5/dw80UoeG+8lYourdsgxHtTHiaTfTSo0ddy9bnmDt3GywtF/L0unVToa+vDV/fiZg+fSP277/Mw4p27fIod9/y5S5wdd3EGyjHji2FgUH13qWOHYWzTgoEqeLwpA0bQnH2rHByKienDXByMoeHxyCejo1Ngq2tabln+J9qgl8jhX2+Nv+Sg7N1MZY4CsPpGWyyl5Eje6AuaYh6622dxWAzAx9/8BQG6qrwPCWcJMylsxH6GQj/DqS3yustNjPwj3++gklreQzdIOyQ+MJODSMslT9pvVWZzsoqyMfeh5EoLinm/xON1DTRr1XpO0lvlddbqa8BrwNy/P9hYTHQy7AE03rXr95qLMiUML86QdQDbP08NrbO2tqaL51Qlrt373LPFlswPCcnh4c7Mu+Wq6truVBPdj97DoMZRTt37iz3bMaWLVvQo0ePcsYYgy3pUHYGTAZbrH3Xrl089PPly5d8CYdhw4bx97JGQFlY+KWvr7DRXxvj7m1q804Rq1evh7PzYjQkjhwJ4r3hbm7CcW7V8fnn9vjmm018IgRJmDPHgTf+DA2FjfPasHu3B77/fg4aEkFBRyAQJMPHp2Zvir3959i06Rs+gYukODjM4YariYlwbFNNpGQVoZtf+Rkf/boNhop8wwhzCQkJQlqaAC4uNcvWihX2mD17E9q2lUy2Vq1y4I0/Pb3ay9bFi7MREFC6BltDICgoBAJBGnx8hB0F1WFvvwKbNs2GqalwEitJcHBYxQ1XE5Pql6sRkZIFdPMrP8nNvrGD0byZQqPSW7XVWQzSW6S3JNFbtdVZDNJbdau3yrJ+/XUsXrwG0gJ59Ih6423jriydO3dGQEBpSFJVMCOxMiOrumdXBzOsmJEoMh7rg4/xzrpg1KgZ+OWX0rDT6ti5M1Ti57KFh4cPn/pORl5DZcaMUdixo+JYq8oIDa1+go63YQsPT506XGIjrzEwcOAMnDsnmWytXi25bLGFh+3spr6TkddQmTFjIHbsOCfRtaGhq2v1bLbw8NSpdu/UWGrseqs2OotBeov0lqR6qzY6i0F6i/TW+0Bj9IhPBuaNY969n3/+uVb3MU8eu0/kzSOEsHGQ48dXPxHNu8AWHh4xYqrUlZW7+/g6eTZbeHjq1PKe6sYOKy9Hxw8vW2zhYWboSZ9sVT3r6/vAFh5mhp40QXqrdmVFeqt25UV6qzayRXqrPiBDjyAIgiAIgiAIQsqg0E1C6nmf8XQMNq7v7bF9BEEQBEEQBNGQIY8eQRAEQRAEQRCElEGGHkEQBEEQBEEQhJRBhh5BEARBEARBEISUQYYeQRAEQRAEQRCElEGGHkEQBEEQBEEQhJRBhh5BEARBEARBEISUQYYeQRAEQRAEQRCElEGGHkEQBEEQBEEQhJRBhh5BfEIsXfoZnJ3NsGCBc7n8kJAjGDnSBC4uVoiOvv1e79i7NxCZmek1XvfNN9PQp09zWFjI4MWLp+L8desWwN5eFz17KmPWrEF4/vwRPgaffbYUZmbOcHZeUC7/yJEQmJiMhJWVC27fjn6vdwQG7kV6emaN102b9g2aN+8DGRkLPH36osL5//xnDz+3atVmfCwCAj6Dp6cZ1q4tL1thYUfg4WGChQut8OzZ+8nWiROBeP26etlKSorFN9/0w+TJapg+XRu7d3+FkpIS8flff/0PnJ1lcODAKnwsPvssAGZmnnB2Xlsu/8iRMJiYeMDKaiFu3372Xu8IDDyB9PTXNV4XG5uEfv2+gZraZGhrT8dXX+3m5VVYWIQlS/agXbvZUFGZhFWrDuBT11lJSQI4O3dBjx6K6NtXEytWuCI/Pw+FhYUICFgCB4d26NVLBZs3f0zZajh6SyBIQpcuzlBU7AFNzb5wdV2BvLx8REbeR/fuE6Gk1BNdu47H9et38CnrrLIUFRXhyy+tuY5KTHyKJ08i8dVX3TFhghIWLeqKmJjr+Fg0JL3FkJFxLrfdvx+HtLQsDBvmh+bNp/B9WloWPnXkPvYHEARRPyQnJyA8PAQXLiRUOHf48HYsXhyIvn0d3/s9P/0UiEGDRkNNTb3a62RkZNCjx0BcuPBrufz8/FzMn78Gyspq8Pf3gL//fGzefAr1SUJCMkJCwpGQcKHCue3bDyMwcDEcHfu+93sCA3/C6NGDoK6uVmNZDRzYA7/+WvF74uIS4Oe3HR+TtLQEREWF4McfK8rWuXPb4eoaCGvr95ct1mjq1Ws0lJWrlq3s7Ezo65tj1Kiv8PjxLRw6tBodO/aEre14JCfH4fBhP3xMEhLSEBIShYSEHyuc2779HAIDXeHoaP3e72ENptGje0FdXbna6zIzs2Furo+vvhqFW7ceY/XqQ+jZsyM3ADduPIl166ZCV1cTqan132BqaDqrSRNZDB/+GYyNLfDw4T8ICFgMc/NeeP36FX7+eSMWLFgHLS1dZGam4mPQ0PSWrGwTfPbZcFhYGOOffx5i8eIA9Opljp9/PsXP7dnjh+++2w1Pz7UIC9uHT1VnleXUqU3ljMudO7243Hl57cGxY99h505PrFsXhk9db4kICHCFlZUhP27XTgsLF+7CX3/FYNs2d3h47IC3915s2zYXnzLk0SMIKePCheMYM8ac9zx/++1c3kMYGOiNzz8fhIyMVN4DLuodj4y8ytMREVe4UVW2d/zWrSs8zbbx47uKvW45OdlYtWo2Jk3qgXHjLHHy5M88//ffD/NrExPjMW+eEz+OirpW5XeuWfM/3rh6m+XLt2L06Jn4v/8bCwsLGyQlxddRSQHHj1+AufkY3us8d+63vKy8vVmj73Okpmbw3m9Rz/jVq5E8feVKBDw8/Mv1jF+5coun2cZ6qEVet+zsHMyevQo9ekyCpeU4/PzzSZ5/+PDv/Nr4+EQ4Oc3jx9euRVX5nf/73xresKqMBQvWw9W1YjnWBX/9dRxeXubw9OyCrVuFsrVnjzdWrBiErKxU3gMu6h2/f/8qT9+7dwU7dniU6x2/e/cKT7ON9VKznmtGXl42fvhhNr7+ugcWLrTEpUtC2bp69TC/Ni0tHt9+68SPo6Mrly19/S6YM2czevUahZEjF/G81FShDO3axbzFrvVSVseP/wVzcy906eKJuXO3vpGtPRg0aAU3mljvt6hn/OrV+zx95co93jgp2zN+5cpdnmZb166L8PRpIs/Pzs7D7Nk/oEePr2FpuRA//3yJ5x8+fJVfGx+fBienb/nxtWtVe3C6dNHH5s1zMGpULyxaNJLnxcenYs+ePzBlSn94eg7HuHF94ObmgE9dZ7VooY1Zs7zRs+cgdO1qy/OUlFRx4sQeODlNwZQpnnBwGIdx49xQlzQWvaWt3QLe3rMwaBDraOnK81RVlfD6dQ7atGkFGxsLvldQaPpJ6ywRTE8dOuSLoUPnifPy8l5DU7MNjI1t+F5eXgF1SWPRWyIsLQ0wYIAZ7Oy6QElJAWfPRmDkyB6YOLEfRozowdOfOjIlZWNaCIJokKxevR7OzotrvI41aJyc2mPv3jDo6urD3X0IRo92hZPTJN7omTXLDmfOlIZJinB1tcPcuewfu504b/78kXBymoyhQyfyHmsZmSZQUlLGxo3LoKamgRkzvkJ2dhZvHP300zWoq7fg9zk6GiAo6A+0aWPA0zdvXsbatfMrvPOHH04hLOx3LF8+E6dPPxFfL4KFbLJGGWtYubn5SFxWu3d74Pvv59R4HWvMtG/vhLCwvdDX18WQIe7cYJo0yYk3eOzsZuHp0zMV7rOzc8WqVXNhZ9dDnDdy5HxMnuyEiROH4tWr12jSRAbKykpYtmwjNDTU8NVXM5CVlf2mYfQTWrQQ9u4aGDjijz+CYGDQhqcvX76J+fPLh8UwTp36Ab//HoaZM5fjyZPT4utPn76MOXO+xb17x6CiYoOVK92xatUXNf72lKwidPMrHwLq120wVKppRLAGjbt7e6xdGwYtLX2sXj2EG039+k3ijR4fHzts315Rtlj+xImr0KVLqWz9618j0a/fZPTrNxE5OULZatZMGfv2LYOKigZGj/4KOTlZWLTICuvWXYOamlC23NwM4Of3B7S1hbJy9+5l7NhRUbaWLz8FTU1dHDmyDvv3r8DGjXcRHx+NrVvn4L//vYdJk1QwYcJK/l214eLF2QgIGFbjdawx0769O8LC1kJfXwtDhqyGq6s9Jk3qxxs8dnY+ePq0oheW5a9aNZE3WkSMHPkvTJ7cjzdcXr3KeSNbzbBs2T5oaKjgq69GIysrB1ZWi3Dt2jq0aCH0shgYuOGPP/xgYKDN05cv38X8+TsqvPPUqeXcY8dYt+4IVqzYj7t3N6Jr1y9hZtYW9+7Fce/Lhg2z8NlnpX/DqkjJArr5yZfL2zd2MJo3U5AKnaWtrcvDzRkuLu7w8dnMQ9CNjMzw5Mk97n1ZsmQD9/zVBmnVW7q62jysnOHu7oLNm31w6dJNDB/uwZ/dvLkqrlzZjS5dOn5wvdXYdNauXQu5MWdgYIH//ncmtm17gsTEZ1izZjhyc7OgpNQc//rXFd6ZVRukVW+1aTML8vJyaNpUDpMm9cWWLe5QUpoIL69hvKPK2bkXdu06j/z84FqV1/r117F48RpICxS6SRBSxNOnD9CqlR709IShDAMHjsLt29d4o6m2dO3aF0FB/hAIYtGnjwNMTKx4/p9/nkFubjZOnhSG2hQU5CMu7rG40fQ23br1Q3BwZK3ezXrxPT1HokuXnpg5s2YD91148OAp9PRawdBQj6dHjRqIa9du8wZTbenbtyv8/YMQGyuAg0MfWFmZ8PwzZ/5EdnYu9u0T9ojn5xfg8eM4cYPpbfr164bISMn+KbFxQayHfvXqeSgoKOR5ubn5KCgogLx8+Yb2h+DFiwdo0UIPrVoJZatnz1G8h5o1mmqLqWlfHDnij+TkWFhZOcDQUChbERFneOPs4kWhbBUW5uPly8fiRtPbdO7cDwEBlcvW9eu/4eeffeDmthna2vrw9XXApEmrUVRUIA4RLiwsgJzchy+rBw9eQE+vBQwNW/H0qFE9ee80azDVlr59TeHvfwSxsclwcLAShymdORPBG2b79l3k6fz8Qjx+/FLcYHqbfv06IzIyoMr3/Pbbdfj4/IzNm91gZKSD3NwCxMWl4ODBr/Ddd8cwd+423miTk5PFp66zmFF68+YlbNjgjX79nJCXl4uXL+Owfv1B7N79Hfz85sLRcSLk5D58E6sx6i1mlDLjztt7A5yc+uHw4XM8nNPX9wusXLkZS5YE4uTJH/Ap66yoqPO4c+cP/PvfN3H9+nGexwzK0NBd3PCbONEXBw6sxN69S+DjI/y7fOp667//nY0uXdpxj+Ly5T+je/cOkJeX5cbfX3+tx9atZ7kR+KlDJUAQRKW4ui7moZXh4efg5TUKy5dvE4+H8ff/CZ07SxaPX13veGVkZ7/GvHnD0KyZEjZu/BXy8nUX1vOhWLzYlYdWnjsXjlGjvLBt23LxWJiffvKHtXVniZ5TXc/427DecNb4Yl6+mTOFeevW7YKVVSfeQ9+QYd7pnj1H4++/z8HffxTc3beJx8MsXPgTjIwkk62qesdZb/x//jMZkyZ9CweH2XwyBNb4Yr3kbGMcPbqON9ZYD31DZvFiZ4we3RPnzv2NUaP8+dgT0ViYn35aCGtrI4meU13P+OPHCRg//t/49ttJmD1bGKLZurU6bG1NMGRIVzx58hKhoVFITX0FbW3JxhpJq85iHj1LSxu+/e9/33EjsmXL1rCysoWt7RC8ePEE166F8s4qFur5qest5tGzsbHk23ff/Y8bkcHB5/D9919i8GAbxMQ8w5dffo+GTl3rLBsbZ2RkJGL27LbiPBYOyjyHM2d+D0vLwRAIYvDjj1+iMVAfesvDQ9i5wTyJbGwfCxtl0QkvX6ZDX18bAkEadHQ08KlDhh5BSBEGBp14zzILedLRaYc//jiOUaPeWAG15NmzGBgYGPPt3r1bePYsmjeaWE/5wYObsXLldjRp0gR//x3Gx9KxCUMYKirNkZGRIg6Dqqp3/Lff9vF7GefPH+PXs0baokVjeQiUr+8u3L17E02bNuONqg9Np04GiIt7ycOd2rXTwfHjf2DmzFHv9CzWWDE2NuDbrVv3EB39jDeYWC/55s0HsX37Sl5WYWF/83EporJq3lwFKSkZ4hCoqnrG9+37jd/LOHbsPL9++PD+uHAhSHzNwIGzMH36SD4epi5o06YTUlLieMhTy5bt+NgXe/t3k634+Bi0aWPMNzZhCgurZI0m1lN+5sxmzJ0rlK3798PQqVOpbCkrN8erVyniMKjKesfj4u5jyRIb3gPP7mW95KxX/9tvSyeoWL58IAYOnA5z88rHPb4vnTq14d4wFu7Url1LPu5l5kz7d3pWTEw8jI3ZGJ02fLKU6Oh43mBiveSbN5/B9u1z38jWfdjYdCojW8pISXklDoGqqmeczVQ3fPga3gPP7v/jjzv8nsGDLf6/vfsAq6r+/wD+ZipTHKAgCoQgiCAhKuIItVBx/Rw4f440UQxFrdQMc/8dDcdPM1eaWplarjTJlWmCuYjSFDURB8geyh7/5/u9DFFAhiBe3q/nOc+999x7D4cPx4/nc77jQFx937//HHbuPINGjerC0LAOanLOCgg4KvOWlVVLORlLXFw0zMys4eLypiz4xMRSR47slIVfvXqGqAyvUt46ejRA5i7RLVNMxhIdHQdrazOYm5tgy5b9aNKkETZv3it/p5qcswQxUZSd3Rvy+aVLR+SFKDEBi5gd+PjxLahfvwmOHdssf6fK8irlLdH6uGHDL7KL6W+/XZHfES16osfBN9/8hp07T+Onny7gv/9VxLQmY6FHpES0tLTx8ccbMHlyHzlFupNTR3TvPrhc2xInRmfP+kNNTR3Gxmbo12+MXO/lNQeffDJNjp/Lzs6S761deyg/UY8Y4SunRBfdosSseHZ2zkVuf/bskfnPxfbE+BxR6ImfKYiCTxDrixqjU1Ha2lrYsOFj9OkzWcaqY0cnDB7cvVzbEidF/v5n5X8yZmbGGDNGceI1Z44Xpk37RE5okJWVLd8TXZTyYuXrO0JOhy66RIkZ8Zyd7Yrc/siRs/Ofi+2JsTniSvyT420EcQIlJkCoDLVqacuTmcWLFceWKKRcXct3bIkTo8uXFceWGDvTtavi2Bo8eI4cpyImNRDHlnhPdFPKi1evXr5ySnQ9vfoYN24lmjV79tgKCQlEcnKCvPIuFqGo8XjixMvAoHJaXMSkAOJEpk+fxbnHli0GD3Yt17bESZGYUEBxbBlizBhFcTpnzmA5w5yY0EBxbBni0CG/J46tXnI69Pr19bBy5Th5ElSUwMAQJCQkyyvvYhHmzh2C5ctHIyoqESNHrpJXxbdv983fdk3NWWL83d69mxEefgc6Onpy0pUhQ7zx6FEiYmOjZE5r0MAY//d/2yslVq9a3hJjO0Uhd+dOOPT0dODlNQje3kPQpk1LeHsvwuDBH8DGxhybNs2r0TlLaNDAVC5C3kQvYrbgd9/dJGeN/PTTwTA1tZGvK8urlLdEl89PP92HO3ei0KCBPmbPHojRo7vI7qaiqJww4UvZI2Hu3CGo6TgZC5ESTcZCpZ/UoCYrz2QsVPpJDWqysk7GQgrMW6U5tpi3yoN5CzV6MhbeXoGIiIiIiEjJsNAjIiIiIiJSMiz0iIiIiIiIlAwLPSIiIiIiIiXDQo+IiIiIiEjJ8PYKryjzWYcKvZ7TuwXGdbSQz1ceC8HvN6Px570EpGdmy3X+UzujeSO9/M/vvnAXH+wJLrSN0KXlm03u6oNE7Dh3BxdCYxGekArkAK8Z6uDtDhb4z+uK++wQEREREVHVYaGnhDafuY2k1Mwq+3m/hkTi23NhhdaJInPq90G4G5uMyd2sqmxfiIiIiIiIhV6lyMrOQXZODjTUKr9n7CeDHODp3KTQusHOTWBnoo+Ld+LwzVMFWB7xHbEU1bJXVipQQW8HY7zT6TXYNNLDmRvR8P7mIjKycrD+t3/h7WYJ9SqIBRERERERKbBFr4KGrA/AuduxaGdRD0PbNsHq4zcRFpuMAz4dkJMjulHewIU7sUhOy4JpXS30dTTBJLdm0FRXxf34FHRYekJuZ+UQR9nN8XpEErqv/E2uOzSlI+xM6uDAnw8w5bvLct1vH3RB0/raJe6T6MYp3IlJRlUY1d4MOrUKDqU3WzTEG9aGOPZPJB6lZSL2cTqM9GtXyb4QEREREREnY3lh/glPxPRdf+J29GPZopeWmY2B687i2D8PEZ+cgfSsbPwb/VgWfl7bLyAnJweNDbRgUkdRAAXdjc99jMvf5uUwxbpLdxTrGurXem6R9zI8WeTlEb+/IApaA23Nl7BXREREREQ1F1v0XpDE1EzZsjX9LWvZiuW17aIsdkSh89XoNrBvXAdz9v8tW+d+vR6F4/9EypYvZ/N6ct3lsLj84k5FBbI1UDz/r4sZLucWgc5m9VAVAm7FYNjGwBI/I4rU32d1LfK9S2FxcjIY4T+OJjIGRERERERUdXgG/oLU0dLAR71sZetVfZ1auBaRKNd3aW6IjlYNUEdbA++5W+d//vSNKPnYxryufPwnPAlpmVmyZc+ivg4sGujg8t04ue6fB4ptOed+tjq7GZkki9zsHMjf4aNeim6kRERERERUddii94KIoqaWupp8npCSIQsdwbiOVv5nGuV20xRikzPko2jRE0TXzj9uxyLkYVL+LQn2Xr6Pszdj5HtCm9zPVrb2lvXLdauFf6MeYfjGc4h+lAbjOrWxfVxbWQBTxUXEhGHdVh+GshRSIuPxvs86xqoEadAEdN8qtO7I2enQRDrjVoKsh4l4f/wBxqikY0tFE6jXp9C6LTs/RC0eW8xbFcS8VT7MW2WTpaY4l1cWLPRekFpPdE8UxY2qCmSxFyHuK5fryef1tBUFUPOGetCvrS67fn59NlR+5/UmBhD9N3+8dB9f/X5bfk63ljpsjfVRXbtu3ol5LIu8yCRFkffdeBeY1q1+4wlfVY0aG6H/jP4vezdeCVt91uHTCd4vezeqtZjULBz84X6hdT0WvgVd3Ze2S6+EU+MP4NNefV/2blRrMRnAwYuF1709fxTq6CrXydOLxrz1fMxb5cO8VTbLz5+HMmHXzUqgpakGp6aKbpYnr0fi7M1o2cq34mhI/mc6Whkq/gCqKnAyU3z2xLVI+fh607qKYg/Amdyxbq83NYCaqB5LISE5Q850mZqRlb8uMVWx7nHai7+/nrhX3rANgYhITM0v8swb6Lzwn0NERERERKXDFr1K8qGHDYZtPCcnZBm+6Vyh9zpZNcCbtkb5r0WXTDFBi2jNq62hKu9Fp6KiAi0NNaTkFmtlmYjFY/VpeeuGJ3l+GSAfBzqZ4rPBrV5o1809F+/hQW5rZXhCKtw+/bXQ+6LwE9skIiIiIqKqwRa9StLarB72TGyPbjZGsmumhpoKzOtrY0rXZtg02lkWcnmcc1v0BDE7p7i5uGi9czCtk78+b9IWIiIiIiKi52GLXgV9P6F9se85mBpg85g2z91Gu9eKbkEradslKe62B5Vl2lvWciEiIiIiouqBLXqvuA/2BMN81iFsPqOYtKW0dl+4K78nvk9ERERERMqFhR4REREREZGSYdfNV1R57nP3JE/nJnIhIiIiIiLlwxY9IiIiIiIiJcNCj4iIiIiISMmw0CMiIiIiIlIyHKNHRC/E3vV7cfrAacQ9jMOWC1tK/Oyj5Gws/TYK0fFZUFdTQbfWOujfWb/G/CXW792LA6dP42FcHC5sKTlWQkJaNiadiUL44yxoqKpgkKUOxtvWnHidWn8KQQeCkPQwCX4X/Er8bHIysPVbNcTFq0BdDWjbOhtdOmejplh/6hQOBAXhYVISLviVHCshIROYFKKG8HQVaKgAgwyzMd6k5sSLeav0mLcqJ2cJzFvMW5WFLXpEVC5hN8Pwbq9381/bt7fHnK1zSvdlFWDEWwb48n0TfO7TCEcvPMaNe2nyrUeJjzDCZQQyMjKU5i9zMywMvd4tiFV7e3tsnVPKWAkqwHQHA5zoa4L9PRth163HCI5RxCvx0SO4jFCueIXfDMeiXovyX1u2t8TYrWNL92UVoOdb2fjo/UxM98nEuQuqCLunIt9KTkzGTJeZyMzIhLK4GR6OXosKYtXe0hJbx5YyVrmmN8nGCcdM7LfPxK4oVQQ/UsQrMTkZLjNnIiNTeeLFvFV6zFvlz1tlylkC8xbzViVhoUdE5bJh0QaM8B2R/7qZQzPUNaxbqu/qaqnC1qyWfK6poQKT+uqIS8xSvKevC+c3nHFoxyGl+css2rABviMKYuXQrBkM65YuVkIdTVW0NlTEq7aaCsz01BGZooiXvq4u3nB2xo5DyhOv3Yt2o7dv7/zXpg6m0DPUK9V3tbUAC7Mc+VxDA2hQPweJibnv6WvD7g07nNpxCspi0e7d8O1dECsHU1MY6pUuVkIddaC1niJetVUBs9o5iMy9ZqCvrY037Oyw45TyxIt5q/SYt8qft8qSswTmLeatysJCj0jJ3A+9jx7mPfDZB59hoMNA9LXpi+iIaEzsPlG+HtVhFG5fv427t+5ieNvhhb6bnZ2NrsZdkZWlKCKKk5KcgsBjgWjXrV2F9zcmIRO3HqSjhUXt/HXunu7Yv3U/Klvo/fsw79EDH3z2GRwGDoRN376IiI5G94kT5esOo0bh+u3buHX3LtoOfzZWxl2fH6vklBQcCwxEt3YVj5UQkZyJq7HpaGNUEC9Pd3ds3V/58YoMjYSXuRe2frAVUx2mwsfGB3ERcZjffb58/WGHD3H/+n2E3wrHB20/eCZeY43HPjdeaclpCD4WDPtu9hXe3/gE4N4DFbxmoShkBFdPV5zYegKVLTQyEuZeXvhg61Y4TJ0KGx8fRMTFofv8+fJ1hw8/xPX793ErPBxtP3g2VsZjnx+r5LQ0HAsORjf7isdKiEgHrj5WQZvcwk/wdHXF1hOVHy/mrdJj3iob5q0yHFvMW0qHY/SIlNDDew9h62SL9z55D4lxiVg5ayWcOjvB6yMvHNh2AMumLMOX/l/KAlB0+Xt49yG0dLUQFxWH11q8hqN7jmLzks3PbHd30G75eOX8Fbxm+xrU1NQqtJ8ZmTn45LsYvNO7rmzly9PcsTmuXb4m901DNMtUonsPH8LJ1hafvPce4hITMWvlSnR2csJHXl7YduAApixbBv8vv5QFoNifuw8fQldLC1FxcWjx2mvYc/Qolmx+NlZBuxWxOn/lCmxfq3ishLSsHEw5E4M5revKVr48js2b4/K1qolXzL0YWDpZYswnY/Ao7hG2z9qOFp1bwPMjT5zcdhKbpmzCXP+5iI+Il10ko+9Go7ZubSRGJcK0hSkC9gTghyU/PLPdFUEr5OON8zdgamta4XiJ3obbvlND/95Z8mp5HgtHC9y+fFvum7pG5f4XeC8mBk6WlvhkzBjEPXqEWdu3o3OLFvjI0xPbTp7ElE2b4D93LiLi42X3yLvR0dCtXRtRiYloYWqKPQEBWPLDs7EKWqGI1fkbN2BrWvFYCWnZwJQbaphjliVb+fI4Wljg8u3bcv801Cs3Xsxbpce8VTbMW2U4tpi3lAoLPSIlpK2rDY9hHvK5fl19BAcGY9jkYfL1mwPelIWeYPO6DW4E38CmJZtk4dbEsglatW+FHkN6yKU4kQ8iUc+oXoX2MScnB5/vioGzjRY62GsXek9dXR06ejqIj46HobEhKpOutjaGeShiVVdfH4HBwZg8TBGrAW++KQs94XUbGwTfuIElmzbJws2ySRO0b9UKQ3r0kEtxHkRGwqhexWKVF6/pZ2PQpbEWejZ9Nl56OjqIjo+HsWHlxksUbZ2GdZLPdevqIiQwBB6TFfFzGeAiCz3B4nUL3Am+I4s6Ubg1smyE5u2bo+OQjnIpTtyDONQxqlOhfczJAXbsUkMLmxy0si9onRLU1NWgpaeFxOhE1DOu+N+lJKJoG9ZJEau6uroIDAnB5NxjbYCLiyz0hNctLBB8544s6kThZtmoEdo3b44hHTvKpTgP4uJgVKdiscqL1/SbauhikIOe9QvHS11NDXpaWohOTITxCziOS8K8VXrMW2XDvFWGY4t5S6mw0CNSQnoGpRsb4OjqiD8D/oSWjpbsypkQm4BOHp1w5PsjJbbo1daqjbRUxWQgpSG6Ya6btw5HQo/kr9v0UzwMdFUxyK3o2SNTU1JRS0sxLq0yGZRyPJOroyMC/vwTOlpasitnbEICPDp1wvdHjpTYoqdVuzZS00ofK9EFc966dQg9UhArYcHFeBhqqcLbruh4paSmQqtW5cdLx0CnVJ+zcbXB9YDrqKVTCxG3IpAUm4TWHq1x5vszJbboaWppIj01vdT7I7ph7py3ExtCN+Sv2/uTKvR0c/CmW9GzR6anpFfNsaVTuli52tgg4Pp16NSqhVsREYhNSoJH69b4/syZElv0tDQ1kZpe+liJLpjzdu5E6IaCWAkL7qjCUDMH3o2LjldKenqVHFvVKW8VlbME5q2iMW+VPm8VlbME5q1XM29Vdyz0iGoABxcHnDp4ClYtrXBi3wnYt1OM6XFo74DF3osx1Gcobl25hXPHz8FnoQ/q1KtTYouepZ0lwm6EFVq3a9UuBPoHyufTPaajvUd7ePp4ytfhYeFw7OCY/9k7D9Nx4PckmDfSwJRV4XKdp5s+OrVSnBjHRMbIkzh9g6q/hYCLgwMOnjqFllZW2HfiBNrljn9q7+AA78WL4TN0KK7cuoXj585hoY8P6tWpU2KLnp2lJW6EFY7Vql274B+oiJXH9OnwaN8ePp6KWIWFh6ODY0GshJD4dGy5ngQbAw30PKyI16QW+uhjrohXZEyMLEAN9Ks+XtYu1rhw8ALMWprh3L5zsG5nLdeL1rv13uvh4eOBsCthCD4ejOELh0Ovnl6JLXpN7Jog/Ibid8xzfNVx/O3/t3y+ymMV7D3s0dWnq3wdFRYF2w62+Z8Nfwj89rsajBvlYPkqRffWN92y4NRK0VIVHxkvi8/SFqwvkou1NQ5euICWZmbYd+4c2lkrYiVa77zXr4ePhweuhIXheHAwFg4fjnp6eiW26Nk1aYIb4YVjter4cfj/rYiVx6pV8LC3h09XRazCoqLQwbYgVkJIMrAlQg022jnoGayI1ySTLPRpoIhXZHy8LEBLW7QqS956OmcJzFvMW6XNW2XJWQLzlvLkreqGhR5RDTBp/iT4jfbDz9/9LLtEzv9qvlxv52yHOyF34OruKrtIiglWxMnS85hZmcnHqPCo/K6Vg30Hy6UoF05dwOw1swu+31ATB5c2LXb7Yj/c+rrhZZg/aRJG+/nhu59/lt0hv5qviJWznR1C7tyBu6ur7B4pJlgRRd7zWJkpYhUeFZXfrdJ38GC5FOXUhQtYM7sgVoK1gSZCRxQfL7Evfd1eTryGzh+K1aNX4/R3p2WXSJ+vfOT6Zs7N8CDkAVq5t0Jd47pyghVR5D2PiZWJfIwNj83vWtnNt5tcinLl1BWMXzM+/7VxQ2Dl0uJvNSH2o03fNngZ5g8ditGrV+O706dld8ivfBSxcm7WDCEPHsC9VSsY160rJ1gRRd7zWJkoYhUeG5vfrdK3Wze5FOXUlStYM74gVoK1NhDqUny8xL70bdOmxuWtp3OW/D7zFvNWKfNWWXKWwLylPHmrulHJEQM/iKhaW7B8AfrP6I/q5MfNPyI6PBpefl4vfNsT3Cdg1upZsLCxKPN3t/qsw2cTvFGdbP7xR4RHR8PP68XHSnCfMAGrZ82CjUXp4hWTmoXWP9wvtG6RXwZ0dVEtHNt8DHHhcfD0U7Ryvkjz3OfhndXvwNTGtMzfPTX+AFb06ovqZPOxYwiPi4Nfbovwi+Y+bx5Wv/MObExLF6+YDKD1xcITAu3wa4w6uhWfMOZFYN4qPeatsmHeenXz1pOWnz+PGYsXQ1nw9gpEVC79xvSDQQODFx49ccP03iN7l6vIq67G9OuHBgYvPlZ5N0wf2bt3qYu8V0GXMV2g16D096AqLXHDdLeRbuUq8qqrMV26oEEZ7ptXFuKG6SPd3Mp1slRdMW+VHvNW2TBvleHYYt6qMiz0iKhcxJTugycW3f2wIsQN0/uM7ANli9XEYrpqVpS4YfrIPsoXrx4Tix9rVV7ihumi0FO6Y6uEMaIVIW6YLgo9ZcK8VbZYMW+VLV7MW2U4tpi3qgQLPSIiIiIiIiXDQo+IiIiIiEjJsNAjIiIiIiJSMiz0iIiIiIiIlAwLPSIiIiIiIiXDQo+IiIiIiEjJsNAjIiIiIiJSMuoveweIKpuzs3Oh19OnT8fw4cPl88zMTGzZsgU//fQTIiMjYWRkhN69e+Ptt9+Gurrin8fBgwcxf/78Qtu4cOFCufdnw4YN+OOPP3D16lWkp6fLdTt37kSzZs3KvU0iIiIioiex0KMabd68eThy5Ej+6/v372P9+vUICwvDwoULK+Vnfvvtt3j06FGlbJuIiIiISGChRy9VVlYWcnJy8lvPKtPcuXPRp0+f/NeXL1/OL/I8PT0xYcIEWeTt3r0bP//8MwYOHAhHR0f5HbEU1bJXHn379kXz5s0RHByMH374Acoi6HQQdq7YieysbHTq2wl9xhXEuih//JOCzYfikJ0NvOmsgyFd66CmWL93Lw6cPo2HcXG4sGVLqb5z/F4KFl2KQ1YOMNhSBz4ta068bpy+gaMrjspjy7GvIzqO61ji538+qopzF1QRn6CClUszUJOsP3UKB4KC8DApCRf8/J77+c/vqmJ3lCrC01UQ6lKzYlXWvPUoORtLv41CdHwW1NVU0K21Dvp31kdNUda8lZCWjUlnohD+OAsaqioYZKmD8bY1J15lyVvi/8FVX6ohI0MFOdmAvV02PNyzUVOUNW9l5wADr6ghNVtFPnevl433mtSceJUFx+hRlfHy8pLdKMXj4cOHMWDAALi6uuLWrVu4du2a7FLZrVs3tG/fXr4nujhmZChOPCIiIuR3xSKKMOHmzZv5665fvy7X+fv756+7d+9eifvzyy+/5D8fP348DAwM5GMesa3KIH7PXr16oV69enjZju89Dk9HTzhpOuF+6P0yfTfsZhje7fWufJ6VmYVtS7Zh6sqpWLxrMQJ+DsD9W8VvLysrB1/sjcXcMYZYO80Yv15+jDsPFd1YHyU+wgiXEfl/++pi7/HjcPT0hKaTE0Lvly1WN8PC0OtdRayE9vb22DpnTqm/n5mdg4/+iMVXbob4pbcx9t5+jJB4RbwSHz2Cy4jqF6/AvYGY5jgNnpqeiAyNLNN3w2+GY1GvRfJ5dmY2Di85jKErh2Liron46+e/EHUrqsTv21jnYNq7mc+sT05MxkyXmcjMePa9l2lvYCAcp02DpqcnQiPLFqub4eHotUgRK6G9pSW2jh1b6u+/YZCDfS2LjkdicjJcZs5ERmb1itfLyltQAUa8ZYAv3zfB5z6NcPTCY9y4lybfYt4qOl7THQxwoq8J9vdshF23HiM4RhEv5q3CVFWBCWOyMMM3Ex/4ZuLGLRXc/FdFvse89SxVFWCrTRZ+dsjEYYdMnE1QQWCiSrXOWy8LCz2qcjdu3JCta6J7pGjRE+PUxo0bh99++w0JCQnyhFW8Jwq99957T7b4NWrUCA0bNpTf//vvvws9Cn/99VehR0NDQ5iampa4H3nFoa6ubn7RJR7FayEkJATKrlv/btgdtBtGJkZl/u6GRRswwneEfP7v3/+igUkDNGraCBq1NODczRmXf7tc7Hev301Hw3rqMGmgAU0NFXSw18YfV1Pke7r6unB+wxmHdhxCddK/WzcE7d4NE6Oyx2rRhg3wHaGIleDQrBkM69Yt9feDotPRRFcdFvoaqK2mAo+m2jh6TxEvfV1dvOHsjB2Hqle8XPq7YEXQCtQ1Kf3vmWf3ot3o7dtbPr//930YmBigXtN6UK+lDttutgj5reR/mxZmOahTRMOBtr427N6ww6kdp1Cd9HdxQdCKFTApwzGRZ9Hu3fDtrYiV4GBqCkM9vVJ/v7VeDhpqFv2evrY23rCzw45T1SteLytv6Wqpwtaslnwu8pZJfXXEJWYp3mPeekYdTVW0NlTES+QtMz11RKYo4sW89SxtbcVjegaQlq6CvGt3zFtFq5PbESwlG0jOVkFqdvXOWy8LCz2qcklJSRg0aBCOHz8uu0MuWbIEaWlp0NTUxNq1a3HixAl0795dfvbs2bM4ffq0fC66UT5ZzIlCT0VFpVDRl/deq1atnrsf8fHx8lFHR6fQ+rzXcXFxz92GmJQlrwWxuOXJ7qKVLTYqFu95voeBDgMxwH4Afvf/Xa6PjojGxO4T5fpRHUbh9vXbFfo5KckpCDwWiHbd2snX8dHxqGtYFxeOX8Dhrw/DwNAAcZHFxy8uKQv19dXw+1/J+OFUIurpqyEm94RJcPd0x/6t+1GZomJj4fnee3AYOBD2AwbA/3dFrCKio9F94kS5vsOoUbh+u2KxSk5JwbHAQHRrp4hVeUSmZqGhthp+DkvGl1cSYaSlhoe5J0yCp7s7tu6v3HglRCVguedyTHWYCl97X1z2V5wQx0XEYX73+XL9hx0+xP3rZWtheVpachqCjwXDvpu9fP0o+hH0DPXwz/F/cPbrs/J5UmRSubfv6umKE1tPoDJFJSTAc/lyOEydCntfX/hfVsQqIi4O3efPl+s7fPghrpexZfhpyWlpOBYcjG72ilhVBk9XV2w9UbnxelXy1pNiEjJx60E6WljUzl/HvFW8iORMXI1NRxujgngxbz3rf+vV8PEidViaZ8ueCXmYt4o25Ioa2lxUR1u9bLxRJ6dK89argmP0qMrp6+tjmuimpKmJWrVqyS6YQocOHdAu92TY29s7v+tkYGAgOnfuLAs9sU60CIpWQFHcNWnSJL/AE+vyWuHyisKKyCsiXyVLpyyFrZMtPtv9mWwZfXjvoVz/xdwv4NTZCV4feeHAtgNYNmUZvvT/stjtHPn+CDYv2fzMenEVXbhy/gpes30Nampqhd4XV8SFE3tKl2BFS55wOLDwiXtzx+a4dvma/B00NDRQGaYsXQonW1vs/kwRq3sPFbGa+8UX6OzkhI+8vLDtwAFMWbYM/l8WH6vvjxzBks3Pxkq0/gnnr1yB7WvPxqo8ejZVxGt7SOF4OTZvjsvXKjdem6ZsgqWTJWbsniG7Psbci5Hrd87diRadW8DzI0+c3HZSfm6u/9xit3Pm+zP4YcmzY1NF659w4/wNmNqaPhMv0ZInXNxzsUK/h4WjBW5fvi1/B3WNyvkvcMqmTXCytMTuGTNk96F7MYpYzd25E51btMBHnp7YdvKk/Jz/3OJj9f2ZM1hSxDhe0fonnL9xA7amz8bqRXK0sMDl27fl76FRSWOpX7W8lZGZg0++i8E7vevKVr48zFtFS8vKwZQzMZjTuq5s5cvDvPWsyROykJoKbPtODXfvqaBpE0XxwrxVtO/tspCUCUy5qYbgxypopZtTZXnrVVGzf3t6KZo2bSqLPCExMRHZYhQyIG9tkOfJ53ktb3nFmzgRuHTpEv7991/07NlTrhNj/sQtC/LGKZWm0BNj8kQX0cePHxdan/davP88osWuIrdaeNECfgmA3zrFQGZxwm9qoei+GhwYjGGTh8nnbw54U54wlaTHkB5yKU7kg0jUMyoYYyivhEcVXAmPj4pHXaPiu6E93YIXm6ho4csjJufR0dORV9wNjQ1RGX4JCMA6v4JYWeR29Q0MDsbkYYpYDXjzTVnolWRIjx5yKc4DcduOCo7HbCha8JIL4iW6P4l1T8ZLT0cH0fHxMDasnHgF/RKEiesmKn6ehjoaWii6UocEhsBjsod87jLARRZ6Jek4pKNcihP3IA51jAommtE11EVSVEFhK57rGZW+a+LT1NTVoKWnhcToRNQzrpxxsr8EBWHdREWsxEmGRW6388CQEEz2UMRqgIuLLPRKMqRjR7kU50FcHIzqVO6kPOpqatDT0kJ0YiKMK2lc8auStwQxlODzXTFwttHKv1CVh3mr6HhNPxuDLo218i9UPRkv5q1n1a4N2Nrk4PylgkKPeat4eupAF4Mc/BhVUOhVRd56VbDQoyqXV+Tlte6pqqrKYk/cxy7Pk8/zCi5LS0vo6enJrp/ff/+9/E7Lli1ly9uhQ4fkvejyul5aWVk9dz/yZr4UtzqIjY2V4/PEY96tD6ytrZ+7DVHkTcw9oSuOsbGx7KJaramU7cp4ba3aSEtVDKoXLOwsEB0ejYd3H8oTqYsnL2LSkkn574tumOvmrcORUMUsp1ammoiMy8SD6Aw0qKOOs3+nYOaI+oV+VmpKKmppKcZ3VCcqZWzR06pdG6lpBbF6HtEFc966dQh94rYfDvU1ce9xJkKTMtBIWx1H7qZgbcfC8UpJTYVWrWoYr6daxp/XoqeppYn0VMVEM4KJnQniw+MRezcW+kb6uHbyGgYuGZj/vuiGuXPeTmwI3VDqfUpPSa+ex9ZTsXpei56WpiZSc+/FWRqiK9O8nTsRuqH0sRJS0tOr5bFVmXnr6ZyVZ9NP8TDQVcUgt6Jnj2TeKhyvBRfjYailCm+7ouNVE/NWUTkr6ZGYpAwwqKN4vB6iAsvXCroiCsxbBfGKzgAyc4BGmorH3xJU4KKf82rkrSrGQo9eqtq1a8Pe3h5//vmnHI93/vx52NjYyNsc5MnrzikKQvFZ8bnfc8dTidd5zp07Jx9F8Vearkzu7u7yVgrCxo0b5e0VxGOevHGCL1peK2aq6J+RSxSXouVSFMHaeSOyy6G9e3vsWb8HY2eOlRPdiC5QJmYmcHBxwKmDp2DV0gon9p2AfbvCY3rqNqiLiLsRaGzeuFRXxi3tLBF2I6zQldlRs0Zhhe8KOZV0xz4d0dhSsS0hPCwcjh0KWlnF1OTe/6mH+VujFLdXaK0DsydmhIiJjIGWjhb0DSpvKm739u2xfs8ezByriJXoumlmYgIXBwccPHUKLa2ssO/ECbR7avxTg7p1cTciAuaNG5eqRc/O0hI3wgpiJazatQv+gYHyucf06fBo3x4+np7ydVh4ODo81SItpiZf1KYe3j4ZJW+v4PmaDqwNCuIVGRMDHS0tGOhXXrwc3R3hv94fA2YOkPESXTeNzIxg7WKNCwcvwKylGc7tOwfrdoUvkOg30Ef03WgYmRuVqkWviV0ThN8Iz38trmR7zPLATl/FFPit+rSCoWVBq2VUWBRsOyi6deY5cFgVF4MUXcTm/p86nJ2y0aeHoudAfGQ8aunUgo5B4bG5L5K7oyPW+/tj5gBFrETXTTMjI7hYW+PghQtoaWaGfefOod1TF5Ma6OvjbnQ0zHN7NDyvRc+uSRPcCC+IlbDq+HH4545Z9li1Ch729vDp2lW+DouKQgfbwrFackcV+2MUsXK5pI7+DbIxs2nBNOWR8fHQqVULBk+NZX6RqmPeejpnCWJm4AO/J8G8kQamrFLE3dNNH51aKWLDvFU4XmJm4C3Xk2BjoIGehxXxmtRCH33MdWp03ioqZz16DGzfqS7/PxSLpUUOOrUv+HfIvFU4XrEZgO9Ndfn/oSj02unnYFTDqs1brwoWevTSTZkyRY7JExOyiMcnubi4yPF5eUSXTFHoiUJJjO9r1qyZvPImCsa8wqm04/Nef/119OjRQ95LTxR8eUWfILqElmY75em6OWLECIQ/dXL2zjvvyMfevXvLm7iX16zVs7DIexEGtRokX09dNlWeME2aPwl+o/3w83c/yy6R878qfD9ArzlemDt2riyuVu5bmX/iVBwzKzP5GBUeld+10rGTo1yKcuHUBcxeM7vQura2WnIpipgwwa2vGyrT6lmz4L1oEVoNUsRq2dSpstCbP2kSRvv54buff5bdir566t6Jc7y8MHbuXHmCsm/lyvyCrzhWZopYhUdF5Xer9B08WC5FOXXhAtbMLhwroZupllyKIiZ76etWufF6Z/U7WO+9HtNaTZOvRy4bKU+Yhs4fitWjV+P0d6dll0ifr3wKfc9zjifWjF0ji6sP932Yf+JUHBMrE/kYGx6b37XSqpOVXIpy5dQVjF9TcFsUoa9HtlyKIiZ6adO3DSrT6nfegff69Wg1TRGrZSNHykJv/tChGL16Nb47fVp2K/rKp3Cs5nh6YuyaNfIEZd+HH+YXfMWxMlHEKjw2Nr97km+3bnIpyqkrV7DmiVvICB+aZculOGKyl75tKjde1TFvFZWzxMWog0ubFrt95q3C8RIXo0JHFB+vmpq3ispZxg0hb61QHOatwvGy1oa8tcLLzFuvCpUc0YGaqAqI++eJsXVOTk7y1glPunr1qmxNCwoKQkpKiuzuKFrUxo4dW6irp/i+2I4gCrFNuWNc8rYtrFu3Dm2e+AcuirGibpguZGZm4quvvpJdPx8+fChv4SDucSd+7tM3cX/yhukVGZcn9uHpQi9PcYXeguUL0H9Gf1QnP27+UXZ78vJT/D1epAnuE+TJn4WNRZm/u9VnHT6bUPiCwcu2+ccfER4dDb/cY/dFc58wQRauNhali1dMahZa/1B4xsdFfhnIvbPIS3ds8zHEhcfB00/RyvkizXOfJ0/+TG1Kvv1KUU6NP4AVvfqiOtl87BjC4+Lgl9si/KK5z5snC1eb59yuJk9MBtD6YuEJgXb4NUYd3cqbMKYsmLdKj3mrbJi3Xt289aTl589jxuLFUBZs0aMq83Rx96QWLVpgRe64k5KIIrGoIqukbZdEFHOiSMwrHqtCtR+vV0r9xvTDDxufHbNQUeLGw71H9i5XkVddjenXDxuLGGv1IogbD4/s3bvURd6roMuYLji68egL36648bDbSLdyFXnV1ZguXbDx6IuPVd6Nh0e6uZXrZKm6Yt4qPeatsmHeKsOxxbxVZXgfPaoxRGucaN379ttvy1yYie/lteaRghgHOXhi0d0PK0LceLjPyKq792BVxWpiMV01K0rceHhkFd6rsari1WNi8WOtykvceFgUekp3bJUwRrQixI2HRaGnTJi3yhYr5q2yxYt5qwzHFvNWlWChR0REREREpGTYdZOUXkXvcyfG1D09to+IiIiIqDpjix4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR5RDfLhfz9Ef7v+mNp/aqH1x348hr42feHp6ImQv0Iq9DO2r9yOxPjE535u9qjZcK3jCgcVB9wPvZ+/fqH3QnSs1xFttNpgeLvhuHrpKl6G/374Iez690f/qYVj9eOxY7Dp2xeOnp74K6RisVq5fTviE58fq1GzZ6OOqytUHBwQer8gVmP8/OS6vGXWypV4WVb8dwWm2E3B0v5LC60P+DEAPjY+mOY4DXf+ulOhn3Fw5UE8jn9c4meiwqIwu9NsDNcfjtFGo7H1/a3IycnB6jGr0V+lf/6ybdY2vCz/XbECdlOmoP/SwrH6MSAANj4+cJw2DX/dqVisVh48iPjHJcdKCIuKQqfZs6E/fDiMRo/G+1sV8TL38oJK//6Flpqes6LCo9C/ZX+Zm0SO+njsx0hPS0cP8x4yjz25vCzVKW+FR0WhZf/+0GrTBvU6dsTYjz9GWnq6/Plthg2DnosL3MaOxZ0HD1CTc9aTsrKy8J7TezJHRYZGyp//QZsPMExvGPzc/BB5JxIvS3XKW8LT+enavXv4/swZNPP2lq/n7dxZoX1RFuoveweIqGpER0Qj8FggTkacfOa9PRv2YMbKGejYo2OFf843K79B1/90hb6BfomfU1FRQZsubXByf+H9sbK3QtsubaFZWxPLfJfh/979P+wI2IGqFBEdjWOBgYg4+WysNuzZg5UzZqBHx4rHauU33+A/XbvCQP/5serSpg32F7E/3V1dMWvcOPm8qbExXoa4iDgEHwvGlogtz7x3dMNRjF05Fk49nCr8c8RJU7v/tIOOgU6xn0lOTIaZvRn6vd8P/176F7sW7IJVWyv53uvdX8eAWQPk8wZNG+BliIiLw7HgYERseTZWG44excqxY9HDqeKxEidM/2nXDgY6xcdKSExOhr2ZGd7v1w+X/v0XC3btQlsrK+x87z2kZmTIz0xYtw5ampqo6TlLVU0Vvf/bG9YO1rh55SZWzFgB+3b2WLZzGdJT0+VnFkxYgNpatfEyVLe8paaqiv/27g0Ha2tcuXkTM1asQDt7e2z/6SckPX6Mb5YskevGzZ2LYxs3oqbmrCcdXnO4UHH5pfeXSElKwbRvpmHbjG1YO24t5h+bj5qet/KsGDsWjhYW8nlTQ0Oc+ecf9G3TBisOHqzwvigLFnpESubkgZP430f/k1flnTo5Yfaa2fL1rwd+RUJsgrwC3tiiMVbuXYmgs0FYPGkxwm6G4e7Nu9DW1cbi7YthbW+NS2cuYYnPkvxCY8XeFWhs3hgpySmyALsedB0Z6Rl4e+bb6DW8F37Z8ws2LtqIyAeReNfjXWhoamDO+jlwaFf01e3FXy/G/q37nyn0hk4aioyMDCTFJ6GeUT3o6JUu4ZfHgZMn8dH/FLHq5OSENbNny9cHfv0VsQkJ8uq3RePG2LtyJc4GBWHS4sW4GRaGm3fvQldbG9sXL4a9tTXOXLoEnyUFsdq7YgXMGzdGckoKfJctQ9D160jPyMDMt9/G8F69sOeXX7Bo40Y8iIyEx7vvQlNDA+vnzEE7h6Jj9fXixdi6f3+RhV6jBg3QuXVrqKpWfgeNPw78gW8++kbGq0WnFhi/Zrx8ff7AeTyKfSSvgDe0aIhZe2fh2tlrWD9pPSJuRiD8Zjhq69bG1O1TZRF29cxVbPTZmB8v8XkjcyOkJadhk+8mhAaFIjM9E/1n9kfn4Z1xds9Z7F60G3EP4rDQYyHUNdXhvd4b1u2sn9lHs5ZmmPDFBPm8pVtLWejFPoiVrw0aGaBF5xZVEqsDf/yBj75RxKpTixZYM368fH3g/HnEPnokr35bNGyIvbNm4ey1a5i0fj1uRkTgZng4dGvXxvapU2UBdubqVfjkngTLY2vWLJgbGSE5LQ2+mzYhKDQU6ZmZmNm/P4Z37ow9Z89i0e7deBAXB4+FC6Gpro713t5oZ/1srGSMzMzwxQRFvNxatpSF3oPYWAzu0EGuC42MxI3wcHz+9tuo6TmrvlF9jJs1DmmpadAz0JPrtPW00cqllXwueiaE3QjD+5+/j8r0quQto/r15UWo1LQ0GOgp4qWnrY1L//wD3xEj0LdLFwQEB+PTr7+WOV9DQ6NG5qw8Ik/tmr8LPd/tiZ9W/STXiYtVvX17o23ftrgecB37P92PzIxMqGuo1+i8laeVuTnesLOTP0N456235CMLvQIs9IiUiDihWeC1ANsDtsPEzAQTu0+E/y5/TF06FZ4TPTHObRx2B+3O/7yjq6N8PdZtLLzneaONW5v897Ys34Kxs8ai59CeeJz0GCqqikS6cfFGmDc3x7yN85D8KFmehHXo3gHug9zlIroxrT28Vp5gCRdPX8TSyYW7egjiM8WZP34+Dnx9AGZWZvh8z+eoDOJkxmvBAgRs3w4zExN0nzgRu/z9sXTqVEz09ITbuHEI2l0QK1dHR/ladDWa5+0NtzYFsVq+ZQtmjR2LoT17yivVqrn/6SzeuBHNzc2xcd48PEpOlidg3Tt0wCB3d7mY9+iBw2vXypMr4fTFi5j8VLcYQXymON8ePiyvkDvZ2mLrwoWwa9YMlUGc0KzzWoelAUthaGaIBd0X4Oyusxi1dBR6TOwhuxWtCFqR/3kbVxv5WqwfOm+oLLry7Fu+T7asdRraSV6tzju2di/ejcbNG+Pdje8i5VEKpjtOh2N3R7gOcpWLl7kX5hyeI0+whKunr2Lj5GdbAsRn6pnUg/+X/vIEy7mPM24H3cbpb0/j1PZTeM3pNUzeOhlN7ZpWSqzEyYzXunUIWLoUZoaG6L5gAXadPYulo0ZhYo8ecPPzQ9CKgli52tjI12L9vKFDZcGVZ/m+fZg1YACGduqEpJSUgmNr9240b9wYG999F49SUuA4fTq6OzpikKurXETXy8Nz5siTK+H01auYXESrifiMSb168vmX/v7yBKuPs3P++1+fPClbZoZ36lQpsXrVcpaRiZHsuimI/fMY5pH/vshZampq8BhesK6m5y0TIyPZdVMQ+zfMwwOzVq1CYHAwomJj5WNmZiai4uLkZ2tyzvpq2lfoMqYLzB3M89frN9BHSGAIEqIS5GNWZhYSoxJlfqvpeUsQ+yhy1rCOHbFu4kSoq6m98Li86ljoESmR0OuhaGjaEKYWpvJ1l35d8Ne5vwqdjJTW6x1fx+YlmxEeFg5Xd1fYONrI9b8f+R2pyak4tOOQfC2ukN/79x4M6hsUuZ3WnVoXOlErjQlzJsDd011euV8+bXmlFHvXQ0Nh2rAhLEwVserXpQvO/fWXPBEpq46vv44lmzcjLDwc7q6ucLRRxOrI778jOTUVOw4pYiWujv977x7qGxQdq06tWxc6SXuegW++iWE9e8qfIa7AvzNvHgJ2VE431/vX76O+aX159Vto268tQs6FoNOwshcAth1t8eOSHxEdFg1Hd0dYOCq63lw+clmenJ3acUq+FlfIH/77EPr1i+4iJq7QP3mi9qTzP53Ht37fwusLLxhbGqP9wPZyX8X2N/tuxtp31mJZwDJUhuv378O0fn155Vvo17YtzoWEYFg5iqWOtrZY8uOPCIuOhrujY343pSOXL8sTsx2nFLESV8f/ffgQ9YvpTieuzj95kva0n86fh9+33+ILLy9Y5nYBFlf1t508CQ8nJxgVc8zWxJwlitKLv13Eqlmr0MmjE9z6uMlYHdx2EB09OsqWv8ryKuYtUZT+dvGiLPA8OnWCn5cXvBctgpGbGxrnntBr1a5do3NW8Ilg/P3r3/j04qeytVEQBaWnnyfWe6/HGKMxqN9YcVxpalVON+pXLW/9b/x4tGzaVHbXnPPtt3Bu1gwTuncv874qOxZ6RFSksTPGynErgUcD4dvPV3ZpyhsPs+SbJWjh1KJUkStPi14TyyZyOT/4PL7/4vtq/xeaMXasHLNyNDAQ/Xx9ZXemvLEwYhyKU4vSxaqsLXp93Nzyn/9++TK+LEOR+DL1n9Efbf/TFn8e/RNL+i3BxPUT88fDiLEolk6WpdpOcVfHxdX4z4d/jmELh8F9vLtc16ZPQUvGtd+vyda+V8GM/v3xn7ZtcfTPP9FvyRKsnzgxfyzMN9OmwcmydLEq6cr4vxERGPzpp1g4bBjGu7sX+o44Cftk9Gi8CqoiZ4kWPdFVUyxff/K1LCJFoSe+I4rH6Z9Mx6uiKvKWaKVzadVKLp98/bUsItd+9BH6urkhPikJ+06ckMVm3eeM91P2nOXS3wUJkQkY32R8/joxCcuu1F1o07eNnNDl3L5zstjUrauL6q4q8pZP7sUN0ZIoxvZVdCIYZcVCj0iJiO5JD+89lGNFjJsayzEu/d7uV65t3blxB+bW5nL559I/uBNyR540iSvloviau2GuHOv0Z8CfcHBxyO8jr1tHFwkxCfndoIq7Ov7Tjp/kd4UT+07Iz4uTtIUTF6Ldm+2grq6O4z8elz+/MoiuSfcePpSzWIpJTMT4lrf7lS9WN+7cgbW5uVzE+JOQO3fkCZO4Sv7F999jw1xFrAL+/BMuDgWxqqOri5iEhPwuUMVdGd/x00/yu4I4MRKfFydoq3bsgJWZGeISE/HdkSNwtrNDZRHdk2LuxciZ4MREJmLsS7e3u5VrWw9uPEBj68ZyEWNQHoQ8kCdN4kr5kS+OwHuDt4zXtYBraO7SPD9eOnV0kBSTlN8Nqqir4/eu3cNMl5nyCrz4rrhKLj5/bv85mFiZ4FHcI5z+7jQsnUt3olEeomvSvZgYOb6taYMGctzL293KF6sbDx7AunFjuYjJUkIePJAnTOIq+RdHjmCDtyJWAdeuwaV5Qazq6OggJikpvwtUcVfGxUx1vRcvllfgxfd//ftv+R2xiG6b9fX00PuJrpw1OWcFHA2QecuqpZWcjCUuOg5m1mbyvYNfH5QthG/0fgOV6VXKW0cDAmTuamllJSdjiY6Lg7WZGQ7++itS0tLkDJyfb9uGkb17oybnLCH6XjTs3lDk70tHLmHvsr3w3eaL8wfPIz0lHRlpGTjw+QG8MbLyjq9XKW+J1scNv/wiu5j+duWK/I5o0RPbuxURIT8THBqKHb/+irccHdGwknokvApY6BEpES1tLXy84WNM7jNZMbFBRyd0H1y+rgzixOis/1moqavB2MwY/cYoTia85njhk2mfYFCrQcjOypbvrT20Nj9Rj/AdIadEFyc9YlY8O+eii4/ZI2fnPxfbE+NzRKF38++b+Pm7n+W4DdvXbTF7bcHnXiRtLS1s+Phj9JmsiFVHJycMLme3D3FS5H/2rBwfYGZsjDG5J15zvLww7ZNP0GrQIGRlZ8v3Dq0tiJWYkEBMhy66RIkZ8Yor1EbOLoiB2J4YmyMKvV8vXIDfmjVyex3Ef6AffYTKUku7ljyZWdxnsYyXKKRcB7uWa1vixOiy/2V5bImxM13HdJXrB88ZLMepTGs1TR5b4j2/Q3758erl20tOia5XXw/jVo5DM+dnxyOKcSzJCcnyyrtYhCFzhyD0z1DZlVNsy6aDTf6ELZVBu1YteSLTZ7EiVqKIGuxavliJkyL/y5cVx5ahIcZ0VcRqzuDBmPbVV2g1bZri2DI0xCFxu428Y6tXLzkduijUVo4bJ0+CihIYEoKE5GR55V0swtwhQ+QV+d1nz2J0ly5y0o3K8irlLDHr5t7NexF+J1xOEjXIaxCGeA+R4wx/2f0L+o7uKyd0qUyvUt4SYzs3792LO+Hh0NPRgdegQfAeMkQWf9M//RS1NDRky96yp24FUdNyltDAtIFcBFGYCmK2YNGlc8v0LdCopSEnZBm1bBQqy6uUt0SXz0/37cOdqCg00NfH7IEDZa56+3//kxeohL3nzsnl5MKFNbrQU8kRf00iqtYWLF8gu47Q8231WYfPJngzVCWISc1C6x8K7scnLPLLgG717xH0Up0afwArevV92btRrcVkAK0vFi52dvg1Rh1dTpJQEuatUhxbzFvlwrxVNsvPn8eMxYuhLHjDdCIiIiIiIiXDQo+IiIiIiEjJsNAjIiIiIiJSMiz0iIiIiIiIlAwLPSIiIiIiIiXDQo+IiIiIiEjJsNAjIiIiIiJSMiz0iIiIiIiIlAwLPSIiIiIiIiXDQo+IiIiIiEjJsNAjIiIiIiJSMuoveweI6Pl0tXSxd/lehqoUMgEs38tYlSQlR6T+VoXWXV5zGbVVRfSoOFlqalh+/jwD9Nxjq22hdYfWHIYWjy3mrQpi3iof5q2y0apTB8pEJScnJ+dl7wQREVWdmEdpaL3oWKF1F/3eRH3dWvwzEI8tqpaYt4jKjoUeEVENk52dg7jk9ELr6mprQlVV5aXtEykHHlvEY4uo+mChR0REREREpGQ4GQsREREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4REREREZGSYaFHRERERESkZFjoERERERERKRkWekREREREREqGhR4RERERERGUy/8DTiuYWar7Wu0AAAAASUVORK5CYII=", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 3, + "metadata": { + "output": { + "id": 1550310722733610, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Row-major 4×3: offset(i,j) = i*3 + j\n", + "draw_layout(Layout((4, 3), (3, 1)), title=\"Row-Major (4,3):(3,1)\")" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Nested pedagogical view — shows row=.../col=.../offset=... per cell\n", - "# with color-coded hierarchy boundaries and per-level axis labels\n", - "draw_layout(hier, title=\"Nested: ((2,3),(2,4)):((1,6),(2,12))\",\n", - " colorize=True, flatten_hierarchical=False, label_hierarchy_levels=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Swizzled Layouts\n", - "\n", - "Swizzle applies an XOR operation to indices, redistributing elements across memory banks\n", - "to avoid bank conflicts in GPU shared memory.\n", - "\n", - "`Swizzle(B, M, S)`: XOR B bits starting at position M with bits at position M+S.\n", - "\n", - "### Classic LDMATRIX Swizzles — `Swizzle(B, 0, 3)`" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "output": { - "id": 917716814314818, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 4, + "metadata": { + "output": { + "id": 805509571956944, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Column-major 4×3: offset(i,j) = i + j*4\n", + "draw_layout(Layout((4, 3), (1, 4)), title=\"Col-Major (4,3):(1,4)\")" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Swizzle(3,0,3) on 8×8 — the classic LDMATRIX bank conflict avoidance pattern\n", - "draw_swizzle(Layout((8, 8), (8, 1)), Swizzle(3, 0, 3), colorize=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### GMMA/TMA Swizzles — `Swizzle(B, 4, 3)` (SM90+)\n", - "\n", - "These operate on higher bits and are designed for the Tensor Memory Accelerator.\n", - "All elements are shown at full resolution; color bands reveal which blocks of\n", - "2^base elements were permuted by the swizzle." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "output": { - "id": 901597456182441, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 5, + "metadata": { + "output": { + "id": 798884306577558, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 8×8 row-major with rainbow coloring\n", + "draw_layout(Layout((8, 8), (8, 1)), title=\"Row-Major (8,8):(8,1)\", colorize=True)" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# SW128: Swizzle(3,4,3) on canonical byte layout 8×128\n", - "# Full-resolution view: every element visible, colored by block identity\n", - "draw_swizzle(Layout((8, 128), (128, 1)), Swizzle(3, 4, 3), colorize=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. MMA Atom Traits\n", - "\n", - "MMA atoms define how matrix multiplication operands are distributed across threads\n", - "for Tensor Core operations. Each atom is defined by its A, B, C layouts from the\n", - "CuTe `MMA_Traits` struct.\n", - "\n", - "The layouts map `(thread_idx, value_idx) → element coordinate` using column-major\n", - "encoding: `offset = m + n*M` for an M×N matrix.\n", - "\n", - "### SM70 Volta — `SM70_8x8x4_F32F16F16F32_NT`\n", - "\n", - "8 threads (one quadpair), Shape 8×8×4. This is the example from\n", - "[0t_mma_atom.md](https://github.com/NVIDIA/cutlass/blob/main/media/docs/cpp/cute/0t_mma_atom.md).\n", - "\n", - "Equivalent to:\n", - "```cpp\n", - "MMA_Atom mma = MMA_Atom{};\n", - "print_latex(mma);\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "output": { - "id": 772800265512658, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "SM70_8x8x4_F32F16F16F32_NT Shape: 8×8×4\n", - " PTX: mma.sync.aligned.m8n8k4.col.row.f32.f16.f16.f32\n", - " A layout: ((4, 2), 4) : ((8, 4), 1)\n", - " B layout: ((4, 2), 4) : ((8, 4), 1)\n", - " C layout: ((2, 2, 2), (2, 2, 2)) : ((1, 16, 4), (8, 2, 32))\n" - ] - } - ], - "source": [ - "atom = SM70_8x8x4_F32F16F16F32_NT\n", - "M, N, K = atom.shape_mnk\n", - "print(f\"{atom.name} Shape: {M}×{N}×{K}\")\n", - "print(f\" PTX: {atom.ptx}\")\n", - "print(f\" A layout: {atom.a_layout}\")\n", - "print(f\" B layout: {atom.b_layout}\")\n", - "print(f\" C layout: {atom.c_layout}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "output": { - "id": 2343721956054734, - "loadingStatus": "loaded" - } - }, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rank-1 as Column Vector\n", + "\n", + "By default, rank-1 layouts render as a row (1×N). Use `transpose=True` to display as a column (N×1).\n", + "This is useful when a mode-1 slice represents a column." + ] + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Mode slicing produces rank-1 layouts\n", + "L = Layout((4, 8), (2, 8))\n", + "L0 = mode(L, 0) # 4:2 — the row dimension\n", + "\n", + "# Default: row vector\n", + "draw_layout(L0, title=\"mode 0 (default)\", colorize=True)" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Composite A, B, C visualization\n", - "draw_mma_layout(atom.a_layout, atom.b_layout, atom.c_layout,\n", - " tile_mnk=(M, N, K), colorize=True, thr_id_layout=atom.thr_id,\n", - " main_title=f\"{atom.name} ({M}×{N}×{K})\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Tiled MMA — 2×2 Atom Layout (Full Warp)\n", - "\n", - "Tiling the atom with a `(2,2):(2,1)` n-major layout creates a 16×16×4 MMA\n", - "using all 32 threads (4 quadpairs = full warp).\n", - "\n", - "Equivalent to:\n", - "```cpp\n", - "TiledMMA mma = make_tiled_mma(SM70_8x8x4_F32F16F16F32_NT{},\n", - " Layout, Stride<_2,_1>>{});\n", - "print_latex(mma);\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "output": { - "id": 942912081568887, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# transpose=True: column vector\n", + "draw_layout(L0, title=\"mode 0 (transpose=True)\", colorize=True, transpose=True)" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# 2x2 tiled C matrix (16x16)\n", - "atom_layout = Layout((2, 2), (2, 1))\n", - "c_grid, _ = tile_mma_grid(atom, atom_layout, 'C')\n", - "draw_tiled_grid(c_grid, 16, 16, title=f\"{atom.name} 2x2 C (16x16)\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Tiled MMA — 32×32×4 (Value Tiling)\n", - "\n", - "Expanding the tile to 32×32×4 replicates across **values** (not threads).\n", - "Each 16×16 quadrant uses the same threads but new value indices.\n", - "\n", - "Equivalent to:\n", - "```cpp\n", - "TiledMMA mma = make_tiled_mma(SM70_8x8x4_F32F16F16F32_NT{},\n", - " Layout, Stride<_2,_1>>{},\n", - " Tile<_32,_32,_4>{});\n", - "print_latex(mma);\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "output": { - "id": 966448212485654, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Hierarchical Layouts\n", + "\n", + "CuTe supports nested (hierarchical) shapes. A layout with shape `((2,3),(2,4))` describes\n", + "2×2 tiles arranged in a 3×4 grid — the inner dimensions describe the tile, outer dimensions\n", + "describe the grid of tiles." ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# 32x32x4 tiled C matrix\n", - "c_grid_32, _ = tile_mma_grid(atom, atom_layout, 'C', tile_mnk=(32, 32, 4))\n", - "draw_tiled_grid(c_grid_32, 32, 32, title=f\"{atom.name} 2x2 32x32x4 C (32x32)\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SM80 Ampere — `SM80_16x8x8_F16F16F16F16_TN`\n", - "\n", - "32 threads (one warp), Shape 16×8×8. From `mma_traits_sm80.hpp`.\n", - "\n", - "PTX: `mma.sync.aligned.m16n8k8.row.col.f16.f16.f16.f16`" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "output": { - "id": 856271947434372, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 6, + "metadata": { + "output": { + "id": 1181989490677108, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 2×2 tiles in a 3×4 grid: ((2,3),(2,4)) : ((1,6),(2,12))\n", + "hier = Layout(((2, 3), (2, 4)), ((1, 6), (2, 12)))\n", + "\n", + "# Flat view — offsets only\n", + "draw_layout(hier, title=\"Flat: ((2,3),(2,4)):((1,6),(2,12))\", colorize=True, flatten_hierarchical=True)" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "atom = SM80_16x8x8_F16F16F16F16_TN\n", - "M, N, K = atom.shape_mnk\n", - "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", - " colorize=True, grid_shape=(M, N))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SM90 GMMA — Warpgroup Accumulator\n", - "\n", - "128 threads (warpgroup = 4 warps). A and B operands come from shared memory\n", - "descriptors. The C accumulator layout shows register distribution.\n", - "\n", - "From `mma_traits_sm90_gmma.hpp`, `CLayout_64xN` template." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "output": { - "id": 1685001715877307, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "SM90_64x64x16_F16F16F16_SS Shape: 64×64×16\n", - " 128 threads × 32 vals/thr = 4096 elements\n" - ] + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Nested pedagogical view — shows row=.../col=.../offset=... per cell\n", + "# with color-coded hierarchy boundaries and per-level axis labels\n", + "draw_layout(hier, title=\"Nested: ((2,3),(2,4)):((1,6),(2,12))\",\n", + " colorize=True, flatten_hierarchical=False, label_hierarchy_levels=True)" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cell Label Modes\n", + "\n", + "`cell_labels` controls what text appears inside each cell:\n", + "\n", + "| Value | Effect |\n", + "|-------|--------|\n", + "| `True` (default) | Offset in flat mode; row/col/offset in nested mode |\n", + "| `\"offset\"` | Just the offset number — useful with hierarchy boundaries |\n", + "| `False` | No text — colored grid with boundaries only |\n", + "| `list` / `tuple` | Custom labels indexed by offset (e.g., alphabet letters) |" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "atom = SM90_64x64x16_F16F16F16_SS\n", - "M, N, K = atom.shape_mnk\n", - "print(f\"{atom.name} Shape: {M}×{N}×{K}\")\n", - "print(f\" 128 threads × {size(mode(atom.c_layout, 1))} vals/thr = {M*N} elements\")\n", - "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", - " colorize=True, grid_shape=(M, N))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SM75 Turing — `SM75_16x8x8_F32F16F16F32_TN`\n", - "\n", - "32 threads (one warp), Shape 16×8×8. First generation of asymmetric tensor core tiles.\n", - "\n", - "PTX: `mma.sync.aligned.m16n8k8.row.col.f32.f16.f16.f32`" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "output": { - "id": 1454137506437681, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Swizzled Layouts\n", + "\n", + "Swizzle applies an XOR operation to indices, redistributing elements across memory banks\n", + "to avoid bank conflicts in GPU shared memory.\n", + "\n", + "`Swizzle(B, M, S)`: XOR B bits starting at position M with bits at position M+S.\n", + "\n", + "### Classic LDMATRIX Swizzles — `Swizzle(B, 0, 3)`" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "atom = SM75_16x8x8_F32F16F16F32_TN\n", - "M, N, K = atom.shape_mnk\n", - "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", - " colorize=True, grid_shape=(M, N))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SM89 Ada Lovelace — `SM89_16x8x32_F32E4M3E4M3F32_TN`\n", - "\n", - "32 threads (one warp), Shape 16×8×32. First FP8 (E4M3/E5M2) tensor cores.\n", - "\n", - "PTX: `mma.sync.aligned.m16n8k32.row.col.f32.e4m3.e4m3.f32`" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "output": { - "id": 780639114666597, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 8, + "metadata": { + "output": { + "id": 917716814314818, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Swizzle(3,0,3) on 8×8 — the classic LDMATRIX bank conflict avoidance pattern\n", + "draw_swizzle(Layout((8, 8), (8, 1)), Swizzle(3, 0, 3), colorize=True)" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "atom = SM89_16x8x32_F32E4M3E4M3F32_TN\n", - "M, N, K = atom.shape_mnk\n", - "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", - " colorize=True, grid_shape=(M, N))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SM100 Blackwell UMMA — `SM100_128x128x16_F16F16F16_SS`\n", - "\n", - "1 \"thread\" (warp group operates as a unit via TMEM). Shape 128×128×16.\n", - "\n", - "SM100 uses a fundamentally different model from SM90: instead of distributing\n", - "elements across 128 threads with a hierarchical layout, all elements live in\n", - "TMEM (Tensor Memory) accessible by the entire warp group as a single unit.\n", - "\n", - "The layout is trivial col-major: `(1, (M, N)) : (0, (1, M))`.\n", - "\n", - "Below we compare the SM90 GMMA and SM100 UMMA representations of the same\n", - "64×8 C accumulator tile." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "output": { - "id": 1326420539507572, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "SM90 GMMA 64×8 C: ((4, 8, 4), (2, 2, 1)) : ((128, 1, 16), (64, 8, 512))\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### GMMA/TMA Swizzles — `Swizzle(B, 4, 3)` (SM90+)\n", + "\n", + "These operate on higher bits and are designed for the Tensor Memory Accelerator.\n", + "All elements are shown at full resolution; color bands reveal which blocks of\n", + "2^base elements were permuted by the swizzle." + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 9, + "metadata": { + "output": { + "id": 901597456182441, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# SW128: Swizzle(3,4,3) on canonical byte layout 8×128\n", + "# Full-resolution view: every element visible, colored by block identity\n", + "draw_swizzle(Layout((8, 128), (128, 1)), Swizzle(3, 4, 3), colorize=True)" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "SM100 UMMA 64×8 C: (1, (64, 8)) : (0, (1, 64))\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. MMA Atom Traits\n", + "\n", + "MMA atoms define how matrix multiplication operands are distributed across threads\n", + "for Tensor Core operations. Each atom is defined by its A, B, C layouts from the\n", + "CuTe `MMA_Traits` struct.\n", + "\n", + "The layouts map `(thread_idx, value_idx) → element coordinate` using column-major\n", + "encoding: `offset = m + n*M` for an M×N matrix.\n", + "\n", + "### SM70 Volta — `SM70_8x8x4_F32F16F16F32_NT`\n", + "\n", + "8 threads (one quadpair), Shape 8×8×4. This is the example from\n", + "[0t_mma_atom.md](https://github.com/NVIDIA/cutlass/blob/main/media/docs/cpp/cute/0t_mma_atom.md).\n", + "\n", + "Equivalent to:\n", + "```cpp\n", + "MMA_Atom mma = MMA_Atom{};\n", + "print_latex(mma);\n", + "```" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 10, + "metadata": { + "output": { + "id": 772800265512658, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SM70_8x8x4_F32F16F16F32_NT Shape: 8×8×4\n", + " PTX: mma.sync.aligned.m8n8k4.col.row.f32.f16.f16.f32\n", + " A layout: ((4, 2), 4) : ((8, 4), 1)\n", + " B layout: ((4, 2), 4) : ((8, 4), 1)\n", + " C layout: ((2, 2, 2), (2, 2, 2)) : ((1, 16, 4), (8, 2, 32))\n" + ] + } + ], + "source": [ + "atom = SM70_8x8x4_F32F16F16F32_NT\n", + "M, N, K = atom.shape_mnk\n", + "print(f\"{atom.name} Shape: {M}×{N}×{K}\")\n", + "print(f\" PTX: {atom.ptx}\")\n", + "print(f\" A layout: {atom.a_layout}\")\n", + "print(f\" B layout: {atom.b_layout}\")\n", + "print(f\" C layout: {atom.c_layout}\")" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# SM90 GMMA 64×8 C: 128 threads, hierarchical layout\n", - "sm90_c = gmma_c_layout(8)\n", - "print(f\"SM90 GMMA 64×8 C: {sm90_c}\")\n", - "draw_tv_layout(sm90_c, title=\"SM90 GMMA C (64×8) — 128 threads\",\n", - " colorize=True, grid_shape=(64, 8))\n", - "\n", - "# SM100 UMMA 64×8 C: 1 thread, simple col-major\n", - "umma_c = umma_layout(64, 8)\n", - "print(f\"\\nSM100 UMMA 64×8 C: {umma_c}\")\n", - "draw_layout(umma_c, title=\"SM100 UMMA C (64×8) — 1 thread, TMEM\",\n", - " flatten_hierarchical=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SM120 Blackwell B200 — `SM120_16x8x32_F32E4M3E4M3F32_TN`\n", - "\n", - "32 threads (one warp), Shape 16×8×32. Warp-level FP8 with block scaling support.\n", - "\n", - "PTX: `mma.sync.aligned.m16n8k32.row.col.f32.e4m3.e4m3.f32`" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "output": { - "id": 1455636679512773, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 11, + "metadata": { + "output": { + "id": 2343721956054734, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Composite A, B, C visualization\n", + "draw_mma_layout(atom.a_layout, atom.b_layout, atom.c_layout,\n", + " tile_mnk=(M, N, K), colorize=True, thr_id_layout=atom.thr_id,\n", + " main_title=f\"{atom.name} ({M}×{N}×{K})\")" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "atom = SM120_16x8x32_F32E4M3E4M3F32_TN\n", - "M, N, K = atom.shape_mnk\n", - "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", - " colorize=True, grid_shape=(M, N))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 5. Slicing — Cecka, \"CuTe Layout Representation and Algebra\"\n", - "\n", - "Slicing fixes some coordinates while leaving others free (`None`).\n", - "For hierarchical layouts, slice specs mirror the shape tree — use `None` for free modes\n", - "and integer values to fix a coordinate at that level.\n", - "\n", - "### Simple Slicing\n", - "\n", - "Simple row and column slicing on an 8×8 row-major layout." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "output": { - "id": 1656371888885622, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tiled MMA — 2×2 Atom Layout (Full Warp)\n", + "\n", + "Tiling the atom with a `(2,2):(2,1)` n-major layout creates a 16×16×4 MMA\n", + "using all 32 threads (4 quadpairs = full warp).\n", + "\n", + "Equivalent to:\n", + "```cpp\n", + "TiledMMA mma = make_tiled_mma(SM70_8x8x4_F32F16F16F32_NT{},\n", + " Layout, Stride<_2,_1>>{});\n", + "print_latex(mma);\n", + "```" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "base = Layout((8, 8), (8, 1))\n", - "\n", - "# Row slice: select row 3\n", - "draw_slice(base, (3, None), title=\"Row Slice: layout(3, :)\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "output": { - "id": 4192437657684195, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl8AAAKECAYAAAA5Rl/xAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAmOBJREFUeJzt3Qd0FFUbBuA3EEho0rv0pvQqRWmKCkgTUVARLIgNEVFEVCwUxQI27KKCgIpgARQUpChSFQEBlQ7SAoQEQiCUkP+8N/+ss5tNBJVJZuZ9ztmTze4GdmZn5n73u9+9G5GSkpICEREREXFENmf+GxERERFR8CUiIiLiMGW+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+JFN99dVXuPnmm1G1alXkz58fOXLkQLFixdCiRQs89dRT2Lp163/y//D/iIiICNz8LCUlBR9++CGuvPJKFC9eHDlz5jT7vnz58mjWrBnuuecevPvuu2n+rlWrVoH9x9d6bf8uWLAgaBs++OCDzH5LWdquXbuQO3dus694/Bw6dMix/5ufjf2zSu82duzYoL/bvHkzIiMjzXOlSpXC0aNHHXvPInaRQb+JOIRBVffu3bFixYo0z+3fv9/cfvjhB7z88ss4ePCgPpf/yIkTJ9C1a1cT9NqdPHkShw8fxvbt27FkyRLzWJ8+fbTffeTJJ580HR77ORoaZNsNHToUx44dM/fvuusuE4BldZUqVUK3bt3wySefYM+ePRgzZgwee+yxzH5b4kMKvsRx7H02adIEBw4cCDyWLVs21K9f3/RG4+LisHLlSiQmJuL06dP6hP5DL774YlDgVaBAATRo0AB58uTB3r178euvvwYa1LPRqFEjHDlyRJ+VT/zxxx8YP368uZ89e3bcd999mfZeihQpgpYtW4Z9rnLlymkee/DBB03wRc8995zJ9BYsWPCcv08ROwVf4igGU9dcc01Q4NW0aVMzDMZeqT1Dwwvk6NGj9Qn9h7ifLRdddJEZasuVK1fQfp8/fz7ef//9s/p32YDxJv7w+uuvBzpGrVu3RsmSJTPtvdSoUQNTp04949c3bNjQBGWbNm1CQkKCOSf69+9/Tt+jSCjVfImjpk2bhtWrVwd+L1euHL755pugwItYh3TTTTdh2bJlaf4NDo+xx3rxxRejUKFCgTqxyy+/HO+9954ZQjsbf1evdDa1Tvy/R44caS7uDGqqV6+Ot956K/D6L7/80mT9WCtTtGhR9O7d22ScQvH/sf5N/v/MAj7xxBOoUqUKoqKiULp0adNgsPE4G2xwLKzvsgde1n5nLdjHH398Vv/umdR8MavG4Snuk3z58pn/m59/ly5d8MUXX6R5fWxsLIYPH47GjRubzATfG7ebw9U//vijo3VbrJPjMcf/m429VSuXN29eXHDBBWaI1n5cMwvIYTjrffTq1SvNv8kML/8N6zX33ntv0PP79u0zQ3sMFpih5GuZGe7YsaM5j/ie/u64CWXfN/zM7PVT9iFHqlChQtjjPikpKSiI5z4JJ6PzJrNdd911gfvvvPNOpr4X8akUEQddd911bDECt7Fjx57V369bty6lfPnyQf9G6K1JkyYpsbGxQX/Xu3fvoNec6XPUsmXLwHPlypXL8G+vuuqqsO9p5MiRKaNHjw77XPXq1VOOHTsW9O/y/7Ger1GjRkrNmjXD/u1ll12Wcvr06TPef3nz5g38bb58+VJefvnllK1bt57R357Nfgg1YsSIlGzZsqX7mXXu3Dno9YsXL04pXrx4uq+PiIhIGTZsWJr/Z/78+UGve//9989432T0tydPnszwmOMtR44cKVOmTAn8zX333Rd4LleuXClxcXFB/9+4ceOC/n7lypWB5xYuXJhSuHDhDP+/jh07piQlJaV73PDzCmX/e35mxO38u22zf97ffPNN0HObNm066+Pl37K/50qVKqX0798/pUePHil9+vQx51l678kyZ86coG3YvHnzf/r+RP6OMl/iqNBM1hVXXHHGf8uZSe3bt8e2bdsCjzFzwn+DWSTL0qVLceONNyIzsJ6KWbzLLrvM1LFZmFV46KGHcN5556FNmzamTsWyfv36DDNN69atw9q1a82MUGYTmOmzfPfdd1i4cOEZvz9muyzMmrFWhxkOZnI6depkJjjExMTgv8RsJIua7fV7zIS0a9fOZC+ZybNjJpDZHet9MHPCbCE/e75PYhzx+OOPY8qUKXASjzMO1/K98z2yXo41T8Ss55133mmylNSvX79AFpB1dPZsEdnfe926dVGvXr3ALMLOnTubzJ+lWrVq5rjh8WOZMWMGBgwY8K+3iZ8FSwEuvPDCoMe5jXycN+57y/fffx+4z8xzaNY6M2pIX3nlFXMOcZbuAw88YM4VHtvJycnp1ijaM7Rncw6J/Cf+NjwT+Q8xA2DvcYZmfDLCLI39b6+99lqTkaCDBw+m1K5dO+j5H3/80fHMV4cOHVJOnTplnnv00UeDnsufP3+gR7527dqwWYhwGQze2LO3TJw4Mei5J5544oz34ZIlS1Jy5syZYZYjOjraZOr+zX6wcF+UKFEi6Dl+jvZsHbOUn3/+eeD3Bx54IPDa7NmzB32OR48eTWnYsGHg+apVqzqS+eL7Xb16ddgs46xZs4L+bubMmYHn2rdvH3i8Vq1aQdscGRkZeO6VV14JPHf//fcH/Xv83bJjx46U0qVLB+2f7du3/6vMl4XHkf359DKi9m26+OKL092fTmW+MroNGDAg3X/Dvh/79ev3n74/kb+jzJe4xqxZs4J+Z20V1+wh1gQ9/PDDQc/Pnj0bTnvkkUcCmRBmSOxYG2NlCVg3VLhw4cBznPaeHtaHsfbJnpGwy+hvQzGDxF4+64jSw5qeRx99NOxaX2fr559/DqppY10ea9XsWQdmT1j3Zfn6668D9zkLk8sBcHkA3lgHyJo/y4YNG0zmw8LMIGMM62bVNf1bfL88xpi9ZLaL9631okI/D74ni72OizVvzMrSZ599hlOnTpn7zPzZM7X24zw6OjqoFqtMmTJBExuY2Zk7dy6cxFo0i/0YDld/Z30O9mz1f4H1dHfccYfJ/vHzZ2Zx48aNaermXn31Vfz5559h/w0ed5b/Otsr8nc021EcxcJ4riVl4YWRReRnwv53bLBCp5EzoEnv9U5hMbmFxdjpPWc9bw0tHT9+PN1/kwGbfbgpdD2ljP42vQCM66utWbPGNNwsXucMRxaA23GByn+71ldoo8thxrP5GwZaLC7PCD/ncz30tWrVKhPYnclCovbgkJMXOARmBWQs7ub+tw85crjXHgjYj1sGW5yckJWO8/j4+MD90PfmlKuvvtrc7Hg94PAjh20Z3NqD01tuuSXNv2E/p+zbJOIEZb7EUZy5Zvftt99muU8gtE7kbHrF9sDIXvMV+tzZsDfMZGXW/q3atWtj4MCBJrhhNmPcuHFB75lrObmBE6uUM6tqD7y4tIJVExWa+bLPQmRmjLVfFi6fsmXLFhPsWm699dYsdxxnhDMvLWc729YJobM8w80mJvvnad8mESco+BJHcejI7vnnn8/wAm7P6pQtWzbocftwk1WYbmd/fUY4hd/OngFig8XG0ivSG6LkEBqDAHs20RrS/TdClxhIb4kIO06isFSsWDFoGDHcrUOHDjjXFi9eHLjPwnhm5zg8yvWlWPifEQ59WhkiFuNff/31gSHH888/P82kE/txy8xw6OK1GR3n9mM5NJNpfXNBes70a6GYvbZk1rdPWPsvnNBMoD3DZWd/7/YJOyJOUPAljmKmoE6dOkEXSg7NhAY4nDk2adIkM0RjCc0wcAaddRHmsAHXYbJr27btGb2nEiVKBP1u1Tqx9unuu+82C496RfPmzU3dFGeshX57AIfW7EN+XL/q32J9lH3/zpkzxwwN2bND/Oy4/lm4z5nHxahRo9K8Vw7XcggvdGX1c7XOl33tOA55WzNOmXXj+msZYeBlrz1bvnx54D7XeQvNkNq3n8egveaLQ2pc4NSeBeUsSIt9X//222+BoJFB3JAhQzJ8n6Frvu3evTvs6zgz0/5/pOfv1vn6N98HypmZPE+tmaUW1jO+8cYb6c7wtR9z9o6INdNUxDF/W5Iv8h/buHFjSpEiRYJmJXENqEaNGqV06tQppUWLFmYNKmuGoCUhISGlTJkyQX/HNb+uvPLKlGLFigU9fvnll5/xjMbvvvsuzSypUqVKmVl/Ga139Hf/7t/NvMtoZtq/mbWWEfu/y33bvHlzs8+bNm2aZh0u+wy8f7PO1zvvvJNmP/Jz46w5ftacAWtf52vXrl0pBQoUCHp92bJlU9q2bWv+5sILLwy819B9c65mO3I/2Z+rVq2aeS+cyck1x/5u9ukff/yR5nW88VwIxRmN5513XtDruM08pvmZ2R+//fbbg/526NChac4r7rtwa6yFHjfTpk0Lep7rrPHYuOaaa4L2Reg6X1u2bPlHsx3/bpZxRqy/iYqKMuv6cc2zOnXqpNlGHjPhfPvtt0Gv27Bhw1n9/yL/loIvyRRc1JDB1t9NFS9YsGDQ361Zs8Y0Jhn9Df/d/fv3n/GFnssHtGrVKt1/q27dup4Jvv5ugVrr1rVr18AyHv/FIqtPPvnkWS2y+sMPP6QJqMPdLr300rPa5xnJ6G+56Kl9aYjQxV7/LvgiBgL21zHwTM+8efNSChUqlOG2M/gLXaolJiYmpWjRomFff8cdd2R43Bw5ciTdhW25YKyF/6c9OOZisZkVfGV0a9asmVmCJpwhQ4YEXnfBBRec1f8t8l/QsKNkCtbycMFVThXnV6+w1ojDM6wz4gKkHB578sknzVIFdrVq1TKz9J555hkzJMlCWf4Np7xfeumlZiiKdUX2RUz/Doc8OOzFwmh+fQuHlDh7jsNJHJ77p4XyWRHrfjhcw33O4SMW83P/sVaI9UececeZeCzC/y9qvizcl/ws+/bta4YzuYQEh+84m4//Z+iSEJdccokZ0uJyIhw24tIOHGLjDFEOOXFphgkTJgQNV55LLVq0MEXyHErj0h98HzxGWffFYdwzEboMQkaF9vy+RNZ2cckPDolZ5wYXmb3qqqvMZzRz5kyzFEVoPdaiRYvMTEAet3yeQ7/cV2+++WaG74+fCWcGcvFY7u/0hgL5b9q/Lsn6kuqzZS+EP5NZsHZcmHjYsGFmyJVfOcXjl+ctJ0Jw/0ycONGcu+l9YbZ9timXrBBxWgQjMMf/VxERn+EK91bQwiJw1lQx4HGj33//3Sx5wVo8BoWsKQutncwI6ygZGLFmjkE46w3/ixrDM8GaO2vWNYNa1jmGzigWOdeU+RIROUeYvXrhhRfw4IMPBmW+mAF0a+BFDJQ4WYA46eWll1466wystUQIvzzcqcCLRo8eHbg/aNAgBV6SKZT5EhE5RzjbMnSBT36X5sqVK12/thRnXnKBZK4uz0zejh07zniInstz8FsbuNbcTz/9FPR9pecSl6fh92RyDTQOUW7atMkMI4s4TcGXiMg5Dr5YP8VhOa7pxTo21imJiH8p+BIRERFxkGq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtEREREwZeIiIiINynzJSIiIuIgBV8iIiIiDlLwdZaOHwcGDwZKlQJy5QIaNwbmzIFvHDkCPPEE0LYtUKgQEBEBfPABfGHFCqBfP6BGDSBPHqBsWeC664ANG+Ab69YB114LVKwI5M4NFCkCtGgBzJgBXxo5MvUcqFkTvrBgQer2hrstXQrfWLkS6NQp9RrI84Cf/yuvwPNuvjn9z5+3Xbsy+x26R2RmvwE3HnxTpwIDBgBVqqQGHu3bA/PnA5dcAs87cAAYNiw18KhTJ/Vi7BfPPgv8+GNq8FG7NrB3LzB2LFC/fmrD44cGePt2ICEB6N07tQNy9CgwbVpqQ/TWW0DfvvCNnTuBp59ODcT9pn9/oFGj4McqV4YvfPst0LEjUK8eMHQokDcvsHlz6vHgdXfcAbRpE/xYSgpw551A+fJA6dKZ9c7cJyIlhbtOzsTy5amZruefBx58MPWxpKTURrdYMWDxYn9k/uLigBIlgJ9+Sr0Av/9+alDqdfx8GzYEcub867GNG4FatYBu3YCJE+FLyclAgwap58Lvv8M3evQA9u9P3X52Stauheexs9W6NfDpp6nHvN8cPgxUrQo0a5baCc+msSMsWgQ0b56aBX7kkcz+hNxDh85Z4MmWPXtw7z46GrjtNmDJEuDPP+F5UVGpgZcf8YJrD7yI2U8OQ/72G3yL50SZMkB8PHzj++9TrwcvvQTfYgb01Cn4yuTJQExMaqDBwCsxETh9Gr7GfcIhxxtuyOx34i4Kvs7CL7+k9nrOOy/48YsuSv25atV/+dGIGzBvzIsxa5/8hI0Osz0cbnnxRWDWLOCyy+ALzHTdey/Qp09q1tOPbrkl9TrIziczYcyC+8HcuanbzdqmatVShxz5+113pWZ+/ebkSWDKlNSOKYcd5cyp5uss7NkDlCyZ9nHrsd27z+ZfEy+YNCn1Qsw6OD954IHUGi9iBqBr19T6Nz94883U2jc2xH7DzO8116TWubLDsX498MILqcNOHJZnHZSXscyA2b7OnVNHPJ55JnUo9tVXUzO/H30EX/nmGyA2Frjxxsx+J+6j4OssHDuWOuwWir0/63nxD9Y33XMP0LRpagG6n3DCCWt+2OFgz5fZoBMn4HlsaB5/PLXQumhR+A4zHLxZONGCxwEnoAwZAsyeDc/P9uYkExaYW7Mb2fHgsc/OCDthLEXw05Bjjhyps77l7GjY8SxwaQkWnIey0s18XvyBMx2vugrIn/+vWkA/ueCC1FlPvXoBM2emNkqcAeb16TuPPZa6vACHHeWvWY7MBHHGN4NwL7Ou8ddfH/y4Ve/E2l+/4Dn/5ZfAlVcChQtn9rtxHwVfZ4HDixx6DGU9xqn34n2HDgHt2qUOM7Cnr889NfvBddC8vOYZh5zefjt1mQVm/LZtS72x88XaF94/eBC+xAkXzP6wFtDLrHO9ePHgxznbnTgT3C+++CI1C6ghx39GwddZqFs3tXHhdGO7Zcv+el68jQ0tMzw8DpjxqV49s99R1mANuTMw9SrW9nFmG4OvChX+uvH85/HA+36r/bNs2ZJafsECdC/jkioUupioVe/rp6Fo1rvy8+bQs5w9BV9n2btnWp29XwuHIbnOFdf/Yu9PvIuffffuqUMLXOeItV5+s29f2seY9ZkwIXVIxsvBKNfz+/zztDcuNcJFh3mfRdhexnXNQq1eDUyfDlxxhffXvbJqm8aNC3783XeByEigVSv4Ao8DTji5+urUFf7l7Kng/iwwwOLq5iwsZSPEWofx41OHG0JPRi/jrDYOuVm9PX61jLW6M2thWAfl1Rl+bGSY+eLwUuiiqj17whcrXDPzy68U4mrWrH1jD5iTD0aP9nbmg7P7unRJ+7i11le457yGnQ8G2Sy651AbZzuyM8oGeNQoeB5nc956K/Dee6mzHlu2TJ3tyM4Y2wW/lCB88knq9mvI8Z/TCvf/YNiJM53Y8HJ8n7N8hg9PLTr0C67nwqn24Wzd6t31XtirXbgw/ee9XmxOH3+c2tH49dfUmX/58qUOxTDo9uvwA48Lv6xwzxl+DLY3bUoNwjnMxvXd+H2vfvl6IWZ6+bVSHPFgB7RcudRZz5wB7BfM+nOomdvvt8lG/xUFXyIiIiIO8vgIvYiIiEjWouBLRERExEEKvkREREQcpOBLRERExEEKvkREREQcpOBLRERExEEKvkREREQcpOBLRERExEEKvkREREQcpOBLRERExEH6Ym0RETc5fTr1izXlL4ULA9mUSxD3cGXwlZKSgqNHj8Kv7NufO3duREREwE/8vv3k933g6+3fvx95KlSAn/E77INagK1bU7/l2yd8ffyHcOv2u/KLtRMTE5E3b97MfhsiIo4rwvjL5/s9EYBaAKEjR44gT548cBvlaUVEREQc5MphR7uYmBhXRr3/xr59+1CxYkVzf82aNSbt6icHDhxAkyZNzP05c+YgV65c8JuDBw+iU6dO5v7EiRMRHR0NP4mPj0efPn3M/dGjRyMqKgp+EZ2QAAwZktlvI8vo3bs3cuTIAT/hkOPkyZPN/Xbt2iF79uzwk+TkZMyaNQtu5vrgi4GX34Iv+/Yy8PJb8GXfXgZefgy+7NvMwMtvwZd9exl4+Sn4ijpxIu2Ds4cCBX0yEBd3BGg7PPArAy+/BV/27WXgFRnp+qbcd/SJiYi4HQOvwvky+12IyBlSzZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDgo0on/5Phx4PHHgQ8/BOLigNq1gREjgMsvh+scP34cjz/+OD788EPExcWhdu3aGDFiBC5348b8A4mJiXj99dfxyy+/YNWqVYiPj8eLL76I7t27w+vWrVuHmTNn4qeffsLu3buRP39+1KpVC3fffTfKlSsHP9i+fTsmT56MTZs2mc8+KioKZcqUQdeuXdG4cWP4zVdffYUvvvgCpUqVwlNPPQWvW7B0A1r3fCnsc0s+HYQm9SrAD3jMX3XVVahUqRJy5MiBAwcOYNGiRViwYAG87N5778Wll16a7vO33XYbDh486Oh7citHgq+bbwamTgUGDACqVAE++ABo3x6YPx+45BK4ys0334ypU6diwIABqFKlCj744AO0b98e8+fPxyVu25h/gCcWg63SpUujevXqWLx4Mfxi/PjxJuBs06aN+exjY2MxZcoU3HjjjeY4qFy5Mrxu3759OHbsGC677DIUKlTIdEZ4DAwfPhz9+vVD27Zt4Rc8F77++msTgPpN/96t0KhWcIejcrmi8IMLL7wQd955J3bu3IlZs2aZc6BIkSIoWLAgvO7bb7/FmjVr0jzO/cFrgwKvLBR8LV8OfPwx8PzzwIMPpj7WqxdQsybw0EOAm9ru5cuX4+OPP8bzzz+PB/+/Mb169ULNmjXx0EMP+SIQKVasmAlA+HP16tVo164d/IJB1siRI01P13LFFVeYrB+DL2ZAva5Ro0bmZtehQwfTGWEGyE/BFzthFStWxOnTp3HkyBH4SfOGldGtXX34TXR0tLnmMwv+zjvvICUlBX7yxx9/mFtoMMr98v3332fa+3Kjc17zxYxX9uxA375/PRYdzfQksGQJ8OefcNXFNnv27Ohr2xgedEy1LlmyBH+6aWP+IfbyGXj5UZ06dYICLypbtqxpgLdu3Qq/4jnBnr+fApANGzbg559/9sVwe3oSjiTh1Klk+Ak7Hiw3mD59ugm8cubMiYiICPhZ8+bNTQdEwVcWy3z98gtQtSpw3nnBj190UerPVas4fg5XYJ1T1apVcV7Ixlz0/41hRoi1AOIfvAAz1c4AzE+SkpLMcMvRo0exbNkyE4jwIuwHbGg++ugjU2Zw/vnnw49uefhDHEk8juzZs6F5w0p4/uGuaBgyDOlF1apVM8PuDMDuuOMOFC9e3JwLHBVh5/zUqVPwW8fr4osvNtmw/fv3Z/bbcZVzHnzt2QOULJn2ceux3bvhGnv27EHJMBtjPcYibPEX1nyw1oE1D37y7rvvYvbs2eZ+tmzZ0LRpU9x1113wg4ULF5p6v4EDB8JvcubMjmuurIf2rWqgSMG8WL9pD14YNxfNe4zB4ikPol4Nb3c+mfXn8c7znWUmX375pan/bN26NXLlyoX3338fflKvXj2TjOAkHMliwdexYxyqSvs4hx6t592CPZ5wxbUcerSeF//gUOOoUaPMjFfWPflJ586dTeaHQQhneTEbdPLkSXgdh1bZ4PLzzpcvH/ymWf1K5mbp1KY2urWth9odRmLIC19i9vv94GW8/vPGIbZPP/00MOIRGRlpMr+cDe2nDBC3mee9H+qdXVfzlStX6lIToZKS/nreLdiz4VBLKKadrefFHzi1/L777kPevHnx3HPPmfS7n3B4vW7dumbW4xNPPGHOgWHDhnm+AJmTCvLkyZPhdHu/qVy+GDq3qYP5SzcgOfk0vMzqYHC5GbsVK1aYn34qP2DSgSU3DD4TEhIy++24zjkPvjgix6HHUNZjpUrBNTi8yKHHUNZjXOtHvI8Xmv79+5ssyNixY1G0qD+m2GeEdR8bN27Erl274FUxMTEm48HAi2ucMQDnjQ1ycnKyuc918PyoTMkCOHHyFBKPhulpe8ihQ4fMz8OHDwc9bgUfuXPnhl9wXT/NcszCw45166au58Vj1V6nvmzZX8+7BXv6XM+LJ5696J4Fx9bz4m3MfN5///1msdE33njDVz3djFgZYS8HHwy4mNnjcjO8hRoyZIjJBPbo0QN+s2VHLKKjciBvHm+vebZjxw6ztEKBAgVMraeFBfjkpwxQixYtTKkNJxtIFsx8desGJCcDb7/912O8TrMukQtiu2lyYLdu3UwP923bxrDRYZElewGa6eht/OzZwHKRwWeffdbUevkNA5BQnOE1b948UwvDpTe8ipltfptB6I2Pc8FZ3vf6Qsv7Y9MGF6t/24np89bgiksuNMXoXsZZvdSsWbM0mV9eH5j99QMmH3j9W7p0KU6cOJHZb8eVznnmiwHWtdeyV8jVsQEuAj5+PLBtGzBuHFyFAda1115rGmD2eriiOVc937ZtG8a5bWP+hffee89k/zgMQ3PmzAkMvd56661pluLwCq7sz5lu7PFx+7m6uR2/6cDrOMzK5SW4sHDhwoXNV2zxK1W42jfXu/Ny3SML7Dm7K9TcuXPNz3DPeU33+8YhV3QONKtfEcUK5cP6TXvx9ieLkDs6J0YN6gyv43HO4nIGX6zzZLDF2Y4NGjQws3+tYUmvY7DJSQZa2yuLf73QhAnA0KHB3+04cybTlnCdCRMmYOjQoUHf7cgZLmyQ/eLNN980FyELgxArELnmmms8G3xxYU3iBSfcRccPwRdnNzHY5ufNIRYGW+yE3HLLLb78bke/6XJ5HUyavgJj3puHw0eOoWihfOh6RV08cW97U3jvB1xWgWv7cXkVLrzM+5z5yJIUv2jZsqXJgof7qiHJQsEXV2Lg1wvx5nYsMOTXC/HmV34d47cPN/sVL7q8yV8GDRrkm93Rv3drc/MzLqti73D60cMPP5zZb8H1vD1ALyIiIpLFKPgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHRTr5n4mIyL90+nTax7bGAHFH/LFr4xPNjyL//zXvsWM4ERmJlIiITH1bIp4PvlJSUgL39+3bhzx58sBPuM2W/fv3+277Dxw4ELgfGxuL3Llzw28OHjwYuB8XF4dcuXLBT+Lj4wP3Dx06hOjoaPhFNtv5H9BjDPyEZ/w265dJkzC4e3ck+ugYOHr0aOB+UlISIiNd2ZT/Y8nJyWHjATeJSHHhO2fwUbx48cx+GyIijmPGZ7/P9ztzX3kz+01IlhATE4NixYrBbVTzJSIiIuIgV+Yq7cNMjHr9NuzGzF/FihXN/TVr1vhu2I3Djk2aNDH358yZ47shN2vYsVOnTub+xIkTfTXsZg079unTx9wfPXo0oqKi4BfRCQnAkCGZ/TayjN69eyNHjhzwEw47Tp482dxv164dsmfPDr8NO86aNcvcd2v758rgK8JWWMnAy2/Bl317eeC59eD7p+zby8DLj8GXfZsZePkt+LJvLwMvPwVfUSdOpH1w9lCgoE8G4jixoO3wwK8MvPwWfNm3l4GX32q+0osH3MS/n5iIiFcw8CqcL7PfhYicIdV8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgxR8iYiIiDhIwZeIiIiIgyLP9X9w5Ajw/PPAsmXA8uVAXBzw/vvAzTfDlTZu3IihQ4di0aJFOHjwIMqWLYsbbrgBDz74IHLnzg2vW7NmDUaNGoWffvoJKSkpaNCgAR577DHUrFkTXnP06FFMmDABa9euxbp163D48GE88cQT6NSpU5rXbt26FaNHj8aqVauQI0cOXHLJJRg4cCAKFiwItzp27Bg+++wz/PHHH9iwYQOOHDmCAQMGoE2bNkGv4/Pfffed+blt2zYkJydj5syZcLukpCR888035rPljcfDzTffjIsvvjjwmtOnT2PJkiX45ZdfsGPHDiQmJqJIkSJo1KgRrrzySnMsuNWRxCQ8/85cLFu9DcvXbEPcoaN4/9mbcPM1TYNe987HizDxy+X4fUsM4g8fQ6ni+dGqcRU8ce9VKH9+YbhVVFSUOdbLly9vbnny5DHXg6VLl6b7N9myZcOjjz6KkiVLmnNn7ty5cLPo6Gh06dIFVapUMbd8+fLhlVdewfz584Ned++99+LSSy9N8/c7d+40z0kmBF8HDgDDhgFlywJ16gALFsC1/vzzT1x00UXInz8/+vXrh0KFCpkLLxvkn3/+GV9++SW8HnjxRCxVqpQJLNjwjB8/Htdccw2++uorVK5cGV4SHx+Pd955ByVKlDAXHn7G4cTExKBPnz7Imzcv7rnnHhO0fPjhh9i0aZO5WLu1AWaw+dFHH6Fo0aKoUKECfv3117CvYyD+7bffmgaK+2rXrl3wAgabDCJ5npcpU8YEl6FOnDiBDz74ABUrVkTLli1N47RlyxZMnz4dv//+Ox544AFERETAjQ7EJWLY2K9RtlQh1LmgNBYs2xj2db+s/xMVyhRBp8tqo2D+3Ni6MxbvfPIjZs5bi9UzH0Gp4gXgRgy2rrrqKsTGxppjumrVqn/7N61atXJ1hysUj+fu3btj3759pmNVq1atdF/Lc+H1118PeoydEcmk4KtkSWDPHqBECV6kgUaN4FpsUNkgM+tVo0YN81jfvn1NEMJGNi4uzlMnXqjnn3/e9ITYsLBBIgZezPIwG/buu+/CS5jBYOaDP9evX4+bbrop7Ovee+89E3BNnDjR9HiJx8fdd9+NGTNmoGvXrnAjfsY85nlMM+N7//33h31d+/bt0a1bN5MpeOONNzwTfLGT9cILL5ifbHhGjhyZ5jWRkZEYPHhwUMejRYsWKFy4sDlPfvvtN1SvXh1uVLLoediz5BmUKJofP/26HY2ufjbs614fdn2ax7pcXgcNu4zChM+X4eE7r4RbOx8PP/yw+ckRDt7PCDtfPBfmzJmDjh07wgvYpt1yyy2m3atUqZI5H9LDjPfChQsdfX9uds5rvqKiUgMvL+BJSMWLFw96nA0u0805c+aEly1btgzNmzcPBF7WvmjatKlJr3utl8PPk4HX35k3b57ZL1bgRY0bN0a5cuXMhditmLE7k84EX8PAy2u4/Qy8MsLgK1zGt169eubnHvY8XSoqKocJvP6J8qVTrxEchnSrU6dOBa75Z4KjAsyCL2d9jUdwHzDwOlNsB3PlynVO35NXqOD+LDClTLfddpup7eEw5CeffGJ6+/379zdpai9jWpmZr1A82fgch1n8hul41v6Fy24w+xVuqEq8z2q0mQ3xi9i4I9gXm2CyZLcM/tA8dlmzavADdrSaNGmCqVOnmlpYP2IHbNKkSZg8ebIZCeKoULj2QhwadvSStm3bYvjw4Xj66afNkIKFBZYjRoyA1zHtzLonppezZ89uHmPQtXLlSnN/79698JsDLGr8/xBlKD526NAhs4+8nhWVYLNnzzadkoxqZLym9MWP4PiJU+Z+4YJ58Mrj1+LySy6EH1x33XXm2siJGfaRAb/g8OQXX3yBzZs3m+wXM7/t2rUzdaCckMXSHAmm4Oss8WBiTQdrnVjXwUJzBmMsNGYRvpf17t3b1D2wiJj1TDyhXnrpJZP9sWaH+c3x48fNz3BF9VbAxdco+PIPXhNY63XjjTf6Yga0Zda4e5B04hR+27TXzH5MPHoCfsCMV+nSpT1X83o2WO9qx7ro3bt3o2fPnmjWrJn5XYIp+DoLH3/8sUmlctr9+eefbx5jMTWDEBbdXn/99SYg86pevXqZE4rDrFOmTDGP1alTxwRiL7/8sq8aGotV63Ty5Mk0zzHjZX+NeN+KFSvMrGdOQrHKFPyiddPUIcZ2LWugc5vaqNl+BPLmjkK/Xt7dDxxW69y5s6ntZPZH/sLJRmwTa9eureArDNV8nQVOo2U61Qq8LFz3iWsAca0fr2Pma/Xq1fj888/N2k6zZs0KpJQ5LOk31nCjNfxox8dYsK2slz9wRixnvnKokT1+P6tUrijqVT8fk6avgJdxHTBOuuCQI4cbebMmqbAzyt+tEg2/YeeTy7VwuQpJS5mvs8CZLOFmf1lZD84M8YMCBQqY2XyWH374wcz089o6X2eiWLFi5phgwxuKC7OeydpA4n5c24udMxZe33HHHb5tcO2OJZ0M1IB5Fc99TrR6/PHHw9YI88ayFC426jfMCjLwYt2rpKXg6yywIeVikhx2tDeqXIiSRYZMr/oNh1g485MXH+4DP+LKzlyMkxMOWPtHnG6+fft28+0H4m1cTuLVV181JQdczdtPmc5Tp5KRkHjcLK5qt3z1Nvy6YTdu6NgQXrZgwQKz+LQdZ7iy3o8LcPO5cFlxL2G9KzsboTW/nITANsEPI0JZNvgaO5arhQO7d6f+PmMGv3Yg9T6/eeBvltLJMgYNGmSG2bimE4vrebFlo8vHuMI5V373Mn6txpgxY8xK3uzxcZYjl9po3bq12X4v4vYlJCRg//79gSyfNcGAKz+zZ3frrbeadc6Y8WCNA4eguTgpM4HhvorIbXUbXL+Ny2lYQaXVmHAhSfb6uT+41hlxVX+rPtLKDIb72hG34Hbx87R672xMrdoebhcbF0464T664oor0nwLAL8dwM3D8WMnLEB8wjHsjkld62nGvF+xc2/q/Xt7tTLLKpRp/ii6t6+PGlVKIU/unPj1j914f9oS5M+XC0P7tYeb8VrHWavM9hOHlK37DLy43BBvdtZsRwblLNFwO85a5HlubRe/Osuqbf7666/Nc2wXeG20FliuW7cuGjZsaNoIL6175rrgi4vibt/+1++ffZZ6I5ZGuCX44izHxYsX48knnzRDDPzaCX7tCle+fuihh+B1zOqwh8OCezY2/MoVbjeDDtY9eBGDKPtCmWyMrUCDq1kz+OJ+4dcQ8QLEDIj13Y5cEd7tWRDW9lnBJvH4540YdPPCy4xf6Gwn63d+56ebgy9munmeW9iYWEurcJYbWYEpv8svFBcgdnPw9cK4udi+K3X76LNvVpkb9ex8EUoVy48+1zXD/KUbMHX2Lzh2/KR57PoODfHYPe1c/d2OVk2XfRIVa36tBXQZVPhhhjcXj2Unyn5M80Zc0Z5tAb9ijJOveE1gh4TXBF47OTLi13XP/k5Eigv3DD9sa/FCFvR5fXHTUGwMrVX2mWnw2yxDZl6sIV5OYfbjisps8C+//HJznws7+m0xQ666bRW1jx071lczSqMTEtBz4MDgB5c9CxT2SWFzbAISGw+GtXwts+5u/f7Uf4rZWH6vLnXo0MGznd/0sL6ao05ujgH8WaQjIiIikkkUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMUfImIiIg4SMGXiIiIiIMinfzPRETkXzp9Ou1jW2OAuCP+2LXxieZHkf//mvfYMZyIjERKRESmvi0RzwdfKSkpgfv79u1Dnjx54CfcZsv+/ft9t/0HDhwI3I+NjUXu3LnhNwcPHgzcj4uLQ65cueAn8fHxgfuHDh1CdHQ0/CKb7fwP6DEGfsIzfpv1y6RJGNy9OxJ9dAwcPXo0cD8pKQmRka5syv+x5OTksPGAm0SkuPCdM/goXrx4Zr8NERHHMeOz3+f7nbmvvJn9JiRLiImJQbFixeA2qvkSERERcZArc5X2YSZGvX4bdmPmr2LFiub+mjVrfDfsxmHHJk2amPtz5szx3ZCbNezYqVMnc3/ixIm+Gnazhh379Olj7o8ePRpRUVHwi+iEBGDIkMx+G1lG7969kSNHDvgJhx0nT55s7rdr1w7Zs2eH34YdZ82aZe67tf1zZfAVYSusZODlt+DLvr088Nx68P1T9u1l4OXH4Mu+zQy8/BZ82beXgZefgq+oEyfSPjh7KFDQJwNxnFjQdnjgVwZefgu+7NvLwMtvNV/pxQNu4t9PTETEKxh4Fc6X2e9CRM6Qar5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBkef6P1ixAhg/Hpg/H9i2DShcGGjSBBgxAqhaFVnWkSNH8Pzzz2PZsmVYvnw54uLi8P777+Pmm29O89rTp0/jrbfeMrc//vgDuXPnRp06dfDiiy+an26VmJiI119/Hb/88gtWrVqF+Ph4s03du3cPel2pUqXS/TeaN2+OTz75BG509OhRTJgwAWvXrsW6detw+PBhPPHEE+jUqVOa13777beYNGkStm3bhuzZs6NSpUro1auX2X63OnbsGD777DNzTG/YsMGcEwMGDECbNm3SvHbGjBn46quvsHfvXpx33nlmu2+66SZER0fDrbZu3YolS5bg999/R2xsLPLmzYsKFSqgS5cuKFGiRNBr9+zZY47zTZs2mc+/du3auO6665AvXz641Yo12zD+s2WYv3QDtu2KReECedCkbgWMGNgRVSsUD7xu+ept+GDaEixbvQ1r/tiFU6dOI2XT63C7cuXKoXHjxqhatSoKFy5sroc8Jnis79u3z7wmIiLCvKZu3booU6aMufbzWPnpp58wd+5cnDp1Cm5VuXJltG7dGjVr1kSxYsWQkJBgrgOTJ0/G7t27A6+7/PLL0bJlS5QuXRp58uTBwYMHzTWT58P+/fszdRt8HXw9+yzw44/AtdcCtWsDe/cCY8cC9esDS5cCNWsiSzpw4ACGDRuGsmXLmgBqwYIF6b721ltvNQ0vG9t+/fqZk5QBi3WCuhVPIgZbPKmqV6+OxYsXh33dq6++muax1atX49133zUnpVsx2HznnXdMQ1ulShX8/PPPYV/38ccfm0D9kksuwb333osTJ06YCzQDFT5+6aWXwo0YbH700UcoWrSoCTp+/fXXsK9jp2TatGm4+OKLTWD6559/YubMmdixYweGDx8Ot5o9ezY2b96MBg0a4Pzzz8ehQ4cwf/58jBgxAkOGDDHnhXWePPfcc8iVKxeuvvpqJCUlmWB8586dePTRRxEZec4vs+fEs2/NwY8rN+PadvVRu1pp7D1wGGM/XIj6nUdh6dRBqFk1tdP19YK1ePfTxeY1FcsUwYat7r7u2YMKdqJWrlyJXbt2mU4Fr2cPP/ywOa8ZcOfMmdNc97ds2YIffvjBBCg8Vzp06IALLrgAL730EtyKxzK3gdf97du3o0CBAmjfvj1eeOEFsw94fhO3NyYmxiQp2PYxUOO+a9iwIe6//36TuJC0zvlVYeBAYPJkIGfOvx5j4qRWLWDUKGDiRGRJJUuWNCcXG172Yho1ahT2dVOmTMH48eNNhoAHq5fwJGLGiz8ZTLVr1y7s66655po0j/GEZa+QWQK3KlKkCL755hvzc/369SaTEw57eDVq1DAXWm4zMQjh/mIQ4tbgq1ChQvjwww9RsGBBbNy40VxIQzHw+OKLL0wP+YEHHgjKhjITzMwxMwNuxAbk9ttvDwqeeB148sknMWvWLPTp08c8xvsMuB977DGTIbEaJHZceB60aNECbjTwtksx+cVbkDPnX9vf/aoGqNV+BEa9+Q0mjrnFPHbXjS0w+I4rkCs6J/o9+Ylngq958+aZjkVycnLgMXbA+DlfeeWV+OCDD0xmi8EIgy/Ljz/+aLJfHTt2RLVq1Uzm2I2mT59ujmF79o7bxutc165dA4Hl22+/neZved6PHj3aXBfYNkom1Hw1axYceFGVKkCNGsBvvyHLioqKSjO0EM6YMWNw0UUXmcCLw4+M/L2C+4CB19k6fvw4vv76azRt2jTDIcmsjr1aBl5/h585AxQr8CIOUTETwn3oVjly5DDblREOybFxCg0wrN+///57uHnYJTRrVbx4cXNMs2Nmb5Br1aoVCLyImWK+lh03t2pWv1JQ4EVVyhdDjSol8dvmvYHHihc5zwReXsOAyh54EYfRrE458Xl74GVhZ9XqxLsVg8bQYVNuOzPbzARnxBpu5DCkZKGC+5QUICaGmQW4GodlmGplb/iRRx5B/vz5TaNbsWJFkxHzK/YYOUTjtUxgejgsxdogDj+yFoJ1IaNGjTI1Utdffz287OTJk+ZnaJBp/c5hOy9JSUkx5z3Pc+KQCoeaypcvn+a1zH5ZQzNe2v6YAwkoUjB1+/2IdXw8tzPCIUr6u9e5Eds5ngPh9guf41Aty29ozZo1mfAO3SFTihEmTQJ27QKGDYOrsWHhxYiNLnvIrPvgwffyyy+jR48e5gRs27Yt/IZpZja+rHvwg0GDBpn6MNaB8Easj3jzzTdN4bWXWXVPHJa1bysnKBCHX7yEwyn8rDt37mx+ZyeDeN6H4mPMijJAZRbRCyZ9uRy7YuIxbIA/zu1QHOVgNpjlBH83ZM0JK9Z54BWseeNoANu8UKzx5WgBMThjvayVAZQsEHz9/jtwzz1A06ZA795wNatXwwZm6dKlgdoW1vuw18vCXL8FX8wCfPfdd6bOKVyD5EWc0ceZURyi5Sw/zpLkBIwHH3wQ48aNM7OgvIpDc6xrYcE9h90YgHFYgrNk2SHhELRXcMiFM73Ys2/GegrA1HpRuKJ6K+DySvD1++a9uOfJT9C0XgX07toEfsNhZM705jAjr/fpYT3YhRdeaCarMADzUkeLNZAsNeDEk1CcXMPgi0OSLDtw80xnzwVfnOl41VXsEQJTpwLZs8PVWNNDDLTsRcUckmCx5cSJE82YuVtnO/0TXG6As71YkOkXgwcPNssL2Gc2sYfIYdfXXnvNDEF6GWf+MevLjC9ly5bNTLTgdHPOEvMCZrg4q5fn/J133mm2kayefrglBawhWS8EXnv3H8JVfV5H/ny5MHXs7cie3V9LRHIU4+677zbBFDM6HPFIrwSB134WpnP2o1cwk8+JBuxY8lxnfXMonu/E2aEsx+H1kPuLE1IkLceiAmbnOVkuPh7gMeniOuwAq5icPaJQzILw4sthB79kgKwhR16owq0F5UVcToAz2rikgB0/c67944e0O4cheEFmoMUaKPaQOTTDKfhunnBhYYPDwJI/H3roIdMQWaxz2xp+tONjLDh2e/B1KOEY2t36GuITjuGHjwaiVPG/tt8PmMG55557TODNCVbhPmvisgw85jnUyKyXV3DtsqFDh5pjmbXNZ7J0BNf7Y+0rO6EKvjIx+EpKAjp2BDZsAObO5UwgeAIbFs56Cde7Z+E1T1o3L7J4trjWCwMRLi7p5ll+Z4NLLVC4niCzIaGzpbyMQZdVA8ZCc+6byy67DG7GDtTYsWPNsT1w4MA0wSSDTJ7jXFw3FBsftw85Jx0/iY5938CGbfswd3x/VK/i3tl7/wRHLe666y7TmX7llVdMUBEOJ1z07dvXHPesfQp3PXAjdhwYcPG45xIr7GyeKWaF3d7xOJfOee6YbQ/X9VqyBPj009RaLy9hDQBrXObMmRO0QOuXX35p6p6s4Qk/4DbzouOnIUc2rvyMuaimfSiCjTUX2mU9lN/wGOD6SAzA01sbzg2sb65gjQ+HGlnrFU79+vXNArRWIE6//fabOQY4DOVWycmn0b3/OCz5ZQs+fbUPmtavCD/h0jG33Xabmb3OgIrBdDjsgHNIkp8/ax2t4Wa343WNdau8hnEiUbj1yviacMtJcFFq1sHyGx8kkzJfXHdx+vTUzBevTaGLqvbsiSyLPV7ObLK+SoGrlluRP1cy55AD6124rAQXGmXPmI9xlhtPwKeffhpu995775mZK2xIiEGmtcYRV/a3plRbQ468EFnFyF7ABVQ5icBat4Z1HNY3FzDwZuaDEyy40CgbaAbcHGqeOnWqKTa/5ZbUhSjdisc8t8cKLFjLwc4FsbaFF14GKDze2Ugx27dw4ULzNSRclPWfrBOXVfC85rAxv+GC+yC0yLoJvycNMKt+c60vLrbJTB8/dy7OyywgV/13qweemYbp361Bx0tr4WB8IiZ+sSzo+Z5dUutct++KxYdfLDf3f/p1u/k54rXUOp9ypQrhpqvducgur+n87LlcAo9zznS047nADgaXVeDQHK+NXO/NjteN9IK2rI5fpcdt5nYyuxv6bSU8zzm6wxo41rgxCcF6XwZdvA5ymP5TZlwkc4KvVatSf86YkXoLlZWDL15M+bUK9uDCWq23Z8+eJtBivdeiRYtMD4GrAbMR4uKiLLZ38/c6WhhI2lPNXDyVN+viZAVf7OHwInXHHXd4KtvHFd7tC2pyDTPerEaXFyUG4Pz+N2b+GLBbi2w+9dRTJiviZp9//nnQ12RxWNn6mimuXs1GiRkhbju/govZAu6LkSNHun6ZDTYmxAAsXO2eFXzxmwB4/jNY4/WBQ1VshDn87uZhl1XrU8/7GfN+NbdQVvC19c9YDH0x+OJu/d7yoiquDb6shUR5HIc7lhmU8Pjn50/h1jXk+n9uDb44kYwYgIUGnlbwxdm+/A5Lfv8j2z0ONbImjJ1UBl76bsf0RaSkN20jC2Mv1FrkkMs9+G0VXTaGVpE/gx72uvyEmRfrYsjA15p16ifMRHEtIWKWzW/TupmRZgeIGPD6pcaQohMS0JPf22a37FmgsE/qS2MTkNh4MKxlXvk1T24Ocv8JZpX4tXbE9RT9NKOemGG31lpzawzgnRSFiIiIiAso+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQdFOvmfiYjIv3T6dNrHtsYAcUf8sWvjE82PIv//Ne+xYzgRGYmUiIhMfVsing++UlJSAvf37duHPHnywE+4zZb9+/f7bvsPHDgQuB8bG4vcuXPDbw4ePBi4HxcXh1y5csFP4uPjA/cPHTqE6Oho+EU22/kf0GMM/IRn/Dbrl0mTMLh7dyT66Bg4evRo4H5SUhIiI13ZlP9jycnJYeMBN4lIceE7Z/BRvHjxzH4bIiKOY8Znv8/3O3NfeTP7TUiWEBMTg2LFisFtVPMlIiIi4iBX5irtw0yMev027MbMX8WKFc39NWvW+G7YjcOOTZo0MffnzJnjuyE3a9ixU6dO5v7EiRN9NexmDTv26dPH3B89ejSioqLgF9EJCcCQIZn9NrKM3r17I0eOHPATDjtOnjzZ3G/Xrh2yZ88Ovw07zpo1y9x3a/vnyuArwlZYycDLb8GXfXt54Ln14Pun7NvLwMuPwZd9mxl4+S34sm8vAy8/BV9RJ06kfXD2UKCgTwbiOLGg7fDArwy8/BZ82beXgZffar7SiwfcxL+fmIiIVzDwKpwvs9+FiJwh1XyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDIs/1f7BuHfDkk8DPPwN79wK5cwPVqwODBgEdOyLLWrFiBcaPH4/58+dj27ZtKFy4MJo0aYIRI0agatWqYf/m5MmTqFOnDn777Tc8//zzePDBB+FWq1atwpQpU7B48WL8+eefKFiwIBo0aICHHnoIlSpVCrxuwIAB5nWh+JoffvgBbrVu3TrMnDkTP/30E3bv3o38+fOjVq1auPvuu1GuXLmg154+fRrTpk3DZ599hu3btyM6OhpVqlTBAw88kO6xktVt2LAB3333HX799VfExMTgvPPOQ7Vq1XDTTTehdOnSgdd16NAh3X+jbt265nxxq61bt2LJkiX4/fffERsbi7x586JChQro0qULSpQokeZ6MWfOHOzduxfZsmUz++jKK69E7dq14VYr1mzD+M+WYf7SDdi2KxaFC+RBk7oVMGJgR1StUDzotWMnLMBrkxZiy45YFCmUB93bN8Dw+zsiT+4ouFXJkiVx1VVXoWzZsub4P3HiBPbs2YO5c+ea88KOx8M111xjrnvJyclYu3atuSYcOXIEblWmTBn06NEDFStWNNf/48ePm7bgiy++MNdFC691rVu3Ntc6XhsjIyNx9dVXZ+p7d4NzHnxt3w4kJAC9ewOlSgFHjwLTpgGdOgFvvQX07Yss6dlnn8WPP/6Ia6+91lxAeVEdO3Ys6tevj6VLl6JmzZpp/ubVV1/Fjh074AWvvfaaaVDYuF544YXYv38/3n//fdOgMCi54IILAq+NiorCCy+8EPT3+fLlg5sx8GYA2qZNG3NxYePLIPPGG2/EBx98gMqVKwde+9RTT2HWrFlmX1133XU4duwY/vjjDxw8eBBuNXXqVNOJuOSSS1C+fHnExcWZz/2+++4znzUfIwaYoTZu3Ijp06ejXr16cLPZs2dj8+bNptNx/vnn49ChQ6YzxoByyJAhgSCUQerHH39sgvOuXbvi1KlT5trB68Fdd91lrhlu9Oxbc/Djys24tl191K5WGnsPHMbYDxeifudRWDp1EGpWLWVeN/i5z/Hc23PQrW093Ne7NdZv2otXP1yAdRv34JsP7oVbFSpUyFzbeL3nZ58zZ07ToeBnOmnSJPMZU4ECBXD//feb857HPf+G141SpUrhueeeM8GYGxUtWtR0JHnM8/zndjEB8eijj+L11183nQ3i8c3tZceTHTV750wyMfhq3z71ZtevH9CgATBmTNYNvgYOHIjJkyebE87SvXt3c4EdNWoUJk6cGPT6ffv2YdiwYRg8eDAef/xxuF3fvn1NAGbf/k6dOuGyyy4zQShvluzZs5ten5cwyBo5ciRy5MgReOyKK64wxwCDLyuj8+2335qghJnOSy+9FF7BnuugQYOCtr958+bo16+fCcysrC57vKGYFYiIiEDLli3hZpdffjluv/1205O3NGrUCE8++aQJtvv06WMemzdvnglG7733XrPddPHFF5v9x8yxW4Ovgbddiskv3oKcOf/a/u5XNUCt9iMw6s1vMHHMLdiz7xDGvPcdbupyESa8cHPgdVXLF8O9w6Zgxndr0PGy2q7NfvNmt2DBAjz88MPmOmgFX23btjWBCdsFBinE0RJ2VBisWK9zm5UrV5qb3ddff206X2wLrOCLnZTPP//cZAZ5vij4ysI1X9mzM6UJxMcjy2rWrFlQ4EHMgNSoUcNkBELxhOSwTM+ePeEFbGRCt5/pZ6aWmdkIxd5dAlOcHsHhY3vgQRx+4D7gcJSFPWAeEwy8OPzI3q8XMNsZuv28qHIfcOghPRx6Z2PDzHCRIkXgZsxu2gMvKl68uMlocPjJkpSUZDK9VuBFuXLlMlmD0HPITZrVrxQUeFGV8sVQo0pJ/LZ5r/l9yS9bcOrUafTo0DDoddbvH3/1M7wkJSUF8fHx5vO1MBvGDocVeBEz38wCMWvqJbzGHThwAHny5Ak8xqwgAy/JosFXYiJw4ACweTPw4ovArFnAZZfBdSceT6jQRmX58uVmmOqll14KugB7DbefJx7T8XYMOBiUMfisXr26GZJJ5Afuwe3nUCKHGYj1HOwZM/hiJpCZHg7TsVfIjJjXWA0P61/Sw6FqfvatWrWCF3EfHD582NR/WXjc8zjg8CPPDwZmDMp5XjBD4iXmGnggAUUKpm7/8ROnzM9cUcGBeu5cqUHnz2vdX4bBAJrBBq/77GTxGsfgilgLyvMhXLkJs18crnY7ZvXYuWBdW8eOHU0md82aNZn9tlzvnA87WlgawhovypYN6NoVsI1cuQIvqLt27TLDi/aLEYcbOBzVtGlTc8J5FQvK2bDYJxIUK1bMFKFzOJa9IqblGYiuX7/eFJyGZg7cjENNHF6+8847ze87d+40n/8333xjtrN///6mUf7oo4/wyCOPmPvMoHoFP1vWvnFINqPXMGPGYTcvWrZsmQlAO3fuHHiMRckMxFn3xRvxs2fpgn1yihdM+nI5dsXEY9iA1IkW1f5feP/jyi1o3bRa4HU/rNhkfvK1bseSCg65E69xrAX95JNPAsGXlf0JZQXpvDawDtCtbrnlFlPra41w8Bx45513MvttuZ5jLeOAAUC3bsDu3QAnx7EG0U2ZSs54uueee0yA1ZuzB/6P9T9MObMOxss41MiAgml0FpVb+JgdZ4JxaI71D6yF4u9ewKFGbhMnX1gz/KwhRl54eRwwACVmwNhDfPfddz0TfHGo8Y033jATLdLL5hw9etTMgmrYsGFQZsgr2PFgHSgDKvvnyswIhyOZEeVwNYchWQ/D/cXZweygeMHvm/finic/QdN6FdC7axPzWP2aZdG4Tnk8+/a3KF28AFo3qWqGJO96/CPkyJEdx5JOwu1Y08faJ36+zPpwNqvVqbSG5sMFVxyCt17j5uBrxowZpnaRIx7sVNm3X1ww7MjJcW3aAL16ATNncsgmdamJlBRkeZzpyCnH7OUwyGKBudWz4RAbC2s5LdermO3p1auXST2zx2Ntf3pYdMkT1M1LTdhxKInFswwoOHvJ2n6m461aKCvwoty5c6NFixZmKMrNF10La1k4o5NDLzze0/v8WevF2g8vDjkywObsRdb6MPPJ49vy1ltvmeHoW2+91XROrGJ7fvYsRPaCvfsP4ao+ryN/vlyYOvZ2ZM/+1/ZPe60v6lxwPm59+ENUaDUUHfu+geva10e96mWQ18VLTVhYasJhRmZ8GFDzvOeMR3uAFS4YsQIz6zVuxdEeDjMyq81JSKxl5IxHcekiq8yCrVjB9YSQ5S+67dq1M0MNnNXBYlsLZ32wseGQI4cbeeNQlNVg8Xe3FyIywOQwE3+y1x+6vlE4bKC4Lgz3mdtxEgGHEzmsxLouTr+2WPdDa+CI28/G1+0F+KzfeuKJJ8xPBmBc7y49vDgzQLvooovgJczovfzyy+Yng3Cr5o+4BAvXdGLGy477gQX7mzalDr+52aGEY2h362uITziG2e/1Q6nif20/lS5RAIs+eQAb5j6J7z8aiJ2LRuK5wV3x5544VK3gjayfHbNgnN3KjKY13GgNP9qxFozXDS90wOyYBePkM3tbKGcv03KHVpsUZqg8y+DwAYePuOAkF9ZjoaUdiywZZLHgOtTTTz9tbr/88ouZDeNG3H4OsW7ZssXUOJzpgqG84DATkFFD7QZcVJDr93D9GvZ4OZxqx+CL28jMYLhsGXvI9llBbsOOA+sb2fPl0hqc6Zgeft4cfueQZOgsSTdj1oJBN7MfrOEKbXDYKbFqgUKxPibc426SdPykyWRt2LYPc8f3R/UqJdN9LWdC8kbrN+4xy1Dc/P/hSS+xZrCyk8lznx20cOcGAzSrM+4lVsbfzdc2X2S+wrRLYBZ2wgQevKmr3WdFvHAyo8UVrj/99FNT6xWKGREOK9hvHIKgm2++2fzOFbHdiNvP4ZWff/4Zb7/9tqnjCRechVvB+cUXXzSF6OHWgHLT9nOIjel2Lrib3krlXPuLDTMXYrQwIGcWiPvMPjzltu3ndrPWkcuocOmJjHz//fcm0PDSkCO3h+czOx88F8IVzzP7wRnOrHXjMW8PRlknmVHAmtUlJ59G9/7jzHISn77aB03rB3c+MtpvDz33uZnxeOcNqYXqbhSubpHnc+PGjU3HhOUoxA42yw6Y7bbPgGUdIJ9zq3DZPJYc8By3VruXLJz5uuMO9g6BFi1YG5P6FUOTJrGAHRg9mgc4siSu3M3Vipn54oU0dFFVrufF4svQBRSt2Y7Mhrm52JxDTFwugQtNcviQMxdDZwBxyIXBB7fTapgWLlxoptwz8LJmyLgRA0huC2u3mN3g4oJ27f+/cjBnArG4moXVHJ7lBZv7ikMNXJDUrcaNG2dqXDiEyACbq1zbhQbWDDY5/GqvfXM7fqPB6tWrzZAih13tATZxAU3WQXJ5EdY3jh492lwP2Cnh/mDWjCULbvXAM9MwnYukXloLB+MTMfGLZUHP9+zS2Py8b/gUJB0/hboXno+Tp5IxefoKLF+zHeOf64WypdIOybvFDTfcYOqbOHRsLbHC84GlF6z9ZQBCnO3Mz51D0vzcrRXumTFm592t2OFg/SprV60ldjiZiMtn8NtOeJxbIwDWgspWO9CNdUX/H5bndVQyIfjq3p0XcuCNN4DYWH7tTOrq9s8+m/oVQ1kVpxNbMz14C+WVxVTTY63szMDCWsk4NPjixYgXGWY92FCxx8tUOzNGoUXJbsOhZuK28RbKCr447MhAhWu8cSkSBl3Mkg0fPty13+tIzPZYa9jxFsoefHFohQ0Ug3A3f+ahrJ49AzDeQjH4IgbdbJAWLVpklmMhngcswHfzMbBqfeqQ2Yx5v5pbKCv4YmH9Sx/Mx6TpK5AtIgIX1SmH7yb0D1p6wo2Y9eesVi4zwU4Vgw2WmnBEw/7djsx0s7PGayKXILF/t6Ob6704gYZlBFzBn50M1q/y67YmTJhg1vOzZ39Dl5+xfud+UPAVXkSKPVfuEuyFWilh9sr9NvbMOgOmtImNHnsnfsJ6KmsYkA2efbVpv2BPlFlJYi+cPXQ/YSbC6gCxJsuqQ/GD6IQE9Bw4MPjBZc8Chd39fapnLDYBiY0Hwxo04dc8eanO8Exw8gfXUyQufeO3pR9OnTplljJycwzgnW6qiIiIiAso+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQcp+BIRERFxkIIvEREREQdFOvmfiYjIv3T6dNrHtsYAcUf8sWvjE82PIv//Ne+xYzgRGYmUiIhMfVsing++UlJSAvf37duHPHnywE+4zZb9+/f7bvsPHDgQuB8bG4vcuXPDbw4ePBi4HxcXh1y5csFP4uPjA/cPHTqE6Oho+EU22/kf0GMM/IRn/Dbrl0mTMLh7dyT66Bg4evRo4H5SUhIiI13ZlP9jycnJYeMBN4lIceE7Z/BRvHjxzH4bIiKOY8Znv8/3O3NfeTP7TUiWEBMTg2LFisFtVPMlIiIi4iBX5irtw0yMev027MbMX8WKFc39NWvW+G7YjcOOTZo0MffnzJnjuyE3a9ixU6dO5v7EiRN9NexmDTv26dPH3B89ejSioqLgF9EJCcCQIZn9NrKM3r17I0eOHPATDjtOnjzZ3G/Xrh2yZ88Ovw07zpo1y9x3a/vnyuArwlZYycDLb8GXfXt54Ln14Pun7NvLwMuPwZd9mxl4+S34sm8vAy8/BV9RJ06kfXD2UKCgTwbiOLGg7fDArwy8/BZ82beXgZffar7SiwfcxL+fmIiIVzDwKpwvs9+FiJwh1XyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOCgSDhs5EnjsMaBGDWDtWmRZ69atw5NPPomff/4Ze/fuRe7cuVG9enUMGjQIHTt2NK85ffo0JkyYgM8++wy//PILDh48iAoVKqBHjx548MEHER0dDbf6448/MHr0aKxZswb79u1Drly5ULVqVdx111244oorAq+bNGkSpk2bhk2bNuHw4cMoXrw4mjZtigceeABlypSBW23evBlvvfUWfv/9dxw4cMB8lhUrVkSvXr3QokWLsH9z8uRJXH/99di6dSvuu+8+81q32r59OyZPnmw+1/j4eERFRZnPs2vXrmjcuHHgdS+++CK+++67NH9//vnn480334Sb7dq1CzNmzDD7gsd2zpw5UbJkSVx55ZWoU6dO0Gt5Lfj++++xcOFCxMTEmNdyH3Tv3t2158G6Dbvx5Ctf4ed1O7B3/2HkzpUT1SuXxKA+bdDxstqB10VUvjvdf6PNxRdgzvj+cCN+1ldddRXKli2L8847DydOnMCePXswd+5c/Prrr0GvrV+/Pi677DJz/eOxwNfNmTMHa7NyI/c3eNyyLeN1r2DBgjh+/Dj+/PNPfPHFF/jpp5+CXtuuXTu0b9/ebD/PlR9//NFcP/g3kgWCr507gaefBvLkQZbHC25CQgJ69+6NUqVK4ejRoybI6NSpk2mU+/btax675ZZb0KRJE9x5550oVqwYlixZgieeeMI0SPPmzUNERATcaOfOnThy5AiuvfZalChRAseOHcNXX32Fm2++Gc899xx69uxpXseLCy9ODMjy589vTk4GZLxA8ca/dSNePPn5dujQAUWKFEFSUpL5PO+//348+uijJggJ9cknn5hA3QsYcPMzZ4NSqFAhcxFdvHgxhg8fjn79+qFt27aB1+bIkQP9+wc3sOysuB07U/zc2ZkoUKCAaXxXrlyJsWPH4qabbgoKwj/44AMsX77cXAsuvfRSs7927NhhriFutX33QSQkHkfvq5ugVLH8OJp0AtO+WYVOd7yJt0bcgL49LjGv+/CF3mn+9qe1O/DyB/NxxSUXwq143LPTsXTpUhw6dMgE1HXr1jUdUF7jGGBQq1atcN1115mAjK+NjIw0x8Hdd9+Nt99+G6tWrYIbFS1a1HQ658+fj7i4OLMvuF28/r3++usmuCSeC7we8vowc+ZM0+lgIMbgbdiwYZm9GVlWREpKSopT/1mPHsD+/UByMnDgwD/PfCUmJiJv3rzmPgOEPA5Fc8nJyWjQoIG5IDMjwosxewDNmjULeh0POAZgPDjbtGlzThpG9jCImQmnGjpuP3v9bFh++OGHdF/HbBkb5yFDhuDee+/9z98HM1G1a6f2vBctWmSyck5tP4NObj+znaEN9dVXX22eZ8bnXGe++P9dfvnl5v7UqVMdybJy+wcMGGAyfFZWi5kvNkJ8D05iNs7qADAYYsPgBGY1GICeOnXK/KQVK1aYRpaNMjMg51p0QgJ6DhwY/OCyZ4HC+c75/52cfBoNuoxC0vGT+P3bJ9J9XZ8hE/He1CXY8f0InF+y4H/7JmITkNh4MFJbAKBPnz6mA+AEdqYffvhh8/9ZgQWv9eyosFNq4fn49NNPmxEEdtb/a+wYjh8/3txnB5EBnxOyZcuGF154wWw/r+3MiPHYZ3vwyiuvBGXCmKAYOXJkmizZf+HUqVMm0HM6BnBlzdf337ORAF56Ca6VPXt2E83zwk/sCYUGXsRGmH777Td4CbefWUCmlTPCng/93evcuP0Menmyh3r11VdRrlw50+PzKm4/s4Dhtp+BGRsEr2Pjw4yIfVvZyWK5AQMvBmdeHmrJnj0bypQogPjDx9J9zfHjJzHtm1/Q8qLK/33glcmYq+D1397hY6AVmuFkB53HATsqXsLjm51fK9ipVq2aCfzYCbazfr/kktTsqKTlSLjMTBcTIH36ALVqwVWYZWOvhmnn6dOnY9asWaaOIyPW0BMbKrdjI8Pt58Xl22+/NSloDr2Gy8TwxGSdzJgxYzxz4nHbeSFlwMGaHqbWrYyThUOv7IWNGzfOtcPM6bEaER4Hy5YtMzWQzZs3D3oNn+ewC38yI92yZUszPO1URvJc43Yxy81jYfXq1ebzbtiwoXmOj23bts0MPTEbyqFpvp7nPodiGjVqBLdLPHocx5JO4lDCMUz/bg1mfb8e3a9qkO7rv164zgRnN3a6CF7ATjYzPTyemXFn7S/PA8vGjRtRr149cwww68/X8j5fz+ul2zGrzH3AgIvHMzsZVnBlZdx4fthZHZBKlSplwjt2B0eCL45QbN8OzJ0L12HhuJU2Zq+XF1QOc2SE6WcWaDL16nZPPfUUPvzww8D2M7PDVHIoDsdaJxxT0RySYSPsdhxWY62ftf2tW7fG4MGDg3rC/LwZkPHCvHv3bnjJu+++i9mzZwe2n/VPHF6z8LO+5pprzEWWwTdrolgbyEkHzzzzjMmWud2UKVNM4E0Mrtn43HDDDeb3/fv3m2OAQ4/cP926dTONLms+33nnHXO/Zs2acLMHnpmGtz5KbWyzZYtA1yvqYuwT6XdAJ325AlE5I9GtXT14AY9vq8PBY5w1XKzvtB8f7HSwA8IbsbP68ssvm/PA7VjXzHITK8PNThiPbbKudxdccEHQ5AIGqFS4cOFMec9ucM6Dr9hY4PHHgaFDWcAH12GNCy+oPMh4kvHgC43y7TjOz0JzFiSySNftWE/BGT+cwcWZX9z+cKn0iRMnmuCLvUAGK14ZguLsRRads5Hl8BIvvvbt5z5h3Z293sNLOnfubDKYsbGxprcbuv3McNkx4C5durSZBczXeyEAZ90mOxccbmL9CvcBzwMrM0jMjLLGkTPDiLMh+TsDUbcHXwNuvhTd2tbH7n3xmPL1SiSfPo0TJ0+Ffe3hhGP4asFatG9VAwXOc/+kC2I2k50KXs8ZeDPIttdY8Xzg9ZFF6QxAmCniNYM1TxwF4LXDzXiNY8afw+0XX3xx0PZv2bLF1LUxKcHRD046YGnOHXfcYfYLM2aSSTVfXFaiUKHUYUc3YkTPiy+Lpzm0xIssl5oIN0+BvaHHHnsMt912W1B2wM2qVKliZnVx1iMbVA7DcgZo6PbzpOQsL550LMBkxui9996D27GWh0srsKiVPVkGlZzxyO3nscAsKI8Nt87q/Du8kHKGFxsTFhYz2GChcUbzdBiw8QLNITov4JID7MmzvpOzOtnJYI0f94HVuHCY0Qq8rDogBmDMfFiBmltdUKmEWTKi19VNMPOdu3Ek8Tg69n0j7DHA2ZAsxvfKkCMxsGKAwYzPG2+8YYIr+/WdHVQGJhwh4JJDnPHI6x+zvuFKNNyGpSQcTl2wYIEZ9eCxzRmPFnY8OfTOAnxe+x955BEzCYfHvtU5EYeDr40bgbffBjgLndnJbdtSb/w82Hnm/YMH4SrMgnGIYcOGDUGPMyvCRphZIrevb5QRBiFMu3MdrPSUL18eNWrUwOeffw6vYSDONeC4FAkvtuzdcZkNZkZ544XaGnbg714ruGWQzewmL8jpYeOUL18+Vy+zkBFmwdjY8LO2stssMwjFfcDAy2sF+N3a1ceKNduxYeu+NM9Nmr4c+fPlQofW7s72ZYRZMF7juLQQh9V4rWNwYsdOGq+R9oDcK5gFY6eck6+IGS8GXFxagz8ZjLKjzg6J18owXDPsyOvz6dOpwVfIMkBGhQrAffe5awYkC2yJBfgW9og4w5FFuByadGrab2awejJ/17DydRkNz7qVfZiJEys4o5NZwVDM+vHGhQY5I8grrECCGdD0sOHhfuG6b15kHde8FjDjye20ZkDb8TEWX7t5seVwjiWlbj8L8O327DuE+Us34OauTRAV5czSD5nBynayno8ZXrJ+2jHzFe5xt7OWdQld3oFrI/JmzXhnNpBDthLeOY0SWOoQLvnBoUi23S+/zNkQyJK4lhZ7NnbMYjCi50lnFRRyOQlmu9gT4rCkV2Z4cTpx6GxNbv+nn35qGhOuds+1VhiEhNa2MfXOddCsJTfciL05XjxCt581PLz4sEfL1Z85q8mOdR9MzXNomvVOVu/QbRg4hH6u/Lx5MeX2c2FdBiF8LHSduY8//tgMSTmx5tW5xAAyNKPF7eVCytZq98ROFwvs169fH7gusHPCYVeWLbi1Ad4Xm4BiIWuHnTyZjAmfL0Ou6ByoXjl4qP3jmayHS8GNnb0x5Mgi+tBlVfhZsgyBxz47XwyuWQPIbKh97UOeO5UrV85whCCrY6fCnmSwAkpe86zV7sPhpBSWprCj+s033zj0bt3nnAZfbLu7dEn7uJXpCvdcVsHaJV58We/EAmKeaFzVmEEFv3aHJyYvsJwFwgaXXzvEhtmOM8A4O8yNHnroIXPh4YWGvXsWjXIqPYvLWfvDXg9PTDY8rGtgdoeNMINR1r6x0eJkBbdiAMXsDgMIrvTMgnMuM8LhJtZ8cVsvvPBCc7Oz0uwMzjgz0q1Yy8YMFovFObTCY5w1H/zmA9Y0spPBYTfWQDHItNZ245AMi9LZGHE1bDfjsDIbEA6xcFYnj3dmuXktYLbTymhxBjC3mfVAnPXKfcOvGeKQo5s7IHc8NhmHjyShRaPKKF28APYeOGyGFX/fHIPRQ65B3jzBGb1J01egVPH8aNW4CryAM1r5GVtfscVr2kUXXWSuh1xUmAGI9c0PnJTChZVZksG/YbvBwMzNwQe/tYXXOZZZsDPKgNI6199///3AKACvB9xW1nhx1IczQ3nOcNFVduIlPO+Oj/1LXMuL6zbxgsqGl/UbbFCeffbZQBElH7eif656HIrRv1uDL27jRx99ZDJ9bHgZbNaqVcsUWlrTjtnI8ALFiw8DT56MXIS0S5cuJvBy63faEeu4vvzyS3OR5YWXwSYDLSvY8DpeQFnH+PXXX5tOBj9r9uQ57dz6bkfuEzZGzHQy88MMALNBrH3k7Ce3ZnwsXNOIMzYZSDEQZ8aPC+ly6QFOQrCwUebyI8wKc6Yzgy4G32yU3HwOcC2vcZ8uxhuTf0Bs/BHkyxONBjXL4tlBV6NTm7++25H+2BKDn9fuwMBbL3P9527hWl6cZMFzgdc/Xt/4lVGsZbV/tyMzvayB5Gs52YRYE8oV6Bm4uRWL5jnRht9WwvaPw+zM5LFNYN2zhTMemelnwMmMN2tC2UF38/daeu7rhf4rmfX1QllFZn29UFaRWV8vlJVkxtcLZSWZ9fVCWUFmfr1QlpCJXy+UVWTW1wtlFaf09UIiIiIicja8kR8WERERcQkFXyIiIiIOUvAlIiIi4iAFXyIiIiIOUvAlIiIi4iAFXyIiIiIOUvAlIiIi4iAFXyIiIiIOUvAlIiIi4iAFXyIiIiIOUvAlIiIi4iAFXyIiIiIOUvAlIiIi4iAFXyIiIiIOUvAlIiIi4iAFXyIiIiIOUvAlIiIi4iAFXyIiIiIOUvAlIiIi4iAFXyIiIiIOUvAlIiIi4qBIJ/8zERH5l06fTvvY1hgg7og/dm18ovlR5P+/5j12DCciI5ESEZGpb0vE88FXSkpK4P6+ffuQJ08e+Am32bJ//37fbf+BAwcC92NjY5E7d274zcGDBwP34+LikCtXLvhJfHx84P6hQ4cQHR0Nv8hmO/8DeoyBn/CM32b9MmkSBnfvjkQfHQNHjx4N3E9KSkJkpCub8n8sOTk5bDzgJhEpLnznDD6KFy+e2W9DRMRxzPjs9/l+Z+4rb2a/CckSYmJiUKxYMbiNar5EREREHOTKXKV9mIlRr9+G3Zj5q1ixorm/Zs0a3w27cdixSZMm5v6cOXN8N+RmDTt26tTJ3J84caKvht2sYcc+ffqY+6NHj0ZUVBT8IjohARgyJLPfRpbRu3dv5MiRA37CYcfJkyeb++3atUP27Nnht2HHWbNmmftubf9cGXxF2AorGXj5Lfiyby8PPLcefP+UfXsZePkx+LJvMwMvvwVf9u1l4OWn4CvqxIm0D84eChT0yUAcJxa0HR74lYGX34Iv+/Yy8PJbzVd68YCb+PcTExHxCgZehfNl9rsQkTOkmi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERB0We6/9gwQKgdevwzy1ZAjRpAlcYOXIkHnvsMdSoUQNr164Nem7x4sV46KGHsHLlSpx33nm47rrr8PTTTyNv3rzwkpdffhnPPvssqlWrhvnz5wceX7BgAaZPn45ffvkFGzduRKlSpbB8+XJ4zbhx4/D666+jUqVKmDJlinns2LFjmDFjhtkHmzZtMr+XKVMGV199Nbp27Yrs2bPDKz755BN8+OGHKFu2rNkPFu6LZcuWYc+ePWb7ixQpgkaNGqF79+7Inz8/vOKrr77CF198YY7vp556Kuxrjh49aq4TCQkJuPPOO9GgQQN4xcjXZ+GxMTNQo0pJrJ01NPB4qxtexMLlG9O8/srm1TH7/X7wirZt26JTp07YvXs3RowYEfQcz/M2bdqgcePGKFy4sDkPduzYgcmTJyM+Ph5e0a1bN9x4441m2+677z7zWNGiRfH222+n+zdz5swJul6IQ8GXpX9/oFGj4McqV4Yr7Ny50wRTefLkSfPcqlWrcNlll+HCCy/EmDFjzGtfeOEFE4TMmjULXsELziuvvILcuXOneY4NEoOvmjVronjx4vCimJgYvPfee8iVK1fQ47t27cJzzz2Hiy66CD179jTHyJIlSzBq1Cj8+uuvGDZsGLzgwIEDJsiKjo5O8xyDzgoVKqBFixZm//z555/45ptvsGLFCrz66qth/8ZtDh48iK+//hpRUVEZvu7LL7/EiRMn4DU798Th6Te+QZ7c4bf//BIF8MyDnYMeK1W8ALyiQIECuPLKK5GUlJTmuWzZsuHuu+9GxYoV8eOPP5prAq+T5cuXN+eDV4IvBpXXXHONCSztDh8+jJdeeinN6+vVq4eWLVuaNlIyMfhq3pxRM1zpwQcfRJMmTZCcnGwaIbtHHnkEBQsWNJkPZr2IJ93tt9+Ob7/9FldccQW8gEEEe/HcB2yI7B5++GE8//zzyJEjB3r16oXff/8dXsOLS61atXD69OmgiykvSMwIMRtm4QWKmREGpDwOmAnzQtaPGU9uPy+2oedAqAsuuADPPPOMyYjxAux2U6dONY0rt//IkSNhX8NGd+HChejQoYMJwrzkwVGfoUndCkhOPo0DcWm3P3++XOjZpTG8ilnsrVu3mkArdESDne8qVapg9OjR2L59O7yqd+/e2LBhg9kHVltHx48fN8d9qNatWyMxMdF0wiSTa74SEoBTp+Aq33//vbnwhovs2QgxpcqMh/1gZADCE9QamnK7pUuXmiGX9IZaSpQoYQIvr+Jw8nfffYcHHnggzXMMvO2Bl/3CQ7xgux2H2dmj79u37xn/jZUB5cXX7djg/Pzzz2YYNSMff/wx6tataxpiL/l++UZMnf0LXnos497zqVPJOJKYNjPkdpUrVzZZHLYDoSIiIsy5vnr1ahN4MTDx4rWwevXqaNasmemEnQleFzkSwrbj5MmT5/z9uZFjma9bbgHYYWQJDLNgzz8PNGyILI1ZnnvvvRd9+vQxWY9QHFY6deoUGoZsSM6cOc1FmDVQbsd9wBqWG264wQyt+g23n8OKXbp0OatG1cqQcrjC7dv/5ptvmgwuM7rpSUlJMZ0RZoaYARo/frxpiMKdN27C7fnoo49wySWX4Pzzz0/3dT/99BM2b95sMsSxsbHwCma67h02BX2ua4Za1Uqn+7oN2/YhT637ceLkKRQvch5u734xHu/XHjlyuLvmkcEVa3hZ18vSi3AdT57jPOZ5jWTNF4Mv/v7pp5+awN3teB6zDZw7d66p9ToTPF9YB8fkhWRS8JUzJ4dhgPbtgSJFgPXrgRdeSA3AFi/muDCyLDY67M3woAuHBcZUsmTJNM/xsR9++AFuN2HCBFPHxqE1P5o2bZr5nN94440z/hv29Nhgly5d2vQY3Yx1i/v37zcTTjLCodibbrop8DuL7gcNGuT6IVcOpzCYGjhwYLqvYY0XG1oWXHO7vRR8vTn5B2zfdRBzx/dP9zWVyhZB6yZVUataKSQePWGyZCNem4UNW2PwySt94GbNmzdHoUKFTL1rOMWKFTM/L730UpPl5XlPrA+75557TMeNgZibcVu4nU8++eQZ/w3rP1mewgSFZFLw1axZ6s3SqVNq7Vft2sCQIcDs2ciSeAF9/PHHMXToUDObIxyr8DBcES6LjEMLE92GJw8nDwwYMMDUNvkNAwoG4Oz1MY1+pjgjdMuWLWZ2aGSkY8nl/xwzWZMmTTqjWYscZucMMAYizABx0oHbj3/WdrF2izVc+fLlyzBAZYawPXuYHhIbdwSPvzwTQ+9ph6KF09/+caP+Crrppqsbo++jk/DOJz/i/lu2okm9CnAjTp7hZ8/PN706P+vaz5+scYyLizO///HHH6ZM4/LLL8cHH3wAt+Jxf/3115sSmtBaz/RwNjCHalnzyoy4ZKF1vjjLsXNngKsVJCcjS+JQG3s8HHZMjzXzjQWHoTgrJnRmnNuw18aU+q233go/4vRo1vL16NHjrDKFn3/+Oe666y6TenczLivBoKpjx45/+1oOtXConbM+ebHm9jNb4OYlRziLlw0wsxoZDS9zYg2XFvHCrE67x16cgUL5c+PeXq3O+m8fuK2N+Tl3sXsn3/C459IhnEyVHqueiZ0tK/Ai3mcnhJM03IxDqVw2hTN9zybrReGK8OUvmdYt52gEZ2SzHtdWq54lcJkIrlvCInv7OD8DKp5s27ZtM42yNdxoDT/a8TH2ANyKF5OJEyea3huXWbAw0OQ+4HICbJjPJiPkJqxtYBDFInsOu9m3n3V+PC7YMNszQuzpMeDgbEdmy9yMQyVcLoKzNe2zW/nZM8vDY4LT6dPLCLE+kJ0XNlwMyNyG28d6FWb97LNbre1n0MXOFTNj7KBUrVo1UOd36NAh85ONFh/jfmDdjJts3LYPb3+8yBTZ796Xuj2UdPwkTp5KxradsTgvbzQKFUi7/A6VKZl6XTgY784JFxztYOeJRfb2c5ydDNYy8TNle2B91uGyQvz83TzszvaNmTsusWO/zlv7gPuI2e3QrCCHalmqwjZEsmDwxc+FHcWsuA4pGx4W2vbv39/cQnFNIy4wx8CEw0ostmVRpoVDL1zbxP6Y2+zdu9fsAw678haKhaUMMLyyjlWoffv2me3nEhq8hesVM8PDZUiIQQaH3Zgl4dIbbsdhd27/W2+9ZW6hbrvtNrPgZEYzIHkeuHW2IwMuDplwBiNvoYYMGWKWGGBgymMl3HIbHLIlDj+HWx8vK9u1Nx6nT6eg/7BPzS1UhVZDcd/NrfHSY9eG/fstf6YGokULZcEL/BlgQM2AmdfwcNdxnuvz5s0zCyyzMxZuYg2DNgZgbsUAk0EWO2C8hWKCgtvP4MzCSUlMOnBxWcnk4ItJg9CSqdWrmSUA2rXjTApkOZwiy6xHKGvlal5MubwATy4W2TJDxADFygJwuIa9gWuvDX9hcgOu6RRuWjGHIrltDLoymv3mdvx8We8WioX3DCgYdFmz37gUBRtfTkfnRdltWY5wypUrh0cffTTN4zy22dtl0MWesbXoZOiQG5em4HHi1mUX2IBw4cxwQ5HcZg5Fp9fzZ+eNGTEWKvM44uxnt6lZtRQ+fyNtYM0V7hMSj+Plod1QqWxRHE44hqickYiK+mt5BQatLLi3Vrl3I2a2w3U62OlifRczYsyIMxO+bt26wALT1igBZ0FyyHHRokVwc/afdWyhuMI9z3e2D+ykhxty9MJkM9cHX1wah6VPLLrnxBDOduQ3EbAjOGoUsiTOWOLSAqGstb7sz3EWGNc/4UKSbJCYbuVie5yaz6+jcCsW2LdjdBzi3XffNT/tz61fv97UvVjrWjFAtfYVZ/u5caFZptmttbrsrNlM1nMcXr7//vvNfWZCQmfGMvhwYwDCjkXTpk3TPG4tHmo9x6EFdko41MBglFPzueI9v36KjRGzY27EjhSD6VDW5xvuOYuV5WKGPKPXZWVFCuVFl8vrpnn8pfdTv1bMem7B0g24/v73cH2HhqhcriiOJZ3E53NW48efN6Nvj0tQv2ZZuBE7WFy7K5R13tuf4znBzipHQ6z6sFatWpl6sdlZdUbZGeB1PFzNplUDGvocO50XX3yxmWwQGpRJJgRfjFOYfR8zhuPiqVmwrl2BJ55wz9cLZaR+/frmgjx48GDTCPOizSGZcD0Gr+J0YmbE7KzfmbJ3Y/B1ppjlsDIfnOUYigG5G4OvswnS2flgY8SFaDkEw2npnCXGz96++LB4T7nShdC8YWUTcO3dfxjZskXgwkol8Obw603w5QcMNF588UXTKWeHm5k/ru/12WefBWrC/KB27dqm0xpuMVpJKyLFhXNB2SuxvuKBDV+471z0MtaYWCuIM8vgtnqSf4tFzDzRiWl9t88q/SdYa8RiWOLFzmsz7c6kJovfLEFjx4792+9c9JLohAT0DF13bNmzQAbLQXhKbAISGw+GVU3G2lMvriqfEWbVuJAxsaPj5iVt/gl28mbOnOnqGMD9xSkiIiIiLqLgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHKTgS0RERMRBCr5EREREHBTp5H8mIiL/0unTaR/bGgPEHfHHro1PND+K/P/XvMeO4URkJFIiIjL1bYl4PvhKSUkJ3N+3bx/y5MkDP+E2W/bv3++77T9w4EDgfmxsLHLnzg2/OXjwYOB+XFwccuXKBT+Jj48P3D906BCio6PhF9ls539AjzHwE57x26xfJk3C4O7dkeijY+Do0aOB+0lJSYiMdGVT/o8lJyeHjQfcJCLFhe+cwUfx4sUz+22IiDiOGZ/9Pt/vzH3lzew3IVlCTEwMihUrBrdRzZeIiIiIg1yZq7QPMzHq9duwGzN/FStWNPfXrFnju2E3Djs2adLE3J8zZ47vhtysYcdOnTqZ+xMnTvTVsJs17NinTx9zf/To0YiKioJfRCckAEOGZPbbyDJ69+6NHDlywE847Dh58mRzv127dsiePTv8Nuw4a9Ysc9+t7Z8rg68IW2ElAy+/BV/27eWB59aD75+yby8DLz8GX/ZtZuDlt+DLvr0MvPwUfEWdOJH2wdlDgYI+GYjjxIK2wwO/MvDyW/Bl314GXn6r+UovHnAT/35iIiJewcCrcL7MfhcicoZU8yUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg6KdOo/WrkSePJJYNEiICkJqFgR6NsX6N8frjBy5Eg89thjqFGjBtauXRt4/PTp03j77bfx5ptvYtOmTciTJw/q16+PoUOHolmzZvCSl19+Gc8++yyqVauG+fPnBx4/efIkXnnlFXz66afYu3cvSpQogR49eqBfv36IjHTsEPtP/fTTT7jjjjvCPvfBBx+gVq1agd9Xr15t9s3vv/+OvHnzok2bNmbbc+fODbdas2YNHnnkkbDPvfDCC7jgggvM/ZUrV+KHH37AH3/8gZ07d6JIkSJ477334AXcJm5rOA8//DAqVaqE48ePY/HixVi1ahV27dqFpKQkFCtWDC1atDC3bNnc279dsHQDWvd8KexzSz4dhCb1Kpj7T78+G9O/W4PNOw4gITEJZUoWxFWta+LRu9qiaOF8cKsqVarg/vvvD/vcc889h23btqV5PFeuXHjyySeRL18+vPPOO/jll1/gVmzrRowYEfa5wYMHY8OGDeb+8OHDUbNmzTSv4bWBz0l4jrSM334LdOwI1KsHDB0K5M0LbN4M7NwJV2Cj8vTTT5vAKtSgQYMwZswY9OzZE3fffTfi4+Px1ltvoWXLlvjxxx9x0UUXwQt2795tAqxwAQUDjZkzZ5qAq06dOuak48WJjdHzzz8PN+M28SJkd/755wc10HfddRfKly+PgQMHYt++ffjwww/x559/4tVXX4XbdezYEVWrVg16rGTJkoH7CxcuNMEXA5FChQrBiy677DLz+doxwKIDBw7go48+MsHo5ZdfjujoaKxbtw6TJk3Cli1bcOutt8Lt+vduhUa1ygU9Vrlc0cD9n9ftQN3q56NHh4bIlycKv23ei3c++RFfzV+LVTMeQZ7cUXAzdjS3b98e9Nj+/fvDvrZDhw7IkSMHvITXdiYW7Pbs2RP0O8+DiRMnBj128OBBR96fW53z4OvwYaBXL+Cqq4CpUwE3dgQffPBBNGnSBMnJyeYgs5w6dQpvvPEGunXrZhpcy7XXXouKFSuaC7BXgq9hw4ahQYMGZh/YTyr2+GfMmIEBAwbgoYceMo/16tULBQsWNBnBW265BdWrV4db1atXz2Sy0vPaa6+ZXi63lVkvKzhhj3HJkiVo2rQp3IyB5yWXXJLu8/ys7733XpPhfOqpp9I0Ul7ADAiP/XDOO+88PPHEEyhdunTgMXa8mB1l54uNsRWouVXzhpXRrV39dJ+f9lrfNI81rVcR3fq9gxnzfjVBmZsx8DiTDBbPe2Y7v/76a9Np8Yr169eba1lGjh49ajpicubOeSg0eTIQE8Nhu9TAKzGRQ3Vwje+//x5Tp07FSy+lTb9zuO3YsWMoXrx40OO82HK4gSloL1i6dCm++uor07iGWrZsmfnZpUuXoMf5e0pKCqZPnw63S0xMNIF2qCNHjph90759+0DgRWxwmSGcM2cOvIAXVgbd4RQuXNi1Q8tng8OJ4fYBA2974GUP2sNlCNwq4UgSTp0KfwyEU/78wuZn/OGj8IKoqKi/HUJmp5ud0dAskRcwo/t328/n+To5M+f8qjl3LnuHwK5dbJABDhNz9O6mm4AXX+SHiiyLF1v26vv06RNU42NhcNW4cWPTy2WGo3nz5mbYkePczPz0ZVGby3EfsNbthhtuwIUXXpjm+RMnTpifoSedFXiydsjNGHAy+MiePTvq1q1rMnxWJo8XWe6f0P3CYQcO1XFI0u1Yy8YOBi+szIJxGI2ZID95//33TW0X9wG3nZnu0GHIUIcOHTI/7UG5W93y8Ic4kngc2bNnQ/OGlfD8w13RMGQYkh2t2LhEnEpOxsZt+/Hw81+Y17dqHDxk7UY33XSTub7xXN+8eTM+++wz7NixI02wzdEOjhCwQ+IlbAN5Pef2Mws2fvx4sx9Cs34ff/yxufbFxcWZjueUKVPS7bSJA8HXxo0cngM6dwZuuw145hlgwQKA5TDx8cBHH2Xdj4FF9BxGmcsIMh0c5+7evbup+bLwJOSQA3+63YQJE0zN2yeffBL2edb60IoVK1C2bNk0GTEW4LsRLyKs9bn44otRoEABU7/DoWUG4iwoZ42PNQRdtOhf9S8WFp67udiW288JIw0bNkT+/PlNY/P555+bQlvW8Vmfu5cx4ObkGXa8GEQxi/Xtt9+aekYW3NuPdztmSXnN4DHwd0FaVpYzZ3Zcc2U9tG9VA0UK5sX6TXvwwri5aN5jDBZPeRD1apQJvDbmwGGUbDok8Pv5JQpg8phbcEGlEnArBg6sX2UNH7PcDDBYgsDaTk7E4HXROle6du2KefPmmZIMrwRfPI45mYT74PDhwyhTpgw6d+5sJp8NGTIEW7duDVzjf/31V3ONYIaQ143rrrsOpUqVwujRozN7M/wbfB05wmEL4M47gVdeSX2sa1dmTIC33mItEWsqkOXExsbi8ccfN7MWwzWu9mEHZgSY+WJjzQNx1KhRZtiNhci8ALsVLyS8yDDbk94F5dJLLzUF6OzxsXdUu3Ztc7JyH3A4isM1bsSJA7zZ63h44WWgPXbsWHNjNoTCFdjyImQ970bM5tkzeszwMhBlL5g9X37eXle5cmVzszDzydovZkOZ/eB5Ec7kyZNNoNa/f38TwLlVs/qVzM3SqU1tdGtbD7U7jMSQF77E7Pf7BZ4rlD8P5ozvj6TjJ/HL+j/x2TercOSoe49/YoeLNwsDDHaoHn30UROEsN6TrrjiCvM5f/PNN/ASZu7tE6bYwWYwxhIcJhusmYzWfrCw9ouTkLhfWA9szYoUh2u+rLKn668PfvyGG1J//k0dX6bhUBtnb7GxyahnwAaZmQE2xldffbU56NjrZVrW7TP92MNn1iejGVtMxzMjxGFWZoU4weC+++4zU7T5t25ebiEUe36tWrUyy1CwV8wAy6r9C8XAy3reK9iTZRDGoWS/DiewnpNBORsmLjMTig0wO11snMOVKrhd5fLF0LlNHcxfugHJyX9tf86ckWhz8QXocGktDO3XHq891R23DZmImfN+hZdwliOXlmFZQUREhGkjOMuVta1u7mydKSYXli9fbo7tjGrAvvzyS/OTnXHJpOCrVKnUnyE16bAmAMXFIcvZuHGjmb3GniuXWOB6Lrwxi8OGlveZFWIxPtf86tSpU9Dfsy6EWQMOPboVe3wcUmXgFRMTY5ZO4I0XGO4D3ufYPlnrfvHGoSlmvm688Uazj7w2PMXJFdZECyurGW7aOYckM8qYuhW3mZ0OPzQ06WGDG24f8HyfNm2ayZJy0oVXlSlZACdOnkJiBpktZsxKFsuPSdNXwGtY18tsNztXnNXI39lm8LjgjTNgiUPV/J1Bmpfw2mZtf0avsUaGJJOGHTlDm5O+WHBfrdpfj+/enfozK7ZPXJ+KvVoGX7yFqlChgsnuMAtA4bIAbKDDzZBzUw+H+4DDrryF4rYz02UNP/ECwyDM8t1335m/5yQEL+GxwYsOM3oMLDnc8Ntvv5kUu/2zZ6qdPWKv4XGRM2dOX89qYrAd2vhwlhvrI1l4zckpXrZlRyyio3Igb56MM7scgjyUcAxewxIMTjRi8M2MP7Oh4RYTvf7/wz0PPPCA6ax5qQPKbc+opIQLbdsnnkgmBF/XXQeMGgWMG8f6oL8ef/ddgDPUW7VClsPVepnBCTcUmZCQYGaAseG1Zvpxlkfbtm0Dr2Pmh8MSbp7tyEBqHD+0MEORLD5l0JVeMTEvNHwdT9LQJSjcglk9XljtGFCxnoG1T0y5s1fHIJTr+jAQtRbh5bIcnCGZ0fpgWR0vmhxOD82GcsiBdU9uXrn9TPFcD+25M+PLYSdeI6x9wOOCmXJmvHkceGXf7I9NSLNC/erfdmL6vDVo16KG2U5mv9jxyp0rZ9Drps3+BXGHjqJhrfCTEtyAmSte6+y4rAiH0liEzxmerGkKndHKwnyOhnByBovS3ZolZgaPhfZ2vOY3atTI1L5x+1nnGy7RwBnBVqdEMin44nI3LBniN47w82nZMnW246efAkOG/DUsmdWGVsIFDdZaX/bnmN1gATIPUmY/WGjLlc15UKZXkOuW3l27du3SPP4uo2Yg6Dl+DQ8DLdZBsMFiMMqZL8wEuHWqPWezMbPB+h4GYbyIssiaGR97HSC/1YBDs7fffruZ8cQV7jlcy0V53fz1UvwaKWa4OHzOIIxBx+zZs80+ufnmmwOv436xZrby2OeaaPz8rQyxlR12I35TBfcBO1oMwrh9LDXgY9dcc01gYg7rPRmAMCj9+eefg/4NTkaxfyOCm3S/bxxyRedAs/oVUaxQPqzftBdvf7IIuaNzYtSgzuY1G7ftQ5ver6B7+wa4oFJxZIvIhp/WbsfEL5ebtb7u690abnXbbbeZwIKdDl7XmM3hgsPsdFs1TaFLLhA7XsSZ8gzU3YqLizNwZCKBnTEex2zjuP3WouKc0c/Zn4sWLTLnB88NXvt43WD9o33CggRzZHXEN98EOCv7/fcBJpTKlUtd48vFsUkAT0LOCGSDw8aJBx+H2piGtg/DeRl7glyKgkEHgxMW3XMGTLjv+3ILFtbPmjXLfEsBe78MwDizk9lMFt5beJF5/fXXTcDNr5nicCSLrfmVS27GC+iCBQvwxRdfmMaEARiDSQ6lsPDewsYn9GtFrN85+9fNwReHEBlYcs0iDrGwI8GlJ1jnY/96IWtIibMcQ/G1bg2+ulxex9RsjXlvHg4fOYaihfKh6xV18cS97U3hPZ1foqBZjmLe0j8w/vNlOHkyGeVKF0K/nq3w6N1tUbigOztfxMCJWR6e9+xMMwBjJoeZ7vS+XshLeOxzxX5m8bj9TDBwUWle660lhLgfWHbB85wTrJgN4xIc/OYXZv4kfREp3Fsuw961lVFhwxjuOxe9jNkVa1V9LvTppRmFZ4INnjWLhj0ur3yTwNngZAarpozfwOC3GiwWOVtr6zHz5LWZpRmJTkhAz4EDgx9c9izg4i+xPiuxCUhsPBhWWMehXq99n+LfYYeIIy7EyR1++JYJOw5z8jsn3RwDeKM4QURERMQlFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDFHyJiIiIOEjBl4iIiIiDIp38z0RE5F86fTrtY1tjgLgj/ti18YnmR5H//5r32DGciIxESkREpr4tEc8HXykpKYH7+/btQ548eeAn3GbL/v37fbf9Bw4cCNyPjY1F7ty54TcHDx4M3I+Li0OuXLngJ/Hx8YH7hw4dQnR0NPwim+38D+gxBn7CM36b9cukSRjcvTsSfXQMHD16NHA/KSkJkZGubMr/seTk5LDxgJtEpLjwnTP4KF68eGa/DRERxzHjs9/n+525r7yZ/SYkS4iJiUGxYsXgNqr5EhEREXGQK3OV9mEmRr1+G3Zj5q9ixYrm/po1a3w37MZhxyZNmpj7c+bM8d2QmzXs2KlTJ3N/4sSJvhp2s4Yd+/TpY+6PHj0aUVFR8IvohARgyJDMfhtZRu/evZEjRw74CYcdJ0+ebO63a9cO2bNnh9+GHWfNmmXuu7X9c2XwFWErrGTg5bfgy769PPDcevD9U/btZeDlx+DLvs0MvPwWfNm3l4GXn4KvqBMn0j44eyhQ0CcDcZxY0HZ44FcGXn4Lvuzby8DLbzVf6cUDbuLfT0xExCsYeBXOl9nvQkTOkGq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQQq+RERERByk4EtERETEQZHn+j+4+WZg/Pj0n9+5EyhdGlnOggUL0Lp167DPLVmyBE2aNAn8fuLECbzwwguYMGECtm3bhvz586Nhw4Z46623cP7558ONFi9ejG7duoV9bsaMGWjQoAH+/PNPNG7cON1/44YbbjD7xY1++ukn3HHHHWGf++CDD1CrVi1z//Tp0/jss88wbdo0sz9y5cqFCy64AH369EGdOnXgVmvWrMEjjzwS9jl+ptxGOnXqFKZMmYLvvvsOsbGxKFy4MC6//HJce+21yJ49O9xu+/bt5njfuHGj2dYiRYqgRYsWuOyyywKv2bRpk/n8d+zYgejoaHPuX3311ea+F6xcuwNPvvIVFv28GUnHT6JimSLo2+MS9O+den389of1+OSrn7Fs9Tb8tnkvypQsiG0LR8ArypQpg6uuugqVKlVCjhw5cODAASxatMi0Efy9adOm5lwvVaoUoqKisH//fvM8bykpKXC7ihUronv37rjwwguRM2dOxMTE4Ntvv8VXX31lnr/mmmvQqFEjlChRwlz/uH9+/vlnTJ06FYcPH87st+/f4IvtV5s2wY/xeLzzTqB8+awZeNn179/fHFh2lStXDtw/efKkOTEZrNx+++2oXbs24uLisGzZMhw6dMi1wZfltttuQ926dYMeK88PDjAN7auvvprmb+bPn28CkpYtW8LtevTogRo1agQ9Zv9MX3rpJUyaNAnt27c3AUdCQoJpiHksvPfee6hZsybcrGPHjqhatWrQYyVLlgzcHz16tGlkGHDxvPjjjz8wceJE0wDde++9cLN169Zh7NixpvHt0KFDoGHl+W1hwDVmzBizT/j58zk2TPv27cN9990Ht2Ng1bHvm6hX/XwMvacd8uaOwuYdB7Bz71/7YPKMn0zwVb9GGZQqlh9ewoDjzjvvxM6dOzFr1iwcP37cBOAFCxY0z/P+ddddZ457dkCSkpJQvXp1XH/99ahQoYLpkLsZg8pHH30UW7Zswaeffmq2j0EWr/0WBqVMOvA6cOzYMXN95PWAHfSBAweafSaZEHw1bZp6s1u0CDh6FLjxRmR5zZs3TzcDRC+++CIWLlxoDryLLroIXsPMFhuecHLnzm16PaE++eQT5MuXz5yAblevXj20Ce09/B8zIezdMQsyfPjwwON8fadOnczF2u3BFwPPSy65JOxzGzZswA8//GAC1J49e5rHGISed955+OKLL8xxwwbIjdiIMHhmhpONb7Zs4Ss0Pv/8c3MePPjgg6bXbzXIbHQZvIUG7m5yOOEYeg2agKta18DUsbenuw+efqAT3hl5I3LkyI4Ot7+OtRt2wwuYuezVq5f5HN95552wWSxmdkaOHIk9e/YEHmNbwPOhWbNm5hrAgN2NeDyzA8Es1nPPPZduFo/PhWIwOnjwYJO44P6QLFLzNXkyEBHBYSm4ArMZbGhDccjp5ZdfNkMMDLz4mqOMKj3myJEjYbc/HKakmQVs166dZ4ZdEhMTw24/H2Ovzt4LpEKFCpmGipkSL+AxnZycnOZxNkrEYTg7/s4LNQMzt2Lmmg0rz21+lvyceb6HBmi//fabKUGwAi/iMBQ/ew5du9nkGSsQc+AwRg7sZPZB4tG0+4BKFS9gAi+vYeDAEpLp06eb45lDbhFsuEKuDfbAy7J69Wrzk1kit+J5zAwfM/vcfh7TodufHmZ+KU+ePOf4XbrXOc98hTp5EpgyBWjWLHXYMau75ZZbTPDB+hVmwZ5//nlT00Hr16/H7t27zVBj3759MX78eFP/xd4yg7L0asbc5P777zcXGG4/s2BDhw7NsJbpyy+/NBforl27wgueeuopE3xw+zn8OmDAADOsQAwumdliTRA/c2bJeKywl8zMnxf2AY9jBhlsfJnFufXWW1GlSpXAkDuxUbKzgk7WQrkVgyoGVBxGfO2110yngtvFQIv1L6z12bVrlwlKy5UrF/S3kZGRZqiSQ5JuNvfHP3Be3mjsijmELne9hQ1b9yFP7ijc1OUivPhoN0RH5YCXVatWzRz7DMBY/1m8eHEz7LZ8+XKT8c6oQ8rsL/F64FZs13jtZ2fy4YcfRunSpc3+4EgPs8LW+W/hNY/XSQ7B33TTTebcWLt2baa9/6zO8eDrm2+A2NisP+TIBoVDahxG4TACAy0WGjMAY2aHDS2LcK2hRx6gLLCnp59+Gm3btsWKFSvMAexGbFxYy3bppZeabeMQ05tvvmkyAQywrILzUKz14kUqvaEqN20/hxMvvvhiFChQwNQ8fPjhh6aQnhceq+B8xIgR5sLEoNTCixRf4+Z6P24/h03Y0WDjw0CCQ2wcSmAHhHUe1vYxULH38K2MGAvw3Yo9dzYeDLx4LDOQ5lDKvHnzTDDOzhZrOon7JxQfc3PwSRu378Op5NPofOebuO3aZnjmwc5YsGwjXp2wAPGHj+Gjl26FlxUrVsx0OjjszGs+r3vseLBTzcD8/fffD/t3DED4Ghaec8KGWzGI4rYMGTIEc+fONbWc7ICxnIAZLdY6WniNtO8PbjufZwdFskjwxSHHHDmA665DlsaGhzcLa3hY+8Vgigfj7NmzA70aDkv+8ssvprdLDFhYfMyxcB6wbk252ycaXHnlleakY0DyzDPPYDI/yBCbN282s+TYMKVXH+IWzO7ZM3ycPMBaLmY9WITNG7Heh4EIjwvuLwYcnA35wAMP4N133w0U5rqx0Jg3C7OeDERZRM8M77Bhw0xgxgZq3LhxJitkFdwzSOVFm1lgt+IwI98/P3cWT1P9+vVNtuP7779H586dA9vHQDUUH3Pz9tORxOM4euwE7ryhOV55PPWC3fXKejhx8hTe+mgRhg3ogCrli8GreEzzxs+bxea0atUqk9lkJ3zmzJlh67l4jeDMRwbu4YZp3YIBJrP7bOt4jtPSpUvNsc324KOPPgoMubItfOKJJ0zSgnWeoUPxkpajLSRjlS+/ZEPOmXJwHTYuvOhyNh97xdbBxUbJCryobNmyprfM3pKX8KTiScftClcDxKwXeWG4LRx+xq1atTK1PNx+NsR33XUX8ubNazJCDLo54+2NN94ws6MYhHgJGxQGYQywuf280PKCyyEWZns5JMneLgvwOQTh5po/K6AKnURjLa3CjoY13Bo6/GI9Fjoc6za5olP3wfUdUsssLDd0TO2ULfllC7zM+lxDa/c4omEtwRCKHTRe+1knZmWA3crqPITWbjIYtYZlLbwW8rrAfcVA9e2330a/fv0CJTqSycHXF1+4Z5ZjRg0wD0qOhbMxIg6zhWJGwD4l3Su4zdz+cBMLOMPNygJ5FT9rXpRZ+7By5UrTCIcWnDP4ZqDKXrLXcAjemmhArHdiD5+3Z5991szyY4DOYnUOv7oVh1HstTsWBpXE498abrSGH+34WLjhSDexlo0oXiR4HxQrnLoP4g55b3KRnfW5hq5VxZEOK+ttx2xPly5dTHDCbJHbHTx40PyMj48Pu1/Y6UwPM+D8+9Bro2RS8DVpEj8wDuHBtVj7wx49DzzWPVmFt6FYiF+0aFF4jbWQZOgsFgYiW7du9WzWy8LPmkMRvPBaF6dwQwsMUMJlB91u7969JqNjz2pxBhSDMNaDMDhhD5j7JHR9ODexiuhDO1BWQ8TtZEeEw6uhdT387Lngrj0b7kYNapY1P3fFBDe+u/elNr5FC6UGYV5lTZiwAnGLFVRbQRixw3njjTeaDheX2vECdiwp3Gzu9DoddmwbQwNUyYTgi0Pjc+cCV1/NHgOyvHBj+Zw+zHTyFVdcYWqaeAFmQT6H4X7//ffA61iAzMfcvM5VuGJpptG5gCR7M6E1XSzGJhbke0G4rCUnHXCmD3u43H6rgf6Gs0hs+PmzQban5d0m3IWVHQ/O9OJkk/Rq+pgRY50jL9Bu7vVawyWhaxTxdwZc/GzZsLAujnUwnAVn/wYM7ge3D7lc176B+Tnu0+DyiXen/IjIyGxo1Th11qtXcX0rstf+WmUm7FhZE65YjsIhd06wYL2nF1a1px9//NH8tH+bgzW0yg4GZzKyIxpueJ3XSLaPVgAnmVhwz84AZ+a6ZciRRZOs6eKJxyFEznbkODYvuKNGjQq8jrUuXNmY9T5cDZ9eeeUV0/ik9/UsbsAZPtZXpXCoiYEHG1XuE654bMcLEYNSrmhsrX7vdpzByAsLi+5ZNM+sHmvauE+sldvZ8LIGiIW3HIbmBYezfNjz5d/y65XcikOIvKhyG9nTZyaHQyncrpv5nWH/x3OBxzqHWjkUN2fOHJMdYy2Ym3u93B42smyAmMXjKv8cSmGDzDXsrGwIh5m4DzgDlEXYDNq5D7gcidsX2K1Xowxu7dYU701dglOnktHyoipmtuOns1ZiyJ1XmvW9aM3vOzH9u1/N/U3b9+NQwjGMeG2W+b3OBaXR8TJ3liGwbpOdaLYBDLgZbHG2I69zPBfYQeGxz2slcdIVJ2WEZsrdOuOP1zzOcmSwxe1n55vHNM8LLrXBY53Xey7Hw/OE+4uBJ0tPOFGFy7Pw2iiZHHxxyLFYsbRfNZRV8aLKxeVYQMwxfw4hckiNjYr964V4kWU2hAXXXHaAGQEGYrwYu7nmhXU7zGYx4GR6nalnZvn4dRGhq5azIJOZQiv49AIW1nN1ah4DnMnDAIyfK2dy2oeTeHywsJ4ZQV6omWpnZoiF+G4ORBlI8rvrWMdn1TexEeLMP6vWkXgu8ALNxojBGoceBw0aFLYY2W24SjkbV36ubFh5DrBTZv/GA2Y/eU7wK6X4HZcMzq2lKbzgzeE3oGypQnh/2hJ8Pmc1ypUqZNb4GnDLpYHXrFz3J4a+OCPo76zfe3dt4trgizirm+UF1vc38j4LyjnpinhMWJ0MTjQJxe8/dGvwRVxeiNd2Zr/Y0eR9zny0giqOkDDTyxIcXjM5E5Sv+frrr02AZh+alWARKS7MkTLLYBX7sWH02yq6XIPIKvJnqtvNGYZ/gtklq6ifw0B+nNLMRsAa1uZFzs0zC/8J1l5ZX2nEZT+88m0CZyI6IQE9Bw4MfnDZs8D/C+E9LzYBiY0Hwyr35tp74Zb78DJ2iLjkC3EJIAY9fnLq1KlAAOjWGMDdizGJiIiIuIyCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcZCCLxEREREHKfgSERERcVCkk/+ZiIicA3FH/LNb/bSt4lmuD74SExPhN/ZtPnr0KPzGvs3Hjh2DH9m3OykpCX5j3+bjx4/DTyLCbW/b4fCrkydPws/bnJycDL9J9sA2R6SkpKTAhcFH3rx5M/ttiIg4rgiA/T7f7+x+qgUQOnLkCPLkyQO3Uc2XiIiIiINcmfniW/bjcFu47c+dOzciIiLgJ37ffvL7PvD19u/fjzwVKsDP2GgFtQBbtwJFi8IvfH38h3Dr9rsy+BIR8a3Tp4HY2Mx+F1lL4cJANg3kiHso+BIRERFxkLoKIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIg5S8CUiIiLiIAVfIiIiIgq+RERERLxJmS8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8RERERByn4EhEREXGQgi8REREROOd/HHGtwbnlg6MAAAAASUVORK5CYII=", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 12, + "metadata": { + "output": { + "id": 942912081568887, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 2x2 tiled C matrix (16x16)\n", + "atom_layout = Layout((2, 2), (2, 1))\n", + "c_grid, _ = tile_mma_grid(atom, atom_layout, 'C')\n", + "draw_tiled_grid(c_grid, 16, 16, title=f\"{atom.name} 2x2 C (16x16)\")" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Column slice: select column 5\n", - "draw_slice(base, (None, 5), title=\"Column Slice: layout(:, 5)\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Hierarchical Slicing\n", - "\n", - "These examples are from Cecka, \"CuTe Layout Representation and Algebra\".\n", - "The base tensor has deeply nested structure in both modes:\n", - "\n", - "**Base tensor:** `((3,2),((2,3),2)):((4,1),((2,15),100))`" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "output": { - "id": 1995543871400994, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Tensor: ((3, 2), ((2, 3), 2)) : ((4, 1), ((2, 15), 100))\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tiled MMA — 32×32×4 (Value Tiling)\n", + "\n", + "Expanding the tile to 32×32×4 replicates across **values** (not threads).\n", + "Each 16×16 quadrant uses the same threads but new value indices.\n", + "\n", + "Equivalent to:\n", + "```cpp\n", + "TiledMMA mma = make_tiled_mma(SM70_8x8x4_F32F16F16F32_NT{},\n", + " Layout, Stride<_2,_1>>{},\n", + " Tile<_32,_32,_4>{});\n", + "print_latex(mma);\n", + "```" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 13, + "metadata": { + "output": { + "id": 966448212485654, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 32x32x4 tiled C matrix\n", + "c_grid_32, _ = tile_mma_grid(atom, atom_layout, 'C', tile_mnk=(32, 32, 4))\n", + "draw_tiled_grid(c_grid_32, 32, 32, title=f\"{atom.name} 2x2 32x32x4 C (32x32)\")" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cecka_t = Layout(((3, 2), ((2, 3), 2)), ((4, 1), ((2, 15), 100)))\n", - "print(f\"Tensor: {cecka_t}\")\n", - "draw_layout(cecka_t, title=f\"Tensor: {cecka_t}\", flatten_hierarchical=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "output": { - "id": 1969451546987700, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SM80 Ampere — `SM80_16x8x8_F16F16F16F16_TN`\n", + "\n", + "32 threads (one warp), Shape 16×8×8. From `mma_traits_sm80.hpp`.\n", + "\n", + "PTX: `mma.sync.aligned.m16n8k8.row.col.f16.f16.f16.f16`" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# (2,:) — fix mode-0 to flat index 2, keep all of mode-1\n", - "draw_slice(cecka_t, (2, None), title=\"(2,:)\")" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "output": { - "id": 1640967410569655, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 14, + "metadata": { + "output": { + "id": 856271947434372, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "atom = SM80_16x8x8_F16F16F16F16_TN\n", + "M, N, K = atom.shape_mnk\n", + "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", + " colorize=True, grid_shape=(M, N))" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# (:,5) — keep all of mode-0, fix mode-1 to flat index 5\n", - "draw_slice(cecka_t, (None, 5), title=\"(:,5)\")" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "output": { - "id": 1401134948003030, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SM90 GMMA — Warpgroup Accumulator\n", + "\n", + "128 threads (warpgroup = 4 warps). A and B operands come from shared memory\n", + "descriptors. The C accumulator layout shows register distribution.\n", + "\n", + "From `mma_traits_sm90_gmma.hpp`, `CLayout_64xN` template." ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# (2,((0,:),:)) — fix mode-0 to 2, partially slice mode-1\n", - "draw_slice(cecka_t, (2, ((0, None), None)), title=\"(2,((0,:),:))\")" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "output": { - "id": 1824970334868558, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 15, + "metadata": { + "output": { + "id": 1685001715877307, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SM90_64x64x16_F16F16F16_SS Shape: 64×64×16\n", + " 128 threads × 32 vals/thr = 4096 elements\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "atom = SM90_64x64x16_F16F16F16_SS\n", + "M, N, K = atom.shape_mnk\n", + "print(f\"{atom.name} Shape: {M}×{N}×{K}\")\n", + "print(f\" 128 threads × {size(mode(atom.c_layout, 1))} vals/thr = {M*N} elements\")\n", + "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", + " colorize=True, grid_shape=(M, N))" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# ((:,1),(:,0)) — fix outer-row=1, inner-col-outer=0\n", - "draw_slice(cecka_t, ((None, 1), (None, 0)), title=\"((:,1),(:,0))\")" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": { - "output": { - "id": 2365542210561060, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SM75 Turing — `SM75_16x8x8_F32F16F16F32_TN`\n", + "\n", + "32 threads (one warp), Shape 16×8×8. First generation of asymmetric tensor core tiles.\n", + "\n", + "PTX: `mma.sync.aligned.m16n8k8.row.col.f32.f16.f16.f32`" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# ((:,0),((0,:),1)) — outer-row=0, inner-col-0=0, outer-col=1\n", - "draw_slice(cecka_t, ((None, 0), ((0, None), 1)), title=\"((:,0),((0,:),1))\")" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "output": { - "id": 2496503134097427, - "loadingStatus": "loaded" - } - }, - "outputs": [ + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "output": { + "id": 1454137506437681, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "atom = SM75_16x8x8_F32F16F16F32_TN\n", + "M, N, K = atom.shape_mnk\n", + "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", + " colorize=True, grid_shape=(M, N))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SM89 Ada Lovelace — `SM89_16x8x32_F32E4M3E4M3F32_TN`\n", + "\n", + "32 threads (one warp), Shape 16×8×32. First FP8 (E4M3/E5M2) tensor cores.\n", + "\n", + "PTX: `mma.sync.aligned.m16n8k32.row.col.f32.e4m3.e4m3.f32`" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "output": { + "id": 780639114666597, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "atom = SM89_16x8x32_F32E4M3E4M3F32_TN\n", + "M, N, K = atom.shape_mnk\n", + "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", + " colorize=True, grid_shape=(M, N))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SM100 Blackwell UMMA — `SM100_128x128x16_F16F16F16_SS`\n", + "\n", + "1 \"thread\" (warp group operates as a unit via TMEM). Shape 128×128×16.\n", + "\n", + "SM100 uses a fundamentally different model from SM90: instead of distributing\n", + "elements across 128 threads with a hierarchical layout, all elements live in\n", + "TMEM (Tensor Memory) accessible by the entire warp group as a single unit.\n", + "\n", + "The layout is trivial col-major: `(1, (M, N)) : (0, (1, M))`.\n", + "\n", + "Below we compare the SM90 GMMA and SM100 UMMA representations of the same\n", + "64×8 C accumulator tile." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "output": { + "id": 1326420539507572, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SM90 GMMA 64×8 C: ((4, 8, 4), (2, 2, 1)) : ((128, 1, 16), (64, 8, 512))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "SM100 UMMA 64×8 C: (1, (64, 8)) : (0, (1, 64))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# SM90 GMMA 64×8 C: 128 threads, hierarchical layout\n", + "sm90_c = gmma_c_layout(8)\n", + "print(f\"SM90 GMMA 64×8 C: {sm90_c}\")\n", + "draw_tv_layout(sm90_c, title=\"SM90 GMMA C (64×8) — 128 threads\",\n", + " colorize=True, grid_shape=(64, 8))\n", + "\n", + "# SM100 UMMA 64×8 C: 1 thread, simple col-major\n", + "umma_c = umma_layout(64, 8)\n", + "print(f\"\\nSM100 UMMA 64×8 C: {umma_c}\")\n", + "draw_layout(umma_c, title=\"SM100 UMMA C (64×8) — 1 thread, TMEM\",\n", + " flatten_hierarchical=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SM120 Blackwell B200 — `SM120_16x8x32_F32E4M3E4M3F32_TN`\n", + "\n", + "32 threads (one warp), Shape 16×8×32. Warp-level FP8 with block scaling support.\n", + "\n", + "PTX: `mma.sync.aligned.m16n8k32.row.col.f32.e4m3.e4m3.f32`" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "output": { + "id": 1455636679512773, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "atom = SM120_16x8x32_F32E4M3E4M3F32_TN\n", + "M, N, K = atom.shape_mnk\n", + "draw_tv_layout(atom.c_layout, title=f\"{atom.name} C ({M}×{N})\",\n", + " colorize=True, grid_shape=(M, N))" + ] + }, { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0sAAAH5CAYAAABQ2aUhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAn9lJREFUeJzt3QeUFEXXh/FLjqKCoGAEFQOIWTGDEQyAOaEYML6KAUXFnAOiGD5zQhEjJsygmBWzmFAMoAiSc1jSfOeptcbe3lpY0MXp7v/vnJXZ2QG3Z7qr7q26VV0pl8vlTEREREREREqoXPJbERERERERUbIkIiIiIiJSBs0siYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKISAW76aabrFKlSu7rmGOOKfXzWbNmWZMmTdzPq1ataj///HOJn3/22Wd2zTXX2H777WeNGjXK/1tl/Xv/loceeij//+nYseM//veeeeaZ/L/Xpk2b4GsWLVpkm2++ef51b731llWETz/91I488khbc801rUaNGu593Wuvveypp54Kvp7fw/9O/H65XK5Cfq/LLrss//8544wzgq+ZNm2arbjiiu41tWvXtj/++KNCfhcRETGjwRcRkQoyZcqUXP369Ymsc5UqVcp99913pV5z+eWXu5/zdeihh5b6eceOHfM/j3916dKlwj67efPm5dZcc838/+vdd99d5n9r/vz5uebNm+f/rVdeeSX4ur59++Zfs+222+Yqwq233pqrXLlyme/p4YcfnluwYEGpv8fv41/zyCOPVMjvNnHixFydOnXc/6N69eq5n3/+Ofi68847L/+7HH/88RXyu4iISC6nmSURkQp044032uTJk93j9u3b20YbbVTi51OmTHGv8bp3777Yf2/llVe25aVatWrWrVu3/PcXXHDBP5ql+vHHH93jjTfe2Nq1a1fqNQsWLLBLLrmk3O/FsnjjjTfcMTGDhZVWWsn22Wcfa9q0af41jz32mF1++eWl/u4555yTf3zxxRfbwoUL//Xfr0GDBvnZwnnz5tmll14afN2ZZ55pVapUKfXeiojIv0vJkohIBSHYveeee/LfH3HEEaVeQ6A7Y8YM93i99dazrbfeutRrDj74YHv88cft119/tc8//3y5fl6HHXaYK/fCe++9Z8OGDVumf+f2229f7PuAgQMH2qhRo9zjFVZYwZUd/tvOPffc/GMSJY7nxRdftOHDh9v222+f/9kNN9xgEydOLPF39913X/d7YeTIkfbSSy9ZRTj88MPzj5988slSvwdWW201a9u2rXtM0nbXXXdVyO8iIpJ1SpZERCrIs88+axMmTHCPa9asaR06dCj1mmgydeihhwb/HdbW8LN11lnnX/39outw+CJxi1tjjTVsu+22y39/7733LvX/Z+jQofbVV1/lvz/kkEOCr4u+F7xXvGeLW9PDF0lLeX377bf2xRdflEgEWbOE6tWr2+mnn57/WVFRkUtUovh9ogncsrwX0XVgZa3JImnjffcJd9++fYP/VvR9fPjhh93vLCIi/y4lSyIiFeT555/PP95qq63ysxIepVPMaHh+pqDQRH+vF1544R+9DyQB66+/fqnXzJ4925XIhf6f/5YPP/ywxPdbbrnlYr+Pvz7+ew0aNMjmzJnzr/+eJFG77LJL8P0r63eZNGmSvf/++//67yIiknVKlkREKsg777yTfxwqr4v+nACZhKoQbbPNNvnHv/32mysH/DffB3zwwQc2f/78Jb7unxgxYkSJ7xs3blyqtC0qtA4o+l4wk/PRRx/9679n/P/z8ccf29y5c0u9hrLN+vXr579/++23K+R3ERHJMiVLIiIVgPK76JbObGoQFy0JY+twtoMuRPHffWnXTUWPM/Q+xF+D+EYY/4apU6eW+L5WrVolvmcb7vgW3XHx36ui1pBF3yeSMkoIQ6K/z/JezyYikgVKlkREKsD48eNL7XK2uNeEfl7RuNcR9wvyX2Xdsyk6e4Fx48aV+//BPaQosVvScUbfi3r16rmd+EJYsxT9nf/JOq74vZLKc+8kfq9oOeXSvBfgPY7+/mXdb6q873n0dUv7u4iIyJIpWRIRqQDxWYz4eqX4a0I/LxQkL4s7tn/6Piyv9yI+cxdfbxT/vqyZvuj7sTTvRUW858vjdxERyTIlSyIiFYBtqaP89uBlvSb080IRL0eLH9s/fR+W13vRvHnzEt+PGTNmsd/HXx96P5bmvaiI93x5/C4iIlmmZElEpAI0atSoxPf+xrRlvSb080IR/90aNmxY7r9bp06dEmuByjrO6Hsxffp0d4Paf1t0C/TQGp/PPvtssa8Hm1DMnDlzmd6LinjPo6+rqN9FRCTLlCyJiFQAAtfVV189//13331X6jWbbbZZ/jGbQZAk/JuWdE+f8txnKfS7b7755qXW4UT/ncUdZ+h9iL8G33//ffB1S7rP0uKOuUWLFiV+9yeeeMJ+//33/CYKt912W/5n3HeJmwEv7XvxT36/sv4/rJNq2bJl8HXR9yn+u4iIyD+nZElEpILsvPPO+ceffvppqZ9H76XDYv/4zIZ35ZVXWuvWrd3X/vvvX+JnL730Uv5nfFUEtq6O7trHltVLI3qcoffB34i1atWqS3zdP9WrV68Sa3xatWpl++67r9tVLroN+HnnnRecqYm+FyQx/N4VIfr/YRv1+M59fiv0KVOmBN9nERH5dyhZEhGpIB07dsw//uSTT0qUb/k1MRtuuGH++yFDhgT/nZ9//tmGDh3qvr788ssSP5s4cWL+Z3xVhOjv1aFDh3/0PnCfpl9++SVYrrf77rsH/5//pt12281uueUWq1y5cj5hIuGM3jvqsMMOs0svvTT496O/F/9WfLvxfwOJc/SeSWW959HfZeWVV7addtrpX/9dRESyTsmSiEgFYRbIz06w09rAgQNLvebEE08sURb2b/rzzz9LBNNl3eNocUhuojMuJ5100mL/PzvssEOpn2+77bZuBmdJxxl9L55//nlXGlcRx9ytWzeXWB5++OGuVJIZIrY032OPPdzv9thjj1mVKlVK/b34Z7ik92LdddctdaPb8njvvffy9+jidzv22GODr4u+j0cffbTVrFlzqf9fIiKyBDkREakwPXv25OY97mufffYp9fNJkybl6tatm3/NJ5988q/9v3fffff8v/vAAw8s079x/fXX5/+NHXbYodTPi4qKcrVr13Y/r1GjRu77778P/jv33HNP/t9p0aJF8DXz58/Prb322vnXPfXUU//JMZfliSeeyP/b/J78vnHrrbde/jVvvPHGMv1/TjnllPy/ceSRRwZfM2bMmFyVKlXcaypXrpwbPnz4Mv2/RERk8ZQsiYhUoClTpuTq16/vgtpKlSrlvvvuu1Kvufzyy/PB8aGHHvqv/H/nzp2bq1Wrlvs399hjj2X6N+bNm5dbY4018r/bO++8U+o1b731Vv7nV111VZn/FolF8+bN86995ZVXgq/r27dv/jWtW7de7se8ONtss03+d3v44YdL/XzUqFH5n3ft2nWZ/h8TJ07MJ5/VqlXL/fTTT8HX9ejRI///Ou6445bp/yUiIkumZElEpIL17t07H9h26dKl1M9nzpyZa9y4sfs5swVlBchLg1kN/j0C719++WWZ/o0HH3ww/3t36NAh+JqLL77Y/bxVq1YuuVqcAQMG5P+9XXbZJfiahQsX5jbbbLP864YMGbJcj7ks/B7+d+L3W7RoUanX3H///e7nfJYkycvi0ksvzf9/unXrFnzN1KlTc/Xq1XOvITkcPXr0Mv2/RERkySrxnyWV6omIiIiIiGSNNngQEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUvlVFRkdt55Zk2amNWqZbbttmaDBlkmzJxpdumlZu3amdWvb1apktlDD1nqffKJ2WmnmbVoYVanjtlaa5kdcojZjz9aqn37rdnBB5s1a2ZWu7bZKquY7byz2cCBljlXX118vrdsaan31lvFxxr6+ugjS73PPzfr0KG4jeO85zO/9VZLtWOOKfsz5+uPPyy1RowwO+wwszXWKP68N9zQ7IorzGbPttT77LPi/rxePbMVVjDbc0+zL7+0zMYt339f/Lq6dYtfe9RRZhMmWKqP++OPzU491WzLLc2qVSt+nZSt6mJ+JrFO5emnzc4802z99YtPvr33NhsyxGzHHdP9Vk2cWNyJkCxsumlxUJUF119v9v77xYlDq1Zmf/5pdvvtZltsURw8pjWAHjXKbMYMsy5digcHCB4GDCgOJO++2+zEEy0TRo82u+aa4kQ5S7p1M9t665LPrbeepdrrr5vtt5/Z5pubXXxxcdD088/F50CanXSS2e67l3wulzM7+WSzddYxW311S6XffzfbZhuzFVcsHhAjqPzww+Igk0Ti+ect1YMCxCxrrll8vIsWmd1xh9kuuxQH0BtsYJmKW7jGGQzkXKC9J9m48Uazr78ufj+qV7dUHvfLL5vdd19xbMPAaNoHgf+xnCzR0KF0H7lcr15/PzdnTi637rq53Hbbpf8NnDs3lxs7tvjxJ58UvxcPPphLvfffz+WKiko+9+OPuVyNGrnckUfmMmXBglxu001zuQ02yGXGoYfmcrvumsvtsksu16JFLvWGDCm+tp96Kpcp06blcquumsvtv38ut3Dhf/3b/Pfefbf4PLj66lxqcWwc4zfflHz+6KOLn588OZdae++dy628ci43ceLfz40Zk8vVrZvLHXBALnNxyymn5HK1auVyo0b9/dygQcWvv/vuXGqP+88/c7nZs4sf/+9/xa+TsqkMrxyYUapSpeSIes2aZscfXzwaxShVmtWoYbbaapY5229felSJWUXK8pi2zxLOf0Yip061THjnneLrvk8fyyRmFhcssEzo399s3LjiksvKlc1mzSoebc8q3g9Kco44wlJr+vTiP1ddteTzjRsXnwNJm01YGu++Wzyb2KBByeNmZunFF4tnVrIUt1A1se++xTMxHu9P8+ZmTz5pqT1uzn2WlEj5KFkqhy++KL5wqO+NYhofaav1lbIx/kJgxTqetCNoZEqfcqSbbzZ75RWz3Xaz1Fu40Oz00826djXbZBPLnGOPLW7rGBBq29bs008t1QYPLj5e1udQgkQJHt+fcorZ3LmWKfPnFweIDBRRhpdWbdoU/8mAJ/03A55PPGF2553FZahpLr1l/XUoSGbd1rx5Zt98Y5nBNT9+vNlWW5X+GfEdsZ8ItGapHMaOLR55ifPPjRmjkykrHn20uIGlJjjtuncvXqMERlsPOKB4zVba3XVX8botgugsYTT9wAOL12IyGPDdd8W1+zvtZPbBB8XredK60J9ZtI4di4Pna68trvO/7bbimdTHHrPMeO01s0mTzI480lKNxe9XXlm8RuWFF/5+/sILza66ylKNAQHW3DIoRMUASJKGDi1+nOZNPUKxHcqK7yZPLk4uma2RbFOyVA5z5oQvFkZe/c8l/YYPN/vf/8y2265484O0YzOTgw4qHgxgtJnOlU41zQgUL7mkeJF/w4aWKcwm8OWxoQefPwuAL7jA7NVXLZUoO2ITEzY18LvfMTDAuc5gAQMjlN9mpQSPnbHY9TPtmDljYT8DBJSkvfRScfJECRObPqQVO6Axa8rAQI8exSWnJIg+cchSPOOPdUnxnZIlURleOTBlzehCnC/RUN1n+rET3j77FO+Y49ewpR1b6VK7ffTRf9eys2MYpYhpddFFxTtjUYYnxbvgMePCrp8ky2nk2+/DDy/5vF+zw7rULOD6Zhe4vfYquZ4ljR5/vHgNMruBnXBCcXJ8//3Fg2DcIoRBk7RiUKBnz+LEmPW3lBpTak3iBMpQs8Jf+4rvZEmULJUD07F+1CXKP8f2ypJe06aZtW9fXJLD6HpWP29mGbj3VFq3GKUc6557itcsMJs2cmTxF4MirOXgMWUZWcPGHsyysIYtjfz1HF/s36hR8Z9TplgmPPdc8Qxb2kvwwFbZlJVyj6UoZlN5D9K+VoXNTFh7y2YPw4YVt+t+UxPWZ2eFL78rK75j4EyzSgIlS+Ww2WbFAaLfQcfzNb78XNKJQJnZFD5/Zlc23tgyy5cskDymEbX6BAwkS02b/v3Fdc7nz+MsrFWL++WX4pKUtI44c1PG0FoNvxY1K+WYrMfkMyZhSDsShdBMKYMiyMJOkCuvXHy/Jb+JDWs0SR6pKMgK7iPG9R3axIZ7LCm2E0/JUjlH1GlYGXX2mLZ98EGzbbctHnmV9OEzP/TQ4jKcp54qXquUBewOFAoiHn64uGwhrQkjNxl+9tnSX5SqsK0sj6nzT6vQHeu/+qp4AfyeexZv8pFGfn0OZVhRlGhVrfr3zmlpxmdPsLz//sW7oqUdsyfMHsVnydnMg/OcdXpZwk6AzC6xTjWt13lZWLPGQGj0FjBvvFF8bnBDehFog4dyICHiomGRM4Ekdfx9+xaX5cQ72LRiFzTK0Pxo68CBf9/dnvUdrOVJ425wBIrMLFF+1a9fyZ937mypdNJJxbOoLH5m5I31Wow6s8FF797pnWFgB7hOnUo/7++1FPpZmjAwQDLMJg+UoLEbHgNEBM/XXWepRTnWcceZPfBA8YwC95thNzwGSGjzs1B2S7DMsWehBA/nnlt8KwR2emQzB9ZoETDzHLcMSPNnzj3kmCFnAITjZmc8Bn7ZIfCMMyxzcQvrt7jWuU0Cx8/avV69imfcuI1CWo+bHV8feaT4OT+z5neCXHtts6OO+i9+8wK2mBvWSsScObncOefkcqutlsvVqJHLbb11Lvfqq9l5i9Zeu/gOz6GvX3/NpdIuu5R9zGm+ch57LJfbffdcbtVVc7mqVYvv9s73zz+fyyTOgxYtcql3yy253Dbb5HL16xd/7o0b53KdO+dyI0bkUm/evFzussuK27lq1XK59dbL5W6+OZcZrVvnco0a5XILFuQyY+jQXK59++I+nc+8efNc7uqrc7n583Op9tNPudyee+Zyq6xSHMtsuGEud+21uVxRUS6zccs33xS/J7Vr53IrrZTLHXlkLvfnn7lUH/eQIWW/hj5PSqrEf/7rhE1ERERERKTQZKw6VUREREREpHyULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJqGoJk8vlbPbs2ZZF0WOvXbu2VapUybIgq8cNHXv2Pnd95vrMs3KuQ+e7zned79lSO4H9eeKSJYLmunXr/te/hoiIiIiILIWZM2danTp1LElUhiciIiIiIpKGmaWocePGJS47/SfGjx9vzZo1c48HDRpktWrVsiyYPHmydejQwT1u3769ValSxbKiqKjIfdYYNmyYm77OiokTJ1rr1q3d4y5duli1atUsC5g979+/v2W9jevdu7fVqFHDsmD69OnWs2fPzJ3r8fO9X79+VrNmTcuKqVOnWteuXd3jHj16WPXq1S0rMwt9+vTJXCwTj2ey1MYVFRVZ9+7dLakSnSwRRGQpkIgeK41LVhqY6HGSKFWtmujTdqksWLAg/5hEKUvJUvRYCR6zEkBGjzPLbRxBRFYCiehxZulcR/RYSZSylCxFj5VEKSvJUvQ4sxTLIHqsWWrjkk5leCIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCahqFayoyOySS8weecRsyhSzVq3MrrrKbI89LFGKiorskksusUceecSmTJlirVq1squuusr2SNqBLKVvv/3WXnzxRfv0009tzJgxtuKKK9omm2xip556qq299tqWFjVr1rROnTrZ+uuv775WWGEFu/XWW23IkCElXnf66afbrrvuWurvjx492v0siWbNmmV33HGHffHFF/bll1/a1KlT7eabb7ZDDz20xOuaNGlS5r+x00472RNPPGFJ0rhxY9tnn31srbXWsnr16tm8efNs7NixNnjwYPv6669LvHa11VazAw880NZdd11buHChffPNNzZgwACbOXOmJfGavuyyy+yzzz6zP//802rXrm0bb7yxnXvuubbffvu51yxatMgefvhhe+aZZ9x5MXnyZGvatKkddthhds4557jrpdDNnTvXXnvtNfv111/d1+zZs+2YY46xHXbYodRr+dw5f3/66SerUqWKa98POeQQ1w5E8b68/vrr9tZbb9m0adNs1VVXtfbt29u2225rhaRGjRq2++672zrrrOO+6tSp4z7Pjz76qNRry3Nuc5zbb7+9bbjhhtawYUPXH/7++++ub/jtt9+sUMyZM8edsz/88IP9+OOP7hjOPPNM915E8fM33njD/Tly5Eh33BxLyL777ht8vkuXLnbwwQdboeAzef/9911f9Mcff7j3Yv/997fNN9+8xOv4Odc0f44bN86d01dccUWpf4/XPPvss2X+/zhnNt100wo5lqXFtc35zblL+zZ9+nS79NJLrUOHDiVex7nxyiuvuM98xowZ7lzecsst7cQTTwz2b88995yL+Yh9uAZo//hKWhv3zjvv2NChQ107x3lBHLfBBhu49n6VVVbJv452/r333nP93/jx461y5crufdlnn31cH5FlFZ4sHXOM2dNPm515ptn665s99JDZ3nubEYPuuKMlBifg008/7RpegumHHnrI9t57bxdM75ikA1lKffv2dQE0nQ3HPWnSJHvyySftyCOPdO/BeuutZ2lAUERyQANBQ0pCWBaCapKLeMKRVDSQJEerr766axA/+OCD4Otuu+22Us999dVXdt9999kuu+xiSVO/fn0XVBJAEvhWr17dNttsMzvllFPs0UcfdYEHVlppJTvrrLNcJ/PCCy/kA1E6kRtuuMEFWkkyatQoFygQ7HEMdLAExwQWd999twsceO7YY4+11q1b28knn2yNGjWyDz/80AUgBJlvvvmmVapUyQoZgTIBMJ/zmmuu6QLjss5/PsdatWq54JIAhISIYPLCCy+0qlWrlgieCLYYHCAJoW3k/Oe92GabbaxQkBwR4NBeEzg3b948+LryntsEXyRLBNAEXrxX9Hsk2LfffnuZ7+3yRpD82GOPuSCY5D4+6OEx+MdnzGdIssh7tDgkHPFBsmbNmlkh4ZoliScQJrCnHwshifz888/da1ZeeWV3joQwGEpCFEf/QJJVSMfPAN+9997rPkviFAaCQjhPObd33nlnN0DG5841/e6779rjjz/uzhuPNvGaa66x3XbbzcU7XOu9evVy7QPxYJLaOAY2GjRo4JJbBscmTpzojnnYsGGuTacdAMdI8kU/yPXO9U+7f/PNN5c50JQVFZosffyx2eOPm/XqZXbOOcXPHX20WcuWZj16cNFZInz88cfuQuJCYVQVRx99tLVs2dJ69OhRZnCZBjQSV199tVWrVi3/3J577ukSC5IlZtfSgNlCgkMaXUZYb7zxxjJfSwPy9ttvW1oQCNNI8ifJDyPlIWV1nASKzMolDSOQfEURbJx//vmug/TJUrt27VwQed1117nzBAQiZ5xxhksm/OuSgkEevqJOO+00N8J60003uWSJxJHjosP0TjjhBBdc+oQpPlpfaAgauY75k8+LdiyE5IcBkIsuusgFFCDQJkDg/CawAp89AXbbtm3tiCOOcM+RNNEvMJC21VZbuZHYQkkaOI/5k5lTHoeU99z+5JNP7KWXXnKzFx5BFNUWJGWFkiwRNDITQBIwYsQIlwiGcP4fdNBB7tjvvPPOJSZLBNh87oU+4Efyyp8cDwMfIST1nLf06QTaZSVLvJd8Rc2fP9/9Ha6P+Kzrf4nZEYJ8/vzuu+/sqKOOCr7uggsuKPUcn2vnzp3dcREDgITo//7v/9yAAIMGOOCAA9wsHIMjPCbZSkobRxwXGgAgfuM69n0+s020BdHPloHQK664wp5//vlMJ0sV2rIzo1SlitmJJ/79HNUbxx9PQ0u2a4lAR0hpBkGERxnK8ccf7040sva0YiQimiiBzpdRJaZ902LBggUuUSovgiJGV9OAgIFEaWkROL388su23XbbLbZEL0lyuZw7D6KfLaNsjFD7YBIEh4yukmCkAe0bI5P+GiBZiiZKHjMv+P77763Q0W4RRCwJo9DMJPtECcywMvLODITHgAIDJW3atMk/x0ABwQTnxs8//2yF1J6RKC1Jec9t+rhoouRn0ylbZDS/kD5zEqUl4TW0e0uD4yepLlTMgJYngalbt26pPr28ODd4HyhTLSS0V9FysqUtxwaz7R7XPdUG8TJLSnOZhaVULUltXIhv75iR9KguiZ9D/D822WQT10aQRGZVhc4sffGFGbP/8QTcVyt8+aXZmmtawaP0gDKG+EiCL7ugEyXQyAoCSkpXCmkafnmik6VMi4SZBpaGk3rprDUklGLRofgAOqnoaOkQSJAIAgiUfRkHHRHXfWhdBiN5LVq0sKQi2KXj5zOkBIsZlvg6tTjWOGFZA5NCQwDANcyMWVy8jIuEgWvfB1fR14FzhBKgpPg3zm3+fpJLkMuLmVQGhuj76Ou5TqJJc1ZQtkVbmfT1KwwKMUtEe0b5HqJltH6mNH6cG220kRsoHT58eKnZ+SSgbI/jJn7za/Q4piWZ9leZOl9ZVaHJ0tixZO2ln/fPjRljicCiuHgHCf8ci/+yhKCKtT2sZcgagitqnBlFptFkKpspbIItynhoiLKCxbIEj2UtgE4KygspSwGfH4MffrMKP2pHZxHHyD2jtIzoMpKfNN27d8+X6nAuU1rC+pPFoSSFALmsUs2k8Z9raHSW50gEKD0iQCTA4tjja7UWd44Usn96blOuTKL46quvWpoRTFKOxQwaJWuUI1L6xIh8EgPmZcXxUtrI+7G0s3KFhvbLzxJyHVC+SNmpx5oeZtvjZYh+JoefJxHH6a9nrm82q1hS4kus98UXX7iZ5kIpM05dsjRnDqPwpZ/3Gynx8yRg9DXUOPgdofh5VlB6R00rI/BJD5KXRb9+/Up8z6wSyTI1z5QtFcr0fEVjNJ7RVhY9L2sZQCHNkLHgmUWuW2yxhesQ/KJ+X64SChgJov1rkpgssVkN6zY4f9m0hRKzxZUZsdiZnQLZ3MQvCE46f7zRTRw8/9n7ZIk/F/e6Qi7RCvkn5zaB1nHHHeeSh0GDBlmasSYtih1wuXbY/Ii1jUlPHMqLtUC0EYVWgrcs2OmW65V4hhnDeAxHqWHoWgezK0mtImEtItc2EwDsjrekNov34a677nLtQGjNcpZUaJpI2X+szNnx51lSlnxQnhOv14a/YNKydmVJGE3hYqOjZISZkRcxGzhwYGo6kfJidJXzn9mIpGN9BmUXdB4s9ib4YUe8aNC4pGA6idgGmk0a2KyGkgxKNNhKllKjOGbamDllnaZ/b9LAl5UsKWHwfy7udUkrUVnWc5vj5NYRXCcEUqG+Mc14bxgo9Gu2soLNf4h1klRqWpatt97abVbAIOf111/vSvGit77g3C5rAIwEIwm3TiirzWf9EZt0nXTSSS52YbAwhCoL3hcSq5NPPjk1A2QFmSxRpUYpXpx/Lilrwim344SJ88+lZXH7kmYSunXr5gIqSnWiW2xmHY0n70sh7Q60PErwKEkq9B3RlgWzTJRVsunF4sq0OH4+9yTOKoUwy8SuZ2wtHMXMAQkVu54RHKfJ4krReI4tuH3iQLDAc/FkcnHnSCFblnPbb3TEQnBKOEP9Yhb4NXtJvM/asqAElbVtrGNL2yApa9DYBY7lBdHPlwFQ1vZEMXjAdZOGNZv0b2zWxSBhCOuwWaPGluEblWNdU9pVaLK02Wbs6U/9c8nn/WfDz5OAHYMIIOK7C/mTjJ+nGSOHbMHK/Vn69OmT2Y0dysIoE4lS0tYs/JOZGLZUpl4/jSUofoaAUVQ+UwYK6FTiSKi4F09a+FKU6HlMG8cGHmyLTaleWaUpScWuaFy7oXvSUKIT3biHx/7GxfHX+Z8nydKe26zV4t5cBJYPPvigW7+SVX6jk0LYPnp5YKMTBgnSWj1BjBNNfP19ySg9jOJ7Zly4BtKA9iy0jOSpp55ytw1g979Cu+F2KpOlgw7injRm99zz93PM2D/4oBnvf1L6FkZcGWW4J3IgXFx0GJxISesklwbHzb0JGGFgujqtjWV5MMIcmn6nQWGdC4sgs4D7LdBhJL0Ej3LSOD5Hrmk6ER8Q8blSuhDdkpjOkq2lk/iZs2A3jhFTRhJJEP2CX7YHZzaJwJkyvbSWG7NOjWAwOorMsce3z+Y2Coyqcy8ujwCSe64x65TEG3QvzblNO0fSzD0H2QQlC0IDYGx0wO6RJEpJ/MyXBf0/M5DcqDapytpO/5tvvnHllNGNDijT43i5bUwU3xMDsOFHkmK40I6VDPJwP674Z8r9qrifHIOhaawcWVYVOkxIQsQ29dwHjP6ZdqVvX7YlNbv/fksMgif22ydpINCggWRxJ6OR9yfpQJYBN2YkGODGjDQ0LIaMStNuQOyQQ9mN3wGHBtPfi4Dj5mfctJM7X/ubGDKrSABB6RY3L06qBx54wH2+BIi+9MqPoLOQOzqCSgkeO0OF7sOTJNxYlI6PjtLvdMb2sRwbnaJfi0HnQUDNej0CZWbT6EQ4B7jPWtJQq85nzTVNORVJIVvhsx1u7969XRLJjMNee+3ldn9kByXWqMV3QuP+WoWOenyCWx/0EvT5ewqxOQl3s6cNY6t4djhjwT6fO5857030Joy0C3zu/IwAhCSShIIZlq5duxbcTlHc/4kE1681ICnyjzmPWXNY3nObG3fy7/3yyy8usY5uswySp0LZ4IJ1GASHPvmlXfa7l7Emj3acftyv1fDrjkgCfXkS5wYYJPjoo4/c8VJ6zrlD2zhhwgQ7++yzl/l+RRWFmWBmCvw9g1iL6c99dnujvaOt88mu38nXDwBwfsQrZegT+GLH0PhOkIWENUccN58N6Kf9wJC/JQLXOut1qI7h2uCzJ/GlzeMa9nifWKfDAHGPHj1cW8e1Thzwv//9r6BKbpfUxuG8885zcQpLRrjGub6ZOeI9iG7URRxD38c1wPITzv2ojTfeODOzqXEVXlPx8MNmF19s9sgjbLtsxsQE27v/dVP0xGDU9eKLL3Z3B+dEZIaFhtTf3T2t/PqFd955x33FpSlZ6tSpU4mbs9JA+oCQhJEOmJvVMcJM8EBwRKDJOcFsS2hhfFKwFiVadkOn4BNjdsHxDSSdC40xAXehBYdLiwCZhI8ggM6S4JG6/GeffbbE/XW43hk04H3o2LGjC5QZjRwwYEAi1ysRODDIw2YW7GZGGRozKAQGHTp0cK/heX+z7fPPP7/Uv0E5VhKSJUZIOZZoMMCXDx5JlkiCzjnnHFdmyEAApYYkFsykxINhZlP5O7SFlKLSXrDpRSGWqpD0RG+0y20O+PIJBOd7ec/tNdZYw/1JkBkqw2bzj/j6jv8K12909pTPiS/QbpMs0W7Hdzb137ds2TIfZBIcMojAeUQgTqBJiRbJJf1AoSEAjt5cnbIxX0rG70sSwGceX9Tvv2cAIJ4s0d6j0KtK6IejJbIckz8u4hSSXfp4+nB29WRQhOcYFCJRiq895/qnLeC84HpntpXbLRx++OGWpDaOBJiZMBJnnmdQg+cYAKByILr+yscAXD+hiYBzzjkns8lSpVzCIjwCVl8+Q40pDV9WcAJzwYItqtNaFhNHJ8x2rWAUJG3rJhaHgMbfx4REhUAtKxgN9h00nVmhjeJWFEYJmbnOehvHRjJpXBMXwkwfgVjWzvX4+e7LnLKCxIYd2XzCmbQdFZcV7Ro76mYtlonHM1lq44qKiuy0005LbL+W7KFhERERERGRCqJkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSERERERFRsiQiIiIiIlI+mlkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAVUtSRYtMpswwVbx30+YYDZ7tmXCokVWecQI2+Cvb2uOHGlVGzUyq5z+fLfa1Kn5z7xeUZHNqVLFcpUq/ce/lYj8qxYtskoTJ+av9ZozZliNefPS/yYvWmRVxo/Pt+2rTpli8+vWzUwbV2Xu3PxnXn3aNLPq1TPRr4lIciQrWZo0yeo0bWoT/PdNm1qW0KEM99907mxZkTOzkf6bQYPsuF13tel0qBlQVFSUfzxhwgSrU6eOZcXEiRPzj2fNmmXVM/KZz44MAI0bN87q1q1rWUCi1LBFi7/b9wsusCw51j8YMMCyhPb9Ov/N8cfby3fcYfPq1bMsmDp1av7xDAYHatSwLJg5c2b+8aRJk6x27dqWFZMnT84/njZtmtWsWdOyFsvkclz1yVIpl6TfmpkkZlMkU2aZWTbCRZHsYjAonyhJZqh9F8mWcePGWaOExfKa6xYREREREUl8GZ5kXr9+/TIzbe3LNLp27eoe9+jRIzOlaL5Uo0+fPu7xoEGDrFatWpaVMo0OHTq4x717985MaQ5rlLJWeicltW/f3qpUqZKZt4XSJNo2DBs2LDPlaJRYt27d2j3u0qWLVatWzbKCMuv+/fvnZ1iyUlo/a9YsW3XVVd3jJJ7nyU+WXr3YbOUMFGn9Os7ssJuyd+xTZpq1uzL/LYlSlpKl6LGSKGUpWYoeK4lSVpKl6HGSKGUlWQpu5pCFNi6rbXugfSdRqlo1+WFJeS1YsCD/mAAyiUHksogeJ4lSlpKl6LGSKGUlWYqqlMDNa5LfKtGhNFjBMtGpZPXYRSSbstDGqW0XESloWrMkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEhAVatgM2ea9eplNnSo2ccfm02ZYvbgg2bHHGOJdvUdr9hFNw20Fus3tm9eudjS7vNvfrPLbn3J3vvsZ5tbNN+arbmKnXjYjtatS1tLgzlz5tgzzzxjP/zwg/344482c+ZMO/PMM2333Xcv9dqBAwfaSy+9ZH/++afVq1fPdtppJzvqqKOsZs2aljR//PGHffHFF/brr7/a1KlTrXbt2rbGGmvYbrvtZqusskr+daNHj3av489x48bZokWL7IorrrAk+/nnn+3uu++24cOH28SJE93n16xZMzv66KNt5513Dv6d+fPn2+GHH+7erzPOOMO9NomfOefwqFGjbPr06Va9enVr3Lix7bXXXrbpppuWeC2f8zvvvGNvv/22+9x5LefHoYceamuuuaYVspmz5lqvewfb0K9G2sfDRtqUabPtweuPsmMO3K7Ua7//aayddfUA175Vr1bF9mnT0m7qeaA1bLBCmf/+o89/bJ27P2R1atewmcNutiwc+8+jJtjFfQba4PeH24xZRbbGaivZIXtvYVd372iFgGu4U6dOtv7667uvFVZYwW699VYbMmRIidfxs7Zt21rz5s1t7bXXtqpVq9r+++8f/DdXXHFF175vtdVW7t+nDaSv+OCDD6yQzJo1y+644w7XTn/55ZeuPb/55pvdtRq9np966il7+eWX7ZtvvnGvWWuttaxjx4528sknl+rD+vbta++//759/vnnNmbMGDvkkEOsT58+Vmhq1Kjh+up11lnHfdWpU8cefvhh++ijj0q8bocddrBtttnGVl11VatVq5ZNmzbNRowY4frzyZMnl/nvr7vuuta9e3f3+Nxzz3XvdSEgTunVq5cNHTrUPv74Y5syZYo9+OCDdkwswL733nutX79+rq/jM2/SpIm1adPGLr30Uvd+xdHWX3LJJfbiiy/apEmTbLXVVnMxwf33329ZVeHJ0sSJZsRUa61lRj/81luWeKPHTrFr7nzNdZJZ8Pq739l+J95lm2+8hl38v/ZWt3YN+/m3iTb6zymWFgSNjz32mDVs2NCaNm1qX3/9dfB1NEQDBgxwjW6HDh3s999/dw3Kb7/9ZldeeaUlzbvvvut+9xYtWrgGccaMGa7Rveuuu+yEE05wnQpIIOkw+X7llVd2DWjSjR071mbPnm377ruvSwznzp1rb775pp111ll24YUX2gEHHFDq7zzxxBMuSU4yggKOdbvttrOVVlrJ5s2b5z7b22+/3QWF0UTxoYcecudD69atbdddd7WioiJ3vnCeFLqJU2bZFbe/bGs1qW+bbri6vTV0RJnt+c6H32wrrlDLrunewWbOKrIb7x9sX/84xj4e0MOqV68aTEZ63PBswfYBFXHsX373u7U5so+tvupK1v343a3BSnXst7GT7fexhdMPkByRHIwfP95Gjhxpm2yySfB1W2yxhQuuGTAgMFx99dWDryOgvuaaa9x1QjtPoEnbT8B80003ufazkK5rkiOOZeONNw4mcwwK0r5tueWWbqCHdu/TTz+1G2+80d577z2XSFWqVCn/+v/7v/9zicFmm23m3tNCRXK0zz77uH6JwSCS4BAGeBgYGzZsmGv7GzRo4D7Pli1bus+Z5CmO94MkkTaz0AZEORYGLUl4Geh6q4wAmwSauIaYhf6bwT4SKM7pr776yiVPHjEN7wlIoDmfxowZ4/qBLKvwZKlxY4ISs9VWM/v0U7Ott7bEO+e6Z6z1Zk1t4cJFNnHKTEuz6TPm2NHnPmz7tG1hT99+glWunM7Kzfr169sjjzziGhJGmuhQQp3Rc88950Yk/SgTaGiYoWB0Z9ttt7Uk2X777e2ggw5yI6seAQadJIEAPwOjccygVatWLT/alHQ77rij+4oi0OrcubMbhYsnS3z+dDBdunRxyWRS8fnGg0gSIZL9QYMG5ZOlTz75xD788EM75ZRTXHCZNI0b1rOxH15rqzVc0T79epRtvf/1wdddc+erNmtOkX32/PkuucA2m65je3S51R565iM3gx531f+9aivUqWltt21uzw0eZmk/dmYkjjqnr23YbFUb8uiZVqtmdStEjKwfe+yxLqlhNoAkIOTVV1+1Z5991g0UMChUVrLEbCvtO6PsfgCNv3v99de70XuujwULFlghaNSokZtR4k8C4Pbt25d6De33888/b1tHArEjjzzSJRG8V7T50cESZtB4b0gY1ltvPSvkwc7zzz/f/UniwOOQxx9/vNRzvFcXXHCB67tff/31Uj+njyAuIPmknSwkVAQw6MdAJ0lv9HONYsYxjhlYZkuZgYu+XyeddJKLB2j/SSalWIVHvjVqFCdKafHOxyPs6Ve/sD4XFQeRadd/4Cc2buJ0u/rsDi5RmjW7yHWcaUMnQoO4OExhL1y4sFSJlv+ecqWkoWOJJkqggWSGbcKECfnn6tat696jtKtSpYqbPaO8Ie62225zJTt77723pQ3XNgMGjLZ6JE6MRpIocc0zq5QkNWpUc8nCkgx47Uvbt+0m+WQBu++woTVv2siefPmzUq8fMXK83fzgm65UrWrVKpaFY3/93e/tmx/H2KXd9nGJ0uw589xgYaEhcSFRWhJmEEiUlmSjjTZyr41WGuRyOVeaxvXCjHwhlaKRKC0OZbShgNonVgwURlFyG51pKlR87iRKy8KX3zGLGEdZ+n777ecGCJmVKzR85iRKy8KX30WvF2KcV155xc2cEgcwm0bpuWiDh6VC53D6FU9a10O2t002CI9Epc3g93+wenVr2h/jptkGe1xmdVudZfU2626nXPKYW7uUJb7RoIGK8t+zBiYNCAYovaCjyAI6QUakKT949NFH3QhiPKCgvp8O85xzzklE8FAeJD+U01FeQ2LEMW644Yb594QyJjpURpe7detmp512mhuBZcQxLf74c6qNnzTDttpkrVI/26bVOvbFd6NLPX/mVU9Z29bNbe82LS0rxz74g+HuzxrVq9pWna6zOpucabVbnmmHnXG/TZ5aGOs3KgIDRKFBAv8cs1dp4EvsSACzgLI9BgAZLKT0GKxXjiNRIgkrpHLLf4KKED5rZqGYgQVrkbzBgwe7Pxkw5HkSSL7at2/v+oMsq/AyvDS5q/+7NuqPyTa4bzfLihGjxtuChYus48l32fEHb2/XntPR1b/f9vBbNnX6HHusz3GWFb5U47vvvrNWrVrln//222/dn2koTQP13HQQhVZyUFGo82cdmp9hoczyvPPOK5E83nDDDbbHHnu4z5367TR48skn87OhJIDMIB1xxBHue2YVOW4SI94TyjHpNN944w1Xishj6vyTbuyE4jUKjQOzMI0b1XOJQFHRfDdTg5eGfG2vv/e9fTXwQsvSsY8YWTzLfEi3+6zdThvbBSfvZV8NH23X3vWaW7P03hPdUzOIEMX6F675+Ew7a4LSlFxQpsV6r6y0+axP8pUSVBHQFjKrEu/vKcHjvaEtTAOOySf6zByx+Qn9mudnFk888UQ3YMgaXdaoXn755W6NH7FBVgZR45QsldOkKTPtkltedBscLG6HpLRhwS8lFycfsZPdeskh7rkD9trc5s1fYHc/9p5dcea+tv46i5/6TwtqtjfYYAMXWNPQ0IkyG0FjSilb0sqUQggImEGhhp1FvVnA7naMonHszLBQchYtPWDnuJ9++sklTGlC58dCb8owGGnkuCkzBeUXPpBgNoldAsEiYr5n96g0JEtz5v41WxzYxKHmXwnSnL8ShnnzFrhd404+fCfbeP3GlqVjnzm7uG3bepO1rd9NxSPSB7bb3GrXrG4X3Pi8vfHBD658L20YaWfdEjPKDzzwgCvJY52nX5tKWVvSETAzc3Lttde6nf+ygDW59NmUsLEeN/Q5HnzwwW5g9Pvvv7e0oMSOtp1jYl1ufFc/X37O+0Ib79eor7HGGq6f7N+/v3Xt2tWyKJ2r9SvARTcPtPor1rbTj25jWVKrZnGnefi+W5V4/oj9isuUPvziF8sSAkXWcdxyyy12/PHHu51oGH0imAzVPCcJJVk0oOz4w0YHad3MI47Pk+CHXfH4XFm3wwYfjCbSebBLHDtHLWtteKFicTAj5AR/lNmR7LMui+P2wQO7ZflECZwbJEzspuQTqzS0b0XzSi/S92XGtf5KHFinxIY+l5+xr6XB0hx7vh/YL9YPdCjuBz74PJ39ALvlMfPMtX/dddfZnXfe6XZdI3GKDiokFZs9sFkFgTAb12QFu7uSCLH76X333efWoe6yyy75nzOIRLvnKw7SgqoJSurOPvtst/MhM0b0b56PYdj9L9r/H3zwwS65LLTt8pcnzSyVAwt673n8Pbepw5jx00p0KPMXLLSRoye5dT31V6pjadOk0Yr27Yixtuoq9Uo83+iv2TXu35ElBI/MMFCewToXprXZGIJgOrr9ZtLQ6bMbIH+SBHL/qKxixuXqq692gRIjccwy7bnnnvnyO7Ya9sklz1Gik4bNLwgQOAc4PrZKRug8oFyHRInkKuklGb4EzZekRY0dP9216cysTJsxx6664xU79cidbfrMue7Lz7yTXNIH1K5VPd8upunYfT+AVRtkrx9gxzvKUVm/RwD5yy+/5Dd2SHJJLvdO415xzKqTMGUV229z7yzKznhPwD23uJ0CG0f4UkufSNDfkziEthlPEtbbbb755m6dLutR4WMYf8uQ6MZHDRo0cDFPVilZKudC2EWLctbtiqfcV1zTNhfbGce0tT4XHWxps2XLtWzQ+8Ptj3FTbYNmf19APmlsWD85wcG/iSTJr2GippcddaILJZOEZIAGkzVXjC4uaUeltIuWoHFPJdZvMbIWx+gyX5QmUJ6ZdH53MDZ3YCSdkpzQzmI8R3JYaPccWRarr7aSNaxf1z79+rdSP+NmrptttEY+GSAxuuGeQe4r1Ad03L2VPXfXyZa2Y/f9wL1PvO/6gagx43w/UNfSjKCZUlzP37yZNRxJRCLAoBil5Nz2Ir4jatbQnkXfAxIkyvP4iuvZs6crv6dsMelo66PLBxgwA4PB8b5h4sSJbmAwq7J9hZRTy+ZN7Nk7Tyz1/EU3DXR3Mb/l4oNs3bXSeRIdsveWdt3dr9v9T31gu273d0B435PvW9Wqla3NtutblrHOgxvVsiNe6L4Whc7f0Z3Gn8X97A6UFSS48QXaJI7UavN5UoZx2GGHuTudRzG6xswTOyVRupG0GUWSv/iMEcEgI+iU31GeB+7BwYYOlKv4Be3MpnFfEnbNS0uZJmtv+j7zkf0+ZrKt+dcW2m98MNx+/HW8nXXsrvkZlFAfcGvft+zDL361x/ocG9woIQ3HDhLBM658yh4c8KEdc2Dr/GdPP4A9dkzfeqWycH2wjonZpiTOLLGInx3gWJfKPXaSXj5eXpyztOvxLcC5HQRtOOs2PRLIOBIJ2kRu1F2e7ekLBW077Xb81ijcZJYt8f2mPqCvY7CUwVOSQj8g9tBDD7lqguhmEFmzXJIlSiI5t3y7MnCg2ei/diU9/XSzQl9TuEr9utZpj9KL3fs8OMT9GfpZWmzeYk077qDt7IGnufneQttlm/XdbnhPvfK52xGpyarF5TppwEJ+Fjz6+y7QmDCaAgJjthulESWgJpCmEWLanvpn1rgkcUaGGyyyCxAzI3QiBMJRfgSVzoEbHsIHCP5u4ZRsJXEzCBIePm92gWPEjJk1yu7YIpXPkxIz7rPCV5Q/fs4BasCTxpdbrr/++q4DpZyEGyozi8YMmu8gqeMngGCdBp0kQRXnO50mZSpJcDu7ds6YY2P+mhEZ+ObXNvrP4sesP11xhVrW8+S9XHvWtvMtdsYxbdwMUq/7BtsmGzSxYw/czr2WErtQO//coGH28bBRBdkH/FvHDu7ZdOGp7eySPi9au2Nvt057bGpfDf/DzTaxjmnrVsX3bCkEDFrRVvuBEMqr/M01X375Zbcmkevdr1Hx23/7G3Cz0Ysvx/IbILBWg+cpT2rXrp2bdS7EG1Mz081giC8VZsMablqK4447ziUMrE/imudm0wyGxBMHEgKPm7QyWAL6Ox736dPHfU9psh9EKQR8nrRRvoSYG2/7x/RV7NZIm8+sGm04syUkSdttt53r+zg3vHg/6Dc58LvfxjdG+C+x5oj+2fdLxDGUFeL00093ZcIkxqxDpnyUa4MkiUFeqgcuvvji/L9FMtmrVy9XYcL9I0mqqZy55ZZb3E3p4zdqz5LlkixxE+1Ro/7+/plnir/QuXPhJ0tZd9eVR7ibFjKq+Oygr2ztJvXt5gsPsjMjI49pwB3d/f0mQAfpFzQSFNPI0LGyKNY3vs2bN3cNcHQr8SQhQPb3mAjdZ8InS8ymsBg2yn9PLX8SkyU6ez7Lp59+2nU2fL4kRmx2EF3smzYEj++9954LCOn06SAJkg488MASnyOzT2yhzswju4KRJJEgUr5D55sEN94/2N3uwXvmtS/dFzp33MYlDMyovP3oWXb2NQPs/F7PW/VqVWyfNi2td88D82t2kujfPvaL/tfeVq5X22575C078+qnbbVV6hUnUKcV1k2aO3XqVGLgimCYL3DOkyzx8yOPPLLE3/Pfc7+xaLLE4AlbahN4k4hwQ9rHH3+8INeskMD5QBkkAD4J4PqGD6rZPjuOhf3RZIm/y7baHu8NX9ENYgppralPisF6HL78wCefF/05fTbPU3rHcwwIMUjmB0mT5sYbb3Traz3ui8cXOnfu7BJCdrAbMmSI6+tIDHmOpPmiiy7K35zWY/01FQZsaMLNaTnvTzrpJHe+sHYpqyrlkrSBPPc5iI/eD73eLEGLapfZT2PN2l2ZvWOfNMNmbXue+Yp4LvY0rJUoL4J4GjzQsKVhq9ryYvTWb9dNcJ+VchE6bV/uwKhh/CbIaVVzxgzrfPbZ2Wvjstq2B9p3dqTM0voZZniZ3QdropK+YUp5UbHhBxgJ5NOwQU55kaz37ds338cxSJcFs2bNcjcCTupxp6PoXERERERE5F+mZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIkqWREREREREyqeqJd2UmZYJU2dl89izcIwikt3rP6tte5aOU0QSLXHJUs7MZkefaHelZUX02GubWaWMHHu0O50yZYrVqlXLsmLq1Kn5xzNmzLAaNWpYVsyc+fcnP2nSJKtdm7M+/SZPnpx/PG3aNKtZs6ZlwbyZM921nsU2Lqtte7x9nzt3rlWtmriwZJkVFRXlH0+YMMHq1KljWTBx4sT841mzZln16tUtK2bP/juCHTdunNWtW9eyYNasvweFcjlavGSplEvSbz1hgs1q1MiycWqJiIiIiKTHuHHjrFGjRpYk2uBBREREREQkoGrSs9OsTFtj/Pjx1qxZM/d40KBBmSlHoyypQ4cO7nH79u2tSpUqlqUyDT5rDBs2LDOlaL5Uo3Xr1u5xly5drFq1apaVMo3+/ftb1tu43r17Z6bsdPr06dazZ8/Mnevx871fv36ZKTv1ZdZdu3Z1j3v06JGZcjRKrPv06ZO5WCYez2SpjSsqKrLu3bu7x0mMY5KVLDVoYPbrr2ZNm7pvCSKyFEhEj5XGJSsNTPQ4SZSyVNO+YMGC/GMamCQ2MssqeqwEj1kJIKPHmeU2jiAiK4FE9DizdK4jeqwkSllKlqLHSqKUlWQpepxZimUQPdYstXFRlSpVsqRJVhle5cpmDRv+17+FiIiIiIhkQLKSJRERERERkeVEyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFVrQJ98olZ375mQ4aYjRxp1qCBWevWZlddZda8uSXKiBEj7OKLL7b33nvPJk+ebGuttZYdccQRds4551jt2rUtLWbPnm0PP/ywffPNN/btt9/a9OnT7dJLL7UOHTqUeu2vv/5qvXv3ti+//NKqVatmO+64o5199tm28sorW5Kst9561rZtW2vZsqU1atTIZsyYYT/++KP179/fxowZk3/dHnvsYbvssoutvvrqVqdOHXce8D498cQTNmHCBEsiPrsnn3zSPvjgA/v999/dZ7fllltajx49bN11182/7swzz3Svi+M17777riVR48aNbZ999nHXcr169WzevHk2duxYGzx4sH399dclXrvFFlvYbrvtZquuuqotWrTIvW7QoEHu80+Dq6++2i666CJr0aJFqWPi3OB8+Pzzz937dMghh9g111xjdevWtUI2d+5ce+2111w7xRdt2zHHHGM77LBDqdfyeXId//TTT1alShVr1aqVO84VVlihxOumTp1qL7zwgn333XeubVxppZVs0003dedRIb0fNWrUsN13393WWWcd90V7Rbv+0UcflXjd2muvbdttt517De0ax37qqaeW+e9uv/327t9t0KCBTZkyxd566y33VSjmzJljzzzzjP3www+uDZ85c6Zru/idPa7fN998053Xv/zyi2vvua533nlnO+CAA6x69er51xYVFdldd93l/r2JEye6v7vaaqu5voDPvGrVCg2hlgq/6/vvv2+jR4+2P/74w70X+++/v22++eb51/D7f/XVV+785ZznNbT59H1cF/TjUZdccknw/8X7yfuVtLiFc+OVV16xkSNHus+9YcOGrr878cQTrUmTJiVey88feOABGzJkiI0fP969T9tuu62dcMIJru9IWhvnLViwwK644gr3+R900EG21157lfg558jrr7/urutp06a5a6N9+/bu2LOsQq/06683e/99s4MPNmvVyuzPP81uv53Aw4w2u2VLSwSCyG222cZWXHFFO+2006x+/fr24Ycfuovxs88+s+eff97SgmDg3nvvdR3C+uuv744vZNy4cda1a1cXIPzvf/9zje4jjzzigg0arXijW8joUDbccEPXeY4aNcoFQHvvvbfdeOONdv7559tvv/3mXte0aVN33B9//LHNmjXLJVZ0mltttZWdddZZLnhImv/7v/+zTz75xPbdd1/baKONXNL34IMPugb0xRdfdO9LNADjPYmKB5NJwnXMMRFA0ikQJG222WZ2yimn2KOPPuoCD7Rp08YFziRQvJYAqXXr1i6ovOeee1zCmWQEVyQ/BNRxHBtJIufGTTfd5F7LOcDgEUFHISNQ5hzmc15zzTVdwBvCoMcNN9xgtWrVcm0BAQjBAsd64YUX5gNinr/uuutcUMo5wb9L30Awxb9Nslm5cmEUa/BZEsxPmjTJBc7NyxidJEgmAeI1JAMERmVhMIwBQpLmN954ww0ycV3Q1jNwUAgIkh977DEXBNNexwc9wOfXp08f22CDDVwQSL8+fPhwNzhGIsG1UKlSJfdaBlBo/2njeW94/vvvv7f77rvPJWPnnnuuFQoCZQJcjofflYQgbv78+fbss8/aGmusYVtvvbU7T/w5TOJ47LHH5o89OiBGuxhVKMnC0sYtXKckRSR6DPxw3j/33HNuwO/xxx93541PGIhreE8OPvhgN6DG+/T000+72I8/Q+1lobZxUQwU0OaVhfeDtn2nnXZygyj0Affdd587L4iDs6pCk6Wzzzbr398sMlBjhx5qtskmZtddZ9avnyUCSQAXI7NKjLyCkQguKBIDguSkzaaUZZVVVnEjFfzJ6NNRRx0VfB0jLiRI/fr1yzecvDcEkAMHDnQjdEnBSPHNN9/sRlw8AmU6VI6DP0FgHDd06FA3u8bMFKNWScN5TMIUHU1lNI4A+fbbb3dfHqPOBx54oKUFI5B8RRFskCBz/D5ZYjaRwOPOO+/Mv44Ok6CK0bakJ0vMjpP8LVy40AXMUT179nRtG+8LwQXoQBldJaHYc889rVARNJLY8SefH7NnIQQGBMUkO8yYgECbNoEBFD+CTiBN8nH66ae7mSePoImAheSKoKpQkgbOY/7kd+JxyDvvvOM+R4JoEp+ykiUSItoFkg8CJ3B9EECRcNA30h/81wga6a85Z0noGcSKI/nt1auXGwDw2rVr546dQRI+Z58cMBhE+x7FQJr/zBkwLJS+n9+V5I0/SQLuvvvuUq+hDed3jp6nJIIMEPqEKVpRAK4JZk/TELdccMEFpZ6j7+7cubP7PEkWwXlO33Deeee568Kj7bv88stdv7/rrrtaUto4j/aA4+R8Dw3yE8vSHvCeMDACkqZevXq5BJFzpVAGhJa3Cj3q7bcvmShh/fUJqs2+/94SgxMM8Y6EJIETJxpoJh3HQoNTntEJLqLoCBOBI2UdhTLKWF6MxkQTJTBFzUgSI3CL48vvCmGUaVkwuhg/f5s1a+ZGogk24gioKU9Iq1wu5wZGmGXwatasWeqYmWVghJogM8kIlukE/YBAvN3jWiaQ8IkSjj76aDejHCrLLCQE+AQRS8Io9CabbJJPlLDxxhu79v7TTz/NP+eTgeh7Af//KKTZdNoz328tDud1ec5h2gM+c86XqLfffttdH7x/hYDPYEnJC6+JJkoe5Yig3V8Sqgr8yH6hIAlc0kw/rwkl9JzvKKucnHOkkNu68sYtIT6GibbxVI745DvK/z8455PUxnkM6DL7VlZJHQN/9PHMnHsMiOyyyy4ukfr5558tq5Z7wW0uRwlXccKUFJw4119/vR1//PFuVIFOlRFHRpq7deuW2EB5WVG/yzSub2CjmF3yI/JJRyMU6jjpkEiSaTj9qNOwYcMsTQkDMwzx0h2CRZ7jT0YiO3bs6Ebjk37+09HS6ZAgMWPAeR0t4yBppO6fdoDPmdfymNczGptUdIrMkjDSHAp2GV0l6GY0McqXK37xxReWdAQABEmMGMfFy7g49wkcKNehNIegnBH8l19+2b0fhVaa9G+ixAeUKUdRokaFBYNKlCcnmS+jjifDIFGgzI0ZSNoDStlImOLrXJLKJwqh9dcE0JRq0y9QpkbgHJ1ZTSIGxDhv//zzT1e+h2iJGck07TsxHucD7QOxwC233OJinCSWo7GmibiV2bJ4qaXHMVKaHm/LmjZtmr/eKXPMouWeLD36qNkff5hdcYUlBlOWV155pSu7oWTLo579KnaryBhfqhMayeE51n/QqSR5xo0OgWMhMIqjDMUfG6O3NLaUbqQFo0/MrFGe5REYUGJJUE0nQ1lW3759XcnDgAEDCmqh89KitJBZUnBsBAcs9veYQWFUncTYJ8cEF3ScdEBJxcJ1gl82tAjhHEAoCeC5pG7sEUVbhdDoLM8xwkygTIJMYEx5DzNxrF2Kzkh06dLF0oyAkeQ6PpPCc7xHSzO6Xahox0gWWPAfR5BJKZJHwHjGGWe4srY0oIySIDkeCJMks66NgQHaPMrPOP+ZWU9iwuBROkqMAs5dyhcpRfY43muvvdbFd6xhjV7rrG9MWn9HostaPipJKLOMl1tHk0iu9XgyteJf17dvL7NouX7iw4eb/e9/nHBmSetbGFmgdp3Aipmll156ySVPTGmy6UOWUH5UVtmJTyJ4TVKTJXaFYk0Gi35DMwckzhwbo6mcE4UyJf9vYNSUdSoEDNFabZ6L6tSpkyvXI2ikBprvk4qSUhatM1vGrnfMGkY7Q4JlNvZg5JndlggqWNPEei82PUjiToisvWGnK3b49Iua43zZGccbxzlfCGtU/ikfMIWCH9+++WTJB1H0Bb5sj+uF84fZZmab0or2jsQohPcnqW19dECEQRIGhEK7GjKTQuBMssjAGIMkJAxpQCkla5XY5Cdafgz6wShm2BlkYYCFx4VUero0br31Vnft8zkyMxxqy7jW2QTk0EMPdX0dG3owQHjZZZe5hClJSPaZBT/55JMX+zqu5cW1hfP+ai+zaLklS+yEt88+ZKhmTz/NQkNLDGYXCIy4WPwaFhb+MwrNlObhhx9eot497XzwFKph9hdTKMBKAgJmSssouaBB5DOO81srE2BTesJ6DxrbQt8drDzllaxHIfBjtmxJo6Z0pLxHzDAkOVkiEeILjJxSmsZoou8QKVPjPIhu8EA5Hp0mi97vv/9+SxrOcerxOday+MDJD45EESjGA6sk8kF+fM1itH3zgQI7fd52221ukbgv2yNgJHFkwIDtetNSlhVq18tqD3h/khxEsQ6LTSHYrITNG0IInP1aKHYFJLlioIFNfwplg4dlQZkpyT6DROWZKSKQZr0LmzhxWw3WKCcRMyzgmqWKhISIWUX+BJu1nHTSSW6LbQbGQOk1M+q0+yw1WNz23IXEb6fP+R1fgxW6lhfXFlZP+KDIP7FctrVg5q59e6b4zF591Sxp/ckdd9zhOsX4Yn8CJYLqNNTuLw1ffheayuU5pmyTeFHRWNIBsgaHRrI8W4FT88zoFA1uklFOeOSRR7o/2UKXGdMlIVgmUGDqPk1IggmGKT1kEIQa9fiaNK57Frsy4pg0zIYQ5LHekoCHXZT4IgGiU+QxaxJ9+Z0vx4viuTQkBosrL+E52gKfLDEC79cvRLFeiTKXNC9+pl0gWYrPuvAc71FSy3Pou5kdZl0eW0WXF4EyQWj8vlVJQvJPEE3p3X777bfU10waZpZ9qSEzSNHBTpJBBgB8ebbn+/kkld2zux0JEAki8RlfPrahH+N7nyAxWMy1THtW3nLlrKjwmSVmqrkOf/zRjNL4wJ4ABY9R59Dokc+2Q5l4mhFE8n6wXiWO7TbLuqdHISMgotSMAJCRI0aWlnaDgKQiSGbNBaUYrNUp7+dHSQpBddpmVX2iTzLot0kNbZdKoJjEbVQpx2CmjGSJrzgW87Ieg81sGElmR7hoSSZBBCVL0eeSinaMmdTQPWkYBPEbG/iEITTT7MvTyipTSwPfHjKTEN1un++5BpamvSykXVDZaplkga3Vl2b9kZ9t9bumJQ0L+amYob9jNmVpjt0H2qHNIJKKzzM6O0q/RsIQv6Z9rJekmI+Sa5Ii7gsaRwkiXwwSs0si7R2VIvHBsF//WpsbbQ+zpkJ7es4zZjU//NDsqaeK1yolEcEjI1CU4UWxYI6OIuk7wywL7jHARcXMikdJGgvGo3dLTwI+QzYzYHSJRbyhG7vxmtCub3S0BAyM0iURnQF1zOz+xmxDfOczn0yFtsjlPjR0KNyTIYlCaxP4nCkzoePk3GY9EgFyfNE3I3DclDOJQSILttnNK/7FDBodJo/Z+ZNRRK5l7qUW3VaXkiXOh7Ss0aEEiXKk6I0aufEog2TRz52txEmY4u2D3wWuUO6xVBE4Zj5zf88pj5F3Ak1fmpykZIHBAAb+CCLLKhsPjbL70XokcWcw2jTuJ0Ubxm0ByhroCyWCfNbcY45EKWkzy2Vtp8+5S/8d3d2Xa5nPPX4blFcpjTIrcbP2QkcZIWvxol/+PlTckJrvfbUQ99MicWYDJ4/34e233873eVlVoTNL3btzw8/imSX6ofhNaDt3tkRgpxR/R2M2c2AknRp1nmM9Q9IajSVhdoHgyC9cJyliPQsYhWIk9rjjjnOLPKnrZc0WIxcEUVxMlCcmyTHHHOPqtQl6OLZ4SZ2/lwjreKhVpqMlgSBJImnk2J9iNCCBCBjo+PfYYw9XTseOUFFsaMJ5QL0z65L8DQt5T9544w2XKO21116WRNx0j8+VjtLvAsR5QAkiOz4RGPDF4ljWKTDbwowKf4egkSCDGyEmDR1jaI2Zv9dS9GeMvNOhck2wbpPkkJt0cj6wS2ihYz0G16cvI6Gc0o+Mc+0S9LFOhcECbu5IYMFnzufKRi/RdQm8nnOBdUs8ph9gAI12g0Cr0Eoy+cyYHSXIAZtS+McEQ7RhrGHwa1X8+hP/uZI8+kSQKgr6vMMOO8z1eVQV0NYzsMDNLXmPCwUlVAT6PvnlGHzJOOVm7PTF5iYkf6w9ZlvsKK5/fx8m3if6eXZK43lfds8X71uh3ayVNZeUx/nBDZJcf+5zDBz7ww8/7F7DuR0fAGam1Sf9/FtscsQgIgMn/JscN/8e71uh7Qi3pLgFXOu0XVyrXBu0/exwzMAZ57XHeUI8wyZevIf0e7wXzz33nHtcSAOES2rjuK7ja8v89UDsyhITj/aAATLaPwZSKTnmMx8xYoR7f5JYSfFvqdCz3d/YfuDA4q+4pCRLBEZ0kpRnsX6JaU1KVQgkevToYWlDIxFdp8DFyJdvbEgo6DhIHqj3JnggcCSg5I7pSVuv5O8hQOcXWuRKYsBMA8kho/JsH8ox0iDRIJMoJXFHNPiSGkbQQjcTJlkiiaABZSE0C5uZaaERZaE7s1JJbUAJkEkEGAShsyR45D4SzKxE769DuQqla7yWe0uBGVR2RkrqjOLSzLpw3rORDdc21z6zTmyrmwQMBNBeR9ej8eWDR5IlAgRmljm3WcNBEEhiQZlhdNSdNo+NMQiYCCQJTkg+CL4KcYCIazZaIktQ5AMjEgjOd34e/9399z4R9Lj+CaBIKHl/aP9o+wrtXmNcvz5IBn03X/BBrm+vH3rooVJ/n+PzyRJJMLOM9AEMqDDqThJN4Lg063yWFwbzomtISWp9ubxP7HxQHWrvWX/nkyX+ZGCQdpLkimuBY/c7oSYtbmHXT353yopp0xgU4TkG++KD3lzXzKiz8x99PIOIJIxcG6xtK6Sy+/K0cUuDRJi/w/XOdcPs6/HHH1/mjWyzolIuNMdcwBgx8uUzjAwl/YaYS4MOgFIQf1+ENOxGVR6MEDLzAbY3LbQRrYpEQOOn/gnM01QnviSMfvkSVzqzQuqgKhKjhCRiWW/jbr/99sTuqrm0KA/qTilGxs71+PnOjG6absWwJCQ2lMKBRDxpA43LinbN7zaapVgmHs9kqY0rKirK32Ynif1aMoeERUREREREKpiSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiElDVEiaXy+Ufjx8/3urUqWNZwfF6kyZNstq1a1sWTJ48Of947ty5VrVq4k7bZVZUVJR/PGHChEyd7xMnTsw/njVrllWvXt2yYPbs2fnH48aNs7p161oW27hp06ZZzZo1LQumT5+eyXM9fr5PmTLFatWqZVkxderU/OMZM2ZYjRo1LAtmzpyZyVgmHs9kqY0risQy0Tg+KSrlEvZb05muuuqq//WvISIiIiIiS4FBwEaNGlmSqAxPREREREQkIHH1TNHp2mHDhmVq+paypNatW7vH/fr1y8z0LaUKXbt2zY9IZKkUjZnUZs2auceDBg3KVIkK5QodOnRwj9u3b29VqlSxrJQr8FlnvY3r0aNHZsrRKEvq06dP5s71+Pneu3fvzJSi+fLLnj17usddunSxatWqWVZKL/v375+5WCYez2SpjZs3b57dcMMN7nES+7TEJUuVKlXKP+YNT+Kbvqyix0rjkpUGJnqcJEpZSpaix0qilKVkKXqsBI9ZWau2YMGC/OMst3EEEVkJJKLHmaVzPX6+kyhlKVmKHiuJUlaSpehxZimWQfRYs9TGlRXHJ4XK8ERERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiElDVKti335pddpnZZ5+Z/fmnWe3aZhtvbHbuuWb77WeJMWvWLLvjjjvsiy++sC+//NKmTp1qN998sx166KGWZqNGjbL+/fvbTz/95I65Ro0atuaaa9oBBxxg2267raXFzJkzrVevXjZ06FD7+OOPbcqUKfbggw/aMcccU+q1ixYtsrvvvtt9/fDDD1a7dm3bdNNN3fnAn0kze/Zse/jhh+2bb76xb7/91qZPn26XXnqpdejQodRrX3/9dXv00Udt5MiRVqVKFVt33XXt6KOPtp122smShvP4sMMOs2bNmtnKK69sRUVF9vvvv9tzzz1nn376af5166+/vrVt29aaN29ua6+9tlWtWtX2339/SyrO2d69e9uwYcNs/PjxVqtWLXdsp5xyiu2555751/E5DxgwwF37nBOrrrqqbbfddta9e3f33hU6Ps/333/fRo8ebX/88YfNmTPHfW6bb755qddOmDDBXnnlFfvtt9/cec370a5dO6tTp06J17399tvu3+OLPqFNmza26667WqGpWbOmderUyZ27fK2wwgp266232pAhQ0q9do011rBjjz3WNtpoI1uwYIF99tlnru3jM/e4Prp06WLrrbee1a9f37WBY8aMce9Z6N/8r8ydO9dee+01+/XXX90XbRtt+A477FDidfzsgw8+sF9++cWdGwsXLrR77723zH+X9+L555931wx9xYorrmgbbrhhsH/4r9A377777rbOOuu4L85d2vWPPvqoxOtow7iOec3qq6/uzvdTTz21zPOoffv2rl9baaWVbMaMGa79eOmll1wfWQi4rp955hn3e/3444/u8znzzDPdexH16quv2ltvveWuXV7ToEED22STTezwww93bVvUyy+/bF999ZX792gbdtttNzvrrLMsqW0c/RnHM3HiRHeN0B40bdrUtV9c2978+fPdZ8u/N23aNMvlcu7nW2yxhW2zzTbuXMmqCk+WRo0ymzHDrEsXsyZNCMzMBgwwIw67+26zE0+0RJg8ebILhmlcNt54Y9fQZgHBFBcgjQWdJBcnx37llVfaaaed5gKKNKARueKKK2yttdZyHQONalmOO+44F0iSJPAeEDSRRPNeJRFJMIHCaqut5gIrgqWQxx9/3CWUO+64o51++uk2b948GzhwoOuYeL4Qg8bFadiwoQsGCPbo+Ak2WrdubRdeeKEbGBk0aJB7HR0FHS8DB+PGjXNtQJL5YOHggw92nznXNx0kgd8NN9xgnTt3dq8jeeZ6IIEiOCSR5LwfPHiw++LvFjICZa5jfneCIRL8EIKC+++/350LfM6+jeOzPvHEE11y7L3xxhtWt25da9y4sUsiCxXBEAN5tEkcN0FhCAHjVVdd5d4rPlveg44dO7qAukePHi55Qr169dxrP/zwQxc8EjRtttlm1q1bN2vSpIn7u4WA8/rFF190fRUJPQF0yNdff23vvvuuSxRXWWUV91kvru+//vrr3eNddtnFJQ20mWWdT/8VkqN99tnHJk2a5AJnEv6Qli1b2vbbb+9eQ78XTxS8SpUquc+X65z3iveINnPnnXd2iTX9JdfKf41E9rHHHnO/GwkAn20IiTHHStDPNczxkFgzOHrbbbe589t7+umnXbvIe8jnn/Q2buzYsS7pIcFncIz+jn6e64NEmevbJ0u0GcQBvJ5zgAGkV1991fUb9BlZVeHJ0t57F39FnXaa2ZZbmt10U3KSpUaNGrkZJf4kQ2e0JQu23npr9xW17777ugCZEfi0JEsEPzQodAyMwsSP2XvyySetb9++biQrybMLUQQLdBr8+d1339lRRx0VfN0TTzxhLVq0sD59+rhGFMw+cS0QoCQtWfr888/dV3xE8cYbb3TH5ZMlOopnn33WJYcnnHBC4pMlBj74imJmYa+99nKzpT5Zuvbaa0v9Xa53vp566imXMBcyEoZzzz3X/UlgyLGFvPPOOy5IOPnkk10gDIJornPa/K222ir/WkaXCSIYIPEBdCEiGOIzJahn9pdzOuTAAw90CdI555zjAmeMGDHCLr/8cjeb6q8BBgouvvjiEn+XWaWePXu6AJ1gldmm/xpBI8fKnwSOV199dfB1jKhzHlevXt1VTiwuWXrkkUescuXKbhCFILtQkTScf/757k8GOXhc1vlOhQDn/CGHHFJmskTiwewTg2T8HY/3ioFCAm9iof8aiTGfEdcl525ZM0Ch2TNm2Ihl3nzzzRKJwHXXXeeSL/q5gw46yJLexu0XKOMi4b3rrrtcG0cCDKpkGCCKIhaqWbOmq7rhmuH/lUX/yZolZvKo4pg61RKDUWcSJeHzq+ICa0bx0oLPtzwj5TfddJMbmSJRIjggaEo6AgY+zyXhWP1ok0fwwEgV718a8JkSNEbLr5h5IFFK+zXNDEG09CqEJAJLel0hYEaoPB07AwSMIPtECSQYjDQzuxYVLVkpZMwIkSgtCcEig0M+UQKlZgRe8dK1EEahufajs2//pWrVqrlEaUkYSafdWxIG0DgHGEigrSPB8LNthYbfqzzXJaV0HMeSECD710f5/0d5/o3l9Zkv63XpY7p4P87z0X4u6W1ciG/vKMv7N1+bVsutheNcnDOHwMPshRcYlTJL+XKfVOEiYcqdaV9GGJjCTeI6lX+CToIpe0aoGFFl6p6EkRE4RqIYpUuzLbfc0pUhMdLISBTnA7NNvAfUfScVwR6BEwkSo2iU3b333nuWdlzLlJoQDDHSTDliaJ0aZSgkkQTQDBaAUsy0XNMESiSKocSQNQtpxYg8QVConJAReq73OK4TrhcCacq5mE2mlCetgwnff/99Prlind/w4cPdLBOl+EceeWS5BpmSitlE+n1mJbhGmFEiiWCgkFk73oukXvO0Z5STMiOKJK41XtY2n2NnANAvNWDNbijxpn/nT9r9999/37UVtBlZtdySpe7di9cooXJlswMOMLv99uX1f5d/6r777nPlSKCzYESSBeFZ8vPPP7sFjyQLjOiwvoNRzFtuucVtFECHmpayxBCm+xmtZn0SX6ABZSq/VatWllS+BA0s9GYwYHGLvdOCUivKV/w1vffeewfLlgia/doERnBZr8jajTTwo+ah0VlmEkgmCRgKZebk3+RH40ML9XmO94Tjjs6kUIIdLdOlDItBo7Ty61C5TihJo0SJwQPWajJwwEY4aZlVjyNBeuCBB+yII45wpWoemwARDxRC2eWyYKMSPytGn33SSScFN31JI0pU/fVMyR1tPpu2hAYJKLX2mjRp4pJkbfCwHHCtUfo5ZgzrPghKzFI6GJVKLPplNJnFo4y601AWyjT88uLLDnkP2GHI7wbIaDyzSyyUTnOyxGgyC78ZXWRW0S8KZ70DC+STsENaCIEPC/oZNaP0iMQhjcFxXNeuXd16E0aMeQ9IFEPXdL9+/VyyxGwDu+PxuaeFP97Q5+2f4zVpPB98GVroM/fP8ZpossRCf2aiCDJZy8VgSVqThWjZEcfLGj3aBp9oMqBCpUGaKywYTGBhP7tAUpLIbOsee+zhEmYSpqQOEjETyoY1zK5kqbSM9ahcz8yqUW5b1oww8QxJJe8NG2P8+eefqZ09Lrg1SxtuaMZOjkcfbfbiiwSexVuH53LL6zeQf4JAmN2PWBjOaBoXEbvhMNOSFazN8Q1JdNt0RqApVaDjLNR69n/Deeed5xpNOht2DSNJvOeee9wx/9///Z8lFWUGdBx0nMyskBSymDvt2PGIckoWNrPFMCPJdJDxa5oEknIrRmD5vNkVlBHnNGC9A0LXrX/OvyZtfPATOj7/XDxA8kEWA2Zs9EKifdlll5Vr/U8S+eMiMfSJkv+eUXaqDdKKNXvMKDGQxAZAfO5sgENlBaXKlCImEVUQfH7MlLAJBqV4DBZlASV3rM+kTWe3TPo8KiniiGlYt8mGTsQ2zZs3dxvexNevZcl/dlNaZpk++cQsxSXhqcbFxkgzgWZW+HUNod2DmG1hNDYNGz6EMLpIp+l3zfEoQySJLoRdkf4tHCeJRGgdS5pRYsXOSIsLAClFogNld8A08OV3oSCAmWQGSNI4qxQtvwstjuc53pMlDf5wrbBrWFID5yXxm0X4rZU9EifWOKa1vQel9iTN8U1OSJpAMJ2GXXBJIBZ3q5C0opKC4y9P392iRQs3cJLUdWr/hv+sF2CzB7DhgySPX8OQ5s4ijuCZHfNCCSI3aGRGIq3bavp7TYTq1AmoKOFKC19WFL8hadr5cpQljR7yurSUZBAE8zlz/YYGCAr9XlL/9JpmoXdozQKDBdy4tbzXCusf0oiyY8R3FqTNI5lOa3sPf2zxXeH8upXoTFuS0ZZlbUmBx3GXp+9e8NegSZZKFuMq/GwP3aeT8/LhhylrMkvpgFRqhLaf5cLhvgR0lNzPIUuYuqbW2d9/BGy7y93dKVVKSwcSKsPk2Ng1LVqmRRkON+TdYIMNLGlCWwwTCHAPFgYD+JzTKLpNdLTTZEEvCT8lF2VtPc1nzehimnaPYlaEXe9IHDxm11ibyI5vacZNZilJit6QkxvYci+x6I3X4zMrHmXZDKCwriGNaNdIGihVigbUvDccd1pn1PzmFrT58V0R/T0IGUxIChKC0K1O2MmRnf1CAwZpwbGzUU0cnx+fcbSCgsHv0NKKz/66UX3S7zFY0DNLJ53EVo1mVO/wPv/5pxk3+2Y2r3dvaiMtMajTZ9tJfwM7AmYWPeK4444rs0NJsttvv90t6CZooEOldIMpay60448/Pr+OJy3HSoDoR5mpY/YdAot7Ca4vuOACd2NabuZ49tlnu+fYDY6O9JprrrGkYgtwZhRYk+AXcvudoEgQKcthjRI3IubmnSSGNKzc6ZzEgh3lkobjYESc3Z0YZWexOru8sYj5wQcfzI+iUWbkd3/zpSf+RoW8Xyx+TpIePXq4wIF1d8yccAzcZJmF+6xHZKaFxIEgms+cgJH3iR2SOE9o56K7YxUygly/PboPjnxS1Lp1a5ccUlrKOcBnznOMNLNVLuW28V2yKFOkjfCBM9sr+xIeylGj92r6r3GzaD5Lv90vQa5Pilh7QrvO9bv99tu7HQ65sTTvR6dOnVwAyW0CPM53bkJKskyyzZoGyrSYgeLvsZaxUDCQx7H5z5myMV9ySLvFuUwiTKIIjhUcB3iPODZQhsaxc26w+ynnB20F7w3HztqdQkI7RZ/sz0MSX//Yb2bA+cC9AqMzZ35jIo6NtbdgEyPWpnJbCAbL6BcZHOV84THXQqGgr6Y/8hUQHIMfFGLNDQnAMccc4zbj4Bg4z/ncBw8e7K4RdrONtxt+ZpWBI17LWi3QbrJuOSltHMfOtvfEcPRlrMPzg5wMeDM46FGSx33XuNY5T+jb6Rd+/vln1w+EthnPigpPlriX0v33m915J7uIMbXLVrRm3Pw8cEuPgkZQHB1NocPhCwTPaUyWaFxICjlOLkYaYkZhCI6jmxykZVtNgh+PAJIvv4sMiREBFIub2QGOhe4ETXSs7BiW5NF2tsb1ib8POPgC24syukqiyKwDs2gklmBklQ0fCi1oKA8CYkbG/V3J6XDoFNjs4BMWVEbWo3FPlSj/PfX8SUuWSIBY1MxxEkQS+BJUsamF30Kd65wtgxlBf+mll1yQxblPIE2ilJSdD/mMozNk3ICWL3C9EjRxXTPY9corr7i2jtlFznPOi/h6pc8//zwfXIOAygdVBJ6FlCzxWUVvpE475ZMAzlkSCpKGiy66yLXn7HBGYMgoMslBdL0Sz5FYc73Qz9Hu0Vbeeuut7v5chYTZb44r+pnx5YNHkiVfDRDlv+ez9+8TSA44Dzg/SC75+yTYBxxwQMFVEpDcRGcJSfZ9wk8CwXXMz+P3U/PfM8PqkyWSD+4fSLJB+8BuuDxHksl7VUil16yh9IN7oN3yM6Nt27Z1gf+ee+7pEmfaBAZEeI7kksHA+Dpk/m50sIB+wa/l5N5ahZQsLamNo2+jf6adYlCI65rn+Ew5/uiaRdowKiq+/vpr91lzfnO+tGvXLnXx3tKqlEvYdmZ8gHTuIONNa610CA28v58Njba/w3ba0RCQrIAR8SytJaED8A05SVqaZvKWhFFCtqn1mw+kdaF9HAGNv6dZlts4gvi07rIWR7vGzEXWzvX4+c4gTJq3Io+jUqU7N6H8ayv/tO68GEeizu5qWYtl4vFMltq4efPmudurJDWOK6xhERERERERkQKhZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiARUtSRZtMhswgRb5a9vK0+aZJXnzLFMWLTIqv/6q23w17d1R4+2yg0amFVOf75bY/r0/GfO52+1amXiuEUyZdEiqzJ5cv5arz1rllWfP99SL5ezWpMm5dv21WfMsLm1almuUiXLghrz5uU/85ozZliuWjW17yJSUJKVLE2aZHWaNrUJ/vttt7UsWdXMhvtvzjzTsiJnZu39N02b2vhvvzVbJZ8+pdr48ePzjydNmmS1a9e2rJg8eXL+8dy5c61q1WQ1V8uqqKgo/3jChAlWp04dywISpY3btPm7fb/5ZsuSc/yDt9+2LKF9n+2/ueAC63v55Ta3bl3LgunTp+cfz2JwoHp1y4LZs/OfuE2ZMsVqMQCaEVOnTs0/njFjhtWoUcOyYN68efnHuRxXfbJUyiXpt2ZWoVGj//q3kOVsFjNpetdFUo3hj3yiJJmh9l0kW8aNG2eNEhbLq5ZJREREREQkIBt1LZIavXv3zsy0tS/T6Nmzp3vcpUsXq0Y9f0ZQqtG/f3/3uF+/flazZk3LSplG165d3eMePXpkpjSHNUpZK72T0iPOWSk79WXWzZo1c48HDRqUmXI0Sqw7dOjgHrdv396qVKliWUGZNZ81hg0blpnS+tmzZ1urVq3c4yQec/KTpVcvNls5A0Vav44zO+ym7B37lJlm7a7Mf0uilKVkKXqsJEpZSpaix0qilJVkKXqcJEpZSZaCmzlkoY3LatseaN9JlLKULEWPlUQpK8lS9DhJlLKyHhULFizIPyZpSGLi8E9VSuDmNck/Q+lQGqxgmehUsnrsIpJNWWjj1LaLiBQ0rVkSEREREREJULIkIiIiIiKiZElERERERKR8NLMkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQmoasvZ1VebXXSRWYsWZt98Y4nx1kc/WtvOfYI/+/Cpc6315k0tjY7p8bD1feajMn8++r1rbPXVVrIk+/XXX+3DDz+04cOH26RJk6xu3brWtGlT69Spk6222molXjt27Fh74okn7KeffrIqVapYq1at7JBDDrEVVljBkmjttde2bbfd1po3b24NGjSwWbNmufdj4MCBNn78ePeaSpUquddsttlmtuaaa1rt2rXd+/Tpp5/a4MGDbcGCBZZEo0aNsv79+7vPcurUqVajRg13fAcccIA7Xu/mm2+2N954o9TfX2ONNeyuu+6ypOFzHTJkiI0ZM8Zmzpxp1apVs4YNG9oOO+xgG264Yf51l1xySZn/RrNmzeyYY46xQjZz1lzrde9gG/rVSPt42EibMm22PXj9UXbMgduVeu33P421s64eYO999rNVr1bF9mnT0m7qeaA1bPD3dT1y9CRr2ubi4P/rsT7H2WH7bmVpPfbLbnnRLr/t5TL/f+890d122HJd+69xPvfq1cuGDh1qH3/8sU2ZMsUefPDBEufqokWL7OGHH7ZnnnnGvvjiC5s8ebJr7w877DA755xzrGbNmqX+3fvvv99uvPFG1zbSRnTr1s1OP/10KySzZ892x/XNN9/Yt99+a9OnT7dLL73UOnToUOLYX3zxRXf9//DDDzZt2jRbffXVbc8997SjjjrKtYHen3/+aS+88IK999579ttvv1nlypVtvfXWs+OPP75E+1gI+Mzor9dff333RX986623uuOM2mOPPWyXXXZxx1ynTh332fN+0adPmDChxGufffbZ4P/rkUcecedOIaC/vuOOO9x5/OWXX7p+jP7q0EMPLfG6Rx991AYMGOD6Os6LVVdd1bbbbjvr3r27O5893oezzjqrzP/f7bff7vrHLFquydLo0WbXXGNWp44lVrcubWzrTdYu8dx6aze0tDrpsB1t9+03KPFcLmd28iWP2TqrN0h8ooRXX33Vfv75Z9tyyy1dAEwHQiN71VVX2QUXXOAaVtCw3nDDDVarVi3bf//9be7cufb666/b6NGj7cILL7SqVZf72MM/Ruex7rrr2ueff25//PGH1atXz3Um559/vgs6SA6rV69uRx99tP3yyy/27rvv2owZM1xwse+++7rguk+f8CBCEpKGOXPm2G677Wb169e3oqIi++CDD+zKK6+00047zdq1a5d/LQkFAVIUSWMS0aFyrCS/BBXz58+37777ziWOBFZbbVUc9B944IGl/i7nyEcffeSCpkI3ccosu+L2l22tJvVt0w1Xt7eGjgi+bvTYKbbz4TfbiivUsmu6d7CZs4rsxvsH29c/jrGPB/Sw6tVLXteH77eV7b1LixLPbVdgg2X/9rEfsNdmwX6uZ+8XbObsolJ94n9l4sSJdsUVV9haa61lm266qb311lvBpOLYY4+11q1b28knn2yNGjVyg2UkFgyKvPnmm26AyLv77rvd67gezj77bNcG0hbw75x33nlWSNf1vffe6wb4SBg+++yzUq+hz7r88sttk002ccez8sor29dff+2OkeSSP/2xv/322/bQQw9ZmzZtXFvPoNhLL71kp556aqkk7L9GO0aCQJs+cuRId3wh9Fvjxo1zx0qiwWdPH0ibR5JAch1FAhI/h+gHCwUxCckRMcrGG2/s+q8QEkKuCZLiFVdc0X7//XeXQDHYyZcfFOaauO2220r9/Xvuucf1ETvuuKNl1XKN7s45hw/DbOFCGjVLpJ22Ws8Oar+FZcV2WzRzX1HvffqTzZ4zz47ssLWlAY3lCSecUCLZ2Xrrre2yyy6zV155xbp27eqe4/G8efPsoosucrMwvvGlsaKR2nnnnS1pCAwYeV3IRfkXOlmOca+99nKdJZ0ko6rRTuL99993s0v77befbbDBBm6UMmn4jPmKIig488wz7bnnniuRLDGL2LZtW0sDZhH5imKkmFkyzmOfLBFsxjGyTjBVVjBSSBo3rGdjP7zWVmu4on369Sjbev/rg6+75s5XbdacIvvs+fNdcoFtNl3H9uhyqz30zEd24mElA4QtWqxpnTsV1sh6RR97qw3XcF9Rv4+ZbKP/nGpdD9m+VEL5X2ncuLEb4CH4Y+Y7fn2DwR/ar+233z7/HO3/Ouusk0+Ydt99d/c8gykMhO2zzz729NNP51/LDA2DKieeeKJLOArBKqusYq+99pr7k8CWmaI4Bn0eeOCBEtc2MwW8bz5h8rNGtAMkR9HjO+igg+zwww93bUUhJUskOSTAJIwM/tFfhRD0xzEL2bt3b9e+x2eMmH0naSxUJHskdPz51VdfWfv27YOvu/baa0s9R//G11NPPZWfJaXShK8oroELLrjAVR7w/8mq5bZm6Z13zGhrEjoIXcKMmXNtwYK/g8us6f/CJy5gOiIlyRKj5PFZIaapmzRp4jreaBJBkOgTJTCaw2vpmJOIBCiaKIFyBB9wgJ+HRtNonEFHmxYkRQQblPPE8T4wmpxGlNgwq8jIc1lImgnC6EwZnSx0NWpUc8nCkgx47Uvbt+0m+WQBu++woTVv2siefLn06DxmzS6yefMWZPLYvcde/NRyuVxBDZpRRhYvnQ4lS9FEyaNaAN9//33+OSoMGBRiNiXqf//7n5uZIJkoFBwXbdfikCyFBkH8QBCDIR5JRzwR5P9B0MzsDMdfKGibSJSWhS+/oywvhGPmfStEnO/LmsBQRQPK8hZn0KBBrj/Mavmdt1yGg4jFSFwZoE/AgORiHXv+I65UoUqVyrbTVutar/MPsK0KpARheZg/f6E9+crntv0WzWydNf5OGtKGIIBGhITJj1xRfsboYxyzS5QypAllDdFEMYTgGqHEIklIEChLIxFilJGkeKeddirxGn7O2jT+ZE0bpYqsg6AkM6mYJaUEj2NivR717C1btizz9T/++KN7r0LBVlL98edUGz9phm21yVqlfrZNq3Xs5be/LfU8a3fOve5ZN2C0Zcs17eqzO9ieO21sWTj2qEdf+MTWbLyy7bzN+pYGrNFBNOFgLQj8bKtHyTYDDPy8c+fOlnQkhFhppZXK9VrWCIXWdiWpf+Pz47OmXcewYcOCSSSzL7yW0jVmYSjDTCrK9pgVpZz6pptucs8tqbSO2baaNWva3nvvbVm2XJIl1kCPGmU2eLAlVvXqVezAvTa3vdu0sFVWrmvf/TTW1XbvdNhN9sGT59jmLf5eJJdmr737nU2aMqugRhMrAkEzI1UdO3Z037OOCaERdZ5jlI3As1BHoJbGNtts40YUWQi8pPJFpuhZTJxk9913n1u3BjpFFr6ecsop+Z/zXlDfz0grHQ3ruxhRZhSW8gZmo5KIY/YzogT+zJJSblQWgglmYHldWoydUHxdNw7MwjRuVM8mT51lRUXz3UxN5cqVbM8dN7L999zUVl91Jfvl94l20wNvWvvj/89euPtk26ftJqk99rhvfxxjw4b/YT1O3KPE+p4kYz0qA0DRUiYGjLi+46P3zDZQYUCZVhqwMQQzK8waLQ4JA7NtlCkmtd3zbT6fIRgUZa2Xr5TwmGGkLJlZNNa0cl6wZo21qpQ7JhFJPoNjvl+jlJSBv7IwSMyarb322ssNEmZZhSdLDFiwqdLFF5s1TPA+CNtvsa778jrs3soOare5tdr3arvgxuft1QdPsyzoP/ATq1atih2yd3rXbdFBstid4NiXazAKj9AmDj5BSkOyREkhC2Upu2Mhf1loPDfaaCN77LHHXMKUZCTEjK4xYsrOTyREfJZefNc3v5sSAQavX1xnU8hIClu0aOFmTFkAzHHHSzI9ZpSYWWLheJJn0+LmzC3+nGsE1tzU/CtJmPNXwkCp2msPldwB7ahO29rG7a607tc+k7hkaWmOPTSrhLQMml1zzTVuoTs7i0VnV2jbfFAdx2h70ts+sIaJwUE29Vncrq4cKxtaUPpVaDsBLi2SBD5XStFYaxyaJevZs2eJ71nLxlooZhJJGH1MkCT9+vVzydKIESPc7nhLKitnUJDjPCDjJXjLZc0S24TXr19chpc2663TyDruvqkN+ehHW7hwkaUd29E+P3iY7bXjRtZg5XSOMjCDxG4wBITsgMRMA3yHGdom2wfWSU+UGFWlNp9OkZE2ShHLGp1iYwcWSSe5JMFj61R2hmNXPBZ4kxiwo1ZZx+8TLM6N+GhkkrBdOAMCHDsBAJ0iOySFjpu1Spz7bJWfJrVqFl+zRYH1R3OLiq/rWoFkwau/Uh079sDW9sMv49zOclk4ds4PBs1aNm9SatOHJGK7ZDa0YUvs6Iwy6AfKCoppJ5I+cMBuriSItGcHH3xwma9jEIXkgUG066+/3rUdScbgEBUCbI1OAkQpXlmbI3i0fy+//LKbYaHdTCJmDnfddVc76aST3GYXbE5Fsry4EjxmoHbddVfLugpNlkaMYPcRM3bcZbZ65MjiL9YQE1/yePJkS7Q1G69k8+YvcAt+0+65QV8V74LXcRtLI0ZZbrnlFvfnGWecUWKE0Zff+XK8KJ6jhCHJyRIjayxapvPnXgqh4wRbhbONOKV3zCqlER0KI2/UdZeF0VVGYZmVSQtmmThmv34hXoLHOcLOh2niS9B8SVrU2PHTXTIUmlmJYt0OJk8rnAXvFXns73/2s436Y3IqZpVYvE57Rvlp6J5pbF5DouDvOeeRQHGd+DWtSUTlAPdSY1Y9PosSx200GBhjh1jKtNOEtWqUVJenQoCt6ZGGkjTWX9Pml3U/KW6JwowjO8RWS3Bsk4hkiVhj0aLiZKlp07+/hg5lsXDx4yuusET75bdJrmShbp2/b+aWVpRecJwddkvX6LKfHSJJoD6ZEoN4J8joCsEx93CI8zcqTCpKCxlRpS7/zjvvzC90DjWubJXLDQqp+aZsK418TffidnsioabWPQm7wpWXnyGN74hHQsg5zlqlJN5LbHG4T1zD+nXt069/K/Uzbua62UZLnjlh7RIa1l8hE8f+aEp2QyUQZAc8Nm948skng+c2s66I73bK97R//udJw4ZE3ICXa/q6665b7HXNffSYgWG9TvR2CmlC5Uh57ptHmXp5dpBLCtr6so6F22cwi6wSvOWQLLGxEklr/KtFC7O11ip+fPzxlggTJpUeQf7q+9H2wpvD3KJfX66VVhz/4A+G2/57bGq1a4VruJOKTo97TFBiQOldWVPsW2yxhetk2FEmugiUBIvStCQi6KH8pFmzZi4Bim4dG8V2vJToceyUbUTX9CRVaKtZSi249xQzR9zEjxHkUF33448/7joSzomkKWtbdO7XwQhivMSGc55jTVsJnndgu83txSFfu/sGeW98MNx+/HW8Hdx+88X2Aewo98DTH1qrDVe3xo1WTO2xR3dDfeqVz23HrdYtsd140tBuM5vEABAb2ZRVTkf5EYv7GUSK4nuC68VtiFKoaOOpnGBAkERocbvasS7zkUceseOOO86OOOIISzJitND24KzD5HYI7AYa3+k1iveJ8nOqLriJfVKUta06OzmyC2pZu5uSLLE2N20zicuqQocJ2YGzU6fSz/t7LYV+VqgOPeN+V+PNltmN6q9g3/30p93zxHtWu2Z1u+7c4h3T0uyJlz6zBQsW2ZEd0nfhMKrI2hMaDWYT4hsbcFdrsHUm20pT48z6FmYg2BWHBmVJuwgVKnZ547gps6IjiTeM3KSQxOG0005zwQFlK/EbknKfirKSrELGTCKJENtls7OV3/mH8gMSSAIoEuFu3bq5Eg1/Xwpq3RlZJkH250aSDBw40I0oEigSFDBzxOdPiQkbd/B5R/EzZlVD2+YXutsffsumzphjY8YVBwsD3/za3UgVpx/dxlZcoZb1PHkvlwC07XyLnXFMG3driF73DbZNNmhixx64Xf7f6nHDs/bzbxNtt+02sCaNVrSRf0yyux9/z2bNnme3XFT2eo80HHuSdkPluiY49DvVcb5zTYOqAYJmznOu93PPPbfUvZIYLGPzE9AGsBkAJcqs6eHvUY7GQvmrr77aJVKFtv6K69nfO4jf1ZcQsnEPx86x8BrKD9mgJoo2zg+KMGhEWTqDRtweg/U6Udy8NnrPwf8aa47ow/xnwg2J/e/nf3fW4rLWll39aANJkkiI6QfYFjz6b3F8n3zyiWsXqSyhz2ercd6T0Nrl/wprjpgdoq8CfbS/7QdJLgNdzJ5yE2HKqOnHGSzgXKH95ybscSRRrFOl30/Lbpf/VLpqKipQpz02deUHbBU7feYcV3JxwJ6b2aWn7+02ekg7jr1RgxXcDQvThoYTJEyhBfs+IKYRpnSB5IqFj5QukDiwODSpNb0+AaCDDM0ckCxFOyB/48aoDz/8MJHJEvdSomOhIyV4IDDiBsXcCd7fxd4nkIzCsRsSs5CsYyDQoDwhiTPKJIck/QQCBAkkRxzTnnvu6dakRREoEHSyK2QSj5XbO7C+xnvmtS/dFzp33MYlDGs2qW9vP3qWnX3NADu/1/NWvVoV26dNS+vd88ASa3aoILir/7v2f/3etinTZ9tKK9S2nbdezy46tb1t0bL0vYrSdOzRfoDdUA9uX7gzqgxmjeJeJX+hreYL/p5Ivs1nB7i4Ll265JMlMKNO+967d29XjkbJNQvjmZ0pNMwCRe+PR8LDF/x9cnxQzUZGcaxP8f0A6zZB2fXFbGccQzVGISVLnTp1KrHFO5+h/xzffvttlxyz4yHtH89TesdzJJQkSj7B9MkCbSFbpDNQ5HeQIxEvtHsqstbODwaA/swnhwyGUjrIrCDboDMwQJLIc7xfJEqhJQT+egn191lVKbe4LZ8KDSdz/G7FQ683a5CsWvFl8tNYs3ZXZu/YJ82wWdueZ345JY1VfOQ7zRgx6t69u3vctWvXxCZly4JAvm/fvu7x008/neibIC4NRsV9UMcuXWVtXZw2tWfNsu7XX5+9Ni6rbXugfadENFQqlVbM+vh1MMzyJH13vfKinJv79PkELW1rIReHZMXf14/Sv/KslUpLf77eeusl9jpP3lChiIiIiIjIcqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREAqpa0k2ZaZkwdVY2jz0Lxygi2b3+s9q2Z+k4RSTREpcs5cxsdvSJdldaVkSPvbaZVcrIsUe702nTplnNmjUtK6ZPn55/PGvWLKtevbplxezZf1/pU6ZMsVq1alkWTJ06Nf94xowZVqNGDcuCRbNnu2s9i21cVtv2ePs+btw4q1u3rmXF+PHj848nTZpktWvz6aff5MmT84/nzp1rVasmLhRdZkVFRfnHEyZMsDp16ljW+vNcjhYvWSrlkvRbT5hgsxo1suw0pSIiIiIi6TBu3Dhr1KiRJYnWLImIiIiIiAQkeu5z2LBhmZm2xsSJE61169bucb9+/TJTjkZZUteuXfMjElmZtvZlGs2aNXOPBw0alJlSNF+q0aFDB/e4ffv2VqVKFctKmQafddbbuB49emSm7HTmzJnWp0+fzJ3r8fO9d+/emSk79WXWPXv2dI+7dOli1apVs6yUZPXv3z9zsUw8nslSGzdv3jy74YYb3OMk9mnJSpYaNDD79Vezpk3zb3gS3/RlFT1WGpesNDDR4yRRylKyFD1WEqUsJUvRYyV4zEpd+4IFC/KPs9zGEURkJZCIHmeWzvX4+U6ilKVkKXqsJEpZSZaix5mlWAbRY81SGxdVqVIlS5pkleFVrmzWsOF//VuIiIiIiEgGJCtZEhERERERWU6ULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiJKlkRERERERMpHM0siIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREAqpaBXvrLbO2bcM/+/BDs9atLRGGDRtm1113nX366aeWy+Vsyy23tIsuushatmxpaTFnzhx75pln7IcffrAff/zRZs6caWeeeabtvvvuJV7Hz9944w3358iRI23hwoX24osvWlJ98skn1rdvXxsyZIg7ngYNGljr1q3tqquusubNmwf/zvz5823TTTe177//3nr16mXnnHOOJdG3337rPjvO6zFjxtiKK65om2yyiZ166qm29tprl3jtokWLbMCAAe4cGTVqlNWsWdPWX3996969e5nvUyFbc8017bDDDrNmzZrZyiuvbEVFRfb777/bc889596PqPbt29vee+9tq666qk2fPt3ef/9969+/v/s7aXDLLbfY9ddfbxtssIG7Dry33nrLXnjhBfviiy9sxIgR1qRJE/v4448tCfhs+JxGjx5tf/zxh2vf9t9/f9t8881LvXbChAn2yiuv2G+//WZVqlRx53O7du2sTp06JV43adIkGzRokP3yyy+u3WvcuLHtuuuu7hwqJFybnTp1ctcnXyussILdeuutJT5b8LO2bdu64+V6r1q1qnuPQvbaay9r1aqV+zsNGza0N99802677TYrJHPnzrXXXnvNfv31V/c1e/ZsO+aYY2yHHXYo0Y59+OGH7pzm8541a5atssoqtvXWW7tjrFatWpn/PtfADTfc4B7fdNNN7n0tFDVq1HB99TrrrOO+OHcffvhh++ijj/KvqVSpkm277ba22Wabufavdu3a7pymvRs8eLAtWLCg1L/LMe67776uX+DfpP2j7+/Xr58lLXZ59dVXXZtGm8Br6Os5rsMPP9y17VFTpkxxcQHxAf8+79fBBx9sO+64oyWxjfNot+644w7X5u25556ljuftt992/x5fXBtt2rRxbVzWVXiy5HXrZrb11iWfW289S0yiRMdDoHD22We7xpaL6MADD7SXXnrJ1kvKgSwBjeBjjz3mOsKmTZva119/HXwdDevrr7/uGuTVVlvNXaRJRpBIg0NDSDDw559/2u23325bbLGF62hCCTFBAh1t0nEef/nll65TIQii43zyySftyCOPtIceeqjEuX355Ze7gJKO85BDDnENM53T5MmTLYk4zwkqCSDpGAk2SJIvvPBC15kQFOOoo46yAw44wD744AOXWK6xxhoucaLzvOKKKyzpSJIJpAmc4kgcSZa4BuLBRKEjUCYwYgCA352BkJBp06bZ/fff784FrgMCED7rcePG2YknnugSCP+6e++91ypXruyC7+rVq7uAm4CUgJz2sFAQ4B566KE2fvx4d9wEhCG0cRwzgx8c7+qrr17mv8k1UKtWLZcwMLhQiAiAuUbr16/vrk/ap7h58+a5to0Ed5dddnHvFckv5/nw4cPd4A9JRRz9Pv0j7UQhDpKQyOyzzz6uDadPDg1gcc4effTR7njfffddmzFjhuvradM33HBD69OnT4nX8znzfoDXT5061V1PhXSuL03swnHTFmyzzTZWt25dd86TXDMARJ9O8uTbjh49erjj7dChg3sf3nvvPTdgzsAoCUSS2rgoYhrasrIwEM57w0DQTz/99C//xsm13JKlnXYyO+ggSyRmDuhIaUxphEGiREbOxXPfffdZGnBsjzzyiGsY6BDPOuus4OsIFA866CDXadx5552JT5ZIgJkloCPxCDQIMPh84yNoBCAEyeedd55dcskllmQkRVdffXWJ0VRGmzh+Agpm10ByTBDCtZCWUabPP//cfUW9/PLLduONN7oOkmSJa4HHJFQkFNEEg0B6q622KjULlTScy8yUM+IYT3zPP/9895lzfhBkEUwmBUHwueee6/6kjbr77ruDr3vnnXfcTPHJJ59sK620knuOhNgPJPAZ+2CRmYvTTjvNzUSA940gi0GEU045xQoFyf+xxx7rgr11113XndMhjLQ/++yzLoE44YQTFpssUUnBaDRoLwsRQSPHyp8EjrRtcSS/tN3RgaCdd97ZBcr08VQLbLzxxsHzhPeVfp+AstCQMHC98udaa63lHscxc8T7Q9LgMVBIgrXffvu5meVogsmMC0kiA4rMMiQ9dqFiIm677bZzs1DMlDJgCq7nsWPHuvOHChIf95A4MrDCYMniZiALrY2LDiYwc8Q5zPGG8N7xPvJ587nLf7BmacYMLlZLnKFDh9pOO+2UT5RAFs9FxtR1ITciS4OLvzwjhryGRCkttt9++xKJEphladGihes44+iE6FQ6d+5sSUdHEG/06WgZdaWMxXv00Ufd+0GiROfJrFIacWwTJ07Ml1/xORNcMaoY5b8vpJKMZcEoI7PjzBqGMHNcCEHBsuBzK0+Z1HfffedG4X2iBBIMgudvvvkm/xyzL4y2+kQJtBucIwRWBJyFgqCYRGlJGGEmUSoPnygVMs5VEqUlnRehahBfusRnGUcf//zzz7uBk9AMbKF85iRKi8OASDRR8r766iv3J+d3NMZhRplBI46f941Z1STHLiGNGjVyf0bjOMrTOY98ogSOnTiQhDnaLiShjfP4LGnXoscVV6izxv+15XbmH3usWb161FIXr2FK0mAsnQkzS3GUJPCzJI22SvmwLo0p+mhgBKbrGXGmXCFUqpGWY2eGwQePjEbReZAsUZ5I6QpJAoEDM05JR+JPh0NiwOgqpUmU3sKXYMUDSl+GQ1CdVAROzBYcccQRttFGG1kWEVwSJFFiHcfsUjRwJhj150OUTyaZbZTk8okGJUihctR69eq5ti+NODbf1nuU5YFSvW7durmZddY2/u9//ysxcJzUz5rBBGahfOlhNIFgpjk+gAo/SJzE8jTWIDFTzvpbKcAyPM63Aw9kCtOMuPO778yoCKAs74MPGM2xgkdA9Nlnn7nggsW/PnjyJTyscZF0YSaFae3omhSSiNNPP92VqDGrWJ764CSiBIFSQ8qSfCPLsVPbTbBIx0lAQY14z5493WNm55KKciUWdoNrnJlk1qZEA2ACh+hooi/T8TXuScRaGz7bJ554wrKKQBCh0VnOa2ZQfZLEwAmzSyTK0Zl1v3ZxSaP6UtgoSWQANL6+i2uEEjzavUKdWfmn9thjD3euMygWn3FhMIXznuUGJEmUo/FeUKJGUpFEXbp0yf/uJIonnXRSiU0RGChhto1+0L8P8O9PIc0ilwf9NxUEzBRSOcLsmBRYskQMFY2jOnQoXrvUqpXZBRfQQFkiLixKr6hXpeaVUh1GI7iQQB27pAczhYyekRDx2Xus4WHh6NNPP21pRekd67TY6IJFv/Ald5Ts8B74YIJRVmZi6ESTnCwNHDjQLegnEKAWnYDIzyBQskINP4vbmW3j82fhOJ1rWaOPScCxsHaBWv0kJ3z/lA+YQjNG/jlew2N2S+NcYAMUNkVgRomZZp9QJzVwFHOBJCXXrOGMl9kxKESQycx6GjFQxMwyxxktr/YDAgwCsOENATcItI8//nh3PdBuJhFlxwx4s/spGyTEYzjW7TJoSF/IWj6qLFizyC6KKG/paqFgIxriVXZ/lWXznwyTUC7csaMZu5guXGgFj4XNjKSwENZvo8hIi18sWKg1zLL0mCVkRyHqlUmK/EwiHcYFF1zgFlMSLKcRa3XOOOMMN6LO9rj+2H2nyeLv6Kgr5z0LoxltC205mxTMIFJ2R6fJaCklt+yI5/FeMIvIrOI999zjZtNYFE1imdSBEo6JAOC4446zLPMldKHz1z/nX8O6JtoG2n42tqEsiW2Kd9ttN/fzpCbOWcfW0KxHorQ4vssZP/v555/zC//Thg1KGPCiPSMZiPIJAVU1PlECFTXMwBfadvlLg8FANm5hm20GwkkUGTTz2FGPXe+IB+jzSZj4OX8itCyjUNFHsbaegcAlreeTAtgNL454k2uRNXV/lcsWNC4oypIYWWTalpGYa6+9NvHrFuRvzJxQz0stMx1HdB0Do/B0HpTg+fI7yjP8SBvP8fqkBky+Lp2adWaK2ILV849DdeosBiWoZESykO458k8wWspACJ8nswbMwpAgsfiZBIN1LJwj7IqUxHUqzJaxwyOjq6zL8ygvY3aE0VYS5iws9PXnrC/Hi+JaoCwrOuvEPWoo1yGI4nnWufly7Pj6Ril8bO7xwAMPuEGg0IY9DJiRUPBZM5jkt2v27T5JQ3RjkCShtJiBYAa7SBbi/PbS8WuDxIlrIy2DxLTrJH4MlpE4eiTPXO8MilFNRJzntyRf3K6RhYZEmPOU2VFffudLhkmkeI52MDS7Ln/7z94dNmQhOQ+spSxYNIpcPB4BNRdaWu6zlGU0GjSUjBQzChPfOpZ1CTQqoVKMa665xn0x1c3N/pKGIJntQv2IeXzEkGSJUi1fdhpFAMHMU/zmnUnmZ9Lix0SS5Bf8U9NO8ljW9quFjECfzv/iiy92X3G0cV27dk3FPaSWhIEvPudQ0stgCMlQHAMi1P17zDww+xR9TpIxaEB5GTfjpazWz6RHMVBCqWXoRsxXXnmlawcuvfRSSxruk8StD+jXGByjPYjza/HiySDvE4Mp0c0gko6B0FAZLdd19H5VbJCAJPXzJL0MZrI5Uxxr8fjitgfRnRDlP0iW2G00MkjtsEvlCy+YsSlHUtdLMm3PhcN9dtK66DMrGHVhxoh6ZD5X1irFMevCjYmjSB7oZLkhZceOHd3UfRKPnfJCytC4Iz3lCSHUcDP6yFbT3LgVJI+MxlHOkMRrgJKE+M35CAQoxSGBZIYlhF0QWctGgs2mF0nDVtfMioVK8wiASJIK7aaTFYmBEdpyzgVfpkICxCLuJa3FI6BkrQvrN5JUmpN1DHr4m5BSXltWRUDovjyU5vFFCWsSZ18ZAOC4SARJFstaa8dOccxAcG6z+YUvS6X9p50M3Vaj0Ps6kob4bodUC1EZsqSdDinXZh0T70eSZpb4vOK7nbIDKPcUY5acGcYknsepS5YOPZQttos3eWBTEXbDu+ce1juYXXedJQIBIoEkFxMnFWUX7CDVtm1bNwKbJtTlciH5m1MyoubLD5h5YRSWJMGPqPstNB9//HH3JzvHJO2mpWzcQcPB8XHc8ZvQUp7BdtJ8RflyPGab4olUUtx8883uJnWsPaJj5KasUex85HeM4x4N3NWcRdB0OAMGDHAdKDfpTCLKaikloQzFb5XONc5o8YMPPphfj8RiZkYYKcegVIF7bXAfLtas+GsjSQgQQ9vH+ptrR39GmZLfHp7jpyTHb7VLkkESXcjY2ZAAyZcSERj5BJkgggTHr7vjM+c5RpkpXeE+M9Edsii9pN0nuOD8px3khsS8jg0fCg2fI+21L58lyPObeXCdU07GrLEPEn05OTcc9/dVom3wGBTxSTTXATMy/rUkD8xMFwL6Jo7Nf84MBPnyI/omBnY4h+nnOH99aZXHe+Lfi+jn7/lBFMqaCq30mM+S0lE/G0R5oX/MwBYldLTXtHu05/Gd//jM/f31aNtZp83AEDduJxYg/iHuIZHysyxJiV04dgY2ab+ZBebapw+nkoTrJL75AbMtlOJxPlCuzDXD583mT0lq4ygnj98awV8PHFs8keJzpa3zSTTX9VtvvZWfUUtq2WnBJ0vEkI8+anbTTdRJFs8yHXCAGTPXSaleYySGkRRKlLgYWeBP0MisQtrqPGkco+VWrN/wO97QSNKoUMYTTyj893QgSUuWfKNPYxtd5Oml4eazZaHsMDodH+eTJYIsZiMIMthWnY6UWShKUaJlCklCQMzi/Hbt2rlOkA6HGQW21Cb4i5br0NkSVNPhEihQelMoNyasSASSzDhF+e8POeSQgk+W+IyjN2cl+ePL31eFgInZJGYJGDUmgKSt55zmvIi27/5+XD44oYSPkkUC1EK8STcDONFtj5kx97PmJEEkFPycwY8o/z3ndzRZ4u9G23YSCp9UMAtXKMkSyX10a2cGN/26Mj8r7gPqZ555ptTf5ziTug6ZpD26uyXJnk/4fCmhT57Z3CCO6orozcg512nruc55PecMN+SmAiO66UMSYheOm+MgeaZdYFCE57h+qSxh0COKShESKRILrnUSJ66NQksWytPGLQ2ulehtUTgffv3rnGCApNCOf3mplCu0M34JSFb8NCqzGmlZZFgejJL4MikWnmal7IOGwCcslAmlaX3MktD4+0acTopRw6wgoOH+H2Ab87QNTJSFGS3KXrLexnHD3KRumLK0aNd8Epqlcz1+vrOuohATz4rCbD6VDaBKxe+8mHYkXdzcPWuxTDyeyVIbN2/ePLvqqqsSG8clb6GBiIiIiIjIcqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCahqCTZ79mzLkujxzp0717IieqyzZs2yLIke75w5cyxLose7cOFCy4rosWa5jZs3b55lRfRYs3Sux4+3qKjIsiR6vPPnz7esiB5rlmKZ+PFmtY1Lokq5XC5nCQse69at+1//GiIiIiIishRmzpxpderUsSRRGZ6IiIiIiEgaZpb4dbNWmhI69tq1a1ulSpUsC7J63NCxZ+9z12euzzwr5zp0vut81/meLbUT2J8nLlkSERERERFZHlSGJyIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZERERERESULImIiIiIiJSPZpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiJipf0/EPFvguQ4TX8AAAAASUVORK5CYII=", - "text/plain": [ - "" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Slicing — Cecka, \"CuTe Layout Representation and Algebra\"\n", + "\n", + "Slicing fixes some coordinates while leaving others free (`None`).\n", + "For hierarchical layouts, slice specs mirror the shape tree — use `None` for free modes\n", + "and integer values to fix a coordinate at that level.\n", + "\n", + "### Simple Slicing\n", + "\n", + "Simple row and column slicing on an 8×8 row-major layout." ] - }, - "metadata": {}, - "output_type": "display_data" + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "output": { + "id": 1656371888885622, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "base = Layout((8, 8), (8, 1))\n", + "\n", + "# Row slice: select row 3\n", + "draw_slice(base, (3, None), title=\"Row Slice: layout(3, :)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "output": { + "id": 4192437657684195, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Column slice: select column 5\n", + "draw_slice(base, (None, 5), title=\"Column Slice: layout(:, 5)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hierarchical Slicing\n", + "\n", + "These examples are from Cecka, \"CuTe Layout Representation and Algebra\".\n", + "The base tensor has deeply nested structure in both modes:\n", + "\n", + "**Base tensor:** `((3,2),((2,3),2)):((4,1),((2,15),100))`" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "output": { + "id": 1995543871400994, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tensor: ((3, 2), ((2, 3), 2)) : ((4, 1), ((2, 15), 100))\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0sAAAH5CAYAAABQ2aUhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAqzBJREFUeJztnQWcVFX7xx+kw1awAxUDOxETA8VAxE5QsVsQFTtfC8V4bcVATOxGxUZssVtsulN0/p/v2f+Z9+7dM7uzy+4y997f9/MZdpi5szv33nOe8/RpkMvlciaEEEIIIYQQohwLlP+vEEIIIYQQQggZS0IIIYQQQghRAEWWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWRAVWWmkla9CgQbUfP//8s65mLTF9+nRbZpll3HVt1KiR/fDDD8Hjrrnmmvz179mzZ7n3vv76azvjjDOsU6dO7p4uuOCC1rhxY1tiiSWsY8eOduGFF9q4ceNq9Z7Nnj3bnn/+efd3t956a1tllVWsVatW1rx5c1t11VXdd/zwww+Dn73gggvy53LyySdbXcJ3WGCBBdzf4nv9888/weO6du2a/0533313/vV///3Xhg0bZueff77tsMMO1q5dO1t44YWtadOmtsIKK9i+++7r3q9t+LtXX3217bPPPrbmmmu6e8n44Brz/8MOO8zeeeed4Ge33Xbb/Lk8/vjjtf7dpk2b5n4v947xxZjjvrds2dJ9t+OPP96+++674GcZF/67XXvttcFjmAOcK8cwN2bMmGHzi99//91atGjhvgv3ffLkycHjTjrppPx5Mb4rY+LEibbUUkuVk6ncs7oY+5dddpntvvvu1rp163J/Ly5DqnuPaovHHnusymvAXNhggw3yx7322mu1IofmlWeeecbOPPNM22abbdzYj17fqAypTP5V9uD3R+G8/Xtcj1wuVyfr0b333mvHHXec+xt+Hha79nOvbr/9dncvFl98cWvWrJm1bdvWjjrqqIIywcP7HMfxfI7P83v4ffzemsqJ+hzPIgXkhIix4oorIm2r/fjpp590LWuJCy+8MH9d99tvv+AxEydOzC222GLumAYNGuS+/PLLcu/ffPPNVd6z1q1bV/jcvPD+++9X+TcXWGCB3HXXXVfhs+PGjcu1bNnSHdOkSZPcDz/8kKsrtttuu/z34TqFeP311/PHLL/88rk5c+bk3xs7dmxRc6JPnz61+r1nzpxZ1N+9+uqrK3z2+eefz7+/+uqr5/7+++9a/W6PPPJIld+rWbNmuUcffbTCZxmDjGGOWXzxxXOTJk0K/g3mgv9dF198cW5+cdhhh+W/xxlnnBE85vvvv881btzYHcO4ZnwX+zv9Y5tttqn1777HHnsUvD89evQo+Lli79G8wrhs165d/jsxbkPcc889+WM222yzWpND88rCCy9c8G8OHDiw4OfOP//8oub2008/XeGznL9//7777qv1c/r4449rvPZPmzYtt+222xb8bNOmTXOPPfZY8LNDhgxx7xf6LL+X318TOVFf41mkAxlLogLHHntsbq+99ir3WGKJJcoJqS5dulQ4ZsyYMbqatcCECRNyCy64YP5av/fee8Hjzj777Pwxu+yyS4X3vbG05JJL5jp06JDbbbfdcuutt16FBWennXaqtfsWVVJatWqV69SpU2777bcvdz48WKQ+/PDDCp8//vjj88ccfPDBubpg6NCh+b+BsYkBEmKLLbbIH3fllVeWey9qLLGYb7nllrnOnTu7RTd+fQspAvNiLGF0rLPOOm4eojC0aNGi3N9s2LBh7rfffqvw+fbt2+ePueOOO3J1ZSxxXXfcccfc1ltvXUHZ4buGvtuuu+6aP+acc86pcnwxppgr9c3XX3/tFG1/nf/444/gcQcddFD+ux533HGV/s5XXnklqAzWtbG06KKLFm0sFXuP5pXbb789/zfWWmutggZV1Kn38MMP16ocqi1jaZFFFqmRscS5xddX//jggw8qnXsrrbRSbu7cuXVmLDVq1Mhd02KNpUMOOaTcsdxT5Fbz5s3zr+Ec++qrr8p9jv/zuj+G4/lcVIbx4PfXVE7Ux3gW6UDGkigKFu1ihaOYN6655pr8dV511VWDx8yePdsZQf64QYMGVThm5MiRuREjRuT+/fffcq8/9dRT5e4lXu/agkWKxfquu+7KzZo1K/86CmXUW8zjxBNPrPD5t956q9wCilFS23Tt2jX/N3r16lWlcoBC9euvv5Z7n+/F9b/22mtzU6ZMyb+OdxLDKXqeu+++e619d5QgFMOpU6eWex1HBdGi6N9FgYpzySWX5N/fcMMNc7UJfw8DDm9wVFnDuIg7W/r371/h84xh/36bNm3KRfKiMCf8cXURGaiKk046Kf/3d9hhh+Axo0ePzkeVeDCuCzFjxozcKqus4o5bYYUV6txY4jo/+OCDTobzqI6xVOw9mheiDh3GawgcEFFlOO7wmFc5NC9cccUVueeeey43fvx4ZxzVxFiq6j7E4fyjhuCTTz6Zq01wbjBnGceMV75fMfrAp59+Wu64ffbZJ78effTRR87w8u9179693Gf33HPPcgYaxwOf5/dEfy9/pyZyoj7Gs0gHMpZErRlLCDFSbFAOl156aacs4GXr2LFj7sYbb3QKflWpB/xeBD0eabxXPFBIWPzi/PPPP7nbbrvNedZRxhCoCy20kFM88BgRfh81alRQkcGLtNFGG7nvx/fk+xJ54fvHjYv4+eP1Y3G64IIL3MKLUh9VauLHVpc11lgj/3miRyFQdvwxRBmiCnsxRD3KXLvaYvLkyW4xDXHnnXeWu9c777xzhWO49sstt1yl6WTzuugTDfC/nyhTiGOOOSZ/DBGmOIxllKFiogTcz/rg1FNPLfd3n3nmmQrHfPvtt+WOCXmpawoGZKHUvnPPPbfc3+X6xmEMM5b9MaF0PejXr1/+mLXXXrva3zMakaiuMcK8j84doiAhLr/88vwxjOeQTPH07ds3fyxKdl0bS1GqaywVe49qyrvvvlvu+zBeQyA7/DFE8GpbDtUW9WUswYEHHpj/PGtZXVKssUQacvQ47m8Ushr8e6zDpJYDP6POhvg9Gj58eLnfe/rpp9dITtT1eBbpQQ0eRK1AEeWuu+5qe++9tz399NP2559/2t9//+0Knyk4P+GEE2yrrbay8ePHV/p7zjrrLNtjjz3sjTfecAXjPF5++WVXLEvDgihHHHGEK/ykwJVGBXPnzrUpU6a4As9nn33Wzj33XPd7ovD/tdZayy655BJX4Mv343vyfSmc5fvz9ykQLsScOXNs5513dgW53377rft/bcHvi54nzRlCPPnkk/nnG2+8sWveUCycJ8Xknh133NFqi4UWWsgVUYegeD0KhfFxKLblXofOszZgXPhmDhQBb7nllsHjnnrqqUrvQZMmTWyxxRar8XnWNoz/5557Lv9/xkOHDh0qHLfaaqvZsssuWyfX1zebqOk14TtvtNFGVX636P34/PPP7ccff7T6AvkRnTvFzE/fWCPExx9/7Jq0wEEHHWRdunSxUqbYe1RTor9vueWWc+M1tNa88sorld6DeZVD8xvGNc0UDjjgADvmmGPsv//9r1ujKiN6HYYOHWozZ860+c3w4cPzz30DiijRscQ67JtufPDBB+7/oePAN/YI/Z3qyIm6Hs8iPchYErXCkUce6boPeeiEhfG0/vrr519777337JBDDqn09zz44IO2yCKLuA5j0UWNBfLyyy/P//+3334r11kIRQ1Fo3PnzrbGGms4ZTbUwQpDKGqwrb766u5vsbh6MPZOOeWUgt+RRev11193i+x2221nW2yxRfDv1YSoccdigCFU1XGbbLJJpb+T88EIpPvVuuuu6356+P1eWatrXnjhhXL/L9TlatNNNy03ZmbNmlVr3yF63dZZZx3XXSnO999/b3/88UfR17em5zkvTJ061d3TvfbayxmXdOD75ptv3Ht0/aJzFV2jqrq+jONSvfeFvhv3I6oo1dc5xMcPxjJd1uIgq1D2qho/GO3ITZw8yK8BAwZYEqjL8VOMXMP5FlWkS3F+zisYDTfffLNbD2+99VbnbGRNja6Bld0XnH3vvvuuzW+ine6QR/F1Mm644iyMfw6WXnrpcv+n6+iiiy5a4XM1kRPzQx6K5CFjScwzeG0GDx6c/z8eMbw4RDDwnF555ZX59zCoCrU2BjyJX331lfOM8XujwjTaGhbDJ8qnn37qPOsvvvii+zye9kcffdTWXnvt/DH9+/e3SZMm5f9/6qmnuiiO/1tRjzttSX/55ZeC3xMBi0DHw/nWW285g6Q24Hp5aHsa8nqOHTu23PkTKasMlOghQ4a4+/HZZ5/lX6f9Kq/HF6y6gGt0yy235P+Pcl/IcI6eD4v+F198UWvfI3p9C1236DGVHReCRfviiy/O/x8j/MQTT7TahuvCvaPFMgqm9yLjaLjvvvusW7duBT8bPZ+PPvrI6pqHHnqo3PzAQN9pp52q/G7Mv1AkmjnB3KjPcwiNDdqhh2C8RpX5QuOHdsXek46hhMGUBIq5R/U5Pwvdh3mVQ6UGGQxkXlx33XXB9+PXoT7nRSGi620o0kf7/Si+BX/0c8V8NtS6v1g5UZfjWaQHGUtinomm/wAGCPvA4PnmQRpdlGgEKg77YnjlHU9U1GsYTUOIe3T79u1rDzzwgBOI7AlBeB2vezSyFf27RBTYZ8iz/PLLu31gol7f+PeOwoK15JJLlvN0RY26/68HrPbeU2PGjMk/LxQZiB5T2XFVgZKNMYmxWJeQIkE0yyuQ7D2Cos/PEPH0ttGjR9fad6nL64uhtP322+cX+oYNG9qgQYPKGeF1DX97zz33tGOPPbbgMdHrS5prXe5X9MQTT9ihhx6a/3+bNm3skUceKZiWVuy9jx5X3fHBnPTzM+qAqc/xgzOJPbqAlF5S8JJCXc1P5HZ0LBZzfXFGsHdcXcih+oY9r0477TR76aWXbNSoUe5a4Nzab7/9yh133nnnBVPsuA7RdOzalJu1QWj/p2L3hKrpZ4uRE3W53oj0IGNJzDNxg+DVV191i5B/IPyjsBAUIp7THI2sRGuD8MKSy+25//777cADD3T5xyyg/Lz++utdikvo72Icxet82rdvX9T3JJVgs802s7og6lErVIcU97pVVa/Up08ft7Cw+BJ16927d7l0LpTZulKYibxRE+W/M4oJUYZC6YUQTYkMnW+pXV8YOXKkq8kjPRSo3SHCE015rE0Y/9xTxjdOBIyyaIQQ7zlRp/q+vlGYkzhN/LxFGcQBQTpRIYr9btHj6ur71+X4IULAnCNlkjSrJFFX46fYeVfMPagNOVTfkJFB9gPfk4gX0RScWWRtRL8ndbmFUuzm17woRHT9Dhl48df88fGMiqo+W6jurJjrUV/yUCQbGUui3qlMMY97efDOF4KiV+qWSOmJfo5dvYkwnXzyyS7iVNvgHS/kGZ9XSKOKGjJVHVPZcXFYfKnnuvrqq6179+751//66y8bMWKE1TYoI9St4TEGcsyJYhUqii+UUhE/31K7vlw76h68x5soIymgFGfXNcwPjCQiE7fddlu59woVK9fl9fVgAGCEe2cFyt+bb75ZLi12Xr5b9Li6+P51PX6895p0yg033NAZv/4R5e2333avcUypUFfjp9h5V8w9qA05VCossMACLmU6CjK7lOZFIdq1a5d/PmHChAqNk6K1odHjo58LHUcda7TRSvz46lyP+pCHIvnIWBLzzIorrlju/xRJ+jSX0ANFsrYWkR49eriCXfKMqVMirSZasIuHHePJK2yeX3/91aUgRYnXxkSPj//dugLve3RxqeqYyo6rjHjBbDx1aF6hMBmDzC+O/D3Gxeabb17lZ+PnE013LLXry3ijQYhfuPF0k+5JI5H6pth7Gj0f8v7jdQPzCt5xor5+3mGgo/QXUmgKfbfK7n30uNocH/U9fkgJQ3ZFH1EwNnmtJnO8rqir+Um0JzoWi7m+RFmi2QO1KYfqE9K+K0sri2c5xKMhfixF17T6nBeFiF5nzi9eb+Zr9nwaoe9MRyQtml4Zrzfi/9HrVeh+FiMn6nK9EelBxpKYZ+Ltbqk7Ci36pOeRKudTleYFFoUrrrjCtQmP5rjTGSzaDppQPQ0R4t8Tz1S0ZomGCTfddFM5jz1KcE3wrYJ5VJZyFCJaY8V3QhmIgzCP1sF8+eWXwetD/jtpd3FYaFAioqy88srl/s/39udQ3W5Rd955p4t0eCWmbdu2rrCa7nPFED0fFsx4NKK2rm/ousWPqew4jKJddtklr6AQAWCMV+WxJm3Vf38etKCvjiFC+/NoAwHvYY82lgjd09D5xNNeIfrdevbsadWBcyHt04PSQ0SJNtDFEP1ufCakuJAmE61fDJ1DZczL2I6OjdDc8um8UUWv0PiZF+blHs0rVd2j2rq+xc7PQvehpnIIB0j0+ka7rtYVOO8wFB5++OEKW1HQIOXxxx8vtzaF0sDj1ys+L5ib0fOqbj1tTTj44IPL/Z+sBm/ksA4NGzYs/95uu+2Wj+rwk/9H0yi9wcTn4x1c43+nOnKiGJkjRHhTDCGqAe2oqU2gcBvIpyYqg6KE0MNYoVDVK5WXXXbZPF9fjJ0zzzzTPVgEafiAZ5Jw/fvvv58/jr/vC4UxHu666668AYLgRvFEQNKiOhqOP/zwwytEzOqD6B5DLAp43kLKN2kZNLSAaJtiDwoC3bZ4cC98O3UWZToHRllvvfWq3X63ECxotEOOev3oSBRKh0SpjBqsHu6Fh+9VaL+Uml5f37mRDogoJvF2tnRkxAPtF1qub7z2iDQqokdRo4U6uFBrXzzhUUN8XsDwwBghgsW8w0AjqsV1j3qViX4yhkNEr290vM0rKHTx+0l6bLS20MOYjjZUCX23eOqRh/kdHV+1eQ5Vwd/y8guH0E8//VTBKCU6guzze7+E5mdljSWiKb78veo2oagKjGrkHsTTong9uj9XqDammHtUUzhf3y01dN2gY8eOribQG0EcFzeAakMO1RQarHjZ4R110Wvvu/GRWhmVC0RdaObAOsZ71OHQcdVvCeDhvEKdE6P3BWOd61RbcD6clyfqpATe802OevXq5R5+bcGQoaYSqGHG+cXayrj29xAZfOmll5b7nfyf8YiM5jicoBjfRNmiBg7dDJGFNZUTdTmeRYqY37viimTATvKV7dg9derUcrtxV/b45ZdfgruWh35vfKdwz9ixY4v6WzfffHO53/fqq6/mFltssUo/s8suu+RmzpxZ8PxXXHHFoq9VVceGWGONNfKfP/fcc4PHPPjgg/ljmjdv7q5/FHZAL+b6rL766rnvv/++wu/ne/tjOJ9iGTZsWFF/t9Dv/ffff3PLLrts/pjLL7+8Vq/vb7/9lmvYsGH+86+88krwuGOOOSZ/zFZbbVXhfcZpsecZ/47xzzIHimWPPfao8u81bdo0d+eddwY//80335Q79t13361wTPR95l+xDBw4sOhrEvq9kydPdt/dH8MYD3HWWWflj2GuVJeajm1ALiyyyCL5zxe6zoxbf8wKK6zgxnWxVDVH5uUehWRqZY+a3KN5ub6Mx+jf/+GHH4LH7bzzzvljDjnkkFqVQ/HPMq6rQ/T8i/27P//8c1Gf6datW27WrFnBv3vAAQfkj+P6xKlqra2M6si7uDybNm1aBf0hLq+GDBkS/Lu83qRJk0qvIb+/pnKiWJkjhNLwRK1AVyfSkujAhZeJaA2eJjxGPKfDD54i2ivjgZ9XiBjhrTrqqKNceJ0id7xp/E08vXjo8FzFvdp4tKlNOvvss93n8NDjpaRpA0XApEGwH1Fos9L6gnOKpmCE4Br7dAFSDeP7PHE/7rjjDldkjyePYzlPojRcH6IiAwcOdF3c4m3YfZ2EJ5rWWNeQJuP3kOJ+HnbYYRWOiRY3V/e7kb7Ifa7q+kbvQfQ71Qbx4mw2NS4WPOOnn366+wzziPvJdeL+8to555zj5lihqFL0fPH6xtN54t+tPu89DSl8pIPziXqyozBHPUcffbTVJ8iFaCv0QuOH1DifisfeLbW5QWgp36N5lR2Mx2iUoJj5Gf1OtX19uYfRTUvrCiItRDj69evnohvR9YzMALbgeOqpp1z0NrpNhSe+BoTmRfS8kPn1sb8eECkjjY6mL4wH1m70AtI1iUCxBkUbDkXhdbJSOI7j+Ryf5/fw+/i9hVq/FyMnipU5QiiyJESJMX78+FyrVq3y3q73338/eFy/fv3yx+y666619vffeuut/O9t165dhShbXXLsscfm//ZBBx0UjAz595dYYoncmDFjqv03XnrppfzvWHzxxQueX8eOHfPHXXXVVbna4pJLLsn/3kMPPTRXn6y11lr5v3377bdXeH/QoEH597fddttqRUTmlS5duuT/9tlnnx08ZsSIEfljFlxwQTdX6puvvvoqt8ACC7jv0KhRo9yff/4ZPO7AAw/Mf9fjjz++1v5+Kd+j2pAdt912W/53tG/fPnjM33//XS6C88gjj+Rqi169euV/73nnnZdLAg899FD+O3NduD5xVl111Soj6mmhWDlRjMwRAmQsCVGCXHjhhXkhvt9++wWPIdXOpxQ2aNAg9+WXX9bK377gggvyv/ONN97I1Rfjxo3LtWjRwv3txo0bB9MD77777vx1QWmsKZ06dSqYqul5/fXX88csv/zyuTlz5uRqAxRcfmfr1q3rVdl/7rnnyqVfhhSqnj175lM7v/vuu3r7bl988YUbb/xtxjRjO8S+++6bP4eLLrooN7847LDD8t/jjDPOCB7D+GUcc0zLli3d+K4NSvke1YbsYFxiaPnr+/zzzwePu+eee/LHdOjQIVdbrLzyyu534liYPXt2Lglsuumm+Wtx7733Vnh/1KhR+fcxBtNOMXKiWJkjBMhYEqIEIQ976aWXdoKcGpuQ4QD9+/evce1CIajR4fcR5alPojn1J510UvAY6hN4H4/gvPDBBx/kF8pVVlklN3fu3OBxu+++e41rF0LMmDEjnyOPN7g+idYNPPbYY8FjMAp5/4orrqjX7xato7nmmmuCxzAHfL0Zc2P69Om5+QURTowVvstCCy2UmzRpUvC4E088sWAtR00p5XtUW7KDWpVoXUqIf/75J7f++uvnj6PWaF6hRorfReRw+PDhuSQQrbHieoQijdTW+XmTdqOgWDlRzHgWwtOAf5SNKIQQQgghhBDlUYMHIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjqUhmzzY74wyzZZYxa97cbLPNzIYOtUwwbZrZ+eeb7byz2WKLmTVoYHb33ZZ63n/f7IQTzNq3N2vZ0myFFcz23dfs228t1Xzxhdk++5i1bWvWooXZEkuYbb212dNPW+a49NKy8b722pZ6Xnut7FxDj3fftdTz0UdmXbuWyTjGPff8+ust1fTsWfie8/j9d0st331ntv/+ZsstV3a/11jD7KKLzGbMsNTz4Ydl6/lCC5ktuKBZ585mn3ximdVbvvqq7LhWrcqOPeQQs7FjLdXn/d57ZscdZ7bRRmaNG5cdJwrTqJL3RGxRefRRs1NOMVtttbLBt8suZsOGmW25Zbov1bhxZYsIxsJ665UpVVngiivM3n67zHBYd12zv/4yu/FGsw03LFMe06pAjxplNnWqWY8eZc4BlIchQ8oUyVtvNTvqKMsEv/1mdtllZYZyljjpJLNNNin/2qqrWqp56SWz3Xc322ADs3PPLVOafvihbAykmaOPNtthh/Kv5XJmxxxjttJKZssua6nk11/NNt3UbOGFyxxiKJXDh5cpmRgSTz5pqXYKoLMsv3zZ+f77r9lNN5lts02ZAr366pYpvYU5jjOQsYC8x9i4+mqzzz4rux5Nmlgqz/u558zuuKNMt8ExmnYn8DyTE1UyYgTLRy531VX/e23mzFxulVVyuc03T/8FnDUrl/vzz7Ln779fdi0GDsylnrffzuVmzy7/2rff5nJNm+ZyBx2UyxRz5+Zy662Xy62+ei4z7LdfLrfddrncNtvkcu3b51LPsGFlc/uRR3KZYvLkXK5Nm1xuzz1zuX/+md/fZv7z5ptl4+DSS3OphXPjHD//vPzrhx5a9vqECbnUsssuudyii+Zy48b977U//sjlWrXK5bp3z2VObzn22FyuefNcbtSo/702dGjZ8bfemkvtef/1Vy43Y0bZ8+OPLztOFEZpeEVARKlhw/Ie9WbNzI44oswbhZcqzTRtarbUUpY5Onas6FUiqkhaHmH7LMH4xxM5aZJlgjfeKJv3AwZYJiGyOHeuZYLBg81Gjy5LuVxgAbPp08u87VmF60FKzoEHWmqZMqXsZ5s25V9feumyMZC0aEJ1ePPNsmji4ouXP28iS888UxZZyZLeQtbEbruVRWI8XJ927cwefthSe96MfUpKRHHIWCqCjz8umzjk90YhjA9py/UVhcH/gmJFHU/aQWkkpE860rXXmj3/vNn221vq+ecfsxNPNOvVy2yddSxzHHZYmazDIdSpk9kHH1iqefnlsvOlPocUJFLw+P+xx5rNmmWZ4u+/yxREHEWk4aWVbbct+4nDk/Ubh+dDD5ndfHNZGmqaU2+pvw4pydRtzZlj9vnnlhmY82PGmG28ccX30O/Q/YQA1SwVwZ9/lnle4vjX/vhDgykr3H9/mYAlJzjt9O5dVqMEeFu7dy+r2Uo7t9xSVreFEp0l8KbvtVdZLSbOgC+/LMvd32ors3feKavnSWuhP1G0PfYoU57/85+yPP8bbiiLpD7wgGWGF180Gz/e7KCDLNVQ/H7xxWU1Kk899b/Xzz7b7JJLLNXgEKDmFqcQGQOAkTRiRNnzNDf1COl2UEi/mzChzLgkWiOyjYylIpg5MzxZ8Lz690X6+fprs+OPN9t887LmB2mHZiZ7713mDMDbzOLKoppmUBTPO6+syH/JJS1TEE3g4aGhB/efAuCzzjJ74QVLJaQd0cSEpga++x2OAcY6zgIcI6TfZiUFj85YdP1MO0TOKOzHQUBK2rPPlhlPpDDR9CGt0AGNqCmOgb59y1JOMRC94ZAlfcafa1X6nYwloTS8IiBkjXchjk/RUN5n+qET3q67lnXM8TVsaYdWuuRuH3ro/3LZ6RhGKmJaOeecss5YpOGJsi54RFzo+omxnEa8/D7ggPKv+5od6lKzAPObLnA77VS+niWNPPhgWQ0y3cCOPLLMOL7zzjInGFuE4DRJKzgF+vUrM4ypvyXVmFRrDCcgDTUr+Lkv/U5UhYylIiAc670uUfxrtFcW6WXyZLMuXcpScvCuZ/V+E2Vg76m0thglHeu228pqFoim/fxz2QOnCLUcPCctI2vQ2IMoCzVsacTP53ixf+vWZT8nTrRM8MQTZRG2tKfgAa2ySStlj6UoRFO5BmmvVaGZCbW3NHsYObJMrvumJtRnZwWffldIv8NxpqiSABlLRbD++mUKou+g4/E5vrwv0gmKMtEU7j/RlbXWssziUxYwHtMIufooDBhLK6/8vwfznPvP8yzUqsX58ceylJS0epzZlDFUq+FrUbOSjkk9JvcYgyHtYCiEIqU4RSALnSAXXbRsvyXfxIYaTYxHMgqyAvuIMb9DTWzYY0m6nfDIWCrSo45gxevsIWw7cKDZZpuVeV5F+uCe77dfWRrOI4+U1SplAboDhZSIe+8tS1tIq8HIJsOPP17xQaoKbWV5Tp5/WgntWP/pp2UF8J07lzX5SCO+Poc0rCikaDVq9L/OaWmGe4+yvOeeZV3R0g7RE6JH8Sg5zTwY59TpZQk6ARJdok41rfO8ENSs4QiNbgHzyitlY4MN6YUANXgoAgwiJg1FziiS5PHfc09ZWk58gU0rdEEjDc17W59++n+721PfQS1PGrvBoSgSWSL9atCg8u8ffLClkqOPLouiUvyM5416LbzONLjo3z+9EQY6wHXrVvF1v9dS6L00gWMAY5gmD6Sg0Q0PBxHK8+WXW2ohHevww83uuqssosB+M3TDw0GCzM9C2i3KMueehRQ8OP30sq0Q6PRIMwdqtFCYeY0tA9J8z9lDjgg5DhDOm854OH7pEHjyyZY5vYX6LeY62yRw/tTuXXVVWcSNbRTSet50fL3vvrLXfGTNd4JccUWzQw6ZH9+8hKlkw1oRYebMXK5Pn1xuqaVyuaZNc7lNNsnlXnghO5doxRXLdngOPX76KZdKttmm8DmneeY88EAut8MOuVybNrlco0Zlu73z/yefzGUSxkH79rnUc911udymm+Zyiy1Wdt+XXjqXO/jgXO6773KpZ86cXO6CC8rkXOPGudyqq+Zy116bywwdOuRyrVvncnPn5jLDiBG5XJcuZWs697xdu1zu0ktzub//zqWa77/P5Tp3zuWWWKJMl1ljjVzuP//J5WbPzmVWb/n887Jr0qJFLrfIIrncQQflcn/9lUv1eQ8bVvgY1jxRngb8M78NNiGEEEIIIYQoNTKWnSqEEEIIIYQQxSFjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIAI0sYeRyOZsxY4Zlkei5t2jRwho0aGBZIKvnDTr37N133XPd86yMddB413jXeM8WLRK4nifOWEJpbtWq1fz+GkIIIYQQQohqMG3aNGvZsqUlCaXhCSGEEEIIIUQaIktRRo8enTjrdF4YM2aMtW3b1j0fOnSoNW/e3LLAhAkTrGvXru55ly5drGHDhpYVZs+e7e41jBw50oWvs8K4ceOsQ4cO7nmPHj2scePGlgWIng8ePNiyLuP69+9vTZs2tSwwZcoU69evX+bGeny8Dxo0yJo1a2ZZYdKkSdarVy/3vG/fvtakSRPLSmRhwIABmdNl4vpMlmTc7NmzrXfv3pZUEm0soURkSZGInivCJSsCJnqeGEqNGiV62FaLuXPn5p9jKGXJWIqeK8pjVhTI6HlmWcahRGRFkYieZ5bGOkTPFUMpS8ZS9FwxlLJiLEXPM0u6DETPNUsyLukoDU8IIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECNDI6pjZs83OO8/svvvMJk40W3dds0suMdtxR0sUs2fPtvPOO8/uu+8+mzhxoq277rp2ySWX2I5JO5Fq8sUXX9gzzzxjH3zwgf3xxx+28MIL2zrrrGPHHXecrbjiipYWmjVrZt26dbPVVlvNPRZccEG7/vrrbdiwYeWOO/HEE2277bar8PnffvvNvZdEpk+fbjfddJN9/PHH9sknn9ikSZPs2muvtf3226/cccsss0zB37HVVlvZQw89ZEli6aWXtl133dVWWGEFW2ihhWzOnDn2559/2ssvv2yfffZZuWOXWmop22uvvWyVVVaxf/75xz7//HMbMmSITZs2zZI4py+44AL78MMP7a+//rIWLVrYWmutZaeffrrtvvvu7ph///3X7r33XnvsscfcuJgwYYKtvPLKtv/++1ufPn3cfCl1Zs2aZS+++KL99NNP7jFjxgzr2bOnbbHFFhWO5b4zfr///ntr2LChk+/77ruvkwNRuC4vvfSSvfbaazZ58mRr06aNdenSxTbbbDMrJZo2bWo77LCDrbTSSu7RsmVLdz/ffffdCscWM7Y5z44dO9oaa6xhSy65pFsPf/31V7c2/PLLL1YqzJw5043Zb775xr799lt3Dqeccoq7FlF4/5VXXnE/f/75Z3fenEuI3XbbLfh6jx49bJ999rFSgXvy9ttvu7Xo999/d9dizz33tA022KDccbzPnObn6NGj3Zi+6KKLKvw+jnn88ccL/j3GzHrrrVcn51JdmNuMb8Yu8m3KlCl2/vnnW9euXcsdx9h4/vnn3T2fOnWqG8sbbbSRHXXUUcH17YknnnA6H7oPcwD5xyNpMu6NN96wESNGODnHuECPW3311Z28X2KJJfLHIeffeustt/6NGTPGFlhgAXdddt11V7dGZJk6N5Z69jR79FGzU04xW201s7vvNttlFzN00C23tMTAAHz00Ued4EWZvvvuu22XXXZxyvSWSTqRanLPPfc4BZrFhvMeP368Pfzww3bQQQe5a7DqqqtaGkApwjhAQCBIMQgLgVKNcRE3OJIKAhLjaNlll3UC8Z133gked8MNN1R47dNPP7U77rjDttlmG0saiy22mFMqUSBRfJs0aWLrr7++HXvssXb//fc7xQMWWWQRO/XUU90i89RTT+UVURaRK6+80ilaSWLUqFFOUUDZ4xxYYFGOUSxuvfVWpzjw2mGHHWYdOnSwY445xlq3bm3Dhw93CghK5quvvmoNGjSwUgZFGQWY+7z88ss7xbjQ+Oc+Nm/e3CmXKCAYRCiTZ599tjVq1Kic8oSyhXMAIwTZyPjnWmy66aZWKmAcoeAgr1Gc27VrFzyu2LGN8oWxhAKN4sW1Yt3DwL7xxhsLXtv6BiX5gQcecEowxn3c6eHB+cc95h5iLHKNKgODI+4ka9u2rZUSzFmMeBRhFHvWsRAYkR999JE7ZtFFF3VjJATOUAyiOKwPGFmldP44+G6//XZ3L9FTcASFYJwytrfeemvnIOO+M6fffPNNe/DBB9248SATL7vsMtt+++2dvsNcv+qqq5x8QB9MkozDsbH44os74xbn2Lhx49w5jxw50sl05ABwjhhfrIPMd+Y/cv/aa68t6GjKCnVqLL33ntmDD5pddZVZnz5lrx16qNnaa5v17cuks0Tw3nvvuYnERMGrCoceeqitvfba1rdv34LKZRpASFx66aXWuHHj/GudO3d2hgXGEtG1NEC0EOUQoYuH9eqrry54LALk9ddft7SAIoyQ5CfGD57yEIUWThRFonJJAw8kjygoG2eeeaZbIL2xtPPOOzsl8vLLL3fjBFBETj75ZGdM+OOSAk4eHlFOOOEE52G95pprnLGE4ch5sWB6jjzySKdceoMp7q0vNVAamcf85H4hx0Jg/OAAOeecc5xCASjaKAiMbxQr4N6jYHfq1MkOPPBA9xpGE+sCjrSNN97YeWJLxWhgHPOTyCnPQxQ7tt9//3179tlnXfTCgxJFtgVGWakYSyiNRAIwAr777jtnCIZg/O+9997u3G+++eYqjSUUbO57qTv8MF75yfng+AiBUc+4ZU1H0S5kLHEteUT5+++/3WeYH/Go6/yE6AhKPj+//PJLO+SQQ4LHnXXWWRVe474efPDB7rzQAQCD6L///a9zCOA0gO7du7soHM4RnmNsJUXGoceFHADob8xjv+YTbUIWRO8tjtCLLrrInnzyyUwbS3Uq2YkoNWxodtRR/3uN7I0jjkDQYu1aImAhJDUDJcJDGsoRRxzhBhpWe1rBExE1lIDFF68SYd+0MHfuXGcoFQtKEd7VNIDCgKFUXVCcnnvuOdt8880rTdFLErlczo2D6L3Fy4aH2iuTgHKIdxUDIw0g3/BM+jmAsRQ1lDxEXuCrr76yUge5hRJRFXihiSR7QwmIsOJ5JwLhwaGAo2TbbbfNv4ajAGWCsfHDDz9YKckzDKWqKHZss8ZFDSUfTSdtEW9+Kd1zDKWq4BjkXnXg/DGqSxUioMUYMK1ataqwphcLY4PrQJpqKYG8iqaTVTcdG4i2e5j3ZBvE0yxJzSUKS6pakmRcCC/viEh6yC6JjyH+xjrrrONkBEZkVqnTyNLHH5sR/Y8b4D5b4ZNPzJZf3koeUg9IY4h7EnzaBYsoikZWQKEkdaWUwvD1CYssaVoYzAhYBCf50lkTJKRisaB4BTqpsNCyIGAgoQSgKPs0DhYi5n2oLgNPXvv27S2poOyy8HMPScEiwhKvU4tDjRPUVDEpNVAAmMNEzOLE07gwGJj7XrmKHgeMEVKAkkJtjG0+n+QU5GIhkopjiLWPtZ55EjWaswJpW8jKpNev4BQiSoQ8I30Pomm0PlIaP88111zTOUq//vrrCtH5JEDaHueN/uZr9Dinqpj8/2nqPLJKnRpLf/6J1V7xdf/aH39YIqAoLr5Agn+N4r8sgVJFbQ+1DFkD5YocZ7zICE1C2YSwUbZI40EQZQWKZVEeCxVAJwXSC0lLAe4fzg/frMJ77Vgs4uC5x0uLRxdPftLo3bt3PlWHsUxqCfUnlUFKCgpyoVTNpOHva8g7y2sYAqQeoSCiYHHu8VqtysZIKTOvY5t0ZQzFF154wdIMyiTpWETQSFkjHZHUJzzySVSYawrnS2oj16O6UblSA/nlo4TMA9IXSTv1UNNDtD2ehugjObyfRDhPP5+Z3zSrqMrwRdf7+OOPXaS5VNKMU2cszZyJF77i676REu8nAbyvIeHgO0LxflYg9Y6cVjzwSVeSa8KgQYPK/Z+oEsYyOc+kLZVKeL6uwRuPt5Wi55qmAZRShIyCZ4pcN9xwQ7cg+KJ+n64SUhhRov0xSTSWaFZD3Qbjl6YtpJhVlmZEsTOdAmlu4guCk44/32gTB4+/995Y4mdlx5VyilaIeRnbKFqHH364Mx6GDh1qaYaatCh0wGXu0PyI2sakGw7FQi0QMqLUUvBqAp1uma/oM0QM4zocqYahuQ5EV5KaRUItInObAADd8aqSWVyHW265xcmBUM1ylqhTM5G0/1ias8OPs6SUfJCeE8/XBj9h0lK7UhV4U5hsLJR4mPG8CLOnn346NYtIseBdZfwTjUg61GeQdsHiQbE3yg8d8aJKY1XKdBKhDTRNGmhWQ0oGKRq0kiXVKA6RNiKn1Gn6a5MGfFpJVQaD/1nZcUlLUanp2OY82TqCeYIiFVob0wzXBkehr9nKCjT/QddJUqppITbZZBPXrAAn5xVXXOFS8aJbXzC2CznAMDCSsHVCIZlP/RFNuo4++minu+AsDEGWBdcFw+qYY45JjYOsJI0lstRIxYvjX0tKTTjpdgyYOP61tBS3VxVJOOmkk5xCRapOtMVm1kF4cl1KqTtQfaTgkZJU6h3RagJRJtIqaXpRWZoW5899T2JUKQRRJrqe0Vo4CpEDDCq6nqEcp4nKUtF4jRbc3nBAWeC1uDFZ2RgpZWoytn2jIwrBSeEMrYtZwNfsJXGftZpACiq1bdSxpc1JSg0aXeAoL4jeXxyg1PZEwXnAvElDzSbrG826cBKGoA6bGjVahq9ZRF1T2qlTY2n99enpT/5z+df9veH9JEDHIBSIeHchP8h4P83gOaQFK/uzDBgwILONHQqBlwlDKWk1C/MSiaGlMvn6aUxB8RECvKjcUxwFLCpxMKjYiyct+FSU6DhGxtHAg7bYpOoVSk1JKnRFY+6G9qQhRSfauIfnfuPi+HH+/SRR3bFNrRZ7c6FYDhw40NWvZBXf6KQU2kfXBzQ6wUmQ1uwJdJyo4ev3JSP1MAr/J+LCHEgDyLNQGckjjzzitg2g+1+pbbidSmNp773Zk8bsttv+9xoR+4EDzbj+SVlb8LjiZbgtciJMLhYMBlLSFsnqwHmzNwEeBsLVaRWWxYCHORR+R6BQ50IRZBZgvwUWjKSn4JFOGof7yJxmEfEKEfeV1IVoS2IWS1pLJ/GeU7AbB48pnkQMRF/wS3twokkozqTppTXdmDo1lMGoF5lzj7fPZhsFvOrsxeVBgWTPNaJOSdyguzpjGzmH0cyegzRByQIhBxiNDugeiaGUxHteE1j/iUCyUW1SKdRO//PPP3fplNFGB6Tpcb5sGxOF/6MD0PAjSTpcqGMlTh7244rfU/arYj85nKFpzBypKXXqJsQgok09+4CxPiNX7rmHtqRmd95piQHliX77GA0oGghIijvxRt6ZpBOpAWzMiDLAxowIGooho6SpGxAdcki78R1wEJh+LwLOm/fYtJOdr/0mhkQVUSBI3WLz4qRy1113ufuLguhTr7wHnULuqAeVFDw6Q4X24UkSbCzKwsdC6Tud0T6Wc2NR9LUYLB4o1NTroSgTTWMRYQywz1rSIFede82cJp0Ko5BW+LTD7d+/vzMiiTjstNNOrvsjHZSoUYt3QmN/rVKHfHyUW6/0ovT5PYVoTsJu9sgwWsXT4YyCfe4795xrE92EEbnAfec9FBCMSAwKIiy9evUquU5R7P+EgetrDTCK/HPGMTWHxY5tNu7k9/3444/OsI62WQaMp1JpcEEdBsqhN36Ry757GTV5yHHWcV+r4euOMAJ9ehJjA3ASvPvuu+58ST1n7CAbx44da6eddlqN9yuqK4gEEynwewZRi+nHPt3ekHfIOm/s+k6+3gHA+IhnyrAm8KBjaLwTZClBzRHnzb0B1mnvGPJbIjDXqdchO4a5wb3H8EXmMYc9XCfqdHAQ9+3b18k65jp6wPHHH19SKbdVyTg444wznJ5CyQhznPlN5IhrEG3UhR7D2sccoPyEsR9lrbXWykw0NU6d51Tce6/Zueea3XcfbZfNCEzQ3v3/N0VPDHhdzz33XLc7OAORCAuC1O/unlZ8/cIbb7zhHnHSZCx169at3OasCEivEGIwsgCzWR0eZpQHlCMUTcYE0ZZQYXxSoBYlmnbDouANY7rgeAHJ4oIwRuEuNeWwuqAgY/ChBLBYojySl//444+X21+H+Y7TgOuwxx57OEUZb+SQIUMSWa+E4oCTh2YWdDMjDY0ICopB165d3TG87jfbPvPMMyv8DtKxkmAs4SHlXKLKAA+vPGIsYQT16dPHpRniCCDVEMOCSEpcGSaaymeQhaSiIi9oelGKqSoYPdGNdtnmgIc3IBjvxY7t5ZZbzv1EyQylYdP8I17fMb9g/kajp9wnHoDcxlhCbsc7m/r/r7322nklE+UQJwLjCEUcRZMULYxL1oFSAwU4urk6aWM+lYzvixHAPY8X9fv/4wCIG0vIeyj1rBLW4WiKLOfkzws9BWOXNZ41nK6eOEV4DacQhlK89pz5jyxgXDDfibay3cIBBxxgSZJxGMBEwjCceR2nBq/hACBzIFp/5XUA5k8oENCnT5/MGksNcgnT8FBYffoMOaYIvqzAAGbCAi2q05oWE4dFmHatgBckbXUTlYFC4/cxwVBBUcsKeIP9As1iVmpe3LoCLyGR66zLOBrJpLEmLgSRPhSxrI31+Hj3aU5ZAcOGjmze4ExaR8Waglyjo27WdJm4PpMlGTd79mw74YQTEruuJds1LIQQQgghhBB1hIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQggZS0IIIYQQQghRHIosCSGEEEIIIUQAGUtCCCGEEEIIEUDGkhBCCCGEEEIEkLEkhBBCCCGEEAFkLAkhhBBCCCFEABlLQgghhBBCCBFAxpIQQgghhBBCBGhkCSOXy+Wfjxkzxlq2bGlZgfP1jB8/3lq0aGFZYMKECfnns2bNskaNEjdsa8zs2bPzz8eOHZup8T5u3Lj88+nTp1uTJk0sC8yYMSP/fPTo0daqVSvLooybPHmyNWvWzLLAlClTMjnW4+N94sSJ1rx5c8sKkyZNyj+fOnWqNW3a1LLAtGnTMqnLxPWZLMm42RFdJqrHJ4UGuYR9axbTNm3azO+vIYQQQgghhKgGOAFbt25tSUJpeEIIIYQQQggRIHH5TNFwbf/+/TMTtvapGv369XPPe/ToYY0bN7aspGkMHjzYPR80aFBmwtY+TaNXr17ued++fTOVnkOqxoABA9zzoUOHZiY9hzSNrl27WtZlHN7HrKSdkjHRtm3bzI31+Hjv0qWLNWzY0LICqUncbxg5cmRm0tFIse7QoUPmdJm4PpMlGTd9+vR8VlgSx3nijKUGDRrkn6NEZEmRiJ4rwiUrAiZ6nhhKWTKWoueKoZQlYyl6riiPWVEgo+eZZRmHEpEVRSJ6nlka6xA9VwylLNWkzp07N/8cBTKJSmRNiJ5nlnQZiJ5rlmRcIT0+KSgNTwghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQI0MjqmGnTzK66ymzECLP33jObONFs4ECznj0t0Tz77LP2xBNP2DLLLGMXXnihpZ3ll1/edt11V1tllVWscePGNm7cOHvrrbfstddeszQwc+ZMe+yxx+ybb76xb7/91qZNm2annHKK7bDDDhWOffrpp939/+uvv2yhhRayrbbayg455BBr1qyZJY3ff//dPv74Y/vpp59s0qRJ1qJFC1tuueVs++23tyWWWCJ/3G+//eaO4+fo0aPt33//tYsuusiSzA8//GC33nqrff311248c//atm1rhx56qG299dbBz/z99992wAEHuOt18sknu2OTeM8Zw6NGjbIpU6ZYkyZNbOmll7addtrJ1ltvvXLHcp/feOMNe/31191951jGx3777edkQinDHL7qqqtsxIgR9t5779nEiRNt4MCB1jOw+Hz11Vd26qmnOpnGOSLrrrnmGltyySUL/v7777/fDj74YGvZsqX7W6XEjBkz7N5777XPP//cvvjiC3efzz//fOvatWuFYxnL/fv3t08++cTJ9i233NJOO+00W3TRRSsc++uvv9rNN9/srid/o3Xr1rbjjjva8ccfb6UAc7hbt2622mqruceCCy5o119/vQ0bNqzccbzXqVMna9euna244orWqFEj23PPPYO/c+GFF3byfeONN3a/HxnIWvHOO+9YKTF9+nS76aabnJzmXiLPr732WjdXo/P5kUceseeee86NDY5ZYYUVbI899rBjjjmmwhp2zz332Ntvv20fffSR/fHHH7bvvvvagAEDrNRo2rSpW6tXWmkl92BOMv7ffffdcsdtscUWtummm1qbNm2sefPmNnnyZPvuu+/cej5hwoSCvx+9p3fv3u756aef7q51kmTc7bffboMGDXJrHfccvXXbbbd1MoHrFQdZf95559kzzzxj48ePt6WWWsrpBHfeeadllTo3lsaNM0OnWmEFM9bhNOjWTCqEDRM0C6y55ppOkLJIPP/88zZ79mynSIcW06SCMvHAAw845WjllVe2zz77LHgcgmjIkCFO6KJ4oDwgUH755Re7+OKLLWm8+eab7ru3b9/eCcSpU6c6oXvLLbfYkUce6RYVwIBkweT/3HcEaNL5888/ncK32267ufE8a9Yse/XVV53SfPbZZ1v37t0rfOahhx5yRnLS5Rfnuvnmm9siiyxic+bMcff2xhtvdEph1FC8++673Xjo0KGDbbfddm7uM14YJ6UOBjAGPcogRmAhxw5yjXNGKb7sssucAnL11Vc7GcC5YzzF4Zi+ffs6pawUQSFCQWJOYxh8+OGHweNQinr16mWtWrVyBg9Oo/vuu8++//57p2xiPHlwJB111FHOQMJI5HoxF/gdpQLGEcbBmDFj7Oeff7Z11lkneNyGG27olGscBnz/ZZddNngcCjVjgnmCnOe6IvtRmDGmkZ+lNK8xjjiXtdZaK2jMcX+RbxtttJFz9CD3PvjgAzfecRRgSDVo0CB//H//+19nGKy//vrumpYqzEMcHKxLOIMwgkPg4EEujBw50sn+xRdf3N3Ptdde291njKc4XA+MRGRmqTlEi5VxGNDoNegsrN84SJAPjOlPP/3UGU8edBquCaD3MZ7++OMPJwuzTJ0bS0svjVJittRSZh98YLbJJpZ4Hn30UeeBxktTah7F2gbhgFDFO8nkyuVylkYWW2wxpyQgSPA0saCEFiOiiXgkvZcJEDREKPDubLbZZpYkOnbsaHvvvbfzrHpQMFgkUQR4D/DGEUFDefLepqSDB51HFBQtFEG8cHFjifvPHOjRo4czJpMK9zeuRGIIYewPHTo0byy9//77Nnz4cDv22GOdcpk0iJZhEGMwoBBuUmDxQUlCIcSgQOnw452ICcYiBkKcSy65xCnmyAJkQqmBEvziiy+6n19++aUzgkPcddddToFmvHO9AMfJcccd56KPfg6w1p177rnOC42sKzWl0YNn/bDDDnNGDdEAjIAQL7zwgj3++OPOUYBTqJCxRLQV+Y6X3TvQ+OwVV1zhvPfMj7lz51opgBFLRImfKMBdunSpcAzy+8knnyw3Fw466CBnRHCtkPlRZwkRNK4NBsOqq65qpezsPPPMM91P5jDPQzz44IMVXuNanXXWWW7tfumllyq8zxqBXoDxiZxMoowj4hiHCCzRUpwi0et19NFHO30A+Y8xKeqpZongC4ZSWsDDzqIaDW2nGSYfHsSnnnrKGUp4WaOep7TAIlJVpIwQ9j///FMhRcv/n3SlpMHCEjWUAAFJhG3s2LH51/A8R73MaaVhw4YuehZygtxwww0uZWeXXXaxtLHAAgs4hwHeVg+GE95IDCWUZaJKSYLIP0pEVRApJrroDSUg6oB3+uGHH65wPM4UPPhEFuJzp1RATkfTaAtBJBUniDeUAKWRcc7995DORNoqhiOGEgYWsrDUwHDBUKoKIggYSsVkVXBsNNOAdZDUNOYLhmUpjXcMparGRUih9oYVYzsKKbdJWO+57xhKNcGn3xFFjENa+u677+4chIz5pMq4ED79Ljpf0HHIHiJyih5ANI3Uc1EPkaU0gcJAqhaeBoRIFlh99dWdkMBgwuOAIskEIiRLhK1UvGr1gRca8fRL/3+UiTSAMoCnvbJ6jTTB+GZMYyBh8OJBJKoQhfx+FkxytpOgPBQDxg8KI+ePd5VzxNMIvEYaE3nteJdRqn36LdGGQh7MpEHKDulF/ryjEF0i3ToOtYxElDCaQ8ZUUuC8URRJ2YqDEYBB4CFqDjhMiLxS48VzrgNeadaHNMI5hpwE/jWiV8ydpONT7DAAswBpe8hxztc7v0gzjYOhhBFGxC0NTjIyQnBykErta46pRfK8/PLL7id6Hq8j93Eg7rjjjq5WMVTflBVkLFUDipwZbBS/ZgU8VXidyV1FiSSE74tj8cRQw5MVfKoGaS3rrrtu/nVSFCENqWlAPjcLRKmlHNQVRAmILgBjnbF9xhlnlDMer7zySrdgcN/J304DKPo+GoriQATpwAMPdP8nqsh5k4rBNSEdk/n+yiuvuFREnpPnn3RIYYFoZMXDaxgTKMbeIUIhOKk6aVCQqXeAUASK13z0hWgEdQyAYUTqLqluZFkg/6n5SZMTIW5MM+fjkXZvYKbFuCBNi7TSrMh8Um99pgROMmQhUZX4eo9jnGuTlvIDzskb+kSOaH4SdQz6yCIRZBxi1OhiWF144YUu2o5uQLQti8hYKhImFIYC6RoIlayAksADpYriTyAvmvQT0jfwtkcXkTRDzjaRNhRrBA2LKEoEwpTrkbQ0pRDcS+4pOewU9WYButvhRePcST0ighxNPaB2g4J3DKY0weJHoTdpGOS7c94+tYpIm5d75PNTowkUEfN/jIY0GEs+tSbUrMfX5XAM72M4UMuI4ygUjUkaXl6F0mt9UwuO4blPzyTiRL0WMGe4RjQGIdMgafWaxYCnnbqlPn36uPouDEiMRX+uoeYfSQOFmcjJf/7zn9RGCONQk8uaTQobEeTQfdxnn32cY5QoalogxQ7ZzjlRpxjv6ufTz7kuyHgcZbDccsu5dXLw4MGuIUwW0T5LRUIRL6HbrHhePF5pRJmKgscZvBKVFVAUqeO47rrr7IgjjnChbLxPXIdQznOSoMMZAhQFiJo8LyjTDvcT5QdHCPcVxRClGG8iiwfKIE1OapobXqoQOUHpR/k76aSTnGJMXZavTfQRhugcZ2xgMNFNqRRrVqqLn7MhR4c3GP0xRCCJxqRlqwhvIIZqEnw9jz/G/8RwiLLzzju7n2mItIWgWx73nbl/+eWXu1Qkuq5hOEXHSFLBAUyzChRhGtdkBaKiGEKkmd1xxx0uxW6bbbbJv48TCbnnMw7SAlkT1KeRHYXzG1nG+ubxso7uf9H1f5999nHGZam1y69PFFkqAtIMiKygQEaL4VhkUBhYQBlkpdpGdl7Ak0Y3oHjxpG8dnLWQLMojEQbSM+i8RFibxhAo09H2m0mDRZ9ugPzECGT/qKxCxOXSSy91ihKeOOZ5586d8+l3vlUyc4DXSNFJQ/MLFATGAOdHq2QIjQMi68g9DIykz3+ffufT8aLwGmlWGArIQSIqdIlDFnp5iDGNcUl9F9eiqgL7UsKn3/l0vCi8RpTBG82+fjGedub/n4RW8jWFjnc4B6nXQIH88ccf840dkpySS1kBe8URIcRgyiqMdbYPIO2MawLsucV2CtRk+zHuDQnWewyHUJvxJEG93QYbbOD2izvhhBPca16H8VuGeBo2bOiyadB5soqMpSLAQGJBpO1kqPUk0QYEzv77729pg3xVOgKhPEX3WfDh+jQvkpWBkeRrmLhG1DZECyWTBMYAApOaK7yLSVL46oJoChr7yKAY41mLg3eZB6kJpGcmHR9NIO0MTzpzPNRZjNcwDku1fXR1YA5jCMQj50BqmU9FRUlgPOAoCaVjEp1kY89SbCNeCOY5ih8e9jjUYUb3qmENoNV2POXa/z9Ne+6FQGkmFdfjN2+mhiOJYAjgFCOVnFbwpdrVsb5AnkWvAQYS6Xk84vTr18+l35O2mHSQ9dGoOg4zwBkcXxvGjRuXmaZPIbI9Q4oEaxuPYhwWRhQrjKS0DiLapJN6QaoOoWsPm5bhXY63Gs0a1HlQ5Iz3ObSvRanjd3RH+FPcH22fnHYwcOOecgxHcrW5n6RhMLfpCBcFxZnIE52SSN1IWkQR4y8eMUIZxINOJMFHW+gQR0MHlGlfo4NzhJSrNdZYIzVpmnvttZfdc889bg5QqwecN/LO77eGYYGxEKr34LrRJTXUJKLUIa2cGkWcAj7NFCORqKpv9gGMc/bhYQsJxr2/9944TGO9UiG4z6yJRJuSGFlizWbfLcY6e+wkPX28WBizyPV4C3Da5CPDow4TDMg4GBLIRPZeK6Y9famAbEduxx0azHNa4kfnOWsdsg7nKUahd4jdfffdTt+Ld4nNEvViLJESydjycuXpp9k1vez5iScSpbCShrQTwpVxfJvF0HtpgfA0eaoYS4RiEbR0w0NwsDlf0kPRUSjkp+DR77uAMPEpKigIpFkiRFGoUaQRQoTtvVKVxIgM95AuQL5FfLz2wHtQWRxo7AFeQfC7hRN1TGIzCAwe7jdd4HB2EFkj7Y6UKu4naVV41HlE8efPGCAHPGn4dEvmMQsoc5jW0CjMRND8AkkePwoEdRoskihVjHcWTdJUkgD5+Ixdf8+Y48g0OPHEE130DKUAhwH3krQkIkhXXXWV27iXrm/AWGATxzgYC8iJ0HvzGzpZoST56A9F/D47gJRy1rXDDz/crWNsC0HdCvV6jA+a2XTt2rVcyh7HshkzKTsoVawFGJAYDqW03xBOK2S1d4SQXuU316QVPOfIfPc1KqQjgd+Am+vl07G8QcwayOukJ1GnxRgpxY2piXTjDPGpwjSs8Smm3D8MBu4zc57NpnEKxA2HaBt9Oj/6yCPrHc8HDBjg/k9qcik1OuF+IqN8CjHz1z9nraJbIzKfqBrygGgJRtLmm2/u1r7oNgGhGjy/XQxR13hjhFKWcWRFYRgz55mnzA2MJJy8yD82m/ZgTCL7yDBh/0iMajJnrrvuOtfQK75Re5aoF2OJTbRHjfrf/x97rOwBBx9c+sZS1iHNCAMCoYLyzHOUi2HDhlmaYOGPphqyQPqCRhQphAwLK0WxXviSqoIAjrYSTxIoyH6PidA+E95YIppCMWwU/39y+ZNoLLHYcy/ZL4zFhvuLYUSzg2ixb9pAeXzrrbecQsiizwKJkkSEJXofiT7RQp25jkKNkYSBSPqOj8CUOkRDiJJ42DOKB7BfEMoC58K1oOiZ1thE1yji79+/f7BLXlLA6InWYjFf/ZzFEMZYIppEK3g22KW5B+lINKzBWRDvEEYXLMYERhjXBgMEBfzII4+0UgLDNeq4Yt3iAdxnjCXeP+igg8p9zv+f/caixhLOEyJwKN4YIuw/RTp+KToKMeC8ogwYAN4IYH6DV6ppnx2Hwv6oscRno3uJcW14RBvElFKtqTeKvRPbO7JxaHC/WM9Zs3mdsc5rOIRwknknadKoSsZhEDJ30ddY6zAMeQ2j+ZxzzqmwdxL118x9GpqwOS3j/uijj3bjBYd5VmmQS1gDeRb3Vq1a5S3qJC9m1QVB3bt3b/ecwZ+GovJiYHEjTQaY7GmolSgWlHgEHiDY0tCqtlh8jQig3GclXYRF26c7ZFnGcf/T2DQnBE4aX1SdpbEeH+90pMxS/QwRXqL7QE1U0humFAsZG97BmCVdJq7PZEnGTY/o7kk873QknQshhBBCCCFELSNjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYSQsSSEEEIIIYQQxaHIkhBCCCGEEEIEaGQJI5fL5Z9PmTLFmjZtalmB8/VMnz7dmjRpYllgxowZ+ecTJ0605s2bW1aYNGlS/vnUqVMzNd6nTZuWfz5+/Hhr0aKFZYEJEybkn0+ePNmaNWtmWZRxo0ePtlatWlkWGDNmTCbHeny8z5o1yxo1SpxaUmNmz56dfz527Fhr2bKlZYFx48ZlUpeJ6zNZknHTp08P6vFJoUEuYd+aRaVNmzbz+2sIIYQQQgghqgFGYuvWrS1JKA1PCCGEEEIIIQIkLt4dTU/AOs1K2NpH1dq2beueDx06NDPpaKRpdO3a1T3v0qWLNWzY0LKUpsG9hpEjR2YqPYdUjQ4dOrjnPXr0sMaNG1tW0jQGDx5sWZdx/fv3z0zaKemH/fr1y9xYj4/3QYMGZSrtlDTrXr16ued9+/bNTDoaKdYDBgzInC4T12eyJONmz55tvXv3ds+TqMckzlhq0KBB/jlKRJYUiei5IlyyImCi54mhlKWc9rlz5+afI2CSKGRqSvRcUR6zokBGzzPLMg4lIiuKRPQ8szTWIXquGEpZMpai54qhlBVjKXqeWdJlIHquWZJxhfT4pKA0PCGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAjQyOqQ9983u+ces2HDzH7+2Wzxxc06dDC75BKzdu0sUXz33Xd27rnn2ltvvWUTJkywFVZYwQ488EDr06ePtWjRwtLCjBkz7N5777XPP//cvvjiC5syZYqdf/751rVr1wrH/vTTT9a/f3/75JNPrHHjxrblllvaaaedZosuuqgliVVXXdU6depka6+9trVu3dqmTp1q3377rQ0ePNj++OOP/HE77rijbbPNNrbssstay5Yt3TjgOj300EM2duxYSyLcu4cfftjeeecd+/XXX92922ijjaxv3762yiqr5I875ZRT3HFxOObNN9+0JLL00kvbrrvu6ubyQgstZHPmzLE///zTXn75Zfvss8/KHbvhhhva9ttvb23atLF///3XHTd06FB3/9PApZdeauecc461b9++wjkxNhgPH330kbtO++67r1122WXWqlUrK2VmzZplL774opNTPJBtPXv2tC222KLCsdxP5vH3339vDRs2tHXXXded54ILLljuuEmTJtlTTz1lX375pZONiyyyiK233npuHJXS9WjatKntsMMOttJKK7kH8gq5/u6775Y7bsUVV7TNN9/cHYNc49yPO+64gr+3Y8eO7vcuvvjiNnHiRHvttdfco1SYOXOmPfbYY/bNN984GT5t2jQnu/jOHubvq6++6sb1jz/+6OQ983rrrbe27t27W5MmTfLHzp4922655Rb3+8aNG+c+u9RSS7m1gHveqFGdqlDVgu/69ttv22+//Wa///67uxZ77rmnbbDBBvlj+P6ffvqpG7+MeY5B5rP2MS9Yx6Ocd955wb/F9eR6JU1vYWw8//zz9vPPP7v7vuSSS7r17qijjrJlllmm3LG8f9ddd9mwYcNszJgx7jptttlmduSRR7q1I2kyzjN37ly76KKL3P3fe++9baeddir3PmPkpZdecvN68uTJbm506dLFnXuWqdOZfsUVZm+/bbbPPmbrrmv2119mN96I4mGGzF57bUsEKJGbbrqpLbzwwnbCCSfYYostZsOHD3eT8cMPP7Qnn3zS0gLKwO233+4WhNVWW82dX4jRo0dbr169nIJw/PHHO6F73333OWUDoRUXuqUMC8oaa6zhFs9Ro0Y5BWiXXXaxq6++2s4880z75Zdf3HErr7yyO+/33nvPpk+f7gwrFs2NN97YTj31VKc8JI3//ve/9v7779tuu+1ma665pjP6Bg4c6AToM888465LVAHjmkSJK5NJgnnMOaFAsiigJK2//vp27LHH2v333+8UD9h2222d4owBxbEoSB06dHBK5W233eYMziSDcoXxg0Idh3PDSGRsXHPNNe5YxgDOI5SOUgZFmTHMfV5++eWdwhsCp8eVV15pzZs3d7IABQRlgXM9++yz8woxr19++eVOKWVM8HtZG1Cm+N0YmwssUBrJGtxLlPnx48c7xbldAe8kSjIGEMdgDKAYFQJnGA5CjOZXXnnFOZmYF8h6HAelAEryAw884JRg5HXc6QHcvwEDBtjqq6/ulEDW9a+//to5xzAkmAsNGjRwx+JAQf4j47k2vP7VV1/ZHXfc4Yyx008/3UoFFGUUXM6H74pBEOfvv/+2xx9/3JZbbjnbZJNN3DjxYxjD8bDDDsufe9QhhlyMUirGQnX1FuYpRhGGHo4fxv0TTzzhHH4PPvigGzfeYECv4Zrss88+zqHGdXr00Ued7sfPkLwsVRkXBUcBMq8QXA9k+1ZbbeWcKKwBd9xxhxsX6MFZpU6NpdNOMxs82CziqLH99jNbZx2zyy83GzTIEgFGAJORqBKeV8ATwYTCMEBJTlo0pRBLLLGE81TwE+/TIYccEjwOjwsG0qBBg/KCk2uDAvn00087D11SwFN87bXXOo+LB0WZBZXz4CegGMcZMWKEi64RmcJrlTQYxxhMUW8q3jgU5BtvvNE9PHid99prL0sLeCB5REHZwEDm/L2xRDQRxePmm2/OH8eCiVKFty3pxhLRcYy/f/75xynMUfr16+dkG9cF5QJYQPGuYlB07tzZShWURgw7fnL/iJ6FQDFAKcbYIWICKNrIBBwo3oOOIo3xceKJJ7rIkwelCYUF4wqlqlSMBsYxP/lOPA/xxhtvuPuIEo3hU8hYwiBCLmB8oDgB8wMFCoODtZH1YH6D0sh6zZjFoMeJFQfj96qrrnIOAM/OO+/szh0nCffZGwc4g5DvUXCk+XuOw7BU1n6+K8YbPzECbr311grHIMP5ztFxiiGIg9AbTNGMAmBOED1Ng95y1llnVXiNtfvggw929xNjERjnrA1nnHGGmxceZN+FF17o1v3tttvOkiLjPMgDzpPxHnLyo8siD7gmOEYAo+mqq65yBiJjpVQcQvVNnZ51x47lDSVYbTWUarOvvrLEwACD+EKCkcDAiSqaSYdzQeAU451gEkU9TCiOpHWUipexWPDGRA0lIESNJwkPXGX49LtS8DLVBLyL8fHbtm1b54lG2YiDQk16QlrJ5XLOMUKUwdOsWbMK50yUAQ81SmaSQVlmEfQOgbjcYy6jSHhDCQ499FAXUQ6lZZYSKPgoEVWBF3qdddbJG0qw1lprOXn/wQcf5F/zxkD0WoD/G6UUTUee+XWrMhjXxYxh5AH3nPES5fXXX3fzg+tXCnAPqjJeOCZqKHlIRwTkflWQVeA9+6UCRmBVkX6OCRn0jHcolE7OGCllWVes3hLC6zBRGU/miDe+o/i/wZhPkozz4NAl+lYopQ7HH2s8kXMPDpFtttnGGVI//PCDZZV6T7jN5UjhKjOYkgID54orrrAjjjjCeRVYVPE44mk+6aSTEqso1xTydwnjegEbheiS98gnHYRQaOFkQcJIRnB6r9PIkSMtTQYDEYZ46g7KIq/xE0/kHnvs4bzxSR//LLQsOhhIRAwY19E0DoxG8v6RA9xnjuU5x+ONTSosikRJ8DSHlF28qyjdeBOj+HTFjz/+2JIOCgBKEh7jOPE0LsY+igPpOqTmoJTjwX/uuefc9Si11KTahBQfIE05CilqZFjgVCI9Ocn4NOq4MQwYCqS5EYFEHpDKhsEUr3NJKt5QCNVfo0CTqs26QJoainM0sppEcIgxbv/66y+XvgfRFDOMaeQ7Oh7jAfmALnDdddc5HSeJ6WjUNKG3Ei2Lp1p6OEdS0+OybOWVV87Pd9Ics0i9G0v332/2++9mF11kiYGQ5cUXX+zSbkjZ8pDPfgndKjKGT9UJeXJ4jfoPFpUkR9xYEDgXFKM4pKH4c8N7i7AldSMt4H0iskZ6lgfFgBRLlGoWGdKy7rnnHpfyMGTIkJIqdK4upBYSJQXODeWAYn8PERS86hjG3jhGuWDhZAFKKhSuo/zS0CIEYwBCRgCvJbWxRxRkFYS8s7yGhxlFGQMZxZj0HiJx1C5FIxI9evSwNIPCiHEdj6TwGteoOt7tUgU5hrFAwX8clExSkTwojCeffLJLa0sDpFGiJMcVYYxk6tpwDCDzSD9j/BNZT6LB4CF1FB0FGLukL5KK7OF8//Of/zj9jhrW6FynvjFp6x2GLrV8ZJKQZhlPt44akcz1uDG18P/Pby8vs0i93vGvvzY7/ngGnFnS1hY8C+Suo1gRWXr22Wed8URIk6YPWYL0o0JpJ96I4JikGkt0haImg6LfUOQAw5lzw5vKmCiVkHxtgNeUOhUUhmiuNq9F6datm0vXQ2kkB5r/JxVSSilaJ1pG1zuihtHFEGWZxh54num2hFJBTRP1XjQ9SGInRGpv6HRFh09f1BzHp51xvnEY86VQozKveIUppPx4+eaNJa9EsRb4tD3mC+OHaDPRprSCvMMwCsH1SaqsjzpEcJLgEAp1NSSSguKMsYhjDCcJBkMaIJWSWiWa/ETTj4F1MAoRdpwsOFh4Xkqpp9Xh+uuvd3Of+0hkOCTLmOs0Adlvv/3cWkdDDxyEF1xwgTOYkgTGPlHwY445ptLjmMuVycI5/y8vs0i9GUt0wtt1VyxUs0cfpdDQEgPRBRQjJouvYaHwHy80Ic0DDjigXL572vHKUyiH2U+mkIKVBFCYSS0j5QKByD2O41sro2CTekK9B8K21LuDFZNeST0Kih/Rsqq8piykXCMiDEk2ljCEeACeU1LT8Cb6BZE0NcZBtMED6XgsmhS933nnnZY0GOPk43OuhfCKk3eOREFRjCtWScQr+fGaxah884oCnT5vuOEGVyTu0/ZQGDEccRjQrjctaVkhuV5IHnB9kqxEUYdFUwialdC8IQSKs6+FoisgxhWOBpr+lEqDh5pAminGPk6iYiJFKNLUu9DEiW01qFFOIkRYgDlLFgkGEVFFfgLNWo4++mjXYhvHGJB6TUQduU+pQWXtuUsJ306f8R2vwQrN5cpkYZOEO0XmhXppa0HkrksXQnxmL7xglrT15KabbnKLYrzYH0UJpToNufvVwaffhUK5vEbINomTCmHJAkgNDkKymFbg5DzjnULgJhnSCQ866CD3kxa6REyrAmUZRYHQfZrACEYZJvUQJwg56vGaNOY9xa54HJMG0RCUPOotUXjoosQDA4hFkefUJPr0O5+OF4XX0mAYVJZewmvIAm8s4YH39QtRqFcizSXNxc/IBYyleNSF17hGSU3PYe0mOkxdHq2iiwVFGSU0vm9VksD4R4km9W733Xev9pxJQ2TZpxoSQYo6OzEGcQD49GyPX+eTlHZPdzsMIAxE9DMeXrdhHeP/3kDCWcxcRp4Vm66cFeo8skSkmnn47bdmpMYHegKUPHidQ94jb22HLPE0gxLJ9aBeJQ7tNgvt6VHKoBCRaoYCiOcIz1J1GwQkFZRkai5IxaBWp9j7R0oKSnXaoqre0McY9G1SQ+1SURST2EaVdAwiZRhLPOJQzEs9Bs1s8CTTES6akokSQcpS9LWkghwjkhrakwYniG9s4A2GUKTZp6cVSlNLA14eEkmIttvn/8yB6sjLUuqCSqtljAVaq1en/shHW33XtKRBIT8ZM6x3RFOqc+5e0Q41g0gq3M9odJR1DYMhPqe9rpcknY+Ua4wi9gWNQwoiD5zEdElE3pEpEneG/fT/tblReZg16nSlZ5wR1Rw+3OyRR8pqlZIIyiMeKNLwolAwx0KR9M4wNYE9BphURFY8pKRRMB7dLT0JcA9pZoB3iSLe0MZuHBPq+sZCi8KAly6JsBiQx0z3N6IN8c5n3pgKtchlHxoWFPZkSCKh2gTuM2kmLJyMbeqRUJDjRd944NiUM4lKIgXbdPOKP4igsWDynM6feBGZy+ylFm2rS8oS4yEtNTqkIJGOFN2okY1HcZJF7zutxDGY4vLBd4ErlT2W6gLOmXvu95zy4HlH0fSpyUkyFnAG4PhDiSyUNh7ysntvPSSxMxgyjf2kkGFsC1DI0RcyBLnX7DGHoZS0yHKhdvqMXdbvaHdf5jL3Pb4NygukRpmV26y91CGNkFq86MPvQ8WG1PzfZwuxnxaGMw2cPFyH119/Pb/mZZU6jSz17s2Gn2WRJdah+Ca0Bx9siYBOKX5HY5o54EknR53XqGdImtCoCqILKEe+cB2jiHoWwAuFJ/bwww93RZ7k9VKzhecCJYrJRHpikujZs6fL10bp4dziKXV+LxHqeMhVZqHFgMBIwmjk3B/BG5BAUBhY+HfccUeXTkdHqCg0NGEckO9MXZLfsJBr8sorrzhDaaeddrIkwqZ73FcWSt8FiHFACiIdn1AMeFAcS50C0RYiKnwGpRElg40QkwYLY6jGzO+1FH0PzzsLKnOCuk2MQzbpZDzQJbTUoR6D+enTSEin9J5x5i5KH3UqOAvY3BHFgnvOfaXRS7QugeMZC9Qt8Zx1AAcacgNFq9RSMrlnREdRcoCmFP45yhAyjBoGX6vi60/8fcV49IYgWRSsefvvv79b88gqQNbjWGBzS65xqUAKFYq+N345B58yTroZnb5oboLxR+0xbbGjMP/9PkxcJ9Z5OqXxuk+758F1K7XNWqm5JD3OOzcwcv3Y5xw493vvvdcdw9iOO4CJtHqjn99FkyOciDhO+J2cN7+P61ZqHeGq0luAuY7sYq4yN5D9dDjGcca49jBO0Gdo4sU1ZN3jWjzxxBPueSk5CKuScczreG2Znw/orpSYeJAHOMiQfzhSSTnmnn/33Xfu+iQxk6K2qNPR7je2f/rpskecpBhLKEYskqRnUb9EWJNUFRSJvn37WtpASETrFJiMPLywwaBg4cB4IN8b5QHFEYWSHdOTVq/k9xBg8QsVuWIYEGnAOMQrT/tQzhGBhEDGUEpiRzTwKTV40EKbCWMsYUQgQCmEprCZSAtClEJ3olJJFaAoyBgCOEFYLFEe2UeCyEp0fx3SVUhd41j2lgIiqHRGSmpEsTpRF8Y9jWyY28x9ok601U0COAKQ19F6NB5eecRYQkEgsszYpoYDJRDDgjTDqNcdmUdjDBQmFEmUE4wPlK9SdBAxZ6MpsihFXjHCgGC88378u/v/e0PQw/xHgcKg5Pog/5B9pbbXGPPXK8nA2s0DvJLr5fXdd99d4fOcnzeWMIKJMrIG4FDB644RjeJYnTqf+gJnXrSGFKPWp8t7w84r1SF5T/2dN5b4iWMQOYlxxVzg3H0n1KTpLXT95LuTVoxMwynCazj74k5v5jURdTr/scbjRMRgZG5Q21ZKaffFyLjqgCHMZ5jvzBuir0cccUTBjWyzQoNcKMZcwuAx8ukzeIaSviFmdWABIBXE74uQhm5UxYCHkMgH0N601DxadQkKjQ/9o5inKU+8KvB++RRXFrNSWqDqEryEGGJZl3E33nhjYrtqVhfSg3qTipGxsR4f70R007QVQ1Vg2JAKBxjiSXM01hTkmu82miVdJq7PZEnGzZ49O7/NThLXtWS6hIUQQgghhBCijpGxJIQQQgghhBABZCwJIYQQQgghRAAZS0IIIYQQQggRQMaSEEIIIYQQQgSQsSSEEEIIIYQQAWQsCSGEEEIIIUQAGUtCCCGEEEIIEUDGkhBCCCGEEEIEkLEkhBBCCCGEEAFkLAkhhBBCCCFEABlLQgghhBBCCBFAxpIQQgghhBBCBJCxJIQQQgghhBABZCwJIYQQQgghRAAZS0IIIYQQQggRQMaSEEIIIYQQQgSQsSSEEEIIIYQQAWQsCSGEEEIIIUQAGUtCCCGEEEIIEUDGkhBCCCGEEEIEkLEkhBBCCCGEEAFkLAkhhBBCCCFEgEaWMHK5XP75mDFjrGXLlpYVOF/P+PHjrUWLFpYFJkyYkH8+a9Ysa9QoccO2xsyePTv/fOzYsZka7+PGjcs/nz59ujVp0sSywIwZM/LPR48eba1atbIsyrjJkydbs2bNLAtMmTIlk2M9Pt4nTpxozZs3t6wwadKk/POpU6da06ZNLQtMmzYtk7pMXJ/JkoybHdFlonp8UmiQS9i3ZjFt06bN/P4aQgghhBBCiGqAE7B169aWJJSGJ4QQQgghhBABEpfPFA3Xjhw5MlPhW9KSOnTo4J4PGjQoM+FbUhV69eqV90hkKRWNSGrbtm3d86FDh2YqRYV0ha5du7rnXbp0sYYNG1pW0hW411mXcX379s1MOhppSQMGDMjcWI+P9/79+2cmFc2nX/br188979GjhzVu3Niykno5ePDgzOkycX0mSzJuzpw5duWVV7rnSVzTEmcsNWjQIP+cC57Ei15ToueKcMmKgImeJ4ZSloyl6LliKGXJWIqeK8pjVmrV5s6dm3+eZRmHEpEVRSJ6nlka6/HxjqGUJWMpeq4YSlkxlqLnmSVdBqLnmiUZV0iPTwpKwxNCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAjSyOuaLL8wuuMDsww/N/vrLrEULs7XWMjv9dLPdd7fEMH36dLvpppvs448/tk8++cQmTZpk1157re23336WZkaNGmWDBw+277//3p1z06ZNbfnll7fu3bvbZpttZmlh2rRpdtVVV9mIESPsvffes4kTJ9rAgQOtZ8+eFY79999/7dZbb3WPb775xlq0aGHrrbeeGw/8TBozZsywe++91z7//HP74osvbMqUKXb++edb165dKxz70ksv2f33328///yzNWzY0FZZZRU79NBDbauttrKkwTjef//9rW3btrbooova7Nmz7ddff7UnnnjCPvjgg/xxq622mnXq1MnatWtnK664ojVq1Mj23HNPSyqM2f79+9vIkSNtzJgx1rx5c3duxx57rHXu3Dl/HPd5yJAhbu4zJtq0aWObb7659e7d2127Uof7+fbbb9tvv/1mv//+u82cOdPdtw022KDCsWPHjrXnn3/efvnlFzeuuR4777yztWzZstxxr7/+uvt9PFgTtt12W9tuu+2s1GjWrJl169bNjV0eCy64oF1//fU2bNiwCscut9xydthhh9maa65pc+fOtQ8//NDJPu65h/nRo0cPW3XVVW2xxRZzMvCPP/5w1yz0O+cXs2bNshdffNF++ukn90C2IcO32GKLcsfx3jvvvGM//vijGxv//POP3X777QV/L9fiySefdHOGtWLhhRe2NdZYI7g+zC9Ym3fYYQdbaaWV3IOxi1x/9913yx2HDGMec8yyyy7rxvtxxx1XcBx16dLFrWuLLLKITZ061cmPZ5991q2RpQDz+rHHHnPf69tvv3X355RTTnHXIsoLL7xgr732mpu7HLP44ovbOuusYwcccICTbVGee+45+/TTT93vQzZsv/32duqpp1pSZRzrGeczbtw4N0eQByuvvLKTX8xtz99//+3uLb9v8uTJlsvl3Psbbrihbbrppm6sZJU6N5ZGjTKbOtWsRw+zZZZBMTMbMsQMPezWW82OOsoSwYQJE5wyjHBZa621nKDNAihTTECEBYskk5Nzv/jii+2EE05wCkUaQIhcdNFFtsIKK7iFAaFaiMMPP9wpkhgJXAOUJoxorlUSwQhGUVhqqaWcYoWyFOLBBx90BuWWW25pJ554os2ZM8eefvpptzDxeikqjZWx5JJLOmUAZY+FH2WjQ4cOdvbZZzvHyNChQ91xLBQsvDgORo8e7WRAkvHKwj777OPuOfObBRLF78orr7SDDz7YHYfxzHzAgEI5xJBk3L/88svuwWdLGRRl5jHfHWUIAz8ESsGdd97pxgL32cs47vVRRx3ljGPPK6+8Yq1atbKll17aGZGlCsoQjjxkEueNUhgChfGSSy5x14p7yzXYY489nELdt29fZzzBQgst5I4dPny4Ux5RmtZff3076aSTbJlllnGfLQUY188884xbqzDoUaBDfPbZZ/bmm286Q3GJJZZw97qytf+KK65wz7fZZhtnNCAzC42n+QXG0a677mrjx493ijMGf4i1117bOnbs6I5h3YsbCp4GDRq4+8s851pxjZCZW2+9tTOsWS+ZK/MbDNkHHnjAfTcMAO5tCAxjzhWlnznM+WBY4xy94YYb3Pj2PProo04ucg25/0mXcX/++aczejDwcY6x3rHOMz8wlJnf3lhCZqAHcDxjAAfSCy+84NYN1oysUufG0i67lD2inHCC2UYbmV1zTXKMpdatW7uIEj+x0PG2ZIFNNtnEPaLstttuTkHGA58WYwnlB4HCwoAXJn7Onocfftjuuece58lKcnQhCsoCiwY/v/zySzvkkEOCxz300EPWvn17GzBggBOiQPSJuYCCkjRj6aOPPnKPuEfx6quvdufljSUWiscff9wZh0ceeWTijSUcHzyiEFnYaaedXLTUG0v/+c9/KnyW+c7jkUcecQZzKYPBcPrpp7ufKIacW4g33njDKQnHHHOMU4QBJZp5jszfeOON88fiXUaJwEHiFehSBGWIe4pST/SXMR1ir732cgZSnz59nOIM3333nV144YUumurnAI6Cc889t9xniSr169fPKegoq0Sb5jcojZwrP1EcL7300uBxeNQZx02aNHGZE5UZS/fdd58tsMACzomCkl2qYDSceeaZ7idODp4XGu9kCDDm991334LGEoYH0SecZHzGw7XCUYjijS40v8Ew5h4xLxm7hSJAoegZETZ0mVdffbWcIXD55Zc744t1bu+997aky7jdA2lcGLy33HKLk3EYwECWDA6iKOhCzZo1c1k3zBn+VhaZLzVLRPLI4pg0yRIDXmcMJcH9a+gUa7x4aYH7W4yn/JprrnGeKQwllAOUpqSDwsD9rArO1XubPCgPeKq4fmmAe4rSGE2/IvKAoZT2OU2EIJp6FQIjAqo6rhQgIlTMwo6DAA+yN5QAAwNPM9G1KNGUlVKGiBCGUlWgLOIc8oYSkGqG4hVPXQuBF5q5H42+zU8aN27sDKWqwJOO3KsKHGiMARwJyDoMDB9tKzX4XsXMS1LpOI+qQEH2x0fxf6OY31Ff97ym89LrdPF1nNej61zSZVwIL+9Iy6vNY9NKvUk4xuLMmSgeZk89hVfKLOXlPqmCSULInbAvHgZCuEmsU5kXWCQI2eOhwqNK6B6DEQ8cnii8dGlmo402cmlIeBrxRDEeiDZxDcj7TiooeyhOGEh40Ui7e+uttyztMJdJNUEZwtNMOmKoTo00FIxIFGicBUAqZlrmNIoShmLIMKRmIa3gkUcJCqUT4qFnvsdhnjBfUKRJ5yKaTCpPWp0JX331Vd64os7v66+/dlEmUvEPOuigopxMSYVoIus+UQnmCBEljAgchUTtuBZJnfPIM9JJiYhCEmuNayrzOXccgL7UgJrdkOHN+s5P5P7bb7/tZAUyI6vUm7HUu3dZjRIssIBZ9+5mN95YX39dzCt33HGHS0cCFgs8khSEZ4kffvjBFTxiLODRob4DL+Z1113nGgWwoKYlLTEE4X681dQn8QAEKKH8dddd15KKT0EDCr1xBlRW7J0WSLUifcXP6V122SWYtoTS7GsT8OBSr0jtRhrwXvOQd5ZIAsYkCkOpRE5qE++NDxXq8xrXhPOORlJIwY6m6ZKGhdMorfg6VOYJKWmkKOE8oFYTxwGNcNISVY+DgXTXXXfZgQce6FLVPDQBQh8ohbTLmkCjEh8VY80++uijg01f0ggpqn4+k3KHzKdpS8hJQKq1Z5lllnFGsho81APMNVI///iDug+UErOUOqNSCUW/eJMpHsXrjqAslTB8feHTDrkGdBjy3QDxxhNdolA6zcYS3mQKv/EuElX0ReHUO1Agn4QOaSFQfCjox2tG6hGGQxqV4zi9evVy9SZ4jLkGGIqhOT1o0CBnLBFtoDse9z0t+PMN3W//GsekcTz4NLTQPfevcUzUWKLQn0gUSia1XDhL0mosRNOOOF9q9JAN3tDEoUKmQZozLHAmUNhPF0hSEom27rjjjs5gxmBKqpOISCgNa4iuZCm1jHpU5jNRNdJtC0WE0WcwKrk2NMb466+/Uhs9LrmapTXWMKOT46GHmj3zDIpnWevwXK6+voGYF1CE6X5EYTjeNCYR3XCItGQFanO8IIm2TccDTaoCC2ep5rPXBmeccYYTmiw2dA3DSLztttvcOf/3v/+1pEKaAQsHCyeRFYxCirnTDh2PSKeksJkWw3iSWSDjcxoDknQrPLDcb7qC4nFOA9Q7QGje+tf8MWnDKz+h8/OvxRUkr2ThMKPRC4b2BRdcUFT9TxLx54Vh6A0l/3+87GQbpBVq9ogo4UiiARD3nQY4ZFaQqkwqYhIhC4L7R6SEJhik4uEsygKk3FGfiUynWyZrHpkUcdBpqNukoRO6Tbt27VzDm3j9WpaYb5vSEmV6/32zFKeEpxomG55mFM2s4OsaQt2DiLbgjU1Dw4cQeBdZNH3XHA9piBjRpdAVqbbgPDEkQnUsaYYUKzojVaYAkorEAkp3wDTg0+9CSgCRZBwkaYwqRdPvQsXxvMY1qcr5w1yha1hSFeeq8M0ifGtlD4YTNY5plfdAqj1Gc7zJCUYToEynoQsuBkRlW4WkFTIpOP9i1u727ds7x0lS69Rqg/m2CtDsAWj4IJKHr2FI82IRB+WZjnkhA5ENGolIpLWtpt9rIpSnjkJFClda8GlF8Q1J045PR6nKe8hxaUnJQAnmPjN/Qw6CUt9Lal7nNIXeoZoFnAVs3FrsXKH+IY2QdgzxzoLIPIzptMp78OcW7wrn61aikbYkgyzLWkmBh/MuZu2e+/9OkyylLMap89Ee2qeTcXnvvaQ1maXUIZUaQu1nmTjsS8BCyX4OWYLQNbnOfv8RoO0uu7uTqpSWBSSUhsm50TUtmqZFGg4b8q6++uqWNEIthlEE2IMFZwD3OY1E20RHF00KejH4Sbko1Hqae413MU3do4iK0PUOw8FDdI3aRDq+pRk2mSUlKbohJxvYspdYdOP1eGTFQ1o2DhTqGtIIcg2jgVSlqELNteG80xpR880tkPnxroh+D0KcCUkBgyC01QmdHOnsF3IYpAXOnUY1cbh/3ONoBgXO71BpxYf/v1F90vcYLOnI0tFH06rRjOwdrvNff5mx2TfRvP79yY20xECePm0n/QZ2KMwUPcLhhx9ecEFJMjfeeKMr6EZpYEEldYOQNRPtiCOOyNfxpOVcURC9l5k8Zr8gUNyLcn3WWWe5jWnZzPG0005zr9ENjoX0sssus6RCC3AiCtQk+EJu3wkKA5G0HGqU2IiYzTsxDBGs7HSOYUFHuaTBeeARp7sTXnaK1enyRhHzwIED81400ox89zefeuI3KuR6UfycJPr27esUB+ruiJxwDmyyTOE+9YhEWjAcUKK55yiMXCc6JDFOkHPR7lilDEqub4/ulSNvFHXo0MEZh6SWMga457yGp5lWuaTbxrtkkaaIjPCKM+2VfQoP6ajRvZrmN2wWzb307X5Rcr1RRO0Jcp3527FjR9fhkI2luR7dunVzCiTbBHgY72xCirGMsU1NA2laRKD4HLWMpQKOPM7N32fSxnzKIXKLsYwhjKEInCtwHsA14tyANDTOnbFB91PGB7KCa8O5U7tTSiCnWJP9OMTw9c99MwPGA3sFRiNnvjER50btLdDEiNpUtoXAWca6iHOU8cJz5kKpwFrNeuQzIDgH7xSi5gYDoGfPnq4ZB+fAOOe+v/zyy26O0M02Ljd8ZBXHEcdSqwXITeqWkyLjOHfa3qPDsZZRh+ednDi8cQ56SMlj3zXmOuOEtZ114YcffnDrQKjNeFaoc2OJvZTuvNPs5pvpIkZol1a0Zmx+HtjSo6RBKY56U1hweADKcxqNJYQLRiHnyWREEOOFQTmONjlIS1tNlB8PCiQP30UGwwgFiuJmOsBR6I7SxMJKx7Ake9tpjesNf69w8ADai+JdxVAk6kAUDcMS8KzS8KHUlIZiQCHGM+53JWfBYVGg2cH7FFRG6tHYUyWK/z/5/EkzljCAKGrmPFEiUXxRqmhq4VuoM89pGYwH/dlnn3VKFmMfRRpDKSmdD7nH0QgZG9DyAOYrShPzGmfX888/72Qd0UXGOeMiXq/00Ucf5ZVrQKHyShWKZykZS9yr6EbqyClvBDBmMSgwGs455xwnz+lwhmKIFxnjIFqvxGsY1swX1jnkHrLy+uuvd/tzlRJEvzmv6D3j4ZVHjCWfDRDF/597768TYBwwDhgfGJd8HgO7e/fuJZdJgHETjRJi7HuDHwOCecz78f3U/P+JsHpjCeOD/QMxNpAPdMPlNYxMrlUppV5TQ+mde4Dc8pHRTp06OcW/c+fOznBGJuAQ4TWMS5yB8TpkPht1FrAu+FpO9tYqJWOpKhnH2sb6jJzCKcS85jXuKecfrVlEhpFR8dlnn7l7zfhmvOy8886p0/eqS4NcwtqZcQNZ3AGLN6250iEQ8H4/G4S232E77SAIMFYAj3iWaklYALwgx0hLUySvKvAS0qbWNx9Ia6F9HBQav6dZlmUcSnxau6zFQa4RucjaWI+Pd5wwaW5FHodMld5sQvn/rfzT2nkxDoY63dWypsvE9Zksybg5c+a47VWSqseVlltECCGEEEIIIUoEGUtCCCGEEEIIEUDGkhBCCCGEEEIEkLEkhBBCCCGEEAFkLAkhhBBCCCFEABlLQgghhBBCCBFAxpIQQgghhBBCBJCxJIQQQgghhBABZCwJIYQQQgghRAAZS0IIIYQQQggRQMaSEEIIIYQQQgSQsSSEEEIIIYQQAWQsCSGEEEIIIUQAGUtCCCGEEEIIEUDGkhBCCCGEEEIEkLEkhBBCCCGEEAFkLAkhhBBCCCFEABlLQgghhBBCCBFAxpIQQgghhBBCBJCxJIQQQgghhBABZCwJIYQQQgghRAAZS0IIIYQQQggRQMaSEEIIIYQQQgSQsSSEEEIIIYQQARpZwsjlcvnn48aNsxYtWlhW4Hw9EydOtObNm1sWmDRpUv756NGjrVWrVpYVxowZk38+fvz4TI33CRMm5J/PmjXLGjVKnLiqEbNnz84/Hzt2rLVs2dKyKOOmTp1qTZs2tSwwbdq0TI71+HifPHmyNWvWzLLClClT8s+nT59uTZo0sSwwY8aMTOoycX0mSzJuzpw5QT0+KTTIJexbozy2adNmfn8NIYQQQgghRDXA6d26dWtLEkrDE0IIIYQQQogAiYv1R9OQ+vbtm5mwtU/VGDBggHvepUsXa9iwoWUlTWPo0KHuef/+/TMTtvZpGv369XPPe/ToYY0bN7asQKrG4MGD3fNBgwZlJj2HNI1evXpZ1mXcyJEjM5N2Svphhw4dMjfW4+Mdj3OW0k7JlGnbtq17zhqXlXQ0Uqy7du2aOV0mrs9kScbNmDHD1l13Xfc8ieecOGOpQYMG+ecoEVlSJKLninDJSl773Llz888xlLJkLEXPFUMpS8ZS9FxRHrOiQEbPM8syjgU1iYtqTYieZ5bGOkTPFUMpS8ZS9FwxlLJiLEXPM0u6TFyfyZKMK6THJwWl4QkhhBBCCCFEABlLQgghhBBCCBFAxpIQQgghhBBCyFgSQgghhBBCiOJQZEkIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQI0MjqmUsvNTvnHLP27c0+/9wSw08//WQDBw4MvnfkkUfa8ssvb2nkxBNPtO22267g+0cccYRNmDDBkgz3dvjw4fb111/b+PHjrVWrVrbyyitbt27dbKmllip37J9//mkPPfSQff/999awYUNbd911bd9997UFF1zQksiKK65om222mbVr184WX3xxmz59urseTz/9tI0ZM8Yd06BBA3fM+uuv78Z5ixYt3HX64IMP7OWXX7a5c+daEhk1apQNHjzY3ctJkyZZ06ZN3fl1797dna/n2muvtVdeeaXC55dbbjm75ZZbLGlwX4cNG2Z//PGHTZs2zRo3bmxLLrmkbbHFFrbGGmvkjzvvvPMK/o62bdtaz549rZRhLN9000328ccf2yeffOLuMfdyv/32q3Dsd999Z+eff76999571qRJE9t+++3tggsucHPC8+uvv5YbF1H4O8iLUmHmzJn22GOP2TfffGPffvutu8+nnHKK7bDDDhWO5bxuv/12+/LLL61Ro0a2ySabWK9evWzhhRfOH3P//ffbAw88UPDvXXnllbbWWmvZ/IbzvOqqq2zEiBHuXk6cONGt29Gx+u+//9q9997rrg9jg/ULeb///vtbnz59rFmzZhV+75133mlXX321k43IiJNOOsmtjaXEjBkz3Hl9/vnn9sUXX9iUKVPcmO7atWu5c3/mmWfc/GdsTJ482ZZddlnr3LmzHXLIIU4Gev766y976qmn7K233rJffvnFFlhgAVt11VXdml9oHswvuGfMv9VWW809WI+vv/56d55RdtxxR9tmm23cObds2dLde64Xa/rYsWPLHfv4448H/9Z9993nxk6SZBzzd8iQIW6tY1y0adPGNt98c+vdu3c53ZXrcOqppxb8ezfeeKNbH7NIvRpLv/1mdtllZi1bWmLp0KGDm2hRFltsMUsrL730ko0cObLC68ccc4xTupJuKMELL7xgP/zwg2200UZOAWYBQchecskldtZZZ+XvN+eKUtC8eXPbc889bdasWe76/Pbbb3b22Wc7RSNpsHisssoq9tFHH9nvv/9uCy20kFtMzjzzTKd0YByiPB566KH2448/2ptvvmlTp051ysVuu+3mlOsBAwZYEmH8olSiGDOHZ8+ebe+8845dfPHFdsIJJ9jOO++cPxaDAgUpCkZjEmFB5VwxflEq/v77b6coYziiWG288cbuuL322qvCZxkj7777rlOaSh3mK4oD8xdFnnsbAqOR+czYZ9yjdGIEf/XVV/bcc8+58R8FpYwxE8Vfs1IBhQjjBiOYufrZZ58Fjxs3bpydccYZTnFkjiPTUAR//vlnu+aaa9y4h44dO9oyyyxT4fMo58whFNRSgPO56KKLbIUVVrD11lvPXnvttQrHcH8PO+wwt5azjrVu3do5yzAscIq8+uqrzkHkufXWW91xzIfTTjvNyUBkAb+Ha1dK8xqjFwcf9+PDDz+scAz398ILL7R11lnHnc+iiy7qxgbniHHJT3/ur7/+ut1999227bbbOlmPU+zZZ5+14447roIRNr9BjmEgINMZu5xfCObC6NGj3bliaHDvWQOZvxgJGNdRMEDiY4h1MGkyDoOQOYFRjBMEBwkGFM5OHt4pzJy44YYbKnz+tttuc2vElltuaVmlXrW7Pn24GWb//INQs8R64tsTFssIeJ94RFlzzTWdJ+eNN96wNICwJDoYNXbwruJZfv75552XFXg+Z84cO+ecc/IeZ4QvwgohtfXWW1vSQDHA8/oPk/L/YZHlHHfaaSe3WLJI4lWNLhJvv/22iy7tvvvutvrqq1cYI0mAe8wjCkoBHvgnnniinLFEFLFTp06WBogi8oiCpxgDgXHsFX+UzTh41lGmCikjpQSKEMoOPz/99FPr0qVL8DiUAxRfnCY4SwBDkkjDww8/bAcffHC5472iWcpg/OMBRxkmalbIW8z5YTjj8OA6AWOD+Y/h4OcAco5HFDzxGCcoYN6omt8svfTSzsGD8kfkOz6/AeMX+YUB6EH+r7TSSnmDyUfgMARxhO2666726KOP5o8lQoNT5aijjnLXuBRYYokl7MUXX3Q/UWyJFMXhPt11113l5jaRAq6bN5h81Ag5gHEUPb+9997bDjjgACcrSslYwsjBAMZgxPnHehUCpT8OUcj+/fs7+R6PGOFIwWhMuoz7z3/+U+E15jaPRx55JB8lRb/lEYU5cNZZZ7nMAy8jski91SyhVyNrEuqELgeLS1S5zBpbbbWVWyzSYizhJY9HhQhT40ll4Y0aEShK0dQcvDkcy8KcRDCA4mMZJcgrHMD7IW8awhlYaNMCRhHKBuk8cbgOKNVphBQbIit4nguB0YwSxmIaTdEqVUgpKmZxRyHEYeINJcDxQaohaUghGAc4TkoVlOJilHiMYwyK6HXCUMRTTQSlMlAic7mcizyU0j2Pp06HjKWooeQhughEFD1kGOAUIpoS5fjjj3eRCcZOqcB5IbuqGhchJ4h3BOEM8WB0xMcQfwOlmegM518qIJswlGqCT78juhqCcy4VZ0BNZVwIL++IQlfG0KFD3XqY1fS7eo0soYthuOKgT4BDslLIY2WRRLkgrIn3PZ6Wl2ZQJhGWRBLiOb5pAiUAIeJTT/BckX6G9zFOZWkuSYW0hqihGALlGkKGRZLAQMABggKMlxGjGIdAFN6nNo2f1LSRqkgdBCmZSQU5Rgoe50S9Hvnsa6+9dsHjqX3hWoWUraTCGCc6Qu1hnA022MBFXuOQnkZUgQgbnyMVq5QMhmLhvFEwQymVRJeqcgCRnkSaX2VjJklQowNRg4NakFCaJSnb6AC8H488JhEMQlhkkUWKOpbMklBtV5LWN+4f9xq5DqFyA4xIoi8cS+oaUZiqnAilDGl7OLpJp0aOQVWpdUTbmjVrZrvssotlmXoxlqiBHjXK7OWXLdFGAlEEFhFqFciNxStH4Sdh+TR51ysDBQIlmfqGNIPSjCKxxx57uP9TxwQhjzqv4WVD8SxVD1R12HTTTZ1HkULgysAbT4ieYuIkc8cdd7gULGBRpPD12GOPzb/PtSDtCk8rCw31XXiU8cKS3oBsSCKcs1eIUfyRb6QbFQJlgghsKRTy1xa+iQnR4Th4bHGSYEziweUaYSST6kL0gqJ3UpdQlklXDTVPKGV8fUao5pYxj3OokEyjOQq1IcyLaH1PkqEelbUtmsqEMc38jnvviTaQYUCaVhqg9ozICo7QysBgINrGWE+q3PMy39ci4hSl1stnSniIMKLjEUVjjjAuqFlD/yPdMYlg5CPP/BzH6YNMq0xG4BTZaaednJMwy9S5sYTDgqZK555rtuSSlliIIvHwUNhO7RKdSAhTUhybBfC4s4AWKiRMAyyQGIMoxz5dw6fchJo4eGUiDcYSSiOFsqTdUchfCIQntWsUkWMwJRkMYrxreEzp/IRBxL30xLu++W5KKBgcX9liU8pgFCLDUIopAOa8C6UXE1EiskTheJKjaXF82mG8iQP4zmAcw3PSVuId4TAWiCpRNJ80Y8krTSGZ5a8Hx4Te90XvSYyohbjssstcoTvreTS6gmwLjQ3A25502QfUMOEcpLlJZV1dOVeiqMyFUusEWF0wErivzGlSbkNRsn79+pX7P7Vs1ELhHMFgLOU03EIMGjTIzWnqGOmOV1VaOU5BzrN7xlPw6qVmiTbhOK4SPreC4FnCaMLDjKKRdhAoRB0oKETBSiNEkCj4RiGkAxKRBvALZqhNtlesk24o4VUlN59FEU8bqYiFvFM0dqBIOskpCR5ap1KnQYczCrxRjumoVej8vYHF2Ih7I5MEKVQ4BDh3FAAWRTokhc6bWiXGfihdLcl4JSmk+HhjorJ0I7yzOBfoppm0KIM3BqOOAY+/HtFW0h7GB/VK1K7Fmz4kEdol09CCltjRiDKwDhRSipETSXcc0M0VAxF5ts8++xQ8DicKxgNOtCuuuMLJjiSDc4gMAWoSMYBIxSvUHMGD/KM7JhEW5GYSIXLIVjBHH320a3ZBcyqM5cpS8JBx21WyfUxWqFNj6bvv6D5iRsdd1pGffy574MxDPvM86Z2nUTARJEn0MlQXuuSkqQteHLws1113nft58sknl/Mw+vQ7n44XhddIYUiyscR9pWiZxZ+9FELnCTgHiKKSelfZvitJhgUFzxt53YVAicQLmyanAVEmztnXL8RT8BgjdD5MEz69ilSbUIoeikLIYIji6xprWmA+v/DF+6HtH0i/YXyHZBqGM9cmDVElnxVC+mlozzTS61nffbqmh/WeeRJqp54UyBxgLzWi6vEoShy20cAxRodYHKZpglo1HN7FZAhQ5wdpSEmj/hqZX2g/KbZEIeJIh9jGCdZtEmEsoWsQcMFYwgHlHyNGUCxc9vyiiyzRsKiQmlUoVJ8mCFcTdaC9aNrAu4qRgNJEikF8EUSxQHkgTz+O36gwqTB+8aiiON588835QueQcKVVLrUa5HynNZrqIwqVdXvCoCbXPQld4YrFRxjiHfEwCBnj1ColcS+xykAZJkMgVNxN8X4x20RQvwPRLplJgOJ2xi+NPeKQclkoakQKnq/fSjIognTAo3kDLdRDY5uoK8SbXfB/5J9/P2nQkIgNeJnTl19+eaXzmrbyRGCo14lup5Am0N+K2TfP1zZW1UEuKSDrC50L22cQRVYKXj0YSzTJwWiNP1h/KP/h+RFHWCIIKU4olXSFo5uQT9dKK0TQSMHBG5W2KBqLHoXapBiQelcoxL7hhhu6RSbqiaUIFAOL1LQkgtJD+gltkjGAoq1jo1DQTooe507aRih1J2mEIgGkWtABjWgCNYqM9VBe94MPPugWEsZE0ijUFp30WjyI8RQbxjznmrYUPA9RBSIM0UgiXnTkAV5VTyjiRn0jaVx+C4GkQU3m+++/X66zKeOAaxHqksX8IP2W803ynivIbe47DiAa2RRKpyP9iOJ+nEhR+D/KdWUNUUoVZDyZEzgEMYQqSzOlLpP9ug4//HA78MADLcmgo4Xag1OHSUpp1GngO71G4TqRfk7WBWm3SaFQW3WcQXRBLdTdFGOJ2ty0RRJrSp26CenA2a1bxdf9Xkuh90oV73lCgWLCsbjgXUK5oCtY2iE1ifNPYwoe95baE4QGRnG8sQG7WgOtM2krTY4z9S1EIOiKg0CpqotQqUKBOueNZ51xHReMRBExHE444QSnHKBUxjckZS4UMrJKGSKJGEK0PiYq4Dv/kH6AAYkChSF80kknOS+635eCXHfmPgayHxtJ4umnn3YeRRRFlAIiR9x/Ukxo3BFPO+M9oqqhtvmlDvn4eE59mh3j17fERwHk/Ikkc02o2eC+MyZQhmlgQj1StCicKBJGBM4DOoOhSHI8NW6lBueEPPPOHeayTyNC6WO+U6uB8UMaFpuMkjlAnQL3OrSuMfa5nqWcgse8Rjn0NWRcB+Y0cK9RmhnnzPfTTz+9wl5JOMtofgLIAO47KcqMDz6HIU2h/KWXXhrsJDg/wXBnPnvjl+/qUwgZy5w758IxpB/SoCYKMs47RXAakZaOzkOUkXqdeFp+KUVTqTliTPt7wv5h/vv5704tLuOduYsMxEjCIGYO0xY8+rs4PxwJzBkyS1jzicZyTUK1y6Uq43B0ET1lfpNGzTqOs4CxgvxjE/Y4GFGk27Lup6Xb5bySrpyKOoSFE4WaLnAoyUxKvGssGqUkMOoKlEUWoFC6StJBcAL3N1Sw7xVihDCpCxhXKBQYjxgOKBxJzen1BgALZChygIIVXYD8xo1Rhg8fnkhjic6OLCwspCgPKEZEidkJ3u9i7w1IvHB0QyIKSeoWigbpCUmMKGMcYvSjCKAkYBxxTp07d3Y1aVFQFFA6iUAk8VypQ/GKMnCvveKEowBlAWcH85l6DLqikZLjm31EDUdkIMYRbcLxLvNZZANe+lKMulGLEK21Ye3yXUzZP4axTRSR9vdElTkvZBpKJkZjoS54HFPV3izzE5xZPjUSuLc8wO+J5GU+HeDi9OjRI28sARF1rkX//v1dOhop1xTGc99LDcZndH88DB6/V5jfJ8cr1TQyikMk1Y9l6jaBtOtzaWccg2yMUtJ9unXrVi7ayT3095GGJBjHdDxE/vE685zXMCgxlKLRVYwFZCEdLnEU+Q5yGOKltqdiVTKOiDdRQeY+jgGMRF7jemEohUoI/HwJrfdZpUGuspZPJQieMl9cRwebLNQKRdNn2AvCC7W01Q8Ugsnt98FBWFVVcJ0m8Bj17t3bPe/Vq1dijbKagCJ/zz33uOePPvpoojdBrA44JbxSl2UZR1pMMXUEaSC6MW6Wxnp8vHP/Q6lSaQVj1qdvEuVJene9YiHa6SOXWdJl4vpMlmTcjBkz8htgJ3GeJ89VKIQQQgghhBD1gIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECNLKEkcvl8s+nTZtmTZo0sazA+XpmzZpljRol7vbViNmzZ+efT5482Zo1a2ZZYcqUKfnn06dPz9R4nzFjRv75xIkTrXnz5pYFJk2alH8+depUa9q0qWVRxo0dO9ZatmxpWWDcuHGZHOvx8T569Ghr1aqVZYUxY8bkn48fP95atGhhWWDChAmZ1GXi+kyWZNyMyHoe1eOTQoNcwr41wqVNmzbz+2sIIYQQQgghqgFOkdatW1uSUBqeEEIIIYQQQgRIXOwzGqYeOXJkZsLWPlWjQ4cO7vmgQYMyk45GmkavXr3yHomshK19JLVt27bu+dChQzOVnkOqRteuXd3zLl26WMOGDS0raRrc66zLuL59+2Ym7ZT0wwEDBmRurMfHe//+/TOVdkqadb9+/dzzHj16WOPGjS0rKVmDBw/OnC4T12eyJOPmzJljV155pXuexDUtccZSgwYN8s+54Em86DUleq4Il6wImOh5YihlyViKniuGUpaMpei5ojxmJa997ty5+edZlnEoEVlRJKLnmaWxHh/vGEpZMpai54qhlBVjKXqeWdJlIHquWZJxhfT4pKA0PCGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhJCxJIQQQgghhBDFociSEEIIIYQQQgSQsSSEEEIIIYQQAWQsCSGEEEIIIUQAGUtCCCGEEEIIEUDGkhBCCCGEEEIEkLEkhBBCCCGEEAFkLAkhhBBCCCFEABlLQgghhBBCCBFAxpIQQgghhBBCBJCxJIQQQgghhBABGlkd89prZp06hd8bPtysQwdLBCNHjrTLL7/cPvjgA8vlcrbRRhvZOeecY2uvvbalhZkzZ9pjjz1m33zzjX377bc2bdo0O+WUU2yHHXYodxzvv/LKK+7nzz//bP/8848988wzllTef/99u+eee2zYsGHufBZffHHr0KGDXXLJJdauXbvgZ/7++29bb7317KuvvrKrrrrK+vTpY0nkiy++cPeOcf3HH3/YwgsvbOuss44dd9xxtuKKK5Y79t9//7UhQ4a4MTJq1Chr1qyZrbbaata7d++C16mUWX755W3//fe3tm3b2qKLLmqzZ8+2X3/91Z544gl3PaJ06dLFdtllF2vTpo1NmTLF3n77bRs8eLD7TBq47rrr7IorrrDVV1/dzQPPa6+9Zk899ZR9/PHH9t1339kyyyxj7733niUB7g336bfffrPff//dybc999zTNthggwrHjh071p5//nn75ZdfrGHDhm4877zzztayZctyx40fP96GDh1qP/74o5N7Sy+9tG233XZuDJUSzM1u3bq5+cljwQUXtOuvv77cvQXe69Spkztf5nujRo3cNQqx00472brrrus+s+SSS9qrr75qN9xwg5USs2bNshdffNF++ukn95gxY4b17NnTtthii3JybPjw4W5Mc7+nT59uSyyxhG2yySbuHBs3blzw9zMHrrzySvf8mmuucde1VGjatKlbq1daaSX3YOzee++99u677+aPadCggW222Wa2/vrrO/nXokULN6aRdy+//LLNnTu3wu/lHHfbbTe3LvA7kX+s/YMGDbKk6S4vvPCCk2nIBI5hree8DjjgACfbo0ycONHpBegH/H6u1z777GNbbrmlJVHGeZBbN910k5N5nTt3rnA+r7/+uvt9PJgb2267rZNxWafOjSXPSSeZbbJJ+ddWXdUSYyix8KAonHbaaU7YMon22msve/bZZ23VpJxIFSAEH3jgAbcQrrzyyvbZZ58Fj0OwvvTSS04gL7XUUm6SJhmURAQOghBl4K+//rIbb7zRNtxwQ7fQhAxilAQW2qTDOP7kk0/cooISxML58MMP20EHHWR33313ubF94YUXOoWShXPfffd1gpnFacKECZZEGOcolSiQLIwoGxjJZ599tltMUIrhkEMOse7du9s777zjDMvlllvOGU4snhdddJElHYxkFGkUpzgYjhhLzIG4MlHqoCijGOEA4LvjCAkxefJku/POO91YYB6ggHCvR48ebUcddZQzIPxxt99+uy2wwAJO+W7SpIlTuFFIUciRh6UCCu5+++1nY8aMceeNQhgCGcc54/zgfJdddtmCv5M50Lx5c2cw4FwoRVCAmaOLLbaYm5/Ipzhz5sxxsg0Dd5tttnHXCuOXcf7111875w9GRRzWfdZH5EQpOkkwZHbddVcnw1mTQw4sxuyhhx7qzvfNN9+0qVOnurUemb7GGmvYgAEDyh3PfeZ6AMdPmjTJzadSGuvV0V04b2TBpptuaq1atXJjHuMaBxBrOsaTlx19+/Z159u1a1d3Hd566y3nMMcxigGRJBkXBZ0GWVYIHOFcGxxB33//fS1/4+RSb8bSVluZ7b23JRIiByykCFOEMGAoYZEzee644w5LA5zbfffd5wQDC+Kpp54aPA5Fce+993aLxs0335x4YwkDmCgBC4kHRQMFg/sb96ChgKAkn3HGGXbeeedZksEouvTSS8t5U/E2cf4oFETXAOMYJYS5kBYv00cffeQeUZ577jm7+uqr3QKJscRc4DkGFQZF1MBAkd54440rRKGSBmOZSDkex7jhe+aZZ7p7zvhAyUKZTAoowaeffrr7iYy69dZbg8e98cYbLlJ8zDHH2CKLLOJewyD2jgTusVcWiVyccMIJLhIBXDeULJwIxx57rJUKGP+HHXaYU/ZWWWUVN6ZD4Gl//PHHnQFx5JFHVmoskUmBNxqQl6UISiPnyk8UR2RbHIxfZHfUEbT11ls7RZk1nmyBtdZaKzhOuK6s+yiUpQYGA/OVnyussIJ7HofIEdcHo8GDoxADa/fdd3eR5aiBScQFIxGHIlGGpOsuZEzE2XzzzV0UikgpDlNgPv/5559u/JBB4vUeDEccKzhLKotAlpqMizoTiBwxhjnfEFw7riP3m/su5kPN0tSpTFZLHCNGjLCtttoqbygBVjyTjNB1KQuR6sDkL8ZjyDEYSmmhY8eO5QwlIMrSvn17t3DGYRFiUTn44IMt6bAQxIU+Cy1eV9JYPPfff7+7HhhKLJ5EldII5zZu3Lh8+hX3GeUKr2IU//9SSsmoCXgZiY4TNQxB5LgUlIKawH0rJk3qyy+/dF54bygBBgbK8+eff55/jegL3lZvKAFygzGCYoXCWSqgFGMoVQUeZgylYvCGUinDWMVQqmpchLJBfOoS9zIOa/yTTz7pHCehCGyp3HMMpcrAIRI1lDyffvqp+8n4juo4RJRxGnH+XDeiqknWXUK0bt3a/YzqcaSnM468oQScO3ogBnNULiRBxnm4l8i16HnFKdWo8fym3kb+YYeZLbQQudRlNUxJcsaymBBZikNKAu8lydsqioO6NEL0UcUICNfjcSZdIZSqkZZzJ8LglUe8USweGEukJ5K6gpGA4kDEKelg+LPgYBjgXSU1idRb8ClYcYXSp+GgVCcVFCeiBQceeKCtueaalkVQLlGSSLGOQ3QpqjijjPrxEMUbk0QbRXLxhgYpSKF01IUWWsjJvjTCuXlZ7yEtD0jVO+mkk1xkndrG448/vpzjOKn3GmcCUSifehg1IIg0xx2o4J3ESUxPowaJSDn1t6IE0/AYb3vtRQjTDL3zyy/NyAggLe+dd/DmWMmDQvThhx865YLiX688+RQealxEuiCSQlg7WpOCEXHiiSe6FDWiisXkBycRUhBINSQtyQtZzp3cbpRFFk4UCnLE+/Xr554TnUsqpCtR2A3McSLJ1KZEFWAUh6g30afp+Bz3JEKtDff2oYcesqyCIggh7yzjmgiqN5JwnBBdwlCORtZ97WJVXn1R2pCSiAM0Xt/FHCEFD7lXqpGVeWXHHXd0Yx2nWDzigjOFcU+5AUYS6WhcC1LUMCqSSI8ePfLfHUPx6KOPLtcUAUcJ0TbWQX8dwF+fUooiFwPrNxkERArJHCE6JkrMWEKHiupRXbuW1S6tu67ZWWchoCwRE4vUK/JVyXklVQdvBBMJyGMX6YFIId4zDCLuvYcaHgpHH330UUsrpN5Rp0WjC4p+wafckbLDNfDKBF5WIjEsokk2lp5++mlX0I8iQC46CpGPIJCyQg4/xe1E27j/FI6zuBbyPiYBzoXaBXL1k2zwzSteYQpFjPxrHMNzuqUxFmiAQlMEIkpEmr1BnVTFUZhTJEm5poYznmaHUwglk8h6GsFRRGSZ84ymV3uHAE4AGt6gcAOK9hFHHOHmA3IziZB2jMOb7qc0SIjrcNTt4jRkLaSWjywLahbpogjFpq6WCjSiQV+l+6uoGfPFTUK68B57mNHF9J9/rOShsBlPCoWwvo0inhZfLFiqOcyi+hAlpKMQ+coYRT6SyIJx1llnuWJKlOU0Qq3OySef7DzqtMf15+4XTYq/o15Xxj2F0XjbQi1nkwIRRNLuWDTxlpJyS0c8D9eCKCJRxdtuu81F0yiKxrBMqqOEc0IBOPzwwy3L+BS60Pj1r/ljqGtCNiD7aWxDWhJtirfffnv3flIN56xDa2jqkUgtjnc5470ffvghX/ifNmhQgsMLeYYxEMUbBGTVeEMJyKghAl9q7fKrA85AGrfQZhtHOIYiTjMPHfXoeoc+wJqPwcT7/IRQWUapwhpFbT2OwKrq+UQJdMOLg77JXKSm7v/TZUsaJhRpSXgWCdviifnPf/6T+LoF8T+InJDPSy4zC0e0jgEvPIsHKXg+/Y70DO9p4zWOT6rC5PPSyVknUkQLVo9/HspTpxgUpRKPZCntOTIv4C3FEcL9JGpAFAYDieJnDAzqWBgjdEVKYp0K0TI6POJdpS7PQ3oZ0RG8rRjMWSj09WPWp+NFYS6QlhWNOrFHDek6KFG8Tp2bT8eO1zeK0ofmHnfddZdzAoUa9uAww6DgXuNM8u2avdzHaIg2BkkSpBbjCMbZhbEQx7eXjs8NDCfmRlqcxMh1DD+cZRiOHoxn5jtOMbKJ0PN8S/LKukaWGhjCjFOioz79zqcMY0jxGnIwFF0X/2O+XR0asmCcB2opSxaEIpPHg0LNREvLPktZBqGBoMRTjBcm3jqWugSESigV47LLLnMPQt1s9pc0UJJpF+o95nGPIcYSqVo+7TQKCgSRp/jmnUnGR9Li54SR5Av+yWnHeCzUfrWUQdFn8T/33HPdIw4yrlevXqnYQ6oqcHxxn0NGL84QjKE4OETI+/cQeSD6FH1NJMNpQHoZm/GSVusj6VFwlJBqGdqI+eKLL3Zy4Pzzz7ekwT5JbH3AuoZzDHkQx9fixY1BrhPOlGgziKSDIzSURsu8ju5XRYMESNI6j9GLM5PmTHGoxePBtgfRTohiPhhLdBuNOKkddKl86ikzmnIktV6SsD0Th3120lr0mRXwuhAxIh+Z+0qtUhyiLmxMHAXjgUWWDSn32GMPF7pP4rmTXkgaGjvSk54QghxuvI+0mmbjVsB4xBtHOkMS5wApCfHN+VAESMXBgCTCEoIuiNSyYWDT9CJp0OqaqFgoNQ8FCCOp1DadrEtwjCDLGQs+TQUDiCLuqmrxUCipdaF+I0mpOVkHp4ffhJT02kIZAaF9eUjN40EKaxKjrzgAOC8MQYzFQrV2dIojAsHYpvmFT0tF/iMnQ9tqlPpah9EQ73ZIthCZIVV1OiRdmzomrkeSIkvcr3i3UzqAsqcYUXIijEkcx6kzlvbbjxbbZU0eaCpCN7zbbqPewezyyy0RoCCiSDKZGFSkXdBBqlOnTs4DmybIy2Ui+c0p8aj59AMiL3hhMRK8R9230HzwwQfdTzrHJG3TUhp3IDg4P847vgkt6Rm0k+YRxafjEW2KG1JJ4dprr3Wb1FF7xMLIpqxR6HzkO8axRwO7mlMEzYIzZMgQt4CySWcSIa2WVBLSUHyrdOY43uKBAwfm65EoZsbDSDoGqQrstcE+XNSs+LmRJFAQQ+1j/eba0fdIU/Lt4Tl/UnJ8q12MDIzoUobOhihIPpUIxcgbyCgRGDi+7o57zmt4mUldYZ+ZaIcsUi+R+ygXjH/kIBsScxwNH0oN7iPy2qfPouT5Zh7Mc9LJiBp7JdGnk7PhuN9XCdngwSnijWjmAREZfyzGA5HpUoC1iXPz9xlHkE8/Ym3CscMYZp1j/PrUKg/XxF+L6P33eCcKaU2llnrMvSR11EeDSC/0z3FskUKHvEbuIc/jnf+4535/PWQ7ddo4hti4HV0A/Qe9B0PKR1mSortw7jg2kd9EgZn7rOFkkjBP4s0PiLaQisd4IF2ZOcP9pvlTkmQc6eTxrRH8fODc4oYU9xVZ541o5vVrr72Wj6glNe205I0ldMj77ze75hryJMuiTN27mxG5Tkr2Gp4YPCmkKDEZKfBHaSSqkLY8T4RjNN2K+g3f8QYhiVAhjSduUPj/s4AkzVjyQh9hGy3y9KRh89lCkHYYDcfH8cYSShbRCJQM2qqzkBKFIhUlmqaQJFCIKc7feeed3SLIgkNEgZbaKH/RdB0WW5RqFlwUBVJvSmVjwroERZKIUxT//3333bfkjSXucXRzVow/Hn5fFRQmoklECfAao0Ai6xnTjIuofPf7cXnlhBQ+UhZRUEtxk24cONG2x0TMfdQcIwiDgvdxfkTx/2d8R40lPhuV7RgU3qggClcqxhLGfbS1M85NX1fmo+JeoX7ssccqfJ7zTGodMkZ7tLslxp43+HwqoTeeaW4Qh+yK6GbkjHVkPfOc4xkzbMhNBka06UMSdBfOm/PAeEYu4BThNeYvmSU4PaKQKYIhhWHBXMdwYm6UmrFQjIyrDsyV6LYojIef/n9M4CAptfOvLxrkSm3EVwHGig+jEtVIS5FhMeAl8WlSFJ5mJe0DQeANFtKE0lQfUxUIfy/EWaTwGmYFFBr2/wDamKfNMVEIIlqkvWRdxrFhblIbplQX5Jo3QrM01uPjnbqKUjQ86wqi+WQ2AFkqvvNi2sHoYnP3rOkycX0mSzJuzpw5dskllyRWj0teoYEQQgghhBBC1AMyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECNLIEM2PGDMsS0fOdNWuWZYXouU6fPt2yRPR8Z86caVkier7//POPZYXouWZZxs2ZM8eyQvRcszTW4+c7e/ZsyxLR8/37778tK0TPNUu6TPx8syrjkkiDXC6Xs4Qpj61atZrfX0MIIYQQQghRDaZNm2YtW7a0JKE0PCGEEEIIIYRIQ2SJr5u11JTQubdo0cIaNGhgWSCr5w069+zdd91z3fOsjHXQeNd413jPFi0SuJ4nzlgSQgghhBBCiPpAaXhCCCGEEEIIEUDGkhBCCCGEEEIEkLEkhBBCCCGEEAFkLAkhhBBCCCFEABlLQgghhBBCCBFAxpIQQgghhBBCBJCxJIQQQgghhBABZCwJIYQQQgghRAAZS0IIIYQQQggRQMaSEEIIIYQQQgSQsSSEEEIIIYQQAWQsCSGEEEIIIUQAGUtCCCGEEEIIEUDGkhBCCCGEEELIWBJCCCGEEEKI4lBkSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhAggY0kIIYQQQgghAshYEkIIIYQQQogAMpaEEEIIIYQQIoCMJSGEEEIIIYQIIGNJCCGEEEIIIQLIWBJCCCGEEEKIADKWhBBCCCGEECKAjCUhhBBCCCGECCBjSQghhBBCCCECyFgSQgghhBBCiAAyloQQQgghhBAigIwlIYQQQgghhLCK/B+dVyYka+/4wQAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cecka_t = Layout(((3, 2), ((2, 3), 2)), ((4, 1), ((2, 15), 100)))\n", + "print(f\"Tensor: {cecka_t}\")\n", + "draw_layout(cecka_t, title=f\"Tensor: {cecka_t}\", flatten_hierarchical=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "output": { + "id": 1969451546987700, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0sAAAH5CAYAAABQ2aUhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAlhZJREFUeJzt3QWYFdUbx/GXThMBscUm7MAEVFBQEezGwMYEUbE7EEXFDgzExMIGBAMFW0TFBIvu7vt/vmc9+5+dPQsLEndmfp/nWVnuXpC5M3PO+57znjNlcrlczkRERERERKSIskV/KyIiIiIiIkqWRERERERESqCZJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEZH/5M4777QyZcq4r5NPPrnw9e+++87uuusua926tTVo0MBq1qxpFStWtFq1almzZs2sR48etnDhwuX+6fN3br755u7fU7ZsWfvqq6+W+/9DRESyoUwul8ut6n+EiIgk05QpU2yzzTazSZMmueTk+++/t2222cb9jASJ3y9OkyZN7I033rBq1aot13/Xgw8+aGeffbb7fr/99rN+/fot179fRESyQTNLIiKyzO644w6XKKFFixaFiVIUSdR2221nLVu2tE033bTIzwYOHGidO3de7mfglFNOsRo1arjv+/fv775ERESWlpIlERFZJvPmzbOHH3648PfHHXdckZ9TcnfhhRfayJEj7ZtvvrE333zTfv31V7vggguKvO+pp56yRYsWLdezUKlSJWvTpk3h7++7777l+veLiEg2qAxPRESWyfPPP2/HHHOM+75y5co2btw4W2211Qp/PmbMGFt33XWL/bm5c+e6982fP7/Ie2vXrl3q/zflex988IH7fuONN3YJWVzfvn2tefPm7vvy5cvbX3/9Ffz3iIiIlEQzSyIiskxee+21wu933nnnIokSSkpMmPVZc801i7y2+uqrL/ezsPfee7skCQsWLLC33npruf8/REQk3ZQsiYjIMvnwww8Lv99ll11K/efYnW78+PGFv99tt92sSpUqy/0sMNvVsGHDwt/7mSgREZHSUrIkIiJLjWTnn3/+Kfx9vXr1SvXnZs2aZWeccUaR16644ooVdgai/y5tIS4iIkuroD5BRERkKbA+KcrvPLc4M2bMsEMPPdS+/PLLwtc6depkhxxyyFJ/9uyiVxprr7124fdjx45d6v+PiIhkm5IlERFZpucrRcXXK4Xez9bigwcPLnzt3HPPtdtuu22FfvrRtVDxf7OIiMiSqAxPRESWWnyDhunTpy+2ZK9p06ZFEqXLLrvMunfvvsI/+alTp5b4bxYREVkSzSyJiMhSq1WrVpHf+wfTxrGuaf/997fhw4cXvnb77bfbJZdcslI+9ei/q2bNmivl/ykiIumhmSUREVlqJB7rr79+4e9/+OGHYu/5/fff3fbdPlEqV66cPfroo6VKlDbZZBMrU6aM++KZSnG85n/Oe0sS/XftsMMOpTo2ERERTzNLIiKyTPbZZx979tln3fdffPFFsZ+3adPGRowYUfj7OnXq2Ntvv+2+4h544IHlPvMze/ZsGzZsWOHvGzduvFz/fhERST8lSyIiskzY2c4nS59//rnb7a569erB9UL4+++/3VfIHXfcsdyTpY8++sg9jNbParVs2XK5/v0iIpJ+KsMTEZFlwsyRT3CYxenTp89y+SRJcCZOnFj4+7322muZ/p7nn3++8PuDDz64SNmgiIhIaShZEhGRZVKxYkU7/fTTC3//zDPPFPn5yJEjLZfLleoruu5oyJAhbpYKW265pV155ZXB5yz5P8v/J27OnDn26quvFv6+ffv2OssiIrLUlCyJiMgyY7MG/+DXt956y3788cf//Gn269fP/crmDWwIUbly5aX+O3r06FG4E96+++7rduQTERFZWkqWRERkmfHsoiuuuMJ9zyzP8njIbP/+/d2vZ511lttNb2ktXLjQrYHyCRdblYuIiCyLMjl6NxERERERESlCM0siIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZKmU5s41u/RSs/XWM6tSxWy33cz69rVMmDHD7JprzA480Gzttc3KlDF74glLvc8/N2vf3qx+fbNq1cw22sjsqKPMfv7ZUu37782OPNKsbl2zqlXN1lnHbJ99zPr0scy56aaC671BA0u9gQMLjjX0NXiwpd5XX5m1alXQxnHdc87vucdS7eSTSz7nfP3zj6XWL7+YHXOM2QYbFJzvrbc2u/56s1mzLPW+/LKgP199dbPVVjNr3tzsm28ss3HLjz8WvK969YL3nnii2fjxlurj/uwzs3POMdtpJ7MKFQreJyUrv5ifSaxTeeklswsvNNtii4KLr2VLswEDzPbaK90f1YQJBZ0IycJ22xUEVVlw221mgwYVJA7bbms2ZoxZ9+5mO+5YEDymNYD+4w+z6dPN2rYtGBwgeOjduyCQfOghszPOsEz4+2+zm28uSJSz5PzzzXbZpehrm29uqfbee2aHHGK2ww5mV11VEDT99lvBNZBmZ55ptv/+RV/L5czOOstsk03M1l/fUumvv8x23dVsjTUKBsQIKj/9tCDIJJF47TVL9aAAMcuGGxYc76JFZvffb9a4cUEAvdVWlqm4hXucwUCuBdp7ko077jD77ruCz6NiRUvlcb/1ltmjjxbENgyMpn0Q+D/LyRINGUL3kct16fL/12bPzuU22yyX23339H+Ac+bkcqNHF3z/+ecFn0WPHrnUGzQol5s7t+hrP/+cy1WqlMsdf3wuUxYsyOW22y6X22qrXGYcfXQut+++uVzjxrlc/fq51BswoODefvHFXKZMnZrL1a6dy7Vpk8stXLiq/zWr3kcfFVwHN92USy2OjWMcNqzo6yedVPD6pEm51GrZMpdba61cbsKE/782alQuV716LnfYYbnMxS1nn53LVamSy/3xx/9f69u34P0PPZRL7XGPGZPLzZpV8P255xa8T0qmMrxSYEapXLmiI+qVK5uddlrBaBSjVGlWqZLZuuta5uyxR/FRJWYVKctj2j5LuP4ZiZwyxTLhww8L7vtu3SyTmFlcsMAyoVcvs7FjC0ouy5Y1mzmzYLQ9q/g8KMk57jhLrWnTCn6tXbvo63XqFFwDSZtNWBoffVQwm1ijRtHjZmbpjTcKZlayFLdQNXHwwQUzMR6fz5Zbmr3wgqX2uLn2WVIipaNkqRS+/rrgxqG+N4ppfKSt1ldKxvgLgRXreNKOoJEpfcqR7rrL7O23zfbbz1Jv4UKz884za9fOrGFDy5xTTilo6xgQatrU7IsvLNX69Ss4XtbnUIJECR6/P/tsszlzLFPmzy8IEBkoogwvrZo0KfiVAU/6bwY8n3/e7IEHCspQ01x6y/rrUJDMuq1588yGDbPM4J4fN85s552L/4z4jthPBFqzVAqjRxeMvMT510aN0sWUFc88U9DAUhOcdh06FKxRAqOthx1WsGYr7R58sGDdFkF0ljCafvjhBWsxGQz44YeC2v299zb75JOC9TxpXejPLNqhhxYEz7fcUlDnf++9BTOpzz5rmfHuu2YTJ5odf7ylGovfb7ihYI3K66////UrrjC78UZLNQYEWHPLoBAVAyBJGjKk4Ps0b+oRiu1QUnw3aVJBcslsjWSbkqVSmD07fLMw8up/Luk3fLjZueea7b57weYHacdmJkccUTAYwGgznSudapoRKF59dcEi/5o1LVOYTeDLY0MPzj8LgC+/3OyddyyVKDtiExM2NfC73zEwwLXOYAEDI5TfZqUEj52x2PUz7Zg5Y2E/AwSUpL35ZkHyRAkTmz6kFTugMWvKwECnTgUlpySIPnHIUjzjj3VJ8Z2SJVEZXikwZc3oQpwv0VDdZ/qxE95BBxXsmOPXsKUdW+lSu33SSf+vZWfHMEoR0+rKKwt2xqIMTwp2wWPGhV0/SZbTyLffxx5b9HW/Zod1qVnA/c0ucAccUHQ9Sxo991zBGmR2Azv99ILk+LHHCgbBeEQIgyZpxaBA584FiTHrbyk1ptSaxAmUoWaFv/cV38mSKFkqBaZj/ahLlH+N7ZUlvaZONWvRoqAkh9H1rJ5vZhl49lRatxilHOvhhwvWLDCbNnJkwReDIqzl4HvKMrKGjT2YZWENWxr5+zm+2L9WrYJfJ0+2THj11YIZtrSX4IGtsikr5RlLUcym8hmkfa0Km5mw9pbNHoYOLWjX/aYmrM/OCl9+V1J8x8CZZpUESpZKYfvtCwJEv4OO52t8+bmkE4Eysymcf2ZX6tWzzPIlCySPaUStPgEDydKmm/7/i/uc88/3WVirFvf77wUlKWkdceahjKG1Gn4talbKMVmPyTkmYUg7EoXQTCmDIsjCTpBrrVXwvCW/iQ1rNEkeqSjICp4jxv0d2sSGZywpthNPyVIpR9RpWBl19pi27dHDbLfdCkZeJX0450cfXVCG8+KLBWuVsoDdgUJBxFNPFZQtpDVh5CHDr7xS/ItSFbaV5Xvq/NMq9MT6b78tWADfvHnBJh9p5NfnUIYVRYlW+fL/3zktzTj3BMtt2hTsipZ2zJ4wexSfJWczD65z1ullCTsBMrvEOtW03uclYc0aA6HRR8D0719wbfBAehFog4dSICHipmGRM4EkdfxPPllQlhPvYNOKXdAoQ/OjrX36/P/p9qzvYC1PGneDI1BkZonyq549i/78hBMslc48s2AWlcXPjLyxXotRZza46No1vTMM7ADXunXx1/2zlkI/SxMGBkiG2eSBEjR2w2OAiOD51lsttSjHOvVUs8cfL5hR4Hkz7IbHAAltfhbKbgmWOfYslODhkksKHoXATo9s5sAaLQJmXuORAWk+5zxDjhlyBkA4bnbGY+CXHQIvuMAyF7ewfot7ncckcPys3evSpWDGjccopPW42fH16acLXvMza34nyI03NjvxxFXxL89ji3lgrUTMnp3LdeyYy627bi5XqVIut8suudw772TnI9p444InPIe+RozIpVLjxiUfc5rvnGefzeX23z+Xq107lytfvuBp7/z+tddymcR1UL9+LvXuvjuX23XXXG7ttQvOe506udwJJ+Ryv/ySS71583K5a68taOcqVMjlNt88l7vrrlxmNGqUy9WqlcstWJDLjCFDcrkWLQr6dM75llvmcjfdlMvNn59LtV9/zeWaN8/l1lmnIJbZeutc7pZbcrm5c3OZjVuGDSv4TKpWzeXWXDOXO/74XG7MmFyqj3vAgJLfQ58nRZXhP6s6YRMREREREck3GatOFRERERERKR0lSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQCylvC5HI5mzVrlmVR9NirVq1qZcqUsSzI6nFDx569865zrnOelWsdut51vet6z5aqCezPE5csETRXr159Vf8zRERERERkKcyYMcOqVatmSaIyPBERERERkTTMLEWNHTs2cdnpfzFu3DirW7eu+75v375WpUoVy4JJkyZZq1at3PctWrSwcuXKWVbMnTvXnWsMHTrUTV9nxYQJE6xRo0bu+7Zt21qFChUsC5g979Wrl2W9jevatatVqlTJsmDatGnWuXPnzF3r8eu9Z8+eVrlyZcuKKVOmWLt27dz3nTp1sooVK1pWZha6deuWuVgmHs9kqY2bO3eudejQwZIq0ckSQUSWAonosdK4ZKWBiR4niVL58om+bJfKggULCr8nUcpSshQ9VoLHrASQ0ePMchtHEJGVQCJ6nFm61hE9VhKlLCVL0WMlUcpKshQ9zizFMogea5bauKRTGZ6IiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERALK2wo2d67Z1VebPf202eTJZttua3bjjWbNmlmizJ07166++mp7+umnbfLkybbtttvajTfeaM2SdiBL6fvvv7c33njDvvjiCxs1apStscYa1rBhQzvnnHNs4403trSoXLmytW7d2rbYYgv3tdpqq9k999xjAwYMKPK+8847z/bdd99if/7vv/92P0uimTNn2v33329ff/21ffPNNzZlyhS766677Oijjy7yvvXWW6/Ev2Pvvfe2559/3pKkTp06dtBBB9lGG21kq6++us2bN89Gjx5t/fr1s++++67Ie9ddd107/PDDbbPNNrOFCxfasGHDrHfv3jZjxgxL4j197bXX2pdffmljxoyxqlWrWr169eySSy6xQw45xL1n0aJF9tRTT9nLL7/srotJkybZpptuasccc4x17NjR3S/5bs6cOfbuu+/aiBEj3NesWbPs5JNPtj333LPYeznvXL+//vqrlStXzrXvRx11lGsHovhc3nvvPRs4cKBNnTrVateubS1atLDddtvN8kmlSpVs//33t0022cR9VatWzZ3PwYMHF3tvaa5tjnOPPfawrbfe2mrWrOn6w7/++sv1DX/++afli9mzZ7tr9qeffrKff/7ZHcOFF17oPosoft6/f3/368iRI91xcywhBx98cPD1tm3b2pFHHmn5gnMyaNAg1xf9888/7rNo06aN7bDDDkXex8+5p/l17Nix7pq+/vrri/19vOeVV14p8f/HNbPddtutkGNZWtzbXN9cu7Rv06ZNs2uuucZatWpV5H1cG2+//bY759OnT3fX8k477WRnnHFGsH979dVXXcxH7MM9QPvHV9LauA8//NCGDBni2jmuC+K4rbbayrX366yzTuH7aOc//vhj1/+NGzfOypYt6z6Xgw46yPURWbbCk6WTTzZ76SWzCy8022ILsyeeMGvZ0owYdK+9LDG4AF966SXX8BJMP/HEE9ayZUsXTO+VpANZSk8++aQLoOlsOO6JEyfaCy+8YMcff7z7DDbffHNLA4IikgMaCBpSEsKSEFSTXMQTjqSigSQ5Wn/99V2D+MknnwTfd++99xZ77dtvv7VHH33UGjdubEmz9tpru6CSAJLAt2LFirb99tvb2Wefbc8884wLPLDmmmvaRRdd5DqZ119/vTAQpRO5/fbbXaCVJH/88YcLFAj2OAY6WIJjAouHHnrIBQ68dsopp1ijRo3srLPOslq1atmnn37qAhCCzPfff9/KlClj+YxAmQCY87zhhhu6wLik65/zWKVKFRdcEoCQEBFMXnHFFVa+fPkiwRPBFoMDJCG0jVz/fBa77rqr5QuSIwIc2msC5y233DL4vtJe2wRfJEsE0ARefFb0eyTY3bt3L/GzXdkIkp999lkXBJPcxwc9PAb/OMecQ5JFPqPFIeGID5LVrVvX8gn3LEk8gTCBPf1YCEnkV1995d6z1lpruWskhMFQEqI4+geSrHw6fgb4HnnkEXcuiVMYCArhOuXa3meffdwAGeede/qjjz6y5557zl03Hm3izTffbPvtt5+Ld7jXu3Tp4toH4sEktXEMbNSoUcMltwyOTZgwwR3z0KFDXZtOOwCOkeSLfpD7nfufdv+uu+4qcaApK1ZosvTZZ2bPPWfWpYtZx44Fr510klmDBmadOnHTWSJ89tln7kbiRmFUFSeddJI1aNDAOnXqVGJwmQY0EjfddJNVqFCh8LXmzZu7xIJkidm1NGC2kOCQRpcR1jvuuKPE99KAfPDBB5YWBMI0kvxK8sNIeUhJHSeBIrNyScMIJF9RBBuXXXaZ6yB9snTggQe6IPLWW2911wkIRC644AKXTPj3JQWDPHxFtW/f3o2w3nnnnS5ZInHkuOgwvdNPP90Flz5hio/W5xuCRu5jfuV80Y6FkPwwAHLllVe6gAIE2gQIXN8EVuDcE2A3bdrUjjvuOPcaSRP9AgNpO++8sxuJzZekgeuYX5k55fuQ0l7bn3/+ub355ptu9sIjiKLagqQsX5IlgkZmAkgCfvnlF5cIhnD9H3HEEe7YH3jggSUmSwTYnPd8H/AjeeVXjoeBjxCSeq5b+nQC7ZKSJT5LvqLmz5/v/gz3R3zWdVVidoQgn19/+OEHO/HEE4Pvu/zyy4u9xnk94YQT3HERA4CE6L777nMDAgwa4LDDDnOzcAyO8D3JVlLaOOK40AAA8Rv3se/zmW2iLYieWwZCr7/+envttdcynSyt0JadGaVy5czOOOP/r1G9cdppNLRku5YIdISUZhBEeJShnHbaae5CI2tPK0YiookS6HwZVWLaNy0WLFjgEqXSIihidDUNCBhIlJYWgdNbb71lu++++2JL9JIkl8u56yB6bhllY4TaB5MgOGR0lQQjDWjfGJn09wDJUjRR8ph5wY8//mj5jnaLIGJJGIVmJtknSmCGlZF3ZiA8BhQYKGnSpEnhawwUEExwbfz222+WT+0ZidKSlPbapo+LJkp+Np2yRUbz8+mckygtCe+h3VsaHD9Jdb5iBrQ0CUz16tWL9emlxbXB50CZaj6hvYqWky1tOTaYbfe476k2iJdZUprLLCylaklq40J8e8eMpEd1Sfwa4v/RsGFD10aQRGbVCp1Z+vprM2b/4wm4r1b45huzDTe0vEfpAWUM8ZEEX3ZBJ0qgkRUElJSu5NM0/MpEJ0uZFgkzDSwNJ/XSWWtIKMWiQ/EBdFLR0dIhkCARBBAo+zIOOiLu+9C6DEby6tevb0lFsEvHzzmkBIsZlvg6tTjWOGFZA5N8QwDAPcyMWVy8jIuEgXvfB1fR94FrhBKgpFge1zZ/PsklyKXFTCoDQ/R99PXcJ9GkOSso26KtTPr6FQaFmCWiPaN8D9EyWj9TGj/ObbbZxg2UDh8+vNjsfBJQtsdxE7/5NXoc05JM/bdMna+sWqHJ0ujRZO3FX/evjRplicCiuHgHCf8ai/+yhKCKtT2sZcgagitqnBlFptFkKpspbIItynhoiLKCxbIEjyUtgE4KygspSwHnj8EPv1mFH7Wjs4hj5J5RWkZ0GclPmg4dOhSW6nAtU1rC+pPFoSSFALmkUs2k8ec1NDrLayQClB4RIBJgcezxtVqLu0by2X+9tilXJlF85513LM0IJinHYgaNkjXKESl9YkQ+iQHzsuJ4KW3k81jaWbl8Q/vlZwm5DyhfpOzUY00Ps+3xMkQ/k8PPk4jj9Pcz9zebVSwp8SXW+/rrr91Mc76UGacuWZo9m1H44q/7jZT4eRIw+hpqHPyOUPw8Kyi9o6aVEfikB8nLomfPnkV+z6wSyTI1z5Qt5cv0/IrGaDyjrSx6XtYygHyaIWPBM4tcd9xxR9ch+EX9vlwlFDASRPv3JDFZYrMa1m1w/bJpCyVmiyszYrEzOwWyuYlfEJx0/nijmzh4/tz7ZIlfF/e+fC7RCvkv1zaB1qmnnuqSh759+1qasSYtih1wuXfY/Ii1jUlPHEqLtUC0EflWgrcs2OmW+5V4hhnDeAxHqWHoXgezK0mtImEtIvc2EwDsjrekNovP4cEHH3TtQGjNcpas0DSRsv9YmbPjr7OkLPmgPCderw1/w6Rl7cqSMJrCzUZHyQgzIy9i1qdPn9R0IqXF6CrXP7MRScf6DMou6DxY7E3ww4540aBxScF0ErENNJs0sFkNJRmUaLCVLKVGccy0MXPKOk3/2aSBLytZUsLgf13c+5JWorKs1zbHyaMjuE8IpEJ9Y5rx2TBQ6NdsZQWb/xDrJKnUtCS77LKL26yAQc7bbrvNleJFH33BtV3SABgJRhIenVBSm8/6IzbpOvPMM13swmBhCFUWfC4kVmeddVZqBsjyMlmiSo1SvDj/WlLWhFNuxwUT519Ly+L2Jc0knH/++S6golQnusVm1tF48rnk0+5AK6MEj5KkfN8RbVkwy0RZJZteLK5Mi+PnvCdxVimEWSZ2PWNr4ShmDkio2PWM4DhNFleKxmtswe0TB4IFXosnk4u7RvLZslzbfqMjFoJTwhnqF7PAr9lL4nPWlgUlqKxtYx1b2gZJWYPGLnAsL4ieXwZAWdsTxeAB900a1mzSv7FZF4OEIazDZo0aW4ZvU4p1TWm3QpOl7bdnT3/qn4u+7s8NP08CdgwigIjvLuQvMn6eZowcsgUrz2fp1q1bZjd2KAmjTCRKSVuz8F9mYthSmXr9NJag+BkCRlE5pwwU0KnEkVDxLJ608KUo0euYNo4NPNgWm1K9kkpTkopd0bh3Q8+koUQnunEP3/sHF8ff53+eJEt7bbNWi2dzEVj26NHDrV/JKr/RST5sH70ysNEJgwRprZ4gxokmvv65ZJQeRvF7Zly4B9KA9iy0jOTFF190jw1g9798e+B2KpOlI47gmTRmDz/8/9eYse/Rw4zPPyl9CyOujDI8HDkQbi46DC6kpHWSS4Pj5tkEjDAwXZ3WxrI0GGEOTb/ToLDOhUWQWcDzFugwkl6CRzlpHOeRe5pOxAdEnFdKF6JbEtNZsrV0Es85C3bjGDFlJJEE0S/4ZXtwZpMInCnTS2u5MevUCAajo8gce3z7bB6jwKg6z+LyCCB55hqzTkl8QPfSXNu0cyTNPHOQTVCyIDQAxkYH7B5JopTEc74s6P+ZgeRBtUlV0nb6w4YNc+WU0Y0OKNPjeHlsTBS/JwZgw48kxXChHSsZ5OF5XPFzyvOqeJ4cg6FprBxZVit0mJCEiG3qeQ4Y/TPtypNPsi2p2WOPWWIQPLHfPkkDgQYNJIs7GY18LEkHsgx4MCPBAA9mpKFhMWRUmnYDYoccym78Djg0mP5ZBBw3P+OhnTz52j/EkFlFAghKt3h4cVI9/vjj7vwSIPrSKz+CzkLu6AgqJXjsDBV6Dk+S8GBROj46Sr/TGdvHcmx0in4tBp0HATXr9QiUmU2jE+Ea4DlrSUOtOueae5pyKpJCtsJnO9yuXbu6JJIZhwMOOMDt/sgOSqxRi++ExvO18h31+AS3Pugl6PPPFGJzEp5mTxvGVvHscMaCfc4755zPJvoQRtoFzjs/IwAhiSShYIalXbt2ebdTFM9/IsH1aw1Iivz3XMesOSzttc2DO/n7fv/9d5dYR7dZBslTvmxwwToMgkOf/NIu+93LWJNHO04/7tdq+HVHJIG+PIlrAwwSDB482B0vpedcO7SN48ePt4svvniZn1e0ojATzEyBf2YQazH9tc9ub7R3tHU+2fU7+foBAK6PeKUMfQJf7Bga3wkyn7DmiOPm3IB+2g8M+UcicK+zXofqGO4Nzj2JL20e97DH58Q6HQaIO3Xq5No67nXigHPPPTevSm6X1Mbh0ksvdXEKS0a4x7m/mTniM4hu1EUcQ9/HPcDyE679qHr16mVmNjVuhddUPPWU2VVXmT39NNsumzExwfbu/z4UPTEYdb3qqqvc08G5EJlhoSH1T3dPK79+4cMPP3RfcWlKllq3bl3k4aw0kD4gJGGkA+ZhdYwwEzwQHBFock0w2xJaGJ8UrEWJlt3QKfjEmF1wfANJ50JjTMCdb8Hh0iJAJuEjCKCzJHikLv+VV14p8nwd7ncGDfgcDj30UBcoMxrZu3fvRK5XInBgkIfNLNjNjDI0ZlAIDFq1auXew+v+YduXXXZZsb+DcqwkJEuMkHIs0WCALx88kiyRBHXs2NGVGTIQQKkhiQUzKfFgmNlU/gxtIaWotBdsepGPpSokPdEH7fKYA758AsH1Xtpre4MNNnC/EmSGyrDZ/CO+vmNV4f6Nzp5ynvgC7TbJEu12fGdT//sGDRoUBpkEhwwicB0RiBNoUqJFckk/kG8IgKMPV6dszJeS8e8lCeCcxxf1+98zABBPlmjvke9VJfTD0RJZjskfF3EKyS59PH04u3oyKMJrDAqRKMXXnnP/0xZwXXC/M9vK4xaOPfZYS1IbRwLMTBiJM68zqMFrDABQORBdf+VjAO6f0ERAx44dM5sslcklLMIjYPXlM9SY0vBlBRcwNyzYojqtZTFxdMJs1wpGQdK2bmJxCGj8c0xIVAjUsoLRYN9B05nl2yjuisIoITPXWW/j2EgmjWviQpjpIxDL2rUev959mVNWkNiwI5tPOJO2o+Kyol1jR92sxTLxeCZLbdzcuXOtffv2ie3Xkj00LCIiIiIisoIoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWRERERERElCyJiIiIiIiUjmaWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkYDyljC5XK7w+3Hjxlm1atUsKzheb+LEiVa1alXLgkmTJhV+P2fOHCtfPnGX7TKbO3du4ffjx4/P1PU+YcKEwu9nzpxpFStWtCyYNWtW4fdjx4616tWrWxbbuKlTp1rlypUtC6ZNm5bJaz1+vU+ePNmqVKliWTFlypTC76dPn26VKlWyLJgxY0YmY5l4PJOlNm5uJJaJxvFJUSaXsH81nWnt2rVX9T9DRERERESWAoOAtWrVsiRRGZ6IiIiIiEhA4uqZotO1Xbt2zcy0tS/V6Ny5s/u+bdu2VqFCBctKmUavXr3c9z179szMtLUv02jXrp37vlOnTpkqz6FUo1u3bu77vn37ZqY8hzKNVq1aWdbbOEYfs1J2SsVE3bp1M3etx6/3Fi1aWLly5SwrKE3ifGPo0KGZKUejxLpRo0aZi2Xi8UyW2riZM2cWVoUl8TpPXLJUpkyZwu8JIrIUSESPlcYlKw1M9DhJlLKULEWPlUQpS8lS9FgJHrMSQEaPM8ttHEFEVgKJ6HFm6VpH9FhJlLK0JnXBggWF3xNAJjGIXBbR48xSLIPosWapjSspjk8KleGJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCSgvK1gM2aYdeliNmSI2WefmU2ebNajh9nJJ1uivfnmm/bqq6/aeuutZ9ddd52l3YYbbmgHHXSQbbbZZlahQgWbMGGCffzxxzZw4EBLg9mzZ9vLL79sP/30k/388882Y8YMu/DCC23//fcv9t4+ffq48z9mzBhbffXVbe+997YTTzzRKleubEnzzz//2Ndff20jRoywKVOmWNWqVW2DDTaw/fbbz9ZZZ53C9/3999/uffw6duxYW7RokV1//fWWZL/99ps99NBDNnz4cHc9c/7q1q1rJ510ku2zzz7BPzN//nw79thj3ed1wQUXuPcm8ZxzDf/xxx82bdo0q1ixotWpU8cOOOAA22677Yq8l/P84Ycf2gcffODOO+/l+jj66KNdm5DPuIe7dOliQ4YMsc8++8wmT55sPXr0sJMDnc+PP/5oF110kWvTOEbaujvvvNNq1qxZ4t//zDPP2AknnGDVqlVz/698MmvWLHvqqads2LBh9v3337vzfM0111irVq2KvZdruWvXrvbNN9+4tn2vvfayiy++2NZaa61i7/3rr7/sgQcecJ8n/49atWpZs2bN7Nxzz7V8wD3cunVr22KLLdzXaqutZvfcc48NGDCgyPv4WdOmTW3LLbe0jTfe2MqXL29t2rQJ/p1rrLGGa9933nln9/fTBtJXfPLJJ5ZPZs6caffff79rpzmXtOd33XWXu1ej9/OLL75ob731lrs2eM9GG21khx56qJ111lnF+rAnn3zSBg0aZF999ZWNGjXKjjrqKOvWrZvlm0qVKrm+epNNNnFf3JNc/4MHDy7yvj333NN23XVXq127tlWpUsWmTp1qv/zyi+vPJ02aVOLfT9zToUMH9/0ll1ziPusktXGPPPKI9ezZ0/V1nHPi1iZNmrg2gc8rjrb+6quvtjfeeMMmTpxo6667rosJHnvsMcuqFZ4sTZhgRky10UZm9MNpiK25qWhsuEGzYJtttnENKZ3E22+/bXPnznWBdKgzTSqCiWeffdYFR5tuuql99913wffREPXu3ds1ugQeBA80KH/++afdcMMNljQfffSR+7fXr1/fNYjTp093je6DDz5op59+uutUQAJJh8nvOe80oEk3evRoF/AdfPDB7nqeM2eOvf/++y5ovuKKK+ywww4r9meef/55lyQnvf3iWHfffXdbc801bd68ee7cdu/e3QWF0UTxiSeecNdDo0aNbN9993X3PtcL10m+IwEmoScYJAksaWCHdo1jJii++eabXQByxx13uDaAYyd5iuM9nTp1ckFZPiIgIkDiniYx+PLLL4PvIyhq166dVa9e3SU8DBo9/fTT9uuvv7pgk+TJYyDpjDPOcAkSSSKfF/cCf0e+IDkiORg3bpyNHDnSGjZsGHzfjjvu6IJrBgz496+//vrB9xFQc01wn9DO87nS9hMwk0zTfubTfU1yxLHUq1cvmMxxfmnfdtppJzfQQ7v3xRdfuOudgQISqTJlyhS+/7777nOJwfbbb+8+03zFfcgAB/0Sg0EkwSEM8NAuDB061LX9NWrUcOezQYMG7jyTPMXxeZAk0mbm24Boads4EmjiGmIW+m8GSGgfuKa//fZblzx5xDR8JiDu43oaNWqUawuzbIUnS3XqEJSYrbuu2RdfmO2yiyXeSy+95EagGaXJtxHF5Y3GgUaV0UlurlwuZ2m09tpruyCBhoSRJjqUUGfEbCIjkn6UCTQ0zFAwurPbbrtZkuyxxx52xBFHuJFVjwCDTpJAgJ+B0Thm0Aie/GhT0jGCzlcUgRaBIKNw8WSJ88890LZtW5dMJhXnNx5EkgiR7Pft27cwWfr888/t008/tbPPPtsFl0nDbBkJMQkDAeEuJXQ+BEkEhCQUBB3+emfGhGSRBCHuxhtvdIE5bQFtQr4hCH733Xfdrz/88INLgkMef/xxF0BzvfN5gYGTc845x80++nuAvu6qq65yo9C0dfkWNHqMrJ9yyikuqWE2gCQg5J133rFXXnnFDRQwKFRSssRsK+07o+x+AI0/e9ttt7nRe+6PBQsWWD4giWVGiV8JgFu0aFHsPbTfr732WpF74fjjj3dJBJ8VbX50sIQZND4bEobNN9/c8nmw87LLLnO/cg/zfchzzz1X7DU+q8svv9z13e+9916xn9NHEBeQfNJOJrGNY8YxjhlYZksZFIl+XmeeeaaLB2j/SSZlJa1ZYvKFRCktGGGnU41ObacZNx8jiK+//rpLlBhljY48pQWdyJJmypjCXrhwYbESLf97ypWSho4lmiiBBpIZtvHjxxe+xshzdJQ5rcqVK+dmz0KDIPfee68r2WnZsqWlTdmyZd2AAaOtHokTo5EkSgTLzColCTP/BBFLwkwxs4s+UQKzDoxOv/DCC8Xez2AKI/jMLMTvnXxBOx0toy0JM6kMgvhECQSNXOecf49yJspWSRxJlEiwaAvzDYkLidKSMINAolSaqgreG600oB+kNI37hcQyn653EqUlXRehgNonVlzbUZTcJqG/57yTKC0LX37HLGIcZemHHHKIGyDkmk9qGxfiy++i9wsxDtVDzJwSBzCbRum5rISZpTQhYKBUi5EGGpEs2GqrrVwjQcLEiAOBJDcQU7LMsOXLqNrK4BuNePml/z3BRBoQDDDSvrj1GmnC9c01TYJEwssIIrMKUdT302FSs52E4KE0SH4IGDl+Rlc5RkYawWuUMVHXzugyQbUvv2W2oaQRzKShZIfyIn/cUcwuUW4dx1pGZpRImkPJVFJw3ASKlGzFkQSQEHjMmoMBE2ZeWePF93wOjErTP6QRxxgaJPCvMXvFvZN0vsSOBDALKNujHed4/eAXZaZxJEokYcy4pWGQjIoQBjkopfZrjlmL5PXr18/9SpzH67T7DCA2a9bMrVUMrW/KCiVLS4FFzlxsLH7NCkaqGHWmdpUgkil8vziWkRjW8GSFL9WgrGXbbbctfJ0SRaShNA3Uc9NB5FvJwYrCLAGzC+Ba59q+9NJLiySPt99+u+swOO/Ub6cBgb6fDSVwYAbpuOOOc79nVpHjphSDz4RyTO73/v37u1JEvqfOP+koYUF0ZsXjNZIJAmM/IMJCcEp10hAgs94BoRkoXvOzL8xGsI4BJEaU7lLqRpUF7T9rftI0iBBPprnn4zPtPsFMS3JBmRZlpVlp8ym99ZUSDJLRFjKrEu/vGRjns0nL8gOOySf6zByx+Ul0YNDPLDKDzIAYa3RJrK677jo3205swGxbFilZKiVuKBIFyjVoVLKCIIEvgioWf4K6aMpPKN9gtD3aiaQZNdvMtBFY09DQiRJE0JjyeSStTCmEc8k5pYadRb1ZwO52jKJx7JQeMYMcLT1g7QYL3kmY0oTOj4XelGFQ785x+9IqZtp8u0c9P2s0wSJifk/SkIZkyZfWhDbr8etyeA8/J3FgLSMDR6HZmKTx7VWovNZvasF7+N6XZzLjxHotcM/wGbExCJUGSVuvWRqMtLNuqWPHjm59FwkkyaI/1tDmH0lDwMzMyS233JLaGcI41uTSZ1PCxgxy6DweeeSRbmCUWdS0oMSOtp1jYp1ifFc/X37O50Ibz0AZNthgA9dP9urVy20Ik0V6zlIpsYiXqdusjLx4PmgkmIpixBk+iMoKAkXWcdx999122mmnualsRp/4HEI1z0nCDmc0oARArMnzDWXacT4JfhgI4bwSGBIUM5pI50EwyCYny1obnq+YOSHoJ/g7//zzXWDMuiy/NtHPMETvca4NEiZ2U8rHNStLy9+zoYEOnzD69zADyWxMWh4V4RPE0JoEv57Hv8f/SuIQdeCBB7pf0zDTFsJueZx37v1bb73VlSKx6xqJU/QaSSoGgNmsgkCYjWuygllREiHKzB599FFXYte4cePCnzOIRLvnKw7SgqoJ1qdRHcXgN20Z/Zvn2zp2/4v2/0ceeaRLLvNtu/yVSTNLpUCZATMrBJDRxXB0MgQMdKBcZPm6jex/wUgauwHFF0/6rYOzNiVL8MgMA+UZ7LzEtDYbQxBMR7ffTBo6fXYD5FeSQJ4flVXMuNx0000uUGIkjvu8efPmheV3fqtk7gFeo0QnDZtfECBwDXB8bJWM0HXAzDrtHglG0u9/X37ny/GieI0yKxIF2kFmVNgljrbQt4ck0ySXrO/is1jSAvt84svvfDleFK8xy+CTZr9+MV525n+fhK3klxU73jE4yHoNAsjff/+9cGOHJJfksqyAZ8UxQ0jClFVc6zw+gLIzPhPwzC0ep8CabH+N+0SC/p7EIbTNeJKw3m6HHXZwz4tr3769e83HMP6RIV65cuVcNQ0xT1YpWSoFEiQ6RLadDG09yWwDDc4xxxxjaUO9KjsCETxFn7Pgp+vT3EkuDkmSX8PEZ8TahuhCySQhGaDBZM0Vo4tJCvhWhGgJGs+RITBmZC2O0WW+KE2gPDPp/GwCZWeMpHOPh3YW4zWSw3zdPnppcA+TCMRnzkFpmS9FJUjgemCgJFSOyewkD/bMx23ES8J9TuDHCHsc6zCjz6qhD2Cr7XjJtf99mp65F0LQTCmu5x/ezBqOJCIRYFCMUnK2gs/XXR1XFtqz6GdAgkR5Hl9xnTt3duX3lC0mHW19dFadATMwGBzvGyZMmJCZTZ9Csn2HlBLZNiOKcXSMBFYkSWm9iNgmndILSnWYuvZ4aBmjy/GtRrOGdR4scmb0OfRci3znn+hO48/i/uj2yWlHghsfKSdxpFab80kZBvc2O8JFETgz88ROSZRuJG1GkeQvPmNEMMgIOjMJfraFHeLY0IFg2q/RYXCEkqutt946NWWahx9+uD355JPuHmCtHjhu2jv/vDUSC5KF0HoPPjd2SQ1tEpHvKCtnjSKDAr7MlCSRWVW/2Qe4znkOD4+Q4Lr3594nh2lcr1QSzjN9IrNNSZxZos/muVtc6zxjJ+nl46XFNUu7Ht8CnG3yacOjAyYkkHEkErSJPHutNNvT5wvadtrt+IAG9zlb4kfvc/o62joGT0kK/YDYE0884eK9+C6xWbJSkiVKIrm2fLvSpw9PTS/4/rzzmKWwvEbZCdOVcX6bxdDP0oLpaepUSZaYiqWhZTc8Gg4ezpf0qegoFvKz4NE/d4HGxJeoECBQZkkjSkBNIE0jxLS9D6qSOCPDOWQXIL9FfHztgR9BpXNgYw/4AME/LZxZxyRuBkHCw/lmFzgGO5hZo+yOkirOJ2VVjKjzFeWPn2uAGvCk8eWW3Md0oNzDbA1NwMwMmu8gqeMngGCdBp0kQRXXO50mZSpJQD0+164/Z9zjtGk477zz3OwZQQEDBpxLypKYQerSpYt7cC+7voFrgYc4xpEs0E6EfraqsZMVQZKf/WERv68OoKScfu3UU091/RiPhWDdCuv1uD7YzKZVq1ZFSvZ4Lw9jpmSHoIq+gASSxCGfnjfEoBVttR8IobzKP1yTreA5Ru53v0aFciT4B3DzeflyLJ8Q0wfyOuVJrNPiGsnHB1Mz081giC8VZsMaX2LK+SNh4Dxzz/OwaQYF4olDdBt9dn70M4/0d3zfrVs393tKk/NpoxPOJ22ULyHm/vXf01exWyNtPrNqtAfMlpAk7b777q7viz4mILQGzz8uhlnX+MYI+dzGURVFYsw9z33KvUGSxCAv7R8Pm/ZIJmn7qDDh+ZEk1VTO3H333W5Dr/iD2rNkpSRLPET7jz/+//uXXy74wgkn5H+ylHWUGZFA0KgQPPM9wcWAAQMsTej4o6WGdJB+QSOBFI0MHSuLYn3jS6kKDXB0K/EkIUD2z5gIPWfCJ0vMprAYNsr/nlr+JCZLdPacS54XRmfD+SUxYrOD6GLftCF4/Pjjj11ASKdPB0mQxAxL9Dwy+8QW6tzrBNQkSSSIlO/4GZh8x2wIsyQez4ziCzwviGCBY+GzYNEzW2Mzu8Yi/q5duwZ3yUsKkp7oWizuV3/PkgiTLDGbxFbwPGCXzT0oR2LDGgYL4juEsQsW1wRJGJ8NCQgB+Omnn275hMQ1OnBFv8UXOM8kS/z8+OOPL/Ln/O953lg0WWLwhBk4Am8SEZ4/RTl+Pg4UksD5QBkkAD4J4P6GD6rZPjuOhf3RZIk/G32WGJ8NX9ENYvJpralPiv0gth/IZkCD80V/Tp/N61zrvMaAEINkfpA0aZbUxpEQcu8Sr9HXkRjyGknzlVdeWezZSay/5t5nQxMeTst1f+aZZ7rrhQHzrCqTS9gG8nTu1atXL8yok9yZLS0a6g4dOrjvufjTsKi8NOjcKJMBN3sa1kqUFkE8DR5o2NKwVW1p+TUiILjPSrkInbYvd8hyG8f5T+OmOSEM0vhF1Vm61uPXOztSZmn9DDO8zO6DNVFJ3zCltKjY8AOMWYpl4vFMltq4mZHYPYnHnY6icxERERERkeVMyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERJQsiYiIiIiIlE55S5JFi8zGj7d1/v1t5enTrdK8eZYJixZZuXHjbKt/f1t78mSbX7265cqUsTQrk8vZGlOmFB539b//trI1apiVzcCk6KJFttqoUYXHXmP8eFu4+urZOPZczqpMnFh47JVHjrTytWql/9gXLbKqf/5ZeNxrjh5tubXWSv9xB9o4Gz7cbIMN0n/sixZZ2V9+yd61Hrje158+3eZUqZL6fs33bevMmFF47OV//dXK1qmT/vO+aJFVHDEic7FMKJ7JTBuHmTMLY3fieKtSJVHHXSaXy+UsKfiA6URERERERCR5xo0zq1nTkiI5aZ2IiIiIiMhKpGRJREREREQkQMmSiIiIiIhI4jd4CHnnKrO1qlvqjRhrdsyd2Tv2rB43dOzZO+8650U/D53zdNP1XvTz0PWeblm93ifPMDvwBkuy5CdLXGQ1VrPU42LL4rFn9bihY8/eedc5L0rnPN10vRel6z3dsny9J5zK8ERERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiElDeVqDPPzd78kmzAQPMRo40q1HDrFEjsxtvNNtyS0uUX0aOs6vu6mMff/GbTZo60zZab2077pBdrGO7/a1qlYqWFjNmzrEuj/SzId+OtM+GjrTJU2dZj9tOtJMP373Ye3/8dbRddFNv+/jL36xihXJ2UJMGdmfnw61mjdUsST4fOtKefHmIDRj8s438Z6LVWLOaNdp+U7vx4kNsy01rF77vkec+tp6vfWbDfx9rU6bNtvVqr2FNdtvCrjnvINtkgxqWRKU99pM7PWVPvjy42J/fqm5tG/7eNZZE3/88yq6950378vs/bcz4ae4+rrd5Hbuk3f52yH7bFnnvC29+aXc+3t+d+3LlylqDLepYpzOa2UFNG1oa3HT/23blnX2s/hZ1bNjbVxX52Sdf/WadbnvVvvr+T1u9ehU7quWOdnOHVla9WmXLWls2etxUu+buN6zvoOHumlmv1hp26P7b2hXnHGg11qpuSTv2z74daU/0/tS9b+hP/9iCBYss9+v9Jf69j70wyO54rJ+N+GuibVhnLTu/bRM776SmlqTjXrRokT31yhB7+d1v7Osf/rJJU2fZphvUsGMO3tn155UrVSh87+w586z9tc+7v++v0ZNt4aKcbbbROnbqEbvbOcc3tgoVyllajx1lNj8n+P+6peOhdtlZB1jSrvel6cOnTp/t2sVX3vvW/h4zxWrVWM3232Mru+b8g1z8l7Q2zps/f6Ftd/BN9uNvY6zLZW2sY7tmRX7ONXLHo/3sgV4fufZuy01r2eVnHWDHHrKLZdkKTZZuu81s0CCzI48023ZbszFjzLp3N9txR7PBg80aNLBE+GvUJNv1sNtsjdWqWPsTG9vaa1azT7/+3XWaXw7701576CxLiwmTZ9r13d9yjcF2W69vA4f8Enzf36Mn2z7H3uU+EwKnGTPnuk70u59H2We9O1nFiiv00lqubnuorw366jc7ssWOtu1W69uYCdOs+9Mf2I6H3mqDX7rEGmy5nnsfncumG65jrfbb1tZao6qN+HuiPfL8IHvj/WH27Rudbb3aa1rSlPbYUalieXv05uOL/HnOf1L9MWqSTZ8519q2aeSC3llz5lnvd7+xVmc+aA/deJydccxe7n33PjXAzr/+RTuoaQO79fBGNmfuAnvi5cF28OkPWO/7TrfDDtjBkox7+eYH3rVqVSsV+9k3P/xl+514j22z2boueSBooCNl8Ojtx9tbltoyApPdj+xiM2fNs3OO38clC98O/9u69/zADTZ8+dplVrZs2UQd+1sDh9mjL37i7v26G65jP48YV+Lf+dCzH9lZVz1rhx+wg118yn720Re/uvti1uz5dumZzS0pxz1r9jw75dKn3aDQWcftbbXWXs0+/WaE68/7fzLc3u95oZUpU8a9d/ac+fb9L6OtZZP6tsn6Naxs2TL2yVe/u8SaALXXXadavljex+4123NrO6nNbkVe26HehpZPSnu9l7YPJ2Fo1vYe++HXMXbO8XvblpvUtl//GG/3P/OhvfvRj/bju1fbatUrJ+a4o+59aqD9OXpyiT+/ouvrdutD79npR+9puzTc2F7rP9SOu6iHuy5IqrNqhUa0F19s1quXWcXIxMvRR5s1bGh2661mPXtaIjz96mduFOLj5zpY/X+DRwKpRYtybpSGbJ4bLw3q1FzdRn96i61bcw374rs/bJc2twXfd/MD79jM2XNdgOBHWXbdbhPXwBBI+kAzCS4+bV/rddcpRRK8ow/ayRq2vNFuffBd63nnKe61+68/ttifbd1sO9u59a3uOsinkbblfewoX76cndC6aKeZZC2bNHBfUe1PbGI7tb7VzSL9P1n6wHbZdmPr8/DZhYEEI8vr79XZzcolPVnqeOvLLnhauHCRTZg8o8jPOnd93bVtA5+50Fb/NzEmaDz9imfsvY9+sOZ717OstGWv9//O/vhnkr3xyNlFZhTXXqOaC1i+/fEf26H+hok69rOP38clOlUqV3QzKCUlS8ywXHHn627A4KX7Tnevnf5vH3jDfW+7zygf+sDSHHfFCuVt0AsdbI8dNyt8jWPhui5IGn6y/ffc2r3OwOjg3p2K/PmzjtvHJdYMKjGAwP8rHyzvY/eoMMj3dr+013tp+/DB34ywz4f+Yd2vOdrOPbFxkUqKUy972vp9MtzaNN/eknLc3riJ011bdekZzezqbm8U+/k/Y6ZY18f727knNLbu1x7tXmt39J7W+Li77JJbX3aDqlRWZNEKPeo99iiaKGGLLczq1zf78UdLjGkz5rhfa6+zepHX69Rcw400UbaRFpUqVShV488I/MFNGxaZjqaRZcr2hbe+tCSh44jPhG2xSS1XksRU9eJssn7B8ZNMJ9HSHjsB9bTpyTzW0qAj2HDdNYucT+5/SjCiI64kDtWrVrIqlYuWrSTNh5/9Yi+987V1u/KIYj/jPPcd9KOdcOguhYkSGGWuXq2SvfDWV5altmzajNnhfqBWwe/z6Voo7bFzLCRKS8LM2cTJM92MWhRB1cxZc+3NAd9ZUo6b9i6aLHhtmm/nfv3xt9FL/P+QXORbu78ij51kec7c+ZavSnu9l7YPnzbdx3yrFUtOUCVWrpiU476sy6su4Tvh0F2DP3+t37euTC96n9PvnX3c3q6qgIqqrFrpKWIuZzZ2rNk661hiUNOK0y7v6cpSKMt7/s0v7IFeH9r5JzUNlq+kGaMPjFDs3HCjYj/bddtN7Osf/raky+VyNnbCdFsnsA5h4uQZ7vgZyaGkAfvtsZWlRUnHTgnH6ttfbGvs0MHW3qmjnXvNc640KekI9iZMmmG//THe7nq8v7394Q9Fzif3/zsf/uDK8Ub+PdGG/zbGHTs17Re0zZ/1GkuLxPe861+wdkftYQ23Wr/YzylDYw3Lzg02LhZwbb/NBq6kJUtt2T67bOEGxy644UUb/PUIV75HGdtN97/jRqe33mxdSyt/rnduWPRa2KnBRu4zSUObzxo0hNr8efMWuDaCvv+V975xZZobr7+2bb5xTUuDxR07s6vVGl5kVepfYPUOuN56vf65Jd2S+nCuc+K6q7r1sfc//cm1Ex8M+dk63f6KqzKIz74lAesTWXfc7YojipVaetzHHPc2m69brC1EGtr8ZbXSF5Y884zZP/+YXX+9JcaBjevbDRcd4so1Xu8/tPB1FvXeeHEry5rR46cWzqzFMco6acpMmzt3vhv1SKpnXvvM/hk7xa6/8OBiP1t/z842d94C932NtarZPVcfac322sbSInTsjKh1Or2Z7Vh/Q1uUy7nkgfrtb4f/40q0KNFLqg639LaHnv3YfU/gd1jz7V35hXfP1Ue58jTWZ/Dlg4r+T11gu+9Y15LqwV4fubKyfk+eH/w5i3tRp1bgPq+5hluzkqW2rN4WdezhG49zZYusXfLaHtao2Fq+tBk9bpqbdWWGNZ44synMqH+vlSS7/ZG+tnr1ytaicf1iP3v5vW/s2AsfL/w9yfXjt56Y6HavNMe+x4513YYum26wjo0aN8Xu6/mhHX9xDzdQRAlnUi2pD19n7er2/N2n2ulX9LL9Try78PUD9q5nL3Vvl7jzzgAoA2OU2NNnMehXUntYO1ZFEe0DRo1N/n2eiGRp+HCzc8812313s7ZtLVGYqmVk8fADtnc315sDhrlF0euus7q1P6mJZQmLXv2C/zi/m87sBCdLbubg2udt9x02dYFQ3NuPnWtz5i2wH38d43bWYcF3WpR07Ldc0rrI+1joueUmtdw6Bsq4krzw88KT97UjDtzRBQOUli1ctMjmzS/oSFG1cgXbatPatsG6a9nBTRu4TSHu6tHfDjv3Yfvo2Ytt801qWRJHVq+++w276twWJe5eufj7vHzhz7PUlq1fe003ysqCf2YWPvr8N7vnqQG2zlrV7I7LD7e0ogyrpHJzPid+nmQ33/+O9Rs03O6/7hhbc/Xia6+aNtrS+j55vk2ZNsv6f/qTffvj36lp9xd37INe6Fjk96cesYdb09m562t28uGNSlXCmY9K04fXXHs126HeBtb+hMauLP2bH/92SSUzUS92L1i3lxRP9B5s3/30j710b7sltocltfe+LcyqlZYssRPeQQeZrbGG2UsvsTbAEuO5N76wM67sZT/3vdY2qLOWe41F3YywX9rlVTv2kJ3zatvYFc3X5vuRmShf15wvNb1La8z4qXZQu/vdAt6Xup8eXMzYdPeC6XpG4dg2uEHLG936laQnzaU59qiLTt3XlSnQ0SY5WaJ8ypdQndSmkTVve48dcsYDNqR3JzfCduR5j1r5cmWtzyP/30aX877F/te6ZPH5exbfAeWjK+/qY2uvUdXOW8w1u/j7fEFerdFZGW3ZoC9/s4PPeMDtEunL0Vo3296NyF9371sukGT2KY0IiufNXxj8GZ9TUoNmUFLP/XDakXuUOFvC2i6/Vu2IFju6BKPZyffYL/2uzZsNHlbUscdnEtkRmF0R2Ql4r503tyRaUh/++58TrOkJ3eypLm3t8AMLNvA5tNl2bntxHqPx9gffB2cg8xFrTy+/4zW7pF0z23AJW57THpbU3ic5rkvMmqWpU81atDCbMsXsnXfM1vv/bsSJQLkRW2X6RMlj+0nWcaShXntp+JIVX8ISL9dgB6EkzipRWtDi1PtsyvTZ9s7j7Uu1FfhmG9d0o0/PJLyOe1mOnQCJEhyeO5YmBEPshMTOYHSalBxyr0dxje+102Y26MvkLXhl2++Hn/vYPSOH8ilKMvgi6J2/YKH7nvIzX3rhy/GiuPfZbj1LbRlbZ7PgO75uh2uDMhe2lE4rShJZ48Y6j/hanolTZib2Wuj78Y92Usen7KAm9e3BG4rvlFaSI1rs4LaYf63f/8vys3LsbJmPSVNmWRqE+vAnXv7UtYdUEkT5foCBk6RgfR2VEpTg+bb+7zEFW4ezkzO/5z727SGPD6E9ixr9bx/Ac6myaoXPLM2ZY3bIIWY//2zWr59ZvfzdabZEYydMs7UCU/PsGoIFC8Ijbmm1/rprWs21q9sX3/1Z7Gc8GI3F30lDw8hsws8jx7k1HEszQszUdWg0Ju3HPn3GHPecB8oV0sSXFJFAEiCC0rw4EosF//48SViszJbP0TVYUZs2ucouOLmpXXfBwVa+fFn7YtgfdtRBOxX+nI6VkpSjWuxoWWrL2PRk4cKiQYS/DrBgYXr7Af85sCA+ut0+1wbXUhLb/CHfjLA25zzs1h+9cO/SrUPx5Zu0EUn0X46dASRw36RFvA/nXidf4CHEwXt9QXLa/T9HTXZJUf0WNxT7GUtJ+Pr69ctt+3obuvv40RcGufLEaBww5NuR7tftt8mPRyOkbmaJvoPnKn36qdmLLxasVUoi1mYwe/TziLFFXn/2jS/cgvBtty6+k1TaMTX9xoDv3O5AHg+1YzT+yBbJeu4MAfHR5z/mtsV88d52wUX7JMQ0OKEdZtg1LLSbVlqOnWSKxCjuhvveciNQB+6TwBGQf585ERoA4XkblCPU23xdt9sV9/jzb35ZZLSNndDY4IARyaThQcOvPHBGsS/q8tk+m+8py6Ecc/89traer31e5Pw//eoQN6rOMzey1JaxlTgDZwMH/1zkzz/b54u8fFDn8rTv7lu5WbYHnvmwyOsPPPORVa1S0T1/KUl+/HW0HXT6/W4t8huPnFNiGSE74MVH2UFAifgsY5qOfXygfaQd6PYEa/Squ50Qk2Rp+nBiPs57/DEoz/YpmH3aoX5y2v3zT2pSrK3noetg3Rm/50G9oCSxQoVyrprK43N48NmP3HpNNvzIqhU6s9Shg9nrrxfMLE2aVPwhtCecYIlwyenN3HbCex9zp6vXpfTojQHDXN1qu6P2LFXJUpJ0f2qgK8caNXaK+32f979ze+yDNQ4EUZ3POsBefPsra3rC3XbByU1c8NTl0X7WcKv17JTDd0/cbmjscnjIvg1d+VHPV4cU+TkP5Jsxa65tuPcVdnTLHa3+FutZtaoV7bufRlmP3p+6z+Oq9i0tiUpz7Gwru0Orm+3Yg3cuXNvz7kc/2FsDv3eJEg1sEp15ZS/3DKV9dtncdQSUHzzz+mc2/Lex1vXyw616tcrui7UoBEfsisROedNnznGdCaORlyfwQcTs9MRam7huPQa4X6M/u+niVrbHUXe4hxKeccyerh3o+lh/a77XNm6X0Cy1ZTywuEfvwXbImQ/YeSc2cRs8fPDZLy5Zarbn1rbb9pta0o79j38muoeu+1kj3Hjf2+7Xjddb205sU/AwUgLqGy482G3+cmT7R9yuYAwWsDiea4REKinHXbZMGTvglO4ucGYdR/wZUZttVLNw0IjjI1Bsvf92VnejdVyyQNvXd9Bw12aSROaT5Xns9/X8wF7tV9A3bFRnLRs9fpo9/tInbqbi6TvaFns+X74fO0F/aftwkgjK18688lm3XTbv/+r7P+3RFz5xg0ptAu1nvh73jg02cl9Rfjc8jiXa3rPU5MKTm1qXR/q5WbRdGm5sr/b71j76/Fd75s5TMvtAWpTJhYZNlpMmTcw++KDkny/1/3n8eLNasZ2nhtxmVsJuTssTow/X3vOmu3Go0d50gxrWtk0j63RGs5WzjeSvo80OvGGlHPsmja90WwqHjBh4g1vkiO9/HmUX39zbPv7yN7dT0kFNGljXzocXe2hjvh93k+PuckFPSXK/3u9Kj3jGAg9npKFhVxjq9Bl5v/LcFoWfyXKVJ8fODlDnXfeCe6o5a1yYjWLG5fhWu1jHds3cSFQSj52NWx578RPXYU6cMsNWq1bZjZYSCLeKJICMSLLNNu/99c/x7jU6EXaS8wuFk3ifh64Ftkgf9vZVRV7/+Itf7dLbX7Wvvv/LVqtWyY5quZPd0vFQW6165bw/9uXdlv30+1i78s7XXVkKyTVtADNslCwyw5JP57w0x84sGQvZQxrvuoUN7HVRkdceee5j6/p4fxvx10S3doXBQ0o2S3puSz6ec19qWhJ2AX3i9pMKE8jbH+7rzjezivT1W21ayz3Uk0D0P/X9eX7srGnq8khfN+tCzFOtSkW3E+SlZzb/b0niKrreuVeXpg+nXPnqbn1swJCf7Z8xU90uyKxhurnDoW7AKWltXBTHz3XQ5bI2rg+PWrRokd320Hv20HMfu3WbW2xS0w0KHl/Cg2xLhVnK3S4t+tq4cWY1k/OcshWaLC13qzBZWuVWYRC1SmX1uKFjz9551zkv+nnonKebrvein4eu93TL6vU+MfnJUnbn1ERERERERBZDyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiASUt6SbPMMyYcrMbB57Vo8bOvbsnXed86J0ztNN13tRut7TLavX++TkH2OZXC6Xs6QYP95ytWrZLMsmTpQ/9qqcPMuGrB43dOzZO+865wV0zrNB13sBXe/ZkOXr3aLHPW6cWc2alhSJm1niIqu+qv8RIiIiIiKyVJhnqmbJojVLIiIiIiIiaZhZiho6dKhVrcqEXjZMmDDBGjVq5L7v2bOnVa5c2bJgypQp1q5dO/f92LFjrVq1pI1JLLtx48ZZ3bp13fd9+/a1KlWqWFZMmjTJWrVq5b5v0aKFlStXzrJg7ty57lxnvY3r1KmTVaxY0bJgxowZ1q1bt8xd6/HrvWvXrlapUiXLimnTplnnzp3d923btrUKFSpYFsyaNct69eqVuVgmHs9kqY2bN2+e3X777ZZUyUqWatQwGzHCbNNN3W8JIrIUSESPlcYlKw1M9DhJlLKULEWPlUQpS8lS9FgJHsuXT1ZztawWLFhQ+H2W2ziCiKwEEtHjzNK1Hr/eSZSylCxFj5VEKSvJUvQ4sxTLIHqsWWrjiiCOJ55PkGSV4ZUtm6gFYSIiIiIi8i/ieOL5BEnWv1ZERERERGQlUbIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCSgvK1g339vdu21Zl9+aTZmjFnVqmb16pldconZIYdYYsycOdPuv/9++/rrr+2bb76xKVOm2F133WVHH320pdkff/xhvXr1sl9//dUdc6VKlWzDDTe0ww47zHbbbTdLixkzZliXLl1syJAh9tlnn9nkyZOtR48edvLJJxd776JFi+yhhx5yXz/99JNVrVrVtttuO3c98GvSzJo1y5566ikbNmyYff/99zZt2jS75pprrFWrVsXe+95779kzzzxjI0eOtHLlytlmm21mJ510ku29996WNFzHxxxzjNWtW9fWWmstmzt3rv3111/26quv2hdffFH4vi222MKaNm1qW265pW288cZWvnx5a9OmjSUV12zXrl1t6NChNm7cOKtSpYo7trPPPtuaN29e+D7Oc+/evd29zzVRu3Zt23333a1Dhw7us8t3nM9BgwbZ33//bf/884/Nnj3bnbcddtih2HvHjx9vb7/9tv3555/uuubzOPDAA61atWpF3vfBBx+4v48v+oQmTZrYvvvua/mmcuXK1rp1a3ft8rXaaqvZPffcYwMGDCj23g022MBOOeUU22abbWzBggX25ZdfuraPc+5xf7Rt29Y233xzW3vttV0bOGrUKPeZhf7OVWXOnDn27rvv2ogRI9wXbRtt+J577lnkffzsk08+sd9//91dGwsXLrRHHnmkxL+Xz+K1115z9wx9xRprrGFbb711sH9YVeib999/f9tkk03cF9cu7frgwYOLvI82jPuY96y//vruej/nnHNKvI5atGjh+rU111zTpk+f7tqPN9980/WR+YD7+uWXX3b/rp9//tmdnwsvvNB9FlHvvPOODRw40N27vKdGjRrWsGFDO/bYY13bFvXWW2/Zt99+6/4+2ob99tvPLrroIktqG0d/xvFMmDDB3SO0B5tuuqlrv7i3vfnz57tzy983depUy+Vy7uc77rij7brrru5ayaoVniz98YfZ9OlmbduarbcegZlZ795mxGEPPWR2xhmWCJMmTXLBMI1LvXr1XEObBQRT3IA0FnSS3Jwc+w033GDt27d3AUUa0Ihcf/31ttFGG7mOgUa1JKeeeqoLJEkS+AwImkii+aySiCSYQGHdddd1gRXBUshzzz3nEsq99trLzjvvPJs3b5716dPHdUy8no9B4+LUrFnTBQMEe3T8BBuNGjWyK664wg2M9O3b172PjoKOl4GDsWPHujYgyXywcOSRR7pzzv1NB0ngd/vtt9sJJ5zg3kfyzP1AAkVwSCLJdd+vXz/3xZ/NZwTK3Mf82wmGSPBDCAoee+wxdy1wnn0bx7k+44wzXHLs9e/f36pXr2516tRxSWS+IhhiII82ieMmKAwhYLzxxhvdZ8W55TM49NBDXUDdqVMnlzxh9dVXd+/99NNPXfBI0LT99tvb+eefb+utt577s/mA6/qNN95wfRUJPQF0yHfffWcfffSRSxTXWWcdd64X1/ffdttt7vvGjRu7pIE2s6TraVUhOTrooINs4sSJLnAm4Q9p0KCB7bHHHu499HvxRMErU6aMO7/c53xWfEa0mfvss49LrOkvuVdWNRLZZ5991v3bSAA4tyEkxhwrQT/3MMdDYs3g6L333uuub++ll15y7SKfIec/6W3c6NGjXdJDgs/gGP0d/Tz3B4ky97dPlmgziAN4P9cAA0jvvPOO6zfoM7JqhSdLLVsWfEW1b2+2005md96ZnGSpVq1abkaJX8nQGW3Jgl122cV9RR188MEuQGYEPi3JEsEPDQodA6Mw8WP2XnjhBXvyySfdSFaSZxeiCBboNPj1hx9+sBNPPDH4vueff97q169v3bp1c40omH3iXiBASVqy9NVXX7mv+IjiHXfc4Y7LJ0t0FK+88opLDk8//fTEJ0sMfPAVxczCAQcc4GZLfbJ0yy23FPuz3O98vfjiiy5hzmckDJdccon7lcCQYwv58MMPXZBw1llnuUAYBNHc57T5O++8c+F7GV0miGCAxAfQ+YhgiHNKUM/sL9d0yOGHH+4SpI4dO7rAGb/88otdd911bjbV3wMMFFx11VVF/iyzSp07d3YBOsEqs02rGkEjx8qvBI433XRT8H2MqHMdV6xY0VVOLC5Zevrpp61s2bJuEIUgO1+RNFx22WXuVwY5+L6k650KAa75o446qsRkicSD2ScGyfgzHp8VA4UE3sRCqxqJMeeI+5Jrt6QZoNDsGTNsxDLvv/9+kUTg1ltvdckX/dwRRxxhSW/jDgmUcZHwPvjgg66NIwEGVTIMEEURC1WuXNlV3XDP8P/KolWyZomZPKo4pkyxxGDUmURJOH/lXGDNKF5acH5LM1J+5513upEpEiWCA4KmpCNg4HwuCcfqR5s8ggdGqvj80oBzStAYLb9i5oFEKe33NDME0dKrEJIILOl9+YAZodJ07AwQMILsEyWQYDDSzOxaVLRkJZ8xI0SitCQEiwwO+UQJlJoReMVL10IYhebej86+rUoVKlRwidKSMJJOu7ckDKBxDTCQQFtHguFn2/IN/67S3JeU0nEcS0KA7N8f5f8fpfk7VtY5X9b70sd08X6c16P9XNLbuBDf3lGWtzzfm1YrrYXjWpw9m8DD7PXXGZUyS/lyn1ThJmHKnWlfRhiYwk3iOpX/gk6CKXtGqBhRZeqehJEROEaiGKVLs5122smVITHSyEgU1wOzTXwG1H0nFcEegRMJEqNolN19/PHHlnbcy5SaEAwx0kw5YmidGmUoJJEE0AwWgFLMtNzTBEokiqHEkDULacWIPEFQqJyQEXru9zjuE+4XAmnKuZhNppQnrYMJP/74Y2FyxTq/4cOHu1kmSvGPP/74Ug0yJRWzifT7zEpwjzCjRBLBQCGzdnwWSb3nac8oJ2VGFElca7ysbT7HzgCgX2rAmt1Q4k3/zq+0+4MGDXJtBW1GVq20ZKlDh4I1Sihb1uyww8y6d19Z/3f5rx599FFXjgQ6C0YkWRCeJb/99ptb8EiywIgO6zsYxbz77rvdRgF0qGkpSwxhup/RatYn8QUaUKbyt912W0sqX4IGFnozGLC4xd5pQakV5Sv+nm7ZsmWwbImg2a9NYASX9Yqs3UgDP2oeGp1lJoFkkoAhX2ZOlic/Gh9aqM9rfCYcd3QmhRLsaJkuZVgMGqWVX4fKfUJJGiVKDB6wVpOBAzbCScusehwJ0uOPP27HHXecK1Xz2ASIeCAfyi6XBRuV+Fkx+uwzzzwzuOlLGlGi6u9nSu5o89m0JTRIQKm1t95667kkWRs8rATca5R+jhrFug+CErOUDkalEot+GU1m8Sij7jSU+TINv7L4skM+A3YY8rsBMhrP7BILpdOcLDGazMJvRheZVfSLwlnvwAL5JOyQFkLgw4J+Rs0oPSJxSGNwHNeuXTu33oQRYz4DEsXQPd2zZ0+XLDHbwO54nPe08McbOt/+Nd6TxuvBl6GFzrl/jfdEkyUW+jMTRZDJWi4GS9KaLETLjjhe1ujRNvhEkwEVKg3SXGHBYAIL+9kFkpJEZlubNWvmEmYSpqQOEjETyoY1zK5kqbSM9ajcz8yqUW5b0oww8QxJJZ8NG2OMGTMmtbPHebdmaeutzdjJ8aSTzN54g8CzYOvwXG5l/QvkvyAQZvcjFoYzmsZNxG44zLRkBWtzfEMS3TadEWhKFeg487WefXm49NJLXaNJZ8OuYSSJDz/8sDvm++67z5KKMgM6DjpOZlZIClnMnXbseEQ5JQub2WKYkWQ6yPg9TQJJuRUjsJxvdgVlxDkNWO+A0H3rX/PvSRsf/ISOz78WD5B8kMWAGRu9kGhfe+21pVr/k0T+uEgMfaLkf88oO9UGacWaPWaUGEhiAyDOOxvgUFlBqTKliElEFQTnj5kSNsGgFI/Boiyg5I71mbTp7JZJn0clRRwxDes22dCJ2GbLLbd0G97E169lySp7KC2zTJ9/bpbikvBU42ZjpJlAMyv8uobQ7kHMtjAam4YNH0IYXaTT9LvmeJQhkkTnw65IywvHSSIRWseSZpRYsTPS4gJASpHoQNkdMA18+V0oCGAmmQGSNM4qRcvvQovjeY3PZEmDP9wr7BqW1MB5SfxmEX5rZY/EiTWOaW3vQak9SXN8kxOSJhBMp2EXXBKIxT0qJK2opOD4S9N3169f3w2cJHWd2vKwynoBNnsAGz5I8vg1DGnuLOIIntkxL5Qg8oBGZiTSuq2mf9ZEqE6dgIoSrrTwZUXxB5KmnS9HWdLoIe9LS0kGQTDnmfs3NECQ78+S+q/3NAu9Q2sWGCzgwa2lvVdY/5BGlB0jvrMgbR7JdFrbe/hji+8K59etRGfakoy2LGtLCjyOuzR994J/B02yVLIYt8Kv9tBzOrkun3qKsiazlA5IpUZo+1luHJ5LQEfJ8xyyhKlrap3980fAtrs83Z1SpbR0IKEyTI6NXdOiZVqU4fBA3q222sqSJrTFMIEAz2BhMIDznEbRbaKjnSYLekn4KbkoaetpzjWji2naPYpZEXa9I3HwmF1jbSI7vqUZD5mlJCn6QE4eYMuzxKIPXo/PrHiUZTOAwrqGNKJdI2mgVCkaUPPZcNxpnVHzm1vQ5sd3RfTPIGQwISlICEKPOmEnR3b2Cw0YpAXHzkY1cZw/znG0goLB79DSii//fVB90p8xmNczS2eeyVaNZlTv8DmPGWPGw76ZzevaldpISwzq9Nl20j/AjoCZRY849dRTS+xQkqx79+5uQTdBAx0qpRtMWXOjnXbaaYXreNJyrASIfpSZOmbfIbC4l+D68ssvdw+m5WGOF198sXuN3eDoSG+++WZLKrYAZ0aBNQl+IbffCYoEkbIc1ijxIGIe3kliSMPKk85JLNhRLmk4DkbE2d2JUXYWq7PLG4uYe/ToUTiKRpmR3/3Nl574BxXyebH4OUk6derkAgfW3TFzwjHwkGUW7rMekZkWEgeCaM45ASOfEzskcZ3QzkV3x8pnBLl+e3QfHPmkqFGjRi45pLSUa4BzzmuMNLNVLuW28V2yKFOkjfCBM9sr+xIeylGjz2pa1XhYNOfSb/dLkOuTItae0K5z/+6xxx5uh0MeLM3n0bp1axdA8pgAj+udh5CSLJNss6aBMi1moPhzrGXMFwzkcWz+PFM25ksOabe4lkmESRTBsYLjAJ8RxwbK0Dh2rg12P+X6oK3gs+HYWbuTT2in6JP9dUji67/3mxlwPfCswOjMmd+YiGNj7S3YxIi1qTwWgsEy+kUGR7le+J57IV/QV9Mf+QoIjsEPCrHmhgTg5JNPdptxcAxc55z3fv36uXuE3Wzj7YafWWXgiPeyVgu0m6xbTkobx7Gz7T0xHH0Z6/D8ICcD3gwOepTk8dw17nWuE/p2+oXffvvN9QOhbcazYoUnSzxL6bHHzB54gF3EmNplK1ozHn4eeKRHXiMojo6m0OHwBYLnNCZLNC4khRwnNyMNMaMwBMfRTQ7Ssq0mwY9HAMmX30WGxIgAisXN7ADHQneCJjpWdgxL8mg7W+P6xN8HHHyB7UUZXSVRZNaBWTQSSzCyyoYP+RY0lAYBMSPj/qnkdDh0Cmx28DkLKiPr0XimSpT/PfX8SUuWSIBY1MxxEkQS+BJUsamF30Kd+5wtgxlBf/PNN12QxbVPIE2ilJSdDznH0RkyHkDLF7hfCZq4rxnsevvtt11bx+wi1znXRXy90ldffVUYXIOAygdVBJ75lCxxrqIPUqed8kkA1ywJBUnDlVde6dpzdjgjMGQUmeQgul6J10isuV/o52j3aCvvuece93yufMLsN8cVPWd8+eCRZMlXA0T533Pu/ecEkgOuA64Pkkv+PAn2YYcdlneVBCQ30VlCkn2f8JNAcB/z8/jz1PzvmWH1yRLJB88PJNmgfWA3XF4jyeSzyqfSa9ZQ+sE90G75mdGmTZu6wL958+YucaZNYECE10guGQyMr0Pmz0YHC+gX/FpOnq2VT8nSkto4+jb6Z9opBoW4r3mNc8rxR9cs0oZRUfHdd9+5c831zfVy4IEHpi7eW1plcgnbzowTSOcOMt601kqH0MD759nQaPsnbKcdDQHJChgRz9JaEjoA35CTpKVpJm9JGCVkm1q/+UBaF9rHEdD4Z5pluY0jiE/rLmtxtGvMXGTtWo9f7wzCpHkr8jgqVTrwEMp/t/JP686LcSTq7K6WtVgmHs9kqY2bN2+ee7xKUuO4/BoWERERERERyRNKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkYDyljC5XK7w+wkTJljVqlUtKzheb/LkyValShXLgilTphR+P3bsWKtevbplxbhx4wq/nzhxYqau90mTJhV+P2fOHCtfPnHN1TKZO3du4ffjx4+3atWqWRbbuOnTp1ulSpUsC2bMmJHJaz1+vU+dOtUqV65sWTFt2rTC72fOnGkVK1a0LJg1a1YmY5l4PJOlNm7evHnBOD4pyuQS9q8meKxdu/aq/meIiIiIiMhSYNC7Vq1aliQqwxMREREREQlI3Fx/tAypU6dOmZm29qUa3bp1c9+3aNHCypUrZ1kp0+jbt6/7vmvXrpmZtvZlGp07d3bft23b1ipUqGBZQalGr1693Pc9e/bMTHkOZRrt2rWzrLdxQ4cOzUzZKeWHjRo1yty1Hr/eGXHOUtkplTJ169Z139PHZaUcjRLrVq1aZS6WicczWWrjZs2aZdtuu637PonHnLhkqUyZMoXfE0RkKZCIHiuNS1bq2hcsWFD4PYlSlpKl6LGSKGUpWYoeK8FjVgLI6HFmuY2jQ01ip7ososeZpWsd0WMlUcpSshQ9VhKlrCRL0ePMUiwTj2ey1MaVFMcnhcrwREREREREApQsiYiIiIiIBChZEhERERERUbIkIiIiIiJSOppZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgElLeV7KabzK680qx+fbNhwywxRowYYT169Aj+7PTTT7cNN9zQ0ui8886zfffdt8Sfn3baaTZp0iRLMs7tp59+asOHD7eJEyda9erVbdNNN7XWrVvbuuuuW+S9o0ePtueff95+/fVXK1eunG277bZ21FFH2WqrrWZJtPHGG9tuu+1mW265pdWoUcNmzpzpPo8+ffrYuHHj3HvKlCnj3rP99tu767xq1aruc/riiy+sX79+tmDBAkuiP/74w3r16uXO5ZQpU6xSpUru+A477DB3vN5dd91l/fv3L/bnN9hgA3vwwQctaTivAwYMsFGjRtmMGTOsQoUKVrNmTdtzzz1t6623Lnzf1VdfXeLfUbduXTv55JMtn3Et33///fb111/bN998484x5/Loo48u9t5ffvnFrrnmGvvss8+sYsWKtt9++9m1117r7gnvr7/+KnJdRPH/ob3IF7Nnz7aXX37ZfvrpJ/v555/deb7wwgtt//33L/ZejuuRRx6xH374wcqXL2+77LKLtWvXztZYY43C9zzzzDP27LPPlvj/u/32261evXq2qnGcXbp0sSFDhrhzOXnyZNdvR6/VRYsW2VNPPeU+H64N+i/a+2OOOcY6duxolStXLvb3PvbYY3bHHXe4tpE24vzzz3d9Yz6ZNWuWO65hw4bZ999/b9OmTXPXdKtWrYoc+xtvvOHuf66NqVOn2vrrr2/Nmze3E0880bWB3pgxY+z111+3jz/+2P78808rW7asbb755q7PL+k+WFU4Z9x/W2yxhfuiP77nnnvccUY1a9bMGjdu7I65WrVq7tzzedGnjx8/vsh7X3nlleD/6+mnn3bXTpLaOO7f3r17u76O66J27dq2++67W4cOHYrErnwOF110UYn/v+7du7v+MYtWarL0999mN99sVq2aJVajRo3cjRa19tprW1q99957NnTo0GKvn3XWWS7oSnqihHfeecd+++0322mnnVwATAdCI3vjjTfa5ZdfXni+OVaCgipVqlibNm1szpw57vP5+++/7YorrnCBRtLQeWy22Wb21Vdf2T///GOrr76660wuu+wyF3SQHBI8nnTSSfb777/bRx99ZNOnT3fBxcEHH+yC627dulkScf0SVBIYcw/PnTvXPvnkE7vhhhusffv2duCBBxa+l4SCACmKpDGJ6FA5VpJfgor58+e7QJnEkcBq5513du87/PDDi/1ZrpHBgwe7oCnfcb8SOHD/EshzbkNIGrmfufa57gk6SYJ//PFHe+utt9z1H0VQxjUT5T+zfEFARHJDEsy9+t133wXfN2HCBLv00ktd4Mg9TptGIDhy5Ei788473XWPPfbYw9Zbb71if57gnHuIADUfcDzXX3+9bbTRRrbddtvZwIEDi72H83vKKae4vpx+rFatWm6wjMSCQZH333/fDRB5Dz30kHsf98PFF1/s2kDaAv4ePrt8uq9Jehng43x8+eWXxd7D+b3uuuusYcOG7njWWmstd21wjCSX/OqP/YMPPrAnnnjCmjRp4tp6BsXefPNNO+ecc4olYasa7RgJAm061y7HF8K9MHbsWHesJBqce/pA7l+SBJLrKBKQ+DVEP5i0No6EkHuCpJhBEAZISKAY7OTLDwpzT9x7773F/vzDDz/s+oi99trLsmqlRncdO3IyzBYupFGzxI7E12daLCMYfeIraptttnEjOR9++KGlAY0ls4PRZIfRVUaW3377bTfKCr6fN2+eXXnllYUjzjS+NFY0Uvvss48lDYEBI68LuSn/RSfLMR5wwAGus6STZFQ12kkMGjTIzS4dcsghttVWWxW7RpKAc8xXFEEBI/CvvvpqkWSJWcSmTZtaGjCLyFcUI8UkCFzHPvAn2IxjZJ1gqqRgJJ8QCBHs8Ou3335rLVq0CL6P4IDAl0ETBktAIslMwwsvvGAnnHBCkff7QDOfkfwzAk4wzKxZSaPFHB+JMwMefE7g2uD+J3Hw9wDtHF9RjMSTnBCA+aRqVatTp44b4CH4Y+Y7fn+D5Jf2iwTQo/3fZJNNChMmPwNHIshA2EEHHWQvvfRS4XuZoWFQ5YwzznCfcT5YZ5117N1333W/EtgyUxTHeXr88ceL3NvMFPC5+YTJzxrRDpAcRY/viCOOsGOPPda1FfmULJHkkACTMDL4R38VQtAfxyxk165dXfsenzFiIIWkMelt3C233FLsNe5tvl588cXCWVLiW76iuAcuv/xyV3ng24gsWmlrloiraWsSOghdBJ1LNLjMmr333tt1FmlJlhglj88KMU3NSCodbzSJIFCKluYwmsN76ZiTiAQofi0TBPmAA/w8NJpG4ww62rQgKSLYoJwnjs+BoDqNKLFhZoWR55KQNBOE0ZlGS7TyFSVFpencCQgZMPGJEhj4oNSQMqQQrgMGTvIVQXFpgniSYxKK6OdEoshINTMoi0MQmcvl3MxDPp3zeOl0KFmKJkoes4tgRtGjwoBBIWZTos4991w3M8G1ky84LtquJV0XoUEQPxDEYIhH0hG/hvh/EDQzO8Px5wvaJhKlZeHL75hdDeGY82UwYFnbuBDf3jELvTh9+/Z1/WFWy+9W6swSsRiJKwP0CRiQXCzqWOkkCS6Y1mT0PV6Wl2YEkzSWzCTEa3zThCCARsSXnjByRfkZo49xiytzSSrKGqKJYgjBNUKJRZKQIDAAQgDMKCNJMQMCUfyctWn8ypo2ShVZB0FJZlLRjlGCxzGxXo969gYNGpT4fta+8FmFgq2k4hpndoS1h3E77LCDm3mNozyNWQVm2PhzlGLlU8JQWhw3AWaopJLZpSUNAFGeRJnf4q6ZJGGNDqIJB2tBQmWWlGwTA/Dz+MxjEpEQYs011yzVe6ksCa3tSlL/xvnjXNOuI7TcgCSS2RfeS+kaszBLGkTIZ5TtMdBNOTXtGJZUWsdsW+XKla1ly5aWZSslWWIN9B9/mPXrZ4lOEphFoBNhrQK1sYzKsfCTafk0ja4vDgEEQTLrG9KMoJlA4tBDD3W/Zx0TQiPqvMYoG4Fnvo5ALY1dd93VjSiyEHhxGI1nip7FxEn26KOPuhIs0Cmy8PXss88u/DmfBWVXjLTS0bC+ixFlRmEpb6BtSCKO2QfEBP60b5QblYRgghnYfFjIv7z4TUyYHY5jxJZBEpJJRnD5jEiSKXVh9oJF75QuESxTrhraPCGf+fUZoTW3XPMMDpXUprE5CmtDuC+i63uSjPWo9G3RUiaSae7v+Og9sw1UGFCmlQasPWNmhYHQxSFhYLaNaz2p7Z5v8/1aRAZFWevlKyU8ZhiJ8ZhF4x7humDNGvEf5Y5JRJJPe+bvcQZ9aNMW10YwKHLAAQe4QcIsW+HJEgMWbKp01VVmNWtaYjGLxJfHwnbWLrETCdOULI7NAkbc6UBLWkiYBnSQJIMEx75cw5fchDZx8MFEGpIlgkYWylJ2x0L+ktB4snaNReQkTElGQszoGiOm7PxEQsS59OK7vvndlAgweP/iOpt8RlJIG0ZQzAJgjruk8mJmlJhZYuF4kmfT4nzZYXwTB/idwXgP31O2Et8RjmSBWSUWzSctWfJBU6jN8p8H7wn93C96T+KMWsjNN9/sFrrTn0dnV2jbQtcGGG1PetsH1jAxOMjmJovb1ZVjZRaVeyHfdgJcWiQJnFfuaUpuQ7NknTt3LvJ71rKxForBERLGfC7DLUnPnj3dPc06RnbHW1JZOYOCHOdhGS/BWylrltgmnIGrhN9bQYwskTQxwkygkXY0KMw6sKCQACuNmEFiwTcBITsgMdMA32GGtsn2gXXSEyVGVanNp1NkpI1SxJJGp9jYgUXSSS5J8Ng6lXUa7HDGAm+CY3bUKun4fYLFtREfjUwSSqgYEODYCQDoFNkhKXTcrFXi2g+VqyWZD5JCgY9PJhZXbsToLIML7KaZtFkGnwxGBwY8/3lEt5L2uD5Yr8TatfimD0nEdslsaMGW2NEZZdAPlBQU004kfeCA3VxJEGnPjjzyyBLfxyAKyQODaLfddptrO5KMwSEqBFiTSAJEKV5JmyN4tH/sjskMC+1mEjFzyKNgzjzzTLfZBZtTkSwvrgSPNm7fxTw+JitWaLL0yy/sPmLGjrv0IyNHFnwxmEf7zPdJ33maAJOGJImjDEuLXXLStAteHKMsd999t/v1ggsuKDLC6MvvfDleFK9RwpDkZInzyqJlOn+epRA6TjA4wCwqpXeLe+5KktGhMPJGXXdJCCIZhU3ToAGzTByzX78QL8HjGmHnwzTx5VWU2oRK9AgUQglDlF/XuKwLzFcVv3g/9PgHym+4vkNtGokzn00aZpV8VQjlp6FnplFeT//uyzU9+nvuk9B26klB5QDPUmNWPT6LEsdjNBgYY4dYBkzThLVqDHiXpkKAdX5IQ0ka669p80t6nhSPRGHGkR1iKyQ4tklEskSswYQLyRIDUP5ryBAWCxd8f/31lmh0KpRmlTRVnyZMVzPrwPaiacPoKkkCQRMlBvFOkMCC4IE6/Tj/oMKk4vplRJXA8YEHHihc6BxqXNkql7Ua1HyndTbVzygsbrcnEmpq3ZOwK1xp+RmG+I54JIRc46xVSuKzxBaHYJgKgdDibhbvl+YxEazfQXSXzCRgcTvXLxt7xFFyWdKsESV4fv1WkhEIsgMemzewhXro2mbWFfHNLvg97Z//edKwIREP4OWevvXWWxd7X7OtPDMwrNeJPk4hTYjfSvPcPL+2cUk7yCUFbX1Jx8LjM5hFVgneSkiW2CSHpDX+Rf/D8h++P+00S4RQ4ERQya5w7Cbky7XSihk0SnAYjUrbLBqdHgu1KTGg9K6kKfYdd9zRdTLRkVgWgZJgUZqWRAQ9lJ+wTTIJUHTr2CgWtFOix7FTthEq3Uma0EwApRbsgMZsAmsUudZDdd3PPfec60i4JpKmpG3RKa9lBDFeYsM1z7GmrQTPY1aBGYboTCKj6LQHjKp6oRk31jdSxuUfIZA0rMn8/PPPi+xsynXAZxHaJYv7g/JbjjfJz1yh3ea8MwDERjYlldNRfsTifgaRovg9wfXiNkTJV7TxVE4wIEgitLgyU9Zl8ryuU0891Y477jhLMmK00PbgrMOkpDQ6aOB3eo3ic6L8nKoLym6ToqRt1RkMYhfUknY3JVlibW7aZhKX1QodJmQHztati7/un7UU+lm+8iNPBFDccHQujC4RXLArWNpRmsTxp7EEj3PL2hMaDZLi+MYGPNUabJ3JttLUOLO+hRkIdsWhQVnSLkL5igXqHDcj61zX8YaRWUQSh/bt27vggKAy/kBS7oWSkqx8xkwiiRBbHzMr4Hf+ofyABJIAikT4/PPPd6Po/rkU1Lpz75Mg+2sjSfr06eNGFAkUCQqYOeL8U2LCxh3xsjN+xqxqaNv8fEc9PiOnvsyO69dviU8AyPEzk8xnwpoNzjvXBMEwG5iwHim6KJxZJJIIBg/YGYxAkvezxi3fcEy0Z35wh3vZlxER9HG/s1aD5IcyLB4ySuUA6xQ416F+jWufzzOfS/C4rwkO/RoyPgfuaXCuCZq5zrnfL7nkkmLPSmKwjM1PQBvAeadEmeuDP0cizUL5m266KbiT4KpE4s797JNf/q2+hJBrmWPnWHgP5YdsUBNFG+cHRRg0oiydmIdZRtbrxMvy82k2lTVHXNP+nPD8MP/v8/921uJyvXPv0gaSJJEQcw+zLXj07+L4GEjgnqGyhD6f2Vg+k9Da5Xxt4xjoYvaU+5syavpxBgu4Vmj/eAh7HEkU5bb0+2nZ7fK/SldNxQpEx0lAzS5wBMnclIyu0WnkU4OxohAs0gGFylWSjoYTnN/Qgn0fENMIU7pAckVAQfJI4kDAkdSaXp8A0EGGZg4IsKIdkH9wY9Snn36ayGSJnR3pWOhICR4IjJgl5knw/in2PoFkFI7dkJiFpHSLQIPyhCTOKJMckvQTCBAkkBxxTM2bN3dr0qIIFAg6mYFI4rGyDsUHyuBc+8CJgQKCBQY7uJ9Zj8GuaJTk+M0+ookjbSDJEduEM7rMn6VtYJQ+H2fdWIsQXWtD3+V3MeX5MVzbzCKy/T2zyhwXbRpBJkljSbvg8Z4lPZtlVWIwy5dGgnPLF/wzkXybzw5wcW3bti1MlsCMOp9F165dXTkaJdcsjOe85xuuz+jz8Uh4/LPC/HNyfFDNRkZxzKT6a5l1m6Ds+iq2M46hGiOfYp/WrVsXme3kHPrzyIYkJMfseEj7x+vc57xGQkmiFJ1dJVmgLWSHSwaK/A5yJOL59kzFJbVxzHgzK8i9z8AASSKv8XmRKIWWEPj7JdTfZ1WZ3OK2fMpDjJT5xXXsYJOFtULR8hmeBeEbtbStHygJN7d/Dg6N1ZIWXKcJI0YdOnRw37dr1y6xSdmyIJB/8skn3fcvvfRSoh+CuDQYlPBBXZbbOMpiSrOOIA2iD8bN0rUev945/6FSqbQimfXlm8zyJH13vdJittPPXGYplonHM1lq42bNmlX4AOwk3ufJGyoUERERERFZCZQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRgPKWMLlcrvD7GTNmWMWKFS0rOF5vzpw5Vr584k7fMpk7d27h91OnTrXKlStbVkybNq3w+5kzZ2bqep81a1bh95MnT7YqVapYFkyZMqXw++nTp1ulSpUsi23c+PHjrVq1apYFEyZMyOS1Hr/ex44da9WrV7esGDduXOH3EydOtKpVq1oWTJo0KZOxTDyeyVIbNyvSn0fj+KQok0vYv5rGpXbt2qv6nyEiIiIiIkuBQZFatWpZkqgMT0REREREJCBxc5/RaeqhQ4dmZtral2o0atTIfd+zZ8/MlKNRptGuXbvCEYmsTFv7mdS6deu67/v27Zup8hxKNVq1auW+b9GihZUrV86yUqbBuc56G9epU6fMlJ1SftitW7fMXevx671r166ZKjulzLpz587u+7Zt21qFChUsKyVZvXr1ylwsE49nstTGzZs3z26//Xb3fRL7tMQlS2XKlCn8ng88iR/6sooeK41LVhqY6HGSKGUpWYoeK4lSlpKl6LESPGalrn3BggWF32e5jSOIyEogET3OLF3r8eudRClLyVL0WEmUspIsRY8zS7EMoseapTaupDg+KVSGJyIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIqJkSUREREREpHQ0syQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkoLytYAMHmjVtGv7Zp5+aNWpkiTB06FC79dZb7YsvvrBcLmc77bSTXXnlldagQQNLi9mzZ9vLL79sP/30k/388882Y8YMu/DCC23//fcv8j5+3r9/f/fryJEjbeHChfbGG29YUn3++ef25JNP2oABA9zx1KhRwxo1amQ33nijbbnllsE/M3/+fNtuu+3sxx9/tC5duljHjh0tib7//nt37riuR40aZWussYY1bNjQzjnnHNt4442LvHfRokXWu3dvd4388ccfVrlyZdtiiy2sQ4cOJX5O+WzDDTe0Y445xurWrWtrrbWWzZ071/766y979dVX3ecR1aJFC2vZsqXVrl3bpk2bZoMGDbJevXq5P5MGd999t91222221VZbufvAGzhwoL3++uv29ddf2y+//GLrrbeeffbZZ5YEnBvO099//23//POPa9/atGljO+ywQ7H3jh8/3t5++237888/rVy5cu56PvDAA61atWpF3jdx4kTr27ev/f77767dq1Onju27777uGson3JutW7d29ydfq622mt1zzz1Fzi34WdOmTd3xcr+XL1/efUYhBxxwgG277bbuz9SsWdPef/99u/feey2fzJkzx959910bMWKE+5o1a5adfPLJtueeexZpxz799FN3TXO+Z86caeuss47tsssu7hgrVKhQ4t/PPXD77be77++88073ueaLSpUqub56k002cV9cu0899ZQNHjy48D1lypSx3XbbzbbffnvX/lWtWtVd07R3/fr1swULFhT7eznGgw8+2PUL/J20f/T9PXv2tKTFLu+8845r02gTeA99Pcd17LHHurY9avLkyS4uID7g7+fzOvLII22vvfayJLZxHu3W/fff79q85s2bFzueDz74wP19fHFvNGnSxLVxWbfCkyXv/PPNdtml6Gubb26JSZToeAgULr74YtfYchMdfvjh9uabb9rmSTmQJaARfPbZZ11HuOmmm9p3330XfB8N63vvveca5HXXXdfdpElGkEiDQ0NIMDBmzBjr3r277bjjjq6jCSXEBAl0tEnHdfzNN9+4ToUgiI7zhRdesOOPP96eeOKJItf2dddd5wJKOs6jjjrKNcx0TpMmTbIk4jonqCSApGMk2CBJvuKKK1xnQlCME0880Q477DD75JNPXGK5wQYbuMSJzvP666+3pCNJJpAmcIojcSRZ4h6IBxP5jkCZwIgBAP7tDISETJ061R577DF3LXAfEIBwrseOHWtnnHGGSyD8+x555BErW7asC74rVqzoAm4CUgJy2sN8QYB79NFH27hx49xxExCG0MZxzAx+cLzrr79+iX8n90CVKlVcwsDgQj4iAOYeXXvttd39SfsUN2/ePNe2keA2btzYfVYkv1znw4cPd4M/JBVx9Pv0j7QT+ThIQiJz0EEHuTacPjk0gMU1e9JJJ7nj/eijj2z69Omur6dN33rrra1bt25F3s955vMA758yZYq7n/LpWl+a2IXjpi3YddddrXr16u6aJ7lmAIg+neTJtx2dOnVyx9uqVSv3OXz88cduwJyBURKIJLVxUcQ0tGUlYSCcz4aBoF9//XU5/4uTa6UlS3vvbXbEEZZIzBzQkdKY0giDRImMnJvn0UcftTTg2J5++mnXMNAhXnTRRcH3ESgeccQRrtN44IEHEp8skQAzS0BH4hFoEGBwfuMjaAQgBMmXXnqpXX311ZZkJEU33XRTkdFURps4fgIKZtdAckwQwr2QllGmr776yn1FvfXWW3bHHXe4DpJkiXuB70moSCiiCQaB9M4771xsFippuJaZKWfEMZ74XnbZZe6cc30QZBFMJgVB8CWXXOJ+pY166KGHgu/78MMP3UzxWWedZWuuuaZ7jYTYDyRwjn2wyMxF+/bt3UwE+NwIshhEOPvssy1fkPyfcsopLtjbbLPN3DUdwkj7K6+84hKI008/fbHJEpUUjEaD9jIfETRyrPxK4EjbFkfyS9sdHQjaZ599XKBMH0+1QL169YLXCZ8r/T4BZb4hYeB+5deNNtrIfR/HzBGfD0mDx0AhCdYhhxziZpajCSYzLiSJDCgyy5D02IWKibjdd9/dzUIxU8qAKbifR48e7a4fKkh83EPiyMAKgyWLm4HMtzYuOpjAzBHXMMcbwmfH58j55rzLKlizNH06N6slzpAhQ2zvvfcuTJRAFs9NxtR1PjciS4ObvzQjhryHRCkt9thjjyKJEphlqV+/vus44+iE6FROOOEESzo6gnijT0fLqCtlLN4zzzzjPg8SJTpPZpXSiGObMGFCYfkV55ngilHFKP/7fCrJWBaMMjI7zqxhCDPH+RAULAvOW2nKpH744Qc3Cu8TJZBgEDwPGzas8DVmXxht9YkSaDe4RgisCDjzBUExidKSMMJMolQaPlHKZ1yrJEpLui5C1SC+dIlzGUcf/9prr7mBk9AMbL6ccxKlxWFAJJooed9++637les7GuMwo8ygEcfP58asapJjl5BatWq5X6NxHOXpXEc+UQLHThxIwhxtF5LQxnmcS9q16HHF5eus8aq20q78U04xW311aqkL1jAlaTCWzoSZpThKEvhZkkZbpXRYl8YUfTQwAtP1jDhTrhAq1UjLsTPD4INHRqPoPEiWKE+kdIUkgcCBGaekI/GnwyExYHSV0iRKb+FLsOIBpS/DIahOKgInZguOO+4422abbSyLCC4JkiixjmN2KRo4E4z66yHKJ5PMNkpy+USDEqRQOerqq6/u2r404th8W+9RlgdK9c4//3w3s87axnPPPbfIwHFSzzWDCcxC+dLDaALBTHN8ABV+kDiJ5WmsQWKmnPW3kodleFxvhx/OFKYZcecPP5hREUBZ3iefMJpjeY+A6Msvv3TBBYt/ffDkS3hY4yLpwkwK09rRNSkkEeedd54rUWNWsTT1wUlECQKlhpQl+UaWY6e2m2CRjpOAghrxzp07u++ZnUsqypVY2A3ucWaSWZsSDYAJHKKjib5Mx9e4JxFrbTi3zz//vGUVgSBCo7Nc18yg+iSJgRNml0iUozPrfu3ikkb1Jb9RksgAaHx9F/cIJXi0e/k6s/JfNWvWzF3rDIrFZ1wYTOG6Z7kBSRLlaHwWlKiRVCRR27ZtC//tJIpnnnlmkU0RGChhto1+0H8O8J9PPs0ilwb9NxUEzBRSOcLsmORZskQMFY2jWrUqWLu07bZml19OA2WJuLEovaJelZpXSnUYjeBGAnXskh7MFDJ6RkLEufdYw8PC0ZdeesnSitI71mmx0QWLfuFL7ijZ4TPwwQSjrMzE0IkmOVnq06ePW9BPIEAtOgGRn0GgZIUafha3M9vG+WfhOJ1rSaOPScCxsHaBWv0kJ3z/lQ+YQjNG/jXew/fslsa1wAYobIrAjBIzzT6hTmrgKOYCSUquWcMZL7NjUIggk5n1NGKgiJlljjNaXu0HBBgEYMMbAm4QaJ922mnufqDdTCLKjhnwZvdTNkiIx3Cs22XQkL6QtXxUWbBmkV0UUdrS1XzBRjTEq+z+KstmlQyTUC586KFm7GK6cKHlPRY2M5LCQli/jSIjLX6xYL7WMMvSY5aQHYWoVyYp8jOJdBiXX365W0xJsJxGrNW54IIL3Ig62+P6Y/edJou/o6OuXPcsjGa0LbTlbFIwg0jZHZ0mo6WU3LIjnsdnwSwis4oPP/ywm01jUTSJZVIHSjgmAoBTTz3VssyX0IWuX/+afw/rmmgbaPvZ2IayJLYp3m+//dzPk5o4Zx1bQ7MeidLi+C5n/Oy3334rXPifNmxQwoAX7RnJQJRPCKiq8YkSqKhhBj7ftstfGgwGsnEL22wzEE6iyKCZx4567HpHPECfT8LEz/kVoWUZ+Yo+irX1DAQuaT2f5MFueHHEm9yLrKn7t1w2r3FDUZbEyCLTtozE3HLLLYlftyD/x8wJ9bzUMtNxRNcxMApP50EJni+/ozzDj7TxGu9PasDk69KpWWemiC1YPf99qE6dxaAElYxI5tMzR/4LRksZCOF8MmvALAwJEoufSTBYx8I1wq5ISVynwmwZOzwyusq6PI/yMmZHGG0lYc7CQl9/zfpyvCjuBcqyorNOPKOGch2CKF5nnZsvx46vb5T8x+Yejz/+uBsECm3Yw4AZCQXnmsEkv12zb/dJGqIbgyQJpcUMBDPYRbIQ57eXjt8bJE7cG2kZJKZdJ/FjsIzE0SN55n5nUIxqIuI8vyX54naNzDckwlynzI768jtfMkwixWu0g6HZdfm/VfbpsCELyXlgLWXeolHk5vEIqLnR0vKcpSyj0aChZKSYUZj41rGsS6BRCZVi3Hzzze6LqW4e9pc0BMlsF+pHzOMjhiRLlGr5stMoAghmnuIP70wyP5MWPyaSJL/gn5p2kseStl/NZwT6dP5XXXWV+4qjjWvXrl0qniG1JAx8cZ5DSS+DISRDcQyIUPfvMfPA7FP0NUnGoAHlZTyMl7JaP5MexUAJpZahBzHfcMMNrh245pprLGl4ThKPPqBfY3CM9iDOr8WLJ4N8TgymRDeDSDoGQkNltNzX0edVsUECktTPk/QymMnmTHGsxeOLxx5Ed0KUVZAssdtoZJDaYZfK1183Y1OOpK6XZNqeG4fn7KR10WdWMOrCjBH1yJxX1irFMevCg4mjSB7oZHkg5aGHHuqm7pN47JQXUobGE+kpTwihhpvRR7aa5sGtIHlkNI5yhiTeA5QkxB/ORyBAKQ4JJDMsIeyCyFo2Emw2vUgatrpmVixUmkcARJKUbw+dXJEYGKEt51rwZSokQCziXtJaPAJK1rqwfiNJpTlZx6CHfwgp5bUlVQSEnstDaR5flLAmcfaVAQCOi0SQZLGktXbsFMcMBNc2m1/4slTaf9rJ0GM18r2vI2mI73ZItRCVIUva6ZBybdYx8XkkaWaJ8xXf7ZQdQHmmGLPkzDAm8TpOXbJ09NFssV2wyQObirAb3sMPs97B7NZbLREIEAkkuZm4qCi7YAeppk2buhHYNKEulxvJP5ySETVffsDMC6OwJAl+RN1vofncc8+5X9k5JmkPLWXjDhoOjo/jjj+ElvIMtpPmK8qX4zHbFE+kkuKuu+5yD6lj7REdIw9ljWLnI79jHM9o4KnmLIKmw+ndu7frQHlIZxJRVkspCWUofqt07nFGi3v06FG4HonFzIwwUo5BqQLP2uA5XKxZ8fdGkhAghraP9Q/Xjv6MMiW/PTzHT0mO32qXJIMkOp+xsyEBki8lIjDyCTJBBAmOX3fHOec1RpkpXeE5M9Edsii9pN0nuOD6px3kgcS8jw0f8g3nkfbal88S5PnNPLjPKSdj1tgHib6cnAeO++cq0TZ4DIr4JJr7gBkZ/16SB2am8wF9E8fmzzMDQb78iL6JgR2uYfo5rl9fWuXxmfjPInr+PT+IQllTvpUecy4pHfWzQZQX+u8Z2KKEjvaado/2PL7zH+fcP1+Ptp112gwM8eB2YgHiH+IeEik/y5KU2IVjZ2CT9ptZYO59+nAqSbhP4psfMNtCKR7XA+XK3DOcbzZ/SlIbRzl5/NEI/n7g2OKJFOeVts4n0dzXAwcOLJxRS2rZad4nS8SQzzxjdued1EkWzDIddpgZM9dJqV5jJIaRFEqUuBlZ4E/QyKxC2uo8aRyj5Vas3/A73tBI0qhQxhNPKPzv6UCSliz5Rp/GNrrI00vDw2dLQtlhdDo+zidLBFnMRhBksK06HSmzUJSiRMsUkoSAmMX5Bx54oOsE6XCYUWBLbYK/aLkOnS1BNR0ugQKlN/nyYMIViUCSGaco//ujjjoq75MlznH04awkf3z556oQMDGbxCwBo8YEkLT1XNNcF9H23T+PywcnlPBRskiAmo8P6WYAJ7rtMTPmftacJIiEgp8z+BHlf8/1HU2W+LPRtp2EwicVzMLlS7JEch/d2pnBTb+uzM+K+4D65ZdfLvbnOc6krkMmaY/ubkmy5xM+X0rok2c2N4ijuiL6MHKuddp67nPezzXDA7mpwIhu+pCE2IXj5jhInmkXGBThNe5fKksY9IiiUoREisSCe53EiXsj35KF0rRxS4N7JfpYFK6HEf9eEwyQ5Nvxryxlcvl2xS8ByYqfRmVWIy2LDEuDURJfJsXC06yUfdAQ+ISFMqE0rY9ZEhp/34jTSTFqmBUENDz/A2xjnraBiZIwo0XZS9bbOB6Ym9QNU5YW7ZpPQrN0rcevd9ZV5GPiuaIwm09lA6hS8Tsvph1JFw93z1osE49nstTGzZs3z2688cbExnHJW2ggIiIiIiKyEihZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREAspbgs2aNcuyJHq8c+bMsayIHuvMmTMtS6LHO3v2bMuS6PEuXLjQsiJ6rFlu4+bNm2dZET3WLF3r8eOdO3euZUn0eOfPn29ZET3WLMUy8ePNahuXRGVyuVzOEhY8Vq9efVX/M0REREREZCnMmDHDqlWrZkmiMjwREREREZE0zCzxz81aaUro2KtWrWplypSxLMjqcUPHnr3zrnOuc56Vax263nW963rPlqoJ7M8TlyyJiIiIiIisDCrDExERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiJKlkREREREREpHM0siIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSEREREREJULIkIiIiIiISoGRJREREREQkQMmSiIiIiIhIgJIlERERERGRACVLIiIiIiIiAUqWREREREREApQsiYiIiIiIBChZEhERERERCVCyJCIiIiIiEqBkSUREREREJEDJkoiIiIiISICSJRERERERkQAlSyIiIiIiIgFKlkRERERERAKULImIiIiIiAQoWRIREREREQlQsiQiIiIiIhKgZElERERERCRAyZKIiIiIiEiAkiUREREREZEAJUsiIiIiIiIBSpZEREREREQClCyJiIiIiIgEKFkSERERERGx4v4H9LBipvTgz7kAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# (2,:) — fix mode-0 to flat index 2, keep all of mode-1\n", + "draw_slice(cecka_t, (2, None), title=\"(2,:)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "output": { + "id": 1640967410569655, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# (:,5) — keep all of mode-0, fix mode-1 to flat index 5\n", + "draw_slice(cecka_t, (None, 5), title=\"(:,5)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "output": { + "id": 1401134948003030, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# (2,((0,:),:)) — fix mode-0 to 2, partially slice mode-1\n", + "draw_slice(cecka_t, (2, ((0, None), None)), title=\"(2,((0,:),:))\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "output": { + "id": 1824970334868558, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ((:,1),(:,0)) — fix outer-row=1, inner-col-outer=0\n", + "draw_slice(cecka_t, ((None, 1), (None, 0)), title=\"((:,1),(:,0))\")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "output": { + "id": 2365542210561060, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ((:,0),((0,:),1)) — outer-row=0, inner-col-0=0, outer-col=1\n", + "draw_slice(cecka_t, ((None, 0), ((0, None), 1)), title=\"((:,0),((0,:),1))\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "output": { + "id": 2496503134097427, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ((1,:),((:,0),:)) — inner-row=1, middle-col=0\n", + "draw_slice(cecka_t, ((1, None), ((None, 0), None)), title=\"((1,:),((:,0),:))\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Tensor Storage and Auto-Labeling\n", + "\n", + "A Tensor can hold optional **storage** (any indexable object). When storage is present:\n", + "- `tensor[i, j]` returns `data[offset]` instead of the raw offset\n", + "- `tensor[i, j] = val` writes to the storage\n", + "- `draw_layout(tensor)` auto-labels cells with data values\n", + "- Slicing produces sub-Tensors that share the same storage (view semantics)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Attach storage: cells show data values instead of offsets\n", + "buf = list(\"ABCDEFGHIJKLMNOPQRSTUVWXYZ012345\")\n", + "t = Tensor(Layout((4, 8), (8, 1)), data=buf)\n", + "\n", + "print(f\"t[0, 0] = {t[0, 0]!r}\")\n", + "print(f\"t[2, 3] = {t[2, 3]!r} (data[{t(2, 3)}])\")\n", + "print(f\"t(2, 3) = {t(2, 3)} (offset, always int)\")\n", + "\n", + "draw_layout(t, title=\"Auto-labeled from storage\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Same data viewed through row-major vs column-major\n", + "row_t = Tensor(Layout((4, 8), (8, 1)), data=buf)\n", + "col_t = Tensor(Layout((4, 8), (1, 4)), data=buf)\n", + "\n", + "draw_composite([row_t, col_t],\n", + " titles=[\"Row-major\", \"Col-major\"],\n", + " main_title=\"Same data, different layouts\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Override auto-labeling: show raw offsets or suppress labels\n", + "draw_layout(t, title='cell_labels=\"offset\"', cell_labels=\"offset\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# View semantics: slicing shares storage\n", + "row2 = t[2, :]\n", + "print(f\"row2[3] = {row2[3]!r}\")\n", + "print(f\"t[2, 3] = {t[2, 3]!r} (same value)\")\n", + "print(f\"row2.data is t.data: {row2.data is t.data}\")\n", + "\n", + "# Write through the slice\n", + "row2[0] = '*'\n", + "print(f\"\\nAfter row2[0] = '*':\")\n", + "print(f\"t[2, 0] = {t[2, 0]!r} (visible through parent)\")\n", + "draw_layout(t, title=\"After row2[0] = '*'\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "fileHeader": "", + "fileUid": "24b17c59-f63d-4f7e-8b6a-8fd6f33256da", + "isAdHoc": false, + "kernelspec": { + "display_name": "Python (jld-dev)", + "language": "python", + "name": "jld-dev" + }, + "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.12.12" } - ], - "source": [ - "# ((1,:),((:,0),:)) — inner-row=1, middle-col=0\n", - "draw_slice(cecka_t, ((1, None), ((None, 0), None)), title=\"((1,:),((:,0),:))\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "fileHeader": "", - "fileUid": "24b17c59-f63d-4f7e-8b6a-8fd6f33256da", - "isAdHoc": false, - "kernelspec": { - "display_name": "Python (jld-dev)", - "language": "python", - "name": "jld-dev" }, - "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.12.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/viz.py b/examples/viz.py index 24620b4..e02e982 100644 --- a/examples/viz.py +++ b/examples/viz.py @@ -62,6 +62,7 @@ def setup_output_dir(name: str = "examples_output") -> Path: # Section 1: Output Formats (SVG, PNG, PDF) # ============================================================================= + def example_output_formats(output: Path): """Demonstrate SVG, PNG, and PDF output formats. @@ -89,57 +90,71 @@ def example_output_formats(output: Path): layout = Layout((4, 8), (8, 1)) # SVG output - vector format (default, best for most uses) - draw_layout(layout, output / "format_example.svg", - title="(4,8):(8,1)") + draw_layout(layout, output / "format_example.svg", title="(4,8):(8,1)") print(f"✓ SVG: format_example.svg (vector, scalable)") # PNG output - raster format with configurable DPI - draw_layout(layout, output / "format_example.png", - title="(4,8):(8,1)", dpi=150) + draw_layout(layout, output / "format_example.png", title="(4,8):(8,1)", dpi=150) print(f"✓ PNG: format_example.png (raster, 150 dpi)") # PDF output - print-ready format - draw_layout(layout, output / "format_example.pdf", - title="(4,8):(8,1)") + draw_layout(layout, output / "format_example.pdf", title="(4,8):(8,1)") print(f"✓ PDF: format_example.pdf (print-ready)") # Demonstrate color_layout options layout_8x8 = Layout((8, 8), (8, 1)) # Color by value (default) - same value = same color - draw_layout(layout_8x8, output / "color_by_value.svg", - title="color_layout=None (by value)") + draw_layout(layout_8x8, output / "color_by_value.svg", title="color_layout=None (by value)") print(f"✓ Color by value: color_by_value.svg") # Color by column - darker across columns (cute-viz style) - draw_layout(layout_8x8, output / "color_by_col.svg", - title="color_layout=(8,8):(0,1) (by column)", - color_layout=Layout((8, 8), (0, 1))) + draw_layout( + layout_8x8, + output / "color_by_col.svg", + title="color_layout=(8,8):(0,1) (by column)", + color_layout=Layout((8, 8), (0, 1)), + ) print(f"✓ Color by column: color_by_col.svg") # Color by row - darker down rows - draw_layout(layout_8x8, output / "color_by_row.svg", - title="color_layout=(8,8):(1,0) (by row)", - color_layout=Layout((8, 8), (1, 0))) + draw_layout( + layout_8x8, + output / "color_by_row.svg", + title="color_layout=(8,8):(1,0) (by row)", + color_layout=Layout((8, 8), (1, 0)), + ) print(f"✓ Color by row: color_by_row.svg") # Uniform color - no variation - draw_layout(layout_8x8, output / "color_uniform.svg", - title="color_layout=1:0 (uniform)", - color_layout=Layout(1, 0)) + draw_layout( + layout_8x8, + output / "color_uniform.svg", + title="color_layout=1:0 (uniform)", + color_layout=Layout(1, 0), + ) print(f"✓ Uniform color: color_uniform.svg") # Rainbow colors with different color_layout - draw_layout(layout_8x8, output / "color_by_col_rainbow.svg", - title="colorize=True, by column", - colorize=True, color_layout=Layout((8, 8), (0, 1))) + draw_layout( + layout_8x8, + output / "color_by_col_rainbow.svg", + title="colorize=True, by column", + colorize=True, + color_layout=Layout((8, 8), (0, 1)), + ) print(f"✓ Rainbow by column: color_by_col_rainbow.svg") # color_by shorthand — equivalent to the manual color_layout above - draw_layout(layout_8x8, output / "color_by_row_shorthand.svg", - title='color_by="row"', color_by="row") - draw_layout(layout_8x8, output / "color_by_col_shorthand.svg", - title='color_by="column"', color_by="column") + draw_layout( + layout_8x8, output / "color_by_row_shorthand.svg", title='color_by="row"', color_by="row" + ) + draw_layout( + layout_8x8, + output / "color_by_col_shorthand.svg", + title='color_by="column"', + color_by="column", + ) print(f"✓ color_by shorthand: color_by_row_shorthand.svg, color_by_col_shorthand.svg") # Swizzle comparison showing row-group coloring (reveals permutation effect) @@ -154,6 +169,7 @@ def example_output_formats(output: Path): # Section 2: 1D Layouts # ============================================================================= + def example_1d_layouts(output: Path): """1D contiguous and strided layouts. @@ -168,30 +184,37 @@ def example_1d_layouts(output: Path): # Contiguous 1D layout: 8 elements, stride 1 layout_1d_contiguous = Layout(8, 1) - draw_layout(layout_1d_contiguous, output / "1d_contiguous.svg", - title="1D Contiguous: 8:1") + draw_layout(layout_1d_contiguous, output / "1d_contiguous.svg", title="1D Contiguous: 8:1") print(f"✓ 1D Contiguous: 8:1") print(f" Maps index i → offset i (e.g., 3 → 3)") # Strided 1D layout: 8 elements, stride 2 layout_1d_strided = Layout(8, 2) - draw_layout(layout_1d_strided, output / "1d_strided.svg", - title="1D Strided: 8:2") + draw_layout(layout_1d_strided, output / "1d_strided.svg", title="1D Strided: 8:2") print(f"✓ 1D Strided: 8:2") print(f" Maps index i → offset 2*i (e.g., 3 → 6)") # Strided 1D layout: 4 elements, stride 4 layout_1d_stride4 = Layout(4, 4) - draw_layout(layout_1d_stride4, output / "1d_stride4.svg", - title="1D Stride-4: 4:4") + draw_layout(layout_1d_stride4, output / "1d_stride4.svg", title="1D Stride-4: 4:4") print(f"✓ 1D Stride-4: 4:4") print(f" Maps index i → offset 4*i (e.g., 2 → 8)") + # Transpose: render 1D layout as a column vector instead of a row + draw_layout( + layout_1d_contiguous, + output / "1d_contiguous_col.svg", + title="1D Column: 8:1 (transpose=True)", + transpose=True, + ) + print(f"✓ 1D Column (transpose=True): renders as N×1 instead of 1×N") + # ============================================================================= # Section 3: 2D Layouts # ============================================================================= + def example_2d_layouts(output: Path): """2D row-major and column-major layouts. @@ -207,35 +230,39 @@ def example_2d_layouts(output: Path): # Row-major 4x3: shape (4 rows, 3 cols), stride (3, 1) # Row i, Col j → offset = i*3 + j row_major_4x3 = Layout((4, 3), (3, 1)) - draw_layout(row_major_4x3, output / "2d_row_major_4x3.svg", - title="Row-Major 4×3: (4,3):(3,1)") + draw_layout(row_major_4x3, output / "2d_row_major_4x3.svg", title="Row-Major 4×3: (4,3):(3,1)") print(f"✓ Row-Major 4×3: (4,3):(3,1)") print(f" offset(i,j) = i*3 + j*1") # Column-major 4x3: shape (4 rows, 3 cols), stride (1, 4) # Row i, Col j → offset = i*1 + j*4 col_major_4x3 = Layout((4, 3), (1, 4)) - draw_layout(col_major_4x3, output / "2d_col_major_4x3.svg", - title="Col-Major 4×3: (4,3):(1,4)") + draw_layout(col_major_4x3, output / "2d_col_major_4x3.svg", title="Col-Major 4×3: (4,3):(1,4)") print(f"✓ Col-Major 4×3: (4,3):(1,4)") print(f" offset(i,j) = i*1 + j*4") # 8x8 Row-major: shape (8 rows, 8 cols), stride (8, 1) # This is the common layout for matrix operations row_major_8x8 = Layout((8, 8), (8, 1)) - draw_layout(row_major_8x8, output / "2d_row_major_8x8.svg", - title="Row-Major 8×8: (8,8):(8,1)") - draw_layout(row_major_8x8, output / "2d_row_major_8x8_color.svg", - title="Row-Major 8×8: (8,8):(8,1)", colorize=True) + draw_layout(row_major_8x8, output / "2d_row_major_8x8.svg", title="Row-Major 8×8: (8,8):(8,1)") + draw_layout( + row_major_8x8, + output / "2d_row_major_8x8_color.svg", + title="Row-Major 8×8: (8,8):(8,1)", + colorize=True, + ) print(f"✓ Row-Major 8×8: (8,8):(8,1) [grayscale and colorized]") print(f" offset(i,j) = i*8 + j*1") # 8x8 Column-major: shape (8 rows, 8 cols), stride (1, 8) col_major_8x8 = Layout((8, 8), (1, 8)) - draw_layout(col_major_8x8, output / "2d_col_major_8x8.svg", - title="Col-Major 8×8: (8,8):(1,8)") - draw_layout(col_major_8x8, output / "2d_col_major_8x8_color.svg", - title="Col-Major 8×8: (8,8):(1,8)", colorize=True) + draw_layout(col_major_8x8, output / "2d_col_major_8x8.svg", title="Col-Major 8×8: (8,8):(1,8)") + draw_layout( + col_major_8x8, + output / "2d_col_major_8x8_color.svg", + title="Col-Major 8×8: (8,8):(1,8)", + colorize=True, + ) print(f"✓ Col-Major 8×8: (8,8):(1,8) [grayscale and colorized]") print(f" offset(i,j) = i*1 + j*8") @@ -244,6 +271,7 @@ def example_2d_layouts(output: Path): # Section 4: Hierarchical Layouts # ============================================================================= + def example_hierarchical_layouts(output: Path): """Hierarchical (nested) layouts - flattened and nested views. @@ -275,8 +303,12 @@ def example_hierarchical_layouts(output: Path): print(f" (({i},0),({j},0)) → {idx}") # Flat view (default) - draw_layout(hier_2x2_3x4, output / "hier_2x2_3x4_flat.svg", - title=f"Flat: {hier_2x2_3x4}", flatten_hierarchical=True) + draw_layout( + hier_2x2_3x4, + output / "hier_2x2_3x4_flat.svg", + title=f"Flat: {hier_2x2_3x4}", + flatten_hierarchical=True, + ) print(f"✓ Flat view: hier_2x2_3x4_flat.svg") # Nested pedagogical view: @@ -284,9 +316,13 @@ def example_hierarchical_layouts(output: Path): # - each cell shows col=... (nested column coordinate) # - each cell shows offset=... (resulting offset) # - axes stay simple (R0, R1, ... / C0, C1, ...) - draw_layout(hier_2x2_3x4, output / "hier_2x2_3x4_nested.svg", - title=f"Nested: {hier_2x2_3x4}", flatten_hierarchical=False, - label_hierarchy_levels=True) + draw_layout( + hier_2x2_3x4, + output / "hier_2x2_3x4_nested.svg", + title=f"Nested: {hier_2x2_3x4}", + flatten_hierarchical=False, + label_hierarchy_levels=True, + ) print(f"✓ Nested view: hier_2x2_3x4_nested.svg") # ========================================================================= @@ -306,13 +342,23 @@ def example_hierarchical_layouts(output: Path): # Tile (1,0): 4 6 Tile (1,1): 12 14 # 5 7 13 15 - draw_layout(logo_layout, output / "hier_2x2_tiles_flat.svg", - title=f"Flat: {logo_layout}", flatten_hierarchical=True) - draw_layout(logo_layout, output / "hier_2x2_tiles_nested.svg", - title=f"Nested: {logo_layout}", flatten_hierarchical=False, - label_hierarchy_levels=True) + draw_layout( + logo_layout, + output / "hier_2x2_tiles_flat.svg", + title=f"Flat: {logo_layout}", + flatten_hierarchical=True, + ) + draw_layout( + logo_layout, + output / "hier_2x2_tiles_nested.svg", + title=f"Nested: {logo_layout}", + flatten_hierarchical=False, + label_hierarchy_levels=True, + ) print(f"✓ Hierarchical 2×2 in 2×2 (logo layout): {logo_layout}") - print(f" Nested view is pedagogical: row=... / col=... show nested coordinates, offset=... shows mapping") + print( + f" Nested view is pedagogical: row=... / col=... show nested coordinates, offset=... shows mapping" + ) # ========================================================================= # Example 3: 3-level asymmetric hierarchy with per-level axis labels @@ -373,16 +419,104 @@ def example_hierarchical_layouts(output: Path): # Flatten the hierarchical layout (algebra operation) flat_layout = flatten(logo_layout) - draw_layout(flat_layout, output / "hier_flattened.svg", - title=f"flatten(): {flat_layout}") + draw_layout(flat_layout, output / "hier_flattened.svg", title=f"flatten(): {flat_layout}") print(f"✓ Flattened (algebra): {flat_layout}") # Coalesce to merge contiguous dimensions coal_layout = coalesce(logo_layout) - draw_layout(coal_layout, output / "hier_coalesced.svg", - title=f"coalesce(): {coal_layout}") + draw_layout(coal_layout, output / "hier_coalesced.svg", title=f"coalesce(): {coal_layout}") print(f"✓ Coalesced: {coal_layout}") + # ========================================================================= + # Cell Label Modes + # + # cell_labels controls what text appears inside each cell: + # True — default (offset in flat mode, row/col/offset in nested) + # "offset" — just the offset number (useful with hierarchy boundaries) + # False — no text (colored grid + boundaries only) + # list/tuple — custom labels indexed by offset value + # ========================================================================= + print("\n --- Cell Label Modes ---") + + demo = Layout(((2, 2), (2, 2)), ((1, 4), (2, 8))) + + # Flat mode: default labels (offset numbers) vs no labels + draw_layout( + demo, + output / "cell_labels_flat_default.svg", + title="Flat: cell_labels=True (default)", + colorize=True, + flatten_hierarchical=True, + ) + draw_layout( + demo, + output / "cell_labels_flat_none.svg", + title="Flat: cell_labels=False", + colorize=True, + flatten_hierarchical=True, + cell_labels=False, + ) + print(f"✓ Flat mode: default vs cell_labels=False") + + # Flat mode: custom labels (alphabet) + import string + + labels = list(string.ascii_uppercase[: size(demo)]) + draw_layout( + demo, + output / "cell_labels_flat_custom.svg", + title="Flat: cell_labels=['A','B',...]", + colorize=True, + flatten_hierarchical=True, + cell_labels=labels, + ) + print(f"✓ Flat mode: cell_labels={labels}") + + # Hierarchical mode: full detail (default) + draw_layout( + demo, + output / "cell_labels_hier_default.svg", + title="Nested: cell_labels=True (default)", + colorize=True, + flatten_hierarchical=False, + label_hierarchy_levels=True, + ) + + # Hierarchical mode: offset only — keeps boundaries + axis labels, + # replaces verbose row/col/offset with a single number + draw_layout( + demo, + output / "cell_labels_hier_offset.svg", + title='Nested: cell_labels="offset"', + colorize=True, + flatten_hierarchical=False, + label_hierarchy_levels=True, + cell_labels="offset", + ) + + # Hierarchical mode: no text at all + draw_layout( + demo, + output / "cell_labels_hier_none.svg", + title="Nested: cell_labels=False", + colorize=True, + flatten_hierarchical=False, + label_hierarchy_levels=True, + cell_labels=False, + ) + + # Hierarchical mode: custom labels + draw_layout( + demo, + output / "cell_labels_hier_custom.svg", + title="Nested: cell_labels=['A','B',...]", + colorize=True, + flatten_hierarchical=False, + label_hierarchy_levels=True, + cell_labels=labels, + ) + print(f'✓ Nested mode: default / "offset" / False / custom labels') + # ========================================================================= # Examples from "Cute Layout Representation and Algebra" by Cris Cecka # ========================================================================= @@ -390,53 +524,74 @@ def example_hierarchical_layouts(output: Path): # (4,8):(1,4) — column-major 4x8 cecka_1 = Layout((4, 8), (1, 4)) - draw_layout(cecka_1, output / "cecka_4x8_col.svg", - title="(4,8):(1,4)") + draw_layout(cecka_1, output / "cecka_4x8_col.svg", title="(4,8):(1,4)") print(f"✓ (4,8):(1,4) — column-major 4×8") # (4,8):(8,1) — row-major 4x8 cecka_2 = Layout((4, 8), (8, 1)) - draw_layout(cecka_2, output / "cecka_4x8_row.svg", - title="(4,8):(8,1)") + draw_layout(cecka_2, output / "cecka_4x8_row.svg", title="(4,8):(8,1)") print(f"✓ (4,8):(8,1) — row-major 4×8") # (4,8):(1,5) — non-injective layout (stride 5 with shape 8 wraps) cecka_3 = Layout((4, 8), (1, 5)) - draw_layout(cecka_3, output / "cecka_4x8_s1_s5.svg", - title="(4,8):(1,5)") + draw_layout(cecka_3, output / "cecka_4x8_s1_s5.svg", title="(4,8):(1,5)") print(f"✓ (4,8):(1,5) — non-injective (surjective) layout") # (4,(4,2)):(4,(1,16)) — hierarchical column dimension # Nested rendering explicitly shows how the hierarchical column coordinate # maps to the final offset for each displayed cell. cecka_4 = Layout((4, (4, 2)), (4, (1, 16))) - draw_layout(cecka_4, output / "cecka_hier_col.svg", - title="(4,(4,2)):(4,(1,16))", flatten_hierarchical=False, - label_hierarchy_levels=True) - draw_layout(cecka_4, output / "cecka_hier_col_flat.svg", - title="(4,(4,2)):(4,(1,16))", flatten_hierarchical=True) + draw_layout( + cecka_4, + output / "cecka_hier_col.svg", + title="(4,(4,2)):(4,(1,16))", + flatten_hierarchical=False, + label_hierarchy_levels=True, + ) + draw_layout( + cecka_4, + output / "cecka_hier_col_flat.svg", + title="(4,(4,2)):(4,(1,16))", + flatten_hierarchical=True, + ) print(f"✓ (4,(4,2)):(4,(1,16)) — hierarchical column") # ((2,2),(4,2)):((1,8),(2,16)) — hierarchical in both modes # This is a good example where explicit row=... / col=... labels help explain # the two-level row and column structure. cecka_5 = Layout(((2, 2), (4, 2)), ((1, 8), (2, 16))) - draw_layout(cecka_5, output / "cecka_hier_both.svg", - title="((2,2),(4,2)):((1,8),(2,16))", flatten_hierarchical=False, - label_hierarchy_levels=True) - draw_layout(cecka_5, output / "cecka_hier_both_flat.svg", - title="((2,2),(4,2)):((1,8),(2,16))", flatten_hierarchical=True) + draw_layout( + cecka_5, + output / "cecka_hier_both.svg", + title="((2,2),(4,2)):((1,8),(2,16))", + flatten_hierarchical=False, + label_hierarchy_levels=True, + ) + draw_layout( + cecka_5, + output / "cecka_hier_both_flat.svg", + title="((2,2),(4,2)):((1,8),(2,16))", + flatten_hierarchical=True, + ) print(f"✓ ((2,2),(4,2)):((1,8),(2,16)) — hierarchical both modes") # ((2,2),(2,4)):((0,2),(0,4)) — zero-stride (broadcast) layout # The pedagogical nested view is especially useful here because repeated # offsets are easier to interpret when the source coordinates are explicit. cecka_6 = Layout(((2, 2), (2, 4)), ((0, 2), (0, 4))) - draw_layout(cecka_6, output / "cecka_broadcast.svg", - title="((2,2),(2,4)):((0,2),(0,4))", flatten_hierarchical=False, - label_hierarchy_levels=True) - draw_layout(cecka_6, output / "cecka_broadcast_flat.svg", - title="((2,2),(2,4)):((0,2),(0,4))", flatten_hierarchical=True) + draw_layout( + cecka_6, + output / "cecka_broadcast.svg", + title="((2,2),(2,4)):((0,2),(0,4))", + flatten_hierarchical=False, + label_hierarchy_levels=True, + ) + draw_layout( + cecka_6, + output / "cecka_broadcast_flat.svg", + title="((2,2),(2,4)):((0,2),(0,4))", + flatten_hierarchical=True, + ) print(f"✓ ((2,2),(2,4)):((0,2),(0,4)) — broadcast (zero-stride) layout") # Morton/Z-order layout using blocked_product (CuTe pattern) @@ -446,14 +601,12 @@ def example_hierarchical_layouts(output: Path): morton1 = Layout((2, 2), (1, 2)) morton2 = blocked_product(morton1, morton1) morton3 = blocked_product(morton1, morton2) - draw_layout(morton1, output / "hier_morton_2x2.svg", - title=f"Morton 2×2: {morton1}") - draw_layout(morton2, output / "hier_morton_4x4.svg", - title=f"Morton 4×4: {morton2}") - draw_layout(morton3, output / "hier_morton_8x8.svg", - title=f"Morton 8×8: {morton3}") - draw_layout(morton3, output / "hier_morton_8x8_color.svg", - title=f"Morton 8×8: {morton3}", colorize=True) + draw_layout(morton1, output / "hier_morton_2x2.svg", title=f"Morton 2×2: {morton1}") + draw_layout(morton2, output / "hier_morton_4x4.svg", title=f"Morton 4×4: {morton2}") + draw_layout(morton3, output / "hier_morton_8x8.svg", title=f"Morton 8×8: {morton3}") + draw_layout( + morton3, output / "hier_morton_8x8_color.svg", title=f"Morton 8×8: {morton3}", colorize=True + ) print(f"✓ Morton 2×2: {morton1}") print(f"✓ Morton 4×4: {morton2}") print(f"✓ Morton 8×8: {morton3}") @@ -461,14 +614,12 @@ def example_hierarchical_layouts(output: Path): # Show nested mode access # Mode 0 is the row dimension with shape (2, 2) mode0 = mode(logo_layout, 0) - draw_layout(mode0, output / "hier_mode0.svg", - title=f"Mode 0 (rows): {mode0}") + draw_layout(mode0, output / "hier_mode0.svg", title=f"Mode 0 (rows): {mode0}") print(f"✓ Mode 0 (rows): {mode0}") # Mode 1 is the column dimension with shape (2, 2) mode1 = mode(logo_layout, 1) - draw_layout(mode1, output / "hier_mode1.svg", - title=f"Mode 1 (cols): {mode1}") + draw_layout(mode1, output / "hier_mode1.svg", title=f"Mode 1 (cols): {mode1}") print(f"✓ Mode 1 (cols): {mode1}") @@ -476,6 +627,7 @@ def example_hierarchical_layouts(output: Path): # Section 5: Swizzled Layouts # ============================================================================= + def example_swizzled_layouts(output: Path): """Swizzled layouts for GPU shared memory bank conflict avoidance. @@ -586,6 +738,7 @@ def example_swizzled_layouts(output: Path): # Section 6: Thread-Value (TV) Layouts # ============================================================================= + def example_thread_value_layouts(output: Path): """Thread-Value (TV) layouts for GPU parallelism. @@ -604,38 +757,42 @@ def example_thread_value_layouts(output: Path): # Simple TV layout: 4 threads, 2 values each = 8 elements # Thread 0: V0, V1; Thread 1: V0, V1; etc. tv_4x2 = Layout((4, 2), (2, 1)) - draw_tv_layout(tv_4x2, output / "tv_4threads_2values.svg", - title="TV: (4,2):(2,1) - 4 threads, 2 values each") - draw_tv_layout(tv_4x2, output / "tv_4threads_2values_color.svg", - title="TV: (4,2):(2,1)", colorize=True) + draw_tv_layout( + tv_4x2, + output / "tv_4threads_2values.svg", + title="TV: (4,2):(2,1) - 4 threads, 2 values each", + ) + draw_tv_layout( + tv_4x2, output / "tv_4threads_2values_color.svg", title="TV: (4,2):(2,1)", colorize=True + ) print(f"✓ TV Layout 4×2: 4 threads, 2 values each") print(f" Thread t owns values V0, V1 at offsets 2*t and 2*t+1") # TV layout with interleaved threads tv_4x2_col = Layout((4, 2), (1, 4)) - draw_tv_layout(tv_4x2_col, output / "tv_4threads_2values_interleaved.svg", - title="TV interleaved: (4,2):(1,4)") + draw_tv_layout( + tv_4x2_col, + output / "tv_4threads_2values_interleaved.svg", + title="TV interleaved: (4,2):(1,4)", + ) print(f"✓ TV Layout 4×2 interleaved: offsets t and t+4") # 8x4 TV layout (smaller than full warp for clarity) tv_8x4 = Layout((8, 4), (4, 1)) - draw_tv_layout(tv_8x4, output / "tv_8x4.svg", - title="TV: (8,4):(4,1) - 8 threads, 4 values") - draw_tv_layout(tv_8x4, output / "tv_8x4_color.svg", - title="TV: (8,4):(4,1)", colorize=True) + draw_tv_layout(tv_8x4, output / "tv_8x4.svg", title="TV: (8,4):(4,1) - 8 threads, 4 values") + draw_tv_layout(tv_8x4, output / "tv_8x4_color.svg", title="TV: (8,4):(4,1)", colorize=True) print(f"✓ TV Layout 8×4: 8 threads, 4 values each") # 8x8 TV layout (common for LDMATRIX) tv_8x8 = Layout((8, 8), (8, 1)) - draw_tv_layout(tv_8x8, output / "tv_8x8.svg", - title="TV: (8,8):(8,1) - 8 threads, 8 values") - draw_tv_layout(tv_8x8, output / "tv_8x8_color.svg", - title="TV: (8,8):(8,1)", colorize=True) + draw_tv_layout(tv_8x8, output / "tv_8x8.svg", title="TV: (8,8):(8,1) - 8 threads, 8 values") + draw_tv_layout(tv_8x8, output / "tv_8x8_color.svg", title="TV: (8,8):(8,1)", colorize=True) print(f"✓ TV Layout 8×8: 8 threads, 8 values each (LDMATRIX style)") # Also show the regular layout view for comparison - draw_layout(tv_8x8, output / "tv_8x8_offsets.svg", - title="TV: (8,8):(8,1) - Memory offsets view") + draw_layout( + tv_8x8, output / "tv_8x8_offsets.svg", title="TV: (8,8):(8,1) - Memory offsets view" + ) print(f" (Also showing memory offset view for comparison)") @@ -643,6 +800,7 @@ def example_thread_value_layouts(output: Path): # Section 7: Copy Atom Traits (LDMATRIX, STMATRIX, TMA) # ============================================================================= + def example_copy_atoms(output: Path): """Copy atom TV layouts across GPU architectures. @@ -678,8 +836,7 @@ def example_copy_atoms(output: Path): ] for atom in ldsm_atoms: # draw_copy_atom handles upcast from bit to element coords automatically - draw_copy_atom(atom, element_bits=element_bits, - filename=output / f"{atom.name}_copy.svg") + draw_copy_atom(atom, element_bits=element_bits, filename=output / f"{atom.name}_copy.svg") dst = upcast(atom.dst_layout_bits, element_bits) n_thr = size(atom.thr_id) @@ -694,8 +851,7 @@ def example_copy_atoms(output: Path): stsm_atoms = [SM90_U32x4_STSM_N, SM90_U16x8_STSM_T] for atom in stsm_atoms: - draw_copy_atom(atom, element_bits=element_bits, - filename=output / f"{atom.name}_copy.svg") + draw_copy_atom(atom, element_bits=element_bits, filename=output / f"{atom.name}_copy.svg") print(f"✓ {atom.name} ({atom.ptx})") # ===================================================================== @@ -718,14 +874,14 @@ def example_copy_atoms(output: Path): # For fp16: Swizzle<3,4,3> ∘ (8, 64):(64, 1) = 8 rows × 64 cols print("\n TMA target: GMMA K-major SW128 smem layout (fp16):") base_tma = Layout((8, 64), (64, 1)) - draw_swizzle(base_tma, Swizzle(3, 4, 3), - output / "SM90_TMA_GMMA_K_SW128.svg", colorize=True) + draw_swizzle(base_tma, Swizzle(3, 4, 3), output / "SM90_TMA_GMMA_K_SW128.svg", colorize=True) print(f"✓ SM90 TMA → GMMA K-major SW128: Swizzle(3,4,3) ∘ (8,64):(64,1)") print("\n TMA target: GMMA M|N-major SW128 smem layout (fp16):") base_tma_mn = Layout((64, 8), (1, 64)) - draw_swizzle(base_tma_mn, Swizzle(3, 4, 3), - output / "SM90_TMA_GMMA_MN_SW128.svg", colorize=True) + draw_swizzle( + base_tma_mn, Swizzle(3, 4, 3), output / "SM90_TMA_GMMA_MN_SW128.svg", colorize=True + ) print(f"✓ SM90 TMA → GMMA M|N-major SW128: Swizzle(3,4,3) ∘ (64,8):(1,64)") # ===================================================================== @@ -733,8 +889,7 @@ def example_copy_atoms(output: Path): # ===================================================================== print("\n --- LDMATRIX Shared Memory with Swizzle ---") smem_8x8 = Layout((8, 8), (8, 1)) - draw_swizzle(smem_8x8, Swizzle(3, 0, 3), - output / "ldmatrix_smem_swizzle.svg", colorize=True) + draw_swizzle(smem_8x8, Swizzle(3, 0, 3), output / "ldmatrix_smem_swizzle.svg", colorize=True) print(f"✓ LDMATRIX shared memory with Swizzle(3,0,3)") @@ -742,6 +897,7 @@ def example_copy_atoms(output: Path): # Section 8: MMA Atom Traits # ============================================================================= + def _draw_mma_atom(atom, output: Path): """Draw A, B, C, and combined figures for one MMA atom.""" name = atom.name @@ -757,23 +913,44 @@ def _draw_mma_atom(atom, output: Path): b_rows, b_cols = cs_b // N if cs_b % N == 0 else K, N c_rows, c_cols = M, cs_c // M if cs_c % M == 0 else N - draw_tv_layout(atom.a_layout, output / f"{name}_A.svg", - title=f"{name} A ({a_rows}×{a_cols})", - colorize=True, grid_shape=(a_rows, a_cols), thr_id_layout=thr) + draw_tv_layout( + atom.a_layout, + output / f"{name}_A.svg", + title=f"{name} A ({a_rows}×{a_cols})", + colorize=True, + grid_shape=(a_rows, a_cols), + thr_id_layout=thr, + ) - draw_tv_layout(atom.b_layout, output / f"{name}_B.svg", - title=f"{name} B ({b_rows}×{b_cols})", - colorize=True, grid_shape=(b_rows, b_cols), thr_id_layout=thr, - col_major=False) + draw_tv_layout( + atom.b_layout, + output / f"{name}_B.svg", + title=f"{name} B ({b_rows}×{b_cols})", + colorize=True, + grid_shape=(b_rows, b_cols), + thr_id_layout=thr, + col_major=False, + ) - draw_tv_layout(atom.c_layout, output / f"{name}_C.svg", - title=f"{name} C ({c_rows}×{c_cols})", - colorize=True, grid_shape=(c_rows, c_cols), thr_id_layout=thr) + draw_tv_layout( + atom.c_layout, + output / f"{name}_C.svg", + title=f"{name} C ({c_rows}×{c_cols})", + colorize=True, + grid_shape=(c_rows, c_cols), + thr_id_layout=thr, + ) - draw_mma_layout(atom.a_layout, atom.b_layout, atom.c_layout, - output / f"{name}_combined.svg", - tile_mnk=(a_rows, c_cols, a_cols), main_title=name, - colorize=True, thr_id_layout=thr) + draw_mma_layout( + atom.a_layout, + atom.b_layout, + atom.c_layout, + output / f"{name}_combined.svg", + tile_mnk=(a_rows, c_cols, a_cols), + main_title=name, + colorize=True, + thr_id_layout=thr, + ) n_thr = size(mode(atom.c_layout, 0)) n_val_a = size(mode(atom.a_layout, 1)) @@ -815,14 +992,12 @@ def _draw_tiled_mma(atom, atom_layout, output: Path, tile_mnk=None): label = f"{atom.name}_{n_am}x{n_an}_{M}x{N}x{K}" # Compute tiled grids - c_grid, _ = tile_mma_grid(atom, atom_layout, 'C', tile_mnk=tile_mnk) - a_grid, _ = tile_mma_grid(atom, atom_layout, 'A', tile_mnk=tile_mnk) - b_grid, _ = tile_mma_grid(atom, atom_layout, 'B', tile_mnk=tile_mnk) - - draw_tiled_grid(c_grid, M, N, output / f"{label}_C.svg", - title=f"{label} C ({M}×{N})") - draw_tiled_grid(a_grid, M, K, output / f"{label}_A.svg", - title=f"{label} A ({M}×{K})") + c_grid, _ = tile_mma_grid(atom, atom_layout, "C", tile_mnk=tile_mnk) + a_grid, _ = tile_mma_grid(atom, atom_layout, "A", tile_mnk=tile_mnk) + b_grid, _ = tile_mma_grid(atom, atom_layout, "B", tile_mnk=tile_mnk) + + draw_tiled_grid(c_grid, M, N, output / f"{label}_C.svg", title=f"{label} C ({M}×{N})") + draw_tiled_grid(a_grid, M, K, output / f"{label}_A.svg", title=f"{label} A ({M}×{K})") # B displayed as K×N (transposed) b_display = {} for (r, c), val in b_grid.items(): @@ -830,17 +1005,19 @@ def _draw_tiled_mma(atom, atom_layout, output: Path, tile_mnk=None): n_coord = r k_coord = c b_display[(k_coord, n_coord)] = val - draw_tiled_grid(b_display, K, N, output / f"{label}_B.svg", - title=f"{label} B ({K}×{N})") + draw_tiled_grid(b_display, K, N, output / f"{label}_B.svg", title=f"{label} B ({K}×{N})") # Combined figure: A (left), B (top-right), C (bottom-right) - draw_combined_mma_grid(a_grid, b_display, c_grid, M, N, K, - output / f"{label}_combined.svg", title=label) + draw_combined_mma_grid( + a_grid, b_display, c_grid, M, N, K, output / f"{label}_combined.svg", title=label + ) print(f"✓ Tiled MMA: {label}") - print(f" {size(atom_layout)} atoms ({n_am}×{n_an}), " - f"tile {M}×{N}×{K}, " - f"{size(atom_layout) * size(mode(atom.c_layout, 0))} threads") + print( + f" {size(atom_layout)} atoms ({n_am}×{n_an}), " + f"tile {M}×{N}×{K}, " + f"{size(atom_layout) * size(mode(atom.c_layout, 0))} threads" + ) def example_mma_atom(output: Path): @@ -866,8 +1043,7 @@ def example_mma_atom(output: Path): # make_tiled_mma(SM70_8x8x4_F32F16F16F32_NT{}, # Layout, Stride<_2,_1>>{}); # Reference: HMMA.8x8x4.NT_2x2.png - _draw_tiled_mma(SM70_8x8x4_F32F16F16F32_NT, - Layout((2, 2), (2, 1)), output) + _draw_tiled_mma(SM70_8x8x4_F32F16F16F32_NT, Layout((2, 2), (2, 1)), output) # Tiled MMA expanded to 32×32×4 via value tiling # Equivalent to C++: @@ -875,9 +1051,9 @@ def example_mma_atom(output: Path): # Layout, Stride<_2,_1>>{}, # Tile<_32,_32,_4>{}); # Reference: HMMA.8x8x4.NT_2x2_32x32x4.png - _draw_tiled_mma(SM70_8x8x4_F32F16F16F32_NT, - Layout((2, 2), (2, 1)), output, - tile_mnk=(32, 32, 4)) + _draw_tiled_mma( + SM70_8x8x4_F32F16F16F32_NT, Layout((2, 2), (2, 1)), output, tile_mnk=(32, 32, 4) + ) # SM80 Ampere print("\n --- SM80 Ampere (32 threads, warp) ---") @@ -893,11 +1069,15 @@ def example_mma_atom(output: Path): print("\n --- SM90 Hopper GMMA (128 threads, warpgroup) ---") for atom in [SM90_64x8x16_F16F16F16_SS, SM90_64x64x16_F16F16F16_SS]: M, N, K = atom.shape_mnk - draw_tv_layout(atom.c_layout, output / f"{atom.name}_C.svg", - title=f"{atom.name} C ({M}×{N})", - colorize=True, grid_shape=(M, N)) + draw_tv_layout( + atom.c_layout, + output / f"{atom.name}_C.svg", + title=f"{atom.name} C ({M}×{N})", + colorize=True, + grid_shape=(M, N), + ) n_vals = size(mode(atom.c_layout, 1)) - print(f"✓ {atom.name} C: 128 thr × {n_vals} vals = {128*n_vals} elements") + print(f"✓ {atom.name} C: 128 thr × {n_vals} vals = {128 * n_vals} elements") # SM75 Turing — 32 threads, first-gen asymmetric tiles print("\n --- SM75 Turing (32 threads, warp) ---") @@ -919,22 +1099,29 @@ def example_mma_atom(output: Path): print("\n --- SM100 Blackwell UMMA (1 thread, warp group) ---") atom = SM100_128x128x16_F16F16F16_SS M, N, K = atom.shape_mnk - print(f"✓ {atom.name} C: {atom.c_layout} ({M*N} elements)") + print(f"✓ {atom.name} C: {atom.c_layout} ({M * N} elements)") # Compare: SM90 GMMA 64×8 C uses 128 threads with hierarchical layout sm90_atom = SM90_64x8x16_F16F16F16_SS sm90_c = sm90_atom.c_layout - draw_tv_layout(sm90_c, output / "SM100_compare_SM90_64x8_C.svg", - title="SM90 GMMA C (64×8) — 128 threads", - colorize=True, grid_shape=(64, 8)) + draw_tv_layout( + sm90_c, + output / "SM100_compare_SM90_64x8_C.svg", + title="SM90 GMMA C (64×8) — 128 threads", + colorize=True, + grid_shape=(64, 8), + ) print(f"✓ SM90 GMMA 64×8 C: {sm90_c} (128 thr × {size(mode(sm90_c, 1))} vals)") # SM100 UMMA 64×8 C — same logical tile, 1 "thread", all values umma_atom = make_umma_atom_ss(64, 8) umma_c = umma_atom.c_layout - draw_layout(umma_c, output / "SM100_compare_UMMA_64x8_C.svg", - title="SM100 UMMA C (64×8) — 1 thread, TMEM", - flatten_hierarchical=True) + draw_layout( + umma_c, + output / "SM100_compare_UMMA_64x8_C.svg", + title="SM100 UMMA C (64×8) — 1 thread, TMEM", + flatten_hierarchical=True, + ) print(f"✓ SM100 UMMA 64×8 C: {umma_c} (1 thr × {size(umma_c)} vals)") # SM120 Blackwell B200 — warp-level FP8 @@ -957,6 +1144,7 @@ def example_mma_atom(output: Path): # Section 9: Slicing Examples # ============================================================================= + def example_slicing(output: Path): """Slicing layouts - row, column, and complex discontinuous slices. @@ -973,25 +1161,26 @@ def example_slicing(output: Path): base = Layout((8, 8), (8, 1)) # Row slice: select row 3 (all columns) - draw_slice(base, (3, None), output / "slice_row3.svg", - title="Row Slice: layout(3, :)") + draw_slice(base, (3, None), output / "slice_row3.svg", title="Row Slice: layout(3, :)") print(f"✓ Row slice: layout(3, :)") print(f" Selects all 8 elements in row 3") # Column slice: select column 5 (all rows) - draw_slice(base, (None, 5), output / "slice_col5.svg", - title="Column Slice: layout(:, 5)") + draw_slice(base, (None, 5), output / "slice_col5.svg", title="Column Slice: layout(:, 5)") print(f"✓ Column slice: layout(:, 5)") print(f" Selects all 8 elements in column 5") # Single element - draw_slice(base, (4, 6), output / "slice_element.svg", - title="Single Element: layout(4, 6)") + draw_slice(base, (4, 6), output / "slice_element.svg", title="Single Element: layout(4, 6)") print(f"✓ Single element: layout(4, 6)") # Rectangular region: rows 2-5, columns 1-4 - draw_slice(base, (slice(2, 6), slice(1, 5)), output / "slice_rect.svg", - title="Rectangular: layout[2:6, 1:5]") + draw_slice( + base, + (slice(2, 6), slice(1, 5)), + output / "slice_rect.svg", + title="Rectangular: layout[2:6, 1:5]", + ) print(f"✓ Rectangular region: layout[2:6, 1:5]") print(f" Selects 4×4 = 16 elements") @@ -1001,33 +1190,28 @@ def example_slicing(output: Path): # Divide 8 rows into 4 groups of 2 divided = logical_divide(base, Layout((2, 4), (1, 2))) - draw_layout(divided, output / "slice_divided_base.svg", - title="Divided: 2-row groups") + draw_layout(divided, output / "slice_divided_base.svg", title="Divided: 2-row groups") print(f"✓ Divided layout: groups of 2 rows") # Tile-based slicing: select every other 2x2 tile tiled = Layout(((2, 4), (2, 4)), ((1, 16), (2, 8))) - draw_layout(tiled, output / "slice_tiled.svg", - title="Tiled: ((2,4),(2,4)):((1,16),(2,8))") + draw_layout(tiled, output / "slice_tiled.svg", title="Tiled: ((2,4),(2,4)):((1,16),(2,8))") print(f"✓ Tiled layout: 2×2 tiles in 8×8") # Strided row access (every other row) strided_rows = Layout((4, 8), (16, 1)) - draw_layout(strided_rows, output / "slice_strided_rows.svg", - title="Strided Rows: (4,8):(16,1)") + draw_layout(strided_rows, output / "slice_strided_rows.svg", title="Strided Rows: (4,8):(16,1)") print(f"✓ Strided rows: every other row") # Strided column access (every other column) strided_cols = Layout((8, 4), (8, 2)) - draw_layout(strided_cols, output / "slice_strided_cols.svg", - title="Strided Cols: (8,4):(8,2)") + draw_layout(strided_cols, output / "slice_strided_cols.svg", title="Strided Cols: (8,4):(8,2)") print(f"✓ Strided columns: every other column") # Diagonal-like pattern using hierarchical layout # Access elements (0,0), (1,1), (2,2), (3,3), ... diag = Layout(8, 9) # stride 9 = 8+1 gives diagonal - draw_layout(diag, output / "slice_diagonal.svg", - title="Diagonal: 8:9") + draw_layout(diag, output / "slice_diagonal.svg", title="Diagonal: 8:9") print(f"✓ Diagonal access: stride 9 (row_stride + 1)") # ========================================================================= @@ -1036,45 +1220,57 @@ def example_slicing(output: Path): # ========================================================================= print(f"\n --- Cecka Hierarchical Slicing ---") cecka_t = Layout(((3, 2), ((2, 3), 2)), ((4, 1), ((2, 15), 100))) - draw_layout(cecka_t, output / "cecka_slice_base.svg", - title=f"Tensor: {cecka_t}", flatten_hierarchical=True) - draw_layout(cecka_t, output / "cecka_slice_base_nested.svg", - title=f"Tensor: {cecka_t}", flatten_hierarchical=False, - label_hierarchy_levels=True) + draw_layout( + cecka_t, + output / "cecka_slice_base.svg", + title=f"Tensor: {cecka_t}", + flatten_hierarchical=True, + ) + draw_layout( + cecka_t, + output / "cecka_slice_base_nested.svg", + title=f"Tensor: {cecka_t}", + flatten_hierarchical=False, + label_hierarchy_levels=True, + ) print(f"✓ Base tensor: {cecka_t}") # Slice (2, None) — fix mode-0 to flat index 2, keep all of mode-1 - draw_slice(cecka_t, (2, None), output / "cecka_slice_2_None.svg", - title="(2,:)") + draw_slice(cecka_t, (2, None), output / "cecka_slice_2_None.svg", title="(2,:)") print(f"✓ Slice (2, :) — fix row to 2") # Slice (None, 5) — keep all of mode-0, fix mode-1 to flat index 5 - draw_slice(cecka_t, (None, 5), output / "cecka_slice_None_5.svg", - title="(:,5)") + draw_slice(cecka_t, (None, 5), output / "cecka_slice_None_5.svg", title="(:,5)") print(f"✓ Slice (:, 5) — fix col to 5") # Slice (2, ((0,None),None)) — fix mode-0 to 2, partially slice mode-1 - draw_slice(cecka_t, (2, ((0, None), None)), - output / "cecka_slice_2_0NN.svg", - title="(2,((0,:),:))") + draw_slice( + cecka_t, (2, ((0, None), None)), output / "cecka_slice_2_0NN.svg", title="(2,((0,:),:))" + ) print(f"✓ Slice (2, ((0,:),:)) — fix row=2, inner-col-0=0, rest free") # Slice ((None,1),(None,0)) — fix outer-row=1, inner-col-outer=0 - draw_slice(cecka_t, ((None, 1), (None, 0)), - output / "cecka_slice_N1_N0.svg", - title="((:,1),(:,0))") + draw_slice( + cecka_t, ((None, 1), (None, 0)), output / "cecka_slice_N1_N0.svg", title="((:,1),(:,0))" + ) print(f"✓ Slice ((:,1), (:,0)) — outer-row=1, mode-1 partially fixed") # Slice ((None,0),((0,None),1)) — outer-row=0, inner-col-0=0, outer-col=1 - draw_slice(cecka_t, ((None, 0), ((0, None), 1)), - output / "cecka_slice_N0_0N1.svg", - title="((:,0),((0,:),1))") + draw_slice( + cecka_t, + ((None, 0), ((0, None), 1)), + output / "cecka_slice_N0_0N1.svg", + title="((:,0),((0,:),1))", + ) print(f"✓ Slice ((:,0), ((0,:),1)) — outer-row=0, inner-0=0, outer-col=1") # Slice ((1,None),((None,0),None)) — inner-row=1, middle-col=0 - draw_slice(cecka_t, ((1, None), ((None, 0), None)), - output / "cecka_slice_1N_N0N.svg", - title="((1,:),((:,0),:))") + draw_slice( + cecka_t, + ((1, None), ((None, 0), None)), + output / "cecka_slice_1N_N0N.svg", + title="((1,:),((:,0),:))", + ) print(f"✓ Slice ((1,:), ((:,0),:)) — inner-row=1, middle-col=0") @@ -1082,6 +1278,7 @@ def example_slicing(output: Path): # Section 10: Layout Algebra Operations # ============================================================================= + def example_algebra_operations(output: Path): """Layout algebra operations: compose, complement, divide, product. @@ -1098,51 +1295,53 @@ def example_algebra_operations(output: Path): inner = Layout((4, 2), (1, 4)) outer = Layout(8, 2) composed = compose(outer, inner) - draw_layout(inner, output / "algebra_inner.svg", - title=f"Inner: {inner}") - draw_layout(composed, output / "algebra_composed.svg", - title=f"Composed: compose({outer}, {inner})") + draw_layout(inner, output / "algebra_inner.svg", title=f"Inner: {inner}") + draw_layout( + composed, output / "algebra_composed.svg", title=f"Composed: compose({outer}, {inner})" + ) print(f"✓ Composition: compose({outer}, {inner}) = {composed}") # Complement: find layout that covers remaining indices base = Layout((4, 2), (2, 1)) comp = complement(base, 16) - draw_layout(base, output / "algebra_base.svg", - title=f"Base: {base}") - draw_layout(comp, output / "algebra_complement.svg", - title=f"Complement: complement({base}, 16)") + draw_layout(base, output / "algebra_base.svg", title=f"Base: {base}") + draw_layout( + comp, output / "algebra_complement.svg", title=f"Complement: complement({base}, 16)" + ) print(f"✓ Complement: complement({base}, 16) = {comp}") # Logical divide: tile a layout matrix = Layout((8, 8), (8, 1)) tiler = Layout((2, 2), (1, 2)) divided = logical_divide(matrix, tiler) - draw_layout(matrix, output / "algebra_matrix.svg", - title=f"Matrix: {matrix}") - draw_layout(divided, output / "algebra_divided.svg", - title=f"Divided: logical_divide by {tiler}") + draw_layout(matrix, output / "algebra_matrix.svg", title=f"Matrix: {matrix}") + draw_layout( + divided, output / "algebra_divided.svg", title=f"Divided: logical_divide by {tiler}" + ) print(f"✓ Logical divide: 8×8 by 2×2 tiler") # Logical product: replicate a layout tile = Layout((2, 2), (2, 1)) grid = Layout((4, 4), (1, 4)) product = logical_product(tile, grid) - draw_layout(tile, output / "algebra_tile.svg", - title=f"Tile: {tile}") - draw_layout(product, output / "algebra_product.svg", - title=f"Product: logical_product({tile}, {grid})") + draw_layout(tile, output / "algebra_tile.svg", title=f"Tile: {tile}") + draw_layout( + product, output / "algebra_product.svg", title=f"Product: logical_product({tile}, {grid})" + ) print(f"✓ Logical product: {tile} × {grid}") # Rank >= 3 results: flat_divide and flat_product produce rank-3 layouts # that are now automatically rendered as multi-panel 2D grids fd = flat_divide(matrix, Layout(2, 1)) - draw_layout(fd, output / "algebra_flat_divide.svg", - title=f"flat_divide result (rank {rank(fd)})") + draw_layout( + fd, output / "algebra_flat_divide.svg", title=f"flat_divide result (rank {rank(fd)})" + ) print(f"✓ flat_divide: shape={fd.shape}, rank={rank(fd)} → multi-panel") fp = flat_product(Layout((2, 2), (1, 2)), Layout(4, 1)) - draw_layout(fp, output / "algebra_flat_product.svg", - title=f"flat_product result (rank {rank(fp)})") + draw_layout( + fp, output / "algebra_flat_product.svg", title=f"flat_product result (rank {rank(fp)})" + ) print(f"✓ flat_product: shape={fp.shape}, rank={rank(fp)} → multi-panel") @@ -1150,6 +1349,7 @@ def example_algebra_operations(output: Path): # Section 11: Tensor Slicing with Visualization # ============================================================================= + def example_tensor_slicing(output: Path): """Tensor slicing - visualizing tensors directly. @@ -1174,10 +1374,12 @@ def example_tensor_slicing(output: Path): print(f"✓ Offset tensor (offset=16): cell (0,0) = {tensor_16(0, 0)}") # Side-by-side comparison using draw_composite - draw_composite([tensor, tensor_16], - output / "tensor_offset_compare.svg", - titles=["offset=0", "offset=16"], - main_title="Tensor Offset Comparison") + draw_composite( + [tensor, tensor_16], + output / "tensor_offset_compare.svg", + titles=["offset=0", "offset=16"], + main_title="Tensor Offset Comparison", + ) print(f"✓ Tensor comparison: tensor_offset_compare.svg") # Swizzled tensor — swizzle applied to total linear offset @@ -1191,14 +1393,14 @@ def example_tensor_slicing(output: Path): row2 = tensor[2, :] print(f"\n tensor[2, :] = {row2}") print(f" tensor[2, :](0) = {row2(0)}, tensor(2, 0) = {tensor(2, 0)}") - draw_layout(row2, output / "tensor_slice_row2.svg", - title=f"tensor[2, :] = {row2}") + draw_layout(row2, output / "tensor_slice_row2.svg", title=f"tensor[2, :] = {row2}") # ============================================================================= # Main Entry Point # ============================================================================= + def main(output_dir: str = "examples_output"): """Run all visualization examples.""" output = setup_output_dir(output_dir) diff --git a/src/tensor_layouts/analysis.py b/src/tensor_layouts/analysis.py index 2bc5d02..de24cf4 100644 --- a/src/tensor_layouts/analysis.py +++ b/src/tensor_layouts/analysis.py @@ -52,6 +52,7 @@ "atom_summary", "operand_analysis", "explain", + "to_F2_matrix", ] @@ -1069,3 +1070,119 @@ def explain(fn, *args): text = '\n'.join(lines) print(text) return text + + +# ============================================================================= +# F2 linear layout matrix +# ============================================================================= +# +# A layout with power-of-2 shapes is a linear map over GF(2). Each +# coordinate bit maps to an offset bit via a binary matrix M such that +# offset_bits = M @ coord_bits (mod 2). +# +# Swizzles (XOR operations) are also linear over F2, so they fold +# naturally into the matrix. +# +# Reference: arXiv 2603.02298, Section 2.4.4 +# + + +def to_F2_matrix(layout: Layout) -> list[list[int]]: + """Return the F2 (binary) matrix representation of a layout. + + The layout must have power-of-2 shapes in all modes. The returned + matrix M has shape (n_offset_bits, n_coord_bits) where: + + - n_coord_bits = log2(size(layout)) + - n_offset_bits = enough bits to represent the codomain + + Each entry is 0 or 1. The mapping is: + ``offset_bits = M @ coord_bits (mod 2)`` + + Columns correspond to coordinate bits in colexicographic order + (mode 0 LSB first, then mode 1, etc.). Rows correspond to offset + bits (LSB at row 0). + + When the layout has a swizzle, it is folded into the matrix (XOR + is linear over F2). + + Args: + layout: Layout with power-of-2 shapes. + + Returns: + List of lists representing the binary matrix (row-major). + + Raises: + ValueError: If any shape is not a power of 2. + + Examples: + # Identity layout + to_F2_matrix(Layout(4, 1)) + # [[1, 0], [0, 1]] — 2x2 identity + + # Row-major 4x8 + to_F2_matrix(Layout((4, 8), (8, 1))) + # 5x5 permutation matrix (swaps row/col bit groups) + + # Swizzled layout — swizzle folds into the matrix + to_F2_matrix(compose(Swizzle(3, 0, 3), Layout((8, 8), (8, 1)))) + """ + flat = flatten(layout) + if is_int(flat.shape): + shapes = [flat.shape] + strides = [flat.stride] + else: + shapes = list(flat.shape) + strides = list(flat.stride) + + # Validate: all shapes must be powers of 2 + for s in shapes: + if s < 1 or (s & (s - 1)) != 0: + raise ValueError( + f"Shape {s} is not a power of 2; " + f"F2 matrix requires all shapes to be powers of 2" + ) + + # Number of coordinate bits + n_coord_bits = sum(s.bit_length() - 1 for s in shapes) + + # Determine number of offset bits from cosize + cs = cosize(layout) + n_offset_bits = max((cs - 1).bit_length(), 1) if cs > 1 else 1 + + # Build columns: coordinate bit j has value stride_i * 2^b + col_values = [] + for s, d in zip(shapes, strides): + n_bits = s.bit_length() - 1 # log2(s) + for b in range(n_bits): + col_values.append(d * (1 << b)) + + # Build the matrix (n_offset_bits × n_coord_bits) + M = [[0] * n_coord_bits for _ in range(n_offset_bits)] + for j, val in enumerate(col_values): + for i in range(n_offset_bits): + M[i][j] = (val >> i) & 1 + + # Fold in swizzle: Swizzle(bits, base, shift) XORs offset bits + # [base, base+bits) with [base+shift, base+shift+bits). + # In F2: row[base+k] += row[base+shift+k] (mod 2) + # This is a post-composition: M' = S @ M + if layout.swizzle is not None: + sw = layout.swizzle + # Build swizzle matrix S (identity + XOR connections) + S = [[1 if i == j else 0 for j in range(n_offset_bits)] + for i in range(n_offset_bits)] + for k in range(sw.bits): + src = sw.base + sw.shift + k + dst = sw.base + k + if src < n_offset_bits and dst < n_offset_bits: + S[dst][src] = 1 + # Compose: M' = S @ M (mod 2) + M = [ + [sum(S[i][k] * M[k][j] for k in range(n_offset_bits)) % 2 + for j in range(n_coord_bits)] + for i in range(n_offset_bits) + ] + + return M + diff --git a/src/tensor_layouts/atoms_amd.py b/src/tensor_layouts/atoms_amd.py index 4356eb4..b96e93b 100644 --- a/src/tensor_layouts/atoms_amd.py +++ b/src/tensor_layouts/atoms_amd.py @@ -20,10 +20,13 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -"""AMD CDNA MFMA (Matrix Fused Multiply-Add) atom definitions. +"""AMD CDNA MFMA and RDNA WMMA atom definitions. -Mirrors the lane-to-element mapping of AMD's MFMA instructions on CDNA -architectures (CDNA1/gfx908, CDNA2/gfx90a, CDNA3/gfx942, CDNA3+/gfx950). +Mirrors the lane-to-element mapping of AMD's matrix multiply instructions: + - **MFMA** (Matrix Fused Multiply-Add) on CDNA architectures + (CDNA1/gfx908, CDNA2/gfx90a, CDNA3/gfx942, CDNA3+/gfx950) — wave64 + - **WMMA** (Wave Matrix Multiply-Accumulate) on RDNA architectures + (RDNA3/gfx1100, RDNA4/gfx1200) — wave32 Each MFMA atom maps (thread_idx, value_idx) -> element coordinate using column-major encoding: @@ -46,6 +49,14 @@ - AMD Matrix Cores blog: https://gpuopen.com/learn/amd-lab-notes/amd-lab-notes-matrix-cores-readme/ +.. note:: Community feedback welcome + + These atom definitions were derived from public ISA documentation and + cross-checked against AMD's matrix instruction calculator where possible. + If you find an incorrect mapping, please open an issue at + https://github.com/facebookresearch/tensor-layouts/issues — both bug + reports and confirmations that layouts match real hardware are valuable. + MFMA Register Layout ===================== @@ -774,3 +785,245 @@ def make_mfma_atom( CDNA3P_32x32x32_I32I8I8_MFMA, CDNA3P_16x16x64_I32I8I8_MFMA, ] + + +# ============================================================================= +# RDNA WMMA (Wave Matrix Multiply-Accumulate) — wave32 +# +# WMMA operates on a wave32 (32 lanes), unlike CDNA MFMA which uses wave64. +# All WMMA variants produce a 16×16 output tile. +# +# WMMA Register Layout +# -------------------- +# +# The 16×16 output (C/D) is distributed across 32 lanes with 8 values +# per lane (32 × 8 = 256 = 16 × 16): +# +# lane t (0..31): +# row_group = t // 16 (0 or 1 — upper or lower 8 rows) +# col = t % 16 (column 0..15) +# value v (0..7): +# row = row_group * 8 + v +# +# col-major offset = row + col * 16 +# +# The A and B inputs (each rows × K) are distributed similarly: +# +# lane t (0..31): +# row = t % 16 (which row, 0..15) +# k_group = t // 16 (0 or 1 — first or second K-half) +# value v (0..V-1): +# k = k_group * V + v (V = K/2 values per lane) +# +# col-major offset = row + k * rows +# +# References: +# - AMD RDNA3/RDNA4 ISA Reference Guides (publicly available from GPUOpen) +# - AMD Matrix Instruction Calculator: +# https://github.com/ROCm/amd_matrix_instruction_calculator +# - rocWMMA library: https://github.com/ROCm/rocWMMA +# ============================================================================= + + +def _wmma_c_layout(m: int, n: int) -> Layout: + """Build the (T32, V8) -> col-major(M, N) accumulator layout. + + Thread (2, 16) decomposition: + row_group = t // 16 (0 or 1) + col = t % 16 (0..15) + + Value 8: + row = row_group * 8 + v + + offset = row + col * M + = (row_group * 8 + v) + col * M + """ + half_m = m // 2 # rows per row_group = 8 + return Layout( + ((2, n), half_m), + ((half_m, m), 1), + ) + + +def _wmma_input_layout(rows: int, k: int) -> Layout: + """Build the (T32, V) -> col-major(rows, K) input layout for A or B. + + Thread (2, 16) decomposition: + row = t % 16 (which row) + k_group = t // 16 (0 or 1) + + Value (K // 2): + k = k_group * (K // 2) + v + + offset = row + k * rows + = row + (k_group * V + v) * rows + """ + v_per_lane = k // 2 + return Layout( + ((2, rows), v_per_lane), + ((v_per_lane * rows, 1), rows), + ) + + +def make_wmma_atom( + name: str, + inst: str, + m: int, + n: int, + k: int, +) -> MMAAtom: + """Create an AMD RDNA WMMA atom. + + All WMMA variants use wave32 with the same structural mapping; + only M, N, K dimensions vary. + """ + wave_size = 32 + + if m != 16 or n != 16: + raise ValueError(f"WMMA requires M=N=16, got M={m}, N={n}") + if k % 2 != 0: + raise ValueError(f"WMMA K must be even, got K={k}") + if m * n != wave_size * (m // 2): + raise ValueError(f"M*N ({m * n}) != wave_size * V ({wave_size * m // 2})") + + c_layout = _wmma_c_layout(m, n) + a_layout = _wmma_input_layout(m, k) + b_layout = _wmma_input_layout(n, k) + + return MMAAtom( + name=name, + ptx=inst, + shape_mnk=(m, n, k), + thr_id=None, # identity: lane_id = thread_idx % 32 + a_layout=a_layout, + b_layout=b_layout, + c_layout=c_layout, + ) + + +# ============================================================================= +# RDNA3 (gfx1100/gfx1101) — WMMA 16×16×16 atoms +# ============================================================================= + +# --- FP16 --- +RDNA3_16x16x16_F32F16F16_WMMA = make_wmma_atom( + name="RDNA3_16x16x16_F32F16F16_WMMA", + inst="v_wmma_f32_16x16x16_f16", + m=16, n=16, k=16, +) + +RDNA3_16x16x16_F16F16F16_WMMA = make_wmma_atom( + name="RDNA3_16x16x16_F16F16F16_WMMA", + inst="v_wmma_f16_16x16x16_f16", + m=16, n=16, k=16, +) + +# --- BF16 --- +RDNA3_16x16x16_F32BF16BF16_WMMA = make_wmma_atom( + name="RDNA3_16x16x16_F32BF16BF16_WMMA", + inst="v_wmma_f32_16x16x16_bf16", + m=16, n=16, k=16, +) + +RDNA3_16x16x16_BF16BF16BF16_WMMA = make_wmma_atom( + name="RDNA3_16x16x16_BF16BF16BF16_WMMA", + inst="v_wmma_bf16_16x16x16_bf16", + m=16, n=16, k=16, +) + +# --- INT8 --- +RDNA3_16x16x16_I32I8I8_WMMA = make_wmma_atom( + name="RDNA3_16x16x16_I32I8I8_WMMA", + inst="v_wmma_i32_16x16x16_iu8", + m=16, n=16, k=16, +) + +# --- INT4 --- +RDNA3_16x16x16_I32I4I4_WMMA = make_wmma_atom( + name="RDNA3_16x16x16_I32I4I4_WMMA", + inst="v_wmma_i32_16x16x16_iu4", + m=16, n=16, k=16, +) + + +# ============================================================================= +# RDNA4 (gfx1200) — WMMA 16×16×32 atoms (doubled K) +# ============================================================================= + +# --- FP16 --- +RDNA4_16x16x32_F32F16F16_WMMA = make_wmma_atom( + name="RDNA4_16x16x32_F32F16F16_WMMA", + inst="v_wmma_f32_16x16x32_f16", + m=16, n=16, k=32, +) + +RDNA4_16x16x32_F16F16F16_WMMA = make_wmma_atom( + name="RDNA4_16x16x32_F16F16F16_WMMA", + inst="v_wmma_f16_16x16x32_f16", + m=16, n=16, k=32, +) + +# --- BF16 --- +RDNA4_16x16x32_F32BF16BF16_WMMA = make_wmma_atom( + name="RDNA4_16x16x32_F32BF16BF16_WMMA", + inst="v_wmma_f32_16x16x32_bf16", + m=16, n=16, k=32, +) + +RDNA4_16x16x32_BF16BF16BF16_WMMA = make_wmma_atom( + name="RDNA4_16x16x32_BF16BF16BF16_WMMA", + inst="v_wmma_bf16_16x16x32_bf16", + m=16, n=16, k=32, +) + +# --- FP8 (new in RDNA4) --- +RDNA4_16x16x32_F32F8F8_WMMA = make_wmma_atom( + name="RDNA4_16x16x32_F32F8F8_WMMA", + inst="v_wmma_f32_16x16x32_fp8_fp8", + m=16, n=16, k=32, +) + +RDNA4_16x16x32_F32BF8BF8_WMMA = make_wmma_atom( + name="RDNA4_16x16x32_F32BF8BF8_WMMA", + inst="v_wmma_f32_16x16x32_bf8_bf8", + m=16, n=16, k=32, +) + +# --- INT8 (doubled K) --- +RDNA4_16x16x32_I32I8I8_WMMA = make_wmma_atom( + name="RDNA4_16x16x32_I32I8I8_WMMA", + inst="v_wmma_i32_16x16x32_iu8", + m=16, n=16, k=32, +) + +# --- INT4 (quadrupled K) --- +RDNA4_16x16x64_I32I4I4_WMMA = make_wmma_atom( + name="RDNA4_16x16x64_I32I4I4_WMMA", + inst="v_wmma_i32_16x16x64_iu4", + m=16, n=16, k=64, +) + + +# ============================================================================= +# Convenience lists — RDNA WMMA +# ============================================================================= + +MMA_ATOMS_RDNA3 = [ + RDNA3_16x16x16_F32F16F16_WMMA, + RDNA3_16x16x16_F16F16F16_WMMA, + RDNA3_16x16x16_F32BF16BF16_WMMA, + RDNA3_16x16x16_BF16BF16BF16_WMMA, + RDNA3_16x16x16_I32I8I8_WMMA, + RDNA3_16x16x16_I32I4I4_WMMA, +] + +MMA_ATOMS_RDNA4 = [ + RDNA4_16x16x32_F32F16F16_WMMA, + RDNA4_16x16x32_F16F16F16_WMMA, + RDNA4_16x16x32_F32BF16BF16_WMMA, + RDNA4_16x16x32_BF16BF16BF16_WMMA, + RDNA4_16x16x32_F32F8F8_WMMA, + RDNA4_16x16x32_F32BF8BF8_WMMA, + RDNA4_16x16x32_I32I8I8_WMMA, + RDNA4_16x16x64_I32I4I4_WMMA, +] diff --git a/src/tensor_layouts/atoms_amx.py b/src/tensor_layouts/atoms_amx.py index c7b05b4..53f5a2f 100644 --- a/src/tensor_layouts/atoms_amx.py +++ b/src/tensor_layouts/atoms_amx.py @@ -65,6 +65,13 @@ - Intel 64 and IA-32 Architectures Software Developer's Manual (SDM), Volume 2 -- Instruction Set Reference +.. note:: Community feedback welcome + + These atom definitions were derived from public Intel ISA documentation. + If you find an incorrect mapping, please open an issue at + https://github.com/facebookresearch/tensor-layouts/issues — both bug + reports and confirmations that layouts match real hardware are valuable. + Usage:: from tensor_layouts.atoms_amx import AMX_16x16x32_F32BF16BF16F32 diff --git a/src/tensor_layouts/atoms_nv.py b/src/tensor_layouts/atoms_nv.py index 91a8bc7..1c06bba 100644 --- a/src/tensor_layouts/atoms_nv.py +++ b/src/tensor_layouts/atoms_nv.py @@ -46,6 +46,14 @@ §9.7.13 Matrix Multiply-Accumulate §9.7.12 Matrix Load/Store +.. note:: Community feedback welcome + + These atom definitions were derived from NVIDIA CUTLASS source and PTX + ISA documentation. If you find an incorrect mapping, please open an + issue at https://github.com/facebookresearch/tensor-layouts/issues — + both bug reports and confirmations that layouts match real hardware are + valuable. + Usage: from tensor_layouts.atoms_nv import SM70_8x8x4_F32F16F16F32_NT, SM80_16x8x8_F16F16F16F16_TN print(SM70_8x8x4_F32F16F16F32_NT.a_layout) diff --git a/src/tensor_layouts/atoms_xe.py b/src/tensor_layouts/atoms_xe.py new file mode 100644 index 0000000..04c7b28 --- /dev/null +++ b/src/tensor_layouts/atoms_xe.py @@ -0,0 +1,240 @@ +# MIT License +# +# Copyright (c) 2026 Meta Platforms, Inc. and affiliates. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +"""Intel Xe GPU DPAS (Dot Product Accumulate Systolic) atom definitions. + +Mirrors the lane-to-element mapping of Intel's DPAS instruction on Xe +architectures: + - Xe-HPC (Ponte Vecchio / Data Center Max): subgroup_size = 8 + - Xe-HPG (Arc / DG2): subgroup_size = 16 + +Each DPAS atom maps (thread_idx, value_idx) -> element coordinate using +column-major encoding: + A: (T, V) -> m + k*M in the M × K matrix + B: (T, V) -> n + k*N in the N × K matrix + C: (T, V) -> m + n*M in the M × N matrix + +DPAS Register Layout +==================== + +DPAS is a subgroup-cooperative systolic instruction: + + dpas.{systolic_depth}x{repeat_count} (exec_size) dst src0 src1 src2 + + systolic_depth (sd): 8 (fixed on all Xe architectures) — the K dimension + repeat_count (rc): 1–8 — the M dimension (typically 8 for peak throughput) + exec_size: N dimension = subgroup_size (8 for Xe-HPC, 16 for Xe-HPG) + +C accumulator (M × N): + Each work item (lane t) owns one column of C. + Value v (0..rc-1) selects the row. + + col = t, row = v + offset = row + col * M = v + t * M + +A operand (M × K): + A is broadcast across the subgroup — all lanes see the same A data. + Thread dimension has stride 0. + + offset = m + k * M (col-major in M × K) + +B operand (N × K, CuTe convention): + Each lane t owns one column of B (one N-position). + Value v selects the K-position. + + n = t, k = v + offset = n + k * N = t + v * N + +References +---------- + +- Intel Graphics Compiler (IGC) VISA specification: DPAS.md + https://github.com/intel/intel-graphics-compiler/blob/master/documentation/visa/instructions/DPAS.md +- Khronos OpenCL extension: cl_intel_subgroup_matrix_multiply_accumulate +- Intel XeTLA (Xe Templates for Linear Algebra): + https://intel.github.io/xetla/ +- CUTLASS experimental Xe backend (CuTe atom definitions for DPAS) + +.. note:: Community feedback welcome + + These atom definitions were derived from public Intel ISA documentation + and the CUTLASS experimental Xe backend. If you find an incorrect + mapping, please open an issue at + https://github.com/facebookresearch/tensor-layouts/issues — both bug + reports and confirmations that layouts match real hardware are valuable. + +Usage:: + + from tensor_layouts.atoms_xe import XeHPC_8x8x8_F32F16F16_DPAS + print(XeHPC_8x8x8_F32F16F16_DPAS.c_layout) +""" + +from .atoms import MMAAtom +from .layouts import Layout + + +# ============================================================================= +# Helper: construct CuTe layouts from DPAS structural parameters +# ============================================================================= + +def _dpas_c_layout(m: int, n: int) -> Layout: + """Build the (T_n, V_m) -> col-major(M, N) accumulator layout. + + Lane t owns column t, value v selects row v. + offset = v + t * M + """ + return Layout( + (n, m), + (m, 1), + ) + + +def _dpas_a_layout(m: int, k: int, n: int) -> Layout: + """Build the (T_n, V_{m*k}) -> col-major(M, K) input layout for A. + + A is broadcast across the subgroup (stride 0 on thread dimension). + All lanes see the same M × K tile. + """ + return Layout( + (n, (m, k)), + (0, (1, m)), + ) + + +def _dpas_b_layout(n: int, k: int) -> Layout: + """Build the (T_n, V_k) -> col-major(N, K) input layout for B. + + Lane t owns column t (N dimension), value v selects K position. + offset = t + v * N + """ + return Layout( + (n, k), + (1, n), + ) + + +def make_dpas_atom( + name: str, + inst: str, + m: int, + n: int, + k: int, +) -> MMAAtom: + """Create an Intel Xe DPAS atom. + + Args: + m: repeat_count (rows of output, typically 8) + n: exec_size = subgroup_size (8 for Xe-HPC, 16 for Xe-HPG) + k: systolic_depth (always 8 on current Xe) + """ + c_layout = _dpas_c_layout(m, n) + a_layout = _dpas_a_layout(m, k, n) + b_layout = _dpas_b_layout(n, k) + + return MMAAtom( + name=name, + ptx=inst, + shape_mnk=(m, n, k), + thr_id=None, # identity: lane_id = thread_idx % subgroup_size + a_layout=a_layout, + b_layout=b_layout, + c_layout=c_layout, + ) + + +# ============================================================================= +# Xe-HPC (Ponte Vecchio / Data Center Max) — subgroup_size = 8 +# DPAS shape: rc × 8 × sd = 8 × 8 × 8 +# ============================================================================= + +# --- FP16 input, FP32 accumulator --- +XeHPC_8x8x8_F32F16F16_DPAS = make_dpas_atom( + name="XeHPC_8x8x8_F32F16F16_DPAS", + inst="dpas.8x8 (exec_size=8, FP16)", + m=8, n=8, k=8, +) + +# --- BF16 input, FP32 accumulator --- +XeHPC_8x8x8_F32BF16BF16_DPAS = make_dpas_atom( + name="XeHPC_8x8x8_F32BF16BF16_DPAS", + inst="dpas.8x8 (exec_size=8, BF16)", + m=8, n=8, k=8, +) + +# --- TF32 input, FP32 accumulator --- +XeHPC_8x8x8_F32TF32TF32_DPAS = make_dpas_atom( + name="XeHPC_8x8x8_F32TF32TF32_DPAS", + inst="dpas.8x8 (exec_size=8, TF32)", + m=8, n=8, k=8, +) + +# --- INT8 input, INT32 accumulator --- +XeHPC_8x8x8_I32I8I8_DPAS = make_dpas_atom( + name="XeHPC_8x8x8_I32I8I8_DPAS", + inst="dpas.8x8 (exec_size=8, INT8)", + m=8, n=8, k=8, +) + + +# ============================================================================= +# Xe-HPG (Arc / DG2) — subgroup_size = 16 +# DPAS shape: rc × 16 × sd = 8 × 16 × 8 +# ============================================================================= + +# --- FP16 input, FP32 accumulator --- +XeHPG_8x16x8_F32F16F16_DPAS = make_dpas_atom( + name="XeHPG_8x16x8_F32F16F16_DPAS", + inst="dpas.8x8 (exec_size=16, FP16)", + m=8, n=16, k=8, +) + +# --- BF16 input, FP32 accumulator --- +XeHPG_8x16x8_F32BF16BF16_DPAS = make_dpas_atom( + name="XeHPG_8x16x8_F32BF16BF16_DPAS", + inst="dpas.8x8 (exec_size=16, BF16)", + m=8, n=16, k=8, +) + +# --- INT8 input, INT32 accumulator --- +XeHPG_8x16x8_I32I8I8_DPAS = make_dpas_atom( + name="XeHPG_8x16x8_I32I8I8_DPAS", + inst="dpas.8x8 (exec_size=16, INT8)", + m=8, n=16, k=8, +) + + +# ============================================================================= +# Convenience lists +# ============================================================================= + +MMA_ATOMS_XeHPC = [ + XeHPC_8x8x8_F32F16F16_DPAS, + XeHPC_8x8x8_F32BF16BF16_DPAS, + XeHPC_8x8x8_F32TF32TF32_DPAS, + XeHPC_8x8x8_I32I8I8_DPAS, +] + +MMA_ATOMS_XeHPG = [ + XeHPG_8x16x8_F32F16F16_DPAS, + XeHPG_8x16x8_F32BF16BF16_DPAS, + XeHPG_8x16x8_I32I8I8_DPAS, +] diff --git a/src/tensor_layouts/layouts.py b/src/tensor_layouts/layouts.py index 8c637ad..f9be863 100644 --- a/src/tensor_layouts/layouts.py +++ b/src/tensor_layouts/layouts.py @@ -168,6 +168,7 @@ "is_injective", "is_surjective", "is_bijective", + "is_contiguous", # Functional equivalence "functionally_equal", ] @@ -374,6 +375,17 @@ def _validate_shape_type(x, name: str) -> None: raise TypeError(f"Layout {name} must be int or tuple of ints, got {type(x).__name__}") +def _fmt_shape(x): + """Format a shape/stride without Python's trailing-comma for 1-tuples. + + Python renders ``((4, 2),)`` for a 1-element tuple, but CuTe notation + uses ``((4, 2))`` which is cleaner for human readers. + """ + if isinstance(x, int): + return str(x) + return "(" + ", ".join(_fmt_shape(e) for e in x) + ")" + + class Layout: """A function from logical coordinates to memory offsets: offset = sum(coord_i * stride_i). @@ -472,13 +484,7 @@ def __repr__(self): def __str__(self): """Return human-readable CuTe notation: (4, 2) : (1, 4).""" - - def fmt(x): - if isinstance(x, int): - return str(x) - return repr(x) - - base = f"{fmt(self._shape)} : {fmt(self._stride)}" + base = f"{_fmt_shape(self._shape)} : {_fmt_shape(self._stride)}" if self._swizzle is not None: return f"({self._swizzle}) o ({base})" return base @@ -655,6 +661,8 @@ def size(obj: Any) -> int: """Returns the logical number of elements (product of shape).""" if isinstance(obj, Layout): return size(obj.shape) + if hasattr(obj, 'layout'): # Tensor or any layout-backed object + return size(obj.layout) if is_tuple(obj) or is_int(obj): return fold(obj, 1, lambda acc, x: acc * x) raise TypeError(f"Cannot calculate size of {type(obj).__name__}") @@ -662,6 +670,8 @@ def size(obj: Any) -> int: def cosize(obj: Layout) -> int: """Returns the memory span (max_offset + 1).""" + if hasattr(obj, 'layout') and not isinstance(obj, Layout): + return cosize(obj.layout) if is_int(obj.shape): return obj._calculate_max_offset(obj.shape, obj.stride) + 1 if len(obj.shape) == 0: @@ -670,6 +680,8 @@ def cosize(obj: Layout) -> int: def rank(obj: Any) -> int: + if hasattr(obj, 'layout') and not isinstance(obj, Layout): + return rank(obj.layout) if is_tuple(obj): return len(obj) if isinstance(obj, Layout): @@ -690,6 +702,8 @@ def depth(obj: Any) -> int: """ if isinstance(obj, Layout): return depth(obj.shape) + if hasattr(obj, 'layout'): + return depth(obj.layout) if is_int(obj): return 0 if is_tuple(obj): @@ -700,6 +714,8 @@ def depth(obj: Any) -> int: def mode(obj: Any, idx): + if hasattr(obj, 'layout') and not isinstance(obj, Layout): + return mode(obj.layout, idx) if is_tuple(obj): if not obj: return () @@ -849,6 +865,7 @@ def iter_layout(layout: Layout): # is_injective -- no two coordinates map to the same offset # is_surjective -- every offset in the codomain is hit # is_bijective -- both (the layout is a permutation) +# is_contiguous -- maps to [0, size) with no gaps or aliasing (== bijective) # @@ -865,6 +882,8 @@ def image(layout: Layout) -> list: image(Layout(4, 2)) # [0, 2, 4, 6] image(Layout((4, 2), (0, 1))) # [0, 1] (broadcast) """ + if hasattr(layout, 'layout') and not isinstance(layout, Layout): + return image(layout.layout) return sorted({layout(i) for i in range(size(layout))}) @@ -918,6 +937,26 @@ def is_bijective(layout: Layout) -> bool: return len(img) == size(layout) and len(img) == cosize(layout) +def is_contiguous(layout: Layout) -> bool: + """True if the layout maps to the dense range [0, size). + + A contiguous layout visits every offset in ``{0, 1, ..., size-1}`` + exactly once. Equivalently, ``size == cosize`` and the layout is + injective — there are no gaps and no aliasing. + + This is the same as :func:`is_bijective` but named for readability + when the question is "does this layout occupy a contiguous block of + memory starting at offset 0?" + + Examples: + is_contiguous(Layout(4, 1)) # True + is_contiguous(Layout((2, 2), (2, 1))) # True (row-major 2x2) + is_contiguous(Layout(4, 2)) # False (gaps) + is_contiguous(Layout((4, 2), (0, 1))) # False (aliasing) + """ + return is_bijective(layout) + + # ============================================================================= # Functional equivalence # ============================================================================= @@ -1029,6 +1068,8 @@ def _flatten(s): return (obj,) if is_tuple(obj): return _flatten(obj) + if hasattr(obj, 'layout') and not isinstance(obj, Layout): + return flatten(obj.layout) elif isinstance(obj, Layout): flat_shape = _flatten(obj.shape) flat_stride = _flatten(obj.stride) @@ -1837,7 +1878,13 @@ def slice_and_offset(crd, layout: Layout): """ sliced_shape = slice_modes(crd, layout.shape) sliced_stride = slice_modes(crd, layout.stride) - # slice_modes returns tuples that preserve structure; pass directly to Layout + # When slicing drops some top-level modes, a single surviving hierarchical + # mode can end up wrapped in a spurious outer tuple, e.g. ((3,2),). + # Unwrap it so the result is (3,2) — but only when the single element is + # itself a tuple (hierarchical); scalar modes like (4,) must stay wrapped. + if len(sliced_shape) == 1 and is_tuple(sliced_shape[0]): + sliced_shape = sliced_shape[0] + sliced_stride = sliced_stride[0] sublayout = Layout( sliced_shape if sliced_shape else (), sliced_stride if sliced_stride else (), @@ -1867,6 +1914,9 @@ def slice_and_offset(crd, layout: Layout): def idx2crd(coord: Any, shape: Any) -> Any: """Convert index into a hierarchical coordinate.""" + if isinstance(shape, Layout): + shape = shape.shape + if isinstance(shape, int): if isinstance(coord, int): return coord % shape @@ -1900,6 +1950,9 @@ def crd2flat(coord: Any, shape: Any = None) -> int: Example: crd2flat((1, 1), (4, 4)) -> 5 """ + if isinstance(shape, Layout): + shape = shape.shape + if isinstance(shape, int): if is_tuple(coord): raise ValueError(f"Cannot map coordinate {coord} to scalar shape {shape}") @@ -2010,9 +2063,10 @@ def crd2crd(crd: Any, dst_shape: Any, src_shape: Any = None) -> Any: src_shape: The source shape (required when crd is tuple and dst_shape is scalar) Examples: - crd2crd(3, (2, 4)) -> (1, 0) # expand index 3 into (2,4) + crd2crd(3, (2, 4)) -> (1, 1) # expand index 3 into (2,4) crd2crd((1, 0), 8, (2, 4)) -> 1 # flatten (1,0) from (2,4) space crd2crd((1, 2), (3, 4)) -> (1, 2) # identity transform + crd2crd(((0, 1), 0), (6, 2), ((2, 3), 2)) -> (2, 0) # flatten per-mode """ if is_tuple(crd): if is_tuple(dst_shape): @@ -2020,6 +2074,8 @@ def crd2crd(crd: Any, dst_shape: Any, src_shape: Any = None) -> Any: raise ValueError( f"Rank mismatch: crd has {len(crd)} elements, dst_shape has {len(dst_shape)}" ) + if src_shape is not None and is_tuple(src_shape): + return tuple(crd2crd(c, d, s) for c, d, s in zip(crd, dst_shape, src_shape)) return zip_transform(crd, dst_shape, crd2crd) else: # crd is tuple, dst_shape is scalar: flatten using src_shape @@ -2058,11 +2114,14 @@ def slice_modes(crd, trg): if is_tuple(trg): if len(crd) != len(trg): raise ValueError(f"Rank mismatch: crd has {len(crd)} elements, trg has {len(trg)}") - # Flatten and concatenate non-empty results + # Process each top-level mode independently, preserving hierarchy result = [] for c, s in zip(crd, trg): sub = slice_modes(c, s) - result.extend(sub) + if sub: + # Unwrap single-element results to avoid extra nesting, + # but keep multi-element results as a nested tuple + result.append(sub[0] if len(sub) == 1 else sub) return tuple(result) else: raise TypeError("Cannot slice scalar target with tuple coordinate") diff --git a/src/tensor_layouts/tensor.py b/src/tensor_layouts/tensor.py index 9a85618..24c0fa0 100644 --- a/src/tensor_layouts/tensor.py +++ b/src/tensor_layouts/tensor.py @@ -20,11 +20,20 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -"""Tensor class: combines a Layout with a base offset (pointer equivalent). +"""Tensor class: combines a Layout with a base offset and optional storage. In CuTe, a Tensor is (Engine/Pointer, Layout). Here we represent the pointer -as an integer offset. The Tensor holds the offset and provides slicing operations -that accumulate offset contributions while reducing the layout. +as an integer offset and optionally attach storage (any indexable object such +as a list, numpy array, or torch tensor). + +When storage is present: + - ``tensor[i, j]`` returns the data element at the computed offset + - ``tensor[i, j] = val`` writes to that position + - ``draw_layout(tensor)`` auto-labels cells with data values + - Slicing produces sub-Tensors that share the same storage (view semantics) + +When storage is absent, the Tensor is purely algebraic and ``tensor[i, j]`` +returns the integer offset (the original behavior). IMPORTANT: For swizzled layouts, the base offset is a *linear* offset that gets added to the linear coordinate-to-offset result BEFORE swizzling. @@ -36,14 +45,16 @@ class Tensor: - """A Tensor combines a base offset with a Layout. + """A Tensor combines a base offset and optional storage with a Layout. In CuTe C++, a Tensor is (Pointer, Layout) where the pointer holds the - base address into memory. Here we represent the pointer as an integer - offset, which is sufficient for the algebraic operations. + base address into memory. Here we model the pointer as an integer offset + and optionally attach a storage object so elements can be read and written + through logical coordinates. Tensor supports slicing: fixing coordinates accumulates their offset - contribution and returns a new Tensor with a reduced Layout. + contribution and returns a new Tensor with a reduced Layout. Sub-Tensors + produced by slicing share the parent's storage (view semantics). IMPORTANT: For swizzled layouts, the offset is a *linear* offset. The swizzle is applied to (linear_offset + linear_layout_result) at @@ -57,16 +68,36 @@ class Tensor: Args: layout: The Layout describing the coordinate-to-offset mapping offset: The base offset in linear (pre-swizzle) space (default 0) + data: Optional storage (any indexable object — list, numpy array, + torch tensor, etc.). Must satisfy ``len(data) >= cosize(layout)``. + Stored by reference (no copy). Examples: - t = Tensor(Layout((8, 8), (8, 1))) - t(3, 5) -> offset for coordinate (3, 5) - t[3, :] -> Tensor with row 3's offset and column layout + Algebraic (no storage):: + + t = Tensor(Layout((4, 8), (8, 1))) + t(3, 5) # 29 — memory offset + t[3, :] # Tensor with row 3's offset and column layout + t[3, 5] # 29 — all modes fixed, returns int offset + + With storage:: + + t = Tensor(Layout((4, 8), (8, 1)), data=list(range(32))) + t[2, 3] # data[2*8 + 3] = data[19] → 19 + t[2, :][3] # same result via slicing + t[0, 0] = 99 # writes data[0] = 99 + t.data = list(range(100, 132)) # swap storage """ - def __init__(self, layout: Layout, offset: int = 0): + def __init__(self, layout: Layout, offset: int = 0, data=None): self._layout = layout self._offset = offset + if data is not None and len(data) < cosize(self._layout): + raise ValueError( + f"Storage length {len(data)} is smaller than " + f"layout cosize {cosize(self._layout)}" + ) + self._data = data @property def layout(self) -> Layout: @@ -84,15 +115,65 @@ def shape(self): def stride(self): return self._layout.stride + @property + def data(self): + """The backing storage, or None if this is a purely algebraic Tensor. + + Assignable: ``tensor.data = new_array`` replaces the storage reference. + The new storage must satisfy ``len(new_data) >= cosize(layout)``. + + Note: sub-Tensors produced by slicing hold their own reference to the + storage object. Reassigning ``parent.data`` does *not* update existing + sub-Tensors (they keep the old reference). This matches numpy/torch + view semantics. + """ + return self._data + + @data.setter + def data(self, value): + if value is not None and len(value) < cosize(self._layout): + raise ValueError( + f"Storage length {len(value)} is smaller than " + f"layout cosize {cosize(self._layout)}" + ) + self._data = value + + def view(self, layout: Layout) -> "Tensor": + """Return a new Tensor sharing this storage with a different layout. + + The new layout's cosize must not exceed the current storage size. + """ + if self._data is None: + raise TypeError("Cannot create a view of a Tensor with no storage") + if cosize(layout) > len(self._data): + raise ValueError( + f"New layout cosize {cosize(layout)} exceeds " + f"storage length {len(self._data)}" + ) + return Tensor(layout, data=self._data) + def __repr__(self) -> str: if self._offset: return f"Tensor({self._layout}, offset={self._offset})" return f"Tensor({self._layout})" + def __str__(self) -> str: + return f"{{{self._offset}}} ∘ {self._layout}" + def __eq__(self, other: object) -> bool: if not isinstance(other, Tensor): return False - return self._layout == other._layout and self._offset == other._offset + if self._layout != other._layout or self._offset != other._offset: + return False + if self._data is None and other._data is None: + return True + if self._data is None or other._data is None: + return False + if self._data is other._data: + return True + return len(self._data) == len(other._data) and all( + a == b for a, b in zip(self._data, other._data) + ) def __hash__(self): return hash((self._layout, self._offset)) @@ -118,21 +199,53 @@ def __call__(self, *args) -> int: return total_linear def __getitem__(self, key): - """Slice the tensor by fixing some coordinates. + """Access a data element or slice the tensor. - Fixed coordinates contribute to the offset; free coordinates (:) - remain in the resulting tensor's layout. + A bare integer performs **flat 1D evaluation**: the index is + decomposed via ``idx2crd`` into the natural coordinate, and the + offset is computed. This matches CuTe C++ ``Tensor::operator()(int)`` + and is consistent with ``__setitem__``, enabling the canonical + copy loop ``dst[i] = src[i]`` on any-rank tensor. + + A tuple key performs **slicing**: fixed coordinates (ints) contribute + to the offset; free coordinates (``:`` / ``None``) remain in the + resulting sub-Tensor's layout. Examples: - tensor[3, :] -- fix mode 0 to 3, keep mode 1 - tensor[:, 5] -- keep mode 0, fix mode 1 to 5 - tensor[2, 3] -- fix both modes, returns integer offset + tensor[5] -- flat 1D evaluation → data element or offset + tensor[2, 3] -- fix all modes → data element or offset + tensor[3, :] -- fix mode 0 to 3, keep mode 1 → sub-Tensor + tensor[:, 5] -- keep mode 0, fix mode 1 to 5 → sub-Tensor """ if isinstance(key, tuple): return self._slice_multi(key) + elif isinstance(key, int): + # Flat 1D evaluation — matches CuTe C++ and __setitem__ + offset = self(key) + if self._data is not None: + return self._data[offset] + return offset else: return self._slice_single(key, 0) + def __setitem__(self, key, value): + """Write a value to storage at the given coordinates. + + Only supports fully-fixed coordinates (all modes specified as + integers). Requires storage to be present and mutable. + + Examples: + tensor[2, 3] = 42 # writes data[tensor(2, 3)] = 42 + tensor[5] = 99 # rank-1 tensor + """ + if self._data is None: + raise TypeError("Cannot assign to a Tensor with no storage") + if isinstance(key, tuple): + offset = self(*key) + else: + offset = self(key) + self._data[offset] = value + def _get_linear_mode_offset(self, mode_idx: int, coord) -> int: """Get the linear offset contribution from a mode (without swizzle).""" m = mode(self._layout, mode_idx) @@ -145,7 +258,8 @@ def _slice_single(self, key, mode_idx: int) -> "Tensor | int": # Slice with : (all elements) - return tensor for this mode mode_layout = mode(self._layout, mode_idx) return Tensor(Layout(mode_layout.shape, mode_layout.stride, - swizzle=self._layout.swizzle), self._offset) + swizzle=self._layout.swizzle), self._offset, + data=self._data) elif isinstance(key, (int, tuple)): # Fixed coordinate - compute the linear offset contribution return self._fix_mode(mode_idx, key) @@ -153,31 +267,58 @@ def _slice_single(self, key, mode_idx: int) -> "Tensor | int": raise TypeError(f"Invalid slice key: {key}") def _slice_multi(self, keys: tuple) -> "Tensor | int": - """Handle multi-dimensional slicing like tensor[i, :].""" + """Handle multi-dimensional slicing like tensor[i, :] or tensor[i, ((0, None), None)]. + + Supports three kinds of per-mode keys: + - int or tuple of ints: fix the mode to that coordinate + - None or slice(None): keep the entire mode free + - tuple containing None(s): partial hierarchical slice + """ if len(keys) != rank(self._layout): raise IndexError( f"Expected {rank(self._layout)} indices, got {len(keys)}" ) + # Check if any key is a partial hierarchical slice (tuple with Nones). + # If so, delegate to slice_and_offset which handles this correctly. + if any(self._has_nested_none(k) for k in keys): + sub, offset = slice_and_offset(keys, self._layout) + return Tensor(sub, self._offset + offset, data=self._data) + fixed_modes = [] sliced_modes = [] for i, key in enumerate(keys): if isinstance(key, (int, tuple)): fixed_modes.append((i, key)) - elif isinstance(key, slice) and key == slice(None): + elif key is None or (isinstance(key, slice) and key == slice(None)): sliced_modes.append(i) else: raise TypeError(f"Invalid slice key at position {i}: {key}") if not sliced_modes: - # All modes fixed - return the computed offset - return self(*keys) + # All modes fixed - return data element or computed offset + offset = self(*keys) + if self._data is not None: + return self._data[offset] + return offset # Compute LINEAR offset contribution from fixed modes (no swizzle) fixed_offset = sum(self._get_linear_mode_offset(i, coord) for i, coord in fixed_modes) new_layout = self._build_remaining_layout(sliced_modes) - return Tensor(new_layout, self._offset + fixed_offset) + return Tensor(new_layout, self._offset + fixed_offset, data=self._data) + + @staticmethod + def _has_nested_none(key) -> bool: + """Check if a key contains None inside a nested tuple.""" + if not isinstance(key, tuple): + return False + for item in key: + if item is None: + return True + if isinstance(item, tuple) and Tensor._has_nested_none(item): + return True + return False def _build_remaining_layout(self, mode_indices) -> Layout: """Build a Layout from selected modes.""" @@ -196,10 +337,14 @@ def _fix_mode(self, mode_idx: int, coord) -> "Tensor | int": offset_contrib = self._get_linear_mode_offset(mode_idx, coord) remaining = [i for i in range(rank(self._layout)) if i != mode_idx] if not remaining: - # No modes left - return the computed offset + # No modes left - return data element or computed offset total_linear = self._offset + offset_contrib if self._layout.swizzle is not None: - return self._layout.swizzle(total_linear) - return total_linear + offset = self._layout.swizzle(total_linear) + else: + offset = total_linear + if self._data is not None: + return self._data[offset] + return offset new_layout = self._build_remaining_layout(remaining) - return Tensor(new_layout, self._offset + offset_contrib) + return Tensor(new_layout, self._offset + offset_contrib, data=self._data) diff --git a/src/tensor_layouts/viz.py b/src/tensor_layouts/viz.py index 81e1db9..9c7666b 100644 --- a/src/tensor_layouts/viz.py +++ b/src/tensor_layouts/viz.py @@ -42,8 +42,8 @@ draw_slice(Layout((4, 8), (8, 1)), (2, None), "slice.svg") # Jupyter notebook display - from tensor_layouts.viz import show_layout - show_layout(Layout((8, 8), (8, 1))) + from tensor_layouts.viz import draw_layout + draw_layout(Layout((8, 8), (8, 1))) # inline display when filename=None Requirements: pip install matplotlib numpy @@ -85,20 +85,8 @@ "draw_combined_mma_grid", "draw_copy_layout", "draw_composite", + "draw_gemm", "draw_copy_atom", - # show_* (return matplotlib Figure) - "show_layout", - "show_swizzle", - "show_slice", - "show_tv_layout", - "show_mma_layout", - "show_tiled_grid", - "show_combined_mma_grid", - "show_copy_layout", - "show_composite", - "show_copy_atom", - # Demo - "demo", ] @@ -146,7 +134,7 @@ def _make_grayscale_palette(n: int) -> list: return [f"#{grays[k]:02X}{grays[k]:02X}{grays[k]:02X}" for k in order] -def _make_rainbow_palette(n: int) -> list: +def _make_rainbow_palette(n: int, interleave: bool = False) -> list: """Generate n distinct rainbow colors. Uses 8 base colors to match cute-viz palette for n <= 8. @@ -154,6 +142,10 @@ def _make_rainbow_palette(n: int) -> list: (small n → pastel, large n → more vivid so adjacent hues stay distinguishable), then applies a bit-reversal reorder so consecutive palette indices are maximally different in hue. + + When interleave=True, same-hue shades are placed consecutively + (blue, lt blue, green, lt green, ...) so that consecutive indices + share hues. This matches the CuTe paper's coloring convention. """ # 8 base colors matching cute-viz pastel palette base_colors = [ @@ -166,6 +158,14 @@ def _make_rainbow_palette(n: int) -> list: "#FFFFD2", # Lighter yellow "#FFD2D2", # Lighter red ] + if interleave: + # Reorder so same-hue shades are adjacent: (blue, lt blue, green, lt green, ...) + half = len(base_colors) // 2 + interleaved = [] + for i in range(half): + interleaved.append(base_colors[i]) + interleaved.append(base_colors[i + half]) + base_colors = interleaved if n <= len(base_colors): return base_colors[:n] # Ramp saturation from pastel (0.35 near n=8) to vivid (0.60 at n>=32) @@ -445,6 +445,13 @@ def _setup_axes( ax.set_title(title, fontsize=title_fontsize, fontweight="bold", pad=10) +def _format_cell_value(val, precision: Optional[int] = None) -> str: + """Format a cell label value, respecting *precision* for floats.""" + if precision is not None and isinstance(val, float): + return f"{val:.{precision}g}" + return str(val) + + def _draw_grid( ax, indices: np.ndarray, @@ -459,6 +466,9 @@ def _draw_grid( label_color: str = "blue", label_fontsize: float = 8, cell_fontsize: Optional[float] = None, + cell_labels=True, + interleave_colors: bool = False, + precision: Optional[int] = None, ): """Draw a grid of cells with indices on a matplotlib axis. @@ -479,6 +489,9 @@ def _draw_grid( cell_fontsize: Font size for cell value text. If None, auto-scaled based on the figure width and number of columns so text fits within cells. + precision: Number of digits for float cell labels. None (default) + uses full ``str()`` representation. When set, floats are + formatted with ``f"{v:.{precision}g}"``. """ rows, cols = indices.shape @@ -501,7 +514,7 @@ def _draw_grid( # Build the appropriate palette if colorize: - colors = _make_rainbow_palette(num_colors) + colors = _make_rainbow_palette(num_colors, interleave=interleave_colors) else: colors = _make_grayscale_palette(num_colors) @@ -575,10 +588,17 @@ def _draw_grid( idx = int(indices[i, j]) facecolor = final_facecolors[i, j] text_color = "white" if _is_dark(facecolor) else "black" + if cell_labels is False: + continue + if not isinstance(cell_labels, (bool, str)): + val = cell_labels[idx] if idx < len(cell_labels) else idx + label = _format_cell_value(val, precision) + else: + label = str(idx) ax.text( j + 0.5, i + 0.5, - str(idx), + label, ha="center", va="center", fontsize=cell_fontsize, @@ -615,7 +635,11 @@ def _draw_grid( def _save_figure(fig, filename, dpi: int = 150): - """Save figure to file, or display inline in Jupyter if filename is None.""" + """Save figure to file, or display inline in Jupyter if filename is None. + + Returns the figure when saving to a file (for further inspection), + or None when displaying inline (to prevent Jupyter double-rendering). + """ if filename is None: # Inline display in Jupyter notebook try: @@ -625,12 +649,12 @@ def _save_figure(fig, filename, dpi: int = 150): buf = io.BytesIO() fig.savefig(buf, format="png", dpi=dpi, bbox_inches="tight") - plt.close(fig) buf.seek(0) display(Image(data=buf.getvalue())) except ImportError: plt.show() - return + plt.close(fig) + return None path = Path(filename) fmt = path.suffix.lower().lstrip(".") @@ -657,17 +681,51 @@ def _build_composite_figure( arrangement: str = "horizontal", titles: Optional[list] = None, main_title: Optional[str] = None, - panel_size: Tuple[float, float] = (4, 4), - colorize: bool = False, - tv_mode: bool = False, - flatten_hierarchical: bool = True, - label_hierarchy_levels: bool = False, + panel_size: Optional[Tuple[float, float]] = None, + **defaults, ): - """Build the composite figure used by draw_composite/show_composite.""" + """Build the composite figure used by draw_composite. + + Keyword arguments beyond the named parameters are treated as default + panel-rendering options. Per-panel option dicts override these defaults. + """ n = len(panels) if n == 0: raise ValueError("panels list cannot be empty") + # Auto-compute panel_size from layout dimensions if not provided + if panel_size is None: + cell_scale = 0.55 + padding_w, padding_h = 1.5, 0.9 + max_rows, max_cols = 1, 1 + # If grid_rows/grid_cols are specified in defaults, use them + # instead of inferring from layout shape (which can be wrong + # for TV layouts where the rendered grid differs from the shape). + default_gr = defaults.get("grid_rows") + default_gc = defaults.get("grid_cols") + for p in panels: + lay = p[0] if isinstance(p, tuple) else p + opts = p[1] if isinstance(p, tuple) else {} + if hasattr(lay, 'layout'): + lay = lay.layout + lay = as_layout(lay) + # Per-panel grid overrides take priority, then defaults + gr = opts.get("grid_rows", default_gr) + gc = opts.get("grid_cols", default_gc) + if gr is not None and gc is not None: + pr, pc = gr, gc + else: + r = rank(lay) + if r >= 2: + pr = size(mode(lay.shape, 0)) + pc = size(mode(lay.shape, 1)) + else: + pr, pc = 1, size(lay) + max_rows = max(max_rows, pr) + max_cols = max(max_cols, pc) + panel_size = (max_cols * cell_scale + padding_w, + max_rows * cell_scale + padding_h) + # Parse arrangement if arrangement == "horizontal": nrows, ncols = 1, n @@ -715,21 +773,31 @@ def _build_composite_figure( layout = panel opts = {} - # Unwrap Tensor for offset-grid rendering + # Merge defaults with per-panel overrides + panel_opts = {**defaults, **opts} + + # Unwrap Tensor for offset-grid rendering (duck-typed to avoid + # class-identity mismatches after editable-install reloads) eval_fn = None - if isinstance(layout, Tensor): - eval_fn = layout.__call__ - layout = layout.layout - - # Merge with defaults - panel_colorize = opts.get("colorize", colorize) - panel_tv_mode = opts.get("tv_mode", tv_mode) - color_layout = opts.get("color_layout", None) - num_colors = opts.get("num_colors", 8) - panel_flatten = opts.get("flatten_hierarchical", flatten_hierarchical) - panel_label_levels = opts.get( - "label_hierarchy_levels", label_hierarchy_levels - ) + tensor = None + if hasattr(layout, 'layout') and hasattr(layout, 'data') and callable(layout): + tensor = layout + eval_fn = tensor.__call__ + layout = tensor.layout + + # Extract rendering options with sensible fallbacks + panel_colorize = panel_opts.get("colorize", False) + panel_tv_mode = panel_opts.get("tv_mode", False) + panel_color_layout = panel_opts.get("color_layout", None) + panel_num_colors = panel_opts.get("num_colors", 8) + panel_flatten = panel_opts.get("flatten_hierarchical", True) + panel_label_levels = panel_opts.get("label_hierarchy_levels", False) + panel_cell_labels = panel_opts.get("cell_labels", True) + panel_precision = panel_opts.get("precision", None) + + # Auto-label from Tensor data (after opts merge so user can override) + if tensor is not None and tensor.data is not None and panel_cell_labels is True: + panel_cell_labels = tensor.data # Get title title = titles[idx] if titles and idx < len(titles) else None @@ -741,11 +809,11 @@ def _build_composite_figure( layout, title=title, colorize=panel_colorize, - num_colors=opts.get("num_colors", num_colors), - grid_rows=opts.get("grid_rows"), - grid_cols=opts.get("grid_cols"), - thr_id_layout=opts.get("thr_id_layout"), - col_major=opts.get("col_major", True), + num_colors=panel_num_colors, + grid_rows=panel_opts.get("grid_rows"), + grid_cols=panel_opts.get("grid_cols"), + thr_id_layout=panel_opts.get("thr_id_layout"), + col_major=panel_opts.get("col_major", True), ) else: # Check if this panel should use hierarchical rendering @@ -755,7 +823,7 @@ def _build_composite_figure( or isinstance(mode(layout.shape, 1), tuple) ) grid = _prepare_offset_grid( - layout, color_layout=color_layout, eval_fn=eval_fn, + layout, color_layout=panel_color_layout, eval_fn=eval_fn, hierarchical=is_hier, ) if grid.is_hierarchical: @@ -772,7 +840,9 @@ def _build_composite_figure( color_indices=grid.color_indices, flatten_hierarchical=False, label_hierarchy_levels=panel_label_levels, - num_colors=num_colors, + cell_labels=panel_cell_labels, + num_colors=panel_num_colors, + precision=panel_precision, ) else: _draw_grid( @@ -781,7 +851,9 @@ def _build_composite_figure( title=title, colorize=panel_colorize, color_indices=grid.color_indices, - num_colors=num_colors, + num_colors=panel_num_colors, + cell_labels=panel_cell_labels, + precision=panel_precision, ) # Hide unused axes @@ -795,18 +867,168 @@ def _build_composite_figure( return fig +def _unwrap_tensor(panel): + """Duck-type unwrap a Layout or Tensor into (layout, eval_fn, cell_labels).""" + if hasattr(panel, 'layout') and hasattr(panel, 'data') and callable(panel): + tensor = panel + layout = tensor.layout + eval_fn = tensor.__call__ + labels = tensor.data if tensor.data is not None else True + return layout, eval_fn, labels + return as_layout(panel), None, True + + +def _build_gemm_figure( + A, B, C, + main_title: Optional[str] = None, + **defaults, +): + """Build the GEMM figure used by draw_gemm. + + Arranges A, B, C in the standard matmul spatial pattern:: + + B^T (K×N) + A (M×K) C (M×N) + + B is automatically transposed for display so its K dimension aligns + vertically with A's K columns. + """ + import matplotlib.gridspec as gridspec + + a_layout, a_fn, a_labels = _unwrap_tensor(A) + b_layout, b_fn, b_labels = _unwrap_tensor(B) + c_layout, c_fn, c_labels = _unwrap_tensor(C) + + # Get M, K, N from flattened sizes (for grid proportions) + M = size(mode(a_layout, 0)) + K = size(mode(a_layout, 1)) + N = size(mode(b_layout, 0)) + + # Transpose B for display: (N, K):(sn, sk) → (K, N):(sk, sn) + bt_layout = Layout( + (b_layout.shape[1], b_layout.shape[0]), + (b_layout.stride[1], b_layout.stride[0]), + ) + bt_fn = (lambda k, n: b_fn(n, k)) if b_fn is not None else None + + # Format shape for panel titles, preserving hierarchy + def _fmt(s): + if isinstance(s, tuple): + return "(" + ",".join(str(x) for x in s) + ")" + return str(s) + + a_title = f"A ({_fmt(a_layout.shape[0])}\u00d7{_fmt(a_layout.shape[1])})" + bt_title = f"B\u1d40 ({_fmt(bt_layout.shape[0])}\u00d7{_fmt(bt_layout.shape[1])})" + c_title = f"C ({_fmt(c_layout.shape[0])}\u00d7{_fmt(c_layout.shape[1])})" + + # Figure sizing proportional to matrix dimensions + cell_scale = 0.55 + pad = 1.5 + fig_w = (K + N) * cell_scale + pad + fig_h = (K + M) * cell_scale + pad + + fig = plt.figure(figsize=(fig_w, fig_h), layout="constrained") + gs = fig.add_gridspec( + 2, 2, + width_ratios=[K, N], + height_ratios=[K, M], + wspace=0.3, + hspace=0.15, + ) + + ax_empty = fig.add_subplot(gs[0, 0]) + ax_empty.axis("off") + ax_b = fig.add_subplot(gs[0, 1]) + ax_a = fig.add_subplot(gs[1, 0]) + ax_c = fig.add_subplot(gs[1, 1]) + + def _hier_shapes(layout): + """Extract hierarchy_shapes for boundary boxes if layout has nested modes.""" + if rank(layout) == 2: + rs = mode(layout.shape, 0) + cs = mode(layout.shape, 1) + if isinstance(rs, tuple) or isinstance(cs, tuple): + return (rs, cs) + return None + + def _render(ax, layout, eval_fn, auto_labels, title): + cell_labels = defaults.get("cell_labels", True) + if cell_labels is True and isinstance(auto_labels, list): + cell_labels = auto_labels + grid = _prepare_offset_grid( + layout, eval_fn=eval_fn, + color_layout=defaults.get("color_layout"), + ) + _draw_grid( + ax, grid.indices, title=title, + colorize=defaults.get("colorize", False), + color_indices=grid.color_indices, + num_colors=defaults.get("num_colors", 8), + cell_labels=cell_labels, + interleave_colors=defaults.get("interleave_colors", False), + hierarchy_shapes=_hier_shapes(layout), + precision=defaults.get("precision"), + ) + + _render(ax_a, a_layout, a_fn, a_labels, a_title) + _render(ax_b, bt_layout, bt_fn, b_labels, bt_title) + _render(ax_c, c_layout, c_fn, c_labels, c_title) + + if main_title: + fig.suptitle(main_title, fontsize=12, fontweight="bold") + + return fig + + +def draw_gemm( + A, B, C, + filename: str = None, + main_title: Optional[str] = None, + dpi: int = 150, + **kwargs, +): + """Draw GEMM operands in the standard matmul spatial arrangement. + + Renders A, B, C as offset grids arranged so shared dimensions align:: + + B^T (K×N) + A (M×K) C (M×N) + + B is automatically transposed for display so its K dimension aligns + vertically with A's K columns, and its N dimension aligns horizontally + with C's N columns. + + Each operand can be a Layout (shows offsets) or a Tensor (shows data). + + Args: + A: Layout or Tensor with shape (M, K) + B: Layout or Tensor with shape (N, K) + C: Layout or Tensor with shape (M, N) + filename: Output path (.svg, .png, .pdf) or None for inline display + main_title: Optional title for the entire figure + dpi: Resolution for raster formats + **kwargs: Rendering options (cell_labels, colorize, num_colors, etc.) + + Example: + A = Tensor(Layout((4, 2), (1, 4)), data=[1,0,0,1, 2,1,1,0]) + B = Tensor(Layout((3, 2), (1, 3)), data=[1,0,1, 0,1,1]) + C = Tensor(Layout((4, 3), (1, 4)), data=[0]*12) + gemm(A, B, C) + draw_gemm(A, B, C, main_title='NT GEMM -- data') + """ + fig = _build_gemm_figure(A, B, C, main_title=main_title, **kwargs) + return _save_figure(fig, filename, dpi) + + def draw_composite( panels: list, - filename: str, + filename: str = None, arrangement: str = "horizontal", titles: Optional[list] = None, main_title: Optional[str] = None, dpi: int = 150, - panel_size: Tuple[float, float] = (4, 4), - colorize: bool = False, - tv_mode: bool = False, - flatten_hierarchical: bool = True, - label_hierarchy_levels: bool = False, + panel_size: Optional[Tuple[float, float]] = None, + **kwargs, ): """Draw multiple layouts in a single composite figure. @@ -819,11 +1041,7 @@ def draw_composite( Args: panels: List of Layout/Tensor objects or (Layout/Tensor, options_dict) - tuples. Per-panel options override the top-level defaults: - colorize, color_layout, num_colors -- offset-grid options - tv_mode -- if True, render this panel as a TV grid - grid_rows, grid_cols, thr_id_layout, col_major -- TV options - flatten_hierarchical, label_hierarchy_levels -- hierarchy options + tuples. Per-panel option dicts override the top-level defaults. filename: Output path (.svg, .png, or .pdf) arrangement: How to arrange panels: - "horizontal": side by side (1 row) @@ -832,13 +1050,16 @@ def draw_composite( titles: Optional list of titles for each panel main_title: Optional title for the entire figure dpi: Resolution for raster formats - panel_size: Size of each panel in inches (width, height) - colorize: Default colorize setting for all panels - tv_mode: If True, render panels as TV layouts with T/V labels - flatten_hierarchical: Default for all panels. If False, show explicit - nested coordinate labels for hierarchical layouts - label_hierarchy_levels: Default for all panels. If True, annotate axes - with hierarchy level labels + panel_size: Size of each panel in inches (width, height). + If None (default), auto-computed from layout dimensions: + ~0.55 in per cell plus padding for titles and labels. + **kwargs: Default rendering options applied to every panel + unless overridden by a per-panel option dict. Common options: + cell_labels -- True (auto), False, "offset", or a list + colorize, color_layout, num_colors -- coloring + tv_mode, grid_rows, grid_cols -- TV layout rendering + flatten_hierarchical, label_hierarchy_levels -- hierarchy + precision -- significant digits for float cell labels Example: # Side-by-side comparison @@ -855,12 +1076,9 @@ def draw_composite( titles=titles, main_title=main_title, panel_size=panel_size, - colorize=colorize, - tv_mode=tv_mode, - flatten_hierarchical=flatten_hierarchical, - label_hierarchy_levels=label_hierarchy_levels, + **kwargs, ) - _save_figure(fig, filename, dpi) + return _save_figure(fig, filename, dpi) # ============================================================================= @@ -1260,7 +1478,10 @@ def _draw_hierarchical_grid( color_indices: Optional[np.ndarray] = None, flatten_hierarchical: bool = True, label_hierarchy_levels: bool = False, + cell_labels: bool = True, num_colors: int = 8, + interleave_colors: bool = False, + precision: Optional[int] = None, ): """Draw a hierarchical layout grid. @@ -1292,7 +1513,7 @@ def _draw_hierarchical_grid( # Build palette if colorize: - colors = _make_rainbow_palette(num_colors) + colors = _make_rainbow_palette(num_colors, interleave=interleave_colors) else: colors = _make_grayscale_palette(num_colors) @@ -1343,7 +1564,22 @@ def _draw_hierarchical_grid( is_dark_bg = _is_dark(facecolor) text_color = "white" if is_dark_bg else "black" - if flatten_hierarchical: + if cell_labels is False: + pass + elif not isinstance(cell_labels, (bool, str)): + # User-provided or auto-generated labels indexed by offset + val = cell_labels[idx] if idx < len(cell_labels) else idx + label = _format_cell_value(val, precision) + ax.text( + j + 0.5, + i + 0.5, + label, + ha="center", + va="center", + fontsize=8, + color=text_color, + ) + elif flatten_hierarchical or cell_labels == "offset": # Draw flat offset value in cell ax.text( j + 0.5, @@ -1460,12 +1696,12 @@ def _draw_hierarchical_grid( fontweight="bold", ) else: - # Single-level labels + # Single-level labels — plain integers, matching flat mode for i in range(rows): ax.text( -0.3, i + 0.5, - f"R{i}", + str(i), ha="center", va="center", fontsize=8, @@ -1475,7 +1711,7 @@ def _draw_hierarchical_grid( ax.text( j + 0.5, -0.3, - f"C{j}", + str(j), ha="center", va="center", fontsize=8, @@ -1493,20 +1729,28 @@ def _build_layout_figure( num_colors: int = 8, flatten_hierarchical: bool = True, label_hierarchy_levels: bool = False, + cell_labels: bool = True, + interleave_colors: bool = False, + transpose: bool = False, + precision: Optional[int] = None, ): - """Build the layout figure used by draw_layout/show_layout. + """Build the layout figure used by draw_layout. Accepts Layout or Tensor. When given a Tensor, cells display offset-adjusted values and the default title includes the base offset. """ # Unwrap Tensor: use its layout for shape/structure, its __call__ for values + # (duck-typed to avoid class-identity mismatches after editable-install reloads) eval_fn = None - if isinstance(layout, Tensor): + if hasattr(layout, 'layout') and hasattr(layout, 'data') and callable(layout): tensor = layout eval_fn = tensor.__call__ layout = tensor.layout if title is None: - title = repr(tensor) + title = str(tensor) + # Auto-label cells with data values when storage is present + if tensor.data is not None and cell_labels is True: + cell_labels = tensor.data # Resolve color_by shorthand to a color_layout if color_by is not None: @@ -1526,17 +1770,16 @@ def _build_layout_figure( ) colorize = True - # Rank >= 3: decompose into multiple 2D panels along the leading mode(s) + # Rank >= 3: decompose into multiple 2D panels along the trailing mode(s) r = rank(layout) if r >= 3: - # Group all leading modes (0..r-3) into a flat slice index, - # keeping the last two modes as the 2D grid per panel. - outer_sizes = [size(mode(layout.shape, i)) for i in range(r - 2)] + # Modes 0,1 form the 2D grid per panel; modes 2..r are the panel axes. + outer_sizes = [size(mode(layout.shape, i)) for i in range(2, r)] n_panels = 1 for s in outer_sizes: n_panels *= s - inner_shape = as_shape(tuple(mode(layout.shape, i) for i in range(r - 2, r))) - inner_stride = as_shape(tuple(mode(layout.stride, i) for i in range(r - 2, r))) + inner_shape = as_shape(tuple(mode(layout.shape, i) for i in range(2))) + inner_stride = as_shape(tuple(mode(layout.stride, i) for i in range(2))) # Build per-panel sub-layouts and eval functions sub_layouts = [] @@ -1550,7 +1793,7 @@ def _build_layout_figure( # Offset contribution from fixed outer modes offset = 0 for dim_idx, coord_val in enumerate(outer_coord): - m = mode(layout, dim_idx) + m = mode(layout, 2 + dim_idx) offset += crd2offset(coord_val, m.shape, m.stride) sub = Layout(inner_shape, inner_stride, swizzle=layout.swizzle) @@ -1583,7 +1826,7 @@ def fn(*args): sub_evals.append(_make_eval_plain(_off, _sub)) if len(outer_sizes) == 1: - panel_titles.append(f"mode[0]={outer_coord[0]}") + panel_titles.append(f"mode[2]={outer_coord[0]}") else: coord_str = ", ".join(str(c) for c in outer_coord) panel_titles.append(f"outer=({coord_str})") @@ -1614,6 +1857,9 @@ def fn(*args): colorize=colorize, color_indices=grid.color_indices, num_colors=num_colors, + cell_labels=cell_labels, + interleave_colors=interleave_colors, + precision=precision, ) for idx in range(n_panels, len(axes)): @@ -1637,8 +1883,18 @@ def fn(*args): eval_fn=eval_fn, ) + # Transpose rank-1 layouts from 1×N row to N×1 column + if transpose and rank(layout) <= 1: + grid = OffsetGrid( + indices=grid.indices.T, + color_indices=grid.color_indices.T if grid.color_indices is not None else None, + cell_coords=grid.cell_coords, + row_shape=grid.row_shape, + col_shape=grid.col_shape, + ) + if figsize is None: - if grid.is_hierarchical: + if grid.is_hierarchical and cell_labels is True: figsize = _auto_hierarchical_figsize( layout, grid.indices, grid.rows, grid.cols, label_hierarchy_levels ) @@ -1662,7 +1918,10 @@ def fn(*args): color_indices=grid.color_indices, flatten_hierarchical=False, label_hierarchy_levels=label_hierarchy_levels, + cell_labels=cell_labels, + interleave_colors=interleave_colors, num_colors=num_colors, + precision=precision, ) else: _draw_grid( @@ -1672,6 +1931,9 @@ def fn(*args): colorize=colorize, color_indices=grid.color_indices, num_colors=num_colors, + cell_labels=cell_labels, + interleave_colors=interleave_colors, + precision=precision, ) return fig @@ -1689,6 +1951,10 @@ def draw_layout( num_colors: int = 8, flatten_hierarchical: bool = True, label_hierarchy_levels: bool = False, + cell_labels: bool = True, + interleave_colors: bool = False, + transpose: bool = False, + precision: Optional[int] = None, ): """Draw a layout or tensor and save to file. @@ -1722,6 +1988,18 @@ def draw_layout( label_hierarchy_levels: For hierarchical nested views, if True annotate axes with each hierarchy level at block/tile granularity. Label colors match the corresponding hierarchy boundary lines. + cell_labels: Controls text inside cells. True (default) shows full + detail (row/col/offset in hierarchical mode, offset in flat mode). + "offset" shows only the offset number. False suppresses all text. + A list/tuple of strings labels cells by offset (e.g., + list("ABCDEFGHIJ...") to show letters). + interleave_colors: If True, reorder the rainbow palette so that + consecutive indices share hues (blue, lt blue, green, lt green, ...). + Matches the CuTe paper's coloring convention. + transpose: If True, render rank-1 layouts as a column vector (N×1) + instead of the default row vector (1×N). Ignored for rank >= 2. + precision: Number of significant digits for float cell labels. + None (default) uses full ``str()`` representation. """ fig = _build_layout_figure( layout, @@ -1733,8 +2011,12 @@ def draw_layout( num_colors=num_colors, flatten_hierarchical=flatten_hierarchical, label_hierarchy_levels=label_hierarchy_levels, + cell_labels=cell_labels, + interleave_colors=interleave_colors, + transpose=transpose, + precision=precision, ) - _save_figure(fig, filename, dpi) + return _save_figure(fig, filename, dpi) def _infer_tv_grid_shape(layout, grid_shape=None, grid_rows=None, grid_cols=None): @@ -1977,7 +2259,7 @@ def _build_tv_figure( thr_id_layout=None, col_major: bool = True, ): - """Build the TV figure used by draw_tv_layout/show_tv_layout.""" + """Build the TV figure used by draw_tv_layout.""" r = rank(layout) if r != 2: raise ValueError(f"TV layout must be rank 2, got rank {r}") @@ -2049,7 +2331,7 @@ def draw_tv_layout( thr_id_layout=thr_id_layout, col_major=col_major, ) - _save_figure(fig, filename, dpi) + return _save_figure(fig, filename, dpi) def _build_mma_figure( @@ -2061,7 +2343,7 @@ def _build_mma_figure( colorize=True, thr_id_layout=None, ): - """Build the MMA figure used by draw_mma_layout/show_mma_layout.""" + """Build the MMA figure used by draw_mma_layout.""" # Infer M, N, K from tile_mnk or layout dimensions if tile_mnk: M, N, K = tile_mnk @@ -2280,13 +2562,13 @@ def draw_mma_layout( colorize=colorize, thr_id_layout=thr_id_layout, ) - _save_figure(fig, filename, dpi) + return _save_figure(fig, filename, dpi) def _build_tiled_grid_figure( grid: dict, rows: int, cols: int, title: Optional[str] = None ): - """Build the tiled-grid figure used by draw_tiled_grid/show_tiled_grid.""" + """Build the tiled-grid figure used by draw_tiled_grid.""" colors = _make_rainbow_palette(8) font = max(4, min(7, int(60 / max(rows, cols)))) fig, ax = plt.subplots(figsize=(cols * 0.45 + 1.5, rows * 0.4 + 1.0)) @@ -2320,7 +2602,7 @@ def draw_tiled_grid( title: plot title """ fig = _build_tiled_grid_figure(grid, rows, cols, title=title) - _save_figure(fig, filename, dpi) + return _save_figure(fig, filename, dpi) def _build_combined_grid_figure(a_grid, b_grid, c_grid, M, N, K, title=None): @@ -2408,7 +2690,7 @@ def draw_combined_mma_grid( title: plot title """ fig = _build_combined_grid_figure(a_grid, b_grid, c_grid, M, N, K, title=title) - _save_figure(fig, filename, dpi) + return _save_figure(fig, filename, dpi) def _build_copy_figure( @@ -2567,7 +2849,7 @@ def draw_copy_layout( thr_id_layout=thr_id_layout, col_major=col_major, ) - _save_figure(fig, filename, dpi) + return _save_figure(fig, filename, dpi) def _swizzle_figsize(linear_idx, swizzle_idx, rows, cols): @@ -2592,7 +2874,7 @@ def _build_swizzle_figure( colorize: bool = False, num_colors: int = 8, ): - """Build the swizzle comparison figure used by draw_swizzle/show_swizzle.""" + """Build the swizzle comparison figure used by draw_swizzle.""" sw_layout = compose(swizzle, base_layout) linear_idx = _get_indices_2d(base_layout) @@ -2684,7 +2966,7 @@ def draw_swizzle( fig = _build_swizzle_figure( base_layout, swizzle, figsize=figsize, colorize=colorize, num_colors=num_colors ) - _save_figure(fig, filename, dpi) + return _save_figure(fig, filename, dpi) def _expand_hier_slice(spec, shape): @@ -2851,7 +3133,7 @@ def _build_slice_figure( color_layout=None, num_colors=8, ): - """Build the slice figure used by draw_slice/show_slice.""" + """Build the slice figure used by draw_slice.""" grid = _prepare_offset_grid( layout, color_layout=color_layout, slice_spec=slice_spec ) @@ -2860,7 +3142,10 @@ def _build_slice_figure( figsize = (grid.cols * 0.5 + 1, grid.rows * 0.5 + 1) if title is None: - title = f"{layout}[{slice_spec}]" + sub, offset = slice_and_offset(slice_spec, as_layout(layout)) + # Unwrap single-mode results for cleaner display + display_sub = Layout(unwrap(sub.shape), unwrap(sub.stride)) + title = f"{{{offset}}}∘{display_sub}" fig, ax = plt.subplots(figsize=figsize) _draw_grid( @@ -2913,115 +3198,7 @@ def draw_slice( color_layout=color_layout, num_colors=num_colors, ) - _save_figure(fig, filename, dpi) - - -def show_layout( - layout, - title: Optional[str] = None, - figsize: Optional[Tuple[float, float]] = None, - colorize: bool = False, - color_layout: Optional[Layout] = None, - color_by: Optional[str] = None, - num_colors: int = 8, - flatten_hierarchical: bool = True, - label_hierarchy_levels: bool = False, -): - """Display a layout or tensor inline (for Jupyter notebooks). - - Args: - layout: Layout or Tensor to visualize. When given a Tensor, cells - display offset-adjusted values and the title includes the base offset. - title: Optional title - figsize: Figure size in inches - colorize: If True, use rainbow colors for distinct cells - color_layout: Optional layout controlling cell coloring in the same - logical coordinate space as `layout` (None = color by value) - color_by: Shorthand for common color_layout patterns ("row", "column", - or "offset"). Mutually exclusive with color_layout. - num_colors: Number of colors in palette - flatten_hierarchical: For hierarchical layouts, if True show flat grid with - offset values. If False, show explicit cell labels. - label_hierarchy_levels: For hierarchical nested views, if True annotate - axes with each hierarchy level at block/tile granularity. - - Returns: - matplotlib Figure - """ - return _build_layout_figure( - layout, - title=title, - figsize=figsize, - colorize=colorize, - color_layout=color_layout, - color_by=color_by, - num_colors=num_colors, - flatten_hierarchical=flatten_hierarchical, - label_hierarchy_levels=label_hierarchy_levels, - ) - - -def show_swizzle( - base_layout, - swizzle, - figsize: Optional[Tuple[float, float]] = None, - colorize: bool = False, - num_colors: int = 8, -): - """Display swizzle comparison inline (for Jupyter notebooks). - - Colors by the bits that the swizzle affects: (value >> swizzle.base) % num_colors. - - Args: - base_layout: Base Layout object - swizzle: Swizzle object - figsize: Figure size in inches - colorize: If True, use rainbow colors (makes swizzle movement clearer) - num_colors: Number of colors in palette - - Returns: - matplotlib Figure - """ - return _build_swizzle_figure( - base_layout, swizzle, figsize=figsize, colorize=colorize, num_colors=num_colors - ) - - -def show_copy_layout( - src_layout, - dst_layout, - grid_shape=None, - title=None, - colorize=True, - thr_id_layout=None, - col_major=True, -): - """Display a copy layout inline (for Jupyter notebooks). - - Args: - src_layout: TV layout for source - dst_layout: TV layout for destination - grid_shape: Optional (rows, cols) for the output grids - title: Optional title - colorize: If True, use rainbow colors - thr_id_layout: Optional layout for thread ID mapping - col_major: If True (default), use column-major decomposition - (CuTe A/C convention: row = offset % rows). - If False, use row-major (CuTe B convention: - row = offset // cols). - - Returns: - matplotlib Figure - """ - return _build_copy_figure( - src_layout, - dst_layout, - grid_shape=grid_shape, - title=title, - colorize=colorize, - thr_id_layout=thr_id_layout, - col_major=col_major, - ) + return _save_figure(fig, filename, dpi) def draw_copy_atom( @@ -3051,7 +3228,7 @@ def draw_copy_atom( """ src = upcast(atom.src_layout_bits, element_bits) dst = upcast(atom.dst_layout_bits, element_bits) - draw_copy_layout( + return draw_copy_layout( src, dst, filename=filename, @@ -3064,299 +3241,3 @@ def draw_copy_atom( ) -def show_copy_atom( - atom, - element_bits: int = 16, - grid_shape=None, - title=None, - colorize: bool = True, - col_major: bool = True, -): - """Display a CopyAtom inline (for Jupyter notebooks). - - Convenience wrapper around show_copy_layout that handles the upcast - from bit coordinates to element coordinates automatically. - - Args: - atom: CopyAtom with src_layout_bits and dst_layout_bits in bit coords - element_bits: Bit width of the data type (default 16 for fp16) - grid_shape: Optional (rows, cols) for the output grids - title: Optional title (defaults to atom.name) - colorize: If True, use rainbow colors - col_major: If True (default), use column-major grid decomposition - - Returns: - matplotlib Figure - """ - src = upcast(atom.src_layout_bits, element_bits) - dst = upcast(atom.dst_layout_bits, element_bits) - return show_copy_layout( - src, - dst, - grid_shape=grid_shape, - title=title or f"{atom.name} ({atom.ptx})", - colorize=colorize, - thr_id_layout=atom.thr_id, - col_major=col_major, - ) - - -def show_tv_layout( - layout, - title: Optional[str] = None, - figsize: Optional[Tuple[float, float]] = None, - colorize: bool = False, - num_colors: Optional[int] = None, - grid_shape: Optional[Tuple[int, int]] = None, - thr_id_layout=None, - col_major: bool = True, -): - """Display a TV layout inline (for Jupyter notebooks). - - Args: - layout: Layout object with shape (T, V) for Thread-Value - title: Optional title (defaults to "TV: {layout}") - figsize: Figure size in inches (auto-calculated if None) - colorize: If True, use rainbow colors; if False, use grayscale - num_colors: Override number of colors (defaults to T dimension) - grid_shape: Optional (rows, cols) for the output grid - thr_id_layout: Optional layout for thread ID mapping - col_major: If True (default), use column-major decomposition - (CuTe A/C convention: row = offset % rows). - If False, use row-major (CuTe B convention: - row = offset // cols). - - Returns: - matplotlib Figure - """ - return _build_tv_figure( - layout, - title=title, - figsize=figsize, - colorize=colorize, - num_colors=num_colors, - grid_shape=grid_shape, - thr_id_layout=thr_id_layout, - col_major=col_major, - ) - - -def show_mma_layout( - layout_a, - layout_b, - layout_c, - tile_mnk=None, - main_title=None, - colorize=True, - thr_id_layout=None, -): - """Display an MMA layout inline (for Jupyter notebooks). - - Args: - layout_a: TV layout for matrix A (M×K) - layout_b: TV layout for matrix B (K×N) - layout_c: TV layout for matrix C (M×N) - tile_mnk: Optional (M, N, K) dimensions - main_title: Optional title for the entire figure - colorize: If True, use rainbow colors by thread ID - thr_id_layout: Optional layout for thread ID mapping - - Returns: - matplotlib Figure - """ - return _build_mma_figure( - layout_a, - layout_b, - layout_c, - tile_mnk=tile_mnk, - main_title=main_title, - colorize=colorize, - thr_id_layout=thr_id_layout, - ) - - -def show_tiled_grid(grid: dict, rows: int, cols: int, title: Optional[str] = None): - """Display a tiled MMA grid inline (for Jupyter notebooks). - - Args: - grid: dict mapping (row, col) → (phys_thread, value, logical_thread) - rows: number of rows in the grid - cols: number of columns in the grid - title: plot title - - Returns: - matplotlib Figure - """ - return _build_tiled_grid_figure(grid, rows, cols, title=title) - - -def show_combined_mma_grid(a_grid, b_grid, c_grid, M, N, K, title=None): - """Display combined A/B/C grid-dict panels inline (for Jupyter). - - Args: - a_grid: dict for A panel (M×K) - b_grid: dict for B panel (K×N) - c_grid: dict for C panel (M×N) - M, N, K: panel dimensions - title: plot title - - Returns: - matplotlib Figure - """ - return _build_combined_grid_figure(a_grid, b_grid, c_grid, M, N, K, title=title) - - -def show_slice( - layout, - slice_spec, - title: Optional[str] = None, - figsize: Optional[Tuple[float, float]] = None, - colorize: bool = False, - color_layout: Optional[Layout] = None, - num_colors: int = 8, -): - """Display a layout slice inline (for Jupyter notebooks). - - Args: - layout: Layout object - slice_spec: Slice specification (see draw_slice for details) - title: Optional title - figsize: Figure size in inches (auto-calculated if None) - colorize: If True, use rainbow colors for background cells - color_layout: Optional layout controlling background-cell coloring - num_colors: Number of colors in palette - - Returns: - matplotlib Figure - """ - return _build_slice_figure( - layout, - slice_spec, - title=title, - figsize=figsize, - colorize=colorize, - color_layout=color_layout, - num_colors=num_colors, - ) - - -def show_composite( - panels: list, - arrangement: str = "horizontal", - titles: Optional[list] = None, - main_title: Optional[str] = None, - panel_size: Tuple[float, float] = (4, 4), - colorize: bool = False, - tv_mode: bool = False, - flatten_hierarchical: bool = True, - label_hierarchy_levels: bool = False, -): - """Display a composite figure inline (for Jupyter notebooks). - - Args: - panels: List of Layout objects or (Layout, options_dict) tuples. - arrangement: "horizontal", "vertical", or "grid:RxC" - titles: Optional list of titles for each panel - main_title: Optional title for the entire figure - panel_size: Size of each panel in inches (width, height) - colorize: Default colorize setting for all panels - tv_mode: If True, render panels as TV layouts with T/V labels - flatten_hierarchical: Default for all panels. If False, show explicit - nested coordinate labels for hierarchical layouts - label_hierarchy_levels: Default for all panels. If True, annotate axes - with hierarchy level labels - - Returns: - matplotlib Figure - """ - return _build_composite_figure( - panels, - arrangement=arrangement, - titles=titles, - main_title=main_title, - panel_size=panel_size, - colorize=colorize, - tv_mode=tv_mode, - flatten_hierarchical=flatten_hierarchical, - label_hierarchy_levels=label_hierarchy_levels, - ) - - -# ============================================================================= -# Demo -# ============================================================================= - - -def demo(output_dir: str = "."): - """Generate example visualizations in all formats.""" - from pathlib import Path - - - output = Path(output_dir) - output.mkdir(parents=True, exist_ok=True) - - print("=" * 60) - print("Layout Visualization Demo") - print("=" * 60) - - # Basic layouts - all formats - layout_8x8 = Layout((8, 8), (8, 1)) - draw_layout(layout_8x8, output / "row_major.svg") - draw_layout(layout_8x8, output / "row_major.png") - draw_layout(layout_8x8, output / "row_major.pdf") - print("✓ Row-major 8x8 (SVG, PNG, PDF)") - - layout_col = Layout((8, 8), (1, 8)) - draw_layout(layout_col, output / "col_major.svg") - print("✓ Column-major 8x8") - - # Swizzle comparisons - draw_swizzle(Layout((8, 8), (8, 1)), Swizzle(3, 0, 3), output / "swizzle_303.svg") - draw_swizzle(Layout((8, 8), (8, 1)), Swizzle(3, 0, 3), output / "swizzle_303.png") - print("✓ Swizzle(3,0,3) comparison (SVG, PNG)") - - draw_swizzle(Layout((8, 8), (8, 1)), Swizzle(2, 0, 3), output / "swizzle_203.svg") - print("✓ Swizzle(2,0,3) comparison") - - draw_swizzle(Layout((4, 8), (8, 1)), Swizzle(2, 1, 3), output / "swizzle_213.svg") - print("✓ Swizzle(2,1,3) on 4x8") - - # Slice highlights - layout_4x8 = Layout((4, 8), (8, 1)) - draw_slice(layout_4x8, (2, None), output / "slice_row.svg") - draw_slice(layout_4x8, (2, None), output / "slice_row.png") - print("✓ Slice row 2 (SVG, PNG)") - - draw_slice(layout_4x8, (None, 5), output / "slice_col.svg") - print("✓ Slice column 5") - - draw_slice(layout_4x8, (2, 5), output / "slice_single.svg") - print("✓ Slice single element (2, 5)") - - draw_slice(layout_4x8, (slice(1, 3), slice(2, 6)), output / "slice_rect.svg") - print("✓ Slice rectangular region") - - # Hierarchical layout - hier = Layout(((2, 4), 8), ((1, 2), 8)) - draw_layout(hier, output / "hierarchical.svg") - draw_layout(hier, output / "hierarchical.png") - print("✓ Hierarchical layout (SVG, PNG)") - - # Logical divide - divided = Layout((4, 4), (1, 4)) # Result of logical_divide - draw_layout(divided, output / "divide_result.svg") - print("✓ Logical divide result") - - # Different sizes - draw_layout(Layout((4, 16), (16, 1)), output / "wide.svg") - draw_layout(Layout((16, 4), (4, 1)), output / "tall.svg") - print("✓ Wide and tall layouts") - - print(f"\n✓ All visualizations saved to {output_dir}/") - print(" Formats: .svg (vector), .png (raster), .pdf (print)") - - -if __name__ == "__main__": - import sys - - demo(sys.argv[1] if len(sys.argv) > 1 else "./viz_output") diff --git a/tests/analysis.py b/tests/analysis.py index bdd5618..00c96ca 100644 --- a/tests/analysis.py +++ b/tests/analysis.py @@ -747,6 +747,453 @@ def test_mma_atom_repr_is_verbose(): assert "a_layout=Layout(2, 1)" in r +# ============================================================================= +# to_F2_matrix +# ============================================================================= + + +def _verify_F2_matrix(layout): + """Helper: check that the F2 matrix reproduces layout(idx) for all idx.""" + M = to_F2_matrix(layout) + n_coord = len(M[0]) + n_offset = len(M) + for idx in range(size(layout)): + coord_bits = [(idx >> b) & 1 for b in range(n_coord)] + offset_bits = [ + sum(M[i][j] * coord_bits[j] for j in range(n_coord)) % 2 + for i in range(n_offset) + ] + offset = sum(b << i for i, b in enumerate(offset_bits)) + assert offset == layout(idx), ( + f"F2 mismatch at idx={idx}: matrix={offset}, layout={layout(idx)}" + ) + + +def test_F2_matrix_identity(): + """Contiguous layout produces identity matrix.""" + M = to_F2_matrix(Layout(4, 1)) + assert M == [[1, 0], [0, 1]] + + +def test_F2_matrix_row_major(): + """Row-major 4x8 produces a permutation matrix (bit swap).""" + M = to_F2_matrix(Layout((4, 8), (8, 1))) + assert len(M) == 5 + assert len(M[0]) == 5 + _verify_F2_matrix(Layout((4, 8), (8, 1))) + + +def test_F2_matrix_col_major(): + """Column-major produces identity (already in natural bit order).""" + M = to_F2_matrix(Layout((4, 8), (1, 4))) + assert M == [[1, 0, 0, 0, 0], + [0, 1, 0, 0, 0], + [0, 0, 1, 0, 0], + [0, 0, 0, 1, 0], + [0, 0, 0, 0, 1]] + + +def test_F2_matrix_swizzle(): + """Swizzled layout folds XOR into the matrix.""" + L = compose(Swizzle(3, 0, 3), Layout((8, 8), (8, 1))) + M = to_F2_matrix(L) + # Swizzle adds XOR connections — off-diagonal 1s appear + assert M[0][3] == 1 # bit 0 gets XOR'd with bit 3 + _verify_F2_matrix(L) + + +def test_F2_matrix_hierarchical(): + """Hierarchical layout is flattened before matrix construction.""" + L = Layout(((2, 4), (2, 4)), ((1, 2), (8, 16))) + _verify_F2_matrix(L) + + +def test_F2_matrix_non_power_of_2_raises(): + """Non-power-of-2 shapes raise ValueError.""" + with pytest.raises(ValueError, match="not a power of 2"): + to_F2_matrix(Layout(6, 1)) + + +def test_F2_matrix_stride_2(): + """Strided layout: 4:2 maps coord bits to offset bits with a shift.""" + M = to_F2_matrix(Layout(4, 2)) + # stride 2 = 0b10: bit 0 of coord maps to bit 1 of offset + assert M == [[0, 0], [1, 0], [0, 1]] + _verify_F2_matrix(Layout(4, 2)) + + +def test_F2_matrix_swizzle_8x8_structure(): + """Swizzle(3,0,3) on 8x8 row-major: XOR creates off-diagonal 1s. + + Source: CuTe Swizzle(3,0,3) — the canonical LDMATRIX bank-conflict + avoidance pattern. See atoms_nv.py and + include/cute/atom/copy_traits_sm75.hpp. + + The F2 matrix shows how column bits get XOR'd with row bits: + col_i' = col_i XOR row_i (for i in 0..2) + row_i' = row_i (unchanged) + """ + L = compose(Swizzle(3, 0, 3), Layout((8, 8), (8, 1))) + M = to_F2_matrix(L) + # r0 r1 r2 c0 c1 c2 + assert M == [ + [1, 0, 0, 1, 0, 0], # offset bit 0 = col0 XOR row0 + [0, 1, 0, 0, 1, 0], # offset bit 1 = col1 XOR row1 + [0, 0, 1, 0, 0, 1], # offset bit 2 = col2 XOR row2 + [1, 0, 0, 0, 0, 0], # offset bit 3 = row0 + [0, 1, 0, 0, 0, 0], # offset bit 4 = row1 + [0, 0, 1, 0, 0, 0], # offset bit 5 = row2 + ] + _verify_F2_matrix(L) + + +def test_F2_matrix_sm80_mma_c_accumulator(): + """SM80 16x8x16 C accumulator: thread/value bits map to m/n coordinates. + + Thread shape (4,8) = 32 threads (5 bits: T0..T4) + Value shape (2,2) = 4 values (2 bits: V0, V1) + Output: 16×8 tile, col-major offset = m + 16*n (7 bits: m0..m3, n0..n2) + + The F2 matrix reveals the register assignment: + m0..m2 = T2..T4 (threads in groups of 4 select rows) + m3 = V1 (second value bit selects row 8-15 vs 0-7) + n0 = V0 (first value bit selects odd vs even column) + n1..n2 = T0..T1 (thread pairs select column groups) + """ + from tensor_layouts.atoms_nv import SM80_16x8x16_F16F16F16F16_TN + c = SM80_16x8x16_F16F16F16F16_TN.c_layout + M = to_F2_matrix(c) + # T0 T1 T2 T3 T4 V0 V1 + assert M == [ + [0, 0, 1, 0, 0, 0, 0], # m0 = T2 + [0, 0, 0, 1, 0, 0, 0], # m1 = T3 + [0, 0, 0, 0, 1, 0, 0], # m2 = T4 + [0, 0, 0, 0, 0, 0, 1], # m3 = V1 + [0, 0, 0, 0, 0, 1, 0], # n0 = V0 + [1, 0, 0, 0, 0, 0, 0], # n1 = T0 + [0, 1, 0, 0, 0, 0, 0], # n2 = T1 + ] + _verify_F2_matrix(c) + + +# ============================================================================= +# to_F2_matrix — cross-reference against Triton LinearLayout +# ============================================================================= +# +# Triton's LinearLayout represents GPU tensor core layouts as basis vectors +# over (register, lane, warp, block) → (dim0, dim1, ...) dimensions. +# +# Each basis vector (dim0_val, dim1_val) is a power-of-2 coordinate +# contribution. The mapping to our F2 matrix is: +# +# flat_offset = dim0 + M * dim1 (col-major, matching CuTe convention) +# F2 column j = binary decomposition of flat_offset for coord bit j +# +# The F2 matrix columns follow CuTe's flattened colexicographic order: +# thread sub-mode bits first (lane bits, then warp bits), then value +# sub-mode bits (register bits). This matches how Triton orders its +# input dimensions: lane, warp, register. +# +# Source file for known-good Triton representations: +# triton/unittest/Dialect/TritonGPU/LinearLayoutConversionsTest.cpp +# + + +def _triton_bases_to_F2_matrix(bases, tile_M, tile_N): + """Build expected F2 matrix from Triton LinearLayout basis vectors. + + Args: + bases: list of (dim0, dim1) tuples, ordered as: + lane bits (LSB first), warp bits, register bits. + This matches CuTe's flattened coord bit order. + tile_M: output tile rows (dim0 extent). + tile_N: output tile columns (dim1 extent). + + Returns: + F2 matrix (list of lists), same format as to_F2_matrix(). + """ + n_coord_bits = len(bases) + col_strides = [dim0 + tile_M * dim1 for dim0, dim1 in bases] + max_val = max(col_strides) if col_strides else 0 + tile_size = tile_M * tile_N + n_offset_bits = max((max(max_val, tile_size - 1)).bit_length(), 1) + + M = [[0] * n_coord_bits for _ in range(n_offset_bits)] + for j, stride in enumerate(col_strides): + for i in range(n_offset_bits): + M[i][j] = (stride >> i) & 1 + return M + + +def test_F2_matrix_sm80_c_vs_triton_MMAv2(): + """SM80 MMAv2 C accumulator matches Triton's LinearLayout. + + Validates the atom-level 16×8 C layout (SM80_16x8_Row) against + the basis vectors from Triton's MMAv2 encoding. All SM80/SM89/SM90 + warp-level and SM120 atoms with 16×8 C tiles share this layout. + + Source: LinearLayoutConversionsTest.cpp, TEST_F(MMAv2_16x16), line 433. + Atom-level bases extracted from the 16×16 tiled layout by taking + the first 2 register bases (atom values) and all 5 lane bases: + + register: {(0,1), (8,0)} — 2 bits → 4 values/thread + lane: {(0,2), (0,4), (1,0), (2,0), (4,0)} — 5 bits → 32 threads + """ + from tensor_layouts.atoms_nv import SM80_16x8x16_F16F16F16F16_TN + + c = SM80_16x8x16_F16F16F16F16_TN.c_layout + actual = to_F2_matrix(c) + + # Triton basis vectors — lane bits first, then register bits + # (matching CuTe's flattened thread → value coord bit order) + triton_bases = [ + # lane (thread) bases — from LinearLayoutConversionsTest.cpp:438 + (0, 2), (0, 4), (1, 0), (2, 0), (4, 0), + # register (value) bases — from LinearLayoutConversionsTest.cpp:438 + (0, 1), (8, 0), + ] + expected = _triton_bases_to_F2_matrix(triton_bases, tile_M=16, tile_N=8) + + assert actual == expected + _verify_F2_matrix(c) + + +def test_F2_matrix_sm80_c_all_atoms_share_layout(): + """All SM80+ atoms with 16×8 C tile produce the same F2 matrix. + + SM80_16x8_Row is shared across FP16, FP32, BF16, TF32, INT8, INT4, + FP8 (SM89), and SM120 atoms. This test verifies that the F2 + matrix is identical for a representative sample. + + Source: mma_traits_sm80.hpp line 53 (SM80_16x8_Row definition). + """ + from tensor_layouts.atoms_nv import ( + SM80_16x8x8_F16F16F16F16_TN, + SM80_16x8x16_F32F16F16F32_TN, + SM80_16x8x16_F32BF16BF16F32_TN, + SM80_16x8x32_S32S8S8S32_TN, + SM80_16x8x64_S32S4S4S32_TN, + SM89_16x8x32_F32E4M3E4M3F32_TN, + SM120_16x8x32_F32E4M3E4M3F32_TN, + ) + + ref = to_F2_matrix(SM80_16x8x8_F16F16F16F16_TN.c_layout) + for atom in [ + SM80_16x8x16_F32F16F16F32_TN, + SM80_16x8x16_F32BF16BF16F32_TN, + SM80_16x8x32_S32S8S8S32_TN, + SM80_16x8x64_S32S4S4S32_TN, + SM89_16x8x32_F32E4M3E4M3F32_TN, + SM120_16x8x32_F32E4M3E4M3F32_TN, + ]: + assert to_F2_matrix(atom.c_layout) == ref, atom.name + + +def test_F2_matrix_sm90_gmma_c_64x16_vs_triton_MMAv3(): + """SM90 GMMA 64×16 C accumulator matches Triton's MMAv3 LinearLayout. + + The GMMA warpgroup (128 threads) C layout maps (T128, V8) → 64×16 + tile. CuTe's thread dimension (4,8,4) subsumes Triton's lane+warp: + - Thread sub-modes (4,8) = 32 lanes → lane bits T0..T4 + - Thread sub-mode (4) = 4 warps → warp bits W0..W1 + + Source: LinearLayoutConversionsTest.cpp, TEST_F(MMAv3_64x16), line 522. + Both instrShapes {16,16,8} and {16,8,8} produce the same layout: + + register: {(0,1), (8,0), (0,8)} — 3 bits → 8 values + lane: {(0,2), (0,4), (1,0), (2,0), (4,0)} — 5 bits → 32 lanes + warp: {(16,0), (32,0)} — 2 bits → 4 warps + """ + from tensor_layouts.atoms_nv import SM90_64x16x16_F16F16F16_SS + + c = SM90_64x16x16_F16F16F16_SS.c_layout + actual = to_F2_matrix(c) + + # Triton basis vectors — lane, warp, register order + # (matching CuTe's flattened thread → value coord bit order) + triton_bases = [ + # lane bases — LinearLayoutConversionsTest.cpp:531 + (0, 2), (0, 4), (1, 0), (2, 0), (4, 0), + # warp bases — LinearLayoutConversionsTest.cpp:532 + (16, 0), (32, 0), + # register bases — LinearLayoutConversionsTest.cpp:530 + (0, 1), (8, 0), (0, 8), + ] + expected = _triton_bases_to_F2_matrix(triton_bases, tile_M=64, tile_N=16) + + assert actual == expected + _verify_F2_matrix(c) + + +def test_F2_matrix_sm90_gmma_c_parametric(): + """GMMA C accumulator F2 matrix is self-consistent for all standard N. + + Source: mma_traits_sm90_gmma.hpp line 432 (CLayout_64xN template). + Validates that to_F2_matrix faithfully reproduces the layout function + for every N in the standard GMMA repertoire. + """ + from tensor_layouts.atoms_nv import gmma_c_layout + + for n in [8, 16, 32, 64, 128, 256]: + c = gmma_c_layout(n) + _verify_F2_matrix(c) + + +def test_F2_matrix_sm80_a_operand(): + """SM80 16×8×16 A operand F2 matrix is self-consistent. + + A layout maps (T32, V8) → M×K = 16×16 tile. Unlike the C + accumulator, this cannot be directly compared against Triton's + DotOperand encoding (which applies kWidth packing), but the + F2 matrix must reproduce the layout function for all indices. + + Source: mma_traits_sm80.hpp, SM80_16x8x16 A layout. + """ + from tensor_layouts.atoms_nv import SM80_16x8x16_F16F16F16F16_TN + + a = SM80_16x8x16_F16F16F16F16_TN.a_layout + M = to_F2_matrix(a) + assert len(M) == 8 # 8 offset bits (cosize = 256 = 16×16) + assert len(M[0]) == 8 # 8 coord bits (5 thread + 3 value) + _verify_F2_matrix(a) + + +def test_F2_matrix_sm80_b_operand(): + """SM80 16×8×16 B operand F2 matrix is self-consistent. + + B layout maps (T32, V4) → N×K = 8×16 tile. + + Source: mma_traits_sm80.hpp, SM80_16x8x16 B layout. + """ + from tensor_layouts.atoms_nv import SM80_16x8x16_F16F16F16F16_TN + + b = SM80_16x8x16_F16F16F16F16_TN.b_layout + M = to_F2_matrix(b) + assert len(M) == 7 # 7 offset bits (cosize = 128 = 8×16) + assert len(M[0]) == 7 # 7 coord bits (5 thread + 2 value) + _verify_F2_matrix(b) + + +def test_F2_matrix_sm90_gmma_c_64x32_vs_triton_MMAv3(): + """SM90 GMMA 64×32 C accumulator matches Triton's MMAv3 LinearLayout. + + The GMMA warpgroup (128 threads) C layout maps (T128, V16) → 64×32. + CuTe's thread dimension (4,8,4) gives 7 thread bits; value dimension + (2,2,4) gives 4 value bits; total 11 bits = 2048 = 64×32. + + Source: LinearLayoutConversionsTest.cpp, TEST_F(MMAv3_4x2Warps), line 575. + instrShape {16,32,16}, warps {4,2}, tile {64,32}: + + register: {(0,1), (8,0), (0,8), (0,16)} — 4 bits → 16 values + lane: {(0,2), (0,4), (1,0), (2,0), (4,0)} — 5 bits → 32 lanes + warp: {(16,0), (32,0), (0,0)} — 3 bits → 8 warps + + The 3rd warp base (0,0) is a broadcast: with {4,2} warps for a + {64,32} tile, the 2 N-warps are redundant since the 16×32 atom + already covers 32 columns. The 11 non-zero bases correspond to + our 128-thread × 16-value GMMA atom. + """ + from tensor_layouts.atoms_nv import SM90_64x32x16_F16F16F16_SS + + c = SM90_64x32x16_F16F16F16_SS.c_layout + actual = to_F2_matrix(c) + + # Triton basis vectors — non-zero bases only, lane→warp→register order + triton_bases = [ + # lane bases — LinearLayoutConversionsTest.cpp:577 + (0, 2), (0, 4), (1, 0), (2, 0), (4, 0), + # warp bases (skipping W2=(0,0) broadcast) — line 578 + (16, 0), (32, 0), + # register bases — LinearLayoutConversionsTest.cpp:576 + (0, 1), (8, 0), (0, 8), (0, 16), + ] + expected = _triton_bases_to_F2_matrix(triton_bases, tile_M=64, tile_N=32) + + assert actual == expected + _verify_F2_matrix(c) + + +def test_F2_matrix_sm90_warp_c_vs_triton_MMAv3(): + """SM90 warp-level 16×8 C accumulator matches Triton MMAv3 bases. + + SM90 warp-level MMA atoms (F64, complex F64) reuse SM80_16x8_Row + as c_layout — the same per-thread register assignment as SM80. + + Source: LinearLayoutConversionsTest.cpp, TEST_F(MMAv3_64x16), line 522. + The atom-level bases (first 2 register + 5 lane) match MMAv2. + """ + from tensor_layouts.atoms_nv import ( + SM90_16x8x4_F64F64F64F64_TN, + SM90_16x8x16_F64F64F64F64_TN, + SM90_16x8x16_C64C64C64C64_TN, + ) + + # Same expected matrix as SM80 MMAv2 C accumulator + triton_bases = [ + (0, 2), (0, 4), (1, 0), (2, 0), (4, 0), # lane + (0, 1), (8, 0), # register + ] + expected = _triton_bases_to_F2_matrix(triton_bases, tile_M=16, tile_N=8) + + for atom in [ + SM90_16x8x4_F64F64F64F64_TN, + SM90_16x8x16_F64F64F64F64_TN, + SM90_16x8x16_C64C64C64C64_TN, + ]: + actual = to_F2_matrix(atom.c_layout) + assert actual == expected, atom.name + _verify_F2_matrix(atom.c_layout) + + +def test_F2_matrix_sm100_umma_c_identity(): + """SM100 UMMA C accumulator is col-major identity over F2. + + UMMA uses 1 thread with all M×N elements in the value dimension: + (1, (M, N)) : (0, (1, M)). Since stride-0 thread mode contributes + no bits, the F2 matrix reduces to the value-only mapping, which is + a pure identity (col-major offset = m + M*n). + + Source: mma_traits_sm100.hpp (tcgen05.mma UMMA instructions). + """ + from tensor_layouts.atoms_nv import SM100_64x64x16_F16F16F16_SS + + c = SM100_64x64x16_F16F16F16_SS.c_layout + M = to_F2_matrix(c) + n_bits = len(M) + assert n_bits == 12 # log2(64*64) = 12 + + # Should be identity: each coord bit maps to the same offset bit + for i in range(n_bits): + for j in range(n_bits): + assert M[i][j] == (1 if i == j else 0), ( + f"SM100 UMMA F2 not identity at [{i}][{j}]" + ) + _verify_F2_matrix(c) + + +def test_F2_matrix_sm100_umma_c_parametric(): + """SM100 UMMA C accumulator is self-consistent for all standard sizes. + + All UMMA sizes should produce identity F2 matrices (col-major). + + Source: mma_traits_sm100.hpp (tcgen05.mma UMMA instructions). + """ + from tensor_layouts.atoms_nv import umma_layout + + for m, n in [(64, 64), (64, 128), (64, 256), + (128, 64), (128, 128), (128, 256)]: + c = umma_layout(m, n) + M = to_F2_matrix(c) + n_bits = len(M) + # Identity check + for i in range(n_bits): + for j in range(n_bits): + assert M[i][j] == (1 if i == j else 0), ( + f"UMMA {m}×{n} F2 not identity at [{i}][{j}]" + ) + _verify_F2_matrix(c) + + if __name__ == "__main__": import subprocess import sys diff --git a/tests/external.py b/tests/external.py index dd45717..b2644de 100644 --- a/tests/external.py +++ b/tests/external.py @@ -1287,10 +1287,7 @@ def _test_left_inverse_cpp(layout): return # No broadcast modes — check injectivity and contiguity via enumeration - vals = set(layout(i) for i in range(size(layout))) - is_inj = len(vals) == size(layout) - is_contiguous = vals == set(range(size(layout))) - if is_inj and is_contiguous: + if is_contiguous(layout): for i in range(size(layout)): li = layout(i) ili = inv_layout(li) diff --git a/tests/layouts.py b/tests/layouts.py index e1cf319..484f688 100644 --- a/tests/layouts.py +++ b/tests/layouts.py @@ -400,6 +400,29 @@ def test_coalesce_by_mode_with_profile(): assert coalesce(L31, (8, 4)) == Layout((8, 4), (1, 8)) +def test_coalesce_per_mode_with_none_profile(): + """coalesce with (None, ...) profile coalesces each mode independently.""" + # Per-mode coalesce: simplify within each mode, preserve rank + A = Layout((2, (1, 6)), (1, (6, 2))) + assert coalesce(A, (None, None)) == Layout((2, 6), (1, 2)) + + # Hierarchical both modes + B = Layout(((2, 4), (2, 4)), ((1, 2), (8, 16))) + assert coalesce(B, (None, None)) == Layout((8, 8), (1, 8)) + + # Already flat — no-op + C = Layout((4, 8), (1, 4)) + assert coalesce(C, (None, None)) == C + + # Mode with size-1 sub-modes + E = Layout((2, (1, 1, 6)), (1, (0, 0, 2))) + assert coalesce(E, (None, None)) == Layout((2, 6), (1, 2)) + + # Without profile flattens across modes + assert coalesce(A) == Layout(12, 1) + assert coalesce(B) == Layout(64, 1) + + def test_complement_layouts(): assert complement(Layout(), 8) == Layout(8, 1) assert complement(Layout(4, 2), 16) == Layout((2, 2), (1, 8)) @@ -503,6 +526,37 @@ def test_idx2crd_crd2flat_crd2offset(): assert crd2idx(16, layout.shape, layout.stride) == 17 # 3-arg -> crd2offset +def test_idx2crd_accepts_layout(): + """idx2crd and crd2flat accept Layout objects as the shape argument.""" + L = Layout((3, (2, 4))) + for i in range(size(L)): + assert idx2crd(i, L) == idx2crd(i, L.shape) + crd = idx2crd(i, L.shape) + assert crd2flat(crd, L) == crd2flat(crd, L.shape) + + +def test_crd2crd_hierarchical_to_flat(): + """crd2crd converts hierarchical coords to flat coords with src_shape.""" + S = Layout(((2, 3), 2)) + src = S.shape # ((2, 3), 2) + dst = tuple(size(s) for s in src) # (6, 2) + + # Verify all coordinates round-trip correctly + for i in range(size(S)): + crd_hier = idx2crd(i, src) + crd_flat = crd2crd(crd_hier, dst, src) + assert crd_flat == idx2crd(i, dst) + + # Spot-check specific values + assert crd2crd(((0, 1), 0), (6, 2), ((2, 3), 2)) == (2, 0) + assert crd2crd(((1, 2), 1), (6, 2), ((2, 3), 2)) == (5, 1) + + # Existing behavior: expand int -> tuple, flatten tuple -> int + assert crd2crd(3, (2, 4)) == (1, 1) + assert crd2crd((1, 0), 8, (2, 4)) == 1 + assert crd2crd((1, 2), (3, 4)) == (1, 2) + + def test_shape_division(): ## Shape division and modulo, from Cute Layout Algebra docs assert shape_div((6, 2), 2) == (3, 2) @@ -2187,6 +2241,41 @@ def test_image_injectivity_consistency(): assert is_injective(l) == (len(img) == size(l)) +## is_contiguous + + +def test_is_contiguous_basic(): + """Contiguous layouts map to [0, size).""" + assert is_contiguous(Layout(4, 1)) + assert is_contiguous(Layout((2, 3), (1, 2))) + assert is_contiguous(Layout((2, 3), (3, 1))) + + +def test_is_contiguous_strided(): + """Strided layout has gaps -- not contiguous.""" + assert not is_contiguous(Layout(4, 2)) + + +def test_is_contiguous_broadcast(): + """Broadcast layout has aliasing -- not contiguous.""" + assert not is_contiguous(Layout((4, 2), (0, 1))) + + +def test_is_contiguous_agrees_with_bijective(): + """is_contiguous and is_bijective agree on all test layouts.""" + layouts = [ + Layout(4, 1), + Layout(4, 2), + Layout((4, 2), (0, 1)), + Layout((3, 3), (1, 3)), + Layout((2, 4), (4, 1)), + Layout((8, 8), (8, 1)), + Layout(1, 0), + ] + for l in layouts: + assert is_contiguous(l) == is_bijective(l) + + ## functionally_equal diff --git a/tests/oracle_nv.py b/tests/oracle_nv.py index 9f1e49e..44c06b6 100644 --- a/tests/oracle_nv.py +++ b/tests/oracle_nv.py @@ -686,16 +686,6 @@ def _is_injective(layout): return True -def _is_contiguous(layout): - """Check if a layout maps to a contiguous range [0, size-1]. - - A contiguous layout has cosize == size, meaning there are no gaps. - """ - s = size(layout) - if s == 0: - return True - vals = set(layout(i) for i in range(s)) - return vals == set(range(s)) def test_exhaustive_left_inverse_identity(): @@ -707,7 +697,7 @@ def test_exhaustive_left_inverse_identity(): for layout in _generate_small_layouts(): if not _is_injective(layout): continue - if not _is_contiguous(layout): + if not is_contiguous(layout): continue linv = left_inverse(layout) for i in range(size(layout)): @@ -828,8 +818,8 @@ def test_exhaustive_inverse_roundtrip(): f"right_inverse({layout}): L(R({i})) != {i}" ) - # left_inverse property: R(L(i)) == i (only for injective + contiguous layouts) - if _is_injective(layout) and _is_contiguous(layout): + # left_inverse property: R(L(i)) == i (only for contiguous layouts) + if is_contiguous(layout): linv = left_inverse(layout) for i in range(size(layout)): assert linv(layout(i)) == i, ( diff --git a/tests/oracle_rdna.py b/tests/oracle_rdna.py new file mode 100644 index 0000000..4632b39 --- /dev/null +++ b/tests/oracle_rdna.py @@ -0,0 +1,138 @@ +# MIT License — see LICENSE file for details. + +"""Structural tests for AMD RDNA WMMA atoms. + +Validates the (thread, value) -> element mappings for all RDNA3 and RDNA4 +WMMA atom definitions using algebraic invariants — no hardware required. +""" + +import pytest + +from tensor_layouts import Layout, size, rank, cosize +from tensor_layouts.atoms_amd import ( + MMA_ATOMS_RDNA3, MMA_ATOMS_RDNA4, + RDNA3_16x16x16_F32F16F16_WMMA, +) + + +def _num_threads(layout): + return size(layout.shape[0]) if isinstance(layout.shape, tuple) else size(layout.shape) + + +def _num_values(layout): + return size(layout.shape[1]) if isinstance(layout.shape, tuple) else 1 + + +ALL_ATOMS = MMA_ATOMS_RDNA3 + MMA_ATOMS_RDNA4 + + +@pytest.mark.parametrize("atom", ALL_ATOMS, ids=lambda a: a.name) +class TestWMMAStructural: + """Structural invariants that must hold for any valid WMMA atom.""" + + def test_c_layout_covers_all_elements(self, atom): + """Every element of the M × N output is touched exactly once.""" + m, n, k = atom.shape_mnk + c = atom.c_layout + num_t = _num_threads(c) + num_v = _num_values(c) + + seen = set() + for t in range(num_t): + for v in range(num_v): + offset = c(t, v) + assert 0 <= offset < m * n, \ + f"{atom.name}: offset {offset} out of range [0, {m*n})" + assert offset not in seen, \ + f"{atom.name}: duplicate offset {offset} at t={t}, v={v}" + seen.add(offset) + + assert len(seen) == m * n, \ + f"{atom.name}: covers {len(seen)} elements, expected {m*n}" + + def test_c_layout_thread_count(self, atom): + """Thread dimension has exactly 32 elements (wave32).""" + c = atom.c_layout + assert _num_threads(c) == 32, \ + f"{atom.name}: {_num_threads(c)} threads, expected 32" + + def test_a_layout_thread_count(self, atom): + a = atom.a_layout + assert _num_threads(a) == 32 + + def test_b_layout_thread_count(self, atom): + b = atom.b_layout + assert _num_threads(b) == 32 + + def test_c_layout_cosize_equals_mn(self, atom): + """C layout codomain spans exactly M × N.""" + m, n, k = atom.shape_mnk + c = atom.c_layout + assert cosize(c) == m * n + + def test_a_layout_cosize_equals_mk(self, atom): + """A layout codomain spans exactly M × K (no broadcast in WMMA).""" + m, n, k = atom.shape_mnk + a = atom.a_layout + assert cosize(a) == m * k + + def test_b_layout_cosize_equals_nk(self, atom): + """B layout codomain spans exactly N × K.""" + m, n, k = atom.shape_mnk + b = atom.b_layout + assert cosize(b) == n * k + + def test_thr_id_is_none(self, atom): + """RDNA WMMA atoms use identity thread mapping.""" + assert atom.thr_id is None + + def test_c_layout_rank_is_2(self, atom): + assert rank(atom.c_layout) == 2 + + def test_a_layout_rank_is_2(self, atom): + assert rank(atom.a_layout) == 2 + + def test_b_layout_rank_is_2(self, atom): + assert rank(atom.b_layout) == 2 + + def test_layout_sizes_match_shape_mnk(self, atom): + """Layout domain sizes are consistent with M, N, K.""" + m, n, k = atom.shape_mnk + assert size(atom.c_layout) == m * n + assert size(atom.a_layout) == 32 * _num_values(atom.a_layout) + assert size(atom.b_layout) == 32 * _num_values(atom.b_layout) + + def test_a_covers_all_elements(self, atom): + """A layout is a bijection from (T32, V) to M × K offsets.""" + m, n, k = atom.shape_mnk + a = atom.a_layout + num_t = _num_threads(a) + num_v = _num_values(a) + seen = set() + for t in range(num_t): + for v in range(num_v): + offset = a(t, v) + assert 0 <= offset < m * k + seen.add(offset) + assert len(seen) == m * k + + def test_b_covers_all_elements(self, atom): + """B layout is a bijection from (T32, V) to N × K offsets.""" + m, n, k = atom.shape_mnk + b = atom.b_layout + num_t = _num_threads(b) + num_v = _num_values(b) + seen = set() + for t in range(num_t): + for v in range(num_v): + offset = b(t, v) + assert 0 <= offset < n * k + seen.add(offset) + assert len(seen) == n * k + + +if __name__ == "__main__": + import subprocess + import sys + + raise SystemExit(subprocess.call([sys.executable, "-m", "pytest", __file__, "-v"])) diff --git a/tests/oracle_xe.py b/tests/oracle_xe.py new file mode 100644 index 0000000..64938d5 --- /dev/null +++ b/tests/oracle_xe.py @@ -0,0 +1,131 @@ +# MIT License — see LICENSE file for details. + +"""Structural tests for Intel Xe GPU DPAS atoms. + +Validates the (thread, value) -> element mappings for all Xe-HPC and +Xe-HPG DPAS atom definitions using algebraic invariants — no hardware required. +""" + +import pytest + +from tensor_layouts import Layout, size, rank, cosize +from tensor_layouts.atoms_xe import * + + +def _num_threads(layout): + return size(layout.shape[0]) if isinstance(layout.shape, tuple) else size(layout.shape) + + +def _num_values(layout): + return size(layout.shape[1]) if isinstance(layout.shape, tuple) else 1 + + +ALL_ATOMS = MMA_ATOMS_XeHPC + MMA_ATOMS_XeHPG + + +@pytest.mark.parametrize("atom", ALL_ATOMS, ids=lambda a: a.name) +class TestDPASStructural: + """Structural invariants that must hold for any valid DPAS atom.""" + + def test_c_layout_covers_all_elements(self, atom): + """Every element of the M × N output is touched exactly once.""" + m, n, k = atom.shape_mnk + c = atom.c_layout + num_t = _num_threads(c) + num_v = _num_values(c) + + seen = set() + for t in range(num_t): + for v in range(num_v): + offset = c(t, v) + assert 0 <= offset < m * n, \ + f"{atom.name}: offset {offset} out of range [0, {m*n})" + assert offset not in seen, \ + f"{atom.name}: duplicate offset {offset} at t={t}, v={v}" + seen.add(offset) + + assert len(seen) == m * n + + def test_c_layout_thread_count(self, atom): + """Thread count matches N dimension (subgroup size).""" + m, n, k = atom.shape_mnk + c = atom.c_layout + assert _num_threads(c) == n + + def test_a_layout_thread_count(self, atom): + m, n, k = atom.shape_mnk + a = atom.a_layout + assert _num_threads(a) == n + + def test_b_layout_thread_count(self, atom): + m, n, k = atom.shape_mnk + b = atom.b_layout + assert _num_threads(b) == n + + def test_a_layout_broadcast(self, atom): + """A layout broadcasts across subgroup (stride 0 on thread dim).""" + a = atom.a_layout + t_stride = a.stride[0] if isinstance(a.stride, tuple) else a.stride + assert t_stride == 0, \ + f"{atom.name}: A thread stride is {t_stride}, expected 0 (broadcast)" + + def test_c_layout_cosize_equals_mn(self, atom): + m, n, k = atom.shape_mnk + assert cosize(atom.c_layout) == m * n + + def test_b_layout_cosize_equals_nk(self, atom): + m, n, k = atom.shape_mnk + assert cosize(atom.b_layout) == n * k + + def test_thr_id_is_none(self, atom): + assert atom.thr_id is None + + def test_c_layout_rank_is_2(self, atom): + assert rank(atom.c_layout) == 2 + + def test_a_layout_rank_is_2(self, atom): + assert rank(atom.a_layout) == 2 + + def test_b_layout_rank_is_2(self, atom): + assert rank(atom.b_layout) == 2 + + def test_c_layout_column_ownership(self, atom): + """Each thread owns exactly one column of C.""" + m, n, k = atom.shape_mnk + c = atom.c_layout + num_t = _num_threads(c) + num_v = _num_values(c) + + for t in range(num_t): + cols = set() + for v in range(num_v): + offset = c(t, v) + col = offset // m # col-major: col = offset // M + cols.add(col) + assert len(cols) == 1, \ + f"{atom.name}: thread {t} touches columns {cols}, expected 1" + assert cols.pop() == t, \ + f"{atom.name}: thread {t} owns wrong column" + + def test_b_layout_column_ownership(self, atom): + """Each thread owns exactly one N-position of B.""" + m, n, k = atom.shape_mnk + b = atom.b_layout + num_t = _num_threads(b) + num_v = _num_values(b) + + for t in range(num_t): + ns = set() + for v in range(num_v): + offset = b(t, v) + n_pos = offset % n # col-major in N×K: n = offset % N + ns.add(n_pos) + assert len(ns) == 1 + assert ns.pop() == t + + +if __name__ == "__main__": + import subprocess + import sys + + raise SystemExit(subprocess.call([sys.executable, "-m", "pytest", __file__, "-v"])) diff --git a/tests/tensor.py b/tests/tensor.py index f443d02..546642c 100644 --- a/tests/tensor.py +++ b/tests/tensor.py @@ -273,14 +273,23 @@ def test_fix_all_modes(self): assert isinstance(result, int) assert result == tensor(i, j) - def test_single_index_slice(self): - """tensor[i] - single index fixes mode 0.""" + def test_single_index_flat_eval(self): + """tensor[i] — flat 1D evaluation on any-rank tensor. + + Matches CuTe C++ Tensor::operator()(int): the integer is decomposed + via idx2crd into the natural coordinate, then the offset is computed. + """ layout = Layout((4, 8), (1, 4)) tensor = Tensor(layout) - row = tensor[2] - assert isinstance(row, Tensor) - assert row.offset == 2 + # tensor[2] decomposes: idx2crd(2, (4,8)) = (2, 0) → offset 2 + result = tensor[2] + assert isinstance(result, int) + assert result == layout(2) + + # Verify for all flat indices + for i in range(size(layout)): + assert tensor[i] == layout(i) class TestTensorSlicingRowMajor: @@ -972,6 +981,475 @@ def test_cute_mma_fragment_pattern(self): # Verify they access different starting positions assert thread0_slice.offset != thread1_slice.offset or thread0_slice(0) != thread1_slice(0) + def test_hierarchical_slice_preserves_structure(self): + """Slicing with nested Nones preserves hierarchical mode boundaries. + + From arXiv:2603.02298, Figure 5: slicing the Cecka tensor. + """ + A = Layout(((3, 2), ((2, 3), 2)), ((4, 1), ((2, 15), 100))) + T = Tensor(A) + + # (2, ((0, None), None)) — fix mode 0 and partial mode 1 + Ts = T[(2, ((0, None), None))] + assert Ts.offset == 8 + assert Ts.layout.shape == (3, 2) + for j1 in range(3): + for j2 in range(2): + assert A(2, ((0, j1), j2)) == Ts.offset + Ts.layout(j1, j2) + + # ((1, None), ((None, 0), None)) — partial slice on both modes + Ts = T[((1, None), ((None, 0), None))] + assert Ts.offset == 4 + assert Ts.layout.shape == (2, (2, 2)) + for i1 in range(2): + for j0 in range(2): + for j2 in range(2): + assert A((1, i1), ((j0, 0), j2)) == Ts.offset + Ts.layout(i1, (j0, j2)) + + def test_tensor_slice_with_none(self): + """Tensor.__getitem__ accepts None as equivalent to slice(None).""" + layout = Layout((4, 8), (1, 4)) + T = Tensor(layout) + + # T[(2, None)] should equal T[2, :] + Ts_none = T[(2, None)] + Ts_colon = T[2, :] + assert Ts_none.offset == Ts_colon.offset + assert Ts_none.layout == Ts_colon.layout + + +# ============================================================================= +# Flat 1D Evaluation and Copy Algorithm +# ============================================================================= + + +class TestFlatEvaluation: + """Flat 1D evaluation: tensor[i] decomposes i via idx2crd on any rank.""" + + def test_flat_eval_rank2_row_major(self): + """Row-major rank-2 tensor: tensor[i] == layout(i) for all i.""" + layout = Layout((4, 8), (8, 1)) + t = Tensor(layout) + for i in range(size(layout)): + assert t[i] == layout(i) + + def test_flat_eval_rank2_col_major(self): + """Column-major rank-2 tensor: tensor[i] == layout(i) for all i.""" + layout = Layout((4, 8), (1, 4)) + t = Tensor(layout) + for i in range(size(layout)): + assert t[i] == layout(i) + + def test_flat_eval_rank3(self): + """Rank-3 tensor: flat 1D evaluation through all elements.""" + layout = Layout((2, 4, 8), (32, 8, 1)) + t = Tensor(layout) + for i in range(size(layout)): + assert t[i] == layout(i) + + def test_flat_eval_with_offset(self): + """Flat 1D evaluation respects base offset.""" + layout = Layout((4, 8), (8, 1)) + t = Tensor(layout, offset=100) + for i in range(size(layout)): + assert t[i] == 100 + layout(i) + + def test_flat_eval_with_data(self): + """Flat 1D evaluation with storage returns data[offset].""" + layout = Layout((4, 8), (8, 1)) + buf = list(range(32)) + t = Tensor(layout, data=buf) + for i in range(size(layout)): + assert t[i] == buf[layout(i)] + + def test_flat_eval_consistent_with_setitem(self): + """tensor[i] reads what tensor[i] = val wrote.""" + layout = Layout((4, 8), (8, 1)) + buf = [0] * 32 + t = Tensor(layout, data=buf) + for i in range(size(layout)): + t[i] = i * 10 + for i in range(size(layout)): + assert t[i] == i * 10 + + def test_slice_mode0_still_works(self): + """Mode-0 slicing uses tensor[i, :], not tensor[i].""" + layout = Layout((4, 8), (1, 4)) + t = Tensor(layout) + row = t[2, :] + assert isinstance(row, Tensor) + assert row.offset == 2 + for j in range(8): + assert row(j) == t(2, j) + + +class TestCopyAlgorithm: + """The canonical COPY algorithm: dst[i] = src[i] for all i.""" + + def test_copy_same_layout(self): + """Copy between tensors with the same layout.""" + layout = Layout((4, 8), (8, 1)) + src_buf = list(range(32)) + dst_buf = [0] * 32 + src = Tensor(layout, data=src_buf) + dst = Tensor(layout, data=dst_buf) + + for i in range(size(layout)): + dst[i] = src[i] + + for i in range(32): + assert dst_buf[i] == src_buf[i] + + def test_copy_different_layouts(self): + """Copy between row-major and column-major tensors. + + This is the motivating use case: different layouts over the same + logical shape produce different physical orderings, and copy() + must remap correctly. + """ + row_major = Layout((4, 8), (8, 1)) + col_major = Layout((4, 8), (1, 4)) + + src_buf = list(range(32)) + dst_buf = [0] * 32 + src = Tensor(row_major, data=src_buf) + dst = Tensor(col_major, data=dst_buf) + + assert size(src.layout) == size(dst.layout) + for i in range(size(src.layout)): + dst[i] = src[i] + + # Verify: same logical element at every coordinate + for i in range(4): + for j in range(8): + assert dst[i, j] == src[i, j] + + def test_copy_rank3(self): + """Copy works on rank-3 tensors.""" + layout_a = Layout((2, 4, 8), (32, 8, 1)) + layout_b = Layout((2, 4, 8), (1, 2, 8)) + + src_buf = list(range(64)) + dst_buf = [0] * 64 + src = Tensor(layout_a, data=src_buf) + dst = Tensor(layout_b, data=dst_buf) + + for i in range(size(layout_a)): + dst[i] = src[i] + + for b in range(2): + for h in range(4): + for w in range(8): + assert dst[b, h, w] == src[b, h, w] + + +# ============================================================================= +# Tensor Storage +# ============================================================================= + +class TestTensorStorage: + """Tests for Tensor data storage, element access, and view semantics.""" + + def test_construction_with_data(self): + """Tensor can be constructed with storage.""" + layout = Layout((4, 8), (8, 1)) + buf = list(range(32)) + t = Tensor(layout, data=buf) + assert t.data is buf + assert t.layout == layout + assert t.offset == 0 + + def test_construction_with_data_and_offset(self): + """Tensor can have both offset and data.""" + buf = list(range(64)) + t = Tensor(Layout((4, 8), (8, 1)), offset=5, data=buf) + assert t.offset == 5 + assert t.data is buf + + def test_data_too_small_raises(self): + """Storage smaller than cosize raises ValueError.""" + layout = Layout((4, 8), (8, 1)) # cosize = 32 + with pytest.raises(ValueError, match="smaller than layout cosize"): + Tensor(layout, data=list(range(10))) + + def test_data_larger_than_cosize(self): + """Storage can be larger than cosize.""" + layout = Layout((4, 8), (8, 1)) # cosize = 32 + buf = list(range(100)) + t = Tensor(layout, data=buf) + assert t.data is buf + + def test_data_none_by_default(self): + """Without data, tensor.data is None.""" + t = Tensor(Layout((4, 8), (8, 1))) + assert t.data is None + + def test_data_property_setter(self): + """The data property is writable.""" + layout = Layout((4, 8), (8, 1)) + t = Tensor(layout) + assert t.data is None + + buf = list(range(32)) + t.data = buf + assert t.data is buf + + def test_data_setter_validates_size(self): + """Setting data too small raises ValueError.""" + layout = Layout((4, 8), (8, 1)) # cosize = 32 + t = Tensor(layout) + with pytest.raises(ValueError, match="smaller than layout cosize"): + t.data = list(range(10)) + + def test_data_setter_accepts_none(self): + """Setting data to None removes storage.""" + buf = list(range(32)) + t = Tensor(Layout((4, 8), (8, 1)), data=buf) + t.data = None + assert t.data is None + + def test_getitem_returns_data_element(self): + """With data, tensor[i, j] returns data[offset].""" + layout = Layout((4, 8), (8, 1)) + buf = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345") + t = Tensor(layout, data=buf) + + assert t[0, 0] == "A" # buf[0] + assert t[0, 1] == "B" # buf[1] + assert t[1, 0] == "I" # buf[8] + assert t[3, 7] == "5" # buf[31] + + def test_getitem_without_data_returns_offset(self): + """Without data, tensor[i, j] still returns the offset integer.""" + layout = Layout((4, 8), (8, 1)) + t = Tensor(layout) + assert t[2, 3] == 19 + + def test_call_unaffected_by_data(self): + """tensor(i, j) always returns the offset, even with data.""" + layout = Layout((4, 8), (8, 1)) + buf = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345") + t = Tensor(layout, data=buf) + assert t(2, 3) == 19 # offset, not 'T' + + def test_getitem_single_mode_returns_data(self): + """Rank-1 tensor: tensor[i] returns data element.""" + buf = list("ABCDEFGH") + t = Tensor(Layout(8, 1), data=buf) + assert t[0] == "A" + assert t[7] == "H" + + def test_getitem_flat_eval_returns_data(self): + """Flat 1D evaluation with data returns data element, not sub-Tensor.""" + buf = list(range(32)) + t = Tensor(Layout((4, 8), (1, 4)), data=buf) + # t[2] does flat 1D eval: layout(2) = 2, returns buf[2] + result = t[2] + assert isinstance(result, int) + assert result == buf[t.layout(2)] + + def test_setitem_writes_to_data(self): + """tensor[i, j] = val writes data[offset].""" + buf = list(range(32)) + t = Tensor(Layout((4, 8), (8, 1)), data=buf) + + t[2, 3] = 999 + assert buf[19] == 999 + assert t[2, 3] == 999 + + def test_setitem_rank1(self): + """Scalar write on rank-1 tensor.""" + buf = list(range(16)) + t = Tensor(Layout(8, 2), data=buf) + t[3] = 42 + assert buf[6] == 42 # offset = 3*2 = 6 + + def test_setitem_without_data_raises(self): + """Writing to a tensor with no storage raises TypeError.""" + t = Tensor(Layout((4, 8), (8, 1))) + with pytest.raises(TypeError, match="no storage"): + t[2, 3] = 42 + + def test_slice_shares_data(self): + """Sub-Tensors from slicing share the parent's data.""" + buf = list(range(32)) + t = Tensor(Layout((4, 8), (8, 1)), data=buf) + row2 = t[2, :] + assert row2.data is buf + + def test_slice_data_read(self): + """Reading through a sliced sub-Tensor accesses correct data.""" + buf = list(range(32)) + t = Tensor(Layout((4, 8), (8, 1)), data=buf) + row2 = t[2, :] + # row2[3] should be buf[tensor(2, 3)] = buf[19] = 19 + assert row2[3] == 19 + assert row2[3] == t[2, 3] + + def test_slice_data_write(self): + """Writing through a sliced sub-Tensor modifies shared data.""" + buf = list(range(32)) + t = Tensor(Layout((4, 8), (8, 1)), data=buf) + row2 = t[2, :] + row2[3] = 999 + assert buf[19] == 999 + assert t[2, 3] == 999 + + def test_chained_slice_data(self): + """tensor[i, :][j] returns the same data element as tensor[i, j].""" + buf = list(range(32)) + t = Tensor(Layout((4, 8), (8, 1)), data=buf) + for i in range(4): + for j in range(8): + assert t[i, :][j] == t[i, j] + + def test_hierarchical_slice_propagates_data(self): + """Data is propagated through hierarchical partial slicing.""" + layout = Layout(((2, 4), 8), ((1, 2), 8)) + buf = list(range(cosize(layout))) + t = Tensor(layout, data=buf) + + sub = t[((0, None), None)] + assert sub.data is buf + + def test_data_swap_does_not_affect_existing_slices(self): + """Reassigning parent.data does not update existing sub-Tensors.""" + buf1 = list(range(32)) + buf2 = list(range(100, 132)) + t = Tensor(Layout((4, 8), (8, 1)), data=buf1) + row = t[2, :] + + t.data = buf2 + # row still references buf1 + assert row.data is buf1 + assert row[0] == 16 # buf1[16] + # parent now reads from buf2 + assert t[2, 0] == 116 # buf2[16] + + +# ============================================================================= +# Tensor Equality with Data +# ============================================================================= + +class TestTensorEqualityWithData: + """Tests for __eq__ when storage is present.""" + + def test_same_contents_equal(self): + """Tensors with same layout, offset, and data contents are equal.""" + layout = Layout(8, 1) + a = Tensor(layout, data=[1, 2, 3, 4, 5, 6, 7, 8]) + b = Tensor(layout, data=[1, 2, 3, 4, 5, 6, 7, 8]) + assert a == b + + def test_different_contents_not_equal(self): + """Tensors with different data contents are not equal.""" + layout = Layout(8, 1) + a = Tensor(layout, data=[1, 2, 3, 4, 5, 6, 7, 8]) + b = Tensor(layout, data=[8, 7, 6, 5, 4, 3, 2, 1]) + assert a != b + + def test_one_has_data_other_does_not(self): + """Tensor with data != Tensor without data.""" + layout = Layout(8, 1) + a = Tensor(layout, data=[1, 2, 3, 4, 5, 6, 7, 8]) + b = Tensor(layout) + assert a != b + assert b != a + + def test_both_none_equal(self): + """Two algebraic Tensors with same layout/offset are equal (existing behavior).""" + layout = Layout((4, 8), (8, 1)) + a = Tensor(layout) + b = Tensor(layout) + assert a == b + + def test_same_data_identity_shortcut(self): + """Tensors sharing the same data object are equal.""" + layout = Layout(8, 1) + buf = [1, 2, 3, 4, 5, 6, 7, 8] + a = Tensor(layout, data=buf) + b = Tensor(layout, data=buf) + assert a == b + + def test_different_data_lengths_not_equal(self): + """Tensors with different data lengths are not equal.""" + layout = Layout(4, 1) + a = Tensor(layout, data=[1, 2, 3, 4]) + b = Tensor(layout, data=[1, 2, 3, 4, 5, 6, 7, 8]) + assert a != b + + def test_hash_consistent_with_equality(self): + """Equal Tensors must have equal hashes.""" + layout = Layout(8, 1) + a = Tensor(layout, data=[1, 2, 3, 4, 5, 6, 7, 8]) + b = Tensor(layout, data=[1, 2, 3, 4, 5, 6, 7, 8]) + assert a == b + assert hash(a) == hash(b) + + def test_different_data_can_collide_hash(self): + """Tensors with different data may have same hash (collision OK).""" + layout = Layout(8, 1) + a = Tensor(layout, data=[1, 2, 3, 4, 5, 6, 7, 8]) + b = Tensor(layout, data=[8, 7, 6, 5, 4, 3, 2, 1]) + # Same hash is allowed even though a != b + assert hash(a) == hash(b) # both have same (layout, offset) + assert a != b + + +class TestView: + """Tests for Tensor.view().""" + + def test_view_shares_data(self): + """View shares the same backing storage.""" + buf = list("ABCDEFGH") + t = Tensor(Layout((2, 4), (4, 1)), data=buf) + flat = t.view(Layout(8, 1)) + assert flat.data is t.data + + def test_view_reads_same_data(self): + """View reads from the shared storage.""" + buf = list("ABCDEFGH") + t = Tensor(Layout((2, 4), (4, 1)), data=buf) + flat = t.view(Layout(8, 1)) + assert flat[0] == "A" + assert flat[7] == "H" + + def test_view_write_visible(self): + """Writes through a view are visible in the original.""" + buf = list("ABCDEFGH") + t = Tensor(Layout((2, 4), (4, 1)), data=buf) + flat = t.view(Layout(8, 1)) + flat[0] = "Z" + assert t[0, 0] == "Z" + + def test_view_different_layout(self): + """View can reshape to a different rank.""" + buf = list(range(12)) + t = Tensor(Layout(12, 1), data=buf) + reshaped = t.view(Layout((3, 4), (4, 1))) + assert reshaped[1, 2] == buf[1 * 4 + 2] + + def test_view_no_storage_raises(self): + """View on algebraic Tensor raises TypeError.""" + t = Tensor(Layout(8, 1)) + with pytest.raises(TypeError): + t.view(Layout(8, 1)) + + def test_view_cosize_too_large_raises(self): + """View with cosize exceeding storage raises ValueError.""" + buf = list(range(8)) + t = Tensor(Layout(8, 1), data=buf) + with pytest.raises(ValueError): + t.view(Layout(16, 1)) + + def test_view_smaller_cosize(self): + """View with smaller cosize is allowed.""" + buf = list(range(16)) + t = Tensor(Layout(16, 1), data=buf) + small = t.view(Layout(4, 1)) + assert small[0] == 0 + assert small[3] == 3 + if __name__ == "__main__": import subprocess diff --git a/tests/viz.py b/tests/viz.py index e34ab7c..fc1042e 100644 --- a/tests/viz.py +++ b/tests/viz.py @@ -25,11 +25,8 @@ import pytest -from tensor_layouts import Layout, Swizzle +from tensor_layouts import * from tensor_layouts.tensor import Tensor -from tensor_layouts.layouts import ( - mode, rank, flat_divide, tiled_divide, flat_product, -) from tensor_layouts.atoms_amd import ( CDNA3P_16x16x32_F32F16F16_MFMA, CDNA3_32x32x16_F32F8F8_MFMA, @@ -46,9 +43,19 @@ import matplotlib.pyplot as plt from matplotlib.colors import to_rgba from matplotlib.transforms import Bbox + from tensor_layouts.viz import * import tensor_layouts.viz as viz_mod from tensor_layouts.viz import ( + _build_combined_grid_figure, + _build_composite_figure, + _build_copy_figure, + _build_gemm_figure, + _build_layout_figure, + _build_mma_figure, + _build_slice_figure, _build_swizzle_figure, + _build_tiled_grid_figure, + _build_tv_figure, _compute_tv_mapping, _draw_hierarchical_grid, _format_hierarchical_cell_lines, @@ -61,32 +68,11 @@ _get_hierarchical_indices_2d, _get_indices_2d, _get_color_indices_2d, - draw_composite, - draw_copy_layout, - draw_copy_atom, - draw_layout, - draw_mma_layout, - draw_combined_mma_grid, - draw_slice, - draw_swizzle, - draw_tiled_grid, - draw_tv_layout, - show_copy_layout, - show_copy_atom, - show_composite, - show_layout, - show_mma_layout, - show_combined_mma_grid, - show_slice, - show_swizzle, - show_tiled_grid, - show_tv_layout, ) HAS_VIZ = True except ImportError: HAS_VIZ = False - requires_viz = pytest.mark.skipif( not HAS_VIZ, reason="tensor_layouts.viz not available (needs matplotlib)" @@ -121,10 +107,11 @@ def _call_draw_hierarchical_grid(ax, layout, **kwargs): ] + @requires_viz -def test_show_layout_returns_figure_without_raising(): - """Smoke test for show_layout helper.""" - fig = show_layout(Layout((8, 8), (8, 1))) +def test_draw_layout_returns_figure_without_raising(): + """Smoke test for draw_layout helper.""" + fig = _build_layout_figure(Layout((8, 8), (8, 1))) try: assert isinstance(fig, matplotlib.figure.Figure) assert len(fig.axes) == 1 @@ -132,10 +119,11 @@ def test_show_layout_returns_figure_without_raising(): plt.close(fig) + @requires_viz -def test_show_swizzle_returns_figure_without_raising(): - """Regression test for show_swizzle helper.""" - fig = show_swizzle(Layout((8, 8), (8, 1)), Swizzle(3, 0, 3)) +def test_draw_swizzle_returns_figure_without_raising(): + """Regression test for draw_swizzle helper.""" + fig = _build_swizzle_figure(Layout((8, 8), (8, 1)), Swizzle(3, 0, 3)) try: assert isinstance(fig, matplotlib.figure.Figure) assert len(fig.axes) == 2 @@ -143,12 +131,13 @@ def test_show_swizzle_returns_figure_without_raising(): plt.close(fig) + @requires_viz -def test_show_layout_accepts_tensor(): - """draw_layout/show_layout accept Tensor and display offset-adjusted values.""" +def test_draw_layout_accepts_tensor(): + """draw_layout/draw_layout accept Tensor and display offset-adjusted values.""" layout = Layout((4, 8), (8, 1)) tensor = Tensor(layout, offset=16) - fig = show_layout(tensor) + fig = _build_layout_figure(tensor) try: assert isinstance(fig, matplotlib.figure.Figure) # Cell (0,0) at position (0.5, 0.5) should show 16 (offset), not 0 @@ -163,13 +152,14 @@ def test_show_layout_accepts_tensor(): plt.close(fig) + @requires_viz -def test_show_layout_tensor_zero_offset(): +def test_draw_layout_tensor_zero_offset(): """Tensor with offset=0 produces same values as bare Layout.""" layout = Layout((4, 4), (4, 1)) tensor = Tensor(layout, offset=0) - fig_layout = show_layout(layout) - fig_tensor = show_layout(tensor) + fig_layout = _build_layout_figure(layout) + fig_tensor = _build_layout_figure(tensor) try: def _cell_values(fig): ax = fig.axes[0] @@ -182,31 +172,34 @@ def _cell_values(fig): plt.close(fig_tensor) + @requires_viz -def test_show_layout_swizzled_tensor(): +def test_draw_layout_swizzled_tensor(): """Swizzled Tensor renders without error.""" sw = Swizzle(3, 0, 3) layout = Layout((8, 8), (8, 1), swizzle=sw) tensor = Tensor(layout, offset=0) - fig = show_layout(tensor) + fig = _build_layout_figure(tensor) try: assert isinstance(fig, matplotlib.figure.Figure) finally: plt.close(fig) + @requires_viz def test_draw_layout_smoke(): with tempfile.NamedTemporaryFile(suffix=".png") as f: draw_layout(Layout((8, 8), (8, 1)), filename=f.name) + @requires_viz def test_color_by_row_matches_color_layout(): """color_by='row' produces the same color indices as the manual color_layout.""" layout = Layout((4, 8), (8, 1)) - fig_by = show_layout(layout, color_by="row") - fig_manual = show_layout(layout, color_layout=Layout((4, 8), (1, 0)), + fig_by = _build_layout_figure(layout, color_by="row") + fig_manual = _build_layout_figure(layout, color_layout=Layout((4, 8), (1, 0)), colorize=True) try: # Both should have the same cell background colors @@ -220,46 +213,50 @@ def test_color_by_row_matches_color_layout(): plt.close(fig_manual) + @requires_viz def test_color_by_column(): """color_by='column' renders without error.""" - fig = show_layout(Layout((4, 8), (8, 1)), color_by="column") + fig = _build_layout_figure(Layout((4, 8), (8, 1)), color_by="column") try: assert isinstance(fig, matplotlib.figure.Figure) finally: plt.close(fig) + @requires_viz def test_color_by_and_color_layout_exclusive(): """Providing both color_by and color_layout raises ValueError.""" with pytest.raises(ValueError, match="mutually exclusive"): - show_layout(Layout((4, 4), (4, 1)), + draw_layout(Layout((4, 4), (4, 1)), color_by="row", color_layout=Layout((4, 4), (1, 0))) + @requires_viz def test_rank3_layout_produces_multi_panel(): """Rank-3 layout from flat_divide renders as multiple 2D panels.""" matrix = Layout((8, 8), (8, 1)) divided = flat_divide(matrix, Layout(2, 1)) assert rank(divided) == 3 - fig = show_layout(divided) + fig = _build_layout_figure(divided) try: - # shape=(2, 4, 8) → 2 panels of 4×8 + # shape=(2, 4, 8) → modes 0,1 are 2×4 grid, mode 2 = 8 panels with_content = [ax for ax in fig.axes if len(ax.patches) > 0] - assert len(with_content) == 2 + assert len(with_content) == 8 finally: plt.close(fig) + @requires_viz def test_rank3_panel_values_match_layout(): """Each rank-3 panel shows correct offset values.""" matrix = Layout((8, 8), (8, 1)) divided = flat_divide(matrix, Layout(2, 1)) - fig = show_layout(divided) + fig = _build_layout_figure(divided) try: def _cell_val(ax, x, y): for t in ax.texts: @@ -272,14 +269,15 @@ def _cell_val(ax, x, y): pass return None - # Panel 0: divided(0, 0, 0) + # Panel 0: divided(0, 0, 0) — mode[2]=0 assert _cell_val(fig.axes[0], 0.5, 0.5) == divided(0, 0, 0) - # Panel 1: divided(1, 0, 0) - assert _cell_val(fig.axes[1], 0.5, 0.5) == divided(1, 0, 0) + # Panel 1: divided(0, 0, 1) — mode[2]=1 + assert _cell_val(fig.axes[1], 0.5, 0.5) == divided(0, 0, 1) finally: plt.close(fig) + @requires_viz def test_rank4_layout_renders(): """Rank-4 layout renders with multiple panels (outer modes flattened).""" @@ -288,29 +286,32 @@ def test_rank4_layout_renders(): # Use a simple manual rank-4 layout: L = Layout((2, 3, 4, 5), (60, 20, 5, 1)) assert rank(L) == 4 - fig = show_layout(L) + fig = _build_layout_figure(L) try: - # 2*3=6 panels of 4×5 + # modes 0,1 = 2×3 grid, modes 2,3 = 4×5 = 20 panels with_content = [ax for ax in fig.axes if len(ax.patches) > 0] - assert len(with_content) == 6 + assert len(with_content) == 20 finally: plt.close(fig) + @requires_viz def test_draw_swizzle_smoke(): with tempfile.NamedTemporaryFile(suffix=".png") as f: draw_swizzle(Layout((8, 8), (8, 1)), Swizzle(3, 0, 3), filename=f.name) + @requires_viz def test_draw_slice_smoke(): with tempfile.NamedTemporaryFile(suffix=".png") as f: draw_slice(Layout((4, 8), (8, 1)), (2, None), filename=f.name) -@requires_viz + @pytest.mark.parametrize("atom", MIXED_VIZ_ATOMS, ids=lambda a: a.name) +@requires_viz def test_draw_tv_layout_smoke(atom): m, n, _ = atom.shape_mnk with tempfile.NamedTemporaryFile(suffix=".png") as f: @@ -323,8 +324,9 @@ def test_draw_tv_layout_smoke(atom): ) -@requires_viz + @pytest.mark.parametrize("atom", MIXED_VIZ_ATOMS, ids=lambda a: a.name) +@requires_viz def test_draw_mma_layout_smoke(atom): with tempfile.NamedTemporaryFile(suffix=".png") as f: draw_mma_layout( @@ -338,6 +340,7 @@ def test_draw_mma_layout_smoke(atom): ) + @requires_viz def test_draw_mma_layout_raises_for_incompatible_panel_shape(): a_layout = Layout((2, 2), (1, 2)) @@ -356,8 +359,9 @@ def test_draw_mma_layout_raises_for_incompatible_panel_shape(): plt.close("all") -@requires_viz + @pytest.mark.parametrize("atom", MIXED_VIZ_ATOMS, ids=lambda a: a.name) +@requires_viz def test_draw_tiled_grid_smoke(atom): atom_layout = Layout((2, 2), (1, 2)) grid, tile_shape = tile_mma_grid(atom, atom_layout, matrix="C") @@ -371,6 +375,7 @@ def test_draw_tiled_grid_smoke(atom): ) + @requires_viz def test_draw_composite_smoke(): panels = [Layout((4, 4), (4, 1)), Layout((4, 4), (1, 4))] @@ -384,6 +389,7 @@ def test_draw_composite_smoke(): ) + @requires_viz def test_draw_composite_mixed_tv_and_offset(): """Composite figure with per-panel tv_mode: one offset grid, one TV grid.""" @@ -392,7 +398,7 @@ def test_draw_composite_mixed_tv_and_offset(): Layout((4, 4), (4, 1)), # offset grid (default) (atom.c_layout, {'tv_mode': True}), # TV grid ] - fig = show_composite(panels, titles=["Offset", "TV"]) + fig = _build_composite_figure(panels, titles=["Offset", "TV"]) try: assert isinstance(fig, matplotlib.figure.Figure) assert len(fig.axes) == 2 @@ -400,6 +406,7 @@ def test_draw_composite_mixed_tv_and_offset(): plt.close(fig) + @requires_viz def test_draw_composite_hierarchical_panel(): """Composite figure with flatten_hierarchical=False renders hierarchy lines.""" @@ -409,7 +416,7 @@ def test_draw_composite_hierarchical_panel(): (hier, {'flatten_hierarchical': False}), flat, ] - fig = show_composite(panels, titles=["Hierarchical", "Flat"]) + fig = _build_composite_figure(panels, titles=["Hierarchical", "Flat"]) try: assert isinstance(fig, matplotlib.figure.Figure) # The hierarchical panel should have hierarchy boundary lines @@ -422,11 +429,12 @@ def test_draw_composite_hierarchical_panel(): plt.close(fig) + @requires_viz def test_draw_composite_hierarchical_top_level_default(): """flatten_hierarchical=False as top-level default applies to all panels.""" hier = Layout(((2, 2), (2, 2)), ((1, 4), (2, 8))) - fig = show_composite([hier], flatten_hierarchical=False) + fig = _build_composite_figure([hier], flatten_hierarchical=False) try: ax = fig.axes[0] assert len(ax.lines) > 0 @@ -434,15 +442,17 @@ def test_draw_composite_hierarchical_top_level_default(): plt.close(fig) + @requires_viz def test_draw_composite_warns_on_panel_truncation(): """Warning emitted when panels exceed grid capacity.""" panels = [Layout((2, 2), (2, 1)) for _ in range(5)] with pytest.warns(UserWarning, match="5 panels.*4 cells"): - fig = show_composite(panels, arrangement="grid:2x2") + fig = _build_composite_figure(panels, arrangement="grid:2x2") plt.close(fig) + @requires_viz def test_draw_copy_layout_smoke(): src = Layout((4, 2), (2, 1)) @@ -452,6 +462,7 @@ def test_draw_copy_layout_smoke(): title="copy smoke", colorize=True) + @requires_viz def test_draw_copy_layout_rejects_rank1(): with pytest.raises(ValueError, match="rank 2"): @@ -459,17 +470,19 @@ def test_draw_copy_layout_rejects_rank1(): filename="ignored.png") + @requires_viz -def test_show_copy_layout_returns_figure(): +def test_draw_copy_layout_returns_figure(): src = Layout((4, 2), (2, 1)) dst = Layout((4, 2), (1, 4)) - fig = show_copy_layout(src, dst, title="copy show") + fig = _build_copy_figure(src, dst, title="copy show") try: assert isinstance(fig, matplotlib.figure.Figure) finally: plt.close(fig) + @requires_viz def test_draw_copy_atom_smoke(): """draw_copy_atom handles the upcast from bit coordinates automatically.""" @@ -478,31 +491,30 @@ def test_draw_copy_atom_smoke(): draw_copy_atom(SM75_U32x1_LDSM_N, element_bits=16, filename=f.name) + @requires_viz -def test_show_copy_atom_returns_figure(): - """show_copy_atom returns a Figure for Jupyter display.""" +def test_draw_copy_atom_returns_figure(): + """draw_copy_atom renders without raising.""" from tensor_layouts.atoms_nv import SM90_U32x4_STSM_N - fig = show_copy_atom(SM90_U32x4_STSM_N, element_bits=16) - try: - assert isinstance(fig, matplotlib.figure.Figure) - finally: - plt.close(fig) + draw_copy_atom(SM90_U32x4_STSM_N, element_bits=16) + @requires_viz -def test_show_tv_layout_returns_figure(): - fig = show_tv_layout(Layout((4, 2), (2, 1))) +def test_draw_tv_layout_returns_figure(): + fig = _build_tv_figure(Layout((4, 2), (2, 1))) try: assert isinstance(fig, matplotlib.figure.Figure) finally: plt.close(fig) + @requires_viz -def test_show_mma_layout_returns_figure(): +def test_draw_mma_layout_returns_figure(): from tensor_layouts.atoms_nv import SM80_16x8x16_F16F16F16F16_TN atom = SM80_16x8x16_F16F16F16F16_TN - fig = show_mma_layout(atom.a_layout, atom.b_layout, atom.c_layout, + fig = _build_mma_figure(atom.a_layout, atom.b_layout, atom.c_layout, tile_mnk=atom.shape_mnk, colorize=True, thr_id_layout=atom.thr_id) try: @@ -511,33 +523,36 @@ def test_show_mma_layout_returns_figure(): plt.close(fig) + @requires_viz -def test_show_tiled_grid_returns_figure(): +def test_draw_tiled_grid_returns_figure(): from tensor_layouts.atoms_nv import SM80_16x8x16_F16F16F16F16_TN atom = SM80_16x8x16_F16F16F16F16_TN atom_layout = Layout((2, 2), (1, 2)) grid, tile_shape = tile_mma_grid(atom, atom_layout, matrix="C") - fig = show_tiled_grid(grid, tile_shape[0], tile_shape[1], title="tiled") + fig = _build_tiled_grid_figure(grid, tile_shape[0], tile_shape[1], title="tiled") try: assert isinstance(fig, matplotlib.figure.Figure) finally: plt.close(fig) + @requires_viz -def test_show_slice_returns_figure(): - fig = show_slice(Layout((4, 8), (8, 1)), (2, None)) +def test_draw_slice_returns_figure(): + fig = _build_slice_figure(Layout((4, 8), (8, 1)), (2, None)) try: assert isinstance(fig, matplotlib.figure.Figure) finally: plt.close(fig) + @requires_viz -def test_show_composite_returns_figure(): +def test_draw_composite_returns_figure(): l1 = Layout((4, 4), (4, 1)) l2 = Layout((4, 4), (1, 4)) - fig = show_composite([l1, l2], titles=["Row", "Col"]) + fig = _build_composite_figure([l1, l2], titles=["Row", "Col"]) try: assert isinstance(fig, matplotlib.figure.Figure) assert len(fig.axes) == 2 @@ -545,12 +560,202 @@ def test_show_composite_returns_figure(): plt.close(fig) + +@requires_viz +def test_draw_composite_tensor_data_labels(): + """Tensor panels show data values, not raw offsets, in cell text.""" + t = Tensor(Layout(4, 1), data=list("WXYZ")) + fig = _build_composite_figure([t], titles=["Data"]) + try: + ax = fig.axes[0] + cell_texts = [c.get_text() for c in ax.texts + if c.get_text() in ("W", "X", "Y", "Z")] + assert len(cell_texts) == 4, f"expected data labels, got {cell_texts}" + finally: + plt.close(fig) + + + +@requires_viz +def test_draw_composite_layout_shows_offsets(): + """Layout panels show offset integers, not data.""" + fig = _build_composite_figure([Layout(4, 1)], titles=["Offsets"]) + try: + ax = fig.axes[0] + cell_texts = sorted(c.get_text() for c in ax.texts + if c.get_text().isdigit()) + assert "0" in cell_texts and "3" in cell_texts + finally: + plt.close(fig) + + + +@requires_viz +def test_draw_composite_auto_panel_size_compact_for_1d(): + """Auto panel_size produces compact height for rank-1 layouts.""" + fig = _build_composite_figure([Layout(8, 1)]) + try: + _, h = fig.get_size_inches() + assert h < 3.0, f"1-row layout should be compact, got height={h}" + finally: + plt.close(fig) + + + +@requires_viz +def test_draw_composite_auto_panel_size_scales_with_rows(): + """Auto panel_size grows taller for layouts with more rows.""" + fig_1d = _build_composite_figure([Layout(8, 1)]) + fig_2d = _build_composite_figure([Layout((4, 8), (8, 1))]) + try: + _, h_1d = fig_1d.get_size_inches() + _, h_2d = fig_2d.get_size_inches() + assert h_2d > h_1d, f"4×8 should be taller than 1×8: {h_2d} vs {h_1d}" + finally: + plt.close(fig_1d) + plt.close(fig_2d) + + + +@requires_viz +def test_draw_composite_explicit_panel_size_overrides_auto(): + """Explicit panel_size takes precedence over auto-compute.""" + fig = _build_composite_figure([Layout(8, 1)], panel_size=(5.0, 5.0)) + try: + w, h = fig.get_size_inches() + assert abs(w - 5.0) < 0.1 and abs(h - 5.0) < 0.1 + finally: + plt.close(fig) + + + +@requires_viz +def test_draw_composite_cell_labels_offset_kwarg(): + """cell_labels='offset' passed as kwarg forces offset display for Tensors.""" + t = Tensor(Layout(4, 1), data=list("WXYZ")) + fig = _build_composite_figure([t], cell_labels="offset") + try: + ax = fig.axes[0] + cell_texts = [c.get_text() for c in ax.texts] + # Should show offsets (0, 1, 2, 3), not letters + assert "0" in cell_texts and "3" in cell_texts + assert "W" not in cell_texts + finally: + plt.close(fig) + + + +@requires_viz +def test_draw_composite_per_panel_override_wins(): + """Per-panel option dict overrides top-level kwarg.""" + t = Tensor(Layout(4, 1), data=list("WXYZ")) + # Top-level says offset, but per-panel says show data (True = auto) + fig = _build_composite_figure( + [(t, {"cell_labels": True})], + cell_labels="offset", + ) + try: + ax = fig.axes[0] + cell_texts = [c.get_text() for c in ax.texts + if c.get_text() in ("W", "X", "Y", "Z")] + assert len(cell_texts) == 4 + finally: + plt.close(fig) + + + +# --- draw_gemm tests --- + +@requires_viz +def test_draw_gemm_smoke(): + """draw_gemm produces a figure with 4 axes (empty + A + B^T + C).""" + A = Layout((4, 2), (1, 4)) + B = Layout((3, 2), (1, 3)) + C = Layout((4, 3), (1, 4)) + fig = _build_gemm_figure(A, B, C, main_title="GEMM smoke") + try: + assert isinstance(fig, matplotlib.figure.Figure) + # 4 axes: empty (hidden) + A + B^T + C + assert len(fig.axes) == 4 + finally: + plt.close(fig) + + + +@requires_viz +def test_draw_gemm_tensor_shows_data(): + """Tensor operands display data values, not offsets.""" + A = Tensor(Layout((2, 2), (1, 2)), data=list("ABCD")) + B = Tensor(Layout((2, 2), (1, 2)), data=list("WXYZ")) + C = Tensor(Layout((2, 2), (1, 2)), data=[0, 1, 2, 3]) + fig = _build_gemm_figure(A, B, C) + try: + # Check A panel (axes[2] = bottom-left) + a_texts = [c.get_text() for c in fig.axes[2].texts + if c.get_text() in ("A", "B", "C", "D")] + assert len(a_texts) == 4, f"expected A data labels, got {a_texts}" + finally: + plt.close(fig) + + + +@requires_viz +def test_draw_gemm_b_transposed(): + """B panel title shows transposed dimensions K×N.""" + A = Layout((4, 2), (1, 4)) + B = Layout((3, 2), (1, 3)) + C = Layout((4, 3), (1, 4)) + fig = _build_gemm_figure(A, B, C) + try: + # B^T panel is axes[1] (top-right) + b_title = fig.axes[1].get_title() + assert "2\u00d73" in b_title, f"B^T title should show K×N=2×3, got {b_title}" + finally: + plt.close(fig) + + + +@requires_viz +def test_draw_gemm_cell_labels_offset(): + """cell_labels='offset' forces offset display for Tensor operands.""" + A = Tensor(Layout((2, 2), (1, 2)), data=list("ABCD")) + B = Tensor(Layout((2, 2), (1, 2)), data=list("WXYZ")) + C = Tensor(Layout((2, 2), (1, 2)), data=[0, 1, 2, 3]) + fig = _build_gemm_figure(A, B, C, cell_labels="offset") + try: + a_texts = [c.get_text() for c in fig.axes[2].texts] + assert "A" not in a_texts, "should show offsets, not data" + assert "0" in a_texts + finally: + plt.close(fig) + + + +@requires_viz +def test_draw_gemm_hierarchy_boundary_boxes(): + """Hierarchical layouts get hierarchy boundary lines in draw_gemm.""" + A = Layout(((2, 3), 2), ((1, 2), 6)) + B = Layout((4, 2), (1, 4)) + C = Layout(((2, 3), 4), ((1, 2), 6)) + fig = _build_gemm_figure(A, B, C) + try: + # A panel (axes[2]) has hierarchical mode 0 → should have boundary lines + a_ax = fig.axes[2] + assert len(a_ax.lines) > 0, "A panel should have hierarchy boundary lines" + # B panel (axes[1]) is plain → no boundary lines + b_ax = fig.axes[1] + assert len(b_ax.lines) == 0, "B panel should have no hierarchy lines" + finally: + plt.close(fig) + + + @requires_viz def test_draw_copy_layout_same_thread_colors_both_panels(): """Src and dst panels should use the same color for the same thread.""" src = Layout((4, 2), (2, 1)) dst = Layout((4, 2), (1, 4)) - fig = show_copy_layout(src, dst, colorize=True) + fig = _build_copy_figure(src, dst, colorize=True) try: ax = fig.axes[0] patches_list = ax.patches @@ -564,6 +769,7 @@ def test_draw_copy_layout_same_thread_colors_both_panels(): plt.close(fig) + @requires_viz def test_get_indices_2d_row_major_matches_logical_coordinates(): layout = Layout((4, 3), (3, 1)) @@ -576,6 +782,7 @@ def test_get_indices_2d_row_major_matches_logical_coordinates(): ] + @requires_viz def test_get_indices_2d_column_major_matches_logical_coordinates(): layout = Layout((4, 3), (1, 4)) @@ -588,6 +795,7 @@ def test_get_indices_2d_column_major_matches_logical_coordinates(): ] + @requires_viz def test_get_color_indices_2d_by_row_matches_logical_coordinates(): layout = Layout((4, 3), (3, 1)) @@ -601,6 +809,7 @@ def test_get_color_indices_2d_by_row_matches_logical_coordinates(): ] + @requires_viz def test_get_color_indices_2d_by_column_matches_logical_coordinates(): layout = Layout((4, 3), (3, 1)) @@ -614,6 +823,7 @@ def test_get_color_indices_2d_by_column_matches_logical_coordinates(): ] + @requires_viz def test_get_color_indices_2d_uniform_layout_is_uniform(): layout = Layout((4, 3), (3, 1)) @@ -627,6 +837,7 @@ def test_get_color_indices_2d_uniform_layout_is_uniform(): ] + @requires_viz def test_get_color_indices_2d_1d_layout_is_not_treated_as_uniform(): layout = Layout(4, 1) @@ -635,6 +846,7 @@ def test_get_color_indices_2d_1d_layout_is_not_treated_as_uniform(): assert color_indices.tolist() == [[0, 1, 2, 3]] + @requires_viz def test_get_hierarchical_cell_coords_2d_preserves_nested_coordinates(): layout = Layout(((2, 3), (2, 4)), ((1, 6), (2, 12))) @@ -646,6 +858,7 @@ def test_get_hierarchical_cell_coords_2d_preserves_nested_coordinates(): assert coords[0, 2] == ((0, 0), (0, 1)) + @requires_viz def test_format_nested_coord_formats_hierarchical_labels(): assert _format_nested_coord(3) == "3" @@ -653,6 +866,7 @@ def test_format_nested_coord_formats_hierarchical_labels(): assert _format_nested_coord(((1, 2), 3)) == "((1,2),3)" + @requires_viz def test_format_hierarchical_cell_lines_is_explicit_and_pedagogical(): assert _format_hierarchical_cell_lines((1, 2), (3, 4), 17) == ( @@ -662,6 +876,7 @@ def test_format_hierarchical_cell_lines_is_explicit_and_pedagogical(): ) + @requires_viz def test_coord_levels_flattens_nested_coordinates_for_axis_labels(): assert _coord_levels(3) == (3,) @@ -669,16 +884,19 @@ def test_coord_levels_flattens_nested_coordinates_for_axis_labels(): assert _coord_levels(((1, 2), 3)) == (1, 2, 3) + @requires_viz def test_level_spans_supports_three_level_hierarchy(): assert _level_spans((2, 3, 4)) == (2, 6, 24) + @requires_viz def test_level_block_sizes_supports_three_level_hierarchy(): assert _level_block_sizes((2, 3, 4)) == (1, 2, 6) + @requires_viz def test_draw_layout_nested_passes_color_indices_to_hierarchical_renderer(monkeypatch): layout = Layout(((2, 2), (2, 2)), ((1, 4), (2, 8))) @@ -707,6 +925,7 @@ def fake_draw(ax, indices, rows, cols, **kwargs): assert seen["color_indices"].shape == (4, 4) + @requires_viz def test_draw_hierarchical_grid_uses_supplied_color_indices(): layout = Layout(((2, 2), (2, 2)), ((1, 4), (2, 8))) @@ -831,6 +1050,7 @@ def _cell_text_bboxes(ax, rows: int, cols: int): return boxes + @requires_viz def test_draw_hierarchical_grid_draws_outer_perimeter_for_coarse_tiles(): layout = Layout(((2, 2), (2, 2)), ((1, 4), (2, 8))) @@ -846,6 +1066,7 @@ def test_draw_hierarchical_grid_draws_outer_perimeter_for_coarse_tiles(): plt.close(fig) + @requires_viz def test_draw_hierarchical_grid_cecka_hier_col_margin_labels_do_not_overlap(): layout = Layout((4, (4, 2)), (4, (1, 16))) @@ -863,6 +1084,7 @@ def test_draw_hierarchical_grid_cecka_hier_col_margin_labels_do_not_overlap(): plt.close(fig) + @requires_viz def test_draw_hierarchical_grid_offset_values_clear_offset_equals_label(): layout = Layout((4, (4, 2)), (4, (1, 16))) @@ -883,6 +1105,7 @@ def test_draw_hierarchical_grid_offset_values_clear_offset_equals_label(): plt.close(fig) + @requires_viz def test_draw_layout_small_nested_hierarchy_keeps_text_inside_cells(monkeypatch): layout = Layout(((2, 2), (2, 2)), ((1, 4), (2, 8))) @@ -917,6 +1140,7 @@ def fake_save(fig, filename, dpi=150): plt.close(fig) + @requires_viz def test_draw_hierarchical_grid_leaves_corner_gap_between_axis_label_bands(): layout = Layout(((3, 2), ((2, 3), 2)), ((4, 1), ((2, 15), 100))) @@ -942,6 +1166,7 @@ def test_draw_hierarchical_grid_leaves_corner_gap_between_axis_label_bands(): plt.close(fig) + @requires_viz def test_draw_hierarchical_grid_draws_outer_perimeter_for_multiple_levels(): layout = Layout(((3, 2, 2, 2), (4, 2, 2, 2)), @@ -968,6 +1193,7 @@ def test_draw_hierarchical_grid_draws_outer_perimeter_for_multiple_levels(): plt.close(fig) + @requires_viz def test_draw_hierarchical_grid_closes_boxes_for_column_only_hierarchy(): layout = Layout((4, (4, 2)), (4, (1, 16))) @@ -983,6 +1209,7 @@ def test_draw_hierarchical_grid_closes_boxes_for_column_only_hierarchy(): plt.close(fig) + @requires_viz def test_draw_hierarchical_grid_closes_boxes_for_coarse_column_only_level(): layout = Layout(((3, 2), ((2, 3), 2)), ((4, 1), ((2, 15), 100))) @@ -998,6 +1225,7 @@ def test_draw_hierarchical_grid_closes_boxes_for_coarse_column_only_level(): plt.close(fig) + @requires_viz def test_draw_hierarchical_grid_draws_coarser_lines_above_finer_lines(): layout = Layout( @@ -1019,6 +1247,7 @@ def test_draw_hierarchical_grid_draws_coarser_lines_above_finer_lines(): plt.close(fig) + @requires_viz def test_draw_slice_hierarchical_keeps_flat_grid_and_highlights_on_top(monkeypatch): layout = Layout(((2, 2), (2, 2)), ((1, 4), (2, 8))) @@ -1048,6 +1277,7 @@ def fake_save(fig, filename, dpi=150): assert max(seen["base_zorders"]) < min(seen["highlight_zorders"]) + @requires_viz def test_slice_highlight_mask_tracks_logical_cells_not_offsets(): layout = Layout((2, 2), (0, 1)) @@ -1058,6 +1288,7 @@ def test_slice_highlight_mask_tracks_logical_cells_not_offsets(): ] + @requires_viz def test_slice_highlight_mask_1d_tuple_spec(): """1D layout with tuple slice_spec should highlight the correct elements.""" @@ -1067,6 +1298,7 @@ def test_slice_highlight_mask_1d_tuple_spec(): assert mask.tolist() == [[False, False, True, True, True, False, False, False]] + @requires_viz def test_slice_highlight_mask_1d_tuple_spec_rank1(): """Rank-1 layout with tuple slice_spec should highlight the correct elements.""" @@ -1076,6 +1308,7 @@ def test_slice_highlight_mask_1d_tuple_spec_rank1(): assert mask.tolist() == [[False, False, True, True, True, False, False, False]] + @requires_viz def test_slice_highlight_mask_1d_tuple_int_spec(): """1D layout with tuple (int,) slice_spec highlights a single element.""" @@ -1085,6 +1318,7 @@ def test_slice_highlight_mask_1d_tuple_int_spec(): assert mask.tolist() == [[False, False, False, True, False, False, False, False]] + @requires_viz def test_slice_highlight_mask_1d_tuple_none_spec(): """1D layout with tuple (None,) selects all elements.""" @@ -1093,6 +1327,7 @@ def test_slice_highlight_mask_1d_tuple_none_spec(): assert mask.tolist() == [[True, True, True, True]] + @requires_viz def test_slice_highlight_mask_1d_wrong_tuple_length_raises(): """1D layout with 2-element tuple slice_spec raises ValueError.""" @@ -1101,6 +1336,7 @@ def test_slice_highlight_mask_1d_wrong_tuple_length_raises(): _get_slice_highlight_mask_2d(layout, (1, 2)) + @requires_viz def test_compute_tv_mapping_uses_first_wins_for_duplicate_cells(): layout = Layout((2, 2), (0, 0)) @@ -1108,6 +1344,7 @@ def test_compute_tv_mapping_uses_first_wins_for_duplicate_cells(): assert tv_map == {(0, 0): (0, 0, 0)} + @requires_viz def test_compute_tv_mapping_raises_for_out_of_bounds_grid(): layout = Layout((2, 2), (1, 2)) @@ -1115,8 +1352,9 @@ def test_compute_tv_mapping_raises_for_out_of_bounds_grid(): _compute_tv_mapping(layout, grid_rows=1, grid_cols=1) + @requires_viz -def test_show_swizzle_delegates_to_shared_builder(monkeypatch): +def test_draw_swizzle_delegates_to_shared_builder(monkeypatch): layout = Layout((8, 64), (64, 1)) swizzle = Swizzle(3, 4, 3) fig = plt.figure() @@ -1126,11 +1364,12 @@ def fake_builder(*args, **kwargs): monkeypatch.setattr(viz_mod, "_build_swizzle_figure", fake_builder) try: - assert show_swizzle(layout, swizzle) is fig + assert draw_swizzle(layout, swizzle) is fig finally: plt.close(fig) + @requires_viz def test_draw_swizzle_delegates_to_shared_builder(monkeypatch): layout = Layout((8, 64), (64, 1)) @@ -1154,7 +1393,8 @@ def fake_save(passed_fig, filename, dpi=150): assert seen["filename"] == "out.png" -# ── draw_combined_mma_grid / show_combined_mma_grid ────────────────────── +# ── draw_combined_mma_grid / draw_combined_mma_grid ────────────────────── + @requires_viz @@ -1176,8 +1416,9 @@ def test_draw_combined_mma_grid_smoke(): filename=f.name, title="test") + @requires_viz -def test_show_combined_mma_grid_returns_figure(): +def test_draw_combined_mma_grid_returns_figure(): atom = SM80_16x8x16_F16F16F16F16_TN atom_layout = Layout((2, 2), (1, 2)) c_grid, _ = tile_mma_grid(atom, atom_layout, "C") @@ -1189,7 +1430,7 @@ def test_show_combined_mma_grid_returns_figure(): M_a, N_a, K_a = atom.shape_mnk M, N, K = M_a * 2, N_a * 2, K_a - fig = show_combined_mma_grid(a_grid, b_display, c_grid, M, N, K, + fig = _build_combined_grid_figure(a_grid, b_display, c_grid, M, N, K, title="test") try: assert isinstance(fig, matplotlib.figure.Figure)