From 49afc765b8d884f49d3790d5aeb840594053e61f Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Mon, 16 Sep 2024 15:14:17 +0200
Subject: [PATCH 01/24] Refactor canvas context to allow presening as image

---
 examples/cube.py                      |   2 +-
 wgpu/_classes.py                      | 229 ++++++++++++++++++--
 wgpu/backends/wgpu_native/_api.py     | 299 ++++++++++----------------
 wgpu/backends/wgpu_native/_helpers.py |  15 +-
 wgpu/gui/base.py                      |  25 ++-
 wgpu/gui/glfw.py                      |   5 +
 wgpu/gui/offscreen.py                 |   2 +-
 wgpu/gui/qt.py                        |  56 ++++-
 8 files changed, 406 insertions(+), 227 deletions(-)

diff --git a/examples/cube.py b/examples/cube.py
index c1b1a81c..fbb11aa4 100644
--- a/examples/cube.py
+++ b/examples/cube.py
@@ -6,7 +6,7 @@
 
 import time
 
-from wgpu.gui.auto import WgpuCanvas, run
+from wgpu.gui.qt import WgpuCanvas, run
 import wgpu
 import numpy as np
 
diff --git a/wgpu/_classes.py b/wgpu/_classes.py
index 24e19815..9b4454d5 100644
--- a/wgpu/_classes.py
+++ b/wgpu/_classes.py
@@ -12,7 +12,7 @@
 import logging
 from typing import List, Dict, Union
 
-from ._coreutils import ApiDiff
+from ._coreutils import ApiDiff, str_flag_to_int
 from ._diagnostics import diagnostics, texture_format_to_bpp
 from . import flags, enums, structs
 
@@ -186,6 +186,17 @@ def __init__(self, canvas):
         self._ot.increase(self.__class__.__name__)
         self._canvas_ref = weakref.ref(canvas)
 
+        self._capabilities = None
+
+        # Configuration dict from the user, set via self.configure()
+        self._config = None
+
+        # The configuration from the canvas, obtained with canvas.get_surface_info()
+        self._surface_info = canvas.get_surface_info()
+
+        # The last used texture
+        self._texture = None
+
     def _get_canvas(self):
         """Getter method for internal use."""
         return self._canvas_ref()
@@ -196,6 +207,39 @@ def canvas(self):
         """The associated canvas object."""
         return self._canvas_ref()
 
+    def _get_capabilities(self, adapter):
+        if self._capabilities is None:
+            self._capabilities = {}
+            if self._surface_info["method"] == "screen":
+                # Query capabilities from the surface
+                self._capabilities.update(self._get_capabilities_screen(adapter))
+            else:
+                # Default image capabilities
+                self._capabilities = {
+                    "formats": ["rgba8unorm-srgb", "rgba8unorm"],
+                    "usages": 0xFF,
+                    "alpha_modes": [enums.CanvasAlphaMode.opaque],
+                }
+            # If capabilities were provided via surface info, overload them!
+            for key in ["formats", "usages", "alpha_modes"]:
+                if key in self._surface_info:
+                    self._capabilities[key] = self._surface_info[key]
+            # Derived defaults
+            if "view_formats" not in self._capabilities:
+                self._capabilities["view_formats"] = self._capabilities["formats"]
+
+        return self._capabilities
+
+    def _get_capabilities_screen(self, adapter):
+        raise NotImplementedError()
+
+    @apidiff.add("Better place to define the preferred format")
+    def get_preferred_format(self, adapter):
+        """Get the preferred surface texture format."""
+        capabilities = self._get_capabilities(adapter)
+        formats = capabilities["formats"]
+        return formats[0] if formats else "bgra8-unorm"
+
     # IDL: undefined configure(GPUCanvasConfiguration configuration);
     def configure(
         self,
@@ -228,40 +272,199 @@ def configure(
                 will have on the content of textures returned by ``get_current_texture()``
                 when read, displayed, or used as an image source. Default "opaque".
         """
-        raise NotImplementedError()
+
+        # Check types
+
+        if not isinstance(device, GPUDevice):
+            raise TypeError("Given device is not a device.")
+
+        if format is None:
+            format = self.get_preferred_format(device.adapter)
+        if format not in enums.TextureFormat:
+            raise ValueError(f"Configure: format {format} not in {enums.TextureFormat}")
+
+        if not isinstance(usage, int):
+            usage = str_flag_to_int(flags.TextureUsage, usage)
+
+        color_space  # not really supported, just assume srgb for now
+        tone_mapping  # not supported yet
+
+        if alpha_mode not in enums.CanvasAlphaMode:
+            raise ValueError(
+                f"Configure: alpha_mode {alpha_mode} not in {enums.CanvasAlphaMode}"
+            )
+
+        # Check against capabilities
+
+        capabilities = self._get_capabilities(device.adapter)
+
+        if format not in capabilities["formats"]:
+            raise ValueError(
+                f"Configure: unsupported texture format: {format} not in {capabilities['formats']}"
+            )
+
+        if not usage & capabilities["usages"]:
+            raise ValueError(
+                f"Configure: unsupported texture usage: {usage} not in {capabilities['usages']}"
+            )
+
+        for view_format in view_formats:
+            if view_format not in capabilities["view_formats"]:
+                raise ValueError(
+                    f"Configure: unsupported view format: {view_format} not in {capabilities['view_formats']}"
+                )
+
+        if alpha_mode not in capabilities["alpha_modes"]:
+            raise ValueError(
+                f"Configure: unsupported alpha-mode: {alpha_mode} not in {capabilities['alpha_modes']}"
+            )
+
+        # Store
+
+        self._config = {
+            "device": device,
+            "format": format,
+            "usage": usage,
+            "view_formats": view_formats,
+            "color_space": color_space,
+            "tone_mapping": tone_mapping,
+            "alpha_mode": alpha_mode,
+        }
+
+        if self._surface_info["method"] == "screen":
+            self._configure_screen(**self._config)
 
     # IDL: undefined unconfigure();
     def unconfigure(self):
         """Removes the presentation context configuration.
-        Destroys any textures produced while configured."""
-        raise NotImplementedError()
+        Destroys any textures produced while configured.
+        """
+        if self._surface_info["method"] == "screen":
+            self._unconfigure_screen()
+        self._config = None
+        self._drop_texture()
 
     # IDL: GPUTexture getCurrentTexture();
     def get_current_texture(self):
-        """Get the `GPUTexture` that will be composited to the canvas next.
-        This method should be called exactly once during each draw event.
-        """
+        """Get the `GPUTexture` that will be composited to the canvas next."""
+        if not self._config:
+            raise RuntimeError(
+                "Canvas context must be configured before calling get_current_texture()."
+            )
+
+        # When the texture is active right now, we could either:
+        # * return the existing texture
+        # * warn about it, and create a new one
+        # * raise an error
+        # Right now we return the existing texture, so user can retrieve it in different render passes that write to the same frame.
+
+        if self._texture is None:
+            if self._surface_info["method"] == "screen":
+                self._texture = self._create_texture_screen()
+            else:
+                self._texture = self._create_texture_simple()
+
+        return self._texture
+
+    def _create_texture_simple(self):
+
+        canvas = self._get_canvas()
+        width, height = canvas.get_physical_size()
+        width, height = max(width, 1), max(height, 1)
+
+        device = self._config["device"]
+        self._texture = device.create_texture(
+            label="presentation-context",
+            size=(width, height, 1),
+            format=self._config["format"],
+            usage=self._config["usage"] | flags.TextureUsage.COPY_SRC,
+        )
+        # todo: get extra usage from surface info
+        return self._texture
+
+    def _create_texture_screen(self):
         raise NotImplementedError()
 
+    def _drop_texture(self):
+        if self._texture:
+            self._texture._release()  # not destroy, because it may be in use.
+            self._texture = None
+
     @apidiff.add("Present method is exposed")
     def present(self):
         """Present what has been drawn to the current texture, by compositing it
         to the canvas. Note that a canvas based on `gui.WgpuCanvasBase` will call this
         method automatically at the end of each draw event.
         """
-        raise NotImplementedError()
+        # todo: can we remove this present() method?
+
+        if not self._texture:
+            # This can happen when a user somehow forgot to call
+            # get_current_texture(). But then what was this person rendering to
+            # then? The thing is that this also happens when there is an
+            # exception in the draw function before the call to
+            # get_current_texture(). In this scenario our warning may
+            # add confusion, so provide context and make it a debug level warning.
+            msg = "Warning in present(): No texture to present, missing call to get_current_texture()?"
+            logger.debug(msg)
+            return
+
+        if self._surface_info["method"] == "screen":
+            self._present_screen()
+        else:
+            self._present_image()
+
+        self._drop_texture()
+
+    def _present_screen(self):
+        raise NotImplementedError()
+
+    def _present_image(self):
+        texture = self._texture
+        device = texture._device
+
+        size = texture.size
+        format = texture.format
+        nchannels = 4  # we expect rgba or bgra
+        if not format.startswith(("rgba", "bgra")):
+            raise RuntimeError(f"Image present unsupported texture format {format}.")
+        if "8" in format:
+            bytes_per_pixel = nchannels
+        elif "16" in format:
+            bytes_per_pixel = nchannels * 2
+        elif "32" in format:
+            bytes_per_pixel = nchannels * 4
+        else:
+            raise RuntimeError(
+                f"Image present unsupported texture format bitdepth {format}."
+            )
+
+        data = device.queue.read_texture(
+            {
+                "texture": texture,
+                "mip_level": 0,
+                "origin": (0, 0, 0),
+            },
+            {
+                "offset": 0,
+                "bytes_per_row": bytes_per_pixel * size[0],
+                "rows_per_image": size[1],
+            },
+            size,
+        )
 
-    @apidiff.add("Better place to define the preferred format")
-    def get_preferred_format(self, adapter):
-        """Get the preferred surface texture format."""
-        return "bgra8unorm-srgb"  # seems to be a good default
+        # Represent as memory object to avoid numpy dependency
+        # Equivalent: np.frombuffer(data, np.uint8).reshape(size[1], size[0], nchannels)
+        data = data.cast("B", (size[1], size[0], nchannels))
+
+        self._get_canvas().present_image(data, format=format)
 
     def __del__(self):
         self._ot.decrease(self.__class__.__name__)
         self._release()
 
     def _release(self):
-        pass
+        self._drop_texture()
 
 
 class GPUAdapterInfo:
diff --git a/wgpu/backends/wgpu_native/_api.py b/wgpu/backends/wgpu_native/_api.py
index eb8dc3d5..6219479b 100644
--- a/wgpu/backends/wgpu_native/_api.py
+++ b/wgpu/backends/wgpu_native/_api.py
@@ -28,7 +28,7 @@
 from ._mappings import cstructfield2enum, enummap, enum_str2int, enum_int2str
 from ._helpers import (
     get_wgpu_instance,
-    get_surface_id_from_canvas,
+    get_surface_id_from_info,
     get_memoryview_from_address,
     get_memoryview_and_address,
     to_snake_case,
@@ -234,8 +234,7 @@ def request_adapter(
         # able to create a surface texture for it (from this adapter).
         surface_id = ffi.NULL
         if canvas is not None:
-            if canvas.get_surface_info():  # e.g. could be an off-screen canvas
-                surface_id = canvas.get_context()._get_surface_id()
+            surface_id = canvas._surface_id
 
         # ----- Select backend
 
@@ -422,18 +421,91 @@ class GPUCanvasContext(classes.GPUCanvasContext):
 
     def __init__(self, canvas):
         super().__init__(canvas)
-        self._device = None  # set in configure()
-        self._surface_id = None
-        self._config = None
-        self._texture = None
-
-    def _get_surface_id(self):
-        if self._surface_id is None:
-            # get_surface_id_from_canvas calls wgpuInstanceCreateSurface
-            self._surface_id = get_surface_id_from_canvas(self._get_canvas())
-        return self._surface_id
-
-    def configure(
+
+        # Obtain the surface id. The lifetime is of the surface is bound
+        # to the lifetime of this context object.
+        if self._surface_info["method"] == "screen":
+            self._surface_id = get_surface_id_from_info(self._surface_info)
+        else:  # method == "image"
+            self._surface_id = ffi.NULL
+
+    def _get_capabilities_screen(self, adapter):
+        adapter_id = adapter._internal
+        surface_id = self._surface_id
+        assert surface_id
+
+        minimal_capabilities = {
+            "usages": flags.TextureUsage.RENDER_ATTACHMENT,
+            "formats": [
+                enums.TextureFormat.bgra8unorm_srgb,
+                enums.TextureFormat.bgra8unorm,
+            ],
+            "alpha_modes": enums.CanvasAlphaMode.opaque,
+            "present_modes": ["fifo"],
+        }
+
+        # H: nextInChain: WGPUChainedStructOut *, usages: WGPUTextureUsageFlags/int, formatCount: int, formats: WGPUTextureFormat *, presentModeCount: int, presentModes: WGPUPresentMode *, alphaModeCount: int, alphaModes: WGPUCompositeAlphaMode *
+        c_capabilities = new_struct_p(
+            "WGPUSurfaceCapabilities *",
+            # not used: nextInChain
+            # not used: usages
+            # not used: formatCount
+            # not used: formats
+            # not used: presentModeCount
+            # not used: presentModes
+            # not used: alphaModeCount
+            # not used: alphaModes
+        )
+
+        # H: void f(WGPUSurface surface, WGPUAdapter adapter, WGPUSurfaceCapabilities * capabilities)
+        libf.wgpuSurfaceGetCapabilities(surface_id, adapter_id, c_capabilities)
+
+        # Convert to Python.
+        capabilities = {}
+
+        # When the surface is found not to be compatible, the fields below may
+        # be null pointers. This probably means that the surface won't work,
+        # and trying to use it will result in an error (or Rust panic). Since
+        # I'm not sure what the best time/place to error would be, we pretend
+        # that everything is fine here, and populate the fields with values
+        # that wgpu-core claims are guaranteed to exist on any (compatible)
+        # surface.
+
+        capabilities["usages"] = c_capabilities.usages
+
+        if c_capabilities.formats:
+            capabilities["formats"] = formats = []
+            for i in range(c_capabilities.formatCount):
+                int_val = c_capabilities.formats[i]
+                formats.append(enum_int2str["TextureFormat"][int_val])
+
+        else:
+            capabilities["formats"] = minimal_capabilities["formats"]
+
+        if c_capabilities.alphaModes:
+            capabilities["alpha_modes"] = alpha_modes = []
+            for i in range(c_capabilities.alphaModeCount):
+                int_val = c_capabilities.alphaModes[i]
+                str_val = enum_int2str["CompositeAlphaMode"][int_val]
+                alpha_modes.append(str_val.lower())
+        else:
+            capabilities["alpha_modes"] = minimal_capabilities["alpha_modes"]
+
+        if c_capabilities.presentModes:
+            capabilities["present_modes"] = present_modes = []
+            for i in range(c_capabilities.presentModeCount):
+                int_val = c_capabilities.presentModes[i]
+                str_val = enum_int2str["PresentMode"][int_val]
+                present_modes.append(str_val.lower())
+        else:
+            capabilities["present_modes"] = minimal_capabilities["present_modes"]
+
+        # H: void f(WGPUSurfaceCapabilities surfaceCapabilities)
+        libf.wgpuSurfaceCapabilitiesFreeMembers(c_capabilities[0])
+
+        return capabilities
+
+    def _configure_screen(
         self,
         *,
         device: "GPUDevice",
@@ -444,23 +516,19 @@ def configure(
         tone_mapping: "structs.CanvasToneMapping" = {},
         alpha_mode: "enums.CanvasAlphaMode" = "opaque",
     ):
-        # Handle inputs
 
-        # Store for later
-        self._device = device
-        # Handle usage
-        if isinstance(usage, str):
-            usage = str_flag_to_int(flags.TextureUsage, usage)
-        # View formats
+        capabilities = self._get_capabilities(device.adapter)
+
+        # Convert to C values
+
         c_view_formats = ffi.NULL
         if view_formats:
             view_formats_list = [enummap["TextureFormat." + x] for x in view_formats]
             c_view_formats = ffi.new("WGPUTextureFormat []", view_formats_list)
+
         # Lookup alpha mode, needs explicit conversion because enum names mismatch
         c_alpha_mode = getattr(lib, f"WGPUCompositeAlphaMode_{alpha_mode.capitalize()}")
-        # The format is used as-is
-        if format is None:
-            format = self.get_preferred_format(device.adapter)
+
         # The color_space is not used for now
         color_space
         # Same for tone mapping
@@ -486,21 +554,6 @@ def configure(
         else:
             present_mode_pref = ["immediate", "mailbox", "fifo"]
 
-        # Get what's supported
-
-        capabilities = self._get_surface_capabilities(self._device.adapter)
-
-        if format not in capabilities["formats"]:
-            raise ValueError(
-                f"Given format '{format}' is not in supported formats {capabilities['formats']}"
-            )
-
-        if alpha_mode not in capabilities["alpha_modes"]:
-            raise ValueError(
-                f"Given format '{alpha_mode}' is not in supported formats {capabilities['alpha_modes']}"
-            )
-
-        # Select present mode
         present_modes = [
             p for p in present_mode_pref if p in capabilities["present_modes"]
         ]
@@ -510,7 +563,7 @@ def configure(
         # Prepare config object
 
         # H: nextInChain: WGPUChainedStruct *, device: WGPUDevice, format: WGPUTextureFormat, usage: WGPUTextureUsageFlags/int, viewFormatCount: int, viewFormats: WGPUTextureFormat *, alphaMode: WGPUCompositeAlphaMode, width: int, height: int, presentMode: WGPUPresentMode
-        config = new_struct_p(
+        self._wgpu_config = new_struct_p(
             "WGPUSurfaceConfiguration *",
             device=device._internal,
             format=format,
@@ -524,50 +577,29 @@ def configure(
             # not used: nextInChain
         )
 
-        # Configure
-        self._configure(config)
-
-    def _configure(self, config):
+    def _configure_screen_real(self, width, height):
         # If a texture is still active, better release it first
         self._drop_texture()
         # Set the size
-        width, height = self._get_canvas().get_physical_size()
-        config.width = width
-        config.height = height
+        self._wgpu_config.width = width
+        self._wgpu_config.height = height
         if width <= 0 or height <= 0:
             raise RuntimeError(
                 "Cannot configure canvas that has no pixels ({width}x{height})."
             )
         # Configure, and store the config if we did not error out
-        # H: void f(WGPUSurface surface, WGPUSurfaceConfiguration const * config)
-        libf.wgpuSurfaceConfigure(self._get_surface_id(), config)
-        self._config = config
-
-    def unconfigure(self):
-        self._drop_texture()
-        self._config = None
-        # H: void f(WGPUSurface surface)
-        libf.wgpuSurfaceUnconfigure(self._get_surface_id())
+        if self._surface_id:
+            # H: void f(WGPUSurface surface, WGPUSurfaceConfiguration const * config)
+            libf.wgpuSurfaceConfigure(self._surface_id, self._wgpu_config)
 
-    def _drop_texture(self):
-        if self._texture:
-            self._texture._release()  # not destroy, because it may be in use.
-            self._texture = None
+    def _unconfigure_screen(self):
+        if self._surface_id:
+            # H: void f(WGPUSurface surface)
+            libf.wgpuSurfaceUnconfigure(self._surface_id)
 
-    def get_current_texture(self):
-        # If the canvas has changed since the last configure, we need to re-configure it
-        if not self._config:
-            raise RuntimeError(
-                "Canvas context must be configured before calling get_current_texture()."
-            )
+    def _create_texture_screen(self):
 
-        # When the texture is active right now, we could either:
-        # * return the existing texture
-        # * warn about it, and create a new one
-        # * raise an error
-        # Right now we return the existing texture, so user can retrieve it in different render passes that write to the same frame.
-        if self._texture:
-            return self._texture
+        surface_id = self._surface_id
 
         # Reconfigure when the canvas has resized.
         # On some systems (Windows+Qt) this is not necessary, because
@@ -579,10 +611,10 @@ def get_current_texture(self):
         # pre-emptively reconfigure. These log entries are harmless but
         # annoying, and I currently don't know how to prevent them
         # elegantly. See issue #352
-        old_size = (self._config.width, self._config.height)
+        old_size = (self._wgpu_config.width, self._wgpu_config.height)
         new_size = tuple(self._get_canvas().get_physical_size())
         if old_size != new_size:
-            self._configure(self._config)
+            self._configure_screen_real(*new_size)
 
         # Try to obtain a texture.
         # `If it fails, depending on status, we reconfigure and try again.
@@ -597,7 +629,7 @@ def get_current_texture(self):
 
         for attempt in [1, 2]:
             # H: void f(WGPUSurface surface, WGPUSurfaceTexture * surfaceTexture)
-            libf.wgpuSurfaceGetCurrentTexture(self._get_surface_id(), surface_texture)
+            libf.wgpuSurfaceGetCurrentTexture(surface_id, surface_texture)
             status = surface_texture.status
             texture_id = surface_texture.texture
             if status == lib.WGPUSurfaceGetCurrentTextureStatus_Success:
@@ -615,7 +647,7 @@ def get_current_texture(self):
                 # (status==Outdated), but also when moving the window from one
                 # monitor to another with different scale-factor.
                 logger.info(f"Re-configuring canvas context ({status}).")
-                self._configure(self._config)
+                self._configure_screen_real(*new_size)
             else:
                 # WGPUSurfaceGetCurrentTextureStatus_OutOfMemory
                 # WGPUSurfaceGetCurrentTextureStatus_DeviceLost
@@ -630,20 +662,7 @@ def get_current_texture(self):
         if surface_texture.suboptimal:
             logger.warning("The surface texture is suboptimal.")
 
-        return self._create_python_texture(texture_id)
-
-    def _create_python_texture(self, texture_id):
-        # Create the Python wrapper
-
-        # We can derive texture props from the config and common sense:
-        # width = self._config.width
-        # height = self._config.height
-        # depth = 1
-        # mip_level_count = 1
-        # sample_count = 1
-        # dimension = enums.TextureDimension.d2
-        # format = enum_int2str["TextureFormat"][self._config.format]
-        # usage = self._config.usage
+        # Wrap it in a Python texture object
 
         # But we can also read them from the texture
         # H: uint32_t f(WGPUTexture texture)
@@ -680,98 +699,12 @@ def _create_python_texture(self, texture_id):
             "usage": usage,
         }
 
-        self._texture = GPUTexture(label, texture_id, self._device, tex_info)
-        return self._texture
-
-    def present(self):
-        if not self._texture:
-            # This can happen when a user somehow forgot to call
-            # get_current_texture(). But then what was this person rendering to
-            # then? The thing is that this also happens when there is an
-            # exception in the draw function before the call to
-            # get_current_texture(). In this scenario our warning may
-            # add confusion, so provide context and make it a debug level warning.
-            msg = "Warning in present(): No texture to present, missing call to get_current_texture()?"
-            logger.debug(msg)
-        else:
-            # Present the texture, then destroy it
-            # H: void f(WGPUSurface surface)
-            libf.wgpuSurfacePresent(self._get_surface_id())
-            self._drop_texture()
-
-    def get_preferred_format(self, adapter):
-        if self._config is not None:
-            # this shortcut might not be correct if a different format is specified during .configure()
-            return enum_int2str["TextureFormat"][self._config.format]
-        else:
-            return self._get_surface_capabilities(adapter)["formats"][0]
-
-    def _get_surface_capabilities(self, adapter):
-        adapter_id = adapter._internal
-
-        # H: nextInChain: WGPUChainedStructOut *, usages: WGPUTextureUsageFlags/int, formatCount: int, formats: WGPUTextureFormat *, presentModeCount: int, presentModes: WGPUPresentMode *, alphaModeCount: int, alphaModes: WGPUCompositeAlphaMode *
-        c_capabilities = new_struct_p(
-            "WGPUSurfaceCapabilities *",
-            # not used: nextInChain
-            # not used: usages
-            # not used: formatCount
-            # not used: formats
-            # not used: presentModeCount
-            # not used: presentModes
-            # not used: alphaModeCount
-            # not used: alphaModes
-        )
-
-        # H: void f(WGPUSurface surface, WGPUAdapter adapter, WGPUSurfaceCapabilities * capabilities)
-        libf.wgpuSurfaceGetCapabilities(
-            self._get_surface_id(), adapter_id, c_capabilities
-        )
-
-        # Convert to Python.
-        capabilities = {}
-
-        # When the surface is found not to be compatible, the fields below may
-        # be null pointers. This probably means that the surface won't work,
-        # and trying to use it will result in an error (or Rust panic). Since
-        # I'm not sure what the best time/place to error would be, we pretend
-        # that everything is fine here, and populate the fields with values
-        # that wgpu-core claims are guaranteed to exist on any (compatible)
-        # surface.
-
-        if c_capabilities.formats:
-            capabilities["formats"] = formats = []
-            for i in range(c_capabilities.formatCount):
-                int_val = c_capabilities.formats[i]
-                formats.append(enum_int2str["TextureFormat"][int_val])
-
-        else:
-            capabilities["formats"] = [
-                enums.TextureFormat.bgra8unorm_srgb,
-                enums.TextureFormat.bgra8unorm,
-            ]
-
-        if c_capabilities.alphaModes:
-            capabilities["alpha_modes"] = alpha_modes = []
-            for i in range(c_capabilities.alphaModeCount):
-                int_val = c_capabilities.alphaModes[i]
-                str_val = enum_int2str["CompositeAlphaMode"][int_val]
-                alpha_modes.append(str_val.lower())
-        else:
-            capabilities["alpha_modes"] = [enums.CanvasAlphaMode.opaque]
-
-        if c_capabilities.presentModes:
-            capabilities["present_modes"] = present_modes = []
-            for i in range(c_capabilities.presentModeCount):
-                int_val = c_capabilities.presentModes[i]
-                str_val = enum_int2str["PresentMode"][int_val]
-                present_modes.append(str_val.lower())
-        else:
-            capabilities["present_modes"] = ["fifo"]
+        device = self._config["device"]
+        return GPUTexture(label, texture_id, device, tex_info)
 
-        # H: void f(WGPUSurfaceCapabilities surfaceCapabilities)
-        libf.wgpuSurfaceCapabilitiesFreeMembers(c_capabilities[0])
-
-        return capabilities
+    def _present_screen(self):
+        # H: void f(WGPUSurface surface)
+        libf.wgpuSurfacePresent(self._surface_id)
 
     def _release(self):
         self._drop_texture()
diff --git a/wgpu/backends/wgpu_native/_helpers.py b/wgpu/backends/wgpu_native/_helpers.py
index 43b58495..fa6d7a39 100644
--- a/wgpu/backends/wgpu_native/_helpers.py
+++ b/wgpu/backends/wgpu_native/_helpers.py
@@ -94,18 +94,11 @@ def get_wgpu_instance():
     return _the_instance
 
 
-def get_surface_id_from_canvas(canvas):
+def get_surface_id_from_info(surface_info):
     """Get an id representing the surface to render to. The way to
     obtain this id differs per platform and GUI toolkit.
     """
 
-    # Use cached
-    surface_id = getattr(canvas, "_wgpu_surface_id", None)
-    if surface_id:
-        return surface_id
-
-    surface_info = canvas.get_surface_info()
-
     if sys.platform.startswith("win"):  # no-cover
         GetModuleHandle = ctypes.windll.kernel32.GetModuleHandleW  # noqa
         struct = ffi.new("WGPUSurfaceDescriptorFromWindowsHWND *")
@@ -192,11 +185,7 @@ def get_surface_id_from_canvas(canvas):
     surface_descriptor.label = ffi.NULL
     surface_descriptor.nextInChain = ffi.cast("WGPUChainedStruct *", struct)
 
-    surface_id = lib.wgpuInstanceCreateSurface(get_wgpu_instance(), surface_descriptor)
-
-    # Cache and return
-    canvas._wgpu_surface_id = surface_id
-    return surface_id
+    return lib.wgpuInstanceCreateSurface(get_wgpu_instance(), surface_descriptor)
 
 
 # The functions below are copied from codegen/utils.py
diff --git a/wgpu/gui/base.py b/wgpu/gui/base.py
index e172f4da..ee540ea2 100644
--- a/wgpu/gui/base.py
+++ b/wgpu/gui/base.py
@@ -5,6 +5,18 @@
 from ._gui_utils import log_exception
 
 
+def create_canvas_context(canvas):
+    backend_module = sys.modules["wgpu"].gpu.__module__
+    if backend_module == "wgpu._classes":
+        raise RuntimeError(
+            "A backend must be selected (e.g. with request_adapter()) before canvas.get_context() can be called."
+        )
+    # Instantiate the context
+    CC = sys.modules[backend_module].GPUCanvasContext  # noqa: N806
+    # CC = sys.modules["wgpu"]._classes.GPUCanvasContext
+    return CC(canvas)
+
+
 class WgpuCanvasInterface:
     """The minimal interface to be a valid canvas.
 
@@ -48,17 +60,12 @@ def get_context(self, kind="webgpu"):
         # here the only valid arg is 'webgpu', which is also made the default.
         assert kind == "webgpu"
         if self._canvas_context is None:
-            # Get the active wgpu backend module
-            backend_module = sys.modules["wgpu"].gpu.__module__
-            if backend_module == "wgpu._classes":
-                raise RuntimeError(
-                    "A backend must be selected (e.g. with request_adapter()) before canvas.get_context() can be called."
-                )
-            # Instantiate the context
-            CC = sys.modules[backend_module].GPUCanvasContext  # noqa: N806
-            self._canvas_context = CC(self)
+            self._canvas_context = create_canvas_context(self)
         return self._canvas_context
 
+    def present_image(self, image, **kwargs):
+        raise NotImplementedError()
+
 
 class WgpuCanvasBase(WgpuCanvasInterface):
     """A convenient base canvas class.
diff --git a/wgpu/gui/glfw.py b/wgpu/gui/glfw.py
index 00800eca..62b38fd7 100644
--- a/wgpu/gui/glfw.py
+++ b/wgpu/gui/glfw.py
@@ -512,6 +512,11 @@ def _on_char(self, window, char):
         }
         self._handle_event_and_flush(ev)
 
+    def present_image(self, image, **kwargs):
+        raise NotImplementedError()
+        # glfw does not have a way to blit an image.
+        # We could use OpenGL to display it though.
+
 
 # Make available under a name that is the same for all gui backends
 WgpuCanvas = GlfwWgpuCanvas
diff --git a/wgpu/gui/offscreen.py b/wgpu/gui/offscreen.py
index 95b6e373..fc7411d1 100644
--- a/wgpu/gui/offscreen.py
+++ b/wgpu/gui/offscreen.py
@@ -4,7 +4,7 @@
 from .base import WgpuCanvasBase, WgpuAutoGui
 
 
-class GPUCanvasContext(classes.GPUCanvasContext):
+class XXXXXGPUCanvasContext(classes.GPUCanvasContext):
     """GPUCanvasContext subclass for rendering to an offscreen texture."""
 
     # In this context implementation, we keep a ref to the texture, to keep
diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index 1a2035ae..96e07b37 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -23,6 +23,7 @@
 libname, already_had_app_on_import = get_imported_qt_lib()
 if libname:
     QtCore = importlib.import_module(".QtCore", libname)
+    QtGui = importlib.import_module(".QtGui", libname)
     QtWidgets = importlib.import_module(".QtWidgets", libname)
     try:
         WA_PaintOnScreen = QtCore.Qt.WidgetAttribute.WA_PaintOnScreen
@@ -140,13 +141,15 @@ class QWgpuWidget(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
     """A QWidget representing a wgpu canvas that can be embedded in a Qt application."""
 
     def __init__(self, *args, **kwargs):
+        draw_to_screen = kwargs.pop("draw_to_screen", True)
         super().__init__(*args, **kwargs)
 
-        # Configure how Qt renders this widget
-        self.setAttribute(WA_PaintOnScreen, True)
+        self._raw_surface_id = self._get_surface_id()
+        self._draw_to_screen = bool(self._raw_surface_id) and draw_to_screen
+
+        self.setAutoFillBackground(False)
         self.setAttribute(WA_DeleteOnClose, True)
         self.setAttribute(WA_InputMethodEnabled, True)
-        self.setAutoFillBackground(False)
         self.setMouseTracking(True)
         self.setFocusPolicy(FocusPolicy.StrongFocus)
 
@@ -158,14 +161,17 @@ def __init__(self, *args, **kwargs):
 
     def paintEngine(self):  # noqa: N802 - this is a Qt method
         # https://doc.qt.io/qt-5/qt.html#WidgetAttribute-enum  WA_PaintOnScreen
-        return None
+        if self._draw_to_screen:
+            return None
+        else:
+            return super().paintEngine()
 
     def paintEvent(self, event):  # noqa: N802 - this is a Qt method
         self._draw_frame_and_present()
 
     # Methods that we add from wgpu (snake_case)
 
-    def get_surface_info(self):
+    def _get_surface_id(self):
         if sys.platform.startswith("win") or sys.platform.startswith("darwin"):
             return {
                 "window": int(self.winId()),
@@ -184,8 +190,17 @@ def get_surface_info(self):
                     "window": int(self.winId()),
                     "display": int(get_alt_x11_display()),
                 }
+
+    def get_surface_info(self):
+        if self._draw_to_screen and self._raw_surface_id:
+            info = {"method": "screen"}
+            info.update(self._raw_surface_id)
         else:
-            raise RuntimeError(f"Cannot get Qt surafce info on {sys.platform}.")
+            info = {
+                "method": "image",
+                "formats": ["rgba8unorm-srgb", "rgba8unorm"],
+            }
+        return info
 
     def get_pixel_ratio(self):
         # Observations:
@@ -356,6 +371,27 @@ def resizeEvent(self, event):  # noqa: N802
     def closeEvent(self, event):  # noqa: N802
         self._handle_event_and_flush({"event_type": "close"})
 
+    def present_image(self, image_data, **kwargs):
+        size = image_data.shape[1], image_data.shape[0]
+
+        painter = QtGui.QPainter(self)
+
+        image = QtGui.QImage(
+            image_data,
+            size[0],
+            size[1],
+            size[0] * 4,
+            QtGui.QImage.Format.Format_RGBA8888,
+        )
+
+        rect1 = QtCore.QRect(0, 0, size[0], size[1])
+        rect2 = self.rect()
+        painter.drawImage(rect2, image, rect1)
+
+        painter.setPen(QtGui.QColor("#0000ff"))
+        painter.setFont(QtGui.QFont("Arial", 30))
+        painter.drawText(100, 100, "image")
+
 
 class QWgpuCanvas(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
     """A toplevel Qt widget providing a wgpu canvas."""
@@ -370,6 +406,7 @@ def __init__(self, *, size=None, title=None, max_fps=30, **kwargs):
         # application before any widget is created
         get_app()
 
+        draw_to_screen = kwargs.pop("draw_to_screen", False)
         super().__init__(**kwargs)
 
         self.setAttribute(WA_DeleteOnClose, True)
@@ -377,7 +414,9 @@ def __init__(self, *, size=None, title=None, max_fps=30, **kwargs):
         self.setWindowTitle(title or "qt wgpu canvas")
         self.setMouseTracking(True)
 
-        self._subwidget = QWgpuWidget(self, max_fps=max_fps)
+        self._subwidget = QWgpuWidget(
+            self, max_fps=max_fps, draw_to_screen=draw_to_screen
+        )
         self._subwidget.add_event_handler(weakbind(self.handle_event), "*")
 
         # Note: At some point we called `self._subwidget.winId()` here. For some
@@ -446,6 +485,9 @@ def get_context(self, *args, **kwargs):
     def request_draw(self, *args, **kwargs):
         return self._subwidget.request_draw(*args, **kwargs)
 
+    def present_image(self, image, **kwargs):
+        return self._subwidget.present_image(image, **kwargs)
+
 
 # Make available under a name that is the same for all gui backends
 WgpuWidget = QWgpuWidget

From e042000f32f2f46b85a46c7dda8796047b9cc667 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Mon, 16 Sep 2024 16:59:27 +0200
Subject: [PATCH 02/24] some cleanup

---
 examples/cube.py |  2 +-
 wgpu/_classes.py | 34 +++++++++++++++++++++++-----------
 2 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/examples/cube.py b/examples/cube.py
index fbb11aa4..c1b1a81c 100644
--- a/examples/cube.py
+++ b/examples/cube.py
@@ -6,7 +6,7 @@
 
 import time
 
-from wgpu.gui.qt import WgpuCanvas, run
+from wgpu.gui.auto import WgpuCanvas, run
 import wgpu
 import numpy as np
 
diff --git a/wgpu/_classes.py b/wgpu/_classes.py
index 9b4454d5..4c17b776 100644
--- a/wgpu/_classes.py
+++ b/wgpu/_classes.py
@@ -186,14 +186,19 @@ def __init__(self, canvas):
         self._ot.increase(self.__class__.__name__)
         self._canvas_ref = weakref.ref(canvas)
 
+        # The configuration from the canvas, obtained with canvas.get_surface_info()
+        self._surface_info = canvas.get_surface_info()
+        if self._surface_info.get("method", None) not in ("screen", "image"):
+            raise RuntimeError(
+                "canvas.get_surface_info() must produce a dict with a field 'method' that is either 'screen' or 'image'."
+            )
+
+        # Surface capabilities. Stored the first time it is obtained
         self._capabilities = None
 
         # Configuration dict from the user, set via self.configure()
         self._config = None
 
-        # The configuration from the canvas, obtained with canvas.get_surface_info()
-        self._surface_info = canvas.get_surface_info()
-
         # The last used texture
         self._texture = None
 
@@ -208,6 +213,7 @@ def canvas(self):
         return self._canvas_ref()
 
     def _get_capabilities(self, adapter):
+        """Get dict of capabilities and cache the result."""
         if self._capabilities is None:
             self._capabilities = {}
             if self._surface_info["method"] == "screen":
@@ -231,6 +237,7 @@ def _get_capabilities(self, adapter):
         return self._capabilities
 
     def _get_capabilities_screen(self, adapter):
+        """Get capabilities for a native surface."""
         raise NotImplementedError()
 
     @apidiff.add("Better place to define the preferred format")
@@ -260,13 +267,13 @@ def configure(
             device (WgpuDevice): The GPU device object to create compatible textures for.
             format (enums.TextureFormat): The format that textures returned by
                 ``get_current_texture()`` will have. Must be one of the supported context
-                formats. An often used format is "bgra8unorm-srgb".
+                formats. Can be ``None`` to use the canvas' preferred format.
             usage (flags.TextureUsage): Default ``TextureUsage.OUTPUT_ATTACHMENT``.
             view_formats (List[enums.TextureFormat]): The formats that views created
                 from textures returned by ``get_current_texture()`` may use.
             color_space (PredefinedColorSpace): The color space that values written
                 into textures returned by ``get_current_texture()`` should be displayed with.
-                Default "srgb".
+                Default "srgb". Not yet supported.
             tone_mapping (enums.CanvasToneMappingMode): Not yet supported.
             alpha_mode (structs.CanvasAlphaMode): Determines the effect that alpha values
                 will have on the content of textures returned by ``get_current_texture()``
@@ -334,6 +341,9 @@ def configure(
         if self._surface_info["method"] == "screen":
             self._configure_screen(**self._config)
 
+    def _configure_screen(self, **kwargs):
+        raise NotImplementedError()
+
     # IDL: undefined unconfigure();
     def unconfigure(self):
         """Removes the presentation context configuration.
@@ -344,6 +354,9 @@ def unconfigure(self):
         self._config = None
         self._drop_texture()
 
+    def _unconfigure_screen(self, **kwargs):
+        raise NotImplementedError()
+
     # IDL: GPUTexture getCurrentTexture();
     def get_current_texture(self):
         """Get the `GPUTexture` that will be composited to the canvas next."""
@@ -362,11 +375,11 @@ def get_current_texture(self):
             if self._surface_info["method"] == "screen":
                 self._texture = self._create_texture_screen()
             else:
-                self._texture = self._create_texture_simple()
+                self._texture = self._create_texture_image()
 
         return self._texture
 
-    def _create_texture_simple(self):
+    def _create_texture_image(self):
 
         canvas = self._get_canvas()
         width, height = canvas.get_physical_size()
@@ -379,7 +392,6 @@ def _create_texture_simple(self):
             format=self._config["format"],
             usage=self._config["usage"] | flags.TextureUsage.COPY_SRC,
         )
-        # todo: get extra usage from surface info
         return self._texture
 
     def _create_texture_screen(self):
@@ -416,9 +428,6 @@ def present(self):
 
         self._drop_texture()
 
-    def _present_screen(self):
-        raise NotImplementedError()
-
     def _present_image(self):
         texture = self._texture
         device = texture._device
@@ -459,6 +468,9 @@ def _present_image(self):
 
         self._get_canvas().present_image(data, format=format)
 
+    def _present_screen(self):
+        raise NotImplementedError()
+
     def __del__(self):
         self._ot.decrease(self.__class__.__name__)
         self._release()

From 671cd4ae33230013f8a4fafc1b1450f47b431841 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Mon, 16 Sep 2024 17:05:06 +0200
Subject: [PATCH 03/24] codegen

---
 wgpu/_classes.py                  | 14 ++++++++++++--
 wgpu/backends/wgpu_native/_api.py | 14 +++++++-------
 wgpu/resources/codegen_report.md  |  4 ++--
 3 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/wgpu/_classes.py b/wgpu/_classes.py
index 4c17b776..63b4c632 100644
--- a/wgpu/_classes.py
+++ b/wgpu/_classes.py
@@ -341,7 +341,17 @@ def configure(
         if self._surface_info["method"] == "screen":
             self._configure_screen(**self._config)
 
-    def _configure_screen(self, **kwargs):
+    def _configure_screen(
+        self,
+        *,
+        device,
+        format,
+        usage,
+        view_formats,
+        color_space,
+        tone_mapping,
+        alpha_mode,
+    ):
         raise NotImplementedError()
 
     # IDL: undefined unconfigure();
@@ -354,7 +364,7 @@ def unconfigure(self):
         self._config = None
         self._drop_texture()
 
-    def _unconfigure_screen(self, **kwargs):
+    def _unconfigure_screen(self):
         raise NotImplementedError()
 
     # IDL: GPUTexture getCurrentTexture();
diff --git a/wgpu/backends/wgpu_native/_api.py b/wgpu/backends/wgpu_native/_api.py
index 6219479b..54e99bd7 100644
--- a/wgpu/backends/wgpu_native/_api.py
+++ b/wgpu/backends/wgpu_native/_api.py
@@ -508,13 +508,13 @@ def _get_capabilities_screen(self, adapter):
     def _configure_screen(
         self,
         *,
-        device: "GPUDevice",
-        format: "enums.TextureFormat",
-        usage: "flags.TextureUsage" = 0x10,
-        view_formats: "List[enums.TextureFormat]" = [],
-        color_space: str = "srgb",
-        tone_mapping: "structs.CanvasToneMapping" = {},
-        alpha_mode: "enums.CanvasAlphaMode" = "opaque",
+        device,
+        format,
+        usage,
+        view_formats,
+        color_space,
+        tone_mapping,
+        alpha_mode,
     ):
 
         capabilities = self._get_capabilities(device.adapter)
diff --git a/wgpu/resources/codegen_report.md b/wgpu/resources/codegen_report.md
index 7c72d1fc..8b30cd2f 100644
--- a/wgpu/resources/codegen_report.md
+++ b/wgpu/resources/codegen_report.md
@@ -18,9 +18,9 @@
 * Diffs for GPUTextureView: add size, add texture
 * Diffs for GPUBindingCommandsMixin: change set_bind_group
 * Diffs for GPUQueue: add read_buffer, add read_texture, hide copy_external_image_to_texture
-* Validated 37 classes, 112 methods, 45 properties
+* Validated 37 classes, 121 methods, 45 properties
 ### Patching API for backends/wgpu_native/_api.py
-* Validated 37 classes, 112 methods, 0 properties
+* Validated 37 classes, 108 methods, 0 properties
 ## Validating backends/wgpu_native/_api.py
 * Enum field FeatureName.texture-compression-bc-sliced-3d missing in wgpu.h
 * Enum field FeatureName.clip-distances missing in wgpu.h

From 1e816bce6b4c53df569393670100ffdce3985bf6 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 09:00:25 +0200
Subject: [PATCH 04/24] Fix flicker

---
 wgpu/gui/qt.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index 96e07b37..8ac0588e 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -147,6 +147,7 @@ def __init__(self, *args, **kwargs):
         self._raw_surface_id = self._get_surface_id()
         self._draw_to_screen = bool(self._raw_surface_id) and draw_to_screen
 
+        self.setAttribute(WA_PaintOnScreen, self._draw_to_screen)
         self.setAutoFillBackground(False)
         self.setAttribute(WA_DeleteOnClose, True)
         self.setAttribute(WA_InputMethodEnabled, True)

From 65b4848556c08805f919d3fd90f695b411c1fc53 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 09:04:59 +0200
Subject: [PATCH 05/24] cleaner

---
 wgpu/gui/qt.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index 8ac0588e..cfaa8bc8 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -140,12 +140,11 @@ def enable_hidpi():
 class QWgpuWidget(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
     """A QWidget representing a wgpu canvas that can be embedded in a Qt application."""
 
-    def __init__(self, *args, **kwargs):
-        draw_to_screen = kwargs.pop("draw_to_screen", True)
+    def __init__(self, *args, draw_to_screen=True, **kwargs):
         super().__init__(*args, **kwargs)
 
         self._raw_surface_id = self._get_surface_id()
-        self._draw_to_screen = bool(self._raw_surface_id) and draw_to_screen
+        self._draw_to_screen = draw_to_screen and bool(self._raw_surface_id)
 
         self.setAttribute(WA_PaintOnScreen, self._draw_to_screen)
         self.setAutoFillBackground(False)
@@ -402,12 +401,12 @@ class QWgpuCanvas(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
     # size can be set to subpixel (logical) values, without being able to
     # detect this. See https://github.com/pygfx/wgpu-py/pull/68
 
-    def __init__(self, *, size=None, title=None, max_fps=30, **kwargs):
+    def __init__(
+        self, *, size=None, title=None, max_fps=30, draw_to_screen=True, **kwargs
+    ):
         # When using Qt, there needs to be an
         # application before any widget is created
         get_app()
-
-        draw_to_screen = kwargs.pop("draw_to_screen", False)
         super().__init__(**kwargs)
 
         self.setAttribute(WA_DeleteOnClose, True)

From a4d56510bdda5ca7433ff83c2663754146eefb65 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 09:13:47 +0200
Subject: [PATCH 06/24] fix error on exit

---
 wgpu/backends/wgpu_native/_api.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/wgpu/backends/wgpu_native/_api.py b/wgpu/backends/wgpu_native/_api.py
index 54e99bd7..2839a5a0 100644
--- a/wgpu/backends/wgpu_native/_api.py
+++ b/wgpu/backends/wgpu_native/_api.py
@@ -234,7 +234,7 @@ def request_adapter(
         # able to create a surface texture for it (from this adapter).
         surface_id = ffi.NULL
         if canvas is not None:
-            surface_id = canvas._surface_id
+            surface_id = canvas._surface_id  # can still be NULL
 
         # ----- Select backend
 
@@ -710,8 +710,9 @@ def _release(self):
         self._drop_texture()
         if self._surface_id is not None and libf is not None:
             self._surface_id, surface_id = None, self._surface_id
-            # H: void f(WGPUSurface surface)
-            libf.wgpuSurfaceRelease(surface_id)
+            if surface_id:  # is not NULL
+                # H: void f(WGPUSurface surface)
+                libf.wgpuSurfaceRelease(surface_id)
 
 
 class GPUObjectBase(classes.GPUObjectBase):

From 8b6eef839a3a93aed5da1995ab0acb708fe5a787 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 11:00:17 +0200
Subject: [PATCH 07/24] looked into qt image draw performance a bit

---
 wgpu/gui/qt.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index cfaa8bc8..49a62e48 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -372,10 +372,17 @@ def closeEvent(self, event):  # noqa: N802
         self._handle_event_and_flush({"event_type": "close"})
 
     def present_image(self, image_data, **kwargs):
-        size = image_data.shape[1], image_data.shape[0]
+        size = image_data.shape[1], image_data.shape[0]  # width, height
 
         painter = QtGui.QPainter(self)
 
+        # We want to simply blit the image (copy pixels one-to-one on framebuffer).
+        # Maybe Qt does this when the sizes match exactly (like they do here).
+        # Converting to a QPixmap and painting that only makes it slower.
+
+        # Just in case, set render hints that may hurt performance.
+        painter.setRenderHints(painter.RenderHint.Antialiasing | painter.RenderHint.SmoothPixmapTransform, False)
+
         image = QtGui.QImage(
             image_data,
             size[0],
@@ -388,9 +395,10 @@ def present_image(self, image_data, **kwargs):
         rect2 = self.rect()
         painter.drawImage(rect2, image, rect1)
 
+        # Uncomment for testing purposes
         painter.setPen(QtGui.QColor("#0000ff"))
         painter.setFont(QtGui.QFont("Arial", 30))
-        painter.drawText(100, 100, "image")
+        painter.drawText(100, 100, "This is an image")
 
 
 class QWgpuCanvas(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):

From 70e77d46727e9663edb610c47be92ccea1b8c1f4 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 11:14:50 +0200
Subject: [PATCH 08/24] Fix/workaround for Qt on Wayland

---
 wgpu/gui/qt.py | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index 49a62e48..ee3e77d8 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -9,6 +9,7 @@
 
 from .base import WgpuCanvasBase, WgpuAutoGui
 from ._gui_utils import (
+    SYSTEM_IS_WAYLAND,
     get_alt_x11_display,
     get_alt_wayland_display,
     weakbind,
@@ -16,9 +17,6 @@
 )
 
 
-is_wayland = False  # We force Qt to use X11 in _gui_utils.py
-
-
 # Select GUI toolkit
 libname, already_had_app_on_import = get_imported_qt_lib()
 if libname:
@@ -177,13 +175,18 @@ def _get_surface_id(self):
                 "window": int(self.winId()),
             }
         elif sys.platform.startswith("linux"):
-            # The trick to use an al display pointer works for X11, but results in a segfault on Wayland ...
-            if is_wayland:
-                return {
-                    "platform": "wayland",
-                    "window": int(self.winId()),
-                    "display": int(get_alt_wayland_display()),
-                }
+            if SYSTEM_IS_WAYLAND:
+                # Trying to do it the Wayland way segfaults. This might be because
+                # the "display" is not the real display id. We can tell Qt to use
+                # XWayland, so we can use the X11 path. This worked at some point,
+                # but later this resulted in a Rust panic. So, until this is sorted
+                # out, we fall back to rendering via an image.
+                return None
+                # return {
+                #     "platform": "wayland",
+                #     "window": int(self.winId()),
+                #     "display": int(get_alt_wayland_display()),
+                # }
             else:
                 return {
                     "platform": "x11",
@@ -381,7 +384,10 @@ def present_image(self, image_data, **kwargs):
         # Converting to a QPixmap and painting that only makes it slower.
 
         # Just in case, set render hints that may hurt performance.
-        painter.setRenderHints(painter.RenderHint.Antialiasing | painter.RenderHint.SmoothPixmapTransform, False)
+        painter.setRenderHints(
+            painter.RenderHint.Antialiasing | painter.RenderHint.SmoothPixmapTransform,
+            False,
+        )
 
         image = QtGui.QImage(
             image_data,

From 039b61caad43a16112b12cfeb142e7dc4405e074 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 12:28:38 +0200
Subject: [PATCH 09/24] Fix glfw

---
 wgpu/gui/base.py | 3 ++-
 wgpu/gui/glfw.py | 5 +++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/wgpu/gui/base.py b/wgpu/gui/base.py
index ee540ea2..c7168aef 100644
--- a/wgpu/gui/base.py
+++ b/wgpu/gui/base.py
@@ -84,11 +84,12 @@ class WgpuCanvasBase(WgpuCanvasInterface):
     also want to set ``vsync`` to False.
     """
 
-    def __init__(self, *args, max_fps=30, vsync=True, **kwargs):
+    def __init__(self, *args, max_fps=30, vsync=True, draw_to_screen=True, **kwargs):
         super().__init__(*args, **kwargs)
         self._last_draw_time = 0
         self._max_fps = float(max_fps)
         self._vsync = bool(vsync)
+        draw_to_screen  # We just catch the arg here in case a backend does implement support it
 
     def __del__(self):
         # On delete, we call the custom close method.
diff --git a/wgpu/gui/glfw.py b/wgpu/gui/glfw.py
index 62b38fd7..ec74cd7d 100644
--- a/wgpu/gui/glfw.py
+++ b/wgpu/gui/glfw.py
@@ -105,25 +105,30 @@
 
 
 def get_surface_info(window):
+
     if sys.platform.startswith("win"):
         return {
+            "method": "screen",
             "platform": "windows",
             "window": int(glfw.get_win32_window(window)),
         }
     elif sys.platform.startswith("darwin"):
         return {
+            "method": "screen",
             "platform": "cocoa",
             "window": int(glfw.get_cocoa_window(window)),
         }
     elif sys.platform.startswith("linux"):
         if is_wayland:
             return {
+                "method": "screen",
                 "platform": "wayland",
                 "window": int(glfw.get_wayland_window(window)),
                 "display": int(glfw.get_wayland_display()),
             }
         else:
             return {
+                "method": "screen",
                 "platform": "x11",
                 "window": int(glfw.get_x11_window(window)),
                 "display": int(glfw.get_x11_display()),

From 0db867de9d0687216e694161aa86a1c559e57803 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 12:29:23 +0200
Subject: [PATCH 10/24] Give wx same treatment as qt

---
 wgpu/gui/qt.py | 11 ++++---
 wgpu/gui/wx.py | 81 ++++++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 74 insertions(+), 18 deletions(-)

diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index ee3e77d8..df42cbdc 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -11,7 +11,6 @@
 from ._gui_utils import (
     SYSTEM_IS_WAYLAND,
     get_alt_x11_display,
-    get_alt_wayland_display,
     weakbind,
     get_imported_qt_lib,
 )
@@ -141,8 +140,8 @@ class QWgpuWidget(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
     def __init__(self, *args, draw_to_screen=True, **kwargs):
         super().__init__(*args, **kwargs)
 
-        self._raw_surface_id = self._get_surface_id()
-        self._draw_to_screen = draw_to_screen and bool(self._raw_surface_id)
+        self._raw_surface_info = self._get_raw_surface_info()
+        self._draw_to_screen = draw_to_screen and bool(self._raw_surface_info)
 
         self.setAttribute(WA_PaintOnScreen, self._draw_to_screen)
         self.setAutoFillBackground(False)
@@ -169,7 +168,7 @@ def paintEvent(self, event):  # noqa: N802 - this is a Qt method
 
     # Methods that we add from wgpu (snake_case)
 
-    def _get_surface_id(self):
+    def _get_raw_surface_info(self):
         if sys.platform.startswith("win") or sys.platform.startswith("darwin"):
             return {
                 "window": int(self.winId()),
@@ -195,9 +194,9 @@ def _get_surface_id(self):
                 }
 
     def get_surface_info(self):
-        if self._draw_to_screen and self._raw_surface_id:
+        if self._draw_to_screen and self._raw_surface_info:
             info = {"method": "screen"}
-            info.update(self._raw_surface_id)
+            info.update(self._raw_surface_info)
         else:
             info = {
                 "method": "image",
diff --git a/wgpu/gui/wx.py b/wgpu/gui/wx.py
index 8428408c..4b21bad7 100644
--- a/wgpu/gui/wx.py
+++ b/wgpu/gui/wx.py
@@ -9,10 +9,13 @@
 
 import wx
 
-from ._gui_utils import get_alt_x11_display, get_alt_wayland_display, weakbind
+from ._gui_utils import (
+    SYSTEM_IS_WAYLAND,
+    get_alt_x11_display,
+    weakbind,
+)
 from .base import WgpuCanvasBase, WgpuAutoGui
 
-is_wayland = False  # We force wx to use X11 in _gui_utils.py
 
 BUTTON_MAP = {
     wx.MOUSE_BTN_LEFT: 1,
@@ -125,9 +128,12 @@ def Notify(self, *args):  # noqa: N802
 class WxWgpuWindow(WgpuAutoGui, WgpuCanvasBase, wx.Window):
     """A wx Window representing a wgpu canvas that can be embedded in a wx application."""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, draw_to_screen=True, **kwargs):
         super().__init__(*args, **kwargs)
 
+        self._raw_surface_info = self._get_raw_surface_info()
+        self._draw_to_screen = draw_to_screen and bool(self._raw_surface_info)
+
         # A timer for limiting fps
         self._request_draw_timer = TimerWithCallback(self.Refresh)
 
@@ -304,18 +310,20 @@ def _on_mouse_move(self, event: wx.MouseEvent):
 
     # Methods that we add from wgpu
 
-    def get_surface_info(self):
+    def _get_raw_surface_info(self):
         if sys.platform.startswith("win") or sys.platform.startswith("darwin"):
             return {
                 "window": int(self.GetHandle()),
             }
         elif sys.platform.startswith("linux"):
-            if is_wayland:
-                return {
-                    "platform": "wayland",
-                    "window": int(self.GetHandle()),
-                    "display": int(get_alt_wayland_display()),
-                }
+            if SYSTEM_IS_WAYLAND:
+                # Fallback to offscreen rendering. See comment in same place in qt.py.
+                return None
+                # return {
+                #     "platform": "wayland",
+                #     "window": int(self.GetHandle()),
+                #     "display": int(get_alt_wayland_display()),
+                # }
             else:
                 return {
                     "platform": "x11",
@@ -325,6 +333,17 @@ def get_surface_info(self):
         else:
             raise RuntimeError(f"Cannot get Qt surafce info on {sys.platform}.")
 
+    def get_surface_info(self):
+        if self._draw_to_screen and self._raw_surface_info:
+            info = {"method": "screen"}
+            info.update(self._raw_surface_info)
+        else:
+            info = {
+                "method": "image",
+                "formats": ["rgba8unorm-srgb", "rgba8unorm"],
+            }
+        return info
+
     def get_pixel_ratio(self):
         # todo: this is not hidpi-ready (at least on win10)
         # Observations:
@@ -371,19 +390,38 @@ def _call_later(delay, callback, *args):
 
         wx.CallLater(max(delay_ms, 1), callback, *args)
 
+    def present_image(self, image_data, **kwargs):
+        size = image_data.shape[1], image_data.shape[0]  # width, height
+
+        dc = wx.PaintDC(self)
+        bitmap = wx.Bitmap.FromBufferRGBA(*size, image_data)
+        dc.DrawBitmap(bitmap, 0, 0, False)
+
 
 class WxWgpuCanvas(WgpuAutoGui, WgpuCanvasBase, wx.Frame):
     """A toplevel wx Frame providing a wgpu canvas."""
 
     # Most of this is proxying stuff to the inner widget.
 
-    def __init__(self, *, parent=None, size=None, title=None, max_fps=30, **kwargs):
+    def __init__(
+        self,
+        *,
+        parent=None,
+        size=None,
+        title=None,
+        max_fps=30,
+        draw_to_screen=True,
+        **kwargs,
+    ):
+        get_app()
         super().__init__(parent, **kwargs)
 
         self.set_logical_size(*(size or (640, 480)))
         self.SetTitle(title or "wx wgpu canvas")
 
-        self._subwidget = WxWgpuWindow(parent=self, max_fps=max_fps)
+        self._subwidget = WxWgpuWindow(
+            parent=self, max_fps=max_fps, draw_to_screen=draw_to_screen
+        )
         self._subwidget.add_event_handler(weakbind(self.handle_event), "*")
         self.Bind(wx.EVT_CLOSE, lambda e: self.Destroy())
 
@@ -435,7 +473,26 @@ def get_context(self, *args, **kwargs):
     def request_draw(self, *args, **kwargs):
         return self._subwidget.request_draw(*args, **kwargs)
 
+    def present_image(self, image, **kwargs):
+        return self._subwidget.present_image(image, **kwargs)
+
 
 # Make available under a name that is the same for all gui backends
 WgpuWidget = WxWgpuWindow
 WgpuCanvas = WxWgpuCanvas
+
+_the_app = None
+
+
+def get_app():
+    global _the_app
+    app = wx.App.GetInstance()
+    if app is None:
+        print("zxc")
+        _the_app = app = wx.App()
+        wx.App.SetInstance(app)
+    return app
+
+
+def run():
+    get_app().MainLoop()

From dc1c24b1b4b6580e33db2a68b398d91bb6c53f29 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 12:44:51 +0200
Subject: [PATCH 11/24] Show warning when using offscreen rendering in qt and
 wx

---
 wgpu/gui/qt.py |  9 +++++++++
 wgpu/gui/wx.py | 10 ++++++++++
 2 files changed, 19 insertions(+)

diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index df42cbdc..c66b4a4e 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -9,6 +9,7 @@
 
 from .base import WgpuCanvasBase, WgpuAutoGui
 from ._gui_utils import (
+    logger,
     SYSTEM_IS_WAYLAND,
     get_alt_x11_display,
     weakbind,
@@ -133,6 +134,10 @@ def enable_hidpi():
 # needed for wgpu, so not our responsibility (some users may NOT want it set).
 enable_hidpi()
 
+_show_image_method_warning = (
+    "Qt falling back to offscreen rendering, which is less performant."
+)
+
 
 class QWgpuWidget(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
     """A QWidget representing a wgpu canvas that can be embedded in a Qt application."""
@@ -194,10 +199,14 @@ def _get_raw_surface_info(self):
                 }
 
     def get_surface_info(self):
+        global _show_image_method_warning
         if self._draw_to_screen and self._raw_surface_info:
             info = {"method": "screen"}
             info.update(self._raw_surface_info)
         else:
+            if _show_image_method_warning:
+                logger.warn(_show_image_method_warning)
+                _show_image_method_warning = None
             info = {
                 "method": "image",
                 "formats": ["rgba8unorm-srgb", "rgba8unorm"],
diff --git a/wgpu/gui/wx.py b/wgpu/gui/wx.py
index 4b21bad7..61f81060 100644
--- a/wgpu/gui/wx.py
+++ b/wgpu/gui/wx.py
@@ -10,6 +10,7 @@
 import wx
 
 from ._gui_utils import (
+    logger,
     SYSTEM_IS_WAYLAND,
     get_alt_x11_display,
     weakbind,
@@ -113,6 +114,11 @@ def enable_hidpi():
 enable_hidpi()
 
 
+_show_image_method_warning = (
+    "wx falling back to offscreen rendering, which is less performant."
+)
+
+
 class TimerWithCallback(wx.Timer):
     def __init__(self, callback):
         super().__init__()
@@ -334,10 +340,14 @@ def _get_raw_surface_info(self):
             raise RuntimeError(f"Cannot get Qt surafce info on {sys.platform}.")
 
     def get_surface_info(self):
+        global _show_image_method_warning
         if self._draw_to_screen and self._raw_surface_info:
             info = {"method": "screen"}
             info.update(self._raw_surface_info)
         else:
+            if _show_image_method_warning:
+                logger.warn(_show_image_method_warning)
+                _show_image_method_warning = None
             info = {
                 "method": "image",
                 "formats": ["rgba8unorm-srgb", "rgba8unorm"],

From 28fa1a8915e4c7d8a00a9aa649124b878db5ca4b Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 13:06:29 +0200
Subject: [PATCH 12/24] docs

---
 wgpu/_classes.py |  2 +-
 wgpu/gui/base.py | 32 ++++++++++++++++++++++++--------
 2 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/wgpu/_classes.py b/wgpu/_classes.py
index 63b4c632..3e2802b9 100644
--- a/wgpu/_classes.py
+++ b/wgpu/_classes.py
@@ -227,7 +227,7 @@ def _get_capabilities(self, adapter):
                     "alpha_modes": [enums.CanvasAlphaMode.opaque],
                 }
             # If capabilities were provided via surface info, overload them!
-            for key in ["formats", "usages", "alpha_modes"]:
+            for key in ["formats", "alpha_modes"]:
                 if key in self._surface_info:
                     self._capabilities[key] = self._surface_info[key]
             # Derived defaults
diff --git a/wgpu/gui/base.py b/wgpu/gui/base.py
index c7168aef..0fa78b27 100644
--- a/wgpu/gui/base.py
+++ b/wgpu/gui/base.py
@@ -32,15 +32,31 @@ def __init__(self, *args, **kwargs):
         self._canvas_context = None
 
     def get_surface_info(self):
-        """Get information about the native window / surface.
-
-        This is used to obtain a surface id, so that wgpu can render to the
-        region of the screen occupied by the canvas. Should return None for
-        offscreen canvases. Otherwise, this should return a dict with a "window"
-        field. On Linux the dict should contain more fields, see the existing
-        implementations for reference.
+        """Get information about the surface to render to.
+
+        The result is a small dict, by which the context determines how the
+        rendered image is presented to the canvas. There are two possible
+        methods.
+
+        If the ``method`` field is "screen", the context will render directly
+        to a surface representing the region on the screen. The dict should
+        have a ``window`` field containing the window id. On Linux there should
+        also be ``platform`` field to distinguish between "wayland" and "x11",
+        and a ``display`` field for the display id. This information is used
+        by wgpu to obtain the required surface id.
+
+        When the ``method`` field is "image", the context will render to a
+        texture, load the result into RAM, and call ``canvas.present_image()``
+        with the image data. Additional info (like format) is passed as kwargs.
+        This method enables various types of canvases (including remote ones),
+        but note that it has a performance penalty compared to rendering
+        directly to the screen.
+
+        The dict can further contain fields ``formats`` and ``alpha_modes`` to
+        define the canvas capabilities. By default formats is
+        ``["rgba8unorm_srgb", "rgba8unorm"]``, and alpha_modes is ``["opaque"]``.
         """
-        return None
+        raise NotImplementedError()
 
     def get_physical_size(self):
         """Get the physical size of the canvas in integer pixels."""

From 2c923dd1b46ae44ca9e4ec1090224ac75c26b03e Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 15:41:32 +0200
Subject: [PATCH 13/24] Update offscreen canvases. No more need for
 WgpuOfscreenCanvasBase

---
 wgpu/gui/__init__.py  |   2 -
 wgpu/gui/base.py      |   2 +-
 wgpu/gui/jupyter.py   |  42 ++++------
 wgpu/gui/offscreen.py | 177 ++++--------------------------------------
 4 files changed, 29 insertions(+), 194 deletions(-)

diff --git a/wgpu/gui/__init__.py b/wgpu/gui/__init__.py
index 31049f5b..ac542717 100644
--- a/wgpu/gui/__init__.py
+++ b/wgpu/gui/__init__.py
@@ -4,11 +4,9 @@
 
 from . import _gui_utils  # noqa: F401
 from .base import WgpuCanvasInterface, WgpuCanvasBase, WgpuAutoGui  # noqa: F401
-from .offscreen import WgpuOffscreenCanvasBase  # noqa: F401
 
 __all__ = [
     "WgpuCanvasInterface",
     "WgpuCanvasBase",
     "WgpuAutoGui",
-    "WgpuOffscreenCanvasBase",
 ]
diff --git a/wgpu/gui/base.py b/wgpu/gui/base.py
index 0fa78b27..ebd01282 100644
--- a/wgpu/gui/base.py
+++ b/wgpu/gui/base.py
@@ -54,7 +54,7 @@ def get_surface_info(self):
 
         The dict can further contain fields ``formats`` and ``alpha_modes`` to
         define the canvas capabilities. By default formats is
-        ``["rgba8unorm_srgb", "rgba8unorm"]``, and alpha_modes is ``["opaque"]``.
+        ``["rgba8unorm-srgb", "rgba8unorm"]``, and alpha_modes is ``["opaque"]``.
         """
         raise NotImplementedError()
 
diff --git a/wgpu/gui/jupyter.py b/wgpu/gui/jupyter.py
index e981af5e..e5f6ca74 100644
--- a/wgpu/gui/jupyter.py
+++ b/wgpu/gui/jupyter.py
@@ -6,8 +6,7 @@
 import weakref
 import asyncio
 
-from .offscreen import WgpuOffscreenCanvasBase
-from .base import WgpuAutoGui
+from .base import WgpuAutoGui, WgpuCanvasBase
 
 import numpy as np
 from jupyter_rfb import RemoteFrameBuffer
@@ -17,13 +16,14 @@
 pending_jupyter_canvases = []
 
 
-class JupyterWgpuCanvas(WgpuAutoGui, WgpuOffscreenCanvasBase, RemoteFrameBuffer):
+class JupyterWgpuCanvas(WgpuAutoGui, WgpuCanvasBase, RemoteFrameBuffer):
     """An ipywidgets widget providing a wgpu canvas. Needs the jupyter_rfb library."""
 
     def __init__(self, *, size=None, title=None, **kwargs):
         super().__init__(**kwargs)
 
         # Internal variables
+        self._last_image = None
         self._pixel_ratio = 1
         self._logical_size = 0, 0
         self._is_closed = False
@@ -56,7 +56,8 @@ def get_frame(self):
         # present_context.present(), which calls our present() method.
         # The result is either a numpy array or None, and this matches
         # with what this method is expected to return.
-        return self._draw_frame_and_present()
+        self._draw_frame_and_present()
+        return self._last_image
 
     # Implementation needed for WgpuCanvasBase
 
@@ -89,34 +90,21 @@ def _request_draw(self):
             self._request_draw_timer_running = True
             call_later(self._get_draw_wait_time(), RemoteFrameBuffer.request_draw, self)
 
-    # Implementation needed for WgpuOffscreenCanvasBase
-
-    def present(self, texture):
-        # This gets called at the end of a draw pass via offscreen.GPUCanvasContext
-        device = texture._device
-        size = texture.size
-        bytes_per_pixel = 4
-        data = device.queue.read_texture(
-            {
-                "texture": texture,
-                "mip_level": 0,
-                "origin": (0, 0, 0),
-            },
-            {
-                "offset": 0,
-                "bytes_per_row": bytes_per_pixel * size[0],
-                "rows_per_image": size[1],
-            },
-            size,
-        )
-        return np.frombuffer(data, np.uint8).reshape(size[1], size[0], 4)
+    # Implementation needed for WgpuCanvasInterface
 
-    def get_preferred_format(self):
+    def get_surface_info(self):
         # Use a format that maps well to PNG: rgba8norm. Use srgb for
         # perseptive color mapping. This is the common colorspace for
         # e.g. png and jpg images. Most tools (browsers included) will
         # blit the png to screen as-is, and a screen wants colors in srgb.
-        return "rgba8unorm-srgb"
+        return {
+            "method": "image",
+            "formats": ["rgba8unorm-srgb", "rgba8unorm"],
+        }
+
+    def present_image(self, image, **kwargs):
+        # Convert memoryview to ndarray (no copy)
+        self._last_image = np.frombuffer(image, np.uint8).reshape(image.shape)
 
 
 # Make available under a name that is the same for all gui backends
diff --git a/wgpu/gui/offscreen.py b/wgpu/gui/offscreen.py
index fc7411d1..0c613018 100644
--- a/wgpu/gui/offscreen.py
+++ b/wgpu/gui/offscreen.py
@@ -1,148 +1,9 @@
 import time
 
-from .. import classes, flags
 from .base import WgpuCanvasBase, WgpuAutoGui
 
 
-class XXXXXGPUCanvasContext(classes.GPUCanvasContext):
-    """GPUCanvasContext subclass for rendering to an offscreen texture."""
-
-    # In this context implementation, we keep a ref to the texture, to keep
-    # it alive until at least until present() is called, and to be able to
-    # pass it to the canvas' present() method. Thereafter, the texture
-    # reference is removed. If there are no more references to it, it will
-    # be cleaned up. But if the offscreen canvas uses it for something,
-    # it'll simply stay alive longer.
-
-    def __init__(self, canvas):
-        super().__init__(canvas)
-        self._config = None
-        self._texture = None
-
-    def configure(
-        self,
-        *,
-        device,
-        format,
-        usage=flags.TextureUsage.RENDER_ATTACHMENT | flags.TextureUsage.COPY_SRC,
-        view_formats=[],
-        color_space="srgb",
-        alpha_mode="opaque"
-    ):
-        if format is None:
-            format = self.get_preferred_format(device.adapter)
-        self._config = {
-            "device": device,
-            "format": format,
-            "usage": usage,
-            "width": 0,
-            "height": 0,
-            # "view_formats": xx,
-            # "color_space": xx,
-            # "alpha_mode": xx,
-        }
-
-    def unconfigure(self):
-        self._texture = None
-        self._config = None
-
-    def get_current_texture(self):
-        if not self._config:
-            raise RuntimeError(
-                "Canvas context must be configured before calling get_current_texture()."
-            )
-
-        if self._texture:
-            return self._texture
-
-        width, height = self._get_canvas().get_physical_size()
-        width, height = max(width, 1), max(height, 1)
-
-        self._texture = self._config["device"].create_texture(
-            label="presentation-context",
-            size=(width, height, 1),
-            format=self._config["format"],
-            usage=self._config["usage"],
-        )
-        return self._texture
-
-    def present(self):
-        if not self._texture:
-            msg = "present() is called without a preceding call to "
-            msg += "get_current_texture(). Note that present() is usually "
-            msg += "called automatically after the draw function returns."
-            raise RuntimeError(msg)
-        else:
-            texture = self._texture
-            self._texture = None
-            return self._get_canvas().present(texture)
-
-    def get_preferred_format(self, adapter):
-        canvas = self._get_canvas()
-        if canvas:
-            return canvas.get_preferred_format()
-        else:
-            return "rgba8unorm-srgb"
-
-
-class WgpuOffscreenCanvasBase(WgpuCanvasBase):
-    """Base class for off-screen canvases.
-
-    It provides a custom context that renders to a texture instead of
-    a surface/screen. On each draw the resulting image is passes as a
-    texture to the ``present()`` method. Subclasses should (at least)
-    implement ``present()``
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def get_surface_info(self):
-        """This canvas does not correspond to an on-screen window."""
-        return None
-
-    def get_context(self, kind="webgpu"):
-        """Get the GPUCanvasContext object to obtain a texture to render to."""
-        # Normally this creates a GPUCanvasContext object provided by
-        # the backend (e.g. wgpu-native), but here we use our own context.
-        assert kind == "webgpu"
-        if self._canvas_context is None:
-            self._canvas_context = GPUCanvasContext(self)
-        return self._canvas_context
-
-    def present(self, texture):
-        """Method that gets called at the end of each draw event.
-
-        The rendered image is represented by the texture argument.
-        Subclasses should overload this method and use the texture to
-        process the rendered image.
-
-        The texture is a new object at each draw, but is not explicitly
-        destroyed, so it can be used e.g. as a texture binding (subject
-        to set TextureUsage).
-        """
-        # Notes: Creating a new texture object for each draw is
-        # consistent with how real canvas contexts work, plus it avoids
-        # confusion of re-using the same texture except when the canvas
-        # changes size. For use-cases where you do want to render to the
-        # same texture one does not need the canvas API. E.g. in pygfx
-        # the renderer can also work with a target that is a (fixed
-        # size) texture.
-        pass
-
-    def get_preferred_format(self):
-        """Get the preferred format for this canvas.
-
-        This method can be overloaded to control the used texture
-        format. The default is "rgba8unorm-srgb".
-        """
-        # Use rgba because that order is more common for processing and storage.
-        # Use srgb because that's what how colors are usually expected to be.
-        # Use 8unorm because 8bit is enough (when using srgb).
-        return "rgba8unorm-srgb"
-
-
-class WgpuManualOffscreenCanvas(WgpuAutoGui, WgpuOffscreenCanvasBase):
+class WgpuManualOffscreenCanvas(WgpuAutoGui, WgpuCanvasBase):
     """An offscreen canvas intended for manual use.
 
     Call the ``.draw()`` method to perform a draw and get the result.
@@ -154,6 +15,16 @@ def __init__(self, *args, size=None, pixel_ratio=1, title=None, **kwargs):
         self._pixel_ratio = pixel_ratio
         self._title = title
         self._closed = False
+        self._last_image = None
+
+    def get_surface_info(self):
+        return {
+            "method": "image",
+            "formats": ["rgba8unorm-srgb", "rgba8unorm"],
+        }
+
+    def present_image(self, image, **kwargs):
+        self._last_image = image
 
     def get_pixel_ratio(self):
         return self._pixel_ratio
@@ -182,29 +53,6 @@ def _request_draw(self):
         # Deliberately a no-op, because people use .draw() instead.
         pass
 
-    def present(self, texture):
-        # This gets called at the end of a draw pass via GPUCanvasContext
-        device = texture._device
-        size = texture.size
-        bytes_per_pixel = 4
-        data = device.queue.read_texture(
-            {
-                "texture": texture,
-                "mip_level": 0,
-                "origin": (0, 0, 0),
-            },
-            {
-                "offset": 0,
-                "bytes_per_row": bytes_per_pixel * size[0],
-                "rows_per_image": size[1],
-            },
-            size,
-        )
-
-        # Return as memory object to avoid numpy dependency
-        # Equivalent: np.frombuffer(data, np.uint8).reshape(size[1], size[0], 4)
-        return data.cast("B", (size[1], size[0], 4))
-
     def draw(self):
         """Perform a draw and get the resulting image.
 
@@ -212,7 +60,8 @@ def draw(self):
         This object can be converted to a numpy array (without copying data)
         using ``np.asarray(arr)``.
         """
-        return self._draw_frame_and_present()
+        self._draw_frame_and_present()
+        return self._last_image
 
 
 WgpuCanvas = WgpuManualOffscreenCanvas

From 23f3e06a0cdb94ae729d99c2e44cf1debef573ae Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 15:41:49 +0200
Subject: [PATCH 14/24] Update notebook

---
 examples/wgpu-examples.ipynb | 129 +++++++++++++++++++++++++++++------
 1 file changed, 109 insertions(+), 20 deletions(-)

diff --git a/examples/wgpu-examples.ipynb b/examples/wgpu-examples.ipynb
index 8ddb5e0c..9ae2417e 100644
--- a/examples/wgpu-examples.ipynb
+++ b/examples/wgpu-examples.ipynb
@@ -20,14 +20,47 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "c6e4ffe0",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5ed60fb173574ec4be1cf2000ffb5fc3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "RFBOutputContext()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b434f9aabf374f3caf167f0f7ed48822",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/html": [
+       "<div class='snapshot-b434f9aabf374f3caf167f0f7ed48822' style='position:relative;'><img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAHXXElEQVR42uzWY7SlCZrl8VLazrBt27Zt27Zt22aG7chQBjOsaxzbevfs95y7etasme7p6q66p7rq+fD7vr/stf5/+MMf/gAhhBBCCPEvJeoDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8QQgghhBDpK+oDhBBCCCFE+or6ACGEEEIIkb6iPkAIIYQQQqSvqA8Q/8oA/EGhEKK/RQghhPjXEfUB4l+dokSEKKjgjwHgj37ySRQKIYQQfydRHyD+1SHEAKRQCH8MUkCJ8Cv4k4+85AH+5CaXRKEQQgjxNxD1AUIwAINhf/y3CCR/iAFI3lBaBCr4s5tcCv7iVPCBg+zAhyqbhKEQQgjxV4j6ACHwBwTwR4VCjMAgBYL4k8of/N8R6AkxAEP4iyviA0bgh4zAD+1kU/CRVcHHFgWfWIBPzWSSKBRCCCH+HVEfIETYH/8tAgP4U5AC5CdfMOzPXvIE8Rd3EB+4yBliAJI9hI/oY1sIn1hD+JQR+KlZwWcmBZ8bFXxBXxqAr/SkkygUQggh/vAPMECIsD/CzwCkkJ8BmCYtAv/sI28Af/EE8IFbFcSHjMAPnUF85CB7kAEYjAQgfWYJ4XNzCF+YyBhiACoMQAVf6xR8Q99qFXynoVTg+xTgh2QJQyGEEP9Soj5AiH/zR/jwJ4VCFKQAI9DvZwD68ReV148PPH58yAj80EXOAAMwgI/pE3sAnzICP7UGGYBBBmCQARjEl4zArxiBXxtIH8K3OtKGwgH4faqCH+jHFEpW8FOSgp8TgQwJFC9RKIQQ4p9W1AcI8X/4k+JlAHojAUh/DpDfxwD04QOvLy0AIz5y+fGx049PHH58Gg7AAD6zBvA5fWEJ4EtzAF8xAr8yBhmAQXyjD+Jb+k4XxPeMwO81IQZgiAEYwk/JIfycFEIGRmCGRAUZExRkileQOU5BllggSwyQNUaiUAghxD+FqA8Q4v/wJ3gYgZ5wBP45SAEv/uL34gNfxIeMwA89PnzkJpePAehjAPrwKSPwM7sfn9v8+MJKFn9aAAbwNX1jDOBbQwDf6QNpARjED5ogfqSfUikliJ+T1QAMIWNiCJkSIjLHh5CFEZg1VkG2GAXZ39M7BTneKsj5Fsj1Bsj9WsJQCCHE/yhRHyDE/yUSgB78mf4SpIAHH/g9+DAcgOTx4iP62O3FJy4vPnWqAehjAPoYgD4GoA9f0leMwK/NZPLjWyMZ/AxAP75nBP6gC+BHLWkCDMAAfk4JIENyMCxjUhCZEoPInBBEFgZg1jiKDTEAQ8hOOd6HkPOdGoAKA1BhACrI80pBXtVLIN8LIP9ziUIhhBD/sKI+QIj/y5/gxp8VCrkZgG58ECC/Gx+GI9CDj7wefOzx4BO3B5+6yOnFZ/S5w4sv7F58afPiq3AA+hiAPnxD35p8+M7ow/cGNQD9DEA/A9CPnzR+/EwZGIEZGIEZkwPIlBRA5sQAsiSogsgaH0S2uCCyxwaRI4beBxmAIeSi3G9DyPOGXocYgCHke6kg/wsFBZ5HFHymoNBToPDv9ESiUAghxD+EqA8Q4v/pz4oLfwm58IEq6MKHATUA3fjIR143A9CNT+hTRuBnjMDPnR584SC7hwHowVeMwK+tXnxj8eJbsxffmcjoZQD68AP9qPfhJx1pfQxAHwPQj4wpfmRKjsic5EcWRmBWRmC2+ACyx1FsADkoJyMwFyMw9zt6G2QABpH3dRD5GID5VS9DKPAihILPQyj0jJ4qDEAFRajoEwXFHtMjBcUfAiUeACXvSxgKIYRIV1EfIMT/01/gxF8UJwPQiQ+DFGAE+l34iD72ufCJ14VPPeR2MwDdDEA3vqAvHW58xQj8mhH4tdWDby1k9uA7+p4R+AMj8EcD6b0MQC9+1nqRgRGYgRGYMdWHTCk+ZE72IUuSD1kT/QxAP7JR9ng/csT5kTOWYgIMwAADMIA8lPctvQkgHyMw/6sgCrwMouALeh5EIUZgYUZgkachFP2dnoQYgCEUZwCWUD1UUPKBglL3FZT+TUGZe0CZu0DZOxKFQggh/m6iPkCIf9cHioMB6MCHaRH4UcCJj/1OfOJz4lOvMxyAn9Hnbhe+cLnwpdOFrxxkdzMA3fiGvrW68Z3Fje/NZPIwAD0MQA9+op/1HmTQESMwo8aLTKleZE7xIouKEZiVEZgt0YfsCT7kiKc4XzgAc1HuGD/yvKd3fgagH/kYgPlfB1BA9SqAgi8DKPQigMKMwMLPggzAIAMwiGJU/AkxAks8CqHkwxBKPaD7IQZgCGUYgWXvKSh3l+4oKH9bQYVbQMVf6aZEoRBCiL+JqA8Q4t/1Aez4UCFG4EdBCjjwMX3id+BTnwOfMQI/9zjxhZtcTnxJXzECv2YEfmN34VubC99ZyeIKB+AP9KPJjZ+MZHAzAN3hAMyo9SCTSuNB5lQPA9CDrMleZEvyIntiRI4EL3LGe5GLEZg7lmJ8DEAf8r7zIR/lZwTmf+NnAPpR8JUfhV76IwFIRZ4HUPRZAMWe0u+BcACWeBxEyUcRpR4GUfpBEGUYgWUZgWXvhRiAIZS/E0IFFSOw4i0FlX5VUPkm3VBQ5bqCqteAalT9qoShEEKIv0rUBwjxHwoHIH0UsuPjoB2fBOz41G9PC0AHPqcvPA586XbgK5cDXzudDEAnvrVHfGdz4nurEz8wAn80k8nFAHThZ4MLGVSMwIw6NwPQjcwaN7KkupFVDUDKluxB9iQPciR6kDPBkxaAXuSmPLFe5I2h9960APShwBsfCr6OKPTKh8KMwCIv/Cj6nJ75GYB+FP/djxKMwBJPAij5OIBSjwIo/TCAMg/ofhBlqdxvQZS/R3eD4QCseDuESrfo1xAqU5WbIVRlBFZjBFa7pjAAFdS4oqDmZRVQ6xJQ+6JEoRBCiH9X1AcI8R/6EDZ8pNjwcciGT4I2fBqI+IwR+LnPji+8dnzpseMrN7ns+JoR+I3TgW8dDnxnd+B7myMtAJ34kX4yO/GzyYkMRmc4ADPqXcikcyEzZdGSxoWsjMBsKW5kT3YjRxIlupGTcjECc8d7kCeOYj0MQA/yvfcgPyOwwDt660XBN14Ueu1F4XAA+hiAPhSlYs99KP6MnqoB6EfJJ36UekyP/ChNZRiBZRmB5e7TbwEGYAAV7gZQkRFY8U4QlW4HUflWEFV+DaLqTboRYgCGUP1aCDVUV0OoeSWEWozA2pfoooI6FxTUPa+g3nmg/jk6K1EohBAiLOoDhPj/+kix4mP6JGTFp0ErPmMAfu634QsfeW34kr7y2PA1I/AbRuC3Tju+c5Ddju/pB0bgj1YHfrKQ2cEAdDAAHcjICMxkIL2TAehkADqRlQGYLdWF7KoUF3Iku5AzyYVcDMDcCRTvZgC6kZfyxbqRP0YNQA8D0IOCbz0o9CaiMCOwyCsvir70otgLeu5lAHpR4qkPJVW/+1DqiQ+lH/tQ5pEPZR/6GYB+BqAf5anCb3RPDcAAKt0JoPJtuhVgAAZQlRFYjRFY/QZdDzIAg6h5NYha4QAMoTbVuRRC3Ysh1LtAjMD65xQ0OKug4ZmIRqcVND4FNDlJJyQMhRDiX0zUBwjx//UxLPhEseDTEAUtDEArPqcv/FZ86bPiK68VX3vIbcO3rojvnDZ877DhBwbgjzay2hmAdvxMGcxkUgPQwQB0ILPegSw6B7KqGIHZNE4GoBM5UpzImUxJTuRiBOZOdCFPggt54ynOxQB0MQDdKPDejYKqd24UeutGYQZgkdceFH1FLz0MQA+KUwlGYAlGYMmnXpT63YvST7wo81jFAGQElnvoQ/kHdN/HAPSh4j0/Kt2NqHzHjyq3/ah6y49qjMBqNwMMwABqXA+gpupaALUYgbWvBFHnMl0KMgCD4QCsrzofQoNzITQ8G0KjMyE0DgegwgBU0PSEgmaq4wqaHwNa/AK0PCpRKIQQ/8SiPkCI/5RPYcanihmfMQI/ZwR+EbDgS78FX/kivmYEfsMI/NZtxXcuK753ksPKALThR/rJZsPPVhsyWMhsQ0aTHZmMdmSmLAbS2xmAdmTTOpBd40CO1IicKQ7kYgTmZgTmSaQEJwPQiXyUnxFYgBFYIMbFAHSh0DsXCr+lN24UoaKv3Sj2yo3iL+mFmwHoQclnHpR6GlH6dw/KPPGgLCOw3CN66GUAelGBKjICKzICK93zofJdH6rc8aHqbV8kAKn6r37UuEk3/AxAP2oxAGtfpSsBBmAAdanepQDqMwLrXwiiwfkgGp4LotFZOhNEY0Zgk9MhND1FJ0MMwBCaHw+hxTGFAaigJbU6qqD1EToMtDkEtD0oUSiEEP8koj5AiP+UT2HCZ4oJn4fM+CIY8WXAjK/8ZnztM+MbrwXfeiz4zh3xvcuCHxiBPzICf7KTzcoAtCIDZWQEZmIEZjLZGIA2BqANWfU2ZGMAZldp7cihsSNnqh25UuzInexgADqQh/ImOpAvwYH88RTnZAA6UTDGiUKq904UZgQWYQQWfeNCsdf0ysUAdKEEI7AkI7DkczdKPXOj9FM3yvzuRtlwAHpQjso/8qDCQ3rgYQB6Uek3Lyrfo7teVKGqd7yoxgisfot+9TEAfah5w4da11V+1L7mR52rftS94ke9y/60AAygwYUAGqrOB9DoXACNGYFNGIFNTgcZgEE0OxlEcxUjsAUjsOWxEFr9QkdDDMAQ2hxW0PZQRLuDCtofUNBhP+0DOu4FOu2RMBRCiP9hoj5AiP+0zxiBnzMCvwiZ8GXQhK8CJnztN4UD8FuV14zvPGZ87zbjB5cZPzotDEALfqKf7RZksJHVwgC0MgCtyGyyIgtlNZLBimyMwOw6G3JobcipoVQbcjECczMC8yTbkTeJEu0MQHs4AAtQwTiKdTAAHSj83oEi75wo+pbeOFGMir92osQrYgSWfOFCqeculH7mQhnVUxfKMgLLPXGj/GN65GYAulGRAVhJdd+Dyr95UOWeB1XvelAtHIBeBqAXNajmr3TTi1qMwNqMwDrX6KqPAehDParPCKx/yY8GF/0MQD8anfej8Tk6G0ATanomgGan6VSAARhAixNBtDxOx4IMwCBaUxtGYBtGYNvDIbQ7FEL7g3QgFA7AjtRpH+1V0HmPgi67FXTdBXTdCXTbIVEohBD/wKI+QIi/yheKEV+GjPgqGPF1wIhvGIHf+kz4zmvC9x5ym/ADI/BHRuBPTjN+dpiRwU42MzIyADNRZosFWcxksjAALcjGAMyutyKHSmdFTq0VuTRW5GYE5kmhZBsD0IZ8lD/RhgKMwALxdgagHYVi7SgcE1GEEVj0nQPF3jpQ/A29doQDsORLJ0qpXjhR+rmTAehEWQZgud/piQvlqcJjFyo+IkZgpQduVL7vRpXf3Kh6L6IaI7D6HQ9q3KZbHgagB7VuelD7hjesznUv6l7zot5VL+qHA9CHBpd8aHjRh0aqCz40ZgQ2YQQ2PUtn/AxAP5qf8qOFGoDU8kQArY4H0PoY/RJgAAbR9kgQ7Q5HtD8URIeDQXRkBHbcH2IAhtB5bwhd9tDuELoyArvtUtB9J+1Q0GO7gp7bgF5baYtEoRBC/IOI+gAh/ipfwIAvFQO+ChnwddCAbxiA3/qN+M4X8b3XiB88RvzICPzJRU4TA9CEDJTRbkImRmAmq5kBaGYAmpHVZEY2ys4IzG6wMAAtyKmzIJfWgtxqAFKeVCvypliRL9mK/EnWtAC0oSAViqc4GwrH2lCEAVj0vR3F3tFbO4pTiTd2lGQElnzlYAA6UPqFA2WeO1D2mcqJck+dKP+7ExWe0GNnOAArPXShsuqBC1Xuu1D1NxeqMQCr36U7bgagGzWp1i1iBNZmBNa54UHd6x7Uu0ZXPajPCGxwxYuGl+mSlwHoReMLXjQ572MA+hiAPjSj5mfotA8tGIEtT/rR6gQd9zMA/WjDCGzLCGx7NIB2RwJofziADocCaQEYRKf9QXRW7Quiy94gujICuzECu+0KMQBD6LEjhJ7bVQp6bVPQe6uCPltos4K+mxT02wj02wD0Xy9hKIQQ6SzqA4T4q32l6PF1KOJbRuC3AQO+8xvwvc+AH7wG/OhRGfGT24ifXUZkcJLDmBaAJmS2mpCFslrIbEoLQDNyGMzIqY/IpTMjNyMwj8aCvKmUYmEAWpCfCjACCyZSgpUBaEXhOCuKxFpRNMYWVuy9DcXf2VDirS0tAO0o9cqO0lTmJb2woywjsBwjsPxT+t3BAHSgIlViBFZ65GQAOlHlgRNV7ztR7Te650J1qnHXhZp36LaLAehC7V/dqHOTbrhRl+pdd6P+NTUAPQxADwPQg0aXPGh8UcUAZAQ2Pe9Fs3N01ssA9KIFA7DlqYhWJ31ofcKHNseJEdj2Fz/aHfWj/RE67EcH6sgI7HSQDgQYgAF02RdA1720J8gADKI79dhFO4PoyQjsxQjsvY22hhiAIfTdHEI/RmA/RmD/jQoGbKD1CgauUzBoLTB4Da2WKBRCiL+jqA8Q4q/2FXT4WtHhm3AA6vFdQI/v/RE/+PT4kRH4EyPwZ7cBGVzkNCAjZWIEZrYbkcVGViMD0IhsZiOyMwJzmMhoQk6DCbn0JuRmAObRksaMvJQv1Yz8KWYUCAeghQFoQaEECwqr4i0owggsyggsFmNF8ff0zooSVJIRWOoNvbYxAG0MQBvKvrCh3HN7WPlndlR4akfF3+mJnQHoQOVHDlR56EBV1QMHqjECqzMCa9yju04GoBO1bjtRmxFYmxFY51cX6t50od4NF+pfp2tuNLjqRkNqdIUuu9H4khtNGIFNL9B5DwPQg+bU4iwxAlue9qLVKS9an6QT3nAAtj3mQzvVLz60P+pDhyM+dAwHoJ8B6EfnA3502R/RlRHYjRHYfQ/tDjAAA+i5M4BeO4JhvbcH0WdbEH230pYgAzCE/ptoY4gBGMLA9SEMUjECB69VMGSNgqGraZWCYSuB4SuAEcslCoUQ4m8k6gOE+C/5RtHi25AO36mCOnwf0OEHvw4/+nT4yatnAOrxM2Vw65HRpUemcAAaGIAGBqABWSmb1YDsFjUAjQxAI3IajchlMCK3ihGYR2dCXq0J+TQm5E+lFBMD0IyCVCiJEs0MQDOKxJtRNM6CYrERxWMsKPHegpLhALQyAK0o/dqKMq+sKKtiBJZjBJZ/bkOFZ/TUxgC0oRIjsDIjsPJjO6o8sjMA7aj2wI7q9x0MQAdqUM17DtS6S3ccDEAn6txyou6vTtS7GVGfEdiAEdjwGl11MQBdaHzZhSZqAFLTi240u+BG8/N0zh0OwJZnPGh1mk550JranPSgLSOw7XEvA9CL9r940eEoHfGiIyOw02EfOh+igz50OeBD1/0+dNvnZwD6GYB+9KCeu4kR2IsR2HtHAH2207YAAzCAfmoAUv/NQQzYFMTAjbQhGA7AwetCGLKW1oQYgCEMo+GMwOErFYxYoWDkcgWjltFSBaOXAGMW0yIJQyGE+CtFfYAQ/yXfggHICPwupMX3QS1+CGjxo1/FAGQE/uzVIYOH3DoGoI4BqEdmyuLQI6udbHoGoJ4BaEAOswE5VSYDchkNDEAD8uiNyKsjrRH5KL/GiAKMwIKMwILJJgagCYUTTSiSYEJRRmBRRmCxODOKx5pRIobemxmAFpSi0m8tKPOGXlsYgBaUe2lF+Rf03IoKVPGZFZWeEiOw8hMbqjy2oeojG6qpGIHVGYE17ttR8ze6Z2cA2lGbAVhHdduBurccqPerA/Vv0g0nA9DJAHSiETW+SlecaMIIbHrJhWYX6YKLAehCi3MutGQEtjzrRqszbrQ+7UabU+60APSg3XEP2quOedDhFw86MgI7MQI7HfYyAL3octCLrgdUDEBGYPd9PvTYS3t8DEAfeu3yo/dO2uFHH+q73Y9+24gR2H9LAAM206YAAzCAQRsCGMwIHLw+iCHrghi6Nohha4JpARjCiJUhjFxBy0MYRaMZgaMZgWOWKBi7WMG4RbRQwfgFwIT5wMR5EoVCCPEfiPoAIf7LvlM0+D4U8UNQgx8DGvzECPzZp0UGL3m0yEiZGIGZGYFZnOTQMQB1yGbTITsjMAcjMIdFzwDUI5dJj9xGPfKoAUh59Qbk0xmQX2tAAQ2lGhmARhSiwsmUZESRRCMD0IRi8SYUj6NYE0pQSUZgKUZgqXdmBqCZAWhG2ddmlGMElmMEln9pQYUXFlR8Ts8s4QCs/LsVVajqE3psZQBaUf2hDTUe0H0bA9CGWlT7HjEC69yxo+5tO+rdsqP+r3TTjgaMwIY3HGh0na45GIAONGEANr1Ml5xoRs0vOtHiAp1XA9CFVmddaH2GTrvQhtoyAtudpBNuBqAbHY650fEXOuphAHrQmbocpkMedD3oQTdGYPf9tM/LAPSi5x4vejECezECe+/yoc9OH/ruoO2+cAD230pb/BhAAzf7MWgTbVQDMIAh6wMYuo7WBhiAAQxnBI5YTauCGLkyiFEraHmQARjCmKUhjF1Ci0MYR+MXhTCBEThhgYKJ8xVMmkdzFUyeA0yZDUydJVEohBBpoj5AiP+y75CK75VU/BBKxY/BVPykBiD97Ncgg0+DjF4NMnnIrWUAapGFsjq1yObQIrudGIE5rDrktOiQy6xDbpVJhzyMwLwGPfLp9civI60eBRiBBRmBhVIpxcAANKBIkgFFGYDFVAlGFI83okScESVjKcbEADSh9DsTylDZt/TGxAA0o/wrMyq8pBdmVKRKz82ozAis/NTCALQwAC2o9tiC6moAUo2HVtR8YEWt+/SbNRyAde7aUPeODfVUt22of8uGBozAhozAhjfsDEA7Gl+zo4mKEdj0igPNLjvQ/BJddDAAHWh53olWqnNOtD7rRJszTrQNB6CLAehC+xMudDge0ZER2IkR2PkoHXEzAN3oesiNbmoAUvcDHvTY70HPfbTXwwD0ovduL/rsop1e9KV+O4gR2H+bDwO2+jBwC232MQB9GLzRjyGqDX4MXe/HsHV+DF+rBmCAARjAyFUBjFpJKwIYzQgcwwgcsyyIsUuDGLckiPGLg2kBGMLEBSFMmk/zQphMUxiBU+YomDpbwbRZCqbPpBkKZkwHZk4DZk2VMBRC/MuJ+gAh/lt+UFLwoyqUgp8YgT8HUpHBT75UBmAqMlFmRmAWtwZZXeTUMAA14QDMQTltZNUil0XLANQiDwMwr5EMOuSj/HodCuh0KMgILKjRMwD1KJyiRxEqmkyMwGKJBhRPMKBEPMUZUJJKMQJLxxhR5j29MzIAjSjHACz/OqLCKxMqvjSh0gtTWgCaUeWpGVV/N6Oa6okZ1RmBNR5ZUPMhPbAwAC2oTXUYgXXuWVH3rpUBaEX923TLygC0oSE1umlD4xt03RYOwKZX7Wh2hS7b0ZxaXLKjJSOwJSOw1XkHWp9zoM1ZOuNgADrRjtqfopNOdDjhRMfjTnQ65mIAuhiALnShrkfosAvdGIHdD7rR4wDtdzMA3ejFAOyt2uNBn90e9N3lQb+dnnAA9t/uxYBttNWLgTRoixeDGYGDGYFDNvowdIMPw9bTOh8D0I8RNHINrfZj1Co/Rq8kRuCY5QGMXRbAuKW0JMAADGACI3DiIloYxKQFQUyeH0wLwBCmzglh2myaFcJ0msEInMkInDldwaxpCmZPpSkK5kwG5k4C5k2UKBRC/FOL+gAh/lt+QDIDMBk/MQB/DqYgQyAioz8FmXwpyMwAzOIhdyoDMBXZKLszFTkYgTnsGgagBrmsGuS2aJBHxQjMa9Iin1GL/AYtCui1kQCkQlodCmsoVccA1IUDsFiSHsUTI0ok6FEyXo9S4QA0MAANDEADylK5d8QILP/GiAqvjaj4il4aGYBGVGYEVnluQtVn9NTEADShOgOwxmN6ZEZNqvXQjNoPzGkBaEHdexbUu2tBfdUdCxowAhsyAhv9SjetDEArmly3ouk1W1izqzY0v2JDi8t0ycYAtKPVBTtan49oc86OtmftaMcIbHfawQB0oMNJBzqeUDEAGYGdjznR5Rc66mQAOtGNAdj9EB10oQf1POBCr/3ECOy9140+e9zou5t2uRmAbvRnBPbf4cGA7R4M3ObBoK20xcMA9GLIJi+GbowYtsGL4YzAEYzAEWt9DEAfRq2mVb5wAI5Z4cdY1XI/xi3zY/xSPyYsUQMwwAAMYNJCWhBgAAYwhRE4dR7NDWLanCCmzw5ixiyaGWIAhjBrOk0LYTbNmRrCXEbg3MkK5k1SMH+iggUTaDywcBywaKxEoRDin0bUBwjx3/aTkkTJ+DmUjAzBZGQMJCOTn3zJDMAUZKGsnhRkc6cguyslLQBTkdOeilyU20bW1HAA5jVrkM+kQX5jRAGDBgUZgYV0pNUyALUokqpFUSrGCCyWrEPxJB1KJOpQMoHidQxAPUpTmVg9ysbQe304AMu/NaDCm4iKrw2o9MqAyi/VADQyAI0MQCOqPTWiuooRWOOJCTUfm1DrET00MQBNqHPfjLpU7ze6Z2YAmtHgjhkNb1sYgBYGoAWNqclNYgQ2ZQQ2u2ZF86t0xcoAtKIlI7AVI7DVRRtaX7ChzXkb2p6zpQWgHe2pw2k6ZUfHk3Z0YgR2Pk7HHAxAB7oedaCbihHY/bATPQ450fMgHXCGA7D3Phf6qPa60HePC/120y41AN0YsMONgdtpmxuDaDAjcAgjcMhmD4Zu8mDYRg+Gb6D1XgagFyPXejFKtcaL0au9GMMIHLPSxwD0YdxyH8Yvo6U+BqAfE2nSYlrkx+SFfkxZoAZggAEYwLS5AUyfQ7MDmMEInMkInDWTZgQxe3oQc6YF0wIwhHmTQ5g/iSaGsIAWMgIXjadxChaPVbBkDI1WsHQUsGwksHyEhKEQ4n+cqA8Q4r/tJyThZ0ZghhAFkxiASchEmRmBWRiBWb3kSWYAJjMAk5GDEZjTSY4UBmAKAzAFeawpyGtJDctnTkV+UyoKGFNR0EB6DQNQg8JURKtBUY0mLQC1KJ6sRYmkiJKJWpRiBJZmBJaJo1gdA1CHcu91KM8ILP9Ojwpv9aj4Ro9Kr+mVngFoQJUXBlSlas/pmYEBaECN342o+YQeG1GLaj8yog4jsA4jsO59EwPQhPr36K4JDRiBDRmBjW6b0fgW/WpmAJrR9IYFza5HNL9mQYurFrS8QozAVpesaH3RijYXItqet6IdI7D9WTpjYwDa0PGUDZ3CAWhHZ+py3I6ux+gXezgAux9xoMdhOuRAT+p10IHejMDe+50MQCf67nWi3x7a7UT/XS4MUO10YeAOFwZtd2HwNtrqZgC6MXSzG8M2RQxnBI5gBI5cT+s8DEAPRq/xpAWgF2NXejFOtcKL8cu9mMAInMgInLjExwD0YfIiWuhjAPoxlabNp3l+TJ/rx4w5fsxkBM6cFWAABjB7Bk0PMAADmMsInDeVpgQxf3IQCyYFsTAcgCEGYAiLx9HYEAMwhKWMwGWMwGWjFCwfqWDFCBquYOUwYNVQYPUQiUIhxD+0qA8Q4m8iAxKRQUlExlAiMgUTkTmQiCz+JAZgErJSNm8SsnuSkMNNjMCczmTkciQjtz0ZeVSMwLyMwHyWFOQ3p6CAiYwpKMgILMQILKwnXSoDMJUBmIpiqRoUV6VoUCJZg5JJGpRKpAQtA1CLMlQ2TotysRSjBqAOFd7pUPEtvdGhElVmBFZhBFZ9SS/0DEA9qj/To4YagFTzdwNqPTGg9mN6ZGAAGlH3gRH1qP59+s2IBveMaMgIbHSHbpsYgCY0oaaMwKaMwGY3zGh+3YwW1+iqORyArS5b0Fp1yYI2Fy1oe8GCduEAtDIArehwxoqOqtNWdGIEdj5pQ5cTdNzGALSh2y82dGcEdj9qR48jdvQ8bEevQ3TQzgB0oM9+B/rui+i314H+jMD+jMABu5wYuNOJQTtouzMcgENo6Fba4sKwzS4M3+TCiI1uBqCbAejGqHW01o3RNIYROHY1rfIwAD0Yv8KDCctpmZcB6MUk1RIvJi/2YgojcCojcOoCHwPQh+nzfJgx1xcJQJo1m2b5MXumH3Nm+DF3uhqAAQZgAPOnBLBgMk0KYCEjcNFEmhDE4vFBLBkXxNKxxAhcNjqE5aNCWDGSRoSwcngIqxiBq4YpWD1UwZohCtYOpkHAuoHA+gEShUKIfxhRHyDE30QGJCCjkoBMIQomIDMjMAsjMKs/Edl8icjuJU9iOABzUi5XEnI7yZHEAExCXlsy8lmTkV9lSUYBczIKmpJRiBFYyJDCAExBEV0KilIxRmAxRmDx1FSUSElFyWRKSkUpRmBpRmCZBA3KxlOchgGoQfkYLSqo3mtR8Z0Wld5qUfkNvdYxAHUMQB2qUfUX9FyHGozAmk/1qPU7PdEzAPWowwisywis95AeGBiABjT4zYCG4QA0ohE1vmNEk9t0y8gANKHZTROa36DrJrSgltdMaMUIbHXFzAA0o80lM9pepAtmtGMEtj9vQYdzdNbCALSgEwOw8yk6aUUX6nrCim7H6ZgagDb0OGpDzyN02MYAtKE3I7API7DPATv67rej3z7aa2cAOjBgtwMDd0UM2unA4B0ODGEEDtnmZAA6MWyLE8M3OyMBSCM3ujBqA613YfQ6F8aEA9DNAHRj3Co3xqtWujGBETiREThpGS31YPISD6YspkVeBqAX02j6AprvxYx5XsxkBM6aQ7N9mD3LhzkzaYaPAejHPJo/jab6sWCKHwsZgYsYgYsmBrB4QgBLxtO4QDgAl9HyMTQ6iBWjglg5kkaoARjC6mEhrBlKQ0IMwBDWDVIYgArW04YBCjb2p34KNvUFNveh3hKGQoh0F/UBQvzNZEQ8MinxyByKRxZGYNYA+RMYgAnITjm8CcjJCMzpTmQAJjIAE5HHkYi8jMC8jMB8tiQGYBIKWJJQ0JwUCUAqbExGEUMyiupJl8wATEFxTQpKpEaUTElBqeQUlGYElkmkhFQGYCrKUfk4YgRWiNGg4nsNKr2jt5pwAFahqq+1qPaKXmoZgFrUYADWfBZR66kOtX/Xoc4TYgTWfaRnAOpR/0FEg/t6NGQENrpnQOO7dMfAADSg6S0DmjECm/1qRPObRrS4YUTL68a0ADSh9RUT2qgum9D2kgntGIHtGYHtz5sZgGZ0PGtGJxUjsPNpC7qcsqDrSTphYQBa0P2YFT1+ieh51IpeR6zofZgYgX0O2tD3gA399kf0ZwQOYAQO2GPHwN12DNplx+Cd9rQAdGAoDdtGWx0YvsWBEYzAkZtoo5MB6MTo9bTOiTGMwLFrXRi3hla7GIAuTFjpwsQVbgagmwHoxuSlEVMYgVMZgdMW0UIPA9CDGfM9mBkOQC8D0IvZqtlezJnlxVxG4DxG4LzpPgagDwum+rBwCk32MwD9WKya6MeSCX4sHe/HMkbgsrEBBmAAK0bTqAADMIBVI4JYrRoexJphQawdSozAdYzA9YNC2DCQBoQYgCFsCgegwgBUsIW29qZeCrb1BLb3oO4ShUKIv6uoDxDibyqzEocs4QCMR1bKFohHdn88cvji0wIwAbncCchNeVzkTGAAJiKfPRH5bYkoYI0oaElEIUZgYRMZkxiASQzAJBSj4ozA4tpklNAko2RqMkqlJKcFYArKUNnEFJRLoPiUcABWiE1FxZiISu9TUfldKqowAqu+odcaBqAG1V9qUEPFCKz5XItaz7So/ZR+14YDsC7Ve6xD/Uf0UIcGD3RoyABs9Bvd06MxNbmrR9M7dFsNQAOa/2pAi5t0w4CW1IoR2PoaXTUyAI1oe9mIdpfoogntqcMFEzqep3OmcAB2PmNGl9N0yswANKMbdWcEdmcE9jhmQc9fLOh1lI5YwgHYh/oeooNW9DtgRf/9tM/GALRh4B4bBu2OGLzLhiGMwKE7aLudAWjH8K12jNhCmx0YSaM20UYHRm9wYAwjcCwjcOxaJwPQifGrnZiwSsUAZAROWkHLXZi8zIUpS12YusTNAHQzAN2YvtCNGaoFbsxkBM6aR3M9DEAP5sz2YO4smullAHoxnxZMp2leLGQELmIELprsYwD6sGSiD0sn+NIC0I/ltGIsjfFj5Wg/VjECVzECV48IYM3wANYOo6EBrBsSxPrBNCiIDbRxYBCbBhAjcHO/ELb0pT4hBmAI23qFsL2nwgBUsKO7gp2qbgp2dQV2dwH2dJYoFEL8zUR9gBB/U5kRiyyMwKyhOGQLxiF7gPxxDMA45GQE5vLGI7eH3PEMwHjkZQDmcyQgv8qegAK2BBS0JqBQOAATGYCJKEJFjYkoZkhMC8AklNAmoaQmolRqEkozAsskJ6NsEiUmMwCTUZ4qMAIrxKWgYmwKKsWkoPL7lLQATEVVqvYmFdVf06vUcADWfKFBref0TIPaVOepBnUZgfWe0GMtA1CLBg+1aKhiBDa6r0Pj33Roco/u6hiAOjS7rUdz1S09WvyqR8uberQKB6CBAWhAm6sGtFVdMaAdI7A9I7DDRbpgZAAa0emcEZ3PmsK6nDGh62kTup2ikyYGoBk9jpvR81hEr1/M6H3UjD6MwD6HLQxAC/odpAOWcAAOoIH7aK8Vg/ZYMXi3FUPCAWhjANowbLsNw1XbbBjBCBzJCBy1mTbZMXqjHWM20HoHxtK4dQ6MX0trHJiw2oGJjMBJK2mFE5OXOzFlmYoByAictsSF6YtpkYsB6MJMBuCs+TTPjdlz3ZijmuPGXEbgPEbg/Jk0w8MA9GDhNA8WTfUyAL1YPNmLJapJXiyd6MUyRuDy8TTOxwD0YeUYGu1jAPqxeqQfa1Qj/Fg73I91jMB1jMD1QwLYMDiAjYNoYCAcgJv7U78gAzCIrbStDzECtzMCd/SkHiEGYAi7uoWwu6vCAFQYgAr2dqKOCvZ1ULC/A3CgPbWTMBRC/NWiPkCIv7msSiwDMBbZKHswFjkCscjpVwMwjgEYxwCMQx7K6yZGYD5nPAMwHgXs8ShoI2s8CjECC1sSUMScgKImMiYwABNQXJ+IEipdIkpqE1FKk4jSDMAyKZSchLJULikJ5ROT0gIwGRXjklEplmKSUZmqMAKrvktBtbf0JoUBmIIar1JQkxFY82Uqar1IRe3nqajzjJ6mMgA1DEAN6qsea9DgkSYcgI0eaNH4Pv2mZQBq0ZSaMQKbMQKb39ahxS0dWv5KN3UMQD1aU5vrdE3PANSj3RU92l82MAANDEADOlKnC3TegM6MwC5njeh6hk4bGYBGdGcE9mAE9jhhQs/jJvQ6ZkLvX0xpAWhG38Nm9FMdMqP/QTMGMAIH7LcwAC0YtNeCwXtotwVDGIFDd1kxbCftsDIArRixzYqRW20MQBsD0IbRqk02jGEEjmUEjltP6+wMQDsmrLFjohqANGmVA5NX0goHpix3YCojcNpSWuJkADoxY5ETM1WMwFkLXJg9n+a5GIAuzJ3jwrzZbgagmwHoxoIZbixUMQIXMQIXT6UpHgagB0snebAsHIBeBqAXK8ZFrBzrxSpG4GpG4OpRPgagD2tH0HAfA9CP9UP92DCEBvuxkTYNIkbg5gEBbOkfwNZ+1DfAAAxge+8gAzDIAAxiZ48gdnVXMQAZgXu6UpcQ9nYOYV+nEPZ3VANQYQAqONiO2io41EbB4dbAkVYR0f6hEOIfWtQHCPE3lxUxyKbEIHsoBjmCFIhhAMYiF+X2xSKPlzyxDMBY5HPFIb8zDgVUjjgUtMehECOwMCOwsCWeARiPolTMFI/ijMDijMAS+gSU1CWglJY0CSjNCCyTmoiyKYkol0xJiQzARFRISEJFVXwSKsUloXJsEqrEJKHq+2QGYDKqUfW3yajxhl6rAZiCWi9TUPsFPU9BHarLCKzHCKz/Oz1JRYPHqWj4KBWNHmrCGj/QoMl9DZr+Rvc0DEAtmt/RosXtiJa3tGjFCGzNCGx9Q8cA1KHtNR3aXVUxABmBHS7r0fESXdQzAPXozADsci6i61kDup0xoPtpYgT2OGlEzxNG9DpOx4zoTX0YgX2P0hETA9CE/odMaQFoxsD9ZgxS7TNj8F4zhjAChzICh+6yMAAtGL7DghEqRuBIRuCorbTFygC0YswmK8ZutDEAbQxAG8bThHW01oaJjMBJq2mVnQFox5QVdkxdrnJg2jIHpi91YMYSWuwIB+CshbTAyQB0Ys48J+bOVTEAGYHzZ7uwYBbNdDEAXVg03c0AdDMA3VgyxY2lqsluLGMELp/owYoJNN6DleM8WDWWxngZgF6sGeXF2pER6xiB6xmB64f5sGGoDxuH+LBpsC8cgJsH+rFlAPX3MwD92EbbGYHbGYE7egewsxf1DGBXjwB2MwL3dKOuQeztEsS+ztQpyAAM4YCqQwgH24dwqF0Ih9sSI/BIawVHW1FLBb+0UHCsOXC8GTWVKBRC/JuoDxDi7yK78p4B+B45KCcjMBcjMLeffDEMwBjk9cQgHyMwPyMwvyuWARiLgo5YFLKTLQ6FqYg1DkUtcShmJlMcAzAeJQzxKKnSx6OULh6lGYFlGIFlUyklgQGYgPJUgRFYgRFYMSERleITUTmOYhNRhRFYlRFY7X0Sqr+jt0kMwCTUfJ2MWq8iar9MRp0Xyaj7PBn1nqUwAFMYgCloQA2fECOwESOw8cNUNHlA91MZgKloxghszghsfleDFnc0aHlbg1a36FctA1CLNtT2Bl3Xot01LdozAjtcocs6BqAOnajzRWIEdjmvR9dzenQ7S2f04QDsccqAnqqTBvQ6YUDv4wb0CQegkQFoRL8jEf0PGzGAETjwIB0wMQBNGLzPhCF7aY8ZQ2nYbjOG76KdZgagGSO3WzBqG221YPQWC8aoGIFjGYHjNloxfgOttzIArZjIAJy0hlbbMJmmrKKVNkxlBE5jBE5fRkvtDEA7Zi62Y9YiR9jshQ7MWUDzHZg7z4F5jMD5c2i2kwHoxMKZTixiBC5iBC6e7sKSaTTVxQB0YRkDcPkkmuhmALqxcnzEKkbgakbgmjE02oO1ozxYN5JGeBmAXmwY5sXGoTTEi020mRG4eZAPWwb6sHWAD9v6Uz8fA9CPHX2ot58B6Meunn7sVgOQ9nQPYG836hrAvi4B7GcEHmAEHugYxMEOQRxqT+2C4QA80oZahxiAIfxCx1oSI/B4cwUnmlFTBSebKDjVWMHpRsDphsCZBhKGQvwLivoAIf4usuMdcijvkDNEwfcMwPcMwPfIQ3l95H3PAIxhAMaggCsGBZ0RhRwxKMwILGKLRVErWWIZgLEozggswQgsYYxjAMahlD4OpXVxKKONDyuriUe51HiUT6HkeAZgAiomJqBSQkTl+ARUiUtAVUZgtRh6n8gATEQNqskIrMkIrPU6CbVfJaHOS3qRFAlAqv+MniYzAJMZgMlo9DgFjR9FNHmYgqYPUtDsPjECm99LRYu7qWh5J6LV7VS0ZgS2+ZVuahiAGrS7rkF7NQCpw1UtOl7RotNluqQNB2CXCzp0PU/ndOhG3c/q0IMR2OO0ngGoR6+TevQ+Qcf16MMI7HvMgH6/0FED+h8xYMBhOmRkABox6IARg1X7jRjCCBzKCBy2h3abGIAmjNhpwkg1AGnUdjNGb6OtZgagGWM3WzBuE220MAAtmEAT1xMjcNJaKyavodVWBqAVU1daMW2FjQFow3SascyGmUuJETiLETh7ES20MwDtmDvfjnlqANL8uQ4smOPAwtk0y8EAdGLxDJruZAA6sXSqE8umqFxYPtmFFZNoogsrJ7iwarwLq8e5GYBuBqAba0fTKDfWMQLXMwI3jKDhHmwc5sGmoZ60APRiyyAvtg6kAV4GoBfb1QCkHX192NnHh129qZcPuxmBe3pQdz8D0I99Xf3Y34U6BxiAARxUdQzgUIcADrcP4Agj8EjbII62CeKX1tQqGA7A4y1CONGcmoVwsmkIp5qE0gJQwRlVQwVnGyg4V1/B+XrA+brAhToShUL8k4v6ACH+bnIob8MBmItyB98hT4D87xiA75CPAZjf8x4FVO73KOh6j0LO9ygcDsAYBmAMilIxawyKW4gRWMIUi5LGWJQyRJTWx6IMI7CsNg7lNJQaxwCMQwVGYEVGYMWkeFRKjEflhHhUiY9H1XAAJqAaVY9JQI339C6BAZiIWm8SUft1RJ1Xiaj7MhH1GIH1n9OzJDR4moSGvyehkYoR2PhxMpo8SkbTh/QgORyAzX9LQQvVvRS0vJuCVndS0DocgKkMwFS0vZmKdqobqWjPCOxwTYOOV+mKhgGoQedLGnRhBHa5qEXXC1p0O69F93PatADUoedpHXqpTunQ+6QOfRiBfRmBfY/pGYB69D9KR/QYwAgcyAgcdIgOGhiABgzZb8DQfUYGoJEBaMRwGrGbdhkxkhE4agdtNzEATRiz1YSxagDSuM1mjN9kxoSNtMEcDsBJ62ithQFowRSaupoYgdMYgdNXWDFjOS2zMgCtmLXExgC0YTbNWWTD3IW0wIZ5jMD58+xYMJfm2BmAdiyapXJg8UwHlsxwYOl0mubAMkbgckbgisk0yYmVE51YNcEZCUBaM86FtWNpjAvrRruwnhG4fqSbAejGxuFubBpGQ93YzAjcMoQGe7B1kAfbBnqwfQAxAnf082JnX+rjZQB6sZsBuKdnxN4ePuzrTt182M8IPMAIPNDZzwD041BHPw538KcFYABH21KbAAMwgGN0nBF4vGUQJ1oEcbI5NQviVNMgTjMCzzSmRiGcbRjCuQZUP8QAVHChLtVRcLG2gku1FFyuibArNSQKhfgnEvUBQvzd5MQb5GIE5g5R8C0D8C3yUj7/W+RnBOb3vmMAvkNB9zsUckUUZgQWcbxHUft7FLOR9X04AEuYY1BSZYpBKWMMShtiUIYBWFZH2liUo/KaWFRIJUZgxeQ4VEqKQ+XEiCoJcajKCKwWF4/qsRQTzwCMR00GYC3V2wTUfpOAOq8TUPdVAuqFAzAR9anB80Q0fEZPE8MB2PhJEpo8pkdJaErNHiahOSOw+f1kBmAyWt5LRqu7dCcZrRmBbW6noO0t+jWFAZiC9gzADtfpWio6Uqerqeh8hS6rAahB14sadLtA5zXoTj0YgT3P0hktA1CL3qe06HOSTugYgDr0Ux3Tof8vOgw4qsNARuDAw3oGoB6DD+oxRMUIHMoIHLbPgOF7aY+BAWjASAbgqJ0Ro3cYMWY7bTNiLCNw3BYTxm+mTSYGoAkTaRIjcNJ6MyavM2PKWlpjZgCaMW2VBdNX0goLZtDM5RbMYgTOYgTOXmLFnMW0yMoAtGIeA3D+fJpnwwJaONeGRXOIEbiYEbhkJs2wMwDtWDbNjuVTHWErpjiwcjJNcmDVRAdWMwLXjKdxTgagE+vGOCMBSBtGubBxJI1wYdNwFzYPUwPQzQB0Y+tgN7YNooHucADuUPX3YGc/D3b19WB3H2IE7unlxd6e1MPLAPRifzcvDnT1MQB9ONjZh0OdIg539OEII/BIez+OtvPjl7Z+HGvjTwvAAE60pBYBBmAAp5oFcDocgEGcobONIs41DOI8I/ACI/BCvRAu1g3hUh2qHcJlRuCVmlRDwdXqCq5VU3C9KlUBblQGblaSMBTif6CoDxDi7yqX8ga5KU/oDfIGKfCGAfiGAfgWBbxvUVDleYtC7rcozAAs4nyHog6yv0MxKm57hxKMwBKW9wzA9yhleo/SxvcoY1DFoKw+BuV0MSivJU0MAzAGFVNiUUmVHIvKSbGokhiLqgzAavEUF4fqVCM2DjVjiBFY6108ar+NR5039DoedakeI7D+S3qRwABMYAAmoNHTBDT+PTGsyZNENH2ciGaPEtMCMAkt7iehpeq3JLS6l4TWjMA2jMA2t5MZgMlo92sy2qsYgR1upKDj9RR0ukZXUxiAKehyORVdVZdS0e1iKrpfSEWP83ROwwDUoNcZDXqfjujDCOzLCOx3go5r0f+YFgN+0UYCkAYd0WHwYTqkYwDqMPSAHsP20z49A1CPETRyDzECR+0yYPRO2mFgABowdpsB47Yaw8ZvMWLCZiMmbjKmBaAJk9fTOhMD0ISpNI0ROI0ROH2VGTNWmjFzBS03MwAtmL2UllgYgBbMpXmLiBE4f4EVC+ZbsXAezbUyAK1YPNvGALRhCS2dacOyGcQIXM4IXDGVptgZgHasmmTHajUAac0EB9aOp3EOrBvrwHpG4IbRNMrJAHRi0wga7mQAurCFtg6lIS5sG+zC9kHECNwxwI2d/d3Y1Y/6usMBuKc39fJgL+3r6cH+HsQIPMAIPNiVunhxqLMXhzt5cSQcgD4cbe/DL+2orY8B6MNxRuCJ1tTKj5Mt/TjVgpr7cZoReKYpNQngbOMAzjUK4HxDahBkAAZxsR7VDTIAg7gcDsAQrtDVmiFcq0HVQ7jOCLzBCLxRRcHNygp+rUQVFdyqANwuD9wpJ1EoxD+4qA8Q4u8qN14jj0Kh1wzA18gXeI38jMACjMACvjcMwDco5HmDwm5yvUURKup8i2KOtyhuf5sWgO9Q0vIOpVTmdyhteocyjMCyjMByetK9R3mqoH2PiozAiozASikxqJwcgypJMaiaqIpFtYRYVI+PRY04io1lAMai1vs41Fa9i0Odt3Go+yYO9RiA9V/Ry3g0eBGPhtToOTECGzMCm/yegKZP6HECAzABzRmBLR7Sg0QGYCJa/ZaI1vfobhLaUNs7SWh3m24lMQCT0OFmMjreoOvJDMBkdKYujMAujMCul1PQ7VIKul+kCynhAOxJvc7R2VT0PpOKPqdT0feUhgGoYQBq0F91XIMBxzQYyAgcdJSOaBmAWgw5pMVQNQBp2AEdhu/XYcQ+2qsLB+D/Yreegm1NFC5N/8dW5jlpe2fmtm3btm3btm3bNpY9bdueS6PGN+e6+KOiOzqio+vs01Xz4rkfVyPemafopIMB6MBsmnOcGIFzGYHzjjgx/zAdcjIAnVh4wJWwaL8Li/e5sGQv7XExAN1YtsuN5Ttph5sB6MZKRuBKRuCqrR6s3uLBms20yZMIwHUbvFi/ntZ5sYE2riVG4CZG4OZVPmxZSSt8DEAfti3zY/vSpB1L/Ni5mBb5sYsRuHtBAHvm07wA9s4NYN8cmh3EfjowK4iDM2lGEIcYgYcZgYenhhiAIRydHMKxSaFEAB6fEMaJ8Uknx4VxamwYpxmBp0dHcGZUBGdH0ogIAzCC88OiDMAoAzCKi4OjuDQo6TIj8MoA6h/D1X4xXOsbw/U+QgDGGYBx3OxJPeIMwDhuMwDvdKUuxbhL9zpTp2LcZwQ+YAQ+aF+Ch+1K8KhtCR63IUbgk1aleNqSWpQyAEvxvBk1LWMAluFl4zK8akQNy/C6QRne1C9PSKtbjnRBnXJk1AYyawFZNVNRmJLyH+StD0hJ+V/u23IpvqPvy6T4oZQYgZWKZfgxLsNPsaSfGYGVGYFVwnJUDVFQzgCUozojsIaffAoGoAK1PArUditQx6VMqOtUop5Difp2sikZgCo0tKjQSGBWobFJhSaMwKaMwGZ60qkZgGq0oJaMwJaMwFYqDVorNWij0KCtXKBFO5kW7aVadJCQWMsA1KJTkQ6dC5O6FOjQNV+HbnlCAOoZgHr0yNajZ1ZSL0Zgb0Zgn3RKMzAADej32oD+QgDSgJdGDHxhxKDn9MzIADRhyBMThj5OGvbIhOEPTRjBCBxx38wANGPUXTNG3xEwABmBY2/RTQsD0ILx1y2YkAhAKwPQikk0+TJdsmIKI3DqBRumnadzNgagDTNoJiNw5mk7Zp2yY/ZJOmFnANox95gD844mzT/iwILDDixkBC5kBC464MTi/bTPyQB0YikDcJlgtwvLd7mwYqcLK3cQI3DVNjdWb6UtbgagG2tpHSNw3UYP1m/wYMN6Dzauo7UebFrjxebVtMqLLbR1pRfbGIHbGIHbl/mwYykt8TEAfdjFANy9kBb4sYf2zqd5fuxjBO5nBB6YTbMCDMAADs2g6UEGYBBHpgZxVDAliGOTgzjOCDw+MYQTE0I4OT6EU+NCFQEYxpnRNCrMAAzjHJ1nBJ5nBF4YFsHFoTQkgkuDI7icCMAoAzCKq/2juNaP+kYZgDHcEPSO4WavGG71jOF2D2IE3ukWx92u1CXOAIzjfqc4HnQsZgAW42H7YjxqR22LEwH4pDW1KsFTetayBM9bECPwBSPwZVNqUopXjUvxuhExAt8wAtPqlyG9HtUtQ0adMmTWLmcAljMAy5Fdg6qXI6daOXKrAnlVqHIqDFNS3oK3PiAl5X+57yBhAEoYgJJEAFYqkeJHQbEUP8Wl+DkmReWoDFUiFJahKlULyVA9SIzAGn45avrkqOWVo7bAI0cdRmBdlwL1nORQMAAVaMAIbMgIbGhVMgCVaGxWoolJiaZGVUIzgwrN9Sq00JFWxQBUo5VajdaqpDZKNdoq1GjHCGwn0zAANQxADTqKNejECOzECOxcpEWXQi26FlC+lgGoQ3fqkUs5OvTM1qFXlg69M/UMQD0DUI++1C+N3ujRnxE44JUBA1/SCwMD0IDBjMAhjMAhT40Y+sSIYY+NGP7IWBGAJoykUffpngmj75owhhE49jbdMmPcTTPG30iawAiceM2CSVfpioUBaMGUSxZMvWhNmHbBiunnrZhxzloRgDbMOk2nbAxAG+bQXEbgXEbgvGN2zD9qx4IjdNjOAHRg0cGkxQccWLLfgaX7iBG4bI8Ty3c7sWIX7XQyAJ1YxQhctd2F1dtcWLPVhbVbXBUB6Mb6jW5s2EDr3dhImxiBmxiBm9d4sGW1B1tX0UoPA9CL7ctpmZcB6MVO2rWEGIG7F/mwZyEt8DEAfdg3z4f9c/0MQD8D0I+Dgll+HGIEHmYEHplO0wIMwACOTQlUBGAQJyYGcXJC0qnxQZxmBJ4eG8KZMSGcHR3CuVE0MsQADOPCcBoWZgCGcWlIGJcHCyK4MiiCqwNpQATX+kdwnRF4gxF4o08UN3tHcasX9YwmAvBOd+oWYwDGcK9LDPcFjMAHjMCHHalDHI/ax/G4HTECn7QpxtPWxXjWiloWMwCL8aJ5CQOwhAFYgldNqHEJA7AEbxqWIq0B1S9FOmXUI0ZgJiMwqzbVKkN2zTLk1ChDLiMwlxGYV7Uc+VWocjkKfi5H4U9A4Y9AUaVUFKak/C/21gekpPxbfA8xfigXoxIjsFKphAEowU/FEvwcT6rMCKwSlaJqRIpqYQpJEwFYIyBDTYFfhlo+GQNQhjoMwLpucslRj+o75WjgIEZgQ5sCjawKNLYo0ETACGzKCGxmVKK5gfRKBqASLRmBrRiBrTQqtFar0EalQlulCu0SAahGe+ogU6OjlCRqBqAGnUUadCmiQg26UrcCDbozArvnaRmAWvTM0aJXtoAByAjsk6lD3wxK1zEAdejPABzwOmngKz0GvdRj8AtiBA55ZsDQpwYMe0KPDRhOIxiBIx/SAyMD0IjR94wYc5fumDCWxt2mWyaMv2nCBAbgxOt0zcwANGMyTblCjMCpjMBpFy2YfoHOWxiAFsw8a02YdcaK2aetmHOKTloZgDbMO27D/GN01IYFtJARuJARuOiQHYsP2rHkAO23JwJw2V4Hlu9JWrHbgZW7aKcQgE6s3u7Emm201ckAdGIdI3D9ZtrkwoaNLmzcQOtdDEA3Nq91Y8saWu3GVtrGCNzOCNy+woMdyz3YuYyWehIBuHuxF3sW0UIv9tK+BcQI3M8IPDDXh4NzaLYPh2b5cHimnwHoZwD6cXSaH8cEU/04zgg8MZkmBXByYgCnJgRwejyNC+LM2CDOjqHRQQZgEOcZgecZgRdGhHBxeAiXhtHQEC4zAq8wAq8MCjMAw7g2IIzr/alfBDfoZl/qE8Gt3hHc7hXBHUbgnR5R3O0exb1u1DXKAIziQecYAzDGAIzhUYcYHrePJQLwSds4nrah1nE8o+etiBH4ghH4snkxXjWjpsV43aQYbxiBbxiBaQ1LkN6A6pcwAEuQWbcUWXWodimya5UipybVKGUAliGvGlUtYwCWoaByGQp/pp/KUUSiH6lSOcQ/lEPyHSD5FpB+m4rClJT/D731ASkp/xY/QFQRgGL8WCrGT4ISMX4uFqMyA7BKTIKqUYpIUI2qhyWowQisEZQyAKWo5Zeitk+KOgJGYF2PDPXcMtR3kVOWCMCGdjkaCWxyNLbKGYByNDUr0MxERgWaUwuDAi31xAhspVWitUaJNmol2gpUSrRjBLZXqNBBTjIVA1CFTgzAzgKxGl1EanQtUqNboboiADXokadBT0GuBr1yNOjNCOyTRZlaBqAW/dK16C9I02HAGx0GvtZh0Ct6qUsE4JDnegwVPNNj2FM9hj/RY0QiAA0MQANGPTBgtOC+AWMYgWMZgWPvGBmARoy/ZcSEmwITJt4wYdJ1EyZfo6smBqAJUy+bMe0SXTRjOs24YMZMRuBMRuCssxbMPkOnLQxAC+YyAOcJTlgx/7gVC45ZsfAoHbFh0WEbFh+igzYsoaUHbFjGCFy2z47le+1YsceOlbtplx2rdjqwWrDDgTXbHVi7zYF1W4UAdDIAndiwyYmNG2mDE5sYgZsZgZvXubBlrQtb17iwbTWtcjMA3dixgpa7GYBu7KLdjMDdSzzYs9iDvYtooYcB6MH++V4cmEdzvQxALw4JGIGHGYFHZvpwdAZN9zEAfTieCEA/A9CPk5P8ODWRJvhxmhF4hhF4ZlwAZ8cGcG5MAOdHEyPwwsggLo6g4UEGYBCXh9KQEK7Q1cEhXBtEA0O4zgi8wQi80S/MAAzjVp8wbvcOVwRgBHd7UPcIAzCC+10jeMAIfMAIfNg5ikedqGMUjztE8YQR+KRdDE/bxvCsTQzPW1OrGF60jONlC2oeZwDG8bopNYkzAIuR1qgY6Q2pQTEyKJMRmMkIzKpbguw6VLsEObVKkMsIzGME5lUvRX61UhRUpSqlKGQEFjECi34qYwCWQVyJfiiD5PtySL8rh+xb+qYc8q/LofiKvgSUXwCqz1NhmJLy/8JbH5CS8m9TiRH4YzmViRiAIvxcIkLlYhGqxMUJVWNiVIuKUT1CYTEDUIKaQQlqUe0A+SWJAKzrlaKeh9xS1KcGLikaMgIbOmQMQBka22RoYpWhqUUgRzOzHM1NcrQwkkHOAJSjlU6B1gKtAm00CgagAu0SAahkACoZgEp0pE4yYgR2lqjQRaxCVxEVqdCNujMCexRQvpoBqEavXDV651C2Bn2ob5YG/TIpQ5MIwAFpWgx8Q6+1GESDX2kxhBE45IWOAajDsGc6DH9KT3QYwQgc+ViPUY/ooZ4BqMeY+3qMvWdgABowjsbfodsGTGAETmQETrpB140MQCOmXDViKiNwKiNw2mUTpl8yYcZFumBiAJox61zS7LNmzDljxtzTxAicd9KC+ScsWHCcjlmwkBYxAhcdsWLxYSuWHLJi6UFrRQDasHyfDSv2Jq3cY8MqRuAqRuDqnXas2WHH2u20zc4AdGD9Fgc2CDY7sHGTA5s2EiNw83ontqxzYutaWuNkADqxnRG4fZULO1a6sHOFC7uWuyoC0I09S2ixmwHoxr6FbuxnBO5nBB6Y78HBeTTXwwD04PBsL47MopleBqAXx6YnHWcEnpjqw8kpNNmHU5N8OD2RGIFnxvtxdpwf58bSGH8iAC8IRgVwcWQAl0YEcHk4MQKvMAKvDqHBQQZgENcHBnFjQIgBGMLNfiHcEvQN4XafEO4wAu/0CuNuzzDu9QjjfnfqFmYARvCwC3WOMAAjeNwxUhGAUTxtF8UzQdsonreJ4gUj8AUj8GXLGF61oOYxvG4WwxtGYBojMK1xHOmN4shoSA3iDMBiZNWjusUMwGLk1C5Gbi2qWcIALEF+dapWwgAsQWEVqlzKACyF6KdSiAU/lkLCCJQyAqXflUFG8m/pm7JEACpJ9SV9UQ715+XQfEafAtqPAd3HqShMSfl/8NYHpKT8W/1YXoSfyorwc2lSZUZgFUZg1bgI1WIUFTEARajBCKzJCKwZEjMAxQxAMer4xajrkyTU80pQ3yNBAze5JAxAKRo5pGhMTexkk6IpI7AZI7C5mUwyBqAMLakVI7AVI7C1To42WjnaauRopxYo0F6lQAelAh0VJFckArCzVIkukqSuYiW6iZTonghAFQNQhZ75KvQS5KnQmxHYhxHYN5uy1AxANfpnqDGAETggXYOBaRoMeqPB4Nf0SsMA1GLoCy2GCZ5rMfyZFiMYgSMZgSMf6xiAOox+qMMYASNwLCNw3D26q2cA6jHhth4TbxkYgAZMosk3DJhyna4ZGIBGTLtixPTLdMmIGTTzIjECZ503YfY5E+acpTOmRADOO2XGfMFJMxacMGPhcXNFAFqw+IgFSw7TIQuW0jJG4PIDtN+KFfusWLmX9lgZgDas3mXDmp1Ja3fYsI4RuJ4RuH6rnQFox8bNtMmeCMDNGxzYIljvwNZ1Dmxb68D2NUIAOrFjlRM7V9IKJwPQid2MwD3LaKkLe5e4sG8xLXIxAN04sMCNg/NpnhuH5rpxmBF4mBF4ZLYHR2d5cGwmzfDgOAPwxDSa6mUAenFqshenJ3kTAXiGzk6g8T6cG+fD+bHECLww2o+Lo/y4NJJG+BmAflwZFki4OjSAa0MCuD6YBgVwgxF4cwD1DzIAg7jdN4g7iQAM4W6vEO71pB4hBmAIDxiBDxiBD7uG8ahLGI87U6cwnjACn3ag9hEGYATP21KbCAMwipetonjVklpE8bp5FG+aUdMYAzCG9MbUKMYAjCGTEZjFCMyqH0d2vThy6lKdOHIZgXmMwLyaxcivUYyC6sUorEaMwCJGoKgy/VzCACyB5EeqVMoALIXse/qulAFYCsU3pVB+XcYALGMAlkH9BX1exgAsg/bTcmg/KWcAlkP/UTkMH9IHgPF9wPReKgpTUv6btz4gJeXf6icU4qfyQvxcVojKpYWoUlKEqsUUL0I1qh4rQo0oMQJrhkWoFRKhdlCEOgJGYF1GYD2fGPW95BEzAMVoyAhsxAhs5JQwACUMQAma2iRoZpUmNLdI0cIsRUsTGaUMQBla62VoQ211pJWhHSOwPSOwg4qUcgagHJ2oMyOws0yBLlIFukoU6CYmkYIBqEQP6llIBUoGoBK985Tok6tiAKrQl/plq9A/izKFAFRjYLoag9LojRqDaQgjcCgjcOhLDQNQg+HPNRjxjJ5qMZJGPdFi9GN6pGUAajH2gY4BqGMA6jD+rg4TBIzAiYzASbf0mHyTbugZgHpMZQBOE1w1YPoVA2ZcNmDmJUMiAGddMGL2eTpnxByae9aIeYzAeadNDEATFpw0YeEJOm7ComNmLBYcNWPJETOWHjZjWSIALQxAC1bst2DlvqRVjMDVjMDVu61Ys8uKtTutWLeDttsYgDZs2GrDRsEWGzZttmEzI3DzRjsD0I6t6+3Yto7W2hmADuwQrHZg5yoHdq10YPcKIQCdDEAn9i6lJU4GoBP7GYAHBAtdOLjAhUPzaZ6LAejGkTluHJ1Ns9wMQDeOzxB4cGK6ByeneXBqKk3x4PRkD84wAs9M9DIAvTg33ovz47yJALwwxoeLgtE+XBrlw+WRxAi8wgi8OsyPa0NpiJ8B6MeNRAAGGIAB3OofwG1BvwDuMALv9qHeQdzrFcT9nkE86EGMwIfdQnjUlbqEGIAhPEkEYJgBGMaz9mE8b5f0ghH4khH4snUEr1pF8LoltYjgDSMwjRGY3pSaRJHROIrMRsQIzGoQQ3Z9qhdjAMaQWyeGvNpxBmAc+TXjKKhB1eMMwDiKGIFFVYohIvHP9FMxJIxAKSNQVol+KIH8+xIoviNGoJIRqPqaviqF+stSaL4ohZYRqGUE6j4tg/7jJMOHZTAyAo3vl8NE5vfon+WwvFsO6zuA9R+A7e+pMEz5P9JbH5CS8m/3c3kBKpcVoIqAEVi1pBDVigtRPU6xwkQA1qRakSLUDlOoiAFYhLoBEer5ySdCfWrgFaGhhxiBjVxiNHaK0cQhRlOBXYxmjMDmVglaWMgsYQBK0IoR2JoR2NogZQBKGYBStNOSRsYAlKEDdVTJ0ElJChkDUI4uMjm6SpO6SeToLpajByOwR5GCAahArwIFeucLGICMwL65SvTLoWwlA1CJAZkqDMxIGpSuwuA0FYa8oddqBqAaw16qMfxF0ojnaoxkBI56Sk80DEANxjzSYKwQgDTugRbj79M9LQNQi4l3dJh0m27pMJmm3NRh6g1iBE67psf0q3rMuEKX9QxAPWYxAmddNGD2BQPmnDdg7jlDRQAaMf+0EQtOJS08acQiRuAiRuDiYyYsOWrC0iN02MQANGM5rThIB8xYud+MVftor4UBaMGa3Ras3ZW0bqcF6xmBG7bTNisD0IpNW6wVAWjDlo02bBVssGHbehu2MwK3MwJ3rLFj52o7dq2ilXYGoAN7liftXebAvqUO7F9CjMADi5w4uJAWOBmAThye58SRua6Eo3NcODabZrlwnBF4ghF4cjpNczMA3Tg9xV0RgB6cpXMTaYIH58d7cIEReGGslwHoxaXRXlweRSO9uDLCh6vDaZgP1+j6UB9uDCFG4M1BftwaSAP8DEA/7iQCMMAADOBe7wDu96KeATxgBD7snvSoWxCPu1KXIJ4wAp92CuFZR+oQwvP2IbxoR23DDMAwXrWmVmEGYBhvWoSR1jzCAIwgnTKaUpMIMhmBWYzArIZRZDeIIqd+FLn1iBGYxwjMr021YiioGUNhDaouBGAcoqpxiKtQ5TgkP8chZQRKfyxmABZD/gN9X8wALIby2xKovqGvS6D+qgSaL+mLEgZgKXSf0ael0H9SCsPH9JEQgGUwfVAG8/v0Xhks/yqDlRFoZQTa3imH/R/093I4/lYO51+Q4PpTKgpT/rf31gekpPzb/Yx8VC7PTwRg1dICVCuh4gJUpxrxAtRkBNaMFjIACxmAhagTKkRdASOwXqAI9f1FaOAjb1EiABtRY7cITVzkFDEARWjGAGxuI6sYLailRYxWZmIEtjZK0MYgQVu9BO0EOgnaMwI7aKToqCaVlAEoRWdGYBdGYBe5DF1lMnSTytBdIqsIQDl6Uq8iKpSjd4EcfRiBffMoV8EAVKA/DWAEDmAEDsxUYlCGEoPTKU2ZCMChNOw1vVJh+EsVRrxQYWQiANUMQDVG05gn9FiNsYzAcQ/pgYYBqMGEexpMFDACJ93RYvJtLabcopvaRABOu67D9GtJM67qMPMKXRYCUI/ZF/WYc4HO6xmAesxjBM4/S2cMWHDagIWn6KSBAWjE4uNGLBEcM2LpUSOWHTFiOSNw+SETA9CElQdovykRgKtpzV7aY8ba3Was22XG+kQAWhiAFmzclrRpqwWbGYFbNtMmKwPQim0brNi+ntbZsGOtDTvXJO1abcNuRuAeRuCeFXbsXW7HvmW01J4IwAOLHTgoWOTAoYUOHF5AjMAjjMCjc504NodmO3F8lhMnZroYgC6cpFPTXTg9jaa6cIYReHYyTXIzAN04P8FdEYAeXBzrwSXBGA8uj/bgCiPwCiPw6ggvrg334vowGupNBODNwTTIxwD04fYAH+4IGIF3+/lxry/18eN+bz8e9CJG4MMeATzqHsDjbtQ1gCddAnjaOcgADDIAg3jeIekFI/AlI/BVW2oTwuvWIbxpRYzANEZgenNqFmYAhpHZJIysxhEGYATZDSPIaUD1IwzACPLqRhmAUQZgFAW1oiisSTWiKKoeg6hakrhKDBJBZSEA45AJfoxDXikOxQ9xKBmBSkag6ttiqL+hr4uh+aoYWkaglhGo+7wE+s9KYPiUPimBkRFo+jDJ/H4pLIL3SmFlBNr+Se+Wwf5OGRx/p7+VwfnXcrj+Ug73n+lP5fD8sRzePwDe3wO+36WiMOV/K299QErKW1GlPA9Vy/ITqpXmo3pJPmoU51cEYAFqRQtQm+pEKFyQCMB6wULUD5C/EA2ooa8QjRiBjTxFDMAiBmARmjqL0EzACGxuF6GFTYSWVrKIEgHY2iRGG2prJIOYAShGewZgBy1pJOhIndQSdFYRI7CLQoqucim6yUgqRXfqwQjsKSaRjAEoQ+9CGfoIAUh98+XolydH/1zKkTMAFRiYpcCgzKTBGQoMSVdgKCNw6BslA1CJ4a+UGPEyaSQjcNRzFUY/o6cqBqAKYxMBqMY4Gv9QjQkP6L46EYCT7mow+Q7d1jAANZhK0xiB025oMf26FjOuaTHzKl3RYtZlHWYLLukw56IOcy/oMO+8EIB6BqAeC87osfB00iJG4GJG4OITBgagAUuPGbDsqKEiAI1YQSsP0UEjVh0wYjUjcPU+EwPQhLV7TFi3m3aZsJ4RuGGnGRt30HYzNm0zY3MiAC0MQAu2brJg28ak7YzAHYzAHeus2LnWil1rrNi9mlbZGIA27F2RtG+5DfuX2XCAEXhgiZ0BaMehRbTQzgC048h8B47OSzo214Hjc4gReIIReHKmE6dm0HQnA9CJM4kAdDEAXThH5yfRRBcuMAIvjqdxbgagG5fH0Gg3A9CDqyM9uDaChntwnW4MI0bgzSFe3Brsxe1BNNCbCMC7/amfjwHow/0+Pjzo7UsE4MOefjwS9PDjcXc/nnQjRuBTRuCzzgE870QdA3jRIYCX7YMMwCADMIjXbah1kAEYRFrLENJbJGU0CyFTwAjMYgRmN6ZGYeQ0DCO3QRh5jMA8RmB+3QgK6lDtCAprRVDECCxiBIqqRyGuRlWjDMAopJVjkP1MP8Ug/zEGRSX6IcYAjEP1HX0bZwDGofk6Du1X9GUxdF8UQ/85fVbMACyGMRGAJTB9VALzh/RBCQOwBNZEAJYyAEthf7cUjnfoH6VwMgJdjEDXX8vg/ksZPH+mP5bBywj0/YF+Vw7/b8sRoOBv6NdAiMK/SoVhyv8vvfUBKSlvRRUwABmB1cryUL2USvIYgHmoyQisFc9H7RhF8xmA+agbzke9UEFC/WABGgQK0NBPvgIGYCEaewrRhJq6yVWYCMDmjiK0sJOtCC2plbUIrRmBrc0iBqCIAShCOwPpRWjPCOygE6OjVoxOGlKLGYBidFFK0FWgkKCbXILuMgl6JAJQygCUopdIit6CIin6MAL7FsjQL5/yZAxAGQbQQEbgwGw5BmXJMThTjiEZlC5nACowjIa/odcKjHilwEgG4KgX9FzJAFRiDI19SozAcY9VGP+IHqoYgCpMvK/CpHvqhMl31ZhyR42pt+mWmgGowfQbGsy4njTzmgazGIGzGIGzL2sx55IWcy/SBS0DUIf5tOAcndVh4RkdFp2mU3oGoB5LTuix9HjSsmN6LGcErjhChw0MQANWHTRUBKARa2jtPtprxLo9RqxnBG5gBG7YaWIAmrBpO20zYTMjcMtWM7Zuoc1mbNtkxvaNtMHCALRg5zoLdq1N2r3Ggj2MwD2rrNi70op9K6zYv9xaEYA2HFxCi204RIcX2XCEEXiEEXh0vh3H5tFcOwPQjhOzHTg5i2Y6cIpOz6DpDpxhBJ6d6sS5KTTZyQB04sJEmuBiALpwaZwLl8cmXWEEXmUEXh3lxrWRblwf4caN4e5EAN4c6sGtITTYwwD04M5AgRd3B3hxr78X9/tRXy8e9PHiISPwYS8fA9CHxz2ou48B6MPTrn4860Kd/QxAP150FDAAGYGv2lO7AF63DeBNmwDSGIFpjMD0lkFktKDmQQZgEFlNQwzAEAMwhJxGIeQ2pAYhBmAY+fWobpgBGEZhbaoVZgBGIKoRgbh6kqRaBFJGoJQRKKschfxn+ikKxY9RKBmBKkag6vsY1N/FoPmWvolBywjUMQJ1X8ah/yIOw+f0WRxGRqDpk2KYP6YPi2Eh6wfECLS9VwL7v+ifJXC8WwLnO/T3UgZgKdx/pb+UMgBL4f1TGXyMQN8fyuD/fRkCv6PfliHICAwxAkO/LmcAliMi+GU5or8EYoJfpKIw5T/eWx+QkvLWVCvPZQDmojrVKM1FzRJiBNaK5zEA81Anmoe6AkZgPUZg/VA+GgQpkM8AzEcjRmBjRmATL3kKGIAFaOYqQHNnYUILRyFa2gvRykbWQgZgEdqYi9CW2pnIWIT2jMAOjMCOOtKKGIAidKYujMAujMCuSjG6KcToLieZGD0YgT2lEvSSkFjCAJSgT5EEfQulDEAp+lH/fCkG5EkrAlCGQdkyDM6iTBmG0FBG4DBG4LA0OQNQjhGv5Rj5il4qMIpGv1BgzHN6pkgE4Lgn9FjJAFRiAk18SIzASYzAyfdUmHKX7qgYgCpMYwROZwROv6nGjBtqzLxO19QMQA1mX9FgzuWkuZc0mHdRg/mMwPnntQxALRaepTPaRAAupiWn6KQOS0/osOy4DssTAahnAOqx8nDSqkN6rGYErjlA+w0MQAPW7TVg/R7abcQG2riLdhqxaYcRm7cbsYURuGWriQFowrbNJmzfJDBjByNw5wZab8audWbsXmvGnkQAWrB3lQX7VibtX2HBAUbgwWW01IpDS6w4vJgWWRmANhxdYMOx+TTPhuN0ghF4ghF4crYdp2bZcXomzbDjDAPw7DSa6mAAOnBeMNmBC4zAi4zASxNovBOXxzlxZSyNcTEAXbg2yoXrI2mECzfoJiPw5jA3bg114/YQN+4MJkbgXUbgvQHU38MA9OBBX09FAHrxqJcXjwU9vXjSw4unjMCnjMBnXX143oU6+/Cikw8vGYGvOlB7P1638+NNW2rjZwAGkN6KWgYYgAFkUlZzYgRmNw0ipwk1DiK3URB5jMA8RmB+/RAK6oVQWJfqhFDECBQxAkU1wxDXCENSnaqFGYARyKpQ5QgDMALFTxEof6RKUQZgFOrv6bsoAzAK7Tf0dYwBGIP+yxgMX9DnMRgZgKZP6ZM4AzAOy0f0YTwRgLb36b1iBmAxHP+kd4sTAej6Rwncf6e/lcDz1xJ4/0KMQN8fS+EX/KGUAVjK+BOUMQDLEP51GSKCX5Ux/soYf+UJcSr+RVIJY7D0v5Le9uelpPw3b31ASspbUw05qF6egxplVJqTCMBaVLs4F3XiFMtlAOaiXiQP9cNJDUJ5aBjMQ6MAMQIb+/IZgPlo6slHMwEjsDkjsIWzAC0dZC9gABagNSOwDSOwrYXMhQzAQrQ3FqKDoSiho74InXRF6KwlTREDUISuKhG6KZO6K0TowQjsyQjsKRUzAMXoLRajj4AR2JcR2K9Qgv4FlC9hAEowMFeKQYIcKQZnSzEkS4qhmZQhYwDKMDxNhhGCNzKMZASOYgSOfkkv5AxAOcY+Eygw7qkC458oMOExPVIwABWY9ECJyfeTptxTYupdJabdIUbg9FsqzLipwswbdF2FWYzA2YzA2VfVmHNFjbmX1Zh3SV0RgBosoIXn6ZwGi85qsJgRuPi0lgGoxdKTWiw7kbScEbjimA4rj9IRHVYd1mF1IgD1DEA91tK6/bRPj/WMwA2MwI27aZcBm3YasHmHIRmAtHWbEdu20hYjtm82YgcjcMdGEwPQhF3rTdi9jtaasIcRuHcNrTZj3yoz9q8040AiAC0MQAsOLaUlFhymI4zAo4zAowutOLbAiuPzaZ6VAWjDyTk2nJpNs2w4TWdmEiPw7HQ7zk2z4/xUmmLHhcl2XJzkYAA6GIAOXB6fdIUReJUReG0MjXbi+ignbox0VgSgC7eGuXB7KA1xMQBduDvIzQB04x7dH+DGg/7Uz42HjMBHfai3hwHowZOe1MPDAPTiWTcvnnelLl686OzFy85CAPrwil53oPY+vGnnQxojMJ0RmN7aj4xWfmS2pBb+RABmN6OmAQZgALmNA8hrRA2DyG8QREF9qhdkAAZRJKgdYgCGIK6ZJKkRgpQRKGMEyqqGIa8ShqIy/RyGkhGoYgSqKkWg/iECzfcRaL8jRqCOEaj/mr6KwvBlFMYviBFo+iwG86f0SQyWj2OwfkSMQNsHcdjfj8PxHv0rDuc/43AxAl3vFDMAi+H5W5IQgL4/059KGIAlCPyhBMHfEyMwxAgMC35TygAsRfRXAiEAyxh/ScW/KGP8CcoZf+Uoo/IKoLf9fyn/x3vrA1JS3qrq5dmoQTXLslGLEVi7hIpzGIA5qBvLQT1GYD1GYP1ILhqEc9EwRMHcRAA2pib+PDT1kTePAZiH5u58tHCRMx8tqZUjH63txAhsYy1gABagnTmpvakAHRiBHQ2F6KQnXSEDsBBdGIFdGYFd1UXopipCd2UReihILmIAitCLektJImIAitBXJEa/IioUMwDFGEAD84kROChXgsE5EgzJpiwJhjIChzECh2dQupQBKMXIN1KMei1jAMowmsa8lGHsC3ouwzhG4Pin9ETOAJRjIk16RIzAyQ8UmHJfgan36K4iEYDTbysxQ3BLiZk3lZh1gxiBs6+pMOeqCnOvJM27rMJ8RuCCi3RBzQBUY9E5OqtmAGqwhJaeplMaLDupwXIG4IrjdEzLANRi1ZGk1YzANYd0WHuQDugYgDqs36fDhr16BqAeG2nTbtqlx+ademxhBG7dTtsMDEADtm8xVASgETtp10baYMTu9UbsWScEoIkBaMK+1SbsX0UrTTjACDy4gpabcWiZGYeXmnFkCS22MAAtOLaQFlhwnE7Mt+AkI/DkXCtOzbHi9GyaZU0E4NkZNpybTtNsDEAbLggYgRcZgZcm2XF5Ik2w48p4O66OczAAHQxAB66PduDGKBrpwE1G4K0RNNyJ28OcuDOUhjhxlxF4b5AL9wfSABcD0IWHiQB0MwDdeNw76UkvN54yAp8xAp919+B5Nw9edKUuHgagF686UUcvA9CLN+29SGtHbX0MQB8yWlMrHwPQhywBIzC7uR85zfzIbUpN/MhjBOYzAvMbBlDQIIDC+lQvkAhAUZ0gxLWpVhCSmkFIa1D1EAMwBHlVqhJiAIag/DkE1U9hBmAY6kphaH6g78MMwDB030YYgBEGYASGr+jLSCIATZ9HYf6MPo3C8kkU1o+jiQC0fRiD/QN6P8YAjMH5r1hFAMbhfof+EYfn73F4/xaH76/F8P2lGP4/FyPwx6TgH4oRYgSGflvCACxB5DdJ0V+XIMYIjP2ylPFXimIqETAAS6lM8F9ljL8yxl/ZW/+9lJT/+g8YkJLyVtVAFmqWZ1UEYDYDMBt1qG4xxbMZgDmoH81BgwiFc9CQGoVy0JgR2CRA/lwGYC6aeXPRXMAIbOHOQ0tXHlo5yZGXCMA21NaWj3ZWsuSjvTkfHRiAHY1kKEAn6qwvQBcdMQK7agrRTV2I7qqkHspC9GQE9pKTrIgBWIQ+kiL0FQKQ+olE6F8kwoBCKhAlAnBQnhiDc5OG5IgxNFuMYYzAYZkSBqAEI9IlGClIk2AUI3D0aynGvKKXUgagFOMSASjDeJrwVIaJT+ixLBGAkx/KMeUB3ZdjKk27J8d0RuD0OwoGoAIzb9FNRSIAZ9Oc63RNiblXlZh3RYn5iQBUMQBVWHghadF5FRYzApcwApecUTMA1Vh2So3lJ+mEBito5XE6psGqoxqsPqLBmsNaBqCWAajFugNarBcwAjcwAjfupT06BqAOm3fpsCURgHoGoB7baPs22qrHDkbgzs20ycAANGD3BgP2rKd1RuylfWtpjRH7VxtxYJURBxmBB1eYcGi5CYeX0VITjjACjzICjy2mRWYcX2jGiQXmigC04NRcC07PodkWnKGzjMCzM604N8OK89NpmpUBaMXFKTZcmkyTbAxAG65MsCUDkK6Ns+P6WBpjx43RdtwcJQSggwHowO3hDtwZRkMduMsAvDeYBjlxnx4MpAFOPGQEPurnwuO+1MeFJ71deNqLeroZgG48707d3AxAN14yAF8JOnvwupMHbzpSBw/SGIHpjMD0tl5ktPEis7UXWa28iQDMbuFDTnNq5mMA+pDXhBr7GYB+FDT0o7AB1fejiER1AwniOgFIalOtAKQ1A5AxAmXVg5BXC0JRNQhlFWIEqhiB6p/oxxA0lULQ/kCMQB0jUP9tGIZv6OswjF+FYWIEmr6IwPx5BJbP6NMIrJ9EYGME2j6Kwv5hFI4P6P0onO9F4WIEuv9J78bgeScG799jyQAk/1+SAn+KI/jHeEUAFiP8u2JEfpsU/U0xYokALEGcin+ZVEKlvyhNKKNywX+VvvXPS0mp8NYHpKS8dTXLM1GLEVi7LAt1SqkkiwGYhXrxLNSPZSc0iGajYSQbjcLZFQGYwwDMQVNq5idfTiIAW3hy0dJNrly0otbOXLRhBLa1ky2PAZiH9pY8dBAwAjua8tHJmI/OBtLnJwKwq7YA3QSaAnRXF6CHqgA9EwFYyAAsRG/qIyNpIfoyAvuJi9BfREVFDMAiDKRBjMBB+SIMzhNhSK4IQ3NEFQEoxnAakUkZYgagGKMYgKPf0GsJA1CCsYKXEoxjBI5/LsWEZ/RUygCUYtJjKSYzAic/kmHKQxmmPpBh2n1ZRQDKMeOOHDMFt+WYdUuO2YzA2TcUDEAF5l5TYN5VuqLAfEbggstKLLxEF5VYdEGJxefpnIoBqMJSWnaGTquwnBG4ghG48gQdV2PVMTVWHxUwABmBaw9rsO4QHdQwADXYsF+Ljftorxab9mixWbBbiy2MwK07ddi2g7brGIA67EgEoJ4BqMcu2r2JNuqxhxG4lxG4d52BAWjA/jUGHFhtSAYgHVpJK4w4vNyII8uMOMoIPLrExAA04fgiWmhiAJpwkhF4aj7NM+P0XDPOzDFXBKAF52ZacH4GTbfgwjQLLgoBSJemWHF5Mk2y4spEK64yAq+Np3E2BqANN8bQaBsD0I5bI+24LRhhx53hdtwdRozAe0McuD/YgQeDaKADDxmAj/pTPycD0IknfZKeMgKfMQKf96QeLrzo7sLLbsQIfNXFjdedqZObAehGWgc30tt7GIAeZLT1ILMNtfYwAD3IZgRmt/Qip4UXuc29yGtGjMB8RmBBY2rkQ2FDH4oa+JIBWM8PcV2q42cA+iGt5YcsEYAByKsHoKhGVQMMwABUlYMMwCADMAjNj0FoK9EPQegYgfrv6NsQDGT8OpQMQDJ/QZ+HGYBhWD8VCAEYgf2jCBwf0gcRON+PwJUIwCgDMArPu/ROFN5/ROFjBPr+FoP/rzEE/hJD8M/0xxhCjMDwH+j3ccZfHFHBb+KIMQLjv6ZfFTP+ihl/xckApLJflDD+kvBfJW/971JSKrz1ASkpb10tZKA2I7B2WSYDMBN1SzJRT8AIrM8IbBDLQsMoRbIYgFlozAhsEspG0yAFshmA2Wjuy0YLb05CS08OWrlz0NqVUxGAuQzAXLQT2HLR3pqbCMCO5jx0MpExD52piyEPXRmBXXX5DMB8dNfko4eaVPnoyQjspSxAbwXJCxiABegrLUA/SSEDsBD9aYCoEAOLCisCsAiD84swJC9paG4RhjECh2dTlogBKMLIDBFGpQvEGJ0mxpg3Yox9Ta/EGPdSjPEvJAxACSbQxGcSTHpKT4QAlGLKIymmPqQHUkyj6YzAGfforowBKMOs23RLxgCUY84NOeYKrssx75oc86/KsYARuOCyggGowKKLSYsZgUsYgUvP0VklA1CJ5aeVWHFKxQBUYSWtOkHHVVh9TIU1jMC1R+iwmgGoxvqDamwQMAI37tdg0z7aq2EAarCFAbh1F+3UMgC12C7YrsUORuDOrTrs2kKbdQxAHfZspA16BqAe+2j/Olqrx4E1ehxkBB5cZWAAGnB4hQFHlhsqAtCIY4IlRhxfbMSJRUacXCgEoIkBaMLpeTTXxAA04exsM84JZplxfqYZF2bQdDMuMgIvTbXg8hSabMGVSRZcnUgTrLhG18dbcWMcjbXiJiPwFiPw1igbA9CGOyNouC0RgPeG2nF/CA224wE9HESMwEcDHHjcn/o58KSvA0/7OPCst5MB6GQAOvGiB3V3MgCdeNXVxQB04TW96exCWidiBKYzAjPaUzs3Mtu6kdWGWgsB6EFOSw9yW1BzDwPQg/ymXgaglwHoRWEjauhlAHohqu+DWFDPB0ldH6R1qLYPMkagvCbV8ENR3Q9lNT9UjEAVI1BdOQDNz/RTANofA9BVEgIwCP33QRi+o2+DMH4ThIkRaP6KvgzB8kUI1s/psxBsjED7J/RxGI6PwnB+SB+E4WIEut+jf0Xg+WcE3ncj8L0jBGAU/r9FERD8JYoghf4kBGCMARhD5Pf0uxgDMIbYb4UAjDMA4yj+VRwlgl/GGX/FKKtQ/otigN7216Wk/DdvfUBKyn+E2ozAOuUZqFtGpRkMwAzUL85Eg3hSw1gmGkUz0TiSiSaMwCahLAZgFpoFstBcwAhswQhs6c1GKw+5sxmA2WjDCGzrzEE7B9lz0N6Wgw7WHHS05CZ0MueisykXXYxkyGUA5qGbLg/dBdo89NDkoScjsBcjsJcynwGYjz7yfPQVMAL7MQL7SwowQEyiAgZgAQYVFmKwoKAQQ/ILMTSvEMNyKaeIAViEETQyizKLMIoROJoROCaN3ogYgCKMEzACxzMCJ7wQY+JzeiZmAIox+YkEUx4nTX0kwbSHEkx/QPelDEApZt6lO1LMotmMwDmMwDk3ZQxAGeZdl2H+NVkyAGnhFbosx6JLciy+KMeSCwoGoIIBqMCyswosFzACVzACV56ik0oGoBKrjyuxJhGAKqyldUdUWH+YDqkSAbjxAO1XMwDV2LxXjS17BBps3a3Btl0abN9JOzTYsV2Dndu0DEAtA1CL3bRnMzEC9zIC922g9ToGoA4H1upwMBGAehyiw6topR5HVuhxlBF4bBktNeD4EgNOLKZFBgagEafo9AKab8SZeUacnUuMwHOzTTg/i2aaGIAmXGQAXpqWdHmqGVem0GQzrjICrzECr0+g8RYGoAU3x9IYKwPQitujrLgjGGnF3RFW3GME3htmw/2hNjwYQoNtiQB8NNCOxwOovx1P+tnxVMAIfMYIfN6bejnwoqcDL3s48IoR+IoR+LqrE2+6UGcnA9CJ9I4uBqCLAehCZjsXstpSGxeyW7uRI2jlRm5LN/JaECMwnxFY0NSDwibU2IOiRh6IGIEiRqC4vheSelTXywD0QpYIQB8D0AdFDR+U1amajwHoh7oKVfYzAP3Q/pSkYwTqKwVg+IG+C8D4bQAmwddBBmAQFsGXQVi/CMLGCLQxAu2fhuD4mD4KMQBDcDEA3e8nef4Vhvef9G6YARiB/x/09wgDMILgX+kvEYT+HEX4j1FEBH+IIvr7KGK/I0ZgnIp/Q7+OMQBjjL94QhmVC34Rf+sfl5LyP3nrA1JS/iPUQToDMJ0BmI56pemoL2AENijOQMN4BhrFKJqRDEBqGs5EsxAFMxmAmWjhz0JLX1IrbxZae7LQxp2FtozAts5sBmA22tuz0UHACOzICOxkyUFnM5lyGIA56MoI7MYI7KbPZQDmooc2Fz01pM5DL+qtykMfJSnyGIB56CfLR38pSfIxgAaK8zGIETiIETi4sABDCgowNJ/yCjCMETicETgih7ILGYCFGJVZiNEZRQzAIoyhsWn0pogBWITxr0SY8JJeiBiAIkyiyYzAyYzAKU/EmPpYjGmP6KE4EYAzaOZ9uifBrLsSzL5Dt6UMQCnm3pRinuCGFPOvS7GAEbjwKl2RYdFlGRZfkiUDkJZekGPZeTonZwDKseKMAitP0ykFVp1UYLXghAJrGIFrjymx7igdUTIAldhwSImNB1UJmw6osHk/7VNhCyNwKyNw227apWYAqrFDwAjcyQjctU2D3Vtpi4YBqMHeTVoGoJYBqMV+OrCe1mlxcK0Oh9bQah0DUIcjK3U4mghAPQNQj+OCpXqcWKLHSUbgKUbgqYUGBqABZ+bTPEMiAM/NMeK8YLYRF2YZcXEmMQIvTTfh8jSaamIAmnB1sgnXJpkZgGYGoBk3BOPNuMkIvMUIvD2GRlsYgBbcHWmpCEAr7g+z4sFQGmLFQ3rECHw0yIbHA214MoD62xiANjzra8fzPtTbjhe97HjZk3rYGYAOvO5GXR14Q2ldHEhnBKYzAjM6OpHZgdo7kdXOiWxGYDYjMKe1C7mtXMhrSS1cyG/uRkEzaupmALpR1JgauRmAHogbJEnqeyCt54GsLjEC5bW9UNSiml4oa3ihYgSqGIHqqj5oqvigrUw/+6BjAOp/pEp+BqAfxu/pO38iAM3f0NcBBmAA1i/piwADMAj7Z0E4PqVPgnB+HITrI2IEuj8IwfM+vReC918h+BiBPkag/50wAn8PIyj4WxghBmBY8KcIAzCCqOD3kUQAxn+bVPybKEp+Tb+KopQRWPbLGOMvCfS2Py4l5X/y1gekpPzHqIs01CunsrREADYoSUfDYoqnoxE1jqWjCSOwaYTCGQzADDQPZqCFgBHY0p+JVr5MtPaSJzMZgNTORc4stHdkMQCz0NGWjU5WsmSjM3UxZ6OriRiB3Qw56K7PQQ9dUk9GYC9GYG81qXIZgLnoq8hFPyEAqb8sDwOkeRgoIXEeAzAfg4vyMURQmI+hBfkYlp+P4YzA4bkFDMACjMwuwChBVgFGMwLHZBRibDqlFWLcm0KMFwKQJrwqwsSXRZj0gp4XMQBFmPJUhKlPkqY9FmH6IxFmMAJnPBAzAMWYdY/uijGb5jAC596mWxIGoATzb0iwIBGAUgagFIsEV6RYfFmKJYzApRfpgowBKMPyczKsEDACV56RY9VpOiVnAMqx5oQca48rGIAKrKP1RxXYcIQYgRsZgZsO0gElA1CJLfuU2LpXlbBtjwrbd9MuFQNQhZ071Ni1nbapGYBq7NmStJcRuG+TBvs30gYNA1CDg4kA1DIAtTi8WosjglVaHGUEHltBy3UMQB1OLNXh5BJarGcA6nF6YdKZBXqcna/HOUbgubkGBqABF2bTLEMiAC/NMOLy9KQr04y4OpUYgdcYgdcnmXBjIk0w4eZ4E26NMzMAzQxAM+6MTro7yox7jMD7I2i4BQ+GWfBwKA2xMACteDyIBloZgFY87W/FMyEA6XlfG170od42vOxlwytG4CtG4OvudrzpZkdaV+piZwA6kNGJOjoYgA5ktad2DmQzAnPaOpHbhlo7kdfKifyWxAgsaO5CYTNq6kJRExdEjEAxI1Dc0A1JAzek9ameOxGA8jpU28MA9EBZ0wNVDaruhbqaF5qqVMXLAPRC9zP95IOeDD9SJR+MP/hg+s4HMyPQ/K0flm/8sH6VZGME2hmB9s8DcHwWgPNT+jgAFyPQ/SF9EGQABuEl37/onyH43w0h8A79I8QADCH0N/prmAEYRuTP9KcwAzCM2B+IERj/XQTFv42gRPCbCEoZgWWMwLJfRhl/UcZf9K1/W0rK/4W3PiAl5T9KvfI3qF/2Bg1K0xIalqShUXEaGsfT0CQRgOkMwHQ0o+ZhCqUnArBlIAOt/OTLQGtq481AW0ZgOze5MtHemYkOjkx0FDACO9my0NmahS4WMmclArCbMRvdBYZs9NBno6cuG720OQzAHAZgDvpQXxUpc9CPEdhfnosBMpLmMgBzMYgGMwIHi/IYgHkYWpiHYQV5yQCkEXn5GJlLOfkMwHyMZgCOyaSMAoylcemUVoDxjMAJrwsx8RW9LGQAFmIyTWEETnlWhKlPizDtSRGmPy6qCEARZgoeiDDrvgiz74kwJxGAYgagGPNuiTH/ZtICRuDC63RNwgCUYPEVCZZcpktSLKVlF6VYfoHOSxMBuPIsnZExAGVYfUqGNQJG4FpG4Lrjcqw/RkflDEA5Nh5WMAAV2ESbDyqw5QAxArcyArftVWL7HtqtxI5dSuwUApB27VBh93YV9myjrSrsZQDu20yb1AxANQ5sUOOggBF4aJ0Gh9fSGg0DUIOjqzQ4tlLLANTi+HItTgiWaXGSEXiKEXh6MS3S4cxCHc4u0FUEoB7n5yZdmKPHxdl6XGIEXpppwOUZBlyZTtMMDEADrk0x4vpkmmRkABpxUzDBiFuMwNvjTLgzlsaYcHe0CfcSAWhmAJrxYDgNM+MhPWIEPmYEPh5swZNBFjwdSAMseMYIfN6P+loZgFa87G3Fq17U04bXPWx40z0prZsN6YzAdEZgRmc7MjvZkdWROtiRzQjMYQTmtHUwAB3Ia02tHIkALGjhRGFzauZEUVMnRE2osYsB6IKkYZK0gQuy+sQIlNd1Q1HHDWVtquWGihGoZgSqq3ugqeaBtipV8UDHCNQzAg0/0Y9eGCt5YfqBvhcC0AfLt/SND9avfbB9RV/6GYB+OD6nz/wMQD9cn/jhZgS6PwrA82EA3g/o/QB87wXgZwT6/xlE4N0ggu/Q34MIMQLDjMDIX5Kifwoh9kdBGPHfh1H8O/ptmAEYRulv6NcRlFH5r+iXkbf+aSkp/zfe+oCUlP8o9fEa9RmBDRiBDUvfoFEJFb9hAL5BE0Zg01gamkUpksYATEOLUBpaBtMTWgXS0dqfjja+dLT1kieDAZiB9tTBRf+D3XoKljVBtH0fcc/du3fvdldVl23btVDLtm3btm3b9rTStu3MaS9rnPFlztdzz1bE7LqRD7/38TTiX65OBmCnUg06l1CxBl2oa0KDbozAbjEtA1CLHhEteoZTejECewd16BMgv44BqEM/BmB/T8oAtx4DXXoMcuobAtCAITYDhlpThlkMGM4IHGEio5EBaMQovRGjBYzAMVoTxmpIbWIAmjCeAThBkTJRbsYkmRmTpeaGALRgqsiCaUUp0wstmMEInJlPeVbMyrVidg5lWxmANsyleZmUYcP8WzYsYAAuvEHX7Vh0zY7Fgqt2LGEELmUELrtEFx0MQAdWnHdg5Tln0qqzTqw+Q6edDEAn1p50Yd0JOu5iALqwgTYyAjcyAjcddmPzITroZgC6sXW/B9v2pWzf68GOPbTbg52MwF07vdi9g7Z7GYBe7N0q8GHfFh/2b/bhwCba6EsG4KH1tM7PAPTjyBo/jgoYgccYgcdX0ooAAzCAk8sCOLU0yAAMMgCDOLMo5ezCIM4xAs/Pp3khXJgbwsU5oYYADOPyTJoRxhW6Oj2Ma4zAa4zA61MiuDGZJkUYgBHcYgBmjKdxUQZgFFljUrIZgTmjYsgdSSNiyBseQ/4wGhpnAMZROJgGxRmAcYgYgOL+KZJ+CUj7Up8EZIxAOSNQ3rMYih7FUHYvhqobdS2BuksJNJ2pUwkDsAS6DtS+lAFYCgMZ21KbUphal8LMCDS3LIOlRRmsv1LzMtgYgXZGoL1JORy/lMP5czlcP5UnA9D9QwU839N3FQzACvi+oa8rGYCVCHxZieAXKaHPKhFmBIY/qWIAViEq+KgKsQ+rEGcExt+vRuK9ahS/S+9Uo4QRWMoILHuT3qhB+es1qHiNXhUCsBZVghdrUU01zwsYgIzAumfrUP8M/b0Ot/9WhzuMwDt/qcfdP9fj3p/oj/W4/4d6PGAEPvj9bTz8t9t49Dv619t4zAh8wgh8+v/S/7oD/D93Gv3T0tL+Dxp9QFraP52fnsrx85OUXx7L0eSRHE0fytGMEdjsvoIBqMCv1OIuMQJbMgJb1SvRuo5qlQxAJdoyAtsxAttVqRiAKgagCh3LVehUpk7qXKpGlxI1uhZTQs0A1KB7TIMegqgGPSMa9GIA9g5RUMsA1KKvX4t+AkZgf68OAzw6DHSTS8cA1GEwI3CIg+x6DLXpMcyqx/BkABoYgAaMpFFGMhiSAThGZ8RYLWmMGKc2YryAEThBacJEhQmT5CQzMQBNmCIxY6pAbMY0kRnTi8yYUUgFFgagBbPyUmbnWjCHETiXETg3y8oAtGJ+hhULbglsWHjThkU36LqNAWjDkqs2LL1iZwDaGYB2LKcVF+mCHSsZgavO0VkHA9CBNacdWCsEIK076cT6E05sOE7HnAxAFzYdocMuBqALW2jrQWIEbtvvxvZ9tNfNAHRj5243du3yJO3e6cGeHbTdg72MwH2MwP1baLOXAejFwY0CHw5t8OHweh+OrKO1PgagD8dW+xmAfgagHydW+HFyecopRuDppbQkgDOLAzi7KIBzyQAMMgCDuDCP5gZxkS4xAi/PplkhXJkZwtUZND3EAAzj+tQwbkyhyWHcnBTGLQEjMGNCBJnjaVwEWWMjyGYA5oymUVEGYBR5I2h4NBmABYKhMRQOiaFocAyiQcQIFA+IQ9Kf+sUZgHHI+lDvBAMwAUXPBJSC7gmoSM0IVHcthqZLMbSdqVMxdIxAPSPQ0J7alTAAS2BqU9IQgKWwtKQWpQzAUtial8LOCLQ3K4OjaRmcTeiXMrh+LoObEej+sRyeH8rh/b4cvu/o23L4GYGBr+mrCgS/rEDoC/pcCMBKRD6lTyoZgJWIfVSJeDIAq5B4vwrF79G7VSh5pwqlb1czAKsZgNUof4Ner2YAVqPy1RpUvlLDAKxB9Us1qHmRXqhBLSOw7h/0XC3qn63F7WeIEXiHEXj3r/SXOgZgHe4LkgFYj4f06N/od/WMv3o8YQQ++ZfbDMDbADX2l6Wl/X9o9AFpaf90foIMPz+V4ZcnMjR5LEPTR7JUAFLzB3L8ep/uyRmAcrS8o0Cr2ymt6xVoU6dA21oF2jEC21Ur0b5KiQ7UsZIYgZ0YgZ3LVOhSSiUqBqAK3RiB3RmB3eNqBqAaPaNq9IpQWIPe1CekQd8gBTQMQA36+7QY4E0Z6NFikFuLwS4hAHUMQB2G2nUYZksZzggcYdFjpJlMegagHqMNeozRG5LG6gwYpyWNgQFowASVEROVpDBiEk2WGzGFETiFEThVYsI0sQnTRVRkwgxG4ExG4MwCM2blmzE7z4w5uZRjYQBaMI/mZ1GmBQsyLFjICFx408oAtGLxdSuWXBMwABmBy67YsPwyXbIxAG1YmQxAOwPQjtW05iydsWMtI3DdKQfWn6QTDgagAxsFjMBNR53YfMSJLYfpkDMZgNsOuLB9P+1zYQft3EuMwF2MwN273Nizk3a4sXe7G/u2eZL2b/XgwBYPDm4mRuAhRuDhDbTeywD04uhaL44JAUjHV/twYhWt9OHkCh9OMQBPL6OlfpxZ4sfZxSnnGIHnF9KCAC7MD+DivAAuzaU5QQZgEFdm0cwgAzCIa4zA64zA69NCuDE1hJtTaHIoGYAZE8PInEDjw8gaF0b2WEEEOWMiyB1NoyLIGxlB/ogIChiBBcOiKBwaRdEQGhxlAEYhHhhjAMYgIWn/GGT9iBEoZwQqelOvOAMwDlWPeEMAJqDpmoC2C3VOQNcpAX3HYgZgMQxkbE/timFqWwwzI9DSmlqVwNqyBLYW9KsQgKVwNKOmpQzAUrh+KW0IwDJ4fiyD9wf6vowBWAZ/MgDLGYDlCH5FX5YzAMsRZgRGPkuJflqB2McpcUZg4kP6oBLF71ei5D1iBJYyAsvepreqUP5mFSreqEIlI7CSEVj1ajWqX6GXqxmA1ah9UQjAGtRR/T/ouRrcfrYGdxiBd/9Of63Fvb/U4v6f6U+1ePDHOjz8A/17HR79vg6P/41+V8cArMdTwb/UN/qPpaX9XzT6gLS0f0q/PJUyAKVoQk0fS9GMEdj8IT2QMQBlaHFPhpYCRmCrO3K0vi1Hm3o52tbJUwFI7WsU6FBNVQoGoAKdKpToXJ7SpUyJrqVKdCshRmD3hAo94ir0jKX0iqrQmxHYJ0whNQNQjX4BNfozAvszAgf4NBjo1WCQh9waBqAWQ5xaDBU4tBhm12K4TYsRVh0DUMcA1GEUjTYRI3AMI3CsnnR6BqAe4zV6TGAETmAETlQZMElpwGQFyQ0MQCOmSo2YJpAYMV1sxAyRETMZgTMLTZhVYMLs/JQ5jMC5jMB5OZRtZgCasSDTjIXJALRgES2+STcsWHLdgqWMwGVX6YqVAWjFClp5iRiBqy7YsPo8nbMxAG1YywBcdzpl/Sk7Npy0Y+MJezIANx1zYPNROuJgADqwlbYxArcddGL7ASd27Kd9TgagE7v2uLB7N+1yYQ/t3UmMwH2MwP3b3Diwlba4GYBuHNrkYQB6cJiObPDg6Hpa58ExRuDxNbTaywD04uRKL06tEPhwerkPZ5bRUh/OLvHhHAPw/CJa6MeFBX5cnE/z/LjECLzMCLw8J4ArswO4OiuAazOJEXh9ehA3ptHUIAMwiFuTg8hgBGZMCiFzYghZE2h8CNmMwBxGYO4YGh1G3qgw8keGGwIwgkLBsAiKhkYgGhKBmBEoZgRKBkYhHUD9owzAKOR9YwzAGAMwBmWvGFQ9U9SMQE136haHtmscui7ECNQzAg0dEzB2oPYJmNolYE4GYDEDsBjWVtSymAFYDDsj0N68BA5yNiuBqyk1KYGbEej5mX4qhffHUvh+oO9L4WcEBr4tQ/Ab+roMoa/KEP5SCMByRD4vR/Qz+rQcsU/KEU8GYAUDsALFH9D7FQzACpS+W4myd+jtSpS/VYmKN+mNSgZgFapeo1erGIBVqHmZXqpiAFaj7oVq1D9P/6jG7eeqcScZgDUMwBrc+xv9tQb3/1KDB4zAB4zAh3+sxaN/T3n8+1o8YQA+/dcU/Etdo39YWtr/RaMPSEv7p/QLJGjyVIKmTyRo9pgeSRmAUvxKLR7QfWkyAFvdlaH1HbotQxtqWy9DO0Zgu1o5A1DOAJSjY5UcnQSMwM4VCnQpV6BrGZUqkgHYnXoUU0KJnnElesWU6J0MQBUDUIW+1C9EQRUDUI0BfjUG+sirxiAa7FFjCCNwiEvDANRgmEOD4XZNKgBppFWLURYyaxmAWowx6jDWkDJOr8N4HWl1DEA9Jqr1mKQipR6TaQojcCojcKrMwAA0YLrEgBliQyoAaVYRFRoxu8CIOflGzM0zMQBNDEAT5mebsECQZcJCRuCiDLplZgCaseSGGUuvCyxYds2C5VctWHGFLluSAbjqIl2wMgCtWENrzxEjcN0ZG9aftmHDKTppYwDasOm4PWnzMTu2HLVj6xE6bGcAOrD9IB1wMAAd2Em7GIG7GIG79zixZzftcjIAndi3w4X922mbCwfo4Fba4sIhRuDhTW4c2Ugb3AxAN46to7UeHKcTazw4uZpWeXCKEXiaEXh6uZcB6MXZpV6cW0KLfThPFxbRQh8uLvDh0nwfLjMCL8/148ocP67Opll+BqAf1xmBN2bQ9ABuTgvg1lSaIgRgEJmTaGKQARhE9vggcsaFGIAh5FLeGBodQv6oEAoYgQUjwgzAMIqGhSEaSkPCDMAIJINoYARSkg0gRqCcEajoG4WyD/WOQtUrCnUyAGMMwBi03ahrjAEYg75zHIZO1DEOI5k6UPs4zIxAS1tqk4C1dQK2VgnYWxIj0PFrMZzNqVkxA7AY7mQAljAAS+D9qQS+H+mHEvgZgIHv6NtSBmApQl/TV6UMwDJEBF+UIfp5GWKflSH+KTECEx+Xo/gj+rAcJR+Uo/R9YgSWvVuB8nfo7QpUvFWBSkZgJSOw6vVKVL9WiZpX6ZVK1DIC615MqX+hCrefp39U4Q4j8O6z9Ew17v29Gvf/Sn+pZgDW4OGfavDoj/SHGjz+9xo8+T39Wy2e/q4W+NfaRv+vtLT/gEYfkJb2T6vpUzEDUIxmjMDmjMBfH9FDCQNQgpb3JWh1T5rU+q4Ube5I0fa2FO3qqU6G9rUydKCONVQtSwZg50o5ulRQuRxdqVuZHN0Zgd1LFAxABXomFOgVT+nNCOwTVaJvhMJKBqAS/RmAAwIpA/0qDPKpMNiraghANYa61BgmcKox3KHGCEbgSBtZNQxADUabNRgjYASONWoxzkB6LQNQiwkMwImalElqHSardJiiJIWeAajHNJke06UpMyR6zGQEzhQZGIAGzC40YE4B5RswlxE4L8+I+bmUY2QAGrEwGYAmBqAJi2nJLbppwlJG4DJG4PJrdNXMADRj5WWBBasuWbD6ogVrLtB5CwPQgnVnrVh/hk5bsYE2niJG4CZG4ObjNmw5RkdtDEAbtjEAtwsO2bHjoB07D9B+OwPQgd17Hdizh3Y7sJf27SJG4P4dThzY7sTBbbTViUMMwMObaZMLR+joRheObSBG4HFG4Im1tMbNAHTj1Co3Tq/0JJ1Z4cHZ5bTMg3OMwPOMwPOLvQxALy4u9OLSAm9DAPpwRTDXh6tzfLg224frs4QA9DMA/bg5nab5GYB+ZEwJIFMwOYCsSQFkT6QJAeQwAnPH0dggAzCI/NFBFCQDMITCESEUCYaHIBoWgpgRKGYESgaHIR0UhmwgDQhD3j8CRT/qG2EARqDqTb0iUDMCNT2j0Pag7lHoukWh70qMQEPnGIydqGOMARiDmQFoaUdt47C2icPWmlrFkwHoaJHi/DUBV3NqloCbEehpUgzvL/RzMXw/FcP/IzECA9+XIPgdfVuC0DclCDMCI4zAyJeliH5Ritjn9FlpMgATn9DHZQzAMpR8SB+UJQOw7D16t5wBWI6Kt8tR+Ra9WYGqNypQ/Tq9VsEArEDtK/RyJepeqkT9i/RCJQOwEncYgHefo2ercO+ZKtz/O/2tCg8YgQ8ZgQ//XI1Hf6rG4z/Sv1fjCSPwKSPw6e9qGv230tL+gxp9QFraP62mEKHZUxGaMwKbPxYzAMVoQS0f0gMxWjECW9+ToM1dCdreSWnHCGzPCOxQR7VSBqAUnaql6FwlS+pSKUPXChm6lVOZjAEoR48SOXoKiuXolZCjNwOwT4yiCgagAv2of5gYgQOCSgwMKDHITz4lA1CJIYzAoR5yqxiAKgx3qjDCQXY1RtIomxqjrWRRJwNwrImMGgagBuNpgp4YgRO1WkzSaDFZTSotA1CLqYzAaQqS6zBdpsMMqQ4zkwGoxyyRHrMFRXrMKdRjLiNwHiNwXp6BAWjAghwDFgoYgYuyjFicSRlGBqARS28aseyGiQFownJacc2ElVeJEbiKEbj6El00MwDNWEvrGIHrGIHrz1qw4YwFG0/TKQs2nbRi84mULcet2HrMim1HiRG4/bANOw7RQRsD0IZdjMDdjMDd++zYs9eOvXtotz0ZgPt3OnBgB2134CAd2kaMwMNbnDiy2Ymjm2ijkwHoxPH1LgagiwHowkk6tYYYgacZgWdW0go3A9CNc8vcOL/UwwD04AJdXEyLPLi00IPLjMDL870MQC+uzvXi2hya7WUA+nBDMNOHmzN8uDXdhwxGYAYjMHOKH1mTaZKfAehHDgMwd3xK3rgA8sfSmAAKGIGFo2hkkAEYhGh4EOJhNDQEyZAQpINpUIgBGIKcEShnBCr6h6HsF4aqL/UJQ80I1DACNT0jDMAIdN2pWyQZgIYuURg7p5g6RmEWMAIt7WOwtqO2MdjaxGBvTYxAR8s4nC3icP1KzeNwMwA9TalJggGYgO9n+imRDMDAD8UIfp8S+rYY4W/o6xJEKPoVfVmC2BcliH9OjMDEp6Uo/oQ+LkXJR6Uo/bAUZYzAsvfLUP5eGSrepXfKUMkIrGIEVr1Zjuo3ylHzOr1WjlpGYB0jsP5leqkCt1+swJ0XiBF49x+VuPccPVuJ+89U4sHf6a9VDMAqPBL8qYoBWIUnf6jCU0bg099XA/9W3ei/lZb2H9ToA9LS/qklA5B+fSJCi8f0SMQAFKEVA7D1/ZQ298Roe1eMdnfotoQBKGEAStCROtVSjQSdGYFdqqToWkkVUgagFN0ZgT0YgT1KZQxAGXoVy9A7QXE5+lDfmBz9ohSRMwDlGBBSYGAwZVBAgcF+BYb4hABUMgCVGOZWYrgrZQQjcCQjcJSdbCoGoApjLCqMNauTxpnUGG8kg5oBqMZEnQaTtCmTNRpMUWswVSUEoJYBqMV0uRYzZCkzGYGzJCTWMQB1mFOkw9xCKtBjHs3P12NBHuXqkwG4KJuyDAxAA5ZkGLBUwAhcxghcfsOIFdfpmpEBaMSqK6ak1ZdNWHPJhLUX6YKJAWjG+nNmbDhLZ8zYSJtOEyNw80kLtpywYOtxOmZJBuD2Iyk7Dlux85AVuw4SI3D3fhv27KO9NgagDftoPyNw/y47Duy04+AO2m5nANpxeKsDR7bQZgcD0IFjAkbgcUbgifVOnFxHa50MQCdOr3YxAF0MQBfO0rkVtNyF84zAC0tpiZsB6MalRW5cXkgLPLhCV+fTPA+uzfXgOiPwBiPwxiwvbs704tYMmu5lAPqQOTUla4oP2ZN9yJlEjMDcCX7kjadxfgagHwVjaHSAARhA0cgARIIRAYgZgRJGoGRoENIhQcgG06AgAzAExYAQlP2pX4gBGIK6D/UOQ0PaXtQzDF2PMPTdwzAwAg1dIzB2icDUmTpFkgFo6UDtowzAKGxto7C3iSYD0NEqBmfLFFeLGNy/EiPQ0ywOb9M4fE3olzj8P8cRYAQGfkwg+EMCoe/puwTC3yYQYQRGvi5mABYj9mUx4l8UJwMw8VkJij+lT0pQ8nEJSj8qaQjAUpS/T++VMgBLUfkOvV3GACxD9ZtlqHmDXi9D7WtlqHu1nAFYzgAsx+2X6MVyBmA57j5fwQCsYABW4P6z9ExFMgAf/q0Sj/5Kf6nE4z9X4smf6I9CAFYB1Nh/lZb2n9DoA9LS/qk1RxF+fUpPihiARWj5qAitBIzA1g9EaHNfhLb3RGh3l+6I0J4R2OG2GB3rqU7MABSjMwOwS3VK1yoJulVK0L2CGIE9yqToWSpFL0GJFL2LpejDCOwbp5iMAShD/4gMAxiBAxiBA0NyDArKMThAfjkDUIGhNMxLHgWGuxUY4VJgpFPJAFQyAJUYTWNsxAgcywgcZyaTigGowgSDChMZgRMZgZN0akzWqjFFQ2o1A1CDaTRdSQoNZsg1mCkjqZYBqMVssRZzRClzGYHzGIHzCyhfxwDUYWEu5eixiBZn67EkizL1DEA9lt0yYPlNumHAClp5na4ZsIoRuPqKEWsu0yUjA9CIdQzA9YLzJmw4Z8LGs3TGlAzAzafM2HKSTpixlbYdN2M7I3D7UQt2HLFg52E6ZGEAWrD7gBV7BPut2LvPin17rQ0BaMOBXTYc3Ek7bDi03YbDjMDDjMAjW+04usWOY5tpkx3HNzpwYgOtdzAAHThFp9cSI/DMaifOrqKVTgagE+eTAehiALpwkS4tocUuXGYEXmEEXlngZgC6cW2eG9fn0hwPA9CDm4JZHtya6UEGIzCTEZg5zYusqV5kT6HJ3mQA5k6kCT4GoA/5VDCOGIGFjMCi0TTKzwD0QzyChgcYgAFIhwYgG0KDA5APCkDBCFQMDEI5IAhVf+oXhJoRqGEEantTrxB0PUPQ9wg1BGAYxq7UJQwTmTuHYWEEWjpGYO0Qga09tYvA3jYCByPQ0ToKZ6soXC2pRZQBGIWneQzeZtQ0xgCMwf9LrCEA4wj+mBL6Po4wRRiBEUZg9JsEYl/TVwnEv0wgwQhMfF6M4s+KUfIpfVKM0o+LUcYILPuwBOUflKDi/RJUvkeMwCpGYPXb9FYpat4sRe0bxAisYwTWv0qvlOH2y2W481IZ7jIC7zIC7z1fjvv/oOfK8eDZcjxkBD78ewUDsAKP/5Ly5E8VeMoIfPqHykb/qrS0/6RGH5CW9k/v16eFaEEtn9DjwmQAtn5YhDYPitD2fkq7e0VozwjswAjscFvEABShU50InQWMwC41YnStFqNbFVWKGYBi9GAE9iynMgkDUILeJRL0SQagFH2pX1yK/jGKShmAMgwMyzAoREEZBtOQgAxDGYFDfXIGoBzDPXKMcAsYgIzAUU4FRjvIrmAAKjDWqmQAKjGOxpuVmGAio5IBqMIkvQqTdaRVYQpN1agwjRE4TaVmAKoxQ6HGTLk6GYCzaLaUJBrMEWswV6TBvCItA1DLANRiAS3MpzwtFjECF+dQto4BqMPSTB2WMQKXMQKX39JjxU09Vt6g63qsYgCuvkpXDFhDay8bsO4SMQLXXzBiw3kjNp6js0Zsos2MwM2nTdhyyoStJ03YdsLUEIBm7DiasvOIGbsOm7GbEbibEbjngAV799M+CwPQgv17rDgg2G3FwV1WHNpJO6wMQBuObLPh6FbaYmMA2nCcEXicEXhiox0nN9hxaj2tsycD8MwaWu1gADpwjs6vJEbgheVOXFxGS50MQCcuL6ZFLgagC1cXuHBNMN+F64zAG4zAG3PcDEA3bs1yI2MmzfAwAD3ImkZTPcimnCke5DICcyd5kTfRi/wJNN7LAPSicKyPAehjAPogGuWDeKTADwkjUDqchvkhG+qHfAgNFgIwAOXAAFQDqH8A6n4BaPoGGYBBaEnXm3oFoe8ZhIERaOxO3UIwdQ3B3CXUEIBhWDtShzADMAx7u3BDAEbgbB2Bq1WKu2UEHkaghxHobR6Frxk1jcLfJIoAIzD4M/0UQ+jHGMI/0PcxBmAc0W/pmzgDMI74V/GGAEyg+HP6LMEATKD0kwTKkgFYjPIPi1HxQUrle8WoerckqfrtEtS8lVL7RgnqXi9F/Wv0ailu052X6aVSBmAZ7r1Az5cxAMvw4LmyhgAsx6O/09/K8fiv5Xjyl3I8/bMQgBXAHysa/afS0v6TGn1AWto/vRYoYAAWMAAL0OpxAVo/Kkxq87AQbR8Uot19ulfIACxiABahI3W6TfVFyQDsUitC1xqqFqEbda8SoUelEIBiBqAYvcrE6F2a0ocR2LdYgn4JiksYgBIMiEowkBE4MCLFoLAUg0NSDAlKGwJQhmE+GYYLvDKM8MgwkhE4ykVOOQNQjjF2OcYKGIHjrAqMt5BZwQBUYCIDcJLAoMRkvRJTdEpM1SobAlCF6SoVZgiUKsxUqDCLEThLpmYAqjFHosZccco8RuD8Ig0WFFKBhgGowaJkAGqxmJbkaLE0m7K0DEAdlmfosOIW3dQxAHVYJWAErr6mx5qreqy9Qpf1yQBcf9GADYILBmw8b8Cmc4aGADRiy2kjtp6ik0Zso+2MwO3HTdhxzISdR03YdYQOmxiAZuw5mLL3gBn79puxfx8xAg/sseDgbtplYQBacJgBeESw3Yqj26w4tpW2WBmANpzYZMPJjbTBxgC04bSAEXhmrR1n19hxbjWtsjMA7biwwsEAdDAAHbi01IHLAkbgFUbg1UW00MkAdOL6fCduzHMxAF24OceFW7NTMma5kMkIzJzhRtZ0N7KnuZEzlaa4GYAe5E2iiR4GoAcFAkZgISOwaKwXojE02gvxKC8kjEDJCB8D0AfZMBrqYwD6oBjsh1IwyA/VQD/UA6i/HxpGoLYv9QkwAAPQ9wrAkAzAIAMwCFM36hpkAAZhYQRaOodg7RSCrWMI9g7UPgQHI9DZltqE4WodhrsVtQwzACPw/hqBrzk1i8DfNIJAMgCjDMAoQj/Rj1GEKcIIjDACo9/FEPs2hvg39HUMCUZg8Zf0RRwln8dR+hl9GkcZI7D8Y/oogYoPE6j8gN5PoIoRWP1uMWreobeLUftWMereZAAyAutfL8Ht1+jVEtx5pQR3GYF3GYH3XizF/Rfo+VI8+EcpHjICHz1Lz5Th8d/L8OSv9JcyPGUE4k/ljf5RaWn/BY0+IC3tN6El8tHqKT3JR2tGYJtHBWj7sADtHqS0v1+ADozAjnfpTiEDsBCd6wvRpa4oqWttEbrVFKF7NVUVMQBF6FkhQi9BuQi9y0ToUypC3xIxA1DMABSjPw2IU0wIQAkGRSQYHKaQBENoKCNwWID8UgagFCO8Uoz0kFuGUTTaJcMYJzlkyQAcZyOrnAEoxwSaaCZG4CSjApMNCkzRk06BqTSNEThdQ2olA1CJmUplQwCqMJvmyEiqwlyJCvMYgPNFVKRmAKqxsCBlESNwcZ4GS3IpR8MA1GBZlgbLM7VJKzK0WHmLbmqTAbj6ug5rrtFVHdbSuis6rGcErr+kZwDqsfECndczAPXYfNaALYIzBmw9bcC2UwZsP0knjNhx3Iidx+ioEbtoNyNwDyNwzyET9h40Yd8B2m9KBuCBvWYc3JNyaLcZh3cRI/DIDguObrfg2DbaasHxLRacYASe2GzFyU1WnNpoxekN1mQAnllnw9m1tMbGALThvIAReIEReHGFHZeW0zI7A9COK0scDEAHA9CBawsduC5Y4MANRuDNeTTXiVtznMiY7URmMgBdyJrhQvZ0muZCDuUyAnMZgXmT3cif5EbBRJrgRuF4D4rG0VgPA9AD8WhPKgBJOtIL2Qga7oV8mBcKRqCCEagc7INqEA30MQB90DAAtf1SdH390Peh3n4YGIHGntQjAFP3AMzdArB0JUagtXMQtk7UMcgADMKRDMAQAzAEVxtqHYKbPIxALyPQ2yIM369h+JtTszACjMBgE/olgtDPEYR/iiDyI/0QRfT7KGLf0bdRBmAUia/pqxgDMIaSL+jzGAMwhrJkAMYZgHFUUOVH9GEcVYzA6vfo3QRqqPZteiuBOkZg/Zv0RjFuv16MO68V4+6r9HIJ7r1Ugvsv0gslePB8CR4+LwRgKQOwFI+fob+X4snfSvH0r0IAljX6N6Wl/Rc1+oC0tN+ElshjAOahNQOwzeN8tBU8yke7h/lo/yAfHZIBWMAALEAn6nyHbhegCyOwa10hutVSTSG6Uw9GYE9GYM/KIgZgEXqXF6FPWVEqAKlfiQj9iykhYgCKMDAmxqBoyuCIGEPCYgwNUVDCAJRguF+CEQKfBCMZgaMYgaPd5JIyAKUY6xDIMM4uw3ibDBOsZJExAGWYZJJjsjFlikGOqXo5piUDUMEAVGCGWoGZqpRZjMDZCpIrGYBKzJUqMU9CYhXm0wKRCguLqFCFRQUqLM5XMwDVDEA1ltKyHGIELmcErsjUYGUG3dJg1U0NVjMCV9/QYs11LdZe02LdVbqiZQDqsOGSDhsvpmy6oMNmRuBmRuCWs3psPaPHttN0Sp8MwB2CEwbsPG7ArmMG7D5KR4wMQCP2HqKDRuyj/QeMOMAIPLDPhIN7TTi0h3abkgF4ZKcZRwU7zDi23Yzj22irEIAWnNxswalNtNHCALTgDCPwzHorzq6z4txaK86vodVWXFhlw8WVtMLGALTh8jIBA5AReHWJHdcW0yI7A9COG8kAdDAAHbg114GMOSmZjMCsWTTTiewZTuRMdyJ3Gk11IW+KC/mTaZKLAehCoRCAVDTeDdE4N8RjaYwbEkagdBSN9DAAPZAPp2EeBqAXyiFeqASDvVAP8kIzkBiB2v4+6PpRXx8D0AcDA9DYi3r6Yerhh7k7dfMnA9Aq6BKArXMA9k7UMQAHI9DZPghXO2obhLtNEJ7W1CrEAAzB14J+DTEAQwgwAINNqUkYoV/CCP9MP4URYQRGGYHRHyKIfR9B/Dv6NoIEI7CYEVj8VRQlX0ZR+kUUZZ8TI7D80xgqPqGPYwzAGKo+pA/iqH4/jpr36N04at+Jo44RWM8IrH8zgdtvJHDndXotkQzAe6/Qy8W4/1IxHrxILxQzAEvw6B/0XAkeP1uCJ8+U4Onf6a+lADX2N6Wl/Rc1+oC0tN+M1shFa0Zgmyd5DMA8tHtED/MYgHnowAjseD8fne7R3XwGYD66MAC71qd0qytA99oC9Kih6kIGYCF6VRait6CiEH3KC9GXEdivlEqKGIBFGJAowsAEA5AROCgmwuCoCEMiFBYlA3AYDQ9SQMwAFGOkT4xRXgkDUMIAlGAMjXWRU4JxjMDxdrJJGYBSTKRJjMBJjMDJJhmmGGWYaiC9jAEox3SaoSWNHDPVcsxSkVLBAFRgjlyBuQKZAvMYgfMZgQvEJFIyAJVYVChgADICl+SrsDSPclUMQBWWZ6uxIitlZaYaqzLolpoBqMGaGxqsvU7XNAxADdYzAjcwAjdc1mLjJS02XaQLWgagDlvO6bBVcFaHbWd02H6aGIE7Tuqx84Qeu47TMT12MwL3MAL3HDFg72ED9h0yYP9BQ0MAGnFwH+014hAd3mPEEUbgkV0mBqAJx3bQdhMD0IQTW804uSXl1GYzTm+ijWYGoAVn11twbh2ttTAALbggBCBdXGXFpZVWXF5By624wgi8upSW2BiANlxfZMONhQI7bi6w49Z8mmdHxlw7MufQbAcD0IHsmQ7kzKDpDuQyAvMYgXlTncif4kTBZJrkRCEjsGiCC6LxNM7FAHRBMoZGuyEl2Sga6YZ8hBuK4W4oGYHKoR4GoAfqwTTIkwxA7QDq72UAeqEnQ19iBBp7+2DqRT19MPfwwdKdGIHWrn7Yuvhh70yd/HB09MPZIcAADDAAA3AL2gbgYQR6GYG+VtQyCH+LIAK/EiMw2CyEUFNqEkL4lxAiPxMjMPpjGLEfwoh/T9+Fkfg2jOJvIgzACEq+iqD0S/oikgzA8s/o0ygDMIrKj1OqGIHVjMCaD+i9GGqp7l1iBNa/FcdtwZtx3HkjjruvEyPw3qsJ3H855cGLCTx8IYFHzxcnPX6uGE+epWeKkwGIv5U0+ielpf03NPqAtLTflDZPc9H2SS7aPU5p/ygXHRiBHRmBHe/nMQDz0PluHroIGIFdb+ejW30+utdRbT4DMB89GYG9qqmqgAFYgD4VBehbTmWF6Ef9SwsxoISKCxmARRgUL8LgGEWLMISGRoowjBE4LCRiAIowIiDCSH/KKEbgaK8YYzzkFjMAxRiXDEAJxtMEuwQTbWSVMAClmGyWYoopZapRimkGKaYzAqfrZAxAGWZqSC3DLEbgbEbgHCUp5AxAOebJ5JgvVTAAFVhAC8UkUmBRkQKLGYFLCihfyQBUYhktZwQuZwSuyFZhZRZlqhiAKqxmAK65mbL2hhrrrqux/hoxAjdc0WDjZbqkwSbafFGDLYzALee1DEAttp3VYvsZbTIAd5zSYafgpA67Tuiw+7gOexiBe47qsfeIHvsO0yE99tMBRuDBA7TfgEP7DDi8l/YYGIBGHN1lxLGdKcd3GHGCEXiCEXhyqwmntphwejNtMuEMA/DshpRz6804v47WmnGBEXhxtQWXVtFKCwPQgivLBVZcXWbFtaVWXF9Ci624wQi8yQi8ucDGALQhY54NmXMFdmQxArNn0yw7cmbakTuDGIF50xzIn+pAwRSa7EDhJAeKJjqTRBOcEI+ncU5IGIFSRqBsNI1yQT7SBcUIV0MAuqESDHVDPcQNzWA3tIxA7UAPdAM80Penfp5kABr7UG8vA9ALc08vLD28yQC0kq0bdfXB3sUHR2diBDoZga4O1N7PAPTD09YPb5sAAzDAAAzA35JaBBiAAQSbBxmAQQZgEOEmQUR+CSYDMEqxn+jHEOI/hJD4nhiBxYzAkm/o6zBKvwqj7EtiBJZ/HkHFZxFUfkqfRFD1cQTVH0UZgFEGYBS179N7UQZgFPXvxFD/dowBGMOdN2O4+0YsGYD3Xovj/qv0ShwPXo7j4UvECHzECHz8PP0jgSfPJfD0WWIENvYXpaX9NzX6gLS035S2yEHbpzlo9yQH7R/noMMjepjLAMxFJ+p8n+7lMgBz0fVOHrrdpvo8dKcedXnoWSsEYD4DMB+9q/LRpzKlLyOwHyOwfxmVFjAACzCwuACDGIGDEoUYHC/EkFghhkYLGwKwCMNpRIiCRRgZKMIoBuBoH3lFDEARxgrcIoxjBI53ijHBQXYxA1CMSVYxJjMCJ1skmGKWYKpJgmlGSUMASjGDZupIK8UsjRSzGYGzVTIGoAxzFTLME8hlmM8IXCCVY6GExHIsEsmxWAhAWlKowNICBZblU56CAajEihwlVmZTlhKraHUmMQLX3FJh7U0V1t2g6yoGoAobGIEbr9IVNTZdVmPzJXVDAGqw9bwG286lbD+rwQ5G4I7TWgagFrtOarH7BB3XMgB12Cs4qsO+IzrsP6zDgWQA6hmAehzaT/v0OExHGIFHGYFHdxtwbJcBx3fSDgMD0IiT24w4tTXl9BYjzmwmRuDZjSac22DC+fW0zoQLDMCLa1IurTbj8ipaacYVRuBVRuC1ZbTUwgC04MZiWmTFTbq10IqMBTTfisx5VmQxArPm2BiANuTMsiF3pi0ZgHmUP52m2VEw1Y7CKcQILGIEiiY6IJ5A4x2QjHNAOtbJAHRCRvLRNMoJxUgnlIxA1XAa5oJ6qAuaIa6GAHRDN5AGuBmAbhjIyAg09vXA1McDc2/q5YGlpwdWRqC1u5cB6IW9K3XxMgC9cHbywdWROvjgbu+Dp52AAcgI9LWh1n74W/kRaOlHkBEYZASGmgcQbkZNA4g0CSDKCIz+HGQABhH/kX4IMgCDKP4uxAAMMQBDKP06hLKvQskALP8ijArBZ2FUUtUn4VQAUs1H9GEEtR9EUPd+BPWMwHpG4O13orjzNr0Vxd03o7jHCLz3egz3X4vhwav0cgwP6dGL8aTHz8fxhJ7+I54MQDyTaPQvSkv7b2r0AWlpvzntnmYzALPRnjo8zkZHRmCnh/QghwGYgy73ctCVEdiVEdjtTi66385Fj3qqy2UA5qFXTR56C6rz0KcqD30r89CvIp8BmM8AzMcAGlhKJUIAFmBwogBD4hQrwFAaxggcHqFwIQOwECODhRgVIH8RRtMYXxHGeslThHEMwPEucoowgSY6RJhkJ5sQgGJMsYgx1UwmMabRdEbgDAPpJQxACWZpSSNhAEoxh+aqSCllAEoxnwG4QEZSGQNQhkUCsQyLGYFLiuRYWkgFcgagHMvz5FjBCFyRq8DKHAVWZVOWIhmAazKUWHsrZd1NJdbfUGLDdSEAVQxAFTZdocsqBqAKWxiBWy/SBTW2nVdj+zk6q2YAarDztAa7TqXsPqnBHkbgHkbg3mNa7Duqxf4jdFjLANThoOCgDocO6HB4vw5H9tFePQNQj2O7aZcex+kEI/AkI/DkdgNObTPg9FbaYkgG4NlNRpzbmHJ+gxEX1hMj8OJaEy6tMeHyalplwpWVJlxdYWYAmnGNri8z48ZSWmLGTUbgrUW00MIAtCBzvqUhAK3Ippw5NNuK3FlW5DEC82bYGIA2FEyjqTYGoA1Fk+0QTUoRT7RDMoHG2yFlBMrG0hgHA9ABxSgHlMkAdDIAnVAPS9EMdULLCNQOdkE3yAX9QBcMA6i/iwHohqkv9XEzAN2w9KKeblgZgbbuHtgF3TxwdPXAyQh0MgJdnbxwd6QOXnjae+FlBPraUhsf/K19CLSilj4GoB+hX6m5H2GKNKOmfkQZgbFfAoj/TD8FkPgxgGJGYDEjsOS7IEq/pW+CKPs6iHJGYPmXIQZgCJWf02chVH0aQjUjsOZj+iiM2g/DqPuA3g8zACO4/S69E2EARnD3rUhDAEZx/3V6LcoAjOLhK1E8EgLwpRgevxjDkxfo+RgDMAY8F2/0D0pL+x/Q6APS0n5z2iEL7Z9mocOTLHRMBmA2AzAbnanLA7qfzQDMQbe7Oeh+h27noAf1rM9BL0Zgr9pcBmAu+lTnom+VgAHICOxfkYcB5VSWxwDMw6CSfAwuThmSyMfQeD6GxShawAAswIhwAUYKQgUYFSzAaEbgGD/5ChmAhRgnYASOdxdhgqsIE53kKGIAFmGyTYQpAqsIUy0iTDOLMN1ERjEDUIyZ+pRZOjFmMwLnMALnqCUMQAnmKSWYrxBIsUAuxUIZSaUMQCkWi6VYIpIxAGVYSssKZVheQPlCAMqxMpdy5AxAOVbTGkbgmkwF1mYosO6WAutv0g0FA1CJjddSNl1VYvMVJbZcFgJQxQBUYdsFFbafp3Mq7GAE7mQE7jyjxq7Tauw+pcaek3RCg73HNdgnOKbB/qMaHDiiwUFG4MFDWhw6qMXhA7RfmwzAo3RsL+3R4fhuHU7sop16BqAep7brcXpbypmtepxlBJ7dbMC5TQac30gbDAxAAy6uM+LSWlpjxGW6spoYgVcZgddWmHB9OS0zMQBNuJkMQDNuUcYiMzIX0gIzshiB2fNoroUBaEHubJplYQBakT/DigLBdCsKp1lRxAgsYgSKJtsgnkQTbQxAG6QMQNk4GmuHnBRjaLQdSkagaiSNcEA93AHNMAe0Q2mIE7rBTugH0UAnA9AJIyPQyAg09XPB3NcFSx/q7YKVEWhjBNp6uBmAbji6UVc3A9ADV2fq5GEAeuDp4IGXEehlBPraeeFvS228CLT2IsgIDDICQy18CP/qQ6Q5NfMhygCMNaFf/AxAPxI/0Y9+BmAAJd/TdwEGYABl39DXAQZgEBVfBlH5RUrVZ0FUMwKrGYE1H4dQK/gohLoPQ6hnBNYzAm+/F8add8O4+w69HcY9RuD9N+mNCB68HsHD1+jVCB4xAh+/TC9G8YSePp/S2P+TlvY/pNEHpKX9JnV4mskAzERHRmCnx1no/IgeZjEAs9D1fha63ctO6n43Gz3uZKPn7eyGAMxB79oc9BHU5KBvdQ76MQL7V1JFLgMwFwNpUBkxAgeX5GFIcR6GJiielwzA4TQiSpF8BmA+RoXyMToZgAUYQ2P95CtgABZgvKcQE9zkKmQAFmISTWYETmYETrEVYaq1CNMsZC7CdEbgDEbgTCMZRJilF2G2jrRiBqAYc2memlRizFeKsYARuFBOMgkWSSVYLGAELmEELhVJsayICqUMQClW5MuwUpAnw6pcGVbnULaMASjH2kw51mXQLTnW0wZG4EZG4MbrCmy6psDmq3RFwQBUYittu0QXldh+QYkd54kRuPOsCrvOqLD7dMqeUyrsZQTuPaFmAKqx/5gaB46qGwJQg0OCQxocPqjBkQMaHGUEHt2nZQBqcXwP7dYyALU4yQg8tZN26HB6uw5ntukaAlCPc5v1OL+JNupxgS4yAi8yAi+tM+DyWlpjYAAacHWVEddW0gojrtON5bTMiJuMwFtLTMhYTItMDEATspIBaGYAmpFDuXNpjhl5jMB8RmD+TAsD0ILC6TTNwgC0QjTFCvHkFMkkK6QTiREoG2+DfByNtTEAbVAyAFWjaKQd6hF2aIanaBmBOkagbogD+sEOGAY5YBxIjEBTfyfM/aivkwHohLU39XIxAF2wC3q44OjugpMR6GIEurq44e7shqcTdXQzAD3wtad2HgagB4E2HgRbUysvQi29CLdIiTT3IipgBMaa+hBvQr/4kPjZh2JGYDEjsOQHP0q/96PsO/rWj3JGYAUjsOKrACq/DKDqC/o8wAAMouZT+iTIAAyi7qMg6j+kD0K4/X4Id96jd0MMwBDuJQMwzAAM48Eb9HqYARjGo2QARhiAETx5KYKnL9ILESAdgGn//9HoA9LSfpM6IAMdn2agEyOw0+NMBmAmujzMRFcBI7AbI7D7vSz0uEt3shiAWejFCOxdT3XZDMBs9K3JRr9qqspBfxpQmYOBFVSekwzAwaW5GFKSMrQ4F8MSuRjOCBwey2MA5mFkJA+jwimjGYFjgvkYGyB/Psb58jFeCECa4CnARHcBJrnIWcAALMQUeyGm2lKmWQsx3VKIGYzAGaYiBmARZhlSZjMC5zAC52pJI2IAijBfJcICIQBpoUKMRXKSiRmAYiyRSLBUTCIJltHyIglWFBIjcGW+FKvyKFfKAJRiDQNwrSBLhnWZMqzPkGHDLbopZwDKsel6yuZrcmy5KsdWRuDWywoGoALbL9IFRTIAd9Kuc3RWid1nlNhzWtkQgCrsO6HC/uMpB46pcJARePCImgGoxuFDahw5SAfUDEANjgn2aXB8rwYn9mhwcrcQgFoGoBand9B2LQNQi7OMwHNbaYsO5zfrcGETbdQxAPW4tF6Py+torR5X6Coj8Coj8NoqA66vNODGClpuwE0G4K2ltMTIADQiU7DIiCxGYPYCE3Lm0zwTA9CEvDk028wANKNgZkrhDDOKppshYgSKplognmKBZDJNsiQDUDaBxlsZgFYoxlqhFDACVaNtUI+ikTZoRtigHU7D7AxAO/RD7DAMpkF2BqAdJkagaYAD5v4OWPpRXwesjEAbI9Dei3o64ejhhLM7dXMxAF1wd6HOLgagC96OLvgYgb4ObvjbuxFoR23dCLZxI8QIDLXyINzSg0gL+tWTDMBYMy/iTamJF4lfvCj+mX7yoeRHH0p/oO99DEAfyr+lb/wMQD8qv6Iv/aii6i/8qGEE1nwWQO2nAdR9Qh8HUM8IvM0IvP1BEHfeD+Lue/RuEPcYgfffprdCePBmCA/fCOHR68QIfPxqGE9eoZfDDMAwQI39O2lp/4MafUBa2m9WKgAz0Jm6PKZHGQzADHR7kInu9+leJnpQz7uZ6HWHGIG967PQpy4LfWtT+jEC+zMCB1RRZTYDMBuDyrMxmBE4uCwHQ0pzMLQkB8OKKZHDAMzFCBoZo2guRkVyMZoBOCZEwTwGYB7GCfx5GM8InODNx0QPufMZgPmYTFMYgVMcBZhqL8A0WwGmW8lSwAAsxEyBqRCzjIWYbSjEHH0RA7CIAViEeZoizBeoi7CAEbhQSQoRA1CExTIRlkgFYiyViLFMLMZyERWJkwG4soDyJVhFq/MkWJNLjMC12VKsy5JifSZlSLGBNjICN96UYdMNGTZfl2HLNVlDAMqx7bIc2wWX5NhxUY6djMCd5xUMQAV2n1Vgzxk6rcBeRuC+U3RSif0nlDhwXImDyQBU4dARFQ4fTjlySIWjjMBjjMBj+9U4vk+NE3tpj5oBqMEpOr2LdmpwZocGZ7cTI/DcVi3Ob6HNWgagFhcZgZcYgZc26HB5vQ5X1tFaHQNQj2ur9bi+ilbqcYNuriBG4K1lBmQsNSBzCS02IGuRAdkLjQxAIwPQiNx5KXmMwHxGYMFsmmVC4UwTimaYGgLQDPFUmmKGhKSTzZAxAmUTLZBPsEAxnsZZGIAWqMZYGYBWBqAVmpFWaEcIbNAxAvXDaKgNhiE2GAfTICEA7TAPsMPSn/rZYe1rh62PgwHoYAA64BD0dMDZwwEXI9DVzQl3Vyc8XZzwdqZOQgC64O9A7V0MQBeCbV0NAehGuJUbkZbUwo0oxRiBseYexJt5kGhKTTwoZgSWMAJLfvKi9Ecvyn6g770oZwRWMAIrv6Gvfaj6yofqL30NAehH7Wf0qZ8B6Ef9x/RRgAEYwJ0PArj7Pr0XwL13A7j/TpABGMSDt4J4+Ca9EUwG4OPX6NUQAzCEpy/TS6FG/5u0tP9hjT4gLe03qxNuofNTenKLAXgLXR/dQjcBI7D7gwz0uJ+BnvfobkYyAHtTn9tUn4m+dZnoV5uJ/jVZDMAsBmAWBtKgSqrIYgBmY0hZNoaWUkk2htFwRuAIRuCIeA4DMAejojkYHRHkYkw4F2NDFMxlAOZivD8XE3x5DMA8TKRJnjxMduc1BGA+pjryMc2eMt2WjxmMwJmMwJnmAswyFWC2kQwFmMMInKsvxDwdaQsZgIVYwABcqCJlERbRYgXJi7CEEbiUEbhMQmIRA1CEFbSSEbiyUIxVBWKszqc8MQNQjLU5EqwTZEuwPkuCDZkSbEwGoBSbbkqx+QZdl2ILbWUEbrtKV2QMQBl2XKKLMgagHLto93k6J8ees3LsPSMEoIIBqMD+kwocOJFykBF46BgdVeLwESWOHFbi6CE6qGIAqnBcsF+FE/tUOLlXhVOMwFO71QxANc7spB3qZACeo/PbaKsGF7ZocHEzMQIvbdTi8gZar2UAanF1rRbXGIHX1uhwfbUON1bRSl0yAG8t1yNjGS3VMwD1yBIwArMZgTkLDchdQPMNyJtnQP5cIwPQyAA0onBWStFMI0SMQPF0mmaCZKoJ0immhgA0Qz6RJpgZgGYoScUIVDEC1WMs0IymURZoR1qgYwTqhlsZgFYYhlphHEKDrTANssE8MMUywAZrf2IE2hiB9j7U284AtMPZ0w5XMgAdcHdzwNOVujgYgA74GIG+jk74KdDBiWB7audEiBEYbkOtXYi0ciHa0tUQgG7Em1MzNwPQjeIm9IuHAehB6U8elP1IP3hQ/r0HFYzAim+9DEAvqr5Oqf7KixpGYM0XPtR+7kPdZz7Uf0qMwNuMwDsf0Yd+3P3Aj3vvEyPwPiPwwTv0dgAP3wrg0ZvECHz8ehBPXgvi6av0ShB4Odjof/O/2a2r9ioXNFvDf2Rf3b1bqkuXu7uvhbtrcAIBgmsgQgIEd+LJdHd317hCcCd4CJCxxzcnP2FXpXvVPLjPx8n7Xk9Ozv9nIz4gJ+d/tV+HNfiNRr2kF5pMAI4Z0mLsMxrUYhyNf6rFBEbghMc6BqAOkx7qMPlB1hRG4NQBPabdo7t6BqAeMxiAM29lzbppwOwbBsy5TteMDEAj5l0xYr7gshELLhmxkBGY108XTFh03oTFAkbgEkbg0h4zlnVTl5kBaMaKDgtWCtotyG+zYFWrBatbqNnKALRiTSprbdKKdYzAQkZgYczGALRhQ8SGjQJG4KaQHZuDFLAzAO3Y6rNjm9eRsd3jwA63AztdjlcB6ESRnWxO7KY9VieKGYHFjMASkwulRhfKDKR3MQDdKBdo3ajQuLFP7cZ+FSk9DEAPKuVZB2UeHGIEHmYEHhZ7GYBeHG2iRi8D0IfjdKKe6nw4WevDqRqq9jMA/Thzzo+zZ7POMQKrGIFVpwIMwABqTgRQezzwKgCDqBccCaLhcBCNh4JoYgQ2VYYYgCGI99O+EAMwBGl5GDLB3jDkZWEoSqlECMAIVHsiUO+mogg0uyLQMgK1O6PQ7YhCv522RRmAURi3xGDaTJtiDMAYLAJGoJURaCukdXHY18bhWBOHMxOACQZgAu58WpmAh7yMQO/yJHzLkvAvTSKwhBYnGYAphPJoYYoBmEJkPs1LIcoIjM1NIz6HZqeRmJVGkhGYZASmpjcjPY2mNjMAm9EyuQWtk2hiC9omtKBdML4FHYzAzrE0phVdo1vRPaoVPb8RI7D3lzb0/Uw/tTEA23AhE4DtDMB2XPyWvmlnALbjMiPwylf0ZQeuftGBa5/TZx24zgi88Ql93ImbH3Xi1of0QScDsAt33qN3u3D3nS7ce7sLA5kA7Mb9N7rx4HV6rZsB2I1Hf+1hAPYwAHvw5E/0xx4GYA8G/9DLAOxlAPZi6D968fzf6f/24sW/9eHlv9K/9DEA+4D/0zfifyYn5+9gxAfk5Pyv9hvUDEA1A1CN0S/UGPNckzF2SINxzzQYP0hPNQxALSY+1mKS4JEWkx9qMYUBOPU+DegYgDpMpxl3iRE487Yes27pMfsm3dBjDs1lBM67RlcNDEADFlw2YGEmAI3Io0X9dMHIADRiSZ8JS3upx4RltLzbhBVdxAhc2WFGfrsZq9qo1YzVjMACRmBBswVr0hasTVmwLkkJKwPQivW0IUZRKwPQik1hGwPQxgC0YQttDZDfhm2MwO1eO3Z4yG1nANqxy+nIKHI4sNvuwB4bWR0MQCdKzE6UmrLKjE7sNRAjsFznQoXWhX0aUruwnxF4gBFYqSSFGwflbhySkdTDAPTgiNiDowKRB8eaPDjOCDze4GUAenGyzotTtd5MAJ6mM9VU5cPZcz6cO+tD1Rk/A9CP6lN+1JzMqj3hRx0jsP4YHQ2g4UgAjYcDrwIwCFFllvhAEJL9QUgZgVJGoKw8BPleKgsxAENQloShEhSHod4ThmY3FYUZgBHodkag30HbIzBsi8DICDQyAk1bojBvpk1RBmAU1g0x2NZTYQz2dTE41mY5GYGuAlodh3tVHJ78OLwraUUCvuUJ+JfR0gQDMIGgEIAUWpREOC+JyEJakESUERhjBMbmphiAKSRm06wUAzCN1Iw00tOzmqel0TKVGIGtk5vRNokmNjMAm9GRCcAWBmALusa0oHs0jWrJBGCv4NdW9P3SivM/00+tuMAI7P+hDRe/p+/acOnbNlz+hhiBV75qx9Uv6Yt2BmA7rmcCsIMB2IGbH9NHHQzADtxmBN55P+vue5249y6904kBRuD9t+jNLjx4owsPXydG4CNG4OO/duPJX+jP3Xj6p24MMgIHGYHP/tCDof+i/+zB8//owQtG4AtG4Mt/68Xwv9K/9I74j8nJ+TsZ8QE5Of/rjRpWYbTgpQpjGIFjn6sxboieqRmAakxgBE5kBE58omEAajD5kQZTHtIDLabStPtaTB+ge1oGoBYz7+gw63bW7Fs6zLmpw9xMAOoZgHrMv6rHAsEVPRYyAvMu0UUDA9CAxRcMWHJeYMTSPiOW9RqxvIe6jZkAXNlpQr6gw4RV7SasbjOhgBFY0GLGmmYz1qaz1qXMKGQErk9Q3MIAtGBj1IJNQgDS5rAVW0IUtDIArdjGANzuI68NO2inx4ZdbmIEFjnt2O0gu50BaEcxI7CEEVhicaDU7ECZyYG9RkcmAMv1TlQIdE7s0zqxX+PEAUbgAZWLAejCQQXJXThEhxmBR6QkcTMA3Tgmcr8KQA9O0MkGqvfgVJ0HpxmBp2u8DEAvzlZ5ce5cVhUjsPoMnfah5pQPtSd9qMsEoJ8B6EfD0azGI340MQJFh+hgAOLKACQHaH+AARiErCJLXh6EYm8QyjJiBKpKQlAX054QAzAELQNQJ9gVhn5nGIYdtD3MAIzAtDUC8xbaHIFlUwTWjYIobBuisK+nwigc66JwMgBda6ggBvfqGDyrKD+WCUCfYEUc/uVxBJbFEVxKjMDQ4gTCiygvwQBMILqA5icZgEnEKTGX5iSRZASmGIGpmSmkZ6TQPJ2mpTIB2DqFJqcZgGm0T0yjQ8AI7BzfjK5xNLYZ3WOa0TOaGIG9v7Wg79cWnP+Ffm7BBQZg/4/0QysDsBWXvqNvWzMBeEXwdRuuftWGa1/SF224zgi88Vk7bn5Kn7Tj1sftuP0RMQLvfNCBu+/Tex0MwA4MZAKwkwHYiQdvduLhG/R6Jx691oXHf6O/djEAu/D0z/SnLgZgN54J/tDNAOzGc8F/dDMAe/CShv+N/rUH+JeeEf8vOTl/JyM+ICfnf71RUDIAlRjDABz7gp6rMI7GD6kw4RkxAic+VWPSEzUmP86a8kiNqYzAaQ/ovoYBqMGMexrMZATOZATOuqPF7NtazLlFN7UMQB3m0fzrdE3HANRh4RUd8i7rGYB6LKLFF6lfjyWMwKWMwGV91GtgABqwglYyAld2GRmARqzqMGJ1O7UZGYAmrBG0mLC22YR1aRMKMwFoZgCasYE2xilmxiZG4OYIhS0MQAu2Bi3YJmAEbvdbscNnxU4veayZACxyZe122rDHYUOxnRiBJVY7Si12lJmz9prsKGcElhscDEAH9ukc2K91vApAJyoFKicOKp04pHDicCYAXQxAF45Kso6JXTjOCDzRRI1uBqAbp+qpzs0A9OAMna2hag/OVXlQlQlALwPQi5rTXtSeyqpjBNafoOM+NBzzofGoD01H6LCfAeiH+GCWpNIPKSNQxgiU7QtAXhGAopz2BjIBqCoNQi0oCUJTHIR2DzECdUUh6HfRzhADMATj9hBM28IZ5q1hWLbQ5jCsjEAbI9C2IcIAjMBRGIFzHa2NwkXuNVQQhWd1FN5VxAj0rYzBvyKGwHJaFssEYGhJVnhxHJFFlBdHlBEYYwTG59O8BAMwgeQcmp1kACaRnkkzkmimlulJtDICW6em0DYlhfbJNCnFAEyhc0KaAZhmAKbRPTaNnjHpTAD2jmpG329Z539txoVfiBHY/1MLLv5IP7Tg0vctuPxdC64wAq9804qrX7fi2lf0ZSuuf9GKG5+3MQDbGIBtuPUJfdyWCcA7H2bd/aAd995vx8B7xAi8/04HHrxNb3Xg4ZsdePQGMQIfv9aJJ3+jv3bi6V86MfhnYgQ++2MXhv67C8//QP/VhRf/2Y2XjMCX/96N4f/bDfxb94j/lpycv6MRH5CT87swBgqMYQSOfanEuBdKjH9OQ0oGoBITGYGTBumpCpOfqDDlsQpTMwGoZgCqMZ1m3KcBNQNQg1l3NZh9h25rMIfm3tJgHiNw3g0tA1CLBde0WHhVwABkBC66TJd0DEAdlvTrsPSCPmPZeT2W9+mxopd69AxAA/K7DFjVmbW6w4ACRmABI3BNqxFrW4xY10xpIwoZgetTJmxIUsLEADRhU4yiZmymLREztoYpZM4E4PaABTv85LNgJ+3yEiOwyG3FbpcVe5zksDIArSix2VAqsNpQZrFhr5lMNgagHRUGO/bps/br7DjACKzUkNqBgyoHDilJ4cBhRuARuRNHZSR14pjEieNiErkYgC6cbHThlKDBhdOMwDOMwDO1bgagG+eq3aiqonMeVFPNWTrjQe1pD+pOeVB/0ssA9KLhuBeNx+ioF02MQBEjUHTYB/EhHyQHfZBW0gE/A9AP+b4sRYUfynI/VIxAVVmAARiApoSKA5kA1O0OQi8oCsKwKwjjTmIEmhiB5m20NcQADMG6OQTbpnCGfWMYjg20PgxnYRguRqBrbYQBGIGnIALv6kgmAH35UfgFK6MIrIgiuJwYgaGlMYSXxBBZTItiiObFEFsYZwDGGYBxJATz4kjOjSPFCEzPplkJNM9MoGVG4lUAJtE2laYkGYBJdAgYgZ2MwK4JKXSPp3Ep9IxNoZcR2Ds6jb5RaZz/jX5NMwDT6P+5GRd/oh+bcemHZlz+vvlVALbgquCbFlz7ugXXvyJG4A1G4M3P6bNW3Pq0Fbc/acUdRuCdj9pw98M23PuA3m9jALbh/rvtDMB2BmA7Hr5Fb7ZnAvDx6x148hr9rQNP/9qBwb8IOvGMETj0J/pjJwOwEy/+S9DFAOzC8L9njfRPycn5OxvxATk5vwtjIMfYYQXGvaQXCoynCc8VmDgkBKCSAajE5KdKTHmSNZUROO2RCtMf0gMVA1CFmQMqzGIEzrqnxuy7asy5o8bc2+pXAajB/BsaLBBc12DhNQ3yGIF5V7QMQC0WX9JiieCiFksZgcsu6LD8PPXpGIA6rGQE5jMC87v1WNWlx+pOPQo6qN2ANW0GrBW0GrCuxYDCZgPWMwLXp4wMQCM2JozYJGAEbmYEbolSxMQANGFbyITtQXPGjoAZO/1m7PKR14wijwW73eSyYA8VOy0oYQSWMAJLbVaUWa3YayGzFeWMwApGYIXRhn0GG/brbTigI62dAWjHQYHajkMqOw4zAo8wAo/IHQxAB45JSeLAcUbgCUbgSRE1ORmATpxuoHoXA9CFs7UunBPUuFBV7UI1I7D6nJsB6EbtGTfqTruzAUgNJ+mEB43HPWg65oGIESg64oX4sBeSQ1nSg17IGIGyAz7I9/ug2OeDssL3KgD9UJdlaUr90Jb4oWME6vYEGIABGIpoV4ABGIBpRxDm7VmWbUFYt9KWIGyMQPsm2hhiAIbgXB+CKxOAYbjJs5bWhOEtCMPHCPStijAAIwisjCC4gpZHEFoWRXgpLYkiQtHFxAiMMQLjC2NILKD5MSTnxZDKBGCcARhH8yyaGUcLtTICW6cn0DYtgfapCXRMockJdE5KomsiTUgyAJPoGZd8FYAp9I1O4fyorAu/pdDPCOxnBF78OY1LP9GPaVz+IY0rjMAr3zUzAJtx7Rv6upkB2IwbX7bg5hf0eQtufdaC25+2vArAVtz9KOveh60Y+IAYgfcZgQ/ebcPDd+jtNjx6qw2PGYGP32jHk9fb8fQ1+ls7Bv/ajmeMwGd/7mAAduD5H+m/O/CCEfiSETj8n/QfncC/d474T8nJ+Tsb8QE5Ob8bYxmB44blGP9Sjgkv6LmcAajApGcKTBYMKjDlqQJTnygw7bGSAahkACoxg2Y+oPtCAKow+54Kc+7SHRXm0jxG4PxbdFPNAFRj4XU18q7RVQ0W0eIrdFnDANRgKQNwWT9d0GI5rTivxco+YgTm9+iwqluH1V3UqUMBrWEErmnXMwD1WNeqR2GLPhuAtCFtwMYUJQ0MQAM2x40MQCMD0IittC1CYSO2MwJ3BE3YGSC/iQFoQhEjsIgRuNtjxh63GcUucpoZgBaU2i0oE9gs2Gu1oNxCjMAKkxX7jFbsN2QdYARWMgIrtTYGoA2H1DYcVpHSzgC046hAbscxmR3HpXacYASeEDsYgA6caso6zQg80+DE2XqqczIAnaiqcb4KQBdqqPYcnXWh7owL9YzA+lNuBqAbjSfcaDpOx9wQMQLFR+mIB5LDHkgPeSDLBKAX8gNeKPbTPi+UpGIEqstprw+aMh+0pVTiYwD6od9Du/0wkLHIDxMj0MQINO8IwLKdtgUYgAHYMgEYZAAG4SDnRtoQhIsR6C6kdSEGYAjeNVQQYgCG4V8VRkCQH0ZwZRghRmCIERheFkFkKS2JMAAjiC2KIp5HC6MMwCiSgvlRpBiB6bk0J4bm2TG0zIqhNROAcbRNj6N9Gk2NMwDj6BQCkLomJdA9MYGeCTQ+gV5GYN9YGpPE+dFJXBhFvyUZgClc/IV+TjEAU7j8YwpXfhCkcfX7NK59R9+mcf2bNG4wAm8wAm9+2YxbX9Dnzbj9WTPuMALvfNKCux+34N5HLRj4kD5owf33W/HgPXq3lQHYikdv01utDMA2PHmDXm9jALZh8G9trwKwHUP0/M/0p3a8+GM7Xv6hI2P4vzqA/+wY8V+Sk/MPMOIDcnJ+V8YPyxiAMgagDBNpEiNw0pCcASjHlEE5pj6VZwOQpj9WYMYjeqhgACow674Sswey5txTYu5dJebdodsqBqAKC26qsFBwQ4U8RuAiRuCiq2oGoBpLLqux9JJAg2UXNVjer8GKC3RewwDUIL9Xi1WCHi1Wd2tR0KV9FYA6rG3XYV1bVmGrDusZgRuaKa1nAOqxKZm1mRG4JW7A1hhFDQxAA7YzAHeEsnYGjdgVIL+RAWjCbq8JezzkNqGYSlwmlDICSx1mBqAZe21kNWcCsIL2mclkwX6jBQcMFlTqrQxAKw5qrTikyTqstuIII/CokhQ2HJPbcFxGUhtOMAJPSuw4JSaRHaeb7DjT6GAAOhiADpyrc6BKUOtANSOwppqqnAxAJ+rOOlF/hk670ECNp+ikC00nXBAdFwLQzQB0Q3LEDelhOuSGjBEoP0iVHigOeKDc74FqH1V4GYBeaPZSmRda0jEC9YxAfbEPhj0+GHdTkY8B6Id5J+3ww0LW7X7YthEj0L4lAMdm2hRgAAbgygRgkAEYhIe862htED5GoJ8R6F8dYgCGEMynlSEGYBjh5WFEltHSMKIUW0KMwPiiCBJ5tDDCAIwgxQBMz6O5UTTPiaJldlYrI7BtJs2IoX16DB3TaGoMnYzArslxdE+iiXEGYBy942lcggGYwPkxWRdGJ9DPCLzICLz4axKXfkni8s/0UxJXGIFXGYFXv08xAFO4/i19k2IApnHzK/oyzQBM4/bnadz5jD5txt1PmnHv46yBj5pxnxF4nxH44P0WPHyP3m3Bo3da8JgR+IQR+OTNVjx9oxWDr9NrrXjGCBz6K/2ljQHYhhd/oj+24eV/t2P4D/Rf7SP+Q3Jy/kFGfEBOzu/KeEgxYViKiS+lrwJQhslDMkx5ljV1UIZpjMDpT+ixnAEox8yHcswSMAJn31dgzoACc+/RXUUmAOfTgtt0S8kAVCLvBl1XMQBVWExLrtIVFZZeVmEZI3D5RepXYwWtvKBGPiMwnxG4qleD1T0aFHRTlwZrGIFrO6lDi3XtWhS2abG+lVp0DEAdNtKmNKV02MwA3JKguJ4BqMc22h4lRuCOsAE7QwbsClLAgCK/AbsZgbt9RuzxGlHsMaLEbXwVgCaUOUzYK7CbUG4zoYIRWGExMwDN2G8y44CRDGZUMgIP6klnwSGtBYc1FhzJBKCVAWjFMYHCiuNyK04wAk8yAk9KbAxAG06LqMmGM4zAs412nGugejsD0I7qTAA6GIAO1FY5UCc450A9I7CBEdhw2skAdKLppBOiE3TcBTFJjtFRF6RHXJAdJkag/KAbiko3lAdovxsqRqCaEaiu8EBT7oF2rwe6Mir1MgC9MBTTHi+MZNrthZkRaN7lg2WnD9YdtN2XCUD7VtriZwD64STXJmIEujcE4FlPhQEGYAC+tbQmyAAMIrA6iKBgVRCh/CDCjMDwihAiy0OILqOloUwAxheHkVhEeWEkF4aREjAC0/MjaJ5HcyNomRNB62yaFWUARtE+I4qO6TQtik4GYNeUrO7JMfRMookx9DIC+xiB58fR2DgujImjfzSNSjAAE7j0K/2SYAAmcOUn+jHJAEzimuD7JK5/l8QNRuBNRuDNr1O49VUKt7+kL1K4wwi8ywi8+2ka9z5JY+Bj+ijNAGzGgw+a8fB9eq8Zj95txuN36O0WBmALnr5Jb7RgkJ4JAUhDf23F879kvfhzK14yAocZgcP/3Qb8oW3Ef0hOzj/IiA/IyfndmTAsYQBKMIkROPkFPZdiypAUU59JMW2QnsownWY8kWHmY3okywTg7AdyzLlPA3LMpXn35JjPCJx/R8EAVGDhLQXybmYtYgQuvk7XlAxAJZZeUWKZEIC0/JIKKy6qsLKfLqgYgGqs6lNjdW9WQY8aa7qJEbi2U4N1HRoUtmetZwRuYARubKFmLQNQi80pSuqwhbYmdNgWp5iOAajDjogeO8MU0mMXFQUpIASgAXt8BhR7yWNgABpQyggsc5HTyAA0otxONiMD0IR9FhP2C8wmHDCZUGkUAtDMADTjkM6Mw9qsI4zAo2pSWRiAFhxXWHBCTjIrA9CKUwKJFafFVpxhBJ5lBJ5ttDEAbaiqpzobqhmBNbV21NZQtZ0BaEf9OTrrYAA60HjagSbBKQdEjEAxI1B83MkAdEJ61AnZEWcmAOWkOEQHXVBWuqA64IKaEaje54amwg1tOe11Q0d6RqC+1ANDiQfGYg9MezyvAtALyy7a6WUAemETMALt23xwbPXBuYU2+xiAPrg3+hmAfgagH97CLB8j0M8IDKyhggADMIDQqsCrAAwisoKWBxmAQcQozgiMLwkhsTiE5CLKCzEAQ0gvCDMAwwzAMFrmhtE6J5wJwDZqn0UzI+iYEUHndGIEdk2NontKFD2TaVIUvROj6JsQYwDGGIAxXBCMiaGfEXiREXhxVByXfovj8q9xXPmFGIFXGYHXfqQfErj+fQI3vqNvkwzAJG59TV8lGYBJ3PlCkMLdz1O491kKA5/SJync/ziFB4zABx+m8fCDNB69T++l8ZgR+IQR+OTtZjx9qxmDb9IbzXj2eguGXmvB87/RX1vw4i8tePln+lMrA7AV+O/WEf8dOTn/QCM+ICfnd2cixJg0TIzAyS8kmPJcgqlDWdMYgdMZgTOe0hMpA1CKWY+kmM0InP1QhjkPZJh7X4Z5A3RPxgCUYwEtvEO35ci7JceiTAAqGIAKLLmmwFLBVQWWMQKXX1ZixSW6qGQAKpFPqxiBq86rsLpPhYJe6lFlAnAtreuiTjUKO9RY367GhjYNA1DDANRgk6BZg81pDbYwArcmKaFlAGqxPabFDkbgDkbgzogOu8IU0jEAddgd0GOPP6vYp0eJV49SDzECy1wG7HWSw4ByqmAE7mME7rMaGYBGHDAbUWkiowkH6ZCB9CYc1plwRGvCUY2ZAWjGMZUZx5VZJxiBJxmBp2QkteC0xIIzYhJZGYBWnKOqRmqworreihpGYE2tjQFoQ121DfWCKhsaGIGNZ+mMnQFoh+gUnXQwAB2QHHdAKjjmgOyoA3JGoPywkwHohPKgE6pKOuCEmhGo2U/7XNBWuKArd0GfCUA3DKVuGEuo2M0AdMPMCDTv9sBS5IF1lwe2nbTDA/t2LxzbaKuXAeiFS8AIdDMCPRt98G6g9T74Cn3wr/MzAP0MQD+CBbTajxCFGYGRfFoZQHRFALHlgVcBGERiCS0OMgCDSOUFkWYEphmBzQtCaJlP80JonRtCGyOwbXaYARhGx0yaEWYAhtE1LYLuqVk9UyLonUyMwD5G4PkJND7KAIyif2wUFxmBF0fHcGlUDJd/o19jDMAYrv4cZwDGcY2u/0g/xHHj+zhuMgJvfpvArW8SuP11Ane+IkbgXUbgvc/psyQDMIn7nyRfBWAKDz+kD1IMwBQev5fCk3fTDMA0nr6dxuBb9GYaz95IY4gROPRaM57Ti7/RX5rxkhE4zAgc/lPLiP+NnJx/sBEfkJPzuyQE4OSXYkwRvBBj6nMxpg2JMf2ZhAEoYQBKMJNmPaHHEgagFHMeSjH3Ad2XYh7NZwQuYAQuuCtjAMqQd5tuybCIEbj4phxLbtB1OQNQjmVX5Vh+RcEAVGAFrbykQP5FxasAVGL1eSUK+rLW9CqxlhG4tlvFAFShsFOF9R3UrsIGRuDGNjU2tVKLGpub1diSCUANttK2pAbbExTXMAC12BnVYleEwloU0e4QMQL3BHQo9utQ4iOvLhOAZbTXTS49yp16VDjIbmAAGrDfasABgcWASrMBBxmBB41GBqARh/VGHNEZswFIxzSkNuG4yoQTShNOKswMQDMD0IzTAqkZZyRmnGUEnhNRk4UBaEF1gyUbgFRbZ0VdLdVYGYBWNGQC0MYAtKHpjA0iwWkbxIxAyUk6YWcA2iE7Zn8VgA4oDjugFBxyQHXQAXWlEIBOBqAT2n1O6Cqo3MkAdMEgKHPBWOqCqcQFczExAi273bAW0S43A9ANOyPQzgh0bPfAuc0D11ba4oF7sxeeTbTRywD0wrc+y88IDKzzIbiW1vgQKvAhnAlAPwPQj+hKWuFnAPoRZwQmltHSAJJLAkgtpkUBBmAQzQtpQZABGETrPJobZACG0E4ds2lWCJ0zQ+hiBHYxArunhdEzlaaEGYBh9E2K4PxEmhDBhfER9I/LusgIvDSGRkdxeVQUV34jRuBVRuC1n+mnGAMwhhs/xHAzE4Bx3Po2jtvf0NdxBmAcdxmBd79I4B4NfE6fJXD/0wQeMAIffkwfJfHowyQef0CMwCeMwKfv0jspDL6dwrO36E0hANN4/jq9lmYApvHyr2kMMwKH/9wM/Kl5xH9GTs4/2IgPyMn5XZoMESYPixiAIkx9IcK05zQkwnRG4IxnYswcpKdiBqAYsxmAcx5lzX0owbwHEsy/TwNSBqAUC+9KkSe4I8Wi21IsZgQuviljAMqw9LoMywSMwOWMwBVX5Fh5mS7JGYByrOpXYLXgggIF5xVY00e9CgagEuu6lSgUdCmxvlOJDYzAjYzAjW0qBqAKm1uytjACt6bV2JaipJoBqMaOuBo7GYE7YxrsimpQFKGwJhOAe4JaFAeySvxalPq0KGMElnl0DEAdyl3k1KGC9jEC99vJpmcA6lFp0b8KQAMOGQ04LDAYcERvwFFG4FGtkQFoxHG1ESdUWScZgacUJDcxAE04IzXhbCYAzQxAM6oETWZUN5pRwwisrac6CwPQgvoaqraggRHYWGVF0zk6a2UAWiHOBKCNAWiD9IQNMsFxG+SMQMVROmJnANqhOmSH+iBVOqA54IBWsN8B3T4H9IxAPSPQsNcJY5kTplIqcWYC0CLY44J1twu2ItrlYgC64djhhnM7bXMzAN1wbxF44NnsgXcTbfTAt8EDPwMwUEjrvAxAL0JrqMCLMCMwsppW+RDN9yG20of4CmIEJpb5kVxKS/wMQD/SmQAMoJlaFgbQuoDmB9DGCGxnBLbPCTIAg+icRTODDMAQuqeH0DMtq3dqCH1TiBF4flIYFybShDD6x4dxMROAEQZgBJdHR3BlFP0WwdVfo7j2C/0cxXW68RP9GMVNRuCt7+m7GG5/G8Odb+hrIQDjuPdlHANf0Odx3P8sjgeZAEwwABN49BF9mGAAJvDk/SQDMMkATGLwHXo7yQBMYujNFJ4L3kjhxespvHyN/pbCMCMQf0mP+L/IyRkBIz4gJ+d3a8pwE6a+zJr2ognTnzdhBiNwxjMRA1CEWU9FmC1gBM55LMbcR2LMe0gPxAxAMRYwAhcO0D0JA1CCRXckrwJQiiW09CbdkDIApVh+TYYVV+mKDCsp/7IMqy4RI3B1vxwFF+i8nAEox1pG4DpG4LoeBQNQgfVdCmzopA4lNtKmdmpTYnOrEltalNjarGIAqhiAKmynHUlKCAGoxq4YRdUMQDV2h9XYwwjcE9KgOKhBSUCDUj/5NAxALfZ6ssrdWlS4tNiXCUAdA1CHAzYdKq1ZBxmBh8xk0jMA9Thi0OOonnQGHKPjWtIYcEJtwEkG4CklKYw4LTfijCzrLCPwnMSEKjGJTKhuMqGmkRrMDEAz6qi+jmrNaGAENjICG6ssDEALRGfpjAViRqDktBXSU3TSygC0Qn6cjtkYgDYoj9igEhy2QX3IBg0jUFNpZwDaodtvh34fVThgKHfAKNjrgKnMAXMpMQItxU5Y9zhh201FTth3OeFgBDp2uuDc4YJrO21zwc0I9DACvZtpkxu+jW74N9B6DwIULKR1HoTWehBe40GEERhZ7UV0lRexfFrpzQRgQrDch+QyH1JLfUgvIUZg8yI/WvJooZ8B6EfbfJoXYAAG0CGYE0Dn7AC6GIHdjMDuGUH0TA+idxpNDWYC8PxkmhRiAIbQPyGEi+MFYVwaF8blsTQmjCujw7g6ihiB136N4Pov9HOEARjBzUwARhmAUdz+Loo739I3Udz9OoZ7X2UNfBnD/S/o8xgeMAIffkqfxPHo4zgefxTHkw+JEfj0/QQG36N3E3j2TgJDjMAhRuDzN5N48Qa9nmQAJjGcCcDUiP+JnJwRMuIDcnJ+t6agEVOHGzHtZSOmv2jMBiDNHGrCrGc02MQAbMKcJyLMfZw175EI8x+KsOCBEIBiBqAYefforhiLaDEjcMltuiVhAEqw7IYEy68LpFhxTYqVV6XIv0KXpZkAXH1RhgJBvwxrLsiw9jwxAtf1ylHYI8f67qwNXXJsZARu6qB2BTa3KbClVcAAZARua1Zie5pSSgagEjsTKuyKZxXFVNgdpYiKAahGcUiNkiAF1CilMkbgXkbgXq8G5R4NKtzk0jAAtdhPBxxk16LSpsVBK1l0DEAdDpt0OCIw6nCUEXiMEXhMp2cA6nFCo8dJNakMOEWnlaQw4IzcgLMyA85JjQxAIwPQiGqByIgaRmAtI7CugepNDEATGmqpxoxGaqo2Q1RF58wQnzVDwgiUnLYwAC2QncySMwIVjEDlMTpqZQBaoT5sfRWANmgrbdAJDtig32+DgRFoqLAzAO0w7bXDXGbPBKClxAFrcZZtjwP23VQkBKATzp1OuHbQdifc25zwbHVleLe44NtMm1zwb3QhwAgMrqdCN0Lr3AivdWcDkKIFtNqD2CoP4vkeJBiBiRVeJJd7kVpGS70MQC+aF/syWhb50JpHC31oYwS2MwI75tFcPzrn+NE1m2YFGIAB9Myg6QEGYAB9dJ4ReH5KEBcmB9E/iSYGcXFCEJcYgZfGhRiAIVwZQ6NDmQC89hv9GsZ1uvFzGDcFjMBbP0Zw+wf6PoI730Vw91tiBN77OoqBr+jLKAMwigcMwIef0acxPPokhscf00exTAA+/YDej2OQnr1L78QZgAk8F7yVwIs3E3j5RgLDrxMjEH9LjvifyMkZISM+ICfnd23acEPG9JcNmMEInPmchhoZgI2YPdiIOYzAOYzAuU+aMO9xE+Y/oodNDEARFlLefRoQYdE9ERbfpTtiBqAYS2+JsUxwU4zljMAVjMCV1+iqhAEowSpazQhcfUnKAJRiTT9dkDIApVjHCCzso14Z1vfIsKFbho2ZAJQzAOXYLGiXY0ubHFsZgdtaqFnBAFRgR0qBnQJG4K6EEkVxiikZgErsYQAWC8IqlIRUKA2qUBYgv5oBqEa5N6vCo8Y+txr7GYH7nRoGoAaVdrJpcJAReIgReNhCZi0DUIujRjLoGIA6HNfpcEKg1eGkRodTjMBTKj0DUI8zCj3OygUMQEZglZQkBgagATUiA2qbjAxAIwPQiHpBvRENdUY0MgKbaqjaxAA0QXzOlA1Akp4xQ3aaTpkhP2mG4oSFAWhhAFqgOmqBWnDEAg0jUHuIDloZgFboD1hfBaANxgobTOVZ5r02WBiBllI7rCV22Ippj50BaIejyAHnrizXTgfcO4gR6GEEerfSFicD0An/JicCQgBScIMLofVU6EJ4nQsRRmBkjZsB6EZstRvxVZTvZgB6kBSs8CC13IP0MmIENjMCWxZ70bqI8rxoW+hF+wIfA9DHAPShUzDXh645PnQzAntm0Uw/emf40Tfd/yoAA7gwhSYHGIABXJwYyAYgXR4fxJVxNDaIq2OCuMYIvDYqhOu/hXDjV/olxAAM4dZPYQZgmAEYxp3v6btwJgDvfRPBwNdZ97+K4MGXxAh8+HkUjz6jT6N4/EkUTz4mRuDTD2MY/IDej+HZezEMMQKfMwKfvx3Hi7fiePkmvRHPBCBeS4z4f8jJGUEjPiAn53dtGuoxfbgeM17SiwYGYANm0ewhetbAAGzE3KeNmPeEHjdiPi141IiFjMCFD5oYgE1YNED3mrCYljACl96h2yIGoAjLb4qw4oY4Y+V1MfKvibHqKl0RMwAlKLhEFyVYQ2v7JVh3QQhAKQNQivW9UmzoydrICNzURZ0yBqAMW9pl2NpGrXJso+0tcuxoprQ8E4C7kpRQMAAV2E17YsQILI4oURJWojREQSXKaC8jcK9fhXKfChVeFfZ5VK8CUI0DTjUqBQ41DtrVOMQIPGTVMAA1OGLW4Kgp6xgj8LiB9FoGoBYntVqcygSgDqfpjIqUOpxV6HCOEVglI6ke1RI9asRZtYzAuiYD6hupwYCGegMaMwFoZAAaIRJUGyGuMkLCCJSepTMmBqAJ8lN00gQFI1B5wgzVcTpmZgCaockEoIUBaIHuoAX6yiwDI9C4n/ZZYaqwwlxOe60MQBuspTbYSrLsxTY49hAj0Flkh2sX7bQzAO3wbHfAuy3Lt9UB/xba7ECAERjcSBucDEAnwoVORNbRWheiFFtDBS7EV7uQYAQmGIHJlW6kVriRXk7L3Ghe6kHLElrsQSu1LaI8D9oZgR0LaL6XAehF11wvujMB6GMA+tA7k2b4GIA+nGcEnp/mx4WpfvRP8ePiZJrkxyVG4OUJND7AAAzg6tjAqwAM4voo+i2IG3TzV2IE3mIE3v4phDs/0g8h3P0+hHuMwHvfhjHwTRj3v6avwgzAMB5+EWEARhiAETz+NIInn0QyAfj0oygGP8x69n4UQwJG4PN3Y3jxDr0dw8u3Yhh+kxiBI/0bcnJG2IgPyMn53Zs+XIcZjMCZjMBZL+h5PQOwHnOe1WPuYEPGvKcNmP+kAQseN7wKwEbkPchadL8RiwcasSQTgE0MwCYsu92E5YJbTVjBCFx5Q4T863RNxAAUYTUjsIARWHBZjDWXxFh7kfrFDEAJCs9LsF7QJ8GGXgk29kiwqVvKAJRic6cUWwQdUmxlBG5jBG5vpRYZA1CGnWkZdjECd6XkKErKsTtBcTkDUI7iqAIlkazSsAJlIQX2ZgJQiXK/EhU+8iqxj/YzAg+4yaViAKpw0EF2FQNQjcN0xEoWNY6a1TiWCUANA1CDE3oNTgp0GpxiBJ7WkFrLANTirFKLcwqS61BF1TKS6lAj0aGWAVgnoiY9A1CPBkGDHo2MwKY6A0S1VGOAuNoASRWdM0JKsrN0xgj5aSMUjEAlI1B5wsQANEF9jI6aoGEEao+YoTtMh8zQHzTDUEkHLAxAC0z7LDBXZFkYgVZGoLXMClupFfYSKrZmAtC52wZXUZZ7lw2encQI9G63w7eNttoZgHYEGIDBTbTRgRCFN9B6ByKMwCgjMLrWyQB0Il7gRGI1rXIhme9CamVWeoULzcuJEdiy1I3WJbTYzQB0o50B2LGQFnjQOd+DrnlZ3YzAnjk024veWV70zfTi/AxiBF6Y5kP/VJriYwD6cCkTgH5cpisTaLwfV8f5cY0ReG1MANdHB3BjVAA3f6NfA7j1SxC3f6afggzAIO7+QN8HGYAhDHxL34Rwnx58HcJDRuBDRuCjL8J4/Dl9FsaTT8N4ygh8+nEEgx9F8OxD+iDCAIzg+XtRBmCUARjFy7ejGH4rmglAvBEb8b+QkzPCRnxATs7v3gzUYiYjcObLOgZgHWY/r8McwVAd5jIC5w3WY/5TelLPAKzHQkZg3iN62IBFDxqw+D4NNDAAG7GUlt2lO40MwEasYACuvEk3mpBPq643YfU1YgQWXBFhzWW6JMJaWndRhEJGYOEFMQNQjA19YmzsFWcDkDZ3U5eEASjB1g4JtrVLGYBSBqAUO2hnCzVLGYAyFKUoKWMAyrCHihmBxYzAkqgcpRE5ysIUkjMAFSgXBBSo8Cuwz6fAfi95lAxAJSpdWQedShxiBB5mBB62qRiAKhy1kFmFY4zA4yY1ThjJoGYAqnFKR1oNA1CDM2oNzgpUGpxjBFYxAqvkWgagFjVSLWolAh3qxDrUi6hJxwDUobFBh6Z6PQNQzwDUQyyo0UPCCJQyAmXn6KwB8jMGKE7TKSOUpDpphPoEHTdCc8wILSNQe8TEADRBf4gOmmBgBBoZgaYDtN8M8z4zLBVUbmEAWmAro1IL7OQoscDJCHTuscK12wp3Ee2yZgLQu4O22xiANvgpsJUYgcHNdoQ20UY7A9COyHoqdDAAHYitdSAuWONAghGYZAQmVzmRyncivZJWODMB2LLMhdaltMSFNmpfTIzAjjw3OhfSAje65rvRPc+NnrkeBqAHvbM96JtFMz2ZALwgmO5F/zQvLk6lKV5cYgRenuTDlYk0wYer4324No7G+nF9jB83RtMoPwPQj1uMwFuMwNu/BHDnZ/opgLs/BnCPETjACBz4Loj73wbx4Bv6OsgADOHRl/RFiAEYwpPP6NMQAzCMwY/pozADMIwhes4IfM4IfPFeBC/fpXciGH47AjACR/on5OT8DzDiA3Jy/inMZATOGq7F7Jf0opYBWIu5DMB5z7LmD9ZhwdM6LHxCjMC8R/VY9JAe1GMxLblfj6WMwKX3GhiADVh+pwErbgsasfJWI/JvNmLVDbreyABsRMHVpow1V5qw9nIT1l2ii00MQBHWXxBhg+C8CBv7RNjECNzUI2YAirGlS4ytnVnbGIHb2yXY0UatEgagBLsyAShFEe1OSbEnSQkpA1CGkpgMpdGssogMe8PECCwPylERkGOfn3xy7GcEHmAEVnrIrcBBlwKHnORQMgCVOGJT4qjAqsQxixLHGYHHTSoGoAonDSqc0gvUOM0IPKMljZoBqMY5lRpVSg0DUINqqpGTTINaqQZ1jMB6MYm0aGjSorFRwABkBIrqqU7HANRBUqODtFrPANQzAPWQC87qoTijh5IRqDpFJw0MQAM0xw2vAtAIHemP0GEjDIeMMDICjZUmBqAJ5v20zwQLWRmBtnLaa4a9zAxHqflVAFrg2kO7LXCTp8gCLyPQu9MK3w4r/Ntpm5UBaEVwi40BaGMA2hCmyEbaYEOUERgrpHV2BqAdiTVU4GAAOpBa5UA6P6t5pQMtjMCW5U60LnOibSktcTIAnehY5GIAuhiALnQtcKF7voAByAjsnUtz3Oib7cb5WcQIvDDDg/7pHlycRlM9uDTFg8uTvRlXJnlxdSJN8OIaI/A6I/D6WB9ujPHh5mga5WMA+nH7Vz/u/EI/+3H3Jz/u/Ug/BBiAAdz/jr4N4AE9ZAQ+ZAQ++iqIx18G8eQL+jyIp4zAQUbg4CchPPs4hKGP6MMQAzCMF+/Te2EGYBjD79Db4RH/BTk5/0OM+ICcnH8Ks1DDAKxhANZgzosazBUwAucN1WL+s1osGKSntQzAWuQxAvMe12HRozosfliHJQ/qXgVgPZbR8nt0tx4r7tRjJSMw/xbdbGAANmA1FTACCxiBa642Yu0VutzIAGxEISNwPSNwfX8TA7AJG883YVMf9Yqwmbb0ULcIW7tE2MYA3N5B7WIGoBg7aVcrMQKLmiXYnaaUhAEoQXFCghJGYElcitKYFGVRKfZGpJkALA/JUBHM2heQYb9fhgOMwANeOQNQjoNucslxiA4zAo84yK5gACpwzKp4FYBKnKCTJjIqccqgxGlG4GmdigGowlmNCucEahWqGIHVSlKoGYBq1MrUqMsEoAb11CAmkQaNTRo0MQJFDVSvhbhOC0ltlpQRKKumKh0DUAfFWR2UmQDUMwD1UAtO6qE5oYeWEag7RkcNDEADDIfpkAFGRqDpoBHmSjpghGW/EdZMAJoYgCbY91KZCQ5yMgJdJVRshnuPGZ7dVGRmAFrg20k7LAxACwIUZAQGGYGhLVaEN9MmKwPQimgmAG0MQBvi62xICNbakGQEpgpotR3pVXY059tfBaADrctpmYMB6ED7Egc6GIEdjMDORU505dFCJ7oXONHDCOyZ52IAutA3x4Xzs2mWCxdmutEvmOHGxeluXJpGjMDLjMArk2mShwHowbUJNN7LAPTixlgvbo6h0V7cGuXFbUbg7d98uPOrD3d/oZ99uMcIHGAEDvzgx/3v/XjwnR8Pv6VvAnj0dQCPv6IvAwzAAJ5+Tp8FGYBBPPuEPg4yAIN4LmAEvvgghJfvhzD8Hr0bAt7JBWBOzisjPiAn55/GbFRjzjC9rGYAVmPe8xrMH6JnNVhACwdrkPdUCMBaLHpci8WP6GEtltBSRuCy+zRQxwCsw4q7dVh5R1CP/Nv1WHWrHqtv0o16BmAD1lyjqw1YS+uuNKDwMjEC119sxIb+Rmy8kLWJEbiZEbi5t4kB2ISt3U3Y1kWdImynHR0i7GynNhEDUISiFjEDUIzdtCctRnGKkkIASlAal6AsRlEJ9lI5I7A8LEVFSIp9QSn2B8gvZQDKUCnwynDQI8MhtwyHMwEoZwDKcdSedcwmx3FG4AkLmRUMQAVOGcmgwGlG4Bm9Emd1pFUyAJWoygSgigGoQo1ChVqBXIU6RmC9lCRqBqAajSI1mpoEGogaNRA3UL0GkjoNpAxAWQ1VayGv0kIhOKeFkhGoOqOD+jSd0kFzUgftCTquZwDqoRcc1cNwRA8jI9DECDQdNDAADbAcoP0GBqARNkGFEfZyIxx7jXCWUamJAWiCu5j2mBiAJngZgV5GoG+XGf6dZgR20HYzA9CC0FbaYmEAWhDZlBVlBMY2WBFfT4VWBqAVyUwA2hiANqRX0yobmqmFEdi6klbY0bbcjvZltNTOAHSgczEtcjAAHehe6ECPEIDUO9+Jvnk014nzc5y4wAi8wAjsn+nCxRk03cUAdOHyVDeuTKHJblyla5NoohvXGYE3xtM4D26O9eDWGBotBKAXd36jX70MQC/u/ezFwE8+BqAP93/w4YHgex8efufDI0bgo2/8ePy1H0++oi/9eMoIHGQEDn4WwLNPAxj6JIDnHwcyAfjiwyBefkDvBxmAQeDd4Ij/gJyc/0FGfEBOzj+VOcNVmPuyCvOEAKT5z6uxYKgaC5/RYDUDsAaLnmQtflyDJY9qsPQhPahlANZi+UAtVgju1WIlIzCfEbjqNt2qYwDWoUDACFxzvR5rr9Vj3VW6Us8ArMf6Sw3YILjYgI39Ddh0gc43MgAbsaW3EVsFPY3Y1t2I7YzAHZ3U0cQAbMKutqwiRuDuFhH2NFNaxAAUoSQpRqkgIUZZXIy9MYqKGYASVIQl2BfK2h+U4AAjsJIRWOmT4qBXikMecktxmBF4xCXDUSc5ZDhml+G4jaxyBqAcJ+mUmUxynGYEnmEEntErGIAKnNMqUKURKFGtVqJGRUolA1CJOrkS9TIVA1CFBmqUkFiFJkagiBEoalQzANWQ1KshrRNoIKvVQF5D1RoGoAbKcxqozmoZgFoGoBYawSkttIxAHSNQf5yO6WA4qoPxCB3WMwD1MAsO6mGp1MN6QA8bI9C2zwB7hQGOctpryASgS1BqhLvECE+xEd49xAj0FZng30U7TQxAE4ICRmBomxnhrWZEttBmM6IMwNhG2mBhAFqQKMxKMgJTa61Ir6ECK5pXW9GyivJtDEAb2lbQchsD0IaOpQI7OpfY0bXYju5FlGdHDyOwdwHNdzAAHTg/l+Y4GIBO9NPFWTTTiUsznLg8nRiBV6a6cHUKTXYxAF24nglANwPQjZvjaKybAejGbUbgndE0yoO7v3lw71f6xYMBRuD9n+hHLwPQi4ffe18FoA+Pv/Hhydf0lQ9Pv/Rh8As/A9CPZ5/5MfQpfeJnAPrxghH44qMAXn4YwPAH9H5gxG8/J+d/mBEfkJPzT2UuzmHu8DnMYwTOf1GFBc9pqIoBWIU8ASNw0dNqLH5SjSWP6VF1JgCX0fIHdL+GAViDlfdqkH+3lgFYi1W0+nYtCm7RzVqsuVGHtdfpWh3WUeHVOqxnBK5nBG64VI+NF+uxqT9rMyNwy3nqa2AANmBbTwO2ZwKwETtoZ2cjdnVQeyOKGIC7W6mliQHYhGIqSRMjsDQpQllChL1xiolQzgisYARWRMTYFxZjf0iMA0EKSBiAEhwU+CQ45JXgsEeCI4zAIy4pA1CKY46s44zAE4zAk1ayyBiAMpw2kVHOAJTjLJ3Tk06OKq0c1YzAarWCAahArVKBOgEjsJ4R2CAjqZIBqESTWAmRSMUAVEFMkkZqUEFar4KMESirVTMA1VBUq6GsEjAAGYHqs3RGwwDUQHtKA91JLQNQywDUwiA4poXxqBYmRqD5MB3SwXJQB2ul7lUA6mEX7NPDUaGHs1wPFyPQVWaAu9QATwkVGxiABvgYgb7dRviLjAjsMiK405gJwNB2E8LbaKuJAWhCdLPAjNgmM+IbzUhsoPVmJAvNSK2zMAAtDEALmgtotQUtjMBWRmBrvhVtK61oX2FFx3JiBHYyAruW0GIbA9CGnjxaaEcv9S2w4/x8mmfHBUZgPyOwf7aDAejApZk0w5EJwCvTaKqTAejENcFkJ64zAm9MdOHmBBrvwq1xLtweS4zAO6PduDuKfnMzAN0YyASghwHowYMfPXj4Q9YjRuDj7+hbL55848XTr+krLwYZgc++oM99GPrMh+ef0idCAPrx8iM/hj+kD/zA+/4Rv/2cnP9hRnxATs4/nXnDZzH/5bmMBS/OYeHzc8gbOpcJwEWDVVj8NGvJkyosfVyFZYzAZQ+rGYDVWHG/GisHsvIZgavu1mD1HbpdwwCswRohAGntjVqsu16Lwmt0tZYBWIcNl+uwUXCpDpsu1mFzP12oZwDWY2tfPbb1Zm1nBO7obsDOLupsYAA2oKhd0IjdbY3Y09qI4hZqbswEYGmqCWXJrL2JJpTHiRFYERVhX0SE/WEKiXCAKhmBlQExA1CMQz4xDnvFrwJQgqMClwTHnBIcd0hwwi5lAEoZgFKcsmSdNktxhhF41kgGGQNQhiqdLBuAVKORo1ZNKjkDUI56hYIBqGAAKtAoVaBJIFFAxAgUi6hJyQBUQtqghCwTgCr8P3br6qvuRcHS9t/1dVVXnaqj291dkh13IwQCJLgud3f3hbu7BElwQoAkQEIggoXZ87dWLnr0aKnvirPPWRfP/byZY7x+CljIHELQFEKIERg2kD6MiC6MqDYpxgiMq0kVYQBGUKWIoDoRgFEGYBS1AkkUdeIo6hmB9RUxBmAMjWUxNJVSSYwBGEeLoCiO1sI42gooXwjASnTkVqLzNt2qZABWoju7KqEnqwq9NymzCn0ZVehnBA6k0/VqBmA1hq5VJwOQRq7Q5RrcuVSD0Ys1GGMEjp2vxfi5WkycpTO1DMBa3DtVlzB5sg5TJ+owfZwYgTOMwNmjdKSeAViP+V/o5wYGYAPu/5i0+EMDHnzfgCVG4NK3jVj+phErX9NXjXjIAHz0BX3exABswuqn9EkT1hiB6x8lPfmwGU8/aMbG+8QIfPZuCzbfobdbsPVWC57/jf7aygBsxcs/059aGYCt2E4EYBsDsA27tPfv9G9t2GcEvv5X+pd2HPy3duD/az/0z6ek/B069AEpKf90foEOvzICj7zW4+g+7ekZgHocYwQe2zHg+LYBJ14ZcPIlvTAwAI04TWe2aNOIs8+MOMcAPP+UnphwgS6u05oJlxiBlx+bceURPTQzAM24RmmMwLQlCwPQgvRFum9JBGAGZc7TnBU3Z63ImrEie9rGALQhh25N0j0bbt+1IZcRmDdOY3YGoB0FVMgILBxxoGjYgeIhGnQwAB0o7XeiTNDnRHmvExU9Toi6qcsFcacLko4kabsLMkagvJVa3FA0u6FsokY3VIxAdYMHmnqq80Bb64EuEYBeBqAXBjJWUtwLEyPQHKWIjwHogzXkgy0o8MMe8MPhJ5+fAeiHKxGAAQZgAB5nAF6BIwAfI9BvI2uQARhE0BxEyCQIIWwMIWIgfQhRXQgxBmBcQ+owKlVhVCmTqhmBNXKSRRiAEdRJIqgXkyiKhoooGgXlUTSVRdHMCGxmBLYUx9BaFENbIRXE0J4fR0deUmduHF236VYc3YzAnuxK9GbRzUr0ZVaiXwhAGrhRhcF0ul6FobQqDDMCR67SlWrcuVyN0Ut0sZoBWINxwfkaTJyrwd2zxAi8xwicPFWLqZN0opYBWIuZY3UMwDrM0txROlKH+V/rsMAIvP8z/VSPxR/r8eAH+r6eAdiA5W/pmwYGYAMeChiBj75sxOMv6PNGrH7WiLVPG7HOCFz/uAlPPmrC0w/pgyYGYBOevdfMAGxmADZj6+2k54zAF4zAl3+lv7Tg1Z9bsP0nYgTu/Gcrdv+D/tDKAGzF/r/Rf29jALbh4F/ov7Ud+t9TUv5OHfqAlJR/SkcOdAxAHY7Sb/u0p2MA6nF8R48T2/RKj5N0ihF4mhF4+rmBAWjA2U0Dzj0TGHF+w4gLT424+ITWjbi0ZsTlVVPClccmXH1kwrWHpjcBaMb1JTPSHyTdWDQjgxGYsWBhAFpwc86CrNmkbEZgzrQVt6Zo0orb96zITQSgDXmUP25DwRiN2hiAdhSN2FE8nFQyZEcpI7CUEVjW70B5nwMVvdTjgIgRKGYEiruckHQ6Ie1wQtZObS4GoAsKQYsLymYXVIxANSNQ3eBmALqhrUvSMQL1NR4YqqnKwwD0wBSnmJcB6IWFrBEKe2FjBNoZgfaAjwHog9Png0vACHR7/PC4yeVnAPrhc5A9wAAMIEBBK1kCCDECw4zAsDHIAAwiqg8iphOEENeGUKkhdQhVqhCqlSHUKMIMwDBqZWHUSZPqGYENjMAGUYQBGEFTeQTNZVQaRUtJFK3FSW1FUbQXEiOwIz+GzrwYunLpdgzdDMCenKTe7Dj6suhmHP2MwIGMSgzeoPRKDF2vxHAaXavCCN25SleqMHq5CmOMwDFG4PiFakycr8bdc3S2GvfO1GDydNLUqRpMn6QTNZhhBM4eq8Xcb3S0FvNHarGQCMA6BmAdFn9KevBjHZYYgUuMwOXv6rHyLX1TzwCsx6OvGvD4S/qiAaufN2Dts4Y3AdiIJ4KPG/H0o0ZsfEiMwGeMwM33mrD1Lr3ThOdvN+HFW80MwGYGYDNe/YX+3MwAbMbOH1sYgC3Ypb0/JO0zAl8zAg/+O/1rK/AvrYf+9ZSUv1OHPiAl5Z/SEWhx9ECL317TvhbH9rQ4vqtLOLGjw8ltHU69opd6BqAeZ57rcVawpce5TT3OMwIvbNBTAwPQgEsCRuBlRuCVVSOuPqZHRgagEWmMwOsrtGxC+pIJNx7QookBaEbmghk3BfNmZM2Zkc0AzJmhaQsD0ILbgkkLchmBeXetyJ+gcSsD0IrCUSuKGIFFd2woHrGhZJiGbAxAO8oG7CgX9NtR0WeHqJcYgeJuByRdDkg7k2SMQDkjUN7mZAA6oWxxQtVMTS6oSdNIDS5o613Q1bmgr3UzAN0MQDeMVUkmRqCZEWiJUdTDAPTAFqaQF3ZyBL1wBsjvZQB64fb6GIA+BqAPXpcPPgEj0M8IDNjJ5mcA+hGy+BE2BxiAAUQoaiRDADF9AHFGYFwbZAAGUaUOololYAAyAmsVJA+hThZCvZQkYQZgGI2iMJoqkprLw2hhBLaURtBaEkFbMRVFEgHYURBFZ35SV14U3bnECOy5FUNvDmXHGIAx9N+MYSAzzgCMY5CGblB6HMOMwBFG4Mi1SgZgJUavVGLsMl2qwvjFKkwILlTh7vkq3DtHjMDJM9WYOl2N6VN0shozDMDZ43SshgFYg3nB0RosMALv/0q/1GLx51o8+KkWSz/SD3VY/r4OK9/Rt3V4+E0dHjECHzECH39Vj9Uv6Yt6rH1ej3VG4PqnDQzABjz9uAEbH9GHDXj2QSM236f3GhmAjXj+joAByAh8+Rb9rQmv/tqE7b8QI3CHEbj7x2bs/Sf9RzP2/9CM1//ewgBsYQC2AP/acug/T0n5O3boA1JS/mkdPdAwADU4JmAEHmcEntjV4uQObWsZgFqcZgSeeUkvdAxAHc5t6XB+k57pcYEubtBTPQNQj8vrBlxZo1UDrtK1xwakPSJG4PUVI9KXacmIG5TBCMxkBGbeNzEATciaNyF7jmbNyKFbMzRtZgCakTtpRt49CwPQgnwqmLCgcJzGhAC0ovgOjVgZgFaUUhkjsGzQxgC0oaLfBlEf9dog7rFDIui2Q9plh6zTDnmHgwHogKLNAWVrkqrFATUjUNNEjU5oG5zQ1VOdE3pGoKHWBWMNVbtgqnLBXOlmALoZgG5YyRaliBt2RqAjREEPA9ADl9+TDEDyeL3wesjtZQB64Xf6GIA+BqAPQZsPIYHVhzAjMGImk58B6EfM4Ec8EYABVFKVljQBVKsDqGEE1iiDDMAg6uRB1MuSGhiBjRISh9AkCqG5IvQmAMNoLQ2jrSSpvTiMDkZgR2EEnQURdOVTXoQBGEHP7Sh6byX15UTRn02MwAFG4GAmZcQYgDEMp8cwcj3OAIzjzrU4RgVX4xi7Esc4I3D8UiUDsBJ3L9D5ykQATp6twtSZpOnTVZg5RYzA2RPVmDtOx6oZgNVYOFqN+0dqGIA1WPylBg9+TlpiBC4zApd/qMXK97V4+B19W8sArMPjr+mrOgZgHda+qMP65/RZPZ58Wo+ngk/qsfFxPZ59RIzAzQ8asPU+vdeA5+824AUj8OXb9FYjXv2tEdt/pb80YufPTdj9E/2xiQHYhH3BfzThNSPw4N/p35oP/d8pKX/nDn1ASso/rd+gxm8HagagGsf3NTixl3RyV4NTOxqc3iZG4JmXWpx9ocU5wXMtzjMCLzACLz6jDR0uPdXh8hOBHlfW9bi6pse1VXqsTwTg9YcGpAtWDLixbEDGEj0wMgCNuHnfiCzBghHZ80bkMAJvzdKMCbenTcidEjAAGYH598wouEsTZgagGUVjFhQLRi0ouWNB6QgNWxiAVpQPWlExkCTqt0LMCBQzAiU9Nki7bZB1UacNckagooPa7VC22aFqtUOdCEAHA9ABraDRAV2DA3pGoIERaKh1MgCdMFUnmRmBlkoXrHGKuRiALtgTAehmALrhJFeQAm64GYEeH3k9DEAPfO4kPyMw4PQi6CC7lwHoRTgRgD4GoA9RipnI6EOcEVipJ52fAehHtcaPGrUggFpVAHVKUgRQLw+gIRGAQQZgEE3iIJpFSS2MwNZyKguhrTSE9hIqDjEAw+gsDKOrgPLD6KYeRmAPI7D3dgR9tygnwgCMYCArisGblBnFEA1n0I0oRhiBd65TWowBGMPY1dibAIxj4lIcdwUX47h3IY5JRuDkuUpMna3E9Bk6XckArMTsySrMnaDjVZinhWPECLzPCFw8Qr9W48Ev1Vj6mX6qYQDWYOUH+r6GAViDR9/W4PE3tQmrX9di7Sv6shbrjMAnjMAnn9UxAOuw8Ql9XJcIwM0P67H1Ab1fj+fv1eOF4J0GvKRXb9NbDdj+WwN2GIE7jMDdPzdi70/0x0YGYCNeMwAP/kD/3gT8W9Oh/zsl5e/coQ9ISfmnduxAheMCRuCJfTVO7qlxapd21IkAPENnX9FLDQNQg/PPNbiwpWUAanGRLj2jDS0uP9XiCiPw6jqt6RiAOqTRdUbg9Ud6BqAeN1ZoWc8A1COTEXjzAS0aGIAGZC8YkJMIQCNu0e1ZmjEid9qIPEZg/iTdMzEATSikogliBBaPmVEySnfMDEAzyhiA5YIhCyoGLRANUL+FAWiFpNcKqaDHClm3FfIuYgQqOmxQttugaktSMwI1LdRsZwDaoWu0Q99A9Q4YyFhHtQ6YahwwMwAtVVTpZAA6YYsl2RmBjogLzjCFXAxAF9wB8rvhIa/PDZ+XPG74GYABFzk9DEAPQnYPwgJGYMTqRdRCZi8D0Iu4kQw+BqAPVVStI60PNYzAWkZgrcrPAPSjXkFyPxoYgY2yAJqkJAmgWRxAi4gqggzAINrKqDTIAAyigxHYyQjsLAqhqzCE7gLKDzEAw+jNpdthBmAY/TSQQ4zAwawIhm5SZoQBGMFIIgCjDMAoRmksja5FMc4InLhCl2MMwBjuXaQLMQZgHFPn4pg+mzRzJo5ZRuAsI3DuZCXmT9DxSgZgJe7/VsUArGIAVuHBr1VY+iVpmRG48hP9WI2HP1Tj0ffECHzMCFz9hr6uYQDWYP1L+qKWAViLp5/VYkPwaS2efVKLTUbg5kd12PqwDs8/oPfrEgH48l16p54BWI/tt+hv9QzABuz+pQF7f6Y/NWD/jw14LWAEHvxHI/CHxkP/dUrK78ChD0hJ+ad2DEoGoBInXqtwcp/2VDhFp3dVOMMIPLOtZgCqce6lGudfJF1gBF7cok0NA1CDyxsaXBECkK4+0eLauhZpa7SqZQDqkP4o6cZDHTJWdMhcJkbgzQd6ZC3qkX0/KYcReGue5gwMQANyZwzImxYYkT9lRMGkEYX36K4xEYDF4zRmQgmVjppQdocYgeXDZlQMmSEapAEzxCRhBEr6LAxAC2Q9Fsi7LYkAVJCykzqsULVboW6zQtNqYwDaoG22QdeUpG+0wcAINNZTnR2mWjvMNVTtgIWsVQ7YKinugD3mgCPqZAA6GYBOuAQhJ9xBJzyMQK+ffC4GoAt+D7ndCFDQ5UbISQ43A9CNiM3DAPQwAD2ImT2ICxiBlYzAKgPpvQxAL2q0pPExAH2oo3oVKX1oUPjQyAhslPkZgH40S0jsTwRgK7VVUHkA7WUBdJQSI7CzOIiuIioMMgCD6KFeRmBvXgh9uSH036ZboUQADmZTVpgBGMYwjWQSI/DOjQhG0+l6hAEYwfg1uhplAEZx93LSvUtRTDICpxiBU+djmD4Xw8xZOhNjAMYxd4pOxhmAcSwcj+O+gBG4+FslHhylI5VY+rUSy4kArGIAVuHhj/RDFQOwCo+/q2YAVmOV1r6pxvrX9FU1njACn35Bn9cwAGvw7NOaNwFYi62P6MNaBmAtXrxfi5eMwJfv1eHVu3XYfofersPOW3XYZQTu/rUee3+px/6f6U/1DMB6HPxnAwOw4dA/nZLyO3HoA1JS/umdEAKQTr5W4tS+Eqf3aFfJAFTh7LYK5wSvVDj/UoULDMCLz2lLjUubalwWPFPjCiPw6lMNrj2hdQ0DUIPrlM4ITH+sxY1HWmQ8pBVtIgBvUtYSPdAhe1GHnPs63FrQMwD1uD2nR65gVo88RmA+I7BgiiYNDEADiqiYEVg8YUTJuBGlYzRqZAAaUT5iQoVg2ATRkAniQdObADRD2meGrDdJ3mOGghGo6LIwAC1QdVigbqc2CzSMQG0rtViha7ZC32SFIRGANgagDSZBnQ3mWhssjEBrNVXZGYB22OMCBiAj0Bl1wBWhsAPukAOeRAA6GYBO+AQ+J/xeJwKMwKCbXC4GoAthh4AByAiM2tyIWcniZgC6UWnyMAA9DEAPqqlGTzoPahmBdRpSexmAXjQovW8C0IcmapaR1IcWiQ+tjMBWkZ8B6Ed7OZX5GYB+dDICu0qoOIDuogB6CgNvAjCIvjzKDTIAgxigQUbgYE4IQ9khDGfRzRADMIQ7GWEGYJgBGMbY9aRxRuAEI/DuVboSwb3LEUxeootRBmAU0+fpXJQBGMUszTEC507HMH8qhoWTdCKWCMDFY/RbnAEYx9IR+jXOAKzEiuDnSjz8qRKPfqzE4x+IEbj6XRXWvqVvqhiAVXiSCMBqBmA1Nj5PevZZNTYZgVuf0Mc1eP5RDV58SB/UMABr8eo9ereWAViLnbdr3wRgHfb+Sn+pYwDW4fWf6nDACDxgBOI/6w/9zykpvxOHPiAl5Z/eCShw8kCBU69pX8EAVOAMnWUEnt1RMgCVOP9KiQsv6YUKF+nSc9pSMQBVuPJMhasbagagGtco7Yka19fVbwJQgxuP6ZEGGZT5UIObjMCby1oGoBbZD7TIWUy6xQi8vUDzOgagDnmzOuTP6BmAehRQ4ZQeRZN0T88ANKBkgsYNDEADyqicEVjOCKwYMUI0TENGBqAREkagdID6TZD1mSDvpR4TA9AMZZcZKkGnGeoOMzTtQgBaGIAW6Fos0DcnGRiBxkZqsDIArTDXWWGppRobrGSrpiob7JU2OBiBzhhF7QxAO9zhJA8j0Bt0wBcgvwN+nwOBRAA6EaSQ24mwi5xORBiBUTvZXAxAF+KWpEpGYJXJjWojGdwMQDdqEwHoYQB6UC9Qe9Cg8qCREdikILmXAehFi5QkXgagD20CkQ/tFT50lPvQWSYEoJ8B6Ed3MRX5GYB+9DICewsC6MsPoD8vgIFcuh1gAAYxlEPZQQZgECM3BQxARuBoRghjNyg9hPHrIUykhRmAYQZgGPeu0OUwJmmKETh9kS5EMHM+gtlzkTcBGMX8aToVZQBGcf+EIIbF4zE8OBbD0m90NIblIzGsMAJXfonj4c9xPPqJfownAnD1e/quEmu0/i19U4knjMCnX1Vh40v6ogrPPq/C5mf0aTUDsBrPP6aPqhmA1XiZCMAavKLt9+jdGuy8U4NdRuDeW/S3Wuz/tRav/0J/rmUA1gF/rDv0L6ek/I4c+oCUlBQ6CTlOHchx+rUcZ/ZpT84AVODcjgLnBdsKXHilwEVG4MUXSgagEpe3lLiymXSVEXhtQ4W0p/RExQBUIX1NnXBjVY2Mx2pkPqKHagagBlnLGmQLljTIeaDBrUQAahmAWuTOa5EnmNMinxFYMKND4TRN6RiAOhTfE+hRcleP0gk9ysZpTM8ANKDijgGikSTxsAGSIWIESgeMkPUbIe9LUjAClYxAZbeJAWiCutMETQe1m6ElXRu1mqFvMcPQbIaxycIAtMDUYIG5PsnCCLQyAm01VG2FvcoKRyXFbXCSK0ZRG9wRGzxhG7whOwPQzgC0wy/w2xFgBAa9DoQ85HYwAB2IOMnhRJRidifiNrI6UWlxosrsYgC6GIAu1BiSahmBdTo36rWkcaNB7UajipQeBqAHzfKkFpkHrYzANkZgm9iLdpEXHRVU7mUA+tAlKPWhu8SHnmIfeouIEdhX4Ed/PuX5GYB+DDICBxmBQ7cCGM4JYCSbsgK4wwgczaSMIAMwiPH0pAlG4N00uhbCvashTF4JYSoRgGEGYBgzF+h8mAEYxhwjcO5sBPNnIlg4HcH9U3QygkVG4IPjdCzKAIxi+Wj0TQDG8FDwSwyPfo7h8U/ECFz9IY617+NY/46+jePJN3E8/bqSAVjJAKzEM8EXldhkBG4xArc+rcLzT6rw4uMqvPyIGIGvPqjG9vv0XjV23q3G7jv0dg0DsAb7f6O/1jAAa3AgBCAd9odTUn5nDn1ASkoKnYIMpw/otYwBKMNZRuA5RuC5XTkDUI4L23JcfEUvFbhEl1/QcwWubClwlQF47RltKJFG158qkf6EGIE31lTIWKXHKgagCjcZgVmMwKwVNQNQjZwlNW49oEUNblPufVrQMAA1yJ/ToGBWywDUopCKprUoniJGYAkjsPQuTegYgDqUUwUjsGJUD9EdPcQjNKxPBKB00ACZYMAAeb8Bij7qNTIAjVB1G6HuStJ0GqFlBGrbTQxAE/StJhhaTMkAJFMTNZphbjDDUm+Gtc7CALQwAC2wC6otcFRZ4GQEuuIUs8IdtcITETAAGYG+EAVtDEAbAn4bgj47A9DOALQjLHDbEWEERhmBMQfZHQxAByqtjmQAUrXZiRoTGZ2oNThRp3cxAF0MQBcaNEmNjMAmRmCzkhRutMjdaJWR1MMA9KBdIPagQ+RBZ4UHXYzArjIvuku96CmhYm8iAPsEhT70F/gwkO/DYB4xAodu+zF8i3L8DEA/7mQJAhi9GcBYJmUEMH4jgAkG4N3rlBbEvWtBTF6lK0FMMQKnL9OlEGYuhjB7IYS588QInD8bxsIZOh1mAIaxmAjACB7Q0nE6FsHybxGsMAJXjkQZgFE8+iWKxz/TT1Gs/hjD2g/0fQzr9OQ7YgQ+ZQRufE1fxRmAcWx+EcfW55UMwEo8/7QSLz6hjysZgJV49WEVA7AK27TzPr1XhV1G4B4jcO/tauy/VY3Xf6vGwV+JEYg/1xz6h1NSfmcOfUBKSsobpyHFmQMpzr4mRuC5PRnO78pwYSfpIiPwEiPw0ks5A1COK8/luLolUODapgJpzxS4vkFPFQxABW6sKxMy1pTIXFXi5mNiBGY9VCF7RYWc5aRbSyrcZgTeXlQzANXIW1Ajf17AAGQEFs5qUDRD0xoGoAYlk1oGoBalVHZXi/IJGtcyAHUQjdIdHcQkGdFBygiUDukZgHrIB6hfzwDUQ8kIVPVSjwHqbgM0XYY3AWiErt0IvaDNCEOrEUZGoLHZxAA0wdxogqUhycoItNVRrZkBaIaj2gxnIgAtcJE7TjELPFELvIxAX5hCVviDVgQCSUFGYMhnQ9hLHhsibhuiLjsD0I4YxR1kt6PSZkcVI7DaQmYHA9CBWqOAAcgIrNeTzokGrRONGiea1C4GoIsB6EKLIqlV7kIbI7BN6mYAutEhdqNT5H4TgB50lyX1lHrQW0KMwL4iL/oLvRgooHwvA9CLoVxfwvBtH0ZuUY4PdxiBo4zAsZuU6cd4hh8TNyg9gLt07zqlBTB5LYCpqwFMMwKnLwcxcymI2Yt0IZgIwHnBuRAWzoZw/wydDmGREfjgZBhLJ+h4GMvHwlj5jY5G8PBIBI8Ev0bw+JcIVhmBq4zAtR+jWP+Bvo8yAKN4+m0MG9/Q1zE8+yqGzS+TthiBzz+nz+J48WkcLz8hRuArRuD2h/RBJQOwErvvVWLv3SoGYBX2367C67fob1U4IDACD/u7KSm/Q4c+ICUl5X9y5kDCAJTg3L4U5wV7UlzYleLiDm3LGIAyXH4pwxXBCxmuPpfhGiMwbZOeyRmAcqQLnspxgxGYsa5A5hqtKhiACmQxArMf0UMlclaUuLVMS0oGoAq5iyrkCe6rkL+gQgEjsHCOZtUMQDWKBdNqlDACSyc1KLtHdzUMQA0qGIAiwZgW4lEtJHdoRMsA1EE2pINcMKiDYkAHZT8xAlW9eqh79NB0J2kZgbpO6jAwAA0wtBlgbKUWI0xkbqYmIyyNRlgZgLZ6qjPBXmuCQ1BjgpMR6KqiSjMD0AxPzAxvlCIW+MgfppAFgaAFQQZgyE8+KwPQiojAY0WUERhz2RB3ksOGSrsNVTay2lFNNRYy21FrsqOOEVhvIL0DDToHGrVJTYzAZjWpnGhROtGqcKJNTjIX2qUudEiSOsUudDECuyrc6C53o6fMjd5SKnGjr9iD/qKkgUIPBguIETjECBzO9WLkNt3y4k6OF6PZvoSxLB/Gb1KmDxMZPtxlBN5N9zMA/ZhM82Pqmj8ZgDRzhS4HMHspgLmLxAicPx/Ewrkg7p+lM0Esng7iwakQAzCEJVo+QcdDWGEEPmQEPjwaZgCG8fhX+iXMAIxg7acI1n9MevJDBE+/J0bgxrdRPPuGvo5i86sothIBGGMAxvDisxhefkqfxPDq4zi2P0ra+TCO3Q/o/Tj2GIH779I7lXj9diUO3qpMBOBhfzYl5Xfq0AekpKT8T85CjHOMwHOMwPP7ElzYk+DiLu1IcIkReHmbXkkZgFJcfSHFtee0JUMaXd+UIf0ZbchwgwGY8YTW5cikm2tyZK0SIzD7kQI5DxW4tZJ0mxGYywjMfaBkACqRf1+JggWBCoXzKhTNqVA8SzMqlDAAS6doUo0yKr+nRsVdYgSKxjUQj9GohgGogZRkjEDZsJYBqIVikAa0iQBUkbqPenXQ9Oig7aYuPQNQD32HHgZBux5GRqCJEWhqMTAADbA0GWBtFBhhazDCXk91RgagEc4aI1zVJgagCe5KEzyCuAleRqCPEeiLmBmAZgRCZgSDAgtCAQvCfvJZGIAWRD0WxNxWBqCVAWhFpcBhRRUjsJoRWGMliw21ZhvqTGS0o54aDKS3o1FnRxMDsFlDagdaVA60KpPaGIHtjMB2mRMdUic6JU50iUnkQneFCz3lSb1lLvQxAvsYgf3FbgwUuTFYSAVuDOV7MJyXNJLrwZ3bdMuDUUbgWDZleRmAXkxkenE3EYA+3KPJdLruw1SaD9OMwOmrfgagH7OX/Zi7RBf9mL8QwILgfAD3zwWweJYYgQ8YgUun6GSQARjEynE6FmIAhvDoaAiPBUdCWP01hDVG4NrPYaz/FMaTH+mHcCIAN76jbyMMwAg2v45g6ytBFM+/jOLFF/R5FC8/i+LVp8QI3P44hp2P6MMYAzCGvUQAxhmAcbx+J46Dt+mtOPC3ykP/bErK79ShD0hJSflfnDsQ4/xrMS4I9sW4uCfGpV1iBF7eluDKKwmuCl5KcI0RmMYIvL5Fm1IGoBQ3NgQyZDyVIfOJDDfXaU2WCMDsx3LkCB7JceuhHLdXaFnBAFQg74EC+YJFBQruK1DICCyapzklA1CJkhmBCqXTKpRNqVA+SfdUDEAVRBPqBPG4GpIxNaSj6jcBqIF8mIY0UJByUAMVI1DVr2UAaqHppR4tA1ALHSNQ30WdOgagDsZ2atMzAPUwt+hhETTrYW3Sw8YItDUYGIAGOOoMcNYKGICMQHc1VRkZgEZ440b4YiYGoAl+CkQobEIwZEKIERgOkN+MiM+MqFfAAGQExt3ksjAALahyWFBttzIArQxAK2oFFivqzFbUMwLrjTYGoA2NehuadKS1o5laNKS2o1VlR5uSFA4GoAMdMgc6pUldjMBuRmC3yImeCid6y6nMyQB0ob/EhYHipMEiF4YKiRE4nO/GSB7luhmAbowyAMdyKNuDcZrIopse3GUE3sugG14GoBdT172YTqNrPsxc9WFWcMWHucs+zDMC5xmBCxf8uH+ezvkZgH48OBPA0mk6FcAyrZykEwE8ZAQ+Oka/BRmAQaweCb4JwBDWf6afQgzAEJ7SBiNw4/swnn0Xxua39E0YW1+H8ZwR+PzLCAMwgpef02eRRABuf5K081EUu7T3ITEC99+P4fV79G4MB+/EgLdjh/7VlJTfsUMfkJKS8r84DxHOH4gYgCJc3Kc9EQNQhMuMwCs7tC1mAIpx7aUYaS8kDEAJrlP6Fm1KcOOZBBmMwMyn9ESKm5S1LkU2IzB7VcYAlOHWI3ooYwDKkMsIzFumJTkDUI6CRTkK79OCAkVUPE9zCpTMKlDKCCybpiklyqliUgnRPWIEiidUkIzTmIoBqIKMESi/QyNqKIbVUA7RoJoBqIG6XwONoE8Dba8Guh4hALUMQC0MnVoYO5JMjEBzG7XqGIA6WJt1sDVRox52cjRQvR7OOj1cjEBXjYEBaICnygCvoNIAHyPQH6OokQFoRDBsRCgRgCaEKRIgvwlRnwkxRmDcQ24zKl1mVDmTqhmBNXayWRiAFtRZLKhPBKAVDdRoJIMVTXormhmBzVobA9CGVrUNbSpS2tDOCOxQkNyOTpkdXVKSOBiADvSIHOitSOord6CfEdhf6sRAiRODxVTkZAA6MVzgwkg+5blwh0ZziRE4dsuN8RzKdjMA3bh7kzI9DEAPJmnqBqV7MM0InGEEzlzzMgC9mLtCl70MQB8WLvpw/0LS4nkfHpwjRuDSGT+WT9MpPwPQj4eJAAwwAAN4/FvS6tEA1hiB67/SL0E8+TmIpz/Rj0EGYAjPvqfvQgzAELa+CSUDkF58FcbLL+mLMF59HsY2I3D70wh2Polg92P6KMIAjGD/gygDMMoAjOLgXXoneug/TUn5nTv0ASkpKf8bFw4qcPF10qX9ClzeEwJQxAAU4eq2CNdeJaUxAq+/ECP9OW2JcWNTjAwhAClzQ4KbTyXIekLrEgagFDmrUtwSPJbi9iMpch8SIzBvWYb8JRkKHiQVMgKLGIHFCzQvR8mcHKWzAgXKZhQon1agYoomFYkAFN+lCSUkJB1XQjZGjED5HRUUIzSsgpJUjEA1I1A9oGYAqqHto141A1ADPRm6qUsDY6cGpg5q1zIAtbC0amEVtGhhYwTaGYH2Rh0DUAdnvQ6uOoEe7lo9PDVUrWcA6uFLBKCBAWhAIGpAUBAxIMQIDIcoaGQAGhH1GxHzCUyIe02o9JDbhCqXCdUMwBoH2c2otZlRJ7CaUc8IbDCTycIAtKDJYEGznnRWtFCrljRWtKmtaFcJAWhjANrQKbehS0ZSG7oZgT0SEtvRK7Kjr8L+JgAdGCh1YLCEih0YomFG4DAjcKTAiTv5lOdkADoxdtvFAHQxAF2YoLvZxAi8xwiczKQMNwPQjel0uu5hAHowe82DOcFVD+aveLDACFy45MX9i14sXqDz3kQALp2lMz4GoA8rglM+PGQEPjrhx+PjdMyP1d/8WDtKRwIMwACe/EI/BxiAAWwwAjcYgc9+CGLz+yC2vqNvg3jOCHzxNX0VYgCG8OoL+jzEAAxj51P6JIxd2vuYGIH7jMDXH0Rw8D69FwHejRz6R1NSfucOfUBKSsr/xgWU4+JBOS69pv1yBmAFruxW4KpgpwLXtiuQ9qoC11+KGIAiBqAINwRbImQwAjOfiXFzg56KGYBiZFMOIzBnTcIAlOD2Y3okSQRgHuWv0LIUBUtSFD6QomhRxgCUMQBlKBHMy1DKCCxjBJbP0LScASiHSMAIFN9TQHJXAekEjSsYgArIR5UJijtKKEeUUA3TkIoBqIJmIEnbr4KuTwU9I1Dfo2YAqmHsok41TIxAMyPQ0k5tGgagBrYWatYyALVwkLORGrRw1WvhZgS6a3UMQB281Tr4qgR6+Cv1CMQppmcA6hGK6BEOGxiABkQoGqSAATFGYJwRGPcaGYBGVLmNqHYJTKhxmlDrILuJAWhCvZUsZgagGY0mM5oERjOaGYEtjMAWnYUBaEGbhtQWBqAVHdSpJIUVXXIrumXECOyR2NArJpGNAWhDPyNwoJzK7BgstWOohIrtDEAHRgqpwMEAdGCUxhiBY4zA8dtOTNyiHCcD0Il7WS4GoIsB6MJUhgvTghsuzDACZ69TmpsB6Mb8VfebAPTg/iW66MEiPbjgwRIjcOmcF8tnvVg5Q6e9eHjKi0cnfQxAHwPQh9Vj9JsPa4zAdUbg+hE/nvzqx9Nf/Nj4mRiBz34MYPMH+j7AAAzg+bf0TRAv6OXX9FUQr74MYpsRuM0I3PkshN1PQ9j7hD4OYf+jMF5/SB+EGYBh4L3wof8zJeUfwKEPSElJ+T+4eFDGACzDZbrCCLyyV84ALMe1nXKkbZcnA5DSX9KLCgZgBTK2KpC5KWIAinCTsjZEyH5KT0QMQDFurdGqGLcp97EYeYzAvIcSBqAEBcsSFC4lFTECixfpvpQBKEXpvBRlczIGoAzlVDEjg2iapmQQT8ohuUd35ZCSbEIO+TgxAhWjCijv0IiCAaiAmhGoGaJBJbQDSuj6qU/JAFTB0KOCUdCtgqlLBTMj0NyhZgCqYW1Tw9aaZGcEOpqpScMA1MDVoHkTgFp4yFtLNVr4qrXwMwL9lToGoA7BmA4hQVSHMCMwEqaQngGoRyygR9xvYAAaUElVXvIYUO02oIYRWOM0MgCNqLMbUW8TmNDACGy0kNnEADSh2UgGMwPQjFadGW0CrRntGjM6GIEdKgsD0IIuBcktiQDsoV4pSazoE1vRLyJG4EC5DYNlVGpjANowTCOMwJEiO+4U2jFaQPl2BqAD47l028EAdOCuIMeBe4zAySwnpm5SppMB6MTMDUp3MQBdmEujay7M0wIj8P4VuuzG4iU3HlykC24GoAfL5+ishwHowUMBI/ARI/DxSTrhxepxL9aOebHOCFw/6sOTIz48/ZV+8TEAfXjGCHz2kx+bP/qx9QN978dzRuALRuDLb+jrAF59FcD2l/RFEDufB7H7GX0axB7tf0KMwNcfhXDwIX0QOvRfpqT8gzj0ASkpKf8Hl1CKywf0upQBWIare2W4JtgtQ9pOGa4zAtNf0cty3HhRjgzB83JkMgJvblYg6xltVDAAK5DDALwlWBfh9poIuav0WMQAFCP/oRgFghUxCpfFKGIAFj+gRQlK7ktQKliQoIwRWD4nRcUszUgZgFKIpwQySCZlkN6TQXaXJmSJAFSMJSlH5VDdkUM9QoxAzZAC2kEaUEBHekaggRFo6FUyAJUwdVOXkgGogoWsHdSugq1NBXsiANUMQDWcTWq4BI1quBmBnnqq0zAANfDVULUGfkZgoEqLYCXFtQxALcKJANQxAHWIhnSICYI6xBmBlX7y6RmAelR79KgRApBqXQbUOclhQL3dgAabkQFoZAAa0WQ2ollgMqKFEdhqIL2JAWhCu9b0JgDN6KQuFSnN6FaY0cMI7JFZGIAW9ElIbGEAWjDACBysoHIrhsqsGC61vglAG+4UUaGNAWjDWL7AjvE8OyZy7bh7m27ZcY8BOJlNWQ4GoAPTmUkzjMBZRuBcOl13Yj7NiYVrdNXFAHRh8TJdcuEBLTEClxiBy+fdWDlHZ90MQDcenfbg8Sk66cHqCQ/WjietMwKf/EZHvXh6xIuNX+kXIQB92PzJh60f6Qcfnn/vw4vv/AxAPwPQj1eCr/3Y/sqPHUbgzhcB7H4ewN5n9GkgEYCvPw7i4CP6MAh8EDz0X6ak/IM49AEpKSn/F5cPSnCFrjICr+6XMgBLkbZbius7tF2GdLrxil6WMQDLkPm8DDe3yhmA5cii7GflyNkgRuCtJxW4vU5rFQzACuRRPiMw/5GIAShC4YoIRcu0JEYxlTygRTEDUIyyBTHK5yUMQAkqSDRLMxKIGYESRqB0ku5JGYBSyAWMQMW4DMoxGVSjdEeWCEDNcJJ2SA7doBz6AepXMAAVMPYmmXoUMHcrYGEEWjqVDEAlbO3UpoSdEehoVcHZQs0qBqAK7kZqUDMA1fCSr45q1fAzAgOMwECVhgGoQSiuQTgm0CIS1SIaobCWAahFPEgBHQNQhyqq9pFXhxpGYK2bXHoGoB71DrLr0cAIbLQZ0GQli4EBaEBLIgCNDEAj2vRJ7TojOhiBnRpSmxiAJnQrSWFiAJrRK5CZ0Sc1o19ixoBYCEALA9CCoXIqszAALRgpsSbcKbZitMiKsUIqsGKcETiRR7k2BqAN924J7JjMsWMq247pLLppx0ymHbMZDgaggwHowPz1pAVG4H1G4P2rTixeceLBZSeWLtFFF5YvuLByns658PCsC48EjMDHp91YPUUn3Vg74cZ6IgA9DEAPnh71YOMI/erBs1+82BT87MXWT148/5F+8OIFI/Dld/StjwHow/bXvjcB6MfuF37sfU6f+bFPrxmBrz8J4ODjAPBR4ND/mJLyD+TQB6SkpPxfXEHxmwAswbX9EqTtJV3fLUE6IzB9u5QBWIqMl6XIfCFgADICs7bKkL1Jz8oYgGW49bQ84faTcuSulyNvrfxNAFag4FEFCgUPK1C0UoFiRmDxkogBKELpoghl95PKGYEV82KI5mhWDPGMGJJpSYJ0SgLZpATye3RXAsWEFMpxGpNCRepRKTSMQM2IDNphGXRDNChjAMpgYAQa+6lPDlOvHOYe6pYzABWwkq2TOhSwtyvgYAQ6WpUMQCVczdSkhJs8jEBvA9WrGIAq+GupRs0AVCNIoSqqVCMcVyPCCIxENQxADWJhDeICRmAlI7AqQH4tA1CLGi95dAxAHeqo3kVOHRocOjQyAhttegagHs0WMuvRwghsNRnQZiSDAe16Azp0pDUyAI3oUid1q4zoYQT2MgJ75Sb0yUzol5LExAA0Y1CUNFRhxnC5GSNlxAi8U2LBaDEVWRiAFowLAUgT+VbczaNcK+7dtmKSETiVQ9k2BqANMzeTZhmBcxl0w475dDsWrttxP83BAHRg8aoDD67QZQeWaJkRuHzRiZULTjw8T+ecDEAnHp9xMQBdDEAX1k66sH6CjrvxhJ4eo9/c2DjqxrMjxAjc/MWDrZ/pJw8D0IMXDMCX39N3Xrz61ottwTde7DACd7+iL33Y+8KH/c/pMx8D0I+DT+hj/6F/MSXlH8yhD0hJSfl/uHpQjGuC18VI2y/G9b1ipO/STglubJcgQ/CqBJkvS3CTEZj1nLZKGYClyKFbz4gRePtpGXKf0HoZA7AM+YzAglV6XM4ALEfRw3IUr9ByBUqodIkeVKBssQLlDMCKBZoXMQBFEAtmRZAwAqXTYsimaFLMABRDwQhUMAKVExKoxiVQj9GohAEohXYkSTcshX5ICsMgMQKN/TKY+qhXBjNZGIFWRqC1S84AlMPeQe1yBqACTnK1UosC7mYFPIkAVDIAlfDVJ/nrlAgwAoM1VK1iAKoQrlQlA5CiMTViUYqoGYBqVIY0DEANA1CDar8GNQKfBrWMwDoPubUMQC0anNpkAFKTXYdmG1l1aLHo0MoIbDXpGYB6tBuSOhiBnYzALi1pDOhWG9CjIqWRAWhEnzypX2bEgNSIQUbgoNiEIZEJwxVUbkoE4J3SpNESM8aKqciMcUbgRIEFd/Mpz4J7uRZM3hZYMXXLiukcyrZiJsuKWQbgXCZl2DB/w4aFdLpuw31G4GIaXbPjwVU7lq7Y3wSgAysX6YKDAejAo3MOPBYCkFbPOLF2mk45sX7SiSeMwCfHXQxAFzZ+o6OuRABu/urG1i9Jz39248VPxAh8+YMHr76n7zwMQA92vqGvvQxAL/a+pC+8DEAvXjMCDxiBB5/6gE98h/7DlJR/MIc+ICUl5f/hKooYgEVIe12E6/u0V4R0RuANRuCNnWIGYDEyXxXj5kt6UYIsyn5egpwt2ixhAJbg9kYpA7AUuZT3pBT568QILFgtQ+HjMhQ9Sip+WIYSRmDJcjkDsBxlD8pRviioQMX9CogWaL6CAVgByWwFpDMiBqAIMpJP0aSIASiG8q4YqgkaFzMAxdAIGIHaOxLoRiTQD9OQJBGARsGAFKZ+Kcx9Ulh6qUfGAJTB1pVk75TBwQh0MgKdbXIGoBzuFmqWw8MI9DYp4GukBgX89QoE6qhWyQBUIkThaqpSIsIIjMYppmIAqhCPUFiFSkZgVUiN6iAF1AxANWoTAahhAGpQL3Br0ODSoJER2OQgu5YBqEWLlSxatDIC28xk0qHdqEOHQYdOvZ4BqGcA6tGtSepR69HLCOxVGtCnMKBfbsCAzPAmAI0YEicNi4wYqSBG4J0yE0ZLTRgroWITxotMmCg0J9wtMONePuWZMckInGIETt+iHAtmsi2YzaKbVszRfCZlWLFww4r76cQIXEyz4cE1G5au0hUbli/bsSK4ZMfDi3Y8ukDn7XjMCFw9S2ccDEAH1k853gSgE09p4zgdc+LZb05sMgI3j7iw9asLz3+hn10MQBde/uhmALoZgG5sf5e0wwjcZQTufU1febD/pQevvyBG4MFnXuBT76F/MCXlH9ChD0hJSfkvSEMh0g4Kcf11IdL3iRF4Y7cIGTtFyBRsF+HmqyJkMQKzX9DzYgZgMW5tChiAjMDcjRLkPaUnJQzAEhSslaJQsFqKoselKH5U+iYAy1C6XIYywVIZyh+UoYIRKLpPC+UQz5dDImAEShmBspkKyKdpqgKKyQoo74kSVHdFUE+IoBmnMRG0o2Lo7tCIGHoyDIthZAQaByUwDUhg7qc+CSxkZQTaeqhbCnuXFI5O6pAxAGVwCdpkcLfK4GmRwcsI9DbJGYBy+BuoXo4ABRmBoVqqUTAAFYhUUaWSAahEjOIxiipRGVGiihFYFVIxAFWoCSTVMgLrfGrUe8mjRoNbjUYXOTUMQA2aBXYNWmwatDIC2xiBbWYt2k1adBjJoEUnI7BLTzodurU69Gh06FWTSo8+pR79CpLrMUCDjMBBqQFDEgOGxQaMiKjCgDvlRoyWJY2VGjFeQozACUbg3UIqMDEATZjMM2Eq15wwfduMmVuUY8ZsthlzjMC5mxYGoAULGRbcv2FJBOAiPbhOaVYsXbNi+SoxAlcu2/DwEl20MQBteHyeztmxSmtn7Vg/Q6fteMIIfHqSTjgYgA48O0a/ORiATmwdoV+deE4vfnHi5c/ECHz1owvbP9D3Lux858Lut24GoJsB6Mb+V/SlG6/pgBF48Lnn0L+XkvIP6tAHpKSk/BekoQDXDwqQ/pr2C3CDEZixR7uFDMBC3NwuRFYiAIuQTTkvinDrOW0V4TYjMPcZbRQjj/KfFqPgCTECC9dKULRaguLH9KgEJYzA0oe0UsoALEX5UikqHtBiGUQkvk8LZQzAMkjnyiGbpZlyyEkxTVPlUDICVfcqoL5LExUMwApoGYFaRqBuVAT9HREMIzQsYgCKYRpMMg+IYekXw5oIQAkDUAJ7N3VJ4CAnI9DVQe1SuNuk8LRSi5QBKINP0CSDv1GGQIMMwUQAyhmAcoRrkiLVckQZgbFKiisYgApURhXJAKTqsBI1IQoqURtQos6vYgCqGIAqNHiSGhmBTYzAZic51Gixq9FqI6uGAahBu8CsQYdJg06jBl2MwC69Ft06LXq0pNGilxHYxwjsU+nQr9RhQKHDoJxkegxJ9RiWJI2I9bjDCLzDCBwtN2CsjEoNDEADJoqNuFuUdK/QiMkCyjdiihE4nUu3TQxAE2ZzTJhLBKAZ87RwkzLNuJ9hxiIjcDHdwgC0YCmNrlkYgBasXLEmPLxsxaNLVjy+SIzAVUbg2jk6a2MA2vDkNJ2yMwDt2DiR9Oy4HZuMwC1G4NZRB54fceDFr/SLIxGAr36iH50MQCd2vk/aZQTufUvfuLD/tQuvv3LhIBGAbuBz96F/LyXlH9ShD0hJSfkvuo58pB/k48ZrYgRm7BUgc7cAN3eSshiB2a8KkfOSXhQyAAtxe0tQhNzNIuQ9K0L+Bj0tSgRg4XoxigRrxSheLUbJY2IElj4sQdlKCcqXkyqWSiBiBIoWSxmApZAslEI6LyiDbK4M8lmaKWMAlkE5VQbVZDkDsBxq0tyliXIGYAV0YxXQj9KdChjIOEKMQNOQCOZBESwD1C9iAIphE/SKYe8Rw9EthrOLOiUMQAnc7UmeNgm8jEAfI9DXLIW/SYpAIzVIEWQEhuplCNdRrQyRGhmiiQCUMwDliAviclTG5KhiBFZHKKxgACpQG6SAAnWMwHo/+ZRo8CrR6FGiya1iAKoYgCq0CBwqtNpVaGMEtlnVDEA1OsxqdJrUyQCkbgPpNejRadCrJUZgn1qLfpUWA0pSaDFIQ4zAIZkOw1IdRiQk1jEA9Rit0GOsnMr0GKeJUmIE3i024F4RFRoYgAZMMQCn8yjXiBmavU23jJhjBM5nU5aJAWjC/UzKMDEAzXiQbsaS4LoZy2lmrDACVxiBD69Y8OgyXbIwAC1YvWBlAFqxRuvn6KwVT85Y8ZQRuHGKTtrw7IQNm8fpmJ0BaMfzo3TEjhf08ldiBL762YHtn+hHB3Z+cGCXAbj3HX3rxP43Trz+mr5yMgBdAB3251JS/oEd+oCUlJT/H9IP8hiAecjYz0emYC8fN3fzkbWTj+ztAgZgAQOwALcELwpw+3kBchmBeZv0rJABWIgCKmQEFj4pYgAWoXiNVosYgEUoZQSWPaKHxShfKUbFcjFEiQAsgXixBBLB/RJIF0ogYwTK52i2FIqZUigFjEAVI1A9WQbNPbpbBu1EGXTj5Qn6sXIYRsthvFOeCEDTcAXMQ0mWwQpYBypgYwTa+kSw94rg6KFuEZzkYgS6OsVwd4jhaRfD20atEgagBH5BswSBJgmCjRKEGIGheikDUIpIbVKUERirliFeRZUyVMZlqIpRVM4AlKNGEJajNiRHXVCOekZgvV+BBp8Cjd6kJkZgs5tcSgagEq0OJdrsZFOh3apCh8CiQqdZhS5GYJdRzQBUo0evRq+OtGr0MQL7NaTWYEClwaBS8yYAtRiWaTEiJYkWd2iUETgq0mGsQofxcirTMQB1uFuiZwDqGYB6TNJUITECp/MNmMmjXAMD0IC5W5RjZAAasUD3s+h/sFtXvdUl2Jamf2d3HUjOiPjIjJuZGb3NzMzMzMzMzGyPGss71FKpq6sr82SmpYp18dyPizmlV56JHUbgLiNwV5LFAMzCfhIlZjEAs3EYH3YUl43jWIrJxgkj8DQqB2eRFJGD8x85uPgIwFwGYC6uvoRd/5KLG0bgzU95uP1rHu7+kof7P9Of8vDwx3w8/oF+n4+n3+XjWcAIfPmPArz+O/1bAd7+WwHe/29iBH72r4lE/4f79AEikehvIIEWUkaglBEoe9VB/qKD4pmedFAyAlWPeqgf6F4PzZ0e2lu6MUBH+msDDFd0aWAAGmE6N8J8FmY5NcJ6IgSgiQFogv3QBMdBmJMR6NqjXTMD0AzPthneLYEFvk0L/Bu0bmEAWhBctSJlhZatCFHqEi1akcYITJ+3IWOOZm0MQBuyGIFZ03ZkT9mRM2lH7gSN2xmADuQLRh0oGHGgcNiBoo8AdKJ4wImS/rDSPifKGIFlPS4GoAsVXS5UdrrCAUjV7dTmRk2rG7UtbtQ1exiAHgagBw0NYY31HjQxAptrqcaLlmovWqu84QCk9goq96GjzIfOUh+6SvwMQD+6i/zoKQzrZQT2MQL78gIMwAAGcgIYzKasIIYygxgWZAQxkh7EaJoQgCkMwBSMp6RgIkiBFEwyAqf85Ath2hvCjIfcIQZgKuac5EhlAKZigRYZgYuMwCVLGpbNZEpjAKZh1ZDOAExnAKZjnTa0xAjcZARuqUiZwQDMwI6cZJkMwEzsScL2kzNxkESMwMOELBzFZ+E4jmKzcMIAPI2mqGyc0XkkRWTjghF4+Z2+5eDqaw6uv+Tg5hf6ORe3P+Xi7q/0l1zc0wMj8IER+PjHPDz9gX6fxwDMw8t/5jMA8xmA+Xj7t3y8/7f8jwDE/1Xw6b8mEv0f7tMHiESiv5H0XQvZmxZywasWihctlM9aqBiBqkcdA1AHjeBeBy0jUMcI1N/QtZ4BqIfxUg8TI9B0YYD53ADLGZ0aGIBG2I6NsAuOjHAcGuE8oH0TA9AE964JHsGOCV5GoI8R6Ns0MwDNCKybEVwTWJCyakFohZYtDEAL0hYtSF+wfsiYtyJzjmatDEAbsqdtyJmiSRtyKW+CGIH5Y3YUjNpROELDdgagA8WCQQdKBhwo7XegrI96nSjvcaKiO6yyy4kqRmB1B7W7UNPmQm0rtbhQxwisb6YmNxoa3WhscKPpIwA9DEAPWgQ1HrRWe9DGCGyr9DIAvego96KzzBsOQOouoWIfeop86C2kAj8D0I/+PD8GcsMGc/wYYgQOZQUYgAGMZFB6gAEYxFhqEOOCUBATKUFMBokROOVPwbSPvCkMwBTMMgLnGIFzrhDmnSEsOMgeYgCmYslKllQGYCpWaNVEjMA1QxrW9aRLYwCmYVOTzgBMZwCmY1sZtqNIxy4jcE9G0gzsSzJwkJzxEYCHiZk4SqD4TBzTSRwxAk9jsnAWTVFZDMAsXERk4fJHNgMwG1ffsnH9NeyGEXjLCLz9OQd3P+Xg/q/0lxwGYC4e/0R/zGUA5uL597l4+Z0gD6//mYe3/6B/z8P7v+UBjMDP/jGR6Dfg0weIRKK/kQwayN41DEANFK8aKF804QAk9RM9ahmAWmjvtdDd6RiAOujJcKOD8ZqudAxAPcwXdK6HhaxnetgYgbYTAwPQAMeRAc5DOjDAxQh079OekQFohHfHCN+2iQFogp8Cm7RhQnDdhBRGYGiVVsxIpbRlYgSmMwIzFizInKc5C7JmLchmBGbPWJEzbUXulBV5k9aPAMwft6FgLKxw1IaiEWIEFg/ZUTJoR+kA9dtRxggsZwSW9zpQ0eNAZbcDVV3U6WQAOlEjaHeits2JulYn6hmB9c0uNDS50NgY1sQIbK6nOjcD0I3WGjfaqqnKg/ZKDzoEFR50lnvQxQjsKvUyAL3oKfait4gKvehjBPYXUL4PA3k+DOZSjo8B6Mdwlh8jgkw/RjP8GGMEjqUFGIABTIQoJcAADGAqEMS0wB/EjC+IWS8xAufcKZh3kTOFAZiCRQEjcMkWwrI1hBULmUMfAbhmJEMqAzAVG7qwTUbgliYN22pSpWFHmYZdBcnTGYDp2JeGHUjSccgIPEzKwFFiBo4TKD6DAZiB09hMnMVQdCbOozJxIWAEXjICr37Q9yxcf8vCzVf6ks0AzMbdz9m4/4n+mo0HemQEPv45B09/ysHzH+kPOXhhBL4yAl//M5cBmIv3f6d/y/30/xKJfiM+fYBIJPo7yN/VULyFKV/VUDEC1c/0pIHmUQPtQ5iOEai/08JwSzdaBqAWJgagWXCpg+VCB+s5nekYgHrYT/RwCI71cB7p4TokRqB73wDPngHe3TAfI9C/TVtGBqARwQ0jUoQApNCaCamrtGJiAJqQvmRGxiItmJFJWfM0Z2YAWpAzY0HuNE1ZkEf5jMD8CSsKxq0oHLOiaJRGrCgetqFEMGRD6aANZQPECCzvs6Oi147KnrCqbjuqGYHVnQ4GoAO17Q7UtTnCAUgNLdTsRGOTE02NTjQ3uBiALrTUudBaG9bGCGxnBLZXuRmAbnRWuNFVTmUedFNPKZV40FvsQV8RMQL7C7wYyPdiMC9siBE4zAgczvYxAH0YzaQMHwPQj/E0PyYEqX5MhvyYYgROMQKnAwHM+MkXYAAGMOcJfph3B7HgCmLRGfwIwCV7CpZtZE1hAKZg1SwIYc0UwroxhA0D6UPY1IWwpU1lAKYyAFOxowrbZQTuMQL35GnYl6XhQEqSNAZgOo6S0nGcSAnpOKFTRuApI/AsNgPnMRSdwQDMwGVkJgMwkwGYievvmbj5FnbLCLz7Qr9k4f7nLDz8lPVrAGbj6c/0p2wGYDZe/kC/z8Ervf0uB+//Sf+RA/x7zqf/lkj0G/HpA0Qi0d9BDhUU7yoo31RQvdKLmgGohkbwpIb2UQ3dgxr6ew0DUMMA1MBIphtiBJqvtLBc0oWWAaiFjeyMQPupjgGog/OYjnQfAegmzwHt6+Hd08O3SzsGBqABgS0DgoJNA1IYgaF1WjMyAI1IWzEiXcAIzFgyIXORFkwMQBOyGYA5s2G5M2bkTdOUmQFoQcGEBYXjYUVjFhSPEiOwZNiK0iErygZpwIpyRmBFP/XZUNlrQ1WPDdXd1GVHTacdtYIOO+ra7ahnBNa3OhiADjQ2O9DURI0ONDMCWxqo3onWOifaaqnGxQB0oaPKhU5BpQtdFS50MwK7y9wMQDd6S6jY/RGA/TRQSAUeDOZ7MJRHuV4GoBcj2ZTlxSiNMQLHGYHj6T4GoA+TqRTyMQD9mA6GzQT8mPX7MecjRuC8J4AFN7kCDMAAlhzBD8v2IFZsQaxayRLEGiNw3UTGFAZgCjb1AgYgI3BbS5oQdtQh7KpC2FOmMgBTsS9PxYGMpKk4pCNG4FFyGo6T0nCSSAlpDMB0nMVRbDoDMB0X0em4FDACryIzcB1BPzJw8z0Dtx8BmMkAzMT9L/RzJgMwE49/zfrw9JcsPP85Cy9/oj9m4ZUR+PZ7+l02AzAb+I/sT/8rkeg35NMHiESiv5PyXckAVEJFakag+kXFAFRB+6SC7lEVDkAy3KthvKNbNQNQDfO1hgGogYWslxrYLjS/BqAWjlMtnCdhrmMt3IxA96GOAaiDd18H316YnxEY2KFtPQNQj5RNPUIbBgagAamUtkarBgagARnLRmQu0aIRWZS9QIzAnDkTcmdNyJuhaRPyp0woYAQWTJpROGFG0TiNmT8CsGTEgtLhsLIhC8oHiRFY0W9FZZ8VVb3UY0U1I7CGEVjTZWMA2lDXYUN9O7XZ0dBqR6OgxY6mZjuam4QAdDAAHWitd6CtLqydEdhRQ9VOBqATXZVU4WQAutBT5kKvoNSFvhIX+hmB/UVuBqAbgwWU72YAujHMCBzJpRwPRrM9GMuiTC8D0IuJdErzYpKmUr2YZgROp/gwE/RhNkB+HwPQh3mv/8OCx49FN7n8WGIELjsCWLGTLcAADGDNIghi3RzEhomMQWwagthiBG7rSJuCHU0KdtVhe4zAfSUpQjiQh3AoC/0agKk4TqakVAZgKk4TUnHGCDyLT8N5XBouYikmjQGYhquodAZgOgMwHTc/6Hs6bhmBd98ycP+VvmTg4ZcMPP5MjMCnv2bi+S/050wGYCZePwIwC2/0/nv6Xdan/5NI9Bvz6QNEItHfSQkFVO8KqN/oVQnNixJawbMSuicl9IxAwwPdqxiAKpjIfEuMQMu1GtYrulQzANWwn2vgEJxp4DzVwHVCxxoGoBaeQy28ggMtfPta+D8CUMcA1CG4rUOKYEuHECMwdYPW9QxAPdJX9chYERiQuWxA1hItGhiABuTMG5E7F5Y3a0T+DE0LAWhC4aQJRRM0bkIxlTACS0bNKB0xo2yYhswMQDMqBiyoFPRbUNVnQXUvMQJruq2o7bKirjOsvsOKBkZgQ5uNAWhDU4sNzc3UZEcLtTZSgx1t9Xa011GtgwHoQGe1A11VYd2MwB5GYE+5kwHoRF8plTgZgC4M0GARFbowVODCcL4QgG4GoBujOZTtxhiNMwInMinDg8l0D6bSKNXDAPRiJiVsNujFXIAYgfOMwAWvD4secvuw5PJh2en/sOLwY9VONj/WGIHrjMANM5kC2DQGsGUgfRDbtKMjbRC7miD2PgIwhQGYggMFyVMYgCk4YgQeS0kSwklyCKdJlBhiAKbiPJ7iUhmAqbiMETAAGYHXUWm4iaSINNz+SMMdI/DuWzoDMB0PX+iX9I8AfBL8lIHnv2bg5S/05wy8MgLf/piJ9z/Q7zOB32V++j+JRL8xnz5AJBL9F6je5VCThhGoeVUwABXQPSugf6JHJQxkfFDCdE93SgagEpYbFQNQBSvZrlSwXxIj0HGuhvOMTtUMQDXc5GEEeo40DEANfAe0r2EAahGg4C7taBmAWoS2aFPHANQhjdLXaU2HDEZgJiMwc1nPANQje1GPHAEjMHfegLw5mjUwAA0omDaicCqsaNKI4gkaNzIATSgdNaFsJKx82IQKRmAFI7BywIyqfjOq+6jXjBpGYG0PdVtQ12VBfSd1WBiAVjS2WdEkaLWiucWKFkZgS5ONAWhDWwPV2xiANnQwAjtrqcaOrmo7uquo0sEAdKC3PKyvzIH+UgcGGIEDxU4GoBNDhVTgZAC6MCLIc2E014WxHBfGsynLzQB0YzKD0t2YomlG4DQjcCbkwWyKB3NBCngw7/diwRe26PViyUOMwGVG4IrTh1UH2X1Ys/mwbvUzAP3YoE0zmfzYMvqxzQjc1gcYgAHsagPY05A6iH06UJEyiENFEEdyYgQeS1NwIqHkFAZgCs4YgWeMwPOEEC7iQ7iMo9gQrhiB19EUlcoATMVtBP1IxR0j8P47fUvDw9c0PH4hRuDTz+l4/ikdL3+lv6Tj9c/pePtTBgMwA++EP2R8+h+JRL9Bnz5AJBL9F6gh+zUA5dC+yqF7CdM/y2FgBBof6UHBAFTAfCdgADICrTdK2K7pSskAVMJxoYJTcK6C60wF96nq1wBUw3ukhk9wqIb/QI0AIzCwp2EAapCyo0FoW6BFKiMwbZM2tAxALTLWtMhc1X3IWtEhe5mWdAxAHXIX9Mibpzk98qlglhiBhdMGFE3RpIEBaEDJuAGljMDSMSPKRo0oH6FhIwPQhMpBE6oEAyZU95tQ00eMwNoeM+q6zajvok4zGhiBjYzAxnYLA9CC5lZqsTAArWhtsqJN0GhFe4MVHfVCANoYgDZ01VC1Dd3UwwjsraQKO/rK7egvs/8agA4MFocNFTkwXOjACCNwJN+J0TwnxnIpx8kAdGKCETiR5cJkpgtTGS5Mp1OaGzOpbsyGKMWNOZoPEiNwwe/Boo+8HgagB8tuL1Zc5PRildYcZPdinRG4YSWLjwHow5bJh20jGfzYoV096fzY0/qxzwjcVwcYgAEcKkkRYAAGcMwIPJYFcSIN4lQSxFkyMQLPE1NwkUDxKQzAFFzFCkK4jgnhJpqiQriNDOGOEXjPCLz/noqHb6l4/EpfUvH0Sxqefw57+SkNr3+lv6ThjRH4/if6Y/qn/5BI9Bv16QNEItF/keZdBq3gTQbdqwz6FxkMz/QkZwDKYSLzA93LYWEEWm/pRsEAVMBOjitiBDovlHCd05mSAaiEhxHoPaFjFQNQBf8hHagYgGoEKWWPdtUI7aiRyghM3dIwADVI39AgQ7CuQSYjMGuVVrQMQC1ylrTIZQTmMgLzFnTIn6c5HQNQh8IZPYqmw4qn9CiZpAk9A9CAsjEaNTAADaigSkZg5ZCRAWhE9QD1Gz8CsLbXhDpBjwn13SY0dBEjsLHDjKZ2M5rbwlpazWhlBLY2WxiAFrQ3UoOFAWhFJ3XVUa0V3TVW9FRTlY0BaENfBZXb0E8DjMDBUiqxY6jYjuEiKrQzAB0YFeQ7MJbnwHiuAxM5QgA6MZnlxFQmZTgxTTOMwJk0F2ZTXZgLUYrrIwAXAm4s+snnxhIte4kRuOL2YNVFTg8D0IN1uwcbNi8D0ItN2rKQ2YttRuAOI3DH4GMA+rCnI62PAejHgUDtx6HKjyOlH8cKIQADOJEFcColSYABGMB5UvDDRWIQlwkUH8QVI/CaEXgTQ9EpuI1KwV0kRYQYgCE8CL6H8PgthKevxAh8/iUVLz/TT6kMwFS8MQDf/0x/SgP+mPbp/yMS/UZ9+gCRSPRfpIGUASiF7k0K/Su9SGEgIyPQ9ESPMgagDJZ7upPDSrZbOew3dC1nAMrhvFQwABVwkftcAc8ZMQK9J0r4julICT8FDpUIMgKD+yoGoAqhXdpRIZURmLatRvoWbaoZgGpkrtOahgGoQTblrNCyhgGoRd4iLWgZgFoUzGlRKGAEFs3oUDxNUzoGoA6lDMAywbge5WN6VIzSiJ4BaEDVkAHVg2E1AwbUMgJr+4wMQCPqe6jbyAA0opER2NRJHSY0t5vQ0mb6NQDNaGsOa28yo6PRjE5GYGe9hQFoQXct1VgYgBb0MgJ7q6zoq7Siv8KKgXIqszEAbRgqCRsutmGkiBiBowV2jOXbMZ5HuXYGoAOTgmwHprIcmM6kDAcD0InZNCfmUinkxDwtMAIXgi4sBlxY8pPPxQB0YcXjxqqbXG6s0bqTGIEbjMBNG1k9DEAPts1k8jIAvdilPQPpvdhnBB4wAg80PhyqfThSkdLHAPTjRB52KvPjTEoSP84ZgRdJAVwmUkIAV/EBXMcFGYBB3NBtDEUHcRcVxD0j8D4ihQGYgsfv9C3lIwCfv4Tw8kvY688hvP1EjMD3v6QCf0799N8RiX7DPn2ASCT6B9BBAt27BPo3CQyvEhg/AlDKAJTCLHiUwvIghZURaLujWxkDUAbHtQxORqCTEei6lMN9QedyBqAc3lMFfIITBfzHCgSOFL8GoBIp+0qEBHtKpO4qkcYITNtWMQBVyNhUIVPACMxiBGav0aqaAahG7rIaeUuaD/mLGhQs0LzmIwCLZmlGywDUooRKp4gRWDahQ/k4jekYgDpUUhUjsGpYj+ohPWoGaUDPADSgrs+AekGvAQ09BjR2EyOwqdOI5g5qNzIAjWhlBLa1UosJ7c0mdDRRo4kBaEZXfVh3nRk9tWb01ggBaEFflQX9lVRhwQANMgIHy6wYKrViuMSKkWLrRwCOFtowVhA2nm/DRB4xAidz7JjKtmM6izLtmGEAzgrSHZhLc2A+lUIOBqATi0EKOBmATiz7nFgRMAJXPS6sucnlYgC6sOFwMwDdDEA3tmjbShY3dhiBuyYyehiAHuzrSedlAHpxKNB4caT24lhFjMAThQ+nch/OZCT14Vziw0Wy/8Nlkh9XiZTgxzUj8CaOYgMMwADuogO4j6LIIB4igngU/Aji6XsQz4zA568pePmSgtdf6OcUBmAK3v8aYgCGPv1nRKLfuE8fIBKJ/gF0SIb+PRmGN3pNhpERaHqRwPxMTxJYHiWwPtC9FDay30nhuKUbKQNQBtcVXcrgJs+FDN5zYgT6TuXwn9CxnAEoR5ARmHJIBwoGoAKpe7SrYAAqkU4Z27SlZAAqkbWhYgCqGIAq5FDuKq2okMcIzF+iRTUDUI3CeTWKGIFFcxoUz2pQMkPTGgagBmWTWgagFuVUMa5F5Zj21wDUoXqYhnQMQB1qqY4RWNevZwDq0dBLPXoGoB5NXQY0CzoNaOkwoLWdGIFtrUa0t1CzER3UyQjsYgR2NZjQXW9CTx3VmhiAZvQJqs3orzJjoNKMwQoqt2CozILhUiqxYIRGGYGjRVaMFVoxXmDFRD7lWTGZa8NUTth0tg0zWcQInM2wYy6d0uwMQDsWQnYsMgIXUxxYCjqwHCC/4yMAV73kcTIAnVinDRcxAjcdLmzZyeZiALqw8xGAbgagG3sCoxv7BjcOGIEHOg8D0IMjjQfHalJ5cKL04lQRdib34lxGjMALRuBlMiX5GIA+XCf4cBPvZwD6cUt3sRTjxz0j8IER+BAZYAAG8PSDvgcYgEG8fKUvQQZgEG/0zgh8ZwTirymf/jMi0W/cpw8QiUT/IHokwfCeBONbEkyMQNNLMgMwGZanMOtjMmyMQPs93UkYgBI4bwRSuK6lcF9J4bmkCykDUArfmeyD/1SGwIkMwWNiBKYcyhE6oH05UiltT470XQUDUMEAVCBzizYVyGIEZm8okbNOa0oGoBJ5K7SsYgCqUECFi7SgYgCqUTxHs2oGoBqlVDZNjMDySQ0qJmhcwwDUoGpUi2rBiBY1w1rUDtGglgGoQ30/9enQQI29OjQxApsYgc1derR0UoeeAahHGyOwrc2A9lYDOloM6GymJiMD0IjuhrCeeiN664gR2FdjQn+1CQNVVGn6CMAhQbkZw2VmjJRSiZkBaMFYkQXjhWETBRZM5hMjcCrXiukcyrYyAK2YzbRhTpBhw3y6DQtplGpjANqxlEJBOwPQjhW/HauMwFWfA2teB9Y95HYwAB3YdDoZgE4GoBPbtrAdRuCuxYU9M5lc2De6cGAgvRuHOjeOtGHHGjdOGIEnjMBTpQdnCpJ7GIAeXEi9uJRQshdXdJ1EjMAbRuBtPMX5GIA+3MdQtJ8B6MdjZNhThB/PP/x4YQS+fAvg9WsAb1/olwADMAj8FPz0XxGJRJ8/QCQS/QMZ3xMZgIkMwCSYBS9JsDwnwfqUBNtHACYzAJPhIOcd3SbDxQh0X9OVhAEogZd8jEAfI9B/JkXglE6kDEApUhiBoSM6lCH1QIa0fdmvAShHxo4cmYJtObK25MhmBGZvKBiACuSuKZAnYATmMwILlmlJyQBUomiB5lUoppI5FUpnaUb1EYDlUzSpRgVVTqhRNU6MwOpRDWpGaFjDANSgjhFYzwisH9CioV+Lxj7q1TIAdWjuDmvp0qG1U4e2DmIEtrfp0dFKLXp0UhcjsKvJgO5GA3oaDOitpzoD+mqN6K8JG6g2YrCKGIFDFSYMl5swUkalJozSGCNwrNiM8SIzJgqpwPwRgFN5Fkznhs3kWDCbTYzAuUwr5jMo3coAtGJRCEBaCtmwnGLDSpACNgagHWs+8toZgHZsuAUMQEbgltOBbQfZHdixObBrdTIAnQxAJ/ZNYQdGJw4ZgYd6F450LhxrSeNiALpxqnLjTBl2rnDjQk6MwEupB1cSSvYwAD24SfQyAL0MQC/u6D6OYr14YAQ+RlOUD0+RPjxH0A8fA9CP12/01c8A9ONdwAj87B8RiUQfPn2ASCT6BzIiAab3BJgZgebXRFheEmF9pqdE2BiB9sckOB7oPokBmATXLd0kw02e62R4r+gymQEogf+cziQIUPBUgpQTYgSGjqRIPaQDKdIonRGYsUe7MgagDFnbtCVDNiMwZ1OO3A1alzMA5chfVTAAFQxABQqpaIkWFShmBJbM05ySAahE2YxAhfJpFSqmVKicpAkVA1CF6jH1h5pRNWpH1KgbJkZg/aAGDQPUr0EjNfVp0MwIbO7RoqVbi9Yu6tR+BGC7oF2HjjYdOlt16GqhZj26m/ToaaQGPXqpr54Ygf21BgzUGDBYTVUGDFUaMSyoMGKk3IjRMuOvAWjCeLEJE0VUaMIkTTECp/LNmM4zYyaXcswMQDPmsiwMQAvmaSHDgsV0YgQupVqxHKIUKwPQitWAwIY1vw3rPhs2vOSxYZMRuOUip50BaMeOPWyXEbhnJYsD+2YHDkyOXwPQiSO9E8e6sBOtE6eMwFO1C2cqF86VpHB9BOCljKRuBqAb13STTIzA20QP7hIo3sMA9OAhlmK8DEAvnqLCniO9eGEEvjACX7/78PbNh/ev9MUH/OL/9B8RiUQfPn2ASCT6BzO9xzMAE2ARvCbA+pIA23MC7IxA+2MiAzARTsF9IlyMQDcj0HND10kMwCT4LgXJ8F8kI3CejOAZnSYzAJMROpZ8SD2SIO1QgvQD2pcyAKXI3A3L2pEie1uKHEZgzqaMAShD3jqtyZDPCCxYlaNwhZblDEA5ihdpQYESKp1XoGyOZhUoZwRWTNOUkgGoRBVVTxAjsGZMhdpRGlExAFWoH1J/aBhUo3FAjaZ+6lMzADVo6aFuDVqprYsYge0dWnS0a9HZRq1aBqAW3YzA7mYdepp06G2kBt1HAPbX6TFQGzZYo8dQNTEChysNGKmgcgMD0ICxUiPGBSVGTBQbMVlEhUYGoAnT+ZRnYgCaMEtzjMA5RuB8lhkLmZRhZgCasZRmYQBasEwrIQtWUyhowRojcN1PPisD0IpNj8CGLbcN2y5y2rDjsGHXbsOezc4AtGPfYseBOeyQEXhkJIMDx3oHTnSkdTAAnThTk8rJAHTigi4ZgZdyF65kLlxLSeJiALpwm+RmALoZgG7cx4c9MAIfGYGPMR48RXvwHOXBSyRFePH6w4u37/TNywD0AozAz/4NkUj0//j0ASKR6B/MDAYgI9DyFg/razxsL/QcDzsj0PGUAOcjPSTAdZ8A9x3dJsJD3ptE+K7pKhF+RmDggs6TEKSUsySEGIEhRmDqcTLSjugwmQGYjAxGYOY+7UmQtStB9o7k1wCUIpfyNmlDivx1KQoYgQWrMgagDEWCZRmKGYEljMDSBZqXMwDlKJ8VKFAxo0DltAJVUzSp+AjAmnEaU6KW6kaVqB8hRmDDkAqNgzSgYgCq0MwIbGYEtvSq0dqjRls3danR3qlBR0dYZ7sGXW3UKgSgFj3NWvQ2UaMWfdTPCOyv12GgTofBWqrRMQB1GK7SY6QybLRCj7FyYgSOlxowUULFBgagAVOFBkwzAqcLjJjJN2I2j3KNDEAT5rMpy4QFWsykDBOWGIHLaWaspFLIzAA0Y+0jAC1Ypw0/+SzY9FqwxQjcdpPLih2nFbsOAQOQEbhvI6sNBxYbDs1ksjMA7Tg2kN7OALTjlBF4xgg80zhwrnbgQkVKBwPQiSs5yZwMQCduBBInbhmBd0ku3CdSggsP8S48xrkZgG48xbjxHE1RbrzQKyPwNcKDtx8evH+nb55P/wuRSPQ/+PQBIpHon8DyHgfrW5jtNQ72lzg4GIGOp3gGYDxcD2FuRqCHEei9pZsEBmAC/FeCRAQuExG8SETKOZ0lMgCTkHoSlnachPSjJGQcEiMwcz8ZWXu0m4xsymEE5m7TloQBKEH+Bq1LUMAILFyTomiVVqQoXpaiZEnGAJQxAGUoE8zLUD4nQwUjsHKGpuUMQDmqBYzAmgkFascVqBujUQUDUIGGYeWHxiElmgaVaB4gRmBLnwqtvdSjQhu1dxMjsKNTjc4ONbraqU2N7lYNegQtGvQ2a9DXRI0aBqAWA/VaDNZRrRZDNMwIHGYEjlTpMFpJFToGoA7jZXpMCEr1mCzRY6qYivQMQANmCijfwAA0YE7ACJzPMWIh24jFLMo0YokBuJxOaSas0GoqhUxYYwSuB83YCJDfjE2fGVte8liwTTtuclmw67RgjxG4Z7cyAK04sJLFygC04ogReGwiow0nBhtO9cQIPNPaca4htZ0BaMelgBF4pXDgWu7AjYykDtwyAO+SKcnJAHTiISHskRH4FEexLjzHuPAS7fo1AN14i3Dj/Qd9dwPf3J/+EyKR6H/w6QNEItE/gQWxsL7HwvYWC/srvcQyAOPgFDzFwfUYB/dDHDz38QzAeAZgPHyCm3j4r+MRYAQGL+kigQGYgJCAEZh6moi0k0SkH9NR4kcAZgoOkpC1n4TsvSTk7NJOMgMwGXlbYfmbySjYSEYhI7BwTcIAlKB4JayEEVi6JEXZIi1IUT4vRcUczcpQSVUzMlRP05QMNZNy1E7QuBx1VD9Go3I0MAIbhxVoGqJBBQNQgRZGYEu/Eq19SrT1Uo+SAahER5cKnZ1hXR0qdLcTI7CnVY3eFmpWMwDV6G9UY4ARONCgwWC9BkN1VKthAGoxUk1VWozSWKUW4xXECJwo02GylEp0DEAdpoUApJlCPWYL9JjLpzw95nMNWMihbAMD0IAlASNwOcOIlXQjVtMo1Yi1kBHrKSYGoAkbtBkgvwlbjMBtRuC2x8wANGPXZcaekxwW7NOBnWwWHFotOLIQI/DYZMWJkQxWBqAVZ4zAM50N51obLjQ2XKpJZcOV0o5rBcntDEA7bqUCB+4kDtwnU5IDD4kOPCZQvJMB6MRzrBMvMRTtxCsj8C2KIl14j3ABP1yf/g8ikej/5dMHiESifxLbewwDMAZ2cjACnYxA53MsXE+xcD/SQyw8jEDvfRx8d3QbB/9NHAIfARiPIKVcxiN0QefxSD1LQNopnSQgnTKOE5B5RIeJyDpIRPY+7SUih3IZgXk7tJ2E/K0kFGwm/RqAySgSrCWjeDUZJSvJKF2WMAAlDEAJygULElQwAisZgVWzNCNlAEpRMyWQoXZShroJGerHaUyGBgZg4wgNy9FEzUM0KGcAKtDar0BbH/Uq0N6jQAcjsIMR2NmlRFcndSgZgEr0tKnQ2xrW16JCfzM1CQGoxmAD1asZgGoM0wgjcKRGg9FqDcaqqFLzEYAT5VSmxSRNlWoxXUKMwJkiHWYLqUDHANRhPk+gx0KuHos5lK1nAOqxnGnASgalGxiABqwJUg1YZwRupFDQyAA0YstvxLbPxAA0YYd2PeQ2Yc9lwj4jcN9hZgCacWgjq/kjAI8FZgtOTBacGi04MxAj8FxnxYWWNFYGoBVXjMArRuC10oYbBcltuJXZcMcIvJdQsh0PSXY8Jto/AvCJnuMpzoGXWAdeY4gR+BblxHskRTg//Q9EItH/1KcPEIlE/yQ2RMP+Hg3HG73GMABj4BI8x8D9FAPPYwy8jEDvfSwDMBZ+wW0sAozA4HUcUq7oMo4BGIfUc0E80s7ikX4aj4wTOo7/CMCsw7DsgwTk7Ccgd492ExmAicjfDivYSkQhI7Bog9aTULyWhJJVWklCKSOwbJmWkhmAyahYSEblvIQBKEEVVc/SjAQ10xLUMgLrJmlCygCUokHACGwclaFpRIbmYRqSoWVQhtYB+Ye2fjna+6hXzgBUoLNbga4u6lSgm3o6iBHY26ZEXyu1KBmASgw0qTAoaFRhqEGF4XqqUzEA1RitoWo1A1CNcZpgBE5UaDBZrsFUGZVqGIAazBRrP8wWaTFXSAVazDMCFxiBi7mUo8NStg7LAkbgSqYeqxmUrmcA6rGeqsdGyMAANGCTtoIUMGCbEbjjI6+RAWjEntv4awCacCBwmHBoN+HIZsIxI/DYYsaJ2YxTExnNDEAzzvWWDxc6Cy61pLEwAK24VllxoySFFbdyK+5kAhvupTY8SCjZhsckG54YgU8JdgagHS9xFGtnANrxxgh8j6YoBxDp+PQ/EIlE/1OfPkAkEv0T2d+j4CAnI9D5Gs0AjIb7ORqeJ3qMhpcR6Hug+xgGYAwCtzEI3sQyAGORQqEruoxF6kUs0hiB6Wd0GscAjEOmgBGYdRSP7MN45BzQfjwDMB55jMC83QTk7ySgYDsBhVu0mcgATESxYD0RJWuJKGUEljECy5aTUL6UhIrFsEpGYNV8MqrnaDYZNTPJqJ2mKQnqqH6SJiQMQAkax6RoGqURKZqpZZiGpGhlBLYNUL+MAShDR68MnYzAzh45urrl6O6iTjkDUI7edgUDUIE+6m9VYKCFGIGDTUoMNVKDkgGoxEidQIXRWhXGalQYr6YqFQNQjckKKldjiqbLqFSNGUbgbLEGc0VUqMF8gQYL+doPi3laLOVSjpYBqMVKlg6rmZShw1q6DusCRuAGI3AzRCl6BqAe2wHyGxiABuzSnpc8BuwzAg9c5DTi0GHEkZ1sRgagCSeWsFOzCWcmYgSeMwIv9GZc6khrxpXGjGu15cONyoJbJSksuJNbcM8IvJdaGYBWPCZTkhVPjMDnRBteEijehtc4G95iiRH4Hm0Houyffv8ikej/06cPEIlE/0QORML5Tm9RcL1Gwf0S5nmOgvcpCj5GoO8hGv77aATuwoKMwJSbGISu6SoGqZcxSBMCkNLPY5FxFovMUzqJRdZxHLKPwnIO45B7EIe8fSEA45G/G4+CHdqORyEVMQKLNhMYgAkoWU9A6RqtJqBsNRHlK7SciIqlRFQuJqJqIYkBmMQATEKNYDYJtYzAOkZg/RRNJqNhIhmN4wIJmsYkaB6lEQkDUIJWBmDbYFj7gBQd/dQnZQDK0NVD3TIGoAw9nTL0MgJ7GYF97XL0t1GrnAEox2CzggGowBANNyow0kCMwFFG4Fgt1SgZgEpMCBiBk5UqTFWoMF1OZSrMMABnS6hYjTmaL6JCNRYYgYv5lKdhAGqwnKPBihCAtJqlxVomZWgZgFpspOkYgDoGoA5bKTpsC4I67DACd/3k0zMA9dj3kNvAADTg0Bl25DDg2E6MwBOrEacWI87MZDLi3GjChSHsUm/ClY60JlwzAm/UpDIzAM24U5hxLwQgPcgseJSSxIKnZAueGYHPiVYGoBWv8RRn/QjAd0GM7dNvXyQS/S99+gCRSPRP5nyPgIsR6HqLhPs1Ep6XSHifI38NwCj4BQ9RCNxHIXgXhZTbaAZgNAMwGqmCq2ikMQLTL2KQcU5nMQzAGGQJGIHZx7HIOYpF7iEdxDIA45Av2ItDwW4cCnfiULRNW/Eo3oxHyUZY6Xo8ytaEAExgACagYjkBlUthVYzA6gWaT2QAJqJ2NhF1M0kMwCTUU8MUTSahcSIJTYzA5jEaTUbLSDJaBYzAtiEJ2gdpQMIAlKCzT4KuXumH7h4perqpS8oAlKGvg9plDEAZBmiwlRiBQ81yDDdRo5wBKMdoveLDWJ0C47UKTNRQtQKTVUpMVVKFkgGoxIyAEThbqsJcCRWrGIAqLBSqsFig/rCUr8ZyHuWqscIIXM2mLA0DUIP1DA02BIzAzTQttlIppGUAarHzEYA6BqAOe76wfa8OB4zAA7cehy49jpx6HDvIrseJzYBTa9iZxYBzMzECL4xGXBpIb2QAGnHNALzRhN2qTbhTkdKEe0bgg5xkZgagGU8SSjYzAC14ESRa8JpgwVu8Be+MwPdYKxBj/fS7F4lE/0ufPkAkEv2TOfGDARgB91sEPK/0EgEv+RiBvqdIBmAkAg+RCN7TXSRSGIGhW7qJYgBGIe0qCumX0QzAaGRQ5jmdRTMAo5F9EoOcYzqKQS7lHRIjMH8/FgV7sSjcpZ1YFFExI7B4Kw4lm3Eo3YhD2TqtxaN8NR4VgpV4VC7Ho2opHtWLCQzABNTMJ6B2LqyOEVg/Q9OJDMBENE4mokkIQGoeT0LLGI0mMQCT0DaczABMZgAmo4M6B6g/GV2MwO5e6pEwACXo7RJI0dcpRX+HFAPt1CZlAEox1CJjAMowTCNN1CjDKCNwrF6O8TqqlTMA5ZisFigwVaXAdCVVKBiACsyWKTFXSiVKzNNCMRUpscgIXCqgfBUDUIWVXBVWc9Qf1rLVWM+iTDUDUI3NdA0DUMMA1GA7FLbDCNwNarEXIL8W+z4tDrzk0eHQrcORK+zYqcMJI/CEEXhq0+PMShY9A1CPC5MBl8awK4MB13piBN5ojbjVkNrIADTiXkkKEwPQhEeBzIQnqQnPjMAXRuBLkhmviWa8JVC8mQFoAWItn37zIpHo/9enDxCJRP8Cbkag+/0HPG8/4H39Ad8LPUfA/xSBgOAxAsGHCKTcRyDECAzdRiL1JhJp12HpjMCMyyhkXtB5FLLOopB9KohGzkk0co+jkXdEh9HIP4hBwX5Y4V4MinZjfg3AWJRsxaJ0M6xsIxbljMDytTgGYBwqV+JQtRwXDkCqWaSFeNTOx6NuLh71swkMwAQ0TCegUTCVgKbJBDRPJDIAExmAiWgdTUSbgBHYPpyEjiEaTGIAJqHrIwCT0U09vcno7aHuZPQxAvs7qUPCAJRgsE3AAGQEDrdIMdJMTVKMNkox1iBjAMowThN1VCvDJCNwihE4XUWVcsxUyDErYATOlSkwX0olCgagAosfAahkACqxTCv5lKfEKiNwLYeyVQxAFTYyVeEApK10NbbTKFWNnZAauykaBqCGAajBvp98GhwwAg8ZgYceLY7cWhy7yKllAOpwatfhzBZ2btXhwkKMwEuTHldGMugZgHrc6AwMQANu6U5jwL2aVAY8MAIfFSQ34klmxLOUJCYGoAmvgiQT3hJNeE8gRuBn37pIJPrf8ukDRCLRv4Ab3+F5/w7vG71+h4/8jED/8w8G4A8EH38g5YHufyDECEy9o9sIpN1EIP06AhlXkQzASGRS1gWdRyKbEZjDCMw9oeMoBmAU8gWMwIKDaBTuR6Noj3ajUbwTgxLBdgxKt2JQtkkbMQzAWFSsxaJSsBqLqpVYVDMCq5fiGIBxqF2IQ918WD0jsGGWZuIZgPFomopH80cAJqCFWsdpLIEBmID2kUQGYCIDMBGdg4noEjACu/uT0NNHvUkMwCT0dVNXMvppoDMZgx3UnowhRuBwK7VIGIASjAqaJBhjBI43SDFRT3VSTNZKMVUj+zBdLcNMFVXKGIAyzJXLGYByBqAcCyVyLAoYgUtFCiwXUoGCAajAah7lKhmASqzTRjZlKbHJCNzKoHQVA1CFnVQKqbDLCNxLoaAa+wE1DvzECDz0anDk0eDYHXbi0uCUEXjq0OLMrsW5jazajwC8NJNJhyu6NupwYyBG4K1OjzstafQMQD0eVKQ0MAANeBLIDXiWGfDCCHyRGBmARrwlGfGeaPwIQMSbPv3WRSLR/5ZPHyASif5FPPgG7/s3+N7o9RsD8DsCz98RfApLefyO0IMQgD8YgD+QdvsD6TdhGYzAzCu6jGAARiD7PAI5Z5Efck8jkXdCx5EMwEgUHEah8ID2o1BExXvECCzZiUbpdjTKtmgzGuVUwQisWI9hAMagajUG1Su0HIuapVjUChZjUbcQi/p5motjAMahcSYOTYLpODQzAlsmaSKeARiPtjEajUc7I7BjJAGdwzSUwABMQPdAIgMwkQGYiF5BbyL6GIH9jMCBLupMYgAmYahdkIzhtmSMtFJLMgMwGWNNyRhvlDAAJZigyXqqk2CKEThdQ9VSBqAUs5VSzFUIZJgvl2GhjEplDEAZlorlDEA5A1COFVotoHw51hiB67mUo2AAKrCZRZlKbNF2BqUrsZOmxG6qEnuMwL0UFfaDKhwEyK/CISPwyEdeNY49apy4yaVmAGpw5iC7hgGowQVdMgIvLVpcmbW4NpFRywDU4lavYwDqGIA63As0OjwwAh8ZgY9KPQNQj2e5Hi8ykhrwKjHgLTnsPckAMAI/+8ZFItH/tk8fIBKJ/oV8718ZgF/hf/2KACMw8PINwedvSHn6htAjPXxH6v13pAnuviP99jsybr4j8/oHA/AHsi5/IFtw8QM5jMDcswjkndJJBPKPI1AgYAQWHkai6ID2IxmAkSjZjULpTljZdhTKt2gzigEYjcr1aFSthVWvRqOGEVizHMMAjEHdYgzqF2I+ArCBGudoNpYBGIvmaZqKYwDGoZXaJmg8Du2MwA5GYMdIPAMwHl1DYd2MwJ6BBPT2U18C+noT0N9D3YkYoMEu6kzEUEcihhmBI23UmoTRliSMCRiB44zAiUZqSGYAJmOqLhnTtRIGoAQzNFtNVRLMMQLnGYHz5VIGoBSLpWFLjMDlYhlWiqhQxgCUYe0jAOUMQDk2BDlybGbLscUI3M6kDAV20hXYTVOEA5D2Q5SixEFQicMAMQKPfCoce8mjYgCqcMoIPGMEnjnVOHeocWEnm5oBqMGVhcwaBqAGNwJG4C0j8E6vxb2OtFo8aLR4VOsYgDo8KXV4Fih0eJHr8MoIfJXq8SbR4z2ZkvSfftsikehv8ukDRCLRv5APX+B/p7cvDMCvCL58RcozPX1FiFIZgakP3xiA35B+9w0Zt3TzDZmMwKxruvrOAPyOnIvvyD3/wQD8gTzKP6WTHwzAHyg8ikDRIR1EoJhK9okRWLobibId2o5kAEaighFYyQis3IhC1XoUqtdoNYoBGI3a5WjUCZaiUb8YjQZGYMN8DAMwBk2zMWieCWthBLZO0WQsAzAW7eM0FocO6hyNQ9cIDceheygOPYPxDMB4BmA8+gR98ehnBA4wAge7qSsBQ50JGO4QJGKkPRGjbdSayABMxHhzEiaaqDEJkw1JmBLUJ2GaEThTSzXJDMBkzFVRpQTztFAhwWI5lUmwVCrBcomUAShlAEqxWhi2xghcz5dhI49yZdjMkWErm7LkDEA5dgQZcuymy7HHCNxLVTAAFThIoaCCAajAESPw2E8+JU68Spx6iBF45lLh3EkOFQNQhUsBI/DKqsa1RY0bM5nUuDVqcGcgvYYBqMGDQKvBIyPwSU0qLQNQixeF9tcA1OFNqsO7JAzJuk+/bZFI9Df59AEikehfzP/+CwJvvyDICAy+fkHKyxeEnunpCwPwK9IeviJdcP8VGXdfkXlLjMCs62/IvvqGnMuwXEZg3jmdfWcAfkfByXcUCgFIRUc/UHxIBz8YgD9QuheBst2w8p0IVGwTI7ByMxJVG5GoXqe1SNRQLSOwdiWKARiF+iVajGIARqORmuZpLhrNs9FomaHpGAZgDNomw9onYtDBCOwco9FYBmAsuodpKBY9jMDeQRqIYwDGob8vDgO98QzAeAZgPIYEXfEY7ozHCCNwpD2BAZiAsdYEjLcIEjHRnIjJJmpMZAAmYvojAJMYgEmYpbkaqk7CPCNwoZIqkhmAyVgqo9JkLDMCV0okWC2mIgnWCiVYL5AyAKUMQCk2c8O2cqTYZgRuZ8kYgDLsZsiwl05pcuynynEgCMlxmCLHUZAYgcd+BU585FUwABU4YwSeuZU4dylx4VTi0kF2Ja5sKlxbyaJiAKpwK2AE3hnVuDeQXs0AVONRSxoNA1CDZ5UGL8qwV0bgm5xkWrxLtYBE++k3LRKJ/mafPkAkEv2LBfAzAu8/MwB/QcrrLwi90PMvSKU0RmDa4xcG4Bdk3H9B5h3dfkEWIzD7hq6/IufqK3IvvyLv4hsD8BvyqeCMTr+hkBFYdExH3xmA31Fy8B2lAkZg2d4PlO/Szg8G4A9UbkWgSrAZgeqNCNSs01oEAzASdSuRqBcsR6JhKRKNjMDGhSgGYBSa52g2Ci3Uyghsm6apaLRPRqNjgsZjGIAx6BKMxqB7JAY9jMBeRmDvYCz6BmLR3x82wAgc7KWeOAZgHIa74jDyEYDxGKWxdmqLx3hrPCYYgRPNCQzABEw1JmBa0JCAmfpEzNZRbSIDMBHz1VSVxABMwqKgIglL5UlYZgSuMAJXSpIZgMlYK6LCZKwzAjcKKF+CzTwJtnIl2P4IQCl2sqTYFWRKsZchxT4jcD9NxgCU4TBEKbKPADwOhJ345Tj1yXHmJUbguVuBCxc5FQxABa4YgVeMwGubEjdWsigZgErcmVS4N5JBhQe9Co86gRpPjMBnDanVeFGp8aokhYYBqMG7jKSaT79nkUj0d/n0ASKR6BMEGYApb2Gh15+R+kLPPzMAf0H64y/IeAjLvP8FWXfECMy++YKc6y/IvQrLYwTmX9D5VwbgVxSefkXRybcPxcffUHJEh98YgN9Qtv+dAfidAfgdFVS5Q4zAqq0fqN6kjR8MwB+opTpGYN1qBAMwAg3LtBTBAIxE00IkmgXzkWiZi0TrRwBGMQCj0D4V1jEZhU5GYNc4jUWjezQaPSM0HINe6huiwRj0D8RgoD8Gg32xDMBYDPXEYljQHYsRRuBoJ3XEMQDjMN4Wh4lWQTwmW+Ix1UxN8QzAeMx8BGACAzABc7Vh8zUJWGAELlZRZSKWKhKxXE5lSVih1VIqScJacRLWi5KwwQjcKEjGZn4ytvLCthmBOzmULWEASrCXSRkSBqAUB2lhh6lSHIWkOGYEHgdlOAnIcOonn4wBKMO5R/7hwi3HpYuccgagAtd2BW5sZFXg1qLAnVmgxL1JiQcjGZR41CvxxAh80qoYgCq8qEmlwiu9MQLfFSRXAzL1p9+ySCT6u3z6AJFI9AmC+CtS3n9C6I1ef2IA/oS05//Obn11Jbqg3Rr+Y/vrFSqac84Jc9aKK3T37hxWzpWrLHPOWVFUEBUTiIABEwYQFUUwMPd8oX/B/rqbqjXeg+t8jvE8B3cWnjMCnzuz8cKRjZfnZM92B+Dr0xy8EdhyUHGSg7fHdJTLAMxF1WEuqgWWXNQwAmsPaD+PAZiH+t08NAgYgY07+Wjapq18BmA+WjYK0Gr0aFsvQPtawb8CsBCdBtIXoou6dYXoYQT2aIsYgEXo05C6iAFYjAHBQjEG54sxNFeM4VlSlTAASzAimC7B6FQJZIxA2WQpA7AU4/JSTEx4yBmBijGSlTEAy6AcIWk5A7Ac0zQzRIPlUA2UY5YRONt3jwF4D/M91H0PC4zAxa77UHdSx31o2u9jqY1aHzAAH2BZ0PwAuqYH0DMCDQ1U/xArdQ+xWvvQE4C0Xk1Vj2CsfISNt1TxmAH4GFuvH2P7lcfOy8cwMQJNzz/B7rNPsPeUnnzCAPwUBz97mH/6FJYf6YdPccgItH73GY6+pW8+w/HXn+Hkq8/dbF9+jtMv6J+f4+wfn8POCLT/7bcMwN/C8Rf682/hZARe/Ol3uPwj/eF3uPq/v8P17+l3v2cA/h74/Pde/2ORSPT/zesDRCKRlzxxZTIAM/GUnl3RZSYDMAsvnFl46aDzLLyi14zA12fZDMBsVNiy8faEjrNRyQisOiJrDgMwBzUWMucyAHNRR/X7tJfLAMxFoymPAZjHAMxDM7VsESOwdSMfbUZaz2cA5qNjtQCdgpUCdBkK0K0nXQEDsBC9Wo++pUL0awoxwAgcWCzC4EIRhuZprgjDJGUESlXFDMBijE4XQzZFyhKMTZZgXKAowYS8BPIJGi9lAJZiUlYK5ajHFCNwWkrDZQzAMqgGy/4VgOWYo/k+6i3HQk85FhmBi133GID3oOnwWGIEahmB2tb7DMD70DXfh76JGh8wAB9gRVD/AKt1D7BWSzUPGYAPYax6iI1KevsQm4zArQp68wjbrx9h59WjfwXgY+w+p2ePsUf7T4kRePDLJzD//AksP9GPn+CQAWj93uPou09x/C198ylOGIG2r+jLzxiAn+Hsn5/BLgQgnf/9czj+Rn/9HM6/fI4LRuDFn37LAPwtrv5A//e3uGYEuhiBrt/9zuv/KxKJ/le8PkAkEnnJE0jw1EXXEgagBM8vJXjBCHxxkYmXzky8ctB5JgMwC2/OslAhOM3CW1sWKk+EAMxmAGaj2pqNmkOPWkZgnZkOchiAOWjYo90cNDICm0y5aN6h7VwGYC5aN/MYgHloo3ZjHjrWiRHYuZqPrhUy5DMA89FDvYzA3uUC9GkL0L9EmgIGYCEGBYuFGFooxPB8IaRzNFuEEVURRmc8ZNNFGGMEjimLGYDFmFAUQy4vdgeggibHaawESlkJpkZppJQBWIqZ4VKoBEOlmGUEzg1QfxkDsAwLvdRThkVGoLqbusqh6SzHUkc5tO33GID3sNx6D7oWD33zPRgYgYbG+wzA+1itv4+1uvvuAFwnYw1VP8BG1QNsVhIjcKviIbbf0OuH2CETI9D08hF2XzzC3vNH2H9GTx/h4MljmH/xsPz8GIc/ESPQ+sMnOPqevvuEAfgJTr75BLavP3U7/epTnH1JX3wKOyPw/B/0988YgJ/B+Vf6y2cMwM9xKfjT57j64+e4/sPncDECXb//LfC733r9f0Ui0f+K1weIRCIveurKwDN6fk1XGQxACV5ekFPCAJTgNb1hBL6xZzIAM/H2lGyZDMBMVJ1kofqYjrJQY81C7SFZshmA2ag/yEaDYD8bjYzAJkZgkymHAZiDlu0ctAoYgW2buWjfIGMuAzAXnWt5bl2reeheyUOPgfR5DMB89C2TNh/9NLBEjMBBdQGGFgswvEDzBe4AHBHMFmJUVQjZDE0XMgCLMK4swoRgsghyRREUjEDFRDEDsBjKMZIVY4qmGYEzIyQtYQCWYHaIBksZgKWYF/SXYqGvFIu9pVAzAtXdZdB0lWGpkzrKoGUELrdTWzl0reXQt5TD0ExN97DSeA+rgoZ7WKu/h3VG4HrtfQbgfWxUU9V9BuB9bDECt99SxQPsvHkA02t69RC7Lx9i7wU9f4h9OmAEHjACzU8ewfIL/fyIAfgI1h8f4+gHj+PvH+PkO/r2MWyMwNOv6atPGICfwP4F/fNTBuCncAj+/imcf/sUF3/9FJeMwMs/f4arP32G6z/SHz5jAH4OkLf/ViQS/a95fYBIJPKiZ0hnAKYzANPx4iodLy8z3F5dZOC1kxwZDEAJKuwSvD3zqDyVoMomBGAmAzATNUdkzUQt1TEC6y1kzmIAZqFxn/ay0UTNu9loMdFONgMwG21bOQzAHAZgDjqo00iMwK61XHSv0kouAzAXvQJGYJ8uD/3LeRjQ0lIeBjX5GFJ7DC/mQ7pAjMCRuQKMzhZApqKZAozROCNwfKqQAVgI+SQpChmARZgk5QSNF2FqrAjTMhotZgAWQyWl4WLM0hwjcH6QBkqw0F+CxT7qLWEAlkIj6C7FUlcptJ3ECFxuL4OurQz6Vg8DI3CFEbjSVM4ALMdaA9WXMwDvwVh7DxuCmnvYrL6HrSohAO8zAO9jp4Le3GcA3scuI3D31QPsvXyA/Rf0/AED8AHMTx/C8oR+eYhDsv5MjMCjHx/h+Af6/hED8BFs7gB8zAB8jDOyf0VfPsY5I9DxT/rHJ3D+/RNc/O2TfwXgp7gS/PlTXP/pU7j+SIxAb/+sSCT6t/D6AJFI5GXPXWl4IbhOw0tG4KtLukhnAKbjjSMdFYzAivMMvLVnoPKMTjMYgBJUn0hQIziWoPZIgjorHWYyADPRYPZoPMhEEyOweY92sxiAWWjdETAAGYHtW9no2KSNbAZgNrrWcxiAOeimntUc9K6QIQd9+lz062g5FwM0qCVG4JAmD8PqPEgXaSEPI/P5GBXM5UM2m48xFc3kMwALMDFVALnSQzFZgElG4KS8kAFYiKlxGitkABZihhGoGqWRIsxKizA3TEPFDMBiLAx4LPYXQ80IVDMCNT0lWOougbaLOkuwzAjUdVB7KfRtpTC0UksZA7AMq01lWGv0WG8og5ERaKwrZwCWY7OGqssZgPewLai8h52392CqoDf3GID3sffqPvZf0ov7OCAzI9DMCLQ8fYDDJ/TLAwbgAxz99JAB+JAB+BAnZPueGIGn3z7C2Tf09SMG4COcf0lfPGYAPoZT8I/HuPj7Y1wyAi//+gkD8BNc//kTuP5Ef/wE+MOnXv9XkUj0b+H1ASKRyMueI5UBmIqX7gBMYwCm4TW9uSBnGgMwHW/PyZ7OAExHFVUzAqttGQzADNQe01EGAzAD9YzAhkOySNBolqDpgPYzGYCZaKHWXTJlom0nE+3bWQzALAZgFjoFG1noYgR2r2ejZ41WsxmA2egTApD69TkY0NFyDgMwB0NLuRjWkDoXUhpZJEbg6HweZHM0m8cAzMM4TTACJ6bzIZ/Kh0JJk/kMwAIo5R5TEwWYHi/AzJgQgIUMwELMjpC0EHM0zwicHyrCwmARFgeKoO6nvmJoeouxJOgphra7GMtdxAjUdZRA314CQxu1lmCFEbjaQs2lWGsqxXojNZQyAMuwUeexWVuGrZoybDMCt6vKsVNZDtNbqijH7pty7DEC917fw/6rezh4SS/uMQDvw/KMnt5nAN6HlY5+IUbg8U8PcPIj/fCAAfgAp989ZAA+ZAA+hF3w9UOcMwIdjEDHF48YgI9w8Y9HuPw7/e0xrv76GNeCvzyG68+PgT899vqvikSifxuvDxCJRO+Al0jBS0bgq+tUvL6iy1QGYCoqnKl4ywh860hD5Xkaqux0lsYATEeNjU7SUUt1x+moPyJGYMNhBhotZM5AEzUzAlv2aU/CAJSgzSTxBCB1bGeic4s2M9G1kYluYxYDMAs91LtGq1noYwT2G7IxoCddNgaXszEkYAQOL+VAqiF1DgMwB6MLuZDNe4zN5WJ8llS5DMA8yKdpKg8KmlTmQckIVCryMSXPx/QEjeczAAugEsgKMDtagLmRAsxLabgQC0OFWBykgUKoScMI1PQVMQCLoO2h7iIGYBF0ncXQCzqKYWgvxkobMQJXW0qw1kxNJVgnY2MJNhiBG/Wl2KwrxVYt1ZQyAMuwU+VhqizD7luqEAKwHPuv6VU5A7Ac5hflsDACLc/v4fDZPVif0pN77gA8/pl+us8AvA/bDx6njMCz7x7A/i198wDnXz+A4yv68iGcXzzEheCfD3H5j4e4YgRe/e0RA/ARXH+hPz/y+o+KRKJ/K68PEIlE74CXSMYrVwoDMIUBmII3VHFJFykMwFRUOug8lQGYimqqYQTWnKah1paGuhM6TmMApqGBEdhgTUfjYTqaLOloNtNBBgMwA617Hm27GWhnBHbs0LaEAShB16ZHNyOwx5iJ3nVay0Tfaib6V7LcBgxZGNSTLssdgMPabEiXSJONERpVEyNQtpCDsXmay2EA5mBClQM5I1A+kwvFdC4mp0iZywDMw5SC5HmYppmJPKgYgaqxfMzK8jE3SiP5DMB8LDACF4YLsDhUAPUgDRQwAAux1FcIba/Hck8hdN3ECNR3FsHQQe1FDMAirDIC11qppRjrzcUwNhX/KwBLsFlPdSXYou1aYgTuVJfCVEWVpQzAUuxVlGH/jcfB6zKYX9HLMgZgOQ6f07NyBmA5jp4I7uH4l3s4+fkebD/Rj/dw+sM9nH1/nwF4nwF4H+eCb+7DwQh0MgKdXz5gAD7A5T/pHw8YgA9x/beHcAn++hD4y0Ov/6hIJPq38voAkUj0jnjFCHztSsaba7pKZgAm4+0FOVNQSVWOFFSfkz2FAZiK2lOypaKO6k9S0XAsBGAaGq1paDokSxqaqYUR2HpA++lo20tH+y6ZMhiAGegUbGegaysD3ZsZ6NmQMAAlDEAJ+gRrEvQzAgdWyJDJAMzEkC4Tw8uCLEi1WRhZIk0WAzALssVsBmA2xmh8PhsTczQrBGAOFDM0ncMAzIFSwAicmszFtCIXM3KayGUA5mF2zGNOlof5URrJYwDmY3E4H+ohGsyHhpYYgUv9BdD2FWC5l3oK3AGo7yqEQdBZiJWOQqy2EyNwrbUI6y3UXMQALMIGI3CjsRibDcXYqi/Gdh3VFmOnpgSmao/dqhLsVRIjcL+iFAdv6HUpA7AUlpeCMhy+KIP1eRmOntHTMhwzAk9+oZ/LGYDlOP3R44wRaP+evrvHALwHxzf09X0G4H1cfHkfl194XP3zPq4Zgdd/f8AAfAD89YHXf1MkEv3beX2ASCR6h7x2JTEAk1BxlYS3AkZgJSOwykmOZAZgMmrsghTUnqWg7jQF9TY6SWEApqLxyKPJmormw1S0WMicxgBMQ9u+R/teGjoYgZ0m2klH13Y6urdoMx09jMDeDTJmMAAz0L+WgYFVCQNQgkEaMpBegmFGoJQRKNVmMgAzMarJhEzACBxbzML4As1nMQCzIJ/NdlOosjE5kw3lNE1lY0qZg+lJUuRghlRyYgTOjudibiwX8zIazcXCSC4WGYGL0jyoh/OgGaLBPAZgPrT91JePZdL15kPPCNR3FzAAC7DSSR0FDMACrLUVuq23FsLYUoiNZmIEbjYWYauB6ouwTTt1xAg01RRjt5qqihmAxdh/W8IALMEBmd+UwPKaXpXgkBFofUHPSxmApTh+KijDyZMy2H6hn8tw+lMZzhiA9h/o+3Kcf1cOx7ceTkbgxdf01T1cfnkPV1/c+1cA3ofr7/S3+17/SZFI9B/h9QEikegd8gaJqHDRdSIDMBGVl3SRxABMQjXVOOg8CbWMwLozOk1mACajQcAIbDxOQdNRCpqtdJjCAExBKyOw1ZyKtoNUtO+nomOPdtMYgGnoEuykoXs7DT1baehlBPZupKPPmI5+wXo6BhiBg6u0ksEAzMCwPgNSncRtZFmCUS0tSRiAEoypMxmAmQzATEyQfJ4YgYrZLEyqaCaLAZiFKUbgFCNwWpmNmclsqBQkz8bsRA7mxj3mx3KwIKPRHAZgLtRSGs5lAOZiibSMQO1AHpb786Dro948BmA+DN3UlY8VWu3Mx1oHMQLX2wpgbKWWAgZgATYZgZtNhdhqLMR2A9UXMgALYaotYgAWMQCLsEf7VcQIPHhbDHMFvSlmABbj0B2AJbDS0Qt6XoLjZyU4YQTantAvpTj9uRRnPwnKYP+xDOc/0PdlcHxXBue39E05A7Acl1/Rl+W4omtGoOuf9I97wN/vef0nRSLRf4TXB4hEondMhSsBb689Kq8SUMUIrL4gZyIDMBG154Ik1NmTUH+WhIZTsiWh8SQZTcd0lIxmarEmo/WQGIFt5hS0H9B+CjqokxHYuZvKAExF904qerZTPQFIfZu0kcYATMPAOq2lMwDTMbSSjmGBIR1SRuCIjpYzGIAZkC15jDECx9USTCzSgoQBKIFiLpMBmIlJUqpoJpMBmInpqSzMKGkyiwGYhVkBI3BuIhvz4zSWzQDMxiIDUD3ioZHmYGmYhnIYgLlYHqD+XAZgLvRkYAQaevKw0p2H1S7qzGMA5mG9Pd/N2JaPjVZqyWcAFmCrqQDbjdRQgJ36ApgYgSZG4G5tIfZqqLqQAViIg8oiBmARA7AIFsGbIhwyAq2vinH0kl4U4/h5MU6e0dMS2Oj0Cf1SgrOfS2BnBNp/LGUAlsLxPX1XCiddMAIvv6Gvy3D1VRmuv6QvyhmA5cA/yr3+iyKR6D/G6wNEItE75i3i8dYVj8rreFRd0WUCAzABNQJnAmodCahjBNbb6SyRAZiIRgEjsOkkCc3HSWg5ImuSOwDbBJZktJuT0XGQjM592ktB124Kuk0ePTsp6GUE9m6lMgBT0b+RigGjxyAjcGiNVtMYgGmQGkifjhEa1aVDtkzadIwtpWNck8EAzGAAZkAuWMiAghE4OSeBcpZUEkzNSDAtBCDNTGVCpaTJTAZgJubkWZifoPEsLNDiGDEC1aPZ0IyQNJsBmA3tkCAHy4M50A3kQN9PfTkMwFys9FB3LlZprYs6c7HOCDS252GjjVrzsNmSh63mfLftpnzsNFJDPgOwALt1VFvAACzAfrXHASPQXFkIy1uqKMThm0JYXxcxAItwRMcv6UURTp4XwcYItD0tZgAW4+yXYth/pp9KcE6OH+mHEji/L8HFd/RtKQOwFFdf01eluCYXI9D1RZnX/1AkEv1HeX2ASCR6B1W64hiAcaiiakZgzSVdxKPWGY86B50noJ4a7HSWwABMQJMtEc0ndJyIFmo9ImsiAzAJ7ZYkdJjpIAmd1MUI7NpLRvduMnpMyejdoe0U9G2loF+wmYKBjRQMGmk9lQGYiuHVVEgFK6kYYQSO6kmXxgBMw5iWltIwzgic0KRDrqbFdCgW0jE5n8EAzICSpmZJlYFpRuDMtASqKVJKMDspwZyAETgvz8TCBI1nMgAzoZZlMQCzoKGlkSxopcQIXGYE6gZpIJsBmA2DgBG40puD1Z4crHVTVw7WO3Ng7MhlAOZigzbbqDUXW4zA7WZqymMA5sHUIMjHbn0+9urysV9LNfk4qM6HuaqAAVjAACzAoaCiAFZG4NFrelXIACzEyYtC2J7TsyKc0tlTelIE+y9FOGcEnv9UzAAshvMH+r7YHYCXgm9LcPVNCa6/LoHrK/qyFPii1Os/KBKJ/qO8PkAkEr2DKhGLKlcsqt0BGMcAjEPthUedMw71jMCGc7LHo/EsHk2nggQ02xLQcpKA1mM6SkCbNQHth4luHZZEdJrpIJEBmITuvST07Hr0mpLQxwjs205mACZjYJM2khmAyRhiBA6v01oKAzAFIytkSGUApkIm0KVibDkV44zACUbghCaNAZgGxaLHJCNQOU9z6QzAdEyr0jEzk+Gmms7A7BQpMxiAGZhXSBiAEgagBIukHidGoEaWiaVRGslkAGZieViQBd1QFvSDWTAMUH8WVvqysdpLPdkMwGysCxiBRkbgRge15zAAc7DVmoPtlly3neZcmJqoMRe7jMC9eqrLYwDm4aDGw8wItFRRZT4DMB/WinwcvSlgABbg+FUBTgQvC2BjBJ4yAk+fFTIAC2F/Qr8UMgCL4BD8VATnj0W4+KEIl4zAy++KcfVtMa6/oa+LGYDFACPQ2/8nEon+47w+QCQSvaOqXDEMwFjUCK5iUXsZi7qLWNQ7yRHHAIxDo8Aeh6azODQzAltsdBLPAIxHm+AoHu2MwI7DBHRayJyAroMEdDMCu/cT0bOXiN5dMiUyAJPQv52EAcFWEgY3kzC0IQRgMgMwGdI1Wk3GCI0yAmUG0qdgTJeC8WXSpmKC5EukSYVCnYrJxVQoF9IYgGmYmkvDtGA2DTOMQNUMTaczANMxp0zH/KQgAwuKDCzKaSKDAZgBzZiEAShhAEqgFYxIsMwI1DEC9UM0mMkAzMRKvyALq31ZWOulniwGYBaMXdnY6KSObGzSVju1ZWObEbjTQs05DMAc7DZSQy72aL+e6nJxUJsLc00uLNV5DMA8HFbmwfrW44gRePyGXuczAPNhe0kvChiABTh7VgC74GkBzp8UwMEIdPxcCOdPhbj4kX4oZAAW4UrwXRGuvy2C6xv6usjrfycSif4rvD5AJBK9o6oRjRpGYM11DGqvYlB36VF/EYMGRmCDI5YBGIsmeyyazwRxaDmNQ6uNTuIYgHFoP4pDhzWeARiPTuqykDmeAZiAnv0E9O7RbgL6qJ8R2L+TyABMxOAWbSYyABMxvJEEqZHWkzCyloTRVVpJZgAmY0zvMa5LxgQjUK6lpRQoNCmYVHsoGYFTCzSfygBMxcxsKlSqNAZgGmZpbpqm0jCvTMMCI3BBkc4ATId6wkPDCFway4BWRqMZWB7JgE4qYQBKoCfDEA1KsDIgwSojcK2PejOx3pMJo4ARuNGVhc1O6shiAGZh2x2A2QzAbJgEzdnYbcrGHiNwv4Hqc3BQlwNzrYeFEXhYTVW5sFbm4ugtVeQxAPNw8joPNsGrPJwyAs9e0PN8BmA+zp/Sk3wGYAGcgp8LcPFTAS5/JEbg1feFuP6uEK5v6ZtC4OtCr/+dSCT6r/D6AJFI9A6rcUWjVnAdjbqraNRfRqPhgpwxaHTEoElwHoNmewxaGIGtp2SLRdtJLNoFjMAORmCnlQ7jGIBx6DbHoecg3q13Px59e7QbzwBMwMAObSdgkIa2EjC8SYxAqTERI+u0lohRkjECZStJGDMkYVyfhAkdLSczAJOhECwlY1KTDKWaFlMYgCmYnk/BzJyHihE4q6KZVAZgKuanUj0BSIuTaVArSJ4GzUQalsbTGYDpDMB0LAtG06FjBOqlGTAM01AGVgYzsDogkGCtX4L1PuqVMAAl2OjOZABmMgAzsdWRiW1BeyZ22rJgaqWWLOw2Z2GviRqzsU8HDVSfDXNdNizuAMxhAObAWpWDo0qPY0bgSQW9yWUA5uL0Fb3MYwDmwf7c4/xZHhxPiRHo/CUfFz/n4/In+jEfVz8U4FrwfQFc3xUA3xZ4/d9EItF/jdcHiESid1gNohiAUai7jkL9FV1GoYER2MgIbHRGMwCj0XwejRY7ncWgldpOyRbDAIxBx3EsOo/IGosu6j4kSyx6GIG9B7QfxwCMQz8NMAIHTPEY3InH0DZtxTMA4yHdSHAbMSZgdD0BsjVaTcTYSiLGDR4T+kTIGYHy5SQGYBIml5Kg1CS5A3CKphdpIRkz88lQzdFsCgMwBXMzKZgXTKdggRG4qKTJVAZgKjRyjyVGoHacxtIYgGnQjaZBP5LOAExnAKZjRTCUjtXBdKwxAtf6MxiAGTD2ZmCjRyDBZrcEW13UKWEASrDjDsBMBmAmdgUtmdhrzsQ+I3C/MYsBmAVzfRYsdVSbjUOy1lB1No6qsnFcSW9zGIA5sL2h1zk4pTNGoP0lvcjF+fNcOJ7R01w4n+Th4hePy5/zcPUTMQKvf8iH63v6Lt/rvyYSif6rvD5AJBK94+pckW7115FouKLLSAZgFJqcUWh2eLScR6GVEdh6Fs0AjEa7LRodJ4IYdB7HoOuIrDEMwBj0WGLQa4516zuIRf8+7cUyAOMwaKKdOAzR8HYcpFvECBzZiMeokdbjGYDxGGMEjq0mYHwlAROGBMj1pEuEYjkRkwJtIpRLiZjSkDqJAZiEmYUkqOY9ZhmBc7OkSmYAJmNhmqZSGIApUAsmU6BRpGBJngLtRCoDMBXLY6nQyTz0jEDDCEnTGIBpWB1Kw9ogDaRjnYz91JeOjd50bDICN7szGIAZ2O702GEEmtqpTcIAlGCvRYL9ZmrKxEFjJsyChkxY6jNxyAg8rM1iAGbhqJqqsnDMCDxhBNreUkU2Tt9k4+w1vcphAObg/IWH43kOnM+IEXjxJBeXv9DPuQzAXFz/mAfXDx74Ps/rfyYSif6rvD5AJBK94+oQgXpXBBqu6SoCjZcRaGIENl1EotkZiRZHJFrPyR6FtrMotAtOo9Bhi0InI7DzOJoBGI1uazR6BIfR6GUE9pnpIIYBGIOBPUEsBndjMWSKxfAObce6A3Bk02N0Iw4yI63HMQDjMb4aj4kVMsRDTgpGoEKXwABMgFJLSwkMwARMqxMxI1hMhGohEbPzNJfEAEzCvMpjYSYJi4xA9RQpk6GZTMaSguTJ0DIClydoPAW6sRToZSkwjKYyAFOxIk3FqmA4FWuMwHVG4PpAGgMwDRt91JuGTUbgVk86trupKx07nekwdWQwADOw25aBvVaP/ZYMHDACD5okDEAJLA1UL2EAZsJKR7VUk4nj6kycVFFlFgMwC6cV9CYLZ2RnBNpfZeP8ZTYcL+h5tjsAL57m4PKJx9UvObj+mRiBrh9zgR9yvf5jIpHov87rA0Qi0XugHuFocIWj8ZquwhmAEWi+iECL06PVEYE2RmCbPZIBGImO00h02ugkCl3UfUxHUQzAKPS6AzCaARiNfho4oP1oDDICh3bJFMMAjIFUwAgc2YrF6GYsZBtkjMXYeizGGYHja3GYWI2DfIUMcQzAeEzq4qFc9pjSxmN6iRiBM+oEqBZpIYEBmIA5RuD8HM0mYkGViMUZmk5iACZBI1AmYWkyCVqFEIDJDMBk6MaToR/zMDACV0ZpJIUBmIK1YRpKZQCmwjiQig1Bfyo2+1KxxQjc6kljAKZhp4s602BiBO52UHs69trSsd9KLekMwAyYmzJgETRm4LAhA1ZGoLVOwgCU4LiGqiXuALQJKjNx+jYTZxWZsL+h11k4f5UFx0t6kQUnXTACL55l4/JpNq6e0C/ZDMBsuH7KYQDmeP23RCKRV3h9gEgkeg80IIwBGMYADEPTVRiaGYHNl+FouQhHq5Mc4QzACLTbI9AhOItA52kEuhiBXSeRDMBI9BxFoldgjUTfYRT6LWSOYgBGYXCf9qIxRMO70ZCaaCcaI9sxGN2izRjIaGyDjDEMwFhMrMVCvkorsVDQJCNwUh8HpS4OU8ukjWMAxmFGEw+VQB2P2cV4zC0QI3B+LgELs6RKwCKpGYHq6UQGYCKWlInQTpIiEcvyJOgEE0nQjyfBMEayZAZgMlZHkrEm9VhnBBqHaDCFAZiCzX7qS2EApmJb0JOKne5UmLqIEbjbkYa99jTst3kctKbBzAg0N6czANNx2EgN6QzADBzVeRzXZuCkJgM2RqCtSoLTSgnO3lKFhAEowTkj8Px1JhyvMuF8SS8yGYBZuHxGT7MYgFm4Jhcj0MUIxE/ZXv8tkUjkFV4fIBKJ3hONCEWTi66FAAxDy2UYWi/IGYY2amcEtp+HMwDD0XlGp+EMwAh0U88JHUcwACPQZ6XDSAZgJAYE5kgMHkRiiBE4vEe7UQzAKIzsCKIxuh0N2RZtRjMAozFujMbEeoybfC0GilVaiWEAxkKpJ10sAzAW0zTDCJxhBKo0cZhV02IcAzAO84zA+fl4LMzFY3E2HmoVzSRAM52ApSkPrTIBy5PECNTJE6GfSIRhnMYSscIIXJXRaBLWRpKwLqXhZAZgMjYGPTYHkrHVn4xtRuB2bwp2elJg6qauFOwyAvc6qSMV++2pOGhL/VcApsHSTE1pOCRrYxqOGIFH9ek4rkvHSS3VpDMAM3AqqMrAWWUG7G+pIoMBKIHjNb2SMAAluKBLRuDl80xcPcvE9VN6kskAzAR+zvL6T4lEIq/x+gCRSPQeaXKFoPk6BC1XoW6tl6FouyBnKAMwDB3nYei0e3SdhaGbEdhtC2cAhqP3mI7C0Uf9jMCBQ7JEYNAcgaED2o/EMEn3aDcSI6ZIjDICZdu0FYWxzSiMCxiBE4xA+TqtRTMAozG5Eg0lI1BpiMGUPgbTOlqOYQDGQrVEmljM0pw6FvOLxAhcmI/D4hzNxkFNGkagZiYeS9Px0E6RMp4BGA+dIgF6gTwBhokErIwTI3BVloi1URpJxDoZGYEbwzSUhM3BJGwNJP0rAJOxI+hNhqknGbvdxAjc60zBfge1pzAAU2BmBFpaqSUVh82psDZRYyoDMA3H9R4ndWmw1RIj8LQ6HWdV6bBX0tt0nFekw8EIdLzJgPN1Bi5e0csMBqAEV8/pmYQBKIFLwAj09i+JRCKv8voAkUj0HmlGMJpdwWhhBLZe0WUIAzAE7c4QdDACOxyh6DwPRZedzkIZgGHosYWhV3AShr7jMPQfkTWcARiOQYvHkDkcw4xA6T7tRWBkNwKjJkEkZDuRGNumrUgGYCQmNiIhN0a5KdajMLlGq1EMwGhMGUgfzQCMxgypGIEqbQxml2IwpyF1DAMwBgsLsW6L87FQz9FsLAMwDkszcdBOeyxPxUGnJEagXhEPg5wm4hmA8VhlBK6NkSwB66MJMI6QNJEBmIjNIY+twURsD1B/EgMwCaZe6kliACZhrysZ+4LOZBx0JMPcToxAS2sKDluoOQVWOmoiRuBxQypO6lNhq6PaVJzWpOGs2sNelYbzSnqbxgBMh/MNvU5nAKbj8qUgA1cvMnD9PAOuZ/Q0A3gi8foviUQir/L6AJFI9J5pcQWh9TrYre0qGO2XdBHMAAxBp4POQ9BF3fYQ9JzRaSgDMBR9J3Qc6g7AAYE1DIOHYRiyhGHYTAfhDMBwjAj2wjG6Gw4ZI1C2E8EAjMD4VgQmBJsRkDMCFUZaj2QARkK5SitRmKJpQxRm9KSLYgBGY1ZLS9GYo3kNqaOxwAhcXIiBep7mYqCZjcESI3BJFQvtTCyWp2kq1h2A+sk4GBQeK/I4rE4QI3BtLB7rMhqNZwDGY4MRuCFNwOZwAraGErA9SAMJ2OlPhKnPY7c3EXs9xAjc70rCQSd1JDEAk2BhBFraknHYmgxrSzKOmqkpGceNKThpoPoU2Oi0jhiBZzWpsFdTVSoDMBUOdwCmwUkXb9Jw+ZpepeGKEXj9gp6nMwDTgafpXv8hkUjkdV4fIBKJ3jMtCEQrI7Dtmq6CGIBB6LgIQicjsNMZjC5HMLrPyR7sDsDeU48+Wwj6T0IwcExHoRi0hmLo0GPYEgopI1B6EMYADMPoXhhku2QKxxiN79B2OAMwHPJN2ohgAEZgkpTrtBaBKUbg9AoZIhmAkVAJGIGzy1GY00Zhfok0UVhgAC4ueqgXoqGZp7loBmAMtCqaiWEAxkBHekagXhkLw2QsVhQkj2UAxmJtPM5tfSwORlkcNkaJEbgpjcfWMA3FY5t2BokRaOpPwG4f9SYwABOw353odtCVCHNnIiwdxAg8bEuCtZVakhiASThmBB4zAk8ak2FroPpkBmAyzmpTYK+h6hSck6OKGIHOt6m4qKA3qQzAVFy9EqTh+mUaXC/oeZrX/0ckEr0TvD5AJBK9h1pdgQzAQLRTxxVdBjIAg9DlJEcQAzAIPdRrp7Ng9J0Go99GJ8EMwGAMMgIHj0IwZA3B8GEIpBYyh2LkIBSjgv1QyPZCMcYIHDOFMQDDMLEdBvmWh4IROLlBxnAGYDim1mg1AtM0sxIBlYH0EZjVRWJumbSRDMBILAg0kVhUR0G9SAtRDMAoLM1FQcsI1M5GY1kVDd0MTUczAGNgUNJkDFZoVRGDNTkxAtfHY2EcI1ksAzAWm4zAzZE4bEnjsD1MQ3EMwDiYBuIZgPHYpb2+eOz3EiPwoDsB5i7qTGAAJuCwPdHN2paIo1ZqSWQAJuKkKQm2RmpIwimd1RMj0F6bjPMaqk5mACbDWZnCAEzBBV1W0JsUXL1OwTUj0PWSXqQCz1O9/jsikeid4PUBIpHoPdSGALS76DqAARiAzku6CEQXdTsD0eOg80AGYCD6zoIYgEHopwEbnQQxAIMxdBSMYSsdBkNKI4zAEXMIAzAEsn3aC2EAhmB8NxQTJtoJhXw7FAp3AIYxAMOgNHpMrYdhmhE4s0or4QzAcMzqBRGY00Vgfpm0EQzACCxqIqBWRzIAI6GhpQWaj2QARmF5llRRDMAo6MnACDRMRWNFGY3VSVJEMwCjsT4R42Ycj8HGGMliGICx2BqJxbaUhmOxQyZGoIkRuDsQh71+6otjAMbhoCeeARgPM1m6qDMeh4xAa3sCjtqoNQHHLQk4ETACbU2JOG2khkQGYCLsdUkMwCQGYBIcguokOBmBF5XJuHxLFcm4epOM69f0KgUuwssUr/+NSCR6Z3h9gEgkek+1u/zRce2PTsGVP7oYgd0X5AxgAAag91zAAGQE9p8FYuCUbIEYPAnE0HGQ2/BREKRWOgxiAAZj1BwM2YHH2H4wxveEAAxhAIZAvkPbIVDQ5FYolJu0EYopYyim12ktjAEYBpVgJQyzhjDMMQLndbQcjgVtOBYFS+FQMwI1alqMYABGQDtPc5FYJt1sJPQqmolkAEZhZYqUUQzAKKwJGIHrjEDjRDQ2xmksGpuyaGyNxrhtj8RgR0rDMQzAWOwO0kAsAzAW+4K+WBwwAs09cbB0U1ccDjvjYO2Idztqj8dxG7XGMwDjYWtOYAAmMAATcNaQALuAEXhelwhHLdUkwlmdiIuqJAZgEgMwCVeCiiRcv0mGixHoepXs9X8RiUTvFK8PEIlE76kO+KHD5ccA9EPXFV36ofvSHz0X/uh1ksMffYzAfjudBWCABk/JFoAhRuDwcSCkR2QNxMhhIEYZgaOWIMjMQRg7oP0gBmAQJnaDIReYgqHYCcbkNm2FMABDMLXhMW0MwQwjULVGq6GYXQnFnIH0YZinBR0thzEAw6BeIk04AzAcS6RdpIVwLDMCdXM0G8EAjIBhRhCJlelIrE5FYk1Jk5FYV0TCKI9iAEZhgzbHaSwKW4zA7VEaiWYARsM0LIjB7lAM9gZjsD9A/TE46IuBuTeWARgLCx12U1csrIzAow5qj2MAxuGkNQ62FkE8TpvjcdZEjfEMwHic1ycwABMYgAlwCmoScMEIvKyiykQGYCKuKxLhekOvkwDy9r+IRKJ3itcHiESi91iny9et69oX3YzAHkZgz4UfA9APfQ6P/nN/DNjpzJ8B6I8hmz+GTwLcpMcBGDkiawADMBAyC5kDGYCBGKeJfWIEyneDoDDRThADMAhKRqByKxhTm8GY3gjGjJHWQxiAIZgVrIZgbiUE8wbShzIAQ7G4HAq1VhAGDSNwSUPqMAZgGJYXaD6cARgOPRlmSRWOFUbg6jRNRTAAI7AumIyAkRG4IaeJSAZgJLbGIrEti3LbGY2CaYSkUdhlBO4N0WA0AzAaB4L+aJgZgZZe6olhAMbA2hWDo85YBmAsjumkndpiYWMEnjICT5vjGIBxsDd6nDMCHfVUF88AjMdFTTwuqxMYgAm4qkzAteBtAlwVCQAj0Nt/IhKJ3jleHyASid5jnfBBl8sH3dd05csA9EWv4MIXfU5f9Dt8MXDuxwD0w+CZH4YEp34YZgRKT+jYnwHoj1GrP2SMQNlhAMYsARg300GAOwDlex6K3UBMmgKh3CFG4NRWEKY3aSMIM6RiBKrWgxmAwZhbDcb8SrA7ABdoUU+6EKiXQ6DR0lIoAzAUWrXH8mIodIxA/TzNhTEAw7CioplwrNLaNE2FMwDDYZwMx4YiggEYgU3amqDxCGwzAndkNBrJAIzErpSGo7BH+0M0GMUAjIKZAWjpo95oHPZEwyrojsYRI/C4kzpiGIAxsLVRayxO6awlFvZmaorFeWMsHA1xDMA4OOvicFHrcckIvKqmqngGYDxcb6ki3us/IhKJ3kleHyASid5zXa676Kae67vovfJhAPqg78IH/U5y+GCAETh4TnZfBqAvhk99IbX5MQD9MEKjx3TkxwD0w9ihPwPQnwHojwmSMwLl+wFQ7AVgcpdMAQzAAEwxAqe2AzG9FYiZzUCoNsgYhNn1IMytecyvBmFhhQzBDMBgqHW0HAwNLTECtUukCcGyOgS6RVoIZQCGwiCYC8XKbChWGYFrMzQdhvWpMBiVHhuMwE0FycMZgOHYHqexCAZgBEyC0QjsjkRgjxG4P0xDkTgYjIR5wMPSH4XDPuqNYgBG4aibuqIZgNE4IVsHtUfjlBF41kotMQzAGJw3UWMMHIxAZwPVx+KiLhaXtVQTxwCMw3VVHFyCyjjgbZzX/0MkEr2TvD5AJBK957pxBz2uO/8KwLvou/Tov7iLAScxAgfPfTBk98HwmYeUEThioxNfBqAvZEe+ngCk8UM/TFjI7McA9INi358B6I9JUu6SyZ8BGIDp7QDMbNFmAFQ0ywicNQZibj0Q82u0GsgADMSiIQhqgT4IGl0QlpZJG8wADMayhtTB0JGeEWhYoPkQrMyFYHWWVCFYU4VifYamQ2GcCsWGOwDDGIBh2JKHYVswEYYdRqBpjGTh2B0Nx94ISSOwTwfDNBQB82AELAPUH8kAjIS1NxJHgp5IHDMCT7qoM4oBGIXTdmqLZgBGwy5oicZ5czQcTcQIdDbE4KI+Bpd1HleMwOsaqo5lAMYClbFe/w2RSPTO8voAkUj0K9CD2+h10fUd9F3dQf/lHQxckPMOBhmBQw46v4th+11Iz+jUhwHog9ETH8gExz4YYwSOW+nQlwHoC7nZQ8EInNz3g3KPdv0wZfLD9I6/28y2P1RbtOnPAAzAnDEA8+seC2sBWGQELjIC1YZAaPSkC2QABkLLCNRqg7C8FASdJgh6NS0GMwCDsTLvsToXjLVZIQBDGIAhME6HYGPKY1MZiq1JUoQyAEOxM0HjYQzAMOwKZGHYGw3DPiNwXxrOAAyHeSgclkEaCMchI9DaT30RDMAIHPdQdyQDMBK2To/TjkicMQLtbdQahfOWKDiao9wB6KSLRmqIxmV9NK7qqDaGARgDVzVVxXj9J0Qi0TvN6wNEItGvQC9uMQBvoe/6NvqvPAYub2PwghiBQ447GD6/A6ndY4QROHpKtrsMwLsYO6ajuxg/8sGE1QfyQ7L4QGH2weSBLwPQlwHoiynBri+mGYEzO35QbdOWH2Y3/TAn2PDHvNEfC+u05s8ADIB6xUNjCMCSPgBaHTECl7WB0C2RJhB6MjACDYtBWFkIwup8ENbmaDYI66pgGAUzwdiYDsbmFClDGIAh2FaQPAQ7ZGIEmsZDGYCh2JOFYn+URsJwIA2DWTAcBstQGA4HiRFo7Q/HUR/1huOYThiBtm7qisBpZwTOOqg9kgEYiXNBayQcLZFwNlNTFAMwCpcNVB/FAIzCNSPQVUs10UB1tNd/QiQSvdO8PkAkEv1K9OEm+hiB/de3MHBFl7cYgLcw5LyNYYHjNqTntzFip7M7DMA7kNk8xk7uYJwROMEInLDeZQDehcLiMckIVB7Qvg8D0AfTuz6YMfkyAH2hotlt2vJ1B+D8Bhn9GIB+WCT1Gq36Q7PijyUD6f0ZgP5YXg5w02kDoF8KgEFD6kCsLAZidcFjbT4Q63PECDSqgrAxQ9NBDMAgbDECt5U0GYwdRTBMcpoIwe54CPbGPPZlITgYpZFQBmAoLMM0FOoOQCsdDVB/GI77wnDSSz3hDMBwnHZ5nHWGw84ItLdHMAAj4GillggGYAQumiJxKWiMxFVDJK7riRHoqo0CaqK8/gsikeid5/UBIpHoV6TfdRMD13R1E4M0dEmMwGHnLUgddH6LAXgLoyQ7uw3Z6W2M2W5j/ISObzMA70AusN6B4vAOJi13oDTfZQDexdT+XUwL9u5ihhGoMtGODwPQB3NbPpjf9HVb2PDFopHWfRmAvtCs+jEA/bBEWgPp/bDMCNQt+0OvpSV/BqA/VhiBK+oArC4GYG2B5gPcAWicDcSGQBWIzZlAbE0TI3BbGYSdSVIEwUS7jMDdiWDsjQdjf4xkwe4ANI+EwCKQhuBwOATWIRoMZQCG4rif+kJxQjZGoK0nDKfdYTjrCoO9kzrCcd4eDkebh7M1HBctxAi8bIrAVSM1RDAAI+BiBLrqIr3+AyKR6L3g9QEikehXpB83MOC6gcFrurrBALyB4YubkDo9Rhw3MXpO9psMwFsYOyXbLYzTxMktyBmB8qPbUFhvY/KQLLehZAROmengDgPwDmb27kC1e5cBeBezNLdD23cxv3UXC5s+DEAfBqAP1IJ1H2gYgUurvtCukMEXy3pf6HR+bvplPxi0tOTHAPTDqtofa4u04I91MjICjXMBDMAAbKpoJoABGIBtRuD2VCB2lIEwTZIikAEYhL2JIOyPexyMBcEso9FgBmAwDqU0HMwADMYRI/BoMATHAyE46Q+BrY96Q3HaE4qzbuoKhZ3OGYHnHWFwtIfB2UatYQzAMFw2h7tdNYXjujEcrgZiBKIuwus/IBKJ3gteHyASiX5lBlwfMwA/xhANXxEjUHpxAyNOctxgAN6ATMAIHDu7ifHTm5iw0clNBuAtKI48Jq23oDwkRuCU+TamD25jZt9DxQic3SXTHQbgHcxv3/EEIC1u3oV6g4x3oVm/i6U1HwagDwPQB8sCgw90jEC9zheGZdL6YmXJF6uMwFVG4JraD+uLtODHAPTDxpw/A9Afm7Sl8sf2DDECd6YCYFLSZAB2FQHYYwTuyQOxPxGIg3EaC2QABsIyGsQADMIhWaVBOBomRuDxYDBOBqg/mAEYjFNG4GlvCM56QmDvpq4QBmAIHB2hDMBQOOmiLRSXjMBLRuBVcxium6gxjAEYBtSHe/32IpHoveH1ASKR6FdmEB9hyEXXHzEAP4L08mMG4McYoVHnx5A56PxjjNlvYPyMTm9gguQ2YgQqjm9i8ugmlFY6vIkpRuC0hcy3MHNwC6p92rvFALyNOdNtzAt2bmNh+zYWt+4wAO8wAO9AY/RYYgRq12j1LgPwLnSGu9DrfdwMOh+sLJPWhwHoizUNqX0ZgL4w0sYCMQI35/ywNUsqPwagH3am/d1MU/7YVdKkPwMwAPtymghgAAbATBZGoIUReDgaCOsISQMZgIE4HgpyOxkMgm2A+oMYgME46w2GvYe6g3FODkaggxHo7AjBRTu1hTAAQ3DVEsoADMU1uZqoMdTrdxeJRO8Vrw8QiUS/QkOuDzF8/SGkgqsPMXL5EUYvyPkRA/AjjAkBSOP2jzFx9jHkp2T7GIqTG5g89lAe3cCUlRiB05abmDHfhOrAY3b/JuYYgXO7txiAt7CwQ9u3GIC3oRZs3oZm4zaWjLehXb/DALyD5dU70AlW7kDPCDToSXeXAXgXq9q7WFsS+GBd4wOjmhZ9GIA+2Jz3ZQD6You2Z0nlix1GoGmapvwYgH7Ym/TDvkDhjwO5P8wTNO7PAAzAoYxGA2CloxGSBuCYEXgyFAjbIA0E4rQ/EGeMwLO+INh7g3DeQ91BDMAgODuDGYDBDMBgXAragnHFCLxuCYGrmZpCgMYQr99cJBK9V7w+QCQS/QoN4wMMuz5gAH6AEXcAfsgA/BAygfNDjDk+xPj5R5iw09lHDMCPoBAwAidPPobymI4+ZgB+jOnDG5gRWG5AZb6B2QPav8EAvIn5XY8F000s7tyEmhGo3roFzeYtLG2Q8Ra0jMDldVq7zQC8Df3KbRgMdxiAd7BCqzpavoM1RuA6I3Bdc5cBeBcbix6bjMCteR9sz9GsD3ZUPjDN+LrtTvtib4qUvu4APFCQ3I8B6AeLYNwPh2P+sMr8cTRKI/44lvrjZDjAzTYUgNNBGghgAAbC3ke9gQzAQDi6PZyMwIvOIFx2UHsQrtqCcN0azAAMhovQHOz1e4tEoveO1weIRKJfKanrNwzA32CERq8+gOySLj7AmPMDjDvo/ENMkNxOZx8yAD/EpO0jKE/o+CNM0fQRMQJnDj+GykLmjxmAH2OO5hmB83s3sLB7A4sm2rnBALwJjWDrJpY2b0K7QYzA5fVb0K3dgn7Vw7ByCyuG2wzA2wzA21hbJu1trGvvwLh0BxsaUt/B5uIdbC3cZQDeZQDexY5g9i5MjMDdGZr2YQD6YF9Jk744ILPCFxY5TfjicNwX1jE/BqAfA9APx4IRP5wwAm3DNOTPAPTH2YA/7P0Bbud9AXD0Uk8AnAzAiy7qDGQABuJK0B6Ia0agq5Vagrx+Z5FI9F7y+gCRSPQrJcX/YMT1Pxi9pqvfMAB/gzHBxW8w7vwNJhiB8nOyfwDF2QeYFDAClbYPMXVCxx8yAD/EjPVDqA4/cpu1fIQ580f/CsCPsbBHux9jkdQmYgRqtm9gaesGtJu0cQPLjECdkdZvQr92E4ZVWrnJALyFVf0trAl0t7C+fAtGRqBx6TYD8DY21R5bjMDtBZq/wwC8A9Msqe4yAO9ij/anaeouDpR3YZ70YQD6MAB9cDjhYWUEHo2RzJcB6IuTEV/YpH4MQD+c0tkQDfrBPuCH835/BqA/A9Afzh5BAC66A3DZRZ0BDMAAXLcHwNUWyAAMBFoCvX5nkUj0XvL6AJFI9Cs24vo/GCUZI1B29T8MwP/B+MX/YMJJjt9ATopzsv+GAfgbKE8/YAB+wAD8ANM0c0yMQBUjcPaQLB8yAP9fu3X1oNl1X2k4thi71cxUXdVdzMyNkuz5a2dilGVBMxQzfczMfNasU5+SOBPHMUhnj7vWxXO/9m/fvHNYidnmsRqdx1pkHuthCs1jI3gHm4GmLf8dbPuIEbjjuYtd913suZr2D+7igBF4sHePAXgP7h3avscAvA+vbfM+fBv34V+/j8DaAwbgAwRXHiC03BRmBEYWaeEhA/AhYq8eNgOQEi/o+edIPvscqaefI/3kCwbgF8g8+gJZ2/dfIMcIzH9L33zJAPwSxa+/bAYglb+i3/8Cld/9AtXf/gK13/ySAfhL1H/1SzT+tcliBOJ//y/j/ysi/7SMDxCRN9j3mMQjixqTeFyfwpNa09PqFJ5VqDzNAJzGi+I0XhaaXuVn8DpH2RkG4AwW05SaxRItJ2exkqD4LFYZgWtRisxhnTbCxAjcDM5jK0D+eQbgPHa8d7Br89zBnvsO9l10cIcBeBeuvSb37l14du7Cywj0bt2Db/Me/Bu0fg8BRmBwjVbvI7RyH+FlWrrPAHyA6EJT7PUDxF89QOLlQwbgQySfP0TqWVOaEZh5Qo8/ZwB+jtz39N0XDMAvUPjmCxRtf/wCJUZg+Q/01Zeo/P5LVH9Hv/0SNUZg/Tf061+g8atfwPpX+j+/NP63IvJPzfgAEXnDPbIm8NjGCHxSn8TT2iSeVakyieflKbywlabwsjiFVwXKTzMAp7GQncaiLTONJUbgcoqSMwzAGazGbbNYi81iPUqRWQbgLDZDc9gKNm0H5rDjJ98cA3Aeex5yzzMA53HACHQxAl37d+DeuwPPLu3cYQDehc+2dRf+zbsIbBAjMLh2D6FVWrmHMEWW7yHKCIwu3kds4T7ir+nVfQbgAyRtLx4g9fwB0s/o6UMG4ENkHz9E7lFTnhFY+I6+/ZwB+DlKf6SvP2cAfoGK7asvUP39F6j9jhiB9d98icavv4T1qyYwAk3/q4j8UzM+QETecI8wzgAcx5PGBJ7WqTaBZ/S8SozAF+VJvCxRcZIBOInXjMCFPOWmGIBTWMpQepoBOI0VW3Iaq4lprDEC12MUncFGZAabNkbgVmgW20EKzDIAZ7HLANyzeeew75nDgZtccwzAebj3aW8eHvLuEiPQt30H/q07CGzSxh0E1+8iZFu7i/DqXURWaPkuA/AeYotN8YV7SLwmRmDy5X2kXtxH+jk9u48MIzD7lJ48QO7xA+Qf0fcPGYAPUfy2qfTNQ5QZgWVGYOUPn6P61eeo/Z5+9znqjMDGb+k3X8D69RfAr74w/qci8k/P+AAROQKeMAKfMAKfNsbxrE61cQbgOF5UJvDSVp7Aq9IEXheJEbiQn8RijrKTWKLlzCRW0lMMwCmsJqewlqD4FNbj09iIUXSaATiNrTCFZhiAM9ih3QD5ZxiAs9j3kmeWATgLl40R6D6Yg2d/Dt492p2Db2ce/u2mwNY8gpvECAyt30F4jVbvMADvIGpjBMaW7iK+eBeJBXp9F8lX95CyvbyH9It7yDwnRmD26X3kntDj+8hT4dF9FL9/gOJ3D1D69gHK39AfH6Dy9UNU/9BU++oh6r8nRmDjt5/D+g39+nPjfykibwTjA0TkCHiCUTy1xvCsQfUxPKcXNWIEvqyM41WZSuMMwHEsMAIXC5SfwFJuAstZykwwACexaktNYi05ifUEMQI3YlPYjE5hK9K0zQjcCVFwmgE4jT0/+WawTwfeGbg85J6B2zULzwHtz8JLvj1iBPp35hDYpq05BuAcQhu2eYTX5xFZm0d0df4wAGPLdxBfosU7SFBygRiBqVd3kX5JL+4yAO8i++wecran95B/cg+Fx/ToHgPwPkrf0bf3UabKN8QIrH79ALU/0FcPGIAP0PjdQ1i23z4EfvPQ+F+KyBvB+AAROSKeMgKfWaN43qD6KANwFC+rYwzAMbyi1+UxLJSIEbhYGMdSnnLjWKaVLDECV9MTWEtNYD1JiQlsMAI34xSbxFZ0EtsRCk8xAKewG5zCni0whX1G4IGPvNMMwGm43bYZeFwz8B7Q/gwDcAb+3VkEdmh7FkEKbREjMMwIjKzT2hwDcA4x28o84svzSCzR4jwDcB6p13eQftWUeXkH2RfECMw9u4v8U3pylwF4F0UbI7D0/T2Uv6Nv7zEA76H6x/uofd1U/8N9NL4iRqD1uwfAbx8Y/0MReWMYHyAiR8gza4QBOIIX9RG8tDECX1VH8bpC5VEG4CgWi7YxLBXGsJwfw0pu7DAAVzPjWEs3rafGsZEkRuBmfAJbMYpOYJt2GIG7YQpNMgAnsR8g/yQDcAoum3cKbs8UPO4peF3TDMBp+Pan4bftTSOwO4PgDm3PMABnEN6kjVlEKLpOa7MMwFnEV+aQWKalOSQptUiMwPTreWRe0ct5BuA8cs/vHMo/u4PC0zsoPqHHd1B6dBfl7+m7u6hQ9VtiBNb+eA/1r+kP9xiA92D9/v4h038nIm8U4wNE5Ah5jmG8sKgxzAAcxqsaVUcYgCNYoMUyMQKXGIHLBcqPMgBHsWrLjmEtM4b1NKXGGIBj2EyMY8sWH8d2bBw7UYpMMAAnsBdq2g9O4CAwARcj0OWbhNs7CY+nycsI9LnoYIoBOIXAHu1OMwCnEbJtTyO8NY0IIzC6QesziK3NIL5qm0ViZRbJZVqaZQDOIr0wxwCcQ4ayr+aQe0kv5pB/Po/CM3o6zwCcR4kRWGIElh/dQeV7+u4OA/AOat/cZQDeRZ0aX9+F9QdiBOL394z/nYi8UYwPEJEj5oU1hJeNplf1IbxmBC5UqTLMABzGUsk2guXiCFYKlB9hAI5gLTuK9QylR7FBmyliBG4lxrAdp9gYA3AMu4zAvQiFx7EfGsdBkALjDMAJuG2+CXi8E/B6yD3JAJyE/2ASgf2mICMwtEs7UwhvTyGyRZvTiFJsg9anEV+bRoIRmFiZYQDOILU0g7SNEZhZmEX2Nb2aZQDOIn8YgHMoUPEZPZ1jAM6h/HieATjPAJxH9bt51GyMwPo3d9D4I319hwF4B/jqrvE/E5E3jvEBInLEvMQgXlqDeNUYxOs61YYYgENYtFWGsFQewjIjcKVIhWGs5oexZmMErmdHsJGh9AgDcARbydFD24lR7MRHsRuj6CgDcAz7YQqN4YBcjEAXI9DtH4fHNw6vlzzj8DEC/W5yTSBwMIHgPu1NMgAnEbbtTCKyPYnoFm1OMQCnEF+fQmKtKbk6jdQKLU8zAKeRWaSFGQbgDHK2VzPIv5xB4cUsis/p2SxKT2dRfmKbQ+XxHKqP6Ps5BuAc6t/OMwDnGYDzsGxfzxv/LxF5IxkfICJH0CtrgAE4gNe0wAhcrFF1EEuVQSyXqTSIldIQVotUGGIADmE9R9lhBuAwNmkrTalhbCdHsJOg+AgDcAR7jMA9RuB+ZBQH4VG4QhQchTswBo+/yesbg89LjEC/exwBFx2MI0ghRmBob4IBOIHIzgSi27Q1gdjmJOK2jUkk1ieRXKPVKQbgFNLLTZmlKWQZgbkFej2N/KtpFF7SixkUqfScns2g/HQGFUZg5fEsA3AWte+b6t/NofHtHKxv6I9zwNdzxv9KRN5IxgeIyBH0Cv14bfVjoUH1fgbgAJaqTcuVAayUiRG4WhzEWmEQ6/mmDUbgZpYyQwzAIWynKDmMHdpNDGMvTrFh7EdHcBCh8Ahc5A4RI9ATGIXXT75RBuAo/J4xBGzuMQRdYwgd0P44wnvjiOw2RXfGEdsmRmB8cwKJDVqfYABOIMUITK/SyiQyy5PILtHiFANwCnnb6ykUXk2hyAgsvphmAE6j/IyeTqPCCKw+mUHtMT2aQf37GTS+m2UAzjIAZwEy/U8i8sYyPkBEjqjXVh8DsA+LNkbgUq0fy9V+rFSo3I/V0gDWbMUBrBcGsJGn3CADcBBbmabt9CB2GIG7SUoMMQCHsB+zDeMgOgxXhMLDDMBheIIj8AaafP4R+H3ECAx4RhF0k2uUATiKsG1/DJG9MUR3aWfsMADjW+NI2DbHkdwYR2qdGIHp1QlkVmh5AlnKMQJzi5MMwEkUXk+i+IpeTqL0Ygpl2/MpVJ5NofqUnkwzAKdRf0TfT6NB1nczsL6dMf4/IvJGMz5ARI6oBfRi0eo9DMCleh+Wa00r1T6sVogRuFbqx3qRCv3YoE1G4FaOsgPYzgxgJ02pQQbgIPZsiUHsxwdxEBuEKzrEAByCOzwEjy00BG9wGL4A+YcZgMMIeG0jCHpGEHKTa+QwACP7o4ju0e4oYhTfoe0xBuAYkpu0McYAHEOaEZheG0dmdRzZlXHklmlpAvnFCRQWmoqvJ1B6RYzA8otJVJ7Ts0kG4CRqjMDakynUH0+h8WgK1vf03TTw7bTx/xGRN5rxASJyhC1aPViyNXqxXO/FSo2qvQzAXqyV+7BuK/Vho9iHzQLl+xmA/djONu1k+rGb7sdeaoABOID9xAAO4hQbgIsR6I5SZJABOAhviIJDDMAh+CngJ98QgozAkIfcwwi7hhGxHYwguj+C2B7tjjAAR5DYHmUAjiJJqc1RpDeIEZhZG0N2lVbGGIBjyDMC80vjKCyOo7hAr8cZgOMov5w4VHkxgerzCdSeESOw/mQSjcf0aBIWgRFo+l9E5I1nfICIHGGL6GYAdmO50YOVOtV6sEprVar0MAB7sVGiYi8DsBdbjMCtfB+2c33YyfZhN0PpPgZgP/ZtyX4cJPrhihMj0B0dgCcyAK8tPAAfI9AfpMAgA3AQQR95hxCisIfcQwzAIUQPhhmAwwzAYcQpsUuMwOT2CFJbtDnCABxBZn30UHZtFLlVWhllAI6isDSG4iItjKFEZUZgmRFYeTmO6gt6Ps4AHEedEVh/OoHGkwlYj+nRhPE/EZEjwfgAETnilq2uQyuNbqzWqdbNAOzG+mEA9mCDNks92CpSoQfb+V7s5Cjbi13aYwTuMQL3U304SPbBlaB4H9yMQE+Mov0MwH74whQaYAAOIGALDCDoH0CIERjyDjIABxFxDyLqaoodDCG+T3tDDMAhJHdoexgpSm/R5jAyG8PIro8gt0arI8ivjKDACCwwAotLoygt0sIoA3AUlVdjDMAxVKn2gp6PMQDH0Xg6DusJPR4HHo0b/w8RORKMDxCRI24ZnVixqNHFAOzCWq0L67ZqFzYq3dgsU6mbAdiN7YKtBzv5HuzmerCXpUwP9tO9OEg1uZK9cCeIEeiJ9cEbpUgffORnBAZCFOxHMNCPkJ98/Qj7BhDxkmcAUfcAYi46GGQADiKx15TcHUSKEZjepq0hZDaHkN2g9WHkKL9Gq8MMwGEUl0cYgCMMwBGUbQsjqDACq69GUXtJL0ZRfz6KxrOxQ9bTMeDJmPG/EJEjw/gAERGsMAJXGYFrDap3MgA7sVGlSic2K13YKlOpC9vFLuwwAnfzlOtmAHZj38YIPEj3wJWiZA8DsAeeeA+88V54Y73wRXvhj1C4jwHYh2CwKRToQ9hPjMCItx9RD7n7EaM4IzBxQPsDSO4NILVLO4MMwEFkbFuDyG4OIscIzK0PMQCHUFgdQnHFNozS8jDKS7Q4jMrCMKqvRxiAI6hR/SW9GEGDEWg9o6ejxv9ARI4U4wNERLCKdgZgBwOwA+v1po1aBzYZgVuMwK1yJ7ZLndgpNu0WurCXp1wXA7ALB5kuuNLdh9ypbniSlLADsAe+GEV7GIA9CNjCvQiGehEKUqD3MAAjvj5Ebd4+xDx9iLvJ1c8A7Edyvym11480IzC9M8AAHEB2awC5TdoYRJ4K67Q2iOLqIEortDzEABxCZbGpujCE2uthBuAwA3AYjRfDsJ7TsxGATP+BiBwpxgeIiBxaYwSuW9Rox0a9HZs1qnYwADuwbSt3YKfUgV0G4F6B8p3Yz3XiwJbthIsR6E5TqosB2AVvwtYNX7wb/lg3AlGKdCMY7kEoRMEehCkSIH8vA7AXMS95ehmAvUgwAhOuPiQP+pDa70N6j3b7kdnpR3a7KbfVj/wmbQwwAAdQXKPVAZSozAgsLw+isjSI6uIgagv0egj1V0No2F4OwXoxBDACTd9eRI4c4wNERP7dunUbGw2q38YmbTECt6rtDMB27JTbsVuiYgf2aL9A+Q4GYAdchwHYyQDshIe8KUp2wpfohD/exQDsYgB2IWhjBIbC3QiHKNjNAOxG1N/DAOxBjOLeHiQ85O5B0tWL1AHt9yJNGUZgZrcP2Z0+5LZpq48B2IfCRj+KtvV+lNb6UV6llQFUlgdQXWqqLQ6gzgisvx5kAA7CekkvBo3fXESOJOMDRET+3TpuYcO6hc3GLWzVqXYb29Xb2Kk07ZZvY69ExXYGYDsO8u1w5Zrc2Q54MpTuYAB2wJfsaAYgBeIU62QAdiIUoXAXA7ALEYoGKdCFmL8bcR95uxmA3UgyApOMwJSrB+kD2u9hAPYgu9uL3E5TfrsXBUZggRFY3OhDaZ3W+hiAfagwAisr/agu96O2RIv9DMABNF4PwLK9GgBeDhi/uYgcScYHiIj8J5tWGwOwDVu0XadaG3aqt7BbuYW9MpVuYZ8ReFCkwm248rfhzlG2nQHYDm+6yZdqh58RGEhQvAPBWAdCUVsnwozASJhCnQzATsQC5O9CnBI+8nYxALuQcncj7aKDbmT2u5G1MQJzuz3I79B2DwOwB8XN3kOljV6U12mtlwHYh+pKH2rLtNSHOjUYgY2FfgZgP/Cq3/itReTIMj5AROQ/2UQrtixqtDIAW7FTa8Vute3QXqUN+2UqtTEAb8FVoPwtuMnDCPRmKXMbvvRt+FOUbEeAggmKtyMUa0eYERiOdDAAOxANNcUYgXFGYMJPvk4kvZ1IeZrS7i5kXHTQxQDsQm6vmwHYjTwVdrpR3CZGYGmzB+UNWu9BZa0HVdtqL2orvagv01IvA7AP1gK97jN+ZxE50owPEBH5L7asm9hu3MSOjRG4ywjcq1KllQHYioNSK1yMQFexDe5CGzx5yrUxAG/Bl2nyp28hwAgMJG8zAG8jFKfYbYQpEm1HNELhdsRC7YgHKdDBAOxA0ubrQMrbgfRhAHYyADuRPehEzrbfifxeFwq7tNPFAOxCaYs2u1Gmygatdx8GYG2VVnoYgD1okLVEi73AQq/xG4vIkWZ8gIjIf7GNFmxbLQzAFuzWW7BXu8kAvIl9OqhQ+SYDsBXuIhVaGYCt8NoYgb5sG/yZNgTSlGpDMNmGUPIWQolbCMdvIRKj6G0G4G3Ewk3x0G0kGIGJQDsDsB0pXzvSXvJ0IENZN7k6GIAdyB8GYCcDsBNF204nStudKDMCy5tdDMAuVNe7UFuzdaO+2o3GCi13MwC7gcUe4/cVkSPP+AARkT9rx7qB3UbTXv0G9mstDMAWBmALXGUqtcBduglP8Sa8BcrfhC/XCn+WMq0IUDBNqVYGYBvCCYq3MQDbELVFbyEWuYV4+BYSIQreRjJwGymb/zbSvtvIMAIznnYGYDtyLjpoR54RWNjvQHGPdjtQ2ulA+TAAO1Gh6iZtdKK23on6Gq12MQC7YC03mb6riMi//H8wQETkz9rBdexa17HXuP5DAN7AAbmqVLkBd/kGPIxAT7GFAdgCny3fAn/uJgJZytxkAN5E6DAAWxGmSKIV0TjFWhGLtiEeoXAbEpQMUfAWA/AW0n7y3WIA3kaWch5y30bedRuFA9pvZwC2o7TbVN5pR2W7gwHYwQDsQG2D1jtQZwQ2GIHWKq10Asudxu8qIvIv/x8MEBH5b+1Z1w7tN67hoH6dAXidAXgd7gqVr8PDCPSWqHiDAXgD/vwNBHKUbUGQQhlKtyCcuolIkhI3GYA3EYvZWhGPtiIRoXArA7AVqWAb0oGmjL8NWR952xiAt5B3k+sWClRkBBb3b6O0dxvlXdq5zQBsR3WrHTXbZjvqG+1oMAIbax0MwA5gpcP4PUVEfmB8gIjIf2sPV7FvUeMqA/AaXLUmd/UaPJVr8DICvaXr8BWvw19oCjACg4zAYPYGA/AGwmlK3UAk1YJokhItiMVbEI+1IBG9yQC8iSSlwsQITAdbkQmQv5UB2Iqc19aGvKcNBXcbii46aENp/xbKe02V3VuoMgKr27cZgLdR36SN2wzAdli2tXbjtxQR+RPGB4iI/EX71hUckKtB9atw167CU6XKVQbgVfjK1+ArXYO/eA2BAuWvMQCvI5RtCmeuI8IIjDICo8kbiCVuIB5vSjACk1GKtDAAW5AOUfAmMpQN3ETOT4zAPCOw4CF3KwOwFSUbI7C834bKHu22MQDbUNu+dai+dQuNzVuwGIHW+m1g7bbxO4qI/AnjA0RE/qIDXGYAXmYAXoa7foUBeAUe8lapcoUBeBX+0lUEilS4iiCFGIGh3DWEs9cQyVD6GgPwOmK25HXEE9eRiFPsBgPwBlKRG0jbwjeQCd1ANtjCAGxhALYg77PdRMF7E0UPuW8yAG+ifNDKAGxlALaiSrVdYgTWt9vQ2KLNNgZgG7DeZvyGIiL/D+MDRET+Ry5cgsu6BDcj0FO/DG+Nqpfhq1yGnxHoL19BoHQFwSIVrjAAryKco+xVRCiaIUZgLHUN8eQ1JBIUv4YkIzAVo+h1BuB1ZMLXfwjAG8jZAjeQ999AwXcDRW8LA7AFJXcLyjZXCyoHN1Hdp72bDMCbqO+0MgBb0SBrizZbjd9OROTPMD5AROR/5MJFuK2L8DSofhHe+iX4alS9xAC8jECZSpcZgJcRshUuI5y/gkjuCqJZylxBLH0F8fRVxFNXkUheRTJB8asMwGtIRylyDRnKhq8hF7rOALyOfOA6Cv7rzQCkkpc8NxiAN1Bx0UELA7AFNdteC+q7LWjs3IS1TVs3gc2bxm8nIvJnGB8gIvJXceMCPNYFeBt2AF5kAF6Ev3oRgUpTsHwJoRIVLyFcuIRI/jID8DKiFMtS5jID8AoSKUpeYQBeQYrSjMB07Coy0avIRih8lQF4DflgUyFwDUU/+a4zAK+j7CH3dVSoygisHdD+DdT3bqCxSzs3GIAtAJm+mYjIf8P4ABGRv5rXOs8APA9f/Tz89Qvw1y4gUL2AYIXKFxmAFxEuNkUKFxHNX2IAXmIAXkI8cwmJ9OVDydRlpJKUuMwAvIJMjKJXkKVchBiB+dBVFIJXUQyQ/ypKvmso27zXUPFcQ9VNrusMwOuo7zc19q7DYgRajEDTtxIR+QuMDxAR+at5cQ4+ixp2AJ5HoEbV8wzA8wjZyhcQLl1ApHgB0QLlLyKWu4i4LXsRicxFJNOUusQAvIR0wnYZmfhlZGOXkYtS5DLy4csohK4cKgavoBQg/xUG4FVUvOS5iirV3OS6hvrBNTT2r8Hao91rwM5147cSEfkLjA8QEfmb+Kyz8DfOItA4h0D9HIK1cwhVqXIO4fJ5REpN0eJ5xAqUP88AvIBEljIXDgMwRekUJS8ik7iIbJxilxiAl5C3RS6hwAgshih4mQF4GWW/7Qoqviuoeq+g5iH3FdRdV9E4oP2rsAh7V43fSETkf2B8gIjI38SPM/BbdgCeRbBOtbMMwLMI2ypnESmfQ7RExXMMwHOIMwATttx5JLPnkcpQ+jwD8AIyyaZs4gJyjMBc7CID8CIKkYsohil0CSUqBylwCRVGYNVH3ssMwMuo2xiBDdcVWAe0f8X4fURE/grGB4iI/M0C1mkG4BkEKVSn2hkG4BlEGIDRMpXOIkbxIhXOMgDPIZmj7DkG4DmkGYFpRmAmdR7Z5HnkEhQ/j3zsAgq26AUUIxdQYgSWQhcZgBdRCZD/IqpU811CzXuJAXgJDfdlWC46uAyQ6duIiPwVjA8QEfmbBXAKQesUQo3TDMDTCNdOI1JtilbOIFam0hkG4BkkDgPwLJKUyp1FOkuZs8ikzyGbouQ55CifIEZgIXYexShFzjMAz6NsC11AJXgB1cAF1A4D8CLq3otoeJos90XAdcn4XURE/krGB4iI/F2C1kkG4CmEbfVTiNROIVqlymkG4GnES6eRsBVPI1k4g1SecmcYgGeQsQOQsumzyKUoeZYBeBaF+FkUY+cOlaLnUI6cOwzASug8qkEKnEeN6n7yXUDDewGWh9wXjN9DRORvYHyAiMjfJYQTCFknGIAnEamfRLTWFKueRLxyCvHyKQbgKSSLVDiFVOE00nnKnUYmexrZzBnk0pQ6g3zyDAo2RmCREViKUfQsA/AsKmHbOVRD51ALUuDcYQA2fOdheZvgOW/8HiIifwPjA0RE/m5h6zNEGIGRxglE6ycQq1H1BAPwJBLlpmTpJFLFk0gzAtP5U8jkTiGbbcplTiOfptRpBuBpFBMUP8MAPIOyLXoGFUZglRFYC1HwLOqBs2jY/Odg+c4B3nPG7yAi8jcyPkBE5O8WxnEG4HFEG1Q/zgD8DHFKMAITlRNIlk8gVaLiCQbgSWRs+ZPI5k4il6XMKQbgKRRSp1C0JU+hxAgsxyl2GpXoaVQjtjOohc+gHqLgmcMAtPzkO2v8BiIifwfjA0RE/iFR69ihGCMwzgiM144zAI8jWaHycaTKnyFdouJnDMATyOZPIJej7AnkqZA5iUL6JAPwJEpJSpxkAJ5CxRY7hWr0FGoRCp9mAJ5GI3gali1wBvCfMf5+EZG/g/EBIiL/kCg+RcyixjEG4DEkak3J6jGkKseQZgSmS8eRKR5HttCUy3+GfI6ynzEAT6CYptQJlKicJEZgJX4S1dhJ1KIUOYk6I7ARptApBuApIHDK+NtFRP5OxgeIiPzDYvgEcesTJBpU/xTJ2qdIVT9tBiBlylQ6hmzxGHIFyh9nAB5HIXscRVvmOErp4yinPmMAfoZK4gSq8aZa7ATqUWIENsInYYUoeNL4m0VE/gHGB4iI/MPi+JgB+PFhACbrTanaJ0hXqfIJA/BTZEufIle0HUOeEVjIU+4YA/AYSpljzQCkSoqSx1FNHEctTrHPGICfoRH5DFbkBKzwCSB0wvibRUT+AcYHiIj8KBL4CAnrIyQbHyFV/xjpGlU/RoYBmLWVP0Gu9AnyRSp8wgD8BMXcp4dK2U9RZgSW08cYgMdQTR5DLdFUZwQ2YhQ9zgA8DoSPG3+riMg/yPgAEZEfTdL6EKkG1T9EmjK1j5CpfsQA/Ai58scMwI8ZgB+jwAgsMgKLjMBS7hOUs5T5BJX0J6imP0U19SlqyU9RPwzAYwzAY7CiTabfKCLyIzA+QETkR5PEB0gxAtONfwvAD5GtfohcpSlf/hCF0kcMwI8YgB+hlP+YAfgxylTJUsYOwE9QS1HyEwbgJ2iQFf8UVuxTIPqp8TeKiPwIjA8QEflRpa33GYDvI9P4ANk61T5ArvoB8v8egB+iaCt+iFLhQ5TzlPuIAfgRqpmPUEvbPkY99TEayY9/CMBPgNgnxt8mIvIjMT5ARORHlcZ7yFjUeI8B+D5yNaq+jzwVKh+gWKbSBygVP0D5hwCsUDVH2Q9Ry3yIeppSHzIAP4JlS3xk/F0iIj8i4wNERH50GetdZBvvImerv4d87T0UqlR5jwH4PkqlpnLxfVQKHzAAP2AAfoBa9oNmAFKDEWgxAq3kh0DiQ+NvEhH5ERkfICLyo8uCAWg1AzBfp9q7DMB3UbRV3kWp/B7KJSq+xwB8D9X8+6jZcu+jnn0fjQylP2AAfgAkPzD+HhGRH5nxASIiP4mc9Q4D8B3kGYEFRmCx1gzAEgOwXKbSu6hQtUiFdxmA76Geo+x7DMD3YNnS7xt/h4jIT8D4ABGRn0QObyNvvY0CI7BQf4cB+A5Ktuo7KFfeQaX8HwFYKzTV8++ikXsXVpYy7wLpd42/Q0TkJ2B8gIjIT+YwAKnYoPrbDMC3Ua6+/UMAvoMq1UpUfAf1wjto/EkAIqv4E5E3lvEBIiI/mQLeQtGixlso1d9CuWZ7GxVGYLVC5bcZgG+jXqTC22gwAq085d4xvl1E5CdkfICIyE+qaP0cJVvj5ygzAiuMwEr1LQbgW6iVm+qlt9BgBFqMQCv/NpB72/huEZGfkPEBIiI/qSKaAVg+DMCfMwB/jirVqlT5OeoMwMZhAL7FAHwLINObRUR+YsYHiIj85MqMwDIjsMIIrNb/IwDrlaZG+eewSlT8ufGtIiIOMD5AROQnZwdg5U8CsGZjBNYZgQ0GoPVDAEIBKCJHg/EBIiKOqOBnqFo/Q63xs8MArDMAG/8WgISy4k9EjgzjA0REHPNvAVivNzVqP4NVpcrPjG8TEXGQ8QEiIo6pgQHICKwzAhsMQOuHAIQCUESOFuMDREQcVbf+BY2GjfHHCERN8SciR47xASIijqqD8ccItBiBVt38HhERA4wPEBFxnPVDAKJhfouIiAHGB4iIOM4C488yv0NExBDjA0RERETEWcYHiIiIiIizjA8QEREREWcZHyAiIiIizjI+QEREREScZXyAiIiIiDjL+AARERERcZbxASIiIiLiLOMDRERERMRZxgeIiIiIiLOMDxARERERZxkfICIiIiLOMj5ARERERJxlfICIiIiIOMv4ABERERFxlvEBIiIiIuIs4wNERERExFnGB4iIiIiIs4wPEBERERFnGR8gIiIiIs4yPkBEREREnGV8gIiIiIg4y/gAEREREXGW8QEiIiIi4izjA0RERETEWcYHiIiIiIizjA8QEREREWcZHyAiIiIizjI+QEREREScZXyAiIiIiDjL+AARERERcZbxASIiIiLiLOMDRERERMRZxgeIiIiIiLOMDxARERERZxkfICIiIiLOMj5ARERERJxlfICIiIiIOMv4ABERERFxlvEBIiIiIuIs4wNERERExFnGB4iIiIiIs4wPEBERERFnGR8gIiIiIs4yPkBEREREnGV8gIiIiIg4y/gAEREREXGW8QEiIiIi4izjA0RERETEWcYHiIiIiIizjA8QEREREWcZHyAiIiIizjI+QEREREScZXyAiIiIiDjL+AARERERcZbxASIiIiLiLOMDRERERMRZxgeIiIiIiLOMDxARERERZxkfICIiIiLOMj5ARERERJxlfICIiIiIOMv4ABERERFxlvEBIiIiIuIs4wNERERExFnGB4iIiIiIs4wPEBERERFnGR8gIiIiIs4yPkBEREREnGV8gIiIiIg4y/gAEREREXGW8QEiIiIi4izjA0RERETEWcYHiIiIiIizjA8QEREREWcZHyAiIiIizjI+QEREREScZXyAiIiIiDjL+AARERERcZbxASIiIiLiLOMDRERERMRZxgeIiIiIiLOMDxARERERZxkfICIiIiLOMj5ARERERJxlfICIiIiIOMv4ABERERFxlvEBIiIiIuIs4wNERERExFnGB4iIiIiIs4wPEBERERFnGR8gIiIiIs4yPkBEREREnGV8gIiIiIg4y/gAEREREXGW8QEiIiIi4izjA0RERETEWcYHiIiIiIizjA8QEREREWcZHyAiIiIizjI+QEREREScZXyAiIiIiDjL+AARERERcZbxASIiIiLiLOMDRERERMRZxgeIiIiIiLOMDxARERERZxkfICIiIiLOMj5ARERERJxlfICIiIiIOMv4ABERERFxlvEBIiIiIuIs4wNERERExFnGB4iIiIiIs4wPEBERERFnGR8gIiIiIs4yPkBEREREnGV8gIiIiIg4y/gAEREREXGW8QEiIiIi4izjA0RERETEQf8X7TTCXUD5p70AAAAASUVORK5CYII=' style='width:640.0px;height:480.0px;' /><div style='position: absolute; top:0; left:0; padding:1px 3px; background: #777; color:#fff; font-size: 90%; font-family:sans-serif; '>snapshot</div></div>"
+      ],
+      "text/plain": [
+       "JupyterWgpuCanvas(css_height='480px', css_width='640px')"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from wgpu.gui.auto import WgpuCanvas, run\n",
     "import triangle\n",
-    "\n",
+    "         \n",
     "canvas = WgpuCanvas(size=(640, 480), title=\"wgpu triangle with GLFW\")\n",
     "\n",
     "triangle.main(canvas)\n",
@@ -46,10 +79,51 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "e4f9f67d",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Available adapters on this system:\n",
+      "Apple M1 Pro (IntegratedGPU) via Metal\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "871cd2fc00334b1b8c7f82e2676916a3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "RFBOutputContext()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f6aa0a0596cc47a2a5c63e6ecaa32991",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/html": [
+       "<div class='snapshot-f6aa0a0596cc47a2a5c63e6ecaa32991' style='position:relative;'><img src='data:image/png;base64,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' style='width:640.0px;height:480.0px;' /><div style='position: absolute; top:0; left:0; padding:1px 3px; background: #777; color:#fff; font-size: 90%; font-family:sans-serif; '>snapshot</div></div>"
+      ],
+      "text/plain": [
+       "JupyterWgpuCanvas(css_height='480px', css_width='640px')"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from cube import canvas\n",
     "\n",
@@ -61,33 +135,48 @@
    "id": "749ffb40",
    "metadata": {},
    "source": [
-    "## Event example\n",
-    "\n",
-    "The code below is a copy from `show_events.py`. It is just to show how events are handled. These events are the same across all auto-backends."
+    "## Events"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "c858215a",
+   "execution_count": 3,
+   "id": "6d0e64b7-a208-4be6-99eb-9f666ab8c2ae",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a670ad10911d4335bd54a71d2585deda",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Textarea(value='', rows=10)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "from wgpu.gui.auto import WgpuCanvas, run\n",
+    "import ipywidgets\n",
     "\n",
-    "class MyCanvas(WgpuCanvas):\n",
-    "    def handle_event(self, event):\n",
-    "        if event[\"event_type\"] != \"pointer_move\":\n",
-    "            print(event)\n",
+    "out = ipywidgets.Textarea(rows=10)\n",
     "\n",
-    "canvas = MyCanvas(size=(640, 480), title=\"wgpu triangle with GLFW\")\n",
-    "canvas"
+    "@canvas.add_event_handler(\"*\")\n",
+    "def show_events(event):\n",
+    "    if event[\"event_type\"] != \"pointer_move\":\n",
+    "        out.value = str(event)\n",
+    "\n",
+    "out"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "6b92d13b",
+   "id": "17773a3a-aae1-4307-9bdb-220b14802a68",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -109,7 +198,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.9"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,

From 40e70712e397dde3141fab31b53b323ff90c0b6b Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 15:56:46 +0200
Subject: [PATCH 15/24] docs

---
 docs/gui.rst     | 1 -
 wgpu/gui/base.py | 6 ++++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/docs/gui.rst b/docs/gui.rst
index d54459d0..0680992f 100644
--- a/docs/gui.rst
+++ b/docs/gui.rst
@@ -21,7 +21,6 @@ The Canvas base classes
     ~WgpuCanvasInterface
     ~WgpuCanvasBase
     ~WgpuAutoGui
-    ~WgpuOffscreenCanvasBase
 
 
 For each supported GUI toolkit there is a module that implements a ``WgpuCanvas`` class,
diff --git a/wgpu/gui/base.py b/wgpu/gui/base.py
index ebd01282..beb2b68e 100644
--- a/wgpu/gui/base.py
+++ b/wgpu/gui/base.py
@@ -80,6 +80,12 @@ def get_context(self, kind="webgpu"):
         return self._canvas_context
 
     def present_image(self, image, **kwargs):
+        """Consume the final rendered image.
+
+        This is called when using the "image" method, see ``get_surface_info()``.
+        Canvases that don't support offscreen rendering don't need to implement
+        this method.
+        """
         raise NotImplementedError()
 
 

From d7d2db588578af478a821f7b708ff3748ef1209d Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 16:06:34 +0200
Subject: [PATCH 16/24] minor tweaks

---
 wgpu/gui/base.py | 12 +++++-------
 wgpu/gui/glfw.py |  5 +++--
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/wgpu/gui/base.py b/wgpu/gui/base.py
index beb2b68e..400dfb57 100644
--- a/wgpu/gui/base.py
+++ b/wgpu/gui/base.py
@@ -11,10 +11,8 @@ def create_canvas_context(canvas):
         raise RuntimeError(
             "A backend must be selected (e.g. with request_adapter()) before canvas.get_context() can be called."
         )
-    # Instantiate the context
-    CC = sys.modules[backend_module].GPUCanvasContext  # noqa: N806
-    # CC = sys.modules["wgpu"]._classes.GPUCanvasContext
-    return CC(canvas)
+    CanvasContext = sys.modules[backend_module].GPUCanvasContext  # noqa: N806
+    return CanvasContext(canvas)
 
 
 class WgpuCanvasInterface:
@@ -34,9 +32,9 @@ def __init__(self, *args, **kwargs):
     def get_surface_info(self):
         """Get information about the surface to render to.
 
-        The result is a small dict, by which the context determines how the
-        rendered image is presented to the canvas. There are two possible
-        methods.
+        The result is a small dict, used by the canvas-context to determine how
+        the rendered result should be presented to the canvas. There are two
+        possible methods.
 
         If the ``method`` field is "screen", the context will render directly
         to a surface representing the region on the screen. The dict should
diff --git a/wgpu/gui/glfw.py b/wgpu/gui/glfw.py
index ec74cd7d..725c9fa8 100644
--- a/wgpu/gui/glfw.py
+++ b/wgpu/gui/glfw.py
@@ -519,8 +519,9 @@ def _on_char(self, window, char):
 
     def present_image(self, image, **kwargs):
         raise NotImplementedError()
-        # glfw does not have a way to blit an image.
-        # We could use OpenGL to display it though.
+        # AFAIK glfw does not have a builtin way to blit an image. It also does
+        # not really need one, since it's the most reliable GUI backend to
+        # render to the screen.
 
 
 # Make available under a name that is the same for all gui backends

From c8bb1bf926745fde5d1832c5c868cb600bf92247 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Tue, 17 Sep 2024 16:18:40 +0200
Subject: [PATCH 17/24] update tests

---
 tests/test_gui_base.py | 47 ++++++++++++++++--------------------------
 1 file changed, 18 insertions(+), 29 deletions(-)

diff --git a/tests/test_gui_base.py b/tests/test_gui_base.py
index 1b8ac2ba..173c1597 100644
--- a/tests/test_gui_base.py
+++ b/tests/test_gui_base.py
@@ -9,7 +9,7 @@
 import numpy as np
 import wgpu.gui  # noqa
 from testutils import run_tests, can_use_wgpu_lib, is_pypy
-from pytest import mark
+from pytest import mark, raises
 
 
 class TheTestCanvas(wgpu.gui.WgpuCanvasBase):
@@ -37,10 +37,10 @@ def spam_method(self):
 def test_base_canvas_context():
     assert not issubclass(wgpu.gui.WgpuCanvasInterface, wgpu.GPUCanvasContext)
     assert hasattr(wgpu.gui.WgpuCanvasInterface, "get_context")
-    # Provides good default already
     canvas = wgpu.gui.WgpuCanvasInterface()
-    ctx = wgpu.GPUCanvasContext(canvas)
-    assert ctx.get_preferred_format(None) == "bgra8unorm-srgb"
+    # Cannot instantiate, because get_surface_info is not implemented
+    with raises(NotImplementedError):
+        wgpu.GPUCanvasContext(canvas)
 
 
 def test_canvas_logging(caplog):
@@ -80,12 +80,22 @@ def test_canvas_logging(caplog):
     assert text.count("division by zero") == 4
 
 
-class MyOffscreenCanvas(wgpu.gui.WgpuOffscreenCanvasBase):
+class MyOffscreenCanvas(wgpu.gui.WgpuCanvasBase):
     def __init__(self):
         super().__init__()
-        self.textures = []
+        self.frame_count = 0
         self.physical_size = 100, 100
 
+    def get_surface_info(self):
+        return {
+            "method": "image",
+            "formats": ["rgba8unorm-srgb"],
+        }
+
+    def present_image(self, image, **kwargs):
+        self.frame_count += 1
+        self.array = np.frombuffer(image, np.uint8).reshape(image.shape)
+
     def get_pixel_ratio(self):
         return 1
 
@@ -99,26 +109,6 @@ def _request_draw(self):
         # Note: this would normally schedule a call in a later event loop iteration
         self._draw_frame_and_present()
 
-    def present(self, texture):
-        self.textures.append(texture)
-        device = texture._device
-        size = texture.size
-        bytes_per_pixel = 4
-        data = device.queue.read_texture(
-            {
-                "texture": texture,
-                "mip_level": 0,
-                "origin": (0, 0, 0),
-            },
-            {
-                "offset": 0,
-                "bytes_per_row": bytes_per_pixel * size[0],
-                "rows_per_image": size[1],
-            },
-            size,
-        )
-        self.array = np.frombuffer(data, np.uint8).reshape(size[1], size[0], 4)
-
 
 @mark.skipif(not can_use_wgpu_lib, reason="Needs wgpu lib")
 def test_run_bare_canvas():
@@ -181,7 +171,7 @@ def draw_frame():
         render_pass.end()
         device.queue.submit([command_encoder.finish()])
 
-    assert len(canvas.textures) == 0
+    assert canvas.frame_count == 0
 
     # Draw 1
     canvas.request_draw(draw_frame)
@@ -214,8 +204,7 @@ def draw_frame():
     assert np.all(canvas.array[:, :, 1] == 255)
 
     # We now have four unique texture objects
-    assert len(canvas.textures) == 4
-    assert len(set(canvas.textures)) == 4
+    assert canvas.frame_count == 4
 
 
 def test_autogui_mixin():

From fa5b77c2da2a51aabb94c9a05606498a7ea8185d Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Wed, 18 Sep 2024 09:49:11 +0200
Subject: [PATCH 18/24] Fix memtest

---
 tests_mem/test_gui.py    | 2 +-
 tests_mem/test_gui_qt.py | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests_mem/test_gui.py b/tests_mem/test_gui.py
index 1ddb1576..7f67bc01 100644
--- a/tests_mem/test_gui.py
+++ b/tests_mem/test_gui.py
@@ -23,7 +23,7 @@ def make_draw_func_for_canvas(canvas):
     so that we can really present something to a canvas being tested.
     """
     ctx = canvas.get_context()
-    ctx.configure(device=DEVICE, format="bgra8unorm-srgb")
+    ctx.configure(device=DEVICE, format=None)
 
     def draw():
         ctx = canvas.get_context()
diff --git a/tests_mem/test_gui_qt.py b/tests_mem/test_gui_qt.py
index c0043e7e..aec6c046 100644
--- a/tests_mem/test_gui_qt.py
+++ b/tests_mem/test_gui_qt.py
@@ -36,7 +36,9 @@ def test_release_canvas_context(n):
     if app is None:
         app = PySide6.QtWidgets.QApplication([""])
 
-    yield {}
+    yield {
+        "ignore": {"CommandBuffer"},
+    }
 
     canvases = weakref.WeakSet()
 

From 8e3d56a2edca7b113c0ccabd3154acaa8bd04c02 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Wed, 18 Sep 2024 09:50:59 +0200
Subject: [PATCH 19/24] remove debug text overlay

---
 wgpu/gui/qt.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index c66b4a4e..462331f6 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -410,9 +410,9 @@ def present_image(self, image_data, **kwargs):
         painter.drawImage(rect2, image, rect1)
 
         # Uncomment for testing purposes
-        painter.setPen(QtGui.QColor("#0000ff"))
-        painter.setFont(QtGui.QFont("Arial", 30))
-        painter.drawText(100, 100, "This is an image")
+        # painter.setPen(QtGui.QColor("#0000ff"))
+        # painter.setFont(QtGui.QFont("Arial", 30))
+        # painter.drawText(100, 100, "This is an image")
 
 
 class QWgpuCanvas(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):

From 588a8dfb880f99c4b7ace8533b350f6aff598c61 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Wed, 18 Sep 2024 10:15:36 +0200
Subject: [PATCH 20/24] Bit of docstrings

---
 wgpu/gui/base.py | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/wgpu/gui/base.py b/wgpu/gui/base.py
index 400dfb57..4fd80fcf 100644
--- a/wgpu/gui/base.py
+++ b/wgpu/gui/base.py
@@ -6,6 +6,11 @@
 
 
 def create_canvas_context(canvas):
+    """ Create a GPUCanvasContext for the given canvas.
+
+    Helper function to keep the implementation of WgpuCanvasInterface
+    as small as possible.
+    """
     backend_module = sys.modules["wgpu"].gpu.__module__
     if backend_module == "wgpu._classes":
         raise RuntimeError(
@@ -32,9 +37,9 @@ def __init__(self, *args, **kwargs):
     def get_surface_info(self):
         """Get information about the surface to render to.
 
-        The result is a small dict, used by the canvas-context to determine how
-        the rendered result should be presented to the canvas. There are two
-        possible methods.
+        It must return a small dict, used by the canvas-context to determine
+        how the rendered result should be presented to the canvas. There are
+        two possible methods.
 
         If the ``method`` field is "screen", the context will render directly
         to a surface representing the region on the screen. The dict should
@@ -44,15 +49,16 @@ def get_surface_info(self):
         by wgpu to obtain the required surface id.
 
         When the ``method`` field is "image", the context will render to a
-        texture, load the result into RAM, and call ``canvas.present_image()``
+        texture, download the result to RAM, and call ``canvas.present_image()``
         with the image data. Additional info (like format) is passed as kwargs.
         This method enables various types of canvases (including remote ones),
         but note that it has a performance penalty compared to rendering
         directly to the screen.
 
         The dict can further contain fields ``formats`` and ``alpha_modes`` to
-        define the canvas capabilities. By default formats is
-        ``["rgba8unorm-srgb", "rgba8unorm"]``, and alpha_modes is ``["opaque"]``.
+        define the canvas capabilities. For the "image" method, the default
+        formats is ``["rgba8unorm-srgb", "rgba8unorm"]``, and the default
+        alpha_modes is ``["opaque"]``.
         """
         raise NotImplementedError()
 

From 2e4d12551c004a43d1ef720a3d6740d8c350fd94 Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Wed, 18 Sep 2024 10:27:40 +0200
Subject: [PATCH 21/24] explaine purpose of canvas context

---
 wgpu/_classes.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/wgpu/_classes.py b/wgpu/_classes.py
index 3e2802b9..acd91651 100644
--- a/wgpu/_classes.py
+++ b/wgpu/_classes.py
@@ -173,11 +173,14 @@ def wgsl_language_features(self):
 
 
 class GPUCanvasContext:
-    """Represents a context to configure a canvas.
-
-    Is also used to obtain the texture to render to.
+    """Represents a context to configure a canvas and render to it.
 
     Can be obtained via `gui.WgpuCanvasInterface.get_context()`.
+
+    The canvas-context plays a crucial role in connecting the wgpu API to the
+    GUI layer, in a way that allows the GUI to be agnostic about wgpu. It
+    combines (and checks) the user's preferences with the capabilities and
+    preferences of the canvas.
     """
 
     _ot = object_tracker

From 02c9600ae28608eeed1400f6c91385e7432d805a Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Wed, 18 Sep 2024 10:42:20 +0200
Subject: [PATCH 22/24] Rename surface_info -> present_info

---
 examples/triangle_glfw_direct.py      |  6 +++---
 examples/triangle_subprocess.py       |  8 ++++----
 tests/test_gui_base.py                |  4 ++--
 tests/test_gui_glfw.py                |  2 +-
 wgpu/_classes.py                      | 22 +++++++++++-----------
 wgpu/backends/wgpu_native/_api.py     |  4 ++--
 wgpu/backends/wgpu_native/_helpers.py | 20 ++++++++++----------
 wgpu/gui/base.py                      |  6 +++---
 wgpu/gui/glfw.py                      |  6 +++---
 wgpu/gui/jupyter.py                   |  2 +-
 wgpu/gui/offscreen.py                 |  2 +-
 wgpu/gui/qt.py                        | 16 ++++++++--------
 wgpu/gui/wx.py                        | 16 ++++++++--------
 13 files changed, 57 insertions(+), 57 deletions(-)

diff --git a/examples/triangle_glfw_direct.py b/examples/triangle_glfw_direct.py
index 7336eaf3..16aaa1e0 100644
--- a/examples/triangle_glfw_direct.py
+++ b/examples/triangle_glfw_direct.py
@@ -14,7 +14,7 @@
 import glfw
 
 from wgpu.backends.wgpu_native import GPUCanvasContext
-from wgpu.gui.glfw import get_surface_info, get_physical_size
+from wgpu.gui.glfw import get_glfw_present_info, get_physical_size
 from wgpu.utils.device import get_default_device
 
 
@@ -29,9 +29,9 @@ class GlfwCanvas:
     def __init__(self, window):
         self._window = window
 
-    def get_surface_info(self):
+    def get_present_info(self):
         """get window and display id, includes some triage to deal with OS differences"""
-        return get_surface_info(self._window)
+        return get_glfw_present_info(self._window)
 
     def get_physical_size(self):
         """get framebuffer size in integer pixels"""
diff --git a/examples/triangle_subprocess.py b/examples/triangle_subprocess.py
index 59557fd2..5c6a76a7 100644
--- a/examples/triangle_subprocess.py
+++ b/examples/triangle_subprocess.py
@@ -31,7 +31,7 @@
 app = QtWidgets.QApplication([])
 canvas = WgpuCanvas(title="wgpu triangle in Qt subprocess")
 
-print(json.dumps(canvas.get_surface_info()))
+print(json.dumps(canvas.get_present_info()))
 print(canvas.get_physical_size())
 sys.stdout.flush()
 
@@ -42,15 +42,15 @@
 class ProxyCanvas(WgpuCanvasBase):
     def __init__(self):
         super().__init__()
-        self._surface_info = json.loads(p.stdout.readline().decode())
+        self._present_info = json.loads(p.stdout.readline().decode())
         self._psize = tuple(
             int(x) for x in p.stdout.readline().decode().strip().strip("()").split(",")
         )
         print(self._psize)
         time.sleep(0.2)
 
-    def get_surface_info(self):
-        return self._surface_info
+    def get_present_info(self):
+        return self._present_info
 
     def get_physical_size(self):
         return self._psize
diff --git a/tests/test_gui_base.py b/tests/test_gui_base.py
index 173c1597..5f06dddc 100644
--- a/tests/test_gui_base.py
+++ b/tests/test_gui_base.py
@@ -38,7 +38,7 @@ def test_base_canvas_context():
     assert not issubclass(wgpu.gui.WgpuCanvasInterface, wgpu.GPUCanvasContext)
     assert hasattr(wgpu.gui.WgpuCanvasInterface, "get_context")
     canvas = wgpu.gui.WgpuCanvasInterface()
-    # Cannot instantiate, because get_surface_info is not implemented
+    # Cannot instantiate, because get_present_info is not implemented
     with raises(NotImplementedError):
         wgpu.GPUCanvasContext(canvas)
 
@@ -86,7 +86,7 @@ def __init__(self):
         self.frame_count = 0
         self.physical_size = 100, 100
 
-    def get_surface_info(self):
+    def get_present_info(self):
         return {
             "method": "image",
             "formats": ["rgba8unorm-srgb"],
diff --git a/tests/test_gui_glfw.py b/tests/test_gui_glfw.py
index 10c75d64..32a77edd 100644
--- a/tests/test_gui_glfw.py
+++ b/tests/test_gui_glfw.py
@@ -171,7 +171,7 @@ def __init__(self):
             self.window = glfw.create_window(300, 200, "canvas", None, None)
             self._present_context = None
 
-        def get_surface_info(self):
+        def get_present_info(self):
             if sys.platform.startswith("win"):
                 return {
                     "platform": "windows",
diff --git a/wgpu/_classes.py b/wgpu/_classes.py
index acd91651..3bd6ba23 100644
--- a/wgpu/_classes.py
+++ b/wgpu/_classes.py
@@ -189,11 +189,11 @@ def __init__(self, canvas):
         self._ot.increase(self.__class__.__name__)
         self._canvas_ref = weakref.ref(canvas)
 
-        # The configuration from the canvas, obtained with canvas.get_surface_info()
-        self._surface_info = canvas.get_surface_info()
-        if self._surface_info.get("method", None) not in ("screen", "image"):
+        # The configuration from the canvas, obtained with canvas.get_present_info()
+        self._present_info = canvas.get_present_info()
+        if self._present_info.get("method", None) not in ("screen", "image"):
             raise RuntimeError(
-                "canvas.get_surface_info() must produce a dict with a field 'method' that is either 'screen' or 'image'."
+                "canvas.get_present_info() must produce a dict with a field 'method' that is either 'screen' or 'image'."
             )
 
         # Surface capabilities. Stored the first time it is obtained
@@ -219,7 +219,7 @@ def _get_capabilities(self, adapter):
         """Get dict of capabilities and cache the result."""
         if self._capabilities is None:
             self._capabilities = {}
-            if self._surface_info["method"] == "screen":
+            if self._present_info["method"] == "screen":
                 # Query capabilities from the surface
                 self._capabilities.update(self._get_capabilities_screen(adapter))
             else:
@@ -231,8 +231,8 @@ def _get_capabilities(self, adapter):
                 }
             # If capabilities were provided via surface info, overload them!
             for key in ["formats", "alpha_modes"]:
-                if key in self._surface_info:
-                    self._capabilities[key] = self._surface_info[key]
+                if key in self._present_info:
+                    self._capabilities[key] = self._present_info[key]
             # Derived defaults
             if "view_formats" not in self._capabilities:
                 self._capabilities["view_formats"] = self._capabilities["formats"]
@@ -341,7 +341,7 @@ def configure(
             "alpha_mode": alpha_mode,
         }
 
-        if self._surface_info["method"] == "screen":
+        if self._present_info["method"] == "screen":
             self._configure_screen(**self._config)
 
     def _configure_screen(
@@ -362,7 +362,7 @@ def unconfigure(self):
         """Removes the presentation context configuration.
         Destroys any textures produced while configured.
         """
-        if self._surface_info["method"] == "screen":
+        if self._present_info["method"] == "screen":
             self._unconfigure_screen()
         self._config = None
         self._drop_texture()
@@ -385,7 +385,7 @@ def get_current_texture(self):
         # Right now we return the existing texture, so user can retrieve it in different render passes that write to the same frame.
 
         if self._texture is None:
-            if self._surface_info["method"] == "screen":
+            if self._present_info["method"] == "screen":
                 self._texture = self._create_texture_screen()
             else:
                 self._texture = self._create_texture_image()
@@ -434,7 +434,7 @@ def present(self):
             logger.debug(msg)
             return
 
-        if self._surface_info["method"] == "screen":
+        if self._present_info["method"] == "screen":
             self._present_screen()
         else:
             self._present_image()
diff --git a/wgpu/backends/wgpu_native/_api.py b/wgpu/backends/wgpu_native/_api.py
index 4a232382..0bb1d0ea 100644
--- a/wgpu/backends/wgpu_native/_api.py
+++ b/wgpu/backends/wgpu_native/_api.py
@@ -454,8 +454,8 @@ def __init__(self, canvas):
 
         # Obtain the surface id. The lifetime is of the surface is bound
         # to the lifetime of this context object.
-        if self._surface_info["method"] == "screen":
-            self._surface_id = get_surface_id_from_info(self._surface_info)
+        if self._present_info["method"] == "screen":
+            self._surface_id = get_surface_id_from_info(self._present_info)
         else:  # method == "image"
             self._surface_id = ffi.NULL
 
diff --git a/wgpu/backends/wgpu_native/_helpers.py b/wgpu/backends/wgpu_native/_helpers.py
index a7b15fee..05e6dee2 100644
--- a/wgpu/backends/wgpu_native/_helpers.py
+++ b/wgpu/backends/wgpu_native/_helpers.py
@@ -94,7 +94,7 @@ def get_wgpu_instance():
     return _the_instance
 
 
-def get_surface_id_from_info(surface_info):
+def get_surface_id_from_info(present_info):
     """Get an id representing the surface to render to. The way to
     obtain this id differs per platform and GUI toolkit.
     """
@@ -103,7 +103,7 @@ def get_surface_id_from_info(surface_info):
         GetModuleHandle = ctypes.windll.kernel32.GetModuleHandleW  # noqa
         struct = ffi.new("WGPUSurfaceDescriptorFromWindowsHWND *")
         struct.hinstance = ffi.cast("void *", GetModuleHandle(lib_path))
-        struct.hwnd = ffi.cast("void *", int(surface_info["window"]))
+        struct.hwnd = ffi.cast("void *", int(present_info["window"]))
         struct.chain.sType = lib.WGPUSType_SurfaceDescriptorFromWindowsHWND
 
     elif sys.platform.startswith("darwin"):  # no-cover
@@ -117,7 +117,7 @@ def get_surface_id_from_info(surface_info):
         #     [ns_window.contentView setLayer:metal_layer];
         #     surface = wgpu_create_surface_from_metal_layer(metal_layer);
         # }
-        window = ctypes.c_void_p(surface_info["window"])
+        window = ctypes.c_void_p(present_info["window"])
 
         cw = ObjCInstance(window)
         try:
@@ -158,22 +158,22 @@ def get_surface_id_from_info(surface_info):
         struct.chain.sType = lib.WGPUSType_SurfaceDescriptorFromMetalLayer
 
     elif sys.platform.startswith("linux"):  # no-cover
-        platform = surface_info.get("platform", "x11")
+        platform = present_info.get("platform", "x11")
         if platform == "x11":
             struct = ffi.new("WGPUSurfaceDescriptorFromXlibWindow *")
-            struct.display = ffi.cast("void *", surface_info["display"])
-            struct.window = int(surface_info["window"])
+            struct.display = ffi.cast("void *", present_info["display"])
+            struct.window = int(present_info["window"])
             struct.chain.sType = lib.WGPUSType_SurfaceDescriptorFromXlibWindow
         elif platform == "wayland":
             struct = ffi.new("WGPUSurfaceDescriptorFromWaylandSurface *")
-            struct.display = ffi.cast("void *", surface_info["display"])
-            struct.surface = ffi.cast("void *", surface_info["window"])
+            struct.display = ffi.cast("void *", present_info["display"])
+            struct.surface = ffi.cast("void *", present_info["window"])
             struct.chain.sType = lib.WGPUSType_SurfaceDescriptorFromWaylandSurface
         elif platform == "xcb":
             # todo: xcb untested
             struct = ffi.new("WGPUSurfaceDescriptorFromXcbWindow *")
-            struct.connection = ffi.cast("void *", surface_info["connection"])  # ??
-            struct.window = int(surface_info["window"])
+            struct.connection = ffi.cast("void *", present_info["connection"])  # ??
+            struct.window = int(present_info["window"])
             struct.chain.sType = lib.WGPUSType_SurfaceDescriptorFromXlibWindow
         else:
             raise RuntimeError("Unexpected Linux surface platform '{platform}'.")
diff --git a/wgpu/gui/base.py b/wgpu/gui/base.py
index 4fd80fcf..cedf82bf 100644
--- a/wgpu/gui/base.py
+++ b/wgpu/gui/base.py
@@ -6,7 +6,7 @@
 
 
 def create_canvas_context(canvas):
-    """ Create a GPUCanvasContext for the given canvas.
+    """Create a GPUCanvasContext for the given canvas.
 
     Helper function to keep the implementation of WgpuCanvasInterface
     as small as possible.
@@ -34,7 +34,7 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._canvas_context = None
 
-    def get_surface_info(self):
+    def get_present_info(self):
         """Get information about the surface to render to.
 
         It must return a small dict, used by the canvas-context to determine
@@ -86,7 +86,7 @@ def get_context(self, kind="webgpu"):
     def present_image(self, image, **kwargs):
         """Consume the final rendered image.
 
-        This is called when using the "image" method, see ``get_surface_info()``.
+        This is called when using the "image" method, see ``get_present_info()``.
         Canvases that don't support offscreen rendering don't need to implement
         this method.
         """
diff --git a/wgpu/gui/glfw.py b/wgpu/gui/glfw.py
index 725c9fa8..595a99ea 100644
--- a/wgpu/gui/glfw.py
+++ b/wgpu/gui/glfw.py
@@ -104,7 +104,7 @@
 }
 
 
-def get_surface_info(window):
+def get_glfw_present_info(window):
 
     if sys.platform.startswith("win"):
         return {
@@ -303,8 +303,8 @@ def _set_logical_size(self, new_logical_size):
 
     # API
 
-    def get_surface_info(self):
-        return get_surface_info(self._window)
+    def get_present_info(self):
+        return get_glfw_present_info(self._window)
 
     def get_pixel_ratio(self):
         return self._pixel_ratio
diff --git a/wgpu/gui/jupyter.py b/wgpu/gui/jupyter.py
index e5f6ca74..c8ca44eb 100644
--- a/wgpu/gui/jupyter.py
+++ b/wgpu/gui/jupyter.py
@@ -92,7 +92,7 @@ def _request_draw(self):
 
     # Implementation needed for WgpuCanvasInterface
 
-    def get_surface_info(self):
+    def get_present_info(self):
         # Use a format that maps well to PNG: rgba8norm. Use srgb for
         # perseptive color mapping. This is the common colorspace for
         # e.g. png and jpg images. Most tools (browsers included) will
diff --git a/wgpu/gui/offscreen.py b/wgpu/gui/offscreen.py
index 0c613018..b9ce8983 100644
--- a/wgpu/gui/offscreen.py
+++ b/wgpu/gui/offscreen.py
@@ -17,7 +17,7 @@ def __init__(self, *args, size=None, pixel_ratio=1, title=None, **kwargs):
         self._closed = False
         self._last_image = None
 
-    def get_surface_info(self):
+    def get_present_info(self):
         return {
             "method": "image",
             "formats": ["rgba8unorm-srgb", "rgba8unorm"],
diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index 462331f6..668f5dd0 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -145,8 +145,8 @@ class QWgpuWidget(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
     def __init__(self, *args, draw_to_screen=True, **kwargs):
         super().__init__(*args, **kwargs)
 
-        self._raw_surface_info = self._get_raw_surface_info()
-        self._draw_to_screen = draw_to_screen and bool(self._raw_surface_info)
+        self._surface_ids = self._get_surface_ids()
+        self._draw_to_screen = draw_to_screen and bool(self._surface_ids)
 
         self.setAttribute(WA_PaintOnScreen, self._draw_to_screen)
         self.setAutoFillBackground(False)
@@ -173,7 +173,7 @@ def paintEvent(self, event):  # noqa: N802 - this is a Qt method
 
     # Methods that we add from wgpu (snake_case)
 
-    def _get_raw_surface_info(self):
+    def _get_surface_ids(self):
         if sys.platform.startswith("win") or sys.platform.startswith("darwin"):
             return {
                 "window": int(self.winId()),
@@ -198,11 +198,11 @@ def _get_raw_surface_info(self):
                     "display": int(get_alt_x11_display()),
                 }
 
-    def get_surface_info(self):
+    def get_present_info(self):
         global _show_image_method_warning
-        if self._draw_to_screen and self._raw_surface_info:
+        if self._draw_to_screen and self._surface_ids:
             info = {"method": "screen"}
-            info.update(self._raw_surface_info)
+            info.update(self._surface_ids)
         else:
             if _show_image_method_warning:
                 logger.warn(_show_image_method_warning)
@@ -469,8 +469,8 @@ def draw_frame(self):
     def draw_frame(self, f):
         self._subwidget.draw_frame = f
 
-    def get_surface_info(self):
-        return self._subwidget.get_surface_info()
+    def get_present_info(self):
+        return self._subwidget.get_present_info()
 
     def get_pixel_ratio(self):
         return self._subwidget.get_pixel_ratio()
diff --git a/wgpu/gui/wx.py b/wgpu/gui/wx.py
index 61f81060..06797244 100644
--- a/wgpu/gui/wx.py
+++ b/wgpu/gui/wx.py
@@ -137,8 +137,8 @@ class WxWgpuWindow(WgpuAutoGui, WgpuCanvasBase, wx.Window):
     def __init__(self, *args, draw_to_screen=True, **kwargs):
         super().__init__(*args, **kwargs)
 
-        self._raw_surface_info = self._get_raw_surface_info()
-        self._draw_to_screen = draw_to_screen and bool(self._raw_surface_info)
+        self._surface_ids = self._get_surface_ids()
+        self._draw_to_screen = draw_to_screen and bool(self._surface_ids)
 
         # A timer for limiting fps
         self._request_draw_timer = TimerWithCallback(self.Refresh)
@@ -316,7 +316,7 @@ def _on_mouse_move(self, event: wx.MouseEvent):
 
     # Methods that we add from wgpu
 
-    def _get_raw_surface_info(self):
+    def _get_surface_ids(self):
         if sys.platform.startswith("win") or sys.platform.startswith("darwin"):
             return {
                 "window": int(self.GetHandle()),
@@ -339,11 +339,11 @@ def _get_raw_surface_info(self):
         else:
             raise RuntimeError(f"Cannot get Qt surafce info on {sys.platform}.")
 
-    def get_surface_info(self):
+    def get_present_info(self):
         global _show_image_method_warning
-        if self._draw_to_screen and self._raw_surface_info:
+        if self._draw_to_screen and self._surface_ids:
             info = {"method": "screen"}
-            info.update(self._raw_surface_info)
+            info.update(self._surface_ids)
         else:
             if _show_image_method_warning:
                 logger.warn(_show_image_method_warning)
@@ -445,8 +445,8 @@ def Refresh(self):  # noqa: N802
 
     # Methods that we add from wgpu
 
-    def get_surface_info(self):
-        return self._subwidget.get_surface_info()
+    def get_present_info(self):
+        return self._subwidget.get_present_info()
 
     def get_pixel_ratio(self):
         return self._subwidget.get_pixel_ratio()

From 4685a0b20de9474e2961836df958f65ee4efce8b Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Wed, 18 Sep 2024 11:06:41 +0200
Subject: [PATCH 23/24] draw_to_screen -> present_method

---
 wgpu/gui/base.py |  4 ++--
 wgpu/gui/qt.py   | 48 +++++++++++++++++++++++++++++-------------------
 wgpu/gui/wx.py   | 36 +++++++++++++++++++++++-------------
 3 files changed, 54 insertions(+), 34 deletions(-)

diff --git a/wgpu/gui/base.py b/wgpu/gui/base.py
index cedf82bf..ab21c1bd 100644
--- a/wgpu/gui/base.py
+++ b/wgpu/gui/base.py
@@ -110,12 +110,12 @@ class WgpuCanvasBase(WgpuCanvasInterface):
     also want to set ``vsync`` to False.
     """
 
-    def __init__(self, *args, max_fps=30, vsync=True, draw_to_screen=True, **kwargs):
+    def __init__(self, *args, max_fps=30, vsync=True, present_method=None, **kwargs):
         super().__init__(*args, **kwargs)
         self._last_draw_time = 0
         self._max_fps = float(max_fps)
         self._vsync = bool(vsync)
-        draw_to_screen  # We just catch the arg here in case a backend does implement support it
+        present_method  # We just catch the arg here in case a backend does implement support it
 
     def __del__(self):
         # On delete, we call the custom close method.
diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index 668f5dd0..3e73442e 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -142,13 +142,28 @@ def enable_hidpi():
 class QWgpuWidget(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
     """A QWidget representing a wgpu canvas that can be embedded in a Qt application."""
 
-    def __init__(self, *args, draw_to_screen=True, **kwargs):
+    def __init__(self, *args, present_method=None, **kwargs):
         super().__init__(*args, **kwargs)
 
+        # Determine present method
         self._surface_ids = self._get_surface_ids()
-        self._draw_to_screen = draw_to_screen and bool(self._surface_ids)
+        if not present_method:
+            self._present_to_screen = True
+            if SYSTEM_IS_WAYLAND:
+                # Trying to render to screen on Wayland segfaults. This might be because
+                # the "display" is not the real display id. We can tell Qt to use
+                # XWayland, so we can use the X11 path. This worked at some point,
+                # but later this resulted in a Rust panic. So, until this is sorted
+                # out, we fall back to rendering via an image.
+                self._present_to_screen = False
+        elif present_method == "screen":
+            self._present_to_screen = True
+        elif present_method == "image":
+            self._present_to_screen = False
+        else:
+            raise ValueError(f"Invalid present_method {present_method}")
 
-        self.setAttribute(WA_PaintOnScreen, self._draw_to_screen)
+        self.setAttribute(WA_PaintOnScreen, self._present_to_screen)
         self.setAutoFillBackground(False)
         self.setAttribute(WA_DeleteOnClose, True)
         self.setAttribute(WA_InputMethodEnabled, True)
@@ -163,7 +178,7 @@ def __init__(self, *args, draw_to_screen=True, **kwargs):
 
     def paintEngine(self):  # noqa: N802 - this is a Qt method
         # https://doc.qt.io/qt-5/qt.html#WidgetAttribute-enum  WA_PaintOnScreen
-        if self._draw_to_screen:
+        if self._present_to_screen:
             return None
         else:
             return super().paintEngine()
@@ -179,18 +194,13 @@ def _get_surface_ids(self):
                 "window": int(self.winId()),
             }
         elif sys.platform.startswith("linux"):
-            if SYSTEM_IS_WAYLAND:
-                # Trying to do it the Wayland way segfaults. This might be because
-                # the "display" is not the real display id. We can tell Qt to use
-                # XWayland, so we can use the X11 path. This worked at some point,
-                # but later this resulted in a Rust panic. So, until this is sorted
-                # out, we fall back to rendering via an image.
-                return None
-                # return {
-                #     "platform": "wayland",
-                #     "window": int(self.winId()),
-                #     "display": int(get_alt_wayland_display()),
-                # }
+            if False:
+                # We fall back to XWayland, see _gui_utils.py
+                return {
+                    "platform": "wayland",
+                    "window": int(self.winId()),
+                    "display": int(get_alt_wayland_display()),
+                }
             else:
                 return {
                     "platform": "x11",
@@ -200,7 +210,7 @@ def _get_surface_ids(self):
 
     def get_present_info(self):
         global _show_image_method_warning
-        if self._draw_to_screen and self._surface_ids:
+        if self._present_to_screen:
             info = {"method": "screen"}
             info.update(self._surface_ids)
         else:
@@ -424,7 +434,7 @@ class QWgpuCanvas(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
     # detect this. See https://github.com/pygfx/wgpu-py/pull/68
 
     def __init__(
-        self, *, size=None, title=None, max_fps=30, draw_to_screen=True, **kwargs
+        self, *, size=None, title=None, max_fps=30, present_method=None, **kwargs
     ):
         # When using Qt, there needs to be an
         # application before any widget is created
@@ -437,7 +447,7 @@ def __init__(
         self.setMouseTracking(True)
 
         self._subwidget = QWgpuWidget(
-            self, max_fps=max_fps, draw_to_screen=draw_to_screen
+            self, max_fps=max_fps, present_method=present_method
         )
         self._subwidget.add_event_handler(weakbind(self.handle_event), "*")
 
diff --git a/wgpu/gui/wx.py b/wgpu/gui/wx.py
index 06797244..e7bb7215 100644
--- a/wgpu/gui/wx.py
+++ b/wgpu/gui/wx.py
@@ -134,11 +134,22 @@ def Notify(self, *args):  # noqa: N802
 class WxWgpuWindow(WgpuAutoGui, WgpuCanvasBase, wx.Window):
     """A wx Window representing a wgpu canvas that can be embedded in a wx application."""
 
-    def __init__(self, *args, draw_to_screen=True, **kwargs):
+    def __init__(self, *args, present_method=None, **kwargs):
         super().__init__(*args, **kwargs)
 
+        # Determine present method
         self._surface_ids = self._get_surface_ids()
-        self._draw_to_screen = draw_to_screen and bool(self._surface_ids)
+        if not present_method:
+            self._present_to_screen = True
+            if SYSTEM_IS_WAYLAND:
+                # See comments in same place in qt.py
+                self._present_to_screen = False
+        elif present_method == "screen":
+            self._present_to_screen = True
+        elif present_method == "image":
+            self._present_to_screen = False
+        else:
+            raise ValueError(f"Invalid present_method {present_method}")
 
         # A timer for limiting fps
         self._request_draw_timer = TimerWithCallback(self.Refresh)
@@ -322,14 +333,13 @@ def _get_surface_ids(self):
                 "window": int(self.GetHandle()),
             }
         elif sys.platform.startswith("linux"):
-            if SYSTEM_IS_WAYLAND:
-                # Fallback to offscreen rendering. See comment in same place in qt.py.
-                return None
-                # return {
-                #     "platform": "wayland",
-                #     "window": int(self.GetHandle()),
-                #     "display": int(get_alt_wayland_display()),
-                # }
+            if False:
+                # We fall back to XWayland, see _gui_utils.py
+                return {
+                    "platform": "wayland",
+                    "window": int(self.GetHandle()),
+                    "display": int(get_alt_wayland_display()),
+                }
             else:
                 return {
                     "platform": "x11",
@@ -341,7 +351,7 @@ def _get_surface_ids(self):
 
     def get_present_info(self):
         global _show_image_method_warning
-        if self._draw_to_screen and self._surface_ids:
+        if self._present_to_screen and self._surface_ids:
             info = {"method": "screen"}
             info.update(self._surface_ids)
         else:
@@ -420,7 +430,7 @@ def __init__(
         size=None,
         title=None,
         max_fps=30,
-        draw_to_screen=True,
+        present_method=None,
         **kwargs,
     ):
         get_app()
@@ -430,7 +440,7 @@ def __init__(
         self.SetTitle(title or "wx wgpu canvas")
 
         self._subwidget = WxWgpuWindow(
-            parent=self, max_fps=max_fps, draw_to_screen=draw_to_screen
+            parent=self, max_fps=max_fps, present_method=present_method
         )
         self._subwidget.add_event_handler(weakbind(self.handle_event), "*")
         self.Bind(wx.EVT_CLOSE, lambda e: self.Destroy())

From 6b624a86342c4081710df48ab7105d9b68eda72f Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Wed, 18 Sep 2024 11:11:17 +0200
Subject: [PATCH 24/24] flake

---
 wgpu/gui/qt.py | 1 +
 wgpu/gui/wx.py | 1 +
 2 files changed, 2 insertions(+)

diff --git a/wgpu/gui/qt.py b/wgpu/gui/qt.py
index 3e73442e..4ffb6157 100644
--- a/wgpu/gui/qt.py
+++ b/wgpu/gui/qt.py
@@ -12,6 +12,7 @@
     logger,
     SYSTEM_IS_WAYLAND,
     get_alt_x11_display,
+    get_alt_wayland_display,
     weakbind,
     get_imported_qt_lib,
 )
diff --git a/wgpu/gui/wx.py b/wgpu/gui/wx.py
index e7bb7215..f314d244 100644
--- a/wgpu/gui/wx.py
+++ b/wgpu/gui/wx.py
@@ -13,6 +13,7 @@
     logger,
     SYSTEM_IS_WAYLAND,
     get_alt_x11_display,
+    get_alt_wayland_display,
     weakbind,
 )
 from .base import WgpuCanvasBase, WgpuAutoGui