From 5da23c7ae6a6e5625614500b7a18c5a68d8b20ac Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Mon, 4 Nov 2024 15:22:18 -0800
Subject: [PATCH 01/37] add swig

---
 swig/build.sh     | 16 +++++++++++++
 swig/libctlgeom.i | 59 +++++++++++++++++++++++++++++++++++++++++++++++
 swig/setup.py     | 38 ++++++++++++++++++++++++++++++
 3 files changed, 113 insertions(+)
 create mode 100755 swig/build.sh
 create mode 100644 swig/libctlgeom.i
 create mode 100644 swig/setup.py

diff --git a/swig/build.sh b/swig/build.sh
new file mode 100755
index 0000000..de18757
--- /dev/null
+++ b/swig/build.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+# Check if running in a conda environment
+if [ -n "${CONDA_PREFIX}" ]; then
+    echo "Using Conda environment at: $CONDA_PREFIX"
+    PYTHON_INCLUDE=$($CONDA_PREFIX/bin/python3 -c "from sysconfig import get_paths; print(get_paths()['include'])")
+    swig -python -I/usr/local/include -I"$PYTHON_INCLUDE" libctlgeom.i
+    $CONDA_PREFIX/bin/python3 setup.py build_ext --inplace
+    $CONDA_PREFIX/bin/pip install .
+else
+    echo "Using system Python"
+    PYTHON_INCLUDE=$(python3 -c "from sysconfig import get_paths; print(get_paths()['include'])")
+    swig -python -I/usr/local/include -I"$PYTHON_INCLUDE" libctlgeom.i
+    python3 setup.py build_ext --inplace
+    pip install .
+fi
\ No newline at end of file
diff --git a/swig/libctlgeom.i b/swig/libctlgeom.i
new file mode 100644
index 0000000..98d20f5
--- /dev/null
+++ b/swig/libctlgeom.i
@@ -0,0 +1,59 @@
+%module libctlgeom
+
+/* Include the header files first */
+%{
+#include "ctlgeom.h"
+#include "ctlgeom-types.h"
+%}
+
+/* Include the type definitions */
+%include "ctlgeom-types.h"
+
+/* Properly wrap vector3 structure */
+%include "ctl-math.h"
+
+/* Define MATERIAL_TYPE with proper typemap */
+%typemap(in) MATERIAL_TYPE {
+    $1 = (void*)$input;
+}
+
+%typemap(out) MATERIAL_TYPE {
+    $result = (PyObject*)$1;
+}
+
+/* Core initialization */
+extern void geom_initialize(void);
+extern void geom_fix_objects(void);
+extern void geom_fix_lattice(void);
+extern void geom_cartesian_lattice(void);
+
+extern geometric_object make_sphere(MATERIAL_TYPE material, vector3 center, number radius);
+extern geometric_object make_cylinder(MATERIAL_TYPE material, vector3 center, number radius, number height, vector3 axis);
+extern geometric_object make_cone(MATERIAL_TYPE material, vector3 center, number radius, number height, vector3 axis, number radius2);
+extern geometric_object make_block(MATERIAL_TYPE material, vector3 center, vector3 e1, vector3 e2, vector3 e3, vector3 size);
+extern geometric_object make_ellipsoid(MATERIAL_TYPE material, vector3 center, vector3 e1, vector3 e2, vector3 e3, vector3 size);
+
+/* Prism constructors */
+extern geometric_object make_prism(MATERIAL_TYPE material, const vector3 *vertices, int num_vertices, double height, vector3 axis);
+extern geometric_object make_prism_with_center(MATERIAL_TYPE material, vector3 center, const vector3 *vertices, int num_vertices, double height, vector3 axis);
+
+/* Geometric calculations */
+extern double geom_object_volume(geometric_object o);
+extern boolean point_in_objectp(vector3 p, geometric_object o);
+extern boolean point_in_periodic_objectp(vector3 p, geometric_object o);
+
+/* Material/object lookup */
+extern MATERIAL_TYPE material_of_point(vector3 p);
+extern geometric_object object_of_point(vector3 p, vector3 *shiftby);
+extern MATERIAL_TYPE material_of_point0(GEOMETRIC_OBJECT_LIST geometry, vector3 p);
+geometric_object object_of_point0(GEOMETRIC_OBJECT_LIST geometry, vector3 p, vector3 *shiftby);
+
+/* Coordinate transformations */
+extern vector3 to_geom_object_coords(vector3 p, geometric_object o);
+extern vector3 from_geom_object_coords(vector3 p, geometric_object o);
+extern vector3 normal_to_object(vector3 p, geometric_object o);
+
+/* Intersection calculations */
+extern int intersect_line_with_object(vector3 p, vector3 d, geometric_object o, double s[2]);
+
+extern void display_geometric_object_info(int indentby, geometric_object o);
diff --git a/swig/setup.py b/swig/setup.py
new file mode 100644
index 0000000..977d6bb
--- /dev/null
+++ b/swig/setup.py
@@ -0,0 +1,38 @@
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+import sys
+import os
+from sysconfig import get_paths
+
+python_include = get_paths()["include"]
+
+
+class CustomBuildExtCommand(build_ext):
+    """Customized build_ext command"""
+
+    def build_extensions(self):
+        # Customize compiler settings
+        if sys.platform == "darwin":
+            for ext in self.extensions:
+                ext.extra_link_args = ["-Wl,-rpath,/usr/local/lib"]
+        build_ext.build_extensions(self)
+
+
+libctlgeom_module = Extension(
+    "_libctlgeom",
+    sources=["libctlgeom_wrap.c"],
+    include_dirs=["/usr/local/include", python_include],
+    library_dirs=["/usr/local/lib"],
+    libraries=["ctlgeom"],
+    extra_compile_args=["-I/usr/local/include"],
+)
+
+setup(
+    name="libctlgeom",
+    version="0.1",
+    author="SWIG Wrapper Generator",
+    description="SWIG wrapper for libctlgeom",
+    ext_modules=[libctlgeom_module],
+    py_modules=["libctlgeom"],
+    cmdclass={"build_ext": CustomBuildExtCommand},
+)

From 694d9156141c02e0cdc042f1c109abbf779a2e6b Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 7 Nov 2024 11:08:28 -0800
Subject: [PATCH 02/37] Add python wrapper for swig generated python API

This is to simplify the creation and manipulation of swig objects.
---
 swig/ctlgeom.py   | 319 ++++++++++++++++++++++++++++++++++++++++++++++
 swig/libctlgeom.i | 201 +++++++++++++++++++++++++----
 2 files changed, 496 insertions(+), 24 deletions(-)
 create mode 100644 swig/ctlgeom.py

diff --git a/swig/ctlgeom.py b/swig/ctlgeom.py
new file mode 100644
index 0000000..db1f308
--- /dev/null
+++ b/swig/ctlgeom.py
@@ -0,0 +1,319 @@
+import libctlgeom as geom
+from abc import ABC, abstractmethod
+from typing import Tuple, List, Literal
+import dataclasses
+import numpy as np
+
+
+def make_vector3(x, y, z):
+    v = geom.vector3()
+    v.x = x
+    v.y = y
+    v.z = z
+    return v
+
+
+@dataclasses.dataclass(frozen=True)
+class BoundingBox:
+    low: Tuple[float, float, float]
+    high: Tuple[float, float, float]
+
+    def __post_init__(self):
+        self.box = geom.geom_box()
+        self.box.low = make_vector3(*self.low)
+        self.box.high = make_vector3(*self.high)
+
+    def to_geom_object(self):
+        return self.box
+
+
+@dataclasses.dataclass(frozen=True)
+class Material:
+    """Material properties."""
+
+    epsilon: float
+
+
+class GeometricObject(ABC):
+    """Abstract base class for geometric objects."""
+
+    @abstractmethod
+    def to_geom_object(self):
+        raise NotImplementedError
+
+    def get_volume(self) -> float:
+        return geom.geom_object_volume(self.to_geom_object())
+
+    def debug_info(self) -> None:
+        display_geom_object_info(self)
+
+    def get_bounding_box(self) -> Tuple[geom.vector3, geom.vector3]:
+        box = geom.geom_box()
+        geom.geom_get_bounding_box(self.to_geom_object(), box)
+        return (box.low, box.high)
+
+
+@dataclasses.dataclass(frozen=True)
+class Cylinder(GeometricObject):
+    """A cylinder.
+
+    Attributes:
+        material: Material properties.
+        center: The center of the cylinder.
+        radius: The radius of the cylinder.
+        height: The height of the cylinder.
+        axis: The axis of the cylinder.
+    """
+
+    material: Material
+    center: Tuple[float, float, float]
+    radius: float
+    height: float
+    axis: Tuple[float, float, float]
+
+    def to_geom_object(self):
+        return geom.make_cylinder(
+            self.material,
+            make_vector3(*self.center),
+            self.radius,
+            self.height,
+            make_vector3(*self.axis),
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class Wedge(GeometricObject):
+    """A wedge (partial cylinder).
+
+    Attributes:
+        material: Material properties.
+        center: The center of the wedge.
+        radius: The radius of the wedge.
+        height: The height of the wedge.
+        axis: The axis of the wedge.
+        wedge_angle: The angle of the wedge in radians.
+        wedge_start: The starting direction vector of the wedge.
+    """
+
+    material: Material
+    center: Tuple[float, float, float]
+    radius: float
+    height: float
+    axis: Tuple[float, float, float]
+    wedge_angle: float
+    wedge_start: Tuple[float, float, float]
+
+    def to_geom_object(self):
+        return geom.make_wedge(
+            self.material,
+            make_vector3(*self.center),
+            self.radius,
+            self.height,
+            make_vector3(*self.axis),
+            self.wedge_angle,
+            make_vector3(*self.wedge_start),
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class Cone(GeometricObject):
+    """A cone.
+
+    Attributes:
+        material: Material properties.
+        center: The center of the cone.
+        radius: The radius at the base.
+        height: The height of the cone.
+        axis: The axis of the cone.
+        radius2: The radius at the top (0 for a perfect cone).
+    """
+
+    material: Material
+    center: Tuple[float, float, float]
+    radius: float
+    height: float
+    axis: Tuple[float, float, float]
+    radius2: float
+
+    def to_geom_object(self):
+        return geom.make_cone(
+            self.material,
+            make_vector3(*self.center),
+            self.radius,
+            self.height,
+            make_vector3(*self.axis),
+            self.radius2,
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class Sphere(GeometricObject):
+    material: Material
+    center: Tuple[float, float, float]
+    radius: float
+
+    def to_geom_object(self):
+        return geom.make_sphere(self.material, make_vector3(*self.center), self.radius)
+
+
+@dataclasses.dataclass(frozen=True)
+class Block(GeometricObject):
+    """A rectangular block.
+
+    Attributes:
+        material: Material properties.
+        center: The center of the block.
+        e1: First basis vector.
+        e2: Second basis vector.
+        e3: Third basis vector.
+        size: Size along each basis vector.
+    """
+
+    material: Material
+    center: Tuple[float, float, float]
+    e1: Tuple[float, float, float]
+    e2: Tuple[float, float, float]
+    e3: Tuple[float, float, float]
+    size: Tuple[float, float, float]
+
+    def to_geom_object(self):
+        return geom.make_block(
+            self.material,
+            make_vector3(*self.center),
+            make_vector3(*self.e1),
+            make_vector3(*self.e2),
+            make_vector3(*self.e3),
+            make_vector3(*self.size),
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class Ellipsoid(GeometricObject):
+    """An ellipsoid.
+
+    Attributes:
+        material: Material properties.
+        center: The center of the ellipsoid.
+        e1: First basis vector.
+        e2: Second basis vector.
+        e3: Third basis vector.
+        size: Size along each basis vector.
+    """
+
+    material: Material
+    center: Tuple[float, float, float]
+    e1: Tuple[float, float, float]
+    e2: Tuple[float, float, float]
+    e3: Tuple[float, float, float]
+    size: Tuple[float, float, float]
+
+    def to_geom_object(self):
+        return geom.make_ellipsoid(
+            self.material,
+            make_vector3(*self.center),
+            make_vector3(*self.e1),
+            make_vector3(*self.e2),
+            make_vector3(*self.e3),
+            make_vector3(*self.size),
+        )
+
+
+@dataclasses.dataclass(frozen=False)
+class GroupObject:
+    """A group of geometric objects."""
+
+    objects: List[GeometricObject]
+
+    def __post_init__(self):
+        geom_objects = [obj.to_geom_object() for obj in self.objects]
+        self.geom_list = make_geom_object_list(geom_objects)
+        # self.bounding_box = geom.geom_box()
+        self.bounding_box = make_geom_box((-2, -2, -2), (2, 2, 2))
+        self.geom_box_tree = None
+
+    def to_tree_object(self) -> Literal["geom.geom_box_tree"]:
+        """Create a tree object from the group of geometric objects."""
+        return geom.create_geom_box_tree0(self.geom_list, self.bounding_box)
+
+    def get_tree_object(self) -> Literal["geom.geom_box_tree"]:
+        """Get the tree object from the group of geometric objects."""
+        if self.geom_box_tree is None:
+            self.geom_box_tree = self.to_tree_object()
+        return self.geom_box_tree
+
+    def query_object_at_point(
+        self, point: Tuple[float, float, float]
+    ) -> GeometricObject:
+        """Query the object at a point."""
+        shiftby = geom.vector3()
+        return geom.object_of_point0(self.geom_list, make_vector3(*point), shiftby)
+
+    def query_object_at_point_in_tree(
+        self, point: Tuple[float, float, float], precedence: int
+    ) -> GeometricObject:
+        """Unstable. Not outputting object as expected."""
+        shiftby = geom.vector3()
+        precedence_ptr = geom.new_intp()
+        geom.intp_assign(precedence_ptr, precedence)
+        return geom.object_of_point_in_tree(
+            make_vector3(*point), self.get_tree_object(), shiftby, precedence_ptr
+        )
+
+    def query_material_at_point(self, point: Tuple[float, float, float]) -> Material:
+        """Query the material at a point.
+
+        Args:
+            point: The point to query.
+        """
+        # tree = self.get_tree_object()
+        # return geom.material_of_point_in_tree(make_vector3(*point), tree)
+
+        tree = self.get_tree_object()
+        # Use direct material query since boolean type isn't available
+        return geom.material_of_point_in_tree(make_vector3(*point), tree)
+
+    def __del__(self):
+        # Clean up the tree when the object is destroyed
+        if hasattr(self, "tree"):
+            geom.destroy_geom_box_tree(self.tree)
+
+
+def point_is_in_object(
+    point: Tuple[float, float, float], object: GeometricObject
+) -> bool:
+    """Check if a point is inside a geometric object.
+
+    Args:
+        point: The point to check.
+        object: The geometric object to check against.
+    """
+    return bool(geom.point_in_objectp(make_vector3(*point), object.to_geom_object()))
+
+
+def display_geom_object_info(object: GeometricObject) -> None:
+    """Display information about the geometric object.
+
+    Args:
+        object: The geometric object to display information about.
+    """
+    geom.display_geometric_object_info(0, object.to_geom_object())
+
+
+def make_geom_object_list(objects: list[geom.geometric_object]):
+    objects_list = geom.geometric_object_list()
+    objects_list.num_items = len(objects)
+    objects_list.set_items(objects)  # Use set_items instead of direct assignment
+    return objects_list
+
+
+def make_geom_box(low: Tuple[float, float, float], high: Tuple[float, float, float]):
+    """Create a geometric box.
+
+    Args:
+        low: The lower corner of the box.
+        high: The upper corner of the box.
+    """
+    box = geom.geom_box()
+    box.low = make_vector3(*low)
+    box.high = make_vector3(*high)
+    return box
diff --git a/swig/libctlgeom.i b/swig/libctlgeom.i
index 98d20f5..097dcad 100644
--- a/swig/libctlgeom.i
+++ b/swig/libctlgeom.i
@@ -12,6 +12,9 @@
 /* Properly wrap vector3 structure */
 %include "ctl-math.h"
 
+%include "cpointer.i"
+%pointer_functions(int, intp);
+
 /* Define MATERIAL_TYPE with proper typemap */
 %typemap(in) MATERIAL_TYPE {
     $1 = (void*)$input;
@@ -21,39 +24,189 @@
     $result = (PyObject*)$1;
 }
 
-/* Core initialization */
+extern void display_geometric_object_info(int indentby, geometric_object o);
+
 extern void geom_initialize(void);
+extern void geom_fix_object_ptr(geometric_object *o);
+// extern void geom_fix_object(geometric_object o) CTLGEOM_DEPRECATED;
 extern void geom_fix_objects(void);
+// extern void geom_fix_objects0(geometric_object_list geometry) CTLGEOM_DEPRECATED;
+extern void geom_fix_object_list(geometric_object_list geometry);
 extern void geom_fix_lattice(void);
+extern void geom_fix_lattice0(LATTICE *L);
 extern void geom_cartesian_lattice(void);
-
-extern geometric_object make_sphere(MATERIAL_TYPE material, vector3 center, number radius);
-extern geometric_object make_cylinder(MATERIAL_TYPE material, vector3 center, number radius, number height, vector3 axis);
-extern geometric_object make_cone(MATERIAL_TYPE material, vector3 center, number radius, number height, vector3 axis, number radius2);
-extern geometric_object make_block(MATERIAL_TYPE material, vector3 center, vector3 e1, vector3 e2, vector3 e3, vector3 size);
-extern geometric_object make_ellipsoid(MATERIAL_TYPE material, vector3 center, vector3 e1, vector3 e2, vector3 e3, vector3 size);
-
-/* Prism constructors */
-extern geometric_object make_prism(MATERIAL_TYPE material, const vector3 *vertices, int num_vertices, double height, vector3 axis);
-extern geometric_object make_prism_with_center(MATERIAL_TYPE material, vector3 center, const vector3 *vertices, int num_vertices, double height, vector3 axis);
-
-/* Geometric calculations */
+extern void geom_cartesian_lattice0(LATTICE *L);
 extern double geom_object_volume(geometric_object o);
 extern boolean point_in_objectp(vector3 p, geometric_object o);
 extern boolean point_in_periodic_objectp(vector3 p, geometric_object o);
-
-/* Material/object lookup */
-extern MATERIAL_TYPE material_of_point(vector3 p);
-extern geometric_object object_of_point(vector3 p, vector3 *shiftby);
-extern MATERIAL_TYPE material_of_point0(GEOMETRIC_OBJECT_LIST geometry, vector3 p);
-geometric_object object_of_point0(GEOMETRIC_OBJECT_LIST geometry, vector3 p, vector3 *shiftby);
-
-/* Coordinate transformations */
+extern boolean point_in_fixed_objectp(vector3 p, geometric_object o);
+extern boolean point_in_fixed_pobjectp(vector3 p, geometric_object *o);
+extern boolean point_in_periodic_fixed_objectp(vector3 p, geometric_object o);
 extern vector3 to_geom_object_coords(vector3 p, geometric_object o);
 extern vector3 from_geom_object_coords(vector3 p, geometric_object o);
 extern vector3 normal_to_object(vector3 p, geometric_object o);
-
-/* Intersection calculations */
+extern vector3 normal_to_fixed_object(vector3 p, geometric_object o);
 extern int intersect_line_with_object(vector3 p, vector3 d, geometric_object o, double s[2]);
+extern double intersect_line_segment_with_object(vector3 p, vector3 d, geometric_object o, double a,
+                                                 double b);
+extern MATERIAL_TYPE material_of_point_inobject(vector3 p, boolean *inobject);
+extern MATERIAL_TYPE material_of_point_inobject0(geometric_object_list geometry, vector3 p,
+                                                 boolean *inobject);
+extern MATERIAL_TYPE material_of_point(vector3 p);
+extern MATERIAL_TYPE material_of_point0(geometric_object_list geometry, vector3 p);
+geometric_object object_of_point0(geometric_object_list geometry, vector3 p, vector3 *shiftby);
+geometric_object object_of_point(vector3 p, vector3 *shiftby);
+vector3 shift_to_unit_cell(vector3 p);
+extern matrix3x3 square_basis(matrix3x3 lattice_basis, vector3 size);
+extern void ctl_printf(const char *fmt, ...);
+extern void (*ctl_printf_callback)(const char *s);
 
-extern void display_geometric_object_info(int indentby, geometric_object o);
+typedef struct {
+  vector3 low, high;
+} geom_box;
+
+typedef struct {
+  geom_box box;
+  const geometric_object *o;
+  vector3 shiftby;
+  int precedence;
+} geom_box_object;
+
+typedef struct geom_box_tree_struct {
+  geom_box b, b1, b2;
+  struct geom_box_tree_struct *t1, *t2;
+  int nobjects;
+  geom_box_object *objects;
+} * geom_box_tree;
+
+extern void destroy_geom_box_tree(geom_box_tree t);
+extern geom_box_tree create_geom_box_tree(void);
+extern geom_box_tree create_geom_box_tree0(geometric_object_list geometry, geom_box b0);
+extern geom_box_tree restrict_geom_box_tree(geom_box_tree, const geom_box *);
+extern geom_box_tree geom_tree_search(vector3 p, geom_box_tree t, int *oindex);
+extern geom_box_tree geom_tree_search_next(vector3 p, geom_box_tree t, int *oindex);
+extern MATERIAL_TYPE material_of_point_in_tree_inobject(vector3 p, geom_box_tree t,
+                                                        boolean *inobject);
+extern MATERIAL_TYPE material_of_point_in_tree(vector3 p, geom_box_tree t);
+extern MATERIAL_TYPE material_of_unshifted_point_in_tree_inobject(vector3 p, geom_box_tree t,
+                                                                  boolean *inobject);
+const geometric_object *object_of_point_in_tree(vector3 p, geom_box_tree t, vector3 *shiftby,
+                                                int *precedence);
+extern vector3 to_geom_box_coords(vector3 p, geom_box_object *gbo);
+extern void display_geom_box_tree(int indentby, geom_box_tree t);
+extern void geom_box_tree_stats(geom_box_tree t, int *depth, int *nobjects);
+
+extern void geom_get_bounding_box(geometric_object o, geom_box *box);
+extern number box_overlap_with_object(geom_box b, geometric_object o, number tol, int maxeval);
+extern number ellipsoid_overlap_with_object(geom_box b, geometric_object o, number tol,
+                                            int maxeval);
+extern number range_overlap_with_object(vector3 low, vector3 high, geometric_object o, number tol,
+                                        int maxeval);
+
+// extern vector3 get_grid_size(void);
+// extern vector3 get_resolution(void);
+// extern void get_grid_size_n(int *nx, int *ny, int *nz);
+
+geometric_object make_geometric_object(MATERIAL_TYPE material, vector3 center);
+geometric_object make_cylinder(MATERIAL_TYPE material, vector3 center, number radius, number height,
+                               vector3 axis);
+geometric_object make_wedge(MATERIAL_TYPE material, vector3 center, number radius, number height,
+                            vector3 axis, number wedge_angle, vector3 wedge_start);
+geometric_object make_cone(MATERIAL_TYPE material, vector3 center, number radius, number height,
+                           vector3 axis, number radius2);
+geometric_object make_sphere(MATERIAL_TYPE material, vector3 center, number radius);
+geometric_object make_block(MATERIAL_TYPE material, vector3 center, vector3 e1, vector3 e2,
+                            vector3 e3, vector3 size);
+geometric_object make_ellipsoid(MATERIAL_TYPE material, vector3 center, vector3 e1, vector3 e2,
+                                vector3 e3, vector3 size);
+
+extern boolean node_in_or_on_polygon(vector3 q0, vector3 *nodes, int num_nodes,
+                                     boolean include_boundaries);
+
+// prism with `center` field computed automatically from vertices, height, axis
+geometric_object make_prism(MATERIAL_TYPE material, const vector3 *vertices, int num_vertices,
+                            double height, vector3 axis);
+
+// as make_prism, but with a rigid translation so that the prism is centered at center
+geometric_object make_prism_with_center(MATERIAL_TYPE material, vector3 center,
+                                        const vector3 *vertices, int num_vertices, double height,
+                                        vector3 axis);
+
+// slanted prism with `center` field computed automatically from vertices, height, axis, sidewall_angle
+geometric_object make_slanted_prism(MATERIAL_TYPE material, const vector3 *vertices, int num_vertices,
+                            double height, vector3 axis, double sidewall_angle);
+
+// as make_slanted_prism, but with a rigid translation so that the prism is centered at center
+geometric_object make_slanted_prism_with_center(MATERIAL_TYPE material, vector3 center,
+                                        const vector3 *vertices, int num_vertices, double height,
+                                        vector3 axis, double sidewall_angle);
+
+int vector3_nearly_equal(vector3 v1, vector3 v2, double tolerance);
+
+/* Add typemap for geometric object arrays */
+%typemap(in) (geometric_object *items) {
+    if (!PyList_Check($input)) {
+        SWIG_exception(SWIG_TypeError, "Expected a list of geometric objects");
+    }
+    int size = PyList_Size($input);
+    $1 = (geometric_object *)malloc(size * sizeof(geometric_object));
+    for (int i = 0; i < size; i++) {
+        PyObject *obj = PyList_GetItem($input, i);
+        geometric_object *item;
+        int res = SWIG_ConvertPtr(obj, (void **)&item, SWIGTYPE_p_geometric_object, 0);
+        if (!SWIG_IsOK(res)) {
+            free($1);
+            SWIG_exception(SWIG_TypeError, "List items must be geometric objects");
+        }
+        $1[i] = *item;
+    }
+}
+
+%typemap(freearg) (geometric_object *items) {
+    free($1);
+}
+
+/* Add these typemaps before the geometric_object_list declaration */
+
+%include <carrays.i>
+%array_class(geometric_object, geometric_object_array);
+
+%extend geometric_object_list {
+    void set_items(PyObject* list) {
+        if (!PyList_Check(list)) {
+            PyErr_SetString(PyExc_TypeError, "Expected a list");
+            return;
+        }
+        
+        int size = PyList_Size(list);
+        if (size != $self->num_items) {
+            PyErr_SetString(PyExc_ValueError, "List size must match num_items");
+            return;
+        }
+        
+        $self->items = (geometric_object*)malloc(size * sizeof(geometric_object));
+        for (int i = 0; i < size; i++) {
+            PyObject *obj = PyList_GetItem(list, i);
+            geometric_object *item;
+            int res = SWIG_ConvertPtr(obj, (void**)&item, $descriptor(geometric_object*), 0);
+            if (!SWIG_IsOK(res)) {
+                free($self->items);
+                PyErr_SetString(PyExc_TypeError, "List items must be geometric objects");
+                return;
+            }
+            $self->items[i] = *item;
+        }
+    }
+    
+    PyObject* get_items() {
+        PyObject* list = PyList_New($self->num_items);
+        for (int i = 0; i < $self->num_items; i++) {
+            PyObject* obj = SWIG_NewPointerObj(&$self->items[i], $descriptor(geometric_object*), 0);
+            PyList_SET_ITEM(list, i, obj);
+        }
+        return list;
+    }
+}
+
+// Ignore the original items attribute to prevent conflicts
+%ignore geometric_object_list::items;
\ No newline at end of file

From 3a98faefb89c134eb0adaf7f87c501c84de2dc68 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 7 Nov 2024 11:55:10 -0800
Subject: [PATCH 03/37] fix bug where when query the material in tree the
 second time causes a crash.

improve memory management of the MATERIAL_TYPE
---
 swig/libctlgeom.i | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/swig/libctlgeom.i b/swig/libctlgeom.i
index 097dcad..2c7c4c9 100644
--- a/swig/libctlgeom.i
+++ b/swig/libctlgeom.i
@@ -17,11 +17,13 @@
 
 /* Define MATERIAL_TYPE with proper typemap */
 %typemap(in) MATERIAL_TYPE {
+    Py_XINCREF($input);  // Increment reference count when passing to C
     $1 = (void*)$input;
 }
 
 %typemap(out) MATERIAL_TYPE {
     $result = (PyObject*)$1;
+    Py_XINCREF($result);  // Increment reference count when returning to Python
 }
 
 extern void display_geometric_object_info(int indentby, geometric_object o);

From 34edeb5ed4b47a83826bcb5b06c9de4ff12d23f8 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 7 Nov 2024 12:24:27 -0800
Subject: [PATCH 04/37] Add Prism and SlatedPrism

---
 swig/ctlgeom.py | 86 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/swig/ctlgeom.py b/swig/ctlgeom.py
index db1f308..6877211 100644
--- a/swig/ctlgeom.py
+++ b/swig/ctlgeom.py
@@ -218,6 +218,92 @@ def to_geom_object(self):
         )
 
 
+@dataclasses.dataclass(frozen=True)
+class Prism(GeometricObject):
+    """A prism defined by vertices.
+
+    Attributes:
+        material: Material properties.
+        vertices: List of (x,y,z) vertices defining the prism base.
+        height: The height of the prism.
+        axis: The axis along which the prism extends.
+        center: Optional center point. If None, computed automatically from vertices.
+    """
+
+    material: Material
+    vertices: List[Tuple[float, float, float]]
+    height: float
+    axis: Tuple[float, float, float]
+    center: Tuple[float, float, float] = None
+
+    def to_geom_object(self):
+        # Convert vertices list to array of vector3
+        vertex_array = [make_vector3(*v) for v in self.vertices]
+
+        if self.center is None:
+            return geom.make_prism(
+                self.material,
+                vertex_array,
+                len(vertex_array),
+                self.height,
+                make_vector3(*self.axis),
+            )
+        else:
+            return geom.make_prism_with_center(
+                self.material,
+                make_vector3(*self.center),
+                vertex_array,
+                len(vertex_array),
+                self.height,
+                make_vector3(*self.axis),
+            )
+
+
+@dataclasses.dataclass(frozen=True)
+class SlantedPrism(GeometricObject):
+    """A prism with slanted sides.
+
+    Attributes:
+        material: Material properties.
+        vertices: List of (x,y,z) vertices defining the prism base.
+        height: The height of the prism.
+        axis: The axis along which the prism extends.
+        sidewall_angle: The angle of the sidewalls in radians.
+        center: Optional center point. If None, computed automatically from vertices.
+    """
+
+    material: Material
+    vertices: List[Tuple[float, float, float]]
+    height: float
+    axis: Tuple[float, float, float]
+    sidewall_angle: float
+    center: Tuple[float, float, float] = None
+
+    def to_geom_object(self):
+        # Convert vertices list to array of vector3
+        vertex_array = [make_vector3(*v) for v in self.vertices]
+
+        if self.center is None:
+            return geom.make_slanted_prism(
+                self.material,
+                vertex_array,
+                len(vertex_array),
+                self.height,
+                make_vector3(*self.axis),
+                self.sidewall_angle,
+            )
+        else:
+            return geom.make_slanted_prism_with_center(
+                self.material,
+                make_vector3(*self.center),
+                vertex_array,
+                len(vertex_array),
+                self.height,
+                make_vector3(*self.axis),
+                self.sidewall_angle,
+            )
+
+
 @dataclasses.dataclass(frozen=False)
 class GroupObject:
     """A group of geometric objects."""

From 4b838583ef0a4d733babca2c39999b1c47d2b480 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 7 Nov 2024 12:28:28 -0800
Subject: [PATCH 05/37] extend the bounding of the group object from
 float("-inf") to float("inf")

---
 swig/ctlgeom.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/swig/ctlgeom.py b/swig/ctlgeom.py
index 6877211..7207f98 100644
--- a/swig/ctlgeom.py
+++ b/swig/ctlgeom.py
@@ -313,8 +313,10 @@ class GroupObject:
     def __post_init__(self):
         geom_objects = [obj.to_geom_object() for obj in self.objects]
         self.geom_list = make_geom_object_list(geom_objects)
-        # self.bounding_box = geom.geom_box()
-        self.bounding_box = make_geom_box((-2, -2, -2), (2, 2, 2))
+        self.bounding_box = make_geom_box(
+            (float("-inf"), float("-inf"), float("-inf")),
+            (float("inf"), float("inf"), float("inf")),
+        )
         self.geom_box_tree = None
 
     def to_tree_object(self) -> Literal["geom.geom_box_tree"]:

From 01ecc246e5b5cbfcb93dcb44a3232b04efed6375 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 7 Nov 2024 12:53:33 -0800
Subject: [PATCH 06/37] When material_type is NULL, constitutes a None in
 python.

---
 swig/libctlgeom.i | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/swig/libctlgeom.i b/swig/libctlgeom.i
index 2c7c4c9..f567842 100644
--- a/swig/libctlgeom.i
+++ b/swig/libctlgeom.i
@@ -22,8 +22,13 @@
 }
 
 %typemap(out) MATERIAL_TYPE {
-    $result = (PyObject*)$1;
-    Py_XINCREF($result);  // Increment reference count when returning to Python
+    if ($1 == NULL) {
+        Py_INCREF(Py_None);
+        $result = Py_None;
+    } else {
+        $result = (PyObject*)$1;
+        Py_XINCREF($result);  // Increment reference count when returning to Python
+    }
 }
 
 extern void display_geometric_object_info(int indentby, geometric_object o);

From 51065c6ea59ddb42ca10fef61a7c796949597ecf Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 7 Nov 2024 13:20:25 -0800
Subject: [PATCH 07/37] clean up the code a little bit

---
 swig/ctlgeom.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/swig/ctlgeom.py b/swig/ctlgeom.py
index 7207f98..4e3841f 100644
--- a/swig/ctlgeom.py
+++ b/swig/ctlgeom.py
@@ -311,6 +311,9 @@ class GroupObject:
     objects: List[GeometricObject]
 
     def __post_init__(self):
+        self.objects_map = {
+            obj.to_geom_object(): obj for obj in self.objects
+        }  # Add this line
         geom_objects = [obj.to_geom_object() for obj in self.objects]
         self.geom_list = make_geom_object_list(geom_objects)
         self.bounding_box = make_geom_box(
@@ -353,11 +356,7 @@ def query_material_at_point(self, point: Tuple[float, float, float]) -> Material
         Args:
             point: The point to query.
         """
-        # tree = self.get_tree_object()
-        # return geom.material_of_point_in_tree(make_vector3(*point), tree)
-
         tree = self.get_tree_object()
-        # Use direct material query since boolean type isn't available
         return geom.material_of_point_in_tree(make_vector3(*point), tree)
 
     def __del__(self):

From 84715d7c0d320adddde9424b65fc84d525c2a96b Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 7 Nov 2024 13:32:48 -0800
Subject: [PATCH 08/37] add jupyter notebook to showcase the interface

---
 swig/test.ipynb | 194 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 194 insertions(+)
 create mode 100644 swig/test.ipynb

diff --git a/swig/test.ipynb b/swig/test.ipynb
new file mode 100644
index 0000000..7ec9fe4
--- /dev/null
+++ b/swig/test.ipynb
@@ -0,0 +1,194 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ctlgeom import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True False\n"
+     ]
+    }
+   ],
+   "source": [
+    "sphere = Sphere(Material(1), (0, 0.5, 0), 1)\n",
+    "a = point_is_in_object((0.5, 0, 0), sphere)\n",
+    "b = point_is_in_object((1.5, 0, 0), sphere)\n",
+    "print(a, b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(<libctlgeom.vector3; proxy of <Swig Object of type 'vector3 *' at 0x114ac15f0> >,\n",
+       " <libctlgeom.vector3; proxy of <Swig Object of type 'vector3 *' at 0x114ac0ab0> >)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sphere.get_bounding_box()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sphere, center = (0,0.5,0)\n",
+      "     radius 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "sphere.debug_info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Actual volume: 4.1887902047863905\n",
+      "Calculated volume: 4.1887902047863905\n"
+     ]
+    }
+   ],
+   "source": [
+    "actual_volume = 4/3 * np.pi * 1**3\n",
+    "print(f\"Actual volume: {actual_volume}\")\n",
+    "print(f\"Calculated volume: {sphere.get_volume()}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Material(epsilon=1)\n",
+      "Material(epsilon=2)\n",
+      "foo\n",
+      "bar\n"
+     ]
+    }
+   ],
+   "source": [
+    "sphere1 = Sphere(Material(1), (1, 0, 0), 0.1)\n",
+    "sphere2 = Sphere(Material(2), (2, 0, 0), 0.1)\n",
+    "sphere3 = Sphere(\"foo\", (3, 0, 0), 0.1)\n",
+    "sphere4 = Sphere(\"bar\", (4, 0, 0), 0.1)\n",
+    "group = GroupObject([sphere1, sphere2, sphere3, sphere4])\n",
+    "\n",
+    "print(group.query_material_at_point((1, 0, 0)))\n",
+    "print(group.query_material_at_point((2, 0, 0)))\n",
+    "print(group.query_material_at_point((3, 0, 0)))\n",
+    "print(group.query_material_at_point((4, 0, 0)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "sphere1 = Sphere(material=1, center=(0, -0.5, 0), radius=0.5)\n",
+    "sphere2 = Sphere(material=2, center=(0, 0.5, 0), radius=1)\n",
+    "block = Block(material=3, center=(0.5, 0.5, 0), e1=(1, 1, 0), e2=(1, -1, 0), e3=(0, 0, 1), size=(1, 1, 1))\n",
+    "group = GroupObject([sphere2, sphere1, block])\n",
+    "\n",
+    "# Create a grid of points\n",
+    "x = np.linspace(-1, 1, 500)\n",
+    "y = np.linspace(-1, 1, 500)\n",
+    "xx, yy = np.meshgrid(x, y)\n",
+    "\n",
+    "# Create a vectorized version of point_in_objectp\n",
+    "def get_epsilon(x, y):\n",
+    "    mat = group.query_material_at_point((x, y, 0))\n",
+    "    return 0 if mat is None else mat\n",
+    "point_in_object_vec = np.vectorize(get_epsilon)\n",
+    "\n",
+    "material_map = point_in_object_vec(xx, yy)\n",
+    "\n",
+    "# Create the plot\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.imshow(material_map, cmap='viridis')\n",
+    "plt.colorbar()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "libctl",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 072f95dc8eda841bf991d9e218b8c4372433c116 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 7 Nov 2024 13:52:16 -0800
Subject: [PATCH 09/37] add 1000 sphere case

---
 swig/test.ipynb | 97 +++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 85 insertions(+), 12 deletions(-)

diff --git a/swig/test.ipynb b/swig/test.ipynb
index 7ec9fe4..198db7d 100644
--- a/swig/test.ipynb
+++ b/swig/test.ipynb
@@ -37,8 +37,8 @@
     {
      "data": {
       "text/plain": [
-       "(<libctlgeom.vector3; proxy of <Swig Object of type 'vector3 *' at 0x114ac15f0> >,\n",
-       " <libctlgeom.vector3; proxy of <Swig Object of type 'vector3 *' at 0x114ac0ab0> >)"
+       "(<libctlgeom.vector3; proxy of <Swig Object of type 'vector3 *' at 0x1049e17d0> >,\n",
+       " <libctlgeom.vector3; proxy of <Swig Object of type 'vector3 *' at 0x103f30210> >)"
       ]
      },
      "execution_count": 3,
@@ -119,14 +119,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time taken: 0.22838377952575684 seconds\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyYAAAK7CAYAAAAHuJsbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACTSElEQVR4nOzdd5xU9b3/8feZvn13tlF2gaV3EBBBo6IoKiiiWGNPNNeaqPEmIbm5UX+JmGhyjT0mUWM3igWjUYmKJoqxIaIiiqDUZdney8yc3x/IxhVYts35Tnk9H4/zkD175pz3rLsz8znfZtm2bQsAAAAADHKZDgAAAAAAFCYAAAAAjKMwAQAAAGAchQkAAAAA4yhMAAAAABhHYQIAAADAOAoTAAAAAMZRmAAAAAAwjsIEAAAAgHEUJgB6ra6uTj/60Y80Z84c5efny7IsXX311Xs9/r333tMRRxyh9PR0ZWdn68QTT9T69ev3eOwtt9yi0aNHy+/3q6SkRNdcc43a2tp2O66srEznnnuu8vLylJqaqpkzZ+qll17qUv5zzz1XlmW1bz6fT8OGDdNVV12l2traLp0jGmbNmqVZs2YZu/6evPDCC5ozZ44GDBggv9+vAQMGaNasWbr++ut7dL57771XlmXpnXfe6eOkAIB4Q2ECoNcqKip01113qaWlRQsWLOj02E8++USzZs1Sa2ur/vrXv+ruu+/Wp59+qoMPPlg7duzocOyvfvUr/eAHP9CJJ56oF154QRdffLGuu+46XXLJJR2Oa2lp0ezZs/XSSy/p97//vZ5++mkVFhbq6KOP1quvvtql55CSkqIVK1ZoxYoVWrp0qQ477DD99re/1UknndStn0Uiu/POO3X00UcrMzNTt956q1544QX9+te/1pgxY/T444+bjgcAiHc2APRSJBKxI5GIbdu2vWPHDluS/Ytf/GKPx5588sl2Xl6eXVNT077viy++sL1er/2jH/2ofV95ebkdCATs733vex0e/6tf/cq2LMv+6KOP2vfddttttiT7jTfeaN/X1tZmjx071p4+ffo+859zzjl2WlrabvsPO+wwW5K9fv36fZ4jGg499FD70EMPNXLtPRk0aJB9yCGH7PF74XC4R+e85557bEn222+/3Zto+9TQ0BDV8wMAeo8WEwC9tqsL1L6EQiH97W9/08KFC5WZmdm+f/DgwTrssMP05JNPtu97/vnn1dzcrPPOO6/DOc477zzZtq2nnnqqfd+TTz6pUaNGaebMme37PB6PzjzzTL311lvasmVLj57XtGnTJEnbt29v37du3Tqdd955GjFihFJTUzVw4EAdd9xxWr16dYfHLl++XJZl6eGHH9bPfvYzDRgwQJmZmTriiCO0du3aDsfatq3f/OY3Gjx4sAKBgKZMmaK///3ve8y0ceNGnXnmmSooKJDf79eYMWP029/+VpFIpP2YL774QpZl6YYbbtCvf/1rDRkyRCkpKZo1a5Y+/fRTtbW16Sc/+YkGDBigrKwsnXDCCSorK9vnz6OiokL9+/ff4/dcro5vJ5Zl6dJLL9Uf/vAHjRw5Un6/X2PHjtUjjzyyx8fX1dXpoosuUl5ennJzc3XiiSdq69atux336KOPaubMmUpLS1N6erqOOuoorVy5ssMx5557rtLT07V69WrNmTNHGRkZmj17tiSptbVVv/zlL9u7B+bn5+u8887brbXu5Zdf1qxZs5Sbm6uUlBQNGjRICxcuVGNj4z5/TgCAnqEwAeCYzz//XE1NTZo4ceJu35s4caLWrVun5uZmSdKHH34oSZowYUKH4/r376+8vLz27+86dm/nlKSPPvqoR3k3bNggj8ejoUOHtu/bunWrcnNzdf311+v555/XbbfdJo/HowMOOGC3gkOSfvrTn+rLL7/Un/70J91111367LPPdNxxxykcDrcfc8011+jHP/6xjjzySD311FO66KKLdMEFF+x2vh07dujAAw/Uiy++qP/3//6fli5dqiOOOEJXXXWVLr300t2ufdttt+n111/Xbbfdpj/96U/65JNPdNxxx+m73/2uduzYobvvvlu/+c1v9I9//EPnn3/+Pn8eM2fO1JIlS3T11Vdr1apVHZ7DnixdulQ333yzrr32Wj3++OMaPHiwTj/99D12+zr//PPl9Xr10EMP6Te/+Y2WL1+uM888s8Mx1113nU4//XSNHTtWf/3rX3X//ferrq5OBx98sD7++OMOx7a2tmr+/Pk6/PDD9fTTT+uaa65RJBLR8ccfr+uvv17f/va39eyzz+r666/XsmXLNGvWLDU1NUnaWdjNmzdPPp9Pd999t55//nldf/31SktLU2tr6z5/TgCAHjLdZAMgsXTWlev111+3JdkPP/zwbt+77rrrbEn21q1bbdu27QsuuMD2+/17vMbIkSPtOXPmtH/t9Xrt//qv/9rtuDfeeMOWZD/00EOdZt7Vlautrc1ua2uzy8vL7TvuuMN2uVz2T3/6004fGwqF7NbWVnvEiBH2FVdc0b7/lVdesSXZc+fO7XD8X//6V1uSvWLFCtu2bbuqqsoOBAL2CSec0OG4XT+rr3fl+slPfmJLsv/97393OPaiiy6yLcuy165da9u2bW/YsMGWZE+aNKlDF6ubbrrJlmTPnz+/w+Mvv/xyW1KH7nV7sm7dOnv8+PG2JFuSnZKSYs+ePdu+9dZb7dbW1g7H7vp+aWlph5/V6NGj7eHDh7fv29WV6+KLL+7w+N/85je2JHvbtm22bdv2xo0bbY/HY1922WUdjqurq7P79etnn3LKKe37zjnnHFuSfffdd3c49uGHH7Yl2UuWLOmw/+2337Yl2bfffrtt27b9+OOP25Ls999/v9OfBwCgb9FiAsBxnXX7+vr3unpcd4/dk4aGBnm9Xnm9XuXl5emiiy7Sqaeeql/96lcdjguFQrruuus0duxY+Xw+eTwe+Xw+ffbZZ1qzZs1u550/f36Hr3e14nz55ZeSpBUrVqi5uVlnnHFGh+MOPPBADR48uMO+l19+WWPHjtX06dM77D/33HNl27ZefvnlDvvnzp3boYvVmDFjJEnz5s3rcNyu/Rs3btzDT+Y/hg0bplWrVunVV1/VNddcoyOOOEJvv/22Lr30Us2cObO9tWuX2bNnq7CwsP1rt9utU089VevWrdPmzZs7HLuvn9MLL7ygUCiks88+W6FQqH0LBAI69NBDtXz58t3yLly4sMPXf/vb35Sdna3jjjuuwzkmT56sfv36tZ9j8uTJ8vl8+t73vqe//OUve50xDgDQtyhMADgmNzdX0s6xCt9UWVkpy7KUnZ3dfmxzc/Me+/RXVlYqGAx2OO/ezimpw7F7k5KSorfffltvv/22nnnmGc2aNUsPP/zwbtPgXnnllfr5z3+uBQsW6JlnntG///1vvf3225o0aVJ7V6A9Pedd/H6/JLUfuyt3v379dnvsN/ftbYzHgAEDOpxrl28+b5/P1+n+bxYWe+JyuXTIIYfof//3f7V06VJt3bpVp556qt59913dfffdneb/+r5vZt3Xz2nXOJ/999+/vYDctT366KMqLy/v8PjU1NQO45h2naO6ulo+n2+3c5SWlrafY9iwYfrHP/6hgoICXXLJJRo2bJiGDRum3//+9/v8+QAAes5jOgCA5DFs2DClpKTsNlBcklavXq3hw4crEAhI+s/YktWrV+uAAw5oP27XB8jx48e375swYcJezympw7F743K52ge7S9KRRx6pqVOn6pprrtEZZ5yh4uJiSdIDDzygs88+W9ddd12Hx5eXl7cXVd2x6wN5aWnpbt8rLS3VkCFDOhy7bdu23Y7bNUg8Ly+v29fvrbS0NC1atEiPPvpoh3E/0t6fk7R7IbIvu57brrEq+7KnVrJdA+uff/75PT4mIyOj/d8HH3ywDj74YIXDYb3zzju65ZZbdPnll6uwsFCnnXZat7IDALqGFhMAjvF4PDruuOP0xBNPqK6urn3/xo0b9corr+jEE09s33f00UcrEAjo3nvv7XCOXQvyfX29lBNOOEGffPKJ/v3vf7fvC4VCeuCBB3TAAQe0tyh0h9/v12233abm5mb98pe/bN9vWVb73fxdnn322R7P/DVjxgwFAgE9+OCDHfa/8cYb7d2Ydpk9e7Y+/vhjvffeex3233fffbIsS4cddliPMnTVnooiSe1d2L75c37ppZc6zGgWDof16KOPatiwYSoqKurWtY866ih5PB59/vnnmjZt2h63fTn22GNVUVGhcDi8x8ePGjVqt8e43W4dcMABuu222yRpt589AKDv0GICoE/8/e9/V0NDQ3vB8fHHH7fPvjR37lylpqZK2jkD1f77769jjz1WP/nJT9Tc3Kz//d//VV5enn74wx+2ny8YDOp//ud/9POf/1zBYFBz5szR22+/rauvvlrnn3++xo4d237sd77zHd122206+eSTdf3116ugoEC333671q5dq3/84x89fk6HHnqo5s6dq3vuuUc/+clPVFJSomOPPVb33nuvRo8erYkTJ+rdd9/VDTfc0O0P2rvk5OToqquu0i9/+Uudf/75Ovnkk7Vp0yZdffXVu3WFuuKKK3Tfffdp3rx5uvbaazV48GA9++yzuv3223XRRRdp5MiRPX6uXTFu3DjNnj1bxxxzjIYNG6bm5mb9+9//1m9/+1sVFhbqu9/9bofj8/LydPjhh+vnP/+50tLSdPvtt+uTTz7Z65TBnRkyZIiuvfZa/exnP9P69et19NFHKycnR9u3b9dbb72ltLQ0XXPNNZ2e47TTTtODDz6ouXPn6gc/+IGmT58ur9erzZs365VXXtHxxx+vE044QXfeeadefvllzZs3T4MGDVJzc3N7N7Ujjjii29kBAF1kevQ9gMQwePDg9tmavrlt2LChw7HvvPOOPXv2bDs1NdXOzMy0FyxYYK9bt26P5/39739vjxw50vb5fPagQYPsX/ziF7vNAGXbtl1aWmqfffbZdjAYtAOBgD1jxgx72bJlXcq+twUWbdu2V69ebbtcLvu8886zbXvnLFrf/e537YKCAjs1NdX+1re+Zf/zn//cbTHEXbNyPfbYYx3Ot2vGrHvuuad9XyQSsRcvXmwXFxfbPp/Pnjhxov3MM8/scYHFL7/80v72t79t5+bm2l6v1x41apR9ww03dJh9a9c1brjhhg6P3Vumri5y+Ic//ME+8cQT7aFDh9qpqam2z+ezhw0bZl944YX2pk2bOhwryb7kkkvs22+/3R42bJjt9Xrt0aNH2w8++GCXrr0r6yuvvNJh/1NPPWUfdthhdmZmpu33++3BgwfbJ510kv2Pf/yj/ZjO/n+2tbXZN954oz1p0iQ7EAjY6enp9ujRo+3/+q//sj/77DPbtm17xYoV9gknnGAPHjzY9vv9dm5urn3ooYfaS5cu7fTnAwDoHcu2bdtEQQQASFyWZemSSy7RrbfeajoKACBOMMYEAAAAgHEUJgAAAACMY/A7AKDP0UsYANBdtJgAAAAAceyOO+7QxIkTlZmZqczMTM2cOVN///vfO33Mq6++qqlTpyoQCGjo0KG68847HUq7dxQmAAAAQBwrKirS9ddfr3feeUfvvPOODj/8cB1//PH66KOP9nj8hg0bNHfuXB188MFauXKlfvrTn+r73/++lixZ4nDyjpiVCwAAAEgwwWBQN9xww25rTEnSj3/8Yy1durR9gVxJuvDCC7Vq1SqtWLHCyZgdJNUYk0gkoq1btyojI0OWZZmOAwAAkPRs21ZdXZ0GDBgglyv2OvM0NzertbXV8evatr3b51W/3y+/39/p48LhsB577DE1NDRo5syZezxmxYoVmjNnTod9Rx11lP785z+rra1NXq+3d+F7KKkKk61bt6q4uNh0DAAAAHzDpk2bVFRUZDpGB83NzSoZnK7SsrDj105PT1d9fX2Hfb/4xS909dVX7/H41atXa+bMmWpublZ6erqefPJJjR07do/HlpaWqrCwsMO+wsJChUIhlZeXq3///n3yHLorqQqTjIwMSdK3NFcemakEASSvtsMmqzkYm689KRVt8ix/33QMAEkopDb9S8+1f06LJa2trSotC+vLd4coM8O51pzauogGT/1CmzZtUmZmZvv+zlpLRo0apffff1/V1dVasmSJzjnnHL366qt7LU6+2Rqza3SHyV5FSVWY7PpBe+SVx4rNDwcA4pfl8Sg8Y/xev99SnKJwioOBuqElNSDfwfvv9fvuNz+UHQo5mAhA0vhqtHMsd7NPz7CUnuFcvoh2XmvXLFtd4fP5NHz4cEnStGnT9Pbbb+v3v/+9/vCHP+x2bL9+/VRaWtphX1lZmTwej3Jzc3uZvueSqjABgL5g+f1y9yvYbb/t82rH2BitPPahLdVSZSfZC7cPktXattv+8Nbtstuc73sNAOicbdtqaWnZ4/dmzpypZ555psO+F198UdOmTTM2vkSiMAGAfbK+0XTu7leg0qNiqx90tG0/rHCP+/u9IIVLyzrss/fyRggAiI6f/vSnOuaYY1RcXKy6ujo98sgjWr58uZ5//nlJ0qJFi7Rlyxbdd999knbOwHXrrbfqyiuv1AUXXKAVK1boz3/+sx5++GGTT4PCBAA6487J0faTR5uOEbN2Fmgdi7TCxz5RuKrKTCAAiIKwHVHYwQU2wnakW8dv375dZ511lrZt26asrCxNnDhRzz//vI488khJ0rZt27Rx48b240tKSvTcc8/piiuu0G233aYBAwbo5ptv1sKFC/v0eXRXUq1jUltbq6ysLM3S8YwxAbAbVyCgqpMmd9hnuyyFAmbyxCtPs2RFOr615Dz+viLNzYYSAYhlIbtNy/W0ampqujyewim7PjuWrR3s+OD3glFfxuTPJJpoMQGQ1CIH76dwinvnv92W2lJjd/BlvNhZyHX8OTYdNkGur243uhtDcv3rfcdzAUBPRWQrIufu5Tt5rVhCYQIgqbjz86VgVvvX1SUBWkQcUFf8n7cbT7NXuTuG/+eblTUK79hhIBUAIJZQmABIbJYlV3p6+5et44pVNbLzVXMRXaGAtP3Q/Pavg2sy5PlaN69Ifb2UPL2MAcSBiCLq3qiP3l8vGVGYAEho7tygtp840nQMdKJyTEAa85/1XwqXrFW4otJgIgCACRQmABJOzRkzFPYxViRe7Zg/qv3f7lZbWQ++aTANAMApFCYAEoKnuEj1kwdIkkIplmznJk9BH4t8bdJE222p+bjpkqT0lVsU2rzFUCoAySxs2wo72MXUyWvFEgoTAHHNPW6UIj6PmnIDqu/vNh0Hfcx2qf3/q7upn3z52XK1hhT+aK3hZACAvkZhAiDuWB6PXNk7Z9aqmBJUKMVwIDiiZqhPGuqTp0nK3Z4rSYpU18gOhQwnA5DomC7YGRQmAOKHtXPciLtogErnDDQcBqaEUtQ+oUG/v2/6T/euJO36AACJgsIEQNxoWDhdzdkMHsF/bD+qWFKxAlURpS35t+k4AIBeoDABENPcOTmqOWLn3fGWTBeD2tHBrt+H5myX7JMPkCRlLftE4eoag6kAJJqIbIXpyhV1FCYAYpJr/GiFswJqCbjVnEM1gs7ZbrX/ngSmDpe7OSxPdROD5AEgjlCYAIgdLrc8A/tLkqrHZFGQoEeqh/kkSSmVfmXVFkmSQlu2SZGwyVgA4hiD351BYQLAPJdbltstV2a6So8pNp0GCaIp6FLTV79PhY81KFLfIDscpkABgBhFYQLAuNYj91PdIO++DwR6qOyk0ZKkzC/b5H3xHcNpAMQbFlh0BoUJACMsr0/Vp0yRJIX9lmzLcCAktF2/X3VFXrnPmCFJyv7re7LbWg2mAgB8HR24ATjOnZerlsMnqi3NUluapQi3SOCQiEftv3eth02UOy/XdCQAwFf4OADAMZ4hg2T7vArlpqt2MF23YFbNEK88dUXyBLNltbYp9MVG05EAxKjIV5uT10tGFCYAHOFKS1PlzAFqzaDPFmJHxYRUSany19rK2lGhSEOD6UgAkLToygUg+lxu7Th9IkUJYlZLpqUdp0+ULH5HAewu/NUCi05uyYgWEwBRY+03TpUTMyVLrNiOmGe7pKpzZki2lLuqRpH3PzYdCQCSCh8VAESFfdBk1YzOUNgvhX2m0wBdE/ZJYb9UMzpT9oGTTMcBgKRCiwmAPmN5fbLGDpMkVQ8OqDWdbjGITy2ZluzBKcpuGCNJsj/+nKmFgSQWtnduTl4vGVGYAOgTlt8vd78ClR6QbToK0CdaMyyVffX73K+6UOGt2ylOACCK6MoFoE9YI0pUelSR6RhAVJQeVSTXiCGmYwAwJGJgS0YUJgB6rfWoadoxI8d0DCCqyg7MVducaaZjAEDCoisXgB6x/H7VHzdZktSa7mLWLSQ82yXVD/DKd9IBkqT0p1fStQtIEhFZCsu5cZMRB68VSyhMAHSbOzeotjGD1BSkGkFyCfvU/nufcsBYeT/6UuGqKsOpACAx8KkCQLe4s7MUKRmgyrEppqMARlWOTVFk6AC5s7NMRwGAhECLCYCuc7nVMmW4qoezMAkgSTumZionY5jcr62SImHTcQBEScTeuTl5vWREiwmALqs7ZX+KEuAbqkb6VXfy/qZjAEDcozABsG8ut2pPn8GCicBetGZYqjtthuRym44CIArCXw1+d3JLRhQmADrlzs5S6LDJaku3mHkL2AvbtbM4CR02We7MTNNxACAuMcYEwB55igbKDvgUyU5T9TC6bwH7YltS9TCf8quL5a5plNXcqtDmLaZjAUDcoDABsBtXIKCaGUVMBwz0wI6pmZIylVIRUUZ5hSLNzaYjAeglp7tX0ZULAL5S/u39KEqAXmrKdan82/uZjgEAcYNPHgDaubOzVHXOTEVoSwX6RMQjVZ0zk3EnQJyL2JbjWzKiMAEgSfIMGaT6Q0cp7DedBEgsYb9Uf9hoeQYXm44CADGN+6IA5BkySE0jC9RQyFSnQDQ0FLrlGVGgFMtS6IuNpuMA6CbGmDiDwgRIcu7sLNVN6kdRAkRZzVCfwin9lFZdo3B1jek4ABBz6MoFJLny48dSlAAOqe/vVsX8saZjAEBMojABkpQrNVWV35nJmBLAYaGAVPmdmXIFAqajAOiisFyOb8koOZ81kOQ8RQNVN3cCs28BhkQ8Ut2xk+QZOMB0FACIGXwsAZKQHfCxTglgWFPQpSy/z3QMAF1gOzyFr810wQCSgTszU5HsNNMxAEgK56SxxgkAfIXCBEgmLrda9h+hHVMyTCcBIGnH1Ey1TBshuZiAAgDoygUkkdpT91dbenI2DwOxqmaYT76C/ZXxyJumowDYC9YxcQYtJkASsDwe1Z02Q21plpK02yoQs2xLak23VHfaDFpOACQ1WkyABOfOzlLrfsPUkklFAsQq2yW1ZlgKHzpJvnfXKVxbazoSgK8J2y6Fbefu54dtxy4VU2gxARKYOydHkWFFqhrBYiVArLMtqWqEX5ERxXLn5JiOAwCOi9vCZPHixbIsS5dffrnpKEBMsvx+tY0brB1TmfEHiCc7pmYqNHawLC9TCQOxIiJLEbkc3JKzl0NcFiZvv/227rrrLk2cONF0FCBm1R83WZVjU0zHANADFeNSVD9/P9MxAMBRcVeY1NfX64wzztAf//hH5dDUDQAAACSEuCtMLrnkEs2bN09HHHHEPo9taWlRbW1thw1IBq1HTVNretz9eQP4mtYMl9rmTDMdA4D+M12wk1syiqtPLo888ojee+89LV68uEvHL168WFlZWe1bcXFxlBMCZll+v1zjR6uu2Ksw3dOBuBb2SbWDvHKPG8V4EwBJIW4Kk02bNukHP/iBHnjgAQUCgS49ZtGiRaqpqWnfNm3aFOWUgDmW1yd3vwKVHZgjB2c0BBBFtkvaflBQ7n4FFCeAQbumC3ZyS0Zxs47Ju+++q7KyMk2dOrV9Xzgc1muvvaZbb71VLS0tcrs7Lkzl9/vl9zNNKpKDNXaYSg/INh0DQBSUHlOsgjfTZX/wiekoABA1cVOYzJ49W6tXr+6w77zzztPo0aP14x//eLeiBAAAAED8iJvCJCMjQ+PHj++wLy0tTbm5ubvtB5KNfdBkVQ/uWhdHAPGpely2MtInyXpjlekoQNLZuY6JcwPSWccEQFyy9hunukEBtaYn54sYkCxaMyzVD0qRa/JY01EAICripsVkT5YvX246AmBc5aRMZuACkkRLpqWKSVnKed90EiC5RORS2MH7+RHZjl0rltBiAsQzF2OrgKTE3z6ABERhAsQpV1qaKr4zndYSIMmE/VLFd6bLlZpqOgoA9Km47soFJCvPkEGqmjGA9UqAJGW7pJr5E5WzYotCX7JGFxBtTq8tErbpygUgTtg+r1oyGewOJLOWTEu2z2s6BgD0GVpMgDjjzstVKDfddAwAMSCUlyFPVa7C5RWmowAJLSKXIgx+jzpaTIA4Ynl9appaoooJ9C0HIFVMSFXzlBJZXgabAYh/tJgAcaT6lClqS6MLF4D/qBnile/kKcp86E3TUYCEFbYthW3n3n+dvFYsocUEAAAAgHEUJkA8cLnVetQ0hf3JeQcFQOdCAUutR01jfRMAcY2uXEAcsNxu1Q3yKklbdgHsQ8Qj1Q3yKs9lyY6YTgMknrDDK7+HGfwOICa53HJlMgsXgH1zZWXSagIgbtFiAsQ4z8D+Kj2m2HQMADHOtqTtC0ep33MbFdq8xXQcIKFEbJciDi6wGGGBRQCxxp45SWVHUpQA6LqyOYOk6RNMxwCAbqMwAWKZy1KEdk0A3RDxSLaHt3cA8YePPECMco8dqfp8Fk0D0H3N+X6ljxmh8JrPTEcBEgKD351BYQLEqJpxOWrO4a4ngO5rKHQr4g0qbY3pJADQdRQmQCyyrJ0bAPSQbWnn60iSDqIF+lJEzq7GnqyzfnM7Fog1lqXK82aoJYvCBEDPtWS7VHnuDG5yAIgbtJgAMch2icUUAfSKbYnbj0AficiliIN/UE5eK5Yk57MGYpQrLU2Rb02WKEoA9AWXFDloklypqaaTAMA+UZgAMcRKCahyTIDWEgB9wrakyrEpslJTTEcBgH2iKxcQK1xuWV6v6RQAEpDl8TAQHuiFsO1S2MGV3528VixJzmcNxCBr0miVHldiOgaABFQ6f6hck8aYjgEAnaLFBAAAAOhERJYiDg4AdfJasYQWEwAAAADGUZgAMcBTXKTWfAanAoielrwUeYoGmo4BAHtFVy4gBtRNGaCGQrfpGAASWM1Qn8KBgQps3mI6ChB3GPzujOR81gAAAABiCoUJYFjNGTPUmE9rCYDoa+jnVu23Z5iOAcSdsFyOb8koOZ81EEPCPktJ2mILwGG2a+drDgDEIj4OAQAAAJ2I2JbjW3csXrxY+++/vzIyMlRQUKAFCxZo7dq1nT5m+fLlsixrt+2TTz7pzY+qVyhMAFMsS+68XNMpACQZ29LO1x6LlhMgUbz66qu65JJL9Oabb2rZsmUKhUKaM2eOGhoa9vnYtWvXatu2be3biBEjHEi8Z8zKBRjiSk/X9hNHmo4BIMlEvNL2E0eq4MEPFOnChxYAse/555/v8PU999yjgoICvfvuuzrkkEM6fWxBQYGys7OjmK7raDEBAAAAOhFxeOB75KuP6LW1tR22lpaWLuWtqamRJAWDwX0eu99++6l///6aPXu2XnnllZ7/kPoAhQlggKdksGqPGWc6BoAkVjtvgjyDi03HANCJ4uJiZWVltW+LFy/e52Ns29aVV16pb33rWxo/fvxej+vfv7/uuusuLVmyRE888YRGjRql2bNn67XXXuvLp9AtdOUCDLADPjVn078bgDnN2ZZsv890DCAuRGyXIg5OobnrWps2bVJmZmb7fr/fv8/HXnrppfrggw/0r3/9q9PjRo0apVGjRrV/PXPmTG3atEk33njjPrt/RQstJgAAAEAMyszM7LDtqzC57LLLtHTpUr3yyisqKirq9vVmzJihzz77rKdxe40WE8BpLrfk4p4AgBjgce98TYqETScB0Au2beuyyy7Tk08+qeXLl6ukpKRH51m5cqX69+/fx+m6jsIEcFjbEfupYrDXdAwAUNlBucockCHvP941HQWIaWFZCsu5LtjdvdYll1yihx56SE8//bQyMjJUWloqScrKylJKSookadGiRdqyZYvuu+8+SdJNN92kIUOGaNy4cWptbdUDDzygJUuWaMmSJX37ZLqBwgRwmG3t3ADANF6LgMRwxx13SJJmzZrVYf8999yjc889V5K0bds2bdy4sf17ra2tuuqqq7RlyxalpKRo3LhxevbZZzV37lynYu+GwgQAAADohKnB711l2/Y+j7n33ns7fP2jH/1IP/rRj7p1nWijozvgIE/JYIVS3aZjAEC7ULpbniGDTMcAAFpMACdVHNRfban0nQAQOxoK3Go9aICyvti474OBJBVW98d99PZ6yYgWEwAAAADGUZgAAAAAMI6uXAAAAEAnYn3we6JIzmcNOM3llmviaEU8jC8BEHsiXkuuiaMli9coAObQYgI4wPJ6VDYjx3QMANijsE/acUCO8tZ4Zbe1mo4DxJyw7VLYwVYMJ68VS5LzWQMAAACIKRQmAAAAAIyjKxcAAADQCVuWIg6uY2I7eK1YQosJEGXu7CxFpo0xHQMAOmVbUmT/MXJnZpqOAiBJ0WICRJmVnaWKcSmmYwDAPlWMT1W/TZlSba3pKEBMYfC7M5LzWQMAAACIKbSYAAAAAJ2I2JYitnPjPpy8ViyhxQQAAACAcRQmAAAAAIyjKxcQRe68XIUKskzHAIAuC/fLkbuxUeGKStNRgJgRlkthB+/nO3mtWJKczxpwSNuYQSqfnG46BgB02Y790hUaPch0DABJiBYTAAAAoBMMfncGLSYAAAAAjKMwAQAAAGAcXbkAAACATkTkUsTB+/lOXiuWJOezBgAAABBTaDEBAAAd2JaUnENvgT0L25bCDg5Id/JasYQWEyBKGhYeoKpRAdMxAKDbqkanqPHEA0zHAJBkaDEBoiTisWRT+gOIQ7ZLirhNpwBiB9MFO4OPTQAAAACMozABAAAAYBxduQAAAIBO2LZLEQf7Z9tJ2hc8OZ81AAAAgJhCiwkAAADQibAshR2cRNvJa8USWkwAAAAAGEdhAgAAAMA4unIBAAAAnYjYzq4tErEdu1RMocUEAAAAgHEUJkBfsyzVnDlDrRnJOXANQGJoyXKp5owZksVrGRD5arpgJ7dklJzPGoiyUMBSkr6mAEgQtksKpVCUAHAOH50AAAAAGMfgdwAAAKATEVmKOLi2iJPXiiW0mAAAAAAwjhYTAAAAoBNh21LYwemCnbxWLKHFBAAAAIBxtJgAAAAAnXB6Cl+mCwYAAAAAQyhMAAAAABhHVy4AAACgExFZijg4IJ3pggEAAADAEFpMAAAAgE7YDi+waNNiAgAAAABmUJgAAAAAMI6uXAAAAEAnIrbDg99Z+R0AAAAAzKDFBAAAAOgEK787IzmfNQAAAICYQosJEAWeJluhFEtJesMDQAKwIjtfywAwxsQpfGwC+pptK+vBN+Wr4w0dQPzy10SU9eCbks1rGQBnUJgAAAAAMI6uXAAAAEAnIg6v/O7ktWIJLSYAAAAAjKPFBAAAAOgEg9+dQYsJAAAAAOMoTAAAAAAYR1cuAAAAoBN05XIGLSYAAAAAjKPFBAAAAOgELSbOoMUEAAAAgHG0mAAAAACdoMXEGbSYAFGS9dxHyv681XQMAOi2nM9alPnch6ZjAEgyFCZAlETq6uRqjZiOAQDd5mqNKNLQYDoGgCRDVy4AAACgE7akiJzrXmU7dqXYQosJAAAAAONoMQEAAAA6weB3Z8RNi8nixYu1//77KyMjQwUFBVqwYIHWrl1rOhYAAACAPhA3hcmrr76qSy65RG+++aaWLVumUCikOXPmqIHBeQAAAEDci5uuXM8//3yHr++55x4VFBTo3Xff1SGHHGIoFdA5b2mNMjI9qhsYN39qAJJcxuaQPNtrFDYdBIghdOVyRtx+WqqpqZEkBYPBvR7T0tKilpaW9q9ra2ujngv4uvBn65XWFlLdwIGmowBAl6St3qbQps2mYwBIQnHTlevrbNvWlVdeqW9961saP378Xo9bvHixsrKy2rfi4mIHUwIAACAR7GoxcXJLRnFZmFx66aX64IMP9PDDD3d63KJFi1RTU9O+bdq0yaGEAAAAALoj7rpyXXbZZVq6dKlee+01FRUVdXqs3++X3+93KBkAAAASEWNMnBE3hYlt27rsssv05JNPavny5SopKTEdCQAAAEAfiZvC5JJLLtFDDz2kp59+WhkZGSotLZUkZWVlKSUlxXA6oBPNLUqpiKgpNy57TgJIIikVEdmtraZjAEhScfNJ6Y477lBNTY1mzZql/v37t2+PPvqo6WhAp0Kl25X+t/dNxwCATlm2lL50pcLby0xHAWKObVuOb8koblpMbNs2HQEAAABAlMRNYQIAAACYEJGliBwc/O7gtWIJhQkQRS3H7K/ySV5ZEclXTasfgNhlW9LmK6dJlpS/slW+F94xHQlAkqEwAaLEPnCSth7sUXBymdrCLjW+m6eU7bassOlkANCR7ZaaCi2lTi2X1x3R1vR8Da6dJGvFKtPRACQRChOgL7nccgezJUlrvuNV4YAdkiSvO6Ks6WVqerFAnkZaTgDElnDAUtb0/wx6z5myQ58V5GjMZ7k7v19ZLUW4q4LkxTomzqAwAfqQe8xwVd6w8827UNVmwwBALxQWVanyvhxJUvCHQYXXfGY4EYBER2EC9IEvfjlTGtEgtzuiTHFXEUBi2XBtQJHIRFlr0zT4f1eYjgM4zukpfJkuGEC3uPNy9fkVIyVJ1oh6Zac37fMxdfs1K2VtQIFyunMBiA1N+ZaaRzars6WKs9J2vr5VjZK++NVMSdKw361VuKLSgYQAkgWFCdADnqFDVDarv3L229GtxxXk16pqoz9KqQCg+8Kptgrya7t0bE5Go7RfoyRpx/xRKli+VaENX0YzHhATGGPiDAoToBs8xUWSx60dB/eX+6TuFSUAkEjcJ+9QeWiA8iQpFFZo02bTkQDEOZfpAEDcsCx9+us8VdzmlevUXhQlyXkTBEACsk7foYrbvFr76zzJ4sUNMGXx4sXaf//9lZGRoYKCAi1YsEBr167d5+NeffVVTZ06VYFAQEOHDtWdd97pQNq9ozABusCdnaVtT45WTlZDr8+VOblClVMYIA/AvMqpIWVOquj1eYJZDdr25Gi5MzP7IBUQe3YNfndy645XX31Vl1xyid58800tW7ZMoVBIc+bMUUPD3j+3bNiwQXPnztXBBx+slStX6qc//am+//3va8mSJb39cfUYXbmATtScOUNl023JLRX4ev/mLUluV0RyMfgdQAxwffWa1NvTWLZSfW36ZPEYKSwVvmkp86E3+yAggK54/vnnO3x9zz33qKCgQO+++64OOeSQPT7mzjvv1KBBg3TTTTdJksaMGaN33nlHN954oxYuXBjtyHtEYQLsRd2pM1Q2w1bB0L4pSAAg0RWU7Hy93G7lyhWaofS/UpwgMdgOD37f1WJSW9txYgq/3y+/f9+T6NTU1EiSgsHgXo9ZsWKF5syZ02HfUUcdpT//+c9qa2uT1+vtbuxeoysX8DWu1FS5Jo+Va/JYlc5rjVpRYvkias2mPzYAc1qzLVm+6HQrLRhWoW3zWttfT12BQFSuAyS64uJiZWVltW+LFy/e52Ns29aVV16pb33rWxo/fvxejystLVVhYWGHfYWFhQqFQiovL+919p6gxQTYxeWWPXaoqq9tliQVqDVqlyooqFF9pl96nv7YAMywZ9SoINAStfMX5Neq6rqd/87+2TBp1SdShPF1QHds2rRJmV8bu9WV1pJLL71UH3zwgf71r3/t81jrG5NW2La9x/1OoTABvlJ57nRZC8tpRgSAPlbx/9pkPTZdOX9h1XjEJ1uS7eDw0F2XyszM7FCY7Mtll12mpUuX6rXXXlNRUVGnx/br10+lpaUd9pWVlcnj8Sg3N7e7kfsEhQmSm2Xp0zv2l3wR+dIalGMxKB0A+prbFVHV3AbtOHSa1OLSyIveMh0JSCi2beuyyy7Tk08+qeXLl6ukpGSfj5k5c6aeeeaZDvtefPFFTZs2zcj4EokxJkhi7tygtv5wpoIDq1XYr3rnisYO8nlCqpoUke129LIAkpztlqomReT3tjl63ZyMRhX2q1awqFpbrzpQ7pwcR68P9EZEluNbd1xyySV64IEH9NBDDykjI0OlpaUqLS1VU1NT+zGLFi3S2Wef3f71hRdeqC+//FJXXnml1qxZo7vvvlt//vOfddVVV/XZz627aDFB0nGNH622vFQ15HqVdniZsRw+T1gFJRVq+bhAVpiWGgDOsN1W++xZJnjdEXkPL1Pd5yPlr2qTt7xRkQ8/MZYHSAR33HGHJGnWrFkd9t9zzz0699xzJUnbtm3Txo0b279XUlKi5557TldccYVuu+02DRgwQDfffLOxqYIlChMkGXd2ltadmaPgxF6s3N7HIj7JCktW75cSAIBO2S4p7DOdYqe2CyrUJqny/XwN/02WwtU1piMBe9WTRQ97e73uHb/vG5z33nvvbvsOPfRQvffee926VjTRlQtJZd2dg2OqKJGklCPL1JzH1MEAoq8531LqEeZaivckOHmHPrt93/3hASQ+ChMkBXdOjjY8PEnZGU37PhgA4KicrAZteHiS3N2YfQhA4qErFxJa/ckHqGKCSxGPFMyKrZYSAMBOLstWMKtB634yTq6QlLcqorQl/zYdC2gXsS1ZDnblcnKV+VhCYYKE1XrUNJXOtJQ/OvYLkuaCsFwht/yVDIIHEB0tQUvNBWHFcptEcPLO1+vStDwNqpsm74vvGE4EwEl05UJC8hQX6cszIsofXW46SpcUDK9Q40BWRAYQPY3FYRUMMzcbV3fkjSnXF9+25SnufIE4wCm27fyWjChMkHBcqanacWeKCvJqTUcBAPRQQUGNyu5IlSsQMB0FgEPoyoWEUfHdmWo5dud0k2lWq+E03ZdbUqWq3FRlLU8xHQVAgqmd1aTcTGcXke0LbldEmx8eKklKeTpLOfeuMJwIQDRRmCAhbP3vA9U4sUn5/vgrSHZxuyJyuVjMBEDfc7kjcsfp60vaV6/rZYe3qDn3QPX/7RuGEyEZxfo6JomCrlyIe9Vnz1TT5Cbl59aZjtJrfn9INSMkJefrEYC+Zkk1IyS/v810kl4ryKtVw+QmVZ8103QUAFFCiwnikjs3KLt/geS21LqwSnnekOlIfSLN36qUseUKfZ4nK0kHvgHoO7ZLCo4tlytBXlDyc+vUtLBZrlWjpYhkbStTuKLSdCwkAVpMnEFhgrhjeTyqOmqk7DN3zrjlN5wnGmyXJSuSGB8kAJhjuxLvw02Kr01V1+/8t+svI5W55B3ZocS4OQUkO7pyIe5suGZ/hc+Ijykve8Jl2fLO26HW7MT7QAHAOS05lrxzdyRMa8metJ1VqQ2/2N90DAB9hMIEceWz38+Qd0xtQr/RSkr45wfAAVbiv5a4XRF5x9Vq3f/NMB0FCS5iW45vyYjCBHHBlZam0ssPVMbgGqUHWkzHcUT98DY15SfnCxOA3mkqsNQwNP4HvHdFeqBF6SU1Kr38QLnS0kzHAdALFCaIee78fDUdOlYpc8qU4kuON1pJKiyqUmt2Yt/tBBAdrTkRFRZVmY7hmBRfm1LmlKnpkLFy5+WajoMExMrvzqAwQcxyZWTInZ2l+oNK1Hxp8rzBfp3tthXx0GoCoOsiHku223QKM5ovq1LDjGFyZ2fJlZFhOg6AbmJWLsSstbeOUEF+raTknQoyf3S5duRnKPufAdNRAMSJ2gOblB+M/3Wdeqrl4kq1XJyv7duzNPK8d03HQYLY2Yrh5HTBjl0qptBigpjjCgS07oH9lJtbbzoKACBOBfPqtO6B/eQKcGMHiBcUJogp7uEl2rBoivKDdXK7IqbjxIS0jGZVTgmbjgEgDlROCSstvdl0jJjgdUeUH6zThkVT5Bk6xHQcAF1AYYKY4R43SqVH9lP2/mWmo8SUVF+bcgbUmI4BIA4EB1YrNYkmCemK7P3LVHpkf7nHjjQdBXFs18rvTm7JiMIEMcGdn69Nx+TKd9wO01FiVijVkpLzdQrAvlhfvUZgj7zH79CWo/Lkzs83HQVAJyhMEBPWXFuitMNpKdkbnyeslDllfPAAsEdtaZZS5pTJ66YL7N6kHFmmT34x1HQMxCnbwJaMKExglsutDY9MVF5xtekkccF9WIXqi02nABBL6gdJnlkVpmPEhdwhVdrwyETJ4iYPEIsoTGCMp7hIn9+wv7Izmhjo3kU+T5i/WgAd2K6vXhuwT25XRNkZTfr8xgPkGTjAdBwA38BHHBjhGj9aWxYMUt6YcrmsZG2w7JnWgpAa+3O3D4DU2N9SWwGD3bvDZdnKG1OurScMYUA8uozB785ggUU4zjO4WFtnBRU4hjElPVE4sEplvkx5GgLy1VLUAcmqNdNSy7BmFebVmo4Sl/xzy7QtUqABdY0KbdpsOg4A0WICB1kejyyPR59eUiT/XIqS3ijIr5UOqjYdA4BB1reqVEBR0iv+Y8v02SXF7e9PwF4x+t0R/BXCEZ5+hdp2V7YkKcddbjYMAABfyZ5QrrInhkmS+n23UuEdTFsPmEKLCaIucvB++viXxfJ5wvJ5wowp6SMpvjbVHdaoiDc5+6ECySritVR3WKMC3pDpKAnBZdnt709rrhsi+6DJpiMhFjk9viRJx5hQmCCqWubury/nBlQ4oNp0lITjsmwFsxpUMzastozkfAEDkk1rpqWasWEFsxq4yRMFhQOr9MW8FLUcs7/pKEBSojBB1FhTx2nzYR4FJ9EsHk0FJRVqSzOdAoATQmk7/+YRPcHJO7RllkfW1HGmowBJh8IEUeHKyNC6K33KG0dR4gTbvXMtAwCJy3ZLtptWEifkTtihzy73yZWRYToKYoRtO78lIz7KoM+5MjJU8Ug/5eXUmY6SNLL3L1P1BBapBBJZ1cSwsqdxs8cp+bl1qnikn1xpNEkDTqEwQZ+ypo7TZ3cOp++zAdnF1ar6VovpGACioPrgZuUMrHH0mgPSa/Tk+Hv15Ph71S8tOW80uSxbn/5hpFyTx5qOAsNYYNEZFCboMy1z99e60zJpKTHE5wkrK6tRlVPCdOsCEoTtkiqn7Pzb9nnCjl13Ut4WfX/gS+rvSVd/T7ouL1qmCbnbHLt+LMkP1mndt7PUejQD4oFo4+ML+kTk4P209WAPY0oM83tDyi+ukpLzRguQeCwpv7jK0aJkTHC75uWs0qyU/3QPnZUS0bzgKo0JbncsRyzJHb9DWw/2KHLwfqajAAmNwgR9Yt0ZXmbfiiHhgEWrCRDnbNfOv2UnZfhb9IPCf2h+WuNu31uQVq9LC19Shj85u4zm7LdD687wmo4BU3atLeLkloT46AIkGJdlK+XIMrVmJ+eLGpAoWnIspRxZ5tiYPcuy9fSoJZrs9+/1mKl+n54c9ZgjeQAkHwoT9Irl8WjDIxOVV1RtOgq+wXdghWpGmE4BoCdqRtryz3RuvZLsQJOWTXhQqS7fPo9NdwX0j4kPKMvf7ECy2JJXVK0ND0+SXG7TUeAwpgt2BoUJeswzuFifX7e/sjOa5HYxVW2s8XnC8g6pVxXTCANxpWpiRN7BDY6NKxkXLNWvSp5UuivQ5cekuwL6f0OfTLoxJ25XRNmZjVp//XR5igaajgMkHAoT9Ihr/GhtPa5YueN3MDVwDMtKa5KV02o6BoBucAVblJXW5Mi1JuVt0fG572mqf98tJd803e/V8bkrk262Lpdl7xwMf/xguceONB0HTrENbEmIwgTd5ikaqG2HBeWfW2Y6CrrA7Y6oLYPxJkA8aMuw5HKoBbogrV5n5K3Y40D3rlrw1TkK0ur7MFl88M8r07ZZebScAH2IwgTd43Jr7RXFChxDURIvglkN8s4qZ5YuIMbZLsk7q1zBzJ4XCl1lWbbuHrpEh3S999ZezUqJ6E9Dl8hKwtZz/7FlWvuDQYw5AfoIH1XQLV88PE7B0c4NyETf8Lojch9bobZ0Wk6AWNSWbsl9bIW87ui3lqR42/TaxL8qz53WZ+cscKfptYl/VcAT6rNzxovg2HJteHC86RiIMlZ+dwaFCbrEnZ+vT++Yrsy0ZsaUxCm3K6Lm6fVqHJCcL3ZArGoYaKnlgHpHJhEZnl2u20c8LK/V93f4vZZbd4x8SEOzkuvmlcuylZXRpE/vmC53Xq7pOEBcozDBPrnHjtTms0eocHAls2/FuWBmo5oHt6i+2HQSAJJUP0hqHdyinIzod9+akr9Zpxe8qTG+1KhdY4wvVacV/FuT8rZE7RqxyO2KqHBwpTafPUruMczTnrAY+B51HtMBENvcw0tUekiuUmczpiRRFBbWaIc3Qy0NKfJXJvGrH2BYc66lcEmTCnLqon6tQZlVWpDzruaktkX9WvPTGuWz3lNVa6o21uZE/XqxJPWIMm2vz1e/ljaF1n9hOg4Qd2gxwV65AgGtP6u/fPN3mI6CPpYfrJNrRpUiHrp1ASZEPJY8B1Qpz4GixOcO69fFTztSlOxydGqLFhc/LZ/bmbVYYol3wQ6tP2uAXIE+mFkASDIUJtirz/48Rtn701KSqFJ9bfIfW6awn+IEcFI4YMl/bJlSfNEvFDyuiF4Zv0Ql3vSoX+ubhnnT9dL4x5OyC3DWAWX69I9jTMdAH2LwuzMoTLAbV0aGPvvLFOVkNZiOAge0zapRU0FyvgACTmsqtNR2aI0j1xqQXqNHxt4nt2Xurd5rufXo2PvULy36LUOxJju7QZ/9ZYpcaX03+xmQ6ChMsBvL7VJBfm1S3uVKRhkpLWoe0az6QaaTAImtfrDUPKJZGSktUb/WpLwtumTgyyryON9S8k1FnnRdVvSPpFsh3uuOqCC/VnLxUSshsPK7I/hrQQfu/HzVHzrKdAw4rCC/Vm3FLbScAFHSVGCprbhFBXm1Ub/WyJwyzctZpdkpsTO+Y3ZKWPOCqzQyJ/m6BzfOGsM0wkAXUZignSstTY37D1Hrf1WajgIDCvJrpcm1CgcoToC+FA5YsvarcaQoyfC36Kr+L2p+WvSnH+6uBWn1urLfMmX4o99iFEtaLqpU07ShdOmKe5aBLflQmKDd1u9NUvOlVaZjwKDM1Gb5jtohu+/XXgOSUsRjKXB0mSPdtyzL1t9GP6GJvtidDWqy36+nRy2RlWQL9TZ9v0rbvjvJdAwg5lGYQJL02e9nSIdSlGDnKsbho6rVEkzOuzVAX2nOtRSZ48zrajClUc9PeEB+y+vI9Xoj1eXT8xMeUHagyXQUR9mHV2nd/80wHQOIaRQmSc7yePTFL2cqtbjOkakrER9SfG1qGt/ECvFAD9UPklrGNznyujouWKr/HfyMslwpUb9WX8lypejqIUs1JrjddBTHpPjalDK4Tl/8cqbkolk67jD43REUJknMnRtUzcnTlLVfudIDydXnF/uWH6xTa1GrGgfQcgJ0R8NAS21FrY4snjghd5uOz31PMwLx90F3RsCt43NXalyw1HQUx6QHWpQ5uUJ1p+wvd27QdBwg5lCYJDG7f4Hss8rlSrK+vui6wsIahUc1qC2d4gToirZ0S/boehUURH+tkrzUBp2b/8+YHOjeVQvS6nVOwb+Ul5o862a5XRFFzi6X+uWbjoLuoMXEERQmyczNh03sWzCrQd7DymXzagF0ynZJ/sPLlZMR/ULBsmzdP2yJDgrE/x/mIQHp3mGPJ92AeNviPRj4pvh/RUOPVJ0zU6XXJtebAHrO647ImlehtgzeSIE9ac20ZM2rcGRh2jRfq5ZPfEQ57tSoX8spee40LZ/4iFK8yTPWsfRXUs2ZDIYHvo7CJAlt/e8DVXFks/zekOkoiCNed0TN0xpUc2izqsZH/8MXEA+qJkZUc2izWqY2yOuO/t/F8Oxy3Tz80biYfau7/JZXt454RMOzy01HcYTfG9KOo1u07YcHmo6CrrAt57ckRGGSZCq/M1ONE5uUH4z+oEwknmBWg/Jy6uTr16iaEabTAGbVjLTlL2xUXk6dglnRHyMxJX+zTi94U+N88TP7VneN86XolPy3NClvi+kojsgP1ql+UrMqz5tpOgoQEzymA8BZzcfVKN/fajoG4lx2epNaRrapuTIof5UtiwYUJBHbJbXkWMocWSmfJ+zINYsyqrUw+LZmpzhzPZPmpzUqYL2jipY0ba7LNh0n6gryalV/nF+6x3QSdMa2d25OXi8Z0WKSRFypidMfGeb5vSFlHFymcIolJWeLM5KRJYVSLWUcXOZYUeJxRfS7wU8lRVGyy5zUNt0w6Cl5HBizEyt4jwYoTJKGp7hIFY8NVBqtJehj/iN2qLE/lQmSQ8NAKTB7h2PX87gienXC4xrkSXfsmrGixJuuVyc8nhTFSXqgRRWPDZSnaKDpKNgbpgt2BIVJEmg9aprW/KqA9UoQFS7LlntijRqOqFfVt1ioE4mp+uBmNRxRL++EGsdeS4syqvXQ2PvktpL3rdptufTQ2PtUlFFtOkrUuSxba64rVNsRU01HAYxJ3le7JFF/8gHaeJRHBXm1pqMggaUHWpSd3qTs7AZVTg6z5gkShu2WKieHlZXVqOz0Jsdanafkb9b3+r+alC0l3zTIk67v9X81KQbEF+TVauMxXjUsPMB0FMAIBr8nuPKJLuWPdq7bAZKbzxNW4ZBKVZfnywpb8tZL3jpa6hB/WjMthdIk222rcEilo9cenl2ueTnva05q8qzpsS9zUtvUbK9SQ8ivddV5puNEVd6YclXUFShtiekk6MDpKXyTdLpgCpME5s7Jkc3/YRiQPW1nMVy2PldZa9xytVGcIH5EvJYaSsIqKKlw/NppvlYtGvD3hJ4SuKfmpzVqiPd5XdF4ihpafabjRFXEY8udk6NwVZXpKICj6HCRwNbdPkjBSbSWwJyCoRWqP6jRdAygWxq+1WCkKLEsW8+NWUJR0omJvoCeG7NEVoKPmcyZskOf3jbYdAx8jWU7vyUjCpME5M7O0oZHJio7kw+EMC8nq0HNR9UypTBinu2SWo6uNfLamZfaoOfG35+QK7r3Nb/l1XPj71cwJbHf44JZDdrw8CS5MzNNRwEcQ2GSYFwTR2vdT8YqmNnILFyICS7LVlqgVZXT21R5QJsa+1GhILY09rdUeUCbqvZvU3qgxfHXzgm527Ro0LPKcbOORVfluFP1s8F/07hgqekoUeOybAWzGrRu0Ti5x40yHQdwBCMQEkxbbqqCE+m+hdjismwV9q+WJG2P5Cgc8MiKSOkbzeZCcqsftLOVpK2gtf3302kTcrfpuOBKHRTgPmF3HRRwaUfu+5Im66PKfqbjRE1w0g61PZfBnWTTnF5bJIbvLd98881dPvb73/9+t85NYZJA3LlBNeTSDQCxrXBglTRQamnzqK0yKG+DHdMvwEhAltSWZiltYoVjq7fvSTClURcULNd0P6/bPbUgrV757tf0q6ZjVdmUuC1OzXk+ZeQGFa5wdoY4YE/+7//+r0vHWZZFYZLMNn1ntNIOKzMdA+gSvzckHVGmphcK5GmiMoFzQimWUo8w+1ppWbYeHrFEWS4GuvfWQQGXHhz+uOZ+eJbsBJ1ite2CCm0uGa3+v3vDdJTkxXTB7TZs2BC1c9MymCA+vXO6fIeUm44BdJvniHLZx1aqcoq5O9dIDpVTwrKPrZRnttnXygx/i5ZPfISipA/luFO1fOIjSvM5swCmCd7DyvXp7dNNxwCiihaTROGLyOuOmE4BdNuu39uMfnWqPiQgScp6PSCLOgV9IOKxVHtgkyQpI73ZaNctSRqZU6ar+r8ovxUwmiMR+S2v/m/4X/WbrUcn5CKMXndE8tK6bAxjTPZq8+bNWrp0qTZu3KjW1o43B373u99161wUJvHO5VbludPlS2swnQTolVRfm1KDO1e63jHSLysi+SpdStkRR6/OiBlNBZZacyKy3bbyg3Wm40iSJuVt0fzgSk30UZREy0RfQKfkv6VnPZO0qnyg6Th9zpvRosrzZir4l7ekCHdvYN5LL72k+fPnq6SkRGvXrtX48eP1xRdfyLZtTZkypdvnoytXHHOlpsqaMkbWwnLlZCT2fO5ILvmjypU3plxNg9vUErTUkhO7fW0RW1pyLLUELTUNblPemHLlj4yNLq4D0mt0Su5bmpfabDpKwpuf1qiFwXc0IL3GdJQ+F8xslBZWyJoyRq7UxB3sj/ixaNEi/fCHP9SHH36oQCCgJUuWaNOmTTr00EN18sknd/t8FCZxzB5Vouprm1mvBAmrsKhK6YeUKeXgckU8lmyXWKgRu7N2Tvsb8VpKPWSH0g8p2zn7W4zwuCK6eciTmp3CHW6nzElt001DnpTHlXhdnN2uiKqvbZaGDzIdJbnYBrY4sGbNGp1zzjmSJI/Ho6amJqWnp+vaa6/Vr3/9626fj8IEQMxzuyLyztshz3Hlqh1mOg1iTc0IW57jyuWduyPmbtT43GG9OuFxFXnSTUdJOoM86XplwmPyuSkIgWhJS0tTS0uLJGnAgAH6/PPP279XXt79FmsKkzhVd+oMfXqF33QMwDEuy5bLspUyslr1sxtUM6vJdCQYVjurSfWzG5Q6vKb99yOWDMqs0l9G3y+3xVutKV7Lrb+Mvl9FGdWmo/S5tVelquGkA0zHSB60mOzRjBkz9Prrr0uS5s2bpx/+8If61a9+pe985zuaMWNGt8/H4Pc4VHPmDJXNsFWQV2s6CuC4VF+bUn1tCkdcqpi0szhP3eSWvzJOXsXRK825lpqKdt4Bz81slDtGu+pMyd+sBTnvqsRLS4lpJd50nd//n3rSPyWhBsQX5NVq66G5KvDPUNaDb5qOgyT1u9/9TvX19ZKkq6++WvX19Xr00Uc1fPjwLi/E+HUUJnGobLqtgqEVpmMARrldERWU7Pw7KIvkKuJ1SxExi1eCasq3JJfUXBhu//8eq4Znl2t+zkrNSW0zHQVfOTq1Ra32KtW1BbS+Jtd0nD5TMKxCO8J5ynrQdBIkq6FDh7b/OzU1VbfffnuvzkdhEmfc2VmS23QKILYUDKuQhkkNLT5FXspu32+FbdZDiVO2W7Ld/5npwLN/lVJ9bco0mKkrUrxt+tmA5zTGx4xJsWZ+WqOGDXxOlzaepqY2r+k4fcZ223JnZylcnXizkMUUVn53BIVJPLEsbb53gAp8sX23EDAlzd8qzS1r/7psfa5yPqB/fzyqmhBW4ZBK0zG6xe2K6MWxT8hrUZTEqnG+FL049gkd8sEpshPkg1/BsAptumegBpxYK9m0GCP6gsGgPv30U+Xl5SknJ0eWtfe/pcrK7r2OU5jECc/gYn26OFc5XhZSBLoqe1C1WgZ4ZNuSf1mmrNgcjoCv2C6pdc7OsXNBb3x1gypIq9fdQ5fIa6WZjoJ98FpuPTP+Pp37+Ukqb0yM/18pvjatf3CSRv5oh0Kbt5iOk5Ase+fm5PVi1f/93/8pIyNDknTTTTf16bkpTOKFy6Xc7HrTKYC44vOE5fPs7Mu1fVpbe9O4q96t7DWJcbc03lWPtRVJ+6q/nWWrMNBiNlAPTMrborPzXleeOzE+5CaDPHeafjTo77p/x0FaXdHfdJxec1n2zs8IblqIEX271i0JhUKSpKOOOkr9+vXrk3NTmMQBz9Ah2nFIf7m0w3QUIG4VDqhu/3d1fYrqG/8zW5K/wpK3PoZvTyWQtgxLLcH//Kx9AxuUlRa/Uz+PC5ZqXs4qHRTgA2G8OSQgVQZXKWJb+qiybz5UmVZ+aJHy/ulSaMOXpqMgCXg8Hl100UVas2ZN352zz86EqKmeWijXKRQlQF/JTm+S9vvPh+Hyj/KVtqVjC4q7hYHzvWW7pbC/48+1sX9EeWO7v+hWLMoONOm/Cl/RdH/iDKRONgvS6tXP/aqubpyv6uYU03F6zTpth2rr+ymVwqTvOb22SJzcKzvggAO0cuVKDR48uE/OR2ESDzoZVASg9/LG7ZDGddxX82aBUkvj5J0hRjUVWsqaXtZhX/x/9NvJsmw9PnKJ0l0B01HQSzMCbj068nEdvfrMhBgQnwBPAXHk4osv1g9/+ENt3rxZU6dOVVpaxy6tEydO7Nb5KExi3MZfHKjAlEqxxjvgrNT9y3f7kNL6eq78VRQre9Kca8k/s+OMgamxPHqzF7L8zXpy1BNKpShJGFmuFL004WEdv3ah6lri+x234ewaVY45UMW/fMN0FCSBU089VZL0/e9/v32fZVmybVuWZSkc7l7Xgy53it28eXO3Thwtt99+u0pKShQIBDR16lT985//NB0par745UzZ4+rk94ZMRwGSjtcdaR88v2trmdSo6oObO2yhlOS7PRlKtXb7ObRNbNjt5+V1J940aGOC2/XroUuU6vKZjoI+lury6Yahj2tkTtm+D45hfm9I4Qn1+uL/zTQdBQ577bXXdNxxx2nAgAGyLEtPPfVUp8cvX75clmXttn3yySddvuaGDRt229avX9/+3+7qcovJ+PHjdcstt+iss87q9kX6yqOPPqrLL79ct99+uw466CD94Q9/0DHHHKOPP/5YgwYNMpYrakY07OwLDyAm7GlmvLJhPrla9nyPx1drKWV7fLYaNPaz1Jax5+yRQFgFuXUOJzJvUt4WzctZpcn++L6jjr2b7PfrpLx39Ixrv7ierSsno1GVI0ynSCyWHJ4uuAePaWho0KRJk3Teeedp4cKFXX7c2rVrlZn5n+Vr8/Pzu/zYvhpbskuXC5PrrrtOl1xyiZ566indddddys3N7dMgXfG73/1O3/3ud3X++edL2jl38gsvvKA77rhDixcvdjxP1Ljcco8ZLpcrPj/QAMmkYPjeFzzdvi1b7pZ931l3N+0cbO+EsN9SuAsDPZqHtKqwX3XU88SLfml1Oj3335qVknitQOhoflqj0lxvakfzESptyDAdp8fcblvucaMUXrNOijCTRzI45phjdMwxx3T7cQUFBcrOzu7xde+//37deeed2rBhg1asWKHBgwfrpptuUklJiY4//vhunavLXbkuvvhirVq1SlVVVRo3bpyWLl3a7eC90draqnfffVdz5szpsH/OnDl6440996NsaWlRbW1thy0euIPZqrwhHNdTaAKQCvtXK21W2T63hiJbtkuObPWD7C5loij5D7crojtKllCUJJHZKWHdUbJEblf8/j/PSmtS5Q1huXOyTEdBL3zzc2xLS9+v9bTffvupf//+mj17tl555ZVuPfaOO+7QlVdeqblz56q6urp9TEl2dnaPFl/s1uD3kpISvfzyy7r11lu1cOFCjRkzRh5Px1O899573Q7RFeXl5QqHwyosLOywv7CwUKWlpXt8zOLFi3XNNddEJQ8A9JWc8eWyxzkzViWYoAPSoyXgCemlcU/IbaXv+2AklP6edC2f8Jhmf3iSWsNu03Fgmm05O+XZV9cqLi7usPsXv/iFrr766j65RP/+/XXXXXdp6tSpamlp0f3336/Zs2dr+fLlOuSQQ7p0jltuuUV//OMftWDBAl1//fXt+6dNm6arrrqq25m6PSvXl19+qSVLligYDOr444/frTCJNusbU+fuGvW/J4sWLdKVV17Z/nVtbe1u/4NjjX3gJK35jleFqjYdBYBDXJbtbOdldMmQrEr9qmgpRUkS81pu3TP6fi3adLw21uaYjtMja349VCPvGii9tdp0FPTApk2bOoz/8PfhGLdRo0Zp1KhR7V/PnDlTmzZt0o033tjlwmTDhg3ab7/9dtvv9/vV0NDQ7Uzdqir++Mc/6oc//KGOOOIIffjhh90aHNNbeXl5crvdu7WOlJWV7daKsovf7+/T/4FOCKV6OqxQDQBw3pT8zZqfs1LDvBQlyW6YN13n9HtdS337aVX5QNNxuq1wQLXCaZmizaeXDC2wmJmZ2aEwibYZM2bogQce6PLxJSUlev/993cbBP/3v/9dY8eO7fb1u1yYHH300Xrrrbd066236uyzz+72hXrL5/Np6tSpWrZsmU444YT2/cuWLev2wJpY5R4xVBUlPhaXAQCDhmRVan7OSh2d2vd9uRGf5qU2S1qpmrYUfVETNB2n26qH+lWwqUThdRtMR0GMW7lypfr37/qMdP/93/+tSy65RM3NzbJtW2+99ZYefvhhLV68WH/605+6ff0ufwYOh8P64IMPVFRU1O2L9JUrr7xSZ511lqZNm6aZM2fqrrvu0saNG3XhhRcay9RXXGlp+uKUfso8KL7nTweAeBbwhHRt0TMa6U3b98FIKvNSmzWi6Bl9r+EMNYfi6xaiZ+EOfVnQX4NuLlOkB91rEB/q6+u1bt269q83bNig999/X8FgUIMGDdKiRYu0ZcsW3XfffZJ2zm47ZMgQjRs3Tq2trXrggQe0ZMkSLVmypMvXPO+88xQKhfSjH/1IjY2N+va3v62BAwfq97//vU477bRuP4cu/2UtW7as2yfva6eeeqoqKip07bXXatu2bRo/fryee+65Pp9D2YS1t41WQQFFCQCY4nZFtGzcEnktihLs2UhvmpaNW6JZq09WONLliU1jQsbBZfpkxBiN/M47pqPEJ0NdubrjnXfe0WGHHdb+9a5x1uecc47uvfdebdu2TRs3bmz/fmtrq6666ipt2bJFKSkpGjdunJ599lnNnTu3W9e94IILdMEFF6i8vFyRSEQFBQXdD/8Vy7btpBlxWVtbq6ysLM3S8fJYXtNxOvjs3qkqKKgxHQMAklK/tDrdNfQJFbgpSrBvZeEGnb9+ocoa4msM0vbS7JgsTEJ2m5bradXU1Dg6nqIrdn12HHzdr+QKBBy7bqS5WV/+9Gcx+TP5usMPP1xPPPHEbuug1NbWasGCBXr55Ze7db74KvcTkOX1adP/HKjUzGbTUQAgKU3K26LLi5ZRlKDLCtxpurLoRU3I3WY6SrekZTdp088OlOXwjKqJYNfkiU5u8WD58uVqbW3dbX9zc7P++c9/dvt8/GYaZnk9Sp+5Y+d0oQAAR40Jbte8nFUsnohum5USUXVwlUK2S2sq9zw7aKxJD7QoPLNclscjOxQyHQdx7IMPPmj/98cff9xh1txwOKznn39eAwd2fxY7ChODLK9Prn4974cHAOi5LH+zLi18SVP9PtNREKcWpNWr2POSftpwompanOvm0xuWZcvVv1D25m2y23a/0429iIMxJk6aPHmyLMuSZVk6/PDDd/t+SkqKbrnllm6fl8LEpEkjVXFts1yx/tsHAAnGsmw9OeoJpbooStA7U/0+LRn1uI744EzTUbrEZdmquM2r7J+NkFZ+ZDoO4tSGDRtk27aGDh2qt956q8Pahj6fTwUFBXK7u796DoUJACCpZAea9PjIJUp1xccdbsS+dFdA/5j4gBauPSluWk6A3tg1I24k0rfdYClMDGlaMF2bj7RUIAa9A4BTxgS369LCl5ROUYI+lu4K6LqhT+jW7bPjYszJp99NV/EL0xV45i3TUeIDXbk69fHHH2vjxo27DYSfP39+t85DYWJIfT+3Ckp2mI4BAEljUt4WzctZxZgSRM1Uv0/H566Ux5qk1RVdXz3bhIKhFWroly9KdPTG+vXrdcIJJ2j16tWyLEu7ViGxLEvSzoHw3cF0wQZ4hgxSW6ZlOgYAJI2CtHqdkbdC89MaTUdBglvw1e9aQVq96Sj71JJlyTNkkOkYcYHpgvfsBz/4gUpKSrR9+3alpqbqo48+0muvvaZp06Zp+fLl3T4fhYkBa/67v9Jmsco7ADjB7Yro7qFLdAi3huGQWSkR/WnoErldsT0NddrhZVrzw9hu2UFsW7Fiha699lrl5+fL5XLJ5XLpW9/6lhYvXqzvf//73T4fhQkAIGGleNu0fMJjymPxRDiswJ2m5RMeU8DDeiFIXOFwWOnp6ZKkvLw8bd26VdLOwfFr167t9vkoTJxkWfrslgOUPrDWdBIASHhDsyr0h5EPyWt1f8pKoC94LbfuGvWghmRVmo6yV+nFtfrs5gMkiy7mnbIt57c4MH78+PbFFg844AD95je/0euvv65rr71WQ4cO7fb5KEycZLmUNahGqb4200kAIKFNyd+sMwpXaKSXlhKYNdKbprMK39CkvC2mo+xRqq9NGYO4YYqe+Z//+Z/2KYN/+ctf6ssvv9TBBx+s5557Tr///e+7fT5m5XKIKxBQeMooWRbTAwNANA3JqtSCnHc1J5WbQIgN81Kb5dZ7qmpN1cbaHNNxduOybNkzJsq9cq0izXxO2SOmC96jo446qv3fQ4cO1ccff6zKykrl5OS0z8zVHRQmDrGKB6j2fxrEJJUAED0+d1iLi5aqxJtuOgrQwdGpLRpR/LTO++QstYZjq3uh3xtS7c9Dyr2kUJENX5qOgzjwne98p0vH3X333d06L4UJACAhuF0RvTJ+idwWRQli0zBvul4a/7hmrT5Z4Qi96eOJ01P4xvp0wffee68GDx6s/fbbr33tkr5AYeKApuOna+uprcpT7M9pDgDxaEB6jW4b8iRFCWKe13Lr8bH36aINC1XakGE6TgdrfxlU0UMF8j/7tukoiHEXXnihHnnkEa1fv17f+c53dOaZZyoYDPb6vJTrDgiluJSXTVECANEwKW+Lvj/wJfX3UJQgPvT3pOuyon9oQu4201E6yMupU1sqHw2xb7fffru2bdumH//4x3rmmWdUXFysU045RS+88EKvWlD47Ysya/8JqinhxwwA0TAmuF3zgys1KyW2F7IDvml2SljHBVdqZE5sLbhcM9Qta9p40zFij21gi3F+v1+nn366li1bpo8//ljjxo3TxRdfrMGDB6u+vmc35PnEHGXrF6Yr4+DYetEBgESQ4W/RFf2WaV4qswghPs1Pa9SV/ZYpw99iOkq79EPLtP7E2OpihthnWZYsy5Jt2+3TB/cEhQkAIO5Ylq2nRy3RRF/AdBSgVyb7/Xp61BLTMbAv9n8GwDuxxUOLSUtLix5++GEdeeSRGjVqlFavXq1bb71VGzdubF8NvrsoTKLos3unKn1s7K72CgDxKDvQpOcnPKBUFxOwIzGkunx6YeL9yg40mY4iSUofX6lP75lqOgZi2MUXX6z+/fvr17/+tY499lht3rxZjz32mObOnSuXq+flBbNyRZE/rVU+T9h0DABIGOOCpfqvwleU5UoxHQXoU1muFF1b8pTu2H641lQWGs3i84TlY4FSdOLOO+/UoEGDVFJSoldffVWvvvrqHo974oknunVeChMAQFyYkLtNxwVXarrfazoKEBXT/V5tzV0pjzVJqyv6m46Dr2Pl9w7OPvvsHq3svi8UJtHgcss9bLBcLmaJAYC+UJBWr3Pz/6mDAvRARmJbkFavoPt1/abpGJU3phnL4XZH5B4xVOHPv5Qi9P5AR/fee29UzssrfBS483NV+XuXMlJiZ5YNAIhXlmXrL0OfoChB0jgkIN077HFZBpf/zkxtVuXvXXIHs41liClMF+wIXuUBADErxdum1yb+VTnuVNNRAEfludP02sS/KsXLWA8kDwqTPmYfOElrrhliOgYAxL3h2eW6fcTD8lpu01EAI7yWW7ePeFhDsyqMZVjzy2GyZ04ydv1Y4eRUwe1TBichCpM+1pbpU+EgpggGgN6Ykr9Zpxe8qTE+WkqQ3Mb4UnVG4QpNytti5PqFgyoVymDCCTiDwqQPeUoGq66I+QQAoDcGZVZpQc67rOgOfGVearNOCL6nQZlVRq5fV+SVp2SwkWsjuVCY9KEN3x4oz4k7TMcAgLjlc4d146CnNYc1FIAOjk5t0a+Ln5bP7fwMWe6TduiL0wY6fl0kHwoTAEBM8LgiemX8Eg3ypJuOAsSkEm+6Xhr/uDwsR4AERWECADCuKKNaj4y9T26LtyWgM17LrUfG3qcB6TWmoyQXpgt2BO8AfaTskgPVNJx1SwCgu6bkb9ZFA15RES0lQJcUedJ1ycCXHR0Q3ziiVTsumunY9ZCcKEz6SO2MJhUWcvcCALpjZE6Z5uW8r9kprCwNdMfslLDm5azS8OxyR65X2K9a1TO4AYvoojDpA+68XNH7AAC6J83Xqh/3f4HZt4Aemp/WqB8NeF5pvlZHrme5bLnzch25VqxhHRNn8HG6l1xpaSr/S1B5OXWmowBA3LAsW8+NWaJxvhTTUYC4NtEX0HNjlshy4JNsfm6dyv8SlCuV9YUQHRQmAABH5aU26Lnx98tvsWgb0Bf8llfPjb9fwZRG01ESGwPfo47CBADgmAm52/Q/g/6mHDd3XIG+lONO1f8OfkbjgqWmowA9RmHSC55+hao+foJcydoREAC6YULuNh0XXKkZAbfpKEBCmhFw67jc96NenFQvmCh3YUFUrxFzmC7YERQmvRAaUij7TGdmwwCAeBZMadR381/T/DS6mgDRtCCtXt8peC1q3bpcli37zHJFBhVG5fxIbhQmAICosixbDw5/nJYSwCEHBVx6cPjjjgyIB/oShQkAIGrSfK1aPvERxpQADstxp2r5xEccm0o40TFdsDMoTHqo7tQZ+vS7ftMxACBmjcwp083DH2X2LcAQv+XVzcMfjcoijGu/F1D9yQf0+XmR3ChMeqgp36XCgVWmYwBATJqSv1mn5r/FOiWAYeN8KTol/y1NytvSp+ctHFilprwk+hjJ4HdHJNFvVN9xjxqulmzTKQAgNhVlVGth8G1WdAdixPy0Ri0MvqOijOo+PW9LtiX3yGF9ek4kNwqTHlhzRVCZB5aZjgEAMcfjiuimwU9pdkrYdBQAXzMntU2/G/yUPK5In50z4+Ayrbk8t8/OB1CYAAD6hM8d1qsTHleRJ910FAB7MMiTrlcnPN6nxUmyYPC7MyhMAAC9NiizSg+MuV9ui7cVIJa5LZceGntfn3frAvoC7yDdYVkqveJA+XLoNw0Au0zK26Lz+72mQbSUAHFhkCdd5/f/Z58MiPcGm1V6+YGSZfVBshjG4HdHUJh0g+V2y31YhXIyWLkYACRpeHa55gdXak5qm+koALrh6NQWzctZ1euphIOZjXIdVinRWoo+wG8RAKBHUrxt+tmA55h9C4hT89MatWjA35Xi5cbCPtFi4ggKEwBAt1mWrRfHPqExPlZ0B+LZOF+Knh/7uKxkHW2NmEJh0kXu4SVaf/84+TxMgQkguRWk1eu58ffLa7lNRwHQB/yWV8+Mv0/BlJ51Vfd7Q9rw4Hh5hg7p22BIOhQmXeV2K5jVYDoFABg1IXebflz8nHLctJQAiSTPnaafDH5O44KlPXp8MKtBtidxb1YwXbAzPKYDAADiw7hgqY4LrtRBAe5pAYnokIBUmfu+pMn6qLKf6ThIQry7dIErI0NtBRmmYwCAMdmBJv1X4Suan8ashEAiW5BWrwsKXlV2oKnbj20ryJArI0E/LzH43REUJl1Qdfw41S2qMx0DAIywLFuPjnxc0/1e01EAOGBGwK1HR3Z/QHzdT+tVfey4KKVCMqAwAQDsVYa/RS9NeFhZrhTTUQA4KMuVopcmPKw0X6vpKEgiFCYAgD0amVOmG4Y+rlSXz3QUAAakunz67bDHNDKnzHQU8+jK5QgKEwDAbiblbdFJee9ost9vOgoAgyb7/Top7x1NyttiOgqSAIXJPnhKBqsplx8TgOQxIL1Gp+f+m4HuACTtXCH+lNy3NCC9Zp/HNuW55CkZ7EAqZzFdsDP4xL0Pay8eoJSjaMIEkBzcrohuG/KkZqVETEcBEENmp4R185An5XZ1/toQOKZMn/7XAIdSIdFQmAAAJEk+d1ivTXhc/T3ppqMAiEFFnnQtn/CYfO6w6ShIUBQmAAANyarUPaPvl9vibQHA3nktt+4Zfb8GZVaZjuIsBr87gnegTpRdfKDs/s2mYwBAVE3J36xzC1/XMC8tJQD2bZg3Xd/p96+9DoiPDGzWjotmOpwKicBjOkAsa51do/yUFtMxACBqhmZVaH7OSh2dymsdgK47OrVFYa1UXVtA62tyO3wvP7dONYeHpDsMhYsCpwekM/gdAJBUUrxturrobxQlAHpkXmqzfj7wWaV420xHQYKgMAGAJOR2RfTi2Cc00ptmOgqAODbGl6oXxz4hK9Fv8TPGxBEUJgCQZArS6vXkuPvltdymowBIAF7LrafH36eCtHrTURDnKEz2wJ2To42/OFB+b8h0FADoU5Pytuiq4udV4KalBEDfKXCn6ari5zUhd5skKcXfqo2/OFDu7CzDyRBPGPy+B1bAr6wDWFQRQGIZFyzVvJxVOiRgOgmARHRIQKoMrlLIdmlNZaF8B5TJCgQk7XvF+JjndPcqunIBABJVdqBJFxe+rPlpjaajAEhgC9LqdVHhy8rys9wCuo/CBAASnGXZenzkEk31+0xHAZAEpvu9+uuox0zH6FOWgS0ZUZgAQALL8jdr2YQHle6i/xYA52S5UvSPiQ9IqSmmoyCOUJh8g33gJK35yRDTMQCg18YEt+u6oU9QlAAwIt0VUNEj29W0YLrpKIgTFCbf0BL0q2BEuekYANArk/K26ITcd+m+BcCoPxStUNU59ao9fYbpKL3DOiaOoDABgATTL61OZ+StYKA7gJiw+oCHlH7+Fln7TzAdBTGOwgQAEojbFdFdQ59gSmAAMWXZmGd04UNPyvL7TUfpEct2fktGFCYAkCACnpCWT3iMxRMBxKQFafV6eN0rcucGTUdBjKIw+Zqyiw/U5tPaTMcAgG4bmlWhu0Y9KK/lNh0FAPYqx52qw179UqHZU01H6R7GmDiCwuRrmvOk/GCd6RgA0C1T8jfr7MI3NNJLSwmA2Pffwc9Ve0Wdas6I8wHx6HMUJgAQx4ZkVWp+zkodndpiOgoAdNnbU/6q8OmVajsizlpOEFUUJgAQpwKekH5VtJSiBEBcenvKX3XU/70mdzDHdJSuoRtX1FGYAEAccrsiWjZuiYZ5001HAYAe+3HuZ3r8zddMx0CM8JgOAADongHpNbptyJPyWhQlAOAEp6fwTdbpgilMvlJ6+YFqGd5sOgYAdGpS3hadnvtv9fdQlAAAEguFyVca9m9SQQ4zcgGIXWOC2zUvZ5VmpURMRwEAoM9RmABAHMjwt+gHhf/Q5DhdNRkA4prTg9LpygUAiEWWZevpUUuU6qIoAQAkLgoTAIhh2YEmPT5yiVJdAdNRACBpMfjdGRQmABCjxgVLdXHhy0qnKAEAJIGkX8fE8vpU++0Z8vnbTEcBgHaT8rbo+Nz3NNXvMx0FAODk4oo9HM/y2muv6bjjjtOAAQNkWZaeeuqpfT7m1Vdf1dSpUxUIBDR06FDdeeed3b9wH0r6wsSVEpB9ZrkyU5kqGEBsKEir1xl5KzQ/rdF0FABAnGhoaNCkSZN06623dun4DRs2aO7cuTr44IO1cuVK/fSnP9X3v/99LVmyJMpJ946uXAAQQyzL1t1DlyjPnWY6CgAgjhxzzDE65phjunz8nXfeqUGDBummm26SJI0ZM0bvvPOObrzxRi1cuDBKKTtHYQIAMSLF26YXxz4hr0VRAgCxxNTg99ra2g77/X6//H00bfyKFSs0Z86cDvuOOuoo/fnPf1ZbW5u8Xm+fXKc7kr4rFwDEguHZ5bp9xMPyWm7TUQAAMaK4uFhZWVnt2+LFi/vs3KWlpSosLOywr7CwUKFQSOXl5X12ne6gxQQADJuSv1nzct7XGF+q6SgAgD0xtMDipk2blJmZ2b67r1pLdrEsq+NlbXuP+51CYQIABg3KrNKCnHc1J5WZAQEAHWVmZnYoTPpSv379VFpa2mFfWVmZPB6PcnNzo3LNfUnuwsTllpWaYjoFgCTlc4f16+KnVeJNNx0FAJBkZs6cqWeeeabDvhdffFHTpk0zMr5ESvIxJvbMCdrx5+hUoQDQGY8rolfGL6EoAYB4EAfrmNTX1+v999/X+++/L2nndMDvv/++Nm7cKElatGiRzj777PbjL7zwQn355Ze68sortWbNGt19993685//rKuuuqr7F+8jSd1iYluSy8kpFgBA0oD0Gt085Em5LYoSAEDfeOedd3TYYYe1f33llVdKks455xzde++92rZtW3uRIkklJSV67rnndMUVV+i2227TgAEDdPPNNxubKlhK8sIEAJw2KW+LTsl9S0UeihIAiBempgvujlmzZrUPXt+Te++9d7d9hx56qN57773uXyxKkrorFwA4aWROmeblrNLslLDpKAAAxBxaTADAARn+Fl3V/0VN9AVMRwEAdJeh6YKTDYUJAESZZdn62+gn5LcoSgAA2Bu6cgFAFAVTGvX8hAfkt8xMvQgAQLygxQQAomRcsFQXFLyqLBfrJQFAPLNsW1YnA8ujcb1klLQtJtbUcSrbP9V0DAAJakLuNh2f+55mBNymowAAEBeStsVk27eylHJkmekYABJQXmqDzs3/pw4KJO29HwBILAx+d0TSFiYAEA2WZev+YUuU46ZFFgCA7qAwAYA+kuZr1XNjlshvUZQAANBdFCYA0AeGZ5dr0YC/y28x0B0AEk08rPyeCOKiA/QXX3yh7373uyopKVFKSoqGDRumX/ziF2ptbTUdDQA0JX+zTi94U+N8FCUAAPRUXLSYfPLJJ4pEIvrDH/6g4cOH68MPP9QFF1yghoYG3XjjjabjAUhiRRnVWhh8W7NTwqajAACihcHvjoiLwuToo4/W0Ucf3f710KFDtXbtWt1xxx0UJgCM8bgi+t3gpzTIk246CgAAcS8uCpM9qampUTAY7PSYlpYWtbS0tH9dW1sb7VgAkoTHFdGrEx6X26IoAYBExxgTZ8TFGJNv+vzzz3XLLbfowgsv7PS4xYsXKysrq30rLi52KCGARFaUUa2Hxt4ntxWXL6EAAMQko++qV199tSzL6nR75513Ojxm69atOvroo3XyySfr/PPP7/T8ixYtUk1NTfu2adOmaD4dAElgSv5mfa//q3TfAgCgjxntynXppZfqtNNO6/SYIUOGtP9769atOuywwzRz5kzddddd+zy/3++X3+/f/Rv7j1NzgS3mzwHQHcOzyzUv533NSW0zHQUA4CQGvzvCaGGSl5envLy8Lh27ZcsWHXbYYZo6daruueceuVw9b+xZd5Zf/Ufs6PHjASSfNF+rFg34O1MCAwAQJXEx+H3r1q2aNWuWBg0apBtvvFE7dvynqOjXr5/BZACSgWXZX63oTlECAMmIwe/OiIvC5MUXX9S6deu0bt06FRUVdfiebSfp/zkAjshLbdD9w5bIb6WajgIAQEKLiyllzj33XNm2vccNAKJlQu42LRr0rHLcFCUAAERbXLSYAIDTJuRu03HBlTooEBf3bwAA0cTgd0dQmADANwRTGnVBwXJN93tNRwEAIGlQmADA11iWrYdHLFGWi4HuAID/SNYB6U6iMAGAr2T4W/S30U8w+xYAAAZQmACApJE5Zbqq/4vyWwHTUQAAsca2d25OXi8JUZgASHqT8rZofnClJvooSgAAMIXCBEBSG5Beo1Ny39LslLDpKAAAJDUKEwBJy+OK6OYhT6rIk246CgAghrHyuzMoTAAkJZ87rFfGL5HboigBACAWUJgASDqDMqv06+KnKUoAAF3DAouOoDABkFSm5G/Wgpx3VeKlKAEAIJa4TAcAAKcMzy7X/JyVmpPaZjoKAAD4BlpMACSFFG+bfjbgOY3xpZqOAgCIM1Zk5+bk9ZIRhQmAhOd2RfTi2CfktShKAACIVRQmABJaQVq97h66RF4rzXQUAEC8YvC7IyhMACSsSXlbdHbe68pzU5QAABDrGPwOICGNC5ZqXs4qHRTgZQ4AgHhAiwmAhJMdaNJ/Fb6i6X6v6SgAgATAyu/OoDABkFAsy9bjI5co3RUwHQUAAHQDhQmAhJHlb9aTo55QKkUJAKAv2fbOzcnrJSEKEwAJYUxwu35Q+A+luvymowAAgB6gMAEQ9yblbdG8nFWa7KcoAQD0PcaYOIPCBEBc65dWp9Nz/61ZKUm6TC4AAAmCwgRAXLujZIn6e9JNxwAAAL1EYQIAAAB0hpXfHcHKYwDi2kUbFmp5Ey9lAADEO97NAcS10oYMPVxxgJY2pJqOAgBIULsGvzu5JSO6cgGIe6vKB6o14tFAz0ua6veZjgMAAHqAFhMACWFNZaF+uv5E1UeaTUcBAAA9QGECIGHUtAR0xAdnUpwAAPrWrpXfndySEIUJgISzcO1JequlzXQMAADQDRQmABJOTUtAd2w/nAHxAIA+weB3ZzD4HUBCWlNZKI+1n7Ldr+uQgOk0AABgX2gxAZCwVlf0142bjlZZuMF0FABAPLMNbEmIwgRAQitrSNcJH52lNjtsOgoAAOgEhQmAhBeOuHTkRwu1prXRdBQAALAXFCYAkkJzyKP/t2Wenm1kwAkAoHsY/O4MChMASWN9Ta6WVu6n5xv9pqMAAIBvYFYuAEllVflAVbWmakTx0xrmTTcdBwAQDyL2zs3J6yUhWkwAJJ2NtTk67xMGxAMAEEsoTAAkpdawW7NWn6zNoXrTUQAAgChMACSxcMSl739xgl5qcpuOAgCIZaxj4ggKEwBJbWt9lv5aMV1LG1JNRwEAIKkx+B1A0ltVPlBNYa8GeZZpsp8ZuwAAHVlydgpfy7lLxRRaTABA0qdVBfrv9SepMdJqOgoAAEmJwgQAvlLX4tfs1aerJtJkOgoAIJbYtvNbEqIwAYCvsW1Lp356kt5sZiphAACcRGECAN9Q3ZyiP5YdqqcaWIARAACnMPgdAPbgo8p+clmTFHS/rkMCptMAAEyybIcHvydnTy5aTABgb1ZX9NdvNh6j8nCD6SgAACQ8ChMA6ER5Y5qO+/BstdhtpqMAAExhgUVHJGVhMup/PlPDKwWmYwCIE7Zt6eiPT9JHrczWBQBAtCRlYRKurZOLpQoAdENTm1eLtx6jZxsZcAIAQDQw+B0AumhddZ6WevaTV+9oTipduwAgWVi2LcvBtUWcvFYsoTABgG5YVT5QFS1pGjHoKZV4mU4YAIC+kpRduQCgNzbXZeusNWcrbEdMRwEAOCFiYEtCFCYA0AOhiEuHrj5JG0P1pqMAAJAQKEwAoIdCEZeu/HKBXmz0mo4CAIiiXWNMnNySEYUJAPTC5rpsLamcpqUNqaajAAAQ1xj8DgC9tKp8oBpCfg3xPq+JPqYTBgCgJ2gxAYA+sK46T1esO4UV4gEgEbHyuyMoTACgjzS0+jTrg9NUFW40HQUAgLiTtIXJwAc+ke+uoOkYABKMbVs6Y91Jer05Sed6BIBEZNvOb0koaQuTcEWl/OWtpmMASECVTam6u+wQPdXAAowAAHQVg98BIAo+quwnabLy3a/poEDS3gMCAKDLeLcEgCj5qLKffvXlsYw5AYA4Z9nOb8mIwgQAoqiyKVVzPzyL2boAANgHChMAiDLbtjR3zUJ90NpsOgoAoCcY/O4IChMAcEBDq0+/2Xo0K8QDALAXDH4HAIesq87Ts55JCljvaE4qXbsAIF5YkZ2bk9dLRkndYuJuDqlsR6bpGACSyKrygbpz6yxtDtWbjgIAQExJ6sLEfudDjb5snekYAJLM1vosnfbx2QrbSXpLDAAQFbfffrtKSkoUCAQ0depU/fOf/9zrscuXL5dlWbttn3zyiYOJO0rqwgQATAlFXDrsw4Xa0EbLCQDEvDgY/P7oo4/q8ssv189+9jOtXLlSBx98sI455hht3Lix08etXbtW27Zta99GjBjR059Sr1GYAIAhrWG3/nvjAj3f6DcdBQAQ5373u9/pu9/9rs4//3yNGTNGN910k4qLi3XHHXd0+riCggL169evfXO73Q4l3h2FCQAYtLkuW09WTmG2LgCIZbaBTVJtbW2HraWlZY/xWltb9e6772rOnDkd9s+ZM0dvvPFGp09tv/32U//+/TV79my98sorXf6RRAOFCQAYtqp8oB4pO0BrWlkhHgDwH8XFxcrKymrfFi9evMfjysvLFQ6HVVhY2GF/YWGhSktL9/iY/v3766677tKSJUv0xBNPaNSoUZo9e7Zee+21Pn8eXcV0wQAQA9bX5OrixtP14tgn5LXMNaMDAGLHpk2blJn5nxlk/f7Ou/5altXha9u2d9u3y6hRozRq1Kj2r2fOnKlNmzbpxhtv1CGHHNKL1D1HiwkAxIimNq8O+eAUlYcbTEcBAHyNZduOb5KUmZnZYdtbYZKXlye3271b60hZWdlurSidmTFjhj777LOe/6B6KekLk3BdnYLfD6uyJs10FACQbVs69/OT9Fqz6SQAgHjh8/k0depULVu2rMP+ZcuW6cADD+zyeVauXKn+/fv3dbwuoyuXbSu8boMikf1MJwEASVJ5Y5ru33GQKoOrtCCN6YQBwLgeTuHbq+t105VXXqmzzjpL06ZN08yZM3XXXXdp48aNuvDCCyVJixYt0pYtW3TfffdJkm666SYNGTJE48aNU2trqx544AEtWbJES5Ys6dOn0h0UJgAQg1ZX9FfEtjTA84qm+72m4wAAYtypp56qiooKXXvttdq2bZvGjx+v5557ToMHD5Ykbdu2rcOaJq2trbrqqqu0ZcsWpaSkaNy4cXr22Wc1d+5cU09Blm07Wf6ZVVtbq6ysLM3S8fJYHd/oP39wP+Xl1BlKBgB7lh1o0qMjH1eWK8V0FACIitq6iHJGrldNTU2Hgd6xYNdnx8OmLJLHHXDsuqFws155b3FM/kyiKenHmABALKtuTtHRq89UY6TVdBQAAKKKwgQAYpxtWzp+7UK9v5eFtQAASAQUJl8Z8idLZZ/lmY4BAHtU1+LX70qPZIV4ADDA1HTByYbC5CvuV96Tv4IfB4DY9WlVgZ6tmqSXmliAEQCQePgkDgBxZFX5QN2y+QhtCzGNMID4VxNp0hP1cTC429Z/pgx2ZDP9hM2gMAGAOFPakKGTPj5bbXbYdBQA6JXfVUzT/VMGm46BGEFhAgBxKBxxafaHJ+nzNlpOAMSnkr+fr7e+FTQdAzGEwgQA4lRr2K2fbZ6v5xv9pqMAQLeMuetijf59vSJ1cbKGnKPduBxeZT6GUJh8TeE7bap8P990DADosi9qgnqycoqebXRu4S8A6I2S587XkCcqFfngE9NREGM8pgPEEv9zb6u/a7paJptOAgBdt6p8oOraAhpR9DeN9KaZjgMAe1QTadIN5dM15spPFa6tNR2neyKSLIevl4RoMQGABLC+JlffW3sGA+IBxKQ2O6zH60r09mR3/BUlcAyFCQAkiOaQR7NWn6yycIPpKADQwZS3ztJjE4pMx0CMozABgAQSjrh0/vqFWt7EyzuA2DDqzxep+EfNskMh01F6jJXfncE71zekfbJDbU8xAB5A/CprSNeD5TO1tCHVdBQASW7YIxeq5IlahT9bbzoK4gCD378hvG6D+jU0qWJBuukoANBjqyv6K2S7NNDzkqb6fabjAEgyYTuiN1uk0TdvVeiLjabj9J7TU/jSYgIASCRrKgv10/Unqj7SbDoKgCQStiPaFm7UDz85RWpuMR0HcYTCBAASWE1LQEd8cCbFCQDHvN7i0kkfnms6Rt9igUVHUJgAQBJYuPYkvdvSajoGgAR3U9UQXbN+vukYiFMUJnsQqapW4LYcNbZ6TUcBgD5R0xLQrdtnMyAeQNT8umKEXi4frYZWnxpafArclqNIdY3pWIgjFCZ7EGlulv/ZtxUO8+MBkDjWVBbqmcr9mEoYQJ9b2pCql8tGqaxh5+RBoZBb/mffVqQ5QbqR0pXLEbw7AUASWV3RX7/bPIdFGAH0iTY7rI2hei1ed4xqWgKm4yDOUZgAQJIpa0jXCR+dpTY7bDoKgDj3aVurTvnwXNm2ZTpKdEUMbEmIwgQAklA44tKRHy3Up220nADomT/X9NNFa79tOgYSCIVJJ4pucGv7l0HTMQAgKppDHv3v5uP0bCPdLwB0z3Xlo/Tk9v3UGnbv9r2yDbkadIOBUIh7FCadefMDuet3/4MDgETxRU1QSyv30/ONftNRAMSJ+2rz9K+KYSpvTNvj9911Lumt1Q6nii7Lth3fkpHHdAAAgFmrygeqqjVVI4qf1jBvuuk4AGJUmx3WurYW3fXFIQpFuLeNvsdvFQBAG2tzdN4nDIgHsHebQ0067+Ozk7MoYbpgRyThbxYAYE9aw27NWn2ytoXqTUcBEGOW1GfqzDVnm46BBEdhsg+jbtui5ucLTMcAAEeEIy5dtGEhizACaHdd+Sj9cfPBCnehpaTluQKNvGOzA6kcFrGd35IQ7zz7EPpiowKVSTqZNICkVNqQoYcrDtDShlTTUQAYdkvVYL1ZVaLq5pQuHR+oiCj05aYop0KiirvCpKWlRZMnT5ZlWXr//fdNxwGAhLSqfKAeL5+m91taTEcBYEDYjujN5rCe2DpZZQ1MigFnxF1h8qMf/UgDBgxw9JqukNTY6nX0mgBg2qdVBfrv9SepMdJqOgoAB4XtiLaFG3X5J6eqqa3rn38aW71yhRK0CxKD3x0RV4XJ3//+d7344ou68cYbHb1uxiNvqmhRyNFrAkAsqGvxa/bq01UTaTIdBYBD/tns0UkfntvtxxX9qFXpj/277wMhacTNOibbt2/XBRdcoKeeekqpqV3r99zS0qKWr3VDqK2t7XmAJB2EBAC2benUT0/StSVPabqf1mMgkf2ucqieLR1vOkYMcroVIzk/d8ZFi4lt2zr33HN14YUXatq0aV1+3OLFi5WVldW+FRcXRzElACSu6uYU3bH9cD1FX3MgYf26YoSWV4xUQ6vPdBQkKaOFydVXXy3Lsjrd3nnnHd1yyy2qra3VokWLunX+RYsWqaampn3btKnns0RY9Y2qfrtAEdvq8TkAIJ6tqSzUs5WT9Fqz6SQA+lLYjuj5Rr/+UTa6RwPdwxGXat4qkFXXEIV0SCaWbZsbXVNeXq7y8vJOjxkyZIhOO+00PfPMM7Ks/xQF4XBYbrdbZ5xxhv7yl7906Xq1tbXKysrSLB0vj9X97giWx6OyJ4bJ52FlZADJKy+1QfcOe1x57jTTUQD00q6B7id/dI7sHt58bWnzqOCEz6RIzz4fhew2LdfTqqmpUWZmZo/OES27PjseUXKZPC6/Y9cNRVr0jw23xOTPJJqMjjHJy8tTXl7ePo+7+eab9ctf/rL9661bt+qoo47So48+qgMOOCCaEQEA31DemKbjPjxbr038q7yW23QcAL2wurVNF64513QMQFKcDH4fNGhQh6/T03c2Mw4bNkxFRUUmIgFAUrNtS3M+PlG3j3hYY3wsxAjEozurB+qRzfubjhEfIrYcHZCepJMuxcXg91hhh0LK/U2KynYkT5MaAOxNU5tX/2/LPD3bGDAdBUA3/bJ8tP5WNlHNod7do96+PUt5NwR63I0L+Lq4aDH5piFDhsjU0BjXv96XfeZ0I9cGgFizviZXS737ya33dHQqq8QD8eDBuly9UTFUlU190NrZ5JbrX+/2/jyxzo7s3Jy8XhKKy8IEABA7VpUPVFVrqkYVP60SL9MJA7GqzQ5rY6hJd2w4UaEInWYQe/it7ImImDYYAL5mY22OzvnkLIWT9C4fEA82h5p0xkfn9llRErEtWRE+D6HvUJj0wKgfvK/WF/JNxwCAmNIaduvQ1Sdpc6jedBQA3/BIXY7OXHN2n56z7bl8jbw8CbpxSTtXfXd6S0IUJj1gt7XK4qYgAOwmFHHp+1+coJeamEYYiBXXlY/SvVsOVLiPu29ZEVt2KNSn50RyY4wJAKBPba3P0l8rpqshZ5XmpzWajgMktTurB+qNyqGqbk4xHSW+MV2wI2gx6aHUsoi2b84xHQMAYtKq8oF6vHyaPmhtNh0FSEphO6J3W1r1yOb9Vd6Y1ufn374pR6k76D6CvkVh0kPpf31TI+9makwA2JtPqwp0xbpT1GK3mY4CJJWwHdG2cKMuWfPtXq9Tsjej/tSstMf/HZVzI3lRmAAAoqah1adZH5ymqjBdugCnvNTk18kfnWM6RmJh8LsjKEwAAFFl25bOWHeS3mxmZWgg2m6oHKYbvjxaNssaIA5RmPSCe0OpXPflmY4BADGvsilVfyw7VE81sAAjEC03VA7TPytGqK7FH7VrRGxLrvvy5PqiNGrXiEm2HG4xMf2EzaAw6YXw9jJlPbOaxRYBoAs+quynZysn6fVmBswCfSlsR/Rio1cvbh+rMgeK/6ylHyi8Y0fUr4PkQ2HSW7at6trUPp8bHAAS0eqK/lq8cR5jToA+smug+y8+mx/VlhJJCkdcqqpJkyJJeHOBMSaO4NN0L0UaG1Vy+ipVVvX9VHwAkIjKG9M098OzmK0L6APvt4Z00ofnOjKmpKIiXUO//b4izUwDjuigMAEAOM62Lc1ds1AftTaZjgLErduqi/XDz04xHQPoMxQmAAAjGlp9Wrz1GC1tSDUdBYg715WP0t/LxkdtnRJ8QyTi/JaEKEz6SNYbAW0vzTYdAwDiyrrqPD1bNUkvNnpNRwHixl/rs/Ra+fCorOi+N9u3ZSt7RXTHsACU2X0k/44Vag4eKPUznQQA4suq8oGqaEnT6MFPaZCH6YSBvWmzw9oYatLv15/o+KQ7qet8yr/zDUevGVOcHpDO4Hf0lhURUwcDQA9srsvWtz8+W2E7ObsvAF2xIdSsMz461/GiJGJbsvjThAMoTPpQ8Q1vKeWOHNMxACAuhSIuHbr6JG0M1ZuOAsScB+ty9Z01Zxm5dupt2Sr67VtGro3kQmHSh+xQSK5Qcja9AUBfCEVcuvLLBYw5Ab7muvJRenDrAQoZWjPNFbJlh0JGrh0zWMfEERQmAICYsrkuW0sqp+nZxoDpKIBxd9UM0BuVQ1XZxOx1SHwMfu9j3tpWffFlUIWDK01HAYC4tap8oBpCfg0Z8HeN86WYjgM4rs0O66PWkB7aNN3olMDbvwxqZC0LKipiS3KwFSNCiwn6gPXGKo25+gvTMQAg7q2rztOln53GCvFIOmE7ou3hJl245gzj65SM+fnn0psfGM2A5EFhAgCIWU1tXs364DSVhxtMRwEcs6wpRSd/dI7pGPga2444viUjCpMoCO+oUO6lIdU1sRARAPSWbVs69/OT9Hpzcr5RI7ncUDlM//flkbINLz9Q05Ci3EtDCldWG82B5EJhEg2RsELrv1DE0OwZAJBoyhvTdO+Og/VUAwswInH9rnKo/lkxQjUt5id+iEQshdZ/IUXCpqMgiTD4PZpWZ6hyrKVgZqPpJAAQ91ZX9FfEttTP/apmBNym4wB9JmxH9M9mj54tHa+GVp/pOKqsTZXnI24CdGDbzg5IZ7pg9LVB174hfZFmOgYAJIyPKvvp6i/mqybSZDoK0CfCdkTbwo36ydoTY6IokSStT1Px/3vDdAokIQoTAEBcqW5O0dGrz1RjpNV0FKDX3m6xddKH55qOgX1hgUVHUJhE2fDrP1b4sXzTMQAgodi2pePXLtQHrayvgPh1S9VgLfr8RNMxOrAfydfw6z8yHQNJisIkysLVNfI2JWfVCwDRVNfi143b5mhpAytiI/5cVz5Ky8rHqKnNazpKB56miMK1taZjIEkx+B0AELc+rSrQs+5JSnO9pdkpzB6E+LCkPlOvlQ9XdXOK6SjoqkhEshycspx1TBAt3oaIdlRmmI4BAAlpVflA3bblcG0O1ZuOAnSqzQ5rQ1u9frf+iJgsSnZUZsjbmJwfiBEbKEwcEHjmLY26psZ0DABIWFvrs3Tqx2crnKR3GREf1rW16PSPzlU4Rtc5G/3zSvmffdt0jNjE4HdHxOZfBgAA3RSOuHTYhwu1oY2WE8Se+2rzdMEnZ5qOAcQ0ChOH2Ju2KuvaVLWGWBQMAKKlNezWjzcdr+cb/aajAP+/vfsPqrJe8Dj+OYJwRJDSriBXUPQ6SVlLYsvoqqNlmDU76ZjXdt3M1CZ2zVSmzB/N1XGa61haXL3hj1Wr0a2c9Kq3DXe03RG9V72S4s/UUkFQQD1ogIgczjnP/tHVjYVrDj/O95zzvF8z5w++PMIHHuGcD8/3+33u+K3rQX1e9vfyBOiVkrr6cMUu7CBvabnpKAHL8vn8/rCjwPwJCUG+W7ekgydlWQ7TUQAgpBVX3a+t1/rrq5tO01EArauM175rvXStNnB3j/NZDin/hKy6OtNRYHMUE3+yfKq8EKub7sDaGhAAQs1R1y/1H5cH6pT7pukosKl6y6uT7lp9UjxQrpsdTcf5m2rqIlR9IdZ0DEASxcS/LEt9Xv+LblzqZDoJAIS885Vd9G/f/5PqLbYRhv+VeWs15dsX5fYG9hTumosx6jPjgG0XW98zFr/7BcUEABCyauvba+ixX8vlrTEdBTbyx5oojT/5kukYQNChmBiQ8m6panZ3NR0DAGzBshyafH6s9twynQR2sKSijz4sfiIo1pTe/O+uSnn3kukYwcFn+f9hQxQTAzwXStS+yp7/4QDAhCs10dpw9R+0rSbadBSEsOzrPfXna71VWRccGy9EVFnylFw0HQO4g2JiSHSZV1fOdzEdAwBs43hFN22veEwH6+pNR0GI8Vo+7bklfVn2qK4ESfm9cq6LOpax/gqBhWJiSIftB/Xg2mpVsZ0lAPjNqWtx+k3haN3wMa8LrcNr+XTFe1OzTz+vGneE6Tj3pOqmUw/+e6Wc/3nQdJTgYVmS5fPjw54zaygmBvmOfKseE8//uH84AMAvfrjVQU8dn6CbPrfpKAgBB+qkMScmmY5xz7y+durxL2flO3badBSgEYoJAMB2LMuh586M1aE6ygmaL/t6T719bozpGPADy2f5/WFHFBPDfLfqFPX7+3StMnBvvgQAoai6LlK/Kx/Bgng0y29dD+p/XH1VWx88N02u+CFa0b+Plc/NOisEJoqJaT6vInfky1MXbjoJANjOd9e76qtrf6fdtTwd4t5tq4lW3tU+QbPQ/TbPrXBF/Fe+5GPROwITv4kDhON6e9XUBceiOQAIJccruin74lMq89wwHQUBrt7yqthzQ0vOjgyaLYFvq6mLULsf+CNos/l14ftfHzZEMQkQv5p1QNZf7jMdAwBsqbwmRs9/O1H1Fn9Jxt/2Xb1bvz4xKShuntjIn+/Tr7IOmE4B3BXFBAAA/bhb0VMnx+q7+hrTURCA1lXG61/P/LPpGDCExe/+QTEJIEmby+T5wy9MxwAA27rlCddvLv6jvuIeU/iJd1x9tfXyY3J7w0xHaRbv5l8o6Q+lpmPAD3JycpScnCyn06m0tDTt3bv3rsfn5eUpLS1NTqdTvXr10qpVq/yUtGkUkwDiPVuoTkVsXQkAJhVVdtYfrz1GOYEk6eOqrtpX0Uuum8G7e2ZsYZ0854tMxwhuQbDGZNOmTZo5c6bmz5+vgoICDRkyRKNGjVJxcXGTxxcWFuqZZ57RkCFDVFBQoHnz5un111/Xli1bWvrdajaKSYAJr/Ho8qX7TccAAFs76vqlNlwexLQuG6u3vDrlvqm1RYN1rTbKdJxmu3zpfoXVsD2wHbz//vuaMmWKpk6dqpSUFGVnZysxMVErV65s8vhVq1YpKSlJ2dnZSklJ0dSpUzV58mQtXbrUz8n/j622Z7CsH+freVQvBerUvX3fqM+Zzrq++j7TSQDA1s7VdNTkK88r96GvTEeBAZc8NZr47QRJwf2ivs/sU/Jcu246xl15/vo9vv06LRD5+7Xj7e9JVVVVg/HIyEhFRkY2Ot7tduvQoUOaM2dOg/GMjAzt27evyc+xf/9+ZWRkNBgbOXKk1q1bp/r6erVv7/979NiqmFRXV0uS/qRcw0l+RoWk502HAABIEtew7ewD0wFspbq6WrGxsaZjNBAREaH4+Hj9qdz/rx2jo6OVmJjYYGzBggVauHBho2NdLpe8Xq/i4uIajMfFxam8vLzJj19eXt7k8R6PRy6XS926dWvZF9AMtiomCQkJKikpUUxMjByOINzqrxmqqqqUmJiokpISderUyXQctDHOt31wru2Dc20fdj3XlmWpurpaCQkJpqM04nQ6VVhYKLfb/2uALctq9Hq1qaslP/X/j2/qY/zc8U2N+4utikm7du3UvXt30zGM6NSpk61+ydkd59s+ONf2wbm2Dzue60C7UvJTTqdTTmdgb4bxwAMPKCwsrNHVkStXrjS6KnJbfHx8k8eHh4erS5cubZb1blj8DgAAAASxiIgIpaWladeuXQ3Gd+3apUGDBjX5bwYOHNjo+J07d2rAgAFG1pdIFBMAAAAg6GVlZWnt2rVav369Tp06pVmzZqm4uFiZmZmSpLlz52rixIl3js/MzNSFCxeUlZWlU6dOaf369Vq3bp3eeOMNU1+CvaZy2VFkZKQWLFjws3MSERo43/bBubYPzrV9cK7REuPHj1dFRYUWLVqksrIy9evXT7m5uerRo4ckqaysrME9TZKTk5Wbm6tZs2bpww8/VEJCgpYvX66xY8ea+hLksAJ5bzYAAAAAtsBULgAAAADGUUwAAAAAGEcxAQAAAGAcxQQAAACAcRQTm6qrq1NqaqocDoeOHDliOg5aWVFRkaZMmaLk5GR16NBBvXv31oIFC4zcuRatLycnR8nJyXI6nUpLS9PevXtNR0IbWLx4sR5//HHFxMSoa9euGj16tM6cOWM6FtrY4sWL5XA4NHPmTNNRAL+jmNjU7NmzlZCQYDoG2sjp06fl8/m0evVqnTx5Uh988IFWrVqlefPmmY6GFtq0aZNmzpyp+fPnq6CgQEOGDNGoUaMabAGJ0JCXl6dp06bpwIED2rVrlzwejzIyMlRTU2M6GtpIfn6+1qxZo0cffdR0FMAItgu2oR07digrK0tbtmzRww8/rIKCAqWmppqOhTb23nvvaeXKlTp//rzpKGiB9PR09e/fXytXrrwzlpKSotGjR2vx4sUGk6GtXb16VV27dlVeXp6GDh1qOg5a2Y0bN9S/f3/l5OTonXfeUWpqqrKzs03HAvyKKyY2c/nyZb3yyivasGGDoqKiTMeBH1VWVqpz586mY6AF3G63Dh06pIyMjAbjGRkZ2rdvn6FU8JfKykpJ4uc4RE2bNk3PPvusRowYYToKYAx3frcRy7I0adIkZWZmasCAASoqKjIdCX5y7tw5rVixQsuWLTMdBS3gcrnk9XoVFxfXYDwuLk7l5eWGUsEfLMtSVlaWBg8erH79+pmOg1b2+eef6/Dhw8rPzzcdBTCKKyYhYOHChXI4HHd9fPPNN1qxYoWqqqo0d+5c05HRTPd6rn+qtLRUTz/9tMaNG6epU6caSo7W5HA4GrxtWVajMYSW1157TceOHdNnn31mOgpaWUlJiWbMmKGNGzfK6XSajgMYxRqTEOByueRyue56TM+ePfXCCy/oyy+/bPACxuv1KiwsTBMmTNAnn3zS1lHRQvd6rm8/uZWWlmr48OFKT0/Xxx9/rHbt+FtEMHO73YqKitIXX3yhMWPG3BmfMWOGjhw5ory8PIPp0FamT5+ubdu2ac+ePUpOTjYdB61s27ZtGjNmjMLCwu6Meb1eORwOtWvXTnV1dQ3eB4QyiomNFBcXq6qq6s7bpaWlGjlypDZv3qz09HR1797dYDq0tkuXLmn48OFKS0vTxo0beWILEenp6UpLS1NOTs6dsYceekjPPfcci99DjGVZmj59urZu3ardu3erT58+piOhDVRXV+vChQsNxl5++WX17dtXb731FlP3YCusMbGRpKSkBm9HR0dLknr37k0pCTGlpaUaNmyYkpKStHTpUl29evXO++Lj4w0mQ0tlZWXpxRdf1IABAzRw4ECtWbNGxcXFyszMNB0NrWzatGn69NNPtX37dsXExNxZRxQbG6sOHToYTofWEhMT06h8dOzYUV26dKGUwHYoJkAI2rlzp86ePauzZ882Kp1cJA1u48ePV0VFhRYtWqSysjL169dPubm56tGjh+loaGW3t4QeNmxYg/GPPvpIkyZN8n8gAGhjTOUCAAAAYBwrYQEAAAAYRzEBAAAAYBzFBAAAAIBxFBMAAAAAxlFMAAAAABhHMQEAAABgHMUEAAAAgHEUEwAAAADGUUwAAAAAGEcxAYAg4PV6NWjQII0dO7bBeGVlpRITE/X2228bSgYAQOtwWJZlmQ4BAPh533//vVJTU7VmzRpNmDBBkjRx4kQdPXpU+fn5ioiIMJwQAIDmo5gAQBBZvny5Fi5cqBMnTig/P1/jxo3TwYMHlZqaajoaAAAtQjEBgCBiWZaeeOIJhYWF6fjx45o+fTrTuAAAIYFiAgBB5vTp00pJSdEjjzyiw4cPKzw83HQkAABajMXvABBk1q9fr6ioKBUWFurixYum4wAA0Cq4YgIAQWT//v0aOnSoduzYoXfffVder1dff/21HA6H6WgAALQIV0wAIEjU1tbqpZde0quvvqoRI0Zo7dq1ys/P1+rVq01HAwCgxSgmABAk5syZI5/PpyVLlkiSkpKStGzZMr355psqKioyGw4AgBZiKhcABIG8vDw9+eST2r17twYPHtzgfSNHjpTH42FKFwAgqFFMAAAAABjHVC4AAAAAxlFMAAAAABhHMQEAAABgHMUEAAAAgHEUEwAAAADGUUwAAAAAGEcxAQAAAGAcxQQAAACAcRQTAAAAAMZRTAAAAAAYRzEBAAAAYNz/AoxC+oe9ARMDAAAAAElFTkSuQmCC",
       "text/plain": [
-       "<Figure size 800x600 with 2 Axes>"
+       "<Figure size 1000x800 with 2 Axes>"
       ]
      },
      "metadata": {},
@@ -136,6 +143,7 @@
    "source": [
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
+    "import time \n",
     "\n",
     "sphere1 = Sphere(material=1, center=(0, -0.5, 0), radius=0.5)\n",
     "sphere2 = Sphere(material=2, center=(0, 0.5, 0), radius=1)\n",
@@ -147,27 +155,92 @@
     "y = np.linspace(-1, 1, 500)\n",
     "xx, yy = np.meshgrid(x, y)\n",
     "\n",
-    "# Create a vectorized version of point_in_objectp\n",
     "def get_epsilon(x, y):\n",
     "    mat = group.query_material_at_point((x, y, 0))\n",
     "    return 0 if mat is None else mat\n",
     "point_in_object_vec = np.vectorize(get_epsilon)\n",
     "\n",
+    "start_time = time.time()\n",
     "material_map = point_in_object_vec(xx, yy)\n",
+    "end_time = time.time()\n",
+    "print(f\"Time taken: {end_time - start_time} seconds\")\n",
     "\n",
     "# Create the plot\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "plt.imshow(material_map, cmap='viridis')\n",
-    "plt.colorbar()\n",
+    "plt.figure(figsize=(10, 8))\n",
+    "plt.imshow(material_map, cmap='viridis', extent=[-5, 5, -5, 5])\n",
+    "plt.colorbar(label='Material')\n",
+    "plt.title('1000 Random Spheres')\n",
+    "plt.xlabel('X')\n",
+    "plt.ylabel('Y')\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time taken: 0.25003600120544434 seconds\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Generate 1000 random spheres\n",
+    "np.random.seed(42)  # for reproducibility\n",
+    "spheres = []\n",
+    "for _ in range(1000):\n",
+    "    # Random position in x-y plane (z=0)\n",
+    "    x = np.random.uniform(-5, 5)\n",
+    "    y = np.random.uniform(-5, 5)\n",
+    "    # Random radius between 0.05 and 0.2\n",
+    "    radius = np.random.uniform(0.05, 0.2)\n",
+    "    # Random material (1-5)\n",
+    "    material = np.random.randint(1, 6)\n",
+    "    \n",
+    "    sphere = Sphere(material=material, center=(x, y, 0), radius=radius)\n",
+    "    spheres.append(sphere)\n",
+    "\n",
+    "group = GroupObject(spheres)\n",
+    "\n",
+    "# Create a grid of points (increased range to -5 to 5 to match sphere distribution)\n",
+    "x = np.linspace(-5, 5, 500)\n",
+    "y = np.linspace(-5, 5, 500)\n",
+    "xx, yy = np.meshgrid(x, y)\n",
+    "\n",
+    "# Reuse your existing plotting code\n",
+    "def get_epsilon(x, y):\n",
+    "    mat = group.query_material_at_point((x, y, 0))\n",
+    "    return 0 if mat is None else mat\n",
+    "point_in_object_vec = np.vectorize(get_epsilon)\n",
+    "\n",
+    "start_time = time.time()\n",
+    "material_map = point_in_object_vec(xx, yy)\n",
+    "end_time = time.time()\n",
+    "print(f\"Time taken: {end_time - start_time} seconds\")\n",
+    "\n",
+    "# Create the plot\n",
+    "plt.figure(figsize=(10, 8))\n",
+    "plt.imshow(material_map, cmap='viridis', extent=[-5, 5, -5, 5])\n",
+    "plt.colorbar(label='Material')\n",
+    "plt.title('1000 Random Spheres')\n",
+    "plt.xlabel('X')\n",
+    "plt.ylabel('Y')\n",
+    "plt.show()"
+   ]
   }
  ],
  "metadata": {

From 8b1d2dd1375c6d8a4d083d951fe999ce77f2d105 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 7 Nov 2024 13:58:14 -0800
Subject: [PATCH 10/37] Add benchmark

---
 swig/test.ipynb | 85 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 73 insertions(+), 12 deletions(-)

diff --git a/swig/test.ipynb b/swig/test.ipynb
index 198db7d..3b43c28 100644
--- a/swig/test.ipynb
+++ b/swig/test.ipynb
@@ -177,19 +177,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.25003600120544434 seconds\n"
+      "Time taken: 0.34314489364624023 seconds\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x800 with 2 Axes>"
       ]
@@ -199,16 +199,12 @@
     }
    ],
    "source": [
-    "# Generate 1000 random spheres\n",
-    "np.random.seed(42)  # for reproducibility\n",
+    "np.random.seed(42)\n",
     "spheres = []\n",
-    "for _ in range(1000):\n",
-    "    # Random position in x-y plane (z=0)\n",
+    "for _ in range(3000):\n",
     "    x = np.random.uniform(-5, 5)\n",
     "    y = np.random.uniform(-5, 5)\n",
-    "    # Random radius between 0.05 and 0.2\n",
     "    radius = np.random.uniform(0.05, 0.2)\n",
-    "    # Random material (1-5)\n",
     "    material = np.random.randint(1, 6)\n",
     "    \n",
     "    sphere = Sphere(material=material, center=(x, y, 0), radius=radius)\n",
@@ -216,12 +212,10 @@
     "\n",
     "group = GroupObject(spheres)\n",
     "\n",
-    "# Create a grid of points (increased range to -5 to 5 to match sphere distribution)\n",
     "x = np.linspace(-5, 5, 500)\n",
     "y = np.linspace(-5, 5, 500)\n",
     "xx, yy = np.meshgrid(x, y)\n",
     "\n",
-    "# Reuse your existing plotting code\n",
     "def get_epsilon(x, y):\n",
     "    mat = group.query_material_at_point((x, y, 0))\n",
     "    return 0 if mat is None else mat\n",
@@ -236,11 +230,78 @@
     "plt.figure(figsize=(10, 8))\n",
     "plt.imshow(material_map, cmap='viridis', extent=[-5, 5, -5, 5])\n",
     "plt.colorbar(label='Material')\n",
-    "plt.title('1000 Random Spheres')\n",
+    "plt.title('3000 Random Spheres')\n",
     "plt.xlabel('X')\n",
     "plt.ylabel('Y')\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of spheres: 1000, Time taken: 0.26 seconds\n",
+      "Number of spheres: 2000, Time taken: 0.30 seconds\n",
+      "Number of spheres: 3000, Time taken: 0.36 seconds\n",
+      "Number of spheres: 5000, Time taken: 0.57 seconds\n",
+      "Number of spheres: 7000, Time taken: 0.87 seconds\n",
+      "Number of spheres: 10000, Time taken: 1.54 seconds\n",
+      "Number of spheres: 15000, Time taken: 3.34 seconds\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# benchmark\n",
+    "sphere_counts = [1000, 2000, 3000, 5000, 7000, 10000, 15000]\n",
+    "times = []\n",
+    "\n",
+    "for num_spheres in sphere_counts:\n",
+    "    np.random.seed(42)\n",
+    "    spheres = []\n",
+    "    for _ in range(num_spheres):\n",
+    "        x = np.random.uniform(-5, 5)\n",
+    "        y = np.random.uniform(-5, 5)\n",
+    "        radius = np.random.uniform(0.05, 0.2)\n",
+    "        material = np.random.randint(1, 6)\n",
+    "        \n",
+    "        sphere = Sphere(material=material, center=(x, y, 0), radius=radius)\n",
+    "        spheres.append(sphere)\n",
+    "\n",
+    "    group = GroupObject(spheres)\n",
+    "    \n",
+    "    # Measure query time\n",
+    "    start_time = time.time()\n",
+    "    material_map = point_in_object_vec(xx, yy)\n",
+    "    end_time = time.time()\n",
+    "    \n",
+    "    elapsed_time = end_time - start_time\n",
+    "    times.append(elapsed_time)\n",
+    "    print(f\"Number of spheres: {num_spheres}, Time taken: {elapsed_time:.2f} seconds\")\n",
+    "\n",
+    "# Plot the results\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(sphere_counts, times, 'o-')\n",
+    "plt.grid(True)\n",
+    "plt.xlabel('Number of Spheres')\n",
+    "plt.ylabel('Time (seconds)')\n",
+    "plt.title('Performance Scaling with Number of Spheres')\n",
+    "plt.show()"
+   ]
   }
  ],
  "metadata": {

From c9c3134f1b9f5e55a007bd6c0f1aae37ce62c30a Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 11:28:28 -0800
Subject: [PATCH 11/37] Modify the build script to include relative directories
 for header files.

Previously usr/local/include was used, which is undesirable.
---
 swig/build.sh | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/swig/build.sh b/swig/build.sh
index de18757..61f20b8 100755
--- a/swig/build.sh
+++ b/swig/build.sh
@@ -1,16 +1,23 @@
 #!/bin/bash
 
+# Define local include paths relative to script location
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+LOCAL_INCLUDES="-I$SCRIPT_DIR/../src -I$SCRIPT_DIR/../utils"
+echo $LOCAL_INCLUDES
+
 # Check if running in a conda environment
 if [ -n "${CONDA_PREFIX}" ]; then
     echo "Using Conda environment at: $CONDA_PREFIX"
     PYTHON_INCLUDE=$($CONDA_PREFIX/bin/python3 -c "from sysconfig import get_paths; print(get_paths()['include'])")
-    swig -python -I/usr/local/include -I"$PYTHON_INCLUDE" libctlgeom.i
+    export CFLAGS="-I$SCRIPT_DIR/../src -I$SCRIPT_DIR/../utils -I$PYTHON_INCLUDE"
+    swig -python $LOCAL_INCLUDES -I"$PYTHON_INCLUDE" libctlgeom.i
     $CONDA_PREFIX/bin/python3 setup.py build_ext --inplace
     $CONDA_PREFIX/bin/pip install .
 else
     echo "Using system Python"
     PYTHON_INCLUDE=$(python3 -c "from sysconfig import get_paths; print(get_paths()['include'])")
-    swig -python -I/usr/local/include -I"$PYTHON_INCLUDE" libctlgeom.i
+    export CFLAGS="-I$SCRIPT_DIR/../src -I$SCRIPT_DIR/../utils -I$PYTHON_INCLUDE"
+    swig -python $LOCAL_INCLUDES -I"$PYTHON_INCLUDE" libctlgeom.i
     python3 setup.py build_ext --inplace
     pip install .
 fi
\ No newline at end of file

From 41be3cd32f5116d44faa6ad2fcc8eebeae8deea8 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 11:41:59 -0800
Subject: [PATCH 12/37] Add new macros for when compiling for swig; get rid of
 manual includes in the .i

---
 swig/libctlgeom.i | 130 ++++------------------------------------------
 utils/ctlgeom.h   |  10 ++++
 2 files changed, 19 insertions(+), 121 deletions(-)

diff --git a/swig/libctlgeom.i b/swig/libctlgeom.i
index f567842..67eaf22 100644
--- a/swig/libctlgeom.i
+++ b/swig/libctlgeom.i
@@ -2,6 +2,7 @@
 
 /* Include the header files first */
 %{
+#define CTL_SWIG
 #include "ctlgeom.h"
 #include "ctlgeom-types.h"
 %}
@@ -30,126 +31,6 @@
         Py_XINCREF($result);  // Increment reference count when returning to Python
     }
 }
-
-extern void display_geometric_object_info(int indentby, geometric_object o);
-
-extern void geom_initialize(void);
-extern void geom_fix_object_ptr(geometric_object *o);
-// extern void geom_fix_object(geometric_object o) CTLGEOM_DEPRECATED;
-extern void geom_fix_objects(void);
-// extern void geom_fix_objects0(geometric_object_list geometry) CTLGEOM_DEPRECATED;
-extern void geom_fix_object_list(geometric_object_list geometry);
-extern void geom_fix_lattice(void);
-extern void geom_fix_lattice0(LATTICE *L);
-extern void geom_cartesian_lattice(void);
-extern void geom_cartesian_lattice0(LATTICE *L);
-extern double geom_object_volume(geometric_object o);
-extern boolean point_in_objectp(vector3 p, geometric_object o);
-extern boolean point_in_periodic_objectp(vector3 p, geometric_object o);
-extern boolean point_in_fixed_objectp(vector3 p, geometric_object o);
-extern boolean point_in_fixed_pobjectp(vector3 p, geometric_object *o);
-extern boolean point_in_periodic_fixed_objectp(vector3 p, geometric_object o);
-extern vector3 to_geom_object_coords(vector3 p, geometric_object o);
-extern vector3 from_geom_object_coords(vector3 p, geometric_object o);
-extern vector3 normal_to_object(vector3 p, geometric_object o);
-extern vector3 normal_to_fixed_object(vector3 p, geometric_object o);
-extern int intersect_line_with_object(vector3 p, vector3 d, geometric_object o, double s[2]);
-extern double intersect_line_segment_with_object(vector3 p, vector3 d, geometric_object o, double a,
-                                                 double b);
-extern MATERIAL_TYPE material_of_point_inobject(vector3 p, boolean *inobject);
-extern MATERIAL_TYPE material_of_point_inobject0(geometric_object_list geometry, vector3 p,
-                                                 boolean *inobject);
-extern MATERIAL_TYPE material_of_point(vector3 p);
-extern MATERIAL_TYPE material_of_point0(geometric_object_list geometry, vector3 p);
-geometric_object object_of_point0(geometric_object_list geometry, vector3 p, vector3 *shiftby);
-geometric_object object_of_point(vector3 p, vector3 *shiftby);
-vector3 shift_to_unit_cell(vector3 p);
-extern matrix3x3 square_basis(matrix3x3 lattice_basis, vector3 size);
-extern void ctl_printf(const char *fmt, ...);
-extern void (*ctl_printf_callback)(const char *s);
-
-typedef struct {
-  vector3 low, high;
-} geom_box;
-
-typedef struct {
-  geom_box box;
-  const geometric_object *o;
-  vector3 shiftby;
-  int precedence;
-} geom_box_object;
-
-typedef struct geom_box_tree_struct {
-  geom_box b, b1, b2;
-  struct geom_box_tree_struct *t1, *t2;
-  int nobjects;
-  geom_box_object *objects;
-} * geom_box_tree;
-
-extern void destroy_geom_box_tree(geom_box_tree t);
-extern geom_box_tree create_geom_box_tree(void);
-extern geom_box_tree create_geom_box_tree0(geometric_object_list geometry, geom_box b0);
-extern geom_box_tree restrict_geom_box_tree(geom_box_tree, const geom_box *);
-extern geom_box_tree geom_tree_search(vector3 p, geom_box_tree t, int *oindex);
-extern geom_box_tree geom_tree_search_next(vector3 p, geom_box_tree t, int *oindex);
-extern MATERIAL_TYPE material_of_point_in_tree_inobject(vector3 p, geom_box_tree t,
-                                                        boolean *inobject);
-extern MATERIAL_TYPE material_of_point_in_tree(vector3 p, geom_box_tree t);
-extern MATERIAL_TYPE material_of_unshifted_point_in_tree_inobject(vector3 p, geom_box_tree t,
-                                                                  boolean *inobject);
-const geometric_object *object_of_point_in_tree(vector3 p, geom_box_tree t, vector3 *shiftby,
-                                                int *precedence);
-extern vector3 to_geom_box_coords(vector3 p, geom_box_object *gbo);
-extern void display_geom_box_tree(int indentby, geom_box_tree t);
-extern void geom_box_tree_stats(geom_box_tree t, int *depth, int *nobjects);
-
-extern void geom_get_bounding_box(geometric_object o, geom_box *box);
-extern number box_overlap_with_object(geom_box b, geometric_object o, number tol, int maxeval);
-extern number ellipsoid_overlap_with_object(geom_box b, geometric_object o, number tol,
-                                            int maxeval);
-extern number range_overlap_with_object(vector3 low, vector3 high, geometric_object o, number tol,
-                                        int maxeval);
-
-// extern vector3 get_grid_size(void);
-// extern vector3 get_resolution(void);
-// extern void get_grid_size_n(int *nx, int *ny, int *nz);
-
-geometric_object make_geometric_object(MATERIAL_TYPE material, vector3 center);
-geometric_object make_cylinder(MATERIAL_TYPE material, vector3 center, number radius, number height,
-                               vector3 axis);
-geometric_object make_wedge(MATERIAL_TYPE material, vector3 center, number radius, number height,
-                            vector3 axis, number wedge_angle, vector3 wedge_start);
-geometric_object make_cone(MATERIAL_TYPE material, vector3 center, number radius, number height,
-                           vector3 axis, number radius2);
-geometric_object make_sphere(MATERIAL_TYPE material, vector3 center, number radius);
-geometric_object make_block(MATERIAL_TYPE material, vector3 center, vector3 e1, vector3 e2,
-                            vector3 e3, vector3 size);
-geometric_object make_ellipsoid(MATERIAL_TYPE material, vector3 center, vector3 e1, vector3 e2,
-                                vector3 e3, vector3 size);
-
-extern boolean node_in_or_on_polygon(vector3 q0, vector3 *nodes, int num_nodes,
-                                     boolean include_boundaries);
-
-// prism with `center` field computed automatically from vertices, height, axis
-geometric_object make_prism(MATERIAL_TYPE material, const vector3 *vertices, int num_vertices,
-                            double height, vector3 axis);
-
-// as make_prism, but with a rigid translation so that the prism is centered at center
-geometric_object make_prism_with_center(MATERIAL_TYPE material, vector3 center,
-                                        const vector3 *vertices, int num_vertices, double height,
-                                        vector3 axis);
-
-// slanted prism with `center` field computed automatically from vertices, height, axis, sidewall_angle
-geometric_object make_slanted_prism(MATERIAL_TYPE material, const vector3 *vertices, int num_vertices,
-                            double height, vector3 axis, double sidewall_angle);
-
-// as make_slanted_prism, but with a rigid translation so that the prism is centered at center
-geometric_object make_slanted_prism_with_center(MATERIAL_TYPE material, vector3 center,
-                                        const vector3 *vertices, int num_vertices, double height,
-                                        vector3 axis, double sidewall_angle);
-
-int vector3_nearly_equal(vector3 v1, vector3 v2, double tolerance);
-
 /* Add typemap for geometric object arrays */
 %typemap(in) (geometric_object *items) {
     if (!PyList_Check($input)) {
@@ -216,4 +97,11 @@ int vector3_nearly_equal(vector3 v1, vector3 v2, double tolerance);
 }
 
 // Ignore the original items attribute to prevent conflicts
-%ignore geometric_object_list::items;
\ No newline at end of file
+%ignore geometric_object_list::items;
+%ignore geom_fix_object;
+%ignore geom_fix_objects0;
+%ignore get_grid_size;
+%ignore get_resolution;
+%ignore get_grid_size_n;
+
+%include "ctlgeom.h"
\ No newline at end of file
diff --git a/utils/ctlgeom.h b/utils/ctlgeom.h
index 194b226..09cec36 100644
--- a/utils/ctlgeom.h
+++ b/utils/ctlgeom.h
@@ -39,6 +39,16 @@
 #define MATERIAL_TYPE void *
 #endif
 
+#ifndef CTL_SWIG /* for swig */
+#undef MATERIAL_TYPE
+#define MATERIAL_TYPE MATERIAL_TYPE
+#undef GEOMETRIC_OBJECT
+#define GEOMETRIC_OBJECT geometric_object
+#undef GEOMETRIC_OBJECT_LIST
+#define GEOMETRIC_OBJECT_LIST geometric_object_list
+#undef CTL_IO_H /* to include display_geometric_object_info */
+#endif
+
 /* Where possible (e.g. for gcc >= 3.1), enable a compiler warning
    for code that uses a deprecated function */
 #if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0))

From 9076e6a4b97b12efc72648bba045266e26d198fc Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 12:01:35 -0800
Subject: [PATCH 13/37] Add readme, minor edits

---
 swig/README.md    | 39 +++++++++++++++++++++++++++++++++++++++
 swig/build.sh     |  1 -
 swig/libctlgeom.i |  1 +
 utils/ctlgeom.h   |  3 ++-
 4 files changed, 42 insertions(+), 2 deletions(-)
 create mode 100644 swig/README.md

diff --git a/swig/README.md b/swig/README.md
new file mode 100644
index 0000000..4eb5fa1
--- /dev/null
+++ b/swig/README.md
@@ -0,0 +1,39 @@
+# Python Extension for libctl
+
+This directory contains SWIG bindings to create a Python extension for libctl.
+
+## Prerequisites
+- SWIG
+- Python 3.x
+- pip
+- A C compiler (gcc, clang, etc.)
+
+## Installation
+
+**Using Conda Environment**
+   ```bash
+   conda activate my_env
+   chmod +x build.sh
+   ./build.sh
+   ```
+
+**Using System Python**
+   ```bash
+   chmod +x build.sh
+   ./build.sh
+   ```
+
+The build script will automatically:
+- Generate Python bindings using SWIG
+- Compile the extension module
+- Install the package using pip
+
+## Verification
+
+To verify the installation, you can run Python and try the following:
+```python
+import ctlgeom
+sphere = ctlgeom.Sphere(1, (0, 0.5, 0), 1)
+ctlgeom.point_is_in_object((0.5, 0, 0), sphere)
+```
+
diff --git a/swig/build.sh b/swig/build.sh
index 61f20b8..c1384b2 100755
--- a/swig/build.sh
+++ b/swig/build.sh
@@ -3,7 +3,6 @@
 # Define local include paths relative to script location
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 LOCAL_INCLUDES="-I$SCRIPT_DIR/../src -I$SCRIPT_DIR/../utils"
-echo $LOCAL_INCLUDES
 
 # Check if running in a conda environment
 if [ -n "${CONDA_PREFIX}" ]; then
diff --git a/swig/libctlgeom.i b/swig/libctlgeom.i
index 67eaf22..ee32519 100644
--- a/swig/libctlgeom.i
+++ b/swig/libctlgeom.i
@@ -98,6 +98,7 @@
 
 // Ignore the original items attribute to prevent conflicts
 %ignore geometric_object_list::items;
+// Ignore deprecated functions
 %ignore geom_fix_object;
 %ignore geom_fix_objects0;
 %ignore get_grid_size;
diff --git a/utils/ctlgeom.h b/utils/ctlgeom.h
index 09cec36..546a241 100644
--- a/utils/ctlgeom.h
+++ b/utils/ctlgeom.h
@@ -46,7 +46,8 @@
 #define GEOMETRIC_OBJECT geometric_object
 #undef GEOMETRIC_OBJECT_LIST
 #define GEOMETRIC_OBJECT_LIST geometric_object_list
-#undef CTL_IO_H /* to include display_geometric_object_info */
+#include <ctlgeom-types.h>
+extern void display_geometric_object_info(int indentby, geometric_object o);
 #endif
 
 /* Where possible (e.g. for gcc >= 3.1), enable a compiler warning

From 79191847554ffd53d87ae099af059d3b39649d7a Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 12:06:20 -0800
Subject: [PATCH 14/37] Change dir name to python

---
 {swig => python}/README.md    | 0
 {swig => python}/build.sh     | 0
 {swig => python}/ctlgeom.py   | 0
 {swig => python}/libctlgeom.i | 0
 {swig => python}/setup.py     | 0
 {swig => python}/test.ipynb   | 0
 6 files changed, 0 insertions(+), 0 deletions(-)
 rename {swig => python}/README.md (100%)
 rename {swig => python}/build.sh (100%)
 rename {swig => python}/ctlgeom.py (100%)
 rename {swig => python}/libctlgeom.i (100%)
 rename {swig => python}/setup.py (100%)
 rename {swig => python}/test.ipynb (100%)

diff --git a/swig/README.md b/python/README.md
similarity index 100%
rename from swig/README.md
rename to python/README.md
diff --git a/swig/build.sh b/python/build.sh
similarity index 100%
rename from swig/build.sh
rename to python/build.sh
diff --git a/swig/ctlgeom.py b/python/ctlgeom.py
similarity index 100%
rename from swig/ctlgeom.py
rename to python/ctlgeom.py
diff --git a/swig/libctlgeom.i b/python/libctlgeom.i
similarity index 100%
rename from swig/libctlgeom.i
rename to python/libctlgeom.i
diff --git a/swig/setup.py b/python/setup.py
similarity index 100%
rename from swig/setup.py
rename to python/setup.py
diff --git a/swig/test.ipynb b/python/test.ipynb
similarity index 100%
rename from swig/test.ipynb
rename to python/test.ipynb

From ce3b93e5051db66137f131ec1463bfdb7c9f806a Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 12:25:28 -0800
Subject: [PATCH 15/37] Update the bulid script to add autogen.sh

---
 python/build.sh | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/python/build.sh b/python/build.sh
index c1384b2..f6f3ba2 100755
--- a/python/build.sh
+++ b/python/build.sh
@@ -1,5 +1,10 @@
 #!/bin/bash
 
+cd ../
+# run autogen.sh to generate all the header files needed
+./autogen.sh
+cd python
+
 # Define local include paths relative to script location
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 LOCAL_INCLUDES="-I$SCRIPT_DIR/../src -I$SCRIPT_DIR/../utils"

From 742cf41b5a9d1bd97fa979a269fe1808792037d0 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 12:45:00 -0800
Subject: [PATCH 16/37] Get rid of Guile dependency for when building python
 extension

---
 python/build.sh            |   5 -
 python/libctlgeom.i        |   4 +-
 utils/ctlgeom-types-swig.h | 182 +++++++++++++++++++++++++++++++++++++
 utils/ctlgeom.h            |   2 +-
 4 files changed, 185 insertions(+), 8 deletions(-)
 create mode 100644 utils/ctlgeom-types-swig.h

diff --git a/python/build.sh b/python/build.sh
index f6f3ba2..c1384b2 100755
--- a/python/build.sh
+++ b/python/build.sh
@@ -1,10 +1,5 @@
 #!/bin/bash
 
-cd ../
-# run autogen.sh to generate all the header files needed
-./autogen.sh
-cd python
-
 # Define local include paths relative to script location
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 LOCAL_INCLUDES="-I$SCRIPT_DIR/../src -I$SCRIPT_DIR/../utils"
diff --git a/python/libctlgeom.i b/python/libctlgeom.i
index ee32519..90874f0 100644
--- a/python/libctlgeom.i
+++ b/python/libctlgeom.i
@@ -4,11 +4,11 @@
 %{
 #define CTL_SWIG
 #include "ctlgeom.h"
-#include "ctlgeom-types.h"
+#include "ctlgeom-types-swig.h"
 %}
 
 /* Include the type definitions */
-%include "ctlgeom-types.h"
+%include "ctlgeom-types-swig.h"
 
 /* Properly wrap vector3 structure */
 %include "ctl-math.h"
diff --git a/utils/ctlgeom-types-swig.h b/utils/ctlgeom-types-swig.h
new file mode 100644
index 0000000..42843fd
--- /dev/null
+++ b/utils/ctlgeom-types-swig.h
@@ -0,0 +1,182 @@
+/* This file is used to define the types for the SWIG bindings */
+
+#ifndef CTL_IO_H
+#define CTL_IO_H
+
+#include <ctl-math.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif				/* __cplusplus */
+
+	/******* Type declarations *******/
+
+	typedef struct geometric_object_struct {
+		void*		material;
+		vector3		center;
+		enum {
+			GEOMETRIC_OBJECT_SELF, PRISM, BLOCK, SPHERE, CYLINDER, COMPOUND_GEOMETRIC_OBJECT
+		}		which_subclass;
+		union {
+			struct prism_struct *prism_data;
+			struct block_struct *block_data;
+			struct sphere_struct *sphere_data;
+			struct cylinder_struct *cylinder_data;
+			struct compound_geometric_object_struct *compound_geometric_object_data;
+		}		subclass;
+	}		geometric_object;
+
+	typedef struct {
+		int		num_items;
+		geometric_object *items;
+	} geometric_object_list;
+
+	typedef struct compound_geometric_object_struct {
+		geometric_object_list component_objects;
+	}		compound_geometric_object;
+
+	typedef struct cylinder_struct {
+		vector3		axis;
+		number		radius;
+		number		height;
+		enum {
+			CYLINDER_SELF, WEDGE, CONE
+		}		which_subclass;
+		union {
+			struct wedge_struct *wedge_data;
+			struct cone_struct *cone_data;
+		}		subclass;
+	}		cylinder;
+
+	typedef struct cone_struct {
+		number		radius2;
+	}		cone;
+
+	typedef struct wedge_struct {
+		number		wedge_angle;
+		vector3		wedge_start;
+		vector3		e1;
+		vector3		e2;
+	}		wedge;
+
+	typedef struct sphere_struct {
+		number		radius;
+	}		sphere;
+
+	typedef struct block_struct {
+		vector3		e1;
+		vector3		e2;
+		vector3		e3;
+		vector3		size;
+		matrix3x3	projection_matrix;
+		enum {
+			BLOCK_SELF, ELLIPSOID
+		}		which_subclass;
+		union {
+			struct ellipsoid_struct *ellipsoid_data;
+		}		subclass;
+	}		block;
+
+	typedef struct {
+		int		num_items;
+		vector3	       *items;
+	} vector3_list;
+
+	typedef struct {
+		int		num_items;
+		number	       *items;
+	} number_list;
+
+	typedef struct prism_struct {
+		vector3_list	vertices;
+		number		height;
+		vector3		axis;
+		number		sidewall_angle;
+		vector3_list	vertices_p;
+		vector3_list	top_polygon_diff_vectors_p;
+		vector3_list	top_polygon_diff_vectors_scaled_p;
+		vector3_list	vertices_top_p;
+		vector3_list	vertices_top;
+		vector3		centroid;
+		number_list	workspace;
+		matrix3x3	m_c2p;
+		matrix3x3	m_p2c;
+	}		prism;
+
+	typedef struct ellipsoid_struct {
+		vector3		inverse_semi_axes;
+	}		ellipsoid;
+
+	typedef struct lattice_struct {
+		vector3		basis1;
+		vector3		basis2;
+		vector3		basis3;
+		vector3		size;
+		vector3		basis_size;
+		vector3		b1;
+		vector3		b2;
+		vector3		b3;
+		matrix3x3	basis;
+		matrix3x3	metric;
+	}		lattice;
+
+	/******* Input variables *******/
+	extern integer dimensions;
+	extern void* default_material;
+	extern vector3 geometry_center;
+	extern lattice geometry_lattice;
+	extern geometric_object_list geometry;
+	extern boolean ensure_periodicity;
+
+	/******* Output variables *******/
+
+	/******* class copy function prototypes *******/
+
+	extern void	lattice_copy(const lattice * o0, lattice * o);
+	extern void	ellipsoid_copy(const ellipsoid * o0, ellipsoid * o);
+	extern void	prism_copy(const prism * o0, prism * o);
+	extern void	block_copy(const block * o0, block * o);
+	extern void	sphere_copy(const sphere * o0, sphere * o);
+	extern void	wedge_copy(const wedge * o0, wedge * o);
+	extern void	cone_copy(const cone * o0, cone * o);
+	extern void	cylinder_copy(const cylinder * o0, cylinder * o);
+	extern void	compound_geometric_object_copy(const compound_geometric_object * o0, compound_geometric_object * o);
+	extern void	geometric_object_copy(const geometric_object * o0, geometric_object * o);
+
+	/******* class equal function prototypes *******/
+
+	extern boolean lattice_equal(const lattice * o0, const lattice * o);
+	extern boolean ellipsoid_equal(const ellipsoid * o0, const ellipsoid * o);
+	extern boolean prism_equal(const prism * o0, const prism * o);
+	extern boolean block_equal(const block * o0, const block * o);
+	extern boolean sphere_equal(const sphere * o0, const sphere * o);
+	extern boolean wedge_equal(const wedge * o0, const wedge * o);
+	extern boolean cone_equal(const cone * o0, const cone * o);
+	extern boolean cylinder_equal(const cylinder * o0, const cylinder * o);
+	extern boolean compound_geometric_object_equal(const compound_geometric_object * o0, const compound_geometric_object * o);
+	extern boolean geometric_object_equal(const geometric_object * o0, const geometric_object * o);
+
+	/******* class destruction function prototypes *******/
+
+	extern void	lattice_destroy(lattice o);
+	extern void	ellipsoid_destroy(ellipsoid o);
+	extern void	prism_destroy(prism o);
+	extern void	block_destroy(block o);
+	extern void	sphere_destroy(sphere o);
+	extern void	wedge_destroy(wedge o);
+	extern void	cone_destroy(cone o);
+	extern void	cylinder_destroy(cylinder o);
+	extern void	compound_geometric_object_destroy(compound_geometric_object o);
+	extern void	geometric_object_destroy(geometric_object o);
+
+
+#ifdef __cplusplus
+}				/* extern "C" */
+#endif				/* __cplusplus */
+
+#endif				/* CTL_IO_H */
+#ifndef LIBCTL_MAJOR_VERSION
+#  define LIBCTL_MAJOR_VERSION 4
+#  define LIBCTL_MINOR_VERSION 5
+#  define LIBCTL_BUGFIX_VERSION 1
+#endif
diff --git a/utils/ctlgeom.h b/utils/ctlgeom.h
index 546a241..d4fd6e5 100644
--- a/utils/ctlgeom.h
+++ b/utils/ctlgeom.h
@@ -46,7 +46,7 @@
 #define GEOMETRIC_OBJECT geometric_object
 #undef GEOMETRIC_OBJECT_LIST
 #define GEOMETRIC_OBJECT_LIST geometric_object_list
-#include <ctlgeom-types.h>
+#include <ctlgeom-types-swig.h>
 extern void display_geometric_object_info(int indentby, geometric_object o);
 #endif
 

From 896274e0d9b3c4d23e7e7f5dd7e758346b7c3977 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 13:43:05 -0800
Subject: [PATCH 17/37] update gitignore to exclude python extension generated
 files

---
 .gitignore | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index c4f0170..9d9e643 100644
--- a/.gitignore
+++ b/.gitignore
@@ -53,4 +53,12 @@ geom-ctl-io.c
 geomtst
 nlopt-constants.scm
 utils/test-prism
-*.dat
\ No newline at end of file
+*.dat
+
+/python/__pycache__
+/python/build
+/python/libctlgeom.egg-info
+/python/_libctlgeom.cpython*
+/python/libctlgeom_wrap.c
+/python/libctlgeom.py
+/python/todo.md
\ No newline at end of file

From 9ed3791c9e6470798a2d87563569d45788ad631c Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 13:44:11 -0800
Subject: [PATCH 18/37] Make bounding_box return actual coordinates; Get rid of
 Material object; get_volume() -> volume();

---
 python/README.md  |  2 --
 python/ctlgeom.py | 35 +++++++++++-------------
 python/test.ipynb | 68 +++++++++++------------------------------------
 3 files changed, 32 insertions(+), 73 deletions(-)

diff --git a/python/README.md b/python/README.md
index 4eb5fa1..5c61e75 100644
--- a/python/README.md
+++ b/python/README.md
@@ -13,13 +13,11 @@ This directory contains SWIG bindings to create a Python extension for libctl.
 **Using Conda Environment**
    ```bash
    conda activate my_env
-   chmod +x build.sh
    ./build.sh
    ```
 
 **Using System Python**
    ```bash
-   chmod +x build.sh
    ./build.sh
    ```
 
diff --git a/python/ctlgeom.py b/python/ctlgeom.py
index 4e3841f..fde8b0d 100644
--- a/python/ctlgeom.py
+++ b/python/ctlgeom.py
@@ -1,9 +1,11 @@
 import libctlgeom as geom
 from abc import ABC, abstractmethod
-from typing import Tuple, List, Literal
+from typing import Tuple, List, Literal, Any
 import dataclasses
 import numpy as np
 
+MATERIAL_TYPE = Any
+
 
 def make_vector3(x, y, z):
     v = geom.vector3()
@@ -27,13 +29,6 @@ def to_geom_object(self):
         return self.box
 
 
-@dataclasses.dataclass(frozen=True)
-class Material:
-    """Material properties."""
-
-    epsilon: float
-
-
 class GeometricObject(ABC):
     """Abstract base class for geometric objects."""
 
@@ -41,16 +36,18 @@ class GeometricObject(ABC):
     def to_geom_object(self):
         raise NotImplementedError
 
-    def get_volume(self) -> float:
+    def volume(self) -> float:
         return geom.geom_object_volume(self.to_geom_object())
 
     def debug_info(self) -> None:
         display_geom_object_info(self)
 
-    def get_bounding_box(self) -> Tuple[geom.vector3, geom.vector3]:
+    def bounding_box(
+        self,
+    ) -> Tuple[Tuple[float, float, float], Tuple[float, float, float]]:
         box = geom.geom_box()
         geom.geom_get_bounding_box(self.to_geom_object(), box)
-        return (box.low, box.high)
+        return ((box.low.x, box.low.y, box.low.z), (box.high.x, box.high.y, box.high.z))
 
 
 @dataclasses.dataclass(frozen=True)
@@ -65,7 +62,7 @@ class Cylinder(GeometricObject):
         axis: The axis of the cylinder.
     """
 
-    material: Material
+    material: MATERIAL_TYPE
     center: Tuple[float, float, float]
     radius: float
     height: float
@@ -95,7 +92,7 @@ class Wedge(GeometricObject):
         wedge_start: The starting direction vector of the wedge.
     """
 
-    material: Material
+    material: MATERIAL_TYPE
     center: Tuple[float, float, float]
     radius: float
     height: float
@@ -128,7 +125,7 @@ class Cone(GeometricObject):
         radius2: The radius at the top (0 for a perfect cone).
     """
 
-    material: Material
+    material: MATERIAL_TYPE
     center: Tuple[float, float, float]
     radius: float
     height: float
@@ -148,7 +145,7 @@ def to_geom_object(self):
 
 @dataclasses.dataclass(frozen=True)
 class Sphere(GeometricObject):
-    material: Material
+    material: MATERIAL_TYPE
     center: Tuple[float, float, float]
     radius: float
 
@@ -169,7 +166,7 @@ class Block(GeometricObject):
         size: Size along each basis vector.
     """
 
-    material: Material
+    material: MATERIAL_TYPE
     center: Tuple[float, float, float]
     e1: Tuple[float, float, float]
     e2: Tuple[float, float, float]
@@ -200,7 +197,7 @@ class Ellipsoid(GeometricObject):
         size: Size along each basis vector.
     """
 
-    material: Material
+    material: MATERIAL_TYPE
     center: Tuple[float, float, float]
     e1: Tuple[float, float, float]
     e2: Tuple[float, float, float]
@@ -230,7 +227,7 @@ class Prism(GeometricObject):
         center: Optional center point. If None, computed automatically from vertices.
     """
 
-    material: Material
+    material: MATERIAL_TYPE
     vertices: List[Tuple[float, float, float]]
     height: float
     axis: Tuple[float, float, float]
@@ -272,7 +269,7 @@ class SlantedPrism(GeometricObject):
         center: Optional center point. If None, computed automatically from vertices.
     """
 
-    material: Material
+    material: MATERIAL_TYPE
     vertices: List[Tuple[float, float, float]]
     height: float
     axis: Tuple[float, float, float]
diff --git a/python/test.ipynb b/python/test.ipynb
index 3b43c28..1aae64a 100644
--- a/python/test.ipynb
+++ b/python/test.ipynb
@@ -37,8 +37,7 @@
     {
      "data": {
       "text/plain": [
-       "(<libctlgeom.vector3; proxy of <Swig Object of type 'vector3 *' at 0x1049e17d0> >,\n",
-       " <libctlgeom.vector3; proxy of <Swig Object of type 'vector3 *' at 0x103f30210> >)"
+       "((-1.0, -0.5, -1.0), (1.0, 1.5, 1.0))"
       ]
      },
      "execution_count": 3,
@@ -47,7 +46,7 @@
     }
    ],
    "source": [
-    "sphere.get_bounding_box()"
+    "sphere.bounding_box()"
    ]
   },
   {
@@ -70,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -90,7 +89,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
@@ -126,7 +125,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.22838377952575684 seconds\n"
+      "Time taken: 0.2257089614868164 seconds\n"
      ]
     },
     {
@@ -177,27 +176,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Time taken: 0.34314489364624023 seconds\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x800 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "np.random.seed(42)\n",
     "spheres = []\n",
@@ -238,33 +219,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of spheres: 1000, Time taken: 0.26 seconds\n",
-      "Number of spheres: 2000, Time taken: 0.30 seconds\n",
-      "Number of spheres: 3000, Time taken: 0.36 seconds\n",
-      "Number of spheres: 5000, Time taken: 0.57 seconds\n",
-      "Number of spheres: 7000, Time taken: 0.87 seconds\n",
-      "Number of spheres: 10000, Time taken: 1.54 seconds\n",
-      "Number of spheres: 15000, Time taken: 3.34 seconds\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# benchmark\n",
     "sphere_counts = [1000, 2000, 3000, 5000, 7000, 10000, 15000]\n",
@@ -302,6 +259,13 @@
     "plt.title('Performance Scaling with Number of Spheres')\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

From 2d5008d6f3be01c41fff0fc62e63af2e665c489f Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 16:39:42 -0800
Subject: [PATCH 19/37] Improve docs, make things more pythonic.

---
 python/ctlgeom.py | 118 ++++++++++++++++++++++++++--------------------
 python/test.ipynb | 113 +++++++++++++++-----------------------------
 2 files changed, 106 insertions(+), 125 deletions(-)

diff --git a/python/ctlgeom.py b/python/ctlgeom.py
index fde8b0d..cf7ff11 100644
--- a/python/ctlgeom.py
+++ b/python/ctlgeom.py
@@ -3,11 +3,22 @@
 from typing import Tuple, List, Literal, Any
 import dataclasses
 import numpy as np
+import copy
 
 MATERIAL_TYPE = Any
 
 
-def make_vector3(x, y, z):
+def make_vector3(x, y, z) -> geom.vector3:
+    """Create a vector3 object.
+
+    Args:
+        x: The x-coordinate.
+        y: The y-coordinate.
+        z: The z-coordinate.
+
+    Returns:
+        A vector3 object.
+    """
     v = geom.vector3()
     v.x = x
     v.y = y
@@ -17,6 +28,13 @@ def make_vector3(x, y, z):
 
 @dataclasses.dataclass(frozen=True)
 class BoundingBox:
+    """A bounding box.
+
+    Attributes:
+        low: The lower corner of the box.
+        high: The upper corner of the box.
+    """
+
     low: Tuple[float, float, float]
     high: Tuple[float, float, float]
 
@@ -25,7 +43,8 @@ def __post_init__(self):
         self.box.low = make_vector3(*self.low)
         self.box.high = make_vector3(*self.high)
 
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geom_box:
+        """Convert the bounding box to a geometric object."""
         return self.box
 
 
@@ -33,18 +52,25 @@ class GeometricObject(ABC):
     """Abstract base class for geometric objects."""
 
     @abstractmethod
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geometric_object:
         raise NotImplementedError
 
     def volume(self) -> float:
+        """Get the volume of the geometric object."""
         return geom.geom_object_volume(self.to_geom_object())
 
     def debug_info(self) -> None:
+        """Display debug information about the geometric object."""
         display_geom_object_info(self)
 
     def bounding_box(
         self,
     ) -> Tuple[Tuple[float, float, float], Tuple[float, float, float]]:
+        """Get the bounding box of the geometric object.
+
+        Returns:
+            A tuple of the lower and upper corners of the bounding box.
+        """
         box = geom.geom_box()
         geom.geom_get_bounding_box(self.to_geom_object(), box)
         return ((box.low.x, box.low.y, box.low.z), (box.high.x, box.high.y, box.high.z))
@@ -68,7 +94,8 @@ class Cylinder(GeometricObject):
     height: float
     axis: Tuple[float, float, float]
 
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geometric_object:
+        """Convert the cylinder to a geometric object."""
         return geom.make_cylinder(
             self.material,
             make_vector3(*self.center),
@@ -100,7 +127,8 @@ class Wedge(GeometricObject):
     wedge_angle: float
     wedge_start: Tuple[float, float, float]
 
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geometric_object:
+        """Convert the wedge to a geometric object."""
         return geom.make_wedge(
             self.material,
             make_vector3(*self.center),
@@ -132,7 +160,8 @@ class Cone(GeometricObject):
     axis: Tuple[float, float, float]
     radius2: float
 
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geometric_object:
+        """Convert the cone to a geometric object."""
         return geom.make_cone(
             self.material,
             make_vector3(*self.center),
@@ -149,7 +178,8 @@ class Sphere(GeometricObject):
     center: Tuple[float, float, float]
     radius: float
 
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geometric_object:
+        """Convert the sphere to a geometric object."""
         return geom.make_sphere(self.material, make_vector3(*self.center), self.radius)
 
 
@@ -173,7 +203,8 @@ class Block(GeometricObject):
     e3: Tuple[float, float, float]
     size: Tuple[float, float, float]
 
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geometric_object:
+        """Convert the block to a geometric object."""
         return geom.make_block(
             self.material,
             make_vector3(*self.center),
@@ -204,7 +235,8 @@ class Ellipsoid(GeometricObject):
     e3: Tuple[float, float, float]
     size: Tuple[float, float, float]
 
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geometric_object:
+        """Convert the ellipsoid to a geometric object."""
         return geom.make_ellipsoid(
             self.material,
             make_vector3(*self.center),
@@ -233,7 +265,8 @@ class Prism(GeometricObject):
     axis: Tuple[float, float, float]
     center: Tuple[float, float, float] = None
 
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geometric_object:
+        """Convert the prism to a geometric object."""
         # Convert vertices list to array of vector3
         vertex_array = [make_vector3(*v) for v in self.vertices]
 
@@ -276,7 +309,10 @@ class SlantedPrism(GeometricObject):
     sidewall_angle: float
     center: Tuple[float, float, float] = None
 
-    def to_geom_object(self):
+    def to_geom_object(self) -> geom.geometric_object:
+        """Convert the slanted prism to a geometric object."""
+        raise NotImplementedError
+        # This is not working yet
         # Convert vertices list to array of vector3
         vertex_array = [make_vector3(*v) for v in self.vertices]
 
@@ -301,65 +337,36 @@ def to_geom_object(self):
             )
 
 
-@dataclasses.dataclass(frozen=False)
-class GroupObject:
+@dataclasses.dataclass
+class ObjectGroup:
     """A group of geometric objects."""
 
     objects: List[GeometricObject]
 
     def __post_init__(self):
-        self.objects_map = {
-            obj.to_geom_object(): obj for obj in self.objects
-        }  # Add this line
         geom_objects = [obj.to_geom_object() for obj in self.objects]
-        self.geom_list = make_geom_object_list(geom_objects)
+        self.geom_list = copy.copy(make_geom_object_list(geom_objects))
         self.bounding_box = make_geom_box(
             (float("-inf"), float("-inf"), float("-inf")),
             (float("inf"), float("inf"), float("inf")),
         )
-        self.geom_box_tree = None
+        self.geom_box_tree = self._create_tree_object()
 
-    def to_tree_object(self) -> Literal["geom.geom_box_tree"]:
+    def _create_tree_object(self) -> Literal["geom.geom_box_tree"]:
         """Create a tree object from the group of geometric objects."""
         return geom.create_geom_box_tree0(self.geom_list, self.bounding_box)
 
-    def get_tree_object(self) -> Literal["geom.geom_box_tree"]:
-        """Get the tree object from the group of geometric objects."""
-        if self.geom_box_tree is None:
-            self.geom_box_tree = self.to_tree_object()
-        return self.geom_box_tree
-
-    def query_object_at_point(
-        self, point: Tuple[float, float, float]
-    ) -> GeometricObject:
-        """Query the object at a point."""
-        shiftby = geom.vector3()
-        return geom.object_of_point0(self.geom_list, make_vector3(*point), shiftby)
-
-    def query_object_at_point_in_tree(
-        self, point: Tuple[float, float, float], precedence: int
-    ) -> GeometricObject:
-        """Unstable. Not outputting object as expected."""
-        shiftby = geom.vector3()
-        precedence_ptr = geom.new_intp()
-        geom.intp_assign(precedence_ptr, precedence)
-        return geom.object_of_point_in_tree(
-            make_vector3(*point), self.get_tree_object(), shiftby, precedence_ptr
-        )
-
-    def query_material_at_point(self, point: Tuple[float, float, float]) -> Material:
+    def material_at(self, point: Tuple[float, float, float]) -> MATERIAL_TYPE:
         """Query the material at a point.
 
         Args:
             point: The point to query.
         """
-        tree = self.get_tree_object()
-        return geom.material_of_point_in_tree(make_vector3(*point), tree)
+        return geom.material_of_point_in_tree(make_vector3(*point), self.geom_box_tree)
 
     def __del__(self):
         # Clean up the tree when the object is destroyed
-        if hasattr(self, "tree"):
-            geom.destroy_geom_box_tree(self.tree)
+        geom.destroy_geom_box_tree(self.geom_box_tree)
 
 
 def point_is_in_object(
@@ -374,7 +381,7 @@ def point_is_in_object(
     return bool(geom.point_in_objectp(make_vector3(*point), object.to_geom_object()))
 
 
-def display_geom_object_info(object: GeometricObject) -> None:
+def display_geom_object_info(object: GeometricObject):
     """Display information about the geometric object.
 
     Args:
@@ -383,14 +390,23 @@ def display_geom_object_info(object: GeometricObject) -> None:
     geom.display_geometric_object_info(0, object.to_geom_object())
 
 
-def make_geom_object_list(objects: list[geom.geometric_object]):
+def make_geom_object_list(
+    objects: list[geom.geometric_object],
+) -> geom.geometric_object_list:
+    """Create a list of geometric objects.
+
+    Args:
+        objects: The geometric objects to create a list of.
+    """
     objects_list = geom.geometric_object_list()
     objects_list.num_items = len(objects)
     objects_list.set_items(objects)  # Use set_items instead of direct assignment
     return objects_list
 
 
-def make_geom_box(low: Tuple[float, float, float], high: Tuple[float, float, float]):
+def make_geom_box(
+    low: Tuple[float, float, float], high: Tuple[float, float, float]
+) -> geom.geom_box:
     """Create a geometric box.
 
     Args:
diff --git a/python/test.ipynb b/python/test.ipynb
index 1aae64a..8d4d521 100644
--- a/python/test.ipynb
+++ b/python/test.ipynb
@@ -23,7 +23,7 @@
     }
    ],
    "source": [
-    "sphere = Sphere(Material(1), (0, 0.5, 0), 1)\n",
+    "sphere = Sphere(1, (0, 0.5, 0), 1)\n",
     "a = point_is_in_object((0.5, 0, 0), sphere)\n",
     "b = point_is_in_object((1.5, 0, 0), sphere)\n",
     "print(a, b)"
@@ -69,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -84,48 +84,45 @@
    "source": [
     "actual_volume = 4/3 * np.pi * 1**3\n",
     "print(f\"Actual volume: {actual_volume}\")\n",
-    "print(f\"Calculated volume: {sphere.get_volume()}\")"
+    "print(f\"Calculated volume: {sphere.volume()}\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Material(epsilon=1)\n",
-      "Material(epsilon=2)\n",
-      "foo\n",
-      "bar\n"
+      "(1-1j)\n",
+      "{'eps': 2}\n",
+      "foo\n"
      ]
     }
    ],
    "source": [
-    "sphere1 = Sphere(Material(1), (1, 0, 0), 0.1)\n",
-    "sphere2 = Sphere(Material(2), (2, 0, 0), 0.1)\n",
+    "sphere1 = Sphere(1 - 1j, (1, 0, 0), 0.1)\n",
+    "sphere2 = Sphere({\"eps\": 2}, (2, 0, 0), 0.1)\n",
     "sphere3 = Sphere(\"foo\", (3, 0, 0), 0.1)\n",
-    "sphere4 = Sphere(\"bar\", (4, 0, 0), 0.1)\n",
-    "group = GroupObject([sphere1, sphere2, sphere3, sphere4])\n",
+    "group = ObjectGroup([sphere1, sphere2, sphere3])\n",
     "\n",
-    "print(group.query_material_at_point((1, 0, 0)))\n",
-    "print(group.query_material_at_point((2, 0, 0)))\n",
-    "print(group.query_material_at_point((3, 0, 0)))\n",
-    "print(group.query_material_at_point((4, 0, 0)))"
+    "print(group.material_at((1, 0, 0)))\n",
+    "print(group.material_at((2, 0, 0)))\n",
+    "print(group.material_at((3, 0, 0)))\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.2257089614868164 seconds\n"
+      "Time taken: 0.219832181930542 seconds\n"
      ]
     },
     {
@@ -147,7 +144,7 @@
     "sphere1 = Sphere(material=1, center=(0, -0.5, 0), radius=0.5)\n",
     "sphere2 = Sphere(material=2, center=(0, 0.5, 0), radius=1)\n",
     "block = Block(material=3, center=(0.5, 0.5, 0), e1=(1, 1, 0), e2=(1, -1, 0), e3=(0, 0, 1), size=(1, 1, 1))\n",
-    "group = GroupObject([sphere2, sphere1, block])\n",
+    "group = ObjectGroup([sphere2, sphere1, block])\n",
     "\n",
     "# Create a grid of points\n",
     "x = np.linspace(-1, 1, 500)\n",
@@ -155,7 +152,7 @@
     "xx, yy = np.meshgrid(x, y)\n",
     "\n",
     "def get_epsilon(x, y):\n",
-    "    mat = group.query_material_at_point((x, y, 0))\n",
+    "    mat = group.material_at((x, y, 0))\n",
     "    return 0 if mat is None else mat\n",
     "point_in_object_vec = np.vectorize(get_epsilon)\n",
     "\n",
@@ -176,9 +173,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time taken: 0.2346351146697998 seconds\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxkAAAK7CAYAAACeQEKuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd5gU5f3AP1O2Xu+9w9F7PQQEsSAq9oqxd40aS2JMURPjz2g0RsUWNUZj712MioXee+eA47jC9bp15v39sXB3y+7e7V4BDPt5nntgZ955593ZmXfeb5eEEIIwYcKECRMmTJgwYcKE6SXkIz2AMGHChAkTJkyYMGHC/G8RFjLChAkTJkyYMGHChAnTq4SFjDBhwoQJEyZMmDBhwvQqYSEjTJgwYcKECRMmTJgwvUpYyAgTJkyYMGHChAkTJkyvEhYywoQJEyZMmDBhwoQJ06uEhYwwYcKECRMmTJgwYcL0KmEhI0yYMGHChAkTJkyYML1KWMgIEyZMmDBhwoQJEyZMrxIWMsKECdNj1qxZw2mnnUZ2djYWi4X4+HiKior4z3/+47f9qlWrOPHEE4mMjCQ2NpZzzjmH4uJiv22feuopBg4ciMlkIi8vjwceeACXy+XTbv/+/VxxxRUkJiZitVopKiri22+/DWr8V1xxBZIktf0ZjUYKCgq46667aGxsDP5C9DLTpk1j2rRpR+z8/pg3bx4nn3wy6enpmEwm0tPTmTZtGg8//HC3+nvllVeQJIkVK1b08kjDhAkTJsyRJCxkhAkTpsfU19eTlZXFQw89xBdffMGrr75Kbm4uv/jFL3jwwQe92m7ZsoVp06bhdDp55513ePnll9m2bRtTpkyhqqrKq+1f/vIXbrvtNs455xzmzZvHTTfdxEMPPcTNN9/s1c7hcDBjxgy+/fZb/vGPf/Dxxx+TkpLCzJkz+eGHH4L6DhaLhcWLF7N48WI++eQTpk+fzmOPPcZ5553Xs4vzP8Rzzz3HzJkziY6O5umnn2bevHn89a9/ZdCgQbz33ntHenhhwoQJE+ZoQoQJEyZMHzFhwgSRlZXlte38888XiYmJoqGhoW3b7t27hcFgEL/+9a/btlVXVwuz2Syuu+46r+P/8pe/CEmSxMaNG9u2zZ07VwBi0aJFbdtcLpcYPHiwGD9+fJfjvPzyy0VERITP9unTpwtAFBcXd/1l+4Djjz9eHH/88Ufk3P7Izs4WU6dO9btP07Ru9fmvf/1LAGL58uU9GVqXtLS09Gn/YcKECRPGm7AlI0yYMH1GYmIiqqq2fXa73Xz22Wece+65REdHt23Pyclh+vTpfPjhh23bvvrqK+x2O1deeaVXn1deeSVCCD766KO2bR9++CEDBgygqKiobZuqqlx66aUsW7aMffv2dWv8Y8eOBaCysrJt244dO7jyyivp378/VquVjIwMzjjjDNavX+917Pfff48kSbz55pv87ne/Iz09nejoaE488US2bt3q1VYIwSOPPEJOTg5ms5nRo0fz5Zdf+h1TSUkJl156KcnJyZhMJgYNGsRjjz2GruttbXbv3o0kSTz66KP89a9/JTc3F4vFwrRp09i2bRsul4t77rmH9PR0YmJiOPvss9m/f3+X16Ompoa0tDS/+2TZ+3UiSRK33HILzz//PIWFhZhMJgYPHsxbb73l9/impiZuvPFGEhMTSUhI4JxzzqGsrMyn3dtvv01RURERERFERkZyyimnsHr1aq82V1xxBZGRkaxfv56TTz6ZqKgoZsyYAYDT6eTBBx9sc8FLSkriyiuv9LGifffdd0ybNo2EhAQsFgvZ2dmce+65tLa2dnmdwoQJEyZM2F0qTJgwvYiu67jdbqqqqnjmmWeYN28ev/nNb9r279y5E5vNxvDhw32OHT58ODt27MButwOwYcMGAIYNG+bVLi0tjcTExLb9B9sG6hNg48aN3fo+u3btQlVV8vPz27aVlZWRkJDAww8/zFdffcXcuXNRVZUJEyb4CA8A9957L3v27OHFF1/khRdeYPv27ZxxxhlomtbW5oEHHuA3v/kNJ510Eh999BE33ngj1157rU9/VVVVTJo0ia+//po///nPfPLJJ5x44oncdddd3HLLLT7nnjt3LgsXLmTu3Lm8+OKLbNmyhTPOOIOrr76aqqoqXn75ZR555BG++eYbrrnmmi6vR1FREe+//z73338/a9eu9foO/vjkk0948skn+dOf/sR7771HTk4OF198sV/XqmuuuQaDwcAbb7zBI488wvfff8+ll17q1eahhx7i4osvZvDgwbzzzju89tprNDU1MWXKFDZt2uTV1ul0Mnv2bE444QQ+/vhjHnjgAXRd58wzz+Thhx/mkksu4fPPP+fhhx/mv//9L9OmTcNmswEeIe20007DaDTy8ssv89VXX/Hwww8TERGB0+ns8jqFCRMmTBjC7lJhwoTpPa6//noBCEAYjUbxzDPPeO1fuHChAMSbb77pc+xDDz0kAFFWViaEEOLaa68VJpPJ73kKCwvFySef3PbZYDCI66+/3qfdokWLBCDeeOONTsd90F3K5XIJl8slqqurxbPPPitkWRb33ntvp8e63W7hdDpF//79xa9+9au27fPnzxeAmDVrllf7d955RwBi8eLFQggh6urqhNlsFmeffbZXu4PXqqO71D333CMAsXTpUq+2N954o5AkSWzdulUIIcSuXbsEIEaMGOHlxvTEE08IQMyePdvr+Ntvv10AXi5s/tixY4cYOnRo229ssVjEjBkzxNNPPy2cTqdX24P7KyoqvK7VwIEDRb9+/dq2HXSXuummm7yOf+SRRwQgysvLhRBClJSUCFVVxS9/+Uuvdk1NTSI1NVVccMEFbdsuv/xyAYiXX37Zq+2bb74pAPH+++97bV++fLkA2u7X9957TwBizZo1nV6PMGHChAkTmLAlI0yYML3Gvffey/Lly/n888+56qqruOWWW/jb3/7m006SpIB9dNwXbLtQ2/qjpaUFg8GAwWAgMTGRG2+8kQsvvJC//OUvXu3cbjcPPfQQgwcPxmg0oqoqRqOR7du3s3nzZp9+Z8+e7fX5oHVlz549ACxevBi73c6cOXO82k2aNImcnByvbd999x2DBw9m/PjxXtuvuOIKhBB89913XttnzZrl5cY0aNAgAE477TSvdge3l5SU+Lky7RQUFLB27Vp++OEHHnjgAU488USWL1/OLbfcQlFRUZsV6iAzZswgJSWl7bOiKFx44YXs2LGD0tJSr7ZdXad58+bhdru57LLLcLvdbX9ms5njjz+e77//3me85557rtfnzz77jNjYWM444wyvPkaOHElqampbHyNHjsRoNHLdddfx73//O2DmszBhwoQJExi16yZhwoQJExzZ2dlkZ2cDngUuwG9/+1suv/xykpKSSEhIADy+/YdSW1uLJEnExsYCkJCQgN1up7W1FavV6tN2zJgxbZ8TEhIC9gkQHx/f5dgtFgs//vgjABUVFTz22GO8+eabDB8+nHvuuaet3R133MHcuXP5zW9+w/HHH09cXByyLHPNNde0udt05OB3PojJZAJoa3tw3KmpqT7HHrqtpqaG3Nxcn3bp6elefR3k0O9tNBo73X6okOAPWZaZOnUqU6dOBTzC2dVXX83bb7/Nyy+/zE033RRw/B231dTUkJmZ2ba9q+t0MC5m3LhxAcfVEavV6hX3c7CP+vr6tu97KNXV1YBHmPrmm2945JFHuPnmm2lpaSE/P59bb72V2267ze+xYcKECRPGm7CQESZMmD5j/PjxPPfccxQXF5OUlERBQQEWi8UnSBpg/fr19OvXD7PZDLTHYqxfv54JEya0tauoqKC6upqhQ4e2bRs2bFjAPgGvtoGQZbkt0BvgpJNOYsyYMTzwwAPMmTOHrKwsAP7zn/9w2WWX8dBDD3kdX11d3SYghcLBxXVFRYXPvoqKCi+hIiEhgfLycp92BwOkExMTQz5/T4mIiOC3v/0tb7/9tlecDAT+TuArVHTFwe92MLajK/xZrw4GlX/11Vd+j4mKimr7/5QpU5gyZQqaprFixQqeeuopbr/9dlJSUrjoootCGnuYMGHCHIuE3aXChAnTZ8yfPx9ZltsCp1VV5YwzzuCDDz6gqamprV1JSQnz58/nnHPOads2c+ZMzGYzr7zyilefB4u3nXXWWW3bzj77bLZs2cLSpUvbtrndbv7zn/8wYcKENk1/KJhMJubOnYvdbveq9SFJUpuW/SCff/55tzNYTZw4EbPZzOuvv+61fdGiRW2uQgeZMWMGmzZtYtWqVV7bX331VSRJYvr06d0aQ7D4E3CANjexQ6/zt99+65WZS9M03n77bQoKCrysGMFwyimnoKoqO3fuZOzYsX7/uuL000+npqYGTdP8Hj9gwACfYxRFYcKECcydOxfA59qHCRMmTBj/hC0ZYcKE6THXXXcd0dHRjB8/npSUFKqrq3n33Xd5++23ufvuu0lKSmpr+8ADDzBu3DhOP/107rnnHux2O3/84x9JTEzkzjvvbGsXHx/P73//e/7whz8QHx/PySefzPLly7n//vu55pprGDx4cFvbq666irlz53L++efz8MMPk5yczDPPPMPWrVv55ptvuv29jj/+eGbNmsW//vUv7rnnHvLy8jj99NN55ZVXGDhwIMOHD2flypU8+uijIS+aDxIXF8ddd93Fgw8+yDXXXMP555/P3r17uf/++33cjX71q1/x6quvctppp/GnP/2JnJwcPv/8c5555hluvPFGCgsLu/1dg2HIkCHMmDGDU089lYKCAux2O0uXLuWxxx4jJSWFq6++2qt9YmIiJ5xwAn/4wx+IiIjgmWeeYcuWLQHT2HZGbm4uf/rTn/jd735HcXExM2fOJC4ujsrKSpYtW0ZERAQPPPBAp31cdNFFvP7668yaNYvbbruN8ePHYzAYKC0tZf78+Zx55pmcffbZPPfcc3z33XdtVeztdjsvv/wyACeeeGLIYw8TJkyYY5IjHXkeJkyYnz8vv/yymDJlikhMTBSqqorY2Fhx/PHHi9dee81v+xUrVogZM2YIq9UqoqOjxVlnnSV27Njht+0//vEPUVhYKIxGo8jOzhb33XefTyYjIYSoqKgQl112mYiPjxdms1lMnDhR/Pe//w1q/IGK8QkhxPr164Usy+LKK68UQniyQV199dUiOTlZWK1WMXnyZPHTTz/5FM47mF3q3Xff9ervYOanf/3rX23bdF0X//d//yeysrKE0WgUw4cPF59++qnfYnx79uwRl1xyiUhISBAGg0EMGDBAPProo15ZpA6e49FHH/U6NtCYgi2I9/zzz4tzzjlH5OfnC6vVKoxGoygoKBA33HCD2Lt3r1dbQNx8883imWeeEQUFBcJgMIiBAweK119/PahzHxzr/PnzvbZ/9NFHYvr06SI6OlqYTCaRk5MjzjvvPPHNN9+0tens93S5XOJvf/ubGDFihDCbzSIyMlIMHDhQXH/99WL79u1CCCEWL14szj77bJGTkyNMJpNISEgQxx9/vPjkk086vT5hwoQJE6YdSQghjpyIEyZMmDBh/heRJImbb76Zp59++kgPJUyYMGHCHAHCMRlhwoQJEyZMmDBhwoTpVcJCRpgwYcKECRMmTJgwYXqVcOB3mDBhwoTpdcKeuGHChAlzbBO2ZIQJEyZMmDBhwoQJ8zPm/vvvR5Ikrz9/BVEPJ2FLRpgwYcKECRMmTJgwP3OGDBnilbZdUZQjOJqwkBEmTJgwYcKECRMmzM8eVVWPuPWiI8eUkKHrOmVlZURFRSFJ0pEeTpgwYcKECRMmzDGPEIKmpibS09OR5aPPk99ut+N0Og/7eYUQPutVk8mEyWTy23779u2kp6djMpmYMGECDz30EPn5+YdjqH45pupklJaWkpWVdaSHESZMmDBhwoQJE+YQ9u7dS2Zm5pEehhd2u528nEgq9muH/dyRkZE0Nzd7bbvvvvu4//77fdp++eWXtLa2UlhYSGVlJQ8++CBbtmxh48aNJCQkHKYRe3NMCRkNDQ3ExsYymVmoGBATh9F0VwvT0rb7bf99eX+i/haBtGR9t85X8soQJmXvItnUFFT7aNXGENM+TrSGLi0/U59NjSvSa9u68zNwl1WE3JdsNlF648iQj/NHZJmOsUFv++yIUxDn1nBC2rZu9bf2zBSIi8adEIFm8vY1lJ0ahno72ub233P3n8ZzzozFAfvThcTSB8aiOPWAbYLBtG43rkHZ7D3JzJBJOymM3N+27/vy/ugfJAIQUelCcns/ci1pRoQM1eM17pv6EedF1vN0XS4aHu3Fa1vHk3XZph6ND0mC0YPQrAaE7N+K15RtpHaoQEm0d/s0ui4h7TdR8Od16HZHt/vpLkp8HDvu6gfJDiTpyE9tbpuKucRI5iNLj/RQukSJjkIbkI3bavDa7opUsF/RQEZUPRtX5WGq6lrLaGoQJC2px5lspelmzwsyI6qeaIMdo+ym2W1mVUn3FD6WFVZSnvVcz33/GYTV5Oq0fVOrkezLNyGNGIQWZUBXuh7/+Y/N47Lo/X73vdMcx/+tPjX0gQeBEBL5N2+l5ZRh2ONldBWcUYGt7m9f8wS5hkif7cO+uALrHm9HhazXi9H2V/m03XvPBHKn7GFE7D4AviwZjC7azylJgplZm5ElwabGNLYszyX3j8s6/R7KgAJc8VZ0o39/cEkIFJvb03ZXJVp1daf9dUXLmWOZfe98EtRGn30uofLWvaeiONrneEkXKD+t9dvX/usn4Lb6bs/+sAz37r2e41WV4vtHoyc7UJSevTvcTUait6gkPxf8HCEZjLy87idilfaBVmktXHXjDdBL017ZcSZWXvGi17Z1DgcfN44Kuo8SWzzVJzYgJg7zeV8fitvtYMnCh6mvrycmJqZbY+4rGhsbiYmJYc/KXKKjDp+VpbFJJ2fMbvbu3Ut0dHTb9s4sGR1paWmhoKCAX//619xxxx19OdSAHFPuUgdNTioGXGcdx95TYU7/jYDBb/tT+u/m9SuLyEo9DsvHnU+qHVFiY9h1+xBOHbacaNUesP9DcWCgxCCxSi1hmiW0iWumcSfL7HmUONqlVVU2gRTcuTsiS0YUkznk4w4lolxgaXGjuNq/i3k/7F+eySdjYjl/wOqQ+1RlIyIiEi3C6nXztqYa0IwSsktgyU1q265n65giA18DXUioBjOK3rMXhZKZhT05CilCYVhqHQd/8/e2jcSwIorkyoMLbpPPUxdz4L0vbTDzZ+uFZM54hXuzS9r2j0us4Ka5V9D/Fv8vIaVfHvgxL+t7ShEOB7LZjJSTiSM2ms6meT3OhCG7Fej+by8DIhJUxYwu9eyadgfFaEXJAzCh1ZqQ7Z24RUogpXVfoAoGoxVcGFC78RwebhTVghYd5XV7NmUbqZrsYk5hMQC1YxKobYrAaVexbLAE7Ct+n5PaqanUjnUzp3Cdz36HrtNiaGRHRRJChOa6au9vpPnyqSQsreKEgaXEG1o6bV9uj6F8wEBccVHIihxUSkVLpBpwMWFBRbb2fH70hxASqmTAnWjFley5Lp09s1FRMtEG33HKFjOKyXuiUWUj0iH3Ydndk0ieXsH41P04dAsrarJxSlEIvIWMVfZCRsTvY1RkNe7JEZTeezyZ/7fIqy9JVZHzcwBwJ0Yim9XOr/WBoShZKmpCIpJbw128u7Mj2r+f2cyWfwzj4DBz8/Z7zZmH8q9bHbg0BfeKONIWOTxCRoBnUjGZEYes39KW2FAabG3vU0k2IueDIhmDGm9nGK3QbFKxXDmVuFcCK8Q6IkkGz2/fQWC2azKqau41IUMxm7yegTUOBztETqfv00NJMbtY98DxpCx1oTqCex8cza7skVESkZ0I/b2NfuAGj46O9hIygiUiIoJhw4axfbt/Rfrh4JgSMjqyf7TKnIk/ddluzsTFvFc5hZyPg+9biozk3LO67tsf1a4oluoFTLOEdlOMNJnYp9V6CRkHUfrl0Tgy2Wtb1PZG9LWb29vExsCBLASS0Yix0TNTuS0SeojrI0mAoUlgrXQhu3xnvOQVDvaLSL6NLmRGNy0aHXHGqLQmyWhmAInmzPaJMSqursf9BzWG5Aia0xTcid5aVX1nJMkrgtPox+xyYmw28JvUc5k+9nUMkuf3mGl1sOTMxzn7hzuI/mIDeksLksGIHO3RYLoyYv1qZ802B3pVNZLZhCPj6NIM9QVKQjyOoVmAhrvZgLlaQbEFbi9kaI00oES6jwqrx9FGc4aRmpGCOWPbhdvpqdshFXa0JLFhw8CAx2pGmdqJTuaM8q+cMcluRsftpaolksYWM7oWvHZQSrOzP8pAZGkM83dbmJxdTIrJV4MNHgFjwZ58MjODnMQkqBhvIsNweOYN3/ML9DEDD8xlvYuelYzicKDVN7Rtyzu9mOEx+2jWTJS2xlJaFedznBASpVVxuDQFk+qxPliPq0bp3+7nLTW1oNXV48iMDXlczngLxFuQnRpycedt5eEDaSqMwW2W2HH6MyhScPfNyjHvAFBouxz5Jxm1wcHBJa9stSJZ2i+4oUUguw98EGBsEigL16O5PRvliAi04f1C+YpdosY6qZqqEvdK+7aOc/yhSAbf+9kkyVRMMJG0xoVi730FzxZnKjvsKSEdE63aOfesn/h+/SQvS1KYw4PD4WDz5s1MmTLliI3hmBQy5KhIdGPwiwrdKJCjotCbunZ7kgxGRHRET4YHgEO4MPWC9lOJjmb3hWlsuvkZr+15n1/LoF/HodXVgazgHpSLZmm/HeK2ely2GvKMOOIlRCgWQr39+EAkr3TQXJkMdwQnZOhCotwRA8J7ohKqRH0/JeD43G4Fm2bAonTuUtEbNOfCeaNW0ug2E63aqXdZkdxdHuaFpcqFeW4kjpddbUIGQLISwcJ/PM/JZVcgr9iMHBuDY0jn7ib2/imYTAao978A+1/DMTKPkqs1dF3CustAV4YUSYeIYgMtAwSK2c3Rqz/rBFlBCuD+JjQNeuANW3Wig0tGLA/5OMUJGb/dzpSIrl1gTsnczOd7htDc0r1VdfqzRlb9KoNTs/zf48vKs8l8Pvh5VFcllt/8BFa5ZxpqzS37aJRlg97lPSYBu26RkHeC2npgWyf3cZVuIlNoXnNFtdbiV5tdOiOadEMu0mKPm5ASF4cqeXzMS1riWF+a4fccuu4Zdc2iVJQO+pKSc9r/H1OsEfPfLQhV8nEHDQVJVRFu/5OmEhvD5pui2TX7+QNbQndbMRjdCMmEvmZT27Mj5WbiSI1qaxO9u/3dpdjdyMs2tn2WrVb0YQXs+qWE1FsmA39IEkpyIvYBaX53C1WiTJNoEs3EyyqRspkY2cLGW55h/G9vJGpv7wcoGyQNg6ThEsGnRD343pbdAkkIxFFspfhf4K677uKMM84gOzub/fv38+CDD9LY2Mjll19+xMZ0TAoZVS+lcsGABUG3v+DUBcwbNoj407sWMprPHMW03y/qsl1nNGlm/lw1mnsTV/b4ZdfwTiKbhj/js33Xaf/kvvFDWDLSiHb8iIAPf8wuJ/YmAw15Rzbbw7bmZJqmeBYtcobHKqOZZaqHdb6AkJdH82HFOC6Z3LPfJBjMVRLvrR6DdYeR0y9YxLKnR5PZy5P91+++wohHbiLjzR1BtXdkx0N2fK+O4WhGc8tYN4a2YI3YaqQ1S0GJP/wxJD1Ckjp9ds2b9+EuDz0mqyfIbkj9+yLKTs0lPwgh43+VlC+NWCu9FRvFFxpQo4JTdugFNpyAu1UlYnvgd8BVz93G+Zd8z31JnpgtTehMfeFuIrqYdpTEBEZ/4z/mpCNum0rEtq7fQQ35Cg3XDwEgebWzW4KGblTQp47A8ONav4LGkO8a+SL1hZD77cjGote5M3c0G8Z2/uwcRDOraFNHAGBaXcz23wzkrQv/wUWLr+vROLpCGVyIPcW/FQNAcgtuveoWAMpudLL5uNf6dDwA50Y2kmtYw4cNY4I+psQWT9WkeiwsQx46EGdyzxWwRxJN6GiH0eitidCsP6WlpVx88cVUV1eTlJTExIkTWbJkCTk5OX00wq45JoWMAIq/Tvk5uFOcaGkiQ1nBew1jAbj2+x+ZZK4E/D/YyYZGxKQZXU60ploX8Q6F2oGH/3Z5Y904jLtNqK0SGVRzwvoWiiLe5LoVvyD1lb7xi+4O9f2MCAUsxUYkHT7+ZBLJ9SGaMYLktdsf5+oTLyP68T7p/rAhmUxUXuP9wlJbBfH/Cs4v+VhFzcrEle1JJNDZs+vsl4aUn4rs1BDLu05eodXXY1y6Bdf4Ad3SOFqqBEkfbOJw51+xvhzHGzMmHRZFAsB5kRX0L/oncxZf67Xd3Wgk60vP/9WWdmFCN0jsPk9Ciegba+qbHx/P64bj2z4bA5wm+/1y9D37gta/azUmLBWhF/KqGWIkZpcbQ2P37gR9wlDULSVoNbWAx7pxyYbdnBm5FwgcBxQsqaYG1k+aEvI97hqSgzul71KYKmY3254dT+7HAsUe/LVLet1C4fYb2XbFs702lvKbHHw49inAOwJe6UvrTZge89Zbbx3pIfhwTAoZlpdieOPi8VwyMrhg7jfWjCfr/SNbNTEYTJIBq9weBHmypRarHFhzoKB3mfEBPOZ62Xl4JpcdLUks3VDQ9tlYpaK2SEgatJ4zgRfWOvmXcSIRFgf2W2zwQ3InvR3oo0bh9aUTAThz7GoiO9j8ZUlQeqmbxC9MRJR3fxGgqxJCos2XV20FqZurLUkTjHrjV/zz3Of9JgC4acsl2H9IJJqfmea9A2paKg3H5XBIQjQ0s0TrORMAiF60G3dF5WEZj7FGwambUBKP7muq5uXgTooO6rnVDwQE6wYZ45ABAIjdpegtAQKlhUBvacG0pQyA3NcyeLd0Muef5mv1rbJFkjWv3mub1OpAt9nZ8cRETojpXka+7mBscCPbeh6ACyC7BSPeuI2XznuWqQF0GCbJQJbinVJSlJlJ3CRhaPJehDriVfaPllEjOgkO6mw8Jo3WLA3r3sC/t9oS5GK5qQXh8r9ITrc04kxX2Vrm8bnX95sx1cvtsQkhoBmhOU3BYpQxV4c+p2omBfUQAWBWxB5iOnmXhcLpkev56oEh8H9JIQVJ60aF+CVGzm+8FSWp9xNGCE0ibp0CwhUwA6A/DI0aprr2pdzAGzay+sOhQccCHsr+X9p4dNgHDDL6ptjKUTVOj17DZ40jAx5/avRaomTPfdYUbeTGj+YAEG+1EWn0xAPpQqL10Yw+iR3pS3QE+mEUtA7nufqKY1LIMH+1EuOk42FkcO2FXUGxabhO9Na6GhucQWkIDzfNmolPFo/hhtmLe+xudbhYWJVPi9NIbUMEEcW+LlBCgbr+Cpb1Hk1WbaGJcQN2sYmuhQxTPUTsU3HESXyX0p9xqXtJM7cHP140ZAVf/DSZiPLujd2eoCJ6+UnqzA9bdLG/uxgbBa0lFlzRh0hHigjazUNzKkRsMCFcgVcnamYGtsFp1Bf4Lpx01fM7A0Stj4Be9PYx1QlcURK6n99KbQXdKCMSe+984NEGx23oHVdDJSUZd0qMT4rZrhCyhOOA64XJkYxcWd1pfNlBFytDeQU5rSN4PWkic8YvAeCdzaNx15gxVStkr/G1HMgREVx4/CLkIC2/25qTcWmhKXDcTQYspQboIGRbKyQ+Kh7OWfm+maxCQkD2V062n5HKVHPwN5+xQSZ6t++izmWREbndEzAAZEUg4pyw1zPvua2gm3yvreyQ2mI4ukOsoZX8SJ2tpOBuMGKulb3iL0LFGS2BANmtYuyBRVdJTKD8ogGYpeDdmztjo9PGGkcW56ev5IXC2X7n0ZhdvmnGDxK73YmpwUDV7F4ZjhdCl7qMZQyEqU5wQfEM3sn/lldzfmTyCYns11NJXhX8jyhk2HuikXdHPsPIAOlR4xQrwyUnJdYSNtoy0Q4EQ1plJ/0OPC8jjE4i5XYJfd34N/32VXDyDaQuUroliIb5+XBMChkAhhaP1rxfhG/e8I7YNAP9+pez+yrfrE3Snkj67U5Cq+q8j8NJvW5kYXk+/W9ZyktTxnNj/HKSlcPvB6kbZeROak9oZtnzIsKTAWbfynSMdVLQyVMjthnZtG1AUG3VVkHMbhc1EUb0RXGsmARjU73bOGMkXFEKhqbQzQ+NOQohxMJ1iVAkVl36d6+JuiMLh3/ARVEnULU6r8u+ZE0HTQTMV9+RyH1OzA0KtQO8pwXNAg6LhqIGIdk0q6T/bVGn+peW4eldxtIACKsJ2WxGtwenNZQdGjR6vxwlDeQDP2nsTid1/Y1oFs99JyRCzpwWKtHbFRKf79yNR01LBeOBgWg67tJ9Pm0kkwnXwIygajx0hiM7HpMsQxBJLACkRWsZXJzCmrc8xbEyX1IxfOM/lbJkMiFlpwNbu+xXFxLNmok1pRkIPbTvZKpUSVvovXhKWu2gsS4abg2pq26jSBJWqwObzYjLrmLyszbUTHKvZYk6eJ86ktyosb4nc9QbkcvUAwt73+MNLYDW+dwmSwLVoGEsUXtFieGMkdCNCgk9EDL0vHRW3/sMPUmrDVDubkYD/lkzjc+3DvVsnOJf+DM1mFFtOrJL/Gw07THFTiofLkB7/r8oksyC4R9wU8JEVpeNBPDEB3UyKetGmeY0lS2/mIsidV5/wSobuSCygSdccaxvyiRCdVAYWc4FkQcVd8H9VjsveI5C240krDcgu0Gt6Nt04r2Bjs7hvCMO79n6hmNWyEh/ZBGVa8fS76+dCwjfl/WjsclPZR5A5NjY/Eg2hVcePULGH4rPJv50T8amRSOMfP3VL1g4/IPDOgahQNUIA4nrXAHT1pUfp3L+aT/hEgpLPh6OsY+fJcktSFzroGqkCW1xHEvxTtX46yvf4aF1p5Lx3M/D8hMsxpJaRF09jtFdp1y0JxpozPFd8Ck2sGw24xjWelgzMO2dGUdSWiTGr4LLcCQvWMPAddGU3Di0bZu5RhC9p31RFret/f9ChqrRJkIs09Dr1L4c0ZbKeXdrAlWTvPfLZjPOSUOOwMg8uCsqYZrn/wYCm/u08YMZ+9SKoPpsdFuYt31QL4zuyJCsRLB2/JsMWTyH2HlWokp8NcZVIw04h/XAvHAASRK4Bnv6CfTCVmOduA4IH8b1Vi8hQdIgee5itC4yjUUqDs7tv4YP1kzpE0vpkUITOtOX3IjmDk4TVDXbs9hVdljI+L7vYjD6mmcylsDfPBbIybdej6k2sLBXM9jAurueIZSMXbfH7WbYK7NoHWHjyRNCz0IHsO1yTxzJCw3pvH799G71Eebo5pgUMipvnoBiMqMr8MF73vmDbbnOtrzwH+wYgdsVmoo68uPVrNo0iNFvbO66cQCiFDu3x2/CFGKhnwEv3UjBY96BlzEXVDP41pvYdFN7hqmJd99A/Nc7kaxmKPDtxx/GRhdZ//C4htVeMIqWtMArMyGDfYiNksGeNsY9prbJuvgimaSFKuk/upi/ZhJ1AxTkPnyhRe3VsexvN8cmbnBSn2/AGeM7/qWTXuCv/Sew9M5xXfZb399I3STPwsKypXfdlyRNMO6FO0CCUSdv5o28+T5tXs75iq+fj+ep6y/ssj+tvgHDwg24Jw3pdgpBSQfTeiu2AQ4Uo3+NqGWllYzn1va57kXpl4crI9bvPleHwmSxO7VOXTUkHZLWOKkZbKQpX0NOcPaqEJX5bxXT9yv9KhClsUNJe3oPACNNO9u2Z1tqMSxpr2ny/ZpB9Huzd90JnOkxqNFDESs29Fqf5XdOouhC/8U1a10RfP/xaKaduYrV1RnUNnbfshr1k4WY4r5zr9ANEs88/yT9DCY6L4PnYemEl5iw8g6iAteBO+zYhxzQ0O83EbdRIun11eg9SGX8c2anq5kzlt8QtIDREXeBnV0JRvLe955DXBaJswb6Vgt36CpfbjtyyoDOeOvxx7zmZU3AiT/9EqFJnDRoM2+mfUOgBDGd8e2tj2KSZHojID/M/ybHpJChGYED63f5kPeVudTIGy3HefYl2btcdChGnZL7JpH39Ba0mlqEy4nU2HkF2mDoTo0M1SZ5FVoC0BobyX27gknbb2jblvDDLtxVVSArmFrtOIdmdbr4NNTZkXeXoR1wW0n8roSEQyre7rgiGVfCgclYAlUWIHtebI4MF3tmeb5PwlIJa7Ub2SUwtOrIIQpxnWGuEVhqvZe4aqvurdVzC6JKNWx2hdYU7+8cI1u4KWERrY96bo4lfx9LRJn3DVI6w4hmEmhWDdXg6bg1z4V5nwHlEGtvY45KRKXUqQbpUDSTTGOu2uYPvWzxAI5rivOxRlllI0lKI6Z1u3ENyfZfjG97JXqVJ42ocDgwrtsNnfzO0tAcGnMCm7ol3X/ZheyXFNQWF0p1OVqgoOJukLbIhmFLqZfQrAzqjzvOGtBtSBIQt91zhNqidV0r46DvteybQU6vMCNU0a1g8OyXFExritEcvsc2XTSRhvObGGuu99knS4KMDtsli7vHLlKHImQJocpIqgpfp2BVPQqA1ZtzKbw+dI3k7geLyJxYSpKx2e9+TUht8+zwhDK2Kinsq47t1thlN34LfFZMMBE1peuUrJ3RlGVkyq1LKTSYgy7yFimbQ6shdBiQD8y7WryLlgwTCX7cDfWGJhbeM5G0P+xoSzVc5Yzkv4tHYD3c6cH6iM9bzTy+ezYuZ/eWOZIkkKKd7JllIvtrN7vOkolMaybC1IDJj0+aQdKYkLsbgE3VKTQ1H96Ft6QJTtt6Bq/2f8fHRTpT9cRkfdJi5bnSaQAoio6QJVJNjd12qe4tV+wzIrax5s9JLJjaK931GZoQXVoEe/t8P3eOSSGjMxQbWG2et4ZNmNHjnCiGwCsVSRK4B7QimdsXZ6K5mfc+mczJs1YQrYbmZxivtjDCsifkcQ9dMoektf41fNr2YqK2t5dSbZsedQ2tqgrjvmhcKdFt2Wg6Yqy1IVfW4q5rr4Drz2c8cW0SjljP7aQrEs2TPWMZkF5JfmQ11Y5I1nw5iKhSJ7JL4LYq2BJ6N2OXroKugLmm80W92qqh2mU4IEIaj6thiKkMMJKpRvJEmsflY/BZA6ms835RKBE2JLwfHDXShSNRxlgne2V6URyChnwF8hSSV3a9UHVHKNjilbZYFQBzlcz+dSlcGTuFf2V7V5F3CRWtugbDvmiQfX87varaK57hYErIQCit6QTrT6vVmohb7zmncck69JaWoFOXWvc0EhMZ12XtFUNFg0+8kxZlRjN3Mm0JQg40NdcIWjJ9hS/VJiFpEk7FhBIXnKChuWXiFpowLl6L1urfVaY5Q+bsgh4GKPcQe5KZyj+OY+2AJ9sUGq+nJPDg/R7LWN7TW9GqazrvRJKoun4ieZNKGBsfWJVvUVy0DrYzf3d/xmTspSC6Gpcus782Oqix6rqEaYvnOTQ1+J+LHfGCs9N9Y0GyYuspnhbTqdtL6QwjzmQ3kYkNPJa2iu4UeTsaUYwabqv/RYpwOTF+tZzm37YHp9k0A9ay3v3uugqtqQasFYc3uPejlkjeqJxAyf6e1QiSFQHpdkpPsDBsyC6Gx/i++9raSoJcq+eZscep7JLiA7pa9wWSLthRkcQTcUUkGvwL/Evq89he7p0sZWVdNm+Zy7go6ghVuQfS1EgeTl3N8103DfMzIyxkdIKlXKZVNaBFu4ILej2AVt9Azh8XU3tibEhCRozaygBzGTMsoauSMh+SECu65xeJruOMNeA2ey+0IsocSKWVuLtabABRby/hYM1U2Wple8FwovrVc03GT5wV0cxGp43LqgYiHahk44yWaU3tXWd4Z4yEUJUuhQwvJJg/+hViZAvVWguVmuclO8RoYdOk//g0n7nlNEpq43y0Y0qCA6dkQnYoGA/E1EaWuWnop+JOcpG8EtxWBdWm+QTgaRYZIUnY4hW/18RUI7Hki2FwQ7uQsdPVzIuVpwP1aDt2Bf99O0G2uzA2CL+uZJLwZDBxVhrRDYKYnXJbQHOo7lHaxq3EuApoyEsJ2MZUJ5Cc3gsTOSICrZe1+uAJeG/ob0QDhJCgwhP4qNglZCfITgWbpf33lg2aZ/HhB+GSSfm2AtJTPM42TS1olT3TsPcFzekKW655Fmi3mM6JqmHOdR63ykmbbyD2e6XzsUsyk6/pWpESqXgqh7/53XFsMqUwJqWUMYl7mW/rD4DDofoN/nbbVHDIyE6ZtEXdS3U0Om4vuafWsmLnKCLL/WcNmn3qEh5N9e/qFQz2NA1bssHLLRNAtUFrswE18shlz9GNAjU/F3fxbr/7N+1LJcHU4mU9602EArYEGWslQaeLVVtdoPXM6fLV8qKAFcxDQZIEJrOLWaeswRBCTvKBUZUYZY11rnQc9q69ElSDhtXq4NC6FMGiGyTs8SoSbt7dPDqkY7eWpfC8ayoXDfm4W+c+lginsA2d/w2VTR9i3asg7+88NkLXJdC9J0VJDV1+OyFiM6dZQ8+w0Kp3IzhNkkBWkM1mtj0QS9nFTvaf7fD6MxRXoNXWd+pi4w+9tZWCO5dw3+DPOCvCo1EZYrSw8r5nccSpCFU68i4GwrNwBnAJHU3oPFU7nrMW3cg5S6/HIVx+q21+NfBzRqbtQ5J1pAPBJJLsmQrkOCf2VI2EDQ4SNjhQ7DrZXzvJf10gVImaISqaUfYYUDr81QwyUDNEDUnounTT5VRNqu/+95ckJFX1+hObdpD28S6/v43khoQXl5B3z2IK7lxC8jM9LHwmBJJO+9+B3+Pg56R/r8K9Z6/XeF3jB6BZ+k4vIgCtyUDBnUsouHMJsdt0JOFxqYzYamz7ozpw9hXV4mb7n2La/vZd1A/ko7PGjkMEXvwu+vtzlF7ar9N5TDaG5tJ58QkLqSuN4ZuNg4hW7czK3cSs3E2YzS6EkHz+YtYYyX9PI/eTzhfpQqb9YfZDvKGFk3+1wGNpPeQRE6oUdLrdQBSf/TyOOb5WwsR1DpJ/OrJ6PDnVzub74wPegwWXrOGHFYNx6CpOXe31eVlxQMJGR0j1KKQVm9A6WM5Dfb9pQkfvpS9iMLo5M299SALGQfIjqjkhe1uX7SRJkJdYw+ej/4lu6J7irTXZQPUZR392pjDHHmFLRg/RnAqF167H3aHIkZqRTv9P9hOpdG0B6CnVWgu/GDwT0bwxpOOaLpxA5Wke7WCgl+yWR9NApBG50kLqE71TTfe/f38KHZ0rdp3Ols8Ke6XP7mCpcmFslqkeaqDop5uRFR2heyZ4XZMZvuBqAG4Z+gO/jPN2X3st91v0XMEut53TF93E0uOeY/Izd5Gy3EEHZzS/1PhJ3XokshvZZo9j9B9X+WxX2M9gqZIv3itqKyZo2S+I//cy/wEZ3UTbXkz6Y+3XteWcsSAg4kOPq5rQD79juGm9laxHl7Wth6LeWUrkxOGUTe2+33HLhFZ25I2j3+1LemeQvUTsDienXHcTnz3/VMBUyUt+9QSTj/8FSbN93ZCUwYUUvlbsVdgyGC4u8lyH3a0JrP50MADxWzUSG32fG0kE13fNLa2cm9N1oo1J9yzly3eKSFnW3u/cF56k0GDmWNa3Fd6+kvWKETk3nllvLubz94u6VYSvLxArNnDuoBm8sWkecUpwWv7Ry+dg66XijIeDy4Ys5bcJm1CkSD596WlOvOd2n1jAMGF+rhy7M2sImGplpD3+g7iEwKuKquvksex/PjLkly/Ady2D+Kq18xzVHXm8Np+LL73FU1grhAVg5a2TKJ+mIysioNsHeAIIZUXQONTJ3t9PCtguEM9cfi4zt5zmtc0qG4mUzRjlIx9dqBskWgo9v52uyR5XmYP7NBldk3l5RxG37JvgdZwiyRgkhTzVzJsT/0m0bPbSwneGkHz/gkFxQv7717PN1ULBWzcQe3f3Cjxs++c4Kj4ahOGXFUQqDp8/i+LCJLsZMHM7/WbtpN+snVRPcUFfLPp1re0vev52or/b1r7tMFLf34hik5B0qL9wbPsOIVDW7SDn9T1tf64ogUgIXrMqASQ4KP5rEVKAAldHgqYsI5f87XMsnWSws8pGXh/+LzKXRFJzdZHX397TE7s1x8mSQJYEaeYG+s/cSf+ZO1FvrKBsisnbsqUTlPa78Y4mpmQUB6VpNsluCmdtp3S6EWN1C+c//RX9DKagg7w749Vh/ybhT7t9tlur3CR80UvFMvoI4XYjHA703XtZf/3QHhXh6wmyS8e0YjvC3UHCEQJhs6GFYArRD1jCekpcTAvHZ+/sumEnRCoOphVsb7N6H8r9Yz7luriVbfdgpGzml394l7Ipwc8V1cNM7D+u+3PmCf228nzhG90+/lhCR6Adxr//BXepsCUjCCTN4599qHJHqzWR/oPn//qUUdQMNVM3ys2cTI9W7cSojchdrDp1ITO/eRCakGlwW9niSMMq72ZqJ++lfvOvRN5rxlIukfpDaBaG+suKaBjkRo0OfqGkWt3YCgS1VxWR8NpKL6GqM6RFa9nXMDik8R1OhCyhWjpX2TW3mFlckcN9xmYeSPK2FhkkhTGmw+QKI8BaqnDhmqtJXyDQN2wJ6XDJYKTk12OZMnQD2ZauA/wGR7dXO9YLJHb+dhKZDy/uVWtGR7oKSu9L3BapTThsTZWxnuwRNMxrS9Aq96MfyJhVd3kRzkQNNYT4LDgQPJplo/qy0aR8EXpSh75AM8F1MWV0pWfa645hTVU6jkTvRZtmgrc2juWCwSu75W5kkt0MjSlr+/z1WCO74uORNIncTzsvHAaeJAl7T5E4N307JtlNiS2OfS2xftuqks64BM91X7M+n6xlGpJL44bYfQSTpjYYhhgtPJD5KefceD1p/zS1xX7ITh1rhU7rSivNwwKnf+5LZEVQc+V4kj/a2ulzJhwOWL4eefIkQizC3mPUVhfqvlrcjY2+49I0jvv3XfzjopeZaT18EpBR0Yg39CxbniwJUkyNSJL3LS1JgjmDl3OStcQnQ9OcqBp+PG0131lHkj0vwLtWgl2zDZhqZRzxekjvc5PZxUX9VrZ9nh65iULD4S/YG+bYICxkdIEzTqAZBcIkiI305B9v3BaHYpOILoXI95ag5ueyb6QF+aQabshbRaLqifw9zuzCIHU+W2vCzU5nDaXOeFxCodoVxWK9P1PN27ll3wRaNF9NY/7TOtLixSF9D8lghOH9qTrREfIiCUA1adSfaCNuyyDUDbvQ/LwM/GHfGsPcAVncHLu368aHEXeEQktycBrMxiYr7+0Y6SNkdKSlwEVTuZGovb6TvVAlnFG989Z2LYrH0OxESUkOOqBYiY2htaiQs85b0K0F4fCYfeSfV836ZaMxLt6MHiBrUp8iBGq9Ay3aGFRKV0OjA4RAN6pdxnEYWgSy88AiWoL9ozzPXJojA4OmoTc1w7D+1JxoR+3E8tcVDdNtJC2PxVqh8+nuoZyR23t1KvqChXadx/acgmNBos8+xQHKeguLk/MYEb+vW1aNjpycsQUyoFkzseX1QdQMi8RtljA2CyJLPc9UfT8juur5nZwxcMnkn9hnjwWguCGRygDZqmRFJz3Ck9o7fT6YP10Gg/r3aLz+GGS0smbSy5zx92uQHW4a+0d5FbdMSGzC4VawhWCt7g0kSdAww0bK/GgIQpi3Vui0pshoPRymM1ZgTxIkdHKbG5qcoOsodS2495b6byQEub9fzC15l/D4+LeZHXEE5p8ekpdUgxAS1a1WT8YpSXBv4noMkv/F/ajIEn7I60ftwCi/+5Hh3CmLmVcyEHeQ91NiXBPRRgdJlmZ+n9hRSRV2aAmWcOB36ISFjADoB65MzrhSJiTs9tq39NGxGNYeMKMmJlJyXjpC8pTeyDFWt6WC26/Z/eY5TlQsbcKHIslcHVPB3HoD+13RaB0C1nadk+R34pXwLQTUFUpyItvuNKD0sFTarlskCv6eA8vXB9U+/57F/GvH6Zzxx0cByD6Qr/tI05ij0jwptJdVs24P6L++67R/MjRhDlFPH7JfAmeUQn2/3lMN7h9lJDoun+gP6ru0KkkmE7YJ/Zn8fz2LCYhUHBQ9towV145EWrM1aGtWbyJWb0QZOxQRZQxY10USAkkXsMbzElVzs3Dn+k9jedB6EbOz/bvoBonqYUaEAuUTLSRG5hOxsZJtd6jIvTDh62aV2HdWEbttAJVPR5Ni6lxYlxSBZlZQ7Ie/BPO1qy5DXt5JmlkBVd9kUDzL0Wlqz2BxCYUyWwxi5SZMf87hlNTtfFQ8HMuLHl/8QVdsbksRCp7iZwt35/nNTNURXZNZUOypOprRqiNbrQhT99wNu0ITAmXNdvTWVirnTGT+eY9glqQ2bfVN+yYyf7dHwDm00KsAdLccUibDYHE7FJ/kJIGIfnMJrquLcFsluhHvDIBugPQx5dyUO5+5P1yIsdF/jIG0fju63d5FJJuHgjmruePRyxl54dH1LgmGTwd8go7Ow9Uj+M/G8QA06w4MkoxJMrStB5p1O7W6m2dfOJOYWsFJd/zUWbeoso4kiS7dw1SDxn39PzuslqAwYSAsZPjFbYXzzgz8cE94agX6gYe6WTNR8q7/dufcfgcmPzn7z3jyW26P2+217ebYvXzSYmVZS5AluH9GJLy4mGtf8lRWf3zXIoYYf37VQZ0OA6N/up4fjptLWggvt6Yso0/Rv96gMVfGdv1Ykp/u3F1u7x1jOPvCzl9UoTD2n2v4au5kEv4ZmiWttxArNmDsn48jK87vftmpIy1cgwAaL5lIU5b/BaihCeK3+L5wZZcgeZWDqlGmNkVDb1J8q0zc12OIe2UxpdOtxC9UOo0nuHjoCjb8Jp2mBzJ7fzBHGZ8VDyHzXG9r4Vn56+Ah37aNbnO3qivvu9SFuLSQqIi+z8TT744l3PCX2bRM6sd3zz2HIsk8k7EEMpawX2vhuJ9u9mqvNRrJf1dj9xVSp7FyoaK5ZQqvXoM7hFingVdvptllYscX3Xsf3XzJp23W61nPPsn5/aZ51ew5SKjiVMHdi7n211NQYmP5dMO3vRJPc7g4e9uZbTUqhC4zYcGNAFw9dBG/SdhOs25n9E/X0/+uKprv1jnjioVd9jkrexOLq/O6rAfy08TnSOylwnnHMuFifKETFjI6oI9rZGxGCUoQLiUH3U6iVTujz9rAsq+HUpRSyuyISjY6Na764x1ENDj9+ha//eBM3ri0hmWjvKWTEy31ZKgr+aRxFI/X5vOLbxby1O8vIPLdpb3y/Y4oBx6Wu0+9DKEotPSLhgG9ewprpSCiou/SonSlLWqptmJavxvHsOw+G0NH3FbYf9MkUl9e5fcFfjSj5uVQdqonj33qa+s9yQuCRN9VgnFvGRgMOMe1Zygz1rQithR3aW8I5T6pKzRQOzATaLd6adUmzFUKQgL3wO67buh2Bz89PNEnrSpAv9s2tcXOdBXXFSq7zjTw1uwn6Vgj4+fEtuZkNlSkdfv4w5nMTautw/r9Zib9tl2gqB0M153+NacWtgtUn64ZQdaXh3FgXSBLOi/kf8C/fzGcf792SkjH/u3al5hsbuBgYc9I2cw16zbxwmVnwZJeKEIpBFp9PWecfLFfi2bzr6xdxtodbiatvpimQ9yaDr5PXt02nrcNo7E5jPS/u5pd/4jnxOzgvRVGx+8lwdzC6pKsgG2Uw3rXhwnTTljIOIA2tolxGSVBBcUeSraljm3j9nNS3AZeaujPk5/OIrs0sDuJtdJFabOvNt8qG7FKrWhCptYdwQ2xW3g84uejqQkGbfN2ACKrkjHWZ1Ixofcyr0iaR5PdFaUnGHHn2ELyRFUNGncN/S/xin//17xPriP/XQ3Rg8V+ywAnpw3r2g3t85UjiNilIiRwReG32jdA2d2TMBX1fhrl1lOa0AyTQquVIUnYZo9rW+E5I2TP2IGmUwYjHwiUVewC41edF5UUbrcnA43DgXlrefv2Vhu6o2t3ANktgrpPADTjgToMJe3Pq8nmKdKHBO4O2zWrjpIYnDuCbDYjFeRg3e/0u1Ba9fFQdk6rYHrqdtItjay5DHLekoMedyCKL5W4bcJXjA/CXeieoV/xhHEGzoUJ/htIoEysI9Na36MxhcK6hgz21sf6FMM8ahECvamJxG/3sOXubESsi5i4FhrcVq8ihgPyy9l2tqf6ttKLVoxDkUcOpiXXvyVWsekY561o+5ysRHBx9Fr2nOeJyfn6m9EY6/0vVlty3Zw21rMwnm5pxiR5z+vnRjbyrFntpTB7PILGRt/UygBo43rlFPWtFhZX51GU2P1ipw5dZdH+PBqaLAGVVE6HAXtJFDlfunGX7iMrTiLJ6L9itz9MspssSx32DAOb96V67TMY3dw55Buscu8oFB6oGsy/VxdRfPJLvdJfmP99fiYzdd8hZGjNdnNa7jZiDd3XSp6YvpUI2cEHZSPJ/rp3/NVP3nCR30DiYFGSkkA+UPshoRPf6iOAVrkfo8NBTPIgGnPlHteKMDSBGoTfetVIE/FjKkmxNrNxX/DaUFnWuTqmgo7a33J3M+dsvByA/v92IC1eC2YzxmpPRhJ3XPBuYS35Ls4csYYn0lZ02bbRbWJxdD6aW8a60YwYlIe8rcTHGiCKGpiVvSnoMQTLOf3W8nrDBJKDbC+bzTAgj7oBqt/fub6gfemh2CG9dKDnw669bZmd/CIE7n1lfncpgwtxWXtHeyfpYKrz05fw3q7ZFexGY5eZXtxmkNNSsKcEdrtLWeZgb0wK80fB9NTtXDJyGR9sn0LCJg1jQ/e0tPumGXlg0rtcFl0dVPvLoqsxDviae+vPxrrRe9GoOCGiTKfo/K1YlJ7n9P+2vBCxKqbtc9XyFBZO1Dguqdir3f6WSJpbju6UsIciqSoNRVmMGrODgVGVftuMjS9hbHwJ4LkWdU1WNHfPl+Rum0rkFiPy0P6gQ/3g6IAuhKoN0vZ5nr144w4AMtVIns7wWNKLRmZSXec/ELkoZ09buyNtIYveaKBxkBRSxiV/OOwGKkQU+OY9CJpqZyQN81PRhtmQZf/Coygzk7hWwvB113N/ICyKi6HRZexviaRhaTKK3RMXY0/RuHqS93urO5y0+QyanUaqNiSTukJwUf8TeC33v10mtvlfQyd0F7+enu/nTljIUGBOUe/4ly9u7k9FfTSJMWq3FwJGSSdK8Wi4Yq5owV1R3MURhyBJSEZPdhzXgAx0o2cScMaowNEV9KXVNxD57lIa7yzqUSZJ2QXRe92oLZ34HEvgiFUZc8F6Msz1bGlKQVG1oF7kui5htxlZ6fB+aX3WOJ7oU73zqOt2O6zzBB0ro4Yg6V0viFxRgvuO/5grooPLFvVqzo+Q8yO7XM3M3Hs3pSfFkN2cAluDdzk6XEgGI1J2BiUz/cdQHIpmhr2nefyLsz9wwvYQ7/8D7Ds5MWB2HF2R0A0Sssv/S183ds96qNjAWqJiG+juNHjXESdhz+t65ZL1XyflLalwnsf6d875P/HxG1NI2Kij2IJ//QgZ7IkGvrniUTL9xBOVuJux+5H+0hWFi6LqmHD8k8zce7f3zkaJ2FX72VCfztDYsh4LGk0/pJD1sMcypubl0O9f5WyOS+WklC206p75zKYZ0LoI8g4WXUiUu5tDiq/qilbdyY/2KK8Aa8lgRM7LYurvFged2W1G2jY+dQyltReEDLXGQNaLm9l77aAuFTluS/uzN161Ua21ePnxLx7xfo/HczhI/cci3PdOwjm058o+ISSaNVO3sqfVu6ysKM8i46+L2P6PibhN/p/ZrAU6lo+W9XSoyJLgxPStrHpDR+wtQ05PpaYoFc7tfp+a0FnjdGO8XCe6dCfxGTZsg9LY83QhzY98FnSBxDDHLse8kNHbnNt/DcV3JVL5h/xuHV9giOQ3CZ5FxY+G0IMWlMTEwxYTcDQgCUhc5+iyCJ4rSmHaH9rdewZGVZJqbmLe9kFdn6PcTM6XTn798o1e2xW7u9NMX2L1Rqwp42hJ61yL9NPlf/PJlR4MeYZItl75LAP/eVPIxx4utElDKJ14dAX6t6ZKuCKMfgO/dYNE1Yjua/0kDawbzdiG2no1ePcgZ17yE28smETeB8ELGbZkA4v/9hzgf0E97aM7se7zXdCecP5ynkxf3nafHYrjVhdnFU5j3muDPAHavYAcEcEHC97DJHl+g22uFl6tmwjAF8VDfDIydZfWVhNTF9zC6qnPBcwYFyovNBTy5ZBYoN0Nyn3cUCY+0bn7X1/ijndRcl3Xc9yhvP/G8Xw7fQALhn/QB6P6+eByqny+dSjnDFoTVMHHjnyxaBT9b/Nk9Tv47+GiZeZwageouKJ6Ngdtc9n59dW/xFB5wI1XkmjONLLsoWeBY0/AOFgk73Ce7+fO/5bDf4jYUnROOHNl1w0PMysdTk4bNwt3aWhpIZX++bgG/8yy0AhB5jNryHpqDYnrQtOGGhsFmU+vwfj9Wk++dT+Yd+7H8ONaolb4XstYQyuzB6wLWI0VwLzKSta3/q1SuklBnzIK5O4tfFzRgq9ufqRbAsbPgaaLJlI5tvsCxr7TU3HPGNOLI2rHHQlVo0xUjTKhmTzToCNOpWZo4ArYvUHeXMj5qKpHfcwuWknuQ1vb/pozfMdcM9TU9v3ssTKnjZvFTpe3n7dLaAz4141Yyv3fv998PI6B/7yJgrdu8LvfJBn468Zvif93BO9/NKXb32fBvRPJenIN7hPG8NeN37YJGAAFqoU/JK3iD0mrUNXDX8iuJ5TdNYmch7d169iTs7eQndyzApValRnrzu7fz7U/pZL3+bU9GsORIvuJNSR/2Dv1SASwYXYm728fGfQx856czIDfB66r1Bc0us38eH8RzoxYDE0aSWucxG/qvUWqMmQAzoJgnWRD49XGRE6++8o+6TvMkeWYtmQIhR7FYfQVLqEE9DUPhDKoP+74CJ9CZS3pBpyREkKVkHdZ0HLtSN0oyNaXHCzuZl2xm+ziGIRBpXRWfBDmfYmG2cOJemc5yvYSTKrv7aw3tyDcbrTKKhb8bqLffnLrXX4rWTfmWzA2uwMG2wpJ6vIJsqzeQ6rdf4C7kPHrvhIqvzz/U95ZcSrmAHGQy2tyqPjM17rlNtOr6W070nzBRFpS5YBpYB3xgrSRFf53dmB3dgpZ5nGYPg9NG5zxeQX7p6ZgT/R/EwkJxIGxNeQZkHSBbpD6JG1tR5QWJ5K9Z24ckYqDakcki1Z6LJ1RCR7LTEc004GAdUBYoXZqNnPuvYvTf/M9v0/cwjqnnbO+vxlrk+Q3Ax6A7PT8KQ6Z/P9excoTnvZxjxhuNDP892v5+pvRfPbyFE6/Kvj7SRcSP/25iKil29FaW9ENEsONh8R+SDJ1mo3x3/0S2aD3eo6cC7afw0O5HzLS1LMF6YxNs3E9lYqFdrcXzQRp5oZu9WeS3QyKqcSkuNvSnoaCKDNjapS7tPB2huwGc6mBgm+vZMsJL/6s/O/11lZiF+xBtWVTdkn3nzd3k4H+/3bi3ldO1hOJLIidSGO2yqzrF/i0rXJGsvWBoQAkry3BHULGPK9zPpTCW1clcdGQrmM03vliMpYqz1MhaZDQ6EDInmdadgnkHiTZeqIul3++PovUA27WQpGCKoQaKhftOoGNHw4kvr57z0qYo5tjWsjoK2KNNlZON5K+wOXX73vvSUZmFvh3L3inOYbffHMhhYTmo+mOtaKZfF8CLquEM8YzCRkaJXqqC4xYbEWpKg2qeFKoaFVVUFUFskJC9ui2TESOGMVvsKJugKZsmciiYbh1QWOBxavC7kGi9+jE/GdJyAvVGH04bmvnrjNCklCzM9DKKxF+Mhtplfsx6oKEqDxqBrc/bvYknawR5T7tu8PNsXt5LVrmUDFGWxPD69UTMdSoZK31MzaLzOt5HsFrxIAShsaEJth2RlOmjB7g0tmTdcx5TUxN2dFlP0tVNzuN6cSnF5Hw4hK/wqA/tO3FGMYlYw9iWerJchW4nW4AW8Eh18+mELGnk+mzxoQW60Ixtj9xkYusyDXVoPZ8sdbqNmAt9fSjmUAzBR6/UDzPSdrCVl79fDofDh1OlMmJdXNwC2tJA+smM/bp/lesT2cspZ86mvQvK3gndTIAx52wgQxzvU/b11ePx1DuEYgkAdn7bbgLs4AsbEkql+2Z2tb28uSFzLBo2IXAuslM6xB7rxeq216ezJWNl3N+3mruTQwgpXfBSZvPoOHtDBI+bo/taz5/AvYBPUsrHWtopV+UTqvLyOA4b4Hcoan8WNzPa5vbrhK7wkjDAB1zg+zJgNZDFDuYN1nQT9DpUeDcEcBdXkHEYieR2QNpnBQ48Nof6hYrliqBoQWkRZ73hrRwDSYgLTebd7Im+xyj2CWyP/e45Pbk/ah+uxJxhn+F2EF0IfHmyvGkrxGYqwP/0IpDZ/zq8/nviFeJkUOzKq9vyiRtkR1jeSOapvW6gD91/dnY3SqNKxPJWOXokzVFb6MJz9/hPN/PnWNWyNDMIKx9Y36PN7Rw/hkL+Gz/FFSb713y+7MDZ3h5Zvd0Cm8KTcCQIyLQgpwBNLuCYtZCtmbougRVJtJeWoO7tY+tP7qG6QvPxK5ER2McmkdTlq9LkVDAnqBTNsXqyfQzuZo3hr7mo5W8dPc0qrcO83xYvdmT/rQXsecnYWpoQguQPlWrqsL63yZqBo9u26ZktTJ/yMe9NobmLJmE3Gzcuz0ZamSrleyvmw8ISf5fQopNJ/8tz//XXpRN5FCHV0XlQGxqTMVQ1b24BVekIKawllOzNgfVfkLCbiYctxtHkcqG5YNgS/FhqQniihZtljR3pM6cUd7P5KbGVDbUexZ5hibJR2NsKZdpMStg1NqenZR/rsTtcKDm5QQ1Bke8iiva9zmtd1kpbwk9W1z5cVb6vVyBOzmassk9SJkTAG17MXn3egL1f/j3aNJS6n3a5L0OpgWrkWKikSSJvXMKvKxHqz4a2vb/fSfFYsj/hDJX4Pz/vYHhgzheGjmdCbN3MMMS+juh5Z8ZJLzlnTykaU4jl+Ru6PHYEgwtnJ+5sq2w3UHK3c1MXnJX22c9xoVidpO8woHbGoU9USBiO5njBZirgtdK/2CzMtncglXunvvVCw3pKK09z0IWKlpNLcnPLqY5dyK6UaBHaKgRAaqPS4LY6Faqi+PJ/7o5YE0P9+4S8u4t6cthY6qWWdeQwfAY/y7TGjK574Ls6vyaGpo0DI9F89w/hnNl7JqgXXPXOBysq04nodmJtnUHstWKUHomZC5zuNjrSjgwfgnpqSSiWjWiAryfwvxvcMwKGdKwRub0C77gTXdYes8/vPyLu0ITOm5dJiTDvSThGj/Ab659f0RsM9JS4EKJdAWtmRCAqDfS/1dLDm9KNUmi+YSB1A445DaVPO4u9kSdbRc+w7DnbkFyg2NhImeX/pIds5/zqgT7n9zv4cB6/rTJZ+Eu3t37Y1VVJD/uWm0YDB5leR9pJjbc+gz5g6+i/2UlB+6JgR6zeZDkv6Wzcupgss9c0GUWnJLX+pHXnYrfEoyYvo3CyOCyaHXEJLsZ88p6Vlw7ElZsCM6iITza8pDTI0sw4+TVxBsCp88dHF3B4Fke7fI7X0zG2BDALQsQNSb6/2qJ108vCdHpMysJQcXZTs4dvBqX8K4K/s2uQtSV/lOJdokkdTtddChLxP6Xrwq4Tx8/jH3Tux5/5X8zuYkDSQ36uJZY7qcu7t52HUt//zRASK5BuuJJUyt0ASFU1Q6GNGM91/mxMJZpRvrf1e5Os++O8ay//Rm043WGPn8Lfzir81TF5e5mTnz214DnGelsXpJ0uOOf1/L4tf/kZGvogkKr7uTDUdlg77oGUPtJJeiqmnew11oI8n/tma8a5kykela7kknuEI9nMrtYNupdZt1+DvquEs/zeYQqLmc9uIiabRNx/dYzxxwadO4OMcva17dNZdtDKbyQ9WOXVdJdQuOcz25lwIuN6Gs9grJ7dGFbpspQcQnP2C9961ay/tsuUKg99qs4/IRT2IbOMStkHI0Mn3sLWY+t7PN8AhnzZBoKrNhHBmeRsKy2kvHEisOe56D62ok4Y31XF+df/D13JqxCRkaRjKy4/gl0dE7fdBF8l86QF29h4zVP+51M//PDG5zyhzuJe6V30hYfJP+LRu5P/SHgfrsQ/KO6mU8/LULtQ0OQbLWGLGAcJG2Bg292HcfJv/L1N+4pQoaTzlvWrVSQHRn43GZ+eLmI5LldFwKMfns5kZOGUX5c8FlQNDOcfuZiTCE4M585cwnvrRpDxHZfLW/EMitpc72fHfeuPRjr6nGM7ufT/iCGxZvot0iwTjIj5Wcz+o3gLD9dsXd2SrcX7DOf/zXXXfIFt8ft7vb5m8+fQGNuaIsV3Qinnb2Yz3YO7bXsUv6I2+bkpGs9Qe5XPB58Sul5f/07rod1nqodz5IeZCYLhTEmI//Z1T7fmKUFgBlFkll53ROYJJXO8rqkqZEsvflxAEb+eAPmtUdXpqBtz4/ltFGBM5bVOq3UTK4PWQiIeXM5se+1L3vOWF3GNTEd02QbeP27/6AhmPjTzRRcsia0gfcike8tZ90nZpBlkr5V2woFL6/JwfloGrIrtCVo8f2D6HfOIHad/s9O20348y0MmlfWZhXvCTtdzVx9468AyHSGLRbHIseskKFviuL1pvE+bhBHEtmNX7/+nhBV6iai0lMXoL5AIX6rG7VZI36zwLnXjFCgepZ/z/XYbyyoNoGx2Q0jB3gU8Ss39bq27lAkVaXmF+NwRvvXuloVh1fayYMmfIOiHQh4C9x3nGLllnve5c+Dzif/Nz0TNGzJBi74w1cAnBe1gUSl8yDuOxJ/4mPDRPpULStJ3RIwwKOxjKhw8dXcyUy+YblfgWD+XyaRsmBXSP6zzhjBwON29VjAAE/Qswh2nalrqGt3ktWUyd4g6nTYUnVGjNkZkoABHivLlCHbWB6Tg7LCo6HP/rDSU7OmuRW3y/flqjU2Y1rhSVXtHpqHZlYxNDqQt3le7JrDAUIgAGnnHpbd2O5qF59toTE3pCG2EfS184PsBl10P/Cz8ZKJtCbLhNqF5IYPv53I6KJt7KhNpKm5j1IiC1AOFPR86u/n8t7Fu/ms8MsuDzvo6x6ntgCxnbZ944fjiF/v+3zWjtS5ZHLXgnNHEgO4vgTr0nRwDn2j6J/8LuUcyr/ufbe0t5rieOHmczA4Alu2DmXHa6OY1n9Lp0lZIlQH694fAkD8qxHB15nQNYRDQzabGbDQzYVRWzBJ3tfxYHKDt4te4M6vL8B08u5Ou1RzstCSY322KzVNPbOa6xq63fOu3X/rMCrUPM92CWRz6Dpu2amT/o2BYdtvojnfzcYznm67V761KVz7+TXkfK6RtrYYraYuoABnrXQz4pGb+PGuxzqN8/hrTX/eev4k4u1HV32unqAj0fvRKZ2f7+fOMStkqC0Szsa+0TqZZRdTI7eghhAol/flNRQs631fc8Wuo9hBqBIRZTKGJs9CXG3RPMXrJGhZbfW77o0sc7VlVnJFeSYjU0EOYm9Zp37xksFI7SWe1KOJi/ejbdsZsO2hqPm57L4wPWBWlPgTypli3Ya/IMQ5GUt5vCgSsTSOEzedzWsDXvebvemy6Go+mbSdksuL2rYlfb0Ld7l3cKVaWoOUFt/23TtSO8iEemp1B61u11mi0tRIxh6/hSUrBvRJTVyz1YmUnd6jPmSXIKbYiX6IdOfQVb56q4is77fjrgotBatQCOhb3B2axtswXVZE7KtdC4l6UxPyjhJSl1moHGsOuMBtzdZIya9mcLTnHnh36yg0zbvxuZ3kys+21OFOV1gx0pPFa7cxBemArGJszPW1vOgaWmMjAIaSagwGFWx23Ae2dUQ4DlSTP0CEOorG3MNfeyRxRhmTI7bS3erBtkQ5YIHEzpB0MFdLrNiZg2LoXQcC43orpkbf37R2pMZFiaGln51k3c6TT94CwI39vmGC1TPvuYTC/KbBvL64iMQ1EtF7/Gh0hZG3HMcBcPb0pSELuj1hvMnA3Tlfcd+02TR9n9Jr/d6ybwLfvz+GjG+CE56U6Gj23DyUUweu7DLro0HS2mqzvD57AmnmiUS9FUItCkXhr6k/+QgYHRljMnJT7nxeIs/vfjU/FyFLaHGRft8RQolGkT3Hajt3d211kSSUglz/++qakcoq0VtbPTGYEwZ23lcAzNUuDM0yQjEwc+OFHsUcUNEQReQeBeO8pV0qkBSHTuI6B6O+uQXZoHP2oDU8mrq6bf+4VRdQ1xCBVGome9P/joARpnscs0JGX+ISCguaBzDBtAGlE5P1Llczj+4/EYBBD9eidbO6cTBIbkHkPn8vN0heGfxE4MiKw+x0IQN6rP+FtW4xUHeK7cCnZBIs7ROwvn5bQEuImpZK7cRUhp2+hQ2f+J9Ez8pYS45qw9+ifrS5hAlpJSzW46j6JoPSAguZB+5wTegs6fA18yJqWHtKe00Rc0M2EbsOaLuFQF+3BXfpPlRFBhHjiXPo8CJpLNDZOfodv2PsjDfy5nOKvffrYjxVl4NtvxVHWu/khu9IpSOa+TsKKXh0MVonL0o1J4uWoakANBdoiAPF6JSo3g34vHjoCt6SxhL76oEN44ehm/xPZYaKBrTtxSjfr8aaOdFbyJCgNUXCUiVo6acTY7KzotYjJCjrIzG4vNuuSslCkXQyrA1+U5PmR1STP+iAH3yH+mfrGjKwrRuFvHCd33s/1Ho4R4o3B/7Hb4Xsr1pNyG5QczsvAtoDIwjgyXDVMsCJNcaG09EzMV3XJNQSMykrnUhuP8k5pn3C1TFdp1juyHiTgeLznvfZrgkXO501mKoUHPESDYqRmGLvuThml5OYXYAErmkKpgNLPYduoNTd3CuprjvjZKuLgsH/5sQ9d2Ddo/Yo9S140p9+98mYtiruXaEkJdF8XF63UmrPGb2Ud6yjiNwzwksY7w2SlSYcp43D9OWq9mdXVlBionHkxHcaV+W2GnBneyqom+obwe1G2B0+CjrZbEYym0BVcRxo7w+zy43UYECy9IKCQUDtd2ltHxUXWPcH/tHVJgfuaDO6of0hznsVQObD0yYQd1K7UCi/k0BOqZNACUfCHFsc00KGpINNM2BRencRtL05mco/5HPCi5vod0jwqKvDIu23pbOpO+5gwaXuCRiSsW+Lh/nDXpBM9XATzWO7TgtYd4qNulPaF779f5WAaGhEuN0ITUPukAmq8rQ8Gk6wUbU7xycd60Fefm0m2i8k7o73tY7cufN8vyZ/Tejs01q5YsktAcdZfoETDoTca26ZATdGoLe24t6zF/bsRVJVpMnDPftNMsLQ/QiVeYM+wyU0mnVXr1Ubfv2hUxn8Yyn2/r2niQTP8/H9zv4UzFkdsI0cFYUkSey+JIuNv3zGZ/9+rYVna8cBB8zNPV1tdjx3RATi4VomxPv3H37ny8kUPOCxvMW+5m35kAxG7L8cS9LnOzHX5VFa2J71yWeEgrZ7q3hkCxcMCt79Y3jMPvQny1gzMxVtf9URCyYFTzrag3H9QdcEkQK3bdBt3PTV9VjrJfZc2PeFQFPT6kiLaGRDWRoixODXjuhNBnJ/txh98kiE2rc1aRVJ5rqYMq67xlM1/bI9Uyn584A216xDaXKZscpOZElQ7Y7k1fox3U6vGwoFhkh2zX6BQc/dhD/PxiotmnL3HsyS7FMvxSFc1GrtB733x1PIej9496/G4/OZ9vvQ3MU6csHA1Wx5JIWm7teE9Ms0i863LzzPGUNnoNV5YiKU6Egco/JD6scxPBcA074G2LbTMwccKOIqZWfgyIztsg97QTJwSM2UgzJOD6cUc60g5j+BLUH62s2owwfiTPRVkOV87uLbz9tT+kb+DwsXuvD8Hc7z/dw5poUMS4XMlx9N5Jxz+6Yg2e+uvc5nm+GHtZ4sJACirkf9qzlZlJyfRfKqw2+STFznIKLcRNWZobl4bft7OpBOzA8WUv9bztYHYzvstfWJB+LnrZHctSL4aqKKqrP9n/0Z8Pv6Np9a4XajfO9ZWDZ8Vsj2UW/RWWBlV9xbOZaPv57Itsue7XYfh4Ov3ptI/sOduyXdtWYRU81OZL7H3zVJViK4L2kT4LG4VLpCT7/qDyU2hmHzGzBIvi5GB7ng1AXMGzaI+NN9XV+Ey0na44uouLEIZ3Tf+r7KkmDkVxUsv30M8g+BBba+JuuTSrRtO1HTUtlzWXALJVeUYNMVc1Ekb226S2gUPXcn3Ug41CMGR1eQbmlk3vZBXTfuAnnBGr/bK10xQGiWjGB5NedHVs79hl9ffaPvTgG7fzeATXfVMyNtGxnGOr/ZpY4Eb8yYyKtluTSdP45Ff3/Oa9/EFb8g+eztbZ8j9KWHe3iHBTUvB0duQrePd2TEoMYMheUb0KaOAAncQWaG9EftIBOmep2IssOfHjhMmGA4JoWMrFe3ox4IeJKio+Dc3uv7o+LhRL8dhQWXX+2CPn4Iyvpi9G5WAz0UoUD1cBNx21wBNWN9RXcKhx+cTmsnuKgdkYzaDa3Hix+fzPNG0BJc7Jr5IgD9vr8CdbvV54a+t3I4n+0Zgggxb6cEbLormdxPkjB+5V3ET5JEl2kAu+LepIXMuXAJhJaw2C8zfnE1UjLUTs7EWtnzl42kC3b8Ihd0QU7N1oAuUkpKMhf9sIrJZjuGIFM1XxazhW9aU1jdGlytiEDMLNzE5vdSMEi1XbZVZP/PhaSq7L9mHK7I4O+NqGmVjEksDbp9R2RJYHqggn3vTSL56e5rbdXlm8muyabkjG7Uujj4WwqBJCBho/956iDlk1TevuQJFMn7Pl3mcDHn3VsxHaEKWtGqjVP6b+brnQNCtmgYN1gp/PfuTn3P+zrgcrhR4Y4XXufhuy/H2HDISI6w9vI/Vz7BeV/e0lZsUsjw7LXP8Jf5v4DSfcR8sZFTt17idYw8Pobdbw4h98LAGaECUfLHSQw6cXvXDY8AX7Wa+Md556LXb0YeOhBnnCXodPFdItHjvkJNR21PNNCc4f28JK5zYV28rcuEsmJzMebMNOx5vV9j5+eCdpgDvw/nufqKY1LI0GpqkQ4siqSGJuY9OZkB12wOqhBZZ7yxZjwxK0xYqgJbFjSzitpbk9TBPk3QlKlirdJ9X1h9RFO2kfruxZ4BoJrdWOMd3Fj4IwAv7JgcdNYYQ6OEAdCajQxfdjEAyk5LW2pYIcOks9byUtVU1lanY2vt3kJejXWyb6oF0/BJ2BPb3/w35szrVn8diVOs2EUzw5ddwaKx/+qR25R50z5ak3Nxm3vvvtK2FneaRUwcN5K9dzkP5OIP3j8+RrYwwVxGhOxgQXNht8cXa2ilKHFXt48HQJJxBchg5tsWGN/A8ISyLoNSO2NkbCn7Toqh3DSJtMe6J2jodjuSycC4s9ez7ONhQfvPD5+9mcoV+Zhq49HSEokq0VFsnR8csx3Onn9zmzAP8FJDKs/tnMoJ09b4tLdpBlZ9PLTPF8qyJIg1tDI0vRxdyJQ1R1PXEFysk+IA974jax0wSAqnWe3MvXUvFW/nELfNV9kyyFLGOHMJ0PsxXJ0xxmSEQ9xBJ5hcNP+pBV6aQOS7S2GNxzK59w+TcEUJRKaNGXnb+e4RTzKNfq/WoW/YEtT5nHF6W8KFnpBqbmLtI0X0f3BjW1KFntKom9EPfFdhUrxiErqLblIxDOrfK1UiIss1XFaZhjwjko7/pAIHaE0xYI+X0YweBWH6j81ImqB6eCT77h3s0z56JyQ+327FFi4nemUVZghZ0DAXV6ElxfgNkA/zv80xKWR0RLicxL+8mIXjx+McurNbhcIAPt41jJjlJuI3BxYwJCEw1Np6veI0gCNOQnbLSLriySAVBEKVcEYpmOpCG09LmoGGAhDZtq4bd4IsCVINDZwV0cyWjJ0sLM+nvtEKksAZI/xWUu6IYgd9sSdYu+MyV8hwUtwGHtw0q9sCRltfuTYkq4NxSRXkR3iCek+J3Aj0PPiuXpfRF8fxQHYRNyX8RJ4htODOOq2VszdfgiknGrdFOqwa0IZ8C+snvNKtYzPVSByihp5U49jRksTSrfnMGd09twzZaoX+oVlTTs3d1CtZf07L2cjHk4fBY93vwx1j4oWs7xk0rADDFqtfH3oAZ6xAy/K4NJY0xaGaZUhJxBVnxrK/a6tX1F4nps9ULhs0leeyvsEqG2nQrOgCns/0daNr1Z0MH1bgcTkvNWOq61tN3MHFqVl1UQwIIVFdGtveQBEBKzwfDXwx4AsGpd5EnJ9EVhlqHYWGwytgHIpmBveAVmRkFg7/gIFDbyLyXY8VsOWMMQyfuYV+Ee3Z5i482fNUf1QzhSxlEPra3qnvEgyxhlYuPHkBqx9Phy6EDOF2M2P9hbwx+FWyAwTVf9Ji5d4VZ1PAGpSkJDRD79Ro0Q0yjtRuFtM8BFOtG2eEEXui511pagq8pLMnyLg63E7Sik24pwynZozGnEm+z/LHu4bRWjUBe0y7YBWzy4G6cAPGaE9MzqHB4B2RnRpqk2di0krLUADJGYGQZVxxvROLGObo55gXMsATANr/NSfLr8gncWRLp5V+/VFiiyP6jSjMNV3HRujrtnhcFQxGJGMADbAQ6K2ha0ttSRKaSSGmWEd2BV5xCtWjvXVbFRoKFJJXukNaoFaPBimtZwIGQHOLmV+vPIfTpvyLJ9JW8BvZzQeNIz31OHJtiM1WpBC9qYQMmkXwuxVn93h8B7G1mli1L5P8wsAVdHvCl28XYb3Eye3xy30CKv2xy9VMlW5iQctQTCfvpuqGIlyREqY6gVAlv9lygkUSAsmlgwgs3SlxcThjerZ4NEhglZ206t3TbK3YncOgO7bD9907v5ySxJ4gamccrcgundVOnR3TXiGv+VqMlf6n8ojBdawe9xYAp42bhZbaGvICx9jgZufjg6j82xfkyUbuiC/mjnj/iSqsspEd0/8FQNHac6lfkoLSS5m5NRMYAri+9YuoIt9aTaUjmqULEkF45gJXtEAcxULG0YxuAHuWk13TXuHQlOFyVBTH3xfYEnfWxT/xnnUKOb2b7KlTdCGxoyUJoXVt2hMOBxEzi/nbiulcmuD/e9z20yUUXuWpqu4anImu9G2CgO4iawJJkxAK1BeEJgiV3+JgTsFyv/vOzFuP9X4nt8evb6unMXTJHLLXRkBJBVpdHeqIQbij/Cvy1Hq7lzXrYHE/yWRCHueJpxIGuffczw4DYXep0DnmhQxJVXFNGQZA/ps6PxSPDimNXr3Lyr7f9cccUnkycE0dRuXYAA+nDVKe7J4rhTNaomaokaTVgQWeun5GXAfWGd2Jqziaac12s2X2XIb9eE3IcRhHkvffOJ55xw9iycj3umx71t9/TeoT7fdH0nOLabx4Ik3ZMq5II4nru58IQLZrXaaB3PpkLjtn+GaRCoVsNZI7Ezbw56rRXTcO44O0cA1/HDiZ93b+0GUF34M0jcvE4KcmRFfYkgwsevw5gqkF05HFI97nwYyBvPX6CSGf0x9TT19NkrE54P5NjWns+KKg7bMtTUNJDOfp7y7xkytYMPyDIz2MoNnWnEzTlNAUQVvHuvgD4/zuK2RFbwyrz4koc2FsVqgd0PvLuVbdyEPVY7g3cSVW2citg+bz6NyTEUD/q2zoazcHTH8SSNQTDkdbwgVpzBBcMWGrxv8yx7SQocTF4Rqa67UteZWTH7ZMAuClJx7np9YCdjmSvNpcHbeYkxb8krT3jB4XqCC9K4UkUXlLkSclZCdu7JoZKm+dRNqLazq1aLhLSsl+vpG91w3x8ivXVagaFdhN6GDVX9UGcVudRzTQUOgyo5ZexhujX/LZ5yi0oewzYwzS5SJ2egX/HfwqvRFMfSRoXJTMgJV+Ms4cQu6SwAutQOgGid0X+t+X877UpW9+mKMHUTSC/eMiEBKMfXm035iSTy/7W5urzfc2mUenzcJY4O52Nfjuckf8OiZft41bXrihT8/z4c7hiDUxyBK0DrYjSQI5wOqneYSdbS94FpYDb9/oPcdKEmLSCObdZ+JL9Xiv4x776zNMNPeOy0xH5l31CKcOu57UuWaQIO7+PYyO6Fl8YE9ZOvMJTJJMb7iFdsWA+zbx9drJnHx7Txwoe4aSEI9rUOA6L4f7uelrhAzmbxOYFbUp6GOuLJnCkr25gCdEbctTwxj4j6agY2/8snYrhgNJVCRx9FscdSH5FKrt6/P93DmmhQxkycefUHYJhAz9795EjmrEGrGDVqt3TYZ01cRD4z7gj4bZZDwXnLuHbpRpzFHRLF1nhBASuC1Qf9ZwIkvsGPdU497rJ6ONEOjN/l27gsqBL+jUrepw4bAbcPmpnSArAleSC1esjKRJWEsCv+ALT9vOnZnzaBISN+44vdetGLom8/W+gRyftqNX++2I7ALZ1fW4JZfmIxfGL9qHsTmN2gEq9f2NxO7wCI91hUaacgEZVLN/F7fSaRYkDeK2QOKnu3olILEvefO748j/wI7e3MKP93sCTcsucHLR4JU+bV9fOYH8N9qvVsn9k5AdEFF25O/77uCeMYb6AiPuA2s/tcX//XLKt7dx36RP+Km+kM1/H0rU3iVI+UmIEM3vVaNMnHDJsm6P1yobGW+yc8mcb3nt/Rndcp2SXZD5VTVbNg5j84F5zRGlIC6qpmpPHNaUFlxOFVeGx5qsqp0LzIqqQ6SnzZ47RpL7TiXUNSLSPcGsLqPsN4HG1S/+Es0sMAxrYP2EN0L/IgHIViOJttpxxEdSfUErEyL3Ix9hE3OycvhiQbTGRozNXSs5Flbl0+IM/L6tb7SSR2iWDGVAP4TZgG5U0Y2+7xdnjMr+i2yk/8uA7PzfUsT0j9ofdIzZZbtmsa0mCber/RqpES6KL44j/cexGOd1z+rTMT5V/AyEjDChc8wKGUpsDCT4+mQ35hipmeZgQfZPgIFM1b/J4YLIBsyj3uf2c37Rti1hlUz0bt8gAs0iY4tXccSG9oJvypJxmy1EG1Mwu1y4Kyp92ghdEL/JTX1/FS0E93a1Fcx1R/+kqVrcYAFdl3AkmDH1a/SbkvSPWZ8x0mRiid3Mxn1pfnoKjFZrCmjNEREaqtmNEBJ1DRG4UntfkxkqLdmRRDXme1WId+/ZS6SiAMkgwFTeRPX4BJrygczO42ekDM/+BreFqJF5qN92nRb2SBK1W0ZesAYBWD7yLIAToot4e+9kn7bpKwXqt0tAkqi9YiI5U/ewozwZSe97DW1vI40dSn0/Y1DzSMRWI3+LPQl7cRQF7y5HzczAEaLvc+U4E/EnlPNEWs/cRqyykXsTt/Jv9QSUA0KObgBbnvdcKdkVH0WCoRlid7rQNm3D3EHpGhkbQ3nMENRMgc1qRjFqqNGhp8N2DW7FlheH2WzAmdB5PFTqEo/rVU11LJMt5wDw1dA3QsoMV+JupqrDRD3SqLLb3UqKtZkNRUlcVLgm5O9wJBAOB2/Pm8wJ09f4dWF7fdUEMtb3XF3h0FW2N3kK0O1vjOy00rvboWA/YzwAkatKu8wgpmZm4EyK9Ctc1AwxYU8Et1VwQeEaFskTevAtji4UJ8QUu3GJ9sryXbGxIs1LwDiInmejZbuFYyVnVDgmI3SOWSGD5ES/VTbrB0HxSS8H1cXsiFZmn/N82+e8iKtBGJE1iCxtf+E5ohVa0rt3s9iSJMCIYktF8iNkoGuYP1uGen0RmrHrcxyMszVUiaOqgM9uVyL1rsALP1kWkGnj5VGvMNQg2gLR2gndRUoAmkPBuk8JmMXKliKhJeoe7edRQl2hgq4mEbndO/jWXbwb84HigVJWJrVD45HSg1cd6/k2dsWZGLQt07/l7ChgW3MyaquvRBj76mJiAxwjGYzIhXkcd8tyIhUHe2ricVtpS3l81CNJKAnxlE6N7tTN0oelMSTv0VFTkrAXpoZ82oyTS5g36LOQj+sMzQK6KnBHCuaM8c4MtqkxlY11/QCwVErILkHUPs2nTg2AVt9A8tOLaPrbRJC97wejyXdeC7Q4dTcZsCUqyK7gNfcJGxywwaOg+vfT/bkwaguJXWj+6zTPzbbIlsUGW3tl9PT4xXzf2o+hMWUMneG9KLYLA816Q4/SW/cVemsr+b9ZzKrPChkQv58I1UGCoYUSWzwA+f8RqN8Fn/lNbdVZWpPLhITdbdscukq5PSZopZFq0ii72CPYpMmZRNrtaDV+FCaShGy14uif4jfo2JZkwD29gfPyPTU/fg4uK5LmSc2sdfEaVJxg2a9j+XQl7t+rh8bzh4zV6sBt/vkpbMIcPo5dIaMP2HXKS3AKrHE4uPOam5B00auFe3qjD+dAG7Ks0+qOIHoPR7zw00HuWXFOUO3mLL6WR8e9x1kRgeMSJEkE5S6lOxUitnQ+K1sqZVw2E3qeDamXXRj6rOCXrLD5L8koaui+KUqcg61/TaT/VdXodv/HCyGhCb3HBQlDRRcSu18sJOX7fSGlWZCG9GP0K+vbPp/bfw3L43PY93VgH+yjCSU2lpKrB3Tr2MYcmZaL8klcexQEQEuQMLGCaan+C68Njq5g8OmelLQrLx2CvnFre/HAABTctYTdDxYhCg5IjJLgzPz1Xu5GDl3l463DAbzmBQHkfgiys/vKlg9uOZmtj6TyZLr/DD3gqYz+RO04ND8uoXNriwIet6C5kBJXzVFT8VsTuk+iEPeXiayJTKQlz820kZtZ87Gn3kL23oqQ3C5NXyxHXZuO/pnU9tttbUph877QhWOA8gudRGYN9Fv0UomJxjG6n/8DJci/bYtvzayjXM5QWzQSNmhUjfa8zw59/R383eK2uTB9vhxkxa+Lsj+UTvLIPzX8Ta7Yez1JAVuEOdY5OnOy9THSmME4M2L6rP+RJhNvv/Ikpm0V2JINNGf17DLbEyXKj4ug/I5JSGrocqEjTmAfbsM+zMaZA9dy9sC1zDxvCU139E7BosPNb1adw61l/jOCTDQrLJ38bK8LBIqqcfbAtUQGKkgQIvdWDuf8f97ZK30dbgZct4kJ9918WM/p0FUW/mEiUXudOPISkUf6Fo/yR/V1RRT8c2fXDcP0Ga26kweqBjN71hKmpgQX01Twr11se3YczRdM7LKtnm/j7APz2tkD1vnEM5hkd9v+hFiPcsLdqpL1b7XP/exL3c08VD3Mr4Dxc+OkK68j5y/+Xecidqss+2RYj/p37ytj9eQodrcm8E3ZALaUpfSoP3+oeTk4Rxb43eeKUhjy13U+AoYsCYY/sIa6wqPbKUjSIWmVg6RVDsw13s9A1gsbyfj7CkxfrvJs0DVKpkl8vKvz38wqO/l94jrWTHqZYZn7+mroPxs05MP+93Pn5/8NuoGQpT7PzZyoRDD403IqiroO9O4KIXmyQegGqPnFONTUDpOvrFB3uadOQkAkMBjdHF+wHYviwiBpWBQX45NLqLu9mVDef3UDjGjWI+s6pGsy35f246Jd/lNjWuWufUrcjUZMu4NzsVKbJfTiSAySRzf335ZB/NjD3P8uodALdd18UNNS2fWX8cg9cO+SgJ33j0Lpl+d3v263Byz+Fizl7mb+1ZDbZbu3No7ly2cn891zE1FbNU/9Ayn451co9KhCd3tH8OG3E9nWnNzjrt6cfxyZD/R8SMGiG6B2kCmk57y3cQkFk+wOOqA51tDKlBFbqDzTQeMlgQWNHf8ZxdT8HRgkre3PHwf3jU3ay9T8HeTmVPVa0otFz49l9Ar/qdt0PN+9u+x3RfNSQ/e0+b2N2uJGuALEvQiPy05P0Vta2PbCIPYXJ/Q4eUf9MBdlv57kvVGS/GaKqu9vRLuxmugA1t9o1X7UWzPAI2hIOtQO18meubvtb89LmWgTh4De/iPpra1kPgBvfXuc376yTTVcGbsSg6Rgkgw8nPMRr0x82etvtLGXiuCE+Z8l7C7Vhzyaupr3Y0dBWe/51NqSJZom5BC13oK7eDeSLGFLkQIKMs5YgTtGwyjrpJkbvPbFGlqZkbmNL8cWkbje1WkaU6FKtKQYcEVKqA0KbtmAGnXkYjpsW2PZ/kUs+UMK2XDuk35iNDpHcksoQdYTlHTvLD7VriiqDNFA9yxBD1YP5MMtI+gTT2uzCZFj6/H7UGTbENbAQljcpkbyPrmOXbNfCLnvs7afwsYl+Z1Wg7Yl6yBB1C6Z2O2+Eo091Yr90vbFZ/zS/V6B8F2RHtHAjmE2LOuD9yc2V0ss35JHQ56FcQl7gj6uI29+dxw5X7jQ1wSXOlJNS6VlZFa3znUQIYErEpAl0INfWG8vTea+xCF+9yWqzfwyrutrUKe1stzRPatxtqUOd+5uFk/vR/QhyZyUhHj2Xj2QMwYtC8m6GGtoJdYAqqzx7WlpZH3t7rGwEbPTSXF5tM/2Xa5m1jp7JiDYdQOlznigokf9dIfXmxJ4bV/7M9aUYya+NAv3nr19el5HjIRQey4AqlEuWjLbJWs1Ix0tzn/sjNsqMT2AG99B6sY7EbKJ+M1HgethF0SUKGxPTObCAxn3Rsft5Y3zJ5EdPc7jLnUAfc0mlPOKODFqo08f8UoraR2qoRcaIij00d8dffFCfYk4zClsf061vgIRFjJ+htQOVIFkolptaNWd51N3xXaedcUgaThHtNBUZ8XYGHhi1w0SDQUSqg1MdRJCVeAIChmReyQSX1hEoqxw28TpXtpqh64i9ljR0h19FrDdohvZr7WEnOrxq1YTL608rstYkKMdsXIjg0qSuHv8KO5LXhx0cOqjtQWUvJlP/nOLO22nHz+q0wq7tiSV2pntUqKQUkgwGsCtoW3t2iUnw1zPOYPX8GH5REy1UsDA/0OJ2G5km5RKjMlGYeT+4A46wCe7h9L/9SbESt8XeiC09ASqh4cS7R0YtdmFMMidVy6WoDXZcz6lUuKNjf7dEqMibUwY5rnO/hMxeKjQ4Mfmgd0ec35ENepQjZqsTNz7ykHXUFKSaZqUx5mXBF809VCSjM1cNGMhnxdPIWZ35wqWYFDrVF5tTOSy6PYUqsXuGFa0+LcGhkqpu5k0xdoncVB1WiuyJGFA4cvWxLbtj2+bgWNB+2eywDQ4lQhdgBC4S/dhqdHRVRmtw+NvrhZI9tAzfR2kcZgT1do7Zl6hCpQhA9A2bUNLi8cV7Tvv2pIM2JK7FmrmjFrGG/I4jE0mr8QuoSA7NWS3jtvaO890IJJXOai1WVmQWMDkZI+76CVTF/FOy2TyPvdua2iSWG/P8qM06HpOn1ufhaUsREudrKBmtAfzi6YmtPqGTg4I83MmLGT0MZLiqbsR7CImWGoHqtji80l4LfiiTbqQfNwVDpryG48PTq2vrLd6gsiEhKD7FmQBCN1ztCyHprXSNQlZEwc/UDKhhRKvFi7yWczOxyYiUh3+4zOkA3/BnFpqL2AInuu4xZZOuSuO2+M3YZKCe2E063ZuffdGIup//toJAK2qinWjYd62ZGZH1GGQOn/ZVGstfHPVJJKWdS5geDoXSLL/xAlCBv2QU9WeaqP2VAvuRiMDbjMhHF1rG02ym4tOWsA7X07G2CAFnQQhYpuR1TWFpJ7QGNC9oiO6kKh3W8mYU4Le0oKkqj6xVbrT5eXKcBBJE0ia9/3XHWQ3KKu2IgYVoMf5Lh6EzIG6QRLVZ3T9nZqaLcxZfC0AL018heNMvokANKH3SnKDaNXBqkuyyXqmAWF3sP/0Amb+sncKt5127U98/uIU4jf1TDud/bWTfxSfz2X3P9sr4+qISyg8V1vE7QlLiJM9lrfeEDYadM+c/2lLNkZJI8tQw30vXdrpMdXDDVQPz0ZxQtpTlUS/twJl9hga8tpv0KTXV+MOkDTicKPGOtn2Owv9rzIFfLzLT9SYM25JUP1dMmI5C9IK0B9PCjmeR9IFhspGREUVjCsM6djuEL/ZgbM8Bf7YHpMmZJBM3vNjxl8X8eHqk7j4pX90mSWtI9VaC+/eNZPML3yD6/0iK0iyhBwXx55L2pNuJK11Yfx6FWhHT7bLML1HWMjoY7ZNf4nL809oy7pxpHA6DLy3ZRRnD1zb5rdc6Yjmh+J+3TLJmasltBYr7sLu+bsbN1tJW+RAKBJ7LtNCEjTynxfIC7t+KRTctZTKW4poKfIdoxLnoDVCwbq5a4tCa7rGRVPaF8bzK/pTU+8xI78kFbFq8gtdavKrtRaOf+ZujEdPJtxe44WB/fn7FzksGP5BwDYNuo1fDDgJWtcHbNMRecEapFFDcPlZEFeON+EY2up3+apGO9nx8mAKb9yJ1hicO9t5Mxfy5ooJROwIXrsYuxl2PGhh2A+ugHEAB1lcnYfxlFLQPQuvslvHc+ovvF/M3zxXROLzvsKXvmYTWXvjKbmm+9YAQwskz12MLgKX4qscZ8IxzPOchDobXLP0cuYMXs59Sd4uYJ+3RrKytWfBwIey9cmRXDxxYa/2+XPhqVpPDYhCcwVzonpWEXynq5lrr74NgL1XaURHtWJflBj0b68ZYd8dnvFkfl2P9cPNbfv0LjKC/dyZnLyTxgf3seGe4SEpD43rd6PV1CJHRfXd4Lrg/JMXMn94f6JP9U6GYfh6BZcNP52PN3zTpbIIPAqEy0aegakmcFa1Q2k5ZywN+b59Vw83YE4fT/RLPwbd15EiXCcjdI5JIUNevwNDQT8cqX3/sCuSjNzbZoxuIoTE57vafax1XfIRMLKTa3m2/5t+j9eExDlb7moL+lXswBZPASt7ngPV1HXkX+KnZhSXQLG7DwQLhvZC6veQHYpLgnuRCUH6m1tp3ltA+QXdN98DbRagz/cModVubL9uQmL6msvarCXZ0XW8V/ANAAXfXom0/4AQo0uYj47boPfRNaJvEcyM7UQLKgSiNXg3IQA27cCoeF5Kkqqy5f8GIRSBZHZ0mt5dkgRbHhzEgJebAFhTn0n1izlt+yunu71qNMiS4OQRG2gYbKHRaabkq9yAfWd9WYtUXgNuN1pTE+vndK2RtLjcaEJn/8cDiTA5GRy1xUcwybt0OxVn51PXYiHz3EOuUxBxFLZhNsbl+Y+R2FmXCE8f6GPTDkzZGTiyDilEKvXAKikk3t05iq3NKbyRN99rX29kVYpWbQydvYWmf1tBoterYfe/aCurFxaSPa9nc0TcNgczZ3uega03mpkwsJh+EVW9MUSg/VruciTxm9Ysvn26iDf++DcKDf61z8etOwfHu/4zNEk6ROue72tdZqU11ooS4vx0cAosnxJLXMqYbld9/jkSrdox/64cXUjsqkrAWedfyaQ2KPR7YC0Amt3z4tSbmzEu3YJr/IA+T0BzKLIkUAI8P1p9PWeceTk3vPlRpyniP28189RF5yFqg5/P6y8rwpboP3ZUSGCPl3BdNR5e/jjoPsP8PDgmhQzd7gB3L6TC8MMLDen83w+nA7D8tL+TqERwadJi9p0US+V/M7s4OnSEppH+YzOV4yNxBxHD6rAH1taOyt7LJSlLA760AKaevhqbZmBRcQHmdZY2gcNQYWxz6RCy8CoCp9WaiNru2WmpcSK5O0xyAqKWWWgY5kKN8G8uFfsspC3yvAHF9s2dusIo/fIoviyVnPuWgBBo1TVELTfhNmdTNdvbhC+pOq2ZnvvAvF9BPmSNEVEukF0CU53Muw2eatLmWgkpFrB4voOQoI72BVqrw8i1xuNY+NkIcpY6aUmRul2IMRBx2zWiNlRDbAw7fu1tIdMNIBFkRHsvsX3uBL/xOQMetwcd4OwP4XAgACUlmfLz+iHH+bde+CNyj4I7yoR1v86ueXmklrXfM/FLjbxb1l4dfNJJG8gw15NkbMZmNlAyoX0Brq2LIWteS3vHu/ahNTW179+0rcuxKCnJ7HpoImdmLcEUIKXYwKhKBkZV0ug289VDRfR7dAtaXV3nHUsgxjUgSTAicX/ABW2Mwcb8hzz1GPq9XosoKcNsd4Is4chPonKMGVu61qO6XA67gQ1VqdxuHtvjCuGHIkuCfhFVvHX3ceQWlPdq3wCFkftZHuU/rWkoKHY3YsUGANTqIuodFggtZCso7LqB/Y4oYnY5OfXDO9EDaC+it6gk7urcDaw50xNLE2wSDH+4reCKVI6Zqs/gcYFsdXm+sdHoRg8Q96iZFSovH0Hyiyvb3SGFQG89CiuBCoFYsYEH/nEZ98aAc0grO6a90ra78MfLUNdHYmyElBW+LlKSqrLrgXEICbL/60CZv6ptnzNa6rSQqFA8Af9HO5qQD2s66hB1sEclx6SQASC12jE0OXFF9c7UeG/lcOrdVr7aPJj8dzyTyXWDz+LP2Z9wshWSC97lnE23Yi1Teq0Anm4EpX8+2pJ1KCOKcFu6/5DmptRwScrSTjUYAEMjynAJhdXWTATtUo2xY5yBJOHQ2/dFVkokrg/8skvY4EBXTX6D4TSLIKIUon46EMwbFQlRkQibHb2lffGnTx6JK8ZAfb6BmactY/XycUi6IGLTfty79hDzaQP1/Ua0tXfG6chpdkjwjMu01YqhWeDuoJCyVLlRHDrWSojtEEvckm7AGelJheiKgpZII3KkC1kROOwGvtteSP//W4Zwu7HOHEdLeu8G+bmsEq3947GPS+KCWd6+6c2aiYXl+TQ0WXqUmULdYkVuqqMz5aZkMlF/3ig+Pe3vDDH6SriFpTcSP2Qi5nrNK6NJyMRE0Xxc1wKG26ai1niudcJGF7pBxlTnJnWp98I+dofT6/f8PrOQcf13Uxi5H4vi4qwDlX4B3tk6GWnx2rbP3TJGxURxwanBxRBEq3YumLWAbzYeR8IPe3GX7kO43USV6DRnym1paHUD2FM1Ljqk8Jw/kozNbffJJzVTyJgn4d6wBSSJxumZNPd39UqmOFuria92DoJeFjJcQmHx/jzOnr40oJB2NNLkNFFuj/HJ6tdTSmxxLCouIAfI/aSz361rRZotsfPFX7C4rDJKvzy0Hbt63lkvorlkzNvMCK17ZmSbZmB5dY7ffeU1XWdNU4waTVNsxG8ZinH1zvYAZyEw1Npwx5o7T8TQB8SabTSfNs5TM6NjHJgkIYqGk7TK814td0TwztgYXtnnSXGb/qoJ0yHxF+K4kThjPTeQZpQ5a9ZiDJLG2/JkMqztSSO6qkQe5n+Xn62Q8X//93/ce++93HbbbTzxxBMhH+8u3Ydis8GI3sn+8e3jxxG5z0nH3hruz2buX6fzl9TvqNGjGD9mO5t2D0Qo9ErOekesxN7ZKWQ+W4Hswm+AqHTAJaqz4nQms4u5/d7ya8Go01ppEe0T9DNvn9ZpjQRJgOyA7K9Ccz3IfHGDlw/9wcBYeUABjpRIHMNzvcdc0YS0zZOyVLjdlP3KxdkFK9v2T/mzx7/98xenkPZqHVpjI1kPtk+QzlPGsvv89ts/dUE9UrMNR3Z8l2ONKHMRAWgmmdrBBqJ2qDQVCmQ/CzXZpaM4PT7MvYFuBP3iGiZnbPG7P1JxcErmZt7fPhLNLYcsaAghobWoFPx1Je5OLEaSyYQ0qIAljz4H+DehbbvCEwT715r+/LiqAHd536Xh1NwyplIjGT+EHsCb/xosv6CA5DHNXlnKKh3RKPaeadckkwkt1hrycSfevZD5ruOIfGcfelMT0W8uwX7TJNwRoKvgSNC5ZHKQAZcdmP2Ln3gnaTL9/hqH1tBIzQw7qtK76rJqrYU42UKtFkmtK4J4Q0vXB3VCi9tE7XdpNJ5bQZKxcyXIkULSBZJb99If7a+NptVh5MSsll4VjpaX5pDzUs9fILqh9zTHLekSzplpJD/dAyFDklDT03q3eleDgay/LOo0SYnklH3u02bNhFtXKG2Npfa7tEMO8CSeEEOCt6zuuVan4O/ZsLw9Jk1fuxllzBBElMlv7Y6+YmRsKa4Hy1k339puUZEVlKQEtt0idfhOrfzmx/MZdJcnta+5ebXX/a0kJrD7V27O6beSQ7lw5gKY2f75/Y+m9MhadrSgI6EfxvJyem9ppI8gP8tifMuXL+eFF15g+PDhR3ooQTFm/i08UjCMuuNqSXt8Eebq3rtxhAJ7bxlB0qc7SNjsu8i1lihIpYGDkmVFZ+2E1wK6SE1cdAMz5/667a+rlPRqMySu62EecVnBPWU4rqkjcKRE+m3iSI3CNXUE7inDoRO/1tOu+YnNj/v6zRvnraDwmvY/ocpBCRgdURw6SasdJK12ILf4dzZRv11Jxme9t7geO2sDJwcQMDpybv81WCyh+5jrNUYKr1veZXamugtG8+UXb3Ta5iC/SdjOf5Z9gGToO4eK2MWmbgkYB8l/R+OHd8d4bdv25yFkPxD6Qr4jtRePZtwLa3rUx0GSn1mEtUJgH2zj4undD36+YOYCqv+T2HXDbqC5FYp+upnd7lb+9N+z+ent0X1ynqMNY3ljm6tUR5pbzHy8rXeD33sDoUr/z95Zh8dxnX37PjOzLGa22DIzO9QwQwNNXUrTcJv0Telt3/Zrm6bcFMNNmxTCSZuk4TZsZkZZli2wmLU48P2xtqT1gnallWw3vq/LV6Ldod2dOec89HtonWmOSxQjXiglE3ht3evYk8d3NVryosqKpwLv05fXzOb9F+ZQ/XpwGp1mBV8MBkYkjA07MDd0xeFIo0OaWsG+3+QFfSbFrrLvwRL2PViCunTIeksICl93clX5Fk5xikicdEZGX18fy5Yt449//COpqanD7xABraMT8+pdw28YZzKe3ULhg9so+lfb8BtHScOnKzB3eil4O36h+dIXbkHeGnqRHw41AdqmjSw2qpRMQF86E33xtOg7OksC8U4eFxSH/x0vnbmF7tfLwx9j8QzUUabNJdZK6M2hjTlt/0GK/hy50dNw6AosumoLBdYuAF7cN5MP7lkc9O/1hwdrDc4p3ENB5jB5/UOwrbdT9f3hawz2PjifP//o1zFdf6ps53t7ViPmTo1pv/YvLUJ7KLLx8MyiR+ktjumwIcnY4uXt3/i/vw2fmYLt3yfeBNryCS+XTo5OoSsSZ+RWY3svY8z6yFx3zzcoemP8lA42dxXwRt2kcTvfsXhzk/xj15F/mm3wsxu6xIv7ZtKjRtdL5uNI12cX8f13ngfgvfmPUpYTe8G8rGhcPHF7wL+LFm3G8WEm39y/jR8//2dqPjv8cZ57cyn2uvFL8tD2H8SyI/4NDttmWCj5RvC8uKK1lO2X5A1EMXqvW8juO6Of55XSYhwfZJAeQ4TyrIs34iwcmzrYU5zYnHTpUnfccQcXX3wx55xzDvfee2/EbT0eD54hHtmeYyUtDQPd5cKyow5fZT66SSJ9q0HpP2+h5spHYrquOXdu4sMXZpO9bnhv6tGHW6rVKHxLof68lLAdu6NFs0LHJDsJh1XyPuqn57v+AaBtRybmboGv3gYFgR6ipEQn35r4VpDmerfuYu6Ht2Ftlok1ym8I0C3QVW4m6aAv6m66elkhulVBN8deflqV3IxNDp+bnKS4WZhdy8sPzQ9+U/hlT9NfN+NoHHleetIhFW+igi+UmIuuobV3UPhaB41npwU0rooGS6dBxtZ+sq/p4fl/LcXUJ7B3Gpi7AiMVhxdbOPPyjSxLGVROak5JoGVCIm7dxL2bLg6bPpX8jo2sla3DFhvv/fNc7l3yYsgajO80T+eFN5cEvDZ5cQ0vVbwFwBKrhG6So/YANn5jMebT25ie2kCyxcXmuoKA65cVjR/MeJVr/vUVMoOdyDEj+QwcTT5eevo0Cms2c/j2OThzDCwdoa9YUiH3vtFFOgCee/1In45jKNzdEVQDIlu0mDpch8OjKzT1j526nq1TR3brJNdqvPjP0/jklSNrnLe9O4+tW4rJrdFwaYNud5dmYkVz6cDf/R4zXq/CfxonDrxWmtxOqSN+jpxIGJLAGDJ2ZWyQ6JxkgyL/mKv6ZFY1lSBLoQ2vHEcvU5MbozrXrLx6Vn22lNK/jf6644lmgb5rFpD40iYMX/RR1Lr/W8x5V61lvsX/+2bJDr5T/Bp/sS/lw5rwzqGh2O0epmQ2BT8bsr/Le6uaxGx7Lz9f8gL/qJyDUzXTf09+QH1kn2bh5bWzsXdH35wzLugaqPGvNdJNUGQLHs99mozaMKhEp1lEVM0PD51nISd5Pgm72pmcFFt0Ps3UjxEhLdOXYJA0txV+E9Nhx51TEraxc1IZGc888wwbN25k3broikh/+tOf8sMf/jDyRoaB1tyCKTkRFBlTtwmhJ8KVsNXrDttCvkBRAxrXPJi/mrPOyaY2JzB/s3bPJJLWhV5V6k4nYkc1nDc3qs8zHO4MgS/RhOJSuDDPr+zwktuCtiWZ7LU6vY12+ua6BnpS2Ewq1yYERj52eZ389PAFWLbEnkd+FEOAJ1Xg6lewdmrI7vAjtjAMzC39+NLs6Kb4BdZ29uRQltA2kAudIHtYtih8E7in2hdjbbGg9EPm5tgXcaYeDUejTJ9ix9LpV/0KQNfQt+8mrWAemtV/T+mKoKssvFGVdFBHceuYejWUlh6e2jyfgg0app5gj1DTQgul5xzgwfzVwOBvNwkd6MZnaLxXUsOBnnTqt+XgqAv8rrOWt0TslC0UhcNfns9fznyQ00Pczt9pns6zHyym+N+Bi4s97jLOVS9FFjqvTfxX2OOHwjnDxeWFfk9cuaOVzQSqs+maxJ/ql5L3AVg6Ryc/ehTJZ5C9zoPrjCn0znSTm91FS0dSyG11TeC5eB4Y4NjZjFp7KOR24fAZMs9vnU3eBh1LZ/AkL3wacmrqgOHX8+mFZKfF1mU8HB5dGej1MpZYOlSy1+s8VTKfy6ZticlA2txVwI59BWRskrC2e9GPFLJ1+ezU9KWHvP6hrwlh4NYUJGFQldg8+g8TA4l1XnSzmY4EC2fMDVRYa+xPpqY5MF3Nq8oDUueRFnAv7puJt86B4hVAfO75eKEr0F0qk1KQi9bYFFVDTAAxuztIkex0K2xMrOdDhjcyEhxu8pO7IxqU210FLLXVcW1CN9cmvEu37uJK8WWOlioq/Qb/OTgRR+1JtSQKS1eFmb7y4Z1mxpKZ9BVEmTVQ7KKnyU7CCJM/EnL66FMcoIqA79mbamAUuTgzdx8bI+x/ipOTk+aJqqur46677uLtt9/Gao3OFfztb3+bu+++e+Dvnp4eCgsLQ26r7fU3p1FKi3GnJtOtu3ilZxbuMEmrpyfsZqm1H7s0mGbz3pSXYUrgdgu/cSvJT4b2dgpFQU4fXcrXsfSWaXz6tMHzXVG6lSebF5H8lyYcLxyi+tcL0cwGhi106PI//ZPY+FJsKS3h6CuQkH2ENTKEYSC5NYwDdUiJ5SM2MnZ3ZzMl+TA22TfQXXlPaxYF9q6oCy6Pfmer2kpwNeRha409qpF00EvaDi+sDZ/OYn5z0ECWEhPp/2z4fO3U9w+gtbUjZ6TjnlxAyV8hlGJMf56Jy69Zzk+ytwa9dxSTkHm86CP+1J3DQ89dSfpjgfdkpEC2ZLdjTClj/Tf+gEnI1Kt9tGkmJGEw3WzlQze89I+lFK8IXlTkfeRB/ygL1Syh/ml04XKzRcXrUTAMgaxoyLKO/uMsLMTRCyjAm6TQcLmKbNLDGhgAkmzQsMx/n2S8mkeaTwVdj6rA3aWZ2NGdS/HfBEIPff2e3CQskgRHjIzJd26Pu1LReCC7dEr+Cuu/WcTsjLqouqQfdiezY2ch6Rtkkg76F9MHetKwSCqHXUnsO5w17DHaOhNp60xEknXyyrqjOm88Sd7vxWe38PkLV3DmkPSp15xWvtd/OeCv2TAMQW+fjW19+QhhkGPrRQnT4NH6QSKl/6wFk0LPrFzMPWrc1ApHizBA8oKrLANrTy9aFEaGPLGcFEfoGowU2Uligv+9o99TKCakdEYdBRo4L4K+AjOOw/5ou61dx7NmeLWokwF3ukLPGS6WTQ4uyD6W2kttGEXRy+mqdvAUpIzoui4v2QYl/md7edvgvCdK+rl24iY8J6amQwDjL2F7gjzco+CkMTI2bNhAS0sLc+YMFmdqmsaHH37I/fffj8fjQZYDvcIWiwWLJbb6gI6FOVx800f8si1Eas0QPuyros7Xyo3J4RcUmhE55ioX5HHwuvj3zjiWZYtWseZPxUhnQ/nd/k7ZPdcvhM+P+akjpoHJLhVWb8V35uyRq2sY4Ls3hxVft3FO3h6aPUl8VFvKtVWbRnS4RRkHcH2znk3fnh3Yz2MM0Ht7yXowfLqNil+i2H1s47ShCHjyx7+izBSdV/rG5CZ+kx7bd+0+bTLvPf4YHOmkcOmmL+FbmYZqh903Pcj/fvtWcltHn8ITCUkYXFG6lVdqp+JyWijO6OCx8mf5PHfF9TyqXabpmsjN/kLRdombtkuyUPtNVN4UOCbohgiSmV3dWoz1F6nRB8OP1CiFOtbJguUXqbx1SwKfrNwc8TPohmD5O9PI2W5gbx701lt/kcpH52VjFMVWGKxrEm/sncLFE7eHjKTohkCMNl81DBnbPHz/ri/x7iMPD6SlXmx3c/HcZwGYtubTuF2DjirDEPx7X4Tu7oud7F181MDykPeUGcV5YuS6S77YRT9u/NfbfDKhJ+R7X0hq4Qtzn0UzdKas+Dy6FrtaXjgSJCtrf/IQc793G8kHxj4iNG5PrIDML9dyVgSjywj7x/CknNnEguvCR7yjIdfazTWXRifpfYqTn5PGyDj77LPZti3QQ3zDDTdQVVXFt771rSADYyTs/9VCLjpzeOv/KIe86fy8PZFvpYcu6r30E9eSsn/9uDqa7A0yL7yylKsvi/wQJz+/Hk/nLPjz4GtLt15Fx0c5cVUD6C2S8CaaSa4Z24Hc9vtU/jHnNKwL2rlyYniPflTHkn1M/vE21v9u1qjqNEaLmDsVb4SCdFemiZd+dR9ZcmxpLx99+Vecs/QLZFw6fJH3sZS+eAu2Rn9dheKEyQ/djlwEkqZg6Rj7HgYXTvDH6sus8UkbGkp3iZnOM91xvf/T/r6OTZunMueJkRVre7MciIxZAOy/R2E/UH+2zKfOHrm6FPh7Z1xRtYWX90yP28ItGvIet7BSWoAnWabjCidXVG7FJDTWdxSx52AO9r0WJjy0gxLXRqTy4gB1uZrrJOREV9yzlFf8v4VU7WkbsYd2NKyZ9wTXVl/OnsbQnblPAbKQ2Lj4TwB8v2UBL+2eMcwesdFbZMaVGf1dJbtA2m7HMzV6hanKuxrQ2sa2PkizSEy+ZxspSvjIxLNvL6X8h1sHar1Kf7CR9mWz6TonOsO95+0cNr1rHfF4doqPHyeNkZGYmMjUqYFpPA6Hg/T09KDXh+PQd+cjHZNyVfbbPegWI6aQumZIOHUzf+rO4frEQ9glMzccOo39P/OrnNhrNmOMQUFXRAwQ6vBDn6Gq2NZUs+SuW3j3t/djESY8qhJzofew55EIEii31rRidPciLGa0OVPCC5jHQNMCE9L0buZk12MKk2oQCykmJ/JnWmh5J4esDWPrpQ+HIYnIKlvCXyQZK6mynURLdEZf01cXc9UN7w/8LXkDiyIlb2w9X+Y+uIm3H1hC+mPh62MicfS3bfMl8teuOcNsHSOSPwVqVIewqdT+aBFlv9yB1tODoaqIvbWsuns+U36xNeL44kuU6c0fHJITDmuYu1UM2X8PHE07zF4t8dr+0zBkOP+LK0d8v8fjOYkVyev/DLJNQtck3j5UhRAG3pXpVL3RidTThnq0YZl6zPUpxqiGivfqKpiR3RBUDCt7dPSD9VhaOwZeU6uK0Gz+30KzSPTc1oPjiRTMXbEPkLJbY+bvvswTt/2WOZZAp4FdMvPz4n/wSMLpvLF3Ssj9dU1Q8Tsfe260oyQHPrd150oIXcJRL5G5KfpxSmgGaXtUusoU9JNgFXA0Lfn29I+4eEGg6ttuTy713tjkx4diSLH3rRIaKNU2vBM8yKbhq8QNpxMipL7o3T1YttYG9YOKlt4iM8bV7RF70vzrL6dR8XoL2pAmtobHE/Wcn/66lfTl9RjmE0j3eJzx98kYP6fMeJ5rrDgJhpf4o5e4wB74wB/6UhUpE9pjPpZmSBzwZPK5tqlsqSsgYYWdrJf8KTDHO6lha3c+Xs0f4Wnvt2O5fmHQNvFsyBQNlvou9JY2dKcTyeHAlxyfdDFLJzh9MtmW0KH3kXBWzj6eT47Nw6g5TIilM5GWbx7VuZXiInym0UfnRkt/oc73M3fiMzSuqb4I2Tm6++Un2Vv5Z95S0kd5XU7dTIcvdgMrHD0TzPSGbuwbE5JkoJe5aLtqCpnvN6DWHkJ3OlHe3cA7Ly5mwnm1zE4Nlqv0Jiu40iV8RwSfbC1GWGU2a7uKtV3FkOD5jxawdN6ukCoyxwPDEFi225Dd0UUA+/qt2NbbyV/ei75l18g6qkeJ02nBqQYu8l94ZSmltS1oHk9ADYGpMQHFbMJTlErduTLXF+3kPWXJsYeMCqFD1noP7ZoDCP5epphtVNhaeOPYgj5A7TGTsVamu8ICSrBRKGf6jdY+xYIhLAgDMrZ4hldHMvxiFRjxWQIoLrB2hD+pUlwUsp/R//5jEQcveYu702qiOk+JKYGSYxb12fI+nvPN5andgQIqeWndLMmMfFx7m4ZqkxhJfEzpF6gtFtQ0H4oteKWuuhWUNhMpu8HwRn4eDFVF6+iKuE3zfL8wSfoODwg4dK55oAmBmu5jWUH4iuznX11K2dvtIcU9Unb34cpIxDU3fAQk8UMbaaubUGsPIVcG9w45xSnCcVIbGe+//37cjvWJa9aNqjBw4+Yyit7QcWw9CLk5Y9rdOBKGBJrVoNmTxN7mTDR1cKHae2nw5xOSzhYvzDCPbVqQMAzkfh9ada1fsi/OpG/34E5PYGN2YchF3Ejxpeo4s03Ym6P7fnwJCh1VCnkr5VF9Tk9xxrh2gR0On6GxdXsx1lF2wD5R6S0BvTR+TcA6z3ORVJuBPERxquCnK9mbvpCG8mR6mhKp7HOhJpjRbBKuDAl32uB3m3BYHfD6h0PoUPKSysqMUiipidnQkIRBTloPLd0JAePEaDB0yFkTRcGv14B6vwxywavNA8Ib44VLM/HvuomU/HI7Wm9v0PvqQf8YYkyYw/WfGF1qWjRkKj2kp/QNqGPpLVYkryCpUZD+5AaqH58UcbKW0z240/2OLWO7gtCjc3EpLgNViFFHMxSXEZRaKkxmJJs/Y8BTkhEyKltxXzV/qVrA3fOjMzKOohk6rzmPptLZ2daTh2ljYNpo7QQryebBOa83JThcYW9w4s62MdKWYdY2gVsoIaUnpB6FhIOCtD+vjOhwlLOzIC0ZJIneLH+UwNwTrMrYX+JDqBKmfjOGBFect3pYYROPrvD2oSrK7tsdXp587TYKOkvZl+N3qOm57oGIrmEIRIOVnKf8kVkA4fHyr9qpXDxhx0lbHzZSdCS0Ux2/Y+KkNjJOJD592kqetCzEMW0CihOyH2iNapEpNH/X7nihJhgYxS7e318R1faGLrFs1U08v+gRopyXRoTk1SOqLsWD/A88NDdMgNvjZ2R8eslK/pkzHfsDJ0gjrSHztCHAqQ+mT5iEjEmMTfTDLpmpufIRyp++FWtL8CCrKwJDEaGL5YVfiz1WDFXCoytRK4SdDJR93S+8kAMgBOKMWXSVmVCHtB2Jdd6e8JjMR9dURZRoDoUsdN6Z+gJnbbuG5ggqWtFiAIYW3QRsafNQ+k1/2st4Jm15dYU+zcLm9gJyr4gtcqIr+J+/EYyTullCjhBe+FRiJzMm/5VLProDgIl/7ETbscf/ZoziJYYsIMr+RKl7vHSXmfGkihH3ahIGwd+JEMj5ObhLMyPu65lWRJqjDY/hwyKiT8Np0Zx8509fjvhbOA4qVB8c9Lqv/EIp5aaGuI+R1lYJWkfWzFUoCs2Xl9Fz5lEHh98oSlhhJ3WP31g/etuUPqtTf5bC6Xf4+yBFGhc9uoLPkNnbk0XOFbuGfca0fTWUftNv6FX/eiF6pv/cer+Jym+uGtxfCLTGZnKva6FruT1ietYpTgGnjIwxQbVD49cWUPDA5oHGeyG3qz1Ewf0t1N85e9TN+EbLtWtuQq+3c4IspU8RhrZpFvQh89m8B7468P/2JW2sm/3c+F8UcOa3VrKytRT5Z8GJUB1VFlZ/53cxLSIAKr64mbe/sohLbxhZI7cTHsNAfn8jcuUiVJt/AJDUI31axsGBpRkS97ZNp8cd2yI2HHqrlZJXjp9QQjT0/qSA3e+0YdFjd0Sc/o3VvPr8YnJWx1ajpdpl3nj4/gC581CsdJVS/nm/aIU2wiioAOqXqWS8YYlatCJ5vxdXpome4pF5aJNqdaxtgefyTos+91D8PIOp59zJvs89FNX2T/am85Mnbo/ZGP/1X6/iuXMO8dakV2PbcQzZ/+N5GIXByVq9S5z0LhZoToXSpweN04L3vWz6YBaGIjH7xxvCNqF9/w8LSf/bOiB2gYzyr4fvQ+a5cC71y/zGzQxlZAqOp/h4ccrIGCOiLSQztPFsLRoeQ5ci682OAnOPgbxpb5DXUHc6Ma/bi29OxQmVGjRSXJkmVKug6G/7UY8sEprvXIz5/Fb6XBYKrx5ZW2rVIdNd4n9UdXPgzzTUOdq7IYOy6lsxBOy6+g9hF/Vlz97KxEfbR+RB/vuVD9BvBC+WZph7uCltJSsfCl5cpMt9MRsYAOhaxNzyFMWJ9H8tuB7MC9nM7kSg/5ML8H6xI+R7bp9C7lV7yf7HXnrOKKer/IiHdRwj5JohcXp+DZvb80cVzVB228nZpkV17c3zLGSe00a/1x9tTft/ZowNO4K202vrsDrduCvip7wkNCMmMQ7Lmr2svWMO8x/YgEloIx4iLSLKqTYOqaRCGPRMkHCnWVBcBsn7I4s8HF5kwZdsYImhJFFokLbb/z3KIdL6IgpWHHssPfro3Wdqz2TNR5OwjGDaFDrUrixkYtvnWL34Ya69/naU7bshO3yvojFDktn/8/no2aHlsgWAMJDtKjVXmyh+xfBnAxj+70p4dZb/bgEA9mYf1qbAiEJm/R60Ifd57Y8XoVkNMjZC8pOrI19biHuw9keL0OwGmkNHOfJjvV47GYAJqZ3MTKmPeMhVX5uPuc3vcHXnJrDkZ8NcwwnKqT4ZsXPKyBhDnJ+YimNdLVpzeG+CofrIXd5P8zwH2ijDCN4UA1+qdsL9qJJmhI7oGAZ6iHzokxVd8f9Tm/zdhZvuWgxndXJe/m76NAtv/GgRwoDif/VhrIsudcyT6i8IHppOEw7FCYpTAgGLNy7j8Wl/Zbo5+KayH5bQdoWWXR6OhVaZ0AkuDjJkKDHFLp4QiZzVvbyYehqfvCo4miEJgwXptbwn58f1nPHiwGVmyPJwff7ukO97dIVX7lmI0EHyiFEpu6VulXlSWciyebFP3ikmJxfl7cBa4MOtm3h8+6KY9jfttJNco2Puju4DqHYCCnKfvHERE7LnYXk90INqeDx4yrJouNVL/sMjS0cZStobNmzVDTG1btR7e1F2HBj4W57bxWFSyF0VXTSjt8iMdG3rQI+M8UK3GKiqQFcEvUWB351qA/eQXjmqw0CKUmHc0mVg7jXAYMT9OXqLzKhXBRrekttMyWs3AbDugt+SEUI171MHPsGaLeU4OkbukDL1CXzVDs603EjOym3oY1AfeBRbq0H61t6QdreQBEauG1mKvIgUwkBJ8WI75ET0B9aMWY+UMRmd3QP1EgDdyxbiW5gSsK2v0IOs6LTNsuJLGHy+c145ELZ+VC4vofnsHP/+RX4VraFri6P9XepECv0+//8ffa6fXL2IlK2DW+es3TYw19sOJvPao6cBkHxFI0uzxrce6xTjy4m2Hj1pWd9RhHAF+iTapyg49iVBBCMDw0Cs3EJy1nx6CxRGKpijOo4YGElj31joRKS7zIxqEzhzjo/lrzpkZB9Yu1QQAu95c8i6rI4F6bUAJMiegQZE7+xaQlL4iPQAvkQZV7qEJzXGSdUAz/IMfpF+Af+T+3aAbOa9bVXYWqL/jhIPSHzt8Gzuy90Y2zWE4csNC0ioC39+YTJjzBlsRmYAWZtUnq6Yy3VTN4QsNOwql0jVlBMumjFvwV7KHa1h37dIKtdc4r8nXj4wDd+2ZFJ3jez+NfcYKJ0jH87PSNjFEquEx/CxMq8U3RA0dCfjdIZOpdI1gWj2v5e2S4v6u++ZYMaTHbjtssWreOnQaeS/Hry9ZpGYkN5J3aIilHYDNQMU68h+5/S396OGGIvlyZVoSVYkpxd9a7BBaPhUntoyj4sm7+Dykm28Lk+msyON1D2Rx9qeCWbalvo4MPOFEV3vALqBabcdT5k7KrnUgF1N4MwOHD98SQZ6yaDTRxy0YeqNboyRfGDu1VH6tSPHkgei0EI3/IpVEegpPvKdHGlGeJQftk7m+afOJHudhzsnX0KWtZfTEvcONOp7uCuf9asrcYSoB4sVU49AX56KXFFC36Q0fDYJa5uBOyO+0XRrl46xPjh6LdntaDMrQolthae+CbUnWDnRWDwD36ScgNfaLnZjNqv4vIPjwdGVichz05M3uK2tbQLJa2TU+oaB1/QzZqHaFLrKTIjz2+nts0VsTup0WnA6LQhhUOvwp8tmrJVJ+/Ngo9mhd63W1T3QhPZQxmKeKvfLD+suN3DipLKFQkdCP1X4HROnjIwjdHgdWCQ1oJiqRw0fWjh22wMrirD3jXyQsr20FunCeXRMMqEPySwJFZk7ttDOkMBb5EUxj9IrIxkYkhhe/jCWQ6qEleI8ilB1MEkxhdiHotplrJ9s5syckXnnR4uk6fRn+xsOKu9uQJjMzP7JxrD5sqpNIDkc6P3hi+Z0RdAzQYkqghGOzS9P5mtnp/B01d9xH/kJXrnvLDLfr0eVolO/yrp/JRv3zYXH42Nk7L2zirRVwQXKktUKJhMiO4N9dwbe9HqTxMSvHqT65Uysso8UkytACe7Kaz/ihZdPI2e1juw5MdIPY+Xykm081T2f5Hu2oC2ahqEM0yPlGJqX6jEXfofCIky8WvkGALfUL+K9/ZX4nCbEsf1DehSKX4+9/qL3wj6WVW6OenvzW+tRtmTz4upf8bl7vkbnJBPkx25kSLIOyYnIqorh9gw8e1JiIvuvT0cvc6E3pVD5fb+GsN7XN9DXQO/vp+LzG1nzaiVLcmu4qGgnNZ/JoOFn/nQvQw6dHuS9vIsD85+O+VqPxfB5KbpnJft+vwAyho+g6LpAjpTXZfi3kSTjyLbRX4srU6BaFVKr/c9Zd4mCdsSHIXshY0v4MUV1yOhXtnNgTnDd2Pczd3LJrZv55rrbaP5eKc3Ay9fO5pOXPYrP0Pj9k5czQtsyJIYMh67I4pFb7ueLT95B8Wv9NJwRW1PTSESa90RBLge+LBAjXUBKMnJqMgBN/+vmoqLgsXl5SxmNHUn+NOgINH/SgyepiIxnO9GdTuT0NLzf7RiISLg0E69WT0WPQtDBMARraosByHQaSHZ7xJpUgKJ7Bg0R1fARP8mWU5wonDIyjnDoF5WsutrH9VPXD7z2n5fmIYWZR9U5vVwdw2QZDZY31lFwaCKHLhksnnVOUIOiE3K1DaXfP4kYEnimOSN6GqJF5LpxJphw1MSv2U7eu90Ym4LzrYciLd+MmDcNX4Tu1mERMOuHG0mQj0/DPGEYSB9tJf2D6A288+9czlMzF1Nx55owBxW0zrTERXWs7Z08Lnr5m6Tt8n8/iXhxl2VhTklA3xJeV328qf/ybNyzQ09IUo6bPb+bQMWZ2+hWVdZ9fzGfvDIwferqyz/imfK5TPjT+KalxBtDVZE+2oSxZCaa5fj2SXmkYBWL2vNI/kI9viXHNjwdv6iR2tTMV4sXc1/NQ/y+4Ry21MXWW0eSda6ZuAmOrG2f+mAJFXf508p2/24iitWfhiLluKl+xK9GVPGD3iBZ3bRL9vKv3y7k+jNXUOpoo/RH/g7ON6SuoswUvwXqaLHusEV0FJl6BcpOG96pTiy7bDGn6fkSoWVW7GP1sl+8ys3JjTHvN9bsufEhfnllGX/52/lxO2b+fzrHbHyVplYw+69H59TQkdKlWfupdmSy4WDRsMfrOtdFd+UMyn60hWn/6cAkBo9pk31cM3ETL+6bieqLfjxqvcxNV8VMCn+0cviNTyI0Q6CNo0rPeJ5rrDhlZBzliFPhvaYK2tf4w49KhMFX2prIC7tOG/jbFCeJfX3Pfib0u9j1wwwAZCXY2+ErcePVj9x8grgYGEeRE330V+k4do9ecWbCM3Vojc3Rbbx5D5bSIjz5yVEf35Vlougre4+LgWFu68fY48/VNmLM63394aVUvbB3XKU7R4P1g+1ceOH1vPL630cs/9itu7j+vM8j7dsV5L+r+fkitBx3xPtYkgz23D+byb9ooeT3u9j0RHHQNpXuBnC58cyNTr55LPlE+R7SY5R3vGTqVla/VkHqxbFF5Gb/aiOPpX+E05B5umt+wHuTbI1c7hhMhXi2t5gDnkBZ0RtSV1GkhA+ZGR4PphXb0eZPRjeN3Igzr9uLZ9nEEe//83OuoPchwXtL7+egaucLq7847D6JCS5Ozw80Fi5YvJld/55AbXU2sjW29NKJ9+5j02+KUbNTmPfoZgCe7Z7DYsc+zrSNPIo2dfUyJtzdCxwKu03VPdXUf34irjmhjXHNJ2Hda41rJPp4UvQqzFtzG92VYB4jm/aLT93BhReu497s5cy+uZa7Hr1lbE40BL3mIJXfyGL3z7ORhqnJOJbOzy+i6EvRjQ8T7B0kl7t4t3r4Z04rcLP7N1OYI+JXkO2ucLP3ocDxyNQl42gQYED2o+sxfB/P9O6PE6eMjCFYdtloTrVgjRzhA/y5qeGiHKNBqiyl9vIMZFP4i5Bkg5hi3DEgACnGvN9wGD19UQ8ihs+L0diM1afiLo6uH7QuEzHnPR48/d4Sit7SsO4MnPwNtxvdE9q4MVQfq36xgJRbD4VsDGjpNtDaQhdIyynJ9JxTNdLeUCHRrNBVbqbviPBTyh5Ia4/iJj+C7nYjduxjwb1f5tdffyTiYuqQ2se5q25n05LHBiQ7X+xL4if33UbGrtUDKShDUZM1lCjuOSXJS81n8ih8JwWxYnPojYTAurOe1gtKsbVpkYtTBXSX+q9Rdgu8bRbkKNJRoiFB9sTcqCpJcVOZ2koroFQ3IhVm4UuKYOwLqD/LzPdTNlFiSsCpe7k+ZW3AJsmSRoI06GX/hL0ap+1AwDYFiiWs8Zhuc6JN9dfIGPLIvGqSpmPe04ja10fZ33Se6VzCp85ZgW4I3vn1EmSfQeHurmF7Vuy+J5Xflz1NgZJAmuTle7Nf5cdbLgqZylGR24Jd8WJXvEFOiDRTP/MzDpJu7WdrQ96wKSVD0draoa0dqbWdd3822AH8z5cupvqsx6M+zrG4+s2oteENjKPnLniznc7DqbRPD/4tTBqjEg8Ya3775BWsu3QLfyyMrrmh4tRwtBi4suIXWT8WU6+g22cjQbKy1Orm4k+t5JWXFiOPvC8v+R/0IQ6Fb8ZrqOoRMZjYVdNUO1QlRue4MwktagecJBvIyfF11smKDsmD87/WZkHyioG6094rZiF0SKzuOaGi6qeIL6eMjCHYWwwkdWzTLZScbBACva8/SFlJmlpF85JUvNOiXwCeaChOSGzwL+yMMIvwcOi9vaBpmO1WvFmRK+D7c020Txv7UGLyHoH5zXWxJYcYBonPrqa2fDGdS22cnbt34K0n1yykvC78DCasVrrK4psmoyt+NZmjxZ7dmg1rRyLWLdEfw1BVMh9axQ0zvkRiTi8zsxt4uPA/fK95YcB2da5UTBsT+J+SMwYmuA8Pl5O1ugv9GANDKAqes2dCDEatWuWkb4+VxCGvydlZCCn0c6vZJHyO0N+nMaSxmq3FQOmXcTltGEUjD0sKSSczpW/UnXC15hYUsxnJ5cBQJLzp9oD3JZ+O0uNGK9FJkdyAFbtkZsowWSwlMab1JJg8tA7zLIbC3O7011oBqNqA4pr8/kYmyHN4yrQEYUDFcxsxPJ6IBoZktXL4ptm8cdovqTT5r8UumflcUhsfTKjBc0y76gM9aVQmtURcYJmERlViM9tE3ogy43Wnk8Rnhnh9jYWcn3PJiHowfO7g6SRsiK74Stuxh1Sjkt7CjJjPc7zJXelh1exiCGFkfOiGr+9aFvBcjzcWYeLn2Zt5oWIWphrrQEpyNAyd96TNe9Hcka0UQzdI2GCjZ6oXxRZ+dtF8EglbrRjecfD4G4Ldvdlsrc9HUyWSk51cULiLvX1Z6Pro5lq1x4ylU0YZsrTpLvWPy56kFFIdM2DF+jB7nzho49zxWztV+H3yYwBal9nfsXis7h1JRjL7vTGeqnwMSWCp70LyDYZCRHISdRekhc1LH2900xGvWJT3uOL065A7mjTs//DXGowkHqI7nbBzH3LSVCLJb3SXW7jugrFt0ra9O48IAaVhKfzxShq/sZj1Fw5OOJN/1Big5HE80MpdtLnsFIxAyKPy1rUoOdlsu3oqH351DW89tzDkditenBXwd/25UFifhtbZPVBwLmw26j+vxjwI+ewCOSMdo8+fjqSW5wXVLyQe8k/KrkwTfflSgJgC+O9VyQsZ2wIXolq1xMErTMgOX1CDrOEQko7V6uOsOAkQqHV+7XlhsSDPnRTwntzvxdixD71jDu4IxTtO3UubHrxAsQpBVgiZ0JEgebXgPgd7DoRdaCnvbKDiHf//H91NzkiHzLSQ2/vSHWz+9oNA8PX+qWh5wN+aoXNP27RRadmrXWaEGlsyY+KzqxHVU3jlGb8xeIatnWRpeMPhbaeJmvsmkfPCyZu7HkvtmLPPwoduMKOx0Cqz1uPDbZj49t6rSLxv9F3nR4JLM9GtDzoWbp6xnIc9Z0CDCaEL5Ag+B80GhmRg6hUkbWhEPVgXdt4TJjNCHrwv8x7aiPu7s/AV6X6v/7HH9knIhy3k3rcSHb+D0psU+2LfZFZRfTLGMPn9hiHYUldA9osWLJ0q7VPS2X51Htv2Fo5oPByKrU4JG2XrnGrQMc1G+f5sCB8AOsVJysfeyNDcCpW3r6XljsX4xqh2T8nPDWoo5SlIgYKUgb9rrpNQEk8MA0OSDHyTnZh22KMOv+f/oxa1IU5FfbqGWBnZze6YHJuW/0jw3JFKyvbRKfbk/XIlxi8H/z6BsxmiZvcv87h11lt8/Y83Rr2PIcOhL1Ux4S/7B7zaI6XrXBedUyuY8Nrw+Yq2Vh/mPom2qYFWhtIPabuDPd2yS6f0aaj5rIxiiW2hmZLo4rwwPTFGg+HxBKWHHV2SVHxlDR+cVcV8S2it+Rf68vjRxkuCXs9I7WXVjBfjcn2mrTUBOv1Dry9a9n67gurrH47L9YwGXRNMvHMjagwN+45ibNjBAxWVAKzepPOT7K3D7vO7M87F0RBGACLsiU4s76azwP9dJe0bfjlR8oTgh0/ciOqQeffhh/nK/7uThAYvo2wRNSp2tOTwS0dg7cCyOWtgDhxypbLxpWNFDwaZds4eKhP8ssiHPptKc6RpaWoF3tTAT1rwrpemhVa8U4Pnfsd2K3m/HDQ+d/2sgE/PjM2xZpN9XFW+hRf2zkRTY4uQp+/w0L8jn1J0aj6jjFg6OhqkHDfVP86C6KeU44JuSOjj2Izv2Oj/ycjH0sgo/eoBFHEkr0DXR+Rxj4aMrT68uUnA8fHQjJaSvx5Cb23DmFZB84JEch7byO77pyJZBxdfhiaY+OV9qH19x/FK40uPaqX6giT09j3H+1JOSPL+aebxPeePKGhc9+kyhFFGQoNO0huRVcfCkf66lfT3DuGemBvV9rJLJ3Ozl7bpZgwJHIcNHI2R0w+Kn5WoO9uMyB8+derMsn2kmJyjTpGKJws3X02P0xo2zaG9K4HJKz8DwDNzHwvZtBH8NU87ZvtrMjK3ehFqCCGKWWWYD7YPW1MQjsSPMlhX/GvAHnG7ed+9DVtHZMNPVwRL/m8NJhGdgVj+tXb07iEGkq6jj8DAOJbNn0jnIuVcOs8tY9WvBo2nyQ/cTvGjg5Eure1wzMfWdldT1NLOoS9VDb9xCHyJBmqxe1RJH4YE7in+Z+NoQ7m+OT56ZwqKnpGHlZJW+jXOuuNWEnpP7MLfIlsnKdeEb2o0NCWvyNaJvDqFlquTgqLVxpKZaObQ33j2ei/K+wbytprAfbzegESCiXfs5l83ncalXxjbCH7j5T5/s8UGC4X/8f8+xc8J6s+yQWGcFG5O8bHhY2lk6L196GLsiskkFZJrNGSvPtCo6GTE8HrR3W6k3bVkq0Uc+PZsZJsLMWQxZUgGB74+jbLHDg2kd5zMvN9UgeWXqShtG473pZyQuK6YT1+ePGLRg6NpS5oJ9H4nZb/R2HOzFcUR/QE9yRJqfnTiAEeRfAYp1f6Fp+zWh1Xgkbw6WesN1O3hU150Bapu3EWauT/qRe1Y8J/mSVySsI1JZjtO3ctVe6+ks9ceUdveMMRAsy49QhqFLPSBdJjOcjOJDSqm3sDPqssSvrxUFLMpSPY1IkIg3snjJ0XPkRomdevXHaX86ckLAMhq9CF5h/nhBLz9p8WUXLuPyUnD514YfX1BtXEA8qQKdGtwgYt06DBae0fQ68eidXYCkPqOYOmdg4pFxZsPo7WOUqzCMDDcoyjSFQyoGrmKfZibFEwx9HjSbODO86Eco4wkJAMkg7rzzGSvkbG1RH6mh2vcd6IwtCfPcORbu1h5XwkFj+agvOPvmcTUCjRz+D5QQjUwZAlKCyIWQOv9/ciesXdkHE3d8uV6qTvPTOHbXiSvjjCizp4+xSkG+FgaGUMRFgtNN89BG0XTs6GYuw2SD/iGbUB3MqH39qI0taNVmILyMgWgVTgxbKOXvD2ePLViMZZWGWsLON45fvnRer+TjK0+2qeZiJdEtq6AN00P+O18SQYsnA6rh0/pAEAIjMUz6CkaXYPAgfMnCIwFU2HVFrhx/vA7DEGzgpoQu06/uTt6D7Uz24SlW8PWGnpR60lVaF4gUWTrOO4RjA6XnW7dQrfuYo07if1NmcPvNIQnOpbw6bRVzLcEOl5+21nMc3tnD0gL+xLBmSFjk0TQd6lZFaSkGG8MIfF4+bPkKqHzVL/RNIsXP1pAyZoYFtQGpO300OuLnIBz2J3MyjenU+webGQmTGbkfL98uS/NEbJPidmXhZI4eL3qwbqI6UtacwuOFwa7jMdrWW14fWRu8dE+xYQewyzuSzDwJesDv6ni8GEo0R/Al2DgS9VREsIbEFK2G9USnwlVqAb2ZgNXlojbeDgUa5tB/5YUnvfO8vdSiQPXTNzEU5cvpsg6D9s724JSpEKhmyTUFGvcS4p9hsy2rrwRFW4rFg1f9mCkyXFI0KtYEXmxS295MnSE5lfxG9pd3ptioDn0k2YheqrwO3ZO7s5Vo0ROSkKbP5lLbvwIX8Lof0xTHyTVqdjW1wy/8QmMYQiMRisMSRswfD6MRmvQLW8AxmErwjsGer5jTJ9m4Y26SbxRN4nKx/sp+sFKsh48vgWYem8vljfXj6xqPtwxLQYid3Bi0HwSqkOneX70RUhCljm8xB4XAwPAkyJoXuhASkxE6ZLROi1onRbUnsjGg9ZqxdQ79gOvO1XCmyij2kP/c2ZJzFi0L64GRrMnibWHhm+edSxt9SmsdFaw3Wvh6bbQhfiReG3PVP7TG5x3/uiupcjrA/V+3BkCV4aEZhvd1CFZreinTccUQdzhhTXzKHl5ZOPKwdZUVrSWsr07L+g9j66wvyeDkiebBmSohcmMnJ6KuzQTd2lm2EaI3izHwDbu0kzklBSQxr9pouHzYn5zHbYWAznKjCPNAt50DTlt0GjTm61YWwWmKLNdfUlGwP7h8CYJ1DCqbrEg+Qy/iMMYPfIJTSp5H3pwvO9gRWspK1pL8cWhC+qnT1/JoYskREJ8xBWOYukyeL8p+j5Aqi6x73BWTDLNQxEC3BkmEP4atsTakR1HynYj8tx4MzQ0KwP/fJm+oGbDp/jv4mQxIMcE16JKlvw8xqK7CGSv7kaqb8UzoyRuxxxvDEDrV6j8+uoAr5vW1k7Z19vZ+9jcoJqMym+tH1Gh5Ggv1KMrWEYhDL+lI5+MS/cePdx/PYYhQBjITRYsHTF6tuT4L6R0GbzzKyl6e3CS8SXKNF7rvzZxzAJe1wVVD7SCYeApTI379QwlbbeHrgozvROUsB7UXW9UUvDJrrg0g/QZMv/ZPonKG2OXcay8dS2P/vACNp67kzW1xSM6v45AM3RkIR25Hi2sGo07TeCzm4KUuWLBmFTGv59+nFCKUQAew4cYhWxm4aMmIIPaKRYqbmgJSGfb35dBQ1sK/BDKb7L701Dyc3CXxhYBAvDMKsWy7dDoU6BGSMrfVtF3zQJ6igefz4C61CFfobvEg2zWA7zaE3+yH621FTFrCg3nJMdNYbFvoQtfoo2c1SdHSlTqHi/81C8LfOCePsodraN2IIgkL57pxXG4ukGSnl6NtK0K119M2OThDfDRet1ls0bLFRp5T5n9PYcM/zxy7NgcLUqSF3WIUXGyLUB1xrcL939DX82T7Tc+xRhj2mun/N61YRfdE2/dHPSaMd4GBpD+p9VsXzuROX8dWfHwxw1dE0z4m0z7FDNajJlGSmEBhz5VFPd0BUOGljkWMrYO5tqbejWKHvdPjAcvMiHl+CMwui6o/NIuNLcbuaI0vhcShpRqL85sE72FoSdq2QO7F8u4/1XG0qwYahFC8PZji5n4SPjnbqz5644FLM8u482q1wCY9NSXsbbH9oOriWbEabOQPhp92smiH91JcfXoPZzpOz2s/f48Dn86vEEkzZyMJ4qUlnB4pxZibkiKrR4ljiS8sJaEI8ahkASNd83398bJ0mFIBFMBsv9hIeGlwXoz7cjYbWzaQWFdOoduHHlH9qGUPqBjOtyAu+Tk6+fRdk8Jm7+Yz7VV8Umfijf69t3sPN1BxQdyxHqR6v5MNh4qjOu503Z7cDSbab4qvo37TvHfyykj4xSBGJGNhuNhUITEMBC+kXvJnlyzkKo/9J6YngLDoOjJGpouK8GTMrqVva3VwLZHQ91poWNicL+IqJDGrodMKMPlaFF23nIDc5eMpb4LYNgGV3HHAGu7irkn9IcXuoHh8WD/HwvrrdNpmZ/ERbcsD7ltJD64ZzG5K6oHFnwjoeyxQxzYUQVXjOw7MgyBYQi6dRez/vFVbJ0iYnhPN0P7FAvpOz0D2xlCwCgDXpqh83D3BEz9DFucHw39OSaal+goYSzkffdMI2utX+p4pBhC4MtOQrFWoW+Nv4TxUXo/tRBvQujPkbLfg/zeRgwdCp+qAUkCk4JhPuaBbz0Y9j7TOrqY8Pda6q4rDjtOWFskfB4bFERWGRKqjlZ/GHNbB0IIvHPKwxY+R0PaLpXu0vjUgwEIw39M2R18kwnVCD0wxYjRY8aytTru0QzwF4HvvWkKSFB/bjIpZzaxJLuGNw4O9tPRNGnY3hgxY8TnuTxZ0ZHQx7HKYDzPNVZ8bI0M96XzOXQRLDnyt3l6F649KbGnkRwha4MHuaFtxJ7IlG0muisl5IyReQiS37Vh7jXoz5Vwzo+930byezbMPQb2lnFeyI2G1g7+9fhpnPO51VGFjo/y9PtLmPCWhr597BYEo0U93ETm2nQ6pybRnzeye9LWYiCp4E6WMSRQIyuEnnCYu1Qs9V0BHuL+qxcgdP9744HkM5DCGLNC9z/t2g6/1HFObxkvJZ3GFddHJzHp0RXe/usi8j/aFzLdRsnNwUiI/KNp+/z1X2pdPQm5qbSMYpV/qCOVc7d8DnvD8McwJEYlliEfbqPyidvY+LnfkCD5owjduov3XJn89l+XkDtK5aHWmRZ/zneigZISPiIict2o1tGvXHWThG6PXYwgKiQZ77mz6M+R0MLoa3QJC4nmuf4//r1poOFlTOgaakMjOaszaZthD9n4TVL9TSyHW2c2nJWIdfoc/x8GZL/bGLZAXstMxpcY+btTnBqOJglXuhhRQ7qhyF6wN+so/eG/I+t6B88ac7hu8ihUBlUx0DB0LDA2+aP4hdpkGj05rLlQx+UcfwEWeZ8d+2GD3tNPydueIpiPrZHRPFfhnNlbeO3gFABkYSD5QHERk7dEGGA/bGBZsxe1txc5Oyu2CxHQl2/G3GMgu2O3Wg1AqbaR/WoNalMzyVOrOJDq75zrK3UhyeHNHtUjYznkH5SyX49jM71xQmtrJ+f3q/jnrNlIJp2SnDYWpNdG3Of5PbMo/acH6YMTMxQ+FGPTDlKVaQjDgSEJ+nNjm1wVt4HPIXCnn8QyylYTcmYmJPuL1FtmS5j6BMn7xai8z2OBtnc/RY928Mz0uVxetSWi4XvYncx7eyqp+P0atGMWhHK6//nV8tLxJYdP4xGGgbkzHQwDva9/VKlWmldGa7UiNyYOv3EcUJuaKfluG72fUUk4Muz16hrv91RR+G/vqL2lvRUqSvL4FpQakkBJT4tK4jZahMWCVFxI2wxzROe6O03gTjMjDCisLcE4WI8eY+RPKApScSG09CD5whu3kirw9psiyk57Zjg56i4zDEH6jmSEqiM3tKEeDpQWlh0TYRgjA8Da5sMQJnRFjNhhInv8CpD2pshjR+YmD40OO0we2XmOYmg6pk43aoolYiRH8ukoPe4RRdb1zTvJ7y9lf1oulI39Qt+QIDFh8Dwet52EJo1gIehTnOLjamRIMkKDjw6Wkv/w4OCWhhd3ukLPBJmoBCaOZBSk/G1VwOAgaTq6HN5g0E0CoRkI3d88qvVsz2CBnurf76hWdSQMQ6D1K5R9fzXqES+Rvn03E7b739/3+wWoieE9vuYGMxO+71dTOkGSoGLHMKj4gt/bdPhrizl8TWfEzcvvah51x+nxxFi3jeR1fvUb95f9nkpdIar0pd6i8BsJnZNCZtmb4UAtSqJ9in+oMneDK0fHkwZFb554oXuts5OyZZ1s/PcE5qYfCilM0KdZ+LCmnIrPbwx6T7JaoxaOMIQYSMWwHmhDxe84iLVTOYDUbsLaMrrQvDAMhBr5B5HsdsRRyVSTgg9/kTlAvG5H3SwRpLU9DmhWBX16MfL7nfHpyi3JSEX5HLoieseVIeDQFVlMeM6HfuBgTOeSM9I5dMVgg0uh4Z/jjrktZDfYak34pkRn5AthUHOnBEikv15M6gtdgQaQrvtTD6PoKWVr9aG4ZTor/PdQtEJQR+v+bW06jsZxck4oBpLNCgfqEVNLwBS6V4bQDb+BEaFHxnBo+2oo/XEjux+cCsJAMukDvVDiiW4SeJIkLiraOaDCtdFRSO202PoWHYsBqN7xV2mLFc2Q0Max4/d4nmus+HgaGbMmkrfcA8uDvSfWdhVzr07rjOGT111ZOp9Yso1DPx98TWtuQe7qRl8SLAl5lIMXyzjqZLI2eJB8BiV/CRx4VLtM46eH98JJdVbK/ndV2Pcr7oyfctbJQO59K6m/b7itTs7O5IbPS85v/Aah88oFdFaObkBOPKST+OzqeFzauGNr8g+8rTMtZG08MQsQzece5IVH5rFsQfB3/O8X51P6k2CpZDkjfcT52+6SDEydbqru3Ev1I2UjOsZoUXq9GOu3R9xm9++msGze4HfyaMeiuF6DIUHdZ1WUE6j7+khRz5xJw7zxSX8Rs6qoPy056HlSHTLtkwOXCb4EA710ZB7z9ovcdE6cRfH3Buctbdc+LJ3ZuCcXRHUMU69G1ka/1dA23RI2hewowoDMzZ5xd0h8eslK+NDf7HLzWaCXFOALITBgqW1DrT006vPpbjeVX/Sr0zXdtRjngtjTpofj4EUKG666j/vaF/DPPdNHLI0bRION8q+v4+Rv53uKY/lYGhmawxQxc1ny6mRsDe/t6LmthxlZjZglFT1KS9ObolB/oX+Uy1gp4YgQrlVcGrnPmam/QkM2B3slJzwqYdnTiOHzxa2503hy+O7F9JWFvnJzm0zRW4F5rEqnE23XvvG4tJOChLe2kfj+4Mza8PlJw060o0Gta6Toz27qbqgYk4ZYI8WQoW2GhZ4KFUzhF5XCI5FYLfslV8dx7Tnp/x1kkz1YCWtC166g51YpLcablzKq86nJFqSppVR+rYmd3y+KWn9eOmBDiaHj80hpemkSF+dH2fxxnMj6pwVL94mVdhcPGi7JJ3NTKtLyzVFtL7d0k7Y7OAdJcWpkbDNonxq/5qChUFvasDhdeOZG3wMCIG23L6rrOp4RT0kY8E8HvnutmFcEqyGqY9BjKv8vOxDPDeZ977y3AMUWh3wFYdCl6/yjekbcDIyElXZyn93HiekuCkRHoI9jmHQ8zzVWfCyNjGhULmRP+FFJey+dNUtMpCY4MZ7IIpFAb6Xh9WLd1YC3MhddlugtNNM5GWSHh8QVdhwtvojHxwBTj0bqSjOd03XkNA9qr4nif/rfNm+pRu2MnBZ0oiEnJVH/JX90p7dSDbsA8tgUDl7kn+xyV6nILh3SHCgTy9H2VI/b9Z7I6E4nOAe9VHnvdtA6PzWo9iL/vENMSmliW2cezf8e4iVc0E3BpU3s+tRgwnH2763I7wWn7/hPqKGPwf0mdH9EZbgUm0hoZhAOFdkU/hi6TdBbbiZ9u9+rOV5ozS3DbwTIFaX4MhLRzaOLThmSQLfKGGnJlLygUX+2DWPCMB7nQzaUfjGiRZghoLvUTEKDiq2+F9HYGtHpMTGjhRRTZO+qRVI5+Hmd3JfMWDpjXxQJA5KWW+mc40OxD7+/uVf3qwmdAEiJifSdM/hMutJHvohT7aBZ5ei0aRZOpz/d4h9rj8UInAu9qQa+VHVUCwdvlkrzVxaT/Ych0TxdG2iMGAtHpa/HgpR9Ov94/rSBv4vPqWV2at2IjjU7tY6nv5BNduZMEp8Z+wiy1tUNXd2DL+gjk7LVVImUVRZkr4+a6yRuX/IfdMDnjc/SMeXfNjJXtx63PjOnGHs+lkbGaMnY4qHJmkS7LZEJz4RIVzIM1MNNmFKT8KXZ/TKkhf7JNXWfN+pJLaXaiy/BQp9hAZNf5UZ5b3NQoeiJjpKbQ++CIlxz/d9BpJtOsaropf7FQWebnaSDGuZuMHISMXdnoza3xCff+b8IfetuUpNn4co240mS6D7PHwn6Uek/mW8xsSJV54ZZXxjY/uuT3uPm5EY8JT5e6MsB4CcLryNHmoNmluiZoJD12Lqxlys2RicdOkC3CS3ZF9bQkCQDI81DV4WNpIOhZStjRfLpmDqcMUcSfefMwZ1uwtKlYn7Ln9qgpSeg2UY+FPdMMKMPzfystJB0UEXooHZasDXIeKcOLu5VjwxuGQxwdEWWqh2Oo15kqdeF2tYechthMuM7fRpWefhopEloXD9tPf95awmWkdi1hr+xWuf0yAabrgnkOitCP/5RDKVkAnqSHS3BEnUapND93Z9D4UkVMUUd+gtsuFMkkmsiR77M3QaedFASR/edKYk+umfrZB/zuhACd/qR2qtePSoDwtzhQrOb0KzxX8rYm33Yh5Tv7UkvYm9OFjabl8tLtsV8vOunredJ3wLM3fOwvLEujlcaASFQsrOw1oX+jny53rA1XKpTwdJgJnWPh/qzzNy19A2+mlrL/hh+fl0T2LeGV9LJ+qARtaY2+gOe4qTjlJExQnLWeDB1uwfmZykxEXFshKS+CdJK0c1HirSdCrHO6JmbPUg+C/2LnBy8ESpWmNDdJ4+RISUm0rugiMPXxq704pzvxJDspO3WwQ3uyQWY2tpPnF4dJxDSR5tISkmm74yJrDv9r0de9dcVLbFK7B14zY/H8LHHp/GDDZf6X5jm5NA0SErs5aUZf+aWVTfB7hqMId5Fpd/vIY1HLZq/8Hz0xwGwN8g4ZSA1vCdUAL2nuZDdNhIOq6PygEqaXwnmqHQt+Au2hXlwpa/19ATtpxTk03C7mytK1/L6ocnk7shHa21DH0X/ANUh07ZAC4oM+s/uw7bNzoR/tLCrKG3wOrrlEUt1D0UYkLLfG3FIEyYzUnEBh27UmGmOvh7KmyiwWqTIEd8ISC4J1awgZGMg5VQx+f8rSTpul5nC/4yv+lQopMRE2pfk0pcf20MldEisC30ft023YEggacPPNVJiIroy/L0g+cDepuPKkcdEJERYLEi52XSX+o2s5AMC85BH6OjnNCQwlMHvShxuQ85JHxMj41iKX/UBMr2FydTcnEGpoy3mYyybvYZ3citxbMtHrW+I/0UeQSgKyDLCbMY9ucBfgxqCQxeYUdN9IBkBxobmkzAfNpH/oQdntomXPnsfk8x2nLqXJi06aS9dE9BmIe+XwfVnRznZZvJThd+xc8rIiBNNn52GL4T6Y3+JipLkROsxU/rcyWMcxIuGm6YNRDBGgmuuk8YsG4VvH/8FwYlO7R1T2HnHg1Ft+2p/Ov+7/qqg13t67Zyz4g42v/ZHLrr5Diyv+z1uhqqS9cBK2m5ZNOoGgQCmPoPUPeP/m3ad68K90T6qgnFzXWeQ98157vSAAtnCB7eh9w4RdRSCCf9sZ5bJX+B5UdFO+l62sPVbM0acL25I0PApX8QiZ+80J7uK0qi8de3gfktm0rh0fJqmaIunsP+W2EMlF92ynBdeWUr++yO7R/wLQugtMtN5nj9l7PzSXSTIHmbZD5Kp9PDDP984omPHk8YvTkMbQbNxXYHWGSYyN3uDVOIytvrvbXNd57CRtqbPT8PnAGt7hN/I8Efva66WUVLiX0wMoC6ewt4bwH6kZKG7xK9GBX5jNmuDv56qP88cKOU9o5ykgzq2lvGLSCXWeTl8TxmFP+vEJGKf08/O3YvrZRM7FpoxfGMzBkqVpXhyhpejLnrTf35njom2SwY/S9J6K+k7PHjSFFbd9zDgHy/+3lvMLzedF9U1WPbaKPxReAPjFB8PPtZGRvM8C/+6/Rch39OBG+66G1OEplBqkgXOmk3rDGtgusIYIYDdD0xl0q97A7yo/+3ohW5qrjVFbaRJdjup/7bQ9YXUgWZlpxjkzsZ5/PtAVdj3DUMwb80NfOc3/+CHp19LyRAFs8wnNuK8YAYdVSMfOhIa9GF16o/izDbF7OUdSyxbDqB2+PN4hKJw+I75IPyLvqE0fmmaP3Vnr2/AUIsn7gwThy/yIUdRZCIne9n72Fyq7tqF3t+PtGY7ExryOHhddGo+IY/phvRdg1EMz4R0TMkO9M07B7Zpu2URnYu8yFEmlTV7klh+qJRPVmwe8XUN5cCVChcs3IRD9i+6Q8kJxxvdJHHv/vV874YvjUsvnrZpZpIPaCHrV7wFqSiJ9oGmbScqnovn0bRAgTClv4aAllkWhBEcRe2v9GLqM2OLrvwpbkg+g9X/bz62/2lgbtrolaHiyvxpeO3Dq2MOxd7sI//vg/tIXg+Hl1h486ZfAAkjugzPRBf7/rCAiq/896hcakho49iFezzPNVZ8LI0M911dLJjQwlX2JkpM4R+gRd9fi0sz8eqq2ZT8M3gQN4Twd74No+zTX6wiRWhYNBIUm4ohnxyKA4fvXuwv8h7lcYQwwDy8u7d72UJazvMiJIPrHet57keFqJ7Z2Hdayf95/Dwq+hmz6Mu3oLgM7P88+QZQl2ZG9UXO/fZ6TBSbWtGsgYtYw+MhYXUt5p4CmubH7oJNOqhj7tai8t73FprxpIiotPAtLTJenxUpa/gGZH3lKsKwUPD3aryTC6ISghCGgXl7HXp3T0BNkG4hZP67dsTp0F1qIvGK+dheHjQ03m6oom1/GkITFBsjGx8MQUjluZDXDih2FW1GOfK2GvTeXrSGJopesVB3SWbM6W+WLgNHsxZQW2ZIAjXRgjJj0oDev2YWAdf4XkMFs7IayLV2k6w4uSpxS8Bx3YbMpWnp/GjPJegGWKZ3UZuYTPG/Yv+OapYJ5lTuJ800dh2XwzHV7GPSfdtZ/tgiMh8OLTEuWa10XTVz1M4pQyZsTxBDEqBEqX6YJOicaAbDXwsodHCnK3gTJJIOjm3EsadQwZPvQ1Z0+kt92GtNQeODIYfOyhOycVx6ogAo/doJmc5iKFJUPUcCd2KgVk3/dhtTUxu51t5IkTK4Pvp+6xTebgzvnDoWSTJQbR+/7I1TBPKxNDJ+UfEiZ2QMv0D6efZmAJJOc/OMeykT3ohtsJUSfIMdt806bdMsZGyPTUazp9iMMzf0Dkp+HocvmxB8Xi+k/yl8/4zxoq8sOFd8pAhFp226lbzV5pA1GX3X+g2MT88YXMxdW+X3JL6dUUVH6yLS/jzy70QoCvp8f3f4znIr7gyB7AHb4hmYGv3Nt4zuHr+qx38R02YdoO6WRWQ8MkTXvrkFixBk2IoA6JhkCvLkD8WXYJA0y18UbFufiNLrRU2IvLpyZpvwpIioU0l0k4ERQcZ2KEqSF0+qjNbSijk5EYRAS7WjhvD+KU4fcqcTDAOtrW3AwJASE1FnDN+PwueAvlyZo6WP7xyupK0mDXuD7F9IjaDo2pVlors09sWNN9mMPS8buUVB6+xE211NxoQUDAn6cxRcmcELE3O3QWK9hjNTpmuif7Gn2QSqTQFDCRjPdJOEL9WGZUIhWsPhoGN1HUrhg147sycc4st571AWwsFTZerjPzkH0A2JHV059JqT6Ms301UFucvVYWs0DAkazjSzZNIuiu2hC9EBCuU+aq6TKP5n/BSKPKkKDRfomITM7/PWUVE8l8xwG5tM9BbGZ4HqTpYQmoK5O3hc1M0ypsIC1LrIHQh0E3hN/t/fmW1CGP66GM08eE8k7lfoKxHIafEVG9VsYkBeVUn0gYjCCy/AnW4g5OPbjbN2QwHqLIklmbFFzBVJp/mWueQ+Xx21Ct2wCIFSVIA3QiPgaPh6yVtcbA921uzoyaWtc/gUrP9mdEOgj6OO+3iea6z4WBoZsyyxuY/uzdrG1Mvqefj9q4Nk/gxZ4MrWsbZKEb2zilWlf4FK+i4lJsnErkqgKFCG0lmUhF2vonNKChfdsjxonwZ3Ck1r/B4HcagxZBHqyYas6DjnOxFPmOCYtGB5ykTcn+3g04WhO6ael7+b2i+l0762Cn3nPhiBOpcwm2k8zRHwmmaBxtMcpO+0ILs0rI02JJ9/stT7x9eDKiwWFDe86bRwgT1+i4CXKt7iazfPZvsjga+rTc1YXvdLr9gyFqFGMAY0i+BzJf6Iz+vtS5C6+0FKxhACb1roZ7EvX4q6my+AL1VHjlD4HRLDQNu7HwC5vAQygidQpaUnpPqJlJbC4SWx1TXs78mgbWsW9lEWXfflSwFqUdHiSZURxSnYDAM6/Yax+U2/UW5eMhNdCVaBSWxQsa+pQT2rHC3Xr+Cl4i/YNCBoPDMkgbssC3Pr4ALfADSPjL1RxtdrpTvHxulh7hdZSPw+z39NF/RejNIr0TtBMOOMPVTXVTJcYMKQ4YqLV4XNlU9WnCRKLkpMCRy49I+c/vrNSHHwg3hTFNqmyxy4+BGOCi6MF+4MAUiYev2GTiAKIiefZNORDtltHSDLaBP9kqb9eUZQtNKVDZYOCckHypDbLHOTB9VmwZfGmKJZ/B26hQahMtwMyR9BFPmu495FoOhNLzVJ2TEbGSahcfGXPmL9qukQNyNDwlOaGVVkNhJvdM5gsumdoCyPQz2pqD3mqB2HmlfG1Op/FuRJFRhy4ICu79hzSinyY8DH0sgYCZlKD23TTGSvC4xE6GaJ/Z96mIq/3+ZXbBnmmTFEDNFdQciNy7+7k1xreI95vrWL/L93AfD+jxbjePHkS+mJGkmm9IlaZg+jv19sb6f47+1suiAPtak54rYhiTBwt09WSN0rEDmJkFOFMAzk9zeN6wAqJpWRucnDd3/2Rc764e+xRPAGSkJHCAMjgpdESDpylG72lL8OHyF69Z7UI/+3Ex3gAMhWK+1fmR0XtaoRI/knPq3mEIRYJ6hGnDylQuLw60VYjuOI23qJm/Q3bdhqBn9XoRy5oJVbyFgR/HvL2Vn0Lyqj5UpPyAam0YxnhiZw7PYrHt14yX/4Vnp0jTXfrHqNX2aV8Ze/nc/Of01kyRc3kRmDQlUoLkrYzhTzoDFlyEc+wGhkfCWov1A/YmAcJwR4kxVargxtaDd/MgWA7BezUa2CFb94EFmEf/BK3vgS9mrzcXk2tQr/WK61W7A3BN91ms1AKw90vAnDGPXi+mRHxJoiFYZd35rKZ76Zz/vTnkdncPwzXshgQotKw7LojmPdb/EXfksyysO9TE8eVNPSDcHmczLQ2jvics2nOHE5ZWREydk2jffv+CXX3PTVkOH17ct+z4wVX0TZED6cKIBDn9XIes2CvXn4POOa6wWy/fh7az7uyJVl1F12rKp7eAwh0M6YhWndnnGJaOhLZ6KZ/KuB5ANezr/5dl5+5PckS6H1yR/MX8Hzybv53obLQ74vhMGaJQ+TKo+tApHudpN33xpabl+AzzH89vFGslrZ8+hkf81PGJJXWMPm1UeLL1HQePeCmCIzY0H+U2Yca6oHGl8Jk5mHqt8lRZJY+MTXKP5ebJ8z1vHsuVvuo8pkgROomPGN3/+OhfffTfbakUf/yn68mzcK3me8IxhD6S6HrkLvsHNF01V+L/SsdcvYOv/psNvtvuAhNMPgVWcmP3p0GVmbYkvzjQdSugd3euj3hn7OpIMqll0NuCePXMjgZEdOTcU7oyRuhpbnxWyWPvll0l4crJtKc6/Fc+Hs2K4rKYk9D5QhN+rsPpxFVkofZ+bsQxIGlW/3sP3rs8M3gT0B0ce58Fs/gcbKkXLyf4JxJFmy0jHJhGYL/toswoQkRaFLLhk0naHTMTlMtTigWSUOXKkg27SYDYwGdwqv1E4d+Nfz2R4av7E4xqN8PJAry5i3WQv6V7HOMuDhBkBEV3w8FEMSII3T4yXE4ORigDRM3rosJC50NPLA/CeD3ktwuHl64R/H3MAYIA6NJftLVESMtT++Ai/V98xCVnQk2Qj7r3O2Ss3PF1Hzs0UI08iqdA1BXA2M1D0qiR+Gb3AVjoRN9WjtHbTcsZh5mzUWrO+nSLGTKtv5w/WPUfPUzJiOZwCZb1iwdkRWbRKyQX+ll0xZj+g9H453353JmvbiEe9/Q+oqyk2BfrUEycpPbnyCq+5/m8TvR65bCMWC+9bx/dy3giKHM392O5WPNI74WmPBmaej5XoiGstHEcJACAO328Tp266kTQvtBLEIE3bJzEX2Zv73pmcHxEYytqk4Vo9ybKi3Melng5H4gudqyXwlOH9ORPgXgAHGSZZ249EV1t4+G7HrQNyOGXOxdwSyVnaQ/sZedKdz4B+6hn1lNcUPRXceV4mXvd+bgiT7o+aGLtHW4xhYm7xbV4Hcf/ybYZ5ibDkVyYgR1Rb9w3zp5G2sbCqhszvQTaskeekpk/AmhjY0DBnk9Nhzrmv6M6jpTsflHDxuekofPSPQYR8pSkE+ref4C4IN2zgMIIbOR0/OIf/yWman1oXdrMPnYPkzs8nv3ULLHYvprtIQKV5ezwru3OoxfEz6w5dBhwmv6djW15C1IZmWOeENw5ONZMnGUms/n5myNuD1NKWfOTHWLI2WzI39dEy2404f2SQpbOqgwEKUyGYNClzDbqck+CDBhwG0fW4O2a/VjCzdLo4oTg1rp0Tv8JsGcOCLxXiTi5i9cA/3Dtz3/kX/eXYf9817jrvv+xxlX1sd9THtrWrYGrOsDf00mR245jhRbOqoPVqWTkH1nlwOJGdgMqtRSd1mmHqZbasFoEixYRLB1t5lDifg5DT7Pq6++WYKHgtWNxqK4vQhfBq135L4VuYakqXgAvb07R7UAwej/GSjw7DoKGG63YfdR5c43J6Mb5jFeYJk5UrHYX5bYCKhwYepVyOxTqDa7Ximxz5HKbvt5Kzxou2pHnhNbWjE3pwT87EAkt634djXitHbh+VQB56iMS4YiRO6IZDW7UIfoz4Zo0V096G2BQsnaJ2dmLZopL82mdYLPREdq4pVhfxAB4SmyrjUwWfw8Gl2rJMX+d/zuuHJl+P0CcYG3ZDQxzGHcDzPNVacMjJGgS9Jpm2K/yt8qT8Bd5+FoT6eb2W+zy19GUFGBoCU7cYbfQbOsDR7kqjuCj5Xe1cCJgPkyZVoO/fG74QhUPLz6F5QMND8aiQ3l+aTEJ1HFrkZg4OYrguUg1YM7VhtQ4Oc367k4GlTIhsZXju5963Eff5cZn92K38qCi6YP4pFmKi50p9fXeL4EkVKGYYM9iYDV2ZwVMPUB1IMxfzHokwoDIx6GAZq7dhrr9slM9/P3Dn8hmOMWLmFFMtsOmVLbI3+BKj28ZGwFED32S4cLRNIWC/A48XeZODMGcXJhX8MUfqik/QdiqQa6C3RSfYKYeCwezjvqs3cmrY8rGz3ZQ4nM6/5FTd9/bTBeiKvD3OXD73F76kwUnwYmkDqVfyhDD28I0Gs3EK+czL7M5MxioY36KLBcVABFDQbrE/3OzMqk1pIUgK/h+3deWRa+ygwd1Cq9FGgJEDIqpJBpputbDvtT8zZfBdCheQDGgkHgz39ckcfeH2cUdzBNxs/wZ1Z79KkJfBc+/yBbUw9nnHJLlLtQIwGdqyYhEzbIhXpQxP2VhVzt0rmJo1DOdaAMXo4jAYbuau9mN5eH/Se0uNBHEqK+j4xAPmAjeyX9w+oM4naOkwpDly5dmSPHtL41SwSusVfO2nqPSWvGg7DZkFyOEKm+2o9PSQ/uZruisXoRxT9NLO/ED9WXHOcHN1Ld7ohOLh+ipOcU0bGKOiYqAx0WP7Gi5/F3nlkwSH8koBjgZBCr0ZWNRTjcYc+qW+yk905qVR8eWyuCfzqRk2XTKDnjNEtJkSnmaI3VCSfQc3VJkSyDyEM9H6F4v9bRbi1mNdjwqWZsMnBix6PrtDlsSGnJPPzhx9ivmXwe3Lqg54kk5CDPJ0HLngMLoAdXhffmHkBTddPRrX5i0UNCX/DtT2e2Ls2C4FQ/NdRf1XhQF8FAKFDwQNtGD4VDB1DP6oRGv2k2KzpJIjRpaeMJ/J7G8nqmETD2f4C8YjPjziSgiSBVu4aZukYXxqv95KaXkLa0xtJe3Idnq/MH0iHGup0ko7ILxlS+FQpQ/jHkIztRpBq3XBYOlUmvAq1n5WQTHpIO+voWGE2a1w8wd+QzYdAM6K/L7TOTuTV/ZRKU9BlibrzzCi9gtxV4WsYJE0H/Yjm/uadlNelse8PRTF9vuGQXVD/ll++23OOwuy0QAfDzhWlmCb2kF3Ww1+75vCdjOial1qEie13+sf0iY/fhuPF7UHbHPXN1h6xKe54+3oO1mQFdFWH4P0C0HUk3+jnCV+pC2UURobTYNj7wSRkDlz8R8r6byVzvYy9SUdoBhNe9XHgWgXhUEEYQfegrgsMdfC4VX9sGVBzOxZjww7KD6az+1fFAP57Okz6l2EItH6Fsu+uRhsSiTFUFdZvp/vOxTgOh25Q6MpU6M8VCB2yNozeyNDNUsxGnm4IWr0JwPAOgqgxdCRNRx+lfO1RPIWpmB1W2Lon7LxT9AN/7ymhKDBtIvu/cfxqkk5x4nLKyBgDfIkGe254iJF2ygyHEAZXTtwaVp7xeFJ97+wReTKORcpyc3CZRMkTgtIXNBrOtAYpiYSidNkW3vzfRVx53UdB772waQ6Tf9DEKzveQx6SO73f18eFK+8Y+Pvqqk38JHtryONPMdv41473uPSMNLTqAyj5ebgn5o7gE/qRZkyi/rwUILiZmyFB/ZdnAuBo0Elo9CJ0I+oOwkKH2754J5f+/h2+mlo74mscb/Qtu8g9UmfY9D+LAwyvoThzdeTMOE7QMdJ5nouuytmUfGcVOb/xT7TuS+fTPnlwOM1/dBt6by9i3jTqPzE22vJCh5K/CGquNqOkBKddTM9vpCoxMLXrya75LHJUxyRzbPi8/nvvtFkUvh05vePofTqe3Qta/5PPWyI/4DWzMX51ypbzD1Jp1Ma0j97fT+6vV9J01+Koe8GMBReuvIN7Zr/CpxI7o9q+L1+iL38wbdSxH8CEN9UIikKkfGgl49Eh/XWGObbW1k7FF/wpOnXfW4xvUuh0LOmglbLvRBYp6C6VGS5yFQ+UbzSxLL02pn3eqq8i47J9cVUf1Lq6kT7ainHGjLgVf3vTbEiLpyEt3xxxu+5r59J6iftjIVCjIYi9UnZ05zvZOWVkjJADn4PKooNceMGnAHCcKVBD1GI+VvoiD6TM56kd84Y9ZllOK+WJbWHfl4Qe1sA4Z8Ie1rRM+K9rlpOzRkXbZBm2CReGwYRHd7PxhYqgt9I+YeKmd98f8NbdUr+I9c2F6LoUIOP6cs003qqvwiTrrJjxXJB3b+jf6uFmLE4XnlmlQecThoFpzW50V2jjyHPhPLoqTCE7RQ98nCPvOXMkVLuF1L0xLqrjNH+Vvn0jVfd2APErUIyG/Cd2ceDOSXhKghfDQhn/BlxCGLy86CGsR0JW355wGUOXZfZ3d+BYObj40vqOSK1GsZDorDThaNSxtY6shqnwLTAkC13lMmdcu2HgdYcS/N2NpkOxsm4XxpQyfMmhV8WmXi9i276wBsZ5m77Izyb/g/Ps0X3Oc3ddyqFVBdFpNkX4mj2Gwq87Srk1ZTd2Kbp6o4XfvJWyt6qHXRj7zx18cmnGJDRH4LmkDbsxPPFtZDdaIslYH8urV/yaazbeBGuSA17PW+5EqW5EmAJ/KaOvL7rvLwTFD+1BWEPfZ4bHO+LjDhxDgrbpFlL3+gY6XY8Hz/x7KRPvr0c9WQrVozRYTv6l8CnGilNGxgiwH+ql4J+JdCUWkrzVXySZSxWG2f91unLtcIN/2yzZwaeS1yFNMfj7jvnhDklZTiulie2kDNPvIRwJsgdTmFQq6YCNonfHqMBMkmm5fQFaqndMbibZpSO7dCTv8NOK1t4BIXS3lUXZXOHwL/q+engu65qK6O0Ltgi9HhNejwkhDG6uO517894kVwmMRjX92kzq7+agvLMBrbsH694mPOXZGJLA3OFCau0CQHWG/h2958+lp1gJaZCGQlf8nXe7S6xktFai760J6nhurj6MOiEroGN1T7GZ3609G9+89/lGWugUheEoeelmyp5X0arH18AAf5pO4b/7aTzNgWfGyJ6JeFCa3cYn8/wSi5Um64Ch+dXcf/P5Z/0Pefk3O1EP1sEI5Yo1M7gyJAzZhL0pdkPD1KvRPN8C87tHPH4cJU1SqH1m2sDfyuYECn7qj9bobjfywSaslmABhOYLJ9A+X0LunjXwWvFrHuT3B+Upe/ts/LbuXBpz1/OFpOEbkLX32zH1jmz54p3Zj9iVxNv/Wjrw2hNpF2BI4J3Xx57T/hq0z5tOC994+EYAit6pQT0i9RstwmJBKvOncPmSrOimY5wUFSVIuo7odQ504M77oIvWuckjFj0YTyaZ7SRYPfg6DTI3DsoOSLWH0UIUCY+GeB8v5DksjHh1bEhw4HrBOQnR93l48aXTKH2r3z9WjAW6hmVvE97S7KB77xTx4VThd+ycMjKipE3r57ftC/0SoW3d2LbsYug6Ud+6e+D/E3KyOX3blbw+5WkSJCuTzHZuTF3LtsI8AHa1ZOP1+BeEQhikJDmpSm4mQR6dlyvN6sSdHPyT9vfZUd7ZEGKP0SMkQc9CF0qUxX/RHdOgu8xC4iEfku/IcWWBnJ2F1tIaU5hZP2MWrQt0fIbGK/2pvH2gCp838m1vGIIPa8rpypE4NiFq49xnmVN+GxnvALqGWt+AOTkBQxZIrV2oh5vCfCiBPLmSjipzzOkRuglcmYKeyakkHrQEGRnq4SYUqwUyk/AlmfGkKrgz/A3Q/mhbQubM3qgWdUM5e+dlTPyzE2P9MLnlY4hYuYVceRaNkl9OwTPNGbAm0HWBdUdka82TriPyRpZaVZDZyZW5m7g5+agU6eCAv9AqDyxUJ3/mdopfsqPtCM77l7qdJNQn0FcQebLwJYAhSchH7k1Lpxp1NKpjsgVtTi+fLA2d6ncsT7Uu4Ald4ZmSd4PeS5CsAQvwO8vmse7gQpKe8jtTjl38ua6YjyEJ2udoLJsfqEr1nLaUYu8M2DO4qNp3OIvnmEue8u+QEQ3N0Plp+2Q0Q6KzPYGRtk9R260Urtawvro26D3X5fM5PeXKoNfr6tKp/JXfoIosyhuMZLcjZabjzgkfSfZm+T+NyW5GdrnQ2trRN+8kNXkWnViPi6ExKb+JQlM70arZt3UlULzPEzAunHjJu9HTW6AgNFBcBo7D0Rn4ql2mfarC9bOXI0UhG3yU3JVexKotw284HJKMnBmigYhuoDY0YkpyoKba0axxWN5JRJx3xawp9OWd/AvhU4wdH0sjw2P4gOjlSLt1Fy/3lfHS06dhcgFa5GFVbWrGdj7U1ML0IxHzAiWBF8r+A8Al2oUc7Ez1a0cbcF7+7vAHi4GpyY1MTQ7UZm9wp7DKlhGX448XkmTQfZYL2/MWzN3+6V6XJTxTCjG1dwQtsiNx4BaDmjMfoU1z87/rr4rpOlp1O6WGL2L3bGBgcRkp6C5ZLBy6JExnqSgwJOgqk0kym0N6zI2eXkRaAu4MEz0TBgd986YE7mm/ktMuuQ+AYsUescjTY/hY5bZgvrITvXfsFa6GQ/poEwUf+YsL9/xhNgwxZoVHGvCyg7+5npSaErB/27kldOTFfl6rzcu3S16PKrVn5x0PMtF2G2V/yBpQujmKtq+GtM5u+m6cOOxxVLv/NwZI32Eg+XQMRaBZ/L+XuUtFdcjopsDFaNaVh5iXHr1c6tq3p1L8ai+rn9VYaI2ct/77vHWsvnc1P1p5pd8De3ShIcko+bnM/O6mIGWno1x7wXKeyplP1c8D7/t9h7P4dt+VzJz5eNA+vbrB009/AqEzYgNDcUHVD2sGmg4ei+3ltRBCKbNyhCmBQlGQsjNxl0Q3zvqSLEhVhchregfqXTL6ptC0xJ+GFG2UE0D3yQhZHXG6yiMlLwRFayOh7LMjv7dy+A2PI7LbQDNH6G0kQD/yXuciL7JZw2i0Yu2SIgowHH32evNlrvhUcO3fWCMUBYSElODAM6Uw+H3dQFnRDU1tiORCNIs0fJrxMAzMux1dGMfI7crpaVRfl4RRdPwizeONxvjWSZzMBvxRPpZGxj/6srklqSvq7W+qvYSd/5qI0CH7/jWoo2wg9mrlGwDUq3083LFoVMcajn2/nMyEF0fXsfjjyo2rv8AdM94/KYqnd/2qhGWz1lLdn8n2V6oC3rMfkrn8wW8C8Odbf8d8S3gj4+nefJ6uyoOYuzCMLYaqUnlbsFd6KN2Xz+QT314R8NrmLkFHY+xa0R/OfSymhoR7vvgQ5y66FOnsmE8VkvYj0tj9ZT6Wzfcv6pb/30J6vtQzoBQ1Gox12/jBxEU8e+CDsJ3hj7LQKvPayle4eM4FA5E6eVI5s54cXv740zPX4vq7iX17pge83tNrZ8lHdwRtbxgC6yiCokKD7D+sClAdGmvE1ErcabE1R9TNMvpp0zB9uAVDVTE27CB7AyAEh+9ehB7lzOzYY6a/REKJsRnlfzMZj66i97qF9BSHHudUG2gV/oXxUTtE5Lk5eLVM6d/CH7fv5i4uLNwV56uNHjG1Em+E+8yQBL7TplFznYSS6EMcUoYVahj5xQh2/7oY2RQfaepT/PfysTQynvjB5TxxRx+rZrw47Lbl738B8y47ti6DrL9tQY9Dh2KAD93wYd/cuBwrHBs+M4WEfZvHTWVlPNAWTcO069C45OyG44Xv/JKzl9xJxec2Dr8xoJQWU3/pCNzpUeJ5u5ir0jfx2sEpeNanRUx8+MHFy2ifk073kPr40r81I5x+b7Q/ShRbatWJwIGfLuKMT0SXLjTeaO0dFN6/hYZbZ0S9eAxF2fd2kWYeWd1HPOn8wiKqbone0LHJPi6buJXX9k9BUyNHToQwcE1xYdlrQ4pxfWRtN8h8agv6OBoYxuIZ+CwjVzE6XuOZ2eJj+fw/kirHVwHxRKa/REVy+ECETg5TLBo1nx38LRNTnczJGewCP9vcN+Jzb7y6HPPBrTHPxcJkRls4BQBNGf90OsmnI6/aFlP2wClOMZSPpZFh7lHp+2cWFVtvQ8v110G8f+bvKVISeKIni3vWXjK4ba2FlL06qeuawhbzhuOWb3+Vs765MqQsqs+QcY9BM42XD0wj9Qn/xGHft2VAzUSYzIjJZcPuL/W6UGtq435dwzExr5kkU2DaxUFTcIqJbpLgOPd+KDElYHPEIAEqS2MqU1mQ0IVN9jEtq5FNsyWM1SlB2wgNCl9vQ99XS0ZnD+kbkgbe0/YfjKkHx4nG/l8tpGpuLdmWnuN6HT8oeZnbX1pGzhXHeDsNA72/n4JXW2g+IxNPavSLBcthE0+uX8CyuWvItXaP+hpffvI0St7qGJXErGaBIlt0kqdHCdW/JhySbOAq9GFuVTD1RPddJddopKyPfYweLYYsjUoyNB7jmbVJweMVyBmx1fTFEqkDmPzQ7ZS8PLp751hqn51OUUb4e6mmMYPyz/qlu/c+Oo/yssCaN/NNcsj5KnVlPea+XNqmDpljZQNpmJ4WimVwHFRVmX1dmZyZsy+KTxKa6v5MDv+sHFvtxpgX6nJqKnpx3nEv4j72uuWMdGpvmYikfPyiGKcKv2PnY2lkAKRUe0lskOjP9tdmXJx4MxXprexty8KxzYq13cDeqoGhYa/tGdHCO+np1bxUupT2yx08UjC2KUtPrViM3CuRVAO2l/3nOjqcSg4HUlYG7vThJxXFZkLx+jXn1camcVl8Zqf1UJrQFpTbXSsNn8f+cUZyOGi9fjplJv8kXGTrxJulsJ2UEBtDy+J0shqb/Skv4QrUTyKEyUzb5+ewcPEuiu3HL7J1lCVWiT/P+AvfIbSKnLanmrTMBLoqbLiyoluYKk4wDsfHGfHawSnkLu8PEKkYygaPlzv3+CW5X5j815hy9aPBtC4Rb7GGnDr8YlhJ8OFVBbpJBh0sneG/L9dUF/3FJjzJeaQ/Fn1tyomGZLWiz6wk1nWFrhgYythHbwredYa9d2JBKS2m9jp/ZPf5Bb9mujm8B+bDErjt27cD8Ksz/84nEwIdCRcmfTrkfmpdPZbcVDgigOxJMxCm2Mwjn1ehrcfBVls+U5MaYyryBviwuZz2D3Ip+NfKmCMYcnoaZGfgSz2OTVTCIGw2fFOcMVcmJCU6cZgHnQ1NHUkxSSif4uTkY2tkgF8eNanWH5NP+oON+qJy5GSB5IPUXU7Emu2ga6Py3BT+eCVruxfz4p07ggbIeFL1QCfazr0Br0lWK0iS38CIsihRtZtQK3MAsPQ70bp7AgwNOSN90POmqv73WyzomZ5hvUShEMLg9OzqmAfwU4CUmsIFX14e8JoidHxJwd+lLsPln17Oxo8mQtfoPeInApLDFvT5T3Sk5ZtJ806jzTy4gPcmDhapCgPM3Qb9+SB5BJIKQhfU9GdQbG8f1XPiWZeG0tYUVEz4oRu6NDsP11+E9Rf+jut/uG8xCxOqAbAKX9S9LSJR9Lf9NH6yjK7pJpTE4Y+npHghxa8ipjn9ueiSz9+EcChXTdnMFSkbeGD62XS9nBm24PtERyQm0nBG7IadN0OLuSbDMAR7ff2UKbaour+/0m9H8mqjTr1VCvJpuDiPHV958MgrkRfRp1sZsm0wPZVJJDeE/s0ltw9TH7jTwShwI4d4dhITXChy8Azf67Si+mQ0VWZXQw7Z1l4skopF8g0blVvVVoJHVWhflUPRT0ZYJJ+TiSd7ZEa+3CejWTUkxcCbomDuGlmqk6TpyC5fXNKtzRYfk9JbApxBr7im4nabMPSTx1uvGdKoeg2N5HwnOx9rI+NYkg76PWySV4+P1NwRsu5fyR/XXM4nX45QVTYGqHOr0M0jzxf2zCrFuqthUJZVCBo+O3GgE7O13SD9T6spv3s1+3+5COLQ8XsohuT/JwxG3lzOEGiGfxIRwojJcyLiaPgII7iz91hQbG+n+OKTa+Edb/QhX7RuCAzGr1mU24hiSF27jYwhNeztNy0aSKGSPJDxyCqy38tj1+4CHLUKihO2vjKJjGvWhVVyioQe4cbzGTp33Xc7absCowtrvjaPNfgbiLqyTJx13wMxnzcUWQ+sJOnS+TRcH/1vIkkGapU/DUrU2jB3B+75xrOLeAO/gIb4POT9uuOkTf8br3HC51W4eMUdfLj0/mEjVt26i998+UtYd++JbRg+No1MSOz8bj4HLgtvNMTKit8+zLTf3k7eL4KNDH3rbvK6C9n70/Sge+3o2P7MjD9TaQrWMbu25mw21xUAfoPs/f3+IrairA4WpNeiRah8s96go9TV4KBmhJ9qdEx4zUfDGVbUCif1lyiUPknM86cwDJQuN/qW+BS6n1u8J0ii/7Li7bx+aHLInlWn+O/hlJExBMveJtTGw8f7MkaNUBTUpdMxpNHPVp6qPMypSdDYTP2NUwIKVz1pgqavLiLnd2tGcbEG381cz+M9ZRz2pgS89dRPf0WKJHFDzZX0/rBgRIcv/+JOFnz2Dtbf8xDbTn+MuWs/j9sVXdff5xY+yjSziWg15MOh7auh4KFW6m6fNvzGpxgVNf0ZHP5R+eALhkFWqkLrZSPrlRELF+25COOSbiC24uyMx9cF/G0AxoUd5F5eRE/x4OvvvDiPgnNik6t9u6GK/hWZAEjHrLsN1cfVN3+VNG/k9CVbi49zb7oVa1t8HC/W1zZQuXsC+36YNPzGgK4JrDv9C5FjoxjHYshw+H8WUPD36iA54RMdrbWV/N9003jn3FEJBMSTJ3qyeOLuy5F9scXze65fSP8x/RPuvukFrk1YBUQ3/o4V+RldvDXleQAsIrRQ8pMlb6OX6NT4fFy28vaB1+taUzm4JY+K74UXmdCd9WHfiwZj0Qy8w0hLD0feRx66DtvoPd1F7RcEhU8rMXU2t1S3oNY3jOoaouGCwl1s7Cxkf1PmmJ/rFMeHE2QoG18sW2pQRPBAp/W7Ymr0diITDwMDwBACX7oD0kuDJj5D+BvFdXx+PmUv9nN4SQKuObEXXpqEzDWJu/nIlcsm5wRMQuPG1LXkyv6eDvcVv8gvfnYu1f87GcvWWvQY0n0Mjwf5SCaBRZh4YuYTfKfmKmqaw6ePSbLOn+c9wSSzFDKVoPzJ26j4e1dsaXS+0aebHIvW3MraO+ZQeF/1sEXBXT47e/5nEsrB+PRkORF5pXYqlldSSPIGpo4IbXyeaZ8uI42g63eoglDd7UY65rqFDgfWFrLfVICWFNz87lie3TkH6YANUwinvmS1YkyrQHFrURUuy24dZk5E3heH3im6hl5bT/nPSgHY9/kURG5kI3A44yLg8ApIz8o0P72IjEfiXwsnV5TStsQvi5xQ743p2obDUOM/ToyUS/ZeSOMzxaS5PJg3H0Drjzy2Sw4H7df4pYo9qSJovshUerBL8TcwzrhmA+/On4qr10LlDZGbzi4t3c/Xc97GIiJ7z01CBmTKTRJPLPwzN67/PJoqYxgCoQn0sRQYEIxKTAD8z0vSIRXLq/50NNkT/X1l3VmP1t45LmshSRhUJTeTb+/G2+eldszPODoMBPo49skwxvFcY8XH0sjQunoQwzRYGwn6GbPoKRrMMU19buOAupN8uIOy525l29W/H5OB9iiS3Y7Iz4nrMXWTNNAQ7FgMAa4sgbvVSvIBDaHbcc6LbgC22rxcVboFCUGW7GC2pZF0uQ9J6BQMCeGXmRK4I+s9/ofJ6F3dMat0pO7ooeSVmzlw2aPMsZi5oWAF29ML6PLZeWvfpIHtirPbWZBei0loLLFKgMRrTiur+ioCjiep0DE9Bab7UzRSn9kQ1KjoWAxVJXudh7YZloF0s1gQGmRt9GC4BlPSDJ8XsWIzHj1l2P11BNKK8ZX3jIQ0YxJ7v5Ac9Lq5W6LoB7HnMT+/ZxbmDQkk1QZ75U1OHctWO+7p0Rcr3tuylFsyPgqZShGK83ddQtuLhWRRN/zGo8DcJQCB1ifx7M45EbcVh2wh1ZnklGTIzcKbGNuN6Es0Y1EU0rc6ee71pVx7UXRpeT5DZnNHAW2XFaK4SkmuccGKzRhHiogL3p3HwctNIY2mjZ2F7N1YFNN1AjT2JDEWEv7ylIl0T07BmX3kezXM2FvVmLzEQ7HUdWIcMUzlzEwOfbFimD3ig6xoXF25mUQpeAkweeVn8HkVzNvt5Oz1P09aV1fERaeSm4NzRuHg9zIUAdnn1FNlagPiKyaw1uNjkqORlHInu3uzI3b3Ob20ms9mrmSKOfr0HJOQWWKFz1St4x+1M+jts6HZddRP+J8985rd6CNwLAxH/SfM6KWBN3Dq2zZ0E3RODvwdkvcIUvcGzz+yW8feFHhfdpea6ZxigAETXvchdDB1u5E7Bz+D1tY+rpK1CbKHBNmD5wQysP9b+OlPf8p3vvMd7rrrLn77298el2v4WBoZY4E8sZy60234Jg0usFP2TURyepHae1DrGyi/u4k7Fp7N0uR9OPXoO45HQjcEL+2fTonLP7wKhwNPYWpcjj0UoRuY+v1diUPlDLdPUchd4SRxVz/7sjOgaPgZ3mHx8sPMHRxNRyoxJVASRgHEIVTaZljIW22OeQA0NuxgUn0WX503l59kr+RTiZ2Q2MlhtY8dXYMG2RW5m7kjJXCRuNOdz4rW0oG/G9qTMSa46JgwuE3q7olIO2siTjaGqqK8uwFH5kL6c2KTtJW9YGvVUd7dEDJ6snJfKVKlHlZWtNmTxHv7KygjfnVGI0U/bRaqQ6FpgYn91wXnZq9w63x39S0A2DbURlXE+2FzOdZVCWRsDZ32I7t0std5qM22oqd7kZXhF4Sv7JlOlrmXa5M2UWKKvDC6t62Kjr8XkvX4+HVCll0gb4lNgvQoIjkJd250qUpB+yY4kDftoaI5h39UzuCKsq0Ri9E9ukKDK8UfOTzTPyb0bbNT1FsFOug79mB5bR3yJxZyb9a2oP1/qTg51FIc83V6V6STUR3/xV9vZQrdpYOpLM4cgaVXGrGRoR84NDCeiQQ72txefIccmDskpCiHOcktoVllZHNsdSjJipOHuqYEXo8hIa1Lwn5kzdpZaSZtz/BqYHp2Gq0zQjvuDAGvT3oRi4h/T46VzgrafInDbpef0cVdOf+JqGQVie9m7KbOncrawxPocik0z/PP34UdE5D216H3xq95accUO+eev5H78wPTkEs7bsFQDJYtDIzOPZm4AKGbETok10R2dvkSBZbCXnRdoDglJK+G3NSJ2tAYt+v/b+ZkKvxet24djz76KNOnTx9+4zHkY2lkCEVBiOCPbmjaiEKEwmJh111pKCmBHvyaOyXASuJHqWQ+1Ai6xuGlLh7+3JV0nuPiyqotWKKdScLQo9oovHaXvwu5EBCnNKljkXwGaTs9tMy2DLZJDYG2ax/lP2pkz4MTkUzxCyyWmRLY8o0Hufi5i0YUqtaaW9g1B97el8Y5tjZMQiZNtvDm5BcGtpGQOPbDfSNtP99I2z/w95wN19LbZwsoIN//PzIlfyhH2rgbdCNiVCPx2dUoV8yns1wZUBSKhNDB1qKT/GT41JiKz2/ko0fmceHsbUgYQeHc96orKVu2afiTHYNkt4Mc5iJ9PnR3bHUOUmIilz3ynyBDbihLrBLv/fmPACz8xq2kvNAzEA0MRYfPgfZYFhntwyyEDCj+l4/ay8wYmZ6oivof27aE6rIs7i94H/Cn2x3FZ2h06v7Pv+Jzs0nbPLYS1ScK7tJMLBYz6p5qCq+VObQ8jSSTG5vkDVLd0Q3BQWcamw4VBrzuneakepoVA6i8PQnd5Y7qWYgV3SxjstvHNrWFI04XQczFtbpJBPTIUA8cpOg6mYo1Cm98NAtrqxRVKpbtsITHbcYodEd1XxuAp8fCm3eeOfiaItAVAQL+/dAvBorBn+jJ4on/uRxzYqL/d1J9wXOkJGPIYUb6Iym1xxMhDF6f/Bx2aXRysI8UrOJeayd/als68Frd+SnkfWRCrBylA0cIhNkfWfx/3/wLlzmC79kfnPMie925Qa8vm7sG5kKPamXr92Yie8LfNPlvtqL9tnrgNzSAmFcghoHmk5Bjrq3fbwABAABJREFUkARWdRmfJCOjIwkD35EH3qWZUI/8v3eYbIBTRE9fXx/Lli3jj3/8I/fee+9xvZaPpZHRvmw2ak5wyLTgrc6Y1RQku519f5yIIqJ4QISg8a756ApYt9j55+EFfOrsFTGdLxJyZRnevJF5KOOJ3t9PxRc2sfeBeX4ZyhOIhyZO5P++9Tl804O9nFdXbQrZOHEoG+Y8x7U1ZwctnGq+IoBJiDobpd+KvOC0vbQWx8zJ1J2fMuz15qx2IX00vIFQeet69od5r4zNw+4fiqL3De7Pfz/kexftvgLp7OhTgySrlWd2vU2yFH2qwopfPEj56bdQecu6kO9rXd3sny9wLPagRdl1ufgVH00LbHinRbfw/KCmnGk15SAMtp32pwFD4xtNC9g178hiS98Z1bH+69A1Wpd00wrU/+8irrzuo4C3l7eUcbg9OCXuKALY+2AJANdNin8UKOPHtTjVJDxnjK2R0VUuY2+WSDwU/Vin2mUaPu2lco0NrSt4v+s/sYJnds7BGmW0ytIp0PsDI+lhabBR+mbgOQ+dr7DnU/7Iojwk4vCFpBY++9gj6BhUPXcHZS+4ESs2B+zrvGIuXeWhnz9Xts7eax9EHoP05P8mxJwpVN/tX47NtLzDSNLKkhQ3i3+yhvd/vhhbS+jUI29OIlLK9FGpZ6r1DVTc0MS+x2dEbWi8XV0FQGZqL3My6nhz32QASn+tY6zf7j+uceKnS+mGiKjWNxbnA+jpCWx/YLFYsFjCZ8PccccdXHzxxZxzzjmnjIzjga1dw9wWfEOrKVbEohlIXhVjw47oDxiF90hOT6PpmokBHjtLm8Szby7lugtGJjn6Rt0ksr+ug1498NpoC8ZGyqeXvcPkLzXQrg4OjvNsv+fTD93NhGcH1TZ6Z+agH/F69RTbYWZ0x9/s8fC/V38R4/Bg4bKcnkbz1cEN+4QG6Y+FWegfkbYMJWX7yoFpVPdn8lzpOxGv5XdFL/N40hwe375o8JxH/httdNPYtZ+ihkGDsO2icqzdGgkrDgRu198fXYF5PGstJJkzNvdxc+oKTGHUVx6veJrfbTyNrbOjOO/C6Vz3xJsxGRgAspB49fzfc+d/rkM5J0TBsSRjLJiKbvZ/6W3TLeRfXhvyWJou4f1FDpLPIHOrD3WvBV0RtF4eORozt+gQPyh4FfAr0cz5wW1kbuhBcnpBH3kn4P8ajtx3Ex7bx0fbF9F+w6Dx7vMNb/gJ4Adz/sVF9jpgZOlf4ZAwUIRGbH2wR4YrQ6BazSFz44fStMCCc4IKwkABdv+oiqVzd7Fi1WTK7w6MVp5XsZuNKQX0fZAV1TVIPlB22/FNdIWNaOjNVhLrRFDUxRCE7ZchCwkZePGK33F11q3kZc7H9tLagH1Drbus7QaKK7R4RrwptzZzR9oqXt9VHvC6VapjnvUQdim62qqR0DLXQVJW4HcSLfXfXowrR8cw6yiM3iEnCYOs2w6w/7UystYH3/mGEOhWGWnRDMTqrSOfN4zY0gOPzrdt3Qm801858PeeL9oQn1mArUki5ycfjOxaPgYUFgY6Nb///e/zgx/8IOS2zzzzDBs3bmTdutDOufHmY2lkKC4dOcTSTZclsEkYZgnTpAq03dVxWbw5c6HnrAq8yYEjsdDB3C14csMCLpy+nTRT9DnE/6iegeXdJLQ945cHHonZ9lousHuAviGvWpl+2S7WTi9G6zZReftaEn0qCIGelogrPfrakX7DNGj4LZyOO8OKZhF4UoJnN6GD+5L52N/bEVQn0X7jIlz5WsiML4/bRFP/8JGgXCWBq5M34psi8/cdgd2dtRSV1tsWkfnw6oj3juHxBNQbZKxNQbg8qMfUIDivWkBfnkzW/ePzOysTCtnz03T+mfZoxIm5QElgWepqtrJg2GNqNoUvJI1MTnSK2cZ9Zc9z1V9vo/KLW4PqcTSbfwg7vNiCMreT2amhoyu6IXj62hzy3jJhbfMhu3QMCRyr7CEbNlzyxY/INXcxzVoXUPyddNCHsWFHUEO7sSBpSytCy6SzMj65RHnLndDaDskjj3ZaGrqhJbi7um9iPm1TFbzu2D3WxaZWUuX4GhjxRLJa2f+DWZT/am/YbQwZEGDd6+8p1HDVBDwhhjd3rhrQOE9O93B1xnpmn3+I+588C8OAtsespF1bz4L0WmZkNLB8vgWxNnxEaPAiQPaAWm8N24TE3O9v/NhT7E/NSaz3UXuJzKdOG358mWmxkJHaS29BFvIF8zC/uQ7fOXNwZoY2IiQVZM/YC03Msh9kpqWRXCWBG5ObQmwRPwNjvzMTU0vgPa7aoG2Kgj5rMRO+H+U4LQStty7EWepDcQQ6PM94/W6+svQ/3J022GfjTaeFZjWKewCYmtzIHmtZ2PePGhqjGlUMg8LnFerOF8jp0Zvxuibh1QbvFyXZ/yw47SZab14Aj748mqv6r6Wuro6kpMFxO1wUo66ujrvuuou3334bq/XE6Bb/sTQyhGpE/OS6LOHJTcLamYXW3jmsclA4JuY1owidxuQkGosTAf9gYqmxIh+pixY6OPaa6ZlkjcrIWN5ShqpL6DuSyF7XG5dunCNFs4Cn3O8JzpR7CaV//lTJe1ACbztN3MeUgQIz2ZNJYkMi5++6hFerXj4iGRia910SX9n6afLYiVxZRutkB67M8BEbQ/IXoltbSpH31aN1DhZEty9QURLCh2VdPhOv9NtD5sQOpdLk4I60dWzKL2Tn4eyBrqWKw0fPUpX0nTNR1u+NWAwuLBa0eX51K7/J64CCtIH3fckm6s8zyCxsxVXnN2Yc/94+pjnmWloS1Wc+QTRa9smSj67PLSLthS1hr0maOZlDZ4xusJtpsbD1Ew9ytXwGhCj6b59iwTKvg4snhI8+SsJg2Zw1PNeylPRtJuxNfmWV9B2hJ8jPpa6OWllqrND21eBIstFZGd3iYjjkDbvR3G6UURgZtHcGPE9H6S7zp6AJYZCc6Pek97ks+LzDTzEf9E0iU94Y8vuusDTTX+XBsTs+QhmxIE2tor8sCdUqce0Fy3l791L68gW+JANLR+D4Y+4xSDqkotY3YCyZSU+5hpwRfG+F+jZW95XzqdS1fPWsWjRDZ8H7d1CzNR/PZIXTs6u5pHQHzzctCIg+CJ8gew30FkhB9SxathfzQQtKmGFCMzMwfpr6Fc6Yv2PYNNGh+BzQMclEzpvQOdGCL/713FFTam5hirmFsmHEGeJFqzvhiMJbIL4kg8RJHbgun4/jra0R69UkhwN1biU9S90oISJOhW/C8xNmcUnioBDCemcV7hiKW9x5Kq0zg58Za7tBYl18Upitr64lPWsR/bl2NJsRpIYVC4rDR/8CNzwal0sbMzSkiI0Yx+J8AElJSQFGRjg2bNhAS0sLc+YMKg9qmsaHH37I/fffj8fjQQ5XZzlGfCyNjGhxTy7AssNAa22P2EFW6zMhJ/gQ+HssmI4I0z9Z/o+QKSIlb34JS70JoQnkGGpndUPQ+n4eQoOkZgNdkcZdRVl1gCH7B0ZPjsqBc/585J3Ii1Kr5EMpyPcbGYaB1tqK5bVWxFsK7+22ki73U6j4yJIDFxqH1D5u23gbRdf4B9yGC7OjVmZqOCuRXPME5HXOiMXDQ+nqsfONjVdz8dInhg3zZ8gOXqp4i8mtn8HnHdxWCIPaW6CiMRv2BXd9lRwOf5FfRir7bw96e4BFJXuYY+5DEgaWH/oX15u2laHX1Eb1WWJFcjhwZ0Wf0lRiSmDNzx7i4o8uRz8QukFc9aeS2fe5+HX4HYqQBL4kmcrr9lCZEF2k5NoLl/OUfQmF/5ZRnCd+V2ih6sgev0E/4mMYILvBOBpZ03Qkn45uim2ylHx6yOiclJiIZvXLokqSwfkF/rq2Fa2lHO70T4yaGn5ie3z7IpyTzSHVpa5w9DH37N9xwe5vxnStmg36VAst/QkkM7xCWShqP5nGJ68crDM576v+tNb3miroXJ6DaYigUMo+L6b/bABJZv+tAlmO3rv7/K7ZdFXYeTB/NbKQWH/PQyy++1baW3KpvsTf/2b+zMDUvPreFBz/U4Pn5kWotiGzgIA/nvYEX9JuQDpgRhomzb2nWCLf2hX1tQ5Fcjiib9s+RvidQcfRyjmCpUPgXpfORT/8iA0HpyF27Q855wiLBaOqmNpbwndAUC0SrR1J/LVz4YivZ9nCVRBi96c2z8f6kgwG2IQExujGwLQ/ryINv7rmrq/7Q3eyXY1KgOAU8efss89m27bAcfSGG26gqqqKb33rW+NuYMApI2NYPFMKsdQnou0NXVarO51U3ryOfQ8sQE71MCO/YUhOf+gF24ELHgPgyd50fvrn60Z0Xc5sgSHspI2zqM2/b/xFQA+LaDndCqevfY2LZ5+P2tQ88LqhqtxX7pdR3PfAAmqufCRgv0t+902K7ht5qtDhJXaSCmaR+EzkxmXjSf1tM3DPHj4aseqAXzo3McHFRUVjX1xc95UZbL9zbAyCsUBKcHD6D2J/AD59xgreKJ1Eym+Gl7483uhbdpF/KJVDN08afuMwKE7Iun/lgCNcrW9A6ezCu6AqpuPIq7ahhYgkVf/fVErn1XHhMZ3Il2TWQKZfQeaVPeMro/jQZx/mtr/cStE98U8zPCtnH1vPdeI5I1RqTnxY+euHKX/6VjqXdIR834H/9YxHg+//X/x2Guet3UFDWQq1b5SMyfVpZqj78owxOfbJzpwntvHuz5aEnHN6L59FyxWRPYutl7uZWTi6ruHh+PTMtTDT37tm67/jp7ym7amm8ib//1f/ZiEiOzblwZOF41X4HS2JiYlMnTo14DWHw0F6enrQ6+PF+MV9/sup+u5eTGaVPxa/GvU+Vyc08fxtv2LJJzdRZAs9mQxFEgZLr9iEJ92/XHBnCFpuX+yXrgW0fQew7moY2Qc4Dkh2O/rSmQP/il7TWfLVW1l65y1cvPgyLl58GfkP+1UwJIeD/8/eWYfZcdX//3VGrq27a7Jx96SpQ4UKpS5QWgrUS2kpUuDLr0iRUiiUKpQidXf3tEkad9vY7mYt63Z15PfH3ezu3esrEZr38+yT3JkzM+femTnnfOz9brxpESMkLxIW2emdLFn0wKgVK+7+w0J6psU3AHf32Hhx16Hluj6cUPfDRSQtySTxtYPnI/GZOl/50oVYPwr2to829PZ2iu7fGNUrHQopewxyHw1mkjF6elA/24SIoeZM8uqoSzZiahr1ty5ix0Nz/X8PzkOoFuTybmakh18U2WUfZ4/fgKwMzWuaJzt49bo/4EuMgZ5Vxj+m2obHVLPr8ZmceOaauI4Rc6bw052rkUNJrEfAT2e9wR/yPgra/tEFf0R8UBDXuQ5g39nJbF1bwtWXvz6k40cCriyBbhEs/ME1OI3RYRkse/m7jP/ntYz/57WMefqaUbnGUDD+5s3suXNh9IYhcMKYypgjs0OFKnQS3nYg5k4d8XOPv2MrFTfVUPTPg+81P4rDD0cjGTFAy0hEGTcmbDQDYMd9Jfxp+jNxMehYhcpEi8rN2e/zStd0umLIA8qydGNKJiAwJX9aQB8MHVMbnRQQT7pC6S3byZKHt8rXHlcxfjkTdcs+jMJsDEv/QCS7DWS3gTBNjGQH5tbd/fUwkoQWHzlRSFT8y8vesx2YIcQCZxbXcF3eh0EpW9Fw5/SX+P3OU2lui+4Z15J0lBjE4AbCNAU+r8I7tRPI8o2cjLGUlET1Df2TjOKCSfddx5brD99oRtUdi8heUM+EpMbojUcQqpDx/NWNT88P26Z+bS7lPx6F0KJpYnR1UfhWMwhB1/hU2ioiT+CFH3QhOb2Izh60MHVBpseDZVMNSAIzNwNvRnDxtdrpQW7tZu8P5gDgLPWhJPUv4Lf/bTrHFFaiisjjjl32MatgH5ubcnE6g8eQd2on4DEU7soNpmuWhUSZmsjVX3ubLt3Gy1VT8X6WEdDGPd3JNyavQBU6Ey3DLyJPTnJGrJGzSBq+af2RIKmlE58qc5wN/jD7BX617St0dsXWj3S5m8QQGg73tyxix5ZC8i7sZ5ZJWdcUcR46AK2hkYrHs3jy89Mp2tLKvtPSQzJAATzx2SL2zszgsdKPYurvQBR+0EXbxER68oJPbkr+ND936uj5MuVuGbXLf23FKRj74ZUsP+5vZMY5ho80CmztjF1YReXvF0alNB8Mu+yNKHA5UpiQ1MjT3y8k+8X5JD77edT2SmkxRnLoZ1q4vOi9qcF6uz/FT+kp5JDn0x0FH3300SG9/lEjIwbodgWRHnrQElYrtTfO5rmFf2ZGBN7iSJhocfC25IvJyBgMU/J70MTGyrjF0eKBZhO9k9Dw+M7fnvgasydcS3ZLBr600N/XFAJvZgK2wjyMxqYRLXQWS9ejXTyfE8t3Bu37SvoGTrDHr9x7TkI3D1g8NBPeyBCKgvvUmRCHgNFAmKagrSOBLGP4KsbSjEm4ChLwOaQAvQhtl52EOIRf23QnC5Zew5iu0Y+eqUKm+RuzKD9ub1gGqZGAbpOoPk0iVYJzd36ZfHtnn/Lu+5NeiXjsnXnjeXbfyaPGBKZv8bMbJfnGIPSMiG3F5l3oMbw3BxjOZMDqCzYUjAQr7XNy+56TgROGECaXzPs85gVReUIzO9szsaZoTM2o79u+or6Yto4EVqolEMLIOIADbDtjbY38Tj81YN83ytfxi6z+lMJjNpxLxpbRq7lRJANvZv+c4JycSpPfDuOchG7+ZPHRGebYgZhfupdStRUIHAt/31LBUxvn4KiR6RiQ8ZS4N3YDyly1iaRVYCoKnDYvbDtHtcxn8jhut7dGLAC/o2kSjQ2pAVxNUmU1avEEwim0mjJ4U0AeYWp1n6nzvbpjAmoahQ62DXZuKD2L2wveGLK6dzjc1TqGbbW5xHrWWWk1GHNFX5qiuWg6HWXRDa6dXVmUJ7aQqo6uvgvARZNW83jPAoq887C/HIKCVwiUfL8AoJadgpYYuvZSdltRnfkByuFKUyf2VXm45oz+9zhYMJAwDmIC0MG81mjhqJExTEgOB+u+/zdkMTwPf6rspFu3RWWQqHalIfT+AduUYN9JSRTvTQK3Gwwd2a2h20bu1kq6gTyC0W5XlsCbHd3T5C7LxOb1jTibUuH4/TxSPDRtklDY4+vGo0f+vYXdTu1lvkP+wil5uVSfkop7RvBvaoxxwXQXe3zdlMXA1lKlyZRetOGg0LkqyJxx4yfosQqRDBGaXeJXpz7Hu85i9jxdwYZyAy6J7uUDuD1zO1/9wTp+sORbmJsrg+h2Rwr6jl3Yo3iz4zVl9cb90BiYoiFnpNNzfEXUHPJ4kGZzMTu9OmAxe6F2Mpsbc/EZUkzP3mVJLVw2/4mw+1d7vNj+kIZl6frwv4MQyBnpwdtNE72llY4OB03eRLIs3UFN2n0OdrdnBLgUGk7Q2XPW3/s+Z9q76UlS0XQ5ZOTmAL6f9w5jleBn+sElJ5JQFTxa6A4VNSkJo6sraN9wkLBH4bm2Yzjn4tUATFJ1EiUbTsPLJp9/vvnvu8eR0OTvqzBB7TLBMFF7DBSXHDHS/LlHZY7Fi0OKzloXDU7DyzKPnU+en4Uawr7d9MoE/vI1L7/If4viIdQPhsJqj5cHPv4SjurwxlSodD6brOEdNwa9cjfVpyagV0Sfyyrrs3EUeQ+KkQFw2dzlvJA2naLB7LGSjJyYgHt8sMr4YOg2BaMiF7WtHQDT68WoqqXoRYMdc6JT1Ru6QG89+AxyRzH6OPLNpIOE0Ra5uyJ5P9PsIQTHBsAwBatfnRJEnzgQeksr0orNMeVaxwJhmqjNTlI2BnPjH2zE5DAVwX+mwF+3Mkr38IyV11DbnDoq5w7CML/D1p+UhDQwDqCr286pS6+PmkOtmwZ6DKFw0dt2uDAOElmzvdHDf8YX8Z8JxeScV8XOSx6M6/jJFjtvvvkkcmH4tKojBbWXT6Dh/JGVsrt37NNB3vJnyt/n/LHr2N+azGnLr8M3DMabbsPN5Q/fTONcK/qsYKHOA5BTU6m+anzQX823JoAkM/ZejXdXTgtZ6PnWjkkk3R2ZTvKFse+yevYz3DvtyYhMOxcv+y7vuVJj/n4N8210nDE55vZ9iOH1sbQLvvXg9/jWg9/jiS4/6cR7rtS+bbam/uWC5IOsB5ahd3ZieWsleZ+0hx2fhQHXPXRdXN8zEp7rzud7D18d8Tt9/uI0zlzznRG5nm4afOOfN4c1MMCvbH7RqcGOqykpdcx6ZgdynLTRB7O4uA+D5hY5Ix3PnIqYDzclgXfBRLwLJiIX5CGVF7P3kthqiqR6G2NuWxVXdw8FdFMc9L8jHYfasXpEYN9JFqxTnOSdc6h7EhtMTUP+eD3GoqkBNQ9DgXVHA1pdPfKEsdEbjyKMri4K/ryK+uvmhKWwzfpSLS9NfCpou880cP/ePyNdfczFo9nNUcfW3+RQ+nge6jujNyCbpmD2sqt4dPa/WGALfn4mPnwdZfdsBsOEKEkh5b9Yw8lLruajv/89YrtI+FNrOe+dOIaJb7Vgl4dX0BsJlhYnxkZ/StL1O7ZzqmMFQ00P/McnT/DVn99G2r8PMv3bEYqfZW6gbZyDnSfZmX7TjfzzW/eGfPYi4S2nlVv+fR1Sr01bvyiBpKIFJD3tZ/lpumYhmqN30g4zd5sS1N88H1OCrM9Nlr4+H80uccLP/Slwz794LEXLvcS0ageOsRp8uvh+Fn96XZ/K8WDctuZ83huzlTtyPua+tlkAyM74/X+SzYY2P5iFzBSCrLUeWiZbY6b/vuexc7hHAszYPJHG+q0U1WZS/a3wi9If//sKnjh9G0+VfRBbJ0LgtG1nUP1+SUx90j9Po7zqGnZfEJ+jYCA2eN1c/MgtSKNTtx4Wm+ryaHQmcWJuZfTGI4Czxmyi6tN02ha3gWkijx+LN29oejotk60YM4swhT+FzbLRgWuiGzlMLaLeZMPRKmi4YT787agY3/8ajhoZMcCUYXHBHt59YgZjLt/UlwZhHD+T8XdvGjEmor9UfYmqxgwunhy4gPyooYKGzdkA2GJ1Chs66qY9GGMK8aUMLTfVurkGvbV9RFTPD2DBbdeQ2zg072hIUUQBN1z+Mg7JwwzbvqiF9xNequMb6cuA0QvNGoag4s9ezJo4ChxihKwaGAeB61rzydy64wKa1uWQ92mgZ7l8Sx1ab3FfNJgeD46lO1l849W8/9e/YRXxL9p9powR4/ViweOr55P1iQoMep5Ms08Pp1hpwzqMFMg8JTFIJO0owkMVMt/P+pBfvnM61S/BpW9ch6mYFJQ28+m0FyIeO3v1hbTWpiK8AseAW2rKYCj+urm2i2bhSxQx3ZMDGavudIEhKyTVeHnjwcUAZDbqSL7Yx8PNPi/fq7w0rIEBfhXkj/aN5bKurL56o2nzdrF2WykJuwLfl6x1XuzrqoNSFOWsLIzSXAw59FwkDEjdrflrJBIkugsjz1lShEw/e5NJ9vv7CGjSm2ZW8kwtNV8rICDrV0BPuQ8EfL55DLNbM1k9+5mI1w+FaSsuwb0tFUuMWYjCAMkr0E2D426+lvN+8W6AinY03NU6xp8iFcXAcE70MGfs3ohtit7xUlvXFjF1biBMQzqo0QxV6KRbnPTJbEoCU4rz+gJax/sN2YFZrcIAyx4bCBNfsomU7U+/lHbbEQaoXgEmxKE1eMhwuFPYHo44amTEiHS1h3MnruONWxZR/N/daPUNeNJU/pq/csSuIQkTvUPlmW0zA7ZrLXYc++M3ZPT2DpRaG0LPwJseOzWTMEws+9oCRQib2yl/4WrWnnNPXAxag5Hx/h6M3Pj6MxDZ61y0TLThTRFoDig4Zh9XpVT3KoZHN6buzlvDSBkYHYaLe1pmo+sh7s367RijlJN/sLC/NZn0LX5l14GI91vpbW0kvb4e/S9m3GQjt9bP4s0XF1DMyERuHl87j9TVFpJq+g1da20H6Dqi24lITaHy9knkyJ8y3OdE+2obHd4FpDx2+Gi0jCRMU7C6tZiJqQ0kxiA+tzhxB+kRhrEyNZF7C99lvpiKo8ZvDTT0ZHOm7fSI5+3cnEFCW+gHy5sk8C2eEpL9KBp0K3hTBE6vStqO+F3ZH7kk/tv0JfY1Rc9Jdzmt7PZmYJiCWWk1TEpuoKPczm5ycOxR8UxxkfuiBceWBrTBtTM52Zi5GfiSItc7KD3+sVzymhiqwJkT/2+SWGuQurULrSoE+YKho+2pIntNBoYi6Ci30D7Bb5AdEKvVulTad6ZTvvdqAN46+08hld4PYJ/WzTW7LwDAvTU1pNp2JFjbBBXPX8u4V9ax+4dZQOxGxh5XVkCKlCfNxLCYSD4RkLJsT3JHpZytd6XQ2ZwAhkBJjC0a2+22sq69kBmpo6OZMRjSMFJSDYuEM0vBF4b7xK8+LxCGwGv652lrt4g1IHgURzCOGhlR0JOn4kvzD86q0PnqpUtY9cF0qG9AaFCvdZM3QsVlpYmt7FRykbclIg9gKh1OqZzW0IisG6hqbt823aEEebwUpw+h977xmoG+c0/Afr2piYobmmg+Syclir2jmwavOgNDrW5DZa2zBNPnQ7i8yB4LujWyW1Fx+jC9gQOy9PFakh1zaZ6uolU4exl/Do3LuMPQeWxzIGuL7pNQaq2YxuiMnmadDUvnkSd0ZJomtzcuwippfC1lddRUmF80TcZtqLzxygKKf70U1OEXjH7UUEHO+yoJdb0LYgEdpRay1zT10y6WFlP59QcYCRXhtXOfYrz7clIeG/apDlvsbswkQfVQnNAW1tCQhUGe2s6J9m6sIj5qUdt+KaqgXCRT0JsiaJwzdGNRt0JPvoS1s1chPo7X+s3OaXyyO/Y0U12T2d2YyfS0WiR0FmbuIc3qZF3XWC6evIo1vxyPVhO44JSSkjAKs+KKVstug8Q6H75EC5qDsNS2g+FNNXGs1TBXb458/o/WYC0tpqO8ACk3cKxSknzQoVDxcAv61kqunXgJczICaxFnJ+zB0kuJvKpnat/9H8oIYG01Kbzz897bNoTnQNBX0K5l+VDsGppHRnb7z6VbTdJsfgPUMAWbOv21WMWONlJVJz5TZmtnLrveLidBB3eWATEaGW6XhZ2+TPLs/pTUVNWJNVKIaZgwhkE3a6iCnvzox8susLuOlgJ/kXDUyIgAQxW4LujgstJNQfuEoiD5DB5pn8PPMreN2DWVRB/eMRr2TXFEHqLUSepNTdBLVQkgz5yMmRI44Eobd2GE4dMfiBbDSqlpBKWIeUwfem9aVbPh5Wf/uCFgv9oD2fd/DnRAWweqpwCjNDNsSFYYJtK6HeghaHmtb67EnLmInSf8K2p/Rwu6aeAeNDubpkCpt1J2e4g8fMNA16SweamxYvyfqwNoAkcThiEQI2QsmR4PW2f7///Mw9ew5vS/9O1Lkx04DS8e0z+B6pisPCkHvaWVYvrpYDs1O1ZJi4ky1aUHxt49hopybwaqpmGoveKVNolTbviMdZ+MhRFMxzpiMURSgY37CujJsTI73b9Y7Nat2GUfci+3k03SuSa1luHSXx8qmBK0TFLI3Ggiu8O8v6bAaYwMe5JmSBhCoAqdCUmNTDi5kU4thBEhBNr0MUOquxOaSfoWD00zrJgx3BZTghnH7qCydjzZ70Rvv/uKQrRxYQgmCl1s/WEy464E5UvVrBu0+62bL0MfqWxWAaLXQSGJ2Mde3TSQMNGt9DFCHVgsKVa9b9sJYyrJsXZimIIWXwK73/AXzNcubuakgkrq3SnsfqO8f/lu+iltY33TdE3mo13+Opf5pXspdRwEApYhkKSMMunfYQPTlDAO4pc1/wd+2KNGRgSU37GNY2yhFx/VP57HWeeNDh9+PBA65P/pc3QjdkYWc+3mIN9/rMPv/1UsJP3jJJ4o+zBg+8QXb8Be23/WwUOULwHqbp3f9zljkw/7p9vwzh0XdA1JN5A+WYcxgrUgI43/duVy59rANI7UD21kPBI6Ncbo6aHiivXsuG82SspBriIcIsb90YOxft3In/eaNVwiHdf3+bbta/nBn28m58H+tCxTaw04xvR5qTnGYPULE/lK8RaiYeWv5qB0978TpiyY9pt1QYXjB0P06kiAXFGOtzA1YJs7PfbfZndjJnv2Z6B5ZcZ9exM7/jQfJdPvILDZvSPqiDlUaJmikrzXwNYc7Ikuf1Zn8frvsebnDwzrGqYpeOu5BQgTvNN7uHDiGtp9DnYuBtPTr+0jVAva4imjznoI/gXkVy5YhlXSqCQ8Y9fhCHemYOe//GxcP09/hFgJNZ/vSSNVdXLimWt4t3JC2HYf7x7LuLz9uDSVxvcK+7Z7PsvkTTKD2tuaBXqPI7wBdghxIF3KXDANbxykCz35Kj35R/5i+ChGB19II0P5wX7qV1SQtzQ4vN883UrumX6PXI41kDlHFgbXp6/gMvscEERVuY0HZ+44nT0tft52IZv0TPDgqLRGjVIIExgBitBYYWoa7d/O5NSUy2mdlMDSX/2N8c9dj22/RDRH0UCjvG28iid1MqmvbAzZNpKBsfOxmTy6aGRUqXXTYPbvbuCaa1/u9bZGxqlbz6TDY8PlVQOKOQv+q+JYsb0vmhMScRiCQf30SUy8o9WvZxANksz+FyuwWfyLocbKTCpu8ms9TLyrlqpLi/FMj2GSM4wRLfrvP68e8Mjedf7F5NVsR49Sw2JqGrm3+njqmmO4+OTPgva/uGsaiS/50/QSu7yDUltMVKEHvLPtPge7rirD3Bt7nvb/IqRpE/Cl2IMWrLkrdNpbHTjnxrYgMmscTHygDs3nZeIfakH1Ty+mJDg183LueurhiAJp7zhVrnv5mtjJLQ4yTAFdhRI+h4Wk6sGkAdEjyuGQsNxBQr3/YGGC4vK/t75dNt61LUaYJsmzXMhrtwcIro6EgZG+zUdnsYI3JUxNS4rJrOO3Y5U0Pr5jEXlLto+6Lk7B45W0nD52SHU0oXCAQvjGTZdw+ZjPuTltb8h2HtPHw+3+9LYO3c7Oniw2NkTWiDgwBxjmoPqCSMPmYerXOJAuJa+vRC4vjknL6gD+B+qTY4KOiIm6fSSvd6TjC2lkzEqv4aMFaewuSgnal5jdztyMqqDtSbKbExO3kC0nsPNKmeR0Pw+Dz5R53WnjS/auITHnHEBjdxJej/94gT8kGw1qF2Sv6R6dhWAE6Fv9tHpZHRXMX30pjnop7oFTt4IzR8J63CSsb62K6zuMzWviuBESc5WFRMIZDTyy+xj+bkKCxceszBruyfMXGj/TncInHf2erOrWNDSfjKi2k7uifzXkWLMHvaU16PyDUfKqSe3xdihyRW17AHqzlcL3TbTde0N/h4pykCRERxcIQeWNZXyteFnfgvq5rn6VYK1mH4Xvp9LgSqZnQejFownkvGRD1I2esnbA9dZuRhTkI48fi/BpYb8ngF65m7KXUnijcjGmJHDm9z83tiZBYm2w40Dy6lhqWvjoofnkXFLFrLQaPmsqp+vpfDI2HPkUs0pZCaYl/NijpzmovKZ/f8YnFtL/6f/e8rgx+JJtGGqwJ1Lp0UmuEhiKA/fMyIaGusVB/mdutD3+sXNw7QA74bL7buHyb77NbenBQoJnV55G1QvllK9yUn+M47BdtBjqyLDg6JpE0mr/IJZUo2PpCDawZVf/+KLbFZQxJciajuhxoTc2BbUfCmS3EdI55JzowZHsJtXqZWyC/1qJe7rQm0c/XUdvakLyjSFulogo6Oq20xyiMnmz18VeLQ3ddNDo668l9Opy35w8kpB8YNbaocAV1zfc0ZaFZkp992PE+9U7iRtOJ7J+MCRWj+KLgC+kkQFwauFWXHkqjZ7AAuUcayfjbPVB7VNlJ7MtMudUnsq509f0pV3opsSy7goK5FWMVd0kSvGvfnf5utGN+AdUxWXC8g3RG44C5Ix09BQ73s+GXiCrW6FlqkpRVQXGripMz8gKf0XCZq+Ld3v8nPIXFK3h3ndOw94g4bLAy8WZFC9spdy6nyfqF7C5tt+bZTTYULsFGRsNHC/0K0HHOiRb31hJVtIC9ss2RH70Am69yUb6BoH95RCL4V7VYl9+CoYsYbGp6IlWLvxKoChUaqIL72lzsbzlZ0IzV20izzuBqpQQiscAJiS9uAo9FGXwCEGoFqSU/glfz03Dl2JD8uqonRkAGO0dIVWzpSVryVoCSDLStPH4Um0ha3vULi/CpyM8PrSqGjIfrmFX8UK2FeZh3W2l+B/B6Y6my82ZO07nqbEvDuldHog7miYhbRkZUoggSDJyeioAvrxUdFv4odyTrvCVyeu4O/9TrELluLyv4d4/D9trK/Dmp0SkqrS0a2RsNtiX7a8R0zO9AQ4QZbsDYUDucg/yh2sidjn/rqU8lPtlPp4dnCK57/kycu9dilAUOGZeiKMPH+iqwJuiBBkGqtPkprq5/Dnvc2QhMc7WQEFme5BQp+ZWsNSrZG6Mb7zz5PifJbXLjqxpjJRijDtD4MoLHMFmjaliQlLjkM+ZWGXSmmrroys9FDDUYBXu3T2ZLHfrfcQT1Vo3q92l7HBHV7WOF94UEy3fP4bat/dSuyq9bFve2OeMA2jrSKBB9Y2KkVHtSmPJxvGMGyEWv6M4igP4whoZPlOm1p3K6qrigO0zi2v4v5zPQtK0Og0N32UKnzw4llMLtwbse65jDmenrGGmRe+lU40M3TTQ0PGZOv9pn4/HF9+tkDSQvYcm7iqsVrzTSmmYN/xwgimg+qxMSh7vQdsXPV1pJNCmO/lN7RlseKVfuOrA3Za8kLBT5Z87T6Onwotk03vr4Py/dd5Sk5Rlwyu+Tnp6OY79s9j19f57Lll1JKn/fmou/76CT0wSng9d5yEsFjzTSvs+ezMc9OQHe96Ozd3F1h/n4ntb9EWMjA3bKIpgn47qkyUEUnoqnslFQbsMi9z3naybazBaWv1MXaFSzQwdY90W5HlTMazB74+0uzYoulT6s8iRC71xP/oJsHOPYMYwi09f+8vxFP9zFOq2hEBOSQ6495FgbdXY+qMpLPv7ShbaPHwy9UXu+0MRb6yejB6Db0N2G5S86V8s7TvJgjevd3lrCMbcuSq0fk0YjLl1ecjFcQ7Bjp3DFb4k6LDLpOzBb2j0viwJdT423T6djQ99ymSLwlUpDVRYX+Kq5iv6jjV0gaVWpfDDoRvwviQLvkmF0RvGCM9UJ5dOWh2xTbUrzZ8+GSPSH12G/Zx51JytoNj6jTHdJ2FqEngi5/DLPhNJ8+ucDAWmBN5UI8iRs7KqhFu7LuDhCY8D8Eb3dDo0R6hTIAkTSTYwQlGUD4JF0tEHLRnsk9pZP+9JACZUX4snVwugrw316ule/9pBUo0ApfgD84HTN3KRlU7N1lfEvLyqlAk3bQSrFcPjAd1A0o2wuitfVBjmwdWuGCWSyoOKL6yRsaK5JCR/+drqIo5r/lbf4DAQDsnCnNf3ooep+H+lYxa77fu4OKkt5P6B+Mit8mHX9Pg73oustR6UDyJPDKOF9gtm0l1w5A4+cz+5HtuG6OxdCZV+VhJfsolR5k9vajzXg7U1D2WYDE/yh2sYN6B2vvr/LeorBjQMwfhrNsS1eIuEV3dOoeTC0LUvhwLyuDF4CoJTFQfDb4QUoXR7YUWE/q/YGLKc83814K+UFOEuz4r7uF9950pm3LWWu/PWcH1qDd9etZvTrroOyRv74nHMX3b62ep68T8wBw4J7gyTDbc+xLE3XI2lvX8RLTSTW6+6jnP/9g7XpwanGyYvt5O+9eBFbEcCLl1l/3FuTF98xfv2l1YwcVMZlb/sf9dz37SQ9FR03ZiE5z7HsXA6dcfFR3l8AM4SDSU59PjZtC6HW05bCEDPW+WcEEZVe0JSI/ljOnhzx+So17ukYAVXfPe1sPulSV0o3sjLLd0nUfYf///3nWTDKO9PqZ34/R3onZ00XbsQro7anagwTMH7L8ztqyOyADXf86vNFz+yHX3HLtS2LDxTi8Of5CiOIgZ8YY2MSPBpMne1juHmtB19UYmHO/J56ZxFTHxidxBDzUBsd+dxl8+fhnJT2ragOo0/tZajI/AMIbFXmFD0z+3g9WF4PIdkgu95q5yWDQLrCKfm7juvhJwVmYhl60f2xINQ/uw12OIUNlS7BPo2B9qE0WMEKbtnc4AWxFBTlRwNPj78zSIW/HhlxOf0UEHMnowvcfg0n6ONn550IQn/7eaZ8veHdPyXL7yCzLUbYmZtO1j4/M65VJw3jcqh0j+bBkpBPr7S7KBdcrcHY/3WEAfFcXpNo+jBTTRcNhlv8mFamDEA9979177izBc7ZrP8+3NRl23hjVOnc/evTuH/LXgZdasD38TDj00oVthlH7b3svBel4q+eXtcx+q7q6n4Xn9aptnTgwHIqSncvGopsjD44e+/S+bDwRFGadVWShrzqbogf7hfIfjcNhvizXQWpuyJ3jgCFpbtJs/WSZUnk3vb7NyYFljPWa91c9qa76D5Qmc3pL1tx9460B3i/3/eZxrm5xYkn4l99V70ri4Ach7bxLLt81j4pxUhzhYdb1RPwrXGn44qh/HC1F063q/E3W0GExx8wWEcZArbg3mt0cJRIyMMOjQHz3dncpJjH9lyAt26DWPXXvQoFHg+U+4Lvz7XnYsq+r1chinRodvDRkLCIbHWIG1DO4A//eMgF3obx89k50V+o+jcrFW8ZMlmpIvydBuYFmnUuBSa9R4WfXod9kYpfhYY05+eNprQR0inQRhga9FY/ru5IAQd5RJGqknP+fOD2soeE9urQ5ushgpTleMOwRt2BWXKBIxNB48GVdtTRePv5jH+GwVsP/Y/MR+3x9fN+XfeRvaa9RjOkV9YKuWlaJlhZHVjgLVNI/U9O2Wub7PttPjpVo2SXExZCimkaUo2lCl+kgRz++4hR+L0zk5yP2iidU4m3YWH9yQ7w9qfU5eTvowN/68A7ykmWs0+xv49kz9uvBBXhYYCOD53kFg3vPjanq8pzJoRWDhf+dy4uOs74sWUlDqe+FEBRc/4a3lihqEHRL7237AI9fQmbIrGKQ6/E+Ska5bz8VcraO1IYMyl6wDovGQB3UUSugrufJ1x/+hm/4LkiIanKYGz2D9QC0f4AduX6aP6+7P4auqnUSms7bKPmcX+iNSW/bl43CoWq4/JOQ0A5Fi7UIWOz5Tp0gPThz9xw59qzsPpDM67NIHkT+w49mvInmBXhOwxwOPXizLzMth5+xgMq7+dSNBYGLHXofHcjhnoexKxRuEcOSA+qFsEYCHrrd14x+cPK3XKWaj31aMMhtohY2k7/B0KRzE0HDUyIuBnq84hK72TZIuHXQ1ZjM9r4uX1uZw0aRt5YfQzBmKra2geGF2TSFprI6laRxiQUN2NseHQ8cx3F1i5bFEwZeiRBKdpYlk3tNA7ACbobVakVC+tE6zktkwcttd22NB1rI3deLMS+op3Jd1AbXaitikggSkl0Vki0T4meFEoeyFvtj8VQNq1b8QMnXBQ8nLxDWGiMmQJX5YDWYiDamDbXltBlnU+J6Sdw0dTXora/i2nles++xYVDy0btQiGnpaANsxIUPJeL2qPyozkb5GnxdfTSMrShir10V7aunPBp6Fnp9E2JZBcI2W3C/HZuojX0bfvJNVhBZEUc2qm7Ibkav8ivrNEHjlBtxhRqCTy1JhXOE8+wS+49tk68p2T2TXb76BJrg7NIhUJ7gyFhoX9C7BLj/2MX2cHpg7O/XI6e0t66c9NKH5bQ2ixvyfyLjtvJ08MqjMcjEunreT1Fccy1Eq89ssXknfeXt4Y/0bA9rty10LuWnb4erjg5ttIq/TRNBtEvt9IlwBXQQKJdTqdqkJPfujvZsrEpkFkipidRqrQGZfopw3v9Nro8lpJVL1928LhEzf8t+mYANIQgIzUbsal7cdrKOzfXR71PpmSwJuZwEmLNpJj7SRH7SRf7U/H3u7Ow2nENh54Gx04WmNfzBsquNMFekEmanNvKq9dxZccx4slwJNqItK8yFLo7+oTFoQuI40OadZRHGJ8YY0Mi6SjqHpQGFNIBqrin6gKnlRRnKloQAngrsih/DGT5deXcHzxLtLV6ArZQ4Hplsn9c3/BaKzThVAUPztLL4wQatnxQs7Jxp3aP8nXu1OGzAc/UqhuTWOD1x2Rc38gug03G73BwkjxQBjgqJZxJgm6Fzups6aRO7qZXVFhahr65u3I86ZiKv57JHl1aGii9soJmBH4BwwVPGkmuy7wLwALPhmHY28HeH3oO4eXQhASQuCZkH9QxMPCQbL5nxfD64tZsyTh+c+Rtk/gpRf7WaImWRoZp/oX058MeMV+sOF8Kr4ZmWFpOBBW65BVuQcjqcpJ0gUbMRdOx7DJI35fDtSMtEyxMu7C7QGLsieWLGJiXQkA2t7qsIajuXYz6V1leE7xL9S0xNB8/IrTv8BUnSZJH+0AoOeiCejWI9s76kuWaZ4useviyBGnlbOeAX86PbppMH/r9cgesHQbMRk1hR96qfdkwvnR++RN8jsLtPqGWL5CH+SJFVzyoze5NrWSDiN0n/JlmfU/vJ/Jyy5DDKCOFUDdpV5KHxBIeTIUh3bFx3q35Q6Zotea0C+VkOKo3JrTq2gfCx6sP5GVVSV9nxMT3AhhcnrBFn6RtQWn4eUMcV3Mfd7ZmUlOVidTbTWcYO93DDxuqjT6UkJGUgbCP2/H/z4YKuz7Ugolj1dh9jiRsjMwMmyoXf2puIpLQXHC4Pp5UwLDAhS7IuZ/KMlevBYFS3vc3TvoMBB9eiIH63pHOr6wRsbcjCpyHJ0s21MesD0jpYeT83ZEZBDIvc/GW+dO59LFo6T4PURnrVRRhiev32uofrZp2LSw235exqWLl/R9XvbaNGyHONW/+IKNXPKTW9h8Y2yCfPe1TeW/j315lHt1CLFiY99QJOVkU/3t8Aq1B+Cd6GLniY/2b7jc/8+/OrN5csLI50AfcgiBb8EkTElg29Pcp+cQC4xN23igYmzf5533fJ1dFz5Is97D//vuTX06A0UtzlGtwdAXTBpxthexbD3yvKnDjo6EQ8YmD/U1Yxn3i34j49Jjl8Kx/tTSDYsTMHrCO2v0nXvI7jV6G29cFLSQASh4vQ5vURr1C+xUf3dicIMjFA0Xu9lxXOypeuDX/Vn1S79RMuHTb1Dw4Mje169dtIQnJ81h7DdiNzKEauHJd/9DimTnHaeDT7pDj09JspsfZVSGtaP3XmsCsesLhUPC2A5mPXnwMgOEMFky+18BlNhGnCOF9NtMOv9QF2BgAFyW1AK0UK1183Br+CSqpW9Mwz6MpUDVZf0Gk6XTJOuBfqrbBCClqJCqSwOLxLXEfsKUaFBsGtr4Q0d3fBSjhy+skQFQbG8jb+K6gG0yBjt7smi4cwyK6+C77NXNDsb+eV3sQ5AQGItngAT6IL57fcGkvv9LHn1ENDVO+doKXv1kDvaGoS92Lrj0I65PXxm0/ZjkH1D6cWznKH26jpld17H29pFR/o4HBf9VsX2w+ohk1vnjdx5hjrUVm5AhROLDN5IaOL7Kr4D9re/ejOXtI5c3XZo2AS2tn0XsQEqZpyQDUdxfjKp8vjV61E8IGm9ciCmDvQEmPnid/9gZ/U2sHRbSUmeG78+SDcNSfR81rNqCAsjpqTHT4g4FH/zuGCxdgd9fnTPIq62bSJ+uC3l87oOrYNAYV3f9bGq+ln/YivcNFXPuXs3LWcsJ9Y7GilWL/s7vxs1l2S0jozvy6t4puD0qkmyy49HZAEz8cQ16Y+TUoQN4uCOfem9q2P1Ow8Kvmyfw0dyHuXznBVTWB5MLHM440P+b09f1bXM4PHw259EAA+Pxrgwe/sF5KL6RGwuKlUR+kbUuYNtWn483u6ZyS/o2nlMWg2dkXhJfkqDh+4v6Pmetc6PsDHwGnPkGUqbnf8APHwjdFOgHcbA5mNcaLRzeVXUHAarQA/4kYWKYIkBt9WDhjPGbuPXrL9DzYk7UtkpeLmL2ZMSsSRiqhCFLQSkPhiz1/ek2BTF78rDTLRJlz7Bqvr/x9Xf5btoKMuWEoL87zn+KHf+cE9uJfBope3xMvvc6uo2D6wGRPcZBFQ6MFfLk8TR9ZUzIfYYCN13xEottHWTKCWGF5mQhUaYmUqYmctwflgVMJocCjXOttH6vh5abnex+fDryuNDf7wCEavG/F7Mno6XYA96BAzAlEbDdnDIWMXsySnlpwLkq75tPzrJket4qp/3rC9BtoFsAE2SP/8+U+/+8yYLWCbaAcw/8EzMnICUNvWh7JNFdZGfXEzPY9cQM5Ioyv+ZIewfWtbuxrt3tT7sbIag9Oq///VhsrRqyywj4G/wbmarUd//krECaXtPnxfR4MD0ehMVC24WzMBX/sx0pNXC4MFT/u+NL8rsVesb6+OV5T4VsaxUKuR/I/rF2KBAw+Q8buDHj02GLQSZKNnLUzmGdo93n4I3qSX5WIrfapxmhWHUUq87Om8dQ9cuFdF66IPxJTINHOyay35eML8KN0k0Jt6HyQncFHZ7Q393xuYPc54ZebONY6cD+bHT67APY3ZPJ638/lu4YCnxsko/LUlZhF/7oUUXefh6a9ljQffSZMkrPyDsbVCEH/I1VJI5P2Ma4N65Bdo3cYtUU/nHwwF/LRBudcwsofrGRvjp6YQbofBzFFxdf6EjG4QBZGByTsAPGwNkpa5hnVZlc8Ry/YHbYY5S8XPTcjIhFmINhSgJfig1bWQl6bX3si+RkH+Ns9cNWRDUskH5MA9enbSRRCq2CfHFSG50L3+C+750DQMF/tqK3BWuOyDnZGOlJyC6D3BUe5sz8Do/PfYTZ1tCpAQsTKnlm8Uw8nw6vLgMgfYkVa01j2ExepaSIyquDhbJkj6D4jlFKr+uFlmzDlR1mMhFwVfI+ZBH7M3NH1mYeKzl2ZDpnmlj2tePLTcFQY/NtNM6zYszp5IySzX3bnv3GYmzNOSQ0GCQ9Hci3LyUkIPKy8cTxXgB9hYymKiPbx7PzMn+U44cnvkKRpYU7O75CT370SdpQ/IZGT56Ko9HXl0bVd50UG9bCXBRXGni8Mee1C6sVfd6kiMrc8UKzS1zcK8D27DcWU/J6Aixbj97ejlJSNGK1H+DXjohVG8IUom9cs+RnIksipKdcWNSY7slw4U0zKZm7j++m1HGXAs5Jbs6fujasFpIsJB4tXsLJKVfFPbl6UxVqv+rjjbylWMXIKMXPte/mT5cJyp8ww6bhNs204psUzIRW705hV2cmXd3hNYXMEhc60GS3ozrnYX8pNPPUXnem30EVA6o9GXi10L+eNxW6taFblLYWk4zP6nhu3LGce3ZodqnHVyxAeP1jlNwjUbzVw6tL5mAqJmklbZxeFLpAvkOzc9Zqv4jFpOwGLsv/vE9ZfCCmWvex++uCsifMoDEiHHZfJPG9lM3RGw6AQ7KQJXeTsHPkBPxCwZUDrlwJzZqFK9sAAab9cCPvHhkcpbCNH0eNjBCwyT66ii0k1XhHVW3KJvnIVjs5xeHjFMdGILbBQC/IjI/hYQDcpRnYPF705pbohsaCaUwpqWOGbd+wjQzNbvLptBeIFv4/LWEH1Vf6a0CW7FqIvb4Hua0HbffevjZmbgbejN7kbBMKHrTw86xzOC/XX3SrCo3Lk5v72pcr3ZxXsp4nPj156F9AgG6F7Ge3hGRhkqZPREu1UT/Jxo4rggs1q7VurvroRgAs2+vQGhqH3pc4YVjAla8hC4lmvSdiKp4EZMr9LFxSthsxczLm2vgmuAMQqgVh613ENzQhspIgBiOjq8hC0vGNnJy3I2D7BWd9CsBTm+eQ9PSAfttsSFkZuAekQcULzaHSXezou3+rPV5urbyQjg9zYz6HKUF3oYTqVFB79CD2mAM1U2qXF6IYGXJaGsJhx0x0sG+RnfTtGkq3HvPCJFZccOanPGsuZkzLGPSde/GUZR7SAv0D8GY4UBUJqbsnoG5Dcjggc+j3Oebrp5jYJrTz7sRXAdBzvVw7+2NuS98V5cihwZUmsfvL/yTWeSAWLLDJrDv1Xi545BoMixxkqHYXWjAXt3NRWSBjVbvPwa7OTGqbU2O6jihwUXO6ysQtY9Ard/cV80s2G8a0CmTiGz9aWhMxe5QgtihtvJPu8XGdyn9cuwVhChSXgba3mrLf7kc/O7Dw22fKrGguoegNgdoZmMZX+oq/ELFucSZrEouYlRYstNjuc5DzNxvtYy1kf2dnb71EMGZbLWw+5X7OePo6RIySzh+c9mfK1JExPEcKug0Q4E3XkTM8NI/tT3I4urA8igM4+iyEQLG9jeKbP+XjOxZh6dQCDA1T8b9GZhg6tniQqXRxZXINEIdnZgQmf/f4PKwOm38yiIBbH3uSUxw+Nnj9ERfwh7RNyfSPJqMcDT32136BpseXL2TcNXsD9gnTDFgIeX6VxxOc4e+jTeKrD/8Vtfd3/fG+M6m9YyzMGHpfTAHesa4Awby+vlit5D60j0eLl4Q40o9iJZF3n/QXWk///XXk3deCqY2e+MZAB4ir0MfOMx9CN+E/HVNp1cJT+WaqXdyY6n8uZCFRecK/uHX8LDaFD6yFhOjVD5BKi3CVpiL54ntY5tywNi72NjGmBHfOyEzCTsOLQ7JwwZJrcGweWspK2ziZ1F1gbY1wjyNR8koyHV8aR0d5/9jQOl4hbYeImwY1HAaSW5x35mc8O2YWY7+l4pP7twuTQyrr7UuxIc0ah7Rkbd82c1I5NScnRzhqeDjw7sw4bkeAGOPuUx4ZtWuOJgzTRN64GzG5DN2uYArRN4+NuXob5QnNg9oLltaXRoxghIKS5KPy/yVRcX1qfwR6fBlzH14Xd58LX1AwFEHjudHbmgCmCErPObDdNKH0ZQPZa2CtaiXc29PsSUT6bWZExqn8Tz001ZTgubEeqzRQA0vgMfzv6gM/+SvzrNENRUOVkDQ96vtlWIbuzZbwP88j7ZgA8I1zIYQZz+rlKL6AOGpkRMCCn6/gvX8uJH2L3+NvSjDpNxuxy14WDJPHdWVLCc/sn8VfVZ0tix6L+TjjuBkjkjbhLUxFSZ2KuXJj1LbTLDYmZ/rb/bZlEhcfu4wXKqejrD40+eXG+q1YiwpxV4SuXZHdBudcdWPfZ2EybO1AxQUVV25EH2wYCMEftn/MZNVCrCVOK374F2YffwUF5w4tOhAVAr58/oq+SVDG4JfNUwGiCkE2+5L62n4n7XMKlSEs3IXg7u0fUaIIJCQe7hjHqzcOI4p0EGFr9nHGVdfx0MN/GdXraIkq4rgZSB+vDbl//7XziWALDhuK2+S5bcFF6jv+MRExYEUiVdkoeu+Lo/prSrD0+ruxCQUFmf+FssU02cHzW9/na+d/G/mjtXhOn8PcX/sJHawhBCNeqJyOPoyUpO33llLxl8KY5pZwmP9/K9nYnk9jQ1bUtonLHSguk44TA5mMlEoH+Uv8c7cwTCzr9qCFSL+NF8lVXlb+bA7zf7MStXcd8FrVZDLvT0DEaJE7JAvvPHQfC399E2nbw79fzhyV9+/6K44wKcbRUKYmsuaGvzD9kZtQeg59dPJIh4GIyDw6Gtc70nHUyIgAq6RRcsEuunx+r6wAUtXhq/i+Xz+O9m4HpikwjMCH6NI9J9Ly/UIg9ABtCjEiqQz+88TeXhb+yfaatNUYwLr2Qqo5OEbGCTO2suSJGX1qsLFgsOdcABmbNdrGKxhxPvWOBpPMt3YFGRjy2DJOfGkDE1W17/eJBVahosojX/jXPs7BhDP96UWD85/jUZk/0PaZzmksTtjON9KX8Z3XvhH1ONenmRQ/38CJL65nnGpBFf6FyjeTt6D+Tef5m04ZFY+aNGMSvqSRU16TfCZnPP0DrN3De8+6imRqT9O5Y/FLGEj865avIrv9P4ApREjDV1itNF8+C80RWhOis0TGsV/gaBg6j3TbeAtt03WUEBeQBkVotQIPu8/3vzAlr5oh1YlHG6YiYME0xKotoxb9M+Z2cs+Mp5GFQYoUnwc/EsTWXYy9s5TK223sO9UkY5WFlN0H32hzSL0R2N7IWSjj4gDMYS6iJMkcNtvXyuYSGjtim1+EAUk1GtaXAqOOskdDGP6ot2X1TvTu/sio4fGw4cpJaHd3MT9jL2/WTER5JoNEYrs3Qh8UNTFFXAKI4J8HfnXro7RoifyzejHy7zL69tVe4+X2aW+SIHn7790QYRUjW5NhqOAq96IcLew+ihhw1MiIgikpdSN6vmXNZbR3O/pEAA1DcHP9HF79eA5KjyBlF6StWDasa/jzwsMPTI79Wt9iJ14cyNf/buEn/P4EO10fRWfCAlBcgoXrz+PdqY/HzZpSYGtnRtE+uuLu7aA+OHUS6iRcWRJajOuI5L0GqZvaQtM0Wi29+dnxe/2urljCH/94FmN+sDx64xjQdsVCWr/s5pSkkav1aNUSWOcuIVXuiaoGDPDOsRPYlp/FG4N+kzTZwTeTK3leOhWi5CBLPgNLTQs+I/bfVHeoMReTxwp7o4jbGB0M3QKJGc6++qB7r+1AeTaDxH29CxkB8rgxGHtqMH1e5JxsnHNKcKeHX6HpVnCnS4A6JEOjZbKVrjIDJTm2xZSsGpDqb9s410HGFj1yCtgowBQCzaGixmHIxwt3QwK/3fMVpqfX8mp7//YKeyPXpwbn38cKw+1GbNtJzouzqTtVR7ce+inXsaOZlx8/lq9eFpje6TEUVrUUYxrDd2LVnpREnmUGcmUdrz56LKd8c1lEw2YweryWIKHccLC2GdirO5Byg40SyWdgqW5G6wxm2XLnOKjaloQ6ScflsZBXOzTj79ntM7GsTgTiZxw8w+EG3IwZ+wLX3nRZ3/ZfTnqDCxODa/8OCwi/rkU8uGjSapLkQBbIf25Z2MdWdqTAPMhifObRSMZRxItOty0gemEaEq9vn8KEP+9Dq9kX/kAhkNPTIuqT6nYJ3SJhyuDMCf9wyl4ZxdVLRRjvF+jFOQndFE14kvNrryNhpyVqXqnkha6PcrinYAZXpK4KSsOp17pxm9CoR1/9y+PG4CxPpycnsPfWzugKt45GH4ZiQfL1Mm6FiEILExLq/EaYtV3DcFgQc6cGtNESVfZPHjrF5DWptZSe8yh//sHwxcP0E2fRc1YnF48Zvg7KYFR7MqgmI3pD4JSCbaSXxF5HYUrQNiEwAqE4TdKXVPPexjkcM2knpY7g4slP949B3TFy3uaDhdWzn6Gs4TuYn1lIqvZiCoGnMBVLbQOmzwupyTRPie519CWAoUgoLiXoeTcVQePsQAeD5IPsNR66Cyx0jteR04dGv6xNcNLhcpBigrXt4Boaow1HjUxDUwH7xqcFbM9JL2aytTZIBC0emJpG4rOfk1S0CAS4M1VszYdO0VTfuYeih1p4crqfLnxmSQ0TkhrxGAr7mtKiHB0bPNOcVCfYycotI6Ehvt/uma2zMGsc6FYTOSs6Pbm1w4C6RtQQdRCSV0OrCjQShdWKVFpE83QLjmrYlpCHZNFpG2+JmLoUCvXuFKQtiWSvGh6l+TE2iQ3znozYZp3Hg0PSGKfGn0epjXHDLttBT5kSkkF5dgu3ZnxOmhyopLkst5zK5ky8HhVdk6BxeJTNR3F44qiRcZBxauFW3qieRLfTimnEbsVLdju+KSVh6zFMCbpzFdyZ0QeRriL/dW0tEpmfWYes+TDbamHb6Q8w/ZGbELpA8kG0UpWnHj8J6zd83JQWqLj6QvfEsEJNLl2l2ZWIlWakhAT2XJyDNsEJBE7Ulo0Ostb5J7RIaR2JvR4r3SrRMjlwYhKmf1GW/soWTNOk4ZtT6V6kIYSJovq/nKZJLCjZyXsln0T+slGgCg05Kwu9qWloJxACOTWVnDt3ssA+/FzjkYLH9AWE6H2mTtWAVALDImEoAs0hcca3A72p69oLMV5MY+Jtu/js7rGok3QUYZBj9XsiGz3JdL6YR/EDfjpgKSkJbQSpXUcbe874O9OyLsH+jyQUZ//LIqxWTLuFcFltg9PMdCu0V8hkrtcRpj99w5QFziyFzTcGClSu8Pj44XXX0fQljz8yMQy4ZzrR7A7yPz2ERoZuIvn8aRujjcbWZK5be2lcdXM+M3gQlLOyKPxvJVXfrqCrDIrelZC8By/1bJevG6EZfb4gvbOTsV/31wOt/dMCkhZ56NFGTh1cUXXOPnMZv79qHQC/b6nAaVhiStusuK0Zo7mFzrOms/9rkdtqHhmhm37Gv7XBnv+gOyHJSEX5VJ/TL/Tn2GrFWaAz9rIdtPxfadT+IfxjmMdQ+LyuBMtBCjj8rOocChzt3J3/YdzZADtPfJQy97exbLEMO0IbK4RkkOjw8NaE1wFH0P6XKt7mHE5lS10uotVC4dtdVB2crh3FQcRRI+MQ4CvFW/i8pZS9jbF5iAEMpxPp47WYJ8wKaWi0TLb6KeXigDtDUHvjbPLvXhae5SYKrEJl27f9lJ/HbDg3JrrPN+qn0KEFDzrh8MLKOYy7xs+/vu2eSSgJoetivFOd1E4FQxeU/kuKGl2RPQbZawINLLXLCxt2sOOfk3rZSvzXUi0amxc+DsDFe06Kue+RcLJd54R1b3PWjFOHZGgoBfnMfK16RPoyUmjVErizeQY/y9zQV5PxSEcxz95wWl9R5N5zBJctCJ0SOCN1H3zo/7/7h2Ooe6cLMXMyOY/6ozQ115WStdp/rJSQQOVDY8h/xoLaeRgqaYfBhnlPcm9FCS/d+KW+bfuvnEXXcS4OPG8DofskHFuCX25TQNMM/8Iwqcags1Ri8w33B7XLlz3UfsP3P8MCY67dTGF1OtXfnnCouxISdzZPRenu94jLqSm8vO6t3vfhXZ7pTuFHaRdQHrvdMiy06U6uH3sSpm9TyP1jb1lOHf7xhLtG5pp/mfkUpzj6nUA/yqjkvvaiiIrfB7DnyhIkbwmejOhz0qT/tz8oUhEJ+vHTqZ0X/C45amW2VY0nK4aUJ1eWStPZbuq2T/EfG/PVh48Pdo7nyy35LJv+fNzHZn+kklrZTe3xB4cKd1xuE6+NezNim5cq3mZKy2XkvOILy/p1OMEwD3Lh9/+A4vdRI+MQYUbaPjJsPayuKh7eiQQ0T7MO2atnyrD/uoXkPVM5dI96L16c/F+aJkT2VN3XdCIJMYoyDYSclsbWOyuQE6KHsyXZZPclgsLX5bjoPq21HRi7gxft5TnN/KviKcA/OD9Q/FrvnuFPL/EUjB8p0E2Je9rG9X1+r7E/Jaz5JidnFESmTj6AzP/bw9Zpiyj4yyrWnlPm31hbSeelC2g41i/6pOCl5iwDeqOCwi1R9uLhP11dlVJJxcMN/OGar7Pz/6ah53jDGgGSauCc5Ma+zRa2cF79ZiPPjX+cg7Hk8Yx1szfVQulrhy7l53BH0t317HlsIcl7ffzkvn/3GdwAX01oZsGX7qHmBP+9+u7fbyD3cw/JNT7m/+ha3vntn0a0+FzHBPPQi6NdmbwLA4MqzeTJ9nkB+8bZ6jk30Z8ufNlVn/OV927CscuC5rFjjHEFncs0BZatdmq/6iDv40SM9dFrxqLBlKF5upX0Ld64KLe7ZrpxZ1kpfP/gFPS3dCQwa9VFfD77iYDnaiDecaqsdweuLaydOmL1Noq32UFI1Fw1kQgC7AcN7855iN/8/mQ23jr2UHflKEYBR42MQwSrpFFga8ddoLK5dmhCd7pNortAQR9mlNuXCO0njyF1TTL6jn6hqdt/+21eu3YVf81fGdN5suUEsqMMWoXWNpxGfB3OKW6l+uqJKCmxM3spDg1Tin0EtVa3YjY2I+dkUX1xCQj/tRaW7eab2Z+RN6CGZHBu6VEEY2CkKsXqYv1J/ntuMV2sbSkAQBYmx+XsDHuOcYn7qTk5lRrLHArv9KdHtV2xkJbpZoBIl2IfwFdvE+w7yUb+El/c2hwDkVSt05MrE0fALQiO45r4QcU7ofdJFhba2gHQknUUS/hIjMBfgO0s1rDVKwy20cu/spsfFL3FREtwZz9zG/y59pwhfoPQkBUDzXFoF61GZzeF73RQe3LKYbFQAug23LzhzMFAMCGpEe+lChZJC/Dogz/6W6yoFPfOvl+7aAnrTi0E/CaiQ4xc2lI8MFpaKfx3PlWXGcjK0O/vrTPeZYa1HQisHTjAklSmeLkwNXBOSZU0EntpWida4CfHvME9qSehrE7GVx1scAn8aa2aHZpnpZKWMB2xdP2Q+wz+yKBugc4SlcR6HaUn8J3cP9uKN8Vk8PQlqwa69eAxLZmGRHePjW/u/RK/KXy1T6RPNw1e6kkFoMqbGZQtUHeRF+OkWVhbJYrvWErhu20hdbfqj00d1rgXL/KURKYl1rCRw9/IOKr4HT+OGhmDkK70kKN2sNWVP+rXsss+xic3srk2j475BaRA5OLvQTBUEZGJJh50lkgkViciBggsZzyyjE+/Oh5iNDIiQTcNtvk8Q2JmKE1pZfW0+EO8XcUywgRLe3TPtjBMzPJCWqak4J7l7OvlrORqTraPTirOfr2H09Z+i1xP/aic/1Cj2pWGU7PQ7bNilPu9kW6XBbfLP0sLyWCbw89Olm/vIFkJLvI8OW8Hby6UQQi0k2bRPNdATgsfCZNkE6PchblUhWEYGc0zJGSXfyEzVJxRuHlEGWKUFC9et4SlXWIgUcsNBe9zXJhUyV3ebNbXFI5YHw4XmD4vrN1MWsk8OouVmNni4oWi6uSkROa1q9a66TJk2g0rG5x+7/E4Wz2Xpy2PqUj319kbIXsgZfnIWU1tupMnOydhxqAsbbjdWN5ehXnx7GGtDC5J3kmKFP57OyQL06LYUd9NqePTgmrWrJyCpS3ynOHKFqhO+4gRqnvSBIZFQRrEbtU9RouZlW20YZqClVUltOZbKMMvILrDZ7LBVRS27uXiSasB2NSRz/5tC0h6diUYOuYxM2ia7kDSTDIfXoa0YCGRhKWE7ldQl1O9/wPcR0cx2vjCGxmyMEgcMGMnym6SpODw7Gij8VwPhlJI6ltd/iK2MJA8OoZVxlAEhjL6r3h7ewKbvS4mW4Y3i7tMb1CIPBZ4DAW3NrRcMOdcJ0JzkBGDkeEuzaB5mpXOad6Al6JNS6BZ7+mj7u07t+Gl2/SRLQ9dMW2NJ52ss7dHZAw7UtGtW1nfWIDTGV6/wjSkvgWwt0BhfFJjSJpLi6KjlJWw80oDWYot1c6XICFpZtzc9Qfw6tf/yDkrr0bflIw8hOHAl2ySokSOvMkIevIsCJ+BrkkxeY+lHDdeYcNe719IeFNMbMOxhI5w2F9agX7hApzZkT1+viivqeQDBAhL4POXkuDi5JztdBvhWY7e7RnLHk+/aFyK4uS0hKphjQ0jgW7DzRJ3JvesOYkJOfWYRu/z5fX1K3KHgNShYmQYSPKRo4NgyiAnJ6OHoKodCtonawHRUoi8WDJl0BJklB6dla5yKpTtIxrxrte68enBxmeDnky30U6rofFcx8KYzjUlpQ7fjxvZsHUCwu1j67cU9px+P816D5cvuQJPmsBU/IyQoSB0SKhScDp0JIse1tDw6TL7tG4A8mRH2NTgNt1JtSdjxGnIRwNHazLixxfeyFCF3qt14MfMlReTf1MPM1/ee9D70nS2m46yyRT+dmnYNmLZepQ5U2ibmERP/ug/gBWXr+GyG29l3U+CC0oPBpbtL6OxNfmgXCtzgwdHo0rzWf0LjSc2z2V1fnFQAduTXcXcV3k8a+Y8fVD6dqThzZ2T4uJA31qbS0u6gxNzK4P2nZy3A+N5QeW2mTELhe3/mofUd+0kVw3d87hl0WNcWXgsK1+cGr3xILz19bv60hjCIVGy8fnvH2DOL67FmWvDNzE+oU9Tho3f/OuIi20daUh8ZjmRfmnJZqPme7MiniNjiw9ro5M5FwfTQLsNld81z42pL7IwuCWtElkcWgMD4O6WWTy2eR6SbLLj7n5CDnWrg6JfhZ9jxt68nKpfLkQfe/CdbUNFV5GE64op5Pw1/PcaTUg5bmrOkyn7D7xwwym8+4tJvFTx9oid/0srr8brCX7Pb15xMd+cspzLU1fFdT6b5OO1N58IWPhnygm88f6zAExfcQn6ssh0xo6tVnrG+lASQjs5djdmcmLjDQB8svhvASnHA3Hl7q+x840x6FPd8F5cX+MojgB8IY2MH2auJznJ/3J1GV4mL/tu3+JFWpWMVr2dNSdnkfO6j4LevOnRgmZIWDY5cI3zIFt03JNdVP51PhU3fR72GHPNVhJTZtCTP3IqxwANCxNIKlxA4jOBAnG5D6/mlNXf5J3n/h33OV/pcbDBNczi9mEg65wa9izIpOSRoXtJdjRkMavzoj6D4srqY1lWXYrDNvQF7IJ155N+eRsQrAMxFLxXN562rmDP2ZjsZmalDV1M7EhG60luWgwBHSplL8VWDO7OUHjy7rsp7p0QHyz6gI4b3sJrmpzy0A+JpiemJZh8cuUfyZZHj8FFZLtxZQqEZCJxiLx/FoP9swLHH7XHjFtnIBZIPgN52cYhq30bbjdFf1kDQOdZ0+ko7/cIFz+0GdPt8Z976vgR6e/hgDN3nE5lY1bIfZ7xLir/Np+KG8LPMWW/W0/redNpPT12Q0PrtDDhtq00bjJIOUyd0sqSDRTvK6b63OgsiKGgN9mwN/R/Oec4D4rVH4uWLTp7vunfl/zcGMrHX83ucx8aVn/rtW5OXnFNRGHC5a1lw7pGKHw251FOs11K8tc7qL4q/Hvh2K2StQHsn2xDWC3s+EtxLytjIE5ecQ0Axxbv4qHC4YkNH8WRhS+kkWEVKlYhsdrj5ad7LgzwEGilGnW3LiT/j0thxLI8Q6PVl8BntWUB2hKSZGKkean+xSJK/7SR1nOm0FkusHRA7j29XhpDR8SQYxsvDAX0EE5R0+NBXr+TRd/3DxSn3v4Jv8jaEvV8z3cns9OTg/tgENqHQYLiRbVoQGzFlNZ2ndT37LR9ydUXBjYNiW6nla9s/woA+zpS0DUZp9vCmTtO5/mKV+L2Jnt8Cnpz7AaGlJSE9TUH0gB6Ic3UebPGz9zU47KGjBxUtabR2J2ILJmcUrAtaP/hhNauBD6kImQ0YyiQZBNkEz3VR9XpVorf9oZlZwLYP8vKV7++pM/AAP9YkS377+1Nl72Mz1S4b/NxKKv7x4YTzl/NeEcDAA7JM6Q0mfStOh1uB+6Z/dGMcyeu48Skftacm9dciK7JCEBIJkI6hMXXwgwquPYlCNrG979nCY1GTPVQkaB2eZF216IP0cA4AMPtT3dK/bSKlPX990fv6Oyj7z7yExP8GPP+lUj1NiQvIU3QA9uqf7GIsr9sDpmeazidZH5QhbWrkPoLoxuO8k47Y17sxOiKXL9yqGFqGmZNHcWvyNSclUW4wKitQcHjlfrEAMVeO8IA1SMCxhBrTb+2jSmBXOo3yjomauSXNw+rrx+5JH6z9xJ83sjLNM2QRnyOTZRs/Gn803z/sYsovqkxcuPWdvSuLoQ7/Bx74Dssryvlcl3lPyWfMOaDKzG8MnKrwpEiw2ccZMXvg3mt0cIX0sgA+MQNjzcfz66GQG+Pkuyle5JBz/nzWf6mTMnxVcxJHx0tAkXoJNo8DB7iJdlEG++k7ezJtMwwEXku3N0qSefPByD5490HPY/f6Okh6Wl/hOOZ8hP419hFAfvPmr6edS2F1OzLQKgGTyz+O9vdeXEzSQ1GfmIHHk2hvTNyfqvWYUH4+l9IOXNoAoOyxyBpn4/BGcumIVFZnx2wTddkttflcHf6FC5PXR2kYh4OZ1eehvleekxt3WfOY/8cBd1qsqPigb7tu3zd/Kd9PltrI6dxeD0qXo+KECbrEgqZmNwQsu5hpOAxFLZ25mIa8Q+Omk+mrXvkaU1kxcAscNE8zUHaDi1ABO8A1DY3pmz1F+GGwTWptQDok5fwREL/7/7DnPcDDJNY4TN1Fqy5BGunibVVw5Yk4ZUNTh3jNywuSf2cGdb+aMFZYzfhGaCkJQkT6TCahEwZvMn9/RG6hGZTEQbY9w+tbkR4NfSW1pHqIlp9A4TgWRBzp1J1ehJzhnFuh+RllmPvqNFST152Gc52f22cZNG5fubHAfudhoUNnQXYttqjiqKaErjydNq+MpH0z2pDak1otXUkCUHzlJK+be5cv2K8YQis2/rr9BJrTOSm9iND68Dthm07ySxJpXWCih4iIcBT7kax6GhNNjAFjk4RUndpoIK2KYGr2YqU4WXypBouzF3JHl83J71/M+tOuTcuWuK3nFaeaJofk5bWji2FbJcLuGzhyEYI5llV/jr+KW7fMY/aHy1CH9h9E0ruXOUnYIgDTqeVFTUlXGychHWrPWpk+CiOfHwhjYy/tZXycc80djdmhtyv2DQaz9UYe/UudiZMwbHAy6Tkhqjn7datuEKEAuyyj8QQ2hDJipsFWXt5W+RiumUMxUCS+keyljPcfUsIJdFH47n+/6tdJWiOQ8fbGKpm5IMfLyJzg49xb6xETk3htY9mkKl2kSQHFkw2a4kxqb4ewLjE/UjCZHVn5JQrtUNG7RQI3T/YOxP9j3ZDTxLu7tgNHVMRuNMViGO6fHTTQjJndnGMfRc2oTMmRC6+z9S5t60CgP1/LyXnsdhyh6vPhD1nB9bD7NO6eaFrOk9sji1PHPxsJNvrcihNaB11I2N7Xc6In1cSJllpXTR3JMZV63EAAnDNcZJYZwsyMjpLLTgcsdPV3py2l5vT9g7YMrTUKKfpJeUvSQjDvwA3VCjMaB9AGR24+rkrd22IsxymeSn4WXo8aQJJA7VbDmnchYPs0hCmiXAfnKL2tgmJ5CyuG9Y5kmQ3pzmG5tyIBN00uLe9nJKfedG3bgb8Rc73/+IUyPUghIlhCIxulYQ9SkxmpzD8AnQNJ/iQPfkkqwpC09H2BjrUjI5O8pb2f6emmVa6JAvCJwVsB/CVZCH21Q77+wJs8Lqp7orNETMkmCaWt1aSkLqAjjIJX4p/3tVt/n9vnfsum3sK+GRd5FqegTjwm/bYFL6Ws5bLk5t5pSebcd9axS9WH0uxtZU5jt1hmeAANnv9kZAHa0+Nmdo+Z6kgoc4HsdV9xwWb0DEXTeeJa//ENEt/x3XT4MuffQfFqaHWtQU9N5HgdalsemXCYTxyhcfRwu/48YU0Mt6fn0T71UVwQvR80/IfLmPPDYuY9O3IRoZhClY2FbM/RJFyXkZHRD0AgIQ9Cs4iAenRJ6l939QwGhXs0e2euCBMIqaTRELB7wIXzbIwuDJla5D35vctFTgNS1yGBoAQZsSiX7PYhbvRhr1RQpiQsN1vWHRvzyatwwThjaoADuDKUGg+yx23f/iutadwF5Cd3slHU5/FZwYuqHb4TN6e4n82Ulge4gzBEIrivymDcHvtV1i2pzzOHvpxpIZfVaHzydTnOG7j+SHfsVhgmn5vpBikbv+b2/8RpGVwKODKEaye9MqInlMW/rQq0xjhKT2Oyc9QoGWyQvZaA8lnYIbg5h8IYZrI6ysxnM7oEdtIWjim0ZcKFQ2p/12G2DQZHo2p+UFFi+HizakZYPSnEeqdnYy5dTk7Hp6LnOjDbLeQUBO/4ylhl0rtyRqN56Wgt1mpuLEWjPC/etZaD1lrgQh3pstQ0U1jWBGdcz6+LqTK/Ugj6anltPxmIV89ZTkO2csdWX4jTjcNruseGvVzwi6VLbPz0ZP7jdatszW2kszDv7yWzVfdF/K4TsPNOUuvi+tapimGNGdLsUyGwGSLvbcWM/BeyELig/88AkD5i1cz7nvDM9CP4n8XX0gjYzTwyp6peD2hf86G1mRedk7lq2XhUzEOB+R95hy2oBEAisLPMjegiuDw8A/St/Pfrlx2umP3do9NaCK7oos3d0yO2E7kuHHngGkI7Bv7r+1NETRNt5K1buS9jINRV5fOzI9upOje9aAPnojD02CGwtQVOq/mPMhI8ua/t3M8UwrqYorMHS7IUTu5LnXPsBYtpiko+q+CfflWfx7+ALTqiRCUIPe/gcuSWli08H5O+eyGETun3mIloTb+Z9K6bDuUF+LNCB8yEoaJ/PFajBiNgx0Pz0Syhl7w5r9gwfFi+OLm/xVIVXZsHUN3HiRUK3i6ZOQiFzv/PY1xV2/HcMbHdDYQP5t4HCnvO3iq7IMhn+NgouwXK9n4SwtyXhEs9RsZE5dcgbo+ccgumbeeW8Bbcyby22kvBmxP32wy6dMrhtfhAaj4vQtj4zr042fGfEym2sWNqbtHLK1v6zl/49Z5i9m56MihPD6Kg4cvrJGR8/IuEvaXhixq07pVJv65Hb27O+p5fKbMm1UT8XqUsJ520xQxU2/GCjPDi9Oi4qgeuQVo9al29K8u6Ptc8fvtcedD+740m+P/9CmqCN0vWUh8NWEvK5U2PumeEFu/XGmsbYjuVRJB/+mHqUDLZCvp271htROsDV2onRaah/ha6G1WbI0yQgfD5Y7oEYwFibIn6Hc8p/JUdraETvOLBaYpRlVFNFH2cMKYSj7eMyZu73lqspNZ2cG54ZLo94r+Y8JjnPXsreR/qlN/Uf+7a1vnIKnawGcXtH85dIRSGCbaxFLU6ia02jqkpCRmL2nn9IQ6YJTU3MLgqa40fv/X60g3/Ibv7m/AA8c+MirXKlTsPLXwYb6+6qqILDVxYQjriaaLppDQoEdOmxLA3ClIGyox3G6kGZPYeWlK2OaywxV2IbjvFBNl4UIkD5T+fPQZbXa5s1i8YTYAf5/wWEgF9nhxV+sY3rn+OCQjVKpcL0yGdD8GHm/pEGiaHcpcVN4xnXGPtqBv2RH92BAw3G46ri+n4tJrufnM1/q2X5oUm3ZE2evfwbbv4JGFmJoGmga+/jRSw5CGHNUHf0aAFiKtM3VTG57UdDqPHxl6YKH5o3Xq6ko+v3EOc/+6GilE9HswRrJuyCpUfprzPn9cfhzS5U62XZuKHCYjQ+u0YKs/cpedR9Ol4seRe7eHCb1xP0krFTxJJQE0fWatncKlBvrW2BluXBEExw5A0ySWNZcxP2Nv3yBQ607l4x0VOExwZxmYjjhylhUDzaozkl5ub6oRUDBdf9EEFLdJcpUX5f3VUY/vvHQBnovbuD1ze8R2abKDqZY2jMQdfNo9Lnq/DKVPJTomCBNXnoFtv9RXAGkK0BzQVeAvRLX0GNgbvVj29RtRZnsnkiyR8XoFzWfElzKlt1pR2yRClN6MKKo7UvG4D19dBEmY5Fg7EaHrJCPComhkWQIN+zJrE7NtVRyoT5hocSB7IWlFNb6EUrrzeykjq3RsLRpWi4R7jQPndBeSbKI32Uio8afQCd2DbleQctNQhEBvauaZNxdz4SUroyoQA7zvkvvS/FJlJ/OsQ7sPtzdO4+kPF1G6tdfAuFTwg/lvj0o+P4AqZGZb5ZDUkvFCb7OidgxtgeLOENjaBZE0Ck0h0BItWCQJ49iZ1C6yQ2H4AyK9o0qKF1LAp0m0fmshmU9vwOjpGVLfI2FLZy4dXjseTenT9Plt/WnkWLsotTVzferQKaRrPWnIy7ew4775mCHun9QtIbuHvxAROsgugQGIAheGfehjTN0PF6FbwCxwUe9N7dv+sTsbh/CQIfcw2xr8wjXrPZy75evY96pxFwRb20wyNg49+gJgtHcw7j/Xkjq1GeqGn6olbUjiJ+uuoBB/KrFSkI9uU0jap+Fd68A10znkSIkJZL5ug/3+Z8vo6kJevpnX/70YBJjHt3F26aaAY55YP5eMjG4enPwYsbItxoo8JZE7cz9nwo1zyFgp0TnGjlkaaEhp7RYsbTJyfAH9ozjC8YU1MsDPnpH+bCvt4/pDjWnbzKAQu6NR5+U9w0t3MgxBm9MOA8gi6p3JODb7BzMj04diidPzrQvUbvCNACW/J8NEpHmx2b19C/ruxf5Bu3u7g5L2/lQlqbImpLJqw3EGe2IUp8tTElFFK59GDxbFDYFfS8BscfQZGcIAR0P/JC17TJQ2F9qeqsBjrVbSVzXTeFyaXwHYpkdVYtZ6VGzN8pCUoQ8X5KidOMKoabtNNWCxEAndupVPasfga3BAqhdZjc0dqHVaqHOm8745jpPz/B7UPEs7U201AQxLfe3rG0h+qgnHCTMCtkteg+w1HqqzbBgWk6S9EpkbBxWoptiAVMx9tZT9ZBlbzs1jmiV0ulS34abV0NBN+LR7Hr5e3tYctZNceXPcrFKPdOTy1JKFlL3mAwH7Z1t59MQHOcE++nS0Y7Oa8WgKzU4HnSE0VaJB61GxNssRjYSo57AJFJuE7A7zfQV051tImVFB3WI73qnDWziC3yHT/iUXWa8nQAQjQ+px88y2mZw/fl1M3uADqOpIC/o9D9RMZad3MtVWE1Ts6zS8/L4lcorLiYlbGWNrYsU5p1N5zv0hvc/jH7l2dB0buo7a4UZLtkaspZG8OpJHw3fSbBadvzbIWQCwqsev55BnaSdL3tr37rTpTio1lTc759L6QV7cBcGWDpPUXV7E8g3IaeEF5PSOzojRZaOnh7IfL6PxxkXYRoDkLmOLjuMF/1pCTk1BK8hAS7Qguwyy1nqoniFC1txFg+6TsOy1kfr0igBqZ9Pn7aO5bzAW8fT82QjJILHXeZH2mZXOIitLysYx27p3+F9wEKxCZc/ZDzN923U4GqDbaoM8N3q332C1tMio3Ue2Z/5oJCN+fKGNDPCHdkt/vgw5NQUODOK9A5Xe5l94JD77Ock7JkL8WnR9sFh0vlLcry3hM2V8hn/BMtTsFeGRSN/mYf9MK0hx1WIGwFBg9jHbGZvQRLUrjc+rSwMYfLTxTnZPUPoW2/kPVGBdu7tv/4HfaTRgmAJtBIpWJS+kPbMG09M/I4da5sjZWVSdk01C79dz5suYEehwTdMvSDSc0Ho4NHqT6TbcJEqjWwBpk3ycmriFcWpofYd6rZtH2udE5WL3GAqb2/NIuyeRNPzaFEaeO4AxLRR0TSJ9jUzqTh13RibtP9xHlqWLsxK3hlzEGzJIDgdCUcJygBW/HYVaUQh/0bChU+NLx2k04pACvXu6abDJq/JaZzCLV6MvmUfb5vHjzPUxa6Ts13v4y9/PpWSLD90mIXSTNd+7N2xq4UjjlYq3ALinrZQHNx+LrkW/rglgihF7zrsLJHSLIHlv6PtjyoKW0120IoDhGxgDIey2vnseCvqOXZR/w4JnuYJdjo0IwDdYLGQQ9rcmc/Xqb7D1mP/2bfOYPj5xJ/Hp9xdEOBIeu3Ien5/wN278cxUHk0VM98oI3YuJXy+DNVsQi2eAQkhDQxgmaqsT0eNizj/2Rj1/vTeV/7TP4UcZ/vqHd115/GX3ybQtyQWFuKIYkg+yV3Zirt6MZLPhmRmeEMO6fg96a1tEMgDJ4YhbMMWUQs/hxoBHwze9HEMObGT4JJBMJNmMOcpoGAK53krJL5ZGjBTn/sVvbAjVgr5oMppNBqGRXA3/rTmdb//fn0dtXln/w/uZ9MB1lD/nYtd1Egm7Dt/I+1GMPr7wRsYBXLNyJWc4Ar0vZ804Fb2paVSu9/zWGdjWOzAl8Ex1Dj3pyYTsNR6ap1rRhzBmmBKcdf5S1F6Xf7G9jZyKLl7aNj2gXYLDw9q5T/k/HONfgAF0mx4uGnNCwOJ9JPFJ49i+FIThQLdB7fdmU3jf+rhSJhx1EtQd3Hz9A9g1183UB29iz9kPj+p1bknfgEMKLyCXpyTyk4wt/LJ5akRWsOc3zKLsP/2fS970sn+2PUBgLhQKn1dQu/yLTluLxtYfT+HHj/4lrO7I2V/+nJeLp2H4JMqGaPj7kq1Ix05D+ngt701N5p/PXBWwEAR4qjuLra788OcwZe5snsHN6Suj5prrpsEF136fLKeHvVcanD9lLRsWJ2BgMJIpj7Hg5rS9nDRvG+ctvSZqW73DQsLe/41pYvud6RT/Mwv1veipn7Hi5cqpMRlrA3Hl3lNo/L/o7HClj0qctPY2Nvzg/qhtRwomMP76bYFjpGkiLVkLC6ahOYIXjNbtdWj1DSglRTFfx22o/Lp5GgC6KfkFOC/wpyi/8PyxSDHKLxT+Zzt6cwtyTjbeSZHr9jzTy7DtTUbbvTfkfjk1hR33l2HZHJ+hw5wOzh2zIWjzEx8fQ8WzoQ8RBr1jpaB+oQ3f5NgM6pRPbWQ9GHt9kenzIn28lr1/n4uScMBw9jHr0++y8dhH4haR/aLjaCQjfvxvzB5xwni1ACPBSo69i7Mz/QV1pzo6kAe9cN9dugyvKfPTly5lzE9Xs+ai8Ux8YneAl0sVOqeP28x7e8dHVeYMh6E8RupWB/nr+kfC9O0+ugoV3Bmxn82barLghM19Bgb460Q+3+cXX/rvgkfI6c0BUgUM1AM4ELpPEXa+s3ErOoIZ1s+A+NWODxaivq8LplE3ZwRyzwSYC6eG9JhJq7cNyyB7ZcYj3Fx1DutrhkavCFD/j3K8y/oXxTveXcWM6GVFEfHcK4spXKMzmNoyY5MPfWfkk6vdg2b0CC66sytPY2dTJkaTjcIPjaDrDQmmSfn3Wzk99eKAzTtvt3HRpMgLUt2U+EfHVOQIne7Q7bxaNYW2r5pgSiiyzmu7J+O8OwGFJcPv/xAwUVV555i/BWx7pnMm/37mywHb4s3gHA5cWSr1J+vDmpQk2eCNBfdz8cZvBQl4xjIymj4v2y4opfU+uS9tbyRR/s5V5L2hYjNji5Skb/Ux5xfX8vn/u2/URP5ihVi7HUuISIbmHRr9cziHxfwzNvLJssnYG0LvtzeZZL3sr/vTW9uQx5bhy02JSo0M4C1IQ0m0YWzYFrBdzJnC1m85UIhPXC4SvrxwPUtfnETeXSqmFL5v2Wt96FusGKpg/zmhCxYq/l8XoseF2dMT14gnp6Wx7VfjkBMC5xzTkFi4+usAfL18Jbek7w51+LAgrdnGhF/kUXXBoXHSHcXhgS+kkTEnvZq52fXMttYOEE4LtujPSfBHNurOeJO/2k6l4nsr+OzP80n9Vk2ACniy4mZKbj2VLVm0NyeiNAWfqyfZAr3Oq2e2zkJU2zEs4MrT4r4Jlo0OUnYbKD39w43kNXA06Vi6+gfmriKJwdH8pGqDhpM10rK7SLX4KLYHpjr5DBnDEPx45ltMs+g4pOiL7vMSD9RnjLyB0bwih8QG0VcfMlRIPsj/uCPiAl+3KfiG+RVkLyTUGejWMOxa48uQquvR2wfrvIdG+bM607dfh2aDzTfeT6GSiEMZ+kSY9YqNtOW1aHurkTPS2ftQPoWKxmDht3ihdgvUzuDpT/YYyJ74c2xOePo27vzqE1yY6P+ddNPguzXHsas5A59XQeiEvN5Qoe2rhX39n/f+ZiEVeVXhDxiAjggqfrXuVLa25tDVbR/gSfQrsaspHq6sPoHfF7xB3hAUw4cDVciUDRCN/Nn+qTyxbh6OkVtjxQ1T9ouODuschuCOuq/g9AzdQ6vt3ov64Dye+No8Lp2xYlj9GYiyt68ic4kFW3PsP7LsMUisPTiyyGoPZP9XDTtGmh5PnyktrFbqr50dsN+XADPZO+x+FNjaKZ1aR9uY4MWpb0kGWZ81BbIeqgqGJbZokqFKaMk21IkVAeQuhlVBSfXfF1ehhq1RGXaNXZalm7L0VvQqCU9FblgrV3YbyG4DU4LET/1jiaPZQO3uH9+M3VV+Fqw4IE8aR80ZmcjpoefOrm7/79uhj44RYHo8GE0tOItzsO+TRyWl+CgOf3whjQyAYqU1pDJzKNycthfjpHd520wm5bHlNF4wAQaJkY5L3M/WphzkNgVrW/BoInsU3qsbD4C2345igifN6BvYDkDrtJCwp/+29JRpKMledK+MY6sVb4pJ2g4da1vwgKN26ahd/QOTN9ESZGQ49vtIz+ni9KKtIb9rjrWTeUVVXJXSwEgzUBxAtdZNjyHRYUTO73p87TzKP/YiDJPuxcO7ptDBXL15eCeJAtkN1nYTe1P4hZI3MwGrJwvZMEMWzw+G8v5qCtak4Vw0lqe60pCEwac7xqLUWTFL4p8F0z7bh1bjX02LxAS2LHqMWIxDDZ3/LDsmbJQha//IcqSXvOll5cnlXJjojzQamCzZW95Hi2vYDDrKLaTsHp1V8cwT/DVKw0G9O4VdHZm0tIceZ0xTsGxPOY8lTefcpPUxj0ex4JUeB24z9EJ7gqUxQL33vvYintw4B8fWYYazYoTsMbG0uvCmj/zi5sBvWpG3n6aexKBoRqywv7yC7MQFPJ8wg59NeyNs2lxGcg+tXQkxUQNnfWQhqSb+51UYcNHuU7i/9GWy5dGLFEsesL65MiornJyRjmvuGJzzAhevqmXkjKGFmXuCtj21eQ65u3X07f3CtnJmBoYtvnnKsMh4c5KQe6dAefxYmsbbAf94qqR40dtlZFdoq8CwgCu//7uWJIVPv/XqMmZtLWJsDmYIK6OryII+4LWTeunVUza1BlAIxzu6ypPGsf+YjL5UVa3T0n8SyURJGl3xUWNqF+4z5+H4YNOI0uwfapgcXEHb/wXlkS+kkWGXvL0pQrE//A7Jg1JeCl4fqhLag9rdlEBCU+gQr+KE7o+zATArvJhZWlApn+ZWSN6q9BVtAdT8fBFmhgut00LJ41V0zi3013GkKUi6GdGbm7InvgnNJvmY5qju8x6PBpyGl3d7xrLHkxW1bcXfNeR1lXgXTERR9bg4/nVN6otNCR1UZ/TX1bBIxOLUkTz+iV+YBHi77C0Gjobog7enIAWLqsCm8EaGnJnRR0TgnVxE7WU+fr76qwDkv6Iie3XqSqL39QBMQO+0gDHAnaQbfOSSOMbmi1p87DR8TLy7GaEHu6OMugaYUD4qi0bwRzHq9UCDSkn10nqsRMruoQ34hkXCnaySWl7at83scaLvb0IpyEcRw6c63diSR1tH9EXhwxuORZ2uc3Pa3mFdz2fqNPf+Tj/ffAnOMNTaJ4yp5Jd5bwPgNOFP75yBvf7gpeJYOw3YthtpTqBOjqSNXH74XWXP80DTCbzdOXHI50h5fDm29rnk/rWdfXJ6yDZnF2zkrYZJNHYkhUyXlWQDh2149WqS16DtFyWsfDiDMxyB6TRakonsFnFTvgZdQwPFFXmMlNPSQFHwTCtm3+XDW6QapmBLZx7jkxsD0nUHw2MoVHb5582xf/ZhrgrUC9EqCtHtw1vG1J+cHRQpP1DMPdj7bijgzjS4bGH0uoh2n4PajhTyqQ25X0uQaVqg+6mWB8HRnEZSXYpfb2kwDBPTF3lurz8pk455btD877WjSun7LoYF3BX9v3k0Qo+h4PX5D3Cu5TvYXnNS8PultFy1EG+qwPhCrji/2PhC3vJvpq5njDUprmOuSa3lmk9ruaNpUlRGkaGi+AUJ22tLA7a5in1cVrEOKoDXAPrTtN6vH4d6V+qIXf9LiZtZYBtdr8M9rVNxGrF5nubdv4Z3/rwYS7fBV8rX8sr2aTEdZ5qijxoYIGmfQdJTy6Me1zzVwnnnRM+Rf3zZQhL2KijdkH1///1SSotxl0c3nqJCktn+52Ik+cCkHzjTNZ4X/6LF8MqMu3Yl2oA6EW1fLb8dM41f7VnJvDDpXQeQJjt44+MXQu5b9P1rIkZvhovNPi/nLR05xWqA5qkqG78fWFB7zIZzSb1SYuZr1WGOOrzxocvG9Suuitruo10VHLerAhOwbXBgPwTuMsPtRvp0XcC25CkT2H/O6DKpxQvr6yu5+/MTeGPD+2Hb/Cijkj+1lvPAhuOC9hVntvHuxFdHrX+7LnyQsR9eiW3D8Az8lN16VHX0HT8bj8hzMxJ1UE3eJFwn7Gfde4XMzQiflrh0fxmJpx2oF2gc9nVjRpELV4IVR03guOid5OLSyatiOsUbS2dS8b3Q844pQe3FPpQwrFIN53tonDOJoveCjQnF6YPlwYXmA5G0T8OXEPpdkrwEzI/rCwsgZ13E88WLs/7xQ4p+1T83ZjyyjJ7z59M+5siOahwt/I4fR4yR8dvf/pYXXniBbdu2YbfbWbRoEb///e8ZP378oe4aAE+/tRhHx9AfiIpfOzEqtyCNH0v117KZdpY/lnuuLXzh6XG5u2i+059iseWvU2LyoqfdUcWcxOYh9/NgY+b16zBMCbvs4+zxG3h91+SIbC6aS8Gxq9+IceYbOCd5qf/SHAAm3rYrkHJXCOQP8ki1uBhjWRNTn746bw3v5YyH9/qViKXpE/GkDd+Tr5SVsOWnWSjyyKQepL5rJ+vFLWCY6BGoG4eDx//wR3wILtlwJal/js94P5zwxpTH2b5U4ZWOWYe6KwH4zG3wo9uujdhm/xwJpaIrrvMKwDXZxV8XPsl0SzOPd8zkv499Oepxw0HR2+2Ym3cekjSAiv/rwNhbE/e19ZZWzph9Gjcu+TCsYOL1adu58thNQdtVIQGjazitPO4+ri89gw2vDD1qA/60oTvfejxoe6dp5c7x86Ier/lkntsxg7PGbsIaIbRSbG3h9szV7NxjUK7QF0X92OXgnoUnBLRN0dpGgtohLPb8biFavjtkToOU7qHHrpCwI/604Y8aKkjY1x8dlD/biDx9PL4UG+4MhfozNOQwBkbWyzYsXTrCCP0b6nYFcaxfY0VZtxOjK/C9b7lqIZ60w29xmvjqOpJkGSktlaqvlx7q7hzFQcIRY2R8/PHHXH/99cydOxdN0/jpT3/KKaecwpYtW0hIOHiMRl9P9RcCrnQXscnVz/Aj+YJDq9FgNNoY86w/vaFjchrG9HQ6SyVyT95HeUJ0Q0AVOnk2f2rT2ovbcH6YQeb6MIJqmSrTb1vH9Vkf8kHPBBp9gbSwZ6esYbyqASOb8lL2+nfI+UjGkyrx/RufwWPG98gNFHWyyz7mFVWxvrEgZCqI1m7B2iz3CfA5i3RI8vkF4XpF4fZ8byKlL7RibNiGUpDPll/ncWHq6ogh+8FIlD3Mz69iy1k57Jgzhwk3bMFUpLAMIp0lFnrOCJwINJ8Vn3s2mIIJN27F6OnBOH4mO79sQ3EMreJQ3eyg8MPANB+1pgYtTJG5nJbG1j+Vc/l/FvHd894aMsPIgQLi+yY/yU9v/xrcOQLRnBggKSbVp1nJ/0RHccZ+//aeqXLNKW8HbU+R7My2GGSkLePJjui6IAcDtzXM5M1nFpLTFjl6pfRYh8RuJ8kmBXIHhUoil6WsxXmpheefOH6o3Y0K4dVoP38Wad8NjBbVP19K7ketYY4aGq7P+pAsSxePbe5dIHf1xF08C4BpotU38JsfXsF/bt3BE2UfBjWxChWrfGielzTZQapl6FXK6SfVM/fCKho9ySGFLz2mj6rb56CneyIuGExToGsyH9RWMCenJqQg35yEPcyxNuCQEpk2aO0+19oBz/h/Q8+v81Dej041rGyrRi7JiytVU3ZpKJX70AHdZoYVWxWAbNPpKdMC0o2i4cOGClq7EhioQ2pqGnJlDdbCXNyZ6cghaNsMXZD+oQ1bmw+hhTeFTSEw/XSPmONLUPY1oTU0IhSFjgvm4E0VQbWYhwMOEAeYXi/FLwXXSmm6h5HnczuKQ40jxsh46623Aj4/+uijZGdns3r1ao47LjhMPVo4UJyps48k2YVuSqzoGRPXOVLXWRC6ir3ZQCzbAPOn0pMno9nBVaiHLHqLhq8Ub+G5tPDV0UI3WbW/iCv3X05zcxKmR0ZO9HFxL0VnueIlJYJWwlCRslEl5fGlKEWF7PhO3rDPV2xvoz3NQaejVyndFDS0JmOaAiS/HoZu8w/QIsU7IOXID22ck/oT0rFPWUBXkcRlM4dGIZpn6yAvrwMjV7BOSUVq7gQh8CX3T9IN861oDhNvtsZlY9eHPddrVx2L7DHpLgKjPPRiQUgGXxoTfgheXl9Cj92OlqiivtMfzo+0pBJWC5fNXMHTTYvZ7crizmaVpa3lvDbuzQhHhccCm8wDFU9y6gXfp/QlA8k3uv5qIUwodNE6yUHKLhGSDGEwar5s4azjV3Jb+q6Q+2UhMUZNZJ5jFz5kGnypMdUPhUJ+YieaLvWxuETC0rYxlFv2c3ZCf274TXVzeeOj2ZSsiGxgtFdY8KQbQ5Zre7xtAaQtZ4Y1kR9lrOW1xZNxrswkZbeBMPwsdSOC+R3syEonZXwrb4x/I2DXmeefTmVeKQeKb4cKE1C3O2hZ4P/NG73JGLogeZkd0zm8czte+JwthYson1OGzeHtJU0IhG4ajP/oKgxdcOm0lfw6e+OwrhkrdnVmkrnJH8lumaRGFXgVOmRs9VF/uYcflL8d8NwNhoSEPrEbJUZR1M4uB9utOdRbU0hW3VyS3Z8yNEltDqt/kyY7+p6LMVdeSUHiPOwvR2b3cs0bA0IgeWP38GlJKq5jxwJjMex6xPdGCBMl2YsnQ0IYAnuYSNZAtHU70HxyEF+l3tmJ3Khgywsd7TWN8CKV4eBLtiLbbcjJyWhTy+kqjv9d3VGTwy8yJnNH1sgQo8xadRGZG8OPxaamBRTvH4AeI63zocTRdKn4ccQYGYPR0eH3zqanhy7IA/B4PHgG0PF19rL5dBh+78xwhGjGqQmMU934TJ0qbye+ZBPZI5BieE/yX65Gq9mHUBTkgnyqj0vEFKDbwXQMPU3Gl2zizlCwtQSfw9qmYb3bH73wD3EGnaV2mDTkyx0yTEsJLKR7pm0mmAIl2QsDAjThhlvvcZ1kpXVwcsbeYfdFEib6hBKkzbuRhcCX7F+Q9uSrlJyyl1lpNVHPcea3/IbOls5cdjT7ixw9bv+zabN7sVt82BSN+wvC15VcbQqWGRJViSmMfSdEAyEQc6Yg17X0eXPN9BR29viYfcx2MizdPLFzDsbaFBgXzy8QiHFqAjvPfpCT3rgGyXdwRBbcM5xgOEgZMB5b2zQwQbdJaI7+J+FH57zYy5wWGac4fICPzd49dOgOWrX4DfApKXUAbI5gZGgeGdmqs7a6iDaPgwljn2KcmsDrThvvvTyXks+iL2pap+tBLHXx4KVt00mb4mSGdTsOycLq2c8wafl1pK9tA5+GJzkbb8rQJztTAk+mwZI5D5G3IPQC87Vxb7Kh1M23N38jpmL5sNcyBPmfeqi7NI1PO8fx1ubJKA0Wsu9fykgwaOb8dSk5gFJSxINvFgTtdxpWxt/ejOn28ORPjuGUszciY3CMbRiGmoCOMgsJIvQ9fsepUrm5gIrX/TUV1tyFmAroVoE26NFTXH52L6GBbb+b/877J/Os4edBj+lj+xDe49rmVJqsPioymwcVq8fGoLbrpEeZmXQxCXsmBGtaWK3I+bkA7PiqROJehbTtWgCzYjjodomuQoXO43uZpGL7Ooh8/3fITgqOzgxEqy/B7/AKd/2WVmy7EjH25yNl9/8uhi6gUyWyWyg0TFWBwlzqFg+NSc2xxcZ/OxZzypkbh/ec9iLrTissHznq56M4snFEGhmmaXLLLbewePFipkyZErbdb3/7W+64446g7U+2z+U8x2YWjECqrCpkbkyrwnfyO9y79GQSdkUxXAQgSyDJSKVFVJ2f18dTZpnRxnmlwXm9seKSEz7jhcLp5N1/cKgoj1RMy6sbNj3pQMx9eB1LfzAP+y5/ipthkTj2ls8j5iWHwqTkBiYlN2CYgue2+XNuvz52JT/KqIxyJDxUuIx7E+r4c9XpcECUakANhpyayosv/ZMpj9+EtWXAJPhKJqYEMy+tYdOCx2FBXF0Oi5EI1/tMGY/pwx3DydyznLgHlFIUPK4iuw3axqs45/Z7aWfYqomHmnmyxU5+yibubpkfT9f7IAnDH3GBoMWHaQoStlvpGe9Bsersbczga+3fZd2C//Cbn11B3v4YCvxHyNE1mJax9KUW9M1+wbOc+v3su3ZqdDHLMNASTXZe8iDRFpjTLDaWzHiCqZ98O+JCLSIGBM8MBLZd1oAC1JGCVlXDi5MGRbiEACFRd0sRpgz2erjuoeswLLD+mnuHfi27zOd3hBbj002Dn975bSr+2c92lPGI///G8TNpmB9oZWSv7EEsW49SVMjrn79GKH2ogdjqNbhgWXRl+MEQwuTLpdu5Jy+2IulQWDv3KR58qoCXpuUFprlNGsuO2/z9VvDinuGlPt1O8bt6ZM5PAc1TVDzTh6e5FA4uXeXdykDGNIQIEmXV9lZT8YM6Kv81FUnq3ddkpey1oXnyPYWp+JKHN+A6amW+888b2Hjt34Yl+ugxfWCEuQmhxBJHqU5wtHA0khE/jkgj44YbbmDDhg18+umnEdv95Cc/4ZZbbun73NnZSVFR0aj06XtpO/l72jFEHLQFnHT+SjgfDFNBEvsoN+v46PnZ/xuEyF9gTPv9et55YR7Fb3cy4aFtcRsYofCf+f9krlUQPiYTiOtS97Do7L9yQZp/UTDhd93oW3aglBZTfX4hM++fiDWEs++Zq+9mgmqN+TrRIAuJV//2FxbfcyvZa4ZO31l5djbntJ8AY4vhR/EdW3OJ//cXwnUQWc2DMSm5gQlJjehIvLh9Wp/Oh+ZScOy0BL33ri4bX/7ONdjd0RccpgR7LzeRhyHOeAD/2TKPpTnlQWlMAEZXFwV/WkH9DfMCOP1jgWuKi40nPsRoae4MhN5mpfRlvW/h8sEbsyj97YqDM7QumEb9Mf6I9GCbWPLC9PtvRM4Bxa3GxcTmzFVpOSt8mtecVZeSsSf0OyZ9so6CzwI7Y+o6XRct4PU//gkYmuc7FvxxzrOc4ehmuGPKd1JqOHP3dr4z4RQMp5P2byyk+RQ30qC7aha72H2xSvmT4eNVe89QETnDGw9qmtJo7XFwRklgalG1K43lVaUB27rLdJquXkDWg9Hpbv8X0KY7uWzq6dAR2lFaf8tCuqcHUvKO+7MHc+3o6lcdxaHFEWdk3Hjjjbzyyit88sknFBYWRmxrtVqxhihkA1jiHEeLURvEOz5UyELisTmP8MHEibxeN5Xm9wPFm3yJJuOP20OyEng9wxSUn+4vuC10tI9IXw4nOPNMxNyp9GTagNgUlEPBYyi8Uz2BU4r7F/Cdmo2P943tW7jFgvmle/uK5UcSibKnbz5NlIfJiy9Mji/fSaHiQhaxC7TJQmKKRfDE4r/zzZVXsv3b6TjqF2HpMDFlwnLpJ0n6sLxXoZAi2fl/332MGl86bzVOxvfr3LiOt67fg9bWAYaO2Labsb8vZ8dttn7PXxQMbieEyT/m/5uJh6A2VxImEjpiVwKS5l/iKEZ4ogjZHXtijySHkviKH6YhoUd4j0xNo/C5KhAC56RcmmbEaDQIcEixGxhWofLYgn8A8Mfa01hbHZtTSNplJ3uD0Vcw+/D15zJm5z60oRR6xwnPV+bSUaZG1ACQNDAF9ORJaLbYRPlaJlvpmKShAidvPjdkmx6XhY6vqeTkLSD5iUHplKYZstDdlP31D6MJm/CNyJgiC4ks2drnBTclgursoDdBwKGx55wIz1qqFykMo1OsME1Bj8vCq3sDMyh0Qwqah0zJxJRDv52mpjH+zh62XZ2OnDUya5DhQtKg4iU/i923jv2Yn2Vui3JEP+5rL+KFG09BaQ8s1pcSEtj182mYgJbpRRlUZF/5zSTyS+dHpU8+XHA0khE/jhgjwzRNbrzxRl588UU++ugjysrKhnW+Ds3Bdnc+SdJujhshhsHZVgsOsZHajDTemJESsM9q8wXVEoB/ARJq+/8KDIuJL8mCljD0CafVl8DW9hycTiurWopRJIMsWzfpFmdYwbFwyLF2jkiUIRTMaV3sTE5izgicK8faiSVUeDkKrEJlrtU/kJuqiWdWD0W5walhu/Znoq4ZOYXpUDgvsRPo5ATHdi749tUUPyJHjdhJuoGluhWtta3PI216PLC5Epg69M4Ik4VWHVWMvkc9HJQe0cd8pjnAO8PPBHbG2G1kWfzsY07DwktX+/VgvG22XsVHk/InDn2oU9vnH6ccQK4nO2BfV5GVnvzg51U0WDl5y9kAvDDhaVKk4PqUB9sLqPZkBG1v6EkO2jYY1g0OhAGOBhNbi4apCPZd6WPszzvR9o6+3olx/Ew6SxR8Mb5KuhU8qQKEBWeuIGutNyRBQstkK13lBkqKF9MU1Danhj2nnOnBlekg+q8FHV9fgPfCtugNh4FzJ66jQm0j1vqLaFCQ2XbXZFI3KTgLwr8HQpjImcNz8MQC05CizjtahwW1PXIKk75lB0XvzsOTYkP2Hvr3G5M+de5/rl3EU0mz6WlIYM85D4c9ZPySy9GrE7A3CvLfD0xLVEqKaDylELM4fP2LlO2mca6dXHMe6oufjdhXOYrDB0eMkXH99dfzxBNP8PLLL5OUlERDg794MyUlBbt9aLSrrVoCn3RP4Dhb7BZ7NNiEwQR7PYkTR3+wG0nU6TI24SZRGh1Od0kzead2AifmV8ZFFwtQ50xhb1UWikNjX1MaAB0pNoqTY58sTVNgNlnxjZOxMzosFucdEE0cIho9ydT0pCIJk7Nz1qMOw0ddmtlKpSuH0yq28Nf8lUH7/5WXzR1t5wBgG4IxEw9mWK2sP+5h5q+7mYzNPmRXaE+95NVROt1oe4IjXqZhouyx4SvyhqR/jARZ0SnKaB9K10cEHkNhY3s+mOBNMzFUEz1N4ycz3gXgoqRdAYvvGzP8aaDvOcuRMEiW3fxq5TcASKwNpOs191sxMz0hvbvxICnRxZjk2PRztJp9yDX7+j4rebl40kroCaE2YGuSaHzXH3HuGKeTMsjXsNyt8++qBTS3RddXKchsp6o2A6mjPxyVvcbbF73QHDKtkxSOL9/KPtvopMX2QZJRiguomW0nXqZj3QY9DoGz3Ie9UUUOYWR0TNJCKkEPF/u/5GP3nKdjbu+QNAqz2qhtTo25Tub2rGWkSCPnwJCFxJ5zHuaEsefQHcHYOpygdshYOvxUskppMVpVTcj6A9trK7ABckY6nunDc5yOJBxbbCRXWSj+cDd3Lg6tRbbPk0bxvRLSp6HTwXz56XSc6Dcw8jI6aO1x9BGaDIRZ6qJOtVPy4sj1/ygOHxwxRsYDDzwAwAknnBCw/dFHH+WKK644+B0KgzI1ka8n7+J3zeFZr0YTkmSi2/0zebjFXB9Mf8pRsuLmmfa5nJm8bkSK4Q+gTXcidP/EpHbqqHcnU/WrdModzTGHrX2mTG1XCvY9FnyT+yMQbR0JMbPQmIDuVCh/xUf7fHtQytpoQxZGQA6xgUAfxDHpMRQ+2TsGdU0ipgRX3vAyVjG0lAZZSLw98TWIoM11RfJ+rjj7gIdq9HVmHJKFjTffz4zfXkf6dm8QD7wwTNRWJ/qWMDS9hk7pz5ex57cL0fI9IAjLb38Akuwvus5O6e5VXR5acaRvGFn9himocqaz7+0SkGHs/CrmpldRbGkZwHLVb2B0G24ebF0YdJ7Tr/UbHq/++1jSt/jpgYUBpa/62H2+ijQMdimA80vXcXumv9C7XusGI/aUrf2nleHKjr4AbTcUCkyjL42m23BzxarvRBTXHIhHxz/GKWtvo+CT/nHAUAWoAsln0lUo89R1d3NrxfGYvqE7jqQwukuG09m3UJQTE6i6KHK6biQIAxJ2qrSe5AppIB4uE/M4NYF3Jr3A5CVXMuTK/8MEJvR9hwNkDLLiN9hNU2DoI5MyapqCA9ObZoeqiwopvKfRH5EdDQjCajQNB6YAs6OT928OpsYXpon88XokY134E0ii7/d9euJ/uW3fmaza5zf+g955YSLZrHB4ZI6FhWmKoZNSDPF6RzoOl7EsKswjjIXgUOGHk97msof3A3DsLddFLDJMrvKy8WczmPfblXFHF2LBaT+9leJ9gYufpv8rY/MNuXy1LDb++GdWzyGh0jKsJ1XU2Cl/e+S9grGizNrEFcn7+z4/053CBmdxQJvnl8zHUTeydRGHI1b/+G+Mfe1qyp8OfJ+t2+vQ6qNTy5bd7s87F3OmsOv7kRenf5r9zLBrrlZ4fLzeGV3tOBzerJ6Eb1k6CPjyeStIlD0cl7iNk+3B79suXzf/aY/MYvXCzX/g7FVXk3vf6EQcq7Vuvlt+AqYWndEsXlz64C1ceun73J65nV2+bk5fen1ck+ipS6/nV+c8xQVfbwnaV/HitVTcsIxbHl4MxtDfdaFaqPjYG7Kuav25ZSGjbEdxZEDZaUfpEWgO0Cv8DFMvznuIiRYHL/UkctvK80fkOpat9pio7EcK3QUWevJGfjHqTRb4Fg6d476rxMa2xQ/2fkrksdKPoBT2+Lo55bMbAtqKfDe77hsHVw35ckdxmOKIMTKOIjbIwuzzFP7qzr9z46NXk7c0vAdF8hp88ocFZFxdhUPy0qDXck5CZC7wWPH7XzzE1U9cTeGHAyZ9E1IeS+KJ447h0uND52C6dJXX3poPJthd/sFT0kHd6sAz3hVz8e/hgBOTtjDf2gP0LwrPdDRRrLTyWucMAJ5+ezH2jv5JQhgw5fGb+Pt5D3GCfSTY/Q8fDCwGlXQDZaXfe665Y/TyHXA2bNjBuB/1U4juvSeFV+Y8FNA0T7YwXFaj6RaoSPenm/21dQ6+OLh5H187D9teK7KJP/KCwSWpKxirKoRjoRsc4RqMF7qm42xKAEbeKXBbw0w2XTEeUxu59NEADHpt4/XSmabgzq2n8YvNqZQ/G0jeMLGpxq8wYMT/u+y8ZwFFk/wGrhAmycrukO20f+h49FLqP89jzF0jw4hj3WHHVeRDSTz8hcgOF+RldPDohP/2ff7pvrNZXVUc1E5rt2Cv71/iiN4AmOICaas/Snx29a2cc8py7sj+nPyFf+eyZd8Zcr8MQ2Ddbg8g2FCckP/kdvTRimIwugEmM0wqrSkE5oIpKJv2oPfqj8WKYsXBW8f8jTNXXIvm6x9PjwSfvYEIovse7esd6fhCGhlLGsegdPsLt+yqLy4WhcMZ0xzVzLbWcqDg7mS7jm6PviB3NPqoeqOMmkWpfH9CGzAyRsYJdoMLzvqUJ1IXUfZi/8hrbdPIWm3h+bZj+7a5czRQexfUpiChc9DLZfqpIA93qt9Ozcaa5v588C2duaxJ3x2gMO2QLIxXnejJ63mzczpqV39B8AFYWwQ9poXDPn48BCjtCrYd1aDraM6hcdabHg/agLoASUpmjDryhexWoWKVVXTT4OUHjkf2QvMxPi6bHcyGsq0rh9XbS/s+W+pVZLe/2Ncyqw2rpJEk6VjF0GrIwE9Yccy0HSxPKqPkEb9BkrFWpn2CDZE3tGcl7W07L7x/ErIXUjeMPt3mJ264v/7sIR3rclpx7BcY67YEbB+qKb731wuZPHNPTOQbczP8UYzPFphU3j4Z6wjUT0tewPj/7J11fF31/cbfR67H3dOkbequqeDuroONAcM3Jkx/G3NnG2yMYRswvLi714W6pG2atknTuF499vvjpElucz1JW0af16sbOX6PfL8ffZ7BGRJJi53kLumIOjTW/XAe50yKXyTNIkh8b8p73Lvt2LiJNoYak4rquDp/adC3fnP+BzxhqeSDHX29A1qLDVubaN7fg3FgLgFsAYHnVsyifnIqD5e+y3d7+qQe3zOHhtZYWulNqH4JucE64HyCDlrzwMzbkY707RqOeh+aI7SJKBgGlr0taN7QY07TTZUUXbYr5DpJEBlpSeotWQNIcvm4etSHfG/wl34URxi+lE5GU1syot+MLFusw09xeCgwyt7ADFtdwoZWzio/++zp3CMez9K8PdxfNDTGxq9zNmA/VuHJhhOCMipJtQGSemxEf7pMV7scNwf/kYZ2xUl1d2bQ5NTQmkKDJ5kxtnrOcfUZ1OmSkymCjzcPx4UeZqipGoGRPexEFfkhtxE/XZ9QVHq4oGOQ+8RG9K4uLJ65PCnPIj+3PWibhpZUs7Tv4H2tBmeP2Mg4xz6cQ9Bkf3XOYq7OWcw3d15H4ccBUncG0Kw2OmR7XHSYBmDb6CT7/d29zFExQ5SQsk1GKIvXQG8PXh1IEQiXlNngKw4ZeT6UEJ1Ouk+dxImnfk6GxR1ym+UtI9jTnI4k6Vwwal3v8vnZ1bSfuJ83VkzFUSuFpSIeTuiagH2z6azmfdyKvjFCoEyU8J4zg5JTa7giYynRBPhC4Rup+9hYtIPF9WV0djnNvoO9wSV7hgRCoZeXu4txhbTuYaptX8Jz1IzMPcxK2jUg036MHaxZn1HnSWPbvlzUTiu2Vgk5xviFa5fMEnUM96bs4TsZZharVd3E88oUWvelIieHzjKpnX3fuugRsbUdnqizxWtg6RZiZjiLBc5aD9LW3UjlRQQyQgdF1Lr6sGN0+5wAa0a/FfP5XLYA16bWH3Uy/gfxpXQyDjUsgoZF0PDo0Us3vJqFVsWFQ1LCTn4Ho1VxcUbmLnKk4FGmSnEjKrEPfAWf+eGzJLakTGLFXz8BYLSsDJpT/f+ytnLWteu4Zds3sbeqwaq8VpGOkdKAlK9mIzh/akA0+QlNETH8IRhuvAKioqNbRBo8KWRbu3FIQ1+eUN2dyfb6nAHLG1tT+GH3BZwz7/G4jrc3kEm3feewMX4dLpw5Yx1vp0ToSgcqduZhuD0Yfr/ZcBsF7i47O5XuYclm+A2F5X5LbzN08tPLSP+skNoLS9H6PZpIT0kSdC5JasQiDK7J3ikGsAoaxzl01nz9bs5cfDOiYpCxxY+100rj8eaQLtnVsIn23u9EFyj+44r4tSQEASklCf8EM2PnaFRwNAZv0jrehuogyNGQfOA3hn7KEWQZYtBkMJQ+w1fMzebYO4MpNxVDot7XFyDYs6SIog8DaA6RPf+X3rs8SQ6QYXFzxfwlLHp9AXK3cEgdDV0ToMVG0e/M6490akGWkYoKqLxzBRZBw2dY8BsKNiF+R+OegpVcr1l5r2kcKALl7wQ7EqpLYs/5MncuOQ/JpgVFqg/g4nFr+EH28pBUxtFwV/6asOvm2iX+PfI5KvfeinOPPCAzHA3OvRIPPncaF339jxRKTn6ctY021cnLG+eiOUNojRgCrho5YmZd0EDyDX/q3d6sIAUkWscMzbcl+UFQdLTOToSNVYhzJ2JYxN7SKcEwEJTIL7yhC1HfM1nW0HUBUTRIsn4x2DiP6mTEj6NOxiHATFc1c2wt/K1lbtRtX9sxkYJ/W2maauWYi9ZEdTT8uswnz09n+zeWkHOQff2173+Xgqb4P15bi8JPy2YB0PTKGNbEQXkYDlNtNhbffT8Lb70Ba7s5aGsOkeaJAwchXYYLL/g0aFlTIInFz0+LeI6cd62kPr4s5DrBYkVfOAn1N7m8+o0MLhn7eYK/5NDhH4+ey1tn7OSl0W8f7ks55Kj6o9lvkfqhg8wHo2fVRl+9hotvvIM1P7tvyK/l8c5inh2XB/R9i2ptHfn3NlD3ndmHlHTnK2mrKZFDO1JJdQGSevzY6sstyK7QjnT6YhtZD5j3NBETSC4qxDc6N+I2GZv9dJRZ8WX13ZyCh9bxyVmjuKgwvLGYEKaMQUmN7ohbFm+MyPCzorkU8XdZvX8XYRrRklen7id93NQNs22cd5k5Pl185mc8+ck8nHWJMZclAttWB8W/WRJ9Q8CYOZ5p/+ob697pnESNvZ6rY6QrPhjvbRjXo9kSghHLrVHe8/7tPsMGBQOzaou2TGd1a4nJfjfEcOsGjo2JlyJKXjjj3u/z8s1/ZKQliT/lfc6Vly3jK//6dkLHS6vWcL7wxRCZ64/Cx7f1lngZqor42Vr0BVMxrOY7Lvo1hCXrIh0Ca72FZ7ryI75nl5R/jk+3cEzSVk5xKnR2Dd1vOIojB196J0NVJCYtv4J3ZjxAfpjJOx5UKW6e65g+YHmW5OLHWav5U8vUmJtHP3x1OgjgH+njisnBWgfPb58KG5PNCL8B1/73Vpz1Bo6WvgiDo3WQ0frZk0h+wMH8/96AJ0fi85/8c3DHAx74y1/5+paraNqYg3N/sHXmm+zllIotIffLtnZzzEVreL+6IiGqQUMJYPl0A9rcCQlddzS8UzeW9q74Jrgk0c6Ps1bzjW+YBt83dlxqUp32wD1SYcv+XC4QTuaFUe8O6fV+UdC6wE93cSWlP4vuaOQ+to6TN36Nd599ZEjOPe23N1Pw8h5QVWAg85WhqhTdu46GqycTSAnvaVi6BZ598Vi+c90qUiP0Y4yQnXw3czl3tURmmIoFpS9CR5mTQD9N0BH/qcbw+c3sUILHFSeOJZAZ23uesjuAtduCO0+k4KF16G43jsvt/PfUM+HMoek1MuZNQbPFNp5qs8djqaqjc2EZJd/uo0p++cmFpG3XEFVTmT0asj8P8M7+BZxy+2cJX/cBuMf6kWyxhd1H/daHUNeAoaoxPb/GW+Yx6SsbB3eB/TDpbzdTulEhFte06H2NlklOfFMHZiF3NWUwqfMKAN6c8QBFUeZdv6Fw/vGXMWfRFu7M3hxx26HGJKuFV2/+I2c+9P3Q/R1hUPhhF8K6qkPWQmjp0shab9A82YK7IoDYoyWkqyKurbHVIYsqFD6wAa17YE+mtGxjH2mHocf0u3b5c/hbWxK3p9cELe/WfdzbNikuEo0jBUcpbOPHl97JMAwBn9c6ZFwtmiEMKIva5isA9nFmlKqjJ1bMJXOFjKgGSNup0TFCwpDAstvGE965ZBe1927ra3bg6jdPp2/VsbVrSP7B5+0NWUCcMg7FaUH2aMge0GxD87KPszrJdHhoyA7QbZODIoCSrEXM3GRY3Pxq2sv8Y9cJ1Lekht2u93jjRmNYg19xQxJIec/FKyvNpnNDgFMuXzbo8ilVEzF0cxAWBIPpJXuD1oc7vlO0UiKa78svy17ivSsnoiPwTv041I4kNFWiqjmHM7QzqP60NGhfzQqT5u0A4CfFrzPDdvjUrGPFrXVzWLq/NPqGPZAsOv4ihbofzqPwj8sj9mnoHg+WhviYTsJh6u9upvC12qDm8pDndLvJe3c/WC34CpJpnBFiQjfMUqFokASRFNHO1emhs3EAWWJsz7g7X0a3ElQ2ore1o/sGadzLIroUm5Mv6JBU6yPt8y40t/lda80tZH5kw9pdRP2lg6OaFcaPRLFJYRlwDoZuEdFLcukqlih3mRHWF59ZSGaViqUz9hlAVAxc+1Ve+e9CjrlsNeMn72GTszBkP044GCJ4SlWzrCjW83a5Udti6zbf+5N5pC/cT4lj4Pb1SjrPdwe4MCm2b8VvKEx+5JvkblORfLHNL5JfD0vjaugiPq95r2KdrYy6/XRHaNp7tjuVHyy+dkgUf0764Fv8bt4LXJbchiSIlFmSuObSt/nXuyfj2B/93S96vxNxx964GKX0zm7sm2vxjU9Me8WXIdM4U0RNVZHsfaVqgqThLjMrB+z7ZSRv6P1t7Qa5nzSjdYVOJxhxlFTu+m0lxbPrUAyJNtXFE12ZQesVQ6KrX53pZn8hOvXMI8zFHcUXGl96J+MAHmmfyeWpqwZV071H7Wa7MrAmv1V1sd2fB84aZrqq2egtDvrIAJ7eNJP0NTKp1ebEa2tVcSSJ+NMFNEVAdEvB4nMC+DMNDAGco9sRq1OGxMEAk54ukDm4PoxokKwaWpqB39vTMBdjyKdEbsUiRTcI5KJCApkudOvAaMmBe3wAL4yeAZJBQVErx+fFrw8w07ULpVhiedMI9rcnk5PazShXU9A2FkFjtT/AZKuERQgdwZltszDbZlK6TnPW8J1nrsHWKaA5oEZLpXBx8KSl2US2+Mwyjl8dfzZ3FL/JfPuRqbWhGToPdhTzSV053jgZamS7ineihiAKGNFe8c5uRn30NQD+MfspTnPGVy7YqLmZ9+kt2JJh92VFQPCkX/rUXlO9tx+0HSaLiqMtj9SMEXRfYdKreralYWuNzzmXBJEKS2Kmkm4V8aeZ71YgTUDvGd1FBdK3q3EZCqEgFxag2uObMgRFQ+gKDhyodftIliXqL80Ms1d4jM5vZFtpCVJRPr4ExqiGOcl0Tel7J7LXh1egjwQxoJP9uZ/XR01h1qSdONO9xEqXrFshkKojp8TnZLUsLCRTFGPS6tAmd4cdy7o0Oxu9RYywrI04HvUeyzAo+ERBDKFMHgm2VgPvbgdGaXjj8bH2mVySujqmd/7ld+biPD3AL7IH0gdX+fJjjthHg2urjS3TCyC5z0G7I2Mny2eWseGj0eSt0DBEaBsjm/Nvg4GjpW9OEjbuQIvTmTeUAGpDI7b0FJScpJgdeQBProWOchGKPQMMOgF63zO/ImBtE5HdwWOSo8kgbbsPbcsgtXEEAWHmRIpn11GZZY6JmiGyxVsQcbdmJZmdgsY86cjXoDnakxE/jjoZPXh041xskxW+mrqeHCn+Sb5D97LEW8xG78BIhF1UyJDMFOSZTh9vt6dR3Z0VtE3uyzbszcGTTvKeAEqSjUCajpgXPGjJKQFIAUnSeW7aQ1z58vewf8GY8iRZxyj2ormdSDHOt691TqXTN7D+Wu2wYvEYIAiITif+0bkxRzjLnzGNjLrjcqk6oYOKpMYoe/Rcv6CTLrs509nBea61/MXSydPKDI7J3TFgW8WQeLFjBtkZS8mXHFEn9jOdPv78iYJjTwf+/NBUipJfp+AT02DaKozk7yedxPyyD2K69nDQDJ1O3XzXUkR7kK5FolAMjR2Kn7+sP7E325MIpOJCtNr6oAbeg6E1NDLyCvP53f7sJTwx6+G4Mjx7VQuj/xjgzy/dxwTrwLKgmS03kb0yGcHjR6vaGbTO8Hqxtassnv0Ua/1+zm+9BVvr8GeXNJsIAgSSJTpLg++vqIC9xcD+6orESzdECbkwH//InLiVhdUkK/rIPMSDhRZVDa3Zhpjlj4sJ/muFi7lfk/GVZUffOAS6Kr1cMWEViiGxqSN/0JTY5Ys0Nufmxby9IYGSbCCE6FeIhpYzfNg6crEPgSDggfEoN2MpuRHGo27dxxueXEL0cEdF8t4AFo9MY4TE5aMb55I/rZ2K1BiEOH+4lGd9xzLysgasgsZlPU5As+Zmvz96ZnuweG7ke5SvH4n91RUgSrjzzH6sjA2dGKv7HJ+EQ32GgbZlO5JzAiRZY3I0lGSJ9goRdUx0cgwp049fsiKoMrrVwNJlfnmpu/yInybeoyg6nQhOB4Iss+f4ZDL1Lmo8mTgkhVzb0GSWj+KLi6NORj88sH4hn5eW8GTZh/Hv2z6RDjV0ZG2as6ZXeVgzdD7+7yyyNgRHWO2Ezi13FxkDHIz+0DWRMxffQm7XF0u0TRAMkwYRUMd6MLbHFpWUBB1BMHr3B9NOGHtvJ/rGrUhpqfinj0romgo/ClC9u4JRtzYhRphVpR4qmVTJ21Nvak7Qc5w7aC2M7KA+0FrJJWkrmRwiw3Iw2kdZEZXYuNoLP/azPHcUDNLJ6NR9vT0BN2YsjVgvrUVIK/R3TtYHNC5bevOgrksUDap+k87on8sDjPtwKL1kA1f99HbW3fj34GMhhHWeZtisvPnGk0DovoNVvzAby2+vn8mWWT3PUNdAEGg+bzwrfmuuv/Tx23F1B5vPumEE3bOhcOAA2kdbUENcrmBAak2Czaf9HHQpO5OqP2RR+LgUc7lMNKh1+xj9rXq2/2c6kjW2UiVBMNANEd0QGOyd29mdhfeXBUiJm4S9MAx6x7Jo8BZoSBmJM+lE0WqMG/9qreTytBUhHWqAJ7vKeeaW0xGOEIGikp8v4YmfFyGlpHDO5vewCTI/qDuVD9aOH5JSqZiha2Tdnzh5QiQYqzdhmTCGQI75i0IFy4QeUdLakwSkzNi1huS0AFKem3PKNvHaonkIWnjBvVihzB7L/jl9gb/m9wtopgBPocYVx8RGUHAU/7s46mQchFV7ixlbdxUAy+c9EJFq7xMffGOVua2uC0wu3MfY5Iaw2yuGxgm33UxWxxeDrm248OLo1/hL5lge2jC/d5k6ysvIrNao+96RuZofZ63l3rYx3Lf+GAxDoOKWarSOTuSyUvyl8Zdg9EdqTYDPfj6Xyp+blI+hcGHqasZZLIgIMGhz58jBWr+flztn9v79cNtsAIqsrVx7UKTxb20jeOCpM8IeS53Y3avMfjib10p+v4pz7z4+aNmWP41h19kPDuq4f8pbTnONWQby9bOvZ9u3naw+8S4gjLNswPz7+1jgvcXKoK9BEgSaplnDWjmFH3RirAlNpBANO/4yByOjL2M0FMb4ABgGFTdspPoX0zFKotdjvz3vXk55+g6KPlQZRLx4yJHzgANPjgV35KqQIUHdRQqOsfMo/MPQGW/PdczguZ7/lgSdH2RuipppHUr8cf0pfFi8h8dHfBTzPlpnJxeNP4ktfxiLJX3oBUufe+ZYXpkzic9nPT3kx44F2uYqpC0iot1GYG4w3bfsUWCFmTmRTpsNcU55nk57r4MB0DjDhjBtXtA2BR93YqyKThrQceVc3AWh50DnPonnXl7IRed+GnL9FxFHG7/jx1En4yAYuojWM3+du/nykFzfB+BTZTS1bzDe0phLR8DBnMya3mWnp6xjotXPgcio5NUjhj66C600zey3QWqA4Rru3fkWApe2kXZPEoIOnjwLvnQRQTdI3xZckuJo1ph81818cPufyEqgnKw/LILE1amfkz+9jV+tOQswo5R729LwqpaQ5Ub997UJFr6SuoE5c83tFr0/G1W38vaHBZS8lXgzKQCGydSx5rapYTdZ4pxDzVkS1Rfd37vsdY+9p8E/Oj5wj6VV28NxjtCGkmJoTL/7NjJ2x1dDn/+hyOjOm9j+lfhpXN/xWNjoKw9i/Djw3/VKGg909E0k/941j+YtWdhDJN9kDxS+WsuWX2QhWQ6/IWgoAbSDyqsEdfCOoUWQetno5j62jv9L3ki65KRRczPn9W/j9AycHPo3wjpqLZS9fj07zrg/oYzGMp/G5W/fEjZ6W/JaC0ZNLUacgoai3c7On02DLB+SNPgYrZIi0VVgwzKqsndZ6k5fb3mG4fcz6qH9GE4bnpIU9l1x0LOqcTDyabMs5uv5t1OsBQ6L+F0kiIpBV4nAiJNqIm63dU8egji4eypKBp5Cjc7L55LyVHiCgHhw8Df/cEdJbyb3jcZJQ3KOSNA1kYAe3ywnyDLN50/AsU9Ab3JhV4fWGBM08KxPZ5T7a+w47pEhPXZMMAwwNHSvF9ua4PnQ0HR0Q6fml3PRcuO3D0SLjqdMwbXTAoaZHTs4Q9Y4K5nUzJlY314V9jgdX5mLN1sMn10zTMaqaJjm3M1CRz14EqcfPoojF19KJ0P1y1hjqM6pa06L67gBv4X9ncmslYqYmmay0uRJHlLF6M3kzZNs6DbwpxlxqfbGiz2nWdHlfhPdjnQsBWbjdSBVQHGBoAt0F5q15PY2Ddmj9TY6zvnoVh6Y9xgnOhLj4/pt85heQa6mQHLQOiUg09zlYpWlhJkZe3qX51o6mWQ3m23FnsxBjuTq1QWZn7+K4zedi61laCYaQTcQP1sbdr0IpI+o5KMz+0bXbb4CWtXYnK88uYNcqZtwUW8dnaz1CmIgPmvK0aSQv0Si3H4DWy78R8yCW4t9Opv9hWGv36db2OPvC5e1rc6m9MPQzpzk11Br9oCRWM38oCFKyCOKg5cpKureWuSyUhAEUrZJVHz8VWSLxuY4BRJDwaTVNN8Fn2Hg2hV9WBUD4Ky2cMbWc3hw9NNhtS/CYb2/mPJFGoThxdN31ETUhAh/YSL6CG/I/FzTFAsZ27RenZtYoMsCSjIoyX3fpqPFEiRceKBx3tWQQ0bGyKD9XfsV9PWmmrWzoxg1Px3VGb+QXO+51zlYJE9jUsG+hI8RCs5Gg21rSzBEuPiYZSGzoLtb0wn4E7/2AzCsBu4CCdfx05E/2xixRykR1AYyev+73e8YtiBXLFjtD3DJi99kdMDUVpHLR+AvzcAQBTx5AmIAxMDwRHst3QJilZPT8s7k5TEvMX3Z1yiIv5J6cDAMtPaOgctFCXVEYoEAQTCQXQreXClswFNziAi6hYwFUwfMhaLdjlI5Hnd+BAcjDiSLXnIkF51HUHYyHIxD3Ph9NJPxRYVv+EpcfF4rO5Qscu0mFdxqfyEtukmXqBgS3mwZZ0M/pg4BPDkWOicFkEMoiw41kse2Mjd/NxkWN580jMLyxwwaZ9iCBMUMEdwF5gLZLyJ7+ibMEf8R+VHGBVwxYiXZchdXJsfWba4YGp8HdB6vmoUSCP/aGYaAoksUWftKp8qtjf2i/qGnvNbXC8ldP3RlaFJaKlpHpxlROnhdxUj8GQLvdSWmuTHeVs+4WLzcBGBv8DP69o18c+4xVKbsZJ5jV0jmFr+h0KqZ9+vj7hkxqdEfQPIekD9YPWTXPBQQ7XYEqxVsNnwjgusHJJ+K3NWFf0QmhiCQudFP5kYZzW7lL2PLEQWdU12bh+2ZhIOgQ907JVSPSKFEjn2C/cgr8vetx1EQ4RkkEi8XXS6MsSPC9hYEJnno9DlJ1Y2YKF81m4gaB/W11tBI2mPhSRcCxZkh2eLiQc4qP/vlJBji0iZrp0FSjQgi5J/Ujl1Q6NCcA1gEhwq6DPtn2ympK8bYUzd4auIwcFoCNJZbBzDyHSrsVLIZuciLPnMcclMnXROzh0zZOhZIXqh9u5RvJy8k/+82pI/i7G8SBKTk5LCrtW53RFru4YSYG/6dCYh2DEHEl+FkxO4i1Nq63rlQSHKxf3b091q3gD8z/Lh2YI5PkzzA4J3vozgy8aV0MgTNbGMbLh9RUyU+qTabjw/8fy9O8yK8YcfZaDoUuizQdLZvUA9C12OngE3/WxLLv13C6cVmrbYhRb4LhoB5o/odP/muFF7lRNoqrJz1f38BQOp3N0VEnP34/DVDp1b1cuXSW6NeX1FGO++OezW2HzNMMEQB//RRWJdvRXcH02+KdjtbvpPJlXOHt85UswtmeU0c1qJgGAiaDrpGzWwva6++kEe+Us9z454AIL1ff9EOReWp9spwh/piQRBg1Aj8OaEzMZpdRgtBBiD5dF7/ptmv8dz3p/POxKeD3tsjER26l6+/cTujbxt6JWFj7Ah2fjfyZO+Z5SGQ4iR/qY6gRng5BegukIMUv/9XoVtF6k9R2XX6Q0HLP/KKvNc1gXbFdF6HIyq55/xcit+ywoaqmIxVxZBCRmJFwQiZfZmevhf/zfWs/uGMyM87FITo80s0HOfYx/r7zCzG0+8uwN586N8nwYDqeTqSEodSfU8ztehw4J85OuxmtlXb0Tr7GJgEWY6ZalpXJARJHRY7RszxoeWAognsvqKE4n+0DZgLo8GXrXPhwuW973+K7MXWr37q2tQ9Pb0/Rx2M/2V8KZ2M0tdVmhamooyPnZVhKNF8RnAEYTCDhK4LlD4iIujxZ0Ey7B52Ts0n0tzXVSoSSA4dyUqvCnD+10zHoWWCjQPkWroNtnyjTx18UXcmP1tzTdzXdyRCeDODy9OGphY6HGyChffvvY/Zv72NjC2xZ2es+zrRtvXV76Y9thQel/iKeCxikoupH7ZhEQ9P1Gw4YVRORolR9TkcbH9KZ+pJ36Lqq/H3sxxKnHn77Yx+fsVhvQZ1jIddedaecq3QaJ5oY5iC+Eccxv1qA+8VLOFgEojjHDr/bUqldp7Z1O67xzUoZqlwqD01nYySGSa1ahQsWjcDZwg9CfdIhStnDe241jzZhnuWJ+H5bYVf4fXO2UN6TYcK0vgKAjmuqCK/gRmjsO1qRq3Zg2CzUffNGRQ/tAUtmuiirlFx7Wqqfz8Xio9METvnPpF3/ltJ3t1mQKTjtQqWTX2u3xZfQMVvQhY3DOv5vuj4UjoZGJC9VqWzzUn3/EPvaAx15CERDvMDiBZcc9XpQUJD/aE5RNpGmVEI3UpvQ6bkg1FP3cgbF91FhcWFhhhXFK9b9zHl2dt55YK/hqVWPNSQ0tPpeCqdeam7ItLbxoI3uyax31HDKc7wKuNDxu6iaxg6GIrphGqDLKL97MdzyVm+LerkOe7ORqpuLhreCVCUMOZMRI9D9TksDMhfojG5+WbWf/ef0bcfAhgS3Hvtv6i0+4kUzdsS8HD2898BoGJLG9oQz3Li5LFoLhtdJQ4gtrIbKUWh+hLzml01A5WE9aHRRQuCvKYKY0wZSvrgvJfsdQp1u0bhDEMbHvd1CVrk5v1hLocxhIGNu6N+2MGiry/g4rM/61325KfzmDh5Nz845o2gba/65HocO2w827QAgLNPXY5D6rs3NlHF/qN9tD5Ugqs+tntWd5wVf1EgJgPjqxOXcW3aKqCvL+kVt5MtvkK0HsriRW/Px9bxxcmKGYIQ05jUVmFDH1+EqBb2Psf9l43tnUtlb0+wKORJht8EFSQD91i/WYoaZyYDMK3knvc/45saFdfdRNXVR3Yg5yiGFl9OJwOQPRrJtaAvN8PvXdP8MfO1H0kQRIN9C2zkrFaDeifCofoiicoMU43arVpJ3qvTXSSGdTYkhZANyIFUGW+WGDpaaYC9UeS8lTfwq8mvxPxb1E4rO9sKmN91DY4GEZ9xBEU6JDEhNfBQ6NLstOtOIERDXz94cw0C+2SsHdGzVLb6TmgM3x9j+P28fd98Rl5dFbPYYCg4azrQWqJTDau79yIqRcPWyic6nQilhfgdQzeEyW6N5L3RnbA/tY7k6V0zQq7zK3Gk/g34zqaLIzLYAXh8NuyN5nUJ3qGJhAs2G2JPg7yS6kC3iGjW2I04QTB6lYRVh3xIQm66x4OoDX6Mlrw6sk2k67udOP+RhuQ/NA2npa9q1B0XWQE7FljTfZBj3gd9dSqiCu5cCcsJM3p7pdRdu7G1F5IqezjWZTbOd1baOSttLfPtwe/4t2e9x8oxpTR6k6l9uxQtRNv/9PS9LGkqwL69AcNpx18YXvxu/1wb/nwF2R5bdv3hlQt4WDkG0aWw88T/8I7Hwg5/XlA/i7VDOOJYxfpDmDWJqtvMb3/0P1W0GByMzlIrSpKALkP/0GMgpe+/FRc4zpyF/Z11IRv8MzcYNEv2hMQdY4EAyDYN4hThDAVtxy7Kn09ilOVGdlz+r8Ff3GGAjkBsijhDd74vOr60TgaYVKVZG8zBunOiCF9EJwOzfEHbZEOOlpQR4MxZ60izmBv6VbMJPZBsJZAscLBNb+kCKYSDoSRLeDNEfBmRPwBxZQqfllUwK2lXTL9FcovYG0XU2nS84/ykiQHg0NfIC4aBpc3XWxsr5+XSdmwZkLhxfjC6NAe7lDrKLKFZhf7WNgLNDt4MEUGXsHSFfzcDaTKWLjtSBGVrQ1XJemApa0ZX0j3TxvT0vUHrP9o/mtbugY3P5VktTE2rRTEknl07g/HuobsH8cAArFucCB7TQRYc9rBK6MOJJ7oyeWjTfCxr4mODCgVBh8Di6CT3Bz7LpFodvIM3JkS7HTE7C18EQzEeqC4dURURD09vcFxoHWfDlwmBdJ2d0xZxjPUbSIP0297aMY5nU6q4JGlg0MAhKUhZmWjNLVjfXoVj7Dw8ERSwo8HuCFCQ0smsTFP1+4nGSuz1Mv50gbYxVrL7aXFqVphkr2W2zTR+ZxesDHnM29J3Q/pudindnDj+m4x11NOqJvWSQeiGwNPrZjFuRzPq3lrE5GQsSTZaJqeETMv7xnmRY2Q9UrstpG60kFSn4U+x85dp5by+fyKK1jcZHUo2n1ggZWXSempwn0XzVIHqk8wI/aimG7H0UH5LAchdEfyCGaIZpPNlC1ErCXQLNE+0ULy3HGHn3qC+CCkrk5SdXvwpLjos9mFlpewPwx8geY9Od3H44CSYWZikfcHzlrFyA2Maizljep/G0jm567gxrW64LvcoDjO+lE6GqOiIA9SK/3dE1ULBbAo2qHFnkGIxjclWt5P8gE7a9gCt4/pqqA0BlGRI2a2jSwL+9ODXpGOkhGYN5v0Phw7FQasan0FmyFB9ysP0T58fUhigr93c+6d7egkn/GjxkJ5ilz+b5zQXd2T0qVd36z7adRXFgAcfPwObDr4ss3E5bUf4MF57uUTb6GQytjpwvd0RkWlm5B1Lqf5lJYWndpBrMxsOG/wpdL2VR34Idq5tp4wg97guOhQ7FdeuRY2j9EPyCiiKOGi9DAPQPDKlf1qD6vOBKIE8TEOXYVCluBkpOwaUwNSq3fz03Rtw7j30GTbBgLTnPkdNhJa2P0QJMT8XX1nWwHPoBlpAijujax3RjW+fC2dd9PsiKvQx6yUAQdURNR1din+8DqTKjLtiC0+W9fGQ+lNNFfPBXFPxAxZ+eMFlzD3nrl4q4j1qNz5DwK/LKBNKED82s4yC3qMOnmDJ5ciMFiam9tHvXjl3KU8sqcS1O/h7kLIy8RZqnOaM/X0psyRRffK/AdOZ3uHLpVuzsbM7i4rr1qH2BF30ri7ErTU03zgeyaUM8DPieTKOPaZaffso8935939PC7ndkeJmiMnJdB0zimV/Ch+J7x+lX+bT+N72mwGwdGuIqoGaJPX+3lix9/QMit8EYUs1hhJAsFgJTCzFEAUytvqxdVhoOMk8pmTThvV+6V1dpDy1DN8t81CdoVXoRdV0MFzPDSSoUHfvhX76qPf89Fzmfv2vdB+ijOJgcFSML358OZ2MJesRD9YQuOKL2WAWK0S/hrBkHcpxcKCoppA2EASM46YFNRgHUmU+vff+kMc5gIt2nsTW1yqinnfli5NYnD4RYlD0/bLj6zVnsvnVMUDwpKokQdPU6Bmd1rEy7rxpZN0fpoa3B6U/W8rWz+eQe6epGrz19xPDqtCXvBOg5p0xCLqB1EPFHCuKf7OEzivm0nzW4CJsepuN8udVAvMmYF1ZhZCXjb84fVDHDAd7i8pN13yT+/5zTxD1r2bonHL/9zkELNPDCmHKWHxhehpc9QqlT4vUXh2fk/HIjP/wo7QLaagrirpt0VvNaJur4jp+f2ibq7AWFuAbkx/3vnf95R+9Uf0DWP77+5jw95vJWz44563sBZXz19/B6p+b0exz/vR9MjeZxxT7FQ2m7FXxFNgHXTIVDcVveHijKPIYHglXJrew2NLErRuuIOfcrQPW6243FdevpOq+2cipX4AU1hBhx08msj2OnoK5donP/m4+hwl/v9nMABQlFtDce3oGWUXJOD7eTGDO2KB1rnqF8v+a/119qQU5eWj6jSIh594ltH21Ek/eQEM4b4kbYem6mI5T/Ksl/OBXc1ANBTia0fhfw5fSyfiywdroxthWHVPZdMMsG0/e9BcgcnPlw2Wv0nyzhs+QuOT+70asl7V0COhVTtSK6E327hEqH5zxF+LNYiz69p849d1vUf7kF4ePYYcnhzEvndL7txgQDhnfRtKb6/j88zI6p+dj7Rw+yznthbWk7BhN9e2J/TJ5m5PCVcM/YR6AL1Pm3j/ew0j5yCAcALB0Q95jG9AHmcUwKqegDZKFqz8EweC9+feSLzl4bszTPJA7hf8+fvKQHT8c1H312Lq6I1KDxoNXbvwjp066ldKHBndvUmsU5n37RgDS2wca3q3XVOLPELB2gLbNiTomPtKRY8p3kGXrjryRIHDN1hrOctUTbQyPhqs+uZ6xd+yJSPIw7sfb2X3jOAKTYv8tqkfGscsMmnyRyO7874zg/bF/ItEM+ys3/pHrqq6k+73ChK/Bky1jmR45uFf6CtTPc6CXDX9gL3PROjKlgd+N4fP/TzAjHcXg8b9dIxQHRj8eQNx15BgWQwF71X5sm/Yi7NkXXhXWMLBurkXya9ScbeHiKz5isjX65JQqOhhpSWKsxcYll32EPz38kCLooEsGv5rxMrIl/Kwyatpe/u+4V8L2KURChcXF7xY+T92Ng4uqST4V65baQR0jVqi6hKVL6P032NrweCBYreipLlO9OZbZQDBZiARbfLRBus+HtHU3pQ+KlD4oonbE3mNjW+8kY4uO5D2EaXRBYKrNFlQqVaW4GfPx1w9L46lrn0H+e43oXV2x7SBKiJPHBv2TxpnGuGEVMaI0cIqKTuqHDlI+cqA3hB8HnE4/v57xEoWSE4sgkS45uTL1cy684mMuvOJjlOS+l0qz07uce7up+8G82H5LOBgGiALto6xDUkcz0pLEX2Y9S/avdvX+6y6MvxdMUA0cTQqOJiVk+VX2kiYcjQYYIPlB2O1A2O1A9YaP9al+qXe7D1dNYFVLSdTrONaxlyRx8PzBP5zzJlt+VRZxG62tjdJXWih9UCT/mej3TG23Yq23IKpmSc2RbonKXih6q5X6RSO5a/SzveVwiWCkJYnfjXyBsWclnskzRNAtkc02yasTQvIkIei6gLDbQdspFXRfPAdmTwpe7/Ggd3UN+DfUKvRHCvQexe9D+e+LjqOZjB4Ii9dirZyH76AxdXR+I7mOLjoCdjbUJh6BGG7YWxSsDcFRLm1/Q0zCPlpDI0JZHmmjWrkze3PU7ftDEkTuzN7Mo86F0BY+EmhIcFlyG5+M2M67H0xDTdU4buqWoG3Oz1zNOa7EKYUvS24jbfqz3HrGNZS+EX/0u22MFX+6jRG7ZeTCPkngztQjiOUqCjSrgDBjAsaazZEpDh12ApmxK1wbgkAgy4W9Kw+9sTkuYSatsxPpQ1PIKru0En+ak0AqISO5uiZg2WUaSKk7NewtKqpLommqOVTlCxVIvkMb/mzSHNjXHVo1cDAdjPQtXUHaJ+EgpaQgJCeBKOLLChYlFBUda2EB/lhofg1I3WkaCLrVhrerL/Ay8fjtJFtMTzjH1tXT6Nxn8BTJSfwiexMAH86qoKWHSCDJpvQuJ3sTo+q/FvUyWr9eSSA1+HoLHtrQ52xJEv50AU+Opdf5E1UDW1vweKdbRfw93681AtfZOS4P55T1dU1PSx4bdttEoW3bgW1cBm5MNi5ru/n7dNmC5gw9xoh+oXc7a7tEtTWXNk9wMEzuGp7x6Rup+6iv/IwlUcg3tE3bkDZBUkoKzrKJAzcQoGukBgJY20Us3V8Mw8naYeBs1qk7KYOPZ/yZdGnwY8Bcu8R1+Z/yPaKXGg8GjgaBziQ7Yl5wqaraacXSLmHEUL6sKSJ0WLC2C3SVmM9MdSSR4RmLvnFgCd1RHEUoHHUy+sHaZdDtl0jP7DPWf1j6BsfYzWjmZe1fB8DttaFrR0YSyAD0Vhu27bWotT31jKKEOH40wthRYQN9YnMb6v6G3r89+Q4ynFEEgCIhVUFrkZCilN+flrae9Sun0D5K5isnLxmwfrU/wIwILEnRcJrTz+rL/srJG7+Dqz50RPFgdBeaEVH11HZ+MPZd7t17MUl1fZEYT+6R8axjgeqEuhNTKVwnhXUwBYsVwZKYyqqvLAu7qsWt/noA6Y+Y/SLi1PFsuy45aJ0hGYh+kcKPgqNg3kyJCy40FdafcS0gc4MRM19/PNAcIu68oX/WhgiBNANbmxBz5NbSDZmrmtG2RKdNFmw2KMrDl5cccr1uERPqYcjY7Id+MYc/fPUlRsaYZfxk0oth16UkeZEqRqJV7Qy7zfV3vMw3+jU4A5yw6Trsy6qCFJK7Svqel+wF2RPsSARSJDpHmNvYhiC8q6RIqPYI74gBjqb43k1TxTo2R8G100JgZzAj2YHcoi4LiJPGIAmfDdzxEEDr7CTvbwPHdAQB/buVA9gLh+y8NtAtwR+W7BUGFc2XvZBWrWDb181n9zwNDF2QwSn68af3jAdxQFR6sj8xIGOLH9ljpTkpeJx31cikb9OozTCXi04VUQw9KBl+CUdj8ENz5wsoC9PJ3hjXpf/PwDAOsRjfEZ7piwVHnYx+yLp/KbplHmt+/PCAdRUWF2tmPgPAgvUX0NB66OkzQ0FXRUbftgK139soF+Tx+jtPR9yv/MUbGH1rY+9bfOGv3+b29JqEr6P65H8zf/0FdHyYF3YbzdC5f+FCkvO6sLU6+O2Krw3YpnGGjQ3fHpwYWqroYMVv72PmT28itaafwdr/g+0Z3w0BXv/tn8mS+qK/5/7uL5z/tVuPaF72wUAcVYrvMNC/9oe+djOjbw1eJvc09AqGgSEIvf9/qFA/T2bz1/6BZhBZXC1OBNINtl55L5P+davJyBZh4jhAOpT/341BxnQkGNPG4Hcm5jQeDqyZ+QyPvJLDU2MLQm8Q5pl/8MhDzPzZTWQ+ZDqqghEsJqo6oHny4O+DNoB5sA+1F6hcMTk0FSyAYkis+NGskNpCw43uEoM333oacEXdNlZIgm4+j8FYO0P4LYWCdXobZ48ItnqfXDwP557EvZr8D1rNaP3Eoc9oHWOHjVfdw/R/fCuuOSa1RjPLW2NEyu4AKbsPXmpmIst7zINd59ogDPWtnKTgH6Pi2Pi/VUZ+FIcWR52Mftj97CSWVv6ZoYxaHGp0Xj6XRX/4M9Ga09afezffnXU8NbOHvzkstVoj+ZW1nP2nE9HaGhDzomsDDAXe+vmfewskNgeS+dX11wDgurOOh8qf792uv4NxFIcHO++ay4kL17GlzYbj9D3oCydj2VxL/SWjWXhNsFHnLhQJJFtJrxraut/CjxVOWGY27j74j78GsUsNFpIgsvgbfwbgkqpLqX+nOGj92LOq6Ag4kE4zs4va/2hN8wFkSN3ox04bsFy1Szz0wN8YITuJ1DKotbRSePdq9t0yA30I/SuPHuDUb95GeufABin5Jw1cnBG5X8siaEz41XqW/3M6KbuH5xl6CjXOmb96wHIJnV839xnFC1xVHOcYnLPzg8xNnL8rwHdHH5tQnb2Um0PtlaOGPIthSHDyhSsAU5H8YFxYuQJlrsQedzpVr/cRBPhydMjzY+gEGc9KsoFW1mdsK8udh4yE43Ci9A2VxunOsI37omTgm+zFtsnRmxlSkgX2f3se+f9Y9T/be3EUQ4ejTkYPOt4YxSNjHxmSustDBb3BzphHO9F7okx7fj6P6y96i6IYmtOSRDs/yXuX7312Lp3HRVaeHgxyVvuxb9iL5vejDZbjP070dx6SbD4W/HUZAJelriQnDscidZfKK48t5JyrP43r/C88vxBbGBFuJRl82XpE/peU3TqyL9hIaC+XIxpVlm4oeHNfL6f9kQwpJYXt/yoHYHrJdrKt3dgya3nriYm4nF68/jzy0+tIkYMjbYZA1AbmRCCoBrJqzqQX3XNHjxLv0OHA2HLXyEWs/NqI3uWvN01i0/sVFL/rwVD2htk7NIRpE4aUMSoU/OkyJ/7sM4rk+Jr+I0ESQmtdiKrBefd+n3/d+A/mR+ldNvx+il+so+HEAnyZ0d+HM968nR8c+3pY4a+3PDbuuP9mcjr8QdkmzSbSeVMnx6ftwxJDDU6axYPjsv3s/zifove6kLbX9jI0JS3ehbWjmP2zE2vM9kzwMbN8N0lhWCJ8/QaHld4yOvX6QfW5WQSJUllIWPFZEISEncBAqoGSNXAcEx0qowsbw94DMB0PGyojk5rpOsXOvveKmXHORjyqlXV7ixAkcI9S+p6zbCD30y7ZdY6N3Ly5pG5sT+zihwGuXd2IHj+e8nQ6ymK7qaJmkLY9vCMgKgYZWzW63E7cc0O/J4Jg4CkPYNtnQXabAoJD6dh/kXBUJyN+HHUyevDTiteYa49tsr6oeA0viVOpa04b3ouKAHGXg/yVWq9o3L7vz+PUs1fwnYzqmI9RIifx4IjXuFQ4dliuMXOTimNLPWpDn0q0XFqM4gg/QjkbDKasuJx1s58a0mtxita+5tM4M1WWLo3MTTovPLeQ+Wev6xWxCwfdEHh6SSWFm8Knt1WnhCdHwps9cJ1ggKPBwNauDSi7cDaI+DJF1DAZbFE1UKtrIv+g1g6sFolAVvyRelt9J0asTEdhoJwyk5YJVjQbXDo+2HFLkX1cMm5N1GPoVvDkWXDuH0RvhgDufAvORhVBDS4Hyf68z4DRLQLuPAve3OgKvQfDU6AzdVpw78Fkq51R8h5WBczeo3Wrz6P8PQ/C4rVxXr+AmmYb9pIy3SL0fDtDZ1kUSh3sOS1c75WBXVAhSsMxgLprN1IgTNnVQXDVyPwl/UTeyG8k0+bmPyXmu/eDhqls6cxjR1MW+auDDVdfloX9c+HykvgIMY7J3cHLsxw0dKeRu6Kv101rasK2RSTLUULzpPjup7siwISSeiqSGqNvDHSoTraRz2JpO/Mj9ZFEwGKfzlWvf4vRyqqE9k8EviwDRAPNpSMnBX/fSS4fxWntTE6NTU/BJqrMyazh6UmZ3JD7ET7DwqPyfJbuKkd2hR87xDwf9SdYqD/uyCiLzlqvINY2Qk4GnlwZJXT71QAImoC7wBwnw5VmWTtUHA6BSF12slNFl7+knsVRDApHnQxRQjt2CmniGmJl9L09vQbdEHlBn4oBNA5Rf4babkXQBKTM6BF/x36BpG1tMGYU2rYd3HbNSwMaJQ81OjwO7M19xprz4y2oBxmkgZKsiBR8SbUB7A8lo83Sh7Qu3qMH+EPLNH6Q+TlOMbrxIntUdKuEIQqImo6lI0Dxr1fRcHJeRCejU7WzsqmEES+qEettZY9GUp2O4rKiORhgvCbXBkLW7rvqFQzRiiEKaAkGlrWGRrMUIAEnw9hdh+4JjniJU8djWEwHXQio6Ou2hNq1F3XHWLj4rPiyQroh8Oae8Ug9QTnNBt2FItYuCdmjxU2FaYiguiR86SKOZgEBA0MW0GzB75ygGkh+neS9Abw5trgpU20Fbu4d8SL1B/maTbrMO50mHWTFw+1fOraWUlnj0lPCNyg7BZV6NUCDZmGZ18x2NSip2NsGV/5j/TyJ6s+T2JZs8MqlZsnRoiVzcO6RsPhAdanI7r5shSdb5PIT4ntXD+Dcsg08658G9wQvV/c34PioC3v+FPwZQkjF5CAI4E83OG7CNgrt7XFdQ4fq5L2uiZTLK8iRnHGPqe91TWT0bQNVm4cFgkl3bOT7EEUjpHGSk9Qds4PRH5eNX02p7KFITiIv/21u6Lgyal/lcZO39jqiwwF7i4GSLETMmAo62FoN7B+sh+QkvEXJeHJjH4QMyRwnLW4Zi1sbEEwZDKTCPLS6/RhKANFuRygLLgEVur2oew8NHfyhwtFMRvz40jsZUmYGbz/xb+KVDPlORjXfyaimW/cxY/E3ADD0wb2AJW+Atd1P9Q0CohR5MHBXethe6UJTRSquH1wZg+hy4NFs+A0F28FK6DGiW/ehbkgl8+E+dpHBmAPdhp9UYWgazhRD4zOfi2VTLKyvlpgboVJBM3SaNQ1xxSaE6ePQnBbkdl+v4exVLXRrNiyCFrIWeH1rIc4/pcV0XaJikLnJT9NUG0b/2x5lHkiqC2DxynSUS0HOiWAQO6OKbiDoRlxlR4Le78IEAcFqOmuOe5oYn7IfgJUtpQhnmO+jEQgMaBgVLNboRlUI+HWZ3IuqafnKDHzZB0qmoGW8TNYGA8kX39umJMu0j5LIWdPj0AvgT5XoKA/OZjqaDFJ2BzCEnnsrDHQIw8EQwddl497WyrDbdGs2hP8FCpEhxhPtcwB4cedkch5wICoG1iWbcPkGGryCbiDoMRjr/WDpEvjxQ18D+vKamh1ax8lkr9EQ9B5NgmGaIXWPh8yHl7L/W/PQopWFiXDxKYsRhcTeE8WQuLe1ktszlx3R/We6BGqFJ+xMLAgGQoL3APrmowlWB+9PeoZJn1wXcb5WdIkO3UuqOPSNz4qhkf3oGlqumG6W+vWMZwcg6IABsgcyH16KIUq0njo6YbXwtgqJtJ2YFM9hbqGuC2GZpg6GIcDuS4soeUFGr6mFMWVs/0GwHSJvzab0d2bW7WjvxpcXXxxuziMUSaKdzQseYfOCR5g7Ytegjyd+tpYx34nd+5dknR3/Hs9CR3Qu/VBIFR08t/FdPry5knHv3ZDQMQDOvfoWSn++NOH9+0P2aJz/9dt43zs0teZnbT2Xv4ydEtO2P22cyi2jTjDpX1dsQPpoTVBkXjq1nq1z4OO75w7JtQFkr/Vj7TQHd9mLafhGGettrSqZG4LT/RmbVTIfXhbTObWmJuSlm6Jv2ANBN5A+/rw3i+E/YyaTlgaYtDTQ62AAzMrc3btcP2bqgOM0vTCCi05fHPN5D0bGI8vIWh/8u1smWvBlxe4cdxdZaR8tYYgmm9mBf51lA983b7ZA4wwbTdNsFNy7GntT7EZO8sJGLp+2Iuz6TtXOtvky2qZtMR/zy4bzR66n+OemeJlSOR4pN2fANqlPLCd3ZRTu7BhhCNA03YbqlKg5T+a0r4WgZD2Kw4KFZTuZmbEn4f0fbpvDR97YTZ4Ni8Zz2VnXJny+WJDxyDIK7lpK8Uv7g5YXftBBwV1LybnPnFMbbp2Du3Bw5lpHuURnSegsvnO/QsnjctzaiFu+l8mORyaw/fsDPWVlrIcdj0xgxyMTkLJD1AUfxZcCX/pMxlDgQAr6t4Vv8FTyFB5YvzDuY5T9w0DeuBV95kS2fSUJkdgnTUEwkBKM8HTrPs6//CbkNdsw9HEJHQNA1PSYaA7lNVUY48pQUoKjHntPsqKkBYfh79h0ET8Z+yYXJsVG5RkKI5+9kTH3t6D1NEL//NKvoVtEdl7kYOdl/+rdbsofbiZ3pRvJHcBQwpf7HNCeyHptG4sb5jL/931G/ROfzybvHQtOBqnhEOOjPPiRC3GSeBt+P9blW1GnV0QsYZM9CuKGneiGQdXDM8nO6yDdXh8ykwN9bC/6T1vo+P5omnanU3GzaWxbJD2hiKxDUmh/uZyM74kDfqMhmCUB7jwbggoZW4PLDTW7SPuoPidEt/RlI2LJShgCIEDTV6ejJAtkbVRw1LnZe2ragG11K0w81XQaChwdYX/rO3VjyfyRhO4bRJmUYWBZsQ1t8ig0x/AN5fZWlRm/uIkXf/KnQSkex4Or05eR0fNKKobBB/eVAnDvnReT/PRBPQmGMaTZIEOA9lEyUoYnpkbvRCA6nTRdOQU9ShLan24wbUFVwlmM/ni8cwInuLYy2Rpb0/nYz66i7DcqELn8cSigJBsECgPDapBo8aZQdUAdZirinvdWr6ml9NG+rgi9vQPDMBBdLpqumGyWkQ2ycsYQwJ8h0GYLw8wX5RtSC/1oDiuO/eZ9dI8OIDm0sNklAXonqW0/GYmgjSRjg9CrlfRFhG4ICIewhOmo4vdRBKFITuKC5HV0T7Dz5KZZMe2jawJ5r1iRNmxG6+pCd1kQc4YmKhcLNAykZZvQlQDFL0uMsl7DjuP/E/P+fkNh8r+/yajqvcTCZ6S73Yg9A3cgTab2FHMQKhzRQJp9IJ3uDn8uay1NTLXFXxJW/sINjFrkCxI0M1ZuQABGGlMY13lz7/Ky1+vRduyKucRLa2nFsUzj9Qf6HMr8Vh1H4+AcDN0CXSVWkvdETy8Lqk7yXp3uQpGMrSrObc3EaxLpbjfWXY0gieiprqBmcFtdB4LPD/4Aao/4XmFhK8flRReIA6jMMjN7ryoDVYBbFRdb2nMHLLeKGrMyB5C7A3BSwTZWOSbjrGoiS86heWKf46D1BOgE3bx/Qb9RJmyjfDzwp5sDvidbRlScFHxq3pPt11pwpJrfrCxrIRtzdUPg9UcWICrgKTRQnQbOQg0Kg8cJUdGxvDeQnjQcdLd72MutBNVkqIlB1zIm1KrdLPeFbtaWBJ3Tk9dTKluDSjevTDZp2v77jb00pleSfd/wGiqaDSR5GJXlJQlfRnQDwpCNmBu9o6FZScYXI5ds+Xtfp/hZGX1d+EzcUMKQQLYN4/0+wmEogSBx3AMQYnxPYoUug2ZL7HiSRUfrJ3oYycE4GAdsmhbRjviVuaQ+HlvG/Si++DjqZPj9XLDjZB4ue3lI6GtHWpK4MX05TxLdyVC9Ms6dVpIWLUEH5PIRNJfagfi1Kz7yjMbpqoqJvjYcHC+toLRzBl8pO47HR3wUcduX3Ek8Vl+JT7NQ9svVqHHWXPqyLLSOF7lybuTGui7NzgpfGcmiWTIxQo7cvFiluPnh7vMAGHt3E9r20GxbwtJ1lPSzUxKZ3rT2DnL+2VdOIY8owVeeWFrY0axj7RTQLQLeHIHkvUTNaAi6meZuH23DuasTbUdi5XoHlOKlrEwsUp8RYtTWox1Q9hYEAqfMIMUWP7lAutOLcspMLO+sosPtoMaTSbPPRW1T+oBtJVkj29Hd+3eaxUuaJbjRXN21G1dAwZdeQvdBJQSGSNTGSMkPkj/yzVWSwzNJeXIFNKuF3A9b0bZXU3xnGcfkhi9XbFecvLF5AmPuX4OYnUXXjAJax8g0Tw5B4apA0Z6RaDtqQI/trZQ6vCYRgD36cG7pCqDLYkKZj5/Wns1PC19nnHVw42SDZuVzT+mA5XZRoczW1MPyF9oYfmvs65x32am01c7G/mqfASy3+3A22ONqio0Gf6eN9R2FCTUaR4KYnAxlhUN6zKFG4YsW7K8N7H+RxlfgLUmNur9jdQ1aUxOGP0BSrY67UBx0JP5QwthnJ2mfhuj2csGOk3lq5BsJ9ysejD1qNzfuvAT05iE53lBAs4l0F8gQIVSo+mQk3+Aeopjro7HSRurjgzrMYcNRxe/48aV3MrTOTnwX57BycSqnOAdZ5tIDSRCw2hSUgBy2sUxTRey7rRT9ts9IrTuzAHdlYpzmf/r8FPxTLNyWHjoKHAp+Q2FjwAb9FG7lD1bTem42W1ZGvo7vvHkDo79pTkKh6qQBtKaWkIaS5rDQOFPg0lNiY+7Y48/kP36zefa7mcuxCCIaBrph0K7r2AXzngP8rv40vKd0oft8QFPfQQQBKScGB0BV0VpaY7quATAMRC00/38kiJpO6ntVaG1tSLk51F02CkEzQADdIpoMV2EUhDWbiL/MTyDHhcVmwxiEFonW3ALNfcIe/cc30WZj9u9XJVQ+siBnJ92/q6VqdQaBOhfLlRHhr0GVWF7Tt74wq5052TVYBI093nQEVccA1Lp9pC1qwXvTDMCM0IUM0oZo1LZ2GLj2m5Op5A99X5sn28ym34MaMg/Any5Qe04e+XdFpozu1mws3lfG6K+uAbudphOLIxrCugX2nJ9LySNdYb+fg6Ft2Y48qgyjMC3iuydqOuKOWqQkF0Z5dtzvacNPy/nRnefzQPkLcenM9IdiaChhoulZcldvxiISXhr9Ns/elcrDr5b1LjM27yTLW8ye8wdmxxJF8hYrW1rLmHzK0DoZlBay9/SMoT3mMEPKNK93x1WZXHJ6eFawA/j4F/NI/kQDTSP1yeX4bqsckpKfoYBm6HTokYNiI14PIH24BhVQjxVo2O2nZAgoXNs0D7/ZfzLa8TEEa0QJHInpqUSEAIYsBDFN+dMlOk70RiTPs+y3YO0wtxiMuKIhGIjJyeiDpEI/ii8GvvROhpSdzRufvzOkx8yRXGyqfIIJS68k4A89MOW8YyX18cPbVPjb5qksm2Lh4OiF1tTE7SPmRdx3NKaDIdhsPLv6FZLEgYPhGSddgra5asDyHTdKXDEl+kQVCne1zOHt2nG0dzpRO62UL9JonG4LMgTFWyD/ruB7KxcW8PqK16Me/wcNU1k7UIg4Jqi79yK3thOYVRHXftLiDb09I1pDI3l395RHzJ5E/UnJ+LJ1Rrw60BhWXRL7Lg8gAXuug+Qx04e9jCRROMUAO/5RjGjEVwpY15zGm55xnFy8jcZjfEH9MobfT97fzOfsOX8ObRUDZz5fpoFQGJwZDEyCdkxHv+yR0NNq1nrTWfPkWugqSbzh8rUPZjHyDvOZ1N08PWYRqz1fG0Xxmxno62Pr2dB27MLSloF/SlnYbXrfs7Y25NY2AnPGht02HAIX6Rz3jTvYfMs/494X4NnuHLZ4Y9O1iAcdF01n/0kqroHDTcLIXe5Bs0twytAd84sIwWJl3DvtOCSF6f0DNxFw7J3md/lO3VjSz+wg954ltFxbiS/r8HsZK/0GVy275bCce/qb36LiGytj2lacVMGe0wZmewcLzQZNU61kr/FHpFkPB90KyjhPvGzevZDTAmy/fySjr9+O7nZH3+EIgpnJOJQUtofsVMOGL6WTccvabTiTTYPEImwYtvMkvZSCrdOMRPpTJFpO8zHmh00YgQBGt3tQFK+h8K+tC1hZUMpjpZ9E3bb83a8z7mdNQHwKwwdQ94N5/Pn6hxHRQzoYAD987Vk8PZ2Nn3SNYfU0kbbXR3NW7uDu+TH5O3g7MA7rRifNk+UBkWZDgsZbTScp77N2OitS+M3vHojp2D/NXsbL2wr574Sy3ibvwwXh823Yp87AN95P9SUWyp/ti2p3jrDSPF8J+oDb5wTw5FdS+rOhdTSEmROx3NWMRUgsotsUSOLTPSMTHpx9Xiuvbp9IuRFeEC3p7Q0kfxhswdfcNgEj3xd2MpRkneorZIpfE7F0hs4YOJoULF6J1jEDh8oD79mYpBibt4d5btJa27AsDj9p93+fdbcb65JNKJXjo4r5iQENaaXp3GmBACPuDbBw8w18eu/9cV3fve3FNMeqIhYvBJAcKp5xBs6ttrh1Uw6Gu1zBu9MWVkwzFrzw/EJGP7gzpl61Q4Wf15xLhs0TthxWM3TOPO+rJG3agA6IU8Yh3d2OQ0pM72Bh3k42vl+EcNrg+0qW7C1jZHYzU9MSu5ar05dRJttZHSXZO/oX3eg1e/teIcPgxhOuYtwzu7krP7pQ6P8yAukGaoE/TDHjURzFQHwpnYyTnAFSnMPP3mt161i6TONFt5gTuba/cdg4owN+C+saCjnDdwb1i0bwzA/+RIVlYFnDR16RiuIGttxRhKAWMuo7K2Ou/wao/kMlXzntI05zRh6tj7EDmNuMty7huH98l3PyVpMkJV7SAybTkCAYoPU1/PaHIYDS87Obp6eiJAl8a8OlMamIJ4l2Lklq5C8vnkjud9SwPR3hYHi92LfU4R9bEN14U3Ss2/ehaqHvfctXZtA+zkAUDYRkhb0n2XsZpVSXgewINl8kq4aSMvShD90qJVyXvsOdzfbWLJRA4kONYQjoWuTvVfd4oF+FX8M35+EtVJGj8L7LTpX6SgcZGyWS6gZ+l4IOYiD0MQ68Z7v+NYZVp5Vy2YRgVeTnXllA+ZuJlT8mBMOIq1xO9/mwbYn+XA3DQOt3XK29g+RPdzDttzfz6Q//EjbIAFCvdvOpz+w/aFaSw5ZKDQUEzG/AXariqJMRE6l+FcBdoiK6VHTJhmNTHe/8dQGnfDv+zKvsZkAzr1xUiKcw9r45S6fIEyvmcuXswTfKnp6yjgVJVdiF0DdmtT/A9X/8FjlrV6MrAXxnz2bvRSpXpG1M+JwOSWFGxh6eunsuZS8pWN0ynaWJzb2qIqFoib8/v6s/Db8m0x6IwgLR0jbgO9J27GL57+Yw62ujWDn92bjPPfmum5G8MHLzoSN1iRUdI620jzEix0BqHaguA8OlIsuDD48KQMfZkxB72CSsHSrCu0ebwf8X8aV0Mg41/Oky7hwJ1ypHUP/DcMDjsbGluYCKfy7hg1sr8Dl3DthmrW8sMzP2MHPBHvy6zCdXziXzta1obW1Rj990YyW3nPUmt6fXxHVdGaLMFQuGrjwsJ7mbXcXJOPdGnnS82T3O3Zp0vls8nV/lLouo+F2rdvPXpmM4rmAHKyfMxOUKNqCMjVURMxyGqqLW78eaYTZHask2VGdwhN3S6Uf0KqBqIRlFDqBtvNkoByZNsTHC2xtdO1QCN+LU8exdmLiAV7vfQWfX4AkVBAF8J0/DuXgbWmd0SuOOKYEBTlhYFHsJ7HFCGHtb0MHeauBPD90MnvlmFYZYwZPN84OWj36tG1YMX6Z0KND//ZNLi6k7p0+1N//j1rDlWlpzCzn/XM6sY6/nzsmvMd5WH3K7fWom6z0lQ3rNT3Rl8n+fnk8Fq0Kul1MDBDwioiIgKGDpji2FZIgQSDWQ0gK9Bpdav5/MRZ08OX0+J1euI9vaHfEYuiHw9OJK0ASKdh4UBMjNQctNQ0mO3VCW/OCssaDPEgZNYzvG4iUrTB/O013p/OizC6m4b2nvGNNeLnPFlMFnRUXB4Mp5S3m5eiEpe3SsnQbdx7qxft7nbIkBAX+HFTk1cgCuw2+nxpPJCGf03p3+qOrOYXNjHn5f6HpFtdNK8nbTHDL8oa/B9dxyFGclk9XLkUWdlTOeiqqgXq92c+qa6yl8YMMR2YPQWWqlYyQIBZGdH2lENyOzWsmyu/GoFjbURicuUL0y1vq++x3IVZFdfQ5uR5nYW65l6ZLIahgL619O7IccIhxV/I4fR52MYUTAJSLoEt2FEr5MKL1zSdgsvpSdjTY44e4+CCCXlfJBaya1gcgNhjZR5eTvfsaShjnYl1WFNeAEWUYcXcZLPz50XPmRUJm1i9xpXazfG5u2h+SHt5+dywnXb+ZYe/uA6OsupZsuQ+bNrmm8/WyP0N4YaB2TFrRdaUseemsbaBpGhMjxAYE1uXwERn7wMcS9jWgNQ0NLOZyQ8/PYeX4aF50bW4P+wfBqFhR9aCLXgmBQd5XC6J3ZiIEAgsN02LX2jiE5fiSIAZ3UnQEaZ9jCljylP7qU9EeH/VKGDoKAeBAtdNfUfO75ttlrMcemMCX7m5Qro3vXa9uqgzOeukbJxRv49QtncF75+kFfks+wsCngZYI1cqT5V+vOoOK60A7GAQj5PgxAcVuQdsfWCKPZDSgZ2Pyqe72M/WczHTMdjHL2fbcdap/zbBcVFENiafNIKr67NuS4oI7Mj4kBbAAMqPWlUWRvT9jRSJU9SCFe3ve9Em7dxo8+uYiK6/t6BeS8XJQhHubP/cqnPP/iQpz7DVYuuJ+ZNd/pvSIxAI5aGSWKk9HSnoQ3YCGjyCwLTJL8Ye+JYkh4NfPZr60txNBDOwSqVyZlq9zb3xUpDJj22FLSHgPRbuf59elhs0IH8EHnTPLP25JQabSgaFjcfVn5oYJgmCx2SrJMywwdKSN89lMQDFxOPx9M/3cv++YetZtz267D7bGFJ7YJSFj3WSj6sO957ltow1+mI1kHZu6VZKg9MRUGP4wcxRGGo07GMKL7vE5a/RaSP5UovTNyRGjrT8uRsoamtMKW7Gfai/GV+cz743LeuH9B2MZhcXQZb7y/CDj8DsZg8IMHv87FV3zEndnB9f0nvPkdXLuifw67ryghtboQe4uK5FMRlqyLuL1aXYNw0KOItTBtCPS3BoXqe7K5aHRiDgbAh3Wj6eoeAoGKg+A7diJNU61IAcj761FF5kQgOp0DGr8tXRq/uM5UOP7xg4+w9br74Lq+9WfOOA21PliZeCjxXtM4HnjyDNbd/HcswtA4p7JLQRk/ONZAKTODNz58LmhZt+7j9819NOUznbvY6s9HPmnPYNtBBkDQYc1LE1HP2UK5K37aU4ugcUfGTmBgRvGuU89B27GLCoKbkbf9JZ/Lxif+7YfDQ1/9B/PtIuBg+9X39S6/s2kCi549NqZjeDw23qyaAMCpo7cMoLg+gC2deWypy4t6vOJXRRwvxTeO6D4fD1eEJ1noQ+IdOdrmKvJr97PnpoE6Q4OB6IesjX5qvqYjSZHfVptd4fNZT9P/3SmRk/h81tOMW3wVqhL6O03+3EbWhmDnpeBTP61NNroXHMIS0iGGwaDbveI+3xcdR52MYUTpDzwYDc1mo/chOqe81Un5Y7Xw0tAds/mGSp778Z9I1MHYEvDwfOf0obugIYRm6Ix/5BacMZZUAHSOkAgki6TuMhAWTkNcvD6unpZYMern62i8agqdx8avm/K/BgOwbXRSe7azt2RJs8L+b5sN/gUftKGv24Jgs6HNHY8QZfKMFa3jbXSM1Sh74dC373aNTsWRHprqTOoOYKzeFPcxxSnjUNPsUSOrv7z9Wn4hQd0xIjsv+xcA9yx7Dg2BU9+6nYobYmPIiQTdEHjx5QUIB26tAaIKkx+4DYDjz1rDPwv76rRHPXkjZS/5KFu3M+r1H1O+gwxrdOaaV7ZPitrvEwpJop2fZvc1ActIbA0REJZHlFB7fhFglmMdUI9PBGvfGMfWOS2cURKeAOFg5Fvb+UZqDeF0R44U/DhrLbfduAKLIDJv+XVhWRkPxrvVY8h63knqu9sGrtQ8jDIGlgsfDMPrPWTz897/m8dL1/+JLt3CT8YuHBTleKJQUmDX1UZEB+OmyZ9wbdqmnuxX6J6rlZUPcvaWSwfoHWW9ZsfRGPp3pVf5cTbbaTzvyOtNOYrhwVEnYxghuL1oUeowBYuV3T+ZCalD89EpYz1s/10604hfmC3pvP3szZpH8a+CozqaVaDMkngGQ0fAFyt35yHAox8dw6YZ+Txb/j4AkleIi8rPEMGfJtA+ykbqzgDStLEIVXuGvOZW93j6DLAYYN3opOS11sGzlgkCVQ/P4LjiEBP3YYAWkLDstSJoph5G0Lqe9prGOWmkp09HXropbv2HoOPZRWpP7DPINJeK6FLYfaYNLUkxSxFbZWxt8VuKxS/uo+HE/JgUfFOrNSzdWvjfkmRFnjoefW3sBqc4ZRxqij2m+yO7Tac5b5lIReAmqq6+j5E9Y8B9Jz7GtxddQsnFZr9J4R8lnrxiHlccE3s0uN6XykfLJuLwMSBcJ/UMhe98MpWy1L4orrNVpG2cg3RGIn62NuRxBcFgdulusmzdMWm6zCvdxer9RXg98deqRhJn8501G3+aiGYVQpJTJAJRhe6NGTxVPR/dqnPlvPDZ8bNS1pIrebELYBGOnOzzSm85XXr9ANIQm2DBJpn3896pTxEwJF5pm87b2yOXw/5oylvc/clFJMXQT3g4IJcWk/xkn7N7eeZzVFhcaIZOxgdOdMxaqOUbRw6J4x4NgVQDJUdBtgycJURJ5+8zTHKUSdY2UsXI702SaA9ZqiYqRtj5VNDpbfY+ii8HvrROxtW7j+HTDWN6//7g1L8OypDuj1q1m4VvfZux3dGpLQVJRKnwDFmcyW5XKM+MrynuAI7J3cGTo4OjEh1fmYt4cmLHO1Lh3CeypSSXxlI3N9ecmxhXuAUUl2ksbrvehdwxEbGn/FTUBEp+uXxIshsZW734M534pkZPMdvajJh1FaLh9EkbybAcfg5z1SsjtclRm3f96QK+LMugi/kMUUDI73P4ewfIfF/vf6sGGLIEhoC9OXZnQ62uITMnhbYxLjx5ofcTdHA0Gdg6tCCxrIOhSyJKuh3biBK0uv0xMdapabE5GP1hb1bIWmuBq/uWneb0UzPhA16kR9xy2Xocx0fW1TmARdumEXBbEa0ajvrI12JvFKEx2EL3ZQi0j3aQ6Z+EsTK4qV62aBSkd8TVFFxob6ct3ckeMS2otM+xyknKjg6zPMLjpey163nv1L/2OloH4xdN43ny1WMZwVKMeVPoHCEPeS09YIqhdQgYksjz26cGrUty+PnVWLNxdpw1ENVIPBxoVpKpE31A+LK74xw6oOMSlyKLGroh8NlDMxF7hlN3gcCp55hq7+e6arj/rAZq8ip79y//48bD3mTd8ZW5tI0RUFJ1qssGUj1LgsiTZR/2/v1Y5np+86uLARh5d5UpjArofj/Z6xSaJ1oGJYB3AI4GgZRdFgzBQsexPpOlsQeCYPQTJB6+d0dUDbQm+2EvB04ERxu/48eX0sn4a2s565+aSMU9fZG3zTuyKLMMTTahWk1i7HdNY09MTjbLpSKkRe12JehjPxiaJsZMAer3WahqyA6iHPXrMp1qcMrTISkxUckGLmljzcxnYjr3Fw01qpWtr1UkLF9giKYg3pIz/kJ+v2Z4jx7gnI9vRFBM70Xu9CVs/AuL11LcVkFVTga6o+8dMax6L1OHvt+OoIOt3UCw2WD8qPAH3LxjwLsol48wjebekwq0BlpJln0JKXwPJYRuGXtT/JkJod2ClmEgxUC3qHZakfyxz3hysgLJCgaguZ2Qm4VssWAEAtHV4petJ0ObhB7CWDUk0GWB5D2xUVwbgoCvPBub14fe2h7e0RAExKSkoAyXbhVx5w0cUwQdkmqDjyOqBo905nBlcn1vr0SG3I2+4OSga1/cVM787PC9YCtbSrEvSyKtxcCdn3h435sj0DAnmYLavN4eEV0WSEvyUJkVfwZ3Yuo+REGnSs3pZR8qeq0BrcostdE9Hiq+sZJvf3wRvyt9cUBj+rPdqTzx+rGU/3wlUlEhe+a5hsQgjARBA2lVn+aI6oSWEZZ+GYKh74U61JhvF5mfvwq/oXDef63obrdZfnZeEX/LP9D472TplOdhSt9+C9fcgL3Jj6WhM24K8iHB7ElkXbebZRVvxrzL1SnNXH2t2aNSuflGMj6UUfc3YPj9WN9aiTOnEm+WELOYZygoSQb2Zsj5tBEEgfaFyQxR61NcEFQD575DxY94FIcbX0on45O5LnKF4NS+W7ehGZ6olHTRoBk6EgSpPtvqO9G2bA/eUJQQJAnB4eCcsg0RWUM2dhSweZ/ZwBaPZ6v3bLu9K4dNdflB60pyWpmTWdN3OYKBYkgY2tB7ztpwq5AdJugWaJkgD2jkdopW3nvi371/X7brBNqPs4Y2AsV+o7yhD5T4FAS0LdsZ9UMJdeHkXu2NjpFW2o8za6nG/HKLybIkCAhTxjHjP+EpOtZcOd5UYTcMBNn8/Df/MBs56aDm2N1JOMoV8m0dg6bOPBwY8YrCntNsGEUD2YL6wzAEit4WsHbEr10jAGqFh10XZiL5M0nZrZP8bE/JQ5gsliDLsHYbWWsBQw+iQ5ays/FPip/u1T+hGHu1HbVmT+hzWq3BKvQCdOfLnPqtgdoP7YqTzT+ZFJRFsbWq/Pfms1n4n7t7I/mXJHVwybOP9G4z8ukbEX+XhfTXHXSrZumRTTR/m7+nxs3zj0LkHAN3/uDHA8UFe64qp+iedgxVxZMjcG5+4nLf41P2k23v5oMdY8Ju4z92Pxct+gYrKx8MWv63n95I2TNLkfLz2H1lacznNEQSyqKGgmVyO1vnPDk0BzvC0KUHEKxWBFVly/fyqb4gstr8AZHIik+upvyr5rvYG1gJpV0UTVZZPMgSDzVO90Cw2bjjqSc50ZF4cGbpXf9i6u9vJveePnrptMeWIl4+l+5iMSSNdjQYIuTO3k/aMV62npSLYQiIITpRFEMbPOmCIAwQyIV+7/oX2Rw42vkdN76UTkYo/HvSWP7wXCmrZ8QvtNMfV9WcSP0vRwZ9wIG8ZKTUybCsz/iru2MOp16yDIhuxE1M3cf4FJOH/rltU8NS8R2Ml3ZODsv+sLcpnb39GrZOGrWNpY9OZ8y/Vgzpe/2SO4nPPROG8IhHGAw49b7v852rX+Da1NAlAE+MeI+1VSo/LpsdtFxKSWHvDX0151nrA1jf7qPmFGZNQk3qC131F/dL3RkgZZf5HgSmjcS6YTeN51dw7I3LI17uuMe28+nf55K600f1DeYyOYxq2eJd5QC4nH7OLI2/yfhwo+TtAM2TnXhmhS410zWB0v9KCINUdlfGelD3OugyRLq+OweAon+uQ3cPLDfb8dhEzh1jjgPtipPaeV7QNaSKkQQKUxO+Bn9ZFpa0pJh6NGpPsHLO6aGFr9IsHmb8fjWL/zAHR1PsrEybL/072iUGrXqA6ytOwtB0dvxuNlqqxpibTQa2rpsk1CEMsBsC1N42ncyT93FG9qFhGSu9fAsXScEsSMmB5RiVU9izIPb6KCXZYP019zDl4W8iu7/IVtfw4oGOAl6cPZJ/bnyVbEnGJiwh1ib2TQv/g3+ngs/QuHrC6eiji1FTBvbe2LY3oNaGFsmR0tPZe11wX4i92SDjPwP7YaTcHJ5a/TKp4vBkkVKeXk7yvCnsWxC/7tC889aRazPp6Yuc7by7feyAbTRVYsKn1/Bm5T/DlgXGgoZzQ1dIpH1kx9Zh0DniaBbjy4SjTkYPqh6YwBl5m3jfKyUchRj14TVkvmUn6aCItSEIaHYZafYkWLmR7XfPZvq0KhxS7JP4AUfk+PLtLN03ImKjoq6JvFIzEVWRwmY+Dl7+yd6RpDTpEYXmEoFmiGihwhqDxHv7xtC6Npsh6qkcFAQdfv/q+bw/f2tQne0BSILIZKvEseu9PP3IiVg7zWdpiARFfNrGWJGLK8GAzE1uVLscUTX8QGTIEATUiiLc+cKAd6oyaTuzbME16vN+vIMXm6dTUzMi4u868I7oCdaFzsuvYWNbPnXNaQntnwiMQADryirU6aPQJZH0KgXXvtDsKIIBgtp3v7qKrTTN1eIeFIWe/+nPHNR0xWQwIG2nH1t1E/V/Nw2DE/O29T4jm9jJ5y+ZBozyaSY5qxNnmjEEIarCPED1FQJzxm3rzTKEgk1USf5GLfWvl5C9NrZrsgkWEMAiSCxc0cZnF09izD/2YcgSWgz9IonCEMEmqUNS1pdpcXPcyO18XD2KrbdkIwZySNojkPv3PgfGUFUINUYKDIjeOhoNnE191+W5sZ3ilDZKXG2cnfY5NsHCvVc+wHXvfR1X9aElxtipdHPj1bch7T6ygwcXJ+2geXEyJbIz7ioDiyCx1C/xrT/fTPYEN7pNCvmNKKXZCAUZCJoexNgmja+gYUHmgOfqzxBovaaSjEeWDchoDJWD8cvbHuFb475CxU0r+hYaBtLa7eSLFbh+vY/tb42MmAnz5utMmW6W/GVb+3pU0mSP+Z7vGjkgYHnw335D4aGO8rDnmJS+D00Xg8b4cKXfLbNU0AVAj4ku/ojEIe7JSChtdYThC/qkhw6i3U7N96dz4th1pFk8bPYVYRF2c0xouyQsxi2+itRP7CTVhZ5QDVFATbZS/3+VTJ6yk7HJ4ZWeIyHb2o0UJfNhGELcbCl+n4XW8SKWs2Zjf21F9B1iwCc+2KekR98wAbj9VrMJ8giBrUVg2doKLkPg6bIPBqy3CBI/ztrGzkuy+XDFBJx1A6NxqsOsLXc26ANUwqNBs8sk7TV4cvE8rlrwGScmb0JCp1T2kCMFR6U0BDxq7McPKDJLm8virndPs3iwy4PTKDCSVHzZcfRlGIbZ9KkDEkheHYc3ck2Ku8CCLgn40wQkt4jhNj9+LVNBtiVmvB5gkGoXbEhFRZxRMrA0SRSMXjrSRakLEjpPvEjOcjPK1RR1u1mZu3nBGX/p1oH3vOIXcyj8T1pQZu5IhygYvcaYlG3253W4rFi/Wkn6o/EpXzsaDRytGrKn7/3pXpWF/eQmbs76mAqLmfU40aHxtbmL+W/SHOzrEzNQ06s09uWlwJzYtn+go4C/PXEexR+HF4cdTrRqLt7xhB9/TnT4kQSRW+vm8Pqayew6+0EgsUBVl24nY6sfzRHe1NFsEtgkREXvPYswbQJt45Lxpw+cY3QZfNkCgVNn4s6VyVzXgSEJbL0tTqMhAs5xefhVcfvAc7vdyB1eJqbuo2pGNpoefg7MT3EzPmVgdl0UDHJtnVTkNVHdnDmg3/O39adxfc7HjLL4WO7PpD6QFvYcSZKfkSmmdku0YNKBklxNETlqen558KV/0oLDwYUX9IkONSgpfKaNoVha3bssTRR71S4P4C2PjQ+7+tKo6c+5cDRFjtgZApxy3oqYGq4jIdXhI6BKMXOJxwpttIdG3UnJa33LurZm8PeRpdyWvjvu463ylNOqDj3FytauXNwdjhDSUocWugzesr5nLrdaWLVkDA9nbA5bOvVwyWeM2V0OdaHT0aIKrvrEDPOU3QGsbguvFk/k/2as76mtHXied9smsqG2MObjqorE3uY0KrPiv6Ykix+n048nAYpQANmhokkGitcakWHK1mZgb+67b3Knz6RrtUQ2TgKpMp4csbehsr8z45UtqKnE5GhoNgPNLvTSrwJodugcCUr6odfYGAr48jS6i6wDGsFjQdUxj1HWdT2ju6ciLN2AVF4y7M3QwwE5LUDTsXLcau7OZq2XBvgACj7x07AgudfBOIA7szdjmaTxoHdh7zL7XmvQuwTgHqHCAepRVcS1S8a53yBl7X4UZz7fXDiLewoi06A+0pnD7z48i4pfRy4vk7c7WZwduZE/UXSoTj7pHliucwAjLMto1ex8uGcUKVstcHZi51nhV/j7njNj30E0hRe11ja6RifTVRx+7DAEaJpiwT0mgOJKQ3VC9SmRe0XixZiMRmrPnIXt9X5K7KXFNE0zA3cXjIosBBsNU9Nq6Q7YaOpyBdkSn1SPosTRSiB5M0u7R0c9Tr69A5uk0umzxSa+KphN6Ba38D/Rc3Ak4b777uO+++6jpqYGgAkTJvCzn/2M008//bBd05fbyRAlhJQkIFhF1aNbebitjxKvMmk7x9s76dD7JtubPrye8qf6IqQOohiGAmgOCWnwKgYsyNnJSqmU6oYErL4oMERTDVj3mHXs5d9fysN7z+S2H8U3gCqGNiwN392ajTWfjwyZCYgVugwOWUXCQLNBoj6fkmyw64yHev++bNcJrH9rLH957AK+cuvdYXn0rVYVTTYdiv4QjME3gtqbFWz3JOF5JECqcPgZZsYmN5Bpc/PRrtEJiZ4BiFaNQKGCbaMVwQBdotdglXo+yZzl7ejrtvTuo6/bgjx5LEqGE0MMUzIoQltF+PfIUS/iD1ihKLoYopTtw2ez9pYBGCL48lUKRzRzXN72KHsPEUSz8RQYEpGvKxYs4ZmMGSQ9lNi3tuvMBzmu9Dwc59vZc2F+9B2OEGiqGFwSoQgIsoyh91hEERp/D8CQMEvn+m2mOiVcUmiH88dZ2/jxGX26NGVvXId9T3Ax6DOn3ctsmzmm1KrdnPzQ98l8YSNqVxepu3azfd1Ydr1ulmsWyLag8WeX0g3Anx+5mYrfR+9fKb1zCfu/NQ+uOfTsTI+1zeW9fWM4sbSKeyoT1474zrZLsf0x9ky6Lon4p5Rh+bQ7rvN0L/AwOr8x3suLisdHfMQ7dy/mrtf7ehrrzyjijBsGZkUTxYKcnSyXRlDTkNm7TBB11nUUosQRFciwuDmteAvPV03F0COXFEmyjj7Si7HB+YWjsTWM6DwBQ32+eFBUVMTvf/97Ro0yGSYfffRRzj33XD7//HMmTDg8vbFfaicjcPI0Zv0hcqMswNLu0fxt9wj03+T0LiuP01lw51s46XuL477GQw1ttIetfx9PxbWJlzkohsavmycPSy/G2y/PxjlI++nSSz7izuzNgJWNN/yDSffdSpje57jwdNkHvHL1Mn70769F3G7DnCe5o3Qabz5TGbTc0WjETF/6RUK2tZsLK9by3NZpidWz7rNT8b2+RuXAqTNpmmpFCkDeX02DKdTXqK/fiq20GN/InBBrhxfecT7kGOhzhxLukiTaTpoBQMn9m0zGsaOIC4oh9ZAB9J/ddZRj+jhSrY1u9I2RKalbx8gk1Ym49vUNLD/626MDROjCoX/wog99TkORnMSWG//JmY+e3asJoW/cyo2lZtndiBUO7i8yS7zaNA83jToBQwlQyKFpkB8sTirYRmXSIXLOjyIIp4zcRpolui7TwRAFg4vHfM5L1ZN7qaCP4tDi7LOD036/+c1vuO+++1i2bNlRJ+NIxhNr5lD4uoSNL2bZw+HAUDsYrYqLD96chjzENrgkiCy67i7Ofv12nHtij9z4pnh4dd4/4aCiLWmoOCn/x+DRrYz+fguoKrWXluOZHX0SK35ExrGhFkPVgmiC7R9vpGSFAwx9AH3wwVD37sPaELoHQbBaEaZPHJbeuki6N8OGfr+j/isTyP+gGW1zlcm1v2QT6pzI6skH49m3FpC/TMOXKfC7P9zPCDn+AsVnxz3BopVjue/RKdE3Pox4YvUcCt42p0O7qrD7dCta2sDxPnOFTJpuIM4zf4+4YlNYsozGkxQkq0ZJTyZIHIIsdqyovSSbM5yXmH8YBoYSv8Fe+OgmPtsxlwW/Cc1ENpy4KHUV46wi/R2rLzt2/G0ulbO3RN/wMOOk0m2sbCqhsTUl6rbnXPYZl6WbPaDdXToL/zrcVzc4HC4xvs7OzqDlNpsNmy1yCbKmaSxatAi3201lZWXEbYcTX0ono/7JsUhOG6XpdVySZqZjX+ucgkcPw1XkF7G1fXkdjPwPWxmXeTNbvhG5ZOqJrkzebp2Abojs6sxgbnZNXAxaB+O1hxdib9PxZkJQd7YAAQAASURBVIt0Vqi4hoDqseATNxvOKoDsPqrPCVYHhhSfUWi1qoyzhja6BAOmLP46z89+YIBw16GAYMDMJ7/DvRc81E/B9fAhQ3Zzfupqrvn7Vym6w0/hO814t6ai2QTqL+3zGoUaB4Wf9H1n9jXVqM0D1Zt1nw98MQpn6hq6L4xmhTZ0Rp/WZsPaKmKI4C3SEOP0sbNmNrBXzqX4ncS8aF+WBW9m3/ehuKB5VibpSZNgxQbzngHi++k8NWcml0+MnqmUuwU6SmXGXbK1hwgj/sBBjuTiDNcW7ku0sH4IcVbKWpw9KUuPbuG1zqkAPPnZPDI/F5ECGg0zJcCKnh1Atg58b9omSKgOO5kbzYyENHYUomGgWERSdwW/T5YuG55Cg5prfIwubGSStY3hVFLuj3CaKfFAa+/Aubyad/66gONvX3pIhTmTRQWbcPgUy9NW7Ufy59A6NoyJJICnWEMM8Y4cwGKfzt37TmZDfUHvssxkN/Nzq/lD7tq4r8lID8SlZn+4kCT5sYjRx9bjL1jNtRlLeulyO61HA3ThUFxcHPT3nXfeyc9//vOQ227YsIHKykp8Ph9JSUm8+OKLjB8//hBcZWh8KZ2MZTMXkZJ8YMI0GSH2OnezzVcwLI3KwwXVI5O0zXSMusf7E2bCiQZ941bK2wqYNfMSPp76OE5xoDP2lsfGov0zg0T/lCwpeq9KBBS8tR9tezWZxUW0zSuic0TCh0LQILVGQ1yzlY0fTucM1crUtNre9ZI7PgPK2+LgDy2j+UFmX4TwEx/cX3ccGCCvTqZuegoTrIfByDeg5K0Am88s5BRnzYDVM5JrqM7JZE9jRkyHk2SNzJSBmg+xINfSyXh7LTNsVtbPfooxX72Jshc7sb61EtFux14xvXfbtB0a1rf6arCHy6QRk5MRXU6wDF2UVHKLWLoFDAmk9Pjr+Y7P286q2X52qSUUfRC/o6E4BQIpwU64J08AksjqrkDbXIWlyU325waeAgdMDH2cA3h++1T8uRr22e0h2dLigc8QSdup0TFCOizN35KgM8FRyzSbjk0wx3u/obDHaRrir+5ciL1Do32kjF5uZtjCXaaY46NTsCO7raTuChDI6Zsv+hMPmH+DrdNCS5mBUw4gxUAxHC+8Y3Kxd3QOW2mc1txCxhMrWTRjDsfO3kyhvX1YznOkQa2uIRlQHXl0lh5E8yqCkmqE/c5fciexzZfPB41j2L65EGdt39vUlJLEouI0JHQmOOs4y1U7bLoasWCPN50uvxkRFwSDjFQ3sjj8zqQgGPw+/2OSxMPnSH6RsHfvXlJS+jJDkbIYY8aMYe3atbS3t/P888/z1a9+lY8//viwORpfSicjFM50+oB9bPYVohsiXdrQ0dENBzoDNhy7rBT8yayx3fG3uZAzfIODWrePjLPg8S0juDR554CB8Vc7zowpPRoLdENgc2c+gmr+HnVvLamvteG9ZgqqM37qaEEDW4eB67nlGEDpz5aiz5zIKyeO6N0m3qftqrbwcOtJnH/F2t5ld+68gqb3YmdtOly4Ma2OEdZmvt99QVSqY9UvYWAawfHCKQaY4gimg9729fsYZb+RMfvyUOv3976/hwqCxYpQkIuvMNUkOVBM5fZQ75QhgSEZg6Iv0AwBr2aJmtHz6zLn5a3l1Kue4YpN38PRpMRMAqBbQivsgulo1J+QRc7mKrTNVcgTx4LhwCJobOvOpdzVR3rh1SzU+0xBQOd7SUy6qopny9+P7SIioEO34XpuOd3fnDekYnwHsL8rmXpXKvn2gYa2RdDIkN1cktRB/9Ibm2DpWQb/l2uguCSU8bHVoUvZPlrmybgapWAGKQF0i4gY6Htwrn0KrockOijh0Xsmc03qerKkoQtk1S20UNZajLjR35utGmoYqsroby7n0yemMb7IFIWVBS0kPSpAgz+FNIsnohbLFwFqdQ1prW14rpqAktw3RmgOA6MkNBlEvdrNzzZdjm9rGtY2YQADoqVTwLLJziubF/D0OB+Z85/gGHtXyMBds+ZmsXv2gOVDiXUNhX3Mf4LBSQXbIu/wZYchxG+ADPZ8QEpKSpCTEQlWq7W38XvmzJmsXLmSu+++m/vvv3/YLjMSjkov9sOZTh93ZOzklvQNh/tSoqLr41yKf3Pom/ieH5fDDbvjoAVMAC2KC+9xjai7+mhzdbebnH8sQUyg6Tu5Vifzwfh47mOBtV3ggn/e0fvvi+BgHMBpTj8fzAjVXBqMnA+tlP8jsf6Cr6StDqk3s+OKf2F75tCVXgRh6hj8Pcragg5Z6/yIYRIHnhIVIT9Gwy3MLWpuS+atmui9ECubS3mtcTJlliSW3vUvvNmxZ1naxljxZsc28ekbtyIqAqPsDez/xUi8Wt95PqwbTcNPy2n4aTl3ff/+IXEwDgWKvu1h5bOTQ64rtTVHpd+uuvo+vnrpu3GdU3ao7Ls8gGbvm0I1u0jzZAvhvNK3vnkcl267PK7zxILaE1Nwnxr69w8lRl75Of5j9+M/dj++c8M7EItfncKa1uKw679I0No7yP37ErwVfpQJHpQJHvTy0A5Gh+7lmM9ujU2jygDnZjs3fXwVf28L3ZB7+rprWDblaE/KUQwOhmHgHwK2wURxNJMRAy6YvYpPS0aSfNfQROqHAxU/2cC+66bgmRM/K0S86DzL4EzbqXTPKuXj+x8Iu93bO8cxpbCOiqSho/cruH8NAOrMsdTPP9xKGbHh/xon8fEv5wUtExWDHL9p3TZNtg5pGYkhwl8e/CcTrDLhCz8gS3Kx6pj7ALhq5/lsqcsz9wcqvr0PvD50vx80jTUnZgPgeSqFBTk7I55fEnTuyFx9xKXC9QVTMULoZnSOUbF0SFjb+qxDzzg/UoR66/6Qq5wDNA36QwnIPFc1FYD5Jbt6I+66IfDCdrOBWNcFKvL6GtSf+cOfOfnROyj6MLQHpDol2sb00OVGeXdUJ+y/fR75963G8Psp+8NaHlp6Af9+8K8UyH0G0R1ZK2j9j/mbS2QnX6QYVOE/17B07Wwq/xK/kOgFO05m8/68IbkOQ4DGaTYytqpBQnwHoP01l5En3sjOy/41JOc7gLbRMp5rK8l8eOiDKaGgtbX1jgmtp1fQWdb3rgwFU99Q4K2JT/LoP0bzwq2nxLS9qOhISzeEbOQfc1sVO380EWNEaAdjR0MW81qvA0De6uyl1o4F/9kyl+V5I3hhVHyO7hcVSS4fH834D0mHsUwsURzpFLY//vGPOf300ykuLqarq4unn36ajz76iLfeemt4LjAGHHUyQsAhWLkmfSlPdczEp5ulDql2HzqJOxn2Vo1XH1nIKVcvHZY0su52D83gXutgzKLuiBo5WlsbAK4lCnPvuJHUr9fS2jWwBEDXRLY05dIZsDMzI7ZGxHfqxpJ0dyoWI3Rj6oGSAMvGXZQ0ZoEgsPfsnCNS6Ov2/1wPAlg7IbM9fCQhbacGAkj+oWt8K7PoPWJ8kXGg7G3Hu+WUvW/2XQiGgdbYFDTCaS2tAFh+U8rr35nAc1MjZ0GiORg/K36NW966nKTTho+Hv+1rlXSV9GuGTjZ/T+oOSNveZwXkLJFoHwPu8r4PSLJGV3kxAGmXw8yuRfhgDENAU81nsWp/MbLU1wh6YPkJo7bxjeyPAbNsokRO4vsXvci604vZ485gz9PlTPnqRpJl8/23iSo51k4eeeLUqGVVhgCaDQRBwAB0jwfH8h1c/pPv8cHv7+kt1bAJFlKH0a8oeKOe5gV5eHKHrtyg5LUW9PoGdJ8Pe00LT342j8vmL0UUDGa7djLL1ki0ZmuPau19DvGi9kSJnJUSjkYF0a+TtkOjY6REZ6mMs1HA3hI81ktenbxlEqOVm9h+1X0JnTMUDAkCaQKdV8wFIOODXaj7G4bs+KFwYEyQvUbYbODhRJJo59LkrWz5QwEbfzY54vhq6QogVtehqSruC+eg2YLf0dRnV5E9vYGKtCY+qx45YH9DFwn4zY9H0IhLZE5TJTxqcLnURTtPomNjJvYL5uB8waTZH32vwjMXLODS04ZOJyMIhsCbe8exsKB60ILB4TA6v5Hvl7x1WPtQ/pfR0NDAVVddRX19PampqUyePJm33nqLk08++bBd01EnIwQkQexlPDiAbHs3q08oMiOLCXiykk8nc6MfxRg8Fe4TSyspXT884SLZLWCsjK1cTGtpJe2ZVWw/fRKiGPqm+LxW9gkprBWLAJicWocYgt7zycXzsLSJuGrB8k70aJzW3gHtHSAICEZOxEcSSBYwDqKclJo6SK9yRRRjSxSCAfYmg6R6Nag+OxysHUPndGp2kdaxFu5tncp16WvIiaH++1/thWRu1hCWRleQFT/+nM7rpg34PuLFVJuNh8Y+zu3Mi77xQfCdNZvG6aGHLlGF9G1mBLllqoGY0xd5PGA2dBoOVIcNQYfMjX6S6gKoTitevwVdNrViokFTRWizYu88yGA2QGu2IWYGQtLYhlM+H+eqZ4Yt2NC4NnU/pO6nXu3m3LOu4d6i94NqtxVD4/mF09B0kZbq9LgEKrW2NlKfXMmEY28BWefKaSv4dc7Ql4nuUrp5sPE0oBttxy4y0pMQVRfdhYPzZqQApG9V0LbsAL0nYxBQcNZKvLRzMoJgkD+unXNcw5vZFfJ9qHbTYBJ0sLWrYEgoSaB1hHam7M0KBZ9JzBh/CR9Me3TIDC5dplel2ja9BNcmK+ruvQkfTy4qRCkZKPgqd/jQNg1v7f6mQA4WoZESeXDjTJbk4u6CpYy6eBIoIhmrZXKWtKFkO7Hu66MFFdxetI5OjHlT6CqR0A5qkUiqnMTxeas4JmkrNV0ZdDzfFyjoHAlCYXTBzkho8bi4t72YW9L2cmvdHNasH4mzTaCzVMIxr4/+WfIPXz+AYQh0djlRdSlSAjwqnvx4Pq69IkKGwSknrwlaNzt5J8c5vsAsUgaHVqU8znM9/PDDw3Mdg8BRJyMCsuQumtVkfLqFLFs3KVNbMD5JOUioKT5Ud2cxJrkh4WzGh/tHM+YhN8bqTQPW2Tp12tutyGkDw0qCqJOREn7CbetyEmi34WpL6LIiwuuxsc2TC0CuvQtbj+qtV7Owtc0UShtzfwf6+sgCV4nClyGwb6FpbJfWF6Lt24+6ey/Jbg9tFWOG5ZwpexJzRgcL1SninenhPxsrKZ/RyEnO2rCNppqhU6X4+PuW4yhoOgJDkQdj9iQQBRq/6mXL/P8OWN2t+1jld3L98quBCMU+RV48RaBrAq56K7Y2lbTtAdK2g+YQ2V1izrCSVQ9yFFR/v5nXK+HaN/AMgg7OOgm3Q0Z0qGGd7/5ISfaQIYVXGc6Xk1gxbREHshwHYBEklk19DoDzkk9lg1pmOriNMRrwukbF9Sab13O/XEDuhX1G1zWp20gSB09+scZfwAfrx1GBeR5j5QbS/WMJJKcPYMMyRLMJvz8E3XQcA6l999HSJeBo1LG9aR5TLiwAmxU1JwXNCtJKM+O8KHkGC53bmWw9PCQeuiyg2cSQEXTZrZH212Qa/qMPS/aoeZIFQ8rH5fFheDzo7vjY4aT0dDwTC2gK0RPgbHCS1WyO21pjE5ZuDYu7x7HqeUX9qhwT4UE4rHCPRBJ0SuTBN7NLgsiu08zM60jvjeQ8VYfkHIG2bUfQdqLT2TtPHIz6eQ5G2Rs4xamwrWAtr69O6QvG3VhJ1yDb8do7nfx943FMmPEE774zHWdP8EKzEnRN/jyFGk/msFLZtisOHFIgYRtlzIPtiG4vuy8t5B+F0cWOj+J/G0edjAi4Ma2Ohzvy2OnLYen+MjLOqkI7bjqGmFg0QTBg12vlqGeITE2rDRnRjwSvZiHlwoawE0bq48tIqZ5C9S1ikHEkCAapSb5egyQU5q+/AGGRA9dzw9tM/kn1qN7/1vfbGfUdU+gp4diGEN8MvfuSQopfd2Bs3AqGgaATlpknYRwG56L31P1ezZ+uPpctE1bys6zQEepGzcM5S24195MEECUw9GEtOtWMviet03NO6ItGh4GYnMyiFx6MaPi+0F3Er9acFfO1iJJB4/l+cp+3YWtTEQwDQTVwbTWzDe4yFSmlz/lyVtliZnxy7bDgHiEgpoZ33oQeLvnHJz0SVnMlVrw0+m0YbTLSHPvPO2K+zgMo/dlSXvtZeu/f2dvyuTipBSnO7+tghCo609dvJW9fJnuvGdP37Qkma482ql/mSTBQOq3Y91m45PS+EpGnPphP8R9XgSxj6AY7birtbcY18CCtd4IBze8XcG7trb0G5nAg0pfiyRVQnBYyth6epsuW8TKdpaPJ3OhD+vjz2L9rQaDlrLG4C0LPc55cgT1fM8fxkodUrO9+Tm7zWPacnoo61gxkNbSmsEYqZn52/OWQSk/tq0+34jdMNXObMPgGaMXQQMdUSF9x0JgoCAjW2M5xW/purn7xAS4tOxZDVQY2+sdqHgjB2yoBmVsfuDGi/KCr2sKK1nGMOH2YSqaA5TUjGFe4n8mpdXHv69dNk3LzT7OpOvXvDColchT/EzjqZETBb5afiWObDVubOUBLH38OsyaiJoUR7gsDzSHSMt6CIULX34t5+vhirlgYu0G/tr0I9+8KkWaFth4sK7aiezwIS9dTsT2L7Xf3hVbmjtjFwyUfEumD/2jSIqaMu40vjkoISFmZ7P3amLj7MWpPzyBjxGzsr62g8K8r2Pet2ehD9CXIHsjc7D8sjkbLRBvdc7xBc9xTW2bwtDAj6r67rjPg2snQZOt1/IYDx264iKaOvhII9VHz4Y14RER+f3XIfYz5U3ny6X+SJIY3xK/ds4BPa8oTuqb9FwRIXuwgb3Eb1l11MNUUkXDVyAQNkXE+U9duGX+GBEUDSynyMzt4f6Lp9FuEoSMwyJJcrLzlb0z977ewtideWvHQjefz2M/288aYNxI+xg21lXxYPTrkOq25pffb6xqjICWZEe/+V1yR38iEsfUD9r3o+GV4l5mm2BvbJoHgHRTN8GBQ+KQV2XtkZwENUUA7dhqWldtiymjs/2YlegwESQBb/lhuCtIJIIieoOdQ15zGsy3Tev8+vnw72dbwGbsDWPzrOVi6NVYIs/i7AIjw8v33DLqs7MRbbmL0a6tCfsadl8/h/t/+jSvuC830FA7Vf5iLUegL+t2B8R7E3Y7I358Avkle5DgDjUOJRdumoWuhgwhb9+XS6E6Ki9K2U7Wz/VgrunsrY26wMv+KW1nxu6HrOzoScLgUv7/IOOpkRIGhCQg6qC6B1msqyXh0BeKmamyShJCSjK8iOiuJL1OmZaLE7694DIBGNYUK637GWDpRgIfb5qCFCac/+9YCUraDpECSEgibRdEnj0LQDMQOD9qOGkb/2oxKNv0Rfl34BpZ+6qmvuJ3sU8z1omDwjdR9WASJP33139w2+grG3LiVHXdOYfTvt/Y2ecsjSpjyYg1rj08fNuGneCBOHEtjZXpCDd+GCO0jZVyXziX5mWEwqAc5bxiywOl/+RCnGOCvb55J6euRSw5qzrJgWAwMuzJg0jJ0MabLOVDWo2f7qf59JSN/uhpDCW08CQ02/tUeuT7g+tS9QVFwxdA4edOFNHe6giY2sUdpfdf5MllFlaQ/GtyP03DbPK698XXSpciGuGKIGHpiUXdBMGifqgDp5KzfSukTu6m9uHRAXXbcMEyaY5/VzrPn3hO0yimoQ+pcBB1btPKPix/ihk+v7s3KxAvRr9Hyn1LKT7iW6lPir/O9YMfJVDXnRHwmhqbRNVpFcqkDnIQZpXsotLeHVJm2CBoW2Vx+/KgqlteXhKUNtddYKX/hBgA+OueuATX+k/52M879BpYSIWadjP4QdCPi9646oWXCwGsTVYP0bYfOOYmUfd/7f/OQZ7bh9dhIe8+BbosuBWCI4BkVQHIMfHa92xykKbC4tpyKrMYB+hpPfTCf9E1926V0BHoycX039rjff7f3UJ2jdKovjp2dSzN0TrjhRpI+24Z2gDlKlGj96uxer9afJnDeK98aoGvRH79+7QI+mL+Zx0o/6V2my8aAigQBUPMDaHYLjv0D33/dCt4RgYQdDEunwNPvLuDCkxJTYV/VWoLxwwxGdpulaPtOysI914Omioz9g7s342XIMkvy5jDvj5FLnp5+fz4jn3EjGGC4zQyRoQSQlMOY0j+KIwZHnYwYocvgyxZQTpqGfVkVWmcnYiCA3WLewrY5+WjW0MNt63g45rj1nOc6EMU58P9JaIbOiclmf8XXl16Dc01ftMabY5C5wcBVH72uVXWakT1JFrEoRaibqwCwyuVYgPe9fdb4Nn8+Hao5nEqCzvtek4WkJpBNZkY3TVdOgWIv+y8dy4GSWG+2wOu5r1D2h+sRAiK5SwRSnkrcQBd2OyhaEjxAdl8yl/qFwQNT2Ysq8gcDI9x6khVfRuJevmY3ezWSgdwVXponOVCSEzuWN1fvnawEVUBJCjYqrB3EXTJxU9omkkQ7dScs4an02Ti3R7B4c7xIMdT+xwJRMoWmBEnE6PfaCbLM3jvMSdk5qo3aQGS18Pe9jUiCTrncgV2AvzQvZF9LatjIjJThp3WyHbmf41f/nXmMv3BrVJ2DP7SMZnt7dnw/9CDISQpKigUMA7W2jtwV2bRMdOBPG1wkyVugcezMzQOaug/urxhqnOJUsDoVwIYUgOzPfSGpOSMhqTaA9pmVCclXsqnyiajb71G7ubdlAQDbmnII+MMXfkhpqTSdPx4xyTegtLMsp4VCe3tM9fy5tk4qMpvYJWXQ2WWOad48HXujiKCB5AfnXnPsu3D910my+enw2unoMLctWa8gBnS8WTbi6R7QFBHXRjui2uco6BYBd16wToYhmY7GwRB0ge4iK1duuIa/jX+a+fZhpPWKgP23zyN1fgMn5lexx5vOmuwoUvCYRrIvS0d2xPc++X0Watoz0A2Rian7AHhiSSXZ6wSS90Z2uDI2942f9lYLFTlfperYR6Oec63fz8XP3s7It1ejKQGkUWX4RmSAKODLFoKcqWjECfYmkU/XjeUaweBvRe8AUPShTv08B0ZpcLZSsmqoqQLeECaWYTHivnf9IehgbxF4btM0BAFG5jUxKzPyGHkAL+6cjOPNFDJXLOXA7Jtns9DRnIygg7bJbNSWsrMRUpOw7Yen35vf97uKPcwq3sP65/vUo0s/98OKDYezSvjQ4kvzQ4cGR52MCHi6Kx2hn3FuiLDrApHcnPHY2oPLlnTZjIYcrGjrzdOZNbuKh0tC11BKgtgrWKZ1Wcj/tAtWbkRKS0OZOAI9BK9/JATSrXSNyCct1YWabCPZ2siGQDqfdI8Nub1miHzYNZ4GfwobWvJp73TC8eaA2XVM38BpdwT4xAc7zrofSRCZMeIStPrpSJ+sw1JtJ1ASiFlXACBpN9hf7eO014+dRtcVHVTPfipouzLpG1R0TwqqoZXzcvGkJRah7Q9DEpDLSlE/W0tqykw6Si3xORoCqE4DIdcfZCgFDgrye1ts2DpNg8u5P3YlZ4Df5q7nlGM3cr396rDbDLd5IqWk4Js9mrMuWRJz5OzA+9bu3I1dDPDS1ilR9jCZeupPsJC6bTz6+m2Mv3ArT5d9EHW/Z3ZNp6t7aCkRhcVrSXXNpH2kZUCDcqzw5upMnlTDf0o+HdJrixVl2S3syHaSXCMifbQmrrlR6vZjiAKp1QHsTybx69Hm85zoqA3bpL7OO4EXtkwNcTADcep4jI1VJrNbVia+qSNoP9k78N0VjJgNpgMYm9xAt2Kjs8tplrnn+Aj4HEgBEDShV8PE+2kW3TaQvZBTq+NsUDjQDWZxG3S32pAyogcDVL+EpcFKzmpzW1+mjCEKCIapsB4LDBHc+QJ8msWfkk/HUvIas22J9x1odlBS+gYWa5sYE6V56fnVTE6toymQRFUPCUck6FYIpOpI2Yk1ZHd1O9gDjElp4IO6CoreE7C2x5fRcdUr2B+z8v/snXV4HNfZ9n9Di2IGW2RJZmYKg8PMTdo00EAhTZry+5beYvo1aZMGmqScpGFmjpmZQWCBxbg88P0xtqT17kq70kp2Gt/Xpcve2TNnzs6cOefB+/nZhAnclb4+bBjVg22FbHPlsfZQASXfW4kwdTyi20f3hAxaxw1e7HFWyCztnsi/z61ELBqF/Z1NJOTPpKswtK1sU8E2TFXPDbBvNX/3Hm8OVlkl3WqGwuVaOxAFA4+m0BowA6BXHSxC1wUcSxNIfyI4TNvYuJ2kjb2fpaQkjLwM/Ommdlz4Vu9Eap6awArPGMb9dWdPlEMk2FpU7qqfxQO54enoT+CLgRNKRj/42dPX4DiylgrmQr7rgj9jvTB0Mzj70hsQih10lIgcIWXQFbjrrLcHtMQeQcWFf+HssvORrs7AN7kgprHqirm5defLdJzqoeUimQvKNmOXAhEVjCMIGBIra4vweSNvcl6PhZtWfYWNJz1KgmBj/czn+MNDJXywaDSF/7uS/ffNhyhp/DS19x6BadVc8KfV/CRzR0jbiov/wsKSS0lY0nus7ZRiOguHLloHnFB9RT7599djfXMtGYun0zDbXLiPZrkJgWAyf2ilA8eDS+k+Ws41/2951oLSdYyqXQ8S6qRiFvw+9iJnAOtdRdT7kqNuLycG2PddC6W3RMcI5Nb9cYtbNQQQbbbeWizvrSNr9mTqTkqMOWdHV+DWMz/ke+l74zK2weCdcW9yV/IsPnt8dszn6lt2oUwciy87AWubysd3mdbMf55lQRvljYo16whku8q+71oovzcLtb4B1/wx1F0T31AhzRBNWuEjyPOhAYZLxlEtI/kOW+BzVeRkP93lCiV97Bkpe/3Y2hTqzzf7EGU97Hut6wKWGgujPvb3rLkNc0R0i4EjDNtYNNj31hhuW/glNsx6NuZzDeWwl73Ix3XTe9/Rpz9diK1R7Jm3ohZq2RATEzkSTLn2UAH+5elmn1LkcClvloaUPrREdk0XqfWkkPSHRBgknbvk0/ns2/MpfLiZyxPMGkztem9fT/36HJKfXku2pQqcTnbd5cBanYocB0ZjW5PII/+4AC6Fwn+4TPKQftagcFTWR8MADH1w65hzj4U9tcU9pAmnle4mRfFQ5U5j08FR6H6JcXftiy7MWZRQJxWj2cIveBmbfWRsBv+0YuRlroghtQCWd9exd3M2NWu6yZUcQyaROIHPJ04oGVHCk62z/6pHIQL3w1sv/h2AnzRN5ZVnFgPw3q2/Y1SMPN/vjn+DTWt83HPTHTGdV3mJiJTkR0BFkjUuL98U1Xm6IfDyrqmDEtTuTjvAjVu3cU3pqTGdV/qIhrDSjL0XFAt/3/pWVPUchhvi0o3kLjVDg2rvntNvXLIvxYCCoXGjfxGwoW00+w8NLZQpErp1LzOWfi1uSoZ/sptdD0yh/LZeYc1Yu5VRlZlUfzV8AnMkvH7L74ZcSyQe+LSmlKxH41cFevR7fpon23HPjV1a231fFsWPZMdtLH2xf0cexS+HCqxdBRJNi/2U37SOPY/OQU6KLBTZmgMU/92cSxWXWZFSQ4XppBV20nb5UJ0StYcVJemAgq352AhQXzn3I9x6aOjdtScvB0zKc2FTCuJnm9D7sEtJGelMe78JUWgPOff0S9eSFIE6dnlTCTVNqWG/ixbdFcnUPxiffKR/3XkBP7tOAE2g/NZei3mysQrvBXN6npFja/TMcLEisUbFtyW8J1VXiCrXR+tWcO4fOoMWwEf7emnZtS6F8q+tJSqzliCgnTwVQxh4PTUEAXXRJCybKvr1aKiHGripcDE/2Lf5810f4zBOJH7HjhNKRhjsD3Sz5D/3Yj2yx8zt4I0Zj0M/aWFHtPR7M9aQfUMnb580ho7bJUYN4vrKIFdDAUhM8LAob/iqKB8N5fDvLv/9fgRFwTMhl4NfCd3s1S6FCb8w43C1puag0A1lAF/AsxP+yR83LGbLjJEJhjRUldFPRq7ZcfCmcej53kGFKR083yB9lYXkivDCTmeRhd/86C9BVK3zbT5eXPAol6+Mn0AdLZpum8+oaypG9JoAgTljybdtGrBd3O9HGKuj1tJKwRO988E9dwzNk4MFgpzVXixbKyE9lYx/NJEtff6XVn1PBbbOLLxlwYpB2u4A1g47bWfFpmQLQNcPughoInTFOek9wtKQUBdAeVdm74NzkRJ73znJoXLgKpmilwlbMHPUewaGGBqSKXsCdBZZaJ6vxnXz9KxLp7jpZirOiY5u12cE+HPbWHxG/6Po8lpJWrUjSME4gr4Jyyfl76f1YpPJK5KC8W7NeDpdQ6s5YtnqIGObGr+49sPF0c6ZtpXPXpxA/qVmfmPj1xfQPjUw7AJO3eVj+vV6iyooOw/nChUEkJ3DU0RX8ghIWx0U/buaHT/IQ07xI+9yUP74gah8RWJiItrkkqgUjCMwBAF1QiFKTUL/RR8NIyyV9Ql8MfD53wnjjOe6k/nxhhuwtpovRcLJjdxd+n7UPPbJop2rknbw0MMnkyeNfIaQJBoRN4nhhNbQCIDN5ydfKQr5XvTpqDWx824DjJIT+EraCm6/6Fs43to0hFGGwhDg0O2zgo4JGmQ9vLJfXnlxkM9WdgZomyih2a1ByYxHoCtwuj3Y7mQVFMYrIt+Z9j5/2nlq2LC2s8t20up3sLYqTHDwEBBIEgbFl34EhQmtaNkilQ3pMZ2nWSXeenUeL2f0E+ojMOTQjSDU2Cn+IIwQoGtoLa09H51b7Ngag6254sFGtJZWRJebXY9NZ0H6JAwB9Pkd/SZNv+ZycJq9NS6F7+INI+DH8Icqw6Jfx9GgElhhrontUwLICdEJTwFNRB8kC9hgIKgGSpeGlB48PkEwkBMDRPJMRwppbB1vpXOM3iMsGrV2JO/QBSjJB1JbdNvxO24rP9h+NecVhhZkPRoTMhvY8NPpFP9gVdj17JykzTiF0Gf3iXsszUclqHkDckTK02gh+c1ChPFE6lqFt7XJzBxfQRfQfOt82ieowybQ90VgIAe8AaK/9//hoHZYsLQOrZ6Etc0ga20n6sEaSl7IRrMr2Bq7UOsPDXwyIEhixBCpvggkSXiTpZ5Efc0qIStfIDHyOK/4fTziCzQ7BsYrrgR+v/csLBvNMAf3RC+/L3+dJY7YBJksycnuxf+kP8/HcMDu8JHuiK2y61ChCBJNX54RlGMhqpDyz4FDNKT0NBovHYsifDZgW5ug0TpOxlFTRsARX6tI91xPUNysrguk75je84IrbR70zTsBMBZMNUOlhgAxx4vbYyftqBSUzkILrTPD250UQeLW5DrWjzpAiy90Z7sxYymHtCTa/Xb21g+QwFljR9AIYUQB0PwSjl1WDE1HO3UGrsKhCQSZlm70hNiVjI4iGWedgbNORPKbTEdHQ7eI1ETOh48Z1lYB5b2BkxTVmlo4SmE+cpd0r5fUv/fO/YZvLmDnzPDhEjoC690TWWBr4tgHVkWAz4el2VxTAumOHkun5NN7lOSOcplof4CqSSO6b6oOia7REkTgjuookkk6qCJ5BvYedxVY6CzVEbN7jTjWViFuYTiiX+D/msfxg/QdEePX33TbeLJuMe0NiRCFPaHU2UTWGV3s/qEIRp93WRCZZK9hllXDKoR6bNr1arYymoZA0mB/zoghdY/fZPQbb35unaX2KL2GIaB1KliPA2FNdEmosmEmhB+G2q2gtEkonf3vaUlVOi2TBPxpGqJfxF7fOz+sbQYp+/0Y602lU/5oPTLRy6ei04mQmhJyXLeIBBKC56EvScSXImBx9YqOlpbjz0ByAscPTigZQEWgGx34zpobsfWJrVx16oPHJFdAxMCbYVrYLJ1aWHd+OBSltg3K6iwrGmpAGlToiVVQWP/T4II7FYFuvr70OtSqmoiVnKWkJLoXlbLuZ48AAy9SigCBRIOaM5OHXbsXRYOqW/rEL+9NpaQmDa2llb03WJGT4p+LIQZ0muepVJz/eL/tHhsVSXmzAF7GlTzHxe230t3kjHifij4MoHQG2PuV0FhupVUm/zcrMIDaOwJcW7Y2pt8RDqKg98yxaNGX2UztsGB70zxX9mgjb90RJaS0lNDjhhHk4Qg5zWZDdhk80Hg6QFSFyI43aO0dcDhhVJw/1awMLwno0uAs2uMzG/CqCtvduRHbdGtWEqToDTsNviREX/jxeDIkuhZHfl+7TvIgfGInoU5D0A0kb+S1tmnh8FrHLR0CzzxzGnfduYkEIXhNXH54XN9ceQ1Co5XrTl8+6OuINht6YTZXJ7YRyZNzil3HIe7jg65JYXM+jkfIoo6cmwN9SAn0gHi4qObwwpBAtRso3ZH3UPshEa8mY+Sp6IdJCmy1Sg/7WVgIoFkhdXU9jRemct2E9RxwZbDxvfFYD6dCpG9zI6zYPOixi9mZeIuCjUCGCP4kiY7i8O9V+5jetVx2JWA/YHq99K6usO1Xu0qZYdk4YL2j4x9HlWkfket9vvGFVzIaNRcXPPxdIBpRd2Qw3uJg+QNmsaFxT9xO/ifDV7RJFAwuLd3MqxWT8Xris5kUKwm8ufxVzj3jSrTD9TqORsVdk9h528NR91kgJ7D7q48w7onbkV0j++JpZW52/raE8psjC5RDhbKjCuuh/lnAosEYJYF1c/7BxeWnDFjdtzx++cD9ItPSzSWlm3lh1/RBKbJysp+6aw/39aoNe9Pwh0EEXb8gnz2/Cq0LogVEyr7SFjGsrvPCaXgzBJa/OB0EOPuKVVHVfjheIazcjADIo0eF5GnEC4Yu8ubuSZxZtos0JTqv7Pq/T6FwCIXtOk/x0AlobVaKXzz+klMbNRc/Lz0JdI1SNuK5aA6cPvj+2i+dxsrfD1zMbo5VoUjewJ9a5g3+YiOIUmcTvA3792SiqUMLP4oV7lI/q8/8I6c9dO+AbTWvjHN3dHutaofLL1oKl8CR2uklzmbyL1rJtgXWHia8eKOrwIInM7q1unmKAlMmI2iQ9//Chxl/OsXOK29+mTXTn4/3UE/gOMcXUsk467s34i104s0wwBCO65vw8VfuY8mUW8j4U/8WgMJXDbZaRjFlxuDi55cU7mR1UxH1LeHpRh0OH5/MfJIEMXpLxH1v/YMbfn03GY/FV5od/W47aqKV+gVDq42gK+Ab6wmp2BoOkkNlz+OzkZzxUfgs7QLKZ73Wp843Cvhgwu+IOu7kcwZRMLigfCvvVo3vlyp5IBw610/iBhsZW+OYiwFkv2gl8Z3N9BUx676zgO6xARAN5DDpk5Kis+cvZj5P4UtgfXstosNB3S3TgKNokA1469V5jDmtggPN6RhbesNQXpAWhyScv/nl+44LdqpwUGtqUfrEektnxUaROyGpnnSri88OlEZs8+GBcibm1odUhz4aH/9qISntkRW3hBo/1hesHLp84Pkipvo4cL0pnOa9JXNogcBJ83vzHiYrHiR09ndnsr02sidmKBAMmLPqZkTRQPkgmbxXK80v9LqeNo63NrFh73hmPL1zWMYwXEh7x47z0MhVOR9pZElO3rnzdwCcsvQbQVERR2BtEaElOgUjuUIneVMTXBT6nVVUSf0whdZvjukJk4oXWidYQ+p9RQNDgkPfnE/+03vRmpriOqYT+PzieJavhw3WNhWbGsDTJuPKO9aj6R+5cgIPTnmGH373Uqy/S+XgmRaMCJEK2TnRv9iT7DXMsNUEX8vSwbvyBA40ZPQcG5XZRq6jkzSLO2ZX50SLHc0aX6/DnZe9xfPrz8beEAcLjhB9ArcA8Q2VMAiqwKw8kM7pN95xOJfn84nXKifBZ6kgwGnXrgkJebFLgag44/uDpOh0jlNRHVayNsbneeQ9bSFhXSVqH89P/T0L6C4bmA3myPc1p9vISJtH6itb0SK4RCUf7FpfiOgTsITIvMHvyRkf3oUg68wZUxlVQcIRhWEEzd3S/3RQc1YK3mnBuSdaixWlM3ixaspKoNTZNKBHR9dE9rZk4gpYwxbnq3Sns+WFCWS0+vrNiRB0osq3APMJKDaVGQUH2ZmazcTUNvJt7SHtihJacBSawvKmHePjS41qgN+nkP2qlZTVB1Fr60KbBPzQEjqucFjWOAbjT1nY9MHVuemLWbkH2d6SQ1vH4EKIJZ+BoA5frKNPl/m0vnTIyelDwRHK+j/MeZZfpZ5L96fB+XHeiR5unbqMgCHxzDOnhZ07oz7sRHT76ZiUxu7/SWLG4eNrWwpp8/ZK/2fk7aZFGgx/ZQQI0F5qQbUTUcYYCJoNWpaUkr4uBW1ncI2gxP+XRPGXbqZiSXQMasclTiR+x4wvpJIB5sZjcem4GFm3aiTMWHcVN5Wu4M6UUCq4k2zw2/IXuHPS19ELPBEFtSxndDHf4+11zLDVUK4EbxZnJ5gWkVfU3urMpUnNZFs7SR5kFaPAyR10188l4fnVgzr/aHwjtYp/J0kkbu0kZZ+d9tLBPT/NCv4UfdirZUcLyztrEeYvgMVD62en3835S++kzD9065Z1aSKvypO5qHhrv+2e3jwbIyBir7CQu8mUnl8tmwGyTk5+G6fnBofMqS4FwSuCSNhaBANBTvbjLoRWt4K8W8E3xoskxy7p6bpA0io7zuU7UQ9zvQtWK+4lU+me7EOOoYK9kOelNWAnsar/ehq2xuhm3JFwitWuUu61t3FfzsYBzgjF1RWnoX0aGuYVbzTNTMYz1cPppbuDju/LyuTAwUycu3oTiw9UZyELOpNS6shN7+BQa1LEEDqvx0IdSWyR83uObd0zGtElYQhQvCnM3BGgbrE1qMaNIRlESvw+ArvDR4rdiygYlDqbzNCbCEiQfCQ4zWtvGobIzcSVdlKWV4ZVMI7AcHt49p1FnH36BlKU8Gvz65WT4NNUct4IrvCcWOFh/PLr2bnwX/2Oo1FzsdXf63HLt7VTaUmjjcEpGR0lIqAMW7ijbgiDVoDijQudbgKl7/Gj7ouQ15v5Cu6JXr48eTXfS9+LZui8vGAKui7S7bKhentFsQZXEpLXIJAoQIv57uzozKGuM6knpFkQDLY48xEC+pDlUKPLhaXZhi/LiT9Z6Lc+VDRw5QkkpzhCsgnkj9ZTZJlNqfVGADad/Mhxyap3AvHFF1bJABA0oyfpSrdGrnI6WOwPdKMhkCZCRoQEcs3Q+XtnHjnf0/nj/57GnSf/I6RNh+6hS0/BNc895DSgDKWL0+xV5IYpEjjRYic5aQuioIfQFw4W2+c/xWzrlRDnUEz1QCVJHZ24M8cSSIptYfQnGwSyAqRmddHVPbSQq8FA7bRg7RgeE8Wn7jJKr98YFwNI9p9WUGdbAMX9t8t/VcHSrgK9Ql/Jc6aAXnVOFhxWMtoDDnxeBblFxtommMmFg6zrJSf56ZqpkveqQn2qBS3Vj6REp2ioLgXBLSH6BbIeWtHDDCU6HFBWSP1V/kGZHgKpGvUL45vY6KyUebVtHhdfvZ55VmKqmrv76XHk/nnFwA0HAdFmw5g4BoAr7vogYmXzR/Py+X3LBYAZKuLcbWGPkcPsmVWclL2P1zyT8HoVjAi0tl6PhR01uejNprBV/owb+WAz3rGh4Uq6IuDOVrjwohUoQq+C6NNl3q6cgN8nh1VoFItKXlIns9KqY7sJcYagg6XTIPPJtahq/9UN9K4uSr6/kg+fn0x6oossR1dQaNmGttGI76eSFeb5Cys3U/LNHFjf/3j2Bux83DUh6JhVUlEsKgF/7KKDf7Kbbr8D+0hG0ggGmtX0Io40LkvopGzO41y7/m4AvjvrXW5LMcOZJUFk/cznADOpf62nBMDcdw+7Lp7aOIcx/zDgFNhxKCcoz8QwBHbXZVPmc/cW2hME5MLRYceiVh2MmDumNTUh6RpaQeTwxXjB8s5axrxj/v++zTMpsLT0fOfpVoGRq/E1KJzwZMSML7SSoXRpZGw1X9HmqdagGGpDAH8/dRIGgmboXLjua/h9CmeW7eLh/FVh2zVqbp6fUoAR2AtMDekD4N+d5TywaQiZfochCTp3puxHESLHeo+SE7g9ZS+/aJoRsc2xRMDQEA4/F62llczHVlH3nfkY0uGw9n4e2REX8A3nf8yPM3ZREejm7BV3jniBu+KXdJT3QsMXBMP8fYpwfHjXADBMC2E0eSv9QTcE3t07HnmXI24bviTrNFzmI/85Cw0zrWhjPAMq4QaQ85FE0jOh72Ng7jiqbjn+En8tHQJf+8vX+eTO+yIaK45GwBhGFi5BQJs+lvdeDDWIHI3bUmq57VozyXjsX29H6Qp+QhcWbePNqom43KE0qkegumXK7+rjCc3PQzCMkMJhXaMUlnxjWcj5VlHl4pItvLRvKgG/jEFwcNqs/GoK7JGrFveHeC4dlk6DjMdWxvTYCq4wvYw1X5lP2bd6pffAT7PJ+nRoCqYWxs87K62aLHsXqyqLj59qxIeHETBC101R0QmMcyNudQxbxe/+IGEMGHq00Cay0FZJwND4v+YpaIdPuG76mt5s74EgCIgOB7t/lRZ2DSz7Rjdaa2SSCiHBScvEOIqDUUyNVVMVVpHT81k1Pr+kGCcQGV9oJaMvMrb4QjaML932beb+ci2/zd4UU1+NmouTVt7WY3n4YH85i1ryWDblpZC2uXIC/zzwMV8+/+aQ72atuxaPT0HXj5PF/DjARadeSfK+PrSqgsgrX/8d2ZLM+TuupvnD8Ek2qtNg3VfvB8AuWACRYiWBTYsfZ8aKm0acjSQcCn+5jiWf3cqH/37yWA+lB/n3r2HNulnMu39oVLYaIpZh3OjzP/XTXmfvl64UoOy3PvSt/Yd/DRZykh/3BBXHjmMfAnDB+TeQvXXNsOgZtd+bz9I7f0+sdYDWf+V+pnx0BwSCpa5zCnaEFWiPwKMpvPGPXmkreY2NnL9txj+3l42t+iwLF57Zf0jmxWO28Orzi7B0QPfCwYV/Ho3zL17Ji0vn4qg7toGXqf9cw5bnep+H6NnUb3sjEOBnTRO4J31D2JCVf3ZmsN8XnkGswN5GZnk3r+2eMqQxxwsHrhJBV9l/cRb8rve4tNdB3nI/hgDNUwafZzAUTLTYWX3nH4DefScSFEHifzO28oe2MjrU6N+t9hvm03SGabmRCL/A7rq/CCgidbk17kQs4VC/0Eni6HkkPhveuHoCXxycUDKOwAgheEHy6nz48HxmXlje49qMBpphBLs2dZHmTienbjdpIh4ueyaogniW5GThvzZS8fJplFfeztrr/8DFO6/G5bFEDCP4vGDMc7dR9o+uEGGn5F+1TG+5g40/ip7GFkBweUJqbySKAgmijT+XP8PWwvBKhk0MhN1MHaKFf87+K9/efRWNrcNfeKroEQFl237CRfsbAT+St/8wif6wcMulOH6ZjEjs8fuRYKgqom9oBfkOuDJYs2IctmFSMGrOEEhfbyGpWsX6Ru8zTqzyInUdRRCwpzJi7ZZ4QBCHyX1gwJzX7uaBs/7Fhc7IAnKN2s2XvvZt7Du3og8QcjNY6BKD4rtPEG0IghGyFoiCgRj2jTChCmJQzk37lADee6aSt6zXJWZIDJhMLgoGGODONfjXPFOR/1vzIpLkwZNIWEU1dOMYBJIrdFKWV4fhMIsSuobujl5x0ts7WH7HHFr+6GSSM5SRsDGQ1GNRDwe7FOCkkn2sOFgcdf2byaNq2V4xDCE5h8k7DE+vgcG+3kHyAQ1BNRCA1D0qnYXyoFiTBkLCyY08PO6FyN/HkHcgCSLhylUuLjzAmvoC3Ed5/PbclIbm1JAHyEk78v60zlDxf3cBeb8bnjDKIzBE853sD6nL08ixdfZ89ncbfHLSsA5r6DCE+MfVD3S9zzlOKBkDIHm/n+aPMpgvX8bKqS/22/bF7iQ2ugvp1kJd/5oqUdNkBqB3lYZSeP44YxfPuk4j/41upju+jZQZ+8ZX35WERVQZl9gQ87n9ocmfwD5XJqTtj/ncxAMixsbQJGS1oorMDSlR91OjdnPyC9+hvLO3Lzk/j133FpAgmJaZiRY7Ey2xhz3MsSp8uXAVL1mms/9QZlTnqF4ZsV0GAYRs74DeYV0TyHjPhrxhC1o/9SuU2lZKnr+NnZc/iFWInup1+tqrsT6Xgrg0/pYjpbaVl59dzEVXLgsbNlVzhkHWSgsJtcH0lPULrZDvZntTDrbm4VsspTQfms2O5NFx9GESkncfRGtu6efM+EMQwZOjY2sU4+61cVRLNKlJQKgwefHes9m64XDyzFnAWdOCGxhQ/uMtMQmi4dB45wKKzqgc9PmXT9rIQfcgE3EOQ04I4CvRafBZyVrfP7vU0Ug6qYExyS3Msx32Mtva8OqDp1QGSC1uo41UHLWD84am7NNI2tbSb6J3vCFYLNQtclCoWaj2pQ98Qhjk2joYk9nMzk1m6fGCifU9exyYtOc5ib3F2Qqcbeyb2E69J5XcFfGJmbTWdpD7fobJ1udyk/a2HXeOQFKVhqWjD3tfl4ajQcSTLhKndMMelCS3cFIcnZcLHHtZ7y2i3p/Scyzb2ol/Uypp+w8rVCK0nuVFyPXGJMTJiQG6yw06vjSP5KfXDqvBJRKk7Cx2f7+EDYX3kyz2an2dXTqPjfhoTmC4cULJiAIZm310tWZx32gz0fHG5C09sdGaobPWZ774/6hfwM7anIj9HMEmbyF50p4eursj0Cwg1TRR+qxIxddjF8raO03rYryVjBafk93NWazK1ZhtFaJOPv1Z0wTszZElAKnLxz31M/hdzroB+2zVZQre0/Au7A2RaC6U2X/lI5jVroeGW5PrqPenRK1kCB4Je4M5Zk+mENaCbdTZEAPmc7T4BFL+tSKCM7sXatVByr/TwD/OKiRJ7LXMKYLGZQmdYc/5YcMUkh9LxPrW8Lim1aqDjP5DIy9Nn4ooGozLaghKMr1uwUr+41qEau99DorLQJnZRoKi0lyZFjGwRnXLSA417nVNlS4/DJMlvz8IgoGQ7cW2y45qFwhjbxgy9gRcbPAGU1fu/mgMY59vpmNiKsv/GH6rXrjqNiydGvbqjohFMgdC7uWVvDX2rUGdC/Db7E2s9/l5uWNmVO19ukyDL9TDKFk0vFPdyMvAkKObPbmWdp6e8A+KlQQ0Q6dei0/I1Dmjd/KBNJZmfwYYArYWIep8GHuTQfL6etTKkUs6l9LT8Mwew8XXLB1yX50+G3KXgOo0mJF2kFZX75s+OqWdaSnBNOkXFm1jmWMMHYdyST4w+JoZgmEgd/nRKw+SuHsfADqQ/voOkiaXoCuh+4nJaqVgyGLcPBruPJ0SZ3N8OjuMeTaJWrUjSMkAyF4dwPr2WgSrFWH8GFrOtCIMYuGUHSrN56qk7ByHsLNiyIaHmK49ehSNZ45m/1WPACNPujJUGEbEtJZhu97nHSeUjCiReNDPO988BV0RcNzv5+ZkkwWhS/dzw+o7YkqCu2/jWVRPSOcnmZuCkny92RoN5xXTcVr/ceUDIWBIQewqwd8NnFgcMHrP1Q0B3RDweixcv+omNp70KAlCdGab1ddMImlHZMFX37aL7fMs7NnrJf2oehVZRyW4TrHY+Pivj0d13eMF5Y81ou0dBFuGKPDgkxcHuZs1K1wWoUL6pitLse7fMMhRRgfD56PwSjOXYfsv5pOzpCvo+7NO2Yh4ivkMnbKPl3dPwXBb6W5MxlEfXoEUdHDuteAebyBatKgVDUEIjW08OgmYjTvRjoGScQTZL+ym4/RyOorjG+7Ypdu468AVVL9TFHRcAnbencTWJX8Ewr+fyx8wE7BL3ruJsXc6B6wIf6yhGwIHPamsryoI+c4AdL+EtHEnxthiRNVGp2rrN/Tpy0l7SRBNw0634ePR1vlxG+sZebshbze6IfDKS4sQ1H6IKPpEXGQ8uyWoPstIwD13DIt+NXSDRKdqI/CPbLTzPVwzwaSquqBo24DnLcraT/vX6tn2v2ZOhxjQY/JGCYZZb8NYF3wtQbHgm9F/OJa9KYDilmgdZ4o+Q8nT0BX4+wWPxtWLEQ2k/Fz2fNeCOISMKwHYf49C6a8KYNuu+A3uMAwx9N6KNhvV1xSw9a7YQqRP4PONE0pGDDBEqL5e44+bT+OPnNZ7fBBxc8/tnMHqliLeH/96PIdIe6eDV92Tubx8U8h3miHy25bp3JS6moIwFLYAFYFu/t4+t+fzx4fKaG6Ls3+5D4yAn7tKgotDSKnJvL7lg5joOv9bIOdkU33DmJhCMV/95HlOuvdOkp4emSS7ov9dxf7/Df+dPCqfvb9Lj+mdcOy04ipUkVOis2yW5jQxIzW4nsxLW4dYYORzgif+dW7E75x7LcyuuZudt/a/ie8983F+v2osH00+PmoKRMKKphJqm1PCfqe3Win7xhp0w4CN2yneJLD75UnM/sumER3j0RAFg4svXcYbVRNx708OWxfFn2RgFJmGJEH5fG7BTf4E9v5wAvk/2cfpg/CcpyhuFvzKTNR/5YVF5K6MPnxK7vKHKBixQHZpZK0/zCo52RqxeGZ/MCTYePsfYwpp/UJhVgcN5TaS/917qPmFAjZNf4j+kt+Pe5ygsI0Zn88V7hjAlypTe6aBbU/k+AdvnoqcFCooqe0WbIeCb7UvU0PPHJ44dV0TeeXAFM4u3BmSDKkZIs92TmWxY09PXPIRfOaF1e6pPQl/b1ZNxO0NDkU6ddMNEYsB3lyynBTJxQ9fuwaAxNNExMXB8b6Zf9+A4TtqQ+kTF6qePpPr/vzqF1LBEGZOpG5ucoiC4S7Q+M+5DwHhNzRFkEY2P6w/H66uD0rpttfK+N0iQl6oJdpqC3DK6H29baXQd2zGeTtoPcNBQ3cCKfcPn1J8zDHApiN5ofTp23j3it8zRglvSJAEMaKn83jBsh/Mw7G3mbzxFuquCX7e1i0OCv9dhdp3HhoG0oE63v/DIk759sqg39cacLLhgWlc/n/rmDYM4WtH40jekpHlw5UWuo4JkoHhUpjwywbUjvAhkMOFuu8soPD8iiH18cKeaZT8jwfrwZ14teRB93PkPh15d5tcCST9IfK7a91+EKOrG0MLnrvq6TNpL7UgaMQcgpW6J0D3KBlvWnRrljS/jYenPIWEMawKxjmOZvLlNt7onDZs1+gLrbaewn8GqL6+JC57iSAQEsolCMYXcl//ouOEkhEFukZb6CwRkDuMfjn+LU0SAdWKkOJHrOs1j1i9ocWALK0SFbtymeO7gjXT41upzjAEfF6FVU1FTEhtINsavJF1qA7We4to1IKTYqv8mXSoDgKGxMrG4rDsVkfyPsLhmZrZWEQNXQFHnUjACUcTZrvPmYqggqO6E31LsJu27SvzcV5Xxw1J8Y1xHQ5YGyVyVns5NDc+vnJjwVTayh1hkxKVdpGv77h20PNEHj2KugtDQ06OIOdvm2KKy+26ah5N04Of65gXujDWbUNv7yD3uVHUXhZAlAz0RBWvJg9Y6VpUwdIhEtCD43T1PC8Tsg5FrGp8BEWOFoocLXQm2nj92qnIZ8+m9Km2kDk23ND8EqNeltC7XSRvakJUM2grG0F6ZANsTSLeAahdzkjYwcNP3T5gd/bN9mFnogmH6vNFpK4crO0Cuc8Gf+eo6UCtCWVEwh8godbPa68uCBKURBVy631c/tK3+NaSt/lGatXwDv7IdSUDUQpV5oxaO6M+Ukc0D+MI/KlGSJ5EJDy9ZTZpn4VqZdkNGtpuM3RSMFKGPKaj390QGALpq2XsKcWI/lAtuztPQrMIOBpjZ1qQfDqOJg2lO3h98mSIqA6T+nzhWb2U1+embWGhbfgFZYdoIbFPTt6bTywmb2fN4NnHIqD6gjTyk6bCis1oTc1AyZD79E11MzWzge4UK1U/XUDBT0d+/TiB4wdfSCXDlyIjqCKSd+BFqb3UQvdoCCRrA7KHKN0CgiHiFyxYW/o3B8hukN0SrrpMfjV6LJKgY2mViKd/rLE1CZus4lItyKIWVHCq3p8SlFhW7UlF1c3f59cl6ltit1AdYRYRM3z4XTaULiEk1rZ1rDnlAgkppHYXoR6o7PmuebbOmomvDnidNb4ANkFjiuXY1CNQPTJJhwyUtbtJypmMIdpxlwSQnabXyAAs2x0I7sao++wstuPODj9nlE6BrtWZ0Rdm6gO5qIC2eXn91gXw7puAfX1FVExM6ukzqV8SMAtF9cFL3YspMCair9+O/ZU1GBfPBElDtqvmxtg4cHK+6CfovfFm6iQleihPiP4+Jslerpt1OAyjdTGjhfHom3dGda7S4kbenYY6dvCJkEZAxP6qWZ9C27MfZ5KdtrLhp0aOFVMsNvad+rcB291RPo/1h8zchdRnhzfvpy+uXWgKJq9WTEbc6sRR0RHcoKwkfL6TAXmfhbcEFb4Z4MNZ40ZMyQgHo9ZO5gYD69tDqzszWCTth5f3T+GSMVv6bffi3mlkvm8l5V/hayoIsoznnBnkWvaF/X5QY+vz7oK5Jx3oyMAA2g/k4E2PvP8qLhBVA1+qjLVdjWkbVTo1lM5gZdCdYyWQZOBP1XiyILTA43CjUXNRq6b0fM59ZhdqS2vcr+Of7KbzoJ203Wl0nVSGa7SGvV5iKI7O6QUHe9bsjLNcNP00PmM9LnCCwjZmfCGVjI4SCaNFxtE4cIVJ95ndGKqIY1N08cuyS0B2RW+5FDR4+imzmnfqQR1/4tAmlQEYWm8flfXpVJKObNHILO2mNeAkUfaGhEtsqB+Nzxsf968gmDHH+h4HkpewC35noYgvOZesfzfFlIDaprn5aeXlZNu7+EP+u4Pi6x8KdE1AaVBwNOroLheJ/1lFIlDzgwW4jxiBNIHRv16NGkd6QMEw82UKZEeIy3mTz4cUxsInJibScGY+Haf2TyRQ82WVURRjW+rp16MhZWfh+14L12WFUhlfevlSns5ewLiqdFNZccnoso4oGmaiq0RMG5dmhTHTa5idPniB8OJrlvJ84iKKNkfXXt+yi+KDqez8XSmSMxAz45WuCYhHvfuCqiP5GBaWqZHAw/mr4Ddmrs+SrdeRoBwa4Iz44qLirbT/1MGHr89E8tOzlijdkFPXEHPyerPHyU6/G7cxsluf6jLX1uL3AyjvrRvRa/dF2l9X4jw0G37Vf7u8RyzIH0Uu2iYmOMn+3n4KHfEXfMFMKl9dXYSywQz5G+hdDDihvdR89zK26aYBcQj2Ok+2gVHgIcXppVrtjpjDOFxY6sllo7twRK6lWgW8M0uY8+O12KUA/3l/EdbWUANhNNCsIEc4sb3Lfkzu5QkcW3whlQwAV56AK29g66q0zsJIBTt0jRbxJw/Nk6F1WnBWhD5W3QKvaVMY9U+F6rMlxOzBF6CKFmq5G7XajrUt/BbhSxGouWMqef9vddR83YvX3oLPq7CXLM5u+XLcQ80GgnWXHTGMz3rUr4fXJSz64YKHv8u/b7ufadZgifVHCy4ioT602vG+H02CguiYymq+rJJQNo2sh8L/DtFmY/I7jf3G8l+7eAWrny1CPL2FsjtXU/l/89FLPMg2Fd8kFdsWR9Qb/9kXrSGhv9jEYYLW1kb5LWvZ8/jsHs9UtLDusjP6l8H3T9+0g/yadKpvGhvPYR4TvPPmU8fkuimKm8suXcqLryxGOjydAwlQc+dU8u9fhxGIPg7f+rtUvs438GYonPrD5cM04mBofonyW46N52K4oLV30LEItn6cF0LCEA+8sXIGjprB7bzNkxRS9mtYW4ceXNTR5uTch7/L0jt/P+IGrZFCx+keOoCavZO4ctxGrj5zGU+tn4tzT2zU8IYIl1wSvpYSQPHVW7jgru+y+bufX3apMMSGw369zzu+sErG8QpnjYBjo5XGS2ITsKR9dkSfgCWC9UEMgLLdQctEsDWCV7AhZg2/oqGP8uJ2Wga9YYwULt13JjsbItc40XUB687wCsZI4up/3RVCDVjS2X/ow/EAAfBM9GDZa+83ryneOP3sjXwwZirF12zGWDgNQwDLwRbUqv4Fo/Hf3UfFt8ajlkcfOuUb52Hf/fMo/XZ8Wb50BbzlXuw7bXEv8DfSeLE7iZ3evGHpW+vsRFm+DXXBxB5K49ZxViZ+aUdQu+Xbyih5NsCnP1/A5B9sJk2JP4Ws9F4qedUqSreKZWtFP/XMRx62D7ew4drxzHg6NIxQNwQ2XVWGUrH1mBHbPPfWIuxdQ/PodxRJ2BNEEqsHX4sDQLRouCd4mffPe/jFFU9zZULHwCfFAT/fcR6dLU6ml1Xhu0pCa41v7atwMHSRF/dOA0Cyq7gn6hiagHNX/25Yb4aBUtTNSYX7IioYJ/DFxQkl4ziDZgN3dnQCueaXkOtMa4PkGcC9aZgJkLps1iewtIoEVFtYNp94QhQNtKQA7tHgOBjmdwnQdcVsUj7ci9Im8p+u4GrAc20HKY7AktPltnHlgdN5qvi9AWt/DIQOvx01EL4P1SNjOaQccwUDzHC8EAxTxR6ptBjDYW4whlUBtvZ/wlEofrGTutOS8cw0BXVRMvDmB7A0yyidob9DdRr4clXyRrdgjdPNTlNc5Ge0I04dT8AiYggCam4qYrITdLNWSzhobW0UvdRKIM2BL1Xh0BUDa0aiZKAmhIqTekcXBW+Y+S4NC9PwpUYvQAUSDPxZKrL8OdcugBurF5OseAbtocpeUEfNlhxsTZETbw2fD8uOGnb9uBg500NKYidFjuBcI/8EiU235AMBFvRTV2Mw0A2B155dRPpBFdmtIWgGRm4WtLRS8Zv5BFJD53X5k15YE9u7NRQYPh/63ko+/fmCsN87D6zHOAY1ZtoDDt5cOxVHmFy+WGFIpqfcECwkVcWmaNSeYiGQEUDGNI5Iso7cLfC9j6/khwnmfRFFnZ0n/Q1JELmjdh4HutJ5Z9ybQxv0YUxdcw2eXSmQoqEaEmp9b4hix5fmwbXN0B6XS4XgyB545HcbMriKB5gLVg2nopJp6Y7YpPLZKWSndHFB9tALQJ7A5wsnlIzjDLpihjZJex0ExnjMmPYwUD0yUruMpWNwFh/JB0K7iNdqJXGfROcUP7J9eDYWSdHRkgIQJvDMEKH+DA131lj8+T62eYIrGdvEAB16r5Cg672/Vw1IbDo4Cr1YD9t3tHiyI4dOb28SuYHJw98zfo8YVig+1hBVSNmnYgRCn5vv3NloCfqg74qcn0cgKwnNZi4RumVgRpXPGkppXprLaEwvgbFxOzn2qTQGnBgiuOa4kRMD+DUBXQ4dmebUsad6ODVn7yBHHR65jk42XpRP3nIfGKA6FHAoCLqBdVQ+at2hsOF6+pZdSEBiRjpdo3vDnVyjDBgVGoamtltI2xxmjgf8aNt3A5CWNp32MhueAeir/akGhgBago6cGH3YliGCOKedNHF4bed7Ai4uXH0bmxf+dUAqT58R4B+dhaw6WER2chcpVg8WSY0poR/MIm5PObLol2dflGheMoZJUyqYkhyGgQooT2ikfFxs144WGiKZG/2IAXPd1hURf7aTrlnzmbF4N6XOppBznm9eRIFlGuKyTcMypnAwAn4cL4WGWMKxo+b36TLOqviJJJoV/Emxr9vypE4yHOb7reoiLe0J+FMN7NUKomrOdUOE20oWo4gab2+ehNglc1fyLB7IHXq+jXtXCtY2AUOU2FGTS+msDIwNO0HXkL0GHT4Li0r2s7yiZFB04bFAgLC0/NFgQ9to9q4txPYdgdfn3Ue5cnzX5YkK/6V1Mv70pz9F3fab3/xmTH2fUDKOQ4gByNkSoDrNgp7iR5TCJPV2DkwLGs11nFUS+U/vxZ9ahi9dwlCMQS8qscIQQU0wuHLWWpTZ4YWida5i1lHc87mvknEE+wIqpQox85YHDI2Nfp1frT8HQ+29l4YBznBel2GE4jaQvMRUGEr008NkFARB4OCZEkLy4OOSfGU5GGKfe20YbO/IZXzSoYhehrpt2Yz5v+CcBGHFZrJXmGw0e/7fLBANBEBNVXGku/H7ep/ZcN3xEmczoy9ZwZrVs3qEPwBDFPCW52B1udE6OiPmBWnNLWT/qfd3uS6fS22SJeg9UbsVknfKZDzWf26OuHQjaYEpNMxOoA+5W+g1872IksERvjndP/Dd0RXwZmkcmPs0MLzJlWu9BRT9VqfuJR8pYgCvYZqecw8ndVar3aSJMiIi2wIC9208C4Da5hRqScFqC8SsZPSFoIPSFbouCorMyd9aFTdPWCzw6TLbO3KDjukWEVe2zBnfWh4xlOSK85bxdOICxtcUHBNa26Fgf2MG+Y6OEJr0WOHRFGrdg6+5ERECaLbomCQRwJ2lMDtvD/m2dgC6NSvve8biHwW6146ommuioMPKl0y63SOi87uvz4FbB69kaIbOer+GoJv7gOwSkLbYqTndTuGhHLRDDThfWI2jdipPvPApC1uzaetyoGvHX+0Jh+inui2Vwrd9fPDUX+m9SydwPOL++++Pqp0gCCeUjP8G6DI0T1YofMNPzak2jAJPzEw30cKQoPqrZZQ8uh/1UAPMm8KBb47MohVINrhyydDoAQ1D4OIVt/OveU8yL0ZG2/U+uPmxb2EfuGkQzOSv+JoYHC+vxr5wGvULHVGz1kUMfzUMSr+9igO/mR914vdAEAMGnp/nseVHUljGJ90Q+rW6GKpK2bd6cxX8S2Yz61c7eGVXGF78EYZvegm23fWotXVRtXe+sJpxu8ax94e9E67gdQHb61Em/6/aQl5nOXt+7Ij4Xvd9A3W/hGNnhLjoPh14SvxULHkiujEMEdcltnDd60/xs6Y5BAyJ1S1F6IbAhxNeA+CyLV/lppLl5CgdfHfdZSbjXJysroIBSrdB5qMrQ6accHQFsBigG8KQYso3tY1C/2UWYp9RtZconHfrwCEi1560gs/GlmJfIgxb+ONwoOiqLXz4p7lcvXjlkO7d8oYSuj/NiuPITGhWaJmkkLnBN2AIViBR4vTvBZMBJEg+Lhmzhed3T49qXdYMfdAF51p0D1999F4sgGVhC7Kk4/4sE4Cq6wopeMWOttukDJYEkVXTXuCkrZcMim5+OCD1ucFnJG7jh/N2w7zQdpoR/kFEOn5c4b+UwraiYmgFOvvDCSXjOMfojwIYgowvRabpIjN+WNxvxxouNn8IOHjdGNy5xehZfiSG/2V3jfVz6dTYefcvKtvKR7XlIUUBv7LuKwgCFKS18e74Nwbs55t1s/ngldn9BV5ERP77HRib41/kTVi5lYLqXKqujVw47wiSK3QSX94w4qEN0tU+nr13EVedFawcfnzfAkpf3Bh2PFL5GHb9MAWA8T9rRq0wlRSrqHLp+E0AfFpfSkv754faUN++m7Kv9gr+uj82Jipt517K70hiz59LEPoRztR2C46D4ZdpQ4SP77gP62GhRkIARr52zFvVE+h2mdedvPpats59mmXTn0I+7Js6a/HjAMxZc2MPTbbPq/D87ulcXL4lpurjeZ+IJL5sWotDFIyZEyl45MCgvBjPv7GIwrc9zPnz+pjPBXhq7TyKXgSxz9pZeYHCBSet6eesYCzK2k/DyiTqTlHRvcNPyhEvlN+7iQ+uXshZ3x75ehLxQvNkKydfH5kB7OLyLbxtHY+rIhn7ofC7huSByY9+HYBLL1vK/2VFn2fz984sfvfvy3v2I9/KdHwEU/cevCCLjKIUlM7etebg/syw64NnlIaUOnIMG8l2Lz/O6CUgUSJEFVy4dwkd94Xf39SAF/jf4RjeCRxDnFAyjnMIqhleYmtTSX/L3Mg9mQJabOxyA0KXQbcYSCOQYKrN6mJh/kHsUmyCGYAiaDTXJyO4JaTM3o1YUyW0VisV+xIo3ntrz/Hk7TKy16BlZrAgI3VJ2GK/PACCpmHEsQZGD3QN7VAjhc+Zwln92Xn4k4OVydFvtyJ2eTDcHrQBqDvL/tpI7XnZuGcPzJCU8bqNtGXVESvKCrqBZXMFWns7glYa2uD6JqrKZlL4ZnDYRNv4RFqmgGQxPSp7bs+j8O107Gv3s+yH81j0K9O7MSOzBk+aEpFj/biDYQxNEDQMtI5Oyu7zsfuWxLACgX7Ihq1djGiBFQyY++a3eeHsh5hpjW1BWO/zc/kHd7Ln3EeHTJqg6WKPlyJwOHG0b+iiQzDHdrQyZYQJfewPn/10PsnL9+M6exqHru+998W/0TA2bgdR7Df5tD+IqoC0aS8r75nDjPs2RK2ovP73xUheg9x2A/EoRdOQjJiS3EXBIMPaTZ34+aJKNXw+Mt89wOrKWQCU3Ldr0M9hpOH8SS1zUisZZWllgb2Cf7aFMb1j7jvz8yrZII+mw5NO6V8PcfDS3BBDs3h4Sf7Phwt5yjkfKcnPvlP+HvH6E1deh7vJiegVsfeZPuHeeUMCQxJQ6tsofs3c4+z1cti2tkMSeosdXQajKD7e7EiYX3yAu3PeRxEis1CNffJ2LB0CtlaDJHeEfUs9njjYIuC/NCfjaNTU1PDaa69RXV2N3x/8vP7whz/E1NcJJSMKeDMMtLRAzLzR8YSgGjjrArhy41Mw71giJyWU8SVavLRvKkqTjBgQCOjBVlulW0DpFrC0907r7NVdSFUNJNQU0jxl6PcuY2sAsbFt2Hw9RsDfY+nP3JRMIOGoMe+pRI1SuNX27Cc32UE9if0qGkmf2ElbVYd6sKbnmLW6NTgnQxSpuXE8CKCUB9M4PrVqPoJPxOmGQFLoRmNtFaDVgW+yG2GUh7qFDnKkYhyre4v6pSkuGKapXetN4bNVEynUzF28e5QlqLp6+rYANVcU4c7rp/iVDmP+Zz1GwI8wfSLeHMfQqzYbBvqmHeR9NBd/ohm0p8vQNtHcWSwdYv90vwY4K2Ru3fYlfjj2HS5LiC4u/sXuJH6zZwnO/QoX7L6QP495ljERGNxiQYLTy4VFw8eSlLi2ho6TSqg9S+e6sRt7jv/n2kUUps5E6RpaLpnuciF/vImXPp3bQxMtpPm4ZnJvnP0Le6bhr++NLy/cFUD0f04U42GEeqgB8ZBJs7riuQXoEbZKY0Ynl5ZGWR0zTjAEaJpuxZdmoCsGumI+V4A3Cl9ivMVU6jTDzqmJO8L28Vn3ODIt3aQ7XDSnpdA6LxtPto4hgNIlIh+1vJr5kiKaTeb8vHMijk3dlYQzBlIRd5YMZIethdUXoh9Ev4AhgrfBhpDl69djOljMLz7AlzJXhtRuOoI2zc38lV8je52G0vU5UCJOgA8//JALL7yQ4uJidu/ezaRJk6isrMQwDGbMmBFzfyeUjCigZ/lYWHaA1S3jAbC0CzFVL44Vhmi6O1sClh7aVNFvkLrHjytPDKmTEC+IfgHVJyFbh+/H+dIMnMrghQFjSxKWw4KX7I7uRmgNjdg/7sSeOx1vujCo+yfoYGsxsH+6AzXGKsPRQMrMRLAFL9Ta+l0oR3krgsQZUULOD040JRAwc2uONNldRaazlP0TzVddcqgImAn0ute0Omc/vwu1rS2oG/VAZW8fiYmo00o55/oVQaEtAUNiWUMJo98GpSu8Wyih1k9CrTmnK3OtCGl+AhPc1EsOiteovFoxmbMKdg3KqxUtalwpFL0WwJOlYAjQUQpaaa9U0N1mJ2HJIV4a/8+IwnbA0Dhj2e1IXo3GWVa8mTrlVeVBbQSXZ8D6G+HgfHF1T1qk6HDg/ca0mM73LcvgPukspLJ3eo6d42jr8Sb4jABvu3upoe/bdxaepRkA1LxbyK5bMhijDD08x2H1c2HSRiC+xhifLvNO1XhG+5uoPdPgurnBdUiuPnMZL7UvpuiVbl6rnMSFRdsGfzFDp/g1f0+djY5iGx9nlvV8bV2RSP6WkS8S+XlC3u8j5yYd/J8FEMYROtzwTPNw8pi95No6GGVp5baUI8xjvV4jSRA53R5+76v0t1AfSAFMtqWWc81QJgHwSzb6ZlEl1BgI2mF2KwQq3y4O1yUQu13FnS3gzo7+LEEH+yERl0NGdKoR2SoHA7vDx9dzPmSONfx4qtVu/tyyiPxHLXBcVYo5gf7wgx/8gHvuuYef//znJCYm8uKLL5KVlcV1113HkiVLYu7vhJIRDQyBXFsHF59hspY89/YirC3B1gcjDtQ4hggIEEg0OHDJY0Hfvem2cd83rjfrXAyTy87WJBLwWtBLhs+9evZpG0hRoi9wNlQYsohotWIYBulPbaD+jploVqK6f32VEVGFjKc3YhgGQh+rjeGLg8AhSrSePYbu/GDtp/DfevhkZEEAQURKTgrJ37C2G2Q83tzz2TunjMaZVpyHWWFd4wwkq4bepeCsPPz6GzqIkvnv0UmnokRgZhnzHgi22uuGwEF3KrbfpRLNBiLoUPyKSsWlFozDVkSts5O8S3aw99OciHSj8YCIgaoINJzvC7vJdpzmgdYk7q26hGfHvBM2fEgRJD79y18A+EnTRP6zayb7f2J60gxdwDAElB0ZFPy2IaYK1EdDkAe3JHd/msWPP72h53PebX9k0mFlfmcAfvzEDZFOjRsaW5O4bu1NYWltA4Y2qMRv3RDY25VF3iU7Ds+yyAKbtn03eVdZ8a2UY8rL8GhKkNFI0A0QwRAEkiv88LteBc3GAO97359oCPj06MeiGwJd6sjn1IwkBA06VRuiEFsoWTygI6AbAhoiAaP3gYsIAyZr35R8iL936ohCSQiJgZTpRcvsbZv9eBNaQxNMG0vN6YnhOxzhMBjnAQVXkQBh6LCFw4x/0cAwBI7kZ59fuJ08yUc4VclnBPhZ3RIqfzg25LvPNb4A4VI7d+7kmWeeAUCWZTweDwkJCfz85z/noosu4vbbb4+pvxNKRhRw7LLy9q75GAKcf+UKSl7qxlgXbC1rvH0+gQjrSbSYd9EWHh396eFPwYLOeQ4vZzzxMCIi5a/d3isgnkC/qPuOyjlFvULfDGEZ/1kxH0f1wFrh+HP3BNFsBq4LPmddSwGWM0OZlmLFoW/MRe+/qGoQPBfNpq1MJtzO4EsRqLtnbu+Bo9o4dx++UJ/F6+AtEwFI26lieyM4UbXu7rmce12oZfKV/VPIedQaM+tZ8csq9Qscw+aNC4eixBY+/HLGgEn+22rzmNX6JTbPeabfdj/L3M7/ZvSGBc3beDXtnQ78E9zsfmgq5V8bXBiVVD6GgxdlD+rco3HjX74V9Hmk+FA0VWLy0pt4e/7DPV6hZs3FguW3Y+ixP/RnNs6h/OaNAzccAjb8aCaj311pfjAMxE83wpzJqAmxeWQ0u0jLxF6BK3OdwQd75nPeLdEVIFvWOAbHeQePSSG8kcKoX69kz+8kxOQkpn3QPKIVopdXlPT8/499rvutKR9zZ8rAHsivJDVSpLzDU475fLK/LGK73b/NAg4zZQmhBjXNIx+T0Ov8DwWsbaHvYMNsK74p0Rn+nGvs5Dy4GkGSuGP/CkbJ4T2/4968g+Ln9BFbd04gfnA6nfgOG0/z8vLYv38/EyeaMkJzc3N/p4bFCUk1GhxejwQDXn57PmWNNahxohnUZXjwq48hYTBW6UQRIsdGH7EOvrzkQW7adj2+ZRlxGcNwQ+20YK89NlNNFPUQS+KpM7fzWddkyv7aSPUlwUKdP9Vg2qI9ABQ7W4I2QasQ3M+MtIOseHsMAIk/T0BYOchYYzE8U139hYVkrU0LUmg7rpuHJ6v/kLl+Bfgw07anfbgdQSQi+8+gcrQNKHy9HbGhtSfJXL0tkae+O4frpvcqOHemreR1VznVvvRBXKQXu7qy2dmYHdVmZximpTMa9LV8/mfyX/lRzYWsrypASlDZd/88xv5sJ1p7Rz89hIEwuFC+sF3F8GzuevFG3jxtIw/nrxq4cRicPGofm1pG9VBpGrrI1Vu/iiSag9B0cVAKxsvPLmbCMzWoMZAsGD4f224Yh+cPXhZl7R/4BA57Lga5nrdOsPY8M+Oo99iTKeDNir5f3RD+qxUMAAwDQ1XRWtvYeP0ElD+3D6sXU1fAM8aHfDSFcp//P7ZnEf+yBLArAT6e+Gq//YlhXiy90YalNXR+B5J1hNzQMETJruIai6lojKClumu0RMAuklAb7GnN2BogsN+KIQk0Xujtd60UDEDXMIwBCr3qQ6/aflziC+DJmDdvHsuXL2fChAmcd9553HPPPWzdupWXXnqJefPCEyP0hxNKRoywdAhhWRCyV3fQMiUJT1aMursAp9gCh4WW6JIvp1mt/HDsO/xePpOuT+Jj+TwCe4OAY5uNpgvjSKFo9LJuHA/ItXWQPqWJyiuyGfVRb35F/SInaVOaoi4SZpcCnJ5rKiRPfWUeo7PnYH8lPGWl6HSy+8/jwn43q3Q3FlFjVUUxti29VTtS9geQDrWZwrgo4VsyA0+WGHdmsSNw5Ugop85A+tikFm68cwH63FBB+dkdM7Gvc8BAoSMRYEgC9AkL0nbupejZ2by1ehG+VIG/3fpHsiQHFmFoAtdTa+cheEWk9OjHGQhIfL12Lr/LXYpDjO5Gj1ESuCXnUxLleXyyvwwh20vdDRPJe6cBbU90gu6xhLVV4O31U7jWb+fp4o9jOvecpM0sc41lp5wTdPxoiumjIcka5dlN/dJl25uNkOJ0ha8ZvLVpEf5kgYuvMT0Ez7++iMJPei2x+rZd+P42j2cvSOGqCf1T0r7x18Xk76mJyKoWCYYs0JWvoNojK/W6AqJP4Okts7l2Sv/ered3Tyf1NQdwoN924tTxePJ79wnbh1viE7I50jAM8zmpowAoTWlmzXQHlo1xprEWGDDH0OO24nFbESWdr9fO5Te5n5Ighg9bK5O7WZi8l08wPRl6ow1LWwSChg4Rv2BDzAneSwVAtqm48yVshyRGqm6kZjHn5NGQPDqSRwcBnKsddE71I9tCB+Vc5SBnRWeP3Pu6q5x8pZUypeW/o5r3CQAme1R3t8kO99Of/pTu7m6effZZSktLoy7a1xdfSCVDDAAxhKdEA2P9dlJt0zBEO96M6BQNzQ6BMs+givdcltBJztjn+VL9rTh3x0fqtLYZpOz3Y1m5k/ayaXjLvEOmtDXqbCTWiTgPmf28uWkKcyfsp9TZNKj+vHkqtnoZKQodyJOtM9ph5pf4dJm3KiYEfz9a7fE+GAum4s7XuShv96DGdd3cVTxlzKe0ZTri0t7wDmH2ZDrKnAScAgfOeqTfPv4v4RB/DSw0K47vtmLfXodaW4focEBJAc2Th4d+ydJpgAG6BF2jraRnmN6DzjE6NuCDurGc0ee+SPvsZG4avGATSLaZGex92Kws76wlp7SY2vNyexIJRystiOh4DUvMHo3XKieRsVLGnyTgjuFUTZV4d+94fpHzMY4YEphPt2s4Mz/joCuF/Ycycc1z49+SjLQn+msLLg8JtXpIbs5IwFkhs1IshRiVjDlWhVatltqUFFRdpKYpdcBzFItKWoI7Kgu2nJONa0Zw3lH2qg7EhlaeHj8HgLEvtKNv3hnUJumZVQQc83nVPpmLioMZr7Z05LOtIh/DgHFPbg5L5CB1eDBkkx3oaOgWEX+SFJVBSXaDtNPGshzT4zkmqZlcW6/i/sy2WRiqSOoKC8lPrQzfiSAglZvnt01Ipqugd36Mri1B9AYQOrqCCB8+byhytGAvDrByY/yKc+oKBBJi8CRpIu/uHc+cxP0scVaRJYUKzrlyApOt5rqldinYm0VTnggDyQe2ZhG3w4KU5A/xEEjpPgIeO0qXcHwY4QzI2Oqjc7wUttxOxhYvUlMHrnNngwDbXJuoltNxOaw4hNqIoVMn8PlCSUlvWKHD4eDhhx8eUn9fSCXD1mqgKmaoknbYcCwGGLJrSli+iczu8VSfmxqVq9Cbo1Jx6t8Gfb2FNpGtZz3E3L13x8U1mb7NjbBiMzow+hcr2Hf/PPQMH6I0uBuj6wKjP9awvbehJxk26WlY848ZlE4dnJJx3byVPLVqPo5quV+GL90C8+ftosjRgk+X2dmZQ86fg1dOydsrKFd9y+CascuP7ibmsb07ajyZO9LQWlqRMtLZ/U2Z/ac/GtX5P87YxY/P2kXA0JhU+3UQTWFCzMmi6ry0IY3taAgGPfcv+UAAMdD7jH1TigAoeiMA2OgoTqLh1noAMi1dcR1HX9Sdk8vm7/UuaKfbNbA306y5+EsgEXckXszD8GgKTf4ErKJG6hOJyG4/zVPibE3oB/NsEs+UPc+itlsI+GU0m4Ris0VdT0OtqSX1pTa6Y2SXiht0gUbNFVa46g9LHD6WODawKnUtN3XegN8XWRnWVJEEp8rEtPoB+1XtAm0nF3PaD4Lfy6c/W8C4n9RT9hXTSxFp6Ut/ciVq5UwqfxGsZe5cVUzZ91b2e662ex9yWQna6GClyRDBlyLRWRi9Iijo0PxhHgDNc52cMtqs2twesDP2rmq05n7ovAUBKTGRgxdlhQ2pPLjEHF/q3nScb7YPq1dDdDoRpPBBMobfP6i6MU0uJ90pVhIkH6Kgo1vi5/UOJBkwKnYSk19sOB/brJe5MiF8uGPAkFDdMs4KZUCZQdBMBd4zOYAQjtlplAd/nQ1b08gbFiJBCAho/uDnbGgCYkCl6dRRnHVXcNHFLe4CmtQkbk4+EEL48F+H/9KK38OJL6SSkfL0GmRBwX/2LBb+djUAL7y2CDkOVbQDaXY84704tn/+WUJKv72KunsX4J0+ODYo6y47zZMgxT4d5wur4zau6+at5NXsyRirUsJ+b0hw8aXLevIp3tg/ibxHRibR7uxRO+l+z8queRZO/aSSt9I+jLkPRZDY/dVHOOODryL1sfbHE5YOg5S90e3myRV+DvzADPU6+ONDwzKe/pAhOfle+k5+3jwZrZ+khZdXzab87k0EFk5CPkaUiamSg+3zn2Ly6mupuUHAWT6D7D9FpvQ8nuCskDn58XvZedvgLFfzbBJr5/6NaUtvicgklfapleQKgS05Uzn9u/0r9ed/NXzC9LUnrWD1C0WIp7eF/b4v5A/X03TUK1hCBI9BFOgssuBNH8I+sTqZT1bPRPYQ1byQC0ZRdfXoAdu1lUm4vjqDzEcG/9sGwt6fTw6bYwBgX+8g9//FPs8zL9zN6/fP45pTl5Np6ebSy5by0ouLjw/LfgS83TWF8ls3UnfP3BElsBgpFL8cGiqlLN1iGgrL5oc9p96fwm+ap/KTzPB1Rk7g+EZaWhp79uwhIyOD1NRUBCHyGtfa2hpT319IJeMIrJ9sZeP5pivedqmAah/ghDAQFAsNX5vV89mbAZLsxj3Ri32nLaKHIeXUQ7w14Z9Em4cRCQmijZdvu4/znv1OCK1uPDD6sW10nTGeQ5dHbyEzDAHLDjviYTmvs1DCe9N80p+M3wbo2ZdM+SPh+fAFhx3tChFxAEFTt0oIi6ah/7SVc1LjtzhaRZX6OxYwwfbXIfXzq789xo2Pf4ui/4ShsR0CEmp0HE2DCwR2PTiKHO/IJ6dKgsi96cHx9QdU+MHiy3uSdsd59g65SKLVFuD9WY+RKp1w/Q8GDtHCpwv/zHmbbkL9NJ3UPcFzRfKZsSX2xgCf/GJBz/G60+DahceXMqbtr8LW5cI7wcwbaJ1gHdQeEbZvGzR+fQE5f92E7o4PpXcgQaDx6wvIfnRN3BLIpdJidn7H5GcVE3wRk4K7p3rZ86gZvjbunu3oQ6gltPiCjXywYir2+sFL8O4CDSHZPyCjXCT8bOv5rCjazQO564KOf6nyFLY+O4Ec4mc0GykkVerY2gY3L7S5ExAM6M7//FvWhwLBOJz8PoLXGwncf//9JCaa9KgPPPBAXPv+QisZhs+HWmPGBQtaP9V+w0CcNoGu0kQMUSDQJ7pAUEGosiMD7tEqtkYZqY/H1lWomsne6bUUxCmGsVxxYkgGQyGqzFvmRt5TEyKWa52dJK2swtKeDwJU3GAgKeFFObXdgtIhIRgEJbOZYWm9Yyv5Gzxz4UKuOW1w4UkvvbiY0ne60H0+hLJQ3nzdriAxcDiGIQgYVomJKfVx5WxXBI0LblzKbGsL4GSL38uvas+N2P6vhe+ETTKeY1W44Zr3eXzSQmxxKpKbeFDH2q4hqINbvSwdx4795uhkTKfQHVSlHABBwLajBv/YPHRJJPGghiE68MyKTpATBIPcE7HFQ0KunIB3bTrpBzRkV2RmMmsfgSdzlYX/eBZy9RlDC1k8GvqiaXT8YGCB1/9uZqhnQdfQWtqw7Zbwjs1FVwZgbosBhkDQvhEO4pRxtExJib5PEVQHMIgcv6PR8aV5uPJEVDvISQO/O5KsQ5Lpfqj+5lREDTK2BLC8MzCd85jnPLzQtYjLLzTDcDIt3ZRNOchuZx7OfdGH3xgiuAvMOSUMsfCc36fwWe0YrvYmBR1fs6+IRAG6L5sVN15oLU3FI8rYG4bXLSKqxqDXfd1ihk8ZcZQY5R81kGjp9YwFXH74tJ8TTmDY8OUvfxkA9bBx4uyzzyYnJ6e/U6LGF1rJ6IuU/QE6is1E0YHgK8/BlWMJSsA7AjFgVgQHUBMEAgk6qq1P4Z4UMwFsOGPbY4IAruIAzR12sjsyIUx8sFp/CLneDJNJHreAcKHx3aN1LB4BpXPg+2fZWklmfjkvjJrG5eWbYhruf3bMZNS6AFJdC+Rm480K3akNWeA/m2eDYDCuIHJ4j6jpyC0e9Dj7vCVB55KkDSSLFtb4AjzbuoD1VQUR2z+ZUsblidvDCrffS99LxvQu7t986ZDGJBhgbTWwtahB+RfHAh0lFsSAhdSjyh+k7Aswf/NlrJz64uA7NwzUQw0oyYkgS1gbwFlrpZ4E3DM9CP2YhhITPCzIrRz8tfvg5FH7WV5XjEH/LEtHwwiopO7R6CiR0D/Hq7OnxIe31oIlShbfhFo/oqrwTPYsrpm8rt+2yxrH0LA8jwIi1zZo+8p8fCkCneMDVEx/fsDrX5iwhIb2+aT8M9jbagT8qHX1WFMSEbT45/doU8uQd1aGpTv2ZzhHlARAdDjwnGzy4TfNAjFrcB4W/2TzvEM2B6NcwUQY4SCs3ExG/ly4sPfYrLRqArrEAaOXPdFWo4RlcfJm6mhJmskk5YyQhT0IdHXbWd9trttihR10cHYKiAFomiliGThaLyrINhVNkknZp9FeGoeqvmFgazWQfNGv++2lFnSLQNqO4BtubzR4btd0rhwX/Ewdop8J9uioiFWHRM3pIhvGPk+y2Osa7OzSGZg24gSGE7Isc/vtt7Nz586BG0fbZ9x6+pzD8s5aks6dTVuZghYmnULQTaaQQAIcmhNdvoWjRjLdtkm9ydPHk7PREEFNMLhmzmrEuQZvCYvIDB+B1IOsP4cPaei8dh7ubGFAelXBakUvysVZH0B4xcmu281NpNjZErEybqdqo85jcvDnP2NB8ml4x+ZGvoZqUPxPAIFdF49GSPPjTZextfT2L2o6Urcffftu9H6oxny6jK+PtJckD5zcqBkiL3TM4vLkdTzWcDqfHSjtt/2fNp9K8gwXFyUcDFp0j8AmBlCd5vyR3cLgCAoMSD5w7AOdfakyrYv8IBqk/iP4O+vba3FUlkEUaSzNmovXuydF/F7bvS/oc+4aib0PzAIJDLsWRNHocPiQRJ3ZOdU8lB+fMIiH8ldzuTeRfUSXsC9lpCMkmkpm0qZDeNLz8CcLkRUNwfQQRmK2GQx0GfwpOtVqN/mSY1Csd0dQcfaTlHR/jaTK6M9xNAQo+LfEth/mUZbY2LMeBAyJTa2jeto1LMuj4OeRQ6uk8WXc8f0X+UpSdFTUAK+VvcOfvz+aN9fOQ9u5N/hLw4C6RgR9aDVbAI7oKUeE5bqTnBS0Z0GsNVWigJSSjJCa0nvtmvqI1ehFmw3KCqm9PoDqUgAN3aWAaCDbB+e9VMe5qUi2MSaKWoSyR2dT+yimpfR6JudnVDA/o6Ln89P+BWHrUaSNb+Gs/F14NIXXdk8Z1FgjwTAENJdM0We95BjedJn2qTqyS+khjNFlCCQGL8yS31yvdRn6CXFH9cg460WSl++nvXRMXMcvGOYakVQViMmL0TonQGKGC29DUtC+mbrbj73Fwa5vZNMdsPbkXqXbXEyw1/KKy1zD5HYJ0e/v8YD0hTdVYv9VjwBxij0cSXwB6mTMnTuXjRs3UlgYW3RPJJxQMvrA+tZa8qZN4ODZKSHfWToMMp5YQ93dczFiMDY4qiV86bYQlovjoRamP8XgqrN7mSKM/lbCAZD09CpsZ8+iaVr/WoY2ZwK6Ym4UjkMB2n5iTuRD303ilJy9Yc95Z+8ERj9uTtVYE3qLX1FpmmZnzN3bqP1Rb5VWpcmFtmNP/6s/sLa5kNrmlJ7P543dFnVo1fWbbsTriS7h/BcbzmfD2G0hMcAAi+1VPaEEz7++CKX72M+dwcJ+Rx3Xplfy9JbZQ+rnm9Xn07IwBlOirlH2TVOBaL1xPu1n9m6cr0x/nGLl2IZI7f92OVec1/subrxAo31ePh0l4RcbzQaBcje2LY64bUSewgBbz32QGUvv5IOFf45bOGcsEAMGXT8bxdYfy8xKM2tkHHSnwum9wmcBkckQRIeDF95/KuoaJ31xZ8pBvvz+Xq4oPSWIKUmwWqm+dXzM/YWDbWYrNksg7vWNwuHgzRO56Eu9Ev76GyZibNkVtq3n1MnUXh/AAIpeBNFvhsR6MhWaLhp8iGS05DjWN9dibM6HNyK3uXbRyOfsaN0yJc8GhwfbWlSKn4Pqr7pRdjuQvOAp9VFx9pNB7e6pn8HbL88jMMHd726f+55Myvp6qr4cXwUDzPDtjM2DCAUW4MKibdTek0L1D8uDvrI1B2j/3wKkTzfD4UKZLcAj9BrTSliJlJHew1R4dN8ncPzijjvu4J577qGmpoaZM2fidAZHi0yZEpsif0LJOAr65p2M2tm7QcnvpvH3MS+gAy0/FLj8sblxoYv9z66ZrG0t5K2xbw2pH83Q+W3LeERfbG+ue6KXSyZuCjq2+KtreX3abMpvHTiONhws72+koLqE6gszg477UwxcY1QyTp6OLoW3jsp/TGeZGN5SmK9BZLLJgZGxxUfNtnKUT0wX794HZyF3plP8g9C2Db4kPqvsXewNPfi+vr2vt9aGxaKGcPAPBwrkBL6fsZb7WmYO6nzFBam7jm3BLl0RKP35TjItXTyzdRb2nTYOfXtBSDtDhPGP3cHSm+8jQ3Kyxhfgva7JIe2avAk0ftsU/PL/tj2m6trp/15PxnMKYkoyT69+kWTx2CgYos1G5scWFEFnkhLsQcl7oY1isQlZ1KjzJLPj9bEh5wuAZ5JpvBDrbEMifvDk6EgJAWavjMwMdbxDXzydR//9II4hPM8E0cbDuz/ga9d+HWH5piGPSemGpCqVqT/diCgYWEUVCR33lVUAvPfKnIjnyp9souBgIdWXxh4bvfcfM7hwUnBh0IInqlj/WCgBx6FvL8CfDKP+aX4+omAA2JsDjPpnb17EoTkK6rjow6iEHC97npjF2Ns2DZiMrtbWseGUNDLeNiiwxykWaQgQD9gpWhreVWjIIqsW/wlpsYCGgU2QOLq4xG9y1vLjry1DEUTmrLqZgH9kxS1ru0Hy/ti919r3W7g8o2rI19eaW7CscOFfMLHnWPUSC8uv+T1wonjf8YqrrroKgG9+85s9xwRBwDAMBEFA02Iz9EY962tqahg1atTADYcZDz/8MPfddx/19fVMnDiRBx54gMWLF8fvAoaBlJlB+vNmzsT3cl8i4zBvfJYE9375BTRD5Lebz4q6OqnSIRDQ7VDQ683QNRGfFp9Fx2fIlC+oxKfJVDenomwIPy7BgNGvNiIEVA5Y87BPCV5A33lvFmOf7xy8YVTXMKwKrjFHLcyKDpoQUcEAkHxx0NwiQNBBswrs/7cprM4p3ItXVdj29DQEYJq8CYBdXdnsaclE1yKPs+93Pp/MW9Wm0jE7p5pMi1klUzcE3q0Zh88X2/P9tKaUGwN2/lYQGl9whH+8bHElOzYX4qiLIZTFIC6KcSQcvEUl4TMHqbvDb2juHAXf1W1kWzvN4Wii+UwiGJslL/yzYzLJkpsOzYE3TJna8cmH4Hzz//vnFZL3N2tUSaZgxtkbAT+CIpMgDE8djcv3n8GupuyQBbbptvm488DeIJDz5AZybZ0oYQq+HLlXAIWOVtrOOoj8bSdit2lh9xWmUVVOT3KrluXHlTLwnLDVKUFEFACjPupCdPvRewrP6eyak0qBPPhYrNKnbidn/eBdLM3PFPDCmWmIokH+gwoiAwudhizExSNVrCQw66ENvPPYQjIfjY0RTzAgZZ/W411y5Yh0f609JMzyiDfUEKDiykzSt6eF0nzrGoI/+meguCD3nXp2PTGJk8fuDfG4Zlq6SbiqnoN5Cxj9C9MrIE4ZR1KlhiEFKxc9MIKPZ2zT6OiOgUgBEG1RCiWGgdbeQf33p1MridScZuGK85cNeNpTK+aTsl02q1nPiQ9TF5hrZrj8tc4iC+d+67MeuSASFEEiVTJzsh6d8W90Q+SZlrl8tC/UYBDz2AwY/UoDgUf87NuTy6j3Qg0Dkl+Pad3XFYHW212cml4TMXQ5WsijR6FlJYdER2SuN1hofIe91/dfmPYEjh0qKioGbhQDopaCJk2axIMPPsj1118f1wHEgmeffZa77rqLhx9+mIULF/LYY49xzjnnsGPHDgoKIifWxgrDYeOfhW8e/hQcN3gkzvdvKd20R0k/K6pmbGbf11Z1KRyozOJK2+k8VxJ7LQWAbt3LBr9pPTkSy5puc7G6q4Si58PTn2l7K0DXyFuezjOpC7nmVJPN5T8fLKT4bS9idT2BxdNDf4NPhTWRrfa+c2bjT5ZwZ4rICaELveo+dk4zd7ZC41y4ZsKqoOOTknupYXd1ZVPRnobHHb3QaegiXd3m/NjZloM/uZl8WztgJg3GahHudtnY1ZYF/UzlaSk1bLePgkGTM8YfcwqrWLmgmK6i8LlKarLGdQXRUQTrMvjGeaj3J9MqRt7Ek2Qvc9MrAZibXslTF85ntHUO9lfXRDznaBheH6Wv3QYC3LHoQ+5N2x/1uQNhd3MWxtpkMrZ6ERMT6TjPtOa1T9KR0ny05ypod85gOgMLUVZRZXZaFZsqU1A7TeXDosj0pb+WLBpYBhbmfBkiok9A7hbJW24qheLuKrTOzqB2X3/hZm47/13uTjsQ7U8OQuoOk6Z2sEje76dljg1EA/HT/hPBAfxLZlN5Vfw06V9lb+HF0QvJHLhpD0QVbM2GycDWo2RYOGd05CRKbbwL3RBotNnJ9c7B9kbw/DU6u8ncHKB5itJv6JGtxSB1txdtfyVLJtSTpoRn1FqUtZ+nx6SDICAXjsafao+JMc7SrpJUBarDQWBClIqGaNBx5SxS392D1jIwx7746UZEoMA/jZd8oQZET77KY2f0FrF9tnMRaTt9qA4Jd2THUFzQPNWKfFozP8vcHtN5J9kAdMSMlfh1mWUHTG+5Y42DpD0d0N5JxpYMmqdEx6ZlCLDvK1k8VPgEbyRP4+2uWRS8M/icO1+azKF5AlcXDZCUOQDkInPz0jKSCCSF7qX2pgBp20amZtVwQGCEKWxH7lI9iFcuxhFELfn96le/4s477+SVV17hL3/5C+npQ0+CixV/+MMfuOmmm7j55psBk8/33Xff5ZFHHuHXv/51XK4h52TTNn3graUgsY1DGdnYmmObBqpXBgPkVhlrq8C2yrHU3/oqWTEmWrp1PwdUeK8zOJSk1NmEON6g5d3+LX/yh+sZe2gsb40xLfElL3lQqppQy0ZRvyA0IUt2Q36tWbVWa24JqSxbc5qMkB++uqoWEJHaZSCOWapRwpsu0zpJ4JpTIgtzTf4E9rRkxqRgHI36lmQUSSPf1o4oGGSldtHc6URTh84WEjA0GjRPTyE60SVhazHM6sOpwfNP0Ew3OUD3aAFBN0M2hhvXTF4HoVFNIdjnysTwhr8nugW8mRrXDsAuFA7XLVjJ087ZjK0Yhx4h7jzkel4v5bevQXQ6+ce/5nHvvPgpGV6PhaKlbpRtFQSmjqHpQtOSfeSXJ2V2c8Hs6Dd0UTAITB2DvGkfelcXgj+AUWdDyIutyrKUZr63ar0N5T3zPodTTYq/v5Iny+Zz9/wDaIbO1qMs6lZBY7wlNuasmBEQQIxufa05Rabi7GGyjuoGtmYDX5oQkcJWVEHpMkg8GJugV5jVSl17Ev5CqE6xMLa+N7REqmtBrT+E9YONWPNn40sVwuYDKl2Qst9nsjgJAp9UlbK4YH+PZ7UvNrWPQq6zIEgS3pJYVKheWNtUstbr1E4YuC2YglLz+V5S16dBFErGEYjLNjE6zLLtO282Z13YOx81p6lcCrqB1mZFTPH3yyIXLTSLKXxbW3uVsK7pXg7MfG7QfZ5kg5Sc91l6YAzU2Rj1Sg1qZTUaYPuoG6YMHBKry+DN1dh5yUNYBYWzHGt59Pw6/nLgQlL3xDb/3DkKqlXAlSdw9RlRZOhHwuHK9L7ijAFzO0XV4MmOHG5IqkURhodN6wSGhn/96188+uijVFRUsHLlSgoLC3nggQcoLi7moosuiqmvqKXaO+64g82bN9PW1sbEiRN57bXXYh74UOD3+1m/fj1nnXVW0PGzzjqLFSvCJ4T5fD46OzuD/gZC3WVjWHH/owO2e7r4Y35w/svRDf4wDEPAuceCc48Fa6v5Igo6/Ll1Pp16bMLCGp+N59qHljyrbd9N5oW7ybx4Hy2THFR9qYjak8N7Z1QHVH2piKovFSEWjgpKmBZkGQQDQTAQRD34TzCQa60UvjXyCgZA3dlaUEJtOHx8oGxICsYR6IdNjTYxwLIpL5GaGJvrXhAMpDCbY73m4dHW3kqrGRsE0p9YSdYz2xB0gv6sHQbpT6wk4x/rUaa0o451HzdVaQOGxIbPxuKsCGPbEMAzOsC1Jw0+ufPaqWtRHmxHUKK0lAkCCALa1FIyElwEjMFXCQ8YGj4j0PMn7rcjd3pxLR5L5R2D7jYIcx9ch29uOQgCakUVpd9fh67HbusyAEEb+DxVlXDrfmo1N1es/FrQ35e3f5mAoYW9Z27dH9naJ5h5N5H++sLWIGOvkRFk8y9sd1YrgtUaExlHtDAks9iqEfCT/uRK5AjlNgTD9CSk7Asj4BkEsdMdDc/DefgqEhEEg4ScbmY9uaXnr+rLJeZcFkTS/7YGpTv8Tc1Z1op0ON8Mw2D05dv4cN9YAkfdFI+mUP90EcU/XBmXWhoxzz1ZGpBoIyoYphe/56NkYMgCklen+EUVzSPFhwuhwEPtWXrPvDRkoYclMh4o/f461MrqoGNhIieDvzfAn6Zz4NLHekJoAW5LqeWdH/0ezSqiK5GV4SMwZMH8PTc0cva3lnHpFTEqGEfdBik5Cd+ssqjIYxwNAZ7++nlUqF40o9f76NaPPfvhCcAjjzzC3Xffzbnnnkt7e3tPDkZKSsqgCvXFFMNSXFzMRx99xEMPPcRll13G+PHjkY9a/Dds2BDzIKJBc3MzmqaRnR3MypGdnc2hQ+FrIfz617/mZz/72bCMJ1ZIPpC22uPCBPNkRw7V/jh5kkSJ+m/PjYmT/+BF2WRsScXy7joEWWbPk1OQFC9fmbiKe9ODw2JurDqdNRXxYWY53lHbnMInWhnLprw0qPOXlO3g/tzVRKv7611d5P2/o+K4DR1EidHLFGZYTEv5u4njYHvioMYULwQMiTeeXxAxose6sJkLR0XngegPU5Jr8axS2HlWWr+hGVJqKv5pZiFHQxDofj6XiS1fZc/J/4h4Tn+Yu/5afCt730lFh5olaXjT4utbrz5HoYAZKB+sH7hxBCR/aifj8YHDyoqv28H5p91BzVdDN/+2DicTl94IwL/nPskcqynwNGsurrjlLhL94QWGg2da0EeHN6gYTVaKXgs2RvgnuNn7d9NFNvauarS+dXwEgf+3+xMKZQGrsIJeP1F8sP36h7hqwRJcJzX12y55vxZUWLAvUvf4WfOT2Sz8+SrEMJrX/B+tCZuTA3DeVStQrxDx6BaWPj8rYrhUzZI00gpnY3u995mW3rCNt769gIuu6xUet988noxNq5Ay0vFPHlpIhOTTKfy7SMXVArIjunCrPT90kP3qXBKeWzVw435gfXsdV06/gNc3vYskiOy56BGun3omTf9jvs/F/zE4eKYdRof3rMcCOSFA9Y0Co/8lM//Xq3k3ayNDnWdTLDbWLn6Ya6RToU8yvOHzkfeH1TTePpdAhEjs9G0BLMv8cE3od1mSk7ce/zMAk5//JkWvhzfsuXMUFn3H3DcGk3sheVWElVtMamdALi7EVxSjPGLA1279Fif9biU/y9zOkx05/P3rZwA/jXk8IwpDiJ4yLV7XG2E8+OCDPP7441x88cX85je/6Tk+a9YsvvOd78TcX8yB8lVVVbz44oukpaVx0UUXhSgZww3hKE35SMZ7OPzgBz/g7rvv7vnc2dnJ6NGjh3V8/SKMvGGIcGfaSpLE6EIPHm3PpyGQ3BM6MxRI2Vk0Xjgm5qJfhogZ01tUwO5v5CEpXn4x81XOcNSgCMFx9L8Z9QZXz0iDD46/Mjudqo2PD5Zh6PEx9R+dg/HvCf/gZ3XnsrKiJKrzRcGIKmTOlSeQMm8Kgk/D2BgcGyyVFtP0gMJMy64eoUYaQuXbeGCfK5MNS8dGVDCyz6xhYkp9WCFsMLBL/XvNjAVTaZjsQFd6i00lHlRpr4kt/Met+5n04jcRDFA6ROSjUgIMASwdAvru3n69BX5ku4rHq/B65SQuiDEG2hChdYKVhJS5OF9YzdiftrPrm1lIGdGxh+U9Y8G5ah+aPrDXpvVLs2maoyFHeD+Ofm/+0pHHYw9cRMpRCoZmE6k6/7Dn1ukL660DMNJ9VFxiofgVM6cha4NKe7sD91zTI7j7R2WUPpMHa7YilZVw6subKVcswxZyoQgSNknliAMj98V9tJ9aQmdh8O8eaNrKbo0PHlhI0S17KE8Irt3xjYyl2I7avx5pnU3AkFAEjf3uDLYsK8PSj6xhCNA+RsZxzTySnjEFeENVKfjXfta/3yeGcee+HsFwKHTlRyDoxCQECYIRH6+qYUCfcF1FkLD0EZbNccXerSjpnFIcTKPuUq2sriyi8iKB7yTuidtcUyKt87pG7gv7EMQI75zLjTqxOGK/R6ibn7roz+w5p9cg+3TdXAK6OfZUSY1KuXiregLK82kkEM5Dd3hvmTgWf6p9UPNJDBi8/YeTeN1+EpIPHIGBI01OYPhRUVHB9OmheblWqxWXK4I7tx/EJF4+/vjj3HPPPZxxxhls27aNzMzBxXQOBhkZGUiSFOK1aGxsDPFuHIHVasVqDR8GI2VmQmpS0DGjPvriTfFELPkY02zVrNDLaFWHTgEnKAretMFtNt15Mp70PIRc0yo5znKIDMnJm24bX//0SwB8dMYDFCsJnJ67m5dmnUzWupGnUU3ebOFpeQ7XTgu13OqGGHUdi2jR4bFx76Hp/CZ7PWOUBNIs0YVMnTJmLxenhHoB9wRcbPLl93x++rMFZNYbqA4F0SqhlJsJhEbtIXSXC6wWzh4VXZL1cOPVism4umwYHglnW+R5VpTQGlWRw1iw756xlP67xayF0gfGgqm0jXXgSxEQDOgqMJ+/rU0jsVJg/ubLAHhn8r/DFkY8gi1+Lzdvvx5HvdivQCPoJlvWEShNCoFUATkxgMcbXZLnEfxn+yyULgHVDt15EpazZsH76yl8KwN/kg1XtohrfhjSBa9M3jvmUp+wrhK1qX/L/BH4UgXklIFDGK765DbQBeRmhYK9we296TKtEyTklIHfA1EyMNJ91M8zlbKkSp2kag3d6sA7zY2Y7UVzKkiAYbUcTtQfuZhuraERyRcs4DnrDCTPAAnnBiQe9LP1/bFsspcjlnTz5CzTYxau6OHZiVvRDqd86sY0drWXh3QZMjYruHNEbEtm0zVK7skYtbXqOF+MT4HJWHDKmL00eRPYXhu5aOpQoHu8THzyzh4dJ6EGcg6YFaf9hbFZ1dNTukmzu5FFPSSPJUn2UpbbCLlQG0hjf2APY4a5po7WMHQ5ZJ5NokSpYoPPLAY6P70iJHyuPzy3cwbW9U5Sa4P3bKXLb+YKHf6s25WwBfeiRd8cpqHxWY0QvgDF+IqLi9m0aVNIAvjbb7/NhAlRJmL1QdRKxpIlS1izZg0PPfQQN9xwQ8wXGiosFgszZ87k/fff55JLLuk5/v7778eciCKlpWLkpuPPCBbUrbqO7Db4v+Zx/Dij/9CNNb4A77ZM7LfNcGCeTWKLzxsXJWMo8GQKaLbDG+EhG7+qPZdCRyvvVI2n5CnzzfhW6eWMTWxgXUsBvpRjY01P3+5DV6wwbWSu5/VYeHXPZG5JX0axbKPM3sCYnGwMQ+BAQ0ZQW1HSKc40wz9uy/qYmdZghade7WaTL58t7gIChsQ7VePJ/wQs7ebCrEsivlEpANgCKjSEv8fJNi/N4zNJ2xlfJc+QBdrKLRzYPYaVSqh1TTlgw+E6NjUXrjx3Ge/vXER6UybaYaFaKi3m0BQH/mRzTIYA7mzz/7JHJLFWpeuNbAIJ8EDeTG5MXRO2IN16n5/765fg/ix2I4ulTQBkApKB4gxQ6U4n394eMWQm6Nwddo4YIFU7NE21kPeBiOWdtViA5PFlHMgIHZOtGxKeM3NdhmMjz3lPwdEQgKMsnr40mc5iCXVsDHUVgMBEs723y4Gz3kfGFp2D2TbI8dE12krCaTNpmTg81MN98c/ODFZuK6WcXmpkW7MfW4atxzjjbIi+krLSDaJfIKCJLLRFNirNs/UKbQFjG8+UzsW5b2CFVLNA01QFV7GKmBBAFA1am2yUV03CWDc01qBYcUX6GjZ7C8IqGVJ6Gt6Zkb27lo8GrqlhBPwU/m8wvfCRM+QkBwnVdjptNsSs8MYLQTBIcHoRBIOS5BZKnM1h21lFlRmpBwGo9qWzXsrHIdSSewwKVR6B3OHh2opT+VfRhxGNk82aix3+RJZ1D6yghkOgw0pKs4FgGMjtvfuG1NqJWlvXz5kn8HnHvffey5133onX68UwDNasWcMzzzzDr3/9a5544omY+4taydA0jS1bthzTWhl33303119/PbNmzWL+/Pn85S9/obq6mttuuy2mfnyTC5HlULpNX0EaSVV+3vz1Kdzw23URK95Wq93ctvUm/Mv7t5hIfpMJYiQTb326TJM3YWBeeVECS2yW1BAYoPokit8K0PJGES0UkdXna9fP8tlAPiIwOpzLdYQgaCaDFBCWcSXuMAT+3jqfO9JXcFtyFXemHKRb9zKn7eagZkkOL++MO0KVHKxgBAyNl7rHU+9PAUy3fcafHEQSE73FGVhtFgw5dLLNTa+k88ZDbP/elLhaRlS7yHk3L2XjeaPDbjztN8zHNTyGzKjQNFvH3lKE9a0mEAQOXpzbb4Kw0qmR4tFpnmzhhX+dgu86mbsyQuskfGv39bR/HHuBtCOwtAmIPgtamcrKA8XML6kYUNHoVMPTA/eFtnMvhT/ZO2C7qCBKQw4Hbp4soZUNvm6BLpvc/aJfp/BNnQPXSbQu8VBYcJAnRr8KUVKIDxa/fPEKyn8U/PzFpRvJbBtH3ZlpEeu8hEMgSeJPdzzKKfbYaHZPsetsPedBZj9xt+kRi+L9dVbIuEoNRGcAKdPL3m8pjP1GMoamY3iGnqcwGGgBc10SdPBPKWLcL7dFpNndeOkYtOqaARWNSNC37CJrCyRdMIe6MLkLgmAgyTrnRkmr3Rdb3AU0qUncmlwZvzA9QUCQQvsyNK0nLKkvtJ17aT8nkc7t3p46HH0RMDQ+9eSy0T34vJvr5q3klawpOB+zI/UJyQ16IuIJZqj/Rtx4442oqsp3v/td3G431157Lfn5+fzxj3/k6quvjrm/qJWM999/P+bO442rrrqKlpYWfv7zn1NfX8+kSZN466234s7r62gIcOON3+Jvf/tjWEXjqzd8k2SrSNO0/vvJe2wT7RdNoatg5LSMFzbNpPyrA1OA6ounUDUvcjhINLC2Q96/htTFiCBjq4993zfdfJ5f7h2xarKPts7n/KRNzLOZlYR3LPh31Of+qnlyTO5tAF9uEq68ISqOX3CIAYOsDabl7p3uhbyWvGjYrmUA9m12Nm2dwKa5HVxcsiVsu2pPKhtemTSilVGMeZPwpR7bXB7PLDc12XYK3g02UOx+fix3fHgzb7/3n2MyLn3bLvJrkqn+WnSebNUh8fGfH42JorwvEkQbO299mNKnbo+ZMh3MMLS9D5uexpwXrCR+tm9Q4xgsDEOg6CnxsMcngCEI7PjpZBb9MnwC+PSX9rPsR/Owvhldcc1YYbf7Y86F6ot6fwq/ap7MTzLjE5YqlRbjGx2as2hpdKFvC42okLOzqLxxDFbhg7D9PdgWn3Dqi0u2sOd/suh4N/z3+uIp/RbY/a/EFyBcCuCWW27hlltuobm5GV3XycrKGvikCDh2FdIGiTvuuIM77ogTJ2R/MOCq738HQwBHk4qtqr3nK7lyO4ogULDaClYrB79c2mP1S6zWSX3bLL6kueNXffQIHmgrokPtJ0H12MoFxz3WvTmJHYcMrB06/gQRzhwGy55gcG/GKv7ROYGPuiew1K1iE1S+kVo14KltmpsnOmJXMAZCkuwl/WeV1DxYhr1p6HTCrROsjL2m/5DCtBe34Fw4nsbp4U2+ugLzz98SVN36eEJyRQDjqDoN7aUK/b1+0UL2gLjD0fO+6huTeWFbeIVG0IURzDzoRe5KlfZGR9g8j4FQeaGCkeYd+rj73P6CV0RqTxqaYSRu0Ed+oX33yvs4b/XtyOsHzxRXc55GYvFY8v+yFf/swYXSAOgWkcrLQHKGriWvLHiEUkVmgW07ylSNl354FoIa7KWTvDof/3IBAE2XerlyfHA+Ws4P97N1ygJG/XrwlNbhMCqzjRlpB4fcT8CQuK91DDcnbw3rTRgIIiLq/ImIAZ2AHF5xDGQ4EBdOM9uv3oahqgizJlE7PwlBh2n/+hYPXfEEZzkCh8ek8UBbOd3awF7PaFHsbGHrx3lwZaAn7PQI4kEecALHH0477TReeuklUlJSyMjoDfHu7Ozk4osv5qOPPoqpv8+dkjGScBwyX17ZHQBdR9vbW/3WAPB6QRAY9V7vgxA7XKjtHVFfQ9Bg4vIv8/bcRyiOIqGsQ3VEFECf+XghJRFo646GZXcdOUI+h+bGb0H6PEB2g61dx9qqImrDN/0TRCvnJmzHa0gcUhNZ7irnxe6kAc/zGukhSuS61gJq3iskm6HlVJQnNLLlsjzsnyYOKT+jfoEVf6pO1Z/LqaKclLbwFnjd5ULy9ZNrIECuLfp3ZUgwDEa938ahhakEjpLREmp0LF2h4xQDwWarjmILerx4AgwQ+7yqAaeBIRvYmqK3DBoi1H97LqOf2o96qCE+4xIEpAnlBBQRyauTdFDFEHsZno5A9cikrjO9ZtbO0LAW3a4hH023NUTILo2C93Wsh7oRauqZ9ps7+Pje3w9KyBsIZf++nZLXIzOp6G43o99tJ5Bq61fY6iixUHDDvkF7MfpijJKA1aKGLZ4YLWS7iuqwDDlsyhBADqNgAIySwSooWAWFTLkLJcy7hQG2FnPeJH7s4KnOeVw3t9ezUepsYkPi2CGNMWFLPVn2fBov7s3LkEV9QPa5aNGhOnjLPZp5tqqYksGXe3W+8sK3KJD8aP2EHBmigGY1v5fGleIblUh3ntxj5LC0C9y27AYsDtPTJ4oGl5ZuHvwPCgNF0JiRepCNUl5c+/28QjBGuOL3MTAaf/LJJ/jDUJB7vV6WLo29YOMJJSMKqA6FQFIa3pm9LqPkbe2mK9Mw0Df1uk1j3VYFHeT1ifwg/0Luznu3h2/+aAQMjZ2B0MUxYEg8v2IuGFD4joqyfBtSjsm2pTY0ho3pBFAPNWCVZZgb31CzWBBIkqifL5FY0fsySV5IqA9w8PTe+2BrEnpCWAYNAbzpCpZOA8k3fG+uxRpgem4tIgLliumyzpPaadXqBh0j29idQPaa6H6/7DX4z/ZZXDlhfVhK2MvLN/FU91wEzRJzdVgAS6sHa7sVS6dI0tOmlVEHvOfPobMgdDnpLjBQs304d4Um6goavFsznlPy9g6Kr30gyN0igqYhH34faGgl5UACAedhgU8Ab6qIvVk9rFD0j/4qPscFsRoGBegao4I9joYCQcSf5ewRnJVOjdQ9Bt6sYA+C3S2Qunvk2eJsm6t72Hey/7SCBYu/ht3aO49lSWfltGcHLdRrhs68jVdT9vdQZrK+MFQVY9MOfJfMRfboiP7wK78vVeCl0viFGi/Mr+DtkgScBwYfFulPMgicPBVLg4tAhiPEWzcQVIdEZ6EMBO9HkqwxI78G5bD/6hVXAr/evoTw3I+9SNnnRzAsPJ8ynSvGbuy9zigf3vPnYHtj4JouYcdZdZBkl5vOwrF4pnlITnKRao1vdMFOTx5jlEbGxPA49vpzKHgntrXXn+Wko1jGnxT8rBw7rYC5tuoyUBpTt1Gj4fwSst+3oFYN3Qt0AscntmzpNRbu2LEjiMlV0zTeeecd8vPzw53aL04oGVHCnSlTdMcepicdRBR0/vrC2RT7x5gejn0VQ+5/22vj+NW5Cr8ufBlJMHoE1Bq1u0dxea59fsh5Hk1h7He39STJSRnpeMea2bYWlxvjiEaqGxiB+CVfCxpRCWaRoFtEOgtkPrzmd5y58g50zRQKtGYr8nKZD6+5r4fe8Y7aeWyqmYa9cZAWKAFUu0R3vkjaDj9iwECziniTRRSLSsAfv9cg1enh30Wf0LegXobk5JKERrZ5YidNaPIn0O2yEW2VEWurSsHfRLb9Tx5jExvCCu/XzVjNc/YZZGw9zA5mEfu1xgq6gRg4PAv3VJK1KXijlkuKcN5Tw6dj3wp7/oceidvrb8XSEXwNQQPP0gxaL6kbFo+GvUFADBh4J/Ted/uK3Vg6D4dniRKO+ZMH/P0jAWubQMxahgHOKhnDYUN0ONCHITwTzMJroz489tV4VaeENT0FyeNFO/wMC67YGtRGtNl4fWsSZ9lbe2oGRItu3cu77izSL6lEi3Kt7CyUSKoGSwQlI954OH8Vv7W18K8DZw66DyHfw4FrZMpv3oU8ezKqU4la0dCsIl2jJLoXBs81SdZIT3LxP/lvUqUCqPxg0/XkPGlDtxBRCTuC5P1+bK12+J/eY9dOWcvHWWXwRow/sO94m1vI+/1K9v5xDmOLKiOySH3eYYigOYbPeLbk68v4tHUBji+6kvFfnJMxbdo0BEFAEAROO+20kO/tdjsPPvhgzP2eUDKihLM+QOPPSrjzr2+RINq499aH4VaTaeqWwsURPQaxYN9bY7iC7xBIMNh90yMAnPzpN9D9EtfNDM91LgoGvvnjzAJEBNuW+sbcSl4VYUX8XKn2ZoPE6sELHq3jFNxz3Jy+7OtBx6UMH00XwenLvs57Cx+iWEng4fxVbPnNJ3z7q3cO6lq+FJnOIonMjb2W14Y5CpddYrr+nts1PW4F+eKNjz6eFpL4OhAE3WT2Wnavk9Nzw1tjA10WhOVmYqWwaBpGP1znsiuAsdYU5sKJCt/74BVO6seYfrpdY9MNf2T2n+/qmafHBXQNYfkmxAVT0WwDLIXHcfjxznsSyXt7MgnPj3w9hJFE9cU6st2BY/Ukcv4YPlZf93p5pKyUyu3t3JVaGVP/f2qdyqdT7BxNxfvfDGPtVpRJ4/BnRZco3DhTITAhVJmdkV/Dj/Lf4opHeisCS0DTVNNLnbXed+zyBQ2Dsm+uZuPzkykp++9UMryZOtectnxErykYBsbxvDCeQEyoqKjAMAxKSkpYs2ZNUB08i8VCVlYWUhgWtIFwQskYIgrkBB6sXMZdS76CtjOUPjL5hQ0kzJ1A/cLo44YVl8D4x8zkdtvh/e6lisUAZGxVOZrpUo6ieq9ulRAWT0dcvgUOt1dr6xj9UDs1d0yNKQwkZb+GtW3w4S0Hz7Kg5XsGZMs5b61JTTwrv5q/FXzC3/7+R6799j0xXburwIJmgdQ9KhVf7t3lMjKiK0gWC5I+taNUKfDXgdtOstdwyVHVfwGaNB+Ptpoeq7ceW8SoA4OPH7Y+mMb6uskIVfUh343z7+hRGMQVW5H6sWQaEZJc5Zxs7l/9EmNkOwzwNB2ihY/vuI/rrrkTed0uhDGFVJ8fW9GseCAwfQyWymbT7S9K6AunYPRJvPSmyzzz//5f6HkGXPCX7zIMUV0nECO6Z3nY89dZYEDJ0waiqmM52IZ6oLKnzXsnlfCeWEbTBaWs/b9HBuyz5P2vMu6uChiI+vso5D6yno7LpuMbbQkqLPZ5gr5jL8ouAcFuD5sMbohQcR0IooEgha7b90x7n72ebC7/6z1hE/0NARqnW0nbpSK7h5JREh7NX5tP69zgdbLsiUBcjWr94d2uyVQG6rk6ceC5M2fjFdgfTUUeUmbN8QFp+VakaeMIJA1/zZoTGH4cYWnV9Tjn0sW1ty8oyhUniOGFLCPgR9BiNOEYwVWCwbROC4aZ/FhxuURCduR6Dz6vwujHgx+tIQgYioA0dRzCvmr0ri4wDAx/gOTTD9G8Jhs5isJpKfs1LJ3aoK1SB8+yEMj2I0sDd3AkjMmtWpAEkQI5gVP+ZwXdmpVX186g5LkIC7UAbWUWugtBTdQxRIP2cSKSYr48RdktlCX1KhnzCivZeGjUkKt/d5zkxWf388/ODG5ICraYNWk+ln9/Hjf/8SXm2apIFAWsQqj1MFsSuTHV5OZ/y1g0pJA0yauj2RXkzDS0vQcQp44PCgsSA5qZV6RrGFGuK4e+tYDDpTvQFYO7DlzBU6UvRJV8myU5GXv/Tj59fia5y1yk7jWf34Z/TYGzWjmvcPsAPUSPV59eTGpVqEZgOdCE3tSMmJiIUVqArvS+t40zrFz0paVhaau1aG/QSEIAV5GKZNUYycrX0SB7qUTzVBkhf+jsbbpF5OAZEqLV9ESKkoHuh8ylCuBHl0QCOcnISinabpOeVWtpBSDrXYUFroHrKJXv60Jri53a2vD5SPvsIEgiaDre8sHXT4kXXMUqoj0Gbfjw+290d2PdUtlzuOukUuoXCCCAbA3ekCRZ44EZzwEww9rKfd4spH5SdAyJAb2BSrfGG39dzILrN5CmuHhq3VxK/xF+jRcUC1U/mGXmVeWoyLbg33vgEgfKmQsOXxwKfz0wrftgETAkvMbASRknbb2E9i0ZGJmQ5Bq8kuFLNbj9/Hd58qklx9QzbKjqF8+P8V8cLnU0duzYQXV1dUgS+IUXXhhTPyeUjBGAcqid1D022sqDBQHNDr7i0Iqkhiri3BMs8OoKeMu8+FKtTJ+wjwlJh0LOO4JO1cY7Z8wCIH2b0cOSBRBItWHNy0ZqENHaO0AUmJ9VwevjnLg95kJpaCLO3b3Xl7xg7TBnu7VNHdTE1xWB1gmmByMaBaMv6l1JPNqez20ptfxflhm2k7Wgi8elk4Lapa+RSd3jpWqJDTXPh6joYUWvdJsrqBBUgb2NreLQ2DPSU7p7Ksfu92Wz3NuI1OdGtegZHJqnMMN6sF8mEkWQer5Xl7TToqSSvn3wCbaaXYaMBBT/aHxHMeGImo6lcHTPZ6Pb1SOchUCUcF0yi86JAeSE3vm0tz6LB9Jmc0PK6qgYVh7KX03xmClo62Qs7aZgkNauUrUgvtSk+R93oStiSBiU0dGJ7vUi2e34U4NjvPypRs/8+rxASvIflxu9sy5Ae5l1SPZa/ZANW5tA82QFIc/d8zvVDgsJFTKJ1b3vhWY7PM/do1AP1vQcV2vrSHx24ArFQ9nL1ZpawBR8rU47tUuySNk/PFb7/mCI4EvXBz8nDAOtuaXno+gfY7KpCXBu2U7EPhKtVVRZ4jhy/4dekwHMHL/0bT58mgwKKI0K4tJg5UCcMo6u8mR0WSAwzpwT4YQYId/TUzjOADovnUF6YqjneKRwY/Vi6rZmY2sXCAyyhmTbFI3MgjZKEzr5Vuo+Xjz5EAHN3OFybeErmw83pIZ2IOWEN+O/CAcOHOCSSy5h69atCIKAcTgVQDgsO2habOvaCSVjBKBWVJHY2YUnYyy+VAF/koEhQyBV5bqpoQWH2gMO3muaAYDcJYAI3iyNa6euhakDXy9J9nLlucsAeE5YhOSXsbb2Wnp8+clYJRHRHzCrigJnFO8hcDhmyqVaWdM4vqe9/ZAwpPwLAM0m4p7tHlRBscbWJP7sOZnb5j7dc+yHGbv54Xm7ez7/pyuVXxy4hrQdBleeY/72d2vG0+W2oqm9qobVFsAS55gXm93P5PT6nnoPmiHydmfwg7KJAXbe+jAQfdjcljnPMF24mu6OVBJqBn//NZuMVpIZclyXRLxjehnTLM0uRM//Z++s49u47///PBJZZmZI7DAzlZsyM6wrbGXY2rXr6Lvftg46areusK5dYSuskDJjmrRhZnIS27FjZtHR7w85thVJlmRI0jbPx6NbfDqdTqe7z+fzptfbE1RALFitiCUF7L/AG3LAeH7TNJzjPVyZsI7sEFGAgxE0EcnjCzAAjGYL2zsyKAuRQtYfxPJ9iBmpCImBxosZ4wDZG0+2jm2/FCA9O1gYMpgy/ihmFDalKYJxhM/rsgu8nUpYqdNI2OpFZBdB8rnWeomMlcEXSbdKGMMykHoZGaEQ4+MRMtP63AeAxpaYohum6kPfsRvXdekk7zQxLCJqfGTzpdVwo4aJlCmCSKIY2QDX7eBN18ksaaCxxYk5wHbtUmoKombi2CdjinBv5idkdwlxHApWNBZiawz8DnJeLtXHpNAx238/RPsNBaD+HA/HJA2NkVHrTaBNs5GvNIZ8XTdFlr0zrjv1ub+cNW0Nf885sF4Q+XL8gu7XKrQOHm8KFoYZarTKKmTTxLCkRa5r+wbwbZCwveOOOyguLubjjz/urs9obGzkrrvu4s9//nPMx/vm3xVHCHpjE6lPLKX6R7MYMW834xP3hd03SXFx8an+hfJzX80Cm8EVk/tX1HnxaYt5Pns6Rf8lILTqzYpHdg5D3FSOYaosrBrWnS4kSgYXnuIvIhMFkxc2TCVt/ZFRGO01gxcsumny+G0XkPfhV5hdzYsATsnbwhe1w9nf1NOf4pTCLYOmk36A04s2oxxcKNMLSTAQ++krXTPtRX5ZNIbFP5wJELJ2ZrBC5r60OKS4UoQlgbnMQmkxO35q63NSf3z9PDaX5PBUQWQdbWuthLytEmN8UXdkpXiBxqZ9Iyi8yB9JGQxJ21A1Uv29VJIgUn7+Pyl+/Xri9g7ysCmAJ0tHSvViGAL2jfaIrnXDClqZa9CjGEKMcqZ9kbnCS2uDhZYTNIR+zJa+ca7wJdgCIa+REEmAQxBwzx3Jvu9EHgPS38wk/qUV3TVsoY4VhKFTcq9fcrXp6unkz+nb4AF4oyOf7Z7skK/lWZq4MSlwrhAFI2gcsExsZsv0FwAY/dWVaKo0IEOj8fQRdOZ0vV+Ahxrnclfal2RIoaMWhikgmBDuI4Uo00xMWcBryHj/kk32u4HF/dtvLYCCoVFQGwifbBmJY4uVT5kWdp+gYTvM/RsOUxZCSpL3RhIM9CHV2A6NVrUPua0dY8rw8Cp9UXzfiM/uUQ4JS5Ys4dNPPyU9PR1RFBFFkblz5/L73/+e22+/nTVr1kQ+SC+OGhmHEkFk9kVrSLeEr6c4mMtmLY28UwQunbCCtYV5eH8TOJG1F8dRe1sZu7YbAROSoYu8snUSABPzI0+Sh5Lj77oNa0uvSd80sS3eguJaFXL/YzJ3YmT0ShE6DK6BYms934nfT6Ti6Ghw/LyaEfGBjddW/r+pyAPI8e2NbpcRjpuM9MW68IurwficxibkxR2o88Z1byt4p4kNf/UburkL4w5do77DTGeZrzunXBRNPONdWDY5whaZe9INyPEMuoEhJSfjm1A8qHK+iXt8OF5SqLlk8IqiteFuyjMsQTVZcocPVmzs8701P5yFa4o7qmtXd5aX5rIZFPw6WMlKSkig8vqxAduszSapTy1n+5MTEWUDQfSQFOEz7m8sxdVHh8caNYn7GuL5edrW7m13Ju/g9lu3BuwnInKgLmfdrGc4dct5VNSlRPj0yHiTTc4/ZQmKoPNw0/SwzpI3tk4gb4NKw/jg2gTBhPTV3ojOEF+SzPSfrWDr2VlYq4euhuJwo9n99V8Zq6NX3Hrw8X8wRrEQbg4pkJ38NG0tv2uYeFgMDb2tDWnhOvRjJ4QcPxrGW3FW6d0NGA9G7vDB8tBNXY9yaNF1HafTn5GQlpZGdXU1I0aMoLCwkG3btkV4dzBHjYxe7LvRPxHmPhZ9AXCN1sGVV9+BZVffRavS8GL2/dnGFCW24tbBWBSLgsmohP0su8eG/LdUJK9B0ygrLeM0ZMkM6fE6sG1TbRZJSZ3sv0Uh6+HD1x3c65WZu/58lI7gxlfGmBIA5OomjLU7WHbrFKY9tLr72h0Ow+JgBivNoP7fRew6K40LStd2bxNvr0U1RGrWZsUsdxsKUxRg6mjELXv8AgFDhKn6sK7siTaYPh+m90AaTP+bjUVCzs9DzTv0ylYHSNmqEb9qHygym3+a0VW43YMAuIf5wi5AhDC1RrEgOhwYY4cFbNMkMebGbBEx/QW96W/6x47aGSBmDix/XABEp8ru8/3jdNkzLsRtezF1HSOUN1SUYOpo9p7pxJvrQ45yPBAEE0+xlz33zaLo50u6t0tlw6g+NZNhZ+0CYOOKYmz1Iu4MgfI/TEey9hgxVU1JnLj5bD4Z/WbAsb2myhOtJbgMS5+LwgOvPdySz5UJ20kU7UiCiNSHw0IRJB4tfYEHE0/kox0jg7/XHjujnq6LWC/TOUxlxphd3VFa3RTDvuf44dtZen0hqf920jRC9hd640/9S9qlRRVttTarbLpxDGbN5kBJeEFg9+9momd7jzB5g/6hJpiMmltO00kOfM9mElcTPqrmSZX5zq/eZpSiRJxDxEFwYoXjq3tmEL9ie9jfX4yLwxhTEmBgqPFSd4NWQ4GOXInOLAlRNbsbwdq278dsa/ensX4dIhmmED5cN1Sfd4gZO3Ys69evp6SkhBkzZvDHP/4Ri8XC448/TklJSczH+9YaGdXzrAjj2gK2/b9x7wDw65vP6N4W9048CXt9uNMV2i5pxyooXLnnOCra/e3R3KpCvBzFjWC1cFZR3162oeCFDVMRa7qMAxPydZXGMVbaSwzkhMgLUp9XQRRNRPHwDgCaT6b14yzSQ7S715z+xYaQlYwkCEhLN/LOM3MZddFWhscFS9U+v3AOptXgiplLgl6LBUnWKUprQup3Ek50zI/fwAvfn0r+v2ScVT7qXYEL8Dnp5QA8lxxFnnmUaE4LVmnoPWIHmqodzOr/jCfp3H3d3y1aajyJrPzfeHI6V4fdx7Qq/oL4g4gvh5GLv8PWuf8J+b4TN5+N0jKwZU7qJg3nplp/sbAokf1JNjUnEFBMDwSp5fRFwkI7iZubAhYAcnEhpnyQ0MTO3cg52ZgOGyhy93MTCVOEjlz/vo4GDckd4/1ugr1OxVrRhKU1DW9SoLNi/zwDOSk241gUTUjxkvKeHamyDi3EfSSlp0NSPFgU9p4Yj6/IgyzHdu6yVUcr9NB07SzSXt6I0d6OpyAJ7bhWxib6C8r3j46ndn8SgktCSvEGREk0VaK6OTHouLppUnNApi0CuilS40sKbUCFoUyJI9MS+tmS3QL69l19vr9lJJQNqwk5foYi09rGqPRaGjvtOKvF7nQuUSOqKKvsUpH3NQUU7XcjiGi5XqQofzvregedhRqCKhBX0fMMLLEUMTW3ggJ77Cpi4ViwcwJSXWyqhIaE/95JhOdPToF2GWuDRM6injqjyvkW5OHtJDhau9LlDq95ZV9fiRamPklKTYGs9KDxxJQEtF4liHpXDZmgC7TnW4iv8mF2usLOAUc5PPz85z+ns9MvjHPfffdx5plnMm/ePFJTU3nxxRdjPt630siom2xl3MnbeKnkk5CvXzr7v93/Lm79Hu4MK54Mg0+n/pMaHZYsH4m9pmcB5p4E+bXFiOVVQ+r57Q+ODfagIsn2EiMmb6LHbUHrVMgY4sV0KJITO0m2uWnzWWmXbNRN8g9k9jqThL2BCxM1wYoppyB1dJL14FcsL5nBqrSCoGOWvOZDdcq8lj6e84b5Q7SJdg8+TcLnjd6DLkkGU1MqBvDtomOOTWThnIe58ok7+gyvWxK9tJbEkVg+OKkpQnw8oseL6PIglidjlISXI01N6qDUEbmw8qe144mrjrxYynj4K3bOmhSzkVHvdZL1wFeIRQWI4WSlrRbkDl/QpJi424f9RQe/HDEGgCuS/Ln1i1zD0BHZ/2kelgFkkDn2mzhXVaDVdCnDGTrxLy6ldsZMcMZeJ2QCUrmdrHcquhWOoCvtKTcZ46AGi9aWdvScVNT46BZFul3EUAQMWcCV5V86i7qERREQ9OgWj+DPtZbbvBh7KrHu3M3B9eqN42ZhJkV1KAC0NguWegnBhOSXVqN5g4vApYQEzOxU3HnxdGbJ+Ma5+r1MEyWTlpPcZLwXh1CQw76pVs4tWd79+oS0fWyTNfY1hP4Spgmfu0Vm2bxYhaGL0EWD3mAlMcLzZxw7CcfYZqal7o3qmE1qHG5doc1no2mkleTtkVOjeiO5NeS6ttAGRj+wNZjoNhmlDdLX9twb1Y4EFncOJy+rmWMydw7KZ2k74rG2RO9t1hygpfY4EC6f6L+PvqgdTlO9P51Zi4PTT17Og9mxpYyJCBRYGqnypaCaAzdKajyJrKnLBSDL6UNKTg54/YAogpAQjyczUPBDt4mo9tDXxZTAlSXgDF+WeuTyLZCwPeWUU7r/XVJSwubNm2lqaiI5OblbYSoWvpVGxrKbniAhPrKXtk7vZPup/0Q5TaJB7+Sx5ql4DAXRG3yhK09NJu9jEVYNntb/EYVgottEJM+hMzRkRefmYQu5OqFr8dpLsOm4jeei/T0jSCZScyjoE4qRF7dTenv4YnkJKNw+DPxS78zN2MVqJZ+dtWlRdf8WhMMT3dFtIoIU2st90Yg1rEwvQL1vcLT6PaWZ2BQZrXwPxb+qZts/xyPZgrXRZUXn3tL3OTeu71qjCq2DVTdMIHV5HxEksWdyNFQRt65EXahvmAJeTUawWqk6N6/bc3YwmSu8WDdVoo3JD3rN0qJ1F9nv+E0Gmimy+a0RQKCajSn6UwAORjBB7LLxDJnutBHBhPQPyjHa2hGsVjBMTNW/o+gVMAwhpvvJBHSXzLD/W47Wq3ZGsFrxTgod0vaOCza4Qx676/bvyJHxpAT+2h25IiAieSB1k/9z+1pQCqaJ6NUxB2lc1DWRpPUyGY/46yTCXTF9dBGaQ8GVIdNykt84jqYQus8CdbuNrTcmcfm8QHGDlbX5tLWHV43TNYnvL7uKV2c/RomsowjRLQBVU8Jr9EzRTYYB9BQ+R9ObJuA8VJG8T0zsb/QdwS24fwczoqiHOrCQXV2fR2OLE1nROfN7S1jyu+nILgNBNyP2+RF1A2VPbY/hfTCCgBjnQBBMDF1AECP8RkDTMV5SP7eSsCfQ2ZKz2AuLBVqHZcEtAzcyOnRrbMXbkr+e6IoxwcbDMZk74Xr/Od2dtjwqRbGDkQSR6xL381CzlQbNOaDaDLeusLB8OIVP+H9jbwFQ0FPjI5gm8uJOf5pTiIVnZ6aMO+PQp/ocpf9ce+21Ue33739H0W24F99KIyNaLrj9Tmb+Yjl/ylpDmhTHT1I3c1/D2Mhv/AZiT/Iw+7fr+ernM2JPl+gnb09/NGzvhc/Hvs7rDzh56IZLgl4zRQFt3niUZVuD5Fj7YnJyJbmOVj7fVRpx3/Tkdo7PClYvGmqSflzB3MTIuv+Djan6KLt2JTsfnImQERgF+3TGoxGla1sNN9eXngje8H0o5OwsvCN7+pWU/Afemj+jW2ktEh9Xj8D1RTrCHQV9prLWTrOijBxOyta+tWK3/mckvsTQB3IVaOw+5/Gg7bvVDs565B4ALrn4c36Zvrn7Nf1Gg+Fv3YizXMZWb5LylH+xV3LvEupvmkX7vBga1+2zU3Z34GJRSk3BN74o+mOEwBShfrI1YiqwboO6KX4rLmWrhtIeOqqhNLkx1m0Z0Dn1puQpkD4LLsSOBssWe5/yw7oNtBHhx4tt9yUxMS+2yFpvLlxyA+AX03i66L2I+y/YMhHruh5D4mNheve/1TiTbddF7mTem1G/agroij4QvIbM61sDZbo1VeL1rRM4+ycrsEsqzy2ZRcnLfUe75GVb0Dzho+pyUQHbfpuMiEna2zbaC0S84/se0/NfkpFdQ9t9XTUlPnplOpYYpsKsE6qYlbZ76E6qi9uS9/J6p5OVncX9PsY7b8+kcGH48dEUBLS5/rWQNohCEUc632QJ26effprCwkImTZrU3RtjMDhqZBzENRXz2PyI/+Fxtvn48v4ZzLDOpL1AYPPNj/CD1FU8YzuG6FW6vzlEKqCuONXCmBmhJ+F6dxxZ/0xn37lqd+ftiJ8X4fXTHM3YHv8vf7jtKiRv4DGjUcgxyvey+qJSSp7fR5Lin7jSLe2cXLqVj3eOCOn5PKZkJ3Gyt0/J2sGmSuvghbYJJP6ygtL46HKkD8awiMT/pJKdH5WgHBRwSN3sQ9CiG1RG/L4cQQ4cNq5LvBZTFNl1eTLbrw5c+Az79BrK/uBGME1Mb2hlCmHqWAyLhE8Ugn637MU6n66dgynC3B8tCyltu+yOqTQPt9GZJyAxeLVyibtVXBlKj5RnF85j61gw5hlCNSErkB3898YHAChWDKDHIykJIh+c9gDf3XwVHZ9k0nDDLNIeXwqmSdYLm0nYW8a+KyNHbZxfOch+eSe6IGDOHN89FKm9rl/TKGt3pEVUIWVL9A0dB+v62XY3oFfVRNxv+AM7qT1vOG3H9W1klf7Wjblrb99Jm13XxLD5PbCWDgNli3+hHkkVWfKC0LWvu8SLHKIg/+Ax8M09Y/F4okuBOjCerK/O4YS2yzkpJ/h5MEyBV96bg6CDcnDEvNdHyy6B0v/cBMDtZ77LbcmhU5vMahsjHvCndOq1h6YZ3Xu7RzMjby/zp2ygdnSPfHjNEyW4MgU6ylQEn8iIezZg9GFg9CZzgRVLm4a1WaC9yd7nvRJJCjW+QuWz380hcU0d3ke1mBf+H+4bSdodGoXNfoWvjnnDaRrR91Jq5JnbKY5r5LnVM8j+MHDfmpM1rpjSP4n6cMy3N5EjN/Nm6+So39OhW1n256kIJmS1Rx6H+ppjndUqikumrejIkL4/SmRuvPFGXnzxRcrLy7n22mu58sorSUkZuELdUSOjF3PXn0/rp1lkVPVMyPZ6/8Om2f15zIminRtO+IR/rjoGx5aefIzsL12Ie/cPqMPtkYy7zcZHf52L0xPoITJF2H25gCCaDMuv6i6GPJi2OBtvn5PM6MIa9jYnd/fkCIUoGdw1/mPSpb5vT6ugcKLdxR/6uSgyNQ19RzkrH5yJKQnUzda5YuYSUpROxuaG/h5p1o5DamCAv7dDq+bos8t7X7iyFGrnq5jb87GbBKURtRUqxO3Xo8qxD7lQ6cqtLXl5DBPqbw54qXitB2Pj1uD3AIgS0shh+JyWsKpGskv3p8QJ8M6CWTj2m0gHOSktqQaGxd+ZPlp0G7QVWYJSKgJOTzURNZPeDoXMk6u4u+gDypTQ/QIkQWSiNXyXvDIljl+Wvs1fLPPZ/15Pupbe0opj1V5yKezetu8YGQrcaJ0Kha/1HMPS6oLUJKS0ZHw2KeRk76jTcWVKqHEE+UNqZlnJPaESzRAR/pTebWDqdpGO7NinhI5sCYcsYG3WEAwT6w7/fWo0t3SnhIXDc9Z0TAl0q4BRawtZK6b7JApeEjF2bumlPhYeo+uaeNIU3KlCd/paRHqluik1FtRUDTk+cLG15d0y1iWWcklXdM3nk6NKr+yNrkm0dganw9T7nHy4dixxbULkngIGWJu6DEot9L340s5JFL/uQds3uJHPJjWONQ25YV9XfTKqIZFra+mWa/98fymNE010u47sVDEMgerrJwKQ81lzxGiXpU1H0EwkzcRZraMvcdA5KzCioWsiiUttiBHuOS1OommkiPPl3fgemc6LF6Zw6ejQEui9WfDKPOIrTGytOvrOnpqc+FXVOCoDi/t3XZRA/Oim7r+HORt4+asZpK4RsdcFnl/qVxae98zm8jn9i9CFwiFaGKG4OTNhLW+3TYy4//rWXHZ+WEJ2bfTOiL4QVRNrq058BbQXBD4fogbOKgPBhK2/KsOW04m30knRDyL3WDrK0PHII4/wwAMPsGDBAv7973/zk5/8hDPOOIPrrruO+fPn96seA44aGQHUrs+kIEQnWQClw+Ty3cfzn6JP+HHqDp60zSKxvOfyyWt2oHdV5B9JdBRpWBstJO4eYPjYI5L07BKMYydhdKkOaQ6JhnEyF0/6KuLCO0H2dBe5aYbItoYcbFVKyPQEUTS5PrEaODSSuYnP+XuRWDpm8Jw5C0STy6YvC/BaduhW3lg+mTUUM2pkFZOTK6M+/obOPC5tDE6zS1Tc/DOv7/zoOr2TcjWhz336oiPPQuN4k/PGreGDl2eGXLx4UgRszQLyAG9fc80msqLs0yMoFqSMNDxZ8VEeHLK/8mIrr8eoawhIg6u7eTZqlIc5gKGAJ1UgYU/f+8leE0ur2Z02dUPBQk51DGwiPtXhJaVkAZeOvwEEEcwuidDaOqzv9hhxGXEzaG124GwHa6/GZHJRAZ4QHdx7Y2vU8CaJqHECmg0qT+4x6ktm7OX9ke+gmjqjT7y1u6ZCVEHujH0i8SUKOBr8HeMF3YxpUdtcJnOg7MDaJOK2dTUEjVcxvBL4RCSXiPXdpTHVQPqSZNwpAr6E/k2MllYBRBlVJKBjecYaFblD5bmMGf1ukApgGALbOzIYHlffPc60qzbidsVeGP5hzUgmOCqCaqLc1U7ExYPrIQdoU200NEf/wBmmQF1zPEK2p3vBIYomrun+Z9i9zYl1XZg3+1TEPXYweuYv2aWTss3AlRNoqFl8QlAKpG4TaRgXeE3VeBPnhAY6LpqBYJhYNjt4rnUWSCbTRodPh3PUmsRXepE71IB7UausgoOK1vVrZnB6QU+q5MvbJpG2XCS+MngeTtztQ1ItvJw2iYtGxNborC8SRTvjLT7ejmLfuk4n2UsGx8A4gOgzsNcb+A4SmhC1HuftsDHVfD//Cz4pGM3yq6fD028M6jkMOt/wwm+r1cpll13GZZddxt69e3n66ae5+eabUVWVzZs3d/fPiIWjRkaUOOo1yh8Zgff+D3AIFrR6O0mL93YXrEVMANJ0NrbmhPX0DxVXzF7Ci4lTsS3oedAlr4DqlYLSAcKhayJyuz/9QPAZCFYBzSHRViRz3iWxex+mplSwc1UBhe+2sy072KOnRZlONdg4FiyjbIG/eHb9B7nIvSpaa11Oym7yG0k77p9F5rHt5NpaIh6zSY3jwx0juwvoelORobDq9wuZaJFDaqC7DB8rvKks6YhcIxIKNUHqjs649cOranMwYmI8nhGhuxz3hackHassIeypxNQ0pISEAfU4NCxiUN+V3lhaNCSPSNNIBW+KiU0YnG7x060Ky49/iCvFYzHDfLzz5WXEPqT3IGj+SKM7R6f8gn8Gva4IEju+05Pe9mJ7Mr985VIA5A4hJoUgW4OKsT5MxCpKRB/E7fFPSZ3DTeRGGWuzEFOECkC3iLTlS+gD9FFYmgVEn4yvSA+QTxUXr2X07hw2Pp+DYfTPiDF0kTUV+aSVdpIku/AaMk3e2Aq5D9D6WRY/bj2fCTMfobirhm2t14vcEfxgSGmpCAmBBoJRW48Rg4NMEXVkRUdTIxewG6bgL5DuA80h4khICCllarS0kv9x8MJc0EzyP+rbcaZbRdrzZc69LMwc9VP//731zDyKf10Bdhtr7gsWg+jmeDetx4NZE0fZ7lT0hsawu8odIhXu5G653OxnrUju8OfrrPJhf9YKvwWXoeMUjAH3VtJNgw4z8njVojpo7bSHSP4cOIIBSTtDf2/NIVG5MZef1Z5HWnI7/7vnb4x6eghO4ij9QhAEBEHANE0Mo/9rsqNGRpS0Fius+uWjgH+xXn7BP7lm2jyqZ0b3fn3bTtzHS7Qtt5EgD6wZVaxcOmYljOn5e+kPptGZY6HhzOiMDOc6G9l/8XtShSXrkCeNoeLUBC4+tf/hzUtPXszHY0ZQdnpwIbCUlIh+6sAH2f5ier2ox9XQe3hOoKfLdsmPl7D5O7PIvStyQfLHH0+iMMxkaK9Tuee6m3jq6b9REKJw+qm2YVFr6YdCv7GBK6ItTv8a9EE6gLcgBSXegbB5JxU39V+IwRShfoJC2ga1T9U0yWOQtt7Lq089FLOiz+EkYa+PllGWkAZGKC6Nb+bSa/xGR+mzN2FtHuK6sz7C73E7+2kUCyIN4y0MVtNjuVNA2mLDNy4w4qrtq0Y7FtQn85Ht0fc0OZiPdoxkWuFeNtRlYy5N6vdxlNVO5u+9mx1X+n+/O267jeK3g6OkW/9cRPn8JwO2TfnVTaT9M/qeQbm2Fs4ctjGo8DsUjWocn+4c0ec+tRd4aRk+ltz7By9dCGD/TIULz4k8R5313UWUX5jGir3RqfIJ2R62PVDA8O+2gBF6Di2+dwk7Lp9JwT1fxnLKADzcNIuLk1Yw3jIwK3m76uG5lsgLlPcWTaLo7cFxnsRC5cVat/He0BzPafuuB+475OcRE4e48PtQz8ter7c7XWrx4sWceeaZ/OMf/+DUU08NKwkfiaNGRi++vOzPnD/+O1j/mBx5534giAL3ZHzGGx2jBrR4HAif/W4OiZt2IS9pI3F7Kbvu7PsWyHnBguOTtQGRmm232DlrYmwa3rFgdHRy7O03cd8f/8Vx9sMT1Tjc3N9YisuIrckTwITkfTT8zi8/mWbtW1L2AGkb1KDCeQDr+j1ojU0h3vHNonG0wohztvO7gsBQ/UutU9jtSmNzcyb2vyQN+uemSXH8cedi7rnguqglXsUJo/AmRydv6b2nmS/H/IdQBeqR+PKKPzP3y5uwrBlILCU8UmoK+64ciTGIM5CcnUXVxSWDZmCEw3X+DPLv2g6ApcqHoQ/sA1dV5aM22Bmo+WptEhj5L39NlDISxGGzA17/3vXvcFnC3zn4fnjtZ3/iuDm3U3pV+AaWQZ8lapw7ch1v7xobMqKxorKAlUJ+VLLB4ZBzc/ANz+zXe/dcY3DayMh1FgcocjSSUurigx2jotpfkg2SFyXS9v009M3b+3WO31bUBImqc/Womyse5dBw88038+KLL1JQUMA111zDiy++SGpq6oCPe9TI6EWGFMdfR/yP//v5ud29Bvbd6OOE4h1hu6dGi1Q2DPFxF5mSnXOcW/jKk8t6V3S69eEo70xj6eqy7r/zyur6bDJkmAJJK2rQm5sxNQ1xy26KHi1j942htcfznlWwr9qNfpAMrGjTByUaMy61ho+fmMqIm9YHFIiahomtScVnSvSViLbcq/Ldp+4g2ze4uaTRkPZFFR8Jczn5zujkVfviknt/FKToY201EO+ojbkZnSLoZIfQuLeKGmknVFP7VQ7SQcIsgm52e0xcmQqT7lwLQLUrEZ/hT2lyqRasp1aG9dzFgpyXi549cNWKgWLIcM1lHyBhcopzE2VKHF5T5X/t/u984FrGpXv55CYbCzpKON9ZPqjRjPEWG6YSfeMsYW81FjUTb4RaFvlntfy+5DUypP4lQWRIcTF1x951pQiXTaPshhVR7W+0dZD7YT2VZ6QzCH3D/EgDT5EKhWCCuNtO7mc+9s9UsE5roiSuAYDVQt6Aj2/oYhT5tlFggtw1VJsS6Add178uno9rtoUfpwZGNwtkJ/a42MZQ1ZT4vLoUXQ9tRMRieCV8bidzYV2AaErLVbNoKQUjTKaVYED+h6EjxHuuNZhVsrtbMTAaRMEkQXYzrXAvq/floWvBN2Vpdh1JFnf3/kWORl76vzxU9xT/Dm6JspuXB72vPyxyldJu7GWOrX8G7FKPzipP3xGkw0F7voXGCSaSZWglho8SO4899hgFBQUUFxezcOFCFi5cGHK/BQsWxHTco0bGQUy3Kjw67H+ccPGdADww6bWITcb6ouU7s2gvEPBk6pSX/ROQyJOdTLRWY5giG92xT1Kf1JTR7rbh6rDiqOoZDCuVdF7vdCCJBmcVbQx4T40nkUWfjqOkejWm5g/vG52diF+uJ2HM9JCKvLYvN6IPYQfzTGsbF05exQbxII+9aWCpbuPmZVeSktTB9IwK/pEbWMD4XHsqv1x5NoWLgydHwTSxVLdhqP1PY4iEtreS1HddvDRyLgBls/cwMal/HWsTX1qJqWkIU8ZQP9Vf5K06JTLlwQthi4LJ3Ixd/K8sCY+3657xiaQtlRF0k+q5Vjw5Gkqim0dylwa932X4mPqzH4ABeZ91InwVrlIzMmacPequ0+HQEq0I06LzOoZFhLtTdnX9YadZd7FBdbDdE1grkiB7OG/YenZ701mhNDLO0hyxL8hQobe0IiclAn0bGf9X/CbTrQOrwzmteDML2icRt7XvnHqAUcOqKXI2seug7VJpCQ2zM0l+xp+OY86egDuzlyUQwdGttENymJzuQ4YJSptAS6kFcXIrZxT2RJ1yU1qpaUlA9R35U2lcucIT8XNgHEGGRiy0aTZ2tqfT0jY4xnZ8pYa+bSeizUbHaf4UrIaJJmJWeEeWYQo0jLOTvD04Cjtn2K7uWohYEAWTkrgG1oQwHLNTWylxNgYZLheP7CnUblEdLLlhFhnPb8Robyeh3MULn83hsuO/pHqeTPoqA1tj6DnJmyJTN7XHoDiQ6RAn7OxTrS4U630e1ntLDlu2BIDS6sGdHUfFmQe/oIZML7TaVGZmb+epQ3N6/ecbXPh91VVX9VtBqi+O/JHxMFCsONl9dnCjrf6Qeu1elo14N2h7mRKHQ6iM2siQBIPkLvmf2tokLBUWHAcpwcTtlmF3IqoCO9PTKXE0dCuXVHQmU/zTJcH3rKGT/ljofNzDFsw0TfRtO0l/eyaKW+HTMem8+t1AicNfrjybwieDvTyCYSK5VPRtA+/oGgm9oZHin/qv3ZYHZtI8KjiNRWmL7qGViwrYfXoi518QOofYMAUW1g5nZvoe7JJKjSeRrS0ZAftkOtojytxe0kuqsdabwJoV42krsnD2eV9xf+basO9ziBY23/QIACUZNzKyYRj69oOXlIcOb7JCc9kAXeAmfO4WmWXzopo621QrH7aN6/MtX3SMRHXuYK7YHHVXXtXU2amG9xQLmhHbXKJqSB4N3Ta0w/dfslfjlL28uvXYPvfzJptk27sivYKANLonulo7N4URV22lZaXfq7rjbAfysI7uFBt5uwPRG7pruOyChAoN5cO+UzPlYr/srxEXe5fkWJjw3Y1BYg+z0nbznnvU18LIALCuc/BP3zH8eH54I2N5TQHz8spJUYKLwd26QpUriR01GSHeGT0mYNb5jU3F5UWMi8MsK2L/Rf7nJJL/XhBMXDNcWFvtOGq1kOme/cVmUXEZAoYuIggmVpvKrIzdERUUkxQXp920mKXbp2FZswt96XpGVuXy2ahSzjtlCW91ziZ1I1haAxfZvkSZplFSUI1jjS+J19TJLFVauC6xIupO8R93jA4ra3yoMGwKjWNkdp/9SMD2VzsSuH/HKQC0tDkwTQGrTWVkei1/zVh55BsZ32CefvrpITnu12Nk/LoiShEb2EVC6pp9k+VOfpC8B4AfzH+S07edzt4Pi4DgCVpUYeObI4k7bz3ZtlYMU0AzRAbmOz50HGj29sNfvcC9719K8RteHllyUcA+haHeZ5rIHT7MlV1RnL6s8kHsaAkw/IcHef9F/4SQOELCkxssQSt0eUQE0wRJYut9qVw2NnyRYr0vnvgzK1j7fh5TUyv4dPXooND83htmMfqm6HtpDHfU8a9fx9Y1GKD8osc4ddwZcJLUv/Qp0/Q35xug10QwB9Y4TlTh1sdv5IkbHmKflsoaV6i7KpglHaXsUxu7ZJb7RjcNdmsezv7qlrD7lLa0oh+4FlHcl9q+aqS2doyppSGvoSmCdIhcYKYIfzj/OS5wtnHrvhlIiQlM/O+W4HHvOX960WRgY2sOm6uzME0BrcyFtNOO7Drw/XsKKzOXtcPy8B3iDzxjO36fiCD4i59D0tc9MgiXKUyLlyMW0/TflweENVRTx+jV6yPnvM18+NwkLh69Kuh3XN2UT1X9wGsWda9E2Z0ruscP9fjJ7P1+7IZC83w3viUOUjd7B83re0bhJj6uHkFjixPFonFOcR/3YAhmPrCCT/44h4QXlqFV7cN5Kuz7KonzL1jEczmzKH41cP+qk02umB089humwMqmIswT9jFt927GHtRe3CocWYqBvWn+iYuNk58O2n6Bs40LJr0MwJglV6D6ZE4r2syfstbQNnRJE4PHNziSMVQcNTKGkHt2rOUYmw/ov8f10sQVlCkH0gt6JoI3yt7CW6rSbmic9Og9IT2BS98YT9Kx+9m/JYPSe9d8Le5Xz5nTefVRf8fkZNHOmec/xOUTzqL9V5EjPpbKZvRde7r/bvzezLA6+cnbNGxvD07+7MEIioX8xQpWUUMU9oQ0NN/cMIHh/9IRlmzA8XkKF8b3rY+eaW3DusRB+VVW1u+2MUJfO6Dfc5S9mkud9fRX//WtEW/yxQ4LfxzWt+c/FPr2XVia0/GO639NUlxFB84P91B5a2SFm0hc98Rt2GY1cFp+3w3BYuXS3Sewdl9uxOLXbb9MwjQnYd9iI+/30SnsGO3tSAvXoR87IcDQUOMl3vjHg4dEBcsU4bOb/0SqaAdE7sr4hAc+Pj6iY2VsYjWZ9rZu1SFtuBut6xoZqkjZDRtB1zH18AasXFJE8f/83cSnyGt5dfvEkPup8SZ6cfi0G+tGe0xSvaE4OXcra+PyBuzdP1TEbbMyquYWtl/tdzBM+8NtFD6+KmA8GX7tZt6+dS5nf6dn8fvWnrG4+2iiGguyVWfH0xMY9ePqbhn4/tIx040rxxZR0vZQMvuu5bwxZQbD7vI7nxpP8LD031O4eOZyvNMDl13TwrSif2HpTEb+cD0m8PMxxwU4zQSLhefWv/O1Urs7mNUznwZARmJAOuRHOaI5amT0kwebi1hRXYD3D8FeaqVTIP83X5EudaII4SsRMyU716cs4cnmGehhJFEkwQwp5aoIEoogYRcMfn3Nf7l3wRVBkpOCAdKjaYzYVIseRafccEgjhlM/u6f5V0ZqiK7Pg0DVT2Zz83feIq1XsapDsPCXold56yG/VOmCn81Haeu1+BDgmL8uIVF28a//nk7RUy7qTisBwJsohC0qbS2R0S6eifOl4PqDgSCNLqPytzKTLRv7XGwdP3Ibm3+eSbt7JGfEb4qqi3iS4kLwquiewEVT4uJUCh1NjHO8zBRbJS+0TO/zOM9/MRvTYnJFlCmBDXonr7T3pMAc69jBKIuDWVY341f777ml903HsSCGxl/hmkNEgXVfK2ZVTXdt0UBJOmY/E1IHt3/NmdtPY3djSsgC0oMRJb97zFXqo/wPswAovX8renP4vHJhyhjG/WszudZPAfjb8hNJWmVFczDkCw/vBBd/mOov/ksV7d3jkyIQtSBEqtLJMSU7WbSnBAyxJ3whmpg+X58RHfc50+m4rpVJEQp7PekGeqqK3Mdz6Bruw1pl6S6Y7g+iYDIqYT9Oxcuaij76LITBrLZhazmEiywTRNX/3M68+0ZyPy1HO2h+ML1ehIMeL8MUBqQWdTCSbIAo0nrlTOqmm0j0b44SBBMt28fe0ywUvjd4hkZyYieT0vtXZ2eX1ADlNMPjoew+F2sSJ9BeZOfEH4eXtv3i/83CVutlVGNj91hvHCS+QmcnF159G6YkUHuDm02znut+6crEDXzkKmCLO6df536oOJIjMeEQDrGE7SGVyx0ijhoZ/WScrZIZOXv5wjO8e5vWZkF0iWiAduIUrttYRoLNP0hk2tv5T9EnjPrimoDQtGmCUGvl2Dkbg1SBjnFuJT1CLF4SRC5wtnF3jhe31e9lEgyw1fk/Q7cIYO2/90kcP5KWUUm4M3rOI1MZnIJkt66wuimfjityEHRwlfpCLraHKc7uVLF/X92O19szOAmCyb1p67AKCv8Y56J9ZmHAuYZDs0NHjojtxCnIn60Nm/ZjzplIy/DgXO+EvV6kzwMlH41jJ7HrTBuXFkdWnMq2tZKdHawCFYmd12VT/JoTQ5HYeZnfgF1e+Nduw8xrysxP8If3l7mG0aoFLjhfeXMupBhMGxu5nmKV10eLYafdyKTK16MGtUIsQKWK8RYbf+pq8T3r+yU0Jc4i5ano9PbNjk6sFU14C2JXmRK8PvTOToQYCyLDMSyxIWT+eX9wGT7uq5/Kzrq0qAyM3sg2DQq6VnZy+KHZc+Z0aq708H6v9urKjA95p2gcNmlw9e5PjN/EilMD08jmZ2zmAucBtb3+LY5FwQypghaJ9ktmUjNf44pe3ZRD4Ukz0ZO0iA1HZbuGN13EbJJQ2vu/gLZLKvn2Zloz/WNFRVNydM3q6mxYW0XEQ9ymQHbD8OduouzdrWhhjNmMVS7eUOZhSnDGpYPbw6I37nQRKW0AVh4gWXS01MG7iAUJzciCQbql/6IvB6Nv3o4ApOzJ4o3ceWH3y1+4Bb25mUhuJ/kTf31dinMGw8tvwrCYlF/0GBlSHNNsFeQrjXgMhS86RvZ5HMOp485QsNcN3vXrXJrG6XGn826IetSjfLs4amT0kxPtOqmZn7CrLY29e/1efkuj1F3oWzvVCousHFALrUwyuc9ZS+4zlhAdhlUWZg/n1NItDHfU0qD6lWPm2jpxiJG9kl96DBITXXR0SU4ahoDWaUN2CbSWSEhqIvboZPgDkPPzaByXREfe4HrZmtQ43LpCu2r15/ee5L9KMvDM3pmML3uZmbbQE/T66S+E2KrwoUvBalVpGhG9F1e3Qt0UK/kVhRgV+zAPePMEAXG8f2CunOfAOz54AuzY4qCwuZe6UXkV+yfaufTk/jcojIaLzljMK9o8NIdJ+YUH6il6Ij9WQeGYruBZi17DfimJXZ4M3tjhT2sa9mQVO/6Qwksln0T8rFWeIiq8wTrZ2z3ZSILJeEtPx9slE17lVOsZqHunIH8aWZ/e8HigvAIlKQ7NacGMMrFd7vCBp+t3Mkwc+03c6eEjVtGwvTkDu6QOeEHRrLtY5Enj5S2TB3QcAHVkHoqmBUUzzNkTqLpUZdcxzwZsvyWpkluSKgf8uQdzjA2OOYQLBUEwESaOhs07e57HXtQcb3DFlOCImdPhoS05rjuaq6eqfqMtCuQkH6pqG5CRAX5DY1rqXgA6VQudXr9zxzAFXC4rmluGgzqEO2rFmNO1NAd4M/3fzbFXjvn9khccdQa5f1ja50JWXLyWnMX+GrnXJg48LTEU3rIs1MMj1NYnZc7Q0foaTyL7XIndf49JrMEeo2Gv1ewn58/hU8RirXJzLFjGsAUgxsVxw6xZSL3c325dYUlFEYWpzSFl6gEQwJ0mYh/EBIXsr7zsEYrgyFPRPcoh5qiRMQDGWRSeGvFfzvr0nogFOvb9Al/8cBZiGM2mwicklt9VwFWjF/Nem39A95pat8STJAghw4vNuotrlt0UEMYWRRN9uBtxi6PfHjJBsbDv3AK0EGt2VZdQTSmqFJ+g95oSy/YX0NYe2hioa0rgmlVXs2rWkzhECx2GB4/Z9+ekSXHc8OE1xO2N/XY2Bag4P4uCBaDv2gumgRQfz/Z7bF2DcmgPmzrKxc5RPZ704odKMA/B06QIOi99969RdYM9O84FuLi5o4DCi/3RDf/SZGh6VLw/8h1eeiyRJ8uKo3uDoWOu3Ig4awKGTYqqEFzaXoHW4veAm6qP5GeWoN8wC1+C0O8mbB0LM1g+Ww6QJu0PCz0Z3L3iQowwvQP8aVHRsecmk7xnhmH9ZG13WpgYH0/OX3fxYcHAe7MMNrppoPYjtC+KJoZpdo9fomSy626Fsp9mou2pCNzX4QAx9Ieclr+FjQk57Hx3mP8+GOQ8g1iN2OOyetSbVFPilY2TcOyyBI3HEe9ZgaCGhXqpi93HPQ34O7MrHT1F82HS+wOwNZokv70ZEhL8EuURxAZMTaP4snXs+stMhOyB90fqjb/Ye2BRjKHGrffMu1+UD8e6rmfusp2uMcxZ3/13rAbHYGJ0drInKFPWQ5GyjZqbp4btIeM0OYxSkkf5pnPUyBgA/2nP4s9PXzhoCgDxf03gO8ffzrZr/R7qccu+h9fjH+CSElws71JlOMBSj85VBxkYvVFHuRD2xC7rKNpsVN0+OaxyT9Nn2bwyJonLxsXe9fuNHeMippFoqsTERd/ng9kPc+Ibd1H8RviZ05AFFjzx95jP42Aqz8siY1Uy1pp2tv/cgRDjj1p+m0B++r4Bn0ckfpC6Kmrp1K8LwpJ1KGNH4suILLvomzQM6+6GgAVo2j+X4Dp/Bs2lg9XVrf9oXomS/4Z+bc/VRkyGRuV3NeJGTSfrwa9AEPjbxvcpUw6vNGU4PvcofNExI+b3XVi2lnf2jqGjM7LRrLyXwBWJEWqoBPCOcw3qxGYocO4Fi/utFNipWSl8RkQwgiMz9ZOsfXY97yzU2Hn2YwHbetfobf3Ow93/XuE1+d4/b4t4PnUn+Fj8h88AOHfeBWjleyK+59tKhTuZ1W+M7f7betAtsPO9YexkGOC/T8JJkB8uxPh4qm4a16cKn6PGxLnvyCmaP8o3i6NGRj85f+fJbFw8HMsgOsz2T7eiFniYtvpiALwepduAaGm3d28HuKxoJbMdOyIW4uV8qWH/fHPMjoqDD6smmPzn8p7F/P/bcw7PL57N5XOHJlfXNAXO/+M95FVpfRpxompyyi/uIj5FwBhAHZkpQNXxFnypScjEPuBOzK+i0NHU/xMYQn6d9QlPbRzPx+MSSF6czCN5DwNDk6NwpqMe11YrL00fid7WFvkNMWIKAr78VJQ4O/qmbd3bnR9txr6/hOp5/VuEe1an8FzTdK6YFFlxbK5zO3NtrUDPwvinteN5YdlM8j4QwBycgnSh63+k0hIufesLhsmRjcsarYOzf3k3//q/B2Nu4nUwxR9cB14pYs+gqb+4idYyuOSU2CMsb+weh9cbPA1tvicLQQtsini6Y22fxyqNr8Nxlo+VFQWDWqAM9NvA+Gx/KcYzGTiM0B7ulM2qP10lVaYz56BUqmPqeXnMM0hC+BTQ3gbHJKvKEzc8xLX/vi1sBDvz5CoeLX0BRfA/J9e+/ymdhoVffn4+ZTcOjdreocIS58P+f/Vk2wZv3Mm2tTH+rC2se2cUIQP3vW4LUYWX357LcfPXDmotx0AZ5EchKvZeZ/C/2Q/C10Y4P0qOStjGzFEjox+cvu10tq4vwNE68KfXFKFmrhVT8OfZyrIRspOqaYgB2xdUTWSxY1jE48suHaNzYEWtnYUaF89aHtBB+Af5H/FJ0hjOS1zFm22TwqpjDQRntY7SHjklK77Ch6VDxpUm4kvs32/iSTfQk7WQ3UijwSH7hjRU3qbZWPLIVM7+xWqmx7h2TJPiuDJhHR8zj9NT1zNMic7AOM6xgxWiN0ilZLyjginWfYQyVByihe/E7+claUzU5yeVlqAlRP+lDEVES7Ijjxje3XTRaG9H3lZJtlRIzezYIz2SB3BHjoSsbCrgg6pReDUJWTRYPfV/gL+PidwqYWkNb6AmLLXTMk5DTojRiLUoXJXQQDRF1iqQsNfHRS//gFvOeK9bMKE/iM0K2V+ZjGi4qTu6eoAvPHDLYzcDUPBhBe6M/skRe70yphH8veSk4Gski32PBVZRo8jRyEr6L418MJ4Mg1OPWcN5iav4oH0cLiN40fTarvHE2XzMz90asP3lbZOwLnOSXhteNelAEzl7kwb0GBopJ9Two5IPGGWJvsbMKijMtMEJ56zi/c8nY2vwH8sUYeY565FFnctSlwVEww4U8BvHvc6vHjk3qPfO1wlRNJmY1D81qHAogk5JXANrhYjN6f2d4dsFPlw9jrjdMsUrgn93qbSEzpFpQdutTT6EL9cOyjkfCSQndjJlAIIzR/nmcNTI6AdbN+TjqB74olq3ibTny2hl/pzUWH6M2qYEapuC5XMPpqXESrIxKWCbsq4cvSU6ZRdXvs6MCTuDukHPd6jMd6wFLOywVfNs9SxSrC6KHI2hDkOL6uCdNeORnGrkwbqL9jwJOVVE6TRx1Pa9gLc2aZiCjClKdNXNx4SeqPfbwACodSXglH2DplLUm52d6SxfU0rpv5dQeW8q063999T9auVZJMx4mXPjInvaypQ4VDN40p5i3Re1oRINWkYCujW2VCfdKmFkJ2BpyUCvq/d3iW9sQl7lISFnPPtng7VJ9BsPUeBNMbGmuSPuV9OWQFt1PEqLhCnBSyMT2etLY0dresT3pmzx0laqQOTHtue8kk2aJkbX/GyTz81P9l4IQMH7Pv6WfDLKnPf7VRD+g5qp2OtEnHvaSNjs47jp5wa8XlGTQukf/VFM/1MzeAv7gZKS2ElzuwNDH4QxOlHjH7nLAAsLO9WQRoZ7nxO3AJ9Jpd3bmjscWFY5SV8bnSyr5DawN2p05ii4xnh4ovSVsOIXkfhH7jKOm5BNZZ3/vhFFk8fzvwgphX6AqxPqiD/pRR6npF+febiRFZ2U+NjH3rf2jMXjDQ6BT8mrpCSuoftvd76GrVpGiuLnjNstk75OxbZ9PwdmFGlUKYgiHaWJNI0InultTRIZTaXoW8J3Yu8XqkrCHoP2fHFA4hixsH+GlWMzB1bfdpRvDkeNjBip0DoQjP55yw1FQOxVHelJkWg7NvLCZiC0nuim9cTAbUWPlqBs3AO63mdKi+aA785bxC/T+5aLvDS+mZ9uyEfOcJNZGni8JjWOTs3CruZUyq5fwfYnp0a9mO+c1VUQWGUnd6F/gpTc4RO/bI0aks+kaWRst7UpMeBC0fLaNDRTZFba7gEdpzd7XKn4DIkVm0souzWGHhR9MPzKNdzzwgWce+wzUe0/xmJnjOVgwzEKAyMnA8HlCqkQ1BtBsRwsuBM1pijgHZOPpbXNr1aFX08+/n9LKbkjiS/Xl2GvlCMWwxoWSBrTyCl5kZvx6YaIGK+ix/uN3p+tPA9phwNfmj6Alpt9fN5wN76J0Y0R/26cQ+evcrv/LnnB4O91Z3LylX+OqpbDZfjYrfmjBUv/OpXMGi9qghXRrhB3VY9Twuh0Udq+J+C9ssefv15gD9/b42B6F9QOFqJgclLONt7YPQ5PlI3jDEMIUmjS7WBIJpK9J3piFVUUQUcNsVpzVEm0VmV1/52+WUPujK3vgykKqPEm6094BKcYuUalLz4f+/pBW77Zzc7iHR6Oz4q8QG/TbLSoPZFOx0uJpO0PdmAtvaqEpDHubqfRFTOX8MKnc7DXRncd6ycoJMbnkfBuCwBVp6X3mc7rSRGoOi2d3Ap/vx7T6x2UPkCGx0P8/5bSecds9CEYoHyJclBN0e+vfbpLdKSHtV4vhbL+tW4eCEf7ZPSHo0ZGDKimzmmP3YM9dlEldBs0TLCQscp72PPs9txkAoVQZafknvB9DV777p9jCtdrtQ7eNMYHbMt7VsHy/grSCB3hiIo8N/uu8P8z9zmlT0OjP3jHuPts2HW4aLg9D3PlRsoGcu0OA5Ig8u5H/+OYm67H/kb49AtBllHnxd4xPFqumLmE19LHw/LEPvebevrGqBfHnl0J2HulofjGudBLXX4Do+PIK8jP+8THdzfdxZI/PxZx3/sbJ7H4hzMBiKNn4eXOsDDjoZ5mhS+9O5finwaOG1kPfEXNykkUPBSdGESL6uCDHaMi73gIkHfbehSaunjgyic51RFoJNySVMmrHQmscQX2DRksOjOlrrS0gRkYRwnPO4umUPRWz73tIHSEvPhZ+GzuZC44v/+F3K0lEq23Ri/9ayhQ2bV/3oetsObIjwac8quF/Dxta8T9fnrypTT8TQ4SrznKN5+jRsYhxBSgfqKV5O0aTSNkOsd6h8T7OVAMj4f8f6yj+vp4RsWs2t03o360i/IfjkQf3r8Izt4LDdIXWoivCJ3XrnTopK03aRynHJaCtyORu/dPYvPZOWAOvfoV+OVMz5p/GY6d6w63Pc3pxZvpLLCiGhJfvT6h22PtSTeYf+xaAJL62e5ZMMCy0W+Eu3MjRzLKLxWR4vrX1Xgg2OtU5txxQ8C2tiKJlT/4G8fdfVt3dFXUwEJk7+n8k1dTd0wqmiHiOrmtO1olLd3EmvOHMeHV8j4LpTe3ZbF5f1bY1weDUwu3sKSuOGJKqXKQzLcpwms3/oli2QYhftGz45opUhp4rXXKIJ/x4efsuGZyy1fx6yknhew2X/arzdRcNZaO2Ue25Gw43npmHvlbo6+by1qu8v6+uZx6W/8low0ZvCPd2DbbY+5nMpjk/GstzeeND9nzypUloMZZSN4+tApTad9t4gz7mXiHZ/Dxc/8e0s8aUg73pPY146iRcYgxZGjLl/GmmUiWwV3Ax4qWprLv3tnk3r8kSCvd6OzsKuaO7hxtOZ14OiIX7+rNzRS/0kzNcSl0zox9spKtet/a8iaI6qEdzYUKOxiwtzqH3elpXD5hxaAdu+U7s6g7pmfh93hlHs8pgQvVZ0ve6jO9olO3olX1GBiFj4iUNN1A+Xn/HLTzDKK6LmKq1KHAKmpYu/KlUo+rweiyPJ0W76DUz3QrzhigpatUzPen6OQu1LqLejWHRPU8Ccnpjroe6QAlmQ3cVfjBwM7R8KcS9kbymUx44g5yayNHVpUOnTf/4+9QnHDyfo7L2kGS4sIwBV54ZDqj/tyKvmUHpupD21PJ4v83s7tKtmGMzBkXLGFhzfDu43lUOeZu6ACLqkuYmF4dVadwq6gxJqWGvPgWNENkXWVe92tah4LS4J/6RBXi9pkoboOObInLrv+IYbI9bP2CIkiMUFSuSvZL6X5v65Vkl9VT7UghbsfXu9BVESSmWQ0I0xhTb2ujvdDkijEreH7TtEN8duHRG63UeyXIDf26YQq8+eJcUnf2PJPRIPoMnNUab/x3Hide1s+CeCG2/jgHaJicQHLcRMTFa/v3uQdhuFykLt6HdVw2jWMCl32mCKY8NB65Cq2DC//vblJr1ncL0CgtrUz/6U1B++o+D/CzITmPoxw+jhoZh4HOPBM1ST/sF1+2aXjG6bjPmYbz061B9Rk3fHQN953wKlfER07XSXa6qPMFfiPbage2qqYg+Vxj/VacpTPo7xKvI09A8inEVR+axke6KkJbYEKtaTWQ4jSMJgv21gM53QJe3QqD1By38uQE3KM8XDF+BYYpsLktm621GUELtEdTxnBJwjoK5OBaiZ/WjueTDydRRE96i7hoDanDZ8F5g3OeXxeOydw5pMeXbRoU+BfzTaN6POS6Dch3xWxgAGQ62pjvGPz7XGnXyV0YnQNBVE3S1/gNxqrkTD6YKHNK3hZEweSKKctYcME8Cj6wYa7YAIYekCJXUDmG15JnIOQMvIlbW7uDzpTghfwoezXxoj8yaiCyxlWIboqkWzpIt3SgmhJ1qX41iKodGTgrJGwNBxZ+JvYmDclt4EoX+XHqDiLVLzhFG/FGB/MW34rRbEVOdYP29a95qNA6OGHxrZR6Qtc2NH5/FpNnbefSxBVUlKSwuDyyuuFQo7VYsDaL+MS+Z9O09WpMBsYBJK9Bxhov2iX9yzkQdL8R5Es2UVqFqJolAnjSBNytVgazK462txKnJIGQAUDTSLnbYWfI4M5QsNdFP9bsPkfhTseesK+/47Jx6+ffo+zpJQFrAKO9neSng9O0NfPwNTKMmqMStjFzuNe530rUDBXZMTha+gNFEExqLvZRtj4FDjIyym5azl/ePIkrumQ6w7FL7UDvJUNpAkaDlfxndqDX14d/Yz/RRrpodNrRFf+CI6HCNyQPo66K/hy3DhlHVeAk40sUUYG4qqFLeDvvkp58YB2RTfuyQ+73+Pp5jJ6+jwI5cCH3vsvK66/Mpei3wb1MLJ0mL3UkcrEzOpWxocA0TCS3FnW374MRTBPRo2NG6Fh8KBA0AV0TkWT/dOqe+vVMKYlE3qc+9rvS2HpaJiPjawE4/8JFvOGZR06IAJ65ahNle1LY8VBo9SndF+H5Ec3uawrg0iy4dQWn7CVZ9rspTrDvJbvLwNZNgz0+//YO3YbHUFAEnWMyd7K5LYuW8uywik+i6n9mDq7FCMUGXzLDLl/L/h/MRq9wDrgbgJog4c48vPmdKzw5DLt8bcieSuKEUVx/5xtcn1gNOHgw70MmrrsdyakhHOJ6NtMUMFT/fGOvlhFV8KWG3tdryGxqzT5sBbSC4RcFcI9zo3ttiB2H9zfWyvdgK98DgoBQNqvbyNCt0J4vYmnzbxA1E0ELvmiibiD4/NGupef/nQwp2Ax6s9NBi+7gt+tOp+x7sTfsPco3i6NGRoyY0ehlf4MwTQHV1BERQqYQuAwfp311S3caCoDulim7fdkgV3MEcvLxa3jkyqWops5JN9yE7Or5tGgnlAP7mSaEWuNad9nCShZaWgUsrYOvjtNfVFNGNQOv+B9vvJL8j0M3S3S+tJRnlh3DeV+9DvhTJQYLI1qLz9ARlqxDnDMxZglbAMEwEZYcuroPo48iH/t+EdVlxSgePLU4EzBMEd00+pQfPYAomP7BaYgvSNZSL1UVwym7q66n9kLA/xDFYPCZgH2btc9cdTXBDLimW/Zl0ZTi4Py8tb16gPRE8CRB7N7+vsvKks7h6KaIJBjU/b2E9KbwBkRiuY/7b/kOs558iESx7yJ+dZCr6SpPgd3nPDKox4wVPczMJlitvPzOUwEpmU26Tsn/DMovk5HjDq0HWnfJxO2Mbuzd0paF9zfZiDG3ow3E+DrM+mIf96QReTY2RWgY57+u8RVGSNl4pa7DL7MrCHQaJmqI3jUPX3EBLN9AEeujP/ejfGM5amTEgCJILLnpL0x69YeD0ifj60DWJXs4x3I8RlkB77/534DX/tpUwsez8xjm2xaw3TTNQ7bwUwSJ1x99kOP/9CNSN3pR2n2wfjtM6bswM3m7TtzbawAQJJFd/zcJs8i/mDEB6wbHYS3Ui5WHbryEx1cEpjkoHWv7fI+2t5JzRh0PgPF6PO+PfGfA51GhdXDykpsp8UZOTRJkGW3u+K+F1W6YAq+9Nhfb0NZGBpD/jEzjIh+nj/0uH7z+n4j7/y5zJZueWMpd19085OcWV6Py1c9nMOXXq7BLKvMvXcrrEyYy/Mo1Ub1f90kRDQzwNzczN3QV14/yIMkGpUn13JG8k0hpTSfb3ZQoy3mpdQo/Tt3Eh8q8iOclqibn3HA71/7lta4GiMHMWncBSRfXAe1hj9M0UiauWiSu5muQAgJMWH4ZOd+poq/vdIAf105k2c+nIQ1w4d5f5DgV91gN+8ZeUrSVEi+/NZeLzup/kXZYTPji1ckcedpxPXjPmMYLjz4Q9vXvzboYbV912NcPpiNfpCMvsMYy770m9K1d47ppcvPY0xBCeefaN0b9OV83jkrYxs630sh4qSOZ78X3L00kUbR/M375KGm6eBLNI8GwmBy/6RwAWl7LJXGPitKuIbb1LCoarp+F6+TITd7yHxhcAy1ZcnDnzS/xq/cvJHuRTN35k1HTeiZ3sVPCXuP/zII36xHcXsyOTnTVv2I0Vf9PagKaV8JaEXnxc6hRBJ1jSnbyVWUxmhrosZpRtIdtP8xAe38sGf8IHbkIx4E6nM5HRjH28ivYOPO5fp/jm50O/rjrfPQYmqCZYYpMB0rdXYWs+VEu5w0bPG+aqNFnlEDuENB22wclmlH0qICyYQe6y4XUGZ1lowgSKdLQ9t05gBovUXW8SHPlCETBpDi5EcUSnAIqTBrDjksSgJ7z0tos2PbL0T1jvSZ1a7kNT47/uY4msiMJIoWyheuSVqIITq78xTs88t+zyFradzqU5DZ44O8X8+cux71gQPL2nvEksdaF0e5fjOe9WkHdSfm4MwLvY1MEd4aIbrWQsCfy75eyVqIs+Sq2H/NsxH0Hm+HP3UTpc63d36kvpq2+GOPNVJLch9DaDkHQz2+CqA2dt0LQ6FczO0MGd5GKZbcN2TU057fv3tlce+X73SmDoRj7djXLfjYN67vRiZKYAkHOH8E0AyKV0dwvRznKt9LI+PPzF/D7fAtxRa2sn/7C4T6dIw5BsdByyWQAGieYCNkeBKCq3t9B1mH1NxI0JQGbKFHzwxmYEqhT27mwdG3E4z9/yRwk7+AOuFclNLD12K94KWMyAoE3tiYbuLs6IdXPTCPj82r0hsBi9uyvNPbrdrQclX4qmgIguwVe2jqJC0es7VPGsz9k21oZlt6AVw98bHPtLRTlNfJSztx+HVcuKsCxz0PHZ4lMt17ULy3zF9uTeal2alRd6AFEmw0hL3SNSbSYgoBcUoReURXUuEpYso74BTN5fv60Aat9HejpYInwcwqG39Dw1NoQMrwDylVXtlaht3Q5QhqaKXn5RtZc8EDENJ5EUWLv93Ry/mdBaR/chMX6SdbuhZZmAyndhcvl93buEVIwDIHWK/19NlLe3Ize1obU0kHirgRau0oytFYLliaJ/thCkhuy8ps4JzW6aAmAVVDIlv3P/hM75mBtiu43SdnaY4iIuoG4sOczex9Bq6xC9uYRKhynW8CXKNCZE16kojNbwRQFTAGMqsFvVPaJW+L6t77f/feFxy7l/sy1NOidzHj1LgCGLXBhrO274eoBGvYnULLz8BoY4RBVeGnLZM4q24BdOkIiSII/8iK7lCFxXFXfPZtZ563jzpTyPve7P3MtE64fhT15JonPLQXTJGOVh8axNtQoqsvT16nQEH2jzW8sRwu/Y+ZbaWTkfNGJLOvUT0rmwdIiAK5P3I5DDC7fe73TSYrUwTG9FEKt2S7UdidKW/8WyoJXQrcYAQWNhwuTLglWn79AW4yLwxxdQuPp/iLiA9/QNAWMRv/1aS/WaS8GW71M0dIUTr58aUyD+uXHfsnaljy2VWcO5lfhd5nrOTtxDd9Zel3AdtmqQ5Z/wdWSBYo7m2SfGhA+tr6zguTEmezPGdg5SG4Q1zlZm5nHqIT9gz7ZTUyqGtTjAfjyUjAsEqmbvHQ2pfJgURG3JZVH5S0GfzfXp6rmUF6bhqELSPtsmHrfC1zBGYe3IGVA522KAp6iVCzV+0N2x018bimSOpMPUkdF1c07FPU+J+sacrGui24BKBj++gx3GsRa5qJ5ZOS6rlzzXt9Hr62j9I46bpl2Gr/JfZtiJbzHMlG0s/O4pxm1/WZSNwhYmwcuMGGK4E5X6BjvQVJCj1ntXY0ID4wbzqrhWNbtRtu9l4wF7bQeX4DmlrHWS8id/XcwzM/ZyrlxkaOlobC9mISjdvAXyNYWHU+yiBriZ9Et0JktYmmXsNV5EbXA6+eaaMVQQHWag6LAdTAfto1j+A+Wdv/9+m9mYZwhsNeVErC9v8hNMpps+MfYw4ygg2VtHO7hlu5x1yH72F9iIXH30IiDRMQEzSUPWBggFFJCAhde+Tm/TI/OQFw3/QWGtV9DYlewWvp8NfFJ02nPk8MaGoIBtgYT2xeb0F3fTDGLowwt347CgoOY8sA6pj+6Gn1+M2/ddiJv3XYin3kSaDXcQf/97N9X8d2Pvk+H0TMBbJnzH3KmV0cdPhVM/8N64L+4PRJCw5GhqW7qAiU/Xe7voyBKaJNK2fXDni9mmgKGIaC3KxS/rgX8l/2lF8+kQtyGhQ7dihpDPFkUTASxf0aWKBnIQuhJTRQMRKnv49af7WHfBUVB2wWDQZGiFAyoeL+Iva6BLaIPB3E1Km/ecSLNRvSu5qvWXU15bRqmKUCjleJ7lxwRPTIExULCm2tJ/VXk/i2hUE2JxZUldCzMGOQzC8TQ/cpUjh0WSu5dQsm9S0I2Q6uf3cIP91yAy4i8UN5y/SPUzBUwlAFGDAVQ42UazgpvYIRi7/UGHceWIsg9fizHLsuADIyB0BrD/Rwr1ndXkLGqA1Hr1TcF/zggav7/bxkuI2+vxFyxofs/YXM5puhPqUmc3MCO454e1PNyGT7atcD+OUW/WML6ySatcxsR4+IC/3PEHkkp+MCHpcrif/aPELy63C3SUOasY/4tX6Jb+j+umyL9rhsTNYjbYYk5inFgrRD2dasVz/RSEmUXXlMN+K/P85HMnt9ZELC/sYKUzd6gzzuwZpE8kPL0UoyjBsZR+sm3MpIRir/ceAV/CbE9y/DCcjhm7Q9Z/YtHu7d/PPo1nszL4+9Pnxvx2LYGMygvt3a6Fe/QNr2NmYbvT6f12MCGYQmLbCTv8BGuKZ+gmWz9yRgAdp8vccXsYP3rUIxP3Ee2vZVPd46I+Tzvn7wgrDdzulVh1ZzHmbzohpgnvvgXl5K8JJ+9l+bHfE5HgbgVdrL+Ft3vfyjY9vg4Lp64CtjQr/e//OWMIOnioWDEr1rQd+2Jal/38Q1M/N0dbL/q0Yj7br/4Ec6aeCbe3/Q/La21xELL8bE3EQSovtiHddR0Ch/f2u/PHwx2qx1cd90dOIwhTKFZup7sZQIIItV3+tNHM1d4kHqlWem98tnlogIWfPkqMot6HWRwfX5j37iN0ttCS4jKWZksWPV2wLbXOjJ4akRhzJ+T97mP5mob7fMOTT1QJJa9Pp6k4/xNIweKbhVpHKdwqG2o3E9bMVdtCvmaXFLEtt8kg6DzyPpjeYRjA17/YPbDYaOdW4/9N4+tLOTN0akYx0zsronLWOXFFKF+shVTAGdlj7qUftwk5MUbMdUjM03uUHK08Dt2jhoZXfTpaTAhcbfGlF/dxKJf/A2HaEESRC6PLyfre0/z0yeuDvvWhL3GoKQsDAVGrY2Rf6tG65K3O1ieN+U9O456LWKY+cC1E2IciVOVTk4u3crHO0dEbRD8Z+aTjLfo0EcA2ioozB++lU/3lqL6YrzFjcF7qjd8Xsp6qRQ1XeOKaQNPTYiEmqwjThwddX61IMsY08ZgKgNb3Lh2JKG0CxgWaLh+Zvf2rHcr0SoHP70rGvYtGMP8vM0oYSJe4WhS4/j4o0kA2DqFQUmx0FosjP7j/rCv61XV0Uu/Gjqlf9vNtO03seK+vg0NSRB5fNhLPPCnY9g8z+/RNkeXoCZEF9nZP8OKa5iv35OEALhHeNn6y1IkBiey9cI7x/DFtOF8NuaN2M7lUGSmmiaYOvnP+Be3ZmcnxkG/645/zODeE9/CJlRhFYZYAtsgSLp0159mcc+Zb4T8/LPjamnb4k97e/GO01E+jLLHQdf8qHTYaTrtCDA0TH/jzXqfk4+WTODyY7/Ecc8+6p8tJGFv7Avl/hgYI8/czvqqXIb/oo2KC2Iz8gtercGoDFaCqr19Nu0lBqZsIgn+5ynUvHnh+muRRJPpGRX8I3dZwGuSIJIlt2LOOqGrFqjn/YIBqZv8hoWo9ty3piBgTB2FvL0SvbEppu9ylKN8K42M19+bhXO6m5Fpday8YDjFr0Y2AkSfQdJOH2PevLXb4ZSc08qSKf/llXM3smj9CASfiOQSsTb1PLiiagY8sAeIrzAwZAfq6MMThpS3OchZ5EXbUxF2H2ubjuiLfnZOXi/ynDSLK2ZG580WBZMUpZORObXsrE/r0yBQLBrXj1rMJKuBVeg71UxEINXSwejM/exqSqOj09bn/kOF0tV4SdRknlszHYCzxq0noatpXptm460N4wGQ6y0IBZ1cPDL6otYgJBPdrkTtdTZ1HaWqEV9JOqbUa7IxYfobd/Kv057gRHvkRbrk9f9nCuBN6jlOy6w8EuMd6Ju3x/pNYqb29tm0TfVg6gJKjYVTC1Z2X+do2dyWxZptRcS19t9taYrgztERu8YIYY+dooVqn89Z+R9noWcFLsJH3lUZtpFly9xChAtCy6sezCONs/n4PzPJcvlVx/admIBg+D2XkdAc5oCbhkoWHS0esl620jKsfwo9vbG0CtS3h69JOZhXOxK4+/0bKKZ/30NyayiVDTG9O9zvtvOBmdx1wjtdDe2Glj81DSOuMvBil/9xFjec9mHYz3eIlu7Xnv9RAzuu9It/CKKJVfDfP9+fvoh/acdS8lLguCD6DBx1Kp5lDjqmuhGloXPB6j4JqS78HFByejkXJ62gxbCjzDY4M2EtL2yYijFbw5dkJW1ddAavGi/hSo/9hi04dQ8/yv2ATWm53Hfn2ZT+p5OaOXER731Bh+wvOzEqq4PSTRuvm0XrSA05KbKR1NbuT4daYhTyY9nL/ZlrA15XBA3dIdN0eyeKHH58b9idQvEC/52v22Wk/CxkiwWtJrzD5BvP0cLvmPlWGhk5i3zUySlsHCcjJXsh2sZKJpS80vNQNpel8MPseThlH4JPxLTraDYDQZfR4g0St0pIvtB3iWO/iqjK1CbZhqTgLxzyVkfXIkNF/nTVoB47aYcPQ7bCzMj79mZ84j42rS7C2iiiJpgkj2kgyxkoj5egeLqabPXt/fOaKuWq3xszMr6WOlf8YTMyDiB3Cshb/d7jxaklOK3+iaLDayFuqxVLm0l8pU7TSCfvxY3itPzYi5Q/31+Kdb8MooqUlhqknhUS0/RHGgrTAh8BE4oXaPww72LuG/MGZ8eFNoS9psrDzSPCSke2FotYm+JRogusDAj9+BbWT/s35Rq81DKtX8fw6Api5wBXwQJIqT0LBFMCzSGFjruJEm2XTuPB85/iDEfgGDDxspvJfTsOrXxP0NvqJ4lsj1IBrMqThL3eoPUK/0OZd8petu3JJmNwH/2+MQXstR5aiyMvtKKhs8XO4605ERfrL3Uk8os151D8ev8NJdGj+evVBoAgy7RcMpWnznksQEBksHEZPj7z+NXdXq3wR+PECaMwNmwPe5+F4/Oxr8PY3lv8P9xP07aRdmw7D1aeS/aSwIWwqJqkbfDizrKhZvmGpBhcr7cRVyXirDLovQJzZYm0T/R/tydKXu3qRG1wXO4ydFNAEOGyqct4P3MUDUYqOQtb8KWEVmpTmj0Ipolg2vAmRH/DmiK4R3p4fNhL5MlOZtr2k37yf3n45jIS8mZgyP5x0lAEOrP9/3bsN7vXCKIW3FxUUCwY00bRNM+HbIntera1O3i7fAzHxG9lvr2zu+FqltxK9TwrK6Y8HNBg8WAeLCriX9Wnd0s++1LsKEIqkscbsmbsKEcJxbfSyADIWeSFRf0rCD1A8nYf237sr0fIjzOpnqsgFXegpOlcXLyBLz6ehdwZfmCwNWrkfySw51IJyRqu32poJFlHFM2Y0oFMoOjPa4/IIq7hL3QibtyF68SxnHzqBn6e1r887nrdy3Mts7r/lkR/IbgRbe8Gw0Dygj6wW8PfUyEE2sJUmqXAEHzSLhVBM8lYrdNRlwp3xvZZtd4EOt7JIneTF90qYYwrRPq8Kabuy6FI/7uDO668nJEn/g0Jk2GKkwrNXwsjAtW6lX//59RB7n0cO2JmOqYpsNLr4OP2Mf0+zuTkSvJnN/Plq5P6dwDBX8R7AFnROfnElRx73jb+vXR2gAdQkGXEonw+/9NDQWkrzbqLz+7+MycYPyL7v4GTud4Wm7LSs4VfwJ++CNg2y3sBakIqSlv4sUm3ioNiEADINo3dtwpYNgYWRvcXxw4L97eezXcvfggg6PrtUjvQEbj3wxu6PbH9QTBMBCPq/vVhEZ1xfPnHR6JWa4uVDsODahqUazI/WH5pzwsTXexIT2LEg5kh77P+cn1iNafe8EeuWXJHyNfzP/JROd+CmhnodVfsKqIYeDUNXYw6VVbzyOR8Cc6XgnsBmVfM5PljH2aMxQ4ESiVJgsjO458C/AqEd+VOZuPfTcQ5E/xd6g9m4w4M1YcEpKbmRs25AAEAAElEQVSl0nrbCKQD9pQZmHp3oCjcFP3d6ctP/je9O9DbBBU5OwvnK8u7x2M5KxPPJcMASP+gHG1/bcjvK8gyYmEuu24VkMLUREbC51X4wfJLWT7vEZIlf4RjulVhy/WPAH1bvD9I3sPpN/yJa7fdibXFnzatJtuQ7AUIXx1kZIgSUkLfEUajozOkCuDXiiM8kvH73/+eBQsWsHXrVux2O7Nnz+b+++9nxIjYa18Hi2+tkTHYpN69m3kJsYcRRdWk5D9QfomCHB99YeKFZWs5M2FtkFzr15m9P5zI+RctirxjDMxJL6fckcaKvdEVNGr7qsn+Rx377pze72I/wYT0td6wA0TrMAuelMGrJNz2uzGktg+NmlPJf01u+u/t6DaRj/71GOf/+m4EA9zpR46azI8/e4sbVn2Haz76XtSpekOBGm8GNOK7b8IbXOD0Nzs8d+W7nDXquO7mh77jJvDps09ycGSuWXcxfVFXx+7ZLnbMLg54fdhfBl68vGTCqzx3fyr/vuncsPvsPQ9k5xGQXx8CV4nKFdOW8pt6fzrP9SlLKOhqRNZhePj+93+AoJn9TpE6gHVPQ59pbkcKV+8+k3WVeSFfE3Ld7PxrGvIhdgXkfxic1qPf28bcjF0B217bNR6fNzrjZ9Rf2tE3bQv5WuJzS7ln8cW8s+St6E7QNBEXrw39Uu9/Z6Wz9fuPMOrL76CpEkadrbuxK4Cr1Ids0yjNruPdEe8GHWu+Q2X+qvc5ffyJ3dFlbX8tWX/zGxZ93aHqsROouO7wSgOXKXEsfuifzPnBjdgawo890shh7Ph53+pkBU9Ig549cZRAFi5cyC233MK0adPQNI2f/exnzJ8/n82bNxMXF0VDlCHgqJHRhfrjJpo/zo4qV7k3uk0k52c7yXf0WPZb2zNxX2rBOlzFkKLzXhW+CaZgoWaOxGuX/ZVzv7opaB9BMPlg9sPEiQJOQUERJD6Z+w9O+vKWPr1BacntzMjYC0DVB0kYpv9mW7snn9KrVsfydQ8Jqilxf2MpNyavj9h8rDdfegwWdkyJuF/ucwr2z9cx2LWg9joTZ43WVQAafr+EvSrxlb1qILSeneOqfXz229nM/slyrOHCIUB5Zxprqv0Li8xeNT+SW0NcuQUzhiiGtGwz8pjhYdMHACSPwbF33kJCs0p73sA9onpjE5albnwzR/X7GKJuIH21iZsfvxn77EZOnjpwFaNUpZM5F6xh0VuTEGOoEXXlGAip3rD6QJIg8rO1n/Pzm67H8kHogtpP3BI/WP+9Pj9n2012ThjbP7Ws3lzo3M+wJx7nJzfdELJm7OvEf1um8PLuSbg2JCPoAsVfrEafNALd3v/pzbpuN1pz64DPzXfqNO575J+DHsWo0jo48dm7kUa2o0cbpR1EciUHf3nyEW766R3dKkT94dSiLXxZW0JjS3gvuAlYNjsQOvpOAdUqqzljzjm0Ts7qTk0Cf5Th3T/+lVN/ehdpi6vB4wUiOwTrbp7NP+/+G6CwcOZjXLL1cirNFFy9HESSbHDlmOXcnrIS6FlkF79+PdkLe36XhJYoi+iHiGNWfo+/jHuZ+Y6BOykMq4QwdyLil+vANOm8YAb7TtORIxj15VcIcMk05GaZknuPHBXCbxLvv/9+wN9PPfUUGRkZrFq1imOOOeawnNNRI6OL1vez6SjV8EzS0VwyJc/3PfHun2nFN9aFKKnMjQsswtQMyd/orSQz6nIPye1f8gqaRJli4bdTXwu5X4HsCJiwciUH9015nd9uPr27++4BxuTWYJE0EhUPzq5478j4ntCss9TLokf9Bcmj799P1qd1yJ4MmucfXg+mboq067ElL3/iltjsKcRl9F0UnvucgmPlXvTOzrD7mLpO3rtN7D8uJapuqABx1Sa25ugK5QXNRAhjhQgG2Jo03n9hlj8UD7gzDS45/is+rSnr3s/tU9BU/82171i5O4RvbbKSsyQ2BRVT9SHu2YfVm4E3O3zHbnu9im1XHbZyGU9JKnWTgq+1qEJ8ZY/3zVrvCm3MmSamb+CSiKbqQ2nzG+CxFnqHQhRM0i0dMUWxXLk6JGgBqSB3T/qQ2bZqeqdOzLGJGIpI43WzGH5tsEfWYyp43H3fv7JDY0NjNncpk/lLdv8dBFZBYZJV7UoXOTRGRu7nnTSPdAx6FMxlWHB5LCjtAoIOhteLvKMKKS+zT8P5YDxpCnXn+u8hrWMY6MHnOewlDemzPq67KLHjb1MxZZO8jwQE3WSObfCNAANQ2gXcbmVIi6zDIQkiE63W7jGqv9gllXGpNbQmBI73KzaVoDT5lycC/nGlL+U/KSEBsygHA7A1qt3SrAeY+cxd5Nb4wO0Jm550MLrdn1oEkCHF8cuSt6grjA/ab4p1H8lSz3NesuAGMpcI2Ot7FvTCmFIE00Ssb4mqcNp1/gxqp4vA4MzFHrcFj6kA/TMyRt+1geUvTCBtvRdTEDAtEvI4fwqO7DZIWa6AoNBeSMieInq+B9neVUQ+CL2oDheHS8K2rSsCfgCr1YrVGjmnu7XV7yhJSTl8PbuOGhldpK3z0jHF4JLRq6j1JvDlnAl97p8wq457S99HN0XWuPypOC9vm4S2z4HSIVBIdANZKBRB4mJnOC+ayF+bSih3pwMgizoPZq9kVeEW6rzx7G5LZW95BjlFDZTG1/XpDS+wN3PFLL9H4Y0L55H3fhNpi/fjTsvGM/nw121s9FmJE7wkimqfXY7X+zysc4+mSQttEexuS8Gx3O9lsn++rk8DAwDTxNi4leSsKWhO/0LekARahvdYjJZWE+d+/2LanSJhb9K6DcUBY/ao/7gyFTSHyMa2nPDevnx39zKxI9mC97RpWN9fGVNNht7SiiSIWEPlKPfer7oWU/VhU2SYlN69XWkHyWciqv5ao24EATk3sI260dKK0dmJYLFQM8dKxkoVyRvbtRN9OkpjZz8zlSPjSzYQvQKSV0AO8SiYEvgSuq5vkook+89flAxmF+7m8vhynGLw71V5mkDOsFpeLP40YPtSj85HrWOD9g9Fc2scy6QiGICRASAisvd0EUuzQkK5SXzl0Orgy1sqSDYLEAwHrsz+GRruLIOkjB5RiK3tmRQ6mshMaqcq307cHv8zqjc0IisKVl8Cpijiy+jbW9CRZ6Fxgsmlo/tO53ixYy5FTA5paEipKTScNYIL5izFKmo8J8zC0iCx3udhvOXwik8cyWRa28i09iyiPqgahdIsY2mJ7h6RkhIhMx1fWvjfOO9T/71tZKYg6UZYBbC+OM5uAKHm5Z5UvfO2XUTuJ2BpDVzM+1L984/Vo0JN5M9qLZIwCwZvDp5WuJcipYlIdRjh+Ff+l4xIGx+w7cD1ljx+5U0EEDQL3mQhqJ7L5bCiJ/mQFAPTYuA9bRq2j9Z8/Ws0DhH5+YG9u375y1/y//7f/+vzPaZpcueddzJ37lzGjo1ubhkKjhoZXXhSZRSL/6FOUlzkHlcJwIiEOpIUF5JgkCj1eBWOjdvKFKsF1dTZ60sDwLLCyfCXK9H2+t8rejVMSQnyqoTDmyKjJve92Frr9fKPz07ubhJmSrD8+0v4dcYKrILCwy35PLjmTI6PsRHROVcu4nV5HoX/2UPeo+vYdv9YNLuA5DGiTqdQ4yV84R3hMfNem9/QK7PVkCJVhtzHME1ea53aZ7fx/fuSKXvQXywYy1JW+XhVd8a8aLPRee3k7tcSd6tYPliJaLNhnTEq6rS4WNDiJFpGiOilLrbsi65zo5zgo+pKgRFbC9CramJqoKQ3N0O0qiGqhtIBqhMkHzj361hagicMX4odDvIm2/ZYMCtVBLuN8y9YxDvN87C0mchuI9BACYHk1cE0kdq86Ft2IKWmDHYPMwDiilvxeBS8TTbEmuBhUrObUOAfDyT8QgySZGCzqDyY9yHOMGl+5ef9k+1qJ5+4EwLkgf/bOJsPdkSfOubyKbzakdBd89EfFEGi/MJ/cl3FXBZ9Pg65V268aPfGJpjQB6YpYDRbwDQQlqwj1TUKdV5y1FHCA2hxJhkj65mWXkGbZsMwRdbvy0HMM5mYWoVD8VFZ3VN7pdXsh5r9XUWpfU+yLWUWLj3xy4jncOnJi3kuZQajdxcE1GtISYm4pw1j/g8Wd287UB/0ZttExvdTyCIShk9CsOkIYdyromSQOIS1NZLPRNSNiOOfO10hXopuQdm5LA1LLPZudt8R2N74Uh0olizoh5HRF826iwUdJRi/zcDSV9qQLCFYrUEStUPNwwXvdBd+DxkmJO720WyxoMYFGhqOahGXoGAk+5DjVKq+A2U7CzAq9h3yazEgDlPhd2VlJQkJPfd4NFGMW2+9lfXr17N48eKI+w4lR42MLnLv2MnxzjoANrVmI57oX9S+959JXDl+OWlyB7cl7+31Dn9agyJI3JlSDsCddz7CrBMvIOF0we9FXr4BZeLo6EL2AsjX11I+9vWwu6imzuVP/pDeaZWCDtc+dgeP3PAIx9jg5Lit1JySFMtX7+bcSxfx/OhplH63htJbl7H90emkrFVI2hHdiF81X+DyObEXbhsRclO2e7L5k6f/XYsHA8PjIeORQFUT0WbDN7v/akaRqDxFQEqJ3ZslCCbbf5vM8N/ZMTcOzeJG37mbrOpaKm+bSMoWNaZ+Kp6iVJTEOKjwu/QW3ftXnKKNM7efhvs3OX2+V1q/C6O9HQMQrFYqvjcSgAGKgQVxdtFGPtw3kmZDRI1Cm35kZh1juyRV/9QwnZ+mrcIhhk59OvXNOyl6Q+PEZ5/s9/m1bUvhXxeN4pRdC/uUoYyGvfeWIc8TOO7H/kW22LVg/Wx/KXVNA/ca6J0yZbcu6446Geu2kL0vlcprR8SUljbvlPVsaMzmve2Bz9yaih4vnzHKjSBJgR5SQ0f4al2fx7ZPmR31eVwxZRnrn8lF69Voef9lozn9hkM/mcdtt9BZrCEnhL5HM5Pa+WLcawyJJQ4kbmzClKQ+I0WmLDDrnuXYpSHquB4h+noo+FXdMWy4u+/sBwBvVjyyswyWD7yu6kgleZuPtkIL7ozA38WxT8LrskGBGwHY8asEhv3FDmE6mx+lh4SEhAAjIxK33XYbb775Jl988QV5eaFFIQ4VR42Mg3juq1mMvLvnpp9QWMXP09Z3/RW5wOKTcS/wypYcnhvp/2GNdVuwFeThGZbR5/u+8/BbXBa/j3B9IJZ7Va7+9x3+3NQQ3Pjvm5l39hruyvw44jn2xUXjVrPps2zU42oY+cP1mLqBlJmOp6xvT3rnj1q5IGtXn/uEwmvIbDolDRo2wsmzIr/hCEHOzsI7ou8F8eFm290Ost6bSfyLQ9Nt3PT5yFjlHbRuyq+Wvknr04GLpa88mXzc0rOo3Hn9cFhzaCalk3K2oef4F2eGKfDG9nGYhv9vh8PLqYU9/UykQZcROLQU/HEVax5MREyIZ8LbVd2GxlChNzSS+7dVVN86JUD292BcuTpnz/GnMH20Z0REyW5RMtn+xATs26xIXnDuM4j/X9/3//Ynp3LOxOUxf4cjhctmLCXb0srf1x0fsF2vt1HZaoFxQ/fZT37wFGf8/m6y39yLZ0SwI6gj18K021dHZWDU+5wsemNSWPnvkEwfhy8uNiEKzakgzJuEuGgAjU+P0i+sLQK6y4E28vCnY38TMU2T2267jddee43PP/+c4uLiyG8aYr71RoZuE2m7sY2Jdn+aiKALGF05+8Knufym4BUUIfriQYdo4RxnJZ8tHUXtGQp6YxP6/jpsPhXPqNzgz7eKzP39Us6J24NVCB3OvL+xlH9+cQKOPhyqogpr6vP4IG501OcaCkXQSbF2Uovfew+g19Zj7ewZFPTSPESXimlXqPuF/6Rmp1f2Wf/R1+ftfCib4b9Opuh/NbzbNHdQPYKvvj6Pka81D/4SUBSjToOLGQH2nq5AGO9ktEiKwf55Jp7kWaQ/OrhqHlJSIsbw/H4bGLrTgjauCOhJW7AKChlSz4LhfZeVcm8GSUqvCSmMQ7Z9QyovdUzm4lGDp5YmCibiAf+7AHOKdne/JgsGygCaPtjW7GbOD27k8wceRhEkfpjxCTnWFp7aGN7QnlG0B0XU2dWaRvW+6MekaDC9XkyvF6PTxfI7pwLgdGtopXaaTut/uo24287I/4V+/kyvl/wF+9j8i3TKCkMXw8ZbPCiCzidVZag+OaqeCpJFxzXch1KnIBgi+nf81zRlwfrusT3gHK16tzBGtJQ4G3jn+YmU3ljeLUt8KMmUrPzw6gUAnBy3E5sgMG5GT0rpNZ9di71exJM9tMbimffdTfYHVeh1DdhEkeqzCgJeN6zw3peTuPDYpX0+LysaC9m1Jg9bjFOIKYmYMUYyTEEI8BfW3TKbjjnBi15hr8nk39zE6l88GttJHYFcuO1SflvyGjNth0bKOK5WQ/JJdOQdNGCb/vRaY5cdvcTDzsviyc2Zju2tr4mRf4T3ybjlllt4/vnneeONN4iPj2f/fv+4mpiYiN0+uHNGtHxrjYym0VY6CkwMxeSyAn9L4udWziB7cc+A9fdhL1GmxK4tnCjaeapgEcN+cSNlT7VirNuC3tCEtbLHiNh/UiYtM72IssZ9GRtY5ZXpDOHseaVpGu9uG4ujIvLg4PYp1KoDT29IkL2s++Fscp/ciN7Whqn60Jt7FrzyPjum14toteJeWcTZ533V7wWXKJhcPHINK5wTYfl2UvKS+3WczW1ZuLTg9JSkbQbGutg7aB9OTAHI8iINgjdZSvbSmWcnPfKusaFYUBP6n6RkKCJaXPA9rZo6S7z+7Zs9uSGL+bUTp+BOV0h4ZSUZa3w0jrFgaRXobB3spKlAcm0tAz7GhOWXkbVYQG9sIv611Yw49mZMweSK2UuY5dwBBBoZNruPjHh/A74Ce1N3hKFpmIN9t01hmXcls6zusKlZMWPoAUXN8fbJNPXzUPJWB1nLfBjrw6fsabv3YotPYFrq3pCvt6gO1jbn0d4R2wQp2zUMWUG3QmeOf0yPmzUS24ZK9Nq6mI4VCqfk5ZLRq1itDPqTFRVWQeG6xAOGmb/wOMPey5TTREQV5DaRC3edxCvDBhbhDkfmwvruGkSzvR01WHwJ+36R17aNRxCgNLOeiUlVAa9/UTucyt3pxNWH9iAIJqSt82G2t4d8faB05plcEqLg/8WaOWQuaonqGCcnbuSNyyZR8kJkr4sv2YrnspkAJH+4Hb0x+AlLX+tlv82Bb+zgePwr6lK6lLH6d7xpqy/GGUPLGMljoLjDeIRMUDoENBPEHA+dGfZ+lqMf5WAefdRvEB933HEB25966imuvvrqQ39CfEuNjPYCC20z3Fw2biWqKfHWHn9RYOECAeu7SxGsVrTZY7AJA/Oo77r4MUY13UxuyuSA7ZZVO/EmZXHXtI8437mFGg0+7ZxAqxYcyXh70zik/VZ8SWbUahsDJUlxcdZ3F7HmlUII4aXT9lV3/7vwd3W8PWEMxxfsDPQ49xO5w8e7FaM5vcvwi5ZdTWlBEr4AOR2Dn8Yi2mxgHaRF3UGYsoA7VQZiL4az2X0k2v3Rp7rm+Kg76R5qOrMVvMkimg2yLS2IvcITqqmzwVMEgFVUSZRdAc9FW2k8tTPBUdhGwq5RWJq90CVbLHhFtrZnBsg0x0KFO5ktjVmckjd0RmnSE/HY3van75iqj9JblgHw8m/nsnp2Pma1DSHHg83uQxBMsuPbgxbgubYWcktaoAQ+ax9NlrScYtk3eIZGL+QOFar8i1gz1xO2wPhgjP028ha6ERdGTknxVcaxMSOnu6alN00+B3tqU2M76QPnYDExLEJ3v5O6KVby61NhEIyMAwjxTiRVQ/L6F8sAczN2IQomOzvT8WgKp2ccvvx7S4vAlvfKeP2apcy3Nw3JPXIAUzewNZh4U4XAWhsTLGv899DmUQpyceCYXLUjA3uthDfFf29Zm4UgD671k7XoBykRyXm5+KShG+NMCZAEflk/hp+nrUcRwjv6znB4GD3/Ab73Qugu6AfQHBIduRJtx/qjg/b6YmxrCDI05E9XkSVMoWKQRIEyUtpIkvo/P1ueTcHWEH1k3bCIaLYjc/4ZCIdLwjZaYumPdaj4VhoZM7+/GotToUO3Uu1OJOvcwEWFWJjHx8/9m94a9/1ly42PwI2B2477/vcpeGA1C5bNp+avSX2+//IJK2AC7HGlsuat0X6ZOINDG7LrA1PTyLtgE58vGMNJhT3a/7GmH3Qfb+VGMq+Ip+VTR9RGS1+F44YsgCiBMYhip8OL8ESQxOwv3kSJujO8MeXEi5J/0j4+fwd/z1mBbhqMW3IVui5iGkfWQG8oAsbljayZ9HKvrT0LH4do4ZaknrSPpR6d99rHo3cJ8p9wby8FoH/5/+/ld+aitAs4qkU2NZcx7JyGmCNrXkNm8epRjLpvL7wX89cKINxnq6aOKYOgBC/0iv/fKnRdp8zZwbaHh3Fiwfaon6EXWqZzWsI6ZlqNmJu+tRpuBD3EvSZ2qdet2kxJl5N3+yNTEONUBJGwxsaB7SP/tq/bwx2J4XcuZdc9sxl7ebCRMRCkdA9um0JceU8KnimK/kLhQZiM3bpCx7gs5M50Evb44P4UTBFafl+DXfSxavEIbPUCl//gDforHRoK1dRxmb6oG5UKOvzs31eR9L3HumRYBwfdNDAVuft6Gu3tpD65hNrbZ6PbCFnU79hiZeeWYQDdPTbsgKtQ61bjevX1eYi9bv1QTTFFh4OKywtJ3aTGLB0umCbCgd9fEEL2dQAwElX0OAtLJ1qo2uOmQA52AvZ+3iTBn/4smCBoRlAqqSlC8wgZ95Seea3yWp20t8pIfHllsJyrCYYuDEoflLfH/LdbXUo3YxsnXIYv5uelI1sOKvwO4ghZwxxlaPlWGhnbT4CehqAD7+oaKx88/ggfuBL5siP65mFFjkYKLl7Mz9NXMuatW4nbc2T9dLkXbmVrV42CmJTI5I/77y002tvZOUtGfb+YWWm7I+7/6vaJYaU2ay7yYh05g7zffxXy9SMNW6NG4bMSFd8NL0t5MF/OfpRk0d49cUiCyIZZzwLw07rJvF5+5BTUf/dvb/Kd+P1Eq3Yz0yZRKC/j4abw3+GC07/kheUziCtXkNzw9kuzOf78VTFF1j5/aCalzyyHzIGlvzhEHz9N20Zvw+kAE5Z8F9/FPrgotCKZZbOd/N9+xfDvrmfPZ2khPfvh+LB9HLt8tVyV0BB55y5cho/LRp+C2BYcbai/YTqqM3CRMPLuDRidLjrPm0rtBcEGkDPOw2ldEci11tKoz+NQsu/kRJKKpuN4bdmAjrOzM526XxYjH+S8EAzY+hP/71tg+lfHp996O589/Nigdf0+c+s5yN+TeOfLN6La3xTh9IuW8FnHKBzi2u4GcwNBNXXuaxjP2Ge38eUfZwSIS2Q+tITWK2bQkRv++xoynHXhVyEFE847pyeD4NOaMhLP2BXgoZWLCqi4KA9TgMYxCvEVBva66JWr5A4Vc0VXdGnGONSUyIUgf6g9mSxrcFT/tpTlpEl+h1OB7OSDJx4BYOx/bqfgw0DrqOJUBXJcQTZN/VkeWsqmU/CrwDlK/nQVI7dksf0v0cmXR8Mqr4+vXKUHKWWGp0Lr4LRH7yGjbfB76Ng32eksGSLFsaMcMRxZK9VDhKlpMReLDSZvdKax25sRs7dVEXUUQeKVU/9Bi2Hn/dbxvPe/I2QBaeiYXfOF0drOR3+d2/1SR56AOK0FgFMLtwQUiKumxLrrxyFu2hUw3ZiahvU2K8/9YCZXzOhbHaYvJ4sAA+5KeyjxJclUnWwiC31PfKXZdfyp+FWAAAPjAAf+vivtS86+bDVvnj6ZtZMHx4PbHwxF4MoH3+ZCZwWSEJtXN0NycHvqUh5umt4d0eiNKJikrJZJ2eSiZo4DwYAPP5oMIgjFnVw0InTKTovqYNf3h4Fpkl61Dd3Q0esbWPXdsaQ/to8Ce5Q9Q/rgpY5EHth1EgCaKvkXGGGMR/dwLzsfnElqaSPj43fG9Dm6KWLEIFP6bFsa/73mDIT29d3b5Pw8ak/1y8GqTiHouam7bCyCCXE1OqX/1wqiSMrTjcTJfoNDEYzuCFzHQwYezW9otLQ5KL6sbwnZgmd38UnlHE78ceReFQPBFAjruY6VcKIHB2+P8CjHzGPDX+SDd0b0uc8rp/yDGzddiXuRv4eTIujopshnHaNZ5vJhFVWuj8GI7U2V1sFr7WPQTRGrqJF0QwV7SmeT/5uuRbJp9uml9qaaTJq9Pez81zuKOzNzD1+8UUbGRXv84gSzJlAz0dF9bw40I1Rcv5Nhz4/k5dq5XHRWYHr0SaO3Uv7rVNq9w5mibAs59vy3bQwSJoWWes6Oc2EVFObedgNlyytxj8pi97k97xGcvpD6lH3NUVptPaX/Z2fLT1ORY62KB6w2lf9NfoKELpnrsRaBFHETD7eM4sbEvX0avj+vG8e7j81FSISmkRYSKnQsrYN4M38dIxlHeOH3kci30sg43DRpTtr1/oXPP3THMdfWTKKoUyQvYtvpmbh/loVgmOwodsIgKJa1qA6+fHoKWS2x5xKLDgdCfg7OKh91U63oFvAlmghuv2d3WX0RkmhQWZeCuNeGYMKwzkYMPXjC0bfsoGjBVN5ZNw/DAu2TPJw3dm2AHKJhCujVDsxUfzfRg7Guc5D95eDK5Qn767FAxC7C/cGQQE6M7DVyKl7GWCKnS2RIcWRIUCIv5mrm9bmv97Rp7L0weFSzVVoo+H/9jwS5shS0y5u4OqE6ZgMD/AZThhTHGQlrWdg5MmTtktJpomzbR6algNppViyt/tWHlzie90wL3LfKimOfgKiZpK0NVN0yNQ1z3RY2PzGL7RfUc1LONqLlw30jUd9L5z9pJwKQOL2OJJubhuYQ1bAhkK06Uo6P+bn9722imwYfue0cb+/AKoT2WF9TMY81z40jc0nPbyqNKqVlbAqelPCrNm9y12umhG7NoH6SyBhbeUhVuWMye4ykpow4Pv213xlS/GpLSCEGbX8tKV9IvJUxj4fueIQlnaX9HiMj0VYo4bphFpiQ/tQqsl+z8Jx7JldMi07qeXHdMGq/zCEnyropUTUY/s4NfHDKg/0SEjmYYsXJjUn7wr4+d/35+HSJhqokrHEm8ti27oV7u26jXbehCDrvuxq735Mjt0bVlXy72slqT36AwMjk5Epa59jY9+PZ5N7vv6dS1jaTsNuG5lSom9QT1XPl62QOa6DMGV2k2yl5OTV/C6/+3xyGP1GNxyHjS+i5R+NqTJQY6+50q4RSWoK+oxzD5cJS00bqpjRekvyOsZNOXkOK0hnUiTwUDV2V7h5T5lm9ld+/eDHFn2xCa2nFHJ2FHEWPnW4EAam0pOfP9k60mv3oO3eT/0Y6+463IWZEl/0wpbCC6Yl7cIiB84RVUMiRYYptD1JXjckutYN63R6kPHWMcyuvnTweYXkiug06M0UMWY7YMLUzRwmKgvaFGi8gFxWg7Y5dAv8oRz7fWiNDGl2GuyAx5GudmUfmZdFNkSUdpUywLCFRhGGKk/8Me41T839I8jubUZoHpzFcm2Yl4+Gv+iX7KthtePMSac+30DHSh2zTAhyHNY3+ay5U2kjZZBJXo+LNisdaZUUP0fnT8sFKMgAxPp7Km8fxZXoJdqXHyDBNAVu9iFtW0BM0JEuPsSLutpOzqDNiI65Y0Rsaka1WGAIjQ9TArLZBjieswzUtuZ0x8TUxHdcmiLRfMoOkdzd3S26KNhut50zs3qfmVJXdpwQ3iHusJZdnt5wFQNJ7Xe9XfSitHtTEyAsTT4rImskvMdCGYNOtCivcPloJNDJe2jqJvDoNvb4ey9JOnNnju19zVgEbAlOXkjeGXuj2JvXJJVRlzOaTY0xOzN4e8dw+qSnDtSid3H/4F1nClDHsVtJpLB66bssH02lY2a56WNwxgRx5BXHCgQiDP5UD/N7JFa+PI/ehHgNDLsynZWwKrSXRyVt2FEDjTJ0rpvYcI01pDygs3etNQzUl3LpCm2pj6kn+6121tBRrmMfR9KnYmkxmWXWa9BpadAcdev8VwzSvhOgO/k7uTBOzq1t7yrYxJHyyFRjJq0kTuaB0bZ/HXNZYRNW6bAoXRV9zJqomJS+a3DbsEn5T8tqgpCuFQzcNmhZnIaoQhz9qcGGJP1r14b6RuH09n/0KE7v/nebsZE56OdckL2GYElyLuFvtwABWe/LZ6A5u7nV81g7WnuZGvb/rPDZtQwBsyck400fQmSvizjDIKGmM6nnqjSiYXHTGYt6tnIvctcYWTFDaTRx1WkyNQAEMi4QvNwlLcyp6UwuCy0N8eSe2JitNIy2oRuwyr62ag52uDLKWqhhu/0lam7yI5U6Mkr7HAK3NgqMFpIx0vHlJ3duVVhuS6p/rHNVuRK8TrcWC0iJhFgUf0zQFlO12Umbt5+rMLznVEfoetQoKM3sN252mTIvh4GCxkfkOlfem/ZPTl98DgC9RAERE3b8+srT0GBumLKA6/dfNnS6ix6AvoDlAy0iEyJnRh50jvfD7SOTIXE0PMVJCPDu/k8rFp4VWj0qUh65RjNdU0Qex+2qiaGfJXx7jhPrrAH9Do3RLR7+P5zVkal0JQN8eHNFmQ4jrWezpza3dxdWGItI83933zVXgpjbJQuEbIpLXgF4FhH3RsTCDg7+dgL+bqEcVMDJ7Jpyyx6uiLj49UrC0ahS8DxXXCGFHmO8VfdlLvjI6kiUHX/31MU7bejlSeRXYbRg56Xz1wGMR33tj0j5u7NpvftXVSKu2Ynq8CNsrYFpZn+/VrSLqINpiNkFFEXRUs2chUPqTVrTd/hxjw+Ui8bm+PdLRLEkEWSb/T8tpqJtG7fU91zrF0oki6P7nxNsToTBeyCD32Z5F97YbHMjOQ2dgANT4knjONwOAl1p6ojeJsovbk7diFRQ++90ccl/6CgQB0epfwNeenIcnNXrPozffxxWTenTtbaLKNHs5c2w949rDLVZqfEnsdaWwrrJnUZqvmYjx8WAYPf2IrFYEQaBzRjHL7n8UkDg3rgPo4H25lQ8tIyM24QuF1GDB1hD4vUwxMMVmzw0mRY+WEP/OOpzlw6h4pEdCO0lxY5dUmnw9N3DNR/kULu+fqIX220xuvety/jf2KaReht9gozlMlHYhIG2r1puA+HwqGTXhcuDtfJaWTf2PnNyV+TE5ktStpqSbJk+3zAiZLhQJvbmZxOeX0f6TWUycsbPfym8Ap9+4mJe2TkJZ70T0+DtL9xdTFPCOL8K6cgda1T4ktxvvjBLOvHZRv4+Zbukg/Q9LWXXlGMSaOijfx7D/pLDjl+F/Z10TSdgik7bBi3dMfsBraqINxhcBUH6piBTnIWmJnawvmth5ry3gGKYqgioy7Fdfcc22vWENjFCMt9gYb4luf1+igC/Rf1+krzMQDP8cpcZJNJfGZpyZIgGpi4IswyCnFh7l8POtNDIanszk4rLBa/gWC39omBCwQBosPn32Scb842a2/mYc6b/pf+O1VzdOovSqyA3Nar4/mTOv6xmQV143HnNVbJ2Y5QQfVVcKFDwj4Z1QjG13fPdisT/Y6kSo6wkNm67oC+u/Tez8ZzHbj32mX+8tP9+Gba5fklnUIH1N35NTxWU65Sf9q1+fFYrrEvfzoauRLzpGDtoxQ6HPGoehiCTu9lH+k57P2nh3Cydmb+ed8jHkX7ixe3sSg9vscDBp1Rz8pn4yv0jvea7lzAz2fnfYoBz/uqSVZB+0YL4lqZLvVxYEGBgAlVdrcPUw9HobpXf4jcGmyybjyhToLAxeYZzq8DJjxuNMX3TzoJyrK18LSmHZc5OJcsxk8j9qp3ZWj3NlxS9nY5vcRMrfeoyMzH5IS/cm/i8JfI87cKcrURn4sSIJItuvfpTiN68nbrd/enfrCrt+NpI4o+8iW1uDys57R3MTo2m6o5MzCmMbz8MhSBInX7C834qDvbl45Bo+jB9J/F8G3g8KwDu1FNuOWrTKKhzLB8f5N+W/PdetTWtnx/bwGQZZ71iw10e+LiUvGuw9zUbHbBc7ZwdGjzPft5DwfHSpfoNJ/YSBReQ8Y9zIogkoaE4L2pyxsPDVwTm5oeJoTUbMfCuNjMPJXamreaatlBpf0pAc3/HRelZVjmPK00Ojzd7xfgnJNjeTbIHHdz5Yi0fPptHtYH+1Oeg3ltHRQcE/N7Hv6jFEnUFhDn6PjANoNbVYOzvxTh4+ZJ8xFPxkwfOUyB3EKs/sMnxM/O8dWFt7XE+mBA0TrKRs9iGqh240/NPeU6lc3OP1s50F2Z/aMTb2v5YBQEpLRRvhP64ph/bsy4+nsbzWSXH5/pBONykpkS2/H4HkHHw1lsFCmDaOfbOiqxM5GMucRk7IKQdAEgx+kLKCBDG4RiYSYpqX7Y9MZ8QPI6cyJksOPpv7D05bdT0ed3R5GOIuO7Ir+uiMZ4SHXUlOSpSJAEhrd1D89y0INitGWyW+GYNr1EqqyZ+aeoy8yfY9nGgfPJltx16Z9HUqpgTLlk/DasTmIo5/KoHnT5jN5ccMvirf2pY8di6MXDyoDXdz6ZiVg/75oVDnT8X+s8GPeifIHs74/+yddXgc19m37zMzy2JmsmVmpjAzNNQkb5o0DTZtU8avbcqUQjhpU0ibNA0zOBzHzAyyJVlkyWJaHPj+WAvWC9qVVobE93W5jWaHdnbmzHno94z3OyM+qhtLT6/fQDAMQe5zZkzd0asrFXyo0jrZjntGYKZF45kqjSfN6/97lnU5/mS5Y5+kD20k1p5QmPo085k0MiamRU41cWoWnulJ5jJHW8QGPKGoU3tY4c7v//tUWwNZ8sADnyBZQ8r2xQvd7UbaU82L/zuJJZdtjCl16r8fLqb0ldAPvJyZya6flHFZ5tqAwus++sLgNZbUqAtdwyHZ7TT+tyikhOtp+Wt4ZcVsDLvGVbMiv4C2vjQWWlojrjNsdA3DPXLP3JHmZCsMp/+LRShccc5ynn9jMaYu/+TNEKCZoavEhNDB3G3EJCU5XJw+E4MzGlUbtM5JJSVxOmLlCOpvZBnNEvl5N3eq/hQBe5iieyFFVbh/NHixJwvFqaObZdTYGmj3k2DxkqQMRAiTJGtYhZpbsj7EoXh4fXdwRzEhDJQUL3V3z44q77hASeCnk1/j/urTqW9JCbueAUg1fgPjcJUnZ4GGcISebMuKjpblYf95Ngo+8CKXF0N9M+qBxv6eIfGmT8Dg5IRdTDJ1Eo++TH2cf+VKXk5eQOFSb8x9JABMXRqZa8087VnCNWfFJ+r/321z0HtMSG4JWxQZyUa1lae0uVw7bW1cjh8JzSzFJBkdC30RnKlZDaxYMYmiN/1jpDhk+NWca2by/MqAbfa9Noas9YHvF9mlh+wZoljVgDYspijd3zfsPxl1iPoTSRhccM0KXnlpEXKcEwOSP7GS0KD506VP8KnlM2lk5Fk7AX8zvjpnSsh1tnblcWHpGzEZGXVqD5u9GWxxFvUvS5Lc5CmdWIUWF2WRiMzupPvqBaQuryVntYelpVOQbCqZ6d1hVXJ0Q/C/7bP9SivrwLK5ilD+NJFg59olQ3u1EhQvGandMRsa5jYXRo8TpbiQmisL2TTngbCTl4aZyeRYu/ht9qaI+xz/fwspfd6CsTHGsL8k03X13JBSlykvbUF3OpGmTaDhjDR68wwK3/XFzZOvWSQ6S03Akc3nHwpZSPwqewsfzx5L47YsrM0Dv40n5dCF0v2NtY4GzmyBucc6bP+dnJIMKdGlYKh2EyItAQLnBcjZWfQsLAGOTSNjm6uA3mwZzTL8YupY0A0pYqNMAM90J3qTFXPH0Kkqn0voYn/eFjYkFAV9tvVgLl0NiQhDYG0fOKaugJrofzZFqhdJCv+cyiYdrdSN8aGEN82GWU1H1jW0tnYsTX5njZpsRbPG+NoU4E73p5aYejRkd+CkqsTUEZRuNlJ+n7ORV8umEKpfS7Qk1HuRvSb+mzuHqyevj6lB6OG8X1uOqdKK0ht9dMnUJZAqrbydNpGz8neN6PiRMJIceJNGX+e8yNbOsjQf3hSFhH09dI9NACFQU1TGJDT3r/fj7OVccMZ17M/OQvYICt6L33iyx9fLKlcxOhKr9pdg6JG/t2LSOHvqNp5L1bG0SEhx8CEJHSztBslV3uMvHehEulTMfCaNDPAXONc5U4JyhgdTVagx1uQLKwU5mB7dzSeuYOWNT3r8hbEZpm7GpVaP6JzBX8QZzuzZvvBJbitcyN7mSYA/jxMkmuZlseuCjpDbeHWF4n9Kh7x+PvSSXERPL0YIpadoSDP1siS7kpfap4f83G4P7GatG4LenBSsG/2DbNPZBWz9xkNEUiJ6puy9qM5l9xcfply5g3HN+ah14SUfByNMZqSyIk7+zqqQOu5rK2cit/VSeUUqu77kb7w0Z88dJNSpcfHI+BIkepYEN2waTJvmoEXr7W8CdST5ZNoLzPJejbc5/Ygfeyh0RSAnJfWrZ8VEXjaenJFF4HzleRy4amQTAsMQdKnWgGhBPGmbZmBviJ9nvkt3h41mPN58Mh/uG7opn5TtxosVoQq2e10RpZm/kVYJaZVBy28QJ7Nqlz/3XXUYSD4BBqgJA0pSsU4jvVkOTKZcaG1D2+530ijjxkCm/z4ZKuplKAJdFiBBZ6n/6Al1YOkSuFP8fycrzqg9z7GSaPfgynRgax7+zNDW7KP4CRnfb2QsERp+tPkcVLWmUcBhqneSjJSchLE8FWUY83jZBa5PMqi+KJ1Ce3vMvaWiwZOdgDP7yDRTumTaZjYX5FP37kC2g2OfxNv7FvT//YU7VvDJtBdgGmzyeLh959cAsLZqSD5QXQqKLfxvUaslkC17sUuBBmaL1st/O+byn+3zwmwZjOqT+fmGC5Gy3Pg8NsydgpH8BEIHxQnJlcemI+YE8ecza2Ssay2irjk14jqXrriD++f9Nyqlhsc6JtGmju6kTxY6d6fuwSRi83plr/HQvqY47OeDJ7S+ZCvSvElIy0I3MBspH8/5O8nSYZOIeXBG/c1UXa5QednDcT1exQ0Pc9bci5DOiG59Y/YEZj0S/rvPfWQjn09ZEzARWnfPw0y5706yh6k6EyuPbTmJtUUlURtbnxW6iiVcN0wh64Hjo7t7KHRN4s09k7lg/La4FMoeTjydwZohcW/rfL6ctjIunnh7vcyVf/0mW+8MH8UMxxPFH8MNH6MZOj9rmcoLldOjrt+IBW3PPsQevyKWtjg4DWwwPbkmnDmB7oKeAommYp3rFvlTkPyqX6OjMrV21jPcX1rMS185c1T2P5i3Vk6n/KvBXdSVrIyRCwwYsOWViXSdV8WMlLqR7eso83blROR10TszZlgsrPqdXyBg0kN3krvCg/2gwsHLwhsZN6+6kW/PXBrUbPGLlZ9jZ/0IuocXunA5LNhrh++ksLQbx7WBEcdenlEf73jnOOqFHD+eWTc3Yl7vYH5/2/WU//uOsJ/7DI1ftYynU4ucKNKuOvhVy3g0Q+fm5BpOThhZkerxxPTCOtad/DDrTn442MA4xD/+8RfWX/ynUTn+y+Of56bdw1etGsw301czwRScbvL+l3/PP/75F07+U3QqQ7VnmbntkeeGfR6b6vKZt/HKYW8/Ej6e9S8uviY4T9vWpmNeuwdhGJiWb8P08WbG37Gbk++49Sic5fHNm3snsbc3M6773HhZGekb4//aerxjDhdXnMuFe87DqXuZvPI6Jq24no+qop9cpm0RFP5lAyWP7kYNmbAZmVVujV+0TODXrZPQDInzS3Zw6YTNzC6uiXlfo8r8Ti6ff2SKmeOFUA3W/Hgua1tDO6re/ssSxn9vdIRGBlP5TinP7ZkR8rOGkyx8+7H/jPo5jIQbUlcxMXto6fGr//4NftA0Lezn1jaV/P+Y0PXon+XZ669i14GsqNcfDZKqdZKqj18D4wTD4zMZyRA2DSNKGdmac8w4agUzfnMnd9/pnxRe4qgmVR5QVPEYypAa4poh4Tl0uU1CZr61iyRpE691zRjyHMZZD3CSrfrQtuG9XrPXX4X+ZgZpI5RZHCldqpWyP2ss+ut6FjoqyFe6whoXfYyWZjyAXTJTbm4CwkdzALo+v4DuK7uZG2Edk5BCeln7ivtvTV1Dzx+Gznm/xVHN+fYm1v5hA2t+PBfFGdvEytAlOntsnLvrAp4b9zwJ0uh0Rw5FgmQl1dQbsCx7rQfL9lq0nh7MW6r7Gysaqoq5K37i59PXfB7XrpQRZJofH+iaxPaDOVQoGf3LzizYg0loPLliIaUv6eiyYO4v14XsuB0Ko6MLSc0l3v4xt27CpZqob0/mMu1yvJ7w6aVl2S1k24PT2SquymTPGRMxNMHpd9/FD379Ly6wR5cy9pbTwg53Pm594LgmobGlK5/q9sjR6qHQEswo0ycGNW80vF4sm6vwTSlGl6P31ZlkLaRwxrGO4tRQQ7zj3v/NYrKW7Ud1BldyS1MmcHDuyK5/wP5UULXAczD9qJGpKQ38n72ek63dvPeHAZnm59bPoey/R6eoeF2bv25oTtqAkWvCiKquRPaAUw8e4b553Qv8Iv9iyp4dulj671WLqM/fyT2Z/npEj880ZP1FVCT5cE318o1Z7/LgkxcR5dBDb4mKM1+QsN8SUvZcdqnIu+LjCDzBscVn0siQ5RgGngIXPbIVU5fEXnc2AKuVThIlf56vhjysJkXJko2JZhcdCf7upxucJUEDyzzHPsxCo1hppzREF9bDaatLoWxXZAOj7gwz4eyr5D3ExdNgk31UX5TAH5PXH0orOlrlwANky16qf76QMb/fHjZnvzdP4tJD3XEPxyQ05jv2DVmfk6sk8PucaFPNrPw+ZyMnK5HMmvDomsS+xkx+nz6b5/bOwNkaLCV6yeyN/Dl3dDynugLJS/yqYvqmVLSmgwBorW0B65nrOih980vsPfexmNNgDqe7Jgl7e/y98aKtE7NJxps+tByrL1GmuzAR78JF/ctyPunE3NBBwid59CyJTzNPt8uMe5A59fKrCxG6oGidimnpOpBkXpu7kOnn7GKsoznsfpo8SXzy5nRKXEP3vxkJPq9CZZPfKDq5bC+JJjc1valsrfPnn+emdzImqYW0wwxU8BfFkuuvlXtn/UK+8tYX2Hzyh/wgI7RgRR9rPD52uMtCpqp2eay4nDEWuQuD2jPNgWaYbsV+8sBvnVylYn1tDVprG6b6ZNSspNiLwY9DDi4t4Hl7YM1h6ds7UdvbQ66vJVtxZcX5Wa2206nacZh8VF8Jb495ZpCgijlg7M1a2MXDzrMofTmyUWdqd5O+FZ55c0nYBr2x0umx0nQwmd27Bmovnk2fibdt+OIUNyc3cmDxx/zDdSolr0f+Tq0dCSwVE7AfkqNS1fgkrciKTlKik9uT9/P0Dg1lkHKZIaB1qgl3moGhBBpTUqIPSTLwdIaeCwhNR20LfR8dU5wo/I6ZT//IGAfsYzopSO7s/7uvmHukJEu2/nqPVq2FDi1wgnOOvfPQpDZ2HfrBqA4ZV7rfsjjnnHUhi0orezPY4J2A/aCM0CQcuQO5m4bLBV4fb9ZO7PemRiLD1MPumx/mWDAu+ihQEth988Nc8LeLoM/IkGSU7IGUFEP4r0OZoyVoe5PQDv1WoyNn2YekgdphDmoYFomnts+l9AEDsSJY6vGV++bz5yvib2RkKt24inzsmP4897cX83TSuWGjC1pFJRO+3IBnr4pdDD8GsdRpQvKGn7TIHrC0D89zqTY2Ift8KLYCVHtkQ9KTLNMxEaYt3tMv3fxiwkkUvgUZW5z0LBnWKYRF1wXigJXSX21Edw96dnWNop+tYHXePCryM0ixuVmYUdX/8bq2Ipp7HXR0OBj70xXogKVLx+2UUIc5pLT12jngTibX2hmwPN3aizNt4Lrdk/cWBUoC77lkftR7KT1uC/Mzq4eMulgklQu/uIyPf7qQvyqnIC/WsUg+7g4jmrG0e2pABGO4yIqGyaQhhMGF52yI6HF+avNcxtUfarBWVYeU4sCQJSSP/7tpDhOG+DRkUwdS8PBW9O7ugGXxL8OOTPIesHTrtE00s/e8B5BF+Cn7t9P2MemCev748nUAeFMU9EH9b6wt/om63NKJaeN2xm7OhPNGfo5tPgeqJmOqtVDw/uBx3ERvrkRPeK2ZIflRxi7GXtDEX1+/fMh1W9oT+Vv74uEfLAy6LrHJq5L43s4Ah51QFNS589ByvMjmwDuj76rrZvCkKVja/M+K7FYRqo7kPP6ieyeIjhNGRhSo61JprUnBc/eBqFMTQiFFMEuvS2wFDu/pEP3L06l7EVrwi82Q4OBshc9duizEVvR3H1/38QTMvYLWyf5bomVaWf86KXs1HC+uI+OSJlpWJARNMAYjCz3i9zzaGCalX/deTk9j/w1lAZ+vXT6BwrP8dRWjoWQyFOYOlbLnoeoLErIS3YRZ1wUYR/aa/19iI1dccD89Orx1wXQSqoOLPg+nx/BhH2aiU6fu4uuP34k1wiVJrNNwPDf0eYRDa21DdPXAyVNDe5AGPV7mdsHON8dRekUrFknlsquXwdX+7srVu8PnUw8Ho9PM2G+vDNtdZ9ztawB/QzHXrwcKY7seKyTj6VVkDFrX+uoaLItn0LBkmFbG6mTeHz+Bz89cgyQM5EPNKO7MfZ+TA/qr+SOvZ9g05k99kt+0xBatO/mnK3njkSW8f2cSSnYmX1o7ejVsQhjkp3UGGGiRuHb6WviH/78/umcR5i4VS10n2u69/v2dMhMkv5JOX6+OUMFu+fBGHicYEleWoGW+QdXFkRUIB6ObBEIzqD9FIGf6jXRdFxQ/ISP59IGx09BxaaYRpbPphuCD6nJ8Phk5xBgiDP+/SMrOhsSQvbQMOXgHofpKgV+xLp709Fq5euWtlHsPeyaFhG+8CzmCgW4UuqhPNjPmf/51lJ01aO3to9g5LL70/X5H8njHOyeMjChJqPOy9odzYsqBHkyGqZuvpFSOOF0kHJdedQsTOjvwZAemVdV8UeNzE0Or7ezoymH3m36JSXOEp7xzjEznN+cDMF6J3BipyNzKjUkNHKuaArOe28tTyxbhqAkdkbC0Cl57xp8aMfXCyGkoo4Hi9MHqrYz7SGbvr+ci8ofulzH+7pqgFKXR5qI9F6Kf6zeKDc/QxbW6280NY0/ngg2NfCU1ttzbpU4TX3/8zqDmaqOBsFo4ONtCxubgLuYHZ1oCbmuhwRvPLmTmRTsosY9S08cYML2znu0fDDgmEtXhG1yRcOwx89zBxXz+vI/5UcYWJETYcW2Pr5cnO6KXzBzMGbeu4rlZcxh361quGHNK0OdClin60Iip4Wgo5hXvH/bvt+D/reGdfy4kQ09CTp4Ka7YifbwJgBQgRUhIZhN1X50VMLFMlN18K203chTy6CcYPhfY3Zzy+APM+uRWZH3AaSRJBjVf0Bj/o7Z+eXOtpZXtC8zY30tnUtLQBdqH49EVXt49DcMQJC2zkbonOBptb/Rh7pZpnRR+6vWPW//CbLNMuHfoVEsDNV/QAqJtCQ435xXtCFrXqZtDNsM8WtjX2cm7bw2G5v8ttCPsHDvBkefYnAkeo0g+fcjmUqGYZq/h+qTtIV/ELVovZ177RV53Dq9wt1N3ceZ1X0TeVAGq/8FV7TLa91rRvtfKGWN3h/TIv75/MtuXjQ3wtoXDEH7viiExZOGaLPRRM6TiQaLsxpCN/u8Tir5rsuGj8SytnzD657S5CfPaPZjX7kHashcMA0NVGf9gPfY14T3Oaq+J8p92o7V1HPFIhqZLGB5PTP1UDI+H179wEmd9/iYm33/nkOtPX/N5yp67jTtfunnIezRntZuk9/ZEfS4Rz1NA+3gzrZMtAf8M+dCzMGgIEDoBY4JN9nH62N3ISnyiYKbtdibe2xTliRsYPm//v1D3ROVvFuL+cSeJp0a5z8PI+7iX4n9Xk/+Bjy+nrcEk5LDP+4cuide6pw6rZg38qVN97uC+e23wP93ppObWUl6tHv4kaknZPvJtHcPe3iKplHxuH/vPsYB06D4wjIF/hya2PeO99I7zkpvUxVhrEzenbBr1cfLUbZfyxL3nj+oxjgcSJGvIJoxCGOz6Wi7q6bP7lxk+L6670vnvtjkxHeOAO5m39k/sjxrIF7RSdXFoA7I3W+YXX3oi6P2jm+G3t/yd6WaGvDcGRy3yMzpYnFeFJIygf0NFROKJ4fMy7p4utLbwdVDC8IuB9D8fxxvGUfh3nHMikjEEcoWdxJrof+k3ayeiveNPUPjBXU+Sr7STJzvJkEMXbvsMA/mjjXzv0S/yjRQDZUIX2xc+GdWxXum1852n7qT4w5XohoHc0oZemkrNRQbXZe2LuK3TbcbUFbvB9MrW6Swaty+k52+c9QCzrbUcS7UYffgMjQ9cVv6+YyHm9ujqKsydAvd7mbymZuJzwA++ErkIdbgYPc6gXGcAtbqG3I8S6ToQWldd8ehoeyL/zkVv64xJvYl9Z/wjLuc6Uox125CA4pbxjE8IlIb2pmvklQzUw7h2pURd5K10etDCFKAOB3UEt3CmuYdx2c1UtaWNqFeDbb2dnJW9qJXVwz+ZQdR9fxFlc2uYm76fNp+D92cfMmB3JqKEqFXvLVWxpAVG0iozEhB6MXJpT7+iWji6dOuIeweVFDVT/91F5P82dDRW37QDl3v46WkZ5p4Rp0VOSW5gc0pk5TrZpiIAq+zDKnxHpJFmY0ci+XEQ8hCGgaWqBc0dP9VCQ4bx51aE/GzX0vKwnaUTa3VkjwIXR38szdCRNybiKfWhJATuWMpy40syB0yE9C27yH9uHk92L+S6hdFJknt0pf9ZL8lupTypmbfbHYTy4+omuMjexVMX7EYdpPhkldVDimrRR7fyMzoYk9RCiik+YhMjRduzj6I30mhYYsMoCRw7bOvtZK8OFn04waebE0ZGBPQmK5k7dWwHBwaml3ZM5/Rxe8i2BCoUPV8xA59XwbbZRt59/hfiwxedyp/GPhOVMlTe71cg5k5l79WJsDDyuj86OJXK3gxW7Sul/CeDXr7ZGbRONnHd/ND1F/HAvtPCgYKkkEbGGPPBiN16jyY+Q+PjnglIOxKQY2imnLbLh2Njrf+Pr4zOuUXC2LidxBH0RbS8vpZC5kKUzQij4fHOHCp25lPO8Btjadt3U/LDwxbOm8r+C7NRev2GRbTTc9VhYAzRfflIMy25nq0VBUg9ClJW7N27pSobeR92YqzfHrdzmnfJVvKtHQCkmXq5YtwmAJ7sno+vK/hVUDKmicWZh3XXHgcLEyqilpcdKYszK6m8uIvW34ZfR9rjYHl6WdC5JlnctNk9IRWmhKSTYPdEJSkaDaYUN51j7SSvirxeu8dOo5oMjK6SziMd+fgaHEB8CmrV/bVx8Tx70g3UNB/CpPPC2HdCrjOmpgDdLSN3KFibAyfpjgYvCbUGP2me3C/PGol2zcmvmheTuclHTY4MhxkZosaGpTX4Xra9tIZi71yeTgqMaBRmtQU/E/gjmIkJ/kn1tJR6bLIPR6KbjvIUUir8hl7bRAveJHDlashCiksz1fLk5qC5yNHG8sZasq3zafbZMWQDvcx/XawtBpJXgzmBkUe5qQO19vhusniC8JwwMgah6wKjr8GNAUVLA/WoJc1g7A2b+PjpqSwpDhxoyr7ThVoVmGtuPms/d7x5LW9M+XdAXw3wpzm1aRoNmh05IwN0jervGuxd9MiQ5/nBLxeR9Opmyt0DkpRSYiJ7bkrnmrOGNjBcmgldG36o3qMqeHRlREXwRxrfMHVQWqaa8KSUkPZ+FVW+HooUe9zTHIQyuhNkoUGVrycqY3co6tQe/vz3yyn/ffy7aquJZjw5KnJVeE9ef9rUoLQlb7EHb4olwCiRU1MH0lcOcaTrVgrekFGcGtVX+39fxRLdPah6ZCb+aQ9aS5zqPIRATk6CMKkT182OvnbDJDTkIxzDl4SBnJIM+sBxDcPoj/4V/3glTV9ZxIHrAq9XpqUHb5LM7vacoGuvKDrnh8hhHy5XTdjIu0njYYh+cHXNqXxsKefW5D3YpYE7VjN0dAxMYuRjQY/u5oF/XULxxvhEMYQ6zNQW3UDy+T334E8Hmr14N0+Xvh9xs32n+6Out9QuZvlr05EO+xqmrZV89INFaI9tjTgWO3Uvz/aMZcO3Zh1KGwq+tuWP1KNWh64ps7yxljFvBC478I1FcEOwkZFt6Qq6ny4u2cau67Np/0kxqkPmgluW8Yus0W9aONoYgOaOPHW0v7Ca4pf86o177vUrVbaf46L9nODtkj4qJOtfLeA6ThSmPgUpTEeSE0bGIJI/sR5WrBX6pVxy9ZYQPtzQxYdJ5+1j8Y++xY47HwpYPvvprzPmW6uQU5J5eftbMb1clv/lUcYsvp2xdw+4zbqezeSanOg0vl/6aB62puFPlDs+yOH5ySlcOy1yEfixwh5fL0+0LxjRPtTGJm4vXsJ39m3lDFt8Vae65xeRsMw7apNg81tr+fL0C3h1+wcjNpC+9Lk7yFsbfwMDQHlvPZN25PS/lEKus9uO7Aafw0Af4/eQyYP+t4/fbHyTaeaBOqce3c2V405HD9E0bDQxv7WWcW8BQlDxz5nIpsg50qpTYdyX1sVVGlQpKmDmy9Vx2dfnU9YO6ktwZCixt1LyYeCylS2lKGcOpBhm37+CuvtDbd3DxKRuKh4pC/XhUWFrXT4L2r7Alnn/7V+23quxwlkeVqo3FuauvAV1upMmyU7O6pGlOMm9PlgzvImxWLmZwuqcfgW/39zwTy52RP/8/bVwOR/euJK7Hrt9WMc/e9s1WH4Xv2aAI+HfD/5xVBvOHkn0VgvjvrJ6yGoPY/4U9nxl6HTXrlNcdI2ZSdG3P47PCZ7gmOIzaWSo3WbMdtAPWsn/cOBRkUfJki55eBfnv3BVwLJxzfvwnDGbrz765LC8V29edi+3Tb4W60VNeF/LYkEcXk7HMjVqD2c89W0+vvb35MYwWL/nklnnnDGiY/fmSvi+tJD0v0WXnxstmzwebvvx3SR0e/FNLMJcnxgUDYsXWmcXF515Nbe+8iaXOkagxjNKxXrNty+kY6qOIRsohPfAesa4/Z4kMWBWjP2tB3bvQgeUkiJueed9JpoCoyEJkpU7Nm/igRuvQizfNCrfISKGwcTv1sNQ/RMMg2M5PnikoxjhmJVWy6b3ClEubkPvjZznrXV3M+6bgWpBWkEm/HU0zzAybpeZWeuu5vKSzdglL27dhMdQ+GNbGV9L3TssZ0CN2sMlG7+EdqjxmmuCm8oyGTRB2bNazB7Y+lMsTDi1jg5PCdbz6/wFu7EyaLwYjmTvYquPf93+Z274690Uv9SCUVkDVguyW2fxd+/EEILcL1XyUvnbAduVPXcbeR8Bg56mCfc3IXoD6wTUptjUAwv+vp1lexZy0i9iexdc9f1vcfF3PxiyueRQPN6Zw192nxb1+jbZx3njtrO0cgKaeuRSSjtuWMjBJSpKlOl6ep6bfffOgW++PMpnNjJOSNjGzmfSyEjbICMSrChOMHWNfi8ErbUNQnipNWvJsHObx5kc/GHss9z09Be4OGPbSE/xmMdngKVdcMryLyMrOueU7Ryyk/VSp4kdnny6teEpd/WhK+BJETgvm8+3/riIM29eGUNX79DUqT0817mQhHr/hFo3y6jZychyKdre6PT6Y8Iw0HZW8Mtf/R8v3LqdJ4qj9xo92Z3O7x+8GoC86t1xb8DVcttCOqboyKlDe11D9Q6RDrajut14z5lDz9fbDhlRwS/Uix1OHvnFQVr/sZCUJ0JPEgyXi4KlnTSclsxQPd4MCSwLW8myBhfth0JtHJ6i0wmCsUgqc9P2s1FKHnplw0A9EGhkKNYYO4HHGcMQdPfYeK1uCtMz6vtleDs1G8/3pnKW7UBQim0kPnRJ3Fd/GT29A2OdbNLBpPv76MQoJFlzrpnc6QeYktyASzOxXQw9VZAz0tn9o/KAZbpFJ62ghcW5Vcwyt9DXPyVaTEJmmhnyP+zFqK5Dd7uRrRYwwNHgn8BWvTSGsQWB0Y6sDWBpP2yC29KG2hG+x1M0aB2dOFbtY+mflnDa3SujFg1wHPDRPtwOmIPo1Owxd7EP1Xx3JIhUL3v/PJAZkPuJEdCfqO2LC2mbZgQV2UdCkgxIiZ+wwAmOHT6TRkbSfi+KcnRlVo3FM6g7fWSehdkWMxvnPsnPWmKTiZRy3Hi9NsxRKvccjitHJzU12BveqKZQ5WuIS+5/OMyb/KkaL3fPIMvUzSVJm8Kuu9FVPmIDow9DhvZxMvkf9fBS8QL0MwT35m4YesMQ1Kk9bPZmcMCdTNM8C1kbvAjV8HeazkiEvXE55ZCk/WMlGzMXMffkHBxmLx9OeSni+n9uL+G+986h/JCYQTwNDKEo+E6ZTttcH4p9+P77rgXFJK2RaC41sWHaCxHXfWP8G5RPuoOUMJ8bqgobt5NSNI/uQgVfmMwgzQLuAh+Xhcnrf3LNAsoPHJni6FDoS2agHyqG70k3AdVH7VyOJlJiIpQFtliWOkbWVyNWDE3HttFO72RPUCfk1o4E9pozabcOTEB3dufQlLqXNKWHNjWB5R1jguoYenQ3N1ReBMD81Gr2OrPYWpcf8vhCQHu5GV+SIKFOx94YevKnWSRapvst67LZfhWyqL7f4hn0FFjxJAs+f2pwyq4sdH6csRVZDP+9cHCOg/yqJHSnE8Prw9zSizfD/3BmbPaQsXnYu44ZraWVtCfX8uyc+Zwyd0e/mMJQvLBjBhNsB7g5OfYeHOA3JDd1D69deEZSL63dDlTfyOYcZouPzMRelkwZUDV80r6Aku45mJeuRz1tFi3zNJSkkdcDneDTwWfSyDgW2HeFlc1X/pke3Z/KcSS5etJ6npVnQvvwBv2SqQ0hu+NudBbTrVspNR0c6SkG0KO7qfClByxz7DbzrwOn47wgNolQzWYgecWwG7vVn5JA2XPdvFe7gFVfX8sCa2yDtlP38omrkG2uAnKtnVx6zTKWbVuIcqjHiSEEksUSU/+JWMn73Qr4HSgF+bz3UeTzf/jF8yj/UXzTxACEyYxckMu+m7URD0KNV3pQrUV4UuPX2db28hrcNy7EnRF6n54MjevmhZcSmvTjmiMauZAcDoR9YKK653pz/4teMXnp0Qa8nyahDUu0oUez4I3BmWEVPuySF6c+fBlfl2aiyRNazS4SksOBkGWM0nxqzw3My0+uSiZ5eztNnqQjosxj+Lzk/X4FFQ/Mh7RgM73mYBo1pAUs21hTCIDWZiH3I6i59xVMQIcuoSNo1hy0/t7fYv2vJ4+N2LRTCIPuk12cVb6LpR/NIGdl6CfOnSZx6TWhhUPkgly02vqQKVN7r7Fw7UnLwx5/pJiEzKbvPcTpu76E6UCjv65qWwXilOkYEdIPdZNANw/cr5aMNGSTGVQ1tNy1EH4RlnD7a2/v//6GqlL+ldUse2oGk/L9RoMitIAmfh0+O1UdaaR7NHSzRMnfJX7ZeQkLLvhz1CqMmqFzUPPXsfy6+hoqmwLPr7Lb/14c6j4+NaeC57pmoLoVFOvwHDqyopGV1BOkrnXdvFW8kTOJ3Ipi9t2so4xQEvqY5kj3rjiRLnWC4WI9KPGblrmYhMZPMuOncvJp5Pets3n+qeCOv8PhqnM/4ckVC3HsH/6tX39aIql7NH520bW88c7/Ytr2wY6JdEYIm2s2BX3RZOQPN456syK1rp7fjZkacZ0S4m9gABizJ7Dnq/GLJt72kxe4MSm+xm3zSb6YlJeOJgevm0bXqQMTzcF1LapPDuj6W5DZHlKGcyje2jeRs5K3MdEcXYTmbLuPQmUjT3bMj/lYfbxZNYmMf9spuSe2+/DgddPCGp2dpRKdpenUvJDOmVetIUE+Qmkaw3ic5TQPBy+DMz65CwDHSjuK06DzDBd83v8bx2JaX3PmcjgztnOwyT5mvljJ+hunYmw6ft5V7ePM9C4cXGieDCQjamyUfi/4fpKTk6j4S+hoEMCY32fBxkDZ3DHXbqLv7lHT02CQKu0bK2ZS/jW/I0KcMhNDFpQ+r/J/277Bhv/3cFTf4aDm5ORDv30oLF+1svyy6Vx+5dCqktlP2DAUOHDVkKuGZEZ+PWMdoWtYzi/agf68oGLXzP6GhCc4AZwwMqJGcfoQ63ZgDHPiJ08sJ+3xgQd0vNmvzOQzZH7VMn5gufUAn0sYfe/axeVb2ZKRT/3SoqjWV+1w5vnrAXAox3fu5OXz1/FW9kTEmijyuSOg7dzLBbPOoXt+MWf//GN+lLEr5Ho1ag//6fB3lfUYn45HTs5Ixzcx8r1j2lqJFiIHuu2LC2k92Yscx+Sr3249h2WFVTxeFJ3CWjRMuHs3r910Ehd+Mfq+M5W9GXRcLNDa4mvwRKL6lwvxFXpCVKGEpr41mdedk7mgOH49OMIxzmTlm+mrubc1dkPjmbeWkPexiuzWWPb/FlL8g10U2drZ1Z3NtgO5AHj+7I/QZH+gkPyfIZpUHGXG/2AH9bdOxTV7+Apn3fNcGIbAbvWxfN7fAj7b65O5ZuWtYbd9r3IcE3OamJLcMOzjH0776+VcnLM+bvuLGl1DWbYFfd5kNGvwmFp3hhm1yBWyEkUvdLPncX//i8JXJCxt/vQxXYL8/yjsv8II6e3f/VUr6HOw1Jso/nGwkaK1trHhjMz+v8e7t/YrMMnLt1L/vXm4x3oQspvJK6/rX++WCcuDVMVuq1vIJ7VlYSfshiEY97UatLYOiv9Ux7LNkYvRN1w1DlvVJgDKK0qp+GF0kRRZ0bhorL/mc6RNKz8NnCj8jp1Px4xnlDG39CJqDqANQ12j7vuLcE1wY7KqzAoT8h+cTrDXk80zCK5KiK5AzWV4eemfp4RU25137eawYVSLpDIxpRHX6SbaPsiN6GVz5eiMnVYXVVfRBm8qT3f7uCYxPs2mrqo8g3UbxjLykrkBbLIPRdZHNMXtyZfhkjnYX1yNpSOPZx8/nacSTwf89Rtfv+YlrMLvaXTq+SNKGTnWUAoLUHNT0U2RIxF6eRGST0O4vGi7BwpNNDNBuemR0Lwyprrg62dI9HeVVX0yvVp8r7He3U3+K3Us7VrC2XcHGi9tPgerG4ONrO4eG6WtRyhBXJKp/cF8vHkelBAF8eEwdAmn28zbdRM5K39X3BrShUIWEkmSlZtSV/Lfzjm4h6qmP8TzL55E5k4d2e3/XkqvxuqaErbbc/CqSr9SjmLzj8kHF8h0li1CGJBUqeNLiM6b+uqyOUyftS8gzWW4TM+oZ+nf5zD+ti0YvuCcdL27m4KXD9DSmkP72eHTmyIhyQb5Ge38vzGvkiwFThSnmH38ed7TfGP9VSH7IOmaxN7WDGq7Ap0r0zIPRF1XcDgZ9t4jFwk6DENVUXbWoMgSIikRd4k/daj2TDO+HB+KHPq+FsLov290kyVgHJPdOlkfmmmZFdxEs6/XiqfQoPaHiyj81cqgaHM4GXJDVdFNA+Oe1zPwHDxVPZd3mycGrF/bkRKwTij0zm6ab5uHK1PgSzR4s3ZgH96PMkjfPlB7Y63a3H9PGvv2U3r/gGPzwGIH7lmB7/b8jA4KEjqQhH5c9cM6wbHHCSNjCMytTkRTW0iP7FC03ryQxJMOsiSjnnpnCps6Boq2sq3d5FqD99mtWdnjzmWV0sZci4goZbjJ4+GGzTeRucUT0kh4b9VUpsyoZlpyfcjtE2QPS7L28fTEVKx7rUFNjwCc+Rqppe1RFwE6dTO73bmsMrUw28KImkt9tWEua7eMwVEfeh+SV/DivmlcUrZ1VCdKofA5oCdX7jd+MrYOvGgNRVBxSfancnBWcnPQslNQE4ae0PsS/esoPcO/B1SXgtyhYOoOnjQaErhaLIg0L5JkUNedwmOdedwawVM7e/1VZG2I7l7Rl8ygM9uCrsCG9kL2riwmeVor2Qnd9PrMdHUHm76aV6b3c36vffKa+mF3sm341iJCZdWVPt2EtmcfcmoqnWeOwzvRhTKMe1/XJDq7bWzqKGBiUiM2ObgY+JXqKXQ3Jvb/bT2gUDk5G+yxySzLQmKMKYGFjgo2u4ppU0NX01c701m+ZRwABVs0zJ2H8t8VQeskMz6PQZcW2t0gp3lQ0/zDYI/PHnVqku2ARKc3Oq/uUGSae7hixnq2SuGfDW1vFRmShDcpm94Fw4topFhcIXv1WISJC+xuvhnhfvC4TXjcgZPXPaZMfElyzHUvRwrN0Cl/70tMqO0Mcgz11VZIHi8Wk38648tOibruoL1cJmWfwNoycP8n1HnxJlro1qyI3ODUQMWi4Z3kovdz80h6d1fUc4PMTRoHFRt6aaCB2d7poL0z+t4zqlMhba2Jnktm0j5VQ0nxIiBgPLIC5k4vYoXf4TH4jtDdbsRK//KeqxbQW6xRlNERcIwxSS0h5yefeU7UZMTMCSMjArJLRexviNnAEIqCmDCWqbdsI1Fxs7Mzh+qmwMJlX7Yc9iF26yZe65pBXtpKcmVb2In6+70TybwvvI+/9GUfWy1FJEz1UOZoCbmOJAyunb6Wp7oXoXQHGjSOWkFCURfnFe6M9HWD8Bkyr3XNoCNhD7MsbWTJsTXv0gydZW6Ft96Zg6MjvEdSdgNrk/GVyljEsTWh39BWyIzUupCTtz58hsymtgLECGsvJLs9ZP8F3ekEw0AoClL6QGGp0dmF7o5d+UhyOPCVZodMT4i8oUByOJCyMkAIVEf0ObuiR8F6MLShLXSw18s4kwVIBk1tSfy553R8kz7i1uTqoOfmkY580n9lQ6wcOq1GKSli7zm2/oZ/HQeyGPevZvbckkFHXvhnTjZrNH2ubyqUT5Lbg9Ycgxa/JMO8yTz+5b8wzxLsyZzefScFHi+G1cLByzwx5eMfjmEIKg5kkWR2k2/twCb70A3B+jZ/hMb4JJWyDYO91BpPL5xNtqmDJMnNufbYPNhn2DTcRgOVnuyA5cvax9LpsbGvMZOyZwKnkbpZwpUu45znjDod7KgzZSzS9n1hnzFtzz7yDrawu3QiepKKbNUQIQwDtceE1DvoW2d4kMJ450fCwbYkgIhGxnsHxpHqGX4fqVbdRbpkG1b/DxWN8XfsRgvTD0UpyEdPSRzWfMw71Ulvrx3rYa/HtJ0eZK+ZVoc5pFKSEAZNl3uwNZZi2lKJ1jV0irP9xdXkuudSk2RBTh9+9EfqUsj46xr2/mta2GiNe5aTWoeDsvpC1P21YffVcXU3147ZMuxzOcEJhuIzaWQIw0AYRkhlisETPmnt9mGlSMk52cz8jz/f+e26iXR0DS/Z57G2hVyXspqJ5hAeU0PHZwz92i17RmNjw0TKLo+cV37tksAuzh5dYccl+eyclA8lMZ02ALohuPupL3LmeRu4N8+famIRkcO/mqGjY9Cuu7nrr9/GHOVbw6MrMUUNdEPEz0EgyRiSGKi+NECoBvwqk/Xfk1iUWRkyyqIbgoruTNRfZiMfnusW48mps8eHTF2ybNiL1tGJXJhPzZX59KX35n/QDesGFXDqUaQuCYFv3viIai5hz89uwlg4gf036n49dOLcdXtQ3rKrxc4rk9JZULWPKeaB69qte3l5TjHCGSaVSZIRkn8/hm6w44fZKI4Bj6MAKn6SgGBo46zv52v8nIee/HKy7z80g4nCmFSyM3n9hSeA0M/K5m8/ROn4W5l4X8eQ+4qW9fuLaM+2MyOtjjavA/WXfiMgi+CJkPV3qTzKFXSWmTntnvuGfKYP5wK7OyAS4jM0/vr4BWRu8lB8+MoCuvMVf5FzDBji6OUyWySVOY9vYe2tMyJ2ytY6Ohn79VU0fXURnRNV5KTgCXz2RzLJTw4YxBX3zYcMDzoCn6GFdD75jPjnzbs0E8kX16KFSAGLBs2QuK91AV9NXxWzwwnAqftCPjtC8U9fdn+tiGvOGkhnrNozIy6N55L3ebG1KDReGX6d6jsh+/mJOJ6PTiDC8uZaJuwtY89Pk0MalpHoq8+IVhlRHe9kxw9yGHdbeCPjBCcYbT6TRoa8bAvm8RPw5AcX/pqanejb/V05h1vkHQ1VB9Np7nVwfhid/T6e7pzLPMe+oKZ9k5d/gdzHLUijEE+rcaXSfJoX3V0HhFfbCEePZuGd5+ah6FDxlfFcukWGsiLeXPp0xO3O3nkpje/7U8qiHX+FDhWnWan91zguLYvOI/Pf1Quw71dG5AUG8KTB3n9NO3SyBtbtNnJWD0zMpD9k8N/Ls7huQXBB3jM7ZlP4hBz0+ylOH6zeGtWEVJjMqIun+I2cEHhnjgEDNAGZm7wcnOlP46i4zoH4yrT+9cZ/tTq0pGMcEToUPyFTdZmEkhzdZEWqsmEJkSZ1OPZdFnqLVJSUgf3+aOLJIAUaXrozvHGz7z9TWXvSQzRqcOGyL6NEiEBFQtcEtu0D6TeqDRq+uRBhQN5960Lm6sfKjQs/4QnH/Lg++w1vF+HdnAMQ1X6Tq7ycc+udvPzofUG1AdGiGTqnf+VOMjtDe3UPLLLgneCK6TkVgGeqE9MuO0epVCAmsh9YTY4cekJsaCEMhjob+7aWMTnxLvbcGKhQVOXr4dxVd4asxzheeawzjxdnlwQ9u5LDwZgPVSShM10eHQW80UKrqKT8Fjt7Hht/yOkSHaUPG8ird4ChfxqyaI5LThR+x85n0sjAMKg/P4vEc4KL/Xp1iaamWYy7aXiKGb6z59DylaFDp4YhopJ60wwpZKM9XZOQfKN3B8aaTvPkqoUoXYdeljpYDnlbhEdDdzoRFVWccf3NAdt4UxTqTx/429QpYYrBEWfqgbyX96N2d1P0/1SevnFJgEcrFE99tBhbizTsPhl9OAs0ZkyvJN0y8PJrLkyg5RQHqi5h/2MyQjXIe0/w1tolgdvmCkwKtI8bWJZUo2LqPvTlozAw5PQ0tDH5YQ0M8Pfc6JuhCdUgfYc/2uNLktEzB46x54fjEZogY7NB0lOjp9Aj1BjvV52oojq9JSqSI9AoiOb+lRITmfZxNyah8dvkR0mV7fjoHVZKSkl2K51uK91rMoPO2ZD9i1pumE32W/tR60em7mMSWtzTZoRGbOOJAbJL59TffJPvfuW/wxZ6kD162N/YkIjZ2wuHbvkoLZPeMT4ybbE153u5airSRylcdGP0qmNh0TWMaCKJQGKVjGrzG+ymbkHZC7cFfG7IRtQGfLwwvp7CU3fncu2MNUOu+7+uSZzi2M00c3R9oRZsuoKknzuCoo9i5mQaf6ox2zS66mj1p5r59pUvMsNaE3adW7ddT/0ZZlKzFpL5cPTGju50Mv6XPey6PR05c+ixaswfVcTOKvQ+J4UUW6Sm8/oFaObghyIvZXg1Yyc4QbR8Jo2MlpvnoS7p5NScipCfH0hLZtUPFgFQ/Jy/0DJavElyVDUMSYlOipNH13vcR2KNwdPvLg75mSHB1aet6E/p+eTgGDpezSMbf/pU/nvwpLyQ6xZGHkCVDhnLYR3EMzd5kRtbUQHD40F5P9BwMzsclLWPp2mOlRh6fAFgO2iQtr0Htc5f1K5t303J67P4n76Eq88Jb2hY2qSQBe6xYlj0IEWa2t4UGluTMXRILzD3GzKHO8XNXX4P9+DCXmeWjJwsI6km7I7ZKO9viGxsKEpUxdcBm/T6JzNJe2W6GChAFHn+l1yLsCF75+N4LjD0LywWpKL8uHb7jgZvugZCDln0PRhhU4c16RayxK+yNhzKE7cMuf5gTGaVorSB57fQ0cFOX7a/TigM7gwB5vDpRXJmJj1zijht+yX9y07Nqhj1PjrKLjv2xuFZ3Wk7PDSqyUD0Y9n97cX8ecPpGIagOFbDM0o8mRrmVhklTPDKkMCdrSMn+DDHkGr5zM5ZWNY7SK3w9Y+pE+bsZ8YIJ2vec+aw/8LAiWP+B2B/YbW/SdyYEiQfiEOPvNDBXhu4vm4GXwgjQwiD0qxW9remhkwjUjvNtMgJkBN8Xts686h6aQw5aujxX9+0A7qjkye+/5Xzech9AarDQLMYVF75SMj1yp6/DdklkbnBCFk/pSWYuaB4XdjjjM1qobotLajAPRSmHXbsBwPv/aovGJhtPk4p2XGoO3f4cfaWMcv5n3UOjU2xR/y1nRUUvpOKNykKo2vrRvThNGg1GfjOnI0zW0IPMdtrqcyhqjEDu8PNxSXbYt//IHyGjGWjg54J3mE3/DvmOVH4HTOfSSMj6eIDnFISWnEJINfayWVX+b1Ur3eeRK5hoFXE3rwKIMnqxukxBcjR2eweipPbRySbWJzVRsuEQtJ2DT3wJNZ4SQzjjDEUwVtjJyJLBi6vCXVrMsX3D9Rn2F9cTYlrLi9lTwtKR2r2JvBhVTklGW1Ig2agwgBbk4F1xW7U7u6w56X39iJ/uBFH/nycWRLRqFvamwwwwNaqIXk1mDGp/zNldwNj21J4tmRm0HaSZFCc3jbiCEYoNrQXohuC3dW5OHb7X0jOQbWtQgPFFfi36TDnqSdZ4C+xEfTkWyjcX4K+vz4u6TWHk7Tfi+wzcTDRgpwx6P4pcFGfaGbC3knom3f2GzmSzYqnMDXM3kYPJcWLz2cd0siIJyYERVlt1LakYOihLV+TWSUjsZc5aYEP1U6yQ64fCaV0oBLBm59K6yQF3h2YsPxrYgalC/w9N65LPMgf28tZ2jgxaD8jIXW3jq15+EW9L9TNZK6tksXWoT0Fz/Qk88fVZ1H2n7635+i8ReU0D17dguyWcTQEHsOXKOjNN4IkSofig8ZybKsc/UpyxW/4B5PqsrRhGxnec+eiK4KaSwyqLng04LMybmPCB6kgS/RMzoxqfByMyawihIGz3Z/O5nWZMLzBRoa5Rcbns7Eu01/wPyu1FkkYbOooYMe2IsZ/0AHT/fecONCC1hTYA8ZRI/Ps7pmYTFrIlFXdELxQMZ2xT7Sg7fQ79qTERG5ZsBgpxIA84acVYaVgldJimiZEnpTPSKnjYG9CRCPDAIyDVjK2qZi6/C8vQxE0TzPzzqm/Y4wpIeIx+rg9pR6nbuH+kgy8587F/NbaqLbrw/raGqKJ6wznKdE1AV6Jg7P90zxXjo5uG7jejmoFx14TYMKdYmVDciGzUkdWv6H0gNJsQs0YkJc+wWebz6SRsSCjmnCFlYdzwS3LeC7rJIp/MjwjY2FGFdtMeew4MDABmZ9bE7Z/RbS8OP5Zfn7LAtZ9c/aI9iNUg9Q/+wfUrMpm1P3BXlPzW2sp3llI87OBA++ymjGUfH47jV+dj2XQ/ELyQeq/VoZq3RGMYZD8n1UYNyzElTEwmex7oQotsNAt/ZnNGD6Vnktmsvc7gR6m1KWlpP13AyVXBxteksNB7V3TQzZnGgk9moXqd0uQVDi8pLHvvM3dBikVkY2FjnIz3qRDhccS1Hwul+L/aag19dEVZseIo8FH0dsSNVdLyIN6LCjJXiq+Y6b8i5aBlCMhoZvEqKbnhUUY/VGugPmICKj3BvwpiMIbpUEiyYjkpKDFqbKd9ya9wsy11+D2mg7tl34PsJB0itLagwyM4SDZ7QEF+aGw77Twu51XgYDFd/yOl39yJppFwIWBE2TDEP5JxSHkGPpmjBTTb9P44m03svukJ/qXeQwfTt2H77Dp0U+evJOyZUemWELO8KC32kn9V6AXXj1jNp1zjdjVqv6eRUZLfM/9Tw8/wAxLcBStXXNCkg/PzDIMCdrLFaLQ+QD8MsoAWWldJJi81K9Jpr6iKGKvIVOPTF293+AtvLyDFJOTfR+UMv6ldvZ+d+D8Ml4tI+VF/7urb3zI+73fKaUUFtD8fPDk3KWZKLlud0DhuN7dTU3YAEj4Qv/qa/K57Oqh09RUTUJTJYQwgqKcBqB5ZMpe9fXP3g0JnFkKW7/xEBCdgdHHN9Iq+cY5lew8zcndJYti2nYk6B4ZYVdDZgYagN5twrHfP8XTTfCVs9/qb/qnGTqTH/8yilOAAeYOwf53SphxZd2w5eAtksoFty7jrfuX0NtrxjtOi7rmxAA033GjH3eCGPhMGhlHminJDXHtsgow7fm7mfDT3RDstB827rJMzCkJ/hD4Yaj7a6meHzicFbIdDIOcP68IWj9WUp5YScqh/xYWC/Vfm40hIP/DLox1A2FcHaj94SJ8k4PzINrPdtExbhalPzgyhYD17hTWvjSVcONo2k4VxRmdgdBnhKh2mdbJ/sey5qoCclamIy3bGJfzPRzZpVP6T0Hl/8n9jaZCYeRnU3O9Rsk/pSMevpUzPHgz/Ie1bhnof+BzGP3ysn2vJttmG3m/i+5edF8wm/cfeSSspObGuQMiBXt8vVyw/MsAnFRSGRf9eKWwgJrPF0U0MAIw4JKHvwNjwZ2pB00s7OttZG4amABXXqug2I+eJ3HJxuvwvZ1B+o7ASXmecfSrsZX31jNxRw577g2RH3SMcOofv0XpZv+1EjpkbfDQMtWCNoTb2wDG37kT3elEO20W9fOiq38YzMoXp9M7xocy3knFdy0B91rLRW6aL5qA5lIYd3NgypJaWxf0jvDjjqrOLJ74Pk6ndIMHT6qJps8F3nN6i4WylwKfjQOLLWy79QGIuxtqlNA1xn1pHZW/XQiFwUaZqLXhaBv4Ld669XcUKQPGkywkdn3pYUpfurXfEIkXZ9+1nOdfX0zae1Y6zopSGa7exphvreWY18E6kS4VMyeMjOOQOT+5g4mvVqJ2dGBe4S9+02aNj71/QQh8KVbkeVNDyy8eoReF4fFQ+PguAPSe0NroYTlCmTW2/SZWNk5BCXFJhAHp23z+otYYUVwaGVsNWqeYMAQcnG0jMWt+gESiXF6GLzvYCz9sDpvpCmD3H6Yz4cG2/vSGI3VdwyEA54RBkwUphCc6htvT/v52zrvyJt589h9RafcLYXDm2N2khEvyj5Kq3yfibppP8k45egOjj77vJ/x59AVLB0Uu3IHpToWvSRjCQleJjHNunCWDo+DFaX/n1N3fIn10a3Pjwtq6Yg6mJzInrQZZ6NydthYphFRz/TdSWPfcVLI2BE5aU/+TwPvmwJo3u92LtGg6AEI3YFV0yneaoTP/p18mtS729DVLO5R+pxnV6aT3ivl0FwzTMzxoIhXqFhWAbFOpeMAfihjzP++AI+QIGxPhmH75DlYUTqDkVR85zwZGiqTD6oBqb/XxzPyHkEVsdVmHM9Zk4abd+/n3OSehVo880hkN5X/chzAFZmXUXlWMduirqA6DJ//vL+TLoeNYb5z/Z27YdiOuZRkIDZ5/bTHzz9xOkW349aJ9kZCEBh/WQ9e+7iLt01uncYKInDAyjgN+uO1Sfrg8pf/voqW1qI1NwEDIWtl3gINXj8WVZVDw/vDz+A1JoFuUUffn+M6eQ81ZwSlrjjpBzl9WhM3JHQ5Kbg5dC4NU+EeEpIKkBr+CZS84GnRk9zDTVQyQ3TqJ+3V68yQ0C/jsh/0aZhO6OX6h5dQ1JjqmysipA5MnOc2DYYpj+FpAw0kWhM2DdaMdc6dB16mx9T+QzeGjLfbVdnKXd0VtZ+i9vSg7qqNaN1EYTMlvIM00YPBWO9NZvmNswHqSRcMytwtpbWgDUCzowN1lRe6V8MXeLqAfe72EuUtg7gz/nPflmSftB8nnn2B0zXeNSjO3UBQoCejRNroJQ/JenS7djm/i8Iwk60Y7uZ8M7aRQfTIZ1l6uSPZ75lPDTMi+lbOUR69xs+ykMXTWJVP6vH/SZO4InjwZkuh3+gjDwDxpHHpFdX+NlZyRzr4H8ylWAiNvOgYJ9WpIB0VCg4YzU8aXGPQR9kaD9I3t/UIYXofUP9GMFWe+hrBGjsAK/GMEQO1ZNrKT52F9bWiFqXjz9PY5aK7gcWrmuP0YDhWh0985Phzpyb0hU9ZixSRkrkls53f32Uh5YA6mpeGL0+PF4fUxAIqrCN00kHo72xK+cH2i2U6KzdWfoGbqEaj6yMb9p99bTPpuv1pd37Uvfl4CTLSPNeGcH/w8a6k+Dt4+Hx55eUTHHm1OSNjGzgkjI0rkjHSaLx4X9vPM57ZH1fVzOLj3JFP2h4GXUagh0zWjiK7ZbqwOL7w/8gFzNNFPmknN2QrXnBmsAvVuw3ictZHVSjzpelRGkFxeBmYTrtwE2stHP99TdoOl0xhREW0ftmYfziwLmP1KVPKkcWg79sThLINJ3eOlu8QMEWq7hYDOMjOJtSqSNzYDSrNIdBcq+Mb5uzYnV2okbW3BlZkdMu1tOKTt9gWk1UWD4fVx8tYreG7SE+QqofOwn+lJ5q+1FzE/vRqAta3F9PjMtHQm4KgIfHl70g2sE5x48UscG4dN6K8o3smLH8zH0jr8sJCpB+zNOtaW6O4xc4dK2qFJcOdcAUfIyACQ0j10ltkQOiRVx+74cBzwoVnMdAyjzl3ZYyd3hROxckD+1Fg4Hd3iHwfciQrgZXL+ARRJ47TUXUNONCebbdyXt5anE/fy/dbPRX0uhhB4chKxdmdheL3g8YCQyE7pDhkxCYe1VUVXBAgJ36Hb1dxpIAxIrPOib/FHf+VJ44ZtYACING9M/Ru0sS7auuzkvTb8Yw4XucqKNYQwxGZrAQhonWIhfVv4FL3GBRbOyIxv1GHDnP8xc+ydZC2N626PG9I3CRLqA593x6Z6tJZWUvVpOEO83hW7inOuG0ILjp3gOOaEkREFqt2gZ8kY1v7i4bDrnLH/Zqy7G/Ekxi8GUONKxa2Z/MVZQ+D7ehvX5lTwwt7pIz+w5G/0NhrKRkpONrvvMLhm0vKQn5+Ztxt+HHkfHzSW09KZENR0SvPKWHv910pKTKTxzOz+YurRxJD9GUe2boPEmvhdM0k1ELrAkyqoOzeD3FEyMkKh9pgQ6oABIIRB52kulNet2FqMmIrAvckyXacGNlXT9uyj+L6D7PrDBORE34iysdReU8yGD/i16hPOreSPG07iu5mfkHFYN+KdXiffXfYlyv+u0vwnf9fuynWFWNpESNkIS6vAuzwdgDkz95JqdmKTfSTEsStcQoM2pGc2HIZLwVB8w+o9EQlvioLdGhwxOG1MBR9SjuqRsR+UQ9Yn9XlcBxMPgYGyJxpQK6v7/5bT09j5BQtKUt/z6f//e0uep0ixheyeHYo6tYcHqi4fpI4VPe5yv/iHuaUXfcsubOc0U1UlMSMGg8De5EPxKHSW+M83ucqH5DOwNHb3S0zXnZcRUq40WgxVwjBrRztDckiavQlhUyRtW230lvlIuuAAbEsLu49f3vQElzpi65NyXGHAPl8PJYo9ZFroAbWHHm9sUuiRqHam+9MDD8M9PhdrqOaSxxsnajJi5jipcjq6PHDZ3/n4occirvPevx/ni+8v45yvRW4GFwtVv5tIz2USRfeMvLA6FnRZwnfSVEQcQsiHk/qCh2smDa/RYR+n5VQwPic4TJz1ronCX6xAKAp1d0w9IgYGgHuSC99kJ86c+B4vdbcX28EjP8oYwISvbg0ZOWm9wE37+Pi8lPTubsbdthata2T7m/Tj2qAeLLGwZZbBkpW3By2/8f99k/RVJjJ+t5/lz89k+fMzsbRF9xvveHU8y5+fycsbZwz7vOJN2TMaHIj/M/25n78dUCh/OIpFo+FaL5ot+HXTMs1M84yBfy3T4jfh6UNKTKTi/qJBBsYA5y6/iw9c0RdHn/rst7D87sjLOQ/G3KGSuclD5ibPqCi+2Xda0Hpi1Ms9wrg0E8tfmImpJ/zz6Kg00flG7hE8q2MPU4/gkoe+wwEtdMR40WvfoPvD2KW3Q9GjWWj48RgcB0YeyT/Bp4cTkYw4crGjnTGmZp7rnDPsfby4bxrp//Z7VM3dKr5JBaAXILtVjLXBxdiS1YrjnQRmJAxPYjeeqKfPpmVq4CQm74M29C27UPLzSHzGTZGtJS7HmpLUQHnCQXyGzL6L0jFcLnSX+4ga/roJPONdSJJB8vs2EmuPbLfdI4W+o4Lyr6ez54/5CGHQNceNK9tCwXuRv2/NOWbULC9C8kaUC534nV3s//IUvFOjT52SKm2M+YNfBU3tHHmaYtltdVxgPz9gWWrLBlpumDXifR+rCEnno0UP4VwMZ775Db8REidO3noZTR2BxQM1V+qkf2TG5DToKfAbHIc34TQkaJ45MIY4GnTK76zq/7v6y5PDptgZDVbG/cLfCFXtit47ffemq7l87GZ+kRVC7GIU8KXZkRdMg1Vb+OGiS7D8T+OFse+MeL9yehr1108YURTjWKfovs18smUBs38WnVPBnWGQ/8sKau8ZP6xo56eFM//xHb58xet8JXU/4BcYmPjEl7F3xccx9snBMegPZmEaQm7d+u5myiuLqPhJYHqqccDKmJ/tpjouZ3OCY4lP8XAUng1thSxMiK4R3pmJ25li7ia4C0IwJiEz1uTjiuR1wzI0nlyzgPQ1CqauQXrisuTX6JQUlOkT/Xm3hyl4jElowSSOUihSCHqunO/voJsqgiQWm+emYp60AE+SYKYjflEeSRjYZB82fOz4ZQET/9CFsWMPcmYm7WeOiV25J0Z8CQbebBXlUI677I1PmsfRRu0yM/Y/3sDusrqG3tEJ+JvEyYqON9dHzTmRvc5athflsGLtnGctJK2tC6gr0rq6KH6pGd8yB75kE/XXhfeEZT9vwdbkQelqR+sYuZRs/zm0t0N7sKJKYo2P1WvGYxvmfi0NJp5cP5/rZq/myZULsXUMP3icXKlFLYkcjswN0N5rxzajjXsmvdJfi/Lb0//HT9IvJu/h6CMJhgQ591RyScI2Du8t4PKZgtIZZbNG6ywdc7uEEqEee/Ak2ZUpIZ8xAcfzq5Enjydtt4a7MfSvYe3Qh3VP+LwKPVEUMZQ9ezvZIwvCAv6icG+KhaYf+nsqSC2dlO66haxP/F88wRObs8JS04bR1IKwmIeUuI16nwdMeDOkADGIcCR/YCPrk2aOxBtI7+3F1BVDuqAERbZ21t/iRNclpA2J5Kw++jLKRxrFCX/86Bz+lDBw7WxdImRz2m0vTGSbAT3FOteeEjqtuY//LV2CrVGguAxSu4e+b72nTKX6BoMFxVUBy9ty7Oz8xRi4K7rvc7QQhoE4ggpqR/JYo8Vn0sg48E4hb56dynmFOyOuN8dRxRRzd1CudiQSJCtjTbF1ku3D2mAiuTL0AKjLEr40mz+v0hgYzg1N58W3FrLg1JHJzg1G6Abmpm7q75yNaoXUPVqAhGofkt2ONr2crhIp7KTenSHoLgW1ZHjXJBqum7WaNSmzEICwW+kuGr0swN4yH+ZmBV0BJWH0w8LmXh2tQ8LnGP3UL73JStZGgfTJpuAPNY3E5TY6ZntRbKpfjrAw8ss+VPQiaXNTvwJOwO53ViAB9qQkEkqmhN1n8vJ9qI1N0TV6jAPmTi+2xuGn8Ci9ArHfzMtpU8GqYcjDH3It7eqIO9bbG31IPoWu3jS+2XsV553yOCYhc1VCJ9YZz3P3JTdQ+vLQ97U3WaHubIM3S5ZiEQMGhmboPNJZjNsX+nvK6R48VhN6q4K5feh7WrVBV7GMY95UvA4TljYVSxjhOaVneJHEyfkHWJRYMeR6mesE9sbYjqE6ZDpLg6+FbmIgIuM2YW5ScDR4Mb27Hnn8WHyZCdEryHX3ond3I1vSYzq3SChOMNolfLoFDEjeI4MB3aU6Im9gLLets5O1onVA6joOiNmTMeTgMVzaXuk3Mpq6eOXd+ajjvNgqzUhhbldvioFR7NdNumzMFibaGvh3+gL2FBT0r1NmaoGoem4fP6Tu8dIx1ownJfD58vfDCD/+CP1QbyeXBgZYW8086YgswpKz0cDeFN0z0XZaKQfnwbXTgg2XMgdMnbmPP0a1pxMcT3wmjYzc+1bTopzCpksKmJFSF/DZAXcyuzuykITB9yavJUEagdbkEcDweSn9/koq3yqLm5GBAN1u5tGv3M8Cq8wZOy5GVE/2H2/jLuSkBDCZITOVhpOHvj6+ZJ1FZVVDrndMI8CXaHD2zG0s3TIZuVM5IoWRljYVSZXpKBvdR9XcKUio9zdFDIWhqmQ9tAL3jxfhLgbFFlvxsQHozVYYovhP6+oi68HwNUhHUmldTkrCYx95brrsAWN1CpdfuYqX2+Yhu0a/FM6VZaJPiVLSwHZwYCaWtKeL5Hcb0bu7uX9TOTclbyNVtnOxw8miy+/l3C3fAsDeomHqHvi9uovM/ft05gmqLnkIBpXAewwfO706f9l8OkaEUKLi8KGadMzt0dWH6CaoPy2RtN0qSo8Wu6Gl62jNVqQMT8ii9zvz3+dse3wdBr4kGV0WODMlehcMnQaoj3FRnWph4t4i8HiR3SoIgW4Kfa8Iw0ByH/ptVLX//82dBr4kEZdIrqlbYOqW/c0AH1oNuoZ060K68gbWKXxqX7+cOkIgZ2SE3Z/W2gaR0mkObV9/cjJaCLu+QC9FaekCr4/yf7ZQ+K86PqyfgeQL/rKqHfRiF9dNXkvqobDZWfYarpvQChMGr/npMjDA32wyWcymfYIlaqlsSfUrlVlfW4OxcDqaTSGx1kviU0NtGd1z48w20XVFNxeV7Kayd+AeybV2YpOPoxqOE4XfMfOZNDIAcv60Auf2Ofh+eyBg+Qerp1D+tVUANOzXGHckS+NHcENphkDve7OIke3LnWbikyf/Tp8v+r1Jr8Cr/s/On34WbeeMoSc/+gtjr5NZ1zaJoos/6W/UM5oII6i/3IjRzHDlBf50r+y8DlrtoSVPjwiHQrZGDPKXkRCGQfHfKtCam4dct+hnK2i+YyFdJ6kxGVm6KjHum+tQ1SNpJoyMjvMn0VV8DGljSAJCKLcEIaDgrgrGJfjFEfb2ZtL849L+MaF9SjLqvBTS/7aKt6cm07ZxPj/J3ARAhuxg3c/9Knpj/nc7xa8PTAr/e8/vGWMKfd9rhs5qj4mbV9047K83FG3jFVL2CSxt6kCXOIOB/5YESHLQRFbv7aX8a6vY89A8lJQBr2ufwSGPNDx0OALqzhT9fSSiRU7zsOdXfiWksb9yY27rwVMcWhlJ+PR+ed6+b6t1dJL5yEoOfHMRRhzf7EIHDN2vY334Qy+E/x8gp6RQ88XysPspfnJ/yChmH3JyUsTtd99uRbEPfLGKveNRQhgYAOnzGzktp4JUpZe7U6sPLT0yDkOfoY1+msvhY/9hxzO9u57cA+OpvSB9yHehMMDaYpD6r9AOphEjoPSu3ZQ5Wnh9/2R8Kwbu6eaza5mbtn90jnuCY4LPrJEBYHpnPVs+CWy8NM634Ygajz5D5sXd0wCwj6D/XMpl9Tx7z2KuPHs5lT/LoPn/lQ5rP43zLaz48r0QJgu9+tZyhuN4UJzw8rNLOOPytSQpo5c6pe6vpeCBVurumhE3Q8OZp/O5k4LTxY4W2s4KLO3ZuCfmx2V/yortaJ7oJ0RZf11L2s5p7L81usmZ6lKw7zXT8LV5FPxnb8gGUicYmubpZlIr1P5Ge6HQbBLT7tkU8IyNdTST87suNv5kFt0FMr5DqmsHvrEQgA1XHODiphQ6z5/Mij8NCNVvvfI+PFcMGIWpcmgD46ydF1HbmhIxehFP2iZY6FroT4Mp+o9M6x29nF5YgW4IulU7B5a4MEIYs+O/ton6r8/BPcNJgsPNqjn/BsAi4qikJKDqBgPJNPK8f7WyGrnq6E7ArK0GGf9ci2EYVP5mIUahO8DO2PnbPCAP2s04aiMb5DXXFJO7MhOxfFPQZ/Lk8dSeF5zupVnAN97/WyshHFS+CU58Ie47b3sizWkJ3JO5mSMtonnx+deTtX3tqM0j5Ows6q4PbARqb9RJfnJVwDJtxx4KG1KouTVyo5ms9R6UDzbF+zQBf7rgzJ9uIEH28OTqBdirTQH3T8O7hbwsCvGk6Vy24MNROYcTHF0+00YGhoHuHFkzMJ+h8Y+uQgDOsO9hjCkBmzBze9pK/tkxB7c+9AvM0P2D4Eic/LrbTflfG3mjbgnnfHEF1d9Kw/xoWkC6QzQYEiRLwQbGPl8PZ77xDez68KMEQoM335/D+HnVQWlq8cTwxpY3nXt2LdVrC7AcyhE3ZPjBF/6HfCjzP03uYYypnX+0L4z7uQ6FM9uEK/NwCR4DQx+591Xy6Zi2VsZkYIA/dcq8YS9jf+PPm9j11QQUe+CkTtpnQ+j+66nofm+orsDBi8aQuSatv3HYaLLn8TlcMmNTwLJdt08MqdIWLc5CDeOwbsi26vB54fHEkBgyemUIEdKIT5A9qHe10LMpG/OhrMo+b7dwedC6u0l5r4LTvngLAPc89FdOtpqxM3Q9yp/HPMMfHGfzSeWYqL+LZNLpHevDXmmKKf2pO1/GnWFgtqosKqxix93ZLMmo7+9FkiB7WPO/qRiGIPV/DhKeHXAOGD4vruku/rPgcUxCwyLiK5frTVaoPw0kk2fEqZQVN6VQ8N5cLG+sjcu5DRsDDN2g+pcL0XI9yIe9pGRFR2+0YmmXMIYoITFkaJ5hJzllLpbXA7+XIUTQ9t4UA1+2L6Rx0YeAoBfn/JJqLJJKisnF410D9ReXJlSQFUN95XARTg/6KERsPefNxZntrwc8XEHMlSWh3+h/P2W8cKgxsGGgdXZR/HRtxP0anV1og6J/8rZK5LICvOn2CFsNTcdYM7bLm0iQPTz1ySKsB+WgZ73vb0ubxPMfLgCOQkfHGDjR8Tt2jgsjo7q6mp///Oe8//77NDY2kpeXx/XXX88Pf/hDzOb466r3ceF/v8XPLnuaaxKDax2qfD3sV5PQkKnx+D0wq6RiatV2TEJnsTWB0xJ24DMUanxp7HEPrdfdU2jgc1iQfJC5KXDip1klWqeYyP9ExgiX19rRRWpFBs99uACAQl/0BkbllTJKspfy3Oqgz5Y6Tfx4z404qkd+u1haBb2+0fnNxOzJtE9KwpDAmaNjbZGIJLqlm8E30UnDu4Xk7lRpnqFQdFINsqRzTUJzQPMizbBzZuJ2ANZaimnlyKRLaWaBUCF7sytgudHTi6WuA09ByrD2K7tUTAfaUYep0KR1dSF2OPGdPB1TiwnNrASksFh6RciUPXe6QEuwjHo9S9WvF/KLJc9wXWJrwPLyr08h76l5WF9bE9V+VDv4kvSBtJwkH4oS+KZ0Z8kIVSB7xZDFzIljO+iSUrA1hvauGjJ4p4R3fNQXWUjaZSF9e+ye8tNyKnjKlhV0jj2zCkgwKRh2KzXn+Gd6mZITiG6SMdls4/pMfx1NtIaGEAaKwwch2xqGR7P6a7wmZbaQa+0kNzfw/pWEwWVjtgDw1AXzyDIvCPDwJiU6WWCVCS1LMDJ0BeSM+CgXiVw37jQrw+lqkrXeTetka39X8OFibzRI3dmDkARqsRs5RBdwrdmKpVNCitKv40uAzmITGafMRPpoY9j1vKkGvhTNLzARI9mWrv48/753M4DXMbrNTFu0XuY/903Gt8X/OPpJM+kqUcL2ftLM4Mz2f+ZcMh7Zrfc3fVT3RzYygo7V3Y3sDbzuzTMs9PlLZQ9kbBn6PlftgoVZVfxvx2ysB2SkCD+l0MDScgylpp4gbhwXRsauXbvQdZ1HH32UsWPHsm3bNm655RZ6e3v5wx/+MGrHLf3eSp5bPJtrEt8NWH5Q62WDJ4+NzuKA5Ttdeewkj0TZzWJrBYutEqCzU66hW7dxwJsS+YCFLjyF/s7VjsbAl683QeCa4UTIEsZhXlM5JRkAIy8TyatT8mp0rkFJ05FcKo2LEvnb2Y9yhi30jPztzqn0fJQV1T6joakzkZqE1PgVqgM9RTZ6syWc8/0TNAnweWxIXoHQ/ANjH5YOA9kDPofAMGkU/WkDutuNumghb0/s86QcJr8pJE61+a/rI9bgSaA7VWDpkiOmsgwXc7cR9ELWe3sRlfsxJfmjTprNFLZI9HBkt4rS0o1aXTOi8xJmM01zLYc84yMzG5TiQvTkw7yMVfXo3d0x7UeyWnGdNpWfXf40JaYWVh3m1N988mNMr/kaZVE4zFSrwJuiI2dGTu/rm1j6ek1IHv9zq7gIaWRdULydF9VpaB3JyIN260sw0GwGugmuHaJZ5X+T5mDussbcl2VLZz6yJ/h3qjtDIrG0AF8C7Lv6oUNLY/NinmHTyMx5h6qudOpbUoZc3zAEmlOJIk4SiC/JQMlyRRUJvXbGGl5MnEZS9Yz+Ze2tMk90ZXBDUuz9enoKBaot9BlLPn9qTzxxp0mkjS1F2xubaIb84QaSEubRVayMyNBIOOCDNVtBCZ4mGIDmVLA3RXbkhMKXCE1zbBTuL0KtqQ9ZDO5L0UI2T4yEEAY2mzds3V+TZiZFcpMgjU6xt9MwKFyqYfSOLDsiAElGKcyjbo4tZDF8KFqm+seg5CoTCVuGd1g11Y4zZ2AO0jPNg3xIjlx1KtgPDnxmcuph33suzYxl88giIscUJwq/Y+a4MDLOPfdczj333P6/y8rK2L17Nw8//PCoGhkA3V4rPfrAwKQZOs92TxjSYNAMvd8TPtFsJ0fezX1tc/AdFhNW9eCJoWzWaLkwupFbKAremWOiLgIWgwpH5V4fYtteVr7wMXZp9CJChyOtTeKTnnKunRGdN3kofIZM7zWdOJ2Bb3m9yI0OaF2mgChM1upOjG17/HnbDzJiOVRdE/TMcaHabeSsjqORIQ6FZ8MU+xqqCuu2AaBMm4AvzT+YG1Loe6FvP6b9zaj1DfE7zxEiLBb2X1OIZ3rgy7n0gTKkNdtD5teH3VdBLm/89UHmrr4JryfYS/7PBX+PKgQtLBZ6CgVypmvolQ+hOHxo5T5kRUPbkYg47LQVSadHs5CV1EN1kQ37XjNC96dBmad0cklpdGlcn5+6juU5Zej3ZgU1GBOGQZdqDUqZcmkm9r5ThuUwB4Vuggcv/Afn2kfugZ9mtvLGpGeYseyWIeszdJ+EY2/stRBpsw5yRm70nuLLxmyBBwf+7rx3CX/YehU3fOuh8Bsdhmb4r/GN175Npxp6wrSpo4DdDfHpnNxH7wIne3NzKP1+7Mp81tfWYD5pJo3zbUOmMYVCaCC0gQdF98oI64DYg6ELHBXDf2foCuy/uoCix7rR2tv9almqf7khEXOeiBAGZovK5aWbg96xfbzYOZvTEndwqtX/EAyOVEeiR4/sZLAIEyYhU6Qk8OHjf+X8Uy6Hijg0xxUCOS2F/dcUDmtzQ/jnBzGNnxb/O7RxrqPfYQeBcT/FrtJy4cA+zdvsZK/TEeqnYEZ8grhzXBgZoejs7CQtLbTyRh8ejwfPoHzzrq5hdAY+s57ZP/s6u2/2K678omVK2EGsj27Nys9apvKDjE39RYWpsp0fZWwL2P6AO5llVdHnMR+OnJIcm4FhGMgfb+73HBmAsB7/En4v7p7WX9cyGNNuW0AEo49dtyWQvGMe2feHl0qNhcKnFGSvDkZ8mzy1TrKQucmFtCx8WkEf+pZd/p6NDgfe+ROCPhe6gfzhBuDIysBGw+4/T0dJDvb+Vd4lSHl/Lul/i0H1pLs34iT3ptU3kb516Jfh7vunoSTE7pG0WH1sW/Ak2uJg01UWEiffcSveBAnlAjeeKRrWrTYmX7C7XwkqWhZnVtLzy3q2fH9GwMtdduls/+400u+p7t/nAXcyq1+axuHZLoYEa27/46h5do9FzvjGcmY4oi+mrvL18M8Of68A7fD25Mc40rKNFFUXsP/aopi3LXzpQH8ExVBVxt28nn1/mA+5oyPaoW3fTUFtEjV3TME9ydXf5DRapuQ39HdN/21rOd1huhJ+3DOBj3tAwuAnmTuG3O8mj4frH/1GxHVmXLyD/5R8GNP5RoM0dTy150ae40Siq0TCeUf07zlhsVDx+CSEZCCIfuzzTnFSnWOh9KVj7c0Sf07UZMTOcWlk7Nu3j/vvv59777034nq//vWvueeee8J+ri+ZgetHwYbHwfZESj/vlwfEMBj7YCXnvnQdhiwx5eHtUek6h3ohyULiq2nreKp7PAe8KeiIESuyxCJjagiBMX8KyvYqf2EYoHs8XH7RTVz737dDphAs3Pw52jZkxZg5PTTWfRae6l7EtSdFNwC6NBNv7/erZMzKraXI1k6XauX9mnFBBoZhCL+BESbabqtT0GzQed2CIEWOWFCdCvlvyv781TgPBq1TLOS904yxvz6mSIvudGJeFbrJ5JFqYBctksPB7l9NRU4KbZwJoHWhD1fWIgp+Fb1BGOmZMgxB42kavbmLyL03wj5jfCyvnbyW61LWIGMACWG9pN+99wlMaHTodn60/lKmXLSL4mHKyiXIHuw/qGd7VR4pay2k7fJgSNA62ULdB+PYLI3zr2iAKcz9aRLxrU2wS2ZeW/QQV2+6mZ7e+BovRedWMy5pZMpkkjAO/UbRc7wZF4PRDjRS/IRKzf+VDSnYYeqF3P/5m+rp7Yelsh4HnYc9ho+HO8px6uEjLP2/pdD5c3sJNyXvDCl0AvCT5sk89dbJWIb46mvfm8iUyflsW/DkcE89NGLk/U40K7TctpCsf21Ed4c3EOVxY9h1VwayNDxHmUjzUnmFibLntU9Fis8J4sdRNTJ++tOfRjQCANauXcucOXP6/25oaODcc8/lyiuv5Etf+lLEbb///e/zjW8MeCG6urooLCzkwFfn48u3oGb6uC4nuFNpc1oC7//Gr9RQ/u821O27obEJoShoI5TDS5XtyOhU9mawtyN846LDUXtMFL4u0L2HQr0Z6Rh5mTEfX7MpKPKgiYVhYGzcTpuWAAQbGW1dDkxdAkkFR0PoaWpPYfiO3+GQvODYL/PW5iWH7UtwxSXL+v/e1Z3NQWcimiHwuP2mzs7WHKpN6fh0qX9Z//fzyshN5pARjP5jq/5QsitLwnLhPKxvrAddo/hND6UJt1J16WMRz/2L2cswSwtZtnU8lvb4em9kj4appoXsnlSMmobY1c/ioJgWDVJiIhTnk1gT5p4okAg1N8te58FU1eSPpkjSkPUOik3FkxbfYUpx+PCkht6n5HDQeON0hCV6j+21k9dyTfJaxpmGVq65wO7f7z5fPZPyGhnrGLo3SSRmpNRhL/eyvr0cxW3GEP6JhannyMjJ3lU/H1+IH9oTpuM3gNprwtQa+29a6GjvV5EaCbW+NN5z9YatQetjp9fJBk9xxHWOdQxVRW1sIu/Dod8Vklfr75XTe8V8erP97wmhG2Q+sori1334Ev0TeEMWtIdvaTE8TArOAg0pxijG/JJqTkvdxWu96bT4EqPaRjMkWnyJvO3MYYG1niIlsHjlltrFvLtlEo62oZ8jU4/AuzuJhbbPsXL68zGdezjE7Mm0T4juu0TCkPB3/pbCz1uMxTPYf7IdOWP47w1JMhApXhpOspO1XkXp9T9bNtmLWNCBtj7liCjwneDY46gaGXfddRfXXHNNxHVKSkr6/7uhoYHTTjuNhQsX8thjkSeCABaLBYsluBov96xaFhY1ht0u09zD1ef6G6+93HoSBfKEuEpu1njSqepKo70zejk94ZawvTwgxyiSEvFkDE+Or+Oc8STt6w2Q8rxv/enkLXieqxKC1YZkL5i6DOxNoUcJb5IZb2KwBOFQmLsM0h9fhfuCuf3bCl3myXX+9ISp5XXUdyXR1R2YB93RZacjxP5Uj4zoMmGJ4sUAfkWOtkkKBTXlsLcGPthAqTwbLo283dl2H3LWcrbn5gDhXwQ9+WbMvTrmjugMEdmtorT2otbWISfYoDg/rAaO6OqN2NhqtJDT0/wNz5IT8GQ5wt8TiWYQ/uLpwZkL1u11Ax2Cj0GEzUrPYmdU2kNCGEzKa+T21NXkKrFV2NoFTEmOT13MuISDrEsvxpUZXeTAk26g5XgQkoE0TKeJU/ey1JXG0n3jQ6YqRkK4pSFVuEaTFl8ib3mm8ZvqAl4e/3zYerRaNZmdrryQnx1RhEBfPB1l3a6I3uiwGIa/gDsCSk423rG5sGQGAI0LBSLXeWhzQfqOGUhejcT1jah19UhWK+1fmxX7uURCkpHTYzciyx0HKTE380H3pJi33eIswip8mDgY8Ax/sK88ppohc4egY3U2TI/5FELSW5RAT8GRiaB1jrHhnTpyx5QA1HFOOtvsJNb6n2+LpHJJ6VaebF6AtcGEHKbETTeBKyP+oilx50Thd8wcVSMjIyODjIzovPn19fWcdtppzJ49m3/84x9IESzzoZiVVks00okuzcTZ16ziteT5jKlNBUXBpfUM6U2ThY7l8KrPQaxoLqOlPXovhaZKKM74DTjnfP9j/rl+EZMODDRzG/fFLXzvz9cw46I/BnhkdU3C3GmQVB1e6SOlwkvbBAuqg5De63AYEih5ucy8Z0P/NX1h73QmfvkgeH1s+8U45NToXzpSuwlbU2zXyRBQe14axc+40GNofHWGTePeSc/xc24Ku87BhRoJ1Qrp2we8/bJb7x84DAm8KQOPoKPGi1F3ACkxkdoLMyNey6T9aSS/0h5z1EIoCkQqeDT0sIWCwmRGHVeIZht62EjZ679fnDkmevL8GvqyGwzt2EjaMmSQU1MDl4XoryIrWpBkbR8mWeOl8rchRjljzdBxx/Hl0eGzY2jR3/fpU5pZNeO5Q38NL11qv6ry7bVXxLydrgvQh2dgtHvtpJhcmGKVMwrB1o48pDNqeW1PJufbm4LqUjyGDx9Hv1bFkEDJzmL3nVD+qxLk+iYMrxe9tzfidnJqKpgPi/I2twYpOckpySAkuhaV0HjFwFgrGDBmhDCovs3/3+lvFJL2uhNhOXJCIUOxsaNwyDrJwfgMmW514Ld9q2Mau23NXJ20uX+Zrg7jfWvAeo8XoR4Hk+VDSImJUatWRUvvAieGCHQMXjdvFU+um4+1JvTBvKk6V85dzR/jeyonOAY4LmoyGhoaOPXUUykqKuIPf/gDzc0DKQY5OTmjdtzX9k5B1yQoc1HxoD9sXrEXTh1TQbYlfBG5XfLy3fQKYtWAD0fyGitZD8SnSLmPqnP/BgOCXZz9uS9Qftdqblz2zYCuv9TaIhoYfaTt8tBdaMaZE/0EoqcYZr4eqOF9+djN+N6SeWHnDGTiW0h9NHDPcFI/Y+Dv3P+Z+xskurJMrPzDwLW+qvIMdrwanSusq1jCefOMmIvX9bmTIxoJsktFrNwc/IEQqEumxFQDBGBv9GHulmkbr5Bz30q0YyS32ygeeKb7sGyxU/S33QHLTi+t4KH84dfthGK5R2JpV/waOy59bxaOoxgZiAW5xoq5c3jnuuPV8dSe2hSTutRQPD6ulBeWz+bp0vcDlv+ts2xoyfEjQaGLPX/MRQB7f2AFijFtt1P4y8jP/b5HCrlyfKBgxPrrJ6NvC4zI7/zN+ENSsdGNta3nu2k9vxhdF9iG39PyqLK9M5fqN0sDln0M/Itz+v8ejuiquRN+UDoPOLpd2mNh3w+nYBRFr6A3Eq6bsxrmhP/c03NETmNEnCj8jp3jwshYunQpe/fuZe/evRQUFAR8Zgxj0vLyq4uQrVbcOSrXLQxWrunRLLxdOdFvYIRg2f4yxmU3My05tnQVzdCZs+5ael3Ruw7y/23C9vHmUS/a/d1Tj/F/D32dgvs3cMHqiwHomplLvjv6moOEei/mXoWOMUN7lXrLvVwwPX5vKanKhnkEeeh1l+STtTEN80dbOf+MK3nx3af6lcHCsdjq497HH+JrX/1Kfw4q+L2PVdcIZFtwKtEP7v0XeYo/Jc2EzuDX2V9LXuO5G7fzp39eHtU5azZo+uoich/b0J9GIY8fi/1vHf3r7Ht6HLn/3oZvWpn/3IbopaFbZcSSGUjLN/cXe8pJSfimlcVsYPShODUyt+hHpHhUO9hM+Vc1dv6uNOZGXq7JLnb+qgyFgd/t/apyptaVBax3Q/lqvp22Ly7nezToWpFFad0tVF341yNyPF0TWHb5i2ulETh5i5+oZMfYQhi6r+mQTE+tp+LjTNwXeuj+nIlJN9/JN69/gZuTw6fRRmJy8gEyrT0xdT2PN0pZCbZ/+WdqF9q3BX2e+mgTXj2DDZvGMP4HO9j1hwnIibH1ouhDkgyck91Yd1sjNlkLu70P8v+6Fa1nZDPLk8v2kmGJbh9PLVuEpcXfdfr4LeU/Puie7UZusPDuHxZz5reWH+3TOcFR5LgwMm688UZuvPHGuO1P9viTBKyNCk+uXsB18wc8lfXuFLa15KL6wk+UNVWmqi2Nxp5EZEnnjNw9fNw0lisLNnCmYydmoRMuhcLpNkedw5z/bxP2ddVoQ4TG48EMi4Xrb3iHv+acwZhv+q+HLT8NzRJ9GFroRN2YSSgGKab4FSgLVSBGYIlpFtBMEpLPi1ETXa68z9DY7s2j+QtOStLbSLMcagQodG5P3xxSxeY0Ww8WEToNI1myUWKOvhDYEKDaoPPSGaR+UkvvtDxqP6/y+cQBb3z9hcnszZ9M4bvRTSYMITDMMsq0CWAYSAfbMdxudPMIVIgMQDfY88g8EAZFrwqsr63BcLkofkxi3/USij30TMW8zU7hO93Rp6YaBlpLK+WPF1J5qQ2RH72XTpINpIRAw1BTZTQ18Ls/XzOT1e2lmCWNp0o/iHr/xwqSDyRn/DteH07Ccjvp290IzcDU1kr92enDSs2QfFDwditacwvl/8jmmZYlXHXeJyM6N5PQmJTUyJN/nM+EB5yUPHeQ+7svx/Hl/wLQrsZW72YSGlmWbmYW1bKptmDEqoGx4jt7DhXX61ybGN74LXMcEvaYAevvnYCSMLJKXFnRR9SD8/BGm3pHJ8WPFVJ5o+hv/DYUNtkXMX2uyZPEu+sn+9c9KEfdmfxok7S2DsWVR/P0eOs6HhlkRceQwX5Q5eUnT2LBFZsjZn+c4NPLcWFkjBayG+z7TbyaPYUzC3fT7E2gsjODjq6hg6Vulxm3y4yQdLbZ8zjYmcCG5CImWetCqpbs8fVy0ao7wkZH+tDaLSTt9k8AbB9tQguTc29092JuteFNjy2wW32hia/Zq0N+9t30ClbPLWH0TZrQNHmSaHYnoI+we/RIMbw+pnx0C68seoiJ5tDXt11zssNnZacrj8vHbubWtJVBCiWhif9Lo6tYwtyVx8HZJj4/NTC154zcPWyx97LXWUbuiujTz/ruK7MQiN44aeObdM6cspP3fFMo0uZieXMt8ocbSB+7ENVuxpVpoI/xGwX2tXaEBunbPAECBdEilm8iJ3c+PXl2VDt4psXPoG3tSKC1IwEh6TySmo8kDE6y7Q17r3waSZcNTi7by7KqMSEn1JbNdrJXdGJs3A6ABqQWzaWzzBRTF2pTDyRX+tC2+w1nsWIzxaaZPK0sAWFwyWlropIUD8d1c1bz1pwlZGzqJmm/ym93ncN5RTvCdo2OeK5CY6yjmU0in5Fqj5q32fGmGFAwtJHsO3sO+89TuHZadB7jCYlNjJnbwvKmMg52JMRcuD8Yb4qOuVOKafKuOCGlMvg3M3xe5A83YFw/h5hbwYdgb28mG2oLcOw//qY5nvJsOktGft6SCil7VQzfke9hoWd5qL7QBGhYhhPuOhY5UfgdM8ff0xdnhAbaylT2p6dR05VKe6cDIekkOgInVrouhdR9N3SJ7fX++P0nlWNodidQXvZswIRzn6+H7+2/jJJrtrL3j/MxlPB3TvIumawH/fm2kRzzWnMzss8L6WNj+LKw8sp7yZLDe+kyrT24pvv7UfiGSK0ZLpoNFEvgoNOjWdjdkcWB1uRROWYsGD4vZddu4sUtM8lJDd0Ib4fPyptdcZISwW+EduhmNrvKhl45BC1TTbjKQhsR05LrKbm0le0rp8U8aHnT7RCjIRsKoUPZkwbVP0zj2iUreDZzJmP2+VNL0v++BnQN/aSZ7LvKrwaX9+imEUvxJi3dSZLZhF6Yw75p8TfuDF3i3k1nAeCbITPRXDvEFp8esmQHjxV+zOK2HNq77eiahCTrOGweOvanUPxEJeqBwNQjy5trSbpoHt0FMoYkIhobph6/dGpCg4blzbUBn0kfbWTMR/7//vi1cSRYPOTauwY89THSOlelNy8J2QPGqjQqMzIotrcNq8BcEgZms4bXy4gm70WvtNE9IZn6JPOhmgk/ao8JxyCHsFJW4o9gRGlg9GESGqfmVPC6ZzK9ruij64cj8tyoqg2zNzqjSnbj/01fXzv0yiNkR3M25o2xiTIcCyilxez5P4nC/Eba3h9ZbqDkA9vLa0Z1rmq2+LCag43GaZkH+EeRX47+921j6FQ/O06YEwzwmTcy+thQWYRi1hDCwGHzsn72MwGfb/e6uGzl7UOGwXc3ZHNhxy1smfdfNMNvJpz14Vcp/4K/2/LYr8e3iDRqRHTOtUcLVsKb/jqVhd+8PaxE6UjOI3tRA4syK9EN0e8xfL+2HJczWG74SBGqoOvV+ikRGzvFk3Pe/RqOPaN3LP0Yayh25fiNcOgR23hJCer+WqRlGyk/1CIlHjVI7RdOortQOiShO/q9Qz5ryEJi1YznOHXbpTS0JlOQ3sE/xj3FLZechBqm/sb66hqs+Pv81H5xfNh95z5T0d+zIRJpF/qLwLd9YxFlNywbYu3QXDd/Fc9XzIB1iQgdtr06Ae/5FUxKGl59xqVlW3ilesqwx7O+K+d4bjUTdk2g4gcDzq2iVwXWVweKvm3/6omYIjUUFxRv592G8bR2RJ6MiwiRHQP8aVNDzGSFAVkbXEjLQjtuBnZ4fIgYBBGP0xYC7XGVl8se4On2ebwickfmzR5lT7gQBpeUbeVX2VtGtB9Z6MgjyXc+gnwairGPJCeMjEF8a8Y7XJ9YfeivwAnfZLONtSc9wrzltw2Z8tTHRadfBU3NjHfvGNakqeLB+eAIHWZM2Goha310aSz7LzCx4ip/d/RIUYwjwfxLt1Dx60lsfL8VfXIpsx/exAsV06O+puFQx7pQGy1YDw5vP4UvNqLt2488sZxd300C4Kz0HSM6p2gZ9887sHeP3ov13YbxWO9PRTaOzUG8+LlmNv9uPgnPrh565SGQk5Ko+9IUAIwjOLrdt/U0Psqv55my947cQYeJZUkLq2Y+AXGSaH178rNohsHXG07h9mkXgBHca+dwtJZW8v+0LvznvqOTPG9IcMbn1sal6d+wjg+M+/J+tI4OAPTtuyn/4oCx0teM9UgiJJ21Sx7FFEbu2HeSxvcPnMbHz0Xum1H0TB1qzdBiKRO+spXq78xCnTC0Y2DpvvFMyTsQZBA+uWoh9v3KEUu89SUY9Oao9GldypPG4cuM8K7VQfpkU4AYhpyexiMbXyFbtmARViZmbeTiWzfypUe/MqxzSqrWSXphw6jaGQ/MfYrTbG6GK4UNsCRhD2fYnHRZdH4fv1M7wTHCZ97I0BUoOmM/dxZ+wCJrM3Yp/MCQLNn4+9x/cveOa6Kq2xj3VDWbfzgT81uxhYblpCT2fXcyItmNJIUeIron+PAlWsn7eOBlWHmt4OZ5wQWRM+3VR9240CxQfOp+si1d7PMa6N3dyK09vFkzKaiwdjgIYQxXfh+AyutzMJRsNDPIZn8etBzBZfFS5TTMS5P6/37VdhL6oa9hKLD+K38ZUp2qRu3hlDe+gb17ZEXrfVj3W3jSGyhk8OSG+WR+bEL2HLsVj2mmXgx55NMBeWwpzSfloB+FWkldk9jelMOl2jmHemeEZ5bZjSN5PS92zo7LsSctrGTzzmIcVdEN5yZZD+oLMRIswsT4T26g6H4JqWNT1NsZR8mQCIcv0aB0UQ1JyvBrkHRD8L+PFqH0CtRUDSUluu9o3mqn6M0OAL+B0Tf5NIzhNeCLEylJTv486WmSJVvE9b6X/S7Z13bx7FOnBn0mdCh88QBafWNQn45Q6G43Zf9poPHMXLpOjVyTYuhSyCit0OIzpkaDO8PA1CuY8GAvxhy/g8NnVdDl8A4vIRmI2ZMROyrRnU6002Yx/vdbA9KsTUJmpsXHd256hl8/dRWx2L1ZG71YN9cM21gvyGynJLGt/++VNSUB72khDB6Y+xSLrN2YwgiZDOb6pM280TuWKk9g5/kLkzYx0ezFJGyYhqleeEQxjCOikhhwvOOcz7SR4UswMMY6mZNWw+m2NhIiGBh9LLZK3FC6mhcaZlDXnBpyHZ9P4Z7mSfw2ZyVzbhtHYsoCEp+OLk1KKSni4Gn56KWuiDJ7isOHu8CgeaaFzI3+0Scnv50fZcSvM3n3ld1430rqb6w2FN5kBVda8Fl7UwykMT3MSavh+ZdOorTyIBogND1knctw0RM0PF6BJcaeAe5MHT3Ti2yKruT8mV0zsWxIIHVP6FHfkGDqspt5ccGjTDaHfzn36lLUE8NokF3gqDLx4v6TcGX737ApeyQSa479fiMHTtZR3POwvbRmWNvLk8bRNSkVV9bRe1F5PSb2tmZAeeT1EiQreXL8ROGnJDewo6OMlL0aHWPDG+yJpzZhVVQuyo1vg4OJy/+PrKdtSJ+MPBJ1tChOb6Nuks6ctJphbb+lM59dB7LAENgapUMFojKqx4ohgZwZ2lDQmq0kVkpkrXeib4o+cirZ7dTfMYMSyxCpRyOgILOdy/M2sdg6dHS4SEngy2lr+fDMcrr/l4fsBVOvjrlTRRig7auOacKkVlaTtcKKbk6jZ1HkiEZDTxJmWWVcwsGo9z9ihP+9YQjQk1QknwnR48JblBbV5oYQ+JIsWArzkJua0VWDyp4MLtxzHgBfLXiXs+0+LMLEDUktPH1aNS7VRHVtJo7dodNqhU7/XMC2qxG1KbbrIYRBcZbfsChJaAtQgyrJaEMzJDpcNpweE5eUbeU0mzsqAwMgV0lgga0qSD1xotk7pAF7guObz6SR4U0zkKwGaqaX6yZuoMmThC+GVJKvpO6nxpMW1shQfTL/2T6Pr560jq3zn2KB5QqMmumIFSGanA1Cyc+jfX4eHWdFJ7up2FV6Z2o4DliwtcRfvWHbgicZ47wJ2WMlsXZoQ0O1CTSbwHRInqo338CQQU3USDBpvFw1ldI/b0frGDqdYjgoCT5UxUBxm5GjuYSHJGDJ9YSMWrR4HNgkLzbZhyx0ck0dPNswG/vyBNK3h5+4Cx0KHzPxw9xL+Vnxy0wzhx6IrULHWaRhq5Pj5nWztBtkPLoS7dRZGNJx4Bk6xHWLVvKUbzHlL8W+rZKbQ9v0NLqLjq26k0iYhKDA3EadN7pJSSSW1k8gfbNB8pp6PMmFAZ+50wW9JX7v8bIp/yZVjr748pmeZNb3lpIsu/hBxoAs8iq3FhCFKfyjhFh5/BoYAHPSaoZlYLy+fzKqLtHTmICjOvB1auoWmLoFhgROR+hXrb1RIn9pM9rOCiS7Hc8iv+iGdd3eiOOkSEzg4v8bXg1KtMxJr+ErqdE3lsuQHXww+WWmZNxJ2k4Vx74uqKodsjt5OPRtu8hrz2NPYTFGoSusA6i90+8c7DMydnTlIDyjM/b5kgx8KTqGMCgc08zBzgQ8LTbMnQJPlAbGYJxjU7EmWpF8WkCDwHvPPgdn0YdYhY9z7R7eGP8GAD/ImMbTrtCNPIVXYPr9egCinQ3YGgVdmQpJ6b1IwmB+enXI9fqejb29mTQ5Ew/VYMSWgTDZbGMyh0eyThgYn3Y+k0bG5aevxJLgz6nw6AofVY2hN/dtQpsMI2fVjOd45G/5vDgpM+J69ZeX0LswtgJVSTJoudBN9gujUzS97/R/cGnhOXT8pijwuJqBUAMn5vZGH/ZBqbH5VzQwNrGZVz6ZQ95lfi/dCHpxRYViVfGVa0jbbAMFWofZD0L3L9PNoJU7Q768dF2wvroIZ4GZuan7sUo+bk+p518/v4j0pugiA933FHDtXTezZt4/sEvB3qdSUwKVlz3K+L/fgalHfCrk6o4oh8LrDZeXDSmLKsn6iOt+4kmG7OCW5Fq+2ZiLXfIOSzIVoEu1kv4DBX3zKlQg7e91AZ8f/PIiKi979NBfsam7/OKR68j982rkMZNxfjAQ/bj24zso/+Km/tQXQWTnCeHSIA55toXJDIcM4ohSm1Gk2hxpcr94EK29E33RVA4sDv06FTo4KiKLOghFQZtRzvtPPA7AKbfdiu3NDRhq+OvRpVpHlNoF/vSucPgMGZ/hv+YmEf2EcttXH2LiI3ei9Dow2ctgzaDImSQj5PD7EqbAa6i3tlH2/Sb2/G0mkklDSOGL0PuERHa+V47tsMsSyokzHC2M3LkH+HDKS/1/z15/FZnv2klcVoFnalH4DUMhoGOMCXVKcH5n/dIifsQNeJMNNt3wl/73x6+yt/Cry0IXWdepPdz8jZNiihjlPrgO9dtzuGh2dE6CsY5m5iVXR73/TxsnOn7HzmfSyBiMRVK5asJGUqTP/KUIy/Nj30T9W+ALfvbqG8l+IHKo1PmLPCp2y5TXj75c4WCEMPBM9RtrotaGpS3wRVrwZhv69t0oRQXs+XV60Pa6Lih+QkZoBk1fT+Qn44ZfAJ79oJU5G+5mx50PhV1n200PMO6t20ZVXerThpyehndaCeA3FiPhTdHZseRxpn1y8zFlaHTpbnYvVuh4sZgzcvfEvL1LM1FxsgnduXMUzg58C7tpkOeDgLkP3t2/3G5A683zSP/ryiH3IWdm4p1SGLRccmuIlX7jpPLfE7hk3Fa2tOfT8Fb4iVrBI1uDGrgdC3RdPZeewpHdV7XfnseGu/5CXx+dpY88yOSnvsqYb4e+xlrTQfYsUEj6MGtEaUIv7ZuGzxv63ffGnsm8UTEJSTLYvvhfyCL677jltvsZV3A7424NTM1ru3Ee7WeENoysNi/r5/8zYNmD7eN5e0oS477kTwtrv2Ee7WcHh6nbOx286JzO58o3BX0mDMjc7A1wihkSNM+yjFjIKv03dpSW1pD3eEQEHJxlGdLQMXcK5j54N+/e8Ttyo+rDFBvVT47n8vKRNbY8wQkicWJmPQpYbV6emfk3kuJYXBkN4p+ZlJ5yK1WXPhbX/d5edxIb/zYtYFlypwFEVjoROqCqIT2QYuZkGhYmowwqIfFkachpgVEC60Y7SdXB23eOkSM2WOt7d2i5HoxOK8WP7+3/TO/o9Ht79IGXTuIyG7YWv7tLGCAieBBjwgjtRRtMLF7C4xVDEYjvHGRaSnh1mVPmb2fZkzMZc13kPHOlpAhfXiq6LGibZImq0NsiTLw0/xFu2nHDkHKdR4I/tpWx9KbFGO6tpH4NnrprEdeevGLoDQ/x3oFxpH5LQXfujrhe7v92c9KB21j2wKMR1zuc0je/hLXG3D8JOvwe9iQLWm71p23kvFoV1BNDmjEJ3aqgyhJGiEhGb4EV/U1/nxS1wsbLVQsQKkRqzdN03RSEDin7vCjvrQ/4rODfFXxYs4hTfxT9NYwbUcqDh0N/0MnDJQ8FCEVYhImnrriP28dfT+bFoX9jQ1UjRiIi4dEV3to/EdUXfuwxDP8X09HRMWJKjjEJGQ4TLan/3iJ6x/hQDnPPfmHKKj6XtAFZGFhEYF3kzSnbMW2fAMCrt55Gxsu7yPw4GUORqbomO/CgAp7ZuwTzoVeIpd0gsd4/jh8edRc6pG8feH95kuThpVseeoeEuseHJMpNRrOAXZb1mKKoU2x1nGOvJ9ao6KeGE834YuYzaWQs/ftCes80uGbS+qFXDsFyt45JaORndFDfkhL0uRDGUen+a2v2kbXKTJnji1Se9fdh7aNF62W1Z8C7f8/ui+hZkUnuvuEVD2s56SiShFrfMLBwwTTaxznwJRKgmGFulVFdNhAGIs+NZbOd5CoNS1uICb8QdGIfspOzY6uV3BVOtMOK4KRpE6g9Mw1wYltnJ7FORekNNGaqb9L5f2M/jPEbR89BrZfzNt0EgKl55JJIjgMGaVs60QHLvoP4CtPRrCN/xH1JMi2TFXJXDr+A3BAwN70mYoOzfGsHY3MPRhxXlZIi1Kxk//eShL+mJkommu3cPeY9GtVkKl2ZvLlncvQbR4muC153Wjnb1htgPGqGzqS/fxn5UNMy20GDjLV+L7W2Zx9lLybzxo4l/etPv3Eb+daOgH2fl7S5//qVWpr55bcvAGYz4RdtaHurQp6P1tJK4vsqkx6+kw9v/f2QKnNO3cspm67Hut8cUc3GkMGT6v8unYuLSdriQNuzD4RAHjcGX7IlrLpOR7mZ9sUers3dw1Nb5mJpk6OqofIm+4/XMcZMomUuAJa3NoCuoZXm0F4us7y5jMWZlUPv7BD/3TqH+WXVw27kFw/OyNrFySH8UfMsJk7O30dfnKrz+gV4EwNnpkXm2PsTtPkcbGnNw+2KMnJqCL7WsJj/l/3u8LzpQtByywJ6y3wojkDH1NWT1vO5pA1h35fJkq2/LuTfP+hF+fd4v4iKEBS+4z+XjvF2nNn+6yK7BQn1OkIHxWUgu8LP0Ad/ZtH993RPfnSGhsfwMeOxr1FWXYmRNPpOi3M23MID0/4b8j4ZFkKw/6cLmZRZEdNmVskXU13XCU7wmTQyMh5fg5mTeco7DyHrfH7qOipVKFPcUUk7bnIXIwmD0qTWkEaGpkkhJxpHgoQ6L6ZXTHBW7Nu2aL3s8DlY2TMgj9P7SSa5q4c/ufSlWhG+JDhkZMjlZTRPcuDKDHbjKE5QnAJDEnjzIHWPhrkzdETB2uJD9sg0pNsgP7Ao0DAEpt3+mozc5b0hC+5dhYn0znQh1dnI2OYN8nQB/Hr+C1yVMPIidWur0a8aMpgWpwPzf9PoyZcwxyGLx9aq9ivUqLV1SDmphxrRjQxdEfiSDLpKzCTU+5B8sblXNJtE24ThG1GSw4E2zd/Zvq3UhmoRKG4DW2vs0aZrEtuBdj62VfMm8TcyDEPQqiag0809zVNZ214M+PPFy369OWwXc/mDDWR+4K9PcJ81HY8WPDSnSW7MQidNkpiX3MjNZ/vz9yfvvpPiV8xo20N7vLWOTgp/voJLFt1Aus3JhVlbuH1QROnO+gUoQqPM1kynase1LCMmr3XHGBmhZZCkahi9Trx5SRE9u715gssmb+LjprHYdlpj9tR6UgWeVBPCgPx3ZMSkchoWJ+Kd6qS+JYVKewaSMEgz94asWejRLFT3pLO5soCsD8zsvTrjqBoZf9+5COskNWSRdZapmx0LFwDQtEQP6P4N0O61kaS4sMnR98/o8llpaksaesVDGIbgnYoJ3J75IcPqPy0kOk5yo8jGoEU643Ka+Wr6qqjl1dfMfJap3muxdMzF/Nba/nS7FDEd2WvDEOBNFNgPqiHH80jIHh17o443wYwvSYSMTPUWq5ye5n9u3IZK8a/Wofq8yEljYzqWIfmVGGNBX5nKhvISTrZWx7RdWITEmeevJ8UUWw1ol2alRm0MkNo9wQn+P3tnHR7Hee7te2hZzGCRLcnMDGFumKFt0qZN06RJU8jp156c09PTNqeUcps0TVMKM8cBh+zEzCyTLEsWs7Q48P0xtqT1gnalley0uq8rV6zZ2ZnZ2dn3fR/6PdH4tzQyANIfXU36oyClpcH78EzHPK5I2ch0ixbRMPAZ5kA+WPdkv0/hnnXX8/aS31Mo20fd0BAMOBQwJTJzJEvYouMTCRgan3izWNc7fkSvre4zuWgx1Kjr2uCxZKVbo3i5Rs2tIMn9HnI1IFP0w9XRC+B0MDotFC0fWa1+QTfIXt1O4E/1Ia+lALAf9zcWo53C5RjWNpVxKwQO3WAgvatgb1FjMjQ0u4ghCnSNk2NSwunRrLS6nRzXaBEdDgRZxigr5NBdx58Hc9GoN9ooXDF0y0xCx2IN4PcltqmGJOl8PrmFqoCfN35xOqn/HLxu4TiCLCOWFLL0/vBy1493LABgkWtfkANj511/pDztq5T/Xxpae3vE4ydfeIAA8LvvXcay2x7o277/nomoTpn3ZkV4CAUGTUlrmyjRk59P+u7BHRKCBvt6sml7L2/YzdJEp50DN6Shl5qLJcMQWH/YNOzG5zYzLfVoyHuqezLYuquYSd/Zg9bVRdXSeXRkO+JecIGp8qRZTAWpoaa1lP63lz9f9BkuuvtnjFf6F28+I8BsRzV/vctMS5MJHau2HimEcTDe1RI1SpgIunULPiMwaP+fIAQBKS0leJOo47T7ea3iTSC+/k3bFzzBt4pms3tzdl90WvhkK8mfmAZ6YNm0uI4XdF06pFX5aZlmRbeGpsB9/6yXuCW5CZ8RYIffCkNsbqpbRbpKpE9lY/Mqbx4tajLfTI89WvivhKCPbPpauPN92vm3NTLC8WLnHKodh7nK1RXyWovWy69bF8Z1vPM+/hq/nv8Un3GMbjMlS4fKl77wdQByfniQJ0rfH/Q9D3WU0RiI3bs1kgg62HfYkXyxeec+U7kjqENvW8DJgUHe49x+lFJf7iB7DR/roWbUw0dG/DwjjaAalP0TlPuOUL2qiIIPBjfOum/v5MJxsRclv7JqLuVf719gV//HTNSK8As/McdL7fUC9u1DG8KW2ETWL/grM1d+2cw9TzDfOO16Ug/HbmAAeM+bFdHAGMjqnnKq/R3cmdr/XO377INcvegcupcNfp7C+z/hm/f3y2AKbIHz5kbcX7PBVZdHNxKf2jUHy8expVGkVekc9JXFtG80DAFqvjIFf3Yg7ER2oCGLAw3hFf3kFD9VD5VR/uV9VNy2nlV3LebiW+OXhN3/01R0zYPWYsVRN3RnUt4Dn3DnB19h+auP9237YfNsnt41eMPGrUcKaUhP5ozc+FJf4uWWNV/ktukruTd9sNG1H2l8Cfv+NwVxQBJkcVY770x6dcjX8UDeJmrX93BrcXxKSrGSud1HxwRLXzrgidzfMpM1MxRiF4oNRvLoZG3x0TRn+IXnY4xxqjNmZJzADk8hB/2h3rjBoheR+M62q/ieqNPVkEQF0RuN5f1tO56DE6m7KfbQt64LFDyroPSEH/COPFDBImslkt8geVszD6/4B4Wyi7K3b2Xij/o7evb8AU7L2R/2GP9qSJMr8GcN7kH7zX9ez5++Us+Kya/0bfvT//2aa//+TQo+TFyDu/xHttN2xVR684Y347RNVLBnLCL1H/EtbuOh93eF+M7XyPlhsCdr53OTUG0w4+J+o2KmLc5Us1Q/xpKZAAirtw86AYuigXuKF9teG2Li28TETXleE3+b8CzxemcBar+7OOjeDUZTIJlftpUFeRT/XPIKz+6ewPOTsuM6d+dNC3HnhI5vxvxOFhdWI8bgTru4cgfdZTaafS56/7cgYsFiZ2nkxdtQcRxS8GZLiNnxOXOGcxU9mpW3Dk7qUysTM/z02mScB4YRGdu6l4tOuwKAPd/Ixpode2SlqcPF890zEQSDS8bviBjVeGrXHKizIxTE1otpJBATUM16ojknZWYQmBinwlOsCPDIbb/j7h98jWc+bkDw+oHIAhanMsKcKTQuSsEQYaoYW4PgMQYwVvgdN/+WRkbHc+NRXs4n5bHQH1nAkOhUE1fY5PMqVOY3YstoZjDxRb27G8eGw+QLJRy9MYbmd10WMjZKKN2R97V0qDg7vYg1TWjNzVz+g3sxZJiwwxNULOrX4ssrPZV4ZfUcFs/eS4mjFYAk2UvVH+cz+Ue1aPkZ9BQHf59Kj47oH3zhZGtV6fIGFzVMt9i49aq3+GP22ZQ9Gz09wXawGb25ddDz6N3dZK6qJ91lQ022Ub9kaM+fLtNXCC1NqSSQgKLvE7F0qiCJITns+89pxiVpw8ptF0QDzWouH5q/sQBfbngP9UAkWcczTsXaJCH3xrds9BkqSR84aFsQQLYN30rp8Vv5wJNv/qHGl7qiuoy47p1miHRqdp7qTuNC51FSRDtpkoMzHPt4nviMDNUmhKZDLehkTt6RoK6/0XBJPlySj0xrDy/cmkvuc1YsHaH31JDNAttEImjmf0Oh5u4ZiBr0jtNY3VLKoszwBfQDqfemsL01L0iZSRAMkIe3IjBUFe1ANfXfXIRh9UdVfgp5ry6iHhvSnlk7P+LixNJmHnMoWRhfmvYxlyVtIx4j2qhvYtyj6dR8QUcQDBaUVPOlnI+GcPZBkCR0S+IeLGejhqhKBFwCeR+08bWWr5Gzoga19uQYF2dcvZFLXDuA8LUQf+gYx18fuJgMI7qDyVAkAk5AYMi9edy6hWd6UrjK2R6XrPEY/578WxoZ709/iTOsN9CQuRjNCrc6HmOHp5BAome/YxQ52zkvdQe/ueAGLG9tiBri1RqbcLzfi6N8Bt2zvEhy+OnAOGojY7dA9pr+aISabEOzywi6gaW5v8uq0NGN2twMQMZfwg9C3auyWbHMGJJe/2B0V6bQfc5iYPCeBvFgyALeNBlnjcia9BJ2uXJItvlYmn2Amxat5qO5i/AlS/TmBy8+Uw+AtS22abZ9dwb35s/i57n9sqr3ph8gsETm721nUbgi2MAzZAFfqkzKzna0+kYMX2wRD/VgNQBKagppWRPpKB9ezq4/yzliHb/t1QqvZk3lkpIdfdvOK9gT5R2D8+aRSVgO2AHzfvVM9yIrsX1HcrIfrcOOHKGxsOQRuKd+Lg/krguaFAMYpO73482w4i4SQ4pq48Hh8JFs9bLNbfZ5qL+kmLy3FNRDsXdMjhfNENnhKeQsR+3gO8eIIYK7NMCF4w6QrsTfqVkRNK6bvJGnFywlc6uCoyH2qOzJwH+sn44E1Hcks8tiplCOd7VgDRMeq/OmcqAzs6/L9EAEWceXZmBtj/13l3pAQ+gy77PodOI5fTK9szzIYpziCn4Jes3p3HlEiuoBDSQPbXF5YdJ2KpTYDIyrD5xD6iYLem8vyntbMG6eztSiem7IXsMZ9sQmmkupKZCa2FRfpVtD8hlgGOjb9pCxLXJyVPvsTLpKRXLXxBHdNsDaauBPFdCjrMJ0BZjZxY/zPiBFjFxsvamrOOLcfhxpQindef1yfG/XTGRJwaG4f+deXWGnp5DxSjOTFGKq+Rzj35d/SyMDYNPcp2FAGnKr1kGPZsOrK7iHsBLWVDFkYJeOLZJ6VAvpUg9tt/dQuGccWu3RqJ1c9d5ecn/1Ce6fLUJzhh+Q89YauJ5dE9RBW55QCtnJCKoeUWlGSk2BMN6H4gd3c9A2kbrzmhAxyDuW6qI6DQLJEkpX/K5Cd66CLgk0LdE4dKnZjG7Sw3fEJFepOg286RK2NpC84e+BLgt0lZifxbbVgR8HdekGdae3UmDroHG+hNIVOuHrsmD2bYhBgaT4TT9vtizikq8E925Y6toLl8CKFf2yo4Ys4E+S6CoWSXmvJXr34ghoHZ04XlpHx7cWheYEDIIugz9ZQC4rIYa6+SGTt9pHizsNShJ3TO8nmeQPQ8UsGpZOgXeem4/vzk9wCOZvu1P39EUdctf4aMCKu1xDtg7NJV6a1sbUlP4i44tuX8XywFKyX3GjHTPwRwMFA2lyBXrVwahjTCQMEW6aP/w0iuvOX8XznmU4Ggbf91Qh4JfZXlsAgKMkQLoldPG1uy0nYp8VSdYxijzovQ7EAFEX+oIBcg8kvbYV1etFdDgwJpVS99kAQ/IN98g4jsQ4YOigBcS++SkWXE4vShzxj7oHJ5D7wiaw2UCSMNot3LvkTZbYRsDznZeNLy/x9YT2mk60XdGdbnJZCR1X9nJ9xUbePHwazvrYjeqUQ37aKyx4swQ0q4HS3T9oq04DzQJqssahxY8BkbW6d/vd7GzLJYXo6c49U7PoKj72jBigrU6j5sIO0lPjdyZohsiLnXNwpK6lTBHiEwMId226l9d604Z1jNFgrON3/PzbGhknctuxBcI2v5dnOubF9B5tgKvZVmUzJ5YBeKZ6ECWD1YfK2NOWw6Z5jzP5p7cw/n/tEY2AgZT9R3y59dr+QwiDlFXUfnFKRKUYuRfWvzgN3QJXXmUWQV5z8SqeLJ5LyV/jnxx++qOHQnS9Y/HO6zJcfanZhfT5F5aRvyr2xae1TWDdK9O47JrIXUy7ikX8ToWUQ7F5rnPW+/jB+lsH3c+dJdNTaN6nmlsrKf7HwZAmZSOJZ4KPm2atI3CjxLrvZsWUEvbvhD5gkfTr1jl89I3+4ufcNT46my10npm4XPUL7lrFUxOXMv7e0TMyShUXb7z7DBedcZXZt2KMIbG2umRI7xOAwCQ3cpUjqjNF8kD2Hz/peyJ7z5tK/bUjq3R3HKVHQN5rwz81tpoPQdRZN/dxFCH2NM6uEhHHYlMiWjAMyu/ZwLunT2WJbdeQrvlU5dxXt3BPWjUAn79/HV/64tfjyqNPq/LTdL6HeyZ+wG//dnnf9gs+s55f522I6RiXPvUtyv7f4GsF+0vrsC+cTt3piZOffbxjAWcm7eJs+/CUzX7eOodVswC2D7brGJ8yxoyME5husZGfsWZQJam1rSXsr87Bsd/0jIarjbTtMr0PvgwdUuL3FiQKYdYU6s8wZQRj6Y4s+uGFZ/tlamw6NM0O3sfRZOCqDT8pBpIknvjdL8mTHHCCX271F3/B7LfvxlkVPlrkzdK5+MzYBlfJq5O92U/zjP7OxP8SGAYFv9tIy+dm4804NeVHMrb7eO//lnDWdz8e9rHe/fkScppHWkoY5j38TX7x+Ucjqr2lHPRjb7XScHX8EZVd9TnsbshBljWuGB9/g7REcSDQw11zLkNrPfkSk+dfso5XJ0yj5NF/pR9nbJS82I6xJ8p3oBsntaZT0MCy3YFnUuSU3KGy8N7bg37PuiLyy4MfM0lRiDs8+yngbbfCOvd4NEOk8ic7AVj57GyyNww+jpz961Xck74dRZC48ms/79ueJFqAwSfr0756GxPe2jykGhuAQ2+Xsm9GFtdUbh585wis6qlkdW9sVzDdXsOlTjeaoXPJ6VdB+zFxEE0DTl6vmpgxjBFRNIt6vk85Y0ZGGNJEO7emrebxzrl4w6zKP2gop+5wBrZ6JaqO8fHXLO0izUfSYObIXG801LPm0FFuibsPw4npyCeWq3gzBDTFEjEaUBihWU+a5ODB0/9J3eLQ0OjmnmKOepL75GhffHoZGVXRPSSCapC2T6WzWO5rPCfo8PQHi7FFKAR2HjWwh+sinmCaLiwlc0Mq+rb46xUMn4+c5TV0LiikY8LgE3Ngdg+LCkdPKlfQwdau8vqflzH7c9v60utipdGXzMbGQgBcvXrczbNOxNEoYGs1oip0ST64a/nNfLB4XZDkcR8GiP6hXYehm5o5AV3gjZrJnF1YFTanf6TRENBaBhcbCIcvzWD8/JqEXYtL8iErGic6Gv4dEAIaeoz1WG1fWETrTGPUl9+CDv857w2eOTqXg42ZIa/PKz7MbbkfAgza6+n6Q2dx5DcVdJaJZDeHNjctkwc/xqcJQbGw769T6FTXstUo6lsnHK9vyD+/hqYlLrp7bRQ/Evy5u4ssnHePGWn/UtomHKJZ55J5QlPCz1afwe6/TWLj/zzYt23ptisR/tQvy5y0ah+aN3ZVNWlXNYW+cdSeZzodBQ1SX3Py5oqlXHhH5Oh/NAKGFHM9625vAe92prL5x7NxVm8cUkrnGJ8uxoyMMEiCSKniYqmzik2eEtpUJx5NYXeXWRRYdzgDS5McU20BmAt2qbd/ovXluLDWpaB1DL+bdFQWTqdzvAVfauK94ZoFjBSB3jylLw9V6fTizXFw9LroXukLHD4gNI3ogGM/G30FfcWzKYd0rO2DD0JKl4aoyf31KQbYG0QydqlIPh1fqkxnqXn/M3cEzBqPUXAQeLIEtCTbkKUy1do6kp12ICOsoaHL4JtoPoTzCmtHvWuxoBqk7/bx4aqp6DYDR34Pl5dF9+Lv6srFqyl0+Wx095iRPtcwvwt5rwNnvY7So6PLUthu8sdxHJF4/pP5IEDpEHXuo2EYAt09dvRREMCXBJ0lzipcw8yHTt/tpr3SgSfHYG564oyMMWKjN19Ayhpemp5h0/Cli1jbBuT1O0CzRi9EX+Y4gFKgsj0tVP71jOTdQUXaf+nMpTGQErLfkwfmoLydQvbLm7AtmTrotX7s1fna9hvZPO+pQfcNx9tuhdvf+BblxyXh2zqxKBL+zPilo4eCnJfLkRvKuHrKJxHVKOdlHIYMaPa7eO/8mahZAYRjxfyp6W38KPt4WlDka97blk3OC1WUzr6tb1v2JxKpL/anRsWbpKR1dSFWVZOdNalvm+1QG4Kq8VzBMq68dNWQVaei8fi6hQh+cw6Wu0XKN9dBoVkTZ3R2R20ieioxVpMRP2NGRhTOsOts8pgDRbvfwb56UxrSVq/EbGAcR1AFXne78Lfb8GYIWHOyELX+AVzv6UlMaEyUEJ3moNc8zYkvZeQWO7oCvQUi1i4Ja5sfqaEdtcTF/jP+NqTjjVdcKEJdn5ERD5LXQLMES3E6Vx9Aa2nFXlaCLzkPAPv7O2FC0ahNSMNF27uflF4P3rTQexJwCVw5LbbUspGk+A3TyGyancIq13gEwWBCckvY/gp7m7NDumx70yREv4Hk699faLegpftjSuXI2qr2CRO46nQCTjNsp1mDI3C+NPP35ayWcB0NPa5mFfGmJ8bb2ux3kWMdTLS6H1uzELOEKpgqTjlKJ+c5AoD5eWvUHh5oPBeIb3ASPtlKkmsubdNinw48msLG1uBn0mXxMTM1cUpX/w5IE0rR7MMf92WHiqboaJ7+Ijh/uoZh17C2Rw9jfz65BZIHd1A8Ur2ElvakkO2Zr9lIf/9Q1AXvXzsrcYhmZOex2gWkPJzEwxX5SAMSfZyij+uToi82P/LCPVuuo/zutX3btMYmMwqUwDHdk6XgT0nDJU5E39EfiZbzcmk/vYRLPx9b48YsSw/Xnb+K29NXkyPZ447maC2tVNw+tMhkJPTeXpS3++eN499b6U+b0S4VEeM2XQan4C0xyGHoLeuPxlgbbIg+H/SOsNN1jJPCmJExCO82T+wzLmDoDnBrm8B//vkWyjb6wABfQQoU9HuFLGv3oLvd/cpP+tB+6FJWBr4pplcq5YDfjGSkCSPWWdQQoHWyTPETR1HrGzHEEWqINAgpB/30FFrCpsuoB6vJOCYRqzNCyRsCw+vuFQW1to6MR0L12eXCArhlZM45FLI3+WBTBgArbsmIOde7/TwP2od2Uvf1R8BKXglw+EIrRr6ZCiCc4NIxIKyKgBgwyNhpLmbaKyz4UwSzXkeAy89b05fC9FbtJIzfJgeldfQUygkr/F59qIwZ42pj9kTl/voTfHvn4flRLXYpukKNJOjkKJ3cntr/TPiMAHccvIbAGfVDu2DdiOlaA4aEbghsaS9E+klG0Gv15RYmfcWMUEZMFTvmCUzoeCSYx0voIcXQZ9fQEz9y7P5OJrIzMc+cpOioFf3F3BKgukd+im+52EtPfhkFv9sY9nVBNXjprnP6/jbvos7Td14YtJ8nS+HSB34bURLVrfu59Zmvx1TkPFxaLvdw7aRNrG0tQbrAghHwI8gyNTeVcdln4+8M/1DbIr6QtprxSuKKrhOKICBYrUDsDSAThS83Cdk1HtZuGvVzjzHyjBkZcWAA1u2OqHUYQyUwv5LOEiveTAHZA9m//yTuY0iVE/DnB0v5pRzw48lW6Coe2bzomuuLgCJ6yk9tXfyRor3CQiDp1CzS/rRSvNyPIYh4MxWaLw3OOzYabH0RFCGCQZ5W5af2bAuXX2QuSgZ2QT6/cDeNP0zm4Pcmjljq3LaPy8lbE7uzwLp8A3u25DDrzegNv5Y4q45FMPqZ/te7Kf2f9UO6TgBlxSaKjdlwdvT93nxsMZnb/aZRcsJrqfv8bPx/cwBw/Wct01NCP0fqfj/uHIXuosSNR71lAWRXYsedJxc8wvQTmrvN33ATPb22CO849dCbbDgbPj31MPbmAJ+59Q4eefjXYRfjF912J2XL143qNS3IqKZnjZW9ZySx76EJXDU5/nn5OP/oWBD2t3sqYCyazqTfbY/YKX6MY4x1/I6bMSNjEP5Q9gy/Tz6NV/ZOBxKbI6c6JDrL+r8CXTF16lU7tH7ZlNfMWVHf16gtGuKMSQSSbRhC6ELX1qYi+SXay0eu8O64upP9iELpy7dx6LKH+147EOjhjZ4pYd8nCjq3pxwedufQzvEW/LEu8quqsfXk4i3JGHzfGDGEkYsWRUJraGTjLdPIfegIBbaOvu2KoCHf20DX3wsjKoCdLH4y9wXKLU0h2685+A1S952w8ZjX29amkv2ilZStLfRWZqDaRcSAEdXYt27aj6Hp2KdOizhxZlm6OfjdZrx/ysPWOgIFiDrxTRKGgdrYzMZbpgGw95s2bpzebzjcnr4aiyAcq8Gw4DMCLLz/6wiaQU69hjF3MoKqY2wwmyQeuW8xzoWhaTCBtzPJ+e0JiyXDwLKuinV3zmH+H8J7pN94aCnpRwJRi/SPv9b0cAnPXJzTl4cetE+iJ84h/O40VcR6wEagwhMUJRNEnScXPMJUixCS2vLEjEf57uEr2FmXN9wrHh1GeUFk+HxY1lehzp6ALg1tPBcDBtf++F4uvfNDvp9lyt1qhs6ZO67iyMUC0tnB8vKVPz+E2tCI1tyKdXMA36yyYX+Otq/3cmZefxNNl+Sj/ekSzs7cM6xFuGaI6KegCELLbYtIvubooBHUMcYYCmNGxiCUKi7WNJeQ8p6djrMSp6HvT5XxZIioYXrsGCJ4082Zs31eLikOW1Be6HFEmw2hyGweFUi2oSvhBzBBNVB6NFy1Ar0F4oguhkU/OI7ILNp6FS9M+TttusRGbwmNgfDNkiRB5x2PeRMqlVYkwcz3fuWdBeT3xD6ga9b+egxBh9zVboye8LLButeL6Evc4run0IJuDd2etTWAcrh5BMqLTQxVxdiyi22PLmLPFU193dp1Q6Dp1XGktY7+pKHZRJpmKYgDipYcDh83jjdzgM+yN5AmhRZKnnHeFlZPLaG3xxYieSqoBvYW87NY2v3IvTEYyzlZNJ6VRc/CyOF/UTBYlHmIxy/MJuOTU6Rrra6hbzEXV+Oenc9r6/ulpJ/LWoohgOoy0JNV0AVK9/r6jC3VoWDIAvX/sxiA9IUNnJl7ouUGr5w1lZr0xaBD0Y/W9qVm6t3dyNsPohtCUPFnW8DJuytmUVCtxtx7xVkfwLvaSVelRs2XfBQNUNjpLBXJOKOetvdO0mK91k7OFoPuceA34ES/zHSLFDZ3fpLFQbIl+hxgANmv2KBp9JTeTiX07m4sB5sJFGag2Ye2vEjd7+eJV0/nlRlTWZZvygA3tCchp/ohNXjf2uvGo7jLcNWqWN/ahO1gM/7ijCEZOZpdpO3LPfzflJc46MsJmrPOyR+8r1UsVPszWSPWsNAWfQybveE6LM8MrTmdfvos1Cj3Xu5VEVf2S9b60gWWZJ18yetPA2OF3/EzZmTEwNHadCa/eZiecSV4cnWszWKIxGu8+F1inyERja4SEUNMJb2nCLW6X/lFtNkQszLxFqbGdD5BNXDWB/AnWQi4hBBJ2kQiaND9QQ7rJ2TTprnY782JuK9miKzqqQDAkbwdCxpvHppM0duxGwH+FBl9wOcRdBBXbYmqHW74fChdPgLJYayDWBHAnyzjzhHC9ulwbD0yKs34Mh9eTW3mYp6cbE6Khi5Q8YcNiGVFqBlONNvo/MxVp0R3oURgihsByMvoxKH4KXa18Z2M44vd8A29/lS4GgpXs9Pv4dqd3wIgfa+GpcP8oRmCgC/GZx3Mmif/uV1cP4jaFcBNs9fyfPUynPWJHdGt7QK2lqEbs7ZX13Fico6UnAwFOcc6HIder2YRuery6Dnjl5bsgBKzvmLt+nk4Pt6L1tUFmIbr0zvm8JlJO0iWzRS1Dr+dcXH8Ho+TscOHJ8vC8ot/z8Xb/6Nvu2VhG3+qfJyLjtyN44Bl2OmngltCNQDRQHZEH5j1BhvZmw3Slu+l+7ZJ6D0KuAKIYSIuQ8IQSH5+E1rg5EcQdatOwGXOMUpP/1wjecHeat70r1TdyP+Nf2HQRe8Kj4RfjW3SMHp6EbThdW8ufM9PS3Mmry+I3gDQvcB0InRV2ylrmYwGSF1+cFkiOt3C4UuXaZ4psnf+kwA8pXVFdIwNh1p/OhoiC23RjVD93QxSHoszNUsQkMaX0DjdThjBqz6UXoW8BjPiE8hPwZ038k1bO8ol0vaCpTP09yl5VaRu74g548Y4uYwZGTEgKDqG20PZ7/dRsbyd19+dFyQVGNMxDHPxDWakIp5oQneRiC+lgKyHjhkZooRQmIe3KD2uawAzT/14/cBIN7B7sXVOUBrPYOiGyCtd08n7Y3wL/44JUt9nEQwQAyBlZUXcX+/oRGtpRezpRVxgSvkZohA21SwiAqh2ifYKc+I1JELup5HsQvIGT7ZaRwcYBoJiQXSZaiiJkO8rvD94QjIwlamU0mKMovQhpy/EiqAbdBdKdC/r9/T+qPzFkI7vgzHFYmfnXX80//27O8hd++mdenLWexE+3pK4A4oSevk4Ainhb6qZahn7M6wIGkv/bw0bvjQDjqVY6W43Ez63mb0rCk0ZzgRQqrj6vtN+HOy/8GEm/+1ORL+AGOgfH+PFcVQERDQb+MujH6Tk9QDyio2QZv4unYdkektBSAqEiAvEiwFonvi8N4JPRLcLiTNyBiCn+tFTTVll60Z7n1fUdVTD9ewxdabH4IvP3czb8x8iVZRxif3PVsDQcBt+AobOV9d/NebC98D0khEfb07EKPFw4Bvmva/4TjuCkYwv24FmFZF7Iz8TqlPCkKBprkjV5/v7USiChiJoMfd/GIwezdona20TnTRpZpQ9Q7SHpAofCvQgBuJ8HgQBKSmJI1fmDbq2CDih5kpTjj/n3FquSh/5qNvl16/kpaeWkbMueDwXNR2loTOmlPAxPp2MGRkx8MSyP/Pa+zOHdQzRB5nbj6neTLISGIbanjB7Er5heODTqvz05iv0FJxa+aHvdk/hrdqJJ0bE48LeZJDx/A5e3PMe1gj9A+bd91XSH11tpk19aIaNhblT44pqeDIVukr671/+2UdYkFEdvNPVoe/bfHkpanUNnVfP5uzvfGwq9ZyVMWI64eqhwyjtHfhmTxiR4x/HsruWZGcxsYu2jhEv+rLpURdvbZOsXHxr/Mo3JwtJENn7BXNhd/7ui6l7O37p6qDjecG+PUz+6QAsLe0hEU7nIRlvlgj5sTc1C4fRYKPim2viKoMo/9pajty3mMDkkVP10TWBvF+vjahYOO7qHXz2wm/Q9dUuNs19um/7z1sn89cdi0bsukaKqp9mUvKgQNMsC/d/6W/85is3RNz37gee4ipXV8j2q1xdjFc281zn3IRc09svzkcckL36FGcB8Isv/+VY36h+7rzwi2Ttik9BSy4p4vC1BXFfV+M7hbw8M41rJ50cZSdlx2HU1raTcu4hMdbxO27GjIwhcNaZW3h7xxSce0cvjzuQJNB0x2JyHk6MuoajIQCGQtN5ZljfesBGuCbIQ0GXYcEl28mzxqd7/cSqxRSsAOIMnGZuD9BerqA6wJMp0HDzNKb9I7gplOowOHjNQwD8+b9+zRXz76Li9gH3cmsVwpKptE20klYVOdWhbbK1r0D/OFMv3cM4e2xGgvJ3H4aeT6nFzPEVBQPxRRsY+Rx5o4T8nw9dvSQSWmcXljW7CSyYGF+0ZgCGLHDo6n6dUNc+hYLf9BcIa34/9hVdTKgt5cD/s/Da4j9SKttgGH2Mn/nKA1w65Y6QGo1YSf+HkydPW8INZ30cdb83H1xKTk0AUTOwvGILUbIaCmdN2Ev7jxxsf3sxRf+b+O90pJFvNnj8vkXctHB4cqF5q1VmNdzB5v88MZIRzOMVT9M4vv97vvyZb2JtHbniMa2jg6I/7QSg5bLJeCMHPmPCsdZBweN7h9Zh4BRYR9jf3479aCmz/vf6vm2+QGzLA8c6B+l7AgjzpmGs3z74G2IkfW8AW7udtgvir4Vc8LsN3JC6jgmKTMYjf46431yrBgyvmWUk3m8op3VdDhgCcoQp7etPfdFMXS7t5d3Ff+T2c29BPxBffYS+bBZ1s6Ib16cagmGgrNuL5h59ydwxRpcxI2MQPvbqbPcGe9iyLD3MGH+EHdZ8bNsG/3FbugwcTcPLezREUF0gTClHTUCOvaCDqJna6uaGYR9ywMGJK03qOKJHxNIZfy6z6Nf7UgEMyQwHWzqCP5DSLTBx1edYteghZlqd/OCMF/j+n6+g4sumeo8R8GPdU0eGmkf7xMjfqWo/VpifrZNS0YYoQLGjLWbVkakpR0O2HW9g1n6WnSPWxYy7fy37fzEvbN3MxPsPojWGqjNFxTDQ3W6se/rPbSQ5Y65xkLwqyuFmSsnvC8VbWzoxfMFWqe71Iu47TMHfp5C6lLgbT53IFIsdQxewHWrBW5oZ9/uVLo3k/TJPZs/lhqmhTQt9usxz6+cycXU7YnMHRrILzRJ/CmI4XJKPLFcPTUuT2PebhQgGlH9nc8g9O1VRa+uY8FgWKz5agqCDnaGJCEheHUfz4GNfpuQkc8Dj8qUL36XJn8QnTaV0fxC5pus41g4DW/uAnicFItoxH5AhgnucucqrvjwN5ZzFKD0GmX8yDajMTxpJ3Z9MwCVjSAI3FZ7HL4pepkgOllG9++g8drbkhpw7ZYWd7NUtaC1Da5pWtLyTencK7nkjs+CSZJ36Fyoo/LYXbX/4Zo+614t0+CjC8sl0LvHGnL7lWOcg+bCG6NfRLVJCpxHRr6O44583757xPlck7aTw2Pe3JGrKZngHxhqvxjZfadznPs7Lh6bhOZiMrTf6HVG6zdcD+52c4b+b8r3xRRTUs+fQWWYJKyATK8ZhB08bc7hucr/T6Ikt8zE8EjctSlxPEnuTgW13v6y12htemOVUZqzwO37GjIxB2OfPpdYfuvCYmnIUmxxgbbeZhuKokUNyiq3tZoMrS5cR1O1yKIgBSD6s4c+IXgg3FNROC8q/uDy2oIG8MYnvFJ1PprUHgIqyesQZk9C37THlQxsaUQIBbLnldJZJUXNbtSSNC8ftTug1np1XxaazPbQfnMeVZ6wN29DsjT1LyX3HGbRY6L1qAboSerGpm1swauvRjw3mA4vQpd5kLBbTgxfIdGCI4T+s7A4gtXSj1h1FqRtgpET4DIJFoWO8gpKg5UZFYSONZxWRcmhohbSCYYS92LaAk4/rSil4R4QDR1B7e5F6k7En2bBtTsY93YMoxT/CC6JORkpvnzrT0uwDkH0A3RBYcd0SMt46EJeRKNpsiKkpIAj4hhiFGiriqi0kA4LVSmDJ1EH3D4c7V6FxSfz38bhQwM+tnfyd8yPud3yMtXboQTLEAbsF/ZiRoSkC/mnm86Om+lGB7l6FlANmT48AYDvSifDxfhAl9kxcwDnz7uTM8VWcllLVd8z3airwec3fzPHvGcC1X0Db1b9fvBgbd5Iybj7ueYPvOxRESWfzvMeZeeXXSKoxDTYxYOB8vr9rtmizIaQkk7bXjzvPhq8wgGyLPGcZhoBUbSOtKoDkNQ0BQxRQcnNG/Tk9kRuSd5EpDa/pXXUgkxpfv8T5VHsth/2ZdGuDF5m931CO50AytubYI7BKt4B1qw1xxiSMXQcwYhQO6Cq2xCQgEw1ru4BXtsFk8+8X9s8gZYMV2W3wTNosrp24OfoBYsTSY4yKEMoYpxZjRkYUenQvWpTq6AnOZiYsbAbgqZ4lyL0iYgCUYwZ6SnV4TXlBNRC0+BSeZLc5KWhnzI64IBwKBuA8LJ8SIfvRYO2L04P+Fs6HcUdNL7nhdqO1d5L8wX46yyojHkO3gGAdGatsdtoR+I/IhXgXfWUV7/QsJXX/IRAl5HH5lH17N0Vh0rVe+ccyCt6zIOw+0LftuCdd6+qCHWYusjR/GoYS/mGUGzqCVM2iIdpsBKaVHUuNSYwxvHzi6/zl27k8/aUL0KzxRUbEgI47D26YFhrF2NuZjbQ8Fedzq/ty9LWuLtiwg/wNcOCBhWhZ/pi7loO58LRa1T4p4aBrEQzO/eYqPuxZTNJ7PrSO6KmEZvddEHOy8I7PDnpNt4josoDs7n8GA8kS/tSYL3XUaJskcPCKhxJ6TEGnT90v5aA/rDpV0pH+RZpmFemYLSM51D7TV3YGOPLF/v1dn2ST19KG1tpG3i/N9LatNy3k7TOnYE/tT59TLOaJFVnr+55XFCwhLS1tWHVVktdA7VaQk0ZOdvq2m1/vU0yq8aTRumEc6pGjoGuIGel9z1nBB36OnGshEC2FLCBSvCJ4IawrIt7JhQm7Xl0RCNhHt26wRze/a/+AyVkSdK5ytfCPLuugRka9N4W2NbnYhqB2r8tw5II0ijty0I42xmxoJAJBE6j3ptCrWUh9zoW9yZwn7E/aqLo3mwnO5iBZ63jZ0ZmP7Bl5FasRZ6wZX9yMGRlR+HXbTLx6bPma159j5n0/vWsOeY9EXwylVfnpKbTQmzfWIfpkYwhQ88VyeicEyPpYJmvFEQ7fGL0ANXlRE1cmSDd9OMj5ucx6uTri65d+fiVPFSyh+PV+L7RlzW70E/Ng122PGHeIJ/7mOXsaXV8JLaIcLi1qEsInWxHOmBVXTYmyuwbH1Iqwrx1pSaX0ocipAOO/tYYj/7mYwJTYU1hSkzycVxDaz2Ygp//3J7w4cVmIGtiJ6HMnoVmlsElKrVMUeko1Sl/o39b9hS5en/kIf2n/9BXqxou1zYgrsiX5dMqegIM3yhElbnsWu6kqqWD8t9f0bUt5fA2Oxjks/sXWqMc/+z8+5tnJSym5b+ipJZbl65m8p4iq+xOTrjcYRfZ2il5uZ/MlxahHakNeH/fOYPd35EPfbRMtfRK1o4HPCPCTlqGHk7pUG2tfnD6MKjSTw9ePo/DtZNi8c5hHih1rm8C656eTvdEXlBqpdGu0/ncJth8HwjqyYiVwk4ytdnS7tY9xajBmZPybIwCeqR4sVfaEFX6LAXjhuWUsungbebb4ir9PFo6DCq6jgy9cpl66h2LHyVfD8Fw+H/tdR1l5X+RFpXFXMxefsYF3SyvJ+b3pgVPnVWLZ34haF1obMlT2/WYhRpKKIGnDUgY71Sh+YBNdl86k6fLBC8Er8xuZklIf03HPvnI9b0ydyfgbtwzpujK3+3E0yBz8HJQ+Duf/6iPuTNuOS3Rxb+Y6ft4yf0jHjYTh86F8tBVt0bS4eg90fKObj2f+FRiGlN4JJFfr2IbYZLLkOYG6M+wYRRHczHk+qh6eR+UdmzFUldrvLmbpFbGlilx44XrenjiVcVfviGl/QbGgLZ4StM0nCBT8s3+J2jxLwT81+iK74rut6G0d9Jw7mYarQwfwnPQuXp/6OJIQPmk/99kOqn66gOR1iZMxtXyyE2PK+IhSy6cay91WNriHXn8xEuz7fBKu0xaT+5tTQzSi5keVHBYEGhZKXHPxqtjf50mj5SIJrSNx880Yny7GjIwwuHU/z/QUDkkje0FJNWtuLaX4L9EnY3uLiqhKdI+LbdJWnQJdNy7E0RhIeAhNFI3EFn5jGhp6og86ggg6NM61YCwoQoxiayTJvpiLvEcK4/oWavdnkPJ8EenuyJZh53O5vHp6KhlpPRiynZpzFRAMsjYWkb7WMmxtctHppPrbMxDSPUhDqF+IC8PAsq0atXJcTM0FrTuPoA+SkjQYutdLwCGwoKR60H0zrT0xPxfJshe7vf8ha7x7Mb5j7VTEAIx7sxMtymJeUA1EFSSLDojkKe19/Q1sQuxDuiTo3JS6jrW2OYiAmJSEMSE4iid19KAeOoyhqii7DqOXFRBIik1Vz2kJkCkN3cAoe+eLZL5vhQF136JmDLl5n+jXydpk0NHlCLt4FwQDyRXg8H3zKXvkMLrFFPmIBZfkI9kRmyqZlJaGXpYfVo5Y8vV/uPQ9Gr6jdgQdUqt6qbrFRtoWiawt/QWzWl09hqqS9PEhHEdzMQQBx08auDxnM7lyJ35D4sWeYgA6tVBDI8/WyZ4w9VzDwVBVonZCHWFuqrqOH5S+PGiDweNoCDFnLIwWhsWga3IA/duLyf/FyTc0pGOpTllbBF5rWhb0WtccLzfOWB/ynvcbyvG+mENme+KKx082Y4Xf8TNmZAzg0n0XsH1/IWgClkaZCy9ajytO936Jo5XkCi/vnjOLgg8DEZvqSF4daztoFnOA92RGr9HQZegpFEnb0k0g3YFuGcGW3Qli5cHxzC2uYYKzedB9n9o5F1fN0CY7d45CIuYIb6aOnqzi3Dd60sQDebV6Kt2HU7jx9OiSqx6/gq1ZJH1P9Gcz5YCfrlIbHqcP7zQLQoG5sGr12/Gl5JFUl43t1aGHsAVFRq10R9BnSTxaaxvKUReyRcGwKfgzgxewkkdFbjUXhVpTMxgG6bt9PPfK0pBjuWJ0rOmK+ZtONAUpnTTesRhnk0bnlEBfLr7mlwisGboHWEZiqauKDe7SqAsnh+hnhuMwN2z7AmmKiFw8DsNmxZ8WfG5DEZH1cQCoNbX0nFWOahdx1Ya3xA0RWqda8WYYzHB2scYb3vCyCSozrZH70kxdcxNFz0g4DrZQc6lZHGBrMZC8w5t1bS0BrBkWIvkRBECtcGM4RsYLL2WkQ05mTF5+S4eKpcMUL5Dr28n+uJD0re2mUMUxjt8NrbEJGpsQBIF8h5UsuYtU0U2H7mC/d3B1rkQjNXeAmDrkaEbdGRbsM9pYlH2U1YfM7tSZad3YTtCCPdqWgq4Fj0AHGzNpKEoBBjcQt/m91AXyI75e701h1TvT+EfeIhZNOkCZsyX+DzME5G6RQKpBz2Q/vVcvwPXy5lGt0YiEtU3F2nZCyqFh43FPaETdUSNTvKJ+FBLrxjiVGTMyjvFwZz5Nfy6h4rH+nNzOc5PiNjIA0pVerr1oFZ+8Nx9R0yM20JJ8Okk1x1RPbBZUp4A+yDei76tGmlExbCNDs4v4kvsX9ZrVQAwIQ+66G3J8Gyh7Hex25JCiBKcnFNvakAS9r4hubWsJGcttuOrivNfHum73FIoj3r18NPBtTWPiE028PWEi5+TvjVho5zmQTEaNQW++gvNo+NQRb4b5IEl+Aa/HAnP6PbdGiYfuEmh3y0zaXYqWmYQhCshNXRElLk9EdDgwSuJv/jRcjhehS8nJyI6SoNek1h60fcEa89IHmyj+YHSuLR7mptegf/kIz+2ZhTxQxkww8GZasLYFonrsRc1Ab7cgGMETviSIXODw0aC20R3Gc32cLLmLc+zd/OIPKRiCHlJcfhzVZUF1ma9ZO7tomyyhWwxkT+hAZUgCAYeAdlon5xdVkSx7ea1rZtjjpshuCuVt5r9FW5/csWbo/K6jjKL/UtF2rkcoK8HabuBLE0iqUxH9n97iUdHhwCjIDjGOB8MQBLzjs8lYvh89xuLy1T3lMe23vzcLTQE9LRnVMaDY2avFHTESDAPJo2LoBmptHbKmoVty0OzxLTM6x1u44bIP+X7WLg4Ferix42Z6vFamZxwNiSy95ZtEt9uKpgbPh9X+THYqzSiCToUSer+PP2cv1c3EHYhsjLe0JFH+X6YnfsNT0ymbODpGhqVdAEPCKPbTeKVK0r7xiLWN6D29IyKDLeggD6FYHSBjp4+ME8pHfGkygqGB9eQ47EYM3TD/G83zfcr5tzQy3LofWQ9elb502SJSqtZEeMfQsG2pxijIJpBuTvYRi1YFSNvnp7PEgjczBm++YSAYRnyN1U7YtXWSgme2u2+zUeLBV2fH1jLM0LlwrKdHpbmoVd1W3tsfrNT0wLxnyJB6eLNrBrohoP4sB1c4L41AFK1U0GwirVP+tR5hbe9+0i+Tca+1RDRwrz/nYzgHDvZm0vB908snDFS9EKDhMv+gWveyQ2Xf/6bw0dLfkye7qPjwZso+J5vpDtEQJQLzJ1Jzu4owMC/i2GJZM3QkITFWX8DQcOuhE5XW1QVrtgVvG+xgkX4vkbqqihL6KAcMJUWn6XIv+U9akHvDfyLBMLC1Bih7PvJxbkkeXCbXZxCXwp1v9gRUh4ExzkPTgBR24Zgx7HJ6uahoV0zH6lQd/Lp1IQC3pa8mT7ITMDQaNT/LZ2RiqKawgnqwmuzHmqi9c2biut8apgSrEC0XQZbiTiEVBANBCb+oMgJ+tJnlMaX6RcI3rQjbPmvYQu2hEDAktr4zEakQegqDC87TqgQsnfHJrot+Peg3qdY3IHV1o8+vHHyuEkwj1RDg6ft+znjFlKAtVVysmv4sP2qZGjZ9+fzC3XzUOIGGtmSMAcb6H7aewR84g7SUXtbNejbkfe26h+UzMrGq1USOp0HagH/rukjAkMKmRUqCPiz1pRAEczgVBAPDENj/HSup71aStboFbfe+xJ3nGLIH0ncN33g57uyrO1/npvlrqHZn0HJa/zNv6EbEzvNj/Gvyr7VCi5HPzVyMLARPBrr3QIS9h4e+dTeSICC6XPjnhSrdGCI0z7LGNaEZG3diLSvBW5Ix+M6AJ0uhuzh40WcIIO9zoJUnTr3Dk6cjZJt5ydE+zrc3Xg1ARkovK6Y9yUXiAsJZEwevkUjdJoekBXWUW/CnfHrqPUaKMmcLeT816w7e/cdCMrcPbZI4/ZM7+MWc59h52qM8tLWM16akRd1/36Mz2XbOH7AKwR7Av3QW8cCWc5m86hY2L3kEhzh8L1bF8q9Qecd2YJgToCDQcM+isEbDuL/uQWsNLeavemg2V89NrOMhEVjqOoMiNo1qChC/h9UqKLz2p9+x7P5vDpp6d5xx7/hpnerAPb9/3FhSepA869DrX/7SvoBnnzmd4gfMRmSGGlzboLvd5D+wFn3xtISkiabt8+NssoQtlD7O3u85mZAXm3Tzca4r2sgXDoX2zmnUdL76hbvjvs5w+CZko6S5glKmhkJHwMH7L8xBihCt6CiXcDRETouLFb23F+nDrWinzYgqvV57loWNN/8KAJfY3+OiXXPz27a5UesjT8vZT5Uzm80144K256R3cVrOfn7QbDaAuDVtXV+DvqEw4fM7eOMbi7nsppUhr5Vamzkn7SDvkhjRBWVRG58p2oNHU3izyhQIaD/bS29eFuPescG6xHVWTxS6IjDtx1tRBI2FxzSmSxytZK7tN+Nee39ekILbGP/6/FsaGbrXhx5DLLj+q0Wsu6+IK8ZvG3TfgezvzaLjngKMtmNePcNA7+nBuqHfA+GbV07rZPPHN5RUH+3IUWw+P97KvIj7tFda0GUBQyZsYznJC0KV2c/AV+KDbB9um4KjNo6JXIDeCX4QQFD0mPLzjWNRpPZuBxfsvI7rHliOhM7P376EklcCGLJA9SUSostPxyyDzskygiqQdMB8n2YN/3kSgdQhU/zUEWquGzdi54jE1LOq2DdjEqJgMFuMzSNsl8x0qeIrD7I7v5TcNTp1Z4Moxr4oN3SRH+y5mM1FO7g7fQP1mxeyeWlSXxO/gfQuL+PZygf7Co0Hcl3SPvLntfPtDdfEfO5B0YRhpQeIMybRPDcVMOsrwn2nTVdWgg5JtQEsbw3oqSEZYRsijgY1F4KgyziOSOSs7//8tqoGtOaWhHn1XaKN++55jP947UZKXhtctUnQIW1fAKXXTtdZbpaVHiDT2jMsL65miFScd4DtmTOZ8I0IC5BEej8NEAZJQxBFg8aXiljuHscFdw2upjPdUcNZ9qOkiKGpOT6jN3pUNg4MQYgckQMwDA7ePp7V/63xmeLwEqib2sexb20x1ihToCGYdYKa1ULKgWBDw52r0LjY/DDjlhvIbg1Lmwf2HQ6q9+66cSHua03jMyWK/Om8zMN8L3VryJhyX9M0Ht+0gJtmr43wzn7CPX+iYJCm9PLZZFOCOFMaRltszIL2oieqWVG7hLO/0183d5prD/OsnQQSKHQiijqKoCFJOmeMN9cNGxrG4RPtaA4Fed40jA07yHr9AD2LSmirHPpSLmOnimvDYQyvF/+s8fFlSAxEELBLgZBIz8CI/PxFe9n50iQMoOCmmrBzzCnNWJ+MuPm3NDJixdi8k5RnFvL4+bENdABv1U5CfzWDzPUnKCoYhpniMQA1jn5lkheyN3kwVHMhYAT8aC2t2CwKvpKMoIHBEKGnwELAJUQ1YAQdpGN5mFKjBTVdRUhS8eQI2Btjt3wGNrmKB02VaGhL5mBmFt/O+oifpZ+PP0WhdbKElGF6SkVnAJygqSJq/chJIvoyDPQkDblVRq2pJXd1Js2z7KjDm5fiYmJSIxOTGof03ukpdXTMtHMkOQs5JX7vY1e3g1pvGmmSgx9mb2HCr75Cyg4Fpccc5QwRWmdrvDzxt0y3hP8e0iQHp9tb+fyUtXy/aQF3ZKykVBm657By5ecpXD70tCth7lTaJ7oGTUE83jHXkBXSzpiN9MGmIZ8zUcip5ndo1DmwHeqPUugtrSFG1z//ej77r9vMnwqHpuJylauLe9Njl4WVPDquOhXfJifplb0JUVubmnIUfbbA/vsW920rfN+N8PGWYR/7RDxZCu0TRYhY/m3iaNJJW1fPS5nLuPyGUO/1QJyib1hKWonE2LgT29MLeeKCedw4PVT1xx2wYG0ffMTWFVBtgpl+Ob/fGx1IMpDSzWhT02wHYkBG8llxTkom+UnTSGy/ZRFt53q5vmRwSd+rUzaEiADcfXQer26bgdIwNEWPRaUHOT21ipm2GvKGEb04EbXuKOkf6Lyaayos3fjFd5hmaSdNctGkJX7BLAoGOVZz3VCe0cym5DQMUUB1KUiYBf9J2xwIWjatk+NfzmXuCODc2Yja0BjdeE0QZc6WvuL55/5jGWWPNYTU0Y3xr8WYkTEISU+vQZcX8kbmZATB4PzCPRG9du83lONZmUnBnwaXnFM6fdhaYqzBAEQNLHXtQc3RDJ8PtboGOd0cRHWbgmaVMCQBd258A4a1TUCzi0jOAFqmgXOLFQzwpQkRF9qGCKpjeKa2YQi8snc65fZGXMkemmdZ0SaEkZcUDQIuA6VXiNm6Vx0g+vu7A0fdN02FgICrVgDDQFy5maTMBXSWSfhSTYlf1WGgiKduPulpOfvpyqhl1dEyunuGbh1Jgsihi//MmaWXUdtspk5Jssb+JX9HEqIbeiminfsy9zDp48+RZ+nkiqRtQzI07m+pJOdJG64PqyDNvIZ4OirLJUU0TUvCkx3778CXKtAy3UbOB4Pv26NZ2d2R2/d3kau9bzGQSGQvqIcOR90n74FPWGVdzE9vaOE7GYnP1w6H5NXJ2uwjcL2ENa6WjZGZnlLH9Kvr+v5+zrKU0p5J6FtDU5CGgzdd6KsZi8gRO/YWP+qhw4z7fQtPz5jDhRU7SZaDU7mKrK1I6GRJ3cCpI4Oa/MQaDGEhryZP5ZIYFvqR0BXoLrTgm+YO60hSJ/bfx+4ehZSqKajJVryXd8RkYITj8e4MXl0/C2e1jD8l/vmlMKudr+R8wBKbCCS+8FitbyD3Vw0A/H3JAvYUmuNAu8+Bs97AnR1dKXIwvJkGWbbQ6G2Fq4kthYV0FTvI2NLVNw2qB6txebx40kvjmved9QaODYdRG/vrt+QuH2qSNWpq20A8WUqfQqYuQ50nFUXUSFE8g4rmXH3ZSl5vXEYefGoMDYFRlrAdvVONGGNGRgxkfFSLry4bXRZo/FFyX4qKjkBgQJK3/vdsCp6MTdPa2LCDnJYiaq4uDH5BCJ8+FXBCzdX5FD7Yit7T058uYRgYG82wuFwxHr0gBUMcmvdX0AV0TcDolUn9h+kV9Vw+n46ycEoy5iJeH+9JyA/hgS3ncvPUNZw5fRdf2ngzaiB4lBZFA328B2OHI2YFLF+hH7lVwdIuRFRK6bvXqkDOJyIpj/V/f44X1+L50iJ6ZviwOfxcMyF659+TRY/W7wUUBYOl+QdZvn9SX1raiei6gKEHf2uiHDl3QhAMFCV+4+rBbadRU5nOj3LMdJNwKVYD8RkB2jRzYlr+X6ejdGv4Zh0vbDeQV3aHL0oXQ2f02ssL0aJVdEZBsFrNaIFfpEu1BS0sPZqChsjOjjzq3+7PAa+dn8K5JXuR0PvGh+GiqSJijIcqvP8TXttzFjf8ejNFcXpuW7RejIDISW1uEIarL13FE0XzmXh3MgD6KHhaj1P+lya0KrNOT+/tpezGLax7YwLTMsyGi6KgM87Wzs3Jh4/VJoU3MAKGxlH15EyzKY+vIbVqGo2/Tw7a3uuPfeEdSAbP3NjGeNkV4MC3FD5TuW1Iqoxg1mD86Mk7cB6LsAuGOb4NdjzdEPqK+Z+d+MSoRZXGXb2DfjXsblJpRP3KIvzJ0bMIorFs2Q4KbB1hX7t20iZWpFYgPt+MNiBlUq1vIP2JNnxfm9s/7oVZDAs6CJp5X9OeWI82cDw9tpYQF81Ac8hBqaXh5k/dItKwGKSsflmqtdUlAJTnNTEt9eigUc7P3LaSFzKWMe6Hnw4jY4z4GTMyYkA9UovS0Yl/XgXV3+tXSlK6fBgb+r01ycRX0GR0dJK9KStomy9dpmN8eDeIIUDtV6dR9Extn5TnQLSqA1ikchouzQrz7sGx14u41ltJebz/c9hfWkc4n3jPtQtj6oQcL0tsIusX/ZnZK78SpBYyFJxVFtyFGu5kA+eh0Eddt0BgkumJm/gzP/qW0DqIjEdW46qfx9Ifn5oGBsBbL88P7tYugD49vOcRIGmtnYydwZN2zfl2GB9+//yMTj6Y+hIMoSPG63un8kbVFATRYNfSv0VVnbpq36V4fmhq1itG8ORkCALqsukoG/ahd3cHv7ZwKrpVCtp3qJ5E1Q51X59D4e+3UPHVdXx82yIuvKM/J//l9+djaw79DMK6FN5dNx/NBlddET21JlZK/y4gr4i9EZfjhbXc/vGVvLH57bjOc+5P76UsAcoyI8GNM9ehf2g+ySt/aMHScXJqZABSLtrP8VFXKi/jTx+uZrDoxf0t0/jom4tOWm61sX47NQuCt2VV6tRcPnLnfH3vVBaVHqQoSh1GOKoCvVz54L0M7OupdAm889x8LrpmddT6qLqeFCy77ASmJE7IZKhk/mk1vVctoGPCyEjTnZ1Xhed9hZ2LrUGpk0bAT+6vPmHf7xYg9YphU+LSd6vYXjN7I0V7JLuKLXiy+t+ftcUf0vPr8I0akhzeC7KvPpvmXhfnFyY2CnnSMYzEqdzFer5POWNGRqzoYUz5IT4A4oxJaE4LgRhDkkGnFKDukkKyN6WPSL7yyeTJfXPY0Z3Po8XLI+7jqfSi1FhRemK7d/Z6CcOUHMdTccJCSjAQgcr7OtCOhO/OVvedxVR8ZnRSUOKlLeBkxfJZKCemlhtg2eXAU+ZHtpkTs64J5L9oAQNkT+jEkL9SY9fGaUwtm8GOu/8IwBOVj/N/aWeyrW14/TAMQ8DQBOZtvAGA9sZkknYrFLzdr+jUOz4ZzSJgMyIvJAxBQJs+HuVwM2ptHYhSn4FxYrFi+q4AnaUKgaQhXG9w2wrA9JQ+9+YSrN3RnzvJB8++upSzL9hMujLMHO0hDC9aUzMXnnc9AN5feXh/yssjcp7R5Hh6avKWRjpn5dA9LnTxZm/WcdYPHvapX2LFU+YbtYnvnoyNVP6xnj/fcWXC7nMgzW4W/q4/9RSGjqMP1Y0fwfv+yusLmXL6fiYnNwS99uT7S5B7BERVAAkurNiJQzj5aWtJy3fgmFnO0aWxFV56s3QWLzGdXLEotUUTWpj042qO3DSenmn9892k/2nG6O7B8HgjxisFWabpy/PQLEJIc9u2yebcYW03sHVqHLnIQI5gYMTLgs9s54OSuZR98V+nM/gY/YwZGTFi+HzY9taHbIs3iUSaVE4g2YauDL2gVXWYnufAVQv7tk18oAa1LsY2xqcofp9Cqzd6mFtSdPzZKroix1S8KGjH8hoFkBrMNIG03eBoPraYNSTU6iMR1WsCyUbIxHaqENCliMaWGCAk+yWaF1h2a8huDcknMf6Z29l69a/Jk12kKW5aex18+cgS/jwueifywejusaM32LB1iDgadfQdpgynVDEeW7Mvph4CmlVCzEtHSnaCIOCL8B7Jp+Nq0PAExL7C7qHS7Hfx9papOLtiqAcyQOkReHPjdGZMOszUlPC/ybWtJXT9rZD8VpXDlwrIyaalqPklip4xxwbb3rr4qx0Mo+++ar+fz4yyO/pe6i3Uw6Zw5DWcunVGA2lZmoffJYRNg/NmiKh2cyGUcihyQbdmM5CtkT+vYQgUPKlAQ3MiLpkU0c6lzka+93kDDIHUNRbSqoYnC2uIAppNHkJc8RiNzeR/5OToadHH2kCygT9DG9IiYXdrNn5dosI1eL+Wdd5S/BwmNcoHUnoEtmwtY7OtJGi7vUXsq7nTbITUzMSCnJeLkRacUkZtQ4hQSzhqv7sYb1bwQFv54yq01jbkPTXkCUXUL4luaPSWqJRMaIw78hMJtaGRgnfT8ezuT5vU6hoidgyXplTSU56CIQr4k8OPldqxDDtfqoDqkJDbwXAlRk+rwNZBaubg3dnH+HQyZmTEiKGqw1vEixJydia+3KShS8QNQJ3g4YbJG/v+fn3/MpxN4/A7P/2tryVBYOa4WrbX54fUZgDISQFUQFRllEE8y30YYG0XSD6sk/ZxLeg6vgqzYE87fUb/sXsCfR5C/wXzCBREXhAEDIlDvcG9SmxSIObJokez8vreqVw+ceuQpFLtkp/eEhVHjRySM9tbrCIeW0ypPglLnYXB1HQAlG6N4tc0vFdprPVI7O3JweuxsPJwGVrhymE12VM7LdjbRBwNBq66/mtRs5LQrLGnFgSSLJA0eF65pUNFtSnDMjIsXQarjpThPBCfd9R5SGabowCKCTE03m8op31VLuP+aaZCpRcuwpdmLkQkH1jfMLcPNzHI/nJwqqN++ix06dM1PjT6ktneasp0dxcJEWtUVDuodgHBAG+XjLVTQ1D7ldE6y8znRXUaERfnoqST7PQScKbTdd6kkNeT3tzRJ7kp9LhZtPUq3pn2eNhao0OBHrzHLLoAIp+buRbNEHk8sBB/Sr+VFC4NJSZEkHKy0Zqa446oax2diBt2k1I4i+4iCT3MKiDgMvCnaX3Gb7x0dTtotvliMjJqfBl0RulOfxxTWj2xKUhSZgZabgaBtODv0KpqpnrTCYaGNKWSrkmpfX8Xn1fN7LQjQfss37kUW6eOo86Lsu0g1slmnwt3roA/VUe3Bw/WBaUtLMlKbE2CvnU31gEZvpGeEGlCKZ2TU+ksi+2+ajbQbALWNuhNsiAmBRClUzwUmkAEY5QLv/8Fbu2YkTEaiBJSSjLeyYWD7ztEPnObmQf+UeME3O9F7p3xacAqKDxTtoI57dfSFQjvBZKTAgSsOtI+c8IWNSKOpIJGX81C2se1GF4fnWeOD1tTYtS5qKg2a1oC97RyY274VKmAIdHic4U0gLI7fBSVRDcymv0uugM2antSKXpEousnNrIs8XtykmUvNy1azQtHlyEMXAsIcPXC9XzSVEq310p3VxKF78W+WBAM2ORL5Qf7L6GpzfTwGYZAveYmT3JENTQ0Q+eA6sEwzBStvroaA5yHZSQPZG7pDqplGkk0i4DqNJB7h2ZoJB1207UuZUjvdey0sdU/jqlzg42Mjo9yGXd/f61F5sMJTBMQBOSC/LAv+UaxcDpR7O3IpufDbCC2iiBDgM4yibQqULpNM82fKtN1hifqMQRRx+Xwmjnk3w2/z/raWci1rRgeD2p9A8kXwuFqgykn2Ltu3c8bvZOo96eGHOOmeWtgXv/f79QvxdEYiNvQ0CUR35RxKG0dET3U0TACflzPrsV36yLc+QKaLfj8/rxAX6rlaLC5s4j1h4ujdt9OFD26lw89eRi6gVpeiGYPXQb5ClOxWBSEvd6++ytlZVF9eQZXXhO95uqCu1bR6Evmgw+nU74TUveb7+8utZA9qZmz86oS/6GGSPOy3LgU+AbiPCzTO8EwZebHGCMCY0bGKCAX5OEtzznZl/Evh2TR+gr9pH0O5Ag1f0m1OklPmcXsux6eh+wKAOHD6kKBh32/MWsQzs2I7H1xyQABAABJREFU3FV3X3cW22uHVquw6sVZ5K71jbjg5XOT/0Ge7OL+lkpWPLM09jca8NPbPk/9ZQpSlnmfdE3kzFVf4/Ulf6BCiZxmsd0f4LMP3Ys63YNyyBayuC98+oCpyT5KNC9S+es5f+FrD98+auc8mUipqcx6LXyn6pX3FSC7Px2pUcOlvUIi6YiAZhFoP88z6P4FGZ2DepPnPbQZgCc+Xkz5nZH7Jv28dWbUDtUDOfebq3j178vI3HpyCu8z/rIa8fVy1s16Nmj7+bsv5mBj5qhdR5mzBed4P6u3zhh852Hy/cbF7JijwyDJzv5sJ1LyJIRPzJDA/t/lce3E2EQdPnlpBkVrffjmlvdtG/eOnyNCNpxCRsYYcTLWjC9uxoyMUwxru0rmDp2WqZGXoJlnH2VORviFxKLsQ9Rd1s6WlyfHfe68NR6kNbs+lc91YLyHcM7A/BcsON/Ygpiawu5flCM5Yve6rDhYwaTcxoh59eHweiw8v28mV0zYGlSc1xZwsuNH0wHI9g4vJ/tEzrp0Y8i24+lXkz7+HFmP2VHirh4KzxUbbuPrk9/ntjD35N6GWbz2yiIkwLrTTlqVhtJtnlfQDKyr96C6R1/9ZZlNZfmdP+v7++odt/R5x0eblfctoui9LSMiFqueNYesHx2I+HrFf+1ENwTeXzuV0pdPfe/jk9vnYt1jH3LtgavGi7R+N1nvZlL1s8iKe3OKayh2tEV8/UQuXbiRpo/N3i23/uc3OP3ba/hpzhbaNTcPts+K2cA4zpIbN7F8wgxKn48/cqAtnIKypxatOTE1JJ9mBBWeq5rJphsmIj7Yw2sVb4bsU/rKbUy67wAIbehLZmDEUhspCAgr8rksNfZC+zOv3IjnstA5fIp8iqi4CQJNdy4adrNZx0EFb46EmJ14pckxhsZHH33Ez3/+czZu3Eh9fT0vvvgil19++Um7njEj41TDMBtdpe7X6CyVgqU4BUg6vZHp6XURtfgVQSNVGdxzdyIFH/Yg7T2C5jv5g6DPCHDN/kvo9cQePBfF8KaRqBqIE0o4dE0GsiO+Ba6uiRxoy6BXtbAgozqm9wS6LKSslXk9eWlQJx1Bg4zukbm3qUrkzxXwy30L/XiZPXs/Nknt0z4Hszj/r9WLeM3RS5fPhvfv/Q3pbG0aJXVtdJeb6UWW7v68eMEwoLwYERDqmkdlUXTktgA/nf0ykiBSOKB3xAMTn2Ft0QS6NRvPPnlGkLdI8kHBm01o3sR9Vzs68+n4WREAzrUH0EbA0Gr7wiI8l3SxyNEacZ/jzQINS2JMHEGH9/8xn4LLQ/PSE4EekGJqpBmJtsl2hMrZ9BYKQOR7vrs5hwNyJk6Ln6XZkY2047gkHy6n+XzsuCaX599dxCsl0/j21Hdw6/E3f0tXepk9/QAbbSWUPR5n2pQiQgSVQnH6RDqmpAZtS9vSirb71FTLGy6CAZoqEfi9l7p3Sln459DoZeWubrQW8zei7DmCWjkuYj1Y61QrvmV+vF+ezdWpm+Kqm0tV3KSeJJGrw89MoyzrhHHgGl/f5z6OZg3fkyseBJ2w7XXyMjqpTB28HmeMxNPb28uMGTP4whe+wFVXXXWyL2fMyEgUwqwp6BGUbtzJCt70/tdsbWr0HFzDjGjYXWLfIKA6BDrn+fhM7oFBG9xYxQC9E3049lkHbVwnGJC+S0XaVR2TmsZIUpjVzoU5O9EMgz1Hc4bdJ2NBSTXrF07CUZyBWjG0hZ3XY6GBJHbI+UERjTSLh+z0rr6aheMIAZHk6sRGKuJFEnTmOA7hECXOLt/DB2fPpHBF/Nc0L/Uwbt3CWkqCtre0J9F4MJP0TSIZj59QT2CzYc2cEnIsQxDwp5tuM1t79KZ8ieDQ5TI/mf0c17pC5SCX2ESW2A7SqXt4ljP6tlu6DFL3+dH27k/YddirLezfN56C180ajJFKVuouEbi6bFtM+6bmd9GwIJ3ctcM3pDK3+9iXV8zu9GOpg6LBTXMjpxKNJr40U4nKl6VFLRd2u624gV6LhW3WAqan1EXZO5hLS3bw6vvL8PpdHCofWn8igIlJjbjLLPgIrqfzp8o0z5Ao+DD8d2Vt6MZwn+BUmj8NQxLpLLbTXRS8ihTVdFIoDzI0vO9lcX3qWTxV+t6Qr/9E0lJ6yXF0D77jADyaQuaOAK2TlLj73OgW8KfqCMCTFU+xqPFOlF1WHC8GP4sDZ12tpRXKw9dJtkyz0jPPww3lW+K7kFGg2p3B+vcmUaqtD9ouKBaO3DuXp+b9ipnWYAddxbe+yoTH2tB27k349egOnXGZHUHbSpNb+5wag/Fq9VT4IC3h1zUSCIZhOsxG8XzxcuGFF3LhhReOwNUMjTEjIwFIOdnUL0khEGOTUVGVUNw66KbUZiSSjvQvDD1ZCjlFDUgxJFrYpQA3zVrHU21LEH0Ckl9AChPcEDSwdhjYXl8f1D00FpQeDa3NipSeOI/v2Tl7+Wb6QXp0Ha3RDpm+iBGKSEiyRrLTDN3eX/gaPzwnwAcHygd5V3S8Hgt7GrODjIw8WydJWV7edVfS29T/xSs98buGdrTlMSfzyJDkFyPxGUcPkmDnT4Wruf+SNlasiKMmA+jNU9AMEYfoJ8nlobunP66udiuk7pLI+EtwozhBlhGcg+vCG4rc31UbEL0BDFmIS/lIs4v05EUYvgT46PKfB0UvwiEh4MnWsTWbxrzoB/uBFigtBkBvbAZPAEuXEVHacTAyt6vYX143pPeOFJ8p3slaVwn62sSkjBW93T9O6RaR9aXFTE+rG5JiWqKRfGCvk3A7JSSrFlVyM+CX2XM0hzx7JxlKb9ReBMc52JtpNr9M8EzqyVLQFegeJ3LeZ9az86PpYfOz9X3V/YXfooSUlUHtsqSI19NZJqHaM8lo6eiLJuY98An7ehbx0Xf6jYwWtwNdE4asHFSR1kxJlKjaidR7U9h0tJCiJi++ZTJyr4AYo19El8GfbCDk9Y+f+874GxO4hfEvRn+v5AlgyGKIpLxnYS83TNoU8/UPxsHeTPQIT1+mpTdqNPpEDnRmUPZ/29AHdOsWk5IIzC1n252/RxJCMwCqbn6QBbu+SurO+K99MKSkQEwRwEj07k+h4p1W1Enl8C/Wuy9RdJ3gALZarVitoyGTMHzGjIxhItpsHLl5AvE43U25OAmlB9J3x7ZItzcHCPw4l56fNsW8GL3+bLOvweuHpxBYnR4ic2prM0h/dGjKNtY31jNx/3j2/c8Qup2FQRgwoTdqKhO+sZZ9v5mPkeEHwYi4ODAMAVHs/2AF6Z2smPwKAJoRWyOkoeKSfFxeto2Vf12E3HvcRx2/r9r2szQ+uNvKpSWJUVwSw3a0IvYiMgHmf2Mjbt3CmUm7WDp1LzevvrXv5XFvCNhfDu1ELeVk460cXNnMV5SOkuSAzeaMZ2zciTKlEn+2M2Z55+bpCjvv+mOUPaIbGAAu0caB6x9iwuNfRXfoBKb46Dy736NW8sc0xI+3kteYzeGbI7RDj4JgEPKbO5U47iVLhKT2cUS/jvrjHHb+lz4iKVRDQdDBuceKe7IXUQn+Qk785IYh8N7+Ss6asDeq4pt+bMDfsnwSohW0nMREL49Hro1bmjnnWIFwRwSFvRO9nFJ6KjW3TBj0HL15At6bysn9dTMc++6zNnRxx5/uCNpPyNIhP37Hh2EIqIbYV5syWORdNwTe2zyZSb9s4Y0PXwCg7J0v4tgVW8TTm6eFdXaJggGiFLEHEoC+ZRdK5QT8+ckR9xkuuiGw5c1JkeWX53RzZfnWmIxa3RBwKAEC8yuRPtza99l6z5rERw8+TDQNNkPE/L5PsS7S15/zMZwDvp4AK5ac7KsZhAjpYSN6PmDcuGAVy+9///v8z//8zyheyNAZMzKGgVxaTM1VBXEZGAMJuKB5lpWszSNbB3Fh0S4+sZdhu6g2aLuhnzqDzV8X/JWFVvhK7RJqzhTB6KXiW5tBFPAvm8qRL4ZOFFqLlcr/t50/7XmbHOmYlC0ix7XUl267htaOwRebw2XW/2zio0fmkbb35KZJAWQq3dyVerBPZvYDj8gBdxYHPwtl/4z/eB/1TOSFgzOY8MVdfduMQOI91NquKqwdeTEZKYlm2w2/4baa84JqTwAOfkXAuG0Whk/COYQMqsK32tG3n5pKMp1eG2kfmGpJzJuK6oq/liAanp/k8/j1edw069SJ4hQ9IyEGghdh1Z/VkeT4Vg3vHq2ke+UxWd0ELjhmpx2h56dmHrvjmBt/RX0Ftt+kIxrBJxIDOuKqLRiGgTh1IoFMB35b/D0kmm9fiOoQwubm21pE1F4HWnl8qaYVX6+hs8fNNmzo08uZ9/CWqPu/89slpFvg8fceA0yDanJxPbs6i3DURf9MvZV+pAhSu9tPe4Q/bKvkranRDQit6gDSCT/TwHXzwu8cJ/XeFNa8PD3qcyJtTuKphkXceFqo4+ZEnly/gJLnDUTBQDttBpZN+2NOc37nx79k5ul3UfHFDbFe/hinCEeOHCE5uf85/rREMWDMyBgyxqIZNEx3xJ07GnIcCdomW0ndH0D0DzJjGfDJg3NJuaGORZmHYj6HKBgokoahJm5x2HXDQvw3tnFa1n5WHho/5PoJQTB4ZMHfmWVRqXj/K0z4rQq9porH8TQA27p9lNeHWXz6u9C8PmyCgFUIrbJTNWnYdR3H0TWRV6uncs64vSFF9x8+Op+UmuGp9TieTeHxZYu4aeHweyYM7GOx1j2etUeLkawah66wUviuEbUQ3Jshw63NuI41FtEMkctKt9P4UTI1i7xRvYLDwjDQGpuw+gP4phVF3fXgtRK/OOuxhJ3aIVpQxNDPZaaKGBiSQW+5gXO/JeZoUNGLjRg1dSN3vxLBMY+muPMgVunYQCZJ+GaVDfvQYsAgb7nC041Lue6CVcM+XiIQNPqECPqI08/y9K45iAftKCPgzexSbXxY2x+JKE1rMyO1J8wLSqcXsboefe5UAFSbjCGGNxQioSumWEDAFeV9BkheYL8ddYIn5u7O+/6jgvK/m/n/4o4DrPvq7Kj7t9wa4AdLXyJN6o/Y/LL0OR5wnMPb20LruwYi2dS+67JYA/x19t9IE83UTqugkC73AINEKUbIs7+qaTx1m/KwDvKsCDrYmiSefH8JN5z5cdh9XvvLMmSPQX6XgRgw5xpDFNAmlyAfaYnpelJEO6KS2PFIXNTO6bmnRsRyNDhZNRnJyclBRsaniTEjYygsnE5HpQNf6vAXsIYAAWfsKg8ph/x0++K3YvMcnWz87mLG/XJjXy78cPBkilw8zkygLMtpwTAEmnpc9PTGXtRrs/u5umwLS6w6lR98hXFPyrBuc8h+WlcX7IzgrRET2wE2EoYh4HZbWf7cQsQAaHaz0BADxu0fYtfeAaRvacfWnswzbUu59qL4F2VPfLgE5xERT47BPTc9CMBGn5/t3QX4vAoCIGX4aJ7hQPLLWDoM0qpMI65pthVDBtVh4MtVuemEBoQpspvpjhr+wuCpGMPBUFW01jZsh4LTQwyLgq+gvyGeK6eHq1yjJ1IgCAayQ8WTK2NtESOmPQCIKmRv9KIfOjKkJmmJ4vl9MwkEovw2jtpIw/yej3exBkCUEAwjISlU9uYAGdsVnnAt5salg3tpT6S4sIXDgSycB0dOpse1zUZ3RQA5aXAnwfP7ZiLU2FG6R6apoW6IuN39Y3uNmEpnl4MTS/10i4yYkWZ2vh8ihkhMTdgEHeReAbXehpbljy3qU+hBc5rXprvdCKu3Rtz18P8u4vYF7/L55OCFcoXiZJKznvcclYOf7xiiaDDfOvxn5dD9i7hk7gYm2Y+y2xO+sWUsdPssWNtje1bEANgbRF5+bFnfNs0G/jTzfo/bF94JqToUZIuCq6qdsmdv5+A1D0U8x/R1N5D95rHnyzDI2eChZZo95lrScGiaSE1vGq0+Z1xS72P8+zBmZAyB1ilOvJmJnWgCThFBMwZdrHZMsJBqjd9ISFU8qDN7ECQp4X0w5qabPTu2yQUc0tPxeqJPfhmpPTgtfvIcXXw/axe1qpuSPwtIH6yP+r5I3FNzMT8Z9ypFgxT6JoLiR/Zh9PYi5OfgK0pPyDGVbj8cqce6cy8T9pXx3ISZzB93mDxb16D5zAAvHpjOhGe8CB9vQZg3DW4yt6/3lNLoCa6ZUSe6UQFPow1Ljzkh9071IVk08jI6OS0nNC+oU3Xwia8c7bTpCFr/0yNoel+jKgDDH0Dp9g+6+JG8KmKvN3z1iq6hHjrcv29ONlpOCr35/YuHFHv0jupDYbyjmZ0pubR3Rp5xxWwvAZ8dR4OAtc0AAdw5ArYWo09qVfIbSB9sGvVeM456g3ePVnJWXhVbOgphRxK2KOn0li4DuaQItXpAvx1RQkpLQU1gjYazPkDBChni0x0AYGn2ARyKn6quYmwtI7Owz9rsw52vQBQjQzeEvntqGcV2AN09dmi2onSZtSGqy2J6r+0yWmHq6F0IYGsS6U0TIcbUst4iByl1+ah10ReeV17yMUude/nYa9ZuDDQS8pV2ctK7aGwb3INrtQUYnx5aaJ4rd+K76DKsyzfFHFV85PoHOc0GW3y+YRkZ8SJokLE7gP39nehuN3JuDt7J4dWvTkTbvY+J329Cu1oPimQPxLczlfROFd9n+lPBrO06GCKBIUydqgN8nXaqfQpWW4AMay95tlA1vzFGl56eHvbv75/HDx06xJYtW0hPT6eoKHqWwEgwZmTEiaBYQqsFE0BnmUTyYQF7U+hkZ4jH9NAFWHLbhiGpEO3uzKXkum0jWrM0PaWODGsvH1eX9m0ThOCiboD/qniN8+ym9zRgwF/a5yO5h5hupGu0LmnnNxtP44G8YDUQi6wiiDqGPkwx8GNox/O5y4rwZQ/D/XMim3ejHUtl0/YfovQLDj5+qIIzyveRaY1cfHqckq93DDqZn4iY46X1IvPfscSCXJKPhb8ONgKr3Rm0nuvs84Rrzc2I3d0ICydjRNDuF3QD5Ugr6pHasK8H7atYaD+rjJZLvAzs0P6lgtibYsXKfZl7qLDV858broi+4zgP9u02Uh5bgyDLeO+eT/bLVSEa9KNN1kOrCRycS/MPk6hZXjLod+pPFqi5ppDC3zWhe817K6Uk45tROsg7h0aXahvSuDU77QhlZ7TywXNzhnX+SAX4uiJgCNGHdLduiemeDgfdEAiECWdLPgG278Pw+RAXzUCzR5myjwkNDLf3QSJovNKHJ72YzIcjj0uizcaTq6fzbKqZTmV3+Fgz9+84RNNJca2rk5mT/smla81+F7omhqS/SrJpOEzNqQ8rwXuBw8fZf36Iyxdcinq0Ia70RVEwUAQt7uaKQ0V1wgd//jMXXPY5hM2xySwJuhGU7lWvuZGAdMkakkK89wsPwheC33/aHbdha9NonqnEJVJhiKBO8CAfm9t9XoWVh8Zz5vgqpAHzvYgRl3LWKc+noOP3hg0bOPPMM/v+/uY3vwnAzTffzN/+9rcEXVjsjBkZ8SAIHL17bsLlCgejfqmVKy4zU2hiUaA4mRTYOrh2Yn/K09UpG0I0u//RlcmPWvrVerQRmhU/nv4CXz6yZNgStgCqW6biyxvRDAMxJyMBVxceaXwJVf+bgojBRwcnhBho4dB/JlD2+8ygqMJoUOJopWiVwNaLC/uMHN3rRfpgE/rps8JK0irr96IOTM+JwuH/nEugwj0SNn1CMFSVvF9+MmK9L+LFdqiN1S/OiHl/Q4Tau2dT9Hh13EZqPFg6VXZ+ZzoFP9pH0QhEoQZD0CB7U/jo7+EbdSTl5Hcr3tGVz+663JDtRpGHqj9NpfwLg8upSj6d7E0+M/3xFDA0oiE6HOz7cyWyMECm3W1l5sovs3bpg331GRWKkz1LTcWKM3ZcTl1LatBxXlnwEBVKdIePIki8tPYVzv3S7VjfjD1aPt1iY1z6Bh5oXRDzexLB6y/9nTk//RoFzwwuC2vZtB/1WOG31tHJrSWnA1Dz9GR2Lxlc6eP9PzzE95pm88yGeTj3x5ZqplsgMCl0XFYDEocXBzC0/hFRys5i9lv/QkbGp4AzzjgD4xRSEBszMmJELh7H7m/l4zjKqFqyB28UWDZlx0kzLqSK8agZwbFUeXd1zO9/q2cqH5wQpehUHX2GhU+X2XFLJcLeqrhua9PXFvONrz3T9/clzhqOK5OMGAn84Vpa3Yht3ey6Lw/hijl9z5QhG8j0T7yxFK4LwL7PW8kev4i0Pf2Rj88mH2CPJ4/qxpEzikTB4JoVGxBPiJFlyHuC/u7QnDw+b0pc3a4H8zAnknsbZvFWzcRROlvi0U+fRdM0e9xjU4J0EWI4EbR8MYcWPZsjl2Rz2WdXDvqW40XWGDDUTHvVaeAb56enXKToVQHZrR3bLlFzsYGkDE+w4Tgpab18IW01f21flJDjDUSQdIxF09EjdKYOwoCMnQE6y5Rh5dqPCmHmNMMQOGfLLTww+TnOsAePKY9NfAzfCW8pku3EgiJI/L/f/YNv/PNWin4QvT7oJ5dcx/cmpuJLFhEMMwVy3jc3JrSPUTQkQeQP9/yez83+MhPv2Y9vdhy1cLpG1iepPFTwILHIeN9w6Fx2NuYiOVR6Kw2ce6OnuvaWqCybuYdk2TTaV9aV9dURibJO1a/mMOlndf2Rau1UccEkCMNI6DogpvN9yhkzMmJh/jQOn5WEmOmGoyO3kPVkiBiCgqPRnPgOXiMxp/LgsL1/z1XNJP15J0nEqAIhSkiVpsKMmuZAO6GTuVRSgKte48kPlnDDGeHVMI7Trdno1sIXg2/rLKDhr6Wk7VgXVxj7yH2LOeOyTScUC47c96I32Ch5e+iDpewOINf2p9M0nVuEe4EVMZCGnJQYL4+c7CfgCp5wXaKN2c5qtmfnU9MUvX4kL6OT8SmxqZQcxyYGuDBpGzMtcsQ84OMEjF7+98+fYfx/dqPtj10ZbbS4JHUz421NdGoOHtl+qou1h6La5SEvKjuWFNE2qQR/qk7Jq4lZdIdD338YI+BnnCzxVlt/kYbrhqMsyTpIjSeNlTsr+rYrzcqQi6w9uTqGYphGu1UDq0bDIjuCao5lhmwgJ4V2KBUEg4n5jX3qarEiSzqFspUrUjbyStesuKKz2zoLONKRGnUfzS7HbEBKXh1nvYauhN47T7pIIDGtjUaMrm4HvYaFgSmSwKDNNQfjAoeP1Vd+yJP20yj9f1FU/PwBHPVerO398967L8+j7OxDzEwdPM0zESyxiWRkdqN19WCrasA3IacvBVXyaSiHzUaKmqf/HokOB/sfqeChgt9TqsR2r5rcSfh9CoJgINlU3OMiG7JyhpfKnJag9ciUrAbcqoVe1UJ1YwZShg+UsWXlGP2MPQ0x0FPswDd95EN+AReoTpGeAtMzcN6czVEbQsWKesRJ0tNrYtpXUCxImel48yIX2/nT7VjbVHJWKzyXPzPmRkID+bi5jKNr8yn5W/ySrePOrOGPBbF9nplJNezPyqS2OW3wnSNgbRexLO8/n9jjRnYoMfUWkN0B5KYu1No6c8PC6XSNB71sZJ4nsdPNmTsv4+3JL6AIEgVKO5UpTXT7rBGLmlOT3ZSnNMdVtJckeZlgbWSONTaFG0WQ2LvsH0y68Q5KXrKib9sz+JsisLMnj4+de1liS1xOyGk2OM1WR6fuYW1hCQD72zLxuEOV3HrzRFJnTcHYPALtc08CnaUilWcdYEZqLateXTji59N27iV9wK07kr+YZ6elIAgGzn3Rnyd3kYaQEl61S/fIfSkfhmSAS0W29DsH9NJQowJAb7Ihes0FnCHAHiGbvLLOEKnqwbAKCnOssM92FA2RZjWJlggret0QOOjOBOBwe1qQqlQisLaHlysP2C0EkoYoN94joYkGkmVwh4tQbSep9uR3fD+RH2TtpOdcKzv+X+R9AjnJ6JbgxXbexz7q5ycxMzX2cxWntLN5YhLOPYN/t6rTwKgMk0aqa6i1dVhSXBiyOd4J3kD/fHIMuSCf+kuL2XP6H5CEoRljAoRtagjmHDE982jIHFHmNB1Tjb7kEY2Yj/HpZczICIcoIRf092Xwu0YvwbW3WOPGJfHLPUai3puC5I59UhFTkvBOKohpX3tzgPxHrAR+ImEV4ptQjq7Np+Q+08AQlMgLC0MNDCtkeGfqEcZbmvh299X4vPEnXWh+KUSlR62uQfbmoJfnmwX5UZDr21EP90eQqm62IaeEX+wkAq3qANYLZToPecmUnCiCRqG1naR8L6+4p4W9lafl7Y9rQWUTA0ywNg5JRnb37X+k3PVVyn+ehdbcHPf7AVYfKqPJk8Tyia8P6f3RSBHtvDDhHQA+W30GWxvz0XUBv6//2fHOcnMwPZnSULXlMYZA8S824TttKk2zohsYqtPgq6e/y73p4XPV33Yr3F3/JeReAUedhNcnomYEkMM0azMAzWtOfzkbwHl0oOGisO7rxUzLNutU3OrghrRPlahXe8iTXVyfZHp6P/K2sloPrgdrCbjwaBZ0BDYejq70YhgCuipgeGQ4BSp/HHUSHk1Az9IRxchjstqrUPlsV0QjXFAsiDlZEd9vtQVQToHPeyKKpGMTA3j12OaRm3LX8uOil7m89lsovULESJRuAXW8l/3L/hHxWNrOvVHP1T23kE3/9SDROn7XqD1068HGUyBGUZTB5ghR0JFkDU0dnSL5k4VghM3yG9HzfdoZMzLCIE0o4fUPnu/7++dt43l427Io7zh12fvzKZQ8P/wGbyOJumRqRDUi2976YRelXuDwMXfewyxaeWfc7y14RcbxQqjRpzY0Ind04l8cvVnUyeY0G5TJG3mobRFXlW9JyDHPS9o+LD36fZ99kCsXnkvvaQm5nBHjsZIPoASqAr185uP4n50xYqP1+lm4cwZ3hLx+888ZHyUN5DxHgE1f/A3z/nAPgg5lL7oRdIODd4cupLRehbInj+f8hy6e0n/jpA7TQDBkAWZFvzZ9dRpLD32bA9f19ykwo2PBPWemrrkJ/95kjOLBHQ1Go5XMbQJpf1+DdsashPQuGS72BpFArw29LPL1T/zmHvTu7oivq0unMuOXm6jaHT66vHLen4Ma850qXFiwi9Nce3i7a1rM75lkcbD31geZ9Kc7zMaGYZh47r4+x8ZIcv6j/0H+R8GRivrLZaTM4ffNyrL0cGX5Vp7bM8gPZYx/O8aMjBNo/dIiHvnPXwOj37Zdm9vNxaVDTyM5GQiqwdr/nYf1rnoWZFTH9J73719C2Zs7wOFAnV0R0cAA8E/IQUlxoe2qGtZ1ZkpOVi/7AwBfPHhVWCWX4+iaQOU3akDT0d3uiKnQuteLsnI72uIpQUpKgmEgf7ITdANVNRcwotPJnl9NRnKNfIM2Q1W5edG1zH/9EN/P2kWe5ODezHX8snXusJW8bk9fTd4JC4DftRfj1kO9vTelbI6YR/2Psld5YU8hj0+MTQf+ZDJetvPxsj+w7JOvomsiKSvsZD+78xT0tf5rotnhrS/+jIIYFp4O0cKbX/0ZZz37bRoWOnEd1Sm/0/QC7/6/clJ2yqQeDMRVIC+oBllb/LRNtqANvf8dZS9+hZTCTkoWVbP3aE7E/ZRdDlNO1ABPFvjvWoSuQPruAJJ3eCLkWSsbMJw2jlwwtPTR3HVelA37EGRz6bD7/8qRk/1Ytzko+pMpu6pFMTCO3ruYWVfuwCH6+8bjE0mTRrZi/Yc5a3h/fzK/rZgSthZQWrMDeUo5/oxjz5sA33v4byyyelAEibmZG9HR+XnrnKjj6Q5PIQ1qN3emHuGtW38Wcb90UQZib2I7FOb+91fJrR25eqtIaK1tbL4gH+szOpOTG0b9/AlnrPA7bsaMjBPQrEKI5OpoYVHUUVOwCIdcWICWG//ko3RpBLTYwqQrfrqE9I8OYdhs6EXZIbmvJ6JLIoF0B8qUyr6Qsf9nuUy4+Rb2n/G3uK4z89jkdV/RqxzND/2c33jvBiY8piLoRsx9D4yAH2VnDZxQ+Kyd2FVdFJFdIzfIp71lJ/OTxr6Fr1pbx4r/Xsrrt01h3axnSRHs3JS6jhe7ZkYsxI8FpyAiCSL1ag/veYoBaFOdYbXk3+itwCn6yJB6uMARfD9coo15thoeJ7KRUfp8G0fPSsc9P7h+ZWnZAb6U/SHRUgMSiSSIZIj2Pjlh2WeYXejHiAlR01F21aKpQ3v+DYG4Gm0Wya5jvYVAl0BrN9OXclaKWHpUJE/8C3UxYJB8WKMnV4pYOG1pFxm/wmxE8OTSh/uifW7dz7QPvoKtXoJCmJDUjKVQZXtt+LRUQevv62GIoMYmoBQTgi8A0tBTWkS/jpicRPtSM9XL1iCitUkIOnScZ3bnTn5hU9hu94f/dxG5C49SZG9HEvS+8Xi0ebK7iIfvv4JUPXyE31BVxEN1WI8eWweIAv/5/S9z03ff5K60wyiCef9uSl0HwJ9alrGyYTwev0La3/uf06bZErde+TYQ3/MLUPrmlyh7PLYFZuNdi1n8+fASxzVqD+f97V7yatWwHcMTRUfAwdrG4lA1RMNAbWjEff88nvtiLldXbBmxaxjj1GTMyIgDAfClG1g6BGJoxPzpQ1UR1KENRE0r83nalRf2Nam0h5/NMtPPnq9YRlJ1LlK3j0BKbItd3SIRyHRgKSxArTuK5a0N5NvnM4Fb+vb57qzlzLSZ3YsljKiG4nyrAic0uTt716VkrZYRV8bfdVxraaXjc4voLRg4wAbnYpsOr/iKvdVOC4IaPspjWHTkAV2KU/e50fYdDNrH/vI6vKmLmNB5C7KssWfpP5nrOEivbt6bgCGz2W0aChW2ep5rnMuOHcWD1gTVqD1s92cO2g23xmcWAqbIbrKk3TEXiR9H37aHXNs06mxJfcILs4qOcEPmmoQWfceCJIicVbqPlbVljLTXMRL131xMmIARKQd1evJFAskGSlf8KTXeGW7OztxDsaWZxy5dRskrCTaGNWPI9Tf+NIOMGU1xv2/C9Fr2C4W4BogBJVd70WKRgY2ApUNFShcJRBBWlnxg32FaBP+Rcw3lKeZn9mgK9u39loJL8lGe1EzLMWnwlm4nAf/IT8WWpl4MtxshECCtKoP2iv57EUg28OdG+N4NcO63gAG9+VaU5AK6Sszfn+QByWM2NDy+zTV/MvLOQ2gdwUXC9hntLM0evPfDSLPLnU/qP6OnEJ/oREh5rInfV17Eb8abaWKiYHDX9A8QBZ2dnXk016SRvlnC/lL/cYuaZvAnx7k8nL+Mzac9hEuMfdxI2WpBfi+22syuiVpYIZQVHol7tt1GwQcjHz336TIdXWbkp/aSfJSePFz1KtY3zPnUsnw9SfmLeFqdw3WTN4749YwUgh65sedIne/TzpiREQMpkgeX00tPrw0KPehuB1KCa3dVp4FDSbwahydTJCU3B7WhcfBraGhEUlVIL4nrHJJXpfiXe/o6Pw9ELini4M2FXLrUXCRe+pU/Mlm7g7xP4nv0dEnEW5GL0tCIoarYX1rH+Jf6X//l82dzxfhtACiCRnH6BpJF26DSqgCdugftVzmkvT602hVx+kSW3rM2pOP4QHp0L2du+TydPbaoHcgNQPebk7+tXiaSkmYgSSRg05AUHa3NiujrCZsBkvb31aT9HcSkJP6yLhdFUBlvaSJXctNryLzfOQmAbFc32w8UMum3rTCIgut2fyare2JvcNipOnitayZzsnbF/J4+1m2nuLmY3flmetvXF74z6gbGcf5YsIZJ1eUo7uGFsKXMDMgIjaQJvZ4Q1RgpIx1jXC6GIPDGPT8Lm362aOtVuNuTULsVlK74amV8GQaPLPhHX0+CeVf+gs+++vWE9QISNR3Jpw35cGq+j9Uznh98xxN4a9JrzPNcC+tN6WbR4SCCvR4XogpiwIySRKNlRT4tBBvhAZdBksVcyCuCxmk5+wF4unUOWku/UyRSsafk0xE1PWyTy2gIhoHo0+BgTV+fGtebnfTmmPnz3gwBtcjLTdM2hH1/wJB4sWkRSrdAZ5kEg/Q+P7rUQaG3EHGP2jcnSBXjsQ347GlybA05E81Ov4dPmkpJJn5jp+S/+ucHQZb59S8uxDhWAJ98UCLz4WCjQPhkK+OPbfr1tpnclraR7BiiNy/1ulC6DUSHAzHDfH7V2rq4U2f+0nAa2b9LTBjsiCeNcfb2sMXfHQEHde4UNL+EZNFY8tlNpCu9PLN7NhP2lfU5v9IfXY2tYwGrbjcb8S7OOnjKNxceY/iMGRkDEYSwnVJvSznKkhl/5fJPvjpC54W55+ymxBFbik48XPjVVTxVsYTx324akfw+wTAQVm9DD3dsQaDmVy52L/hj3ybNGKZpHoPREDAkHmhdwLcy1sZUQPjr1jkoPUMz8ARZ5o+vPjKoLrlLtLF+9jPMWn+9aaxGQPPKgzZEAlC6BaQqG4EpbiZ+b/eg6Tt6dzfPTDIX6o13XUvvouCoyltMInXTMBLOY0Az9JiMvhNRDx2m/O7DALx/xmSW2E5e3VLOozasy9cN7c3HCneP3FIZthndE1vmU/6FYyIHhgGCQN3nJ7L13uO/n+H1CTgRQ4QdN/0WqxC8YjaExKmayB1e9K27E3OwISLIMv6FkxJyrKQaP0qvfGyxHc9FwIJzdob0PNINgfwnLNheW3tsP4H6by5CDzMzW7dWQ1Y6/tyk+IrADXPBO3Dk1b1esh5aDYJA1R/nRTQwwDQKrr1oFU8vX4q1Pbbz1p6TQlbWZCzL1yPIMhVPHsYl+ZAEnUJLG7emnJz8/Etf+gYT7olN/jwahqrGdZyV021sWXkZT5e9HXEMDBhmesTDl15I+u7V+M6Zw5EvmtvK7+hG6+wKP4cbQx9bY+3GufONSo4sa+TM3H0hr719oBLLZhd2EfzT+ueVaydtovrvGTQvEfqu2/HCWnjBfL1+TQp51v5olz5qnUHHGE3GjIwB1DwzlTWLHgCiW/+Bcg+Beiu25uF7VA0Jzr1qXdzNn+LhijPXsuqNMpIvHN1Q9RU7m/hCyjoG9utd+u07yG0e+mdVl0zFsuNwTDUTv22bG9Mxw9UTxII0qZy/vPVX8uLIt10z95/cXH3+oPKVsSCqYNnuwFBPPT36EwkYEj9qmcqd6etPWi52Inju4V+z6PFvUxatmVc4BIG0VWmkW9xMFcMvTq6ZsZHudaYBeviKDGp+l8KqeYOPR8eRkwK4p2g4dg6elqFZQZ3oRjyhriVPdvHMX3/Lxd/9Fs6jo18o+q+IIcEFV60J6wXeekUJtprY00e0PfuxtGXhmzIupv3lHj9siBxB9L9dxLWZsRnNl5+3hue3zcaxe+g1i2cn7WSJVWe06qlOJXrPdzPxv+9k3+cfDHntCzXLaDzPXGRr3ftpvHsx3fM8fXdpz29M73/6SisZjwSPPRXf2sKylXfwya8eIl5KXldpnOMIMg4GomsCtl12BB26PsrhZSFUsEAZYPdcPnErVrF/PipxtJK8zsnhKzJCorQNZ2k0CP0FTqox8mldw2as8DtuxoyMAdgsAVLE8BN6qSzxt4WPAnDPrutpVQXcVgVH7fB1oUfSwACwiiouS2w/YL2jE+u2anzTSwbdV/KoyLur0U74IUipKZS94+W6pH1YheBIguwzhpVnaIhCTNEMiM140A2BNffOw7Z1f1xqQV03LuS876yMy8AAs2GXGCF5RO20YGuM7ycp6NBy3Qyy369Dra6J671D4YnuSnqGWDg+VGNuIB/euYjnvz2TzfOeGvaxhkKm5MRQ4hv45XGFHPxlGjMd21GiFHMpgka6YqaRyC9p/DjjhYjjUSREWad3grmYtTTKIR2z3QUahl0H0UARw/8QMyUnt3zvVX7z1GXkrxr62GQ90o5RNzyPtfWgjbK3b+XgeX+J630TV30OY5+LtETlfQ0RX5pB5cLqEAOj2p1B43+UINXuCFY4MgzGPXekL+o1EK2jEwwDvbUN6zZt0DHa2tiDUXMUPYyC0nGSLL6oz2TQ8UR1WCGuq1M2MEExkITRrWnSDJ3T7/4qsken8kDLSVOF091uyh9p4IyPvhzymqXdj9C1FYDa7y7GXRpAlvrvtaSYv9XWuRr+lMXkPdCfmmX4fMhDVB0TVIOMXSpdPY6Q6HbfPnrw/6MR7llKV3o5TGijPt0dfD7dGHNq/CsyZmTEiEO0sNCqM+Xjm2F3Eg6PmZfrzdaxNcXvlfHk6gg5XsQIE32iyXN0svnexRT8ekNY5Y/jGKqK1tqGrdr0MKjZyaiO0ARkpcuH1NiBOqC4T8pIR0hJxrBbeXu/jbf3T+R7s97kluT4CzfjxfF6Ms+cO5trJ0Wui4iEdfUetDD1JNFwZ4v8ICuxHZ8FvzikWh9PtoARR1F11mY3mt2Bd6Y5yH+mcgcuycf76eXsnpHBt5J28VHPxLDyjPX+1Pgv8BjrW4v5qS5zTdq6IffZEFduxp6/kGn6jWxf8MSQr2W0EOZOZf9lSVxTviqm/RVB43TXHpbYAihCbB7jG4s28II8k9rmNARAdpqTtT9DQHWc8B0mm12wbXY/V5ZtRYxQxHx7ah2/EcBW3YohS/gKU2O6FsEwsBxpR9ANjJa2kIVEvEgesByO33MeqHOSvdMgZXdkOdWhInsMHI1GTL09dIvBzNTaoG0r6itwL88hd9UnYU2ggc07w2GoKlpbB7bq6NFco7Mrar+KoaJbwJfWP29ZOsWIPSAGki+ruMTERzGrAr38vvkMXl81J2h7VkULP6l8AQ2J9kqJQLKIfnYmkNm3T+UvayL2YdJPn8WhS4OfvdxPDJzPrx3ytWr7D2Hdfyjsa4JioeO62bjL/WEbSALIyX56CxIbBVK6NZJrIOCKHNEYKRq+vpjeIvNZ0r1e+N7Lo3r+uDFIWL1azOf7lDNmZMSBikbeozZEv+nd82QrNC4Ee5P5JPiTBWJx8lrbDXorVW4aRZWFIns7hTeuYvNDKVGNDMCUnTtYDYAkliKkhXrrpeZO1CPBkyfpqXjHmQWt4/5sbvrxly4id/6TIRKmiSb90dV4shdDHKnXXaqNFYcrKNJGN42sxNHK3qQsurr7ozyqT0Lyj05OqrhqCwWeKezPTqJwegM/yFlpesyzt8N0c59qfyv1gdSQ7rY5Shdu3RKTDG5bwIlPM4cYHYFDTRkcbMwkUClB+mr2+OJPGZMmlJK6ox3PuxmwIO63D5vftRdjrw+d5KUplXgLQrVNjy6xcM0lofUXkVAE7VgRduxRn7vSDnPAm0Vtc3AxuZzih5Tw73HZfMeM5PALlvtbKkk5oKMerEaQZZQU81nVHHLYwmPJpyH6NdB1tAiLqEjY2jUCLplAhPWnoMPzPclc7GwNqR8Jx/M9yYh+gaRqN8bmnX09HRKF7NZwNhi4cwa/FjEgsKMzn6kpR9nVlYtqSDRWZTHphRoYZ8o3680t5gIrHnStb4weTSRFx59sIOb2X68fG4rY/0zIHkZtcdSk9bLeW8Srm2ZSMaBGQppUTvVV2bybbzZLveuzL3NlUlVI4fWcvV8l9y0pyLDTzpiNbhGpvlji4NXBKUhTSm7C0j0XQTOQVyR2/hYsCq0XeYe0KLN0qtzXNI0fZW8f0rmVbo2cjTrVeVaEdH/Uju7xUu9NCZv2o541h0u+sLLvmru6ddK+l7DTjnGKMGZkDMAXkOnRvWGl5jRDp00LXig7Gv2UPacjrtoCgOey+XRMGPyW5r5RgzejGGYn5LJjQjcEOtT4u6hGWjCE+FkEIWyIv+gRibtqvtiXh6pZzOL6oaZMCboBEYrHBc1UuhAFfdB+IwFDYl1TMYVX7WS0VeLuz9nGeFsTP15/Ud826xELcu/oFb4ZG3dS2TKO11e/Sric/1tTGni4U+yToT3Odcm7WOPNYl3v+KjH1w2B1UdLwha5v753Kq8zFdUjU2ndjnFiT5EwCMckiatuz0HI9zI+9/Cg7xkJXvjmueS/FawiIzocHPhvK3uXPRKy/xafj5e7TBWfRKSLRUIRNERJR9cG93IahoDXr9Ci9fbVx7h1P+4B6Qqrrp9Byi5z0WaoKqw3FwLyjEn4MxxmF+wByHU96NXmQu34d2UE1LDNzk7E/vI6LGfOpmF+eMNV8sL3//JZxt/+KyYoXhRBCjE2AoaGzwjgNjT++693YAscGytGAMEwEHQDUSVsgfZArG0C+94az/irmtn54QSUHgEHcPjGfgO76DUn7N4f07062RRmtXOCawkx14s2oLepuNNsJjiwjjfWlKxYGCge8ljnNOp8qZwoHbb7m6ncNG8lkqAjYnBrSg2KEGrFbvyfB5mUdwclP21G93oRnU7++9FHIirY7Vz0OCwyFQlvmHYRWkdHYvLmBQHBFl/ETrT1/17ENbvYfGEBvg2bkI85KPQIUcqIl6AalL6kcvBqBZIDfdN5TPO1YNYeHed4Ebdbt/DRwQlUCM3m+uCYoIXocvHIX38zqGDKGJ9+xoyMAYy7djdL7/wmW777x5DXnurJ4i93Xo6o9//a5C4fxsb+lBn7y+uwx6D6oRoGUJyQa46V9W3FiOceBX2Emv3Nm4rfObhn78MH/sCMP95F3uqhRTbkj3egRYjE5P9iNfseEJFcTqZ9GIg6sT2/YiHj/yP+nhiJ4vdVZ1B+8+a+vztvWkBPwamvrvGHtvkx7fd81cxBF7yyXWX/o5Op+GYdWmPklDqpvIyq/zFd8oJw8ppVRuKyDYf5csoqwkUFZlqtzDwm3fuD5skjZmj8PHczZyfv4q51Nwy6b8pHNjL/vI3P2c7lqaoVpIh2Zj72dcru6/89GGpV2PfqW3fjv2IB9dec+Pt1gTE5aEvBkwq214aoxBWGmx7+BgDi/I6QVLmr9n+GA8vLAHNBVPT4QdT6kVEwUprd6Dv2kPeOQMPXF6ENsjYUNHjr2YVEKuU58pkMMkqSsb5+8sajRBKY4sYAelrsWAEEke9lfZSQTt4feETe75nS97dmiHz4xwVUPBpeTCFN7uWetGqiRQZ33PZ7zlt2ObbP+Xlhw6sxRctSRDsv7nibS6+6FdZsi/djhCDMmULVNxSEGENAgixTuhKSgpxpDdzfMrPvr01HColNHiCYsuc1QKSz1ELnWR5809xYdzii9gbzpRtcc+7HfZK0nzSXcbS1P4y696fZFP8lF/m9jUiTynnxncexCp8+A0MwDIRRLMYezXONFGNGxkB0jfwn93LB6s/2beqa4MLvFJAC4NL7F7fWI+3oNXWhx4jxoSh+dD8rqpdw9nc+jmn/dLmXL6TsCNp2VBN4siO2RR8wop4ycds+pLIifLnBKSMNd3p5avaDgFkzoAgScTpYgokmgWsYYGho3d1sv6kCgN1fS+WmxaupdmfQ9qXsvl0rO2tQT5LnsPLRrzLh0fpjxuYxTsGx5OFfXEb26lY6p6Zz5vfM5/SfHy4lo6yd8wsTI0sqCAZ77itlwlP5CB9vQS4soPOR/lVbY1syWrsVSQhe1Fa3pHPa9iv4aNqLCbmOWFiy7UqOXiEiXrgQR51I4R+3cvH6Gj6bfCCmYta70zfwdHc5tf70Ebm+02zdPLXoYa5ffVvEfQoeU3Cs3Yuma+huN9dd9iUQBMrrDqHGoFLW9LXFdEwLhJ84TigKrrnEQDxnIZJboPR70dW4lLV7GNdaxJELI9+b495UdUsqEw7eHvSa3CsgDxwaRmNyjuEcvgyDKQsOsv+NyJE/Q4D2cgXHjQtJfmL48qrxoH7ZyRPfm8+NMwc3Bt+um0hXFPntgQhA64IA7uzFFP1sA2I8krtR0BBCasUEg6DvoubZaZxTFHtPHkkQ+XvFE7z3fklMBsZxrIKCIQjDms5qv7sYb46ObtGRhdjEWeQCNz2vFZEq7w/pMzHw3pw3fi/77zPrTzy/KkDujXG+O3bIgEvg3HJTLryj2M6aDZU4joY6Unor/ZwxeW/ItQzs/i0IBgevlXB+bQr3TXkjrvs8xqebMSPjBLSWVhggj5p6OCtsGFPv6IwpzSPieRqbsLcWcWmKWaj8fs/kiHnuRdZWFv5/9s47PI6z3Nv3lO3qvVdL7r3KJb2RHkKqc0IgENKAENqBAxzgywHOgVASCAlJgADppPde7Lj3btlWsaze27Zp3x9rldWutLvSSrYT3ddlgmZnZmd3Z973fdrvsVUE9HywCF4ujtvBG91zghbp9vH84bnEvRBDPCMXFI4F3e1GqmvEoul4sgc8GLmJHQGdnldcspOP7HPIfTd8yTrNJlJ9GUzfYg/ZEwLDQNvn88QW/Xshb+xcieSBxH3BFzrVP1uOHkIxSHIL5P18IE0m85Nupjx5K4evi1w20F4vBORTJ21vQ1KS6CycGGlHOTODltNyRtwnpl5F21dOQnsGrz+0kvbFCrZmiTY1iZfVWVxasCfgGJdmYmtrHoYe/tQrJXs4fLUV+aIyNJvBdRkDhvc2Sy6HSAs4RlMlGjtiub12Gf+T8X5Y/VD6KFd6adOsLLOGF1Vo0Xr5ScPZNHfEIMd5IQ5caXDo4RJujV8TtlpOomQfsflUuqmL5fZD9BnkkWIXzcwxa3xj7gdox5c+9d4E9nf5clla/lyAY1slamtb/zF9kdiRzAvR4aDxRl+xTud0za/T/EjIsQrEKqiKSPNtZaQ/tnPYQnDd6USsrCVrrZX6FfYR5fslN0ju4M+JoEPmJ73oXdEveO5Di7UgTykMq/ZElw2KY5o5LBSP6EjQLOCNnfhIplZ+BMMZnqPK5TWhqeFH4mS7iqsQGr+6iLI/L+K3X3p03GvzAGZn1pFu6eqfNyH085kjx3BjXEvE79XyAzeOvy3F/kKExeCCQPPXluEsUpAdSkhBX6POinB8TFVlgzqXCQLVZP1IMDlZlORTHHz88xmkfWAm5lh4c27DUgvGwq5+tbskUy910+NpyfVFowwDsu4zI3h1qhLtZC/o6D92S1serb2B47Ec52VBZg3XxrYHvHbKMClhGzGTRkYItObmcTu3bhL6VXbq1Hq6jhsZOiKH3QMjiFXw4hBUjig9FA/KYbSLZhZbdI4oDVR6UgOKdAFeqZqF5f044h9fF/BaMASTGTE+sIC1j5H6U+glebTMi6E3c2CyvDQxMNrzcO4n3HyWwDr3HAQDMtd5hp2Au3PNeJIEVCusXrKG9y9cQeKHlWF1MAeQ399KyvvBXxMdDpxnzuS8izaHrOFo9MRxaOtiABw761A376bUORVCZ6eEhbavHEfiPDoLI6+biRQ5MwP3jGy6igR+21bEHYkHAzxLlx86H0uL7zvR2zvI+LgNJTYZQwBbo4hLTeBj2xQAlqZW9WujK4ZEbUtCxNe0YMFhpsX6/6b17ni6PMMvEHRN5J1D01gYU8WFjsNhywk7dZku3QqEXiwfVXt4vWcq7xya5rc9N7WdD2a+RDT1/uOl3gCDPFJMgsTXEwfqVXZ53Twj+O7bbW95UNsjn+AFu53uVT7Zs9Eke0kmne5VLhIOTce6vRJtkJEzGL27G2H9bmJzF2MI4E4SUUL8pEqs4R8Z1X0y19o8X0d6udONtv8w5jYXSoLVJ4E9RjSbDOnxCIch9piGZhLwxgp4EgfO7U7T0c0GQsLJr/0fd0jmcdsSJIvGtUPESDy6TK0rAQA9AsdBH7JdpWu5RslNu9l4dTEX2MOPMITD0/sWkl0f3ETOkDuYYx5fudxti56mdO9tTHkvLrTz6ziiw4G6oJSuVW7kEJLABqB1mbG3ioPqIgRosvBRxhQWptSEnLsAVs/fxJMdK4DQhkbbNAvC4k6uKPJPA1uZdoQ+f49uCKxJLiP248Okbivh8fQBQ9VSY8abrCMljr9BOcnJz6SRcYIQY2NxJwxM2Zc7eoAeNEOnS3dz7yAjo9ydSbk7E0nQ+W7yVr/CdEkQWR3byoOalTbVNyPrCOzrzgQg4dFYrK8MGBihlFbEpITARk8C6LKAYIB1gxLQ/K3PO3nwZhuVlwY2GgrGo3lr4da1eAyFMw993afzHWS8bT3XzXWzBrrRnvWfn7Cmpwzrq+EZGcMhWCzoM4tYdU94TdXSLV2k/48vleHt368k+bkuUDV2ed3MNJnD7ra63+tE8gafWARNR/KCFuE6U/IAevjl6z2L8midISO54a//vIClXztMvtyDx4Bu3YQXEc/FTujejSDLCHnZHL3YvwDc0irQ9r7vHqu5tJMUs8/j1aWOvlHXUHY0Z/kpcA3Hr7ZfgHPuB9wQ50vhsoumEcPx8ywWwjEwAF7qnsl9O88Ma99wsApeTIIWtDZDR8RjKCdVKoEgywix0ZEdrfmyRs5jRVg/cg6vpqRrxD7le86s5y+ibZoZBALqHgTDV+vgzVTguBKOIBpIJp2q26HP8pAOJ1H0Gwfajn1Iy+agWeWoGBqGAKIs4/j3cQ/2ktk0lA04Z1Kmt1AU73PIVPYmn5TpkH1k/G4dGYBcVIDrWf97r9kbw+bqsdUPCgKICfGYhLFFlxRDQzEGboSK3hRKftI5bERJMeQJeZ6UJBW9JBdh58GwGqMK2RlU3WaElWalqyKOyiBztgGdH2Rw9MJeZsUHl+D16DJt3oFn94yyPXxgnknM0Mp9jtcaqAaeJBO511QwJz5IKvggRMHg9J+sY+M3FxHzzAZKnxn0mtVKw5cX0FXm/wl1RaLLG1nfn5MOAyZUKeYkHjfCZdLIOEEc/J8ZAfJ4AOWKm8c7gmtzaobIr1oWc2vSenKGeG1vTRgYFHZ4PKyZ4zNErPjn2morZgeVoBwJd7JpII1n/iy/1wQdsu7dOOp6D4tgYt1vH+TBjuxxy1UPRtt1CzjvrvB6FwzlvLvW8uTcFUz51ga+W1jGg1VrwlbJ+Pb5N5J8cBjDZsMucqrSqf7iyMpNQ8n6yw60MfQj+NpDdwKQvE/F+krf/eJbEKir5gyr+tPHnpcHvPy6GZg+sVrrAPftPJP7OBOTWeXzU3by49RtJ9VivY8b41r42N3C212zA1477E7nXm8iP0w5eAKuLDjqqjkc+Wr0ZtVjX1SJKVlA2h9DR1bNb20h4y2felfN1+f5vSZ6IWWXh9QB7QRcaWaaL/U3XrQpLvb/rpTSm7fAhl2YZk3DmzZ2o0k3S+inzcX08U7fwnLTbjIGD7V/gL6Yr2AyI3yLEVPATgo8Xl4+OCfqpxUEg0P35fKL2NeB0TshHu3M658j2hQHrSs7wBg+MrfdmU+NknS88Ht8UeKtiGWzEddsD73zBPHSwTnkPuy/xCscJjFS7vYi7KtgwSfOMSuBNd04HyUWbHv8DYrcN9qoPKsYvjem009yijFpZJwATB9m8nHRvcDo1BX+0bGQ02P2DyuzFwzRakVdNC1iL15XgRl30vDHGCI03uEziqZPrYro3CeKI/cuY9WKPezryqD590Uj7nvsEpXV80coijQM7jztOgr/3cQfs4Pn5d58dCUN1/kiAVr1yHncamMTeQ+5qfnqTEYoswF8evSZf9s95oZnw9F97TJ6siamRiTa/L5tBlfHbR+TROINVWewrW7kupVTiZqbpyN5IHmvB/n9ievRM1Z0p5PcBwb0/4WMVFxFgQ4Ja4tC5jNm6q72+nmJJZtK+UOLmf5fFSfEMWgoXnL+vJuGG2cPm/6VdFDF8c7o5LSP3LuMOYuD9/rZUZlLyRcjb1A6HnznS7dR8WWoOOevYzrPixVzyL+jFYwGKn9ZhpLkv3A213ow52oU2EduVhhtDFlAXzkPaeO+0L2oxpln3lhJ5joNwuxvrsaaMcqmIzE6hTM5O4vazxcADNsrrO6sJHQzFL3wNSqueGhU7zPJqcekkTEBdF+7DOOLA7UdjxT8KyASEQlO3YxiyAwXtys06XS9UUziTd0INit6nB1EEd0ceUa1IfnrXwejr/2GVQovBeVEcuTXZcg9AptfmI3kgZSOkfNGUz4280T3cq4/zd/zOmXOMSp/WUbhD9ajVtew63+WsCg1eOMTR4OGtTJMKU/DQOvoJOcNX95658wEugr8F/opexRs1d0Imk9JK1Jittdir4zFsMocOzsOgNQdXux76/38XKpVIEiZz4gIKgjVNvQ8N0KIfOPxpFuzhr1gm/Gn27E3BV6ro0HDXCijLIueEfeeS2Kfe2IMlw1ujR3uYjoUO69tmYvd5HuW20vNxJsXY35z5AWF84qlNC4RgVG0oY8yfZ2re65ehidWIL4ycBEn6CD3aL6QwaB7T8BXhF5161QSy3WsLRM/Tund3WS+20TrklR6s/ydNmnbvdj21qH29kZ83iO/LmPGokpmxAWX67WXKKy7fykl39h0wotIzfVdTHkohuKWWzlybWSCGc/0xNOmxvDEJ8tJWy9QfWM8UISa6UE2+y+kdU1kb3MGh00pxFo8ZJnaudLRHnZK60js9zrZ6cnu//tiRz0Aql2iJ8s3UVqyFwT0aIl9YWtYqVTR4NlXVpKyxwhfTQowBAFDgFeeXMnsy/ZT5Ai/CF6aOZXW+YmEasPVl/JorZco+fAmtp/2YNCeZCczkxK2kTNpZIwzPVctpefaTnbNfW7Q1vHNS4wXbayf+xwX2S9Dj7XhTRl9eoC520AzCyELME8VdJtO7H6RuKrwPE1x1V4E3cwTcb7Ctotn7SJOdrM4uRoGibLYXtwU1V9V3+OTDowXpyF74vxec+xtRK06Oupzq8dq4ZivLiUpZy4A9j11qLXBc3sjQdDB3CHgjqCZd3JCD/GmwBz99JgeVE3C6YxenUcw8l9pQ991IOhrxuVL6F0WuL3LbeHvXWncFDd8f49gHPGm06j4/54fNJTg8vqsOUk0qPMk8KvMj8Y8Af+rdTnr6gtwe004qgaGem+8QMcUE+kLZ/r1+RlKV4GEkR/9KJkz3UA7YwHSh5F72DuLRFS7QXyQgKBmFeksMqG3a0Flso3pLtzNVqyRiwhFBe3gYRJjrViG1BnZdh8bdU+PecsOBQgmDKbA3kr68s2s+eIyUl46gDaKwv9oInyygxLPLOYWXcfOJU+OuG+L1ssxVUZD4D/fuA5Bg/gKEc1k4Jnruy+H83/19FrpATpNNp4yLaEg93XMKGTJKmmSA4+hsGDDTRiGwDdmfOCXbjwSzbqdPa4BJ0GWqR0kA1eK3F/4P1gAoI+YRTOQ9lWFXRzejy5gbTXwJAn+6XYC9BYpxJkHHACKIfHsrgXkbNUwdUWe8iTokLbFw4bcUjpm2ViQGFyNsk1x8OZeX6+SIsHAWRBHT3YEWRUKWHba+XrRufwo8w0/MZtJPn1MGhnjiDS9hMJvHeRfBR9G9byxkhuroBBK68WwmkEcm/fG1qQg6CY6Y8Y3bSZWcmMVFdy6Cd0QONCdjj5MvpBqE5CzswK2613d/R7P4Sh+yhNxRCe2xkvsP3z/v+X/xfSreZgkDX1KIdqRqnHzEuq7DmAb0uspWv4ww+PB9uKmqJ6zD80jIVm0EaMZgmBgMqusSK/AFiQK1jfJHXIGStgGPZ+oY5Kj2/tEcumonWbkeH+jtKvbzq92nc9NK/8Z9rk6dVd/J9w+jroSadmajqlrYPuHpPD6zQc4395AvDg603Wv18UbB2Zg22MLqn+lOKD2rHiytktR75+jKWLQAgTpuMdZL3ZREW+h5MPIzitnZqCZQTeBEith6va/bm+sRMdCD46DlqAFk70WKXTn4nHG2LIH2xb/baN69kQJqSgPs9gRclebpHDeXWvZumUmnGAjA3zfQfZN8Ty1MRFxhB9kl3M2G1sLUDSJ0u9tR4yLo+ELU+g4N/zImqpI7D6WzQ+8VyIKBnMSalkae4Q2NYacqw6ArvF/f7iE2Zc8EDL9uEd349b9lRff7pqNIBs400dOQ649PYZcdw5SfQtqcgyad2AOEmQdUQy8YXVNgE4T8RVe6rIt6PKgfUS4evHm/vqJHs3C3o5MCv8hgDG257nwBZUDRi5Ji5x+KWdHXYl0eW0c7Uyg8Ph8qFklnKmjW0ZufmE2f7m2m/PifKmQiye0onqUDOnJMiHvd4ozaWSMF4LAr97456gk9CRBH7Hvxer47SHTrTRDp2NOMrbmkz+FCWB1bCvvyR180D2DLtVG58/yhn3Ams4XaboicOGZ9EY+Cf8MTy1qtOiDXKTzEo6hPyuw4/SEyD1Un3IcB830FitIMb77L9gULEo6VxSPvVtuH8nxvZydGbxT9XBog5s7Dm0YZhiY39rCjIN5HPxFYA2AYQgohuZrMBkGv29d6Kcq5dFltr00K2gn6J8/upod167lF+mj+36uePJubB0TX2lsGAL2fcHHPNcsF6I0+llz309zkWN9HuyaZBNFT/m/bnLqOA4MH/VyHDJj6TwFFjJhIKUms+DfhyM76CQqr9I6Ovnb1NCqVSI1WPBNBYe+PQXyIk/dMwDzpS3oTid7gD0U9l0FACXf3MDdW+5g3a/+BDBsWtXT3QVUelIjfv8+as5PwJ0ah5ak4tg/ICHozNIhNTCSK9VY+3tJrbxwJ+mW4eeYNXVFJPxueOn5SCl8UWVX1QwKblzTv23787NI2+ohcdB+HcWmMWU5vPbUcjZvX4Tk0XjmoYdHf6JJTlomjYxxQC7I488fP0HeKOouppvt3J28hV+3RNDJewhHlB6+fOfd2JzRMTCsrQqmXpGWWeOv1vN27TTsf0pAGqGzd+57Cq0z7TgX+6dytJznpnPKcvL/O1C5RpBltBWzxyxf2XBPMdu+mMPV004eFZGTlem/68CoroXSAg5/b2BSTX3Jismps+znoetU5iUcI9PWxccVU0bcb2Z2PTPi6v22/atjCWWOQ5xnD/4cHFN7uGX+pehtBzn8r/l8cNr9fq9f8/3vEPfkBtTqGkq+EjzH5jLLOazesIvVscMXmXbqLu5vm+9nYOzpzKL87WKCODD7efHfK3lt8cyQaSWDadF6WfXwdzGfgLpT1SljPzK8/rJ1nw1nvooc50VM8XDo7wv7X0t7x0T84+F3u5ZiFCpvGlgMik1mbI0n0Sr6JKTw0So2PVRG8iPr+8fDwfTEmYCTv69HpAjAwQemM/U3vf1pqINpuaWM7iI461ZfF/n7779v3PprWFtEjFb/Z8ReL6L02NALBwyomHV2EstPnt/i/V+tILVl/PpeiGt2cc2y04GqcXuPSU4Mk0bGeCCKozIw+ogRLNyStJ5/dSzEqfsGpHjZyTVxOwFIl0ZOodAQIir6CkmY2tC7N0xhWU88G+b9e1Rv85/7r4TnkpHcIw+ugmqQcFhFctv6m4QBiJKBJ8/D0f9eTt7P1/uHNQUxYuneYEgeHV2f+MWMGBtL6tsC0jDpR1U/nRaykDdSUt+ppntxDm1TRzdMCG4vmtOJWF5F8b2F/dvFY3W45ueHJZUoCgYplh5WFg2o5xxoT6OlPRZB1FmWX4UkGCSZegO6aSuGxE53Hk6j8XgfmgGatF5e7y0l/TUFiOG/0v4W8Mxe9V9vs/ubviJPRZdoPcsd2N/B6eTRr1/BQ3aR+mUSh24c6BMz5YlbyVqr40yRuODOAbnkN2qm07UvGUuIPBlRBfeeBAqbvgoC7PjcfcOmT91YfRprdk8FXcARhbVA26ulmGnB2RVBc0hDCJqOZIjgLPQZeqLN96EFBtKnAJqWy7RPK0NUhcBnNwgCIMm+NzNqbZi7hJBqbAA9mSKa2YSjbmwOGFHRMe2pQpugYt5osPW++aR/WIOREI8+JTdgPNTlk1RjVxA4+pMy1HTPqBcsklkLGsmpv3s53aUqcpfUP2f+s62Mabb6wH2VhFG++yAMP02C/m1yj4BebifuiO9Fa7uKoJ7YXJnUHR42bPc18rQJgc9L+1QzarQKEXUNrb0jSicbRyY7fkfMpJExCurvXo47zf/Hn3LvYbTmZoRFs9h/09h02CXBZ6SsjDnY38XbIXrGZLhMBJZWgca6BJg3uuNb22IorA7PeyP3atibBIZWYMgWDW+Ji65rl5L42j60ri5Eux0hKz3oeU52nFcspXGpiGY2eCP/QTZ5FNxGYETpi5dOJ276cswdBkl/Gz5lTM7JBlPgY683NgdI4aq1dZhLMxjNMJG6U8Ho8v06utMJgwqMfVN5+A2+TIJGtrWj/28lXsJuUpAFnTzbyDnmnaqdg0YmH0uH/LZ3aKk0KXH8LW/NMEfC3UkVkFThu2ZDZ+o9t1P6YGNA8y/T21swAUV1symMu6V/e8lzLoT1O4lJSeb5jFUAFJxdRXevFUtbeAs6U7eAqdv3e1998CosskpFazK9DQNjTP6UJqor0oI37YoAaeoUDn/Jlw7ywqzf8r/157O+a2SJ55FQYg00m4Ehghwz8qJeSvSgJ4KqC3RdtxQMSNzWgnYwdEqQ7PL1zQgHzepTTRsrgm6c8CLqSEna3o7hdEJWOkrc+IopRBVBxFPsRpbHlurmSXNgTUz0/W6iRPfVi+mepvjuza6B1fIL7y2jdFF10MLnd+um0nRkoDGpmOxBbBl7hN+njAYxtZFHL14/OgPXtmQSiG6kQXYqyI2dAHjzkgKMUiUmPMM+FL0ZJhIXzoQtO8Z+sklOOiaNjDARHQ6UJVMBuPOrL3LLkC6bS/feRuyxXI6ea6Hi8+F1vQ7FaVYY6Ex8aqQCCB6JN50WLrCPX2g1FKJo0HKJm5i6Yky7qkCW8eRFv9Ffj2bh/ZoSsrXRKT0JJjPMm4qxdV/Q4lth8Wzabuhh77J/0KK5qFfhg575dAcRIl+9fD0sh42tBQi7Z/lUg4Z4QaS4OJT8VDRLYA2BVdcR2mUMTUMfJKUp9yhYOix4EsJbmAkaWNsMLO9uH9HLa+pWeKNmOp/L3R/WeQdTYG+NSAO/W7MGNL+zigpppvDraCRB5PD1DzL32O3kvKSjVlYH7rRpN6VBMsC0llZy7/Gl8JUnLEO3GUTY1B2A2rd9kl2J5Rp56yrRGn3KVr1fWEp8ljQmr6JUUkTNZWmU3/jA8S02EkwuzBYFryfyRZRmBW+KhhznDauzcR+iaNBy8XFhBVcStnHoS6jLPslR2Tm6aK/qkOjJMZPo9d1T4qGjaB2d0bzEMC5C5ZWqWZyXdwCLGEE0JSUJT0bw3H1RNdDaLIhJnoh+s3Awam0InrYonzUynOkmrBkpiB4PhqbRdIkHOUhkOP8NLwfsudjneP2Uu7a159K+NZXCDwYMgdZZ9qh48wUN5BGE3LY25rAss5okU6DMcdfBJPI/jv58q9pNqIUpUT/vUDwJAj0FMVi2hN73hKMTvMBwPN/vFOfUWLmeYARZRlkylXcf/yvvPv7XAAMDYOP//pl3H/8r5TdFx8AYLYqh0aGPZgkTHexHJb71j5vxGAqKofkX1g5Dj+6mR3djaNF9equ+ZtC7siSq5xzM/o4MMi/f77coD4VgMiNYLAgWC2JBDose3oGcltK/re8fQNkjW9lb9jjHVBd/aivjT21lQQ2MwSxNrmLuw3uQ4uN85xF9BoUgy3gXTglqYAC4i9PwLCpBm+Nf+2Bs3k3G6zWE0wRWMHySx0l/XR9SE174ZAfpN50YLVFJ0MkxtwV9jkOx83sPcPDOzFG/d/F3NlD07NhSddpLJZou9nWFF0xmYl7aTsLhyM4pGPT/poLFwv7vJrP7rgf89jkrfj+zMwLTRkY+qe//ego9yHFjyynXJaH//gVAE6IituKNF+gokUe1WDBEaJktc+7da1n08A4WPbyD3lVTEeSJ9ddprW1kXL6fvZ2ZAYplg5EEHZOgYRI0DKuMYTWhm0V0c+DUL/dqFD6voqvRXRbousCUH2wek+x2tPBkxmHMLEYwjzxHFj6nsu+tUlyaqf9fw9P55HwwxjoJgaD3neyEpAPDGwqJv4/hg6oSv7quCUFg2GuOFkkHvDieC97IdpJTn8lIRhhU/2gJO776B2D8C5/HymXll2Bc1AFBtP0nClGB2WtuBuBH817nxrjhF5MeQ+GiW7+B5NUp0k79/MNQaG+mMy/x2PG/fGk3M17377Xg0swcXmkBvLztNPFJ79KI3sMkaMx83+elf+vxMnIe3Yt3fjHGUPWkMFFrjpF9fzO131wYTJm0n8RyFdtL0a0LGQ/Ojt17PEp4aiPIMuWPzvIpNtXJEfV/sLQbJD+yAQyDBRsUXkt7iKE+p8sdPbhTtrO1OrymJ7JdxTVLw7Y7OonaDVd6sExdSs4vfFGg0ju3cuz7S/HOHnvvDs0MTQstpO7wRpT7XnUDXDt3rd+2ZT/fxEuLy8j/yfgq2wVDP7eJJx9YyuolwYvmM00d/T0gPC/t7N9+WFH5xpfvnJBrPNnonOKg+a4pIZuFZq73sH3D/P6/E/WxF2K7U3S0RBVHeeSOwMyHzLxwdhlXf25t6J2jgCdRprN4wKiJr9CwtJ06NUiTnBxMGhkhqHxyLo8sfQCLcPIbGEXPfY1pf27H8EbWIGw8MI4XR9974Fz+bBkYnN+Z/Tjvu5L45gerKXpKp6PETILLO6560FprG5btKp75o88vHwvGinl0/NAX7ViVcCQgvSHY3+dt7eXG+N1s8ySMKGc8HH3n7DMKwjUwdIuEtGQ2bN7jn26lG/SUeoPGPu2HzQORjggK1bT2TrZ+cRaOPzaP2FBsOJq9MRy9pRDLH1qZFWZU4rqETRTKEgRJWKpUeni1x9dk6paEw8M+8/+64k98rfgGMi6PPNUrXHqLFejTxVcEHBX+1+LMEDj0f4uQjvds0dI9OG0m7DWhPZ2J5Rqxaw6jHf+tLKI6rGznNHMDZYUVrK8M79kRRYPeqV6/ou7RIgDOEg9V/1NGwX+tB10LLJoFvHle1GYz1pbIjGhDgNbpZgQDrK06jvrg0SDNKiLd3YgoGJwb2xIgMGASNBacfYD1GYspvWVijWxDVZnxyyZeumoVl13vX1+0xHGEVdYWwFe8P/h+LjWJfPnPL/LAj76AtdV//Ml8xUT9aSAljz0FR2uxMO2+JjRVRZwzDd0eenEtbNnnHwnVNab/tI2Dd2QgZAZKvYZLV4GIO9mCLoOp3N8QFr3QOssXQU486EVUjOBF2kNIOKzQky3jTgp97+W8303bzBjaztXonTrEYNGhc5pM4YvDL+JtBxooOQAfbVrO6UEUFKNJT7YZd4p/A8DuXAnFJvbXjSTvU+goMoXs9P1pYrLjd+RMGhkhmJNTGxWvZ6XSw3V7b2LN3KfD1tWPhKIXvkbx0x60feUTHrofjG4Gd5rW3ybQ6bT4dWz+dt2ZJJt6SUjvpmFpEhkbRz+RiaqBUTswWWhxKnJskIWCrqH3hJ/SFA4vVszB/lIciRwbcT/X5Uuo+ZzB6uzgHaWDIQk630w8zAaPjQpveI3ohkNd2k2NMJO0reF9z4YooDlMvkXn8aZOcmYG9ZcXItldQaPmhmAeXTRd19B37qf6r2UcsZXSOU3j+tPCmzzXNhXT82wmyTvWU/fXMqodxXSV6lx3xid++z1zYD5iuYO/3/BHAAplCbvov9D52A1O3UKTmtLfjfstZzxmQSNfbme62X8WXWaVODP3EKFMjPYvltFVHLhdKXKzuND/fti4pxhrrQlPiu87lxxqv6dVNws4j3fUtTZLaGYDb7KGnDCwUJFkHS1WwekTw8JWH7zxXPJelZi9jagtrSBKlD+4gP8X9wDDRWnzZY0vpGwJ28gAkK3R83bKFg1v+sAznbXGSb1mxz1/IJqRl9WKJ12is3dgLDD2xCGF0VJBs0LvVC/dJo3G3mEcSZLB6pQgLcYHUeRooSInecR9xgu1spqct+y81rPKb/vbF01j0/xngx5jEiRWx7byxyCKUgmb6zF3p9O40I4yc/RRI/GIjZy1CtrhSqTSYpQ4a1iNUC0lhRhH6/zSUNWKKgRl9GmKRr1vEu+rn5CC2Cp9r3XnmHA0amHV7EhuHXuzhqBJuFKHHwUzN7gQDx0lpScNXU6h86zAm9OwadQv9zd+JDfkPesrQNdbWtHdbmI9Xl57ZBXnfHk9FlElaUYLxzwp5LwfPclb3eSL9g1GM/tvk1x6VJpbeuIlrKXFGJoHImz9MsnJz6SRMQK9Vy5lWVx4ocmjag/KcaPTJNCvBPWa00qFJ509vVn0fJzG7/NKsQoqy+2HWGgZe+2EYmhcV3E+0/7Qglbuk/k0dANTuxs13jLmvhCRoFlAiddH9IC9f3gqxRnNpMT0cnhKDIwiFVN1SOgmAc0k+HkvPZrs1z1Xihmf0K50xIbcbCfxsdAL4qb5MquXDq9gNBI73PnUexNC7nfUldjfHd0k+isxXVmyg7ft02Br3KiuAUBPTqB7VaCBIQgGsTEu2rMsoAqATMYZC5A+3BbR+fvUsBLPWcgzafNH7EGyrT0Xl2ri6P4MSh4+ftxjvv8mn7mAJ5IW+597jYWkPU6WfaVvceO/yKlUeljfG1hMv6nXZx202uqIFasDml+W2BrZ8oULcfw7+A2snrWQrot6+ELpDr/tOeY2ltkqmGfxV/c50xnL0d5MpJTAZ0cUDTi+3eu1olsNPwOjD8mk9++nOG0IQ27/hIMQs6MW9ZgvfUaQJHZcOLwsLkCiZGeVtYWSTF909Gh7Ih73xEZ1BZNO9zW+/M/EDbVkrdGpinegF/kWaoVxrX73PMDjnUux1JqQe0OPf0V5TZSFMCLCId7ixnv+Isxvb51w6Ul9537Sdvpvqygog/nB9w+GoBuYOtyo1TWYq46S6V1ITYwNIz/yBnjU2EjZpWPbWgkpyXiz48OOpnoy47C6vdCEn6ERWwUdDsuoIiyWFjHsBbE7RUBSJGyGgeQKfZCpS0P0GEge39jSmyliSL46C2ubjmCAtG4vmuKFjk7Su5305uSjlDr9xlRBMFBmDBh1areJmEMm1Gp/lSutuZm0B9r494KFCMcVt8QTJBZm6jV8c7HFF/UxdQe/74dTojL1giEJeHISUFX3yW9kTErYRsykkTECf/3tbyk1jSxH6zF8Xranu+bSeTxuGCu5uStpHwBfX3sz9v0DI8Bj/zwfgDcuqOL1qa+P6rqOqj30Hk9HatbtdJ/eDvqghGxdw9i+F2HlPIwwPEchEXwDwXDoJp8EnydFC7pIGsqRhlTkcjv5GxU0i4DkCW/0N4573bpzJLxxgddjaRewtA8sgHpLjYE0LENHVHQMWRh1bQKAEicx5S81qDUjRzDAp+akm0c3SHiM4Q0kxZD8ij031eSjqb7f2WJVSCkY6AlhEjQkUR+Tmk4wBMHAZFZ96lC5A9s3n5ePtDsJrTVyJRnTu1spOZTL0acSiZM9iEFWBYc35mNuF0itNxCtA4aB7lWQPthGyQcD+4p2O0gSyqISOvWBhZJVkLEIJhRD4+8dS0dMR9vvyqJZjeW2hEN+6SZ3JNRw1e9+y388f1pQZbDEn1VTNiQFzCoqXBxzMMBg6dHdTIlr4VhGIqEQstyE80Qbea6ADMSUPzWgNjaHcbQ/iZK9f6y6tvIsdtRm999vE4E91sO63/0VgLn/ezvZTx2m6KkkDnzL9z16tMBpbPXCjTwhLUHeP3Grr8XJ1Xh+WcvuD80YnhOnrhcJoubr+QEgelT0Hfv6X5Pf38qUmiL2/+eAMp9o1oJ2bdd1Ad0zcE9MfaYLqaUL95yCUV2XuzAFi80CB470P1+pD67Hcv0yGs6VkC3hj2X6KARFejMFNLNM3FElZM2OoBvYaruxvOGLTiq3lKHaBeKrVKyv+OTmBp9BPVZL/j2NHHxgPkiG33equgbu5bh9JjL+MIwjS9co/fKAHJOUEI8ytygqvaDA16NHVHxz+8DnJMBQiz3qRVRM9Gb6jLjEg8GjKS2zLb5zCfQbG4IGscdUTF1R7Ok1yUnHpJExBo6qPfylrSxge7dm5f81Lzj+R/S/4htv/RaW1wfn/o7vQ+pONtFZGHzwMkS45Mp1vFE9HckZ/oSuljqpLQXDEMh7TAo5kOsmgeZ5kUV+HOVmrE2+Xg2GqiKu2Y4+RsPrN7/7E7f96hukPBTayGh+IoOrcyIv0tMMkV+0LBz29bWNRTS1BY9MeNwmXjwwt//vovQWzs4sp+unVvZ+f07Ual/iY12cnxOYMLQ4uRr9XYHtp8Wjdw/tYhIatbqGxjLY+a3lAeF6GKik6M0U6P3mgv7tOW93Ymzf67dv1XfmoU5zAjqLPr6tf/sXZ23gRynhp6+1KLH8omUeP0nZPWztQigkQef7yXsxCYG9bs7ZdQOtHePfA6f83gyKfp8Km3aP+hxPFb7P7xMK+NPOM6J2XZGw8/sPwPfhmZ54Hi31NXjc8tQciqadGKWyU534bYF9XwajHaqg9OaK/r9bbimj64zAyIZ9h42s3wwsiA2A/NyA/SLBkxGLHDcTNuzq3xb3xAYS9k7n8PfDm2s0r+Tn5IsEd7KAEmMmZdfIBqOlstkv2pDyl9ACAIaq9tfvtH6ljM6zXKhumdKbR6fjqnV0Iq7ZhXH63DE50fpIef8oRpyDo5cMSNjGVwYv/HbUKzhCiNCl7PZ9h65UE10FvjE0dYcnKulWE8pkJCNiJo2MceSZN1di6wz+wFd+WMCUui9x+My/jXiOOffeTs4r/h5R29HdYcknS5v3I08vxps0erWXimtFymYexCYNL5EZTufm4RAEg8qrIettE9aW4O/hSZTpyh+dYdCwPJb4rCXYXvR5lEb7nXjjZX597wPMN4v87Qe/o+678bzZOZv9CydGbUMxJF45MgsANQKJyaqWJGraE1AVidxRjlfGgcOUfj+Dg79KRRAMijOamRk//KwiCgamVx24f1CEsG7nsPsFQ4qLo/7GWX4etHCoPz2exKzFWF4LXXj7RPki3m2YxkVZu0dVVP9Z55b4cr6wck/A9h/WXkjrtfEc/GXyuEvJX+ZowXHYw58WLBnnd/r003THcjpmBY5jGWtE4p7wV61Ke3IP6S8FGTtdbj9XlzhrGt7ksauMaTYZcflchPW7+hdc7swYXlvxey5edzvGcHJ3NTZfI8sxrtF0MzTPs9A9TQEx8GTT/68dtSZyKezBpD69h7RXbKAb4+wujAy9vIK8h3xrD8/CKSH2Dg9rq4Kl0zfmnnIGxiSjYtLIGIHr/993uP6ut3ydf4ew1+tis3vkYsjkuU207EzD0h44EKpTnXxr3nsjHj/rvtvJe7kB7VAFcnYW+3/Q5xlKIetDhs0H78PweBCr67F4UvBkRp6TX3GtyMLplRQ5RvYSftBQgmcUDbv6kO0qhjjCrSgQ8aKzD80C3Tky2tXL6MoTyfnzToQIv5O2aRamr97PMqvP0Jljlphj9jDL/CGXvPQVMq6v8csdFmSZ8nsXcXrK3uFOGRFtioNtzTko3sgfV10T0TURA6g5x0zmupELGkWvhvlwPeqgFCBDVX0h/r+mU3GVhDlbG9HoBJgTX8sGc1ZYqT19yIX5tC/JRBk5QzEomgU6C0zEX+QzNBq/sRx3lhp0gFO8Ml1uS39644lCMTS+VH02Xc5TS0/XLpoDiucB8mztNKWMzXsdLhbBxEV2N//vqTRsb8XwROtyrl8x4El/cvciTLWhI5+m5W1MiYs8hSwUh+5fSkJ+x7Cvd3XbKV49fO1RNCh8wUkJt3HohsDeTYqh8UJvEvv/M5mUjBYWxrfh1kwcrEvv36dpsRXVUtZfMwX4opNhRCgNkxSV1B1DEHyKd8f/brmljOIbyymWbfz3glf79/v7seW0PZMDQE8eSE6BSHoUDv/+YJj8hRjAF4GPW2tFS3IgzvDvxWQcOByyT9Bgwv1OQ59Iw7K/Fu+UzLAK7IfDeqSJqhvzsSwbiK5mxdVx7PlCkveMLQ1Q0EHwTloXnyUmjYwRSH5kPeu+WBTUyKhV4zjsTg9y1ABnZ5bzxOEUaA984Esym7gjoSbIUdCi9XLW1q+Q9/ABtNY2pKlTqD0/jetXDhQQP25eRn7vYixvjOy51drbkZITcKf4VunWViVkyowhCzQuMnPO3J2kW4bviuzRZY70pNDcHju8RylMuvNEBE0OkFNUYiU8sWObrBQHdEwR8c5y0nPeLOLWV2E0tGARfef1pjmChpjrTrOgxOjYijt4ovCDgNdz5Bi2LHqCS6znwOCGfILIFSs3hVyIh0OjJ46qnqQxp9MIgFHgor3FTnyVgLkjcBKUXCpySzdqQxA5WcNAfm8ryQVlHElNZk587ZiuZyhyYT49M9P7Q+mjQYmB9hITmfNn0jnfM2LetlnWmGM/yi5neD0ghrLV42X15lvJNwI9+uGio7OpOn/Mz87Jgl304kmxARMT3QPYMO/fFB35GoJX4I2a6f3bTRW2ETso9zFSI7tIsYoKs2zHePv26/jV+Y9zdczwXcCPKD1c+fXvAZD1ps+RFG2E9TuZ0j2NOaXX+W0vSmzjx3mvsMuZx+pFA44ql2aifXCEN6mLpvQ4ZPcy4p7aGHbqhpyRjjpM08+x0j5L55mi9wCR1bGt/ds7Mnfwh/wcct/1osT4ZGqjid5uRoj3oveYMLf6lNsSy72odhPY/T1g1s4MOG5kGLqO1jhxkvJqQyOmuBgwyehWGSU+PAeGqOjI3R4OrY7HXp/L/Iv38a+CD/32KS37IkrMgAcofdMpmO40VibTpSJm0sgIwZG2FPbnOgNkLMPFsOioDhFBF5Bc4E3wdcVNMAfmtdarPTTrMtvcheR8qQEhPhY5LpZjF6ZxyRf9FYpWL9nAa+kzydqf59dJVbBYkJL8C0jd+Um0l4iIKph6xZCt6lW7yJJLd1Noa0ExpIAuoy7NhGJItHkd7D6WHeE3Ehz3PCfo9gAjw5ki4U6JwkLAALXXRP1VHizt2UgfboP2dgDEuLkwSIXLEKA738pvbvgrF9lHr8seDSq6kznalBR6xzBxLXIiu2zYGgMX4HJz14j52QDJj66nckoZBJFmHS1SXBztSzLHZGD0oVng2HnxCL0ammQgycFv9liLhyscbex15YRMmZIEnfgheqhPtS+l6Jaj/b0mhnKoNZUMazcJprE3josWaqcZ0dvj9/i/2pvDZY5aYsSxRVOOqj3s6c4a2wWOkoorH+Li8s9R9UZh/7ZwJzZtfSKHz+0lNaUn9M4jYBUVcsxtXBvbzrXffSDk/sWmGHb8wLffHNPt5D7RG9y4HyP6ngNkXj7wt5ScRMPnSnnhO4E1XzZJ4cyMQ/4bM8A11cT+LYUIqobR2o7WNbzjCcA7NStqBch9iDYbumt4las7Emo44/rfcseab0T1ffuw10g4DTOxVRKp20f25rtLBpyPkkdD7OgcUQhASk+DpPiA7UJXL2pt5KlYfSqTUkoy0lRfZFE3i0EdabpJ6FegNCSB/df/MajEfo/u5kfzX6N8uk9GWDcE1m1fGrZoyySfXSaNjBCkXXaAK372HQ58NfTEEYy+TqzlPWnsfW0q2/7jd8NO6Odv+yr6+uMGwi1w2he2kWTqZT7BvVwX5e+l41k7h5ZK/Qoc+qLpHLlj6J4amteDfb+Fllnh5R1tfmE237vtN+z2ZgZ4ez+sm0JX96nVgUfyQtGTOhU3yAy1soT1/nUDksPBR09/eEo0YBwNscc0hE92BGw/UfnA9TfOGlWK1EhM/d7uQYXfYyNR7uWuxCoGdyJc6KjirZuvI/O364N6mzIu389rDy5h9bKJ7wI9HNO+t9+vGN9QvPxjai6Hd6bz36n7RjgyNGet+Tr5j4rDtdv41LPIXskF9tGlkuz6zgMUL/gSU26IvpExlCN3T+WqiyITo7BJCgue9Rkfrz2yirQ/jm8juKEYgoB32XQsWw6NuJ9d0GiZM343YM57BqauyH5jzSKhrZiF/OGOoCp0APt/nk/lJQ8HbF+87WqSLh7NlR5/75ZWhBZftEdYNR/DFGhkdJSYURzQW6BSednjDJX47uNP7bMDZL4/k+gw7gVnQ9/vFOczaWQ03rEUyWLFUacT+/SGkPsX/nIbZ67/Kh/8NXAgCIen315JyS/2kefextUPX8SCd5u4J82n8NKpu1j2yLfB8HUddeVoXFzm6zMQJ4f2ojtkD+WPLuxv7SxIOlKQO1Mya7hm+zxBpgrriPrxmhU++sqvSZMclJrauWxQTcaiTV+ccJ38aFLwjEDNORYc08tI/XPgAlA7YwEPPHYfliAqQBPNa9Uz6Y1AsStcaq5ScUxd7qcGc+iPSzG1ixT8OPA7kXOyOXZVfv/f5k54fEPZsAto3RDYeWkeUm1kRd/RQFQgZY8XdfFUlFgj6HxwzYyt/DBlKybBzA9TdvCn9qm0qcNbOYed6czYv9Jvm7vHgl2GhrvKyP7nQbSW1oDjpn17L6//x0ouvHUtmiHyv60zuSlhS4CE7acJUTHI+aeJ6ssJ3hgzQqZmNfLUlBeAkRc4ew/kMuPZOqqvmvhoyuqEjZSarAw2QiNl2xkP8OsdS9g8b+KkgUfDqps2031DLI2uWLQzx1bwfCqRulNBHEMtgb5qDqZdVWjHo+d9FGyy8UzWfYB/kfzLvXbOyi6naUOs3/aNr80m9/9FbuSJn+zi8AMLOW+Bb92hGyLrn5+LYEDK2XWsmf4EfZ3hB+MxFH7dOpunDi9EUY7LpFsULs6PTr3hJJ9+PpNGhmYGzL6mOfoNx5s8vbDbr3h3MLrbjW1DOcvvvpV3f3MfdtHMYksnceIOXu2aF/L9BNUnMQeA28267yxhZcJyXEkibYtVHMejwM4ZbhYUHQ3LuOjDJGismnaILbV5IQuDxePqGJ5sBa3FhKVtGENDgDTJt+iSBBFp0OR5/5yn8B5Pn6rwpnHvjnP9DrXZPcxKbWBzdT4nI6JXx5B9YeJgmPdUc8MPvsPHv/7TqDuzG6rC9u8vQPjP5jE1+dIMYVzy9fMzW5GzdQ7PG+jUtaTwEE7VzN5/zQcDSr+6H9dZs3EnSWhmwV9O1gBrnczj68pYvdzf0NjXlUHHz/Mw1e4Y1nM3HtgbDCxdOoJhIKgGuiSStsVA3ROocPPq+lW8ELMK3QL7b3mAq+N28b6zgHK3f0fhja0FtDlt6LoY8GwJsk5vsW8RbbqilLS1LWj7/T2tem8vma/V8EHbCtz/4esb8txfzsJ9ejePLHyMG96/DXODCTXX42ukFwFai4UpT7qpuFP0K0gNhtprYupf3Oi9waM6H313OYu/MYvNC56J7BoMnSsOX4hXk0AwqL5owPkgjtKrPxRZ0MNK5frNWU/xm/xz4cPI3+Po1myapzq4tGB09TVmQR+1tHEf8aKNQkszm8kY03lGQppRSsoOndfqV6Fa4bIbIm8SGie7iZPdpJh7eP5f85n2nbpxSfM6WRAVn3TrWAwMAF0S0UpykOvsqMdqEUxmrO8m8l8ZzxEv+pwOiqHxeLdvDGpU4jEJWkCTyYKzqjg4dT6GLlB68x4MZeQu31JyEgf/4JuLlxYeJtXsSwvUDQFDgnkX7+NbmW+TKAUaGMfUHl7qmc4L1XPweuT+ucjtNvFmzXTiT/1ygUkmgM+kkdGHZoGebN/k4Fg2DcuemmGLtLSOTmKf2czMM+7sl7Izx3u4aurICiGPb1xGzhb/Acr07lZsBXnIM9PxJPom5t4SLzPz65kWG/mAnWdrpyU5hmOd8bjC8HzLNhU1UUAwZMxBlK9G4gybTl8Mr958kANT/RdmfXK2m4nMyBArbNibJmbUchwViGkIvgDWWlpJeMmN/mud4ULHITEMTO9upe2u0tFfZJQRBIPslA4AimJbybR2sjS5KmC/OfG16IbAxhWL6SwwocQG7EJviZeM7HYsksbKmPL+7e91zWD74XxKXBNX+AtgbTGwtWnIvf6/qa15ZE+6bhaZPfd6LinYQ70nnkaX/4et74wbNmonigZijO/87TMlEg7HIu0HMTaWiu/N8t9XFXC8nAxA1hvV1On5fMt+DY5DPsvNq0duSIoeEWHDLhJmLKN1mYrsCPyspn127I0GssvA2Dx8bwzT21uQ0paxRLiKTfOfDev92zUnf+mYy4H6NAxd9EWMMt1+91lLjwO3K7LeNoMpzmjmwrTQPT1+2DiH8p60URvkljaBnq7Rya2WxRwiSYxO/cFsaw2//vkVFPy/rSEXj5Ei5+fiTfLVvFlbVZTYsUVMLKLKdbO2sN06UAeDKCHnZeOJQp+GwQiGgbm2E93jIX29wMLCq9m6MDKDeDTILl/HbnNndMYzNcaMZD9uMIsC/yp+iRgxhqNqDzWqHQ0ppJjMgsQaFiTWoBgSb96xHEGDtC29ASm/ANL0Eo5emsp1s9awqzObLq+Vbd4B9Td3is4NaetZaAn+jB5TbbxcPzcgNdrQRbp6bMR/CoqSI0UwDIQJ/NwT+V7jxWfayBhM4yILmWo2Jq8SENLsR9covXXTwN9LZvPGj32KJmdkHQ5QE3q3bipTnlARPwo0RNzFqb76CMFXDH7GrIMBXotIWJBYQ4/XEpaRASDHKCgmHcllQRplbXOmHMPvM/2bB21wa9yx9zqsNi8etynsiT95j4GtaezpFeGQdMCDpaF7+BoETeNXLXP5RtKWoB6ePnp0N/e1zQUt+JlajiVwODGVKY7oS2RGgiDq2KwKK1LDU7ARBYPqC8xY2n1dWQfjTtO5buEmfpG+K+C4LU4XUrtM/Qozecey0Ooao75YGoxggOSG2Fp1VJ5G0auTdr+NZy9YgZbmRTKPLvIiprnpyrORmp0FgsDBm/0lQ990Wrj3pusQ1+3GSEogvlqh5ePUgR08ErqsB+2kHAxdE5A0n4pP8qPrcacux50SuGjMeb837D4l8f/agFq3kP/9g0+O847E3cNGENo1J++7Mnhk94rAFwWj/z7bLOZzTI/HOwp5a4tV4arMrdwc3xD0dY+h8IHL5wF+am0Z9mNjWzQbbomK3pSQct1DOcfWjUWITn3aEouJ3Tf/kUt/fUZ0nxtBwFOU2l/4q9lEerKik5blnJaOrbsHrbUNwSTjLkoNfdBoaGjG8HqJe3IDnq7FECRz2SSAM0vH1iBGRfVI7jVw1EV5TjLJiHY7xvE5o11zstmdxXZnZE45k6BxyU2+SNSzGSspbi3uL/gGkAvyqDs7lUuvXUuzN4aDDWnomr8xLGa4SRCdBHOmHVN7WOecQ0VjSsBrk0wSCZOdqAZRv8xG19mlCPKA7SXIMoLF4vevn027SbmknJRLytnamodLM/n9S7qxPaiBgSD0lVBgiHD1BWvHZGD0IQpGyNSJwcgWDWWqk2j1I1MMjf87dgHp/9HIeXkHEEQj7AbThuj7FyyJPoKPFBmC4Ps3BN3tZt1cM3/pmItiDBPxMHSe78nhozm2gVS4IZTeuokd706L6iWPBofNyyURpoJce+5aPEn+M7UhwmNXPBDUwAD4UcoB/v35P6BLUH1tLmJ+dtDvN1oIGiTv8Yw5lSHvTS/mo6P3uAO0n++i8ksFYA5cUF9g9/Dm039FSk6i5eLSAPEFR6WM0W7GYGR16f7XWy2Y2wWO3lAEokT2r9ZR/J0NAf8ibYQov7+V92c7eH+2g+d7cujR3QH/FEPjb52z+M8tnw95vsXJ1czNqEOIYFzq2/eM3MPMtgaX+NYMne0eke88fDPfefjmMRsYAI4jJrasmRZUTe/TRnuJiQu/Flnx93Cs+NUG2s8b34itIQh4FpUgxR6PNBrg1AONsBw5hoqrHkS1n7zeX096DPqsAWm+J7qnRmxgDOWqi9Zy5P85/NYtB7+exUVfWYNTN/P+4akBBkYoflZ/Pn/eddqI+xji+I3tJy19ErYT+e8UZzKSMYTacwym3JaJeLZvgpPfTT1eeDjAFatvCzAerBfVsXfI12kogcWgAO03LsOVHv0HdGXaEQ47UtlaHb72vwB4ZjsxHbAjjTGNeuY/76Tox75Q/95lZgqNfdR9cwmuhaEVfpovOv7mDRbyXxvwHsVXenF3yXQWRXfi96bHQLqv/kD6eGfQ+oEPFiXxl0e+wpGzA7uyz9t0A9nXHgGik3t+sqPLsOm234bMj59nsbD5jt+z6KG7qLkik7RtScjvbQVBQDt9PqbNB4etfYoEUzckHTy5vvuicyp56tbgRcqSIPLM9leY/eo3cFQGDrv2Ognq7OgSKDODPy+WPfYJ06V/Ym4xTwTRKa7+wUK0qeH/fkWOFgqm+cbB5w/NRVOHf47tdg8XHS8oFUcwSr5Vv5T3nlscdZEXc7vAq88sB2D6heWjSl2dZPyxvLGFLyy8mFe2vTnmWphPC1eW7uDox0k0r+jsX5ge7k1l29HxaY4pAMduUEl53YKjfmIyECY5NZk0MoIwJ6GWD16eyiX5e7g58VliRH81mGsffIP7/vJ5Mn43oPIQSXjbEPvFoKKOGHbsYACh/3/AnaqzYNkh/tThG5wucOyn2BSeGo6gDXwPff/NfaIC4xUHWpKDim/4JoTMZ8zE7DtugEkiB38Y058qoqV6qbzS5+md9rsmjMYWTFPz6SyKvGN5H6ZuiDvqn1fbrxkuAEtmIu6t9JP3BOh5KZtnpj4EBHq5n5r/KN9988qQCivFjxzlzZqVXHBndDyHkZKZ3MmcpNGpwCwpO8j6g8U4Dvo+v00Iz9vf1w3aEMGZbiJuyezjfwtoc6YgaDpStzugUDpioujkSdum0dFhx7Vo9JK3oYqURzTQjn8WUQP5oD0womcEpq4hQOuXl5D2YnlQdauxMFjXX0pMpPyHvoicluJBjnDw6jMYzio8hDbCsSZBH9G4ACjbeSWtO9Mwj5Ox1WfE7VpTwk7RlzpmmAyuPfsTAJ7atxDh6ED9xjdWbyBNOnXV9k5JDAOtuZULrr0ZRHD9oJO1c54/0VcVGbrBn9pn49ajc++IgoFD9jA0MXc0dUrTHr4dJVZHzBg5j1oQDBpX6cTtt5Cy++Ry+IwbujGOqRXDvN8pzqSRMQRTu8TrFTN5ZOFjLLOAFETK9Ob4BtZds4sN1uXk/HJkOTlh0Sw8yf6LCyVGOP5fA3nGyI2NxhtBMChKb+GYNQFVFUmJcVEa00S9NwGADVI+R5SBazzb5gnqPSp84ysUfhBoaKn1DVAPot1O6ktzAIjdfHSgyZAgkPHykqChV6OxBb27G6m6kfTNFhoXRy7n6k0wMCQB+cDw+faq3YQ5PxupodmnLW4yc/D+ebww9X7mWYK/50yzjfuLnuGcB+9m2t170J3BF6dqzTHS35d51b4KgPnX7w6ZGqcYEm/+YzndM73I9rEVHdpkZdQN4YocLWyx5RHMyAoXd5IIUxzYG3zeLs3mG3IMWcRUVIBaUTXqc0cTU5eGuVti+HZfoanpiuf7jfM4OzZQ3lFH5BdHLsTUHiIid7zOJBwMAdzJAoJp/Ba5UkkR9edlIGT77qGxTBhJprFHsJrbY7FGKFYRiuR9KopDpCt/YFwzdw5qzikKPLl7EQDSMSvmjoHXhmvGeFJhGFgqW/DmJKGbPyWpYLqGuMaXTaBnLGPqnNv6X8r50EtHsRlP4smZzuPKtNF00SLa1HX9QinRIEbycPQnZQAkTo2stgh8KWgz37mNnB0annhfcbc2ZeQRUY7z0jVXx51mJue9kR2t7VPNCDokHAqyTnBINJZa4KOIL3uSk5xTzsjweDwsXbqUnTt3sn37dubNmxfV80tuAXenhRXWkcOwj+at5UuXCdT9cvh95MJ8mmbH4koLPthpdoOrioPnt483JrOK1awgCAaLko6yKOlo0P32u7LYz4D2fIFpA/myub9RnWbofOnoGUy7rxd95/5h3093Ovt7kvgtmw2DmGc3Bj/m+H+15mbMG52Yps1FjQk/CqTaQUnUMMTQE6s3zYHFMJBjY2hblkn5JX/CJIxs1BSbYjh8yYNc8l/nwDBGBoBaUUX6fVUAfLRgIfGJwRdbHkXG6zFh6FBy/yZ6f7kYxmhknGgUBxiCiH1I/a5mlTGyExErqnA0aPRkSahhCvxIHjA5T67FncWqYBgCH9SVYMoOvnA4Vp6GdYT+NCcj3pwEelZEYKQaAhtbC5iXeAyLOPp7N8/SSoLoZXB3v8e7k9G6o29QOQ60oKTH0ZUfvIBb0MEWRAr5VEKtOorJbkW3mJCdY6s/Goo7USQpIx2tvSOq5w2X2Kc3EPu0/zYptwwlZmCMMPWcPM+dO1HiC5dFLh8cCpukcOUVA+c93Bt+Ef4xtYdfNZ5N0b8AQ8XcCbpkpnNKiPe0e5iSU4u70ER9fQHeIGqEfShzelF6zMhBFOc88QLK9BPrcJ1kfDjljIzvfe97ZGVlsXPn+DT6cmeq3L7sgzGfR7BYOHZZNtpI61RdoEezEDPWYogIEUSd3MQOFidXR3zsP9qXcWPiBgplEcXQOKzqNJ3hwfAMb2BEA8OrkLLXRdN8G7oMCAQvWBcGjBBvvgfZrEFneAsET3oMbTOSef17/4dpmGZ8TVqvn/dSAQjDiOH4flMe1tAswRu/WWo70Q7tB12LZibQSY/j3xvRr1lGx5Tghr0wJFXI1qyPTx6wDpoqIsmR5eIIok5pShMz4oIrIfVx/ap1PPHRiqip34w3gsWCZpGIpO2srovUv51L+mXdFNhHn8J1VcxhEiX/5+Tnz16No3scFosm3zQoKhBp9kqFaidJUvqdLmNBMTQOKx7Qx+fm0Pb55KZjMxdH9bwdc1TszQXEvzV+c4CohfediA7fPdOTI6AXDxjH+l7/eqZQz58uR34vnIr0GmYUw8uTXXPZ/31/6W0hxHgoSjqLM2rItPqET0xfreK/U/eN+H6PdmbwK8cFwV8cfabqxDHRxdinQqQ0BKeUkfHGG2/w9ttv89xzz/HGG2+c6MsZFikujqO3zQq5n7VF4O3nl/D5q6Lv1RiJFQWVY1Kz+ke7r4HhGzXTSbmknIkofjYUL+JH20nT56ObRJzpJrrzAhelqg20Et9oNZrEgKR9Hq679Vu88/CDQZvxXfa9b2NvHLLAnQ2W7erw0sf4VMrUVXMGakGC4MmOR06cCRtOTHTrRNKwyuD6lcGfg31dGZS/VjLu1xBf6cXRKFN3fWTyoecVHww7Je360z/hmQPzMW8/+bt+19++EOfiU2HmHxtHL0khdadC7tNVVN9QENGx98xaieWNWF4seWvM1/GPrmyemZ4BjD2tbKLpLJLouXkWKTujPxcIhoH48Y6QqWlSchKH7u8TPfG/bweLKahOub9HzXBcdfVHfNw0BX756ZZwvXXjf3D9zM3EBMnRjKv24nhaonZ1cCPj8tJdUU33muTTySljZDQ2NvLVr36VF198Ebs9PF1yj8eDZ1ABY1fX+IfjpKlTqD83Lez9J7KGCODckgMkyKfGwqHqnjKUxCEyqibdVxQrqgguibzXfK/XnCthJHtB8DcurNvsJO+P0Os95Df5UdNs3rl3JQCO5uALUGVmPoKeh+RU0Hf4e3OkxETUGfkjGhjBOO+M7WiGwPuHp0Z03GCqWpLo9Fg5J+tgxMc+vq4MW91xL68G0/95B09e84dhmzcB7PW6uOKpuzGH8ZUrcTKW93IAuCBu+MhkSWwz9ssUtr8y45SIAEwCW96ZQfmiZs7LPhDRcSZB467krcSL0ek9ES5t0020lxSEvb/shKx/7UdzOoERckTGCUGW0ZfMHLie5m60Q+H1wfm00fblMloX6hiigUxoB4FkV3HO8A0k1sNWxCGH3POVf3CmrZm1zYHqamPFUt+F7AweWe9Q7Gz7zfyANYEhwOxv7+zv1h2Kjd9cxOFrTFxdtonYYg8fHhnZQfP0S6eRtNfARuCgLbl1Mp8xk/btCrJs/lLtn00DY6JlZScjGROCYRjcdNNN3HrrrSxatIiqqqqwjvvlL3/Jz372s7Dfp3eqF8El8e//O49/JQq8+e3/I1MO7nH8YeMcPtw2nZwrfAvHmLf3YMwoonV6DErwbJiTgljZHVLBJVxmpjSw7t5lFH93c1AJ2NEgF+RR83nfwlPJ8YzYIE2TdeqXW8j+yEvSbhnNasEbL+CZ4zOibFvtaGaoLwsiGVovkLQ/uNdNVHSmP3kHT1x5Pz+tuozqtwvIqB3ZQ9dXUCmoQVbBonA87SQ0uklCnjONqh+b+HXqwyiGSILJxfP754V1fMD5NBGPMrrHXHKKiH3zjuGT+Lx67df47sK3uTWhNmD/v3elcc/Wi8IqzO3JMdN6gYtrw0jZMwkaebY2Dq5ooXtbcqQfI2yc6SZa54x/7vac7Dp26jlYdk7sQnpCEAyceRrWOom2/cm84J7DFWHWnSXJvZwTs494ceLrHzQzAfoGCUc0zF0aTfN9L2StdSI6fQ+EoGho7e24L17CoV0C05v+w+/YJxc9MqxoRDCurTyLioenksj6EfeTs7MwEmIxBAHNOui5TolFpigsQ8Oxu543/7SSC+4Yu+LdEzsXY24+PvZpYN1fi2dq1ph7KPRmmpAUsLaM7K1o/UoZbXN0pMTwIygCIJl847QrWyWroIXFqQM1iefYWogRbXy34C2+/43Pk3JfFJ9TTUfw+M9pT+1dhHmfDUGHjObgn+OT5+ejS+CZ5uK62VuC7tOHqa4TyZWGSdBINXczN/cYu+uyhu2VYeoRsA3jPMPwiWIceLWUhjMbOCNjeEVAp26m+KlbefKK+1liCcw1u789nxfr54547ZN8+jihRsZPf/rTkEbA5s2bWbduHV1dXfzgBz+I6Pw/+MEPuPvuu/v/7urqIjc3uG50XLWOZjFjbzRI+IdvoD9zxW08uuixgCLw+9vzeXrPQhzVMu3H+xDFfmimJ8dOb+aJKzDb05lFZXtS0NcEUSc5vhcpgvzqUOTZ2kk/cyNrr11K4lvlaK1tYzqfVFJES1l6v4xoqGW5ZNLRil101NmIq1aR3Do9OWZiT/dJ0bbH2fEma0hJgQN3l92KqA6sKmKPqUgu33cj6JD/ukLVpSnsP5hD0cbwJzBDFjFlpKM2jE5j35NsouoSK3uW34dF8KmS2RPXcSQ3hZ01OaM6p6JJlPekURrTFPYx79WXInkC72XbHht/dJzB0cLdAa+9Vj0T667QC0S5x4sumbl2xtawr0cUDM7P2c+THYvo7bZhcsqYO6NbFK/ECBj5Y9GXCo9psY14s2UqdhaN+3uNhfhKFVeqDaMg/O9EAKRED16nDXOniPdIHG9bffK3p2ceDloMvr6lkG6PhaKEVu5OOnm88bYGD+bD9STEFQAg7TiE3tuLlJiIkZeBOHc67aUy9mPAMf9oxo9SL2dOfC0F1hZuiR9ZQvqrNSvY9/w0Mv8+slIhgBHnwJMe6PjSbDJGehzm7tBjj1pzjNSnOnli3nIuXLJjVOpziiHxQV0JliPW/v5Khgh6WiKmFidqgjVsJSslVkIz+4817iQRUTXA8C1R4uZOB8NAbGzzfT5RQj1zHq2LVeTY0ddnyXFeShOa+XziFk7rF4H0/Z8L7B5Ms5/hF9w06vMPxhsvY2r3nVs3BJ7dvwADsG+1kbpj5DkmfZPv9ZYeGy/YQxvuCfsE/p07jy+U7mBabCMN8XFohkCvx4zL6TN+kxN6EASDDmtoIyp9s4eahHSeyh+Qkr9y+g7erJ5O7/Hz6apI4WsK16Z8jZ8seZWb4gbmmxd7Y3i+bh7HmhNDvtckny5OqJFx5513cu211464T0FBAffccw8bNmzAMsQztGjRIlavXs1jjz0W9FiLxRJwzFAEwxf6Tnh9H7FP+adT5V+9m2+8ci1/nvX4caUTH79/+3O+4k0DhL4502wadefsenc86ZauMUcYdh7JxVxnQsvzBBRrmUwaZ2eWj+n8wbCIKmd/7xO2HJwDYzAypMREGs5Jp3tVZIs8Aehe5ULy2LC267hSBC7t+5yXlbO+pZDatviAJmBihpuujEHned9G7DHVr3v0LmceolsEwo/SaFYZfXo2UmNTxGFV1S7ROl3m0A0PMFhVZ7rZzj8KX6es9Yu4XOaItc9dvWY27y3CPc3E1NjGkKo/uiHQtSYd03Afe2M8L29cGfb7G6JPorAPU6eOyTW6e/26WVt40liE3GsjKcpGxqmI7ARjnAqFbS9uIq9zAdVfjfxYIduFV7BibhfpWZeKqELlxe0kmn3Pt24IuDTfPV6zKRtLm8Cm/CTKc17pP0e6JJ6QqMZg1IZGHP/2Ldr7vmUjL4OaC0ZeLFW9UUgVhfQWKdxyycPD7vexG/b9ZhaZz4Y2MEKhmyU807ORmlpCRpb17m5K7tjIJy9NY0VWZUSGhkeXqXEl4vw41c8RpFmg5oJEcv+wDWl6cVhGhm4S6E2XhpGbFfDG+c7RWZQAQOoOBzanC2xWjtysIUcwNg/H2opi2j12TgtSV2MVFJzpJuxNypgyV3SziCtJxNJhQe7woBgSuX+XEVSDSGoaU3Z76G2JpeL2FIocw8vUJj+6npiGxez7fgYz4gYiEPu6MtivZCAIBmdlliMKBk8mhKdClfuOl37XnwD7f5KB6dUE8iv8oyBTbzvIz353Gedf8Lv+bT/ecz3uIKpSpxyThd8Rc0KNjJSUFFJSQhdW3Xfffdxzzz39f9fV1XH++efz9NNPs3Tp0jFdg6hA2h/XDTtUpVxSzo9WfJW6lQPWft+0J/dA0gHfAOGZmYs7MXIrQ9Bg4wtzmHfZvjGpsfRh6haQD1jxzjo16i76OPSf0yB39F7kjnNcFKW3cPqQ9JuylEoqbClsrs4f8fjOs1y4dtvJGBS1WH/3EgqC5KmOF0cv16m88IGgr9lFMzuXPMmCLdfQ3RPZwks+aqXgv9bjATa/XcDKtCNRuNrw8SZC3XUDE9HUrDbOSvjsFbdHG0GH9D9tRItSqmK0EbLcKFmgawK2PTYOvFra/5rkpr+BVy5eerLNGJLE5x/4bv8+i6/Yzd/yJlYUY6L539MuIuZYcAnviSDtsgO89sASVi8fOU1rMNvacml8Z3RR1aG0TTePrMA4hOZ5Zpg3C0MEYQLkiFZYRdb+5gHOuvVW5N7RP2cts0zkvtTgS2ebPzP0ASPgqFdo+O8iMv+3E5s0/PxkeW0znm0ZMEgjZ0ZcQ0gVvLAwoPdn2cQPUwOTuF3mtJg7x/4+k5zynBI1GXl5eX5/x8T4wsXFxcXk5EQ+2OX8eQfyoO7Fo/EDOuoMHPWRqdCMxLbXZ7BvSSsX5o0sATccT72zEnvbyaMFfiKobE6ixWnnc7n+UooF9laSSpy8dWj6iMe7Z7qoTrGQ/9rYDAtDENBXzuv/Wx9lhCsYHyz4OwD/7i7kV9uHkQI8TvHvNMSD1RiaBg4HiW+bybVXhXwPUTA4+/Obef2DRVhbxn5PSW4Q9trxznQGNLIeDZ+fuYPXbDPhQOTNGYejfoUFd4l7VIpkkfLcoXkIO2KJ4m0xbshrdlFalU35/4w+zUFXJNK2jzxWxtR5MffKtJcM/AIbX51N6axCyk/7x6jfeyw0LrUTk72sv78PgPviJbSXhj9t2qtMlD52G+Vf/HP/tnKll393LgAg7d9dVP10MeY3N0fvwiMkY43I49alrF4Q2tjpqx8Ide8evTAed4nPiDR0gcInDD/RBkOElrkWjFE+cIIO5t12XFNHrtuLBpIg8vc//pbL/vC9kGlNQ3FmmPjXL3/DxY9+r3+bWHmMTf+9GFkd/XULOmz56SKErzeN6DRSGxrZdrYvUnHgdwVcPyfwPrM1ilh2VeGZUzDq6/Fdk4H8yR50JXrropMO3WBCi7EnO36fmuhuD3oEMjXyvmqylRxqz/Tl3cYe1bF0aFFVuhEV6NmbxDO9C7h6+rawj1MMiWfXLsXWLgx7PXGxTuak1kfpSiNDXzmPnjz/judJH9egHjteOCwI1PywDDXVO+ab0dBFVC1w1hIFA4sY2nAQRQPNPPBQ151mQXEYWFuF/pzYsBCgdaaVwStqQYOEw2MffPvSRy6JOUL2kidH3PfZ+xez7R9zSHtgHaLDQYG9NeyUvDjZzbTFVew9mIOjYoyC8QaIKkgVNpRc3/eYae7gAsfIuvpv9k7v7zw/GIuokhLbS8eU2Kh8pwC6yYi4P8Zo0TQB8xgzvcxdBhnvNY17FMNQVYweJzC2XGpfWshIbwSmHo2Ew9BZLLH8C9uZ7qinyBx+HVG0CdYrQTcJEfVPEHSQewT+3pWGeNyd1a3n4tR9Tq5sawcVcnScQ6JXw3SgJuJ7QlIMLDVmnuhZ3r9twfwjTIttpMqZzLotA+p2pk6R4bItDQmc+QpV/7kAd7bi61F0nKMXWMlcZ2DuUFHtEt25kq/f0RgQdDAfNeNJH1tdBsCRtmSurjibZ4reC/p6oSmGL9/8OhWuVDY0FhB7b1zQ/QbTsNTCF679iGJTDN+89iWe3nQh5kMVGJo+pqhIH3KvhmeQB6tLtbLrJ/Ow1e4d2Mkw+mslS+/PZm3KMrpzZZ75r18DcMUfvkfeq42gjj31VDeLlD88m+k/Gz6NSy63k/uWT6L58K1SfwH+JJ9eTkkjo6CgAGMCc9UMVUX0DgwK5h4dyRP9h8PcIeCttvOCeQ4AFxbuGzZ/fkdHDpWtSei6iL1WGtG4tpnUMfXFGC3Cwpl0lNpwpfpPouZ52cSYTagVVSCIeKa5kKWTw2I3rDotc3wecneeF9mq0htjprXXQvJef0NDs4nUL/c9Qik7dKytA7+VEif4dSYXdJ9Xy9akBDUGj51pZtXMvYEvDEOa5OAC+8iGzwV5a5lSOJvwBZX9mZdwjPK4NAbXh4wFU7eA1mLGXKiy2FZBsWnkXhGLbRU0m2Pp1S3scvpHMy2ySnu8MOJ3Gi5t0yx4E7SIohiySSM93icwEI4B28fjG8pI3Clhb9boKB6dG9fWbJBQ7kIrn5i0N8PpJPZjGx3LA2u9QqF2m7BXmQgn71xQDSwdKiBxY8onAYIbOctqqd6eHZXoWjjYGwzijkRHCOCwOz0q5xHauzCbZbzJ/sW6slNBbupCbRldyq3sBNk5cD9ujc1nf1w6bqfZN7+EgSGCHKugxioBCwshy03bNDu2JhFBA29cdH5DuVfAq4w9Juh2mdnXlAEjaDHclVgFiVVsSNrAddfcGvKc00ur+Fmqb0y/NaGWf8WIWGNjETLC78QdiqYd6Xw4D87IOIRHl7G8sQV9mLWRsXk35hXzaJ8t9o+93TO8uPckYjlai6W2E29WXMRS6+Aram9cKnLt3E/Y7pjhU240bBiyQM9yJ44NdkSvQUKFF2G9T648aUaZn8GueU+BTAxD9/2byPc7xTkljYyJRkxKoDfLgXx8vhHGMYRlbhdgUzwAuxOziDMHNskB2FuZheOAJWBhZIhElOM6njQujUcJIiHfOlMGIQ17YzOCNBEJKuEjOxRcS70kxff2196QAK5ME53uBOKqFbxxEopNxJMgcNVFvpzx512riK0WETUDc1fgwGCI0J0rIrtkTL0akkdDHCRleP7ndnFf1olLmZgorE0ibW4HVkEjlPHik0F006610agk0Kj4ew+HfqchveVB8CTJdJW5MJm1YSUeB2O2KIiiQYzVE3FtywcNJUx91IWxeTdyRjqu5CI8CeFPrO40HUOA+AoDce2OiN57LOi9vaQ+uJ72RYsgQiNDbpf96pxCYQjgStdxCArgP5C9N+NlpjTdBC0TI/0bf8TVvyA6WVAbGpE8XmSbv0qi1NLtc9qMAlOPjqlX8pNedxywABaiWXbvneXEU2/F2hTdREFBEdAUccK84susEpUjFPOPhJiciDs3egpLuW97qbSn0pZcx/q6AjIZuS9N7el2Kq4cqPurvPARikxfZlptPtq+cqTE2WhWOSIJYiVOon2qxNUX+OZCT1YMtsMtZB4FPcbK4eVWsp48hNbc7Hdc8qP+dUCqMXH1j5NMHJNGRjgIApJbJ3lPiMnS8KlVRSj+4/9Wx1P+DBGOvTV8sfJwrTiUWCNAcvLkiBH440yRkJdO86UUhemGFsTh9zNCFD5oEWTAC6LBJ3OfQRKGHLMEln33VlovcnPNEPnVz3/BN8CG6k7dXioRXykQt68Hfc/AhFDn+nR3lh1My3tZXHbsTioveCSs/RMlO7cnVHJPyywUQ0I3BPRBD1l7qURclYCtOcxJ6vihmlmk4fMePleynx2t2TS1x46o3CUIBsuyq8m0dg67z1B0Q+i/5rgrG9F7fakCakMjqY+2UnvXkoG0OiHI2DFo24dX/YZUycI06x2UPhv2JUQPXfB9P4IRsramb8yJdDmpm0X2X/snTEJwT4koGL7va5wHtYlukhoJWns7bGj33zaG85nf3Ez6wpkcOyd+1OcQjNDDuNH/P2Nn8O9jrxfxOi1ohYFRp5PJN65LAojjUIllCLx9aBrF1+8Y1eEV5/6Vu2YtYv9CAzbsQiybi26VwotoCFC3SuTaswcEGppvc+J2JfjvJokgDnIonqRiFZNEn0kjIwTivBl4Eq2hdwTiq7y4u010Fo5+IIk9qpPw5n6Ofi1yBQpntoaY4gkYWJvbY3nROYfLi05dRR+rzcu2Jf8c9vVz915JbUtC0NcqelPYcjQv6GuRcv731qDoY4++KKl2xOVzEdadXJ7SkxVJEPlRyh4e7Mznt9vOwbrX5nefd+eLdOdZEBVI2TWyM6BxsQXXLBegIwJvH57GjKwGsmI62X40eB8dQTC4bOqukPK/Q3n6g+WU/GA7AIan1+81Q1XJ+u1Asa00rZijl/gbm+qCbrYtfxQdnWuWXYPe1s5UZccJcRxMvcN3r/ZcNp/Gz4fQ9X/BgqVTAz26RaC7T3uEO4vOYP3z49vUK+/JowN1Y5OEJL5CI359DeW/Hj45Uz5k788GGAumQaqOfRgC8JH/cqZ1uhnn0pNHZfHte3/Pkg1fITO4gOComfbHJvSqY1EbE4QNuzBPL8GTEbqTfcvXnVyZ719bd0nBHtY2FVPfOmC0Hvh1FpAFgNFmoeSbGzglmZSwjZhJI+M4NT9ajhIb+INqVoPYKpGUnWGE/A2wdKgkHpL8VFIiwgBDCX8hY0jw85v+hSToJEk9OAQvHbqNWzcOdKA1DOGUvVevmr6NKxO2YBJ0TMLwxt6fS5/AWSLTqjn4uGda//YtbXnUtCdE3FtiKIqh8Winz1AZqXi60NGK93MylW8VjujZMwQBRpH7+lmmP7IUxGtqCIAAuhlaZw54wb0J4E7z95oZdi+yOPAbGoaAKOjk29uIL/alJ35cVdyfPmUyq6zIrYzYwAAQNAHDM8LYMcijpx+pJv/xIYbIqzFckn4bAHLdjhPqATSOq8bEfXCImCOZdE6PpfkiD8Lx50Frt5CxxndPWzrVUaWvSR6dxb/6Or+/60HOsAU+QBbBxH9nvsXjNzTxz3+dO4ZPM0D2Rz3Ix/xrGbSGxqATfOzHh7C25VO/LLxEIk+Sweyyw8O+vu57S3FsPhSFbg9jQ9hfSZ4zm6OXRl4v4KgzMHdpKPmppL4cOEYbIr77JArCPLZmA0ejGnAewSBAiSfxsIKj0YohQNNFHkTxxE6CMaIVWY7+Ly2oWv+zORqmfHgTU36nAccbrBoGRy9NIeGMBrrcFlKHdDx3J8sIN/tSn1Yl12IS/D/T+/WldPb6Px/ioJpLPclDxa/KmPLT7eju4Ongk3x6+EwbGXJuDs1n+zyXrmIPsiVwAJCAbsGCarUgGL7OlyMNlIJqYOpSiakV6M0UI27Q50kQcJ02I6x9TT2QcETh0jvaMQl9Ro2Zdq07sjcdA4oh8foTy8mrq2DoEszRqNEjSahDUqitrQbWzoEFhH2HjZ5pXmS7/xkumrqHaxM3McccOpI03ex7kx69G6voGyzvqz2Huq44vJ6xFS63a042ehI55g3eTX0wNklhTnwth+alIu6LQRoyhtobDExRUBaJFMOr8Oo/VzLryv0jNnEazMtVs9DqT2wztKEssx3B5jgNhskWNwT87jdd9uVs97+e4kUOUldQ05XIrmPZmPfZ+fwX1lCS3ox6PAXPLGmkW7oCjgmHuKltNN25nLQ/htHN2eMJ9J4fAzl8PYAJQWttQ3R7sCdOw77N1j/Gyb1ga4pM4jMAA5L3eujQ7UBP0F1y5Bi+lLCDjy4owfWrLDqKzUFrv8KlN9tGXLsN7eDwxkAfWmsbpgMyaZY8muaP3FzMmaWTWNQWtC9BszeG9U/PJ3vtDjTnxHjb5fxcDNMwU353L0ZlDRkbY2lcZA1bWtbeYGBr8xmUmlXG1hQkZVEA23bbqOVq+7A1G9jaNCRXeOm1kkvHdnxfx3Yb3dMUZEfwlMrE+F6uyg9f1fFkwVLfhdHeEfb+GRs8lCTchiHAruv+wJyPbyH7CTPG5k1++3kSDc7IOESXauXVyxb6vWbYNVYfb+4XjF6PGVUZ/scWJQPyXDTfMJ/0N0+xiOGkhG3EfGaNDDknm45l2bSf54vfjvRFSCkevCm+W6unzoa9UUFUhv/xBR0cdQreGDOqQ4hIqs+TIOBJCL0oNvVA3FEV65p96OgQQhtH10Vq3QlRV5lSdZHs329BHeJJkRITsTV6UG1WP5k9AHuzhqn7+ELbgLRtHnrzZThuZAiCQW5qO99P/ZBMeWQFoqHEiFZOO26TPChGZzHfpuus7SkNveNxRMHgqqnbebxzGVK3hOQSsNf7FrqOhsB7x/O5xSyMGd+GXIbiJfO369hQtBT3HDlkQ6bnDs3D2B+DrffkirYstJiJt7voJLz8cZ9qzsD95zSbUC06SAaydcCoba1IJPaIRHyVCl/wKWtFgwvz9vHJZUXwx9EdLyUnYeRm+G0TmztQa+uicHVjJ3X7GI2KYfhr3Upy815moSX4Qj5NcvBK6atcsulsnOnTUGKD36eaDdzpKo6q4QfhjikSCMnE9zjD+l61xiYsn/Riz/SpAHoSBT+xDXeab2GbWNQW0LMH4HBvKhv3FVN677pR9WgajLF8LoYp0JNl2lmB1tEJooQU7xNMULKT0KzBvwdzmw3Bq2DeWYkjeyr6cVldXQZ3iv93K2j0pz0FG88CL9I3xrfOtAQ4nMLF1AOORjVsA2Moqds9KDEW3DkENTQUVaLWE72C7OGYktRC5fQSn/pSNKhtROsK3wEiv7+VovcBUeLLyy+g+D4dNmwK2M9RK/Bu3VTOyTrI9ad/Ep1rHULnWS6s7TnEG8ZJM55NEn0+k0aGYLFQf0ke3asiSxAVgLYLXAivWbE3hpbNTCz30jHFjDdumB4WAqPWCk885MX8/g6whCclpSoSayuK+fz0HQHhzdGiGwLN3hhgkLteEBBtNjzzfVqAjjoFRxjjh6D5ikpFUcdiVXhvxstAZAbGUJ4o/IA7zUt5p2JqWMpBY0U3BL8C86sX+9SiXq+aQcKaQbPr8cJVQwA5MZG/PPh7Sk3DlfKPHo8ReI+W3LmRPb8oI+e8DuJk/zCLR5fpUq2oukTBF4/QevVcnNFR3jxpsNdIgITqMFCLNQTBwDAEct43UOw6p/0s/M7H441gMtO7fIpft3SA+PfySX700z0p9/4sm1vvvoG18x/HIvg7XZy6lzbd61ugh5B4dOd4ef2c+7jqz98Zcb+OYgl3Qj7Jj4T3veq9vSQ+5rtXuq9ZRk+277k3RFi1Yi9mUSVG8l9ItikONENg09YSSr8RHadC3P/WMi22MWD7xm8uQvx4B1J8XP9YPBLeJBskFSEYBgnPbOtPv5EzM6i5buB4QwRzt0HCocjSczSLiG4KnO/CyUAUtOM1GGN06mat8dC0wIJzruqfvqMJKOuTOPTPNBhngb/np7zD37++k3/efkl0Tmg2+QqqI02j1DXaV7QBbUFfTr9vHa7qJfCzyE6rGFJEqcmNV3pwJeeT+lgruCfVpT6NfCaNjIqfzEEqGn0FWutFbpxb7WF58RIOe7HUd6HtDwwvyoX5VF+dPapraJpvxp61mORnT1wx91vHppFy6SG/3GWpuIBjl2VG7OEseFmhYamNrHNqeGf6K1G7xj9mb+TFhL18d/MXonbO4djRkcOh+uCFjzVfHJhN4z62kVjupSfPytqn30MSom9gAJy/9yqSdwfOzIU/XM/2LUs5/Sf+KTwvvrOMov88XpB3qhbxhIncKyDtseGd7cR8wEbnTe1clH9y5SXVfmsRrnnR6ZJ+KtKzOYVrYi/mxZK3/LYvXH8zeVfv8f1hjKz05Thk5qrDIxsYYyX26Q0Mztaqu9f3i9X8V1m/6hxA1epstEMVlBjjG7XsQy7Iw1OQHNExhiCgrpyFeUclWns7an0Dmb8diHpKpcV4chIiO6cI8+7ZHmB0ATz7ykpMPcPf4ZIbUnZHL1qWts2Ds85Cy8UDDpas583YX1gH2VlRe5+Jov7aqaTsdiF+tP1EXwq6IfDCgbkR1z92neGia8oC8r778ThdWRSZLPyOmM+kkRGNWbtntgdPkpmc90b26FgP1qM1DtO1dow3kCtFoOmGOVz+uVy++OxbXBvbHvKYVytmsjynatQ55n089c5KpjzVRdOty/y267IvPayvoR2AudMgrjq6KjPjRUpiN0/MeAxJCD+K8lLlbHRdQBshWjL4lmtfotA+X0SKdQfK5EYBzdBZsfNq2rvteM9U6cleTvb/+hsUMW/tYcvRudT8YJBHL8vNofuXgA6l391ByvN7ca6YSsuc6DTjixZzk+t4Iz8FR/XYhi9BB9N+O3lnVjMtvjHsbuiRsij5KNveDVQ3cyom4i6qCuqFrPxlGWqmJ2gSZOsKBWfGcnL/J3Sdx6nOgcY0FnZd7bdNU0Wqfr6Mgh+vp/WrZXjiQwzo4zhPL9/pZaq1nh+9cg3F3/E30AsePMi2pwfkrPXK6qgtGqSUZDxPOSiOORr0ddvP6zm4ppCc9yMfd4eTLhXnzUCJj6wJU2+miYxbKoMaGADLz93Dh9umj/lZHgvCBC/kro45RsJDT/OHO68NnWo2Ai2zLegWaJpvIzZ1KY5/R9d4tXQovHDElxJ4QcF+bNLwkYZmbwxra4pGLbAyRl2WSU5iPpNGhhanIo3xo0tmDdUeeoAwPB4MNTAmLM0opX1O6ELiEc8tgRIjoO8+SJduA3xGRoxo4bvz3+b3e89C8fp/zlunrWWurZo4wUOrbueD7vCKzAezrT0XLVaj9qx4evN9CyRrg8TgxseDc5S98QLdeWZij4484TnzVb6e917E1xOKBZYGbpmzhr/sWhVy326XlXvqL+j/+/rU9RQEuVXq3fEc7PBFLTxuU0SDq2xVwQqSrHHz0ZU8kPtBQErIWGnvtqNrIrJNRYkLPLeQk0nt6XF4PQNFp6JkQJJvMVB/+0IEbfTpfOOJTfQixKg4swW/bsTOPI0LlgSXBFZ0iXUvzg1IHxO9kGbrHnYRFA0sokpZSmXgNRkSz/3fMqb+viag+FFJ1JDNwVMgZKuKN4y6rU8DmirR1R2YyK8m+n5Ib6ww5oLiPpQYAfclS7C+unlYY6D+28vxLBkoSH8m+SHiRRsNn3uTP+ee1r+9+GdutH3lMMoO3CGRpKD3VB9z4mvZE1sw6tMb+ZlIZpOfg0y3yuhS+E6R1pkWnCt6OCd++BS0bGsHpVPrKLdm4DjoX39j6gZHU/RFMiydGo4NdnqWOUl5zUrsznpUQG/vYPZvb+fFr/9ff0fs8cAumrnE3sX9322i929ZOOojSxPSzSLd2TK6xbc41yzQkykhX7QYy2tRzPfSjH7RlHVNhUiCQZq926+eb1t7Ll0eK15NGrPAyimBwQRHMiburcaLk3AJMf7INpVofHTdqtNZaCa+Mvji2dzqBG/wAcSTGUtX/ti92IYI4syp/N/2uSQseoGrYzoxCRK3xNexPqeabsXf83RLwuHjC1oLnXoPDWod5e4MtBAyWIohUe30GUU1HQnIcV7c8739nlav24roFRBVXyrKYDQLuJMFzD0ylvZA+cE+rMkuLnVEX2klT47hS/G7+AuhjQyP28THFVP8ts2LreFwr7+0Y0NvHI1t/h2oI0VTJT6umMKTCeVc7KgkRRpb2lSl0sM2TxYaI0sWS1On0LwiFdfC4b9r52Lfa3qjFVtDdKMtziydqQX1YzqHJOvoSV6o9alMOXM1Fs09zAPZwfXXNUNn+pwpSAcdSFHQ6o8GJkHj2nM+4fUjK3E05mBt8vR38o7fJ9M5A+S4kzMCKFgtdBYdH/s+BRMh+MaptmkyWa+JYAQubruvXcbCq3bzt7w1g7b67r+7Equ4a1VV/9apq28j7kgZtlYN20uBhbVjxuPh8Y3LuGzRdg53p9LuDlRbk1wCniTfPGdpi0x+2Ztkw9IbA8eNDCk9DTUCAwPAmWVw9bTQaTyLk6vp9FjpOeifaiq7jIivOxwkl07yXg+q3U7Su4dRG5uQs7PoWppLQoXGDk8W6VITMWJ4/bFGdQ2CyHszXqbwzK+Qss5MXFV4z7lmFfEkSAHF+Kod2qaayHxtPK4WWtp9CYEuRcYsDTwbR9sT8bjHblzoNh1t1VxY89KYzzXJycVn0siIFnK8l7bTReIrh6hvGAaComPsPYQeJIoRTQwRai5KovSbh/j+z69h9ud+3y/n6j8Z9jEwIMSLNq6Naea3SgI7u3Jxa/63Q5ats79IvEu1sbV6+IZ2QpYbA/D0mpAqTQytLddlX3Flyh7dTz9/LOHiieDjiil8zJTQO46B/9l2IVlLHuc8++gK31q0XnTg8c5FPLZnWcj9685Lo7csPGPOEH0RsyhpBQCwbNFBnij8YNTHe3QTuj7wzKkOg+tXruOetN3DHiMJIuWnP0ZR69eOF3+fPFz4tbUAPLFjCSW+/0v6fevQvrcc97zAxYemiFhOsOqXEBdLx1ku7M+YkXs0BB10k4A3fuQpxdylIXrHqqkEhmggpSRHtaWzIfr6rAQgCMj5ufzknr9xgT28iNfBL/0ZgLvqF3FoRy5qdU10LlKUECQJvdfF1Dt3svfNTI7sy8J+LPCetuAbcwUdUnp0MAwEzQgpWBKAIOCdkRNeB+hTBEEzyP7VOkhNRc7MoPWMPM75rk9Fabszn2JTMzPN2iBp+PGh8sJHKHV8EfMLA0aipc1fsEM3DXzvzlSZ3mwhquNxJHR129naHZ3GtoORkjzU3KRDsCXLycRkTUbETBoZ44Cg6IhrJ74rb+ltm7jpP77Nxv/9c9jHSILId5OOcN5XVyKs9081eeXBJRF7UmWHgnuGim138D4GLbMGjBzZBcl7xi9N5bPC6ZtuGbdQtZTqxumQcRwauSfARLK9NRu50opa6CvefObG34XVS+XTQtLHFpIfPfH1GAJQf7WXlFd8anuts8zs+vbI7YynPXIb2R+OPTojJ3g5dF8u5t2BjRlHizfe4NJzN7L3VzLGoDoZKTmJ19a9PKpz/j5zC8fW9HBz/qqoLBikqUV4MgciqM2vWbCHePQNEZrn+naKrdGxN0yq+PTR9c9Yzsg4BPinK/67cxFVjkoudwTv1RJNyk9/DE4f+Hvp928jptb3jOhmsf+3A3CnGGjJ3oDUskkmOVmZNDKijLnVibH30IgGRufqZTgzxkdSNfGZbVz0/oUA/HjNKyyzDu+J+d/WEj6+wFeYKDbu7b9mMTaWA7+dhuQY3WJAFA1cs1xYDtr86jSGolmheb4vnSvx4PhGfE527tpxDZcX7+IX6SdOLWw4YpKdLJl1gI0vzhlzaswPvvw0lzlqgdEZBYWvfhVbtQmTBvK+yBsFbrjst1y86yacH0fe2TgSnnl9JZJ7eM+vN0nnujP89eevmL2drW8XYDmvCoCcP+5AMAeuIA23Z8z9FYYiFxXgzfbvE2A+VIfaECiPOpRv/vRpFliPYRUMQslOf3DTr+n+osDrPTN55etnj+WSMYD8hw/ScnEpzvTg37UrQ+f8lTuGPceHLy4YUUbVfckS7r//PkZ7v0YFQUBfMRcEAU063r/CJNA6yxxxzVRPtojiMBN/5ORMw5soNItI0tpk5jkqht1npzOPWqWbOxKiFIUKk45p4Eqz4I038OZ5EQbldwoiSIKBa5Z/KEPvNRFbHngzyBnpxD4XOAmrukjvuT2THbcnGXcmjYwxIptVCn5RQe1t+YjHmsDjCZkilbyuHnlhBh3F0Q/FGh5Pf2Obu39wB5pl+IWOpVPDVhs8X3i4zqjhIkoGrlwFc5M8rEShIYBx/A7sypdJj5+YTuWfn76DXtXCW4emT8j7hYPilXEGzdU48YiCQbqli6Qz62nakIk8irIZQ4TrrnufC+01xIiRd+RSDI3pH34Fa62pf1E4mpSBNMmB3aQwHj2Wd3Vms2d3PgC27mF64xzH0iLyxNrlAJy5aC+Z1k5sksLC5KM8/8gipv9nJVpLK+NyoYMQ50wDQUBxmNGHNHVT89KQrRbUquAKRoJgcM/CFznf3kC8GF49UaYcQyaQELeXnb/Ipeqn06i+WMSS7vugmiqS+4hM3UoL7mwl5ARlOF3Dfs+9JV5mTqklydQ77PFpp9eh6iK1NcnIrf7v1vCt5Zy+evOYo2SpkgX93RzMNwvDfpehMExif7qSEivRkyWNSpTBEEGPYNqRc7Kp+o98MjZF3qciZafBs9pKrrp47Yj7vXBkDt4jcUSmWzVGBIFCR+uIPaMUQ6JFieXxbp8M8Pn2o2OumwsHXQJnpo6WqA4r/iBIQ34Mh0JPwcA823xrGe2LFASzzvWO4MXgjz+wlOm/6fIJFJxgtDYL+f9yU3WiLyQUug5Rd/GEer9Tm0kjY4xIksGjeWu50JuN1twc1jFqZTWWohRCdekeK7FPBy+C7UN0ONCXzPbbpltkejLMwNjTmORYBb09vFtMiYEY8/ilTpkEkczkThraY2nzOnBpnwEljEEIJjPHvr0IQwBXjhbRnadqInu6skiwujiWpCHoElIEDjBDAk+yzveT92ISRtfyV0fHssfmt6A0RJCXtpMUTkevcWZzaz7l1Rk4wqz3EBX6a0M+TprC3NxjTIttxCYprF60ke3W6Oc9D0aQZaTMDDzJ9mFz7dUYMxCP7MlArfcpykgpyQhWK968JM6Zsp8rHe1IQuQRpXjRzNfSPuTG02YxZ3YFs44rEHl0mZfPWIZ9ThuyLuJ2hTa844+40CUbrrSBz9FbqDKlsDFk5/aVaUcAWC+rVBjpvPLWUgo1n+Ola6rKfVljV+uxCCbemf4Kn4u7NuJjBZMZKSudwUtNXRbwxo2+PkI3C7hSTdiaR3YkuYqT6cmU8cxyYWwWiVTh2dakkLpd5vHMpVy3YFNQiei3jk3HUxGHtfXkrPdQDIn9Ll//jGSph1TJ3xH2lV03cn3xZr6bdCRq76kmqiAZxwVqwkOUDPREL67Ll+BKlHCd3cPqkh0jHrN6wUaev3IV9uXJ6CbwJPj/BkqcAUyMSoboEhHXD19TN8mpy6SRMQYkWSM51ucl656aQGxjss/7OALC/Jkggis1OotcwQBTlwHxMQELR62lZdg8YNFuRyjIofbMWL/tSqyBPoZGhUMxTAa6LITV2XU8MSFxWvphXnPP5OOq4gnpAD7eaIbOEdU1onyuxarQm2xGWzaTnV//I5Ig8tWaFXx4pGTYY4bi9ZjYX5sBgJTswataMbf7Fh3iCFkXuslnCGhWAzHbyWHFgyQYpEsi8WJ4C9NO3UWjpuM2JHSLrzlXn0fVkOGBOY+TLkW+yI0mR12JlB/KwlE5uuHUstPODnKIL3KTaR1oLifnZGPE2kHV0A4Nn9YxGgSLBXdJ6HbuaowZvTgDudPXV0fPz6A3L4bWWRLvZG8AIn+OPIbCMdXDq11lXH2hv5fbIqpcdYlv2+bWfGq0hAAZbgDDENC6TQg2K9L2cuKs03Gl+XzhSpzBijnlFNjDl48tS6lE0STsD9lh/jSE/cPLw46W7tJ44upCzxGDER023MUDqku6SUAzj21BrtqgJ0fEFsIn1jrT5FOgMwQ8iT5lwEjrXyztKoVPwuaCfExioFfe+UkKDqfPEaFPkN9HN4v0pstIEXqk1/aUBmzL+DE88K0z+O750TEyypVe4tJ7cDojj+uIkkH91V7KCitIt4SXFfD5K32V1nmWVm4ZIjX8nkvie/uuDCoh/ZllsvA7YiaNjDGQn9zOW9NfBWDNHx9i7v/dTsbvgxRkCgIIIqLZxBMvP0yiZOfsfZfS9U7O2C9Ch9S/bKLxq0sCPBF5f/agdQVvuqcsmUbD0vHPMxYy3bjsZhxVJ8etdlH+Xt6unUZ75/iHvcGXUjKY0TYrCkaT5uSiT+4c8b2vKt7Ofy/bB5fC4AWhIBijvhYx3Y2aDromYNsTuMAXDF8qnCtfGUi700UuXXc7ALfN+Zi7k8JbND/YPodHdq/w/VHqhHJ7vwSt6IWvPXQnT9z2W+aYRx8V1EPIN498rMDG92fi6Brb72rdaeeDlplcu2q9z+Mriez7z0xWl61nc2s+nCsFbdo3asTwP7NulvAuG0gtPHa+QeWlIxd4j8Qer8ELnWUh91ucXE2ytZctR/MC7lWtR6boGQ3P3ELA1/RNMHypJlde+MmIjRX1Ye77z+ds5+svVyAJIues/jKI0Z3g1973EHPuvZ3Me0dftN+TbcKVOgFef2GgQZogGDRd4SHtRSvWlsjTaAUd9P9JCxobzzi+1ZMk01nk/wwLhk+pMdqqVt25MufdPvI9EhG6gGKMXYmqR3dz0Sd3jPly1lcWMTun1q+fxWg426bx1ry/UbZm7Nc0EgbRE2+Y5OTj5Fj5TTDJCT20eyeukK/2+2W8f8evAUiMck6nIUH9t5YGbUhVc8ssct9oRdt70G975+pl9Gad+p78cDmi9PCvjiUn5L1vmrmBbyfv6f97yeYbR+WlGg2PLH2MFRadod7mB3I+5rmEffx462VjOr8oGbjn+Ee9tG4Thf/WqPoPA9kUfOZ4cM9KPs4s4cWSt0Y8/6WHLuBAvb92vlLqRKm1YW2J3sJj+ysz2FfWyoV5+yI6zqPLvPZcGaYoRensdRLPv7ySL1y2huLnGpgl+QpOFyYdpWOjnX0/WYDsCjQ0TJsPovcOX3cwFDk3B09xWugdx4GnuhPZ784Ke/8iRwtppd28dnBW/zbxiI3CNf6LXUe9gr0BdJOIdrWISHCD7PFNy7BXDe8yf8gEO275A8/+449YBBk4OeukxpvqC8yQ5YqmQvCIWNpUUjsGHiTb3lrUxmZEhx3v4sAIwliwN2u8+PxKLv/82qgYGlNv383Ka+5k46/CV3U82aj1JvKLllh+mHIw9M5RJuEDGyl/38qk5tmnk8+kkRENzi05wB2pH9DXjGk4yh9ezG9O/xdpQ4yL+6Y8ze9jz2H983PHdB2CAQlH/BvcGZJAe4mEIUHDqiS6vrSMi8/cgm4IfPKXRagOgTE4b8eN8g0FzO+8lu2Ln4rqeTUElGi1BY6AHy94lXPtVViEAcWdv859DMWQeLVrHk/vWzjqc7/nkvjZ4f8I+pphCEz5jZe1j03lNGvgpGESJM631xK75Cnu2hR5nvhghkZqEH06/OlvmmlcaSAlBvovDV2kvDmVM70jGzmNnbEYuv+NKgBamgenxdTf7fvyV77JN856i7sSq0Je78z1q1EOxvktHQUd7P9I4OW8VVx6Y/hC7bohECQDZPQY9KcVxskDRS9VzmQOPjaNeMWLIQYu+/SZRchHm8JSggJAFIKeJxjeeJmebP9nx1oHpR/fSPlp/wjv/QahIYZs/DmUwWkt1m12Eio0v147ABi+sVDy6rz3QBk5NwzUefTxxNrlWJukEQUDJB2mvXQHT17w5xGV+T7NVF9kQk/xpTZOJH71Vorii9xFufDVlWrCmS4iKvDMuytYtWoP2daOUZ+v8R4D2z/nIXkGvqvLD51P5whOzGxHJ/8q+NBv21aPl28fGttYPJiDzWl0em0jdoUfjGaIKEMSrv/RlcJP3/sa5hYJpdiFGOXIXj86GMoponY2mS4VMZ9JI6MkoZkWAXoUM02j6Np8RvEhVievY6Z5ZAOj8hdl/Peq57gyJjBlaabZxl3p73Lo7FRa3gvfs9eHqRvM3QaCYWDq8p81DREcdb6J3J0kYC3q4odpH7G6/FrcKSeukU8ozO0CHQ2xoXeMgHKllx0e/++3IL4NYNxSpgTB4AvTtnOBo5o0yV/Sc6HFt7wt947c8fpnzTP8DCOrqPCjlAMAnLHncho/ySKuwiAp6AXA4Rss3G0fPiUpUbJzprWLa2Zs7d+2pzOLvbWZI15XdkoHFim4677dbaPFG0fjYgtpWz3E77XQXWxFyAysEle8MseaE4OcJTSSSUe16vQJJ9iPSfxxx5m0z9rEz1L3Bj1GM3QuKb8Y9UAc5iGpTSm7FRw7a4k9EMeLJl9X+NO+sG1EVaJ6dzwfHSnBGuU5QNDg6X0LuWjqHmIkD580F1G7OYvcw8NPwmqMGTEjGVkQ+gu0I6VhmQXvrEApK6vNRVacb/yqeT8PUQXJA0a5gwvSLuKVqS+Pe8MyWdQpSm+h5sM84qs0zB0jhI4MiD/iZf/HRTQuiuHszHI8usyLB+ZirZdC14YZ4KiW+dquG/je9LdZHRt+/cR4oLvcWI624c1NHPdmeJpFpGWOCSPdhRRkQdk2XSThkGlC+2wYXgVrVSue/KSofH7NLKDaAAOsLQIf7i9FtmgkxDk5P2d/wP5dqpU3ymcOe75zSw6wISWJ+EqVHzX5RFTKm1OD1hH10dLj4Ed2377fSN5AmuSgQ7dR25Iwps82GK/HRK93bFG4eiURW62Ed5aTvNR2mrtjotLdezD2zXaSd0+MquQkJ4bPpJExM6Yep9VJoyeOHvdA6orHK6Opw0+YgmCQldzJdzPeptQ0/AJVMJnRl8zgL9c8xBRTF8eGTGw7vSl0azZSZYlXZzzF7IpvYKuRwy6Oll1ga9OxNQUf7AWd/mY+hmimudHBTxvOpv7t3AkLf48WwSPyXE9cUMNsNBzwprLL6a/UUxrThFeTx68uQzD4Wdp2TMLw50+Tu0lP6qJxiJHrMRQ2ekw8vn+RnxdfEHWapsSSbemg+9+ZFD4zsJjWOjr9ziHIMq/9z0ch5RbtotmvS/afzB1BjQxR0rFafPfanKRaPy/7YCp6U/AoMpQ5MXbGkHTAA1josJmRE6LsqZIMVDv9crrWXTb+4S5j+sq6oLt7DYnqtwsYnMElGGBrMnDsqsPo7UXo7SXvIZ/x98GiEmRZIyOum6XJVQHna3THYt0V/YJzQfMVgvcWW4iRPFTXJVP4bujvzptkwyQkQzhGhseL3OM9rh4F7aVmCs+r5NXSN0Y8rPDozVirLUgukHsFat7JRykd/67IJkFjcXI1zr3ZIxsYg8j5wEtFajJdqVZ2t2dh2RlZ8aq2PpHnkhawOvad0VwybztNtGn+DobtznxsTZFZpYbHg3akCjnB0f97RRNTtxcMAyXeQk+2jGeuc9hSfnWqk07djuSVsbSNn5KHqdsLx2XgDcWLWlGFc0kGlo7Rd4tXYn33qDbkK3Qc8M3/rTkWGFQiWdGbQpdipdVlH/He2RyXh2oXUGLEsCPTbpe5f98pCxo5314BxIf/YSaITFM7ziIvq487otYLhbQMkqp2ucxjqzE8aiP7zWa0/YfGeqkTh24w5mZREb/fqc1n0shoV+1YgHRLF5cUDOTLf9hQQlN7bMCDI4g6omggigbvzHxu2MWjbjqu2pSdwaI/beXd7pm8O2Qfjy7z4rvLsLQK9Bao7L7kPnZffB9zn70LS6uIoI+s/y/oEFetYuoOLxwRW+Mltgb2vTwbYRYTniblK+oKfyCy10r8+J83cM7X7g1bgSgYHsO3KHYbJl9ay5DQvyjoCKIekI4zUVxg9zBrxj84c62vcFvXBboVKxs9Jm7ecFPA/qrbxKGVEgcWriDB4sWzYEr/a6aPd2L09WYRBMT4OKQomZOCYOCwecKqVyhytFDkaEE3BNbYyjArOkkHPNhaTTReLCAO1XYfA7JNRSnWkAd1lneUm7mn/Lphjxn8jfQpYyX+YxPKsllo1gy/fbP+DJa9NTRdUkzPbfXESJ+ezvRqQyNidw8snYZmFfnGXc9xU1xTyOMqz3+UKR98CXGQlHCn7sUiyEjCSZh/Cexuz6L53exRHevVZZy6F7sY/uK+R/cZ4Le+8TXsx/yNr/zHjpDYshlDjLCI3zAwtuxBWjYHQbf0CytEhV3lPkPmc4vpPCu0qqAy3Ul9opX8N4XAlLVosX0/2uBeU6JEw4VeUt+1YGtWEXQDUQn/vQ0R2kvlkec+wzc3W457+tbvLMFRHXp55PwkBVeBhmvh6MaH/9l2IcdmbWC+vWpUx48nN8a18IULHuAXLT6DqCylElIGXv93+Tz0QXN7OHOpYQjoqu+YqT/fieYc50ZAk5xwPpNGxnCckXGIA450dtb4qz5dMGX/IL304b12P/7q42y9vhCJw0Ff1w2B1/9dhuX4/OKokln2x7sBePyW+1lsEbinZRbPPnFG0OMFA1K3e0alxCB5dNK2emj6/+2dd3hUZdr/P+ec6em9khB6CYiAdLtir2v3texiR3dd1ra+7mvZ4qpr+a0Kytp7F9feARUQRHqHQAoJpNepp/z+GEgYMpnMJJOE8nyuay7ImVOeOeU5z/3c9/29x1qDJon3FFKJHUddZG9E2QtTn/oTL1//RGt4USR4DB+jfpjR+iZOjHcyPWdjwDoj4neRbW88YArypXxjY8eLQ7krtRDOae8pUCwaW14YRvY7lnbhcfsijS/ko3kvdbkexf7kp9cGnckPhSwZHP1/i/li7lSSNnmxV/nIf1Wh5CqtfQ5HH2FqgeQNHrRjj+gwDMM7IpeEIi9LHh/PSbf9FHSdgxnDJPHhs/+PJCX8e2XTcc9zVcEJrPxoBJIOJ8++g/t/91rUPI8HEju+KGDk4JvYftpzYa0/3yVz83/8/bkjyG1ecuVAYCDx2zVi3/058gYtWU1q4xAaRyT1SCHXcJEz3ey4TKEg8pScbjHiprVkWRv4smwYiY+HF1ar2WRqCs2dGmWOnQqfzJvMb84PPycLwDnYi8nWPa/OK+sm8goTu7WPvuCCIStb/1/hTmBh0aCOV95DzC92Mp9YDIB+EOYbGIaOYfSeFFZvHqunEEbGfgyMraZgWA3XprTptyfLAKFDT55vyKTCl9hhBdEdzhSWfT8c8/5f73nOZElHkcz8PvkXTrp+bbvtwZ80+X83X4vi7v6N50kxUNPah2FIitHDJQLDxIC7rrwexeml5PQE1t8YnmTmSo+Ha9ddETCrUt9kZ17RaABOyd+AXfF7OeJNLk4evJFvtg3pdY/Gf1sc3L/xIgBSP7Zhq/VhrWjCslum6pzgSYMSBB0Q6xNGYtpQglZXBxAyfKXgi2tQaoM/9rJPwuTaU1V4qIux+SX0s9dF8rPa9iUZDLp8Myt/GEK/r7094vbVfTJ5L7S52tUhOZRPCz5glnTIe3UbnuE5qHalrdZGiDjvvd85KlW+fXgqSavq2P1Pg9P6tY/djjalN/Vnp9PLEIcHX0L0lfCM4QXc+vQbERkYAIokI++Z5TBkeHzGf5hma6EnVZgcspcbk1bwvWlqjx0jKB1ERmzzNfNxc2HAsg/KjqRiRSbWELf53oFuUz8F39WTSXppcRfaZHQ7WsPcBAk7updXIVs0ii7yX/OUZQoJ27sfDil7NUy/bkZX9xu06xrD/1LFqiezycmr5+jsIjb/xa+O1jAnr52sbu0Ia1tVcylyr89b307FXtt774Noypr3FRnWRk4Z3NYvfvndWDKWth+nxJQ2HRLJzILwEUbGfpgljQSzM2TOxb5ohs6nzlgqfIm4Q1QTUg0Z834Jp54Ug2OO8cfEDzB5ATNJioOpoUb5t1bR9HoWcaVd69SdOTqGycCwa5isPZsBblTYMDsj70AlDbJ/bEZasQnD4yHfN4yR6k2t3199+ZcBFVZv3jkR3x5feI0nhvrGwIGToct43O1fGrJkkGxuYUTWbrZUp+L1RCmpzZC4qewYHsj6kixTbNBV6jUHtZXx9PuvTNyqclA1jOZmpNRkoP2gUtcl4pbaMbnaDw40mwmT0vFLcanHx/Wr/UpUyUvMWJrad/KuNNmfEAkgQX5WJf3sda0GWVcYElvJrrHxFCWmYdttAinKrnFDQqtqqyhmMnRyfB2LKBhJ8Ug+HSXCBFJJNYip8MeuW95I5ouYaegmejSMWt5SitbYiCknG19C6GT8rqBbFM6O6dr1uCr9JyqmJ1D+TT+m2VoiCifqKkmKI6LBYvEZZgYMKu+wJkZ3cBsK1b62mfR5RaNxb4/DFqbHVjeDO0XCfeYE7F+ujFhZx+TUiS2TaM7t2kBY0o1uT1RJgCne3+76ETZacq3IXsj8uWthQ6ZmL6bSKtQOwmfU4lJiXprIG8dOZdjoEsYm+eWd3zoqn9hSK+bmtj5NtXcvLNjcJHeeHymBM0dDthygKiq9jCwZJJr91+7N76eSus5fiHF/DEXGNKgAbWv0i10KDkyEkREEn25is68lLENDx2C5s6BVljFOcZNrqW23nkc3sa9/wp2ukzmykufz9npMwjNq5hfOo+C4GTSWWDE3Qfqv4XXqulmiKdcMae6gyiHRxAC0RguOGrlLSlaSDixZ3Tphp6/eSO7qtu+fTTmZhpMcXJq4lC2+NL4uGhp2Be9iZzK5jvqAGPvChHKafFaaPFZ8qkJzS/dmjg1DYv62wbwdu5P+lmoylYZWOcyvnGachpX3do8nfo0F+0eL2LcrNtntmNf5B5WugX5XvOo0EbPVQtbCenyJtnbyo5ZaF3iDGwM/uXUeKT0T9adkzI0G8SVq0ORJQzHji5HQrBKNQzVGJZa3xid3h2MytrI7sZL52wb3uOiAVl0DwaopywpKWgreEbldVqgxJAlPZhzJi8vRK6uR01IovqRfN1scxnHdbsx1bnxJoe9Jk9OH3OTsoDpEG3LhMJz946ka0/Wu/0S7RubAdzi74qaIDbZ+5hrqNQcV3sSw1o9T3BRY/fkilRMgfZm5Q8GLfZGy3OTE1FPa3DUFs31x6l7O2fQbXh/il9beqSa2fvdj5UA8W+Kx1UZ2HnQT1Iw00e87U8RGhuLRcVQZ+GLNeBOksI0vcxPImtEqlhAtpCw3ahaoHoWGSgvxxd6IQnpNzV5MlQ2dKqM5PviZpLTJeEa23buyBr4YUO297w2QUzwHrJCK3eEh0dZ5js1eHLKXAdb2eVlmSWG4vZyt7oxOZeB1Q+LDrUeQucjAVhP8GdXsJozMBMwNaQETRAcNhtG7ydiHgNdHGBlBcOoWXqmbxF/SfsUqdTy73ay7Wes1oxkyDtn/ohhqq+DcmOZ26/Yz1/A5/iq3mh3GTtzCOwO+7VL7tp/yPACP1Q7g01+P73R9wyThSTLRcKKrQ+WQYCim9kOWUOpb4DcwdK9CzPau3VqSDkpw8aJWBt62hC+umUbFNeHFge7LqtJc9FyJwXFVAaFte/XEd3vimb9tcMTtDsbTq44DoH9GDW/uGaDMXDoTtcVM4iozmU+1r/yrVuyi39/9L9viBybjyZJwbDeT889F6IAyYRSaw39PSpq/AzLWBgkxACq1Fm7bdCXN32cg+yBpc8eDmZhy/0vBmWnmzN91vSJxMGRJRzFpnd47PYIkoSTE4xnpNwi8CSYMBWS1vfRzOLgHpGE1m0DrnVhZraYWqbkFecIIDJMU1EiSfTqmshrUsp3BdyJJKImJAGy7OInTTl/GE1m/dKtdIy12tp3wItDWP2qGTp3efmCjILWGZR1jg0R5C5+oR+DUQ3tAbLKPAmslF8X61dO2XvoMQ503kleho4fw3OlmCcfPDpbI/UmO7/qIWreAYteo0LzIJ5YyZ9VRZJgbKPO2CUdX/pCNtQ8k/iXVIHGLl+pRVgyTPyQo1BhQjTGI3WlgchvIPZSwbbJqNJzowv6eFcWjI6kdJ2hLhtGaOG4qqUTdXYlkDnI/GDqGqqJk+MOjnFkSp+1T+6H/R06aCuw0DPDXvhD4GZRcHXbFb7OkkWup4ZK49qGxZknh8rganlRjqVVjQhoaTt1C1rMWJD305JRuUfAW9kNZUBuZAILgoEQYGd3glrKT2T1dYsyCemYmrwxbDelvl/VuomTdYAvNUyN/2Z46cEM7VZ13Nx0Z0mugNZuJ2db1sCPHboPEVzqPVXZUaxEbGHtZU5ZDZXIcx2X2jnTejt0pTN49E4AhsyrCLpqW/39BzsPSNVhGDsVQJPTV/mT2joYMk/47C0eJgnlPknNfkWZp5vzBq3hv45G9Hn9sysvFvU9160v+/hkzE0u5v2oEC/84uUv79PRLapXE7A0Mjwf5hxXoxx6JobQ/f6aVW1GbOtaaV9LT2PL43jCy8Gc3I2WJB65eMrPdcpvdy5qJb7T+Pdpio1/SCh6tCZ3sOj1uDROsgX1JXDFYtu7GPbSDEDIJqo+wYEhgWRFLM8HDFcNh2Mlb+GDQ12zbM3hddISFrU+cxaXHHTgiAKlr/M+1K91MY37wflk3wZoZT7Xmat28cyIb7iwMum402HWBv03m9Q6yFgXvdyTdQP5hBQAqoGSkt04E7IviUpF+XsugT+uIN7kZS2B9oQlzfgXg+12Dafg+s932gs45NnYjx9lDT5rcklTMW01JrHXlhlzvkMfoZQlb4ck4PJn6h+tJXFYBbg8oXu5OW0psJwbGZKvGBzc9wnnP3h61dtyQuJHxzxVx33UzuqQ4FYy4WBfH5/gH38Hi8c8c5A/6WlufTdHu1HbfWypN5D2/iZIZQyM+dvpyD9ZFGzj49RT8DHzUh1wcOJuk1rQPpYsUbcNWpBAVmzVDZ/irM7E3RD6gt1f6mP/XKYy/e/khJdtqmCTue+Y5Jlp9gJnbU1Yyee4WHrr+yi69M+wVLvIWllF67fDoyYniL3SX/fwatCBGg7JoXVBRBr2DcJvKmVOoH+0DGUz07DTvP6qH8vqW8UG/87jNjPr5MhaOf67Vo5GkOLg71a+//0pjQat3wCxp/CnlV2RkrFLw15NaXoG5shpkiV3Xj/Pnx+xDNK/H9WWTKbswFfDnAAy9bwNf/GYap97yY+gNw6TimjFkf74LbUvHhTP3RdtUhK0+DffwQFleW7UP6z45ISP/toY/pvs95TJgltqMrX9mLeCjOVt5tXBga6iW7bvVDC7OZ8s90VGlA/AMdVEaa2PAX5YH/d4ApKNGoVkV9CDGM0BTfzs5DycRbwo9MTMlfTvFZzWw/uPI3zuHGsoWBxs3DGZFfj6Xjw+tYvbGwimsPSKb4wZ/2el+H5x9KbIGZ1wTmQKX4PBGGBkhGLXwGvQ9qkNas4nUn/2nK23+VtSqKozJR2D8rZZYufMYfrOkMMQcw+WXfMsUWzl0Y4ZtLw7ZwhGW0DOTVUdaaS7QwlKMykhuZHBiVchk373fDY6vwqxobCrP8C//xUHCDo3Yoga0mlryPvHHxteMTaYlu/O3vjNbpyzJQmLuEV1TXTkAkRtd/jyBSLax2WBI/9a/pd21aLv3i5XVNUIp2+kYmJqkLhmekg7WerVHEmajjdnuw/VlAXHX+FBLyzpcryXLzJCb1zPV6ldwA/+zM8Za3+Vj61YTUv+Ok8y7g96BVyLS2H3VDqa49s/yTxUD+L0h7SPLHTlfOc3c/dA1zL/3ce6vnMyCikEdCicYhoTbZUHbz5rbmzB+euwmWvb0s4pkECt3kp9mGK3nQjf5E6mjzYizNrFs3QDyPpawFS9tXa7VN5DxTRlf6tM45Q/dNzRUO2CKwCumaxhq+xATSfd7B5Ag7v/K+H36dww0B3/HxMo2Rll3YvjaPAeGx4PU0AxEz8iwbrST91VT8PtWkpBHD8MXY26XY7aX6tFWjOPqGBbXuefXKqvkO2rZefwu6n7MPGBDp0bmVHBFVvD3W4tu4a+/nkn2mxZ2TVDQB0bmdTQAudiO4t7Tj++08Lo3tLfWXqWwZnkBx7jPY+GoD9t9v83XzCX3+ydGcxZWIOkGC8qndLg/SyehUq1tlSSafzMe9gn/VH1u+OCjsLYXHDwIIyMEpnUxrZ2VrdYg+QV/57C3i3dnWFk4/OOI9nl36iaiYWDsxYzCjnNM5H4bPMbcnWagJHc+I52S2MyAhGpybPVhHTfR7CTHIbMJv5Ghm8FR5kRf6S/apq3bBECSvRBrowPNIlE5XvbPthmg2UDdV0w+0YuRptOg2ul+qmbXqPLGsqM5ufMVQ2C1+ZiYXQzAj1eNIv+zOKRFqzrdTklNQbJawWrBndo2yLIAJpMJdL3TxMgDGZ+hYP85hsZRXkz26FQLNpk1Fo76kCE33sjAd+LRV673x3UfMQQAeat/9tkXI/FK/kKIKCMpNLpZRk+ykbRJpWGAqV0l4a5gboaEoshHR8rIoej2wJG2O82OJzW4i6a+0cEyJQ+6YWQ4DSuOSo259SP4tmwITc1dL5yZ14ECWygkqxVGD4l+cVEJmNDA6vJssr5XsH2ypN0qanEpaf9t4a0R07B1crl8cQaWkQ0By5prHMRs6foNY7jdWHc348kIft6eG/ABqUpoQy1ZVim/fQr9nl2L1ugP3TVaWohZ4qBpggs5CuIg9ioDY9ma4F9KMr4UR0ghBneKwYX913b4/f5YZZXjM7fwvpJJpI47NcbAm+9/T3oGuDEXWzE3R2+iZXJBEWZJ5+SkdR2GSnsMHwsGbGXR2NHYasBj2NEGhWdoaKoMDWZs9W1tNjnBFEZBQftumQo1k9+nHNU68XDTzkl8WzQEb7OFIfuNexxFO4LvSJLQjjsybHGNxnwlII9I8xyYBT0D0HWiFjYSDqJOxqGJIukkKC48qTqyd+8DE/jgmLIyacrp+9PnkC0U/eZZxq+8kYQuJLLuZWxaGcnmloi2USQDi9WH12PGc4STph0xxLVN+mEqyMdodBHb6EJLdFB5noLmciBp4E3UkTPaMrz39jW6CUz9/HGf6s6KDhPDTE4dtd6CKTHyrEuTWcNqChzoNmtWNjekU1bVdRPHYvUxKKW6TTHsdz8yIPF6hu/qj9pRx7wHvV9mUAUhb2oMpMYgazqmhkb0ziqkqjrLPf7CjQcSPkMh66mlND88HqJkZOxl89VzGLPrJjLXWVByMik+MR6AXCMX2elFVv0z79Md0Z3elHQD+0dL8f7PJFxpcrcMDcUNcTtVrJ9HNvBXUpLZPS0ZT2Jb/6RbwD3YjWLq+PeqmsJ2XzMFHcx2h6JZd2OTrFRc7GXO6mMi3r6rzGuJxbJHqlSOjaHkhPAKsoWDZvMPNA3FYMPEV5h2180kbKiHI4aDZqCvDSzmqdXUMvD2xey6dQqatf3+vIkGhgJSXktAPgrAE3X9ebr2tNa/DWtkrhi9qQlp0zaUhJHoVqVLimm5pljW/HE2p394HuwxMrT6BjL+vYjmf01CS/eimEIPcDSvv9eWzXq7Iptqo6X1Wu2L7HAgOeygKKgh2u1JMqHG9l4nptohP7uGn6oGkJ9VQ3lpNiYXbbLeXUSSdeJi3DzT75tOpZ6tktn/7rj+R4a+cCOpq3Qqkvw3V0dKVppPBkPCcCrElHU9T8xaI/HtB0fxypXbUSSDJS8cSf85h0ZEgaBv6ftR8gFIrOJmVnIRsy56pnXZY7UD+PLhPcL4hsH6e/PYfnZ4BeL2ohk6inRgWutaF8Jjks0tnDNgTfCEXklCe15lfLI/1rhZs1K0qRB1iH+Q3OFZyHOx+SF/rseQO+kwDMb81S+M2JzH5n9E7nk4Insng2IC5fMWlA3qVLq2s2rVpxes55HMFQHLis5/lguOOImmoyNuZgC6IuOdNBzLkg3oro5nt5SKaq559pbAF1KEl7ZHI6V6aN+GBNKIgRSf2mYklp2UgL3SIH6Hl3/edBVHPf/vgOJzWpSS6hJeW4L1zAnUjjBFfO723lIZS1uQFnfu8QrY1mSi9HfDAmbzDRl8w52dhkfWNzo4ZfFNrDv6xZDFG4PxXMOwVuW03uQ/008kbnt7z0K3kSB58i5+Gv3BngUKPz80p/Xrbb5mbio4NnwlHAn+dcHLHdYhuTVpB7f+T9v+J669kcSVkTXZUFWkRauQpo3BsERXhGDgbUsovn8K2uCOJzR0XcKxwT8AbslXAyZ7DGDICy5Y2t6L4T56BFVjLEhaaPn12ktbuHRQZM9DQAMiJH25geX24ta/+1OMNL6QnSfEd6s/jLF7WT7uHSItVrnpd3M46teLGHzmZgA2PzcexdE2ObO3SdbtNpQoaTkoHnh9mH+CLw1hYARFJH5HjDAywuSWpC1cVOx/mn97+S0Rbz+vJZbHbr+Mj5/6f2GrUHWXootllDhXWOO674sGMyyrktEJHchghsHuMz3sOm0ckqJz0tCNpJhLu7wvgA1/Syf/zSwsX3Q9rCNaWKw+lk18MeQ6/sFa5C98Y+oYNEt4xuf/rNjEsfbiDr//0dWPv70wsPXvjJPLmJiyg5//dFRY+3dmmBk3awXxpk50hLvIjBO/p9idzHdbu5eg2T+jho+Gvs/el7drcjNl5vZeKHeahBpjJXm9h3NvvJXLH/mE6xLK+Uf1UL68+1hMRnQkFG2fLSe3ZDClp4Vv9Eoa5Dy5HHQDQ43My2LKyqT00gHRDxfqhAu2ncSa8p7JRekrrvqfL/l90kb2lePdl4HmWJ7fsYDrTr4abdPWkPsyZPjyxofJUhyEG5736d//xVHH/oEhMyKXFZYXrcE0agjelOjlUgD0/8dy6i84kpoz9vE2b3EElRePKTFhlLYNJfLnbkSrbS+HWnfVZFzpEuZmSNrUc6ISKes0nGky3oTwrIPsH53IP69tN3Q0lq8jryyd4qsGBt2uNxl2c1vYmJyZzo5L/cZAb0budIphoCxYhTGxEM3e8dBSs8rUFJp7ve8S9A3CyNiPQbbdnOIoYv+8CbOkkLsndjiYjGRnaIaMqbmXNaFNRtgTx4YudzvZV1YM7HFOjsosJc0SWCvEIXuZNmAbi4oLwi6cp5h1DKXjQbtWsZuBj8SxZZYFWQnP4j8qv5gsmz9GulmzsqDML4PrdHc+09TVysZ/7fdf7lxwPp5jg+dUdFT/IBiPPH0xi69YzlM5wVVDss1tL/fJ56/i1oxvSJA1PI+YWHnHkSEnYTxJJhoGyK2VW3sCh+LhroyvuTx1MU26jVuXXtKl/SiS3no9hrx0I9Z6KWidAENqq/5rcmrMeepc5l2wg7kD36Hm/phOz0kwXGlmXKkyGGDOb0us3DdsJu/jamrGp9CS1f66Jm3WiF+5CwwD1dPFwZYsdz/h2ZA4dcN5AFyVu4gr46tDrn72llPZVp0S9vO7PxdsuJwHBs3jmO7Vuow6cbI7ZD0k8IcXjXprKz88NIm4t9q8KbkfllJ5Qi6udAlPssF9575DluKIyGOdqsTw4nEv8MePLiL9nI2db7AvugZbS7CWtPVNF1x/K6c9NJ87UzqW6N7ua+bqmbNwlK0O+r3h8ZD8TRExFf3YeZx/33sTituvHBieWX3WUDAgcbMzwDunm/Y8i0bPDo4lPfxw0X5f1iMVlaEFqTOEYaBV15D/TvAbVv8ihk3XxHWY8zg4q5L7+n9ER8ZrZzwz8jX++OXF2E/Zju72W3dy4TB2T0zqkfNnKH5DMPWj9Wj1DaFXliTiFqaQYm0LsW7y2ag5uhHTuu2YFAUpIQ73gLTW75tzLXjjJNjTJydt0fxiBXtQfdENo+0JDF3H6EXLzhA5GYcO84pGc3bBGo6yFZPVhUTEUDxd349//XgqBb0szhq7wULzIBlTfOd5C1kpDWTYOtbaD4e4WBf9E2tbB/H7IksGObZ6CtJqKK1LxOsxo2sSVAcGNBsWAyUpvIGX4fHAinWkfjWZyqlayN8pyTr5aXX0c9RhljSqvLFsbkjvdnXvcBhucfCv/u9zC1MDlivx8ZRdW4grw8CQDWKLZVLWhf7tKWs9bGlMg5wQK0mQfHwFszK+ZrjFP8P514wljPrtEWBA/BJ7u7oZ7hQT7mQZQ4F3Nh7JeUNXBxQr7A7rGzPZ/NlgcjS/C77AHEuBGTxGE+cPXwnAgopB1NQHPnfydjum/ZIvB5+6jaHxuxloq6RZdzN+0bVkLNNxpci4Uzo31JI3eCj+uj/XcRHvDZ7Xdk4W20ne2Pl950oz40qR8e1pqi8u+DHd2XGoNrDV+MO19sVWXIe6vWNvVFfRLeBJ1sNObzcMiZJKv+flHdNRbPeEbtPm3WndKqi4szqRq7Zfy8ihZXwy5POwt6vUWpg0bxbD6jd3+djR4KGMlUy+aiC19skkv+i/l9XiUlJWx1N6SgJHTdvI5XE1dEVg4Di7zs1D5vMOkdd60FtaoKVtsGf9bBmvFZ7MxvMzeTGvvdzo600p3PfRjQz4ZHHIN5Jks6LZZUwtkU0+OTP2ru8gWR2FsWwN+rFHojokzE1grw3jPbginnnyaM4dENwI6gxbnUFzHmRPKG9dtvOXbCz1gb9F2lnVmvgeDENVQz6rkndSh98lW53t6rxEwjirhXsGfsKjjGxdpsVbcaf2TMypIYEzUwJTx8NC/dgj2XGGDUOClQWPByhrOnUvox/+PZIukfelF9vm3bRkt/3+vXlj1noDSyNYGtSACR4piGqa4ODnsDQyPi0eieIIHNyav01g9xXxjLREP5Tp5e2TGPCW3uvuQZMTJC28DqkwuSLixO/9yYxr6rTK6PjkEtyqmXJfPHqDjZhdgSdFs4PbZopIgSjx1cW4U6bgzFTQrQZyhhvVZWrtwCSTgdmu0z+2llqvX3VlR3Ny2EneZotKv6T6sNvTGcrgAWgpsbSk2jj7irZBwJtrx2Ny2cCAhB3eoDPsdUMtHBXXsSxuvOShJU9leeE7WKW2EAqHbNlToRmGWa+gRolD0iC+xH+enWkKvjh/XK6yMhZ1sIxZiU6nv602lZx/tq8ibpXMPJSxEoC70flRGYhbNVFd5B/4pq41cOwOHKDrp0rkWurw6Gb+WX0UOc9YABVXSvhepswlHioa+vPKzILWczLUciVmZwxxJcHkNkF1+AfXzgy5w2RQQ/YnEAOUH+3vX+KKDWzFdQF1ECI+q7KCKSew+JyeEt9uNW3Pvd8VNpVntMpR9yTZ3ypsqu8PQ8Lfplw1MfiWnyM/bz3A4iPe54LYk2jYemRrMTlj+Tr0M6bwRsH33dp3mqkR9cQzMH33a7djsbMfXsRydQp3XtF+4uidFeMZckfomHslLY2WkZlUF3Z9kOzMlFAdsWRV9qNkgh1DhtgyHXtl56GBWYs9lNniYUDXjm2r9uFLMPH9yDZJ1MKmy/FujMeyT/0gIyMF2en0G2pdwLFLpjnG3E4qOj7OSX9HZPLlwUhUnPhOGoepRcW0YQd9OdcvjxnBlgssFP1mbz5R4ASdQ7aw9TJ/HmtBwrXkfJ1Dc07b+13x+CddYndGLtYiOHg5LI2MrMs2YgriHv91+jDI69ljN+gasVL0E8B1iz/WcV9evuMxHig9k1WlB1aVzmnp2/iwaTSWHf7brzXMxQDFBY6tFryjIutOM//tDx+SRw9l821WYja3DTp98QZagcb32wYDkeceD0itiWjmNRSS1crGW9O4bGr7Qfelhb9AoV+J6ed7jkJx6+0MjcduezZkddYxVivbz51LKBf9xmmvwjR/yMSZz95BMIeFRzeHrJcSLh7dhC+M2e9/ZKyGjNUsdMP9j87ocL2W+3OYF8yNsydko53+QAd5eskbPLx5xxlc++wzKJLMpqNf4cq8Yyi9fyiyN/D8alaZmhGddJWSX67U6B+YhVk/GGrGpjHkj2Ud17mQOzg/e1zlSkoyxZf1cMfUS1Se62ZyQRENuius3DSfoVGv904OW7i8N/AbvnrRzKODRna+cgScHePktFfmcvaw4zqslRIJWY8tYuVj7ZcPofPcj5pTB4VV36gzvPESxZe0r+QdDpIu4dFNWOXw3wUuzYzUgYG2dtLrnJp4BmVf5rcuKz0jmZwFFljSNY9J9sOLqLl2MnXHqgGyv7OGfLvHq9U9JljNfPfK89xfNYLv/ncalgZf2wusF3OCZZsN9yMtFI18o/OVge1n/Ycnp+XzzOtnIGn+fjiuTMNae+CHRIVEJH5HzGFpZPQVkg5XX3Mr5z3+NbckRTdc4ud7nkLfz/ltlQ6w4OcgGDIsuulRHJKFE9deQO13WZ1vFIS6KybgSvfHe9r3k1Y3N0qYV7fN6rf0V8MKIesJtM/SuSQ59CyiWdKY+LdlfPfvycQX91w7C8yxrJz5JIUv3ByoCW/A/PfHkXfKDsYmdS95/9MPJtPvH6GrzkaDhO1e3E1mGgoCDW1blRH2OXwlfyFL53zLn2fcEPHxnTkaSkrwcCsl2cOWF0cy5JoNrbHV+1IzY0KABO1ecr+sxVAUSk9OiLg9BzKr3yzk4sX5fPHRq52ue87ms9BProQ+ncMV9AU5Cz0s3DaJk2eFV/SwxJVE2V8GYw5XBSxKpDy3hOS1o9l+S8/J8r277Ujcl3n3yOg5wZCwrbH32nj3znVLOdqmEkko4C1JxZx5/cOcNfsOUtb4UDwHf36BIHJEfv8+ZN3mZeiLN4a17ogHKzji4ZsiPoakGmg9oONplhSskjng09PU+mL47/ZR7eVrw8SdajDn2tkkyHbMksLLw17lqeue4dEZzyNJBgP+rWNf2HkiZM2MybhTJQx5z0x2sI7XaPvYy0zou8IzwM4fvpLZA96N5GeFxCxryGFkJZoljZyriyif5g+70ewy1875gAnW6Kk+lanNDHt7JiZnkOtnwLYf85lXNLrL+//mX1MpeG5bgPTnl5dOYvTSS4Ouf23pVP701/Cev2BY61VS1/oCPrHlkXljjrDA9c+8hzfBP//iTjFRNyT0s9RSoCIlhTZkZNlg8z/HoAz3e9NMmRlUXzeZ6usm40nYc+/u99l1TDK7pyb0rKRwHyDpIK3ZwvQLrqJa6zhMZcC7N8ANDoxgSblR4v4Zr3FpfGjFqMON2t/5VaB6AmeGTMOAMEMbDXDs9vHV49NwaaGfwY93FLL5qRGdJkTPHfQ2Z1zS3ovcLQwDZcUmhtxTz5B76lGbo//uNfzF3JEko/XflqGe1vDMnsYm+bocfZG61ofiPUQMDN3o/c9BjvBk7IO2pYiCD+wMst7QGlu4l/kumZte8s9wFmwrQS0tI2FH12bdZ398GkUn/dJaXbOrzHfJ/Pb737H1tLlBO4BvXQqZtiZ2JjVRXRe9wlV7KXcmoPyQgHGUM2Kz6cT8zVgL1AClGX9CsE61Vkv6ezbkNWtDxsrKMTG4jhuBJ1mKKN9F9oGlXsYr2ULGsJ8/fCWXJy3pUkXiaFCYUM66mAE05luwXrybS+LqiFRvPRQ+w1/ttSPMzRKerfG8XjUJc62JC079qVMDqcKdwI/fjAJg4NJK1F27A77XV2+kqW5c8G1d8d3y3EiqgaJ2r1O2SmYuim3g33simHSTFLTYmv+A4MzWkGN9YVVIltPdlJyTRnZyDJRU40kK/dT4QhdtbofiltDKbUjZPSM/HE10txtp8WqOnX07xp63kCvPx7rTnmbcf25F0mHQd85OJWO7ywPrz+Afe3KP+sU3MG/wlz16vIMBb4KE3kMjA90MmiX8t4XsM4gr8/LppxNb+3hvqsYFE5bx388ntU4o2WokYio6F27IM8UyLmY7nzKlK83vEN3tRt9TcDV/XhqfjhzN5XHdy9HpDJNVCxr768rQMUyB/ZG9QumSIpWSmMDGJwYxwPwTEGGHBCQrCi03NmB/LhFzN4oFCw5ehJGxH8bydQzdncOZ408LWL5xZyYD/+qfAdk7r2ar8nLBtpN4b+A3Ifd5RGo5S8alkb7c3wn2+8rLZ+Zx9D+lhlnJRSG37YgvnFb+vO488j+Q0E8zAqozOHUvd1QcTaLZSaLZycCEGjw+E03N0YttXtuQzapNeRSs8dAyXoq4xPQpiWs4wxF8MOQ2DGI+WIoeIh5RSUpCH5Tb5cRExQPWahmXw4wS52vtq80WlbzkOorn53PGpJWMtkRnqsghGXjOOIpMy7bINuznoiZDoai1UFjvYq2RiC0xk7TZy7zBo1sLEibFuDgu0y+R+WnxSLx78i5cTTYKvttjKFTVBt1nzCYrd44Z05r0fbBiSKCkRiZB6xntpNLpIN1IiVo7HLv81aU1C1jrZZoPljIWhkHug22zytL4Qs7ofyF5f/05/MJ33URbnNSaUL4uOYUnUvtza9KOXjl2b6MfeyS+mPav/JhVO1F3lgfZIvoobjC3RDgRYEDO/LbJh+YcC/9NGkXud8HFMSIhpsJAaXBFVVTA+tkyfpk2mYfiy0LKCIeDx/DxjSsOXQ8+GeTOUFGaFZR95maM1PbV2n0tdiR9j5Fna29tyF4Je6VMbJkOXr/3V0lJpmXKIIqmz6UrBgZAgmxn2dh3mGy/QRgZhynCyAiCWrYTjgtcNpCKdutJP63EeXYSq1e4UTDINRE0mfE//X7i/WvXMHv5ha3L8j/18XLpqZz3x4cpMEc2U16hNnPTT7+j4GWpnbvUqXv50R3DmgeOIP/ujeTZ6+jvqCE5u4WvioZ1S4JyX1aty2fAe1qAB0HTZXyGEjXp01BoQ/ux89jueRhkFWKKzGjj3ciyv+NNj2/m7v6f8o9/jGfVxfkcY+s8d2a7z18TJFGWAypK78Wpe9mtWcj93y3k2YMPvDvipUkvMNUW/ahGj+Fjt9a50SnpIGkGkmqQNbttSr+mMIHdl/u9FLEvJfjlCMMk55+LWLR5IhseW9QqsXsgsjdsKdo0Feio9q69tPdH8UDaN8UYsQ48OQnoFpmG8QqyJTpBmZKsYzLp+LzReVVoXgXZG3xkaPyyFsvJUTlMl7DWSvzntdO58eb/1yvhpr2JkpJMy58bWicG9uWrx6eR8l4DeksLssPRo+F59mqdmIruCUrE7vQS+2zo66M6FAxr51P3KZ9vRauq6lZ7glFw92LerDiZO//cPSOjVvNw69JrO/z+6DEbKW1OClBKDPaGN/JdGPil6o/JaO8dXN2Qw7YvBhD/5s9oeyb3fMPzqPlt9xQnDzkMA3qzFIFI/BZodXXc3t+vlV32/kjWTX497G1TV3u4euYsvtujcBMupzxxBwUrg8+g/rH8WDb8fRTH/DUwuTje5OaCISt5d9ORXS6m1RlFu1Opaonh9Lz1PbL/HkGCJZPnthqHd+4ew98HjCGSRNOrfj8Lc5PG9iuhaPrz7b6/esdpNEyrAeqp/T6328nU0eCRmlG89foJna7n2G0QW9Y+hCllrYeiPw8DwNKFpFzHBz/zp5/O5bMVX0W8bW9RP8gSdtXgvkDS/apq6oSRqA7/oEv26hS8AkWXmjHFdF8dbEzuTv5f3kcc8+PN3d4XwMDndeQfQgsfCKKLbLMx8us6rHLwwfT0P/7Im2OmMvSBTZRcN7yXW9czDLhnAwuC1Ag51Fi8vYsav/sxOmEnuefXs+2fUdmdQNCKMDKixOhfJV5NC+5WPHnDWTifycYWZDBmcmkc/aebMCRIu2EH/x38RdD9f+tSuOce/4xGSm3boE9x6xz7p5mts08mj4EUwod82qD1fF86GKczMND8u+2DGZZRSWFC77jNVzj7s8tXz4yE0HU1guE8byKN/aPjkcGACS/P4h8Xvs5vYgOLMn1x6iiefvQYv+TrflxUdCKlT/uTeB3N/sFcv/cURmy5ifUzZwes291K6pGwxK1x5VudDwhln9Thwy8ZkLLW5/diqD03a6NVVnH6Medx11cfHnBVoBOW70KbnHXAGhm2WoP0t9eh9XBY0erybE6p7ngmta/QauvIm7OWsmsKu1/5fB8kHUa/9HuevaRjqegT15+N+fY4Nj8Tw7DbN0RFbhbgraYkXj3tWPSmHVHZH4A0biTWx6qxyqH79dOmrWDlmznQg2kESVs0zI29qxLWoLuYW18YsMypWRl99gbK/z4I37BcpCF+SWxJ07ssZRuMrJfWcMKGGXz3SvuJp3CY1xLLX9ZeFrX2RELNjMnUTPYRQ/cnKg4lDN3AiDA0vFvHE54MgRwTQ/XbOcxKfYF0pX34zohF/4N1fjzJNR3Ebhu0FicqeW8AQ3KCq+soTons3cH3sX9xI19cxwPwWMXDERk7cWtmGr02tu1KA0BTFdQwY0PenD+VtJUSwcqKuTwWvikfCsDUjKIOay24dTMbXVlcVjucV/t/iyLJjFt+EXySgqRCitHxbKdmldCil/+MuVGiRbdwzJrz0J5LJxa/5KpaWkbu7HQGVF1P0XnPtq4/9peL0b5NIXW/62FyaqSslxj82o2sv/wpzJJC4ZLLSX4lBjvVEbfr45eO5qu6adSMMdh28TOdbwB4UQKKTbUiQUt+4As+VDaBJ8lE+i861roedA0bBtrW7bh1M/Tyy6xhoIVhv93QsQfR6yN5cQXmlgxqh0Wvm0z+3O8xa4kgb8Lkgqz5gWF2kssbslJx6mITtaMV5PTuJYFrqoIrSiGW2W9YMG/cHp34d8MI+fu7g7lRwm2YCfaEPFmXT3ldAtLpcZjinZTcPApZA0sjDHvuRjZeM6f9DsOkRbei7kkejhaGWQlr4ijR7CTZ7iTu81p2npzcI4nfss/oUvJxpGh31XBjxneAGd0waFADQzJX1udS/FkB6W4P1be58CxNJmuxB0mXMRf6vbNSWQVafUO32qE3NWFbuoVx99/I5/f8i3Ql/BDJpR4fWzwZFCTXsmFn5FXgu4tmlzA5VHw+hUu2n8Bz+Z8FVPcOl0qthWmv30Z2BOG0gkMLYWR0E8liYcmRb6FIwfMDjNXxJK8PLzk0ZZ2HlHXdb5MhSxzpKGatKxef0X6AkGevA6BRtdHkbfNoJFpc7dbdS6Nq45N1ftWgtOVSh1U7VZ9CTb3/XGywZ2JTfCRY3OTY6lvXKXElkWVrZKRjJ9XetvPWuC6FAc/2TSjFfUvOIflHCynvBh5fmf8rg3xjGJd3EcvHvQNA8/pk+q0Jfk0tDSq530r4LtM4dcN5xL8Th33ektbvixb2xzPVxOTU7Z22KevHRoxf1pK8rpAjB1zCiqPe6voPxF/cSkrwhqWEZCSAutZGR8JKnWGpbMHwRJYUfXTKVp4/qT/9vulcYUr2apjr/PerL9WBrkQWAuhJlHit//yQ66jbi7FnJMCw4M+2ZIBWZw37nAIkr2nAl2ijJTv8F7ak+lW5gmHKysQX5LfH7/Dii7HiarJjmPwx2X1NzE9b0OrqorrPpC0qDQWmDquwR5Opq8+nuiHWH2460gmAd5T/37iFdga8uptRoy7j1wmvYpYiM8zmtcTy0KrpDM6qRK2I3LsbDTyqCVZvRDoxuspLvUFLtpmqsf7//zjsNbJMsdRpTtb7Ap+zn6oGsKMkDTlTZ8eZZt4f/TJ3xZ3PlpS9BQMt9PtGw+FTUaDV0KicOSXAYyZpkPHU4k5j5rXGRlKfXcwPf8riFEdlWAP1DV4nK92DaFAdDI3bTU2yg6q6uC5LxYfD5uZ0ViwawgCWBCzXNZnlxXm48zS6kgHZpBv0+0pU+D6cEUZGN5AdDrShHVcz/cmtB6g+9CZKGFNG8SY3xwdJBNzL1pY01D2qFmVNiRS8vLeTC+9HbalIByApoYW4faRiS5qSybPXcXV8JVfHV7K3XIuaqGHqn4e6oySs/UeT4fdXo24PnuQt/bSSjGvSmfejv5s1tXTe2S90x2G6O4G4pYGddv69i9jxt8ksm6yjyDqD4vxx0rGKB1kycGlm1jVkcWL6RlryYohzDgGnl/QHbWjvd6NSvAGOEgXncBks4c0lqw4JzSpHVERJMgxkj4a+fkvYCkFfNxYyyvIDd6Zs4fhL13PLht8DYK9W2x1b9mpIuoHS6EFbtwkAZXwhxJjDNjS8CSY8ye0HB07dS7Xuv7f1tERMuo4rNkQszp5z2jLQhBSjtipvdYRab0HyuZA9GiYnqGHkvMu+EGo8koSvIAPdEvx3p6zzwDrwxSs0j/QbGS0ua4/lZAVD88mwt26AEf1pbNvHS1EvnEhzjtKx1HA30QydT52xxNwfR/1xMa2GRcA6Ngnqm8i5sITX12ZxXmxxWBXNAdZ5Xdz565X0m2vGMywbZdfuQyLhs6fQLTLOtMChS9UEnaLf7PU2+/vpItXE541HtK6zw5lC8YZMLA0ym2bs9ThZ+WLYpzCsbV9Tfr4BJScBJTkGU4MLJInP7nyYrH2kzBt0F5cs+C3Gpu1hTaZ8VjuawZZvyDd1bux/0jyq1ftilVWOz9zCR65RaHueW8OQUH1d8y5qhkSzZiVWaWvzTnciy9YNYMgdHU/wFatm4mRfRIIIdZqTH1zRyRk5YDB0ejfx++CvLyKMjG7QMr2QhbPn0lFNw7tuu5GM+shmc6OBrdrLnMGDiFmYxoj4rs+KlT0+GGut383ZHS2cuoYYPm8Y2fr3kxPe5FRH+/Oy/ey5zBgzjbJJ3ThYD6HtrmTO4EEA5BfW4k3v+IzIPoNHrvsfLBs2B+2O+t/j78ylzAw+f8x/Xib230F/Rw0/7BpI8vklXLdtLbc/tb/cbeeDQz2KckgNx7twr3aQsTT8e1j2aEiLVkV0nNVjDc747wx+Hf82E6xmfn7IPwAY+eRNZP68X0jaqm3oTU0B59X4ZS3mkUPxZIQ311Z9mZPNU9vn2XziTON/fznP/8cdAJloNSYcZaH3F7PNjDNX7rDiN/iVNofNWo3mdiMBOWW5FF+W12lbE7ZrOD7soGK6YSAtWoUyaXRr4ncwfA6ZX8e/DcDpm05vNf57A/tGW6tMbU9lj8S++zOOY4+kYlL03Bn7anNtU108PXgsW5+2oSS1NzAAnBOcbMobyKBZS3hzWDabV2Tyj4zw4vsvePFP5P7Q+++J/dGRDorqvDUjzaz+0+zOV9yPDS8PRz7WxaYLXgq94p5Lv+1iO9suennPwsC+JUG28/kXbzH9gqvC7u/eqT8qsgbvwzkFa1r/X+WN5butQ7u0n8raeL5xDuXcAW335i8fjGLIw6ELFF6y+Dr+Pv5DLooNP4TsL7uOZ8OdhZ2vKDikEUbGQYB1VxPaxm1IsoQ6bTSGfGAko7pTTFSc5UOJIBHq22lPkaM4OJSLzUuGgemH1eghKhWrJ4xjy5Wg7Bl6LS3JY5mUR3J8C3M2f0uC3PGAufDfN5H3n43oeVl88enrnH7ihVBZ4/8yORHOb7+NIYN7pAslzLCevbgKXWwfIWGoMgNeN0Lq0lt3N6Nt6FrxtIxLyzjddgLa4Fy+/OAVABbc9Ai+G/0HrNdlZo04Cd0ZfJCnrd+MrT4L99DgBTINk8TTc/9NoqwTJ5uAwLCFm3ZO4rvtg9ttJ6d4aHGYiNkcOgnIXq5AuQPDBL7hbW3U6qzYy/yzjobWZhqpZTvp91QdZTOP6FAyNPebBli1qbulAAL4cMhH+Ab77zmfoTNp0Q0RezaOG7iF4TEVfDMll01PD0RW2rdw8H1NGDt3YahqVNvfEfIPq8kvyaX4opxu7UfSIffplTw9dzJP7+1ndQOoY+jtayibOQb3ke3vwdifHGQ+/2ur8bvy2ERON59A3fQhLH60fT7VOq+LG//wBwCyXD3o7l66jhWnZlP4+e6Q0uJv/DCFoXevRweyZi+n7uKxtGRF5z0jGZC6yovs61vvzNy7/h9DzTr7P/v7M++RRznmxdvI+9zH2I038uv/dZxn88JbT3PKnDsC6r30JKsbctjYzUkCr8fEu5uObP07cVd41+X/Vp7N/IItzM5Z0um6f6oYy1fbhuK7VGbAmwf/bPxeROJ35Agj4yBATXJgGj4Ibd0mLKu2ow3tF3Tm0lpW31oATQOa7s7hnZnZXDT814iOV+9z8NNL40hs6uTlJ0ntiv50RoKsdD3k5yDC0Dp+oTdeNonKo0CxtIWQGbrMmLxSbsv5otO6KTdf+RGPpJ/FkLtXcvTM64nZugLD579WUmMz+e/6r8muk7PwJPprqbhzfZgiNDAAf66BbGCYdHac0fZyjtshk/3qhsDf7PF0uYia3tICLS3ILjdHz7y+3feSYWB3Let4B4aBVlmN1dkWjrDpyf5cWvhL699DzLag995l249nbVVm0BoyEqDYNFoG+ogpMndoZO2NTpR8IG9rm1E3+SQsTZD9WTmquk9yu2Ggt7SQ917HSbn67qqQhmpXsErm1pAHrYuueLOs4ZA9aI2NDH7MG3S+QC8uizgnp1voGlr5LvLfDT0wrpmSSXNO8P7H0miQ9WUFqtMJQYxZ3emko3G6pBno7rbneW9SetI321rv54YBSmtcv+yDtKZeOD+6hh5GArOkSq0qWYbH0+0id/sjqwa2zbvQE+NCeoE7Y8fZZu48ZV5Y6w4161yUuKzVg5CheIkNMXmzl3QlBkPxe6TNwec0Wsk1xUZV3awzdEPC6KAwX7gYhoShtT0nkh7exdZUhR93FnBKYyqSZPDR0HkB4VM+Q+OsTWdjGBK7muIwdBnJfOgYGAcTs2fP5pFHHqGiooKRI0fyxBNPcPTRR/dJW4SR0QNUai2csOw6UiOIZQ+FZlUg3oaEvy6HaWcMii3IzGpVTYAihvzjSpLzJ/GGZwKXjVka1rHWN2ayavlA+m8I/QJ0ZphpGNg3xkL8liZ0JY7m3OgcP3W1D6MxfBlKuaYei0nGm9w+PEP2aph3NbQWNApGc7aMnNH+7ZVtb2CCtfM31g2JO3l5eBW6243jw58DxgOGz9uqUOONy8adrqNbjG7XTJAAKbNtENUk22g6fgiODzoI5ekiutPZcXhQJxg+L1pdm2Ecs2I4rzdPxprs2iNDHPx+2VSbhsvZcUC/JBkosT5SV0P9QHPoXAoDzM1tL3BbjUHSJneHqkHRUBMyVdQhpSfii4ui5FqYGCuioFQRJQyPp9PzmRRnR9ISaMoLvBfsVQZJG52dbp+2ykNDQ/vnPmlT8Fh7raoKx4f+vCv7lCPQbB2/cmWf3mnf0RUMVeXj96eABOZxdZzVf23rd+98Pg2TUyJzY6D1lLipGYilJbt73gxZ9Z9ba2k9WlU1st1Kd4JvTVlOrgtTZj1WtjHI5OWY2I381DKky8eMBj/PG03OySUcldJ5cdcDGZfTSpHTiiQZ/DPliADvmM9QKNqdGpCgLik6VUfaSVnnQ/YeAgbHQZCT8fbbb3Prrbcye/Zspk6dyrPPPstpp53G+vXrycvrPEQ32ggjoxuYGzUeqR3I7cmBsfM1moT5mwTkHprJU0s7CRLfh4TXl2BpmcBnySMAOLnfpqBu819q83CrZoqL0xjwcegBqeJWcaVa8Y3oZJonCKu8dsZa3EFVNua7ZH4qKSCfNUG2bMNYvo4E82iac7tX8Rv8rnzbN6vQfOGHLKgVu1BUDZOlvbSg7PShbe1cOao3cKcaSFnuoBVgu4ue4KPySAv9P+iBnUeJrEcXkQXIRwznb68O63A9tzeMqUhDwvbtauJsY2jKUTpN2rbV+kPLErd5kH9YEVnDI0QtLkWxWqALRkZGYhOVDbFBvTiHIvqqDSR5B+OLSQ1YnrTJFVZsvenb5aR08diK04ehyOjm9sau7NMxNbrRthR1ce8dY6gq/f7mD+fZdesUPjthROt3g57Yhra7sv1GS9eQpI1EdcTjSeyaoSGrYG4yiCv1+H+XYSB5fSguFc0e+dDDmWkmKS78nICVHg+fNPkTvz8rHcnZ8SvI7aMRT84/F1GUNBnrJJXRCTu7vB+b4sNq8+Fx96z7xFqn01BrRUkOPoYxDInX1k3odD+SDM5Mg+QNna4qiBKPPfYYM2bM4JprrgHgiSee4Msvv2TOnDk8+OCDvd6ew8rI2BvfpuKLjjv42yV8PS2Ta5ZsCgjDyMHGgj88xSm3/RZLlPShDVVFMro2G23+8CeSPgQkiV3f2km3ttfOr3UkTgsAAArESURBVJ6bTky5lzycndZvVjYUY80YRJMzcg3+3353CY+Me4+THO0H9TPe/C39710aXv1o1Y3m6f7tKxmgGj6MCM+tWlkOlV0rXKh53OhBzp232UdjU3gzF1qLB7WTNutuN3ThGoWDZaOD3EcWdqHWdx+wcjXfj+p4EN3yLxNKUujzZBgSquHD8v6PJBw7hsqxoaWMkl5fg97ixCCS2vFdx9A8qGrw36D5tA7vq0/6v8/0tWdR1RgX9rG8zV5chtrp/Xegoq5fT8L6wGU9W9JwDytWoQwbhBpEoMBa0Yi3BwyM/Ul9fAE83vZ3yGmwX1aSWp5JycX5XTqWtdIgtsyLahj+/tUwUHcUoTTUoo7uH/H+9N/s4r6cjwnX6Xz+D1dRMMM/YRXPOp6dP4l/Zf/SyVZ7juV2o6peNK/eaZ+sedxhPQt5dyxk+/UTGXrljrDaEIwCqYzEpFq+3xY9z4zmpV37Y177gfxtoyi5pnv7Vl0mBt22FGPSKFRr6IkMVfXfjQdyHkLUxo6RHA9o3K8mkNVqxWpt/w7yer0sX76cu+66K2D59OnTWbSod/KG2mEcRpSWlhr4bxHxER/xER/xER/xER/xOYA+paWlfT1UbIfL5TIyMzP75HzExsa2W3bvvfcGbefOnTsNwPjpp58Clv/97383hgwZ0gtnqj2HlScjOzub0tJS4uLikKQDQ6Gpp2lsbKRfv36UlpYSHx/f180R9DDieh8+iGt9+CCu9eHD4XqtDcOgqamJ7Ozsvm5KO2w2G9u3b8fr7f3CZ4ZhtBuvBvNi7Mv+6wfbR29xWBkZsiyTm5vb183oE+Lj4w+rDutwR1zvwwdxrQ8fxLU+fDgcr3VCQkJfN6FDbDYbNlvnFdv7ktTUVBRFYdeuwPpolZWVZGRk9EmbDn0tUYFAIBAIBAKB4BDGYrEwbtw4vv7664DlX3/9NVOmTOmTNh1WngyBQCAQCAQCgeBQZNasWVxxxRWMHz+eyZMnM3fuXEpKSrjhhhv6pD3CyDjEsVqt3HvvvZ3G8AkODcT1PnwQ1/rwQVzrwwdxrQXd4eKLL6ampoYHHniAiooKCgsL+eyzz8jPz++T9kiGcQDrhQkEAoFAIBAIBIKDDpGTIRAIBAKBQCAQCKKKMDIEAoFAIBAIBAJBVBFGhkAgEAgEAoFAIIgqwsgQCAQCgUAgEAgEUUUYGYcpHo+HMWPGIEkSK1eu7OvmCKLMjh07mDFjBgUFBdjtdgYOHMi9997bJxVLBdFn9uzZFBQUYLPZGDduHD/88ENfN0nQAzz44IMcddRRxMXFkZ6ezrnnnsumTZv6ulmCHubBBx9EkiRuvfXWvm6KQNAthJFxmHLHHXeQnZ3d180Q9BAbN25E13WeffZZ1q1bx+OPP84zzzzD3Xff3ddNE3STt99+m1tvvZX//d//ZcWKFRx99NGcdtpplJSU9HXTBFFmwYIFzJw5kyVLlvD111+jqirTp0+npaWlr5sm6CGWLVvG3LlzGT16dF83RSDoNkLC9jDk888/Z9asWbz//vuMHDmSFStWMGbMmL5ulqCHeeSRR5gzZw5FRUV93RRBN5g4cSJjx45lzpw5rcuGDx/Oueeey4MPPtiHLRP0NFVVVaSnp7NgwQKOOeaYvm6OIMo0NzczduxYZs+ezd/+9jfGjBnDE0880dfNEgi6jPBkHGbs3r2ba6+9lldffRWHw9HXzRH0Ig0NDSQnJ/d1MwTdwOv1snz5cqZPnx6wfPr06SxatKiPWiXoLRoaGgDEc3yIMnPmTM444wxOOumkvm6KQBAVRMXvwwjDMLj66qu54YYbGD9+PDt27OjrJgl6iW3btvHkk0/y6KOP9nVTBN2guroaTdPIyMgIWJ6RkcGuXbv6qFWC3sAwDGbNmsW0adMoLCzs6+YIosxbb73Fr7/+yrJly/q6KQJB1BCejEOA++67D0mSQn5++eUXnnzySRobG/nzn//c100WdJFwr/W+lJeXc+qpp3LhhRdyzTXX9FHLBdFEkqSAvw3DaLdMcGhx8803s3r1at58882+boogypSWlvKHP/yB1157DZvN1tfNEQiihsjJOASorq6muro65Dr9+/fnkksu4eOPPw4YjGiahqIoXH755bz88ss93VRBNwn3Wu99UZWXl3P88cczceJEXnrpJWRZzCsczHi9XhwOB++++y7nnXde6/I//OEPrFy5kgULFvRh6wQ9xS233MK8efNYuHAhBQUFfd0cQZSZN28e5513HoqitC7TNA1JkpBlGY/HE/CdQHCwIIyMw4iSkhIaGxtb/y4vL+eUU07hvffeY+LEieTm5vZh6wTRZufOnRx//PGMGzeO1157TbykDhEmTpzIuHHjmD17duuyESNGcM4554jE70MMwzC45ZZb+PDDD5k/fz6DBw/u6yYJeoCmpiaKi4sDlv32t79l2LBh3HnnnSI8TnDQInIyDiPy8vIC/o6NjQVg4MCBwsA4xCgvL+e4444jLy+Pf/3rX1RVVbV+l5mZ2YctE3SXWbNmccUVVzB+/HgmT57M3LlzKSkp4YYbbujrpgmizMyZM3njjTf46KOPiIuLa827SUhIwG6393HrBNEiLi6unSERExNDSkqKMDAEBzXCyBAIDkG++uortm7dytatW9sZkMJ5eXBz8cUXU1NTwwMPPEBFRQWFhYV89tln5Ofn93XTBFFmr0zxcccdF7D8xRdf5Oqrr+79BgkEAkEEiHApgUAgEAgEAoFAEFVEFqhAIBAIBAKBQCCIKsLIEAgEAoFAIBAIBFFFGBkCgUAgEAgEAoEgqggjQyAQCAQCgUAgEEQVYWQIBAKBQCAQCASCqCKMDIFAIBAIBAKBQBBVhJEhEAgEAoFAIBAIooowMgQCgUAgEAgEAkFUEUaGQCAQCAQCgUAgiCrCyBAIBIKDAE3TmDJlCr/5zW8Cljc0NNCvXz/uueeePmqZQCAQCATtkQzDMPq6EQKBQCDonC1btjBmzBjmzp3L5ZdfDsCVV17JqlWrWLZsGRaLpY9bKBAIBAKBH2FkCAQCwUHEv//9b+677z7Wrl3LsmXLuPDCC1m6dCljxozp66YJBAKBQNCKMDIEAoHgIMIwDE444QQURWHNmjXccsstIlRKIBAIBAccwsgQCASCg4yNGzcyfPhwRo0axa+//orJZOrrJgkEAoFAEIBI/BYIBIKDjBdeeAGHw8H27dspKyvr6+YIBAKBQNAO4ckQCASCg4jFixdzzDHH8Pnnn/Pwww+jaRrffPMNkiT1ddMEAoFAIGhFeDIEAoHgIMHlcnHVVVdx/fXXc9JJJ/Hcc8+xbNkynn322b5umkAgEAgEAQgjQyAQCA4S7rrrLnRd56GHHgIgLy+PRx99lNtvv50dO3b0beMEAoFAINgHES4lEAgEBwELFizgxBNPZP78+UybNi3gu1NOOQVVVUXYlEAgEAgOGISRIRAIBAKBQCAQCKKKCJcSCAQCgUAgEAgEUUUYGQKBQCAQCAQCgSCqCCNDIBAIBAKBQCAQRBVhZAgEAoFAIBAIBIKoIowMgUAgEAgEAoFAEFWEkSEQCAQCgUAgEAiiijAyBAKBQCAQCAQCQVQRRoZAIBAIBAKBQCCIKsLIEAgEAoFAIBAIBFFFGBkCgUAgEAgEAoEgqggjQyAQCAQCgUAgEESV/w/gFwX1BmrC2wAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 1000x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "np.random.seed(42)\n",
     "spheres = []\n",
@@ -191,14 +206,14 @@
     "    sphere = Sphere(material=material, center=(x, y, 0), radius=radius)\n",
     "    spheres.append(sphere)\n",
     "\n",
-    "group = GroupObject(spheres)\n",
+    "group = ObjectGroup(spheres)\n",
     "\n",
     "x = np.linspace(-5, 5, 500)\n",
     "y = np.linspace(-5, 5, 500)\n",
     "xx, yy = np.meshgrid(x, y)\n",
     "\n",
     "def get_epsilon(x, y):\n",
-    "    mat = group.query_material_at_point((x, y, 0))\n",
+    "    mat = group.material_at((x, y, 0))\n",
     "    return 0 if mat is None else mat\n",
     "point_in_object_vec = np.vectorize(get_epsilon)\n",
     "\n",
@@ -216,56 +231,6 @@
     "plt.ylabel('Y')\n",
     "plt.show()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# benchmark\n",
-    "sphere_counts = [1000, 2000, 3000, 5000, 7000, 10000, 15000]\n",
-    "times = []\n",
-    "\n",
-    "for num_spheres in sphere_counts:\n",
-    "    np.random.seed(42)\n",
-    "    spheres = []\n",
-    "    for _ in range(num_spheres):\n",
-    "        x = np.random.uniform(-5, 5)\n",
-    "        y = np.random.uniform(-5, 5)\n",
-    "        radius = np.random.uniform(0.05, 0.2)\n",
-    "        material = np.random.randint(1, 6)\n",
-    "        \n",
-    "        sphere = Sphere(material=material, center=(x, y, 0), radius=radius)\n",
-    "        spheres.append(sphere)\n",
-    "\n",
-    "    group = GroupObject(spheres)\n",
-    "    \n",
-    "    # Measure query time\n",
-    "    start_time = time.time()\n",
-    "    material_map = point_in_object_vec(xx, yy)\n",
-    "    end_time = time.time()\n",
-    "    \n",
-    "    elapsed_time = end_time - start_time\n",
-    "    times.append(elapsed_time)\n",
-    "    print(f\"Number of spheres: {num_spheres}, Time taken: {elapsed_time:.2f} seconds\")\n",
-    "\n",
-    "# Plot the results\n",
-    "plt.figure(figsize=(10, 6))\n",
-    "plt.plot(sphere_counts, times, 'o-')\n",
-    "plt.grid(True)\n",
-    "plt.xlabel('Number of Spheres')\n",
-    "plt.ylabel('Time (seconds)')\n",
-    "plt.title('Performance Scaling with Number of Spheres')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

From b3a4743e4166c411295d192069b98bffbd6aa338 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 17:04:56 -0800
Subject: [PATCH 20/37] Add vector3 arrays and enable creation of Prisms and
 SlantedPrisms

---
 python/ctlgeom.py   | 24 +++++++++++++-----------
 python/libctlgeom.i |  3 ++-
 python/test.ipynb   |  2 +-
 3 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/python/ctlgeom.py b/python/ctlgeom.py
index cf7ff11..30a3a7b 100644
--- a/python/ctlgeom.py
+++ b/python/ctlgeom.py
@@ -26,7 +26,7 @@ def make_vector3(x, y, z) -> geom.vector3:
     return v
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass
 class BoundingBox:
     """A bounding box.
 
@@ -267,14 +267,16 @@ class Prism(GeometricObject):
 
     def to_geom_object(self) -> geom.geometric_object:
         """Convert the prism to a geometric object."""
-        # Convert vertices list to array of vector3
-        vertex_array = [make_vector3(*v) for v in self.vertices]
+        # Create a vector3 array and populate it
+        vertex_array = geom.vector3_array(len(self.vertices))
+        for i, v in enumerate(self.vertices):
+            vertex_array[i] = make_vector3(*v)
 
         if self.center is None:
             return geom.make_prism(
                 self.material,
                 vertex_array,
-                len(vertex_array),
+                len(self.vertices),
                 self.height,
                 make_vector3(*self.axis),
             )
@@ -283,7 +285,7 @@ def to_geom_object(self) -> geom.geometric_object:
                 self.material,
                 make_vector3(*self.center),
                 vertex_array,
-                len(vertex_array),
+                len(self.vertices),
                 self.height,
                 make_vector3(*self.axis),
             )
@@ -311,16 +313,16 @@ class SlantedPrism(GeometricObject):
 
     def to_geom_object(self) -> geom.geometric_object:
         """Convert the slanted prism to a geometric object."""
-        raise NotImplementedError
-        # This is not working yet
-        # Convert vertices list to array of vector3
-        vertex_array = [make_vector3(*v) for v in self.vertices]
+        # Create a vector3 array and populate it
+        vertex_array = geom.vector3_array(len(self.vertices))
+        for i, v in enumerate(self.vertices):
+            vertex_array[i] = make_vector3(*v)
 
         if self.center is None:
             return geom.make_slanted_prism(
                 self.material,
                 vertex_array,
-                len(vertex_array),
+                len(self.vertices),
                 self.height,
                 make_vector3(*self.axis),
                 self.sidewall_angle,
@@ -330,7 +332,7 @@ def to_geom_object(self) -> geom.geometric_object:
                 self.material,
                 make_vector3(*self.center),
                 vertex_array,
-                len(vertex_array),
+                len(self.vertices),
                 self.height,
                 make_vector3(*self.axis),
                 self.sidewall_angle,
diff --git a/python/libctlgeom.i b/python/libctlgeom.i
index 90874f0..c7a4ed8 100644
--- a/python/libctlgeom.i
+++ b/python/libctlgeom.i
@@ -58,6 +58,7 @@
 
 %include <carrays.i>
 %array_class(geometric_object, geometric_object_array);
+%array_class(vector3, vector3_array);
 
 %extend geometric_object_list {
     void set_items(PyObject* list) {
@@ -105,4 +106,4 @@
 %ignore get_resolution;
 %ignore get_grid_size_n;
 
-%include "ctlgeom.h"
\ No newline at end of file
+%include "ctlgeom.h"
diff --git a/python/test.ipynb b/python/test.ipynb
index 8d4d521..3ed1a5a 100644
--- a/python/test.ipynb
+++ b/python/test.ipynb
@@ -110,7 +110,7 @@
     "\n",
     "print(group.material_at((1, 0, 0)))\n",
     "print(group.material_at((2, 0, 0)))\n",
-    "print(group.material_at((3, 0, 0)))\n"
+    "print(group.material_at((3, 0, 0)))"
    ]
   },
   {

From 3a7cdce380c9ed2170a61ea2dbb2496c4c46fc22 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 17:07:47 -0800
Subject: [PATCH 21/37] Clean up .i file

---
 python/libctlgeom.i | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/python/libctlgeom.i b/python/libctlgeom.i
index c7a4ed8..8e9e700 100644
--- a/python/libctlgeom.i
+++ b/python/libctlgeom.i
@@ -1,18 +1,18 @@
 %module libctlgeom
 
-/* Include the header files first */
+/* Include all SWIG modules first */
+%include "cpointer.i"
+%include "carrays.i"
+%include "ctl-math.h"
+
 %{
 #define CTL_SWIG
 #include "ctlgeom.h"
 #include "ctlgeom-types-swig.h"
 %}
 
-/* Include the type definitions */
 %include "ctlgeom-types-swig.h"
-
-/* Properly wrap vector3 structure */
 %include "ctl-math.h"
-
 %include "cpointer.i"
 %pointer_functions(int, intp);
 
@@ -54,7 +54,6 @@
     free($1);
 }
 
-/* Add these typemaps before the geometric_object_list declaration */
 
 %include <carrays.i>
 %array_class(geometric_object, geometric_object_array);
@@ -97,9 +96,7 @@
     }
 }
 
-// Ignore the original items attribute to prevent conflicts
 %ignore geometric_object_list::items;
-// Ignore deprecated functions
 %ignore geom_fix_object;
 %ignore geom_fix_objects0;
 %ignore get_grid_size;

From 1c4a78e5a1c575352a36c0ad24eb88166a99a484 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 17:14:30 -0800
Subject: [PATCH 22/37] Add tests to the ctlgeom module

---
 python/test_ctlgeom.py | 564 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 564 insertions(+)
 create mode 100644 python/test_ctlgeom.py

diff --git a/python/test_ctlgeom.py b/python/test_ctlgeom.py
new file mode 100644
index 0000000..592cbb0
--- /dev/null
+++ b/python/test_ctlgeom.py
@@ -0,0 +1,564 @@
+import pytest
+import numpy as np
+from ctlgeom import (
+    BoundingBox,
+    Sphere,
+    point_is_in_object,
+    Cylinder,
+    Wedge,
+    Cone,
+    Block,
+    Ellipsoid,
+    Prism,
+    SlantedPrism,
+)
+
+
+class TestBoundingBox:
+    """Tests for BoundingBox functionality."""
+
+    def test_creation(self):
+        """Test creating a BoundingBox object."""
+        low = (-1.0, -2.0, -3.0)
+        high = (1.0, 2.0, 3.0)
+        box = BoundingBox(low=low, high=high)
+
+        assert box.low == low
+        assert box.high == high
+
+        geom_box = box.to_geom_object()
+        assert (geom_box.low.x, geom_box.low.y, geom_box.low.z) == low
+        assert (geom_box.high.x, geom_box.high.y, geom_box.high.z) == high
+
+    def test_invalid_box(self):
+        """Test that creating an invalid bounding box (low > high) still works."""
+        low = (1.0, 1.0, 1.0)
+        high = (-1.0, -1.0, -1.0)
+        box = BoundingBox(low=low, high=high)
+
+        # The box should still be created, even though it's "invalid"
+        assert box.low == low
+        assert box.high == high
+
+
+class TestSphere:
+    """Tests for Sphere functionality."""
+
+    def test_creation(self):
+        """Test creating a Sphere object."""
+        material = "test_material"
+        center = (0.0, 0.0, 0.0)
+        radius = 1.0
+        sphere = Sphere(material=material, center=center, radius=radius)
+
+        assert sphere.material == material
+        assert sphere.center == center
+        assert sphere.radius == radius
+
+    def test_volume(self):
+        """Test calculating the volume of a sphere."""
+        sphere = Sphere(material="test", center=(0, 0, 0), radius=1.0)
+        expected_volume = 4 / 3 * np.pi
+        assert abs(sphere.volume() - expected_volume) < 1e-10
+
+    def test_bounding_box(self):
+        """Test getting the bounding box of a sphere."""
+        center = (1.0, 2.0, 3.0)
+        radius = 2.0
+        sphere = Sphere(material="test", center=center, radius=radius)
+
+        low, high = sphere.bounding_box()
+
+        # Check that the bounding box extends radius units in each direction from center
+        assert all(l == c - radius for l, c in zip(low, center))
+        assert all(h == c + radius for h, c in zip(high, center))
+
+    def test_point_in_sphere(self):
+        """Test checking if points are inside or outside a sphere."""
+        sphere = Sphere(material="test", center=(0, 0, 0), radius=1.0)
+
+        # Test points that should be inside
+        assert point_is_in_object((0, 0, 0), sphere)
+        assert point_is_in_object((0.5, 0, 0), sphere)
+        assert point_is_in_object((0, 0.5, 0), sphere)
+        assert point_is_in_object((0, 0, 0.5), sphere)
+
+        # Test points that should be outside
+        assert not point_is_in_object((1.5, 0, 0), sphere)
+        assert not point_is_in_object((0, 1.5, 0), sphere)
+        assert not point_is_in_object((0, 0, 1.5), sphere)
+        assert not point_is_in_object((1, 1, 1), sphere)
+
+    def test_negative_radius(self):
+        """Test creating a sphere with negative radius."""
+        sphere = Sphere(material="test", center=(0, 0, 0), radius=-1.0)
+
+        # volume is negative for negative radius
+        assert sphere.volume() < 0
+
+
+class TestCylinder:
+    """Tests for Cylinder functionality."""
+
+    def test_creation(self):
+        """Test creating a Cylinder object."""
+        material = "test_material"
+        center = (0.0, 0.0, 0.0)
+        radius = 1.0
+        height = 2.0
+        axis = (0.0, 0.0, 1.0)
+        cylinder = Cylinder(
+            material=material, center=center, radius=radius, height=height, axis=axis
+        )
+
+        assert cylinder.material == material
+        assert cylinder.center == center
+        assert cylinder.radius == radius
+        assert cylinder.height == height
+        assert cylinder.axis == axis
+
+    def test_volume(self):
+        """Test calculating the volume of a cylinder."""
+        cylinder = Cylinder(
+            material="test", center=(0, 0, 0), radius=1.0, height=2.0, axis=(0, 0, 1)
+        )
+        expected_volume = np.pi * 1.0**2 * 2.0
+        assert abs(cylinder.volume() - expected_volume) < 1e-10
+
+    def test_point_in_cylinder(self):
+        """Test checking if points are inside or outside a cylinder."""
+        cylinder = Cylinder(
+            material="test", center=(0, 0, 0), radius=1.0, height=2.0, axis=(0, 0, 1)
+        )
+
+        # Test points that should be inside
+        assert point_is_in_object((0, 0, 0), cylinder)
+        assert point_is_in_object((0.5, 0, 0.5), cylinder)
+        assert point_is_in_object((0, 0, 0.9), cylinder)
+
+        # Test points that should be outside
+        assert not point_is_in_object((0, 0, 1.1), cylinder)
+        assert not point_is_in_object((1.5, 0, 0), cylinder)
+        assert not point_is_in_object((0, 0, -1.1), cylinder)
+
+
+class TestWedge:
+    """Tests for Wedge functionality."""
+
+    def test_creation(self):
+        """Test creating a Wedge object."""
+        material = "test_material"
+        center = (0.0, 0.0, 0.0)
+        radius = 1.0
+        height = 2.0
+        axis = (0.0, 0.0, 1.0)
+        wedge_angle = np.pi / 2
+        wedge_start = (1.0, 0.0, 0.0)
+
+        wedge = Wedge(
+            material=material,
+            center=center,
+            radius=radius,
+            height=height,
+            axis=axis,
+            wedge_angle=wedge_angle,
+            wedge_start=wedge_start,
+        )
+
+        assert wedge.material == material
+        assert wedge.center == center
+        assert wedge.radius == radius
+        assert wedge.height == height
+        assert wedge.axis == axis
+        assert wedge.wedge_angle == wedge_angle
+        assert wedge.wedge_start == wedge_start
+
+    def test_volume(self):
+        """Test calculating the volume of a wedge."""
+        wedge = Wedge(
+            material="test",
+            center=(0, 0, 0),
+            radius=1.0,
+            height=2.0,
+            axis=(0, 0, 1),
+            wedge_angle=np.pi / 2,
+            wedge_start=(1, 0, 0),
+        )
+        expected_volume = np.pi * 1.0**2 * 2.0 / 4
+        assert abs(wedge.volume() - expected_volume) < 1e-10
+
+    def test_point_in_wedge(self):
+        """Test checking if points are inside or outside a wedge."""
+        wedge = Wedge(
+            material="test",
+            center=(0, 0, 0),
+            radius=1.0,
+            height=2.0,
+            axis=(0, 0, 1),
+            wedge_angle=np.pi / 2,
+            wedge_start=(1, 0, 0),
+        )
+
+        # Test points that should be inside
+        assert point_is_in_object((0, 0, 0), wedge)
+        assert point_is_in_object((0.5, 0.1, 0.5), wedge)
+        assert point_is_in_object((0.1, 0.1, 0.9), wedge)
+
+        # Test points that should be outside
+        assert not point_is_in_object((0, 0, 1.1), wedge)
+        assert not point_is_in_object((1.5, 0, 0), wedge)
+        assert not point_is_in_object((0, 0, -1.1), wedge)
+        assert not point_is_in_object((-0.5, 0, 0), wedge)
+        assert not point_is_in_object((0, -0.5, 0), wedge)
+
+
+class TestCone:
+    """Tests for Cone functionality."""
+
+    def test_creation(self):
+        """Test creating a Cone object."""
+        material = "test_material"
+        center = (0.0, 0.0, 0.0)
+        radius = 1.0
+        height = 2.0
+        axis = (0.0, 0.0, 1.0)
+        radius2 = 0.5
+
+        cone = Cone(
+            material=material,
+            center=center,
+            radius=radius,
+            height=height,
+            axis=axis,
+            radius2=radius2,
+        )
+
+        assert cone.material == material
+        assert cone.center == center
+        assert cone.radius == radius
+        assert cone.height == height
+        assert cone.axis == axis
+        assert cone.radius2 == radius2
+
+    def test_volume(self):
+        """Test calculating the volume of a cone."""
+        cone = Cone(
+            material="test",
+            center=(0, 0, 0),
+            radius=1.0,
+            height=2.0,
+            axis=(0, 0, 1),
+            radius2=0.5,
+        )
+
+        expected_volume = np.pi * 2.0 * (1.0**2 + 0.5**2 + 1.0 * 0.5) / 3
+        assert abs(cone.volume() - expected_volume) < 1e-10
+
+        perfect_cone = Cone(
+            material="test",
+            center=(0, 0, 0),
+            radius=1.0,
+            height=2.0,
+            axis=(0, 0, 1),
+            radius2=0.0,
+        )
+
+        expected_volume = np.pi * 1.0**2 * 2.0 / 3
+        assert abs(perfect_cone.volume() - expected_volume) < 1e-10
+
+    def test_point_in_cone(self):
+        """Test checking if points are inside or outside a cone."""
+        cone = Cone(
+            material="test",
+            center=(0, 0, 0),
+            radius=1.0,
+            height=2.0,
+            axis=(0, 0, 1),
+            radius2=0.5,
+        )
+
+        # Test points that should be inside
+        assert point_is_in_object((0, 0, 0), cone)
+        assert point_is_in_object((0.4, 0, 0.5), cone)
+        assert point_is_in_object((0, 0.2, 0.9), cone)
+
+        # Test points that should be outside
+        assert not point_is_in_object((0, 0, 1.1), cone)
+        assert not point_is_in_object((1.5, 0, 0), cone)
+        assert not point_is_in_object((0, 0, -1.1), cone)
+        assert not point_is_in_object((0.9, 0, 0.9), cone)
+
+
+class TestBlock:
+    """Tests for Block functionality."""
+
+    def test_creation(self):
+        """Test creating a Block object."""
+        material = "test_material"
+        center = (0.0, 0.0, 0.0)
+        e1 = (1.0, 0.0, 0.0)
+        e2 = (0.0, 1.0, 0.0)
+        e3 = (0.0, 0.0, 1.0)
+        size = (2.0, 3.0, 4.0)
+
+        block = Block(material=material, center=center, e1=e1, e2=e2, e3=e3, size=size)
+
+        assert block.material == material
+        assert block.center == center
+        assert block.e1 == e1
+        assert block.e2 == e2
+        assert block.e3 == e3
+        assert block.size == size
+
+    def test_volume(self):
+        """Test calculating the volume of a block."""
+        block = Block(
+            material="test",
+            center=(0, 0, 0),
+            e1=(1, 0, 0),
+            e2=(0, 1, 0),
+            e3=(0, 0, 1),
+            size=(2.0, 3.0, 4.0),
+        )
+        expected_volume = 2.0 * 3.0 * 4.0
+        assert abs(block.volume() - expected_volume) < 1e-10
+
+    def test_point_in_block(self):
+        """Test checking if points are inside or outside a block."""
+        block = Block(
+            material="test",
+            center=(0, 0, 0),
+            e1=(1, 0, 0),
+            e2=(0, 1, 0),
+            e3=(0, 0, 1),
+            size=(2.0, 2.0, 2.0),
+        )
+
+        # Test points that should be inside
+        assert point_is_in_object((0, 0, 0), block)
+        assert point_is_in_object((0.9, 0, 0), block)
+        assert point_is_in_object((0, 0.9, 0), block)
+        assert point_is_in_object((0, 0, 0.9), block)
+
+        # Test points that should be outside
+        assert not point_is_in_object((1.1, 0, 0), block)
+        assert not point_is_in_object((0, 1.1, 0), block)
+        assert not point_is_in_object((0, 0, 1.1), block)
+        assert not point_is_in_object((1.1, 1.1, 1.1), block)
+
+
+class TestEllipsoid:
+    """Tests for Ellipsoid functionality."""
+
+    def test_creation(self):
+        """Test creating an Ellipsoid object."""
+        material = "test_material"
+        center = (0.0, 0.0, 0.0)
+        e1 = (1.0, 0.0, 0.0)
+        e2 = (0.0, 1.0, 0.0)
+        e3 = (0.0, 0.0, 1.0)
+        size = (2.0, 3.0, 4.0)
+
+        ellipsoid = Ellipsoid(
+            material=material, center=center, e1=e1, e2=e2, e3=e3, size=size
+        )
+
+        assert ellipsoid.material == material
+        assert ellipsoid.center == center
+        assert ellipsoid.e1 == e1
+        assert ellipsoid.e2 == e2
+        assert ellipsoid.e3 == e3
+        assert ellipsoid.size == size
+
+    def test_volume(self):
+        """Test calculating the volume of an ellipsoid."""
+        ellipsoid = Ellipsoid(
+            material="test",
+            center=(0, 0, 0),
+            e1=(1, 0, 0),
+            e2=(0, 1, 0),
+            e3=(0, 0, 1),
+            size=(2.0, 3.0, 4.0),
+        )
+        expected_volume = 4 / 3 * np.pi * 1.0 * 1.5 * 2.0
+        assert abs(ellipsoid.volume() - expected_volume) < 1e-10
+
+    def test_point_in_ellipsoid(self):
+        """Test checking if points are inside or outside an ellipsoid."""
+        ellipsoid = Ellipsoid(
+            material="test",
+            center=(0, 0, 0),
+            e1=(1, 0, 0),
+            e2=(0, 1, 0),
+            e3=(0, 0, 1),
+            size=(2.0, 2.0, 2.0),
+        )
+
+        # Test points that should be inside
+        assert point_is_in_object((0, 0, 0), ellipsoid)
+        assert point_is_in_object((0.9, 0, 0), ellipsoid)
+        assert point_is_in_object((0, 0.9, 0), ellipsoid)
+        assert point_is_in_object((0, 0, 0.9), ellipsoid)
+
+        # Test points that should be outside
+        assert not point_is_in_object((1.1, 0, 0), ellipsoid)
+        assert not point_is_in_object((0, 1.1, 0), ellipsoid)
+        assert not point_is_in_object((0, 0, 1.1), ellipsoid)
+        assert not point_is_in_object((1.1, 1.1, 1.1), ellipsoid)
+
+
+class TestPrism:
+    """Tests for Prism functionality."""
+
+    def test_creation(self):
+        """Test creating a Prism object."""
+        material = "test_material"
+        vertices = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (-1.0, 0.0, 0.0)]
+        height = 2.0
+        axis = (0.0, 0.0, 1.0)
+        center = (0.0, 0.0, 0.0)
+
+        # Test creation with center
+        prism = Prism(
+            material=material,
+            vertices=vertices,
+            height=height,
+            axis=axis,
+            center=center,
+        )
+
+        assert prism.material == material
+        assert prism.vertices == vertices
+        assert prism.height == height
+        assert prism.axis == axis
+        assert prism.center == center
+
+        # Test creation without center
+        prism_no_center = Prism(
+            material=material,
+            vertices=vertices,
+            height=height,
+            axis=axis,
+        )
+
+        assert prism_no_center.center is None
+
+    def test_volume(self):
+        """Test calculating the volume of a prism."""
+        # Create a triangular prism
+        vertices = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (-1.0, 0.0, 0.0)]
+        height = 2.0
+        prism = Prism(
+            material="test",
+            vertices=vertices,
+            height=height,
+            axis=(0, 0, 1),
+        )
+
+        expected_volume = 2.0
+        assert abs(prism.volume() - expected_volume) < 1e-10
+
+    def test_point_in_prism(self):
+        """Test checking if points are inside or outside a prism."""
+        vertices = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (-1.0, 0.0, 0.0)]
+        height = 2.0
+        prism = Prism(
+            material="test",
+            vertices=vertices,
+            height=height,
+            axis=(0, 0, 1),
+            center=(0, 0, 0),
+        )
+
+        # Test points that should be inside
+        assert point_is_in_object((0, 0, 0), prism)
+        assert point_is_in_object((0, 0.2, 0.5), prism)
+        assert point_is_in_object((0.2, 0.2, 0.9), prism)
+
+        # Test points that should be outside
+        assert not point_is_in_object((0, 0, 1.1), prism)
+        assert not point_is_in_object((1.5, 0, 0), prism)
+        assert not point_is_in_object((0, 0, -1.1), prism)
+        assert not point_is_in_object((0, -0.5, 0), prism)
+
+
+class TestSlantedPrism:
+    """Tests for SlantedPrism functionality."""
+
+    def test_creation(self):
+        """Test creating a SlantedPrism object."""
+        material = "test_material"
+        vertices = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (-1.0, 0.0, 0.0)]
+        height = 2.0
+        axis = (0.0, 0.0, 1.0)
+        sidewall_angle = np.pi / 6  # 30 degrees
+        center = (0.0, 0.0, 0.0)
+
+        # Test creation with center
+        prism = SlantedPrism(
+            material=material,
+            vertices=vertices,
+            height=height,
+            axis=axis,
+            sidewall_angle=sidewall_angle,
+            center=center,
+        )
+
+        assert prism.material == material
+        assert prism.vertices == vertices
+        assert prism.height == height
+        assert prism.axis == axis
+        assert prism.sidewall_angle == sidewall_angle
+        assert prism.center == center
+
+        # Test creation without center
+        prism_no_center = SlantedPrism(
+            material=material,
+            vertices=vertices,
+            height=height,
+            axis=axis,
+            sidewall_angle=sidewall_angle,
+        )
+
+        assert prism_no_center.center is None
+
+    def test_volume(self):
+        """Test calculating the volume of a slanted prism."""
+        # Create a triangular slanted prism
+        vertices = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (-1.0, 0.0, 0.0)]
+        height = 2.0
+        sidewall_angle = np.pi / 6
+        prism = SlantedPrism(
+            material="test",
+            vertices=vertices,
+            height=height,
+            axis=(0, 0, 1),
+            sidewall_angle=sidewall_angle,
+        )
+
+        assert prism.volume() > 0
+
+    def test_point_in_slanted_prism(self):
+        """Test checking if points are inside or outside a slanted prism."""
+        vertices = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (-1.0, 0.0, 0.0)]
+        height = 2.0
+        sidewall_angle = np.pi / 6
+        prism = SlantedPrism(
+            material="test",
+            vertices=vertices,
+            height=height,
+            axis=(0, 0, 1),
+            sidewall_angle=sidewall_angle,
+            center=(0, 0, 0),
+        )
+
+        # Test points that should be inside
+        assert point_is_in_object((0, 0, 0), prism)
+        assert point_is_in_object((0, 0.2, 0.5), prism)
+        assert point_is_in_object((0.2, 0.2, 0.9), prism)
+
+        # Test points that should be outside
+        assert not point_is_in_object((0, 0, 1.1), prism)
+        assert not point_is_in_object((1.5, 0, 0), prism)
+        assert not point_is_in_object((0, 0, -1.1), prism)
+        assert not point_is_in_object((0, -0.5, 0), prism)

From 4b351889fae2e114fdc0dfec3a5e1d6319aeef36 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 17:22:54 -0800
Subject: [PATCH 23/37] Add tests for ObjectGroup

---
 python/test_ctlgeom.py | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/python/test_ctlgeom.py b/python/test_ctlgeom.py
index 592cbb0..0d65073 100644
--- a/python/test_ctlgeom.py
+++ b/python/test_ctlgeom.py
@@ -11,6 +11,7 @@
     Ellipsoid,
     Prism,
     SlantedPrism,
+    ObjectGroup,
 )
 
 
@@ -562,3 +563,37 @@ def test_point_in_slanted_prism(self):
         assert not point_is_in_object((1.5, 0, 0), prism)
         assert not point_is_in_object((0, 0, -1.1), prism)
         assert not point_is_in_object((0, -0.5, 0), prism)
+
+
+class TestObjectGroup:
+    """Tests for ObjectGroup functionality."""
+
+    def test_creation(self):
+        """Test creating an ObjectGroup object."""
+        sphere = Sphere(material="test", center=(0, 0, 0), radius=1.0)
+        cylinder = Cylinder(
+            material="test", center=(2, 0, 0), radius=1.0, height=2.0, axis=(0, 0, 1)
+        )
+
+        group = ObjectGroup(objects=[sphere, cylinder])
+
+        assert len(group.objects) == 2
+        assert group.objects[0] == sphere
+        assert group.objects[1] == cylinder
+
+    def test_material_at(self):
+        """Test getting material at different points in an ObjectGroup."""
+        sphere = Sphere(material="sphere_mat", center=(0, 0, 0), radius=1.0)
+        cylinder = Cylinder(
+            material="cylinder_mat",
+            center=(42, 0, 0),
+            radius=1.0,
+            height=2.0,
+            axis=(0, 0, 1),
+        )
+
+        group = ObjectGroup(objects=[sphere, cylinder])
+
+        assert group.material_at((0, 0, 0)) == "sphere_mat"
+        assert group.material_at((42, 0, 0)) == "cylinder_mat"
+        assert group.material_at((99, 0, 0)) is None

From db2df0a2ab201edce4cf3aab179dd07f301a1242 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 17:23:05 -0800
Subject: [PATCH 24/37] Add readme for python extension

---
 python/README.md | 161 +++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 156 insertions(+), 5 deletions(-)

diff --git a/python/README.md b/python/README.md
index 5c61e75..133a728 100644
--- a/python/README.md
+++ b/python/README.md
@@ -26,12 +26,163 @@ The build script will automatically:
 - Compile the extension module
 - Install the package using pip
 
-## Verification
+## Usage Examples
+
+### Basic Shapes
 
-To verify the installation, you can run Python and try the following:
 ```python
-import ctlgeom
-sphere = ctlgeom.Sphere(1, (0, 0.5, 0), 1)
-ctlgeom.point_is_in_object((0.5, 0, 0), sphere)
+from ctlgeom import Sphere, Cylinder, Block, Cone, Wedge, Ellipsoid, Prism, SlantedPrism
+
+# Create a sphere
+sphere = Sphere(
+    material="metal",
+    center=(0, 0, 0),
+    radius=1.0
+)
+
+# Create a cylinder
+cylinder = Cylinder(
+    material=1 + 1j,
+    center=(0, 0, 0),
+    radius=1.0,
+    height=2.0,
+    axis=(0, 0, 1)
+)
+
+# Create a block (rectangular prism)
+block = Block(
+    material={"foo" : 42},
+    center=(0, 0, 0),
+    e1=(1, 0, 0),    # x-axis
+    e2=(0, 1, 0),    # y-axis
+    e3=(0, 0, 1),    # z-axis
+    size=(2.0, 3.0, 4.0)
+)
+
+# Create a cone
+cone = Cone(
+    material="glass",
+    center=(0, 0, 0),
+    radius=1.0,      # base radius
+    height=2.0,
+    axis=(0, 0, 1),
+    radius2=0.5      # top radius (0 for perfect cone)
+)
+
+# Create a wedge (partial cylinder)
+wedge = Wedge(
+    material="plastic",
+    center=(0, 0, 0),
+    radius=1.0,
+    height=2.0,
+    axis=(0, 0, 1),
+    wedge_angle=1.57,  # 90 degrees in radians
+    wedge_start=(1, 0, 0)
+)
+
+# Create an ellipsoid
+ellipsoid = Ellipsoid(
+    material="glass",
+    center=(0, 0, 0),
+    e1=(1, 0, 0),
+    e2=(0, 1, 0),
+    e3=(0, 0, 1),
+    size=(2.0, 3.0, 4.0)  # semi-axes lengths
+)
+
+# Create a prism from vertices
+vertices = [
+    (1.0, 0.0, 0.0),
+    (0.0, 1.0, 0.0),
+    (-1.0, 0.0, 0.0)
+]
+prism = Prism(
+    material="metal",
+    vertices=vertices,
+    height=2.0,
+    axis=(0, 0, 1),
+    center=(0, 0, 0)  # optional
+)
+
+# Create a slanted prism
+slanted_prism = SlantedPrism(
+    material="metal",
+    vertices=vertices,
+    height=2.0,
+    axis=(0, 0, 1),
+    sidewall_angle=0.523,  # 30 degrees in radians
+    center=(0, 0, 0)  # optional
+)
+```
+
+### Working with Shapes
+
+```python
+from ctlgeom import point_is_in_object, ObjectGroup
+
+# Check if a point is inside an object
+point = (0.5, 0.5, 0.5)
+is_inside = point_is_in_object(point, sphere)
+
+# Get object volume
+volume = sphere.volume()
+
+# Get object bounding box
+low, high = sphere.bounding_box()
+
+# Group multiple objects
+group = ObjectGroup([sphere, cylinder, block])
+
+# Query material at a point
+material = group.material_at(point)
+
+# Display debug information
+sphere.debug_info()
+```
+
+### Vectorized Operations with numpy
+
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+import time
+
+# Create some sample geometry
+sphere1 = Sphere(material=1, center=(0, -0.5, 0), radius=0.5)
+sphere2 = Sphere(material=2, center=(0, 0.5, 0), radius=1)
+block = Block(
+    material=3,
+    center=(0.5, 0.5, 0),
+    e1=(1, 1, 0),
+    e2=(1, -1, 0),
+    e3=(0, 0, 1),
+    size=(1, 1, 1)
+)
+group = ObjectGroup([sphere2, sphere1, block])
+
+# Create a grid of points
+x = np.linspace(-2, 2, 200)
+y = np.linspace(-2, 2, 200)
+xx, yy = np.meshgrid(x, y)
+
+# Vectorize the material lookup function
+def get_material(x, y):
+    mat = group.material_at((x, y, 0))
+    return 0 if mat is None else mat
+
+material_lookup = np.vectorize(get_material)
+
+# Generate material map
+material_map = material_lookup(xx, yy)
+
+# Visualize the result
+plt.figure(figsize=(8, 8))
+plt.imshow(material_map, extent=[-2, 2, -2, 2], origin='lower')
+plt.colorbar(label='Material Index')
+plt.title('Material Distribution')
+plt.xlabel('X')
+plt.ylabel('Y')
+plt.show()
 ```
 
+Note: The `np.vectorize` function allows us to efficiently apply the material lookup across a large array of points. While not as fast as true vectorization (it still calls Python code for each point), it provides a convenient way to process large arrays of coordinates without explicit loops.
\ No newline at end of file

From bfe89e21a9e539f199faa839922005983564508a Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 23:12:43 -0800
Subject: [PATCH 25/37] Add loop in c in material_of_numpy_points_in_tree for
 x10 speed up

---
 python/libctlgeom.i |   35 +
 python/numpy.i      | 2970 +++++++++++++++++++++++++++++++++++++++++++
 python/setup.py     |    4 +-
 python/test.ipynb   |   90 +-
 4 files changed, 3079 insertions(+), 20 deletions(-)
 create mode 100644 python/numpy.i

diff --git a/python/libctlgeom.i b/python/libctlgeom.i
index 8e9e700..bc71939 100644
--- a/python/libctlgeom.i
+++ b/python/libctlgeom.i
@@ -7,6 +7,7 @@
 
 %{
 #define CTL_SWIG
+#define SWIG_FILE_WITH_INIT
 #include "ctlgeom.h"
 #include "ctlgeom-types-swig.h"
 %}
@@ -104,3 +105,37 @@
 %ignore get_grid_size_n;
 
 %include "ctlgeom.h"
+
+%include "numpy.i"
+%init %{
+    import_array();
+%}
+
+/* Add typemap for numpy array input */
+%apply (double* IN_ARRAY2, int DIM1, int DIM2) {(double* points, int n_points, int dims)}
+
+/* Add the new function declaration */
+%inline %{
+PyObject* material_of_numpy_points_in_tree(double* points, int n_points, int dims, geom_box_tree t) {
+    if (dims != 3) {
+        PyErr_SetString(PyExc_ValueError, "Input array must have 3 columns (x,y,z)");
+        return NULL;
+    }
+    
+    PyObject* result = PyList_New(n_points);
+    for (int i = 0; i < n_points; i++) {
+        vector3 p = {points[i*3], points[i*3 + 1], points[i*3 + 2]};
+        MATERIAL_TYPE material = material_of_point_in_tree(p, t);
+        
+        if (material == NULL) {
+            Py_INCREF(Py_None);
+            PyList_SET_ITEM(result, i, Py_None);
+        } else {
+            PyObject* mat = (PyObject*)material;
+            Py_XINCREF(mat);
+            PyList_SET_ITEM(result, i, mat);
+        }
+    }
+    return result;
+}
+%}
\ No newline at end of file
diff --git a/python/numpy.i b/python/numpy.i
new file mode 100644
index 0000000..7474466
--- /dev/null
+++ b/python/numpy.i
@@ -0,0 +1,2970 @@
+/* -*- C -*-  (not really, but good for syntax highlighting) */
+
+/*
+ * Copyright (c) 2005-2015, NumPy Developers.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *        notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials provided
+ *        with the distribution.
+ *
+ *     * Neither the name of the NumPy Developers nor the names of any
+ *        contributors may be used to endorse or promote products derived
+ *        from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef SWIGPYTHON
+
+%{
+#ifndef SWIG_FILE_WITH_INIT
+#define NO_IMPORT_ARRAY
+#endif
+#include "stdio.h"
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <numpy/arrayobject.h>
+%}
+
+/**********************************************************************/
+
+%fragment("NumPy_Backward_Compatibility", "header")
+{
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+%#define NPY_ARRAY_DEFAULT NPY_DEFAULT
+%#define NPY_ARRAY_FARRAY  NPY_FARRAY
+%#define NPY_FORTRANORDER  NPY_FORTRAN
+%#endif
+}
+
+/**********************************************************************/
+
+/* The following code originally appeared in
+ * enthought/kiva/agg/src/numeric.i written by Eric Jones.  It was
+ * translated from C++ to C by John Hunter.  Bill Spotz has modified
+ * it to fix some minor bugs, upgrade from Numeric to numpy (all
+ * versions), add some comments and functionality, and convert from
+ * direct code insertion to SWIG fragments.
+ */
+
+%fragment("NumPy_Macros", "header")
+{
+/* Macros to extract array attributes.
+ */
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+%#define is_array(a)            ((a) && PyArray_Check((PyArrayObject*)a))
+%#define array_type(a)          (int)(PyArray_TYPE((PyArrayObject*)a))
+%#define array_numdims(a)       (((PyArrayObject*)a)->nd)
+%#define array_dimensions(a)    (((PyArrayObject*)a)->dimensions)
+%#define array_size(a,i)        (((PyArrayObject*)a)->dimensions[i])
+%#define array_strides(a)       (((PyArrayObject*)a)->strides)
+%#define array_stride(a,i)      (((PyArrayObject*)a)->strides[i])
+%#define array_data(a)          (((PyArrayObject*)a)->data)
+%#define array_descr(a)         (((PyArrayObject*)a)->descr)
+%#define array_flags(a)         (((PyArrayObject*)a)->flags)
+%#define array_clearflags(a,f)  (((PyArrayObject*)a)->flags) &= ~f
+%#define array_enableflags(a,f) (((PyArrayObject*)a)->flags) = f
+%#define array_is_fortran(a)    (PyArray_ISFORTRAN((PyArrayObject*)a))
+%#else
+%#define is_array(a)            ((a) && PyArray_Check(a))
+%#define array_type(a)          PyArray_TYPE((PyArrayObject*)a)
+%#define array_numdims(a)       PyArray_NDIM((PyArrayObject*)a)
+%#define array_dimensions(a)    PyArray_DIMS((PyArrayObject*)a)
+%#define array_strides(a)       PyArray_STRIDES((PyArrayObject*)a)
+%#define array_stride(a,i)      PyArray_STRIDE((PyArrayObject*)a,i)
+%#define array_size(a,i)        PyArray_DIM((PyArrayObject*)a,i)
+%#define array_data(a)          PyArray_DATA((PyArrayObject*)a)
+%#define array_descr(a)         PyArray_DESCR((PyArrayObject*)a)
+%#define array_flags(a)         PyArray_FLAGS((PyArrayObject*)a)
+%#define array_enableflags(a,f) PyArray_ENABLEFLAGS((PyArrayObject*)a,f)
+%#define array_clearflags(a,f)  PyArray_CLEARFLAGS((PyArrayObject*)a,f)
+%#define array_is_fortran(a)    (PyArray_IS_F_CONTIGUOUS((PyArrayObject*)a))
+%#endif
+%#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS((PyArrayObject*)a))
+%#define array_is_native(a)     (PyArray_ISNOTSWAPPED((PyArrayObject*)a))
+}
+
+/**********************************************************************/
+
+%fragment("NumPy_Utilities",
+          "header")
+{
+  /* Given a PyObject, return a string describing its type.
+   */
+  const char* pytype_string(PyObject* py_obj)
+  {
+    if (py_obj == NULL          ) return "C NULL value";
+    if (py_obj == Py_None       ) return "Python None" ;
+    if (PyCallable_Check(py_obj)) return "callable"    ;
+    if (PyBytes_Check(   py_obj)) return "string"      ;
+    if (PyLong_Check(    py_obj)) return "int"         ;
+    if (PyFloat_Check(   py_obj)) return "float"       ;
+    if (PyDict_Check(    py_obj)) return "dict"        ;
+    if (PyList_Check(    py_obj)) return "list"        ;
+    if (PyTuple_Check(   py_obj)) return "tuple"       ;
+
+    return "unknown type";
+  }
+
+  /* Given a NumPy typecode, return a string describing the type.
+   */
+  const char* typecode_string(int typecode)
+  {
+    static const char* type_names[25] = {"bool",
+                                         "byte",
+                                         "unsigned byte",
+                                         "short",
+                                         "unsigned short",
+                                         "int",
+                                         "unsigned int",
+                                         "long",
+                                         "unsigned long",
+                                         "long long",
+                                         "unsigned long long",
+                                         "float",
+                                         "double",
+                                         "long double",
+                                         "complex float",
+                                         "complex double",
+                                         "complex long double",
+                                         "object",
+                                         "string",
+                                         "unicode",
+                                         "void",
+                                         "ntypes",
+                                         "notype",
+                                         "char",
+                                         "unknown"};
+    return typecode < 24 ? type_names[typecode] : type_names[24];
+  }
+
+  /* Make sure input has correct numpy type.  This now just calls
+     PyArray_EquivTypenums().
+   */
+  int type_match(int actual_type,
+                 int desired_type)
+  {
+    return PyArray_EquivTypenums(actual_type, desired_type);
+  }
+
+void free_cap(PyObject * cap)
+  {
+    void* array = (void*) PyCapsule_GetPointer(cap,SWIGPY_CAPSULE_NAME);
+    if (array != NULL) free(array);
+  }
+
+
+}
+
+/**********************************************************************/
+
+%fragment("NumPy_Object_to_Array",
+          "header",
+          fragment="NumPy_Backward_Compatibility",
+          fragment="NumPy_Macros",
+          fragment="NumPy_Utilities")
+{
+  /* Given a PyObject pointer, cast it to a PyArrayObject pointer if
+   * legal.  If not, set the python error string appropriately and
+   * return NULL.
+   */
+  PyArrayObject* obj_to_array_no_conversion(PyObject* input,
+                                            int        typecode)
+  {
+    PyArrayObject* ary = NULL;
+    if (is_array(input) && (typecode == NPY_NOTYPE ||
+                            PyArray_EquivTypenums(array_type(input), typecode)))
+    {
+      ary = (PyArrayObject*) input;
+    }
+    else if is_array(input)
+    {
+      const char* desired_type = typecode_string(typecode);
+      const char* actual_type  = typecode_string(array_type(input));
+      PyErr_Format(PyExc_TypeError,
+                   "Array of type '%s' required.  Array of type '%s' given",
+                   desired_type, actual_type);
+      ary = NULL;
+    }
+    else
+    {
+      const char* desired_type = typecode_string(typecode);
+      const char* actual_type  = pytype_string(input);
+      PyErr_Format(PyExc_TypeError,
+                   "Array of type '%s' required.  A '%s' was given",
+                   desired_type,
+                   actual_type);
+      ary = NULL;
+    }
+    return ary;
+  }
+
+  /* Convert the given PyObject to a NumPy array with the given
+   * typecode.  On success, return a valid PyArrayObject* with the
+   * correct type.  On failure, the python error string will be set and
+   * the routine returns NULL.
+   */
+  PyArrayObject* obj_to_array_allow_conversion(PyObject* input,
+                                               int       typecode,
+                                               int*      is_new_object)
+  {
+    PyArrayObject* ary = NULL;
+    PyObject*      py_obj;
+    if (is_array(input) && (typecode == NPY_NOTYPE ||
+                            PyArray_EquivTypenums(array_type(input),typecode)))
+    {
+      ary = (PyArrayObject*) input;
+      *is_new_object = 0;
+    }
+    else
+    {
+      py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_ARRAY_DEFAULT);
+      /* If NULL, PyArray_FromObject will have set python error value.*/
+      ary = (PyArrayObject*) py_obj;
+      *is_new_object = 1;
+    }
+    return ary;
+  }
+
+  /* Given a PyArrayObject, check to see if it is contiguous.  If so,
+   * return the input pointer and flag it as not a new object.  If it is
+   * not contiguous, create a new PyArrayObject using the original data,
+   * flag it as a new object and return the pointer.
+   */
+  PyArrayObject* make_contiguous(PyArrayObject* ary,
+                                 int*           is_new_object,
+                                 int            min_dims,
+                                 int            max_dims)
+  {
+    PyArrayObject* result;
+    if (array_is_contiguous(ary))
+    {
+      result = ary;
+      *is_new_object = 0;
+    }
+    else
+    {
+      result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary,
+                                                              array_type(ary),
+                                                              min_dims,
+                                                              max_dims);
+      *is_new_object = 1;
+    }
+    return result;
+  }
+
+  /* Given a PyArrayObject, check to see if it is Fortran-contiguous.
+   * If so, return the input pointer, but do not flag it as not a new
+   * object.  If it is not Fortran-contiguous, create a new
+   * PyArrayObject using the original data, flag it as a new object
+   * and return the pointer.
+   */
+  PyArrayObject* make_fortran(PyArrayObject* ary,
+                              int*           is_new_object)
+  {
+    PyArrayObject* result;
+    if (array_is_fortran(ary))
+    {
+      result = ary;
+      *is_new_object = 0;
+    }
+    else
+    {
+      Py_INCREF(array_descr(ary));
+      result = (PyArrayObject*) PyArray_FromArray(ary,
+                                                  array_descr(ary),
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+                                                  NPY_FORTRANORDER);
+%#else
+                                                  NPY_ARRAY_F_CONTIGUOUS);
+%#endif
+      *is_new_object = 1;
+    }
+    return result;
+  }
+
+  /* Convert a given PyObject to a contiguous PyArrayObject of the
+   * specified type.  If the input object is not a contiguous
+   * PyArrayObject, a new one will be created and the new object flag
+   * will be set.
+   */
+  PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input,
+                                                          int       typecode,
+                                                          int*      is_new_object)
+  {
+    int is_new1 = 0;
+    int is_new2 = 0;
+    PyArrayObject* ary2;
+    PyArrayObject* ary1 = obj_to_array_allow_conversion(input,
+                                                        typecode,
+                                                        &is_new1);
+    if (ary1)
+    {
+      ary2 = make_contiguous(ary1, &is_new2, 0, 0);
+      if ( is_new1 && is_new2)
+      {
+        Py_DECREF(ary1);
+      }
+      ary1 = ary2;
+    }
+    *is_new_object = is_new1 || is_new2;
+    return ary1;
+  }
+
+  /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the
+   * specified type.  If the input object is not a Fortran-ordered
+   * PyArrayObject, a new one will be created and the new object flag
+   * will be set.
+   */
+  PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input,
+                                                       int       typecode,
+                                                       int*      is_new_object)
+  {
+    int is_new1 = 0;
+    int is_new2 = 0;
+    PyArrayObject* ary2;
+    PyArrayObject* ary1 = obj_to_array_allow_conversion(input,
+                                                        typecode,
+                                                        &is_new1);
+    if (ary1)
+    {
+      ary2 = make_fortran(ary1, &is_new2);
+      if (is_new1 && is_new2)
+      {
+        Py_DECREF(ary1);
+      }
+      ary1 = ary2;
+    }
+    *is_new_object = is_new1 || is_new2;
+    return ary1;
+  }
+} /* end fragment */
+
+/**********************************************************************/
+
+%fragment("NumPy_Array_Requirements",
+          "header",
+          fragment="NumPy_Backward_Compatibility",
+          fragment="NumPy_Macros")
+{
+  /* Test whether a python object is contiguous.  If array is
+   * contiguous, return 1.  Otherwise, set the python error string and
+   * return 0.
+   */
+  int require_contiguous(PyArrayObject* ary)
+  {
+    int contiguous = 1;
+    if (!array_is_contiguous(ary))
+    {
+      PyErr_SetString(PyExc_TypeError,
+                      "Array must be contiguous.  A non-contiguous array was given");
+      contiguous = 0;
+    }
+    return contiguous;
+  }
+
+  /* Test whether a python object is (C_ or F_) contiguous.  If array is
+   * contiguous, return 1.  Otherwise, set the python error string and
+   * return 0.
+   */
+  int require_c_or_f_contiguous(PyArrayObject* ary)
+  {
+    int contiguous = 1;
+    if (!(array_is_contiguous(ary) || array_is_fortran(ary)))
+    {
+      PyErr_SetString(PyExc_TypeError,
+                      "Array must be contiguous (C_ or F_).  A non-contiguous array was given");
+      contiguous = 0;
+    }
+    return contiguous;
+  }
+
+  /* Require that a numpy array is not byte-swapped.  If the array is
+   * not byte-swapped, return 1.  Otherwise, set the python error string
+   * and return 0.
+   */
+  int require_native(PyArrayObject* ary)
+  {
+    int native = 1;
+    if (!array_is_native(ary))
+    {
+      PyErr_SetString(PyExc_TypeError,
+                      "Array must have native byteorder.  "
+                      "A byte-swapped array was given");
+      native = 0;
+    }
+    return native;
+  }
+
+  /* Require the given PyArrayObject to have a specified number of
+   * dimensions.  If the array has the specified number of dimensions,
+   * return 1.  Otherwise, set the python error string and return 0.
+   */
+  int require_dimensions(PyArrayObject* ary,
+                         int            exact_dimensions)
+  {
+    int success = 1;
+    if (array_numdims(ary) != exact_dimensions)
+    {
+      PyErr_Format(PyExc_TypeError,
+                   "Array must have %d dimensions.  Given array has %d dimensions",
+                   exact_dimensions,
+                   array_numdims(ary));
+      success = 0;
+    }
+    return success;
+  }
+
+  /* Require the given PyArrayObject to have one of a list of specified
+   * number of dimensions.  If the array has one of the specified number
+   * of dimensions, return 1.  Otherwise, set the python error string
+   * and return 0.
+   */
+  int require_dimensions_n(PyArrayObject* ary,
+                           int*           exact_dimensions,
+                           int            n)
+  {
+    int success = 0;
+    int i;
+    char dims_str[255] = "";
+    char s[255];
+    for (i = 0; i < n && !success; i++)
+    {
+      if (array_numdims(ary) == exact_dimensions[i])
+      {
+        success = 1;
+      }
+    }
+    if (!success)
+    {
+      for (i = 0; i < n-1; i++)
+      {
+        sprintf(s, "%d, ", exact_dimensions[i]);
+        strcat(dims_str,s);
+      }
+      sprintf(s, " or %d", exact_dimensions[n-1]);
+      strcat(dims_str,s);
+      PyErr_Format(PyExc_TypeError,
+                   "Array must have %s dimensions.  Given array has %d dimensions",
+                   dims_str,
+                   array_numdims(ary));
+    }
+    return success;
+  }
+
+  /* Require the given PyArrayObject to have a specified shape.  If the
+   * array has the specified shape, return 1.  Otherwise, set the python
+   * error string and return 0.
+   */
+  int require_size(PyArrayObject* ary,
+                   npy_intp*      size,
+                   int            n)
+  {
+    int i;
+    int success = 1;
+    size_t len;
+    char desired_dims[255] = "[";
+    char s[255];
+    char actual_dims[255] = "[";
+    for(i=0; i < n;i++)
+    {
+      if (size[i] != -1 &&  size[i] != array_size(ary,i))
+      {
+        success = 0;
+      }
+    }
+    if (!success)
+    {
+      for (i = 0; i < n; i++)
+      {
+        if (size[i] == -1)
+        {
+          sprintf(s, "*,");
+        }
+        else
+        {
+          sprintf(s, "%ld,", (long int)size[i]);
+        }
+        strcat(desired_dims,s);
+      }
+      len = strlen(desired_dims);
+      desired_dims[len-1] = ']';
+      for (i = 0; i < n; i++)
+      {
+        sprintf(s, "%ld,", (long int)array_size(ary,i));
+        strcat(actual_dims,s);
+      }
+      len = strlen(actual_dims);
+      actual_dims[len-1] = ']';
+      PyErr_Format(PyExc_TypeError,
+                   "Array must have shape of %s.  Given array has shape of %s",
+                   desired_dims,
+                   actual_dims);
+    }
+    return success;
+  }
+
+  /* Require the given PyArrayObject to be Fortran ordered.  If the
+   * the PyArrayObject is already Fortran ordered, do nothing.  Else,
+   * set the Fortran ordering flag and recompute the strides.
+   */
+  int require_fortran(PyArrayObject* ary)
+  {
+    int success = 1;
+    int nd = array_numdims(ary);
+    int i;
+    npy_intp * strides = array_strides(ary);
+    if (array_is_fortran(ary)) return success;
+    int n_non_one = 0;
+    /* Set the Fortran ordered flag */
+    const npy_intp *dims = array_dimensions(ary);
+    for (i=0; i < nd; ++i)
+      n_non_one += (dims[i] != 1) ? 1 : 0;
+    if (n_non_one > 1)
+      array_clearflags(ary,NPY_ARRAY_CARRAY);
+    array_enableflags(ary,NPY_ARRAY_FARRAY);
+    /* Recompute the strides */
+    strides[0] = strides[nd-1];
+    for (i=1; i < nd; ++i)
+      strides[i] = strides[i-1] * array_size(ary,i-1);
+    return success;
+  }
+}
+
+/* Combine all NumPy fragments into one for convenience */
+%fragment("NumPy_Fragments",
+          "header",
+          fragment="NumPy_Backward_Compatibility",
+          fragment="NumPy_Macros",
+          fragment="NumPy_Utilities",
+          fragment="NumPy_Object_to_Array",
+          fragment="NumPy_Array_Requirements")
+{
+}
+
+/* End John Hunter translation (with modifications by Bill Spotz)
+ */
+
+/* %numpy_typemaps() macro
+ *
+ * This macro defines a family of 75 typemaps that allow C arguments
+ * of the form
+ *
+ *    1. (DATA_TYPE IN_ARRAY1[ANY])
+ *    2. (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+ *    3. (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+ *
+ *    4. (DATA_TYPE IN_ARRAY2[ANY][ANY])
+ *    5. (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ *    6. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+ *    7. (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ *    8. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+ *
+ *    9. (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+ *   10. (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ *   11. (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ *   12. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
+ *   13. (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ *   14. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
+ *
+ *   15. (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY])
+ *   16. (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+ *   17. (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+ *   18. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, , DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4)
+ *   19. (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+ *   20. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4)
+ *
+ *   21. (DATA_TYPE INPLACE_ARRAY1[ANY])
+ *   22. (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
+ *   23. (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
+ *
+ *   24. (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
+ *   25. (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ *   26. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
+ *   27. (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ *   28. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
+ *
+ *   29. (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
+ *   30. (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ *   31. (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ *   32. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)
+ *   33. (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+ *   34. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)
+ *
+ *   35. (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY])
+ *   36. (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+ *   37. (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+ *   38. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4)
+ *   39. (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+ *   40. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4)
+ *
+ *   41. (DATA_TYPE ARGOUT_ARRAY1[ANY])
+ *   42. (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
+ *   43. (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
+ *
+ *   44. (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
+ *
+ *   45. (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
+ *
+ *   46. (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY])
+ *
+ *   47. (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)
+ *   48. (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)
+ *
+ *   49. (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ *   50. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)
+ *   51. (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ *   52. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)
+ *
+ *   53. (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+ *   54. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)
+ *   55. (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+ *   56. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)
+ *
+ *   57. (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+ *   58. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_ARRAY4)
+ *   59. (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+ *   60. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_FARRAY4)
+ *
+ *   61. (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1)
+ *   62. (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1)
+ *
+ *   63. (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ *   64. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2)
+ *   65. (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ *   66. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2)
+ *
+ *   67. (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+ *   68. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_ARRAY3)
+ *   69. (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+ *   70. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_FARRAY3)
+ *
+ *   71. (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+ *   72. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4)
+ *   73. (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+ *   74. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4)
+ *
+ *   75. (DATA_TYPE* INPLACE_ARRAY_FLAT, DIM_TYPE DIM_FLAT)
+ *
+ * where "DATA_TYPE" is any type supported by the NumPy module, and
+ * "DIM_TYPE" is any int-like type suitable for specifying dimensions.
+ * The difference between "ARRAY" typemaps and "FARRAY" typemaps is
+ * that the "FARRAY" typemaps expect Fortran ordering of
+ * multidimensional arrays.  In python, the dimensions will not need
+ * to be specified (except for the "DATA_TYPE* ARGOUT_ARRAY1"
+ * typemaps).  The IN_ARRAYs can be a numpy array or any sequence that
+ * can be converted to a numpy array of the specified type.  The
+ * INPLACE_ARRAYs must be numpy arrays of the appropriate type.  The
+ * ARGOUT_ARRAYs will be returned as new numpy arrays of the
+ * appropriate type.
+ *
+ * These typemaps can be applied to existing functions using the
+ * %apply directive.  For example:
+ *
+ *     %apply (double* IN_ARRAY1, int DIM1) {(double* series, int length)};
+ *     double prod(double* series, int length);
+ *
+ *     %apply (int DIM1, int DIM2, double* INPLACE_ARRAY2)
+ *           {(int rows, int cols, double* matrix        )};
+ *     void floor(int rows, int cols, double* matrix, double f);
+ *
+ *     %apply (double IN_ARRAY3[ANY][ANY][ANY])
+ *           {(double tensor[2][2][2]         )};
+ *     %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY])
+ *           {(double low[2][2][2]                )};
+ *     %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY])
+ *           {(double upp[2][2][2]                )};
+ *     void luSplit(double tensor[2][2][2],
+ *                  double low[2][2][2],
+ *                  double upp[2][2][2]    );
+ *
+ * or directly with
+ *
+ *     double prod(double* IN_ARRAY1, int DIM1);
+ *
+ *     void floor(int DIM1, int DIM2, double* INPLACE_ARRAY2, double f);
+ *
+ *     void luSplit(double IN_ARRAY3[ANY][ANY][ANY],
+ *                  double ARGOUT_ARRAY3[ANY][ANY][ANY],
+ *                  double ARGOUT_ARRAY3[ANY][ANY][ANY]);
+ */
+
+%define %numpy_typemaps(DATA_TYPE, DATA_TYPECODE, DIM_TYPE)
+
+/************************/
+/* Input Array Typemaps */
+/************************/
+
+/* Typemap suite for (DATA_TYPE IN_ARRAY1[ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE IN_ARRAY1[ANY])
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE IN_ARRAY1[ANY])
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[1] = { $1_dim0 };
+  array = obj_to_array_contiguous_allow_conversion($input,
+                                                   DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 1) ||
+      !require_size(array, size, 1)) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+%typemap(freearg)
+  (DATA_TYPE IN_ARRAY1[ANY])
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[1] = { -1 };
+  array = obj_to_array_contiguous_allow_conversion($input,
+                                                   DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 1) ||
+      !require_size(array, size, 1)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+}
+%typemap(freearg)
+  (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[1] = {-1};
+  array = obj_to_array_contiguous_allow_conversion($input,
+                                                   DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 1) ||
+      !require_size(array, size, 1)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+  (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE IN_ARRAY2[ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE IN_ARRAY2[ANY][ANY])
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE IN_ARRAY2[ANY][ANY])
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[2] = { $1_dim0, $1_dim1 };
+  array = obj_to_array_contiguous_allow_conversion($input,
+                                                   DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 2) ||
+      !require_size(array, size, 2)) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+%typemap(freearg)
+  (DATA_TYPE IN_ARRAY2[ANY][ANY])
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[2] = { -1, -1 };
+  array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 2) ||
+      !require_size(array, size, 2)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+}
+%typemap(freearg)
+  (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[2] = { -1, -1 };
+  array = obj_to_array_contiguous_allow_conversion($input,
+                                                   DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 2) ||
+      !require_size(array, size, 2)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[2] = { -1, -1 };
+  array = obj_to_array_fortran_allow_conversion($input,
+                                                DATA_TYPECODE,
+                                                &is_new_object);
+  if (!array || !require_dimensions(array, 2) ||
+      !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+}
+%typemap(freearg)
+  (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[2] = { -1, -1 };
+  array = obj_to_array_fortran_allow_conversion($input,
+                                                   DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 2) ||
+      !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 };
+  array = obj_to_array_contiguous_allow_conversion($input,
+                                                   DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 3) ||
+      !require_size(array, size, 3)) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+%typemap(freearg)
+  (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[3] = { -1, -1, -1 };
+  array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 3) ||
+      !require_size(array, size, 3)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+  $4 = (DIM_TYPE) array_size(array,2);
+}
+%typemap(freearg)
+  (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  /* for now, only concerned with lists */
+  $1 = PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+  (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL, int* is_new_object_array=NULL)
+{
+  npy_intp size[2] = { -1, -1 };
+  PyArrayObject* temp_array;
+  Py_ssize_t i;
+  int is_new_object;
+
+  /* length of the list */
+  $2 = PyList_Size($input);
+
+  /* the arrays */
+  array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *));
+  object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *));
+  is_new_object_array = (int *)calloc($2,sizeof(int));
+
+  if (array == NULL || object_array == NULL || is_new_object_array == NULL)
+  {
+    SWIG_fail;
+  }
+
+  for (i=0; i<$2; i++)
+  {
+    temp_array = obj_to_array_contiguous_allow_conversion(PySequence_GetItem($input,i), DATA_TYPECODE, &is_new_object);
+
+    /* the new array must be stored so that it can be destroyed in freearg */
+    object_array[i] = temp_array;
+    is_new_object_array[i] = is_new_object;
+
+    if (!temp_array || !require_dimensions(temp_array, 2)) SWIG_fail;
+
+    /* store the size of the first array in the list, then use that for comparison. */
+    if (i == 0)
+    {
+      size[0] = array_size(temp_array,0);
+      size[1] = array_size(temp_array,1);
+    }
+
+    if (!require_size(temp_array, size, 2)) SWIG_fail;
+
+    array[i] = (DATA_TYPE*) array_data(temp_array);
+  }
+
+  $1 = (DATA_TYPE**) array;
+  $3 = (DIM_TYPE) size[0];
+  $4 = (DIM_TYPE) size[1];
+}
+%typemap(freearg)
+  (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  Py_ssize_t i;
+
+  if (array$argnum!=NULL) free(array$argnum);
+
+  /*freeing the individual arrays if needed */
+  if (object_array$argnum!=NULL)
+  {
+    if (is_new_object_array$argnum!=NULL)
+    {
+      for (i=0; i<$2; i++)
+      {
+        if (object_array$argnum[i] != NULL && is_new_object_array$argnum[i])
+        { Py_DECREF(object_array$argnum[i]); }
+      }
+      free(is_new_object_array$argnum);
+    }
+    free(object_array$argnum);
+  }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
+ *                    DATA_TYPE* IN_ARRAY3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[3] = { -1, -1, -1 };
+  array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 3) ||
+      !require_size(array, size, 3)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DIM_TYPE) array_size(array,2);
+  $4 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[3] = { -1, -1, -1 };
+  array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE,
+                                                &is_new_object);
+  if (!array || !require_dimensions(array, 3) ||
+      !require_size(array, size, 3) | !require_fortran(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+  $4 = (DIM_TYPE) array_size(array,2);
+}
+%typemap(freearg)
+  (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
+ *                    DATA_TYPE* IN_FARRAY3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[3] = { -1, -1, -1 };
+  array = obj_to_array_fortran_allow_conversion($input,
+                                                   DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 3) ||
+      !require_size(array, size, 3) || !require_fortran(array)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DIM_TYPE) array_size(array,2);
+  $4 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY])
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY])
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[4] = { $1_dim0, $1_dim1, $1_dim2 , $1_dim3};
+  array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 4) ||
+      !require_size(array, size, 4)) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+%typemap(freearg)
+  (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY])
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3, DIM_TYPE DIM4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[4] = { -1, -1, -1, -1 };
+  array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 4) ||
+      !require_size(array, size, 4)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+  $4 = (DIM_TYPE) array_size(array,2);
+  $5 = (DIM_TYPE) array_size(array,3);
+}
+%typemap(freearg)
+  (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3, DIM_TYPE DIM4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  /* for now, only concerned with lists */
+  $1 = PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+  (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL, int* is_new_object_array=NULL)
+{
+  npy_intp size[3] = { -1, -1, -1 };
+  PyArrayObject* temp_array;
+  Py_ssize_t i;
+  int is_new_object;
+
+  /* length of the list */
+  $2 = PyList_Size($input);
+
+  /* the arrays */
+  array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *));
+  object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *));
+  is_new_object_array = (int *)calloc($2,sizeof(int));
+
+  if (array == NULL || object_array == NULL || is_new_object_array == NULL)
+  {
+    SWIG_fail;
+  }
+
+  for (i=0; i<$2; i++)
+  {
+    temp_array = obj_to_array_contiguous_allow_conversion(PySequence_GetItem($input,i), DATA_TYPECODE, &is_new_object);
+
+    /* the new array must be stored so that it can be destroyed in freearg */
+    object_array[i] = temp_array;
+    is_new_object_array[i] = is_new_object;
+
+    if (!temp_array || !require_dimensions(temp_array, 3)) SWIG_fail;
+
+    /* store the size of the first array in the list, then use that for comparison. */
+    if (i == 0)
+    {
+      size[0] = array_size(temp_array,0);
+      size[1] = array_size(temp_array,1);
+      size[2] = array_size(temp_array,2);
+    }
+
+    if (!require_size(temp_array, size, 3)) SWIG_fail;
+
+    array[i] = (DATA_TYPE*) array_data(temp_array);
+  }
+
+  $1 = (DATA_TYPE**) array;
+  $3 = (DIM_TYPE) size[0];
+  $4 = (DIM_TYPE) size[1];
+  $5 = (DIM_TYPE) size[2];
+}
+%typemap(freearg)
+  (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  Py_ssize_t i;
+
+  if (array$argnum!=NULL) free(array$argnum);
+
+  /*freeing the individual arrays if needed */
+  if (object_array$argnum!=NULL)
+  {
+    if (is_new_object_array$argnum!=NULL)
+    {
+      for (i=0; i<$2; i++)
+      {
+        if (object_array$argnum[i] != NULL && is_new_object_array$argnum[i])
+        { Py_DECREF(object_array$argnum[i]); }
+      }
+      free(is_new_object_array$argnum);
+    }
+    free(object_array$argnum);
+  }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4,
+ *                    DATA_TYPE* IN_ARRAY4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[4] = { -1, -1, -1 , -1};
+  array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 4) ||
+      !require_size(array, size, 4)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DIM_TYPE) array_size(array,2);
+  $4 = (DIM_TYPE) array_size(array,3);
+  $5 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3, DIM_TYPE DIM4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[4] = { -1, -1, -1, -1 };
+  array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE,
+                                                &is_new_object);
+  if (!array || !require_dimensions(array, 4) ||
+      !require_size(array, size, 4) | !require_fortran(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+  $4 = (DIM_TYPE) array_size(array,2);
+  $5 = (DIM_TYPE) array_size(array,3);
+}
+%typemap(freearg)
+  (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4,
+ *                    DATA_TYPE* IN_FARRAY4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4)
+{
+  $1 = is_array($input) || PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4)
+  (PyArrayObject* array=NULL, int is_new_object=0)
+{
+  npy_intp size[4] = { -1, -1, -1 , -1 };
+  array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE,
+                                                   &is_new_object);
+  if (!array || !require_dimensions(array, 4) ||
+      !require_size(array, size, 4) || !require_fortran(array)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DIM_TYPE) array_size(array,2);
+  $4 = (DIM_TYPE) array_size(array,3);
+  $5 = (DATA_TYPE*) array_data(array);
+}
+%typemap(freearg)
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4)
+{
+  if (is_new_object$argnum && array$argnum)
+    { Py_DECREF(array$argnum); }
+}
+
+/***************************/
+/* In-Place Array Typemaps */
+/***************************/
+
+/* Typemap suite for (DATA_TYPE INPLACE_ARRAY1[ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE INPLACE_ARRAY1[ANY])
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE INPLACE_ARRAY1[ANY])
+  (PyArrayObject* array=NULL)
+{
+  npy_intp size[1] = { $1_dim0 };
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,1) || !require_size(array, size, 1) ||
+      !require_contiguous(array) || !require_native(array)) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)
+  (PyArrayObject* array=NULL, int i=1)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,1) || !require_contiguous(array)
+      || !require_native(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = 1;
+  for (i=0; i < array_numdims(array); ++i) $2 *= array_size(array,i);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)
+  (PyArrayObject* array=NULL, int i=0)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,1) || !require_contiguous(array)
+      || !require_native(array)) SWIG_fail;
+  $1 = 1;
+  for (i=0; i < array_numdims(array); ++i) $1 *= array_size(array,i);
+  $2 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])
+  (PyArrayObject* array=NULL)
+{
+  npy_intp size[2] = { $1_dim0, $1_dim1 };
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,2) || !require_size(array, size, 2) ||
+      !require_contiguous(array) || !require_native(array)) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,2) || !require_contiguous(array)
+      || !require_native(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,2) || !require_contiguous(array) ||
+      !require_native(array)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,2) || !require_contiguous(array)
+      || !require_native(array) || !require_fortran(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,2) || !require_contiguous(array) ||
+      !require_native(array) || !require_fortran(array)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])
+  (PyArrayObject* array=NULL)
+{
+  npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 };
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,3) || !require_size(array, size, 3) ||
+      !require_contiguous(array) || !require_native(array)) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,3) || !require_contiguous(array) ||
+      !require_native(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+  $4 = (DIM_TYPE) array_size(array,2);
+}
+
+/* Typemap suite for (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  $1 = PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+  (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL)
+{
+  npy_intp size[2] = { -1, -1 };
+  PyArrayObject* temp_array;
+  Py_ssize_t i;
+
+  /* length of the list */
+  $2 = PyList_Size($input);
+
+  /* the arrays */
+  array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *));
+  object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *));
+
+  if (array == NULL || object_array == NULL)
+  {
+    SWIG_fail;
+  }
+
+  for (i=0; i<$2; i++)
+  {
+    temp_array = obj_to_array_no_conversion(PySequence_GetItem($input,i), DATA_TYPECODE);
+
+    /* the new array must be stored so that it can be destroyed in freearg */
+    object_array[i] = temp_array;
+
+    if ( !temp_array || !require_dimensions(temp_array, 2) ||
+      !require_contiguous(temp_array) ||
+      !require_native(temp_array) ||
+      !PyArray_EquivTypenums(array_type(temp_array), DATA_TYPECODE)
+    ) SWIG_fail;
+
+    /* store the size of the first array in the list, then use that for comparison. */
+    if (i == 0)
+    {
+      size[0] = array_size(temp_array,0);
+      size[1] = array_size(temp_array,1);
+    }
+
+    if (!require_size(temp_array, size, 2)) SWIG_fail;
+
+    array[i] = (DATA_TYPE*) array_data(temp_array);
+  }
+
+  $1 = (DATA_TYPE**) array;
+  $3 = (DIM_TYPE) size[0];
+  $4 = (DIM_TYPE) size[1];
+}
+%typemap(freearg)
+  (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  if (array$argnum!=NULL) free(array$argnum);
+  if (object_array$argnum!=NULL) free(object_array$argnum);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
+ *                    DATA_TYPE* INPLACE_ARRAY3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,3) || !require_contiguous(array)
+      || !require_native(array)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DIM_TYPE) array_size(array,2);
+  $4 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,3) || !require_contiguous(array) ||
+      !require_native(array) || !require_fortran(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+  $4 = (DIM_TYPE) array_size(array,2);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
+ *                    DATA_TYPE* INPLACE_FARRAY3)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,3) || !require_contiguous(array)
+      || !require_native(array) || !require_fortran(array)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DIM_TYPE) array_size(array,2);
+  $4 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY])
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY])
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY])
+  (PyArrayObject* array=NULL)
+{
+  npy_intp size[4] = { $1_dim0, $1_dim1, $1_dim2 , $1_dim3 };
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,4) || !require_size(array, size, 4) ||
+      !require_contiguous(array) || !require_native(array)) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3, DIM_TYPE DIM4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,4) || !require_contiguous(array) ||
+      !require_native(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+  $4 = (DIM_TYPE) array_size(array,2);
+  $5 = (DIM_TYPE) array_size(array,3);
+}
+
+/* Typemap suite for (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3, DIM_TYPE DIM4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  $1 = PySequence_Check($input);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+  (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL)
+{
+  npy_intp size[3] = { -1, -1, -1 };
+  PyArrayObject* temp_array;
+  Py_ssize_t i;
+
+  /* length of the list */
+  $2 = PyList_Size($input);
+
+  /* the arrays */
+  array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *));
+  object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *));
+
+  if (array == NULL || object_array == NULL)
+  {
+    SWIG_fail;
+  }
+
+  for (i=0; i<$2; i++)
+  {
+    temp_array = obj_to_array_no_conversion(PySequence_GetItem($input,i), DATA_TYPECODE);
+
+    /* the new array must be stored so that it can be destroyed in freearg */
+    object_array[i] = temp_array;
+
+    if ( !temp_array || !require_dimensions(temp_array, 3) ||
+      !require_contiguous(temp_array) ||
+      !require_native(temp_array) ||
+      !PyArray_EquivTypenums(array_type(temp_array), DATA_TYPECODE)
+    ) SWIG_fail;
+
+    /* store the size of the first array in the list, then use that for comparison. */
+    if (i == 0)
+    {
+      size[0] = array_size(temp_array,0);
+      size[1] = array_size(temp_array,1);
+      size[2] = array_size(temp_array,2);
+    }
+
+    if (!require_size(temp_array, size, 3)) SWIG_fail;
+
+    array[i] = (DATA_TYPE*) array_data(temp_array);
+  }
+
+  $1 = (DATA_TYPE**) array;
+  $3 = (DIM_TYPE) size[0];
+  $4 = (DIM_TYPE) size[1];
+  $5 = (DIM_TYPE) size[2];
+}
+%typemap(freearg)
+  (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  if (array$argnum!=NULL) free(array$argnum);
+  if (object_array$argnum!=NULL) free(object_array$argnum);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4,
+ *                    DATA_TYPE* INPLACE_ARRAY4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,4) || !require_contiguous(array)
+      || !require_native(array)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DIM_TYPE) array_size(array,2);
+  $4 = (DIM_TYPE) array_size(array,3);
+  $5 = (DATA_TYPE*) array_data(array);
+}
+
+/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2,
+ *                    DIM_TYPE DIM3, DIM_TYPE DIM4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,4) || !require_contiguous(array) ||
+      !require_native(array) || !require_fortran(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = (DIM_TYPE) array_size(array,0);
+  $3 = (DIM_TYPE) array_size(array,1);
+  $4 = (DIM_TYPE) array_size(array,2);
+  $5 = (DIM_TYPE) array_size(array,3);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,
+ *                    DATA_TYPE* INPLACE_FARRAY4)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4)
+  (PyArrayObject* array=NULL)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_dimensions(array,4) || !require_contiguous(array)
+      || !require_native(array) || !require_fortran(array)) SWIG_fail;
+  $1 = (DIM_TYPE) array_size(array,0);
+  $2 = (DIM_TYPE) array_size(array,1);
+  $3 = (DIM_TYPE) array_size(array,2);
+  $4 = (DIM_TYPE) array_size(array,3);
+  $5 = (DATA_TYPE*) array_data(array);
+}
+
+/*************************/
+/* Argout Array Typemaps */
+/*************************/
+
+/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY1[ANY])
+ */
+%typemap(in,numinputs=0,
+         fragment="NumPy_Backward_Compatibility,NumPy_Macros")
+  (DATA_TYPE ARGOUT_ARRAY1[ANY])
+  (PyObject* array = NULL)
+{
+  npy_intp dims[1] = { $1_dim0 };
+  array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);
+  if (!array) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+%typemap(argout)
+  (DATA_TYPE ARGOUT_ARRAY1[ANY])
+{
+  $result = SWIG_AppendOutput($result,(PyObject*)array$argnum);
+}
+
+/* Typemap suite for (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
+ */
+%typemap(in,numinputs=1,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
+  (PyObject* array = NULL)
+{
+  npy_intp dims[1];
+  if (!PyLong_Check($input))
+  {
+    const char* typestring = pytype_string($input);
+    PyErr_Format(PyExc_TypeError,
+                 "Int dimension expected.  '%s' given.",
+                 typestring);
+    SWIG_fail;
+  }
+  $2 = (DIM_TYPE) PyLong_AsSsize_t($input);
+  if ($2 == -1 && PyErr_Occurred()) SWIG_fail;
+  dims[0] = (npy_intp) $2;
+  array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);
+  if (!array) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+}
+%typemap(argout)
+  (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)
+{
+  $result = SWIG_AppendOutput($result,(PyObject*)array$argnum);
+}
+
+/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
+ */
+%typemap(in,numinputs=1,
+         fragment="NumPy_Fragments")
+  (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
+  (PyObject* array = NULL)
+{
+  npy_intp dims[1];
+  if (!PyLong_Check($input))
+  {
+    const char* typestring = pytype_string($input);
+    PyErr_Format(PyExc_TypeError,
+                 "Int dimension expected.  '%s' given.",
+                 typestring);
+    SWIG_fail;
+  }
+  $1 = (DIM_TYPE) PyLong_AsSsize_t($input);
+  if ($1 == -1 && PyErr_Occurred()) SWIG_fail;
+  dims[0] = (npy_intp) $1;
+  array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);
+  if (!array) SWIG_fail;
+  $2 = (DATA_TYPE*) array_data(array);
+}
+%typemap(argout)
+  (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)
+{
+  $result = SWIG_AppendOutput($result,(PyObject*)array$argnum);
+}
+
+/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
+ */
+%typemap(in,numinputs=0,
+         fragment="NumPy_Backward_Compatibility,NumPy_Macros")
+  (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
+  (PyObject* array = NULL)
+{
+  npy_intp dims[2] = { $1_dim0, $1_dim1 };
+  array = PyArray_SimpleNew(2, dims, DATA_TYPECODE);
+  if (!array) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+%typemap(argout)
+  (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])
+{
+  $result = SWIG_AppendOutput($result,(PyObject*)array$argnum);
+}
+
+/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
+ */
+%typemap(in,numinputs=0,
+         fragment="NumPy_Backward_Compatibility,NumPy_Macros")
+  (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
+  (PyObject* array = NULL)
+{
+  npy_intp dims[3] = { $1_dim0, $1_dim1, $1_dim2 };
+  array = PyArray_SimpleNew(3, dims, DATA_TYPECODE);
+  if (!array) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+%typemap(argout)
+  (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])
+{
+  $result = SWIG_AppendOutput($result,(PyObject*)array$argnum);
+}
+
+/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY])
+ */
+%typemap(in,numinputs=0,
+         fragment="NumPy_Backward_Compatibility,NumPy_Macros")
+  (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY])
+  (PyObject* array = NULL)
+{
+  npy_intp dims[4] = { $1_dim0, $1_dim1, $1_dim2, $1_dim3 };
+  array = PyArray_SimpleNew(4, dims, DATA_TYPECODE);
+  if (!array) SWIG_fail;
+  $1 = ($1_ltype) array_data(array);
+}
+%typemap(argout)
+  (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY])
+{
+  $result = SWIG_AppendOutput($result,(PyObject*)array$argnum);
+}
+
+/*****************************/
+/* Argoutview Array Typemaps */
+/*****************************/
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1    )
+  (DATA_TYPE*  data_temp = NULL , DIM_TYPE  dim_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility")
+  (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)
+{
+  npy_intp dims[1] = { *$2 };
+  PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1    , DATA_TYPE** ARGOUTVIEW_ARRAY1)
+  (DIM_TYPE  dim_temp, DATA_TYPE*  data_temp = NULL )
+{
+  $1 = &dim_temp;
+  $2 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility")
+  (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)
+{
+  npy_intp dims[1] = { *$1 };
+  PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1     , DIM_TYPE* DIM2     )
+  (DATA_TYPE*  data_temp = NULL , DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility")
+  (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+{
+  npy_intp dims[2] = { *$2, *$3 };
+  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1     , DIM_TYPE* DIM2     , DATA_TYPE** ARGOUTVIEW_ARRAY2)
+  (DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp, DATA_TYPE*  data_temp = NULL )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)
+{
+  npy_intp dims[2] = { *$1, *$2 };
+  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1     , DIM_TYPE* DIM2     )
+  (DATA_TYPE*  data_temp = NULL  , DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+  (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+{
+  npy_intp dims[2] = { *$2, *$3 };
+  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1     , DIM_TYPE* DIM2     , DATA_TYPE** ARGOUTVIEW_FARRAY2)
+  (DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp, DATA_TYPE*  data_temp = NULL  )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)
+{
+  npy_intp dims[2] = { *$1, *$2 };
+  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+                      DIM_TYPE* DIM3)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    )
+  (DATA_TYPE* data_temp = NULL  , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+  $4 = &dim3_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility")
+  (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+{
+  npy_intp dims[3] = { *$2, *$3, *$4 };
+  PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,
+                      DATA_TYPE** ARGOUTVIEW_ARRAY3)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)
+  (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL)
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &dim3_temp;
+  $4 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)
+{
+  npy_intp dims[3] = { *$1, *$2, *$3 };
+  PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+                      DIM_TYPE* DIM3)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    )
+  (DATA_TYPE* data_temp = NULL   , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+  $4 = &dim3_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+  (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+{
+  npy_intp dims[3] = { *$2, *$3, *$4 };
+  PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,
+                      DATA_TYPE** ARGOUTVIEW_FARRAY3)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DATA_TYPE** ARGOUTVIEW_FARRAY3)
+  (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL   )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &dim3_temp;
+  $4 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)
+{
+  npy_intp dims[3] = { *$1, *$2, *$3 };
+  PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+                      DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DIM_TYPE* DIM4    )
+  (DATA_TYPE* data_temp = NULL  , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+  $4 = &dim3_temp;
+  $5 = &dim4_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility")
+  (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+{
+  npy_intp dims[4] = { *$2, *$3, *$4 , *$5 };
+  PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4,
+                      DATA_TYPE** ARGOUTVIEW_ARRAY4)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DIM_TYPE* DIM4    , DATA_TYPE** ARGOUTVIEW_ARRAY4)
+  (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL  )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &dim3_temp;
+  $4 = &dim4_temp;
+  $5 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_ARRAY4)
+{
+  npy_intp dims[4] = { *$1, *$2, *$3 , *$4 };
+  PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+                      DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DIM_TYPE* DIM4    )
+  (DATA_TYPE* data_temp = NULL   , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+  $4 = &dim3_temp;
+  $5 = &dim4_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+  (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+{
+  npy_intp dims[4] = { *$2, *$3, *$4 , *$5 };
+  PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4,
+                      DATA_TYPE** ARGOUTVIEW_FARRAY4)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DIM_TYPE* DIM4    , DATA_TYPE** ARGOUTVIEW_FARRAY4)
+  (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL   )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &dim3_temp;
+  $4 = &dim4_temp;
+  $5 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_FARRAY4)
+{
+  npy_intp dims[4] = { *$1, *$2, *$3 , *$4 };
+  PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/*************************************/
+/* Managed Argoutview Array Typemaps */
+/*************************************/
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1    )
+  (DATA_TYPE*  data_temp = NULL  , DIM_TYPE  dim_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
+  (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1)
+{
+  npy_intp dims[1] = { *$2 };
+  PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1    , DATA_TYPE** ARGOUTVIEWM_ARRAY1)
+  (DIM_TYPE  dim_temp, DATA_TYPE*  data_temp = NULL  )
+{
+  $1 = &dim_temp;
+  $2 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
+  (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1)
+{
+  npy_intp dims[1] = { *$1 };
+  PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$2), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1     , DIM_TYPE* DIM2     )
+  (DATA_TYPE*  data_temp = NULL  , DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
+  (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+{
+  npy_intp dims[2] = { *$2, *$3 };
+  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1     , DIM_TYPE* DIM2     , DATA_TYPE** ARGOUTVIEWM_ARRAY2)
+  (DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp, DATA_TYPE*  data_temp = NULL  )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2)
+{
+  npy_intp dims[2] = { *$1, *$2 };
+  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$3), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1     , DIM_TYPE* DIM2     )
+  (DATA_TYPE*  data_temp = NULL   , DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities")
+  (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)
+{
+  npy_intp dims[2] = { *$2, *$3 };
+  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1     , DIM_TYPE* DIM2     , DATA_TYPE** ARGOUTVIEWM_FARRAY2)
+  (DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp, DATA_TYPE*  data_temp = NULL   )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2)
+{
+  npy_intp dims[2] = { *$1, *$2 };
+  PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$3), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+                      DIM_TYPE* DIM3)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    )
+  (DATA_TYPE* data_temp = NULL   , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+  $4 = &dim3_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
+  (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+{
+  npy_intp dims[3] = { *$2, *$3, *$4 };
+  PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,
+                      DATA_TYPE** ARGOUTVIEWM_ARRAY3)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DATA_TYPE** ARGOUTVIEWM_ARRAY3)
+  (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL   )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &dim3_temp;
+  $4 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_ARRAY3)
+{
+  npy_intp dims[3] = { *$1, *$2, *$3 };
+  PyObject* obj= PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$4), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+                      DIM_TYPE* DIM3)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    )
+  (DATA_TYPE* data_temp = NULL    , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+  $4 = &dim3_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities")
+  (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)
+{
+  npy_intp dims[3] = { *$2, *$3, *$4 };
+  PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,
+                      DATA_TYPE** ARGOUTVIEWM_FARRAY3)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DATA_TYPE** ARGOUTVIEWM_FARRAY3)
+  (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL    )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &dim3_temp;
+  $4 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_FARRAY3)
+{
+  npy_intp dims[3] = { *$1, *$2, *$3 };
+  PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$4), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+                      DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DIM_TYPE* DIM4    )
+  (DATA_TYPE* data_temp = NULL   , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+  $4 = &dim3_temp;
+  $5 = &dim4_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
+  (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+{
+  npy_intp dims[4] = { *$2, *$3, *$4 , *$5 };
+  PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4,
+                      DATA_TYPE** ARGOUTVIEWM_ARRAY4)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DIM_TYPE* DIM4    , DATA_TYPE** ARGOUTVIEWM_ARRAY4)
+  (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL   )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &dim3_temp;
+  $4 = &dim4_temp;
+  $5 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Utilities")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4)
+{
+  npy_intp dims[4] = { *$1, *$2, *$3 , *$4 };
+  PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$5), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2,
+                      DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+ */
+%typemap(in,numinputs=0)
+  (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DIM_TYPE* DIM4    )
+  (DATA_TYPE* data_temp = NULL    , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp)
+{
+  $1 = &data_temp;
+  $2 = &dim1_temp;
+  $3 = &dim2_temp;
+  $4 = &dim3_temp;
+  $5 = &dim4_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities")
+  (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4)
+{
+  npy_intp dims[4] = { *$2, *$3, *$4 , *$5 };
+  PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4,
+                      DATA_TYPE** ARGOUTVIEWM_FARRAY4)
+ */
+%typemap(in,numinputs=0)
+  (DIM_TYPE* DIM1    , DIM_TYPE* DIM2    , DIM_TYPE* DIM3    , DIM_TYPE* DIM4    , DATA_TYPE** ARGOUTVIEWM_FARRAY4)
+  (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL    )
+{
+  $1 = &dim1_temp;
+  $2 = &dim2_temp;
+  $3 = &dim3_temp;
+  $4 = &dim4_temp;
+  $5 = &data_temp;
+}
+%typemap(argout,
+         fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements,NumPy_Utilities")
+  (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4)
+{
+  npy_intp dims[4] = { *$1, *$2, *$3 , *$4 };
+  PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5));
+  PyArrayObject* array = (PyArrayObject*) obj;
+
+  if (!array || !require_fortran(array)) SWIG_fail;
+
+PyObject* cap = PyCapsule_New((void*)(*$5), SWIGPY_CAPSULE_NAME, free_cap);
+
+%#if NPY_API_VERSION < NPY_1_7_API_VERSION
+  PyArray_BASE(array) = cap;
+%#else
+  PyArray_SetBaseObject(array,cap);
+%#endif
+
+  $result = SWIG_AppendOutput($result,obj);
+}
+
+/**************************************/
+/* In-Place Array Typemap - flattened */
+/**************************************/
+
+/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY_FLAT, DIM_TYPE DIM_FLAT)
+ */
+%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,
+           fragment="NumPy_Macros")
+  (DATA_TYPE* INPLACE_ARRAY_FLAT, DIM_TYPE DIM_FLAT)
+{
+  $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),
+                                                 DATA_TYPECODE);
+}
+%typemap(in,
+         fragment="NumPy_Fragments")
+  (DATA_TYPE* INPLACE_ARRAY_FLAT, DIM_TYPE DIM_FLAT)
+  (PyArrayObject* array=NULL, int i=1)
+{
+  array = obj_to_array_no_conversion($input, DATA_TYPECODE);
+  if (!array || !require_c_or_f_contiguous(array)
+      || !require_native(array)) SWIG_fail;
+  $1 = (DATA_TYPE*) array_data(array);
+  $2 = 1;
+  for (i=0; i < array_numdims(array); ++i) $2 *= array_size(array,i);
+}
+
+%enddef    /* %numpy_typemaps() macro */
+/* *************************************************************** */
+
+/* Concrete instances of the %numpy_typemaps() macro: Each invocation
+ * below applies all of the typemaps above to the specified data type.
+ */
+%numpy_typemaps(signed char       , NPY_BYTE     , int)
+%numpy_typemaps(unsigned char     , NPY_UBYTE    , int)
+%numpy_typemaps(short             , NPY_SHORT    , int)
+%numpy_typemaps(unsigned short    , NPY_USHORT   , int)
+%numpy_typemaps(int               , NPY_INT      , int)
+%numpy_typemaps(unsigned int      , NPY_UINT     , int)
+%numpy_typemaps(long              , NPY_LONG     , int)
+%numpy_typemaps(unsigned long     , NPY_ULONG    , int)
+%numpy_typemaps(long long         , NPY_LONGLONG , int)
+%numpy_typemaps(unsigned long long, NPY_ULONGLONG, int)
+%numpy_typemaps(float             , NPY_FLOAT    , int)
+%numpy_typemaps(double            , NPY_DOUBLE   , int)
+%numpy_typemaps(int8_t            , NPY_INT8     , int)
+%numpy_typemaps(int16_t           , NPY_INT16    , int)
+%numpy_typemaps(int32_t           , NPY_INT32    , int)
+%numpy_typemaps(int64_t           , NPY_INT64    , int)
+%numpy_typemaps(uint8_t           , NPY_UINT8    , int)
+%numpy_typemaps(uint16_t          , NPY_UINT16   , int)
+%numpy_typemaps(uint32_t          , NPY_UINT32   , int)
+%numpy_typemaps(uint64_t          , NPY_UINT64   , int)
+
+
+/* ***************************************************************
+ * The follow macro expansion does not work, because C++ bool is 4
+ * bytes and NPY_BOOL is 1 byte
+ *
+ *    %numpy_typemaps(bool, NPY_BOOL, int)
+ */
+
+/* ***************************************************************
+ * On my Mac, I get the following warning for this macro expansion:
+ * 'swig/python detected a memory leak of type 'long double *', no destructor found.'
+ *
+ *    %numpy_typemaps(long double, NPY_LONGDOUBLE, int)
+ */
+
+#ifdef __cplusplus
+
+%include <std_complex.i>
+
+%numpy_typemaps(std::complex<float>,  NPY_CFLOAT , int)
+%numpy_typemaps(std::complex<double>, NPY_CDOUBLE, int)
+
+#endif
+
+#endif /* SWIGPYTHON */
diff --git a/python/setup.py b/python/setup.py
index 977d6bb..d238a1c 100644
--- a/python/setup.py
+++ b/python/setup.py
@@ -3,6 +3,7 @@
 import sys
 import os
 from sysconfig import get_paths
+import numpy
 
 python_include = get_paths()["include"]
 
@@ -21,7 +22,7 @@ def build_extensions(self):
 libctlgeom_module = Extension(
     "_libctlgeom",
     sources=["libctlgeom_wrap.c"],
-    include_dirs=["/usr/local/include", python_include],
+    include_dirs=["/usr/local/include", python_include, numpy.get_include()],
     library_dirs=["/usr/local/lib"],
     libraries=["ctlgeom"],
     extra_compile_args=["-I/usr/local/include"],
@@ -35,4 +36,5 @@ def build_extensions(self):
     ext_modules=[libctlgeom_module],
     py_modules=["libctlgeom"],
     cmdclass={"build_ext": CustomBuildExtCommand},
+    install_requires=["numpy"],
 )
diff --git a/python/test.ipynb b/python/test.ipynb
index 3ed1a5a..65cace6 100644
--- a/python/test.ipynb
+++ b/python/test.ipynb
@@ -4,15 +4,6 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "from ctlgeom import *"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -23,6 +14,8 @@
     }
    ],
    "source": [
+    "from ctlgeom import *\n",
+    "\n",
     "sphere = Sphere(1, (0, 0.5, 0), 1)\n",
     "a = point_is_in_object((0.5, 0, 0), sphere)\n",
     "b = point_is_in_object((1.5, 0, 0), sphere)\n",
@@ -31,7 +24,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -40,7 +33,7 @@
        "((-1.0, -0.5, -1.0), (1.0, 1.5, 1.0))"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -51,7 +44,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -69,7 +62,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -89,7 +82,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -115,19 +108,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.219832181930542 seconds\n"
+      "Time taken: 0.21468734741210938 seconds\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x800 with 2 Axes>"
       ]
@@ -165,7 +158,66 @@
     "plt.figure(figsize=(10, 8))\n",
     "plt.imshow(material_map, cmap='viridis', extent=[-5, 5, -5, 5])\n",
     "plt.colorbar(label='Material')\n",
-    "plt.title('1000 Random Spheres')\n",
+    "plt.title('Cool Shapes')\n",
+    "plt.xlabel('X')\n",
+    "plt.ylabel('Y')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time taken: 0.06966400146484375 seconds\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from ctlgeom import *\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import time \n",
+    "\n",
+    "# This is the same as the previous example, but using the new function\n",
+    "\n",
+    "sphere1 = Sphere(material=1, center=(0, -0.5, 0), radius=0.5)\n",
+    "sphere2 = Sphere(material=2, center=(0, 0.5, 0), radius=1)\n",
+    "block = Block(material=3, center=(0.5, 0.5, 0), e1=(1, 1, 0), e2=(1, -1, 0), e3=(0, 0, 1), size=(1, 1, 1))\n",
+    "group = ObjectGroup([sphere2, sphere1, block])\n",
+    "\n",
+    "# Create a grid of points\n",
+    "x = np.linspace(-1, 1, 1000)\n",
+    "y = np.linspace(-1, 1, 1000)\n",
+    "xx, yy = np.meshgrid(x, y)\n",
+    "points = np.array([xx.flatten(), yy.flatten(), np.zeros_like(xx.flatten())]).T\n",
+    "\n",
+    "start_time = time.time()\n",
+    "material_map = geom.material_of_numpy_points_in_tree(points, group.geom_box_tree)\n",
+    "material_map = np.array(material_map, dtype=float).reshape(xx.shape)\n",
+    "material_map = np.nan_to_num(material_map)\n",
+    "end_time = time.time()\n",
+    "print(f\"Time taken: {end_time - start_time} seconds\")\n",
+    "\n",
+    "# Create the plot\n",
+    "plt.figure(figsize=(10, 8))\n",
+    "plt.imshow(material_map, cmap='viridis', extent=[-5, 5, -5, 5])\n",
+    "plt.colorbar(label='Material')\n",
+    "plt.title('Cool Shapes')\n",
     "plt.xlabel('X')\n",
     "plt.ylabel('Y')\n",
     "plt.show()"
@@ -180,7 +232,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.2346351146697998 seconds\n"
+      "Time taken: 0.23345279693603516 seconds\n"
      ]
     },
     {

From 1ad3961c4a0d4a49c0b72b84a97f0e48b94a1bbc Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 14 Nov 2024 23:14:57 -0800
Subject: [PATCH 26/37] update notebook

---
 python/test.ipynb | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/python/test.ipynb b/python/test.ipynb
index 65cace6..e6be5cb 100644
--- a/python/test.ipynb
+++ b/python/test.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -24,7 +24,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -33,7 +33,7 @@
        "((-1.0, -0.5, -1.0), (1.0, 1.5, 1.0))"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -44,7 +44,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -62,7 +62,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -108,14 +108,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.21468734741210938 seconds\n"
+      "Time taken: 0.2274618148803711 seconds\n"
      ]
     },
     {
@@ -166,19 +166,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.06966400146484375 seconds\n"
+      "Time taken: 0.01887798309326172 seconds\n"
      ]
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyYAAAK7CAYAAAAHuJsbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACG4klEQVR4nO3deXycdb33//c1M8lM9n1t0jYtpZTuTWkptNCyFMEND8eDHhRB5L4REKGsBRVEoYioCAiIghzlp3C0iHgEhPtAS0EUCmWHSqFN0yXNvq8zc/3+CIlNm7ZZZq7vzFyv5+NxPTSTa+b6TEKm85nv8rZs27YFAAAAAAZ5TBcAAAAAADQmAAAAAIyjMQEAAABgHI0JAAAAAONoTAAAAAAYR2MCAAAAwDgaEwAAAADG0ZgAAAAAMI7GBAAAAIBxNCYAXOnNN9/Uueeeq4qKCgUCAaWnp2vBggW69dZb1djYGLXr3nDDDbIsa0Tn/vWvf9XKlStVWloqv9+v0tJSLV++XLfccsuQ8yzL0sUXXxyNcgEAcAyNCQDX+cUvfqHKykq98soruvLKK/XUU0/pj3/8oz7/+c/r3nvv1XnnnWe6RN177736xCc+oczMTN11113661//qh/84AeaMWOG/vCHP5guDwCAiPOZLgAAnPTSSy/p61//uk4++WQ99thj8vv9g987+eSTdfnll+upp54yWGG/NWvW6LjjjtuvCfnyl7+scDhsqCoAAKKHERMArnLzzTfLsizdd999Q5qSAcnJyfrMZz4z+HU4HNatt96qI444Qn6/X4WFhTr77LO1Y8eO/e77wAMPaO7cuQoEAsrNzdXnPvc5vffee2Oqs6GhQSUlJcN+z+MZ/qX7N7/5jWbMmKHU1FTNnTtX//M//zPk+1u2bNG5556radOmKTU1VRMmTNCnP/1pvfXWW0POW7dunSzL0kMPPaRVq1apuLhYKSkpOv7447Vp06b9rrtx40Z95jOfUW5urgKBgObPn6///u//HnJOZ2enrrjiisGpc7m5uVq4cKF+97vfjebHAgBIYDQmAFwjFArp2WefVWVlpcrLy0d0n69//eu6+uqrdfLJJ+vxxx/X9773PT311FM65phjVF9fP3jemjVrdN5552nmzJl69NFH9dOf/lRvvvmmlixZog8++GDUtS5ZskRr167VDTfcoDfeeEOhUOig5//lL3/RXXfdpRtvvFFr164dbIw++uijwXN27dqlvLw83XLLLXrqqaf0s5/9TD6fT4sXL9bmzZv3e8xrr71WH330kX75y1/ql7/8pXbt2qXly5cPecznnntOxx57rJqbm3XvvffqT3/6k+bNm6czzzxTDz744OB5q1at0j333KNLLrlETz31lH7zm9/o85//vBoaGkb9swEAJCgbAFyipqbGlmR/4QtfGNH57733ni3JvvDCC4fc/o9//MOWZF977bW2bdt2U1OTnZKSYp922mlDztu+fbvt9/vt//zP/xy87frrr7dH8tK7ZcsWe9asWbYkW5KdkpJin3jiifZdd91l9/b2DjlXkl1UVGS3trYOea4ej8des2bNAa8RDAbt3t5ee9q0afZll102ePtzzz1nS7IXLFhgh8Phwdu3bdtmJyUl2V/72tcGbzviiCPs+fPn2319fUMe+1Of+pRdUlJih0Ih27Zte9asWfbpp59+yOcNAHAvRkwA4ACee+45SdI555wz5PZFixZpxowZ+t///V9J/etWurq69juvvLxcJ5xwwuB5ozF16lS98cYbWr9+vb773e/qpJNO0iuvvKKLL75YS5YsUXd395DzV6xYoYyMjMGvi4qKVFhYqKqqqsHbgsGgbr75Zh155JFKTk6Wz+dTcnKyPvjgg2GnnP3nf/7nkB3EJk2apGOOOWbw57Jlyxa9//77OuusswYff+A47bTTtHv37sGRmEWLFunJJ5/UNddco3Xr1qmrq2vUPxMAQGKjMQHgGvn5+UpNTdXWrVtHdP7ANKPh1nqUlpYOfn+k542Wx+PRcccdp+985zt6/PHHtWvXLp155pl69dVX9cADDww5Ny8vb7/7+/3+IQ3AqlWr9O1vf1unn366/vznP+sf//iHXnnlFc2dO3fYRqG4uHjY2waez549eyRJV1xxhZKSkoYcF154oSQNTne74447dPXVV+uxxx7TihUrlJubq9NPP31M09wAAImJXbkAuIbX69WJJ56oJ598Ujt27FBZWdlBzx94s7979+79zt21a5fy8/P3O29fe583XmlpaVq9erUeeeQRvf3226O+/0MPPaSzzz5bN99885Db6+vrlZ2dvd/5NTU1w9428HwHntfq1av1b//2b8Nec/r06YO1f/e739V3v/td7dmzZ3D05NOf/rTef//9UT8XAEDiYcQEgKusXr1atm3r/PPPV29v737f7+vr05///GdJ0gknnCCp/w393l555RW99957OvHEEyX1L1RPSUnZ77wdO3bo2WefHTxvNIZrciQNTrkqLS0d9WNalrXfTmR/+ctftHPnzmHP/93vfifbtge/rqqq0t/+9jctX75cUn/TMW3aNL3xxhtauHDhsMfe08sGFBUV6ZxzztEXv/hFbd68WZ2dnaN+LgCAxMOICQBXWbJkie655x5deOGFqqys1Ne//nXNnDlTfX192rRpk+677z7NmjVLn/70pzV9+nT9n//zf3TnnXfK4/Ho1FNP1bZt2/Ttb39b5eXluuyyyyRJ2dnZ+va3v61rr71WZ599tr74xS+qoaFB3/3udxUIBHT99dePus6ZM2fqxBNP1KmnnqqpU6equ7tb//jHP/SjH/1IRUVFYwqB/NSnPqUHH3xQRxxxhObMmaNXX31VP/zhDw84clRbW6vPfe5zOv/889XS0qLrr79egUBAq1evHjzn5z//uU499VSdcsopOuecczRhwgQ1Njbqvffe02uvvabf//73kqTFixfrU5/6lObMmaOcnBy99957+s1vfqMlS5YoNTV11M8FAJCATK++BwATXn/9dfsrX/mKPXHiRDs5OdlOS0uz58+fb3/nO9+xa2trB88LhUL2D37wA/vwww+3k5KS7Pz8fPtLX/qSXV1dvd9j/vKXv7TnzJljJycn21lZWfZnP/tZ+5133hlyzkh35fr5z39u/9u//Zs9ZcoUOzU11U5OTranTp1qX3DBBftdW5J90UUX7fcYkyZNsr/yla8Mft3U1GSfd955dmFhoZ2ammovXbrU3rBhg3388cfbxx9//OB5A7ty/eY3v7EvueQSu6CgwPb7/fayZcvsjRs37nedN954w/6P//gPu7Cw0E5KSrKLi4vtE044wb733nsHz7nmmmvshQsX2jk5Obbf77enTJliX3bZZXZ9ff0hfxYAAHewbHuvcXoAgOutW7dOK1as0O9//3v9+7//u+lyAAAuwRoTAAAAAMbRmAAAAAAwjqlcAAAAAIxjxAQAAACIY/fcc4/mzJmjzMxMZWZmasmSJXryyScPep/169ersrJSgUBAU6ZM0b333utQtQdGYwIAAADEsbKyMt1yyy3auHGjNm7cqBNOOEGf/exn9c477wx7/tatW3Xaaadp2bJl2rRpk6699lpdcsklWrt2rcOVD8VULgAAACDB5Obm6oc//OGwuVdXX321Hn/88cHQXkm64IIL9MYbb+ill15ysswhXBWwGA6HtWvXLmVkZMiyLNPlAAAAuJ5t22pra1Npaak8ntibzNPd3a3e3l7Hr2vb9n7vV/1+v/x+/0HvFwqF9Pvf/14dHR1asmTJsOe89NJLWrly5ZDbTjnlFN1///3q6+tTUlLS+IofI1c1Jrt27VJ5ebnpMgAAALCP6upqlZWVmS5jiO7ublVMSldNbcjxa6enp6u9vX3Ibddff71uuOGGYc9/6623tGTJEnV3dys9PV1//OMfdeSRRw57bk1NjYqKiobcVlRUpGAwqPr6epWUlETkOYyWqxqTjIwMSdJSnSafzHSCANzDm5sz5OveWRPVk73/a09fqkfBFGdq8nVJSZ3h/W73N/cp+e3tQ24LNTY5UxQAVwuqTy/oicH3abGkt7dXNbUhVb06WZkZzo3mtLaFNalym6qrq5WZmTl4+8FGS6ZPn67XX39dzc3NWrt2rb7yla9o/fr1B2xO9h2NGVjdYXJWkasak4EftE9J8lk0JgAiYK8XcM/M6QpmB/q/8FpqnBaQPcJ/x7xRKG04drLUm7X/7b0lkmbMHvzaCks5H3RLof5/qHzN3Qq/s3mvB2J5IoAI+fjlJJan2adnWErPcK6+sPqvNbDL1kgkJyfrsMMOkyQtXLhQr7zyin7605/q5z//+X7nFhcXq6amZshttbW18vl8ysvLG2f1Y+eqxgQAIsETCMhTWixJaplfpL7U/u4jlCzZTnUYUWZ7pMbpgcGvrVCKvPOPltQ/4pK1aY8kKbyrRuHubiM1AgAOzLZt9fT0DPu9JUuW6M9//vOQ255++mktXLjQ2PoSicYEAA7KEwhIXq88RQXqmFEgSQoGPOrKi70FmtFkezU43SyY4lHXSf3zj1Pri+Tt6Z8alvZencJ76qRQiGYFABx07bXX6tRTT1V5ebna2tr08MMPa926dXrqqackSatXr9bOnTv161//WlL/Dlx33XWXVq1apfPPP18vvfSS7r//fv3ud78z+TRoTABgOL4pkxXKSVPTERkKpliSJdmxO8vAmM58jwYisdpLSyS7RL4uW9nvt8nb1KHgR9uM1gcAkRCywwMzWx273mjs2bNHX/7yl7V7925lZWVpzpw5euqpp3TyySdLknbv3q3t2/+1jrCiokJPPPGELrvsMv3sZz9TaWmp7rjjDp1xxhkRfR6j5aock9bWVmVlZWm5PssaEwBD+IqLZKenqrmySLKkvhRLYV4mxsXTJyV12ZIt5bxSI3V2KVizx3RZAGJM0O7TOv1JLS0tI15P4ZSB9461myc5vvi9cHpVTP5MookREwDuY1myfP1dR3jhDAXTfGqYnDziheoYmXCS1JPUP8xUc1KJrJCUWVWmpPY+Wa++L0myg30spAcQ88KyFZZzr1VOXiuW0JgAcBVvUaGCh5Wq8fD+BRO2jylaTrG9UsuUZFl2sqwZlZKknH92ybdll0J7ag1XBwAwjcYEQGLzeOXNyZKK8tV2RI76Ui31pdKJmGRbkv3xNLmGmSlKqpiipI4KZWxukvbUK9TUIoWdDzMDgAMJK6zRrfoY//XciMYEQEKy/H6FK49QMNWn+inJpsvBQQw0i50FeZLylPVRr3ydQXlefV/2Aba6BAAkHhoTAAnD8vnknVimUG66mmZkOJamjshqmZIsKVm+qQuU816bvI3tCm3fITsYNF0aACCKaEwAxD0rKVmeSRPUPrNAHUUJknAIBVOkugUZkjKUtqdQ6e/UKVy1U3Zfr+nSALhMyLYVcnCjDievFUtoTADENe+Rh6vtiBx15XlYxJ7AOoq86iwsVkpDoTLeb1Lo3X+aLgkAEGE0JgDijreoUN1zJ6o7x6fedEs2gySuYFv9gY5dS/KUPPtoBZqCCryxnR29AEQd2wU7g8YEQHywLHmzMtWz4DA1Tk5WmFcv17K9Uk+WpZ6sJLWVTVXmtnL5X9uiUEsrmSgAEMf4px1AzPNNKFXPtGI1VvhJY8cQYZ/UfFiyPJOOVNbWHvk371Jwd43psgAAY0BjAiA2WZa82dnqWjRVzUVJCgZMF4RYFk6Smg73yzexQql7ypTy8ocKNTczggIgIsKyFWIqV9TRmACIOd78PPXNnKiGwwMsaMeoBANS66QktU08Qjn/7FbSO9sVqm8wXRYAYARoTADEDMvnU9/xc9VUlqyQ33Q1iGe2JTVOD8g7+XBlVPcq6fk3yEEBMGYsfncGjQkA4wZySDpmFKi9hC22EDkhf/8alPS0BUp7jxwUAIhlNCYAjBrMIcn1yPaYrgaJqr3Eq46iYqU0koMCYPQIWHQGjQkAI7w5OQpNL1ftzDRySOAI2/OvHJS8zDnybq5WqKnJdFkAgI/RmABwlmXJV1ykhhMnqy+Vle1wnu2V6uekKWnqdOU9u03Bmj3s3gUAMYDGBIBjfJMnqmNGkRpLfAQkwri+NEu1p1YobXe50t7bo+C27aZLAhCjwh8fTl7PjXhrACDqPKmpsirKVbsol4BExJSwT2or96mjeIIKXk6RvbVa4c5O02UBgCvRmACIKm92llpWzlB3NtO2ELvCSdKeY3MVmJmjrKffU6i5xXRJAGJIyOGARSevFUtoTABEh8er8LFz1FwRILUdcaM721LwM0cqc2u3PC++KYVDpksCANdgc04AEecJBGQvma2mI2hKEH+CAanpiIDso2fJE+A/YABwCiMmACLKV16muhPKFU7uT98G4pFtSY0zU+WZNl8Fz1YrWL3DdEkADArZ/YeT13MjGhMAEeEJBNR1wmw1FfgU8puuBhg/2+pPjq87oVyptSVKee4thbu7TZcFAAmLqVwAxs0TCKjjlDlqK6MpQeIJ+ft37uo8eQ5TuwCXChs43IgREwDjYs2fqYa5mQolm64EiK72Eq+6vjBfuW+0yt70julyACDh0JgAGBvLkmfuDNUtyJTtNV0M4IxQslS/IFMF9pEKv/EeifGAS4RlKSTnFk6GHbxWLKExATBq3vw89c2cqIbDAyxwh+vYXqnuqCzlZM1T0jvbFapvMF0SACQEGhMAo+LNz1PTymnqTacjgXvZltQ4PaDkCdOU87RoTgAgAlj8DmDEvPl5ajqZpgQY0JtuqenkafLm55kuBUAUhW3nDzeiMQFwaB6vPHOO6B8pyaApAfbWm2GpaeU0eeYcIXlYcAUAY8VULgAHZSUlq2/ZbLVMTWY9CXAAvemW6hbnKDtvrnwvvC27r9d0SQAiKOTw4ncnrxVLGDEBcGCWpb7jZqv5MJoS4FBsS2qa5lffstmSxR8MAIwWjQmAYVk+n/pOXKCWKQSUAKPRMjVZfScukOVjUgIAjAavmgD2Y/l86jtuLk0JMAa2JbVMSVZOaI58G96UHQyaLgnAODGVyxmMmAAYyrLUd/xcNR9GUwKMR9M0v/qOn8u0LgAYIUZMAAyykpLVd9xsRkqACGmZkqwsLVDS82+xIB6IY2HbUtjBxZZOXiuWMGICoJ/Hq75ls9XM7ltAxNiW1Dy1f2c7thIGgINjxARAf1Nywjy1VjBSAkRDy9RkZXrmKenZ16VwyHQ5AEaJNSbOYMQEcDkrKVnB5f1NCSMlQHTYltRa0f+3ZiXxAQAADIfGBHAzckoAx9iW1HxY/zouFsQDwP6YygW4lOXzqXf5XKZvAQ4bXBC//g22EgbiREgehRz8PN+tEz4ZMQFcaO+cEkZKAGcNLIgPLptDCCMA7IVXRMBtLEu9ywlPBExrmuZXlneukv73Ncm2TZcD4CBsh7cLtl36qSEjJoCLWEnJCp6wgOlbQIxorej/m2RBPADQmADuQU4JEHPIOQGAf2EqF+ASnlnT1DKVT2WBWNQyNVkF9dMUfvN906UAGAY5Js5gxARwAW9+nppnZTNSAsQo25KaZ2XLm59nuhQAMIYREyDBefPz1HTyNPWm05UAsaw33VLTydOU84wUqm8wXQ6AvYRsj0K2g9sFu3Q/DEZMgATmzc9T08pp6s2gKQHiQW+GpaaV0xg5AeBKcduYrFmzRpZl6dJLLzVdChCbLEt9MycyUgLEmd50S30zJpIOD8SQsCyF5XHwcOfff1w2Jq+88oruu+8+zZkzx3QpQMzyzJ2hpsMDpssAMAZNRwTkmXOE6TIAwFFx15i0t7frrLPO0i9+8Qvl5OSYLgeISVblTNVVZrHYHYhTtiXVLcyWNX+m6VIAwDFx15hcdNFF+uQnP6mTTjrpkOf29PSotbV1yAEkOk8goMbZmbKJRADimu2VGudmyhNg5BMwbWC7YCcPN4qrxuThhx/Wa6+9pjVr1ozo/DVr1igrK2vwKC8vj3KFgFmeQECdJ89RiLgSICGEkqXOk+fQnABwhbhpTKqrq/XNb35TDz30kAIjfIFevXq1WlpaBo/q6uooVwmY1XXCbLWXMFQCJJL2Eq+6Vsw2XQbgagPbBTt5uFHc5Ji8+uqrqq2tVWVl5eBtoVBIzz//vO666y719PTI6x36hszv98vv9ztdKmCEr7xMTQVx8ycNYBQ6C31KKy9TsHqH6VIAIGri5l3MiSeeqLfeemvIbeeee66OOOIIXX311fs1JYCb+CaVq25FGVO4gAQV8kt1J5ar4DlLwSpG/wEkprhpTDIyMjRr1qwht6WlpSkvL2+/2wFX8XjVPruEpgRIcKFkqX12iQLVu6RwyHQ5gKv055g4tyCdHBMAcSl87Bx1sK4EcIWOEq/Cx5LhBSAxxc2IyXDWrVtnugTAKG92lporAuSVAC5hW1JrRUB5b2Up1NxiuhzANcLyKOTg5/lh2Y5dK5YwYgLEKU9qqlpWzlCQXUQBVwkGpJaVM+RJTTVdCgBEFI0JEKesinJ1ZzNUArhRd7Ylq4JsLgCJJa6ncgFu5Zs8UbWLck2XAcCgukW5KuyYqOC27aZLARKe09kiIZupXADigcerjhlFCieZLgSASeEkqWNGkeRh8wsAiYHGBIgz4WNmq72MwU4AUnuZT/YSUuGBaAvL4/jhRu581kCc8ubkqG0Su3AB6GdbUuvkgLw5OaZLAYBx42NXII6EpperL42uBMC/9KVZCk0rk15uMl0KkLBCtqWQg58KOnmtWMKICRAnvEceroaZaabLABCDGmany3vk4abLAIBxoTEB4oCVlKy2I3Jks8YVwDBsr9R2RI6spGTTpQDAmDGVC4gDnkkT1JXL5wgADqwr16OMSRMU2rLVdClAwgk5nPweIvkdQCzylRSr/thiObh9OoA4ZHuk+mOL5SspNl0KAIwJIyZAjOs+coJCftNVAIgHIb/UPWOCfLtrTJcCJJSw7VHYwU8IwwQsAog13vw8tZUxZxzAyLWVJ8ubn2e6DAAYNRoTIFZZlvpmTmS0BMCohPxS38yJkuXO7UYBxC+mcgExypudrYbDA6bLABCHmg4PqPDNbIWayDYBIoHF785gxASIUV2LppLwDmBMbKv/NQQA4gkjJkAM8k0oVXNRkukyAMSxzqIkpU4oVXDnLtOlAHEvLGfT2MOOXSm2MGICxBrLUs+0YgWZxQVgHIIBqWdaMWtNAMQNRkyAGOPNylRjBSveAYxfS4VfBa9nKtTcYroUIK6F5VHYwc/znbxWLHHnswZiWM+CwxRmFheACAgn9b+mAEA8oDEBYoi3qFCtk8ktARA5rZOT5S0qNF0GABwSU7mAGNI9d6LC/FUCiKCwr/+1JenpWtOlAHErZHsUcjD53clrxRJ3PmsgBvmKi9RRzBwuAJHXUZzEqAmAmMdns0AssCz1Ti9lJy4AUREMSH2HT5Cntk6y3RncBoxHWJbCcnK7YHfupseICRADPKmpappGVwIgepqmB+RJSTFdBgAcEI0JEAOskkK59MMRAA6ySotMlwAAB8RULsAwy+dT+8wCORgoC8CFbI/UPrNAqduqZQeDpssB4gqL353hzmcNxBDvxDJ1FHlNlwHABTqKvPKWTzBdBgAMixETwLBQXobpEgC4SCgvQ9pqugogvoTkUcjBz/OdvFYsceezBmKE5feraUa66TIAuEjTjAxZfr/pMgBgPzQmgEHhyiPYIhiAo4IpUnjBEabLAOJK2LYcP0ZjzZo1Ouqoo5SRkaHCwkKdfvrp2rx580Hvs27dOlmWtd/x/vvvj+dHNS40JoApHq+CqcymBOC8YJpP8rC2DUgU69ev10UXXaS///3veuaZZxQMBrVy5Up1dHQc8r6bN2/W7t27B49p06Y5UPHweFcEGOLNy1X9lGTTZQBwoZYpySp6I1ehujrTpQCIgKeeemrI17/61a9UWFioV199Vccdd9xB71tYWKjs7OwoVjdyjJgAhnQcXWG6BAAuxmsQMHLhjxe/O3WEP36L3traOuTo6ekZUb0tLS2SpNzc3EOeO3/+fJWUlOjEE0/Uc889N/YfUgTQmAAGWEnJCvkJLgFgTshvyUpi1BaIZeXl5crKyho81qxZc8j72LatVatWaenSpZo1a9YBzyspKdF9992ntWvX6tFHH9X06dN14okn6vnnn4/kUxgVpnIBBnimTVZXLp8LADCnK9ejzGmTFXr3n6ZLAWJe2PYo7GDo4cC1qqurlZmZOXi7fwQ76l188cV688039cILLxz0vOnTp2v69OmDXy9ZskTV1dW67bbbDjn9K1p4ZwQ4zbIUzEk1XQUA9L8WWYzeArEqMzNzyHGoxuQb3/iGHn/8cT333HMqKysb9fWOPvpoffDBB2Mtd9xoTACHWb4kNR2eYroMAFDT4SmyfEmmywAwTrZt6+KLL9ajjz6qZ599VhUVY1tDtmnTJpWUlES4upFjKhfgMG9ZiRwcDQaAA7I9/a9Jwa1VpksBYlpIlkJybnRxtNe66KKL9Nvf/lZ/+tOflJGRoZqaGklSVlaWUlL6PwxdvXq1du7cqV//+teSpNtvv12TJ0/WzJkz1dvbq4ceekhr167V2rVrI/tkRoHGBHBY95R82cQHAIgBtlfqrsiXj8YEiGv33HOPJGn58uVDbv/Vr36lc845R5K0e/dubd++ffB7vb29uuKKK7Rz506lpKRo5syZ+stf/qLTTjvNqbL3Q2MCOMibnaW2AqZNAIgdXYVJys7OUqi5xXQpQMwytfh9pGzbPuQ5Dz744JCvr7rqKl111VWjuk60MaEEcJCVlqaeTBaaAogdPZmWrLQ002UAACMmgJM65kwwXQIA7KdjzgT5d+4yXQYQs0Ia/bqP8V7PjRgxARzUm8XiEgCxh9cmALGAxgRwiDczU2HGKAHEoLC3/zUKAEzibRLgkPC0cvWlsr4EQOzpS7MUnlYuvfqO6VKAmBTri98ThTufNQAAAICYwogJ4ABPIKCmIzJMlwEAB9R8RIZy3gko3N1tuhQg5oRsj0IOjmI4ea1Y4s5nDTjN61UwhWlcAGJXMMWSvCyCB2AOjQngAE9RgRzcZRAARs/6+LUKAAxhKhfggI4ZBbJpTADEMNuSOo4okP+jbaZLAWKOLUthBz9htF36aSYjJgAAoJ873wsBiBGMmABR5ptUrsYi/tQAxL6OIp/SJpUrWFVtuhQgprD43RnufNaAk7xeghUBxIWwTyyAB2AMb5eAKOstzTZdAgCMWG9ptjwfma4CiC1h21LYwcWiTl4rljBiAkSTZam1IsV0FQAwYq0VKZLlzjdFAMyiMQEAAABgHFO5gCjyFhbIZro2gDhie/tfu0J7ak2XAsSMkDwKOfh5vpPXiiXufNaAQ/qmlSqUbLoKABi5ULIUPKzUdBkAXIgREwAAAOAgWPzuDEZMAAAAABhHYwJEiSctTR1lAdNlAMCotZcH5ElLM10GAJdhKhcQJVbAr55Mdw7FAohvPZmWrIBf6ugwXQoQE8LyKOzg5/lOXiuWuPNZAwAAAIgpjJgAAAAABxGyLYUcXJDu5LViCSMmQLQU5pmuAADGjtcwAA5jxASIkrYZuaZLAIAxa5uRq9T3TFcBxAa2C3YGIyYAAAAAjKMxAQAAAGAcU7kAAACAg7Btj8K2c5/n2w5eK5a481kDUebNy1Uw4M75oQASQzBgyZuTY7oMAC7CiAkQDcUF6k2nMQEQv3rTLam0UGpqMl0KYFxIlkJycLtgB68VSxgxAQAAAGAcjQkAAAAA45jKBQAAABxE2HY2WyRsO3apmMKICQAAAADjGDEBAAAADiLs8HbBTl4rlrjzWQMAAACIKTQmAAAAAIxjKhcQYZbPp+ZZhJIBiH8tM3OUsdknOxg0XQpgVFiWwg5mizh5rVjCiAkQaZZHfanufEEBkFh60yzJ4q0CAGcwYgIAAAAcRMi2FHJwu2AnrxVL+BgEAAAAgHGMmAAAAAAHwXbBznDnswYAAAAQU2hMAAAAABjHVC4AAADgIMKyFHZwQTrbBQMAAACAIYyYAAAAAAdhOxywaDNiAgAAAABm0JgAAAAAMI6pXAAAAMBBhG2HF7+T/A4gIuywkjpt01UAwLgld9iSHTZdBgCXYMQEiDA7GFT2203ac2yu6VIAYFyy3mlSKBg0XQZgHMnvznDnswYAAAAQUxgxAQAAAA6CNSbOYMQEAAAAgHE0JgAAAACMYyoXAAAAcBBhh5PfnbxWLGHEBAAAAIBxjJgAAAAAB8Hid2cwYgJEQ02dktsJWQQQv5LbbWlXrekyALgIjQkQBaGGRvm6aUwAxC9ft61QU5PpMgC4CFO5AAAAgINgKpczGDEBAAAAYBwjJgAAAMBBMGLiDEZMgCjx9LHGBED88vTyGgbAWTQmQJSk/X2r6RIAYMzS/v6h6RKAmDEwYuLk4UY0JkC0hEOmKwCAsbMZMQHgLBoTAAAAAMax+B2IEru7R/5WWz2Z7hyOBRC//C227O4e02UAMcOWFJZz/567dbySERMgSsIdHUrb0W26DAAYtfQd3Qp3dJguA4DLMGICAAAAHATbBTsjbkZM1qxZo6OOOkoZGRkqLCzU6aefrs2bN5suCwAAAEAExE1jsn79el100UX6+9//rmeeeUbBYFArV65UB0PNiGFJH+ySt9d0FQAwct5eybdll+kyALhQ3Ezleuqpp4Z8/atf/UqFhYV69dVXddxxxxmqCji4UG2drNBU02UAwIhZof7XLgD/wlQuZ8RNY7KvlpYWSVJubu4Bz+np6VFPz792FWltbY16XQAAAABGL26mcu3Ntm2tWrVKS5cu1axZsw543po1a5SVlTV4lJeXO1glIMm2lbm1y3QVADBimVu7CFcE9kHyuzPisjG5+OKL9eabb+p3v/vdQc9bvXq1WlpaBo/q6mqHKgT+JXlXs+kSAGDEeM0CYErcTeX6xje+occff1zPP/+8ysrKDnqu3++X3+93qDIAAAAkItaYOCNuRkxs29bFF1+sRx99VM8++6wqKipMlwSMiN3UouQ2pkUAiH3+Vlt2U4vpMgC4VNyMmFx00UX67W9/qz/96U/KyMhQTU2NJCkrK0spKSmGqwMOLNTUJH9rSL0ZcfPnBsClkltDCjU1mS4DgEvFzTule+65R5K0fPnyIbf/6le/0jnnnON8QcAoWEFGTADEPg+vVcCwbNuS7eD0KievFUvipjGx2SEEcSzlpX+qrXym7LiZPAnAbaywFPj7PxUyXQgA14qbxgSIa8UFkjs//AAQLyz1v1aR+QXsJyxLYQf/IXfyWrGEz2+BKPKkpqr2wmP03upstZe580UGQHxoL7P03jU5qr3wGHlSU02XA8CFGDEBosA3qVwNSyeo+bMdykyrU5Flq7YtT2k7+SwAQGzqzQ2pqLhZ4U9a2rp8qnIeS1PuizsVrCIDDIAzaEyACLL8fnkmTtC7l+eraGK9svf6np1ky/b0z+MGgFhie/pfoyTJY9nKTu+S/aUuvbusRDN+nKTw9p2ye3oMVwmYQ46JM2hMgAixFs5S9cmZSltapyKrcb/vF01qVMeHhUpuZSMHALGlL91S0cThX7fqb/eq44VKlT/TKnvj2waqA+AWNCbAOHnz89S1cIp2ndujnIzag57blyEls64UQIzpyzjw9zyWrYxltdo6L1WlDyxUysaPFGrYv4kBEhnbBTuDxgQYK49XHZ9bqN3LLBUcXq+cEdwleFiXtDMQ9dIAYDSCh3Ud8pycjE51fbNT2/95uEo22Er740YpzObCACKHxgQYA++0KdpzQpH0qQYVeEe+aCTZ36fezBSmcwGIGb2ZlpL9fSM+v+DwenVN9agrf5GKnt2j0AcfRbE6IDawxsQZNCbAKHhSU7XzgnnqWNClgty6Ud8/M7VbjbkZTOcCEDN6cm3lpnaP6j5J3rD02TptXpqltE3HaMK9ryvc2RmlCgG4BXuXAiMUWr5AH62eq9STalWQ2zb2B+KvDkAsGcdrUkFem1JPqtVHq+cqfPz8yNUEYFTWrFmjo446ShkZGSosLNTpp5+uzZs3H/J+69evV2VlpQKBgKZMmaJ7773XgWoPjLdIwCH4SorV/vnFqrmkRzmVox8l2Zd/eovCPncO0QKILWGfJf/0lnE/Tk5lnXZ/s1cd/75YvuKiCFQGxJaBxe9OHqOxfv16XXTRRfr73/+uZ555RsFgUCtXrlRHR8cB77N161addtppWrZsmTZt2qRrr71Wl1xyidauXTveH9eYMZULOADL51PjWUepbklIRRMblB6hx03yhhTyS55ghB4QAMYo7JeSfZF5MUoP9Cj41R69e9IkFf5tinJ++4rsIC90gBOeeuqpIV//6le/UmFhoV599VUdd9xxw97n3nvv1cSJE3X77bdLkmbMmKGNGzfqtttu0xlnnBHtkodFYwIMwzPrCO08JVeBE/pT2yMp2RfSnulB5b7mjejjAsBotU4PqmgUG3iMRNHERoXLLe3KX6QJTzcq/Pb7EX18wATb4cXvAyMmra1DF6X6/X75/f5D3r+lpX8kNDc394DnvPTSS1q5cuWQ20455RTdf//96uvrU1JS0mjLHjemcgF78WZmKrRigT5YnaLUE2vliXBTMiCntEU9OUznAmBOT66lnNLxT+MajseylXpSrT5YnaLQigXyZmZG5TpAoisvL1dWVtbgsWbNmkPex7ZtrVq1SkuXLtWsWbMOeF5NTY2KioZOvSwqKlIwGFR9ff24ax8LRkwASbIsebMytfWSmco6ulb5Ub5csi+k7uQoXwQADiKc1P9aFE35OW1qv1Jq+fssVdzxjkItrZLNdunASFVXVytzr8Z+JKMlF198sd5880298MILhzzXsoZ+SGp//Pe57+1OoTEBJHV/6ig1frVdGcnjX9w+UsGZ7dKeNMeuBwB7C85sd+xaGYvrVP2rCcq9f7oC//OyY9cFIsWWsz31wKUyMzOHNCaH8o1vfEOPP/64nn/+eZWVlR303OLiYtXU1Ay5rba2Vj6fT3l5eaMtOSKYygVX85VN0Ic/Olr153Qozd8btalbw17bF1bIz3QuAM4L+S0lJTmX2u6xbKX5e1V/boc+vO1o+comOHZtwA1s29bFF1+sRx99VM8++6wqKioOeZ8lS5bomWeeGXLb008/rYULFxpZXyLRmMCtLEu+8jK9+60Jyp9Rr4yUHsdLyEztVvvkyC46BYCRaKsIG3ndy0jpUf6R9Xr3WxPkKy+TDE0XAUYrLMvxYzQuuugiPfTQQ/rtb3+rjIwM1dTUqKamRl1dXYPnrF69Wmefffbg1xdccIGqqqq0atUqvffee3rggQd0//3364orrojYz220aEzgOpbPp5pLluijH+eoaGKj0VoyDmtWKMA/zACcE0yxlDm12WgNRRMb9dGPc1RzyRJZPmaVA+N1zz33qKWlRcuXL1dJScng8cgjjwyes3v3bm3fvn3w64qKCj3xxBNat26d5s2bp+9973u64447jG0VLLHGBC5jL5mrD89IUc4R9UrxmB+tSPKF1OWXvN2mKwHgFuFkyR/lRe8jkZXWpdDJPdpSvlBT1nbJeukN0yUBBzSW0MPxXm905x96KvqDDz64323HH3+8XnvttVFdK5oYMYFrWEfNVtWltvKPrJc3BpoSqX/edfuMXtNlAHCR9iN7HF1PdzBeT1j5R9ar6lJb1lGzTZcDwDAaEyQ8b36ett20RNuulHIyOk2Xs5+c/DZ1FTKdC0D0dRVays1vM13GfnIyOrXtSmnbTUvkzTezGxAA82hMkLg8XnnzcvXBFYcrZ36dstO7Dn0fA5J9IYX8sfHpJYDEFvLbSopw0nukZKd3KWd+nT644nB583JZGI+YEv44+d3Jw41oTJCwWs88SjvuL1LeHOeyScbKd2SrbP4aAUSR7el/rYl1eXPqtOP+IrWdudh0KQAcxuJ3JBzfhFI1Hj9RHf/RotTkPtPljEiqv0/NFVLmh6YrAZCo2qZI2f44eU1M7lP7F1pkW0cr9/ntCu7cZbokuJxtOxyw6NKJFHxGi4TinTZF736vVPaX6uOmKZH6F4CqvIutgwFERShgSWVdMbPxx0ikJvfJ/nK93r2xVN5pU0yXA8ABNCZICJ7UVPWtXKj3rs1RUXGz6XLGJC+7XV2FLv2IBEBUdRXaystuN13GmBSVNOu9a3PUt3KhPIGA6XIARBFTuRD3PIGAdlw0T2kralVkuphxClV0S9v5hxdAZIWmxObmHyNVVNSizkulujkLVHbXawp3E/4EZ8V6jkmioDFBXAsvnaftJ6QqY3HsL3AfCX+gV73ZKUpuZuQEQGT0Zlvyx8nakkNJWVGnbakLVPZspzwvvG66HAARRmOCuNV3UqVqLuhRVmqt6VIiJiOlR7UTwkpusSR6EwDjZUkdE8IqTOkxXUlEeCxbWUfXauecgIoDlUr6f6+aLgkuwYiJM1hjgrgUWrFAu/9vrzJTE284P7uiSSG/O1+QAERWyG8pZ0qj6TIiLjO1W7v/b69CKxaYLgVABNGYIK74SorVctbR2nNJt7LS4nvO9IEk+0JqOTJougwACaDlyGDMBiqOV1Zal/Zc0q2Ws46WrzjeVxgCkJjKhTjiLSjQ+1dPVsHh9UozXUyUZRS3qTc7h7UmAMasN9tSRnGb6TKiKs3fK51Vr/ePqtD0m8IK1SXGekPEnrBtyXJwehXJ70Cssqz+puTbU1RweL3pahyRmtynjkkh02UAiGMdk0Jxlec0HgWH1+v9b02Vt6BAstz5hg5IBDQmiG0erxq+drQ+vKtEhYc1mK7GUakl7erL4B9YAKPXl2EprTSxR0v2VTitXh/eVaKG846mOUHEDSS/O3m4EY0JYpbl86np7EWyP9OgnIxO0+U4Lj3Qo55F7SyEBzAqIb+lnkXt/dOcXCYno1PhzzSq6eyjZfmYrQ7EGxoTxKz6rxwlfb4+YRdujkRWepc6S1z6sQmAMekstV35Yc6AZF9I+o96NZx9lOlSkED6RzEsBw/Tz9gMPk5AzPEeVqHaFcUKfapJPsulf5kf81i2wpO6Fd6VIk+vu38WAA4tnGwpPMm9TckAj2Wr57NNavAuUeFzNQpt2Wq6JAAjwIgJYopn7gy9/50c+T5XJ38SW+ZKUn5OmzqLaEoAHFpnsa387HbTZcQEf1JQvs/V6f3v5Mgz5wjT5QAYARoTxAzPnCP0wdV+Fea3mi4l5vhnN6s7j7UmAA6sO8+Sf1az6TJiTmF+qz64JkBzgnFxdhqXsynzsYTGBDHBM3eG/nlVCp/0HUBqcp86J/fJ5i8WwDBsj9Q5uc812wOPVn52u/55VQrNCRDjeJsD4zxzZ+ifVwZUkOuurS1Hq6i8SX2Z7vwEBcDB9WZZKipvMl1GTCvIbaM5wZjZBg43ojGBUZ65M/TB1X6akhHqmtepYCrNCYB/CaZa6pnLgveRKMhtY1oXEMNoTGCEJzVVu648Rv+8IsD0rVHIz25XxwS3fo4CYDgdE2zl8To6YvnZ7frnlSnadcUx8qSmmi4HwF5oTOA4T2qqtl4zV2kralWQx0jJaGVOb1Q4iVETAP3bA2dObzRdRtwpyGtT2gm12nrNXHkCAdPlIA6w+N0ZNCZwlDczU9uunKfMynrTpcStZF9IzbODNCeAy4WTLDXPCvYHCmJMMivrte2qBfJmZpouBYBoTOAgy+/X1lWzlLW4Vh6XByeOV9HERvXkmq4CgEk9uf2vBRg7j2Ur6+habb1sliy/33Q5iGWsfncEjQkc4cnI0LbrFijjqDrTpSQMa16LerMZNQHcqDfbkjWvxXQZCSNjUZ22XVspT0aG6VIAV6MxQdR5MjK07bLZyl5Yx0hJBGWk9KhjYkiiNwHcxZI6JoaUkdJjupKE4bFsZR9Vq22XzaY5wfCcXl/CGhMg8iy/X1uvnKWso2tNl5KQCqc0qHWK6SoAOKl1av/fPiIv6+habb2SaV2AKTQmiBpvdpaqVley0D3ayrsUCrjzkxXAbUIBS1Y5mSXRlFlZr6rVlSyIBwygMUFUeFJTtfWbM5W1iIXu0ZaX3a7Whd0KJ9OcAIksnGypdWG3crM6TJeS0DyWraxF/QviyTnBANt2/nAjGhNE3EBOScYiFro7pTC/VS3T2TIUSGQtR4RUmN/q6DVn5+3W7Lzdjl4zVmQsquvPOaE5ARxDY4KI8mZnDeaUMFLirIzyVnUVMWoCJKLOYksZZc42JYsKq/STCf+rn0z4Xy0qrHL02rHAY9n9OSdXzmNaFwhYdAiNCSLG8vv10WUzySkxJCW5T77KJnXnu/PFDEhU3fmWkhY0KSW5z5HrWZatBQU7dHPxBqV7Akr3BHRz8QYtKNghy2Wv7R7LVtbiWm1dxYJ4wAk0JoiIgZySzIVM3zIpNblPnRODsvnLBhKC7ZE6JwaV6lBTIkmV+Tv0k9L+pmRAuiegn5RuUGX+DsfqiCUZR5FzAjiBty8YN3JKYktBeZOaZ4Zle01XAmA8bK/UPCusgvImx665qLBKN5Wsk99K2u97fitJN5Ws08KCasfqiRXknEAD2SJOHi5EY4JxIack9ngsW4VTG9Sd584XNSBRdOdZKpzS4NgHPgsKduiW4heV5Uk54DlZnhTdWtI/rcuNso6u1dYrZjOtC4gSGhOMGTklsS00u1196TQnQDzqy7AUmt3u2PUWFVbptpLnlepJPuS5qZ5k3VbyvCsXxEtS5sI6VV1DzonbsF2wM2hMMCaeQICckhiXk9GpnsU0J0C86Uu31LOoXTkZ0Q9StCxbCwuq9b3ikTUlA1I9yfpe8fNaWFDt3gXxl86SJxA49B0AjBiNCUbNk5qqrdfOJ6ckDuRkdKp9To/pMgCMQvucHkeaEkman79TPyp94aDTtw4ky5OiH5W+oPn5O6NQWezLWFynrdfOJ+fELWwDhwvRmGDUdlw0j4XucSQ7t11tFaarADASbRX9f7NOWFRYpVsPsNB9pPxWkm4tWefKaV0DOSc7LpxnuhQgYdCYYFQ8c2eoc06X6TIwCsm+kLJmN6h9kiRmdQGxyZLaJ0lZsxuU7AtF91L75JSMl9tzTjrndskz5wjTpQAJgcYEI+aZO0MfXO1XQV6b6VIwSl5PWJlzG9Q22XQlAIbTNlnKnNsgrycc9WsdVbB9v5yS8XJzzklBXps+uCZAc5LgSH53Bo0JRsQzd4b+eWVA+dnO7RKDyPJ6wkqf2djfnLjz9Q6IPVZ/U5I+s9GRpmRRYZW+V/z8uKZvHYibc07ys9v1z6tSaE6AcaIxwSF55hyhf14ZUEEuIyXxLtkXUsbsBoWS6UyAWBBKtpThwPQtaWQ5JePl5pyTgtw2mpNEx8L3qKMxwUF55s7QB9fQlCSSJG9YLfN6FaY5AYwKJ1tqmderJK8zIyUjzSkZLzfnnBTkMq0LGA8aExyQ5fNp22dzmL6VgIpKmtU8v1dhH80JYELYZ6l5fq+KSpqjep2x5pSMl5tzTvKz27Xt9FxZPp/pUoC4Q2OCA6o/5yilLyLVPVEVlTSreWGvwkk0J4CTwkmWmo/qiXpTIo0vp2S83Jxzkr6oXvXnHGW6DEQQi9+dQWOC/Vg+nxrOW6LQp5scWYwJc4qKPx45YVoX4IhwsqXmBb0qKmqJ+rUikVMyXm7NOfF6wgp9ukmNX13CyAkwCjQmGMrjVeOXjpLn3+rlTwqargYOKCptVvOCXtle05UAiS3s+7gpcWD6ViRzSsbLrTkn/qSgrDPq1filoyQPL7Bxj+R3R9CYYIjQcXMV/LdGUt1dpqi4WU1H9TFyAkRJONlS88JeFRU3R/1alfk7Ip5TMl5uzTnxWLaC/9ao8LI5pksB4gKNCQZ5Cwq09fRkR7atROwpKm5W8zzWnACRFk76eKG7A03JosIq3WR4+taBuDXnJNkX0kef88ubn2e6FIyLZeBwHxoTSOpvSt7/zhQVHM5idzcrKm1W88IedusCIiTss9S80JmF7gsKduiHJX8zstB9pNyac1JweL3e/85h8hYUmC4FiGk0JpCvpFibr5uqwqkNpktBDCgqalFzJQvigfEKJ1tqrnRuofttJdFJdI80t+acFB7WoM3XTZWvpNh0KUDMojGBGk6YzEgJhiDnBBgfp3NKbi7e4GhOyXi5Neek4PB6Na6YbLoMjAWL3x1BY+JyoRUL1PHvrabLQAwqKmlW81E96iylOQFGo7PUuZySyvwd+lHpCzG10H2k3Jpz0v75VoVWLDBdBhCTaExcrO+kSu28sE9p/l7TpSBGFRW1KGVBg9oq5NZ1eMDIWVJbhZSyoMGx6Vu3lKyPi+lbB+K3krSm5DlXTetK8/dq54V9Cp5YaboUjAYjJo6gMXEpy+fT1rOkrLQu06UgxiX7Qsqa3aD2iaYrAWJb+0Qpa3ZD1Hc2HMgpuaX4xbgcKdlXlifFdTknWWld+uhLInwR2AeNiQt5AgFVX7lI+QVtpktBnPB6wkqf8/HICYD9tFVImXMb5PWEo36tgZySeFpTcihuzDnJL2jTjisWyROI/+YSiBQaE5fxpKZqxzcWKG1pnSP/gCJxJHnDSp/ZqKZjetWXzrwuQJL60i01HdOr9JmNUX9NHVjoHqs5JePltpwTryes1GV12nHxApqTeGBbzh8uRGPiMj1Lj1TailqS3TEmyb6QCgtb1LO4neYErteXbqlncbsKC1scCaadn79Tt5ZsiOmckvFyW86Jx7KVdkKtepbONF0KEBNoTFzEO22Ktn6RhgTjl5PRqZ7F7eoqtGR7TVcDOMv2Sl2F/U1JTkanI9ccyClJpOlbB+LGnJOtZ/X/G43YZdvOH25EY+ISvgmlem91riM7xcAdcjI6lXlMrZpnhmXzSgKXsD1S88ywMo+pdaQpideckvFyW85JUVGL3ludK9+EUtOlAEbxdsIlGo+fqKLiZtNlIAHlVzSqaU6I7YSR+CypaU5I+RWNjl0ynnNKxsttOSdFxc1qPI7tD2MW2wU7gsYk0Xm8av3i0er4D0ZKEB0ey1bBpCa1Le9UZzHdCRJTZ7GltuWdKpjU5NgavUTIKRkvv5WkW0vWuWZaV8eZLWr94tGShzmycCcakwTnzclSx5ktSk3uM10KEpjHspWb1aHkBU396054ZUGCsD3960mSFzQpN6vDkaYk0XJKxivdE9AtxS+6IuckNblPHWe2yJuTZboUwAjePiQwb36ePrhyOk0JHJOS3KfAogY1L+lRKMDoCeJbKGCpeUmPAosalOLg62gi5pSM18CCeDfknKQm9+mDK6fLm59nuhTsje2CHUFjksA+vOxw5c2pM10GXCbZF1JhQas6ju5U61Sx9gTxx5JaD5M6l3SosKDVka2ApcTPKRmvVE/yYM5Joo+c5M2p04eXHm66DMBxNCYJyjpqtqxp7abLgIvlZbcrb3admmaH1ZtNd4L40JttqWl2WHmz6pSb1eHotefn79SPSl9I6JyS8XLTgnjr8HZZR802XQY+ZtnOH25EY5KA7CVztfUKS9npXaZLAVQ4pUHhxS3qKrIUTqJBQWwKJ1n9/40ublHhlAbHrz+QU8JIyaG5ZUF8dnqXtl5hyV4y13QpgGNoTBKM5fPpozNSHAv9AkYiI6VHmUtq1Tw7qHAyzQliSzjZUvOcPmUuqVVGSo+j13ZrTsl4pXsCurl4Q8IviM/J6NRH/5Yqy+czXQrgCP5LTySWpd0XLVLOEfWmKwGGVTSxUb2lXnVsylPazsR9M4H40VEmpc5rUJFD60j2NZBT4rfYfWu00j0B/aR0gy7XUm2sKzddTtTkzGhQzYWLVHTnS+6NA48FTmeLxPCv+o477hjxuZdccsmoHpvGJIH4yiaod2mbUjxh06UAB5TsC8me16imyalKeyegpFZbFv/JwkG2R+rLtNQxs1tZ2Z2OLW7f16LCKn2v+Hn5LdaUjJXfStJNJev0bes4vVw7yXQ5UeH1hNW+rE2+P05QsDrxdyVD7PvJT34yovMsy6IxcStfcZHeva5URWnOJRIDY+VPCqqwoFVa3qq6zfnK2mzRnMARtkdqmW6rYHqd0gzWMZBTkspC93HL8qToluIXdYXt1Wt1ZabLiYqstC69e12pjryhT8GaPabLcSent/CN4e2Ct27dGrXHZo1Jgmg9ZrKKJtKUIP7kTmtUz8mtap8o1p8gasLJltonSj0ntyp3mtnXykWFVeSURNhAzkkiL4gvmtio1iWTTZcBRBUjJgkgtHyBGs9qV4bpQoAx8HrC/QuOF9Spvjldnm0pyqhSTM+vRRyxpLZJUnhyp/KzzW6hblm2jirYzvStKEn1JOt7xc/rOnu5Xq0vkx3DnziPVeOX2uVvWiDvutdMl+I+rDE5oB07dujxxx/X9u3b1dvbO+R7P/7xj0f1WDQmcc7y+7XjBL+yU1pNlwKMW352u8JzO1Sflqf07R4ltcXRKzNiTl+GpfaJYeUf1iBPDOzcND9/p35Y8jeakigayDm5TMsSclpXRkqPdpyQqckv+WX3OLuDHDCc//3f/9VnPvMZVVRUaPPmzZo1a5a2bdsm27a1YMGCUT8eU7ni3O6vVyqzkl24kDg8lq3CafWylzaraS7hjBi93mxLTXPDspc2q3BafUw0JYsKq3Qrie6OSPSck8zKeu2+oNJ0GYAkafXq1br88sv19ttvKxAIaO3ataqurtbxxx+vz3/+86N+PBqTOOaZc4TaFnTHxD+6QKSl+XtVWNEg65gmNS4IKRSwJHoUHIglhQKWGheEZB3TpMKKBqX5ew99v2iXZdlaULBDNxdvULqHLYGdksg5Jx7LVltltzyzjjBdirvYBo448N577+krX/mKJMnn86mrq0vp6em68cYb9YMf/GDUj0djEsfevyRdhflM4UJiS03uU9HERnlOalDTkTYjKNhPb7alpiNteU5qUNHERqUm95kuaVBl/g79pJSmxISBnJPK/MTbYrcwv1Xvf5OVpTAvLS1NPR9PKywtLdWHH344+L36+tHP6KExiUOWz6fGc5cou8DsQk7AScm+kAqn1Su8uEWN80Pqy6BBcbu+jP4RkvDiFhVOqzeWR3IgiwqrdBPTt4wayDlJxGld2YVtajx3CanwTmHEZFhHH320XnzxRUnSJz/5SV1++eW66aab9NWvflVHH330qB+P/5rjkLesVDqjQX6CFOFCGSk9ypjUo74yj5qqcuTt8Chjq8hBcQnbI7VNkUKpYeVMalKRNzZ/8eSUxI5EzTnxJwUVOqNB3udKFdy23XQ5cKkf//jHam/v/6D8hhtuUHt7ux555BEddthhIw5i3BuNSZzxlRTr/UtLVeBhwTvcLckbVuGUBoXCHnUelqTgu5lKqbXk7YmTj5kwKiG/pa5CW74jW5Xt75M3hj+YWVRY9XFTQk5JrBjIOblKy7Sxrtx0ORHj9YT1/jdLdcStvQrurjFdDlxoypQpg/8/NTVVd99997gej6lccaZ56SQVHE5TAgwYyEHJqaxT+9FdalzSq94sS7bXdGUYL9sr9WZZalzSq/YlncqprFNGSk/MNiWWZWtRYZW+V/w8TUkMSvUk66aSdVpYUJ1QC+ILptereekk02UkvoHkdycPF2LEJI6Ej5+vli+2K910IUCMys9pkySFCy3V7ciWt82r9CoPoyhxJhTozx8JZYZUMKFZaXHyJpKcktiXqDknLV9sV2rtfHnWbzJdClwgNzdX//znP5Wfn6+cnBxZ1oGbqMbGxlE9No1JnPCkpmrbSQHlBNpMlwLEPI9lq6i8SZLUVuFX+7YM+es9Sm6VPH3x8SbXbcJJlnozpe6CsAKTWpWfEl/hcYsKq3Rz8Qb5LXbfinUDOSfXWsv0cm1ijDSkB3pUfWKmKl5JVbiz03Q5Ccmy+w8nrxerfvKTnygjo39XuNtvvz2ij01jEifsGRXKqawzXQYQdzJSepQxo/9Nbm1tluxurzI3++TpkTzBGH7ld4Gwz1LYL7VOD8pKCaqwoFXxtgGqZdman7+TnJI4M5BzcpXt1ab6CbITYNpM9sI62dMrpE3vmC4FCW4gtyQYDEqSTjnlFBUXF0fksVljEge806Zo88X8gweMV2Fhi4omNsp3Qr2CJzerbYrUWRL/b0jiTWeppbYpUvDkZvlOqFfRxEYVFsRnJhM5JfErEXNONn8jRd5pUw59IhABPp9PX//61wdzTCLymBF7JESHx6s9JxSpqIjREiBSkrxhJXl7lTanTr1Br1raUhVuSlbatv4V80ntNtsPR4jtkfrS+5u/jskheXJ6lZnRGXOZI2MxsNCdNSXxayDn5NvWcQkxrauouFl7TihS/odVUjj+/8ZiitPZInEyoL948WJt2rRJkyZF5u+HxiTGdXxuofSpBtNlAAkr2RfqXzSfI+njDxr3VOXK0+1R1j8taWBecZz8I2HcwGYyltRyuK1wIKyiSf2LH9PMVhZR5JQkjoTLOflUgzrrFir10X+YrgQucOGFF+ryyy/Xjh07VFlZqbS0oa/0c+bMGdXj0ZjEMG9+nnYvs1QQowFiQKIaeCPdMbl/y9eOnRny13llhaSUWjqU4XQV9m/R3FMQUtqE/k06Cvy9hquKDnJKEk8i5ZwkecPadZyl6etzFWoY3Y5IwGideeaZkqRLLrlk8DbLsmTbtizLUig0upG7Ea8x2bEjNuZg3n333aqoqFAgEFBlZaU2bNhguqSo6aqsILMEMCjN36s0f68KpzQoa3GtUhbXq3FJrxqP7lPjUUEF0ywFUyyFApbkhqUqVv9WvsEUS8E0S41HBft/Fkt6lbK4XlmLa1U4pWHw55ZoLMvWwoJqckoSVCLlnBQcXq+uhaw1cZvnn39en/70p1VaWirLsvTYY48d9Px169bJsqz9jvfff3/E19y6det+x0cffTT4v6M14hGTWbNm6c4779SXv/zlUV8kUh555BFdeumluvvuu3Xsscfq5z//uU499VS9++67mjhxorG6osE6arZ2fbVXOaYLATAoyRtWUVHL4Nfh0v5uJBS21LwlV1aw/+uMKkue3vh+YzMgnGypbVL/c7F9trIPa5DX0/91UZy/eRut+fk79aPSF1hTksASKedk11d7VdEwS/bGt02XkhAsObxd8Bju09HRoblz5+rcc8/VGWecMeL7bd68WZmZmYNfFxQUjPi+kVpbMmDEjcnNN9+siy66SI899pjuu+8+5eXlRbSQkfjxj3+s8847T1/72tck9e+d/Ne//lX33HOP1qxZ43g90WL5/ao+KUM5GbWmSwFwEJ6P/5XyeG0VTP/X6GZrRUDh8L/+WenbkaZA3dAB6qR2GQ9+DPkt9e2T2NpdGFbShI7Brz0eW/mp3Q5XFnvIKXGPRMk5ycno1I6TClX2ll92BHdNQuw69dRTdeqpp476foWFhcrOzh7zdX/zm9/o3nvv1datW/XSSy9p0qRJuv3221VRUaHPfvazo3qsETcmF154oU499VSdd955mjlzpu677z595jOfGXXxY9Xb26tXX31V11xzzZDbV65cqb/97W/D3qenp2fIFmatrfGxHaVn4gSlLWUXLiBeZe77Rv6ILumIoTfVNWYo3J407P0z/umTN0K9QCggtR0eHPZ7nvQ+FeQODW2NtxyRaCOnxJ0SJeckZWm9PGsnKPTB6KfUIDbs+97V7/fL7/dH9Brz589Xd3e3jjzySH3rW9/SihUrRnzfe+65R9/5znd06aWX6qabbhpcU5Kdna3bb789eo2JJFVUVOjZZ5/VXXfdpTPOOEMzZsyQzzf0IV577bVRFTBS9fX1CoVCKioqGnJ7UVGRampqhr3PmjVr9N3vfjcq9UTTlq8WKdeiMQESWUFum5Q7/Pd6S70Ru45PUlECbM1rSmX+jo+nb9GUuM1AzsnlWhq3C+K9nrC2nFukimtpTMbNHthy0MHrSSovH/rf3vXXX68bbrghIpcoKSnRfffdp8rKSvX09Og3v/mNTjzxRK1bt07HHXfciB7jzjvv1C9+8QudfvrpuuWWWwZvX7hwoa644opR1zTqXbmqqqq0du1a5ebm6rOf/ex+jUm0WdbQ/ygGVv0PZ/Xq1Vq1atXg162trfv9gmNN96cWKenw+BjZARAdiZDxkQjIKcFAzsl1Wh63zYnv8DZ1f2qRAv/zsulSMAbV1dVD1n9EcrRk+vTpmj59+uDXS5YsUXV1tW677bYRNyZbt27V/Pnz97vd7/ero6NjmHsc3Ki6il/84he6/PLLddJJJ+ntt98e1eKY8crPz5fX691vdKS2tna/UZQB0RjuiiZPaqr2nN2l7BTmggKASeSUYECWJ0W3lmzQFTouLhfEZ6Z2a8/ZliqeTVW4s9N0OfHLUMBiZmbmkMYk2o4++mg99NBDIz6/oqJCr7/++n6L4J988kkdeeSRo77+iLcL/sQnPqGrr75ad911lx599FFHmxJJSk5OVmVlpZ555pkhtz/zzDM65phjHK0lWmrOmafMNBaZAoBJiwqrdFsJWwLjXwZyThYWVJsuZUwy07q15ytzTZeBOLBp0yaVlJSM+Pwrr7xSF110kR555BHZtq2XX35ZN910k6699lpdeeWVo77+iEdMQqGQ3nzzTZWVmfu0YNWqVfryl7+shQsXasmSJbrvvvu0fft2XXDBBcZqihTf5IlqObpbhS7bfhMAYoVl2arM3/FxTgkjJRhqIOfkOi3Xq/VlcbUg3mPZal7So5InJyq4bbvpchAl7e3t2rJly+DXW7du1euvv67c3FxNnDhRq1ev1s6dO/XrX/9aUv/utpMnT9bMmTPV29urhx56SGvXrtXatWtHfM1zzz1XwWBQV111lTo7O/Wf//mfmjBhgn7605/qC1/4wqifw4gbk31HKkw488wz1dDQoBtvvFG7d+/WrFmz9MQTT0R8D2UTaldMUGE+C94BwBRySnAo8ZxzUpjfqtoVE5T7KxqTMTE0lWs0Nm7cOGRHrYF11l/5ylf04IMPavfu3dq+/V+//97eXl1xxRXauXOnUlJSNHPmTP3lL3/RaaedNqrrnn/++Tr//PNVX1+vcDiswsLC0Rf/Mcu2bdd8RN/a2qqsrCwt12fls4bfptMEb1Gh3lszUUXFzaZLAQBXGsgpYUtgjER7uFvX1sRfzsmemmzNWL1doT2xlZMWtPu0Tn9SS0uLo+spRmLgveOkm2+SJ+Dc60O4u1tV114Xkz+TvZ1wwgl69NFH98tBaW1t1emnn65nn312VI834jUmiA5PWpo2XzOFpgQADLAsWwsKdtCUYFQGck4WFOyQFUdTsIuKm7X5minypKWZLiXuWLbzRzxYt26dent797u9u7tbGzZsGPXjObvXL/bTt2i6sg9rNF0GALgSOSUYq3jNOcma2qS+RdPlfS46uXNwhzfffHPw/7/77rtDds0NhUJ66qmnNGHChFE/Lo2JQZ7UVH10il95XnJLAMBp5JRgvOIx5yTZF1LVKX4d9g+2Dx6VOFhj4qR58+bJsixZlqUTTjhhv++npKTozjvvHPXj0pgYFDxquvLmsOAdAJxGTgkiJR5zTvLm1ClYOV2eDZtMl4I4tXXrVtm2rSlTpujll18eEiOSnJyswsJCeb3eUT8ujYkplqUtX0zS8NGQAIBoWVRY9XFTQk4JImMg5+QqLYubkZMtZyXp8BcsyT17ICGCBnbEDYfDEX1cGhNDuj95lDKK20yXAQCuQU4Joineck4yitvUc+pC+Z94xXQp8YGpXAf17rvvavv27fsthP/MZz4zqsehMTHAm5mpXcd5lZfcZ7oUAHANckoQbfGUc5Ka3Kedx/s07YVMhVpZ64qx+eijj/S5z31Ob731lizL0kAKiWX1N+ahUGhUj8d2wQYEZ09Rzsx602UAgGssKqzSrSXr5I+hDCskJr+VpFtL1mlRYZXpUg4pZ1a9grOnmC4jLrBd8PC++c1vqqKiQnv27FFqaqreeecdPf/881q4cKHWrVs36sejMXGax6sP/z0gT7z8FwcAcYycEpgQLzknHsvWh2cEJM/oFykDkvTSSy/pxhtvVEFBgTwejzwej5YuXao1a9bokksuGfXj0Zg4rHflAnJLAMAhlfk79JNSmhI4byDnpDJ/h+lSDip7WqN6T55vugzEqVAopPT0dElSfn6+du3aJal/cfzmzZtH/Xg0Jg6ykpJV9WmPkryR3cEAALC/RYVVuonpWzBoIOdkYUG16VIOKMkbVtWnvbKS2KXuoGzL+SMOzJo1azBscfHixbr11lv14osv6sYbb9SUKaOfJkhj4qCeE+YoYwILzAAg2gZySrLYfQuGDeScLCiI3ZGTjLJW9a6YY7oMxKFvfetbg1sGf//731dVVZWWLVumJ554Qj/96U9H/XjsyuUQb2amdq5IUi47cQFAVJFTglgzkHNyjXWsXq6dZLqc/aQk92nHCUma+lKGwm1EGQyL7YKHdcoppwz+/ylTpujdd99VY2OjcnJyBnfmGg0aE4cEZ1Uol5R3AIgackoQy1I9yfpe8fO6zo7NnJPcOXUKz6yQ/v6m6VIQB7761a+O6LwHHnhgVI9LY+KQD77sV5E6TJcBAAmLnBLEuljPOfnn2QEd/nfTVcQmp7fwjeHN3CRJDz74oCZNmqT58+cPZpdEAo2JA7o/tUjZpawtAYBoWVRYpZuLN8hvsfsWYttAzsm11rKYm9aVWdqm7k8tUuB/XjZdCmLcBRdcoIcfflgfffSRvvrVr+pLX/qScnNzx/24LH6PMk9amnac6JE/KWi6FABIOOSUIB7Fas5J/1oTjzxpaaZLQYy7++67tXv3bl199dX685//rPLycv3Hf/yH/vrXv45rBIXGJMr6Fk0ntwQAouSogu3klCAuxWrOSfa0RvUtmm66jNhjGzhinN/v1xe/+EU988wzevfddzVz5kxdeOGFmjRpktrb28f0mDQmUbZjeYDcEgCIgkWFVfpe8fPklCBuxWLOSZI3rB3LafQxOpZlybIs2bY9uH3wWNCYRJGvYpJ6JvSaLgMAEg45JUgUsZhz0jOhV76K2Fr/Ypz9rwXwThzxMGLS09Oj3/3udzr55JM1ffp0vfXWW7rrrru0ffv2wTT40aIxiaL6paUqKm02XQYAJJRFhVW6reR5ckqQMAZyThYVVpkuRZJUVNqshmNLTJeBGHbhhReqpKREP/jBD/SpT31KO3bs0O9//3uddtpp8njG3l6wK1eUeNLS1PCJbuWbLgQAEgQ5JUhksZZzUn9qj3L+mKZwB1EH2N+9996riRMnqqKiQuvXr9f69euHPe/RRx8d1ePSmERJ3X/OUX4OgYoAECnklCDRxVLOSX5Om+r+c47yfvGS0TpiBsnvQ5x99tljSnY/FBqTKPBNKFXrCZ0a/27OAACJnBK4RyzlnLSe0KmiJ0oV3LnLaB2IPQ8++GBUHpc1JlFgp6UoO7PTdBkAEPfIKYEbxUrOSXZmp+xU/u4ksV2wQ2hMomDLuYXyxFBgEgDEq8r8HeSUwJViIefEY9na8tUiY9eH+9CYRJh97Dz5prWZLgMA4t6iwirdVLKOnBK4VizknPimtck+dp6x68cKJ7cKHtwy2IVoTCLI8vlUfVKqMlO7TZcCAHFtQcEO/bDkb+SUwPVM55xkpnar+sRUWT6WJSP6aEwiyEpOljW71XQZABDXBnJKGCkB+pnOObHmtNKYwBE0JhHU+qk5CiT3mS4DAOKSZdlaWFCtm4s3EJ4I7GMg52RhQbXjC+IDyX1q/fRcR68Jd6IxiRBvQYF2Hysl+0KmSwGAuFSZv0M/Kn2Bhe7AAQzknMzP3+nodZN9Ie1easmbn+fodeE+NCYRYk8oUOG0etNlAEBcWlRYpVtK1jN9CzgEv5WkNSXPOT6tq3BavewJhY5eM6awXbAjaEwiZNeKbNMlAEDcGcgpuaX4RUZKgBHK8qQYyTnZtSLHsWvBnWhMIsA3ZbLaK7tMlwEAcWcgp4Q1JcDomMg5aa/skm/KZMeuB/ehMYmAhmOKVZBLdgkAjNTAQndySoCxczrnpCCvTQ1Lih25Vqwhx8QZNCbj5ElNVeMsy3QZABBX5ufv1K0lG8gpAcbJ6ZyTxlmWPKmpjlwL7kNjMk7hWVOVMbPBdBkAEDcGckqYvgVEhpM5JxmzGmTPnBr168QkFr5HHY3JOG37dLqSvGHTZQBAzCOnBIgep3JOkrxhbft0etQeH+5GYzIOvrIJ6i0gtwQARoKcEiC6nMo56SkMyVc2IarXiDlsF+wIGpNx6DmsSEUTG02XAQAxj5wSwBl+K0m3lqyL6rSuoomN6p3q4kwTRA2NyVhZlnYdy6d+AHAw5JQAzkv3BHRL8YtRzTnZdWyKZLH5DyKLxmSMvDOmKTyXLYIB4GDIKQHMGFgQH62ck9C8NnlnTIvKY8citgt2Bo3JGO1enq/sdEIVAWA45JQA5qV6kgdzTiI9cpKd3qWa4/Mi+pgAjckYeHNy1DqNnbgA4EDm5+/Uj0pfIKcEMCyaC+JbDrflzcmJ+OPGJBa/O4LGZAysnCzlHU52CQAMZyCnhJESIDZEa0F83uENsrIzI/qYcDcakzHYdVqpPG6d/AcAB0BOCRC70j0B3Vy8IaIL4j2WrV2fdNm2wYgqGpMxaJ3KNC4A2Bc5JUBsS/cE9JPSDRFdEO+W90QsfncGjckohZYvUMokduMCgL0tKqxioTsQB/xWkm6K4LSulEltCi1fEJHHAmhMRqknN0npgR7TZQBAzBjIKWGhOxAfsjwpgzkn45Ue6FFPrgs+kGDxuyNoTEbBk5qq3Wf0mi4DAGLGosIqckqAODSQcxKJkZPdZ/TKE2AKJ8aPxmQUPDnZCqTQmACAZdlaVFil7xWz+xYQr1I9yfpe8fPjzjkJpPTKk5MducJiESMmjqAxGYXtZ01mGhcAqD+n5Iclf2P6FhDnIpFzkh7o0fYvT4lgVXArGpMR8mRkqCfHpe0rAOxlUWGVbmWhO5AwIpFz0pNjy5OREcGq4EY0JiNkHzZRuXPrTJcBAMZYlq0FBTt0c/EGtgQGEsx4c05y59ZJU8ujUFlsYLtgZ9CYjFDjHJJNAbhbZf4O/aSUpgRIVOPNOWmYmxXhiuA2NCYjVLc0aLoEADCGnBLAHcaTc1J3bAK/V2LxuyNoTEbi6DnyZ3WbrgIAjCCnBHCXseac+LO7paPnRKkquAGNyQg0T0tTdnqX6TIAwHGLCqt0W8nz5JQALjOQc7KwoHrE98lO71LLYalRrAqJjsbkELzZWapdlsBDkwAwjL1zSmhKAHdK9STrppJ1o8o52bMsJG92Aq41YSqXI2hMDsXvV05xq+kqAMBR5JQAkEafc5JT0iol8WEGxobG5BDCE4vGlYYKAPGGnBIAextNzoll2QpPLnagKmexXbAzaEwOYevp6Uryhk2XAQBRR04JgAMZac5JkjesrZ9Nd7AyJBIak4PwlU1Qb17IdBkA4AhySgAczEhzTnrzQ/JNKHWoKiQSGpOD6D68WEUTG02XAQBRR04JgJEYSc5J0cRG9UxLsOlcLH53BI3JQdj8dAC4ADklAEZjJDkntsdysCIkCt56H4jHq61f4I8KQGIjpwTAWBwq5+SjL3okj9fhqqKHxe/OoDE5CG8q+SUAEpNl2VpYUE1OCYAxO1jOCe+hMBY0JgdgL54lv7/PdBkAEBXz83fqR6UvMH0LwLgcKOfEH+iVFs00VFUUsMbEETQmB1C3IE0ZKT2mywCAiCOnBEAkDZdzkpHSo9oFbBuM0aExGYa3qFDNcxgtAZBYyCkBEC3D5Zw0z+2Tt6jQcGWIJzQmw8lIU1F5k+kqACCiyCkBEE375pwUlDXLSks1XFWEMJXLETQmwwgWZJouAQAiipwSAE4YyDlZWFAtj2UrWMh7KowcjckwPjyTxaAAEgc5JQCclOVJ0a0l/dO6tnwhMUZMLAOHG9GYAEACI6cEgAkDOSe+kk7TpSCO0Jjswz5mrpIndJguAwDGhZwSAKalepL1+8X3qfHcJZLl1jEAjAaNyT66igLKSusyXQYAjAs5JQBiwZzkgP743R+q+ctHmy5lfFj87ggaEwBIMOSUAIglZb50PXjjj9Rw3hLTpSDG0ZjsxfL7VbOEHwmA+EROCYBYNSM5Vb/59o/UfHZ8TuuybOcPN+Jd+F4sn0/+w1pNlwEAY0JOCYBYNiM5VWu//0M1nhPn07oQNTQme/EU5A2mlQJAPCGnBEA8KPOl6/7rf6LGr8bZtC7WmDiCxmQv275YpjR/r+kyAGBUyCkBEE/mJAf039f/sH9aF7AXGhMAiGPklACIRxVJ6Xr4ez+Mv5ETRBWNyccsn09hZkAAiBPklACIdxVJ6br/Oz9R05cXmS5lZJjGFXU0JgNmT1fG4jrTVQDAiJBTAiARzEkO6K/futd0GYgRPtMFxAyP5GHhO4A4sKiwSjcXb5DfYvctAPEvHjbtcHoLX7e+JWXE5GM7T8wyXQIAHBQ5JQCAREZj8rH2w9mNC0BsI6cEAJDImMoFAHFgUWGVvlf8vPwWa0oAwHFOL0p36VQuGhNJ1lGz5c/sMV0GAAxrIKcklYXuAIAERmMiqWlGurLT2ZELQOxZVFj1cVPClsAAYAqL353BGhMAiEHklAAA3IbGBABiEDklABBDnAxXHON6lueff16f/vSnVVpaKsuy9Nhjjx3yPuvXr1dlZaUCgYCmTJmie+81mynj+sbEm5+nhlO6TZcBAIMWFVbp1pJ1cbG3PwAgNnR0dGju3Lm66667RnT+1q1bddppp2nZsmXatGmTrr32Wl1yySVau3ZtlCs9MNevMbF8PmVldpguAwBkWbbm5+8kpwQAMGqnnnqqTj311BGff++992rixIm6/fbbJUkzZszQxo0bddttt+mMM86IUpUH5/rGBABixVEF2/XDkr+R6A4AMcbU4vfW1tYht/v9fvn9/ohc46WXXtLKlSuH3HbKKafo/vvvV19fn5KSnB+1d/1Urp2fnyqvx6VbHwCIGf/KKWH6FgCgX3l5ubKysgaPNWvWROyxa2pqVFRUNOS2oqIiBYNB1dfXR+w6o+H6EZPOElsBt+7JBiAmkFMCADHOUMBidXW1MjMzB2+O1GjJAMuyhl7Wtoe93Smub0wAwCRySgAAB5KZmTmkMYmk4uJi1dTUDLmttrZWPp9PeXl5Ubnmobh+KhcAmEBOCQDApCVLluiZZ54ZctvTTz+thQsXGllfIrm8MfFNKldfftB0GQBciJwSAIgjcZBj0t7ertdff12vv/66pP7tgF9//XVt375dkrR69WqdffbZg+dfcMEFqqqq0qpVq/Tee+/pgQce0P33368rrrhi9BePEFdP5eqeWqiisibTZQBwmUWFVbq5eAO7bwEAImbjxo1asWLF4NerVq2SJH3lK1/Rgw8+qN27dw82KZJUUVGhJ554Qpdddpl+9rOfqbS0VHfccYexrYIllzcmAOAkckoAID6Z2i54NJYvXz64eH04Dz744H63HX/88XrttddGf7EooTEBAIdU5u/Qj0pfYKQEAIBhuLcx8XhV9ckk5ZuuA4Ar/CunhDUlABB3DG0X7DaubUwsjyWrpNt0GQBcYEHBjo8T3WlKAAA4EFfvygUA0baosEq3lZDoDgDAobh2xAQAosmybFXm79DNxRuUykJ3AIhrlm3LOsjC8mhcz41oTAAgCljoDgDA6Li2MWk+c6EyMxpNlwEgAZFTAgAJhsXvjnBtY9Kd61HAGzZdBoAEMpBTckvxi0zfAgBglFzbmABApP1r+lay6VIAAIg7NCYAME4DC91vKlnHlsAAkIDiIfk9EcTFdsHbtm3Teeedp4qKCqWkpGjq1Km6/vrr1dvba7o0AND8/J26tWSDsjw0JQAAjFVcjJi8//77CofD+vnPf67DDjtMb7/9ts4//3x1dHTotttuG/Xj+SaVqff4VjEDHMB4LSqs+nhNCdO3ACBhsfjdEXHRmHziE5/QJz7xicGvp0yZos2bN+uee+4ZU2Ni+3zKTCX1HcDYkVMCAEBkxUVjMpyWlhbl5uYe9Jyenh719PQMft3a2hrtsgC4BDklAOAerDFxRlysMdnXhx9+qDvvvFMXXHDBQc9bs2aNsrKyBo/y8nKHKgSQyBYVVumWkvXyW0mmSwEAIGEYbUxuuOEGWZZ10GPjxo1D7rNr1y594hOf0Oc//3l97WtfO+jjr169Wi0tLYNHdXV1NJ8OgARnWbYWFOzQLcUvKp3pWwAARJTRqVwXX3yxvvCFLxz0nMmTJw/+/127dmnFihVasmSJ7rvvvkM+vt/vl9/vH2+ZACCJnBIAcC0WvzvCaGOSn5+v/Pz8EZ27c+dOrVixQpWVlfrVr34lj2fsgz3VnylSllhvAmBkyCkBACD64mLx+65du7R8+XJNnDhRt912m+rq6ga/V1xcPOrH6yoJKSuSBQJIaPPzd348UkJTAgBuxOJ3Z8RFY/L0009ry5Yt2rJli8rKyoZ8z7Zd+psD4IiBnBKmbwEAEF1xsSvXOeecI9u2hz0AIBosy9bCguqPc0poSgAAiLa4GDEBAKeRUwIAGMTid0fExYgJADhpUWHVxwvdySkBAMApjJgAwF4GckpSPSx0BwD8i1sXpDuJxgQAPraosEo/LPkbC90BADDAlY2Jv6TDdAkAYohl2TqqYLu+V/w8WwIDAPZn2/2Hk9dzIVc2JpkpPZJIhAfQb37+zo9HSmhKAAAwhcXvAFxtUWGVbmWhOwAAxrlyxAQALMvW/Pydurl4g9I9bAkMADgwkt+dQWMCwJXIKQEAILbQmABwnUWFVSx0BwCMHAGLjqAxAeAq5JQAABCbWPwOwDUWFVbptpLnleohpwQAgFjDiAmAhLd3TgkjJQCA0bLC/YeT13MjGhMACY+cEgAAYh+NCYCEtqiwSjcXb2D3LQDA2LH43RE0JgASEjklAADEFxoTAAmJnBIAAOILjQmAhENOCQAgkkh+dwaNCYCEQk4JAADxicYEQMJYVFj1cVNCTgkAIIJsu/9w8nouRMAigLhnWbYWFlR/nFNCUwIAQDxixARA3Jufv/Pjhe5M3wIARB5rTJzBiAmAuLaosEq3lqyT30oyXQoAABgHGhMAcWt23m5ySgAASBBM5QIAAAAOhuR3RzBiAiBuvdVQomtrlqk93G26FAAAME40JgDi2su1k3TV7uXqsftMlwIASFADi9+dPNyIxgRA3NtUP0GX71qqlnCX6VIAAMAY0ZgAiHu2bWljXbmu271cneFe0+UAAIAxoDEBkDA21pXrit3H0ZwAACJrIPndycOFaEwAJJTX6sp0Tc2xTOsCACDO0JgASDgv107SdSyIBwBECIvfnUFjAiAhvVpfpst2sZUwAADxgsYEQEKybUuv1ZWRcwIAGD/bwOFCNCYAEho5JwAAxAcaEwAJj5wTAABiH40JgIRHzgkAYDxY/O4MGhMArkHOCQAAsYvGBICrkHMCABi1sO384UI0JgBch5wTAABiD40JAFci5wQAgNhCYwLAlcg5AQCMGDkmjqAxAeBq5JwAABAbXNmY1G7PMV0CgBhCzgkA4GAsObxdsOknbIgrGxMr6NZfN4DhDOScfLuGrYQBADDFlY0JAAzn5dpJ5JwAAPZn284fLkRjAgB7IecEAAAzaEwAYB/knAAA4DwaEwAYxkDOCSMnAABHF75/fLgRjQkADGMg5+TbNceRcwIAgAPc2ZjY7MoFYGTIOQEAELDoDFc2Jof9d4fpEgDEEXJOAACIPlc2Jp7mTtMlAIgjAzknLIgHACB6XNmYAMBYbKwr12W7lpFzAgAuY9m244cb0ZgAwCgM5JywIB4AgMiiMQGAUXq5dpKu2X0807oAwC3CBg4XojEBgDF4tb5Ml+9aysgJAAAR4srGxN69Ry0vF5ouA0AcG1gQf20Na04AINGxxsQZrmxMwp1d8jeYrgJAIni5dpKu2H0czQkAAOPkysYEACJpU/0EXbV7GTknAACMA40JAIwTOScAkOBIfncEjQkARMir9WW6bNcyFsQDADAGrm1MAo1h9YVc+/QBRIFtW3qtrkzX1tCcAEBCsW3nDxdy7Tvz7Ec2qrUt1XQZABLQy7WTdBXTugAAGBXXNiYAEE2b6ieQcwIAwCjQmABAFJBzAgCJw7KdP9zI1Y2JS3/nABw0kHPCtC4AAA7OtY2JHQyq5A9+02UAcIHX6sp05e5jyDkBgHjF4ndHuLYxkaTk5qDpEgC4xMu1k8g5AQDgIFzdmACAk8g5AYD4ZIWdP9yIxgQAHELOCQAAB+bqxiTwYa327MgxXQYAlyHnBAAQDXfffbcqKioUCARUWVmpDRs2HPDcdevWybKs/Y7333/fwYqHcnVjEqyqVlK9z3QZAFxoIOeEBfEAEAfiYPH7I488oksvvVTXXXedNm3apGXLlunUU0/V9u3bD3q/zZs3a/fu3YPHtGnTxvpTGjdXNyYAYMpAzsm3a44j5wQAMG4//vGPdd555+lrX/uaZsyYodtvv13l5eW65557Dnq/wsJCFRcXDx5er9ehivfn+sbErQE2AGLDQM4JzQkAxDDbwCGptbV1yNHT0zNseb29vXr11Ve1cuXKIbevXLlSf/vb3w761ObPn6+SkhKdeOKJeu6550b8I4kG1zcmU/+/BvWFXP9jAGDQa3Vlumr3MqZ1AQCGKC8vV1ZW1uCxZs2aYc+rr69XKBRSUVHRkNuLiopUU1Mz7H1KSkp03333ae3atXr00Uc1ffp0nXjiiXr++ecj/jxGyvULLKzGFklZpssA4HIb68p1nZbrR6UvyG8lmS4HABADqqurlZmZOfi133/wcHDLsoZ8bdv2frcNmD59uqZPnz749ZIlS1RdXa3bbrtNxx133DiqHjuGCgAgRpBzAgCxybJtxw9JyszMHHIcqDHJz8+X1+vdb3SktrZ2v1GUgzn66KP1wQcfjP0HNU6ub0zsYFDNLWmmywAAck4AAGOSnJysyspKPfPMM0Nuf+aZZ3TMMceM+HE2bdqkkpKSSJc3Yq6fyhWqb1D+04dLX2gzXQoASPo458T26ielG5jWBQCxYIxb+I7reqO0atUqffnLX9bChQu1ZMkS3Xfffdq+fbsuuOACSdLq1au1c+dO/frXv5Yk3X777Zo8ebJmzpyp3t5ePfTQQ1q7dq3Wrl0b0acyGq5vTAAgFm2qn6DLtVQ3laxTlifFdDkAgBh35plnqqGhQTfeeKN2796tWbNm6YknntCkSZMkSbt37x6SadLb26srrrhCO3fuVEpKimbOnKm//OUvOu2000w9BVm27WT7Z1Zra6uysrK0XJ+Vb69PIds/v1jdZzcpyRs2WB0A7G9RYZVuKX5RqZ5k06UAQFS0toWVc/hHamlpGbLQOxYMvHdcsWC1fN6AY9cNhrr13GtrYvJnEk2uX2MiSel/eFmNe9zzSwcQP8g5AQC4BY2J5OycQQAYJXJOAABuQGMyoI8fBYDYtbGuXNftXq4eu890KQDgOqa2C3Yb3o1/bNqve0yXAAAHRc4JACCR0Zh8zNMbNF0CABwUOScAYIitf20Z7Mhh+gmbQWMyICyFwvw4AMS+l2sn6SqmdQFIACE7rKWvnWG6DMQI3okPeGuz2l/ON10FAIzIpvoJunzXUhbEA4hr09d/VUXn7zJdBmIEjcnH7GBQHj58BBAnbNsaXBDPVsIA4k2P3afpG87W4RduVbit3XQ5h+boNC6HU+ZjCI3JXix3/jcAII5trCsn5wRA3Jn74ldV8aX3FWpuMV0KYgiNyV4mPbxDHT2kKwOIL+ScAIgXITusw547V1P+z3bZfXH0gUrYwOFCNCZ7Cdc1yLYt02UAwKiRcwIg1vXZIc1+6WxNu2ALIyUYFo3JXuxgUD1bMk2XAQBjQs4JgFh25PrzNPGsDxRuazNdCmIUjcle7J4eFb/k0rEzAHGPnBMAsajPDmnaunM07aIq2T3xGWhN8rszaEz2Ydm2wkznAhDHyDkBECtCdlhzX/qKpp77nkJNTabLQYyjMdlH2lNvqn5rrukyAGBcyDkBEAvO2HKqJp0bvyMlg9gu2BE0JvsId3fLCjJiAiC+DeScfLuGrYQBmLG2PVNvvjWZNSUYMRqTYeS+SWMCIDG8XDuJnBMAjvvv9izd9uHJynstQd5qMmLiiAT5ryWyCp6vMV0CAETMa3VluqbmWKZ1AXDEw205umvrCQqFPSpct9t0OYgjNCbDsEJh9fT5TJcBABHzcu0kck4ARN3a9kzdtXWFekNe9QW9rv3kH2NDYzKM4LbtCj/HAngAiYWcEwDR9HBbjn780UkKhvvfXtr/m6vgtu2Gq4oQpnI5gsZkOLYtDx8qAkgw5JwAiJb/bs/S3duWKxT+11tLKyjXvsHG2NCYHEDBax1q6/KbLgMAIo6cEwCRtLY9Uz/96ET1hryDt7V1+VX4WrvBqiIsbOBwIRqTA7D+8bZ6epJMlwEAUUHOCYBIeLgtRz/56KQhIyWS1NOdLL38jqGqEK9oTA4i1MkCeACJaSDn5Lrdy9lKGMCoheyw1rZn6u5tywfXlAz5Pu+hMAY0JgcSDqniYeZFAkhsG+vKyTkBMGprO/oXuu89fWtvU34XlsIhh6uKHsu2HT/ciMbkIJKbe9TSkWK6DACIKnJOAIzG3jklw2npSFFSCxtsYPRoTA7C3vi2wv9MN10GAEQdOScARmLvnJIDCW9Ol/1qgq0vYbtgR9CYAAAkkXMC4OD2zSkBIo3/sg6h4rF29YX4MQFIfOScADiQ4XJKhtMX8qjisTaHqnJQ2Hb+cCHecR+CZ1uNwnwyAMBFyDkBsLfhckoOJBjyylO1x4GqkIji7h13T0+P5s2bJ8uy9Prrr0f9eqH6enmeyIn6dQAglpBzAkA6cE7JgfieyFaovj7KVSFRxV1jctVVV6m0tNS5C9q2Ak0207kAuAo5J4C7HSqnZDh9IY8CTeHEXLjN4ndHxNW77SeffFJPP/20brvtNkevm/77f6hxT6aj1wSAWEDOCeBOh8opGU5jTZbS//ByFKtCooubWM49e/bo/PPP12OPPabU1NQR3aenp0c9PT2DX7e2to7t4rYt2dbY7gsAce61ujJdYx2r7xU/rywP2U5Aonu4LWdEC933YyuBP+l3ehQjUX+OBxcXIya2beucc87RBRdcoIULF474fmvWrFFWVtbgUV5ePuYaCl6Imx4OACKOnBPAHUaSU3IgBS/yXgnjY7QxueGGG2RZ1kGPjRs36s4771Rra6tWr149qsdfvXq1WlpaBo/q6uox15r75hhHWwAgQZBzAiS28eaU5L3REuGK4DZGW9uLL75YX/jCFw56zuTJk/X9739ff//73+X3+4d8b+HChTrrrLP0X//1X8Pe1+/373efsbK2bFfjG7OUO7cuIo8HAPFmMOfEWqabizco3RMwXRKACBlpTsmBNL5RoJwP345wVTHE6QXpCTsl7uCMNib5+fnKz88/5Hl33HGHvv/97w9+vWvXLp1yyil65JFHtHjx4miWOCjc1iZ/E+tMAODl2km6yvbqJ6Ub5LeSTJcDYJwGckrG2pRIkr/JUrgtAYMV4ai4mAw4ceLEIV+np6dLkqZOnaqysjLn6vjNR6o6Ok/pgZ5DnwwACWxT/QRdrqW6qWQdC+KBODbmhe57ae/2a9JvPlIwgnXFnLAtRxekk/yOQwm3tKq7K9l0GQBg3EDOybdr2EoYiFcDOSVjWei+t+6uZIWbmiNTFFwtLkZM9jV58mTZBubehTs7VfKHZPWd7/ilASAmvVw7SVfYXt1W8rxSPXxwA8SL/27PGvf0rQElf0hWuDvBN8Www/2Hk9dzIUZMRsnf1Kf27sgsqAeARPBaXZmuqTlWLeEu06UAGIGH23J019YTItKUtHf75W9iG3FEBo3JKHnXvaauqgzTZQBATCHnBIgP48kpGU5XVYa8616LyGMBNCZjkPkhPzYA2NdAzgkjJ0BsergtRz8ZR07JcDK3uOQ90cB2wU4eLuSS/5oiq/RP29XSwS40ALC3gZyTb9ccRwgjEGMGckoi2ZS0dKSo9PHtEXs8gMZkDILVOxR4julcADCcl2sn6SqmdQExYyCnJFLTtwYEnstQsHpHRB8zZoVt5w8XojEZo/SakHr64nJTMwCIuk31E3T5rqVM6wIMe7gtRz/dGpndt/bW0+dT+u5QRB8ToDEZo9THNqqtnelcADCcgZwTFsQD5kQqp2Q4rW0pSv3Txog/LtyNxmSs7LCS36UxAYCD2VhXrst2LSOEEXDYf7dn6ccfnRSVpkSSAu+muCtrg8XvjqAxGSvbVumLLO4EgEMZyDlhQTzgjEjmlBxI6Ytdrn3zjOihMRkH/5Y92rM913QZABDzXq6dpGt2H8+0LiDKIp1TMpw923OVvGVP1B4/JtlyeMTE9BM2g8ZkHII7dir/H16Fbct0KQAQ816tL9Plu5YycgJESTRySvYVCntU8Hevgjt3Re0acC8ak3Eq+J8tCob4MQLAoQwsiL+2hjUnQKRFI6dkOMGQR/n/88+oXiMmscbEEbyjHie7o0Pt7zCdCwBG6uXaSbpi93E0J0CERCunZDgd7+bI7mQbcEQHjck4hTs7VfZcnzp6kk2XAgBxY1P9BF21exk5J8A4RSunZDgdPckqe65P4c7OqF8L7kRjEgFJT29Ue12a6TIAIG6QcwKMXzRzSobTXpumpKddml0SDjt/uBCNSYRkvpdkugQAiDuv1pfpsl3LWBAPjFK0c0qGw3sdRBuNSYRMeKJWzSTBA8Co2Lal1+rKdG0NzQkwUk7klOyruT1FE55w2RbBe2PxuyNoTCIktHmLkjZmmC4DAOLSy7WTdBXTuoBDciKnZDhJr2Qo9M8PHb0m3IfGJIIyt4XVG3T2hQIAEsWm+gnknAAH4UROyXB6g15lbgs5ek24E41JBGU+/rqaG9NNlwEAcYmcE+DAnMopGU5zY7oyHn/d8evGFKZyOYLGJILC3d0q+yMjJgAwHgM5J0zrAvo5mVMynPK1Xtk9PUauDXehMYmwQH2vWjsDpssAgLj2Wl2Zrtx9DDkncD0nc0qG09oZkL+BpkRh2/nDhWhMIsx68XUFP2ARPACM18u1k8g5gas5nVMynOAHGbL+9oax68NdaEyi4LBf1SpsW6bLAIC4R84J3MpETsm+wralwx5w8RbBe7HtsOOHG9GYREF4a7U6NxSYLgMA4h45J3AjEzklw+ncUKDwth1Ga4C70JhEgd3Xq0CDO+cGAkA0kHMCt1jbnqk7DeSU7CtsWwo02LL72CEPzqExiZKC376p+ibWmgBApAzknLAgHolqIKfE9EiJJDU2p6vgt2+aLiN22A4vfGe7YERSuKND+U/6TZcBAAljIOfk2zXHkXOChBKyw0ZzSoaT/6Rf4Y4O02XAZWLjv/4Elffibu3ZlW26DABIKAM5JzQnSBSPdWQbzSnZ155d2cp7cbfpMmILAYuOoDGJouDWKuW8msQOXQAQYa/Vlemq3cuY1oW49/+15RnNKdlX2LaU82qSglurTJcCF4qNv4IEVvzfm9XexZQuAIi0jXXl5Jwgrq1tz9Q9W4+PmZESSWrv8qv4vzebLgMuRWMSZaGGRmU8ziJ4AIgGck4QrwZySmJlTcmAjD9lKNTQaLqM2BMOO3+4UGz9NSSovCe3aM+eLNNlAEDCIecE8ShWckr2tacmW3lPbTFdBlwstv4iElSork7qjp1hWgBINOScIF7ESk7JsLo9/e9ZsD8WvzuCxsQh037dY7oEAEho5Jwg1sVSTslwDv81o44wKzb/MhKQ9+2P1PhmgekyACBhkXOCWBWLOSX7anyjQJ53tpouI2bZ4bDjhxvF5l9HAgq3tWnCc33q6k0yXQoAJDRyThBrYi2nZF9dvUkqe65P4bY206XA5WhMHOR/9k217cw0XQYAJDxyThArHm7LiamckuG07chU8nNvmi4DoDFxkt3Xq0l/DqsvxI8dAKKNnBOYtrY9U3fF6kL3j/WFPJr055DsPkYYD4rF747gHbLDkp9+Tc1bck2XAQCuQM4JTInVnJJ9NX+Qq+RnNpkuA5BEY+K8cEhT/9CtsG2ZrgQAEh45JzAhVnNK9hW2LU39Q5cUDpkuJfaFbecPF4rtv5gE5XvrIzW9k2+6DABwDXJO4JSYzinZR9Pb+fK9zU5ciB00JgaEWls1YX1QnezQBQCOIecE0RbrOSV76+xN0oT1QYVaW02XAgyK/b+cBOX/yytKWZttugwAcI2BnJPrdi9nK2FEVDzklOwr9Q9Z8j/xiuky4odtS3bYwYOpXHBY/gu7tGd3tukyAMBVNtaVk3OCiIr1nJJ97dmdrbwXd5suA9gPjYlBwa1VytmYxEJ4AHAYOSeIlHjIKdlb2LaUszFJwa1VpkuJK3bYdvxwo/j4K0pgxQ+/r/Yuv+kyAMB1yDnBeMVDTsm+2rv8Kn74fdNlAMOiMTEs1NSkjD9lmC4DAFyJnBOM1cNtOXGRU7KvjD9lKNTUZLoMYFjx9deUoPKe/lB7arJNlwEArkPOCcbi4bYc3b1tedxM3xqwpyZbeU9/aLqM+OTowvePDxeKr7+oBBXaU6v8DWwdDACmkHOCkYqnnJJ95W9IUmhPrekygAOiMYkRhc/uUG19pukyAMC1yDnBocRTTsm+auszVfjsDtNlxC0Wvzsj/v6yElSwqlrTb+tUezcL4QHAhIGck2/XsJUw9re2PTOuckr21t7t1/RbOxWsqjZdCqLs7rvvVkVFhQKBgCorK7Vhw4aDnr9+/XpVVlYqEAhoypQpuvfeex2qdHjx99eVwOx3tyj0RpbpMgDA1V6unUTOCYb47/Ys/fijk+Jy+pYkhd7Ikv3+FtNlxLc4WGPyyCOP6NJLL9V1112nTZs2admyZTr11FO1ffv2Yc/funWrTjvtNC1btkybNm3Stddeq0suuURr164d709rzGhMYogdDKr8mQ61dgZMlwIArvZaXZmuqTmWaV3Qw205umvrCXE5fUuSWjsDKn+mQ3YwaLoURNmPf/xjnXfeefra176mGTNm6Pbbb1d5ebnuueeeYc+/9957NXHiRN1+++2aMWOGvva1r+mrX/2qbrvtNocr/xefsSsbYNv98/WC6pNidereixvVfeoipR3RYroSAHC1l7YW68q2Y/WDkpflteLzTSnG54mOFN2+9RiFwkFJ8fnGvvv9DIVefNl0GQcVVP+mEwPv02KR0+8dB34mra2tQ273+/3y+/ef9t/b26tXX31V11xzzZDbV65cqb/97W/DXuOll17SypUrh9x2yimn6P7771dfX5+SkpzfmMlVjUlbW5sk6QU9YbiSQ/jWn0QeKwCY95qk+00XAcPeMV3AuMXLe4q2tjZlZcXWlPbk5GQVFxfrhRrn3zump6ervLx8yG3XX3+9brjhhv3Ora+vVygUUlFR0ZDbi4qKVFNTM+zj19TUDHt+MBhUfX29SkpKxvcExsBVjUlpaamqq6uVkZEhy7JMl+OI1tZWlZeXq7q6WpmZ7PqV6Ph9uwe/a/fgd+0ebv1d27attrY2lZaWmi5lP4FAQFu3blVvr/Nrzmzb3u/96nCjJXvb9/zhHuNQ5w93u1Nc1Zh4PB6VlZWZLsOIzMxMV73IuR2/b/fgd+0e/K7dw42/61gbKdlbIBBQIBDb63/z8/Pl9Xr3Gx2pra3db1RkQHFx8bDn+3w+5eXlRa3Wg2HSLAAAABDHkpOTVVlZqWeeeWbI7c8884yOOeaYYe+zZMmS/c5/+umntXDhQiPrSyQaEwAAACDurVq1Sr/85S/1wAMP6L333tNll12m7du364ILLpAkrV69Wmefffbg+RdccIGqqqq0atUqvffee3rggQd0//3364orrjD1FNw1lcuN/H6/rr/++kPOSURi4PftHvyu3YPftXvwu8Z4nHnmmWpoaNCNN96o3bt3a9asWXriiSc0adIkSdLu3buHZJpUVFToiSee0GWXXaaf/exnKi0t1R133KEzzjjD1FOQZcfy3mwAAAAAXIGpXAAAAACMozEBAAAAYByNCQAAAADjaEwAAAAAGEdj4lI9PT2aN2+eLMvS66+/brocRNi2bdt03nnnqaKiQikpKZo6daquv/56I8m1iLy7775bFRUVCgQCqqys1IYNG0yXhChYs2aNjjrqKGVkZKiwsFCnn366Nm/ebLosRNmaNWtkWZYuvfRS06UAjqMxcamrrrpKpaWlpstAlLz//vsKh8P6+c9/rnfeeUc/+clPdO+99+raa681XRrG6ZFHHtGll16q6667Tps2bdKyZct06qmnDtkCEolh/fr1uuiii/T3v/9dzzzzjILBoFauXKmOjg7TpSFKXnnlFd13332aM2eO6VIAI9gu2IWefPJJrVq1SmvXrtXMmTO1adMmzZs3z3RZiLIf/vCHuueee/TRRx+ZLgXjsHjxYi1YsED33HPP4G0zZszQ6aefrjVr1hisDNFWV1enwsJCrV+/Xscdd5zpchBh7e3tWrBgge6++259//vf17x583T77bebLgtwFCMmLrNnzx6df/75+s1vfqPU1FTT5cBBLS0tys3NNV0GxqG3t1evvvqqVq5cOeT2lStX6m9/+5uhquCUlpYWSeLvOEFddNFF+uQnP6mTTjrJdCmAMSS/u4ht2zrnnHN0wQUXaOHChdq2bZvpkuCQDz/8UHfeead+9KMfmS4F41BfX69QKKSioqIhtxcVFammpsZQVXCCbdtatWqVli5dqlmzZpkuBxH28MMP67XXXtMrr7xiuhTAKEZMEsANN9wgy7IOemzcuFF33nmnWltbtXr1atMlY4xG+rve265du/SJT3xCn//85/W1r33NUOWIJMuyhnxt2/Z+tyGxXHzxxXrzzTf1u9/9znQpiLDq6mp985vf1EMPPaRAIGC6HMAo1pgkgPr6etXX1x/0nMmTJ+sLX/iC/vznPw95AxMKheT1enXWWWfpv/7rv6JdKsZppL/rgX/cdu3apRUrVmjx4sV68MEH5fHwWUQ86+3tVWpqqn7/+9/rc5/73ODt3/zmN/X6669r/fr1BqtDtHzjG9/QY489pueff14VFRWmy0GEPfbYY/rc5z4nr9c7eFsoFJJlWfJ4POrp6RnyPSCR0Zi4yPbt29Xa2jr49a5du3TKKafoD3/4gxYvXqyysjKD1SHSdu7cqRUrVqiyslIPPfQQ/7AliMWLF6uyslJ333334G1HHnmkPvvZz7L4PcHYtq1vfOMb+uMf/6h169Zp2rRppktCFLS1tamqqmrIbeeee66OOOIIXX311Uzdg6uwxsRFJk6cOOTr9PR0SdLUqVNpShLMrl27tHz5ck2cOFG33Xab6urqBr9XXFxssDKM16pVq/TlL39ZCxcu1JIlS3Tfffdp+/btuuCCC0yXhgi76KKL9Nvf/lZ/+tOflJGRMbiOKCsrSykpKYarQ6RkZGTs13ykpaUpLy+PpgSuQ2MCJKCnn35aW7Zs0ZYtW/ZrOhkkjW9nnnmmGhoadOONN2r37t2aNWuWnnjiCU2aNMl0aYiwgS2hly9fPuT2X/3qVzrnnHOcLwgAooypXAAAAACMYyUsAAAAAONoTAAAAAAYR2MCAAAAwDgaEwAAAADG0ZgAAAAAMI7GBAAAAIBxNCYAAAAAjKMxAQAAAGAcjQkAAAAA42hMACAOhEIhHXPMMTrjjDOG3N7S0qLy8nJ961vfMlQZAACRYdm2bZsuAgBwaB988IHmzZun++67T2eddZYk6eyzz9Ybb7yhV155RcnJyYYrBABg7GhMACCO3HHHHbrhhhv09ttv65VXXtHnP/95vfzyy5o3b57p0gAAGBcaEwCII7Zt64QTTpDX69Vbb72lb3zjG0zjAgAkBBoTAIgz77//vmbMmKHZs2frtddek8/nM10SAADjxuJ3AIgzDzzwgFJTU7V161bt2LHDdDkAAEQEIyYAEEdeeuklHXfccXryySd16623KhQK6f/9v/8ny7JMlwYAwLgwYgIAcaKrq0tf+cpX9H//7//VSSedpF/+8pd65ZVX9POf/9x0aQAAjBuNCQDEiWuuuUbhcFg/+MEPJEkTJ07Uj370I1155ZXatm2b2eIAABgnpnIBQBxYv369TjzxRK1bt05Lly4d8r1TTjlFwWCQKV0AgLhGYwIAAADAOKZyAQAAADCOxgQAAACAcTQmAAAAAIyjMQEAAABgHI0JAAAAAONoTAAAAAAYR2MCAAAAwDgaEwAAAADG0ZgAAAAAMI7GBAAAAIBxNCYAAAAAjPv/AR6o8SVju+JlAAAAAElFTkSuQmCC",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyYAAAK7CAYAAAAHuJsbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACNB0lEQVR4nOzdd3wc9Z3/8fdsV5dWzbIl23LvHbAhgMFgwIBxYmqoodyPAOGCQ4rJ5SBcDqdwHCG0kJAQIAECogZw4AgGEiA0Y5oxGBtcZVm9l92d3x/GCsJNkrXz3d15PR+PeYBWszPvlaXd+cy3WbZt2wIAAAAAgzymAwAAAAAAhQkAAAAA4yhMAAAAABhHYQIAAADAOAoTAAAAAMZRmAAAAAAwjsIEAAAAgHEUJgAAAACMozABAAAAYByFCQBXeuedd/SNb3xD5eXlCoVCyszM1IwZM/Tzn/9ctbW1cTvvNddcI8uyerXvX//6V82fP1+DBw9WMBjU4MGDNXfuXP30pz/tsZ9lWbrsssviERcAAMdQmABwnd/85jeaOXOmXn/9dX33u9/V8uXL9cgjj+iUU07R7bffrgsuuMB0RN1+++069thjlZ2drZtvvll//etf9bOf/Uzjx4/XQw89ZDoeAAADzmc6AAA46ZVXXtE3v/lNHX300Xr00UcVDAa7v3f00UfrO9/5jpYvX24w4Q7Lli3TYYcdtksRcvbZZysWixlKBQBA/NBiAsBVrrvuOlmWpTvuuKNHUbJTIBDQwoULu7+OxWL6+c9/rnHjxikYDKqoqEjnnHOONm3atMtzf/e732nq1KkKhUIKh8P66le/qtWrV/crZ01NjUpKSnb7PY9n92/d99xzj8aPH6/09HRNnTpVf/nLX3p8f+3atfrGN76h0aNHKz09XUOGDNGJJ56od999t8d+K1askGVZuvfee7VkyRINGjRIaWlpOvzww7Vy5cpdzvvGG29o4cKFCofDCoVCmj59uv785z/32Ke1tVVXXnlld9e5cDisWbNm6b777uvLjwUAkMIoTAC4RjQa1d/+9jfNnDlTZWVlvXrON7/5TX3/+9/X0Ucfrccff1z/9V//peXLl+vggw9WdXV1937Lli3TBRdcoIkTJ+rhhx/WL3/5S73zzjuaM2eOPv744z5nnTNnjioqKnTNNddo1apVikaje93/ySef1M0336xrr71WFRUV3YXRunXruvfZsmWL8vPz9dOf/lTLly/XLbfcIp/Pp4MOOkhr1qzZ5ZhXXXWV1q1bp9/+9rf67W9/qy1btmju3Lk9jvn888/rkEMOUX19vW6//XY99thjmjZtmk477TTddddd3fstWbJEt912my6//HItX75c99xzj0455RTV1NT0+WcDAEhRNgC4RGVlpS3JPv3003u1/+rVq21J9iWXXNLj8X/+85+2JPuqq66ybdu26+rq7LS0NHvBggU99tuwYYMdDAbtr3/9692PXX311XZv3nrXrl1rT5o0yZZkS7LT0tLsefPm2TfffLPd2dnZY19JdnFxsd3Y2NjjtXo8HnvZsmV7PEckErE7Ozvt0aNH21dccUX3488//7wtyZ4xY4Ydi8W6H//0009tv99vX3jhhd2PjRs3zp4+fbrd1dXV49gnnHCCXVJSYkejUdu2bXvSpEn2okWL9vm6AQDuRYsJAOzB888/L0k677zzejx+4IEHavz48Xruueck7Ri30tbWtst+ZWVlOvLII7v364uRI0dq1apVeuGFF/TjH/9YRx11lF5//XVddtllmjNnjtrb23vsf8QRRygrK6v76+LiYhUVFemzzz7rfiwSiei6667ThAkTFAgE5PP5FAgE9PHHH++2y9nXv/71HjOIDRs2TAcffHD3z2Xt2rX68MMPdeaZZ3Yff+e2YMECbd26tbsl5sADD9TTTz+tH/zgB1qxYoXa2tr6/DMBAKQ2ChMArlFQUKD09HStX7++V/vv7Ga0u7EegwcP7v5+b/frK4/Ho8MOO0z/+Z//qccff1xbtmzRaaedpjfffFO/+93veuybn5+/y/ODwWCPAmDJkiX60Y9+pEWLFumJJ57QP//5T73++uuaOnXqbguFQYMG7faxna9n27ZtkqQrr7xSfr+/x3bJJZdIUnd3t5tuuknf//739eijj+qII45QOBzWokWL+tXNDQCQmpiVC4BreL1ezZs3T08//bQ2bdqk0tLSve6/82J/69atu+y7ZcsWFRQU7LLfl31xv/2VkZGhpUuX6oEHHtB7773X5+ffe++9Ouecc3Tdddf1eLy6ulq5ubm77F9ZWbnbx3a+3p2va+nSpfra176223OOHTu2O/uPf/xj/fjHP9a2bdu6W09OPPFEffjhh31+LQCA1EOLCQBXWbp0qWzb1kUXXaTOzs5dvt/V1aUnnnhCknTkkUdK2nFB/0Wvv/66Vq9erXnz5knaMVA9LS1tl/02bdqkv/3tb9379cXuihxJ3V2uBg8e3OdjWpa1y0xkTz75pDZv3rzb/e+77z7Ztt399WeffaaXX35Zc+fOlbSj6Bg9erRWrVqlWbNm7Xb7YveynYqLi3XeeefpjDPO0Jo1a9Ta2trn1wIASD20mABwlTlz5ui2227TJZdcopkzZ+qb3/ymJk6cqK6uLq1cuVJ33HGHJk2apBNPPFFjx47Vv/3bv+lXv/qVPB6PjjvuOH366af60Y9+pLKyMl1xxRWSpNzcXP3oRz/SVVddpXPOOUdnnHGGampq9OMf/1ihUEhXX311n3NOnDhR8+bN03HHHaeRI0eqvb1d//znP/U///M/Ki4u7tcikCeccILuuusujRs3TlOmTNGbb76pX/ziF3tsOaqqqtJXv/pVXXTRRWpoaNDVV1+tUCikpUuXdu/z61//Wscdd5yOOeYYnXfeeRoyZIhqa2u1evVqvfXWW3rwwQclSQcddJBOOOEETZkyRXl5eVq9erXuuecezZkzR+np6X1+LQCAFGR69D0AmPD222/b5557rj106FA7EAjYGRkZ9vTp0+3//M//tKuqqrr3i0aj9s9+9jN7zJgxtt/vtwsKCuyzzjrL3rhx4y7H/O1vf2tPmTLFDgQCdk5Ojn3SSSfZ77//fo99ejsr169//Wv7a1/7mj1ixAg7PT3dDgQC9siRI+2LL754l3NLsi+99NJdjjFs2DD73HPP7f66rq7OvuCCC+yioiI7PT3d/spXvmK/9NJL9uGHH24ffvjh3fvtnJXrnnvusS+//HK7sLDQDgaD9qGHHmq/8cYbu5xn1apV9qmnnmoXFRXZfr/fHjRokH3kkUfat99+e/c+P/jBD+xZs2bZeXl5djAYtEeMGGFfccUVdnV19T5/FgAAd7Bs+wvt9AAA11uxYoWOOOIIPfjggzr55JNNxwEAuARjTAAAAAAYR2ECAAAAwDi6cgEAAAAwjhYTAAAAIInddtttmjJlirKzs5Wdna05c+bo6aef3utzXnjhBc2cOVOhUEgjRozQ7bff7lDaPaMwAQAAAJJYaWmpfvrTn+qNN97QG2+8oSOPPFInnXSS3n///d3uv379ei1YsECHHnqoVq5cqauuukqXX365KioqHE7eE125AAAAgBQTDof1i1/8YrfrXn3/+9/X448/3r1oryRdfPHFWrVqlV555RUnY/bgqgUWY7GYtmzZoqysLFmWZToOAACA69m2raamJg0ePFgeT+J15mlvb1dnZ6fj57Vte5fr1WAwqGAwuNfnRaNRPfjgg2ppadGcOXN2u88rr7yi+fPn93jsmGOO0Z133qmuri75/f79C99PripMtmzZorKyMtMxAAAA8CUbN25UaWmp6Rg9tLe3q3xYpiqroo6fOzMzU83NzT0eu/rqq3XNNdfsdv93331Xc+bMUXt7uzIzM/XII49owoQJu923srJSxcXFPR4rLi5WJBJRdXW1SkpKBuQ19JWrCpOsrCxJ0le0QD6ZqQQBuFfXEdPUHk7M9560mi75VrxtOgYAF4qoS3/XU93XaYmks7NTlVVRffbmcGVnOdea09gU07CZn2rjxo3Kzs7ufnxvrSVjx47V22+/rfr6elVUVOjcc8/VCy+8sMfi5MutMTtHd5jsVeSqwmTnD9onv3xWYl4cAEhels+n6OxJe/x+R1maomkOBuqDjvSQAocesMfve199T3Yk4mAiAK7x+WjnRO5mn5llKTPLuXwx7TjXzlm2eiMQCGjUqFGSpFmzZun111/XL3/5S/3617/eZd9BgwapsrKyx2NVVVXy+XzKz8/fz/T956rCBAAGghUMyjuoaJfH7YBf2yckaOWxD13plmr3kr1421BZnV27PB7dsk12l/N9rwEAe2fbtjo6Onb7vTlz5uiJJ57o8dgzzzyjWbNmGRtfIlGYAMA+WV9qOvcOKlLlMYnVDzreth1RvNvHB/1VilZW9XjM3sMHIQAgPq666iodd9xxKisrU1NTk+6//36tWLFCy5cvlyQtXbpUmzdv1t133y1pxwxcN998s5YsWaKLLrpIr7zyiu68807dd999Jl8GhQkA7I03L0/bThlnOkbC2lGg9SzSih/8UNG6OjOBACAOonZMUQcX2IjasT7tv23bNp199tnaunWrcnJyNGXKFC1fvlxHH320JGnr1q3asGFD9/7l5eV66qmndMUVV+iWW27R4MGDddNNN2nx4sUD+jr6ylXrmDQ2NionJ0dzdRJjTADswhMKqe7kaT0esz2WIiEzeZKVr12yYj0/WvIeelux9nZDiQAksojdpRV6TA0NDb0eT+GUndeOVWuGOT74vWjsZwn5M4knWkwAuFrs0OmKpnl3/L/XUld64g6+TBY7CrmeP8e2IybL8/ntRm9rRJ6/v+14LgDor5hsxeTcvXwnz5VIKEwAuIq3sFAK53R/XV8eokXEAU1l//q48bX7lb991L++Wdug6PbtBlIBABIJhQmA1GZZ8mRmdn/ZObFMdWP2vmou4isSkrYdXtj9dXh1lnxf6OYVa26W3NPLGEASiCmmvo362P/zuRGFCYCU5s0Pa9vXxpiOgb2oHR+Sxv9r/ZfiijWK1tQaTAQAMIHCBEDKaThztqIBxookq+0Lx3b/v7fTVs4fXzWYBgDgFAoTACnBV1aq5mmDJUmRNEu2c5OnYIDFvjBpou211H7igZKkzJWbFdm02VAqAG4WtW1FHexi6uS5EgmFCYCk5p04VrGAT235ITWXeE3HwQCzPer+d/W2DVKgMFeezoii768xnAwAMNAoTAAkHcvnkyd3x8xaNTPCiqQZDgRHNIwISCMC8rVJ+dvyJUmx+gbZkYjhZABSHdMFO4PCBEDysHaMG/GWDlbl/CGGw8CUSJq6JzQY9PTGf3XvcmnXBwBIFRQmAJJGy+ID1Z7L4BH8y7ZjyiSVKVQXU0bFP03HAQDsBwoTAAnNm5enhqN23B3vyPYwqB097Px9aM/1yD7lIElSzrMfKlrfYDAVgFQTk60oXbnijsIEQELyTBqnaE5IHSGv2vOoRrB3tlfdvyehmaPkbY/KV9/GIHkASCIUJgASh8cr35ASSVL9+BwKEvRL/ciAJCmtNqicxlJJUmTzVikWNRkLQBJj8LszKEwAmOfxyvJ65cnOVOVxZabTIEW0hT1q+/z3qfjBFsWaW2RHoxQoAJCgKEwAGNd59HQ1DfXve0egn6pOHidJyv6sS/5n3jCcBkCyYYFFZ1CYADDC8gdUf+oMSVI0aMm2DAdCStv5+9VU6pf3zNmSpNw/vyW7q9NgKgDAF9GBG4DjvAX56jhyiroyLHVlWIpxiwQOifnU/XvXecQUeQvyTUcCAHyOywEAjvENHyo74FckP1ONw+i6BbMahvvlayqVL5wrq7NLkU83mI4EIEHFPt+cPJ8bUZgAcIQnI0O1cwarM4s+W0gcNZPTJaUr2GgrZ3uNYi0tpiMBgGvRlQtA/Hm82n7GFIoSJKyObEvbz5giWfyOAthV9PMFFp3c3IgWEwBxY02fqNop2ZIlVmxHwrM9Ut25syVbyl/VoNjbH5iOBACuwqUCgLiwD5mmhnFZigalaMB0GqB3ogEpGpQaxmXLPniq6TgA4Cq0mAAYMJY/IGvCSElS/bCQOjPpFoPk1JFtyR6WptyW8ZIk+4NPmFoYcLGovWNz8nxuRGECYEBYwaC8g4pUeVCu6SjAgOjMslT1+e/zoPpiRbdsozgBgDiiKxeAAWGNLlflMaWmYwBxUXlMqTyjh5uOAcCQmIHNjShMAOy3zmNmafvsPNMxgLiqOjhfXfNnmY4BACmLrlwA+sUKBtV84jRJUmemh1m3kPJsj9Q82K/AyQdJkjIfW0nXLsAlYrIUlXPjJmMOniuRcCkBoM+8eXmKHjBebWGP2sIeZt2Ca0QD+tfv/UET5M2jpRAABgqFCYA+8ebmKDZyiGonpJmOAhhVOyFNsRGD5c3NMR0FAFICXbkA9J7Hq44Zo1Q/iiYSQJK2z8xWXtZIeV9cJcWipuMAiJOYvWNz8nxuRIsJgF5rOvUAihLgS+rGBNV0ygGmYwBA0qMwAbBvHq8az5jNgonAHnRmWWo6fbbk8ZqOAiAOop8PfndycyMKEwB75c3NUeSIaerKtJh5C9gD27OjOIkcMU3e7GzTcQAgKTHGBMBu+UqHyA4FFMvNUP1Ium8B+2JbUv3IgArry+RtaJXV3qnIps2mYwFA0qAwAbALTyikhtmlagvTRAL01faZ2ZKylVYTU1Z1jWLt7aYjAdhPTnevoisXAHyu+uvTKUqA/dSW71H116ebjgEASYMrDwDdvLk5qjt3jmK0pQIDIuaT6s6dw7gTIMnFbMvxzY0oTABIknzDh6r58LGKBk0nAVJLNCg1HzFOvmFlpqMAQELjvigA+YYPVduYIrUUM9UpEA8txV75RhcpzbIU+XSD6TgA+ogxJs6gMAFczpubo6apgyhKgDhrGBFQNG2QMuobFK1vMB0HABIOXbkAl6s+aQJFCeCQ5hKvahZOMB0DABIShQngUp70dNWeP4cxJYDDIiGp9vw58oRCpqMA6KWoPI5vbuTOVw24nK90iJoWTGb2LcCQmE9qOmGqfEMGm44CAAmDyxLAhexQgHVKAMPawh7lBAOmYwDoBdvhKXxtpgsG4Abe7GzFcjNMxwAgKZqXwRonAPA5ChPATTxedRwwWttnZJlOAkDS9pnZ6pg1WvIwAQUA0JULcJHG0w5QV6Y7m4eBRNUwMqBA0QHKuv9V01EA7AHrmDiDFhPABSyfT02nz1ZXhiWXdlsFEpZtSZ2ZlppOn03LCQBXo8UESHHe3Bx1Th+pjmwqEiBR2R6pM8tS9PCpCry5VtHGRtORAHxB1PYoajt3Pz9qO3aqhEKLCZDCvHl5io0sVd1oFisBEp1tSXWjg4qNLpM3L890HABwXNIWJsuWLZNlWfr2t79tOgqQkKxgUF0Th2n7TGb8AZLJ9pnZikwYJsvPVMJAoojJUkweBzd39nJIysLk9ddf1x133KEpU6aYjgIkrOYTp6l2QprpGAD6oWZimpoXTjcdAwAclXSFSXNzs84880z95je/UR5N3QAAAEBKSLrC5NJLL9Xxxx+vo446ap/7dnR0qLGxsccGuEHnMbPUmZl0f94AvqAzy6Ou+bNMxwCgf00X7OTmRkl15XL//ffrrbfe0rJly3q1/7Jly5STk9O9lZWVxTkhYJYVDMozaZyayvyK0j0dSGrRgNQ41C/vxLGMNwHgCklTmGzcuFH//u//rnvvvVehUKhXz1m6dKkaGhq6t40bN8Y5JWCO5Q/IO6hIVQfnycEZDQHEke2Rth0SlndQEcUJYNDO6YKd3NwoadYxefPNN1VVVaWZM2d2PxaNRvXiiy/q5ptvVkdHh7zengtTBYNBBYNMkwp3sCaMVOVBuaZjAIiDyuPKVPRqpux3PjQdBQDiJmkKk3nz5undd9/t8dg3vvENjRs3Tt///vd3KUoAAAAAJI+kKUyysrI0adKkHo9lZGQoPz9/l8cBt7EPmab6Yb3r4gggOdVPzFVW5lRZL68yHQVwnR3rmDg3IJ11TAAkJWv6RDUNDakz051vYoBbdGZZah6aJs+0CaajAEBcJE2Lye6sWLHCdATAuNqp2czABbhER7almqk5ynvbdBLAXWLyKOrg/fyYbMfOlUhoMQGSmYexVYAr8bcPIAVRmABJypORoZrzD6S1BHCZaFCqOf9AedLTTUcBgAGV1F25ALfyDR+qutmDWa8EcCnbIzUsnKK8VzYr8hlrdAHx5vTaIlGbrlwAkoQd8Ksjm8HugJt1ZFuyA37TMQBgwNBiAiQZb0G+IvmZpmMASACRgiz56vIVra4xHQVIaTF5FGPwe9zRYgIkEcsfUNvMctVMpm85AKlmcrraZ5TL8jPYDEDyo8UESCL1p85QVwZduAD8S8NwvwKnzFD2n141HQVIWVHbUtR27vPXyXMlElpMAAAAABhHYQIkA49XncfMUjTozjsoAPYuErLUecws1jcBkNToygUkAcvrVdNQv1zasgtgH2I+qWmoXwUeS3bMdBog9UQdXvk9yuB3AAnJ45Unm1m4AOybJyebVhMASYsWEyDB+YaUqPK4MtMxACQ425K2LR6rQU9tUGTTZtNxgJQSsz2KObjAYowFFgEkGnvOVFUdTVECoPeq5g+VDpxsOgYA9BmFCZDIPJZitGsC6IOYT7J9fLwDSD5c8gAJyjthjJoLWTQNQN+1FwaVOX60oqs/Nh0FSAkMfncGhQmQoBom5qk9j7ueAPqupdirmD+sjNWmkwBA71GYAInIsnZsANBPtqUd7yMuHUQLDKSYnF2N3a2zfnM7Fkg0lqXab8xWRw6FCYD+68j1qPa82dzkAJA0aDEBEpDtEYspAtgvtiVuPwIDJCaPYg7+QTl5rkTizlcNJChPRoZiX5kmUZQAGAgeKXbIVHnS000nAYB9ojABEoiVFlLt+BCtJQAGhG1JtRPSZKWnmY4CAPtEVy4gUXi8svx+0ykApCDL52MgPLAforZHUQdXfnfyXInEna8aSEDW1HGqPLHcdAwAKahy4Qh5po43HQMA9ooWEwAAAGAvYrIUc3AAqJPnSiS0mAAAAAAwjsIESAC+slJ1FjI4FUD8dBSkyVc6xHQMANgjunIBCaBpxmC1FHtNxwCQwhpGBBQNDVFo02bTUYCkw+B3Z7jzVQMAAABIKBQmgGENZ85WayGtJQDir2WQV41fn206BpB0ovI4vrmRO181kECiAUsubbEF4DDbs+M9BwASEZdDAAAAwF7EbMvxrS+WLVumAw44QFlZWSoqKtKiRYu0Zs2avT5nxYoVsixrl+3DDz/cnx/VfqEwAUyxLHkL8k2nAOAytqUd7z0WLSdAqnjhhRd06aWX6tVXX9Wzzz6rSCSi+fPnq6WlZZ/PXbNmjbZu3dq9jR492oHEu8esXIAhnsxMbfvaGNMxALhMzC9t+9oYFf3xHcV6cdECIPEtX768x9e///3vVVRUpDfffFOHHXbYXp9bVFSk3NzcOKbrPVpMAAAAgL2IOTzwPfb5JXpjY2OPraOjo1d5GxoaJEnhcHif+06fPl0lJSWaN2+enn/++f7/kAYAhQlggK98mBqPm2g6BgAXazx+snzDykzHALAXZWVlysnJ6d6WLVu2z+fYtq0lS5boK1/5iiZNmrTH/UpKSnTHHXeooqJCDz/8sMaOHat58+bpxRdfHMiX0Cd05QIMsEMBtefSvxuAOe25luxgwHQMICnEbI9iDk6hufNcGzduVHZ2dvfjwWBwn8+97LLL9M477+jvf//7XvcbO3asxo4d2/31nDlztHHjRl1//fX77P4VL7SYAAAAAAkoOzu7x7avwuRb3/qWHn/8cT3//PMqLS3t8/lmz56tjz/+uL9x9xstJoDTPF7Jwz0BAAnA593xnhSLmk4CYD/Ytq1vfetbeuSRR7RixQqVl5f36zgrV65USUnJAKfrPQoTwGFdR01XzTC/6RgAoKpD8pU9OEv+/3vTdBQgoUVlKSrnumD39VyXXnqp/vSnP+mxxx5TVlaWKisrJUk5OTlKS0uTJC1dulSbN2/W3XffLUm68cYbNXz4cE2cOFGdnZ269957VVFRoYqKioF9MX1AYQI4zLZ2bABgGu9FQGq47bbbJElz587t8fjvf/97nXfeeZKkrVu3asOGDd3f6+zs1JVXXqnNmzcrLS1NEydO1JNPPqkFCxY4FXsXFCYAAADAXpga/N5btm3vc5+77rqrx9ff+9739L3vfa9P54k3OroDDvKVD1Mk3Ws6BgB0i2R65Rs+1HQMAKDFBHBSzSEl6kqn7wSAxNFS5FXnIYOV8+mGfe8MuFRUfR/3sb/ncyNaTAAAAAAYR2ECAAAAwDi6cgEAAAB7keiD31OFO1814DSPV54p4xTzMb4EQOKJ+S15poyTLN6jAJhDiwngAMvvU9XsPNMxAGC3ogFp+0F5Kljtl93VaToOkHCitkdRB1sxnDxXInHnqwYAAACQUChMAAAAABhHVy4AAABgL2xZijm4jont4LkSCS0mQJx5c3MUmzXedAwA2CvbkmIHjJc3O9t0FAAuRYsJEGdWbo5qJqaZjgEA+1QzKV2DNmZLjY2mowAJhcHvznDnqwYAAACQUGgxAQAAAPYiZluK2c6N+3DyXImEFhMAAAAAxlGYAAAAADCOrlxAHHkL8hUpyjEdAwB6LTooT97WVkVrak1HARJGVB5FHbyf7+S5Eok7XzXgkK7xQ1U9LdN0DADote3TMxUZN9R0DAAuRIsJAAAAsBcMfncGLSYAAAAAjKMwAQAAAGAcXbkAAACAvYjJo5iD9/OdPFciceerBgAAAJBQaDEBAAA92JbkzqG3wO5FbUtRBwekO3muREKLCRAnLYsPUt3YkOkYANBndePS1Pq1g0zHAOAytJgAcRLzWbIp/QEkIdsjxbymUwCJg+mCncFlEwAAAADjKEwAAAAAGEdXLgAAAGAvbNujmIP9s22X9gV356sGAAAAkFBoMQEAAAD2IipLUQcn0XbyXImEFhMAAAAAxlGYAAAAADCOrlwAAADAXsRsZ9cWidmOnSqh0GICAAAAwDgKE2CgWZYazpqtzix3DlwDkBo6cjxqOHO2ZPFeBsQ+ny7Yyc2N3PmqgTiLhCy59D0FQIqwPVIkjaIEgHO4dAIAAABgHIPfAQAAgL2IyVLMwbVFnDxXIqHFBAAAAIBxtJgAAAAAexG1LUUdnC7YyXMlElpMAAAAABhHiwkAAACwF05P4ct0wQAAAABgCIUJAAAAAOPoygUAAADsRUyWYg4OSGe6YAAAAAAwhBYTAAAAYC9shxdYtGkxAQAAAAAzKEwAAAAAGEdXLgAAAGAvYrbDg99Z+R0AAAAAzKDFBAAAANgLVn53hjtfNQAAAICEQosJEAe+NluRNEsuveEBIAVYsR3vZQAYY+IULpuAgWbbyvnjqwo08YEOIHkFG2LK+eOrks17GQBnUJgAAAAAMI6uXAAAAMBexBxe+d3JcyUSWkwAAAAAGEeLCQAAALAXDH53Bi0mAAAAAIyjMAEAAABgHF25AAAAgL2gK5czaDEBAAAAYBwtJgAAAMBe0GLiDFpMAAAAABhHiwkAAACwF7SYOIMWEyBOcp56X7mfdJqOAQB9lvdxh7Kfes90DAAuQ2ECxEmsqUmezpjpGADQZ57OmGItLaZjAHAZunIBAAAAe2FLism57lW2Y2dKLLSYAAAAADCOFhMAAABgLxj87oykaTFZtmyZDjjgAGVlZamoqEiLFi3SmjVrTMcCAAAAMACSpjB54YUXdOmll+rVV1/Vs88+q0gkovnz56uFwXkAAABA0kuarlzLly/v8fXvf/97FRUV6c0339Rhhx1mKBWwd/7KBmVl+9Q0JGn+1AC4XNamiHzbGhQ1HQRIIHTlckbSXi01NDRIksLh8B736ejoUEdHR/fXjY2Ncc8FfFH043XK6IqoacgQ01EAoFcy3t2qyMZNpmMAcKGk6cr1RbZta8mSJfrKV76iSZMm7XG/ZcuWKScnp3srKytzMCUAAABSwc4WEyc3N0rKwuSyyy7TO++8o/vuu2+v+y1dulQNDQ3d28aNGx1KCAAAAKAvkq4r17e+9S09/vjjevHFF1VaWrrXfYPBoILBoEPJAAAAkIoYY+KMpClMbNvWt771LT3yyCNasWKFysvLTUcCAAAAMECSpjC59NJL9ac//UmPPfaYsrKyVFlZKUnKyclRWlqa4XTAXrR3KK0mprb8pOw5CcBF0mpisjs7TccA4FJJc6V02223qaGhQXPnzlVJSUn39sADD5iOBuxVpHKbMv/ytukYALBXli1lPr5S0W1VpqMACce2Lcc3N0qaFhPbtk1HAAAAABAnSVOYAAAAACbEZCkmBwe/O3iuREJhAsRRx3EHqHqqX1ZMCtTT6gcgcdmWtGnJLMmSCld2KvDXN0xHAuAyFCZAnNgHT9WWQ30KT6tSV9Sj1jcLlLbNlhU1nQwAerK9UluxpfSZ1fJ7Y9qSWahhjVNlvbLKdDQALkJhAgwkj1fecK4kafX5fhUP3i5J8ntjyjmwSm3PFMnXSssJgMQSDVnKOfBfg97zZmzXx0V5Gv9x/o7v19ZLMe6qwL1Yx8QZFCbAAPKOH6XaX+z48C5WvdkwALAfikvrVHt3niQp/J2woqs/NpwIQKqjMAEGwKc/mSONbpHXG1O2uKsIILWsvzakWGyKrDUZGvafr5iOAzjO6Sl8mS4YQJ94C/L1yRVjJEnW6GblZrbt8zlN09uVtiakUDXduQAkhrZCS+1j2rW3pYpzMna8v9WNlT797zmSpJE3rFG0ptaBhADcgsIE6AffiOGqmluivOnb+/S8osJG1W0IxikVAPRdNN1WUWFjr/bNy2qVprdKkrYvHKuiFVsUWf9ZPOMBCYExJs6gMAH6wFdWKvm82n5oibwn960oAYBU4j1lu6ojg1UgSZGoIhs3mY4EIMl5TAcAkoZl6aOfFajmFr88p+1HUeLOmyAAUpB1xnbV3OLXmp8VSBZvboApy5Yt0wEHHKCsrCwVFRVp0aJFWrNmzT6f98ILL2jmzJkKhUIaMWKEbr/9dgfS7hmFCdAL3twcbX1knPJyWvb7WNnTalQ7gwHyAMyrnRlR9tSa/T5OOKdFWx8ZJ2929gCkAhLPzsHvTm598cILL+jSSy/Vq6++qmeffVaRSETz589XS8uer1vWr1+vBQsW6NBDD9XKlSt11VVX6fLLL1dFRcX+/rj6ja5cwF40nDVbVQfaklcqCuz/h7ckeT0xycPgdwAJwPP5e9L+HsaylR7o0ofLxktRqfhVS9l/enUAAgLojeXLl/f4+ve//72Kior05ptv6rDDDtvtc26//XYNHTpUN954oyRp/PjxeuONN3T99ddr8eLF8Y68WxQmwB40nTZbVbNtFY0YmIIEAFJdUfmO98ttVr48kdnK/DPFCVKD7fDg950tJo2NPSemCAaDCgb3PYlOQ0ODJCkcDu9xn1deeUXz58/v8dgxxxyjO++8U11dXfL7/X2Nvd/oygV8gSc9XZ5pE+SZNkGVx3fGrSixAjF15tIfG4A5nbmWrEB8upUWjazR1uM7u99PPaFQXM4DpLqysjLl5OR0b8uWLdvnc2zb1pIlS/SVr3xFkyZN2uN+lZWVKi4u7vFYcXGxIpGIqqur9zt7f9BiAuzk8cqeMEL117ZLkorUGbdTFRU1qDk7KC2nPzYAM+zZDSoKdcTt+EWFjaq7bsf/5/5wpLTqQynG+DqgLzZu3KjsL4zd6k1ryWWXXaZ33nlHf//73/e5r/WlSSts297t406hMAE+V3vegbIWV9OMCAADrOa/umQ9eKDy/sCq8UhOtiTbweGhO0+VnZ3dozDZl29961t6/PHH9eKLL6q0tHSv+w4aNEiVlZU9HquqqpLP51N+fn5fIw8IChO4m2Xpo9sOkAIxBTJalGcxKB0ABprXE1PdghZtP3yW1OHRmG++ZjoSkFJs29a3vvUtPfLII1qxYoXKy8v3+Zw5c+boiSee6PHYM888o1mzZhkZXyIxxgQu5s0Pa8t35ig8pF7Fg+p3rGjsoIAvorqpMdleR08LwOVsr1Q3Naagv8vR8+Zltap4UL3CpfXacuXB8ublOXp+YH/EZDm+9cWll16qe++9V3/605+UlZWlyspKVVZWqq2trXufpUuX6pxzzun++uKLL9Znn32mJUuWaPXq1frd736nO++8U1deeeWA/dz6ihYTuI5n0jh1FaSrJd+vjCOrjOUI+KIqKq9RxwdFsqK01ABwhu21umfPMsHvjcl/ZJWaPhmjYF2X/NWtir33obE8QCq47bbbJElz587t8fjvf/97nXfeeZKkrVu3asOGDd3fKy8v11NPPaUrrrhCt9xyiwYPHqybbrrJ2FTBEoUJXMabm6O1Z+UpPGU/Vm4fYLGAZEUla/+XEgCAvbI9UjRgOsUOXRfVqEtS7duFGvXzHEXrG0xHAvaoP4se7u/5+rb/vm9w3nXXXbs8dvjhh+utt97q07niia5ccJW1tw9LqKJEktKOrlJ7AVMHA4i/9kJL6UeZaynenfC07fr41n33hweQ+ihM4ArevDytv2+qcrPa9r0zAMBReTktWn/fVHn7MPsQgNRDVy6ktOZTDlLNZI9iPimck1gtJQCAHTyWrXBOi9b+YKI8EalgVUwZFf80HQvoFrMtWQ525XJylflEQmGClNV5zCxVzrFUOC7xC5L2oqg8Ea+CtQyCBxAfHWFL7UVRJXKbRHjajvfryowCDW2aJf8zbxhOBMBJdOVCSvKVleqzM2MqHFdtOkqvFI2qUesQVkQGED+tZVEVjTQ3G1dfFIyv1qdft+Ur2/sCcYBTbNv5zY0oTJByPOnp2n57mooKGk1HAQD0U1FRg6puS5cnFDIdBYBD6MqFlFFzwRx1nLBjuskMq9Nwmr7LL69TXX66clakmY4CIMU0zm1Tfrazi8gOBK8npk33jZAkpT2Wo7y7XjGcCEA8UZggJWz57sFqndKmwmDyFSQ7eT0xeTwsZgJg4Hm8MXmT9P0l4/P39aojO9Sef7BK/udlw4ngRom+jkmqoCsXkl79OXPUNq1NhflNpqPst2AwoobRktz5fgRgoFlSw2gpGOwynWS/FRU0qmVam+rPnmM6CoA4ocUEScmbH5ZdUiR5LXUurlOBP2I60oDICHYqbUK1Ip8UyHLpwDcAA8f2SOEJ1fKkyBtKYX6T2ha3y7NqnBSTrK1VitbUmo4FF6DFxBkUJkg6ls+numPGyD5rx4xbQcN54sH2WLJiqXEhAcAc25N6FzdpgS7V/XTH/3v+MEbZFW/IjqTGzSnA7ejKhaSz/scHKHpmckx52R8ey5b/+O3qzE29CwoAzunIs+RfsD1lWkt2p+vsWq2/+gDTMQAMEAoTJJWPfzlb/vGNKf1BKynlXx8AB1ip/17i9cTkn9iotf8723QUpLiYbTm+uRGFCZKCJyNDld8+WFnDGpQZ6jAdxxHNo7rUVujONyYA+6etyFLLiOQf8N4bmaEOZZY3qPLbB8uTkWE6DoD9QGGChOctLFTb4ROUNr9KaQF3fNBKUnFpnTpzU/tuJ4D46MyLqbi0znQMx6QFupQ2v0pth02QtyDfdBykIFZ+dwaFCRKWJytL3twcNR9SrvbL3PMB+0W211bMR6sJgN6L+SzZXtMpzGj/Vp1aZo+UNzdHnqws03EA9BGzciFhrbl5tIoKGyW5dyrIwnHV2l6YpdyXQqajAEgSjQe3qTCc/Os69VfHJbXquKRQ27blaMw33jQdByliRyuGk9MFO3aqhEKLCRKOJxTS2nunKz+/2XQUAECSChc0ae290+UJcWMHSBYUJkgo3lHlWr90hgrDTfJ6YqbjJISMrHbVzoiajgEgCdTOiCojs910jITg98ZUGG7S+qUz5Bsx3HQcAL1AYYKE4Z04VpVHD1LuAVWmoySU9ECX8gY3mI4BIAmEh9Qr3UWThPRG7gFVqjy6RN4JY0xHQRLbufK7k5sbUZggIXgLC7XxuHwFTtxuOkrCiqRbkjvfpwDsi/X5ewR2y3/Sdm0+pkDewkLTUQDsBYUJEsLqa8uVcSQtJXsS8EWVNr+KCw8Au9WVYSltfpX8XrrA7kna0VX68OoRpmMgSdkGNjeiMIFZHq/W3z9FBWX1ppMkBe8RNWouM50CQCJpHir55taYjpEU8ofXaf39UySLmzxAIqIwgTG+slJ98osDlJvVxkD3Xgr4ovzVAujB9nz+3oB98npiys1q0yfXHyTfkMGm4wD4Ei5xYIRn0jhtXjRUBeOr5bHc2mDZP51FEbWWcLcPgNRaYqmriMHufeGxbBWMr9aWrw5nQDx6jcHvzmCBRTjON6xMW+aGFTqOMSX9UTykTlWBbPlaQgo0UtQBbtWZbaljZLuKCxpNR0lKwQVV2hor0uCmVkU2bjIdB4BoMYGDLJ9Pls+njy4tVXABRcn+KCpslA6pNx0DgEHWV+pURFGyX4InVOnjS8u6P5+APWL0uyP4K4QjfIOKtfWOXElSnrfabBgAAD6XO7laVQ+PlCQNuqBW0e1MWw+YQosJ4i526HR98JMyBXxRBXxRxpQMkLRAl5qOaFXM785+qIBbxfyWmo5oVcgfMR0lJXgsu/vzafV1w2UfMs10JCQip8eXuHSMCYUJ4qpjwQH6bEFIxYPrTUdJOR7LVjinRQ0TourKcucbGOA2ndmWGiZEFc5p4SZPHBQPqdOnx6ep47gDTEcBXInCBHFjzZyoTUf4FJ5Ks3g8FZXXqCvDdAoATohk7PibR/yEp23X5rk+WTMnmo4CuA6FCeLCk5WltUsCKphIUeIE27tjLQMAqcv2SraXVhIn5E/ero+/HZAnK8t0FCQI23Z+cyMuZTDgPFlZqrl/kArymkxHcY3cA6pUP5lFKoFUVjclqtxZ3OxxSmF+k2ruHyRPBk3SgFMoTDCgrJkT9fHto+j7bEBuWb3qvtJhOgaAOKg/tF15QxocPefgzAY9MukuPTLpLg3KcOeNJo9l66Nfj5Fn2gTTUWAYCyw6g8IEA6ZjwQFae3o2LSWGBHxR5eS0qnZGlG5dQIqwPVLtjB1/2wFf1LHzTi3YrMuHPKcSX6ZKfJn6dumzmpy/1bHzJ5LCcJPWfj1HnccyIB6INy5fMCBih07XlkN9jCkxLOiPqLCsTnLnjRYg9VhSYVmdo0XJ+PA2HZ+3SnPT/tU9dG5aTMeHV2l8eJtjORJJ/qTt2nKoT7FDp5uOAqQ0ChMMiLVn+pl9K4FEQxatJkCSsz07/padlBXs0L8X/58WZrTu8r1FGc26rPg5ZQXd2WU0b/p2rT3TbzoGTNm5toiTmwtx6QKkGI9lK+3oKnXmuvNNDUgVHXmW0o6ucmzMnmXZemxshaYFg3vcZ2YwoEfGPuhIHgDuQ2GC/WL5fFp//xQVlNabjoIvCRxco4bRplMA6I+GMbaCc5xbryQ31KZnJ/9R6Z7APvfN9IT0f1PuVU6w3YFkiaWgtF7r75sqebymo8BhTBfsDAoT9JtvWJk+ue4A5Wa1yethqtpEE/BF5R/erDqmEQaSSt2UmPzDWhwbVzIxXKn/Ln9EmZ5Qr5+T6Qnpv0Y84roxJ15PTLnZrVr30wPlKx1iOg6QcihM0C+eSeO05cQy5U/aztTACSwno01WXqfpGAD6wBPuUE5GmyPnmlqwWSflv6WZwX23lHzZgUG/Tspf6brZujyWvWMw/EnD5J0wxnQcOMU2sLkQhQn6zFc6RFuPCCu4oMp0FPSC1xtTVxbjTYBk0JVlyeNQC3RRRrPOLHhltwPde2vR58coymgewGTJIXh8lbbOLaDlBBhAFCboG49Xa64oU+g4ipJkEc5pkX9uNbN0AQnO9kj+udUKZ/e/UOgty7L1uxEVOqz3vbf2aG5aTL8dUSHLha3nwROqtObfhzLmBBggXKqgTz69b6LC45wbkImB4ffG5D2hRl2ZtJwAiagr05L3hBr5vfFvLUnzd+nFKX9WgTdjwI5Z5M3Qi1P+rJAvMmDHTBbhCdVa/8dJpmMgzlj53RkUJugVb2GhPrrtQGVntDOmJEl5PTG1H9is1sHufLMDElXLEEsdBzU7MonIqNxq3Tr6Pvmtgb/D77e8um3MnzQix103rzyWrZysNn1024HyFuSbjgMkNQoT7JN3whhtOme0iofVMvtWkgtnt6p9WIeay0wnASBJzUOlzmEdysuKf/etGYWbdEbRqxofSI/bOcYH0nV60T81tWBz3M6RiLyemIqH1WrTOWPlHc887SmLge9x5zMdAInNO6pclYflK30eY0pSRXFxg7b7s9TRkqZgrYvf/QDD2vMtRcvbVJTXFPdzDc2u06K8NzU/vSvu51qY0aqA9ZbqOtO1oTEv7udLJOlHVWlbc6EGdXQpsu5T03GApEOLCfbIEwpp3dklCizcbjoKBlhhuEme2XWK+ejWBZgQ81nyHVSnAgeKkoA3qp+VPeZIUbLTsekdWlb2mAJeZ9ZiSST+Rdu17uzB8oQGYGYBwGUoTLBHH985XrkH0FKSqtIDXQqeUKVokOIEcFI0ZCl4QpXSAvEvFHyemJ6fVKFyf2bcz/VlI/2Zem7SQ67sApxzUJU++s140zEwgBj87gwKE+zCk5Wlj/8wQ3k5LaajwAFdcxvUVuTON0DAaW3FlroOb3DkXIMzG3T/hLvltcx91Pstrx6YcLcGZcS/ZSjR5Oa26OM/zJAnY+BmPwNSHYUJdmF5PSoqbHTlXS43ykrrUPvodjUPNZ0ESG3Nw6T20e3KSuuI+7mmFmzWpUP+plKf8y0lX1bqy9S3Sv/PdSvE+70xFRU2Sh4utVICK787gr8W9OAtLFTz4WNNx4DDigob1VXWQcsJECdtRZa6yjpUVNAY93ONyavS8XmrNC8tccZ3zEuL6vjwKo3Jc1/34Na545lGGOglChN082RkqPWA4er8f7Wmo8CAosJGaVqjoiGKE2AgRUOWrOkNjhQlWcEOXVnyjBZmxH/64b5alNGsJYOeVVYw/i1GiaTjm7VqmzWCLl1JzzKwuQ+FCbpt+bepar+sznQMGJSd3q7AMdtlD/zaa4ArxXyWQsdWOdJ9y7Js/WXcw5oSSNzZoKYFg3psbIUsly3U23Z5nbZeMNV0DCDhUZhAkvTxL2dLh1OUYMcqxtFj6tURdufdGmCgtOdbis135n01nNaq5ZPvVdDyO3K+/ZHuCWj55HuVG2ozHcVR9pF1Wvu/s03HABIahYnLWT6fPv3JHKWXNTkydSWSQ1qgS22T2lghHuin5qFSx6Q2R95XJ4Yr9Z/DnlCOJy3u5xooOZ40XTP8cY0PbzMdxTFpgS6lDWvSpz+ZI3lolk46DH53BIWJi3nzw2o4ZZayp9UoM+SuPr/Yt8JwkzpLO9U6mJYToC9ahljqKu10ZPHEyflbdVL+W5odSr4L3dkhr07KX6mJ4UrTURyTGepQ9rQaNZ16gLz5YdNxgIRDYeJidkmR7LOrmRYYe1Rc3KDo2BZ1ZVKcAL3RlWnJHtesoqL4r1VSkN6i8wpfSsiB7r21KKNZ5xb9XQXp7lk3y+uJKXZOtTSo0HQU9AUtJo6gMHEzLxeb2LdwTov8R1TL5t0C2CvbIwWPrFZeVvwLBcuydc/ICh0SSv4/zMNC0l0jH3LdgHjb4jMY+LLkf0dDv9SdO0eV17rrQwD95/fGZB1fo64sPkiB3enMtmQdX+NIC3RGoFMrptyvPG963M/llAJvhlZMuV9pfveMdaz8b6nhLAbDA19EYeJCW757sGqOblfQHzEdBUnE742pfVaLGg5vV90kuv8BklQ3JaaGw9vVMbNFfm/8/y5G5VbrplEPJMXsW30VtPy6efT9GpVbbTqKI4L+iLYf26Gt3znYdBT0hm05v7kQhYnL1J4/R61T2lQYjv+gTKSecE6LCvKaFBjUqobRptMAZjWMsRUsblVBXpPCOfEfIzGjcJPOKHpVEwPJM/tWX00MpOnUwtc0tWCz6SiOKAw3qXlqu2q/Mcd0FCAh+EwHgLPaT2xQYbDTdAwkudzMNnWM6VJ7bVjBOlsWDShwEdsjdeRZyh5Tq4Av6sg5S7PqtTj8uualOXM+kxZmtCpkvaGajgxtaso1HSfuigoa1XxiUPq96STYG9vesTl5PjeixcRFPOmp0x8Z5gX9EWUdWqVomiW5s8UZbmRJkXRLWYdWOVaU+Dwx3TDsUVcUJTvNT+/SL4Y+Kp+LZo3kMxqgMHENX1mpah4cogxaSzDAgkdtV2sJlQncoWWIFJq33bHz+TwxvTD5IQ31ZTp2zkRR7s/UC5MfckVxkhnqUM2DQ+QrHWI6CvaE6YIdQWHiAp3HzNLq/y6Sx2VTMcIZHsuWd0qDWo5qVt1XWKgTqanuKx1qOapZ/skNjr2XlmbV608T7pbXcu9Htdfy6E8T7lZpVr3pKHHnsWytvq5YXUfNNB0FMMa973Yu0XzKQdpwjE9FBY2moyCFZYY6lJvZptzcFtVOi7LmCVKG7ZVqp0WVm9ui3Mw2x1qdZxRu0r+VvODKlpIvG+rL1L+VvOCKAfFFBY3acJxfLYsPMh0FMILB7ymueopHheOc63YAdwv4oioeXqv66kJZUUv+ZsnfREsdkk9ntqVIhmR7bRUPr3X03KNyq3V83tuan+6eNT32ZX56l9rtVWqJBLW2vsB0nLgqGF+tmqYiZVSYToIenJ7C16XTBVOYpDBvXp5s/oVhQO6sHcVw1bp85az2ytNFcYLkEfNbaimPqqi8xvFzZwQ6tXTw0yk9JXB/Lcxo1XD/cl3ReqpaOgOm48RVzGfLm5enaF2d6SiAo+hwkcLW3jpU4am0lsCcohE1aj6k1XQMoE9avtJipCixLFtPja+gKNmLKYGQnhpfISvFx0zmzdiuj24ZZjoGvsCynd/ciMIkBXlzc7T+/inKzeaCEObl5bSo/ZhGphRGwrM9UsexjUbeOwvSW/TUpHtSckX3gRa0/Hpq0j0Kp6X2Z1w4p0Xr75sqb3a26SiAYyhMUoxnyjit/cEEhbNbmYULCcFj2coIdar2wC7VHtSl1kFUKEgsrSWWag/qUt0BXcoMdTj+3jk5f6uWDn1SeV7WseitPG+6fjjsL5oYrjQdJW48lq1wTovWLp0o78SxpuMAjmAEQorpyk9XeArdt5BYPJat4pJ6SdK2WJ6iIZ+smJS5wWwuuFvz0B2tJF1Fnd2/n06bnL9VJ4ZX6pAQ9wn76pCQR9vz35Y0Te/XDjIdJ27CU7er66ks7iSb5vTaIgl8b/mmm27q9b6XX355n45NYZJCvPlhteTTDQCJrXhInTRE6ujyqas2LH+LndBvwEhBltSVYSljSo1jq7fvTjitVRcVrdCBQd63+2tRRrMKvS/qv9tOUG1b6rY4tRcElJUfVrTG2RnigN353//9317tZ1kWhYmbbTx/nDKOqDIdA+iVoD8iHVWltr8WyddGZQLnRNIspR9l9r3SsmzdN7pCOR4Guu+vQ0Ie/XHUQ1rw3tmyU3SK1a6LarSpfJxKbnjZdBT3YrrgbuvXr4/bsWkZTBEf3X6gAodVm44B9JnvqGrZJ9Sqdoa5O9dwh9oZUdkn1Mo3z+x7ZVawQyum3E9RMoDyvOlaMeV+ZQScWQDTBP8R1fro1gNNxwDiihaTVBGIye+NmU4B9NnO39usQU2qPywkScr5R0gWdQoGQMxnqfHgNklSVma70a5bkjQmr0pXljyjoBUymiMVBS2//nfUn/XzLcem5CKMfm9M8tO6bAxjTPZo06ZNevzxx7VhwwZ1dva8OXDDDTf06VgUJsnO41XteQcqkNFiOgmwX9IDXUoP71jpevuYoKyYFKj1KG17Er07I2G0FVnqzIvJ9toqDDeZjiNJmlqwWQvDKzUlQFESL1MCIZ1a+Jqe9E3VquohpuMMOH9Wh2q/MUfhP7wmxbh7A/Oee+45LVy4UOXl5VqzZo0mTZqkTz/9VLZta8aMGX0+Hl25kpgnPV3WjPGyFlcrLyu153OHuxSOrVbB+Gq1DetSR9hSR17i9rVFYunIs9QRttQ2rEsF46tVOCYxurgOzmzQqfmv6fj0dtNRUt7CjFYtDr+hwZkNpqMMuHB2q7S4RtaM8fKkp+5gfySPpUuX6jvf+Y7ee+89hUIhVVRUaOPGjTr88MN1yimn9Pl4FCZJzB5brvpr21mvBCmruLROmYdVKe3QasV8lmyPWKgRu7J2TPsb81tKP2y7Mg+r2jH7W4LweWK6afgjmpfGHW6nzE/v0o3DH5HPk3pdnL2emOqvbZdGDTUdxV1sA1sSWL16tc4991xJks/nU1tbmzIzM3XttdfqZz/7WZ+PR2ECIOF5PTH5j98u34nVahxpOg0STcNoW74Tq+VfsD3hbtQEvFG9MPkhlfoyTUdxnaG+TD0/+UEFvBSEQLxkZGSoo6NDkjR48GB98skn3d+rru57izWFSZJqOm22ProiaDoG4BiPZctj2UobU6/meS1qmNtmOhIMa5zbpuZ5LUof1dD9+5FIhmbX6Q/j7pHX4qPWFL/l1R/G3aPSrHrTUQbcmivT1XLyQaZjuActJrs1e/Zs/eMf/5AkHX/88frOd76j//7v/9b555+v2bNn9/l4DH5PQg1nzVbVbFtFBY2mowCOSw90KT3QpWjMo5qpO4rz9I1eBWuT5F0c+6U931Jb6Y474PnZrfImaFedGYWbtCjvTZX7aSkxrdyfqQtLXtIjwRkpNSC+qKBRWw7PV1FwtnL++KrpOHCpG264Qc3NzZKka665Rs3NzXrggQc0atSoXi/E+EUUJkmo6kBbRSNqTMcAjPJ6Yioq3/F3UBXLV8zvlWJiFq8U1VZoSR6pvTja/e+eqEblVmth3krNT+8yHQWfOza9Q532KjV1hbSuId90nAFTNLJG26MFyvmj6SRwqxEjRnT/f3p6um699db9Oh6FSZLx5uZIXtMpgMRSNLJGGim1dAQUey63+3ErarMeSpKyvZLt/ddMB74D6pQe6FK2wUy9kebv0g8HP6XxAWZMSjQLM1o1cshTuqz1dLV1+U3HGTC215Y3N0fR+tSbhSyhsPK7IyhMkolladNdg1UUSOy7hYApGcFOaUFV99dV6/KV9w79+5NR3eSoiofXmo7RJ15PTM9MeFh+i6IkUU0MpOmZCQ/rsHdOlZ0iF35FI2u08fdDNPhrjZJNizHiLxwO66OPPlJBQYHy8vJkWXv+W6qt7dv7OIVJkvANK9NHy/KV52chRaC3cofWq2OwT7YtBZ/NlpWYwxHwOdsjdc7fMXYu7E+ublBFGc363YgK+a0M01GwD37Lqycm3a3zPjlZ1a2p8e+VFujSuj9O1ZjvbVdk02bTcVKSZe/YnDxfovrf//1fZWVlSZJuvPHGAT02hUmy8HiUn9tsOgWQVAK+qAK+HX25ts3q6m4a9zR7lbs6Ne6WJrv6CbZiGZ/3t7NsFYc6zAbqh6kFm3VOwT9U4E2Ni1w3KPBm6HtDn9Y92w/RuzUlpuPsN49l77hG8NJCjPjbuW5JJBKRJB1zzDEaNGjQgBybwiQJ+EYM1/bDSuTRdtNRgKRVPLi++//rm9PU3Pqv2ZKCNZb8zQl8eyqFdGVZ6gj/62cdGNKinIzknfp5YrhSx+et0iEhLgiTzWEhqTa8SjHb0vu1A3NRZVr14aUqeMmjyPrPTEeBC/h8Pn3zm9/U6tWrB+6YA3YkxE39zGJ5TqUoAQZKbmabNP1fF8PV7xcqY3PPFhRvBwPn95ftlaLBnj/X1pKYCib0fdGtRJQbatP/K35eBwZTZyC12yzKaNYg7wu6pnWh6tvTTMfZb9bp29XYPEjpFCYDz+m1RZLkXtlBBx2klStXatiwYQNyPAqTZLCXQUUA9l/BxO3SxJ6PNbxapPTKJPlkSFBtxZZyDqzq8VjyX/rtYFm2HhpToUxPyHQU7KfZIa8eGPOQjn33rJQYEJ8CLwFJ5JJLLtF3vvMdbdq0STNnzlRGRs8urVOmTOnT8ShMEtyGqw9WaEatWOMdcFb6AdW7XKR0/iNfwTqKld1pz7cUnNNzxsD0RB69uR9ygu16ZOzDSqcoSRk5njQ9N/k+nbRmsZo6kvsTt+WcBtWOP1hlP3nZdBS4wGmnnSZJuvzyy7sfsyxLtm3LsixFo33retDrTrGbNm3q04Hj5dZbb1V5eblCoZBmzpypl156yXSkuPn0J3NkT2xS0B8xHQVwHb831j14fufWMbVV9Ye299giae67PRlJt3b5OXRNadnl5+X3pt40aOPD2/SzERVK9wRMR8EAS/cE9IsRD2lMXtW+d05gQX9E0cnN+vS/5piOAoe9+OKLOvHEEzV48GBZlqVHH310r/uvWLFClmXtsn344Ye9Puf69et32datW9f9377qdYvJpEmT9Ktf/Upnn312n08yUB544AF9+9vf1q233qpDDjlEv/71r3Xcccfpgw8+0NChQ43lipvRLTv6wgNICLubGa9qZECejt3f4wk0WkrblpytBq2DLHVl7T57LBRVUX6Tw4nMm1qwWcfnrdK0YHLfUceeTQsGdXLBG3rCMz2pZ+vKy2pV7WjTKVKLJYenC+7Hc1paWjR16lR94xvf0OLFi3v9vDVr1ig7+1/L1xYWFvb6uQM1tmSnXhcm1113nS699FI9+uijuuOOO5Sfnz+gQXrjhhtu0AUXXKALL7xQ0o65k//617/qtttu07JlyxzPEzcer7zjR8njSc4LGsBNikbtecHTbVtz5e3Y9511b9uOwfZOiAYtRXsx0KN9eKeKB9XHPU+yGJTRpDPy/6m5aanXCoSeFma0KsPzqra3H6XKlizTcfrN67XlnThW0dVrpRgzebjBcccdp+OOO67PzysqKlJubm6/z3vPPffo9ttv1/r16/XKK69o2LBhuvHGG1VeXq6TTjqpT8fqdVeuSy65RKtWrVJdXZ0mTpyoxx9/vM/B90dnZ6fefPNNzZ8/v8fj8+fP18sv774fZUdHhxobG3tsycAbzlXtL6JJPYUmAKm4pF4Zc6v2ubWU2rI9cmRrHmr3KhNFyb94PTHdVl5BUeIi89Kiuq28Ql5P8v6b52S0qfYXUXnzckxHwX748nVsR8fAr/U0ffp0lZSUaN68eXr++ef79NzbbrtNS5Ys0YIFC1RfX989piQ3N7dfiy/2afB7eXm5/va3v+nmm2/W4sWLNX78ePl8PQ/x1ltv9TlEb1RXVysajaq4uLjH48XFxaqsrNztc5YtW6Yf//jHcckDAAMlb1K17InOjFUJp+iA9HgJ+SJ6buLD8lqZ+94ZKaXEl6kVkx/UvPdOVmfUazoOTLMtZ6c8+/xcZWVlPR6++uqrdc011wzIKUpKSnTHHXdo5syZ6ujo0D333KN58+ZpxYoVOuyww3p1jF/96lf6zW9+o0WLFumnP/1p9+OzZs3SlVde2edMfZ6V67PPPlNFRYXC4bBOOumkXQqTeLO+NHXuzlH/u7N06VItWbKk++vGxsZd/oETjX3wVK0+369i1ZuOAsAhHst2tvMyemV4Tq3+u/RxihIX81te/X7cPVq68SRtaMwzHadfVv9shMbcMUR67V3TUdAPGzdu7DH+IziAY9zGjh2rsWPHdn89Z84cbdy4Uddff32vC5P169dr+vTpuzweDAbV0tLS50x9qip+85vf6Dvf+Y6OOuoovffee30aHLO/CgoK5PV6d2kdqaqq2qUVZadgMDig/4BOiKT7eqxQDQBw3ozCTVqYt1Ij/RQlbjfSn6lzB/1Djwema1X1ENNx+qx4cL2iGdmizWc/GVpgMTs7u0dhEm+zZ8/Wvffe2+v9y8vL9fbbb+8yCP7pp5/WhAkT+nz+Xhcmxx57rF577TXdfPPNOuecc/p8ov0VCAQ0c+ZMPfvss/rqV7/a/fizzz7b54E1ico7eoRqygMsLgMABg3PqdXCvJU6Nn3g+3IjOR2f3i5ppRq60vRpQ9h0nD6rHxFU0cZyRdeuNx0FCW7lypUqKen9jHTf/e53demll6q9vV22beu1117Tfffdp2XLlum3v/1tn8/f62vgaDSqd955R6WlpX0+yUBZsmSJzj77bM2aNUtz5szRHXfcoQ0bNujiiy82lmmgeDIy9Ompg5R9SHLPnw4AySzki+ja0ic0xp+x753hKsent2t06RP6t5Yz1R5JrluIvsXb9VlRiYbeVKVYP7rXIDk0Nzdr7dq13V+vX79eb7/9tsLhsIYOHaqlS5dq8+bNuvvuuyXtmN12+PDhmjhxojo7O3XvvfeqoqJCFRUVvT7nN77xDUUiEX3ve99Ta2urvv71r2vIkCH65S9/qdNPP73Pr6HXf1nPPvtsnw8+0E477TTV1NTo2muv1datWzVp0iQ99dRTAz6HsglrbhmnoiKKEgAwxeuJ6dmJFfJbFCXYvTH+DD07sUJz3z1F0VivJzZNCFmHVunD0eM15vw3TEdJToa6cvXFG2+8oSOOOKL7653jrM8991zddddd2rp1qzZs2ND9/c7OTl155ZXavHmz0tLSNHHiRD355JNasGBBn8570UUX6aKLLlJ1dbVisZiKior6Hv5zlm3brhlx2djYqJycHM3VSfJZftNxevj4rpkqKmowHQMAXGlQRpPuGPGwirwUJdi3qmiLLly3WFUtyTUGaVtlbkIWJhG7Syv0mBoaGhwdT9EbO68dh1333/KEQo6dN9bers+u+mFC/ky+6Mgjj9TDDz+8yzoojY2NWrRokf72t7/16XjJVe6nIMsf0Mb/OFjp2e2mowCAK00t2Kxvlz5LUYJeK/JmaEnpM5qcv9V0lD7JyG3Txh8eLMvhGVVTwc7JE53cksGKFSvU2dm5y+Pt7e166aWX+nw8fjMNs/w+Zc7ZvmO6UACAo8aHt+n4vFUsnog+m5sWU314lSK2R6trdz87aKLJDHUoOqdals8nOxIxHQdJ7J133un+/w8++KDHrLnRaFTLly/XkCF9n8WOwsQgyx+QZ1D/++EBAPovJ9iuy4qf08xgwHQUJKlFGc0q8z2nq1q+poYO57r57A/LsuUpKZa9aavsrl3vdGMPkmCMiZOmTZsmy7JkWZaOPPLIXb6flpamX/3qV30+LoWJSVPHqObadnkS/bcPAFKMZdl6ZOzDSvdQlGD/zAwGVDH2IR31zlmmo/SKx7JVc4tfuT8cLa1833QcJKn169fLtm2NGDFCr732Wo+1DQOBgIqKiuT19n31HAoTAICr5Iba9NCYCqV7kuMONxJfpiek/5tyrxavOTlpWk6A/bFzRtxYbGC7wVKYGNK26EBtOtpSkRj0DgBOGR/epsuKn1MmRQkGWKYnpOtGPKybt81LijEnH12QqbK/HqjQE6+ZjpIc6Mq1Vx988IE2bNiwy0D4hQsX9uk4FCaGNA/yqqh8u+kYAOAaUws26/i8VYwpQdzMDAZ0Uv5K+ayperem96tnm1A0okYtgwpFiY79sW7dOn31q1/Vu+++K8uytHMVEsuyJO0YCN8XTBdsgG/4UHVlW6ZjAIBrFGU068yCV7Qwo9V0FKS4RZ//rhVlNJuOsk8dOZZ8w4eajpEUmC549/793/9d5eXl2rZtm9LT0/X+++/rxRdf1KxZs7RixYo+H4/CxIDV3y1RxlxWeQcAJ3g9Mf1uRIUO49YwHDI3LabfjqiQ15PY01BnHFml1d9J7JYdJLZXXnlF1157rQoLC+XxeOTxePSVr3xFy5Yt0+WXX97n41GYAABSVpq/SysmP6gCFk+Ew4q8GVox+UGFfKwXgtQVjUaVmZkpSSooKNCWLVsk7Rgcv2bNmj4fj8LESZalj391kDKHNJpOAgApb0ROjX495k/yW32fshIYCH7LqzvG/lHDc2pNR9mjzLJGfXzTQZJFF/O9si3ntyQwadKk7sUWDzroIP385z/XP/7xD1177bUaMWJEn49HYeIky6OcoQ1KD3SZTgIAKW1G4SadWfyKxvhpKYFZY/wZOrv4ZU0t2Gw6ym6lB7qUNZQbpuif//iP/+ieMvgnP/mJPvvsMx166KF66qmn9Mtf/rLPx2NWLod4QiFFZ4yVZTE9MADE0/CcWi3Ke1Pz07kJhMRwfHq7vHpLdZ3p2tCYZzrOLjyWLXv2FHlXrlGsneuU3WK64N065phjuv9/xIgR+uCDD1RbW6u8vLzumbn6gsLEIVbZYDX+R4uYpBIA4ifgjWpZ6eMq92eajgL0cGx6h0aXPaZvfHi2OqOJ1b0w6I+o8UcR5V9arNj6z0zHQRI4//zze7Xf7373uz4dl8IEAJASvJ6Ynp9UIa9FUYLENNKfqecmPaS5756iaIze9MnE6Sl8E3264LvuukvDhg3T9OnTu9cuGQgUJg5oO+lAbTmtUwVK/DnNASAZDc5s0C3DH6EoQcLzW149NOFufXP9YlW2ZJmO08Oan4RV+qciBZ983XQUJLiLL75Y999/v9atW6fzzz9fZ511lsLh8H4fl3LdAZE0jwpyKUoAIB6mFmzW5UOeU4mPogTJocSXqW+V/p8m5281HaWHgrwmdaVzaYh9u/XWW7V161Z9//vf1xNPPKGysjKdeuqp+utf/7pfLSj89sWZdcBkNZTzYwaAeBgf3qaF4ZWam5bYC9kBXzYvLaoTwys1Ji+xFlxuGOGVNWuS6RiJxzawJbhgMKgzzjhDzz77rD744ANNnDhRl1xyiYYNG6bm5v7dkOeKOc7WLc5U1qGJ9aYDAKkgK9ihKwY9q+PTmUUIyWlhRquWDHpWWcEO01G6ZR5epXVfS6wuZkh8lmXJsizZtt09fXB/UJgAAJKOZdl6bGyFpgRCpqMA+2VaMKjHxlaYjoF9sf81AN6JLRlaTDo6OnTffffp6KOP1tixY/Xuu+/q5ptv1oYNG7pXg+8rCpM4+viumcqckLirvQJAMsoNtWn55HuV7mECdqSGdE9Af51yj3JDbaajSJIyJ9Xqo9/PNB0DCeySSy5RSUmJfvazn+mEE07Qpk2b9OCDD2rBggXyePpfXjArVxwFMzoV8EVNxwCAlDExXKn/V/y8cjxppqMAAyrHk6Zryx/VbduO1OraYqNZAr6oAixQir24/fbbNXToUJWXl+uFF17QCy+8sNv9Hn744T4dl8IEAJAUJudv1YnhlTow6DcdBYiLA4N+bclfKZ81Ve/WlJiOgy9i5fcezjnnnH6t7L4vFCbx4PHKO3KYPB5miQGAgVCU0azzCl/SISF6ICO1LcpoVtj7D/287ThVt2YYy+H1xuQdPULRTz6TYvT+QE933XVXXI7LO3wceAvzVftLj7LSEmeWDQBIVpZl6w8jHqYogWscFpLuGvmQLIPLf2ent6v2lx55w7nGMiQUpgt2BO/yAICElebv0otT/qw8b7rpKICjCrwZenHKn5XmZ6wH3IPCZIDZB0/V6h8PNx0DAJLeqNxq3Tr6Pvktr+kogBF+y6tbR9+nETk1xjKs/slI2XOmGjt/onByquDuKYNdiMJkgHVlB1Q8lCmCAWB/zCjcpDOKXtX4AC0lcLfxgXSdWfyKphZsNnL+4qG1imQx4QScQWEygHzlw9RUynwCALA/hmbXaVHem6zoDnzu+PR2fTX8loZm1xk5f1OpX77yYUbODXehMBlA678+RL6vbTcdAwCSVsAb1fVDH9N81lAAejg2vUM/K3tMAa/zM2R5T96uT08f4vh54T4UJgCAhODzxPT8pAoN9WWajgIkpHJ/pp6b9JB8LEeAFEVhAgAwrjSrXvdPuFtei48lYG/8llf3T7hbgzMbTEdxF6YLdgSfAAOk6tKD1TaKdUsAoK9mFG7SNwc/r1JaSoBeKfVl6tIhf3N0QHzr6E5t/+Ycx84Hd6IwGSCNs9tUXMzdCwDoizF5VTo+723NS2NlaaAv5qVFdXzeKo3KrXbkfMWD6lU/mxuwiC8KkwHgLcgXvQ8AoG8yAp36fslfmX0L6KeFGa363uDlygh0OnI+y2PLW5DvyLkSDeuYOIPL6f3kychQ9R/CKshrMh0FAJKGZdl6anyFJgbSTEcBktqUQEhPja+Q5cCVbGF+k6r/EJYnnfWFEB8UJgAARxWkt+ipSfcoaLFoGzAQgpZfT026R+G0VtNRUhsD3+OOwgQA4JjJ+Vv1H0P/ojwvd1yBgZTnTdd/DntCE8OVpqMA/UZhsh98g4pVf9JkedzaERAA+mBy/ladGF6p2SGv6ShASpod8urE/LfjXpzUL5oib3FRXM+RcJgu2BEUJvshMrxY9lnOzIYBAMksnNaqCwpf1MIMupoA8bQoo1nnF70Yt25dHsuWfVa1YkOL43J8uBuFCQAgrizL1h9HPURLCeCQQ0Ie/XHUQ44MiAcGEoUJACBuMgKdWjHlfsaUAA7L86ZrxZT7HZtKONUxXbAzKEz6qem02frogqDpGACQsMbkVemmUQ8w+xZgSNDy66ZRD8RlEcY1/xZS8ykHDfhx4W4UJv3UVuhR8ZA60zEAICHNKNyk0wpfY50SwLCJgTSdWviaphZsHtDjFg+pU1uBiy4jGfzuCBf9Rg0c79hR6sg1nQIAElNpVr0Wh19nRXcgQSzMaNXi8Bsqzaof0ON25Fryjhk5oMeEu1GY9MPqK8LKPrjKdAwASDg+T0w3DntU89KipqMA+IL56V26Ydij8nliA3bMrEOrtPrb+QN2PIDCBAAwIALeqF6Y/JBKfZmmowDYjaG+TL0w+aEBLU7cgsHvzqAwAQDst6HZdbp3/D3yWnysAInMa3n0pwl3D3i3LmAg8AnSF5alyisOViCPftMAsNPUgs26cNCLGkpLCZAUhvoydWHJSwMyIN4fblfltw+WLGsAkiUwBr87gsKkDyyvV94japSXxcrFACBJo3KrtTC8UvPTu0xHAdAHx6Z36Pi8Vfs9lXA4u1WeI2olWksxAPgtAgD0S5q/Sz8c/BSzbwFJamFGq5YOflppfm4s7BMtJo6gMAEA9Jll2XpmwsMaH2BFdyCZTQykafmEh2S5dbQ1EgqFSS95R5Vr3T0TFfAxBSYAdyvKaNZTk+6R3/KajgJgAAQtv56YdLfCaf3rqh70R7T+j5PkGzF8YIPBdShMesvrVTinxXQKADBqcv5Wfb/sKeV5aSkBUkmBN0M/GPaUJoYr+/X8cE6LbF/q3qxgumBn+EwHAAAkh4nhSp0YXqlDQtzTAlLRYSGpNv9tSdP0fu0g03HgQny69IInK0tdRVmmYwCAMbmhNv2/4ue1MINZCYFUtiijWRcVvaDcUFufn9tVlCVPVopeLzH43REUJr1Qd9JENS1tMh0DAIywLFsPjHlIBwb9pqMAcMDskFcPjOn7gPimq5pVf8LEOKWCG1CYAAD2KCvYoecm36ccT5rpKAAclONJ03OT71NGoNN0FLgIhQkAYLfG5FXpFyMeUronYDoKAAPSPQH9z8gHNSavynQU8+jK5QgKEwDALqYWbNbJBW9oWjBoOgoAg6YFgzq54A1NLdhsOgpcgMJkH3zlw9SWz48JgHsMzmzQGfn/ZKA7AEk7Vog/Nf81Dc5s2Oe+bQUe+cqHOZDKWUwX7AyuuPdhzSWDlXYMTZgA3MHriemW4Y9oblrMdBQACWReWlQ3DX9EXs/e3xtCx1Xpo/832KFUSDUUJgAASVLAG9WLkx9SiS/TdBQACajUl6kVkx9UwBs1HQUpisIEAKDhObX6/bh75LX4WACwZ37Lq9+Pu0dDs+tMR3EWg98dwSfQXlRdcrDsknbTMQAgrmYUbtJ5xf/QSD8tJQD2baQ/U+cP+vseB8THhrRr+zfnOJwKqcBnOkAi65zXoMK0DtMxACBuRuTUaGHeSh2bznsdgN47Nr1DUa1UU1dI6xrye3yvML9JDUdGpNsMhYsDpwekM/gdAOAqaf4uXVP6F4oSAP1yfHq7fjTkSaX5u0xHQYqgMAEAF/J6YnpmwsMa488wHQVAEhsfSNczEx6Wleq3+Blj4ggKEwBwmaKMZj0y8R75La/pKABSgN/y6rFJd6soo9l0FCQ5CpPd8OblacPVByvoj5iOAgADamrBZl1ZtlxFXlpKAAycIm+Grixbrsn5WyVJacFObbj6YHlzcwwnQzJh8PtuWKGgcg5iUUUAqWViuFLH563SYSHTSQCkosNCUm14lSK2R6trixU4qEpWKCRp3yvGJzynu1fRlQsAkKpyQ226pPhvWpjRajoKgBS2KKNZ3yz+m3KCLLeAvqMwAYAUZ1m2HhpToZnBgOkoAFzgwKBffx77oOkYA8oysLkRhQkApLCcYLuenfxHZXrovwXAOTmeNP3flHul9DTTUZBEKEy+xD54qlb/YLjpGACw38aHt+m6EQ9TlAAwItMTUun929S26EDTUZAkKEy+pCMcVNHoatMxAGC/TC3YrK/mv0n3LQBG/br0FdWd26zGM2abjrJ/WMfEERQmAJBiBmU06cyCVxjoDiAhvHvQn5R54WZZB0w2HQUJjsIEAFKI1xPTHSMeZkpgAAnl2fFP6OI/PSIrGDQdpV8s2/nNjShMACBFhHwRrZj8IIsnAkhIizKadd/a5+XND5uOggRFYfIFVZccrE2nd5mOAQB9NiKnRneM/aP8ltd0FADYozxvuo544TNF5s00HaVvGGPiCAqTL2gvkArDTaZjAECfzCjcpHOKX9YYPy0lABLfd8OfqPGKJjWcmeQD4jHgKEwAIIkNz6nVwryVOja9w3QUAOi112f8WdEzatV1VJK1nCCuKEwAIEmFfBH9d+njFCUAktLrM/6sY/73RXnDeaaj9A7duOKOwgQAkpDXE9OzEys00p9pOgoA9Nv38z/WQ6++aDoGEoTPdAAAQN8MzmzQLcMfkd+iKAEAJzg9ha9bpwumMPlc5bcPVseodtMxAGCvphZs1hn5/1SJj6IEAJBaKEw+13JAm4rymJELQOIaH96m4/NWaW5azHQUAAAGHIUJACSBrGCH/r34/zQtSVdNBoCk5vSgdLpyAQASkWXZemxshdI9FCUAgNRFYQIACSw31KaHxlQo3RMyHQUAXIvB786gMAGABDUxXKlLiv+mTIoSAIALuH4dE8sfUOPXZysQ7DIdBQC6TS3YrJPy39LMYMB0FACAk4sr9nM8y4svvqgTTzxRgwcPlmVZevTRR/f5nBdeeEEzZ85UKBTSiBEjdPvtt/f9xAPI9YWJJy0k+6xqZaczVTCAxFCU0awzC17RwoxW01EAAEmipaVFU6dO1c0339yr/devX68FCxbo0EMP1cqVK3XVVVfp8ssvV0VFRZyT7hlduQAggViWrd+NqFCBN8N0FABAEjnuuON03HHH9Xr/22+/XUOHDtWNN94oSRo/frzeeOMNXX/99Vq8eHGcUu4dhQkAJIg0f5eemfCw/BZFCQAkElOD3xsbG3s8HgwGFRygaeNfeeUVzZ8/v8djxxxzjO688051dXXJ7/cPyHn6wvVduQAgEYzKrdato++T3/KajgIASBBlZWXKycnp3pYtWzZgx66srFRxcXGPx4qLixWJRFRdXT1g5+kLWkwAwLAZhZt0fN7bGh9INx0FALA7hhZY3Lhxo7Kzs7sfHqjWkp0sy+p5Wtve7eNOoTABAIOGZtdpUd6bmp/OzIAAgJ6ys7N7FCYDadCgQaqsrOzxWFVVlXw+n/Lz8+Nyzn1xd2Hi8cpKTzOdAoBLBbxR/azsMZX7M01HAQC4zJw5c/TEE0/0eOyZZ57RrFmzjIwvkVw+xsSeM1nb74xPFQoAe+PzxPT8pAqKEgBIBkmwjklzc7Pefvttvf3225J2TAf89ttva8OGDZKkpUuX6pxzzune/+KLL9Znn32mJUuWaPXq1frd736nO++8U1deeWXfTz5AXN1iYluSx8kpFgBA0uDMBt00/BF5LYoSAMDAeOONN3TEEUd0f71kyRJJ0rnnnqu77rpLW7du7S5SJKm8vFxPPfWUrrjiCt1yyy0aPHiwbrrpJmNTBUsuL0wAwGlTCzbr1PzXVOqjKAGAZGFquuC+mDt3bvfg9d256667dnns8MMP11tvvdX3k8WJq7tyAYCTxuRV6fi8VZqXFjUdBQCAhEOLCQA4ICvYoStLntGUQMh0FABAXxmaLthtKEwAIM4sy9Zfxj2soEVRAgDAntCVCwDiKJzWquWT71XQMjP1IgAAyYIWEwCIk4nhSl1U9IJyPKyXBADJzLJtWXsZWB6P87mRa1tMrJkTVXVAuukYAFLU5PytOin/Lc0OeU1HAQAgKbi2xWTrV3KUdnSV6RgAUlBBeovOK3xJh4Rce+8HAFILg98d4drCBADiwbJs3TOyQnleWmQBAOgLChMAGCAZgU49Nb5CQYuiBACAvqIwAYABMCq3WksHP62gxUB3AEg1ybDyeypIig7Qn376qS644AKVl5crLS1NI0eO1NVXX63Ozk7T0QBAMwo36YyiVzUxQFECAEB/JUWLyYcffqhYLKZf//rXGjVqlN577z1ddNFFamlp0fXXX286HgAXK82q1+Lw65qXFjUdBQAQLwx+d0RSFCbHHnusjj322O6vR4wYoTVr1ui2226jMAFgjM8T0w3DHtVQX6bpKAAAJL2kKEx2p6GhQeFweK/7dHR0qKOjo/vrxsbGeMcC4BI+T0wvTH5IXouiBABSHWNMnJEUY0y+7JNPPtGvfvUrXXzxxXvdb9myZcrJyeneysrKHEoIIJWVZtXrTxPultdKyrdQAAASktFP1WuuuUaWZe11e+ONN3o8Z8uWLTr22GN1yimn6MILL9zr8ZcuXaqGhobubePGjfF8OQBcYEbhJv1byQt03wIAYIAZ7cp12WWX6fTTT9/rPsOHD+/+/y1btuiII47QnDlzdMcdd+zz+MFgUMFgcNdvHDBR7UW2mD8HQF+Myq3W8Xlva356l+koAAAnMfjdEUYLk4KCAhUUFPRq382bN+uII47QzJkz9fvf/14eT/8be9aeHVTJ6O39fj4A98kIdGrp4KeZEhgAgDhJisHvW7Zs0dy5czV06FBdf/312r79X0XFoEGDDCYD4AaWZX++ojtFCQC4EYPfnZEUhckzzzyjtWvXau3atSotLe3xPdt26b8cAEcUpLfonpEVClrppqMAAJDSkmJKmfPOO0+2be92A4B4mZy/VUuHPqk8L0UJAADxlhQtJgDgtMn5W3VieKUOCSXF/RsAQDwx+N0RFCYA8CXhtFZdVLRCBwb9pqMAAOAaFCYA8AWWZeu+0RXK8TDQHQDwL24dkO4kChMA+FxWsEN/Gfcws28BAGAAhQkASBqTV6UrS55R0AqZjgIASDS2vWNz8nwuRGECwPWmFmzWwvBKTQlQlAAAYAqFCQBXG5zZoFPzX9O8tKjpKAAAuBqFCQDX8nliumn4Iyr1ZZqOAgBIYKz87gwKEwCuFPBG9fykCnktihIAABIBhQkA1xmaXaeflT1GUQIA6B0WWHQEhQkAV5lRuEmL8t5UuZ+iBACAROIxHQAAnDIqt1oL81ZqfnqX6SgAAOBLaDEB4App/i79cPBTGh9INx0FAJBkrNiOzcnzuRGFCYCU5/XE9MyEh+W3KEoAAEhUFCYAUlpRRrN+N6JCfivDdBQAQLJi8LsjKEwApKypBZt1TsE/VOClKAEAINEx+B1ASpoYrtTxeat0SIi3OQAAkgEtJgBSTm6oTf+v+HkdGPSbjgIASAGs/O4MChMAKcWybD00pkKZnpDpKAAAoA8oTACkjJxgux4Z+7DSKUoAAAPJtndsTp7PhShMAKSE8eFt+vfi/1O6J2g6CgAA6AcKEwBJb2rBZh2ft0rTghQlAICBxxgTZ1CYAEhqgzKadEb+PzU3zaXL5AIAkCIoTAAktdvKK1TiyzQdAwAA7CcKEwAAAGBvWPndEaw8BiCpfXP9Yq1o460MAIBkx6c5gKRW2ZKl+2oO0uMt6aajAABS1M7B705ubkRXLgBJb1X1EHXGfBrie04zgwHTcQAAQD/QYgIgJayuLdZV676m5li76SgAAKAfKEwApIyGjpCOeucsihMAwMDaufK7k5sLUZgASDmL15ys1zq6TMcAAAB9QGECIOU0dIR027YjGRAPABgQDH53BoPfAaSk1bXF8lnTlev9hw4LmU4DAAD2hRYTACnr3ZoSXb/xWFVFW0xHAQAkM9vA5kIUJgBSWlVLpr76/tnqsqOmowAAgL2gMAGQ8qIxj45+f7FWd7aajgIAAPaAwgSAK7RHfPqvzcfryVYGnAAA+obB786gMAHgGusa8vV47XQtbw2ajgIAAL6EWbkAuMqq6iGq60zX6LLHNNKfaToOACAZxOwdm5PncyFaTAC4zobGPH3jQwbEAwCQSChMALhSZ9Srue+eok2RZtNRAACAKEwAuFg05tHln35Vz7V5TUcBACQy1jFxBIUJAFfb0pyjP9ccqMdb0k1HAQDA1Rj8DsD1VlUPUVvUr6G+ZzUtyIxdAICeLDk7ha/l3KkSCi0mACDpo7oifXfdyWqNdZqOAgCAK1GYAMDnmjqCmvfuGWqItZmOAgBIJLbt/OZCFCYA8AW2bem0j07Wq+1MJQwAgJMoTADgS+rb0/SbqsP1aAsLMAIA4BQGvwPAbrxfO0gea6rC3n/osJDpNAAAkyzb4cHv7uzJRYsJAOzJuzUl+vmG41QdbTEdBQCAlEdhAgB7Ud2aoRPfO0cddpfpKAAAU1hg0RGuLEzG/sfHanm+yHQMAEnCti0d+8HJer+T2boAAIgXVxYm0cYmeViqAEAftHX5tWzLcXqylQEnAADEA4PfAaCX1tYX6HHfdPn1huan07ULANzCsm1ZDq4t4uS5EgmFCQD0warqIarpyNDooY+q3M90wgAADBRXduUCgP2xqSlXZ68+R1E7ZjoKAMAJMQObC1GYAEA/RGIeHf7uydoQaTYdBQCAlEBhAgD9FIl5tOSzRXqm1W86CgAgjnaOMXFycyMKEwDYD5uaclVRO0uPt6SbjgIAQFJj8DsA7KdV1UPUEglquH+5pgSYThgAgP6gxQQABsDa+gJdsfZUVogHgFTEyu+OoDABgAHS0hnQ3HdOV1201XQUAACSjmsLkyH3fqjAHWHTMQCkGNu2dObak/WPdpfO9QgAqci2nd9cyLWFSbSmVsHqTtMxAKSg2rZ0/a7qMD3awgKMAAD0FoPfASAO3q8dJGmaCr0v6pCQa+8BAQDQa3xaAkCcvF87SP/92QmMOQGAJGfZzm9uRGECAHFU25auBe+dzWxdAADsA4UJAMSZbVtasHqx3ulsNx0FANAfDH53BIUJADigpTOgn285lhXiAQDYAwa/A4BD1tYX6EnfVIWsNzQ/na5dAJAsrNiOzcnzuZGrW0y87RFVbc82HQOAi6yqHqLbt8zVpkiz6SgAACQUVxcm9hvvady31pqOAcBltjTn6PQPzlHUduktMQBAXNx6660qLy9XKBTSzJkz9dJLL+1x3xUrVsiyrF22Dz/80MHEPbm6MAEAUyIxj454b7HWd9FyAgAJLwkGvz/wwAP69re/rR/+8IdauXKlDj30UB133HHasGHDXp+3Zs0abd26tXsbPXp0f39K+43CBAAM6Yx69d0Ni7S8NWg6CgAgyd1www264IILdOGFF2r8+PG68cYbVVZWpttuu22vzysqKtKgQYO6N6/X61DiXVGYAIBBm5py9UjtDGbrAoBEZhvYJDU2NvbYOjo6dhuvs7NTb775pubPn9/j8fnz5+vll1/e60ubPn26SkpKNG/ePD3//PO9/pHEA4UJABi2qnqI7q86SKs7WSEeAPAvZWVlysnJ6d6WLVu22/2qq6sVjUZVXFzc4/Hi4mJVVlbu9jklJSW64447VFFRoYcfflhjx47VvHnz9OKLLw746+gtpgsGgASwriFfl7SeoWcmPCy/Za4ZHQCQODZu3Kjs7H/NIBsM7r3rr2VZPb62bXuXx3YaO3asxo4d2/31nDlztHHjRl1//fU67LDD9iN1/9FiAgAJoq3Lr8PeOVXV0RbTUQAAX2DZtuObJGVnZ/fY9lSYFBQUyOv17tI6UlVVtUsryt7Mnj1bH3/8cf9/UPvJ9YVJtKlJ4cujqm3IMB0FAGTbls775GS92G46CQAgWQQCAc2cOVPPPvtsj8efffZZHXzwwb0+zsqVK1VSUjLQ8XqNrly2reja9YrFpptOAgCSpOrWDN2z/RDVhldpUQbTCQOAcf2cwne/ztdHS5Ys0dlnn61Zs2Zpzpw5uuOOO7RhwwZdfPHFkqSlS5dq8+bNuvvuuyVJN954o4YPH66JEyeqs7NT9957ryoqKlRRUTGgL6UvKEwAIAG9W1OimG1psO95HRj0m44DAEhwp512mmpqanTttddq69atmjRpkp566ikNGzZMkrR169Yea5p0dnbqyiuv1ObNm5WWlqaJEyfqySef1IIFC0y9BFm27WT5Z1ZjY6NycnI0VyfJZ/X8oP/kj9NVkNdkKBkA7F5uqE0PjHlIOZ4001EAIC4am2LKG7NODQ0NPQZ6J4Kd145HzFgqnzfk2Hkj0XY9/9ayhPyZxJPrx5gAQCKrb0/Tse+epdZYp+koAADEFYUJACQ427Z00prFensPC2sBAJAKKEw+N/y3lqo+LjAdAwB2q6kjqBsqj2aFeAAwwNR0wW5DYfI57/NvKVjDjwNA4vqorkhP1k3Vc20swAgASD1ciQNAEllVPUS/2nSUtkaYRhhA8muItenh5iQY3G3rX1MGO7KZfsFmUJgAQJKpbMnSyR+coy47ajoKAOyXG2pm6Z4Zw0zHQIKgMAGAJBSNeTTvvZP1SRctJwCSU/nTF+q1r4RNx0ACoTABgCTVGfXqh5sWanlr0HQUAOiT8XdconG/bFasKUnWkHO0G5fDq8wnEAqTLyh+o0u1bxeajgEAvfZpQ1iP1M7Qk63OLfwFAPuj/KkLNfzhWsXe+dB0FCQYn+kAiST41Osq8RyojmmmkwBA762qHqKmrpBGl/5FY/wZpuMAwG41xNr0i+oDNX7JR4o2NpqO0zcxSZbD53MhWkwAIAWsa8jXv605kwHxABJSlx3VQ03len2aN/mKEjiGwgQAUkR7xKe5756iqmiL6SgA0MOM187Wg5NLTcdAgqMwAYAUEo15dOG6xVrRxts7gMQw9s5vqux77bIjEdNR+o2V353BJ9eXZHy4XV2PMgAeQPKqasnUH6vn6PGWdNNRALjcyPsvVvnDjYp+vM50FCQBBr9/SXTteg1qaVPNokzTUQCg396tKVHE9miI7znNDAZMxwHgMlE7plc7pHE3bVHk0w2m4+w/p6fwpcUEAJBKVtcW66p1X1NzrN10FAAuErVj2hpt1Xc+PFVq7zAdB0mEwgQAUlhDR0hHvXMWxQkAx/yjw6OT3zvPdIyBxQKLjqAwAQAXWLzmZL3Z0Wk6BoAUd2PdcP143ULTMZCkKEx2I1ZXr9AteWrt9JuOAgADoqEjpJu3zWNAPIC4+VnNaP2tepxaOgNq6QgodEueYvUNpmMhiVCY7EasvV3BJ19XNMqPB0DqWF1brCdqpzOVMIAB93hLuv5WNVZVLTsmD4pEvAo++bpi7SnSjZSuXI7g0wkAXOTdmhLdsGk+izACGBBddlQbIs1atvY4NXSETMdBkqMwAQCXqWrJ1FffP1tddtR0FABJ7qOuTp363nmybct0lPiKGdhciMIEAFwoGvPo6PcX66MuWk4A9M+dDYP0zTVfNx0DKYTCZC9Kf+HVts/CpmMAQFy0R3z6z00n6slWul8A6JvrqsfqkW3T1Rn17vK9qvX5GvoLA6GQ9ChM9ubVd+Rt3vUPDgBSxacNYT1eO13LW4OmowBIEnc3FujvNSNV3Zqx2+97mzzSa+86nCq+LNt2fHMjn+kAAACzVlUPUV1nukaXPaaR/kzTcQAkqC47qrVdHbrj08MUiXFvGwOP3yoAgDY05ukbHzIgHsCebYq06RsfnOPOooTpgh3hwt8sAMDudEa9mvvuKdoaaTYdBUCCqWjO1lmrzzEdAymOwmQfxt6yWe3Li0zHAABHRGMefXP9YhZhBNDtuuqx+s2mQxXtRUtJx1NFGnPbJgdSOSxmO7+5EJ88+xD5dINCtS6dTBqAK1W2ZOm+moP0eEu66SgADPtV3TC9Wleu+va0Xu0fqokp8tnGOKdCqkq6wqSjo0PTpk2TZVl6++23TccBgJS0qnqIHqqepbc7OkxHAWBA1I7p1faoHt4yTVUtTIoBZyRdYfK9731PgwcPdvScnojU2ul39JwAYNpHdUX67rqT1RrrNB0FgIOidkxbo6369oenqa2r99c/rZ1+eSIp2gWJwe+OSKrC5Omnn9Yzzzyj66+/3tHzZt3/qkqXRhw9JwAkgqaOoOa9e4YaYm2mowBwyEvtPp383nl9fl7p9zqV+eA/Bz4QXCNp1jHZtm2bLrroIj366KNKT+9dv+eOjg51fKEbQmNjY/8DuHQQEgDYtqXTPjpZ15Y/qgODtB4DqeyG2hF6snKS6RgJyOlWDHdedyZFi4lt2zrvvPN08cUXa9asWb1+3rJly5STk9O9lZWVxTElAKSu+vY03bbtSD1KX3MgZf2sZrRW1IxRS2fAdBS4lNHC5JprrpFlWXvd3njjDf3qV79SY2Ojli5d2qfjL126VA0NDd3bxo39nyXCam5V/etFitlWv48BAMlsdW2xnqydqhfbTScBMJCidkzLW4P6v6px/RroHo151PBakaymljikg5tYtm1udE11dbWqq6v3us/w4cN1+umn64knnpBl/asoiEaj8nq9OvPMM/WHP/yhV+drbGxUTk6O5uok+ay+d0ewfD5VPTxSAR8rIwNwr4L0Ft018iEVeDNMRwGwn3YOdD/l/XNl9/Pma0eXT0Vf/ViK9e/6KGJ3aYUeU0NDg7Kzs/t1jHjZee14VPm35PMEHTtvJNah/1v/q4T8mcST0TEmBQUFKigo2Od+N910k37yk590f71lyxYdc8wxeuCBB3TQQQfFMyIA4EuqWzN04nvn6MUpf5bf8pqOA2A/vNvZpYtXn2c6BiApSQa/Dx06tMfXmZk7mhlHjhyp0tJSE5EAwNVs29L8D76mW0ffp/EBFmIEktHt9UN0/6YDTMdIDjFbjg5Id+mkS0kx+D1R2JGI8n+epqrt7mlSA4A9aevy6782H68nW0OmowDoo59Uj9NfqqaoPbJ/96i3bctRwS9C/e7GBXxRUrSYfNnw4cNlamiM5+9vyz7rQCPnBoBEs64hX4/7p8urt3RsOqvEA8ngj035erlmhGrbBqC1s80rz9/f3P/jJDo7tmNz8nwulJSFCQAgcayqHqK6znSNLXtM5X6mEwYSVZcd1YZIm25b/zVFYnSaQeLht7I/YmLaYAD4gg2NeTr3w7MVdeldPiAZbIq06cz3zxuwoiRmW7JiXA9h4FCY9MPYf39bnX8tNB0DABJKZ9Srw989WZsizaajAPiS+5vydNbqcwb0mF1PFWrMt13QjUvaseq705sLUZj0g93VKYubggCwi0jMo8s//aqea2MaYSBRXFc9VndtPljRAe6+ZcVs2ZHIgB4T7sYYEwDAgNrSnKM/1xyolrxVWpjRajoO4Gq31w/Ry7UjVN+eZjpKcmO6YEfQYtJP6VUxbduUZzoGACSkVdVD9FD1LL3T2W46CuBKUTumNzs6df+mA1TdmjHgx9+2MU/p2+k+goFFYdJPmX9+VWN+x9SYALAnH9UV6Yq1p6rD7jIdBXCVqB3T1mirLl399f1ep2RPxv62XRkP/TMux4Z7UZgAAOKmpTOgue+crrooXboApzzXFtQp759rOkZqYfC7IyhMAABxZduWzlx7sl5tZ2VoIN5+UTtSv/jsWNksa4AkRGGyH7zrK+W5u8B0DABIeLVt6fpN1eF6tIUFGIF4+UXtSL1UM1pNHcG4nSNmW/LcXSDPp5VxO0dCsuVwi4npF2wGhcl+iG6rUs4T77LYIgD0wvu1g/Rk7VT9o50Bs8BAitoxPdPq1zPbJqjKgeI/5/F3FN2+Pe7ngftQmOwv21Z9Y/qAzw0OAKno3ZoSLdtwPGNOgAGyc6D71R8vjGtLiSRFYx7VNWRIMRfeXGCMiSO4mt5PsdZWlZ+xSrV1Az8VHwCkourWDC1472xm6wIGwNudEZ383nmOjCmpqcnUiK+/rVg704AjPihMAACOs21LC1Yv1vudbaajAEnrlvoyfefjU03HAAYMhQkAwIiWzoCWbTlOj7ekm44CJJ3rqsfq6apJcVunBF8Sizm/uRCFyQDJeTmkbZW5pmMAQFJZW1+gJ+um6plWv+koQNL4c3OOXqweFZcV3fdk29Zc5b4S3zEsAGX2ACm87RW1hw+WBplOAgDJZVX1ENV0ZGjcsEc11Md0wsCedNlRbYi06Zfrvub4pDvpawMqvP1lR8+ZUJwekM7gd+wvKyamDgaAftjUlKuvf3COorY7uy8AvbE+0q4z3z/P8aIkZluy+NOEAyhMBlDZL15T2m15pmMAQFKKxDw6/N2TtSHSbDoKkHD+2JSv81efbeTc6bfkqvR/XjNybrgLhckAsiMReSLubHoDgIEQiXm05LNFjDkBvuC66rH645aDFDG0ZponYsuORIycO2GwjokjKEwAAAllU1OuKmpn6cnWkOkogHF3NAzWy7UjVNvG7HVIfQx+H2D+xk59+llYxcNqTUcBgKS1qnqIWiJBDR/8tCYG0kzHARzXZUf1fmdEf9p4oNEpgbd9FtaYRhZUVMyW5GArRowWEwwA6+VVGn/Np6ZjAEDSW1tfoMs+Pp0V4uE6UTumbdE2Xbz6TOPrlIz/0SfSq+8YzQD3oDABACSsti6/5r5zuqqjLaajAI55ti1Np7x/rukY+ALbjjm+uRGFSRxEt9co/7KImtpYiAgA9pdtWzrvk5P1j3Z3flDDXX5RO1L/+9nRsg0vP9DQkqb8yyKK1tYbzQF3oTCJh1hUkXWfKmZo9gwASDXVrRm6a/uherSFBRiRum6oHaGXakarocP8xA+xmKXIuk+lWNR0FLgIg9/j6d0s1U6wFM5uNZ0EAJLeuzUlitmWBnlf0OyQ13QcYMBE7ZheavfpycpJaukMmI6j2sZ0+d7nJkAPtu3sgHSmC8ZAG3rty9KnGaZjAEDKeL92kK75dKEaYm2mowADImrHtDXaqh+s+VpCFCWSpHUZKvuvl02ngAtRmAAAkkp9e5qOffcstcY6TUcB9tvrHbZOfu880zGwLyyw6AgKkzgb9dMPFH2w0HQMAEgptm3ppDWL9U4n6ysgef2qbpiWfvI10zF6sO8v1Kifvm86BlyKwiTOovUN8re5s+oFgHhq6gjq+q3z9XgLK2Ij+VxXPVbPVo9XW5ffdJQefG0xRRsbTceASzH4HQCQtD6qK9KT3qnK8LymeWnMHoTkUNGcrRerR6m+Pc10FPRWLCZZDk5ZzjomiBd/S0zba7NMxwCAlLSqeohu2XykNkWaTUcB9qrLjmp9V7NuWHdUQhYl22uz5G915wUxEgOFiQNCT7ymsT9uMB0DAFLWluYcnfbBOYq69C4jksParg6d8f55iiboOmfjflSr4JOvm46RmBj87ojE/MsAAKCPojGPjnhvsdZ30XKCxHN3Y4Eu+vAs0zGAhEZh4hB74xblXJuuzgiLggFAvHRGvfr+xpO0vDVoOgrQ7brqsbp/64GKJGhLSUeXTznXpCm6pdJ0lIRlx2KOb26UmH8hKSjW3i699r5s2zIdBQBS2obGPD1SO0NPtoZMRwF0Z8MgvVw7QrVtiTt7XMy2pNffk93RYToKXI7CxEl2TA2f5ai1M7GmBgSAVLOqeoj+uG2OVne2mo4Cl+qyo3q/s01/2DBH1a0ZpuPsUUtHQE2f5ZiOAUiiMHGWbWv05f9U8+Zs00kAIOWta8jXJR+foS6baYThvK3RNl3wwdnqjCZ2F+6WTVka/e+vunawda8x+N0RFCYAgJTV1uXXYe+cqupoi+kocJHHW9J12vvnmo4BJB0KEwPG/3yLWlYUmY4BAK5g25bOX7dYL7abTgI3+FnNaN2y4cikGFPa+lyRxv98s+kYySFmO7+5EIWJAZHPNsrf6M5fOAAwoaolU/dsP0SPtmSajoIUdmPdcP2jdqQaOpJj4oVAo63Ixk2mYwDdKEwMydwaVdW6fNMxAMA13q0p0WM10/VaR5fpKEgxUTumF9ulJ7ZOUVWSFL9Vn+QrYyvjr5BYKEwMSXvsNY39bZMamc4SAByzurZY/7l+kZpj9OvCwIjaMVVFW/W9D09WS2fAdJxeaWwNaexvGhT6y2umoyQP25bsmIObO3vWUJgYFHv7Aw07Z92O+cMBAI6ob0/T0e+eqdZYp+koSAGvdkhffe880zF6LRrzaNhZaxV750PTUYBdUJgAAFzHti2dtGax3uygOEH/3Vg3XP/xyVdNx4AD7Jjt+OZGFCaGxdo7lH5zrmobEnfxJQBIRU0dQf2y8igGxKNfrqseq79Vj1NbV/IsmlxTn6nMm3MU62ScFRIThYlpsaiCT7+uSIfPdBIAcJ2P6or0ZO1UrWjj4xC992hLpl7YPjppBrrvFGn3KbD8dSnGoHckJt6JE4RV51dLR3IMmgOAVPJuTYlu3HS0tkaaTUdBguuyo9oQadbP1h6TNFMC79TSEZCnnpug/ebowPfPNxeiMEkQo654VfY/c03HAABXqmzJ0skfnKMumzvJ2LOPujp16nvnJcXiibv4R65GLXnVdApgryhMAADQjtmKjn5/sT7qajEdBQnozoZB+uaar5uOAUMY/O4MCpMEMvShrYo8XGg6BgC4VnvEp//cdKKeZI0pfMFPqsfpkW3T1Rn1mo7SL9GHCjX04S2mY8ABt956q8rLyxUKhTRz5ky99NJLe93/hRde0MyZMxUKhTRixAjdfvvtDiXdPQqTBBJdu17ZnzJ1JQCY9GlDWI/XTqc4gSTprsYivVwzQtWtyTt7Zs76DkXWfWo6RnJLgjEmDzzwgL797W/rhz/8oVauXKlDDz1Uxx13nDZs2LDb/devX68FCxbo0EMP1cqVK3XVVVfp8ssvV0VFxf7+tPqNwiTB+Foi2rY5z3QMAHC1VdVDdM+2g+nW5WJddlSrO1v120+/otq2dNNx+m3b5jx5W5ge2A1uuOEGXXDBBbrwwgs1fvx43XjjjSorK9Ntt9222/1vv/12DR06VDfeeKPGjx+vCy+8UOeff76uv/56h5P/i6umZ7DtHf31IuqSErXr3stvaPSasOp+nWs6CQC42ictGTq/6mQ9NeFJ01FgwOZIi8754ExJyX1RP/p7qxWprTMdY68in/+Md16nJSKnrx13/kwaGxt7PB4MBhUMBnfZv7OzU2+++aZ+8IMf9Hh8/vz5evnll3d7jldeeUXz58/v8dgxxxyjO++8U11dXfL7nV+jx1WFSVNTkyTp73rKcJJ9qJF0sukQAABJog3bzf7XdABXaWpqUk5OjukYPQQCAQ0aNEh/r3T+2jEzM1NlZWU9Hrv66qt1zTXX7LJvdXW1otGoiouLezxeXFysysrK3R6/srJyt/tHIhFVV1erpKRk/15AP7iqMBk8eLA2btyorKwsWVYSTvXXD42NjSorK9PGjRuVnZ1tOg7ijH9v9+Df2j34t3YPt/5b27atpqYmDR482HSUXYRC/7+9OwuJunvAOP6MRq9aFmRYRGkSQYvF4BhSVFiJFl1kRBhIZVQkmKhDmxUUEUiLFEpaUlYkLVRkBAbaRRZUNKW2odHiUmmLXthCJI3zv0qav1Evr6Oncb4f8GLO/JRnOLg8nnN+E6D6+np1dPT9GWCXy9Xt79VfrZb87P+v/9XX+NP1vxrvKz5VTPz8/DR69GjTMYwYMmSIT/2Q83XMt+9grn0Hc+07fHGu/7aVkp8FBAQoIODvvhnG8OHD5e/v32115P37991WRX4YOXLkL68fMGCAQkJCei3r73D4HQAAAPBiAwcOlM1mU0VFhdt4RUWFZsyY8cvPmT59erfry8vLFR0dbeR8iUQxAQAAALye3W7X0aNHVVxcrNraWmVlZampqUmpqamSpOzsbK1YsaLr+tTUVDU2Nsput6u2tlbFxcU6duyYNmzYYOol+NZWLl/0zz//aMeOHX/ck4j+gfn2Hcy172CufQdzjZ5ISkpSW1ubdu3apZaWFkVGRqqsrEzh4eGSpJaWFrf3NImIiFBZWZmysrJ06NAhjRo1Snl5eVqyZImplyCL62++NxsAAAAAn8BWLgAAAADGUUwAAAAAGEcxAQAAAGAcxQQAAACAcRQTH/Xt2zdZrVZZLBbV1NSYjgMPa2ho0OrVqxUREaHAwECNGzdOO3bsMPLOtfC8goICRUREKCAgQDabTTdv3jQdCb0gJydH06ZNU3BwsEJDQ5WYmKinT5+ajoVelpOTI4vFoszMTNNRgD5HMfFRmzZt0qhRo0zHQC+pq6tTZ2enjhw5oidPnujAgQM6fPiwtm7dajoaeujcuXPKzMzUtm3bVF1drVmzZmnBggVut4BE/1BZWam0tDTduXNHFRUV+v79u+Lj4/XlyxfT0dBLHA6HioqKNHXqVNNRACO4XbAPunr1qux2uy5evKjJkyerurpaVqvVdCz0sn379qmwsFAvX740HQU9EBMTo6ioKBUWFnaNTZw4UYmJicrJyTGYDL3tw4cPCg0NVWVlpWbPnm06Djzs8+fPioqKUkFBgXbv3i2r1aqDBw+ajgX0KVZMfMy7d++0du1anTp1SkFBQabjoA+1t7dr2LBhpmOgBzo6OnT//n3Fx8e7jcfHx+vWrVuGUqGvtLe3SxLfx/1UWlqaFi5cqLi4ONNRAGN453cf4nK5lJKSotTUVEVHR6uhocF0JPSRFy9eKD8/X7m5uaajoAdaW1vldDo1YsQIt/ERI0bo7du3hlKhL7hcLtntds2cOVORkZGm48DDzp49q6qqKjkcDtNRAKNYMekHdu7cKYvF8tuPe/fuKT8/Xx8/flR2drbpyPiP/u1c/6y5uVnz58/X0qVLtWbNGkPJ4UkWi8Xtscvl6jaG/mX9+vV6+PChzpw5YzoKPOzVq1fKyMhQSUmJAgICTMcBjOKMST/Q2tqq1tbW314zduxYLVu2TFeuXHH7A8bpdMrf31/Jyck6efJkb0dFD/3buf7xy625uVlz5sxRTEyMTpw4IT8//hfhzTo6OhQUFKTz589r8eLFXeMZGRmqqalRZWWlwXToLenp6SotLdWNGzcUERFhOg48rLS0VIsXL5a/v3/XmNPplMVikZ+fn759++b2HNCfUUx8SFNTkz5+/Nj1uLm5WQkJCbpw4YJiYmI0evRog+ngaW/evNGcOXNks9lUUlLCL7Z+IiYmRjabTQUFBV1jkyZN0qJFizj83s+4XC6lp6fr0qVLun79usaPH286EnrBp0+f1NjY6Da2atUqTZgwQZs3b2brHnwKZ0x8SFhYmNvjwYMHS5LGjRtHKelnmpubFRsbq7CwMO3fv18fPnzoem7kyJEGk6Gn7Ha7li9frujoaE2fPl1FRUVqampSamqq6WjwsLS0NJ0+fVqXL19WcHBw1zmioUOHKjAw0HA6eEpwcHC38jFo0CCFhIRQSuBzKCZAP1ReXq7nz5/r+fPn3Uoni6TeLSkpSW1tbdq1a5daWloUGRmpsrIyhYeHm44GD/txS+jY2Fi38ePHjyslJaXvAwFAL2MrFwAAAADjOAkLAAAAwDiKCQAAAADjKCYAAAAAjKOYAAAAADCOYgIAAADAOIoJAAAAAOMoJgAAAACMo5gAAAAAMI5iAgAAAMA4igkAeAGn06kZM2ZoyZIlbuPt7e0aM2aMtm/fbigZAACeYXG5XC7TIQAAf/bs2TNZrVYVFRUpOTlZkrRixQo9ePBADodDAwcONJwQAID/jmICAF4kLy9PO3fu1OPHj+VwOLR06VLdvXtXVqvVdDQAAHqEYgIAXsTlcmnu3Lny9/fXo0ePlJ6ezjYuAEC/QDEBAC9TV1eniRMnasqUKaqqqtKAAQNMRwIAoMc4/A4AXqa4uFhBQUGqr6/X69evTccBAMAjWDEBAC9y+/ZtzZ49W1evXtXevXvldDp17do1WSwW09EAAOgRVkwAwEt8/fpVK1eu1Lp16xQXF6ejR4/K4XDoyJEjpqMBANBjFBMA8BJbtmxRZ2en9uzZI0kKCwtTbm6uNm7cqIaGBrPhAADoIbZyAYAXqKys1Lx583T9+nXNnDnT7bmEhAR9//6dLV0AAK9GMQEAAABgHFu5AAAAABhHMQEAAABgHMUEAAAAgHEUEwAAAADGUUwAAAAAGEcxAQAAAGAcxQQAAACAcRQTAAAAAMZRTAAAAAAYRzEBAAAAYBzFBAAAAIBx/wOMs+I/926JVAAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 1000x800 with 2 Axes>"
       ]
@@ -201,8 +201,8 @@
     "group = ObjectGroup([sphere2, sphere1, block])\n",
     "\n",
     "# Create a grid of points\n",
-    "x = np.linspace(-1, 1, 1000)\n",
-    "y = np.linspace(-1, 1, 1000)\n",
+    "x = np.linspace(-1, 1, 500)\n",
+    "y = np.linspace(-1, 1, 500)\n",
     "xx, yy = np.meshgrid(x, y)\n",
     "points = np.array([xx.flatten(), yy.flatten(), np.zeros_like(xx.flatten())]).T\n",
     "\n",

From 1c805040297a36b84f1a710a3c297e9a1c7c28e4 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Fri, 15 Nov 2024 00:18:00 -0800
Subject: [PATCH 27/37] Add python wrappers for vecterized queries of materials
 in group.

Add tests as well.
---
 python/ctlgeom.py      |  44 ++++++++++++-
 python/libctlgeom.i    |   7 +-
 python/test.ipynb      | 144 +++++++++++++++++++++++++++++------------
 python/test_ctlgeom.py |  96 +++++++++++++++++++++++++--
 4 files changed, 241 insertions(+), 50 deletions(-)

diff --git a/python/ctlgeom.py b/python/ctlgeom.py
index 30a3a7b..7c5dbeb 100644
--- a/python/ctlgeom.py
+++ b/python/ctlgeom.py
@@ -358,7 +358,7 @@ def _create_tree_object(self) -> Literal["geom.geom_box_tree"]:
         """Create a tree object from the group of geometric objects."""
         return geom.create_geom_box_tree0(self.geom_list, self.bounding_box)
 
-    def material_at(self, point: Tuple[float, float, float]) -> MATERIAL_TYPE:
+    def material_at_point(self, point: Tuple[float, float, float]) -> MATERIAL_TYPE:
         """Query the material at a point.
 
         Args:
@@ -366,6 +366,48 @@ def material_at(self, point: Tuple[float, float, float]) -> MATERIAL_TYPE:
         """
         return geom.material_of_point_in_tree(make_vector3(*point), self.geom_box_tree)
 
+    def material_at_numpy_points(self, points: np.ndarray) -> List[MATERIAL_TYPE]:
+        """Query the material at a numpy array of points. Default material is numpy.nan.
+
+        Args:
+            points: A numpy array of points with shape (n_points, 3).
+
+        Returns:
+            A list of materials corresponding to the points.
+        """
+        if points.ndim != 2:
+            raise ValueError("Points must be a 2D numpy array.")
+        if points.shape[1] != 3:
+            raise ValueError("Points must have shape (n_points, 3).")
+        return geom.material_of_numpy_points_in_tree(points, self.geom_box_tree)
+
+    def material_on_grid(
+        self,
+        xx: np.ndarray,
+        yy: np.ndarray,
+        zz: np.ndarray,
+        default_material: MATERIAL_TYPE = 0,
+    ) -> np.ndarray:
+        """Query the material on a grid.
+
+        Args:
+            xx: A numpy array of x-coordinates.
+            yy: A numpy array of y-coordinates.
+            zz: A numpy array of z-coordinates.
+            default_material: The material to return for points outside of any object. Defaults to 0.
+            dtype: The data type of the returned array. Defaults to float.
+
+        Returns:
+            A numpy array of materials with the same shape as xx, yy, and zz.
+        """
+        if not (xx.shape == yy.shape == zz.shape):
+            raise ValueError("xx, yy, and zz must have the same shape.")
+        points = np.vstack((xx.ravel(), yy.ravel(), zz.ravel())).T
+        return np.nan_to_num(
+            np.array(self.material_at_numpy_points(points)).reshape(xx.shape),
+            nan=default_material,
+        )
+
     def __del__(self):
         # Clean up the tree when the object is destroyed
         geom.destroy_geom_box_tree(self.geom_box_tree)
diff --git a/python/libctlgeom.i b/python/libctlgeom.i
index bc71939..a8b1aaa 100644
--- a/python/libctlgeom.i
+++ b/python/libctlgeom.i
@@ -116,6 +116,9 @@
 
 /* Add the new function declaration */
 %inline %{
+#include <numpy/arrayobject.h>
+#include <numpy/npy_math.h>
+
 PyObject* material_of_numpy_points_in_tree(double* points, int n_points, int dims, geom_box_tree t) {
     if (dims != 3) {
         PyErr_SetString(PyExc_ValueError, "Input array must have 3 columns (x,y,z)");
@@ -128,8 +131,8 @@ PyObject* material_of_numpy_points_in_tree(double* points, int n_points, int dim
         MATERIAL_TYPE material = material_of_point_in_tree(p, t);
         
         if (material == NULL) {
-            Py_INCREF(Py_None);
-            PyList_SET_ITEM(result, i, Py_None);
+            PyObject* nan = PyFloat_FromDouble(NPY_NAN);  // Create numpy.nan
+            PyList_SET_ITEM(result, i, nan);
         } else {
             PyObject* mat = (PyObject*)material;
             Py_XINCREF(mat);
diff --git a/python/test.ipynb b/python/test.ipynb
index e6be5cb..5a17abd 100644
--- a/python/test.ipynb
+++ b/python/test.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
@@ -24,7 +24,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -33,7 +33,7 @@
        "((-1.0, -0.5, -1.0), (1.0, 1.5, 1.0))"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -44,7 +44,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -62,7 +62,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -101,28 +101,28 @@
     "sphere3 = Sphere(\"foo\", (3, 0, 0), 0.1)\n",
     "group = ObjectGroup([sphere1, sphere2, sphere3])\n",
     "\n",
-    "print(group.material_at((1, 0, 0)))\n",
-    "print(group.material_at((2, 0, 0)))\n",
-    "print(group.material_at((3, 0, 0)))"
+    "print(group.material_at_point((1, 0, 0)))\n",
+    "print(group.material_at_point((2, 0, 0)))\n",
+    "print(group.material_at_point((3, 0, 0)))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.2274618148803711 seconds\n"
+      "Time taken: 0.33043789863586426 seconds\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1000x800 with 2 Axes>"
+       "<Figure size 1200x500 with 4 Axes>"
       ]
      },
      "metadata": {},
@@ -134,9 +134,9 @@
     "import matplotlib.pyplot as plt\n",
     "import time \n",
     "\n",
-    "sphere1 = Sphere(material=1, center=(0, -0.5, 0), radius=0.5)\n",
-    "sphere2 = Sphere(material=2, center=(0, 0.5, 0), radius=1)\n",
-    "block = Block(material=3, center=(0.5, 0.5, 0), e1=(1, 1, 0), e2=(1, -1, 0), e3=(0, 0, 1), size=(1, 1, 1))\n",
+    "sphere1 = Sphere(material=1 + 3j, center=(0, -0.5, 0), radius=0.5)\n",
+    "sphere2 = Sphere(material=2 + 2j, center=(0, 0.5, 0), radius=1)\n",
+    "block = Block(material=3 + 1j, center=(0.5, 0.5, 0), e1=(1, 1, 0), e2=(1, -1, 0), e3=(0, 0, 1), size=(1, 1, 1))\n",
     "group = ObjectGroup([sphere2, sphere1, block])\n",
     "\n",
     "# Create a grid of points\n",
@@ -145,8 +145,8 @@
     "xx, yy = np.meshgrid(x, y)\n",
     "\n",
     "def get_epsilon(x, y):\n",
-    "    mat = group.material_at((x, y, 0))\n",
-    "    return 0 if mat is None else mat\n",
+    "    mat = group.material_at_point((x, y, 0))\n",
+    "    return 0+0j if mat is None else mat\n",
     "point_in_object_vec = np.vectorize(get_epsilon)\n",
     "\n",
     "start_time = time.time()\n",
@@ -154,33 +154,35 @@
     "end_time = time.time()\n",
     "print(f\"Time taken: {end_time - start_time} seconds\")\n",
     "\n",
-    "# Create the plot\n",
-    "plt.figure(figsize=(10, 8))\n",
-    "plt.imshow(material_map, cmap='viridis', extent=[-5, 5, -5, 5])\n",
+    "plt.figure(figsize=(12, 5))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(material_map.real, cmap='viridis', extent=[-5, 5, -5, 5])\n",
     "plt.colorbar(label='Material')\n",
-    "plt.title('Cool Shapes')\n",
-    "plt.xlabel('X')\n",
-    "plt.ylabel('Y')\n",
+    "plt.title('Real')\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(material_map.imag, cmap='viridis', extent=[-5, 5, -5, 5])\n",
+    "plt.colorbar(label='Material')\n",
+    "plt.title('Imaginary')\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.01887798309326172 seconds\n"
+      "Time taken: 0.0185089111328125 seconds\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1000x800 with 2 Axes>"
+       "<Figure size 1200x500 with 4 Axes>"
       ]
      },
      "metadata": {},
@@ -195,44 +197,44 @@
     "\n",
     "# This is the same as the previous example, but using the new function\n",
     "\n",
-    "sphere1 = Sphere(material=1, center=(0, -0.5, 0), radius=0.5)\n",
-    "sphere2 = Sphere(material=2, center=(0, 0.5, 0), radius=1)\n",
-    "block = Block(material=3, center=(0.5, 0.5, 0), e1=(1, 1, 0), e2=(1, -1, 0), e3=(0, 0, 1), size=(1, 1, 1))\n",
+    "sphere1 = Sphere(material=1+3j, center=(0, -0.5, 0), radius=0.5)\n",
+    "sphere2 = Sphere(material=2+2j, center=(0, 0.5, 0), radius=1)\n",
+    "block = Block(material=3+1j, center=(0.5, 0.5, 0), e1=(1, 1, 0), e2=(1, -1, 0), e3=(0, 0, 1), size=(1, 1, 1))\n",
     "group = ObjectGroup([sphere2, sphere1, block])\n",
     "\n",
     "# Create a grid of points\n",
     "x = np.linspace(-1, 1, 500)\n",
     "y = np.linspace(-1, 1, 500)\n",
     "xx, yy = np.meshgrid(x, y)\n",
-    "points = np.array([xx.flatten(), yy.flatten(), np.zeros_like(xx.flatten())]).T\n",
+    "zz = np.zeros_like(xx)\n",
     "\n",
     "start_time = time.time()\n",
-    "material_map = geom.material_of_numpy_points_in_tree(points, group.geom_box_tree)\n",
-    "material_map = np.array(material_map, dtype=float).reshape(xx.shape)\n",
-    "material_map = np.nan_to_num(material_map)\n",
+    "material_map = group.material_on_grid(xx, yy, zz)\n",
     "end_time = time.time()\n",
     "print(f\"Time taken: {end_time - start_time} seconds\")\n",
     "\n",
-    "# Create the plot\n",
-    "plt.figure(figsize=(10, 8))\n",
-    "plt.imshow(material_map, cmap='viridis', extent=[-5, 5, -5, 5])\n",
+    "plt.figure(figsize=(12, 5))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(material_map.real, cmap='viridis', extent=[-5, 5, -5, 5])\n",
     "plt.colorbar(label='Material')\n",
-    "plt.title('Cool Shapes')\n",
-    "plt.xlabel('X')\n",
-    "plt.ylabel('Y')\n",
+    "plt.title('Real')\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(material_map.imag, cmap='viridis', extent=[-5, 5, -5, 5])\n",
+    "plt.colorbar(label='Material')\n",
+    "plt.title('Imaginary')\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Time taken: 0.23345279693603516 seconds\n"
+      "Time taken: 0.23392677307128906 seconds\n"
      ]
     },
     {
@@ -265,7 +267,7 @@
     "xx, yy = np.meshgrid(x, y)\n",
     "\n",
     "def get_epsilon(x, y):\n",
-    "    mat = group.material_at((x, y, 0))\n",
+    "    mat = group.material_at_point((x, y, 0))\n",
     "    return 0 if mat is None else mat\n",
     "point_in_object_vec = np.vectorize(get_epsilon)\n",
     "\n",
@@ -283,6 +285,62 @@
     "plt.ylabel('Y')\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time taken: 0.03206801414489746 seconds\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "np.random.seed(42)\n",
+    "spheres = []\n",
+    "for _ in range(3000):\n",
+    "    x = np.random.uniform(-5, 5)\n",
+    "    y = np.random.uniform(-5, 5)\n",
+    "    radius = np.random.uniform(0.05, 0.2)\n",
+    "    material = np.random.randint(1, 6)\n",
+    "    \n",
+    "    sphere = Sphere(material=material, center=(x, y, 0), radius=radius)\n",
+    "    spheres.append(sphere)\n",
+    "\n",
+    "group = ObjectGroup(spheres)\n",
+    "\n",
+    "x = np.linspace(-5, 5, 500)\n",
+    "y = np.linspace(-5, 5, 500)\n",
+    "xx, yy = np.meshgrid(x, y)\n",
+    "\n",
+    "start_time = time.time()\n",
+    "material_map = group.material_on_grid(xx, yy, np.zeros_like(xx))\n",
+    "end_time = time.time()\n",
+    "print(f\"Time taken: {end_time - start_time} seconds\")\n",
+    "\n",
+    "# Create the plot\n",
+    "plt.figure(figsize=(10, 8))\n",
+    "plt.imshow(material_map, cmap='viridis', extent=[-5, 5, -5, 5])\n",
+    "plt.colorbar(label='Material')\n",
+    "plt.title('3000 Random Spheres')\n",
+    "plt.xlabel('X')\n",
+    "plt.ylabel('Y')\n",
+    "plt.show()"
+   ]
   }
  ],
  "metadata": {
diff --git a/python/test_ctlgeom.py b/python/test_ctlgeom.py
index 0d65073..626b77f 100644
--- a/python/test_ctlgeom.py
+++ b/python/test_ctlgeom.py
@@ -581,7 +581,7 @@ def test_creation(self):
         assert group.objects[0] == sphere
         assert group.objects[1] == cylinder
 
-    def test_material_at(self):
+    def test_material_at_point(self):
         """Test getting material at different points in an ObjectGroup."""
         sphere = Sphere(material="sphere_mat", center=(0, 0, 0), radius=1.0)
         cylinder = Cylinder(
@@ -594,6 +594,94 @@ def test_material_at(self):
 
         group = ObjectGroup(objects=[sphere, cylinder])
 
-        assert group.material_at((0, 0, 0)) == "sphere_mat"
-        assert group.material_at((42, 0, 0)) == "cylinder_mat"
-        assert group.material_at((99, 0, 0)) is None
+        assert group.material_at_point((0, 0, 0)) == "sphere_mat"
+        assert group.material_at_point((42, 0, 0)) == "cylinder_mat"
+        assert group.material_at_point((99, 0, 0)) is None
+
+    def test_material_at_numpy_points(self):
+        """Test getting materials at multiple points using numpy array."""
+        sphere = Sphere(material="sphere_mat", center=(0, 0, 0), radius=1.0)
+        cylinder = Cylinder(
+            material="cylinder_mat",
+            center=(2, 0, 0),
+            radius=1.0,
+            height=2.0,
+            axis=(0, 0, 1),
+        )
+
+        group = ObjectGroup(objects=[sphere, cylinder])
+
+        # Create a numpy array of test points
+        points = np.array(
+            [
+                [0, 0, 0],  # Inside sphere
+                [2, 0, 0],  # Inside cylinder
+                [5, 5, 5],  # Outside both
+                [0.5, 0, 0],  # Inside sphere
+                [2, 0.5, 0.5],  # Inside cylinder
+            ]
+        )
+
+        materials = group.material_at_numpy_points(points)
+
+        assert materials[0] == "sphere_mat"
+        assert materials[1] == "cylinder_mat"
+        assert np.isnan(materials[2])
+        assert materials[3] == "sphere_mat"
+        assert materials[4] == "cylinder_mat"
+
+    def test_material_at_numpy_points_invalid_input(self):
+        """Test material_at_numpy_points with invalid input shapes."""
+        group = ObjectGroup(
+            objects=[Sphere(material="test", center=(0, 0, 0), radius=1.0)]
+        )
+
+        # Test with wrong number of dimensions
+        with pytest.raises(ValueError, match="Points must be a 2D numpy array"):
+            group.material_at_numpy_points(np.array([1, 2, 3]))
+
+        # Test with wrong second dimension
+        with pytest.raises(ValueError, match="Points must have shape"):
+            group.material_at_numpy_points(np.array([[1, 2], [3, 4]]))
+
+    def test_material_on_grid(self):
+        """Test getting materials on a 3D grid."""
+        sphere = Sphere(material=1.0, center=(0, 0, 0), radius=1.0)
+        group = ObjectGroup(objects=[sphere])
+
+        # Create a simple 3x3x3 grid
+        x = np.linspace(-2, 2, 3)
+        y = np.linspace(-2, 2, 3)
+        z = np.linspace(-2, 2, 3)
+        xx, yy, zz = np.meshgrid(x, y, z)
+
+        materials = group.material_on_grid(xx, yy, zz, default_material=0.0)
+
+        # Check shape
+        assert materials.shape == (3, 3, 3)
+
+        # Center point should be inside sphere (material 1.0)
+        assert materials[1, 1, 1] == 1.0
+
+        # Corner points should be outside sphere (material 0.0)
+        assert materials[0, 0, 0] == 0.0
+        assert materials[0, 0, 2] == 0.0
+        assert materials[0, 2, 0] == 0.0
+        assert materials[2, 0, 0] == 0.0
+        assert materials[2, 2, 2] == 0.0
+
+    def test_material_on_grid_invalid_input(self):
+        """Test material_on_grid with invalid input shapes."""
+        group = ObjectGroup(
+            objects=[Sphere(material=1.0, center=(0, 0, 0), radius=1.0)]
+        )
+
+        # Create mismatched grid shapes
+        x = np.linspace(-2, 2, 3)
+        y = np.linspace(-2, 2, 4)
+        z = np.linspace(-2, 2, 3)
+        xx, yy, zz = np.meshgrid(x, y, z)
+
+        # Test with mismatched shapes
+        with pytest.raises(ValueError, match="xx, yy, and zz must have the same shape"):
+            group.material_on_grid(xx[:2], yy, zz)

From cc12467a986341cadf9d6a3b185bca9879c85213 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Fri, 15 Nov 2024 00:18:33 -0800
Subject: [PATCH 28/37] update readme

---
 python/README.md | 73 +++++++++++++++++++++++++-----------------------
 1 file changed, 38 insertions(+), 35 deletions(-)

diff --git a/python/README.md b/python/README.md
index 133a728..4e4bf56 100644
--- a/python/README.md
+++ b/python/README.md
@@ -134,55 +134,58 @@ low, high = sphere.bounding_box()
 group = ObjectGroup([sphere, cylinder, block])
 
 # Query material at a point
-material = group.material_at(point)
+material = group.material_at_point(point)
+
+# Query the material at a numpy array of points. (Must faster than python loops!)
+material = group.material_at_numpy_points(point)
+
+# Query the material at a cartesian grid
+material = group.material_on_grid(xx, yy, zz)
 
 # Display debug information
 sphere.debug_info()
 ```
 
-### Vectorized Operations with numpy
+### Vectorized Operations
 
 ```python
 import numpy as np
 import matplotlib.pyplot as plt
-import time
+import time 
 
-# Create some sample geometry
-sphere1 = Sphere(material=1, center=(0, -0.5, 0), radius=0.5)
-sphere2 = Sphere(material=2, center=(0, 0.5, 0), radius=1)
-block = Block(
-    material=3,
-    center=(0.5, 0.5, 0),
-    e1=(1, 1, 0),
-    e2=(1, -1, 0),
-    e3=(0, 0, 1),
-    size=(1, 1, 1)
-)
+sphere1 = Sphere(material=1+3j, center=(0, -0.5, 0), radius=0.5)
+sphere2 = Sphere(material=2+2j, center=(0, 0.5, 0), radius=1)
+block = Block(material=3+1j, center=(0.5, 0.5, 0), e1=(1, 1, 0), e2=(1, -1, 0), e3=(0, 0, 1), size=(1, 1, 1))
 group = ObjectGroup([sphere2, sphere1, block])
 
 # Create a grid of points
-x = np.linspace(-2, 2, 200)
-y = np.linspace(-2, 2, 200)
+x = np.linspace(-1, 1, 500)
+y = np.linspace(-1, 1, 500)
 xx, yy = np.meshgrid(x, y)
-
-# Vectorize the material lookup function
-def get_material(x, y):
-    mat = group.material_at((x, y, 0))
-    return 0 if mat is None else mat
-
-material_lookup = np.vectorize(get_material)
-
-# Generate material map
-material_map = material_lookup(xx, yy)
-
-# Visualize the result
-plt.figure(figsize=(8, 8))
-plt.imshow(material_map, extent=[-2, 2, -2, 2], origin='lower')
-plt.colorbar(label='Material Index')
-plt.title('Material Distribution')
-plt.xlabel('X')
-plt.ylabel('Y')
+zz = np.zeros_like(xx)
+
+start_time = time.time()
+material_map = group.material_on_grid(xx, yy, zz)
+end_time = time.time()
+print(f"Time taken: {end_time - start_time} seconds")
+
+plt.figure(figsize=(12, 5))
+plt.subplot(1, 2, 1)
+plt.imshow(material_map.real, cmap='viridis', extent=[-5, 5, -5, 5])
+plt.colorbar(label='Material')
+plt.title('Real')
+plt.subplot(1, 2, 2)
+plt.imshow(material_map.imag, cmap='viridis', extent=[-5, 5, -5, 5])
+plt.colorbar(label='Material')
+plt.title('Imaginary')
 plt.show()
 ```
 
-Note: The `np.vectorize` function allows us to efficiently apply the material lookup across a large array of points. While not as fast as true vectorization (it still calls Python code for each point), it provides a convenient way to process large arrays of coordinates without explicit loops.
\ No newline at end of file
+Note: The `np.vectorize` function allows us to efficiently apply the material lookup across a large array of points. While not as fast as true vectorization (it still calls Python code for each point), it provides a convenient way to process large arrays of coordinates without explicit loops.
+
+
+### Running tests
+First, make sure pytest is installed. You can install it by `pip install pytest`.
+```bash
+pytest test_ctlgeom.py -v
+```
\ No newline at end of file

From 82c54e8eb0332d1c266631eaed0e0beff4217be8 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Fri, 15 Nov 2024 00:26:17 -0800
Subject: [PATCH 29/37] rename test.ipynb to demo.ipynb

---
 python/{test.ipynb => demo.ipynb} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename python/{test.ipynb => demo.ipynb} (100%)

diff --git a/python/test.ipynb b/python/demo.ipynb
similarity index 100%
rename from python/test.ipynb
rename to python/demo.ipynb

From 63855687a10a1f38c93f4695a5e2d9af44a98a3e Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Fri, 15 Nov 2024 17:54:37 -0500
Subject: [PATCH 30/37] automake-ified python build

---
 .gitignore                               |  14 +-
 configure.ac                             |  56 +++++++
 python/build.sh                          |  22 ---
 utils/Makefile.am                        |   4 +
 utils/ctlgeom-types-swig.h               | 182 -----------------------
 utils/ctlgeom.h                          |  11 --
 utils/python/Makefile.am                 |  36 +++++
 {python => utils/python}/README.md       |   0
 {python => utils/python}/ctlgeom.py      |   0
 {python => utils/python}/demo.ipynb      |   0
 {python => utils/python}/libctlgeom.i    |  26 ++--
 {python => utils/python}/numpy.i         |   0
 {python => utils/python}/setup.py        |   0
 {python => utils/python}/test_ctlgeom.py |   0
 14 files changed, 116 insertions(+), 235 deletions(-)
 delete mode 100755 python/build.sh
 delete mode 100644 utils/ctlgeom-types-swig.h
 create mode 100644 utils/python/Makefile.am
 rename {python => utils/python}/README.md (100%)
 rename {python => utils/python}/ctlgeom.py (100%)
 rename {python => utils/python}/demo.ipynb (100%)
 rename {python => utils/python}/libctlgeom.i (93%)
 rename {python => utils/python}/numpy.i (100%)
 rename {python => utils/python}/setup.py (100%)
 rename {python => utils/python}/test_ctlgeom.py (100%)

diff --git a/.gitignore b/.gitignore
index 9d9e643..2034d0f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,6 +38,7 @@ missing
 py-compile
 compile
 test-driver
+.DS_Store
 
 # other generated files
 example.scm
@@ -55,10 +56,9 @@ nlopt-constants.scm
 utils/test-prism
 *.dat
 
-/python/__pycache__
-/python/build
-/python/libctlgeom.egg-info
-/python/_libctlgeom.cpython*
-/python/libctlgeom_wrap.c
-/python/libctlgeom.py
-/python/todo.md
\ No newline at end of file
+utils/python/__pycache__
+utils/python/build
+utils/python/libctlgeom.egg-info
+utils/python/_libctlgeom.cpython*
+utils/python/libctlgeom_wrap.c
+utils/python/libctlgeom.py
diff --git a/configure.ac b/configure.ac
index f847739..13d4bc5 100644
--- a/configure.ac
+++ b/configure.ac
@@ -241,6 +241,57 @@ fi
 AC_PROG_EGREP
 AC_CHECK_HEADERS(nlopt.h)
 
+
+##############################################################################
+# checks for python
+##############################################################################
+
+AC_ARG_WITH(python,
+	[AS_HELP_STRING([--without-python],[compile without Python interface])],
+        with_python=$withval,with_python=yes)
+
+AC_CHECK_PROG(SWIG, swig, swig, echo)
+if test "$USE_MAINTAINER_MODE" = yes && (test "x$with_python" = "xyes" || test "x$with_scheme" = "xyes") && test "x$SWIG" = xecho; then
+  AC_MSG_ERROR([SWIG not found; configure --without-python --without-scheme or use a release tarball])
+fi
+
+if test "x$with_python" = xno; then
+  have_python=no
+else
+  if test "$enable_shared" = no; then
+     AC_MSG_WARN([Python interface requires --enable-shared; disabling])
+     have_python=no
+  else
+    AM_PATH_PYTHON([],[have_python=yes],[have_python=no])
+    if test $have_python = yes; then
+      AC_MSG_CHECKING([for Python include directory])
+      pinc=`echo "from sysconfig import get_paths; print(get_paths()[['include']])" | $PYTHON - 2>/dev/null`
+      AC_MSG_RESULT([${pinc:-unknown}])
+      test -n "$pinc" && PYTHON_INCLUDES="-I$pinc"
+      save_CPPFLAGS=$CPPFLAGS
+      CPPFLAGS="$CPPFLAGS $PYTHON_INCLUDES"
+      AC_CHECK_HEADER([Python.h], [], [AC_MSG_WARN([disabling Python wrappers])
+                                       have_python=no])
+
+      if test $have_python = yes; then
+        AC_MSG_CHECKING([for Numpy include directory])
+        pinc=`echo "import numpy; print (numpy.get_include())" | $PYTHON - 2>/dev/null`
+        AC_MSG_RESULT([${pinc:-unknown}])
+        test -n "$pinc" && PYTHON_INCLUDES="$PYTHON_INCLUDES -I$pinc"
+        CPPFLAGS="$save_CPPFLAGS $PYTHON_INCLUDES"
+        AC_CHECK_HEADER([numpy/arrayobject.h],[],[
+          AC_MSG_WARN([disabling Python wrappers])
+          have_python=no],[#include <Python.h>])
+      fi
+
+      CPPFLAGS=$save_CPPFLAGS
+    fi # have_python
+  fi # enabled_shared
+fi # with_python
+
+AC_SUBST(PYTHON_INCLUDES)
+AM_CONDITIONAL(WITH_PYTHON, test x"$have_python" = "xyes")
+
 ###########################################################################
 
 libctl_dir=$srcdir
@@ -259,4 +310,9 @@ AC_CHECK_LIB(gen, basename)
 
 AC_CONFIG_FILES([Makefile src/Makefile utils/Makefile examples/Makefile examples/example.scm])
 AC_CONFIG_FILES([utils/gen-ctl-io], [chmod u+x utils/gen-ctl-io])
+
+if test "x$with_python" = xyes; then
+   AC_CONFIG_FILES([utils/python/Makefile])
+fi
+
 AC_OUTPUT
diff --git a/python/build.sh b/python/build.sh
deleted file mode 100755
index c1384b2..0000000
--- a/python/build.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/bash
-
-# Define local include paths relative to script location
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-LOCAL_INCLUDES="-I$SCRIPT_DIR/../src -I$SCRIPT_DIR/../utils"
-
-# Check if running in a conda environment
-if [ -n "${CONDA_PREFIX}" ]; then
-    echo "Using Conda environment at: $CONDA_PREFIX"
-    PYTHON_INCLUDE=$($CONDA_PREFIX/bin/python3 -c "from sysconfig import get_paths; print(get_paths()['include'])")
-    export CFLAGS="-I$SCRIPT_DIR/../src -I$SCRIPT_DIR/../utils -I$PYTHON_INCLUDE"
-    swig -python $LOCAL_INCLUDES -I"$PYTHON_INCLUDE" libctlgeom.i
-    $CONDA_PREFIX/bin/python3 setup.py build_ext --inplace
-    $CONDA_PREFIX/bin/pip install .
-else
-    echo "Using system Python"
-    PYTHON_INCLUDE=$(python3 -c "from sysconfig import get_paths; print(get_paths()['include'])")
-    export CFLAGS="-I$SCRIPT_DIR/../src -I$SCRIPT_DIR/../utils -I$PYTHON_INCLUDE"
-    swig -python $LOCAL_INCLUDES -I"$PYTHON_INCLUDE" libctlgeom.i
-    python3 setup.py build_ext --inplace
-    pip install .
-fi
\ No newline at end of file
diff --git a/utils/Makefile.am b/utils/Makefile.am
index 1008480..97f51e2 100644
--- a/utils/Makefile.am
+++ b/utils/Makefile.am
@@ -1,3 +1,7 @@
+if WITH_PYTHON
+SUBDIRS = python
+endif
+
 bin_SCRIPTS = gen-ctl-io
 include_HEADERS = ctlgeom.h
 nodist_include_HEADERS = ctlgeom-types.h
diff --git a/utils/ctlgeom-types-swig.h b/utils/ctlgeom-types-swig.h
deleted file mode 100644
index 42843fd..0000000
--- a/utils/ctlgeom-types-swig.h
+++ /dev/null
@@ -1,182 +0,0 @@
-/* This file is used to define the types for the SWIG bindings */
-
-#ifndef CTL_IO_H
-#define CTL_IO_H
-
-#include <ctl-math.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif				/* __cplusplus */
-
-	/******* Type declarations *******/
-
-	typedef struct geometric_object_struct {
-		void*		material;
-		vector3		center;
-		enum {
-			GEOMETRIC_OBJECT_SELF, PRISM, BLOCK, SPHERE, CYLINDER, COMPOUND_GEOMETRIC_OBJECT
-		}		which_subclass;
-		union {
-			struct prism_struct *prism_data;
-			struct block_struct *block_data;
-			struct sphere_struct *sphere_data;
-			struct cylinder_struct *cylinder_data;
-			struct compound_geometric_object_struct *compound_geometric_object_data;
-		}		subclass;
-	}		geometric_object;
-
-	typedef struct {
-		int		num_items;
-		geometric_object *items;
-	} geometric_object_list;
-
-	typedef struct compound_geometric_object_struct {
-		geometric_object_list component_objects;
-	}		compound_geometric_object;
-
-	typedef struct cylinder_struct {
-		vector3		axis;
-		number		radius;
-		number		height;
-		enum {
-			CYLINDER_SELF, WEDGE, CONE
-		}		which_subclass;
-		union {
-			struct wedge_struct *wedge_data;
-			struct cone_struct *cone_data;
-		}		subclass;
-	}		cylinder;
-
-	typedef struct cone_struct {
-		number		radius2;
-	}		cone;
-
-	typedef struct wedge_struct {
-		number		wedge_angle;
-		vector3		wedge_start;
-		vector3		e1;
-		vector3		e2;
-	}		wedge;
-
-	typedef struct sphere_struct {
-		number		radius;
-	}		sphere;
-
-	typedef struct block_struct {
-		vector3		e1;
-		vector3		e2;
-		vector3		e3;
-		vector3		size;
-		matrix3x3	projection_matrix;
-		enum {
-			BLOCK_SELF, ELLIPSOID
-		}		which_subclass;
-		union {
-			struct ellipsoid_struct *ellipsoid_data;
-		}		subclass;
-	}		block;
-
-	typedef struct {
-		int		num_items;
-		vector3	       *items;
-	} vector3_list;
-
-	typedef struct {
-		int		num_items;
-		number	       *items;
-	} number_list;
-
-	typedef struct prism_struct {
-		vector3_list	vertices;
-		number		height;
-		vector3		axis;
-		number		sidewall_angle;
-		vector3_list	vertices_p;
-		vector3_list	top_polygon_diff_vectors_p;
-		vector3_list	top_polygon_diff_vectors_scaled_p;
-		vector3_list	vertices_top_p;
-		vector3_list	vertices_top;
-		vector3		centroid;
-		number_list	workspace;
-		matrix3x3	m_c2p;
-		matrix3x3	m_p2c;
-	}		prism;
-
-	typedef struct ellipsoid_struct {
-		vector3		inverse_semi_axes;
-	}		ellipsoid;
-
-	typedef struct lattice_struct {
-		vector3		basis1;
-		vector3		basis2;
-		vector3		basis3;
-		vector3		size;
-		vector3		basis_size;
-		vector3		b1;
-		vector3		b2;
-		vector3		b3;
-		matrix3x3	basis;
-		matrix3x3	metric;
-	}		lattice;
-
-	/******* Input variables *******/
-	extern integer dimensions;
-	extern void* default_material;
-	extern vector3 geometry_center;
-	extern lattice geometry_lattice;
-	extern geometric_object_list geometry;
-	extern boolean ensure_periodicity;
-
-	/******* Output variables *******/
-
-	/******* class copy function prototypes *******/
-
-	extern void	lattice_copy(const lattice * o0, lattice * o);
-	extern void	ellipsoid_copy(const ellipsoid * o0, ellipsoid * o);
-	extern void	prism_copy(const prism * o0, prism * o);
-	extern void	block_copy(const block * o0, block * o);
-	extern void	sphere_copy(const sphere * o0, sphere * o);
-	extern void	wedge_copy(const wedge * o0, wedge * o);
-	extern void	cone_copy(const cone * o0, cone * o);
-	extern void	cylinder_copy(const cylinder * o0, cylinder * o);
-	extern void	compound_geometric_object_copy(const compound_geometric_object * o0, compound_geometric_object * o);
-	extern void	geometric_object_copy(const geometric_object * o0, geometric_object * o);
-
-	/******* class equal function prototypes *******/
-
-	extern boolean lattice_equal(const lattice * o0, const lattice * o);
-	extern boolean ellipsoid_equal(const ellipsoid * o0, const ellipsoid * o);
-	extern boolean prism_equal(const prism * o0, const prism * o);
-	extern boolean block_equal(const block * o0, const block * o);
-	extern boolean sphere_equal(const sphere * o0, const sphere * o);
-	extern boolean wedge_equal(const wedge * o0, const wedge * o);
-	extern boolean cone_equal(const cone * o0, const cone * o);
-	extern boolean cylinder_equal(const cylinder * o0, const cylinder * o);
-	extern boolean compound_geometric_object_equal(const compound_geometric_object * o0, const compound_geometric_object * o);
-	extern boolean geometric_object_equal(const geometric_object * o0, const geometric_object * o);
-
-	/******* class destruction function prototypes *******/
-
-	extern void	lattice_destroy(lattice o);
-	extern void	ellipsoid_destroy(ellipsoid o);
-	extern void	prism_destroy(prism o);
-	extern void	block_destroy(block o);
-	extern void	sphere_destroy(sphere o);
-	extern void	wedge_destroy(wedge o);
-	extern void	cone_destroy(cone o);
-	extern void	cylinder_destroy(cylinder o);
-	extern void	compound_geometric_object_destroy(compound_geometric_object o);
-	extern void	geometric_object_destroy(geometric_object o);
-
-
-#ifdef __cplusplus
-}				/* extern "C" */
-#endif				/* __cplusplus */
-
-#endif				/* CTL_IO_H */
-#ifndef LIBCTL_MAJOR_VERSION
-#  define LIBCTL_MAJOR_VERSION 4
-#  define LIBCTL_MINOR_VERSION 5
-#  define LIBCTL_BUGFIX_VERSION 1
-#endif
diff --git a/utils/ctlgeom.h b/utils/ctlgeom.h
index d4fd6e5..194b226 100644
--- a/utils/ctlgeom.h
+++ b/utils/ctlgeom.h
@@ -39,17 +39,6 @@
 #define MATERIAL_TYPE void *
 #endif
 
-#ifndef CTL_SWIG /* for swig */
-#undef MATERIAL_TYPE
-#define MATERIAL_TYPE MATERIAL_TYPE
-#undef GEOMETRIC_OBJECT
-#define GEOMETRIC_OBJECT geometric_object
-#undef GEOMETRIC_OBJECT_LIST
-#define GEOMETRIC_OBJECT_LIST geometric_object_list
-#include <ctlgeom-types-swig.h>
-extern void display_geometric_object_info(int indentby, geometric_object o);
-#endif
-
 /* Where possible (e.g. for gcc >= 3.1), enable a compiler warning
    for code that uses a deprecated function */
 #if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0))
diff --git a/utils/python/Makefile.am b/utils/python/Makefile.am
new file mode 100644
index 0000000..204595b
--- /dev/null
+++ b/utils/python/Makefile.am
@@ -0,0 +1,36 @@
+AM_CPPFLAGS = -I$(top_srcdir)/src       \
+              -I$(top_srcdir)/utils		\
+              -I$(top_builddir) # for config.h
+
+BUILT_SOURCES = libctlgeom_wrap.c libctlgeom.py
+EXTRA_DIST = $(BUILT_SOURCES) libctlgeom.i numpy.i
+MAINTAINERCLEANFILES = $(BUILT_SOURCES)
+
+_libctlgeom_la_SOURCES = libctlgeom_wrap.c
+_libctlgeom_la_LIBADD = $(top_builddir)/utils/libctlgeom.la $(PYTHON_LIBS)
+_libctlgeom_la_LDFLAGS = -module -version-info @SHARED_VERSION_INFO@
+_libctlgeom_la_CPPFLAGS = $(PYTHON_INCLUDES) $(AM_CPPFLAGS)
+
+pyctlgeomdir = $(pythondir)/ctlgeom
+pyctlgeom_PYTHON = ctlgeom.py libctlgeom.py
+pyctlgeom_LTLIBRARIES = _libctlgeom.la
+
+#################################################
+# generated code via swig and guile
+#################################################
+
+if MAINTAINER_MODE
+
+LIBCTL_SWIG_SRC = libctlgeom.i numpy.i
+
+HPPFILES=                                    \
+ $(top_srcdir)/utils/ctlgeom.h               \
+ $(top_srcdir)/src/ctl.h                     \
+ $(top_srcdir)/utils/ctlgeom-types.h
+
+libctlgeom_wrap.c: $(LIBCTL_SWIG_SRC) $(HPPFILES)
+	$(SWIG) -Wextra $(SWIG_MEEP_FLAGS) $(AM_CPPFLAGS) -outdir $(builddir) -python -o $@ $(srcdir)/libctlgeom.i
+
+libctlgeom.py: libctlgeom_wrap.c
+
+endif # MAINTAINER_MODE
diff --git a/python/README.md b/utils/python/README.md
similarity index 100%
rename from python/README.md
rename to utils/python/README.md
diff --git a/python/ctlgeom.py b/utils/python/ctlgeom.py
similarity index 100%
rename from python/ctlgeom.py
rename to utils/python/ctlgeom.py
diff --git a/python/demo.ipynb b/utils/python/demo.ipynb
similarity index 100%
rename from python/demo.ipynb
rename to utils/python/demo.ipynb
diff --git a/python/libctlgeom.i b/utils/python/libctlgeom.i
similarity index 93%
rename from python/libctlgeom.i
rename to utils/python/libctlgeom.i
index a8b1aaa..aaa6f75 100644
--- a/python/libctlgeom.i
+++ b/utils/python/libctlgeom.i
@@ -6,24 +6,24 @@
 %include "ctl-math.h"
 
 %{
-#define CTL_SWIG
+typedef void *material_type;
 #define SWIG_FILE_WITH_INIT
 #include "ctlgeom.h"
-#include "ctlgeom-types-swig.h"
+#include "ctlgeom-types.h"
 %}
 
-%include "ctlgeom-types-swig.h"
+%include "ctlgeom-types.h"
 %include "ctl-math.h"
 %include "cpointer.i"
 %pointer_functions(int, intp);
 
-/* Define MATERIAL_TYPE with proper typemap */
-%typemap(in) MATERIAL_TYPE {
+/* Define material_type with proper typemap */
+%typemap(in) material_type {
     Py_XINCREF($input);  // Increment reference count when passing to C
     $1 = (void*)$input;
 }
 
-%typemap(out) MATERIAL_TYPE {
+%typemap(out) material_type {
     if ($1 == NULL) {
         Py_INCREF(Py_None);
         $result = Py_None;
@@ -66,13 +66,13 @@
             PyErr_SetString(PyExc_TypeError, "Expected a list");
             return;
         }
-        
+
         int size = PyList_Size(list);
         if (size != $self->num_items) {
             PyErr_SetString(PyExc_ValueError, "List size must match num_items");
             return;
         }
-        
+
         $self->items = (geometric_object*)malloc(size * sizeof(geometric_object));
         for (int i = 0; i < size; i++) {
             PyObject *obj = PyList_GetItem(list, i);
@@ -86,7 +86,7 @@
             $self->items[i] = *item;
         }
     }
-    
+
     PyObject* get_items() {
         PyObject* list = PyList_New($self->num_items);
         for (int i = 0; i < $self->num_items; i++) {
@@ -124,12 +124,12 @@ PyObject* material_of_numpy_points_in_tree(double* points, int n_points, int dim
         PyErr_SetString(PyExc_ValueError, "Input array must have 3 columns (x,y,z)");
         return NULL;
     }
-    
+
     PyObject* result = PyList_New(n_points);
     for (int i = 0; i < n_points; i++) {
         vector3 p = {points[i*3], points[i*3 + 1], points[i*3 + 2]};
-        MATERIAL_TYPE material = material_of_point_in_tree(p, t);
-        
+        material_type material = material_of_point_in_tree(p, t);
+
         if (material == NULL) {
             PyObject* nan = PyFloat_FromDouble(NPY_NAN);  // Create numpy.nan
             PyList_SET_ITEM(result, i, nan);
@@ -141,4 +141,4 @@ PyObject* material_of_numpy_points_in_tree(double* points, int n_points, int dim
     }
     return result;
 }
-%}
\ No newline at end of file
+%}
diff --git a/python/numpy.i b/utils/python/numpy.i
similarity index 100%
rename from python/numpy.i
rename to utils/python/numpy.i
diff --git a/python/setup.py b/utils/python/setup.py
similarity index 100%
rename from python/setup.py
rename to utils/python/setup.py
diff --git a/python/test_ctlgeom.py b/utils/python/test_ctlgeom.py
similarity index 100%
rename from python/test_ctlgeom.py
rename to utils/python/test_ctlgeom.py

From 73b3cbe948409b19c4d4f8808ad98716a10a6f0a Mon Sep 17 00:00:00 2001
From: Luocheng Huang <35114355+Luochenghuang@users.noreply.github.com>
Date: Fri, 15 Nov 2024 14:55:16 -0800
Subject: [PATCH 31/37] Update README.md

---
 python/README.md | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/python/README.md b/python/README.md
index 4e4bf56..c7da8b2 100644
--- a/python/README.md
+++ b/python/README.md
@@ -181,11 +181,8 @@ plt.title('Imaginary')
 plt.show()
 ```
 
-Note: The `np.vectorize` function allows us to efficiently apply the material lookup across a large array of points. While not as fast as true vectorization (it still calls Python code for each point), it provides a convenient way to process large arrays of coordinates without explicit loops.
-
-
 ### Running tests
 First, make sure pytest is installed. You can install it by `pip install pytest`.
 ```bash
 pytest test_ctlgeom.py -v
-```
\ No newline at end of file
+```

From 2a6395e04f00dddf81016b88386867f7033b4ea4 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Tue, 19 Nov 2024 13:56:11 -0800
Subject: [PATCH 32/37] Fix imports, delete setup.py

---
 utils/python/ctlgeom.py      |  9 ++++----
 utils/python/setup.py        | 40 ------------------------------------
 utils/python/test_ctlgeom.py | 19 +++++------------
 3 files changed, 10 insertions(+), 58 deletions(-)
 delete mode 100644 utils/python/setup.py

diff --git a/utils/python/ctlgeom.py b/utils/python/ctlgeom.py
index 7c5dbeb..5b12a1f 100644
--- a/utils/python/ctlgeom.py
+++ b/utils/python/ctlgeom.py
@@ -1,9 +1,10 @@
-import libctlgeom as geom
-from abc import ABC, abstractmethod
-from typing import Tuple, List, Literal, Any
+import copy
 import dataclasses
+from abc import ABC, abstractmethod
+from typing import Any, List, Literal, Tuple
+
+import libctlgeom as geom
 import numpy as np
-import copy
 
 MATERIAL_TYPE = Any
 
diff --git a/utils/python/setup.py b/utils/python/setup.py
deleted file mode 100644
index d238a1c..0000000
--- a/utils/python/setup.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from setuptools import setup, Extension
-from setuptools.command.build_ext import build_ext
-import sys
-import os
-from sysconfig import get_paths
-import numpy
-
-python_include = get_paths()["include"]
-
-
-class CustomBuildExtCommand(build_ext):
-    """Customized build_ext command"""
-
-    def build_extensions(self):
-        # Customize compiler settings
-        if sys.platform == "darwin":
-            for ext in self.extensions:
-                ext.extra_link_args = ["-Wl,-rpath,/usr/local/lib"]
-        build_ext.build_extensions(self)
-
-
-libctlgeom_module = Extension(
-    "_libctlgeom",
-    sources=["libctlgeom_wrap.c"],
-    include_dirs=["/usr/local/include", python_include, numpy.get_include()],
-    library_dirs=["/usr/local/lib"],
-    libraries=["ctlgeom"],
-    extra_compile_args=["-I/usr/local/include"],
-)
-
-setup(
-    name="libctlgeom",
-    version="0.1",
-    author="SWIG Wrapper Generator",
-    description="SWIG wrapper for libctlgeom",
-    ext_modules=[libctlgeom_module],
-    py_modules=["libctlgeom"],
-    cmdclass={"build_ext": CustomBuildExtCommand},
-    install_requires=["numpy"],
-)
diff --git a/utils/python/test_ctlgeom.py b/utils/python/test_ctlgeom.py
index 626b77f..68c9e76 100644
--- a/utils/python/test_ctlgeom.py
+++ b/utils/python/test_ctlgeom.py
@@ -1,18 +1,9 @@
-import pytest
 import numpy as np
-from ctlgeom import (
-    BoundingBox,
-    Sphere,
-    point_is_in_object,
-    Cylinder,
-    Wedge,
-    Cone,
-    Block,
-    Ellipsoid,
-    Prism,
-    SlantedPrism,
-    ObjectGroup,
-)
+import pytest
+
+from ctlgeom import (Block, BoundingBox, Cone, Cylinder, Ellipsoid,
+                     ObjectGroup, Prism, SlantedPrism, Sphere, Wedge,
+                     point_is_in_object)
 
 
 class TestBoundingBox:

From c51e3fcdf14fb0497cba64af97d8cdc3b1ec6834 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Tue, 19 Nov 2024 15:38:08 -0800
Subject: [PATCH 33/37] Add . into the SUBDIRS varialbes so utils/* gets built
 when building the python extension.

---
 utils/Makefile.am | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/utils/Makefile.am b/utils/Makefile.am
index 97f51e2..d18e052 100644
--- a/utils/Makefile.am
+++ b/utils/Makefile.am
@@ -1,5 +1,7 @@
 if WITH_PYTHON
-SUBDIRS = python
+SUBDIRS = . python
+else
+SUBDIRS = .
 endif
 
 bin_SCRIPTS = gen-ctl-io

From 8c017f8f3c4c7e7324e979faeb37208e9f57a7c8 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Tue, 19 Nov 2024 17:10:35 -0800
Subject: [PATCH 34/37] Make tweaks to make python installation proper.

Create __init__.py to enable proper import of module
Add display_geometric_object_info in libctlgeom.i
Update README and docs
---
 doc/docs/Installation.md                 | 17 ++++++++++++
 utils/python/Makefile.am                 |  2 +-
 utils/python/README.md                   | 33 ++++++++++++------------
 utils/python/__init__.py                 |  2 ++
 utils/python/ctlgeom.py                  |  2 +-
 utils/python/libctlgeom.i                |  2 ++
 utils/python/{ => tests}/test_ctlgeom.py |  0
 7 files changed, 39 insertions(+), 19 deletions(-)
 create mode 100644 utils/python/__init__.py
 rename utils/python/{ => tests}/test_ctlgeom.py (100%)

diff --git a/doc/docs/Installation.md b/doc/docs/Installation.md
index 8c6a3bf..e5b75f7 100644
--- a/doc/docs/Installation.md
+++ b/doc/docs/Installation.md
@@ -78,6 +78,23 @@ If you are installing on your personal Linux or BSD machine, then precompiled bi
 
 **Do not compile something from source if an official binary package is available.**  For one thing, you're just creating pain for yourself.  Worse, the binary package may already be installed, in which case installing a different version from source will just cause trouble.
 
+Python Extension for libctlgeom
+------
+
+To install the python extension for the libctlgeom, run the following commands:
+```bash
+./configure --enable-maintainer-mode PYTHON=python3 --enable-shared
+make
+make install
+```
+
+If the user desires to install in a conda environment, use the following commands in the environment:
+```bash
+./configure --enable-maintainer-mode PYTHON=$(which python) --prefix=$CONDA_PREFIX --enable-shared
+make
+make install
+```
+
 Guile
 -----
 
diff --git a/utils/python/Makefile.am b/utils/python/Makefile.am
index 204595b..6e80758 100644
--- a/utils/python/Makefile.am
+++ b/utils/python/Makefile.am
@@ -12,7 +12,7 @@ _libctlgeom_la_LDFLAGS = -module -version-info @SHARED_VERSION_INFO@
 _libctlgeom_la_CPPFLAGS = $(PYTHON_INCLUDES) $(AM_CPPFLAGS)
 
 pyctlgeomdir = $(pythondir)/ctlgeom
-pyctlgeom_PYTHON = ctlgeom.py libctlgeom.py
+pyctlgeom_PYTHON = __init__.py ctlgeom.py libctlgeom.py
 pyctlgeom_LTLIBRARIES = _libctlgeom.la
 
 #################################################
diff --git a/utils/python/README.md b/utils/python/README.md
index c7da8b2..ce6ba98 100644
--- a/utils/python/README.md
+++ b/utils/python/README.md
@@ -10,21 +10,19 @@ This directory contains SWIG bindings to create a Python extension for libctl.
 
 ## Installation
 
-**Using Conda Environment**
-   ```bash
-   conda activate my_env
-   ./build.sh
-   ```
-
-**Using System Python**
-   ```bash
-   ./build.sh
-   ```
-
-The build script will automatically:
-- Generate Python bindings using SWIG
-- Compile the extension module
-- Install the package using pip
+In the top source directory, run the following
+```bash
+./configure --enable-maintainer-mode PYTHON=python3 --enable-shared
+make
+make install
+```
+
+If the user desires to install in a conda environment, use the following commands in the environment:
+```bash
+./configure --enable-maintainer-mode PYTHON=$(which python) --prefix=$CONDA_PREFIX --enable-shared
+make
+make install
+```
 
 ## Usage Examples
 
@@ -184,5 +182,6 @@ plt.show()
 ### Running tests
 First, make sure pytest is installed. You can install it by `pip install pytest`.
 ```bash
-pytest test_ctlgeom.py -v
-```
+cd tests/
+pytest * -v
+```
\ No newline at end of file
diff --git a/utils/python/__init__.py b/utils/python/__init__.py
new file mode 100644
index 0000000..899d76a
--- /dev/null
+++ b/utils/python/__init__.py
@@ -0,0 +1,2 @@
+from .libctlgeom import *
+from .ctlgeom import *
diff --git a/utils/python/ctlgeom.py b/utils/python/ctlgeom.py
index 5b12a1f..fd41c51 100644
--- a/utils/python/ctlgeom.py
+++ b/utils/python/ctlgeom.py
@@ -3,7 +3,7 @@
 from abc import ABC, abstractmethod
 from typing import Any, List, Literal, Tuple
 
-import libctlgeom as geom
+from . import libctlgeom as geom
 import numpy as np
 
 MATERIAL_TYPE = Any
diff --git a/utils/python/libctlgeom.i b/utils/python/libctlgeom.i
index aaa6f75..9d1c327 100644
--- a/utils/python/libctlgeom.i
+++ b/utils/python/libctlgeom.i
@@ -12,6 +12,8 @@ typedef void *material_type;
 #include "ctlgeom-types.h"
 %}
 
+extern void display_geometric_object_info(int indentby, geometric_object o);
+
 %include "ctlgeom-types.h"
 %include "ctl-math.h"
 %include "cpointer.i"
diff --git a/utils/python/test_ctlgeom.py b/utils/python/tests/test_ctlgeom.py
similarity index 100%
rename from utils/python/test_ctlgeom.py
rename to utils/python/tests/test_ctlgeom.py

From 04fac59e9d6f98702d4e7b13448b33139ae5d8a6 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Thu, 21 Nov 2024 12:42:48 -0800
Subject: [PATCH 35/37] Automatically grab python 3

---
 configure.ac             |  2 +-
 doc/docs/Installation.md |  9 +--------
 utils/python/README.md   | 11 ++---------
 3 files changed, 4 insertions(+), 18 deletions(-)

diff --git a/configure.ac b/configure.ac
index 13d4bc5..1b33c3e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -262,7 +262,7 @@ else
      AC_MSG_WARN([Python interface requires --enable-shared; disabling])
      have_python=no
   else
-    AM_PATH_PYTHON([],[have_python=yes],[have_python=no])
+    AM_PATH_PYTHON([3],[have_python=yes],[have_python=no])
     if test $have_python = yes; then
       AC_MSG_CHECKING([for Python include directory])
       pinc=`echo "from sysconfig import get_paths; print(get_paths()[['include']])" | $PYTHON - 2>/dev/null`
diff --git a/doc/docs/Installation.md b/doc/docs/Installation.md
index e5b75f7..6d35099 100644
--- a/doc/docs/Installation.md
+++ b/doc/docs/Installation.md
@@ -83,14 +83,7 @@ Python Extension for libctlgeom
 
 To install the python extension for the libctlgeom, run the following commands:
 ```bash
-./configure --enable-maintainer-mode PYTHON=python3 --enable-shared
-make
-make install
-```
-
-If the user desires to install in a conda environment, use the following commands in the environment:
-```bash
-./configure --enable-maintainer-mode PYTHON=$(which python) --prefix=$CONDA_PREFIX --enable-shared
+./configure --enable-maintainer-mode --enable-shared
 make
 make install
 ```
diff --git a/utils/python/README.md b/utils/python/README.md
index ce6ba98..4f20904 100644
--- a/utils/python/README.md
+++ b/utils/python/README.md
@@ -8,18 +8,11 @@ This directory contains SWIG bindings to create a Python extension for libctl.
 - pip
 - A C compiler (gcc, clang, etc.)
 
-## Installation
+## Installation (build from source)
 
 In the top source directory, run the following
 ```bash
-./configure --enable-maintainer-mode PYTHON=python3 --enable-shared
-make
-make install
-```
-
-If the user desires to install in a conda environment, use the following commands in the environment:
-```bash
-./configure --enable-maintainer-mode PYTHON=$(which python) --prefix=$CONDA_PREFIX --enable-shared
+./configure --enable-maintainer-mode --enable-shared
 make
 make install
 ```

From 020c2a399cd9decae38c2143f3a7bce46df9c1b5 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Fri, 22 Nov 2024 15:37:31 -0800
Subject: [PATCH 36/37] Keep namespace cleaner

Import libctlgeom as a module instead of import all names from
libctlgeom
---
 utils/python/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils/python/__init__.py b/utils/python/__init__.py
index 899d76a..159a608 100644
--- a/utils/python/__init__.py
+++ b/utils/python/__init__.py
@@ -1,2 +1,2 @@
-from .libctlgeom import *
+from . import libctlgeom
 from .ctlgeom import *

From 65b919bebf19e08a48b42a00bb3b207fe6cf79e9 Mon Sep 17 00:00:00 2001
From: Luocheng Huang <luocheng@meta.com>
Date: Fri, 29 Nov 2024 00:59:44 -0800
Subject: [PATCH 37/37] Make python install instruction canonical

---
 doc/docs/Installation.md |  7 +------
 utils/python/README.md   | 16 +++++++++++++++-
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/doc/docs/Installation.md b/doc/docs/Installation.md
index 6d35099..bd35410 100644
--- a/doc/docs/Installation.md
+++ b/doc/docs/Installation.md
@@ -81,12 +81,7 @@ If you are installing on your personal Linux or BSD machine, then precompiled bi
 Python Extension for libctlgeom
 ------
 
-To install the python extension for the libctlgeom, run the following commands:
-```bash
-./configure --enable-maintainer-mode --enable-shared
-make
-make install
-```
+Please follow the [instructions here](../../utils/python/README.md) to install the python extension.
 
 Guile
 -----
diff --git a/utils/python/README.md b/utils/python/README.md
index 4f20904..c5c697b 100644
--- a/utils/python/README.md
+++ b/utils/python/README.md
@@ -5,7 +5,6 @@ This directory contains SWIG bindings to create a Python extension for libctl.
 ## Prerequisites
 - SWIG
 - Python 3.x
-- pip
 - A C compiler (gcc, clang, etc.)
 
 ## Installation (build from source)
@@ -16,6 +15,21 @@ In the top source directory, run the following
 make
 make install
 ```
+Note that you'll need to have `guile` installed to build from source.
+
+## Installation (from a release)
+
+If you are building from an official `.tar.gz` package on the [releases page](https://github.com/NanoComp/libctl/releases), then you can run the following commands:
+```bash
+tar xvzf libctl-x.x.x.tar.gz
+cd libctl-x.x.x
+./configure --enable-shared --without-guile
+make
+make install
+```
+
+If you *don't* want to install the python extension, you can configure with `--without-python`.
+
 
 ## Usage Examples
 
