diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
index 05b323e..0943697 100644
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -38,6 +38,8 @@ jobs:
         run: |
           unzip tests/data/PbTe-CNCS-HH4-Ei_12-E_5-q_0/dhkls.npy.zip -d tests/data/PbTe-CNCS-HH4-Ei_12-E_5-q_0
           ls -tl tests/data/beam/ARCS/100meV/out/neutrons
+          mkdir tests/data/SEQUOIA_data/Mn3Si2Te6
+          tar xfz tests/data/SEQUOIA_data/Mn3Si2Te6-mcvine-res-sim.tgz --directory tests/data/SEQUOIA_data/Mn3Si2Te6/
 
       - name: ~/.mantid
         run: git clone https://github.com/yxqd/dotmantid ~/.mantid
diff --git a/dgsres/instruments.py b/dgsres/instruments.py
index 8cb2294..4fc2e73 100644
--- a/dgsres/instruments.py
+++ b/dgsres/instruments.py
@@ -24,6 +24,7 @@ class sequoia:
         name = 'SEQ',
         detsys_radius = "5.5*meter",
         L_m2s = "20.05*meter",
+        L_m2fc = "18*meter",
         offset_sample2beam = "-0.15*meter" # offset from sample to saved beam. don't change this unless you are sure what you are doing
     )
 
@@ -37,6 +38,13 @@ class sequoia:
     def scattering_angle_constraints(cls, theta, phi):
         return ((theta<60.) * (theta>-30)) * (phi<18) * (phi>-18)
 
+    class violini:
+
+        tau_P = 10
+        tau_M = 8
+        sigma_thetai = 0.01
+        sigma_phii = 0.01
+
 class cncs:
     instrument = sx.instrument(
         name = 'CNCS',
diff --git a/dgsres/singlextal/plot.py b/dgsres/singlextal/plot.py
index d854251..1e8eb6a 100644
--- a/dgsres/singlextal/plot.py
+++ b/dgsres/singlextal/plot.py
@@ -1,6 +1,12 @@
 import os, numpy as np
 from . import use_covmat
+from .pointcloud import PointCloud
+from .simdata import McvineResolutionData
+from .violini import VioliniModel
+# backward compatible
+AnalyticalModel = VioliniModel
 
+# obsolete
 def createARCSAnalyticalModel(
     tau_P, tau_M, pix_r, pix_h,
     sample_thickness, 
@@ -24,147 +30,22 @@ def createARCSAnalyticalModel(
         height = "meter*%s" % pix_h,
         pressure = "10*atm",
         )
-    return AnalyticalModel(
+    return VioliniModel(
         instrument, pixel, tofwidths, beamdivs, 
         sample_yml, samplethickness,
         Ei, psi_scan)
 
 
-class PointCloud:
-    
-    """resolution point cloud. can be regarded as "events" with dh,dk,dl,dE,weight data.
-    These data could be generated from mcvine simulation of the resolution function,
-    or generated from a simple normal distribution using a 4D cov matrix (see AnalyticalModel).
-    """
-    
-    def __init__(self, dhs, dks, dls, dEs, weights):
-        self.dhs = dhs
-        self.dks = dks
-        self.dls = dls
-        self.dEs = dEs
-        self.weights = weights
-        return
-    
-    def getThinSlice(
-        self, 
-        axis1=('h', -0.1,0.1, 0.002), axis2=('E', -3, 3., 0.04),
-        axis3=('k', -0.006, 0.006), axis4=('l', -0.006, 0.006)
-    ):
-        axis1_name = axis1[0]; axis1_ticks = np.arange(*axis1[1:])
-        axis2_name = axis2[0]; axis2_ticks = np.arange(*axis2[1:])
-        condition = True
-        for ax in [axis3, axis4]:
-            name = ax[0]
-            min, max = ax[1:]
-            arr = self._evts(name)
-            condition *= (arr<max) * (arr>min)
-            continue
-        Ixy, xedges, yedges = np.histogram2d(
-            self._evts(axis1_name)[condition], self._evts(axis2_name)[condition],
-            bins=(axis1_ticks, axis2_ticks), weights=self.weights[condition]) 
-        xbc = (xedges[:-1] + xedges[1:])/2
-        ybc = (yedges[:-1] + yedges[1:])/2
-        xg, yg = np.meshgrid(xbc, ybc)
-        return xg,yg,Ixy
-            
-    def _evts(self, name):
-        return getattr(self, 'd%ss' % name)
-    
-
-class McvineResolutionData:
-
-    """resolution data simulated by mcvine. 
-    The data was simulated earlier and saved to disk. 
-    This class handles locating the data files and reading the data, 
-    and convert the data to different forms: point cloud, cov matrix, etc.
-    """
-    
-    def __init__(self, parent_dir, dirname_template='E%s_hkl%s'):
-        self.parent_dir = parent_dir
-        self.dirname_template = dirname_template
-        return
-    
-    def path(self, hkl, E):
-        return os.path.join(self.parent_dir, self.dirname_template % (E, '%s,%s,%s' % tuple(hkl)))
-    
-    def loadData(self, hkl, E):
-        p = self.path(hkl, E)
-        return self._loadData(p)
-    
-    def loadPointCloud(self, hkl, E):
-        dhs, dks, dls, dEs, probs = self.loadData(hkl, E)
-        return PointCloud(dhs, dks, dls, dEs, probs)
-    
-    def _loadData(self, outdir1):
-        dhkls = np.load('%s/dhkls.npy' % outdir1)
-        dEs = np.load('%s/dEs.npy' % outdir1)
-        probs = np.load('%s/probs.npy' % outdir1)
-        dhs,dks,dls = dhkls.T
-        # there might be unreasonable data points with unreasonable weights
-        mask = (dhs> -2.)*(dhs<2.) \
-            * (dks> -2.)*(dks<2.) \
-            * (dls> -2.)*(dls<2.) 
-        return np.array([dhs[mask], dks[mask], dls[mask], dEs[mask], probs[mask]])
-    
-    def computeCovMat(self, hkl, E):
-        data = self.loadData(hkl, E)
-        Data = data[:4]; probs = data[-1]
-        return np.cov(Data, aweights=probs)
-
-class AnalyticalModel:
-
-    """analytical resolution model based on paper by Violini et al.
-    The main calculation is done in module .use_covmat.
-    """
-    
-    def __init__(
-        self, instrument, pixel, tofwidths, beamdivs, 
-        sample_yml, samplethickness,
-        Ei, psi_scan):
-        self.instrument = instrument
-        self.pixel = pixel
-        self.tofwidths = tofwidths
-        self.beamdivs = beamdivs
-        self.sample_yml = sample_yml
-        self.samplethickness = samplethickness
-        self.Ei = Ei
-        self.psi_scan = psi_scan
-        return
-    
-    def computePointCloud(self, hkl, E, N=int(1e6)):
-        covmat = self.computeCovMat(hkl, E)
-        events = np.random.multivariate_normal(np.zeros(4), covmat, size=N)
-        dhs, dks, dls, dEs = events.T
-        ws = np.ones(dhs.shape)
-        return PointCloud(dhs, dks, dls, dEs, ws)
-    
-    def computeCovMat(self, hkl, E):
-        class dynamics:
-            hkl_dir = np.array([1.,0.,0.])
-            dq = 0
-        dynamics.hkl0 = hkl
-        dynamics.E = E
-        cm_res = use_covmat.compute(
-            self.sample_yml, self.Ei, 
-            dynamics, 
-            self.psi_scan,
-            self.instrument, self.pixel,
-            self.tofwidths, self.beamdivs, self.samplethickness,
-            plot=False)
-        # ellipsoid_trace = cm_res['u']
-        InvCov4D = cm_res['hklE_inv_cov']
-        return np.linalg.inv(InvCov4D)/2.355
-    
-def plotEllipsoid(covmat, q, symbol='.'):
+def plot_qE_ellipse(covmat, q, symbol='.', **kwds):
     """plot 2d ellipsoid along a particular hkl direction, given the cov matrix.
     """
     invcm = np.linalg.inv(covmat)
-    _, u = computeEllipsoid(invcm, q)
+    _, u = compute_qE_ellipse(invcm, q)
     from matplotlib import pyplot as plt
-    plt.plot(u[:,0], u[:,1], symbol)
+    plt.plot(u[:,0], u[:,1], symbol, **kwds)
     return
 
-def computeEllipsoid(InvCov4D, q):
+def compute_qE_ellipse(InvCov4D, q):
     "compute ellipsoid along a q direction"
     qE2qE = np.array(
         [np.hstack([q, [0]]),
@@ -181,8 +62,36 @@ def computeEllipsoid(InvCov4D, q):
     u = np.dot(up, mR.T)
     return inv_cov_qE, u
 
-def computeEllipsoids(InvCov4D, directions=None):
+def compute_qE_ellipses(InvCov4D, directions=None):
     if directions is None:
         directions = np.eye(3, dtype=float)
-    return [(q, computeEllipsoid(InvCov4D, q)) for q in directions]
+    return [(q, compute_qE_ellipse(InvCov4D, q)) for q in directions]
+
+def plot_qq_ellipse(covmat, q1, q2, symbol='.', **kwds):
+    """plot 2d ellipsoid along two hkl directions, given the cov matrix.
+    """
+    invcm = np.linalg.inv(covmat)
+    _, u = compute_qq_ellipse(invcm, q1, q2)
+    from matplotlib import pyplot as plt
+    plt.plot(u[:,0], u[:,1], symbol, **kwds)
+    return
+
+def compute_qq_ellipse(InvCov4D, q1, q2):
+    "compute ellipsoid along a q direction"
+    q1q2_to_qE = np.array([
+        np.hstack([q1, [0]]),
+        np.hstack([q2, [0]]),
+    ])
+    inv_cov = np.dot(q1q2_to_qE, np.dot(InvCov4D, q1q2_to_qE.T))
+    # print inv_cov_hE
+    r = np.linalg.eig(inv_cov)
+    mR = r[1]; lambdas = r[0]
+    RR = 2*np.log(2)
+    theta = np.arange(0, 360, 1.)*np.pi/180
+    u1p = np.sqrt(RR/lambdas[0])*np.cos(theta)
+    u2p = np.sqrt(RR/lambdas[1])*np.sin(theta)
+    up = np.array([u1p, u2p]).T
+    u = np.dot(up, mR.T)
+    return inv_cov, u
+
 
diff --git a/dgsres/singlextal/pointcloud.py b/dgsres/singlextal/pointcloud.py
new file mode 100644
index 0000000..16b33ba
--- /dev/null
+++ b/dgsres/singlextal/pointcloud.py
@@ -0,0 +1,53 @@
+import os, numpy as np
+
+class PointCloud:
+
+    """resolution point cloud. can be regarded as "events" with dh,dk,dl,dE,weight data.
+    These data could be generated from mcvine simulation of the resolution function,
+    or generated from a simple normal distribution using a 4D cov matrix (see AnalyticalModel).
+    """
+
+    def __init__(self, dhs, dks, dls, dEs, weights):
+        self.dhs = dhs
+        self.dks = dks
+        self.dls = dls
+        self.dEs = dEs
+        self.weights = weights
+        return
+
+    def getThinSlice(
+        self, 
+        axis1=('h', -0.1,0.1, 0.002), axis2=('E', -3, 3., 0.04),
+        axis3=('k', -0.006, 0.006), axis4=('l', -0.006, 0.006)
+    ):
+        axis1_name = axis1[0]; axis1_ticks = np.arange(*axis1[1:])
+        axis2_name = axis2[0]; axis2_ticks = np.arange(*axis2[1:])
+        condition = True
+        for ax in [axis3, axis4]:
+            name = ax[0]
+            min, max = ax[1:]
+            arr = self._evts(name)
+            condition *= (arr<max) * (arr>min)
+            continue
+        Ixy, xedges, yedges = np.histogram2d(
+            self._evts(axis1_name)[condition], self._evts(axis2_name)[condition],
+            bins=(axis1_ticks, axis2_ticks), weights=self.weights[condition]) 
+        xbc = (xedges[:-1] + xedges[1:])/2
+        ybc = (yedges[:-1] + yedges[1:])/2
+        xg, yg = np.meshgrid(xbc, ybc)
+        return xg,yg,Ixy
+
+    def getIE(self, Emin, Emax, dE):
+        bins = np.arange(Emin, Emax, dE)
+        I, edges = np.histogram(self.dEs, bins=bins, weights=self.weights)
+        return edges, I
+
+    def getIq(self, direction, qmin, qmax, dq):
+        "getIq('h', -1., 1., 0.02)"
+        bins = np.arange(qmin, qmax, dq)
+        I, edges = np.histogram(self._evts(direction), bins=bins, weights=self.weights)
+        return edges, I
+
+    def _evts(self, name):
+        return getattr(self, 'd%ss' % name)
+
diff --git a/dgsres/singlextal/simdata.py b/dgsres/singlextal/simdata.py
new file mode 100644
index 0000000..a9c0b61
--- /dev/null
+++ b/dgsres/singlextal/simdata.py
@@ -0,0 +1,46 @@
+import os, numpy as np
+from .pointcloud import PointCloud
+
+class McvineResolutionData:
+
+    """resolution data simulated by mcvine. 
+    The data was simulated earlier and saved to disk. 
+    This class handles locating the data files and reading the data, 
+    and convert the data to different forms: point cloud, cov matrix, etc.
+    """
+    
+    def __init__(self, parent_dir, dirname_template='E%s_hkl%s'):
+        self.parent_dir = parent_dir
+        self.dirname_template = dirname_template
+        return
+    
+    def path(self, hkl, E):
+        return os.path.join(self.parent_dir, self.dirname_template % (E, '%s,%s,%s' % tuple(hkl)))
+    
+    def loadData(self, hkl, E, dhkl_ranges=None):
+        p = self.path(hkl, E)
+        return self._loadData(p, dhkl_ranges=dhkl_ranges)
+    
+    def loadPointCloud(self, hkl, E):
+        dhs, dks, dls, dEs, probs = self.loadData(hkl, E)
+        return PointCloud(dhs, dks, dls, dEs, probs)
+    
+    def _loadData(self, outdir1, dhkl_ranges=None):
+        if dhkl_ranges is None:
+            dhkl_ranges = [ (-2., 2.) ] * 3
+        dhkls = np.load('%s/dhkls.npy' % outdir1)
+        dEs = np.load('%s/dEs.npy' % outdir1)
+        probs = np.load('%s/probs.npy' % outdir1)
+        dhs,dks,dls = dhkls.T
+        # there might be unreasonable data points with unreasonable weights
+        (dh_min, dh_max), (dk_min, dk_max), (dl_min, dl_max) = dhkl_ranges
+        mask = (dhs>dh_min)*(dhs<dh_max) \
+            * (dks>dk_min)*(dks<dk_max) \
+            * (dls>dl_min)*(dls<dl_max) 
+        return np.array([dhs[mask], dks[mask], dls[mask], dEs[mask], probs[mask]])
+    
+    def computeCovMat(self, hkl, E, dhkl_ranges=None):
+        data = self.loadData(hkl, E, dhkl_ranges=dhkl_ranges)
+        Data = data[:4]; probs = data[-1]
+        return np.cov(Data, aweights=probs)
+
diff --git a/dgsres/singlextal/spinw.py b/dgsres/singlextal/spinw.py
index 09912b2..5a6083c 100644
--- a/dgsres/singlextal/spinw.py
+++ b/dgsres/singlextal/spinw.py
@@ -41,5 +41,5 @@ def wrap_spinw_disp_func(f):
     import matlab.engine, matlab
     def _(start, end, Nq_disp):
         sp = f(matlab.double(list(start)), matlab.double(list(end)), Nq_disp)
-        return sp['omega'], sp['swInt']
+        return np.array(sp['omega']), np.array(sp['swInt'])
     return _
diff --git a/dgsres/singlextal/use_covmat.py b/dgsres/singlextal/use_covmat.py
index 82806fd..b938276 100644
--- a/dgsres/singlextal/use_covmat.py
+++ b/dgsres/singlextal/use_covmat.py
@@ -32,8 +32,9 @@ def __init__(self, theta, phi):
         return
 
 def compute(
-        sample_yml, Ei, dynamics, psi_scan, instrument, pixel, tofwidths, beamdivs, samplethickness,
-        plot=False):
+        sample_yml, Ei, dynamics, psi_scan, instrument, pixel,
+        tofwidths, beamdivs, samplethickness,
+        plot=False, verbose=False):
     # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     # should P be the T0 chopper?
     L_PM=mcvine.units.parse(instrument.L_m2fc)/mcvine.units.meter # P chopper to M chopper distance
@@ -70,8 +71,9 @@ def compute(
     from mcvine.workflow.singlextal.coords_transform import hkl2Q
     for r in results:
         xtalori.psi = r*np.pi/180
-        print("psi=%s, Q=%s" % (r, hkl2Q(hkl, xtalori)))
-        print("hkl2Q=%r\n(Q = hkl dot hkl2Q)" % (xtalori.hkl2cartesian_mat(),))
+        if verbose:
+            print("psi=%s, Q=%s" % (r, hkl2Q(hkl, xtalori)))
+            print("hkl2Q=%r\n(Q = hkl dot hkl2Q)" % (xtalori.hkl2cartesian_mat(),))
     # these are the psi angles that the particular point of interest will be measured
     # print results
     assert len(results)
diff --git a/dgsres/singlextal/violini.py b/dgsres/singlextal/violini.py
new file mode 100644
index 0000000..6d9282d
--- /dev/null
+++ b/dgsres/singlextal/violini.py
@@ -0,0 +1,109 @@
+import os, numpy as np
+from . import use_covmat
+from .pointcloud import PointCloud
+
+class VioliniModel:
+
+    """analytical resolution model based on paper by Violini et al.
+    The main calculation is done in module .use_covmat.
+    """
+    
+    def __init__(
+        self, instrument, pixel, tofwidths, beamdivs, 
+        sample_yml, samplethickness,
+        Ei, psi_scan):
+        self.instrument = instrument
+        self.pixel = pixel
+        self.tofwidths = tofwidths
+        self.beamdivs = beamdivs
+        self.sample_yml = sample_yml
+        self.samplethickness = samplethickness
+        self.Ei = Ei
+        self.psi_scan = psi_scan
+        return
+    
+    def computePointCloud(self, hkl, E, N=int(1e6)):
+        covmat = self.computeCovMat(hkl, E)
+        events = np.random.multivariate_normal(np.zeros(4), covmat, size=N)
+        dhs, dks, dls, dEs = events.T
+        ws = np.ones(dhs.shape)
+        return PointCloud(dhs, dks, dls, dEs, ws)
+    
+    def computeCovMat(self, hkl, E):
+        class dynamics:
+            hkl_dir = np.array([1.,0.,0.])
+            dq = 0
+        dynamics.hkl0 = hkl
+        dynamics.E = E
+        cm_res = use_covmat.compute(
+            self.sample_yml, self.Ei, 
+            dynamics, 
+            self.psi_scan,
+            self.instrument, self.pixel,
+            self.tofwidths, self.beamdivs, self.samplethickness,
+            plot=False)
+        # ellipsoid_trace = cm_res['u']
+        InvCov4D = cm_res['hklE_inv_cov']
+        return np.linalg.inv(InvCov4D)/2.355
+    
+    def pdf4D(self, hkl, E):
+        "return a pdf function pdf((h,k,l,E)) gives value of pdf at that point"
+        sigma2 = self.computeCovMat(hkl, E)
+        return create_pdf(sigma2)
+
+    def pdf2D(self, hkl, E, eu, ev, ew):
+        """return a 2D pdf function along uaxis and Eaxis at the point h,k,l,E
+        the pdf is 4D pdf integrated over v and w direction
+
+        eu, ev, ew are unit vectors along uvw
+
+        see https://jupyter.sns.gov/user/{UID}/notebooks/data/SNS/SEQ/IPTS-21411/shared/resolution/violini-04162019.ipynb
+        for an example
+        """
+        # compute covmat
+        cm = self.computeCovMat(hkl, E)
+        # cm = np.matrix(cm)
+        # inverse
+        ic = np.linalg.inv(cm)
+        # transform the coordinate system
+        A = np.array( (eu,ev,ew) ).T
+        A = np.block( [[A, np.zeros((3,1))],
+                       [np.zeros((1,3)), 1]])
+        # A = np.matrix(A)
+        cm0 = cm
+        # print cm0
+        cm = np.dot(A.T, np.dot(cm, A)) # u,v,w,E
+        # print cm
+        # integration along v and w
+        cm2d = [[cm[0,0] - (cm[0,1]+cm[1,0])**2/4./cm[1,1] - (cm[0,2]+cm[2,0])**2/4./cm[2,2],
+                 cm[0,3]],
+                [cm[3,0],
+                 cm[3,3] - (cm[3,1]+cm[1,3])**2/4./cm[1,1] - (cm[3,2]+cm[2,3])**2/4./cm[2,2]
+                ]]
+        cm2d = np.array(cm2d)
+        # print cm2d
+        return create_pdf(cm2d)
+
+
+def create_pdf(covmat):
+    "create probability distribution function out of covariance matrix"
+    # sigma2 = np.matrix(covmat)
+    sigma2 = covmat
+    det = np.linalg.det(sigma2)
+    # det = np.abs(det)
+    if det == 0:
+        raise ValueError("The covariance matrix can't be singular")
+    size, size2 = sigma2.shape
+    assert size == size2
+    # print "det", det
+    norm_const = 1.0/ ( np.power((2*np.pi),float(size)/2) * np.power(det,1.0/2) )
+    # print "norm_const", norm_const
+    # inv = sigma2.I
+    inv = np.linalg.inv(sigma2)
+    # print "inv", inv
+    def _(x):
+        # x = np.matrix(x)
+        x = np.array(x)
+        result = np.exp( -0.5 * (x * np.dot(x, inv.T)).sum(-1) )
+        return norm_const * result
+    return _
diff --git a/dgsres/singlextal/workflow.py b/dgsres/singlextal/workflow.py
index d1c4295..316c0df 100644
--- a/dgsres/singlextal/workflow.py
+++ b/dgsres/singlextal/workflow.py
@@ -707,3 +707,18 @@ def plot_interpolated_resolution_on_grid(model, qs, Es, dqgrid, dEgrid, figsize=
         continue
     plt.tight_layout()
     return
+
+def create_violini_model(config, sample_thickness):
+    from .violini import VioliniModel
+    from . import use_covmat
+    civ = config.instrument.violini
+    tofwidths = use_covmat.tofwidths(P=civ.tau_P, M=civ.tau_M)
+    beamdivs = use_covmat.beamdivs(theta=civ.sigma_thetai, phi=civ.sigma_phii)
+    samplethickness = sample_thickness
+    instrument = config.instrument.instrument
+    pixel = config.instrument.pixel
+    return VioliniModel(
+        instrument, pixel, tofwidths, beamdivs, 
+        config.sample_yaml, samplethickness,
+        config.Ei, config.psi_scan)
+
diff --git a/notebooks/singlextal/Mn3Si2Te6-SEQ/convolution_config.py b/notebooks/singlextal/Mn3Si2Te6-SEQ/convolution_config.py
new file mode 100644
index 0000000..2d8e073
--- /dev/null
+++ b/notebooks/singlextal/Mn3Si2Te6-SEQ/convolution_config.py
@@ -0,0 +1,118 @@
+import os, numpy as np, imp
+narr = np.array
+from dgsres import axis
+from dgsres.singlextal import convolve2d as cvv2
+here = os.path.abspath(os.path.dirname(__file__) or '.')
+rwc = imp.load_source('rwc', os.path.join(here, 'resolution_workflow_config.py'))
+
+resolution_datadir = '/SNS/SEQ/IPTS-21411/shared/resolution/mcvinesim/'
+
+class Slice_00L(rwc.Slice_00L):
+    
+    class expdata:
+        class grid:
+            qaxis = axis(min=0, max=4.+1e-5, step=0.5/10)
+            Eaxis = axis(min=10., max=28.+1e-5, step=0.5)
+        perp_hkl_directions = narr([[1.,0.,0.], [-1.,2.,0.]])
+        dh = 0.1
+        perp_hkl_range = narr([[-dh, dh], [-dh, dh]])
+        Nsample_perp_hkl = 20  # this is for sampling the perp directions.
+        
+    class convolution:
+        expansion_ratio = 0.1
+        N_subpixels = 10,10
+
+class Slice_H00(rwc.Slice_H00):
+    
+    class expdata:
+        class grid:
+            qaxis = axis(min=0, max=2.5+1e-5, step=0.5/10)
+            Eaxis = axis(min=10., max=28.+1e-5, step=0.5)
+        perp_hkl_directions = narr([[-1.,2.,0.], [0.,0.,1.]])
+        dh = 0.1
+        perp_hkl_range = narr([[-dh, dh], [-dh, dh]])
+        Nsample_perp_hkl = 20  # this is for sampling the perp directions.
+    
+    class convolution:
+        expansion_ratio = 0.1
+        N_subpixels = 10,10
+
+class Slice_H01(rwc.Slice_H01):
+    
+    class expdata:
+        class grid:
+            qaxis = axis(min=0, max=3.+1e-5, step=0.5/10)
+            Eaxis = axis(min=10., max=28.+1e-5, step=0.5)
+        perp_hkl_directions = narr([[-1.,2.,0.], [0.,0.,1.]])
+        dh = 0.1
+        perp_hkl_range = narr([[-dh, dh], [-dh, dh]])
+        Nsample_perp_hkl = 20  # this is for sampling the perp directions.
+    
+    class convolution:
+        expansion_ratio = 0.1
+        N_subpixels = 10,10
+
+class Slice_H02(rwc.Slice_H02):
+    
+    class expdata:
+        class grid:
+            qaxis = axis(min=0, max=3.+1e-5, step=0.5/10)
+            Eaxis = axis(min=10., max=28.+1e-5, step=0.5)
+        perp_hkl_directions = narr([[0.,1.,0.], [0.,0.,1.]])
+        dh = 0.1
+        perp_hkl_range = narr([[-dh, dh], [-dh, dh]])
+        Nsample_perp_hkl = 20  # this is for sampling the perp directions.
+    
+    class convolution:
+        expansion_ratio = 0.1
+        N_subpixels = 10,10
+
+class Slice_H03(rwc.Slice_H03):
+    
+    class expdata:
+        class grid:
+            qaxis = axis(min=0, max=3.+1e-5, step=0.5/10)
+            Eaxis = axis(min=10., max=28.+1e-5, step=0.5)
+        perp_hkl_directions = narr([[-1.,2.,0.], [0.,0.,1.]])
+        dh = 0.1
+        perp_hkl_range = narr([[-dh, dh], [-dh, dh]])
+        Nsample_perp_hkl = 20  # this is for sampling the perp directions.
+    
+    class convolution:
+        expansion_ratio = 0.1
+        N_subpixels = 10,10
+
+class Slice_H0H(rwc.Slice_H0H):
+    
+    class expdata:
+        class grid:
+            qaxis = axis(min=0, max=3.+1e-5, step=0.5/10)
+            Eaxis = axis(min=10., max=28.+1e-5, step=0.5)
+        perp_hkl_directions = narr([[-0.18225,0.,1.], [-1.,2.,0.]])
+        dh = 0.1
+        perp_hkl_range = narr([[-dh, dh], [-dh, dh]])
+        Nsample_perp_hkl = 20  # this is for sampling the perp directions.
+    
+    class convolution:
+        expansion_ratio = 0.1
+        N_subpixels = 10,10
+
+class Slice_0K1(rwc.Slice_0K1):
+    
+    class expdata:
+        class grid:
+            qaxis = axis(min=0, max=2.5+1e-5, step=0.5/10)
+            Eaxis = axis(min=10., max=28.+1e-5, step=0.5)
+        perp_hkl_directions = narr([[1.,0.,0.], [0.,0.,1.]])
+        dh = 0.1
+        perp_hkl_range = narr([[-dh, dh], [-dh, dh]])
+        Nsample_perp_hkl = 20  # this is for sampling the perp directions.
+    
+    class convolution:
+        expansion_ratio = 0.1
+        N_subpixels = 10,10
+
+slices = [Slice_00L, Slice_H00, Slice_H01, Slice_H02, Slice_H03, Slice_H0H, Slice_0K1]
+# slices = [Slice_00L]
+for sl in slices:
+    sl.resolution_datadir = resolution_datadir
diff --git a/notebooks/singlextal/Mn3Si2Te6-SEQ/pointcloud_and_ellipse.ipynb b/notebooks/singlextal/Mn3Si2Te6-SEQ/pointcloud_and_ellipse.ipynb
new file mode 100644
index 0000000..ce248f6
--- /dev/null
+++ b/notebooks/singlextal/Mn3Si2Te6-SEQ/pointcloud_and_ellipse.ipynb
@@ -0,0 +1,661 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Note\n",
+    "Before running this notebook, expand the tarball `{repo_root}/tests/data/SEQUOIA_data/Mn3Si2Te6-mcvine-res-sim.tgz` to directory `{repo_root}/tests/data/SEQUOIA_data/Mn3Si2Te6/`. It will create a subdir `mcvine-res-sim` there."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare Violini with mcvine sims"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# some goodies\n",
+    "# %matplotlib notebook\n",
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "import numpy as np, os, glob, sys\n",
+    "import histogram.hdf as hh, histogram as H\n",
+    "\n",
+    "import mcvine.cli\n",
+    "from mcvine.workflow.DGS import ARCS\n",
+    "from mcvine.workflow import singlextal as sx\n",
+    "from mcvine.workflow.sample import loadSampleYml\n",
+    "from mcvine.workflow.singlextal import io as sxio, coords_transform, dynrange"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# sys.path.insert(0, '/SNS/users/linjiao/dv/mcvine/dgsres/')\n",
+    "sys.path.insert(0, '/home/linjiao/dv/neutron/mcvine/dgsres/')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import dgsres"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from dgsres.singlextal import use_covmat, use_res_comps, plot as resplot, workflow, violini, simdata\n",
+    "from dgsres import instruments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from imp import reload"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<module 'dgsres.singlextal.violini' from '/home/linjiao/dv/neutron/mcvine/dgsres/dgsres/singlextal/violini.py'>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "reload(resplot)\n",
+    "reload(use_covmat)\n",
+    "reload(instruments)\n",
+    "reload(simdata)\n",
+    "reload(violini)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/linjiao/dv/neutron/mcvine/dgsres/notebooks/singlextal/Mn3Si2Te6-SEQ'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "srcdir = os.path.abspath('.')\n",
+    "srcdir"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/linjiao/dv/neutron/mcvine/dgsres/notebooks/singlextal/Mn3Si2Te6-SEQ/work\n"
+     ]
+    }
+   ],
+   "source": [
+    "# workdir = '/SNS/SEQ/IPTS-21411/shared/resolution/02012023'\n",
+    "workdir = os.path.abspath(\"work\")\n",
+    "!mkdir -p {workdir}\n",
+    "%cd {workdir}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import shutil"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "files = 'sample.yaml convolution_config.py resolution_workflow_config.py '.split()\n",
+    "for f in files:\n",
+    "    shutil.copyfile(os.path.join(srcdir, f), os.path.join(workdir, f))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# load configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import imp\n",
+    "config = imp.load_source('config', 'convolution_config.py')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "sl = config.rwc.slices[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "rwc.Slice_00L"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sl"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Comparison plot of cloud and ellipsoid"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load mcvine model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class McvineResData(resplot.McvineResolutionData):\n",
+    "    def path(self, q, E):\n",
+    "        return os.path.join(self.parent_dir, config.rwc.simdir(q, E, sl))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#mcvinesim = '/SNS/SEQ/IPTS-21411/shared/resolution/mcvinesim/'\n",
+    "mcvinesim = os.path.join(srcdir, '../../../tests/data/SEQUOIA_data/Mn3Si2Te6/mcvine-res-sim')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "mrd = McvineResData(mcvinesim, dirname_template=None)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#ls {mcvinesim}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dEs.npy    dxs.npy                 mc_params.yml      probs.npy  run.py\n",
+      "dhkls.npy  instrument7g15zupr.pkl  pixel4k5kv1ys.pkl  res.h5     \u001b[0m\u001b[01;34msample\u001b[0m/\n"
+     ]
+    }
+   ],
+   "source": [
+    "ls {mcvinesim}/sim-00L-q_3.100,E_19.000/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "rwc.Slice_00L"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[ 1.91513300e-03 -2.54398642e-04  1.63341994e-03  3.58253004e-02]\n",
+      " [-2.54398642e-04  7.90565327e-04  1.53782776e-04  3.74214632e-03]\n",
+      " [ 1.63341994e-03  1.53782776e-04  4.13309354e-03  5.24305194e-02]\n",
+      " [ 3.58253004e-02  3.74214632e-03  5.24305194e-02  8.90417391e-01]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "q1, E1 = 3.1, 19.\n",
+    "hkl1 = sl.hkl0+sl.hkl_projection*q1\n",
+    "\n",
+    "mcvine_pc1 = mrd.loadPointCloud(q1, E1)\n",
+    "mcvine_cm1 = mrd.computeCovMat(q1, E1, dhkl_ranges=[(-0.2,0.2)]*3)\n",
+    "print(mcvine_cm1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Violini model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/linjiao/miniconda3/envs/mcvine/lib/python3.8/site-packages/mcvine/workflow/singlextal/solve_psi.py:56: UserWarning: Traceback (most recent call last):\n",
+      "  File \"/home/linjiao/miniconda3/envs/mcvine/lib/python3.8/site-packages/mcvine/workflow/singlextal/solve_psi.py\", line 53, in solve\n",
+      "    results.append(solver(res, min, max))\n",
+      "  File \"/home/linjiao/miniconda3/envs/mcvine/lib/python3.8/site-packages/scipy/optimize/_zeros_py.py\", line 784, in brentq\n",
+      "    r = _zeros._brentq(f, a, b, xtol, rtol, maxiter, args, full_output, disp)\n",
+      "ValueError: f(a) and f(b) must have different signs\n",
+      "\n",
+      "  warnings.warn(tb.format_exc())\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[ 1.44901166e-03 -8.06890356e-04 -6.85152477e-04  8.72058749e-03]\n",
+      " [-8.06890356e-04  1.58682496e-03 -7.20936536e-05  9.52557961e-04]\n",
+      " [-6.85152477e-04 -7.20936536e-05  4.24161211e-03  1.72808548e-02]\n",
+      " [ 8.72058749e-03  9.52557961e-04  1.72808548e-02  2.34119649e-01]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "violini_model = workflow.create_violini_model(config.rwc, 0.01)\n",
+    "violini_cm1 = violini_model.computeCovMat(hkl1, E1)\n",
+    "print(violini_cm1)\n",
+    "\n",
+    "violini_pc1 = violini_model.computePointCloud(hkl1, E1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare mcvine sim with violini: (q, E)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_1018458/727963085.py:15: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n",
+      "/tmp/ipykernel_1018458/727963085.py:15: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n",
+      "/tmp/ipykernel_1018458/727963085.py:15: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(10,4))\n",
+    "directions = [\n",
+    "    ('h', [1,0,0]),\n",
+    "    ('k', [0,1,0]),\n",
+    "    ('l', [0,0,1]), \n",
+    "]\n",
+    "for i, direction in enumerate(directions):\n",
+    "    name, vector = direction\n",
+    "    axis1 = name, -0.5, 0.5, 0.002\n",
+    "    axis2 = 'E', -5, 5., 0.02\n",
+    "    otheraxes = [ (n, -0.015, 0.015) for n,v in directions if n !=name]\n",
+    "    \n",
+    "    plt.subplot(1,3,i+1)\n",
+    "    hg1, Eg1, I1 = mcvine_pc1.getThinSlice(axis1, axis2, *otheraxes)\n",
+    "    plt.pcolormesh(hg1, Eg1, I1.T)\n",
+    "    plt.ylim(-1.5,1.5)\n",
+    "    plt.xlim(-.125, .125)\n",
+    "    plt.xlabel(name)\n",
+    "    plt.ylabel('E (meV)')\n",
+    "    plt.clim(0, np.max(I1)/2)\n",
+    "    resplot.plot_qE_ellipse(violini_cm1, vector, 'r') #, label='Violini')\n",
+    "    # plt.legend()\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare mcvine sim with violini: (q1, q2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_1018458/1841452879.py:17: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n",
+      "/tmp/ipykernel_1018458/1841452879.py:17: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n",
+      "/tmp/ipykernel_1018458/1841452879.py:17: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(10,4))\n",
+    "directions = [\n",
+    "    ('h', [1,0,0]),\n",
+    "    ('k', [0,1,0]),\n",
+    "    ('l', [0,0,1]), \n",
+    "]\n",
+    "for i, direction in enumerate(directions):\n",
+    "    name, vector = direction\n",
+    "    qs = [ q for n, q in directions if n != name ]\n",
+    "    axes = [ (n, -0.5, 0.5, 0.002) for n,q in directions if n!=name ]\n",
+    "    oaxis1 = name, -0.015, 0.015\n",
+    "    oaxis2 = 'E', -0.2, 0.2\n",
+    "    otheraxes = [ oaxis1, oaxis2 ]\n",
+    "    \n",
+    "    plt.subplot(1,3,i+1)\n",
+    "    hg1, Eg1, I1 = mcvine_pc1.getThinSlice(axes[0], axes[1], *otheraxes)\n",
+    "    plt.pcolormesh(hg1, Eg1, I1.T)\n",
+    "    plt.ylim(-.125, .125)\n",
+    "    plt.xlim(-.125, .125)\n",
+    "    plt.xlabel(f'${axes[0][0]}$')\n",
+    "    plt.ylabel(f'${axes[1][0]}$')\n",
+    "    plt.clim(0, np.max(I1)/2)\n",
+    "    resplot.plot_qq_ellipse(violini_cm1, qs[0], qs[1], 'r')\n",
+    "    # plt.legend()\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare Violini point cloud with Violini ellipse, MCViNE sim point cloud with ellipse from cov matrix calc from MCViNE sim point cloud"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_1018458/6102574.py:15: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n",
+      "/tmp/ipykernel_1018458/6102574.py:24: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n",
+      "/tmp/ipykernel_1018458/6102574.py:15: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n",
+      "/tmp/ipykernel_1018458/6102574.py:24: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n",
+      "/tmp/ipykernel_1018458/6102574.py:15: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n",
+      "/tmp/ipykernel_1018458/6102574.py:24: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3.  Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading'].  This will become an error two minor releases later.\n",
+      "  plt.pcolormesh(hg1, Eg1, I1.T)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0YAAAKZCAYAAACcOztWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3zT5fbA8U9Gm+4WOimUsoeMgoWOKAoqSwRU9IoouK+oKIg4UK+CXuW6URFwKy78yRAFZTgANSllK8pehZbSAd0jTfL9/fGlaUPLLGnS9rx95dXkm2+SkwLHnDzPcx6NoigKQgghhBBCCNGEad0dgBBCCCGEEEK4mxRGQgghhBBCiCZPCiMhhBBCCCFEkyeFkRBCCCGEEKLJk8JICCGEEEII0eRJYSSEEEIIIYRo8qQwEkIIIYQQQjR5UhgJIYQQQgghmjwpjIQQQgghhBBNnhRGQgghhBBCiCbPpYXRjBkz6Nu3L4GBgURERHDttdeyc+fOMz5uzZo1xMfH4+PjQ7t27Zg7d64rwxRCeCjJIUKIupI8IoQ4Wy4tjNasWcMDDzxASkoKq1atwmq1MmjQIIqLi0/5mP3793P11VfTr18/Nm/ezJNPPslDDz3EwoULXRmqEMIDSQ4RQtSV5BEhxNnSKIqi1NeLZWdnExERwZo1a7jssstqPefxxx/nu+++Y/v27Y5j48ePZ+vWrZjN5voKVQjhgSSHCCHqSvKIEOJU9PX5Yvn5+QA0b978lOeYzWYGDRrkdGzw4MF8+OGHVFRU4OXl5XRfeXk55eXljtt2u51jx44RGhqKRqO5gNELIc6VoigUFhYSHR2NVlv3AWpX5BCQPCKEJ5M8IoSoi3PJIfVWGCmKwuTJk7n00kvp3r37Kc/LzMwkMjLS6VhkZCRWq5WcnBxatGjhdN+MGTOYPn26S2IWQlwYhw4dolWrVnV6DlflEJA8IkRDIHlECFEXZ5ND6q0wmjBhAn/++Se///77Gc89+ZuVytl+tX3jMnXqVCZPnuy4nZ+fT+vWrbmUq9FT8xsdIUT9sVLB7/xAYGBgnZ/LVTkEJI8I4ckkjwgh6uJccki9FEYPPvgg3333HWvXrj1jpRYVFUVmZqbTsaysLPR6PaGhoTXONxgMGAyGGsf1eKHXSCISwq1OrGCs6zQSV+YQkDwihEeTPCKEqItzyCEu7UqnKAoTJkxg0aJF/PLLL7Rt2/aMj0lOTmbVqlVOx1auXEmfPn1qndMrhGi8JIcIIepK8ogQ4my5tDB64IEH+Pzzz/nyyy8JDAwkMzOTzMxMSktLHedMnTqVcePGOW6PHz+egwcPMnnyZLZv385HH33Ehx9+yJQpU1wZqhDCA0kOEULUleQRIcTZcmlhNGfOHPLz8+nfvz8tWrRwXL7++mvHOUeOHCEtLc1xu23btvzwww+sXr2aXr168fzzz/PWW28xatQoV4YqhPBAkkOEEHUleUQIcbbqdR+j+lBQUEBwcDD9GSlzehshbz9vgsL8pfWph7DbFfKO5GOz2mu936pUsJol5OfnExQUVM/RnT/JI42b5BHPoSgKBTnFWEospzxH8ojwNDq9lpAWwWi1kkM8wZnyyLnkkHrdx0iI86XRQP87jPQdHofeWycfaDyEmoyKmDdlAQXZRe4OR4jTkjzieRRFwWqxsf77raz+2ETj+qpWNEZBEYGMe2UUQWEBkkM8xIXMI1IYiQah/x1G+o1OoHlIc7To3B2OcFAICCxk0PjLWPjfH+RDjfBokkc8kx0b/Uar3dx+/cjk5miEODWNBgbd24/otpEE+AQCUhh5iguVR6QwEh7P4O9N3+FxNA9pjhfe7g5HnMTfJ4AOfdrgF+xLcV7pmR8ghBtIHvFcOnQ0D2lO3+Fx/DF/w2mn1QnhTn4hfnTo2wZ/nwB08hHao1yoPOLS5gtCXAiBof7ovXXyDa+H0qBFp9fhG+Tj7lCEOCXJI55Niw69t46gMH93hyLEKfkGGtDpdGjk47NHuhB5RP5khcfTaDQyj9fTaeq++aIQriR5xPPJn5HwdBqNRmbPebi65hEpjIQQQgghhBBNnhRGQjRCY+8dwwuv/dfdYQghGjDJI0KIumiIOUQKIyFc6Ilpj9G5bweemfGfGvdN+98zdO7bgSemPeY4lp2TzfOvTOfKkQPobuzK5cMuZfzD92BONWGpsJB4VV9mf/hOra/17sdzSLyqL5YKC2+/PJuJ4yc57ht77xg69+3AspVLnR7zyZcfc8WIyx23F32/kM59O9S49Ljkojr+JoQQ50vyiBCiLiSHnD1pqSGEi7WIbMEPK5fy5MNP4eOjNigoLy9n2cqlREdFO847nHGYm+++iaCAQB596DE6d+iC1VrB7ym/Mf3laSxfsJIRQ0eyeOlC7rvz/hpzaBctXcjIq0fi7eWNd3DNrlsGg4GZc15n0BWD8dKferPBAP8Ali9Y5XRM5v0L4V6SR4QQdSE55OzIiJEQLnZRl260iIpm5a8rHMdW/rqCqMgWdO1c9e3H9JeeRaOBbz5dxJArh9I2ti0d23fijlvu4v8+XgDADSNvJO1wGus3pTq9xobN6zmQdoAbRvwLqH34etig4RQWFfJ/i78+bbwajYbwsHCnS1hoWJ1+B0KIupE8IoSoC8khZ0cKI9EwKQqa0hK3XM5nF9NRw0ex6PuFjtsLv1vAqOE3OG7n5efxm3ktt9xwK36+fjUeHxQYBEDnDp3pcVFPp+eqfL6e3eLo1KHTKWMI8A9g/B33MfuDWZSUlpzzexCi0XFTHjnfnZAljwjhYeSziNP9jSGHyFQ60SBpykrpeFlPt7z27rV/otSSME5nxNXX8to7r3I44zAajYZNf27k9RdnkrppHQBphw+iKArt2rQ/43ONGnEDL7/5P/7z2LP4+/lTXFLM8p9/5IlJT57xsWNuuIV58z/l4y8+4oG7J9R6TmFRIb1P+t327tmbj2Z9ehbvVIiGw1155HxyCEgeEcLTyGeRxpdDpDASoh40D2lO/0sG8O2yRSiKQv9L+tM8pLnjfuXENz9nM3/2msHD+d8bL/LDqmXcOPJf/LBqGYqiMGzQsDM+1tvbwEP3TuK5V6Zx8w1jaj3H39+fxZ8tcTrmY5DNW4VwN8kjQoi6kBxyZlIYiQZJ8fFl99o/3fba52PUiBt47pXpADz72DSn+2Jj2qDRaNi7fw9X9R942ucJDAhk8JVDWPT9Qm4c+S8Wfb+QwVcOISAg8KziGDF0JB9+/gFzPpxNyxYta9yv1WiJjWlzVs8lREPmrjxyvjkEJI8I4Unks0jjyyGyxkg0TBoNiq+fWy6cZ1eUfsmXUVFRQUVFBZcm9XO6LyQ4hEuT+vHFgs9rnXNbUFjgdPuGETeyaetGfv3tFzZt3cgNI2486zi0Wi2PPDCFrxZ+QfqR9PN6L0I0Cm7KI+ebQ0DyiBAeRT6LNLocIoWREPVEp9Px4/8t58f/W45Op6tx/7OPT8dus3Pjbdez4pflHEg7wN79e5g3/1NuutM52STEJxIbE8vj0x4lNiaWvhcnnFMs/S8dQFz3Xny9+Ksa9ymKQnZOdo2L3W4/tzcshLjgJI8IIepCcsjpyVQ6IerR6YaYY1rGsOjzJcz9aDYvzZxBVk4WzZs1p1uX7kx7YnqN80cNv4HXZ7/GXbfefV6xTJnwKKPv+leN40XFRVw6NLnG8d9/NBMeFn5eryWEuHAkjwgh6kJyyKlpFOU8+4Z6qIKCAoKDg+nPSPSaU28cJRqO8Njm/HvOLUSGRaGj5rcbwr1s2Diak8l7931B9sFjTvdZlQpWs4T8/HyCgoLcFOG5kzzS+Ege8WySR0RDIHnEs50qj5xLDpGpdEIIIYQQQogmTwojIYQQQgghRJMnhZEQQgghhBCiyZPCSAghhBBCCNHkSWEkhBBCCCGEaPKkMBIez25XUJsnNqoGio2KolT+GQnhmSSPeDr1z8duk32OhOeS/9d5urrnEZcWRmvXrmX48OFER0ej0Wj49ttvT3v+6tWr0Wg0NS47duxwZZjCw+Udyacgp4iiskKsVGCT/zzqv3JbGSUFpRRkF7nkz1/yiLgQJI947n9WKigqK6Qgp4i8zIIL/mcvOURcKAXZRZQUlFJuK3P7vxv5z/m/C5VHXLrBa3FxMXFxcdxxxx2MGjXqrB+3c+dOpz7j4eGyGVxTZrPamTdlAYPGX0aHPm3Q6XWgcXdUAtRvz0oKSln4wo9YSitc8hqSR8SFIHnEQylgs9rYs+EAK+euxWa98CNGkkPEhWIprWDhCz8y6qmh+AX5otFIEvEIFzCPuLQwGjp0KEOHDj3nx0VERBASEnLhAxINVkF2EQv/+wN+wb74BvlIMvIQiqJQkF3ksqIIJI+IC0fyiOdRFIXSgjJK8ktx1QwlySHiQjq0LYPZd84jKDxAcoiHuJB5xKWF0fnq3bs3ZWVlXHTRRTz99NMMGDDglOeWl5dTXl7uuF1QcOGH4YVnUBQoziulOK/U3aGIBkDyiKiN5BFxts4lh4DkkabEUlpBTtpxd4chXMCjmi+0aNGC9957j4ULF7Jo0SI6d+7MlVdeydq1a0/5mBkzZhAcHOy4xMTE1GPEQghPI3lECFEX55NDQPKIEI2BRqmn9hoajYbFixdz7bXXntPjhg8fjkaj4bvvvqv1/tq+oYmJiaE/I9FrvOoSshCijqxKBatZQn5+vtNc/fMleUSIpudC5hFX5RCQPCKEpzqXHOJRI0a1SUpKYvfu3ae832AwEBQU5HQRQojqJI8IIeriTDkEJI8I0Rh4fGG0efNmWrRo4e4whBANmOQRIURdSA4RomlwafOFoqIi9uzZ47i9f/9+tmzZQvPmzWndujVTp04lPT2defPmATBz5kzatGlDt27dsFgsfP755yxcuJCFCxe6MkwhhAeTPCKEqAvJIUKIs+XSwmjDhg1OXVwmT54MwG233cYnn3zCkSNHSEtLc9xvsViYMmUK6enp+Pr60q1bN5YtW8bVV1/tyjCFEB5M8ogQoi4khwghzla9NV+oLwUFBQQHB8tiRyE8wIVuvlBfJI8I4TkkjwjRsFiG9sX7x/Xq9SF98V6+3q3xNKrmC0J4Oq23t7tDEEIIIYTwCJVFEeD2ouhcSWEkRB3ZLRZ3hyCEEEIIIepICiMhhBBCCCFEkyeFkRBCCCGEEOKs6dvEOt22DOnrpkguLCmMhBBCCCGEEGfNeuCg0+2GtpboVKQwEkIIIYQQQjR5UhgJIYQQQgghLgiNTndWxzyRFEZCCCGEEEKIC0Kx2c7qmCeSwkiIs6DRy+Z8QgghhBCNmRRGQgghhBBCiCZPCiMhTkMfGwOAYq1wcyRCCCGEEJ6jskV3Y2nVDVIYCSGEEEII0aScvA/RudLodI4W3Y2lVTdIYSSEEEIIIYQQUhgJcTrWg4fcHYIQQgghxAVlPXDwvEeNNDqdU5c5jU7XYNpxn4kURkIIIYQQQjQx1gMHz+txis1G2nSj0+2G0o77TKQwEkIIIYQQQpy11s+a3B2CS0hhJIQQQgghhGjypDASohp7/4udbusjIxzXG1M7SiGEEEIIV2moa46kMBKiGu3qTY5iSN8iCuvRLMd9ftsz3RWWEEIIIUSd1LVFd6WTi57aiqCGuuZICiMhhBBCCCFEkyeFkRAnqRwlKu7T2vn4wUNO37ZUDOpTr3EJIYQQQpwv64GDWIaeellA5X2nOwdqjgY11NGh2khhJMQpGL5PdVzXd+mIvf/FTq0tvVZucEdYQgghhBDnJPt+tb22IbvslOd4/7je6efJTrfWuqGuKTqZFEZCULPpQuWx8msSALDu2I129aZazxNCCCGE8GThs9X22sqGv877ObyX114wQeMZNZLCSAghhBBCCNHkubQwWrt2LcOHDyc6OhqNRsO33357xsesWbOG+Ph4fHx8aNeuHXPnznVliEIAOEaD7JerI0Ll1yRQGuaNYWkq6U9U7e7svf2wu0JssiSPCCHqQnKIaMpy/20880nCwaWFUXFxMXFxccyaNeuszt+/fz9XX301/fr1Y/PmzTz55JM89NBDLFy40JVhiiZOk9gTTWJPtKs3obXYsF0Zj2FpKt4FVioG9aFFStV8XOvRLKe9jYTrSR4RQtSF5BDRlIW+Z3K6bRnSt0bb7rTpavF0pqYLTYHelU8+dOhQhg4detbnz507l9atWzNz5kwAunbtyoYNG3j11VcZNWqUi6IUQngyySNCiLqQHCKEOFsetcbIbDYzaNAgp2ODBw9mw4YNVFRU1PqY8vJyCgoKnC5CnAtl3Z8o6/5Ub5i3YtdpALXrnNfKDVQEOH9/UH3TV+F5JI8IIerifHIISB4RniP7garpc7vnJjjd5718vVOHXYDWz6qjSqfqRteUeFRhlJmZSWRkpNOxyMhIrFYrOTk5tT5mxowZBAcHOy4xMTH1EapoZLImGB1DyJVtuCunzPn/dcRxnkyj83ySR4QQdXE+OQQkjwj3yb3HeR1R+DtV0+c6jk91rJ8GnK6fTtnIxAsTXAPjUYURgEajcbqtKEqtxytNnTqV/Px8x+XQoUMuj1E0DpWtuC1D+xIxy4T3cQuAowmD9WgW+i4dsbQJdzxGRosaBskjQoi6ONccApJHRP3LmqAWRKHvm057nnbNJkD9vFN5HU5fJPksWXcBImx4XLrG6FxFRUWRmZnpdCwrKwu9Xk9oaGitjzEYDBgMhvoITwjRAEgeEULUxfnkEJA8IkRj4FEjRsnJyaxatcrp2MqVK+nTpw9eXl5uiko0Vtm91O8FFL36DaClmTegtu6u/Ebl8NXhTt+uyFQ6zyd5RAhRF5JDREPRbJfFMWp0Nk5eQ1T9841QubQwKioqYsuWLWzZsgVQW2Bu2bKFtLQ0QB12HjdunOP88ePHc/DgQSZPnsz27dv56KOP+PDDD5kyZYorwxRNiHVgHyzD1Cl0rf6rDj0bvk8FwOajRZPY0+n80G0W58fLVLp6J3lECFEXkkNEY+W1cgMRs04/jU6cG5dOpduwYQMDBgxw3J48eTIAt912G5988glHjhxxJCaAtm3b8sMPP/Dwww/zzjvvEB0dzVtvvSXtMYVowiSPCCHqQnKIEOJsaZTKFYWNREFBAcHBwfRnJHqNDHmL2lmGJWDXaxyLCzWJPbF769BabCjr/kTfpSNpI8LRWiHqdfk25nxZlQpWs4T8/HyCgoLcHc5ZkzwihOeQPCKE2oK7erc5UJsnaNdsQtOnB8qGv5zuO35HMlY/DeHvmDh+RzLNPjY73V98YxL+36Q4bluG9nWaanfy/Q3ZueQQj1pjJER98V6Wit+Pmx23lXV/ovlts7qfUVIcBRc1J/plE1Gvm9C3a+O+QIUQQgjR5J1cFEHVGqGsxEAA9r6RDEDR6CSafWwmeG8FliF9afax2dGBrvJnZdFTfGMSUHP9UWMpis6VFEaiadJosVssaL29Ufr1xjK0L2nT1QWMdoMOjQIkxQGg+EmXISGEEEK4R8WgPqe8r2h0EuHvmLBffjHtH1ZHhQLmq0WN9/L1lDfTAVVF1MkNF04eNWrqpDASQgghhBBCNHlSGIkmo3IX5/LhCaDYAbBbLJSGe+P943paP2tCHxuDds0mfBevg5StANi27XRbzEIIIYRo2rxWbqhxLPsBdZZL5ejQqVpvB35VNSJUOW3uVLx/XO90TuHNpz+/MZLCSDQJuu6d8Vmyjv0zjI723AAVg/vin17quF3aOdId4QkhhBBCnLXwd0xo+vRwFEj69m2xX34xRaOTyL2n9r2N7NV6UVuGOE+bq5xGV31qXfWiqqmQwkgIIYQQQgjR5ElhJJqEyulwLddWOKbUAVT4a8npFcDez3tTNDoJr5UbHBvAVnZuEUIIIYRwN02fHo6fhWOSyUoM5N0pbwFgadUM7ZpNaC0Koe+bHJ9hSq6v+syTM7Jqhoz3cucudN4/rm+SU+dOJoWRaPT2vZrsuO7943p8lqxD3yYWAMNxK4FpFbS/dTMB81OwDYinLETt4GIzyD8PIUTt8scm1zhWOKbqmEYv+9YIIc6set4A0MZ3d1x/9YA6le34Heo5lXsV5fQOJPBLM+HvmHi6rdqxTrtmE9nfd8HuraFwTDLaNZuwDOmL36J1FNyiPr7t6K01Xv/kKXVNnXzyE41euylq+8rKb1q08d0p6RrBga/j0P26Ee8f15P5sDofN72/gaAv1PNrW+wohBAAwZ+peaL8GnWEWaP3QleuOD7kKNYKt8UmhGgYSq5PJPBL541XjyZWbUD66A33ADg2Zz06yUjWg0ZC33fe06hyTVH48B0AHBlgJeu7Lo5RoczLbRy7u+a6I8uQvk4jR01xTdHJpDASQgghhBBCNHlSGInGL1ndqLWklR+HnjFSFuGL4Vg5O/vNY/8MIwW3JNN8RwXl1yTQ+lkTyqW93BuvEMKjVU6jK78mAcNStculYq3Ab2EKzVbtdmdoQogGxG/ROsf1ylktzXZbAHV0aNd9Pk7nR840EfG2yWm6HeAYQcq9x0jA/BS0JToiRqijRyP/yaXTv1Np/oF6TvWRo5PXGQkpjEQTUBZuoOCWZO59aQFlbSx4/7ie0kgfBkfH0XaqCd/sCrx/XI/hmJqMNL9vcW/AQgiPVjmNrrIoArVIKrglGWt2jtNiZyGEqE3OeOepbZXrh/SrNpB3ezKRM010vGs9WROqzjt2t5EVGVuxb9xGwa0n1ib90spxf2WB1GFiiuP8JReFsuuDvliG9KXw5iQuva8qb51pX6OmSAojIYQQQgghRJMnhZFo1MqvSUBrg6AvzHwweRT+O72xDEvgSLKeCXt2YxnaF68iK3m3J4Npi2MhtRBCVJfxWO0bJlZ2nzMsTcW7yA44T48RQojahM011X7HL60I+UQdlc5+wEjELBN7P+8NgFeJwtUDbyT3HiOlYRr1/CsOs/eNqs52e96sGgUKOKw2gel093r0pTYCv0phyfqLHW25q2/mKlRSGIlGS5PQA8PSVPy2pqNvE4uigX43bMJ7WSp2H4VHv7wNv+1Z2L21hHxiJm260WlqjBBCVIp+Wf0QUzYykZJRVR88FGsF5cMT2PtaMr7LNjm16daHhgKg0enqN1ghhMexDuxzyuP7vupFxaAT919xmKMT1S9i7Hr1UOhP6lojmzfY/t7F8R52ImeauOaf4+z/n5H2D5s58HUcx+42OqbRFd6chPfy9aQv6gZAaYQ3AB3Hp0r3udOQwkg0Otq4i8h4zIiS+hfa+O7suzsW64GDGJamsrdvGdEpQbR/2IyiB+uBg2hXbwIg9vtCMPZyb/BCCI917G4jPkvW4bdQ/VChDw9Do/fC8H0q7R8xqy26FTv6iHA0ei+subkAKDabO8MWQniA4qja9zbTr9pAu5u3OLYI8VkThV+2AkDkm+oXMiGfmDn8lJF1L84FoMNDag6a9/owOs45hK5bJ8IX+DoaLAAEzk9l7xvJtLz+bwpvTsL/m5Rz28BV0zRLhKb5roUQQgghhBCiGimMRKOR8aiR8msSsG/9h7IwhUv+tJA+IIjW00xYhiVQPjwBTWJP/vqoO0q/3ljCrGROVoerlUt7oWz4C31mnnvfhBDCYzX/wMTuj6qmw9iOHUfXPhaA8uEJ6MPDUGw2bLnHUKwVMoVOCOEQ/JnZ0bGycqpc9gNGjk5UN20F2P1uAmWXZzpt+pr1oJHce4y0esHE4Og49LExjvu8i+zs+l8ou5/2w/+bFNKnqs9TdFMShaMTaP+wmf3z4xxT5047he7kESLFXuf33BBJYSQajZZrCjEsTUWT0IOoFDv/91V/gvepU1jS++kxfJ/KwUcVjsXZ2HuPhk7/TiUqpQSoatFt3XfATdELITxF5X4iRx6p2XAh1OSNvlVLjt1lRLHZsO7cQ/nwBMqDdRRc1gGAvDFqExeZQieEANB17QSojVmOTjQ6psiFv2NCY4eAdBtZDxoJ3qYn8+GqvJN7jxG/LDuh75vQx8ZQeHMSu2aEUXxDEiUr2hFiTqfdzVsI/84HXbdO+Garjwv4OsVRBIUt8QUg43GjY7lA8Q3SpvtUpDASQgghhBBCNHlSGIlGQ1uibtCaN60Mv0XrsARBbg91KksLkxXLsAR6Rh0hcK+OTm9aajxeubRXfYYrhPBQyoa/0PTpQYvXnNvpFt6cROjH6zg8K5iI73ax+51ECsckY/g+laDP1akv+sgItDJQJIRAbdgCYNu+S90WhKqGCpUi3jbht2gdunL1eviWcgDH9LqAr1MoHJPMk79+B+Ny8FvvS3mIFr/B+7AePASArlzBFuhLxJJdoNGy76tejufPOrHfdGCaHUxbAPBfUDWlztGQoYlOnTuZFEai0bBt28ne15IJvno3+eOSiV1RRthWG4efNuKXXoK+yMrhomCiXjeRmRxExuNG7F7qPwHrwD6O6XRCiKZpRcZWLMNOTIM7sQt9dRX+WhSbjahr/8GanYNisJN5mVoFlQ9PIHDl31iPZqErV+o1biGEZ6reJU5TS91RdFPVlLbQ99Rz0x+wsCJjK37DjhL6vnrseCcNTzx6H4FD91CSUILPjZmUjEri0AJ12q/fonXk9vBn+3PtQbGj2+3nmC7XftLp1xdJ625nUhiJRqF8uPphJvo3O2UjEgieZ2bVlx/jVWxDWwGZxiD0RRYChuxF3yYWqz8oGtCu2YRlWAL6VRvc/A6EEO42ODoO72VVe5lpL+7m+NYWICC9An1oKPvnxwHQ+d5NdByfSu69Rgzfp2IrLKR8eAJ+C1PQ6L3Q6HTSgEGIJqyyyQJA8Dx1VLly5KhwTDIBX6eQc19V84WCW5JpfcNfXPzCfVgWRDoe650PfgtT6LjBQLubt1BQ6kPRbXmELPRXT0iOI/R9Ey1Wq5u+xj5j4uioMnXE6kRTBX14GPrwMJe/54ZOCiPRqEWU5nFnyi80KylydyhCCCGEEMKDubwwmj17Nm3btsXHx4f4+Hh+++23U567evVqNBpNjcuOHTtcHaZoyJLiONxfx/4ZRoqidfh8l8qBF42MunoUn/39Co+sXsptuT+y/9og7JdfTEWrZkS/ZKLVT4VoEns6fUMsPJPkEVFfcu4zkn2/kd1vJ7F7XCARb1dNhfH+cT3W3Fzajt4KgC4kBH1oKAEZVsc5hu/VfKJrFozWz08603kQySOivlWuJ8q9x+j4mT3AQtFNSdi8Yd9XvQibYyK/VwUA5lfmUnRTEooWvEZlOZ7HEqL+3PT6xQBEP6/F96sQAr9K4eiSrig6DYU3JxHyyx4OPqe+VuRCH5pvK3asHbJm52DNzqmPt92gubQw+vrrr5k0aRJPPfUUmzdvpl+/fgwdOpS0tLTTPm7nzp0cOXLEcenYsaMrwxQNXcpW2j9ipvl2hU1Pz0G5tBeWMCvXN1uN9zH1Q4llVzARm2xo12ziwDV+KJf2ojzMh4ogb8fT6Du2d9c7EKcheUTUh6yHjOhbRhM2x0T4bBOdPy50zM3f+0Vvx3n60FAAjt1lZPtzHbDl5TmKIajKI9bsHGyFhfX4DsTpSB4R7hT6vonce4zkd1boeNtGAr5OIeQTM+Hfq620O9613nFuWXMtEW+bOLpbnfa278vetH5WLbCyhpWx+90E7Bu3cbyL+hE+cF4wRTE+BH6VgjU7h9hnqjV3SNlK9v1GtPHda+5TdPJtAbi4MHr99de56667uPvuu+natSszZ84kJiaGOXPmnPZxERERREVFOS46maMtzlH3g4cZ+0vVgsKN4VL0NFSSR4QQdSV5RAhxNlxWGFksFjZu3MigQYOcjg8aNAiTyXSKR6l69+5NixYtuPLKK/n1119Pe255eTkFBQVOF9GEJMU5NmMMnmem4+rbsfrqePm/nztOSfdrzl4lGsOxCjIfNhL7YxkVAV7YfLROTResu/fWe/ji9CSPCFcpGu28waHPMQVregYAuz+NJ9MY7Liv/S2byZqgTk+x5uZSOCaZ5h+a6PjAOsdUuYJb1AXVkkc8j+QR4WoVg/o43bb3v7jmMS9oN8XsdCzwSzOFY9Tckf6Ekfjn78MSALveS3Cc027MZsf19rdspuO96gh1yC4FNFr8FqZg89Y4Pa8+PMzRkjt8tgltWqY6pa76KJG0566VywqjnJwcbDYbkZGRTscjIyPJzMys9TEtWrTgvffeY+HChSxatIjOnTtz5ZVXsnbt2lO+zowZMwgODnZcYmJiLuj7EB4uZatTW91OTx7joov+pBvHHMd+LYlEX1zBgWEGpoz/hrTBPvjtPUZZc62jNa/wTJJHhKsEzHduUVu5DxHAp/0+ImKWCcvQvvx3/wZIjiN68QHHh5Vmaw6iDw3l6ESjYw+QoC/M0oHOQ0keEa7mtVL9krWyC51XdhFeKzc4FUfhs9UiPPNhdR0jQNnIRAK/NGO7Mp6o9eUY8hV0lx4nYLeeVj+phUvlXkiVz592okW31qbgtyYcgOJoDdr47hSNTkLXrZO6ligpzvE4a3aO+jyKXTrTnYHLJxhqNM5VrKIoNY5V6ty5M/fccw8XX3wxycnJzJ49m2HDhvHqq6+e8vmnTp1Kfn6+43Lo0KELGr/wbBmPqwnj2LJOWIYlsPvpZkydudTpnNWtktg/MohOszP4+MGRRKbasO7eS7OPzLU9pfBAkkfEhVJ6nbrbYfrUqg8bh58yOn5mTTDyzAN3UzQ6iWOdvXh2xK1g3oo1PYPgf/TqhwsvL/AxOG3UWDQ6SRoteDjJI+JCsfdXmyAcvzPZ6XhlTrD9vQtQCyZ95w6O+7MeNKK1QvPt5dh/jsEnu5ysB42Uh3iR29XA3c8spiAzkOhXTHgV2ii8OcmxF9KuD/oS+aaJpQlz0cZ3x+KvpeSyowC0nGHCvnEbAfNTHK9Nylan2CqfJ//yDohTc1lhFBYWhk6nq/FtTFZWVo1vbU4nKSmJ3bt3n/J+g8FAUFCQ00U0XTet3UAMVQuet7ZsTbpXczdGJOpC8ogQoq4kjwghzpbLCiNvb2/i4+NZtWqV0/FVq1ZhNBpP8aiaNm/eTIsWLS50eKKRiH7JRP7YZJpfs4egpSYmz//J6f5l4UnsHt+S2GdM7L2zJQUPFZLTs2q6i7Tq9mySR8SF5rt4HaB+w1opZK86ZaXVCyY2PzmH4+OLyO2mRWsH219V7ZkL29qJ+C2LgvgWFH5sAI3WsWt8QazWsaFr5fQ64Rkkj4gLTbt6E0CtM080CT3IfNhIzn0n1iXu3OO4L+JtEz7HFHS/bkR75SHKwryJeNuE30I1j8x663o63pvK0YlGdL9uRF+msCJjK/u+7M2DyT9z7C4jd93/MP0/XUfzD03Y+1/MsbuM6CPUKXWHn6ra0PXkrnOV6yr9F8rnntNx6VS6yZMn88EHH/DRRx+xfft2Hn74YdLS0hg/fjygDjuPGzfOcf7MmTP59ttv2b17N3///TdTp05l4cKFTJgwwZVhigas/JoEDPk2Sq/tS/+hZYSWV23kWoAX5e+W0fYJE9aBfWixzkroNTuJ3Gg9zTMKTyN5RLjSkUeMFMRU/a9wwF13U5AeRPBehYi3nBfmd5iYQu4bGoLW7sF3WjCFoxPI+q4LoH5Jg0aLYrM5iiWZy+85JI+Iusgfm3zmk04oaemHvgzC5qgtune/q65NzHrQyMh/cgn6wuyYgufzXVWREjHLhK5cXYNU0NsCSXFYArVc9sC/iQrN54eHBpB7qYWKAC2/dPdn/wwjNoOO5h+asGZlA+qXOyh2cv9tdG6ukBxXta5S1hmdlt6VT37TTTeRm5vLc889x5EjR+jevTs//PADsbGxABw5csRpDwGLxcKUKVNIT0/H19eXbt26sWzZMq6++mpXhikagQBLKff8utrp2EraYPWRxdANneQRIURdSR4RnixMKWEc/9BukYnXBgxnZVxbd4fUZGkURVHcHcSFVFBQQHBwMP0ZiV7j5e5wxAVkuzIe3c8bAdDGXURFmC+6nzdy4AUjn6a9g3HuXkr0Bvys5QDczmDSNYEA6Dt3oCI8gLIwA7oKBa3F7tSqW7iGValgNUvIz89vUPPtJY80fjnjjWjsEJBhxbDUeWpJ1kPqFJio3/P58rsPGN0qGZLjyOrjT36fcro+mgY2Oz7f6ijqV7U7fe69RkLfNaEPDcWam1uv76cxkzwiPEnJ9Yn4ZpWj+X0LoDZ0qZyiW529/8UUt/B2jCDrenalPMKfY129ue6e1fzR05uDzxu5cclmpm74PwIU9bPLKloz5cFJBB+w0uWZbaQciSXgs2CKo7REbCjGEuKN9/L1ZD1kJOiAFZ/vN1A4OsHxOqKmc8khsu2taDAqiyIA+9Z/KG7hDUB0m8P0+PgwALlW9X8+61p0ZP0Tgym/JoF9ryST8Yoeze9b8P12Hd7LUqUoEqKJqexGVynokJXQ90wYlqZSulL9dvbII0YyHjXim22n581/s+N+Py6f+QiHFvQA81b0pdB1RgEl8W1Iv7UzZaMU0p+sWqMiRZEQjV/1ogjUdYuVXeoAtPHd1Z8n1iFVuu7rNeh/2oBm0DEWv9ef0lEJ/Pfpubyw/jNHUQSwhQha/JqDIaecX36NI/9oIP4LUoj+Xu1y6Lc9k8NPGYl4y4RPdjn2y3sR+FUKliF9ASgfftI2JBr5qH8u5LclPF7xjc4LmSs/4Bztp7bGvemjLQSWl1PRSU+r5qUALOpoJPolE7nd9LT62UqLx+2OlpnWgc6brgkhGr9jXdRptXtfS+bwU0YyE6pmkvdunk7hzUlUJBcS/YqJopZacm7wBwX+nDwHw1p15Ln538WkDw6nIkBHyyXp7H2oI7Hv7nQsfEajxXrsuHwQEaKRynzY6CiKjt2lfimSc5+R/HYGsu83siJjK1kJ6ohEwG8RHLlCbbmdPy6Ztz6+lrIRCYQP34GvtZz/rp/Hv9jl9PwHCOKLR//FjgdDIGUrbR830+JXLfrOHZj3x9cUtPdj+xPRtHrBRPmqNmDe6ijAvJevB8Cw9KQvfmUj13Mi2Vs0aMFKObet/R0Aaxc9mmM2sn2C+K1VNzdHJoQQQgjhLFQp5aMF79D/4DYsXjp+Rt0I2I6G14mnQufS5f/iDOS3Lzye/zfO82Yr5/K2Xgo3shN/i4VtUa0w7LbQkTLmDUqkLEiP7ZZkypsrHByhpfMHXlQuprN7y/cBQjQ1le252z9S1V73yBQjLV41EepdRH47LeVZfqzI2MrgaMi624hGW0HbH+6mw59lFI1OImB+CpEnHp7xkJHYp01YUdckBaS3d7TcFUI0DvnjkgmeV5Uzot6o6lTZ/EP1eticqmOXHLuXiN0F2IG/fu9Ap6kmDrxopHXiIbQftKTdkl94ISKFVll5KM11/KfvzTz560KwwBcjE1jeZzixz5x4PmMvMG1BZ1Fbfo9pZcRwjY2On5aj694Zw8Cd7J2ZRPtJJ+UdGSGqE/mEKDyXsVft10+I+m4tI9kLwJbMADpuz8KClrWlyYS+a8KQb6Pt42Ziv7Nj3/Q39k1/A7J3kRACCm5NpsWrJgpuTWbBp/2J2GKlY5d0Bo65g2f2bWb9c3PYN/QD9l/9AdfNXkVeB/V/lxmPGcl6yEiLX49Rel0iPmuiiHjLJEWREI1Q9aLoZJVreiqvZ04yEvzXMY49p64Xare4kLRpRto8aSKn2J9u+w7xuuF3WmXlkY4/yretuHn3GoItpez0juTLo0MI2aOQ+bA6Re94F18A/BamULS8PTn3GdVGMSlbKWkTDKAWRUlxlF9Tta7IMrQqLnHupDASDdZN7MAHG9tpTgzq/kU/05o8Q4CbIxNCCCGEUPX65xBvbniX0PIidrWL4GEGoPksn177DlGo8+HF8GFYtTKJyxNIYSQ8l2mL0/X8sckUjU4if2wyzZQyhukOALCiZTKX6dSudIN/tuO9LJWCW5PxzSim9NpEvJevV3eDFkI0KQf/6/zvfu9ryex9Td1YMaeXeizoczM2Xzg4TIP1xSj2/suLDaXt6PnafQyOjmPwqHEsvm8g4Vut6ENDKetVSkUA2P7age+36ym7PLOe35UQwt0yJxnxXr6ezElGMicZyW/vRWEnG1nGMIJeCaR0ZVv2XxtI62km+ipHePeJLwiwlrGNUO6eMZa2j3qheT8PgGeuHENGRgHFrXz57PlXiV5bQMajRgx5VVPigh/REZFaQPb9RvQto7H6aim4Vd1GgJStTlsOeOdZ6vvX0ahIYSQahN0f9SH4MzNHBtoI/szMjS2O42Ozsq1Za0JDitHYwNy2I3cEXIVlWAIaO9g3/Y3vt+vIvt9IyzUl7n4LQoh6UL2LpdVXbaddWSC1f8TsWGPUboqZwh87sP+lZFr910TH+9dR+kge+659jx+6BWP3gv0zjGrXpzWbyG+rx5qbi7VYT8sX1TUA5df0UVvjarQcnWiUbnRCNDIl1yc6WnFX7m8GEDXT5Pj5+aTXCX/HxCW9dzJxyjfY9Vp8B+2nzZMmug8NZLo2BR/FSipRPN36ZvqV7uW5V5YA8EnvASwf3xqAjKutXP3HBOwbtxFwRKEoWkfxjUnY+1+M7e9d2DduI3y2CWt6BpnJGoI+N4N5K+A8ra/ymDg/ksWFx9L6+jqud7xTbT/Z9YVsjs/txMg8dT7/Fz36M2Kv2ozhh/3hZCQVAGCvNiIdPttEYZuq5xJCND6ahB4ABBwsdhzTWjS0fNFE7NMmpu770zFatO/VZDInGzHFLaTDjO0UjU7CelUfeoZmEP/8feh6dCHsygw6fJFL1oNGikYnqeuI1kbS6Z71HHzeyN7XkzF8n4rh+1QOPp9E5Jsmx6JnfWho/f8ChBDn5NhdRvLHJjsdyx+bjPWn1o7beWOLHO2wI95Si6HMSWqBlPGokbKRiUxpo34Zk5Wcx7x7h/PzvA8B6Kcc5tWVn+Blt/FzdE9eWz0C77QD/Hfq9xiwY47swscxgyktMgAQElZEu1kKu99OwjergqI2Cv7fpKBdvYnMyc5fvLSf7Lz2yXv5erU4ki9n6kx+g6LBueNHE96lNtK6NKNZWSHBZaUcCghlHS3cHZoQooHT22zEF+6l1eHj7g5FCNFAXa4c4inWobMqfH/RxTwffzMo8CwmNEdsHAgKZ1rfMdilkPE48iciPFLR6CTspaVOu9Vr47uTfn8Qt3+vflPyaveRjN72GwBfd+2HotFgHdgH72WpNNtWQNnIRF48oG54pi9Var6IEKLRONZdbbqipP7lONZ2qvoNb+l1icxo15O4BLWL5Y1Xmbjq1nUMjo7j4AMX4XfEQkmkF/p7/Vn4+cu8sP8rPr3zY8r7aymKVSgNVf9XWfJ4FBWD+lARZKfzWxnqiyTH4XtUvVo0Wv3m2JqbWx9vWQhRBxG/ZxH8mfp5ouBWdeTIrgf9VWmUjFKnsEVf97fTY7IeMhI104S9/8UUd7Xgs2Qd2Q+oI0ja+O7kdvNh+vV9mco6dCgsiO/LrH/a4vX9Bj6d8xndOEahly/TW48ms20Aha30dLxtI9afWpMQmYb2hWyCd2rJivem3aPqbBiMvfDLUkCxo43vXmNUSB8eBpzY4FVaddeZFEbCM52oYyr8tOTcpw5X7x4bwORH5uNvK2dPSBRFERpal+RQ5OWD6VgsAFm9vdFe3A1LqC8+S9Yx5YEHAKSVrhCNXF5HDQDH71A/4Bx8zkj6k+oHlrIQLfteTWbnsg7sezWZRd9dQg+/w5Rel0irF0xkXOrD5cc3MXPTu7QuzgbAy26n+9u/Yw22orWqr7F/hD9eKzfQYWIK7/32hXrQvJWIt9UCLGC+5BkhGoq83mGO60GfqwVSs4/NZE4yOn1mqJw6B+p0uqyHjOT08CEiKh+AwENWXj2Qgn3jNgbaf+dZ81fogB/DLubJ628i88FLuLZjGT7/V4oNmHDbWA7/fYSIWSYiU/LRd+5A8act2Z9QwtFvYilsrxCVUk7mxCRKrk8E0xZHfPaN29gzr5fT+7Bm57jmF9RESWEkGgz/sjKuZw8An3S/itt//R2AJR0SKdUa3BmaEKIBu9v0My8v+wJvqr5tPYaBXTRzY1RCiIZkiLKfl+YsRovCd7TjzdhrULRaLt+3jfG7fwDgXeL4o1NnN0cqTkcKI+GRgv88xr5X1W9+w+aYsPpqeOjxrwnCwiGfUA55h3PZ9t3YNBo+vqIf1j37AChuZ6U8zJfsnt4A2PUat70HIYTrRZnVjQ4rp82VB6v/5mOfMWH1g32vJNPsYzPtpphp+T8T4d2ysXvDrDdG4bsohVuVf3jkl2UALKAj6fgDsJR2HHjuUjp8biP0XfVb4rZTTeyelcjuT+K5M+ZSN7xbIcSFUjnCe/xO5wYMlR3niloanG5X6nLTTqJMBZStDCf7ASN2vYbPn0viETaiVRS+7nwp/5nwAEcuCWHQ1KW8/ONn6FDYOCqWL66/hYgNCtar+rB7TiJ2g56KiEC0NvW5w2eb0FjBsOsIhXEW/BatI39cMrtnJ7L74z4AdBi7yZW/liZPCiPhkY5fHEqUyU7QF2ZWZGwl9KvfGeW9H4CvWl7O6F8WA7A2pju23QHsflfd9bnrqzl4rdxAzBJ1bxFdqc09b0AI4XKZk4xkJuc7HStpqTjui33aRLtHzRz6T9VUGFPcQtAohM79g5suzuc2/gFg1sVXs+Wm7rSkmJxAf969ayzb75lDwPPpHH7KiF2vrkPo+mom7T+WNYtCNFQlo5Kcbjf7SJ2mVjFILTyOnpg6F/SF2en8FRlqG+xjl+SS1yUQfTEEXZvB5W1+56UPFwCwiA683XUEzXdW0KHPTp7zTsXHXkEqkdwaN4Hf3nmfwH1F+GzPoON967D56MmaUkbgl2biNmspvDkJNFDUJ4aOd6jdeLP6KnS8fx3tP7FTfk0C+pbRLv4NNW1SGAmPFPSFGb9F69g/w8jg6DiuZj/NLUWkNW/O790v4kr9IQAWHwonq7c3He9VNzerHDmq/Om1coN73oAQ4oLIeOzUmzNHzTSROcno+MAC0O5Rs+O+/TOMjPwnF51FHTna93Iyg6Pj0JZruJkd3L3pJwB+erwL/9evL1O/XgrA+70HU+Ltw/jDyRyd245WL5iIet2E1UeD9cBB9l3v7cJ3LIRwpcr1Q5UNFyqbGVT/vJD1kJG825PJerBqvVHyo+M5vLA7uh5dKGuuQdHDwKt+4/nXv0MLfEd73v31anyXpFI0No/Xx31JqKUIpZs3D0yaiKWjhUsfupfMS4IoSFJbgh8c6k3zd/zJeNzIAnNfAr9Kod3CEnyWrHPE0vFB9fUrAvUYlqZiTc9w9a+oSZPCSHg8L8XGv9gJwLtXXMGo3Sa8rTYO9GrOdk3YGR4thBDObln3O3eidpuaS0/Wj2vL0ysW4U8F22nGN91PXYwJIQTAgH1/8iSp6BSFRV0SmUUv0GjQK3befvlrYikkJ9wfZV40JQYfd4crzpL+zKcIUT90XTth274LgG8Op3BjqySszazEX68lbFEZ2fpAti8o5wkvdb7vR1u6kD8ukcBDdvLHJjvabpaNSMDnu1TKRiTgd6gI++Z/3PaehBB1E/2yiWN3G2n+ganW+6Nmmhg8M479M9RiRvFSaLeolH3X+dLuURNLpoby+t73efCre4h92sTFw7x5dumXAHx+WwLvhI3mun9tYtCOH6nQaXlk8p2Evqp+Q/tTv97c8+RPLC27Ar8jZRS0BeuDRjpMNJH1oNHRjU4I0bAcnWQk8NCJZivVWlwvPLyOUa1qnh/0ezjaijSCBqRDjy4Mf2sBz+pT0KGwtH0fpowfRZulNnIXePNs/B8kbdxPkY839185nvQZLfBpBqFfeeG/Kwf/BXscz9vuMTPlwxMI/dtK9EvqzBfM6gi4vmU09shm2A16MG/FsDSV8msSMCxNddnvRciIkfAglUWR7cp4br5sNGUjE+lybwr3L/8FgC87X8GA7gqBFWUcCApnxdjrCP7MjKLTOIoiAJ/vUh0/pSgSouGrXhSVjUx0uk+T0IN9LyfTdqqJtlNNtJtiZt+1vhiOa9j3ajKahB682r6but7oX814celXAHzeux9jZhyjy2u/MHHvEgB+HdeFilcPqi1yASXXwPx3B+JdaAPzVvQlELGhGPvlF5Pf3VpP714Ica7KRiSc9ljkTBN+C1Mc0+mOTjJSvqoNo1olkne7czOG9EXdKLg0m6K31Yqp95+reYYUvKx2vu/di6eGj6b9w6lMee9zHvx1Oddv3IANDS+UJbAzsiXpA+2EbS7AatBiD/Ahf6zz82cm6Mnprkfp19vpuDU9g0xjMJi3YhnSF0CKonoghZHwaP05RIuS4+T6BrC8VTz/2qu26P7yov4osmO0EOIstVeO88aiT9GhsIrWvDxgJACT2UhoWSEHfMJZfnd3N0cphPBkvZQspmHCGztrackjY8Zg16qfRVr933Hu/nsVAG/Smw2aKHeGKs6TTKUTbqeNu4ii9oEY8q2UNfPCZtCQflk0/kfs3HRibdG3pW247OBfRJbmURhqYHVgHMGfmSm4NZmgz82UXJ+I36KqxYra3hfJaJEQjcyRR4xUBEHrJerIsu7njSipf9HuxJeo+15OJqJnFi20mfgOUrtY7pqdSKurujD9rbfwK7SwNb4Vr2/sQ+QbKUzf0YvpLMCClvFTbuXgjzF0+W0PB9bqaFXYh703vMvg6DhKrk/k2AQjrV4wkXdbMiGfmum4xo2/CCHEaVXOHDnTMY1NIeu7LkSOMMFM9VjIJ+oMlKOTjETONBH2sT+59xq5bO53PMcfGLBjpgV3vTWBNhNTmX/YzJq2kXR76AgAH8RfyY+bmpF9v5GIt0x43ZGMfeM2/L3j2D8yiIhNNgpvTqKsuZYWP2UR+5+aU3ILb04i8KsUImap93kvX3+BfjPiTOQrd+F29q3/4LdonaMo8s2uoPWzJq6es4i2FFCsN7CUdlxXuhaAL1oOQPlpi6MoAvBbtA7rwD5VzylFkRANXtaDVU0Qjt1tpMVrJlpdeoiykYlk9TKQOcnI8TvUaSkvHlhPu8fMBEwPwHfQftKmGcl41EhwTjmfvv0BkYUF7PeN4D9+d2LVaNE/0J4nVqlT6Ob2HIbthUPEvvMPRf2y2HnHHPSrNmCcMh775Rfjt2id4wNKyKdmsiYYOfhNz/r/hQghztmuD/qe8r7Ar1KIGLEDUAuh3HvVnJM/LhnNid0+DN+nkjB3GS/wO77YWNO5CxMefJidN34EwJT7r2fYg1vQKQrfXpTA28lXA+qeRLpunWj2sZnjdyajP1ZMq1/LKWqp42gShOy2YN25B8uwmtP+Ar9KoXx4zePC9aQwEm5Xcn0iu95L4M7/fkt2Hzh8pReFNydxb+/tAHzTzUjA5HC6HDxKKTo+HnwJANlDypyeR79KWnML0Zh4FSmO4khboe4dpL3yED5L1tFsj42Q/Taa7SgBYNzGO9T9R8xbObasE/Nue4u/Jszmo/+8RfuCTHLx4anSPrzyxfus2L+ZH9bMxLeignXRHVn6pzeHnzJiy8sjc5K6RcCeN5MI/NKMdk3VZor2y3qrTRdmmYi98U/AuXgTQrhP0eikWo93urv20RZdjy6AWhAdvzMZr4E5hL6rfgHic9xGxNsmdAEBtP7Ujxn8jj9Wtga3Yfzdt1F4eRmfFESw4tdU3lz+gWMUac4/rdAMOe54jV13hmLvfzGaUTnkJIdz7CID4e+YsPvZ8Fq5gYQtNryXpTqKoMo1lOXDEzB8X3OE6+T1SeLCk8JIeKS4rP3EbD6O1UvLlz0u59/L1Xkry2lLvq+/m6MTQjQEmmeziSeLUnQ8xSVka/zU49Ny0PxVznE/P5697GYUjcbNkQohPFG4vYgZUxbRjHK2d4zi6e5jKff2AsA/oxzNzRkElZei9PXhBRKxy9rnBs/lf4KzZ8+mbdu2+Pj4EB8fz2+//Xba89esWUN8fDw+Pj60a9eOuXPnujpE4QFa/Krlo6evpc1SC61+ruCOnxYC8H8JCcQcOk6/f/Zg1Wh55/7RxDxvYs+8iwlbqe4LoO/Qzp2hi3ogeaRpavax2dESW9HW3OzVq8hKcUtfAFqN2sb8h1/l5h1HCHklgD/aNEfzcT4AM0hkr6YZKzK2srB1DJpP1OOvlPSGFRlof22JJj4fffu2FHZS5890mJhC0lbnznPatZtrtOiuflsXGHgB37240CSPNG4B81Mc17W9LwLUUaTK69r47mjjqxqsKHr1I3DkTBP6G7NpPmwXuoAAXjqwjrx2eqIWB/Ff3WoisorYFxzJ07v7kt6jGZFdsgktLiRpeBqaI1Z2RUVyrd+jlGvUZfuKoq6BBPDJ0aBdvQm/2c2wBGjwLlBHvtvPt1MyKonUXjpAna5XNjLRsbFrbaNFgFMHXuEaLi2Mvv76ayZNmsRTTz3F5s2b6devH0OHDiUtLa3W8/fv38/VV19Nv3792Lx5M08++SQPPfQQCxcudGWYws38Fq3DN9tK5MR9WP10xNizSCITG7DijxDGrFkEwFqlJZo56lzgqB+8CTUddTyHFEeNl+SRpskytC/6iHD2vaxOHdHYwTdbcdzvs2Qdup834r8ghYP/VQumiaPv46suLejx60oeZDMAH7W9igVP3gDAmO8uZ6qfOq3mc7qw/N5RHLr3Ivo0S6Pl9X+TfVkUfod0HF3SFYCUOD1pC3oAcPA5I1kPGslb1hEApV/vGoWQrbDQVb8OUUeSR5qWHQ+oM0uCdhY41hzbN27DvnGbozgqbhNI0egkXjqwjuAnvQGwFRVx5ysP4xVUwrRrFxJbkMMR/Jgw+F72TBxA6Lsm/GYH8dH9XxJblEWmbwjTI8ZQsna747X13zWnPMSL9KlGykMVipa3x3tZKhGzTAQctrDns4vR/byRCj+No4ACHEWRcC+XFkavv/46d911F3fffTddu3Zl5syZxMTEMGfOnFrPnzt3Lq1bt2bmzJl07dqVu+++mzvvvJNXX33VlWEKD3PrztUA/EYrrGjoz2EA/o9OboxKuIvkEXEuwpUSnsWMFwqrw7vzRewAAHwUKzNeWIymREG51JfP6ObmSEV9kjwizpZPRTnvf/IB7ckn1xDAE1xGtn8wADrFzn9TPqNrcToFeDO53z3keAe7OWJxIbmsMLJYLGzcuJFBgwY5HR80aBAmU+27hZvN5hrnDx48mA0bNlBRUVHrY8rLyykoKHC6iIZH/9MGivpl0fafA1x5aAsAP30SzxOkokNhQ1gHlr87mPxx6rfHAfNTsO7ZB4B1zz7HddG4SB5pmvJuT8b7x/Wk3d6RgEPq+p+QT808OlXdnFV7cTe0F3cjbbo6UhT7tPp3wWDayDRMNKMcpbuBR8fcAhoNLV/8g+/5lrZpueTiw79+vxK7RkOFP0S/ZHJMZykP1qArhciR6re/ebcl0/qGv9TXeMZE9LIMLMvD0bdrg+a3zTJC1EBIHml6KhsuZPcJ4dAzap7ImmDk6CQjBR0DAAjYk0/A/BQeb5PIc4vmkT8uGS/FxjvvvsHFaQfIN/jyxOxr2X7bQEI+MRP15h/8wGKSj+6gDB1PcwnZq/aT1TdIff6HjGQ/YCS/PfgtTKEk1ooSVUbAkL2A2uRB9+tGQn8xoO19EVqrgu7njdgGxJP1kNEx5e/kjV5F/XJZYZSTk4PNZiMyMtLpeGRkJJmZmbU+JjMzs9bzrVYrOTk5tT5mxowZBAcHOy4xMTEX5g2IelF0UxJaX1+Kb0ii5PpErtFuRa/Y2UAku+Z2oQe5AKzNCSbydx3N1+e6OWJRnySPNC0FtySTd1syOb0V8m5LJvplExFvmzh2t5H0Rd14ffrNANg3/c3hgcG0ftbktEv9g2ymE3kcx8Ct265AM6SAI8k+3H/xAcc5U2+7hccOqsVO1BsmDj2rfmhakbGVqJkmomaqH5QtwxII+dR5Pr9134Eaa4yE55M80rRUdnjTxncn9H0TMc+Z1KKkHGKu3e9Yi1TQOQSAI1OMPHP9OHQ3ZjHlkn8cDVv+U57EoUl6yoM07PuiF69GrEeLOp33eZJY89Bwcu81EjZXXfcckG4n/B0TkRvsAHQcn4qttGq70MgTuSUozYJ98z8EfqXGoft1IxFvmShtpRZsmt82u/6XJE7J5c0XNCd1+1EUpcaxM51f2/FKU6dOJT8/33E5dOhQHSMW9aHwZrWtZsDXKdhLSwlctpXohWsYvk+dY/vqoyMZkrXRcf5y2qBowLZ9l1viFe4leaRpaL5qDyGfmukwMcVRlFiGJaBoIXCh+q3svlfUQqi0Ryn7Xkl2bMbYd6SOwRzEptHwwH13sv6/Awm+ejcfdJnFyC1qy+29MWHsn5fPk236ogsJAcCmLi1gcHQc+vZtsQxV9zzxXua8+LlwTFUBZt13wCXvX7iW5JHGq/qePxX+Jz7a2u0cv1P9dxs500To+yYs/dVNWLW9L8J/QQra+O60eNWEfdPf/Oea/+OKP3ZiQcurbw1hzcThACh6mDbmC3pkqevRTD3asXrUtUS8bcLqCxWrYukwbhPFUVoG/12A1VdD1gT1C5dO96gjV0cnqbd3fdCXgtbelA9P4OBzzs1k/Deqf1+kJbd76c98yvkJCwtDp9PV+DYmKyurxrcwlaKiomo9X6/XExoaWutjDAYDBoPhwgQt3Opa9uBjtbKlTQxb2sbw7qHPAZjRciRKhrTTbYokj4iz0U7J45mlqwGYOWgoKR07oC+BFkoRfR46iNausJJYHpt9K+Ejdro3WFHvJI+IMxnHP1zNfmwaDS8qiWzv0wrUGXCM3biasajTa2fRi7eevZ7wr9wYrHApl40YeXt7Ex8fz6pVq5yOr1q1CqOx9g3xkpOTa5y/cuVK+vTpg5eXl6tCFe6g0VByfSKFNydRNDqJH7f8wQjdAQD2PhzGvz/cSHBFCRk+zfmlfTwFtyRLm8omSPJI02LNyna6nXdbsrr54dB8ilppyOkNzbep97W/dTPtHjVjuaU3TwZtwcdqZR1RzO1/Be0fMfPBNe/wafuf8c6zcaynH1ft1/N6929YkbGVAy8YueJ3tamLcuL/ghmPGXlv9Wd4/7ieilWxpE81kndbMsqlvQAI/FLyT0MleaTxq97eOmB+CiWjktjzmDfNPlL/3R6ZcmKd0YMn1vJoteTdnox94zYuG4Cj8Hlb6c0fmpYcLQnAu0AhKaGER9d+p96XPJR3l4wg9sY/+W3We6Qt6EFBjwrKrOrfB0UDPw/sTNDnZiJmmSi4VR35KRuRgL5Yja3T3evJ76DB8H0qsc84T8u1ZqijWfJZx71cOpVu8uTJfPDBB3z00Uds376dhx9+mLS0NMaPHw+ow87jxo1znD9+/HgOHjzI5MmT2b59Ox999BEffvghU6ZMcWWYwg0CvzSjtUHm4AqODLHyfid/Am1lHAgK5411o7l14woA3rmuP3v+rSfoCzN75l3s9Bwy3Nw0SB5peizDErAMS6D5lnwCfougfGcwAYcV2k0xE32X2mhlRcZW5h8y8fzns4ktyCE9pBkv0Re7XsOKg1vwHqlFs7cCJVrPfX8O4IC+mHu/Gs/VXS+jzVMmVnVX5/O3nap+OIl+2cSNj6l/R3KWt6TlDBMhn5rR/L7FLb8DcWFJHmk8ikYnOV2vvH346aoGBpYADe1nqmt9yocn0OJV9d95xNsm8roFk90niONDSoh/2spTv6gt2OfRlWWadhydZMRr4EH6H9nKMz//HwCfxPfnO7MfUdf+Q+bDRgZHx9E8oIS4jmmU/hjB8TuSiZhloqhP1bqynJ7qOqfSMB3HLil3xGnzrdp2ANRmMsJzuGwqHcBNN91Ebm4uzz33HEeOHKF79+788MMPxMbGAnDkyBGnPQTatm3LDz/8wMMPP8w777xDdHQ0b731FqNGjXJlmMLN9FYb17EHgM8vGsDAA5uJoJRcn0AWJPdxc3TC3SSPiFMxfF7CZeRRgYYHx46lcFYGKAqaqVkkHSygxMsbn3lRHBvo6+5QhZtJHhEn67P9ANP/9z1aFL7pkcRnf7V03JegHGHaSjNaYEH3JF6/dDiRm2QkpynQKJWrCRuJgoICgoOD6c9I9BoZ7vY0ZSMTOTQQOk5Yx+6P1aJnX9EbaCccJSskgDHGqXz0w/9oTSH/u/ZqVh2/BO3azRTfkIT/ghSKRidh12sI+lwSVENgVSpYzRLy8/MJCgpydzhnTfJI/Su/JgHD0lQw9gLTFjIfNhL1homCW5LJ6QXRv9koa6ZzNGVopRQy2/sXfC0VzBg6gg+uuJx2j5lZ8cxqtNNzsANzXu/PJ38NZ8qTX/FBpza8m/Y7gz97DF0ZWP3U0aKsh4yM/vcqPvx+IG2nmogyB5OZnO+IyzIswdGIQbm0l4wguYHkEXE2SkYlcbyTlpYz1NGhrIeMRLxVNV1Nk9iTsggfiqL1xP11iLf+mEUgFfzapjsvfzCAvA9jCZifwtfzf8H/pjwM2FnevjeD1hRy8f/uJyjNSvH4PGw/hKFo1dEnv7WRlDweRXmYAcP3qRSNTqI4Ukvkm6YasfktTHE6pr24G/ZNf7v+FyPOKYe4vCudENX5LFlHxwlq5zltvp7rem5i+0vqHiJL82JJPL6D1hSS5+9L6vauaNeqbSv9F6gJJXOYRYoiIRoBfUS40+3jHdUJDPo96WQ9ZKT5LivZ9xux66Hdo2Z8vksl5FMztgHx6BQ7k6P/xtdSwe+dOvLrj160e8zMpUo6PKe29H+t30juuzmd4100PPvFGFZkbGXQF48x4bplxDxvQl+ivm7EWyaWvHClY0pd9aIIILtn1cQKKYqE8Eza+O74LUxxFEUAfll2jt1dtYZMWfcnuomZhJcf539bPiKQCrZEtGFGx9HsTWlLwPwUYoZH4XtTPgbs/Ny9K08NGUPvl+5HWwHH2+uxrApjwoOLKL5EXTRUctlRflz4Cflt9By/I5mA+SlEvmlyTJur3E7g5KIIkKLIQ0lhJOrdvlfVRNHpwzxsE5vR7VAGpTov3nxzFLft+BmA74rbcDgxmvyxyRTcmszuD9UWuuErDez57OJTPrcQomGo3mhh//w4dOVVxzVWyI/VM+Dudfgct/FtetXC6ryOBsbyDz0yDlOAF8GfFXHsTiNfff0LT3mtQ6sofJGczJDP1zM4Og67l4K+WG3H3XaqiaUXNVOfSAsH/68ngGM/keoqBqs5p/oHLSGEZ9n3SjIlo5Kwb9zmOKZJ6AGoTRhye9kANccANLtyD+99PJPI4nz2BUcy6eq7WD7vU3bcNYcuSi6zfnoXX2xsIJLHBtxO89nriJhl4tUn5hI104QGmP3G9bQdvZUVGVsBGBrdWx09yrFx/A71841GfVlCPjFz/I5kcsYbHfcJzyaFkXCrm3evAeCH1n25eG8anY5nUOTjzbd0dHNkQghPFJe5n9HsAGAm8VRE6emUm07zu46jr7CjDPFn+nXXwWn2pxFCND1eio3n+INYCsnGl4euuocCH3/1zj/LmMHv+JVUkNqqA9NIxqKX6Y9NkRRGol7teTOJdlPUqXDhYaUkZ+7AjoY3x13GI5//AsB3rZIp1HgT/JmZ7IHlBH1upuNd6x0tuzuM3eTOtyCEqCN9y2gALEPUUZm2b2kIn20i+wF12kv4bBOGfIW/+4LPd6nEfTYJANuwi3naNB8dsCi+D5++eiNPvjCWWUveQVuosK5dOy6J+A93DPuV0e88woqMrbR/xIzNB/a9nOxo2ZvxuJGY6SZi//UnAIeeqdmy2WvFehf/FoQQ56NyRAigw5f5jmlq6VON5N5rREn9i9x7jermrl4KFYP70u6mLdyXuJfu5FKo8+HBERNIi2lO6LsmbnxkJEWDjxJABZui2zKl/52Ua/REzTSxNH0jRyca+XfqWAAUIPRdEyWjkhgcHeeII++2ZAzfp9LsY/Xzjf83KY7jzT42EzbX5LhPeDaXdqUT4mStflGwDEvA6qNltu4/AKxt0Z2k4F10P5aGYtDwdfvLsLf0Yf9IHzqMq0okQV9IUhGiMbCmZwDgvfxE8WHaAkD4O1XT1kK25WO32ci7PZm2T5jQxl3EmJ2/0D47m1x8mLcxmt3vz+LIlCyaU05+Fx+Wvdedy4LXc0fwFn552Z/BL6sfXP6+fw6Do+N486CJ6/2nEDPdxN43kmn/sJpTYp5TX7dicF8piITwMEWjkwiYXzXdVUn9y3G9LMof7xPXq097DX3XhH51NM36Z1B8YxL/5m+Gr9tBBRqm2RLYEdOCyDdNRPWP5a0FcwjCwp9RrXlw2D0cTtShuSSRoJ06rtnZCq0V2o7eSpipGRhNZE4yEnzQRt5tyaBRp8sFjTsMnzrHmnuvkdB3q2LSxnd3mvInPJOMGAm3aF5WQMDiUgC+bncZN39+Yg3BmCCO+QS6MTIhhCeKKcvm1j2/AjCbOHywobnhMC0p5nBgc8wft6MsyPsMzyKEaGqG7UtlzInpt28Qz5+aCABaKoW8YXqPZpZidhPCfdf9m2JvH3eGKjyAFEbC5fa+nkzBLeqiQ32xDe9lqfzrn9/RWODP0FjembqE3psOY0XDJT3G4/NdKnvG6Wn/iIwQCdFYZT7sPH0t77Zksr7rAoA27iLsW/8BIGjsYWwD4rlvx0K8FBspRPE3YbzKGjT7KsjEjycKE3ng97v4X+RWNvbScPmHjzJ9/0b2vazmncHRcdy84wjXfqaOFgG0Xm51vHZlowUZLRLCs5w8WlSd1tcX7x+d/82WD08g60E1t9iHHqe3cpTHNi0AYG7iQFZp2qCN706Pd1byMmsJKy+ksLOBf9/+CM1vziR8tolO96wndJMO/cBcuOKwYyQ7x3hcfd0rjlEWoiXkUzO6cnXHG+2VhwCcYq0+WgRQ2C6grr8OUQ+kMBIuZb2qDzE/2zg6yML++XFYgvX4KFauy/kDgMW50WjeVJPND+374vVLKABRq/Xkj63ZwaW2Y0KIhkc74Ji6Z9EJIZ+aiRihfqtbWRQB6CcH0ueXH4gniwqNjjlPD+FVnxRaUcThZs3Qmf2Zd2QPaNQCKONxI62nmRi7cAKvXz+Pp/epnaN0Gju6sqrXP95JFlYL4ekqC43iG9T215XrEgHspaWO65Vfbhi+TyXibbUgsU2J5BldKl52Oz8Tw8J16v41Ph3KecUvhQhK2ds8kjt3DkT/6VZy5rQhwhwCQKtxe+kaetTReS59UTeOTlQLrogRO6rWC43LcXSbq63rXN5tVccq1x0JzyaFkXAp/U8bsHlpiFzpTdvRW/FbmMIgDhBQUE5aVDM2PJKEZlUxNo2Ged2v4OAoOwCKBrKustQohII/k1EkIRqDiBE7wLQF24B48sclU3hzUq3n2bf+w03RhwHYFtOSmf/9ilZluRzBj7F3PkDS708AEJCmYUXGVqJfMrF/hpF2U8xM/nYc/20Xx2eH/iBEV0Kr/1Z9gxvxtsnRjKH6SJF1YB9XvWUhxHkoGq1u8F58QxLey9c79ggqH57AoQU90MZ3x2vFerIeNDoKJ6+R3fjsudkE2MrZEt6W1+gDGg1zfl3LB4veIaokD1sHPS9/MpCD4wYQZmpGwPwUPotdw9GJRkouO8pf8y9icHQc1p9a0/L6v532Jzq6pCt73kzCNj/cUSTZvdVOmLn3Gjm0QG0QUbkhtWg4pDAS9UqrKIxiNwDzRiRx789qJ7qlfXpyKCj8dA8VQjRBLZQi4jP2A9A7LY1mlLObECZyBenNmrs5OiGEp/FWbLz828e0oIR0Anj8stup0OiIUQqI/VcO4ZYC9jSPpGRBBHlh/u4OV3gYKYyEy/l+uw6vYjtlIxO59bV0oikm38uPw+9ZuHqLOky9dH0EQZ+babFCz76Xk0l5aS5and0xQiRT6IRoXHLvUUdrClt7c6wbBO0tdrpPG3cRAM2uauX0uN/DLuIRLue4xoeANNh961wGR8ex5vHXWV9eAUDbqSZu3ZnO9ze+BsDYmEuY1aHm3mgtXq25eat+1YYL8waFEHWm9fU95Rojw/epxNzwF/aN29D6+hLxtom8Dnr+3TON7rlpFODNPfdMwL7oL7weaMecsF/wyrKzIyaKqcf6cn1vI9u/6UzMvXvIMR5n/mEzlz3wbyLfVDvaRb5pYv5hMzlLq3JQZSyRI7fTYWKK04hQ6Lsmx3S6mBv+QjRM0q5buMy+V5Jp96iZ3XMS6XjfOna/m0Dfd9Rvfr9tl8y1xXloD4OJFhzQBGMbEE/A1ynYvZIZHB1HezYDalEkU+iEaFwq/NUCKPR9E2Etox0tvAFC3zdhP3F9Q1QHUokknFIW0pEVOW3w+y0KLjtK6PsmOnYeT/A9Gm5sdSLnoOaKzzu35H9P30grqoqfI48YafFazWJICOGZqq8j8l+gFiW1tcM+cm9vCnqX88S4TxnJn9jQ8BxJlBxqRqurYnn7vXcwWKz80zqKZ8JvY/d1kY7nLbg0m/yxyYxuBdYfc2ExWPtnUHpdIqNbQVS1HHLsbiPNPzh1DpG9iho+KYxEvel28DBdth7FqtGSGtmJt9bOBeBzLnJzZEIIT2XRe/GUpp+7wxBCeLhLt+3mHtRNm+fSk62aCNoXZPDqhg8cLblvffIuwj4xuDlS4clkKp244EqvTaRicF+if7NRet2J0aIP+3LnH78BsEZpybVrl6FDYVWvrvw1cjAFtyaj+3UjBbcmo61QKLilqsW3jBYJ0fhEzTQR+r6J9EXdHKNFldPr8sclO657jzlK90060qYb2f1uAgDbV7d3PI+uVEN5M3W0SHNimOn9tN+ZnfYHFYGK02vKaJEQjUf1dtghzY4y5+XP0QFLuvblw3vHEfZCEDPXvUszSzHbImN4jMsIvW8nu+7zJr+rjTY37iVypomjE40Ef2bm6CQjJcsjWJGxlaMTjfguXufoRAdqh7nTjRaJxkEKI3FBVLbKhBNrilasx+e7VA6PsAHQ987fGL5aXU/0e+KlXKlVe/6/ee2VrJn7Pt4FNgpuSSboczOKTkPQF2aCvpCCSIjGKnOSkdx7jLS8/m/4pRW5SzsT+r6JvNuSCZ5nJmKd2sb/6JZItl1sIyANOt6bSvqTRvwyq57HqxCiXzbR7lEz3sc1HHzeSGt9IO31Aay8+RXu2JXm2M9ICNF4aH19AfBRrHzy8qcEYmE7zXgvcAiD313MR//5jEBbGX8HxPD00d7se7A/x5Z1ImiLNx3vX8f+he3Juz2ZLY/P4ehEI5EzTWhOfJcS+aZaMEW+qRZCebclO9YT5S7t7Jb3K+qHFEbigqhtY8SsCUY63rGBisF9uZr9eGNnO81IOLoLrV3hj8iuZO9ty+DoOA4NUoshy7AEAr80s2fexW54F0KI+lI5YqRvGQ1XHCb0mp2A2t429x4j6Vc0A8A/XW2BG75eLZRavmhCa1VHlw4/ZST6ZRMZjxl586CJFQ+8TOx/TAyOjqPjl+O5t/WlzJg7mnaPyZcsQjRE+nZtHNcr9zKqZC8tBUXh4ah9tCvKJBcfpmOka/ODPKc142ur4Pc2Xbjh9bsp1ngTMctE82G7HKNEkW+aKAvRkPzYeCLfNFGxKpbo6w8wODoOwFEUHZ1kdBRFebclO3KVaJxkjZFwOZ3dxnD2ArCBKMYc3ATAx50HujMsIYQQQjRgQznAFZl/Yj3RbCGBTCau+AGdorCaVjw84k5KDTZ3hykaEBkxEhdM2chEx/XcfxspaqOOSV+S9zdhlHE81JfQrgZ0isJvLS/i7+jW5F9bRNJWK5EpWkquT6QsRAdAh3Gb3PIehBCulXuPkfJrEhzXrekZHLtbncdfebwsXB1RyrstGUOemkdsf253jCQf71dG6PsmWl2ZxiV/Woh+2cTEWCPHbFXf9flkqyNN5c2qXvvAi1XrBYQQns+674DjemVXusqRo1gln/vZAsAs49V0SfJmMhvRKQrf9EhiBomEvZ1Kx9s3AnB0opGDzxvJnGRky+NzANj62BxKQzVk328k0Lsca/+q7pgAGHvhna842nDLhq2NnxRG4oLxWbLOcT30PRNtvivj6EQjN6UuB+CPqC4M3q6uM/qg5yACvk6h5SwvUuL0oIC+XCHoC7PsWSREIxb6vgnD0lTHdcCxoLnyuK4E0p80UuGvFjfpT6oFTfhPajephHYH1Se74jB/9PR2PPf1Cx52XI9+yUTmZCOx/zGx/yU1p7R5UhZOC9GQZU0w4r8gBW/FxhPN/sIHG1sIp9v+DO5LWQnAO0MH8PyVN2LXaAj5PYwVGVtZkbGVyDdN+OSABhgcHUf2/UbHNLrw2SbKLlcXLzb/I9Txekf7+uF7zC5tuJsQKYyES1109BDdyKVCo6N5STE6FH7q0o0doTHuDk0IIYQQDdDN7KDD8ROFDGUMPLIZGxpe52JeuW4oaDRujlA0VFIYiQvKfllvAPZ+3htLiBd3frUIgH9iokk8sBuAndMi+OGl19XzbvJi9+xE0IDvgTxA2nML0ZRkLO6mNlJY2B2Awh878MwDn9Ps8kzCZ5sInmfGN0uddne8i/ph59gluex7JRnblfGkP6GOJn126A+8j2vY/1Iy+15JJuNxI1GvnxiJypEPSUJ4srIRCae8r7L7HEDELBPRShH/oqoBQmsKKUbPhGH/5kdNOyJ/0xE508SKjK3sndeJkbsHMzg6jr1f9CbyTROx1+3D+lNrwmebsBo0HJ1kJP+HjgBc/Xc+xy7J5egkI8fvSFZHmarNhqm+ZEA0TlIYiQsic5L64SR9gJrA2t+6magla+mvOQxAT46gUxRMtOCtncMZ3SqZ/TOM3NvvFzQBFQR9bsb29y63xS+EcA/DD8EUXFlMwPeB7J8fh13RMOPlW/EbvA99uzYcWtCDXKOFwMMVRK6vWkTtk6PhsjfMlDdXOPQfI2NjLqHVCybeu/Fd2j1qJvqlqmlz0a/IFDohPJnPd6mO6/bLT9+VduiJLreVDhDEQ1zBnh9yyZpgpCxE/SJkcHQcmpE5HFzcDoD2t2zm2LJOlF2eyc8XfQ+AzQCRM00EX72bo5OMfPrOUI5OMqIvhmYfmym91rkQql4kicZJCiNRJ7qQEMpGJhI100TOfUa05VC0XN18cRAH8VZsWNGgSbNiBz6mOyF7FHZ/2Je2U0380t1fGi0I0URUbtp6srajt1ISrsE3xZ/gq3cT+kEKebcnY913gKDvAuh45wby23rhu3gdh/5jJMzUjOiXTPzR05t2j5mJeb6q8JnRrudpYzj4nDRgEMKTadc4fyawl5Y63TZQ9QXJUtry7+9vZ/dPPSm4NZmIWVW5oODWZJoP20XsdfsAsP7UmlaB+QAMvn4cebcnEz5bPT/7fnUfo/DZJiJPbCVwdKIR32+lEGpqpF23cA1F4Wr2A6BH7Sr1C605oAl2Z1RCCCGEaMA+oRt7CCFlTH8KvjpAua/3mR8kxFly2YjR8ePHGTt2LMHBwQQHBzN27Fjy8vJO+5jbb78djUbjdElKSjrtY4R72fLyHEPLYXNMhG63ETBkLysWpNCSIsd5Vo2WeVwEQNDnZjretR7bgHjg9HOLRdMmeaRxCX3fhCahR41jANFD02j1zQH0rVqSNy6RkE/UtYYp/5tL9v1GvIsU9v/PSNuPD5JjPO54fMZj5zYCFPuMTKtraiSPeK6T88HJqq8vqhjUB4ADD17OSk0bNg4KA8Aw8AA+TwVSHHViLaFW3TKkzX27ODrRSPoX6lS6/DJfMj5qR8GtyZCy1ZFjSq9NdIwcVVe5wStA3u3SLbepcFlhNGbMGLZs2cLy5ctZvnw5W7ZsYezYsWd83JAhQzhy5Ijj8sMPP7gqRHEBWQeqCcv7uAX7Zb1Z/p8Ip/u/b5PI2rlXOhZKl41IoP+bJm7akYnPd6kU3CJJR9QkeaTx0aXn1jimSehB7letsaZn0GfZQcdeIfnjkhkcHedowtD2CRPWw+lOj/1r0hzeT/u9xnPWVjDJNLqmSfKI51JS/3Jcr61IOvLv3o7rLafvQevri6JT23aHRhQ4PU+LV9VCJuItE6HvmTh2SS6Rb6rXAUKv2UnIJ2bKmqkFVNZDRlZkbKXlo3vIuc9Izn3O+aF6MVRZRInGzyVT6bZv387y5ctJSUkhMVFduPb++++TnJzMzp076dy58ykfazAYiIqKckVYop4EVRRz1a4/HbfLtF580uUqN0YkGiLJI0KIupI8IoQ4Fy4ZMTKbzQQHBzuSEEBSUhLBwcGYTKefxrB69WoiIiLo1KkT99xzD1lZWac9v7y8nIKCAqeLqF8anQ6rnw4Ar7wyhuxJwdtWtThyQftLKVm+neifNbQwl7H7oz7k9NSz9oEk3px7PQDehbZan1s0XZJHGh9NQg+s6RmUX6NOny0arU5NUlL/IvR9E/rQUL795DIAdn8ST1FLDXnLOlJyfSKHnzZScr1zhyj7zzEM3H4Nw2Y95jhWMbgvANEv1/w7ItPomh7JI55D367Nae/T2JQaxyuns2VNMJKVnIfSowMt3ttMxCwTzYftIvsBI7n/Vkd6Cm5NJuvBqusAQb+HsyJjK1kPGskfl0zxDUlEvF01sjQ4Oo7MF9sTNsdE2OZix+vm3Z5MdqLdcV00HS4ZMcrMzCQiIqLG8YiICDIzM0/5uKFDh3LjjTcSGxvL/v37+c9//sMVV1zBxo0bMRgMtT5mxowZTJ8+/YLFLs6dYrOhK1ULG01RKQPKdzjuO+7lzze7gyi9LpHMS+GSxL1ok/Md90f9pv6s3qpTCJA80hhVTpsxLE1Fk9CDgPkp6vFLe3G8ix/NPzBR2MOCz+3JdLzdzLG7jYQMU/c/81sEtivVdYmHnzbS6r8mtFceAiCaQ47X8Fqxvj7fkvBwkkc8h3XfgVPfaVewb9xW47CueTOOjOnq6DanpP5F3rhkNDYoDdPgm6MQ8e/9lL2nrl8ue0gtgJQTy40KLs1mMHHwIJSHaAieZybvthOFjkadIue97MTnj5StjtcN+cRMyCdV10XTcU4jRtOmTauxGPHky4YNGwDQ1LLrsKIotR6vdNNNNzFs2DC6d+/O8OHD+fHHH9m1axfLli075WOmTp1Kfn6+43Lo0KFTnisuHF1ICKB+O5t9v5Hc+0soWt6ewI56OuVnOM6bMXYwJRovfL9dR/tJKWSeKIoyH1a/1bFe1afeYxfuJXmkadK3jHb6WX2tUX6Hahs4rvaqWhQdDulTjRx+Ws0Xup83OoqiSulP1FwbIBo/ySONg667OpWxpItavFaO9FSyHTtOxCwTuz/pQ/449b7yIA1F0Ro0CgR9Yabs8kyyHlJzQPMRhwmeZ3asUwTIvddI2eWFRLxVlTe8i5SqgicpDoDjd6jPX3yDNNloys5pxGjChAmMHj36tOe0adOGP//8k6NHj9a4Lzs7m8jIyLN+vRYtWhAbG8vu3btPeY7BYDjltzei/vU/XLW2aDchLOgXT/uPN7sxIuFpJI8IIepK8ogQwhXOqTAKCwsjLCzsjOclJyeTn59PamoqCQnqXPJ169aRn5+P0Xj23+zl5uZy6NAhWrRocS5hChfRhYRgO9HitPKn14r1hF7WG+3sfwDo0mW/4/xJj99G+zs3s+/lZAzHNNh8ofWz6jc2UW+oP61+WtlMq4mRPNI0WdPVkWR7dg4AuVfGEjwvg9x7jPjl2CgPVicwBM+r+qa35Qw1T+hbtYRWLbEeTncaLQJo+T/TObfsFg2f5JGGRd+uTa1T6WzbdrL7nUQ6PqBu+xH0uRlNQg+nbnVaX1863r6BrAlGCm6p2sRVk9CD6quSsh40whKIIE29/ZCRiLdMaC0KrW+oer7K0aTK+yun0GnUJUX4L0i5UG9bNEAuab7QtWtXhgwZwj333ENKSgopKSncc889XHPNNU4dYLp06cLixYsBKCoqYsqUKZjNZg4cOMDq1asZPnw4YWFhXHfdda4IU5wjW14eZSMTHdPoAA5+05PMRF/KRiSgjbuIvcUxWLVaXjZeS/HWaPUDS6syWv7P5CiKqpO1ReJUJI80Dlpv580X7RYLoBZAWm9vQt83URqqq/G4yvVElT9Pp7ZGC0KA5BFPoOve+bTrizrMtzjdLugQ4HTbXloKQGRqISGLtjiOH00KBNS2/hFvmYh4W71kP2Ak60Ej3vlq2WQoUH861hahTpurPrUOcJp+J5oul+1j9MUXX9CjRw8GDRrEoEGD6NmzJ5999pnTOTt37iQ/X11zotPp+Ouvvxg5ciSdOnXitttuo1OnTpjNZgIDA10VprjA/q9lP3pOe4n5PS5zdyiiEZA8IoSoK8kjQoizpVEUpWZ/xAasoKCA4OBg+jMSvcbL3eE0KtWn0lWn79geS4sgDl/pS+tnTeT+20j451s48HgvxyhRwS3JBH1h5tB/jMQ8L9/uNhVWpYLVLCE/P5+goCB3h3PWJI+4htbb2zFidOxuI80/ODElJrEnyro/0Xp7kzOuj+O4ECB5pCHSt4nFeuAgRycaablE3ZTZeuAgoI4gaYrKHLdBbZAQ+q767z5tutFphsmeeRcTtMHHMcJTOCaZwC+rRncqVsXiNfAg+tXRWPtnUDIqCb+F6nS4Q88YiXmuZj7xWxtJyWU1156JxulccojLRoxE41NZFFkH9lH3HDixS3XWZZFo126m1c+l6Dt3IPQ9E3umxdH6WRPXbc/hwItGgr4wU3ptohRFQjRhlUURQPMPTBxe2B2AXfd7Oe4/XVFU2Z1OCOHZKoueyDdNWA8cdCqC7H7eTrcBR1EE1Jh233FWBdUXEwV+aSb7gapckPdtS/U1+2eQd1uyoygiKY6Y50wcnaieW/kTIOfNtnV4d6Ixk8JInBWNrmoNgNcvm7HuO4CS+he67p0J/WQdmsSeWEK8OHRNBMU3JNHucfXY4q5htF5RRu69RgzHK9z4DoQQ7qL19q6x1kjr7U2rUeq+JR1v2whA/tjTb6R4cuMFIYTn0beJPe391RsrnEnWg0aU1L8cm7I6nkOLo02/Uu2TbMinZg49c6IAStnK8TuS8Tqxb2vkmyZKRiWROclYVTwJcRIpjIQQQgghhBBNnhRG4ow0Oh2KzVbr9Yrmfhx+PBFtaQVexTZavGbiWFctKHb2jvIHQLtmE6HvmtCu2eS29yCEcB+7xeKYRlc5cpR1l/PmzpnfXkTwZ+q6gcIxNUeO9K1aujhKIYQ7FI5JdkyNq9z8HdR23BFvmxybt1YeA2h9wz7sJ/b6OHk0qfqaomYfm52m5/otTCFqpow8i1OTwkickWKzOT7MVBZF+lYtKR0Wj1deGbHv72Ln3cEY/lL3Doh53kTZyETaPaZ+yNn3cjL2yy+mbGSie96AEMJj2C0WsiYYCZvj/OEk6lp1L7STF1ZXsh5Or5f4hBB1U339kK57VUv08uEJtZ4f+KWZ8HfUAqhyj0OoNuXuqmM1jpVdnknE2ybyx51++q0Q50oKIyGEEEIIIUSTJ4WROCt2iwXrwD5odDp1B+vD6fjvy0dTVAp+vhiytVizsh3nK5qqx7Z7zIx2zSZ8lqxzQ+RCCE9TuXN9bWobLRJCNByVzReqN2HQde+M4ftUx1S4Uzn5/qNLuhIxYscpzw+eZ4akOOfHTDJSMirpXMMWAgC9uwMQnq363kX6VRtQgLL2Yej3HUDZfRBbeRm7P+5D5we2UDYsAbsONAr4fqsWQboeXbD9deqkJoRousqvScCwNNXdYQghLqDKqXTVp9TZtu0ETt+RLuItEydvrBk5cjsA+eOSKQ/ROM5zkrKV3bMS6ThhHVkTjETKGiJRB1IYidOy5eU5Gi7oenQhp08zQudvwQ4o1gq0fn50fuAf7CUlVPhp0ZfZnR8vRZEQ4oTqG7wCWAK1GNwYjxDCM2U9ZHQqgILn1RxJ/jFjM0Oje5M1wUjHCeq5pxuNFuJsyFQ6IYQQQgghRJMnhZE4LX1sjDpaFByM7a8dNPvYjKZ9awrHJGM39sReUkLu6DjKRiSgL7OT106P4Xt1asypOtAIIZomu8XitO4g8CvZZFGIpqx6a/7K9UUhv4fVnC5Xi6HRvQEZJRIXlhRG4rSU/EIAbPn5AGgNPti27STwSzO6VHXub/j3uwkw78PwfSqRb1YlKMP3qViv6lPzSYUQTUplu39wXncghGiaji7pCjg3W6lcf5R3aQ6Zk4w1HlN9PyMhXEUKIyGEEEIIIUSTJ4WRqEGj06HR6Zw60gFYB/Zh94zejjaY1sSulF+TgLV9S8p7xjpNnau8rv9pQ73GLoTwPNUbLgghGr/qU+QqlV5btcl7Zbe52s7PnGQkqpbOcrVNrysZlVTr6JIQ50sKI1GDYrOh2GxORRGo7bo7PJpKXnstFYP7YvXTY1iais1fj+7njfj+vM1xbuU6IyGEEEI0LbXtR1a5jUel6lPjjndWW3FrEno4FUVZD6rnlF6byNFJRsftSn4LU2otooQ4X1IYiVPS6HQ1julaRNFstw2vFetp/tRBtH5+6H7eSPnwBOwlJW6IUgjR0OWPq/ntshCiYTp5k9ZTbepafQSo9bO1FzcRb6vHfb9dR+RMk+N2paMyWiQuMCmMhBBCCCGEEE2eFEbC4eQRIo3eq+p6Yk/sl/VGaRaI72J1OLzgqZaOUSKZOieEOJ3qnelOVtvmjUKIhqmyu1yl0hZ+5/3YspHquqSD3/Ss9fxImUYnLjApjISDYrM53baXlzmKJWXdn+jXbUfZm4b9MnXvAO3azZSNkL2KhBBnVtmAofDmJDdHIoRwterNFHyWrDvNmTVVFkPVHxt7458XJjAhzkAKIyGEEEIIIUSTJ4WROK3qo0j28jLsJSV4HS91HPP5TqbQCSHOXuBXKe4OQQjhYoFfmh2jRtVHgM6kbGTiOY8wCXEhSWEkzoomsWp+r83fAOCYUme/rDfl18iUOiGEEEKoKlt2n1zolI1MdBRNJ3ekrH5ubR3njk6ULnTCtaQwEmfF5qMHTnzzk7IVfXgY+vU7AHWtkWGpjBwJIYQQjYHW4HNe99Xm5HWFPkvWEfilmaMTjadtvFK9sUJlQRT5pjRbEK4lhZEQQgghhBCiyXNZYfTCCy9gNBrx8/MjJCTkrB6jKArTpk0jOjoaX19f+vfvz99//+2qEMW5UBR0Pbo4hrmt2Tlo2rd2c1CisZM80riVXH/2aw+EOF+SRy4se3nZOZ3vVaLUevxcRn9kpEjUF5cVRhaLhRtvvJH77rvvrB/z8ssv8/rrrzNr1izWr19PVFQUAwcOpLCw0FVhirOkXbsZZW9a1W1fX2zbdjrWGQnhCpJHGje/RbLIWrie5JFzd7ri51yn0lVfN3QujRiEcAeXFUbTp0/n4YcfpkePHmd1vqIozJw5k6eeeorrr7+e7t278+mnn1JSUsKXX37pqjCFEB5M8ogQoq4kjwghzpbHrDHav38/mZmZDBo0yHHMYDBw+eWXYzKdegi1vLycgoICp4twDXtJSdX1UrVlt3btZneFI0QNkkeEEHUleeT0znUqXXWVo0en6y4nneeEO3lMYZSZmQlAZGSk0/HIyEjHfbWZMWMGwcHBjktMTIxL4xTqNDohPJHkESFEXTX1PKL19q7zc5xpylxta4ak85zwBOdUGE2bNg2NRnPay4YNG+oUkEajcbqtKEqNY9VNnTqV/Px8x+XQoUN1en1RRR8e5nRd6+uLrkcXx2iREOdD8ogQoq4kj7iO3WI5r8dVL4YqR4YO/l/PU53ucOyuqoLo5IKq8j4h6ov+XE6eMGECo0ePPu05bdq0Oa9AoqKiAPWbmhYtWjiOZ2Vl1fjWpjqDwYDBYDiv1xRC1D/JI0KIupI8IoRwhXMqjMLCwggLCzvzieehbdu2REVFsWrVKnr3VjudWSwW1qxZw0svveSS1xSnZ+kagzY7B1DbcwPw1w43RiQaA8kjQoi6kjzieap3n6sU+68/HdePTjTWOk2u+YdVx05+jur3CVEfXLbGKC0tjS1btpCWlobNZmPLli1s2bKFoqIixzldunRh8eLFgDpkPWnSJF588UUWL17Mtm3buP322/Hz82PMmDGuClOcgmVYAvr1ahEkLbmFu0geEULUleQR1yobmXhWbbhLjcVA1VoiabIgPNE5jRidi2eeeYZPP/3UcbvyW5dff/2V/v37A7Bz507y8/Md5zz22GOUlpZy//33c/z4cRITE1m5ciWBgYGuClMI4cEkjwgh6kryiBDibGkURal9S+IGqqCggODgYPozEr3Gy93hNCzGXmDa4nRI6+fn1Ka7OsuwBLyXpbo+LtFgWZUKVrOE/Px8goKC3B3OWZM8IoTnkDxSf7Te3mfdfKH4hiT8F6Sc9XOXjUysdbrdme4Toq7OJYd4TLtu4QFOKorORIoiIYQQovE4XVFUfGOS0+1zKYqg9jVIZ3OfEPVJCiNxSvbLep9ytEgIIYQQjVfxDScVQt84F0JlIxKczjm5cKqU9ZCsJRINhxRGQgghhBBCiCbPZc0XRMOnXbvZ3SEIIYQQwg3ONFXO5zvn6fSVI0onrxeKeEtabouGQ0aMhBBCCCHEBSHrhURDJoWREEIIIYQQosmTwkiobbqFEEII0aRovb3P6fzd7yQ6Gi6c/FOIxkAKI+HcpluKJCGEEKJJqN6e+2yKpI4PrHOsPar+s3qRFPBbhAsiFaJ+SGEkqtSywasQQgghGr+z3di1NtWLpKJ+WRcqJCHqnRRGQgghhBBCiCZPCiNRRUaLhBBCCHGWZH2RaGykMBJCCCGEEOes+voiIRoDKYyEEEIIIYQQTZ4URkIIIYQQ4rxUNl4QojGQwkgIIYQQQgjR5ElhJIQQQgghhGjypDASQgghhBBCNHlSGAkhhBBCCCGaPCmMhBBCCCHE2UuOc3cEQriEFEZCCCGEEEKIJk8KIyGEEEKIJuCCbcZq3nphnkcIDyOFkRBCCCFEE+C/IOWsi6MLVkQJ0YBIYSSEEEII0USc7YassnGraIqkMBJCCCGEEEI0eS4rjF544QWMRiN+fn6EhISc1WNuv/12NBqN0yUpSYZyhWiqJI8IIepK8ogQ4my5rDCyWCzceOON3Hfffef0uCFDhnDkyBHH5YcffnBRhEIITyd5RAhRV5JHhBBnS++qJ54+fToAn3zyyTk9zmAwEBUV5YKIhBANjeQRIURdSR4RQpwtj1tjtHr1aiIiIujUqRP33HMPWVlZpz2/vLycgoICp4sQommTPCKEqCvJI0I0PR5VGA0dOpQvvviCX375hddee43169dzxRVXUF5efsrHzJgxg+DgYMclJiamHiMWQngaySNCiLqSPCJE03ROhdG0adNqLEY8+bJhw4bzDuamm25i2LBhdO/eneHDh/Pjjz+ya9culi1bdsrHTJ06lfz8fMfl0KFD5/36QgjXkzwihKgrySNCCFc4pzVGEyZMYPTo0ac9p02bNnWJx0mLFi2IjY1l9+7dpzzHYDBgMBgu2GsKIVxL8ogQoq4kjwghXOGcCqOwsDDCwsJcFUsNubm5HDp0iBYtWtTbawohXEvyiBCiriSPnKfkODBvdXcUQngsl60xSktLY8uWLaSlpWGz2diyZQtbtmyhqKjIcU6XLl1YvHgxAEVFRUyZMgWz2cyBAwdYvXo1w4cPJywsjOuuu85VYQohPJjkESFEXUkeqUaKIiFOy2Xtup955hk+/fRTx+3evXsD8Ouvv9K/f38Adu7cSX5+PgA6nY6//vqLefPmkZeXR4sWLRgwYABff/01gYGBrgpTCOHBJI8IIepK8ogQ4mxpFEVR3B3EhVRQUEBwcDD9GYle4+XucIRo0qxKBatZQn5+PkFBQe4O56xJHhHCc0gecQGZUieakHPJIR7VrlsIIYQQQriYFEVC1EoKIyGEEEIIIUSTJ4WREEIIIYQQosmTwkgIIYQQorFLjnN3BEJ4PCmMhBBCCCEaO1lXJMQZSWEkhBBCCCGEaPKkMBJCCCGEEEI0eVIYCSGEEEIIIZo8KYyEEEIIIYQQTZ4URkIIIYQQQogmTwojIYQQQgghRJMnhZEQQgghhBCiyZPCSAghhBBCCNHkSWEkhBBCCCGEaPKkMBJCCCGEEEI0eVIYCSGEEEIIIZo8KYyEEEIIIYQQTZ4URkIIIYQQQogmTwojIYQQQgghRJMnhZEQQgghhBCiyZPCSAghhBBCCNHkSWEkhBBCCCGEaPKkMBJCCCGEEEI0eVIYCSGEEEIIIZo8lxRGBw4c4K677qJt27b4+vrSvn17nn32WSwWy2kfpygK06ZNIzo6Gl9fX/r378/ff//tihCFEB5O8ogQoq4kjwghzoVLCqMdO3Zgt9t59913+fvvv3njjTeYO3cuTz755Gkf9/LLL/P6668za9Ys1q9fT1RUFAMHDqSwsNAVYQohPJjkESFEXUkeEUKcC42iKEp9vNArr7zCnDlz2LdvX633K4pCdHQ0kyZN4vHHHwegvLycyMhIXnrpJe69996zep2CggKCg4Ppz0j0Gq8LFr8Q4txZlQpWs4T8/HyCgoLq/HySR4RoeiSPCCHq4lxyiL6eYiI/P5/mzZuf8v79+/eTmZnJoEGDHMcMBgOXX345JpPplImovLyc8vJyp9cBsFIB9VLyCSFOxUoFoH7QuBAkjwjR9EgeEULUxbnkkHopjPbu3cvbb7/Na6+9dspzMjMzAYiMjHQ6HhkZycGDB0/5uBkzZjB9+vQax3/nh/OMVghxoRUWFhIcHFyn55A8IkTTJnlECFEXZ5NDzqkwmjZtWq3/6Ktbv349ffr0cdzOyMhgyJAh3Hjjjdx9991nfA2NRuN0W1GUGseqmzp1KpMnT3bcttvtHDt2jNDQ0NM+7nwUFBQQExPDoUOHLshwfn1piHE3xJhB4j6ZoigUFhYSHR3tOCZ5pOH9HWmIMYPEXZ9cGbPkEWcN8e8HSNz1qSHGDPX7WeRUzqkwmjBhAqNHjz7tOW3atHFcz8jIYMCAASQnJ/Pee++d9nFRUVGA+k1NixYtHMezsrJqfGtTncFgwGAwOB0LCQk57WvVVVBQUIP6i1apIcbdEGMGibu6k7+dkTyiaoh/RxpizCBx1ydXxSx5pKaG+PcDJO761BBjhvr5LHIq51QYhYWFERYWdlbnpqenM2DAAOLj4/n444/Rak/fAK9t27ZERUWxatUqevfuDYDFYmHNmjW89NJL5xKmEMKDSR4RQtSV5BEhhCu4pF13RkYG/fv3JyYmhldffZXs7GwyMzMd83YrdenShcWLFwPqkPWkSZN48cUXWbx4Mdu2beP222/Hz8+PMWPGuCJMIYQHkzwihKgrySNCiHPhkuYLK1euZM+ePezZs4dWrVo53Ve9I8TOnTsdXVsAHnvsMUpLS7n//vs5fvw4iYmJrFy5ksDAQFeEec4MBgPPPvtsjaFyT9cQ426IMYPEfSFJHvEcDTFmkLjrk6fG3BjziKf+rs9E4q4/DTFm8Iy4620fIyGEEEIIIYTwVC6ZSieEEEIIIYQQDYkURkIIIYQQQogmTwojIYQQQgghRJMnhZEQQgghhBCiyZPC6AyOHz/O2LFjCQ4OJjg4mLFjx5KXl3fK8ysqKnj88cfp0aMH/v7+REdHM27cODIyMjw2ZoBFixYxePBgwsLC0Gg0bNmyxeVxzp49m7Zt2+Lj40N8fDy//fbbac9fs2YN8fHx+Pj40K5dO+bOnevyGGtzLnEfOXKEMWPG0LlzZ7RaLZMmTaq/QKs5l5gXLVrEwIEDCQ8PJygoiOTkZFasWFGP0TYuDTGHgOQRV2qIOQQkj7iT5BHXaYg5BBpmHmkQOUQRpzVkyBCle/fuislkUkwmk9K9e3flmmuuOeX5eXl5ylVXXaV8/fXXyo4dOxSz2awkJiYq8fHxHhuzoijKvHnzlOnTpyvvv/++AiibN292aYzz589XvLy8lPfff1/5559/lIkTJyr+/v7KwYMHaz1/3759ip+fnzJx4kTln3/+Ud5//33Fy8tLWbBggUvjrGvc+/fvVx566CHl008/VXr16qVMnDixXuNVlHOPeeLEicpLL72kpKamKrt27VKmTp2qeHl5KZs2barnyBuHhphDFEXyiKfE7Ak5RFEkj7ib5BHXaIg55Hzi9oQ80lByiBRGp/HPP/8ogJKSkuI4ZjabFUDZsWPHWT9PamqqApzyD/9CqmvM+/fvr5cPNAkJCcr48eOdjnXp0kV54oknaj3/scceU7p06eJ07N5771WSkpJcFmNtzjXu6i6//HK3JKO6xFzpoosuUqZPn36hQ2v0GmIOURTJI67UEHOIokgecSfJI5tdFmNDzCGK0jDzSEPJITKV7jTMZjPBwcEkJiY6jiUlJREcHIzJZDrr58nPz0ej0RASEuKCKJ1dqJhdyWKxsHHjRgYNGuR0fNCgQaeM0Ww21zh/8ODBbNiwgYqKCpfFWt35xO1uFyJmu91OYWEhzZs3d0WIjVpDzCEgecRVGmIOAckj7iZ5xDUaYg6BhplHGlIOkcLoNDIzM4mIiKhxPCIigszMzLN6jrKyMp544gnGjBlDUFDQhQ6xhgsRs6vl5ORgs9mIjIx0Oh4ZGXnKGDMzM2s932q1kpOT47JYqzufuN3tQsT82muvUVxczL/+9S9XhNioNcQcApJHXKUh5hCQPOJukkdcoyHmEGiYeaQh5ZAmWRhNmzYNjUZz2suGDRsA0Gg0NR6vKEqtx09WUVHB6NGjsdvtzJ49u0HEXJ9OjudMMdZ2fm3HXe1c4/YE5xvzV199xbRp0/j6669r/R9cU9UQc0h9xl2fGmIeaYg5BCSPXGiSRzxDQ8whp4rDk36vtWkIOUTv0mf3UBMmTGD06NGnPadNmzb8+eefHD16tMZ92dnZNarek1VUVPCvf/2L/fv388svv9T5G5r6iLm+hIWFodPpanxLkJWVdcoYo6Kiaj1fr9cTGhrqslirO5+43a0uMX/99dfcddddfPPNN1x11VWuDLPBaYg5BCSPuDuPNMQcApJHXEXyiHs1xBwCDTOPNKgc4tIVTA1c5cLBdevWOY6lpKScceGgxWJRrr32WqVbt25KVlZWfYTqcL4xV6rPRdP33Xef07GuXbuedsFj165dnY6NHz/eLQsezyXu6ty54PFcY/7yyy8VHx8fZfHixS6OrnFriDlEUSSPuFJDzCGKInnEnSSPbHZZjA0xhyhKw8wjDSWHSGF0BkOGDFF69uypmM1mxWw2Kz169KjRarJz587KokWLFEVRlIqKCmXEiBFKq1atlC1btihHjhxxXMrLyz0yZkVRlNzcXGXz5s3KsmXLFECZP3++snnzZuXIkSMuibGybeOHH36o/PPPP8qkSZMUf39/5cCBA4qiKMoTTzyhjB071nF+ZYvMhx9+WPnnn3+UDz/80K0tMs82bkVRlM2bNyubN29W4uPjlTFjxij/z959x8l1Vof//zy3TJ/d2V61qrYlW66ywcbYmGbHJqYZggMBgylxaAHHCSUVUpxvfpAYCIaQYAgBggFRDHZiDMEFXHCRu2Srl9X23ZnZqbc9vz/uzmhXWskS0kqr1XnzmtdqZ6fckdHZe+5znnPWrVunn3nmmXl7zN/+9re1ZVn6i1/84oz//2az2aN2zAvJ8RhDfpvj1lriyFwcs9bHPob8NsctceTIkjgyN3HkeIwhv81xa33s48jxEkMkMXoBY2Nj+m1ve5tOp9M6nU7rt73tbXpiYmLGYwD9ta99TWu95wrHbLdf/vKX8/KYtdb6a1/72qzH/Nd//ddzdpxf/OIX9eLFi3UkEtHnnHOOvueee+o/u+aaa/TLXvayGY+/++679dlnn60jkYhesmSJ/tKXvjRnx3Ygh3rcs/29Ll68eN4e88te9rJZj/maa645qse8UByPMeS3OW6tJY4crOMxhmgtceRYkjgyd3HkeIwhWh+fceR4iCFK66ldY0IIIYQQQghxgjohu9IJIYQQQgghxHSSGAkhhBBCCCFOeJIYCSGEEEIIIU54khgJIYQQQgghTniSGAkhhBBCCCFOeJIYCSGEEEIIIU54khgJIYQQQgghTniSGAkhhBBCCCFOeJIYCSGEEEIIIU54khgJIYQQQgghTniSGAkhhBBCCCFOeJIYCSGEEEIIIU54khgJIYQQQgghTniSGAkhhBBCCCFOeJIYCSGEEEIIIU54khgJIYQQQgghTniSGAkhhBBCCCFOeJIYCSGEEEIIIU54khgJIYQQQgghTniSGAkhhBBCCCFOeJIYCSGEEEIIIU54khgJIYQQQgghTniSGAkhhBBCCCFOeJIYCSGEEEIIIU54khgJIYQQQgghTniSGAkhhBBCCCFOeJIYCSGEEEIIIU54khgJIYQQQgghTniSGAkhhBBCCCFOeJIYCSGEEEIIIU54c5oY3XjjjZx33nmk02na29t5/etfz3PPPfeCz7vnnntYs2YNsViMZcuW8eUvf3kuD1MIMU9JDBFCHC6JI0KIgzWnidE999zDBz7wAR588EHuuusuPM/j0ksvpVgs7vc5W7du5YorruCiiy5i3bp1fPKTn+TDH/4wa9eunctDFULMQxJDhBCHS+KIEOJgKa21PlpvNjIyQnt7O/fccw8XX3zxrI/52Mc+xm233cb69evr91133XU88cQTPPDAA0frUIUQ85DEECHE4ZI4IoTYH+tovlkulwOgubl5v4954IEHuPTSS2fcd9lll/HVr34V13WxbXvGz6rVKtVqtf59EASMj4/T0tKCUuoIHr0Q4lBprZmcnKS7uxvDOPwF6rmIISBxRIj5TOKIEOJwHEoMOWqJkdaa66+/npe+9KWsXr16v48bHByko6Njxn0dHR14nsfo6ChdXV0zfnbjjTfyqU99ak6OWQhxZOzcuZPe3t7Deo25iiEgcUSI44HEESHE4TiYGHLUEqMPfvCDPPnkk/zqV796wcfufWWlVu032xWXT3ziE1x//fX173O5HH19fbyUK7DY94qOEOLo8XD5FXeQTqcP+7XmKoaAxBEh5jOJI0KIw3EoMeSoJEYf+tCHuO2227j33ntfMFPr7OxkcHBwxn3Dw8NYlkVLS8s+j49Go0Sj0X3ut7CxlAQiIY6pqR2Mh1tGMpcxBCSOCDGvSRwRQhyOQ4ghc9qVTmvNBz/4QX7wgx/wf//3fyxduvQFn3PBBRdw1113zbjvZz/7Geeee+6sNb1CiIVLYogQ4nBJHBFCHKw5TYw+8IEP8M1vfpNvf/vbpNNpBgcHGRwcpFwu1x/ziU98gne84x3176+77jq2b9/O9ddfz/r167nlllv46le/yg033DCXhyqEmIckhgghDpfEESHEwZrTxOhLX/oSuVyOSy65hK6urvrt1ltvrT9mYGCAHTt21L9funQpd9xxB3fffTdnnXUWf/u3f8vnP/95rrrqqrk8VCHEPCQxRAhxuCSOCCEO1lGdY3Q05PN5GhsbuYTXSU2vIJKI0NCalFapcyQINNmBHL4XzPpzT7vczY/J5XI0NDQc5aP77UkcEdNJHJk7Wmvyo0WckrPfx0gcEcc70zLIdDViGBJD5sILxZFDiSFHdY6REEeLUnDJu17CeVeeiRUx5YRmjoTBqMA3bvg++ZHCsT4cIY4oiSNzT2uN5/g8/JMnuPtr97OwLtUKAQ3tad7x/11FQ2tKYsgcOZJxRBIjsSBd8q6XcNHVL6I504yBeawPZwHTpNKTXHrdxaz9uzvkpEYsKBJHjo4An4uuDru5/fKW+4/x0Qhx5CgFl/7hRXQv7SAVSwOSGM2VIxVHJDESC040GeG8K8+kOdOMTeRYH86Cl4ylWHHuEhKNcYrZ8gs/QYjjgMSRo8fEpDnTzHlXnsmvv/PIAcvqhDieJDIJVpy3hGQshSmn3HPqSMWROW2+IMSxkG5JYkVMucJ7lCgMTMsk3hA71ocixBEjceToMjCxIiYNrcljfShCHDHxdBTTNFFyun1UHIk4Iv+lxIKjlJI63qNNHf7wRSHmE4kjR5/8nYuFRikl1XNH2eHGEUmMhBBCCCGEECc8SYyEONoO4+rRF77yOV731isP+vG7du/ilPNWsP65ZwF46NEHOeW8FeQn8wf9Gh//mz/j/Tdcd8jHKoSYnySOCCEOx/ESQ4zIoe8PlZ1gQhxt++ncdt1H30ulWuXrN39jn5+te/Ixrn737/HNf/s2f/B775jl2Qfn7DPO4Vf/8wDpVPqgn/PnN/wlC2zcmRALlsQRIcThWEgxJHAOvQGDrBgJMR8oeNPrfo8HH3mA/oH+fX689rbvs+rkVZx3zotoyjT91m8TsSO0tbYdUv1tOpWmIX38DFUU4kQmcUQIcThO9BgiiZEQ88QlL305LU0t/PCna2fcX66UuePnt/Om1715n+XrIAj413//Ahe/5kJWv2QVr3vrldx7/z37fY+9l69/8JO1nPvys7nvgXu5/M2XcfbFZ/DuD72L4dHh+nOkBEaI44fEESHE4TjRY4gkRuLEoDWqXDomt4OaeqrBsixe95o38IOf/mDGcvH//vx/cF2XK3/ndfs87Rvf+Tpf+9ZX+dgff4Lbvn07L73gIt7/J9exbce2g/6rqVQq3PLNr/JPn/oM3/zKtxkY2s3/u+kfD/r5QpwwjlEcOZTJyRJHhJjH5vu5CBJDZI+ROCGoSpmTLj7jmLz3xnufRMcTB/XYq177Jr76X//OQ48+yPnnXgDA2tu+x6Uvv4zGhsZ9Hv/Vb36V917zPl5z6e8C8Kcf+jMeeuRB/vO/v8Zff+xTB/WerufyqU98mr7exQC87c1v5+b/+NeDeq4QJ5JjFUcOJYaAxBEh5is5F9m/+RJDZMVIiHlk+ZLlnH3GOay97fsA7Ni1nUcef4SrrnzTPo8tFCYZHhninDPWzLj/nDPPYfO2zQf9nvFYvB6IANpb2xmbGPstP4EQ4liTOCKEOBwncgyRFSNxQtCxOBvvffKYvfeheNPr3szf/tOn+Os/+xvW/mQt3V09XPCil+z38XtvXtQa1CH0BLesmWFAKSXdo4SYxbGKI4caQ0DiiBDzkZyL7N98iSGSGIkTg1KHVIpyTChAw+WvuoK//+zf8ZM7f8KPfvoD3vz6t8zauSWVStPe1sGjTzzCeee8qH7/uicf44zTjs1SvRAL2vEQR6ZIHBFiHpIYMu9JYiTEfDF1YSSZSHLFq6/gX27+LJOFSd545VX7fcq7/+A9fOErn6OvZzErT17FD37yfTY8v57P/O0/H6WDFkLMRxJHhBCH40SNIZIYCTEPvem1b+b7P/4eLz3/pXR3du/3ce+4+hoKxQL/+Ll/YHx8nOVLV3DzZ7/Mkr4lR+9ghRDzksQRIcThOBFjiNILrAg4n8/T2NjIJbwOS9nH+nDEMdC2uJn3feltdLR2YmIe68NZ8Hx8hkYH+coffYuR7eMzfuZpl7v5MblcjoaG42e4o8QRIXHk6JI4IhYiiSNH1/7iyKHEEOlKJ8TRdvB7EYUQQgghThyz7GM6VIYdXogwIpFDf+5hv7sQQgghhBBCHOckMRJiruzvoseCKl4VQgghhDhE+1sZqu3wUeqFV4/28/PAdcOvjnPIhyXNF4SYK5IACSGEEELs64VaHBxMC4Tpj1HqiJx3yYqREEeT7C8SQgghhNjXoa4QTf/+CPWSk8RILDhBoKemJcuSzdGitZYp92JBkThytIV/34EfHOsDEeKIkd+NR9vhx5E5TYzuvfderrzySrq7u1FK8aMf/eiAj7/77rtRSu1z27Bhw1weplhgsgM58qMFCpVJPFx8+d+c/q/qVyjly+RHCnPy31PiiDgWJI4cvf95uBQqk+RHC2QH80f8v6XEEHGs5EcKlPJlqn7lmP87Oy7+p72D+7kK9nn8kYojc7rHqFgscuaZZ/Kud72Lq67a/8TcvT333HMz+oy3tbXNxeGJBcr3Ar5xw/e59LqLWXHuEkzLlBK2OaK1ppQvs/bv/wen7M7Je0gcEceCxJGjRIPv+Wx6ZBs/+/K9+N6RXzGSGCKOFafssvbv/4er/vxyEg1x1BFoRb3gKDV7Gdz+7t8P3z0ycWROE6PLL7+cyy+//JCf197eTiaTOfIHJE4Y+ZECa//uDhKNceINsaMajJRpon3/qL3fsaS1Jj9SmLOkCCSOiGPnWMaRE4XWmnK+QilXPlJbBPYhMUQcSzuf3s3N136DhraUxJBZGLZd7yJ3MPfPyrIojU0ekTgyL7vSnX322VQqFU499VT+4i/+gpe//OX7fWy1WqVarda/z+eP/DK8OD5pDcVsmWK2fKwPRRwDEkfEkSBx5MR1KDEEJI6I/XPKLqM7Jo71YcwrRiTygu209/eYg3nu3o/nIB8+r5ovdHV18ZWvfIW1a9fygx/8gFNOOYVXvvKV3Hvvvft9zo033khjY2P9tmjRoqN4xELsnzJNlGnW/yyODokjQojD8dvEEJA4IsSBGJHIjO/3l/BM/zr9MdOfv/dz937tvR1KEqX0UWqXoZTihz/8Ia9//esP6XlXXnklSiluu+22WX8+2xWaRYsWcQmvw1L24RyyEOIwedrlbn5MLpebUav/25I4IsSJ50jGkbmKISBxRIij7UDJ0nSHEkPm1YrRbM4//3w2bty4359Ho1EaGhpm3IQQYjqJI0KIw/FCMQQkjgixEMz7xGjdunV0dXUd68MQYr9+mzI5Ka07uiSOCCEOh8QQIQ7ebKVtL1TudqDH7l1iVxM4Tv12pMxp84VCocCmTZvq32/dupXHH3+c5uZm+vr6+MQnPkF/fz/f+MY3ALjppptYsmQJp512Go7j8M1vfpO1a9eydu3auTxMIQ5LrQPd9GTnhbrSnShd644EiSNCiMMhMUSIo6PWFCFwnH32CR1K8lJ77KG+xmx7kw7VnCZGjzzyyIwuLtdffz0A11xzDV//+tcZGBhgx44d9Z87jsMNN9xAf38/8Xic0047jdtvv50rrrhiLg9TCDGPSRwRQhwOiSFCiIN11JovHC35fJ7GxkbZ7CiOiukzi2p/PpSVo4XuSDdfOFokjggxf0gcEWL+ONRW2QfzvNl+Nv2+3/Y9axZU8wUh5rO9k6K9759O9hUJIYQQ4ni2d5nb/hyo9fb+HmdEIpip1D6J0PTSvLk2Lwe8CjFfzbZCBNRXig6UHJ3oq0dCCCGEWBhmmzG0996ivZMZM5VC75XwTH9s4DiwnwTqSDZYOBBZMRJCCCGEEEKc8CQxEuIQ7L0ipExzz82yMaIxWRkSQgghxAljeie6vUvg1LRVIz2ttfZsneaOdLncb/N6khgJcYim7xVSlo32/RnJkDJNjGjsWByaEEIIIcScOZhkQ03tFQLwC4X68/ZOnmr7imDfBKn2/MM5tt+qScQhP0MIIYQQQgghFhhJjIQ4RNNbcgfVyp77PXfG90IIIYQQC8HeKzt7d5GrrfCYqdSMVaLa19lWi/Z+PZVK1r/qWVZ7au+5v1WrI9GgQRIjIV7A3m22a2VyyjTrgaC2t6j2WO25sz5XCCGEEOJ4M1tCEzgOemofUS0Z8gsFjGnfT39u4Dj186bAcVCp5Iz38McnMFqa0YXiPkmOmUrNui/pSJN23UK8gNr+ISMaQ9kWQblcv1+7Hso0CaqVegOG6c+brY23EEIIIcTxZPoqzfTkSKWS6EJxxqpQjYpEMJjZunv6apI/PlH/cy1pCsbGZ0189CxJ0fTVqSP2OY/oqwkhhBBCCCHEcUgSIyEOUlCtEJTL4SqQZYfd5xrCJeHpe46m7zWS1SIhhBBCHA9m27szvfRt+g3AbG6ql71NL3NTe+0Dqu81amme9T1rz/ULhX1Wi2brWldzpFeLQBIjIfarluxM/6p9HyMaqyc+/vjEnlK7eDwst5tKmmrPk9bdQgghhJjv9pd8mM1N+zQ9UNNK4Wpqj6vNK1IdbahUck/SNDZef53pzRimv3btq9ncVN9XdKTnGx2IJEZCCCGEEEKIE540XxDiBUxvoLD3cNegWqk3ZfALhVlL56SUTgghhBDHm/pKjePO6DxnRCIQsWes8tRWkKavAnmbt+5p5R2x6z+HPY0TppfSwZ5GDdNXo2Zr9b2/znQH+tlBfebf+plCLHDTE5pamZwRj9eToRkzjFyv3rIbpE23EEIIIY4/00vZYGrPUDpMYmozi1QkgopGAVCpZHhLp+qvYXV11l9LTUuuaklL4DgzkqLp84kOZkbRgRKfw23lLYmRELMwM5mwuUI0hhGNhatBU626pw8xqyVIyrbQnlv/mawSCSGEEGK+2Tvx2Gfv0NSQ1dqKTa2Fdi1RUlOrRXpyqvGB46ILxRmvHYyN11/PLxTCWUfpaedOezVU2Luxw/Tk5kDJ0lyQxEgIIYQQQghxwpPESIhZ+NlsfQ+Rsq2wTM71wlK6chkVj9W/AmBZMwa+gpTTCSGEEGJ+md7lrVbKplJJYE9rbjW1L6i+p6elGV0oopoz9UGrtdeCcJVJV6v1P6tIpF5iZ/X1EjgOulpFpZL1fUq1Fai923rXjmF/bbrnevVIEiMhZmFEY/XSuFoZnYrHwLLCdtytzRjxeHi/aRJMTtYTISmjE0IIIcR8tXczAxy33iBBF4rheU86VU9eIEyWdKEYltI5LjC1h6ijLdxvNHVf7as/PhH+2fXCFt6FYr3krvbzWhJ0IHsnQnOdKEliJIQQQgghhDjhSWIkxJTaUFZlmvWOc0G5PGNAazA5ibGoGz04jHa98DZthajWsQ5k5UgIcWQdzQ3IQoiFZXr5nNncVG+yANTL43ShWF9N0pOFcMUnYtfL5HShWG+kUGumoIdG0JNTDRZSyfDxjoOZSqGnSugCx8FoaSaYur/23rVBsLXjmN4SvGbvZgx7O9wudPv8PR3RVxPiOFZvtW3ZYYJk2WHwsK0wCKSSmF2d4PlhSV08RjA5WW9LWVNLqmSPkRDiSDnc2RxCiBPb9Pjhj0/Uy9qml8sZLc3177Xj1EvrdKEIyxaFe4emkqZaV7paghQ4Dv74RL2b3fRkq5Zo1ZKh6TOKprfs1lNfZ+xv2k8b77m6UCSJkRDTKMvG6OoAwGiYqn21LPA8gpGx8PtqFTwPZYfzkf3hEczmpn0GwMqKkRDiUO2vNe30kwQhhNif6StDe99vNjfVGyvUkhwcF6OlGQA9WQhXc1qa9/xsUU8Yf7bsDC8SN2dQHW1A2GghGBuHSHgh2Vq+dEYDh/p7AETs+nOAWVtz1+6fvmpUe4yKHHiv0ZEiiZEQQgghhBDihDenidG9997LlVdeSXd3N0opfvSjH73gc+655x7WrFlDLBZj2bJlfPnLX57LQxQCCKc01zrR+Tt3YcTj0NKELldQmUaAcIUoFkWXw1I5Xa6Eq0SWTZAvhM+XVaIjTuKIOJHMNtxw+p9f6CqprCjtS2KIOJHsHT/MVAqrq3OfFRcIy9204xCMjddXgyBcOartFcJ195TXVatg2+iJbDi4tVAMV5eiUVQ0SrCzHyJ2fa+RXwhfZ++OdtO70U3fX3SgjnN77z2aK3OaGBWLRc4880z+9V//9aAev3XrVq644gouuugi1q1bxyc/+Uk+/OEPs3bt2rk8THGCM6Ix/OERtOdixOOY7eESMbnJ8Gu1GiZI8RhUqqjWZrCscI6RaaI9l6BaQXvusfsQC5jEEbHQzZbMzDbD42BKR2Qf0r4khoiFarZyudqtXsYWsfc0R2hvDR+4bBGqtwujpRljUQ9GZzu6Wg33EiXi9f1BtbI3mEpMHBc9kUU1ZerJlp4shA0WxsZntP+GcP/S9BbdtdfZu1Sutr9ob0d7hhGANZcvfvnll3P55Zcf9OO//OUv09fXx0033QTAqlWreOSRR/jMZz7DVVddNUdHKYSYzySOCCEOh8QQIcTBmld7jB544AEuvfTSGfdddtllPPLII7ju7Ffjq9Uq+Xx+xk2Ig1Vb8YGw8YJ2PYhGwx82psNuK9Fo2IAB0NkcVKph2+50esZrSRnd/CBxRMxnB2qsMP0xx+JKqQj9NjEEJI6Io2/vpiy1JgXBVImcdpywzK05E64e5Sb3tNmOWGFpnBsOYa2Xw23Zjkol69/rTHiuY3V1huV20SiUygRj47Ou8kC4KqRSyXr3OZVOzVrKN73ZTO3n+4t1R6sz57xKjAYHB+no6JhxX0dHB57nMTo6OutzbrzxRhobG+u3RYsWHY1DFQuE9n2MeDy8NaRQ8Rg6m0PFY7htKfA8sEyCkxdBMglLesKa2nR6z16jvbrRiWNL4og4HuyvcxTM3oFOSuSOnt8mhoDEEXF07R1D6vEiYu+ZFbSoB2wLPZ4Nu8LZFjSmcdoSAKj2VtzFbWGClIhDIo7R0ox/ch9Bd2t4367BMBmaei6JePjcSASjsz3cl+S4e2YTTZXO6UJxz16iRLy+36i272nvRMcvFOr3Td+DVDN93tFcmleJEYBSasb3WutZ76/5xCc+QS6Xq9927tw558coFgZlmlhtrQTlMgDa9VCtzWFNbUsT5m/WQ2MDVKqYO0egWER5AcHkZL1Vd+11ZLVofpE4Iua72gnBbAlP7Srq/k4EZPVo7h1qDAGJI+Lo2Lshy/S22LU9PTOGr9aSIgDXAyDan0eNhKs5ZskNEx9AJ8MB9db2IYxiFWwrPCeyrfC5ucnwMY3p8DVdL3z9KSoS2TM4dmqfkdHZTrCzH6uvt36fXyjUE6CgNhiWPfFwf40WjsYFojndY3SoOjs7GRwcnHHf8PAwlmXR0tIy63Oi0SjRWumTEOKEJ3FECHE4fpsYAhJHhFgI5tWK0QUXXMBdd901476f/exnnHvuudi2fYyOSiw0ZiqFmcnU9wiZzU1h/WumMSybawnbc7N6BToWTn0mmQj3GuUm63uRtOeifV9Wi+YZiSNivtp7mjuA1dE+4+e1K8AHWlGSsrq5JTFEzFd7ryTPiAURO9wXNNUprkZ1tIV7hlJJvMUd4SpPxApXgXKTGLtHqZ7ag07GUMVKvWQuSIb7jQCwwzI8Xa3CrkH08CgqlQy/J2z7TW9n+H5TFwf8QgGVTqHHs+H+IdcL9zzt1YLbiETqe5EO5vPPtTlNjAqFAo8//jiPP/44ELbAfPzxx9mxYwcQLju/4x3vqD/+uuuuY/v27Vx//fWsX7+eW265ha9+9avccMMNc3mY4gSjXY9gcqoVd2PDnoYLnofXlMDIFfEbYhhj4WP08l704DBUqwTj2XDWUTaLsuQX5NEgcUQcz6ZvLt67PMSIRAgmsvv8vPa1dn8tYTqU9xR7SAwRx6vZ5pjVvqqp2KIdJ7y4O1WOppoz4b6f3k5Ytoggk0Rn0njdU6udtkX+lEZwPYpr+vAWd2A4ASoblslVTwqTJyMbzigK2jLoiWyYHEG9KUOtLI+IHSZouwb3tPme2kfkDQzW5yHVkjU9LbGbbS/RgeLXcV9K98gjj/Dyl7+8/v31118PwDXXXMPXv/51BgYG6oEJYOnSpdxxxx189KMf5Ytf/CLd3d18/vOfl/aYQpzAJI4IIQ6HxBAhxMFSurajcIHI5/M0NjZyCa/DUnJFX8ykTBMjHq9vTASm2nGHXeWCxgR4AUHCxly/HdXZBmMTYUc6y4Rc2H41yBcIqhWMaIygWjkWH+W44GmXu/kxuVyOhoaGY304B03iiJgLe3dhmq0c5mi1pD2eSBwRIlxdqZWeQTh8VRfCVR09WUA1Z9CZNHrDZoxli8MnuR7FVW0kn9xdb7utHA9KZXIv7iWS94lvCjst1h6H6xF0t6K29qOawtUiFY2i25pQIxNh+ZzjojraoFQOB8ImY7BlJ6o5QzA4DIRxzWxuAqh3qpse26Z/nrmOeYcSQ+bVHiMhjhZdrhC0N4PnEbSkcbsa0TEbVXWpdiYJoib+qsWQmyTobicYGEKPjoeld+UKKh52bpGkSAhRM9sU+hozlap3jaq1qw0cp14aUyspmW3Wx3S1Ew0plxNi4ZteiqunJRoQJkZGZztBdyv+6uVg26hiBWNRD14mbMdNqUx8oBSW0jXG8BOR8Ge2TWzcJb49i07G8NoaSOyYDMvoEnGU64fJ0EQW1ZQJ3y87Gc53jEZRvV1QKtfnIKmRiRn7iVQqGcY0J+x4V4t10z/X9CRvPpHESJwQlGmiTDNstBCPoVqbMYoVgr5ws6BR9aj0hFcRvISB8jXWyCS6XMEYHq8nQv7W7ah4bM8eJSGEmDLbsMXpJzVEbHDc+vDF6XuH6puQC4X6/bOdNMx25VUIcfzb30yzWhypJRwqEoHTT0YXiuhMGiNbxNo9hk7GCDJJvLYGzOd3oCMWQXcrRrGKn4hgllz8pIXbGCHIJLGzVchN7aW2DZy2BNFt43htDeGqUiKOXhrOQcK2wu+Hp+Z4lcIxJzhuGJNsa8+qleOEbbmnWoR7A4MzErq957O90MWgo00SIyGEEEIIIcQJTxIjseDVBrCazU3QMnUDdMzGaYqhTYXbECXWn8dtTWKVAqyJEl5buj7IVcVj4c2y8ccnpEW3EGIftVWe2hVQq7en/rPAccLYsddKz96rTBCuLu29IvRCQ19nOxYhxPFjf//ma2W49VK1dApjJFtvj11bzQEIbBNr9xj0dqJtE+X6VHsa8JMWyvUxix5Og0m1NU61NR52pWuMEUTCdCDIJPGT4XmPTsbC98lNhqtCrodKJXFXdO3pUNecCVfBB4fDznOFYhj/plqH1zrQ6UKxvhI+fRUM2CcmHmuSGIkFb0Zbbc+HikOQjDF+TjNW0cVpiuElwn8KZslFW+Fkc2vnaNh0wfPqt6BakaRICFE3WwJSa7etszmMpkx9VpHV0Y7R272nRe1UqUm9ze60vUcwsxRv79lGL5T4SKmdEMe3elxIp8IExLbChgeJOO7iNpTj4SciYclcMkpheQOTyxIUz+jGaUtQ7kqgbRPDCfDiJl5jDLcxQnJnGachbDgVHa1ibx8hum2cSrNNYJuYRa9+DEHb1Pu2t4Z3uB729pF6eZ0uFGe06NaFYr1k2BsYDEvlauV/zIxLB5rVdixJYiSEEEIIIYQ44c3pHCMh5gPtuVhdnZBMgOcTtKTJn5RC+eA0R1Fe2LF+5MUttD6eR3ka5QUQi4YrTJZFMJ4FwrI8QFaNhBDAvldAays5RiSCSibQrguOG5aTFEvgunsGuBamVpwct/4a04fAziidi8xs9zzfrrIKIX4709tVz1gJdlyMlmZoTIPr1dtmY1tYuQo6YuEnLayRPM6SZgxXEyt5GF5AbkkUgEpzGt9WxMd9gojB6GqbSMHGi4HdYBBtMEm7GdxMlOTOMuWuGMkdRcqLM8S3Z/ETEQzbxm1LYeUqeN0ZrFwFVQw78tZK51Q6VR/gWmu8YDY31ZvF1OKa2dyEPz5xlP5mfzuyYiQWNGWaGOk0mCZBMoazpAUvHSHZXyUx5DJ+8lQtralo2O7gpSPE+vNUehvxm8NlbD1ZwGhIoT0X7fuSFAkhgPAkZnr77en7i2qUbYcd56Za3kJYUlcrr6uVywAzOtLBzESrdjIhe4eEWFimJ0UqldxzS6cIulvREYvqkmbo7STobg27w9lm2DkOmDyjPewwB1RaLJwGi8ZtVZqfKZLqd4jmA6xSWE7X+rRLqt+j46FieH85YOTcBqL9eazdY1ilgNwpaWIDBYJkFG0bYQe7TQMA2NtH0LYJrou3Y1d9XlIwNg4RO/wsU6V0NbpQrO+Xmu9JEUhiJBYwZZqYXZ2ozjaClkYmT2rAmnSoNtkoL8BNm6QGApy0iR9VeAkDL2mhKi6xbeOoqh/uLSKcezRjr5IQ4oRW2yekC8X6yYDR3oZqbw3HAkQi4WoRM5MZNbVpufYzHHfG5mM97SSp9jqz1eVPb+ctyZIQx7fp8UQ1ZcK9O5MFjGIV5XiUOiJ4jTGU61NenKHclaC8OBPeHzcodyUYP8Uit1QRWIrR1VHGT0viNFgYnsZLGBjunq+TyxJE8j6Gq+n4+QCTq5pxF7cR2IrG58IW3oFt1o/PW9wRrhK5Hsr1wbaxVp6E3hUmTEZLMzhu2OTKmVoVd9xZ9xbB/I5ZkhgJIYQQQgghTniSGIkFTReK4PnoqEnjIwOMn54mMBW7L04SmIrAVFSaDbxYuGIUGa/itaXDvUUbtoSv4XpoN+xIJ4Q4scw2aLW256dWBmf19qASCXQ2B8USQH3Ioa5974Z199p16/uO6l2nppXTTb+yqgvFffYcTX/cfO3qJIQ4eFZfb1h+dvrJ4R2lMv6LT4Nli/AyCbxMAqschANaExEme8NV5/wSm0qTwnA1hqvJbAnL/ANbYRfAj4GTNsj3mXhxg1KHxfA5JoGtiI15eAmDwJ7qwlsKsHIVKs0mfsJGjUzgNkawRwoYI1ms7UMA6GoVlZ1ET2TRw6Ph3iLHCYe79nbVY5YRiRywDfd8jlmSGIkFxYjG9vw5nUbFYwSNCbRpkDu3C6uimVxkoE3wEopyq0KbEBsPA4rbEEH5AX57A0ZbS33jYG2ekRDixDI9AZmeJOlCMdwc3d4WJkQRG5VpRBdLYTlMKolKJuoldkCYPE3FlPprsGcDc72N97T3rr3f9DbesyVrQoj5b/q/Z7O5KSw9cz1UNIqxe5TgnFUE3a1YuQqlvjRmycFww5I3NxMld3ICu6wp9FjExgNiE5pqQ9hUwUkbRLNQalP4MahmoNKkSO0OcONhAtS8XhPJuZQ6wnOaYoeF19aAlzAo9aVp+fUgXsJi4uVLw31GW7ajM2mAsPlDKgluuMVARcMGD2oqCfI2bJwRxwLHmXFhZz4nQ9NJYiSEEEIIIYQ44cllcLFgKNNEey5GNIb2XFRnG25bCrchXHY2nYBKysSqQCQPuWUKN63peDjckBiYCqvkoU0Da1M/ulwBy0LZFkG5fIw/nRDiWKl1m9NTwwp1oVhfBcJ1UT2dUCxDMg5NaVT/UL3JgkqEq0aKBLguRm93WG5n22GpScQGx0ElE3hDw+HV1oiNPz4xo41vrTyl5ni5+iqE2EOlkjA+NRB1qvW2Hs+ierugFJ5nVFvjVFos3LjCcFMEtsJpMOurRLllBm2Pu3gJg0K3gZsCJ6OJFBRmBbwMBBbER2F8dQAYBBY0P+cT2IpKawSrrLFKAXbcwE9aYYvurgTVJc0YXkDTY6O4bSnsznbcxhim3QpPPY+KRsNyumg07EQ3jRGJzFghqt13vMUqWTESC8L0+UIqHsNsbsJrSlBtCpeXraLH+CqLiVMUpQ6YOD2geUOAPanILzaITvjEsj7WU1uxtoW1tCoeI5icxC8UpEW3ECcoIxLBaMqgkokwqXHC5EZnc+BO7SGqJUXZPPSH8cNf0knQ04YulaBYCr/a9p6kyJ3aY+S4YbneRLb+nrX2tiqVrJfN7X2CsXfZnRBifqt1bINwD6Jua8Jd3IbqaKO8OEPxjG6qrVFGV9ukdlZofqZIpcUiu9zCcMN5i4VuA7sApT/OMvCSMOExp7Y/l1vBLoePa37OQ3mQ2mZgeBDNhmVz+T6TfJ+JVQ6otFhY5QAA5fokn9xNYBmUOiLoiIW9fQQScaxcBWP3KEZnOGKg9hlUKjmja+b0MrrjOT5JYiQWhNp8ITOTCROa7nYMxye73MKLKSZOjuFHwCqB8kE5isleg0gOyl0B1SYTP6JQrc1gmuhyBX98QhIiIU4w01dlaitFwUQWkgmCXbvrMzpUT2eY3CTDlaDx89oIetpQbS2oRAJj404qHQn0km5IJlC2HSZHU4/XhWK4xyhiY3W072nAELHrJxv++ASB48w4+Zi+giSEOL5ox8Hq692TZEA4JyjnENgKLx4mMkHEYGRNkoGXezRvcDE8TWCBPfXPvnhPG34qQFvgnF8gPqhwU5A9SWF4UGk2mVwChSUBzRuqmK6mmoHEiCaz2as3bAAILAM/EaG8qovAVjQ9NEhheUP4fTKK1xhDTxbQ49n6ENfaqlH9MzgOetqeotrX4221CCQxEkIIIYQQQgjZYyQWBmWaGPF4eNU1lcCoujhNaVQATkph+KBN0AbExqDc56HHbCJ56Pm/gOiEi5ew0DEbVSyFe4ssW1aMhDiBTC9XM5ub9gxjdRyCTBKVTaLaWsD10JHw16e/pBOAxo1FtG3iZxKQSWCU0iSe2h2W3CUTuCd1Y+Uq6KlSO2NpH2TzeEPD4fulUmGL26mBsWZzU/3Peq8SuoVQxy/EQlf7d7lPWZnr4a7owspVcBptiifHaX6miJM28O2wi5wXN3GnnjZylk1gheVwpquZOF3jJ32srEV6p2Y0k8KPgeGBFwMyEFiKzEZNsctg4Pwo6Z2axIim0qQYX2XR+ZAXtu0ed4k+20/Q3Yqdc7B2j1E9qYP4QAUrW0IPj2JHo+ip8QTB4HB9n6U/PoHV1YmxwMYGyIqROO4Z0RjKssGyIBalcHITwxe2UW2yqbRAbCJcLo7kwF1aIX+yj3IMqhkodYSvYU2U0JZCeWG9bTA5ifbcY/SJhBDHQu0kxkylwhlE7p5aemM4i3fqYoJkFKevGW2b0NNBYBsYJQej5GCO5DGzJcz+sfAFIzaqpxN/SSdWroIqVsLEynHxntsEmQasjnbMVCrcw9SUAcLkp5YU1Ur7avuMZiuhWygnJEIsBNPbVZvNTWEc6GgLS89OPzlMQkYKlPrSREer2GXNzsuSVJrCNtsTJxsUeiyKvQFWNvxabQt41wduZ+giD6NshEnRyglGrizTvF5TbQuIZMHvDTcc+bGwrK7SqrEL4KTDdt1mJWzZHR2tkt5SIrsiSvXUHvyETbkrhru4DTtbxSw5YVvu3k5IxFFNmfpYARwXVdv3ODY+Y6TBQiCJkRBCCCGEEOKEJ6V04rin4jFUphGqVYJkDG0qKq1QWGQSnYBCr8I5p4g7GoO8jfIVkXGD1E5wGsCPGOioTeKJfqhWwzbdQogTyoxytIgddobLNIbftzfD8Dhu2sbeNoLtpsmdlsEqBUTyHto28RqimIkIxd4EkbxHbEcWHBe3O4M9Ugg719VEbKxlS9AjY/UOT8FEFqO9DaMpE3a628v04a4L6eqsEAuNrq0UOWHnSa+7BWskT3FNH4YbjgeBsNlKtTXK+CpF969c8ktsqpmw9bbhKbA0y9bsYsuji4iNKj7/xMtRtsZtdbGyFq5noodijJ0OiZ0GfgwaH4yRXe1jZU3aHwtbe1daIZIFw1M0P1um0hqh2hrFKvskhsPtAlauQipXCVfCAXYNQioJW0YgnUJXqzM66qmplezpsWihxCZZMRLHPWVbEItQPmMRpcUpTEfjJiGwobA0oNjn87qTn4Kkh9nkoM1waVmb4TwjuxyAF0AqAVBvzy37i4Q4sVgd7aj2VpRth2VtERu/p4VqZyoseyv7OCvC+ttKxiA67jBwfoz8yeFk+LHTU8TGnDApKpYJ2sOkyM8k8Hta0E3psESvUATbQtlhqZ2aSsCC4ZF6+d70vQnTS+oWwomHEAtR7d9ovcPkskWQiGO4PtgWyU0T2DmH0TNMnLRBoTucTeS0+mRX2GG77QIoT1Fc5YCn2DLUipfxqLRq/NEYJ/UNkmotkV45QXFXGj/p42U8Jle6uCmITGoioyZ2AXLLDJQXvqa2wnbeo2fECSyFVfaJ9ufx4mEaoG0Tpy2BUaxijGRRTRmwbfzVy8N5RY4bXjCaKpvTC6x8bjpJjMTxr7GBIBnFKnl4CYOhcyycdg8vHWBUFH0nD3HbptUoU+NXTMyigTYhmg+IFAPi23Mo38fbsJEgLy1whTjR1DdH23Y4cNF1IZnA6WtmcmmCyFiZ0rImSp0RxlfGyJ2WIbXbw3AD0rs0Dc9PoryAlqcKOA0WTlcDAMZwlkpfpr73CMDvaQmHw7oeulgi2LoDXSrV23LXTkBq+4kW6smHEAuNikSwli9FRaOoVJJKVxhXcqekKS/OUF6cwXB9krug2KXIbHKpZiC1ySR/UkD5JIfsah9jRQEja9F7yhBXr3qUjp4sfpvL6WdsI1eJc1HvZvKbM5x+xjbMosmixaPYozZexqfUpvBjGiejSQ6E+6uj2fDmZMKW34YX3u+2pWh8bpJCT4TANoluGw/3FQF6IoueyGI+vTlstuA49T1GZio1a1xaKLFKEiMhhBBCCCHECW/OE6Obb76ZpUuXEovFWLNmDffdd99+H3v33XejlNrntmHDhrk+THGcMqIxdMye2lcUIb/YoNLpo5IeOuXRfNooHfECphFgDEQ5c8VODFehpqrkUtvDun81lsPMZI7dBxEHJHFEzJXaapGKRCAZx21LQU8HbneGSkuE2JhHqTdJpcUit8TAqmgqGYN8n0WxN0F6W5nC0jRu2qbYG5bj2mMlnBUdVFZ14cUNgkwSP5NA2ybmtsFw0GttZagpg0oksHp79nScc9z9Xn2dPoBWHBqJI2Iu1DpGquZMOLy5WqV6Ugd2zqG4oolI3qfSYpFfYjNybgNuCoq9AeMrp/YUnV/AT/p89EV3YRYMLli0je5ThyhUo/xmfDEXdm7hvBXbaI6WeEPf49y54VSCqOapZxejOio0RcsE8bCjrlWB2Io8dkGRPUnhZMISOqusSe4KW4GnNucJLGNqr1GcxudLGK6P2x0eP7YdltJBONB6mulDXBdqLJrT5gu33norH/nIR7j55pu58MIL+bd/+zcuv/xynn32Wfr6+vb7vOeee46Ghob6921tbXN5mOI4o8xwc6CRTkNvByMvbsF0NaV2hdMAyR0m9ktzTE7GGRlp4GXdm6ED6BjkkcdWkNkVNl2wSgHFnjjprT7K89DlCkFVGi/MNxJHxJFkRCL1jcMqmUC3N6OKFfy2BpTrY5Zcqp0pooMFKisTeHGbSN6vzxEByGwOk5aRMyMEdgzDhVKHRWIoLEMpLm3AcDWJ50bw2xowitWw0UJPuD9J2XZ4wjHVY6GWKFkd7ehi6YBzihZKucrRJnFEHK69mwuYzU0AYRJRKqMzabzGGF6ii9hAgeELmvBiYbLixcI9z0bZIDEYPj+/0uekU/opezbLF20jaVQxlxS5pv1XfNd8EWPVFL9Zv5Tu0/MMlNLs2t3C+NIEhhWw7JR+VmcG+GX/STz7m6VhswYCJs5ySf+qEbdT0/JUWLIH4NuK5g0uhhfgtCWY7LVpfTwPQLkrQSTnYj2zDaY+S40/PhHOdJuKmfoEiD9zumL0z//8z7z73e/mPe95D6tWreKmm25i0aJFfOlLXzrg89rb2+ns7KzfzKkTYSHEiUfiiBDicEkcEUIcjDlLjBzH4dFHH+XSSy+dcf+ll17K/ffff8Dnnn322XR1dfHKV76SX/7ylwd8bLVaJZ/Pz7iJha3WLU6XK2jTxKqEGwlLXRq3p4pzTpGGWIWTu4e49pz7eWvTA5ze0M+6+04mMm5Q6oDm9WGjhvTGPHgBQb4gA13nIYkj4kiql35MlYdo10UNj+O3NRDYBoWlabRtkl8cIXdahkIvOCmF0xDGmcAK2//vvjB8nc4HSzip8Ndow7Yq9qQblsz0WQS2YvcV3bgNEYJkNFwt6h8CoHTOYgBUIiy9q7fBdd16q996Qwj2XSVaqCUsc0XiiDgSZqwWpVL44xPh0NbaIOhiBafRJrAV2dUZABIjmsjkVNODsoGX8cmtdtExn2Rngec3d/HOvge4d+MKlkWGObNrN7/In8bvtfyGgVKaN655jPXjHaxuGuANZ6zjueF2AEaKYXzIb84QH1QE8QDd4mBlLfwYdN0fUOxSuKlw2GtyyCO/xMaLm5Q6IjQ/UwTAyBbDIbObBvasfE0W0JPhqrXZ3IQ/PjGjhG62v4+FZM4So9HRUXzfp6OjY8b9HR0dDA4Ozvqcrq4uvvKVr7B27Vp+8IMfcMopp/DKV76Se++9d7/vc+ONN9LY2Fi/LVq06Ih+DjE/mUsXY3R1UOlNUehVjJ4JQUv4j/Qza77Pnyy9i68u/x7PFTuYDGI8ML6UIB5gOtD2RJhYNT49gZErojbvAJD23POQxBExJ3o6wi5LS7rJv3QZftxCWwaGG7Dtd1PEJgJKrWH3yokzfUbO1QxcGJ5gRLLQ/pjH+CkRhs9NYFU0XlwxujpGsTdGYsglNRCQ2FWk+TkHL25gFKvQP0TxpSfhrOol8dRudDaHzuYgmQhPOCI2/vhEOMeoUMQvFOp7F2BmMrRQT0jmisQRcbiMSKR+wcLq6kSlU5jNTWECkYjjruhCJ2MYrqbSbOLGFdlVAZOLFJOLFIXTHTrXDGBUFcozSLWWWNY8RlPnJAAXn7SJL+1+BSenhnht4zp+kT+NQjXK09ku3rfsPjZPttIeyfOa5c/w2lOe4sy23dz23OkEUc1Lr36MwATDCvDbXFqe9Rk+x6TlGY/YKFRaA7LLLayyJjpaJb2lhDWSp9oaDzvPlRxIxNHJGLpaRaWnLso4bhiTpmLP/rrRLTRzPuBVKTXje631PvfVnHLKKZxyyin17y+44AJ27tzJZz7zGS6++OJZn/OJT3yC66+/vv59Pp+XYLSAKdMM9xZZJk5vhnyfRTUDF7xkPb9ev4Ku7gk+u/XVvPOBB+j67FN86CO/4M9eehWub2JnjXC+kanAVKhCBTwP7Xqyt2iekzgiDsf0pEKlkmjbZPyta2jYVsVwAwq9USoZRaSgiY3B5KLwmqHyIbHdpNIZYBUMKi1geODHLAwPAguKnQq7AJnNLlbZp9QZwXDBa4gSWIrouIPT1UDE9UhuzaOGx8PXzjSGiRF79ioYkUh9jpGsCh15EkfE4fDHJ7CWLw1XVapV6O2k1JfGKvsElkF+aYb8UkVslHClJuljF4xw389TEQYHulBLSvS25BjOpVmRHuFVbevpsHKc07CdtzasZ4sb4e2PXMuZXbv54El380yph/uyJ3Pnytu5+OnXM1FM0N2YI1eJs6xjlO2b+vhA+y/5v+w5OFaU9sXj7Lq0mc77dDjAdcQksznAcH1KHRblrhjp9eN4bQ3YOQfV3oqXiGACamQColGww9RAT9vXWBsfcCKYsxWj1tZWTNPc52rM8PDwPldtDuT8889n48aN+/15NBqloaFhxk2c2BbtHOfav/w1KhvQ+ZCUMhzPJI4IIQ6XxBFxvFr0zDg3fPhO1JU7aZooHuvDOSHM2YpRJBJhzZo13HXXXbzhDW+o33/XXXfxute97qBfZ926dXR1dc3FIYrjjJlKEZTLKNsCz2eyL0puhSZocRgspblw1Sbe1343J/35SP05pfMtljeM8shAH8qH9G7wEoqGreEKkc7mUPEYyIrRvCRxRBwJgeNgplKoZAIyDVRb4sTGw9WdYqeBm4LMpoCRM8M9AKnN4QZ7fWqB0lgcPEWQ8YkOmWgTyh0as6Jo3Kwp9IYrDqUOCydlE8tqJnsVVil8DStXQdsmfltD2KrbddFLujGGs+Gq0fBouOfJcesDXhfy8MRjQeKI+G0ZkQhGZzu6UMSKNocd2xJxlG0R2CZW2afQM1Xu6oVla7U1h+igTeQ1I5wcK7Mp1o72Dba87D/5TiFcIb46NcHDVZfzojYkdrDDC7gtdzafPft7JHUF6ya4+F/3JOIfyN3DZ1e8mt/tfIqfj6ziqa29kAm4+rH3YBcgNmqSHW0jApTaoNAVxY9BeqdJYsijYWsFs+RCbhLL9cL23LnJMBEolQnGxuvd5/Z2IsWfOS2lu/7663n729/OueeeywUXXMBXvvIVduzYwXXXXQeEy879/f184xvfAOCmm25iyZIlnHbaaTiOwze/+U3Wrl3L2rVr5/IwxXFAmSZBuYzZ3ETQ14mfsPFtRSQLTadl+fDi/+PKRIkt383S/Uiu/rwnL1tEwY3Rm8kyOJoh3e9RyZjYW4ehWiUol/f/pmJekDgiDofV20MwPFJPivxMArPsUeqIAxDNavJnukSyEbxOB2UGFM9wiaeq4JlYWZMgHmBlw6RI+eDHNPEhRW65IrAgNgpjZ2mW/qhKdkWMxq0B9qRbT4q8hiiBbRCc1I29bQTVPwK2jU7GANCF8EpwrWTFTKXQjnNCnYzMNYkj4lDUSlkDx8FwPVRTBj00gupoA9tCJ2MU+5IAJIY8xlfaFHs1WJrqigptLZOM5ZI4vsn2sWZW9+1mRXqE20sxXhLbwRYvXE08L2pz/uNv4sGzvs+/j1/AaxvXYY37xN7ncdojA/XjmYxH+belF1P2bH46eDq/2/kUT+/ohoxDcTCF2arxMh7pDTapAc3kIkU0C54Xtuo2vIAgYmCWwFscrpLam8LX17sGUL1d4WclnOl2opTNzWZOE6O3vOUtjI2N8elPf5qBgQFWr17NHXfcweLFYUeegYEBduzYUX+84zjccMMN9Pf3E4/HOe2007j99tu54oor5vIwxUJRClj0/ybq325/WTPVZhtGDvAcMe9JHBFCHC6JI+J4EN/gcPJ7h4nt9Or3Babi2o9fgxcxoXoMD+4EobTW+lgfxJGUz+dpbGzkEl6HpewXfoI4LhjRGEZbCzqTYuiiFgAmVvtgaja99t8wMOBfxjH+aaz+nNtuPoMfnnsOTmDxmx2LiT2YJL0zoPHX2wAIxrPSdGGOedrlbn5MLpc7rurtJY4c/4xIBJVKomw7HOI6MQnJONmzW/FiikKvonJyBe0bRJIO5pMpnFPLBJ6iIVMiNxZ2ZlJmgM5FaNhsYE6Fi2IPxIdAW+HgRsMLh7/GJgJiYw7ZFTFS/S6GpwksVV89Uo4HrkewazdGbbK8baNLJXShWF8h2nuQ5IlO4og42sxUqt4ZUkUiqHSK6qk9eHGTSnNYmuY0mBS6DSbPraALNpFRk1Mu3sKzv1lKeuUEuWyCX77s8/RZab6Q7eNDmR2c8+hbeM2iZ/jb9qcBKOsw04mrKJtuy3LSR0dRpZmn5Tdf8zIW/dU4f7LuzbxiyfPETZcfPnk2d7/iJl71rT/DbXVRnkHnfQaVJkWlNVzFTgwHVJoN2h7JU+xLkl4/HpbMDQ5jtDSHDSQA1d6K3jVQXyVaiPHnUGLInA54FeJwKdMMO9EtXYQuFCkvbiQ56JNbEQaON734EXZ4RRj0UP86Xn+eXmQx+LJGCm6MrlgeY32S1EBAakcRGtP4wyOSFAmxANVaXKtIBGXbkExQ7UxROr2bwinNlFoNJk4JkyJ7e4zo9gjVXJQlr9oG/TGuOetBAFYt3U1be47Y8zESPZN4F+fwYzDxYoe2Fw3iZMLOU6WegHKHZmJ1AIAXN4kUApxGk8BSGJ7GcAOqnVMtcIulelKkiyW8Xf344xMzPsNCOykR4nhQix1GJFLvyGZ0tqPSKYLuVkodEayyT/YkRakjnFXmZAiTotYyp1y8hYlqnKtf/SvesvRRzl26gyE/RllXabMm+U6hibvOvqWeFEGYEMWJwJcnOOm6EVRJM9GSqP9862tbePKDvfzl+tfhVixa7CLnpbZiRj1efs+Hia7MYcR8VMpl9HRFNQNWAZo3VImNuzRscyl3JQgsRZCMojNpjEU9AOHcIsJSutrnB4k/c96uW4jDpSwbCiXcs5ZhVAOGzongN7g0tBW5vvU+Bn0b9f+NzbjKot+ZQZuKJwa62RhrxXQgMehgjhfRg8PH8NMIIeZSrT7eTCUhmcDpayYyVmbg4kbMCuTWTP3Sz0VwWn0S201efeazPDHSTeqUCfoiYyxrGme4lGJ0LM1Zl23i8a29rOwbhNdPkF+/iMJPOglawUuGTRhS2xW50wK8uMHkIhs3BZ0PORhuQKkzQmzzKEYphu4Pu6KpZAJsG5VpxGpvRWdzM5KjhXjFVoj5rtakRTsORmc7hutBIk61pwGnwcJwNYWeCH5MM75qT5v35DYTOn3+ou+nPFXt5ZHJJWHy07wJCFcKr05NsMObpMVIz3xTX6P+egT11XBv9MbL2ul+IgtA/5pGrnjzh/gdaz3vWv4Aw04D9wyv4Hu5swk8g8ZMieyuRrQVkN5gEw2fRjQfMHxWlNSAJr2lhLYNkpsK6OFRVDQazl6K2DBZQDsOaloiKGTFSCwA0U0ufGdPW+4gquD3j59yCyGEEEKcYEoB6j0D9aSoeEOa1ECF5KCDXmLz0y+cgWPL+sXRJomRmPdUPEZlZReTfVHGTovQc8lOViwb5IOn3M195R5O/ZcCKtjz+Oeu7GBbusQdI6ezqHmC/PNNBCYoX4Pno10P7fvH7gMJIY64Wjc3lWnEbG5CtbVQOqWNwDbIn5wmORgwcVqA9hRXnv4kv/fSsGTunX/wM3pjE6xoGmXdubdyfnwrLdEi7178a5Z0j5Ktxjh/xVae3djD+vWL0FZA8+t3UW0JCDqqNJ86CoSDYCEsr2vYpomMlQlsg8Sgg9/WgHI8VKYxvFIL6FKJYHgEb8u2GdPlhRBHV618DsKhpkZLM0FbhuKaPnTEYvisKE46PF3OnqTwUwFel4NeUiK6MsepVz5PpWJT1OFr3NzzEGPBvjOH+qw9q0Xf3tqEenM/6n+L6Kgi+EIHiYd9up7MozMGH/+n13JW9042vuw/+ePWe/j5yCp+tPUMBsYaObNrN8ZglOy2DMTDc5lIAaqZPe+V2eLT9Ngo2jawRwpUe6YuFjemZ3ScCxwHv1AgmOqCKXFIEiMxjxnRGGZ7GyrTSDVjUW1Q+DFojpb5ve5H6bRzvHnTEOqnM9tKnvKHEd678fd58vGlbN7QTeMmRfP6AHvTAMHAEEG1gjLNY/SphBBHWu2XuWpvhWQclWnEbUsR2Ir84giGC5O9BlbBQHkGLZECGwvtXHDm87wr8yRjTorWSHgi889Dr+b6jrt4Z8Mw46UEO4Zb6j9betIA56zcztad7eH7jUcoPNBG9kyXpo0BhqeJjYLhabyGKF7cwH7keYySQ5CMhs+xbbTrhnOLUsn6Z5heOidldELMjekn/mYqhdXViYpEMFqasfp6MVqaYWpGUXa5Rf6URqwKDJ+n6b/UJ5KFk07pJ74xgtqWoFKxaYkWeOnSLVwS01zbMMR3Ck20GMn9H8QWh7f9/jrUYxV0k8Fnv/Aqyj/Loe4p4cYNnr2lnb966cMUdYT397+YP93xen6/6ze875RfEYu59CYmMJcU0TEfJi2aHrdRHiy6fSRsCBNXeHEDXA8rV8FtSxHtz4cNXrZsx0ylwHFnbcktsUcSI3GcUzeOzfi++OIIrI4eo6MRQgghhNiPJyqo1+5CbXfRfRb6tkWcd+c2kj+poG34+b+uonBO7Fgf5QlNihfFvGSmUmBZkExQOLWV/BKDyVNcFi8Z4fSGfjZWOnnvk5tR95ZmPC/+gRbuq8BJDSNsNruxsyaGA8n+MnqygLItlGdKKZ0QC4zRlEFnc7hnLCW7IkZsIqDQZZA7JSA6ZqBPLaA9k7MX9bMqtpuE4VAKInwtewaf636Yt227hLGgyKszz7DNa+Lr46t4Y98TdPxXjr7Pj6OvDXioupR/WrGWN214P0ajQ5CL4EdhyQ+g0GPgpsKBsQ3PT2L0j5C/fDmRc0/GHithTA11nU4XitJoQYijqFYuVishq9WO6GoVZVu4K7rwEhbR0XI4vHncpdQeBUtjFk38GOQqcXpfuYMXNW9naWyEaxuGeLjqUtYBcRXl6tQEZV0lrva6SPvrEuqdA6hCgD49iv5WN+prOV62dhytQP9rJ/0vbSKqXeJKc0lMs6zj5/y8tIJSEKEURPiDk37Dv933Coyqwi4bWBUodUL7Yz5BMkrDNpfAViQ3TVBd0kxk3RasXTC9AbiWsQAHJImRmJe062H0duG2pdCmQr00SwNw00m38rXRi/hc129Q7xqd+ZyTIjx+kUk2SDDpxUhvMkkMaxJDLk5zlJjroT1XkiIhFoBa9ygIO9FVzugjtiNLfkkUq6IZuAjsLCxdtZsdwy38w1m38fXdL+GVLet5RWI3LakcjzoOa6ZKa7615G42uPDmVLgR+necx5h8724a7wvb+ju2yUMfX8pHnnsLVtIjGnPwt8RwllXIDsUwPGh7vILTYJE9tQHj5DTNT4ZNYdTEJEFPG+r57VMd88Jjl5p+IY4dq6sTb3EH1kgeXJfJNT2knxxm4pIuAltRWhQwZEWpnFWCqkXgWaQvHOENfY/zWHYxH2l9iBYjyQ5vkg4T4mrPHqJ9kqLbC6j3D6Icjb4wjv5aF3wnj/qXcMyIvrGN21/VxrWJIW4vxYAw7vx3/my+su4iLj5pE7+67zTSKyewsiapXeGeosTgnr1F1dY4VmlqMKzrEd02jnZciNhhN7rCnn1PMjNt/6SUTsxLRnMGpzNNpTVC/8sVnm/wF6fewVdGXsbnuh+G/ymi1lXREYWOhG0zd7w3ScwM+MgDb+HhXX3EJjSGr7GKLonnRgmqFUmKhFgAjKmW3GpqiGtw2jK8uMH4eW1UM4pyqyK9ySB2zjiOb3HVqnU8WlzCitQo78/sqtf/r9krKVlpJ/l6vp3KziLqtbvqSRGAOh8+s+r7REyPFy3Zxiv7NgKgizZWBfwYZFfECGyD1K4qyV0VlOtjDGchGcfIFtGOg9XRXt/sXJu3JIQ4emptubEtrN1juN0ZgrYMAAO/00WlFYbXWFg9JaoZaGkskmws0758jI+s+AXvyTzBXy36CU854WyyPitN0ghPp3d4k/u+4TdzqPcNhEnRFUn0N7vhf4sYfxVe3A0+1sIzb43wmkQYb16TqHB3RfGMW6LgxUikqty7cQWxFXmqDzajLY2bgvjUteHeu8JW/4YX4CUs7N3Z8AelMkRsdKEYtuie+uyyn/HAJDESx59Ao/6/qb1F7WYYbNpNxl9/gM2OQghxENI7ysTeMIR6fs8JQ64pxiOvXXLsDkoIcfzRGj4/jvGnw6gA9Nsa0F/pgp8XUR8dCh/y3gz8cdOxPU4xg5TSiXmpfMYi/Kii/+WKc8/ZRMqu8OZUju3OKPy0gNrgoBuMeuGsfneGM9Nx/muyFWMgimdG8SOKaC7AGsji79x1bD+QEOKw1co+gqmVl2Aii5FMENgGToOJF1OkLx9kcKyRwFOc3zrE2zvu57+GXsKFmU0si77AcOctDm96x5OoAR8dU6hKGGC2/XkL3975Ijpa8vzp0ju54d/fTbVF43f44IUr1pUWsAtglXwC28D0AoJEBNOJQzaPdl0Cx0EVSzM+C3LFVog5VVuZ9QuFPR0smzO4i9vCP7sBk8vC1Z9qBrQFsVGYyEYx4wFv6Huc7eUWLm58ntOj/TzlpLgkpsHes3Ontgpdb8kdaNSnRlFfyQKgP9yE/ngL3FVE/dEgygd9dQP6b1pBKU6zEwDcku/g2oYhLolp/mTwpTyd7QKgrWWS8SfaSBTAyUDjloDAVjQ9Fi4bRfJhCV180yi47ozPX/vs4uBIYiTmDWWGTRGs3h5cIN9nYXcVODk1xPOFDgBuaNyE+kxYk8vKCOo3FXRC8b9v7uR7O89j3XAvhqswStD0fAWj6oPnoSxbyuiEOM7VSmBUMgG2jTplGaXeNIGtmDhF4bT6NFYj+FWTxpYCr25+lqRy+I/Fd9Zr/u+rwEWzNX3a5KDetAs15DO8JE2bWYHNLmMvTnDn76zmz+07+McnL6Oai/L96z7HX217Heu3dhPZFWFyMfTc61DoCZsrRAfDkxA1PB625u7pwH9qQ70EcPr+KCHE3NPT9vMZLc1AmBABTC5LYLia8VMNzAqcevnzPPrICpRn8MeX/g/DTgM39zzEnwyew9WpiRkJ0axcjbp+CPX9sKwu+FQrvK8JfllEvXcQ5YF+Qxr9mXYwVP1pY0GRZZFhvpDt47H8Yn61dRmBZxBUTNyMidflYG2LEB9UWGWf+JYSE+e0YpUD4gMVrN1jkIijJ7Kopgx6PCtx5rcgpXTi+PLjSdRGB50xwJ0KTm9rxG2UHF8I8Vva6aLe0o8a8tGrImx4aSdqs4uTMHnqH3tAqRd+DSGEqASo9w6gvj+JNiH4fEeYFN1fQl07tc/oNSn05zvAlLgyH8nZpJgX6qtFba2QSpBfbFN+WYHzencQNTxuXfYL8DTqn6dWi16aQP20gDbDGt2Ycrgk8xz33nM6pg9tT/iYJRfj+Z142ewx/WxCiCPDTIXlLrpYQp+8GG2bBLai0G0RH4LTLtkKwCtX/JrHC328s6FWOrenQ9Q+q0VDHur3+lG7PfRJEfRftHLRNWFjhV2fzvCp4Erebj3Elamt/FdzFprhr7a9jucfXkzjdkWxB5qe0xhugDHVEKrcmyaxZQJdLIWrWxOTWB3teEPh8UhZixBza3q3tdogZdWUCYe3JqMU+5IUuk1KnWEJbKUVus4cYNfmdrJOjEsvfByAtzas565SL2Vd5bOdjx34TUsB6l27UfeW0TGF/vcueFUSflNGvX03qqLRr06ib+4Ea2ZSdNmG13Dnytv50u5XcHJqiF9tXUZLY5H8Q224K0vYj6RIZWHsXJeen5l4cYNyV4LG5yZRrg+7BiEaJdiyHaOlGW/z1hl/B9J97uBJYiTmDWWakEziNSUYP9OnL5PnPxf/EqO2sPmDSdRmF900bbXotSkeboebtr+a53d34DV5tNxnkX5qBCpVsOX/4kIc72q/1LXj4L/oVKxcBa8hSnZFDKuimTjTRyVdrmx7glckNod1/pmD2Fc44aOu7kdtmxq2+LUu/HfswvZA/26KJW9t4m+qP5lKppJ87eRv80dbfo/nHu8jtjxPNpMg1m9jVTSBbRDJ+xieDkvpimVUphFdKuEPvcDeJiHEEVOLF2YqhWrOEAwOo1Yup9qWINqfp9oap9RuYnhgeGC/dJzy5gy7nuvgpNN28a7e+zk92j+17ycZls/xAoPj8z7qD3ajHg7L+/U3uuHCBDxeCe8vafTFCfRXOiGieLjqcl7U5vZSjHZzkn9e/j3+cvhF/NWin/BHz72Vq1c9yl27VwLQeHeCwIJyK3T90sIqh9sC4gMllOujihVIJdGFYtilc2x8nzEAkhQdPDlrFPOC2dUJ1SpBY5JKW5S2JeO8u+/XDPslOs1UuFo01e+fK9PwrXDWiL6uiTVRk5TlYK+P0zgEiSEXPB+qVbyR0QO8qxBivqv9greWLQHHxbMMcqdlCCxFbjkEcY22ApZ2j7KusJh3NgwzFhTrm6H3qxCg3tYfNnLpMNHf7UX9yxj2Fh/dZaH/qZ0NXomHSmfwUAm+teVc8tkES7pHsbpLlAtREtttlAeGC2bZIzpYCU9SbAu/pwVz2yD++MTc/yUJIWYwIhGI2ASDwxjLFsPIBEZjjGpPA4YXEJnUTC5SVJY6BJUIrSeP8eruDXyk9SGeclJ8Z+JFfLLt0X3nEc1mzEf9fj/qqSq60UB/qxvWxOHpanj/ZIC+YGp2USy80HteNNyPGLbotrkl38vtO0/j+UIHE8UEt/7PRURX5kgMhglRuTOg/WFFbMwjOlrGT9gYu0frF3/1eDb8ulc7bnHoJDESx4fv58Orui1muFztg74kAWfEgOBYH50Q4njiaNS1u8NZaE0G+tYe+FUJdesk2gD9hQ5oMsF94ZcSQpzABr1wf+LzDrrFDGPJaVF4rhrenw3Q58bQ/9UNCdnWfzyQ/0pifqhWCfo6qfSmGHyxxf+e+Q2G3EYaDTvs8FLbW/TmNNwW1ufrDzdT1lX+YfRUHtnaR2Wpg5uEWH8enc0R5KWOX4jjWW1PkYpE8NsaGH1VH/klUbxYOMTV8KDlpDES221+cepP+Fz3wzzqOAdeLQo06qNDqPvK6KRCf7sHqhr15yMA6I+1wIUJPjO+nDYTftx/Bjc0b6a7IU9DpsR5LTvwtydJPhnDTUJ6V7i/yMpNDYMtliCbx9i4Ez3VmlsIMbfqK8tdnahIBKOzPbx/UQ/VngbcFWHb64HzoxR6IuSWKtxzC1A2ObNrN4sbwpXdLW6ES2Kav21/mqedFzhF3umiXr8rTIq6LPQPe8OkaLMT7lsc99FnRsMVpOS+rzUWFPlOoYm7K4rTo7t4y9JHeWKgm6ZkCS/j4z7dSGRSk96pWfJTn9i4j1XyKHclMEsuuloFwtUiv1CAiC0Do48ASYzEMaNMEwAzk4HGBqqtcUZXWzjtLkO+5gNNz4bL2LfmUTs9dJsJFR12dTkvBufHeKQaZcRJo8YiND0cofPBImzrR5craE8u9wpxvDJTqfov+uC0ZSjXp3FTmXKrIr9EEX31CE6vQ8TyUefk6s9b8wInBuofxlA/mERboP+jC5bYYRepargxmg+GwxZvaN5Mi5FkVdMQnxlfzoYdnRQKcdb+/ALMiiKwIIgHFDsVya15vMYYamISMg1hc4hCsf6ee9f7CyGODCMSqe8pMiIRgrFxVG8XJOKoaBSdjFFpthk/Nc6OS+OYFcgvVTirS3zgtHtoXzzOrct+wTmZ7fxt+9P1Ejdgxp/3sckJk6LtLnqxjf5RL5wUCZOiq3ahhn30qRH0f/dAg7nP059xS9xV6uXO8dUss/I8Ve3la+svoJqNsvvZDqysGc5FKwc0PTNJqcMiuSlM3pJP7g7L6Ho7w31F6fACkj8+IY1djgBJjMT85mjUTVOrRW9vhO/mAdB/3CwtdIUQh+Y/sqgvhicX+rMdcHEC9ZEh1A4PvcgKW+gaEleEEAfwTBX1hl17Oln+sBf67D1J0ZCPXhkJy+qa9k2KxPwmiZE4ZrTvY0Rj0NvB+Is7GDvVprDC5bVnP8FKOxmuFn03j+r30B1mmCSVNHp1FF4RTom+KAY/vf8cOh6E5vUVrE39YFloz5WBrkIch6avrijbhqW9FHsTDL+oETdtM3mKiz61wGsWPcPZK3bQnijw9PnffuEX/ukk6q/Ccrng4y3wew1w8wTqziI6MtVaNxOexHyv0Fh/2lmpHXxv+9ks6R7Fz0VoPnWUjoc9mjYGND1t0PFIhSARwSy5ELHR/YPhpu+pLnogHaGEmAt7t6BWqSRGZzs6YuG2pZh4+VIqXSnyfQax8QCn1Udb0HrhAO85/dd8/omXc2HnFgA+1rzp4N70sUqY/Iz66NVR9A96oMvaNyn6Xg+07ruN/wvZPgD+r7iSUhDhkYFFvPyeD3Pr7nO5YNE2lK2JTBi0PqWxC1BuNglsk5bfjFLtacBatxGdSYdldLvC5i7B2Pjh/2WKOmm+II4ZM5VC9XbhtCYp9CpKPQErlg3yj12/AqLh3qIvhP/g9TUZ1FemrvR+uAmU4nuFRr4/fC7xQQMIiGwaQpcrspQsxHFo75kbLO2FYgVtm5TaDAwPhtfYRBsLvOfU+ykFET7ScxenRopscGGlfYB9RQ+WUR8cQmnQ1zTCh6em0N84BoD+uzY4c8+AoxfHdgFpbs72ApArxhnZ0Ux0yCQ/1Eb5ZEjvCmi/b5ggGUVt201w0qJ6hyh/fGJmeY8kRkLMCbO5CRwXc+Vy1Eh4jlBY3oBVCjBczchZNrFRmDjZwMyUKK02sKtRbt26hmUdo/xdxwNAlLKuvnAHut+UUW/bjSpMNVT4Zjc0mmFZ3ZteOCkC+FBmB6/beBkV32J5epSnXvxtTrrnGkbW9rErA0kP0js1lSZFbEKTGJqKHa5H9Nl+dMTGf3K9xJc5JImROCaMaCysi604GFWfYp/PeWdu5oae/90TnH44GZa4tJqgddjdZbkNV4T1tA8Xl/HS5o0MPr2M+GAZAO16x+ojCSF+C2YqVV9ZATCaMuEeHdvE7Wum1BnBTYEfg8rJFYJclHX5ReyYbOKvTl8PJGk5UO3DZicculjV6MuS6L9vg60u6o8GUQHoqxvgDxrqD7+vAhfF0vxvOcL7M7tY9uP3ceV56/jZs+diF6Bxa4AXV1QyBqVlTcQf2oRqa0Gt24A3daIy/TPJSYsQR870hACmhre6HmQncVd04SUsYqMO+aUxDA8CC7IrNS2njfKGvscBuHXrGv521Y95RTxHXEXZ4U2Gs88O5P5SOKS1pNEXxtH/OdVQYXpStCqC/u7+k6LvFJooBRHe13MPH37g93nR6dt5y5ZXwq44lVZwUxo/pomNGmQ2udg5B2skX7/gEoyNY7Q0z1hVl/hy5EkpnZiffI363NRq0bsaUf85Nbfog01gyh4AIcRBGPfDk5lsgD4nFk6cLwWodw6gcgF6TQz9j22yX1EIsX/3lcKVotqQ1m8celIkjh9znhjdfPPNLF26lFgsxpo1a7jvvvsO+Ph77rmHNWvWEIvFWLZsGV/+8pfn+hDFMaDiMbwlHUye3cng+UnMJofzMtv2dIH58SRqi4tuMiBmhB1eui14YwNlXWUiKPFMrpN/ufcy4oNlzPEiulAkqFaO7QcTc0LiyMJVG0gYOA5WRztkGlDtrTgtcQq9UcZXGhSWh/sFV/YN8j+Xfo6Kb/P7ix4+8As7GvWeAdRWF91rob/eBTGF+sAQauNUe92vdkF0z6/BsaDIRbHw66n2GJ8eXYW2An7+o3MxK2B44MUViSGXzp/tDifQOy7ec+H+hNrVbL9QkCu585DEkeNXbZUkcJx6G3+jsx0ScYLuVoK2DKXOsNrEaQzPI0ZPD1v6a1vzvmX3cf/Ycv7tvldwfuc2XpOoEFdRbsl3HHi16JdF1Dt2oyoa/YoE+j+7wnlEB5kUjQV7ulOeHu3n6zsuYDKI8+fn3cG3nzqPhzctQduaxCDEBxUtjxuYrsYqefhJi/KKViiV0UMjqFSyvp9I4svcmdPE6NZbb+UjH/kIf/7nf866deu46KKLuPzyy9mxY8esj9+6dStXXHEFF110EevWreOTn/wkH/7wh1m7du1cHqY4yoxoDNXajNsQYbLHJIhAJOrypobHwwcEGvW5qWnx12ZQX88CoN/fxMPaI66iPO0kyFbixPotzOE85PIEk5PH5POIuSVxZOEzUynM5ibck7rB9cif3QlAJO9T6XExqorUBSPkqzESKmDt8rt4f2bX/l9Qa9THhlEPlNEpIxyu2Gah/mkMdVcRHVXoW7qgY+aJTIuR5L5K+PWhSi8/3HYG7d1Zyj1hYhYf1ZRbFXbeAdvCyldRmcYZJ20g7bnnI4kjx7favy0zldpz4cEOEyDl+riZKIGtcBpMBq+pMHyeJogH2C8d572v+gUAr2pbz0df9r98vOPn9de9tmFo/296VyFcXa5o9KXJMGbEppKiqw5upajFSPKMW+IL2T7+r7gSx7N4SWwH//C/ryf5eIzu2y1SWw1S/R4NOwKi+bA9N4CdrWLf+TDB4DB+oRA2Wpi6iCTmzpwmRv/8z//Mu9/9bt7znvewatUqbrrpJhYtWsSXvvSlWR//5S9/mb6+Pm666SZWrVrFe97zHq699lo+85nPzOVhivnmjkI4MK3BQLeY4QyjVhPe2vDCzxULjsQRcci+OIH6Th5tgP63TlgZhdsm6xdc9P/XDmfFXuBFxEIicUQckv8poN49EM5NvCIZdq2MTkuKhqV8bqGas8TIcRweffRRLr300hn3X3rppdx///2zPueBBx7Y5/GXXXYZjzzyCK47+7DOarVKPp+fcRPzl5lKYTSkmDy9jWKXxeRSjXFBlpf1bWKJlQ6v9NbmFr2zEeOTU9Po35eBuMF5UZsNbpEb1r+J0k876HrAwd+5C398QtpzL0ASRxY2s7kJoymDSiZQmUbMkkuQSeLFFYMvjrDzDQFG1OcVL3mKP1p+Lxe2byFpGNxXod4xbh+3FzD+fqrb3N+2wSuS8N08xh8Ohvddl4E37/8iy0UxePG6N/HxB99IoRAnV4xDzKdpY0B+iaLzgQJ+3EKPjKG27QbX3ecqrlzRnV8kjiwMtaHPVlcnVlcnXlsDQTJKYXkDgWWQW6rILTNwKxakw0ZM53du4/6x5VzbMMSHMjv4UGbHPqVz08vdgLC1//sGUC7o16bQX+6CiII7CxgXbd+TFH2vd79J0f8bXwHAOY++hdPscLzI6bGdDPVn+OvdV6A6KlhTlf+1r4anaXxqDGMki71pAPXctnrZoDh65iwxGh0dxfd9Ojo6Ztzf0dHB4ODgrM8ZHByc9fGe5zE6Ojrrc2688UYaGxvrt0WLFh2ZDyCOOGWa4YyhjhZKbSaBqWg4eYInXvTf3NzzUPignxVRzzjopIKd0375vKOR/5ps5b8mW/nQprdQurcN04Ho4CTKsiUpWqAkjiw8tUn1tV/4wUQW7broZAyvIYrTEie1q0okC9pTGENRxqpJ7s+v4DWNT9BiJLkoxuyldI9XUB+cSoCubYRrMzDkYfzxnnIZ/Retsx5XWVcp6yo3Z3sZ2dLCyr5B/KpJ5DcpTv6yQ6XJYNFdBcyRPJEd4+GMJcfFGxo+0n9F4giTOHL8s7o6IWKjmjJgW7grujBLDpPLUjhpg6FzbfxY2IUuqJhEkg4Xnf8sn+2+l6FimrsrirKuzvraLca0Vv8/mkRdN4jyQL8xjf5iJ9gKNlQx3jkAgI6pMClqmX14a1lX+VjzJi5++vU8tuZW/mTwHNYXu/hJ9mwWLR7lkYFFxB5P0PFgnsBWJIZ94gMlUpvDRLp6Uke9E52W0rmjbs6bL6i9uv1orfe574UeP9v9NZ/4xCfI5XL1286dOw/ziMVc0b6PXt6L15TAj8D4JRXeuPgJ7qv1S9Aa9S+11aIMPB8GA73IgkaTSmBzd/YUAAwHWp4qoiouypZl7IVO4sjCETgOqtZqN9NY/+q2JAhsA7PsUWmJUOwBVTGJLs/z930/4qzUDi46UPXbsBe25a5o9MsT6E+1hR3ortm9570fWrLfrpaXPn01AGt3n03j4iwbH1jCoh+GvyInlyZoeSpcKcJxwXHRrotfKMh+ouOIxJHjT33FxLZQ7eFFjepJHVRaI/iJ8N9epUlRWVnByQSUOwOslEsmWeaGrjt5qBrjwbO+z4ujlReeU/S9POoDgygf9FvS6M93gKXgmSrqqv76w/TP+vabFAH1pg7v7HuAL2T7KPvhXqgf/vo8snd2UczFSe/UbH19A43PTZLanKfYl0Q5HpTKRNZtQY9nUc0ZSYqOgTk7o2xtbcU0zX2uxgwPD+9zFaams7Nz1sdblkVLS8usz4lGo0SjL/B/dnF8+GUJ9UQVHVfoJTbGM064cfp/+471kYljROKIOCi1DnSDPvqkCPrLnWCA+tBgGFOaDPQdi6DPPtZHKo4BiSPiBX0nh7p+OBwC/daGcB+ioeCJCurq/rDl/5lR9H/3QNP+kyJx/JuzFaNIJMKaNWu46667Ztx/11138ZKXvGTW51xwwQX7PP5nP/sZ5557LrYtv9COZ8o0MaIxKp0JJvtiBDYs6hznzMTUVeDpe4vevmduEdc2QrPJZ8aXc9Ozr+DezScx9D+LaF9XwSi56NFxGeq6gEkcWaAi4X+HIJOE1SdROqUN5QV4cYPcijhD5xpoS9Nz8jDvX3kvv//EtQfsQqf+Yhj1cCVs2PK1LmgwUTeOoe4ooiMKfUs3LNn/ys7X8+3cd/oP2e55DOXT5LMJEkNQaTaJZiGS8yl3xIgM5MF10dkc/viETJ0/TkgcOT5MX32tD3BtzmCmUpRXdaEjFrguXtwk32eSOznB8DkGpU4wd8XA0rQvH+PU7kHe0Pc4P508g2VWWJ52wNWi/56WFL2zcU9S9GgZ9XtTSdGaWNho4QWSorGgyA5vklt3n8vXd1zATwdP5+mJLn7+83Mw/HBQdfMDEQxX0/5YuAVAOR7pB7ejdw2EHejGJ8LOe4PDsiJ9DMxpKd3111/Pf/zHf3DLLbewfv16PvrRj7Jjxw6uu+46IFx2fsc73lF//HXXXcf27du5/vrrWb9+Pbfccgtf/epXueGGG+byMMUcUqYZ7i0CjOYMbtxg6JUu1ZcU+JOld3FlohQ+8Nfl8MQmqtDLI6inq+ikQv9hEw9XXYbdBkrjcazn46R3BdijRYxihWByUmYXLXASRxYWM5UCx0X1dOInbJTrk11uk1sRJ7fMotipsItAT/jv+l2Nm3nbskf2/4LfyKH+K49WhANcl0fC+/51qgPdZ9vh/Pg+T6vtNyjrKp12lrMfeQtXfvdPMO5vROciFHs0kUlN62M54g9tIvmrjVAsh3uippIhSYqOHxJH5r/Acep7EGFactTbRfzJnWjbpHhGN06DiV0IZ4qldoHfW8HrcjALBosbJmiOlvhY8yYShkOfld63ucJ0382j/mQqKXp3I/of2sKk6KEy6urdqHyAflEM/Z0eaDhwUvT+/hfTYiT5x6FXAeB4FtvHmsnf3oVdAOUqEoOQ6vdIbymQ2pxHuT64Hrpa3Wf+mbTmPjbmdHPGW97yFsbGxvj0pz/NwMAAq1ev5o477mDx4sUADAwMzJghsHTpUu644w4++tGP8sUvfpHu7m4+//nPc9VVV83lYYp5QH1+arXorQ2o/5paLXpXBppNqAbH7LjEsSdxROzXb8qovwibH+iPt8Ark+HskU+E9wU3NMObpM2/kDgiZvG9POojQ2FS9K7GsIulUvCrEuqa3aiSRl8YR3+jOxzqKk4IStd2Ey4Q+XyexsZGLuF1WEqWu+cLM5WCJT3sfE0LpdUVzl26g1uXhUPXeLyCcflOtAX6020YnxxBJxT6N0uhxeQtW17JUDnFwG+6aVsX0LBhApUt4A8MSje6ec7TLnfzY3K5HA0Nx88JqsSRwzdbmVmt3W6t6UJleStm2SO3Ik5s3Gf0DIvAAj8Kb/yd+9lYaGft8rCc6VHHYc30spIBD3XZDtSIj/7dFPornfBEFfXGXaiyRv9+Q7hatJ+N8mVd5dbJRbwisZnPDr+C29adSaw//G/tR6HrAQ/D1cQf2hR2oAN0sSSrRceAxJGFbXq5mIpEwhgRjeKu6MLenQXA7c7gJSwqLRZWOWDsVJNqW4BucdAFm5edvZ4Hdi7hs2d/j8kgztWpiQO/6do86kNTSdE1jegbp5Kiuwqo9w6iqhr9skQ41PUASdEzbonT7AS35Dv48dBZVHyL1ZkBfj24jKH+DOkNNuVOTWxUYVYgs9mj2GHR/usRcL2w3f/g1IUciSlz5lBiiKTAYs7USujMVArV20XhpAyVM8vcfvG/0hIt7HncF6ZWi16fRn1nau7DtZl615dtuSZ2P9JNejsk+8uooTF0oYgR37c8RggxP9TKYmBPi24iNsq2cbsz5M/upNJiMbEyQW65otBtUW0NqLYExMbg4bE+TkoN8/GhMwFmJkXVAPXu3WFStCqCvqkDdniot+8Ok6JLEuj/t/+kCMI9BxvKXbzr+bfWk6LYKMRGoeWZ8HphbKiESiTwhobxhobrpS5yAiPEkVG7gFLvVJlOoZoy6MkC1rqN6GSMIJNk2xVx8ktsJhcp+t/osuLSLUDYmrt98Tjj1QR/dvrPeEU8x3I7TDQers4+b4ofTqI+PJUUvb0hLJ9TCn4yibp2IEyKLkui/3P2pGh6aV5a+dyS7+Bf1r+Sf1jyQ3KVOD988mwc38QetYlmoeUpMCuQ2h2Q2DFJ+13hyqQeGkEXDlDmJ44J6XMs5oz2fYxoDBWP4XSmmewxaW/Oc19pBZ/tvheIwkYH/icMDHplBOP7k2FXuj/MEBCQCyq0Jovkq22Yjg4bLpQraNeTvUVCzHO1BEKlkuhCEZVpxG9rwMpVCHpjGC4khj0mVhvkVkIQ1URaygQ9Pue17GBlfIC7xk/d53XV34yi1k11m/taN1Q16m39qFEfvToaTqm3ZyZFY0GRFiPJ/5YjbKm2c3psF3fuXEkq6mAWTSo9Lm7GpOf/AlJPT5XnZXMgG+2FmDOB49RbcqtIBF2togj3FbltqXDos21ieJBbofHbXDKZEs/+ZilBm0tTS4ELO7cw7iTZWmnjocgwl8TCCxvnRWf5t/vjSdQHB1HBVPe5f5xqtHBrHnX9UHj/G9Loz3XsE0NqEmrPqfN/58/msexiLl28gT967q0Mb2/GypqUdjaTGIXkkIfTYNLz3S1UT+1BZSfR41kYD/cqBtLyf96RFSNxTKkvTYRXbS5Lon4ytYr0rsx+p0kLIU5wP5pEfT3ch6j/tRPaTdQ7d6M2u+geC/3NbkjJrzYhxF5+MhnOKQoIS21r3ee+lsX4yNCeZOkL+0+KxMInZ59izijTDDvRregivyRslXl597O8t3EAiMJuF74/VTp3ahR1ZzFcLfqjDI87Fc6KxDj3lx9AuwaNo9D0bAGj6hLIapEQxw0zlQpXi1JJgkwS5foUlzZglQIqzSbVjIU1SThU8dQCbsXi4y+6kytTW2kxkpwe28UOr0qflYZNDuqGIQD0HzfBRQnUuwfCjpaNBvpb3dAx+6+12mrRedEJksrhhvVvIp9NUN7eDOmA3v81cdKK+FAlHOIKYZnLVBmglM8JceQYkQgqEsEvFOr79lQqiX9yH9buMao9DRhOQLU1jtNgEslCYYnGHLFxG01OfdFWbln+A+4q9bLdaeHvOh7g8xOn1VeLyro6s0X3TydRfzRteOtnppKiL45j/N0YAPo9GfSnWw9YgjsWFHnKSfGL/Glc3fQbvrLuIgwr4BGvj+TjMZJWWI6rLbDKGi9ukBhyIBEnum2cYHC4/rlrfw8SW+YXSYzEEaVMs94QwWxvg2iUapONF1fkVvn8ReuGPY/9Shblgj4/DndP1dle0witFjduuYwNo+2o4SgK6P7RdnQ2hzcVTKa/jxBifqn9sjdTKfxCAWvZEvTwKMr1CRLhDI/8YptKOMgeNfVPuac5i+NblIII79j0Jm4/+X9YE4mwwXUpF8sk3jeMKmr0S+LoP2kJO0rdVUTHFPrr3XDKvrNKaiV0AINuhp+4GXY4LYxsacHwIb0dUv0+lZbw12FgG5gRGz08Gp6wyEmLEEecikRQ6RQm4b4iXa2imjKYJYfJNT1YpYDxlVGqGUjv1FRaQcd8aHVpSpZojpZ46/O/x7t67+djzZuA6NTX0Iyk6I7CnqTozWn0ZztAgfqnMdS/hHuc9Uea0X/WfMCk6PZSjC1OH6fHdvKt+y7k/Ms3saInLLsdKaYwszG0BU3Pl5k4OU5iyMMqeVi5CnoiW//ctaQIpOHCfCT1BuLYGPeh1pZ7dTTcLxBT6Pc3HdvjEkLMS5G/nECtd9BtJvrmTtTfjKB+MBl2s/z3rllnFQkhTnB3FlB/OIDyQF+VRv9LBxhT+xSnkqLgky3oj7UcMCkSJw5ZMRJHlPb9sIQuHodkAr85SanNwouBWTQICDAw4OvZcEbA6ig8Wg6ffE0jtFk87lSImB7uoxkiQMdjHvg+2vVmvI8QYv4xm5vQhWJ9Q7XV2wO2BUt7ASh3xCh0W1gVTbVVo5sdgqpJsqWE41u0Jwr8YmwVMdPjlc9eyVXd63j/L57F+O8iWsFzn2vhlG/kULfkwqGun+uAVyVf8LgedRw2lLv46dbTOKVthOiYgR+FciskhhXpbWXsbSNh+9yJLCr1wq8phDh408vGtOPgDwxi9fWC66Gi4QqP05YAwEsYBBa4KRh+hYuRDU9XT+0e5KmtvXQlJrlz5e3s8Ca5Jb+ChOGQNsq8JjGtzP7uIup9g2FSVGuoAKg/HUZ9KyzjD/6+LeyCexC+0v8y3tdzDzduuwId8/nIw2+BXXGSuxS51S5dZY1VDnAabVofz+NmopglF71hMyqVREWjaGc/nfLEvCGJkTiiaiVuKtNIkIwxuSxJEAHzFeMYpSiPVn3O80H9RzZ8wsmR8KrvtNWitdlzefiuU4lPQGarR2LzBMF4VvYVCXGcUJEIKpmAZCLcr1MsQyQNQHyowsAFKZL9ivSyCVzPpKmjzEQxjuOZZKsxfnHqT/j06Cr+qnU97HJRnxgBQP9JM+3PlVH/PBl+//dt8Mb9z6TY4BZJqIBb870kDIcfbTwDZyjBlv9rpH2HR6XZpGl9ETNbCmeKAMFENjx5G5cSFyEOx/REaHrr/sBxUCuXY41MzRpqTFNcEf7+L/RYVDPh3cXeALOisAYidK4ZYDiXpuJbvOGMdSyJjXJ7KcYr4lWubRji7oqq7y8C4MEy6l0DKEeHc84+3wE+qI8Mon5YQBuEc86ubtzv8ddeszarqDla4k/WvZlEzMGI+ZhWgA84GWh82iY25hLfnsVtCy8KRR56DtWcIQD88QnZT3SckFI6cUQZ8ThGNBau8ERNRs40yK3QvGbRM/zd2T8O22d+O4+aCNB9FjxbDZ/4ngy0h3n60/luAhusMkTGq+hdA5IUCTHPGZFIuErkuGjHQbsuengUIja6KY3XGKPamcJtiGAXwfDAv7eZ4liCiWKcUi7Ozad9m6u61/Ga5y/nNQ1P8AdbXhbuI5oM0GtikDZo/lSYFAV/1hJ2sJymrKv1rzu8Sb40cgltZoR/33Qhd42fino2RaLfIFLQRPJemBRtG0T3D4Z7ioZH6p9FWugKcXimJwHGoh4gbLBgNjehHA8ScXIvDleSA1thlcNKkMYtAQCRrIGfCnBbXYZzaS5YtI07V95OeyTPY/nFvCZRqe8lmpEUrauEM80qGv3KBPqLneDosHvlDwth+e3NnbMmRV/I9tX/POhl2OFNMuInWf6Ld3Hfg6eSSZYpPd5MbEMM4+kU8UFF+6Meqd0Bds7ByySwd2cxdo8CoMez9b8HSYqOD5IYiaPL0agvTV0lWmyjNjjolIH+I9lbJISY6Xe++zTq12V0XMHZMYy/njrZ+GATfERihhBiL89WUW/tRxUC9IXxcP9hMUC9pR/1y1JYnfKf3fC69LE+UjFPSWIkjijtehhdHQTdrfS/PI02Naes2c4ZiZ28OZULZ5Ds9tAtJmybqrX9www0mwC8ev3vkrKrtD0R0LDdwdo5SlAuo0zz2H0oIcQLUpFI2HY3Yof19LYdrhwlY+ROy2DlKth5h+zyCKldmonTAiotkGwp8cq+jWhP8f5n3kqbNUnFsxjamOYPvvwgAPneaL38Vn+wCf3JFsrse/W1dvW49nVToZU/7n853Q15NnxjFYlBiGYhsBRWvorZPwa2jUom8AsFAseZcRNCHB4zlQpXX0tlVCQSltb2dkJuElyX2LjLtqvaKHSbeHGTlieKeHFFNRO2vY4Nmihb89mzv8cNXXfycNWlzZrkmvZfscObnPlmG50wAcoG6HNjYQKUC1Bv3IV6pILOGOjv9cAr9r9/8EOZHdyS7+AZt8Tp0X76rDQf33AV9rYYgQljuSReOsBNgVkJ23IndkzS8FwOK1vC2j4EpTJ6MmxD7ssA1+OO7DESR4QyTYx0GtXaTGVJM0HUIDYKToNi80grbz45x3/lW3jbv20Ls/FmE7XRQTcZfP3qlbydIS5Y93uMDDWydaKXpYNVIs/tJhjPoiwb7cmGRSHmo9ovfe04GE0ZdLEEERuSCVR7M8WlDTQ+k2VsTROxcR/DCxOThs2qvpfgzi0rARjb2MKj3Uv4pxVrqVxtY0xV2jZuDEtpnQ80sOlPY7TpUr0F9w5vkj4rzQ5vku1emu+Pn8fT2U6u6l7H9vEm3tz5KJ9+9PVEeqDpOU3jxiLK9TGyUyMCXBddLEn9vxBHkBGJhA1MHDe8aDJZQDVnwLbB8XBXdBFEDAwnoOvBKqOroxQ7LIodFhOnBygXjFdNUBlLYUY9vtL/Mn580p3s8CZJxLdymp0AwlWfvxxezd9W1oVJ0aiPXh0NBz0Pe+F9Oz10h4n+Tg+s3Lelfy2G1GYfXdswxF8Ov4gfbT2DZNRhZCyNbvWxsibRXWFziMYtAZVmg4ZtblgW6HroiWw4s612kWiKxJXji6wYiaOm88E81rMu2gaGw43O+v1NOGnJz4UQe6Tvr3DRA5tm3Pf0h7txP9koLXWFEDM0DJVRb96FGvDQJ0fCBGiHi3rtrjApWmqjb1s0a1IkxN4kMRJHTDA5SZCMoU3F9isUY+d5nPWy59FBeCKz4paR+mNVLkC3mXBthvPiW/nWZDsV1yayK0LTs4rIc7vR5QpBNbxJe24h5p/a9Pp6+dlENiyls20AtG0SH6rgtiSwKmEr21InlDqh0gLVloByIYpl+ZyzcjuLV+/m4bE+Nv1HW/09AkPx3D+0s/TjFnEjxko7SYuRZCwo8r5dL6HNDFesnnVbeKrSS9x0uLzzWT7zi9dQysX5hx9eRWK7SdNzmkjeD1eLitVwYPSufoKJbL2MTghx+OqlY44bNl9xnHAFxfUIMklwPbyERWSkxOCL4hR6wsdXM5BbAQ3Ls3gZj4jpk2kp8OoVG3hdx+Ms/8W72OI1cJqd4OGqy90Vxec3LeLP3v8L1A4Pd7GJvrUHnndQV01bPfpxL/TZ+z3ePivNWFDkH0bWsOxn72aHN0l7JE/wSCOjz7fQ0zGBlTWxKtD0vE/HI1UCW9H8bJn4ptGwyUypjC4UCaY+q5IV6OOWXKoXR4SRTqM62/CjJrsvtImMQeLscTZOtPLcRd9g/bOTnHZPmBipqaq4zX/UzId2vYbmaIlfP7ccYyxCxIXEiBeW0Nnyf08h5rvpU9yN3u7wJKGtBYpljGKV0rImDE8TyfkUemxio2BdOUL+4TD5WdIdNlRY9/RS3nnhfdwzvIKgIbxmF7QZ/MNf/Q6ZV5V5v9rFa56/nBWpUT7X/TAAb2x5hEufvpqI6XF557M8MLGMJ3f2EHiKSEcJ9WyK2ChECprYmEdsqBQmRSNjQLj/YfrxCyEO3d5lqIHj1OeY0duJkZ0E28btDvcaTry4E6scMH5WBqsCo+do4gOK2CgUz6pQeLoZMx4wMpYmkaoSN11eldhExwX/zXfHXsQlPQ+FHW6LPi//4K9Rm1x0t4X5vV54vIL6o8GwI935cfR/dkHDvnuUby/F6jOPznn0LZzfuY2/7fo/ftR4Bpf830fItBSorKygCzbZO7toHtH4tiKwFOYvHqWprxedSUMpnMMYjI3P7D4nSdFxS848xWGpzS3Si7vRQKkngZfURLKKrnSe5mgJgNavzjz50N0Wy97VwEf0XfxwfA3aNVA+JHdDcksODXLCIsQ8VjsZmr6XgGIJ1d5KpS9DbAdU+jIYnsaLGxiuJrAUbgqKj7WR3gWxUYOh/rBd79JX7eKH285gWdM4n3r7a7j/shWc+5KtdEdzbCh38fGhFj695Mc8VFrGWFDk1vwpvD+ziy2LHiZhOHzm2VeRjDqkUmXy2QTWYynsQtgWPDHkYU+GV2R0/yAg8UWII6UeByKRerMB1dEWJg2Oh7u4DXt7eGG00pXCjSsieY1V1jhpRcNGg0IvVM4qoUdjdK4ZYGCskUtXbACg7Nv0WWmG/Ek+230v3yl00uAVOeu9/fQ+UUU3GeFK0c+LqL8YQQWgL02iv9wJ8dkLo86PjQFJbi/FeNfyBxh2GnjKSVEcTNG+eJxiNYL2DfAUTgbaH3eoNNuktxQwli/F7c5gPvQMGjBamtGFouxTXCCklE7MvTGftrXFGXfpjzRDTP7vJ4TYl2ebPLe6Ez8u3SiFEHsJNGd9bBe9v8qi4wr9zR7UrXmMT04lRW9rQH+1a79JkRAHIitG4rBo36+30vYbopTaTGJjoNfkWZEKS2S8b4wRqe4ZvqaX23B1A1/I9nHbwBnkKzFaHrbRJmQ2V1DZAtgWVI/JRxJC7MfeV0Snt6FVybBbk87miD1ZwlnVi513mFiVxIspmjdUyC230ZYmtV2RWw5eKhzkaBUMtu5sJ9FYZstEM+9d8Wv+c+v5fHLnG+hsyXFh+xb6omOM+Cn+fdOF/DsXsqxpnLW7zwZgecMY5UKUUi5OZFeEiA9tT7g4jSbJXRXskQI6YqGGx9ERG3984ij+rQlx4jCbm1BNGQB027RZY4k49kiB/ItaMV1NscPCLmsKvWELfS8VYAzFMIBdu1tob89R9iPcs24VX3j1NxgLipwXTXJLrp1L/+kZem/LhYNav9TJ/9/enUfJXZ4Hvv/+ttqrq3rv1i4QQoAgBmyz3MlFdgzG12YcZ+KYiw+xbxKul3BjPOPjmORcG+6N4yET7Jzx82miugAAQ9ZJREFUkkwYx3FmcMyJL8RnBofYGQxjG7EIJAMSEggtrZZ679rX3/LeP96uUnWrJbSVens+59RR1a9/VfW2UD3U83uf93mN/5zFeOz4xs9Dd9uss2c3aWmUzjU6z31u+Fa2JEbYWxwkatX5yf4tDG/sJD5QZPL1boK0x5ofWphuAOg4FT9SwU2HCR08ij02ATPd57yR0fb/xYoLRtJpcdbMcETfolEACusiAAz+2hESkRqbYmN8OP4c3t+UZz1P/VEPLwQeaavMeCFJ5ae92FVF74sFQruH8EdGpcxFiEVo1toB9C72AEYsptvwpjtQG1ah+rrwohZuR4jU/gqhoqI8EKJ7t2LVz3xKq3WJW3jKZPXmca78V/uxJh064xUu7xnj8fEr+ZXeY/yby3byj1f8V34xfhH/Y+oyAO7a9AsS4Tp3rXqasXySg28M8uQzV7Jlnf5yEpmCgedcYgcymI0u/64HB4dRpTKqOHv2Wghx9qxEAiuRaDYdAKBcIUjHMSYyVAcTBCETLx3DS8cwPah2Gigb6kmDcFYnRqYPoYzJ33/wG1wy81n+dP+TXHLpUV6truGAG+L7xU5+57/uZd3fZAE4/MUujId0UqRs2PPn/Tz+iVW84vbxwPQmACqqxm63zJP5y/nIgV/jh6UB3rv3/XSFSvz1zl/l6Z2X8dLEWiw74LXpfkrDSeyCScfOEJHJOoFjEMq5hCbKWK8PEX5jDCOsu9tJ05blSWaMRFv1/fciscnjexCpd0TgfXGoews4KiGEEEIsJev/2xTmn+jGKer30vQ9XMDY56ISJuo/DzB6XaIxuSPEWZPESJw15blYXZ0QDlNanyB3kUGtN2D6jUFuvfZlnhi/gv/94edmPecbv38jr48M8N9evgrqJsl9NrEpRTjrY43nCfJFac0txCKmZhZaA83NDIlHCQ4OwdZL8GMOds4ndiBDdV2awoYoobz+TGc224AuvY1MQWm1YvpnA0wDqidgIpeg7lmEbJ+I5bEmkuH6//n7XLX2KDt3XcTXfZu9QwOEDkT4XOk3KeeimDWD7l0Go3s3sPaYh+m6RMbKUKrQ8eoklCqobE5moYU4Dxqf/eZMSchBFUvY69Y0Z2NVrYaZLeFuGiTyi9cw1gySuaaHUN7HjRrYVd2a2/DATYDzr6YJphJY6yt8a+zdHMul6IyXeUfY4U82/iN/MvQBPnnwBdL3ziRF10aoPloiNu1S7bMJPbwKtobZhgJ0p7n3x/Y3N269woHf6f45ryRW80JxI/uP9vHG7jWoiE901GKq2ENk0sCfTNANhPMBtQ4TO1cleSwLrqtbjRdLUHdRM9sTiOVJSunEWWl2o6tUUekEfsgkeWRmHZFvcHViiAcqP6Bv5/EvI+p9cXZvXcWOybVQNyHi4yYgVAhIvHQUNTmF8tyTvKMQYiGZoVBzjZGRiGMk4s3yGTUxhXHpRdS7o9i5Kl4qAq6Hk68TyvvUOywym23io4rAhsHtHuV+CE8Z1FOK6uYqQcrDejlB6We9TOQS7Nx1EX//6DbUeJiXj6zmthteYnUsx/WbDlLr96kUw3T8MoRZMZm+AmITAXYlIHYgQ707isrmIJsH1521C70Q4uw19iyzujqbZbVGIq4vkjRKzDavI3dNP17MprztcmqrO+j8+RHqM22zDU+XzwF4yYDscArlGlzUpROfatVha+cI1+/6TS5y6vwOPyf6f2QxZtYqq101otMuamuY4PE+2Krf9+vZdXw9u47dri7f/5fyJr6eXUdF1fg3z3+C7wzfyP5CL79+xS8hqatWOg4qlKN0q/A14EcgNlojOezipSLUNnShprMEU9P6d5PyuWVPZozEGTMsC8N29N5FiThUXSauNgkcRWJdnjs3PU/Oj5H9m3jzOcqCP/qdW7gsPsLhUhe5IRsnbxPOK+IHCvpKk23LbJEQi1DjKrERCmFC88qwlUhg9PXoJOToGGHAqHso20TFI5jlOvWOOKG8T2BbxMZcvKhJfp1N7y8DchtM0vsMcp5en1i/vKL3INqTwEwHXP5r+xnOpyjVQvy37ddgdddIJCrEDlv4Ef0lKzYGVtWg49UJVMgG1yP84pv6SnapLDNFQpwnZiiEOdBHMDqOP53RjRbCYVRtplOSY0NvJ1a5TvKA3kz5yPs6SR0wmfzQOgIblD3TbCEChS0u4XSN0LMJ6tdX2Dfex68MHuPmTXt5f+cveTUzyP2Hb+JPPv2PRCaOl9+bvuLArT2U/8JBxQyuAP4m38/10TcZ95Nc4cR4YHoTvXaBf5m4jG/+f+/n9//N43xz903UR2O8Yq8HIDZs4UWh5yUwPUXPywGRyTpW2cUquxj7DjU3qIWZNZXTkhQtdzJjJNrCKXtc/8MDxw/8TprR9amFG5AQQgghlpQP/PXLpF+tzDo2/Nk0T/7FpaiYfIUV51/b/lVlMhnuvPNOUqkUqVSKO++8k2w2e8rnfPzjH8cwjFm366+/vl1DFGfJsB39ZzSCv6qL3Nv6CByFsmDbmv2ETZdf+9keQjU9+1PqDvHk7/fx7bW/4GvPv4cDT23AyUNsMiC9t4g5Po2qVAkKhYX8tcQiJHFkcQjqdb2WKOQ0S2nMvl79w1IZ6i6G4xDEQgRxXdZilKooxyL1RonAMbGrinqHPXMfCmtMwlmIjXvExmZmft6MYkyHqPX7qK46v3zxIko/68XbncL0If1klNCjndhVcGYmgrp31+l+tYzbm8AoVQmGj+kf1KWETmgSR86PoF7XJXOJOGYopGeOnZnCo7qrfzaRQTkWk2/roN4bo3eXi+kpIhlFx1BAOAvF9xSpp2Ht+klq2TDqX+XwjsbwPZOYXefVzCD/cejXeNv0MLf+7e7m+6u0yQP//lYyn42zu7KGK5wY38+8k69n1/Ge2H5KKsSYpy/A/kHnbv76wK+SqUWpDbgcqvbQlypA0sMqmthZi1pvQKig6NqVxa4ExIdK2Lkqhutj7DuEkUw0W/sbjd9XLHttS4zuuOMOdu3axRNPPMETTzzBrl27uPPOO9/yebfeeisjIyPN249+9KN2DVGcJSOqy16Cvi78mEOl18TwDYJIwI7Jtfxe6g3Sjx+/wvPKF1bzHws3s+UXd2LkHQwf0gc9EocrWEcmCKazsrZIzEviyOLQul+RlUjoL0XlMkY8hiqVMVYP6J8dnaK4MUloaJr6Oh0fChtjhPIekSkPL2pgl328CMRHFaXV4MVMvIgurbFqYBf0/5aieyIYrkF9ZqJ57T/71NJQSxsMbC8SnVT07qoSGcriTBRx3jgGdbf55a2xFqB17GJlkjhyHtVdfSEkEccc6APX02sO+3sxEnFql6/GcH3iYx6TW8MEjkE9aZK9xKDcpz/b/qE41Z6AI4d7sEoWnfEyRn8VfzLCb/a8QNR2uTg5ydRTx/dB2vv2fqZ/3MO22/dSDhzekTjIp49eR18ozwcTuykoi68duYWYWef6Xb/JFT/5NOs7MoznkthZm8d+8Q6y/zxI4pUQkUkDL+3T85KB6SqMbIHka9OYpRpq75swrNuFN0sEkbVFK0lb1hi99tprPPHEEzz77LNcd911ADz00EPccMMN7Nu3j0svvfSkzw2HwwwMDLRjWOICimR0PbD/9hCHP9gFYws8ILHkSBwRQpwriSNL1/MXXcQ3v7aN7UMXk7ijyv+76qcg11BFm7Vlxmj79u2kUqlmEAK4/vrrSaVSPPPMM6d87lNPPUVfXx+bN2/mrrvuYnx8/JTn12o18vn8rJtoL8OxMbvSYOt/PsZMv4R1m8fY0jnGD4qrOfL/pJn6QoInvr2ZiOXxv/W+Qi0bpvNVk47DishoGXskq0voarq9pjReEK0kjiysRhc6YPbmjehFyEYsBvEYRjwGpQqkOyAeJTpWxV2VxqroiyPx4SqBbWC6AaUBg8ylDqGiYuoKA6sG9YQurQNIDCusGiTetPAjEB0zcEoQzFzCC2xIHgk49qsJul/MEBrJ63bcE1OoUplgfKLZOa9BrvKubBJHzs2s2eKuTgg5GF1pjL4evalzKqlbWafj5K5bg1kP8FIRTFdhelDvsAgVArpe0x0pKz3g97pEJk0S+x0uvmqY4Tf7uHnTXox0nR9MvoMPDLwCgB+Fr/q38Y7/8xCvZlfxw+JFfD9zHe8IO7xQ3MhULcE/DF/DOjvJ7d/6d9zY/SZ//NyvM/l6N9aEw+F8J/6hOH4iwPQhNqGwq9C922PgZyYdB6skD8zU5JYrkCs044VfLDbL6CSGrCxtSYxGR0fp6+s74XhfXx+jo6Mnfd773vc+Hn74YZ588kkefPBBXnjhBd797ndTa5nOnOsrX/lKs244lUqxdu3a8/I7iBMZloWVTkN3J6o7Rb0zQr3DxikpTBcypRj/9+ATfPnl97H/0n5+ftfFbOyc5t/vv5WHh99J/KCDVVdYdYVRc1HZHKpSxQxHFvpXE4uQxJHFoTVBoq4v1/rTGb23B6D6ulCdSd0RLpvHj9rNOn01c/HE9HSb3d5f1kkeCTA9SB6G2KhOdqKTCm+miWUoq/c2sWaSJacIqTeh3G/T+UZAKO8x8GwZo+7phMx1MdKpZvc5+RIjWkkcOXtmKISRiOvW3F2dzTI6ADU+2UwmAALHwosaOBNFqj0hCmscBn6Wwa4EZDZbFNYauAndlS7+Wgg3oSht8JkoJbjp6tf4l3+5BtPWu7N+c/dNPLHjV7jkimF+733/wni9g0wpxsGqXtf4wTfeyz/u/hW6w0WG9/Xz9ew6fvU3X+LJ8UuJJWpE1xdQjmL6l70YngFRn77nDUwPIhlFvcMi/WoWq9yy+XyxRDA1jRkKNROixt+BWFnOKDG67777TliMOPe2Y8cOAAzDOOH5Sql5jzd85CMf4f3vfz9bt27ltttu45/+6Z94/fXXefzxx0/6nHvvvZdcLte8HTly5Ex+JXGaDMvS7bkdG4pl/GSE8GiB4mqbSo9Bvdsn4rj8rLKRD1+ykycyW3nw4M184Af/jvHpDoZ3D1Be7eMUFekd4xjZYnO2KKhVZbZoBZE4sri1zhI1kgxjZhbGLxb1DBGgXJdg+FizyYKRKUA8Rni0iJeK4HWEMbwAN+kQmqpgeAGBbRAdqxLYOvlJ76/StVc/tmfWNUey+kqzXYXkcDCTSCki0z7J17NEXhvRX77WpfUeRa6rv6QhSdFKInGkvRozr6pY0onCnGYmRmcaUkncTYMAKMckMu0z/r/0MnW5RXLYJbs1zdTlFoYH1R5FrTfAquq9gvxEQGK/RfHVLp7eeRleIsCfjLDjsa2k4xXeceWbvLtvH+tDU/zk2BZuWb+Xh7ffyDsSB3l1aBX/6yX7maoluPKqQ3zt+Zt58tBm3nx5DZXDSar7Oxj4hW4L3nEIrAmHyJRHKO9jVwKqnYaOWQePYuw7hJrONn+vuesSJaasPGe0xujuu+/m9ttvP+U5GzZs4OWXX2Zs7MRFJRMTE/T395/2+w0ODrJ+/XreeOONk54TDocJz2wqJoRY/CSOCCHOlcQRIUQ7nFFi1NPTQ09Pz1ued8MNN5DL5Xj++ed55zvfCcBzzz1HLpfjxhtvPO33m5qa4siRIwwODp7JMMV51tjQVVWqGE4Cf1UXxfVR6nFd+1LvgMiohbvO4tGxa/iN/pd4+KXrcOIuZt3AnwyT3mdi1iF+tAQ5XXcd1KoYliWzRSuMxJHFa76yESMRx5/OYK9ZTTA+gSqVdYmN4+irxoA5nm2W1hl1FxtQjoU5nkVt6qfaH8Ou+ASOQa0rhOnprnTV7hDVTpPEUZfcxQ52VVFNm3S9FlDuNTFdqHaadL/SsklryAHXI/LmJDgOKpOVq7orkMSR82/u+jwrkYCQgx3uQhWKmN1dEIsC6HWEMxuheuv7sXNVygNhksMuPbsquOkwuY16Rq68NiA8YVJP69miyCTERi0qPZDaD/6v53A9i7cPHmHHmrVkX+xlbCDNb7/rF/xfP/8ooXid4XIn6TU5Hhu/hliixs8PXsRgd47RFwe55Lohph5ZR26TovsVyF5iMPZOSB6CUEGx+mkfJ1fHdH3cdJiBN/N6prtRFlivExSL+veVWLLitWWN0WWXXcatt97KXXfdxbPPPsuzzz7LXXfdxQc+8IFZHWC2bNnCY489BkCxWORzn/sc27dv59ChQzz11FPcdttt9PT08KEPfagdwxSnwQxHUL6PEY3ohgvdnbgdYUKFADcB+Y2KelpR21zFMX2uTQ9x/3//TXr7c7gZfeXMyZokjnokRj3skSxBXi9qlKRInIrEkYXRWkrS2KvESiRQ5fKs81SprG/ZHCqb080XXFev+ckUMFwff3U3VsUjcAycqTLh6TrRMb14yK4oIlN1Ekddqt02a/9HlciUR8dhl8hUndhEgF326X1uGrNcJ3BMjEwBlc0RDB9DjU8SjE9c8L8fsbRIHDl9RsvnvjVB8kZGMdYM6qRo5jNulV3MUg03HcaP62vsgWMQOAaVwRhe1MJNQOqgwo/7+BFwigZWFao9kN8AlTU+2feUKVdD1Pam2H5kA53xMvW1dToHCtzzwkcIxevEInUO53Xr7sP5TsrFMMlElfHndJJ64MW1ZC8LcIoG9aRB12s6QUoc06Vz0ZFyc4zhQ9N6r6VMtlka2NpwofWxWJnato/Rww8/zJVXXsktt9zCLbfcwlVXXcV/+S//ZdY5+/btI5fLAWBZFq+88gof/OAH2bx5Mx/72MfYvHkz27dvJ5lMtmuYQohFTOKIEOJcSRwRQpwuQymlFnoQ51M+nyeVSrGND2IbzkIPZ8lrNF3QZXQ2weUbMWo++cs6qHWY5DYprKpB6toJ3MDC902KhQjh1yP4Ed1ZKnlEEc4F2OWA8FOvoDwXw3aabbrF8uUpl6f4Iblcjo6OjoUezmlbqXFk7pXixsyRkYijiiXMzjRBJos5U0KnSjObvLouwSVrsbJl1NFR2LhGN2MIOQTpuC61i0epD3YQOCahqQrTV3XQ/WKGypokxdUOHYfrWBWP3KYoXS/nyW9Okt45SRAPw6tvYG5chzo62ryqa4ZCGKFQ87FYviSOtFfr595KJGZ9psxQCLO7S3dsu2g9QTyMmS3h9XZglev4sRC1Hr2RK0ClywIgOexSWOPgVBT1pIE303zW9HQnSqcImSsDVl0+xrE9eq3Xr16/h58fvEifOByFNRUu6p/kjX2rSa/JkRlNYlQtTB/8uI8Z8Ym9GqEyGJB+zcSuKGJjepsAJ1dHOSZezMYuezgTRd1Fz/UIpqabv5/EkJXhTGJIWzZ4FcuDYekAh+dhDvaD51EZ0PXF5R6TwAG7bOAmFZmXe/HXVOn5H2GqlxhUV3t0v2AThCA+ogNV9M0plGNLFzohFqm5JSSNsjp/OqPL6kplfcxxUNkcfrGI3dcD2RyBY2Jl86jN6zGzJYhHIZvHyOYgnUKFbKrdOtHyonF6tk/gp2OEp2vYFZ/QSJ7yRZ10vqbb06V/egDiMcyjeVQohDo6iqrXsbo68aczeqxS8iLEGWkkQXMvgjR+BmAPDuCNjB5v0Z1KNsuLzIksQW+a0too8SNgletAGC9qEpnyoMsiPuZR7rfJbYJwVpfPBbbuNBnYUNwYEFgQmTTJ/vMgdhr8TWVe+c5W/Lf5pNfkyPbaWMAbQwMQ9ak924W9tUx0r4OXAK9iomybyCSkDkCtAzoOVimujdD50iReOoYzUcQByBVQhdnJT/N3lxgi5mhbKZ1Y+gzbwYxGwbZRk1MUr1lN7GiZ0oCNsvRGi34Y/A4PZSlU3mH8f/Go97l0/tLGrio6hjycfJ3oSwdRo+NyZUaIRah1TdHcY0G9jpVIzFp/0FhvZHV16vVFgL3nsE5kSjXd2vfoKDgORiyG36uv0CVfz5I4WCDx3CHKF3XqZGoiT2homuKlXUSf26/fYzyrN490bL2OqV7Xs08z7YOFEOemdYbIaPncG8kEODZWV6durhJy9KxtLIoK2ZSuWoU5kSUy7VIZjFDvjWG6uvCo3G8TH/P0hY5CQGo/GDN7B1V7wIvo5guhjInVoytGCltcAhu8okN+A3TstchlY4SOhLj9shexR0JQ0Rs++5PHK1HW/UsNq6r3RrIrAeF8gBezCeV9gnh4JmEDyhW9RiqZQM1sOSDEqUhiJIQQQgghhFjxJDESJ6W8ll2hL91AKO+RuSJJZDrAi8PoDQZWDcIjDiqkiA9ZxA86JPY7RDIByoLI8MzVmZnW3kKIxSeY052pwQyF9AzRzIyN0deD2deLkU6h6nXdsru3GyMWQxVLeqNV19Od6dIpPZsUj+qOcqUqbrfeHLZ+2Rrdqe5YFhwbHJv4wTxGLNZ8b1UuoyammjNFzLTWlY5RQpy9+T4/rbMoqlbDGxpuft5UsYTh+rir0ijHIv7yMbxV3VglD9NVlPtDBI5BbEy/bijnktsQprjKwqkoKgOKUCFg4Hkfc2ajV7sIoVdjVHsCOnc5mB5Ehx28tE95AJRvYnrw8K7rSAyDnbVwirr0rvP1gOQRxfjbwnS9pkgcC6h3WITyujw/9swbGPsOYUxk9O87Og7oznqtJYTzbU0gBMgaIzGPxr5FRjSCkU7pgzUXkiG8iIEbNwhnwIsY1NbVCQ2H6HzFxIuCssCqQ2TSw8nXUGEL67XD4NgElYq06BZikTjVGoOgXp9VaqNmEpNg+JgurevqxOzrBddFTUzpBCkR14mNY+NvGMA6NIqxegCyecz08XI6w/UJDU0Tco7/76c+2EFoJA8hB+uoTobIHt9jBJASGCHOo8Zn3S8WdUlssaQ/2/XjCYMam9Cf62yhuTdZ7ZJ+rJJHrSdMKKc/o+HJGn7cJjKt/98ezgeQh9xFJlYV8ut0KVw4C/FhA9ODytvLJHbEyF1fJfZqhHAWDM/CqoLK6jEkXgmROOYDFoljPqG8h5OtURmMMXDEpZ5yiL82QeGqPiIjRYxSFRL6IqyazuLPrJMyi/OvnxRiPjJjJIQQQgghhFjxZMZInED5PmY0qlv0JiIYVZf8lk5MXxHOB4QzPtNbHDr3KYqlEFYVKv3Q9ZpPOOPixW2cfA3r2DQqnQAgyBdlpkiIRaRxxXTuzFHr8YZGu+6gXsfu70O5Lt7wUb1TfMhBlXQzBlXPYcSjetYnHoNSBdXXhTWRB8Cqu/r88UnU5vUYrg1Hx3AmpqC3G+/AoVnvK1d1hTg/5pshbqq7x5usrBnEdj1UJqubLzg2anxSzwq7LiE3SXZrmsiUp1thV/T/151sjXJ/kuzFNuk3PUr9+utlz8sBuYtM3ZWuojA83dY7sitGPQ2dP49Q6dHd6rr3+NSTJuVeg/LaAAAvYRGZhFDe02V7q0MkjtaPv7djk3xtWrfiRpf+qWKp2VDCn87M+v0lpoi3IjNG4gSGZYFtg21jFKsEqRipHSM6YPWYDN1iU++Acp+BXdIdZwwfrLqiPBDCLnkYvoJEDPXGYYJCYdZ6JSHE4tRae9/4EuEXi82kyAyFCDJZVLHULLEzHKe55qjZwcp1dfKTzWGUqnqtUd1FdSabXezMoxO69KXu6tc/OHR836R5uuQJIc5Na/dJY6bkrHFxw+rq1J3bhkd0UhTWn2MvHdP3HRtvVTdeKkLiSBW77GGXPeodNtNXxAkcC7sS0LXXpd5hEc4HpA4ElPtMkkcU0UkoDRq6lfcA1NKQPATZywL6d7iYHmQvsrArivQBn/CESShjEspCx2GP0ESZxJEqHQerhPccxfQCwoem8dIxPebpLGo620zyWvc7A7nIIk6fzBiJUwpScZRloBIRvIhBYaMiMWTQud9j6jKb8JQiu8mgb6dPZLhIKKY3sTNqLkzpKzUyUyTE4jXfhq6N+43ND82+XhifaJ7faMjQWGcUjE9gblwH2TwcOkZz1/CQ3u/ISKdQ8QgcHcNwHIJiSa8jGp/UG8TOJGFWQs8wy3oiIc6PkyUGzYsdAPU6RiiEQn/2zFAIIxzWF0DKSbz1/fhxG7MeYJVdzGOTFK5fj+kqKl0Wna9X8OM2gW2Q3eTgJqB/R51ql0OooMheYhDYsO7HFcavieJHIDEMuU0QO2KS3WRSXAORSah2mXTtqbD6f+pxBiETq+SRvzRFx74cxkSG2uWrCb8xhreqG/vwGCQTeCOj886KSUIkzpTMGAkhhBBCCCFWPJkxEsBM+dwMMxpFVarNqXaA2kCS+KgH2JRWQaXbouNQgJswiEyBHzbANjHLLsbhYwD4hYLMFgmxRFiJxKyZGt0iW19tbZS/wfGZJABcV2/ECpDNo1xXt+7O5nR7b8c5vlHrvgM6psRjGK4urTX6evSMUiKOWTw+UzR3LEKIs9OY4bW6OpvrbRrHm+WwMzPARsjBHhxA1Wqo3k78WAj72BT2hAczs0ZWGWqXryb52jSFy7pwKoryQJhql0l6f41Q3sSL6WvupqeITAf4jo3lKkbfGaXaA12vKepJg76XdKld4phPen9Atdsmta+AH3PIbI4SH/MI5VzcVIj4Eb2GiFiU8J6jqFoN86Vx1Mz6R3twQHe/HRpeiL9msYxIYiSalO83EyQjGoFEDK8zQr3DxqoplGUQm/CJjypqaX1eYtglvc/FKlQxqi5BKoaRThGMjElSJMQi1ig7aXw5mpuItK73aZTXAM3yGyMUQrkuKpPVJXUhB//AIay63sOIeJTg4JBu99t40boLpTLUXf2axVLz/VpLXiQpEuL8aHxuVbE0ew1fY28y9OfN3nIJ5AqoQhGjv5dg75vY3V0QixL0plGOSb3DJnxomnCpBq5H4s085XVJoiNlOvb5GHWP3JXdxEZrlAfChPI+hTUOyWGXyEiR6rs66XlF4UYN0vtdspt0qV10pKpL9VyFP1OO3/eLCVTIxqh7GOkY9kwDF9B7LTX2WWoke8FMKZ0Q50pK6YQQQgghhBArniRGAjjeIEH5PkZPN0Y6RXVNCmeyRDjj4uTr2OVAl8wBqTd0e97iGgdlmxhVF2wLY98hKJWkC50Qi1xjhsYvFmfN1liJxKzWto3ZG2Omk1XzqmzI0W1xE3FUuXy81XbIQZXLqIkp/bzeblQ2h7lm1azNWqVblBDt0dp9LqjX9aztnNkUK5HQsy4hPUOjxichlcToSutZ4IE+XVIXj2AcPEpxbYT4UInKph5KmzoJ0nGUY2FXfALHojqYIHNND6G8jzNRJJT3qXbbJId1l7r8pSnsKrhRA8tVBI5B74t6xthNhQhNlDE9hTMxM1tcrmCUqgTxMKar23IHR46ixiZ0J8t5thWQWCLOB0mMRLN8zgxHMMMR1OQU2BaRQ9MAeDGbIGxh1Xz8kIHpg9sRIjZWIzHsYtY8sC2o6qDkTUxi2M6C/T5CCO1sSksaiVIjQTJDoeP7Fc10sgJ0d7l6HSOdwp/O6D1QQiFdJjedae4lEhwc0l9iZvY6CjLZ5nvJFxkh2s+fzjQ7PwK6hK6/FyOZwJ/OYG+5hPrVF+lSumIJtXE1xKJQdzFKVYzONOkn9mK4PuHJCrGhAoFjURmMEdgmU78SJ3CMmb2NTAqXdREZKZI8UMb0AgLHwPQUoYIiOexiVxTxF4ews2ViYx7R/ZNUBxNER6qokI2dq1K5bBAVj2BOZDEnspArYCTi+MViM0bJvkSiHSQxErPWFoFeX6Qmp/F6k1RXdwBQWBcmsE1iYx7VtIVd9gAIjxYwy3WCg0dQ2Vzz6nJQq174X0QIMUvrvkRnqvlZnpk1atTyW4kEQb2ONzaur0gP62YrRjymnxNysPv7jidQjdmnTBYjET++H9KcPZOEEOdu7mxR4wJH68/86QwqkyWY0hc/yRVwfvYKODZGZxrD9cH1MNYM6j3J4hHdKGUmGVKOhXJMoiNlovsn6X96Arvi48VM7HKAXQ4w6h6VwQi5DWFS+wpUuiwSR6qYXkAo71O7fDWV9WnCkxWCdJzISBE3NbMGqu4RPZzFmJhpFuE4zbHKOiLRbpIYCSGEEEIIIVY8SYwEhmVhRqOYvd2YHQmU68GafqxCVZfPhQ2iUz6hiTJOvk5szMXK1zC8gNpAEmNsCsOxdYvvlpknIcTCm282Zu5Grqfz3Mbmq437jZmjxtqFIJPVG78WS837recH9TpqpgudITNFQrTFfBs2Nz6njc9d47NszLTxxrH1WsFiCcqV4y/meqh0EoZHCeJhDNcn/pre6Nkqu5ilGl5vB6VNnQBEJuvYZQ+77OH2Jkg+exhrptNc12792XeyNZxcHavk4eTqGK6Pmw5jTGSIHs7CgSPgevqWSqKms6ixCT1zPZ2RmCHaTtp1r3CNRCaoVLCSM8EynUIByrKwM1WcSR8/GcHrjGAX6kQyZZRtAg7hHfshGkG5Hoaj/zlJm24hFp/WXeFbv1wELYuY537paD3WbKE9U57TaKDQWnIHs/cgMk/yXtKOW4hzN99nFmZ/ppvNU5IJgqnp5p5FZjIB4TA4ti6b60zrBgfxsF7TAzo5GZvQ65FKNQBUPIIfc7BzVWozpfbhSf2zWk9YN2OwTQLHwHFsup+fxEvHqPWEiQ0V8GMh3FSI6P7J5nuHswXcTYM4E0WMrjSUK83SOSMRb5bxtpbgSoIk2kVmjIQQQgghhBArniRGK5zyfd18wXYIprNg2xAJwaGjmKUqfkcY0F3ozJqPUXPB8wliIeyRrJ4liscIalXdKUaaLgix6JzOFdaTLdRufY35Hpst5TmNdt2nc74Q4szN15669XM793FrCazZ3YWRPP5YFYqo6SzEoqhMVrfIPnhUH3McXWLX30tw5CjkChQu60I5Fs4x3RghfDRP+NA09uEx3WFuqICTrWF6AXbFp3TVKihXMF2f+MvHmu8b3T+p7+QKzVkje+cbqOER1PTxphBBvd7cyLX195XZItFOkhitYGY4gpVOY/f2YHal9cF4DKp1jIE+gOZaovBoCcMP9Dm2hXVwBEolCIdRk9Ozgq8QYnF5qy8SzW5VM21w3yqR8ovF5noFY6ald6MdsD+dmTf5kS81Qpy7+cpdW0tTra7O5h4/jY6SViKhk6CaLnkzEnGdfIQcXbrmujOldI7e86i/FxWPEIyOg2NjdncRrOoh8WYew/XxejsIVvXoUjrXJVjVA65H8eIOzGxJryPK1oi/OIRKJzGzJUpXrcKPhbCPTaEyWZ2IOTbe3jfAsVH1+qykrRGHpOxWXGiSGK1wqlJFuR7eyCjmxrXg+ahEBBVxCFIxALzOGIbvY43njz/P9QjyRYKJKVSlKsFLiCXiVEnL3MeNLydWV2fzua1JVONPY55ESvYYEaL9TrjgMDPDEtTr2BdvPD6LG3J0m+5CESMcxuzu0ue63vGmC+WKvu/YGNkCxpaL9d5GtZpu4Q0YpSr2sSkCx8Iq6SYJZlY/J5T3wHUxsyXMmTVJRraAikeIDRWwXh/S65nCuhJFTWexBwf0DBXMmik63QYxQpxvkhgJIYQQQgghVry2JUZf/vKXufHGG4nFYqTT6dN6jlKK++67j1WrVhGNRtm2bRu7d+9u1xBXLMOyMCwL5c1cWSoUsNJpgoNHwPMwvACj6hKELMyai31oDGNsCpXNYRSrqOGR4x3oPFfWFYm2kThy/p1uWd2szVfr7qzW3K2vNV+5i8wUicVkuccRMxRqlrM3O0KGQnptEKCKJVSxhL1uDf7WiwmmpvUsUFdaz9LUXYhFdde6vh691iedxMjqNUBGOIxRqqIciyAdB8fBPjyGVdafc6+3AxWyCe85Co6DuyoN5QrupkHc9b36dRrjqNWar6nqdVSh2Jx1Nru7ZpUBSvmtWAhtS4zq9Tof/vCH+dSnPnXaz/mzP/szvvrVr/KNb3yDF154gYGBAW6++WYKhUK7hrmiNFpzm9Gofmw7eu+iZBI8T68zsm3wfMjlsfcfhWKZoK8LujsxEnEolTCiEUAnRYbtLNSvI1YAiSMXXuNLyNwkCGa32W58EZMvLWKxWy5x5FQlZWrmIkVjfWBz76JEvPlZVtNZePaXmGtX6/+fu57+WchBZbKYA316v6KZNcfeqm5UsYS3vl+XyJVqmBNZnXA5NkapSrCqBzcVwpjQZXqUKxiuXo9s56rYuw8RjI6j9r6px1AsEYyOz24dPnNxxRsZPaGMTogLrW2J0f33389nP/tZrrzyytM6XynFX/zFX/DHf/zH/MZv/AZbt27lu9/9LuVyme9973vtGqYQYhGTOCKEOFcSR4QQp2vRrDE6ePAgo6Oj3HLLLc1j4XCYm266iWeeeeakz6vVauTz+Vk3Mb/Gxqt+sahbdEcjujzOsXU3GM8D24JcHuJx6O4k6O/EnMpBsQyJGP50Ri/grFRRvi9ldGJRkThy/rTODrXeb8wQqZaZIulKKZaTxRpHWjduPa2fhxzdTCF0vLLD6uokSMd1WVuh2PwcG+Ewwei4btedTmJMZLAn8pRvvER3kpvONhs1GFsu1rNAmSxmqUbkhf0Eq3ow+nshFsXOllHTuqU3dVeXyc10um1t1NLogjl3lkhmocVCWjSJ0ejoKAD9/f2zjvf39zd/Np+vfOUrpFKp5m3t2rVtHedSZ1iW3uMgHJlJhGyU6+GPT0CqQ5fRAUEqDrkC5lgGf2QUajX8Nw40XyeoVBbqVxDipCSOnL5TlaucaSmLdKUUy8liiSPzfQ5P1lWyuQ9ZdxdGy5ojIxRqJieAvr/vkP6zK61L7RJx/doDfXhXbEDtfVOvBXJd4i8O6dfpSqPGJvA3r8OYyOj3CYf1XkR1F/PYpO5s59io4RH9Xo7d7IinprPNsr1GuV/rekZJhsRicUaJ0X333YdhGKe87dix45wGZBjGrMdKqROOtbr33nvJ5XLN25EjR87p/VcC5XqzGi+AvopELk8wMoZyPcxx3TaTmX0PgnwRw3aaa4oas09CnCmJI4vDqb6InKzOf76rurIeQCyElRBHWj+jrc1Qgpb1RK0a63T8op4JaswWqXq9eWu9iKGms83GDI2NVp3DE3ptUjgMrnf8vOkshBzsibw+17F18hSL6lmnWBRVq+nmTDP7EanpbLN9uF/UTRYajVxafz9JisRiYp/JyXfffTe33377Kc/ZsGHDWQ1kYGAA0FdqBgcHm8fHx8dPuGrTKhwOE57piS+EWPwkjgghzpXEESFEO5xRYtTT00NPT09bBrJx40YGBgb4yU9+wtVXXw3oTjJPP/00DzzwQFvec6VodKNrzPIoz8VMJpvrhAxHl9PheZi93VCroSpVfbxSbc4SyXoicT5IHFm65ruyK1d7xUJYSXGktdSs9f7cWVsjEcefzmAlEs21Q/50BqurU68NCoUwmSmLK5Z0CVx3F6pWwxsaxh7UCaHRldazRY6tS+BmHqtaDTU2gZFM6A50IUd3p0vE8d48iNXV2XxtNdMVT9Xr0DJOv1iU0jmxqLVtjdHQ0BC7du1iaGgI3/fZtWsXu3btotgyjbtlyxYee+wxQE9Z33PPPfzpn/4pjz32GK+++iof//jHicVi3HHHHe0a5oqgfB/l+5jhyPESOM/DcGzMcESXyaVTzelvwmGMRBxV0YmQ4diSFIkFIXFk4cgXF7FcLMU4crL1N40yuvlKWf3pDGYjGWk5VxVLwExL74vWg6ObMhjJhG6bnYjrZGqmdF5NZ/XzR8ePN25o7F3YuvdQ6xqjmfdplOfNHfN8fwqxGJ3RjNGZ+OIXv8h3v/vd5uPGVZef/vSnbNu2DYB9+/aRy+Wa53z+85+nUqnw6U9/mkwmw3XXXcePf/xjkslku4YphFjEJI4IIc6VxBEhxOkylFJqoQdxPuXzeVKpFNv4ILYhm4+2MsOREzZlVZ57fMPX5PGWu6pQbHaeM6NRfXVoTkmeEG/FUy5P8UNyuRwdHR0LPZzTttzjiJSyiKVkJcWR1o5t85XPze3o9latrq1Eojnr0yizAyDk6BkfIJiaxly7muDIUd14Yc0g5AqoQhGjK63beCfizXI8Va83O9k1ZqMa720lEs1yOUNK58QicSYxZNG06xYXjvJczK603r/IdvT6InQyhOfpYNiSJDUSpEZJnhBiaTvdLymtX7ik+5wQ7XeqcrO564sa9xutuFvbdAPH1xrVXVSxNKvMjrqLNzKKNzKq1xllss3XUeOTkErqsrnpbDMpCup1nVC1lOc1EqTWvYkaj1vvC7FUtK2UTiwuhmU1W3QDzfVDAObaVajJafxsFgudCBkzyZIQYnk6nau4860TEEJcWHovohPXFDVmaBr3G1e6G7M1rccb56p6vdkgoZk4OXZza47GprCNRMgEaOyT1NU5e2AzrbgbscHq6sSfzrTjr0CIC0ZmjIQQQgghhBArniRGy1RjPVDjT2DWBq14HsrVnenUpN7M1Uqn9eau0WhzdsmMRmetSRJCLA8nK9URQiy8Wd3mWkrSWm+N9TxqzpojoLmxq5VIzJotAvCGhpubv4LuQtc602Mk4pjdXc3ZKLO7q9l1zp/O6HK6RLy5aWvjvWW2SCwHkhgtMyfsWdTyp/JclOfq6XDb1o9dT5fVeXofo7n8YlFadQuxQsxNliRREmJhnOqz2EhY/GJxVindrOfU3VnPb+wr1Pr8xjlqnjI5b2T0+FimppvvYYZC+NOZZmvwxvHWtU1CLGWSGAkhhBBCCCFWPEmMlpnWrnGt5XSGZWEmk7oLXaVKUCg0zzW70s2p+pO9lhBi5ZGGC0IsnLmzMM2StdbytWKxORPU+pzG/9Nby+yMrjRmd5d+re4u/bPurubz/WKx2XihUXrX2gVvbqvwVvN9hxBiKZLEaJmZlQzNrA1qrC1SlSpBrdpsv20lErqcrlLVdciVCspz9Z+SFAkhhBALpjXZOKFUjtlJUGuiFLSsLWrtTucNDeuyuJBDMDWNkYjjjYzq92npMNfaaruVMWcdk1w4EcuRJEbLTOuaota1Qcpzm48bCVMjQfKz2VmbuQohloczWSMk64mEWJzmfjYbSU9jNmju+iOzZWPVxqyPPTgwq0lCUK+jiiXsdWua5899r0aCZcy8h5JESKwAkhgJIYQQQgghVjxJjJa5xsauyvePd6ybacWtfB/l+5jhyPHHrtecdWpt9S2EWHrOpNRFymKEWJxa1/U0WnQ3Zo3mrgFqdJ+zujpnb9A8Nd08vzHL1Civa2i8x9xW4Y3yvFPFCJlxFsuFJEbLSKPJQutj5fuz9iFqrkFqrD+aSZwa92eV38k6IyGEEOKCmi9BaSQlrSVyDY1SN2PmRsg5YU+hxjmtr9n6eO4+SM09jFrL9Oa09G4lF1bEciGJkRBCCCGEEGLFk8RoGWmUxjXMN1PUPNdzZ80ezX2uEEIIIRbW3BK1Rglc66aqfrGIkYg3y9786UyzCUPrTFPjeUYifvx+KISRiGMk4s33MFqaMbTOBLXOQknpnFiu7IUegGifRvLT7EY3U1oHYIYjzbVHkhAJsbK0fmESQiwurXsGNbQmRI37jXI6MxRCFUsnJEKNnxmJOKpYav6s9dzWttzz7ZN0sjgh8UMsV5IYLTPNBgtz1haZ0ai+qjSTHLWuJRJCrCzypUaIhXG6FyWClqSntfFB6yarRiiEyck/z41GDUyfuClr61qiRkvvWc0aJEaIFUpK6YQQQgghhBArniRGy0xrWVxQqzZnhhobuAohhBBiYZzJTEzr7NLc0ra5ZXDzaS2Jm28MrRvAypohITRJjJax1rK6VmY4ckJrbyGEEEIsvLlJ0KnK71rPOVkr7pOdJ6VzQpxIEiMhhBBCCCHEiieJ0TKmfP/ENt0tjRekG50QQgixuMydvZnbna7xZ6Ndd+Oc1pK4uQ0b5js+33sJsdJJYrSMzOpIN1Mq10h+5iZJkhQJIYQQi9vJusmdbI3RfOuFTpZYCSFOJInRMtKa/DQSn+Ymri1JkhBCCCEWv7dqjHCy5gon24eoNbESQpxIEiMhhBBCCCHEite2xOjLX/4yN954I7FYjHQ6fVrP+fjHP45hGLNu119/fbuGuKy0zhQ1us4p359VSifEUiNxRAhxrpZyHHmr2aJTdaubryvdW72mECtd2xKjer3Ohz/8YT71qU+d0fNuvfVWRkZGmrcf/ehHbRrh8tJaRtdortAgbbnFUiVxRAhxrpZyHJnbLAFObOd9Ok6WJAkhZrPb9cL3338/AH/7t397Rs8Lh8MMDAy0YURCiKVG4ogQ4lxJHBFCnK5Ft8boqaeeoq+vj82bN3PXXXcxPj5+yvNrtRr5fH7WbaVqLZc72X0hVgKJI0KIc9XOOHK65Wwna65wJq/R+hwhxKktqsTofe97Hw8//DBPPvkkDz74IC+88ALvfve7qdVqJ33OV77yFVKpVPO2du3aCzjihdFaGidlckLMJnFECHGu2h1HTpaonKzV9qkSJCHE+XNGidF99913wmLEubcdO3ac9WA+8pGP8P73v5+tW7dy22238U//9E+8/vrrPP744yd9zr333ksul2vejhw5ctbvv1TIbJBYyiSOCCHO1XKNIydrz306SdCp9i8SQpyeM1pjdPfdd3P77bef8pwNGzacy3hmGRwcZP369bzxxhsnPSccDhMOh8/bewoh2kviiBDiXEkcEUK0wxklRj09PfT09LRrLCeYmpriyJEjDA4OXrD3XEpOtmlr47hs6ioWI4kjQohztZzjyHwzPa2tuU/WpltmiIQ4d21bYzQ0NMSuXbsYGhrC93127drFrl27KBaLzXO2bNnCY489BkCxWORzn/sc27dv59ChQzz11FPcdttt9PT08KEPfahdw1zSGknP3HVGsneRWC4kjgghztVyiCOtSY8kQEK0T9vadX/xi1/ku9/9bvPx1VdfDcBPf/pTtm3bBsC+ffvI5XIAWJbFK6+8wt/93d+RzWYZHBzkXe96F4888gjJZLJdwxRCLGISR4QQ50riiBDidBlKKbXQgzif8vk8qVSKbXwQ23AWejhtI2VyYinwlMtT/JBcLkdHR8dCD+e0rZQ4IsRSIHFECHEuziSGLKp23eL0SVIkhBBCCCHE+SOJkRBCCCGEEGLFk8RICCGEEEIIseJJYiSEEEIIIYRY8SQxEkIIIYRYJMxQaKGHIMSKJYmREEIIIYQQYsWTxEgIIYQQYpGQDVyFWDiSGAkhhBBCCCFWPEmMlhjDshZ6CEIIIYQQQiw7khgJIYQQQgghVjxJjJYY5fsLPQQhhBBCCCGWHUmMhBBCCCGEECueJEZCCCGEEEKIFU8SIyGEEEIIIcSKJ4mREEIIIYQQYsWTxEgIIYQQQgix4kliJIQQQgghhFjxJDESQgghhBBCrHiSGAkhhBBCCCFWPEmMhBBCCCGEECueJEZCCCGEEEKIFU8SIyGEEEIIIcSKJ4mREEIIIYQQYsWTxEgIIYQQQgix4rUlMTp06BC/+7u/y8aNG4lGo1x88cV86Utfol6vn/J5Sinuu+8+Vq1aRTQaZdu2bezevbsdQxRCLHISR4QQ50riiBDiTLQlMdq7dy9BEPCf/tN/Yvfu3Xzta1/jr/7qr/ijP/qjUz7vz/7sz/jqV7/KN77xDV544QUGBga4+eabKRQK7RimEGIRkzgihDhXEkeEEGfCUEqpC/FG/+E//Af+8i//kgMHDsz7c6UUq1at4p577uEP//APAajVavT39/PAAw/wiU984rTeJ5/Pk0ql2MYHsQ3nvI1fCHHmPOXyFD8kl8vR0dFxzq8ncUSIlUfiiBDiXJxJDLEv0JjI5XJ0dXWd9OcHDx5kdHSUW265pXksHA5z00038cwzz5w0ENVqNWq12qz3AfBw4YKkfEKIk/FwAf1F43yQOCLEyiNxRAhxLs4khlyQxOjNN9/k61//Og8++OBJzxkdHQWgv79/1vH+/n4OHz580ud95Stf4f777z/h+M/50VmOVghxvhUKBVKp1Dm9hsQRIVY2iSNCiHNxOjHkjBKj++67b94PfasXXniBt7/97c3Hx44d49Zbb+XDH/4wv/d7v/eW72EYxqzHSqkTjrW69957+bf/9t82HwdBwPT0NN3d3ad83tnI5/OsXbuWI0eOnJfp/AtlKY57KY4ZZNxzKaUoFAqsWrWqeUziyNL7N7IUxwwy7gupnWOWODLbUvz3ATLuC2kpjhku7HeRkzmjxOjuu+/m9ttvP+U5GzZsaN4/duwY73rXu7jhhhv467/+61M+b2BgANBXagYHB5vHx8fHT7hq0yocDhMOh2cdS6fTp3yvc9XR0bGk/qE1LMVxL8Uxg4y71dyrMxJHtKX4b2Qpjhlk3BdSu8YsceRES/HfB8i4L6SlOGa4MN9FTuaMEqOenh56enpO69yjR4/yrne9i2uvvZbvfOc7mOapG+Bt3LiRgYEBfvKTn3D11VcDUK/Xefrpp3nggQfOZJhCiEVM4ogQ4lxJHBFCtENb2nUfO3aMbdu2sXbtWv78z/+ciYkJRkdHm3W7DVu2bOGxxx4D9JT1Pffcw5/+6Z/y2GOP8eqrr/Lxj3+cWCzGHXfc0Y5hCiEWMYkjQohzJXFECHEm2tJ84cc//jH79+9n//79rFmzZtbPWjtC7Nu3r9m1BeDzn/88lUqFT3/602QyGa677jp+/OMfk0wm2zHMMxYOh/nSl750wlT5YrcUx70Uxwwy7vNJ4sjisRTHDDLuC2mxjnk5xpHF+nf9VmTcF85SHDMsjnFfsH2MhBBCCCGEEGKxakspnRBCCCGEEEIsJZIYCSGEEEIIIVY8SYyEEEIIIYQQK54kRkIIIYQQQogVTxKjt5DJZLjzzjtJpVKkUinuvPNOstnsSc93XZc//MM/5MorryQej7Nq1Sp++7d/m2PHji3aMQM8+uijvPe976WnpwfDMNi1a1fbx/mtb32LjRs3EolEuPbaa/nZz352yvOffvpprr32WiKRCBdddBF/9Vd/1fYxzudMxj0yMsIdd9zBpZdeimma3HPPPRduoC3OZMyPPvooN998M729vXR0dHDDDTfwz//8zxdwtMvLUowhIHGknZZiDAGJIwtJ4kj7LMUYAkszjiyJGKLEKd16661q69at6plnnlHPPPOM2rp1q/rABz5w0vOz2ax6z3veox555BG1d+9etX37dnXdddepa6+9dtGOWSml/u7v/k7df//96qGHHlKA2rlzZ1vH+P3vf185jqMeeughtWfPHvWZz3xGxeNxdfjw4XnPP3DggIrFYuozn/mM2rNnj3rooYeU4zjqBz/4QVvHea7jPnjwoPqDP/gD9d3vfle97W1vU5/5zGcu6HiVOvMxf+Yzn1EPPPCAev7559Xrr7+u7r33XuU4jnrppZcu8MiXh6UYQ5SSOLJYxrwYYohSEkcWmsSR9liKMeRsxr0Y4shSiSGSGJ3Cnj17FKCeffbZ5rHt27crQO3du/e0X+f5559XwEn/459P5zrmgwcPXpAvNO985zvVJz/5yVnHtmzZor7whS/Me/7nP/95tWXLllnHPvGJT6jrr7++bWOcz5mOu9VNN920IMHoXMbccPnll6v777//fA9t2VuKMUQpiSPttBRjiFISRxaSxJGdbRvjUowhSi3NOLJUYoiU0p3C9u3bSaVSXHfddc1j119/PalUimeeeea0XyeXy2EYBul0ug2jnO18jbmd6vU6L774Irfccsus47fccstJx7h9+/YTzn/ve9/Ljh07cF23bWNtdTbjXmjnY8xBEFAoFOjq6mrHEJe1pRhDQOJIuyzFGAISRxaaxJH2WIoxBJZmHFlKMUQSo1MYHR2lr6/vhON9fX2Mjo6e1mtUq1W+8IUvcMcdd9DR0XG+h3iC8zHmdpucnMT3ffr7+2cd7+/vP+kYR0dH5z3f8zwmJyfbNtZWZzPuhXY+xvzggw9SKpX4rd/6rXYMcVlbijEEJI60y1KMISBxZKFJHGmPpRhDYGnGkaUUQ1ZkYnTfffdhGMYpbzt27ADAMIwTnq+Umvf4XK7rcvvttxMEAd/61reWxJgvpLnjeasxznf+fMfb7UzHvRic7Zj//u//nvvuu49HHnlk3v/BrVRLMYZcyHFfSEsxjizFGAISR843iSOLw1KMIScbx2L6e53PUoghdltffZG6++67uf322095zoYNG3j55ZcZGxs74WcTExMnZL1zua7Lb/3Wb3Hw4EGefPLJc75CcyHGfKH09PRgWdYJVwnGx8dPOsaBgYF5z7dtm+7u7raNtdXZjHuhncuYH3nkEX73d3+Xf/iHf+A973lPO4e55CzFGAISRxY6jizFGAISR9pF4sjCWooxBJZmHFlSMaStK5iWuMbCweeee6557Nlnn33LhYP1el39+q//urriiivU+Pj4hRhq09mOueFCLpr+1Kc+NevYZZdddsoFj5dddtmsY5/85CcXZMHjmYy71UIueDzTMX/ve99TkUhEPfbYY20e3fK2FGOIUhJH2mkpxhClJI4sJIkjO9s2xqUYQ5RamnFkqcQQSYzewq233qquuuoqtX37drV9+3Z15ZVXntBq8tJLL1WPPvqoUkop13XVv/7X/1qtWbNG7dq1S42MjDRvtVptUY5ZKaWmpqbUzp071eOPP64A9f3vf1/t3LlTjYyMtGWMjbaN3/72t9WePXvUPffco+LxuDp06JBSSqkvfOEL6s4772ye32iR+dnPflbt2bNHffvb317QFpmnO26llNq5c6fauXOnuvbaa9Udd9yhdu7cqXbv3r1ox/y9731P2batvvnNb87695vNZi/YmJeTpRhDzmbcSkkcaceYlVr4GHI245Y4cn5JHGlPHFmKMeRsxq3UwseRpRJDJDF6C1NTU+qjH/2oSiaTKplMqo9+9KMqk8nMOgdQ3/nOd5RSx69wzHf76U9/uijHrJRS3/nOd+Yd85e+9KW2jfOb3/ymWr9+vQqFQuqaa65RTz/9dPNnH/vYx9RNN9006/ynnnpKXX311SoUCqkNGzaov/zLv2zb2E7lTMc939/r+vXrF+2Yb7rppnnH/LGPfeyCjnm5WIox5GzGrZTEkdO1FGOIUhJHFpLEkfbFkaUYQ5RamnFkKcQQQ6mZVWNCCCGEEEIIsUKtyK50QgghhBBCCNFKEiMhhBBCCCHEiieJkRBCCCGEEGLFk8RICCGEEEIIseJJYiSEEEIIIYRY8SQxEkIIIYQQQqx4khgJIYQQQgghVjxJjIQQQgghhBArniRGQgghhBBCiBVPEiMhhBBCCCHEiieJkRBCCCGEEGLFk8RICCGEEEIIseL9/1kw+T9ZwAHXAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1000x800 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(10,8))\n",
+    "directions = [\n",
+    "    ('h', [1,0,0]),\n",
+    "    ('k', [0,1,0]),\n",
+    "    ('l', [0,0,1]), \n",
+    "]\n",
+    "for i, direction in enumerate(directions):\n",
+    "    name, vector = direction\n",
+    "    axis1 = name, -0.5, 0.5, 0.002\n",
+    "    axis2 = 'E', -5, 5., 0.02\n",
+    "    otheraxes = [ (n, -0.02, 0.02) for n,v in directions if n !=name]\n",
+    "    \n",
+    "    plt.subplot(2,3,i+4)\n",
+    "    hg1, Eg1, I1 = violini_pc1.getThinSlice(axis1, axis2, *otheraxes)\n",
+    "    plt.pcolormesh(hg1, Eg1, I1.T)\n",
+    "    plt.clim(0, np.max(I1)/2)\n",
+    "    plt.ylim(-2,2)\n",
+    "    plt.xlim(-.25, .25)\n",
+    "    resplot.plot_qE_ellipse(violini_cm1, vector, 'r', label='Violini')\n",
+    "    plt.legend()\n",
+    "    \n",
+    "    plt.subplot(2,3,i+1)\n",
+    "    hg1, Eg1, I1 = mcvine_pc1.getThinSlice(axis1, axis2, *otheraxes)\n",
+    "    plt.pcolormesh(hg1, Eg1, I1.T)\n",
+    "    plt.ylim(-2,2)\n",
+    "    plt.xlim(-.25, .25)\n",
+    "    plt.clim(0, np.max(I1)/2)\n",
+    "    resplot.plot_qE_ellipse(mcvine_cm1, vector, 'r', label='MCViNE')\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "mcvine",
+   "language": "python",
+   "name": "mcvine"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.15"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {
+    "height": "calc(100% - 180px)",
+    "left": "10px",
+    "top": "150px",
+    "width": "332px"
+   },
+   "toc_section_display": true,
+   "toc_window_display": true
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/singlextal/Mn3Si2Te6-SEQ/resolution_workflow_config.py b/notebooks/singlextal/Mn3Si2Te6-SEQ/resolution_workflow_config.py
new file mode 100644
index 0000000..0936de3
--- /dev/null
+++ b/notebooks/singlextal/Mn3Si2Te6-SEQ/resolution_workflow_config.py
@@ -0,0 +1,142 @@
+import os
+thisdir = os.path.abspath(os.path.dirname(__file__) or '.')
+
+import numpy as np
+
+# instrument
+from dgsres.instruments import sequoia as instrument
+
+# sample
+sample_yaml = os.path.join(thisdir, 'sample.yaml')
+
+# exp condition
+beam = os.path.join(thisdir, "beam-60meV-n5e9/")
+Ei = 60.47848057039433
+
+from mcvine.workflow import singlextal as sx
+psi_scan = sx.axis(min=0., max=180., step=1.)
+
+# sim directory name
+def simdir(q, E, slice):
+    return 'sim-%s-q_%.3f,E_%.3f' % (slice.name, q, E)
+sim_Nrounds_beam = 30
+
+# slice
+# 
+class Slice_00L:
+    name = '00L'
+    hkl_projection = np.array([0,0,1.])
+    hkl0 = np.array([0,0,0.])
+    
+    class grid:
+        "simulations will be done for points on this grid"
+        qaxis = sx.axis(min=-.5, max=4.5, step=0.6)
+        Eaxis = sx.axis(min=5., max=31., step=5.)
+GammaA = Slice_00L
+
+# 
+class Slice_H00:
+    name = 'H00'
+    hkl_projection = np.array([1.,0,0.])
+    hkl0 = np.array([0.,0,0])
+    
+    class grid:
+        "simulations will be done for points on this grid"
+        qaxis = sx.axis(min=-0.5, max=3., step=0.4)
+        Eaxis = sx.axis(min=5., max=31., step=5.)
+
+#
+class Slice_H01:
+    name = 'H01'
+    hkl_projection = np.array([1.,0,0.])
+    hkl0 = np.array([0,0,1.])
+    
+    class grid:
+        "simulations will be done for points on this grid"
+        qaxis = sx.axis(min=-0.5, max=3., step=0.2)
+        Eaxis = sx.axis(min=5., max=31., step=5.)
+
+#
+class Slice_H02:
+    name = 'H02'
+    hkl_projection = np.array([1.,0,0.])
+    hkl0 = np.array([0,0,2.])
+    
+    class grid:
+        "simulations will be done for points on this grid"
+        qaxis = sx.axis(min=-0.5, max=3., step=0.4)
+        Eaxis = sx.axis(min=5., max=31., step=5.)
+        
+# 
+class Slice_H03:
+    name = 'H03'
+    hkl_projection = np.array([1.,0,0])
+    hkl0 = np.array([0,0,3.])
+    
+    class grid:
+        "simulations will be done for points on this grid"
+        qaxis = sx.axis(min=-0.3, max=2.6, step=0.4)
+        Eaxis = sx.axis(min=5., max=31., step=5.)
+
+# 
+class Slice_H0H:
+    name = 'H0H'
+    hkl_projection = np.array([1,0,1.])
+    hkl0 = np.array([0,0,0.])
+    
+    class grid:
+        "simulations will be done for points on this grid"
+        qaxis = sx.axis(min=-0.3, max=3.35, step=0.6)
+        Eaxis = sx.axis(min=5., max=31., step=5.)
+
+# 
+class Slice_0K1:
+    name = '0K1'
+    hkl_projection = np.array([0,1.,0.])
+    hkl0 = np.array([0,0.,1.])
+    
+    class grid:
+        "simulations will be done for points on this grid"
+        qaxis = sx.axis(min=-0.5, max=3., step=0.4)
+        Eaxis = sx.axis(min=5., max=31., step=5.)
+        
+# 
+class Slice_mK2K2:
+    name = 'mK2K2'
+    hkl_projection = np.array([-1.,2.,0.])
+    hkl0 = np.array([0,0.,2.])
+    
+    class grid:
+        "simulations will be done for points on this grid"
+        qaxis = sx.axis(min=-0.5, max=3., step=0.4)
+        Eaxis = sx.axis(min=5., max=31., step=5.)
+        
+# 
+class Slice_mK2K3:
+    name = 'mK2K3'
+    hkl_projection = np.array([-1.,2.,0.])
+    hkl0 = np.array([0,0.,3.])
+    
+    class grid:
+        "simulations will be done for points on this grid"
+        qaxis = sx.axis(min=-0.5, max=3., step=0.4)
+        Eaxis = sx.axis(min=5., max=31., step=5.)     
+           
+
+#
+#slices = [Slice_00L, Slice_H00, Slice_H01, Slice_H02, Slice_H03, Slice_H0H, Slice_0K1, Slice_mK2K2, Slice_mK2K3]
+slices = [Slice_00L]
+
+class res_2d_grid:
+    "resolution data will be histogrammed into this grid"
+    qaxis = sx.axis(min=-0.5, max=0.5, step=0.02)
+    Eaxis = sx.axis(min=-5., max=5., step=.2)
+
+class fitting:
+    rounds = 3
+    gaussian2d_threshold = 0.5
+    alpha_bounds = (-np.pi/2, np.pi/2)
+
+for sl in slices:
+    sl.res_2d_grid = res_2d_grid
+    sl.fitting = fitting
diff --git a/notebooks/singlextal/Mn3Si2Te6-SEQ/sample.yaml b/notebooks/singlextal/Mn3Si2Te6-SEQ/sample.yaml
new file mode 100644
index 0000000..3b20e1c
--- /dev/null
+++ b/notebooks/singlextal/Mn3Si2Te6-SEQ/sample.yaml
@@ -0,0 +1,15 @@
+name: Mn3Si2Te6
+chemical_formula: Mn3Si2Te6
+lattice: 
+ constants: 7.042, 7.042, 14.273, 90, 90, 120
+ basis_vectors:
+  - 7.042, 0, 0
+  - -3.521, 6.0985508934500166, 0
+  - 0, 0, 14.273
+excitations:
+ - type: DGSresolution
+orientation:
+ u: -0.1174936,0.20601821,-14.26685034
+ v: -5.63407729,-0.84153412,-0.01625055
+shape: cylinder radius="1*mm" height="6*mm"
+temperature: 300*K
\ No newline at end of file
diff --git a/tests/data b/tests/data
index ecf27aa..a84233e 160000
--- a/tests/data
+++ b/tests/data
@@ -1 +1 @@
-Subproject commit ecf27aac1fd3b7ba24996b1968e47121f98897fa
+Subproject commit a84233ed3696ab778d47d374b096a2fc664ecb0d
diff --git a/tests/singlextal/test_plot_ellipse.py b/tests/singlextal/test_plot_ellipse.py
new file mode 100755
index 0000000..7ab7f4a
--- /dev/null
+++ b/tests/singlextal/test_plot_ellipse.py
@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+#
+# Jiao Lin <jiao.lin@gmail.com>
+
+import os, glob, sys, contextlib
+
+from matplotlib import pyplot as plt
+import numpy as np
+
+import dgsres
+from dgsres.singlextal import plot as resplot, workflow, violini
+
+thisdir = os.path.abspath(os.path.dirname(__file__))
+
+def test_plot_ellipse():
+    # resolution simulation configuration
+    configdir = os.path.join(thisdir, '../../notebooks/singlextal/Mn3Si2Te6-SEQ')
+    # mcvine sim results for resolution
+    mcvinesim = os.path.join(thisdir, '../data/SEQUOIA_data/Mn3Si2Te6/mcvine-res-sim')
+    # workdir for this test
+    workdir = os.path.abspath("work.plotellipse")
+    if not os.path.exists(workdir):
+        os.makedirs(workdir)
+    copy_config_files(configdir, workdir)
+    with chdir(workdir):
+        # load config
+        import imp
+        config = imp.load_source('config', 'convolution_config.py')
+        # slice of interest
+        sl = config.rwc.slices[0]
+        print(sl)
+        # object for resolution data
+        class McvineResData(resplot.McvineResolutionData):
+            def path(self, q, E):
+                return os.path.join(self.parent_dir, config.rwc.simdir(q, E, sl))
+        mrd = McvineResData(mcvinesim, dirname_template=None)
+        # point of interest on the slice
+        q1, E1 = 3.1, 19.
+        # hkl of interest
+        hkl1 = sl.hkl0+sl.hkl_projection*q1
+        # point cloud of simulated resolution data
+        mcvine_pc1 = mrd.loadPointCloud(q1, E1)
+        # cov matrix of simulated resolution data
+        mcvine_cm1 = mrd.computeCovMat(q1, E1, dhkl_ranges=[(-0.2,0.2)]*3)
+        print(mcvine_cm1)
+        # we can obtain cov matrix from violini model too, but it will be less accurate
+        violini_model = workflow.create_violini_model(config.rwc, 0.01)
+        violini_cm1 = violini_model.computeCovMat(hkl1, E1)
+        print(violini_cm1)
+        # point cloud from violini cov mat
+        violini_pc1 = violini_model.computePointCloud(hkl1, E1)
+        # plotting
+        plot_qE_with_violini(mcvine_pc1, violini_cm1, 'res_qE_with_violini.png')
+        plot_q1q2_with_violini(mcvine_pc1, violini_cm1, 'res_q1q2_with_violini.png')
+
+def plot_qE_with_violini(mcvine_pc1, violini_cm1, outfile):
+    plt.figure(figsize=(10,4))
+    directions = [
+        ('h', [1,0,0]),
+        ('k', [0,1,0]),
+        ('l', [0,0,1]), 
+    ]
+    for i, direction in enumerate(directions):
+        name, vector = direction
+        axis1 = name, -0.5, 0.5, 0.002
+        axis2 = 'E', -5, 5., 0.02
+        otheraxes = [ (n, -0.015, 0.015) for n,v in directions if n !=name]
+
+        plt.subplot(1,3,i+1)
+        hg1, Eg1, I1 = mcvine_pc1.getThinSlice(axis1, axis2, *otheraxes)
+        plt.pcolormesh(hg1, Eg1, I1.T)
+        plt.ylim(-1.5,1.5)
+        plt.xlim(-.125, .125)
+        plt.xlabel(name)
+        plt.ylabel('E (meV)')
+        plt.clim(0, np.max(I1)/2)
+        resplot.plot_qE_ellipse(violini_cm1, vector, 'r') #, label='Violini')
+        # plt.legend()
+    plt.tight_layout()
+    plt.savefig(outfile)
+    print(f"made plot {outfile}")
+    plt.close()
+    return
+
+def plot_q1q2_with_violini(mcvine_pc1, violini_cm1, outfile):
+    plt.figure(figsize=(10,4))
+    directions = [
+        ('h', [1,0,0]),
+        ('k', [0,1,0]),
+        ('l', [0,0,1]), 
+    ]
+    for i, direction in enumerate(directions):
+        name, vector = direction
+        qs = [ q for n, q in directions if n != name ]
+        axes = [ (n, -0.5, 0.5, 0.002) for n,q in directions if n!=name ]
+        oaxis1 = name, -0.015, 0.015
+        oaxis2 = 'E', -0.2, 0.2
+        otheraxes = [ oaxis1, oaxis2 ]
+
+        plt.subplot(1,3,i+1)
+        hg1, Eg1, I1 = mcvine_pc1.getThinSlice(axes[0], axes[1], *otheraxes)
+        plt.pcolormesh(hg1, Eg1, I1.T)
+        plt.ylim(-.125, .125)
+        plt.xlim(-.125, .125)
+        plt.xlabel(f'${axes[0][0]}$')
+        plt.ylabel(f'${axes[1][0]}$')
+        plt.clim(0, np.max(I1)/2)
+        resplot.plot_qq_ellipse(violini_cm1, qs[0], qs[1], 'r')
+        # plt.legend()
+    plt.tight_layout()
+    plt.savefig(outfile)
+    print(f"made plot {outfile}")
+    plt.close()
+    return
+
+def copy_config_files(src, dest):
+    files = 'sample.yaml convolution_config.py resolution_workflow_config.py '.split()
+    import shutil
+    for f in files:
+        shutil.copyfile(os.path.join(src, f), os.path.join(dest, f))
+    return
+
+@contextlib.contextmanager
+def chdir(path):
+    """Sets the cwd within the context
+    """
+    origin = os.path.abspath(os.curdir)
+    try:
+        os.chdir(path)
+        yield
+    finally:
+        os.chdir(origin)
+
+def main():
+    test_plot_ellipse()
+
+if __name__ == '__main__': main()
+
+# End of file